diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 00000000..589d6d80 --- /dev/null +++ b/requirements.txt @@ -0,0 +1,4 @@ +pygame +vulkan +numpy +pyopengl \ No newline at end of file diff --git a/venv/bin/Activate.ps1 b/venv/bin/Activate.ps1 new file mode 100644 index 00000000..b49d77ba --- /dev/null +++ b/venv/bin/Activate.ps1 @@ -0,0 +1,247 @@ +<# +.Synopsis +Activate a Python virtual environment for the current PowerShell session. + +.Description +Pushes the python executable for a virtual environment to the front of the +$Env:PATH environment variable and sets the prompt to signify that you are +in a Python virtual environment. Makes use of the command line switches as +well as the `pyvenv.cfg` file values present in the virtual environment. + +.Parameter VenvDir +Path to the directory that contains the virtual environment to activate. The +default value for this is the parent of the directory that the Activate.ps1 +script is located within. + +.Parameter Prompt +The prompt prefix to display when this virtual environment is activated. By +default, this prompt is the name of the virtual environment folder (VenvDir) +surrounded by parentheses and followed by a single space (ie. '(.venv) '). + +.Example +Activate.ps1 +Activates the Python virtual environment that contains the Activate.ps1 script. + +.Example +Activate.ps1 -Verbose +Activates the Python virtual environment that contains the Activate.ps1 script, +and shows extra information about the activation as it executes. + +.Example +Activate.ps1 -VenvDir C:\Users\MyUser\Common\.venv +Activates the Python virtual environment located in the specified location. + +.Example +Activate.ps1 -Prompt "MyPython" +Activates the Python virtual environment that contains the Activate.ps1 script, +and prefixes the current prompt with the specified string (surrounded in +parentheses) while the virtual environment is active. + +.Notes +On Windows, it may be required to enable this Activate.ps1 script by setting the +execution policy for the user. You can do this by issuing the following PowerShell +command: + +PS C:\> Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser + +For more information on Execution Policies: +https://go.microsoft.com/fwlink/?LinkID=135170 + +#> +Param( + [Parameter(Mandatory = $false)] + [String] + $VenvDir, + [Parameter(Mandatory = $false)] + [String] + $Prompt +) + +<# Function declarations --------------------------------------------------- #> + +<# +.Synopsis +Remove all shell session elements added by the Activate script, including the +addition of the virtual environment's Python executable from the beginning of +the PATH variable. + +.Parameter NonDestructive +If present, do not remove this function from the global namespace for the +session. + +#> +function global:deactivate ([switch]$NonDestructive) { + # Revert to original values + + # The prior prompt: + if (Test-Path -Path Function:_OLD_VIRTUAL_PROMPT) { + Copy-Item -Path Function:_OLD_VIRTUAL_PROMPT -Destination Function:prompt + Remove-Item -Path Function:_OLD_VIRTUAL_PROMPT + } + + # The prior PYTHONHOME: + if (Test-Path -Path Env:_OLD_VIRTUAL_PYTHONHOME) { + Copy-Item -Path Env:_OLD_VIRTUAL_PYTHONHOME -Destination Env:PYTHONHOME + Remove-Item -Path Env:_OLD_VIRTUAL_PYTHONHOME + } + + # The prior PATH: + if (Test-Path -Path Env:_OLD_VIRTUAL_PATH) { + Copy-Item -Path Env:_OLD_VIRTUAL_PATH -Destination Env:PATH + Remove-Item -Path Env:_OLD_VIRTUAL_PATH + } + + # Just remove the VIRTUAL_ENV altogether: + if (Test-Path -Path Env:VIRTUAL_ENV) { + Remove-Item -Path env:VIRTUAL_ENV + } + + # Just remove VIRTUAL_ENV_PROMPT altogether. + if (Test-Path -Path Env:VIRTUAL_ENV_PROMPT) { + Remove-Item -Path env:VIRTUAL_ENV_PROMPT + } + + # Just remove the _PYTHON_VENV_PROMPT_PREFIX altogether: + if (Get-Variable -Name "_PYTHON_VENV_PROMPT_PREFIX" -ErrorAction SilentlyContinue) { + Remove-Variable -Name _PYTHON_VENV_PROMPT_PREFIX -Scope Global -Force + } + + # Leave deactivate function in the global namespace if requested: + if (-not $NonDestructive) { + Remove-Item -Path function:deactivate + } +} + +<# +.Description +Get-PyVenvConfig parses the values from the pyvenv.cfg file located in the +given folder, and returns them in a map. + +For each line in the pyvenv.cfg file, if that line can be parsed into exactly +two strings separated by `=` (with any amount of whitespace surrounding the =) +then it is considered a `key = value` line. The left hand string is the key, +the right hand is the value. + +If the value starts with a `'` or a `"` then the first and last character is +stripped from the value before being captured. + +.Parameter ConfigDir +Path to the directory that contains the `pyvenv.cfg` file. +#> +function Get-PyVenvConfig( + [String] + $ConfigDir +) { + Write-Verbose "Given ConfigDir=$ConfigDir, obtain values in pyvenv.cfg" + + # Ensure the file exists, and issue a warning if it doesn't (but still allow the function to continue). + $pyvenvConfigPath = Join-Path -Resolve -Path $ConfigDir -ChildPath 'pyvenv.cfg' -ErrorAction Continue + + # An empty map will be returned if no config file is found. + $pyvenvConfig = @{ } + + if ($pyvenvConfigPath) { + + Write-Verbose "File exists, parse `key = value` lines" + $pyvenvConfigContent = Get-Content -Path $pyvenvConfigPath + + $pyvenvConfigContent | ForEach-Object { + $keyval = $PSItem -split "\s*=\s*", 2 + if ($keyval[0] -and $keyval[1]) { + $val = $keyval[1] + + # Remove extraneous quotations around a string value. + if ("'""".Contains($val.Substring(0, 1))) { + $val = $val.Substring(1, $val.Length - 2) + } + + $pyvenvConfig[$keyval[0]] = $val + Write-Verbose "Adding Key: '$($keyval[0])'='$val'" + } + } + } + return $pyvenvConfig +} + + +<# Begin Activate script --------------------------------------------------- #> + +# Determine the containing directory of this script +$VenvExecPath = Split-Path -Parent $MyInvocation.MyCommand.Definition +$VenvExecDir = Get-Item -Path $VenvExecPath + +Write-Verbose "Activation script is located in path: '$VenvExecPath'" +Write-Verbose "VenvExecDir Fullname: '$($VenvExecDir.FullName)" +Write-Verbose "VenvExecDir Name: '$($VenvExecDir.Name)" + +# Set values required in priority: CmdLine, ConfigFile, Default +# First, get the location of the virtual environment, it might not be +# VenvExecDir if specified on the command line. +if ($VenvDir) { + Write-Verbose "VenvDir given as parameter, using '$VenvDir' to determine values" +} +else { + Write-Verbose "VenvDir not given as a parameter, using parent directory name as VenvDir." + $VenvDir = $VenvExecDir.Parent.FullName.TrimEnd("\\/") + Write-Verbose "VenvDir=$VenvDir" +} + +# Next, read the `pyvenv.cfg` file to determine any required value such +# as `prompt`. +$pyvenvCfg = Get-PyVenvConfig -ConfigDir $VenvDir + +# Next, set the prompt from the command line, or the config file, or +# just use the name of the virtual environment folder. +if ($Prompt) { + Write-Verbose "Prompt specified as argument, using '$Prompt'" +} +else { + Write-Verbose "Prompt not specified as argument to script, checking pyvenv.cfg value" + if ($pyvenvCfg -and $pyvenvCfg['prompt']) { + Write-Verbose " Setting based on value in pyvenv.cfg='$($pyvenvCfg['prompt'])'" + $Prompt = $pyvenvCfg['prompt']; + } + else { + Write-Verbose " Setting prompt based on parent's directory's name. (Is the directory name passed to venv module when creating the virtual environment)" + Write-Verbose " Got leaf-name of $VenvDir='$(Split-Path -Path $venvDir -Leaf)'" + $Prompt = Split-Path -Path $venvDir -Leaf + } +} + +Write-Verbose "Prompt = '$Prompt'" +Write-Verbose "VenvDir='$VenvDir'" + +# Deactivate any currently active virtual environment, but leave the +# deactivate function in place. +deactivate -nondestructive + +# Now set the environment variable VIRTUAL_ENV, used by many tools to determine +# that there is an activated venv. +$env:VIRTUAL_ENV = $VenvDir + +if (-not $Env:VIRTUAL_ENV_DISABLE_PROMPT) { + + Write-Verbose "Setting prompt to '$Prompt'" + + # Set the prompt to include the env name + # Make sure _OLD_VIRTUAL_PROMPT is global + function global:_OLD_VIRTUAL_PROMPT { "" } + Copy-Item -Path function:prompt -Destination function:_OLD_VIRTUAL_PROMPT + New-Variable -Name _PYTHON_VENV_PROMPT_PREFIX -Description "Python virtual environment prompt prefix" -Scope Global -Option ReadOnly -Visibility Public -Value $Prompt + + function global:prompt { + Write-Host -NoNewline -ForegroundColor Green "($_PYTHON_VENV_PROMPT_PREFIX) " + _OLD_VIRTUAL_PROMPT + } + $env:VIRTUAL_ENV_PROMPT = $Prompt +} + +# Clear PYTHONHOME +if (Test-Path -Path Env:PYTHONHOME) { + Copy-Item -Path Env:PYTHONHOME -Destination Env:_OLD_VIRTUAL_PYTHONHOME + Remove-Item -Path Env:PYTHONHOME +} + +# Add the venv to the PATH +Copy-Item -Path Env:PATH -Destination Env:_OLD_VIRTUAL_PATH +$Env:PATH = "$VenvExecDir$([System.IO.Path]::PathSeparator)$Env:PATH" diff --git a/venv/bin/activate b/venv/bin/activate new file mode 100644 index 00000000..2b769155 --- /dev/null +++ b/venv/bin/activate @@ -0,0 +1,70 @@ +# This file must be used with "source bin/activate" *from bash* +# You cannot run it directly + +deactivate () { + # reset old environment variables + if [ -n "${_OLD_VIRTUAL_PATH:-}" ] ; then + PATH="${_OLD_VIRTUAL_PATH:-}" + export PATH + unset _OLD_VIRTUAL_PATH + fi + if [ -n "${_OLD_VIRTUAL_PYTHONHOME:-}" ] ; then + PYTHONHOME="${_OLD_VIRTUAL_PYTHONHOME:-}" + export PYTHONHOME + unset _OLD_VIRTUAL_PYTHONHOME + fi + + # Call hash to forget past commands. Without forgetting + # past commands the $PATH changes we made may not be respected + hash -r 2> /dev/null + + if [ -n "${_OLD_VIRTUAL_PS1:-}" ] ; then + PS1="${_OLD_VIRTUAL_PS1:-}" + export PS1 + unset _OLD_VIRTUAL_PS1 + fi + + unset VIRTUAL_ENV + unset VIRTUAL_ENV_PROMPT + if [ ! "${1:-}" = "nondestructive" ] ; then + # Self destruct! + unset -f deactivate + fi +} + +# unset irrelevant variables +deactivate nondestructive + +# on Windows, a path can contain colons and backslashes and has to be converted: +if [ "${OSTYPE:-}" = "cygwin" ] || [ "${OSTYPE:-}" = "msys" ] ; then + # transform D:\path\to\venv to /d/path/to/venv on MSYS + # and to /cygdrive/d/path/to/venv on Cygwin + export VIRTUAL_ENV=$(cygpath "/Users/raymondlei/Documents/GitHub/Mini-Games/venv") +else + # use the path as-is + export VIRTUAL_ENV="/Users/raymondlei/Documents/GitHub/Mini-Games/venv" +fi + +_OLD_VIRTUAL_PATH="$PATH" +PATH="$VIRTUAL_ENV/bin:$PATH" +export PATH + +# unset PYTHONHOME if set +# this will fail if PYTHONHOME is set to the empty string (which is bad anyway) +# could use `if (set -u; : $PYTHONHOME) ;` in bash +if [ -n "${PYTHONHOME:-}" ] ; then + _OLD_VIRTUAL_PYTHONHOME="${PYTHONHOME:-}" + unset PYTHONHOME +fi + +if [ -z "${VIRTUAL_ENV_DISABLE_PROMPT:-}" ] ; then + _OLD_VIRTUAL_PS1="${PS1:-}" + PS1="(venv) ${PS1:-}" + export PS1 + VIRTUAL_ENV_PROMPT="(venv) " + export VIRTUAL_ENV_PROMPT +fi + +# Call hash to forget past commands. Without forgetting +# past commands the $PATH changes we made may not be respected +hash -r 2> /dev/null diff --git a/venv/bin/activate.csh b/venv/bin/activate.csh new file mode 100644 index 00000000..d7a090ed --- /dev/null +++ b/venv/bin/activate.csh @@ -0,0 +1,27 @@ +# This file must be used with "source bin/activate.csh" *from csh*. +# You cannot run it directly. + +# Created by Davide Di Blasi . +# Ported to Python 3.3 venv by Andrew Svetlov + +alias deactivate 'test $?_OLD_VIRTUAL_PATH != 0 && setenv PATH "$_OLD_VIRTUAL_PATH" && unset _OLD_VIRTUAL_PATH; rehash; test $?_OLD_VIRTUAL_PROMPT != 0 && set prompt="$_OLD_VIRTUAL_PROMPT" && unset _OLD_VIRTUAL_PROMPT; unsetenv VIRTUAL_ENV; unsetenv VIRTUAL_ENV_PROMPT; test "\!:*" != "nondestructive" && unalias deactivate' + +# Unset irrelevant variables. +deactivate nondestructive + +setenv VIRTUAL_ENV "/Users/raymondlei/Documents/GitHub/Mini-Games/venv" + +set _OLD_VIRTUAL_PATH="$PATH" +setenv PATH "$VIRTUAL_ENV/bin:$PATH" + + +set _OLD_VIRTUAL_PROMPT="$prompt" + +if (! "$?VIRTUAL_ENV_DISABLE_PROMPT") then + set prompt = "(venv) $prompt" + setenv VIRTUAL_ENV_PROMPT "(venv) " +endif + +alias pydoc python -m pydoc + +rehash diff --git a/venv/bin/activate.fish b/venv/bin/activate.fish new file mode 100644 index 00000000..9b5666c2 --- /dev/null +++ b/venv/bin/activate.fish @@ -0,0 +1,69 @@ +# This file must be used with "source /bin/activate.fish" *from fish* +# (https://fishshell.com/). You cannot run it directly. + +function deactivate -d "Exit virtual environment and return to normal shell environment" + # reset old environment variables + if test -n "$_OLD_VIRTUAL_PATH" + set -gx PATH $_OLD_VIRTUAL_PATH + set -e _OLD_VIRTUAL_PATH + end + if test -n "$_OLD_VIRTUAL_PYTHONHOME" + set -gx PYTHONHOME $_OLD_VIRTUAL_PYTHONHOME + set -e _OLD_VIRTUAL_PYTHONHOME + end + + if test -n "$_OLD_FISH_PROMPT_OVERRIDE" + set -e _OLD_FISH_PROMPT_OVERRIDE + # prevents error when using nested fish instances (Issue #93858) + if functions -q _old_fish_prompt + functions -e fish_prompt + functions -c _old_fish_prompt fish_prompt + functions -e _old_fish_prompt + end + end + + set -e VIRTUAL_ENV + set -e VIRTUAL_ENV_PROMPT + if test "$argv[1]" != "nondestructive" + # Self-destruct! + functions -e deactivate + end +end + +# Unset irrelevant variables. +deactivate nondestructive + +set -gx VIRTUAL_ENV "/Users/raymondlei/Documents/GitHub/Mini-Games/venv" + +set -gx _OLD_VIRTUAL_PATH $PATH +set -gx PATH "$VIRTUAL_ENV/bin" $PATH + +# Unset PYTHONHOME if set. +if set -q PYTHONHOME + set -gx _OLD_VIRTUAL_PYTHONHOME $PYTHONHOME + set -e PYTHONHOME +end + +if test -z "$VIRTUAL_ENV_DISABLE_PROMPT" + # fish uses a function instead of an env var to generate the prompt. + + # Save the current fish_prompt function as the function _old_fish_prompt. + functions -c fish_prompt _old_fish_prompt + + # With the original prompt function renamed, we can override with our own. + function fish_prompt + # Save the return status of the last command. + set -l old_status $status + + # Output the venv prompt; color taken from the blue of the Python logo. + printf "%s%s%s" (set_color 4B8BBE) "(venv) " (set_color normal) + + # Restore the return status of the previous command. + echo "exit $old_status" | . + # Output the original/"old" prompt. + _old_fish_prompt + end + + set -gx _OLD_FISH_PROMPT_OVERRIDE "$VIRTUAL_ENV" + set -gx VIRTUAL_ENV_PROMPT "(venv) " +end diff --git a/venv/bin/f2py b/venv/bin/f2py new file mode 100755 index 00000000..2fa07d6c --- /dev/null +++ b/venv/bin/f2py @@ -0,0 +1,8 @@ +#!/Users/raymondlei/Documents/GitHub/Mini-Games/venv/bin/python3.12 +# -*- coding: utf-8 -*- +import re +import sys +from numpy.f2py.f2py2e import main +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) + sys.exit(main()) diff --git a/venv/bin/numpy-config b/venv/bin/numpy-config new file mode 100755 index 00000000..c904ea64 --- /dev/null +++ b/venv/bin/numpy-config @@ -0,0 +1,8 @@ +#!/Users/raymondlei/Documents/GitHub/Mini-Games/venv/bin/python3.12 +# -*- coding: utf-8 -*- +import re +import sys +from numpy._configtool import main +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) + sys.exit(main()) diff --git a/venv/bin/pip b/venv/bin/pip new file mode 100755 index 00000000..66b8d104 --- /dev/null +++ b/venv/bin/pip @@ -0,0 +1,8 @@ +#!/Users/raymondlei/Documents/GitHub/Mini-Games/venv/bin/python3.12 +# -*- coding: utf-8 -*- +import re +import sys +from pip._internal.cli.main import main +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) + sys.exit(main()) diff --git a/venv/bin/pip3 b/venv/bin/pip3 new file mode 100755 index 00000000..66b8d104 --- /dev/null +++ b/venv/bin/pip3 @@ -0,0 +1,8 @@ +#!/Users/raymondlei/Documents/GitHub/Mini-Games/venv/bin/python3.12 +# -*- coding: utf-8 -*- +import re +import sys +from pip._internal.cli.main import main +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) + sys.exit(main()) diff --git a/venv/bin/pip3.12 b/venv/bin/pip3.12 new file mode 100755 index 00000000..66b8d104 --- /dev/null +++ b/venv/bin/pip3.12 @@ -0,0 +1,8 @@ +#!/Users/raymondlei/Documents/GitHub/Mini-Games/venv/bin/python3.12 +# -*- coding: utf-8 -*- +import re +import sys +from pip._internal.cli.main import main +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) + sys.exit(main()) diff --git a/venv/bin/python b/venv/bin/python new file mode 120000 index 00000000..11b9d885 --- /dev/null +++ b/venv/bin/python @@ -0,0 +1 @@ +python3.12 \ No newline at end of file diff --git a/venv/bin/python3 b/venv/bin/python3 new file mode 120000 index 00000000..11b9d885 --- /dev/null +++ b/venv/bin/python3 @@ -0,0 +1 @@ +python3.12 \ No newline at end of file diff --git a/venv/bin/python3.12 b/venv/bin/python3.12 new file mode 120000 index 00000000..a3f05084 --- /dev/null +++ b/venv/bin/python3.12 @@ -0,0 +1 @@ +/opt/homebrew/opt/python@3.12/bin/python3.12 \ No newline at end of file diff --git a/venv/include/site/python3.12/pygame/_blit_info.h b/venv/include/site/python3.12/pygame/_blit_info.h new file mode 100644 index 00000000..5320d0b1 --- /dev/null +++ b/venv/include/site/python3.12/pygame/_blit_info.h @@ -0,0 +1,21 @@ +#define NO_PYGAME_C_API +#include "_surface.h" + +/* The structure passed to the low level blit functions */ +typedef struct { + int width; + int height; + Uint8 *s_pixels; + int s_pxskip; + int s_skip; + Uint8 *d_pixels; + int d_pxskip; + int d_skip; + SDL_PixelFormat *src; + SDL_PixelFormat *dst; + Uint8 src_blanket_alpha; + int src_has_colorkey; + Uint32 src_colorkey; + SDL_BlendMode src_blend; + SDL_BlendMode dst_blend; +} SDL_BlitInfo; diff --git a/venv/include/site/python3.12/pygame/_camera.h b/venv/include/site/python3.12/pygame/_camera.h new file mode 100644 index 00000000..075ef6fb --- /dev/null +++ b/venv/include/site/python3.12/pygame/_camera.h @@ -0,0 +1,26 @@ +/* + pygame - Python Game Library + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public + License along with this library; if not, write to the Free + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + +*/ + +#ifndef _CAMERA_H +#define _CAMERA_H + +#include "_pygame.h" +#include "camera.h" + +#endif diff --git a/venv/include/site/python3.12/pygame/_pygame.h b/venv/include/site/python3.12/pygame/_pygame.h new file mode 100644 index 00000000..e3521b33 --- /dev/null +++ b/venv/include/site/python3.12/pygame/_pygame.h @@ -0,0 +1,374 @@ +/* + pygame - Python Game Library + Copyright (C) 2000-2001 Pete Shinners + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public + License along with this library; if not, write to the Free + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + + Pete Shinners + pete@shinners.org +*/ + +/* This will use PYGAMEAPI_EXTERN_SLOTS instead + * of PYGAMEAPI_DEFINE_SLOTS for base modules. + */ +#ifndef _PYGAME_INTERNAL_H +#define _PYGAME_INTERNAL_H + +#include "pgplatform.h" +/* + If PY_SSIZE_T_CLEAN is defined before including Python.h, length is a + Py_ssize_t rather than an int for all # variants of formats (s#, y#, etc.) +*/ +#define PY_SSIZE_T_CLEAN +#include + +/* Ensure PyPy-specific code is not in use when running on GraalPython (PR + * #2580) */ +#if defined(GRAALVM_PYTHON) && defined(PYPY_VERSION) +#undef PYPY_VERSION +#endif + +#include + +/* SDL 1.2 constants removed from SDL 2 */ +typedef enum { + SDL_HWSURFACE = 0, + SDL_RESIZABLE = SDL_WINDOW_RESIZABLE, + SDL_ASYNCBLIT = 0, + SDL_OPENGL = SDL_WINDOW_OPENGL, + SDL_OPENGLBLIT = 0, + SDL_ANYFORMAT = 0, + SDL_HWPALETTE = 0, + SDL_DOUBLEBUF = 0, + SDL_FULLSCREEN = SDL_WINDOW_FULLSCREEN, + SDL_HWACCEL = 0, + SDL_SRCCOLORKEY = 0, + SDL_RLEACCELOK = 0, + SDL_SRCALPHA = 0, + SDL_NOFRAME = SDL_WINDOW_BORDERLESS, + SDL_GL_SWAP_CONTROL = 0, + TIMER_RESOLUTION = 0 +} PygameVideoFlags; + +/* the wheel button constants were removed from SDL 2 */ +typedef enum { + PGM_BUTTON_LEFT = SDL_BUTTON_LEFT, + PGM_BUTTON_RIGHT = SDL_BUTTON_RIGHT, + PGM_BUTTON_MIDDLE = SDL_BUTTON_MIDDLE, + PGM_BUTTON_WHEELUP = 4, + PGM_BUTTON_WHEELDOWN = 5, + PGM_BUTTON_X1 = SDL_BUTTON_X1 + 2, + PGM_BUTTON_X2 = SDL_BUTTON_X2 + 2, + PGM_BUTTON_KEEP = 0x80 +} PygameMouseFlags; + +typedef enum { + /* Any SDL_* events here are for backward compatibility. */ + SDL_NOEVENT = 0, + + SDL_ACTIVEEVENT = SDL_USEREVENT, + SDL_VIDEORESIZE, + SDL_VIDEOEXPOSE, + + PGE_MIDIIN, + PGE_MIDIOUT, + PGE_KEYREPEAT, /* Special internal pygame event, for managing key-presses + */ + + /* DO NOT CHANGE THE ORDER OF EVENTS HERE */ + PGE_WINDOWSHOWN, + PGE_WINDOWHIDDEN, + PGE_WINDOWEXPOSED, + PGE_WINDOWMOVED, + PGE_WINDOWRESIZED, + PGE_WINDOWSIZECHANGED, + PGE_WINDOWMINIMIZED, + PGE_WINDOWMAXIMIZED, + PGE_WINDOWRESTORED, + PGE_WINDOWENTER, + PGE_WINDOWLEAVE, + PGE_WINDOWFOCUSGAINED, + PGE_WINDOWFOCUSLOST, + PGE_WINDOWCLOSE, + PGE_WINDOWTAKEFOCUS, + PGE_WINDOWHITTEST, + PGE_WINDOWICCPROFCHANGED, + PGE_WINDOWDISPLAYCHANGED, + + /* Here we define PGPOST_* events, events that act as a one-to-one + * proxy for SDL events (and some extra events too!), the proxy is used + * internally when pygame users use event.post() + * + * At a first glance, these may look redundant, but they are really + * important, especially with event blocking. If proxy events are + * not there, blocked events dont make it to our event filter, and + * that can break a lot of stuff. + * + * IMPORTANT NOTE: Do not post events directly with these proxy types, + * use the appropriate functions from event.c, that handle these proxy + * events for you. + * Proxy events are for internal use only */ + PGPOST_EVENTBEGIN, /* mark start of proxy-events */ + PGPOST_ACTIVEEVENT = PGPOST_EVENTBEGIN, + PGPOST_APP_TERMINATING, + PGPOST_APP_LOWMEMORY, + PGPOST_APP_WILLENTERBACKGROUND, + PGPOST_APP_DIDENTERBACKGROUND, + PGPOST_APP_WILLENTERFOREGROUND, + PGPOST_APP_DIDENTERFOREGROUND, + PGPOST_AUDIODEVICEADDED, + PGPOST_AUDIODEVICEREMOVED, + PGPOST_CLIPBOARDUPDATE, + PGPOST_CONTROLLERAXISMOTION, + PGPOST_CONTROLLERBUTTONDOWN, + PGPOST_CONTROLLERBUTTONUP, + PGPOST_CONTROLLERDEVICEADDED, + PGPOST_CONTROLLERDEVICEREMOVED, + PGPOST_CONTROLLERDEVICEREMAPPED, + PGPOST_CONTROLLERTOUCHPADDOWN, + PGPOST_CONTROLLERTOUCHPADMOTION, + PGPOST_CONTROLLERTOUCHPADUP, + PGPOST_CONTROLLERSENSORUPDATE, + PGPOST_DOLLARGESTURE, + PGPOST_DOLLARRECORD, + PGPOST_DROPFILE, + PGPOST_DROPTEXT, + PGPOST_DROPBEGIN, + PGPOST_DROPCOMPLETE, + PGPOST_FINGERMOTION, + PGPOST_FINGERDOWN, + PGPOST_FINGERUP, + PGPOST_KEYDOWN, + PGPOST_KEYMAPCHANGED, + PGPOST_KEYUP, + PGPOST_JOYAXISMOTION, + PGPOST_JOYBALLMOTION, + PGPOST_JOYHATMOTION, + PGPOST_JOYBUTTONDOWN, + PGPOST_JOYBUTTONUP, + PGPOST_JOYDEVICEADDED, + PGPOST_JOYDEVICEREMOVED, + PGPOST_LOCALECHANGED, + PGPOST_MIDIIN, + PGPOST_MIDIOUT, + PGPOST_MOUSEMOTION, + PGPOST_MOUSEBUTTONDOWN, + PGPOST_MOUSEBUTTONUP, + PGPOST_MOUSEWHEEL, + PGPOST_MULTIGESTURE, + PGPOST_NOEVENT, + PGPOST_QUIT, + PGPOST_RENDER_TARGETS_RESET, + PGPOST_RENDER_DEVICE_RESET, + PGPOST_SYSWMEVENT, + PGPOST_TEXTEDITING, + PGPOST_TEXTINPUT, + PGPOST_VIDEORESIZE, + PGPOST_VIDEOEXPOSE, + PGPOST_WINDOWSHOWN, + PGPOST_WINDOWHIDDEN, + PGPOST_WINDOWEXPOSED, + PGPOST_WINDOWMOVED, + PGPOST_WINDOWRESIZED, + PGPOST_WINDOWSIZECHANGED, + PGPOST_WINDOWMINIMIZED, + PGPOST_WINDOWMAXIMIZED, + PGPOST_WINDOWRESTORED, + PGPOST_WINDOWENTER, + PGPOST_WINDOWLEAVE, + PGPOST_WINDOWFOCUSGAINED, + PGPOST_WINDOWFOCUSLOST, + PGPOST_WINDOWCLOSE, + PGPOST_WINDOWTAKEFOCUS, + PGPOST_WINDOWHITTEST, + PGPOST_WINDOWICCPROFCHANGED, + PGPOST_WINDOWDISPLAYCHANGED, + + PGE_USEREVENT, /* this event must stay in this position only */ + + PG_NUMEVENTS = + SDL_LASTEVENT /* Not an event. Indicates end of user events. */ +} PygameEventCode; + +/* SDL1 ACTIVEEVENT state attribute can take the following values */ +/* These constant values are directly picked from SDL1 source */ +#define SDL_APPMOUSEFOCUS 0x01 +#define SDL_APPINPUTFOCUS 0x02 +#define SDL_APPACTIVE 0x04 + +/* Surface flags: based on SDL 1.2 flags */ +typedef enum { + PGS_SWSURFACE = 0x00000000, + PGS_HWSURFACE = 0x00000001, + PGS_ASYNCBLIT = 0x00000004, + + PGS_ANYFORMAT = 0x10000000, + PGS_HWPALETTE = 0x20000000, + PGS_DOUBLEBUF = 0x40000000, + PGS_FULLSCREEN = 0x80000000, + PGS_SCALED = 0x00000200, + + PGS_OPENGL = 0x00000002, + PGS_OPENGLBLIT = 0x0000000A, + PGS_RESIZABLE = 0x00000010, + PGS_NOFRAME = 0x00000020, + PGS_SHOWN = 0x00000040, /* Added from SDL 2 */ + PGS_HIDDEN = 0x00000080, /* Added from SDL 2 */ + + PGS_HWACCEL = 0x00000100, + PGS_SRCCOLORKEY = 0x00001000, + PGS_RLEACCELOK = 0x00002000, + PGS_RLEACCEL = 0x00004000, + PGS_SRCALPHA = 0x00010000, + PGS_PREALLOC = 0x01000000 +} PygameSurfaceFlags; + +// TODO Implement check below in a way that does not break CI +/* New buffer protocol (PEP 3118) implemented on all supported Py versions. +#if !defined(Py_TPFLAGS_HAVE_NEWBUFFER) +#error No support for PEP 3118/Py_TPFLAGS_HAVE_NEWBUFFER. Please use a +supported Python version. #endif */ + +#define RAISE(x, y) (PyErr_SetString((x), (y)), NULL) +#define DEL_ATTR_NOT_SUPPORTED_CHECK(name, value) \ + do { \ + if (!value) { \ + PyErr_Format(PyExc_AttributeError, "Cannot delete attribute %s", \ + name); \ + return -1; \ + } \ + } while (0) + +#define DEL_ATTR_NOT_SUPPORTED_CHECK_NO_NAME(value) \ + do { \ + if (!value) { \ + PyErr_SetString(PyExc_AttributeError, "Cannot delete attribute"); \ + return -1; \ + } \ + } while (0) + +/* + * Initialization checks + */ + +#define VIDEO_INIT_CHECK() \ + if (!SDL_WasInit(SDL_INIT_VIDEO)) \ + return RAISE(pgExc_SDLError, "video system not initialized") + +#define JOYSTICK_INIT_CHECK() \ + if (!SDL_WasInit(SDL_INIT_JOYSTICK)) \ + return RAISE(pgExc_SDLError, "joystick system not initialized") + +/* thread check */ +#ifdef WITH_THREAD +#define PG_CHECK_THREADS() (1) +#else /* ~WITH_THREAD */ +#define PG_CHECK_THREADS() \ + (RAISE(PyExc_NotImplementedError, "Python built without thread support")) +#endif /* ~WITH_THREAD */ + +#define PyType_Init(x) (((x).ob_type) = &PyType_Type) + +/* CPython 3.6 had initial and undocumented FASTCALL support, but we play it + * safe by not relying on implementation details */ +#if PY_VERSION_HEX < 0x03070000 + +/* Macro for naming a pygame fastcall wrapper function */ +#define PG_FASTCALL_NAME(func) _##func##_fastcall_wrap + +/* used to forward declare compat functions */ +#define PG_DECLARE_FASTCALL_FUNC(func, self_type) \ + static PyObject *PG_FASTCALL_NAME(func)(self_type * self, PyObject * args) + +/* Using this macro on a function defined with the FASTCALL calling convention + * adds a wrapper definition that uses regular python VARARGS convention. + * Since it is guaranteed that the 'args' object is a tuple, we can directly + * call PySequence_Fast_ITEMS and PyTuple_GET_SIZE on it (which are macros that + * assume the same, and don't do error checking) */ +#define PG_WRAP_FASTCALL_FUNC(func, self_type) \ + PG_DECLARE_FASTCALL_FUNC(func, self_type) \ + { \ + return func(self, (PyObject *const *)PySequence_Fast_ITEMS(args), \ + PyTuple_GET_SIZE(args)); \ + } + +#define PG_FASTCALL METH_VARARGS + +#else /* PY_VERSION_HEX >= 0x03070000 */ +/* compat macros are no-op on python versions that support fastcall */ +#define PG_FASTCALL_NAME(func) func +#define PG_DECLARE_FASTCALL_FUNC(func, self_type) +#define PG_WRAP_FASTCALL_FUNC(func, self_type) + +#define PG_FASTCALL METH_FASTCALL + +#endif /* PY_VERSION_HEX >= 0x03070000 */ + +/* + * event module internals + */ +struct pgEventObject { + PyObject_HEAD int type; + PyObject *dict; +}; + +/* + * surflock module internals + */ +typedef struct { + PyObject_HEAD PyObject *surface; + PyObject *lockobj; + PyObject *weakrefs; +} pgLifetimeLockObject; + +/* + * surface module internals + */ +struct pgSubSurface_Data { + PyObject *owner; + int pixeloffset; + int offsetx, offsety; +}; + +/* + * color module internals + */ +struct pgColorObject { + PyObject_HEAD Uint8 data[4]; + Uint8 len; +}; + +/* + * include public API + */ +#include "include/_pygame.h" + +/* Slot counts. + * Remember to keep these constants up to date. + */ + +#define PYGAMEAPI_RECT_NUMSLOTS 5 +#define PYGAMEAPI_JOYSTICK_NUMSLOTS 2 +#define PYGAMEAPI_DISPLAY_NUMSLOTS 2 +#define PYGAMEAPI_SURFACE_NUMSLOTS 4 +#define PYGAMEAPI_SURFLOCK_NUMSLOTS 8 +#define PYGAMEAPI_RWOBJECT_NUMSLOTS 6 +#define PYGAMEAPI_PIXELARRAY_NUMSLOTS 2 +#define PYGAMEAPI_COLOR_NUMSLOTS 5 +#define PYGAMEAPI_MATH_NUMSLOTS 2 +#define PYGAMEAPI_BASE_NUMSLOTS 27 +#define PYGAMEAPI_EVENT_NUMSLOTS 6 + +#endif /* _PYGAME_INTERNAL_H */ diff --git a/venv/include/site/python3.12/pygame/_surface.h b/venv/include/site/python3.12/pygame/_surface.h new file mode 100644 index 00000000..b2b4644a --- /dev/null +++ b/venv/include/site/python3.12/pygame/_surface.h @@ -0,0 +1,30 @@ +/* + pygame - Python Game Library + Copyright (C) 2000-2001 Pete Shinners + Copyright (C) 2007 Marcus von Appen + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public + License along with this library; if not, write to the Free + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + + Pete Shinners + pete@shinners.org +*/ + +#ifndef _SURFACE_H +#define _SURFACE_H + +#include "_pygame.h" +#include "surface.h" + +#endif diff --git a/venv/include/site/python3.12/pygame/camera.h b/venv/include/site/python3.12/pygame/camera.h new file mode 100644 index 00000000..f170b7d9 --- /dev/null +++ b/venv/include/site/python3.12/pygame/camera.h @@ -0,0 +1,218 @@ +#ifndef CAMERA_H +#define CAMERA_H +/* + pygame - Python Game Library + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public + License along with this library; if not, write to the Free + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + +*/ + +#include "pygame.h" +#include "pgcompat.h" +#include "doc/camera_doc.h" + +#if defined(__unix__) +#include +#include +#include +#include +#include + +#include /* low-level i/o */ +#include +#include +#include +#include +#include +#include +#include + +/* on freebsd there is no asm/types */ +#ifdef __linux__ +#include /* for videodev2.h */ +#include +#endif + +/* on openbsd and netbsd we need to include videoio.h */ +#if defined(__OpenBSD__) || defined(__NetBSD__) +#include +#endif + +#ifdef __FreeBSD__ +#include +#endif + +#endif /* defined(__unix__) */ + +#if defined(__WIN32__) + +#ifdef __MINGW32__ +#undef WINVER +/** _WIN32_WINNT_WINBLUE sets minimum platform SDK to Windows 8.1. */ +#define WINVER _WIN32_WINNT_WINBLUE +#endif + +#include +#include +#include +#include +#include +#include +#endif + +/* some constants used which are not defined on non-v4l machines. */ +#ifndef V4L2_PIX_FMT_RGB24 +#define V4L2_PIX_FMT_RGB24 'RGB3' +#endif +#ifndef V4L2_PIX_FMT_RGB444 +#define V4L2_PIX_FMT_RGB444 'R444' +#endif +#ifndef V4L2_PIX_FMT_YUYV +#define V4L2_PIX_FMT_YUYV 'YUYV' +#endif +#ifndef V4L2_PIX_FMT_XBGR32 +#define V4L2_PIX_FMT_XBGR32 'XR24' +#endif + +#define CLEAR(x) memset(&(x), 0, sizeof(x)) +#define SAT(c) \ + if (c & (~255)) { \ + if (c < 0) \ + c = 0; \ + else \ + c = 255; \ + } +#define SAT2(c) ((c) & (~255) ? ((c) < 0 ? 0 : 255) : (c)) +#define DEFAULT_WIDTH 640 +#define DEFAULT_HEIGHT 480 +#define RGB_OUT 1 +#define YUV_OUT 2 +#define HSV_OUT 4 +#define CAM_V4L \ + 1 /* deprecated. the incomplete support in pygame was removed */ +#define CAM_V4L2 2 + +struct buffer { + void *start; + size_t length; +}; + +#if defined(__unix__) +typedef struct pgCameraObject { + PyObject_HEAD char *device_name; + int camera_type; + unsigned long pixelformat; + unsigned int color_out; + struct buffer *buffers; + unsigned int n_buffers; + int width; + int height; + int size; + int hflip; + int vflip; + int brightness; + int fd; +} pgCameraObject; +#else +/* generic definition. + */ + +typedef struct pgCameraObject { + PyObject_HEAD char *device_name; + int camera_type; + unsigned long pixelformat; + unsigned int color_out; + struct buffer *buffers; + unsigned int n_buffers; + int width; + int height; + int size; + int hflip; + int vflip; + int brightness; + int fd; +} pgCameraObject; +#endif + +/* internal functions for colorspace conversion */ +void +colorspace(SDL_Surface *src, SDL_Surface *dst, int cspace); +void +rgb24_to_rgb(const void *src, void *dst, int length, SDL_PixelFormat *format); +void +bgr32_to_rgb(const void *src, void *dst, int length, SDL_PixelFormat *format); +void +rgb444_to_rgb(const void *src, void *dst, int length, SDL_PixelFormat *format); +void +rgb_to_yuv(const void *src, void *dst, int length, unsigned long source, + SDL_PixelFormat *format); +void +rgb_to_hsv(const void *src, void *dst, int length, unsigned long source, + SDL_PixelFormat *format); +void +yuyv_to_rgb(const void *src, void *dst, int length, SDL_PixelFormat *format); +void +yuyv_to_yuv(const void *src, void *dst, int length, SDL_PixelFormat *format); +void +uyvy_to_rgb(const void *src, void *dst, int length, SDL_PixelFormat *format); +void +uyvy_to_yuv(const void *src, void *dst, int length, SDL_PixelFormat *format); +void +sbggr8_to_rgb(const void *src, void *dst, int width, int height, + SDL_PixelFormat *format); +void +yuv420_to_rgb(const void *src, void *dst, int width, int height, + SDL_PixelFormat *format); +void +yuv420_to_yuv(const void *src, void *dst, int width, int height, + SDL_PixelFormat *format); + +#if defined(__unix__) +/* internal functions specific to v4l2 */ +char ** +v4l2_list_cameras(int *num_devices); +int +v4l2_get_control(int fd, int id, int *value); +int +v4l2_set_control(int fd, int id, int value); +PyObject * +v4l2_read_raw(pgCameraObject *self); +int +v4l2_xioctl(int fd, int request, void *arg); +int +v4l2_process_image(pgCameraObject *self, const void *image, int buffer_size, + SDL_Surface *surf); +int +v4l2_query_buffer(pgCameraObject *self); +int +v4l2_read_frame(pgCameraObject *self, SDL_Surface *surf, int *errno_code); +int +v4l2_stop_capturing(pgCameraObject *self); +int +v4l2_start_capturing(pgCameraObject *self); +int +v4l2_uninit_device(pgCameraObject *self); +int +v4l2_init_mmap(pgCameraObject *self); +int +v4l2_init_device(pgCameraObject *self); +int +v4l2_close_device(pgCameraObject *self); +int +v4l2_open_device(pgCameraObject *self); + +#endif + +#endif /* !CAMERA_H */ diff --git a/venv/include/site/python3.12/pygame/font.h b/venv/include/site/python3.12/pygame/font.h new file mode 100644 index 00000000..f5eedb25 --- /dev/null +++ b/venv/include/site/python3.12/pygame/font.h @@ -0,0 +1,15 @@ +#ifndef PGFONT_INTERNAL_H +#define PGFONT_INTERNAL_H + +#include + +/* test font initialization */ +#define FONT_INIT_CHECK() \ + if (!(*(int *)PyFONT_C_API[2])) \ + return RAISE(pgExc_SDLError, "font system not initialized") + +#include "include/pygame_font.h" + +#define PYGAMEAPI_FONT_NUMSLOTS 3 + +#endif /* ~PGFONT_INTERNAL_H */ diff --git a/venv/include/site/python3.12/pygame/freetype.h b/venv/include/site/python3.12/pygame/freetype.h new file mode 100644 index 00000000..fd86bc21 --- /dev/null +++ b/venv/include/site/python3.12/pygame/freetype.h @@ -0,0 +1,114 @@ +/* + pygame - Python Game Library + Copyright (C) 2009 Vicent Marti + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public + License along with this library; if not, write to the Free + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + +*/ +#ifndef _PYGAME_FREETYPE_INTERNAL_H_ +#define _PYGAME_FREETYPE_INTERNAL_H_ + +#include "pgcompat.h" +#include "pgplatform.h" + +#include +#include FT_FREETYPE_H +#include FT_CACHE_H +#include FT_XFREE86_H +#include FT_TRIGONOMETRY_H + +/********************************************************** + * Global module constants + **********************************************************/ + +/* Render styles */ +#define FT_STYLE_NORMAL 0x00 +#define FT_STYLE_STRONG 0x01 +#define FT_STYLE_OBLIQUE 0x02 +#define FT_STYLE_UNDERLINE 0x04 +#define FT_STYLE_WIDE 0x08 +#define FT_STYLE_DEFAULT 0xFF + +/* Bounding box modes */ +#define FT_BBOX_EXACT FT_GLYPH_BBOX_SUBPIXELS +#define FT_BBOX_EXACT_GRIDFIT FT_GLYPH_BBOX_GRIDFIT +#define FT_BBOX_PIXEL FT_GLYPH_BBOX_TRUNCATE +#define FT_BBOX_PIXEL_GRIDFIT FT_GLYPH_BBOX_PIXELS + +/* Rendering flags */ +#define FT_RFLAG_NONE (0) +#define FT_RFLAG_ANTIALIAS (1 << 0) +#define FT_RFLAG_AUTOHINT (1 << 1) +#define FT_RFLAG_VERTICAL (1 << 2) +#define FT_RFLAG_HINTED (1 << 3) +#define FT_RFLAG_KERNING (1 << 4) +#define FT_RFLAG_TRANSFORM (1 << 5) +#define FT_RFLAG_PAD (1 << 6) +#define FT_RFLAG_ORIGIN (1 << 7) +#define FT_RFLAG_UCS4 (1 << 8) +#define FT_RFLAG_USE_BITMAP_STRIKES (1 << 9) +#define FT_RFLAG_DEFAULTS \ + (FT_RFLAG_HINTED | FT_RFLAG_USE_BITMAP_STRIKES | FT_RFLAG_ANTIALIAS) + +#define FT_RENDER_NEWBYTEARRAY 0x0 +#define FT_RENDER_NEWSURFACE 0x1 +#define FT_RENDER_EXISTINGSURFACE 0x2 + +/********************************************************** + * Global module types + **********************************************************/ + +typedef struct _scale_s { + FT_UInt x, y; +} Scale_t; +typedef FT_Angle Angle_t; + +struct fontinternals_; +struct freetypeinstance_; + +typedef struct { + FT_Long font_index; + FT_Open_Args open_args; +} pgFontId; + +typedef struct { + PyObject_HEAD pgFontId id; + PyObject *path; + int is_scalable; + int is_bg_col_set; + + Scale_t face_size; + FT_Int16 style; + FT_Int16 render_flags; + double strength; + double underline_adjustment; + FT_UInt resolution; + Angle_t rotation; + FT_Matrix transform; + FT_Byte fgcolor[4]; + FT_Byte bgcolor[4]; + + struct freetypeinstance_ *freetype; /* Personal reference */ + struct fontinternals_ *_internals; +} pgFontObject; + +#define pgFont_IS_ALIVE(o) (((pgFontObject *)(o))->_internals != 0) + +/* import public API */ +#include "include/pygame_freetype.h" + +#define PYGAMEAPI_FREETYPE_NUMSLOTS 2 + +#endif /* ~_PYGAME_FREETYPE_INTERNAL_H_ */ diff --git a/venv/include/site/python3.12/pygame/include/_pygame.h b/venv/include/site/python3.12/pygame/include/_pygame.h new file mode 100644 index 00000000..f98f3f5f --- /dev/null +++ b/venv/include/site/python3.12/pygame/include/_pygame.h @@ -0,0 +1,949 @@ +/* + pygame - Python Game Library + Copyright (C) 2000-2001 Pete Shinners + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public + License along with this library; if not, write to the Free + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + + Pete Shinners + pete@shinners.org +*/ + +#ifndef _PYGAME_H +#define _PYGAME_H + +/** This header file includes all the definitions for the + ** base pygame extensions. This header only requires + ** Python includes (and SDL.h for functions that use SDL types). + ** The reason for functions prototyped with #define's is + ** to allow for maximum Python portability. It also uses + ** Python as the runtime linker, which allows for late binding. + '' For more information on this style of development, read + ** the Python docs on this subject. + ** http://www.python.org/doc/current/ext/using-cobjects.html + ** + ** If using this to build your own derived extensions, + ** you'll see that the functions available here are mainly + ** used to help convert between python objects and SDL objects. + ** Since this library doesn't add a lot of functionality to + ** the SDL library, it doesn't need to offer a lot either. + ** + ** When initializing your extension module, you must manually + ** import the modules you want to use. (this is the part about + ** using python as the runtime linker). Each module has its + ** own import_xxx() routine. You need to perform this import + ** after you have initialized your own module, and before + ** you call any routines from that module. Since every module + ** in pygame does this, there are plenty of examples. + ** + ** The base module does include some useful conversion routines + ** that you are free to use in your own extension. + **/ + +#include "pgplatform.h" +#include + +/* version macros (defined since version 1.9.5) */ +#define PG_MAJOR_VERSION 2 +#define PG_MINOR_VERSION 6 +#define PG_PATCH_VERSION 1 +#define PG_VERSIONNUM(MAJOR, MINOR, PATCH) \ + (1000 * (MAJOR) + 100 * (MINOR) + (PATCH)) +#define PG_VERSION_ATLEAST(MAJOR, MINOR, PATCH) \ + (PG_VERSIONNUM(PG_MAJOR_VERSION, PG_MINOR_VERSION, PG_PATCH_VERSION) >= \ + PG_VERSIONNUM(MAJOR, MINOR, PATCH)) + +#include "pgcompat.h" + +/* Flag indicating a pg_buffer; used for assertions within callbacks */ +#ifndef NDEBUG +#define PyBUF_PYGAME 0x4000 +#endif +#define PyBUF_HAS_FLAG(f, F) (((f) & (F)) == (F)) + +/* Array information exchange struct C type; inherits from Py_buffer + * + * Pygame uses its own Py_buffer derived C struct as an internal representation + * of an imported array buffer. The extended Py_buffer allows for a + * per-instance release callback, + */ +typedef void (*pybuffer_releaseproc)(Py_buffer *); + +typedef struct pg_bufferinfo_s { + Py_buffer view; + PyObject *consumer; /* Input: Borrowed reference */ + pybuffer_releaseproc release_buffer; +} pg_buffer; + +#include "pgimport.h" + +/* + * BASE module + */ +#ifndef PYGAMEAPI_BASE_INTERNAL +#define pgExc_SDLError ((PyObject *)PYGAMEAPI_GET_SLOT(base, 0)) + +#define pg_RegisterQuit \ + (*(void (*)(void (*)(void)))PYGAMEAPI_GET_SLOT(base, 1)) + +/** + * \brief Convert number like object *obj* to C int and in *val*. + * + * \param obj The Python object to convert. + * \param val A pointer to the C integer to store the result. + * \returns 1 if the conversion was successful, 0 otherwise. + * + * \note This function will clear any Python errors. + * \note This function will convert floats to integers. + */ +#define pg_IntFromObj \ + (*(int (*)(PyObject *, int *))PYGAMEAPI_GET_SLOT(base, 2)) + +/** + * \brief Convert number like object at position *i* in sequence *obj* + * to C int and place in argument *val*. + * + * \param obj The Python object to convert. + * \param i The index of the object to convert. + * \param val A pointer to the C integer to store the result. + * \returns 1 if the conversion was successful, 0 otherwise. + * + * \note This function will clear any Python errors. + * \note This function will convert floats to integers. + */ +#define pg_IntFromObjIndex \ + (*(int (*)(PyObject *, int, int *))PYGAMEAPI_GET_SLOT(base, 3)) + +/** + * \brief Convert the two number like objects in length 2 sequence *obj* to C + * int and place in arguments *val1* and *val2*. + * + * \param obj The Python two element sequence object to convert. + * \param val A pointer to the C integer to store the result. + * \param val2 A pointer to the C integer to store the result. + * \returns 1 if the conversion was successful, 0 otherwise. + * + * \note This function will clear any Python errors. + * \note This function will convert floats to integers. + */ +#define pg_TwoIntsFromObj \ + (*(int (*)(PyObject *, int *, int *))PYGAMEAPI_GET_SLOT(base, 4)) + +/** + * \brief Convert number like object *obj* to C float and in *val*. + * + * \param obj The Python object to convert. + * \param val A pointer to the C float to store the result. + * \returns 1 if the conversion was successful, 0 otherwise. + * + * \note This function will clear any Python errors. + */ +#define pg_FloatFromObj \ + (*(int (*)(PyObject *, float *))PYGAMEAPI_GET_SLOT(base, 5)) + +/** + * \brief Convert number like object at position *i* in sequence *obj* to C + * float and place in argument *val*. + * + * \param obj The Python object to convert. + * \param i The index of the object to convert. + * \param val A pointer to the C float to store the result. + * \returns 1 if the conversion was successful, 0 otherwise. + * + * \note This function will clear any Python errors. + */ +#define pg_FloatFromObjIndex \ + (*(int (*)(PyObject *, int, float *))PYGAMEAPI_GET_SLOT(base, 6)) + +/** + * \brief Convert the two number like objects in length 2 sequence *obj* to C + * float and place in arguments *val1* and *val2*. + * + * \param obj The Python two element sequence object to convert. + * \param val A pointer to the C float to store the result. + * \param val2 A pointer to the C float to store the result. + * \returns 1 if the conversion was successful, 0 otherwise. + * + * \note This function will clear any Python errors. + */ +#define pg_TwoFloatsFromObj \ + (*(int (*)(PyObject *, float *, float *))PYGAMEAPI_GET_SLOT(base, 7)) + +/** + * \brief Convert number like object *obj* to C Uint32 and in *val*. + * + * \param obj The Python object to convert. + * \param val A pointer to the C int to store the result. + * \returns 1 if the conversion was successful, 0 otherwise. + */ +#define pg_UintFromObj \ + (*(int (*)(PyObject *, Uint32 *))PYGAMEAPI_GET_SLOT(base, 8)) + +/** + * \brief Convert number like object at position *i* in sequence *obj* to C + * Uint32 and place in argument *val*. + * + * \param obj The Python object to convert. + * \param i The index of the object to convert. + * \param val A pointer to the C int to store the result. + * \returns 1 if the conversion was successful, 0 otherwise. + */ +#define pg_UintFromObjIndex \ + (*(int (*)(PyObject *, int, Uint32 *))PYGAMEAPI_GET_SLOT(base, 9)) + +/** + * \brief Initialize all of the pygame modules. + * \returns 1 on success, 0 on failure with PyErr set. + */ +#define pg_mod_autoinit (*(int (*)(const char *))PYGAMEAPI_GET_SLOT(base, 10)) + +/** + * \brief Quit all of the pygame modules. + */ +#define pg_mod_autoquit (*(void (*)(const char *))PYGAMEAPI_GET_SLOT(base, 11)) + +/** + * \brief Convert the color represented by object *obj* into a red, green, + * blue, alpha length 4 C array *RGBA*. + * + * The object must be a length 3 or 4 sequence of numbers having values between + * 0 and 255 inclusive. For a length 3 sequence an alpha value of 255 is + * assumed. + * + * \param obj The Python object to convert. + * \param RGBA A pointer to the C array to store the result. + * \returns 1 if the conversion was successful, 0 otherwise. + */ +#define pg_RGBAFromObj \ + (*(int (*)(PyObject *, Uint8 *))PYGAMEAPI_GET_SLOT(base, 12)) + +/** + * \brief Given a Py_buffer, return a python dictionary representing the array + * interface. + * + * \param view_p A pointer to the Py_buffer to convert to a dictionary. + * + * \returns A Python dictionary representing the array interface of the object. + */ +#define pgBuffer_AsArrayInterface \ + (*(PyObject * (*)(Py_buffer *)) PYGAMEAPI_GET_SLOT(base, 13)) + +/** + * \brief Given a Py_buffer, return a python capsule representing the array + * interface. + * + * \param view_p A pointer to the Py_buffer to convert to a capsule. + * + * \returns A Python capsule representing the array interface of the object. + */ +#define pgBuffer_AsArrayStruct \ + (*(PyObject * (*)(Py_buffer *)) PYGAMEAPI_GET_SLOT(base, 14)) + +/** + * \brief Get a buffer object from a given Python object. + * + * \param obj The Python object to get the buffer from. + * \param pg_view_p A pointer to a pg_buffer struct to store the buffer in. + * \param flags The desired buffer access mode. + * + * \returns 0 on success, -1 on failure. + * + * \note This function attempts to get a buffer object from a given Python + * object. If the object supports the buffer protocol, it will be used to + * create the buffer. If not, it will try to get an array interface or + * dictionary representation of the object and use that to create the buffer. + * If none of these methods work, it will raise a ValueError. + * + */ +#define pgObject_GetBuffer \ + (*(int (*)(PyObject *, pg_buffer *, int))PYGAMEAPI_GET_SLOT(base, 15)) + +/** + * \brief Release a pg_buffer object. + * + * \param pg_view_p The pg_buffer object to release. + * + * \note This function releases a pg_buffer object. + * \note some calls to this function expect this function to not clear + * previously set errors. + */ +#define pgBuffer_Release (*(void (*)(pg_buffer *))PYGAMEAPI_GET_SLOT(base, 16)) + +/** + * \brief Write the array interface dictionary buffer description *dict* into a + * Pygame buffer description struct *pg_view_p*. + * + * \param pg_view_p The Pygame buffer description struct to write into. + * \param dict The array interface dictionary to read from. + * \param flags The PyBUF flags describing the view type requested. + * + * \returns 0 on success, or -1 on failure. + */ +#define pgDict_AsBuffer \ + (*(int (*)(pg_buffer *, PyObject *, int))PYGAMEAPI_GET_SLOT(base, 17)) + +#define pgExc_BufferError ((PyObject *)PYGAMEAPI_GET_SLOT(base, 18)) + +/** + * \brief Get the default SDL window created by a pygame.display.set_mode() + * call, or *NULL*. + * + * \return The default window, or *NULL* if no window has been created. + */ +#define pg_GetDefaultWindow \ + (*(SDL_Window * (*)(void)) PYGAMEAPI_GET_SLOT(base, 19)) + +/** + * \brief Set the default SDL window created by a pygame.display.set_mode() + * call. The previous window, if any, is destroyed. Argument *win* may be + * *NULL*. This function is called by pygame.display.set_mode(). + * + * \param win The new default window. May be NULL. + */ +#define pg_SetDefaultWindow \ + (*(void (*)(SDL_Window *))PYGAMEAPI_GET_SLOT(base, 20)) + +/** + * \brief Return a borrowed reference to the Pygame default window display + * surface, or *NULL* if no default window is open. + * + * \return The default renderer, or *NULL* if no renderer has been created. + */ +#define pg_GetDefaultWindowSurface \ + (*(pgSurfaceObject * (*)(void)) PYGAMEAPI_GET_SLOT(base, 21)) + +/** + * \brief Set the Pygame default window display surface. The previous + * surface, if any, is destroyed. Argument *screen* may be *NULL*. This + * function is called by pygame.display.set_mode(). + * + * \param screen The new default window display surface. May be NULL. + */ +#define pg_SetDefaultWindowSurface \ + (*(void (*)(pgSurfaceObject *))PYGAMEAPI_GET_SLOT(base, 22)) + +/** + * \returns NULL if the environment variable PYGAME_BLEND_ALPHA_SDL2 is not + * set, otherwise returns a pointer to the environment variable. + */ +#define pg_EnvShouldBlendAlphaSDL2 \ + (*(char *(*)(void))PYGAMEAPI_GET_SLOT(base, 23)) + +/** + * \brief Convert number like object *obj* to C double and in *val*. + * + * \param obj The Python object to convert. + * \param val A pointer to the C double to store the result. + * \returns 1 if the conversion was successful, 0 otherwise. + * + * \note This function will clear any Python errors. + */ +#define pg_DoubleFromObj \ + (*(int (*)(PyObject *, double *))PYGAMEAPI_GET_SLOT(base, 24)) + +/** + * \brief Convert number like object at position *i* in sequence *obj* to C + * double and place in argument *val*. + * + * \param obj The Python object to convert. + * \param i The index of the object to convert. + * \param val A pointer to the C double to store the result. + * \returns 1 if the conversion was successful, 0 otherwise. + * + * \note This function will clear any Python errors. + */ +#define pg_DoubleFromObjIndex \ + (*(int (*)(PyObject *, int, double *))PYGAMEAPI_GET_SLOT(base, 25)) + +/** + * \brief Convert the two number like objects in length 2 sequence *obj* to C + * double and place in arguments *val1* and *val2*. + * + * \param obj The Python two element sequence object to convert. + * \param val A pointer to the C double to store the result. + * \param val2 A pointer to the C double to store the result. + * \returns 1 if the conversion was successful, 0 otherwise. + */ +#define pg_TwoDoublesFromObj \ + (*(int (*)(PyObject *, double *, double *))PYGAMEAPI_GET_SLOT(base, 26)) + +#define import_pygame_base() IMPORT_PYGAME_MODULE(base) +#endif /* ~PYGAMEAPI_BASE_INTERNAL */ + +typedef struct { + /** + * \brief The SDL rect wrapped by this object. + */ + PyObject_HEAD SDL_Rect r; + /** + * \brief A list of weak references to this rect. + */ + PyObject *weakreflist; +} pgRectObject; + +/** + * \brief Convert a pgRectObject to an SDL_Rect. + * + * \param obj A pgRectObject instance. + * \returns the SDL_Rect field of *obj*, a pgRect_Type instance. + * + * \note SDL_Rect pgRect_AsRect(PyObject *obj) + */ +#define pgRect_AsRect(x) (((pgRectObject *)x)->r) + +#ifndef PYGAMEAPI_RECT_INTERNAL + +/** + * \brief The Pygame rectangle object type pygame.Rect. + */ +#define pgRect_Type (*(PyTypeObject *)PYGAMEAPI_GET_SLOT(rect, 0)) + +/** + * \brief Check if *obj* is a `pygame.Rect` instance. + * + * \returns true if *obj* is a `pygame.Rect` instance + */ +#define pgRect_Check(obj) ((obj)->ob_type == &pgRect_Type) + +/** + * \brief Create a new `pygame.Rect` instance. + * + * \param r A pointer to an SDL_Rect struct. + * \returns a new `pygame.Rect` object for the SDL_Rect *r*. + * Returns *NULL* on error. + * + * \note PyObject* pgRect_New(SDL_Rect *r) + */ +#define pgRect_New (*(PyObject * (*)(SDL_Rect *)) PYGAMEAPI_GET_SLOT(rect, 1)) + +/** + * \brief Create a new `pygame.Rect` instance from x, y, w, h. + * + * \param x The x coordinate of the rectangle. + * \param y The y coordinate of the rectangle. + * \param w The width of the rectangle. + * \param h The height of the rectangle. + * \returns a new `pygame.Rect` object. Returns *NULL* on error. + * + * \note PyObject* pgRect_New4(int x, int y, int w, int h) + */ +#define pgRect_New4 \ + (*(PyObject * (*)(int, int, int, int)) PYGAMEAPI_GET_SLOT(rect, 2)) + +/** + * \brief Convert a Python object to a `pygame.Rect` instance. + * + * \param obj A Python object. + * A rectangle can be a length 4 sequence integers (x, y, w, h), or a length 2 + * sequence of position (x, y) and size (w, h), or a length 1 tuple containing + * a rectangle representation, or have a method *rect* that returns a + * rectangle. + * + * \param temp A pointer to an SDL_Rect struct to store the result in. + * \returns a pointer to the SDL_Rect field of the `pygame.Rect` instance + * *obj*. Returns *NULL* on error. + * + * \note This function will clear any Python errors. + * \note SDL_Rect* pgRect_FromObject(PyObject *obj, SDL_Rect *temp) + */ +#define pgRect_FromObject \ + (*(SDL_Rect * (*)(PyObject *, SDL_Rect *)) PYGAMEAPI_GET_SLOT(rect, 3)) + +/** + * \brief Normalize a `pygame.Rect` instance. A rect with a negative size + * (negative width and/or height) will be adjusted to have a positive size. + * + * \param rect A pointer to a `pygame.Rect` instance. + * \returns *rect* normalized with positive values only. + * + * \note void pgRect_Normalize(SDL_Rect *rect) + */ +#define pgRect_Normalize (*(void (*)(SDL_Rect *))PYGAMEAPI_GET_SLOT(rect, 4)) + +#define import_pygame_rect() IMPORT_PYGAME_MODULE(rect) +#endif /* ~PYGAMEAPI_RECT_INTERNAL */ + +/* + * JOYSTICK module + */ +typedef struct pgJoystickObject { + PyObject_HEAD int id; + SDL_Joystick *joy; + + /* Joysticks form an intrusive linked list. + * + * Note that we don't maintain refcounts for these so they are weakrefs + * from the Python side. + */ + struct pgJoystickObject *next; + struct pgJoystickObject *prev; +} pgJoystickObject; + +#define pgJoystick_AsID(x) (((pgJoystickObject *)x)->id) +#define pgJoystick_AsSDL(x) (((pgJoystickObject *)x)->joy) + +#ifndef PYGAMEAPI_JOYSTICK_INTERNAL +#define pgJoystick_Type (*(PyTypeObject *)PYGAMEAPI_GET_SLOT(joystick, 0)) + +#define pgJoystick_Check(x) ((x)->ob_type == &pgJoystick_Type) +#define pgJoystick_New (*(PyObject * (*)(int)) PYGAMEAPI_GET_SLOT(joystick, 1)) + +#define import_pygame_joystick() IMPORT_PYGAME_MODULE(joystick) +#endif + +/* + * DISPLAY module + */ + +typedef struct { + Uint32 hw_available : 1; + Uint32 wm_available : 1; + Uint32 blit_hw : 1; + Uint32 blit_hw_CC : 1; + Uint32 blit_hw_A : 1; + Uint32 blit_sw : 1; + Uint32 blit_sw_CC : 1; + Uint32 blit_sw_A : 1; + Uint32 blit_fill : 1; + Uint32 video_mem; + SDL_PixelFormat *vfmt; + SDL_PixelFormat vfmt_data; + int current_w; + int current_h; +} pg_VideoInfo; + +/** + * A pygame object that wraps an SDL_VideoInfo struct. + * The object returned by `pygame.display.Info()` + */ +typedef struct { + PyObject_HEAD pg_VideoInfo info; +} pgVidInfoObject; + +/** + * \brief Convert a pgVidInfoObject to an SDL_VideoInfo. + * + * \note SDL_VideoInfo pgVidInfo_AsVidInfo(PyObject *obj) + * + * \returns the SDL_VideoInfo field of *obj*, a pgVidInfo_Type instance. + * \param obj A pgVidInfo_Type instance. + * + * \note Does not check that *obj* is not `NULL` or an `pgVidInfoObject` + * object. + */ +#define pgVidInfo_AsVidInfo(x) (((pgVidInfoObject *)x)->info) + +#ifndef PYGAMEAPI_DISPLAY_INTERNAL +/** + * \brief The pgVidInfoObject object Python type. + * \note pgVideoInfo_Type is used for the `pygame.display.Info()` object. + */ +#define pgVidInfo_Type (*(PyTypeObject *)PYGAMEAPI_GET_SLOT(display, 0)) + +/** + * \brief Check if *obj* is a pgVidInfoObject. + * + * \returns true if *x* is a `pgVidInfo_Type` instance + * \note Will return false if *x* is a subclass of `pgVidInfo_Type`. + * \note This macro does not check that *x* is not ``NULL``. + * \note int pgVidInfo_Check(PyObject *x) + */ +#define pgVidInfo_Check(x) ((x)->ob_type == &pgVidInfo_Type) + +/** + * \brief Create a new pgVidInfoObject. + * + * \param i A pointer to an SDL_VideoInfo struct. + * \returns a new `pgVidInfoObject` object for the SDL_VideoInfo *i*. + * + * \note PyObject* pgVidInfo_New(SDL_VideoInfo *i) + * \note On failure, raise a Python exception and return `NULL`. + */ +#define pgVidInfo_New \ + (*(PyObject * (*)(pg_VideoInfo *)) PYGAMEAPI_GET_SLOT(display, 1)) + +#define import_pygame_display() IMPORT_PYGAME_MODULE(display) +#endif /* ~PYGAMEAPI_DISPLAY_INTERNAL */ + +/* + * SURFACE module + */ +struct pgSubSurface_Data; +struct SDL_Surface; + +/** + * \brief A pygame object that wraps an SDL_Surface. A `pygame.Surface` + * instance. + */ +typedef struct { + PyObject_HEAD struct SDL_Surface *surf; + /** + * \brief If true, the surface will be freed when the python object is + * destroyed. + */ + int owner; + /** + * \brief The subsurface data for this surface (if a subsurface). + */ + struct pgSubSurface_Data *subsurface; + /** + * \brief A list of weak references to this surface. + */ + PyObject *weakreflist; + /** + * \brief A list of locks for this surface. + */ + PyObject *locklist; + /** + * \brief Usually a buffer object which the surface gets its data from. + */ + PyObject *dependency; +} pgSurfaceObject; + +/** + * \brief Convert a `pygame.Surface` instance to an SDL_Surface. + * + * \param x A `pygame.Surface` instance. + * \returns the SDL_Surface field of *x*, a `pygame.Surface` instance. + * + * \note SDL_Surface* pgSurface_AsSurface(PyObject *x) + */ +#define pgSurface_AsSurface(x) (((pgSurfaceObject *)x)->surf) + +#ifndef PYGAMEAPI_SURFACE_INTERNAL +/** + * \brief The `pygame.Surface` object Python type. + */ +#define pgSurface_Type (*(PyTypeObject *)PYGAMEAPI_GET_SLOT(surface, 0)) + +/** + * \brief Check if *x* is a `pygame.Surface` instance. + * + * \param x The object to check. + * \returns true if *x* is a `pygame.Surface` instance + * + * \note Will return false if *x* is a subclass of `pygame.Surface`. + * \note This macro does not check that *x* is not ``NULL``. + * \note int pgSurface_Check(PyObject *x) + */ +#define pgSurface_Check(x) \ + (PyObject_IsInstance((x), (PyObject *)&pgSurface_Type)) + +/** + * \brief Create a new `pygame.Surface` instance. + * + * \param s The SDL surface to wrap in a python object. + * \param owner If true, the surface will be freed when the python object is + * destroyed. \returns A new new pygame surface instance for SDL surface *s*. + * Returns *NULL* on error. + * + * \note pgSurfaceObject* pgSurface_New2(SDL_Surface *s, int owner) + */ +#define pgSurface_New2 \ + (*(pgSurfaceObject * (*)(SDL_Surface *, int)) \ + PYGAMEAPI_GET_SLOT(surface, 1)) + +/** + * \brief Sets the SDL surface for a `pygame.Surface` instance. + * + * \param self The `pygame.Surface` instance to set the surface for. + * \param s The SDL surface to set. + * \param owner If true, the surface will be freed when the python object is + * destroyed. \returns 0 on success, -1 on failure. + * + * \note int pgSurface_SetSurface(pgSurfaceObject *self, SDL_Surface *s, int + * owner) + */ +#define pgSurface_SetSurface \ + (*(int (*)(pgSurfaceObject *, SDL_Surface *, int))PYGAMEAPI_GET_SLOT( \ + surface, 3)) + +/** + * \brief Blit one surface onto another. + * + * \param dstobj The destination surface. + * \param srcobj The source surface. + * \param dstrect The destination rectangle. + * \param srcrect The source rectangle. + * \param the_args The blit flags. + * \return 0 for success, -1 or -2 for error. + * + * \note Is accessible through the C api. + * \note int pgSurface_Blit(PyObject *dstobj, PyObject *srcobj, SDL_Rect + * *dstrect, SDL_Rect *srcrect, int the_args) + */ +#define pgSurface_Blit \ + (*(int (*)(pgSurfaceObject *, pgSurfaceObject *, SDL_Rect *, SDL_Rect *, \ + int))PYGAMEAPI_GET_SLOT(surface, 2)) + +#define import_pygame_surface() \ + do { \ + IMPORT_PYGAME_MODULE(surface); \ + if (PyErr_Occurred() != NULL) \ + break; \ + IMPORT_PYGAME_MODULE(surflock); \ + } while (0) + +#define pgSurface_New(surface) pgSurface_New2((surface), 1) +#define pgSurface_NewNoOwn(surface) pgSurface_New2((surface), 0) + +#endif /* ~PYGAMEAPI_SURFACE_INTERNAL */ + +/* + * SURFLOCK module + * auto imported/initialized by surface + */ +#ifndef PYGAMEAPI_SURFLOCK_INTERNAL +#define pgLifetimeLock_Type (*(PyTypeObject *)PYGAMEAPI_GET_SLOT(surflock, 0)) + +#define pgLifetimeLock_Check(x) ((x)->ob_type == &pgLifetimeLock_Type) + +#define pgSurface_Prep(x) \ + if ((x)->subsurface) \ + (*(*(void (*)(pgSurfaceObject *))PYGAMEAPI_GET_SLOT(surflock, 1)))(x) + +#define pgSurface_Unprep(x) \ + if ((x)->subsurface) \ + (*(*(void (*)(pgSurfaceObject *))PYGAMEAPI_GET_SLOT(surflock, 2)))(x) + +#define pgSurface_Lock \ + (*(int (*)(pgSurfaceObject *))PYGAMEAPI_GET_SLOT(surflock, 3)) + +#define pgSurface_Unlock \ + (*(int (*)(pgSurfaceObject *))PYGAMEAPI_GET_SLOT(surflock, 4)) + +#define pgSurface_LockBy \ + (*(int (*)(pgSurfaceObject *, PyObject *))PYGAMEAPI_GET_SLOT(surflock, 5)) + +#define pgSurface_UnlockBy \ + (*(int (*)(pgSurfaceObject *, PyObject *))PYGAMEAPI_GET_SLOT(surflock, 6)) + +#define pgSurface_LockLifetime \ + (*(PyObject * (*)(PyObject *, PyObject *)) PYGAMEAPI_GET_SLOT(surflock, 7)) +#endif + +/* + * EVENT module + */ +typedef struct pgEventObject pgEventObject; + +#ifndef PYGAMEAPI_EVENT_INTERNAL +#define pgEvent_Type (*(PyTypeObject *)PYGAMEAPI_GET_SLOT(event, 0)) + +#define pgEvent_Check(x) ((x)->ob_type == &pgEvent_Type) + +#define pgEvent_New \ + (*(PyObject * (*)(SDL_Event *)) PYGAMEAPI_GET_SLOT(event, 1)) + +#define pgEvent_New2 \ + (*(PyObject * (*)(int, PyObject *)) PYGAMEAPI_GET_SLOT(event, 2)) + +#define pgEvent_FillUserEvent \ + (*(int (*)(pgEventObject *, SDL_Event *))PYGAMEAPI_GET_SLOT(event, 3)) + +#define pg_EnableKeyRepeat (*(int (*)(int, int))PYGAMEAPI_GET_SLOT(event, 4)) + +#define pg_GetKeyRepeat (*(void (*)(int *, int *))PYGAMEAPI_GET_SLOT(event, 5)) + +#define import_pygame_event() IMPORT_PYGAME_MODULE(event) +#endif + +/* + * RWOBJECT module + * the rwobject are only needed for C side work, not accessible from python. + */ +#ifndef PYGAMEAPI_RWOBJECT_INTERNAL +#define pgRWops_FromObject \ + (*(SDL_RWops * (*)(PyObject *, char **)) PYGAMEAPI_GET_SLOT(rwobject, 0)) + +#define pgRWops_IsFileObject \ + (*(int (*)(SDL_RWops *))PYGAMEAPI_GET_SLOT(rwobject, 1)) + +#define pg_EncodeFilePath \ + (*(PyObject * (*)(PyObject *, PyObject *)) PYGAMEAPI_GET_SLOT(rwobject, 2)) + +#define pg_EncodeString \ + (*(PyObject * (*)(PyObject *, const char *, const char *, PyObject *)) \ + PYGAMEAPI_GET_SLOT(rwobject, 3)) + +#define pgRWops_FromFileObject \ + (*(SDL_RWops * (*)(PyObject *)) PYGAMEAPI_GET_SLOT(rwobject, 4)) + +#define pgRWops_ReleaseObject \ + (*(int (*)(SDL_RWops *))PYGAMEAPI_GET_SLOT(rwobject, 5)) + +#define import_pygame_rwobject() IMPORT_PYGAME_MODULE(rwobject) + +#endif + +/* + * PixelArray module + */ +#ifndef PYGAMEAPI_PIXELARRAY_INTERNAL +#define PyPixelArray_Type ((PyTypeObject *)PYGAMEAPI_GET_SLOT(pixelarray, 0)) + +#define PyPixelArray_Check(x) ((x)->ob_type == &PyPixelArray_Type) +#define PyPixelArray_New (*(PyObject * (*)) PYGAMEAPI_GET_SLOT(pixelarray, 1)) + +#define import_pygame_pixelarray() IMPORT_PYGAME_MODULE(pixelarray) +#endif /* PYGAMEAPI_PIXELARRAY_INTERNAL */ + +/* + * Color module + */ +typedef struct pgColorObject pgColorObject; + +#ifndef PYGAMEAPI_COLOR_INTERNAL +#define pgColor_Type (*(PyObject *)PYGAMEAPI_GET_SLOT(color, 0)) + +#define pgColor_Check(x) ((x)->ob_type == &pgColor_Type) +#define pgColor_New (*(PyObject * (*)(Uint8 *)) PYGAMEAPI_GET_SLOT(color, 1)) + +#define pgColor_NewLength \ + (*(PyObject * (*)(Uint8 *, Uint8)) PYGAMEAPI_GET_SLOT(color, 3)) + +#define pg_RGBAFromColorObj \ + (*(int (*)(PyObject *, Uint8 *))PYGAMEAPI_GET_SLOT(color, 2)) + +#define pg_RGBAFromFuzzyColorObj \ + (*(int (*)(PyObject *, Uint8 *))PYGAMEAPI_GET_SLOT(color, 4)) + +#define pgColor_AsArray(x) (((pgColorObject *)x)->data) +#define pgColor_NumComponents(x) (((pgColorObject *)x)->len) + +#define import_pygame_color() IMPORT_PYGAME_MODULE(color) +#endif /* PYGAMEAPI_COLOR_INTERNAL */ + +/* + * Math module + */ +#ifndef PYGAMEAPI_MATH_INTERNAL +#define pgVector2_Check(x) \ + ((x)->ob_type == (PyTypeObject *)PYGAMEAPI_GET_SLOT(math, 0)) + +#define pgVector3_Check(x) \ + ((x)->ob_type == (PyTypeObject *)PYGAMEAPI_GET_SLOT(math, 1)) +/* +#define pgVector2_New \ + (*(PyObject*(*)) \ + PYGAMEAPI_GET_SLOT(PyGAME_C_API, 1)) +*/ +#define import_pygame_math() IMPORT_PYGAME_MODULE(math) +#endif /* PYGAMEAPI_MATH_INTERNAL */ + +#define IMPORT_PYGAME_MODULE _IMPORT_PYGAME_MODULE + +/* + * base pygame API slots + * disable slots with NO_PYGAME_C_API + */ +#ifdef PYGAME_H +PYGAMEAPI_DEFINE_SLOTS(base); +PYGAMEAPI_DEFINE_SLOTS(rect); +PYGAMEAPI_DEFINE_SLOTS(cdrom); +PYGAMEAPI_DEFINE_SLOTS(joystick); +PYGAMEAPI_DEFINE_SLOTS(display); +PYGAMEAPI_DEFINE_SLOTS(surface); +PYGAMEAPI_DEFINE_SLOTS(surflock); +PYGAMEAPI_DEFINE_SLOTS(event); +PYGAMEAPI_DEFINE_SLOTS(rwobject); +PYGAMEAPI_DEFINE_SLOTS(pixelarray); +PYGAMEAPI_DEFINE_SLOTS(color); +PYGAMEAPI_DEFINE_SLOTS(math); +#else /* ~PYGAME_H */ +PYGAMEAPI_EXTERN_SLOTS(base); +PYGAMEAPI_EXTERN_SLOTS(rect); +PYGAMEAPI_EXTERN_SLOTS(cdrom); +PYGAMEAPI_EXTERN_SLOTS(joystick); +PYGAMEAPI_EXTERN_SLOTS(display); +PYGAMEAPI_EXTERN_SLOTS(surface); +PYGAMEAPI_EXTERN_SLOTS(surflock); +PYGAMEAPI_EXTERN_SLOTS(event); +PYGAMEAPI_EXTERN_SLOTS(rwobject); +PYGAMEAPI_EXTERN_SLOTS(pixelarray); +PYGAMEAPI_EXTERN_SLOTS(color); +PYGAMEAPI_EXTERN_SLOTS(math); +#endif /* ~PYGAME_H */ + +#endif /* PYGAME_H */ + +/* Use the end of this file for other cross module inline utility + * functions There seems to be no good reason to stick to macro only + * functions in Python 3. + */ + +static PG_INLINE PyObject * +pg_tuple_couple_from_values_int(int val1, int val2) +{ + /* This function turns two input integers into a python tuple object. + * Currently, 5th November 2022, this is faster than using Py_BuildValue + * to do the same thing. + */ + PyObject *tup = PyTuple_New(2); + if (!tup) { + return NULL; + } + + PyObject *tmp = PyLong_FromLong(val1); + if (!tmp) { + Py_DECREF(tup); + return NULL; + } + PyTuple_SET_ITEM(tup, 0, tmp); + + tmp = PyLong_FromLong(val2); + if (!tmp) { + Py_DECREF(tup); + return NULL; + } + PyTuple_SET_ITEM(tup, 1, tmp); + + return tup; +} + +static PG_INLINE PyObject * +pg_tuple_triple_from_values_int(int val1, int val2, int val3) +{ + /* This function turns three input integers into a python tuple object. + * Currently, 5th November 2022, this is faster than using Py_BuildValue + * to do the same thing. + */ + PyObject *tup = PyTuple_New(3); + if (!tup) { + return NULL; + } + + PyObject *tmp = PyLong_FromLong(val1); + if (!tmp) { + Py_DECREF(tup); + return NULL; + } + PyTuple_SET_ITEM(tup, 0, tmp); + + tmp = PyLong_FromLong(val2); + if (!tmp) { + Py_DECREF(tup); + return NULL; + } + PyTuple_SET_ITEM(tup, 1, tmp); + + tmp = PyLong_FromLong(val3); + if (!tmp) { + Py_DECREF(tup); + return NULL; + } + PyTuple_SET_ITEM(tup, 2, tmp); + + return tup; +} diff --git a/venv/include/site/python3.12/pygame/include/bitmask.h b/venv/include/site/python3.12/pygame/include/bitmask.h new file mode 100644 index 00000000..eee09b70 --- /dev/null +++ b/venv/include/site/python3.12/pygame/include/bitmask.h @@ -0,0 +1,171 @@ +/* + Bitmask 1.7 - A pixel-perfect collision detection library. + + Copyright (C) 2002-2005 Ulf Ekstrom except for the bitcount + function which is copyright (C) Donald W. Gillies, 1992. + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public + License along with this library; if not, write to the Free + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ +#ifndef BITMASK_H +#define BITMASK_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include +/* Define INLINE for different compilers. If your compiler does not + support inlining then there might be a performance hit in + bitmask_overlap_area(). +*/ +#ifndef INLINE +#ifdef __GNUC__ +#define INLINE inline +#else +#ifdef _MSC_VER +#define INLINE __inline +#else +#define INLINE +#endif +#endif +#endif + +#define BITMASK_W unsigned long int +#define BITMASK_W_LEN (sizeof(BITMASK_W) * CHAR_BIT) +#define BITMASK_W_MASK (BITMASK_W_LEN - 1) +#define BITMASK_N(n) ((BITMASK_W)1 << (n)) + +typedef struct bitmask { + int w, h; + BITMASK_W bits[1]; +} bitmask_t; + +/* Creates a bitmask of width w and height h, where + w and h must both be greater than or equal to 0. + The mask is automatically cleared when created. + */ +bitmask_t * +bitmask_create(int w, int h); + +/* Frees all the memory allocated by bitmask_create for m. */ +void +bitmask_free(bitmask_t *m); + +/* Create a copy of the given bitmask. */ +bitmask_t * +bitmask_copy(bitmask_t *m); + +/* Clears all bits in the mask */ +void +bitmask_clear(bitmask_t *m); + +/* Sets all bits in the mask */ +void +bitmask_fill(bitmask_t *m); + +/* Flips all bits in the mask */ +void +bitmask_invert(bitmask_t *m); + +/* Counts the bits in the mask */ +unsigned int +bitmask_count(bitmask_t *m); + +/* Returns nonzero if the bit at (x,y) is set. Coordinates start at + (0,0) */ +static INLINE int +bitmask_getbit(const bitmask_t *m, int x, int y) +{ + return (m->bits[x / BITMASK_W_LEN * m->h + y] & + BITMASK_N(x & BITMASK_W_MASK)) != 0; +} + +/* Sets the bit at (x,y) */ +static INLINE void +bitmask_setbit(bitmask_t *m, int x, int y) +{ + m->bits[x / BITMASK_W_LEN * m->h + y] |= BITMASK_N(x & BITMASK_W_MASK); +} + +/* Clears the bit at (x,y) */ +static INLINE void +bitmask_clearbit(bitmask_t *m, int x, int y) +{ + m->bits[x / BITMASK_W_LEN * m->h + y] &= ~BITMASK_N(x & BITMASK_W_MASK); +} + +/* Returns nonzero if the masks overlap with the given offset. + The overlap tests uses the following offsets (which may be negative): + + +----+----------.. + |A | yoffset + | +-+----------.. + +--|B + |xoffset + | | + : : +*/ +int +bitmask_overlap(const bitmask_t *a, const bitmask_t *b, int xoffset, + int yoffset); + +/* Like bitmask_overlap(), but will also give a point of intersection. + x and y are given in the coordinates of mask a, and are untouched + if there is no overlap. */ +int +bitmask_overlap_pos(const bitmask_t *a, const bitmask_t *b, int xoffset, + int yoffset, int *x, int *y); + +/* Returns the number of overlapping 'pixels' */ +int +bitmask_overlap_area(const bitmask_t *a, const bitmask_t *b, int xoffset, + int yoffset); + +/* Fills a mask with the overlap of two other masks. A bitwise AND. */ +void +bitmask_overlap_mask(const bitmask_t *a, const bitmask_t *b, bitmask_t *c, + int xoffset, int yoffset); + +/* Draws mask b onto mask a (bitwise OR). Can be used to compose large + (game background?) mask from several submasks, which may speed up + the testing. */ + +void +bitmask_draw(bitmask_t *a, const bitmask_t *b, int xoffset, int yoffset); + +void +bitmask_erase(bitmask_t *a, const bitmask_t *b, int xoffset, int yoffset); + +/* Return a new scaled bitmask, with dimensions w*h. The quality of the + scaling may not be perfect for all circumstances, but it should + be reasonable. If either w or h is 0 a clear 1x1 mask is returned. */ +bitmask_t * +bitmask_scale(const bitmask_t *m, int w, int h); + +/* Convolve b into a, drawing the output into o, shifted by offset. If offset + * is 0, then the (x,y) bit will be set if and only if + * bitmask_overlap(a, b, x - b->w - 1, y - b->h - 1) returns true. + * + * Modifies bits o[xoffset ... xoffset + a->w + b->w - 1) + * [yoffset ... yoffset + a->h + b->h - 1). */ +void +bitmask_convolve(const bitmask_t *a, const bitmask_t *b, bitmask_t *o, + int xoffset, int yoffset); + +#ifdef __cplusplus +} /* End of extern "C" { */ +#endif + +#endif diff --git a/venv/include/site/python3.12/pygame/include/pgcompat.h b/venv/include/site/python3.12/pygame/include/pgcompat.h new file mode 100644 index 00000000..3c09099a --- /dev/null +++ b/venv/include/site/python3.12/pygame/include/pgcompat.h @@ -0,0 +1,102 @@ +#if !defined(PGCOMPAT_H) +#define PGCOMPAT_H + +#include + +/* In CPython, Py_Exit finalises the python interpreter before calling C exit() + * This does not exist on PyPy, so use exit() directly here */ +#ifdef PYPY_VERSION +#define PG_EXIT(n) exit(n) +#else +#define PG_EXIT(n) Py_Exit(n) +#endif + +/* define common types where SDL is not included */ +#ifndef SDL_VERSION_ATLEAST +#ifdef _MSC_VER +typedef unsigned __int8 uint8_t; +typedef unsigned __int32 uint32_t; +#else +#include +#endif +typedef uint32_t Uint32; +typedef uint8_t Uint8; +#endif /* no SDL */ + +#if defined(SDL_VERSION_ATLEAST) + +#ifndef SDL_WINDOW_VULKAN +#define SDL_WINDOW_VULKAN 0 +#endif + +#ifndef SDL_WINDOW_ALWAYS_ON_TOP +#define SDL_WINDOW_ALWAYS_ON_TOP 0 +#endif + +#ifndef SDL_WINDOW_SKIP_TASKBAR +#define SDL_WINDOW_SKIP_TASKBAR 0 +#endif + +#ifndef SDL_WINDOW_UTILITY +#define SDL_WINDOW_UTILITY 0 +#endif + +#ifndef SDL_WINDOW_TOOLTIP +#define SDL_WINDOW_TOOLTIP 0 +#endif + +#ifndef SDL_WINDOW_POPUP_MENU +#define SDL_WINDOW_POPUP_MENU 0 +#endif + +#ifndef SDL_WINDOW_INPUT_GRABBED +#define SDL_WINDOW_INPUT_GRABBED 0 +#endif + +#ifndef SDL_WINDOW_INPUT_FOCUS +#define SDL_WINDOW_INPUT_FOCUS 0 +#endif + +#ifndef SDL_WINDOW_MOUSE_FOCUS +#define SDL_WINDOW_MOUSE_FOCUS 0 +#endif + +#ifndef SDL_WINDOW_FOREIGN +#define SDL_WINDOW_FOREIGN 0 +#endif + +#ifndef SDL_WINDOW_ALLOW_HIGHDPI +#define SDL_WINDOW_ALLOW_HIGHDPI 0 +#endif + +#ifndef SDL_WINDOW_MOUSE_CAPTURE +#define SDL_WINDOW_MOUSE_CAPTURE 0 +#endif + +#ifndef SDL_WINDOW_ALWAYS_ON_TOP +#define SDL_WINDOW_ALWAYS_ON_TOP 0 +#endif + +#ifndef SDL_WINDOW_SKIP_TASKBAR +#define SDL_WINDOW_SKIP_TASKBAR 0 +#endif + +#ifndef SDL_WINDOW_UTILITY +#define SDL_WINDOW_UTILITY 0 +#endif + +#ifndef SDL_WINDOW_TOOLTIP +#define SDL_WINDOW_TOOLTIP 0 +#endif + +#ifndef SDL_WINDOW_POPUP_MENU +#define SDL_WINDOW_POPUP_MENU 0 +#endif + +#ifndef SDL_MOUSEWHEEL_FLIPPED +#define NO_SDL_MOUSEWHEEL_FLIPPED +#endif + +#endif /* defined(SDL_VERSION_ATLEAST) */ + +#endif /* ~defined(PGCOMPAT_H) */ diff --git a/venv/include/site/python3.12/pygame/include/pgimport.h b/venv/include/site/python3.12/pygame/include/pgimport.h new file mode 100644 index 00000000..2c2e8cfb --- /dev/null +++ b/venv/include/site/python3.12/pygame/include/pgimport.h @@ -0,0 +1,67 @@ +#ifndef PGIMPORT_H +#define PGIMPORT_H + +/* Prefix when importing module */ +#define IMPPREFIX "pygame." + +#include "pgcompat.h" + +#define PYGAMEAPI_LOCAL_ENTRY "_PYGAME_C_API" +#define PG_CAPSULE_NAME(m) (IMPPREFIX m "." PYGAMEAPI_LOCAL_ENTRY) + +/* + * fill API slots defined by PYGAMEAPI_DEFINE_SLOTS/PYGAMEAPI_EXTERN_SLOTS + */ +#define _IMPORT_PYGAME_MODULE(module) \ + { \ + PyObject *_mod_##module = PyImport_ImportModule(IMPPREFIX #module); \ + \ + if (_mod_##module != NULL) { \ + PyObject *_c_api = \ + PyObject_GetAttrString(_mod_##module, PYGAMEAPI_LOCAL_ENTRY); \ + \ + Py_DECREF(_mod_##module); \ + if (_c_api != NULL && PyCapsule_CheckExact(_c_api)) { \ + void **localptr = (void **)PyCapsule_GetPointer( \ + _c_api, PG_CAPSULE_NAME(#module)); \ + _PGSLOTS_##module = localptr; \ + } \ + Py_XDECREF(_c_api); \ + } \ + } + +#define PYGAMEAPI_IS_IMPORTED(module) (_PGSLOTS_##module != NULL) + +/* + * source file must include one of these in order to use _IMPORT_PYGAME_MODULE. + * this is set by import_pygame_*() functions. + * disable with NO_PYGAME_C_API + */ +#define PYGAMEAPI_DEFINE_SLOTS(module) void **_PGSLOTS_##module = NULL +#define PYGAMEAPI_EXTERN_SLOTS(module) extern void **_PGSLOTS_##module +#define PYGAMEAPI_GET_SLOT(module, index) _PGSLOTS_##module[(index)] + +/* + * disabled API with NO_PYGAME_C_API; do nothing instead + */ +#ifdef NO_PYGAME_C_API + +#undef PYGAMEAPI_DEFINE_SLOTS +#undef PYGAMEAPI_EXTERN_SLOTS + +#define PYGAMEAPI_DEFINE_SLOTS(module) +#define PYGAMEAPI_EXTERN_SLOTS(module) + +/* intentionally leave this defined to cause a compiler error * +#define PYGAMEAPI_GET_SLOT(api_root, index) +#undef PYGAMEAPI_GET_SLOT*/ + +#undef _IMPORT_PYGAME_MODULE +#define _IMPORT_PYGAME_MODULE(module) + +#endif /* NO_PYGAME_C_API */ + +#define encapsulate_api(ptr, module) \ + PyCapsule_New(ptr, PG_CAPSULE_NAME(module), NULL) + +#endif /* ~PGIMPORT_H */ diff --git a/venv/include/site/python3.12/pygame/include/pgplatform.h b/venv/include/site/python3.12/pygame/include/pgplatform.h new file mode 100644 index 00000000..9465dc5b --- /dev/null +++ b/venv/include/site/python3.12/pygame/include/pgplatform.h @@ -0,0 +1,83 @@ +/* platform/compiler adjustments */ +#ifndef PG_PLATFORM_H +#define PG_PLATFORM_H + +#if defined(HAVE_SNPRINTF) /* defined in python.h (pyerrors.h) and SDL.h \ + (SDL_config.h) */ +#undef HAVE_SNPRINTF /* remove GCC redefine warning */ +#endif /* HAVE_SNPRINTF */ + +#ifndef PG_INLINE +#if defined(__clang__) +#define PG_INLINE __inline__ __attribute__((__unused__)) +#elif defined(__GNUC__) +#define PG_INLINE __inline__ +#elif defined(_MSC_VER) +#define PG_INLINE __inline +#elif defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L +#define PG_INLINE inline +#else +#define PG_INLINE +#endif +#endif /* ~PG_INLINE */ + +// Worth trying this on MSVC/win32 builds to see if provides any speed up +#ifndef PG_FORCEINLINE +#if defined(__clang__) +#define PG_FORCEINLINE __inline__ __attribute__((__unused__)) +#elif defined(__GNUC__) +#define PG_FORCEINLINE __inline__ +#elif defined(_MSC_VER) +#define PG_FORCEINLINE __forceinline +#elif defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L +#define PG_FORCEINLINE inline +#else +#define PG_FORCEINLINE +#endif +#endif /* ~PG_FORCEINLINE */ + +/* This is unconditionally defined in Python.h */ +#if defined(_POSIX_C_SOURCE) +#undef _POSIX_C_SOURCE +#endif + +#if defined(HAVE_SNPRINTF) +#undef HAVE_SNPRINTF +#endif + +/* SDL needs WIN32 */ +#if !defined(WIN32) && \ + (defined(MS_WIN32) || defined(_WIN32) || defined(__WIN32) || \ + defined(__WIN32__) || defined(_WINDOWS)) +#define WIN32 +#endif + +#ifndef PG_TARGET_SSE4_2 +#if defined(__clang__) || \ + (defined(__GNUC__) && \ + ((__GNUC__ == 4 && __GNUC_MINOR__ >= 9) || __GNUC__ >= 5)) +// The old gcc 4.8 on centos used by manylinux1 does not seem to get sse4.2 +// intrinsics +#define PG_FUNCTION_TARGET_SSE4_2 __attribute__((target("sse4.2"))) +// No else; we define the fallback later +#endif +#endif /* ~PG_TARGET_SSE4_2 */ + +#ifdef PG_FUNCTION_TARGET_SSE4_2 +#if !defined(__SSE4_2__) && !defined(PG_COMPILE_SSE4_2) +#if defined(__x86_64__) || defined(__i386__) +#define PG_COMPILE_SSE4_2 1 +#endif +#endif +#endif /* ~PG_TARGET_SSE4_2 */ + +/* Fallback definition of target attribute */ +#ifndef PG_FUNCTION_TARGET_SSE4_2 +#define PG_FUNCTION_TARGET_SSE4_2 +#endif + +#ifndef PG_COMPILE_SSE4_2 +#define PG_COMPILE_SSE4_2 0 +#endif + +#endif /* ~PG_PLATFORM_H */ diff --git a/venv/include/site/python3.12/pygame/include/pygame.h b/venv/include/site/python3.12/pygame/include/pygame.h new file mode 100644 index 00000000..3772ae6a --- /dev/null +++ b/venv/include/site/python3.12/pygame/include/pygame.h @@ -0,0 +1,34 @@ +/* + pygame - Python Game Library + Copyright (C) 2000-2001 Pete Shinners + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public + License along with this library; if not, write to the Free + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + + Pete Shinners + pete@shinners.org +*/ + +/* To allow the Pygame C api to be globally shared by all code within an + * extension module built from multiple C files, only include the pygame.h + * header within the top level C file, the one which calls the + * 'import_pygame_*' macros. All other C source files of the module should + * include _pygame.h instead. + */ +#ifndef PYGAME_H +#define PYGAME_H + +#include "_pygame.h" + +#endif diff --git a/venv/include/site/python3.12/pygame/include/pygame_bufferproxy.h b/venv/include/site/python3.12/pygame/include/pygame_bufferproxy.h new file mode 100644 index 00000000..9284ff29 --- /dev/null +++ b/venv/include/site/python3.12/pygame/include/pygame_bufferproxy.h @@ -0,0 +1,56 @@ +/* + pygame - Python Game Library + Copyright (C) 2000-2001 Pete Shinners + Copyright (C) 2007 Rene Dudfield, Richard Goedeken + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public + License along with this library; if not, write to the Free + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + + Pete Shinners + pete@shinners.org +*/ + +/* Bufferproxy module C api. */ +#if !defined(PG_BUFPROXY_HEADER) +#define PG_BUFPROXY_HEADER + +#include + +typedef PyObject *(*_pgbufproxy_new_t)(PyObject *, getbufferproc); +typedef PyObject *(*_pgbufproxy_get_obj_t)(PyObject *); +typedef int (*_pgbufproxy_trip_t)(PyObject *); + +#ifndef PYGAMEAPI_BUFPROXY_INTERNAL + +#include "pgimport.h" + +PYGAMEAPI_DEFINE_SLOTS(bufferproxy); + +#define pgBufproxy_Type (*(PyTypeObject *)PYGAMEAPI_GET_SLOT(bufferproxy, 0)) + +#define pgBufproxy_Check(x) ((x)->ob_type == &pgBufproxy_Type) + +#define pgBufproxy_New (*(_pgbufproxy_new_t)PYGAMEAPI_GET_SLOT(bufferproxy, 1)) + +#define pgBufproxy_GetParent \ + (*(_pgbufproxy_get_obj_t)PYGAMEAPI_GET_SLOT(bufferproxy, 2)) + +#define pgBufproxy_Trip \ + (*(_pgbufproxy_trip_t)PYGAMEAPI_GET_SLOT(bufferproxy, 3)) + +#define import_pygame_bufferproxy() _IMPORT_PYGAME_MODULE(bufferproxy) + +#endif /* ~PYGAMEAPI_BUFPROXY_INTERNAL */ + +#endif /* ~defined(PG_BUFPROXY_HEADER) */ diff --git a/venv/include/site/python3.12/pygame/include/pygame_font.h b/venv/include/site/python3.12/pygame/include/pygame_font.h new file mode 100644 index 00000000..aae41bf9 --- /dev/null +++ b/venv/include/site/python3.12/pygame/include/pygame_font.h @@ -0,0 +1,50 @@ +/* + pygame - Python Game Library + Copyright (C) 2000-2001 Pete Shinners + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public + License along with this library; if not, write to the Free + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + + Pete Shinners + pete@shinners.org +*/ + +#include +#include "pgplatform.h" + +struct TTF_Font; + +typedef struct { + PyObject_HEAD TTF_Font *font; + PyObject *weakreflist; + unsigned int ttf_init_generation; +} PyFontObject; +#define PyFont_AsFont(x) (((PyFontObject *)x)->font) + +#ifndef PYGAMEAPI_FONT_INTERNAL + +#include "pgimport.h" + +PYGAMEAPI_DEFINE_SLOTS(font); + +#define PyFont_Type (*(PyTypeObject *)PYGAMEAPI_GET_SLOT(font, 0)) +#define PyFont_Check(x) ((x)->ob_type == &PyFont_Type) + +#define PyFont_New (*(PyObject * (*)(TTF_Font *)) PYGAMEAPI_GET_SLOT(font, 1)) + +/*slot 2 taken by FONT_INIT_CHECK*/ + +#define import_pygame_font() _IMPORT_PYGAME_MODULE(font) + +#endif diff --git a/venv/include/site/python3.12/pygame/include/pygame_freetype.h b/venv/include/site/python3.12/pygame/include/pygame_freetype.h new file mode 100644 index 00000000..90172ccf --- /dev/null +++ b/venv/include/site/python3.12/pygame/include/pygame_freetype.h @@ -0,0 +1,42 @@ +/* + pygame - Python Game Library + Copyright (C) 2009 Vicent Marti + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public + License along with this library; if not, write to the Free + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + +*/ +#ifndef PYGAME_FREETYPE_H_ +#define PYGAME_FREETYPE_H_ + +#include "pgplatform.h" +#include "pgimport.h" +#include "pgcompat.h" + +#ifndef PYGAME_FREETYPE_INTERNAL + +PYGAMEAPI_DEFINE_SLOTS(_freetype); + +#define pgFont_Type (*(PyTypeObject *)PYGAMEAPI_GET_SLOT(_freetype, 0)) + +#define pgFont_Check(x) ((x)->ob_type == &pgFont_Type) + +#define pgFont_New \ + (*(PyObject * (*)(const char *, long)) PYGAMEAPI_GET_SLOT(_freetype, 1)) + +#define import_pygame_freetype() _IMPORT_PYGAME_MODULE(_freetype) + +#endif /* PYGAME_FREETYPE_INTERNAL */ + +#endif /* PYGAME_FREETYPE_H_ */ diff --git a/venv/include/site/python3.12/pygame/include/pygame_mask.h b/venv/include/site/python3.12/pygame/include/pygame_mask.h new file mode 100644 index 00000000..8dd8f170 --- /dev/null +++ b/venv/include/site/python3.12/pygame/include/pygame_mask.h @@ -0,0 +1,45 @@ +/* + pygame - Python Game Library + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public + License along with this library; if not, write to the Free + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +*/ + +#ifndef PGMASK_H +#define PGMASK_H + +#include +#include "bitmask.h" + +typedef struct { + PyObject_HEAD bitmask_t *mask; + void *bufdata; +} pgMaskObject; + +#define pgMask_AsBitmap(x) (((pgMaskObject *)x)->mask) + +#ifndef PYGAMEAPI_MASK_INTERNAL + +#include "pgimport.h" + +PYGAMEAPI_DEFINE_SLOTS(mask); + +#define pgMask_Type (*(PyTypeObject *)PYGAMEAPI_GET_SLOT(mask, 0)) +#define pgMask_Check(x) ((x)->ob_type == &pgMask_Type) + +#define import_pygame_mask() _IMPORT_PYGAME_MODULE(mask) + +#endif /* ~PYGAMEAPI_MASK_INTERNAL */ + +#endif /* ~PGMASK_H */ diff --git a/venv/include/site/python3.12/pygame/include/pygame_mixer.h b/venv/include/site/python3.12/pygame/include/pygame_mixer.h new file mode 100644 index 00000000..e19d273b --- /dev/null +++ b/venv/include/site/python3.12/pygame/include/pygame_mixer.h @@ -0,0 +1,71 @@ +/* + pygame - Python Game Library + Copyright (C) 2000-2001 Pete Shinners + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public + License along with this library; if not, write to the Free + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + + Pete Shinners + pete@shinners.org +*/ + +#ifndef PGMIXER_H +#define PGMIXER_H + +#include +#include + +#include "pgcompat.h" + +struct Mix_Chunk; + +typedef struct { + PyObject_HEAD Mix_Chunk *chunk; + Uint8 *mem; + PyObject *weakreflist; +} pgSoundObject; + +typedef struct { + PyObject_HEAD int chan; +} pgChannelObject; + +#define pgSound_AsChunk(x) (((pgSoundObject *)x)->chunk) +#define pgChannel_AsInt(x) (((pgChannelObject *)x)->chan) + +#include "pgimport.h" + +#ifndef PYGAMEAPI_MIXER_INTERNAL + +PYGAMEAPI_DEFINE_SLOTS(mixer); + +#define pgSound_Type (*(PyTypeObject *)PYGAMEAPI_GET_SLOT(mixer, 0)) + +#define pgSound_Check(x) ((x)->ob_type == &pgSound_Type) + +#define pgSound_New \ + (*(PyObject * (*)(Mix_Chunk *)) PYGAMEAPI_GET_SLOT(mixer, 1)) + +#define pgSound_Play \ + (*(PyObject * (*)(PyObject *, PyObject *)) PYGAMEAPI_GET_SLOT(mixer, 2)) + +#define pgChannel_Type (*(PyTypeObject *)PYGAMEAPI_GET_SLOT(mixer, 3)) +#define pgChannel_Check(x) ((x)->ob_type == &pgChannel_Type) + +#define pgChannel_New (*(PyObject * (*)(int)) PYGAMEAPI_GET_SLOT(mixer, 4)) + +#define import_pygame_mixer() _IMPORT_PYGAME_MODULE(mixer) + +#endif /* PYGAMEAPI_MIXER_INTERNAL */ + +#endif /* ~PGMIXER_H */ diff --git a/venv/include/site/python3.12/pygame/include/sse2neon.h b/venv/include/site/python3.12/pygame/include/sse2neon.h new file mode 100644 index 00000000..a3e3ac0d --- /dev/null +++ b/venv/include/site/python3.12/pygame/include/sse2neon.h @@ -0,0 +1,6203 @@ +#ifndef SSE2NEON_H +#define SSE2NEON_H + +// This header file provides a simple API translation layer +// between SSE intrinsics to their corresponding Arm/Aarch64 NEON versions +// +// This header file does not yet translate all of the SSE intrinsics. +// +// Contributors to this work are: +// John W. Ratcliff +// Brandon Rowlett +// Ken Fast +// Eric van Beurden +// Alexander Potylitsin +// Hasindu Gamaarachchi +// Jim Huang +// Mark Cheng +// Malcolm James MacLeod +// Devin Hussey (easyaspi314) +// Sebastian Pop +// Developer Ecosystem Engineering +// Danila Kutenin +// François Turban (JishinMaster) +// Pei-Hsuan Hung +// Yang-Hao Yuan + +/* + * sse2neon is freely redistributable under the MIT License. + * + * 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. + */ + +/* Tunable configurations */ + +/* Enable precise implementation of _mm_min_ps and _mm_max_ps + * This would slow down the computation a bit, but gives consistent result with + * x86 SSE2. (e.g. would solve a hole or NaN pixel in the rendering result) + */ +#ifndef SSE2NEON_PRECISE_MINMAX +#define SSE2NEON_PRECISE_MINMAX (0) +#endif + +#if defined(__GNUC__) || defined(__clang__) +#pragma push_macro("FORCE_INLINE") +#pragma push_macro("ALIGN_STRUCT") +#define FORCE_INLINE static inline __attribute__((always_inline)) +#define ALIGN_STRUCT(x) __attribute__((aligned(x))) +#else +#error "Macro name collisions may happen with unsupported compiler." +#ifdef FORCE_INLINE +#undef FORCE_INLINE +#endif +#define FORCE_INLINE static inline +#ifndef ALIGN_STRUCT +#define ALIGN_STRUCT(x) __declspec(align(x)) +#endif +#endif + +#include +#include + +// These cause the build to fail on raspberry pi with 'unsupported target' +// and don't seem to do anything particularly useful +///* Architecture-specific build options */ +///* FIXME: #pragma GCC push_options is only available on GCC */ +//#if defined(__GNUC__) +//#if defined(__arm__) && __ARM_ARCH == 7 +///* According to ARM C Language Extensions Architecture specification, +// * __ARM_NEON is defined to a value indicating the Advanced SIMD (NEON) +// * architecture supported. +// */ +//#if !defined(__ARM_NEON) || !defined(__ARM_NEON__) +//#error "You must enable NEON instructions (e.g. -mfpu=neon) to use SSE2NEON." +//#endif +//#pragma GCC push_options +//#pragma GCC target("fpu=neon") +//#elif defined(__aarch64__) +//#pragma GCC push_options +//#pragma GCC target("+simd") +//#else +//#error "Unsupported target. Must be either ARMv7-A+NEON or ARMv8-A." +//#endif +//#endif + +#include + +/* Rounding functions require either Aarch64 instructions or libm failback */ +#if !defined(__aarch64__) +#include +#endif + +/* "__has_builtin" can be used to query support for built-in functions + * provided by gcc/clang and other compilers that support it. + */ +#ifndef __has_builtin /* GCC prior to 10 or non-clang compilers */ +/* Compatibility with gcc <= 9 */ +#if __GNUC__ <= 9 +#define __has_builtin(x) HAS##x +#define HAS__builtin_popcount 1 +#define HAS__builtin_popcountll 1 +#else +#define __has_builtin(x) 0 +#endif +#endif + +/** + * MACRO for shuffle parameter for _mm_shuffle_ps(). + * Argument fp3 is a digit[0123] that represents the fp from argument "b" + * of mm_shuffle_ps that will be placed in fp3 of result. fp2 is the same + * for fp2 in result. fp1 is a digit[0123] that represents the fp from + * argument "a" of mm_shuffle_ps that will be places in fp1 of result. + * fp0 is the same for fp0 of result. + */ +#define _MM_SHUFFLE(fp3, fp2, fp1, fp0) \ + (((fp3) << 6) | ((fp2) << 4) | ((fp1) << 2) | ((fp0))) + +/* Rounding mode macros. */ +#define _MM_FROUND_TO_NEAREST_INT 0x00 +#define _MM_FROUND_TO_NEG_INF 0x01 +#define _MM_FROUND_TO_POS_INF 0x02 +#define _MM_FROUND_TO_ZERO 0x03 +#define _MM_FROUND_CUR_DIRECTION 0x04 +#define _MM_FROUND_NO_EXC 0x08 + +/* indicate immediate constant argument in a given range */ +#define __constrange(a, b) const + +/* A few intrinsics accept traditional data types like ints or floats, but + * most operate on data types that are specific to SSE. + * If a vector type ends in d, it contains doubles, and if it does not have + * a suffix, it contains floats. An integer vector type can contain any type + * of integer, from chars to shorts to unsigned long longs. + */ +typedef int64x1_t __m64; +typedef float32x4_t __m128; /* 128-bit vector containing 4 floats */ +// On ARM 32-bit architecture, the float64x2_t is not supported. +// The data type __m128d should be represented in a different way for related +// intrinsic conversion. +#if defined(__aarch64__) +typedef float64x2_t __m128d; /* 128-bit vector containing 2 doubles */ +#else +typedef float32x4_t __m128d; +#endif +typedef int64x2_t __m128i; /* 128-bit vector containing integers */ + +/* type-safe casting between types */ + +#define vreinterpretq_m128_f16(x) vreinterpretq_f32_f16(x) +#define vreinterpretq_m128_f32(x) (x) +#define vreinterpretq_m128_f64(x) vreinterpretq_f32_f64(x) + +#define vreinterpretq_m128_u8(x) vreinterpretq_f32_u8(x) +#define vreinterpretq_m128_u16(x) vreinterpretq_f32_u16(x) +#define vreinterpretq_m128_u32(x) vreinterpretq_f32_u32(x) +#define vreinterpretq_m128_u64(x) vreinterpretq_f32_u64(x) + +#define vreinterpretq_m128_s8(x) vreinterpretq_f32_s8(x) +#define vreinterpretq_m128_s16(x) vreinterpretq_f32_s16(x) +#define vreinterpretq_m128_s32(x) vreinterpretq_f32_s32(x) +#define vreinterpretq_m128_s64(x) vreinterpretq_f32_s64(x) + +#define vreinterpretq_f16_m128(x) vreinterpretq_f16_f32(x) +#define vreinterpretq_f32_m128(x) (x) +#define vreinterpretq_f64_m128(x) vreinterpretq_f64_f32(x) + +#define vreinterpretq_u8_m128(x) vreinterpretq_u8_f32(x) +#define vreinterpretq_u16_m128(x) vreinterpretq_u16_f32(x) +#define vreinterpretq_u32_m128(x) vreinterpretq_u32_f32(x) +#define vreinterpretq_u64_m128(x) vreinterpretq_u64_f32(x) + +#define vreinterpretq_s8_m128(x) vreinterpretq_s8_f32(x) +#define vreinterpretq_s16_m128(x) vreinterpretq_s16_f32(x) +#define vreinterpretq_s32_m128(x) vreinterpretq_s32_f32(x) +#define vreinterpretq_s64_m128(x) vreinterpretq_s64_f32(x) + +#define vreinterpretq_m128i_s8(x) vreinterpretq_s64_s8(x) +#define vreinterpretq_m128i_s16(x) vreinterpretq_s64_s16(x) +#define vreinterpretq_m128i_s32(x) vreinterpretq_s64_s32(x) +#define vreinterpretq_m128i_s64(x) (x) + +#define vreinterpretq_m128i_u8(x) vreinterpretq_s64_u8(x) +#define vreinterpretq_m128i_u16(x) vreinterpretq_s64_u16(x) +#define vreinterpretq_m128i_u32(x) vreinterpretq_s64_u32(x) +#define vreinterpretq_m128i_u64(x) vreinterpretq_s64_u64(x) + +#define vreinterpretq_s8_m128i(x) vreinterpretq_s8_s64(x) +#define vreinterpretq_s16_m128i(x) vreinterpretq_s16_s64(x) +#define vreinterpretq_s32_m128i(x) vreinterpretq_s32_s64(x) +#define vreinterpretq_s64_m128i(x) (x) + +#define vreinterpretq_u8_m128i(x) vreinterpretq_u8_s64(x) +#define vreinterpretq_u16_m128i(x) vreinterpretq_u16_s64(x) +#define vreinterpretq_u32_m128i(x) vreinterpretq_u32_s64(x) +#define vreinterpretq_u64_m128i(x) vreinterpretq_u64_s64(x) + +#define vreinterpret_m64_s8(x) vreinterpret_s64_s8(x) +#define vreinterpret_m64_s16(x) vreinterpret_s64_s16(x) +#define vreinterpret_m64_s32(x) vreinterpret_s64_s32(x) +#define vreinterpret_m64_s64(x) (x) + +#define vreinterpret_m64_u8(x) vreinterpret_s64_u8(x) +#define vreinterpret_m64_u16(x) vreinterpret_s64_u16(x) +#define vreinterpret_m64_u32(x) vreinterpret_s64_u32(x) +#define vreinterpret_m64_u64(x) vreinterpret_s64_u64(x) + +#define vreinterpret_m64_f16(x) vreinterpret_s64_f16(x) +#define vreinterpret_m64_f32(x) vreinterpret_s64_f32(x) +#define vreinterpret_m64_f64(x) vreinterpret_s64_f64(x) + +#define vreinterpret_u8_m64(x) vreinterpret_u8_s64(x) +#define vreinterpret_u16_m64(x) vreinterpret_u16_s64(x) +#define vreinterpret_u32_m64(x) vreinterpret_u32_s64(x) +#define vreinterpret_u64_m64(x) vreinterpret_u64_s64(x) + +#define vreinterpret_s8_m64(x) vreinterpret_s8_s64(x) +#define vreinterpret_s16_m64(x) vreinterpret_s16_s64(x) +#define vreinterpret_s32_m64(x) vreinterpret_s32_s64(x) +#define vreinterpret_s64_m64(x) (x) + +#define vreinterpret_f32_m64(x) vreinterpret_f32_s64(x) + +#if defined(__aarch64__) +#define vreinterpretq_m128d_s32(x) vreinterpretq_f64_s32(x) +#define vreinterpretq_m128d_s64(x) vreinterpretq_f64_s64(x) + +#define vreinterpretq_m128d_f64(x) (x) + +#define vreinterpretq_s64_m128d(x) vreinterpretq_s64_f64(x) + +#define vreinterpretq_f64_m128d(x) (x) +#else +#define vreinterpretq_m128d_s32(x) vreinterpretq_f32_s32(x) +#define vreinterpretq_m128d_s64(x) vreinterpretq_f32_s64(x) + +#define vreinterpretq_m128d_f32(x) (x) + +#define vreinterpretq_s64_m128d(x) vreinterpretq_s64_f32(x) + +#define vreinterpretq_f32_m128d(x) (x) +#endif + +// A struct is defined in this header file called 'SIMDVec' which can be used +// by applications which attempt to access the contents of an _m128 struct +// directly. It is important to note that accessing the __m128 struct directly +// is bad coding practice by Microsoft: @see: +// https://msdn.microsoft.com/en-us/library/ayeb3ayc.aspx +// +// However, some legacy source code may try to access the contents of an __m128 +// struct directly so the developer can use the SIMDVec as an alias for it. Any +// casting must be done manually by the developer, as you cannot cast or +// otherwise alias the base NEON data type for intrinsic operations. +// +// union intended to allow direct access to an __m128 variable using the names +// that the MSVC compiler provides. This union should really only be used when +// trying to access the members of the vector as integer values. GCC/clang +// allow native access to the float members through a simple array access +// operator (in C since 4.6, in C++ since 4.8). +// +// Ideally direct accesses to SIMD vectors should not be used since it can cause +// a performance hit. If it really is needed however, the original __m128 +// variable can be aliased with a pointer to this union and used to access +// individual components. The use of this union should be hidden behind a macro +// that is used throughout the codebase to access the members instead of always +// declaring this type of variable. +typedef union ALIGN_STRUCT(16) SIMDVec { + float m128_f32[4]; // as floats - DON'T USE. Added for convenience. + int8_t m128_i8[16]; // as signed 8-bit integers. + int16_t m128_i16[8]; // as signed 16-bit integers. + int32_t m128_i32[4]; // as signed 32-bit integers. + int64_t m128_i64[2]; // as signed 64-bit integers. + uint8_t m128_u8[16]; // as unsigned 8-bit integers. + uint16_t m128_u16[8]; // as unsigned 16-bit integers. + uint32_t m128_u32[4]; // as unsigned 32-bit integers. + uint64_t m128_u64[2]; // as unsigned 64-bit integers. +} SIMDVec; + +// casting using SIMDVec +#define vreinterpretq_nth_u64_m128i(x, n) (((SIMDVec *) &x)->m128_u64[n]) +#define vreinterpretq_nth_u32_m128i(x, n) (((SIMDVec *) &x)->m128_u32[n]) +#define vreinterpretq_nth_u8_m128i(x, n) (((SIMDVec *) &x)->m128_u8[n]) + +/* Backwards compatibility for compilers with lack of specific type support */ + +// Older gcc does not define vld1q_u8_x4 type +#if defined(__GNUC__) && !defined(__clang__) +#if __GNUC__ <= 9 +FORCE_INLINE uint8x16x4_t vld1q_u8_x4(const uint8_t *p) +{ + uint8x16x4_t ret; + ret.val[0] = vld1q_u8(p + 0); + ret.val[1] = vld1q_u8(p + 16); + ret.val[2] = vld1q_u8(p + 32); + ret.val[3] = vld1q_u8(p + 48); + return ret; +} +#endif +#endif + +/* Function Naming Conventions + * The naming convention of SSE intrinsics is straightforward. A generic SSE + * intrinsic function is given as follows: + * _mm__ + * + * The parts of this format are given as follows: + * 1. describes the operation performed by the intrinsic + * 2. identifies the data type of the function's primary arguments + * + * This last part, , is a little complicated. It identifies the + * content of the input values, and can be set to any of the following values: + * + ps - vectors contain floats (ps stands for packed single-precision) + * + pd - vectors cantain doubles (pd stands for packed double-precision) + * + epi8/epi16/epi32/epi64 - vectors contain 8-bit/16-bit/32-bit/64-bit + * signed integers + * + epu8/epu16/epu32/epu64 - vectors contain 8-bit/16-bit/32-bit/64-bit + * unsigned integers + * + si128 - unspecified 128-bit vector or 256-bit vector + * + m128/m128i/m128d - identifies input vector types when they are different + * than the type of the returned vector + * + * For example, _mm_setzero_ps. The _mm implies that the function returns + * a 128-bit vector. The _ps at the end implies that the argument vectors + * contain floats. + * + * A complete example: Byte Shuffle - pshufb (_mm_shuffle_epi8) + * // Set packed 16-bit integers. 128 bits, 8 short, per 16 bits + * __m128i v_in = _mm_setr_epi16(1, 2, 3, 4, 5, 6, 7, 8); + * // Set packed 8-bit integers + * // 128 bits, 16 chars, per 8 bits + * __m128i v_perm = _mm_setr_epi8(1, 0, 2, 3, 8, 9, 10, 11, + * 4, 5, 12, 13, 6, 7, 14, 15); + * // Shuffle packed 8-bit integers + * __m128i v_out = _mm_shuffle_epi8(v_in, v_perm); // pshufb + * + * Data (Number, Binary, Byte Index): + +------+------+-------------+------+------+-------------+ + | 1 | 2 | 3 | 4 | Number + +------+------+------+------+------+------+------+------+ + | 0000 | 0001 | 0000 | 0010 | 0000 | 0011 | 0000 | 0100 | Binary + +------+------+------+------+------+------+------+------+ + | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | Index + +------+------+------+------+------+------+------+------+ + + +------+------+------+------+------+------+------+------+ + | 5 | 6 | 7 | 8 | Number + +------+------+------+------+------+------+------+------+ + | 0000 | 0101 | 0000 | 0110 | 0000 | 0111 | 0000 | 1000 | Binary + +------+------+------+------+------+------+------+------+ + | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | Index + +------+------+------+------+------+------+------+------+ + * Index (Byte Index): + +------+------+------+------+------+------+------+------+ + | 1 | 0 | 2 | 3 | 8 | 9 | 10 | 11 | + +------+------+------+------+------+------+------+------+ + + +------+------+------+------+------+------+------+------+ + | 4 | 5 | 12 | 13 | 6 | 7 | 14 | 15 | + +------+------+------+------+------+------+------+------+ + * Result: + +------+------+------+------+------+------+------+------+ + | 1 | 0 | 2 | 3 | 8 | 9 | 10 | 11 | Index + +------+------+------+------+------+------+------+------+ + | 0001 | 0000 | 0000 | 0010 | 0000 | 0101 | 0000 | 0110 | Binary + +------+------+------+------+------+------+------+------+ + | 256 | 2 | 5 | 6 | Number + +------+------+------+------+------+------+------+------+ + + +------+------+------+------+------+------+------+------+ + | 4 | 5 | 12 | 13 | 6 | 7 | 14 | 15 | Index + +------+------+------+------+------+------+------+------+ + | 0000 | 0011 | 0000 | 0111 | 0000 | 0100 | 0000 | 1000 | Binary + +------+------+------+------+------+------+------+------+ + | 3 | 7 | 4 | 8 | Number + +------+------+------+------+------+------+-------------+ + */ + +/* Set/get methods */ + +/* Constants for use with _mm_prefetch. */ +enum _mm_hint { + _MM_HINT_NTA = 0, /* load data to L1 and L2 cache, mark it as NTA */ + _MM_HINT_T0 = 1, /* load data to L1 and L2 cache */ + _MM_HINT_T1 = 2, /* load data to L2 cache only */ + _MM_HINT_T2 = 3, /* load data to L2 cache only, mark it as NTA */ + _MM_HINT_ENTA = 4, /* exclusive version of _MM_HINT_NTA */ + _MM_HINT_ET0 = 5, /* exclusive version of _MM_HINT_T0 */ + _MM_HINT_ET1 = 6, /* exclusive version of _MM_HINT_T1 */ + _MM_HINT_ET2 = 7 /* exclusive version of _MM_HINT_T2 */ +}; + +// Loads one cache line of data from address p to a location closer to the +// processor. https://msdn.microsoft.com/en-us/library/84szxsww(v=vs.100).aspx +FORCE_INLINE void _mm_prefetch(const void *p, int i) +{ + (void) i; + __builtin_prefetch(p); +} + +// Copy the lower single-precision (32-bit) floating-point element of a to dst. +// +// dst[31:0] := a[31:0] +// +// https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_cvtss_f32 +FORCE_INLINE float _mm_cvtss_f32(__m128 a) +{ + return vgetq_lane_f32(vreinterpretq_f32_m128(a), 0); +} + +// Convert the lower single-precision (32-bit) floating-point element in a to a +// 32-bit integer, and store the result in dst. +// +// dst[31:0] := Convert_FP32_To_Int32(a[31:0]) +// +// https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_cvtss_si32 +#define _mm_cvtss_si32(a) _mm_cvt_ss2si(a) + +// Convert the lower single-precision (32-bit) floating-point element in a to a +// 64-bit integer, and store the result in dst. +// +// dst[63:0] := Convert_FP32_To_Int64(a[31:0]) +// +// https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_cvtss_si64 +FORCE_INLINE int _mm_cvtss_si64(__m128 a) +{ +#if defined(__aarch64__) + return vgetq_lane_s64( + vreinterpretq_s64_s32(vcvtnq_s32_f32(vreinterpretq_f32_m128(a))), 0); +#else + float32_t data = vgetq_lane_f32(vreinterpretq_f32_m128(a), 0); + float32_t diff = data - floor(data); + if (diff > 0.5) + return (int64_t) ceil(data); + if (diff == 0.5) { + int64_t f = (int64_t) floor(data); + int64_t c = (int64_t) ceil(data); + return c & 1 ? f : c; + } + return (int64_t) floor(data); +#endif +} + +// Convert packed single-precision (32-bit) floating-point elements in a to +// packed 32-bit integers with truncation, and store the results in dst. +// +// FOR j := 0 to 1 +// i := 32*j +// dst[i+31:i] := Convert_FP32_To_Int32_Truncate(a[i+31:i]) +// ENDFOR +// +// https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_cvtt_ps2pi +FORCE_INLINE __m64 _mm_cvtt_ps2pi(__m128 a) +{ + return vreinterpret_m64_s32( + vget_low_s32(vcvtq_s32_f32(vreinterpretq_f32_m128(a)))); +} + +// Convert the lower single-precision (32-bit) floating-point element in a to a +// 32-bit integer with truncation, and store the result in dst. +// +// dst[31:0] := Convert_FP32_To_Int32_Truncate(a[31:0]) +// +// https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_cvtt_ss2si +FORCE_INLINE int _mm_cvtt_ss2si(__m128 a) +{ + return vgetq_lane_s32(vcvtq_s32_f32(vreinterpretq_f32_m128(a)), 0); +} + +// Convert packed single-precision (32-bit) floating-point elements in a to +// packed 32-bit integers with truncation, and store the results in dst. +// +// FOR j := 0 to 1 +// i := 32*j +// dst[i+31:i] := Convert_FP32_To_Int32_Truncate(a[i+31:i]) +// ENDFOR +// +// https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_cvttps_pi32 +#define _mm_cvttps_pi32(a) _mm_cvtt_ps2pi(a) + +// Convert the lower single-precision (32-bit) floating-point element in a to a +// 32-bit integer with truncation, and store the result in dst. +// +// dst[31:0] := Convert_FP32_To_Int32_Truncate(a[31:0]) +// +// https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_cvttss_si32 +#define _mm_cvttss_si32(a) _mm_cvtt_ss2si(a) + +// Convert the lower single-precision (32-bit) floating-point element in a to a +// 64-bit integer with truncation, and store the result in dst. +// +// dst[63:0] := Convert_FP32_To_Int64_Truncate(a[31:0]) +// +// https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_cvttss_si64 +FORCE_INLINE int64_t _mm_cvttss_si64(__m128 a) +{ + return vgetq_lane_s64( + vmovl_s32(vget_low_s32(vcvtq_s32_f32(vreinterpretq_f32_m128(a)))), 0); +} + +// Sets the 128-bit value to zero +// https://msdn.microsoft.com/en-us/library/vstudio/ys7dw0kh(v=vs.100).aspx +FORCE_INLINE __m128i _mm_setzero_si128(void) +{ + return vreinterpretq_m128i_s32(vdupq_n_s32(0)); +} + +// Clears the four single-precision, floating-point values. +// https://msdn.microsoft.com/en-us/library/vstudio/tk1t2tbz(v=vs.100).aspx +FORCE_INLINE __m128 _mm_setzero_ps(void) +{ + return vreinterpretq_m128_f32(vdupq_n_f32(0)); +} + +// Return vector of type __m128d with all elements set to zero. +// https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_setzero_pd +FORCE_INLINE __m128d _mm_setzero_pd(void) +{ +#if defined(__aarch64__) + return vreinterpretq_m128d_f64(vdupq_n_f64(0)); +#else + return vreinterpretq_m128d_f32(vdupq_n_f32(0)); +#endif +} + +// Sets the four single-precision, floating-point values to w. +// +// r0 := r1 := r2 := r3 := w +// +// https://msdn.microsoft.com/en-us/library/vstudio/2x1se8ha(v=vs.100).aspx +FORCE_INLINE __m128 _mm_set1_ps(float _w) +{ + return vreinterpretq_m128_f32(vdupq_n_f32(_w)); +} + +// Sets the four single-precision, floating-point values to w. +// https://msdn.microsoft.com/en-us/library/vstudio/2x1se8ha(v=vs.100).aspx +FORCE_INLINE __m128 _mm_set_ps1(float _w) +{ + return vreinterpretq_m128_f32(vdupq_n_f32(_w)); +} + +// Sets the four single-precision, floating-point values to the four inputs. +// https://msdn.microsoft.com/en-us/library/vstudio/afh0zf75(v=vs.100).aspx +FORCE_INLINE __m128 _mm_set_ps(float w, float z, float y, float x) +{ + float ALIGN_STRUCT(16) data[4] = {x, y, z, w}; + return vreinterpretq_m128_f32(vld1q_f32(data)); +} + +// Copy single-precision (32-bit) floating-point element a to the lower element +// of dst, and zero the upper 3 elements. +// https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_set_ss +FORCE_INLINE __m128 _mm_set_ss(float a) +{ + float ALIGN_STRUCT(16) data[4] = {a, 0, 0, 0}; + return vreinterpretq_m128_f32(vld1q_f32(data)); +} + +// Sets the four single-precision, floating-point values to the four inputs in +// reverse order. +// https://msdn.microsoft.com/en-us/library/vstudio/d2172ct3(v=vs.100).aspx +FORCE_INLINE __m128 _mm_setr_ps(float w, float z, float y, float x) +{ + float ALIGN_STRUCT(16) data[4] = {w, z, y, x}; + return vreinterpretq_m128_f32(vld1q_f32(data)); +} + +// Sets the 8 signed 16-bit integer values in reverse order. +// +// Return Value +// r0 := w0 +// r1 := w1 +// ... +// r7 := w7 +FORCE_INLINE __m128i _mm_setr_epi16(short w0, + short w1, + short w2, + short w3, + short w4, + short w5, + short w6, + short w7) +{ + int16_t ALIGN_STRUCT(16) data[8] = {w0, w1, w2, w3, w4, w5, w6, w7}; + return vreinterpretq_m128i_s16(vld1q_s16((int16_t *) data)); +} + +// Sets the 4 signed 32-bit integer values in reverse order +// https://technet.microsoft.com/en-us/library/security/27yb3ee5(v=vs.90).aspx +FORCE_INLINE __m128i _mm_setr_epi32(int i3, int i2, int i1, int i0) +{ + int32_t ALIGN_STRUCT(16) data[4] = {i3, i2, i1, i0}; + return vreinterpretq_m128i_s32(vld1q_s32(data)); +} + +// Set packed 64-bit integers in dst with the supplied values in reverse order. +// https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_setr_epi64 +FORCE_INLINE __m128i _mm_setr_epi64(__m64 e1, __m64 e0) +{ + return vreinterpretq_m128i_s64(vcombine_s64(e1, e0)); +} + +// Sets the 16 signed 8-bit integer values to b. +// +// r0 := b +// r1 := b +// ... +// r15 := b +// +// https://msdn.microsoft.com/en-us/library/6e14xhyf(v=vs.100).aspx +FORCE_INLINE __m128i _mm_set1_epi8(signed char w) +{ + return vreinterpretq_m128i_s8(vdupq_n_s8(w)); +} + +// Sets the 8 signed 16-bit integer values to w. +// +// r0 := w +// r1 := w +// ... +// r7 := w +// +// https://msdn.microsoft.com/en-us/library/k0ya3x0e(v=vs.90).aspx +FORCE_INLINE __m128i _mm_set1_epi16(short w) +{ + return vreinterpretq_m128i_s16(vdupq_n_s16(w)); +} + +// Sets the 16 signed 8-bit integer values. +// https://msdn.microsoft.com/en-us/library/x0cx8zd3(v=vs.90).aspx +FORCE_INLINE __m128i _mm_set_epi8(signed char b15, + signed char b14, + signed char b13, + signed char b12, + signed char b11, + signed char b10, + signed char b9, + signed char b8, + signed char b7, + signed char b6, + signed char b5, + signed char b4, + signed char b3, + signed char b2, + signed char b1, + signed char b0) +{ + int8_t ALIGN_STRUCT(16) + data[16] = {(int8_t) b0, (int8_t) b1, (int8_t) b2, (int8_t) b3, + (int8_t) b4, (int8_t) b5, (int8_t) b6, (int8_t) b7, + (int8_t) b8, (int8_t) b9, (int8_t) b10, (int8_t) b11, + (int8_t) b12, (int8_t) b13, (int8_t) b14, (int8_t) b15}; + return (__m128i) vld1q_s8(data); +} + +// Sets the 8 signed 16-bit integer values. +// https://msdn.microsoft.com/en-au/library/3e0fek84(v=vs.90).aspx +FORCE_INLINE __m128i _mm_set_epi16(short i7, + short i6, + short i5, + short i4, + short i3, + short i2, + short i1, + short i0) +{ + int16_t ALIGN_STRUCT(16) data[8] = {i0, i1, i2, i3, i4, i5, i6, i7}; + return vreinterpretq_m128i_s16(vld1q_s16(data)); +} + +// Sets the 16 signed 8-bit integer values in reverse order. +// https://msdn.microsoft.com/en-us/library/2khb9c7k(v=vs.90).aspx +FORCE_INLINE __m128i _mm_setr_epi8(signed char b0, + signed char b1, + signed char b2, + signed char b3, + signed char b4, + signed char b5, + signed char b6, + signed char b7, + signed char b8, + signed char b9, + signed char b10, + signed char b11, + signed char b12, + signed char b13, + signed char b14, + signed char b15) +{ + int8_t ALIGN_STRUCT(16) + data[16] = {(int8_t) b0, (int8_t) b1, (int8_t) b2, (int8_t) b3, + (int8_t) b4, (int8_t) b5, (int8_t) b6, (int8_t) b7, + (int8_t) b8, (int8_t) b9, (int8_t) b10, (int8_t) b11, + (int8_t) b12, (int8_t) b13, (int8_t) b14, (int8_t) b15}; + return (__m128i) vld1q_s8(data); +} + +// Sets the 4 signed 32-bit integer values to i. +// +// r0 := i +// r1 := i +// r2 := i +// r3 := I +// +// https://msdn.microsoft.com/en-us/library/vstudio/h4xscxat(v=vs.100).aspx +FORCE_INLINE __m128i _mm_set1_epi32(int _i) +{ + return vreinterpretq_m128i_s32(vdupq_n_s32(_i)); +} + +// Sets the 2 signed 64-bit integer values to i. +// https://docs.microsoft.com/en-us/previous-versions/visualstudio/visual-studio-2010/whtfzhzk(v=vs.100) +FORCE_INLINE __m128i _mm_set1_epi64(__m64 _i) +{ + return vreinterpretq_m128i_s64(vdupq_n_s64((int64_t) _i)); +} + +// Sets the 2 signed 64-bit integer values to i. +// https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_set1_epi64x +FORCE_INLINE __m128i _mm_set1_epi64x(int64_t _i) +{ + return vreinterpretq_m128i_s64(vdupq_n_s64(_i)); +} + +// Sets the 4 signed 32-bit integer values. +// https://msdn.microsoft.com/en-us/library/vstudio/019beekt(v=vs.100).aspx +FORCE_INLINE __m128i _mm_set_epi32(int i3, int i2, int i1, int i0) +{ + int32_t ALIGN_STRUCT(16) data[4] = {i0, i1, i2, i3}; + return vreinterpretq_m128i_s32(vld1q_s32(data)); +} + +// Returns the __m128i structure with its two 64-bit integer values +// initialized to the values of the two 64-bit integers passed in. +// https://msdn.microsoft.com/en-us/library/dk2sdw0h(v=vs.120).aspx +FORCE_INLINE __m128i _mm_set_epi64x(int64_t i1, int64_t i2) +{ + int64_t ALIGN_STRUCT(16) data[2] = {i2, i1}; + return vreinterpretq_m128i_s64(vld1q_s64(data)); +} + +// Returns the __m128i structure with its two 64-bit integer values +// initialized to the values of the two 64-bit integers passed in. +// https://msdn.microsoft.com/en-us/library/dk2sdw0h(v=vs.120).aspx +FORCE_INLINE __m128i _mm_set_epi64(__m64 i1, __m64 i2) +{ + return _mm_set_epi64x((int64_t) i1, (int64_t) i2); +} + +// Set packed double-precision (64-bit) floating-point elements in dst with the +// supplied values. +// https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_set_pd +FORCE_INLINE __m128d _mm_set_pd(double e1, double e0) +{ + double ALIGN_STRUCT(16) data[2] = {e0, e1}; +#if defined(__aarch64__) + return vreinterpretq_m128d_f64(vld1q_f64((float64_t *) data)); +#else + return vreinterpretq_m128d_f32(vld1q_f32((float32_t *) data)); +#endif +} + +// Stores four single-precision, floating-point values. +// https://msdn.microsoft.com/en-us/library/vstudio/s3h4ay6y(v=vs.100).aspx +FORCE_INLINE void _mm_store_ps(float *p, __m128 a) +{ + vst1q_f32(p, vreinterpretq_f32_m128(a)); +} + +// Stores four single-precision, floating-point values. +// https://msdn.microsoft.com/en-us/library/44e30x22(v=vs.100).aspx +FORCE_INLINE void _mm_storeu_ps(float *p, __m128 a) +{ + vst1q_f32(p, vreinterpretq_f32_m128(a)); +} + +// Stores four 32-bit integer values as (as a __m128i value) at the address p. +// https://msdn.microsoft.com/en-us/library/vstudio/edk11s13(v=vs.100).aspx +FORCE_INLINE void _mm_store_si128(__m128i *p, __m128i a) +{ + vst1q_s32((int32_t *) p, vreinterpretq_s32_m128i(a)); +} + +// Stores four 32-bit integer values as (as a __m128i value) at the address p. +// https://msdn.microsoft.com/en-us/library/vstudio/edk11s13(v=vs.100).aspx +FORCE_INLINE void _mm_storeu_si128(__m128i *p, __m128i a) +{ + vst1q_s32((int32_t *) p, vreinterpretq_s32_m128i(a)); +} + +// Stores the lower single - precision, floating - point value. +// https://msdn.microsoft.com/en-us/library/tzz10fbx(v=vs.100).aspx +FORCE_INLINE void _mm_store_ss(float *p, __m128 a) +{ + vst1q_lane_f32(p, vreinterpretq_f32_m128(a), 0); +} + +// Store 128-bits (composed of 2 packed double-precision (64-bit) floating-point +// elements) from a into memory. mem_addr must be aligned on a 16-byte boundary +// or a general-protection exception may be generated. +// https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_store_pd +FORCE_INLINE void _mm_store_pd(double *mem_addr, __m128d a) +{ +#if defined(__aarch64__) + vst1q_f64((float64_t *) mem_addr, vreinterpretq_f64_m128d(a)); +#else + vst1q_f32((float32_t *) mem_addr, vreinterpretq_f32_m128d(a)); +#endif +} + +// Store 128-bits (composed of 2 packed double-precision (64-bit) floating-point +// elements) from a into memory. mem_addr does not need to be aligned on any +// particular boundary. +// https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_storeu_pd +FORCE_INLINE void _mm_storeu_pd(double *mem_addr, __m128d a) +{ + _mm_store_pd(mem_addr, a); +} + +// Reads the lower 64 bits of b and stores them into the lower 64 bits of a. +// https://msdn.microsoft.com/en-us/library/hhwf428f%28v=vs.90%29.aspx +FORCE_INLINE void _mm_storel_epi64(__m128i *a, __m128i b) +{ + uint64x1_t hi = vget_high_u64(vreinterpretq_u64_m128i(*a)); + uint64x1_t lo = vget_low_u64(vreinterpretq_u64_m128i(b)); + *a = vreinterpretq_m128i_u64(vcombine_u64(lo, hi)); +} + +// Stores the lower two single-precision floating point values of a to the +// address p. +// +// *p0 := a0 +// *p1 := a1 +// +// https://msdn.microsoft.com/en-us/library/h54t98ks(v=vs.90).aspx +FORCE_INLINE void _mm_storel_pi(__m64 *p, __m128 a) +{ + *p = vreinterpret_m64_f32(vget_low_f32(a)); +} + +// Stores the upper two single-precision, floating-point values of a to the +// address p. +// +// *p0 := a2 +// *p1 := a3 +// +// https://msdn.microsoft.com/en-us/library/a7525fs8(v%3dvs.90).aspx +FORCE_INLINE void _mm_storeh_pi(__m64 *p, __m128 a) +{ + *p = vreinterpret_m64_f32(vget_high_f32(a)); +} + +// Loads a single single-precision, floating-point value, copying it into all +// four words +// https://msdn.microsoft.com/en-us/library/vstudio/5cdkf716(v=vs.100).aspx +FORCE_INLINE __m128 _mm_load1_ps(const float *p) +{ + return vreinterpretq_m128_f32(vld1q_dup_f32(p)); +} + +// Load a single-precision (32-bit) floating-point element from memory into all +// elements of dst. +// +// dst[31:0] := MEM[mem_addr+31:mem_addr] +// dst[63:32] := MEM[mem_addr+31:mem_addr] +// dst[95:64] := MEM[mem_addr+31:mem_addr] +// dst[127:96] := MEM[mem_addr+31:mem_addr] +// +// https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_load_ps1 +#define _mm_load_ps1 _mm_load1_ps + +// Sets the lower two single-precision, floating-point values with 64 +// bits of data loaded from the address p; the upper two values are passed +// through from a. +// +// Return Value +// r0 := *p0 +// r1 := *p1 +// r2 := a2 +// r3 := a3 +// +// https://msdn.microsoft.com/en-us/library/s57cyak2(v=vs.100).aspx +FORCE_INLINE __m128 _mm_loadl_pi(__m128 a, __m64 const *p) +{ + return vreinterpretq_m128_f32( + vcombine_f32(vld1_f32((const float32_t *) p), vget_high_f32(a))); +} + +// Load 4 single-precision (32-bit) floating-point elements from memory into dst +// in reverse order. mem_addr must be aligned on a 16-byte boundary or a +// general-protection exception may be generated. +// +// dst[31:0] := MEM[mem_addr+127:mem_addr+96] +// dst[63:32] := MEM[mem_addr+95:mem_addr+64] +// dst[95:64] := MEM[mem_addr+63:mem_addr+32] +// dst[127:96] := MEM[mem_addr+31:mem_addr] +// +// https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_loadr_ps +FORCE_INLINE __m128 _mm_loadr_ps(const float *p) +{ + float32x4_t v = vrev64q_f32(vld1q_f32(p)); + return vreinterpretq_m128_f32(vextq_f32(v, v, 2)); +} + +// Sets the upper two single-precision, floating-point values with 64 +// bits of data loaded from the address p; the lower two values are passed +// through from a. +// +// r0 := a0 +// r1 := a1 +// r2 := *p0 +// r3 := *p1 +// +// https://msdn.microsoft.com/en-us/library/w92wta0x(v%3dvs.100).aspx +FORCE_INLINE __m128 _mm_loadh_pi(__m128 a, __m64 const *p) +{ + return vreinterpretq_m128_f32( + vcombine_f32(vget_low_f32(a), vld1_f32((const float32_t *) p))); +} + +// Loads four single-precision, floating-point values. +// https://msdn.microsoft.com/en-us/library/vstudio/zzd50xxt(v=vs.100).aspx +FORCE_INLINE __m128 _mm_load_ps(const float *p) +{ + return vreinterpretq_m128_f32(vld1q_f32(p)); +} + +// Loads four single-precision, floating-point values. +// https://msdn.microsoft.com/en-us/library/x1b16s7z%28v=vs.90%29.aspx +FORCE_INLINE __m128 _mm_loadu_ps(const float *p) +{ + // for neon, alignment doesn't matter, so _mm_load_ps and _mm_loadu_ps are + // equivalent for neon + return vreinterpretq_m128_f32(vld1q_f32(p)); +} + +// Load unaligned 16-bit integer from memory into the first element of dst. +// +// dst[15:0] := MEM[mem_addr+15:mem_addr] +// dst[MAX:16] := 0 +// +// https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_loadu_si16 +FORCE_INLINE __m128i _mm_loadu_si16(const void *p) +{ + return vreinterpretq_m128i_s16( + vsetq_lane_s16(*(const int16_t *) p, vdupq_n_s16(0), 0)); +} + +// Load unaligned 64-bit integer from memory into the first element of dst. +// +// dst[63:0] := MEM[mem_addr+63:mem_addr] +// dst[MAX:64] := 0 +// +// https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_loadu_si64 +FORCE_INLINE __m128i _mm_loadu_si64(const void *p) +{ + return vreinterpretq_m128i_s64( + vcombine_s64(vld1_s64((const int64_t *) p), vdup_n_s64(0))); +} + +// Load a double-precision (64-bit) floating-point element from memory into the +// lower of dst, and zero the upper element. mem_addr does not need to be +// aligned on any particular boundary. +// +// dst[63:0] := MEM[mem_addr+63:mem_addr] +// dst[127:64] := 0 +// +// https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_load_sd +FORCE_INLINE __m128d _mm_load_sd(const double *p) +{ +#if defined(__aarch64__) + return vreinterpretq_m128d_f64(vsetq_lane_f64(*p, vdupq_n_f64(0), 0)); +#else + const float *fp = (const float *) p; + float ALIGN_STRUCT(16) data[4] = {fp[0], fp[1], 0, 0}; + return vreinterpretq_m128d_f32(vld1q_f32(data)); +#endif +} + +// Loads two double-precision from 16-byte aligned memory, floating-point +// values. +// +// dst[127:0] := MEM[mem_addr+127:mem_addr] +// +// https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_load_pd +FORCE_INLINE __m128d _mm_load_pd(const double *p) +{ +#if defined(__aarch64__) + return vreinterpretq_m128d_f64(vld1q_f64(p)); +#else + const float *fp = (const float *) p; + float ALIGN_STRUCT(16) data[4] = {fp[0], fp[1], fp[2], fp[3]}; + return vreinterpretq_m128d_f32(vld1q_f32(data)); +#endif +} + +// Loads two double-precision from unaligned memory, floating-point values. +// https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_loadu_pd +FORCE_INLINE __m128d _mm_loadu_pd(const double *p) +{ + return _mm_load_pd(p); +} + +// Loads an single - precision, floating - point value into the low word and +// clears the upper three words. +// https://msdn.microsoft.com/en-us/library/548bb9h4%28v=vs.90%29.aspx +FORCE_INLINE __m128 _mm_load_ss(const float *p) +{ + return vreinterpretq_m128_f32(vsetq_lane_f32(*p, vdupq_n_f32(0), 0)); +} + +FORCE_INLINE __m128i _mm_loadl_epi64(__m128i const *p) +{ + /* Load the lower 64 bits of the value pointed to by p into the + * lower 64 bits of the result, zeroing the upper 64 bits of the result. + */ + return vreinterpretq_m128i_s32( + vcombine_s32(vld1_s32((int32_t const *) p), vcreate_s32(0))); +} + +// Load a double-precision (64-bit) floating-point element from memory into the +// lower element of dst, and copy the upper element from a to dst. mem_addr does +// not need to be aligned on any particular boundary. +// +// dst[63:0] := MEM[mem_addr+63:mem_addr] +// dst[127:64] := a[127:64] +// +// https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_loadl_pd +FORCE_INLINE __m128d _mm_loadl_pd(__m128d a, const double *p) +{ +#if defined(__aarch64__) + return vreinterpretq_m128d_f64( + vcombine_f64(vld1_f64(p), vget_high_f64(vreinterpretq_f64_m128d(a)))); +#else + return vreinterpretq_m128d_f32( + vcombine_f32(vld1_f32((const float *) p), + vget_high_f32(vreinterpretq_f32_m128d(a)))); +#endif +} + +// Load 2 double-precision (64-bit) floating-point elements from memory into dst +// in reverse order. mem_addr must be aligned on a 16-byte boundary or a +// general-protection exception may be generated. +// +// dst[63:0] := MEM[mem_addr+127:mem_addr+64] +// dst[127:64] := MEM[mem_addr+63:mem_addr] +// +// https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_loadr_pd +FORCE_INLINE __m128d _mm_loadr_pd(const double *p) +{ +#if defined(__aarch64__) + float64x2_t v = vld1q_f64(p); + return vreinterpretq_m128d_f64(vextq_f64(v, v, 1)); +#else + int64x2_t v = vld1q_s64((const int64_t *) p); + return vreinterpretq_m128d_s64(vextq_s64(v, v, 1)); +#endif +} + +// Sets the low word to the single-precision, floating-point value of b +// https://docs.microsoft.com/en-us/previous-versions/visualstudio/visual-studio-2010/35hdzazd(v=vs.100) +FORCE_INLINE __m128 _mm_move_ss(__m128 a, __m128 b) +{ + return vreinterpretq_m128_f32( + vsetq_lane_f32(vgetq_lane_f32(vreinterpretq_f32_m128(b), 0), + vreinterpretq_f32_m128(a), 0)); +} + +// Copy the lower 64-bit integer in a to the lower element of dst, and zero the +// upper element. +// +// dst[63:0] := a[63:0] +// dst[127:64] := 0 +// +// https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_move_epi64 +FORCE_INLINE __m128i _mm_move_epi64(__m128i a) +{ + return vreinterpretq_m128i_s64( + vsetq_lane_s64(0, vreinterpretq_s64_m128i(a), 1)); +} + +// Return vector of type __m128 with undefined elements. +// https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_undefined_ps +FORCE_INLINE __m128 _mm_undefined_ps(void) +{ + __m128 a; + return a; +} + +/* Logic/Binary operations */ + +// Computes the bitwise AND-NOT of the four single-precision, floating-point +// values of a and b. +// +// r0 := ~a0 & b0 +// r1 := ~a1 & b1 +// r2 := ~a2 & b2 +// r3 := ~a3 & b3 +// +// https://msdn.microsoft.com/en-us/library/vstudio/68h7wd02(v=vs.100).aspx +FORCE_INLINE __m128 _mm_andnot_ps(__m128 a, __m128 b) +{ + return vreinterpretq_m128_s32( + vbicq_s32(vreinterpretq_s32_m128(b), + vreinterpretq_s32_m128(a))); // *NOTE* argument swap +} + +// Compute the bitwise NOT of packed double-precision (64-bit) floating-point +// elements in a and then AND with b, and store the results in dst. +// +// FOR j := 0 to 1 +// i := j*64 +// dst[i+63:i] := ((NOT a[i+63:i]) AND b[i+63:i]) +// ENDFOR +// +// https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_andnot_pd +FORCE_INLINE __m128d _mm_andnot_pd(__m128d a, __m128d b) +{ + // *NOTE* argument swap + return vreinterpretq_m128d_s64( + vbicq_s64(vreinterpretq_s64_m128d(b), vreinterpretq_s64_m128d(a))); +} + +// Computes the bitwise AND of the 128-bit value in b and the bitwise NOT of the +// 128-bit value in a. +// +// r := (~a) & b +// +// https://msdn.microsoft.com/en-us/library/vstudio/1beaceh8(v=vs.100).aspx +FORCE_INLINE __m128i _mm_andnot_si128(__m128i a, __m128i b) +{ + return vreinterpretq_m128i_s32( + vbicq_s32(vreinterpretq_s32_m128i(b), + vreinterpretq_s32_m128i(a))); // *NOTE* argument swap +} + +// Computes the bitwise AND of the 128-bit value in a and the 128-bit value in +// b. +// +// r := a & b +// +// https://msdn.microsoft.com/en-us/library/vstudio/6d1txsa8(v=vs.100).aspx +FORCE_INLINE __m128i _mm_and_si128(__m128i a, __m128i b) +{ + return vreinterpretq_m128i_s32( + vandq_s32(vreinterpretq_s32_m128i(a), vreinterpretq_s32_m128i(b))); +} + +// Computes the bitwise AND of the four single-precision, floating-point values +// of a and b. +// +// r0 := a0 & b0 +// r1 := a1 & b1 +// r2 := a2 & b2 +// r3 := a3 & b3 +// +// https://msdn.microsoft.com/en-us/library/vstudio/73ck1xc5(v=vs.100).aspx +FORCE_INLINE __m128 _mm_and_ps(__m128 a, __m128 b) +{ + return vreinterpretq_m128_s32( + vandq_s32(vreinterpretq_s32_m128(a), vreinterpretq_s32_m128(b))); +} + +// Compute the bitwise AND of packed double-precision (64-bit) floating-point +// elements in a and b, and store the results in dst. +// +// FOR j := 0 to 1 +// i := j*64 +// dst[i+63:i] := a[i+63:i] AND b[i+63:i] +// ENDFOR +// +// https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_and_pd +FORCE_INLINE __m128d _mm_and_pd(__m128d a, __m128d b) +{ + return vreinterpretq_m128d_s64( + vandq_s64(vreinterpretq_s64_m128d(a), vreinterpretq_s64_m128d(b))); +} + +// Computes the bitwise OR of the four single-precision, floating-point values +// of a and b. +// https://msdn.microsoft.com/en-us/library/vstudio/7ctdsyy0(v=vs.100).aspx +FORCE_INLINE __m128 _mm_or_ps(__m128 a, __m128 b) +{ + return vreinterpretq_m128_s32( + vorrq_s32(vreinterpretq_s32_m128(a), vreinterpretq_s32_m128(b))); +} + +// Computes bitwise EXOR (exclusive-or) of the four single-precision, +// floating-point values of a and b. +// https://msdn.microsoft.com/en-us/library/ss6k3wk8(v=vs.100).aspx +FORCE_INLINE __m128 _mm_xor_ps(__m128 a, __m128 b) +{ + return vreinterpretq_m128_s32( + veorq_s32(vreinterpretq_s32_m128(a), vreinterpretq_s32_m128(b))); +} + +// Compute the bitwise XOR of packed double-precision (64-bit) floating-point +// elements in a and b, and store the results in dst. +// +// FOR j := 0 to 1 +// i := j*64 +// dst[i+63:i] := a[i+63:i] XOR b[i+63:i] +// ENDFOR +// +// https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_xor_pd +FORCE_INLINE __m128d _mm_xor_pd(__m128d a, __m128d b) +{ + return vreinterpretq_m128d_s64( + veorq_s64(vreinterpretq_s64_m128d(a), vreinterpretq_s64_m128d(b))); +} + +// Computes the bitwise OR of the 128-bit value in a and the 128-bit value in b. +// +// r := a | b +// +// https://msdn.microsoft.com/en-us/library/vstudio/ew8ty0db(v=vs.100).aspx +FORCE_INLINE __m128i _mm_or_si128(__m128i a, __m128i b) +{ + return vreinterpretq_m128i_s32( + vorrq_s32(vreinterpretq_s32_m128i(a), vreinterpretq_s32_m128i(b))); +} + +// Computes the bitwise XOR of the 128-bit value in a and the 128-bit value in +// b. https://msdn.microsoft.com/en-us/library/fzt08www(v=vs.100).aspx +FORCE_INLINE __m128i _mm_xor_si128(__m128i a, __m128i b) +{ + return vreinterpretq_m128i_s32( + veorq_s32(vreinterpretq_s32_m128i(a), vreinterpretq_s32_m128i(b))); +} + +// Duplicate odd-indexed single-precision (32-bit) floating-point elements +// from a, and store the results in dst. +// https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_movehdup_ps +FORCE_INLINE __m128 _mm_movehdup_ps(__m128 a) +{ +#if __has_builtin(__builtin_shufflevector) + return vreinterpretq_m128_f32(__builtin_shufflevector( + vreinterpretq_f32_m128(a), vreinterpretq_f32_m128(a), 1, 1, 3, 3)); +#else + float32_t a1 = vgetq_lane_f32(vreinterpretq_f32_m128(a), 1); + float32_t a3 = vgetq_lane_f32(vreinterpretq_f32_m128(a), 3); + float ALIGN_STRUCT(16) data[4] = {a1, a1, a3, a3}; + return vreinterpretq_m128_f32(vld1q_f32(data)); +#endif +} + +// Duplicate even-indexed single-precision (32-bit) floating-point elements +// from a, and store the results in dst. +// https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_moveldup_ps +FORCE_INLINE __m128 _mm_moveldup_ps(__m128 a) +{ +#if __has_builtin(__builtin_shufflevector) + return vreinterpretq_m128_f32(__builtin_shufflevector( + vreinterpretq_f32_m128(a), vreinterpretq_f32_m128(a), 0, 0, 2, 2)); +#else + float32_t a0 = vgetq_lane_f32(vreinterpretq_f32_m128(a), 0); + float32_t a2 = vgetq_lane_f32(vreinterpretq_f32_m128(a), 2); + float ALIGN_STRUCT(16) data[4] = {a0, a0, a2, a2}; + return vreinterpretq_m128_f32(vld1q_f32(data)); +#endif +} + +// Moves the upper two values of B into the lower two values of A. +// +// r3 := a3 +// r2 := a2 +// r1 := b3 +// r0 := b2 +FORCE_INLINE __m128 _mm_movehl_ps(__m128 __A, __m128 __B) +{ + float32x2_t a32 = vget_high_f32(vreinterpretq_f32_m128(__A)); + float32x2_t b32 = vget_high_f32(vreinterpretq_f32_m128(__B)); + return vreinterpretq_m128_f32(vcombine_f32(b32, a32)); +} + +// Moves the lower two values of B into the upper two values of A. +// +// r3 := b1 +// r2 := b0 +// r1 := a1 +// r0 := a0 +FORCE_INLINE __m128 _mm_movelh_ps(__m128 __A, __m128 __B) +{ + float32x2_t a10 = vget_low_f32(vreinterpretq_f32_m128(__A)); + float32x2_t b10 = vget_low_f32(vreinterpretq_f32_m128(__B)); + return vreinterpretq_m128_f32(vcombine_f32(a10, b10)); +} + +// Compute the absolute value of packed signed 32-bit integers in a, and store +// the unsigned results in dst. +// +// FOR j := 0 to 3 +// i := j*32 +// dst[i+31:i] := ABS(a[i+31:i]) +// ENDFOR +// +// https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_abs_epi32 +FORCE_INLINE __m128i _mm_abs_epi32(__m128i a) +{ + return vreinterpretq_m128i_s32(vabsq_s32(vreinterpretq_s32_m128i(a))); +} + +// Compute the absolute value of packed signed 16-bit integers in a, and store +// the unsigned results in dst. +// +// FOR j := 0 to 7 +// i := j*16 +// dst[i+15:i] := ABS(a[i+15:i]) +// ENDFOR +// +// https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_abs_epi16 +FORCE_INLINE __m128i _mm_abs_epi16(__m128i a) +{ + return vreinterpretq_m128i_s16(vabsq_s16(vreinterpretq_s16_m128i(a))); +} + +// Compute the absolute value of packed signed 8-bit integers in a, and store +// the unsigned results in dst. +// +// FOR j := 0 to 15 +// i := j*8 +// dst[i+7:i] := ABS(a[i+7:i]) +// ENDFOR +// +// https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_abs_epi8 +FORCE_INLINE __m128i _mm_abs_epi8(__m128i a) +{ + return vreinterpretq_m128i_s8(vabsq_s8(vreinterpretq_s8_m128i(a))); +} + +// Compute the absolute value of packed signed 32-bit integers in a, and store +// the unsigned results in dst. +// +// FOR j := 0 to 1 +// i := j*32 +// dst[i+31:i] := ABS(a[i+31:i]) +// ENDFOR +// +// https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_abs_pi32 +FORCE_INLINE __m64 _mm_abs_pi32(__m64 a) +{ + return vreinterpret_m64_s32(vabs_s32(vreinterpret_s32_m64(a))); +} + +// Compute the absolute value of packed signed 16-bit integers in a, and store +// the unsigned results in dst. +// +// FOR j := 0 to 3 +// i := j*16 +// dst[i+15:i] := ABS(a[i+15:i]) +// ENDFOR +// +// https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_abs_pi16 +FORCE_INLINE __m64 _mm_abs_pi16(__m64 a) +{ + return vreinterpret_m64_s16(vabs_s16(vreinterpret_s16_m64(a))); +} + +// Compute the absolute value of packed signed 8-bit integers in a, and store +// the unsigned results in dst. +// +// FOR j := 0 to 7 +// i := j*8 +// dst[i+7:i] := ABS(a[i+7:i]) +// ENDFOR +// +// https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_abs_pi8 +FORCE_INLINE __m64 _mm_abs_pi8(__m64 a) +{ + return vreinterpret_m64_s8(vabs_s8(vreinterpret_s8_m64(a))); +} + +// Takes the upper 64 bits of a and places it in the low end of the result +// Takes the lower 64 bits of b and places it into the high end of the result. +FORCE_INLINE __m128 _mm_shuffle_ps_1032(__m128 a, __m128 b) +{ + float32x2_t a32 = vget_high_f32(vreinterpretq_f32_m128(a)); + float32x2_t b10 = vget_low_f32(vreinterpretq_f32_m128(b)); + return vreinterpretq_m128_f32(vcombine_f32(a32, b10)); +} + +// takes the lower two 32-bit values from a and swaps them and places in high +// end of result takes the higher two 32 bit values from b and swaps them and +// places in low end of result. +FORCE_INLINE __m128 _mm_shuffle_ps_2301(__m128 a, __m128 b) +{ + float32x2_t a01 = vrev64_f32(vget_low_f32(vreinterpretq_f32_m128(a))); + float32x2_t b23 = vrev64_f32(vget_high_f32(vreinterpretq_f32_m128(b))); + return vreinterpretq_m128_f32(vcombine_f32(a01, b23)); +} + +FORCE_INLINE __m128 _mm_shuffle_ps_0321(__m128 a, __m128 b) +{ + float32x2_t a21 = vget_high_f32( + vextq_f32(vreinterpretq_f32_m128(a), vreinterpretq_f32_m128(a), 3)); + float32x2_t b03 = vget_low_f32( + vextq_f32(vreinterpretq_f32_m128(b), vreinterpretq_f32_m128(b), 3)); + return vreinterpretq_m128_f32(vcombine_f32(a21, b03)); +} + +FORCE_INLINE __m128 _mm_shuffle_ps_2103(__m128 a, __m128 b) +{ + float32x2_t a03 = vget_low_f32( + vextq_f32(vreinterpretq_f32_m128(a), vreinterpretq_f32_m128(a), 3)); + float32x2_t b21 = vget_high_f32( + vextq_f32(vreinterpretq_f32_m128(b), vreinterpretq_f32_m128(b), 3)); + return vreinterpretq_m128_f32(vcombine_f32(a03, b21)); +} + +FORCE_INLINE __m128 _mm_shuffle_ps_1010(__m128 a, __m128 b) +{ + float32x2_t a10 = vget_low_f32(vreinterpretq_f32_m128(a)); + float32x2_t b10 = vget_low_f32(vreinterpretq_f32_m128(b)); + return vreinterpretq_m128_f32(vcombine_f32(a10, b10)); +} + +FORCE_INLINE __m128 _mm_shuffle_ps_1001(__m128 a, __m128 b) +{ + float32x2_t a01 = vrev64_f32(vget_low_f32(vreinterpretq_f32_m128(a))); + float32x2_t b10 = vget_low_f32(vreinterpretq_f32_m128(b)); + return vreinterpretq_m128_f32(vcombine_f32(a01, b10)); +} + +FORCE_INLINE __m128 _mm_shuffle_ps_0101(__m128 a, __m128 b) +{ + float32x2_t a01 = vrev64_f32(vget_low_f32(vreinterpretq_f32_m128(a))); + float32x2_t b01 = vrev64_f32(vget_low_f32(vreinterpretq_f32_m128(b))); + return vreinterpretq_m128_f32(vcombine_f32(a01, b01)); +} + +// keeps the low 64 bits of b in the low and puts the high 64 bits of a in the +// high +FORCE_INLINE __m128 _mm_shuffle_ps_3210(__m128 a, __m128 b) +{ + float32x2_t a10 = vget_low_f32(vreinterpretq_f32_m128(a)); + float32x2_t b32 = vget_high_f32(vreinterpretq_f32_m128(b)); + return vreinterpretq_m128_f32(vcombine_f32(a10, b32)); +} + +FORCE_INLINE __m128 _mm_shuffle_ps_0011(__m128 a, __m128 b) +{ + float32x2_t a11 = vdup_lane_f32(vget_low_f32(vreinterpretq_f32_m128(a)), 1); + float32x2_t b00 = vdup_lane_f32(vget_low_f32(vreinterpretq_f32_m128(b)), 0); + return vreinterpretq_m128_f32(vcombine_f32(a11, b00)); +} + +FORCE_INLINE __m128 _mm_shuffle_ps_0022(__m128 a, __m128 b) +{ + float32x2_t a22 = + vdup_lane_f32(vget_high_f32(vreinterpretq_f32_m128(a)), 0); + float32x2_t b00 = vdup_lane_f32(vget_low_f32(vreinterpretq_f32_m128(b)), 0); + return vreinterpretq_m128_f32(vcombine_f32(a22, b00)); +} + +FORCE_INLINE __m128 _mm_shuffle_ps_2200(__m128 a, __m128 b) +{ + float32x2_t a00 = vdup_lane_f32(vget_low_f32(vreinterpretq_f32_m128(a)), 0); + float32x2_t b22 = + vdup_lane_f32(vget_high_f32(vreinterpretq_f32_m128(b)), 0); + return vreinterpretq_m128_f32(vcombine_f32(a00, b22)); +} + +FORCE_INLINE __m128 _mm_shuffle_ps_3202(__m128 a, __m128 b) +{ + float32_t a0 = vgetq_lane_f32(vreinterpretq_f32_m128(a), 0); + float32x2_t a22 = + vdup_lane_f32(vget_high_f32(vreinterpretq_f32_m128(a)), 0); + float32x2_t a02 = vset_lane_f32(a0, a22, 1); /* TODO: use vzip ?*/ + float32x2_t b32 = vget_high_f32(vreinterpretq_f32_m128(b)); + return vreinterpretq_m128_f32(vcombine_f32(a02, b32)); +} + +FORCE_INLINE __m128 _mm_shuffle_ps_1133(__m128 a, __m128 b) +{ + float32x2_t a33 = + vdup_lane_f32(vget_high_f32(vreinterpretq_f32_m128(a)), 1); + float32x2_t b11 = vdup_lane_f32(vget_low_f32(vreinterpretq_f32_m128(b)), 1); + return vreinterpretq_m128_f32(vcombine_f32(a33, b11)); +} + +FORCE_INLINE __m128 _mm_shuffle_ps_2010(__m128 a, __m128 b) +{ + float32x2_t a10 = vget_low_f32(vreinterpretq_f32_m128(a)); + float32_t b2 = vgetq_lane_f32(vreinterpretq_f32_m128(b), 2); + float32x2_t b00 = vdup_lane_f32(vget_low_f32(vreinterpretq_f32_m128(b)), 0); + float32x2_t b20 = vset_lane_f32(b2, b00, 1); + return vreinterpretq_m128_f32(vcombine_f32(a10, b20)); +} + +FORCE_INLINE __m128 _mm_shuffle_ps_2001(__m128 a, __m128 b) +{ + float32x2_t a01 = vrev64_f32(vget_low_f32(vreinterpretq_f32_m128(a))); + float32_t b2 = vgetq_lane_f32(b, 2); + float32x2_t b00 = vdup_lane_f32(vget_low_f32(vreinterpretq_f32_m128(b)), 0); + float32x2_t b20 = vset_lane_f32(b2, b00, 1); + return vreinterpretq_m128_f32(vcombine_f32(a01, b20)); +} + +FORCE_INLINE __m128 _mm_shuffle_ps_2032(__m128 a, __m128 b) +{ + float32x2_t a32 = vget_high_f32(vreinterpretq_f32_m128(a)); + float32_t b2 = vgetq_lane_f32(b, 2); + float32x2_t b00 = vdup_lane_f32(vget_low_f32(vreinterpretq_f32_m128(b)), 0); + float32x2_t b20 = vset_lane_f32(b2, b00, 1); + return vreinterpretq_m128_f32(vcombine_f32(a32, b20)); +} + +// NEON does not support a general purpose permute intrinsic +// Selects four specific single-precision, floating-point values from a and b, +// based on the mask i. +// +// C equivalent: +// __m128 _mm_shuffle_ps_default(__m128 a, __m128 b, +// __constrange(0, 255) int imm) { +// __m128 ret; +// ret[0] = a[imm & 0x3]; ret[1] = a[(imm >> 2) & 0x3]; +// ret[2] = b[(imm >> 4) & 0x03]; ret[3] = b[(imm >> 6) & 0x03]; +// return ret; +// } +// +// https://msdn.microsoft.com/en-us/library/vstudio/5f0858x0(v=vs.100).aspx +#define _mm_shuffle_ps_default(a, b, imm) \ + __extension__({ \ + float32x4_t ret; \ + ret = vmovq_n_f32( \ + vgetq_lane_f32(vreinterpretq_f32_m128(a), (imm) & (0x3))); \ + ret = vsetq_lane_f32( \ + vgetq_lane_f32(vreinterpretq_f32_m128(a), ((imm) >> 2) & 0x3), \ + ret, 1); \ + ret = vsetq_lane_f32( \ + vgetq_lane_f32(vreinterpretq_f32_m128(b), ((imm) >> 4) & 0x3), \ + ret, 2); \ + ret = vsetq_lane_f32( \ + vgetq_lane_f32(vreinterpretq_f32_m128(b), ((imm) >> 6) & 0x3), \ + ret, 3); \ + vreinterpretq_m128_f32(ret); \ + }) + +// FORCE_INLINE __m128 _mm_shuffle_ps(__m128 a, __m128 b, __constrange(0,255) +// int imm) +#if __has_builtin(__builtin_shufflevector) +#define _mm_shuffle_ps(a, b, imm) \ + __extension__({ \ + float32x4_t _input1 = vreinterpretq_f32_m128(a); \ + float32x4_t _input2 = vreinterpretq_f32_m128(b); \ + float32x4_t _shuf = __builtin_shufflevector( \ + _input1, _input2, (imm) & (0x3), ((imm) >> 2) & 0x3, \ + (((imm) >> 4) & 0x3) + 4, (((imm) >> 6) & 0x3) + 4); \ + vreinterpretq_m128_f32(_shuf); \ + }) +#else // generic +#define _mm_shuffle_ps(a, b, imm) \ + __extension__({ \ + __m128 ret; \ + switch (imm) { \ + case _MM_SHUFFLE(1, 0, 3, 2): \ + ret = _mm_shuffle_ps_1032((a), (b)); \ + break; \ + case _MM_SHUFFLE(2, 3, 0, 1): \ + ret = _mm_shuffle_ps_2301((a), (b)); \ + break; \ + case _MM_SHUFFLE(0, 3, 2, 1): \ + ret = _mm_shuffle_ps_0321((a), (b)); \ + break; \ + case _MM_SHUFFLE(2, 1, 0, 3): \ + ret = _mm_shuffle_ps_2103((a), (b)); \ + break; \ + case _MM_SHUFFLE(1, 0, 1, 0): \ + ret = _mm_movelh_ps((a), (b)); \ + break; \ + case _MM_SHUFFLE(1, 0, 0, 1): \ + ret = _mm_shuffle_ps_1001((a), (b)); \ + break; \ + case _MM_SHUFFLE(0, 1, 0, 1): \ + ret = _mm_shuffle_ps_0101((a), (b)); \ + break; \ + case _MM_SHUFFLE(3, 2, 1, 0): \ + ret = _mm_shuffle_ps_3210((a), (b)); \ + break; \ + case _MM_SHUFFLE(0, 0, 1, 1): \ + ret = _mm_shuffle_ps_0011((a), (b)); \ + break; \ + case _MM_SHUFFLE(0, 0, 2, 2): \ + ret = _mm_shuffle_ps_0022((a), (b)); \ + break; \ + case _MM_SHUFFLE(2, 2, 0, 0): \ + ret = _mm_shuffle_ps_2200((a), (b)); \ + break; \ + case _MM_SHUFFLE(3, 2, 0, 2): \ + ret = _mm_shuffle_ps_3202((a), (b)); \ + break; \ + case _MM_SHUFFLE(3, 2, 3, 2): \ + ret = _mm_movehl_ps((b), (a)); \ + break; \ + case _MM_SHUFFLE(1, 1, 3, 3): \ + ret = _mm_shuffle_ps_1133((a), (b)); \ + break; \ + case _MM_SHUFFLE(2, 0, 1, 0): \ + ret = _mm_shuffle_ps_2010((a), (b)); \ + break; \ + case _MM_SHUFFLE(2, 0, 0, 1): \ + ret = _mm_shuffle_ps_2001((a), (b)); \ + break; \ + case _MM_SHUFFLE(2, 0, 3, 2): \ + ret = _mm_shuffle_ps_2032((a), (b)); \ + break; \ + default: \ + ret = _mm_shuffle_ps_default((a), (b), (imm)); \ + break; \ + } \ + ret; \ + }) +#endif + +// Takes the upper 64 bits of a and places it in the low end of the result +// Takes the lower 64 bits of a and places it into the high end of the result. +FORCE_INLINE __m128i _mm_shuffle_epi_1032(__m128i a) +{ + int32x2_t a32 = vget_high_s32(vreinterpretq_s32_m128i(a)); + int32x2_t a10 = vget_low_s32(vreinterpretq_s32_m128i(a)); + return vreinterpretq_m128i_s32(vcombine_s32(a32, a10)); +} + +// takes the lower two 32-bit values from a and swaps them and places in low end +// of result takes the higher two 32 bit values from a and swaps them and places +// in high end of result. +FORCE_INLINE __m128i _mm_shuffle_epi_2301(__m128i a) +{ + int32x2_t a01 = vrev64_s32(vget_low_s32(vreinterpretq_s32_m128i(a))); + int32x2_t a23 = vrev64_s32(vget_high_s32(vreinterpretq_s32_m128i(a))); + return vreinterpretq_m128i_s32(vcombine_s32(a01, a23)); +} + +// rotates the least significant 32 bits into the most signficant 32 bits, and +// shifts the rest down +FORCE_INLINE __m128i _mm_shuffle_epi_0321(__m128i a) +{ + return vreinterpretq_m128i_s32( + vextq_s32(vreinterpretq_s32_m128i(a), vreinterpretq_s32_m128i(a), 1)); +} + +// rotates the most significant 32 bits into the least signficant 32 bits, and +// shifts the rest up +FORCE_INLINE __m128i _mm_shuffle_epi_2103(__m128i a) +{ + return vreinterpretq_m128i_s32( + vextq_s32(vreinterpretq_s32_m128i(a), vreinterpretq_s32_m128i(a), 3)); +} + +// gets the lower 64 bits of a, and places it in the upper 64 bits +// gets the lower 64 bits of a and places it in the lower 64 bits +FORCE_INLINE __m128i _mm_shuffle_epi_1010(__m128i a) +{ + int32x2_t a10 = vget_low_s32(vreinterpretq_s32_m128i(a)); + return vreinterpretq_m128i_s32(vcombine_s32(a10, a10)); +} + +// gets the lower 64 bits of a, swaps the 0 and 1 elements, and places it in the +// lower 64 bits gets the lower 64 bits of a, and places it in the upper 64 bits +FORCE_INLINE __m128i _mm_shuffle_epi_1001(__m128i a) +{ + int32x2_t a01 = vrev64_s32(vget_low_s32(vreinterpretq_s32_m128i(a))); + int32x2_t a10 = vget_low_s32(vreinterpretq_s32_m128i(a)); + return vreinterpretq_m128i_s32(vcombine_s32(a01, a10)); +} + +// gets the lower 64 bits of a, swaps the 0 and 1 elements and places it in the +// upper 64 bits gets the lower 64 bits of a, swaps the 0 and 1 elements, and +// places it in the lower 64 bits +FORCE_INLINE __m128i _mm_shuffle_epi_0101(__m128i a) +{ + int32x2_t a01 = vrev64_s32(vget_low_s32(vreinterpretq_s32_m128i(a))); + return vreinterpretq_m128i_s32(vcombine_s32(a01, a01)); +} + +FORCE_INLINE __m128i _mm_shuffle_epi_2211(__m128i a) +{ + int32x2_t a11 = vdup_lane_s32(vget_low_s32(vreinterpretq_s32_m128i(a)), 1); + int32x2_t a22 = vdup_lane_s32(vget_high_s32(vreinterpretq_s32_m128i(a)), 0); + return vreinterpretq_m128i_s32(vcombine_s32(a11, a22)); +} + +FORCE_INLINE __m128i _mm_shuffle_epi_0122(__m128i a) +{ + int32x2_t a22 = vdup_lane_s32(vget_high_s32(vreinterpretq_s32_m128i(a)), 0); + int32x2_t a01 = vrev64_s32(vget_low_s32(vreinterpretq_s32_m128i(a))); + return vreinterpretq_m128i_s32(vcombine_s32(a22, a01)); +} + +FORCE_INLINE __m128i _mm_shuffle_epi_3332(__m128i a) +{ + int32x2_t a32 = vget_high_s32(vreinterpretq_s32_m128i(a)); + int32x2_t a33 = vdup_lane_s32(vget_high_s32(vreinterpretq_s32_m128i(a)), 1); + return vreinterpretq_m128i_s32(vcombine_s32(a32, a33)); +} + +// Shuffle packed 8-bit integers in a according to shuffle control mask in the +// corresponding 8-bit element of b, and store the results in dst. +// https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_shuffle_epi8 +FORCE_INLINE __m128i _mm_shuffle_epi8(__m128i a, __m128i b) +{ + int8x16_t tbl = vreinterpretq_s8_m128i(a); // input a + uint8x16_t idx = vreinterpretq_u8_m128i(b); // input b + uint8x16_t idx_masked = + vandq_u8(idx, vdupq_n_u8(0x8F)); // avoid using meaningless bits +#if defined(__aarch64__) + return vreinterpretq_m128i_s8(vqtbl1q_s8(tbl, idx_masked)); +#elif defined(__GNUC__) + int8x16_t ret; + // %e and %f represent the even and odd D registers + // respectively. + __asm__ __volatile__( + "vtbl.8 %e[ret], {%e[tbl], %f[tbl]}, %e[idx]\n" + "vtbl.8 %f[ret], {%e[tbl], %f[tbl]}, %f[idx]\n" + : [ret] "=&w"(ret) + : [tbl] "w"(tbl), [idx] "w"(idx_masked)); + return vreinterpretq_m128i_s8(ret); +#else + // use this line if testing on aarch64 + int8x8x2_t a_split = {vget_low_s8(tbl), vget_high_s8(tbl)}; + return vreinterpretq_m128i_s8( + vcombine_s8(vtbl2_s8(a_split, vget_low_u8(idx_masked)), + vtbl2_s8(a_split, vget_high_u8(idx_masked)))); +#endif +} + +// C equivalent: +// __m128i _mm_shuffle_epi32_default(__m128i a, +// __constrange(0, 255) int imm) { +// __m128i ret; +// ret[0] = a[imm & 0x3]; ret[1] = a[(imm >> 2) & 0x3]; +// ret[2] = a[(imm >> 4) & 0x03]; ret[3] = a[(imm >> 6) & 0x03]; +// return ret; +// } +#define _mm_shuffle_epi32_default(a, imm) \ + __extension__({ \ + int32x4_t ret; \ + ret = vmovq_n_s32( \ + vgetq_lane_s32(vreinterpretq_s32_m128i(a), (imm) & (0x3))); \ + ret = vsetq_lane_s32( \ + vgetq_lane_s32(vreinterpretq_s32_m128i(a), ((imm) >> 2) & 0x3), \ + ret, 1); \ + ret = vsetq_lane_s32( \ + vgetq_lane_s32(vreinterpretq_s32_m128i(a), ((imm) >> 4) & 0x3), \ + ret, 2); \ + ret = vsetq_lane_s32( \ + vgetq_lane_s32(vreinterpretq_s32_m128i(a), ((imm) >> 6) & 0x3), \ + ret, 3); \ + vreinterpretq_m128i_s32(ret); \ + }) + +// FORCE_INLINE __m128i _mm_shuffle_epi32_splat(__m128i a, __constrange(0,255) +// int imm) +#if defined(__aarch64__) +#define _mm_shuffle_epi32_splat(a, imm) \ + __extension__({ \ + vreinterpretq_m128i_s32( \ + vdupq_laneq_s32(vreinterpretq_s32_m128i(a), (imm))); \ + }) +#else +#define _mm_shuffle_epi32_splat(a, imm) \ + __extension__({ \ + vreinterpretq_m128i_s32( \ + vdupq_n_s32(vgetq_lane_s32(vreinterpretq_s32_m128i(a), (imm)))); \ + }) +#endif + +// Shuffles the 4 signed or unsigned 32-bit integers in a as specified by imm. +// https://msdn.microsoft.com/en-us/library/56f67xbk%28v=vs.90%29.aspx +// FORCE_INLINE __m128i _mm_shuffle_epi32(__m128i a, +// __constrange(0,255) int imm) +#if __has_builtin(__builtin_shufflevector) +#define _mm_shuffle_epi32(a, imm) \ + __extension__({ \ + int32x4_t _input = vreinterpretq_s32_m128i(a); \ + int32x4_t _shuf = __builtin_shufflevector( \ + _input, _input, (imm) & (0x3), ((imm) >> 2) & 0x3, \ + ((imm) >> 4) & 0x3, ((imm) >> 6) & 0x3); \ + vreinterpretq_m128i_s32(_shuf); \ + }) +#else // generic +#define _mm_shuffle_epi32(a, imm) \ + __extension__({ \ + __m128i ret; \ + switch (imm) { \ + case _MM_SHUFFLE(1, 0, 3, 2): \ + ret = _mm_shuffle_epi_1032((a)); \ + break; \ + case _MM_SHUFFLE(2, 3, 0, 1): \ + ret = _mm_shuffle_epi_2301((a)); \ + break; \ + case _MM_SHUFFLE(0, 3, 2, 1): \ + ret = _mm_shuffle_epi_0321((a)); \ + break; \ + case _MM_SHUFFLE(2, 1, 0, 3): \ + ret = _mm_shuffle_epi_2103((a)); \ + break; \ + case _MM_SHUFFLE(1, 0, 1, 0): \ + ret = _mm_shuffle_epi_1010((a)); \ + break; \ + case _MM_SHUFFLE(1, 0, 0, 1): \ + ret = _mm_shuffle_epi_1001((a)); \ + break; \ + case _MM_SHUFFLE(0, 1, 0, 1): \ + ret = _mm_shuffle_epi_0101((a)); \ + break; \ + case _MM_SHUFFLE(2, 2, 1, 1): \ + ret = _mm_shuffle_epi_2211((a)); \ + break; \ + case _MM_SHUFFLE(0, 1, 2, 2): \ + ret = _mm_shuffle_epi_0122((a)); \ + break; \ + case _MM_SHUFFLE(3, 3, 3, 2): \ + ret = _mm_shuffle_epi_3332((a)); \ + break; \ + case _MM_SHUFFLE(0, 0, 0, 0): \ + ret = _mm_shuffle_epi32_splat((a), 0); \ + break; \ + case _MM_SHUFFLE(1, 1, 1, 1): \ + ret = _mm_shuffle_epi32_splat((a), 1); \ + break; \ + case _MM_SHUFFLE(2, 2, 2, 2): \ + ret = _mm_shuffle_epi32_splat((a), 2); \ + break; \ + case _MM_SHUFFLE(3, 3, 3, 3): \ + ret = _mm_shuffle_epi32_splat((a), 3); \ + break; \ + default: \ + ret = _mm_shuffle_epi32_default((a), (imm)); \ + break; \ + } \ + ret; \ + }) +#endif + +// Shuffles the lower 4 signed or unsigned 16-bit integers in a as specified +// by imm. +// https://docs.microsoft.com/en-us/previous-versions/visualstudio/visual-studio-2010/y41dkk37(v=vs.100) +// FORCE_INLINE __m128i _mm_shufflelo_epi16_function(__m128i a, +// __constrange(0,255) int +// imm) +#define _mm_shufflelo_epi16_function(a, imm) \ + __extension__({ \ + int16x8_t ret = vreinterpretq_s16_m128i(a); \ + int16x4_t lowBits = vget_low_s16(ret); \ + ret = vsetq_lane_s16(vget_lane_s16(lowBits, (imm) & (0x3)), ret, 0); \ + ret = vsetq_lane_s16(vget_lane_s16(lowBits, ((imm) >> 2) & 0x3), ret, \ + 1); \ + ret = vsetq_lane_s16(vget_lane_s16(lowBits, ((imm) >> 4) & 0x3), ret, \ + 2); \ + ret = vsetq_lane_s16(vget_lane_s16(lowBits, ((imm) >> 6) & 0x3), ret, \ + 3); \ + vreinterpretq_m128i_s16(ret); \ + }) + +// FORCE_INLINE __m128i _mm_shufflelo_epi16(__m128i a, +// __constrange(0,255) int imm) +#if __has_builtin(__builtin_shufflevector) +#define _mm_shufflelo_epi16(a, imm) \ + __extension__({ \ + int16x8_t _input = vreinterpretq_s16_m128i(a); \ + int16x8_t _shuf = __builtin_shufflevector( \ + _input, _input, ((imm) & (0x3)), (((imm) >> 2) & 0x3), \ + (((imm) >> 4) & 0x3), (((imm) >> 6) & 0x3), 4, 5, 6, 7); \ + vreinterpretq_m128i_s16(_shuf); \ + }) +#else // generic +#define _mm_shufflelo_epi16(a, imm) _mm_shufflelo_epi16_function((a), (imm)) +#endif + +// Shuffles the upper 4 signed or unsigned 16-bit integers in a as specified +// by imm. +// https://msdn.microsoft.com/en-us/library/13ywktbs(v=vs.100).aspx +// FORCE_INLINE __m128i _mm_shufflehi_epi16_function(__m128i a, +// __constrange(0,255) int +// imm) +#define _mm_shufflehi_epi16_function(a, imm) \ + __extension__({ \ + int16x8_t ret = vreinterpretq_s16_m128i(a); \ + int16x4_t highBits = vget_high_s16(ret); \ + ret = vsetq_lane_s16(vget_lane_s16(highBits, (imm) & (0x3)), ret, 4); \ + ret = vsetq_lane_s16(vget_lane_s16(highBits, ((imm) >> 2) & 0x3), ret, \ + 5); \ + ret = vsetq_lane_s16(vget_lane_s16(highBits, ((imm) >> 4) & 0x3), ret, \ + 6); \ + ret = vsetq_lane_s16(vget_lane_s16(highBits, ((imm) >> 6) & 0x3), ret, \ + 7); \ + vreinterpretq_m128i_s16(ret); \ + }) + +// FORCE_INLINE __m128i _mm_shufflehi_epi16(__m128i a, +// __constrange(0,255) int imm) +#if __has_builtin(__builtin_shufflevector) +#define _mm_shufflehi_epi16(a, imm) \ + __extension__({ \ + int16x8_t _input = vreinterpretq_s16_m128i(a); \ + int16x8_t _shuf = __builtin_shufflevector( \ + _input, _input, 0, 1, 2, 3, ((imm) & (0x3)) + 4, \ + (((imm) >> 2) & 0x3) + 4, (((imm) >> 4) & 0x3) + 4, \ + (((imm) >> 6) & 0x3) + 4); \ + vreinterpretq_m128i_s16(_shuf); \ + }) +#else // generic +#define _mm_shufflehi_epi16(a, imm) _mm_shufflehi_epi16_function((a), (imm)) +#endif + +// Blend packed 16-bit integers from a and b using control mask imm8, and store +// the results in dst. +// +// FOR j := 0 to 7 +// i := j*16 +// IF imm8[j] +// dst[i+15:i] := b[i+15:i] +// ELSE +// dst[i+15:i] := a[i+15:i] +// FI +// ENDFOR +// FORCE_INLINE __m128i _mm_blend_epi16(__m128i a, __m128i b, +// __constrange(0,255) int imm) +#define _mm_blend_epi16(a, b, imm) \ + __extension__({ \ + const uint16_t _mask[8] = {((imm) & (1 << 0)) ? 0xFFFF : 0x0000, \ + ((imm) & (1 << 1)) ? 0xFFFF : 0x0000, \ + ((imm) & (1 << 2)) ? 0xFFFF : 0x0000, \ + ((imm) & (1 << 3)) ? 0xFFFF : 0x0000, \ + ((imm) & (1 << 4)) ? 0xFFFF : 0x0000, \ + ((imm) & (1 << 5)) ? 0xFFFF : 0x0000, \ + ((imm) & (1 << 6)) ? 0xFFFF : 0x0000, \ + ((imm) & (1 << 7)) ? 0xFFFF : 0x0000}; \ + uint16x8_t _mask_vec = vld1q_u16(_mask); \ + uint16x8_t _a = vreinterpretq_u16_m128i(a); \ + uint16x8_t _b = vreinterpretq_u16_m128i(b); \ + vreinterpretq_m128i_u16(vbslq_u16(_mask_vec, _b, _a)); \ + }) + +// Blend packed 8-bit integers from a and b using mask, and store the results in +// dst. +// +// FOR j := 0 to 15 +// i := j*8 +// IF mask[i+7] +// dst[i+7:i] := b[i+7:i] +// ELSE +// dst[i+7:i] := a[i+7:i] +// FI +// ENDFOR +FORCE_INLINE __m128i _mm_blendv_epi8(__m128i _a, __m128i _b, __m128i _mask) +{ + // Use a signed shift right to create a mask with the sign bit + uint8x16_t mask = + vreinterpretq_u8_s8(vshrq_n_s8(vreinterpretq_s8_m128i(_mask), 7)); + uint8x16_t a = vreinterpretq_u8_m128i(_a); + uint8x16_t b = vreinterpretq_u8_m128i(_b); + return vreinterpretq_m128i_u8(vbslq_u8(mask, b, a)); +} + +/* Shifts */ + + +// Shift packed 16-bit integers in a right by imm while shifting in sign +// bits, and store the results in dst. +// https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_srai_epi16 +FORCE_INLINE __m128i _mm_srai_epi16(__m128i a, int imm) +{ + const int count = (imm & ~15) ? 15 : imm; + return (__m128i) vshlq_s16((int16x8_t) a, vdupq_n_s16(-count)); +} + +// Shifts the 8 signed or unsigned 16-bit integers in a left by count bits while +// shifting in zeros. +// +// r0 := a0 << count +// r1 := a1 << count +// ... +// r7 := a7 << count +// +// https://msdn.microsoft.com/en-us/library/es73bcsy(v=vs.90).aspx +#define _mm_slli_epi16(a, imm) \ + __extension__({ \ + __m128i ret; \ + if ((imm) <= 0) { \ + ret = a; \ + } else if ((imm) > 15) { \ + ret = _mm_setzero_si128(); \ + } else { \ + ret = vreinterpretq_m128i_s16( \ + vshlq_n_s16(vreinterpretq_s16_m128i(a), (imm))); \ + } \ + ret; \ + }) + +// Shifts the 4 signed or unsigned 32-bit integers in a left by count bits while +// shifting in zeros. : +// https://msdn.microsoft.com/en-us/library/z2k3bbtb%28v=vs.90%29.aspx +// FORCE_INLINE __m128i _mm_slli_epi32(__m128i a, __constrange(0,255) int imm) +FORCE_INLINE __m128i _mm_slli_epi32(__m128i a, int imm) +{ + if (imm <= 0) /* TODO: add constant range macro: [0, 255] */ + return a; + if (imm > 31) /* TODO: add unlikely macro */ + return _mm_setzero_si128(); + return vreinterpretq_m128i_s32( + vshlq_s32(vreinterpretq_s32_m128i(a), vdupq_n_s32(imm))); +} + +// Shift packed 64-bit integers in a left by imm8 while shifting in zeros, and +// store the results in dst. +FORCE_INLINE __m128i _mm_slli_epi64(__m128i a, int imm) +{ + if (imm <= 0) /* TODO: add constant range macro: [0, 255] */ + return a; + if (imm > 63) /* TODO: add unlikely macro */ + return _mm_setzero_si128(); + return vreinterpretq_m128i_s64( + vshlq_s64(vreinterpretq_s64_m128i(a), vdupq_n_s64(imm))); +} + +// Shift packed 16-bit integers in a right by imm8 while shifting in zeros, and +// store the results in dst. +// +// FOR j := 0 to 7 +// i := j*16 +// IF imm8[7:0] > 15 +// dst[i+15:i] := 0 +// ELSE +// dst[i+15:i] := ZeroExtend16(a[i+15:i] >> imm8[7:0]) +// FI +// ENDFOR +// +// https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_srli_epi16 +#define _mm_srli_epi16(a, imm) \ + __extension__({ \ + __m128i ret; \ + if ((imm) == 0) { \ + ret = a; \ + } else if (0 < (imm) && (imm) < 16) { \ + ret = vreinterpretq_m128i_u16( \ + vshlq_u16(vreinterpretq_u16_m128i(a), vdupq_n_s16(-imm))); \ + } else { \ + ret = _mm_setzero_si128(); \ + } \ + ret; \ + }) + +// Shift packed 32-bit integers in a right by imm8 while shifting in zeros, and +// store the results in dst. +// +// FOR j := 0 to 3 +// i := j*32 +// IF imm8[7:0] > 31 +// dst[i+31:i] := 0 +// ELSE +// dst[i+31:i] := ZeroExtend32(a[i+31:i] >> imm8[7:0]) +// FI +// ENDFOR +// +// https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_srli_epi32 +// FORCE_INLINE __m128i _mm_srli_epi32(__m128i a, __constrange(0,255) int imm) +#define _mm_srli_epi32(a, imm) \ + __extension__({ \ + __m128i ret; \ + if ((imm) == 0) { \ + ret = a; \ + } else if (0 < (imm) && (imm) < 32) { \ + ret = vreinterpretq_m128i_u32( \ + vshlq_u32(vreinterpretq_u32_m128i(a), vdupq_n_s32(-imm))); \ + } else { \ + ret = _mm_setzero_si128(); \ + } \ + ret; \ + }) + +// Shift packed 64-bit integers in a right by imm8 while shifting in zeros, and +// store the results in dst. +// +// FOR j := 0 to 1 +// i := j*64 +// IF imm8[7:0] > 63 +// dst[i+63:i] := 0 +// ELSE +// dst[i+63:i] := ZeroExtend64(a[i+63:i] >> imm8[7:0]) +// FI +// ENDFOR +// +// https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_srli_epi64 +#define _mm_srli_epi64(a, imm) \ + __extension__({ \ + __m128i ret; \ + if ((imm) == 0) { \ + ret = a; \ + } else if (0 < (imm) && (imm) < 64) { \ + ret = vreinterpretq_m128i_u64( \ + vshlq_u64(vreinterpretq_u64_m128i(a), vdupq_n_s64(-imm))); \ + } else { \ + ret = _mm_setzero_si128(); \ + } \ + ret; \ + }) + +// Shift packed 32-bit integers in a right by imm8 while shifting in sign bits, +// and store the results in dst. +// +// FOR j := 0 to 3 +// i := j*32 +// IF imm8[7:0] > 31 +// dst[i+31:i] := (a[i+31] ? 0xFFFFFFFF : 0x0) +// ELSE +// dst[i+31:i] := SignExtend32(a[i+31:i] >> imm8[7:0]) +// FI +// ENDFOR +// +// https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_srai_epi32 +// FORCE_INLINE __m128i _mm_srai_epi32(__m128i a, __constrange(0,255) int imm) +#define _mm_srai_epi32(a, imm) \ + __extension__({ \ + __m128i ret; \ + if ((imm) == 0) { \ + ret = a; \ + } else if (0 < (imm) && (imm) < 32) { \ + ret = vreinterpretq_m128i_s32( \ + vshlq_s32(vreinterpretq_s32_m128i(a), vdupq_n_s32(-imm))); \ + } else { \ + ret = vreinterpretq_m128i_s32( \ + vshrq_n_s32(vreinterpretq_s32_m128i(a), 31)); \ + } \ + ret; \ + }) + +// Shifts the 128 - bit value in a right by imm bytes while shifting in +// zeros.imm must be an immediate. +// +// r := srl(a, imm*8) +// +// https://msdn.microsoft.com/en-us/library/305w28yz(v=vs.100).aspx +// FORCE_INLINE _mm_srli_si128(__m128i a, __constrange(0,255) int imm) +#define _mm_srli_si128(a, imm) \ + __extension__({ \ + __m128i ret; \ + if ((imm) <= 0) { \ + ret = a; \ + } else if ((imm) > 15) { \ + ret = _mm_setzero_si128(); \ + } else { \ + ret = vreinterpretq_m128i_s8( \ + vextq_s8(vreinterpretq_s8_m128i(a), vdupq_n_s8(0), (imm))); \ + } \ + ret; \ + }) + +// Shifts the 128-bit value in a left by imm bytes while shifting in zeros. imm +// must be an immediate. +// +// r := a << (imm * 8) +// +// https://msdn.microsoft.com/en-us/library/34d3k2kt(v=vs.100).aspx +// FORCE_INLINE __m128i _mm_slli_si128(__m128i a, __constrange(0,255) int imm) +#define _mm_slli_si128(a, imm) \ + __extension__({ \ + __m128i ret; \ + if ((imm) <= 0) { \ + ret = a; \ + } else if ((imm) > 15) { \ + ret = _mm_setzero_si128(); \ + } else { \ + ret = vreinterpretq_m128i_s8(vextq_s8( \ + vdupq_n_s8(0), vreinterpretq_s8_m128i(a), 16 - (imm))); \ + } \ + ret; \ + }) + +// Shifts the 8 signed or unsigned 16-bit integers in a left by count bits while +// shifting in zeros. +// +// r0 := a0 << count +// r1 := a1 << count +// ... +// r7 := a7 << count +// +// https://msdn.microsoft.com/en-us/library/c79w388h(v%3dvs.90).aspx +FORCE_INLINE __m128i _mm_sll_epi16(__m128i a, __m128i count) +{ + uint64_t c = vreinterpretq_nth_u64_m128i(count, 0); + if (c > 15) + return _mm_setzero_si128(); + + int16x8_t vc = vdupq_n_s16((int16_t) c); + return vreinterpretq_m128i_s16(vshlq_s16(vreinterpretq_s16_m128i(a), vc)); +} + +// Shifts the 4 signed or unsigned 32-bit integers in a left by count bits while +// shifting in zeros. +// +// r0 := a0 << count +// r1 := a1 << count +// r2 := a2 << count +// r3 := a3 << count +// +// https://msdn.microsoft.com/en-us/library/6fe5a6s9(v%3dvs.90).aspx +FORCE_INLINE __m128i _mm_sll_epi32(__m128i a, __m128i count) +{ + uint64_t c = vreinterpretq_nth_u64_m128i(count, 0); + if (c > 31) + return _mm_setzero_si128(); + + int32x4_t vc = vdupq_n_s32((int32_t) c); + return vreinterpretq_m128i_s32(vshlq_s32(vreinterpretq_s32_m128i(a), vc)); +} + +// Shifts the 2 signed or unsigned 64-bit integers in a left by count bits while +// shifting in zeros. +// +// r0 := a0 << count +// r1 := a1 << count +// +// https://msdn.microsoft.com/en-us/library/6ta9dffd(v%3dvs.90).aspx +FORCE_INLINE __m128i _mm_sll_epi64(__m128i a, __m128i count) +{ + uint64_t c = vreinterpretq_nth_u64_m128i(count, 0); + if (c > 63) + return _mm_setzero_si128(); + + int64x2_t vc = vdupq_n_s64((int64_t) c); + return vreinterpretq_m128i_s64(vshlq_s64(vreinterpretq_s64_m128i(a), vc)); +} + +// Shifts the 8 signed or unsigned 16-bit integers in a right by count bits +// while shifting in zeros. +// +// r0 := srl(a0, count) +// r1 := srl(a1, count) +// ... +// r7 := srl(a7, count) +// +// https://msdn.microsoft.com/en-us/library/wd5ax830(v%3dvs.90).aspx +FORCE_INLINE __m128i _mm_srl_epi16(__m128i a, __m128i count) +{ + uint64_t c = vreinterpretq_nth_u64_m128i(count, 0); + if (c > 15) + return _mm_setzero_si128(); + + int16x8_t vc = vdupq_n_s16(-(int16_t) c); + return vreinterpretq_m128i_u16(vshlq_u16(vreinterpretq_u16_m128i(a), vc)); +} + +// Shifts the 4 signed or unsigned 32-bit integers in a right by count bits +// while shifting in zeros. +// +// r0 := srl(a0, count) +// r1 := srl(a1, count) +// r2 := srl(a2, count) +// r3 := srl(a3, count) +// +// https://msdn.microsoft.com/en-us/library/a9cbttf4(v%3dvs.90).aspx +FORCE_INLINE __m128i _mm_srl_epi32(__m128i a, __m128i count) +{ + uint64_t c = vreinterpretq_nth_u64_m128i(count, 0); + if (c > 31) + return _mm_setzero_si128(); + + int32x4_t vc = vdupq_n_s32(-(int32_t) c); + return vreinterpretq_m128i_u32(vshlq_u32(vreinterpretq_u32_m128i(a), vc)); +} + +// Shifts the 2 signed or unsigned 64-bit integers in a right by count bits +// while shifting in zeros. +// +// r0 := srl(a0, count) +// r1 := srl(a1, count) +// +// https://msdn.microsoft.com/en-us/library/yf6cf9k8(v%3dvs.90).aspx +FORCE_INLINE __m128i _mm_srl_epi64(__m128i a, __m128i count) +{ + uint64_t c = vreinterpretq_nth_u64_m128i(count, 0); + if (c > 63) + return _mm_setzero_si128(); + + int64x2_t vc = vdupq_n_s64(-(int64_t) c); + return vreinterpretq_m128i_u64(vshlq_u64(vreinterpretq_u64_m128i(a), vc)); +} + +// NEON does not provide a version of this function. +// Creates a 16-bit mask from the most significant bits of the 16 signed or +// unsigned 8-bit integers in a and zero extends the upper bits. +// https://msdn.microsoft.com/en-us/library/vstudio/s090c8fk(v=vs.100).aspx +FORCE_INLINE int _mm_movemask_epi8(__m128i a) +{ +#if defined(__aarch64__) + uint8x16_t input = vreinterpretq_u8_m128i(a); + const int8_t ALIGN_STRUCT(16) + xr[16] = {-7, -6, -5, -4, -3, -2, -1, 0, -7, -6, -5, -4, -3, -2, -1, 0}; + const uint8x16_t mask_and = vdupq_n_u8(0x80); + const int8x16_t mask_shift = vld1q_s8(xr); + const uint8x16_t mask_result = + vshlq_u8(vandq_u8(input, mask_and), mask_shift); + uint8x8_t lo = vget_low_u8(mask_result); + uint8x8_t hi = vget_high_u8(mask_result); + + return vaddv_u8(lo) + (vaddv_u8(hi) << 8); +#else + // Use increasingly wide shifts+adds to collect the sign bits + // together. + // Since the widening shifts would be rather confusing to follow in little + // endian, everything will be illustrated in big endian order instead. This + // has a different result - the bits would actually be reversed on a big + // endian machine. + + // Starting input (only half the elements are shown): + // 89 ff 1d c0 00 10 99 33 + uint8x16_t input = vreinterpretq_u8_m128i(a); + + // Shift out everything but the sign bits with an unsigned shift right. + // + // Bytes of the vector:: + // 89 ff 1d c0 00 10 99 33 + // \ \ \ \ \ \ \ \ high_bits = (uint16x4_t)(input >> 7) + // | | | | | | | | + // 01 01 00 01 00 00 01 00 + // + // Bits of first important lane(s): + // 10001001 (89) + // \______ + // | + // 00000001 (01) + uint16x8_t high_bits = vreinterpretq_u16_u8(vshrq_n_u8(input, 7)); + + // Merge the even lanes together with a 16-bit unsigned shift right + add. + // 'xx' represents garbage data which will be ignored in the final result. + // In the important bytes, the add functions like a binary OR. + // + // 01 01 00 01 00 00 01 00 + // \_ | \_ | \_ | \_ | paired16 = (uint32x4_t)(input + (input >> 7)) + // \| \| \| \| + // xx 03 xx 01 xx 00 xx 02 + // + // 00000001 00000001 (01 01) + // \_______ | + // \| + // xxxxxxxx xxxxxx11 (xx 03) + uint32x4_t paired16 = + vreinterpretq_u32_u16(vsraq_n_u16(high_bits, high_bits, 7)); + + // Repeat with a wider 32-bit shift + add. + // xx 03 xx 01 xx 00 xx 02 + // \____ | \____ | paired32 = (uint64x1_t)(paired16 + (paired16 >> + // 14)) + // \| \| + // xx xx xx 0d xx xx xx 02 + // + // 00000011 00000001 (03 01) + // \\_____ || + // '----.\|| + // xxxxxxxx xxxx1101 (xx 0d) + uint64x2_t paired32 = + vreinterpretq_u64_u32(vsraq_n_u32(paired16, paired16, 14)); + + // Last, an even wider 64-bit shift + add to get our result in the low 8 bit + // lanes. xx xx xx 0d xx xx xx 02 + // \_________ | paired64 = (uint8x8_t)(paired32 + (paired32 >> + // 28)) + // \| + // xx xx xx xx xx xx xx d2 + // + // 00001101 00000010 (0d 02) + // \ \___ | | + // '---. \| | + // xxxxxxxx 11010010 (xx d2) + uint8x16_t paired64 = + vreinterpretq_u8_u64(vsraq_n_u64(paired32, paired32, 28)); + + // Extract the low 8 bits from each 64-bit lane with 2 8-bit extracts. + // xx xx xx xx xx xx xx d2 + // || return paired64[0] + // d2 + // Note: Little endian would return the correct value 4b (01001011) instead. + return vgetq_lane_u8(paired64, 0) | ((int) vgetq_lane_u8(paired64, 8) << 8); +#endif +} + +// Copy the lower 64-bit integer in a to dst. +// +// dst[63:0] := a[63:0] +// +// https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_movepi64_pi64 +FORCE_INLINE __m64 _mm_movepi64_pi64(__m128i a) +{ + return vreinterpret_m64_s64(vget_low_s64(vreinterpretq_s64_m128i(a))); +} + +// Copy the 64-bit integer a to the lower element of dst, and zero the upper +// element. +// +// dst[63:0] := a[63:0] +// dst[127:64] := 0 +// +// https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_movpi64_epi64 +FORCE_INLINE __m128i _mm_movpi64_epi64(__m64 a) +{ + return vreinterpretq_m128i_s64( + vcombine_s64(vreinterpret_s64_m64(a), vdup_n_s64(0))); +} + +// NEON does not provide this method +// Creates a 4-bit mask from the most significant bits of the four +// single-precision, floating-point values. +// https://msdn.microsoft.com/en-us/library/vstudio/4490ys29(v=vs.100).aspx +FORCE_INLINE int _mm_movemask_ps(__m128 a) +{ + uint32x4_t input = vreinterpretq_u32_m128(a); +#if defined(__aarch64__) + static const int32x4_t shift = {0, 1, 2, 3}; + uint32x4_t tmp = vshrq_n_u32(input, 31); + return vaddvq_u32(vshlq_u32(tmp, shift)); +#else + // Uses the exact same method as _mm_movemask_epi8, see that for details. + // Shift out everything but the sign bits with a 32-bit unsigned shift + // right. + uint64x2_t high_bits = vreinterpretq_u64_u32(vshrq_n_u32(input, 31)); + // Merge the two pairs together with a 64-bit unsigned shift right + add. + uint8x16_t paired = + vreinterpretq_u8_u64(vsraq_n_u64(high_bits, high_bits, 31)); + // Extract the result. + return vgetq_lane_u8(paired, 0) | (vgetq_lane_u8(paired, 8) << 2); +#endif +} + +// Compute the bitwise NOT of a and then AND with a 128-bit vector containing +// all 1's, and return 1 if the result is zero, otherwise return 0. +// https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_test_all_ones +FORCE_INLINE int _mm_test_all_ones(__m128i a) +{ + return (uint64_t)(vgetq_lane_s64(a, 0) & vgetq_lane_s64(a, 1)) == + ~(uint64_t) 0; +} + +// Compute the bitwise AND of 128 bits (representing integer data) in a and +// mask, and return 1 if the result is zero, otherwise return 0. +// https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_test_all_zeros +FORCE_INLINE int _mm_test_all_zeros(__m128i a, __m128i mask) +{ + int64x2_t a_and_mask = + vandq_s64(vreinterpretq_s64_m128i(a), vreinterpretq_s64_m128i(mask)); + return (vgetq_lane_s64(a_and_mask, 0) | vgetq_lane_s64(a_and_mask, 1)) ? 0 + : 1; +} + +/* Math operations */ + +// Subtracts the four single-precision, floating-point values of a and b. +// +// r0 := a0 - b0 +// r1 := a1 - b1 +// r2 := a2 - b2 +// r3 := a3 - b3 +// +// https://msdn.microsoft.com/en-us/library/vstudio/1zad2k61(v=vs.100).aspx +FORCE_INLINE __m128 _mm_sub_ps(__m128 a, __m128 b) +{ + return vreinterpretq_m128_f32( + vsubq_f32(vreinterpretq_f32_m128(a), vreinterpretq_f32_m128(b))); +} + +// Subtract the lower single-precision (32-bit) floating-point element in b from +// the lower single-precision (32-bit) floating-point element in a, store the +// result in the lower element of dst, and copy the upper 3 packed elements from +// a to the upper elements of dst. +// +// dst[31:0] := a[31:0] - b[31:0] +// dst[127:32] := a[127:32] +// +// https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_sub_ss +FORCE_INLINE __m128 _mm_sub_ss(__m128 a, __m128 b) +{ + return _mm_move_ss(a, _mm_sub_ps(a, b)); +} + +// Subtract 2 packed 64-bit integers in b from 2 packed 64-bit integers in a, +// and store the results in dst. +// r0 := a0 - b0 +// r1 := a1 - b1 +FORCE_INLINE __m128i _mm_sub_epi64(__m128i a, __m128i b) +{ + return vreinterpretq_m128i_s64( + vsubq_s64(vreinterpretq_s64_m128i(a), vreinterpretq_s64_m128i(b))); +} + +// Subtracts the 4 signed or unsigned 32-bit integers of b from the 4 signed or +// unsigned 32-bit integers of a. +// +// r0 := a0 - b0 +// r1 := a1 - b1 +// r2 := a2 - b2 +// r3 := a3 - b3 +// +// https://msdn.microsoft.com/en-us/library/vstudio/fhh866h0(v=vs.100).aspx +FORCE_INLINE __m128i _mm_sub_epi32(__m128i a, __m128i b) +{ + return vreinterpretq_m128i_s32( + vsubq_s32(vreinterpretq_s32_m128i(a), vreinterpretq_s32_m128i(b))); +} + +FORCE_INLINE __m128i _mm_sub_epi16(__m128i a, __m128i b) +{ + return vreinterpretq_m128i_s16( + vsubq_s16(vreinterpretq_s16_m128i(a), vreinterpretq_s16_m128i(b))); +} + +FORCE_INLINE __m128i _mm_sub_epi8(__m128i a, __m128i b) +{ + return vreinterpretq_m128i_s8( + vsubq_s8(vreinterpretq_s8_m128i(a), vreinterpretq_s8_m128i(b))); +} + +// Subtract 64-bit integer b from 64-bit integer a, and store the result in dst. +// +// dst[63:0] := a[63:0] - b[63:0] +// +// https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_sub_si64 +FORCE_INLINE __m64 _mm_sub_si64(__m64 a, __m64 b) +{ + return vreinterpret_m64_s64( + vsub_s64(vreinterpret_s64_m64(a), vreinterpret_s64_m64(b))); +} + +// Subtracts the 8 unsigned 16-bit integers of bfrom the 8 unsigned 16-bit +// integers of a and saturates.. +// https://technet.microsoft.com/en-us/subscriptions/index/f44y0s19(v=vs.90).aspx +FORCE_INLINE __m128i _mm_subs_epu16(__m128i a, __m128i b) +{ + return vreinterpretq_m128i_u16( + vqsubq_u16(vreinterpretq_u16_m128i(a), vreinterpretq_u16_m128i(b))); +} + +// Subtracts the 16 unsigned 8-bit integers of b from the 16 unsigned 8-bit +// integers of a and saturates. +// +// r0 := UnsignedSaturate(a0 - b0) +// r1 := UnsignedSaturate(a1 - b1) +// ... +// r15 := UnsignedSaturate(a15 - b15) +// +// https://technet.microsoft.com/en-us/subscriptions/yadkxc18(v=vs.90) +FORCE_INLINE __m128i _mm_subs_epu8(__m128i a, __m128i b) +{ + return vreinterpretq_m128i_u8( + vqsubq_u8(vreinterpretq_u8_m128i(a), vreinterpretq_u8_m128i(b))); +} + +// Subtracts the 16 signed 8-bit integers of b from the 16 signed 8-bit integers +// of a and saturates. +// +// r0 := SignedSaturate(a0 - b0) +// r1 := SignedSaturate(a1 - b1) +// ... +// r15 := SignedSaturate(a15 - b15) +// +// https://technet.microsoft.com/en-us/subscriptions/by7kzks1(v=vs.90) +FORCE_INLINE __m128i _mm_subs_epi8(__m128i a, __m128i b) +{ + return vreinterpretq_m128i_s8( + vqsubq_s8(vreinterpretq_s8_m128i(a), vreinterpretq_s8_m128i(b))); +} + +// Subtracts the 8 signed 16-bit integers of b from the 8 signed 16-bit integers +// of a and saturates. +// +// r0 := SignedSaturate(a0 - b0) +// r1 := SignedSaturate(a1 - b1) +// ... +// r7 := SignedSaturate(a7 - b7) +// +// https://technet.microsoft.com/en-us/subscriptions/3247z5b8(v=vs.90) +FORCE_INLINE __m128i _mm_subs_epi16(__m128i a, __m128i b) +{ + return vreinterpretq_m128i_s16( + vqsubq_s16(vreinterpretq_s16_m128i(a), vreinterpretq_s16_m128i(b))); +} + +FORCE_INLINE __m128i _mm_adds_epu16(__m128i a, __m128i b) +{ + return vreinterpretq_m128i_u16( + vqaddq_u16(vreinterpretq_u16_m128i(a), vreinterpretq_u16_m128i(b))); +} + +// Negate packed 8-bit integers in a when the corresponding signed +// 8-bit integer in b is negative, and store the results in dst. +// Element in dst are zeroed out when the corresponding element +// in b is zero. +// +// for i in 0..15 +// if b[i] < 0 +// r[i] := -a[i] +// else if b[i] == 0 +// r[i] := 0 +// else +// r[i] := a[i] +// fi +// done +FORCE_INLINE __m128i _mm_sign_epi8(__m128i _a, __m128i _b) +{ + int8x16_t a = vreinterpretq_s8_m128i(_a); + int8x16_t b = vreinterpretq_s8_m128i(_b); + + // signed shift right: faster than vclt + // (b < 0) ? 0xFF : 0 + uint8x16_t ltMask = vreinterpretq_u8_s8(vshrq_n_s8(b, 7)); + + // (b == 0) ? 0xFF : 0 +#if defined(__aarch64__) + int8x16_t zeroMask = vreinterpretq_s8_u8(vceqzq_s8(b)); +#else + int8x16_t zeroMask = vreinterpretq_s8_u8(vceqq_s8(b, vdupq_n_s8(0))); +#endif + + // bitwise select either a or nagative 'a' (vnegq_s8(a) return nagative 'a') + // based on ltMask + int8x16_t masked = vbslq_s8(ltMask, vnegq_s8(a), a); + // res = masked & (~zeroMask) + int8x16_t res = vbicq_s8(masked, zeroMask); + + return vreinterpretq_m128i_s8(res); +} + +// Negate packed 16-bit integers in a when the corresponding signed +// 16-bit integer in b is negative, and store the results in dst. +// Element in dst are zeroed out when the corresponding element +// in b is zero. +// +// for i in 0..7 +// if b[i] < 0 +// r[i] := -a[i] +// else if b[i] == 0 +// r[i] := 0 +// else +// r[i] := a[i] +// fi +// done +FORCE_INLINE __m128i _mm_sign_epi16(__m128i _a, __m128i _b) +{ + int16x8_t a = vreinterpretq_s16_m128i(_a); + int16x8_t b = vreinterpretq_s16_m128i(_b); + + // signed shift right: faster than vclt + // (b < 0) ? 0xFFFF : 0 + uint16x8_t ltMask = vreinterpretq_u16_s16(vshrq_n_s16(b, 15)); + // (b == 0) ? 0xFFFF : 0 +#if defined(__aarch64__) + int16x8_t zeroMask = vreinterpretq_s16_u16(vceqzq_s16(b)); +#else + int16x8_t zeroMask = vreinterpretq_s16_u16(vceqq_s16(b, vdupq_n_s16(0))); +#endif + + // bitwise select either a or negative 'a' (vnegq_s16(a) equals to negative + // 'a') based on ltMask + int16x8_t masked = vbslq_s16(ltMask, vnegq_s16(a), a); + // res = masked & (~zeroMask) + int16x8_t res = vbicq_s16(masked, zeroMask); + return vreinterpretq_m128i_s16(res); +} + +// Negate packed 32-bit integers in a when the corresponding signed +// 32-bit integer in b is negative, and store the results in dst. +// Element in dst are zeroed out when the corresponding element +// in b is zero. +// +// for i in 0..3 +// if b[i] < 0 +// r[i] := -a[i] +// else if b[i] == 0 +// r[i] := 0 +// else +// r[i] := a[i] +// fi +// done +FORCE_INLINE __m128i _mm_sign_epi32(__m128i _a, __m128i _b) +{ + int32x4_t a = vreinterpretq_s32_m128i(_a); + int32x4_t b = vreinterpretq_s32_m128i(_b); + + // signed shift right: faster than vclt + // (b < 0) ? 0xFFFFFFFF : 0 + uint32x4_t ltMask = vreinterpretq_u32_s32(vshrq_n_s32(b, 31)); + + // (b == 0) ? 0xFFFFFFFF : 0 +#if defined(__aarch64__) + int32x4_t zeroMask = vreinterpretq_s32_u32(vceqzq_s32(b)); +#else + int32x4_t zeroMask = vreinterpretq_s32_u32(vceqq_s32(b, vdupq_n_s32(0))); +#endif + + // bitwise select either a or negative 'a' (vnegq_s32(a) equals to negative + // 'a') based on ltMask + int32x4_t masked = vbslq_s32(ltMask, vnegq_s32(a), a); + // res = masked & (~zeroMask) + int32x4_t res = vbicq_s32(masked, zeroMask); + return vreinterpretq_m128i_s32(res); +} + +// Negate packed 16-bit integers in a when the corresponding signed 16-bit +// integer in b is negative, and store the results in dst. Element in dst are +// zeroed out when the corresponding element in b is zero. +// +// FOR j := 0 to 3 +// i := j*16 +// IF b[i+15:i] < 0 +// dst[i+15:i] := -(a[i+15:i]) +// ELSE IF b[i+15:i] == 0 +// dst[i+15:i] := 0 +// ELSE +// dst[i+15:i] := a[i+15:i] +// FI +// ENDFOR +// +// https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_sign_pi16 +FORCE_INLINE __m64 _mm_sign_pi16(__m64 _a, __m64 _b) +{ + int16x4_t a = vreinterpret_s16_m64(_a); + int16x4_t b = vreinterpret_s16_m64(_b); + + // signed shift right: faster than vclt + // (b < 0) ? 0xFFFF : 0 + uint16x4_t ltMask = vreinterpret_u16_s16(vshr_n_s16(b, 15)); + + // (b == 0) ? 0xFFFF : 0 +#if defined(__aarch64__) + int16x4_t zeroMask = vreinterpret_s16_u16(vceqz_s16(b)); +#else + int16x4_t zeroMask = vreinterpret_s16_u16(vceq_s16(b, vdup_n_s16(0))); +#endif + + // bitwise select either a or nagative 'a' (vneg_s16(a) return nagative 'a') + // based on ltMask + int16x4_t masked = vbsl_s16(ltMask, vneg_s16(a), a); + // res = masked & (~zeroMask) + int16x4_t res = vbic_s16(masked, zeroMask); + + return vreinterpret_m64_s16(res); +} + +// Negate packed 32-bit integers in a when the corresponding signed 32-bit +// integer in b is negative, and store the results in dst. Element in dst are +// zeroed out when the corresponding element in b is zero. +// +// FOR j := 0 to 1 +// i := j*32 +// IF b[i+31:i] < 0 +// dst[i+31:i] := -(a[i+31:i]) +// ELSE IF b[i+31:i] == 0 +// dst[i+31:i] := 0 +// ELSE +// dst[i+31:i] := a[i+31:i] +// FI +// ENDFOR +// +// https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_sign_pi32 +FORCE_INLINE __m64 _mm_sign_pi32(__m64 _a, __m64 _b) +{ + int32x2_t a = vreinterpret_s32_m64(_a); + int32x2_t b = vreinterpret_s32_m64(_b); + + // signed shift right: faster than vclt + // (b < 0) ? 0xFFFFFFFF : 0 + uint32x2_t ltMask = vreinterpret_u32_s32(vshr_n_s32(b, 31)); + + // (b == 0) ? 0xFFFFFFFF : 0 +#if defined(__aarch64__) + int32x2_t zeroMask = vreinterpret_s32_u32(vceqz_s32(b)); +#else + int32x2_t zeroMask = vreinterpret_s32_u32(vceq_s32(b, vdup_n_s32(0))); +#endif + + // bitwise select either a or nagative 'a' (vneg_s32(a) return nagative 'a') + // based on ltMask + int32x2_t masked = vbsl_s32(ltMask, vneg_s32(a), a); + // res = masked & (~zeroMask) + int32x2_t res = vbic_s32(masked, zeroMask); + + return vreinterpret_m64_s32(res); +} + +// Negate packed 8-bit integers in a when the corresponding signed 8-bit integer +// in b is negative, and store the results in dst. Element in dst are zeroed out +// when the corresponding element in b is zero. +// +// FOR j := 0 to 7 +// i := j*8 +// IF b[i+7:i] < 0 +// dst[i+7:i] := -(a[i+7:i]) +// ELSE IF b[i+7:i] == 0 +// dst[i+7:i] := 0 +// ELSE +// dst[i+7:i] := a[i+7:i] +// FI +// ENDFOR +// +// https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_sign_pi8 +FORCE_INLINE __m64 _mm_sign_pi8(__m64 _a, __m64 _b) +{ + int8x8_t a = vreinterpret_s8_m64(_a); + int8x8_t b = vreinterpret_s8_m64(_b); + + // signed shift right: faster than vclt + // (b < 0) ? 0xFF : 0 + uint8x8_t ltMask = vreinterpret_u8_s8(vshr_n_s8(b, 7)); + + // (b == 0) ? 0xFF : 0 +#if defined(__aarch64__) + int8x8_t zeroMask = vreinterpret_s8_u8(vceqz_s8(b)); +#else + int8x8_t zeroMask = vreinterpret_s8_u8(vceq_s8(b, vdup_n_s8(0))); +#endif + + // bitwise select either a or nagative 'a' (vneg_s8(a) return nagative 'a') + // based on ltMask + int8x8_t masked = vbsl_s8(ltMask, vneg_s8(a), a); + // res = masked & (~zeroMask) + int8x8_t res = vbic_s8(masked, zeroMask); + + return vreinterpret_m64_s8(res); +} + +// Average packed unsigned 16-bit integers in a and b, and store the results in +// dst. +// +// FOR j := 0 to 3 +// i := j*16 +// dst[i+15:i] := (a[i+15:i] + b[i+15:i] + 1) >> 1 +// ENDFOR +// +// https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_avg_pu16 +FORCE_INLINE __m64 _mm_avg_pu16(__m64 a, __m64 b) +{ + return vreinterpret_m64_u16( + vrhadd_u16(vreinterpret_u16_m64(a), vreinterpret_u16_m64(b))); +} + +// Average packed unsigned 8-bit integers in a and b, and store the results in +// dst. +// +// FOR j := 0 to 7 +// i := j*8 +// dst[i+7:i] := (a[i+7:i] + b[i+7:i] + 1) >> 1 +// ENDFOR +// +// https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_avg_pu8 +FORCE_INLINE __m64 _mm_avg_pu8(__m64 a, __m64 b) +{ + return vreinterpret_m64_u8( + vrhadd_u8(vreinterpret_u8_m64(a), vreinterpret_u8_m64(b))); +} + +// Average packed unsigned 8-bit integers in a and b, and store the results in +// dst. +// +// FOR j := 0 to 7 +// i := j*8 +// dst[i+7:i] := (a[i+7:i] + b[i+7:i] + 1) >> 1 +// ENDFOR +// +// https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_m_pavgb +#define _m_pavgb(a, b) _mm_avg_pu8(a, b) + +// Average packed unsigned 16-bit integers in a and b, and store the results in +// dst. +// +// FOR j := 0 to 3 +// i := j*16 +// dst[i+15:i] := (a[i+15:i] + b[i+15:i] + 1) >> 1 +// ENDFOR +// +// https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_m_pavgw +#define _m_pavgw(a, b) _mm_avg_pu16(a, b) + +// Computes the average of the 16 unsigned 8-bit integers in a and the 16 +// unsigned 8-bit integers in b and rounds. +// +// r0 := (a0 + b0) / 2 +// r1 := (a1 + b1) / 2 +// ... +// r15 := (a15 + b15) / 2 +// +// https://msdn.microsoft.com/en-us/library/vstudio/8zwh554a(v%3dvs.90).aspx +FORCE_INLINE __m128i _mm_avg_epu8(__m128i a, __m128i b) +{ + return vreinterpretq_m128i_u8( + vrhaddq_u8(vreinterpretq_u8_m128i(a), vreinterpretq_u8_m128i(b))); +} + +// Computes the average of the 8 unsigned 16-bit integers in a and the 8 +// unsigned 16-bit integers in b and rounds. +// +// r0 := (a0 + b0) / 2 +// r1 := (a1 + b1) / 2 +// ... +// r7 := (a7 + b7) / 2 +// +// https://msdn.microsoft.com/en-us/library/vstudio/y13ca3c8(v=vs.90).aspx +FORCE_INLINE __m128i _mm_avg_epu16(__m128i a, __m128i b) +{ + return (__m128i) vrhaddq_u16(vreinterpretq_u16_m128i(a), + vreinterpretq_u16_m128i(b)); +} + +// Adds the four single-precision, floating-point values of a and b. +// +// r0 := a0 + b0 +// r1 := a1 + b1 +// r2 := a2 + b2 +// r3 := a3 + b3 +// +// https://msdn.microsoft.com/en-us/library/vstudio/c9848chc(v=vs.100).aspx +FORCE_INLINE __m128 _mm_add_ps(__m128 a, __m128 b) +{ + return vreinterpretq_m128_f32( + vaddq_f32(vreinterpretq_f32_m128(a), vreinterpretq_f32_m128(b))); +} + +// Add packed double-precision (64-bit) floating-point elements in a and b, and +// store the results in dst. +// https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_add_pd +FORCE_INLINE __m128d _mm_add_pd(__m128d a, __m128d b) +{ +#if defined(__aarch64__) + return vreinterpretq_m128d_f64( + vaddq_f64(vreinterpretq_f64_m128d(a), vreinterpretq_f64_m128d(b))); +#else + double *da = (double *) &a; + double *db = (double *) &b; + double c[2]; + c[0] = da[0] + db[0]; + c[1] = da[1] + db[1]; + return vld1q_f32((float32_t *) c); +#endif +} + +// Add 64-bit integers a and b, and store the result in dst. +// +// dst[63:0] := a[63:0] + b[63:0] +// +// https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_add_si64 +FORCE_INLINE __m64 _mm_add_si64(__m64 a, __m64 b) +{ + return vreinterpret_m64_s64( + vadd_s64(vreinterpret_s64_m64(a), vreinterpret_s64_m64(b))); +} + +// adds the scalar single-precision floating point values of a and b. +// https://msdn.microsoft.com/en-us/library/be94x2y6(v=vs.100).aspx +FORCE_INLINE __m128 _mm_add_ss(__m128 a, __m128 b) +{ + float32_t b0 = vgetq_lane_f32(vreinterpretq_f32_m128(b), 0); + float32x4_t value = vsetq_lane_f32(b0, vdupq_n_f32(0), 0); + // the upper values in the result must be the remnants of . + return vreinterpretq_m128_f32(vaddq_f32(a, value)); +} + +// Adds the 4 signed or unsigned 64-bit integers in a to the 4 signed or +// unsigned 32-bit integers in b. +// https://msdn.microsoft.com/en-us/library/vstudio/09xs4fkk(v=vs.100).aspx +FORCE_INLINE __m128i _mm_add_epi64(__m128i a, __m128i b) +{ + return vreinterpretq_m128i_s64( + vaddq_s64(vreinterpretq_s64_m128i(a), vreinterpretq_s64_m128i(b))); +} + +// Adds the 4 signed or unsigned 32-bit integers in a to the 4 signed or +// unsigned 32-bit integers in b. +// +// r0 := a0 + b0 +// r1 := a1 + b1 +// r2 := a2 + b2 +// r3 := a3 + b3 +// +// https://msdn.microsoft.com/en-us/library/vstudio/09xs4fkk(v=vs.100).aspx +FORCE_INLINE __m128i _mm_add_epi32(__m128i a, __m128i b) +{ + return vreinterpretq_m128i_s32( + vaddq_s32(vreinterpretq_s32_m128i(a), vreinterpretq_s32_m128i(b))); +} + +// Adds the 8 signed or unsigned 16-bit integers in a to the 8 signed or +// unsigned 16-bit integers in b. +// https://msdn.microsoft.com/en-us/library/fceha5k4(v=vs.100).aspx +FORCE_INLINE __m128i _mm_add_epi16(__m128i a, __m128i b) +{ + return vreinterpretq_m128i_s16( + vaddq_s16(vreinterpretq_s16_m128i(a), vreinterpretq_s16_m128i(b))); +} + +// Adds the 16 signed or unsigned 8-bit integers in a to the 16 signed or +// unsigned 8-bit integers in b. +// https://technet.microsoft.com/en-us/subscriptions/yc7tcyzs(v=vs.90) +FORCE_INLINE __m128i _mm_add_epi8(__m128i a, __m128i b) +{ + return vreinterpretq_m128i_s8( + vaddq_s8(vreinterpretq_s8_m128i(a), vreinterpretq_s8_m128i(b))); +} + +// Adds the 8 signed 16-bit integers in a to the 8 signed 16-bit integers in b +// and saturates. +// +// r0 := SignedSaturate(a0 + b0) +// r1 := SignedSaturate(a1 + b1) +// ... +// r7 := SignedSaturate(a7 + b7) +// +// https://msdn.microsoft.com/en-us/library/1a306ef8(v=vs.100).aspx +FORCE_INLINE __m128i _mm_adds_epi16(__m128i a, __m128i b) +{ + return vreinterpretq_m128i_s16( + vqaddq_s16(vreinterpretq_s16_m128i(a), vreinterpretq_s16_m128i(b))); +} + +// Add packed signed 8-bit integers in a and b using saturation, and store the +// results in dst. +// +// FOR j := 0 to 15 +// i := j*8 +// dst[i+7:i] := Saturate8( a[i+7:i] + b[i+7:i] ) +// ENDFOR +// +// https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_adds_epi8 +FORCE_INLINE __m128i _mm_adds_epi8(__m128i a, __m128i b) +{ + return vreinterpretq_m128i_s8( + vqaddq_s8(vreinterpretq_s8_m128i(a), vreinterpretq_s8_m128i(b))); +} + +// Adds the 16 unsigned 8-bit integers in a to the 16 unsigned 8-bit integers in +// b and saturates.. +// https://msdn.microsoft.com/en-us/library/9hahyddy(v=vs.100).aspx +FORCE_INLINE __m128i _mm_adds_epu8(__m128i a, __m128i b) +{ + return vreinterpretq_m128i_u8( + vqaddq_u8(vreinterpretq_u8_m128i(a), vreinterpretq_u8_m128i(b))); +} + +// Multiplies the 8 signed or unsigned 16-bit integers from a by the 8 signed or +// unsigned 16-bit integers from b. +// +// r0 := (a0 * b0)[15:0] +// r1 := (a1 * b1)[15:0] +// ... +// r7 := (a7 * b7)[15:0] +// +// https://msdn.microsoft.com/en-us/library/vstudio/9ks1472s(v=vs.100).aspx +FORCE_INLINE __m128i _mm_mullo_epi16(__m128i a, __m128i b) +{ + return vreinterpretq_m128i_s16( + vmulq_s16(vreinterpretq_s16_m128i(a), vreinterpretq_s16_m128i(b))); +} + +// Multiplies the 4 signed or unsigned 32-bit integers from a by the 4 signed or +// unsigned 32-bit integers from b. +// https://msdn.microsoft.com/en-us/library/vstudio/bb531409(v=vs.100).aspx +FORCE_INLINE __m128i _mm_mullo_epi32(__m128i a, __m128i b) +{ + return vreinterpretq_m128i_s32( + vmulq_s32(vreinterpretq_s32_m128i(a), vreinterpretq_s32_m128i(b))); +} + +// Multiply the packed unsigned 16-bit integers in a and b, producing +// intermediate 32-bit integers, and store the high 16 bits of the intermediate +// integers in dst. +// +// FOR j := 0 to 3 +// i := j*16 +// tmp[31:0] := a[i+15:i] * b[i+15:i] +// dst[i+15:i] := tmp[31:16] +// ENDFOR +// +// https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_m_pmulhuw +#define _m_pmulhuw(a, b) _mm_mulhi_pu16(a, b) + +// Multiplies the four single-precision, floating-point values of a and b. +// +// r0 := a0 * b0 +// r1 := a1 * b1 +// r2 := a2 * b2 +// r3 := a3 * b3 +// +// https://msdn.microsoft.com/en-us/library/vstudio/22kbk6t9(v=vs.100).aspx +FORCE_INLINE __m128 _mm_mul_ps(__m128 a, __m128 b) +{ + return vreinterpretq_m128_f32( + vmulq_f32(vreinterpretq_f32_m128(a), vreinterpretq_f32_m128(b))); +} + +// Multiply packed double-precision (64-bit) floating-point elements in a and b, +// and store the results in dst. +// https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_mul_pd +FORCE_INLINE __m128d _mm_mul_pd(__m128d a, __m128d b) +{ +#if defined(__aarch64__) + return vreinterpretq_m128d_f64( + vmulq_f64(vreinterpretq_f64_m128d(a), vreinterpretq_f64_m128d(b))); +#else + double *da = (double *) &a; + double *db = (double *) &b; + double c[2]; + c[0] = da[0] * db[0]; + c[1] = da[1] * db[1]; + return vld1q_f32((float32_t *) c); +#endif +} + +// Multiply the lower single-precision (32-bit) floating-point element in a and +// b, store the result in the lower element of dst, and copy the upper 3 packed +// elements from a to the upper elements of dst. +// +// dst[31:0] := a[31:0] * b[31:0] +// dst[127:32] := a[127:32] +// +// https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_mul_ss +FORCE_INLINE __m128 _mm_mul_ss(__m128 a, __m128 b) +{ + return _mm_move_ss(a, _mm_mul_ps(a, b)); +} + +// Multiply the low unsigned 32-bit integers from each packed 64-bit element in +// a and b, and store the unsigned 64-bit results in dst. +// +// r0 := (a0 & 0xFFFFFFFF) * (b0 & 0xFFFFFFFF) +// r1 := (a2 & 0xFFFFFFFF) * (b2 & 0xFFFFFFFF) +FORCE_INLINE __m128i _mm_mul_epu32(__m128i a, __m128i b) +{ + // vmull_u32 upcasts instead of masking, so we downcast. + uint32x2_t a_lo = vmovn_u64(vreinterpretq_u64_m128i(a)); + uint32x2_t b_lo = vmovn_u64(vreinterpretq_u64_m128i(b)); + return vreinterpretq_m128i_u64(vmull_u32(a_lo, b_lo)); +} + +// Multiply the low unsigned 32-bit integers from a and b, and store the +// unsigned 64-bit result in dst. +// +// dst[63:0] := a[31:0] * b[31:0] +// +// https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_mul_su32 +FORCE_INLINE __m64 _mm_mul_su32(__m64 a, __m64 b) +{ + return vreinterpret_m64_u64(vget_low_u64( + vmull_u32(vreinterpret_u32_m64(a), vreinterpret_u32_m64(b)))); +} + +// Multiply the low signed 32-bit integers from each packed 64-bit element in +// a and b, and store the signed 64-bit results in dst. +// +// r0 := (int64_t)(int32_t)a0 * (int64_t)(int32_t)b0 +// r1 := (int64_t)(int32_t)a2 * (int64_t)(int32_t)b2 +FORCE_INLINE __m128i _mm_mul_epi32(__m128i a, __m128i b) +{ + // vmull_s32 upcasts instead of masking, so we downcast. + int32x2_t a_lo = vmovn_s64(vreinterpretq_s64_m128i(a)); + int32x2_t b_lo = vmovn_s64(vreinterpretq_s64_m128i(b)); + return vreinterpretq_m128i_s64(vmull_s32(a_lo, b_lo)); +} + +// Multiplies the 8 signed 16-bit integers from a by the 8 signed 16-bit +// integers from b. +// +// r0 := (a0 * b0) + (a1 * b1) +// r1 := (a2 * b2) + (a3 * b3) +// r2 := (a4 * b4) + (a5 * b5) +// r3 := (a6 * b6) + (a7 * b7) +// https://msdn.microsoft.com/en-us/library/yht36sa6(v=vs.90).aspx +FORCE_INLINE __m128i _mm_madd_epi16(__m128i a, __m128i b) +{ + int32x4_t low = vmull_s16(vget_low_s16(vreinterpretq_s16_m128i(a)), + vget_low_s16(vreinterpretq_s16_m128i(b))); + int32x4_t high = vmull_s16(vget_high_s16(vreinterpretq_s16_m128i(a)), + vget_high_s16(vreinterpretq_s16_m128i(b))); + + int32x2_t low_sum = vpadd_s32(vget_low_s32(low), vget_high_s32(low)); + int32x2_t high_sum = vpadd_s32(vget_low_s32(high), vget_high_s32(high)); + + return vreinterpretq_m128i_s32(vcombine_s32(low_sum, high_sum)); +} + +// Multiply packed signed 16-bit integers in a and b, producing intermediate +// signed 32-bit integers. Shift right by 15 bits while rounding up, and store +// the packed 16-bit integers in dst. +// +// r0 := Round(((int32_t)a0 * (int32_t)b0) >> 15) +// r1 := Round(((int32_t)a1 * (int32_t)b1) >> 15) +// r2 := Round(((int32_t)a2 * (int32_t)b2) >> 15) +// ... +// r7 := Round(((int32_t)a7 * (int32_t)b7) >> 15) +FORCE_INLINE __m128i _mm_mulhrs_epi16(__m128i a, __m128i b) +{ + // Has issues due to saturation + // return vreinterpretq_m128i_s16(vqrdmulhq_s16(a, b)); + + // Multiply + int32x4_t mul_lo = vmull_s16(vget_low_s16(vreinterpretq_s16_m128i(a)), + vget_low_s16(vreinterpretq_s16_m128i(b))); + int32x4_t mul_hi = vmull_s16(vget_high_s16(vreinterpretq_s16_m128i(a)), + vget_high_s16(vreinterpretq_s16_m128i(b))); + + // Rounding narrowing shift right + // narrow = (int16_t)((mul + 16384) >> 15); + int16x4_t narrow_lo = vrshrn_n_s32(mul_lo, 15); + int16x4_t narrow_hi = vrshrn_n_s32(mul_hi, 15); + + // Join together + return vreinterpretq_m128i_s16(vcombine_s16(narrow_lo, narrow_hi)); +} + +// Vertically multiply each unsigned 8-bit integer from a with the corresponding +// signed 8-bit integer from b, producing intermediate signed 16-bit integers. +// Horizontally add adjacent pairs of intermediate signed 16-bit integers, +// and pack the saturated results in dst. +// +// FOR j := 0 to 7 +// i := j*16 +// dst[i+15:i] := Saturate_To_Int16( a[i+15:i+8]*b[i+15:i+8] + +// a[i+7:i]*b[i+7:i] ) +// ENDFOR +FORCE_INLINE __m128i _mm_maddubs_epi16(__m128i _a, __m128i _b) +{ +#if defined(__aarch64__) + uint8x16_t a = vreinterpretq_u8_m128i(_a); + int8x16_t b = vreinterpretq_s8_m128i(_b); + int16x8_t tl = vmulq_s16(vreinterpretq_s16_u16(vmovl_u8(vget_low_u8(a))), + vmovl_s8(vget_low_s8(b))); + int16x8_t th = vmulq_s16(vreinterpretq_s16_u16(vmovl_u8(vget_high_u8(a))), + vmovl_s8(vget_high_s8(b))); + return vreinterpretq_m128i_s16( + vqaddq_s16(vuzp1q_s16(tl, th), vuzp2q_s16(tl, th))); +#else + // This would be much simpler if x86 would choose to zero extend OR sign + // extend, not both. This could probably be optimized better. + uint16x8_t a = vreinterpretq_u16_m128i(_a); + int16x8_t b = vreinterpretq_s16_m128i(_b); + + // Zero extend a + int16x8_t a_odd = vreinterpretq_s16_u16(vshrq_n_u16(a, 8)); + int16x8_t a_even = vreinterpretq_s16_u16(vbicq_u16(a, vdupq_n_u16(0xff00))); + + // Sign extend by shifting left then shifting right. + int16x8_t b_even = vshrq_n_s16(vshlq_n_s16(b, 8), 8); + int16x8_t b_odd = vshrq_n_s16(b, 8); + + // multiply + int16x8_t prod1 = vmulq_s16(a_even, b_even); + int16x8_t prod2 = vmulq_s16(a_odd, b_odd); + + // saturated add + return vreinterpretq_m128i_s16(vqaddq_s16(prod1, prod2)); +#endif +} + +// Computes the fused multiple add product of 32-bit floating point numbers. +// +// Return Value +// Multiplies A and B, and adds C to the temporary result before returning it. +// https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_fmadd +FORCE_INLINE __m128 _mm_fmadd_ps(__m128 a, __m128 b, __m128 c) +{ +#if defined(__aarch64__) + return vreinterpretq_m128_f32(vfmaq_f32(vreinterpretq_f32_m128(c), + vreinterpretq_f32_m128(b), + vreinterpretq_f32_m128(a))); +#else + return _mm_add_ps(_mm_mul_ps(a, b), c); +#endif +} + +// Alternatively add and subtract packed single-precision (32-bit) +// floating-point elements in a to/from packed elements in b, and store the +// results in dst. +// +// https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=addsub_ps +FORCE_INLINE __m128 _mm_addsub_ps(__m128 a, __m128 b) +{ + __m128 mask = {-1.0f, 1.0f, -1.0f, 1.0f}; + return _mm_fmadd_ps(b, mask, a); +} + +// Compute the absolute differences of packed unsigned 8-bit integers in a and +// b, then horizontally sum each consecutive 8 differences to produce two +// unsigned 16-bit integers, and pack these unsigned 16-bit integers in the low +// 16 bits of 64-bit elements in dst. +// https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_sad_epu8 +FORCE_INLINE __m128i _mm_sad_epu8(__m128i a, __m128i b) +{ + uint16x8_t t = vpaddlq_u8(vabdq_u8((uint8x16_t) a, (uint8x16_t) b)); + uint16_t r0 = t[0] + t[1] + t[2] + t[3]; + uint16_t r4 = t[4] + t[5] + t[6] + t[7]; + uint16x8_t r = vsetq_lane_u16(r0, vdupq_n_u16(0), 0); + return (__m128i) vsetq_lane_u16(r4, r, 4); +} + +// Compute the absolute differences of packed unsigned 8-bit integers in a and +// b, then horizontally sum each consecutive 8 differences to produce four +// unsigned 16-bit integers, and pack these unsigned 16-bit integers in the low +// 16 bits of dst. +// https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_sad_pu8 +FORCE_INLINE __m64 _mm_sad_pu8(__m64 a, __m64 b) +{ + uint16x4_t t = + vpaddl_u8(vabd_u8(vreinterpret_u8_m64(a), vreinterpret_u8_m64(b))); + uint16_t r0 = t[0] + t[1] + t[2] + t[3]; + return vreinterpret_m64_u16(vset_lane_u16(r0, vdup_n_u16(0), 0)); +} + +// Compute the absolute differences of packed unsigned 8-bit integers in a and +// b, then horizontally sum each consecutive 8 differences to produce four +// unsigned 16-bit integers, and pack these unsigned 16-bit integers in the low +// 16 bits of dst. +// +// FOR j := 0 to 7 +// i := j*8 +// tmp[i+7:i] := ABS(a[i+7:i] - b[i+7:i]) +// ENDFOR +// dst[15:0] := tmp[7:0] + tmp[15:8] + tmp[23:16] + tmp[31:24] + tmp[39:32] + +// tmp[47:40] + tmp[55:48] + tmp[63:56] dst[63:16] := 0 +// +// https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_m_psadbw +#define _m_psadbw(a, b) _mm_sad_pu8(a, b) + +// Divides the four single-precision, floating-point values of a and b. +// +// r0 := a0 / b0 +// r1 := a1 / b1 +// r2 := a2 / b2 +// r3 := a3 / b3 +// +// https://msdn.microsoft.com/en-us/library/edaw8147(v=vs.100).aspx +FORCE_INLINE __m128 _mm_div_ps(__m128 a, __m128 b) +{ +#if defined(__aarch64__) + return vreinterpretq_m128_f32( + vdivq_f32(vreinterpretq_f32_m128(a), vreinterpretq_f32_m128(b))); +#else + float32x4_t recip0 = vrecpeq_f32(vreinterpretq_f32_m128(b)); + float32x4_t recip1 = + vmulq_f32(recip0, vrecpsq_f32(recip0, vreinterpretq_f32_m128(b))); + return vreinterpretq_m128_f32(vmulq_f32(vreinterpretq_f32_m128(a), recip1)); +#endif +} + +// Divides the scalar single-precision floating point value of a by b. +// https://msdn.microsoft.com/en-us/library/4y73xa49(v=vs.100).aspx +FORCE_INLINE __m128 _mm_div_ss(__m128 a, __m128 b) +{ + float32_t value = + vgetq_lane_f32(vreinterpretq_f32_m128(_mm_div_ps(a, b)), 0); + return vreinterpretq_m128_f32( + vsetq_lane_f32(value, vreinterpretq_f32_m128(a), 0)); +} + +// Compute the approximate reciprocal of packed single-precision (32-bit) +// floating-point elements in a, and store the results in dst. The maximum +// relative error for this approximation is less than 1.5*2^-12. +// https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_rcp_ps +FORCE_INLINE __m128 _mm_rcp_ps(__m128 in) +{ +#if defined(__aarch64__) + return vreinterpretq_m128_f32( + vdivq_f32(vdupq_n_f32(1.0f), vreinterpretq_f32_m128(in))); +#else + float32x4_t recip = vrecpeq_f32(vreinterpretq_f32_m128(in)); + recip = vmulq_f32(recip, vrecpsq_f32(recip, vreinterpretq_f32_m128(in))); + return vreinterpretq_m128_f32(recip); +#endif +} + +// Compute the approximate reciprocal of the lower single-precision (32-bit) +// floating-point element in a, store the result in the lower element of dst, +// and copy the upper 3 packed elements from a to the upper elements of dst. The +// maximum relative error for this approximation is less than 1.5*2^-12. +// +// dst[31:0] := (1.0 / a[31:0]) +// dst[127:32] := a[127:32] +// +// https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_rcp_ss +FORCE_INLINE __m128 _mm_rcp_ss(__m128 a) +{ + return _mm_move_ss(a, _mm_rcp_ps(a)); +} + +// Computes the approximations of square roots of the four single-precision, +// floating-point values of a. First computes reciprocal square roots and then +// reciprocals of the four values. +// +// r0 := sqrt(a0) +// r1 := sqrt(a1) +// r2 := sqrt(a2) +// r3 := sqrt(a3) +// +// https://msdn.microsoft.com/en-us/library/vstudio/8z67bwwk(v=vs.100).aspx +FORCE_INLINE __m128 _mm_sqrt_ps(__m128 in) +{ +#if defined(__aarch64__) + return vreinterpretq_m128_f32(vsqrtq_f32(vreinterpretq_f32_m128(in))); +#else + float32x4_t recipsq = vrsqrteq_f32(vreinterpretq_f32_m128(in)); + float32x4_t sq = vrecpeq_f32(recipsq); + // ??? use step versions of both sqrt and recip for better accuracy? + return vreinterpretq_m128_f32(sq); +#endif +} + +// Computes the approximation of the square root of the scalar single-precision +// floating point value of in. +// https://msdn.microsoft.com/en-us/library/ahfsc22d(v=vs.100).aspx +FORCE_INLINE __m128 _mm_sqrt_ss(__m128 in) +{ + float32_t value = + vgetq_lane_f32(vreinterpretq_f32_m128(_mm_sqrt_ps(in)), 0); + return vreinterpretq_m128_f32( + vsetq_lane_f32(value, vreinterpretq_f32_m128(in), 0)); +} + +// Computes the approximations of the reciprocal square roots of the four +// single-precision floating point values of in. +// https://msdn.microsoft.com/en-us/library/22hfsh53(v=vs.100).aspx +FORCE_INLINE __m128 _mm_rsqrt_ps(__m128 in) +{ + return vreinterpretq_m128_f32(vrsqrteq_f32(vreinterpretq_f32_m128(in))); +} + +// Compute the approximate reciprocal square root of the lower single-precision +// (32-bit) floating-point element in a, store the result in the lower element +// of dst, and copy the upper 3 packed elements from a to the upper elements of +// dst. +// https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_rsqrt_ss +FORCE_INLINE __m128 _mm_rsqrt_ss(__m128 in) +{ + return vsetq_lane_f32(vgetq_lane_f32(_mm_rsqrt_ps(in), 0), in, 0); +} + +// Compare packed signed 16-bit integers in a and b, and store packed maximum +// values in dst. +// +// FOR j := 0 to 3 +// i := j*16 +// dst[i+15:i] := MAX(a[i+15:i], b[i+15:i]) +// ENDFOR +// +// https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_max_pi16 +FORCE_INLINE __m64 _mm_max_pi16(__m64 a, __m64 b) +{ + return vreinterpret_m64_s16( + vmax_s16(vreinterpret_s16_m64(a), vreinterpret_s16_m64(b))); +} + +// Compare packed signed 16-bit integers in a and b, and store packed maximum +// values in dst. +// +// FOR j := 0 to 3 +// i := j*16 +// dst[i+15:i] := MAX(a[i+15:i], b[i+15:i]) +// ENDFOR +// +// https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_max_pi16 +#define _m_pmaxsw(a, b) _mm_max_pi16(a, b) + +// Computes the maximums of the four single-precision, floating-point values of +// a and b. +// https://msdn.microsoft.com/en-us/library/vstudio/ff5d607a(v=vs.100).aspx +FORCE_INLINE __m128 _mm_max_ps(__m128 a, __m128 b) +{ +#if SSE2NEON_PRECISE_MINMAX + float32x4_t _a = vreinterpretq_f32_m128(a); + float32x4_t _b = vreinterpretq_f32_m128(b); + return vbslq_f32(vcltq_f32(_b, _a), _a, _b); +#else + return vreinterpretq_m128_f32( + vmaxq_f32(vreinterpretq_f32_m128(a), vreinterpretq_f32_m128(b))); +#endif +} + +// Compare packed unsigned 8-bit integers in a and b, and store packed maximum +// values in dst. +// +// FOR j := 0 to 7 +// i := j*8 +// dst[i+7:i] := MAX(a[i+7:i], b[i+7:i]) +// ENDFOR +// +// https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_max_pu8 +FORCE_INLINE __m64 _mm_max_pu8(__m64 a, __m64 b) +{ + return vreinterpret_m64_u8( + vmax_u8(vreinterpret_u8_m64(a), vreinterpret_u8_m64(b))); +} + +// Compare packed unsigned 8-bit integers in a and b, and store packed maximum +// values in dst. +// +// FOR j := 0 to 7 +// i := j*8 +// dst[i+7:i] := MAX(a[i+7:i], b[i+7:i]) +// ENDFOR +// +// https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_max_pu8 +#define _m_pmaxub(a, b) _mm_max_pu8(a, b) + +// Compare packed signed 16-bit integers in a and b, and store packed minimum +// values in dst. +// +// FOR j := 0 to 3 +// i := j*16 +// dst[i+15:i] := MIN(a[i+15:i], b[i+15:i]) +// ENDFOR +// +// https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_min_pi16 +FORCE_INLINE __m64 _mm_min_pi16(__m64 a, __m64 b) +{ + return vreinterpret_m64_s16( + vmin_s16(vreinterpret_s16_m64(a), vreinterpret_s16_m64(b))); +} + +// Compare packed signed 16-bit integers in a and b, and store packed minimum +// values in dst. +// +// FOR j := 0 to 3 +// i := j*16 +// dst[i+15:i] := MIN(a[i+15:i], b[i+15:i]) +// ENDFOR +// +// https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_min_pi16 +#define _m_pminsw(a, b) _mm_min_pi16(a, b) + +// Computes the minima of the four single-precision, floating-point values of a +// and b. +// https://msdn.microsoft.com/en-us/library/vstudio/wh13kadz(v=vs.100).aspx +FORCE_INLINE __m128 _mm_min_ps(__m128 a, __m128 b) +{ +#if SSE2NEON_PRECISE_MINMAX + float32x4_t _a = vreinterpretq_f32_m128(a); + float32x4_t _b = vreinterpretq_f32_m128(b); + return vbslq_f32(vcltq_f32(_a, _b), _a, _b); +#else + return vreinterpretq_m128_f32( + vminq_f32(vreinterpretq_f32_m128(a), vreinterpretq_f32_m128(b))); +#endif +} + +// Compare packed unsigned 8-bit integers in a and b, and store packed minimum +// values in dst. +// +// FOR j := 0 to 7 +// i := j*8 +// dst[i+7:i] := MIN(a[i+7:i], b[i+7:i]) +// ENDFOR +// +// https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_min_pu8 +FORCE_INLINE __m64 _mm_min_pu8(__m64 a, __m64 b) +{ + return vreinterpret_m64_u8( + vmin_u8(vreinterpret_u8_m64(a), vreinterpret_u8_m64(b))); +} + +// Compare packed unsigned 8-bit integers in a and b, and store packed minimum +// values in dst. +// +// FOR j := 0 to 7 +// i := j*8 +// dst[i+7:i] := MIN(a[i+7:i], b[i+7:i]) +// ENDFOR +// +// https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_min_pu8 +#define _m_pminub(a, b) _mm_min_pu8(a, b) + +// Computes the maximum of the two lower scalar single-precision floating point +// values of a and b. +// https://msdn.microsoft.com/en-us/library/s6db5esz(v=vs.100).aspx +FORCE_INLINE __m128 _mm_max_ss(__m128 a, __m128 b) +{ + float32_t value = vgetq_lane_f32(_mm_max_ps(a, b), 0); + return vreinterpretq_m128_f32( + vsetq_lane_f32(value, vreinterpretq_f32_m128(a), 0)); +} + +// Computes the minimum of the two lower scalar single-precision floating point +// values of a and b. +// https://msdn.microsoft.com/en-us/library/0a9y7xaa(v=vs.100).aspx +FORCE_INLINE __m128 _mm_min_ss(__m128 a, __m128 b) +{ + float32_t value = vgetq_lane_f32(_mm_min_ps(a, b), 0); + return vreinterpretq_m128_f32( + vsetq_lane_f32(value, vreinterpretq_f32_m128(a), 0)); +} + +// Computes the pairwise maxima of the 16 unsigned 8-bit integers from a and the +// 16 unsigned 8-bit integers from b. +// https://msdn.microsoft.com/en-us/library/st6634za(v=vs.100).aspx +FORCE_INLINE __m128i _mm_max_epu8(__m128i a, __m128i b) +{ + return vreinterpretq_m128i_u8( + vmaxq_u8(vreinterpretq_u8_m128i(a), vreinterpretq_u8_m128i(b))); +} + +// Computes the pairwise minima of the 16 unsigned 8-bit integers from a and the +// 16 unsigned 8-bit integers from b. +// https://msdn.microsoft.com/ko-kr/library/17k8cf58(v=vs.100).aspxx +FORCE_INLINE __m128i _mm_min_epu8(__m128i a, __m128i b) +{ + return vreinterpretq_m128i_u8( + vminq_u8(vreinterpretq_u8_m128i(a), vreinterpretq_u8_m128i(b))); +} + +// Computes the pairwise minima of the 8 signed 16-bit integers from a and the 8 +// signed 16-bit integers from b. +// https://msdn.microsoft.com/en-us/library/vstudio/6te997ew(v=vs.100).aspx +FORCE_INLINE __m128i _mm_min_epi16(__m128i a, __m128i b) +{ + return vreinterpretq_m128i_s16( + vminq_s16(vreinterpretq_s16_m128i(a), vreinterpretq_s16_m128i(b))); +} + +// Compare packed signed 8-bit integers in a and b, and store packed maximum +// values in dst. +// https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_max_epi8 +FORCE_INLINE __m128i _mm_max_epi8(__m128i a, __m128i b) +{ + return vreinterpretq_m128i_s8( + vmaxq_s8(vreinterpretq_s8_m128i(a), vreinterpretq_s8_m128i(b))); +} + +// Compare packed unsigned 16-bit integers in a and b, and store packed maximum +// values in dst. +// https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_max_epu16 +FORCE_INLINE __m128i _mm_max_epu16(__m128i a, __m128i b) +{ + return vreinterpretq_m128i_u16( + vmaxq_u16(vreinterpretq_u16_m128i(a), vreinterpretq_u16_m128i(b))); +} + +// Compare packed signed 8-bit integers in a and b, and store packed minimum +// values in dst. +// https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_min_epi8 +FORCE_INLINE __m128i _mm_min_epi8(__m128i a, __m128i b) +{ + return vreinterpretq_m128i_s8( + vminq_s8(vreinterpretq_s8_m128i(a), vreinterpretq_s8_m128i(b))); +} + +// Compare packed unsigned 16-bit integers in a and b, and store packed minimum +// values in dst. +// https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_min_epu16 +FORCE_INLINE __m128i _mm_min_epu16(__m128i a, __m128i b) +{ + return vreinterpretq_m128i_u16( + vminq_u16(vreinterpretq_u16_m128i(a), vreinterpretq_u16_m128i(b))); +} + +// Computes the pairwise maxima of the 8 signed 16-bit integers from a and the 8 +// signed 16-bit integers from b. +// https://msdn.microsoft.com/en-us/LIBRary/3x060h7c(v=vs.100).aspx +FORCE_INLINE __m128i _mm_max_epi16(__m128i a, __m128i b) +{ + return vreinterpretq_m128i_s16( + vmaxq_s16(vreinterpretq_s16_m128i(a), vreinterpretq_s16_m128i(b))); +} + +// epi versions of min/max +// Computes the pariwise maximums of the four signed 32-bit integer values of a +// and b. +// +// A 128-bit parameter that can be defined with the following equations: +// r0 := (a0 > b0) ? a0 : b0 +// r1 := (a1 > b1) ? a1 : b1 +// r2 := (a2 > b2) ? a2 : b2 +// r3 := (a3 > b3) ? a3 : b3 +// +// https://msdn.microsoft.com/en-us/library/vstudio/bb514055(v=vs.100).aspx +FORCE_INLINE __m128i _mm_max_epi32(__m128i a, __m128i b) +{ + return vreinterpretq_m128i_s32( + vmaxq_s32(vreinterpretq_s32_m128i(a), vreinterpretq_s32_m128i(b))); +} + +// Computes the pariwise minima of the four signed 32-bit integer values of a +// and b. +// +// A 128-bit parameter that can be defined with the following equations: +// r0 := (a0 < b0) ? a0 : b0 +// r1 := (a1 < b1) ? a1 : b1 +// r2 := (a2 < b2) ? a2 : b2 +// r3 := (a3 < b3) ? a3 : b3 +// +// https://msdn.microsoft.com/en-us/library/vstudio/bb531476(v=vs.100).aspx +FORCE_INLINE __m128i _mm_min_epi32(__m128i a, __m128i b) +{ + return vreinterpretq_m128i_s32( + vminq_s32(vreinterpretq_s32_m128i(a), vreinterpretq_s32_m128i(b))); +} + +// Compare packed unsigned 32-bit integers in a and b, and store packed maximum +// values in dst. +// https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_max_epu32 +FORCE_INLINE __m128i _mm_max_epu32(__m128i a, __m128i b) +{ + return vreinterpretq_m128i_u32( + vmaxq_u32(vreinterpretq_u32_m128i(a), vreinterpretq_u32_m128i(b))); +} + +// Compare packed unsigned 32-bit integers in a and b, and store packed minimum +// values in dst. +// https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_max_epu32 +FORCE_INLINE __m128i _mm_min_epu32(__m128i a, __m128i b) +{ + return vreinterpretq_m128i_u32( + vminq_u32(vreinterpretq_u32_m128i(a), vreinterpretq_u32_m128i(b))); +} + +// Multiply the packed unsigned 16-bit integers in a and b, producing +// intermediate 32-bit integers, and store the high 16 bits of the intermediate +// integers in dst. +// https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_mulhi_pu16 +FORCE_INLINE __m64 _mm_mulhi_pu16(__m64 a, __m64 b) +{ + return vreinterpret_m64_u16(vshrn_n_u32( + vmull_u16(vreinterpret_u16_m64(a), vreinterpret_u16_m64(b)), 16)); +} + +// Multiplies the 8 signed 16-bit integers from a by the 8 signed 16-bit +// integers from b. +// +// r0 := (a0 * b0)[31:16] +// r1 := (a1 * b1)[31:16] +// ... +// r7 := (a7 * b7)[31:16] +// +// https://msdn.microsoft.com/en-us/library/vstudio/59hddw1d(v=vs.100).aspx +FORCE_INLINE __m128i _mm_mulhi_epi16(__m128i a, __m128i b) +{ + /* FIXME: issue with large values because of result saturation */ + // int16x8_t ret = vqdmulhq_s16(vreinterpretq_s16_m128i(a), + // vreinterpretq_s16_m128i(b)); /* =2*a*b */ return + // vreinterpretq_m128i_s16(vshrq_n_s16(ret, 1)); + int16x4_t a3210 = vget_low_s16(vreinterpretq_s16_m128i(a)); + int16x4_t b3210 = vget_low_s16(vreinterpretq_s16_m128i(b)); + int32x4_t ab3210 = vmull_s16(a3210, b3210); /* 3333222211110000 */ + int16x4_t a7654 = vget_high_s16(vreinterpretq_s16_m128i(a)); + int16x4_t b7654 = vget_high_s16(vreinterpretq_s16_m128i(b)); + int32x4_t ab7654 = vmull_s16(a7654, b7654); /* 7777666655554444 */ + uint16x8x2_t r = + vuzpq_u16(vreinterpretq_u16_s32(ab3210), vreinterpretq_u16_s32(ab7654)); + return vreinterpretq_m128i_u16(r.val[1]); +} + +// Multiply the packed unsigned 16-bit integers in a and b, producing +// intermediate 32-bit integers, and store the high 16 bits of the intermediate +// integers in dst. +// https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_mulhi_epu16 +FORCE_INLINE __m128i _mm_mulhi_epu16(__m128i a, __m128i b) +{ + uint16x4_t a3210 = vget_low_u16(vreinterpretq_u16_m128i(a)); + uint16x4_t b3210 = vget_low_u16(vreinterpretq_u16_m128i(b)); + uint32x4_t ab3210 = vmull_u16(a3210, b3210); +#if defined(__aarch64__) + uint32x4_t ab7654 = + vmull_high_u16(vreinterpretq_u16_m128i(a), vreinterpretq_u16_m128i(b)); + uint16x8_t r = vuzp2q_u16(vreinterpretq_u16_u32(ab3210), + vreinterpretq_u16_u32(ab7654)); + return vreinterpretq_m128i_u16(r); +#else + uint16x4_t a7654 = vget_high_u16(vreinterpretq_u16_m128i(a)); + uint16x4_t b7654 = vget_high_u16(vreinterpretq_u16_m128i(b)); + uint32x4_t ab7654 = vmull_u16(a7654, b7654); + uint16x8x2_t r = + vuzpq_u16(vreinterpretq_u16_u32(ab3210), vreinterpretq_u16_u32(ab7654)); + return vreinterpretq_m128i_u16(r.val[1]); +#endif +} + +// Computes pairwise add of each argument as single-precision, floating-point +// values a and b. +// https://msdn.microsoft.com/en-us/library/yd9wecaa.aspx +FORCE_INLINE __m128 _mm_hadd_ps(__m128 a, __m128 b) +{ +#if defined(__aarch64__) + return vreinterpretq_m128_f32( + vpaddq_f32(vreinterpretq_f32_m128(a), vreinterpretq_f32_m128(b))); +#else + float32x2_t a10 = vget_low_f32(vreinterpretq_f32_m128(a)); + float32x2_t a32 = vget_high_f32(vreinterpretq_f32_m128(a)); + float32x2_t b10 = vget_low_f32(vreinterpretq_f32_m128(b)); + float32x2_t b32 = vget_high_f32(vreinterpretq_f32_m128(b)); + return vreinterpretq_m128_f32( + vcombine_f32(vpadd_f32(a10, a32), vpadd_f32(b10, b32))); +#endif +} + +// Computes pairwise add of each argument as a 16-bit signed or unsigned integer +// values a and b. +FORCE_INLINE __m128i _mm_hadd_epi16(__m128i _a, __m128i _b) +{ + int16x8_t a = vreinterpretq_s16_m128i(_a); + int16x8_t b = vreinterpretq_s16_m128i(_b); +#if defined(__aarch64__) + return vreinterpretq_m128i_s16(vpaddq_s16(a, b)); +#else + return vreinterpretq_m128i_s16( + vcombine_s16(vpadd_s16(vget_low_s16(a), vget_high_s16(a)), + vpadd_s16(vget_low_s16(b), vget_high_s16(b)))); +#endif +} + +// Horizontally substract adjacent pairs of single-precision (32-bit) +// floating-point elements in a and b, and pack the results in dst. +// https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_hsub_ps +FORCE_INLINE __m128 _mm_hsub_ps(__m128 _a, __m128 _b) +{ +#if defined(__aarch64__) + return vreinterpretq_m128_f32(vsubq_f32( + vuzp1q_f32(vreinterpretq_f32_m128(_a), vreinterpretq_f32_m128(_b)), + vuzp2q_f32(vreinterpretq_f32_m128(_a), vreinterpretq_f32_m128(_b)))); +#else + float32x4x2_t c = + vuzpq_f32(vreinterpretq_f32_m128(_a), vreinterpretq_f32_m128(_b)); + return vreinterpretq_m128_f32(vsubq_f32(c.val[0], c.val[1])); +#endif +} + +// Horizontally add adjacent pairs of 16-bit integers in a and b, and pack the +// signed 16-bit results in dst. +// https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_hadd_pi16 +FORCE_INLINE __m64 _mm_hadd_pi16(__m64 a, __m64 b) +{ + return vreinterpret_m64_s16( + vpadd_s16(vreinterpret_s16_m64(a), vreinterpret_s16_m64(b))); +} + +// Horizontally add adjacent pairs of 32-bit integers in a and b, and pack the +// signed 32-bit results in dst. +// https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_hadd_pi32 +FORCE_INLINE __m64 _mm_hadd_pi32(__m64 a, __m64 b) +{ + return vreinterpret_m64_s32( + vpadd_s32(vreinterpret_s32_m64(a), vreinterpret_s32_m64(b))); +} + +// Computes pairwise difference of each argument as a 16-bit signed or unsigned +// integer values a and b. +FORCE_INLINE __m128i _mm_hsub_epi16(__m128i _a, __m128i _b) +{ + int32x4_t a = vreinterpretq_s32_m128i(_a); + int32x4_t b = vreinterpretq_s32_m128i(_b); + // Interleave using vshrn/vmovn + // [a0|a2|a4|a6|b0|b2|b4|b6] + // [a1|a3|a5|a7|b1|b3|b5|b7] + int16x8_t ab0246 = vcombine_s16(vmovn_s32(a), vmovn_s32(b)); + int16x8_t ab1357 = vcombine_s16(vshrn_n_s32(a, 16), vshrn_n_s32(b, 16)); + // Subtract + return vreinterpretq_m128i_s16(vsubq_s16(ab0246, ab1357)); +} + +// Computes saturated pairwise sub of each argument as a 16-bit signed +// integer values a and b. +FORCE_INLINE __m128i _mm_hadds_epi16(__m128i _a, __m128i _b) +{ +#if defined(__aarch64__) + int16x8_t a = vreinterpretq_s16_m128i(_a); + int16x8_t b = vreinterpretq_s16_m128i(_b); + return vreinterpretq_s64_s16( + vqaddq_s16(vuzp1q_s16(a, b), vuzp2q_s16(a, b))); +#else + int32x4_t a = vreinterpretq_s32_m128i(_a); + int32x4_t b = vreinterpretq_s32_m128i(_b); + // Interleave using vshrn/vmovn + // [a0|a2|a4|a6|b0|b2|b4|b6] + // [a1|a3|a5|a7|b1|b3|b5|b7] + int16x8_t ab0246 = vcombine_s16(vmovn_s32(a), vmovn_s32(b)); + int16x8_t ab1357 = vcombine_s16(vshrn_n_s32(a, 16), vshrn_n_s32(b, 16)); + // Saturated add + return vreinterpretq_m128i_s16(vqaddq_s16(ab0246, ab1357)); +#endif +} + +// Computes saturated pairwise difference of each argument as a 16-bit signed +// integer values a and b. +// https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_hsubs_epi16 +FORCE_INLINE __m128i _mm_hsubs_epi16(__m128i _a, __m128i _b) +{ +#if defined(__aarch64__) + int16x8_t a = vreinterpretq_s16_m128i(_a); + int16x8_t b = vreinterpretq_s16_m128i(_b); + return vreinterpretq_s64_s16( + vqsubq_s16(vuzp1q_s16(a, b), vuzp2q_s16(a, b))); +#else + int32x4_t a = vreinterpretq_s32_m128i(_a); + int32x4_t b = vreinterpretq_s32_m128i(_b); + // Interleave using vshrn/vmovn + // [a0|a2|a4|a6|b0|b2|b4|b6] + // [a1|a3|a5|a7|b1|b3|b5|b7] + int16x8_t ab0246 = vcombine_s16(vmovn_s32(a), vmovn_s32(b)); + int16x8_t ab1357 = vcombine_s16(vshrn_n_s32(a, 16), vshrn_n_s32(b, 16)); + // Saturated subtract + return vreinterpretq_m128i_s16(vqsubq_s16(ab0246, ab1357)); +#endif +} + +// Computes pairwise add of each argument as a 32-bit signed or unsigned integer +// values a and b. +FORCE_INLINE __m128i _mm_hadd_epi32(__m128i _a, __m128i _b) +{ + int32x4_t a = vreinterpretq_s32_m128i(_a); + int32x4_t b = vreinterpretq_s32_m128i(_b); + return vreinterpretq_m128i_s32( + vcombine_s32(vpadd_s32(vget_low_s32(a), vget_high_s32(a)), + vpadd_s32(vget_low_s32(b), vget_high_s32(b)))); +} + +// Computes pairwise difference of each argument as a 32-bit signed or unsigned +// integer values a and b. +FORCE_INLINE __m128i _mm_hsub_epi32(__m128i _a, __m128i _b) +{ + int64x2_t a = vreinterpretq_s64_m128i(_a); + int64x2_t b = vreinterpretq_s64_m128i(_b); + // Interleave using vshrn/vmovn + // [a0|a2|b0|b2] + // [a1|a2|b1|b3] + int32x4_t ab02 = vcombine_s32(vmovn_s64(a), vmovn_s64(b)); + int32x4_t ab13 = vcombine_s32(vshrn_n_s64(a, 32), vshrn_n_s64(b, 32)); + // Subtract + return vreinterpretq_m128i_s32(vsubq_s32(ab02, ab13)); +} + +// Kahan summation for accurate summation of floating-point numbers. +// http://blog.zachbjornson.com/2019/08/11/fast-float-summation.html +FORCE_INLINE void sse2neon_kadd_f32(float *sum, float *c, float y) +{ + y -= *c; + float t = *sum + y; + *c = (t - *sum) - y; + *sum = t; +} + +// Conditionally multiply the packed single-precision (32-bit) floating-point +// elements in a and b using the high 4 bits in imm8, sum the four products, +// and conditionally store the sum in dst using the low 4 bits of imm. +// https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_dp_ps +FORCE_INLINE __m128 _mm_dp_ps(__m128 a, __m128 b, const int imm) +{ +#if defined(__aarch64__) + /* shortcuts */ + if (imm == 0xFF) { + return _mm_set1_ps(vaddvq_f32(_mm_mul_ps(a, b))); + } + if (imm == 0x7F) { + float32x4_t m = _mm_mul_ps(a, b); + m[3] = 0; + return _mm_set1_ps(vaddvq_f32(m)); + } +#endif + + float s = 0, c = 0; + float32x4_t f32a = vreinterpretq_f32_m128(a); + float32x4_t f32b = vreinterpretq_f32_m128(b); + + /* To improve the accuracy of floating-point summation, Kahan algorithm + * is used for each operation. + */ + if (imm & (1 << 4)) + sse2neon_kadd_f32(&s, &c, f32a[0] * f32b[0]); + if (imm & (1 << 5)) + sse2neon_kadd_f32(&s, &c, f32a[1] * f32b[1]); + if (imm & (1 << 6)) + sse2neon_kadd_f32(&s, &c, f32a[2] * f32b[2]); + if (imm & (1 << 7)) + sse2neon_kadd_f32(&s, &c, f32a[3] * f32b[3]); + s += c; + + float32x4_t res = { + (imm & 0x1) ? s : 0, + (imm & 0x2) ? s : 0, + (imm & 0x4) ? s : 0, + (imm & 0x8) ? s : 0, + }; + return vreinterpretq_m128_f32(res); +} + +/* Compare operations */ + +// Compares for less than +// https://msdn.microsoft.com/en-us/library/vstudio/f330yhc8(v=vs.100).aspx +FORCE_INLINE __m128 _mm_cmplt_ps(__m128 a, __m128 b) +{ + return vreinterpretq_m128_u32( + vcltq_f32(vreinterpretq_f32_m128(a), vreinterpretq_f32_m128(b))); +} + +// Compares for less than +// https://docs.microsoft.com/en-us/previous-versions/visualstudio/visual-studio-2010/fy94wye7(v=vs.100) +FORCE_INLINE __m128 _mm_cmplt_ss(__m128 a, __m128 b) +{ + return _mm_move_ss(a, _mm_cmplt_ps(a, b)); +} + +// Compares for greater than. +// +// r0 := (a0 > b0) ? 0xffffffff : 0x0 +// r1 := (a1 > b1) ? 0xffffffff : 0x0 +// r2 := (a2 > b2) ? 0xffffffff : 0x0 +// r3 := (a3 > b3) ? 0xffffffff : 0x0 +// +// https://msdn.microsoft.com/en-us/library/vstudio/11dy102s(v=vs.100).aspx +FORCE_INLINE __m128 _mm_cmpgt_ps(__m128 a, __m128 b) +{ + return vreinterpretq_m128_u32( + vcgtq_f32(vreinterpretq_f32_m128(a), vreinterpretq_f32_m128(b))); +} + +// Compares for greater than. +// https://docs.microsoft.com/en-us/previous-versions/visualstudio/visual-studio-2010/1xyyyy9e(v=vs.100) +FORCE_INLINE __m128 _mm_cmpgt_ss(__m128 a, __m128 b) +{ + return _mm_move_ss(a, _mm_cmpgt_ps(a, b)); +} + +// Compares for greater than or equal. +// https://msdn.microsoft.com/en-us/library/vstudio/fs813y2t(v=vs.100).aspx +FORCE_INLINE __m128 _mm_cmpge_ps(__m128 a, __m128 b) +{ + return vreinterpretq_m128_u32( + vcgeq_f32(vreinterpretq_f32_m128(a), vreinterpretq_f32_m128(b))); +} + +// Compares for greater than or equal. +// https://docs.microsoft.com/en-us/previous-versions/visualstudio/visual-studio-2010/kesh3ddc(v=vs.100) +FORCE_INLINE __m128 _mm_cmpge_ss(__m128 a, __m128 b) +{ + return _mm_move_ss(a, _mm_cmpge_ps(a, b)); +} + +// Compares for less than or equal. +// +// r0 := (a0 <= b0) ? 0xffffffff : 0x0 +// r1 := (a1 <= b1) ? 0xffffffff : 0x0 +// r2 := (a2 <= b2) ? 0xffffffff : 0x0 +// r3 := (a3 <= b3) ? 0xffffffff : 0x0 +// +// https://msdn.microsoft.com/en-us/library/vstudio/1s75w83z(v=vs.100).aspx +FORCE_INLINE __m128 _mm_cmple_ps(__m128 a, __m128 b) +{ + return vreinterpretq_m128_u32( + vcleq_f32(vreinterpretq_f32_m128(a), vreinterpretq_f32_m128(b))); +} + +// Compares for less than or equal. +// https://docs.microsoft.com/en-us/previous-versions/visualstudio/visual-studio-2010/a7x0hbhw(v=vs.100) +FORCE_INLINE __m128 _mm_cmple_ss(__m128 a, __m128 b) +{ + return _mm_move_ss(a, _mm_cmple_ps(a, b)); +} + +// Compares for equality. +// https://msdn.microsoft.com/en-us/library/vstudio/36aectz5(v=vs.100).aspx +FORCE_INLINE __m128 _mm_cmpeq_ps(__m128 a, __m128 b) +{ + return vreinterpretq_m128_u32( + vceqq_f32(vreinterpretq_f32_m128(a), vreinterpretq_f32_m128(b))); +} + +// Compares for equality. +// https://docs.microsoft.com/en-us/previous-versions/visualstudio/visual-studio-2010/k423z28e(v=vs.100) +FORCE_INLINE __m128 _mm_cmpeq_ss(__m128 a, __m128 b) +{ + return _mm_move_ss(a, _mm_cmpeq_ps(a, b)); +} + +// Compares for inequality. +// https://msdn.microsoft.com/en-us/library/sf44thbx(v=vs.100).aspx +FORCE_INLINE __m128 _mm_cmpneq_ps(__m128 a, __m128 b) +{ + return vreinterpretq_m128_u32(vmvnq_u32( + vceqq_f32(vreinterpretq_f32_m128(a), vreinterpretq_f32_m128(b)))); +} + +// Compares for inequality. +// https://docs.microsoft.com/en-us/previous-versions/visualstudio/visual-studio-2010/ekya8fh4(v=vs.100) +FORCE_INLINE __m128 _mm_cmpneq_ss(__m128 a, __m128 b) +{ + return _mm_move_ss(a, _mm_cmpneq_ps(a, b)); +} + +// Compares for not greater than or equal. +// https://docs.microsoft.com/en-us/previous-versions/visualstudio/visual-studio-2010/wsexys62(v=vs.100) +FORCE_INLINE __m128 _mm_cmpnge_ps(__m128 a, __m128 b) +{ + return _mm_cmplt_ps(a, b); +} + +// Compares for not greater than or equal. +// https://docs.microsoft.com/en-us/previous-versions/visualstudio/visual-studio-2010/fk2y80s8(v=vs.100) +FORCE_INLINE __m128 _mm_cmpnge_ss(__m128 a, __m128 b) +{ + return _mm_cmplt_ss(a, b); +} + +// Compares for not greater than. +// https://docs.microsoft.com/en-us/previous-versions/visualstudio/visual-studio-2010/d0xh7w0s(v=vs.100) +FORCE_INLINE __m128 _mm_cmpngt_ps(__m128 a, __m128 b) +{ + return _mm_cmple_ps(a, b); +} + +// Compares for not greater than. +// https://docs.microsoft.com/en-us/previous-versions/visualstudio/visual-studio-2010/z7x9ydwh(v=vs.100) +FORCE_INLINE __m128 _mm_cmpngt_ss(__m128 a, __m128 b) +{ + return _mm_cmple_ss(a, b); +} + +// Compares for not less than or equal. +// https://docs.microsoft.com/en-us/previous-versions/visualstudio/visual-studio-2010/6a330kxw(v=vs.100) +FORCE_INLINE __m128 _mm_cmpnle_ps(__m128 a, __m128 b) +{ + return _mm_cmpgt_ps(a, b); +} + +// Compares for not less than or equal. +// https://docs.microsoft.com/en-us/previous-versions/visualstudio/visual-studio-2010/z7x9ydwh(v=vs.100) +FORCE_INLINE __m128 _mm_cmpnle_ss(__m128 a, __m128 b) +{ + return _mm_cmpgt_ss(a, b); +} + +// Compares for not less than. +// https://docs.microsoft.com/en-us/previous-versions/visualstudio/visual-studio-2010/4686bbdw(v=vs.100) +FORCE_INLINE __m128 _mm_cmpnlt_ps(__m128 a, __m128 b) +{ + return _mm_cmpge_ps(a, b); +} + +// Compares for not less than. +// https://docs.microsoft.com/en-us/previous-versions/visualstudio/visual-studio-2010/56b9z2wf(v=vs.100) +FORCE_INLINE __m128 _mm_cmpnlt_ss(__m128 a, __m128 b) +{ + return _mm_cmpge_ss(a, b); +} + +// Compares the 16 signed or unsigned 8-bit integers in a and the 16 signed or +// unsigned 8-bit integers in b for equality. +// https://msdn.microsoft.com/en-us/library/windows/desktop/bz5xk21a(v=vs.90).aspx +FORCE_INLINE __m128i _mm_cmpeq_epi8(__m128i a, __m128i b) +{ + return vreinterpretq_m128i_u8( + vceqq_s8(vreinterpretq_s8_m128i(a), vreinterpretq_s8_m128i(b))); +} + +// Compares the 8 signed or unsigned 16-bit integers in a and the 8 signed or +// unsigned 16-bit integers in b for equality. +// https://msdn.microsoft.com/en-us/library/2ay060te(v=vs.100).aspx +FORCE_INLINE __m128i _mm_cmpeq_epi16(__m128i a, __m128i b) +{ + return vreinterpretq_m128i_u16( + vceqq_s16(vreinterpretq_s16_m128i(a), vreinterpretq_s16_m128i(b))); +} + +// Compare packed 32-bit integers in a and b for equality, and store the results +// in dst +FORCE_INLINE __m128i _mm_cmpeq_epi32(__m128i a, __m128i b) +{ + return vreinterpretq_m128i_u32( + vceqq_s32(vreinterpretq_s32_m128i(a), vreinterpretq_s32_m128i(b))); +} + +// Compare packed 64-bit integers in a and b for equality, and store the results +// in dst +FORCE_INLINE __m128i _mm_cmpeq_epi64(__m128i a, __m128i b) +{ +#if defined(__aarch64__) + return vreinterpretq_m128i_u64( + vceqq_u64(vreinterpretq_u64_m128i(a), vreinterpretq_u64_m128i(b))); +#else + // ARMv7 lacks vceqq_u64 + // (a == b) -> (a_lo == b_lo) && (a_hi == b_hi) + uint32x4_t cmp = + vceqq_u32(vreinterpretq_u32_m128i(a), vreinterpretq_u32_m128i(b)); + uint32x4_t swapped = vrev64q_u32(cmp); + return vreinterpretq_m128i_u32(vandq_u32(cmp, swapped)); +#endif +} + +// Compares the 16 signed 8-bit integers in a and the 16 signed 8-bit integers +// in b for lesser than. +// https://msdn.microsoft.com/en-us/library/windows/desktop/9s46csht(v=vs.90).aspx +FORCE_INLINE __m128i _mm_cmplt_epi8(__m128i a, __m128i b) +{ + return vreinterpretq_m128i_u8( + vcltq_s8(vreinterpretq_s8_m128i(a), vreinterpretq_s8_m128i(b))); +} + +// Compares the 16 signed 8-bit integers in a and the 16 signed 8-bit integers +// in b for greater than. +// +// r0 := (a0 > b0) ? 0xff : 0x0 +// r1 := (a1 > b1) ? 0xff : 0x0 +// ... +// r15 := (a15 > b15) ? 0xff : 0x0 +// +// https://msdn.microsoft.com/zh-tw/library/wf45zt2b(v=vs.100).aspx +FORCE_INLINE __m128i _mm_cmpgt_epi8(__m128i a, __m128i b) +{ + return vreinterpretq_m128i_u8( + vcgtq_s8(vreinterpretq_s8_m128i(a), vreinterpretq_s8_m128i(b))); +} + +// Compares the 8 signed 16-bit integers in a and the 8 signed 16-bit integers +// in b for less than. +// +// r0 := (a0 < b0) ? 0xffff : 0x0 +// r1 := (a1 < b1) ? 0xffff : 0x0 +// ... +// r7 := (a7 < b7) ? 0xffff : 0x0 +// +// https://technet.microsoft.com/en-us/library/t863edb2(v=vs.100).aspx +FORCE_INLINE __m128i _mm_cmplt_epi16(__m128i a, __m128i b) +{ + return vreinterpretq_m128i_u16( + vcltq_s16(vreinterpretq_s16_m128i(a), vreinterpretq_s16_m128i(b))); +} + +// Compares the 8 signed 16-bit integers in a and the 8 signed 16-bit integers +// in b for greater than. +// +// r0 := (a0 > b0) ? 0xffff : 0x0 +// r1 := (a1 > b1) ? 0xffff : 0x0 +// ... +// r7 := (a7 > b7) ? 0xffff : 0x0 +// +// https://technet.microsoft.com/en-us/library/xd43yfsa(v=vs.100).aspx +FORCE_INLINE __m128i _mm_cmpgt_epi16(__m128i a, __m128i b) +{ + return vreinterpretq_m128i_u16( + vcgtq_s16(vreinterpretq_s16_m128i(a), vreinterpretq_s16_m128i(b))); +} + + +// Compares the 4 signed 32-bit integers in a and the 4 signed 32-bit integers +// in b for less than. +// https://msdn.microsoft.com/en-us/library/vstudio/4ak0bf5d(v=vs.100).aspx +FORCE_INLINE __m128i _mm_cmplt_epi32(__m128i a, __m128i b) +{ + return vreinterpretq_m128i_u32( + vcltq_s32(vreinterpretq_s32_m128i(a), vreinterpretq_s32_m128i(b))); +} + +// Compares the 4 signed 32-bit integers in a and the 4 signed 32-bit integers +// in b for greater than. +// https://msdn.microsoft.com/en-us/library/vstudio/1s9f2z0y(v=vs.100).aspx +FORCE_INLINE __m128i _mm_cmpgt_epi32(__m128i a, __m128i b) +{ + return vreinterpretq_m128i_u32( + vcgtq_s32(vreinterpretq_s32_m128i(a), vreinterpretq_s32_m128i(b))); +} + +// Compares the 2 signed 64-bit integers in a and the 2 signed 64-bit integers +// in b for greater than. +FORCE_INLINE __m128i _mm_cmpgt_epi64(__m128i a, __m128i b) +{ +#if defined(__aarch64__) + return vreinterpretq_m128i_u64( + vcgtq_s64(vreinterpretq_s64_m128i(a), vreinterpretq_s64_m128i(b))); +#else + // ARMv7 lacks vcgtq_s64. + // This is based off of Clang's SSE2 polyfill: + // (a > b) -> ((a_hi > b_hi) || (a_lo > b_lo && a_hi == b_hi)) + + // Mask the sign bit out since we need a signed AND an unsigned comparison + // and it is ugly to try and split them. + int32x4_t mask = vreinterpretq_s32_s64(vdupq_n_s64(0x80000000ull)); + int32x4_t a_mask = veorq_s32(vreinterpretq_s32_m128i(a), mask); + int32x4_t b_mask = veorq_s32(vreinterpretq_s32_m128i(b), mask); + // Check if a > b + int64x2_t greater = vreinterpretq_s64_u32(vcgtq_s32(a_mask, b_mask)); + // Copy upper mask to lower mask + // a_hi > b_hi + int64x2_t gt_hi = vshrq_n_s64(greater, 63); + // Copy lower mask to upper mask + // a_lo > b_lo + int64x2_t gt_lo = vsliq_n_s64(greater, greater, 32); + // Compare for equality + int64x2_t equal = vreinterpretq_s64_u32(vceqq_s32(a_mask, b_mask)); + // Copy upper mask to lower mask + // a_hi == b_hi + int64x2_t eq_hi = vshrq_n_s64(equal, 63); + // a_hi > b_hi || (a_lo > b_lo && a_hi == b_hi) + int64x2_t ret = vorrq_s64(gt_hi, vandq_s64(gt_lo, eq_hi)); + return vreinterpretq_m128i_s64(ret); +#endif +} + +// Compares the four 32-bit floats in a and b to check if any values are NaN. +// Ordered compare between each value returns true for "orderable" and false for +// "not orderable" (NaN). +// https://msdn.microsoft.com/en-us/library/vstudio/0h9w00fx(v=vs.100).aspx see +// also: +// http://stackoverflow.com/questions/8627331/what-does-ordered-unordered-comparison-mean +// http://stackoverflow.com/questions/29349621/neon-isnanval-intrinsics +FORCE_INLINE __m128 _mm_cmpord_ps(__m128 a, __m128 b) +{ + // Note: NEON does not have ordered compare builtin + // Need to compare a eq a and b eq b to check for NaN + // Do AND of results to get final + uint32x4_t ceqaa = + vceqq_f32(vreinterpretq_f32_m128(a), vreinterpretq_f32_m128(a)); + uint32x4_t ceqbb = + vceqq_f32(vreinterpretq_f32_m128(b), vreinterpretq_f32_m128(b)); + return vreinterpretq_m128_u32(vandq_u32(ceqaa, ceqbb)); +} + +// Compares for ordered. +// https://docs.microsoft.com/en-us/previous-versions/visualstudio/visual-studio-2010/343t62da(v=vs.100) +FORCE_INLINE __m128 _mm_cmpord_ss(__m128 a, __m128 b) +{ + return _mm_move_ss(a, _mm_cmpord_ps(a, b)); +} + +// Compares for unordered. +// https://docs.microsoft.com/en-us/previous-versions/visualstudio/visual-studio-2010/khy6fk1t(v=vs.100) +FORCE_INLINE __m128 _mm_cmpunord_ps(__m128 a, __m128 b) +{ + uint32x4_t f32a = + vceqq_f32(vreinterpretq_f32_m128(a), vreinterpretq_f32_m128(a)); + uint32x4_t f32b = + vceqq_f32(vreinterpretq_f32_m128(b), vreinterpretq_f32_m128(b)); + return vreinterpretq_m128_u32(vmvnq_u32(vandq_u32(f32a, f32b))); +} + +// Compares for unordered. +// https://docs.microsoft.com/en-us/previous-versions/visualstudio/visual-studio-2010/2as2387b(v=vs.100) +FORCE_INLINE __m128 _mm_cmpunord_ss(__m128 a, __m128 b) +{ + return _mm_move_ss(a, _mm_cmpunord_ps(a, b)); +} + +// Compares the lower single-precision floating point scalar values of a and b +// using a less than operation. : +// https://msdn.microsoft.com/en-us/library/2kwe606b(v=vs.90).aspx Important +// note!! The documentation on MSDN is incorrect! If either of the values is a +// NAN the docs say you will get a one, but in fact, it will return a zero!! +FORCE_INLINE int _mm_comilt_ss(__m128 a, __m128 b) +{ + uint32x4_t a_not_nan = + vceqq_f32(vreinterpretq_f32_m128(a), vreinterpretq_f32_m128(a)); + uint32x4_t b_not_nan = + vceqq_f32(vreinterpretq_f32_m128(b), vreinterpretq_f32_m128(b)); + uint32x4_t a_and_b_not_nan = vandq_u32(a_not_nan, b_not_nan); + uint32x4_t a_lt_b = + vcltq_f32(vreinterpretq_f32_m128(a), vreinterpretq_f32_m128(b)); + return (vgetq_lane_u32(vandq_u32(a_and_b_not_nan, a_lt_b), 0) != 0) ? 1 : 0; +} + +// Compares the lower single-precision floating point scalar values of a and b +// using a greater than operation. : +// https://msdn.microsoft.com/en-us/library/b0738e0t(v=vs.100).aspx +FORCE_INLINE int _mm_comigt_ss(__m128 a, __m128 b) +{ + // return vgetq_lane_u32(vcgtq_f32(vreinterpretq_f32_m128(a), + // vreinterpretq_f32_m128(b)), 0); + uint32x4_t a_not_nan = + vceqq_f32(vreinterpretq_f32_m128(a), vreinterpretq_f32_m128(a)); + uint32x4_t b_not_nan = + vceqq_f32(vreinterpretq_f32_m128(b), vreinterpretq_f32_m128(b)); + uint32x4_t a_and_b_not_nan = vandq_u32(a_not_nan, b_not_nan); + uint32x4_t a_gt_b = + vcgtq_f32(vreinterpretq_f32_m128(a), vreinterpretq_f32_m128(b)); + return (vgetq_lane_u32(vandq_u32(a_and_b_not_nan, a_gt_b), 0) != 0) ? 1 : 0; +} + +// Compares the lower single-precision floating point scalar values of a and b +// using a less than or equal operation. : +// https://msdn.microsoft.com/en-us/library/1w4t7c57(v=vs.90).aspx +FORCE_INLINE int _mm_comile_ss(__m128 a, __m128 b) +{ + // return vgetq_lane_u32(vcleq_f32(vreinterpretq_f32_m128(a), + // vreinterpretq_f32_m128(b)), 0); + uint32x4_t a_not_nan = + vceqq_f32(vreinterpretq_f32_m128(a), vreinterpretq_f32_m128(a)); + uint32x4_t b_not_nan = + vceqq_f32(vreinterpretq_f32_m128(b), vreinterpretq_f32_m128(b)); + uint32x4_t a_and_b_not_nan = vandq_u32(a_not_nan, b_not_nan); + uint32x4_t a_le_b = + vcleq_f32(vreinterpretq_f32_m128(a), vreinterpretq_f32_m128(b)); + return (vgetq_lane_u32(vandq_u32(a_and_b_not_nan, a_le_b), 0) != 0) ? 1 : 0; +} + +// Compares the lower single-precision floating point scalar values of a and b +// using a greater than or equal operation. : +// https://msdn.microsoft.com/en-us/library/8t80des6(v=vs.100).aspx +FORCE_INLINE int _mm_comige_ss(__m128 a, __m128 b) +{ + // return vgetq_lane_u32(vcgeq_f32(vreinterpretq_f32_m128(a), + // vreinterpretq_f32_m128(b)), 0); + uint32x4_t a_not_nan = + vceqq_f32(vreinterpretq_f32_m128(a), vreinterpretq_f32_m128(a)); + uint32x4_t b_not_nan = + vceqq_f32(vreinterpretq_f32_m128(b), vreinterpretq_f32_m128(b)); + uint32x4_t a_and_b_not_nan = vandq_u32(a_not_nan, b_not_nan); + uint32x4_t a_ge_b = + vcgeq_f32(vreinterpretq_f32_m128(a), vreinterpretq_f32_m128(b)); + return (vgetq_lane_u32(vandq_u32(a_and_b_not_nan, a_ge_b), 0) != 0) ? 1 : 0; +} + +// Compares the lower single-precision floating point scalar values of a and b +// using an equality operation. : +// https://msdn.microsoft.com/en-us/library/93yx2h2b(v=vs.100).aspx +FORCE_INLINE int _mm_comieq_ss(__m128 a, __m128 b) +{ + // return vgetq_lane_u32(vceqq_f32(vreinterpretq_f32_m128(a), + // vreinterpretq_f32_m128(b)), 0); + uint32x4_t a_not_nan = + vceqq_f32(vreinterpretq_f32_m128(a), vreinterpretq_f32_m128(a)); + uint32x4_t b_not_nan = + vceqq_f32(vreinterpretq_f32_m128(b), vreinterpretq_f32_m128(b)); + uint32x4_t a_and_b_not_nan = vandq_u32(a_not_nan, b_not_nan); + uint32x4_t a_eq_b = + vceqq_f32(vreinterpretq_f32_m128(a), vreinterpretq_f32_m128(b)); + return (vgetq_lane_u32(vandq_u32(a_and_b_not_nan, a_eq_b), 0) != 0) ? 1 : 0; +} + +// Compares the lower single-precision floating point scalar values of a and b +// using an inequality operation. : +// https://msdn.microsoft.com/en-us/library/bafh5e0a(v=vs.90).aspx +FORCE_INLINE int _mm_comineq_ss(__m128 a, __m128 b) +{ + // return !vgetq_lane_u32(vceqq_f32(vreinterpretq_f32_m128(a), + // vreinterpretq_f32_m128(b)), 0); + uint32x4_t a_not_nan = + vceqq_f32(vreinterpretq_f32_m128(a), vreinterpretq_f32_m128(a)); + uint32x4_t b_not_nan = + vceqq_f32(vreinterpretq_f32_m128(b), vreinterpretq_f32_m128(b)); + uint32x4_t a_or_b_nan = vmvnq_u32(vandq_u32(a_not_nan, b_not_nan)); + uint32x4_t a_neq_b = vmvnq_u32( + vceqq_f32(vreinterpretq_f32_m128(a), vreinterpretq_f32_m128(b))); + return (vgetq_lane_u32(vorrq_u32(a_or_b_nan, a_neq_b), 0) != 0) ? 1 : 0; +} + +// according to the documentation, these intrinsics behave the same as the +// non-'u' versions. We'll just alias them here. +#define _mm_ucomilt_ss _mm_comilt_ss +#define _mm_ucomile_ss _mm_comile_ss +#define _mm_ucomigt_ss _mm_comigt_ss +#define _mm_ucomige_ss _mm_comige_ss +#define _mm_ucomieq_ss _mm_comieq_ss +#define _mm_ucomineq_ss _mm_comineq_ss + +/* Conversions */ + +// Convert packed signed 32-bit integers in b to packed single-precision +// (32-bit) floating-point elements, store the results in the lower 2 elements +// of dst, and copy the upper 2 packed elements from a to the upper elements of +// dst. +// +// dst[31:0] := Convert_Int32_To_FP32(b[31:0]) +// dst[63:32] := Convert_Int32_To_FP32(b[63:32]) +// dst[95:64] := a[95:64] +// dst[127:96] := a[127:96] +// +// https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_cvt_pi2ps +FORCE_INLINE __m128 _mm_cvt_pi2ps(__m128 a, __m64 b) +{ + return vreinterpretq_m128_f32( + vcombine_f32(vcvt_f32_s32(vreinterpret_s32_m64(b)), + vget_high_f32(vreinterpretq_f32_m128(a)))); +} + +// Convert the signed 32-bit integer b to a single-precision (32-bit) +// floating-point element, store the result in the lower element of dst, and +// copy the upper 3 packed elements from a to the upper elements of dst. +// +// dst[31:0] := Convert_Int32_To_FP32(b[31:0]) +// dst[127:32] := a[127:32] +// +// https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_cvt_si2ss +FORCE_INLINE __m128 _mm_cvt_si2ss(__m128 a, int b) +{ + return vreinterpretq_m128_f32( + vsetq_lane_f32((float) b, vreinterpretq_f32_m128(a), 0)); +} + +// Convert the signed 32-bit integer b to a single-precision (32-bit) +// floating-point element, store the result in the lower element of dst, and +// copy the upper 3 packed elements from a to the upper elements of dst. +// +// dst[31:0] := Convert_Int32_To_FP32(b[31:0]) +// dst[127:32] := a[127:32] +// +// https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_cvtsi32_ss +#define _mm_cvtsi32_ss(a, b) _mm_cvt_si2ss(a, b) + +// Convert the signed 64-bit integer b to a single-precision (32-bit) +// floating-point element, store the result in the lower element of dst, and +// copy the upper 3 packed elements from a to the upper elements of dst. +// +// dst[31:0] := Convert_Int64_To_FP32(b[63:0]) +// dst[127:32] := a[127:32] +// +// https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_cvtsi64_ss +FORCE_INLINE __m128 _mm_cvtsi64_ss(__m128 a, int64_t b) +{ + return vreinterpretq_m128_f32( + vsetq_lane_f32((float) b, vreinterpretq_f32_m128(a), 0)); +} + +// Convert the lower single-precision (32-bit) floating-point element in a to a +// 32-bit integer, and store the result in dst. +// https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_cvt_ss2si +FORCE_INLINE int _mm_cvt_ss2si(__m128 a) +{ +#if defined(__aarch64__) + return vgetq_lane_s32(vcvtnq_s32_f32(vreinterpretq_f32_m128(a)), 0); +#else + float32_t data = vgetq_lane_f32(vreinterpretq_f32_m128(a), 0); + float32_t diff = data - floor(data); + if (diff > 0.5) + return (int32_t) ceil(data); + if (diff == 0.5) { + int32_t f = (int32_t) floor(data); + int32_t c = (int32_t) ceil(data); + return c & 1 ? f : c; + } + return (int32_t) floor(data); +#endif +} + +// Convert packed 16-bit integers in a to packed single-precision (32-bit) +// floating-point elements, and store the results in dst. +// +// FOR j := 0 to 3 +// i := j*16 +// m := j*32 +// dst[m+31:m] := Convert_Int16_To_FP32(a[i+15:i]) +// ENDFOR +// +// https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_cvtpi16_ps +FORCE_INLINE __m128 _mm_cvtpi16_ps(__m64 a) +{ + return vreinterpretq_m128_f32( + vcvtq_f32_s32(vmovl_s16(vreinterpret_s16_m64(a)))); +} + +// Convert packed 32-bit integers in b to packed single-precision (32-bit) +// floating-point elements, store the results in the lower 2 elements of dst, +// and copy the upper 2 packed elements from a to the upper elements of dst. +// +// dst[31:0] := Convert_Int32_To_FP32(b[31:0]) +// dst[63:32] := Convert_Int32_To_FP32(b[63:32]) +// dst[95:64] := a[95:64] +// dst[127:96] := a[127:96] +// +// https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_cvtpi32_ps +FORCE_INLINE __m128 _mm_cvtpi32_ps(__m128 a, __m64 b) +{ + return vreinterpretq_m128_f32( + vcombine_f32(vcvt_f32_s32(vreinterpret_s32_m64(b)), + vget_high_f32(vreinterpretq_f32_m128(a)))); +} + +// Convert packed signed 32-bit integers in a to packed single-precision +// (32-bit) floating-point elements, store the results in the lower 2 elements +// of dst, then covert the packed signed 32-bit integers in b to +// single-precision (32-bit) floating-point element, and store the results in +// the upper 2 elements of dst. +// +// dst[31:0] := Convert_Int32_To_FP32(a[31:0]) +// dst[63:32] := Convert_Int32_To_FP32(a[63:32]) +// dst[95:64] := Convert_Int32_To_FP32(b[31:0]) +// dst[127:96] := Convert_Int32_To_FP32(b[63:32]) +// +// https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_cvtpi32x2_ps +FORCE_INLINE __m128 _mm_cvtpi32x2_ps(__m64 a, __m64 b) +{ + return vreinterpretq_m128_f32(vcvtq_f32_s32( + vcombine_s32(vreinterpret_s32_m64(a), vreinterpret_s32_m64(b)))); +} + +// Convert the lower packed 8-bit integers in a to packed single-precision +// (32-bit) floating-point elements, and store the results in dst. +// +// FOR j := 0 to 3 +// i := j*8 +// m := j*32 +// dst[m+31:m] := Convert_Int8_To_FP32(a[i+7:i]) +// ENDFOR +// +// https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_cvtpi8_ps +FORCE_INLINE __m128 _mm_cvtpi8_ps(__m64 a) +{ + return vreinterpretq_m128_f32(vcvtq_f32_s32( + vmovl_s16(vget_low_s16(vmovl_s8(vreinterpret_s8_m64(a)))))); +} + +// Convert packed unsigned 16-bit integers in a to packed single-precision +// (32-bit) floating-point elements, and store the results in dst. +// +// FOR j := 0 to 3 +// i := j*16 +// m := j*32 +// dst[m+31:m] := Convert_UInt16_To_FP32(a[i+15:i]) +// ENDFOR +// +// https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_cvtpu16_ps +FORCE_INLINE __m128 _mm_cvtpu16_ps(__m64 a) +{ + return vreinterpretq_m128_f32( + vcvtq_f32_u32(vmovl_u16(vreinterpret_u16_m64(a)))); +} + +// Convert the lower packed unsigned 8-bit integers in a to packed +// single-precision (32-bit) floating-point elements, and store the results in +// dst. +// +// FOR j := 0 to 3 +// i := j*8 +// m := j*32 +// dst[m+31:m] := Convert_UInt8_To_FP32(a[i+7:i]) +// ENDFOR +// +// https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_cvtpu8_ps +FORCE_INLINE __m128 _mm_cvtpu8_ps(__m64 a) +{ + return vreinterpretq_m128_f32(vcvtq_f32_u32( + vmovl_u16(vget_low_u16(vmovl_u8(vreinterpret_u8_m64(a)))))); +} + +// Converts the four single-precision, floating-point values of a to signed +// 32-bit integer values using truncate. +// https://msdn.microsoft.com/en-us/library/vstudio/1h005y6x(v=vs.100).aspx +FORCE_INLINE __m128i _mm_cvttps_epi32(__m128 a) +{ + return vreinterpretq_m128i_s32(vcvtq_s32_f32(vreinterpretq_f32_m128(a))); +} + +// Convert the lower double-precision (64-bit) floating-point element in a to a +// 64-bit integer with truncation, and store the result in dst. +// +// dst[63:0] := Convert_FP64_To_Int64_Truncate(a[63:0]) +// +// https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_cvttsd_si64 +FORCE_INLINE int64_t _mm_cvttsd_si64(__m128d a) +{ +#if defined(__aarch64__) + return vgetq_lane_s64(vcvtq_s64_f64(vreinterpretq_f64_m128d(a)), 0); +#else + double ret = *((double *) &a); + return (int64_t) ret; +#endif +} + +// Convert the lower double-precision (64-bit) floating-point element in a to a +// 64-bit integer with truncation, and store the result in dst. +// +// dst[63:0] := Convert_FP64_To_Int64_Truncate(a[63:0]) +// +// https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_cvttsd_si64x +#define _mm_cvttsd_si64x(a) _mm_cvttsd_si64(a) + +// Converts the four signed 32-bit integer values of a to single-precision, +// floating-point values +// https://msdn.microsoft.com/en-us/library/vstudio/36bwxcx5(v=vs.100).aspx +FORCE_INLINE __m128 _mm_cvtepi32_ps(__m128i a) +{ + return vreinterpretq_m128_f32(vcvtq_f32_s32(vreinterpretq_s32_m128i(a))); +} + +// Converts the four unsigned 8-bit integers in the lower 16 bits to four +// unsigned 32-bit integers. +FORCE_INLINE __m128i _mm_cvtepu8_epi16(__m128i a) +{ + uint8x16_t u8x16 = vreinterpretq_u8_m128i(a); /* xxxx xxxx xxxx DCBA */ + uint16x8_t u16x8 = vmovl_u8(vget_low_u8(u8x16)); /* 0x0x 0x0x 0D0C 0B0A */ + return vreinterpretq_m128i_u16(u16x8); +} + +// Converts the four unsigned 8-bit integers in the lower 32 bits to four +// unsigned 32-bit integers. +// https://msdn.microsoft.com/en-us/library/bb531467%28v=vs.100%29.aspx +FORCE_INLINE __m128i _mm_cvtepu8_epi32(__m128i a) +{ + uint8x16_t u8x16 = vreinterpretq_u8_m128i(a); /* xxxx xxxx xxxx DCBA */ + uint16x8_t u16x8 = vmovl_u8(vget_low_u8(u8x16)); /* 0x0x 0x0x 0D0C 0B0A */ + uint32x4_t u32x4 = vmovl_u16(vget_low_u16(u16x8)); /* 000D 000C 000B 000A */ + return vreinterpretq_m128i_u32(u32x4); +} + +// Converts the two unsigned 8-bit integers in the lower 16 bits to two +// unsigned 64-bit integers. +FORCE_INLINE __m128i _mm_cvtepu8_epi64(__m128i a) +{ + uint8x16_t u8x16 = vreinterpretq_u8_m128i(a); /* xxxx xxxx xxxx xxBA */ + uint16x8_t u16x8 = vmovl_u8(vget_low_u8(u8x16)); /* 0x0x 0x0x 0x0x 0B0A */ + uint32x4_t u32x4 = vmovl_u16(vget_low_u16(u16x8)); /* 000x 000x 000B 000A */ + uint64x2_t u64x2 = vmovl_u32(vget_low_u32(u32x4)); /* 0000 000B 0000 000A */ + return vreinterpretq_m128i_u64(u64x2); +} + +// Converts the four unsigned 8-bit integers in the lower 16 bits to four +// unsigned 32-bit integers. +FORCE_INLINE __m128i _mm_cvtepi8_epi16(__m128i a) +{ + int8x16_t s8x16 = vreinterpretq_s8_m128i(a); /* xxxx xxxx xxxx DCBA */ + int16x8_t s16x8 = vmovl_s8(vget_low_s8(s8x16)); /* 0x0x 0x0x 0D0C 0B0A */ + return vreinterpretq_m128i_s16(s16x8); +} + +// Converts the four unsigned 8-bit integers in the lower 32 bits to four +// unsigned 32-bit integers. +FORCE_INLINE __m128i _mm_cvtepi8_epi32(__m128i a) +{ + int8x16_t s8x16 = vreinterpretq_s8_m128i(a); /* xxxx xxxx xxxx DCBA */ + int16x8_t s16x8 = vmovl_s8(vget_low_s8(s8x16)); /* 0x0x 0x0x 0D0C 0B0A */ + int32x4_t s32x4 = vmovl_s16(vget_low_s16(s16x8)); /* 000D 000C 000B 000A */ + return vreinterpretq_m128i_s32(s32x4); +} + +// Converts the two signed 8-bit integers in the lower 32 bits to four +// signed 64-bit integers. +FORCE_INLINE __m128i _mm_cvtepi8_epi64(__m128i a) +{ + int8x16_t s8x16 = vreinterpretq_s8_m128i(a); /* xxxx xxxx xxxx xxBA */ + int16x8_t s16x8 = vmovl_s8(vget_low_s8(s8x16)); /* 0x0x 0x0x 0x0x 0B0A */ + int32x4_t s32x4 = vmovl_s16(vget_low_s16(s16x8)); /* 000x 000x 000B 000A */ + int64x2_t s64x2 = vmovl_s32(vget_low_s32(s32x4)); /* 0000 000B 0000 000A */ + return vreinterpretq_m128i_s64(s64x2); +} + +// Converts the four signed 16-bit integers in the lower 64 bits to four signed +// 32-bit integers. +FORCE_INLINE __m128i _mm_cvtepi16_epi32(__m128i a) +{ + return vreinterpretq_m128i_s32( + vmovl_s16(vget_low_s16(vreinterpretq_s16_m128i(a)))); +} + +// Converts the two signed 16-bit integers in the lower 32 bits two signed +// 32-bit integers. +FORCE_INLINE __m128i _mm_cvtepi16_epi64(__m128i a) +{ + int16x8_t s16x8 = vreinterpretq_s16_m128i(a); /* xxxx xxxx xxxx 0B0A */ + int32x4_t s32x4 = vmovl_s16(vget_low_s16(s16x8)); /* 000x 000x 000B 000A */ + int64x2_t s64x2 = vmovl_s32(vget_low_s32(s32x4)); /* 0000 000B 0000 000A */ + return vreinterpretq_m128i_s64(s64x2); +} + +// Converts the four unsigned 16-bit integers in the lower 64 bits to four +// unsigned 32-bit integers. +FORCE_INLINE __m128i _mm_cvtepu16_epi32(__m128i a) +{ + return vreinterpretq_m128i_u32( + vmovl_u16(vget_low_u16(vreinterpretq_u16_m128i(a)))); +} + +// Converts the two unsigned 16-bit integers in the lower 32 bits to two +// unsigned 64-bit integers. +FORCE_INLINE __m128i _mm_cvtepu16_epi64(__m128i a) +{ + uint16x8_t u16x8 = vreinterpretq_u16_m128i(a); /* xxxx xxxx xxxx 0B0A */ + uint32x4_t u32x4 = vmovl_u16(vget_low_u16(u16x8)); /* 000x 000x 000B 000A */ + uint64x2_t u64x2 = vmovl_u32(vget_low_u32(u32x4)); /* 0000 000B 0000 000A */ + return vreinterpretq_m128i_u64(u64x2); +} + +// Converts the two unsigned 32-bit integers in the lower 64 bits to two +// unsigned 64-bit integers. +FORCE_INLINE __m128i _mm_cvtepu32_epi64(__m128i a) +{ + return vreinterpretq_m128i_u64( + vmovl_u32(vget_low_u32(vreinterpretq_u32_m128i(a)))); +} + +// Converts the two signed 32-bit integers in the lower 64 bits to two signed +// 64-bit integers. +FORCE_INLINE __m128i _mm_cvtepi32_epi64(__m128i a) +{ + return vreinterpretq_m128i_s64( + vmovl_s32(vget_low_s32(vreinterpretq_s32_m128i(a)))); +} + +// Converts the four single-precision, floating-point values of a to signed +// 32-bit integer values. +// +// r0 := (int) a0 +// r1 := (int) a1 +// r2 := (int) a2 +// r3 := (int) a3 +// +// https://msdn.microsoft.com/en-us/library/vstudio/xdc42k5e(v=vs.100).aspx +// *NOTE*. The default rounding mode on SSE is 'round to even', which ARMv7-A +// does not support! It is supported on ARMv8-A however. +FORCE_INLINE __m128i _mm_cvtps_epi32(__m128 a) +{ +#if defined(__aarch64__) + return vreinterpretq_m128i_s32(vcvtnq_s32_f32(a)); +#else + uint32x4_t signmask = vdupq_n_u32(0x80000000); + float32x4_t half = vbslq_f32(signmask, vreinterpretq_f32_m128(a), + vdupq_n_f32(0.5f)); /* +/- 0.5 */ + int32x4_t r_normal = vcvtq_s32_f32(vaddq_f32( + vreinterpretq_f32_m128(a), half)); /* round to integer: [a + 0.5]*/ + int32x4_t r_trunc = + vcvtq_s32_f32(vreinterpretq_f32_m128(a)); /* truncate to integer: [a] */ + int32x4_t plusone = vreinterpretq_s32_u32(vshrq_n_u32( + vreinterpretq_u32_s32(vnegq_s32(r_trunc)), 31)); /* 1 or 0 */ + int32x4_t r_even = vbicq_s32(vaddq_s32(r_trunc, plusone), + vdupq_n_s32(1)); /* ([a] + {0,1}) & ~1 */ + float32x4_t delta = vsubq_f32( + vreinterpretq_f32_m128(a), + vcvtq_f32_s32(r_trunc)); /* compute delta: delta = (a - [a]) */ + uint32x4_t is_delta_half = vceqq_f32(delta, half); /* delta == +/- 0.5 */ + return vreinterpretq_m128i_s32(vbslq_s32(is_delta_half, r_even, r_normal)); +#endif +} + +// Copy the lower 32-bit integer in a to dst. +// +// dst[31:0] := a[31:0] +// +// https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_cvtsi128_si32 +FORCE_INLINE int _mm_cvtsi128_si32(__m128i a) +{ + return vgetq_lane_s32(vreinterpretq_s32_m128i(a), 0); +} + +// Copy the lower 64-bit integer in a to dst. +// +// dst[63:0] := a[63:0] +// +// https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_cvtsi128_si64 +FORCE_INLINE int64_t _mm_cvtsi128_si64(__m128i a) +{ + return vgetq_lane_s64(vreinterpretq_s64_m128i(a), 0); +} + +// Copy the lower 64-bit integer in a to dst. +// +// dst[63:0] := a[63:0] +// +// https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_cvtsi128_si64x +#define _mm_cvtsi128_si64x(a) _mm_cvtsi128_si64(a) + +// Moves 32-bit integer a to the least significant 32 bits of an __m128 object, +// zero extending the upper bits. +// +// r0 := a +// r1 := 0x0 +// r2 := 0x0 +// r3 := 0x0 +// +// https://msdn.microsoft.com/en-us/library/ct3539ha%28v=vs.90%29.aspx +FORCE_INLINE __m128i _mm_cvtsi32_si128(int a) +{ + return vreinterpretq_m128i_s32(vsetq_lane_s32(a, vdupq_n_s32(0), 0)); +} + +// Moves 64-bit integer a to the least significant 64 bits of an __m128 object, +// zero extending the upper bits. +// +// r0 := a +// r1 := 0x0 +FORCE_INLINE __m128i _mm_cvtsi64_si128(int64_t a) +{ + return vreinterpretq_m128i_s64(vsetq_lane_s64(a, vdupq_n_s64(0), 0)); +} + +// Cast vector of type __m128 to type __m128d. This intrinsic is only used for +// compilation and does not generate any instructions, thus it has zero latency. +// https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_castps_pd +FORCE_INLINE __m128d _mm_castps_pd(__m128 a) +{ + return vreinterpretq_m128d_s32(vreinterpretq_s32_m128(a)); +} + +// Applies a type cast to reinterpret four 32-bit floating point values passed +// in as a 128-bit parameter as packed 32-bit integers. +// https://msdn.microsoft.com/en-us/library/bb514099.aspx +FORCE_INLINE __m128i _mm_castps_si128(__m128 a) +{ + return vreinterpretq_m128i_s32(vreinterpretq_s32_m128(a)); +} + +// Applies a type cast to reinterpret four 32-bit integers passed in as a +// 128-bit parameter as packed 32-bit floating point values. +// https://msdn.microsoft.com/en-us/library/bb514029.aspx +FORCE_INLINE __m128 _mm_castsi128_ps(__m128i a) +{ + return vreinterpretq_m128_s32(vreinterpretq_s32_m128i(a)); +} + +// Loads 128-bit value. : +// https://msdn.microsoft.com/en-us/library/atzzad1h(v=vs.80).aspx +FORCE_INLINE __m128i _mm_load_si128(const __m128i *p) +{ + return vreinterpretq_m128i_s32(vld1q_s32((const int32_t *) p)); +} + +// Load a double-precision (64-bit) floating-point element from memory into both +// elements of dst. +// +// dst[63:0] := MEM[mem_addr+63:mem_addr] +// dst[127:64] := MEM[mem_addr+63:mem_addr] +// +// https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_load1_pd +FORCE_INLINE __m128d _mm_load1_pd(const double *p) +{ +#if defined(__aarch64__) + return vreinterpretq_m128d_f64(vld1q_dup_f64(p)); +#else + return vreinterpretq_m128d_s64(vdupq_n_s64(*(const int64_t *) p)); +#endif +} + +// Load a double-precision (64-bit) floating-point element from memory into the +// upper element of dst, and copy the lower element from a to dst. mem_addr does +// not need to be aligned on any particular boundary. +// +// dst[63:0] := a[63:0] +// dst[127:64] := MEM[mem_addr+63:mem_addr] +// +// https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_loadh_pd +FORCE_INLINE __m128d _mm_loadh_pd(__m128d a, const double *p) +{ +#if defined(__aarch64__) + return vreinterpretq_m128d_f64( + vcombine_f64(vget_low_f64(vreinterpretq_f64_m128d(a)), vld1_f64(p))); +#else + return vreinterpretq_m128d_f32(vcombine_f32( + vget_low_f32(vreinterpretq_f32_m128d(a)), vld1_f32((const float *) p))); +#endif +} + +// Load a double-precision (64-bit) floating-point element from memory into both +// elements of dst. +// +// dst[63:0] := MEM[mem_addr+63:mem_addr] +// dst[127:64] := MEM[mem_addr+63:mem_addr] +// +// https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_load_pd1 +#define _mm_load_pd1 _mm_load1_pd + +// Load a double-precision (64-bit) floating-point element from memory into both +// elements of dst. +// +// dst[63:0] := MEM[mem_addr+63:mem_addr] +// dst[127:64] := MEM[mem_addr+63:mem_addr] +// +// https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_loaddup_pd +#define _mm_loaddup_pd _mm_load1_pd + +// Loads 128-bit value. : +// https://msdn.microsoft.com/zh-cn/library/f4k12ae8(v=vs.90).aspx +FORCE_INLINE __m128i _mm_loadu_si128(const __m128i *p) +{ + return vreinterpretq_m128i_s32(vld1q_s32((const int32_t *) p)); +} + +// Load unaligned 32-bit integer from memory into the first element of dst. +// +// dst[31:0] := MEM[mem_addr+31:mem_addr] +// dst[MAX:32] := 0 +// +// https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_loadu_si32 +FORCE_INLINE __m128i _mm_loadu_si32(const void *p) +{ + return vreinterpretq_m128i_s32( + vsetq_lane_s32(*(const int32_t *) p, vdupq_n_s32(0), 0)); +} + +// Convert packed double-precision (64-bit) floating-point elements in a to +// packed single-precision (32-bit) floating-point elements, and store the +// results in dst. +// +// FOR j := 0 to 1 +// i := 32*j +// k := 64*j +// dst[i+31:i] := Convert_FP64_To_FP32(a[k+64:k]) +// ENDFOR +// dst[127:64] := 0 +// +// https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_cvtpd_ps +FORCE_INLINE __m128 _mm_cvtpd_ps(__m128d a) +{ +#if defined(__aarch64__) + float32x2_t tmp = vcvt_f32_f64(vreinterpretq_f64_m128d(a)); + return vreinterpretq_m128_f32(vcombine_f32(tmp, vdup_n_f32(0))); +#else + float a0 = (float) ((double *) &a)[0]; + float a1 = (float) ((double *) &a)[1]; + return _mm_set_ps(0, 0, a1, a0); +#endif +} + +// Copy the lower double-precision (64-bit) floating-point element of a to dst. +// +// dst[63:0] := a[63:0] +// +// https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_cvtsd_f64 +FORCE_INLINE double _mm_cvtsd_f64(__m128d a) +{ +#if defined(__aarch64__) + return (double) vgetq_lane_f64(vreinterpretq_f64_m128d(a), 0); +#else + return ((double *) &a)[0]; +#endif +} + +// Convert packed single-precision (32-bit) floating-point elements in a to +// packed double-precision (64-bit) floating-point elements, and store the +// results in dst. +// +// FOR j := 0 to 1 +// i := 64*j +// k := 32*j +// dst[i+63:i] := Convert_FP32_To_FP64(a[k+31:k]) +// ENDFOR +// +// https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_cvtps_pd +FORCE_INLINE __m128d _mm_cvtps_pd(__m128 a) +{ +#if defined(__aarch64__) + return vreinterpretq_m128d_f64( + vcvt_f64_f32(vget_low_f32(vreinterpretq_f32_m128(a)))); +#else + double a0 = (double) vgetq_lane_f32(vreinterpretq_f32_m128(a), 0); + double a1 = (double) vgetq_lane_f32(vreinterpretq_f32_m128(a), 1); + return _mm_set_pd(a1, a0); +#endif +} + +// Cast vector of type __m128d to type __m128i. This intrinsic is only used for +// compilation and does not generate any instructions, thus it has zero latency. +// https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_castpd_si128 +FORCE_INLINE __m128i _mm_castpd_si128(__m128d a) +{ + return vreinterpretq_m128i_s64(vreinterpretq_s64_m128d(a)); +} + +// Blend packed single-precision (32-bit) floating-point elements from a and b +// using mask, and store the results in dst. +// https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_blendv_ps +FORCE_INLINE __m128 _mm_blendv_ps(__m128 a, __m128 b, __m128 mask) +{ + return vreinterpretq_m128_f32(vbslq_f32(vreinterpretq_u32_m128(mask), + vreinterpretq_f32_m128(b), + vreinterpretq_f32_m128(a))); +} + +// Round the packed single-precision (32-bit) floating-point elements in a using +// the rounding parameter, and store the results as packed single-precision +// floating-point elements in dst. +// software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_round_ps +FORCE_INLINE __m128 _mm_round_ps(__m128 a, int rounding) +{ +#if defined(__aarch64__) + switch (rounding) { + case (_MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC): + return vreinterpretq_m128_f32(vrndnq_f32(vreinterpretq_f32_m128(a))); + case (_MM_FROUND_TO_NEG_INF | _MM_FROUND_NO_EXC): + return vreinterpretq_m128_f32(vrndmq_f32(vreinterpretq_f32_m128(a))); + case (_MM_FROUND_TO_POS_INF | _MM_FROUND_NO_EXC): + return vreinterpretq_m128_f32(vrndpq_f32(vreinterpretq_f32_m128(a))); + case (_MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC): + return vreinterpretq_m128_f32(vrndq_f32(vreinterpretq_f32_m128(a))); + default: //_MM_FROUND_CUR_DIRECTION + return vreinterpretq_m128_f32(vrndiq_f32(vreinterpretq_f32_m128(a))); + } +#else + float *v_float = (float *) &a; + __m128 zero, neg_inf, pos_inf; + + switch (rounding) { + case (_MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC): + return _mm_cvtepi32_ps(_mm_cvtps_epi32(a)); + case (_MM_FROUND_TO_NEG_INF | _MM_FROUND_NO_EXC): + return (__m128){floorf(v_float[0]), floorf(v_float[1]), + floorf(v_float[2]), floorf(v_float[3])}; + case (_MM_FROUND_TO_POS_INF | _MM_FROUND_NO_EXC): + return (__m128){ceilf(v_float[0]), ceilf(v_float[1]), ceilf(v_float[2]), + ceilf(v_float[3])}; + case (_MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC): + zero = _mm_set_ps(0.0f, 0.0f, 0.0f, 0.0f); + neg_inf = _mm_set_ps(floorf(v_float[0]), floorf(v_float[1]), + floorf(v_float[2]), floorf(v_float[3])); + pos_inf = _mm_set_ps(ceilf(v_float[0]), ceilf(v_float[1]), + ceilf(v_float[2]), ceilf(v_float[3])); + return _mm_blendv_ps(pos_inf, neg_inf, _mm_cmple_ps(a, zero)); + default: //_MM_FROUND_CUR_DIRECTION + return (__m128){roundf(v_float[0]), roundf(v_float[1]), + roundf(v_float[2]), roundf(v_float[3])}; + } +#endif +} + +// Convert packed single-precision (32-bit) floating-point elements in a to +// packed 32-bit integers, and store the results in dst. +// +// FOR j := 0 to 1 +// i := 32*j +// dst[i+31:i] := Convert_FP32_To_Int32(a[i+31:i]) +// ENDFOR +// +// https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_cvt_ps2pi +FORCE_INLINE __m64 _mm_cvt_ps2pi(__m128 a) +{ +#if defined(__aarch64__) + return vreinterpret_m64_s32( + vget_low_s32(vcvtnq_s32_f32(vreinterpretq_f32_m128(a)))); +#else + return vreinterpret_m64_s32( + vcvt_s32_f32(vget_low_f32(vreinterpretq_f32_m128( + _mm_round_ps(a, _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC))))); +#endif +} + +// Round the packed single-precision (32-bit) floating-point elements in a up to +// an integer value, and store the results as packed single-precision +// floating-point elements in dst. +// https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_ceil_ps +FORCE_INLINE __m128 _mm_ceil_ps(__m128 a) +{ + return _mm_round_ps(a, _MM_FROUND_TO_POS_INF | _MM_FROUND_NO_EXC); +} + +// Round the packed single-precision (32-bit) floating-point elements in a down +// to an integer value, and store the results as packed single-precision +// floating-point elements in dst. +// https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_floor_ps +FORCE_INLINE __m128 _mm_floor_ps(__m128 a) +{ + return _mm_round_ps(a, _MM_FROUND_TO_NEG_INF | _MM_FROUND_NO_EXC); +} + + +// Load 128-bits of integer data from unaligned memory into dst. This intrinsic +// may perform better than _mm_loadu_si128 when the data crosses a cache line +// boundary. +// +// dst[127:0] := MEM[mem_addr+127:mem_addr] +// +// https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_lddqu_si128 +#define _mm_lddqu_si128 _mm_loadu_si128 + +/* Miscellaneous Operations */ + +// Shifts the 8 signed 16-bit integers in a right by count bits while shifting +// in the sign bit. +// +// r0 := a0 >> count +// r1 := a1 >> count +// ... +// r7 := a7 >> count +// +// https://msdn.microsoft.com/en-us/library/3c9997dk(v%3dvs.90).aspx +FORCE_INLINE __m128i _mm_sra_epi16(__m128i a, __m128i count) +{ + int64_t c = (int64_t) vget_low_s64((int64x2_t) count); + if (c > 15) + return _mm_cmplt_epi16(a, _mm_setzero_si128()); + return vreinterpretq_m128i_s16(vshlq_s16((int16x8_t) a, vdupq_n_s16(-c))); +} + +// Shifts the 4 signed 32-bit integers in a right by count bits while shifting +// in the sign bit. +// +// r0 := a0 >> count +// r1 := a1 >> count +// r2 := a2 >> count +// r3 := a3 >> count +// +// https://msdn.microsoft.com/en-us/library/ce40009e(v%3dvs.100).aspx +FORCE_INLINE __m128i _mm_sra_epi32(__m128i a, __m128i count) +{ + int64_t c = (int64_t) vget_low_s64((int64x2_t) count); + if (c > 31) + return _mm_cmplt_epi32(a, _mm_setzero_si128()); + return vreinterpretq_m128i_s32(vshlq_s32((int32x4_t) a, vdupq_n_s32(-c))); +} + +// Packs the 16 signed 16-bit integers from a and b into 8-bit integers and +// saturates. +// https://msdn.microsoft.com/en-us/library/k4y4f7w5%28v=vs.90%29.aspx +FORCE_INLINE __m128i _mm_packs_epi16(__m128i a, __m128i b) +{ + return vreinterpretq_m128i_s8( + vcombine_s8(vqmovn_s16(vreinterpretq_s16_m128i(a)), + vqmovn_s16(vreinterpretq_s16_m128i(b)))); +} + +// Packs the 16 signed 16 - bit integers from a and b into 8 - bit unsigned +// integers and saturates. +// +// r0 := UnsignedSaturate(a0) +// r1 := UnsignedSaturate(a1) +// ... +// r7 := UnsignedSaturate(a7) +// r8 := UnsignedSaturate(b0) +// r9 := UnsignedSaturate(b1) +// ... +// r15 := UnsignedSaturate(b7) +// +// https://msdn.microsoft.com/en-us/library/07ad1wx4(v=vs.100).aspx +FORCE_INLINE __m128i _mm_packus_epi16(const __m128i a, const __m128i b) +{ + return vreinterpretq_m128i_u8( + vcombine_u8(vqmovun_s16(vreinterpretq_s16_m128i(a)), + vqmovun_s16(vreinterpretq_s16_m128i(b)))); +} + +// Packs the 8 signed 32-bit integers from a and b into signed 16-bit integers +// and saturates. +// +// r0 := SignedSaturate(a0) +// r1 := SignedSaturate(a1) +// r2 := SignedSaturate(a2) +// r3 := SignedSaturate(a3) +// r4 := SignedSaturate(b0) +// r5 := SignedSaturate(b1) +// r6 := SignedSaturate(b2) +// r7 := SignedSaturate(b3) +// +// https://msdn.microsoft.com/en-us/library/393t56f9%28v=vs.90%29.aspx +FORCE_INLINE __m128i _mm_packs_epi32(__m128i a, __m128i b) +{ + return vreinterpretq_m128i_s16( + vcombine_s16(vqmovn_s32(vreinterpretq_s32_m128i(a)), + vqmovn_s32(vreinterpretq_s32_m128i(b)))); +} + +// Packs the 8 unsigned 32-bit integers from a and b into unsigned 16-bit +// integers and saturates. +// +// r0 := UnsignedSaturate(a0) +// r1 := UnsignedSaturate(a1) +// r2 := UnsignedSaturate(a2) +// r3 := UnsignedSaturate(a3) +// r4 := UnsignedSaturate(b0) +// r5 := UnsignedSaturate(b1) +// r6 := UnsignedSaturate(b2) +// r7 := UnsignedSaturate(b3) +FORCE_INLINE __m128i _mm_packus_epi32(__m128i a, __m128i b) +{ + return vreinterpretq_m128i_u16( + vcombine_u16(vqmovun_s32(vreinterpretq_s32_m128i(a)), + vqmovun_s32(vreinterpretq_s32_m128i(b)))); +} + +// Interleaves the lower 8 signed or unsigned 8-bit integers in a with the lower +// 8 signed or unsigned 8-bit integers in b. +// +// r0 := a0 +// r1 := b0 +// r2 := a1 +// r3 := b1 +// ... +// r14 := a7 +// r15 := b7 +// +// https://msdn.microsoft.com/en-us/library/xf7k860c%28v=vs.90%29.aspx +FORCE_INLINE __m128i _mm_unpacklo_epi8(__m128i a, __m128i b) +{ +#if defined(__aarch64__) + return vreinterpretq_m128i_s8( + vzip1q_s8(vreinterpretq_s8_m128i(a), vreinterpretq_s8_m128i(b))); +#else + int8x8_t a1 = vreinterpret_s8_s16(vget_low_s16(vreinterpretq_s16_m128i(a))); + int8x8_t b1 = vreinterpret_s8_s16(vget_low_s16(vreinterpretq_s16_m128i(b))); + int8x8x2_t result = vzip_s8(a1, b1); + return vreinterpretq_m128i_s8(vcombine_s8(result.val[0], result.val[1])); +#endif +} + +// Interleaves the lower 4 signed or unsigned 16-bit integers in a with the +// lower 4 signed or unsigned 16-bit integers in b. +// +// r0 := a0 +// r1 := b0 +// r2 := a1 +// r3 := b1 +// r4 := a2 +// r5 := b2 +// r6 := a3 +// r7 := b3 +// +// https://msdn.microsoft.com/en-us/library/btxb17bw%28v=vs.90%29.aspx +FORCE_INLINE __m128i _mm_unpacklo_epi16(__m128i a, __m128i b) +{ +#if defined(__aarch64__) + return vreinterpretq_m128i_s16( + vzip1q_s16(vreinterpretq_s16_m128i(a), vreinterpretq_s16_m128i(b))); +#else + int16x4_t a1 = vget_low_s16(vreinterpretq_s16_m128i(a)); + int16x4_t b1 = vget_low_s16(vreinterpretq_s16_m128i(b)); + int16x4x2_t result = vzip_s16(a1, b1); + return vreinterpretq_m128i_s16(vcombine_s16(result.val[0], result.val[1])); +#endif +} + +// Interleaves the lower 2 signed or unsigned 32 - bit integers in a with the +// lower 2 signed or unsigned 32 - bit integers in b. +// +// r0 := a0 +// r1 := b0 +// r2 := a1 +// r3 := b1 +// +// https://msdn.microsoft.com/en-us/library/x8atst9d(v=vs.100).aspx +FORCE_INLINE __m128i _mm_unpacklo_epi32(__m128i a, __m128i b) +{ +#if defined(__aarch64__) + return vreinterpretq_m128i_s32( + vzip1q_s32(vreinterpretq_s32_m128i(a), vreinterpretq_s32_m128i(b))); +#else + int32x2_t a1 = vget_low_s32(vreinterpretq_s32_m128i(a)); + int32x2_t b1 = vget_low_s32(vreinterpretq_s32_m128i(b)); + int32x2x2_t result = vzip_s32(a1, b1); + return vreinterpretq_m128i_s32(vcombine_s32(result.val[0], result.val[1])); +#endif +} + +FORCE_INLINE __m128i _mm_unpacklo_epi64(__m128i a, __m128i b) +{ + int64x1_t a_l = vget_low_s64(vreinterpretq_s64_m128i(a)); + int64x1_t b_l = vget_low_s64(vreinterpretq_s64_m128i(b)); + return vreinterpretq_m128i_s64(vcombine_s64(a_l, b_l)); +} + +// Selects and interleaves the lower two single-precision, floating-point values +// from a and b. +// +// r0 := a0 +// r1 := b0 +// r2 := a1 +// r3 := b1 +// +// https://msdn.microsoft.com/en-us/library/25st103b%28v=vs.90%29.aspx +FORCE_INLINE __m128 _mm_unpacklo_ps(__m128 a, __m128 b) +{ +#if defined(__aarch64__) + return vreinterpretq_m128_f32( + vzip1q_f32(vreinterpretq_f32_m128(a), vreinterpretq_f32_m128(b))); +#else + float32x2_t a1 = vget_low_f32(vreinterpretq_f32_m128(a)); + float32x2_t b1 = vget_low_f32(vreinterpretq_f32_m128(b)); + float32x2x2_t result = vzip_f32(a1, b1); + return vreinterpretq_m128_f32(vcombine_f32(result.val[0], result.val[1])); +#endif +} + +// Selects and interleaves the upper two single-precision, floating-point values +// from a and b. +// +// r0 := a2 +// r1 := b2 +// r2 := a3 +// r3 := b3 +// +// https://msdn.microsoft.com/en-us/library/skccxx7d%28v=vs.90%29.aspx +FORCE_INLINE __m128 _mm_unpackhi_ps(__m128 a, __m128 b) +{ +#if defined(__aarch64__) + return vreinterpretq_m128_f32( + vzip2q_f32(vreinterpretq_f32_m128(a), vreinterpretq_f32_m128(b))); +#else + float32x2_t a1 = vget_high_f32(vreinterpretq_f32_m128(a)); + float32x2_t b1 = vget_high_f32(vreinterpretq_f32_m128(b)); + float32x2x2_t result = vzip_f32(a1, b1); + return vreinterpretq_m128_f32(vcombine_f32(result.val[0], result.val[1])); +#endif +} + +// Interleaves the upper 8 signed or unsigned 8-bit integers in a with the upper +// 8 signed or unsigned 8-bit integers in b. +// +// r0 := a8 +// r1 := b8 +// r2 := a9 +// r3 := b9 +// ... +// r14 := a15 +// r15 := b15 +// +// https://msdn.microsoft.com/en-us/library/t5h7783k(v=vs.100).aspx +FORCE_INLINE __m128i _mm_unpackhi_epi8(__m128i a, __m128i b) +{ +#if defined(__aarch64__) + return vreinterpretq_m128i_s8( + vzip2q_s8(vreinterpretq_s8_m128i(a), vreinterpretq_s8_m128i(b))); +#else + int8x8_t a1 = + vreinterpret_s8_s16(vget_high_s16(vreinterpretq_s16_m128i(a))); + int8x8_t b1 = + vreinterpret_s8_s16(vget_high_s16(vreinterpretq_s16_m128i(b))); + int8x8x2_t result = vzip_s8(a1, b1); + return vreinterpretq_m128i_s8(vcombine_s8(result.val[0], result.val[1])); +#endif +} + +// Interleaves the upper 4 signed or unsigned 16-bit integers in a with the +// upper 4 signed or unsigned 16-bit integers in b. +// +// r0 := a4 +// r1 := b4 +// r2 := a5 +// r3 := b5 +// r4 := a6 +// r5 := b6 +// r6 := a7 +// r7 := b7 +// +// https://msdn.microsoft.com/en-us/library/03196cz7(v=vs.100).aspx +FORCE_INLINE __m128i _mm_unpackhi_epi16(__m128i a, __m128i b) +{ +#if defined(__aarch64__) + return vreinterpretq_m128i_s16( + vzip2q_s16(vreinterpretq_s16_m128i(a), vreinterpretq_s16_m128i(b))); +#else + int16x4_t a1 = vget_high_s16(vreinterpretq_s16_m128i(a)); + int16x4_t b1 = vget_high_s16(vreinterpretq_s16_m128i(b)); + int16x4x2_t result = vzip_s16(a1, b1); + return vreinterpretq_m128i_s16(vcombine_s16(result.val[0], result.val[1])); +#endif +} + +// Interleaves the upper 2 signed or unsigned 32-bit integers in a with the +// upper 2 signed or unsigned 32-bit integers in b. +// https://msdn.microsoft.com/en-us/library/65sa7cbs(v=vs.100).aspx +FORCE_INLINE __m128i _mm_unpackhi_epi32(__m128i a, __m128i b) +{ +#if defined(__aarch64__) + return vreinterpretq_m128i_s32( + vzip2q_s32(vreinterpretq_s32_m128i(a), vreinterpretq_s32_m128i(b))); +#else + int32x2_t a1 = vget_high_s32(vreinterpretq_s32_m128i(a)); + int32x2_t b1 = vget_high_s32(vreinterpretq_s32_m128i(b)); + int32x2x2_t result = vzip_s32(a1, b1); + return vreinterpretq_m128i_s32(vcombine_s32(result.val[0], result.val[1])); +#endif +} + +// Interleaves the upper signed or unsigned 64-bit integer in a with the +// upper signed or unsigned 64-bit integer in b. +// +// r0 := a1 +// r1 := b1 +FORCE_INLINE __m128i _mm_unpackhi_epi64(__m128i a, __m128i b) +{ + int64x1_t a_h = vget_high_s64(vreinterpretq_s64_m128i(a)); + int64x1_t b_h = vget_high_s64(vreinterpretq_s64_m128i(b)); + return vreinterpretq_m128i_s64(vcombine_s64(a_h, b_h)); +} + +// Horizontally compute the minimum amongst the packed unsigned 16-bit integers +// in a, store the minimum and index in dst, and zero the remaining bits in dst. +// +// index[2:0] := 0 +// min[15:0] := a[15:0] +// FOR j := 0 to 7 +// i := j*16 +// IF a[i+15:i] < min[15:0] +// index[2:0] := j +// min[15:0] := a[i+15:i] +// FI +// ENDFOR +// dst[15:0] := min[15:0] +// dst[18:16] := index[2:0] +// dst[127:19] := 0 +// +// https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_minpos_epu16 +FORCE_INLINE __m128i _mm_minpos_epu16(__m128i a) +{ + __m128i dst; + uint16_t min, idx = 0; + // Find the minimum value +#if defined(__aarch64__) + min = vminvq_u16(vreinterpretq_u16_m128i(a)); +#else + __m64 tmp; + tmp = vreinterpret_m64_u16( + vmin_u16(vget_low_u16(vreinterpretq_u16_m128i(a)), + vget_high_u16(vreinterpretq_u16_m128i(a)))); + tmp = vreinterpret_m64_u16( + vpmin_u16(vreinterpret_u16_m64(tmp), vreinterpret_u16_m64(tmp))); + tmp = vreinterpret_m64_u16( + vpmin_u16(vreinterpret_u16_m64(tmp), vreinterpret_u16_m64(tmp))); + min = vget_lane_u16(vreinterpret_u16_m64(tmp), 0); +#endif + // Get the index of the minimum value + int i; + for (i = 0; i < 8; i++) { + if (min == vgetq_lane_u16(vreinterpretq_u16_m128i(a), 0)) { + idx = (uint16_t) i; + break; + } + a = _mm_srli_si128(a, 2); + } + // Generate result + dst = _mm_setzero_si128(); + dst = vreinterpretq_m128i_u16( + vsetq_lane_u16(min, vreinterpretq_u16_m128i(dst), 0)); + dst = vreinterpretq_m128i_u16( + vsetq_lane_u16(idx, vreinterpretq_u16_m128i(dst), 1)); + return dst; +} + +// shift to right +// https://msdn.microsoft.com/en-us/library/bb514041(v=vs.120).aspx +// http://blog.csdn.net/hemmingway/article/details/44828303 +// Clang requires a macro here, as it is extremely picky about c being a +// literal. +#define _mm_alignr_epi8(a, b, c) \ + ((__m128i) vextq_s8((int8x16_t)(b), (int8x16_t)(a), (c))) + +// Compute the bitwise AND of 128 bits (representing integer data) in a and b, +// and set ZF to 1 if the result is zero, otherwise set ZF to 0. Compute the +// bitwise NOT of a and then AND with b, and set CF to 1 if the result is zero, +// otherwise set CF to 0. Return the CF value. +// https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_testc_si128 +FORCE_INLINE int _mm_testc_si128(__m128i a, __m128i b) +{ + int64x2_t s64 = + vandq_s64(vreinterpretq_s64_s32(vmvnq_s32(vreinterpretq_s32_m128i(a))), + vreinterpretq_s64_m128i(b)); + return !(vgetq_lane_s64(s64, 0) | vgetq_lane_s64(s64, 1)); +} + +// Compute the bitwise AND of 128 bits (representing integer data) in a and b, +// and set ZF to 1 if the result is zero, otherwise set ZF to 0. Compute the +// bitwise NOT of a and then AND with b, and set CF to 1 if the result is zero, +// otherwise set CF to 0. Return the ZF value. +// https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_testz_si128 +FORCE_INLINE int _mm_testz_si128(__m128i a, __m128i b) +{ + int64x2_t s64 = + vandq_s64(vreinterpretq_s64_m128i(a), vreinterpretq_s64_m128i(b)); + return !(vgetq_lane_s64(s64, 0) | vgetq_lane_s64(s64, 1)); +} + +// Extracts the selected signed or unsigned 8-bit integer from a and zero +// extends. +// FORCE_INLINE int _mm_extract_epi8(__m128i a, __constrange(0,16) int imm) +#define _mm_extract_epi8(a, imm) vgetq_lane_u8(vreinterpretq_u8_m128i(a), (imm)) + +// Inserts the least significant 8 bits of b into the selected 8-bit integer +// of a. +// FORCE_INLINE __m128i _mm_insert_epi8(__m128i a, int b, +// __constrange(0,16) int imm) +#define _mm_insert_epi8(a, b, imm) \ + __extension__({ \ + vreinterpretq_m128i_s8( \ + vsetq_lane_s8((b), vreinterpretq_s8_m128i(a), (imm))); \ + }) + +// Extracts the selected signed or unsigned 16-bit integer from a and zero +// extends. +// https://msdn.microsoft.com/en-us/library/6dceta0c(v=vs.100).aspx +// FORCE_INLINE int _mm_extract_epi16(__m128i a, __constrange(0,8) int imm) +#define _mm_extract_epi16(a, imm) \ + vgetq_lane_u16(vreinterpretq_u16_m128i(a), (imm)) + +// Inserts the least significant 16 bits of b into the selected 16-bit integer +// of a. +// https://msdn.microsoft.com/en-us/library/kaze8hz1%28v=vs.100%29.aspx +// FORCE_INLINE __m128i _mm_insert_epi16(__m128i a, int b, +// __constrange(0,8) int imm) +#define _mm_insert_epi16(a, b, imm) \ + __extension__({ \ + vreinterpretq_m128i_s16( \ + vsetq_lane_s16((b), vreinterpretq_s16_m128i(a), (imm))); \ + }) + +// Extracts the selected signed or unsigned 32-bit integer from a and zero +// extends. +// FORCE_INLINE int _mm_extract_epi32(__m128i a, __constrange(0,4) int imm) +#define _mm_extract_epi32(a, imm) \ + vgetq_lane_s32(vreinterpretq_s32_m128i(a), (imm)) + +// Extracts the selected single-precision (32-bit) floating-point from a. +// FORCE_INLINE int _mm_extract_ps(__m128 a, __constrange(0,4) int imm) +#define _mm_extract_ps(a, imm) vgetq_lane_s32(vreinterpretq_s32_m128(a), (imm)) + +// Inserts the least significant 32 bits of b into the selected 32-bit integer +// of a. +// FORCE_INLINE __m128i _mm_insert_epi32(__m128i a, int b, +// __constrange(0,4) int imm) +#define _mm_insert_epi32(a, b, imm) \ + __extension__({ \ + vreinterpretq_m128i_s32( \ + vsetq_lane_s32((b), vreinterpretq_s32_m128i(a), (imm))); \ + }) + +// Extracts the selected signed or unsigned 64-bit integer from a and zero +// extends. +// FORCE_INLINE __int64 _mm_extract_epi64(__m128i a, __constrange(0,2) int imm) +#define _mm_extract_epi64(a, imm) \ + vgetq_lane_s64(vreinterpretq_s64_m128i(a), (imm)) + +// Inserts the least significant 64 bits of b into the selected 64-bit integer +// of a. +// FORCE_INLINE __m128i _mm_insert_epi64(__m128i a, __int64 b, +// __constrange(0,2) int imm) +#define _mm_insert_epi64(a, b, imm) \ + __extension__({ \ + vreinterpretq_m128i_s64( \ + vsetq_lane_s64((b), vreinterpretq_s64_m128i(a), (imm))); \ + }) + +// Count the number of bits set to 1 in unsigned 32-bit integer a, and +// return that count in dst. +// https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_popcnt_u32 +FORCE_INLINE int _mm_popcnt_u32(unsigned int a) +{ +#if defined(__aarch64__) +#if __has_builtin(__builtin_popcount) + return __builtin_popcount(a); +#else + return (int) vaddlv_u8(vcnt_u8(vcreate_u8((uint64_t) a))); +#endif +#else + uint32_t count = 0; + uint8x8_t input_val, count8x8_val; + uint16x4_t count16x4_val; + uint32x2_t count32x2_val; + + input_val = vld1_u8((uint8_t *) &a); + count8x8_val = vcnt_u8(input_val); + count16x4_val = vpaddl_u8(count8x8_val); + count32x2_val = vpaddl_u16(count16x4_val); + + vst1_u32(&count, count32x2_val); + return count; +#endif +} + +// Count the number of bits set to 1 in unsigned 64-bit integer a, and +// return that count in dst. +// https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_popcnt_u64 +FORCE_INLINE int64_t _mm_popcnt_u64(uint64_t a) +{ +#if defined(__aarch64__) +#if __has_builtin(__builtin_popcountll) + return __builtin_popcountll(a); +#else + return (int64_t) vaddlv_u8(vcnt_u8(vcreate_u8(a))); +#endif +#else + uint64_t count = 0; + uint8x8_t input_val, count8x8_val; + uint16x4_t count16x4_val; + uint32x2_t count32x2_val; + uint64x1_t count64x1_val; + + input_val = vld1_u8((uint8_t *) &a); + count8x8_val = vcnt_u8(input_val); + count16x4_val = vpaddl_u8(count8x8_val); + count32x2_val = vpaddl_u16(count16x4_val); + count64x1_val = vpaddl_u32(count32x2_val); + vst1_u64(&count, count64x1_val); + return count; +#endif +} + +// Macro: Transpose the 4x4 matrix formed by the 4 rows of single-precision +// (32-bit) floating-point elements in row0, row1, row2, and row3, and store the +// transposed matrix in these vectors (row0 now contains column 0, etc.). +// https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=MM_TRANSPOSE4_PS +#define _MM_TRANSPOSE4_PS(row0, row1, row2, row3) \ + do { \ + float32x4x2_t ROW01 = vtrnq_f32(row0, row1); \ + float32x4x2_t ROW23 = vtrnq_f32(row2, row3); \ + row0 = vcombine_f32(vget_low_f32(ROW01.val[0]), \ + vget_low_f32(ROW23.val[0])); \ + row1 = vcombine_f32(vget_low_f32(ROW01.val[1]), \ + vget_low_f32(ROW23.val[1])); \ + row2 = vcombine_f32(vget_high_f32(ROW01.val[0]), \ + vget_high_f32(ROW23.val[0])); \ + row3 = vcombine_f32(vget_high_f32(ROW01.val[1]), \ + vget_high_f32(ROW23.val[1])); \ + } while (0) + +/* Crypto Extensions */ + +#if defined(__ARM_FEATURE_CRYPTO) +// Wraps vmull_p64 +FORCE_INLINE uint64x2_t _sse2neon_vmull_p64(uint64x1_t _a, uint64x1_t _b) +{ + poly64_t a = vget_lane_p64(vreinterpret_p64_u64(_a), 0); + poly64_t b = vget_lane_p64(vreinterpret_p64_u64(_b), 0); + return vreinterpretq_u64_p128(vmull_p64(a, b)); +} +#else // ARMv7 polyfill +// ARMv7/some A64 lacks vmull_p64, but it has vmull_p8. +// +// vmull_p8 calculates 8 8-bit->16-bit polynomial multiplies, but we need a +// 64-bit->128-bit polynomial multiply. +// +// It needs some work and is somewhat slow, but it is still faster than all +// known scalar methods. +// +// Algorithm adapted to C from +// https://www.workofard.com/2017/07/ghash-for-low-end-cores/, which is adapted +// from "Fast Software Polynomial Multiplication on ARM Processors Using the +// NEON Engine" by Danilo Camara, Conrado Gouvea, Julio Lopez and Ricardo Dahab +// (https://hal.inria.fr/hal-01506572) +static uint64x2_t _sse2neon_vmull_p64(uint64x1_t _a, uint64x1_t _b) +{ + poly8x8_t a = vreinterpret_p8_u64(_a); + poly8x8_t b = vreinterpret_p8_u64(_b); + + // Masks + uint8x16_t k48_32 = vcombine_u8(vcreate_u8(0x0000ffffffffffff), + vcreate_u8(0x00000000ffffffff)); + uint8x16_t k16_00 = vcombine_u8(vcreate_u8(0x000000000000ffff), + vcreate_u8(0x0000000000000000)); + + // Do the multiplies, rotating with vext to get all combinations + uint8x16_t d = vreinterpretq_u8_p16(vmull_p8(a, b)); // D = A0 * B0 + uint8x16_t e = + vreinterpretq_u8_p16(vmull_p8(a, vext_p8(b, b, 1))); // E = A0 * B1 + uint8x16_t f = + vreinterpretq_u8_p16(vmull_p8(vext_p8(a, a, 1), b)); // F = A1 * B0 + uint8x16_t g = + vreinterpretq_u8_p16(vmull_p8(a, vext_p8(b, b, 2))); // G = A0 * B2 + uint8x16_t h = + vreinterpretq_u8_p16(vmull_p8(vext_p8(a, a, 2), b)); // H = A2 * B0 + uint8x16_t i = + vreinterpretq_u8_p16(vmull_p8(a, vext_p8(b, b, 3))); // I = A0 * B3 + uint8x16_t j = + vreinterpretq_u8_p16(vmull_p8(vext_p8(a, a, 3), b)); // J = A3 * B0 + uint8x16_t k = + vreinterpretq_u8_p16(vmull_p8(a, vext_p8(b, b, 4))); // L = A0 * B4 + + // Add cross products + uint8x16_t l = veorq_u8(e, f); // L = E + F + uint8x16_t m = veorq_u8(g, h); // M = G + H + uint8x16_t n = veorq_u8(i, j); // N = I + J + + // Interleave. Using vzip1 and vzip2 prevents Clang from emitting TBL + // instructions. +#if defined(__aarch64__) + uint8x16_t lm_p0 = vreinterpretq_u8_u64( + vzip1q_u64(vreinterpretq_u64_u8(l), vreinterpretq_u64_u8(m))); + uint8x16_t lm_p1 = vreinterpretq_u8_u64( + vzip2q_u64(vreinterpretq_u64_u8(l), vreinterpretq_u64_u8(m))); + uint8x16_t nk_p0 = vreinterpretq_u8_u64( + vzip1q_u64(vreinterpretq_u64_u8(n), vreinterpretq_u64_u8(k))); + uint8x16_t nk_p1 = vreinterpretq_u8_u64( + vzip2q_u64(vreinterpretq_u64_u8(n), vreinterpretq_u64_u8(k))); +#else + uint8x16_t lm_p0 = vcombine_u8(vget_low_u8(l), vget_low_u8(m)); + uint8x16_t lm_p1 = vcombine_u8(vget_high_u8(l), vget_high_u8(m)); + uint8x16_t nk_p0 = vcombine_u8(vget_low_u8(n), vget_low_u8(k)); + uint8x16_t nk_p1 = vcombine_u8(vget_high_u8(n), vget_high_u8(k)); +#endif + // t0 = (L) (P0 + P1) << 8 + // t1 = (M) (P2 + P3) << 16 + uint8x16_t t0t1_tmp = veorq_u8(lm_p0, lm_p1); + uint8x16_t t0t1_h = vandq_u8(lm_p1, k48_32); + uint8x16_t t0t1_l = veorq_u8(t0t1_tmp, t0t1_h); + + // t2 = (N) (P4 + P5) << 24 + // t3 = (K) (P6 + P7) << 32 + uint8x16_t t2t3_tmp = veorq_u8(nk_p0, nk_p1); + uint8x16_t t2t3_h = vandq_u8(nk_p1, k16_00); + uint8x16_t t2t3_l = veorq_u8(t2t3_tmp, t2t3_h); + + // De-interleave +#if defined(__aarch64__) + uint8x16_t t0 = vreinterpretq_u8_u64( + vuzp1q_u64(vreinterpretq_u64_u8(t0t1_l), vreinterpretq_u64_u8(t0t1_h))); + uint8x16_t t1 = vreinterpretq_u8_u64( + vuzp2q_u64(vreinterpretq_u64_u8(t0t1_l), vreinterpretq_u64_u8(t0t1_h))); + uint8x16_t t2 = vreinterpretq_u8_u64( + vuzp1q_u64(vreinterpretq_u64_u8(t2t3_l), vreinterpretq_u64_u8(t2t3_h))); + uint8x16_t t3 = vreinterpretq_u8_u64( + vuzp2q_u64(vreinterpretq_u64_u8(t2t3_l), vreinterpretq_u64_u8(t2t3_h))); +#else + uint8x16_t t1 = vcombine_u8(vget_high_u8(t0t1_l), vget_high_u8(t0t1_h)); + uint8x16_t t0 = vcombine_u8(vget_low_u8(t0t1_l), vget_low_u8(t0t1_h)); + uint8x16_t t3 = vcombine_u8(vget_high_u8(t2t3_l), vget_high_u8(t2t3_h)); + uint8x16_t t2 = vcombine_u8(vget_low_u8(t2t3_l), vget_low_u8(t2t3_h)); +#endif + // Shift the cross products + uint8x16_t t0_shift = vextq_u8(t0, t0, 15); // t0 << 8 + uint8x16_t t1_shift = vextq_u8(t1, t1, 14); // t1 << 16 + uint8x16_t t2_shift = vextq_u8(t2, t2, 13); // t2 << 24 + uint8x16_t t3_shift = vextq_u8(t3, t3, 12); // t3 << 32 + + // Accumulate the products + uint8x16_t cross1 = veorq_u8(t0_shift, t1_shift); + uint8x16_t cross2 = veorq_u8(t2_shift, t3_shift); + uint8x16_t mix = veorq_u8(d, cross1); + uint8x16_t r = veorq_u8(mix, cross2); + return vreinterpretq_u64_u8(r); +} +#endif // ARMv7 polyfill + +FORCE_INLINE __m128i _mm_clmulepi64_si128(__m128i _a, __m128i _b, const int imm) +{ + uint64x2_t a = vreinterpretq_u64_m128i(_a); + uint64x2_t b = vreinterpretq_u64_m128i(_b); + switch (imm & 0x11) { + case 0x00: + return vreinterpretq_m128i_u64( + _sse2neon_vmull_p64(vget_low_u64(a), vget_low_u64(b))); + case 0x01: + return vreinterpretq_m128i_u64( + _sse2neon_vmull_p64(vget_high_u64(a), vget_low_u64(b))); + case 0x10: + return vreinterpretq_m128i_u64( + _sse2neon_vmull_p64(vget_low_u64(a), vget_high_u64(b))); + case 0x11: + return vreinterpretq_m128i_u64( + _sse2neon_vmull_p64(vget_high_u64(a), vget_high_u64(b))); + default: + abort(); + } +} + +#if !defined(__ARM_FEATURE_CRYPTO) +/* clang-format off */ +#define SSE2NEON_AES_DATA(w) \ + { \ + w(0x63), w(0x7c), w(0x77), w(0x7b), w(0xf2), w(0x6b), w(0x6f), \ + w(0xc5), w(0x30), w(0x01), w(0x67), w(0x2b), w(0xfe), w(0xd7), \ + w(0xab), w(0x76), w(0xca), w(0x82), w(0xc9), w(0x7d), w(0xfa), \ + w(0x59), w(0x47), w(0xf0), w(0xad), w(0xd4), w(0xa2), w(0xaf), \ + w(0x9c), w(0xa4), w(0x72), w(0xc0), w(0xb7), w(0xfd), w(0x93), \ + w(0x26), w(0x36), w(0x3f), w(0xf7), w(0xcc), w(0x34), w(0xa5), \ + w(0xe5), w(0xf1), w(0x71), w(0xd8), w(0x31), w(0x15), w(0x04), \ + w(0xc7), w(0x23), w(0xc3), w(0x18), w(0x96), w(0x05), w(0x9a), \ + w(0x07), w(0x12), w(0x80), w(0xe2), w(0xeb), w(0x27), w(0xb2), \ + w(0x75), w(0x09), w(0x83), w(0x2c), w(0x1a), w(0x1b), w(0x6e), \ + w(0x5a), w(0xa0), w(0x52), w(0x3b), w(0xd6), w(0xb3), w(0x29), \ + w(0xe3), w(0x2f), w(0x84), w(0x53), w(0xd1), w(0x00), w(0xed), \ + w(0x20), w(0xfc), w(0xb1), w(0x5b), w(0x6a), w(0xcb), w(0xbe), \ + w(0x39), w(0x4a), w(0x4c), w(0x58), w(0xcf), w(0xd0), w(0xef), \ + w(0xaa), w(0xfb), w(0x43), w(0x4d), w(0x33), w(0x85), w(0x45), \ + w(0xf9), w(0x02), w(0x7f), w(0x50), w(0x3c), w(0x9f), w(0xa8), \ + w(0x51), w(0xa3), w(0x40), w(0x8f), w(0x92), w(0x9d), w(0x38), \ + w(0xf5), w(0xbc), w(0xb6), w(0xda), w(0x21), w(0x10), w(0xff), \ + w(0xf3), w(0xd2), w(0xcd), w(0x0c), w(0x13), w(0xec), w(0x5f), \ + w(0x97), w(0x44), w(0x17), w(0xc4), w(0xa7), w(0x7e), w(0x3d), \ + w(0x64), w(0x5d), w(0x19), w(0x73), w(0x60), w(0x81), w(0x4f), \ + w(0xdc), w(0x22), w(0x2a), w(0x90), w(0x88), w(0x46), w(0xee), \ + w(0xb8), w(0x14), w(0xde), w(0x5e), w(0x0b), w(0xdb), w(0xe0), \ + w(0x32), w(0x3a), w(0x0a), w(0x49), w(0x06), w(0x24), w(0x5c), \ + w(0xc2), w(0xd3), w(0xac), w(0x62), w(0x91), w(0x95), w(0xe4), \ + w(0x79), w(0xe7), w(0xc8), w(0x37), w(0x6d), w(0x8d), w(0xd5), \ + w(0x4e), w(0xa9), w(0x6c), w(0x56), w(0xf4), w(0xea), w(0x65), \ + w(0x7a), w(0xae), w(0x08), w(0xba), w(0x78), w(0x25), w(0x2e), \ + w(0x1c), w(0xa6), w(0xb4), w(0xc6), w(0xe8), w(0xdd), w(0x74), \ + w(0x1f), w(0x4b), w(0xbd), w(0x8b), w(0x8a), w(0x70), w(0x3e), \ + w(0xb5), w(0x66), w(0x48), w(0x03), w(0xf6), w(0x0e), w(0x61), \ + w(0x35), w(0x57), w(0xb9), w(0x86), w(0xc1), w(0x1d), w(0x9e), \ + w(0xe1), w(0xf8), w(0x98), w(0x11), w(0x69), w(0xd9), w(0x8e), \ + w(0x94), w(0x9b), w(0x1e), w(0x87), w(0xe9), w(0xce), w(0x55), \ + w(0x28), w(0xdf), w(0x8c), w(0xa1), w(0x89), w(0x0d), w(0xbf), \ + w(0xe6), w(0x42), w(0x68), w(0x41), w(0x99), w(0x2d), w(0x0f), \ + w(0xb0), w(0x54), w(0xbb), w(0x16) \ + } +/* clang-format on */ + +/* X Macro trick. See https://en.wikipedia.org/wiki/X_Macro */ +#define SSE2NEON_AES_H0(x) (x) +static const uint8_t SSE2NEON_sbox[256] = SSE2NEON_AES_DATA(SSE2NEON_AES_H0); +#undef SSE2NEON_AES_H0 + +// In the absence of crypto extensions, implement aesenc using regular neon +// intrinsics instead. See: +// https://www.workofard.com/2017/01/accelerated-aes-for-the-arm64-linux-kernel/ +// https://www.workofard.com/2017/07/ghash-for-low-end-cores/ and +// https://github.com/ColinIanKing/linux-next-mirror/blob/b5f466091e130caaf0735976648f72bd5e09aa84/crypto/aegis128-neon-inner.c#L52 +// for more information Reproduced with permission of the author. +FORCE_INLINE __m128i _mm_aesenc_si128(__m128i EncBlock, __m128i RoundKey) +{ +#if defined(__aarch64__) + static const uint8_t shift_rows[] = {0x0, 0x5, 0xa, 0xf, 0x4, 0x9, + 0xe, 0x3, 0x8, 0xd, 0x2, 0x7, + 0xc, 0x1, 0x6, 0xb}; + static const uint8_t ror32by8[] = {0x1, 0x2, 0x3, 0x0, 0x5, 0x6, 0x7, 0x4, + 0x9, 0xa, 0xb, 0x8, 0xd, 0xe, 0xf, 0xc}; + + uint8x16_t v; + uint8x16_t w = vreinterpretq_u8_m128i(EncBlock); + + // shift rows + w = vqtbl1q_u8(w, vld1q_u8(shift_rows)); + + // sub bytes + v = vqtbl4q_u8(vld1q_u8_x4(SSE2NEON_sbox), w); + v = vqtbx4q_u8(v, vld1q_u8_x4(SSE2NEON_sbox + 0x40), w - 0x40); + v = vqtbx4q_u8(v, vld1q_u8_x4(SSE2NEON_sbox + 0x80), w - 0x80); + v = vqtbx4q_u8(v, vld1q_u8_x4(SSE2NEON_sbox + 0xc0), w - 0xc0); + + // mix columns + w = (v << 1) ^ (uint8x16_t)(((int8x16_t) v >> 7) & 0x1b); + w ^= (uint8x16_t) vrev32q_u16((uint16x8_t) v); + w ^= vqtbl1q_u8(v ^ w, vld1q_u8(ror32by8)); + + // add round key + return vreinterpretq_m128i_u8(w) ^ RoundKey; + +#else /* ARMv7-A NEON implementation */ +#define SSE2NEON_AES_B2W(b0, b1, b2, b3) \ + (((uint32_t)(b3) << 24) | ((uint32_t)(b2) << 16) | ((uint32_t)(b1) << 8) | \ + (b0)) +#define SSE2NEON_AES_F2(x) ((x << 1) ^ (((x >> 7) & 1) * 0x011b /* WPOLY */)) +#define SSE2NEON_AES_F3(x) (SSE2NEON_AES_F2(x) ^ x) +#define SSE2NEON_AES_U0(p) \ + SSE2NEON_AES_B2W(SSE2NEON_AES_F2(p), p, p, SSE2NEON_AES_F3(p)) +#define SSE2NEON_AES_U1(p) \ + SSE2NEON_AES_B2W(SSE2NEON_AES_F3(p), SSE2NEON_AES_F2(p), p, p) +#define SSE2NEON_AES_U2(p) \ + SSE2NEON_AES_B2W(p, SSE2NEON_AES_F3(p), SSE2NEON_AES_F2(p), p) +#define SSE2NEON_AES_U3(p) \ + SSE2NEON_AES_B2W(p, p, SSE2NEON_AES_F3(p), SSE2NEON_AES_F2(p)) + static const uint32_t ALIGN_STRUCT(16) aes_table[4][256] = { + SSE2NEON_AES_DATA(SSE2NEON_AES_U0), + SSE2NEON_AES_DATA(SSE2NEON_AES_U1), + SSE2NEON_AES_DATA(SSE2NEON_AES_U2), + SSE2NEON_AES_DATA(SSE2NEON_AES_U3), + }; +#undef SSE2NEON_AES_B2W +#undef SSE2NEON_AES_F2 +#undef SSE2NEON_AES_F3 +#undef SSE2NEON_AES_U0 +#undef SSE2NEON_AES_U1 +#undef SSE2NEON_AES_U2 +#undef SSE2NEON_AES_U3 + + uint32_t x0 = _mm_cvtsi128_si32(EncBlock); + uint32_t x1 = _mm_cvtsi128_si32(_mm_shuffle_epi32(EncBlock, 0x55)); + uint32_t x2 = _mm_cvtsi128_si32(_mm_shuffle_epi32(EncBlock, 0xAA)); + uint32_t x3 = _mm_cvtsi128_si32(_mm_shuffle_epi32(EncBlock, 0xFF)); + + __m128i out = _mm_set_epi32( + (aes_table[0][x3 & 0xff] ^ aes_table[1][(x0 >> 8) & 0xff] ^ + aes_table[2][(x1 >> 16) & 0xff] ^ aes_table[3][x2 >> 24]), + (aes_table[0][x2 & 0xff] ^ aes_table[1][(x3 >> 8) & 0xff] ^ + aes_table[2][(x0 >> 16) & 0xff] ^ aes_table[3][x1 >> 24]), + (aes_table[0][x1 & 0xff] ^ aes_table[1][(x2 >> 8) & 0xff] ^ + aes_table[2][(x3 >> 16) & 0xff] ^ aes_table[3][x0 >> 24]), + (aes_table[0][x0 & 0xff] ^ aes_table[1][(x1 >> 8) & 0xff] ^ + aes_table[2][(x2 >> 16) & 0xff] ^ aes_table[3][x3 >> 24])); + + return _mm_xor_si128(out, RoundKey); +#endif +} + +FORCE_INLINE __m128i _mm_aesenclast_si128(__m128i a, __m128i RoundKey) +{ + /* FIXME: optimized for NEON */ + uint8_t v[4][4] = { + [0] = {SSE2NEON_sbox[vreinterpretq_nth_u8_m128i(a, 0)], + SSE2NEON_sbox[vreinterpretq_nth_u8_m128i(a, 5)], + SSE2NEON_sbox[vreinterpretq_nth_u8_m128i(a, 10)], + SSE2NEON_sbox[vreinterpretq_nth_u8_m128i(a, 15)]}, + [1] = {SSE2NEON_sbox[vreinterpretq_nth_u8_m128i(a, 4)], + SSE2NEON_sbox[vreinterpretq_nth_u8_m128i(a, 9)], + SSE2NEON_sbox[vreinterpretq_nth_u8_m128i(a, 14)], + SSE2NEON_sbox[vreinterpretq_nth_u8_m128i(a, 3)]}, + [2] = {SSE2NEON_sbox[vreinterpretq_nth_u8_m128i(a, 8)], + SSE2NEON_sbox[vreinterpretq_nth_u8_m128i(a, 13)], + SSE2NEON_sbox[vreinterpretq_nth_u8_m128i(a, 2)], + SSE2NEON_sbox[vreinterpretq_nth_u8_m128i(a, 7)]}, + [3] = {SSE2NEON_sbox[vreinterpretq_nth_u8_m128i(a, 12)], + SSE2NEON_sbox[vreinterpretq_nth_u8_m128i(a, 1)], + SSE2NEON_sbox[vreinterpretq_nth_u8_m128i(a, 6)], + SSE2NEON_sbox[vreinterpretq_nth_u8_m128i(a, 11)]}, + }; + for (int i = 0; i < 16; i++) + vreinterpretq_nth_u8_m128i(a, i) = + v[i / 4][i % 4] ^ vreinterpretq_nth_u8_m128i(RoundKey, i); + return a; +} + +// Emits the Advanced Encryption Standard (AES) instruction aeskeygenassist. +// This instruction generates a round key for AES encryption. See +// https://kazakov.life/2017/11/01/cryptocurrency-mining-on-ios-devices/ +// for details. +// +// https://msdn.microsoft.com/en-us/library/cc714138(v=vs.120).aspx +FORCE_INLINE __m128i _mm_aeskeygenassist_si128(__m128i key, const int rcon) +{ + uint32_t X1 = _mm_cvtsi128_si32(_mm_shuffle_epi32(key, 0x55)); + uint32_t X3 = _mm_cvtsi128_si32(_mm_shuffle_epi32(key, 0xFF)); + for (int i = 0; i < 4; ++i) { + ((uint8_t *) &X1)[i] = SSE2NEON_sbox[((uint8_t *) &X1)[i]]; + ((uint8_t *) &X3)[i] = SSE2NEON_sbox[((uint8_t *) &X3)[i]]; + } + return _mm_set_epi32(((X3 >> 8) | (X3 << 24)) ^ rcon, X3, + ((X1 >> 8) | (X1 << 24)) ^ rcon, X1); +} +#undef SSE2NEON_AES_DATA + +#else /* __ARM_FEATURE_CRYPTO */ +// Implements equivalent of 'aesenc' by combining AESE (with an empty key) and +// AESMC and then manually applying the real key as an xor operation. This +// unfortunately means an additional xor op; the compiler should be able to +// optimize this away for repeated calls however. See +// https://blog.michaelbrase.com/2018/05/08/emulating-x86-aes-intrinsics-on-armv8-a +// for more details. +FORCE_INLINE __m128i _mm_aesenc_si128(__m128i a, __m128i b) +{ + return vreinterpretq_m128i_u8( + vaesmcq_u8(vaeseq_u8(vreinterpretq_u8_m128i(a), vdupq_n_u8(0))) ^ + vreinterpretq_u8_m128i(b)); +} + +// https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_aesenclast_si128 +FORCE_INLINE __m128i _mm_aesenclast_si128(__m128i a, __m128i RoundKey) +{ + return _mm_xor_si128(vreinterpretq_m128i_u8(vaeseq_u8( + vreinterpretq_u8_m128i(a), vdupq_n_u8(0))), + RoundKey); +} + +FORCE_INLINE __m128i _mm_aeskeygenassist_si128(__m128i a, const int rcon) +{ + // AESE does ShiftRows and SubBytes on A + uint8x16_t u8 = vaeseq_u8(vreinterpretq_u8_m128i(a), vdupq_n_u8(0)); + + uint8x16_t dest = { + // Undo ShiftRows step from AESE and extract X1 and X3 + u8[0x4], u8[0x1], u8[0xE], u8[0xB], // SubBytes(X1) + u8[0x1], u8[0xE], u8[0xB], u8[0x4], // ROT(SubBytes(X1)) + u8[0xC], u8[0x9], u8[0x6], u8[0x3], // SubBytes(X3) + u8[0x9], u8[0x6], u8[0x3], u8[0xC], // ROT(SubBytes(X3)) + }; + uint32x4_t r = {0, (unsigned) rcon, 0, (unsigned) rcon}; + return vreinterpretq_m128i_u8(dest) ^ vreinterpretq_m128i_u32(r); +} +#endif + +/* Streaming Extensions */ + +// Guarantees that every preceding store is globally visible before any +// subsequent store. +// https://msdn.microsoft.com/en-us/library/5h2w73d1%28v=vs.90%29.aspx +FORCE_INLINE void _mm_sfence(void) +{ + __sync_synchronize(); +} + +// Store 128-bits (composed of 4 packed single-precision (32-bit) floating- +// point elements) from a into memory using a non-temporal memory hint. +// https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_stream_ps +FORCE_INLINE void _mm_stream_ps(float *p, __m128 a) +{ +#if __has_builtin(__builtin_nontemporal_store) + __builtin_nontemporal_store(a, (float32x4_t *) p); +#else + vst1q_f32(p, vreinterpretq_f32_m128(a)); +#endif +} + +// Stores the data in a to the address p without polluting the caches. If the +// cache line containing address p is already in the cache, the cache will be +// updated. +// https://msdn.microsoft.com/en-us/library/ba08y07y%28v=vs.90%29.aspx +FORCE_INLINE void _mm_stream_si128(__m128i *p, __m128i a) +{ +#if __has_builtin(__builtin_nontemporal_store) + __builtin_nontemporal_store(a, p); +#else + vst1q_s64((int64_t *) p, vreinterpretq_s64_m128i(a)); +#endif +} + +// Load 128-bits of integer data from memory into dst using a non-temporal +// memory hint. mem_addr must be aligned on a 16-byte boundary or a +// general-protection exception may be generated. +// +// dst[127:0] := MEM[mem_addr+127:mem_addr] +// +// https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_stream_load_si128 +FORCE_INLINE __m128i _mm_stream_load_si128(__m128i *p) +{ +#if __has_builtin(__builtin_nontemporal_store) + return __builtin_nontemporal_load(p); +#else + return vreinterpretq_m128i_s64(vld1q_s64((int64_t *) p)); +#endif +} + +// Cache line containing p is flushed and invalidated from all caches in the +// coherency domain. : +// https://msdn.microsoft.com/en-us/library/ba08y07y(v=vs.100).aspx +FORCE_INLINE void _mm_clflush(void const *p) +{ + (void) p; + // no corollary for Neon? +} + +// Allocate aligned blocks of memory. +// https://software.intel.com/en-us/ +// cpp-compiler-developer-guide-and-reference-allocating-and-freeing-aligned-memory-blocks +FORCE_INLINE void *_mm_malloc(size_t size, size_t align) +{ + void *ptr; + if (align == 1) + return malloc(size); + if (align == 2 || (sizeof(void *) == 8 && align == 4)) + align = sizeof(void *); + if (!posix_memalign(&ptr, align, size)) + return ptr; + return NULL; +} + +FORCE_INLINE void _mm_free(void *addr) +{ + free(addr); +} + +// Starting with the initial value in crc, accumulates a CRC32 value for +// unsigned 8-bit integer v. +// https://msdn.microsoft.com/en-us/library/bb514036(v=vs.100) +FORCE_INLINE uint32_t _mm_crc32_u8(uint32_t crc, uint8_t v) +{ +#if defined(__aarch64__) && defined(__ARM_FEATURE_CRC32) + __asm__ __volatile__("crc32cb %w[c], %w[c], %w[v]\n\t" + : [c] "+r"(crc) + : [v] "r"(v)); +#else + crc ^= v; + for (int bit = 0; bit < 8; bit++) { + if (crc & 1) + crc = (crc >> 1) ^ UINT32_C(0x82f63b78); + else + crc = (crc >> 1); + } +#endif + return crc; +} + +// Starting with the initial value in crc, accumulates a CRC32 value for +// unsigned 16-bit integer v. +// https://msdn.microsoft.com/en-us/library/bb531411(v=vs.100) +FORCE_INLINE uint32_t _mm_crc32_u16(uint32_t crc, uint16_t v) +{ +#if defined(__aarch64__) && defined(__ARM_FEATURE_CRC32) + __asm__ __volatile__("crc32ch %w[c], %w[c], %w[v]\n\t" + : [c] "+r"(crc) + : [v] "r"(v)); +#else + crc = _mm_crc32_u8(crc, v & 0xff); + crc = _mm_crc32_u8(crc, (v >> 8) & 0xff); +#endif + return crc; +} + +// Starting with the initial value in crc, accumulates a CRC32 value for +// unsigned 32-bit integer v. +// https://msdn.microsoft.com/en-us/library/bb531394(v=vs.100) +FORCE_INLINE uint32_t _mm_crc32_u32(uint32_t crc, uint32_t v) +{ +#if defined(__aarch64__) && defined(__ARM_FEATURE_CRC32) + __asm__ __volatile__("crc32cw %w[c], %w[c], %w[v]\n\t" + : [c] "+r"(crc) + : [v] "r"(v)); +#else + crc = _mm_crc32_u16(crc, v & 0xffff); + crc = _mm_crc32_u16(crc, (v >> 16) & 0xffff); +#endif + return crc; +} + +// Starting with the initial value in crc, accumulates a CRC32 value for +// unsigned 64-bit integer v. +// https://msdn.microsoft.com/en-us/library/bb514033(v=vs.100) +FORCE_INLINE uint64_t _mm_crc32_u64(uint64_t crc, uint64_t v) +{ +#if defined(__aarch64__) && defined(__ARM_FEATURE_CRC32) + __asm__ __volatile__("crc32cx %w[c], %w[c], %x[v]\n\t" + : [c] "+r"(crc) + : [v] "r"(v)); +#else + crc = _mm_crc32_u32((uint32_t)(crc), v & 0xffffffff); + crc = _mm_crc32_u32((uint32_t)(crc), (v >> 32) & 0xffffffff); +#endif + return crc; +} + +#if defined(__GNUC__) || defined(__clang__) +#pragma pop_macro("ALIGN_STRUCT") +#pragma pop_macro("FORCE_INLINE") +#endif + +#if defined(__GNUC__) +#pragma GCC pop_options +#endif + +#endif diff --git a/venv/include/site/python3.12/pygame/mask.h b/venv/include/site/python3.12/pygame/mask.h new file mode 100644 index 00000000..45ad8c51 --- /dev/null +++ b/venv/include/site/python3.12/pygame/mask.h @@ -0,0 +1,7 @@ +#ifndef PGMASK_INTERNAL_H +#define PGMASK_INTERNAL_H + +#include "include/pygame_mask.h" +#define PYGAMEAPI_MASK_NUMSLOTS 1 + +#endif /* ~PGMASK_INTERNAL_H */ diff --git a/venv/include/site/python3.12/pygame/mixer.h b/venv/include/site/python3.12/pygame/mixer.h new file mode 100644 index 00000000..97f5a0f1 --- /dev/null +++ b/venv/include/site/python3.12/pygame/mixer.h @@ -0,0 +1,14 @@ +#ifndef MIXER_INTERNAL_H +#define MIXER_INTERNAL_H + +#include + +/* test mixer initializations */ +#define MIXER_INIT_CHECK() \ + if (!SDL_WasInit(SDL_INIT_AUDIO)) \ + return RAISE(pgExc_SDLError, "mixer not initialized") + +#define PYGAMEAPI_MIXER_NUMSLOTS 5 +#include "include/pygame_mixer.h" + +#endif /* ~MIXER_INTERNAL_H */ diff --git a/venv/include/site/python3.12/pygame/palette.h b/venv/include/site/python3.12/pygame/palette.h new file mode 100644 index 00000000..1ae4cf6d --- /dev/null +++ b/venv/include/site/python3.12/pygame/palette.h @@ -0,0 +1,123 @@ +/* + pygame - Python Game Library + Copyright (C) 2000-2001 Pete Shinners + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public + License along with this library; if not, write to the Free + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + + Pete Shinners + pete@shinners.org +*/ + +#ifndef PALETTE_H +#define PALETTE_H + +#include + +/* SDL 2 does not assign a default palette color scheme to a new 8 bit + * surface. Instead, the palette is set all white. This defines the SDL 1.2 + * default palette. + */ +static const SDL_Color default_palette_colors[] = { + {0, 0, 0, 255}, {0, 0, 85, 255}, {0, 0, 170, 255}, + {0, 0, 255, 255}, {0, 36, 0, 255}, {0, 36, 85, 255}, + {0, 36, 170, 255}, {0, 36, 255, 255}, {0, 73, 0, 255}, + {0, 73, 85, 255}, {0, 73, 170, 255}, {0, 73, 255, 255}, + {0, 109, 0, 255}, {0, 109, 85, 255}, {0, 109, 170, 255}, + {0, 109, 255, 255}, {0, 146, 0, 255}, {0, 146, 85, 255}, + {0, 146, 170, 255}, {0, 146, 255, 255}, {0, 182, 0, 255}, + {0, 182, 85, 255}, {0, 182, 170, 255}, {0, 182, 255, 255}, + {0, 219, 0, 255}, {0, 219, 85, 255}, {0, 219, 170, 255}, + {0, 219, 255, 255}, {0, 255, 0, 255}, {0, 255, 85, 255}, + {0, 255, 170, 255}, {0, 255, 255, 255}, {85, 0, 0, 255}, + {85, 0, 85, 255}, {85, 0, 170, 255}, {85, 0, 255, 255}, + {85, 36, 0, 255}, {85, 36, 85, 255}, {85, 36, 170, 255}, + {85, 36, 255, 255}, {85, 73, 0, 255}, {85, 73, 85, 255}, + {85, 73, 170, 255}, {85, 73, 255, 255}, {85, 109, 0, 255}, + {85, 109, 85, 255}, {85, 109, 170, 255}, {85, 109, 255, 255}, + {85, 146, 0, 255}, {85, 146, 85, 255}, {85, 146, 170, 255}, + {85, 146, 255, 255}, {85, 182, 0, 255}, {85, 182, 85, 255}, + {85, 182, 170, 255}, {85, 182, 255, 255}, {85, 219, 0, 255}, + {85, 219, 85, 255}, {85, 219, 170, 255}, {85, 219, 255, 255}, + {85, 255, 0, 255}, {85, 255, 85, 255}, {85, 255, 170, 255}, + {85, 255, 255, 255}, {170, 0, 0, 255}, {170, 0, 85, 255}, + {170, 0, 170, 255}, {170, 0, 255, 255}, {170, 36, 0, 255}, + {170, 36, 85, 255}, {170, 36, 170, 255}, {170, 36, 255, 255}, + {170, 73, 0, 255}, {170, 73, 85, 255}, {170, 73, 170, 255}, + {170, 73, 255, 255}, {170, 109, 0, 255}, {170, 109, 85, 255}, + {170, 109, 170, 255}, {170, 109, 255, 255}, {170, 146, 0, 255}, + {170, 146, 85, 255}, {170, 146, 170, 255}, {170, 146, 255, 255}, + {170, 182, 0, 255}, {170, 182, 85, 255}, {170, 182, 170, 255}, + {170, 182, 255, 255}, {170, 219, 0, 255}, {170, 219, 85, 255}, + {170, 219, 170, 255}, {170, 219, 255, 255}, {170, 255, 0, 255}, + {170, 255, 85, 255}, {170, 255, 170, 255}, {170, 255, 255, 255}, + {255, 0, 0, 255}, {255, 0, 85, 255}, {255, 0, 170, 255}, + {255, 0, 255, 255}, {255, 36, 0, 255}, {255, 36, 85, 255}, + {255, 36, 170, 255}, {255, 36, 255, 255}, {255, 73, 0, 255}, + {255, 73, 85, 255}, {255, 73, 170, 255}, {255, 73, 255, 255}, + {255, 109, 0, 255}, {255, 109, 85, 255}, {255, 109, 170, 255}, + {255, 109, 255, 255}, {255, 146, 0, 255}, {255, 146, 85, 255}, + {255, 146, 170, 255}, {255, 146, 255, 255}, {255, 182, 0, 255}, + {255, 182, 85, 255}, {255, 182, 170, 255}, {255, 182, 255, 255}, + {255, 219, 0, 255}, {255, 219, 85, 255}, {255, 219, 170, 255}, + {255, 219, 255, 255}, {255, 255, 0, 255}, {255, 255, 85, 255}, + {255, 255, 170, 255}, {255, 255, 255, 255}, {0, 0, 0, 255}, + {0, 0, 85, 255}, {0, 0, 170, 255}, {0, 0, 255, 255}, + {0, 36, 0, 255}, {0, 36, 85, 255}, {0, 36, 170, 255}, + {0, 36, 255, 255}, {0, 73, 0, 255}, {0, 73, 85, 255}, + {0, 73, 170, 255}, {0, 73, 255, 255}, {0, 109, 0, 255}, + {0, 109, 85, 255}, {0, 109, 170, 255}, {0, 109, 255, 255}, + {0, 146, 0, 255}, {0, 146, 85, 255}, {0, 146, 170, 255}, + {0, 146, 255, 255}, {0, 182, 0, 255}, {0, 182, 85, 255}, + {0, 182, 170, 255}, {0, 182, 255, 255}, {0, 219, 0, 255}, + {0, 219, 85, 255}, {0, 219, 170, 255}, {0, 219, 255, 255}, + {0, 255, 0, 255}, {0, 255, 85, 255}, {0, 255, 170, 255}, + {0, 255, 255, 255}, {85, 0, 0, 255}, {85, 0, 85, 255}, + {85, 0, 170, 255}, {85, 0, 255, 255}, {85, 36, 0, 255}, + {85, 36, 85, 255}, {85, 36, 170, 255}, {85, 36, 255, 255}, + {85, 73, 0, 255}, {85, 73, 85, 255}, {85, 73, 170, 255}, + {85, 73, 255, 255}, {85, 109, 0, 255}, {85, 109, 85, 255}, + {85, 109, 170, 255}, {85, 109, 255, 255}, {85, 146, 0, 255}, + {85, 146, 85, 255}, {85, 146, 170, 255}, {85, 146, 255, 255}, + {85, 182, 0, 255}, {85, 182, 85, 255}, {85, 182, 170, 255}, + {85, 182, 255, 255}, {85, 219, 0, 255}, {85, 219, 85, 255}, + {85, 219, 170, 255}, {85, 219, 255, 255}, {85, 255, 0, 255}, + {85, 255, 85, 255}, {85, 255, 170, 255}, {85, 255, 255, 255}, + {170, 0, 0, 255}, {170, 0, 85, 255}, {170, 0, 170, 255}, + {170, 0, 255, 255}, {170, 36, 0, 255}, {170, 36, 85, 255}, + {170, 36, 170, 255}, {170, 36, 255, 255}, {170, 73, 0, 255}, + {170, 73, 85, 255}, {170, 73, 170, 255}, {170, 73, 255, 255}, + {170, 109, 0, 255}, {170, 109, 85, 255}, {170, 109, 170, 255}, + {170, 109, 255, 255}, {170, 146, 0, 255}, {170, 146, 85, 255}, + {170, 146, 170, 255}, {170, 146, 255, 255}, {170, 182, 0, 255}, + {170, 182, 85, 255}, {170, 182, 170, 255}, {170, 182, 255, 255}, + {170, 219, 0, 255}, {170, 219, 85, 255}, {170, 219, 170, 255}, + {170, 219, 255, 255}, {170, 255, 0, 255}, {170, 255, 85, 255}, + {170, 255, 170, 255}, {170, 255, 255, 255}, {255, 0, 0, 255}, + {255, 0, 85, 255}, {255, 0, 170, 255}, {255, 0, 255, 255}, + {255, 36, 0, 255}, {255, 36, 85, 255}, {255, 36, 170, 255}, + {255, 36, 255, 255}, {255, 73, 0, 255}, {255, 73, 85, 255}, + {255, 73, 170, 255}, {255, 73, 255, 255}, {255, 109, 0, 255}, + {255, 109, 85, 255}, {255, 109, 170, 255}, {255, 109, 255, 255}, + {255, 146, 0, 255}, {255, 146, 85, 255}, {255, 146, 170, 255}, + {255, 146, 255, 255}, {255, 182, 0, 255}, {255, 182, 85, 255}, + {255, 182, 170, 255}, {255, 182, 255, 255}, {255, 219, 0, 255}, + {255, 219, 85, 255}, {255, 219, 170, 255}, {255, 219, 255, 255}, + {255, 255, 0, 255}, {255, 255, 85, 255}, {255, 255, 170, 255}, + {255, 255, 255, 255}}; + +static const int default_palette_size = + (int)(sizeof(default_palette_colors) / sizeof(SDL_Color)); + +#endif diff --git a/venv/include/site/python3.12/pygame/pgarrinter.h b/venv/include/site/python3.12/pygame/pgarrinter.h new file mode 100644 index 00000000..5ba096be --- /dev/null +++ b/venv/include/site/python3.12/pygame/pgarrinter.h @@ -0,0 +1,26 @@ +/* array structure interface version 3 declarations */ + +#if !defined(PG_ARRAYINTER_HEADER) +#define PG_ARRAYINTER_HEADER + +static const int PAI_CONTIGUOUS = 0x01; +static const int PAI_FORTRAN = 0x02; +static const int PAI_ALIGNED = 0x100; +static const int PAI_NOTSWAPPED = 0x200; +static const int PAI_WRITEABLE = 0x400; +static const int PAI_ARR_HAS_DESCR = 0x800; + +typedef struct { + int two; /* contains the integer 2 -- simple sanity check */ + int nd; /* number of dimensions */ + char typekind; /* kind in array -- character code of typestr */ + int itemsize; /* size of each element */ + int flags; /* flags indicating how the data should be */ + /* interpreted */ + Py_intptr_t *shape; /* A length-nd array of shape information */ + Py_intptr_t *strides; /* A length-nd array of stride information */ + void *data; /* A pointer to the first element of the array */ + PyObject *descr; /* NULL or a data-description */ +} PyArrayInterface; + +#endif diff --git a/venv/include/site/python3.12/pygame/pgbufferproxy.h b/venv/include/site/python3.12/pygame/pgbufferproxy.h new file mode 100644 index 00000000..15076086 --- /dev/null +++ b/venv/include/site/python3.12/pygame/pgbufferproxy.h @@ -0,0 +1,7 @@ +#ifndef PG_BUFPROXY_INTERNAL_H +#define PG_BUFPROXY_INTERNAL_H + +#include "include/pygame_bufferproxy.h" +#define PYGAMEAPI_BUFPROXY_NUMSLOTS 4 + +#endif /* ~PG_BUFPROXY_INTERNAL_H */ diff --git a/venv/include/site/python3.12/pygame/pgcompat.h b/venv/include/site/python3.12/pygame/pgcompat.h new file mode 100644 index 00000000..1bc0d247 --- /dev/null +++ b/venv/include/site/python3.12/pygame/pgcompat.h @@ -0,0 +1,27 @@ +/* Python 2.x/3.x compatibility tools (internal) + */ +#ifndef PGCOMPAT_INTERNAL_H +#define PGCOMPAT_INTERNAL_H + +#include "include/pgcompat.h" + +/* Module init function returns new module instance. */ +#define MODINIT_DEFINE(mod_name) PyMODINIT_FUNC PyInit_##mod_name(void) + +/* Defaults for unicode file path encoding */ +#if defined(MS_WIN32) +#define UNICODE_DEF_FS_ERROR "replace" +#else +#define UNICODE_DEF_FS_ERROR "surrogateescape" +#endif + +#define RELATIVE_MODULE(m) ("." m) + +#ifndef Py_TPFLAGS_HAVE_NEWBUFFER +#define Py_TPFLAGS_HAVE_NEWBUFFER 0 +#endif + +#define Slice_GET_INDICES_EX(slice, length, start, stop, step, slicelength) \ + PySlice_GetIndicesEx(slice, length, start, stop, step, slicelength) + +#endif /* ~PGCOMPAT_INTERNAL_H */ diff --git a/venv/include/site/python3.12/pygame/pgopengl.h b/venv/include/site/python3.12/pygame/pgopengl.h new file mode 100644 index 00000000..a845cbf2 --- /dev/null +++ b/venv/include/site/python3.12/pygame/pgopengl.h @@ -0,0 +1,20 @@ +#if !defined(PGOPENGL_H) +#define PGOPENGL_H + +/** This header includes definitions of Opengl functions as pointer types for + ** use with the SDL function SDL_GL_GetProcAddress. + **/ + +#if defined(_WIN32) +#define GL_APIENTRY __stdcall +#else +#define GL_APIENTRY +#endif + +typedef void(GL_APIENTRY *GL_glReadPixels_Func)(int, int, int, int, + unsigned int, unsigned int, + void *); + +typedef void(GL_APIENTRY *GL_glViewport_Func)(int, int, unsigned int, + unsigned int); +#endif diff --git a/venv/include/site/python3.12/pygame/pgplatform.h b/venv/include/site/python3.12/pygame/pgplatform.h new file mode 100644 index 00000000..54310eb6 --- /dev/null +++ b/venv/include/site/python3.12/pygame/pgplatform.h @@ -0,0 +1,23 @@ +/* platform/compiler adjustments (internal) */ +#ifndef PG_PLATFORM_INTERNAL_H +#define PG_PLATFORM_INTERNAL_H + +#include "include/pgplatform.h" + +#ifndef MIN +#define MIN(a, b) ((a) < (b) ? (a) : (b)) +#endif +#ifndef MAX +#define MAX(a, b) ((a) > (b) ? (a) : (b)) +#endif +#ifndef ABS +#define ABS(a) (((a) < 0) ? -(a) : (a)) +#endif + +/* warnings */ +#define PG_STRINGIZE_HELPER(x) #x +#define PG_STRINGIZE(x) PG_STRINGIZE_HELPER(x) +#define PG_WARN(desc) \ + message(__FILE__ "(" PG_STRINGIZE(__LINE__) "): WARNING: " #desc) + +#endif /* ~PG_PLATFORM_INTERNAL_H */ diff --git a/venv/include/site/python3.12/pygame/pygame.h b/venv/include/site/python3.12/pygame/pygame.h new file mode 100644 index 00000000..d7eaf739 --- /dev/null +++ b/venv/include/site/python3.12/pygame/pygame.h @@ -0,0 +1,32 @@ +/* + pygame - Python Game Library + Copyright (C) 2000-2001 Pete Shinners + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public + License along with this library; if not, write to the Free + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + + Pete Shinners + pete@shinners.org +*/ + +/* This will use PYGAMEAPI_DEFINE_SLOTS instead + * of PYGAMEAPI_EXTERN_SLOTS for base modules. + */ +#ifndef PYGAME_INTERNAL_H +#define PYGAME_INTERNAL_H + +#define PYGAME_H +#include "_pygame.h" + +#endif /* ~PYGAME_INTERNAL_H */ diff --git a/venv/include/site/python3.12/pygame/scrap.h b/venv/include/site/python3.12/pygame/scrap.h new file mode 100644 index 00000000..5866b568 --- /dev/null +++ b/venv/include/site/python3.12/pygame/scrap.h @@ -0,0 +1,147 @@ +/* + pygame - Python Game Library + Copyright (C) 2006, 2007 Rene Dudfield, Marcus von Appen + + Originally put in the public domain by Sam Lantinga. + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public + License along with this library; if not, write to the Free + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +*/ + +#ifndef SCRAP_H +#define SCRAP_H + +/* This is unconditionally defined in Python.h */ +#if defined(_POSIX_C_SOURCE) +#undef _POSIX_C_SOURCE +#endif + +#include + +/* Handle clipboard text and data in arbitrary formats */ + +/** + * Predefined supported pygame scrap types. + */ +#define PYGAME_SCRAP_TEXT "text/plain" +#define PYGAME_SCRAP_BMP "image/bmp" +#define PYGAME_SCRAP_PPM "image/ppm" +#define PYGAME_SCRAP_PBM "image/pbm" + +/** + * The supported scrap clipboard types. + * + * This is only relevant in a X11 environment, which supports mouse + * selections as well. For Win32 and MacOS environments the default + * clipboard is used, no matter what value is passed. + */ +typedef enum { + SCRAP_CLIPBOARD, + SCRAP_SELECTION /* only supported in X11 environments. */ +} ScrapClipType; + +/** + * Macro for initialization checks. + */ +#define PYGAME_SCRAP_INIT_CHECK() \ + if (!pygame_scrap_initialized()) \ + return (PyErr_SetString(pgExc_SDLError, "scrap system not initialized."), \ + NULL) + +/** + * \brief Checks, whether the pygame scrap module was initialized. + * + * \return 1 if the modules was initialized, 0 otherwise. + */ +extern int +pygame_scrap_initialized(void); + +/** + * \brief Initializes the pygame scrap module internals. Call this before any + * other method. + * + * \return 1 on successful initialization, 0 otherwise. + */ +extern int +pygame_scrap_init(void); + +/** + * \brief Checks, whether the pygame window lost the clipboard focus or not. + * + * \return 1 if the window lost the focus, 0 otherwise. + */ +extern int +pygame_scrap_lost(void); + +/** + * \brief Places content of a specific type into the clipboard. + * + * \note For X11 the following notes are important: The following types + * are reserved for internal usage and thus will throw an error on + * setting them: "TIMESTAMP", "TARGETS", "SDL_SELECTION". + * Setting PYGAME_SCRAP_TEXT ("text/plain") will also automatically + * set the X11 types "STRING" (XA_STRING), "TEXT" and "UTF8_STRING". + * + * For Win32 the following notes are important: Setting + * PYGAME_SCRAP_TEXT ("text/plain") will also automatically set + * the Win32 type "TEXT" (CF_TEXT). + * + * For QNX the following notes are important: Setting + * PYGAME_SCRAP_TEXT ("text/plain") will also automatically set + * the QNX type "TEXT" (Ph_CL_TEXT). + * + * \param type The type of the content. + * \param srclen The length of the content. + * \param src The NULL terminated content. + * \return 1, if the content could be successfully pasted into the clipboard, + * 0 otherwise. + */ +extern int +pygame_scrap_put(char *type, Py_ssize_t srclen, char *src); + +/** + * \brief Gets the current content from the clipboard. + * + * \note The received content does not need to be the content previously + * placed in the clipboard using pygame_put_scrap(). See the + * pygame_put_scrap() notes for more details. + * + * \param type The type of the content to receive. + * \param count The size of the returned content. + * \return The content or NULL in case of an error or if no content of the + * specified type was available. + */ +extern char * +pygame_scrap_get(char *type, size_t *count); + +/** + * \brief Gets the currently available content types from the clipboard. + * + * \return The different available content types or NULL in case of an + * error or if no content type is available. + */ +extern char ** +pygame_scrap_get_types(void); + +/** + * \brief Checks whether content for the specified scrap type is currently + * available in the clipboard. + * + * \param type The type to check for. + * \return 1, if there is content and 0 otherwise. + */ +extern int +pygame_scrap_contains(char *type); + +#endif /* SCRAP_H */ diff --git a/venv/include/site/python3.12/pygame/simd_blitters.h b/venv/include/site/python3.12/pygame/simd_blitters.h new file mode 100644 index 00000000..da0ecbb2 --- /dev/null +++ b/venv/include/site/python3.12/pygame/simd_blitters.h @@ -0,0 +1,84 @@ +#define NO_PYGAME_C_API +#include "_surface.h" +#include "_blit_info.h" + +#if !defined(PG_ENABLE_ARM_NEON) && defined(__aarch64__) +// arm64 has neon optimisations enabled by default, even when fpu=neon is not +// passed +#define PG_ENABLE_ARM_NEON 1 +#endif + +int +pg_sse2_at_runtime_but_uncompiled(); +int +pg_neon_at_runtime_but_uncompiled(); +int +pg_avx2_at_runtime_but_uncompiled(); + +#if (defined(__SSE2__) || defined(PG_ENABLE_ARM_NEON)) +void +alphablit_alpha_sse2_argb_surf_alpha(SDL_BlitInfo *info); +void +alphablit_alpha_sse2_argb_no_surf_alpha(SDL_BlitInfo *info); +void +alphablit_alpha_sse2_argb_no_surf_alpha_opaque_dst(SDL_BlitInfo *info); +void +blit_blend_rgba_mul_sse2(SDL_BlitInfo *info); +void +blit_blend_rgb_mul_sse2(SDL_BlitInfo *info); +void +blit_blend_rgba_add_sse2(SDL_BlitInfo *info); +void +blit_blend_rgb_add_sse2(SDL_BlitInfo *info); +void +blit_blend_rgba_sub_sse2(SDL_BlitInfo *info); +void +blit_blend_rgb_sub_sse2(SDL_BlitInfo *info); +void +blit_blend_rgba_max_sse2(SDL_BlitInfo *info); +void +blit_blend_rgb_max_sse2(SDL_BlitInfo *info); +void +blit_blend_rgba_min_sse2(SDL_BlitInfo *info); +void +blit_blend_rgb_min_sse2(SDL_BlitInfo *info); +void +blit_blend_premultiplied_sse2(SDL_BlitInfo *info); +#endif /* (defined(__SSE2__) || defined(PG_ENABLE_ARM_NEON)) */ + +/* Deliberately putting these outside of the preprocessor guards as I want to + move to a system of trusting the runtime checks to head to the right + function and having a fallback function there if pygame is not compiled + with the right stuff (this is the strategy used for AVX2 right now. + Potentially I might want to shift both these into a slightly different + file as they are not exactly blits (though v. similar) - or I could rename + the SIMD trilogy of files to replace the word blit with something more + generic like surface_ops*/ + +void +premul_surf_color_by_alpha_non_simd(SDL_Surface *src, SDL_Surface *dst); +void +premul_surf_color_by_alpha_sse2(SDL_Surface *src, SDL_Surface *dst); + +int +pg_has_avx2(); +void +blit_blend_rgba_mul_avx2(SDL_BlitInfo *info); +void +blit_blend_rgb_mul_avx2(SDL_BlitInfo *info); +void +blit_blend_rgba_add_avx2(SDL_BlitInfo *info); +void +blit_blend_rgb_add_avx2(SDL_BlitInfo *info); +void +blit_blend_rgba_sub_avx2(SDL_BlitInfo *info); +void +blit_blend_rgb_sub_avx2(SDL_BlitInfo *info); +void +blit_blend_rgba_max_avx2(SDL_BlitInfo *info); +void +blit_blend_rgb_max_avx2(SDL_BlitInfo *info); +void +blit_blend_rgba_min_avx2(SDL_BlitInfo *info); +void +blit_blend_rgb_min_avx2(SDL_BlitInfo *info); diff --git a/venv/include/site/python3.12/pygame/surface.h b/venv/include/site/python3.12/pygame/surface.h new file mode 100644 index 00000000..21508c63 --- /dev/null +++ b/venv/include/site/python3.12/pygame/surface.h @@ -0,0 +1,361 @@ +/* + pygame - Python Game Library + Copyright (C) 2000-2001 Pete Shinners + Copyright (C) 2007 Marcus von Appen + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public + License along with this library; if not, write to the Free + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + + Pete Shinners + pete@shinners.org +*/ + +#ifndef SURFACE_H +#define SURFACE_H + +/* This is defined in SDL.h */ +#if defined(_POSIX_C_SOURCE) +#undef _POSIX_C_SOURCE +#endif + +#include +#include "pygame.h" + +/* Blend modes */ +#define PYGAME_BLEND_ADD 0x1 +#define PYGAME_BLEND_SUB 0x2 +#define PYGAME_BLEND_MULT 0x3 +#define PYGAME_BLEND_MIN 0x4 +#define PYGAME_BLEND_MAX 0x5 + +#define PYGAME_BLEND_RGB_ADD 0x1 +#define PYGAME_BLEND_RGB_SUB 0x2 +#define PYGAME_BLEND_RGB_MULT 0x3 +#define PYGAME_BLEND_RGB_MIN 0x4 +#define PYGAME_BLEND_RGB_MAX 0x5 + +#define PYGAME_BLEND_RGBA_ADD 0x6 +#define PYGAME_BLEND_RGBA_SUB 0x7 +#define PYGAME_BLEND_RGBA_MULT 0x8 +#define PYGAME_BLEND_RGBA_MIN 0x9 +#define PYGAME_BLEND_RGBA_MAX 0x10 +#define PYGAME_BLEND_PREMULTIPLIED 0x11 +#define PYGAME_BLEND_ALPHA_SDL2 0x12 + +#if SDL_BYTEORDER == SDL_LIL_ENDIAN +#define GET_PIXEL_24(b) (b[0] + (b[1] << 8) + (b[2] << 16)) +#else +#define GET_PIXEL_24(b) (b[2] + (b[1] << 8) + (b[0] << 16)) +#endif + +#define GET_PIXEL(pxl, bpp, source) \ + switch (bpp) { \ + case 2: \ + pxl = *((Uint16 *)(source)); \ + break; \ + case 4: \ + pxl = *((Uint32 *)(source)); \ + break; \ + default: { \ + Uint8 *b = (Uint8 *)source; \ + pxl = GET_PIXEL_24(b); \ + } break; \ + } + +#define GET_PIXELVALS(_sR, _sG, _sB, _sA, px, fmt, ppa) \ + SDL_GetRGBA(px, fmt, &(_sR), &(_sG), &(_sB), &(_sA)); \ + if (!ppa) { \ + _sA = 255; \ + } + +#define GET_PIXELVALS_1(sr, sg, sb, sa, _src, _fmt) \ + sr = _fmt->palette->colors[*((Uint8 *)(_src))].r; \ + sg = _fmt->palette->colors[*((Uint8 *)(_src))].g; \ + sb = _fmt->palette->colors[*((Uint8 *)(_src))].b; \ + sa = 255; + +/* For 1 byte palette pixels */ +#define SET_PIXELVAL(px, fmt, _dR, _dG, _dB, _dA) \ + *(px) = (Uint8)SDL_MapRGBA(fmt, _dR, _dG, _dB, _dA) + +#if SDL_BYTEORDER == SDL_LIL_ENDIAN +#define SET_OFFSETS_24(or, og, ob, fmt) \ + { \ + or = (fmt->Rshift == 0 ? 0 : fmt->Rshift == 8 ? 1 : 2); \ + og = (fmt->Gshift == 0 ? 0 : fmt->Gshift == 8 ? 1 : 2); \ + ob = (fmt->Bshift == 0 ? 0 : fmt->Bshift == 8 ? 1 : 2); \ + } + +#define SET_OFFSETS_32(or, og, ob, fmt) \ + { \ + or = (fmt->Rshift == 0 ? 0 \ + : fmt->Rshift == 8 ? 1 \ + : fmt->Rshift == 16 ? 2 \ + : 3); \ + og = (fmt->Gshift == 0 ? 0 \ + : fmt->Gshift == 8 ? 1 \ + : fmt->Gshift == 16 ? 2 \ + : 3); \ + ob = (fmt->Bshift == 0 ? 0 \ + : fmt->Bshift == 8 ? 1 \ + : fmt->Bshift == 16 ? 2 \ + : 3); \ + } +#else +#define SET_OFFSETS_24(or, og, ob, fmt) \ + { \ + or = (fmt->Rshift == 0 ? 2 : fmt->Rshift == 8 ? 1 : 0); \ + og = (fmt->Gshift == 0 ? 2 : fmt->Gshift == 8 ? 1 : 0); \ + ob = (fmt->Bshift == 0 ? 2 : fmt->Bshift == 8 ? 1 : 0); \ + } + +#define SET_OFFSETS_32(or, og, ob, fmt) \ + { \ + or = (fmt->Rshift == 0 ? 3 \ + : fmt->Rshift == 8 ? 2 \ + : fmt->Rshift == 16 ? 1 \ + : 0); \ + og = (fmt->Gshift == 0 ? 3 \ + : fmt->Gshift == 8 ? 2 \ + : fmt->Gshift == 16 ? 1 \ + : 0); \ + ob = (fmt->Bshift == 0 ? 3 \ + : fmt->Bshift == 8 ? 2 \ + : fmt->Bshift == 16 ? 1 \ + : 0); \ + } +#endif + +#define CREATE_PIXEL(buf, r, g, b, a, bp, ft) \ + switch (bp) { \ + case 2: \ + *((Uint16 *)(buf)) = ((r >> ft->Rloss) << ft->Rshift) | \ + ((g >> ft->Gloss) << ft->Gshift) | \ + ((b >> ft->Bloss) << ft->Bshift) | \ + ((a >> ft->Aloss) << ft->Ashift); \ + break; \ + case 4: \ + *((Uint32 *)(buf)) = ((r >> ft->Rloss) << ft->Rshift) | \ + ((g >> ft->Gloss) << ft->Gshift) | \ + ((b >> ft->Bloss) << ft->Bshift) | \ + ((a >> ft->Aloss) << ft->Ashift); \ + break; \ + } + +/* Pretty good idea from Tom Duff :-). */ +#define LOOP_UNROLLED4(code, n, width) \ + n = (width + 3) / 4; \ + switch (width & 3) { \ + case 0: \ + do { \ + code; \ + case 3: \ + code; \ + case 2: \ + code; \ + case 1: \ + code; \ + } while (--n > 0); \ + } + +/* Used in the srcbpp == dstbpp == 1 blend functions */ +#define REPEAT_3(code) \ + code; \ + code; \ + code; + +#define REPEAT_4(code) \ + code; \ + code; \ + code; \ + code; + +#define BLEND_ADD(tmp, sR, sG, sB, sA, dR, dG, dB, dA) \ + tmp = dR + sR; \ + dR = (tmp <= 255 ? tmp : 255); \ + tmp = dG + sG; \ + dG = (tmp <= 255 ? tmp : 255); \ + tmp = dB + sB; \ + dB = (tmp <= 255 ? tmp : 255); + +#define BLEND_SUB(tmp, sR, sG, sB, sA, dR, dG, dB, dA) \ + tmp = dR - sR; \ + dR = (tmp >= 0 ? tmp : 0); \ + tmp = dG - sG; \ + dG = (tmp >= 0 ? tmp : 0); \ + tmp = dB - sB; \ + dB = (tmp >= 0 ? tmp : 0); + +#define BLEND_MULT(sR, sG, sB, sA, dR, dG, dB, dA) \ + dR = (dR && sR) ? ((dR * sR) + 255) >> 8 : 0; \ + dG = (dG && sG) ? ((dG * sG) + 255) >> 8 : 0; \ + dB = (dB && sB) ? ((dB * sB) + 255) >> 8 : 0; + +#define BLEND_MIN(sR, sG, sB, sA, dR, dG, dB, dA) \ + if (sR < dR) { \ + dR = sR; \ + } \ + if (sG < dG) { \ + dG = sG; \ + } \ + if (sB < dB) { \ + dB = sB; \ + } + +#define BLEND_MAX(sR, sG, sB, sA, dR, dG, dB, dA) \ + if (sR > dR) { \ + dR = sR; \ + } \ + if (sG > dG) { \ + dG = sG; \ + } \ + if (sB > dB) { \ + dB = sB; \ + } + +#define BLEND_RGBA_ADD(tmp, sR, sG, sB, sA, dR, dG, dB, dA) \ + tmp = dR + sR; \ + dR = (tmp <= 255 ? tmp : 255); \ + tmp = dG + sG; \ + dG = (tmp <= 255 ? tmp : 255); \ + tmp = dB + sB; \ + dB = (tmp <= 255 ? tmp : 255); \ + tmp = dA + sA; \ + dA = (tmp <= 255 ? tmp : 255); + +#define BLEND_RGBA_SUB(tmp, sR, sG, sB, sA, dR, dG, dB, dA) \ + tmp = dR - sR; \ + dR = (tmp >= 0 ? tmp : 0); \ + tmp = dG - sG; \ + dG = (tmp >= 0 ? tmp : 0); \ + tmp = dB - sB; \ + dB = (tmp >= 0 ? tmp : 0); \ + tmp = dA - sA; \ + dA = (tmp >= 0 ? tmp : 0); + +#define BLEND_RGBA_MULT(sR, sG, sB, sA, dR, dG, dB, dA) \ + dR = (dR && sR) ? ((dR * sR) + 255) >> 8 : 0; \ + dG = (dG && sG) ? ((dG * sG) + 255) >> 8 : 0; \ + dB = (dB && sB) ? ((dB * sB) + 255) >> 8 : 0; \ + dA = (dA && sA) ? ((dA * sA) + 255) >> 8 : 0; + +#define BLEND_RGBA_MIN(sR, sG, sB, sA, dR, dG, dB, dA) \ + if (sR < dR) { \ + dR = sR; \ + } \ + if (sG < dG) { \ + dG = sG; \ + } \ + if (sB < dB) { \ + dB = sB; \ + } \ + if (sA < dA) { \ + dA = sA; \ + } + +#define BLEND_RGBA_MAX(sR, sG, sB, sA, dR, dG, dB, dA) \ + if (sR > dR) { \ + dR = sR; \ + } \ + if (sG > dG) { \ + dG = sG; \ + } \ + if (sB > dB) { \ + dB = sB; \ + } \ + if (sA > dA) { \ + dA = sA; \ + } + +#if 1 +/* Choose an alpha blend equation. If the sign is preserved on a right shift + * then use a specialized, faster, equation. Otherwise a more general form, + * where all additions are done before the shift, is needed. + */ +#if (-1 >> 1) < 0 +#define ALPHA_BLEND_COMP(sC, dC, sA) ((((sC - dC) * sA + sC) >> 8) + dC) +#else +#define ALPHA_BLEND_COMP(sC, dC, sA) (((dC << 8) + (sC - dC) * sA + sC) >> 8) +#endif + +#define ALPHA_BLEND(sR, sG, sB, sA, dR, dG, dB, dA) \ + do { \ + if (dA) { \ + dR = ALPHA_BLEND_COMP(sR, dR, sA); \ + dG = ALPHA_BLEND_COMP(sG, dG, sA); \ + dB = ALPHA_BLEND_COMP(sB, dB, sA); \ + dA = sA + dA - ((sA * dA) / 255); \ + } \ + else { \ + dR = sR; \ + dG = sG; \ + dB = sB; \ + dA = sA; \ + } \ + } while (0) + +#define ALPHA_BLEND_PREMULTIPLIED_COMP(sC, dC, sA) \ + (sC + dC - ((dC + 1) * sA >> 8)) + +#define ALPHA_BLEND_PREMULTIPLIED(tmp, sR, sG, sB, sA, dR, dG, dB, dA) \ + do { \ + dR = ALPHA_BLEND_PREMULTIPLIED_COMP(sR, dR, sA); \ + dG = ALPHA_BLEND_PREMULTIPLIED_COMP(sG, dG, sA); \ + dB = ALPHA_BLEND_PREMULTIPLIED_COMP(sB, dB, sA); \ + dA = ALPHA_BLEND_PREMULTIPLIED_COMP(sA, dA, sA); \ + } while (0) +#elif 0 + +#define ALPHA_BLEND(sR, sG, sB, sA, dR, dG, dB, dA) \ + do { \ + if (sA) { \ + if (dA && sA < 255) { \ + int dContrib = dA * (255 - sA) / 255; \ + dA = sA + dA - ((sA * dA) / 255); \ + dR = (dR * dContrib + sR * sA) / dA; \ + dG = (dG * dContrib + sG * sA) / dA; \ + dB = (dB * dContrib + sB * sA) / dA; \ + } \ + else { \ + dR = sR; \ + dG = sG; \ + dB = sB; \ + dA = sA; \ + } \ + } \ + } while (0) +#endif + +int +surface_fill_blend(SDL_Surface *surface, SDL_Rect *rect, Uint32 color, + int blendargs); + +void +surface_respect_clip_rect(SDL_Surface *surface, SDL_Rect *rect); + +int +pygame_AlphaBlit(SDL_Surface *src, SDL_Rect *srcrect, SDL_Surface *dst, + SDL_Rect *dstrect, int the_args); + +int +pygame_Blit(SDL_Surface *src, SDL_Rect *srcrect, SDL_Surface *dst, + SDL_Rect *dstrect, int the_args); + +int +premul_surf_color_by_alpha(SDL_Surface *src, SDL_Surface *dst); + +int +pg_warn_simd_at_runtime_but_uncompiled(); + +#endif /* SURFACE_H */ diff --git a/venv/lib/python3.12/site-packages/OpenGL/AGL/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/AGL/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/venv/lib/python3.12/site-packages/OpenGL/AGL/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/AGL/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..232bbbe6 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/AGL/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/ANDROID/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/EGL/ANDROID/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/EGL/ANDROID/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/ANDROID/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/EGL/ANDROID/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..05a3a7e5 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/EGL/ANDROID/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/ANDROID/__pycache__/blob_cache.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/EGL/ANDROID/__pycache__/blob_cache.cpython-312.pyc new file mode 100644 index 00000000..8d289dca Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/EGL/ANDROID/__pycache__/blob_cache.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/ANDROID/__pycache__/framebuffer_target.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/EGL/ANDROID/__pycache__/framebuffer_target.cpython-312.pyc new file mode 100644 index 00000000..a86ccb1b Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/EGL/ANDROID/__pycache__/framebuffer_target.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/ANDROID/__pycache__/image_native_buffer.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/EGL/ANDROID/__pycache__/image_native_buffer.cpython-312.pyc new file mode 100644 index 00000000..7e6e5b07 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/EGL/ANDROID/__pycache__/image_native_buffer.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/ANDROID/__pycache__/native_fence_sync.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/EGL/ANDROID/__pycache__/native_fence_sync.cpython-312.pyc new file mode 100644 index 00000000..3ef47463 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/EGL/ANDROID/__pycache__/native_fence_sync.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/ANDROID/__pycache__/recordable.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/EGL/ANDROID/__pycache__/recordable.cpython-312.pyc new file mode 100644 index 00000000..0d5aa2ea Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/EGL/ANDROID/__pycache__/recordable.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/ANDROID/blob_cache.py b/venv/lib/python3.12/site-packages/OpenGL/EGL/ANDROID/blob_cache.py new file mode 100644 index 00000000..f3e65dfc --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/EGL/ANDROID/blob_cache.py @@ -0,0 +1,23 @@ +'''OpenGL extension ANDROID.blob_cache + +This module customises the behaviour of the +OpenGL.raw.EGL.ANDROID.blob_cache to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ANDROID/blob_cache.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.EGL import _types, _glgets +from OpenGL.raw.EGL.ANDROID.blob_cache import * +from OpenGL.raw.EGL.ANDROID.blob_cache import _EXTENSION_NAME + +def glInitBlobCacheANDROID(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/ANDROID/framebuffer_target.py b/venv/lib/python3.12/site-packages/OpenGL/EGL/ANDROID/framebuffer_target.py new file mode 100644 index 00000000..aa3f5d35 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/EGL/ANDROID/framebuffer_target.py @@ -0,0 +1,23 @@ +'''OpenGL extension ANDROID.framebuffer_target + +This module customises the behaviour of the +OpenGL.raw.EGL.ANDROID.framebuffer_target to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ANDROID/framebuffer_target.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.EGL import _types, _glgets +from OpenGL.raw.EGL.ANDROID.framebuffer_target import * +from OpenGL.raw.EGL.ANDROID.framebuffer_target import _EXTENSION_NAME + +def glInitFramebufferTargetANDROID(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/ANDROID/image_native_buffer.py b/venv/lib/python3.12/site-packages/OpenGL/EGL/ANDROID/image_native_buffer.py new file mode 100644 index 00000000..d7849d66 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/EGL/ANDROID/image_native_buffer.py @@ -0,0 +1,23 @@ +'''OpenGL extension ANDROID.image_native_buffer + +This module customises the behaviour of the +OpenGL.raw.EGL.ANDROID.image_native_buffer to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ANDROID/image_native_buffer.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.EGL import _types, _glgets +from OpenGL.raw.EGL.ANDROID.image_native_buffer import * +from OpenGL.raw.EGL.ANDROID.image_native_buffer import _EXTENSION_NAME + +def glInitImageNativeBufferANDROID(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/ANDROID/native_fence_sync.py b/venv/lib/python3.12/site-packages/OpenGL/EGL/ANDROID/native_fence_sync.py new file mode 100644 index 00000000..37cbad3b --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/EGL/ANDROID/native_fence_sync.py @@ -0,0 +1,23 @@ +'''OpenGL extension ANDROID.native_fence_sync + +This module customises the behaviour of the +OpenGL.raw.EGL.ANDROID.native_fence_sync to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ANDROID/native_fence_sync.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.EGL import _types, _glgets +from OpenGL.raw.EGL.ANDROID.native_fence_sync import * +from OpenGL.raw.EGL.ANDROID.native_fence_sync import _EXTENSION_NAME + +def glInitNativeFenceSyncANDROID(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/ANDROID/recordable.py b/venv/lib/python3.12/site-packages/OpenGL/EGL/ANDROID/recordable.py new file mode 100644 index 00000000..87ec54cc --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/EGL/ANDROID/recordable.py @@ -0,0 +1,23 @@ +'''OpenGL extension ANDROID.recordable + +This module customises the behaviour of the +OpenGL.raw.EGL.ANDROID.recordable to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ANDROID/recordable.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.EGL import _types, _glgets +from OpenGL.raw.EGL.ANDROID.recordable import * +from OpenGL.raw.EGL.ANDROID.recordable import _EXTENSION_NAME + +def glInitRecordableANDROID(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/ANGLE/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/EGL/ANGLE/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/EGL/ANGLE/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/ANGLE/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/EGL/ANGLE/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..bc5d1b5b Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/EGL/ANGLE/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/ANGLE/__pycache__/d3d_share_handle_client_buffer.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/EGL/ANGLE/__pycache__/d3d_share_handle_client_buffer.cpython-312.pyc new file mode 100644 index 00000000..c67de02b Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/EGL/ANGLE/__pycache__/d3d_share_handle_client_buffer.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/ANGLE/__pycache__/device_d3d.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/EGL/ANGLE/__pycache__/device_d3d.cpython-312.pyc new file mode 100644 index 00000000..c5d5879d Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/EGL/ANGLE/__pycache__/device_d3d.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/ANGLE/__pycache__/query_surface_pointer.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/EGL/ANGLE/__pycache__/query_surface_pointer.cpython-312.pyc new file mode 100644 index 00000000..b8d185b4 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/EGL/ANGLE/__pycache__/query_surface_pointer.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/ANGLE/__pycache__/surface_d3d_texture_2d_share_handle.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/EGL/ANGLE/__pycache__/surface_d3d_texture_2d_share_handle.cpython-312.pyc new file mode 100644 index 00000000..6be04971 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/EGL/ANGLE/__pycache__/surface_d3d_texture_2d_share_handle.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/ANGLE/__pycache__/window_fixed_size.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/EGL/ANGLE/__pycache__/window_fixed_size.cpython-312.pyc new file mode 100644 index 00000000..b78841c3 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/EGL/ANGLE/__pycache__/window_fixed_size.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/ANGLE/d3d_share_handle_client_buffer.py b/venv/lib/python3.12/site-packages/OpenGL/EGL/ANGLE/d3d_share_handle_client_buffer.py new file mode 100644 index 00000000..981726de --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/EGL/ANGLE/d3d_share_handle_client_buffer.py @@ -0,0 +1,23 @@ +'''OpenGL extension ANGLE.d3d_share_handle_client_buffer + +This module customises the behaviour of the +OpenGL.raw.EGL.ANGLE.d3d_share_handle_client_buffer to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ANGLE/d3d_share_handle_client_buffer.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.EGL import _types, _glgets +from OpenGL.raw.EGL.ANGLE.d3d_share_handle_client_buffer import * +from OpenGL.raw.EGL.ANGLE.d3d_share_handle_client_buffer import _EXTENSION_NAME + +def glInitD3DShareHandleClientBufferANGLE(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/ANGLE/device_d3d.py b/venv/lib/python3.12/site-packages/OpenGL/EGL/ANGLE/device_d3d.py new file mode 100644 index 00000000..1755f7a6 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/EGL/ANGLE/device_d3d.py @@ -0,0 +1,23 @@ +'''OpenGL extension ANGLE.device_d3d + +This module customises the behaviour of the +OpenGL.raw.EGL.ANGLE.device_d3d to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ANGLE/device_d3d.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.EGL import _types, _glgets +from OpenGL.raw.EGL.ANGLE.device_d3d import * +from OpenGL.raw.EGL.ANGLE.device_d3d import _EXTENSION_NAME + +def glInitDeviceD3DANGLE(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/ANGLE/query_surface_pointer.py b/venv/lib/python3.12/site-packages/OpenGL/EGL/ANGLE/query_surface_pointer.py new file mode 100644 index 00000000..e996b34d --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/EGL/ANGLE/query_surface_pointer.py @@ -0,0 +1,23 @@ +'''OpenGL extension ANGLE.query_surface_pointer + +This module customises the behaviour of the +OpenGL.raw.EGL.ANGLE.query_surface_pointer to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ANGLE/query_surface_pointer.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.EGL import _types, _glgets +from OpenGL.raw.EGL.ANGLE.query_surface_pointer import * +from OpenGL.raw.EGL.ANGLE.query_surface_pointer import _EXTENSION_NAME + +def glInitQuerySurfacePointerANGLE(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/ANGLE/surface_d3d_texture_2d_share_handle.py b/venv/lib/python3.12/site-packages/OpenGL/EGL/ANGLE/surface_d3d_texture_2d_share_handle.py new file mode 100644 index 00000000..1587a482 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/EGL/ANGLE/surface_d3d_texture_2d_share_handle.py @@ -0,0 +1,23 @@ +'''OpenGL extension ANGLE.surface_d3d_texture_2d_share_handle + +This module customises the behaviour of the +OpenGL.raw.EGL.ANGLE.surface_d3d_texture_2d_share_handle to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ANGLE/surface_d3d_texture_2d_share_handle.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.EGL import _types, _glgets +from OpenGL.raw.EGL.ANGLE.surface_d3d_texture_2d_share_handle import * +from OpenGL.raw.EGL.ANGLE.surface_d3d_texture_2d_share_handle import _EXTENSION_NAME + +def glInitSurfaceD3DTexture2DShareHandleANGLE(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/ANGLE/window_fixed_size.py b/venv/lib/python3.12/site-packages/OpenGL/EGL/ANGLE/window_fixed_size.py new file mode 100644 index 00000000..604f3fb0 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/EGL/ANGLE/window_fixed_size.py @@ -0,0 +1,23 @@ +'''OpenGL extension ANGLE.window_fixed_size + +This module customises the behaviour of the +OpenGL.raw.EGL.ANGLE.window_fixed_size to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ANGLE/window_fixed_size.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.EGL import _types, _glgets +from OpenGL.raw.EGL.ANGLE.window_fixed_size import * +from OpenGL.raw.EGL.ANGLE.window_fixed_size import _EXTENSION_NAME + +def glInitWindowFixedSizeANGLE(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/ARM/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/EGL/ARM/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/EGL/ARM/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/ARM/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/EGL/ARM/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..b8047561 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/EGL/ARM/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/ARM/__pycache__/pixmap_multisample_discard.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/EGL/ARM/__pycache__/pixmap_multisample_discard.cpython-312.pyc new file mode 100644 index 00000000..6623f5e2 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/EGL/ARM/__pycache__/pixmap_multisample_discard.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/ARM/pixmap_multisample_discard.py b/venv/lib/python3.12/site-packages/OpenGL/EGL/ARM/pixmap_multisample_discard.py new file mode 100644 index 00000000..771507ad --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/EGL/ARM/pixmap_multisample_discard.py @@ -0,0 +1,23 @@ +'''OpenGL extension ARM.pixmap_multisample_discard + +This module customises the behaviour of the +OpenGL.raw.EGL.ARM.pixmap_multisample_discard to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARM/pixmap_multisample_discard.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.EGL import _types, _glgets +from OpenGL.raw.EGL.ARM.pixmap_multisample_discard import * +from OpenGL.raw.EGL.ARM.pixmap_multisample_discard import _EXTENSION_NAME + +def glInitPixmapMultisampleDiscardARM(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/EXT/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/EGL/EXT/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/EGL/EXT/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/EXT/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/EGL/EXT/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..817d93c7 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/EGL/EXT/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/EXT/__pycache__/buffer_age.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/EGL/EXT/__pycache__/buffer_age.cpython-312.pyc new file mode 100644 index 00000000..185f4ea0 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/EGL/EXT/__pycache__/buffer_age.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/EXT/__pycache__/client_extensions.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/EGL/EXT/__pycache__/client_extensions.cpython-312.pyc new file mode 100644 index 00000000..faf684ca Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/EGL/EXT/__pycache__/client_extensions.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/EXT/__pycache__/create_context_robustness.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/EGL/EXT/__pycache__/create_context_robustness.cpython-312.pyc new file mode 100644 index 00000000..68a72f0f Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/EGL/EXT/__pycache__/create_context_robustness.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/EXT/__pycache__/device_base.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/EGL/EXT/__pycache__/device_base.cpython-312.pyc new file mode 100644 index 00000000..2950ac79 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/EGL/EXT/__pycache__/device_base.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/EXT/__pycache__/device_drm.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/EGL/EXT/__pycache__/device_drm.cpython-312.pyc new file mode 100644 index 00000000..91483538 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/EGL/EXT/__pycache__/device_drm.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/EXT/__pycache__/device_enumeration.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/EGL/EXT/__pycache__/device_enumeration.cpython-312.pyc new file mode 100644 index 00000000..15b78ec2 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/EGL/EXT/__pycache__/device_enumeration.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/EXT/__pycache__/device_openwf.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/EGL/EXT/__pycache__/device_openwf.cpython-312.pyc new file mode 100644 index 00000000..07269c38 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/EGL/EXT/__pycache__/device_openwf.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/EXT/__pycache__/device_query.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/EGL/EXT/__pycache__/device_query.cpython-312.pyc new file mode 100644 index 00000000..f6c5556f Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/EGL/EXT/__pycache__/device_query.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/EXT/__pycache__/image_dma_buf_import.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/EGL/EXT/__pycache__/image_dma_buf_import.cpython-312.pyc new file mode 100644 index 00000000..8058231d Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/EGL/EXT/__pycache__/image_dma_buf_import.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/EXT/__pycache__/multiview_window.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/EGL/EXT/__pycache__/multiview_window.cpython-312.pyc new file mode 100644 index 00000000..abf6360d Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/EGL/EXT/__pycache__/multiview_window.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/EXT/__pycache__/output_base.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/EGL/EXT/__pycache__/output_base.cpython-312.pyc new file mode 100644 index 00000000..cdca5d46 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/EGL/EXT/__pycache__/output_base.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/EXT/__pycache__/output_drm.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/EGL/EXT/__pycache__/output_drm.cpython-312.pyc new file mode 100644 index 00000000..d91af75e Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/EGL/EXT/__pycache__/output_drm.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/EXT/__pycache__/output_openwf.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/EGL/EXT/__pycache__/output_openwf.cpython-312.pyc new file mode 100644 index 00000000..48ba4d55 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/EGL/EXT/__pycache__/output_openwf.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/EXT/__pycache__/platform_base.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/EGL/EXT/__pycache__/platform_base.cpython-312.pyc new file mode 100644 index 00000000..19fb95ec Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/EGL/EXT/__pycache__/platform_base.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/EXT/__pycache__/platform_device.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/EGL/EXT/__pycache__/platform_device.cpython-312.pyc new file mode 100644 index 00000000..83077a73 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/EGL/EXT/__pycache__/platform_device.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/EXT/__pycache__/platform_wayland.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/EGL/EXT/__pycache__/platform_wayland.cpython-312.pyc new file mode 100644 index 00000000..55fa9e81 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/EGL/EXT/__pycache__/platform_wayland.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/EXT/__pycache__/platform_x11.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/EGL/EXT/__pycache__/platform_x11.cpython-312.pyc new file mode 100644 index 00000000..49deb59a Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/EGL/EXT/__pycache__/platform_x11.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/EXT/__pycache__/protected_surface.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/EGL/EXT/__pycache__/protected_surface.cpython-312.pyc new file mode 100644 index 00000000..bf168b1a Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/EGL/EXT/__pycache__/protected_surface.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/EXT/__pycache__/stream_consumer_egloutput.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/EGL/EXT/__pycache__/stream_consumer_egloutput.cpython-312.pyc new file mode 100644 index 00000000..42e83315 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/EGL/EXT/__pycache__/stream_consumer_egloutput.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/EXT/__pycache__/swap_buffers_with_damage.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/EGL/EXT/__pycache__/swap_buffers_with_damage.cpython-312.pyc new file mode 100644 index 00000000..bc4895df Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/EGL/EXT/__pycache__/swap_buffers_with_damage.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/EXT/__pycache__/yuv_surface.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/EGL/EXT/__pycache__/yuv_surface.cpython-312.pyc new file mode 100644 index 00000000..f36ea8aa Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/EGL/EXT/__pycache__/yuv_surface.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/EXT/buffer_age.py b/venv/lib/python3.12/site-packages/OpenGL/EGL/EXT/buffer_age.py new file mode 100644 index 00000000..b36b266f --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/EGL/EXT/buffer_age.py @@ -0,0 +1,23 @@ +'''OpenGL extension EXT.buffer_age + +This module customises the behaviour of the +OpenGL.raw.EGL.EXT.buffer_age to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/buffer_age.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.EGL import _types, _glgets +from OpenGL.raw.EGL.EXT.buffer_age import * +from OpenGL.raw.EGL.EXT.buffer_age import _EXTENSION_NAME + +def glInitBufferAgeEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/EXT/client_extensions.py b/venv/lib/python3.12/site-packages/OpenGL/EGL/EXT/client_extensions.py new file mode 100644 index 00000000..5dc830d9 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/EGL/EXT/client_extensions.py @@ -0,0 +1,23 @@ +'''OpenGL extension EXT.client_extensions + +This module customises the behaviour of the +OpenGL.raw.EGL.EXT.client_extensions to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/client_extensions.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.EGL import _types, _glgets +from OpenGL.raw.EGL.EXT.client_extensions import * +from OpenGL.raw.EGL.EXT.client_extensions import _EXTENSION_NAME + +def glInitClientExtensionsEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/EXT/create_context_robustness.py b/venv/lib/python3.12/site-packages/OpenGL/EGL/EXT/create_context_robustness.py new file mode 100644 index 00000000..6f678c08 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/EGL/EXT/create_context_robustness.py @@ -0,0 +1,23 @@ +'''OpenGL extension EXT.create_context_robustness + +This module customises the behaviour of the +OpenGL.raw.EGL.EXT.create_context_robustness to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/create_context_robustness.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.EGL import _types, _glgets +from OpenGL.raw.EGL.EXT.create_context_robustness import * +from OpenGL.raw.EGL.EXT.create_context_robustness import _EXTENSION_NAME + +def glInitCreateContextRobustnessEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/EXT/device_base.py b/venv/lib/python3.12/site-packages/OpenGL/EGL/EXT/device_base.py new file mode 100644 index 00000000..d782d87e --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/EGL/EXT/device_base.py @@ -0,0 +1,36 @@ +'''OpenGL extension EXT.device_base + +This module customises the behaviour of the +OpenGL.raw.EGL.EXT.device_base to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/device_base.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.EGL import _types, _glgets +from OpenGL.raw.EGL.EXT.device_base import * +from OpenGL.raw.EGL.EXT.device_base import _EXTENSION_NAME + +def glInitDeviceBaseEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION +eglQueryDevicesEXT.extension = None +eglQueryDevicesEXT.force_extension = True +eglQueryDeviceStringEXT.extension = None +eglQueryDeviceStringEXT.force_extension = True + + +def egl_get_devices(max_count=10): + """Utility function that retrieves platform devices""" + devices = (_types.EGLDeviceEXT*max_count)() + count = _types.EGLint() + if eglQueryDevicesEXT(max_count,devices,count): + return devices[:count.value] + return [] diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/EXT/device_drm.py b/venv/lib/python3.12/site-packages/OpenGL/EGL/EXT/device_drm.py new file mode 100644 index 00000000..652542bf --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/EGL/EXT/device_drm.py @@ -0,0 +1,23 @@ +'''OpenGL extension EXT.device_drm + +This module customises the behaviour of the +OpenGL.raw.EGL.EXT.device_drm to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/device_drm.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.EGL import _types, _glgets +from OpenGL.raw.EGL.EXT.device_drm import * +from OpenGL.raw.EGL.EXT.device_drm import _EXTENSION_NAME + +def glInitDeviceDrmEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/EXT/device_enumeration.py b/venv/lib/python3.12/site-packages/OpenGL/EGL/EXT/device_enumeration.py new file mode 100644 index 00000000..fc41bda5 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/EGL/EXT/device_enumeration.py @@ -0,0 +1,26 @@ +'''OpenGL extension EXT.device_enumeration + +This module customises the behaviour of the +OpenGL.raw.EGL.EXT.device_enumeration to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/device_enumeration.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.EGL import _types, _glgets +from OpenGL.raw.EGL.EXT.device_enumeration import * +from OpenGL.raw.EGL.EXT.device_enumeration import _EXTENSION_NAME + +def glInitDeviceEnumerationEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION + +eglQueryDevicesEXT.extension = None +eglQueryDevicesEXT.force_extension = True diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/EXT/device_openwf.py b/venv/lib/python3.12/site-packages/OpenGL/EGL/EXT/device_openwf.py new file mode 100644 index 00000000..218b2d22 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/EGL/EXT/device_openwf.py @@ -0,0 +1,23 @@ +'''OpenGL extension EXT.device_openwf + +This module customises the behaviour of the +OpenGL.raw.EGL.EXT.device_openwf to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/device_openwf.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.EGL import _types, _glgets +from OpenGL.raw.EGL.EXT.device_openwf import * +from OpenGL.raw.EGL.EXT.device_openwf import _EXTENSION_NAME + +def glInitDeviceOpenwfEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/EXT/device_query.py b/venv/lib/python3.12/site-packages/OpenGL/EGL/EXT/device_query.py new file mode 100644 index 00000000..45549198 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/EGL/EXT/device_query.py @@ -0,0 +1,26 @@ +'''OpenGL extension EXT.device_query + +This module customises the behaviour of the +OpenGL.raw.EGL.EXT.device_query to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/device_query.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.EGL import _types, _glgets +from OpenGL.raw.EGL.EXT.device_query import * +from OpenGL.raw.EGL.EXT.device_query import _EXTENSION_NAME + +def glInitDeviceQueryEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION + +eglQueryDeviceStringEXT.extension = None +eglQueryDeviceStringEXT.force_extension = True diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/EXT/image_dma_buf_import.py b/venv/lib/python3.12/site-packages/OpenGL/EGL/EXT/image_dma_buf_import.py new file mode 100644 index 00000000..3fbea711 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/EGL/EXT/image_dma_buf_import.py @@ -0,0 +1,23 @@ +'''OpenGL extension EXT.image_dma_buf_import + +This module customises the behaviour of the +OpenGL.raw.EGL.EXT.image_dma_buf_import to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/image_dma_buf_import.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.EGL import _types, _glgets +from OpenGL.raw.EGL.EXT.image_dma_buf_import import * +from OpenGL.raw.EGL.EXT.image_dma_buf_import import _EXTENSION_NAME + +def glInitImageDmaBufImportEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/EXT/multiview_window.py b/venv/lib/python3.12/site-packages/OpenGL/EGL/EXT/multiview_window.py new file mode 100644 index 00000000..36f3e3d7 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/EGL/EXT/multiview_window.py @@ -0,0 +1,23 @@ +'''OpenGL extension EXT.multiview_window + +This module customises the behaviour of the +OpenGL.raw.EGL.EXT.multiview_window to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/multiview_window.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.EGL import _types, _glgets +from OpenGL.raw.EGL.EXT.multiview_window import * +from OpenGL.raw.EGL.EXT.multiview_window import _EXTENSION_NAME + +def glInitMultiviewWindowEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/EXT/output_base.py b/venv/lib/python3.12/site-packages/OpenGL/EGL/EXT/output_base.py new file mode 100644 index 00000000..01ce9ca9 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/EGL/EXT/output_base.py @@ -0,0 +1,23 @@ +'''OpenGL extension EXT.output_base + +This module customises the behaviour of the +OpenGL.raw.EGL.EXT.output_base to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/output_base.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.EGL import _types, _glgets +from OpenGL.raw.EGL.EXT.output_base import * +from OpenGL.raw.EGL.EXT.output_base import _EXTENSION_NAME + +def glInitOutputBaseEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/EXT/output_drm.py b/venv/lib/python3.12/site-packages/OpenGL/EGL/EXT/output_drm.py new file mode 100644 index 00000000..67e3759d --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/EGL/EXT/output_drm.py @@ -0,0 +1,23 @@ +'''OpenGL extension EXT.output_drm + +This module customises the behaviour of the +OpenGL.raw.EGL.EXT.output_drm to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/output_drm.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.EGL import _types, _glgets +from OpenGL.raw.EGL.EXT.output_drm import * +from OpenGL.raw.EGL.EXT.output_drm import _EXTENSION_NAME + +def glInitOutputDrmEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/EXT/output_openwf.py b/venv/lib/python3.12/site-packages/OpenGL/EGL/EXT/output_openwf.py new file mode 100644 index 00000000..8944d805 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/EGL/EXT/output_openwf.py @@ -0,0 +1,23 @@ +'''OpenGL extension EXT.output_openwf + +This module customises the behaviour of the +OpenGL.raw.EGL.EXT.output_openwf to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/output_openwf.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.EGL import _types, _glgets +from OpenGL.raw.EGL.EXT.output_openwf import * +from OpenGL.raw.EGL.EXT.output_openwf import _EXTENSION_NAME + +def glInitOutputOpenwfEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/EXT/platform_base.py b/venv/lib/python3.12/site-packages/OpenGL/EGL/EXT/platform_base.py new file mode 100644 index 00000000..6d521214 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/EGL/EXT/platform_base.py @@ -0,0 +1,28 @@ +'''OpenGL extension EXT.platform_base + +This module customises the behaviour of the +OpenGL.raw.EGL.EXT.platform_base to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/platform_base.txt +''' +from OpenGL import constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.EGL import _types, _glgets +from OpenGL.raw.EGL.EXT.platform_base import * +from OpenGL.raw.EGL.EXT.platform_base import _EXTENSION_NAME + +# Cannot use this to check for the extension because the extension +# checking requires a context +#eglGetPlatformDisplayEXT.extension = None + +def glInitPlatformBaseEXT(): + '''Return boolean indicating whether this extension is available''' + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION +eglGetPlatformDisplayEXT.extension = None +eglGetPlatformDisplayEXT.force_extension = True diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/EXT/platform_device.py b/venv/lib/python3.12/site-packages/OpenGL/EGL/EXT/platform_device.py new file mode 100644 index 00000000..71b22520 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/EGL/EXT/platform_device.py @@ -0,0 +1,23 @@ +'''OpenGL extension EXT.platform_device + +This module customises the behaviour of the +OpenGL.raw.EGL.EXT.platform_device to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/platform_device.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.EGL import _types, _glgets +from OpenGL.raw.EGL.EXT.platform_device import * +from OpenGL.raw.EGL.EXT.platform_device import _EXTENSION_NAME + +def glInitPlatformDeviceEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/EXT/platform_wayland.py b/venv/lib/python3.12/site-packages/OpenGL/EGL/EXT/platform_wayland.py new file mode 100644 index 00000000..79b26127 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/EGL/EXT/platform_wayland.py @@ -0,0 +1,23 @@ +'''OpenGL extension EXT.platform_wayland + +This module customises the behaviour of the +OpenGL.raw.EGL.EXT.platform_wayland to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/platform_wayland.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.EGL import _types, _glgets +from OpenGL.raw.EGL.EXT.platform_wayland import * +from OpenGL.raw.EGL.EXT.platform_wayland import _EXTENSION_NAME + +def glInitPlatformWaylandEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/EXT/platform_x11.py b/venv/lib/python3.12/site-packages/OpenGL/EGL/EXT/platform_x11.py new file mode 100644 index 00000000..d5764df8 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/EGL/EXT/platform_x11.py @@ -0,0 +1,23 @@ +'''OpenGL extension EXT.platform_x11 + +This module customises the behaviour of the +OpenGL.raw.EGL.EXT.platform_x11 to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/platform_x11.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.EGL import _types, _glgets +from OpenGL.raw.EGL.EXT.platform_x11 import * +from OpenGL.raw.EGL.EXT.platform_x11 import _EXTENSION_NAME + +def glInitPlatformX11EXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/EXT/protected_surface.py b/venv/lib/python3.12/site-packages/OpenGL/EGL/EXT/protected_surface.py new file mode 100644 index 00000000..e8f3d0b8 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/EGL/EXT/protected_surface.py @@ -0,0 +1,23 @@ +'''OpenGL extension EXT.protected_surface + +This module customises the behaviour of the +OpenGL.raw.EGL.EXT.protected_surface to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/protected_surface.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.EGL import _types, _glgets +from OpenGL.raw.EGL.EXT.protected_surface import * +from OpenGL.raw.EGL.EXT.protected_surface import _EXTENSION_NAME + +def glInitProtectedSurfaceEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/EXT/stream_consumer_egloutput.py b/venv/lib/python3.12/site-packages/OpenGL/EGL/EXT/stream_consumer_egloutput.py new file mode 100644 index 00000000..16e724c7 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/EGL/EXT/stream_consumer_egloutput.py @@ -0,0 +1,23 @@ +'''OpenGL extension EXT.stream_consumer_egloutput + +This module customises the behaviour of the +OpenGL.raw.EGL.EXT.stream_consumer_egloutput to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/stream_consumer_egloutput.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.EGL import _types, _glgets +from OpenGL.raw.EGL.EXT.stream_consumer_egloutput import * +from OpenGL.raw.EGL.EXT.stream_consumer_egloutput import _EXTENSION_NAME + +def glInitStreamConsumerEgloutputEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/EXT/swap_buffers_with_damage.py b/venv/lib/python3.12/site-packages/OpenGL/EGL/EXT/swap_buffers_with_damage.py new file mode 100644 index 00000000..544a6860 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/EGL/EXT/swap_buffers_with_damage.py @@ -0,0 +1,23 @@ +'''OpenGL extension EXT.swap_buffers_with_damage + +This module customises the behaviour of the +OpenGL.raw.EGL.EXT.swap_buffers_with_damage to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/swap_buffers_with_damage.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.EGL import _types, _glgets +from OpenGL.raw.EGL.EXT.swap_buffers_with_damage import * +from OpenGL.raw.EGL.EXT.swap_buffers_with_damage import _EXTENSION_NAME + +def glInitSwapBuffersWithDamageEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/EXT/yuv_surface.py b/venv/lib/python3.12/site-packages/OpenGL/EGL/EXT/yuv_surface.py new file mode 100644 index 00000000..82416a2e --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/EGL/EXT/yuv_surface.py @@ -0,0 +1,23 @@ +'''OpenGL extension EXT.yuv_surface + +This module customises the behaviour of the +OpenGL.raw.EGL.EXT.yuv_surface to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/yuv_surface.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.EGL import _types, _glgets +from OpenGL.raw.EGL.EXT.yuv_surface import * +from OpenGL.raw.EGL.EXT.yuv_surface import _EXTENSION_NAME + +def glInitYuvSurfaceEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/HI/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/EGL/HI/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/EGL/HI/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/HI/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/EGL/HI/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..c8fa59a2 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/EGL/HI/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/HI/__pycache__/clientpixmap.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/EGL/HI/__pycache__/clientpixmap.cpython-312.pyc new file mode 100644 index 00000000..8857c0d8 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/EGL/HI/__pycache__/clientpixmap.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/HI/__pycache__/colorformats.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/EGL/HI/__pycache__/colorformats.cpython-312.pyc new file mode 100644 index 00000000..8cce396b Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/EGL/HI/__pycache__/colorformats.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/HI/clientpixmap.py b/venv/lib/python3.12/site-packages/OpenGL/EGL/HI/clientpixmap.py new file mode 100644 index 00000000..dd545450 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/EGL/HI/clientpixmap.py @@ -0,0 +1,23 @@ +'''OpenGL extension HI.clientpixmap + +This module customises the behaviour of the +OpenGL.raw.EGL.HI.clientpixmap to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/HI/clientpixmap.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.EGL import _types, _glgets +from OpenGL.raw.EGL.HI.clientpixmap import * +from OpenGL.raw.EGL.HI.clientpixmap import _EXTENSION_NAME + +def glInitClientpixmapHI(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/HI/colorformats.py b/venv/lib/python3.12/site-packages/OpenGL/EGL/HI/colorformats.py new file mode 100644 index 00000000..b9901f5e --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/EGL/HI/colorformats.py @@ -0,0 +1,23 @@ +'''OpenGL extension HI.colorformats + +This module customises the behaviour of the +OpenGL.raw.EGL.HI.colorformats to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/HI/colorformats.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.EGL import _types, _glgets +from OpenGL.raw.EGL.HI.colorformats import * +from OpenGL.raw.EGL.HI.colorformats import _EXTENSION_NAME + +def glInitColorformatsHI(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/IMG/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/EGL/IMG/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/EGL/IMG/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/IMG/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/EGL/IMG/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..e59ecc10 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/EGL/IMG/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/IMG/__pycache__/context_priority.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/EGL/IMG/__pycache__/context_priority.cpython-312.pyc new file mode 100644 index 00000000..2b902e33 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/EGL/IMG/__pycache__/context_priority.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/IMG/context_priority.py b/venv/lib/python3.12/site-packages/OpenGL/EGL/IMG/context_priority.py new file mode 100644 index 00000000..8fbb8870 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/EGL/IMG/context_priority.py @@ -0,0 +1,23 @@ +'''OpenGL extension IMG.context_priority + +This module customises the behaviour of the +OpenGL.raw.EGL.IMG.context_priority to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/IMG/context_priority.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.EGL import _types, _glgets +from OpenGL.raw.EGL.IMG.context_priority import * +from OpenGL.raw.EGL.IMG.context_priority import _EXTENSION_NAME + +def glInitContextPriorityIMG(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..39bef3c7 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/__pycache__/cl_event.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/__pycache__/cl_event.cpython-312.pyc new file mode 100644 index 00000000..fc76d532 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/__pycache__/cl_event.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/__pycache__/cl_event2.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/__pycache__/cl_event2.cpython-312.pyc new file mode 100644 index 00000000..eb9ee695 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/__pycache__/cl_event2.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/__pycache__/client_get_all_proc_addresses.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/__pycache__/client_get_all_proc_addresses.cpython-312.pyc new file mode 100644 index 00000000..ad725d35 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/__pycache__/client_get_all_proc_addresses.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/__pycache__/config_attribs.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/__pycache__/config_attribs.cpython-312.pyc new file mode 100644 index 00000000..907d7e8c Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/__pycache__/config_attribs.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/__pycache__/create_context.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/__pycache__/create_context.cpython-312.pyc new file mode 100644 index 00000000..8ed0166a Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/__pycache__/create_context.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/__pycache__/create_context_no_error.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/__pycache__/create_context_no_error.cpython-312.pyc new file mode 100644 index 00000000..b87b3a21 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/__pycache__/create_context_no_error.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/__pycache__/debug.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/__pycache__/debug.cpython-312.pyc new file mode 100644 index 00000000..c3b3a02b Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/__pycache__/debug.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/__pycache__/fence_sync.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/__pycache__/fence_sync.cpython-312.pyc new file mode 100644 index 00000000..771a411b Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/__pycache__/fence_sync.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/__pycache__/get_all_proc_addresses.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/__pycache__/get_all_proc_addresses.cpython-312.pyc new file mode 100644 index 00000000..fe8c24f2 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/__pycache__/get_all_proc_addresses.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/__pycache__/gl_colorspace.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/__pycache__/gl_colorspace.cpython-312.pyc new file mode 100644 index 00000000..d5d6e133 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/__pycache__/gl_colorspace.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/__pycache__/gl_renderbuffer_image.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/__pycache__/gl_renderbuffer_image.cpython-312.pyc new file mode 100644 index 00000000..7f965819 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/__pycache__/gl_renderbuffer_image.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/__pycache__/gl_texture_2D_image.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/__pycache__/gl_texture_2D_image.cpython-312.pyc new file mode 100644 index 00000000..7f2333d0 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/__pycache__/gl_texture_2D_image.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/__pycache__/gl_texture_3D_image.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/__pycache__/gl_texture_3D_image.cpython-312.pyc new file mode 100644 index 00000000..1bc2b3aa Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/__pycache__/gl_texture_3D_image.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/__pycache__/gl_texture_cubemap_image.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/__pycache__/gl_texture_cubemap_image.cpython-312.pyc new file mode 100644 index 00000000..7fc378b0 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/__pycache__/gl_texture_cubemap_image.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/__pycache__/image.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/__pycache__/image.cpython-312.pyc new file mode 100644 index 00000000..f37e83db Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/__pycache__/image.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/__pycache__/image_base.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/__pycache__/image_base.cpython-312.pyc new file mode 100644 index 00000000..ba76573a Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/__pycache__/image_base.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/__pycache__/image_pixmap.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/__pycache__/image_pixmap.cpython-312.pyc new file mode 100644 index 00000000..ed3875a1 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/__pycache__/image_pixmap.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/__pycache__/lock_surface.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/__pycache__/lock_surface.cpython-312.pyc new file mode 100644 index 00000000..81696e5f Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/__pycache__/lock_surface.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/__pycache__/lock_surface2.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/__pycache__/lock_surface2.cpython-312.pyc new file mode 100644 index 00000000..6143cca4 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/__pycache__/lock_surface2.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/__pycache__/lock_surface3.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/__pycache__/lock_surface3.cpython-312.pyc new file mode 100644 index 00000000..df4a3e6a Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/__pycache__/lock_surface3.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/__pycache__/partial_update.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/__pycache__/partial_update.cpython-312.pyc new file mode 100644 index 00000000..a00de2d2 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/__pycache__/partial_update.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/__pycache__/platform_android.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/__pycache__/platform_android.cpython-312.pyc new file mode 100644 index 00000000..8fbcb61e Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/__pycache__/platform_android.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/__pycache__/platform_gbm.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/__pycache__/platform_gbm.cpython-312.pyc new file mode 100644 index 00000000..62b9cefb Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/__pycache__/platform_gbm.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/__pycache__/platform_wayland.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/__pycache__/platform_wayland.cpython-312.pyc new file mode 100644 index 00000000..2134f659 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/__pycache__/platform_wayland.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/__pycache__/platform_x11.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/__pycache__/platform_x11.cpython-312.pyc new file mode 100644 index 00000000..8d3dbb17 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/__pycache__/platform_x11.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/__pycache__/reusable_sync.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/__pycache__/reusable_sync.cpython-312.pyc new file mode 100644 index 00000000..a2d84190 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/__pycache__/reusable_sync.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/__pycache__/stream.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/__pycache__/stream.cpython-312.pyc new file mode 100644 index 00000000..b01e5e1e Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/__pycache__/stream.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/__pycache__/stream_consumer_gltexture.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/__pycache__/stream_consumer_gltexture.cpython-312.pyc new file mode 100644 index 00000000..53783341 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/__pycache__/stream_consumer_gltexture.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/__pycache__/stream_cross_process_fd.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/__pycache__/stream_cross_process_fd.cpython-312.pyc new file mode 100644 index 00000000..8e996028 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/__pycache__/stream_cross_process_fd.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/__pycache__/stream_fifo.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/__pycache__/stream_fifo.cpython-312.pyc new file mode 100644 index 00000000..85846443 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/__pycache__/stream_fifo.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/__pycache__/stream_producer_aldatalocator.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/__pycache__/stream_producer_aldatalocator.cpython-312.pyc new file mode 100644 index 00000000..efa2f0cd Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/__pycache__/stream_producer_aldatalocator.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/__pycache__/stream_producer_eglsurface.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/__pycache__/stream_producer_eglsurface.cpython-312.pyc new file mode 100644 index 00000000..bc3d68b6 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/__pycache__/stream_producer_eglsurface.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/__pycache__/surfaceless_context.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/__pycache__/surfaceless_context.cpython-312.pyc new file mode 100644 index 00000000..7081d45b Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/__pycache__/surfaceless_context.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/__pycache__/swap_buffers_with_damage.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/__pycache__/swap_buffers_with_damage.cpython-312.pyc new file mode 100644 index 00000000..04c0557e Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/__pycache__/swap_buffers_with_damage.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/__pycache__/vg_parent_image.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/__pycache__/vg_parent_image.cpython-312.pyc new file mode 100644 index 00000000..97501d95 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/__pycache__/vg_parent_image.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/__pycache__/wait_sync.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/__pycache__/wait_sync.cpython-312.pyc new file mode 100644 index 00000000..79524075 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/__pycache__/wait_sync.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/cl_event.py b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/cl_event.py new file mode 100644 index 00000000..b784f08d --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/cl_event.py @@ -0,0 +1,23 @@ +'''OpenGL extension KHR.cl_event + +This module customises the behaviour of the +OpenGL.raw.EGL.KHR.cl_event to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/KHR/cl_event.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.EGL import _types, _glgets +from OpenGL.raw.EGL.KHR.cl_event import * +from OpenGL.raw.EGL.KHR.cl_event import _EXTENSION_NAME + +def glInitClEventKHR(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/cl_event2.py b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/cl_event2.py new file mode 100644 index 00000000..d50b0956 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/cl_event2.py @@ -0,0 +1,23 @@ +'''OpenGL extension KHR.cl_event2 + +This module customises the behaviour of the +OpenGL.raw.EGL.KHR.cl_event2 to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/KHR/cl_event2.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.EGL import _types, _glgets +from OpenGL.raw.EGL.KHR.cl_event2 import * +from OpenGL.raw.EGL.KHR.cl_event2 import _EXTENSION_NAME + +def glInitClEvent2KHR(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/client_get_all_proc_addresses.py b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/client_get_all_proc_addresses.py new file mode 100644 index 00000000..81f03d06 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/client_get_all_proc_addresses.py @@ -0,0 +1,23 @@ +'''OpenGL extension KHR.client_get_all_proc_addresses + +This module customises the behaviour of the +OpenGL.raw.EGL.KHR.client_get_all_proc_addresses to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/KHR/client_get_all_proc_addresses.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.EGL import _types, _glgets +from OpenGL.raw.EGL.KHR.client_get_all_proc_addresses import * +from OpenGL.raw.EGL.KHR.client_get_all_proc_addresses import _EXTENSION_NAME + +def glInitClientGetAllProcAddressesKHR(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/config_attribs.py b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/config_attribs.py new file mode 100644 index 00000000..b55984d2 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/config_attribs.py @@ -0,0 +1,23 @@ +'''OpenGL extension KHR.config_attribs + +This module customises the behaviour of the +OpenGL.raw.EGL.KHR.config_attribs to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/KHR/config_attribs.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.EGL import _types, _glgets +from OpenGL.raw.EGL.KHR.config_attribs import * +from OpenGL.raw.EGL.KHR.config_attribs import _EXTENSION_NAME + +def glInitConfigAttribsKHR(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/create_context.py b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/create_context.py new file mode 100644 index 00000000..42e29278 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/create_context.py @@ -0,0 +1,23 @@ +'''OpenGL extension KHR.create_context + +This module customises the behaviour of the +OpenGL.raw.EGL.KHR.create_context to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/KHR/create_context.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.EGL import _types, _glgets +from OpenGL.raw.EGL.KHR.create_context import * +from OpenGL.raw.EGL.KHR.create_context import _EXTENSION_NAME + +def glInitCreateContextKHR(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/create_context_no_error.py b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/create_context_no_error.py new file mode 100644 index 00000000..0f6842c2 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/create_context_no_error.py @@ -0,0 +1,23 @@ +'''OpenGL extension KHR.create_context_no_error + +This module customises the behaviour of the +OpenGL.raw.EGL.KHR.create_context_no_error to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/KHR/create_context_no_error.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.EGL import _types, _glgets +from OpenGL.raw.EGL.KHR.create_context_no_error import * +from OpenGL.raw.EGL.KHR.create_context_no_error import _EXTENSION_NAME + +def glInitCreateContextNoErrorKHR(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/debug.py b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/debug.py new file mode 100644 index 00000000..91fbd6bc --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/debug.py @@ -0,0 +1,23 @@ +'''OpenGL extension KHR.debug + +This module customises the behaviour of the +OpenGL.raw.EGL.KHR.debug to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/KHR/debug.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.EGL import _types, _glgets +from OpenGL.raw.EGL.KHR.debug import * +from OpenGL.raw.EGL.KHR.debug import _EXTENSION_NAME + +def glInitDebugKHR(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/fence_sync.py b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/fence_sync.py new file mode 100644 index 00000000..b152cb6f --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/fence_sync.py @@ -0,0 +1,23 @@ +'''OpenGL extension KHR.fence_sync + +This module customises the behaviour of the +OpenGL.raw.EGL.KHR.fence_sync to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/KHR/fence_sync.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.EGL import _types, _glgets +from OpenGL.raw.EGL.KHR.fence_sync import * +from OpenGL.raw.EGL.KHR.fence_sync import _EXTENSION_NAME + +def glInitFenceSyncKHR(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/get_all_proc_addresses.py b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/get_all_proc_addresses.py new file mode 100644 index 00000000..eb538e0f --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/get_all_proc_addresses.py @@ -0,0 +1,23 @@ +'''OpenGL extension KHR.get_all_proc_addresses + +This module customises the behaviour of the +OpenGL.raw.EGL.KHR.get_all_proc_addresses to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/KHR/get_all_proc_addresses.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.EGL import _types, _glgets +from OpenGL.raw.EGL.KHR.get_all_proc_addresses import * +from OpenGL.raw.EGL.KHR.get_all_proc_addresses import _EXTENSION_NAME + +def glInitGetAllProcAddressesKHR(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/gl_colorspace.py b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/gl_colorspace.py new file mode 100644 index 00000000..fdf02132 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/gl_colorspace.py @@ -0,0 +1,23 @@ +'''OpenGL extension KHR.gl_colorspace + +This module customises the behaviour of the +OpenGL.raw.EGL.KHR.gl_colorspace to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/KHR/gl_colorspace.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.EGL import _types, _glgets +from OpenGL.raw.EGL.KHR.gl_colorspace import * +from OpenGL.raw.EGL.KHR.gl_colorspace import _EXTENSION_NAME + +def glInitGlColorspaceKHR(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/gl_renderbuffer_image.py b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/gl_renderbuffer_image.py new file mode 100644 index 00000000..fc72cf75 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/gl_renderbuffer_image.py @@ -0,0 +1,23 @@ +'''OpenGL extension KHR.gl_renderbuffer_image + +This module customises the behaviour of the +OpenGL.raw.EGL.KHR.gl_renderbuffer_image to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/KHR/gl_renderbuffer_image.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.EGL import _types, _glgets +from OpenGL.raw.EGL.KHR.gl_renderbuffer_image import * +from OpenGL.raw.EGL.KHR.gl_renderbuffer_image import _EXTENSION_NAME + +def glInitGlRenderbufferImageKHR(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/gl_texture_2D_image.py b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/gl_texture_2D_image.py new file mode 100644 index 00000000..493926a3 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/gl_texture_2D_image.py @@ -0,0 +1,23 @@ +'''OpenGL extension KHR.gl_texture_2D_image + +This module customises the behaviour of the +OpenGL.raw.EGL.KHR.gl_texture_2D_image to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/KHR/gl_texture_2D_image.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.EGL import _types, _glgets +from OpenGL.raw.EGL.KHR.gl_texture_2D_image import * +from OpenGL.raw.EGL.KHR.gl_texture_2D_image import _EXTENSION_NAME + +def glInitGlTexture2DImageKHR(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/gl_texture_3D_image.py b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/gl_texture_3D_image.py new file mode 100644 index 00000000..c4a36ae8 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/gl_texture_3D_image.py @@ -0,0 +1,23 @@ +'''OpenGL extension KHR.gl_texture_3D_image + +This module customises the behaviour of the +OpenGL.raw.EGL.KHR.gl_texture_3D_image to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/KHR/gl_texture_3D_image.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.EGL import _types, _glgets +from OpenGL.raw.EGL.KHR.gl_texture_3D_image import * +from OpenGL.raw.EGL.KHR.gl_texture_3D_image import _EXTENSION_NAME + +def glInitGlTexture3DImageKHR(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/gl_texture_cubemap_image.py b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/gl_texture_cubemap_image.py new file mode 100644 index 00000000..281fdeaf --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/gl_texture_cubemap_image.py @@ -0,0 +1,23 @@ +'''OpenGL extension KHR.gl_texture_cubemap_image + +This module customises the behaviour of the +OpenGL.raw.EGL.KHR.gl_texture_cubemap_image to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/KHR/gl_texture_cubemap_image.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.EGL import _types, _glgets +from OpenGL.raw.EGL.KHR.gl_texture_cubemap_image import * +from OpenGL.raw.EGL.KHR.gl_texture_cubemap_image import _EXTENSION_NAME + +def glInitGlTextureCubemapImageKHR(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/image.py b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/image.py new file mode 100644 index 00000000..9021ec89 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/image.py @@ -0,0 +1,23 @@ +'''OpenGL extension KHR.image + +This module customises the behaviour of the +OpenGL.raw.EGL.KHR.image to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/KHR/image.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.EGL import _types, _glgets +from OpenGL.raw.EGL.KHR.image import * +from OpenGL.raw.EGL.KHR.image import _EXTENSION_NAME + +def glInitImageKHR(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/image_base.py b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/image_base.py new file mode 100644 index 00000000..34d0fba8 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/image_base.py @@ -0,0 +1,23 @@ +'''OpenGL extension KHR.image_base + +This module customises the behaviour of the +OpenGL.raw.EGL.KHR.image_base to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/KHR/image_base.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.EGL import _types, _glgets +from OpenGL.raw.EGL.KHR.image_base import * +from OpenGL.raw.EGL.KHR.image_base import _EXTENSION_NAME + +def glInitImageBaseKHR(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/image_pixmap.py b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/image_pixmap.py new file mode 100644 index 00000000..0c8db530 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/image_pixmap.py @@ -0,0 +1,23 @@ +'''OpenGL extension KHR.image_pixmap + +This module customises the behaviour of the +OpenGL.raw.EGL.KHR.image_pixmap to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/KHR/image_pixmap.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.EGL import _types, _glgets +from OpenGL.raw.EGL.KHR.image_pixmap import * +from OpenGL.raw.EGL.KHR.image_pixmap import _EXTENSION_NAME + +def glInitImagePixmapKHR(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/lock_surface.py b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/lock_surface.py new file mode 100644 index 00000000..772c4db0 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/lock_surface.py @@ -0,0 +1,23 @@ +'''OpenGL extension KHR.lock_surface + +This module customises the behaviour of the +OpenGL.raw.EGL.KHR.lock_surface to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/KHR/lock_surface.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.EGL import _types, _glgets +from OpenGL.raw.EGL.KHR.lock_surface import * +from OpenGL.raw.EGL.KHR.lock_surface import _EXTENSION_NAME + +def glInitLockSurfaceKHR(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/lock_surface2.py b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/lock_surface2.py new file mode 100644 index 00000000..78a926b7 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/lock_surface2.py @@ -0,0 +1,23 @@ +'''OpenGL extension KHR.lock_surface2 + +This module customises the behaviour of the +OpenGL.raw.EGL.KHR.lock_surface2 to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/KHR/lock_surface2.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.EGL import _types, _glgets +from OpenGL.raw.EGL.KHR.lock_surface2 import * +from OpenGL.raw.EGL.KHR.lock_surface2 import _EXTENSION_NAME + +def glInitLockSurface2KHR(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/lock_surface3.py b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/lock_surface3.py new file mode 100644 index 00000000..7d27d8e0 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/lock_surface3.py @@ -0,0 +1,23 @@ +'''OpenGL extension KHR.lock_surface3 + +This module customises the behaviour of the +OpenGL.raw.EGL.KHR.lock_surface3 to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/KHR/lock_surface3.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.EGL import _types, _glgets +from OpenGL.raw.EGL.KHR.lock_surface3 import * +from OpenGL.raw.EGL.KHR.lock_surface3 import _EXTENSION_NAME + +def glInitLockSurface3KHR(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/partial_update.py b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/partial_update.py new file mode 100644 index 00000000..b9e7779d --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/partial_update.py @@ -0,0 +1,23 @@ +'''OpenGL extension KHR.partial_update + +This module customises the behaviour of the +OpenGL.raw.EGL.KHR.partial_update to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/KHR/partial_update.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.EGL import _types, _glgets +from OpenGL.raw.EGL.KHR.partial_update import * +from OpenGL.raw.EGL.KHR.partial_update import _EXTENSION_NAME + +def glInitPartialUpdateKHR(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/platform_android.py b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/platform_android.py new file mode 100644 index 00000000..a7f62380 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/platform_android.py @@ -0,0 +1,23 @@ +'''OpenGL extension KHR.platform_android + +This module customises the behaviour of the +OpenGL.raw.EGL.KHR.platform_android to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/KHR/platform_android.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.EGL import _types, _glgets +from OpenGL.raw.EGL.KHR.platform_android import * +from OpenGL.raw.EGL.KHR.platform_android import _EXTENSION_NAME + +def glInitPlatformAndroidKHR(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/platform_gbm.py b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/platform_gbm.py new file mode 100644 index 00000000..1b5eb179 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/platform_gbm.py @@ -0,0 +1,23 @@ +'''OpenGL extension KHR.platform_gbm + +This module customises the behaviour of the +OpenGL.raw.EGL.KHR.platform_gbm to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/KHR/platform_gbm.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.EGL import _types, _glgets +from OpenGL.raw.EGL.KHR.platform_gbm import * +from OpenGL.raw.EGL.KHR.platform_gbm import _EXTENSION_NAME + +def glInitPlatformGbmKHR(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/platform_wayland.py b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/platform_wayland.py new file mode 100644 index 00000000..a8262202 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/platform_wayland.py @@ -0,0 +1,23 @@ +'''OpenGL extension KHR.platform_wayland + +This module customises the behaviour of the +OpenGL.raw.EGL.KHR.platform_wayland to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/KHR/platform_wayland.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.EGL import _types, _glgets +from OpenGL.raw.EGL.KHR.platform_wayland import * +from OpenGL.raw.EGL.KHR.platform_wayland import _EXTENSION_NAME + +def glInitPlatformWaylandKHR(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/platform_x11.py b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/platform_x11.py new file mode 100644 index 00000000..a86e04bf --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/platform_x11.py @@ -0,0 +1,23 @@ +'''OpenGL extension KHR.platform_x11 + +This module customises the behaviour of the +OpenGL.raw.EGL.KHR.platform_x11 to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/KHR/platform_x11.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.EGL import _types, _glgets +from OpenGL.raw.EGL.KHR.platform_x11 import * +from OpenGL.raw.EGL.KHR.platform_x11 import _EXTENSION_NAME + +def glInitPlatformX11KHR(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/reusable_sync.py b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/reusable_sync.py new file mode 100644 index 00000000..fe233738 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/reusable_sync.py @@ -0,0 +1,23 @@ +'''OpenGL extension KHR.reusable_sync + +This module customises the behaviour of the +OpenGL.raw.EGL.KHR.reusable_sync to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/KHR/reusable_sync.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.EGL import _types, _glgets +from OpenGL.raw.EGL.KHR.reusable_sync import * +from OpenGL.raw.EGL.KHR.reusable_sync import _EXTENSION_NAME + +def glInitReusableSyncKHR(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/stream.py b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/stream.py new file mode 100644 index 00000000..cb042082 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/stream.py @@ -0,0 +1,23 @@ +'''OpenGL extension KHR.stream + +This module customises the behaviour of the +OpenGL.raw.EGL.KHR.stream to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/KHR/stream.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.EGL import _types, _glgets +from OpenGL.raw.EGL.KHR.stream import * +from OpenGL.raw.EGL.KHR.stream import _EXTENSION_NAME + +def glInitStreamKHR(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/stream_consumer_gltexture.py b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/stream_consumer_gltexture.py new file mode 100644 index 00000000..80c1f196 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/stream_consumer_gltexture.py @@ -0,0 +1,23 @@ +'''OpenGL extension KHR.stream_consumer_gltexture + +This module customises the behaviour of the +OpenGL.raw.EGL.KHR.stream_consumer_gltexture to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/KHR/stream_consumer_gltexture.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.EGL import _types, _glgets +from OpenGL.raw.EGL.KHR.stream_consumer_gltexture import * +from OpenGL.raw.EGL.KHR.stream_consumer_gltexture import _EXTENSION_NAME + +def glInitStreamConsumerGltextureKHR(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/stream_cross_process_fd.py b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/stream_cross_process_fd.py new file mode 100644 index 00000000..3af00e0e --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/stream_cross_process_fd.py @@ -0,0 +1,23 @@ +'''OpenGL extension KHR.stream_cross_process_fd + +This module customises the behaviour of the +OpenGL.raw.EGL.KHR.stream_cross_process_fd to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/KHR/stream_cross_process_fd.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.EGL import _types, _glgets +from OpenGL.raw.EGL.KHR.stream_cross_process_fd import * +from OpenGL.raw.EGL.KHR.stream_cross_process_fd import _EXTENSION_NAME + +def glInitStreamCrossProcessFdKHR(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/stream_fifo.py b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/stream_fifo.py new file mode 100644 index 00000000..3a1eb432 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/stream_fifo.py @@ -0,0 +1,23 @@ +'''OpenGL extension KHR.stream_fifo + +This module customises the behaviour of the +OpenGL.raw.EGL.KHR.stream_fifo to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/KHR/stream_fifo.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.EGL import _types, _glgets +from OpenGL.raw.EGL.KHR.stream_fifo import * +from OpenGL.raw.EGL.KHR.stream_fifo import _EXTENSION_NAME + +def glInitStreamFifoKHR(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/stream_producer_aldatalocator.py b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/stream_producer_aldatalocator.py new file mode 100644 index 00000000..62f1bdc4 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/stream_producer_aldatalocator.py @@ -0,0 +1,23 @@ +'''OpenGL extension KHR.stream_producer_aldatalocator + +This module customises the behaviour of the +OpenGL.raw.EGL.KHR.stream_producer_aldatalocator to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/KHR/stream_producer_aldatalocator.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.EGL import _types, _glgets +from OpenGL.raw.EGL.KHR.stream_producer_aldatalocator import * +from OpenGL.raw.EGL.KHR.stream_producer_aldatalocator import _EXTENSION_NAME + +def glInitStreamProducerAldatalocatorKHR(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/stream_producer_eglsurface.py b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/stream_producer_eglsurface.py new file mode 100644 index 00000000..4a407966 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/stream_producer_eglsurface.py @@ -0,0 +1,23 @@ +'''OpenGL extension KHR.stream_producer_eglsurface + +This module customises the behaviour of the +OpenGL.raw.EGL.KHR.stream_producer_eglsurface to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/KHR/stream_producer_eglsurface.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.EGL import _types, _glgets +from OpenGL.raw.EGL.KHR.stream_producer_eglsurface import * +from OpenGL.raw.EGL.KHR.stream_producer_eglsurface import _EXTENSION_NAME + +def glInitStreamProducerEglsurfaceKHR(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/surfaceless_context.py b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/surfaceless_context.py new file mode 100644 index 00000000..db8d271b --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/surfaceless_context.py @@ -0,0 +1,23 @@ +'''OpenGL extension KHR.surfaceless_context + +This module customises the behaviour of the +OpenGL.raw.EGL.KHR.surfaceless_context to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/KHR/surfaceless_context.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.EGL import _types, _glgets +from OpenGL.raw.EGL.KHR.surfaceless_context import * +from OpenGL.raw.EGL.KHR.surfaceless_context import _EXTENSION_NAME + +def glInitSurfacelessContextKHR(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/swap_buffers_with_damage.py b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/swap_buffers_with_damage.py new file mode 100644 index 00000000..1da3fd59 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/swap_buffers_with_damage.py @@ -0,0 +1,23 @@ +'''OpenGL extension KHR.swap_buffers_with_damage + +This module customises the behaviour of the +OpenGL.raw.EGL.KHR.swap_buffers_with_damage to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/KHR/swap_buffers_with_damage.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.EGL import _types, _glgets +from OpenGL.raw.EGL.KHR.swap_buffers_with_damage import * +from OpenGL.raw.EGL.KHR.swap_buffers_with_damage import _EXTENSION_NAME + +def glInitSwapBuffersWithDamageKHR(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/vg_parent_image.py b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/vg_parent_image.py new file mode 100644 index 00000000..449f0de9 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/vg_parent_image.py @@ -0,0 +1,23 @@ +'''OpenGL extension KHR.vg_parent_image + +This module customises the behaviour of the +OpenGL.raw.EGL.KHR.vg_parent_image to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/KHR/vg_parent_image.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.EGL import _types, _glgets +from OpenGL.raw.EGL.KHR.vg_parent_image import * +from OpenGL.raw.EGL.KHR.vg_parent_image import _EXTENSION_NAME + +def glInitVgParentImageKHR(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/wait_sync.py b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/wait_sync.py new file mode 100644 index 00000000..492ac437 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/EGL/KHR/wait_sync.py @@ -0,0 +1,23 @@ +'''OpenGL extension KHR.wait_sync + +This module customises the behaviour of the +OpenGL.raw.EGL.KHR.wait_sync to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/KHR/wait_sync.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.EGL import _types, _glgets +from OpenGL.raw.EGL.KHR.wait_sync import * +from OpenGL.raw.EGL.KHR.wait_sync import _EXTENSION_NAME + +def glInitWaitSyncKHR(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/MESA/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/EGL/MESA/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/EGL/MESA/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/MESA/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/EGL/MESA/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..514fba2b Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/EGL/MESA/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/MESA/__pycache__/drm_image.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/EGL/MESA/__pycache__/drm_image.cpython-312.pyc new file mode 100644 index 00000000..e6385589 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/EGL/MESA/__pycache__/drm_image.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/MESA/__pycache__/image_dma_buf_export.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/EGL/MESA/__pycache__/image_dma_buf_export.cpython-312.pyc new file mode 100644 index 00000000..adfd7544 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/EGL/MESA/__pycache__/image_dma_buf_export.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/MESA/__pycache__/platform_gbm.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/EGL/MESA/__pycache__/platform_gbm.cpython-312.pyc new file mode 100644 index 00000000..a87bbf12 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/EGL/MESA/__pycache__/platform_gbm.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/MESA/drm_image.py b/venv/lib/python3.12/site-packages/OpenGL/EGL/MESA/drm_image.py new file mode 100644 index 00000000..feba6068 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/EGL/MESA/drm_image.py @@ -0,0 +1,23 @@ +'''OpenGL extension MESA.drm_image + +This module customises the behaviour of the +OpenGL.raw.EGL.MESA.drm_image to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/MESA/drm_image.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.EGL import _types, _glgets +from OpenGL.raw.EGL.MESA.drm_image import * +from OpenGL.raw.EGL.MESA.drm_image import _EXTENSION_NAME + +def glInitDrmImageMESA(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/MESA/image_dma_buf_export.py b/venv/lib/python3.12/site-packages/OpenGL/EGL/MESA/image_dma_buf_export.py new file mode 100644 index 00000000..851b5209 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/EGL/MESA/image_dma_buf_export.py @@ -0,0 +1,23 @@ +'''OpenGL extension MESA.image_dma_buf_export + +This module customises the behaviour of the +OpenGL.raw.EGL.MESA.image_dma_buf_export to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/MESA/image_dma_buf_export.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.EGL import _types, _glgets +from OpenGL.raw.EGL.MESA.image_dma_buf_export import * +from OpenGL.raw.EGL.MESA.image_dma_buf_export import _EXTENSION_NAME + +def glInitImageDmaBufExportMESA(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/MESA/platform_gbm.py b/venv/lib/python3.12/site-packages/OpenGL/EGL/MESA/platform_gbm.py new file mode 100644 index 00000000..9c66e55f --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/EGL/MESA/platform_gbm.py @@ -0,0 +1,23 @@ +'''OpenGL extension MESA.platform_gbm + +This module customises the behaviour of the +OpenGL.raw.EGL.MESA.platform_gbm to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/MESA/platform_gbm.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.EGL import _types, _glgets +from OpenGL.raw.EGL.MESA.platform_gbm import * +from OpenGL.raw.EGL.MESA.platform_gbm import _EXTENSION_NAME + +def glInitPlatformGbmMESA(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/NOK/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/EGL/NOK/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/EGL/NOK/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/NOK/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/EGL/NOK/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..459d6469 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/EGL/NOK/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/NOK/__pycache__/swap_region.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/EGL/NOK/__pycache__/swap_region.cpython-312.pyc new file mode 100644 index 00000000..62fee6d4 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/EGL/NOK/__pycache__/swap_region.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/NOK/__pycache__/swap_region2.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/EGL/NOK/__pycache__/swap_region2.cpython-312.pyc new file mode 100644 index 00000000..91c1ea07 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/EGL/NOK/__pycache__/swap_region2.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/NOK/__pycache__/texture_from_pixmap.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/EGL/NOK/__pycache__/texture_from_pixmap.cpython-312.pyc new file mode 100644 index 00000000..7ed6ae46 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/EGL/NOK/__pycache__/texture_from_pixmap.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/NOK/swap_region.py b/venv/lib/python3.12/site-packages/OpenGL/EGL/NOK/swap_region.py new file mode 100644 index 00000000..4b0bda9e --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/EGL/NOK/swap_region.py @@ -0,0 +1,23 @@ +'''OpenGL extension NOK.swap_region + +This module customises the behaviour of the +OpenGL.raw.EGL.NOK.swap_region to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NOK/swap_region.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.EGL import _types, _glgets +from OpenGL.raw.EGL.NOK.swap_region import * +from OpenGL.raw.EGL.NOK.swap_region import _EXTENSION_NAME + +def glInitSwapRegionNOK(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/NOK/swap_region2.py b/venv/lib/python3.12/site-packages/OpenGL/EGL/NOK/swap_region2.py new file mode 100644 index 00000000..15d7b774 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/EGL/NOK/swap_region2.py @@ -0,0 +1,23 @@ +'''OpenGL extension NOK.swap_region2 + +This module customises the behaviour of the +OpenGL.raw.EGL.NOK.swap_region2 to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NOK/swap_region2.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.EGL import _types, _glgets +from OpenGL.raw.EGL.NOK.swap_region2 import * +from OpenGL.raw.EGL.NOK.swap_region2 import _EXTENSION_NAME + +def glInitSwapRegion2NOK(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/NOK/texture_from_pixmap.py b/venv/lib/python3.12/site-packages/OpenGL/EGL/NOK/texture_from_pixmap.py new file mode 100644 index 00000000..7dc6ab7b --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/EGL/NOK/texture_from_pixmap.py @@ -0,0 +1,23 @@ +'''OpenGL extension NOK.texture_from_pixmap + +This module customises the behaviour of the +OpenGL.raw.EGL.NOK.texture_from_pixmap to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NOK/texture_from_pixmap.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.EGL import _types, _glgets +from OpenGL.raw.EGL.NOK.texture_from_pixmap import * +from OpenGL.raw.EGL.NOK.texture_from_pixmap import _EXTENSION_NAME + +def glInitTextureFromPixmapNOK(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/NV/EGL_3dvision_surface.py b/venv/lib/python3.12/site-packages/OpenGL/EGL/NV/EGL_3dvision_surface.py new file mode 100644 index 00000000..0a62862c --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/EGL/NV/EGL_3dvision_surface.py @@ -0,0 +1,23 @@ +'''OpenGL extension NV.EGL_3dvision_surface + +This module customises the behaviour of the +OpenGL.raw.EGL.NV.EGL_3dvision_surface to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/EGL_3dvision_surface.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.EGL import _types, _glgets +from OpenGL.raw.EGL.NV.EGL_3dvision_surface import * +from OpenGL.raw.EGL.NV.EGL_3dvision_surface import _EXTENSION_NAME + +def glInitEgl3DvisionSurfaceNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/NV/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/EGL/NV/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/EGL/NV/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/NV/__pycache__/EGL_3dvision_surface.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/EGL/NV/__pycache__/EGL_3dvision_surface.cpython-312.pyc new file mode 100644 index 00000000..d3c2d21f Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/EGL/NV/__pycache__/EGL_3dvision_surface.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/NV/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/EGL/NV/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..e3e552e9 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/EGL/NV/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/NV/__pycache__/coverage_sample.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/EGL/NV/__pycache__/coverage_sample.cpython-312.pyc new file mode 100644 index 00000000..9986d63f Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/EGL/NV/__pycache__/coverage_sample.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/NV/__pycache__/coverage_sample_resolve.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/EGL/NV/__pycache__/coverage_sample_resolve.cpython-312.pyc new file mode 100644 index 00000000..c4ed88f4 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/EGL/NV/__pycache__/coverage_sample_resolve.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/NV/__pycache__/cuda_event.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/EGL/NV/__pycache__/cuda_event.cpython-312.pyc new file mode 100644 index 00000000..613755e5 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/EGL/NV/__pycache__/cuda_event.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/NV/__pycache__/depth_nonlinear.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/EGL/NV/__pycache__/depth_nonlinear.cpython-312.pyc new file mode 100644 index 00000000..aa28f129 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/EGL/NV/__pycache__/depth_nonlinear.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/NV/__pycache__/device_cuda.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/EGL/NV/__pycache__/device_cuda.cpython-312.pyc new file mode 100644 index 00000000..ba409914 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/EGL/NV/__pycache__/device_cuda.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/NV/__pycache__/native_query.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/EGL/NV/__pycache__/native_query.cpython-312.pyc new file mode 100644 index 00000000..69321433 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/EGL/NV/__pycache__/native_query.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/NV/__pycache__/post_convert_rounding.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/EGL/NV/__pycache__/post_convert_rounding.cpython-312.pyc new file mode 100644 index 00000000..15be5a16 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/EGL/NV/__pycache__/post_convert_rounding.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/NV/__pycache__/post_sub_buffer.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/EGL/NV/__pycache__/post_sub_buffer.cpython-312.pyc new file mode 100644 index 00000000..3bc2e5f6 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/EGL/NV/__pycache__/post_sub_buffer.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/NV/__pycache__/stream_consumer_gltexture_yuv.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/EGL/NV/__pycache__/stream_consumer_gltexture_yuv.cpython-312.pyc new file mode 100644 index 00000000..9e424a50 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/EGL/NV/__pycache__/stream_consumer_gltexture_yuv.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/NV/__pycache__/stream_metadata.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/EGL/NV/__pycache__/stream_metadata.cpython-312.pyc new file mode 100644 index 00000000..6dc84c81 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/EGL/NV/__pycache__/stream_metadata.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/NV/__pycache__/stream_sync.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/EGL/NV/__pycache__/stream_sync.cpython-312.pyc new file mode 100644 index 00000000..f42dcaf8 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/EGL/NV/__pycache__/stream_sync.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/NV/__pycache__/sync.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/EGL/NV/__pycache__/sync.cpython-312.pyc new file mode 100644 index 00000000..31e0377f Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/EGL/NV/__pycache__/sync.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/NV/__pycache__/system_time.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/EGL/NV/__pycache__/system_time.cpython-312.pyc new file mode 100644 index 00000000..9d7b979f Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/EGL/NV/__pycache__/system_time.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/NV/coverage_sample.py b/venv/lib/python3.12/site-packages/OpenGL/EGL/NV/coverage_sample.py new file mode 100644 index 00000000..d66fea5b --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/EGL/NV/coverage_sample.py @@ -0,0 +1,23 @@ +'''OpenGL extension NV.coverage_sample + +This module customises the behaviour of the +OpenGL.raw.EGL.NV.coverage_sample to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/coverage_sample.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.EGL import _types, _glgets +from OpenGL.raw.EGL.NV.coverage_sample import * +from OpenGL.raw.EGL.NV.coverage_sample import _EXTENSION_NAME + +def glInitCoverageSampleNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/NV/coverage_sample_resolve.py b/venv/lib/python3.12/site-packages/OpenGL/EGL/NV/coverage_sample_resolve.py new file mode 100644 index 00000000..85776ab8 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/EGL/NV/coverage_sample_resolve.py @@ -0,0 +1,23 @@ +'''OpenGL extension NV.coverage_sample_resolve + +This module customises the behaviour of the +OpenGL.raw.EGL.NV.coverage_sample_resolve to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/coverage_sample_resolve.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.EGL import _types, _glgets +from OpenGL.raw.EGL.NV.coverage_sample_resolve import * +from OpenGL.raw.EGL.NV.coverage_sample_resolve import _EXTENSION_NAME + +def glInitCoverageSampleResolveNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/NV/cuda_event.py b/venv/lib/python3.12/site-packages/OpenGL/EGL/NV/cuda_event.py new file mode 100644 index 00000000..194d1a8b --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/EGL/NV/cuda_event.py @@ -0,0 +1,23 @@ +'''OpenGL extension NV.cuda_event + +This module customises the behaviour of the +OpenGL.raw.EGL.NV.cuda_event to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/cuda_event.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.EGL import _types, _glgets +from OpenGL.raw.EGL.NV.cuda_event import * +from OpenGL.raw.EGL.NV.cuda_event import _EXTENSION_NAME + +def glInitCudaEventNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/NV/depth_nonlinear.py b/venv/lib/python3.12/site-packages/OpenGL/EGL/NV/depth_nonlinear.py new file mode 100644 index 00000000..5c3403e3 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/EGL/NV/depth_nonlinear.py @@ -0,0 +1,23 @@ +'''OpenGL extension NV.depth_nonlinear + +This module customises the behaviour of the +OpenGL.raw.EGL.NV.depth_nonlinear to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/depth_nonlinear.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.EGL import _types, _glgets +from OpenGL.raw.EGL.NV.depth_nonlinear import * +from OpenGL.raw.EGL.NV.depth_nonlinear import _EXTENSION_NAME + +def glInitDepthNonlinearNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/NV/device_cuda.py b/venv/lib/python3.12/site-packages/OpenGL/EGL/NV/device_cuda.py new file mode 100644 index 00000000..75aed6fa --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/EGL/NV/device_cuda.py @@ -0,0 +1,23 @@ +'''OpenGL extension NV.device_cuda + +This module customises the behaviour of the +OpenGL.raw.EGL.NV.device_cuda to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/device_cuda.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.EGL import _types, _glgets +from OpenGL.raw.EGL.NV.device_cuda import * +from OpenGL.raw.EGL.NV.device_cuda import _EXTENSION_NAME + +def glInitDeviceCudaNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/NV/native_query.py b/venv/lib/python3.12/site-packages/OpenGL/EGL/NV/native_query.py new file mode 100644 index 00000000..6224d8ed --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/EGL/NV/native_query.py @@ -0,0 +1,23 @@ +'''OpenGL extension NV.native_query + +This module customises the behaviour of the +OpenGL.raw.EGL.NV.native_query to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/native_query.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.EGL import _types, _glgets +from OpenGL.raw.EGL.NV.native_query import * +from OpenGL.raw.EGL.NV.native_query import _EXTENSION_NAME + +def glInitNativeQueryNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/NV/post_convert_rounding.py b/venv/lib/python3.12/site-packages/OpenGL/EGL/NV/post_convert_rounding.py new file mode 100644 index 00000000..5da41dba --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/EGL/NV/post_convert_rounding.py @@ -0,0 +1,23 @@ +'''OpenGL extension NV.post_convert_rounding + +This module customises the behaviour of the +OpenGL.raw.EGL.NV.post_convert_rounding to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/post_convert_rounding.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.EGL import _types, _glgets +from OpenGL.raw.EGL.NV.post_convert_rounding import * +from OpenGL.raw.EGL.NV.post_convert_rounding import _EXTENSION_NAME + +def glInitPostConvertRoundingNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/NV/post_sub_buffer.py b/venv/lib/python3.12/site-packages/OpenGL/EGL/NV/post_sub_buffer.py new file mode 100644 index 00000000..a5501410 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/EGL/NV/post_sub_buffer.py @@ -0,0 +1,23 @@ +'''OpenGL extension NV.post_sub_buffer + +This module customises the behaviour of the +OpenGL.raw.EGL.NV.post_sub_buffer to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/post_sub_buffer.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.EGL import _types, _glgets +from OpenGL.raw.EGL.NV.post_sub_buffer import * +from OpenGL.raw.EGL.NV.post_sub_buffer import _EXTENSION_NAME + +def glInitPostSubBufferNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/NV/stream_consumer_gltexture_yuv.py b/venv/lib/python3.12/site-packages/OpenGL/EGL/NV/stream_consumer_gltexture_yuv.py new file mode 100644 index 00000000..d1674801 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/EGL/NV/stream_consumer_gltexture_yuv.py @@ -0,0 +1,23 @@ +'''OpenGL extension NV.stream_consumer_gltexture_yuv + +This module customises the behaviour of the +OpenGL.raw.EGL.NV.stream_consumer_gltexture_yuv to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/stream_consumer_gltexture_yuv.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.EGL import _types, _glgets +from OpenGL.raw.EGL.NV.stream_consumer_gltexture_yuv import * +from OpenGL.raw.EGL.NV.stream_consumer_gltexture_yuv import _EXTENSION_NAME + +def glInitStreamConsumerGltextureYuvNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/NV/stream_metadata.py b/venv/lib/python3.12/site-packages/OpenGL/EGL/NV/stream_metadata.py new file mode 100644 index 00000000..9f72d148 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/EGL/NV/stream_metadata.py @@ -0,0 +1,23 @@ +'''OpenGL extension NV.stream_metadata + +This module customises the behaviour of the +OpenGL.raw.EGL.NV.stream_metadata to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/stream_metadata.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.EGL import _types, _glgets +from OpenGL.raw.EGL.NV.stream_metadata import * +from OpenGL.raw.EGL.NV.stream_metadata import _EXTENSION_NAME + +def glInitStreamMetadataNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/NV/stream_sync.py b/venv/lib/python3.12/site-packages/OpenGL/EGL/NV/stream_sync.py new file mode 100644 index 00000000..79be8c6c --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/EGL/NV/stream_sync.py @@ -0,0 +1,23 @@ +'''OpenGL extension NV.stream_sync + +This module customises the behaviour of the +OpenGL.raw.EGL.NV.stream_sync to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/stream_sync.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.EGL import _types, _glgets +from OpenGL.raw.EGL.NV.stream_sync import * +from OpenGL.raw.EGL.NV.stream_sync import _EXTENSION_NAME + +def glInitStreamSyncNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/NV/sync.py b/venv/lib/python3.12/site-packages/OpenGL/EGL/NV/sync.py new file mode 100644 index 00000000..821f09de --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/EGL/NV/sync.py @@ -0,0 +1,23 @@ +'''OpenGL extension NV.sync + +This module customises the behaviour of the +OpenGL.raw.EGL.NV.sync to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/sync.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.EGL import _types, _glgets +from OpenGL.raw.EGL.NV.sync import * +from OpenGL.raw.EGL.NV.sync import _EXTENSION_NAME + +def glInitSyncNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/NV/system_time.py b/venv/lib/python3.12/site-packages/OpenGL/EGL/NV/system_time.py new file mode 100644 index 00000000..1aff5c9c --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/EGL/NV/system_time.py @@ -0,0 +1,23 @@ +'''OpenGL extension NV.system_time + +This module customises the behaviour of the +OpenGL.raw.EGL.NV.system_time to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/system_time.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.EGL import _types, _glgets +from OpenGL.raw.EGL.NV.system_time import * +from OpenGL.raw.EGL.NV.system_time import _EXTENSION_NAME + +def glInitSystemTimeNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/TIZEN/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/EGL/TIZEN/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/EGL/TIZEN/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/TIZEN/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/EGL/TIZEN/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..bb0152ae Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/EGL/TIZEN/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/TIZEN/__pycache__/image_native_buffer.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/EGL/TIZEN/__pycache__/image_native_buffer.cpython-312.pyc new file mode 100644 index 00000000..87c3d788 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/EGL/TIZEN/__pycache__/image_native_buffer.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/TIZEN/__pycache__/image_native_surface.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/EGL/TIZEN/__pycache__/image_native_surface.cpython-312.pyc new file mode 100644 index 00000000..2cba330f Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/EGL/TIZEN/__pycache__/image_native_surface.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/TIZEN/image_native_buffer.py b/venv/lib/python3.12/site-packages/OpenGL/EGL/TIZEN/image_native_buffer.py new file mode 100644 index 00000000..737df554 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/EGL/TIZEN/image_native_buffer.py @@ -0,0 +1,23 @@ +'''OpenGL extension TIZEN.image_native_buffer + +This module customises the behaviour of the +OpenGL.raw.EGL.TIZEN.image_native_buffer to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/TIZEN/image_native_buffer.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.EGL import _types, _glgets +from OpenGL.raw.EGL.TIZEN.image_native_buffer import * +from OpenGL.raw.EGL.TIZEN.image_native_buffer import _EXTENSION_NAME + +def glInitImageNativeBufferTIZEN(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/TIZEN/image_native_surface.py b/venv/lib/python3.12/site-packages/OpenGL/EGL/TIZEN/image_native_surface.py new file mode 100644 index 00000000..37521dfc --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/EGL/TIZEN/image_native_surface.py @@ -0,0 +1,23 @@ +'''OpenGL extension TIZEN.image_native_surface + +This module customises the behaviour of the +OpenGL.raw.EGL.TIZEN.image_native_surface to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/TIZEN/image_native_surface.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.EGL import _types, _glgets +from OpenGL.raw.EGL.TIZEN.image_native_surface import * +from OpenGL.raw.EGL.TIZEN.image_native_surface import _EXTENSION_NAME + +def glInitImageNativeSurfaceTIZEN(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/VERSION/EGL_1_0.py b/venv/lib/python3.12/site-packages/OpenGL/EGL/VERSION/EGL_1_0.py new file mode 100644 index 00000000..3a399b25 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/EGL/VERSION/EGL_1_0.py @@ -0,0 +1,23 @@ +'''OpenGL extension VERSION.EGL_1_0 + +This module customises the behaviour of the +OpenGL.raw.EGL.VERSION.EGL_1_0 to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/VERSION/EGL_1_0.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.EGL import _types, _glgets +from OpenGL.raw.EGL.VERSION.EGL_1_0 import * +from OpenGL.raw.EGL.VERSION.EGL_1_0 import _EXTENSION_NAME + +def glInitEgl10VERSION(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/VERSION/EGL_1_1.py b/venv/lib/python3.12/site-packages/OpenGL/EGL/VERSION/EGL_1_1.py new file mode 100644 index 00000000..78d474a2 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/EGL/VERSION/EGL_1_1.py @@ -0,0 +1,23 @@ +'''OpenGL extension VERSION.EGL_1_1 + +This module customises the behaviour of the +OpenGL.raw.EGL.VERSION.EGL_1_1 to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/VERSION/EGL_1_1.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.EGL import _types, _glgets +from OpenGL.raw.EGL.VERSION.EGL_1_1 import * +from OpenGL.raw.EGL.VERSION.EGL_1_1 import _EXTENSION_NAME + +def glInitEgl11VERSION(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/VERSION/EGL_1_2.py b/venv/lib/python3.12/site-packages/OpenGL/EGL/VERSION/EGL_1_2.py new file mode 100644 index 00000000..bd326144 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/EGL/VERSION/EGL_1_2.py @@ -0,0 +1,23 @@ +'''OpenGL extension VERSION.EGL_1_2 + +This module customises the behaviour of the +OpenGL.raw.EGL.VERSION.EGL_1_2 to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/VERSION/EGL_1_2.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.EGL import _types, _glgets +from OpenGL.raw.EGL.VERSION.EGL_1_2 import * +from OpenGL.raw.EGL.VERSION.EGL_1_2 import _EXTENSION_NAME + +def glInitEgl12VERSION(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/VERSION/EGL_1_3.py b/venv/lib/python3.12/site-packages/OpenGL/EGL/VERSION/EGL_1_3.py new file mode 100644 index 00000000..67db5f4a --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/EGL/VERSION/EGL_1_3.py @@ -0,0 +1,23 @@ +'''OpenGL extension VERSION.EGL_1_3 + +This module customises the behaviour of the +OpenGL.raw.EGL.VERSION.EGL_1_3 to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/VERSION/EGL_1_3.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.EGL import _types, _glgets +from OpenGL.raw.EGL.VERSION.EGL_1_3 import * +from OpenGL.raw.EGL.VERSION.EGL_1_3 import _EXTENSION_NAME + +def glInitEgl13VERSION(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/VERSION/EGL_1_4.py b/venv/lib/python3.12/site-packages/OpenGL/EGL/VERSION/EGL_1_4.py new file mode 100644 index 00000000..c349ec45 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/EGL/VERSION/EGL_1_4.py @@ -0,0 +1,23 @@ +'''OpenGL extension VERSION.EGL_1_4 + +This module customises the behaviour of the +OpenGL.raw.EGL.VERSION.EGL_1_4 to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/VERSION/EGL_1_4.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.EGL import _types, _glgets +from OpenGL.raw.EGL.VERSION.EGL_1_4 import * +from OpenGL.raw.EGL.VERSION.EGL_1_4 import _EXTENSION_NAME + +def glInitEgl14VERSION(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/VERSION/EGL_1_5.py b/venv/lib/python3.12/site-packages/OpenGL/EGL/VERSION/EGL_1_5.py new file mode 100644 index 00000000..1a0f757d --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/EGL/VERSION/EGL_1_5.py @@ -0,0 +1,33 @@ +'''OpenGL extension VERSION.EGL_1_5 + +This module customises the behaviour of the +OpenGL.raw.EGL.VERSION.EGL_1_5 to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/VERSION/EGL_1_5.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.EGL import _types, _glgets +from OpenGL.raw.EGL.VERSION.EGL_1_5 import * +from OpenGL.raw.EGL.VERSION.EGL_1_5 import _EXTENSION_NAME + +def glInitEgl15VERSION(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION +from ..EXT.platform_base import eglGetPlatformDisplayEXT +from OpenGL.extensions import alternate as _alternate +eglGetPlatformDisplay.extension = None +eglGetPlatformDisplay.force_extension = True + +eglGetPlatformDisplay = _alternate( + 'eglGetPlatformDisplay', + eglGetPlatformDisplayEXT, + eglGetPlatformDisplay, +) \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/VERSION/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/EGL/VERSION/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/EGL/VERSION/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/VERSION/__pycache__/EGL_1_0.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/EGL/VERSION/__pycache__/EGL_1_0.cpython-312.pyc new file mode 100644 index 00000000..4ce7f2dc Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/EGL/VERSION/__pycache__/EGL_1_0.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/VERSION/__pycache__/EGL_1_1.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/EGL/VERSION/__pycache__/EGL_1_1.cpython-312.pyc new file mode 100644 index 00000000..8c93f056 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/EGL/VERSION/__pycache__/EGL_1_1.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/VERSION/__pycache__/EGL_1_2.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/EGL/VERSION/__pycache__/EGL_1_2.cpython-312.pyc new file mode 100644 index 00000000..7fbb50bb Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/EGL/VERSION/__pycache__/EGL_1_2.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/VERSION/__pycache__/EGL_1_3.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/EGL/VERSION/__pycache__/EGL_1_3.cpython-312.pyc new file mode 100644 index 00000000..3655fb6a Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/EGL/VERSION/__pycache__/EGL_1_3.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/VERSION/__pycache__/EGL_1_4.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/EGL/VERSION/__pycache__/EGL_1_4.cpython-312.pyc new file mode 100644 index 00000000..413c500e Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/EGL/VERSION/__pycache__/EGL_1_4.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/VERSION/__pycache__/EGL_1_5.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/EGL/VERSION/__pycache__/EGL_1_5.cpython-312.pyc new file mode 100644 index 00000000..c91999bd Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/EGL/VERSION/__pycache__/EGL_1_5.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/VERSION/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/EGL/VERSION/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..ce8922ab Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/EGL/VERSION/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/EGL/__init__.py new file mode 100644 index 00000000..3db6aa75 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/EGL/__init__.py @@ -0,0 +1,9 @@ +"""OpenGL.EGL the portable interface to GL environments""" +from OpenGL.raw.EGL._types import * +from OpenGL.raw.EGL._errors import EGLError +from OpenGL.EGL.VERSION.EGL_1_0 import * +from OpenGL.EGL.VERSION.EGL_1_1 import * +from OpenGL.EGL.VERSION.EGL_1_2 import * +from OpenGL.EGL.VERSION.EGL_1_3 import * +from OpenGL.EGL.VERSION.EGL_1_4 import * +from OpenGL.EGL.VERSION.EGL_1_5 import * diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/EGL/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..afc21fc7 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/EGL/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/__pycache__/debug.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/EGL/__pycache__/debug.cpython-312.pyc new file mode 100644 index 00000000..7c011254 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/EGL/__pycache__/debug.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/__pycache__/gbmdevice.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/EGL/__pycache__/gbmdevice.cpython-312.pyc new file mode 100644 index 00000000..829e6a3b Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/EGL/__pycache__/gbmdevice.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/debug.py b/venv/lib/python3.12/site-packages/OpenGL/EGL/debug.py new file mode 100644 index 00000000..c0e36466 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/EGL/debug.py @@ -0,0 +1,245 @@ +"""Debug utilities for EGL operations""" +from OpenGL.EGL import * +import itertools + + +def eglErrorName(value): + """Returns error constant if known, otherwise returns value""" + return KNOWN_ERRORS.get(value, value) + + +KNOWN_ERRORS = { + EGL_SUCCESS: EGL_SUCCESS, + EGL_NOT_INITIALIZED: EGL_NOT_INITIALIZED, + EGL_BAD_ACCESS: EGL_BAD_ACCESS, + EGL_BAD_ALLOC: EGL_BAD_ALLOC, + EGL_BAD_ATTRIBUTE: EGL_BAD_ATTRIBUTE, + EGL_BAD_CONTEXT: EGL_BAD_CONTEXT, + EGL_BAD_CONFIG: EGL_BAD_CONFIG, + EGL_BAD_CURRENT_SURFACE: EGL_BAD_CURRENT_SURFACE, + EGL_BAD_DISPLAY: EGL_BAD_DISPLAY, + EGL_BAD_SURFACE: EGL_BAD_SURFACE, + EGL_BAD_MATCH: EGL_BAD_MATCH, + EGL_BAD_PARAMETER: EGL_BAD_PARAMETER, + EGL_BAD_NATIVE_PIXMAP: EGL_BAD_NATIVE_PIXMAP, + EGL_BAD_NATIVE_WINDOW: EGL_BAD_NATIVE_WINDOW, + EGL_CONTEXT_LOST: EGL_CONTEXT_LOST, +} + + +def write_ppm(buf, filename): + """Write height * width * 3-component buffer as ppm to filename + + This lets us write a simple image format without + using any libraries that can be viewed on most + linux workstations. + """ + with open(filename, "w") as f: + (h, w, c) = buf.shape + f.write("P3\n") + f.write("# ascii ppm file created by pyopengl\n") + f.write("%i %i\n" % (w, h)) + f.write("255\n") + for y in range(h - 1, -1, -1): + for x in range(w): + pixel = buf[y, x] + l = " %3d %3d %3d" % (pixel[0], pixel[1], pixel[2]) + f.write(l) + f.write("\n") + + +def debug_config(display, config): + """Get debug display for the given configuration""" + result = {} + value = EGLint() + for attr in CONFIG_ATTRS: + if not eglGetConfigAttrib(display, config, attr, value): + log.warning("Failed to get attribute %s from config", attr) + continue + if attr in BITMASK_FIELDS: + attr_value = {} + for subattr in BITMASK_FIELDS[attr]: + if value.value & subattr: + attr_value[subattr.name] = True + else: + attr_value = value.value + result[attr.name] = attr_value + return result + + +def debug_configs(display, configs=None, max_count=256): + """Present a formatted list of configs for the display""" + if configs is None: + configs = (EGLConfig * max_count)() + num_configs = EGLint() + eglGetConfigs(display, configs, max_count, num_configs) + if not num_configs.value: + return [] + configs = configs[: num_configs.value] + debug_configs = [debug_config(display, cfg) for cfg in configs] + return debug_configs + + +SURFACE_TYPE_BITS = [ + EGL_MULTISAMPLE_RESOLVE_BOX_BIT, + EGL_PBUFFER_BIT, + EGL_PIXMAP_BIT, + EGL_SWAP_BEHAVIOR_PRESERVED_BIT, + EGL_VG_ALPHA_FORMAT_PRE_BIT, + EGL_VG_COLORSPACE_LINEAR_BIT, + EGL_WINDOW_BIT, +] +RENDERABLE_TYPE_BITS = [ + EGL_OPENGL_BIT, + EGL_OPENGL_ES_BIT, + EGL_OPENGL_ES2_BIT, + EGL_OPENGL_ES3_BIT, + EGL_OPENVG_BIT, +] +CAVEAT_BITS = [ + EGL_NONE, + EGL_SLOW_CONFIG, + EGL_NON_CONFORMANT_CONFIG, +] +TRANSPARENT_BITS = [ + EGL_NONE, + EGL_TRANSPARENT_RGB, +] + +CONFIG_ATTRS = [ + EGL_CONFIG_ID, + EGL_RED_SIZE, + EGL_GREEN_SIZE, + EGL_BLUE_SIZE, + EGL_DEPTH_SIZE, + EGL_ALPHA_SIZE, + EGL_ALPHA_MASK_SIZE, + EGL_BUFFER_SIZE, + EGL_STENCIL_SIZE, + EGL_BIND_TO_TEXTURE_RGB, + EGL_BIND_TO_TEXTURE_RGBA, + EGL_COLOR_BUFFER_TYPE, + EGL_CONFIG_CAVEAT, + EGL_CONFORMANT, + EGL_LEVEL, + EGL_LUMINANCE_SIZE, + EGL_MAX_PBUFFER_WIDTH, + EGL_MAX_PBUFFER_HEIGHT, + EGL_MAX_PBUFFER_PIXELS, + EGL_MIN_SWAP_INTERVAL, + EGL_MAX_SWAP_INTERVAL, + EGL_NATIVE_RENDERABLE, + EGL_NATIVE_VISUAL_ID, + EGL_NATIVE_VISUAL_TYPE, + EGL_RENDERABLE_TYPE, + EGL_SAMPLE_BUFFERS, + EGL_SAMPLES, + EGL_SURFACE_TYPE, + EGL_TRANSPARENT_TYPE, + EGL_TRANSPARENT_RED_VALUE, + EGL_TRANSPARENT_GREEN_VALUE, + EGL_TRANSPARENT_BLUE_VALUE, +] + +BITMASK_FIELDS = dict( + [ + (EGL_SURFACE_TYPE, SURFACE_TYPE_BITS), + (EGL_RENDERABLE_TYPE, RENDERABLE_TYPE_BITS), + (EGL_CONFORMANT, RENDERABLE_TYPE_BITS), + (EGL_CONFIG_CAVEAT, CAVEAT_BITS), + (EGL_TRANSPARENT_TYPE, TRANSPARENT_BITS), + ] +) + + +def bit_renderer(bit): + def render(value): + if bit.name in value: + return " Y" + else: + return " ." + + return render + + +CONFIG_FORMAT = [ + (EGL_CONFIG_ID, "0x%x", "id", "cfg"), + (EGL_BUFFER_SIZE, "%i", "sz", "bf"), + (EGL_LEVEL, "%i", "l", "lv"), + (EGL_RED_SIZE, "%i", "r", "cbuf"), + (EGL_GREEN_SIZE, "%i", "g", "cbuf"), + (EGL_BLUE_SIZE, "%i", "b", "cbuf"), + (EGL_ALPHA_SIZE, "%i", "a", "cbuf"), + (EGL_DEPTH_SIZE, "%i", "th", "dp"), + (EGL_STENCIL_SIZE, "%i", "t", "s"), + (EGL_SAMPLES, "%i", "ns", "mult"), + (EGL_SAMPLE_BUFFERS, "%i", "bu", "mult"), + (EGL_NATIVE_VISUAL_ID, "0x%x", "id", "visual"), + (EGL_RENDERABLE_TYPE, bit_renderer(EGL_OPENGL_BIT), "gl", "render"), + (EGL_RENDERABLE_TYPE, bit_renderer(EGL_OPENGL_ES_BIT), "es", "render"), + (EGL_RENDERABLE_TYPE, bit_renderer(EGL_OPENGL_ES2_BIT), "e2", "render"), + (EGL_RENDERABLE_TYPE, bit_renderer(EGL_OPENGL_ES3_BIT), "e3", "render"), + (EGL_RENDERABLE_TYPE, bit_renderer(EGL_OPENVG_BIT), "vg", "render"), + (EGL_SURFACE_TYPE, bit_renderer(EGL_WINDOW_BIT), "wn", "surface"), + (EGL_SURFACE_TYPE, bit_renderer(EGL_PBUFFER_BIT), "pb", "surface"), + (EGL_SURFACE_TYPE, bit_renderer(EGL_PIXMAP_BIT), "px", "surface"), +] + + +def format_debug_configs(debug_configs, formats=CONFIG_FORMAT): + """Format config for compact debugging display + + Produces a config summary display for a set of + debug_configs as a text-mode table. + + Uses `formats` (default `CONFIG_FORMAT`) to determine + which fields are extracted and how they are formatted + along with the column/subcolum set to be rendered in + the overall header. + + returns formatted ASCII table for display in debug + logs or utilities + """ + columns = [] + for (key, format, subcol, col) in formats: + column = [] + max_width = 0 + for row in debug_configs: + if isinstance(row, EGLConfig): + raise TypeError(row, "Call debug_config(display,config)") + try: + value = row[key.name] + except KeyError: + formatted = "_" + else: + if isinstance(format, str): + formatted = format % (value) + else: + formatted = format(value) + max_width = max((len(formatted), max_width)) + column.append(formatted) + columns.append( + { + "rows": column, + "key": key, + "format": format, + "subcol": subcol, + "col": col, + "width": max_width, + } + ) + headers = [] + subheaders = [] + rows = [headers, subheaders] + last_column = None + last_column_width = 0 + for header, subcols in itertools.groupby(columns, lambda x: x["col"]): + subcols = list(subcols) + width = sum([col["width"] for col in subcols]) + (len(subcols) - 1) + headers.append(header.center(width, ".")[:width]) + for column in columns: + subheaders.append(column["subcol"].rjust(column["width"])[: column["width"]]) + rows.extend( + zip(*[[v.rjust(col["width"], " ") for v in col["rows"]] for col in columns]) + ) + return "\n".join([" ".join(row) for row in rows]) diff --git a/venv/lib/python3.12/site-packages/OpenGL/EGL/gbmdevice.py b/venv/lib/python3.12/site-packages/OpenGL/EGL/gbmdevice.py new file mode 100644 index 00000000..66a55467 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/EGL/gbmdevice.py @@ -0,0 +1,114 @@ +"""Utility module for interacting with GBM to select rendering device + +The base code here comes from github bug report #6 in the pyopengl +project, thanks to @abandoned-cocoon for that. +""" +import weakref, ctypes, logging, os, glob +from OpenGL.platform import ctypesloader +from OpenGL import _opaque +log = logging.getLogger(__name__) +gbm = ctypesloader.loadLibrary(ctypes.CDLL,"gbm") +__all__ = ('enumerate_devices','open_device','close_device','gbm') +_DEVICE_HANDLES = {} +GBM_BO_USE_SCANOUT = (1 << 0) +GBM_BO_USE_CURSOR = (1 << 1) +GBM_BO_USE_CURSOR_64X64 = GBM_BO_USE_CURSOR +GBM_BO_USE_RENDERING = (1 << 2) +GBM_BO_USE_WRITE = (1 << 3) +GBM_BO_USE_LINEAR = (1 << 4) + +GBMDevice = _opaque.opaque_pointer_cls('GBMDevice') +GBMSurface = _opaque.opaque_pointer_cls('GBMSurface') +gbm.gbm_create_device.restype = GBMDevice +gbm.gbm_surface_create.restype = GBMSurface + +def filter_bad_drivers(cards, bad_drivers=('nvidia',)): + """Lookup the driver for each card to exclude loading nvidia devices""" + # this is pci specific, which I suppose means we're going to fail + # if the GPU isn't on the PCI bus, but we don't seem to have + # another way to match up the card to the driver :( + bad_cards = set() + for link in glob.glob('/dev/dri/by-path/pci-*-card'): + base = os.path.basename(link) + pci_id = base[4:-5] + driver = os.path.basename(os.readlink('/sys/bus/pci/devices/%s/driver'%(pci_id,))) + if driver in bad_drivers: + card = os.path.basename(os.readlink(link)) + log.debug("Skipping %s because it uses %s driver",card,driver) + bad_cards.add(card) + filtered = [ + card for card in cards + if os.path.basename(card) not in bad_cards + ] + # assert len(filtered) == 1, filtered + return filtered + +def enumerate_devices(): + """Enumerate the set of gbm renderD* devices on the system + + Attempts to filter out any nvidia drivers with filter_bad_drivers + along the way. + """ + import glob + # gbm says card* is the correct entry point... + return filter_bad_drivers(sorted(glob.glob('/dev/dri/card*'))) +def open_device(path): + """Open a particular gbm device + + * path -- integer index of devices in sorted enumeration, or + device basename (`renderD128`) or a full path-name + as returned from enumerate_devices + + Will raise (at least): + + * RuntimeError for invalid indices + * IOError/OSError for device access failures + * RuntimeError if we cannot create the gbm device + + Caller is responsible for calling close_device(display) on the + resulting opaque pointer in order to release the open file-handle + and deallocate the gbm_device record. + + returns GBMDevice, an opaque pointer + """ + if isinstance(path,int): + try: + devices = enumerate_devices() + path = devices[int] + except IndexError: + raise RuntimeError('Only %s devices available, cannot use 0-index %s'%(len(devices),path)) + else: + path = os.path.join('/dev/dri',path) # allow for specifying "renderD128" + log.debug("Final device path: %s", path) + fh = open(path,'w') + dev = gbm.gbm_create_device(fh.fileno()) + if dev == 0: + fh.close() + raise RuntimeError('Unable to create rendering device for: %s'%(path)) + _DEVICE_HANDLES[dev] = fh + return dev +def close_device(device): + """Close an opened gbm device""" + gbm.gbm_device_destroy(device) + try: + handle = _DEVICE_HANDLES.pop(device) + handle.close() + except KeyError: + pass + +def create_surface(device, width=512, height=512, format=None, flags=GBM_BO_USE_RENDERING): + """Create a GBM surface to use on the given device + + devices -- opaque GBMDevice pointer + width,height -- dimensions + format -- EGL_NATIVE_VISUAL_ID from an EGL configuration + flags -- surface flags regarding reading/writing pattern that + is expected for the buffer + + returns GBMSurface opaque pointer + """ + if not format: + raise ValueError( + 'Use eglGetConfigAttrib(display,config,EGL_NATIVE_VISUAL_ID) to get the native surface format', + ) + return gbm.gbm_surface_create(device, width, height, format, flags) \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..4319c465 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/__pycache__/blend_minmax_factor.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/__pycache__/blend_minmax_factor.cpython-312.pyc new file mode 100644 index 00000000..304d910a Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/__pycache__/blend_minmax_factor.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/__pycache__/conservative_depth.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/__pycache__/conservative_depth.cpython-312.pyc new file mode 100644 index 00000000..4fad9b46 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/__pycache__/conservative_depth.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/__pycache__/debug_output.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/__pycache__/debug_output.cpython-312.pyc new file mode 100644 index 00000000..fb0eca52 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/__pycache__/debug_output.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/__pycache__/depth_clamp_separate.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/__pycache__/depth_clamp_separate.cpython-312.pyc new file mode 100644 index 00000000..507d91bf Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/__pycache__/depth_clamp_separate.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/__pycache__/draw_buffers_blend.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/__pycache__/draw_buffers_blend.cpython-312.pyc new file mode 100644 index 00000000..65c89382 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/__pycache__/draw_buffers_blend.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/__pycache__/framebuffer_multisample_advanced.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/__pycache__/framebuffer_multisample_advanced.cpython-312.pyc new file mode 100644 index 00000000..ff4a5211 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/__pycache__/framebuffer_multisample_advanced.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/__pycache__/framebuffer_sample_positions.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/__pycache__/framebuffer_sample_positions.cpython-312.pyc new file mode 100644 index 00000000..9b9b75f4 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/__pycache__/framebuffer_sample_positions.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/__pycache__/gcn_shader.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/__pycache__/gcn_shader.cpython-312.pyc new file mode 100644 index 00000000..dcdac8ae Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/__pycache__/gcn_shader.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/__pycache__/gpu_shader_half_float.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/__pycache__/gpu_shader_half_float.cpython-312.pyc new file mode 100644 index 00000000..e5bb3915 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/__pycache__/gpu_shader_half_float.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/__pycache__/gpu_shader_int16.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/__pycache__/gpu_shader_int16.cpython-312.pyc new file mode 100644 index 00000000..b0335340 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/__pycache__/gpu_shader_int16.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/__pycache__/gpu_shader_int64.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/__pycache__/gpu_shader_int64.cpython-312.pyc new file mode 100644 index 00000000..2f67f3e3 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/__pycache__/gpu_shader_int64.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/__pycache__/interleaved_elements.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/__pycache__/interleaved_elements.cpython-312.pyc new file mode 100644 index 00000000..210fc103 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/__pycache__/interleaved_elements.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/__pycache__/multi_draw_indirect.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/__pycache__/multi_draw_indirect.cpython-312.pyc new file mode 100644 index 00000000..d9f8b329 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/__pycache__/multi_draw_indirect.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/__pycache__/name_gen_delete.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/__pycache__/name_gen_delete.cpython-312.pyc new file mode 100644 index 00000000..4701eaa4 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/__pycache__/name_gen_delete.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/__pycache__/occlusion_query_event.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/__pycache__/occlusion_query_event.cpython-312.pyc new file mode 100644 index 00000000..7dfaf17c Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/__pycache__/occlusion_query_event.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/__pycache__/performance_monitor.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/__pycache__/performance_monitor.cpython-312.pyc new file mode 100644 index 00000000..c15d9040 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/__pycache__/performance_monitor.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/__pycache__/pinned_memory.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/__pycache__/pinned_memory.cpython-312.pyc new file mode 100644 index 00000000..a92d28ea Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/__pycache__/pinned_memory.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/__pycache__/query_buffer_object.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/__pycache__/query_buffer_object.cpython-312.pyc new file mode 100644 index 00000000..0f108dfc Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/__pycache__/query_buffer_object.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/__pycache__/sample_positions.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/__pycache__/sample_positions.cpython-312.pyc new file mode 100644 index 00000000..5060b052 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/__pycache__/sample_positions.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/__pycache__/seamless_cubemap_per_texture.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/__pycache__/seamless_cubemap_per_texture.cpython-312.pyc new file mode 100644 index 00000000..79a3e4da Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/__pycache__/seamless_cubemap_per_texture.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/__pycache__/shader_atomic_counter_ops.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/__pycache__/shader_atomic_counter_ops.cpython-312.pyc new file mode 100644 index 00000000..7481aacb Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/__pycache__/shader_atomic_counter_ops.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/__pycache__/shader_ballot.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/__pycache__/shader_ballot.cpython-312.pyc new file mode 100644 index 00000000..dd4f5b02 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/__pycache__/shader_ballot.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/__pycache__/shader_explicit_vertex_parameter.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/__pycache__/shader_explicit_vertex_parameter.cpython-312.pyc new file mode 100644 index 00000000..b577d1d6 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/__pycache__/shader_explicit_vertex_parameter.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/__pycache__/shader_gpu_shader_half_float_fetch.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/__pycache__/shader_gpu_shader_half_float_fetch.cpython-312.pyc new file mode 100644 index 00000000..b697a11d Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/__pycache__/shader_gpu_shader_half_float_fetch.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/__pycache__/shader_image_load_store_lod.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/__pycache__/shader_image_load_store_lod.cpython-312.pyc new file mode 100644 index 00000000..8e0c63c2 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/__pycache__/shader_image_load_store_lod.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/__pycache__/shader_stencil_export.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/__pycache__/shader_stencil_export.cpython-312.pyc new file mode 100644 index 00000000..becd2cad Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/__pycache__/shader_stencil_export.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/__pycache__/shader_trinary_minmax.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/__pycache__/shader_trinary_minmax.cpython-312.pyc new file mode 100644 index 00000000..028f55d9 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/__pycache__/shader_trinary_minmax.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/__pycache__/sparse_texture.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/__pycache__/sparse_texture.cpython-312.pyc new file mode 100644 index 00000000..d8874598 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/__pycache__/sparse_texture.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/__pycache__/stencil_operation_extended.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/__pycache__/stencil_operation_extended.cpython-312.pyc new file mode 100644 index 00000000..4d533b09 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/__pycache__/stencil_operation_extended.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/__pycache__/texture_gather_bias_lod.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/__pycache__/texture_gather_bias_lod.cpython-312.pyc new file mode 100644 index 00000000..1614c853 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/__pycache__/texture_gather_bias_lod.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/__pycache__/texture_texture4.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/__pycache__/texture_texture4.cpython-312.pyc new file mode 100644 index 00000000..b89914f3 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/__pycache__/texture_texture4.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/__pycache__/transform_feedback3_lines_triangles.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/__pycache__/transform_feedback3_lines_triangles.cpython-312.pyc new file mode 100644 index 00000000..5dc98c57 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/__pycache__/transform_feedback3_lines_triangles.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/__pycache__/transform_feedback4.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/__pycache__/transform_feedback4.cpython-312.pyc new file mode 100644 index 00000000..08f98303 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/__pycache__/transform_feedback4.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/__pycache__/vertex_shader_layer.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/__pycache__/vertex_shader_layer.cpython-312.pyc new file mode 100644 index 00000000..10a6cd4f Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/__pycache__/vertex_shader_layer.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/__pycache__/vertex_shader_tessellator.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/__pycache__/vertex_shader_tessellator.cpython-312.pyc new file mode 100644 index 00000000..f36866d2 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/__pycache__/vertex_shader_tessellator.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/__pycache__/vertex_shader_viewport_index.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/__pycache__/vertex_shader_viewport_index.cpython-312.pyc new file mode 100644 index 00000000..50e5586b Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/__pycache__/vertex_shader_viewport_index.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/blend_minmax_factor.py b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/blend_minmax_factor.py new file mode 100644 index 00000000..75e695ae --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/blend_minmax_factor.py @@ -0,0 +1,37 @@ +'''OpenGL extension AMD.blend_minmax_factor + +This module customises the behaviour of the +OpenGL.raw.GL.AMD.blend_minmax_factor to provide a more +Python-friendly API + +Overview (from the spec) + + The EXT_blend_minmax extension extended the GL's blending functionality + to allow the blending equation to be specified by the application. That + extension introduced the MIN_EXT and MAX_EXT blend equations, which caused the + result of the blend equation to become the minimum or maximum of the source + color and destination color, respectively. + + The MIN_EXT and MAX_EXT blend equations, however, do not include the source + or destination blend factors in the arguments to the min and max functions. + This extension provides two new blend equations that produce the minimum + or maximum of the products of the source color and source factor, and the + destination color and destination factor. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/AMD/blend_minmax_factor.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.AMD.blend_minmax_factor import * +from OpenGL.raw.GL.AMD.blend_minmax_factor import _EXTENSION_NAME + +def glInitBlendMinmaxFactorAMD(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/conservative_depth.py b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/conservative_depth.py new file mode 100644 index 00000000..98d57816 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/conservative_depth.py @@ -0,0 +1,39 @@ +'''OpenGL extension AMD.conservative_depth + +This module customises the behaviour of the +OpenGL.raw.GL.AMD.conservative_depth to provide a more +Python-friendly API + +Overview (from the spec) + + There is a common optimization for hardware accelerated implementation of + OpenGL which relies on an early depth test to be run before the fragment + shader so that the shader evaluation can be skipped if the fragment ends + up being discarded because it is occluded. + + This optimization does not affect the final rendering, and is typically + possible when the fragment does not change the depth programmatically. + (i.e.: it does not write to the built-in gl_FragDepth output). There are, + however a class of operations on the depth in the shader which could + still be performed while allowing the early depth test to operate. + + This extension allows the application to pass enough information to the + GL implementation to activate such optimizations safely. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/AMD/conservative_depth.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.AMD.conservative_depth import * +from OpenGL.raw.GL.AMD.conservative_depth import _EXTENSION_NAME + +def glInitConservativeDepthAMD(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/debug_output.py b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/debug_output.py new file mode 100644 index 00000000..a2ccad17 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/debug_output.py @@ -0,0 +1,88 @@ +'''OpenGL extension AMD.debug_output + +This module customises the behaviour of the +OpenGL.raw.GL.AMD.debug_output to provide a more +Python-friendly API + +Overview (from the spec) + + This extension allows the GL to notify applications when various + debug events occur in contexts that have been created with the debug + flag, as provided by WGL_ARB_create_context and GLX_ARB_create_context. + + These events are represented in the form of enumerable messages with an + included human-readable translation. Examples of debug events include + incorrect use of the GL, warnings of undefined behavior, and performance + warnings. + + A message is uniquely identified by a category and an implementation- + dependent ID within that category. Message categories are general and are + used to organize large groups of similar messages together. Examples of + categories include GL errors, performance warnings, and deprecated + functionality warnings. Each message is also assigned a severity level + that denotes roughly how "important" that message is in comparison to + other messages across all categories. For example, notification of a GL + error would have a higher severity than a performance warning due to + redundant state changes. + + Messages are communicated to the application through an application-defined + callback function that is called by the GL implementation on each debug + message. The motivation for the callback routine is to free application + developers from actively having to query whether any GL error or other + debuggable event has happened after each call to a GL function. With a + callback, developers can keep their code free of debug checks, and only have + to react to messages as they occur. In order to support indirect rendering, + a message log is also provided that stores copies of recent messages until + they are actively queried. + + To control the volume of debug output, messages can be disabled either + individually by ID, or entire groups of messages can be turned off based + on category or severity. + + The only requirement on the minimum quantity and type of messages that + implementations of this extension must support is that a message must be + sent notifying the application whenever any GL error occurs. Any further + messages are left to the implementation. Implementations do not have + to output messages from all categories listed by this extension + in order to support this extension, and new categories can be added by + other extensions. + + This extension places no restrictions or requirements on any additional + functionality provided by the debug context flag through other extensions. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/AMD/debug_output.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.AMD.debug_output import * +from OpenGL.raw.GL.AMD.debug_output import _EXTENSION_NAME + +def glInitDebugOutputAMD(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glDebugMessageEnableAMD.ids size not checked against count +glDebugMessageEnableAMD=wrapper.wrapper(glDebugMessageEnableAMD).setInputArraySize( + 'ids', None +) +# INPUT glDebugMessageInsertAMD.buf size not checked against length +glDebugMessageInsertAMD=wrapper.wrapper(glDebugMessageInsertAMD).setInputArraySize( + 'buf', None +) +# glDebugMessageCallbackAMD.userParam is OUTPUT without known output size +glGetDebugMessageLogAMD=wrapper.wrapper(glGetDebugMessageLogAMD).setOutput( + 'categories',size=lambda x:(x,),pnameArg='count',orPassIn=True +).setOutput( + 'ids',size=lambda x:(x,),pnameArg='count',orPassIn=True +).setOutput( + 'lengths',size=lambda x:(x,),pnameArg='count',orPassIn=True +).setOutput( + 'message',size=lambda x:(x,),pnameArg='bufsize',orPassIn=True +).setOutput( + 'severities',size=lambda x:(x,),pnameArg='count',orPassIn=True +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/depth_clamp_separate.py b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/depth_clamp_separate.py new file mode 100644 index 00000000..1e1c03ad --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/depth_clamp_separate.py @@ -0,0 +1,34 @@ +'''OpenGL extension AMD.depth_clamp_separate + +This module customises the behaviour of the +OpenGL.raw.GL.AMD.depth_clamp_separate to provide a more +Python-friendly API + +Overview (from the spec) + + The extension ARB_depth_clamp introduced the ability to control + the clamping of the depth value for both the near and far plane. + One limitation is that the control was for both planes at the + same time; some applications can benefit from having clamping + enabled for only one of the two planes, in order to save + fillrate for the other plane by clipping the geometry. + + This extension provides exactly such functionality. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/AMD/depth_clamp_separate.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.AMD.depth_clamp_separate import * +from OpenGL.raw.GL.AMD.depth_clamp_separate import _EXTENSION_NAME + +def glInitDepthClampSeparateAMD(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/draw_buffers_blend.py b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/draw_buffers_blend.py new file mode 100644 index 00000000..6626e856 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/draw_buffers_blend.py @@ -0,0 +1,34 @@ +'''OpenGL extension AMD.draw_buffers_blend + +This module customises the behaviour of the +OpenGL.raw.GL.AMD.draw_buffers_blend to provide a more +Python-friendly API + +Overview (from the spec) + + This extension builds upon the ARB_draw_buffers and EXT_draw_buffers2 + extensions. In ARB_draw_buffers (part of OpenGL 2.0), separate values + could be written to each color buffer. This was further enhanced by + EXT_draw_buffers2 by adding in the ability to enable blending and to set + color write masks independently per color output. + + This extension provides the ability to set individual blend equations and + blend functions for each color output. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/AMD/draw_buffers_blend.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.AMD.draw_buffers_blend import * +from OpenGL.raw.GL.AMD.draw_buffers_blend import _EXTENSION_NAME + +def glInitDrawBuffersBlendAMD(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/framebuffer_multisample_advanced.py b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/framebuffer_multisample_advanced.py new file mode 100644 index 00000000..f711fb17 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/framebuffer_multisample_advanced.py @@ -0,0 +1,46 @@ +'''OpenGL extension AMD.framebuffer_multisample_advanced + +This module customises the behaviour of the +OpenGL.raw.GL.AMD.framebuffer_multisample_advanced to provide a more +Python-friendly API + +Overview (from the spec) + + This extension extends ARB_framebuffer_object by allowing compromises + between image quality and memory footprint of multisample + antialiasing. + + ARB_framebuffer_object introduced RenderbufferStorageMultisample + as a method of defining the parameters for a multisample render + buffer. This function takes a parameter that has strict + requirements on behavior such that no compromises in the final image + quality are allowed. Additionally, ARB_framebuffer_object requires + that all framebuffer attachments have the same number of samples. + + This extension extends ARB_framebuffer_object by providing a new + function, RenderbufferStorageMultisampleAdvancedAMD, that + distinguishes between samples and storage samples for color + renderbuffers where the number of storage samples can be less than + the number of samples. This extension also allows non-matching sample + counts between color and depth/stencil renderbuffers. + + This extension does not require any specific combination of sample + counts to be supported. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/AMD/framebuffer_multisample_advanced.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.AMD.framebuffer_multisample_advanced import * +from OpenGL.raw.GL.AMD.framebuffer_multisample_advanced import _EXTENSION_NAME + +def glInitFramebufferMultisampleAdvancedAMD(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/framebuffer_sample_positions.py b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/framebuffer_sample_positions.py new file mode 100644 index 00000000..2ce65a85 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/framebuffer_sample_positions.py @@ -0,0 +1,44 @@ +'''OpenGL extension AMD.framebuffer_sample_positions + +This module customises the behaviour of the +OpenGL.raw.GL.AMD.framebuffer_sample_positions to provide a more +Python-friendly API + +Overview (from the spec) + + In unextended GL, the sub-pixel loations of multisampled textures and + renderbuffers are generally determined in an implementation dependent + manner. Some algorithms -- in particular custom antialiasing functions -- + depend on the knowledge of, or even require control over the positions of + samples within each pixel. + + The AMD_sample_positions extension added some control over the positions + of samples within a single framebuffer. However, it forced all pixels + within a framebuffer to have the set of sample positions. + + This extension provides a mechanism to explicitly set sample positions for + a framebuffer object with multi-sampled attachments in a repeating pattern, + allowing different pixels to use different sub-pixel locations for their + samples. The sample locations used by the FBO can be fixed for all pixels + in the FBOs attachments or they can be fixed for a sampling pattern + comprised of multiple pixels, where the sampling pattern is repeated over + all pixels. The rate of repeat of this sampling pattern size itself is + fixed and is implementation-dependent. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/AMD/framebuffer_sample_positions.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.AMD.framebuffer_sample_positions import * +from OpenGL.raw.GL.AMD.framebuffer_sample_positions import _EXTENSION_NAME + +def glInitFramebufferSamplePositionsAMD(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/gcn_shader.py b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/gcn_shader.py new file mode 100644 index 00000000..a27866d5 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/gcn_shader.py @@ -0,0 +1,31 @@ +'''OpenGL extension AMD.gcn_shader + +This module customises the behaviour of the +OpenGL.raw.GL.AMD.gcn_shader to provide a more +Python-friendly API + +Overview (from the spec) + + This extension exposes miscellaneous features of the AMD "Graphics Core + Next" shader architecture that do not cleanly fit into other extensions + and are not significant enough alone to warrant their own extensions. + This includes cross-SIMD lane ballots, cube map query functions and + a functionality to query the elapsed shader core time. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/AMD/gcn_shader.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.AMD.gcn_shader import * +from OpenGL.raw.GL.AMD.gcn_shader import _EXTENSION_NAME + +def glInitGcnShaderAMD(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/gpu_shader_half_float.py b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/gpu_shader_half_float.py new file mode 100644 index 00000000..1593cf18 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/gpu_shader_half_float.py @@ -0,0 +1,47 @@ +'''OpenGL extension AMD.gpu_shader_half_float + +This module customises the behaviour of the +OpenGL.raw.GL.AMD.gpu_shader_half_float to provide a more +Python-friendly API + +Overview (from the spec) + + This extension was developed based on the NV_gpu_shader5 extension to + allow implementations supporting half float in shader and expose the + feature without the additional requirements that are present in + NV_gpu_shader5. + + The extension introduces the following features for all shader types: + + * support for half float scalar, vector and matrix data types in shader; + + * new built-in functions to pack and unpack half float types into a + 32-bit integer vector; + + * half float support for all existing single float built-in functions, + including angle functions, exponential functions, common functions, + geometric functions, matrix functions and etc.; + + This extension is designed to be a functional superset of the half-precision + floating-point support from NV_gpu_shader5 and to keep source code compatible + with that, thus the new procedures, functions, and tokens are identical to + those found in that extension. + + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/AMD/gpu_shader_half_float.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.AMD.gpu_shader_half_float import * +from OpenGL.raw.GL.AMD.gpu_shader_half_float import _EXTENSION_NAME + +def glInitGpuShaderHalfFloatAMD(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/gpu_shader_int16.py b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/gpu_shader_int16.py new file mode 100644 index 00000000..f199a493 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/gpu_shader_int16.py @@ -0,0 +1,43 @@ +'''OpenGL extension AMD.gpu_shader_int16 + +This module customises the behaviour of the +OpenGL.raw.GL.AMD.gpu_shader_int16 to provide a more +Python-friendly API + +Overview (from the spec) + + This extension was developed to allow implementations supporting 16-bit + integers to expose the feature in GLSL. + + The extension introduces the following features for all shader types: + + * new built-in functions to pack and unpack 32-bit integer types into a + two-component 16-bit integer vector; + + * new built-in functions to convert half-precision floating-point + values to or from their 16-bit integer bit encodings; + + * vector relational functions supporting comparisons of vectors of + 16-bit integer types; and + + * common functions abs, frexp, ldexp, sign, min, max, clamp, and mix + supporting arguments of 16-bit integer types. + + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/AMD/gpu_shader_int16.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.AMD.gpu_shader_int16 import * +from OpenGL.raw.GL.AMD.gpu_shader_int16 import _EXTENSION_NAME + +def glInitGpuShaderInt16AMD(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/gpu_shader_int64.py b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/gpu_shader_int64.py new file mode 100644 index 00000000..78655134 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/gpu_shader_int64.py @@ -0,0 +1,118 @@ +'''OpenGL extension AMD.gpu_shader_int64 + +This module customises the behaviour of the +OpenGL.raw.GL.AMD.gpu_shader_int64 to provide a more +Python-friendly API + +Overview (from the spec) + + This extension was developed based on the NV_gpu_shader5 extension to + allow implementations supporting 64-bit integers to expose the feature + without the additional requirements that are present in NV_gpu_shader5. + + The extension introduces the following features for all shader types: + + * support for 64-bit scalar and vector integer data types, including + uniform API, uniform buffer object, transform feedback, and shader + input and output support; + + * new built-in functions to pack and unpack 64-bit integer types into a + two-component 32-bit integer vector; + + * new built-in functions to convert double-precision floating-point + values to or from their 64-bit integer bit encodings; + + * vector relational functions supporting comparisons of vectors of + 64-bit integer types; and + + * common functions abs, sign, min, max, clamp, and mix supporting + arguments of 64-bit integer types. + + This extension is designed to be a functional superset of the 64-bit + integer support introduced by NV_gpu_shader5 and to be source code + compatible with that, thus the new procedures, functions, and tokens + are identical to those found in that extension. + + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/AMD/gpu_shader_int64.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.AMD.gpu_shader_int64 import * +from OpenGL.raw.GL.AMD.gpu_shader_int64 import _EXTENSION_NAME + +def glInitGpuShaderInt64AMD(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glUniform1i64vNV.value size not checked against count +glUniform1i64vNV=wrapper.wrapper(glUniform1i64vNV).setInputArraySize( + 'value', None +) +# INPUT glUniform2i64vNV.value size not checked against count*2 +glUniform2i64vNV=wrapper.wrapper(glUniform2i64vNV).setInputArraySize( + 'value', None +) +# INPUT glUniform3i64vNV.value size not checked against count*3 +glUniform3i64vNV=wrapper.wrapper(glUniform3i64vNV).setInputArraySize( + 'value', None +) +# INPUT glUniform4i64vNV.value size not checked against count*4 +glUniform4i64vNV=wrapper.wrapper(glUniform4i64vNV).setInputArraySize( + 'value', None +) +# INPUT glUniform1ui64vNV.value size not checked against count +glUniform1ui64vNV=wrapper.wrapper(glUniform1ui64vNV).setInputArraySize( + 'value', None +) +# INPUT glUniform2ui64vNV.value size not checked against count*2 +glUniform2ui64vNV=wrapper.wrapper(glUniform2ui64vNV).setInputArraySize( + 'value', None +) +# INPUT glUniform3ui64vNV.value size not checked against count*3 +glUniform3ui64vNV=wrapper.wrapper(glUniform3ui64vNV).setInputArraySize( + 'value', None +) +# INPUT glUniform4ui64vNV.value size not checked against count*4 +glUniform4ui64vNV=wrapper.wrapper(glUniform4ui64vNV).setInputArraySize( + 'value', None +) +# OUTPUT glGetUniformi64vNV.params COMPSIZE(program, location) +# OUTPUT glGetUniformui64vNV.params COMPSIZE(program, location) +# INPUT glProgramUniform1i64vNV.value size not checked against count +glProgramUniform1i64vNV=wrapper.wrapper(glProgramUniform1i64vNV).setInputArraySize( + 'value', None +) +# INPUT glProgramUniform2i64vNV.value size not checked against count*2 +glProgramUniform2i64vNV=wrapper.wrapper(glProgramUniform2i64vNV).setInputArraySize( + 'value', None +) +# INPUT glProgramUniform3i64vNV.value size not checked against count*3 +glProgramUniform3i64vNV=wrapper.wrapper(glProgramUniform3i64vNV).setInputArraySize( + 'value', None +) +# INPUT glProgramUniform4i64vNV.value size not checked against count*4 +glProgramUniform4i64vNV=wrapper.wrapper(glProgramUniform4i64vNV).setInputArraySize( + 'value', None +) +# INPUT glProgramUniform1ui64vNV.value size not checked against count +glProgramUniform1ui64vNV=wrapper.wrapper(glProgramUniform1ui64vNV).setInputArraySize( + 'value', None +) +# INPUT glProgramUniform2ui64vNV.value size not checked against count*2 +glProgramUniform2ui64vNV=wrapper.wrapper(glProgramUniform2ui64vNV).setInputArraySize( + 'value', None +) +# INPUT glProgramUniform3ui64vNV.value size not checked against count*3 +glProgramUniform3ui64vNV=wrapper.wrapper(glProgramUniform3ui64vNV).setInputArraySize( + 'value', None +) +# INPUT glProgramUniform4ui64vNV.value size not checked against count*4 +glProgramUniform4ui64vNV=wrapper.wrapper(glProgramUniform4ui64vNV).setInputArraySize( + 'value', None +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/interleaved_elements.py b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/interleaved_elements.py new file mode 100644 index 00000000..76c6f80e --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/interleaved_elements.py @@ -0,0 +1,56 @@ +'''OpenGL extension AMD.interleaved_elements + +This module customises the behaviour of the +OpenGL.raw.GL.AMD.interleaved_elements to provide a more +Python-friendly API + +Overview (from the spec) + + The glDrawElements function and its variants (instanced and indirect, + for example) allow OpenGL to draw indexed arrays of vertices. Since its + inception, OpenGL has supported unsigned bytes, unsigned shorts and + unsigned integers as index types. However, all enabled vertex arrays may + be represented by at most one shared index. + + A common scenario in graphics rendering is that several faces share + a vertex where, for each face some properties of a vertex (position and + texture coordinates, for example) should be common but others must be + unique (colors, normals, and so on). Consider a mesh of a cube with + per-face normals, for example. There are 8 vertices and 6 normals, and 12 + triangles (where each face of the cube is represented as two triangles). + To render this cube, we must compute the 24 unique permutations of + position and normal and build a new element list to index into it. In + fact, any advantage of indexed draw is lost here as the number of required + permutations is equal to the final vertex count required to draw the + object. + + This extension allows OpenGL to process multi-component packed element + data. The maximum size of a vertex's index data is not increased, but the + facility to store 2 16-bit or 2 or 4 8-bit indices per vertex is introduced. + Each vertex attribute is given a swizzle property to allow its index to + be sourced from one of up to 4 channels of index data. This effectively + allows an application to supply multiple interleaved streams of index data + to OpenGL. Each vertex attribute is given a 'channel selector' to select + one of the up to 4 channels of vertex index information presented to + OpenGL. This enables the use-case described above and many more. + The swizzle parameter is also applied to vertex indices passed to shaders, + and updates to the definition of base vertex parameters and primitive + restart are applied. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/AMD/interleaved_elements.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.AMD.interleaved_elements import * +from OpenGL.raw.GL.AMD.interleaved_elements import _EXTENSION_NAME + +def glInitInterleavedElementsAMD(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/multi_draw_indirect.py b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/multi_draw_indirect.py new file mode 100644 index 00000000..b7592bd9 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/multi_draw_indirect.py @@ -0,0 +1,37 @@ +'''OpenGL extension AMD.multi_draw_indirect + +This module customises the behaviour of the +OpenGL.raw.GL.AMD.multi_draw_indirect to provide a more +Python-friendly API + +Overview (from the spec) + + The ARB_draw_indirect extension (included in OpenGL 4.0) introduced + mechanisms whereby the parameters for a draw function may be provided in + a structure contained in a buffer object rather than as parameters to the + drawing procedure. This is known as an indirect draw and is exposed as two + new functions, glDrawArraysIndirect and glDrawElementsIndirect. Each of + these functions generates a single batch of primitives. + + This extension builds on this functionality by providing procedures to + invoke multiple draws from a single procedure call. This allows large + batches of drawing commands to be assembled in server memory (via a buffer + object) which may then be dispatched through a single function call. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/AMD/multi_draw_indirect.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.AMD.multi_draw_indirect import * +from OpenGL.raw.GL.AMD.multi_draw_indirect import _EXTENSION_NAME + +def glInitMultiDrawIndirectAMD(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/name_gen_delete.py b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/name_gen_delete.py new file mode 100644 index 00000000..d2d1844d --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/name_gen_delete.py @@ -0,0 +1,52 @@ +'''OpenGL extension AMD.name_gen_delete + +This module customises the behaviour of the +OpenGL.raw.GL.AMD.name_gen_delete to provide a more +Python-friendly API + +Overview (from the spec) + + This extension simply creates 2 new entry-points that name generic + creation and deletion of names. The intent is to go away from API + functionality that provides a create/delete function for each specific + object. + + For example: + glGenTextures/glDeleteTextures/glIsTexture + glGenBuffers/glDeleteBuffers/IsBuffer + glGenFramebuffers/glDeleteFramebuffers/IsFramebuffer + + Instead, everything is created using one entry-point GenNamesAMD and + everything is now deleted with another entry-point DeleteNamesAMD with + the appropriate identifier set. In addition, everything can now be + queried with IsNameAMD. + + This alleviates the problem we may eventually encounter where we have + many Gen/Delete/Is functions where 3 might suffice. All that is needed + in the new case is to add a valid identifier to the accepted parameters + list. + + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/AMD/name_gen_delete.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.AMD.name_gen_delete import * +from OpenGL.raw.GL.AMD.name_gen_delete import _EXTENSION_NAME + +def glInitNameGenDeleteAMD(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +glGenNamesAMD=wrapper.wrapper(glGenNamesAMD).setOutput( + 'names',size=lambda x:(x,),pnameArg='num',orPassIn=True +) +# INPUT glDeleteNamesAMD.names size not checked against num +glDeleteNamesAMD=wrapper.wrapper(glDeleteNamesAMD).setInputArraySize( + 'names', None +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/occlusion_query_event.py b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/occlusion_query_event.py new file mode 100644 index 00000000..b60ad49b --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/occlusion_query_event.py @@ -0,0 +1,40 @@ +'''OpenGL extension AMD.occlusion_query_event + +This module customises the behaviour of the +OpenGL.raw.GL.AMD.occlusion_query_event to provide a more +Python-friendly API + +Overview (from the spec) + + Occlusion queries provide a means to count the number of fragments that + pass the depth and stencil tests and that may contribute to a rendered + image. In unextended OpenGL, an occlusion query increments its + samples-passed count whenever a sample passes both the stencil test and + the depth test (if enabled). However, there is no way to count fragments + that fail the stencil test, or pass the stencil test and then subsequently + fail the depth test. + + This extension introduces the concept of occlusion query events and changes + the concept of an occlusion query from counting passed fragments to counting + fragments that generate any of a user-selectable set of events. Provided + events include passing the depth test, and passing or failing the stencil + test. For a given occlusion query object, counting of these events may be + enabled or disabled, allowing any combination to be counted. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/AMD/occlusion_query_event.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.AMD.occlusion_query_event import * +from OpenGL.raw.GL.AMD.occlusion_query_event import _EXTENSION_NAME + +def glInitOcclusionQueryEventAMD(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/performance_monitor.py b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/performance_monitor.py new file mode 100644 index 00000000..9aecf2ad --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/performance_monitor.py @@ -0,0 +1,71 @@ +'''OpenGL extension AMD.performance_monitor + +This module customises the behaviour of the +OpenGL.raw.GL.AMD.performance_monitor to provide a more +Python-friendly API + +Overview (from the spec) + + This extension enables the capture and reporting of performance monitors. + Performance monitors contain groups of counters which hold arbitrary counted + data. Typically, the counters hold information on performance-related + counters in the underlying hardware. The extension is general enough to + allow the implementation to choose which counters to expose and pick the + data type and range of the counters. The extension also allows counting to + start and end on arbitrary boundaries during rendering. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/AMD/performance_monitor.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.AMD.performance_monitor import * +from OpenGL.raw.GL.AMD.performance_monitor import _EXTENSION_NAME + +def glInitPerformanceMonitorAMD(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +glGetPerfMonitorGroupsAMD=wrapper.wrapper(glGetPerfMonitorGroupsAMD).setOutput( + 'groups',size=lambda x:(x,),pnameArg='groupsSize',orPassIn=True +).setOutput( + 'numGroups',size=(1,),orPassIn=True +) +glGetPerfMonitorCountersAMD=wrapper.wrapper(glGetPerfMonitorCountersAMD).setOutput( + 'counters',size=lambda x:(x,),pnameArg='counterSize',orPassIn=True +).setOutput( + 'maxActiveCounters',size=(1,),orPassIn=True +).setOutput( + 'numCounters',size=(1,),orPassIn=True +) +glGetPerfMonitorGroupStringAMD=wrapper.wrapper(glGetPerfMonitorGroupStringAMD).setOutput( + 'groupString',size=lambda x:(x,),pnameArg='bufSize',orPassIn=True +).setOutput( + 'length',size=(1,),orPassIn=True +) +glGetPerfMonitorCounterStringAMD=wrapper.wrapper(glGetPerfMonitorCounterStringAMD).setOutput( + 'counterString',size=lambda x:(x,),pnameArg='bufSize',orPassIn=True +).setOutput( + 'length',size=(1,),orPassIn=True +) +glGetPerfMonitorCounterInfoAMD=wrapper.wrapper(glGetPerfMonitorCounterInfoAMD).setOutput( + 'data',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGenPerfMonitorsAMD=wrapper.wrapper(glGenPerfMonitorsAMD).setOutput( + 'monitors',size=lambda x:(x,),pnameArg='n',orPassIn=True +) +glDeletePerfMonitorsAMD=wrapper.wrapper(glDeletePerfMonitorsAMD).setOutput( + 'monitors',size=lambda x:(x,),pnameArg='n',orPassIn=True +) +glSelectPerfMonitorCountersAMD=wrapper.wrapper(glSelectPerfMonitorCountersAMD).setOutput( + 'counterList',size=lambda x:(x,),pnameArg='numCounters',orPassIn=True +) +glGetPerfMonitorCounterDataAMD=wrapper.wrapper(glGetPerfMonitorCounterDataAMD).setOutput( + 'bytesWritten',size=(1,),orPassIn=True +).setOutput( + 'data',size=lambda x:(x,),pnameArg='dataSize',orPassIn=True +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/pinned_memory.py b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/pinned_memory.py new file mode 100644 index 00000000..355cceaa --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/pinned_memory.py @@ -0,0 +1,35 @@ +'''OpenGL extension AMD.pinned_memory + +This module customises the behaviour of the +OpenGL.raw.GL.AMD.pinned_memory to provide a more +Python-friendly API + +Overview (from the spec) + + This extension defines an interface that allows improved control + of the physical memory used by the graphics device. + + It allows an existing page of system memory allocated by the application + to be used as memory directly accessible to the graphics processor. One + example application of this functionality would be to be able to avoid an + explicit synchronous copy with sub-system of the application; for instance + it is possible to directly draw from a system memory copy of a video + image. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/AMD/pinned_memory.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.AMD.pinned_memory import * +from OpenGL.raw.GL.AMD.pinned_memory import _EXTENSION_NAME + +def glInitPinnedMemoryAMD(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/query_buffer_object.py b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/query_buffer_object.py new file mode 100644 index 00000000..b2b3000e --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/query_buffer_object.py @@ -0,0 +1,48 @@ +'''OpenGL extension AMD.query_buffer_object + +This module customises the behaviour of the +OpenGL.raw.GL.AMD.query_buffer_object to provide a more +Python-friendly API + +Overview (from the spec) + + Statistics about the operation of the OpenGL pipeline, such as the number + of samples that passed the depth test, the elapsed time between two events + or the number of vertices written to a transform feedback buffer may + be retrieved from the GL through query objects. The current value of a + query object may be retrieved by the application through the OpenGL API. + Should the result returned by the API be required for use in a shader, + it must be passed back to the GL via a program uniform or some other + mechanism. This requires a round-trip from the GPU to the CPU and back. + + This extension introduces a mechanism whereby the current value of a query + result may be retrieved into a buffer object instead of client memory. + This allows the query result to be made available to a shader without a + round-trip to the CPU for example by subsequently using the buffer object + as a uniform buffer, texture buffer or other data store visible to the + shader. This functionality may also be used to place the results of + many query objects into a single, large buffer and then map or otherwise + read back the entire buffer at a later point in time, avoiding a per-query + CPU-GPU synchronization event. + + The result of any query object type supported by the GL implementation + may be retrieved into a buffer object. The implementation will determine + the most efficient method of copying the query result to the buffer. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/AMD/query_buffer_object.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.AMD.query_buffer_object import * +from OpenGL.raw.GL.AMD.query_buffer_object import _EXTENSION_NAME + +def glInitQueryBufferObjectAMD(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/sample_positions.py b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/sample_positions.py new file mode 100644 index 00000000..96ac85bc --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/sample_positions.py @@ -0,0 +1,35 @@ +'''OpenGL extension AMD.sample_positions + +This module customises the behaviour of the +OpenGL.raw.GL.AMD.sample_positions to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides a mechanism to explicitly set sample positions for a + FBO with multi-sampled attachments. The FBO will use identical sample locations + for all pixels in each attachment. This forces TEXTURE_FIXED_SAMPLE_LOCATIONS + to TRUE if a multi-sampled texture is specified using TexImage2DMultisample + or TexImage3DMultisample. That is, using GetTexLevelParameter to query + TEXTURE_FIXED_SAMPLE_LOCATIONS will always return TRUE if the mechanism is + explicitly used to set the sample positions. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/AMD/sample_positions.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.AMD.sample_positions import * +from OpenGL.raw.GL.AMD.sample_positions import _EXTENSION_NAME + +def glInitSamplePositionsAMD(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +glSetMultisamplefvAMD=wrapper.wrapper(glSetMultisamplefvAMD).setInputArraySize( + 'val', 2 +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/seamless_cubemap_per_texture.py b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/seamless_cubemap_per_texture.py new file mode 100644 index 00000000..6a096d9d --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/seamless_cubemap_per_texture.py @@ -0,0 +1,47 @@ +'''OpenGL extension AMD.seamless_cubemap_per_texture + +This module customises the behaviour of the +OpenGL.raw.GL.AMD.seamless_cubemap_per_texture to provide a more +Python-friendly API + +Overview (from the spec) + + In unextended OpenGL, cube maps are treated as sets of six, independent + texture images. Once a face is selected from the set, it is treated exactly + as any other two-dimensional texture would be. When sampling linearly from + the texture, all of the individual texels that would be used to to create + the final, bilinear sample values are taken from the same cube face. The + normal, two-dimensional texture coordinate wrapping modes are honored. + This sometimes causes seams to appear in cube maps. + + ARB_seamless_cube_map addresses this issue by providing a mechanism whereby + an implementation could take each of the taps of a bilinear sample from + a different face, spanning face boundaries and providing seamless filtering + from cube map textures. However, in ARB_seamless_cube_map, this feature was + exposed as a global state, affecting all bound cube map textures. It was not + possible to mix seamless and per-face cube map sampling modes during + multisampling. Furthermore, if an application included cube maps that were + meant to be sampled seamlessly and non-seamlessly, it would have to track + this state and enable or disable seamless cube map sampling as needed. + + This extension addresses this issue and provides an orthogonal method for + allowing an implementation to provide a per-texture setting for enabling + seamless sampling from cube maps. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/AMD/seamless_cubemap_per_texture.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.AMD.seamless_cubemap_per_texture import * +from OpenGL.raw.GL.AMD.seamless_cubemap_per_texture import _EXTENSION_NAME + +def glInitSeamlessCubemapPerTextureAMD(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/shader_atomic_counter_ops.py b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/shader_atomic_counter_ops.py new file mode 100644 index 00000000..8cf7787e --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/shader_atomic_counter_ops.py @@ -0,0 +1,38 @@ +'''OpenGL extension AMD.shader_atomic_counter_ops + +This module customises the behaviour of the +OpenGL.raw.GL.AMD.shader_atomic_counter_ops to provide a more +Python-friendly API + +Overview (from the spec) + + The ARB_shader_atomic_counters extension introduced atomic counters, but + it limits list of potential operations that can be performed on them to + increment, decrement, and query. This extension extends the list of GLSL + built-in functions that can operate on atomic counters. The list of new + operations include: + + * Increment and decrement with wrap + * Addition and subtraction + * Minimum and maximum + * Bitwise operators (AND, OR, XOR, etc.) + * Masked OR operator + * Exchange, and compare and exchange operators + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/AMD/shader_atomic_counter_ops.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.AMD.shader_atomic_counter_ops import * +from OpenGL.raw.GL.AMD.shader_atomic_counter_ops import _EXTENSION_NAME + +def glInitShaderAtomicCounterOpsAMD(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/shader_ballot.py b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/shader_ballot.py new file mode 100644 index 00000000..2d30edd9 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/shader_ballot.py @@ -0,0 +1,32 @@ +'''OpenGL extension AMD.shader_ballot + +This module customises the behaviour of the +OpenGL.raw.GL.AMD.shader_ballot to provide a more +Python-friendly API + +Overview (from the spec) + + The extensions ARB_shader_group_vote and ARB_shader_ballot introduced the + concept of sub-groups and a set of operations that allow data exchange + across shader invocations within a sub-group. + + This extension further extends the capabilities of these extensions with + additional sub-group operations. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/AMD/shader_ballot.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.AMD.shader_ballot import * +from OpenGL.raw.GL.AMD.shader_ballot import _EXTENSION_NAME + +def glInitShaderBallotAMD(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/shader_explicit_vertex_parameter.py b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/shader_explicit_vertex_parameter.py new file mode 100644 index 00000000..64d39109 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/shader_explicit_vertex_parameter.py @@ -0,0 +1,34 @@ +'''OpenGL extension AMD.shader_explicit_vertex_parameter + +This module customises the behaviour of the +OpenGL.raw.GL.AMD.shader_explicit_vertex_parameter to provide a more +Python-friendly API + +Overview (from the spec) + + Unextended GLSL provides a set of fixed function interpolation modes and + even those are limited to certain types of interpolants (for example, + interpolation of integer and double isn't supported). + + This extension introduces new built-in functions allowing access to vertex + parameters explicitly in the fragment shader. It also exposes barycentric + coordinates as new built-in variables, which can be used to implement + custom interpolation algorithms using shader code. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/AMD/shader_explicit_vertex_parameter.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.AMD.shader_explicit_vertex_parameter import * +from OpenGL.raw.GL.AMD.shader_explicit_vertex_parameter import _EXTENSION_NAME + +def glInitShaderExplicitVertexParameterAMD(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/shader_gpu_shader_half_float_fetch.py b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/shader_gpu_shader_half_float_fetch.py new file mode 100644 index 00000000..b0508035 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/shader_gpu_shader_half_float_fetch.py @@ -0,0 +1,23 @@ +'''OpenGL extension AMD.shader_gpu_shader_half_float_fetch + +This module customises the behaviour of the +OpenGL.raw.GL.AMD.shader_gpu_shader_half_float_fetch to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/AMD/shader_gpu_shader_half_float_fetch.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.AMD.shader_gpu_shader_half_float_fetch import * +from OpenGL.raw.GL.AMD.shader_gpu_shader_half_float_fetch import _EXTENSION_NAME + +def glInitShaderGpuShaderHalfFloatFetchAMD(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/shader_image_load_store_lod.py b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/shader_image_load_store_lod.py new file mode 100644 index 00000000..8d8a4672 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/shader_image_load_store_lod.py @@ -0,0 +1,29 @@ +'''OpenGL extension AMD.shader_image_load_store_lod + +This module customises the behaviour of the +OpenGL.raw.GL.AMD.shader_image_load_store_lod to provide a more +Python-friendly API + +Overview (from the spec) + + This extension was developed based on the ARB_shader_image_load_store + extension to allow implementations supporting loads and stores on + mipmap texture images. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/AMD/shader_image_load_store_lod.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.AMD.shader_image_load_store_lod import * +from OpenGL.raw.GL.AMD.shader_image_load_store_lod import _EXTENSION_NAME + +def glInitShaderImageLoadStoreLodAMD(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/shader_stencil_export.py b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/shader_stencil_export.py new file mode 100644 index 00000000..b414d8d3 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/shader_stencil_export.py @@ -0,0 +1,37 @@ +'''OpenGL extension AMD.shader_stencil_export + +This module customises the behaviour of the +OpenGL.raw.GL.AMD.shader_stencil_export to provide a more +Python-friendly API + +Overview (from the spec) + + In OpenGL, the stencil test is a powerful mechanism to selectively discard + fragments based on the content of the stencil buffer. However, facilites + to update the content of the stencil buffer are limited to operations such + as incrementing the existing value, or overwriting with a fixed reference + value. + + This extension provides a mechanism whereby a shader may generate the + stencil reference value per invocation. When stencil testing is enabled, + this allows the test to be performed against the value generated in the + shader. When the stencil operation is set to GL_REPLACE, this allows a + value generated in the shader to be written to the stencil buffer directly. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/AMD/shader_stencil_export.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.AMD.shader_stencil_export import * +from OpenGL.raw.GL.AMD.shader_stencil_export import _EXTENSION_NAME + +def glInitShaderStencilExportAMD(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/shader_trinary_minmax.py b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/shader_trinary_minmax.py new file mode 100644 index 00000000..9022d114 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/shader_trinary_minmax.py @@ -0,0 +1,33 @@ +'''OpenGL extension AMD.shader_trinary_minmax + +This module customises the behaviour of the +OpenGL.raw.GL.AMD.shader_trinary_minmax to provide a more +Python-friendly API + +Overview (from the spec) + + This extension introduces three new trinary built-in functions to the + OpenGL Shading Languages. These functions allow the minimum, maximum + or median of three inputs to be found with a single function call. These + operations may be useful for sorting and filtering operations, for example. + By explicitly performing a trinary operation with a single built-in + function, shader compilers and optimizers may be able to generate better + instruction sequences for perform sorting and other multi-input functions. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/AMD/shader_trinary_minmax.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.AMD.shader_trinary_minmax import * +from OpenGL.raw.GL.AMD.shader_trinary_minmax import _EXTENSION_NAME + +def glInitShaderTrinaryMinmaxAMD(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/sparse_texture.py b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/sparse_texture.py new file mode 100644 index 00000000..a91b751d --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/sparse_texture.py @@ -0,0 +1,42 @@ +'''OpenGL extension AMD.sparse_texture + +This module customises the behaviour of the +OpenGL.raw.GL.AMD.sparse_texture to provide a more +Python-friendly API + +Overview (from the spec) + + Recent advances in application complexity and a desire for higher + resolutions have pushed texture sizes up considerably. Often, the amount + of physical memory available to a graphics processor is a limiting factor + in the performance of texture-heavy applications. Once the available + physical memory is exhausted, paging may occur bringing performance down + considerably - or worse, the application may fail. Nevertheless, the amount + of address space available to the graphics processor has increased to the + point where many gigabytes - or even terabytes of address space may be + usable even though that amount of physical memory is not present. + + This extension allows the separation of the graphics processor's address + space (reservation) from the requirement that all textures must be + physically backed (commitment). This exposes a limited form of + virtualization for textures. Use cases include sparse (or partially + resident) textures, texture paging, on-demand and delayed loading of + texture assets and application controlled level of detail. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/AMD/sparse_texture.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.AMD.sparse_texture import * +from OpenGL.raw.GL.AMD.sparse_texture import _EXTENSION_NAME + +def glInitSparseTextureAMD(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/stencil_operation_extended.py b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/stencil_operation_extended.py new file mode 100644 index 00000000..422ab59b --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/stencil_operation_extended.py @@ -0,0 +1,40 @@ +'''OpenGL extension AMD.stencil_operation_extended + +This module customises the behaviour of the +OpenGL.raw.GL.AMD.stencil_operation_extended to provide a more +Python-friendly API + +Overview (from the spec) + + Stencil buffers are special buffers that allow tests to be made against an + incoming value and action taken based on that value. The stencil buffer is + updated during rasterization, and the operation used to update the stencil + buffer is chosen based on whether the fragment passes the stencil test, + and if it does, whether it passes the depth test. Traditional OpenGL + includes support for several primitive operations, such as incrementing, + or clearing the content of the stencil buffer, or replacing it with a + specified reference value. + + This extension adds support for an additional set of operations that may + be performed on the stencil buffer under each circumstance. Additionally, + this extension separates the value used as the source for stencil + operations from the reference value, allowing different values to be used + in the stencil test, and in the update of the stencil buffer. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/AMD/stencil_operation_extended.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.AMD.stencil_operation_extended import * +from OpenGL.raw.GL.AMD.stencil_operation_extended import _EXTENSION_NAME + +def glInitStencilOperationExtendedAMD(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/texture_gather_bias_lod.py b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/texture_gather_bias_lod.py new file mode 100644 index 00000000..e499540a --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/texture_gather_bias_lod.py @@ -0,0 +1,29 @@ +'''OpenGL extension AMD.texture_gather_bias_lod + +This module customises the behaviour of the +OpenGL.raw.GL.AMD.texture_gather_bias_lod to provide a more +Python-friendly API + +Overview (from the spec) + + This extension was developed based on existing built-in texture gather functions to allow + implementations supporting bias of implicit level of detail and explicit control of level of + detail in texture gather operations. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/AMD/texture_gather_bias_lod.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.AMD.texture_gather_bias_lod import * +from OpenGL.raw.GL.AMD.texture_gather_bias_lod import _EXTENSION_NAME + +def glInitTextureGatherBiasLodAMD(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/texture_texture4.py b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/texture_texture4.py new file mode 100644 index 00000000..db1280e8 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/texture_texture4.py @@ -0,0 +1,37 @@ +'''OpenGL extension AMD.texture_texture4 + +This module customises the behaviour of the +OpenGL.raw.GL.AMD.texture_texture4 to provide a more +Python-friendly API + +Overview (from the spec) + + This extension adds new shading language built-in texture functions + to the shading language. + + These texture functions may be used to access one component textures. + + The texture4 built-in function returns a texture value derived from + a 2x2 set of texels in the image array of level levelbase is selected. + These texels are selected in the same way as when the value of + TEXTURE_MIN_FILTER is LINEAR, but instead of these texels being + filtered to generate the texture value, the R, G, B and A texture values + are derived directly from these four texels. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/AMD/texture_texture4.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.AMD.texture_texture4 import * +from OpenGL.raw.GL.AMD.texture_texture4 import _EXTENSION_NAME + +def glInitTextureTexture4AMD(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/transform_feedback3_lines_triangles.py b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/transform_feedback3_lines_triangles.py new file mode 100644 index 00000000..61b5a7fe --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/transform_feedback3_lines_triangles.py @@ -0,0 +1,32 @@ +'''OpenGL extension AMD.transform_feedback3_lines_triangles + +This module customises the behaviour of the +OpenGL.raw.GL.AMD.transform_feedback3_lines_triangles to provide a more +Python-friendly API + +Overview (from the spec) + + OpenGL 4.0 introduced the ability to record primitives into multiple output + streams using transform feedback. However, the restriction that all streams + must output POINT primitives when more than one output stream is active was + also introduced. This extension simply removes that restriction, allowing + the same set of primitives to be used with multiple transform feedback + streams as with a single stream. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/AMD/transform_feedback3_lines_triangles.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.AMD.transform_feedback3_lines_triangles import * +from OpenGL.raw.GL.AMD.transform_feedback3_lines_triangles import _EXTENSION_NAME + +def glInitTransformFeedback3LinesTrianglesAMD(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/transform_feedback4.py b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/transform_feedback4.py new file mode 100644 index 00000000..486c9bd3 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/transform_feedback4.py @@ -0,0 +1,49 @@ +'''OpenGL extension AMD.transform_feedback4 + +This module customises the behaviour of the +OpenGL.raw.GL.AMD.transform_feedback4 to provide a more +Python-friendly API + +Overview (from the spec) + + Transform feedback is a mechanism to record the output of the vertex, + tessellation evaluation or geometry shader into one or more buffers for + further processing, recursive rendering or read-back by the client. + ARB_transform_feedback3 (and OpenGL 4.0) extended the transform feedback + subsystem to allow multiple streams of primitive information to be + captured. However, it imposed a limitation that the primitive type for all + streams must be POINTS if more than one stream is to be captured. + AMD_transform_feedback3_lines_triangles relaxed that restriction to allow + lines or triangles to be captured, in the case where multiple streams are + to be processed. However, it still required that all streams share the same + primitive type. Additionally, with all current extensions to transform + feedback, only a single primitive stream may be rasterized. + + This extension enhances transform feedback in two significant ways. First, + it allows multiple transform feedback streams to be captured, each with its + own, independent primitve type. Second, it allows any combination of streams + to be rasterized. As an example, this enables the geometry shader to take + a single stream of triangle geometry and emit filled triangles with a + wireframe outline and a point at each vertex, all in a single pass through + the input vertices. Combined with features such those provided by + ARB_viewport_array, layered rendering, shader subroutines and so on, an + application can render several views of its geoemtry, each with a + radically different style, all in a single pass. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/AMD/transform_feedback4.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.AMD.transform_feedback4 import * +from OpenGL.raw.GL.AMD.transform_feedback4 import _EXTENSION_NAME + +def glInitTransformFeedback4AMD(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/vertex_shader_layer.py b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/vertex_shader_layer.py new file mode 100644 index 00000000..061d19b8 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/vertex_shader_layer.py @@ -0,0 +1,44 @@ +'''OpenGL extension AMD.vertex_shader_layer + +This module customises the behaviour of the +OpenGL.raw.GL.AMD.vertex_shader_layer to provide a more +Python-friendly API + +Overview (from the spec) + + The gl_Layer built-in shading language variable was introduced with the + ARB_geometry_shader extension and subsequently promoted to core OpenGL + in version 3.2. This variable is an output from the geometry shader stage + that allows rendering to be directed to a specific layer of an array + texture, slice of a 3D texture or face of a cube map or cube map array + attachment of the framebuffer. Thus, this extremely useful functionality is + only available if a geometry shader is present - even if the geometry shader + is not otherwise required by the application. This adds overhead to the + graphics processing pipeline, and complexity to applications. It also + precludes implementations that cannot support geometry shaders from + supporting rendering to layered framebuffer attachments. + + This extension exposes the gl_Layer built-in variable in the vertex shader, + allowing rendering to be directed to layered framebuffer attachments with + only a vertex and fragment shader present. Combined with features such + as instancing, or static vertex attributes and so on, this allows a wide + variety of techniques to be implemented without the requirement for a + geometry shader to be present. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/AMD/vertex_shader_layer.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.AMD.vertex_shader_layer import * +from OpenGL.raw.GL.AMD.vertex_shader_layer import _EXTENSION_NAME + +def glInitVertexShaderLayerAMD(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/vertex_shader_tessellator.py b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/vertex_shader_tessellator.py new file mode 100644 index 00000000..fc5d051e --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/vertex_shader_tessellator.py @@ -0,0 +1,85 @@ +'''OpenGL extension AMD.vertex_shader_tessellator + +This module customises the behaviour of the +OpenGL.raw.GL.AMD.vertex_shader_tessellator to provide a more +Python-friendly API + +Overview (from the spec) + + The vertex shader tessellator gives new flexibility to the shader + author to shade at a tessellated vertex, rather than just at a + provided vertex. + + In unextended vertex shading, the built-in attributes such as + gl_Vertex, gl_Normal, and gl_MultiTexcoord0, together with the + user defined attributes, are system provided values which are + initialized prior to vertex shader invocation. + + With vertex shading tessellation, additional vertex shader special + values are available: + + ivec3 gl_VertexTriangleIndex; // indices of the three control + // points for the vertex + vec3 gl_BarycentricCoord; // barycentric coordinates + // of the vertex + + i o + |\ + | \ + *--* + |\ |\ + | \| \ + *--*--* + |\ |\ |\ + | \| \| \ + j o--*--*--o k + + Figure 1 A Tessellated Triangle + o = control point (and tessellated vertex) + * = tessellated vertex + + ivec4 gl_VertexQuadIndex; // indices for the four control + // points for the vertex + vec2 gl_UVCoord; // UV coordinates of the vertex + + i o--*--*--o k + |\ |\ |\ | + | \| \| \| + *--*--*--* + |\ |\ |\ | + | \| \| \| + *--*--*--* + |\ |\ |\ | + | \| \| \| + j o--*--*--o l + + Figure 2 A Tessellated Quad + o = control point (and tessellated vertex) + * = tessellated vertex + + When this extension is enabled, conventional built-in attributes + and user defined attributes are uninitialized. The shader writer + is responsible for explicitly fetching all other vertex data either + from textures, uniform buffers, or vertex buffers. + + The shader writer is further responsible for interpolating + the vertex data at the given barycentric coordinates or uv + coordinates of the vertex. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/AMD/vertex_shader_tessellator.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.AMD.vertex_shader_tessellator import * +from OpenGL.raw.GL.AMD.vertex_shader_tessellator import _EXTENSION_NAME + +def glInitVertexShaderTessellatorAMD(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/vertex_shader_viewport_index.py b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/vertex_shader_viewport_index.py new file mode 100644 index 00000000..b2f16054 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/AMD/vertex_shader_viewport_index.py @@ -0,0 +1,38 @@ +'''OpenGL extension AMD.vertex_shader_viewport_index + +This module customises the behaviour of the +OpenGL.raw.GL.AMD.vertex_shader_viewport_index to provide a more +Python-friendly API + +Overview (from the spec) + + The gl_ViewportIndex built-in variable was introduced by the + ARB_viewport_array extension and OpenGL 4.1. This variable is available + in un-extended OpenGL only to the geometry shader. When written in the + geometry shader, it causes geometry to be directed to one of an array + of several independent viewport rectangles. + + In order to use any viewport other than zero, a geometry shader must be + present. Geometry shaders introduce processing overhead and potential + performance issues. This extension exposes the gl_ViewportIndex built-in + variable to the vertex shader, allowing the functionality introduced by + ARB_viewport_array to be accessed without requiring a geometry shader to + be present. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/AMD/vertex_shader_viewport_index.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.AMD.vertex_shader_viewport_index import * +from OpenGL.raw.GL.AMD.vertex_shader_viewport_index import _EXTENSION_NAME + +def glInitVertexShaderViewportIndexAMD(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ANGLE/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ANGLE/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ANGLE/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ANGLE/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ANGLE/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..9d65e819 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ANGLE/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/APPLE/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/GL/APPLE/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/APPLE/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/APPLE/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/APPLE/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..f475b0ec Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/APPLE/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/APPLE/__pycache__/aux_depth_stencil.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/APPLE/__pycache__/aux_depth_stencil.cpython-312.pyc new file mode 100644 index 00000000..4c8c600f Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/APPLE/__pycache__/aux_depth_stencil.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/APPLE/__pycache__/client_storage.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/APPLE/__pycache__/client_storage.cpython-312.pyc new file mode 100644 index 00000000..f704f2fa Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/APPLE/__pycache__/client_storage.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/APPLE/__pycache__/element_array.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/APPLE/__pycache__/element_array.cpython-312.pyc new file mode 100644 index 00000000..24b7958e Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/APPLE/__pycache__/element_array.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/APPLE/__pycache__/fence.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/APPLE/__pycache__/fence.cpython-312.pyc new file mode 100644 index 00000000..1372f15d Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/APPLE/__pycache__/fence.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/APPLE/__pycache__/float_pixels.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/APPLE/__pycache__/float_pixels.cpython-312.pyc new file mode 100644 index 00000000..c640e4a4 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/APPLE/__pycache__/float_pixels.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/APPLE/__pycache__/flush_buffer_range.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/APPLE/__pycache__/flush_buffer_range.cpython-312.pyc new file mode 100644 index 00000000..282c8c3d Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/APPLE/__pycache__/flush_buffer_range.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/APPLE/__pycache__/object_purgeable.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/APPLE/__pycache__/object_purgeable.cpython-312.pyc new file mode 100644 index 00000000..798eff8f Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/APPLE/__pycache__/object_purgeable.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/APPLE/__pycache__/rgb_422.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/APPLE/__pycache__/rgb_422.cpython-312.pyc new file mode 100644 index 00000000..2435eae6 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/APPLE/__pycache__/rgb_422.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/APPLE/__pycache__/row_bytes.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/APPLE/__pycache__/row_bytes.cpython-312.pyc new file mode 100644 index 00000000..b061c3a2 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/APPLE/__pycache__/row_bytes.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/APPLE/__pycache__/specular_vector.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/APPLE/__pycache__/specular_vector.cpython-312.pyc new file mode 100644 index 00000000..93b3b1ca Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/APPLE/__pycache__/specular_vector.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/APPLE/__pycache__/texture_range.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/APPLE/__pycache__/texture_range.cpython-312.pyc new file mode 100644 index 00000000..18aa41c4 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/APPLE/__pycache__/texture_range.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/APPLE/__pycache__/transform_hint.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/APPLE/__pycache__/transform_hint.cpython-312.pyc new file mode 100644 index 00000000..8bad96de Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/APPLE/__pycache__/transform_hint.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/APPLE/__pycache__/vertex_array_object.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/APPLE/__pycache__/vertex_array_object.cpython-312.pyc new file mode 100644 index 00000000..c1ece4d1 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/APPLE/__pycache__/vertex_array_object.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/APPLE/__pycache__/vertex_array_range.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/APPLE/__pycache__/vertex_array_range.cpython-312.pyc new file mode 100644 index 00000000..43157294 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/APPLE/__pycache__/vertex_array_range.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/APPLE/__pycache__/vertex_program_evaluators.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/APPLE/__pycache__/vertex_program_evaluators.cpython-312.pyc new file mode 100644 index 00000000..84566b24 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/APPLE/__pycache__/vertex_program_evaluators.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/APPLE/__pycache__/ycbcr_422.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/APPLE/__pycache__/ycbcr_422.cpython-312.pyc new file mode 100644 index 00000000..a1cf0c11 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/APPLE/__pycache__/ycbcr_422.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/APPLE/aux_depth_stencil.py b/venv/lib/python3.12/site-packages/OpenGL/GL/APPLE/aux_depth_stencil.py new file mode 100644 index 00000000..e67952d4 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/APPLE/aux_depth_stencil.py @@ -0,0 +1,47 @@ +'''OpenGL extension APPLE.aux_depth_stencil + +This module customises the behaviour of the +OpenGL.raw.GL.APPLE.aux_depth_stencil to provide a more +Python-friendly API + +Overview (from the spec) + + Normally, each OpenGL drawable allocates at most one depth buffer and one + stencil buffer, regardless of how many aux buffers there are. + + When the APPLE_aux_depth_stencil extension is used, and the depth buffer + size is non-zero, the GL silently allocates a separate depth buffer for the + color buffer and for each aux buffer. Similarly, if the stencil buffer size + is non-zero, a separate stencil buffer is allocated for the color buffer and + each aux buffer. This extension does not cause separate depth or stencil + buffers to be allocated for the left and right buffers of a stereo drawable. + A context with no aux buffers will be unaffected by this extension. + + Switching the draw or read buffer from the color buffer to an aux buffer, or + switching between two aux buffers, simultaneously switches the associated + depth and stencil buffers, for drawing or reading. + + For example, if an OpenGL context has two aux buffers and non-zero depth + buffer size, it will have a total of three depth buffers - one associated + with the color buffer and one associated with each aux buffer. If that + context is used to render to AUX0, then to render to AUX1, the changes to + the depth buffer made by the rendering to AUX1 will not affect the depth + buffer associated with AUX0, and vice versa. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/APPLE/aux_depth_stencil.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.APPLE.aux_depth_stencil import * +from OpenGL.raw.GL.APPLE.aux_depth_stencil import _EXTENSION_NAME + +def glInitAuxDepthStencilAPPLE(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/APPLE/client_storage.py b/venv/lib/python3.12/site-packages/OpenGL/GL/APPLE/client_storage.py new file mode 100644 index 00000000..9ddc4cff --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/APPLE/client_storage.py @@ -0,0 +1,107 @@ +'''OpenGL extension APPLE.client_storage + +This module customises the behaviour of the +OpenGL.raw.GL.APPLE.client_storage to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides a simple mechanism to optimize texture data handling + by clients. GL implementations normally maintain a copy of texture image + data supplied clients when any of the various texturing commands, such as + TexImage2D, are invoked. This extension eliminates GL's internal copy of + the texture image data and allows a client to maintain this data locally for + textures when the UNPACK_CLIENT_STORAGE_APPLE pixel storage parameter is + TRUE at the time of texture specification. Local texture data storage is + especially useful in cases where clients maintain internal copies of + textures used in any case. This results in what could be considered an + extra copy of the texture image data. Assuming all operations are error + free, the use of client storage has no affect on the result of texturing + operations and will not affect rendering results. APPLE_client_storage + allows clients to optimize memory requirements and copy operations it also + requires adherence to specific rules in maintaining texture image data. + + Clients using this extension are agreeing to preserve a texture's image data + for the life of the texture. The life of the texture is defined, in this + case, as the time from first issuing the TexImage3D, TexImage2D or + TexImage1D command, for the specific texture object with the + UNPACK_CLIENT_STORAGE_APPLE pixel storage parameter set to TRUE, until the + DeleteTextures command or another TexImage command for that same object. + Only after DeleteTextures has completed, or new texture is specified, can + the local texture memory be released, as it will no longer be utilized by + OpenGL. Changing the UNPACK_CLIENT_STORAGE_APPLE pixel storage parameter + will have no additional effect once the texturing command has been issued + and specifically will not alleviate the client from maintaining the texture + data. + + Client storage is implemented as a pixel storage parameter which affects + texture image storage at the time the texturing command is issued. As with + other pixel storage parameters this state may differ from the time the + texturing command in executed if the command is placed in a display list. + The PixelStore command is used to set the parameter + UNPACK_CLIENT_STORAGE_APPLE. Values can either be TRUE or FALSE, with TRUE + representing the use of client local storage and FALSE indicating the OpenGL + engine and not the client will be responsible for maintaining texture + storage for future texturing commands issued per the OpenGL specification. + The default state for the UNPACK_CLIENT_STORAGE_APPLE parameter is FALSE + + Client storage is only available for texture objects and not the default + texture (of any target type). This means that a texture object has to + generated and bound to be used with client storage. Setting + UNPACK_CLIENT_STORAGE_APPLE to TRUE and texturing with the default texture + will result in normally texturing with GL maintaining a copy of the texture + image data. + + Normally, client storage will be used in conjunction with normal texturing + techniques. An application would use GenTextures to generate texture + objects as needed. BindTexture to the texture object name of interest. + Enable client storage via the PixelStore command setting the + UNPACK_CLIENT_STORAGE_APPLE parameter to TRUE. Then use TexImage3D, + TexImage2D or TexImage1D to specify the texture image. If no further use of + client storage is desired, it is recommended to again use the PixelStore + command, in this case setting the UNPACK_CLIENT_STORAGE_APPLE parameter to + FALSE to disable client storage, since this pixel state is maintained unless + explicitly set by the PixelStore command. + + If an application needs to modify the texture, using TexSubImage for + example, it should be noted that the pointer passed to TexSubImage1D, + TexSubImage2D or TexSubImage3D does not have to the same, or within the + original texture memory. It if is not, there is the likelihood of GL + copying the new data to the original texture memory owned by the client, + thus actually modifying this texture image data. This does not affect + requirement to maintain the original texture memory but also does not add + the requirement to maintain the sub image data, due to the copy. + + Once a client has completed use of the texture stored in client memory, it + should issue a DeleteTextures command to delete the texture object or issue + a texture command, with the same target type, for the object, with either a + different data pointer, or UNPACK_CLIENT_STORAGE_APPLE set to false, in any + case, breaking the tie between GL and the texture buffer. An implicit Flush + command is issued in these cases, ensuring all access to the texture by + OpenGL is complete. Only at this point can the texture buffer be safely + released. Releasing the texture buffer prior has undefined results and will + very possibly display texel anomalies at run time. System level memory + management and paging schemes should not affect the use of client storage. + Consider in any case, that GL has an alias of the base pointer for this + block of texture memory which is maintained until GL is finished rendering + with the texture and it has been deleted or reassigned to another set of + texture data. As long as this alias exists, applications must not + de-allocate, move or purge this memory. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/APPLE/client_storage.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.APPLE.client_storage import * +from OpenGL.raw.GL.APPLE.client_storage import _EXTENSION_NAME + +def glInitClientStorageAPPLE(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/APPLE/element_array.py b/venv/lib/python3.12/site-packages/OpenGL/GL/APPLE/element_array.py new file mode 100644 index 00000000..a476a6d6 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/APPLE/element_array.py @@ -0,0 +1,59 @@ +'''OpenGL extension APPLE.element_array + +This module customises the behaviour of the +OpenGL.raw.GL.APPLE.element_array to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides facilities to improve DrawElements style vertex + indices submission performance by allowing index arrays. Using this + extension these arrays can be contained inside a vertex array range and + thus pulled directly by the graphics processor, avoiding the CPU overhead + of touching the index data. + + This extension is most useful when used in conjunction with the + APPLE_vertex_array_range extension. APPLE_vertex_array_range provides an + interface for storing vertex array data. In cases where large amounts of + vertex data are in use, the index data used to construct primitives + (typically as passed to the GL through DrawElements) can impose a + significant bandwidth burden. APPLE_element_array allows the application to + specify independent arrays of elements, which can then be cached using + APPLE_vertex_array_range. In effect this creates a more orthogonal + interface for both vertex indices and data. + + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/APPLE/element_array.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.APPLE.element_array import * +from OpenGL.raw.GL.APPLE.element_array import _EXTENSION_NAME + +def glInitElementArrayAPPLE(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glElementPointerAPPLE.pointer size not checked against 'type' +glElementPointerAPPLE=wrapper.wrapper(glElementPointerAPPLE).setInputArraySize( + 'pointer', None +) +# INPUT glMultiDrawElementArrayAPPLE.count size not checked against primcount +# INPUT glMultiDrawElementArrayAPPLE.first size not checked against primcount +glMultiDrawElementArrayAPPLE=wrapper.wrapper(glMultiDrawElementArrayAPPLE).setInputArraySize( + 'count', None +).setInputArraySize( + 'first', None +) +# INPUT glMultiDrawRangeElementArrayAPPLE.count size not checked against primcount +# INPUT glMultiDrawRangeElementArrayAPPLE.first size not checked against primcount +glMultiDrawRangeElementArrayAPPLE=wrapper.wrapper(glMultiDrawRangeElementArrayAPPLE).setInputArraySize( + 'count', None +).setInputArraySize( + 'first', None +) +### END AUTOGENERATED SECTION diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/APPLE/fence.py b/venv/lib/python3.12/site-packages/OpenGL/GL/APPLE/fence.py new file mode 100644 index 00000000..86e34f8d --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/APPLE/fence.py @@ -0,0 +1,79 @@ +'''OpenGL extension APPLE.fence + +This module customises the behaviour of the +OpenGL.raw.GL.APPLE.fence to provide a more +Python-friendly API + +Overview (from the spec) + + This extension is provided a finer granularity of synchronizing GL command + completion than offered by standard OpenGL, which currently offers only two + mechanisms for synchronization: Flush and Finish. Since Flush merely assures + the user that the commands complete in a finite (though undetermined) amount + of time, it is, thus, of only modest utility. Finish, on the other hand, + stalls CPU execution until all pending GL commands have completed forcing + completely synchronous operation, which most often not the desired result. + This extension offers a middle ground - the ability to "finish" a subset of + the command stream, and the ability to determine whether a given command has + completed or not. + + This extension introduces the concept of a "fence" to the OpenGL command + stream with SetFenceAPPLE. Once the fence is inserted into the command + stream, it can be tested for its completion with TestFenceAPPLE. Moreover, + the application may also request a partial Finish up to a particular "fence" + using the FinishFenceAPPLE command -- that is, all commands prior to the + fence will be forced to complete until control is returned to the calling + process. These new mechanisms allow for synchronization between the host + CPU and the GPU, which may be accessing the same resources (typically + memory). + + Fences are created and deleted, as are other objects in OpenGL, specifically + with GenFencesAPPLE and DeleteFencesAPPLE. The former returns a list of + unused fence names and the later deletes the provided list of fence names. + + In addition to being able to test or finish a fence this extension allows + testing for other types of completion, including texture objects, vertex + array objects, and draw pixels. This allows the client to use + TestObjectAPPLE or FinishObjectAPPLE with FENCE_APPLE, TEXTURE, + VERTEX_ARRAY, or DRAW_PIXELS_APPLE with the same type of results as + TestFenceAPPLE and FinishFenceAPPLE. Specifically, using the FENCE_APPLE + type is equivalent to calling TestFenceAPPLE or FinishFenceAPPLE with the + particular fence name. Using TEXTURE as the object type tests or waits for + completion of a specific texture, meaning when there are no pending + rendering commands which use that texture object. Using the VERTEX_ARRAY + type will test or wait for drawing commands using that particular vertex + array object name. Finally, DRAW_PIXELS_APPLE will wait or test for + completion of all pending DrawPixels commands. These tests and finishes + operate with the same limitations and results as test and finish fence. + + One use of this extension is in conjunction with APPLE_vertex_array_range to + determine when graphics hardware has completed accessing vertex data from a + vertex array range. Once a fence has been tested TRUE or finished, all + vertex indices issued before the fence must have completed being accessed. + This ensures that the vertex data memory corresponding to the issued vertex + indices can be safely modified (assuming no other outstanding vertex indices + are issued subsequent to the fence). + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/APPLE/fence.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.APPLE.fence import * +from OpenGL.raw.GL.APPLE.fence import _EXTENSION_NAME + +def glInitFenceAPPLE(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +glGenFencesAPPLE=wrapper.wrapper(glGenFencesAPPLE).setOutput( + 'fences',size=lambda x:(x,),pnameArg='n',orPassIn=True +) +# INPUT glDeleteFencesAPPLE.fences size not checked against n +glDeleteFencesAPPLE=wrapper.wrapper(glDeleteFencesAPPLE).setInputArraySize( + 'fences', None +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/APPLE/float_pixels.py b/venv/lib/python3.12/site-packages/OpenGL/GL/APPLE/float_pixels.py new file mode 100644 index 00000000..038fc356 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/APPLE/float_pixels.py @@ -0,0 +1,70 @@ +'''OpenGL extension APPLE.float_pixels + +This module customises the behaviour of the +OpenGL.raw.GL.APPLE.float_pixels to provide a more +Python-friendly API + +Overview (from the spec) + + This extensions adds texture types, texture internal formats and + color buffers composed of both 32 bit and 16 floating point numbers. + 16 bit floats (half float) are very similar to the IEEE + single-precision floating-point standard, except that it has only 5 + exponent bits and 10 mantissa bits. All floating point numbers are + clamped to the limits of the range representable by their respective + format. + + Specifically, APPLE_float_pixels adds four pieces of functionality + to OpenGL. First, it provides an HALF_APPLE texture type allowing + clients to pass textures in the half float format. Second, it adds + 12 additional sized internal formats to allow OpenGL to process and + maintain texture data in the requested format if possible. Next, it + provides the COLOR_FLOAT_APPLE pixel format to allow creation of + floating point and half float color buffers. Lastly, it provides an + additional query to allow clients to verify that they have a + floating point color buffer. + + The HALF_APPLE texture type allows clients to use source textures + composed of half float color components. This constant is use in + the type parameter in DrawPixels, ReadPixels and texturing commands + with a corresponding GL half data type, which corresponds to a 16 + bit half float, and has no special interpretation. + + Clients can use the 12 additional (6 floating point and 6 half + float) sized internal texture formats to specify the mapping of R, + G, B and A values to texture components, as they would with any + other sized internal texture format. Note, as is the standard + practice with OpenGL, implementations should map the sized internal + texture R, G, B and A values to internal components with memory + allocations as close as possible to those specified in the sized + internal format. + + Floating point color buffers are created by specifying the + appropriate color floating point pixel format attribute for the + windowing system API in use by the client. Both 128 bit and 64 bit + floating point color buffers can be supported, the former with full + 32 bit floating point components and the latter with 16 bit half + float components. + + Additionally, clients can query to see if they have a floating point + color buffer using GetBooleanv with COLOR_FLOAT_APPLE as the get + value. The number of bits per color buffer component can be + determined in the usual manner. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/APPLE/float_pixels.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.APPLE.float_pixels import * +from OpenGL.raw.GL.APPLE.float_pixels import _EXTENSION_NAME + +def glInitFloatPixelsAPPLE(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/APPLE/flush_buffer_range.py b/venv/lib/python3.12/site-packages/OpenGL/GL/APPLE/flush_buffer_range.py new file mode 100644 index 00000000..36d98307 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/APPLE/flush_buffer_range.py @@ -0,0 +1,46 @@ +'''OpenGL extension APPLE.flush_buffer_range + +This module customises the behaviour of the +OpenGL.raw.GL.APPLE.flush_buffer_range to provide a more +Python-friendly API + +Overview (from the spec) + + APPLE_flush_buffer_range expands the buffer object API to allow greater + performance when a client application only needs to write to a sub-range + of a buffer object. To that end, this extension introduces two new buffer + object features: non-serialized buffer modification and explicit sub-range + flushing for mapped buffer objects. + + OpenGL requires that commands occur in a FIFO manner meaning that any + changes to buffer objects either block until the data has been processed by + the OpenGL pipeline or else create extra copies to avoid such a block. By + providing a method to asynchronously modify buffer object data, an + application is then able to manage the synchronization points themselves + and modify ranges of data contained by a buffer object even though OpenGL + might still be using other parts of it. + + This extension also provides a method for explicitly flushing ranges of a + mapped buffer object so OpenGL does not have to assume that the entire + range may have been modified. + + Affects ARB_vertex_buffer_object, ARB_pixel_buffer_object and OpenGL 1.5 + Buffer Objects. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/APPLE/flush_buffer_range.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.APPLE.flush_buffer_range import * +from OpenGL.raw.GL.APPLE.flush_buffer_range import _EXTENSION_NAME + +def glInitFlushBufferRangeAPPLE(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/APPLE/object_purgeable.py b/venv/lib/python3.12/site-packages/OpenGL/GL/APPLE/object_purgeable.py new file mode 100644 index 00000000..347f3f13 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/APPLE/object_purgeable.py @@ -0,0 +1,79 @@ +'''OpenGL extension APPLE.object_purgeable + +This module customises the behaviour of the +OpenGL.raw.GL.APPLE.object_purgeable to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides the ability to mark the storage of OpenGL + objects as "purgeable". + + Many of today's modern virtual memory systems include the concept of + purgeability in order to avoid unnecessary paging when the object + contents are no longer needed. In OpenGL, objects such as textures, + vertex buffers, pixel buffers, and renderbuffers all have + significant storage requirements. By default, the OpenGL is + required to preserve the contents of these objects regardless of + system resource stress, such as vram shortage or physical memory + shortage. Often this is accomplished by temporarily paging the + contents of objects that are not currently needed to some kind of + secondary storage area. This paging operation can be an unnecessary + computational expense in the cases where the data is not going to be + used again or where the content can be reproduced by the application + with less expense than the paging operation would require. + + This extension defines a mechanism for the application to mark the + storage of OpenGL objects as "purgeable" in order to influence these + paging operations. The application can further control the + semantics of making object storage "purgeable" with two options + ("volatile" and "released") and "unpurgeable" with two options + ("undefined" and "retained") + + Applications that use this extension will typically follow one of + two operational models. The typical model for most applications is + to mark an object storage as "purgeable" with the "volatile" option, + and then later mark the storage as "unpurgeable" with the "retained" + option. When this happens, the application may or may not need to + respecify the object contents, depending on the whether the object + storage was actually released. The application can find out whether + the storage was released by examining the return value of the + function which marks the storage as "unpurgeable". This model is + useful when the application does not know at the time it marks the + object storage as "purgeable" whether it will later need those + contents to be valid. + + Another operational model is for an application to mark the storage + for an object as "purgeable" with the "released" option, and then + later mark the object "unpurgeable" with the "undefined" option. In + this latter model, the application intends to unconditionally reload + the object contents later on, and so it tells the GL that it is okay + if the contents are "undefined" when the storage is re-allocated. + + Note that in both models, it is possible for the contents to become + undefined since they could have actually been purged from the system + in either case. The various options are still useful, however, + since they give more information to the GL about what the + application expects to happen and the GL can use this information to + make better predictions about which paging choices will be more + efficient. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/APPLE/object_purgeable.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.APPLE.object_purgeable import * +from OpenGL.raw.GL.APPLE.object_purgeable import _EXTENSION_NAME + +def glInitObjectPurgeableAPPLE(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +glGetObjectParameterivAPPLE=wrapper.wrapper(glGetObjectParameterivAPPLE).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/APPLE/rgb_422.py b/venv/lib/python3.12/site-packages/OpenGL/GL/APPLE/rgb_422.py new file mode 100644 index 00000000..8b9d443c --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/APPLE/rgb_422.py @@ -0,0 +1,64 @@ +'''OpenGL extension APPLE.rgb_422 + +This module customises the behaviour of the +OpenGL.raw.GL.APPLE.rgb_422 to provide a more +Python-friendly API + +Overview (from the spec) + + A common storage format for video data is 8-bit 422, with every four + bytes encoding two pixels. Within the four bytes there are two + luminance samples, and two chrominance samples that are shared between + both pixels. + + There is a previous extension, namely GL_APPLE_ycbcr_422 that provided + transparent support for this kind of data. However, that extension + left the exact conversion from Y'CbCr to RGB undefined. In reality, + it really had always been based on the ITU-R BT.601 standard, which + meant it was not particularly useful for dealing with high definition + video data, which is encoded using the Rec. 709 standard. + + In some cases the original extension was implemented via fixed function + hardware, but on more modern graphics processors this is done via + a combination of 422 sampling formats and fragment shader instructions. + + This extension essentially exposes a "raw" 422 texture format that + allows developers to access the raw pre-converted Y'CbCr components + so that they have full control over the colorspace conversion. + + In order to avoid defining entirely new color channels within GL, + the Y, Cb and Cr color channels within the 422 data are mapped into + the existing green, blue and red color channels, respectively. Developers + must write their own fragment shader/program to perform the desired + color space transformation. + + Note: Because of the use of the packed UNSIGNED_SHORT_8_8[_REV] types, the + correct type to use based on the layout of the data in memory (Cb Y Cr Y + versus Y Cb Y Cr) will necessarily be sensitive to host endianness. + + This extension differs from the EXT_422_pixels extension in a couple of + ways. First, this extension defines only a single new format, while + relying on two new type arguments to differentiate between the two + component orderings. Second, this extension provides no defined method + of filtering the chroma values between adjacent pixels. And lastly, + the color channel assignments are slightly different, essentially to + match more closely the rough meanings of the Y, Cb and Cr values in + 422 video data. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/APPLE/rgb_422.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.APPLE.rgb_422 import * +from OpenGL.raw.GL.APPLE.rgb_422 import _EXTENSION_NAME + +def glInitRgb422APPLE(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/APPLE/row_bytes.py b/venv/lib/python3.12/site-packages/OpenGL/GL/APPLE/row_bytes.py new file mode 100644 index 00000000..958d89ee --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/APPLE/row_bytes.py @@ -0,0 +1,55 @@ +'''OpenGL extension APPLE.row_bytes + +This module customises the behaviour of the +OpenGL.raw.GL.APPLE.row_bytes to provide a more +Python-friendly API + +Overview (from the spec) + + The APPLE_row_bytes extension was developed to relax the limitations + within GL regarding the packing and unpacking of pixel data from + arbitrary arrangements in memory. + + Prior to this extension, similar, albeit more restrictive, functionality + existed in GL using pixel storage modes for unpacking, packing, and + alignment. The limitation of the existing mechanism lies primarily in how + packing or unpacking of data is specified with pixel atomicity rather than + basic machine units. To some extent, this pixel granularity can be + overcome using pixel storage modes GL_UNPACK_ALIGNMENT and + GL_PACK_ALIGNMENT. Both of these parameters are specified in basic + machine units but their range of possible values is restricted and even + then they do not allow for the packing and unpacking of pixel data in a + fully arbitrary manner. + + Consider this simple example: + + Consider a column of pixels in memory. The pixels are of GL_RGB + format and GL_UNSIGNED_BYTE type resulting in 3 bytes per pixel. + Now consider that this column of pixel data was arranged in memory + such that each row of the image (in this case each pixel) has two + bytes padding or space between them. + + Each row of 1 pixel then has 5 bytes. An attempting to express this + memory arrangement with existing pixel storage semantics would + naturally start with a GL_UNPACK_ROW_LENGTH of 1 because there is + one pixel per row. However, no valid value of GL_UNPACK_ALIGNMENT, + 1, 2, 4, or 8, will allow the proper row padding to express this + memory arrangement. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/APPLE/row_bytes.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.APPLE.row_bytes import * +from OpenGL.raw.GL.APPLE.row_bytes import _EXTENSION_NAME + +def glInitRowBytesAPPLE(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/APPLE/specular_vector.py b/venv/lib/python3.12/site-packages/OpenGL/GL/APPLE/specular_vector.py new file mode 100644 index 00000000..93f76f13 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/APPLE/specular_vector.py @@ -0,0 +1,52 @@ +'''OpenGL extension APPLE.specular_vector + +This module customises the behaviour of the +OpenGL.raw.GL.APPLE.specular_vector to provide a more +Python-friendly API + +Overview (from the spec) + + An alternative specular lighting model is enabled by passing + the LIGHT_MODEL_SPECULAR_VECTOR token as the parameter + to LightModel, and TRUE as the parameter. The specular + vector lighting model calculates the specular intensity as the + dot product of the true reflection vector of the light source + and the vector from the vertex to the viewpoint. This yields + results that are visually similar to but often more realistic + than the existing lighting model. + + Mathematically, the specular component s.n in the existing + lighting model calculation is replaced with the following + alternative calculation. + + Given three vectors, n, l, and p, where n is the unit normal + vector at the vertex, l is the unit vector from the vertex to + the light position, and p is the unit vector from the vertex + to the viewpoint (or the vector {0,0,1} if + LIGHT_MODEL_LOCAL_VIEWER is false), the specular component is + given by + + (2 * cross(n, cross(n, l)) + l) . p + + All other lighting model and material parameters (shininess, + spotlight, attenuation, local viewer, and direction/positional + sources) operate normally. The specular vector lighting model + affects both rgba and index modes. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/APPLE/specular_vector.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.APPLE.specular_vector import * +from OpenGL.raw.GL.APPLE.specular_vector import _EXTENSION_NAME + +def glInitSpecularVectorAPPLE(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/APPLE/texture_range.py b/venv/lib/python3.12/site-packages/OpenGL/GL/APPLE/texture_range.py new file mode 100644 index 00000000..12d2b4da --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/APPLE/texture_range.py @@ -0,0 +1,45 @@ +'''OpenGL extension APPLE.texture_range + +This module customises the behaviour of the +OpenGL.raw.GL.APPLE.texture_range to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides a method to specify the range of client address + space that may be used by a texture. In general, the storage size of a + texture may be easily determined by the texture's data type and geometry. + However, driver optimizations may be realized if an extended address + range is specified to encompass the storage of multiple textures, or to + encompass potential future changes in the size of a texture. A typical + usage of this extension is to specify an identical address range for + several textures in a particular working set that encompasses the storage + of all the textures in the set. This allows the driver to make a single + memory mapping for all of the textures. + + Further, a mechanism is provided to allow the application to give the GL + driver a hint regarding the storage requirements of the texture data. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/APPLE/texture_range.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.APPLE.texture_range import * +from OpenGL.raw.GL.APPLE.texture_range import _EXTENSION_NAME + +def glInitTextureRangeAPPLE(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glTextureRangeAPPLE.pointer size not checked against length +glTextureRangeAPPLE=wrapper.wrapper(glTextureRangeAPPLE).setInputArraySize( + 'pointer', None +) +glGetTexParameterPointervAPPLE=wrapper.wrapper(glGetTexParameterPointervAPPLE).setOutput( + 'params',size=(1,),orPassIn=True +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/APPLE/transform_hint.py b/venv/lib/python3.12/site-packages/OpenGL/GL/APPLE/transform_hint.py new file mode 100644 index 00000000..b3206d84 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/APPLE/transform_hint.py @@ -0,0 +1,43 @@ +'''OpenGL extension APPLE.transform_hint + +This module customises the behaviour of the +OpenGL.raw.GL.APPLE.transform_hint to provide a more +Python-friendly API + +Overview (from the spec) + + The transform_hint extension provides a new target, + TRANSFORM_HINT_APPLE, for the Hint procedure. When the + transform hint is set to FASTEST the GL may choose to + implement certain state dependent algebraic simplifications + in the geometry transformation that affect the sub-pixel + precision of the transformed vertex coordinates. + + For example, if two polygons are rendered with identical object + coordinates, different GL state settings, and the transform + hint set to FASTEST, there is no gaurantee that the resulting + window coordinates of the two polygons will be precisely + identical. Therefore, precise tests of the window coordinates, + such as a depth test setting of EQUAL, should not be used. + + If the transform hint is set to NICEST or DONT_CARE, two polygons + with identical object coordinates will always be transformed + to identical window coordinates. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/APPLE/transform_hint.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.APPLE.transform_hint import * +from OpenGL.raw.GL.APPLE.transform_hint import _EXTENSION_NAME + +def glInitTransformHintAPPLE(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/APPLE/vertex_array_object.py b/venv/lib/python3.12/site-packages/OpenGL/GL/APPLE/vertex_array_object.py new file mode 100644 index 00000000..eba0dbd6 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/APPLE/vertex_array_object.py @@ -0,0 +1,52 @@ +'''OpenGL extension APPLE.vertex_array_object + +This module customises the behaviour of the +OpenGL.raw.GL.APPLE.vertex_array_object to provide a more +Python-friendly API + +Overview (from the spec) + + This extension introduces named vertex array objects which encapsulate + vertex array state on the client side. The main purpose of these + objects is to keep pointers to static vertex data and provide a name + for different sets of static vertex data. + + By extending vertex array range functionality this extension allows multiple + vertex array ranges to exist at one time, including their complete sets of + state, in manner analogous to texture objects. + + GenVertexArraysAPPLE creates a list of n number of vertex array object + names. After creating a name, BindVertexArrayAPPLE associates the name with + a vertex array object and selects this vertex array and its associated + state as current. To get back to the default vertex array and its + associated state the client should bind to vertex array named 0. + + Once a client is done using a vertex array object it can be deleted with + DeleteVertexArraysAPPLE. The client is responsible for allocating and + deallocating the memory used by the vertex array data, while the + DeleteVertexArraysAPPLE command deletes vertex array object names and + associated state only. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/APPLE/vertex_array_object.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.APPLE.vertex_array_object import * +from OpenGL.raw.GL.APPLE.vertex_array_object import _EXTENSION_NAME + +def glInitVertexArrayObjectAPPLE(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glDeleteVertexArraysAPPLE.arrays size not checked against n +glDeleteVertexArraysAPPLE=wrapper.wrapper(glDeleteVertexArraysAPPLE).setInputArraySize( + 'arrays', None +) +glGenVertexArraysAPPLE=wrapper.wrapper(glGenVertexArraysAPPLE).setOutput( + 'arrays',size=lambda x:(x,),pnameArg='n',orPassIn=True +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/APPLE/vertex_array_range.py b/venv/lib/python3.12/site-packages/OpenGL/GL/APPLE/vertex_array_range.py new file mode 100644 index 00000000..0eba692b --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/APPLE/vertex_array_range.py @@ -0,0 +1,154 @@ +'''OpenGL extension APPLE.vertex_array_range + +This module customises the behaviour of the +OpenGL.raw.GL.APPLE.vertex_array_range to provide a more +Python-friendly API + +Overview (from the spec) + + This extension is designed to allow very high vertex processing rates which + are facilitated both by relieving the CPU of as much processing burden as + possible and by allowing graphics hardware to directly access vertex data. + Because this extension is implemented as an addition to the vertex array + specification provided by OpenGL 1.1, applications can continue to use + existing vertex submission logic while taking advantage of vertex array + ranges to more efficiently process those arrays. + + The vertex array coherency model provided by OpenGL 1.1 requires that + vertex data specified in vertex arrays be transferred from system memory + each time Begin, DrawArrays, or DrawElements is called. Further, OpenGL + 1.1 requires that the transfer of data be completed by the time End, + DrawArrays, or DrawElements returns. Both of these requirements are + relaxed by the vertex array range extension. Vertex data may be cached + by the GL so there is no guarantee that changes to the vertex data will + be reflected in following drawing commands unless it is flushed with + FlushVertexArrayRangeAPPLE. The reading of vertex data may be deferred + by the GL so there is no guarantee that the GL will be finished reading + the data until completion is forced by the use of Finish or the APPLE_fence + extension. + + Vertex array range can be enabled in two ways. EnableClientState can be + used with the VERTEX_ARRAY_RANGE_APPLE param to enable vertex array range + for the client context. One can also simply set the vertex array storage + hint to either STORAGE_CACHED_APPLE or STORAGE_SHARED_APPLE (as discussed + below) to enable a particular vertex array range. Once this is done, use of + vertex array range requires the definition of a specific memory range for + vertex data through VertexArrayRangeAPPLE. It is recommended this data be + page aligned (4096 byte boundaries) and a multiple of page size in length + for maximum efficiency in data handling and internal flushing, but this is + not a requirement and any location and length of data can be defined as a + vertex array. This extension provides no memory allocators as any + convenient memory allocator can be used. + + Once a data set is established, using VertexArrayRangeAPPLE, it can be can + be drawn using standard OpenGL vertex array commands, as one would do + without this extension. Note, if any the data for any enabled array for a + given array element index falls outside of the vertex array range, an + undefined vertex is generated. One should also understand removing or + replacing all calls to vertex array range functions with no-ops or disabling + the vertex array range by disabling the VERTEX_ARRAY_RANGE_APPLE client + state should not change the results of an application's OpenGL drawing. + + For static data no additional coherency nor synchronization must be done and + the client is free to draw with the specified draw as it sees fit. + + If data is dynamic, thus to be modified, FlushVertexArrayRangeAPPLE should + be used. The command is issued when data has been modified since the last + call to VertexArrayRangeAPPLE or FlushVertexArrayRangeAPPLE and prior to + drawing with such data. FlushVertexArrayRangeAPPLE only provides memory + coherency prior to drawing (such as ensuring CPU caches are flushed or VRAM + cached copies are updated) and does not provide any synchronization with + previously issued drawing commands. The range flushed can be the specific + range modified and does not have to be the entire vertex array range. + Additionally, data maybe read immediately after a flush without need for + further synchronization, thus overlapping areas of data maybe read, modified + and written between two successive flushes and the data will be + consistent. + + To synchronize data modification after drawing two methods can be used. A + Finish command can be issued which will not return until all previously + issued commands are complete, forcing completely synchronous operation. + While this guarantees all drawing is complete it may not be the optimal + solution for clients which just need to ensure drawing with the vertex array + range or a specific range with the array is compete. The APPLE_fence + extension can be used when dynamic data modifications need to be + synchronized with drawing commands. Specifically, if data is to be modified, + a fence can be set immediately after drawing with the data. Once it comes + time to modify the data, the application must test (or finish) this fence to + ensure the drawing command has completed. Failure to do this could result in + new data being used by the previously issued drawing commands. It should be + noted that providing the maximum time between the drawing set fence and the + modification test/finish fence allows the most asynchronous behavior and + will result in the least stalling waiting for drawing completion. Techniques + such as double buffering vertex data can be used to help further prevent + stalls based on fence completion but are beyond the scope of this extension. + + Once an application is finished with a specific vertex array range or at + latest prior to exit, and prior to freeing the memory associated with this + vertex array, the client should call VertexArrayRangeAPPLE with a data + location and length of 0 to allow the internal memory managers to complete + any commitments for the array range. In this case once + VertexArrayRangeAPPLE returns it is safe to de-allocate the memory. + + Three types of storage hints are available for vertex array ranges; client, + shared, and cached. These hints are set by passing the + STORAGE_CLIENT_APPLE, STORAGE_SHARED_APPLE, or STORAGE_CACHED_APPLE param to + VertexArrayParameteriAPPLE with VERTEX_ARRAY_STORAGE_HINT_APPLE pname. + Client storage, the default OpenGL behavior, occurs when + VERTEX_ARRAY_RANGE_APPLE is disabled AND the STORAGE_CLIENT_APPLE hint is + set. Note, STORAGE_CLIENT_APPLE is also the default hint setting. Shared + memory usage is normally used for dynamic data that is expected to be + modified and is likely mapped to AGP memory space for access by both the + graphics hardware and client. It is set when either + VERTEX_ARRAY_RANGE_APPLE is enabled, without the STORAGE_CACHED_APPLE hint + being set, or in all cases when the STORAGE_SHARED_APPLE hint is set. + Finally, the cached storage is designed to support static data and data which + could be cached in VRAM. This provides maximum access bandwidth for the + vertex array and occurs when the STORAGE_CACHED_APPLE hint is set. + + The following pseudo-code represents the treatment of a vertex array range + memory depending on the hint setting and whether vertex array range is + enabled for the client context: + + if (VERTEX_ARRAY_STORAGE_HINT_APPLE == STORAGE_CACHED_APPLE) + vertex array is treated as cached + else if (VERTEX_ARRAY_STORAGE_HINT_APPLE == STORAGE_SHARED_APPLE) + vertex array is treated as shared + else if (VERTEX_ARRAY_RANGE_APPLE enabled) + vertex array is treated as shared + else + vertex array is treated as client + + Note, these hints can affect how array flushes are handled and the overhead + associated with flushing the array, it is recommended that data be handled + as shared unless it really is static and there are no plans to modify it. + + To summarize the vertex array range extension provides relaxed + synchronization rules for handling vertex array data allowing high bandwidth + asynchronous data transfer from client memory to graphics hardware. + Different flushing and synchronization rules are required to ensure data + coherency when modifying data. Lastly, memory handling hints are provided + to allow the tunning of memory storage and access for maximum efficiency. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/APPLE/vertex_array_range.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.APPLE.vertex_array_range import * +from OpenGL.raw.GL.APPLE.vertex_array_range import _EXTENSION_NAME + +def glInitVertexArrayRangeAPPLE(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +glVertexArrayRangeAPPLE=wrapper.wrapper(glVertexArrayRangeAPPLE).setOutput( + 'pointer',size=lambda x:(x,),pnameArg='length',orPassIn=True +) +glFlushVertexArrayRangeAPPLE=wrapper.wrapper(glFlushVertexArrayRangeAPPLE).setOutput( + 'pointer',size=lambda x:(x,),pnameArg='length',orPassIn=True +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/APPLE/vertex_program_evaluators.py b/venv/lib/python3.12/site-packages/OpenGL/GL/APPLE/vertex_program_evaluators.py new file mode 100644 index 00000000..c5aecf9b --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/APPLE/vertex_program_evaluators.py @@ -0,0 +1,58 @@ +'''OpenGL extension APPLE.vertex_program_evaluators + +This module customises the behaviour of the +OpenGL.raw.GL.APPLE.vertex_program_evaluators to provide a more +Python-friendly API + +Overview (from the spec) + + This extension allows the one- and two-dimensional evaluators to be used + with vertex program attributes. The operation of this extension is + precisely analogous to the operation of the normal evaluators. + + Where normal evaluators are enabled with Enable(MAP1_VERTEX_3), for + example, attribute evaluators are enabled with + EnableVertexAttribAPPLE(index, VERTEX_ATTRIB_MAP1_APPLE). + + Where the size (1, 2, 3, or 4) of a normal evaluator is embedded in the + token for that evaluator (for example, MAP1_VERTEX_3 has size 3), + attribute evaluators give the size as an argument to MapVertexAttrib**APPLE. + + The 1D and 2D evaluator order, domain, and coefficients are given as + arguments to MapVertexAttrib**APPLE, with exactly the same meaning and + restrictions as the same arguments to Map1f, Map2f, Map1d, & Map2d. + The evaluator order, domain, and coefficients may be queried with + GetVertexAttrib*vARB, with the same operation as GetMap*v. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/APPLE/vertex_program_evaluators.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.APPLE.vertex_program_evaluators import * +from OpenGL.raw.GL.APPLE.vertex_program_evaluators import _EXTENSION_NAME + +def glInitVertexProgramEvaluatorsAPPLE(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glMapVertexAttrib1dAPPLE.points size not checked against 'size,stride,order' +glMapVertexAttrib1dAPPLE=wrapper.wrapper(glMapVertexAttrib1dAPPLE).setInputArraySize( + 'points', None +) +# INPUT glMapVertexAttrib1fAPPLE.points size not checked against 'size,stride,order' +glMapVertexAttrib1fAPPLE=wrapper.wrapper(glMapVertexAttrib1fAPPLE).setInputArraySize( + 'points', None +) +# INPUT glMapVertexAttrib2dAPPLE.points size not checked against 'size,ustride,uorder,vstride,vorder' +glMapVertexAttrib2dAPPLE=wrapper.wrapper(glMapVertexAttrib2dAPPLE).setInputArraySize( + 'points', None +) +# INPUT glMapVertexAttrib2fAPPLE.points size not checked against 'size,ustride,uorder,vstride,vorder' +glMapVertexAttrib2fAPPLE=wrapper.wrapper(glMapVertexAttrib2fAPPLE).setInputArraySize( + 'points', None +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/APPLE/ycbcr_422.py b/venv/lib/python3.12/site-packages/OpenGL/GL/APPLE/ycbcr_422.py new file mode 100644 index 00000000..bcc27ff9 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/APPLE/ycbcr_422.py @@ -0,0 +1,62 @@ +'''OpenGL extension APPLE.ycbcr_422 + +This module customises the behaviour of the +OpenGL.raw.GL.APPLE.ycbcr_422 to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides a method for GL to read, store and optionally + process textures that are defined in Y'CbCr 422 video formats. This + extension supports the two common Y'CbCr 422 video formats (known by + QuickTime FourCC as '2vuy' and 'yuvs'). These formats represent one of the + most common 16 bit Y'CbCr formats in both standard and reverse byte + ordering. From a client stand point these can be assumed to be decoded + immediately (even though the implementation is free to optimize the data + storage and keep it in the native format) and otherwise function as any + other texture format. The texture command parameter + normally be should be specified as RGB, since Y'CbCr is just a form of RGB + data. This extension can be supported with either hardware or software + decoding and it is up to the specific implementation to determine which is + used. + + A new is added, YCBCR_422_APPLE. Additionally, to handle the + difference in pixel size and byte ordering for 422 video, the pixel storage + operations treat YCBCR_422_APPLE as a 2 component format using + the UNSIGNED_SHORT_8_8_APPLE or UNSIGNED_SHORT_8_8_REV_APPLE . + + The '2vuy' or k2vuyPixelFormat pixel format is an 8-bit 4:2:2 Component + Y'CbCr format. Each 16 bit pixel is represented by an unsigned eight bit + luminance component and two unsigned eight bit chroma components. Each pair + of pixels shares a common set of chroma values. The components are ordered + in memory; Cb, Y0, Cr, Y1. The luminance components have a range of [16, + 235], while the chroma value has a range of [16, 240]. This is consistent + with the CCIR601 spec. This format is fairly prevalent on both Mac and Win32 + platforms. The equivalent Microsoft fourCC is OUYVYO. This format is + supported with the UNSIGNED_SHORT_8_8_REV_APPLE type for pixel storage + operations. + + The 'yuvs' or kYUVSPixelFormat is an 8-bit 4:2:2 Component Y'CbCr format. + Identical to the k2vuyPixelFormat except each 16 bit word has been byte + swapped. This results in a component ordering of; Y0, Cb, Y1, Cr. This is + most prevalent yuv 4:2:2 format on both Mac and Win32 platforms. The + equivalent Microsoft fourCC is 'YUY2'. This format is supported with the + UNSIGNED_SHORT_8_8_APPLE type for pixel storage operations. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/APPLE/ycbcr_422.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.APPLE.ycbcr_422 import * +from OpenGL.raw.GL.APPLE.ycbcr_422 import _EXTENSION_NAME + +def glInitYcbcr422APPLE(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/ES2_compatibility.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/ES2_compatibility.py new file mode 100644 index 00000000..b9b81a94 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/ES2_compatibility.py @@ -0,0 +1,51 @@ +'''OpenGL extension ARB.ES2_compatibility + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.ES2_compatibility to provide a more +Python-friendly API + +Overview (from the spec) + + This extension adds support for features of OpenGL ES 2.0 that are + missing from OpenGL 3.x. Enabling these features will ease the process + of porting applications from OpenGL ES 2.0 to OpenGL. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/ES2_compatibility.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.ES2_compatibility import * +from OpenGL.raw.GL.ARB.ES2_compatibility import _EXTENSION_NAME + +def glInitEs2CompatibilityARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glShaderBinary.binary size not checked against length +# INPUT glShaderBinary.shaders size not checked against count +glShaderBinary=wrapper.wrapper(glShaderBinary).setInputArraySize( + 'binary', None +).setInputArraySize( + 'shaders', None +) +glGetShaderPrecisionFormat=wrapper.wrapper(glGetShaderPrecisionFormat).setOutput( + 'precision',size=(1,),orPassIn=True +).setOutput( + 'range',size=(2,),orPassIn=True +) +### END AUTOGENERATED SECTION +from OpenGL import lazywrapper as _lazywrapper +from OpenGL.arrays import GLintArray +@_lazywrapper.lazy( glGetShaderPrecisionFormat ) +def glGetShaderPrecisionFormat(baseOperation, shadertype, precisiontype, range=None,precision=None ): + """Provides range and precision if not provided, returns (range,precision)""" + if range is None: + range = GLintArray.zeros( (2,)) + if precision is None: + precision = GLintArray.zeros((2,)) + baseOperation( shadertype, precisiontype, range, precision ) + return range, precision diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/ES3_1_compatibility.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/ES3_1_compatibility.py new file mode 100644 index 00000000..154678de --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/ES3_1_compatibility.py @@ -0,0 +1,59 @@ +'''OpenGL extension ARB.ES3_1_compatibility + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.ES3_1_compatibility to provide a more +Python-friendly API + +Overview (from the spec) + + This extension adds support for features of OpenGL ES 3.1 that are + missing from OpenGL 4.4. Enabling these features will ease the process + of porting applications from OpenGL ES 3.1 to OpenGL. + + In particular this adds the following features: + + - a new MemoryBarrierByRegion API which is potentially more efficient + for specific localized memory access patterns. + + - increases the minimum required size of SSBOs to 2^27 (128 MB). + + - support for GLSL ES version 310 (ie #version 310 es). + + - a new GLSL built-in function, imageAtomicExchange, which performs atomic + exchanges on r32f floating point images. + + - a new GLSL built-in fragment shader input, gl_HelperInvocation, that + identifies whether the current fragment shader input is a helper + invocation. Fragment shader code can use this variable to skip performing + operations that are useless or potentially dangerous for helper + invocations. + + - a new GLSL built-in constant for the maximum supported samples: + gl_MaxSamples. + + - a number of new GLSL built-in constants mirroring the API limits for + image uniforms: gl_Max*ImageUniforms, gl_MaxCombinedShaderOutputResources. + + - new GLSL built-in functions which extend mix() to select between int, + uint, and bool components. + + - add the "coherent" qualifier to all memory variables taken by the GLSL + built-in atomic* and imageAtomic* functions. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/ES3_1_compatibility.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.ES3_1_compatibility import * +from OpenGL.raw.GL.ARB.ES3_1_compatibility import _EXTENSION_NAME + +def glInitEs31CompatibilityARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/ES3_2_compatibility.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/ES3_2_compatibility.py new file mode 100644 index 00000000..2c8d89da --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/ES3_2_compatibility.py @@ -0,0 +1,41 @@ +'''OpenGL extension ARB.ES3_2_compatibility + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.ES3_2_compatibility to provide a more +Python-friendly API + +Overview (from the spec) + + This extension adds support for features of OpenGL ES 3.2 that are + missing from OpenGL 4.5. Enabling these features will ease the process + of porting applications from OpenGL ES 3.2 to OpenGL. + + In particular this adds the following features: + + - Bounding box used to optimization tessellation processing + (OES_primitive_bounding_box) + - query for MULTISAMPLE_LINE_WIDTH_RANGE_ARB + - support for the OpenGL ES 3.20 shading language + + For full OpenGL ES 3.2 compatibility the implementation must support + KHR_blend_equation_advanced and KHR_texture_compression_astc_ldr. Those + features are not defined in this extension spec since they are already + defined at the KHR level. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/ES3_2_compatibility.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.ES3_2_compatibility import * +from OpenGL.raw.GL.ARB.ES3_2_compatibility import _EXTENSION_NAME + +def glInitEs32CompatibilityARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/ES3_compatibility.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/ES3_compatibility.py new file mode 100644 index 00000000..c11e1bd6 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/ES3_compatibility.py @@ -0,0 +1,32 @@ +'''OpenGL extension ARB.ES3_compatibility + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.ES3_compatibility to provide a more +Python-friendly API + +Overview (from the spec) + + This extension adds support for features of OpenGL ES 3.0 that are + missing from OpenGL 3.x. Enabling these features will ease the process + of porting applications from OpenGL ES 3.0 to OpenGL. These features + include conservative boolean occlusion queries, primitive restart with a + fixed index, the OpenGL ES Shading Language 3.00 specification, and the + dependencies stated above. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/ES3_compatibility.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.ES3_compatibility import * +from OpenGL.raw.GL.ARB.ES3_compatibility import _EXTENSION_NAME + +def glInitEs3CompatibilityARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/ES2_compatibility.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/ES2_compatibility.cpython-312.pyc new file mode 100644 index 00000000..13d39e43 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/ES2_compatibility.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/ES3_1_compatibility.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/ES3_1_compatibility.cpython-312.pyc new file mode 100644 index 00000000..bfec3d6c Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/ES3_1_compatibility.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/ES3_2_compatibility.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/ES3_2_compatibility.cpython-312.pyc new file mode 100644 index 00000000..018da879 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/ES3_2_compatibility.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/ES3_compatibility.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/ES3_compatibility.cpython-312.pyc new file mode 100644 index 00000000..183814d5 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/ES3_compatibility.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..b42dbe88 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/arrays_of_arrays.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/arrays_of_arrays.cpython-312.pyc new file mode 100644 index 00000000..779f7520 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/arrays_of_arrays.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/base_instance.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/base_instance.cpython-312.pyc new file mode 100644 index 00000000..16098f10 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/base_instance.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/bindless_texture.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/bindless_texture.cpython-312.pyc new file mode 100644 index 00000000..9729da00 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/bindless_texture.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/blend_func_extended.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/blend_func_extended.cpython-312.pyc new file mode 100644 index 00000000..0938d914 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/blend_func_extended.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/buffer_storage.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/buffer_storage.cpython-312.pyc new file mode 100644 index 00000000..e0564409 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/buffer_storage.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/cl_event.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/cl_event.cpython-312.pyc new file mode 100644 index 00000000..c75dbb25 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/cl_event.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/clear_buffer_object.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/clear_buffer_object.cpython-312.pyc new file mode 100644 index 00000000..f0eaf56d Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/clear_buffer_object.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/clear_texture.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/clear_texture.cpython-312.pyc new file mode 100644 index 00000000..4f6729ca Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/clear_texture.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/clip_control.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/clip_control.cpython-312.pyc new file mode 100644 index 00000000..4033f687 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/clip_control.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/color_buffer_float.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/color_buffer_float.cpython-312.pyc new file mode 100644 index 00000000..e6dafaec Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/color_buffer_float.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/compatibility.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/compatibility.cpython-312.pyc new file mode 100644 index 00000000..b3f7aed7 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/compatibility.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/compressed_texture_pixel_storage.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/compressed_texture_pixel_storage.cpython-312.pyc new file mode 100644 index 00000000..31b51184 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/compressed_texture_pixel_storage.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/compute_shader.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/compute_shader.cpython-312.pyc new file mode 100644 index 00000000..3f526bfb Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/compute_shader.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/compute_variable_group_size.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/compute_variable_group_size.cpython-312.pyc new file mode 100644 index 00000000..f053e7d2 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/compute_variable_group_size.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/conditional_render_inverted.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/conditional_render_inverted.cpython-312.pyc new file mode 100644 index 00000000..858145da Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/conditional_render_inverted.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/conservative_depth.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/conservative_depth.cpython-312.pyc new file mode 100644 index 00000000..9cb1dc1c Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/conservative_depth.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/copy_buffer.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/copy_buffer.cpython-312.pyc new file mode 100644 index 00000000..ee09a521 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/copy_buffer.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/copy_image.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/copy_image.cpython-312.pyc new file mode 100644 index 00000000..ccca0ff9 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/copy_image.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/cull_distance.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/cull_distance.cpython-312.pyc new file mode 100644 index 00000000..b0b45e58 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/cull_distance.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/debug_output.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/debug_output.cpython-312.pyc new file mode 100644 index 00000000..cdaf6496 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/debug_output.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/depth_buffer_float.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/depth_buffer_float.cpython-312.pyc new file mode 100644 index 00000000..36411da0 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/depth_buffer_float.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/depth_clamp.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/depth_clamp.cpython-312.pyc new file mode 100644 index 00000000..bf96695b Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/depth_clamp.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/depth_texture.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/depth_texture.cpython-312.pyc new file mode 100644 index 00000000..e1b51688 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/depth_texture.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/derivative_control.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/derivative_control.cpython-312.pyc new file mode 100644 index 00000000..82202be5 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/derivative_control.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/direct_state_access.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/direct_state_access.cpython-312.pyc new file mode 100644 index 00000000..bc74ec7d Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/direct_state_access.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/draw_buffers.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/draw_buffers.cpython-312.pyc new file mode 100644 index 00000000..837929be Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/draw_buffers.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/draw_buffers_blend.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/draw_buffers_blend.cpython-312.pyc new file mode 100644 index 00000000..baf54cb7 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/draw_buffers_blend.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/draw_elements_base_vertex.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/draw_elements_base_vertex.cpython-312.pyc new file mode 100644 index 00000000..42bc4c99 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/draw_elements_base_vertex.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/draw_indirect.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/draw_indirect.cpython-312.pyc new file mode 100644 index 00000000..41096084 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/draw_indirect.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/draw_instanced.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/draw_instanced.cpython-312.pyc new file mode 100644 index 00000000..c6eff674 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/draw_instanced.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/enhanced_layouts.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/enhanced_layouts.cpython-312.pyc new file mode 100644 index 00000000..b6c12a7b Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/enhanced_layouts.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/explicit_attrib_location.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/explicit_attrib_location.cpython-312.pyc new file mode 100644 index 00000000..98b2d4b8 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/explicit_attrib_location.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/explicit_uniform_location.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/explicit_uniform_location.cpython-312.pyc new file mode 100644 index 00000000..b08d0458 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/explicit_uniform_location.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/fragment_coord_conventions.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/fragment_coord_conventions.cpython-312.pyc new file mode 100644 index 00000000..fc082f34 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/fragment_coord_conventions.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/fragment_layer_viewport.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/fragment_layer_viewport.cpython-312.pyc new file mode 100644 index 00000000..79b3a60b Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/fragment_layer_viewport.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/fragment_program.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/fragment_program.cpython-312.pyc new file mode 100644 index 00000000..b05f2923 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/fragment_program.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/fragment_program_shadow.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/fragment_program_shadow.cpython-312.pyc new file mode 100644 index 00000000..8eb01e2d Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/fragment_program_shadow.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/fragment_shader.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/fragment_shader.cpython-312.pyc new file mode 100644 index 00000000..a3e8b466 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/fragment_shader.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/fragment_shader_interlock.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/fragment_shader_interlock.cpython-312.pyc new file mode 100644 index 00000000..85e90df8 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/fragment_shader_interlock.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/framebuffer_no_attachments.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/framebuffer_no_attachments.cpython-312.pyc new file mode 100644 index 00000000..f4804716 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/framebuffer_no_attachments.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/framebuffer_object.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/framebuffer_object.cpython-312.pyc new file mode 100644 index 00000000..77168ae6 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/framebuffer_object.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/framebuffer_sRGB.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/framebuffer_sRGB.cpython-312.pyc new file mode 100644 index 00000000..0633e1a6 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/framebuffer_sRGB.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/geometry_shader4.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/geometry_shader4.cpython-312.pyc new file mode 100644 index 00000000..9dd89805 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/geometry_shader4.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/get_program_binary.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/get_program_binary.cpython-312.pyc new file mode 100644 index 00000000..77be33b7 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/get_program_binary.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/get_texture_sub_image.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/get_texture_sub_image.cpython-312.pyc new file mode 100644 index 00000000..b40a6277 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/get_texture_sub_image.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/gl_spirv.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/gl_spirv.cpython-312.pyc new file mode 100644 index 00000000..71c57a25 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/gl_spirv.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/gpu_shader5.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/gpu_shader5.cpython-312.pyc new file mode 100644 index 00000000..75cd73ec Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/gpu_shader5.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/gpu_shader_fp64.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/gpu_shader_fp64.cpython-312.pyc new file mode 100644 index 00000000..04ee855f Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/gpu_shader_fp64.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/gpu_shader_int64.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/gpu_shader_int64.cpython-312.pyc new file mode 100644 index 00000000..4d1e527a Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/gpu_shader_int64.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/half_float_pixel.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/half_float_pixel.cpython-312.pyc new file mode 100644 index 00000000..fca3e7b8 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/half_float_pixel.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/half_float_vertex.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/half_float_vertex.cpython-312.pyc new file mode 100644 index 00000000..dc26d332 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/half_float_vertex.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/imaging.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/imaging.cpython-312.pyc new file mode 100644 index 00000000..2280a07a Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/imaging.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/indirect_parameters.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/indirect_parameters.cpython-312.pyc new file mode 100644 index 00000000..2cb3db17 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/indirect_parameters.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/instanced_arrays.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/instanced_arrays.cpython-312.pyc new file mode 100644 index 00000000..1bcffd92 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/instanced_arrays.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/internalformat_query.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/internalformat_query.cpython-312.pyc new file mode 100644 index 00000000..f6a84169 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/internalformat_query.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/internalformat_query2.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/internalformat_query2.cpython-312.pyc new file mode 100644 index 00000000..376f3a11 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/internalformat_query2.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/invalidate_subdata.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/invalidate_subdata.cpython-312.pyc new file mode 100644 index 00000000..f0f23bea Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/invalidate_subdata.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/map_buffer_alignment.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/map_buffer_alignment.cpython-312.pyc new file mode 100644 index 00000000..9c383114 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/map_buffer_alignment.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/map_buffer_range.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/map_buffer_range.cpython-312.pyc new file mode 100644 index 00000000..e522f1f5 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/map_buffer_range.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/matrix_palette.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/matrix_palette.cpython-312.pyc new file mode 100644 index 00000000..985061ae Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/matrix_palette.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/multi_bind.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/multi_bind.cpython-312.pyc new file mode 100644 index 00000000..abe023ca Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/multi_bind.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/multi_draw_indirect.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/multi_draw_indirect.cpython-312.pyc new file mode 100644 index 00000000..84766e4e Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/multi_draw_indirect.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/multisample.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/multisample.cpython-312.pyc new file mode 100644 index 00000000..129dfcd0 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/multisample.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/multitexture.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/multitexture.cpython-312.pyc new file mode 100644 index 00000000..daf268f3 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/multitexture.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/occlusion_query.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/occlusion_query.cpython-312.pyc new file mode 100644 index 00000000..fb99d4e2 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/occlusion_query.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/occlusion_query2.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/occlusion_query2.cpython-312.pyc new file mode 100644 index 00000000..e22e4071 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/occlusion_query2.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/parallel_shader_compile.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/parallel_shader_compile.cpython-312.pyc new file mode 100644 index 00000000..4652fad2 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/parallel_shader_compile.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/pipeline_statistics_query.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/pipeline_statistics_query.cpython-312.pyc new file mode 100644 index 00000000..7d569e2e Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/pipeline_statistics_query.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/pixel_buffer_object.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/pixel_buffer_object.cpython-312.pyc new file mode 100644 index 00000000..3399cd3e Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/pixel_buffer_object.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/point_parameters.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/point_parameters.cpython-312.pyc new file mode 100644 index 00000000..a5ffa40b Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/point_parameters.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/point_sprite.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/point_sprite.cpython-312.pyc new file mode 100644 index 00000000..651bfa2b Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/point_sprite.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/polygon_offset_clamp.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/polygon_offset_clamp.cpython-312.pyc new file mode 100644 index 00000000..b49b355c Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/polygon_offset_clamp.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/post_depth_coverage.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/post_depth_coverage.cpython-312.pyc new file mode 100644 index 00000000..667a0d82 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/post_depth_coverage.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/program_interface_query.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/program_interface_query.cpython-312.pyc new file mode 100644 index 00000000..a843bffa Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/program_interface_query.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/provoking_vertex.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/provoking_vertex.cpython-312.pyc new file mode 100644 index 00000000..cb024a19 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/provoking_vertex.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/query_buffer_object.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/query_buffer_object.cpython-312.pyc new file mode 100644 index 00000000..98c2b6e2 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/query_buffer_object.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/robust_buffer_access_behavior.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/robust_buffer_access_behavior.cpython-312.pyc new file mode 100644 index 00000000..afa4b796 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/robust_buffer_access_behavior.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/robustness.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/robustness.cpython-312.pyc new file mode 100644 index 00000000..831642c1 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/robustness.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/robustness_isolation.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/robustness_isolation.cpython-312.pyc new file mode 100644 index 00000000..42450883 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/robustness_isolation.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/sample_locations.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/sample_locations.cpython-312.pyc new file mode 100644 index 00000000..47661eb7 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/sample_locations.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/sample_shading.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/sample_shading.cpython-312.pyc new file mode 100644 index 00000000..5ad3b54d Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/sample_shading.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/sampler_objects.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/sampler_objects.cpython-312.pyc new file mode 100644 index 00000000..008d2b51 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/sampler_objects.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/seamless_cube_map.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/seamless_cube_map.cpython-312.pyc new file mode 100644 index 00000000..9a54ac4d Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/seamless_cube_map.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/seamless_cubemap_per_texture.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/seamless_cubemap_per_texture.cpython-312.pyc new file mode 100644 index 00000000..9747bd1a Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/seamless_cubemap_per_texture.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/separate_shader_objects.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/separate_shader_objects.cpython-312.pyc new file mode 100644 index 00000000..e61478cd Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/separate_shader_objects.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/shader_atomic_counter_ops.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/shader_atomic_counter_ops.cpython-312.pyc new file mode 100644 index 00000000..d95b381d Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/shader_atomic_counter_ops.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/shader_atomic_counters.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/shader_atomic_counters.cpython-312.pyc new file mode 100644 index 00000000..10ac91e5 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/shader_atomic_counters.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/shader_ballot.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/shader_ballot.cpython-312.pyc new file mode 100644 index 00000000..c5ffa04a Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/shader_ballot.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/shader_bit_encoding.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/shader_bit_encoding.cpython-312.pyc new file mode 100644 index 00000000..eaf9cd29 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/shader_bit_encoding.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/shader_clock.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/shader_clock.cpython-312.pyc new file mode 100644 index 00000000..be0c21e4 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/shader_clock.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/shader_draw_parameters.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/shader_draw_parameters.cpython-312.pyc new file mode 100644 index 00000000..fb1755fc Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/shader_draw_parameters.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/shader_group_vote.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/shader_group_vote.cpython-312.pyc new file mode 100644 index 00000000..e538e914 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/shader_group_vote.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/shader_image_load_store.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/shader_image_load_store.cpython-312.pyc new file mode 100644 index 00000000..403f5d9f Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/shader_image_load_store.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/shader_image_size.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/shader_image_size.cpython-312.pyc new file mode 100644 index 00000000..5fb21fde Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/shader_image_size.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/shader_objects.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/shader_objects.cpython-312.pyc new file mode 100644 index 00000000..ee0b2bbc Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/shader_objects.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/shader_precision.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/shader_precision.cpython-312.pyc new file mode 100644 index 00000000..8d6ba199 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/shader_precision.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/shader_stencil_export.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/shader_stencil_export.cpython-312.pyc new file mode 100644 index 00000000..43021413 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/shader_stencil_export.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/shader_storage_buffer_object.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/shader_storage_buffer_object.cpython-312.pyc new file mode 100644 index 00000000..fb6fa731 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/shader_storage_buffer_object.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/shader_subroutine.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/shader_subroutine.cpython-312.pyc new file mode 100644 index 00000000..06a1b805 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/shader_subroutine.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/shader_texture_image_samples.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/shader_texture_image_samples.cpython-312.pyc new file mode 100644 index 00000000..ca03e381 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/shader_texture_image_samples.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/shader_texture_lod.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/shader_texture_lod.cpython-312.pyc new file mode 100644 index 00000000..c23bcbe5 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/shader_texture_lod.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/shader_viewport_layer_array.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/shader_viewport_layer_array.cpython-312.pyc new file mode 100644 index 00000000..0793739b Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/shader_viewport_layer_array.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/shading_language_100.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/shading_language_100.cpython-312.pyc new file mode 100644 index 00000000..0e69ac18 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/shading_language_100.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/shading_language_420pack.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/shading_language_420pack.cpython-312.pyc new file mode 100644 index 00000000..d28c5407 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/shading_language_420pack.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/shading_language_include.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/shading_language_include.cpython-312.pyc new file mode 100644 index 00000000..0c9649b6 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/shading_language_include.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/shading_language_packing.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/shading_language_packing.cpython-312.pyc new file mode 100644 index 00000000..92d9a7e3 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/shading_language_packing.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/shadow.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/shadow.cpython-312.pyc new file mode 100644 index 00000000..f43774c4 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/shadow.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/shadow_ambient.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/shadow_ambient.cpython-312.pyc new file mode 100644 index 00000000..601ab7c9 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/shadow_ambient.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/sparse_buffer.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/sparse_buffer.cpython-312.pyc new file mode 100644 index 00000000..537839c5 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/sparse_buffer.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/sparse_texture.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/sparse_texture.cpython-312.pyc new file mode 100644 index 00000000..6d9a294f Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/sparse_texture.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/sparse_texture2.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/sparse_texture2.cpython-312.pyc new file mode 100644 index 00000000..927f63ff Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/sparse_texture2.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/sparse_texture_clamp.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/sparse_texture_clamp.cpython-312.pyc new file mode 100644 index 00000000..ab2860d9 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/sparse_texture_clamp.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/spirv_extensions.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/spirv_extensions.cpython-312.pyc new file mode 100644 index 00000000..9116fc80 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/spirv_extensions.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/stencil_texturing.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/stencil_texturing.cpython-312.pyc new file mode 100644 index 00000000..716b16e7 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/stencil_texturing.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/sync.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/sync.cpython-312.pyc new file mode 100644 index 00000000..03aa5be5 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/sync.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/tessellation_shader.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/tessellation_shader.cpython-312.pyc new file mode 100644 index 00000000..2f4a34ce Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/tessellation_shader.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/texture_barrier.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/texture_barrier.cpython-312.pyc new file mode 100644 index 00000000..de8ed44f Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/texture_barrier.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/texture_border_clamp.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/texture_border_clamp.cpython-312.pyc new file mode 100644 index 00000000..e778f780 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/texture_border_clamp.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/texture_buffer_object.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/texture_buffer_object.cpython-312.pyc new file mode 100644 index 00000000..bcacb3a2 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/texture_buffer_object.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/texture_buffer_object_rgb32.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/texture_buffer_object_rgb32.cpython-312.pyc new file mode 100644 index 00000000..b07ac691 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/texture_buffer_object_rgb32.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/texture_buffer_range.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/texture_buffer_range.cpython-312.pyc new file mode 100644 index 00000000..76e0c359 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/texture_buffer_range.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/texture_compression.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/texture_compression.cpython-312.pyc new file mode 100644 index 00000000..0abb3e5c Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/texture_compression.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/texture_compression_bptc.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/texture_compression_bptc.cpython-312.pyc new file mode 100644 index 00000000..8e4126a2 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/texture_compression_bptc.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/texture_compression_rgtc.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/texture_compression_rgtc.cpython-312.pyc new file mode 100644 index 00000000..f8a71252 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/texture_compression_rgtc.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/texture_cube_map.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/texture_cube_map.cpython-312.pyc new file mode 100644 index 00000000..54e78f51 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/texture_cube_map.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/texture_cube_map_array.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/texture_cube_map_array.cpython-312.pyc new file mode 100644 index 00000000..c9f46a1f Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/texture_cube_map_array.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/texture_env_add.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/texture_env_add.cpython-312.pyc new file mode 100644 index 00000000..6f059fc2 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/texture_env_add.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/texture_env_combine.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/texture_env_combine.cpython-312.pyc new file mode 100644 index 00000000..31a175f0 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/texture_env_combine.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/texture_env_crossbar.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/texture_env_crossbar.cpython-312.pyc new file mode 100644 index 00000000..60ee2f45 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/texture_env_crossbar.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/texture_env_dot3.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/texture_env_dot3.cpython-312.pyc new file mode 100644 index 00000000..db962a5a Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/texture_env_dot3.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/texture_filter_anisotropic.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/texture_filter_anisotropic.cpython-312.pyc new file mode 100644 index 00000000..5223e733 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/texture_filter_anisotropic.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/texture_filter_minmax.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/texture_filter_minmax.cpython-312.pyc new file mode 100644 index 00000000..f102ac06 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/texture_filter_minmax.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/texture_float.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/texture_float.cpython-312.pyc new file mode 100644 index 00000000..fdca2f84 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/texture_float.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/texture_gather.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/texture_gather.cpython-312.pyc new file mode 100644 index 00000000..2c6a25dc Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/texture_gather.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/texture_mirror_clamp_to_edge.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/texture_mirror_clamp_to_edge.cpython-312.pyc new file mode 100644 index 00000000..4ac43fa9 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/texture_mirror_clamp_to_edge.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/texture_mirrored_repeat.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/texture_mirrored_repeat.cpython-312.pyc new file mode 100644 index 00000000..f424db4b Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/texture_mirrored_repeat.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/texture_multisample.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/texture_multisample.cpython-312.pyc new file mode 100644 index 00000000..9d6cf1b5 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/texture_multisample.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/texture_non_power_of_two.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/texture_non_power_of_two.cpython-312.pyc new file mode 100644 index 00000000..3735a782 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/texture_non_power_of_two.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/texture_query_levels.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/texture_query_levels.cpython-312.pyc new file mode 100644 index 00000000..95b8132a Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/texture_query_levels.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/texture_query_lod.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/texture_query_lod.cpython-312.pyc new file mode 100644 index 00000000..92fe4b18 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/texture_query_lod.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/texture_rectangle.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/texture_rectangle.cpython-312.pyc new file mode 100644 index 00000000..ab66a0b5 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/texture_rectangle.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/texture_rg.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/texture_rg.cpython-312.pyc new file mode 100644 index 00000000..d17593f9 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/texture_rg.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/texture_rgb10_a2ui.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/texture_rgb10_a2ui.cpython-312.pyc new file mode 100644 index 00000000..305971ad Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/texture_rgb10_a2ui.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/texture_stencil8.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/texture_stencil8.cpython-312.pyc new file mode 100644 index 00000000..0b2a67bf Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/texture_stencil8.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/texture_storage.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/texture_storage.cpython-312.pyc new file mode 100644 index 00000000..410f354f Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/texture_storage.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/texture_storage_multisample.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/texture_storage_multisample.cpython-312.pyc new file mode 100644 index 00000000..5c93d3ea Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/texture_storage_multisample.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/texture_swizzle.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/texture_swizzle.cpython-312.pyc new file mode 100644 index 00000000..012dec6c Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/texture_swizzle.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/texture_view.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/texture_view.cpython-312.pyc new file mode 100644 index 00000000..f9b2a65e Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/texture_view.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/timer_query.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/timer_query.cpython-312.pyc new file mode 100644 index 00000000..18ce65d5 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/timer_query.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/transform_feedback2.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/transform_feedback2.cpython-312.pyc new file mode 100644 index 00000000..d1177c3a Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/transform_feedback2.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/transform_feedback3.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/transform_feedback3.cpython-312.pyc new file mode 100644 index 00000000..932e3080 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/transform_feedback3.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/transform_feedback_instanced.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/transform_feedback_instanced.cpython-312.pyc new file mode 100644 index 00000000..67c8f5a8 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/transform_feedback_instanced.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/transform_feedback_overflow_query.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/transform_feedback_overflow_query.cpython-312.pyc new file mode 100644 index 00000000..8df5b7ce Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/transform_feedback_overflow_query.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/transpose_matrix.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/transpose_matrix.cpython-312.pyc new file mode 100644 index 00000000..43ca6f7d Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/transpose_matrix.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/uniform_buffer_object.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/uniform_buffer_object.cpython-312.pyc new file mode 100644 index 00000000..af427963 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/uniform_buffer_object.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/vboimplementation.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/vboimplementation.cpython-312.pyc new file mode 100644 index 00000000..0fe616ab Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/vboimplementation.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/vertex_array_bgra.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/vertex_array_bgra.cpython-312.pyc new file mode 100644 index 00000000..39eb931d Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/vertex_array_bgra.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/vertex_array_object.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/vertex_array_object.cpython-312.pyc new file mode 100644 index 00000000..ca3e369f Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/vertex_array_object.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/vertex_attrib_64bit.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/vertex_attrib_64bit.cpython-312.pyc new file mode 100644 index 00000000..64374cab Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/vertex_attrib_64bit.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/vertex_attrib_binding.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/vertex_attrib_binding.cpython-312.pyc new file mode 100644 index 00000000..060afc73 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/vertex_attrib_binding.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/vertex_blend.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/vertex_blend.cpython-312.pyc new file mode 100644 index 00000000..735233e1 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/vertex_blend.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/vertex_buffer_object.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/vertex_buffer_object.cpython-312.pyc new file mode 100644 index 00000000..84e17d68 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/vertex_buffer_object.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/vertex_program.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/vertex_program.cpython-312.pyc new file mode 100644 index 00000000..c3cbcff9 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/vertex_program.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/vertex_shader.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/vertex_shader.cpython-312.pyc new file mode 100644 index 00000000..a6b46cab Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/vertex_shader.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/vertex_type_10f_11f_11f_rev.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/vertex_type_10f_11f_11f_rev.cpython-312.pyc new file mode 100644 index 00000000..c6fdd164 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/vertex_type_10f_11f_11f_rev.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/vertex_type_2_10_10_10_rev.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/vertex_type_2_10_10_10_rev.cpython-312.pyc new file mode 100644 index 00000000..b2bfabf7 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/vertex_type_2_10_10_10_rev.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/viewport_array.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/viewport_array.cpython-312.pyc new file mode 100644 index 00000000..937543b4 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/viewport_array.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/window_pos.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/window_pos.cpython-312.pyc new file mode 100644 index 00000000..51c786ff Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/__pycache__/window_pos.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/arrays_of_arrays.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/arrays_of_arrays.py new file mode 100644 index 00000000..dd8dc970 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/arrays_of_arrays.py @@ -0,0 +1,115 @@ +'''OpenGL extension ARB.arrays_of_arrays + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.arrays_of_arrays to provide a more +Python-friendly API + +Overview (from the spec) + + Multi-dimensional arrays are a frequently requested feature. This extension + removes the restriciton that arrays cannot be formed into arrays, allowing + arrays of arrays to be declared. Technically, removing this restriction is + all that is necessary to enable this feature, but it is worthwhile showing + what the result of doing that looks like. + + The following will be true of arrays of arrays + + - They will first class objects. (They know their size, can be passed by + copy-in semantics to functions, etc.) + + - They will only be one-dimensional arrays of other first class objects. + (arrays are already first class objects). + + - The syntax + + vec4 a[3][2]; + + Declares a one-dimensional array of size 3 of one-dimensional arrays of + size 2 of vec4s. Also, these syntaxes do the same thing: + + vec4[2] a[3]; + vec4[3][2] a; + + or, looking at more dimensions, these are all the same + + int a[1][2][3][4][5][6]; + + int[1][2][3][4][5][6] a; + + int[4][5][6] a[1][2][3]; + + note this latter is equivalent to C, in meaning the same thing, if done as + + typedef int int456[4][5][6]; + + int456 a[1][2][3]; + + that is, this GLSL proposal matches C behavior in this way. The type needed for + both constructors and nameless parameters is: + + int[1][2][3][4][5][6] + + - This type could be declared as a formal parameter in a function prototype as + + void foo(vec4[3][2]); + + - Accessing is done as + + a[x][y] // x selects which array of size 2 is desired + // y selects which vec4 is desired + + a[x] // this results in a one-dimensional array, with all rights and + // priviledges implied + + - The .length() operator works as normal: + + a.length() // this is 3 + a[x].length() // this is 2 + + - The constructor for the above is + + vec4[3][2](vec4[2](vec4(0.0), vec4(1.0)), + vec4[2](vec4(0.0), vec4(1.0)), + vec4[2](vec4(0.0), vec4(1.0))) + + - Initializers for the above are + + vec4 a[3][2] = vec4[3][2](vec4[2](vec4(0.0), vec4(1.0)), + vec4[2](vec4(0.0), vec4(1.0)), + vec4[2](vec4(0.0), vec4(1.0))); + + // or + + vec4 a[3][2] = {vec4[2](vec4(0.0), vec4(1.0)), + vec4[2](vec4(0.0), vec4(1.0)), + vec4[2](vec4(0.0), vec4(1.0))) }; + + // or + + vec4 a[3][2] = {{ vec4(0.0), vec4(1.0) }, + { vec4(0.0), vec4(1.0) }, + { vec4(0.0), vec4(1.0) } }; // requires matching nesting of + // {} with object's hierarchy + + + Note that all the above is naturally already specified in the core + specification. + + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/arrays_of_arrays.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.arrays_of_arrays import * +from OpenGL.raw.GL.ARB.arrays_of_arrays import _EXTENSION_NAME + +def glInitArraysOfArraysARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/base_instance.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/base_instance.py new file mode 100644 index 00000000..e9c58aaa --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/base_instance.py @@ -0,0 +1,50 @@ +'''OpenGL extension ARB.base_instance + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.base_instance to provide a more +Python-friendly API + +Overview (from the spec) + + This extension allows the offset within buffer objects used for instanced + rendering to be specified. This is congruent with the parameter + in glDrawArrays and the parameter in glDrawElements. When + instanced rendering is performed (for example, through + glDrawArraysInstanced), instanced vertex attributes whose vertex attribute + divisors are non-zero are fetched from enabled vertex arrays per-instance + rather than per-vertex. However, in unextended OpenGL, there is no way to + define the offset into those arrays from which the attributes are fetched. + This extension adds that offset in the form of a parameter + to several new procedures. + + The parameter is added to the index of the array element, + after division by the vertex attribute divisor. This allows several sets of + instanced vertex attribute data to be stored in a single vertex array, and + the base offset of that data to be specified for each draw. Further, this + extension exposes the parameter as the final and previously + undefined structure member of the draw-indirect data structure. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/base_instance.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.base_instance import * +from OpenGL.raw.GL.ARB.base_instance import _EXTENSION_NAME + +def glInitBaseInstanceARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glDrawElementsInstancedBaseInstance.indices size not checked against count +glDrawElementsInstancedBaseInstance=wrapper.wrapper(glDrawElementsInstancedBaseInstance).setInputArraySize( + 'indices', None +) +# INPUT glDrawElementsInstancedBaseVertexBaseInstance.indices size not checked against count +glDrawElementsInstancedBaseVertexBaseInstance=wrapper.wrapper(glDrawElementsInstancedBaseVertexBaseInstance).setInputArraySize( + 'indices', None +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/bindless_texture.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/bindless_texture.py new file mode 100644 index 00000000..828783ae --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/bindless_texture.py @@ -0,0 +1,76 @@ +'''OpenGL extension ARB.bindless_texture + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.bindless_texture to provide a more +Python-friendly API + +Overview (from the spec) + + This extension allows OpenGL applications to access texture objects in + shaders without first binding each texture to one of a limited number of + texture image units. Using this extension, an application can query a + 64-bit unsigned integer texture handle for each texture that it wants to + access and then use that handle directly in GLSL or assembly-based + shaders. The ability to access textures without having to bind and/or + re-bind them is similar to the capability provided by the + NV_shader_buffer_load extension that allows shaders to access buffer + objects without binding them. In both cases, these extensions + significantly reduce the amount of API and internal GL driver overhead + needed to manage resource bindings. + + This extension also provides similar capability for the image load, store, + and atomic functionality provided by OpenGL 4.2 and the + ARB_shader_image_load_store and EXT_shader_image_load_store extensions, + where a texture can be accessed without first binding it to an image unit. + An image handle can be extracted from a texture object using an API with a + set of parameters similar to those for BindImageTextureEXT. + + This extension adds no new data types to GLSL. Instead, it uses existing + sampler and image data types and allows them to be populated with texture + and image handles. This extension does permit sampler and image data + types to be used in more contexts than in unextended GLSL 4.00. In + particular, sampler and image types may be used as shader inputs/outputs, + temporary variables, and uniform block members, and may be assigned to by + shader code. Constructors are provided to convert unsigned integer values + to and from sampler and image data types. Additionally, new APIs are + provided to load values for sampler and image uniforms with 64-bit + handle inputs. The use of existing integer-based Uniform* APIs is still + permitted, in which case the integer specified will identify a texture + image or image unit. For samplers and images with values specified as + texture image or image units, the GL implemenation will translate the unit + number to an internal handle as required. + + To access texture or image resources using handles, the handles must first + be made resident. Accessing a texture or image by handle without first + making it resident can result in undefined results, including program + termination. Since the amount of texture memory required by an + application may exceed the amount of memory available to the system, this + extension provides API calls allowing applications to manage overall + texture memory consumption by making a texture resident and non-resident + as required. + + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/bindless_texture.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.bindless_texture import * +from OpenGL.raw.GL.ARB.bindless_texture import _EXTENSION_NAME + +def glInitBindlessTextureARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glUniformHandleui64vARB.value size not checked against count +glUniformHandleui64vARB=wrapper.wrapper(glUniformHandleui64vARB).setInputArraySize( + 'value', None +) +# INPUT glProgramUniformHandleui64vARB.values size not checked against count +glProgramUniformHandleui64vARB=wrapper.wrapper(glProgramUniformHandleui64vARB).setInputArraySize( + 'values', None +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/blend_func_extended.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/blend_func_extended.py new file mode 100644 index 00000000..89452adc --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/blend_func_extended.py @@ -0,0 +1,39 @@ +'''OpenGL extension ARB.blend_func_extended + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.blend_func_extended to provide a more +Python-friendly API + +Overview (from the spec) + + Traditional OpenGL includes fixed-function blending that combines source + colors with the existing content of a render buffer in a variety of ways. + A number of extensions have enhanced this functionality by adding further + sources of blending weights and methods to combine them. However, the inputs + to the fixed-function blending units are constrained to a source color (as + output from fragment shading), destination color (as the current content + of the frame buffer) or constants that may be used in their place. + + This extension adds new blending functions whereby a fragment shader may + output two colors, one of which is treated as the source color, and the + other used as a blending factor for either source or destination colors. + Furthermore, this extension increases orthogonality by allowing the + SRC_ALPHA_SATURATE function to be used as the destination weight. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/blend_func_extended.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.blend_func_extended import * +from OpenGL.raw.GL.ARB.blend_func_extended import _EXTENSION_NAME + +def glInitBlendFuncExtendedARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/buffer_storage.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/buffer_storage.py new file mode 100644 index 00000000..7868f86a --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/buffer_storage.py @@ -0,0 +1,48 @@ +'''OpenGL extension ARB.buffer_storage + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.buffer_storage to provide a more +Python-friendly API + +Overview (from the spec) + + OpenGL has long supported buffer objects as a means of storing data + that may be used to source vertex attributes, pixel data for textures, + uniforms and other elements. In un-extended GL, buffer data stores + are mutable - that is, they may be de-allocated or resized while they + are in use. The GL_ARB_texture_storage extension added immutable storage + for texture object (and was subsequently incorporated into OpenGL 4.2). + This extension further applies the concept of immutable storage to + buffer objects. If an implementation is aware of a buffer's immutability, + it may be able to make certain assumptions or apply particular + optimizations in order to increase performance or reliability. + + Furthermore, this extension allows applications to pass additional + information about a requested allocation to the implementation which it + may use to select memory heaps, caching behavior or allocation strategies. + + Finally, this extension introduces the concept of persistent client + mappings of buffer objects, which allow clients to retain pointers to a + buffer's data store returned as the result of a mapping, and to issue + drawing commands while those mappings are in place. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/buffer_storage.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.buffer_storage import * +from OpenGL.raw.GL.ARB.buffer_storage import _EXTENSION_NAME + +def glInitBufferStorageARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glBufferStorage.data size not checked against size +glBufferStorage=wrapper.wrapper(glBufferStorage).setInputArraySize( + 'data', None +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/cl_event.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/cl_event.py new file mode 100644 index 00000000..ad2add5a --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/cl_event.py @@ -0,0 +1,32 @@ +'''OpenGL extension ARB.cl_event + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.cl_event to provide a more +Python-friendly API + +Overview (from the spec) + + This extension allows creating OpenGL sync objects linked to OpenCL + event objects, potentially improving efficiency of sharing images + and buffers between the two APIs. The companion cl_khr_gl_event + OpenCL extension provides the complementary functionality of + creating an OpenCL event object from an OpenGL fence sync object. + That extension is located in the OpenCL API Registry. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/cl_event.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.cl_event import * +from OpenGL.raw.GL.ARB.cl_event import _EXTENSION_NAME + +def glInitClEventARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/clear_buffer_object.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/clear_buffer_object.py new file mode 100644 index 00000000..67a6eda9 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/clear_buffer_object.py @@ -0,0 +1,45 @@ +'''OpenGL extension ARB.clear_buffer_object + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.clear_buffer_object to provide a more +Python-friendly API + +Overview (from the spec) + + Buffer objects are fundamental to the operation of OpenGL. Buffers are used + as a source of data for vertices and indices, read through buffer textures + in shaders, used to transfer texture and image data into and out of + textures and framebuffers, and may be written to by operations such as + transform feedback. OpenGL contains mechanisms to copy sections of buffers + from one to another, but it has no mechanism to initialize the content + of a buffer to a known value. In effect, it has memcpy, but not memset. + + This extension adds such a mechanism and has several use cases. Examples + include clearing a pixel unpack buffer before transferring data to + a texture or resetting buffer data to a known value before sparse updates + through shader image stores or transform feedback. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/clear_buffer_object.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.clear_buffer_object import * +from OpenGL.raw.GL.ARB.clear_buffer_object import _EXTENSION_NAME + +def glInitClearBufferObjectARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glClearBufferData.data size not checked against 'format,type' +glClearBufferData=wrapper.wrapper(glClearBufferData).setInputArraySize( + 'data', None +) +# INPUT glClearBufferSubData.data size not checked against 'format,type' +glClearBufferSubData=wrapper.wrapper(glClearBufferSubData).setInputArraySize( + 'data', None +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/clear_texture.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/clear_texture.py new file mode 100644 index 00000000..fc6c9de9 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/clear_texture.py @@ -0,0 +1,59 @@ +'''OpenGL extension ARB.clear_texture + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.clear_texture to provide a more +Python-friendly API + +Overview (from the spec) + + Texture objects are fundamental to the operation of OpenGL. They are + used as a source for texture sampling and destination for rendering + as well as being accessed in shaders for image load/store operations + It is also possible to invalidate the contents of a texture. It is + currently only possible to set texture image data to known values by + uploading some or all of a image array from application memory or by + attaching it to a framebuffer object and using the Clear or ClearBuffer + commands. + + Both uploading initial texture data and clearing by attaching to a + framebuffer have potential disadvantages when one simply wants to + initialize texture data to a known value. Uploading initial data + requires the application to allocate a (potentially large) chunk + of memory and transferring that to the GL. This can be a costly + operation both in terms of memory bandwidth and power usage. + Alternatively, attaching a texture level to a framebuffer to clear it + may not be possible if the texture format isn't supported for + rendering, or even if it is, attaching the image to a framebuffer object + may cause the texture to be allocated in certain types of memory, which + it may otherwise not need to be placed in. + + This extension solves these problems by providing a mechanism whereby + the contents of a texture image array can be set to known values by + using the ClearTexImage or ClearTexSubImage commands. These commands + can also be useful for initializing an image that will be used for + atomic shader operations. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/clear_texture.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.clear_texture import * +from OpenGL.raw.GL.ARB.clear_texture import _EXTENSION_NAME + +def glInitClearTextureARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glClearTexImage.data size not checked against 'format,type' +glClearTexImage=wrapper.wrapper(glClearTexImage).setInputArraySize( + 'data', None +) +# INPUT glClearTexSubImage.data size not checked against 'format,type' +glClearTexSubImage=wrapper.wrapper(glClearTexSubImage).setInputArraySize( + 'data', None +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/clip_control.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/clip_control.py new file mode 100644 index 00000000..7140bd7d --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/clip_control.py @@ -0,0 +1,89 @@ +'''OpenGL extension ARB.clip_control + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.clip_control to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides additional clip control modes to configure how + clip space is mapped to window space. This extension's goal is to 1) + allow OpenGL to effectively match Direct3D's coordinate system + conventions, and 2) potentially improve the numerical precision of the Z + coordinate mapping. + + Developers interested in this functionality may be porting content + from Direct3D to OpenGL and/or interested in improving the numerical + accuracy of depth testing, particularly with floating-point depth + buffers. + + OpenGL's initial and conventional clip control state is configured by: + + glClipControl(GL_LOWER_LEFT, GL_NEGATIVE_ONE_TO_ONE); + + where geometry with (x,y) normalized device coordinates of (-1,-1) + correspond to the lower-left corner of the viewport and the near and far + planes correspond to z normalized device coordinates of -1 and +1, + respectively. + + This extension can be used to render content used in a Direct3D + application in OpenGL in a straightforward way without modifying vertex or + matrix data. When rendering into a window, the command + + glClipControl(GL_LOWER_LEFT, GL_ZERO_TO_ONE); + + configures the near clip plane to correspond to a z normalized device + coordinate of 0 as in Direct3D. Geometry with (x,y) normalized device + coordinates of (-1,-1) correspond to the lower-left corner of the viewport + in Direct3D, so no change relative to OpenGL conventions is needed there. + Other state related to screen-space coordinates may need to be modified + for the application to map from Direct3D to OpenGL window coordinate + conventions. For example, the viewport rectangle in Direct3D needs to be + inverted within the window to work properly in OpenGL windowed rendering: + + glViewport(d3d_viewport_x, + window_height - (d3d_viewport_y + d3d_viewport_height), + d3d_viewport_width, d3d_viewport_height); + + When rendering Direct3D content into a framebuffer object in OpenGL, there + is one complication -- how to get a correct image *out* of the related + textures. Direct3D applications would expect a texture coordinate of + (0,0) to correspond to the upper-left corner of a rendered image, while + OpenGL FBO conventions would map (0,0) to the lower-left corner of the + rendered image. For applications wishing to use Direct3D content with + unmodified texture coordinates, the command + + glClipControl(GL_UPPER_LEFT, GL_ZERO_TO_ONE); + + configures the OpenGL to invert geometry vertically inside the viewport. + Content at the top of the viewport for Direct3D will be rendered to the + bottom of the viewport from the point of view of OpenGL, but will have a + texture coordinate of zero in both cases. When operating in this + mode, applications need not invert the programmed viewport rectangle as + recommended for windowed rendering above. + + Applications happy with OpenGL's origin conventions but seeking + potentially improved depth precision can configure clip controls using: + + glClipControl(GL_LOWER_LEFT, GL_ZERO_TO_ONE); + + to avoid the loss of precision from the DepthRange transformation + (which by default is z_window = z_ndc * 0.5 + 0.5). + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/clip_control.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.clip_control import * +from OpenGL.raw.GL.ARB.clip_control import _EXTENSION_NAME + +def glInitClipControlARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/color_buffer_float.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/color_buffer_float.py new file mode 100644 index 00000000..c1b5ba27 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/color_buffer_float.py @@ -0,0 +1,55 @@ +'''OpenGL extension ARB.color_buffer_float + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.color_buffer_float to provide a more +Python-friendly API + +Overview (from the spec) + + The standard OpenGL pipeline is based on a fixed-point pipeline. + While color components are nominally floating-point values in the + pipeline, components are frequently clamped to the range [0,1] to + accomodate the fixed-point color buffer representation and allow + for fixed-point computational hardware. + + This extension adds pixel formats or visuals with floating-point + RGBA color components and controls for clamping of color + components within the pipeline. + + For a floating-point RGBA pixel format, the size of each float + components is specified using the same attributes that are used + for defining the size of fixed-point components. 32-bit + floating-point components are in the standard IEEE float format. + 16-bit floating-point components have 1 sign bit, 5 exponent bits, + and 10 mantissa bits. + + Clamping control provides a way to disable certain color clamps + and allow programs, and the fixed-function pipeline, to deal in + unclamped colors. There are controls to modify clamping of vertex + colors, clamping of fragment colors throughout the pipeline, and + for pixel return data. + + The default state for fragment clamping is "FIXED_ONLY", which + has the behavior of clamping colors for fixed-point color buffers + and not clamping colors for floating-pont color buffers. + + Vertex colors are clamped by default. + + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/color_buffer_float.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.color_buffer_float import * +from OpenGL.raw.GL.ARB.color_buffer_float import _EXTENSION_NAME + +def glInitColorBufferFloatARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/compatibility.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/compatibility.py new file mode 100644 index 00000000..b6295643 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/compatibility.py @@ -0,0 +1,23 @@ +'''OpenGL extension ARB.compatibility + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.compatibility to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/compatibility.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.compatibility import * +from OpenGL.raw.GL.ARB.compatibility import _EXTENSION_NAME + +def glInitCompatibilityARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/compressed_texture_pixel_storage.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/compressed_texture_pixel_storage.py new file mode 100644 index 00000000..e9fb80e2 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/compressed_texture_pixel_storage.py @@ -0,0 +1,47 @@ +'''OpenGL extension ARB.compressed_texture_pixel_storage + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.compressed_texture_pixel_storage to provide a more +Python-friendly API + +Overview (from the spec) + + This extension expands the functionality of the PixelStore modes + to allow UNPACK_ROW_LENGTH, UNPACK_SKIP_ROWS, UNPACK_SKIP_PIXELS, + UNPACK_IMAGE_HEIGHT and UNPACK_SKIP_IMAGES to affect the operation of + CompressedTexImage*D and CompressedTexSubImage*D. Similarly, it + also allows PACK_ROW_LENGTH, PACK_SKIP_ROWS, PACK_SKIP_PIXELS, + PACK_IMAGE_HEIGHT and PACK_SKIP_IMAGES to affect the operation of + GetCompressedTexImage*D. This allows data to be transferred + to or from a specified sub-rectangle of a larger compressed image. + + This extension is designed primarily to support compressed image + formats with fixed-size blocks. To use this new mechanism, an + application should program new parameters UNPACK_COMPRESSED_BLOCK_ + {WIDTH,HEIGHT,DEPTH,SIZE} to indicate the number of texels in each + dimension of the fixed-size block as well as the number of bytes + consumed by each block. These parameters, in addition to the + existing PixelStore parameters, are used to identify a collection + of bytes in client memory or a buffer object's data store to use + as compressed texture data. This operation is unlikely to have + the desired results if the client programs a block size inconsistent + with the underlying compressed image format, or if the compressed + image format has variable-sized blocks. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/compressed_texture_pixel_storage.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.compressed_texture_pixel_storage import * +from OpenGL.raw.GL.ARB.compressed_texture_pixel_storage import _EXTENSION_NAME + +def glInitCompressedTexturePixelStorageARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/compute_shader.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/compute_shader.py new file mode 100644 index 00000000..3b99ac4d --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/compute_shader.py @@ -0,0 +1,61 @@ +'''OpenGL extension ARB.compute_shader + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.compute_shader to provide a more +Python-friendly API + +Overview (from the spec) + + Recent graphics hardware has become extremely powerful and a strong desire + to harness this power for work (both graphics and non-graphics) that does + not fit the traditional graphics pipeline well has emerged. To address + this, this extension adds a new single-stage program type known as a + compute program. This program may contain one or more compute shaders + which may be launched in a manner that is essentially stateless. This allows + arbitrary workloads to be sent to the graphics hardware with minimal + disturbance to the GL state machine. + + In most respects, a compute program is identical to a traditional OpenGL + program object, with similar status, uniforms, and other such properties. + It has access to many of the same resources as fragment and other shader + types, such as textures, image variables, atomic counters, and so on. + However, it has no predefined inputs nor any fixed-function outputs. It + cannot be part of a pipeline and its visible side effects are through its + actions on images and atomic counters. + + OpenCL is another solution for using graphics processors as generalized + compute devices. This extension addresses a different need. For example, + OpenCL is designed to be usable on a wide range of devices ranging from + CPUs, GPUs, and DSPs through to FPGAs. While one could implement GL on these + types of devices, the target here is clearly GPUs. Another difference is + that OpenCL is more full featured and includes features such as multiple + devices, asynchronous queues and strict IEEE semantics for floating point + operations. This extension follows the semantics of OpenGL - implicitly + synchronous, in-order operation with single-device, single queue + logical architecture and somewhat more relaxed numerical precision + requirements. Although not as feature rich, this extension offers several + advantages for applications that can tolerate the omission of these + features. Compute shaders are written in GLSL, for example and so code may + be shared between compute and other shader types. Objects are created and + owned by the same context as the rest of the GL, and therefore no + interoperability API is required and objects may be freely used by both + compute and graphics simultaneously without acquire-release semantics or + object type translation. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/compute_shader.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.compute_shader import * +from OpenGL.raw.GL.ARB.compute_shader import _EXTENSION_NAME + +def glInitComputeShaderARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/compute_variable_group_size.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/compute_variable_group_size.py new file mode 100644 index 00000000..699c5b06 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/compute_variable_group_size.py @@ -0,0 +1,39 @@ +'''OpenGL extension ARB.compute_variable_group_size + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.compute_variable_group_size to provide a more +Python-friendly API + +Overview (from the spec) + + This extension allows applications to write generic compute shaders that + operate on workgroups with arbitrary dimensions. Instead of specifying a + fixed workgroup size in the compute shader, an application can use a + compute shader using the /local_size_variable/ layout qualifer to indicate + a variable workgroup size. When using such compute shaders, the new + command DispatchComputeGroupSizeARB should be used to specify both a + workgroup size and workgroup count. + + In this extension, compute shaders with fixed group sizes must be + dispatched by DispatchCompute and DispatchComputeIndirect. Compute + shaders with variable group sizes must be dispatched via + DispatchComputeGroupSizeARB. No support is provided in this extension for + indirect dispatch of compute shaders with a variable group size. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/compute_variable_group_size.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.compute_variable_group_size import * +from OpenGL.raw.GL.ARB.compute_variable_group_size import _EXTENSION_NAME + +def glInitComputeVariableGroupSizeARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/conditional_render_inverted.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/conditional_render_inverted.py new file mode 100644 index 00000000..c42c4214 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/conditional_render_inverted.py @@ -0,0 +1,28 @@ +'''OpenGL extension ARB.conditional_render_inverted + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.conditional_render_inverted to provide a more +Python-friendly API + +Overview (from the spec) + + This extension adds new modes to BeginConditionalRender which invert + the condition used to determine whether to draw or not. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/conditional_render_inverted.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.conditional_render_inverted import * +from OpenGL.raw.GL.ARB.conditional_render_inverted import _EXTENSION_NAME + +def glInitConditionalRenderInvertedARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/conservative_depth.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/conservative_depth.py new file mode 100644 index 00000000..7af485c5 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/conservative_depth.py @@ -0,0 +1,39 @@ +'''OpenGL extension ARB.conservative_depth + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.conservative_depth to provide a more +Python-friendly API + +Overview (from the spec) + + There is a common optimization for hardware accelerated implementation of + OpenGL which relies on an early depth test to be run before the fragment + shader so that the shader evaluation can be skipped if the fragment ends + up being discarded because it is occluded. + + This optimization does not affect the final rendering, and is typically + possible when the fragment does not change the depth programmatically. + (i.e.: it does not write to the built-in gl_FragDepth output). There are, + however a class of operations on the depth in the shader which could + still be performed while allowing the early depth test to operate. + + This extension allows the application to pass enough information to the + GL implementation to activate such optimizations safely. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/conservative_depth.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.conservative_depth import * +from OpenGL.raw.GL.ARB.conservative_depth import _EXTENSION_NAME + +def glInitConservativeDepthARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/copy_buffer.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/copy_buffer.py new file mode 100644 index 00000000..720ccfff --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/copy_buffer.py @@ -0,0 +1,30 @@ +'''OpenGL extension ARB.copy_buffer + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.copy_buffer to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides a mechanism to do an accelerated copy from one + buffer object to another. This may be useful to load buffer objects + in a "loading thread" while minimizing cost and synchronization effort + in the "rendering thread." + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/copy_buffer.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.copy_buffer import * +from OpenGL.raw.GL.ARB.copy_buffer import _EXTENSION_NAME + +def glInitCopyBufferARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/copy_image.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/copy_image.py new file mode 100644 index 00000000..4ffcaf1d --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/copy_image.py @@ -0,0 +1,44 @@ +'''OpenGL extension ARB.copy_image + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.copy_image to provide a more +Python-friendly API + +Overview (from the spec) + + This extension enables efficient image data transfer between image + objects (i.e. textures and renderbuffers) without the need to bind + the objects or otherwise configure the rendering pipeline. + + This is accomplised by adding a new entry-point CopyImageSubData, + which takes a named source and destination. + + CopyImageSubData does not perform general-purpose conversions + such as scaling, resizing, blending, color-space, or format + conversions. It should be considered to operate in a manner + similar to a CPU memcpy, but using the GPU for the copy. + + CopyImageSubData supports copies between images with different + internal formats, if the formats are compatible for TextureViews. + + CopyImageSubData also supports copying between compressed and + uncompressed images if the compressed block / uncompressed texel + sizes are the same. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/copy_image.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.copy_image import * +from OpenGL.raw.GL.ARB.copy_image import _EXTENSION_NAME + +def glInitCopyImageARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/cull_distance.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/cull_distance.py new file mode 100644 index 00000000..7e6afba8 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/cull_distance.py @@ -0,0 +1,31 @@ +'''OpenGL extension ARB.cull_distance + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.cull_distance to provide a more +Python-friendly API + +Overview (from the spec) + + This extension adds a new GLSL gl_CullDistance shader output, similar + to gl_ClipDistance, but used for whole primitive culling. + + This new stage in the pipeline is added as part of the primitive clipping + stage. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/cull_distance.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.cull_distance import * +from OpenGL.raw.GL.ARB.cull_distance import _EXTENSION_NAME + +def glInitCullDistanceARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/debug_output.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/debug_output.py new file mode 100644 index 00000000..493911a4 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/debug_output.py @@ -0,0 +1,116 @@ +'''OpenGL extension ARB.debug_output + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.debug_output to provide a more +Python-friendly API + +Overview (from the spec) + + This extension allows the GL to notify applications when various + events occur that may be useful during application development and + debugging. + + These events are represented in the form of enumerable messages with + a human-readable string representation. Examples of debug events + include incorrect use of the GL, warnings of undefined behavior, and + performance warnings. + + A message is uniquely identified by a source, a type and an + implementation-dependent ID within the source and type pair. + + A message's source identifies the origin of the message and can + either describe components of the GL, the window system, + third-party external sources such as external debuggers, or even + the application itself. + + The type of the message roughly identifies the nature of the event + that caused the message. Examples include errors, performance + warnings, or warnings about undefined behavior. + + A message's ID for a given source and type further + distinguishes messages within those groups. For example, an error + caused by a negative parameter value or an invalid internal + texture format are both errors generated by the API, but would + likely have different message IDs. + + Each message is also assigned to a severity level that denotes + roughly how "important" that message is in comparison to other + messages across all sources and types. For example, notification + of a GL error would likely have a higher severity than a performance + warning due to redundant state changes. + + Finally, every message contains an implementation-dependent string + representation that provides a useful description of the event. + + Messages are communicated to the application through an application- + defined callback function that is called by the GL implementation on + each debug message. The motivation for the callback routine is to + free application developers from actively having to query whether + a GL error, or any other debuggable event has happened after each + call to a GL function. With a callback, developers can keep their + code free of debug checks, and only have to react to messages as + they occur. In situations where using a callback is not possible, + a message log is also provided that stores copies of recent messages + until they are actively queried. + + To control the volume of debug output, messages can be disabled + either individually by ID, or entire groups of messages can be + turned off based on combination of source and type. + + The only requirement on the minimum quantity and type of messages + that implementations of this extension must support is that some + sort of message must be sent notifying the application whenever any + GL error occurs. Any further messages are left to the + implementation. Implementations do not have to output messages from + all sources nor do they have to use all types of messages listed + by this extension, and both new sources and types can be added by + other extensions. + + For performance reasons it is recommended, but not required, that + implementations restrict supporting this extension only to + contexts created using the debug flag as provided by + WGL_create_context or GLX_create_context. This extension places no + limits on any other functionality provided by debug contexts through + other extensions. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/debug_output.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.debug_output import * +from OpenGL.raw.GL.ARB.debug_output import _EXTENSION_NAME + +def glInitDebugOutputARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glDebugMessageControlARB.ids size not checked against count +glDebugMessageControlARB=wrapper.wrapper(glDebugMessageControlARB).setInputArraySize( + 'ids', None +) +# INPUT glDebugMessageInsertARB.buf size not checked against length +glDebugMessageInsertARB=wrapper.wrapper(glDebugMessageInsertARB).setInputArraySize( + 'buf', None +) +# INPUT glDebugMessageCallbackARB.userParam size not checked against 'callback' +glDebugMessageCallbackARB=wrapper.wrapper(glDebugMessageCallbackARB).setInputArraySize( + 'userParam', None +) +glGetDebugMessageLogARB=wrapper.wrapper(glGetDebugMessageLogARB).setOutput( + 'ids',size=lambda x:(x,),pnameArg='count',orPassIn=True +).setOutput( + 'lengths',size=lambda x:(x,),pnameArg='count',orPassIn=True +).setOutput( + 'messageLog',size=lambda x:(x,),pnameArg='bufSize',orPassIn=True +).setOutput( + 'severities',size=lambda x:(x,),pnameArg='count',orPassIn=True +).setOutput( + 'sources',size=lambda x:(x,),pnameArg='count',orPassIn=True +).setOutput( + 'types',size=lambda x:(x,),pnameArg='count',orPassIn=True +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/depth_buffer_float.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/depth_buffer_float.py new file mode 100644 index 00000000..76080289 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/depth_buffer_float.py @@ -0,0 +1,43 @@ +'''OpenGL extension ARB.depth_buffer_float + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.depth_buffer_float to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides new texture internal formats whose depth + components are stored as 32-bit floating-point values, rather than the + normalized unsigned integers used in existing depth formats. + Floating-point depth textures support all the functionality supported for + fixed-point depth textures, including shadow mapping and rendering support + via EXT_framebuffer_object. Floating-point depth textures can store + values outside the range [0,1]. + + Additionally, this extension provides new packed depth/stencil pixel + formats (see EXT_packed_depth_stencil) that have 64-bit pixels consisting + of a 32-bit floating-point depth value, 8 bits of stencil, and 24 unused + bites. A packed depth/stencil texture internal format is also provided. + + This extension does not provide support for WGL or GLX pixel formats with + floating-point depth buffers. The existing (but not commonly used) + WGL_EXT_depth_float extension could be used for this purpose. + + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/depth_buffer_float.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.depth_buffer_float import * +from OpenGL.raw.GL.ARB.depth_buffer_float import _EXTENSION_NAME + +def glInitDepthBufferFloatARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/depth_clamp.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/depth_clamp.py new file mode 100644 index 00000000..2fbc9787 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/depth_clamp.py @@ -0,0 +1,54 @@ +'''OpenGL extension ARB.depth_clamp + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.depth_clamp to provide a more +Python-friendly API + +Overview (from the spec) + + Conventional OpenGL clips geometric primitives to a clip volume + with six faces, two of which are the near and far clip planes. + Clipping to the near and far planes of the clip volume ensures that + interpolated depth values (after the depth range transform) must be + in the [0,1] range. + + In some rendering applications such as shadow volumes, it is useful + to allow line and polygon primitives to be rasterized without + clipping the primitive to the near or far clip volume planes (side + clip volume planes clip normally). Without the near and far clip + planes, rasterization (pixel coverage determination) in X and Y + can proceed normally if we ignore the near and far clip planes. + The one major issue is that fragments of a primitive may extend + beyond the conventional window space depth range for depth values + (typically the range [0,1]). Rather than discarding fragments that + defy the window space depth range (effectively what near and far + plane clipping accomplish), the depth values can be clamped to the + current depth range. + + This extension provides exactly such functionality. This + functionality is useful to obviate the need for near plane capping + of stenciled shadow volumes. The functionality may also be useful + for rendering geometry "beyond" the far plane if an alternative + algorithm (rather than depth testing) for hidden surface removal is + applied to such geometry (specifically, the painter's algorithm). + Similar situations at the near clip plane can be avoided at the + near clip plane where apparently solid objects can be "seen through" + if they intersect the near clip plane. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/depth_clamp.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.depth_clamp import * +from OpenGL.raw.GL.ARB.depth_clamp import _EXTENSION_NAME + +def glInitDepthClampARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/depth_texture.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/depth_texture.py new file mode 100644 index 00000000..151c652b --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/depth_texture.py @@ -0,0 +1,37 @@ +'''OpenGL extension ARB.depth_texture + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.depth_texture to provide a more +Python-friendly API + +Overview (from the spec) + + This is a clarification of the GL_SGIX_depth_texture extension. The + original overview follows: + + This extension defines a new depth texture format. An important + application of depth texture images is shadow casting, but separating + this from the shadow extension allows for the potential use of depth + textures in other applications such as image-based rendering or + displacement mapping. This extension does not define new depth-texture + environment functions, such as filtering or applying the depth values + computed from a texture but leaves this to other extensions, such as + the shadow extension. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/depth_texture.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.depth_texture import * +from OpenGL.raw.GL.ARB.depth_texture import _EXTENSION_NAME + +def glInitDepthTextureARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/derivative_control.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/derivative_control.py new file mode 100644 index 00000000..75841c49 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/derivative_control.py @@ -0,0 +1,57 @@ +'''OpenGL extension ARB.derivative_control + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.derivative_control to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides control over the spacial granularity at which the + underlying implementation computes derivatives. + + For example, for the coarse-granularity derivative, a single x derivative + could be computed for each 2x2 group of pixels, using that same derivative + value for all 4 pixels. For the fine-granularity derivative, two + derivatives could be computed for each 2x2 group of pixels; one for the top + row and one for the bottom row. Implementations vary somewhat on how this + is done. + + To select the coarse derivative, use: + + dFdxCoarse(p) + dFdyCoarse(p) + fwidthCoarse(p) + + To select the fine derivative, use: + + dFdxFine(p) + dFdyFine(p) + fwidthFine(p) + + To select which ever is "better" (based on performance, API hints, or other + factors), use: + + dFdx(p) + dFdy(p) + fwidth(p) + + This last set is the set of previously existing built-ins for derivatives, + and continues to work in a backward compatible way. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/derivative_control.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.derivative_control import * +from OpenGL.raw.GL.ARB.derivative_control import _EXTENSION_NAME + +def glInitDerivativeControlARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/direct_state_access.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/direct_state_access.py new file mode 100644 index 00000000..cc14492c --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/direct_state_access.py @@ -0,0 +1,101 @@ +'''OpenGL extension ARB.direct_state_access + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.direct_state_access to provide a more +Python-friendly API + +Overview (from the spec) + + In unextended OpenGL, most mutation of state contained in objects is through + an indirection known as a binding. Objects are attached to a context (either + directly or indirectly via a container) and then commands to modify or + query their state are issued on that context, indirecting through its + attachments and into the underlying object. This is known as `bind-to-edit'. + + This extension derives from the GL_EXT_direct_state_access extension, which + added accessors for most state on most objects, allowing it to be queried + and modified without the object needing to be bound to a context. In cases + where a single property of an object is to be modified, directly accessing + its state can be more efficient than binding the object to the context and + then indirecting through it. Further, directly accessing the state of + objects through their names rather than by bind-to-edit does not disturb + the bindings of the current context, which is useful for tools, middleware + and other applications that are unaware of the outer state but it can also + avoid cases of redundant state changes. + + There are several subtle differences between this extension and the older + GL_EXT_direct_state_access extension. First, this extension only expands + functionality that still exists in core profile OpenGL. Second, any function + that only partially avoids bind-to-edit (for example, explicitly specifying + a texture unit, bypassing the active texture selector but still indirecting + through a texture binding) has been omitted. Finally, the original extension + effectively allowed any function to create new objects whereas in unextended + OpenGL, only binding functions created objects (bind-to-create), even if + their names were obtained through one of the glGen* functions. This + extension does not allow on-the-spot creation of objects. Rather than rely + on bind-to-create (which would defeat the purpose of the extension), we add + glCreate* functions that produce new names that represent state vectors + initialized to their default values. Due to this last change, several + functions no longer require their parameters, and so where + applicable, this parameter is absent from this extension. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/direct_state_access.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.direct_state_access import * +from OpenGL.raw.GL.ARB.direct_state_access import _EXTENSION_NAME + +def glInitDirectStateAccessARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glCreateTransformFeedbacks.ids size not checked against n +glCreateTransformFeedbacks=wrapper.wrapper(glCreateTransformFeedbacks).setInputArraySize( + 'ids', None +) +# INPUT glCreateBuffers.buffers size not checked against n +glCreateBuffers=wrapper.wrapper(glCreateBuffers).setInputArraySize( + 'buffers', None +) +# INPUT glNamedBufferStorage.data size not checked against size +glNamedBufferStorage=wrapper.wrapper(glNamedBufferStorage).setInputArraySize( + 'data', None +) +# INPUT glNamedBufferSubData.data size not checked against 'size' +glNamedBufferSubData=wrapper.wrapper(glNamedBufferSubData).setInputArraySize( + 'data', None +) +# INPUT glCreateFramebuffers.framebuffers size not checked against n +glCreateFramebuffers=wrapper.wrapper(glCreateFramebuffers).setInputArraySize( + 'framebuffers', None +) +# INPUT glCreateRenderbuffers.renderbuffers size not checked against n +glCreateRenderbuffers=wrapper.wrapper(glCreateRenderbuffers).setInputArraySize( + 'renderbuffers', None +) +# INPUT glCreateTextures.textures size not checked against n +glCreateTextures=wrapper.wrapper(glCreateTextures).setInputArraySize( + 'textures', None +) +# INPUT glCreateVertexArrays.arrays size not checked against n +glCreateVertexArrays=wrapper.wrapper(glCreateVertexArrays).setInputArraySize( + 'arrays', None +) +# INPUT glCreateSamplers.samplers size not checked against n +glCreateSamplers=wrapper.wrapper(glCreateSamplers).setInputArraySize( + 'samplers', None +) +# INPUT glCreateProgramPipelines.pipelines size not checked against n +glCreateProgramPipelines=wrapper.wrapper(glCreateProgramPipelines).setInputArraySize( + 'pipelines', None +) +# INPUT glCreateQueries.ids size not checked against n +glCreateQueries=wrapper.wrapper(glCreateQueries).setInputArraySize( + 'ids', None +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/draw_buffers.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/draw_buffers.py new file mode 100644 index 00000000..5f76cb9b --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/draw_buffers.py @@ -0,0 +1,48 @@ +'''OpenGL extension ARB.draw_buffers + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.draw_buffers to provide a more +Python-friendly API + +Overview (from the spec) + + This extension extends ARB_fragment_program and ARB_fragment_shader + to allow multiple output colors, and provides a mechanism for + directing those outputs to multiple color buffers. + + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/draw_buffers.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.draw_buffers import * +from OpenGL.raw.GL.ARB.draw_buffers import _EXTENSION_NAME + +def glInitDrawBuffersARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glDrawBuffersARB.bufs size not checked against n +glDrawBuffersARB=wrapper.wrapper(glDrawBuffersARB).setInputArraySize( + 'bufs', None +) +### END AUTOGENERATED SECTION +from OpenGL.lazywrapper import lazy as _lazy +@_lazy( glDrawBuffersARB ) +def glDrawBuffersARB( baseOperation, n=None, bufs=None ): + """glDrawBuffersARB( bufs ) -> bufs + + Wrapper will calculate n from dims of bufs if only + one argument is provided... + """ + if bufs is None: + bufs = n + n = None + bufs = arrays.GLenumArray.asArray( bufs ) + if n is None: + n = arrays.GLenumArray.arraySize( bufs ) + return baseOperation( n,bufs ) diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/draw_buffers_blend.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/draw_buffers_blend.py new file mode 100644 index 00000000..aac268ca --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/draw_buffers_blend.py @@ -0,0 +1,35 @@ +'''OpenGL extension ARB.draw_buffers_blend + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.draw_buffers_blend to provide a more +Python-friendly API + +Overview (from the spec) + + This extension builds upon the ARB_draw_buffers and + EXT_draw_buffers2 extensions. In ARB_draw_buffers (part of OpenGL + 2.0), separate values could be written to each color buffer. This + was further enhanced by EXT_draw_buffers2 by adding in the ability + to enable blending and to set color write masks independently per + color output. + + This extension provides the ability to set individual blend + equations and blend functions for each color output. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/draw_buffers_blend.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.draw_buffers_blend import * +from OpenGL.raw.GL.ARB.draw_buffers_blend import _EXTENSION_NAME + +def glInitDrawBuffersBlendARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/draw_elements_base_vertex.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/draw_elements_base_vertex.py new file mode 100644 index 00000000..324623ed --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/draw_elements_base_vertex.py @@ -0,0 +1,101 @@ +'''OpenGL extension ARB.draw_elements_base_vertex + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.draw_elements_base_vertex to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides a method to specify a "base vertex offset" + value which is effectively added to every vertex index that is + transferred through DrawElements. + + This mechanism can be used to decouple a set of indices from the + actual vertex array that it is referencing. This is useful if an + application stores multiple indexed models in a single vertex array. + The same index array can be used to draw the model no matter where + it ends up in a larger vertex array simply by changing the base + vertex value. Without this functionality, it would be necessary to + rebind all the vertex attributes every time geometry is switched and + this can have larger performance penalty. + + For example consider the (very contrived and simple) example of + drawing two triangles to form a quad. In the typical example you + have the following setup: + + vertices indices + ---------- ----- + 0 | (-1, 1) | 0 | 0 | + 1 | (-1, -1) | 1 | 1 | + 2 | ( 1, -1) | 2 | 2 | + 3 | ( 1, 1) | 3 | 3 | + ---------- 4 | 0 | + 5 | 2 | + ----- + which is normally rendered with the call + + DrawElements(TRIANGLES, 6, UNSIGNED_BYTE, &indices). + + Now consider the case where the vertices you want to draw are not at + the start of a vertex array but are instead located at offset 100 + into a larger array: + + vertices2 indices2 + ---------- ----- + .... 0 | 100 | + 100 | (-1, 1) | 1 | 101 | + 101 | (-1, -1) | 2 | 102 | + 102 | ( 1, -1) | 3 | 103 | + 103 | ( 1, 1) | 4 | 100 | + .... 5 | 102 | + ---------- ----- + + The typical choices for rendering this are to rebind your vertex + attributes with an additional offset of 100*stride, or to create an + new array of indices (as indices2 in the example). However both + rebinding vertex attributes and rebuilding index arrays can be quite + costly activities. + + With the new drawing commands introduced by this extension you can + instead draw using vertices2 and the new draw call: + + DrawElementsBaseVertex(TRIANGLES, 6, UNSIGNED_BYTE, &indices, 100) + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/draw_elements_base_vertex.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.draw_elements_base_vertex import * +from OpenGL.raw.GL.ARB.draw_elements_base_vertex import _EXTENSION_NAME + +def glInitDrawElementsBaseVertexARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glDrawElementsBaseVertex.indices size not checked against 'count,type' +glDrawElementsBaseVertex=wrapper.wrapper(glDrawElementsBaseVertex).setInputArraySize( + 'indices', None +) +# INPUT glDrawRangeElementsBaseVertex.indices size not checked against 'count,type' +glDrawRangeElementsBaseVertex=wrapper.wrapper(glDrawRangeElementsBaseVertex).setInputArraySize( + 'indices', None +) +# INPUT glDrawElementsInstancedBaseVertex.indices size not checked against 'count,type' +glDrawElementsInstancedBaseVertex=wrapper.wrapper(glDrawElementsInstancedBaseVertex).setInputArraySize( + 'indices', None +) +# INPUT glMultiDrawElementsBaseVertex.basevertex size not checked against 'drawcount' +# INPUT glMultiDrawElementsBaseVertex.count size not checked against 'drawcount' +# INPUT glMultiDrawElementsBaseVertex.indices size not checked against 'drawcount' +glMultiDrawElementsBaseVertex=wrapper.wrapper(glMultiDrawElementsBaseVertex).setInputArraySize( + 'basevertex', None +).setInputArraySize( + 'count', None +).setInputArraySize( + 'indices', None +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/draw_indirect.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/draw_indirect.py new file mode 100644 index 00000000..847b5bd0 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/draw_indirect.py @@ -0,0 +1,37 @@ +'''OpenGL extension ARB.draw_indirect + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.draw_indirect to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides a mechanism for supplying the arguments to a + DrawArraysInstanced or DrawElementsInstancedBaseVertex from buffer object + memory. This is not particularly useful for applications where the CPU + knows the values of the arguments beforehand, but is helpful when the + values will be generated on the GPU through any mechanism that can write + to a buffer object including image stores, atomic counters, or compute + interop. This allows the GPU to consume these arguments without a round- + trip to the CPU or the expensive synchronization that would involve. This + is similar to the DrawTransformFeedbackEXT command from + EXT_transform_feedback2, but offers much more flexibility in both + generating the arguments and in the type of Draws that can be accomplished. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/draw_indirect.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.draw_indirect import * +from OpenGL.raw.GL.ARB.draw_indirect import _EXTENSION_NAME + +def glInitDrawIndirectARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/draw_instanced.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/draw_instanced.py new file mode 100644 index 00000000..e532980d --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/draw_instanced.py @@ -0,0 +1,47 @@ +'''OpenGL extension ARB.draw_instanced + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.draw_instanced to provide a more +Python-friendly API + +Overview (from the spec) + + A common use case in GL for some applications is to be able to + draw the same object, or groups of similar objects that share + vertex data, primitive count and type, multiple times. This + extension provides a means of accelerating such use cases while + restricting the number of API calls, and keeping the amount of + duplicate data to a minimum. + + This extension introduces two draw calls which are conceptually + equivalent to a series of draw calls. Each conceptual call in + this series is considered an "instance" of the actual draw call. + + This extension also introduces a read-only built-in variable to + GLSL which contains the "instance ID." This variable initially + contains 0, but increases by one after each conceptual draw call. + + By using the instance ID or multiples thereof as an index into + a uniform array containing transform data, vertex shaders can + draw multiple instances of an object with a single draw call. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/draw_instanced.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.draw_instanced import * +from OpenGL.raw.GL.ARB.draw_instanced import _EXTENSION_NAME + +def glInitDrawInstancedARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glDrawElementsInstancedARB.indices size not checked against 'count,type' +glDrawElementsInstancedARB=wrapper.wrapper(glDrawElementsInstancedARB).setInputArraySize( + 'indices', None +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/enhanced_layouts.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/enhanced_layouts.py new file mode 100644 index 00000000..ca1be1c8 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/enhanced_layouts.py @@ -0,0 +1,123 @@ +'''OpenGL extension ARB.enhanced_layouts + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.enhanced_layouts to provide a more +Python-friendly API + +Overview (from the spec) + + This extension adds the following functionality to layout qualifiers, + including broadening the API where this functionality is reflected. + + The following are added: + + 1) Use compile-time constant expressions. E.g., + + const int start = 6; + layout(location = start + 2) int vec4 v; + + 2) Specify explicit byte offsets within a uniform or shader storage block. + For example, if you want two vec4 variables "batman" and "robin" to + appear at byte offsets 0 and 64 in your block, you can say: + + uniform Block { + layout(offset = 0) vec4 batman; + layout(offset = 64) vec4 robin; + }; + + 3) Force alignment within a uniform or shader storage block. The previous + example could also be expressed: + + uniform Block { + vec4 batman; + layout(align = 64) vec4 robin; + }; + + This says the member 'robin' must start at the next address that is a + multiple of 64. It allows constructing the same layout in C and in GLSL + without inventing explicit offsets. + + Explicit offsets and aligned offsets can be combined: + + uniform Block { + vec4 batman; + layout(offset = 44, align = 8) vec4 robin; + }; + + would make 'robin' be at the first 8-byte aligned address, starting at + 44, which is 48. This is more useful when using the *align* at + the block level, which will apply to all members. + + 4) Specify component numbers to more fully utilize the vec4-slot interfaces + between shader outputs and shader inputs. + + For example, you could fit the following + + - an array of 32 vec3 + - a single float + + into the space of 32 vec4 slots using the following code: + + // consume X/Y/Z components of 32 vectors + layout(location = 0) in vec3 batman[32]; + + // consumes W component of first vector + layout(location = 0, component = 3) in float robin; + + Further, an array of vec3 and an array of float can be stored + interleaved, using the following. + + // consumes W component of 32 vectors + layout(location = 0, component = 3) in float robin[32]; + + // consume X/Y/Z components of 32 vectors + layout(location = 0) in vec3 batman[32]; + + 5) Specify transform/feedback buffers, locations, and widths. For example: + + layout(xfb_buffer = 0, xfb_offset = 0) out vec3 var1; + layout(xfb_buffer = 0, xfb_offset = 24) out vec3 var2; + layout(xfb_buffer = 1, xfb_offset = 0) out vec4 var3; + + The second line above says to write var2 out to byte offset 24 of + transform/feedback buffer 0. (When doing this, output are only + captured when xfb_offset is used.) + + To specify the total number of bytes per entry in a buffer: + + layout(xfb_buffer = 1, xfb_stride = 32) out; + + This is necessary if, say, var3 above, which uses bytes 0-11, + does not fully fill the buffer, which in this case takes 32 bytes. + + Use of this feature effectively eliminates the need to use previously + existing API commands to describe the transform feedback layout. + + 6) Allow locations on input and output blocks for SSO interface matching. + + For example: + + layout(location = 4) in block { + vec4 batman; // gets location 4 + vec4 robin; // gets location 5 + layout(location = 7) vec4 joker; // gets location 7 + vec4 riddler; // location 8 + }; + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/enhanced_layouts.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.enhanced_layouts import * +from OpenGL.raw.GL.ARB.enhanced_layouts import _EXTENSION_NAME + +def glInitEnhancedLayoutsARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/explicit_attrib_location.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/explicit_attrib_location.py new file mode 100644 index 00000000..dc449c4c --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/explicit_attrib_location.py @@ -0,0 +1,32 @@ +'''OpenGL extension ARB.explicit_attrib_location + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.explicit_attrib_location to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides a method to pre-assign attribute locations to + named vertex shader inputs and color numbers to named fragment shader + outputs. This allows applications to globally assign a particular + semantic meaning, such as diffuse color or vertex normal, to a particular + attribute location without knowing how that attribute will be named in any + particular shader. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/explicit_attrib_location.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.explicit_attrib_location import * +from OpenGL.raw.GL.ARB.explicit_attrib_location import _EXTENSION_NAME + +def glInitExplicitAttribLocationARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/explicit_uniform_location.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/explicit_uniform_location.py new file mode 100644 index 00000000..ed79e4a6 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/explicit_uniform_location.py @@ -0,0 +1,31 @@ +'''OpenGL extension ARB.explicit_uniform_location + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.explicit_uniform_location to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides a method to pre-assign uniform locations to + uniform variables in the default uniform block, including subroutine + uniforms. This allows an application to modify the uniform values without + requiring a GL query like GetUniformLocation, GetSubroutineUniformLocation + and GetSubroutineIndex. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/explicit_uniform_location.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.explicit_uniform_location import * +from OpenGL.raw.GL.ARB.explicit_uniform_location import _EXTENSION_NAME + +def glInitExplicitUniformLocationARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/fragment_coord_conventions.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/fragment_coord_conventions.py new file mode 100644 index 00000000..fb1b9d4e --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/fragment_coord_conventions.py @@ -0,0 +1,84 @@ +'''OpenGL extension ARB.fragment_coord_conventions + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.fragment_coord_conventions to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides alternative conventions for the fragment + coordinate XY location available for programmable fragment processing. + + The scope of this extension deals *only* with how the fragment + coordinate XY location appears during programming fragment processing. + Beyond the scope of this extension are coordinate conventions used + for rasterization or transformation. + + In the case of the coordinate conventions for rasterization and + transformation, some combination of the viewport, depth range, culling + state, and projection matrix state can be reconfigured to adopt other + arbitrary clip-space and window-space coordinate space conventions. + Adopting other clip-space and window-space conventions involves + adjusting existing OpenGL state. However it is non-trivial to massage + an arbitrary fragment shader or program to adopt a different + window-space coordinate system because such shaders are encoded in + various textual representations. + + The dominant 2D and 3D rendering APIs make two basic choices of + convention when locating fragments in window space. + + The two choices are: + + 1) Is the origin nearest the lower-left- or upper-left-most pixel + of the window? + + 2) Is the (x,y) location of the pixel nearest the origin at (0,0) + or (0.5,0.5)? + + OpenGL assumes a lower-left origin for window coordinates and assumes + pixel centers are located at half-pixel coordinates. This means + the XY location (0.5,0.5) corresponds to the lower-left-most pixel + in a window. + + Other window coordinate conventions exist for other rendering APIs. + X11, GDI, and Direct3D version through DirectX 9 assume an upper-left + window origin and locate pixel centers at integer XY values. + By this alternative convention, the XY location (0,0) corresponds + to the upper-left-most pixel in a window. + + Direct3D for DirectX 10 assumes an upper-left origin (as do prior + DirectX versions) yet assumes half-pixel coordinates (unlike prior + DirectX versions). By the DirectX 10 convention, the XY location + (0.5,0.5) corresponds to the upper-left-most pixel in a window. + + Fragment shaders can directly access the location of a given + processed fragment in window space. We call this location the + "fragment coordinate". + + This extension provides a means for fragment shaders written in GLSL + or OpenGL assembly extensions to specify alternative conventions + for determining the fragment coordinate value accessed during + programmable fragment processing. + + The motivation for this extension is to provide an easy, efficient + means for fragment shaders accessing a fragment's window-space + location to adopt the fragment coordinate convention for which the + shader was originally written. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/fragment_coord_conventions.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.fragment_coord_conventions import * +from OpenGL.raw.GL.ARB.fragment_coord_conventions import _EXTENSION_NAME + +def glInitFragmentCoordConventionsARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/fragment_layer_viewport.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/fragment_layer_viewport.py new file mode 100644 index 00000000..01577ee2 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/fragment_layer_viewport.py @@ -0,0 +1,36 @@ +'''OpenGL extension ARB.fragment_layer_viewport + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.fragment_layer_viewport to provide a more +Python-friendly API + +Overview (from the spec) + + The geometry shader has the special built-in variables gl_Layer and + gl_ViewportIndex that specify which layer and viewport primitives + are rendered to. Currently the fragment shader does not know which + layer or viewport the fragments are being written to without the + application implementing their own interface variables between + the geometry and fragment shaders. + + This extension specifies that the gl_Layer and gl_ViewportIndex + built-in variables are also available to the fragment shader so the + application doesn't need to implement these manually. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/fragment_layer_viewport.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.fragment_layer_viewport import * +from OpenGL.raw.GL.ARB.fragment_layer_viewport import _EXTENSION_NAME + +def glInitFragmentLayerViewportARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/fragment_program.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/fragment_program.py new file mode 100644 index 00000000..282bb293 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/fragment_program.py @@ -0,0 +1,112 @@ +'''OpenGL extension ARB.fragment_program + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.fragment_program to provide a more +Python-friendly API + +Overview (from the spec) + + Unextended OpenGL mandates a certain set of configurable per- + fragment computations defining texture application, texture + environment, color sum, and fog operations. Several extensions have + added further per-fragment computations to OpenGL. For example, + extensions have defined new texture environment capabilities + (ARB_texture_env_add, ARB_texture_env_combine, ARB_texture_env_dot3, + ARB_texture_env_crossbar), per-fragment depth comparisons + (ARB_depth_texture, ARB_shadow, ARB_shadow_ambient, + EXT_shadow_funcs), per-fragment lighting (EXT_fragment_lighting, + EXT_light_texture), and environment mapped bump mapping + (ATI_envmap_bumpmap). + + Each such extension adds a small set of relatively inflexible per- + fragment computations. + + This inflexibility is in contrast to the typical flexibility + provided by the underlying programmable floating point engines + (whether micro-coded fragment engines, DSPs, or CPUs) that are + traditionally used to implement OpenGL's texturing computations. + The purpose of this extension is to expose to the OpenGL application + writer a significant degree of per-fragment programmability for + computing fragment parameters. + + For the purposes of discussing this extension, a fragment program is + a sequence of floating-point 4-component vector operations that + determines how a set of program parameters (not specific to an + individual fragment) and an input set of per-fragment parameters are + transformed to a set of per-fragment result parameters. + + The per-fragment computations for standard OpenGL given a particular + set of texture and fog application modes (along with any state for + extensions defining per-fragment computations) is, in essence, a + fragment program. However, the sequence of operations is defined + implicitly by the current OpenGL state settings rather than defined + explicitly as a sequence of instructions. + + This extension provides an explicit mechanism for defining fragment + program instruction sequences for application-defined fragment + programs. In order to define such fragment programs, this extension + defines a fragment programming model including a floating-point + 4-component vector instruction set and a relatively large set of + floating-point 4-component registers. + + The extension's fragment programming model is designed for efficient + hardware implementation and to support a wide variety of fragment + programs. By design, the entire set of existing fragment programs + defined by existing OpenGL per-fragment computation extensions can + be implemented using the extension's fragment programming model. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/fragment_program.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.fragment_program import * +from OpenGL.raw.GL.ARB.fragment_program import _EXTENSION_NAME + +def glInitFragmentProgramARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glProgramStringARB.string size not checked against len +glProgramStringARB=wrapper.wrapper(glProgramStringARB).setInputArraySize( + 'string', None +) +# INPUT glDeleteProgramsARB.programs size not checked against n +glDeleteProgramsARB=wrapper.wrapper(glDeleteProgramsARB).setInputArraySize( + 'programs', None +) +glGenProgramsARB=wrapper.wrapper(glGenProgramsARB).setOutput( + 'programs',size=lambda x:(x,),pnameArg='n',orPassIn=True +) +glProgramEnvParameter4dvARB=wrapper.wrapper(glProgramEnvParameter4dvARB).setInputArraySize( + 'params', 4 +) +glProgramEnvParameter4fvARB=wrapper.wrapper(glProgramEnvParameter4fvARB).setInputArraySize( + 'params', 4 +) +glProgramLocalParameter4dvARB=wrapper.wrapper(glProgramLocalParameter4dvARB).setInputArraySize( + 'params', 4 +) +glProgramLocalParameter4fvARB=wrapper.wrapper(glProgramLocalParameter4fvARB).setInputArraySize( + 'params', 4 +) +glGetProgramEnvParameterdvARB=wrapper.wrapper(glGetProgramEnvParameterdvARB).setOutput( + 'params',size=(4,),orPassIn=True +) +glGetProgramEnvParameterfvARB=wrapper.wrapper(glGetProgramEnvParameterfvARB).setOutput( + 'params',size=(4,),orPassIn=True +) +glGetProgramLocalParameterdvARB=wrapper.wrapper(glGetProgramLocalParameterdvARB).setOutput( + 'params',size=(4,),orPassIn=True +) +glGetProgramLocalParameterfvARB=wrapper.wrapper(glGetProgramLocalParameterfvARB).setOutput( + 'params',size=(4,),orPassIn=True +) +glGetProgramivARB=wrapper.wrapper(glGetProgramivARB).setOutput( + 'params',size=(1,),orPassIn=True +) +# OUTPUT glGetProgramStringARB.string COMPSIZE(target, pname) +### END AUTOGENERATED SECTION diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/fragment_program_shadow.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/fragment_program_shadow.py new file mode 100644 index 00000000..96c6b21e --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/fragment_program_shadow.py @@ -0,0 +1,49 @@ +'''OpenGL extension ARB.fragment_program_shadow + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.fragment_program_shadow to provide a more +Python-friendly API + +Overview (from the spec) + + This extension extends ARB_fragment_program to remove + the interaction with ARB_shadow. + + This extension defines the program option + "ARB_fragment_program_shadow". + + If a fragment program specifies the option "ARB_fragment_program_shadow" + + SHADOW1D, SHADOW2D, SHADOWRECT + + are added as texture targets. When shadow map comparisons are + desired, specify the SHADOW1D, SHADOW2D, or SHADOWRECT texture + targets in texture instructions. + + Programs must assure that the comparison mode for each depth + texture (TEXTURE_COMPARE_MODE) and/or the internal texture + format (DEPTH_COMPONENT) and the targets of the texture lookup + instructions match. Otherwise, if the comparison mode + and/or the internal texture format are inconsistent with the + texture target, the results of the texture lookup are undefined. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/fragment_program_shadow.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.fragment_program_shadow import * +from OpenGL.raw.GL.ARB.fragment_program_shadow import _EXTENSION_NAME + +def glInitFragmentProgramShadowARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION + +# This extension is entirely within the fragment program functionality, +# it doesn't affect the function-level operations AFAICS. \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/fragment_shader.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/fragment_shader.py new file mode 100644 index 00000000..1bbc396f --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/fragment_shader.py @@ -0,0 +1,37 @@ +'''OpenGL extension ARB.fragment_shader + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.fragment_shader to provide a more +Python-friendly API + +Overview (from the spec) + + This extension adds functionality to define fragment shader objects. A + fragment shader object is a shader object (see the ARB_shader_objects + extension) that, when attached to a program object, can be compiled and + linked to produce an executable that runs on the fragment processor in + OpenGL. The fragment processor is a programmable unit that replaces the + OpenGL 1.4 fixed-function texturing, color sum and fog stages. This + extension also defines how such an executable interacts with the fixed + functionality fragment processing of OpenGL 1.4. The language used to + write fragment shaders is not discussed here. That language is defined + in the OpenGL Shading Language specification as the Fragment Shading + Language. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/fragment_shader.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.fragment_shader import * +from OpenGL.raw.GL.ARB.fragment_shader import _EXTENSION_NAME + +def glInitFragmentShaderARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/fragment_shader_interlock.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/fragment_shader_interlock.py new file mode 100644 index 00000000..532206f6 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/fragment_shader_interlock.py @@ -0,0 +1,79 @@ +'''OpenGL extension ARB.fragment_shader_interlock + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.fragment_shader_interlock to provide a more +Python-friendly API + +Overview (from the spec) + + In unextended OpenGL 4.5, applications may produce a + large number of fragment shader invocations that perform loads and + stores to memory using image uniforms, atomic counter uniforms, + buffer variables, or pointers. The order in which loads and stores + to common addresses are performed by different fragment shader + invocations is largely undefined. For algorithms that use shader + writes and touch the same pixels more than once, one or more of the + following techniques may be required to ensure proper execution ordering: + + * inserting Finish or WaitSync commands to drain the pipeline between + different "passes" or "layers"; + + * using only atomic memory operations to write to shader memory (which + may be relatively slow and limits how memory may be updated); or + + * injecting spin loops into shaders to prevent multiple shader + invocations from touching the same memory concurrently. + + This extension provides new GLSL built-in functions + beginInvocationInterlockARB() and endInvocationInterlockARB() that delimit + a critical section of fragment shader code. For pairs of shader + invocations with "overlapping" coverage in a given pixel, the OpenGL + implementation will guarantee that the critical section of the fragment + shader will be executed for only one fragment at a time. + + There are four different interlock modes supported by this extension, + which are identified by layout qualifiers. The qualifiers + "pixel_interlock_ordered" and "pixel_interlock_unordered" provides mutual + exclusion in the critical section for any pair of fragments corresponding + to the same pixel. When using multisampling, the qualifiers + "sample_interlock_ordered" and "sample_interlock_unordered" only provide + mutual exclusion for pairs of fragments that both cover at least one + common sample in the same pixel; these are recommended for performance if + shaders use per-sample data structures. + + Additionally, when the "pixel_interlock_ordered" or + "sample_interlock_ordered" layout qualifier is used, the interlock also + guarantees that the critical section for multiple shader invocations with + "overlapping" coverage will be executed in the order in which the + primitives were processed by the GL. Such a guarantee is useful for + applications like blending in the fragment shader, where an application + requires that fragment values to be composited in the framebuffer in + primitive order. + + This extension can be useful for algorithms that need to access per-pixel + data structures via shader loads and stores. Such algorithms using this + extension can access such data structures in the critical section without + worrying about other invocations for the same pixel accessing the data + structures concurrently. Additionally, the ordering guarantees are useful + for cases where the API ordering of fragments is meaningful. For example, + applications may be able to execute programmable blending operations in + the fragment shader, where the destination buffer is read via image loads + and the final value is written via image stores. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/fragment_shader_interlock.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.fragment_shader_interlock import * +from OpenGL.raw.GL.ARB.fragment_shader_interlock import _EXTENSION_NAME + +def glInitFragmentShaderInterlockARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/framebuffer_no_attachments.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/framebuffer_no_attachments.py new file mode 100644 index 00000000..81201a58 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/framebuffer_no_attachments.py @@ -0,0 +1,72 @@ +'''OpenGL extension ARB.framebuffer_no_attachments + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.framebuffer_no_attachments to provide a more +Python-friendly API + +Overview (from the spec) + + Framebuffer objects as introduced by ARB_framebuffer_object and OpenGL 3.0 + provide a generalized mechanism for rendering to off-screen surfaces. + Each framebuffer object may have depth, stencil and zero or more color + attachments that can be written to by the GL. The size of the framebuffer + (width, height, layer count, sample count) is derived from the attachments + of that framebuffer. In unextended OpenGL 4.2, it is not legal to render + into a framebuffer object that has no attachments. Such a framebuffer + would be considered incomplete with the + FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT status. + + With OpenGL 4.2 and ARB_shader_image_load_store, fragment shaders are + capable of doing random access writes to buffer and texture memory via + image loads, stores, and atomics. This ability enables algorithms using + the conventional rasterizer to generate a collection of fragments, where + each fragment shader invocation will write its outputs to buffer or + texture memory using image stores or atomics. Such algorithms may have no + need to write color or depth values to a conventional framebuffer. + However, a framebuffer with no attachments will be considered incomplete + and no rasterization or fragment shader exectuion will occur. To avoid + such errors, an application may be required to create an otherwise + unnecessary "dummy" texture and attach it to the framebuffer (possibly + with color writes masked off). If the algorithm requires the rasterizer + to operate over a large number of pixels, this dummy texture will + needlessly consume a significant amount of memory. + + This extension enables the algorithms described above to work even with a + framebuffer with no attachments. Applications can specify default width, + height, layer count, and sample count parameters for a framebuffer object. + When a framebuffer with no attachments is bound, it will be considered + complete as long as the application has specified non-zero default width + and height parameters. For the purposes of rasterization, the framebuffer + will be considered to have a width, height, layer count, and sample count + derived from its default parameters. Framebuffers with one or more + attachments are not affected by these default parameters; the size of the + framebuffer will still be derived from the sizes of the attachments in + that case. + + Additionally, this extension provides queryable implementation-dependent + maximums for framebuffer width, height, layer count, and sample count, + which may differ from similar limits on textures and renderbuffers. These + maximums will be used to error-check the default framebuffer parameters + and also permit implementations to expose the ability to rasterize to an + attachment-less framebuffer larger than the maximum supported texture + size. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/framebuffer_no_attachments.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.framebuffer_no_attachments import * +from OpenGL.raw.GL.ARB.framebuffer_no_attachments import _EXTENSION_NAME + +def glInitFramebufferNoAttachmentsARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +glGetFramebufferParameteriv=wrapper.wrapper(glGetFramebufferParameteriv).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/framebuffer_object.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/framebuffer_object.py new file mode 100644 index 00000000..a1a55bbe --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/framebuffer_object.py @@ -0,0 +1,331 @@ +'''OpenGL extension ARB.framebuffer_object + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.framebuffer_object to provide a more +Python-friendly API + +Overview (from the spec) + + ARB_framebuffer_object is an extension intended to address the following + goals: + + - Reflect FBO-related functionality found in the OpenGL 3.0 specification. + + - Integrate multiple disjoint extensions into a single ARB extension. + These extensions are: + + EXT_framebuffer_object + EXT_framebuffer_blit + EXT_framebuffer_multisample + EXT_packed_depth_stencil + + - Where appropriate, relax some of the constraints expressed by previous + FBO-related extensions. In particular the requirement of matching + attachment dimensions and component sizes has been relaxed, to allow + implementations the freedom to support more flexible usages where + possible. + + + ARB_framebuffer_object defines an interface for drawing to rendering + destinations other than the buffers provided to the GL by the + window-system. + + In this extension, these newly defined rendering destinations are + known collectively as "framebuffer-attachable images". This + extension provides a mechanism for attaching framebuffer-attachable + images to the GL framebuffer as one of the standard GL logical + buffers: color, depth, and stencil. (Attaching a + framebuffer-attachable image to the accum logical buffer is left for + a future extension to define). When a framebuffer-attachable image + is attached to the framebuffer, it is used as the source and + destination of fragment operations as described in Chapter 4. + + By allowing the use of a framebuffer-attachable image as a rendering + destination, this extension enables a form of "offscreen" rendering. + Furthermore, "render to texture" is supported by allowing the images + of a texture to be used as framebuffer-attachable images. A + particular image of a texture object is selected for use as a + framebuffer-attachable image by specifying the mipmap level, cube + map face (for a cube map texture), and layer (for a 3D texture) + that identifies the image. The "render to texture" semantics of + this extension are similar to performing traditional rendering to + the framebuffer, followed immediately by a call to CopyTexSubImage. + However, by using this extension instead, an application can achieve + the same effect, but with the advantage that the GL can usually + eliminate the data copy that would have been incurred by calling + CopyTexSubImage. + + This extension also defines a new GL object type, called a + "renderbuffer", which encapsulates a single 2D pixel image. The + image of renderbuffer can be used as a framebuffer-attachable image + for generalized offscreen rendering and it also provides a means to + support rendering to GL logical buffer types which have no + corresponding texture format (stencil, accum, etc). A renderbuffer + is similar to a texture in that both renderbuffers and textures can + be independently allocated and shared among multiple contexts. The + framework defined by this extension is general enough that support + for attaching images from GL objects other than textures and + renderbuffers could be added by layered extensions. + + To facilitate efficient switching between collections of + framebuffer-attachable images, this extension introduces another new + GL object, called a framebuffer object. A framebuffer object + contains the state that defines the traditional GL framebuffer, + including its set of images. Prior to this extension, it was the + window-system which defined and managed this collection of images, + traditionally by grouping them into a "drawable". The window-system + API's would also provide a function (i.e., wglMakeCurrent, + glXMakeCurrent, aglSetDrawable, etc.) to bind a drawable with a GL + context (as is done in the WGL_ARB_pbuffer extension). In this + extension however, this functionality is subsumed by the GL and the + GL provides the function BindFramebufferARB to bind a framebuffer + object to the current context. Later, the context can bind back to + the window-system-provided framebuffer in order to display rendered + content. + + Previous extensions that enabled rendering to a texture have been + much more complicated. One example is the combination of + ARB_pbuffer and ARB_render_texture, both of which are window-system + extensions. This combination requires calling MakeCurrent, an + operation that may be expensive, to switch between the window and + the pbuffer drawables. An application must create one pbuffer per + renderable texture in order to portably use ARB_render_texture. An + application must maintain at least one GL context per texture + format, because each context can only operate on a single + pixelformat or FBConfig. All of these characteristics make + ARB_render_texture both inefficient and cumbersome to use. + + ARB_framebuffer_object, on the other hand, is both simpler to use + and more efficient than ARB_render_texture. The + ARB_framebuffer_object API is contained wholly within the GL API and + has no (non-portable) window-system components. Under + ARB_framebuffer_object, it is not necessary to create a second GL + context when rendering to a texture image whose format differs from + that of the window. Finally, unlike the pbuffers of + ARB_render_texture, a single framebuffer object can facilitate + rendering to an unlimited number of texture objects. + + This extension differs from EXT_framebuffer_object by splitting the + framebuffer object binding point into separate DRAW and READ + bindings (incorporating functionality introduced by + EXT_framebuffer_blit). This allows copying directly from one + framebuffer to another. In addition, a new high performance blit + function is added to facilitate these blits and perform some data + conversion where allowed. + + This extension also enables usage of multisampling in conjunction with + renderbuffers (incorporating functionality from + EXT_packed_depth_stencil), as follows: + + The new operation RenderbufferStorageMultisample() allocates + storage for a renderbuffer object that can be used as a multisample + buffer. A multisample render buffer image differs from a + single-sample render buffer image in that a multisample image has a + number of SAMPLES that is greater than zero. No method is provided + for creating multisample texture images. + + All of the framebuffer-attachable images attached to a framebuffer + object must have the same number of SAMPLES or else the framebuffer + object is not "framebuffer complete". If a framebuffer object with + multisample attachments is "framebuffer complete", then the + framebuffer object behaves as if SAMPLE_BUFFERS is one. + + In traditional multisample rendering, where + DRAW_FRAMEBUFFER_BINDING is zero and SAMPLE_BUFFERS is one, the + GL spec states that "the color sample values are resolved to a + single, displayable color each time a pixel is updated." There are, + however, several modern hardware implementations that do not + actually resolve for each sample update, but instead postpones the + resolve operation to a later time and resolve a batch of sample + updates at a time. This is OK as long as the implementation behaves + "as if" it had resolved a sample-at-a-time. Unfortunately, however, + honoring the "as if" rule can sometimes degrade performance. + + In contrast, when DRAW_FRAMEBUFFER_BINDING is an + application-created framebuffer object, MULTISAMPLE is enabled, and + SAMPLE_BUFFERS is one, there is no implicit per-sample-update + resolve. Instead, the application explicitly controls when the + resolve operation is performed. The resolve operation is affected + by calling BlitFramebuffer where the source is a multisample + application-created framebuffer object and the destination is a + single-sample framebuffer object (either application-created or + window-system provided). + + This design for multisample resolve more closely matches current + hardware, but still permits implementations which choose to resolve + a single sample at a time. If hardware that implements the + multisample resolution "one sample at a time" exposes + ARB_framebuffer_object, it could perform the implicit resolve + to a driver-managed hidden surface, then read from that surface when + the application calls BlitFramebuffer. + + Another motivation for granting the application explicit control + over the multisample resolve operation has to do with the + flexibility afforded by ARB_framebuffer_object. Previously, a + drawable (window or pbuffer) had exclusive access to all of its + buffers. There was no mechanism for sharing a buffer across + multiple drawables. Under ARB_framebuffer_object, however, a + mechanism exists for sharing a framebuffer-attachable image across + several framebuffer objects, as well as sharing an image between a + framebuffer object and a texture. If we had retained the "implicit" + resolve from traditional multisampled rendering, and allowed the + creation of "multisample" format renderbuffers, then this type of + sharing would have lead to two problematic situations: + + * Two contexts, which shared renderbuffers, might perform + competing resolve operations into the same single-sample buffer + with ambiguous results. + + * It would have introduced the unfortunate ability to use the + single-sample buffer as a texture while MULTISAMPLE is ENABLED. + + Using BlitFramebuffer as an explicit resolve to serialize access to + the multisampled contents and eliminate the implicit per-sample + resolve operation, we avoid both of these problems. + + This extension also enables usage of packed depth-stencil formats in + renderbuffers (incorporating functionality from + EXT_packed_depth_stencil), as follows: + + Many OpenGL implementations have chosen to interleave the depth and + stencil buffers into one buffer, often with 24 bits of depth + precision and 8 bits of stencil data. 32 bits is more than is + needed for the depth buffer much of the time; a 24-bit depth buffer, + on the other hand, requires that reads and writes of depth data be + unaligned with respect to power-of-two boundaries. On the other + hand, 8 bits of stencil data is more than sufficient for most + applications, so it is only natural to pack the two buffers into a + single buffer with both depth and stencil data. OpenGL never + provides direct access to the buffers, so the OpenGL implementation + can provide an interface to applications where it appears the one + merged buffer is composed of two logical buffers. + + One disadvantage of this scheme is that OpenGL lacks any means by + which this packed data can be handled efficiently. For example, + when an application reads from the 24-bit depth buffer, using the + type GL_UNSIGNED_SHORT will lose 8 bits of data, while + GL_UNSIGNED_INT has 8 too many. Both require expensive format + conversion operations. A 24-bit format would be no more suitable, + because it would also suffer from the unaligned memory accesses that + made the standalone 24-bit depth buffer an unattractive proposition + in the first place. + + Many applications, such as parallel rendering applications, may also + wish to draw to or read back from both the depth and stencil buffers + at the same time. Currently this requires two separate operations, + reducing performance. Since the buffers are interleaved, drawing to + or reading from both should be no more expensive than using just + one; in some cases, it may even be cheaper. + + This extension provides a new data format, GL_DEPTH_STENCIL, + that can be used with the glDrawPixels, glReadPixels, and + glCopyPixels commands, as well as a packed data type, + GL_UNSIGNED_INT_24_8, that is meant to be used with + GL_DEPTH_STENCIL. No other data types are supported with + GL_DEPTH_STENCIL. If ARB_depth_texture or SGIX_depth_texture is + supported, GL_DEPTH_STENCIL/GL_UNSIGNED_INT_24_8 data can + also be used for textures; this provides a more efficient way to + supply data for a 24-bit depth texture. + + GL_DEPTH_STENCIL data, when passed through the pixel path, + undergoes both depth and stencil operations. The depth data is + scaled and biased by the current GL_DEPTH_SCALE and GL_DEPTH_BIAS, + while the stencil data is shifted and offset by the current + GL_INDEX_SHIFT and GL_INDEX_OFFSET. The stencil data is also put + through the stencil-to-stencil pixel map. + + glDrawPixels of GL_DEPTH_STENCIL data operates similarly to that + of GL_STENCIL_INDEX data, bypassing the OpenGL fragment pipeline + entirely, unlike the treatment of GL_DEPTH_COMPONENT data. The + stencil and depth masks are applied, as are the pixel ownership and + scissor tests, but all other operations are skipped. + + glReadPixels of GL_DEPTH_STENCIL data reads back a rectangle + from both the depth and stencil buffers. + + glCopyPixels of GL_DEPTH_STENCIL data copies a rectangle from + both the depth and stencil buffers. Like glDrawPixels, it applies + both the stencil and depth masks but skips the remainder of the + OpenGL fragment pipeline. + + glTex[Sub]Image[1,2,3]D of GL_DEPTH_STENCIL data loads depth and + stencil data into a depth_stencil texture. glGetTexImage of + GL_DEPTH_STENCIL data can be used to retrieve depth and stencil + data from a depth/stencil texture. + + In addition, a new base internal format, GL_DEPTH_STENCIL, can + be used by both texture images and renderbuffer storage. When an + image with a DEPTH_STENCIL internal format is attached to both + the depth and stencil attachment points of a framebuffer object, + then it becomes both the depth and stencil + buffers of the framebuffer. This fits nicely with hardware that + interleaves both depth and stencil data into a single buffer. When + a texture with DEPTH_STENCIL data is bound for texturing, only + the depth component is accessible through the texture fetcher. The + stencil data can be written with TexImage or CopyTexImage, and can + be read with GetTexImage. When a DEPTH_STENCIL image is + attached to the stencil attachment of the bound framebuffer object, + the stencil data can be accessed through any operation that reads + from or writes to the framebuffer's stencil buffer. + + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/framebuffer_object.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.framebuffer_object import * +from OpenGL.raw.GL.ARB.framebuffer_object import _EXTENSION_NAME + +def glInitFramebufferObjectARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glDeleteRenderbuffers.renderbuffers size not checked against n +glDeleteRenderbuffers=wrapper.wrapper(glDeleteRenderbuffers).setInputArraySize( + 'renderbuffers', None +) +glGenRenderbuffers=wrapper.wrapper(glGenRenderbuffers).setOutput( + 'renderbuffers',size=lambda x:(x,),pnameArg='n',orPassIn=True +) +glGetRenderbufferParameteriv=wrapper.wrapper(glGetRenderbufferParameteriv).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +# INPUT glDeleteFramebuffers.framebuffers size not checked against n +glDeleteFramebuffers=wrapper.wrapper(glDeleteFramebuffers).setInputArraySize( + 'framebuffers', None +) +glGenFramebuffers=wrapper.wrapper(glGenFramebuffers).setOutput( + 'framebuffers',size=lambda x:(x,),pnameArg='n',orPassIn=True +) +glGetFramebufferAttachmentParameteriv=wrapper.wrapper(glGetFramebufferAttachmentParameteriv).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +### END AUTOGENERATED SECTION +from OpenGL.lazywrapper import lazy as _lazy + +@_lazy( glDeleteFramebuffers ) +def glDeleteFramebuffers( baseOperation, n, framebuffers=None ): + """glDeleteFramebuffers( framebuffers ) -> None + """ + if framebuffers is None: + framebuffers = arrays.GLuintArray.asArray( n ) + n = arrays.GLuintArray.arraySize( framebuffers ) + return baseOperation( n, framebuffers ) + +# Setup the GL_UNSIGNED_INT_24_8 image type +from OpenGL import images +from OpenGL.raw.GL.VERSION.GL_1_1 import GL_UNSIGNED_INT +images.TYPE_TO_ARRAYTYPE[ GL_UNSIGNED_INT_24_8 ] = GL_UNSIGNED_INT +images.TIGHT_PACK_FORMATS[ GL_UNSIGNED_INT_24_8 ] = 4 + +# The extensions actually use the _EXT forms, which is a bit confusing +# for users, IMO. +GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS = constant.Constant( 'GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS', 0x8CD9 ) +GL_FRAMEBUFFER_INCOMPLETE_FORMATS = constant.Constant( 'GL_FRAMEBUFFER_INCOMPLETE_FORMATS', 0x8CDA ) +GL_FRAMEBUFFER_UNSUPPORTED = constant.Constant( 'GL_FRAMEBUFFER_UNSUPPORTED', 0x8CDD ) +del images +del GL_UNSIGNED_INT diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/framebuffer_sRGB.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/framebuffer_sRGB.py new file mode 100644 index 00000000..63423ddd --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/framebuffer_sRGB.py @@ -0,0 +1,55 @@ +'''OpenGL extension ARB.framebuffer_sRGB + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.framebuffer_sRGB to provide a more +Python-friendly API + +Overview (from the spec) + + Conventionally, OpenGL assumes framebuffer color components are stored + in a linear color space. In particular, framebuffer blending is a + linear operation. + + The sRGB color space is based on typical (non-linear) monitor + characteristics expected in a dimly lit office. It has been + standardized by the International Electrotechnical Commission (IEC) + as IEC 61966-2-1. The sRGB color space roughly corresponds to 2.2 + gamma correction. + + This extension adds a framebuffer capability for sRGB framebuffer + update and blending. When blending is disabled but the new sRGB + updated mode is enabled (assume the framebuffer supports the + capability), high-precision linear color component values for red, + green, and blue generated by fragment coloring are encoded for sRGB + prior to being written into the framebuffer. When blending is enabled + along with the new sRGB update mode, red, green, and blue framebuffer + color components are treated as sRGB values that are converted to + linear color values, blended with the high-precision color values + generated by fragment coloring, and then the blend result is encoded + for sRGB just prior to being written into the framebuffer. + + The primary motivation for this extension is that it allows OpenGL + applications to render into a framebuffer that is scanned to a monitor + configured to assume framebuffer color values are sRGB encoded. + This assumption is roughly true of most PC monitors with default + gamma correction. This allows applications to achieve faithful + color reproduction for OpenGL rendering without adjusting the + monitor's gamma correction. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/framebuffer_sRGB.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.framebuffer_sRGB import * +from OpenGL.raw.GL.ARB.framebuffer_sRGB import _EXTENSION_NAME + +def glInitFramebufferSrgbARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/geometry_shader4.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/geometry_shader4.py new file mode 100644 index 00000000..07fc8ade --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/geometry_shader4.py @@ -0,0 +1,53 @@ +'''OpenGL extension ARB.geometry_shader4 + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.geometry_shader4 to provide a more +Python-friendly API + +Overview (from the spec) + + ARB_geometry_shader4 defines a new shader type available to be run on the + GPU, called a geometry shader. Geometry shaders are run after vertices are + transformed, but prior to color clamping, flat shading and clipping. + + A geometry shader begins with a single primitive (point, line, + triangle). It can read the attributes of any of the vertices in the + primitive and use them to generate new primitives. A geometry shader has a + fixed output primitive type (point, line strip, or triangle strip) and + emits vertices to define a new primitive. A geometry shader can emit + multiple disconnected primitives. The primitives emitted by the geometry + shader are clipped and then processed like an equivalent OpenGL primitive + specified by the application. + + Furthermore, ARB_geometry_shader4 provides four additional primitive + types: lines with adjacency, line strips with adjacency, separate + triangles with adjacency, and triangle strips with adjacency. Some of the + vertices specified in these new primitive types are not part of the + ordinary primitives, instead they represent neighboring vertices that are + adjacent to the two line segment end points (lines/strips) or the three + triangle edges (triangles/tstrips). These vertices can be accessed by + geometry shaders and used to match up the vertices emitted by the geometry + shader with those of neighboring primitives. + + Since geometry shaders expect a specific input primitive type, an error + will occur if the application presents primitives of a different type. + For example, if a geometry shader expects points, an error will occur at + Begin() time, if a primitive mode of TRIANGLES is specified. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/geometry_shader4.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.geometry_shader4 import * +from OpenGL.raw.GL.ARB.geometry_shader4 import _EXTENSION_NAME + +def glInitGeometryShader4ARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/get_program_binary.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/get_program_binary.py new file mode 100644 index 00000000..d07a5bed --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/get_program_binary.py @@ -0,0 +1,56 @@ +'''OpenGL extension ARB.get_program_binary + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.get_program_binary to provide a more +Python-friendly API + +Overview (from the spec) + + This extension introduces new commands to retrieve and set the binary + representation of a program object. GetProgramBinary allows an + application to cache compiled and linked programs to avoid compiling and + linking when used again. This may even allow the GL itself to act as an + offline compiler. The resulting program binary can be reloaded into the + GL via ProgramBinary. This is a very useful path for applications that + wish to remain portable by shipping pure GLSL source shaders, yet would + like to avoid the cost of compiling their shaders at runtime. Instead an + application can supply its GLSL source shaders during first application run, + or even during installation. The application then compiles and links its + shaders and reads back the program binaries. On subsequent runs, only the + program binaries need be supplied. + + ProgramBinary may also accept binaries in vendor-specific formats + produced by specialized offline compilation tools. This extension does not + add any such formats, but allows for them in further extensions. Though the + level of optimization may not be identical -- the offline shader compiler + may have the luxury of more aggressive optimization at its disposal -- + program binaries generated online by the GL are interchangeable with those + generated offline by an SDK tool. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/get_program_binary.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.get_program_binary import * +from OpenGL.raw.GL.ARB.get_program_binary import _EXTENSION_NAME + +def glInitGetProgramBinaryARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +glGetProgramBinary=wrapper.wrapper(glGetProgramBinary).setOutput( + 'binary',size=lambda x:(x,),pnameArg='bufSize',orPassIn=True +).setOutput( + 'binaryFormat',size=(1,),orPassIn=True +).setOutput( + 'length',size=(1,),orPassIn=True +) +# INPUT glProgramBinary.binary size not checked against length +glProgramBinary=wrapper.wrapper(glProgramBinary).setInputArraySize( + 'binary', None +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/get_texture_sub_image.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/get_texture_sub_image.py new file mode 100644 index 00000000..40150666 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/get_texture_sub_image.py @@ -0,0 +1,28 @@ +'''OpenGL extension ARB.get_texture_sub_image + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.get_texture_sub_image to provide a more +Python-friendly API + +Overview (from the spec) + + This extension adds a new function to get sub-regions of texture + images. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/get_texture_sub_image.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.get_texture_sub_image import * +from OpenGL.raw.GL.ARB.get_texture_sub_image import _EXTENSION_NAME + +def glInitGetTextureSubImageARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/gl_spirv.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/gl_spirv.py new file mode 100644 index 00000000..edcd0828 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/gl_spirv.py @@ -0,0 +1,414 @@ +'''OpenGL extension ARB.gl_spirv + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.gl_spirv to provide a more +Python-friendly API + +Overview (from the spec) + + This is version 100 of the GL_ARB_gl_spirv extension. + + This extension does two things: + + 1. Allows a SPIR-V module to be specified as containing a programmable + shader stage, rather than using GLSL, whatever the source language + was used to create the SPIR-V module. + + 2. Modifies GLSL to be a source language for creating SPIR-V modules + for OpenGL consumption. Such GLSL can be used to create such SPIR-V + modules, outside of the OpenGL runtime. + + Enabling GLSL SPIR-V Features + ----------------------------- + + This extension is not enabled with a #extension as other extensions are. + It is also not enabled through use of a profile or #version. The intended + level of GLSL features comes from the traditional use of #version, profile, + and #extension. + + Instead, use of this extension is an effect of using a GLSL front-end in a + mode that has it generate SPIR-V for OpenGL. Such tool use is outside the + scope of using the OpenGL API and outside the definition of GLSL and this + extension. See the documentation of the compiler to see how to request + generation of SPIR-V for OpenGL. + + When a front-end is used to accept the GLSL features in this extension, it + must error check and reject shaders not adhering to this specification, and + accept those that do. Implementation-dependent maximums and capabilities + are supplied to, or part of, the front-end, so it can do error checking + against them. + + A shader can query the level of GLSL SPIR-V support available, using the + predefined + + #define GL_SPIRV 100 + + This allows shader code to say, for example, + + #ifdef GL_SPIRV + layout(constant_id = 11) const int count = 4; + #if GL_SPIRV > 100 + ... + #endif + #else + const int count = 6; + #endif + + SPIR-V Modules + -------------- + + An entire stage is held in a single SPIR-V module. The SPIR-V model is + that multiple (e.g., GLSL) compilation units forming a single stage + in a high-level language are all compiled and linked together to form a + single entry point (and its call tree) in a SPIR-V module. This would be + done prior to using the OpenGL API to create a program object containing the + stage. + + The OpenGL API expects the SPIR-V module to have already been validated, + and can return an error if it discovers anything invalid in + the module. An invalid SPIR-V module is allowed to result in undefined + behavior. + + Specialization Constants + ------------------------ + + SPIR-V specialization constants, which can be set later by the client API, + can be declared using "layout(constant_id=...)". For example, to make a + specialization constant with a default value of 12: + + layout(constant_id = 17) const int arraySize = 12; + + Above, "17" is the ID by which the API or other tools can later refer to + this specific specialization constant. The API or an intermediate tool can + then change its value to another constant integer before it is fully + lowered to executable code. If it is never changed before final lowering, + it will retain the value of 12. + + Specialization constants have const semantics, except they don't fold. + Hence, an array can be declared with 'arraySize' from above: + + vec4 data[arraySize]; // legal, even though arraySize might change + + Specialization constants can be in expressions: + + vec4 data2[arraySize + 2]; + + This will make data2 be sized by 2 more than whatever constant value + 'arraySize' has when it is time to lower the shader to executable code. + + An expression formed with specialization constants also behaves in the + shader like a specialization constant, not a like a constant. + + arraySize + 2 // a specialization constant (with no constant_id) + + Such expressions can be used in the same places as a constant. + + The constant_id can only be applied to a scalar *int*, a scalar *float* + or a scalar *bool*. + + Only basic operators and constructors can be applied to a specialization + constant and still result in a specialization constant: + + layout(constant_id = 17) const int arraySize = 12; + sin(float(arraySize)); // result is not a specialization constant + + While SPIR-V specialization constants are only for scalars, a vector + can be made by operations on scalars: + + layout(constant_id = 18) const int scX = 1; + layout(constant_id = 19) const int scZ = 1; + const vec3 scVec = vec3(scX, 1, scZ); // partially specialized vector + + A built-in variable can have a 'constant_id' attached to it: + + layout(constant_id = 18) gl_MaxImageUnits; + + This makes it behave as a specialization constant. It is not a full + redeclaration; all other characteristics are left intact from the + original built-in declaration. + + The built-in vector gl_WorkGroupSize can be specialized using special + layout local_size_{xyz}_id's applied to the "in" qualifier. For example: + + layout(local_size_x_id = 18, local_size_z_id = 19) in; + + This leaves gl_WorkGroupSize.y as a non-specialization constant, with + gl_WorkGroupSize being a partially specialized vector. Its x and z + components can be later specialized using the ID's 18 and 19. + + gl_FragColor + ------------ + + The fragment-stage built-in gl_FragColor, which implies a broadcast to all + outputs, is not present in SPIR-V. Shaders where writing to gl_FragColor + is allowed can still write to it, but it only means to write to an output: + - of the same type as gl_FragColor + - decorated with location 0 + - not decorated as a built-in variable. + There is no implicit broadcast. + + Mapping to SPIR-V + ----------------- + + For informational purposes (non-specification), the following is an + expected way for an implementation to map GLSL constructs to SPIR-V + constructs: + + Mapping of Storage Classes: + + uniform sampler2D...; -> UniformConstant + uniform variable (non-block) -> UniformConstant + uniform blockN { ... } ...; -> Uniform, with Block decoration + in / out variable -> Input/Output, possibly with block (below) + in / out block... -> Input/Output, with Block decoration + buffer blockN { ... } ...; -> Uniform, with BufferBlock decoration + ... uniform atomic_uint ... -> AtomicCounter + shared -> Workgroup + -> Private + + Mapping of input/output blocks or variables is the same for all versions + of GLSL. To the extent variables or members are available in a + version and a stage, its location is as follows: + + These are mapped to SPIR-V individual variables, with similarly spelled + built-in decorations (except as noted): + + General: + + in gl_VertexID + in gl_InstanceID + in gl_InvocationID + in gl_PatchVerticesIn (PatchVertices) + in gl_PrimitiveIDIn (PrimitiveID) + in/out gl_PrimitiveID (in/out based only on storage qualifier) + in gl_TessCoord + + in/out gl_Layer + in/out gl_ViewportIndex + + patch in/out gl_TessLevelOuter (uses Patch decoration) + patch in/out gl_TessLevelInner (uses Patch decoration) + + Compute stage only: + + in gl_NumWorkGroups + in gl_WorkGroupSize + in gl_WorkGroupID + in gl_LocalInvocationID + in gl_GlobalInvocationID + in gl_LocalInvocationIndex + + Fragment stage only: + + in gl_FragCoord + in gl_FrontFacing + in gl_ClipDistance + in gl_CullDistance + in gl_PointCoord + in gl_SampleID + in gl_SamplePosition + in gl_HelperInvocation + out gl_FragDepth + in gl_SampleMaskIn (SampleMask) + out gl_SampleMask (in/out based only on storage qualifier) + + These are mapped to SPIR-V blocks, as implied by the pseudo code, with + the members decorated with similarly spelled built-in decorations: + + Non-fragment stage: + + in/out gl_PerVertex { // some subset of these members will be used + gl_Position + gl_PointSize + gl_ClipDistance + gl_CullDistance + } // name of block is for debug only + + There is at most one input and one output block per stage in SPIR-V. + The subset and order of members will match between stages sharing an + interface. + + Mapping of precise: + + precise -> NoContraction + + Mapping of atomic_uint /offset/ layout qualifier + + offset -> Offset (decoration) + + Mapping of images + + imageLoad() -> OpImageRead + imageStore() -> OpImageWrite + texelFetch() -> OpImageFetch + + imageAtomicXXX(params, data) -> %ptr = OpImageTexelPointer params + OpAtomicXXX %ptr, data + + XXXQueryXXX(combined) -> %image = OpImage combined + OpXXXQueryXXX %image + + Mapping of layouts + + std140/std430 -> explicit *Offset*, *ArrayStride*, and *MatrixStride* + Decoration on struct members + shared/packed -> not allowed + -> not shared, but std140 or std430 + xfb_offset -> *Offset* Decoration on the object or struct member + xfb_buffer -> *XfbBuffer* Decoration on the object + xfb_stride -> *XfbStride* Decoration on the object + any xfb_* -> the *Xfb* Execution Mode is set + captured XFB -> has both *XfbBuffer* and *Offset* + non-captured -> lacking *XfbBuffer* or *Offset* + + max_vertices -> OutputVertices + + Mapping of barriers + + barrier() (compute) -> OpControlBarrier(/*Execution*/Workgroup, + /*Memory*/Workgroup, + /*Semantics*/AcquireRelease | + WorkgroupMemory) + + barrier() (tess control) -> OpControlBarrier(/*Execution*/Workgroup, + /*Memory*/Invocation, + /*Semantics*/None) + + memoryBarrier() -> OpMemoryBarrier(/*Memory*/Device, + /*Semantics*/AcquireRelease | + UniformMemory | + WorkgroupMemory | + ImageMemory) + + memoryBarrierBuffer() -> OpMemoryBarrier(/*Memory*/Device, + /*Semantics*/AcquireRelease | + UniformMemory) + + memoryBarrierShared() -> OpMemoryBarrier(/*Memory*/Device, + /*Semantics*/AcquireRelease | + WorkgroupMemory) + + memoryBarrierImage() -> OpMemoryBarrier(/*Memory*/Device, + /*Semantics*/AcquireRelease | + ImageMemory) + + groupMemoryBarrier() -> OpMemoryBarrier(/*Memory*/Workgroup, + /*Semantics*/AcquireRelease | + UniformMemory | + WorkgroupMemory | + ImageMemory) + + Mapping of atomics + + all atomic builtin functions -> Semantics = None(Relaxed) + + atomicExchange() -> OpAtomicExchange + imageAtomicExchange() -> OpAtomicExchange + atomicCompSwap() -> OpAtomicCompareExchange + imageAtomicCompSwap() -> OpAtomicCompareExchange + NA -> OpAtomicCompareExchangeWeak + + atomicCounterIncrement -> OpAtomicIIncrement + atomicCounterDecrement -> OpAtomicIDecrement (with post decrement) + atomicCounter -> OpAtomicLoad + + Mapping of uniform initializers + + Using the OpVariable initializer logic, but only from a constant + instruction (not a global one). + + Mapping of other instructions + + % -> OpUMod/OpSMod + mod() -> OpFMod + NA -> OpSRem/OpFRem + + pack/unpack (conversion) -> pack/unpack in GLSL extended instructions + pack/unpack (no conversion) -> OpBitcast + + Differences Relative to Other Specifications + -------------------------------------------- + + The following summarizes the set of differences to existing specifications. + + Additional use of existing SPIR-V features, relative to Vulkan: + + The *UniformConstant* Storage Class can be used on individual + variables at global scope. (That is, uniforms don't have to be in a + block, unless they are built-in members that are in block in GLSL + version 4.5.) + + *AtomicCounter* Storage Class can use the *Offset* decoration + + OriginLowerLeft + + Uniforms support constant initializers. + + Corresponding features that GLSL keeps, despite GL_KHR_vulkan_glsl removal: + . default uniforms (those not inside a uniform block) + . atomic-counter bindings have the /offset/ layout qualifier + . special rules for locations for input doubles in the vertex shader + . origin_lower_left + + Addition of features to GLSL: + + specialization constants, as per GL_KHR_vulkan_glsl + + #define GL_SPIRV 100, when compiled for OpenGL and SPIR-V generation + + offset can organize members in a different order than declaration order + + Non-acceptance of SPIR-V features, relative to Vulkan: + - VertexIndex and InstanceIndex built-in decorations cannot be used + - Push-constant buffers cannot be used + - *DescriptorSet* must always be 0, if present + - input targets and input attachments + - OpTypeSampler + + Corresponding features not added to GLSL that GL_KHR_vulkan_glsl added: + . gl_VertexIndex and gl_InstanceIndex + (gl_VertexID and gl_InstanceID have same semantics as in GLSL) + . push_constant buffers + . descriptor sets + . input_attachment_index and accessing input targets + . shader-combining of textures and samplers + + Removal of features from GLSL, as removed by GL_KHR_vulkan_glsl: + - subroutines + - the already deprecated texturing functions (e.g., texture2D()) + - the already deprecated noise functions (e.g., noise1()) + - compatibility profile features + - gl_DepthRangeParameters and gl_NumSamples + - *shared* and *packed* block layouts + + Addition of features to The OpenGL Graphics System: + + a command to associate a SPIR-V module with a program (ShaderBinary) + + a command to select a SPIR-V entry point and set specialization + constants in a SPIR-V module (SpecializeShaderARB) + + a new appendix for SPIR-V validation rules, precision, etc. + + Changes of system features, relative to Vulkan: + . Vulkan uses only one binding point for a resource array, while OpenGL + still uses multiple binding points, so binding numbers are counted + differently for SPIR-V used in Vulkan and OpenGL + . gl_FragColor can be written to, but it won't broadcast, for versions of + OpenGL that support gl_FragColor + . Vulkan does not allow multi-dimensional arrays of resources like + UBOs and SSBOs in its SPIR-V environment spec. SPIR-V supports + it and OpenGL already allows this for GLSL shaders. SPIR-V + for OpenGL also allows it. + + Additions to the SPIR-V specification: + + *Offset* can also apply to an object, for transform feedback. + + *Offset* can also apply to a default uniform, for atomic_uint offset. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/gl_spirv.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.gl_spirv import * +from OpenGL.raw.GL.ARB.gl_spirv import _EXTENSION_NAME + +def glInitGlSpirvARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/gpu_shader5.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/gpu_shader5.py new file mode 100644 index 00000000..4069ac90 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/gpu_shader5.py @@ -0,0 +1,104 @@ +'''OpenGL extension ARB.gpu_shader5 + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.gpu_shader5 to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides a set of new features to the OpenGL Shading + Language and related APIs to support capabilities of new GPUs, extending + the capabilities of version 1.50 of the OpenGL Shading Language. Shaders + using the new functionality provided by this extension should enable this + functionality via the construct + + #extension GL_ARB_gpu_shader5 : require (or enable) + + This extension provides a variety of new features for all shader types, + including: + + * support for indexing into arrays of samplers using non-constant + indices, as long as the index doesn't diverge if multiple shader + invocations are run in lockstep; + + * extending the uniform block capability of OpenGL 3.1 and 3.2 to allow + shaders to index into an array of uniform blocks; + + * support for implicitly converting signed integer types to unsigned + types, as well as more general implicit conversion and function + overloading infrastructure to support new data types introduced by + other extensions; + + * a "precise" qualifier allowing computations to be carried out exactly + as specified in the shader source to avoid optimization-induced + invariance issues (which might cause cracking in tessellation); + + * new built-in functions supporting: + + * fused floating-point multiply-add operations; + + * splitting a floating-point number into a significand and exponent + (frexp), or building a floating-point number from a significand and + exponent (ldexp); + + * integer bitfield manipulation, including functions to find the + position of the most or least significant set bit, count the number + of one bits, and bitfield insertion, extraction, and reversal; + + * packing and unpacking vectors of small fixed-point data types into a + larger scalar; and + + * convert floating-point values to or from their integer bit + encodings; + + * extending the textureGather() built-in functions provided by + ARB_texture_gather: + + * allowing shaders to select any single component of a multi-component + texture to produce the gathered 2x2 footprint; + + * allowing shaders to perform a per-sample depth comparison when + gathering the 2x2 footprint using for shadow sampler types; + + * allowing shaders to use arbitrary offsets computed at run-time to + select a 2x2 footprint to gather from; and + + * allowing shaders to use separate independent offsets for each of the + four texels returned, instead of requiring a fixed 2x2 footprint. + + This extension also provides some new capabilities for individual + shader types, including: + + * support for instanced geometry shaders, where a geometry shader may be + run multiple times for each primitive, including a built-in + gl_InvocationID to identify the invocation number; + + * support for emitting vertices in a geometry program where each vertex + emitted may be directed independently at a specified vertex stream (as + provided by ARB_transform_feedback3), and where each shader output is + associated with a stream; + + * support for reading a mask of covered samples in a fragment shader; + and + + * support for interpolating a fragment shader input at a programmable + offset relative to the pixel center, a programmable sample number, or + at the centroid. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/gpu_shader5.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.gpu_shader5 import * +from OpenGL.raw.GL.ARB.gpu_shader5 import _EXTENSION_NAME + +def glInitGpuShader5ARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/gpu_shader_fp64.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/gpu_shader_fp64.py new file mode 100644 index 00000000..1ad66ce0 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/gpu_shader_fp64.py @@ -0,0 +1,127 @@ +'''OpenGL extension ARB.gpu_shader_fp64 + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.gpu_shader_fp64 to provide a more +Python-friendly API + +Overview (from the spec) + + This extension allows GLSL shaders to use double-precision floating-point + data types, including vectors and matrices of doubles. Doubles may be + used as inputs, outputs, and uniforms. + + The shading language supports various arithmetic and comparison operators + on double-precision scalar, vector, and matrix types, and provides a set + of built-in functions including: + + * square roots and inverse square roots; + + * fused floating-point multiply-add operations; + + * splitting a floating-point number into a significand and exponent + (frexp), or building a floating-point number from a significand and + exponent (ldexp); + + * absolute value, sign tests, various functions to round to an integer + value, modulus, minimum, maximum, clamping, blending two values, step + functions, and testing for infinity and NaN values; + + * packing and unpacking doubles into a pair of 32-bit unsigned integers; + + * matrix component-wise multiplication, and computation of outer + products, transposes, determinants, and inverses; and + + * vector relational functions. + + Double-precision versions of angle, trigonometry, and exponential + functions are not supported. + + Implicit conversions are supported from integer and single-precision + floating-point values to doubles, and this extension uses the relaxed + function overloading rules specified by the ARB_gpu_shader5 extension to + resolve ambiguities. + + This extension provides API functions for specifying double-precision + uniforms in the default uniform block, including functions similar to the + uniform functions added by EXT_direct_state_access (if supported). + + This extension provides an "LF" suffix for specifying double-precision + constants. Floating-point constants without a suffix in GLSL are treated + as single-precision values for backward compatibility with versions not + supporting doubles; similar constants are treated as double-precision + values in the "C" programming language. + + This extension does not support interpolation of double-precision values; + doubles used as fragment shader inputs must be qualified as "flat". + Additionally, this extension does not allow vertex attributes with 64-bit + components. That support is added separately by EXT_vertex_attrib_64bit. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/gpu_shader_fp64.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.gpu_shader_fp64 import * +from OpenGL.raw.GL.ARB.gpu_shader_fp64 import _EXTENSION_NAME + +def glInitGpuShaderFp64ARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glUniform1dv.value size not checked against count +glUniform1dv=wrapper.wrapper(glUniform1dv).setInputArraySize( + 'value', None +) +# INPUT glUniform2dv.value size not checked against count*2 +glUniform2dv=wrapper.wrapper(glUniform2dv).setInputArraySize( + 'value', None +) +# INPUT glUniform3dv.value size not checked against count*3 +glUniform3dv=wrapper.wrapper(glUniform3dv).setInputArraySize( + 'value', None +) +# INPUT glUniform4dv.value size not checked against count*4 +glUniform4dv=wrapper.wrapper(glUniform4dv).setInputArraySize( + 'value', None +) +# INPUT glUniformMatrix2dv.value size not checked against count*4 +glUniformMatrix2dv=wrapper.wrapper(glUniformMatrix2dv).setInputArraySize( + 'value', None +) +# INPUT glUniformMatrix3dv.value size not checked against count*9 +glUniformMatrix3dv=wrapper.wrapper(glUniformMatrix3dv).setInputArraySize( + 'value', None +) +# INPUT glUniformMatrix4dv.value size not checked against count*16 +glUniformMatrix4dv=wrapper.wrapper(glUniformMatrix4dv).setInputArraySize( + 'value', None +) +# INPUT glUniformMatrix2x3dv.value size not checked against count*6 +glUniformMatrix2x3dv=wrapper.wrapper(glUniformMatrix2x3dv).setInputArraySize( + 'value', None +) +# INPUT glUniformMatrix2x4dv.value size not checked against count*8 +glUniformMatrix2x4dv=wrapper.wrapper(glUniformMatrix2x4dv).setInputArraySize( + 'value', None +) +# INPUT glUniformMatrix3x2dv.value size not checked against count*6 +glUniformMatrix3x2dv=wrapper.wrapper(glUniformMatrix3x2dv).setInputArraySize( + 'value', None +) +# INPUT glUniformMatrix3x4dv.value size not checked against count*12 +glUniformMatrix3x4dv=wrapper.wrapper(glUniformMatrix3x4dv).setInputArraySize( + 'value', None +) +# INPUT glUniformMatrix4x2dv.value size not checked against count*8 +glUniformMatrix4x2dv=wrapper.wrapper(glUniformMatrix4x2dv).setInputArraySize( + 'value', None +) +# INPUT glUniformMatrix4x3dv.value size not checked against count*12 +glUniformMatrix4x3dv=wrapper.wrapper(glUniformMatrix4x3dv).setInputArraySize( + 'value', None +) +# OUTPUT glGetUniformdv.params COMPSIZE(program, location) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/gpu_shader_int64.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/gpu_shader_int64.py new file mode 100644 index 00000000..446b521d --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/gpu_shader_int64.py @@ -0,0 +1,123 @@ +'''OpenGL extension ARB.gpu_shader_int64 + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.gpu_shader_int64 to provide a more +Python-friendly API + +Overview (from the spec) + + The extension introduces the following features for all shader types: + + * support for 64-bit scalar and vector integer data types, including + uniform API, uniform buffer object, transform feedback, and shader + input and output support; + + * new built-in functions to pack and unpack 64-bit integer types into a + two-component 32-bit integer vector; + + * new built-in functions to convert double-precision floating-point + values to or from their 64-bit integer bit encodings; + + * vector relational functions supporting comparisons of vectors of + 64-bit integer types; and + + * common functions abs, sign, min, max, clamp, and mix supporting + arguments of 64-bit integer types. + + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/gpu_shader_int64.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.gpu_shader_int64 import * +from OpenGL.raw.GL.ARB.gpu_shader_int64 import _EXTENSION_NAME + +def glInitGpuShaderInt64ARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glUniform1i64vARB.value size not checked against count +glUniform1i64vARB=wrapper.wrapper(glUniform1i64vARB).setInputArraySize( + 'value', None +) +# INPUT glUniform2i64vARB.value size not checked against count*2 +glUniform2i64vARB=wrapper.wrapper(glUniform2i64vARB).setInputArraySize( + 'value', None +) +# INPUT glUniform3i64vARB.value size not checked against count*3 +glUniform3i64vARB=wrapper.wrapper(glUniform3i64vARB).setInputArraySize( + 'value', None +) +# INPUT glUniform4i64vARB.value size not checked against count*4 +glUniform4i64vARB=wrapper.wrapper(glUniform4i64vARB).setInputArraySize( + 'value', None +) +# INPUT glUniform1ui64vARB.value size not checked against count +glUniform1ui64vARB=wrapper.wrapper(glUniform1ui64vARB).setInputArraySize( + 'value', None +) +# INPUT glUniform2ui64vARB.value size not checked against count*2 +glUniform2ui64vARB=wrapper.wrapper(glUniform2ui64vARB).setInputArraySize( + 'value', None +) +# INPUT glUniform3ui64vARB.value size not checked against count*3 +glUniform3ui64vARB=wrapper.wrapper(glUniform3ui64vARB).setInputArraySize( + 'value', None +) +# INPUT glUniform4ui64vARB.value size not checked against count*4 +glUniform4ui64vARB=wrapper.wrapper(glUniform4ui64vARB).setInputArraySize( + 'value', None +) +# INPUT glGetUniformi64vARB.params size not checked against 'program,location' +glGetUniformi64vARB=wrapper.wrapper(glGetUniformi64vARB).setInputArraySize( + 'params', None +) +# INPUT glGetUniformui64vARB.params size not checked against 'program,location' +glGetUniformui64vARB=wrapper.wrapper(glGetUniformui64vARB).setInputArraySize( + 'params', None +) +# INPUT glGetnUniformi64vARB.params size not checked against bufSize +glGetnUniformi64vARB=wrapper.wrapper(glGetnUniformi64vARB).setInputArraySize( + 'params', None +) +# INPUT glGetnUniformui64vARB.params size not checked against bufSize +glGetnUniformui64vARB=wrapper.wrapper(glGetnUniformui64vARB).setInputArraySize( + 'params', None +) +# INPUT glProgramUniform1i64vARB.value size not checked against count +glProgramUniform1i64vARB=wrapper.wrapper(glProgramUniform1i64vARB).setInputArraySize( + 'value', None +) +# INPUT glProgramUniform2i64vARB.value size not checked against count*2 +glProgramUniform2i64vARB=wrapper.wrapper(glProgramUniform2i64vARB).setInputArraySize( + 'value', None +) +# INPUT glProgramUniform3i64vARB.value size not checked against count*3 +glProgramUniform3i64vARB=wrapper.wrapper(glProgramUniform3i64vARB).setInputArraySize( + 'value', None +) +# INPUT glProgramUniform4i64vARB.value size not checked against count*4 +glProgramUniform4i64vARB=wrapper.wrapper(glProgramUniform4i64vARB).setInputArraySize( + 'value', None +) +# INPUT glProgramUniform1ui64vARB.value size not checked against count +glProgramUniform1ui64vARB=wrapper.wrapper(glProgramUniform1ui64vARB).setInputArraySize( + 'value', None +) +# INPUT glProgramUniform2ui64vARB.value size not checked against count*2 +glProgramUniform2ui64vARB=wrapper.wrapper(glProgramUniform2ui64vARB).setInputArraySize( + 'value', None +) +# INPUT glProgramUniform3ui64vARB.value size not checked against count*3 +glProgramUniform3ui64vARB=wrapper.wrapper(glProgramUniform3ui64vARB).setInputArraySize( + 'value', None +) +# INPUT glProgramUniform4ui64vARB.value size not checked against count*4 +glProgramUniform4ui64vARB=wrapper.wrapper(glProgramUniform4ui64vARB).setInputArraySize( + 'value', None +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/half_float_pixel.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/half_float_pixel.py new file mode 100644 index 00000000..a8c3da14 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/half_float_pixel.py @@ -0,0 +1,40 @@ +'''OpenGL extension ARB.half_float_pixel + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.half_float_pixel to provide a more +Python-friendly API + +Overview (from the spec) + + This extension introduces a new data type for half-precision (16-bit) + floating-point quantities. The floating-point format is very similar + to the IEEE single-precision floating-point standard, except that it + has only 5 exponent bits and 10 mantissa bits. Half-precision floats + are smaller than full precision floats and provide a larger dynamic + range than similarly sized normalized scalar data types. + + This extension allows applications to use half-precision floating- + point data when specifying pixel data. It extends the existing image + specification commands to accept the new data type. + + Floating-point data is clamped to [0, 1] at various places in the + GL unless clamping is disabled with the ARB_color_buffer_float + extension. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/half_float_pixel.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.half_float_pixel import * +from OpenGL.raw.GL.ARB.half_float_pixel import _EXTENSION_NAME + +def glInitHalfFloatPixelARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/half_float_vertex.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/half_float_vertex.py new file mode 100644 index 00000000..cf1ceb7d --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/half_float_vertex.py @@ -0,0 +1,37 @@ +'''OpenGL extension ARB.half_float_vertex + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.half_float_vertex to provide a more +Python-friendly API + +Overview (from the spec) + + This extension extends the usage of the half-precision (16-bit) floating- + point quantities introduced in ARB_half_float_pixel for usage in specifying + vertex array data. + + This extension allows applications to use half-precision floating point data + when specifying vertices. This can allow applications to reduce their + memory footprint, as well as the memory bandwidth required for vertex data. + + This extension extends the existing vertex array commands to accept the new + data type. + + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/half_float_vertex.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.half_float_vertex import * +from OpenGL.raw.GL.ARB.half_float_vertex import _EXTENSION_NAME + +def glInitHalfFloatVertexARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/imaging.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/imaging.py new file mode 100644 index 00000000..43437506 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/imaging.py @@ -0,0 +1,225 @@ +'''OpenGL extension ARB.imaging + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.imaging to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/imaging.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.imaging import * +from OpenGL.raw.GL.ARB.imaging import _EXTENSION_NAME + +def glInitImagingARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glColorTable.table size not checked against 'format,type,width' +glColorTable=wrapper.wrapper(glColorTable).setInputArraySize( + 'table', None +) +# INPUT glColorTableParameterfv.params size not checked against 'pname' +glColorTableParameterfv=wrapper.wrapper(glColorTableParameterfv).setInputArraySize( + 'params', None +) +# INPUT glColorTableParameteriv.params size not checked against 'pname' +glColorTableParameteriv=wrapper.wrapper(glColorTableParameteriv).setInputArraySize( + 'params', None +) +# OUTPUT glGetColorTable.table COMPSIZE(target, format, type) +glGetColorTableParameterfv=wrapper.wrapper(glGetColorTableParameterfv).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetColorTableParameteriv=wrapper.wrapper(glGetColorTableParameteriv).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +# INPUT glColorSubTable.data size not checked against 'format,type,count' +glColorSubTable=wrapper.wrapper(glColorSubTable).setInputArraySize( + 'data', None +) +# INPUT glConvolutionFilter1D.image size not checked against 'format,type,width' +glConvolutionFilter1D=wrapper.wrapper(glConvolutionFilter1D).setInputArraySize( + 'image', None +) +# INPUT glConvolutionFilter2D.image size not checked against 'format,type,width,height' +glConvolutionFilter2D=wrapper.wrapper(glConvolutionFilter2D).setInputArraySize( + 'image', None +) +# INPUT glConvolutionParameterfv.params size not checked against 'pname' +glConvolutionParameterfv=wrapper.wrapper(glConvolutionParameterfv).setInputArraySize( + 'params', None +) +# INPUT glConvolutionParameteriv.params size not checked against 'pname' +glConvolutionParameteriv=wrapper.wrapper(glConvolutionParameteriv).setInputArraySize( + 'params', None +) +# OUTPUT glGetConvolutionFilter.image COMPSIZE(target, format, type) +glGetConvolutionParameterfv=wrapper.wrapper(glGetConvolutionParameterfv).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetConvolutionParameteriv=wrapper.wrapper(glGetConvolutionParameteriv).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +# OUTPUT glGetSeparableFilter.column COMPSIZE(target, format, type) +# OUTPUT glGetSeparableFilter.row COMPSIZE(target, format, type) +# OUTPUT glGetSeparableFilter.span COMPSIZE(target, format, type) +# INPUT glSeparableFilter2D.column size not checked against 'target,format,type,height' +# INPUT glSeparableFilter2D.row size not checked against 'target,format,type,width' +glSeparableFilter2D=wrapper.wrapper(glSeparableFilter2D).setInputArraySize( + 'column', None +).setInputArraySize( + 'row', None +) +# OUTPUT glGetHistogram.values COMPSIZE(target, format, type) +glGetHistogramParameterfv=wrapper.wrapper(glGetHistogramParameterfv).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetHistogramParameteriv=wrapper.wrapper(glGetHistogramParameteriv).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +# OUTPUT glGetMinmax.values COMPSIZE(target, format, type) +glGetMinmaxParameterfv=wrapper.wrapper(glGetMinmaxParameterfv).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetMinmaxParameteriv=wrapper.wrapper(glGetMinmaxParameteriv).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +### END AUTOGENERATED SECTION +from OpenGL.GL import images +from OpenGL.lazywrapper import lazy as _lazy +glColorTable = images.setDimensionsAsInts( + images.setImageInput( + glColorTable, + pixelName = 'table', + typeName = 'type', + ) +) +glColorSubTable = images.setDimensionsAsInts( + images.setImageInput( + glColorSubTable, + pixelName = 'data', + ) +) +glSeparableFilter2D = images.setDimensionsAsInts( + images.setImageInput( + images.setImageInput( + glSeparableFilter2D, + pixelName = 'row', + typeName = 'type', + ), + pixelName = 'column', + typeName = 'type', + ) +) +glConvolutionFilter1D = images.setDimensionsAsInts( + images.setImageInput( + glConvolutionFilter1D, + pixelName = 'image', + typeName = 'type', + ) +) +glConvolutionFilter2D = images.setDimensionsAsInts( + images.setImageInput( + glConvolutionFilter2D, + pixelName = 'image', + typeName = 'type', + ) +) + +@_lazy( glGetConvolutionFilter ) +def glGetConvolutionFilter( baseFunction, target, format, type ): + """Retrieve 1 or 2D convolution parameter "kernels" as pixel data""" + dims = ( + glGetConvolutionParameteriv( target, GL_CONVOLUTION_WIDTH )[0], + ) + if target != GL_CONVOLUTION_1D: + dims += ( + glGetConvolutionParameteriv( target, GL_CONVOLUTION_HEIGHT )[0], + ) + # is it always 4? Seems to be, but the spec/man-page isn't really clear about it... + dims += (4,) + array = images.images.SetupPixelRead( format, dims, type ) + arrayType = arrays.GL_CONSTANT_TO_ARRAY_TYPE[ + images.images.TYPE_TO_ARRAYTYPE.get(type,type) + ] + baseFunction( + target, format, type, + ctypes.c_void_p( arrayType.dataPointer(array)) + ) + return array +@_lazy( glGetSeparableFilter ) +def glGetSeparableFilter( baseFunction, target, format, type ): + """Retrieve 2 1D convolution parameter "kernels" as pixel data""" + rowDims = ( + glGetConvolutionParameteriv( GL_CONVOLUTION_WIDTH )[0], + 4, + ) + columnDims = ( + glGetConvolutionParameteriv( GL_CONVOLUTION_HEIGHT )[0], + 4, + ) + arrayType = arrays.GL_CONSTANT_TO_ARRAY_TYPE[ + images.images.TYPE_TO_ARRAYTYPE.get(type,type) + ] + row = images.images.SetupPixelRead( format, rowDims, type ) + column = images.images.SetupPixelRead( format, columnDims, type ) + baseFunction( + target, format, type, + ctypes.c_void_p( arrayType.dataPointer(row)), + ctypes.c_void_p( arrayType.dataPointer(column)), + None # span + ) + return row, column +@_lazy( glGetColorTable ) +def glGetColorTable( baseFunction, target, format, type ): + """Retrieve the current 1D color table as a bitmap""" + dims = ( + glGetColorTableParameteriv(target, GL_COLOR_TABLE_WIDTH), + 4, # Grr, spec *seems* to say that it's different sizes, but it doesn't really say... + ) + array = images.images.SetupPixelRead( format, dims, type ) + arrayType = arrays.GL_CONSTANT_TO_ARRAY_TYPE[ + images.images.TYPE_TO_ARRAYTYPE.get(type,type) + ] + baseFunction( + target, format, type, + ctypes.c_void_p( arrayType.dataPointer(array)) + ) + return array +@_lazy( glGetHistogram ) +def glGetHistogram( baseFunction, target, reset, format, type, values=None): + """Retrieve current 1D histogram as a 1D bitmap""" + if values is None: + width = glGetHistogramParameteriv( + target, + GL_HISTOGRAM_WIDTH, + ) + values = images.images.SetupPixelRead( format, (width,4), type ) + arrayType = arrays.GL_CONSTANT_TO_ARRAY_TYPE[ + images.images.TYPE_TO_ARRAYTYPE.get(type,type) + ] + baseFunction( + target, reset, format, type, + ctypes.c_void_p( arrayType.dataPointer(values)) + ) + return values + +@_lazy( glGetMinmax ) +def glGetMinmax( baseFunction, target, reset, format, type, values=None): + """Retrieve minimum and maximum values as a 2-element image""" + if values is None: + width = 2 + values = images.images.SetupPixelRead( format, (width,4), type ) + arrayType = arrays.GL_CONSTANT_TO_ARRAY_TYPE[ + images.images.TYPE_TO_ARRAYTYPE.get(type,type) + ] + baseFunction( + target, reset, format, type, + ctypes.c_void_p( arrayType.dataPointer(values)) + ) + return values diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/indirect_parameters.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/indirect_parameters.py new file mode 100644 index 00000000..0cee9714 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/indirect_parameters.py @@ -0,0 +1,46 @@ +'''OpenGL extension ARB.indirect_parameters + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.indirect_parameters to provide a more +Python-friendly API + +Overview (from the spec) + + OpenGL 4.3 (with the introduction of the GL_ARB_multi_draw_indirect + extension) enhanced the ability of OpenGL to allow a large sets of + parameters for indirect draws (introduced with OpenGL 4.0) into a buffer + object and dispatch the entire list with one API call. This allows, for + example, a shader (such as a compute shader via shader storage buffers, + or a geometry shader via transform feedback) to produce lists of draw + commands that can then be consumed by OpenGL without a server-client + round trip. However, when a variable and potentially unknown number of + draws are produced by such a shader, it becomes difficult to know how + many draws are in the output array(s). Applications must resort to + techniques such as transform feedback primitive queries, or mapping + buffers containing the content of atomic counters, which can cause stalls + or bubbles in the OpenGL pipeline. + + This extension introduces the concept of the "parameter buffer", which + is a target allowing buffers to store parameters for certain drawing + commands. Also in this extension, new variants of MultiDrawArraysIndirect + and MultiDrawElementsIndirect are introduced that source some of their + parameters from this buffer. Further commands could potentially be + introduced that source other parameters from a buffer. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/indirect_parameters.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.indirect_parameters import * +from OpenGL.raw.GL.ARB.indirect_parameters import _EXTENSION_NAME + +def glInitIndirectParametersARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/instanced_arrays.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/instanced_arrays.py new file mode 100644 index 00000000..4edfd7cb --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/instanced_arrays.py @@ -0,0 +1,52 @@ +'''OpenGL extension ARB.instanced_arrays + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.instanced_arrays to provide a more +Python-friendly API + +Overview (from the spec) + + A common use case in GL for some applications is to be able to + draw the same object, or groups of similar objects that share + vertex data, primitive count and type, multiple times. This + extension provides a means of accelerating such use cases while + restricting the number of API calls, and keeping the amount of + duplicate data to a minimum. + + In particular, this extension specifies an alternative to the + read-only shader variable introduced by ARB_draw_instanced. It + uses the same draw calls introduced by that extension, but + redefines them so that a vertex shader can instead use vertex + array attributes as a source of instance data. + + This extension introduces an array "divisor" for generic + vertex array attributes, which when non-zero specifies that the + attribute is "instanced." An instanced attribute does not + advance per-vertex as usual, but rather after every + conceptual draw calls. + + (Attributes which aren't instanced are repeated in their entirety + for every conceptual draw call.) + + By specifying transform data in an instanced attribute or series + of instanced attributes, vertex shaders can, in concert with the + instancing draw calls, draw multiple instances of an object with + one draw call. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/instanced_arrays.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.instanced_arrays import * +from OpenGL.raw.GL.ARB.instanced_arrays import _EXTENSION_NAME + +def glInitInstancedArraysARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/internalformat_query.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/internalformat_query.py new file mode 100644 index 00000000..f7b4cb40 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/internalformat_query.py @@ -0,0 +1,39 @@ +'''OpenGL extension ARB.internalformat_query + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.internalformat_query to provide a more +Python-friendly API + +Overview (from the spec) + + OpenGL 4.1 has a number of queries to indicate the maximum number of + samples available for different formats. These give a coarse-grained + query mechanism e.g. an implementation can expose different sample + counts for integer and floating-point formats, but not for different + floating-point formats. There is also no convenient way for the user + to determine the granularity of sample counts available, only the + maximum. + + This extension adds a query mechanism that allows the user to + determine which sample counts are available for a specific internal + format. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/internalformat_query.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.internalformat_query import * +from OpenGL.raw.GL.ARB.internalformat_query import _EXTENSION_NAME + +def glInitInternalformatQueryARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +glGetInternalformativ=wrapper.wrapper(glGetInternalformativ).setOutput( + 'params',size=lambda x:(x,),pnameArg='bufSize',orPassIn=True +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/internalformat_query2.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/internalformat_query2.py new file mode 100644 index 00000000..2b6f3803 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/internalformat_query2.py @@ -0,0 +1,73 @@ +'''OpenGL extension ARB.internalformat_query2 + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.internalformat_query2 to provide a more +Python-friendly API + +Overview (from the spec) + + This extension extends the GetInternalformativ query that was added in + the ARB_internalformat_query extension to provide applications with more + granular per-format capability information. + + This extension allows the remainder of the texture-style targets to + be specified along with any possible internal format. + We add queries for additional properties supported for an internal + format in addition to the multisample-related information that was + added in ARB_internalformat_query. + + The goals of this extension are to: + + a) provide a mechanism for implementations to declare support *above* the + minimum required by the specification + + b) provide API to allow universally constant information to be queried + + c) provide a user-friendly way of finding out about version- or + implementation-specific limitations. + + While much of this information can be determined for a single GL version + by careful examination of the specification, support for many of these + properties has been gradually introduced over a number of API + revisions. This can observed when considering the range in functionality + between the various versions of GL 2, 3, and 4, as well as GL ES 2 and 3. + + In the case of an application which wishes to be scalable and able to run + on a variety of possible GL or GL ES versions without being specifically + tailored for each version, it must either have knowledge of the + specifications built up into either the code or tables, or it must do + a number of tests on startup to determine which capabilities are present. + + In OpenGL, other than the course-grained extension mechanism, many + limitations of, or limited support for, an internalformat can only + be signaled by failing an operation or by operating at reduced + performance. Thus, such tests often involve attempts to create resources, + using them in specific ways and benchmarking the operations to + find out if it is supported in the desired form, and at a required + performance level. The extension provides a way for these properties + and caveats to be directly queried from the implementation. + + This extension is NOT intended to allow implementations to only support + a subset of features that are required by a specific GL version, nor is + it intended to replace the proper use of extension checks for optional + functionality. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/internalformat_query2.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.internalformat_query2 import * +from OpenGL.raw.GL.ARB.internalformat_query2 import _EXTENSION_NAME + +def glInitInternalformatQuery2ARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +glGetInternalformati64v=wrapper.wrapper(glGetInternalformati64v).setOutput( + 'params',size=lambda x:(x,),pnameArg='bufSize',orPassIn=True +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/invalidate_subdata.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/invalidate_subdata.py new file mode 100644 index 00000000..cf0bbbdd --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/invalidate_subdata.py @@ -0,0 +1,75 @@ +'''OpenGL extension ARB.invalidate_subdata + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.invalidate_subdata to provide a more +Python-friendly API + +Overview (from the spec) + + This extension adds a mechanism for an application to tell the GL that + the previous contents of a subregion of an image or a range of a buffer + may be invalidated. + + GL implementations often include several memory spaces, each with + distinct performance characteristics, and the implementations + transparently move allocations between memory spaces. With this + extension, an application can tell the GL that the contents of a texture + or buffer are no longer needed, and the implementation can avoid + transferring the data unnecessarily. + + Examples of when this may be useful include: + + (1) invalidating a multisample texture after resolving it into a non- + multisample texture. + + (2) invalidating depth/stencil buffers after using them to generate a color + buffer. + + (3) invalidating a subregion of a framebuffer rather than clearing it + before rendering to it, when the whole subregion will be overwritten. + + (4) invalidating dynamically generated data (e.g. textures written by FBO + rendering or CopyTexSubImage, buffers written by transform feedback, + etc.) after it is no longer needed but before the end of the frame. + + It is expected that the situations in which the GL will take advantage of + this knowledge and achieve increased performance as a result of its use + will be implementation-dependent. The first three examples may show + benefit on tiled renderers where some data won't need to be copied into + or out of on-chip memory. The fourth example may show a benefit in multi- + GPU systems where some data won't need to be copied between GPUs. + + This extension is a superset of the EXT_discard_framebuffer extension + with the following additions: + + - The parameters to InvalidateFramebufferEXT are extended for MRT support + and Desktop-GL-only buffer enums. + + - New functions to invalidate a region of a texture image or buffer object + data store. + + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/invalidate_subdata.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.invalidate_subdata import * +from OpenGL.raw.GL.ARB.invalidate_subdata import _EXTENSION_NAME + +def glInitInvalidateSubdataARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glInvalidateFramebuffer.attachments size not checked against numAttachments +glInvalidateFramebuffer=wrapper.wrapper(glInvalidateFramebuffer).setInputArraySize( + 'attachments', None +) +# INPUT glInvalidateSubFramebuffer.attachments size not checked against numAttachments +glInvalidateSubFramebuffer=wrapper.wrapper(glInvalidateSubFramebuffer).setInputArraySize( + 'attachments', None +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/map_buffer_alignment.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/map_buffer_alignment.py new file mode 100644 index 00000000..1affe26f --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/map_buffer_alignment.py @@ -0,0 +1,30 @@ +'''OpenGL extension ARB.map_buffer_alignment + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.map_buffer_alignment to provide a more +Python-friendly API + +Overview (from the spec) + + This extension adds a requirement to the pointer returned by MapBuffer + and MapBufferRange that they provide a minimum of 64 byte alignment to + support processing of the data directly with special CPU instructions + like SSE and AVX. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/map_buffer_alignment.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.map_buffer_alignment import * +from OpenGL.raw.GL.ARB.map_buffer_alignment import _EXTENSION_NAME + +def glInitMapBufferAlignmentARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/map_buffer_range.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/map_buffer_range.py new file mode 100644 index 00000000..3301db5a --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/map_buffer_range.py @@ -0,0 +1,50 @@ +'''OpenGL extension ARB.map_buffer_range + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.map_buffer_range to provide a more +Python-friendly API + +Overview (from the spec) + + ARB_map_buffer_range expands the buffer object API to allow greater + performance when a client application only needs to write to a sub-range + of a buffer object. To that end, this extension introduces two new buffer + object features: non-serialized buffer modification and explicit sub-range + flushing for mapped buffer objects. + + OpenGL requires that commands occur in a FIFO manner meaning that any + changes to buffer objects either block until the data has been processed by + the OpenGL pipeline or else create extra copies to avoid such a block. By + providing a method to asynchronously modify buffer object data, an + application is then able to manage the synchronization points themselves + and modify ranges of data contained by a buffer object even though OpenGL + might still be using other parts of it. + + This extension also provides a method for explicitly flushing ranges of a + mapped buffer object so OpenGL does not have to assume that the entire + range may have been modified. Further, it allows the application to more + precisely specify its intent with respect to reading, writing, and whether + the previous contents of a mapped range of interest need be preserved + prior to modification. + + Affects ARB_vertex_buffer_object, ARB_pixel_buffer_object and OpenGL 1.5 + Buffer Objects. + + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/map_buffer_range.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.map_buffer_range import * +from OpenGL.raw.GL.ARB.map_buffer_range import _EXTENSION_NAME + +def glInitMapBufferRangeARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/matrix_palette.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/matrix_palette.py new file mode 100644 index 00000000..1adabca1 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/matrix_palette.py @@ -0,0 +1,57 @@ +'''OpenGL extension ARB.matrix_palette + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.matrix_palette to provide a more +Python-friendly API + +Overview (from the spec) + + This extension extends the abilities of ARB_vertex_blend to include + a palette of modelview matrices. The n vertex units use a palette + of m modelview matrices. (Where n and m are constrained to + implementation defined maxima.) Each vertex has a set of n + indices into the palette, and a corresponding set of n weights. + Matrix indices can be changed for each vertex (between Begin and + End). + + When this extension is utilized, the enabled units transform each + vertex by the modelview matrices specified by the vertices' + respective indices. These results are subsequently scaled by the + weights of the respective units and then summed to create the + eyespace vertex. + + A similar procedure is followed for normals. Normals, however, + are transformed by the inverse transpose of the modelview matrix. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/matrix_palette.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.matrix_palette import * +from OpenGL.raw.GL.ARB.matrix_palette import _EXTENSION_NAME + +def glInitMatrixPaletteARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glMatrixIndexubvARB.indices size not checked against size +glMatrixIndexubvARB=wrapper.wrapper(glMatrixIndexubvARB).setInputArraySize( + 'indices', None +) +# INPUT glMatrixIndexusvARB.indices size not checked against size +glMatrixIndexusvARB=wrapper.wrapper(glMatrixIndexusvARB).setInputArraySize( + 'indices', None +) +# INPUT glMatrixIndexuivARB.indices size not checked against size +glMatrixIndexuivARB=wrapper.wrapper(glMatrixIndexuivARB).setInputArraySize( + 'indices', None +) +# INPUT glMatrixIndexPointerARB.pointer size not checked against 'size,type,stride' +glMatrixIndexPointerARB=wrapper.wrapper(glMatrixIndexPointerARB).setInputArraySize( + 'pointer', None +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/multi_bind.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/multi_bind.py new file mode 100644 index 00000000..1abbec56 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/multi_bind.py @@ -0,0 +1,85 @@ +'''OpenGL extension ARB.multi_bind + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.multi_bind to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides a new set of commands allowing applications to + bind or unbind a set of objects in a single call, instead of requiring a + separate call for each bind or unbind operation. Using a single command + allows OpenGL implementations to amortize function call, name space + lookup, and potential locking overhead over multiple bind or unbind + operations. The rendering loops of graphics applications frequently + switch between different states, binding different sets of resources, + including texture objects, sampler objects, textures for image loads and + stores, uniform buffers, and vertex buffers; this extension provides + "multi-bind" entry points for all of these object types. + + Each command in this extension includes a and parameter, + specifying a continguous range of binding points to update, as well as an + array of object names specifying the objects to bind. Unlike + single bind commands, multi-bind commands can be used only to bind or + unbind existing objects. Passing a previously unused object name + (generated or not) results in an error and does not create a new object. + For binding points with associated data (e.g., ranges of a buffer), + separate arrays are used to pass the associated data for each binding + point. Passing zero values in the array of object names removes the + object bound to the current bounding point. Additionally, if NULL is + passed as the array of objects, objects bound to the entire range of + binding points are unbound, as though the caller passed an array of + zeroes. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/multi_bind.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.multi_bind import * +from OpenGL.raw.GL.ARB.multi_bind import _EXTENSION_NAME + +def glInitMultiBindARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glBindBuffersBase.buffers size not checked against count +glBindBuffersBase=wrapper.wrapper(glBindBuffersBase).setInputArraySize( + 'buffers', None +) +# INPUT glBindBuffersRange.buffers size not checked against count +# INPUT glBindBuffersRange.offsets size not checked against count +# INPUT glBindBuffersRange.sizes size not checked against count +glBindBuffersRange=wrapper.wrapper(glBindBuffersRange).setInputArraySize( + 'buffers', None +).setInputArraySize( + 'offsets', None +).setInputArraySize( + 'sizes', None +) +# INPUT glBindTextures.textures size not checked against count +glBindTextures=wrapper.wrapper(glBindTextures).setInputArraySize( + 'textures', None +) +# INPUT glBindSamplers.samplers size not checked against count +glBindSamplers=wrapper.wrapper(glBindSamplers).setInputArraySize( + 'samplers', None +) +# INPUT glBindImageTextures.textures size not checked against count +glBindImageTextures=wrapper.wrapper(glBindImageTextures).setInputArraySize( + 'textures', None +) +# INPUT glBindVertexBuffers.buffers size not checked against count +# INPUT glBindVertexBuffers.offsets size not checked against count +# INPUT glBindVertexBuffers.strides size not checked against count +glBindVertexBuffers=wrapper.wrapper(glBindVertexBuffers).setInputArraySize( + 'buffers', None +).setInputArraySize( + 'offsets', None +).setInputArraySize( + 'strides', None +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/multi_draw_indirect.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/multi_draw_indirect.py new file mode 100644 index 00000000..b98355e9 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/multi_draw_indirect.py @@ -0,0 +1,44 @@ +'''OpenGL extension ARB.multi_draw_indirect + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.multi_draw_indirect to provide a more +Python-friendly API + +Overview (from the spec) + + The ARB_draw_indirect extension (included in OpenGL 4.0) introduced + mechanisms whereby the parameters for a draw function may be provided in + a structure contained in a buffer object rather than as parameters to the + drawing procedure. This is known as an indirect draw and is exposed as two + new functions, glDrawArraysIndirect and glDrawElementsIndirect. Each of + these functions generates a single batch of primitives. + + This extension builds on this functionality by providing procedures to + invoke multiple draws from a single procedure call. This allows large + batches of drawing commands to be assembled in server memory (via a buffer + object) which may then be dispatched through a single function call. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/multi_draw_indirect.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.multi_draw_indirect import * +from OpenGL.raw.GL.ARB.multi_draw_indirect import _EXTENSION_NAME + +def glInitMultiDrawIndirectARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glMultiDrawArraysIndirect.indirect size not checked against 'drawcount,stride' +glMultiDrawArraysIndirect=wrapper.wrapper(glMultiDrawArraysIndirect).setInputArraySize( + 'indirect', None +) +# INPUT glMultiDrawElementsIndirect.indirect size not checked against 'drawcount,stride' +glMultiDrawElementsIndirect=wrapper.wrapper(glMultiDrawElementsIndirect).setInputArraySize( + 'indirect', None +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/multisample.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/multisample.py new file mode 100644 index 00000000..60ea1871 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/multisample.py @@ -0,0 +1,51 @@ +'''OpenGL extension ARB.multisample + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.multisample to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides a mechanism to antialias all GL primitives: + points, lines, polygons, bitmaps, and images. The technique is to + sample all primitives multiple times at each pixel. The color + sample values are resolved to a single, displayable color each time + a pixel is updated, so the antialiasing appears to be automatic at + the application level. Because each sample includes depth and + stencil information, the depth and stencil functions perform + equivalently to the single-sample mode. + + An additional buffer, called the multisample buffer, is added to + the framebuffer. Pixel sample values, including color, depth, and + stencil values, are stored in this buffer. When the framebuffer + includes a multisample buffer, it does not also include separate + depth or stencil buffers, even if the multisample buffer does not + store depth or stencil values. Color buffers (left/right, front/ + back, and aux) do coexist with the multisample buffer, however. + + Multisample antialiasing is most valuable for rendering polygons, + because it requires no sorting for hidden surface elimination, and + it correctly handles adjacent polygons, object silhouettes, and + even intersecting polygons. If only points or lines are being + rendered, the "smooth" antialiasing mechanism provided by the base + GL may result in a higher quality image. This extension is + designed to allow multisample and smooth antialiasing techniques + to be alternated during the rendering of a single scene. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/multisample.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.multisample import * +from OpenGL.raw.GL.ARB.multisample import _EXTENSION_NAME + +def glInitMultisampleARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/multitexture.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/multitexture.py new file mode 100644 index 00000000..e289e22c --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/multitexture.py @@ -0,0 +1,70 @@ +'''OpenGL extension ARB.multitexture + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.multitexture to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/multitexture.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.multitexture import * +from OpenGL.raw.GL.ARB.multitexture import _EXTENSION_NAME + +def glInitMultitextureARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +glMultiTexCoord1dvARB=wrapper.wrapper(glMultiTexCoord1dvARB).setInputArraySize( + 'v', 1 +) +glMultiTexCoord1fvARB=wrapper.wrapper(glMultiTexCoord1fvARB).setInputArraySize( + 'v', 1 +) +glMultiTexCoord1ivARB=wrapper.wrapper(glMultiTexCoord1ivARB).setInputArraySize( + 'v', 1 +) +glMultiTexCoord1svARB=wrapper.wrapper(glMultiTexCoord1svARB).setInputArraySize( + 'v', 1 +) +glMultiTexCoord2dvARB=wrapper.wrapper(glMultiTexCoord2dvARB).setInputArraySize( + 'v', 2 +) +glMultiTexCoord2fvARB=wrapper.wrapper(glMultiTexCoord2fvARB).setInputArraySize( + 'v', 2 +) +glMultiTexCoord2ivARB=wrapper.wrapper(glMultiTexCoord2ivARB).setInputArraySize( + 'v', 2 +) +glMultiTexCoord2svARB=wrapper.wrapper(glMultiTexCoord2svARB).setInputArraySize( + 'v', 2 +) +glMultiTexCoord3dvARB=wrapper.wrapper(glMultiTexCoord3dvARB).setInputArraySize( + 'v', 3 +) +glMultiTexCoord3fvARB=wrapper.wrapper(glMultiTexCoord3fvARB).setInputArraySize( + 'v', 3 +) +glMultiTexCoord3ivARB=wrapper.wrapper(glMultiTexCoord3ivARB).setInputArraySize( + 'v', 3 +) +glMultiTexCoord3svARB=wrapper.wrapper(glMultiTexCoord3svARB).setInputArraySize( + 'v', 3 +) +glMultiTexCoord4dvARB=wrapper.wrapper(glMultiTexCoord4dvARB).setInputArraySize( + 'v', 4 +) +glMultiTexCoord4fvARB=wrapper.wrapper(glMultiTexCoord4fvARB).setInputArraySize( + 'v', 4 +) +glMultiTexCoord4ivARB=wrapper.wrapper(glMultiTexCoord4ivARB).setInputArraySize( + 'v', 4 +) +glMultiTexCoord4svARB=wrapper.wrapper(glMultiTexCoord4svARB).setInputArraySize( + 'v', 4 +) +### END AUTOGENERATED SECTION diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/occlusion_query.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/occlusion_query.py new file mode 100644 index 00000000..61452f16 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/occlusion_query.py @@ -0,0 +1,114 @@ +'''OpenGL extension ARB.occlusion_query + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.occlusion_query to provide a more +Python-friendly API + +Overview (from the spec) + + This extension defines a mechanism whereby an application can query + the number of pixels (or, more precisely, samples) drawn by a + primitive or group of primitives. + + The primary purpose of such a query (hereafter referred to as an + "occlusion query") is to determine the visibility of an object. + Typically, the application will render the major occluders in the + scene, then perform an occlusion query for the bounding box of each + detail object in the scene. Only if said bounding box is visible, + i.e., if at least one sample is drawn, should the corresponding object + be drawn. + + The earlier HP_occlusion_test extension defined a similar mechanism, + but it had two major shortcomings. + + - It returned the result as a simple GL_TRUE/GL_FALSE result, when in + fact it is often useful to know exactly how many samples were + drawn. + - It provided only a simple "stop-and-wait" model for using multiple + queries. The application begins an occlusion test and ends it; + then, at some later point, it asks for the result, at which point + the driver must stop and wait until the result from the previous + test is back before the application can even begin the next one. + This is a very simple model, but its performance is mediocre when + an application wishes to perform many queries, and it eliminates + most of the opportunities for parallelism between the CPU and GPU. + + This extension solves both of those problems. It returns as its + result the number of samples that pass the depth and stencil tests, + and it encapsulates occlusion queries in "query objects" that allow + applications to issue many queries before asking for the result of + any one. As a result, they can overlap the time it takes for the + occlusion query results to be returned with other, more useful work, + such as rendering other parts of the scene or performing other + computations on the CPU. + + There are many situations where a pixel/sample count, rather than a + boolean result, is useful. + + - Objects that are visible but cover only a very small number of + pixels can be skipped at a minimal reduction of image quality. + - Knowing exactly how many pixels an object might cover may help the + application decide which level-of-detail model should be used. If + only a few pixels are visible, a low-detail model may be + acceptable. + - "Depth peeling" techniques, such as order-independent transparency, + need to know when to stop rendering more layers; it is difficult to + determine a priori how many layers are needed. A boolean result + allows applications to stop when more layers will not affect the + image at all, but this will likely result in unacceptable + performance. Instead, it makes more sense to stop rendering when + the number of pixels in each layer falls below a given threshold. + - Occlusion queries can replace glReadPixels of the depth buffer to + determine whether (for example) a light source is visible for the + purposes of a lens flare effect or a halo to simulate glare. Pixel + counts allow you to compute the percentage of the light source that + is visible, and the brightness of these effects can be modulated + accordingly. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/occlusion_query.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.occlusion_query import * +from OpenGL.raw.GL.ARB.occlusion_query import _EXTENSION_NAME + +def glInitOcclusionQueryARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +glGenQueriesARB=wrapper.wrapper(glGenQueriesARB).setOutput( + 'ids',size=lambda x:(x,),pnameArg='n',orPassIn=True +) +# INPUT glDeleteQueriesARB.ids size not checked against n +glDeleteQueriesARB=wrapper.wrapper(glDeleteQueriesARB).setInputArraySize( + 'ids', None +) +glGetQueryivARB=wrapper.wrapper(glGetQueryivARB).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetQueryObjectivARB=wrapper.wrapper(glGetQueryObjectivARB).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetQueryObjectuivARB=wrapper.wrapper(glGetQueryObjectuivARB).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +### END AUTOGENERATED SECTION +from OpenGL.lazywrapper import lazy as _lazy + +@_lazy( glDeleteQueriesARB ) +def glDeleteQueriesARB( baseOperation, n, ids=None ): + """Delete the given queries + + n -- either the number of queries to delete, or an array of query values + ids -- if provided, the array/pointer to the queries to delete + """ + if ids is None: + ids = arrays.GLuintArray.asArray( n ) + n = arrays.GLuintArray.arraySize( ids ) + else: + ids = arrays.GLuintArray.asArray( ids ) + return baseOperation( n,ids ) diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/occlusion_query2.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/occlusion_query2.py new file mode 100644 index 00000000..79843b4e --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/occlusion_query2.py @@ -0,0 +1,32 @@ +'''OpenGL extension ARB.occlusion_query2 + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.occlusion_query2 to provide a more +Python-friendly API + +Overview (from the spec) + + This extension trivially adds a boolean occlusion query + to ARB_occlusion_query. + + While the counter-based occlusion query provided by + ARB_occlusion_query is flexible, there is still value + to a simple boolean, which is often sufficient for applications. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/occlusion_query2.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.occlusion_query2 import * +from OpenGL.raw.GL.ARB.occlusion_query2 import _EXTENSION_NAME + +def glInitOcclusionQuery2ARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/parallel_shader_compile.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/parallel_shader_compile.py new file mode 100644 index 00000000..509867ff --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/parallel_shader_compile.py @@ -0,0 +1,32 @@ +'''OpenGL extension ARB.parallel_shader_compile + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.parallel_shader_compile to provide a more +Python-friendly API + +Overview (from the spec) + + Compiling GLSL into implementation-specific code can be a time consuming + process, so a GL implementation may wish to perform the compilation in a + separate CPU thread. This extension provides a mechanism for the application + to provide a hint to limit the number of threads it wants to be used to + compile shaders, as well as a query to determine if the compilation process + is complete. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/parallel_shader_compile.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.parallel_shader_compile import * +from OpenGL.raw.GL.ARB.parallel_shader_compile import _EXTENSION_NAME + +def glInitParallelShaderCompileARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/pipeline_statistics_query.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/pipeline_statistics_query.py new file mode 100644 index 00000000..cbf2c463 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/pipeline_statistics_query.py @@ -0,0 +1,41 @@ +'''OpenGL extension ARB.pipeline_statistics_query + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.pipeline_statistics_query to provide a more +Python-friendly API + +Overview (from the spec) + + This extension introduces new query types that allow applications to get + statistics information about different parts of the pipeline: + + * Number of vertices and primitives issued to the GL; + + * Number of times a vertex shader, tessellation evaluation shader, + geometry shader, fragment shader, and compute shader was invoked; + + * Number of patches processed by the tessellation control shader stage; + + * Number of primitives emitted by a geometry shader; + + * Number of primitives that entered the primitive clipping stage; + + * Number of primitives that are output by the primitive clipping stage; + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/pipeline_statistics_query.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.pipeline_statistics_query import * +from OpenGL.raw.GL.ARB.pipeline_statistics_query import _EXTENSION_NAME + +def glInitPipelineStatisticsQueryARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/pixel_buffer_object.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/pixel_buffer_object.py new file mode 100644 index 00000000..3673020c --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/pixel_buffer_object.py @@ -0,0 +1,89 @@ +'''OpenGL extension ARB.pixel_buffer_object + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.pixel_buffer_object to provide a more +Python-friendly API + +Overview (from the spec) + + This extension expands on the interface provided by the + ARB_vertex_buffer_object extension (and later integrated into OpenGL + 1.5) in order to permit buffer objects to be used not only with vertex + array data, but also with pixel data. The intent is to provide more + acceleration opportunities for OpenGL pixel commands. + + While a single buffer object can be bound for both vertex arrays and + pixel commands, we use the designations vertex buffer object (VBO) + and pixel buffer object (PBO) to indicate their particular usage in + a given situation. + + Recall that buffer objects conceptually are nothing more than arrays + of bytes, just like any chunk of memory. ARB_vertex_buffer_object + allows GL commands to source data from a buffer object by binding the + buffer object to a given target and then overloading a certain set of + GL commands' pointer arguments to refer to offsets inside the buffer, + rather than pointers to user memory. An offset is encoded in a + pointer by adding the offset to a null pointer. + + This extension does not add any new functionality to buffer objects + themselves. It simply adds two new targets to which buffer objects + can be bound: GL_PIXEL_PACK_BUFFER and GL_PIXEL_UNPACK_BUFFER. When a + buffer object is bound to the GL_PIXEL_PACK_BUFFER target, commands + such as glReadPixels pack (write) their data into a buffer object. + When a buffer object is bound to the GL_PIXEL_UNPACK_BUFFER target, + commands such as glDrawPixels and glTexImage2D unpack (read) their + data from a buffer object. + + There are a several approaches to improve graphics performance + with PBOs. Some of the most interesting approaches are: + + - Streaming texture updates: If the application uses + glMapBuffer/glUnmapBuffer to write its data for glTexSubImage into + a buffer object, at least one of the data copies usually required + to download a texture can be eliminated, significantly increasing + texture download performance. + + - Streaming draw pixels: When glDrawPixels sources client memory, + OpenGL says the client memory can be modified immediately after the + glDrawPixels command returns without disturbing the drawn image. + This typically necessitates unpacking and copying the image prior + to glDrawPixels returning. However, when using glDrawPixels with + a pixel pack buffer object, glDrawPixels may return prior to image + unpacking because future modification of the buffer data requires + explicit commands (glMapBuffer, glBufferData, or glBufferSubData). + + - Asynchronous glReadPixels: If an application needs to read back a + number of images and process them with the CPU, the existing GL + interface makes it nearly impossible to pipeline this operation. + The driver will typically send the hardware a readback command + when glReadPixels is called, and then wait for all of the data to + be available before returning control to the application. Then, + the application can either process the data immediately or call + glReadPixels again; in neither case will the readback overlap with + the processing. If the application issues several readbacks + into several buffer objects, however, and then maps each one to + process its data, then the readbacks can proceed in parallel with + the data processing. + + - Render to vertex array: The application can use a fragment + program to render some image into one of its buffers, then read + this image out into a buffer object via glReadPixels. Then, it can + use this buffer object as a source of vertex data. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/pixel_buffer_object.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.pixel_buffer_object import * +from OpenGL.raw.GL.ARB.pixel_buffer_object import _EXTENSION_NAME + +def glInitPixelBufferObjectARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/point_parameters.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/point_parameters.py new file mode 100644 index 00000000..f598460b --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/point_parameters.py @@ -0,0 +1,83 @@ +'''OpenGL extension ARB.point_parameters + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.point_parameters to provide a more +Python-friendly API + +Overview (from the spec) + + This extension supports additional geometric characteristics of + points. It can be used to render particles or tiny light sources, + commonly referred to as "Light points". + + The raster brightness of a point is a function of the point area, + point color, point transparency, and the response of the display's + electron gun and phosphor. The point area and the point transparency + are derived from the point size, currently provided with the + parameter of glPointSize. + + The primary motivation is to allow the size of a point to be + affected by distance attenuation. When distance attenuation has an + effect, the final point size decreases as the distance of the point + from the eye increases. + + The secondary motivation is a mean to control the mapping from the + point size to the raster point area and point transparency. This is + done in order to increase the dynamic range of the raster brightness + of points. In other words, the alpha component of a point may be + decreased (and its transparency increased) as its area shrinks below + a defined threshold. + + This extension defines a derived point size to be closely related to + point brightness. The brightness of a point is given by: + + 1 + dist_atten(d) = ------------------- + a + b * d + c * d^2 + + brightness(Pe) = Brightness * dist_atten(|Pe|) + + where 'Pe' is the point in eye coordinates, and 'Brightness' is some + initial value proportional to the square of the size provided with + PointSize. Here we simplify the raster brightness to be a function + of the rasterized point area and point transparency. + + brightness(Pe) brightness(Pe) >= Threshold_Area + area(Pe) = + Threshold_Area Otherwise + + factor(Pe) = brightness(Pe)/Threshold_Area + + alpha(Pe) = Alpha * factor(Pe) + + where 'Alpha' comes with the point color (possibly modified by + lighting). + + 'Threshold_Area' above is in area units. Thus, it is proportional to + the square of the threshold provided by the programmer through this + extension. + + The new point size derivation method applies to all points, while + the threshold applies to multisample points only. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/point_parameters.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.point_parameters import * +from OpenGL.raw.GL.ARB.point_parameters import _EXTENSION_NAME + +def glInitPointParametersARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glPointParameterfvARB.params size not checked against 'pname' +glPointParameterfvARB=wrapper.wrapper(glPointParameterfvARB).setInputArraySize( + 'params', None +) +### END AUTOGENERATED SECTION + diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/point_sprite.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/point_sprite.py new file mode 100644 index 00000000..15425d32 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/point_sprite.py @@ -0,0 +1,43 @@ +'''OpenGL extension ARB.point_sprite + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.point_sprite to provide a more +Python-friendly API + +Overview (from the spec) + + Applications such as particle systems have tended to use OpenGL quads + rather than points to render their geometry, since they would like + to use a custom-drawn texture for each particle, rather than the + traditional OpenGL round antialiased points, and each fragment in + a point has the same texture coordinates as every other fragment. + + Unfortunately, specifying the geometry for these quads can be + expensive, since it quadruples the amount of geometry required, and + may also require the application to do extra processing to compute + the location of each vertex. + + The purpose of this extension is to allow such applications to use + points rather than quads. When GL_POINT_SPRITE_ARB is enabled, + the state of point antialiasing is ignored. For each texture unit, + the app can then specify whether to replace the existing texture + coordinates with point sprite texture coordinates, which are + interpolated across the point. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/point_sprite.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.point_sprite import * +from OpenGL.raw.GL.ARB.point_sprite import _EXTENSION_NAME + +def glInitPointSpriteARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/polygon_offset_clamp.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/polygon_offset_clamp.py new file mode 100644 index 00000000..eecf4a0e --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/polygon_offset_clamp.py @@ -0,0 +1,35 @@ +'''OpenGL extension ARB.polygon_offset_clamp + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.polygon_offset_clamp to provide a more +Python-friendly API + +Overview (from the spec) + + This extension adds a new parameter to the polygon offset function + that clamps the calculated offset to a minimum or maximum value. + The clamping functionality is useful when polygons are nearly + parallel to the view direction because their high slopes can result + in arbitrarily large polygon offsets. In the particular case of + shadow mapping, the lack of clamping can produce the appearance of + unwanted holes when the shadow casting polygons are offset beyond + the shadow receiving polygons, and this problem can be alleviated by + enforcing a maximum offset value. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/polygon_offset_clamp.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.polygon_offset_clamp import * +from OpenGL.raw.GL.ARB.polygon_offset_clamp import _EXTENSION_NAME + +def glInitPolygonOffsetClampARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/post_depth_coverage.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/post_depth_coverage.py new file mode 100644 index 00000000..8e2454b5 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/post_depth_coverage.py @@ -0,0 +1,34 @@ +'''OpenGL extension ARB.post_depth_coverage + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.post_depth_coverage to provide a more +Python-friendly API + +Overview (from the spec) + + This extension allows the fragment shader to control whether values in + gl_SampleMaskIn[] reflect the coverage after application of the early + depth and stencil tests. This feature can be enabled with the following + layout qualifier in the fragment shader: + + layout(post_depth_coverage) in; + + Use of this feature implicitly enables early fragment tests. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/post_depth_coverage.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.post_depth_coverage import * +from OpenGL.raw.GL.ARB.post_depth_coverage import _EXTENSION_NAME + +def glInitPostDepthCoverageARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/program_interface_query.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/program_interface_query.py new file mode 100644 index 00000000..0a7ba56d --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/program_interface_query.py @@ -0,0 +1,86 @@ +'''OpenGL extension ARB.program_interface_query + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.program_interface_query to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides a single unified set of query commands that can be + used by applications to determine properties of various interfaces and + resources used by program objects to communicate with application code, + fixed-function OpenGL pipeline stages, and other programs. In unextended + OpenGL 4.2, there is a separate set of query commands for each different + type of interface or resource used by the program. These different sets + of queries are structured nearly identically, but the queries for some + interfaces have limited capability (e.g., there is no ability to enumerate + fragment shader outputs). + + With the single set of query commands provided by this extension, a + consistent set of queries is available for all interfaces, and a new + interface can be added without having to introduce a completely new set of + query commands. These queries are intended to provide a superset of the + capabilities provided by similar queries in OpenGL 4.2, and should allow + for the deprecation of the existing queries. + + This extension defines two terms: interfaces and active resources. Each + interface of a program object provides a way for the program to + communicate with application code, fixed-function OpenGL pipeline stages, + and other programs. Examples of interfaces for a program object include + inputs (receiving values from vertex attributes or outputs of other + programs), outputs (sending values to other programs or per-fragment + operations), uniforms (receiving values from API calls), uniform blocks + (receiving values from bound buffer objects), subroutines and subroutine + uniforms (receiving API calls to indicate functions to call during program + execution), and atomic counter buffers (holding values to be manipulated + by atomic counter shader functions). Each interface of a program has a + set of active resources used by the program. For example, the resources + of a program's input interface includes all active input variables used by + the first stage of the program. The resources of a program's uniform + block interface consists of the set of uniform blocks with at least one + member used by any shader in the program. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/program_interface_query.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.program_interface_query import * +from OpenGL.raw.GL.ARB.program_interface_query import _EXTENSION_NAME + +def glInitProgramInterfaceQueryARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +glGetProgramInterfaceiv=wrapper.wrapper(glGetProgramInterfaceiv).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +# INPUT glGetProgramResourceIndex.name size not checked against 'name' +glGetProgramResourceIndex=wrapper.wrapper(glGetProgramResourceIndex).setInputArraySize( + 'name', None +) +glGetProgramResourceName=wrapper.wrapper(glGetProgramResourceName).setOutput( + 'length',size=(1,),orPassIn=True +).setOutput( + 'name',size=lambda x:(x,),pnameArg='bufSize',orPassIn=True +) +# INPUT glGetProgramResourceiv.props size not checked against propCount +glGetProgramResourceiv=wrapper.wrapper(glGetProgramResourceiv).setOutput( + 'length',size=(1,),orPassIn=True +).setOutput( + 'params',size=lambda x:(x,),pnameArg='bufSize',orPassIn=True +).setInputArraySize( + 'props', None +) +# INPUT glGetProgramResourceLocation.name size not checked against 'name' +glGetProgramResourceLocation=wrapper.wrapper(glGetProgramResourceLocation).setInputArraySize( + 'name', None +) +# INPUT glGetProgramResourceLocationIndex.name size not checked against 'name' +glGetProgramResourceLocationIndex=wrapper.wrapper(glGetProgramResourceLocationIndex).setInputArraySize( + 'name', None +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/provoking_vertex.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/provoking_vertex.py new file mode 100644 index 00000000..c9e9d67b --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/provoking_vertex.py @@ -0,0 +1,52 @@ +'''OpenGL extension ARB.provoking_vertex + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.provoking_vertex to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides an alternative provoking vertex convention + for rendering lines, triangles, and (optionally depending on the + implementation) quads. + + The provoking vertex of a primitive is the vertex that determines the + constant primary and secondary colors when flat shading is enabled. + + In OpenGL, the provoking vertex for triangle, quad, line, and + (trivially) point primitives is the last vertex used to assemble + the primitive. The polygon primitive is an exception in OpenGL where + the first vertex of a polygon primitive determines the color of the + polygon, even if actually broken into triangles and/or quads. + + See section 2.14.7 (Flatshading) of the OpenGL 2.1 specification, + particularly Table 2.12 for more details. + + Alternatively the provoking vertex could be the first vertex of + the primitive. Other APIs with flat-shading functionality such + as Reality Lab and Direct3D have adopted the "first vertex of the + primitive" convention to determine the provoking vertex. However, + these APIs lack quads so do not have a defined provoking vertex + convention for quads. + + The motivation for this extension is to allow applications developed + for APIs with a "first vertex of the primitive" provoking vertex to + be easily converted to OpenGL. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/provoking_vertex.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.provoking_vertex import * +from OpenGL.raw.GL.ARB.provoking_vertex import _EXTENSION_NAME + +def glInitProvokingVertexARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/query_buffer_object.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/query_buffer_object.py new file mode 100644 index 00000000..58886a91 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/query_buffer_object.py @@ -0,0 +1,50 @@ +'''OpenGL extension ARB.query_buffer_object + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.query_buffer_object to provide a more +Python-friendly API + +Overview (from the spec) + + Statistics about the operation of the OpenGL pipeline, such as the number + of samples that passed the depth test, the elapsed time between two events + or the number of vertices written by transform feedback can be retrieved + from the GL through query objects. The result of a query object is + acquired by the application through the OpenGL API into a client provided + memory location. Should the result returned by the API be required for use + in a shader, it must be passed back to the GL via a program uniform or + some other mechanism. This requires a round-trip from the GPU to the CPU + and back. + + This extension introduces a mechanism whereby the result of a query object + may be retrieved into a buffer object instead of client memory. This allows + the query rsult to be made available to a shader without a round-trip to + the CPU for example by subsequently using the buffer object as a uniform + buffer, texture buffer or other data store visible to the shader. This + functionality may also be used to place the results of many query objects + into a single, large buffer and then map or otherwise read back the entire + buffer at a later point in time, avoiding a per-query object CPU-GPU + synchronization event. + + The extension allows acquiring the result of any query object type + supported by the GL implementation into a buffer object. The implementation + will determine the most efficient method of copying the query result to the + buffer. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/query_buffer_object.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.query_buffer_object import * +from OpenGL.raw.GL.ARB.query_buffer_object import _EXTENSION_NAME + +def glInitQueryBufferObjectARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/robust_buffer_access_behavior.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/robust_buffer_access_behavior.py new file mode 100644 index 00000000..ef797ef5 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/robust_buffer_access_behavior.py @@ -0,0 +1,35 @@ +'''OpenGL extension ARB.robust_buffer_access_behavior + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.robust_buffer_access_behavior to provide a more +Python-friendly API + +Overview (from the spec) + + This extension specifies the behavior of out-of-bounds buffer and array + accesses. This is an improvement over the existing ARB_robustness + extension which stated that the application should not crash, but + the behavior is otherwise undefined. This extension specifies the access + protection provided by the GL to ensure that out-of-bounds accesses + cannot read from or write to data not owned by the application. All + accesses are contained within the buffer object and program area they + reference. These additional robustness guarantees apply to contexts + created with the CONTEXT_FLAG_ROBUST_ACCESS_BIT_ARB feature enabled. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/robust_buffer_access_behavior.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.robust_buffer_access_behavior import * +from OpenGL.raw.GL.ARB.robust_buffer_access_behavior import _EXTENSION_NAME + +def glInitRobustBufferAccessBehaviorARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/robustness.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/robustness.py new file mode 100644 index 00000000..d1c0ed3b --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/robustness.py @@ -0,0 +1,178 @@ +'''OpenGL extension ARB.robustness + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.robustness to provide a more +Python-friendly API + +Overview (from the spec) + + Several recent trends in how OpenGL integrates into modern computer + systems have created new requirements for robustness and security + for OpenGL rendering contexts. + + Additionally GPU architectures now support hardware fault detection; + for example, video memory supporting ECC (error correcting codes) + and error detection. OpenGL contexts should be capable of recovering + from hardware faults such as uncorrectable memory errors. Along with + recovery from such hardware faults, the recovery mechanism can + also allow recovery from video memory access exceptions and system + software failures. System software failures can be due to device + changes or driver failures. + + Demands for increased software robustness and concerns about malware + exploiting buffer overflows have lead API designers to provide + additional "safe" APIs that bound the amount of data returned by + an API query. For example, the safer "snprintf" or "_snprintf" + routines are prefered over "sprintf". + + The OpenGL API has many such robustness perils. OpenGL queries + return (write) some number of bytes to a buffer indicated by a + pointer parameter. The exact number of bytes written by existing + OpenGL queries is not expressed directly by any specific parameter; + instead the number of bytes returned is a complex function of one + or more query arguments, sometimes context state such as pixel + store modes or the active texture selector, and the current state + of an object (such as a texture level's number of total texels). + By the standards of modern API design, such queries are not "safe". + Making these queries safer involves introducing a new query API with + an additional parameter that specifies the number of bytes in the + buffer and never writing bytes beyond that limit. + + Multi-threaded use of OpenGL contexts in a "share group" allow + sharing of objects such as textures and programs. Such sharing in + conjunction with concurrent OpenGL commands stream execution by two + or more contexts introduces hazards whereby one context can change + objects in ways that can cause buffer overflows for another context's + OpenGL queries. + + The original ARB_vertex_buffer_object extension includes an issue + that explicitly states program termination is allowed when + out-of-bounds vertex buffer object fetches occur. Modern GPUs + capable of DirectX 10 enforce the well-defined behavior of always + returning zero values for indices or non-fixed components in this + case. Older GPUs may require extra checks to enforce well-defined + (and termination free) behavior, but this expense is warranted when + processing potentially untrusted content. + + The intent of this extension is to address some specific robustness + goals: + + * For all existing OpenGL queries, provide additional "safe" APIs + that limit data written to user pointers to a buffer size in + bytes that is an explicit additional parameter of the query. + + * Provide a mechanism for an OpenGL application to learn about + graphics resets that affect the context. When a graphics reset + occurs, the OpenGL context becomes unusable and the application + must create a new context to continue operation. Detecting a + graphics reset happens through an inexpensive query. + + * Provide an enable to guarantee that out-of-bounds buffer object + accesses by the GPU will have deterministic behavior and preclude + application instability or termination due to an incorrect buffer + access. Such accesses include vertex buffer fetches of + attributes and indices, and indexed reads of uniforms or + parameters from buffers. + + In one anticipated usage model, WebGL contexts may make use of these + robust features to grant greater stability when using untrusted code. + WebGL contexts cannot call OpenGL commands directly but rather must + route all OpenGL API calls through the web browser. It is then the + web browser that configures the context, using the commands in this + extension, to enforce safe behavior. In this scenario, the WebGL + content cannot specify or change the use of this extension's features + itself; the web browser enforces this policy. + + There are other well-known robustness issues with the OpenGL API + which this extension does not address. For example, selector-based + OpenGL commands are a well-known source of programming errors. + Code to manipulate texture state may assume the active texture + selector is set appropriately when an intervening function call + obscures a change to the active texture state resulting in + incorrectly updated or queried state. The EXT_direct_state_access + extension introduces selector-free OpenGL commands and queries to + address that particular issue so this extension does not. + + The intent of this extension is NOT to deprecate any existing API + and thereby introduce compatibility issues and coding burdens on + existing code, but rather to provide new APIs to ensure a level of + robustness commensurate with the expectations of modern applications + of OpenGL. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/robustness.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.robustness import * +from OpenGL.raw.GL.ARB.robustness import _EXTENSION_NAME + +def glInitRobustnessARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +glGetnTexImageARB=wrapper.wrapper(glGetnTexImageARB).setOutput( + 'img',size=lambda x:(x,),pnameArg='bufSize',orPassIn=True +) +glReadnPixelsARB=wrapper.wrapper(glReadnPixelsARB).setOutput( + 'data',size=lambda x:(x,),pnameArg='bufSize',orPassIn=True +) +glGetnCompressedTexImageARB=wrapper.wrapper(glGetnCompressedTexImageARB).setOutput( + 'img',size=lambda x:(x,),pnameArg='bufSize',orPassIn=True +) +glGetnUniformfvARB=wrapper.wrapper(glGetnUniformfvARB).setOutput( + 'params',size=lambda x:(x,),pnameArg='bufSize',orPassIn=True +) +glGetnUniformivARB=wrapper.wrapper(glGetnUniformivARB).setOutput( + 'params',size=lambda x:(x,),pnameArg='bufSize',orPassIn=True +) +glGetnUniformuivARB=wrapper.wrapper(glGetnUniformuivARB).setOutput( + 'params',size=lambda x:(x,),pnameArg='bufSize',orPassIn=True +) +glGetnUniformdvARB=wrapper.wrapper(glGetnUniformdvARB).setOutput( + 'params',size=lambda x:(x,),pnameArg='bufSize',orPassIn=True +) +glGetnMapdvARB=wrapper.wrapper(glGetnMapdvARB).setOutput( + 'v',size=lambda x:(x,),pnameArg='bufSize',orPassIn=True +) +glGetnMapfvARB=wrapper.wrapper(glGetnMapfvARB).setOutput( + 'v',size=lambda x:(x,),pnameArg='bufSize',orPassIn=True +) +glGetnMapivARB=wrapper.wrapper(glGetnMapivARB).setOutput( + 'v',size=lambda x:(x,),pnameArg='bufSize',orPassIn=True +) +glGetnPixelMapfvARB=wrapper.wrapper(glGetnPixelMapfvARB).setOutput( + 'values',size=lambda x:(x,),pnameArg='bufSize',orPassIn=True +) +glGetnPixelMapuivARB=wrapper.wrapper(glGetnPixelMapuivARB).setOutput( + 'values',size=lambda x:(x,),pnameArg='bufSize',orPassIn=True +) +glGetnPixelMapusvARB=wrapper.wrapper(glGetnPixelMapusvARB).setOutput( + 'values',size=lambda x:(x,),pnameArg='bufSize',orPassIn=True +) +glGetnPolygonStippleARB=wrapper.wrapper(glGetnPolygonStippleARB).setOutput( + 'pattern',size=lambda x:(x,),pnameArg='bufSize',orPassIn=True +) +glGetnColorTableARB=wrapper.wrapper(glGetnColorTableARB).setOutput( + 'table',size=lambda x:(x,),pnameArg='bufSize',orPassIn=True +) +glGetnConvolutionFilterARB=wrapper.wrapper(glGetnConvolutionFilterARB).setOutput( + 'image',size=lambda x:(x,),pnameArg='bufSize',orPassIn=True +) +glGetnSeparableFilterARB=wrapper.wrapper(glGetnSeparableFilterARB).setOutput( + 'column',size=lambda x:(x,),pnameArg='columnBufSize',orPassIn=True +).setOutput( + 'row',size=lambda x:(x,),pnameArg='rowBufSize',orPassIn=True +).setOutput( + 'span',size=(0,),orPassIn=True +) +glGetnHistogramARB=wrapper.wrapper(glGetnHistogramARB).setOutput( + 'values',size=lambda x:(x,),pnameArg='bufSize',orPassIn=True +) +glGetnMinmaxARB=wrapper.wrapper(glGetnMinmaxARB).setOutput( + 'values',size=lambda x:(x,),pnameArg='bufSize',orPassIn=True +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/robustness_isolation.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/robustness_isolation.py new file mode 100644 index 00000000..ffc34543 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/robustness_isolation.py @@ -0,0 +1,23 @@ +'''OpenGL extension ARB.robustness_isolation + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.robustness_isolation to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/robustness_isolation.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.robustness_isolation import * +from OpenGL.raw.GL.ARB.robustness_isolation import _EXTENSION_NAME + +def glInitRobustnessIsolationARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/sample_locations.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/sample_locations.py new file mode 100644 index 00000000..36c14f55 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/sample_locations.py @@ -0,0 +1,56 @@ +'''OpenGL extension ARB.sample_locations + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.sample_locations to provide a more +Python-friendly API + +Overview (from the spec) + + This extension allows an application to modify the locations of samples + within a pixel used in multisample rasterization. Additionally, it allows + applications to specify different sample locations for each pixel in a + group of adjacent pixels, which may increase antialiasing quality + (particularly if a custom resolve shader is used that takes advantage of + these different locations). + + It is common for implementations to optimize the storage of depth values + by storing values that can be used to reconstruct depth at each sample + location, rather than storing separate depth values for each sample. For + example, the depth values from a single triangle can be represented using + plane equations. When the depth value for a sample is needed, it is + automatically evaluated at the sample location. Modifying the sample + locations causes the reconstruction to no longer evaluate the same depth + values as when the samples were originally generated. This extension + provides a command to "evaluate" and store per-sample depth values using + the currently programmed sample locations, which allows the application to + manage this issue if/when necessary. + + The programmable sample locations are used during rasterization and for + evaluation of depth functions during normal geometric rendering. The + programmable locations are associated with a framebuffer object rather + than an individual depth buffer, so if the depth buffer is used as a + texture the texture sampling may be done at the standard sample + locations. Additionally, commands that do not render geometric primitives + (e.g. ReadPixels, BlitFramebuffer, CopyTexSubImage2D, etc.) may use the + standard sample locations to evaluate depth functions rather than the + programmable locations. If a single depth buffer is used at different + times with different sample locations, the depth functions may be + interpreted using the current sample locations. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/sample_locations.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.sample_locations import * +from OpenGL.raw.GL.ARB.sample_locations import _EXTENSION_NAME + +def glInitSampleLocationsARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/sample_shading.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/sample_shading.py new file mode 100644 index 00000000..fa80b7c8 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/sample_shading.py @@ -0,0 +1,50 @@ +'''OpenGL extension ARB.sample_shading + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.sample_shading to provide a more +Python-friendly API + +Overview (from the spec) + + In standard multisample rendering, an implementation is allowed to + assign the same color and texture coordinate values to each sample, + which then allows the optimization where the shader is only + evaluated once and then distributed to the samples that have been + determined to be covered by the primitive currently being + rasterized. This can cause aliasing where the input color and + texture coordinates are used to generate a result that doesn't + antialias itself, for example with alpha-tested transparency. + + This extension adds the ability to explicitly request that an + implementation use a minimum number of unique set of fragment + computation inputs when multisampling a pixel. Specifying such a + requirement can reduce aliasing that results from evaluating the + fragment computations too few times per pixel. + + This extension adds new global state that controls the minimum + number of samples for which attribute data is independently + interpolated. When enabled, all operations that were traditionally + executed per-fragment operate independently on each sample. + + This also extends the shading language to allow control over the + sample being processed. This includes built-in fragment input + variables identifying the sample number and position being processed + when executing fragment shaders per sample. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/sample_shading.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.sample_shading import * +from OpenGL.raw.GL.ARB.sample_shading import _EXTENSION_NAME + +def glInitSampleShadingARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/sampler_objects.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/sampler_objects.py new file mode 100644 index 00000000..5da9b2ba --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/sampler_objects.py @@ -0,0 +1,86 @@ +'''OpenGL extension ARB.sampler_objects + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.sampler_objects to provide a more +Python-friendly API + +Overview (from the spec) + + In unextended OpenGL textures are considered to be sets of image + data (mip-chains, arrays, cube-map face sets, etc.) and sampling + state (sampling mode, mip-mapping state, coordinate wrapping and + clamping rules, etc.) combined into a single object. It is typical + for an application to use many textures with a limited set of + sampling states that are the same between them. In order to use + textures in this way, an application must generate and configure + many texture names, adding overhead both to applications and to + implementations. Furthermore, should an application wish to sample + from a texture in more than one way (with and without mip-mapping, + for example) it must either modify the state of the texture or + create two textures, each with a copy of the same image data. This + can introduce runtime and memory costs to the application. + + This extension separates sampler state from texture image data. A + new object type is introduced, the sampler (representing generic + sampling parameters). The new sampler objects are represented by a + new named type encapsulating the sampling parameters of a + traditional texture object. Sampler objects may be bound to texture + units to supplant the bound texture's sampling state. A single + sampler may be bound to more than one texture unit simultaneously, + allowing different textures to be accessed with a single set of + shared sampling parameters. Also, by binding different sampler + objects to texture units to which the same texture has been bound, + the same texture image data may be sampled with different sampling + parameters. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/sampler_objects.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.sampler_objects import * +from OpenGL.raw.GL.ARB.sampler_objects import _EXTENSION_NAME + +def glInitSamplerObjectsARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +glGenSamplers=wrapper.wrapper(glGenSamplers).setOutput( + 'samplers',size=lambda x:(x,),pnameArg='count',orPassIn=True +) +# INPUT glDeleteSamplers.samplers size not checked against count +glDeleteSamplers=wrapper.wrapper(glDeleteSamplers).setInputArraySize( + 'samplers', None +) +# INPUT glSamplerParameteriv.param size not checked against 'pname' +glSamplerParameteriv=wrapper.wrapper(glSamplerParameteriv).setInputArraySize( + 'param', None +) +# INPUT glSamplerParameterfv.param size not checked against 'pname' +glSamplerParameterfv=wrapper.wrapper(glSamplerParameterfv).setInputArraySize( + 'param', None +) +# INPUT glSamplerParameterIiv.param size not checked against 'pname' +glSamplerParameterIiv=wrapper.wrapper(glSamplerParameterIiv).setInputArraySize( + 'param', None +) +# INPUT glSamplerParameterIuiv.param size not checked against 'pname' +glSamplerParameterIuiv=wrapper.wrapper(glSamplerParameterIuiv).setInputArraySize( + 'param', None +) +glGetSamplerParameteriv=wrapper.wrapper(glGetSamplerParameteriv).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetSamplerParameterIiv=wrapper.wrapper(glGetSamplerParameterIiv).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetSamplerParameterfv=wrapper.wrapper(glGetSamplerParameterfv).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetSamplerParameterIuiv=wrapper.wrapper(glGetSamplerParameterIuiv).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/seamless_cube_map.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/seamless_cube_map.py new file mode 100644 index 00000000..3ede5671 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/seamless_cube_map.py @@ -0,0 +1,45 @@ +'''OpenGL extension ARB.seamless_cube_map + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.seamless_cube_map to provide a more +Python-friendly API + +Overview (from the spec) + + When sampling from cube map textures, a three-dimensional texture + coordinate is used to select one of the cube map faces and generate + a two dimensional texture coordinate ( s t ), at which a texel is + sampled from the determined face of the cube map texture. Each face + of the texture is treated as an independent two-dimensional texture, + and the generated ( s t ) coordinate is subjected to the same + clamping and wrapping rules as for any other two dimensional texture + fetch. + + Although it is unlikely that the generated ( s t ) coordinate lies + significantly outside the determined cube map face, it is often the + case that the locations of the individual elements required during a + linear sampling do not lie within the determined face, and their + coordinates will therefore be modified by the selected clamping and + wrapping rules. This often has the effect of producing seams or + other discontinuities in the sampled texture. + + This extension allows implementations to take samples from adjacent + cube map faces, providing the ability to create seamless cube maps. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/seamless_cube_map.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.seamless_cube_map import * +from OpenGL.raw.GL.ARB.seamless_cube_map import _EXTENSION_NAME + +def glInitSeamlessCubeMapARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/seamless_cubemap_per_texture.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/seamless_cubemap_per_texture.py new file mode 100644 index 00000000..52faf7c4 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/seamless_cubemap_per_texture.py @@ -0,0 +1,48 @@ +'''OpenGL extension ARB.seamless_cubemap_per_texture + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.seamless_cubemap_per_texture to provide a more +Python-friendly API + +Overview (from the spec) + + In unextended OpenGL, cube maps are treated as sets of six, independent + texture images. Once a face is selected from the set, it is treated exactly + as any other two-dimensional texture would be. When sampling linearly from + the texture, all of the individual texels that would be used to to create + the final, bilinear sample values are taken from the same cube face. The + normal, two-dimensional texture coordinate wrapping modes are honored. + This sometimes causes seams to appear in cube maps. + + ARB_seamless_cube_map (and subsequently, OpenGL 3.2) addresses this issue + by providing a mechanism whereby an implementation could take each of the + taps of a bilinear sample from a different face, spanning face boundaries + and providing seamless filtering from cube map textures. However, in + ARB_seamless_cube_map, this feature was exposed as a global state, + affecting all bound cube map textures. It was not possible to mix seamless + and per-face cube map sampling modes during sampling. Furthermore, if an + application included cube maps that were meant to be sampled seamlessly + and non-seamlessly, it would have to track this state and enable or disable + seamless cube map sampling as needed. + + This extension addresses this issue and provides an orthogonal method for + allowing an implementation to provide a per-texture setting for enabling + seamless sampling from cube maps. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/seamless_cubemap_per_texture.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.seamless_cubemap_per_texture import * +from OpenGL.raw.GL.ARB.seamless_cubemap_per_texture import _EXTENSION_NAME + +def glInitSeamlessCubemapPerTextureARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/separate_shader_objects.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/separate_shader_objects.py new file mode 100644 index 00000000..d7e76416 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/separate_shader_objects.py @@ -0,0 +1,252 @@ +'''OpenGL extension ARB.separate_shader_objects + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.separate_shader_objects to provide a more +Python-friendly API + +Overview (from the spec) + + Conventional GLSL requires multiple shader stages (vertex, + fragment, geometry, tessellation control, and tessellation + evaluation) to be linked into a single monolithic program object to + specify a GLSL shader for each stage. + + While GLSL's monolithic approach has some advantages for + optimizing shaders as a unit that span multiple stages, all + existing GPU hardware supports the more flexible mix-and-match + approach. + + Shaders written for HLSL9, Cg, the prior OpenGL assembly program + extensions, and game console favor a more flexible "mix-and-match" + approach to specifying shaders independently for these different + shader stages. Many developers build their shader content around + the mix-and-match approach where they can use a single vertex shader + with multiple fragment shaders (or vice versa). + + This extension adopts a "mix-and-match" shader stage model for GLSL + allowing multiple different GLSL program objects to be bound at once + each to an individual rendering pipeline stage independently of + other stage bindings. This allows program objects to contain only + the shader stages that best suit the applications needs. + + This extension introduces the program pipeline object that serves as + a container for the program bound to any particular rendering stage. + It can be bound, unbound, and rebound to simply save and restore the + complete shader stage to program object bindings. Like framebuffer + and vertex array objects, program pipeline objects are "container" + objects that are not shared between contexts. + + To bind a program object to a specific shader stage or set of + stages, UseProgramStages is used. The VERTEX_SHADER_BIT, + GEOMETRY_SHADER_BIT, FRAGMENT_SHADER_BIT, TESS_CONTROL_SHADER_BIT, + and TESS_EVALUATION_SHADER_BIT tokens refer to the conventional + vertex, geometry, fragment, tessellation control and tessellation + evaluation stages respectively. ActiveShaderProgram specifies the + program that Uniform* commands will update. + + While ActiveShaderProgram allows the use of conventional Uniform* + commands to update uniform variable values for separable program + objects, this extension provides a preferrable interface in a set + of ProgramUniform* commands that update the same uniform variables + but take a parameter indicating the program object to be updated, + rather than updating the currently active program object. These + commands mirror those introduced in EXT_direct_state_access. + + While glActiveShaderProgram provides a selector for setting and + querying uniform values of a program object, the glProgramUniform* + commands provide a selector-free way to modify uniforms of a GLSL + program object without an explicit bind. This selector-free model + reduces API overhead and provides a cleaner interface for + applications. + + Separate linking creates the possibility that certain output varyings + of a shader may go unread by the subsequent shader inputting varyings. + In this case, the output varyings are simply ignored. It is also + possible input varyings from a shader may not be written as output + varyings of a preceding shader. In this case, the unwritten input + varying values are undefined. + + This extension builds on the proof-of-concept provided by + EXT_separate_shader_objects which demonstrated that separate + shader objects can work for GLSL. EXT_separate_shader_objects + was a response to repeated requests for this functionality from + 3D developers. + + This ARB version addresses several "loose ends" in the prior + EXT extension. In particular, it allows user-defined varyings + with explicitly defined locations or implicitly assigned locations. + + This ARB extension extends the GLSL language's use of layout + qualifiers to provide cross-stage interfacing. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/separate_shader_objects.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.separate_shader_objects import * +from OpenGL.raw.GL.ARB.separate_shader_objects import _EXTENSION_NAME + +def glInitSeparateShaderObjectsARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glCreateShaderProgramv.strings size not checked against count +glCreateShaderProgramv=wrapper.wrapper(glCreateShaderProgramv).setInputArraySize( + 'strings', None +) +# INPUT glDeleteProgramPipelines.pipelines size not checked against n +glDeleteProgramPipelines=wrapper.wrapper(glDeleteProgramPipelines).setInputArraySize( + 'pipelines', None +) +glGenProgramPipelines=wrapper.wrapper(glGenProgramPipelines).setOutput( + 'pipelines',size=lambda x:(x,),pnameArg='n',orPassIn=True +) +glGetProgramPipelineiv=wrapper.wrapper(glGetProgramPipelineiv).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +# INPUT glProgramUniform1iv.value size not checked against count +glProgramUniform1iv=wrapper.wrapper(glProgramUniform1iv).setInputArraySize( + 'value', None +) +# INPUT glProgramUniform1fv.value size not checked against count +glProgramUniform1fv=wrapper.wrapper(glProgramUniform1fv).setInputArraySize( + 'value', None +) +# INPUT glProgramUniform1dv.value size not checked against count +glProgramUniform1dv=wrapper.wrapper(glProgramUniform1dv).setInputArraySize( + 'value', None +) +# INPUT glProgramUniform1uiv.value size not checked against count +glProgramUniform1uiv=wrapper.wrapper(glProgramUniform1uiv).setInputArraySize( + 'value', None +) +# INPUT glProgramUniform2iv.value size not checked against count*2 +glProgramUniform2iv=wrapper.wrapper(glProgramUniform2iv).setInputArraySize( + 'value', None +) +# INPUT glProgramUniform2fv.value size not checked against count*2 +glProgramUniform2fv=wrapper.wrapper(glProgramUniform2fv).setInputArraySize( + 'value', None +) +# INPUT glProgramUniform2dv.value size not checked against count*2 +glProgramUniform2dv=wrapper.wrapper(glProgramUniform2dv).setInputArraySize( + 'value', None +) +# INPUT glProgramUniform2uiv.value size not checked against count*2 +glProgramUniform2uiv=wrapper.wrapper(glProgramUniform2uiv).setInputArraySize( + 'value', None +) +# INPUT glProgramUniform3iv.value size not checked against count*3 +glProgramUniform3iv=wrapper.wrapper(glProgramUniform3iv).setInputArraySize( + 'value', None +) +# INPUT glProgramUniform3fv.value size not checked against count*3 +glProgramUniform3fv=wrapper.wrapper(glProgramUniform3fv).setInputArraySize( + 'value', None +) +# INPUT glProgramUniform3dv.value size not checked against count*3 +glProgramUniform3dv=wrapper.wrapper(glProgramUniform3dv).setInputArraySize( + 'value', None +) +# INPUT glProgramUniform3uiv.value size not checked against count*3 +glProgramUniform3uiv=wrapper.wrapper(glProgramUniform3uiv).setInputArraySize( + 'value', None +) +# INPUT glProgramUniform4iv.value size not checked against count*4 +glProgramUniform4iv=wrapper.wrapper(glProgramUniform4iv).setInputArraySize( + 'value', None +) +# INPUT glProgramUniform4fv.value size not checked against count*4 +glProgramUniform4fv=wrapper.wrapper(glProgramUniform4fv).setInputArraySize( + 'value', None +) +# INPUT glProgramUniform4dv.value size not checked against count*4 +glProgramUniform4dv=wrapper.wrapper(glProgramUniform4dv).setInputArraySize( + 'value', None +) +# INPUT glProgramUniform4uiv.value size not checked against count*4 +glProgramUniform4uiv=wrapper.wrapper(glProgramUniform4uiv).setInputArraySize( + 'value', None +) +# INPUT glProgramUniformMatrix2fv.value size not checked against count*4 +glProgramUniformMatrix2fv=wrapper.wrapper(glProgramUniformMatrix2fv).setInputArraySize( + 'value', None +) +# INPUT glProgramUniformMatrix3fv.value size not checked against count*9 +glProgramUniformMatrix3fv=wrapper.wrapper(glProgramUniformMatrix3fv).setInputArraySize( + 'value', None +) +# INPUT glProgramUniformMatrix4fv.value size not checked against count*16 +glProgramUniformMatrix4fv=wrapper.wrapper(glProgramUniformMatrix4fv).setInputArraySize( + 'value', None +) +# INPUT glProgramUniformMatrix2dv.value size not checked against count*4 +glProgramUniformMatrix2dv=wrapper.wrapper(glProgramUniformMatrix2dv).setInputArraySize( + 'value', None +) +# INPUT glProgramUniformMatrix3dv.value size not checked against count*9 +glProgramUniformMatrix3dv=wrapper.wrapper(glProgramUniformMatrix3dv).setInputArraySize( + 'value', None +) +# INPUT glProgramUniformMatrix4dv.value size not checked against count*16 +glProgramUniformMatrix4dv=wrapper.wrapper(glProgramUniformMatrix4dv).setInputArraySize( + 'value', None +) +# INPUT glProgramUniformMatrix2x3fv.value size not checked against count*6 +glProgramUniformMatrix2x3fv=wrapper.wrapper(glProgramUniformMatrix2x3fv).setInputArraySize( + 'value', None +) +# INPUT glProgramUniformMatrix3x2fv.value size not checked against count*6 +glProgramUniformMatrix3x2fv=wrapper.wrapper(glProgramUniformMatrix3x2fv).setInputArraySize( + 'value', None +) +# INPUT glProgramUniformMatrix2x4fv.value size not checked against count*8 +glProgramUniformMatrix2x4fv=wrapper.wrapper(glProgramUniformMatrix2x4fv).setInputArraySize( + 'value', None +) +# INPUT glProgramUniformMatrix4x2fv.value size not checked against count*8 +glProgramUniformMatrix4x2fv=wrapper.wrapper(glProgramUniformMatrix4x2fv).setInputArraySize( + 'value', None +) +# INPUT glProgramUniformMatrix3x4fv.value size not checked against count*12 +glProgramUniformMatrix3x4fv=wrapper.wrapper(glProgramUniformMatrix3x4fv).setInputArraySize( + 'value', None +) +# INPUT glProgramUniformMatrix4x3fv.value size not checked against count*12 +glProgramUniformMatrix4x3fv=wrapper.wrapper(glProgramUniformMatrix4x3fv).setInputArraySize( + 'value', None +) +# INPUT glProgramUniformMatrix2x3dv.value size not checked against count*6 +glProgramUniformMatrix2x3dv=wrapper.wrapper(glProgramUniformMatrix2x3dv).setInputArraySize( + 'value', None +) +# INPUT glProgramUniformMatrix3x2dv.value size not checked against count*6 +glProgramUniformMatrix3x2dv=wrapper.wrapper(glProgramUniformMatrix3x2dv).setInputArraySize( + 'value', None +) +# INPUT glProgramUniformMatrix2x4dv.value size not checked against count*8 +glProgramUniformMatrix2x4dv=wrapper.wrapper(glProgramUniformMatrix2x4dv).setInputArraySize( + 'value', None +) +# INPUT glProgramUniformMatrix4x2dv.value size not checked against count*8 +glProgramUniformMatrix4x2dv=wrapper.wrapper(glProgramUniformMatrix4x2dv).setInputArraySize( + 'value', None +) +# INPUT glProgramUniformMatrix3x4dv.value size not checked against count*12 +glProgramUniformMatrix3x4dv=wrapper.wrapper(glProgramUniformMatrix3x4dv).setInputArraySize( + 'value', None +) +# INPUT glProgramUniformMatrix4x3dv.value size not checked against count*12 +glProgramUniformMatrix4x3dv=wrapper.wrapper(glProgramUniformMatrix4x3dv).setInputArraySize( + 'value', None +) +glGetProgramPipelineInfoLog=wrapper.wrapper(glGetProgramPipelineInfoLog).setOutput( + 'infoLog',size=lambda x:(x,),pnameArg='bufSize',orPassIn=True +).setOutput( + 'length',size=(1,),orPassIn=True +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/shader_atomic_counter_ops.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/shader_atomic_counter_ops.py new file mode 100644 index 00000000..085a31dc --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/shader_atomic_counter_ops.py @@ -0,0 +1,37 @@ +'''OpenGL extension ARB.shader_atomic_counter_ops + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.shader_atomic_counter_ops to provide a more +Python-friendly API + +Overview (from the spec) + + The ARB_shader_atomic_counters extension introduced atomic counters, but + it limits list of potential operations that can be performed on them to + increment, decrement, and query. This extension extends the list of GLSL + built-in functions that can operate on atomic counters. The list of new + operations include: + + * Addition and subtraction + * Minimum and maximum + * Bitwise operators (AND, OR, XOR, etc.) + * Exchange, and compare and exchange operators + + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/shader_atomic_counter_ops.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.shader_atomic_counter_ops import * +from OpenGL.raw.GL.ARB.shader_atomic_counter_ops import _EXTENSION_NAME + +def glInitShaderAtomicCounterOpsARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/shader_atomic_counters.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/shader_atomic_counters.py new file mode 100644 index 00000000..d67f4406 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/shader_atomic_counters.py @@ -0,0 +1,67 @@ +'''OpenGL extension ARB.shader_atomic_counters + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.shader_atomic_counters to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides a set of atomic counters. + + This extension provides GLSL built-in functions to + query and increment/decrement these atomic counters. + + This enables a shader to write to unique offsets + (append to a buffer object) or read from unique offsets + (consume from a buffer object). + + Opaque handles to atomic counters are declared + at global scope and are qualified with the uniform qualifier. + + Unlike other user-defined uniforms declared at global scope, + they take NO storage from the default partition, they have + NO location, and they may NOT be set with the Uniform* commands. + Atomic counters may also NOT be grouped into uniform blocks. + + Active atomic counters can be discovered by the commands + GetUniformIndices, GetActiveUniformName, GetActiveUniform + and GetActiveUniformsiv. + + Like samplers, the opaque handles of the atomic counters + and are ONLY used in some GLSL built-in functions. + + The atomic counters pointed to by the opaque handles + are bound to buffer binding points and buffer offsets + through the layout qualifiers in the shading language, + or they are implicitly assigned by the compiler. + + Through the OpenGL API, buffer objects may be + bound to these binding points with BindBufferBase + or BindBufferRange. + + The contents of the atomic counters are stored + in the buffer objects. The contents of atomic + counters may be set and queried with buffer object + manipulation functions (e.g. BufferData, + BufferSubData, MapBuffer or MapBufferRange). + + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/shader_atomic_counters.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.shader_atomic_counters import * +from OpenGL.raw.GL.ARB.shader_atomic_counters import _EXTENSION_NAME + +def glInitShaderAtomicCountersARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +glGetActiveAtomicCounterBufferiv=wrapper.wrapper(glGetActiveAtomicCounterBufferiv).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/shader_ballot.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/shader_ballot.py new file mode 100644 index 00000000..a409aaf3 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/shader_ballot.py @@ -0,0 +1,30 @@ +'''OpenGL extension ARB.shader_ballot + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.shader_ballot to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides the ability for a group of invocations which + execute in lockstep to do limited forms of cross-invocation communication + via a group broadcast of a invocation value, or broadcast of a bitarray + representing a predicate value from each invocation in the group. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/shader_ballot.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.shader_ballot import * +from OpenGL.raw.GL.ARB.shader_ballot import _EXTENSION_NAME + +def glInitShaderBallotARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/shader_bit_encoding.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/shader_bit_encoding.py new file mode 100644 index 00000000..21b02ef6 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/shader_bit_encoding.py @@ -0,0 +1,31 @@ +'''OpenGL extension ARB.shader_bit_encoding + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.shader_bit_encoding to provide a more +Python-friendly API + +Overview (from the spec) + + This extension trivially adds built-in functions for getting/setting + the bit encoding for floating-point values in the OpenGL Shading Language. + + These functions are pulled out of ARB_gpu_shader5, since support for such + built-in functions exists in current hardware. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/shader_bit_encoding.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.shader_bit_encoding import * +from OpenGL.raw.GL.ARB.shader_bit_encoding import _EXTENSION_NAME + +def glInitShaderBitEncodingARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/shader_clock.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/shader_clock.py new file mode 100644 index 00000000..2ef007f9 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/shader_clock.py @@ -0,0 +1,29 @@ +'''OpenGL extension ARB.shader_clock + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.shader_clock to provide a more +Python-friendly API + +Overview (from the spec) + + This extension exposes a 64-bit monotonically incrementing shader + counter which may be used to derive local timing information within + a single shader invocation. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/shader_clock.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.shader_clock import * +from OpenGL.raw.GL.ARB.shader_clock import _EXTENSION_NAME + +def glInitShaderClockARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/shader_draw_parameters.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/shader_draw_parameters.py new file mode 100644 index 00000000..b098d67e --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/shader_draw_parameters.py @@ -0,0 +1,50 @@ +'''OpenGL extension ARB.shader_draw_parameters + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.shader_draw_parameters to provide a more +Python-friendly API + +Overview (from the spec) + + In unextended GL, vertex shaders have inputs named gl_VertexID and + gl_InstanceID, which contain, respectively the index of the vertex and + instance. The value of gl_VertexID is the implicitly passed index of the + vertex being processed, which includes the value of baseVertex, for those + commands that accept it. Meanwhile, gl_InstanceID is the integer index + of the current instance being processed, but, even for commands that + accept a baseInstance parameter, it does not include the value of this + argument. Furthermore, the equivalents to these variables in other + graphics APIs do not necessarily follow these conventions. The reason for + this inconsistency is that there are legitimate use cases for both + inclusion and exclusion of the baseVertex or baseInstance parameters + in gl_VertexID and gl_InstanceID, respectively. + + Rather than change the semantics of either built-in variable, this + extension adds two new built-in variables to the GL shading language, + gl_BaseVertexARB and gl_BaseInstanceARB, which contain the values passed + in the baseVertex and baseInstance parameters, respectively. Shaders + provided by the application may use these variables to offset gl_VertexID + or gl_InstanceID if desired, or use them for any other purpose. + + Additionally, this extension adds a further built-in variable, gl_DrawID + to the shading language. This variable contains the index of the draw + currently being processed by a Multi* variant of a drawing command (such + as MultiDrawElements or MultiDrawArraysIndirect). + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/shader_draw_parameters.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.shader_draw_parameters import * +from OpenGL.raw.GL.ARB.shader_draw_parameters import _EXTENSION_NAME + +def glInitShaderDrawParametersARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/shader_group_vote.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/shader_group_vote.py new file mode 100644 index 00000000..f13d4472 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/shader_group_vote.py @@ -0,0 +1,77 @@ +'''OpenGL extension ARB.shader_group_vote + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.shader_group_vote to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides new built-in functions to compute the composite of + a set of boolean conditions across a group of shader invocations. These + composite results may be used to execute shaders more efficiently on a + single-instruction multiple-data (SIMD) processor. The set of shader + invocations across which boolean conditions are evaluated is + implementation-dependent, and this extension provides no guarantee over + how individual shader invocations are assigned to such sets. In + particular, the set of shader invocations has no necessary relationship + with the compute shader workgroup -- a pair of shader invocations + in a single compute shader workgroup may end up in different sets used by + these built-ins. + + Compute shaders operate on an explicitly specified group of threads (a + workgroup), but many implementations of OpenGL 4.3 will even group + non-compute shader invocations and execute them in a SIMD fashion. When + executing code like + + if (condition) { + result = do_fast_path(); + } else { + result = do_general_path(); + } + + where diverges between invocations, a SIMD implementation + might first call do_fast_path() for the invocations where is + true and leave the other invocations dormant. Once do_fast_path() + returns, it might call do_general_path() for invocations where + is false and leave the other invocations dormant. In this case, the + shader executes *both* the fast and the general path and might be better + off just using the general path for all invocations. + + This extension provides the ability to avoid divergent execution by + evaluting a condition across an entire SIMD invocation group using code + like: + + if (allInvocationsARB(condition)) { + result = do_fast_path(); + } else { + result = do_general_path(); + } + + The built-in function allInvocationsARB() will return the same value for + all invocations in the group, so the group will either execute + do_fast_path() or do_general_path(), but never both. For example, shader + code might want to evaluate a complex function iteratively by starting + with an approximation of the result and then refining the approximation. + Some input values may require a small number of iterations to generate an + accurate result (do_fast_path) while others require a larger number + (do_general_path). In another example, shader code might want to evaluate + a complex function (do_general_path) that can be greatly simplified when + assuming a specific value for one of its inputs (do_fast_path). + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/shader_group_vote.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.shader_group_vote import * +from OpenGL.raw.GL.ARB.shader_group_vote import _EXTENSION_NAME + +def glInitShaderGroupVoteARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/shader_image_load_store.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/shader_image_load_store.py new file mode 100644 index 00000000..7d9da4cf --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/shader_image_load_store.py @@ -0,0 +1,68 @@ +'''OpenGL extension ARB.shader_image_load_store + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.shader_image_load_store to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides GLSL built-in functions allowing shaders to load + from, store to, and perform atomic read-modify-write operations to a + single level of a texture object from any shader stage. These built-in + functions are named imageLoad(), imageStore(), and imageAtomic*(), + respectively, and accept integer texel coordinates to identify the texel + accessed. The extension adds the notion of "image units" to the OpenGL + API, to which texture levels are bound for access by the GLSL built-in + functions. To allow shaders to specify the image unit to access, GLSL + provides a new set of data types ("image*") similar to samplers. Each + image variable is assigned an integer value to identify an image unit to + access, which is specified using Uniform*() APIs in a manner similar to + samplers. + + This extension also provides the capability to explicitly enable "early" + per-fragment tests, where operations like depth and stencil testing are + performed prior to fragment shader execution. In unextended OpenGL, + fragment shaders never have any side effects and implementations can + sometimes perform per-fragment tests and discard some fragments prior to + executing the fragment shader. Since this extension allows fragment + shaders to write to texture and buffer object memory using the built-in + image functions, such optimizations could lead to non-deterministic + results. To avoid this, implementations supporting this extension may not + perform such optimizations on shaders having such side effects. However, + enabling early per-fragment tests guarantees that such tests will be + performed prior to fragment shader execution, and ensures that image + stores and atomics will not be performed by fragment shader invocations + where these per-fragment tests fail. + + Finally, this extension provides both a GLSL built-in function and an + OpenGL API function allowing applications some control over the ordering + of image loads, stores, and atomics relative to other OpenGL pipeline + operations accessing the same memory. Because the extension provides the + ability to perform random accesses to texture or buffer object memory, + such accesses are not easily tracked by the OpenGL driver. To avoid the + need for heavy-handed synchronization at the driver level, this extension + requires manual synchronization. The MemoryBarrier() OpenGL API + function allows applications to specify a bitfield indicating the set of + OpenGL API operations to synchronize relative to shader memory access. + The memoryBarrier() GLSL built-in function provides a synchronization + point within a given shader invocation to ensure that all memory accesses + performed prior to the synchronization point complete prior to any started + after the synchronization point. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/shader_image_load_store.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.shader_image_load_store import * +from OpenGL.raw.GL.ARB.shader_image_load_store import _EXTENSION_NAME + +def glInitShaderImageLoadStoreARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/shader_image_size.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/shader_image_size.py new file mode 100644 index 00000000..62b0c1ec --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/shader_image_size.py @@ -0,0 +1,27 @@ +'''OpenGL extension ARB.shader_image_size + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.shader_image_size to provide a more +Python-friendly API + +Overview (from the spec) + This extension provides GLSL built-in functions allowing shaders to query + the size of an image. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/shader_image_size.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.shader_image_size import * +from OpenGL.raw.GL.ARB.shader_image_size import _EXTENSION_NAME + +def glInitShaderImageSizeARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/shader_objects.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/shader_objects.py new file mode 100644 index 00000000..fd6b7a37 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/shader_objects.py @@ -0,0 +1,266 @@ +'''OpenGL extension ARB.shader_objects + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.shader_objects to provide a more +Python-friendly API + +Overview (from the spec) + + This extension adds API calls that are necessary to manage shader + objects and program objects as defined in the OpenGL 2.0 white papers by + 3Dlabs. + + The generation of an executable that runs on one of OpenGL's + programmable units is modeled to that of developing a typical C/C++ + application. There are one or more source files, each of which are + stored by OpenGL in a shader object. Each shader object (source file) + needs to be compiled and attached to a program object. Once all shader + objects are compiled successfully, the program object needs to be linked + to produce an executable. This executable is part of the program object, + and can now be loaded onto the programmable units to make it part of the + current OpenGL state. Both the compile and link stages generate a text + string that can be queried to get more information. This information + could be, but is not limited to, compile errors, link errors, + optimization hints, etc. Values for uniform variables, declared in a + shader, can be set by the application and used to control a shader's + behavior. + + This extension defines functions for creating shader objects and program + objects, for compiling shader objects, for linking program objects, for + attaching shader objects to program objects, and for using a program + object as part of current state. Functions to load uniform values are + also defined. Some house keeping functions, like deleting an object and + querying object state, are also provided. + + Although this extension defines the API for creating shader objects, it + does not define any specific types of shader objects. It is assumed that + this extension will be implemented along with at least one such + additional extension for creating a specific type of OpenGL 2.0 shader + (e.g., the ARB_fragment_shader extension or the ARB_vertex_shader + extension). + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/shader_objects.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.shader_objects import * +from OpenGL.raw.GL.ARB.shader_objects import _EXTENSION_NAME + +def glInitShaderObjectsARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glShaderSourceARB.length size not checked against count +# INPUT glShaderSourceARB.string size not checked against count +glShaderSourceARB=wrapper.wrapper(glShaderSourceARB).setInputArraySize( + 'length', None +).setInputArraySize( + 'string', None +) +# INPUT glUniform1fvARB.value size not checked against count +glUniform1fvARB=wrapper.wrapper(glUniform1fvARB).setInputArraySize( + 'value', None +) +# INPUT glUniform2fvARB.value size not checked against count*2 +glUniform2fvARB=wrapper.wrapper(glUniform2fvARB).setInputArraySize( + 'value', None +) +# INPUT glUniform3fvARB.value size not checked against count*3 +glUniform3fvARB=wrapper.wrapper(glUniform3fvARB).setInputArraySize( + 'value', None +) +# INPUT glUniform4fvARB.value size not checked against count*4 +glUniform4fvARB=wrapper.wrapper(glUniform4fvARB).setInputArraySize( + 'value', None +) +# INPUT glUniform1ivARB.value size not checked against count +glUniform1ivARB=wrapper.wrapper(glUniform1ivARB).setInputArraySize( + 'value', None +) +# INPUT glUniform2ivARB.value size not checked against count*2 +glUniform2ivARB=wrapper.wrapper(glUniform2ivARB).setInputArraySize( + 'value', None +) +# INPUT glUniform3ivARB.value size not checked against count*3 +glUniform3ivARB=wrapper.wrapper(glUniform3ivARB).setInputArraySize( + 'value', None +) +# INPUT glUniform4ivARB.value size not checked against count*4 +glUniform4ivARB=wrapper.wrapper(glUniform4ivARB).setInputArraySize( + 'value', None +) +# INPUT glUniformMatrix2fvARB.value size not checked against count*4 +glUniformMatrix2fvARB=wrapper.wrapper(glUniformMatrix2fvARB).setInputArraySize( + 'value', None +) +# INPUT glUniformMatrix3fvARB.value size not checked against count*9 +glUniformMatrix3fvARB=wrapper.wrapper(glUniformMatrix3fvARB).setInputArraySize( + 'value', None +) +# INPUT glUniformMatrix4fvARB.value size not checked against count*16 +glUniformMatrix4fvARB=wrapper.wrapper(glUniformMatrix4fvARB).setInputArraySize( + 'value', None +) +glGetObjectParameterfvARB=wrapper.wrapper(glGetObjectParameterfvARB).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetObjectParameterivARB=wrapper.wrapper(glGetObjectParameterivARB).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetInfoLogARB=wrapper.wrapper(glGetInfoLogARB).setOutput( + 'infoLog',size=lambda x:(x,),pnameArg='maxLength',orPassIn=True +).setOutput( + 'length',size=(1,),orPassIn=True +) +glGetAttachedObjectsARB=wrapper.wrapper(glGetAttachedObjectsARB).setOutput( + 'count',size=(1,),orPassIn=True +).setOutput( + 'obj',size=lambda x:(x,),pnameArg='maxCount',orPassIn=True +) +glGetActiveUniformARB=wrapper.wrapper(glGetActiveUniformARB).setOutput( + 'length',size=(1,),orPassIn=True +).setOutput( + 'name',size=lambda x:(x,),pnameArg='maxLength',orPassIn=True +).setOutput( + 'size',size=(1,),orPassIn=True +).setOutput( + 'type',size=(1,),orPassIn=True +) +# OUTPUT glGetUniformfvARB.params COMPSIZE(programObj, location) +# OUTPUT glGetUniformivARB.params COMPSIZE(programObj, location) +glGetShaderSourceARB=wrapper.wrapper(glGetShaderSourceARB).setOutput( + 'length',size=(1,),orPassIn=True +).setOutput( + 'source',size=lambda x:(x,),pnameArg='maxLength',orPassIn=True +) +### END AUTOGENERATED SECTION +import OpenGL +from OpenGL._bytes import bytes, _NULL_8_BYTE, as_8_bit +from OpenGL.raw.GL import _errors +from OpenGL.lazywrapper import lazy as _lazy +from OpenGL import converters, error +GL_INFO_LOG_LENGTH_ARB = constant.Constant( 'GL_INFO_LOG_LENGTH_ARB', 0x8B84 ) + +glShaderSourceARB = platform.createExtensionFunction( + 'glShaderSourceARB', dll=platform.PLATFORM.GL, + resultType=None, + argTypes=(_types.GLhandleARB, _types.GLsizei, ctypes.POINTER(ctypes.c_char_p), arrays.GLintArray,), + doc = 'glShaderSourceARB( GLhandleARB(shaderObj), [bytes(string),...] ) -> None', + argNames = ('shaderObj', 'count', 'string', 'length',), + extension = _EXTENSION_NAME, +) +conv = converters.StringLengths( name='string' ) +glShaderSourceARB = wrapper.wrapper( + glShaderSourceARB +).setPyConverter( + 'count' # number of strings +).setPyConverter( + 'length' # lengths of strings +).setPyConverter( + 'string', conv.stringArray +).setCResolver( + 'string', conv.stringArrayForC, +).setCConverter( + 'length', conv, +).setCConverter( + 'count', conv.totalCount, +) +try: + del conv +except NameError as err: + pass + +def _afterCheck( key ): + """Generate an error-checking function for compilation operations""" + def GLSLCheckError( + result, + baseOperation=None, + cArguments=None, + *args + ): + result = _errors._error_checker.glCheckError( result, baseOperation, cArguments, *args ) + status = glGetObjectParameterivARB( + cArguments[0], key + ) + if not status: + raise error.GLError( + result = result, + baseOperation = baseOperation, + cArguments = cArguments, + description= glGetInfoLogARB( cArguments[0] ) + ) + return result + return GLSLCheckError + +if OpenGL.ERROR_CHECKING: + glCompileShaderARB.errcheck = _afterCheck( GL_OBJECT_COMPILE_STATUS_ARB ) +if OpenGL.ERROR_CHECKING: + glLinkProgramARB.errcheck = _afterCheck( GL_OBJECT_LINK_STATUS_ARB ) +## Not sure why, but these give invalid operation :( +##if glValidateProgramARB and OpenGL.ERROR_CHECKING: +## glValidateProgramARB.errcheck = _afterCheck( GL_OBJECT_VALIDATE_STATUS_ARB ) + +@_lazy( glGetInfoLogARB ) +def glGetInfoLogARB( baseOperation, obj ): + """Retrieve the program/shader's error messages as a Python string + + returns string which is '' if no message + """ + length = int(glGetObjectParameterivARB(obj, GL_INFO_LOG_LENGTH_ARB)) + if length > 0: + log = ctypes.create_string_buffer(length) + baseOperation(obj, length, None, log) + return log.value.strip(_NULL_8_BYTE) # null-termination + return '' + +@_lazy( glGetAttachedObjectsARB ) +def glGetAttachedObjectsARB( baseOperation, obj ): + """Retrieve the attached objects as an array of GLhandleARB instances""" + length= glGetObjectParameterivARB( obj, GL_OBJECT_ATTACHED_OBJECTS_ARB ) + if length > 0: + storage = arrays.GLuintArray.zeros( (length,)) + baseOperation( obj, length, None, storage ) + return storage + return arrays.GLuintArray.zeros( (0,)) + +@_lazy( glGetShaderSourceARB ) +def glGetShaderSourceARB( baseOperation, obj ): + """Retrieve the program/shader's source code as a Python string + + returns string which is '' if no source code + """ + length = int(glGetObjectParameterivARB(obj, GL_OBJECT_SHADER_SOURCE_LENGTH_ARB)) + if length > 0: + source = ctypes.create_string_buffer(length) + baseOperation(obj, length, None, source) + return source.value.strip(_NULL_8_BYTE) # null-termination + return '' + +@_lazy( glGetActiveUniformARB ) +def glGetActiveUniformARB(baseOperation,program, index,bufSize=None): + """Retrieve the name, size and type of the uniform of the index in the program""" + max_index = int(glGetObjectParameterivARB( program, GL_OBJECT_ACTIVE_UNIFORMS_ARB )) + if bufSize is None: + bufSize = int(glGetObjectParameterivARB( program, GL_OBJECT_ACTIVE_UNIFORM_MAX_LENGTH_ARB)) + if index < max_index and index >= 0: + length,name,size,type = baseOperation( program, index, bufSize ) + if hasattr(name,'tostring'): + name = name.tostring().rstrip(b'\000') + elif hasattr(name,'value'): + name = name.value + return name,size,type + raise IndexError( 'Index %s out of range 0 to %i' % (index, max_index - 1, ) ) + +@_lazy( glGetUniformLocationARB ) +def glGetUniformLocationARB( baseOperation, program, name ): + """Check that name is a string with a null byte at the end of it""" + if not name: + raise ValueError( """Non-null name required""" ) + name = as_8_bit( name ) + if name[-1] != _NULL_8_BYTE: + name = name + _NULL_8_BYTE + return baseOperation( program, name ) diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/shader_precision.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/shader_precision.py new file mode 100644 index 00000000..3383c2dc --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/shader_precision.py @@ -0,0 +1,32 @@ +'''OpenGL extension ARB.shader_precision + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.shader_precision to provide a more +Python-friendly API + +Overview (from the spec) + + This extension more clearly restricts the precision requirements of + implementations of the GLSL specification. These include precision of + arithmetic operations (operators '+', '/', ...), transcendentals (log, exp, + pow, reciprocal sqrt, ...), when NaNs (not a number) and INFs (infinities) will + be supported and generated, and denorm flushing behavior. Trigonometric + built-ins and some other categories of built-ins are not addressed. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/shader_precision.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.shader_precision import * +from OpenGL.raw.GL.ARB.shader_precision import _EXTENSION_NAME + +def glInitShaderPrecisionARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/shader_stencil_export.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/shader_stencil_export.py new file mode 100644 index 00000000..f14dbfe8 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/shader_stencil_export.py @@ -0,0 +1,37 @@ +'''OpenGL extension ARB.shader_stencil_export + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.shader_stencil_export to provide a more +Python-friendly API + +Overview (from the spec) + + In OpenGL, the stencil test is a powerful mechanism to selectively discard + fragments based on the content of the stencil buffer. However, facilites + to update the content of the stencil buffer are limited to operations such + as incrementing the existing value, or overwriting with a fixed reference + value. + + This extension provides a mechanism whereby a shader may generate the + stencil reference value per invocation. When stencil testing is enabled, + this allows the test to be performed against the value generated in the + shader. When the stencil operation is set to GL_REPLACE, this allows a + value generated in the shader to be written to the stencil buffer directly. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/shader_stencil_export.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.shader_stencil_export import * +from OpenGL.raw.GL.ARB.shader_stencil_export import _EXTENSION_NAME + +def glInitShaderStencilExportARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/shader_storage_buffer_object.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/shader_storage_buffer_object.py new file mode 100644 index 00000000..46d1d8d2 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/shader_storage_buffer_object.py @@ -0,0 +1,62 @@ +'''OpenGL extension ARB.shader_storage_buffer_object + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.shader_storage_buffer_object to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides the ability for OpenGL shaders to perform random + access reads, writes, and atomic memory operations on variables stored in + a buffer object. Application shader code can declare sets of variables + (referred to as "buffer variables") arranged into interface blocks in a + manner similar to that done with uniform blocks in OpenGL 3.1. In both + cases, the values of the variables declared in a given interface block are + taken from a buffer object bound to a binding point associated with the + block. Buffer objects used in this extension are referred to as "shader + storage buffers". + + While the capability provided by this extension is similar to that + provided by OpenGL 3.1 and ARB_uniform_buffer_object, there are several + significant differences. Most importantly, shader code is allowed to + write to shader storage buffers, while uniform buffers are always + read-only. Shader storage buffers have a separate set of binding points, + with different counts and size limits. The maximum usable size for shader + storage buffers is implementation-dependent, but its minimum value is + substantially larger than the minimum for uniform buffers. + + The ability to write to buffer objects creates the potential for multiple + independent shader invocations to read and write the same underlying + memory. The same issue exists with the ARB_shader_image_load_store + extension provided in OpenGL 4.2, which can write to texture objects and + buffers. In both cases, the specification makes few guarantees related to + the relative order of memory reads and writes performed by the shader + invocations. For ARB_shader_image_load_store, the OpenGL API and shading + language do provide some control over memory transactions; those + mechanisms also affect reads and writes of shader storage buffers. In the + OpenGL API, the glMemoryBarrier() call can be used to ensure that certain + memory operations related to commands issued prior the barrier complete + before other operations related to commands issued after the barrier. + Additionally, the shading language provides the memoryBarrier() function + to control the relative order of memory accesses within individual shader + invocations and provides various memory qualifiers controlling how the + memory corresponding to individual variables is accessed. + + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/shader_storage_buffer_object.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.shader_storage_buffer_object import * +from OpenGL.raw.GL.ARB.shader_storage_buffer_object import _EXTENSION_NAME + +def glInitShaderStorageBufferObjectARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/shader_subroutine.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/shader_subroutine.py new file mode 100644 index 00000000..de0a5f4d --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/shader_subroutine.py @@ -0,0 +1,54 @@ +'''OpenGL extension ARB.shader_subroutine + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.shader_subroutine to provide a more +Python-friendly API + +Overview (from the spec) + + This extension adds support to shaders for "indirect subroutine calls", + where a single shader can include many subroutines and dynamically select + through the API which subroutine is called from each call site. + Switching subroutines dynamically in this fashion can avoid the cost of + recompiling and managing multiple shaders, while still retaining most of + the performance of specialized shaders. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/shader_subroutine.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.shader_subroutine import * +from OpenGL.raw.GL.ARB.shader_subroutine import _EXTENSION_NAME + +def glInitShaderSubroutineARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +glGetActiveSubroutineUniformiv=wrapper.wrapper(glGetActiveSubroutineUniformiv).setOutput( + 'values',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetActiveSubroutineUniformName=wrapper.wrapper(glGetActiveSubroutineUniformName).setOutput( + 'length',size=(1,),orPassIn=True +).setOutput( + 'name',size=lambda x:(x,),pnameArg='bufsize',orPassIn=True +) +glGetActiveSubroutineName=wrapper.wrapper(glGetActiveSubroutineName).setOutput( + 'length',size=(1,),orPassIn=True +).setOutput( + 'name',size=lambda x:(x,),pnameArg='bufsize',orPassIn=True +) +# INPUT glUniformSubroutinesuiv.indices size not checked against count +glUniformSubroutinesuiv=wrapper.wrapper(glUniformSubroutinesuiv).setInputArraySize( + 'indices', None +) +glGetUniformSubroutineuiv=wrapper.wrapper(glGetUniformSubroutineuiv).setOutput( + 'params',size=(1,),orPassIn=True +) +glGetProgramStageiv=wrapper.wrapper(glGetProgramStageiv).setOutput( + 'values',size=(1,),orPassIn=True +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/shader_texture_image_samples.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/shader_texture_image_samples.py new file mode 100644 index 00000000..89b70301 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/shader_texture_image_samples.py @@ -0,0 +1,28 @@ +'''OpenGL extension ARB.shader_texture_image_samples + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.shader_texture_image_samples to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides GLSL built-in functions allowing shaders to query + the number of samples of a texture. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/shader_texture_image_samples.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.shader_texture_image_samples import * +from OpenGL.raw.GL.ARB.shader_texture_image_samples import _EXTENSION_NAME + +def glInitShaderTextureImageSamplesARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/shader_texture_lod.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/shader_texture_lod.py new file mode 100644 index 00000000..508f3cd3 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/shader_texture_lod.py @@ -0,0 +1,111 @@ +'''OpenGL extension ARB.shader_texture_lod + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.shader_texture_lod to provide a more +Python-friendly API + +Overview (from the spec) + + This extension adds additional texture functions to the + OpenGL Shading Language which provide the shader writer + with explicit control of LOD. + + Mipmap texture fetches and anisotropic texture fetches + require an implicit derivatives to calculate rho, lambda + and/or the line of anisotropy. These implicit derivatives + will be undefined for texture fetches occurring inside + non-uniform control flow or for vertex shader texture + fetches, resulting in undefined texels. + + The additional texture functions introduced with + this extension provide explict control of LOD + (isotropic texture functions) or provide explicit + derivatives (anisotropic texture functions). + + Anisotropic texture functions return defined texels + for mipmap texture fetches or anisotropic texture fetches, + even inside non-uniform control flow. Isotropic texture + functions return defined texels for mipmap texture fetches, + even inside non-uniform control flow. However, isotropic + texture functions return undefined texels for anisotropic + texture fetches. + + The existing isotropic vertex texture functions: + + texture1DLod, texture1DProjLod, + texture2DLod, texture2DProjLod, + texture3DLod, texture3DProjLod, + textureCubeLod, + shadow1DLod, shadow1DProjLod, + shadow2DLod, shadow2DProjLod, + + are added to the built-in functions for fragment shaders. + + New anisotropic texture functions, providing explicit + derivatives: + + texture1DGradARB( sampler1D sampler, + float P, float dPdx, float dPdy ); + texture1DProjGradARB( sampler1D sampler, + vec2 P, float dPdx, float dPdy ); + texture1DProjGradARB( sampler1D sampler, + vec4 P, float dPdx, float dPdy ); + + texture2DGradARB( sampler2D sampler, + vec2 P, vec2 dPdx, vec2 dPdy ); + texture2DProjGradARB( sampler2D sampler, + vec3 P, vec2 dPdx, vec2 dPdy ); + texture2DProjGradARB( sampler2D sampler, + vec4 P, vec2 dPdx, vec2 dPdy ); + + texture3DGradARB( sampler3D sampler, + vec3 P, vec3 dPdx, vec3 dPdy ); + texture3DProjGradARB( sampler3D sampler, + vec4 P, vec3 dPdx, vec3 dPdy ); + + textureCubeGradARB( samplerCube sampler, + vec3 P, vec3 dPdx, vec3 dPdy ); + + shadow1DGradARB( sampler1DShadow sampler, + vec3 P, float dPdx, float dPdy ); + shadow1DProjGradARB( sampler1DShadow sampler, + vec4 P, float dPdx, float dPdy ); + + shadow2DGradARB( sampler2DShadow sampler, + vec3 P, vec2 dPdx, vec2 dPdy ); + shadow2DProjGradARB( sampler2DShadow sampler, + vec4 P, vec2 dPdx, vec2 dPdy ); + + + texture2DRectGradARB( sampler2DRect sampler, + vec2 P, vec2 dPdx, vec2 dPdy ); + texture2DRectProjGradARB( sampler2DRect sampler, + vec3 P, vec2 dPdx, vec2 dPdy ); + texture2DRectProjGradARB( sampler2DRect sampler, + vec4 P, vec2 dPdx, vec2 dPdy ); + + shadow2DRectGradARB( sampler2DRectShadow sampler, + vec3 P, vec2 dPdx, vec2 dPdy ); + shadow2DRectProjGradARB( sampler2DRectShadow sampler, + vec4 P, vec2 dPdx, vec2 dPdy ); + + are added to the built-in functions for vertex shaders + and fragment shaders. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/shader_texture_lod.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.shader_texture_lod import * +from OpenGL.raw.GL.ARB.shader_texture_lod import _EXTENSION_NAME + +def glInitShaderTextureLodARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/shader_viewport_layer_array.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/shader_viewport_layer_array.py new file mode 100644 index 00000000..91ef5343 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/shader_viewport_layer_array.py @@ -0,0 +1,42 @@ +'''OpenGL extension ARB.shader_viewport_layer_array + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.shader_viewport_layer_array to provide a more +Python-friendly API + +Overview (from the spec) + + The gl_ViewportIndex and gl_Layer built-in variables were introduced by + the in OpenGL 4.1. These variables are available in un-extended OpenGL + only to the geometry shader. When written in the geometry shader, they + cause geometry to be directed to one of an array of several independent + viewport rectangles or framebuffer attachment layers, respectively. + + In order to use any viewport or attachment layer other than zero, a + geometry shader must be present. Geometry shaders introduce processing + overhead and potential performance issues. The AMD_vertex_shader_layer + and AMD_vertex_shader_viewport_index extensions allowed the gl_Layer + and gl_ViewportIndex outputs to be written directly from the vertex shader + with no geometry shader present. + + This extension effectively merges the AMD_vertex_shader_layer and + AMD_vertex_shader_viewport_index extensions together and extends them further + to allow both outputs to be written from tessellation evaluation shaders. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/shader_viewport_layer_array.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.shader_viewport_layer_array import * +from OpenGL.raw.GL.ARB.shader_viewport_layer_array import _EXTENSION_NAME + +def glInitShaderViewportLayerArrayARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/shading_language_100.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/shading_language_100.py new file mode 100644 index 00000000..7ff639f9 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/shading_language_100.py @@ -0,0 +1,31 @@ +'''OpenGL extension ARB.shading_language_100 + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.shading_language_100 to provide a more +Python-friendly API + +Overview (from the spec) + + This extension string indicates that the OpenGL Shading Language is + supported. The Shading Language is defined by a separate specification + document which can be downloaded from + + http://www.opengl.org/documentation/oglsl.html + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/shading_language_100.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.shading_language_100 import * +from OpenGL.raw.GL.ARB.shading_language_100 import _EXTENSION_NAME + +def glInitShadingLanguage100ARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/shading_language_420pack.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/shading_language_420pack.py new file mode 100644 index 00000000..9d799b97 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/shading_language_420pack.py @@ -0,0 +1,65 @@ +'''OpenGL extension ARB.shading_language_420pack + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.shading_language_420pack to provide a more +Python-friendly API + +Overview (from the spec) + + This is a language feature only extension formed from changes made + to version 4.20 of GLSL. It includes: + + * Add line-continuation using '\', as in C++. + + * Change from ASCII to UTF-8 for the language character set and also + allow any characters inside comments. + + * Allow implicit conversions of return values to the declared type of + the function. + + * The *const* keyword can be used to declare variables within a function + body with initializer expressions that are not constant expressions. + + * Qualifiers on variable declarations no longer have to follow a strict + order. The layout qualifier can be used multiple times, and multiple + parameter qualifiers can be used. However, this is not as + straightforward as saying declarations have arbitrary lists of + initializers. Typically, one qualifier from each class of qualifiers + is allowed, so care is now taken to classify them and say so. Then, + of these, order restrictions are removed. + + * Add layout qualifier identifier "binding" to bind the location of a + uniform block. This requires version 1.4 of GLSL. If this extension + is used with an earlier version than 1.4, this feature is not present. + + * Add layout qualifier identifier "binding" to bind units to sampler + and image variable declarations. + + * Add C-style curly brace initializer lists syntax for initializers. + Full initialization of aggregates is required when these are used. + + * Allow ".length()" to be applied to vectors and matrices, returning + the number of components or columns. + + * Allow swizzle operations on scalars. + + * Built-in constants for gl_MinProgramTexelOffset and + gl_MaxProgramTexelOffset. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/shading_language_420pack.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.shading_language_420pack import * +from OpenGL.raw.GL.ARB.shading_language_420pack import _EXTENSION_NAME + +def glInitShadingLanguage420PackARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/shading_language_include.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/shading_language_include.py new file mode 100644 index 00000000..63d12c2d --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/shading_language_include.py @@ -0,0 +1,66 @@ +'''OpenGL extension ARB.shading_language_include + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.shading_language_include to provide a more +Python-friendly API + +Overview (from the spec) + + This extension introduces a #include GLSL directive to allow reusing + the same shader text in multiple shaders and defines the semantics + and syntax of the names allowed in #include directives. It also + defines API mechanisms to define the named string backing a + #include. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/shading_language_include.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.shading_language_include import * +from OpenGL.raw.GL.ARB.shading_language_include import _EXTENSION_NAME + +def glInitShadingLanguageIncludeARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glNamedStringARB.name size not checked against namelen +# INPUT glNamedStringARB.string size not checked against stringlen +glNamedStringARB=wrapper.wrapper(glNamedStringARB).setInputArraySize( + 'name', None +).setInputArraySize( + 'string', None +) +# INPUT glDeleteNamedStringARB.name size not checked against namelen +glDeleteNamedStringARB=wrapper.wrapper(glDeleteNamedStringARB).setInputArraySize( + 'name', None +) +# INPUT glCompileShaderIncludeARB.length size not checked against count +# INPUT glCompileShaderIncludeARB.path size not checked against count +glCompileShaderIncludeARB=wrapper.wrapper(glCompileShaderIncludeARB).setInputArraySize( + 'length', None +).setInputArraySize( + 'path', None +) +# INPUT glIsNamedStringARB.name size not checked against namelen +glIsNamedStringARB=wrapper.wrapper(glIsNamedStringARB).setInputArraySize( + 'name', None +) +# INPUT glGetNamedStringARB.name size not checked against namelen +glGetNamedStringARB=wrapper.wrapper(glGetNamedStringARB).setInputArraySize( + 'name', None +).setOutput( + 'string',size=lambda x:(x,),pnameArg='bufSize',orPassIn=True +).setOutput( + 'stringlen',size=(1,),orPassIn=True +) +# INPUT glGetNamedStringivARB.name size not checked against namelen +glGetNamedStringivARB=wrapper.wrapper(glGetNamedStringivARB).setInputArraySize( + 'name', None +).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/shading_language_packing.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/shading_language_packing.py new file mode 100644 index 00000000..2c15b0c2 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/shading_language_packing.py @@ -0,0 +1,43 @@ +'''OpenGL extension ARB.shading_language_packing + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.shading_language_packing to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides the GLSL built-in functions to convert a 32-bit + unsigned integer holding a pair of 16-bit floating-point values to or from + a two-component floating-point vector (vec2). + + This mechanism allows GLSL shaders to read and write 16-bit floating-point + encodings (via 32-bit unsigned integers) without introducing a full set of + 16-bit floating-point data types. + + This extension also adds the GLSL built-in packing functions included in + GLSL version 4.00 and the ARB_gpu_shader5 extension which pack and unpack + vectors of small fixed-point data types into a larger scalar. By putting + these packing functions in this separate extension it allows + implementations to provide these functions in hardware that supports them + independent of the other ARB_gpu_shader5 features. + + In addition to the packing functions from ARB_gpu_shader5 this extension + also adds the missing [un]packSnorm2x16 for completeness. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/shading_language_packing.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.shading_language_packing import * +from OpenGL.raw.GL.ARB.shading_language_packing import _EXTENSION_NAME + +def glInitShadingLanguagePackingARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/shadow.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/shadow.py new file mode 100644 index 00000000..d7550f0b --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/shadow.py @@ -0,0 +1,34 @@ +'''OpenGL extension ARB.shadow + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.shadow to provide a more +Python-friendly API + +Overview (from the spec) + + This extension clarifies the GL_SGIX_shadow extension. + + This extension supports comparing the texture R coordinate to a depth + texture value in order to produce a boolean texture value. This can + be used to implement shadow maps. + + The extension is written in generic terms such that other texture + comparison modes can be accommodated in the future. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/shadow.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.shadow import * +from OpenGL.raw.GL.ARB.shadow import _EXTENSION_NAME + +def glInitShadowARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/shadow_ambient.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/shadow_ambient.py new file mode 100644 index 00000000..65da5fca --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/shadow_ambient.py @@ -0,0 +1,35 @@ +'''OpenGL extension ARB.shadow_ambient + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.shadow_ambient to provide a more +Python-friendly API + +Overview (from the spec) + + This is based on the GL_SGIX_shadow_ambient extension and is layered + upon the GL_ARB_shadow extension. + + Basically, this extension allows the user to specify the texture + value to use when the texture compare function fails. Normally + this value is zero. By allowing an arbitrary value we can get + functionality which otherwise requires an advanced texture + combine extension (such as GL_NV_register_combiners) and multiple + texture units. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/shadow_ambient.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.shadow_ambient import * +from OpenGL.raw.GL.ARB.shadow_ambient import _EXTENSION_NAME + +def glInitShadowAmbientARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/sparse_buffer.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/sparse_buffer.py new file mode 100644 index 00000000..3bbc059d --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/sparse_buffer.py @@ -0,0 +1,32 @@ +'''OpenGL extension ARB.sparse_buffer + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.sparse_buffer to provide a more +Python-friendly API + +Overview (from the spec) + + The ARB_sparse_texture extension adds to GL a mechanism to decouple the + virtual and physical storage requirements of textures and allows an + application to create partially populated textures that would + over-subscribe available graphics memory if made fully resident. This + extension provides like functionality for buffer objects, allowing + applications to manage buffer object storage in a similar manner. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/sparse_buffer.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.sparse_buffer import * +from OpenGL.raw.GL.ARB.sparse_buffer import _EXTENSION_NAME + +def glInitSparseBufferARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/sparse_texture.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/sparse_texture.py new file mode 100644 index 00000000..c2842918 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/sparse_texture.py @@ -0,0 +1,42 @@ +'''OpenGL extension ARB.sparse_texture + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.sparse_texture to provide a more +Python-friendly API + +Overview (from the spec) + + Recent advances in application complexity and a desire for higher + resolutions have pushed texture sizes up considerably. Often, the amount + of physical memory available to a graphics processor is a limiting factor + in the performance of texture-heavy applications. Once the available + physical memory is exhausted, paging may occur bringing performance down + considerably - or worse, the application may fail. Nevertheless, the amount + of address space available to the graphics processor has increased to the + point where many gigabytes - or even terabytes of address space may be + usable even though that amount of physical memory is not present. + + This extension allows the separation of the graphics processor's address + space (reservation) from the requirement that all textures must be + physically backed (commitment). This exposes a limited form of + virtualization for textures. Use cases include sparse (or partially + resident) textures, texture paging, on-demand and delayed loading of + texture assets and application controlled level of detail. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/sparse_texture.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.sparse_texture import * +from OpenGL.raw.GL.ARB.sparse_texture import _EXTENSION_NAME + +def glInitSparseTextureARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/sparse_texture2.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/sparse_texture2.py new file mode 100644 index 00000000..a8dc9692 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/sparse_texture2.py @@ -0,0 +1,53 @@ +'''OpenGL extension ARB.sparse_texture2 + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.sparse_texture2 to provide a more +Python-friendly API + +Overview (from the spec) + + This extension builds on the ARB_sparse_texture extension, providing the + following new functionality: + + * New built-in GLSL texture lookup and image load functions are provided + that return information on whether the texels accessed for the texture + lookup accessed uncommitted texture memory. + + * New built-in GLSL texture lookup functions are provided that specify a + minimum level of detail to use for lookups where the level of detail + is computed automatically. This allows shaders to avoid accessing + unpopulated portions of high-resolution levels of detail when it knows + that the memory accessed is unpopulated, either from a priori + knowledge or from feedback provided by the return value of previously + executed "sparse" texture lookup functions. + + * Reads of uncommitted texture memory will act as though such memory + were filled with zeroes; previously, the values returned by reads were + undefined. + + * Standard implementation-independent virtual page sizes for internal + formats required to be supported with sparse textures. These standard + sizes can be requested by leaving VIRTUAL_PAGE_SIZE_INDEX_ARB at its + initial value (0). + + * Support for creating sparse multisample and multisample array textures + is added. However, the virtual page sizes for such textures remain + fully implementation-dependent. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/sparse_texture2.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.sparse_texture2 import * +from OpenGL.raw.GL.ARB.sparse_texture2 import _EXTENSION_NAME + +def glInitSparseTexture2ARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/sparse_texture_clamp.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/sparse_texture_clamp.py new file mode 100644 index 00000000..6d9577f0 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/sparse_texture_clamp.py @@ -0,0 +1,36 @@ +'''OpenGL extension ARB.sparse_texture_clamp + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.sparse_texture_clamp to provide a more +Python-friendly API + +Overview (from the spec) + + This extension builds on the ARB_sparse_texture2 extension, providing the + following new functionality: + + * New built-in GLSL texture lookup functions are provided that specify a + minimum level of detail to use for lookups where the level of detail + is computed automatically. This allows shaders to avoid accessing + unpopulated portions of high-resolution levels of detail when it knows + that the memory accessed is unpopulated, either from a priori + knowledge or from feedback provided by the return value of previously + executed "sparse" texture lookup functions. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/sparse_texture_clamp.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.sparse_texture_clamp import * +from OpenGL.raw.GL.ARB.sparse_texture_clamp import _EXTENSION_NAME + +def glInitSparseTextureClampARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/spirv_extensions.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/spirv_extensions.py new file mode 100644 index 00000000..c8b8b867 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/spirv_extensions.py @@ -0,0 +1,49 @@ +'''OpenGL extension ARB.spirv_extensions + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.spirv_extensions to provide a more +Python-friendly API + +Overview (from the spec) + + ARB_gl_spirv added support for using SPIR-V modules in OpenGL. + However it only added support for SPIR-V 1.0 concepts that were part of + the OpenGL 4.5 Core Profile. + + There are a great number of additional OpenGL ARB and vendor extensions + which add shading language concepts and since they were defined prior + to the existence of SPIR-V support in OpenGL they don't add SPIR-V support + for their additional features. Ideally GL_ARB_gl_spirv would have added + support for them, but as noted in Issue 27 of that extension, support for + them was left as a future exercise. + + Now that at least some of that functionality has been defined via SPIR-V + extensions, there is currently no way for an OpenGL implementation to + advertise that is supports additional SPIR-V extensions. + + This extension provides a mechanism for an implementation to advertise + which SPIR-V extensions it supports, and further provides a place where + the SPIR-V environment for those extensions can be documented for OpenGL. + + It is expected that this document can be extended over time as SPIR-V + support for additional extensions is added. The mapping between GLSL and + SPIR-V concepts and any other pertinent information can be provided here + as interactions with the corresponding OpenGL and SPIR-V extensions. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/spirv_extensions.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.spirv_extensions import * +from OpenGL.raw.GL.ARB.spirv_extensions import _EXTENSION_NAME + +def glInitSpirvExtensionsARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/stencil_texturing.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/stencil_texturing.py new file mode 100644 index 00000000..df44e82a --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/stencil_texturing.py @@ -0,0 +1,31 @@ +'''OpenGL extension ARB.stencil_texturing + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.stencil_texturing to provide a more +Python-friendly API + +Overview (from the spec) + + This extension allows texturing of the stencil component of a packed depth + stencil texture. Stencil values are returned as unsigned integers. It is + not possible to sample both depth and stencil values from the same + texture, and this extension allows the app to select which is sampled for + the bound texture. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/stencil_texturing.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.stencil_texturing import * +from OpenGL.raw.GL.ARB.stencil_texturing import _EXTENSION_NAME + +def glInitStencilTexturingARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/sync.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/sync.py new file mode 100644 index 00000000..2f41b8b7 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/sync.py @@ -0,0 +1,79 @@ +'''OpenGL extension ARB.sync + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.sync to provide a more +Python-friendly API + +Overview (from the spec) + + This extension introduces the concept of "sync objects". Sync + objects are a synchronization primitive - a representation of events + whose completion status can be tested or waited upon. One specific + type of sync object, the "fence sync object", is supported in this + extension, and additional types can easily be added in the future. + + Fence sync objects have corresponding fences, which are inserted + into the OpenGL command stream at the time the sync object is + created. A sync object can be queried for a given condition. The + only condition supported for fence sync objects is completion of the + corresponding fence command. Fence completion allows applications to + request a partial Finish, wherein all commands prior to the fence + will be forced to complete before control is returned to the calling + process. + + These new mechanisms allow for synchronization between the host CPU + and the GPU, which may be accessing the same resources (typically + memory), as well as between multiple GL contexts bound to multiple + threads in the host CPU. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/sync.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.sync import * +from OpenGL.raw.GL.ARB.sync import _EXTENSION_NAME + +def glInitSyncARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +glGetInteger64v=wrapper.wrapper(glGetInteger64v).setOutput( + 'data',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetSynciv=wrapper.wrapper(glGetSynciv).setOutput( + 'length',size=(1,),orPassIn=True +).setOutput( + 'values',size=lambda x:(x,),pnameArg='bufSize',orPassIn=True +) +### END AUTOGENERATED SECTION +from OpenGL.raw.GL._types import GLint +from OpenGL.arrays import GLintArray + +def glGetSync( sync, pname, bufSize=1,length=None,values=None ): + """Wrapper around glGetSynciv that auto-allocates buffers + + sync -- the GLsync struct pointer (see glGetSynciv) + pname -- constant to retrieve (see glGetSynciv) + bufSize -- defaults to 1, maximum number of items to retrieve, + currently all constants are defined to return a single + value + length -- None or a GLint() instance (ONLY!), must be a byref() + capable object with a .value attribute which retrieves the + set value + values -- None or an array object, if None, will be a default + return-array-type of length bufSize + + returns values[:length.value], i.e. an array with the values set + by the call, currently always a single-value array. + """ + if values is None: + values = GLintArray.zeros( (bufSize,) ) + if length is None: + length = GLint() + glGetSynciv( sync, pname, bufSize, length, values ) + written = length.value + return values[:written] diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/tessellation_shader.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/tessellation_shader.py new file mode 100644 index 00000000..7e081835 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/tessellation_shader.py @@ -0,0 +1,95 @@ +'''OpenGL extension ARB.tessellation_shader + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.tessellation_shader to provide a more +Python-friendly API + +Overview (from the spec) + + This extension introduces new tessellation stages and two new shader types + to the OpenGL primitive processing pipeline. These pipeline stages + operate on a new basic primitive type, called a patch. A patch consists + of a fixed-size collection of vertices, each with per-vertex attributes, + plus a number of associated per-patch attributes. Tessellation control + shaders transform an input patch specified by the application, computing + per-vertex and per-patch attributes for a new output patch. A + fixed-function tessellation primitive generator subdivides the patch, and + tessellation evaluation shaders are used to compute the position and + attributes of each vertex produced by the tessellator. + + When tessellation is active, it begins by running the optional + tessellation control shader. This shader consumes an input patch and + produces a new fixed-size output patch. The output patch consists of an + array of vertices, and a set of per-patch attributes. The per-patch + attributes include tessellation levels that control how finely the patch + will be tessellated. For each patch processed, multiple tessellation + control shader invocations are performed -- one per output patch vertex. + Each tessellation control shader invocation writes all the attributes of + its corresponding output patch vertex. A tessellation control shader may + also read the per-vertex outputs of other tessellation control shader + invocations, as well as read and write shared per-patch outputs. The + tessellation control shader invocations for a single patch effectively run + as a group. A built-in barrier() function is provided to allow + synchronization points where no shader invocation will continue until all + shader invocations have reached the barrier. + + The tessellation primitive generator then decomposes a patch into a new + set of primitives using the tessellation levels to determine how finely + tessellated the output should be. The primitive generator begins with + either a triangle or a quad, and splits each outer edge of the primitive + into a number of segments approximately equal to the corresponding element + of the outer tessellation level array. The interior of the primitive is + tessellated according to elements of the inner tessellation level array. + The primitive generator has three modes: "triangles" and "quads" split a + triangular or quad-shaped patch into a set of triangles that cover the + original patch; "isolines" splits a quad-shaped patch into a set of line + strips running across the patch horizontally. Each vertex generated by + the tessellation primitive generator is assigned a (u,v) or (u,v,w) + coordinate indicating its relative location in the subdivided triangle or + quad. + + For each vertex produced by the tessellation primitive generator, the + tessellation evaluation shader is run to compute its position and other + attributes of the vertex, using its (u,v) or (u,v,w) coordinate. When + computing final vertex attributes, the tessellation evaluation shader can + also read the attributes of any of the vertices of the patch written by + the tessellation control shader. Tessellation evaluation shader + invocations are completely independent, although all invocations for a + single patch share the same collection of input vertices and per-patch + attributes. + + The tessellator operates on vertices after they have been transformed by a + vertex shader. The primitives generated by the tessellator are passed + further down the OpenGL pipeline, where they can be used as inputs to + geometry shaders, transform feedback, and the rasterizer. + + The tessellation control and evaluation shaders are both optional. If + neither shader type is present, the tessellation stage has no effect. If + no tessellation control shader is present, the input patch provided by the + application is passed directly to the tessellation primitive generator, + and a set of default tessellation level parameters is used to control + primitive generation. In this extension, patches may not be passed beyond + the tessellation evaluation shader, and an error is generated if an + application provides patches and the current program object contains no + tessellation evaluation shader. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/tessellation_shader.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.tessellation_shader import * +from OpenGL.raw.GL.ARB.tessellation_shader import _EXTENSION_NAME + +def glInitTessellationShaderARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glPatchParameterfv.values size not checked against 'pname' +glPatchParameterfv=wrapper.wrapper(glPatchParameterfv).setInputArraySize( + 'values', None +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/texture_barrier.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/texture_barrier.py new file mode 100644 index 00000000..758514c9 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/texture_barrier.py @@ -0,0 +1,29 @@ +'''OpenGL extension ARB.texture_barrier + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.texture_barrier to provide a more +Python-friendly API + +Overview (from the spec) + + This extension relaxes the restrictions on rendering to a currently + bound texture and provides a mechanism to avoid read-after-write + hazards. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/texture_barrier.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.texture_barrier import * +from OpenGL.raw.GL.ARB.texture_barrier import _EXTENSION_NAME + +def glInitTextureBarrierARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/texture_border_clamp.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/texture_border_clamp.py new file mode 100644 index 00000000..0d5c0500 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/texture_border_clamp.py @@ -0,0 +1,38 @@ +'''OpenGL extension ARB.texture_border_clamp + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.texture_border_clamp to provide a more +Python-friendly API + +Overview (from the spec) + + The base OpenGL provides clamping such that the texture coordinates are + limited to exactly the range [0,1]. When a texture coordinate is clamped + using this algorithm, the texture sampling filter straddles the edge of + the texture image, taking 1/2 its sample values from within the texture + image, and the other 1/2 from the texture border. It is sometimes + desirable for a texture to be clamped to the border color, rather than to + an average of the border and edge colors. + + This extension defines an additional texture clamping algorithm. + CLAMP_TO_BORDER_ARB clamps texture coordinates at all mipmap levels such + that NEAREST and LINEAR filters return only the color of the border + texels. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/texture_border_clamp.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.texture_border_clamp import * +from OpenGL.raw.GL.ARB.texture_border_clamp import _EXTENSION_NAME + +def glInitTextureBorderClampARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/texture_buffer_object.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/texture_buffer_object.py new file mode 100644 index 00000000..181ba2c4 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/texture_buffer_object.py @@ -0,0 +1,55 @@ +'''OpenGL extension ARB.texture_buffer_object + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.texture_buffer_object to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides a new texture type, called a buffer texture. + Buffer textures are one-dimensional arrays of texels whose storage comes + from an attached buffer object. When a buffer object is bound to a buffer + texture, a format is specified, and the data in the buffer object is + treated as an array of texels of the specified format. + + The use of a buffer object to provide storage allows the texture data to + be specified in a number of different ways: via buffer object loads + (BufferData), direct CPU writes (MapBuffer), framebuffer readbacks + (EXT_pixel_buffer_object extension). A buffer object can also be loaded + by transform feedback (NV_transform_feedback extension), which captures + selected transformed attributes of vertices processed by the GL. Several + of these mechanisms do not require an extra data copy, which would be + required when using conventional TexImage-like entry points. + + Buffer textures do not support mipmapping, texture lookups with normalized + floating-point texture coordinates, and texture filtering of any sort, and + may not be used in fixed-function fragment processing. They can be + accessed via single texel fetch operations in programmable shaders. For + assembly shaders (NV_gpu_program4), the TXF instruction is used. For GLSL + (EXT_gpu_shader4), a new sampler type and texel fetch function are used. + + While buffer textures can be substantially larger than equivalent + one-dimensional textures; the maximum texture size supported for buffer + textures in the initial implementation of this extension is 2^27 texels, + versus 2^13 (8192) texels for otherwise equivalent one-dimensional + textures. When a buffer object is attached to a buffer texture, a size is + not specified; rather, the number of texels in the texture is taken by + dividing the size of the buffer object by the size of each texel. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/texture_buffer_object.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.texture_buffer_object import * +from OpenGL.raw.GL.ARB.texture_buffer_object import _EXTENSION_NAME + +def glInitTextureBufferObjectARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/texture_buffer_object_rgb32.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/texture_buffer_object_rgb32.py new file mode 100644 index 00000000..f2769b4d --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/texture_buffer_object_rgb32.py @@ -0,0 +1,30 @@ +'''OpenGL extension ARB.texture_buffer_object_rgb32 + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.texture_buffer_object_rgb32 to provide a more +Python-friendly API + +Overview (from the spec) + + This extension adds three new buffer texture formats - RGB32F, RGB32I, + and RGB32UI. This partially addresses one of the limitations of buffer + textures in the original EXT_texture_buffer_object extension and in + OpenGL 3.1, which provide no support for three-component formats. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/texture_buffer_object_rgb32.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.texture_buffer_object_rgb32 import * +from OpenGL.raw.GL.ARB.texture_buffer_object_rgb32 import _EXTENSION_NAME + +def glInitTextureBufferObjectRgb32ARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/texture_buffer_range.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/texture_buffer_range.py new file mode 100644 index 00000000..9b8a8a59 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/texture_buffer_range.py @@ -0,0 +1,35 @@ +'''OpenGL extension ARB.texture_buffer_range + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.texture_buffer_range to provide a more +Python-friendly API + +Overview (from the spec) + + ARB_texture_buffer_object (which was promoted to core in OpenGL 3.1) + introduced the ability to attach the data store of a buffer object + to a buffer texture and access it from shaders. The extension only allows + the entire store of the buffer object to the texture. This extension + expands on this and allows a sub-range of the buffer's data store to + be attached to a texture. This can be used, for example, to allow multiple + buffer textures to be backed by independent sub-ranges of the same buffer + object, or for different sub-ranges of a single buffer object to be used + for different purposes. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/texture_buffer_range.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.texture_buffer_range import * +from OpenGL.raw.GL.ARB.texture_buffer_range import _EXTENSION_NAME + +def glInitTextureBufferRangeARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/texture_compression.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/texture_compression.py new file mode 100644 index 00000000..8d9fa477 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/texture_compression.py @@ -0,0 +1,132 @@ +'''OpenGL extension ARB.texture_compression + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.texture_compression to provide a more +Python-friendly API + +Overview (from the spec) + + Compressing texture images can reduce texture memory utilization and + improve performance when rendering textured primitives. This extension + allows OpenGL applications to use compressed texture images by providing: + + (1) A framework upon which extensions providing specific compressed + image formats can be built. + + (2) A set of generic compressed internal formats that allow + applications to specify that texture images should be stored in + compressed form without needing to code for specific compression + formats. + + An application can define compressed texture images by providing a texture + image stored in a specific compressed image format. This extension does + not define any specific compressed image formats, but it does provide the + mechanisms necessary to enable other extensions that do. + + An application can also define compressed texture images by providing an + uncompressed texture image but specifying a compressed internal format. + In this case, the GL will automatically compress the texture image using + the appropriate image format. Compressed internal formats can either be + specific (as above) or generic. Generic compressed internal formats are + not actual image formats, but are instead mapped into one of the specific + compressed formats provided by the GL (or to an uncompressed base internal + format if no appropriate compressed format is available). Generic + compressed internal formats allow applications to use texture compression + without needing to code to any particular compression algorithm. Generic + compressed formats allow the use of texture compression across a wide + range of platforms with differing compression algorithms and also allow + future GL implementations to substitute improved compression methods + transparently. + + Compressed texture images can be obtained from the GL in uncompressed form + by calling GetTexImage and in compressed form by calling + GetCompressedTexImageARB. Queried compressed images can be saved and + later reused by calling CompressedTexImage[123]DARB. Pre-compressed + texture images do not need to be processed by the GL and should + significantly improve texture loading performance relative to uncompressed + images. + + This extension does not define specific compressed image formats (e.g., + S3TC, FXT1), nor does it provide means to encode or decode such images. + To support images in a specific compressed format, a hardware vendor + would: + + (1) Provide a new extension defininig specific compressed + and tokens for TexImage[123]D, + TexSubImage[123]D, CopyTexImage[12]D, CompressedTexImage[123]DARB, + CompressedTexSubImage[123]DARB, and GetCompressedTexImageARB calls. + + (2) Specify the encoding of compressed images of that specific format. + + (3) Specify a method for deriving the size of compressed images of that + specific format, using the , , , + parameters, and (if necessary) the compressed image itself. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/texture_compression.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.texture_compression import * +from OpenGL.raw.GL.ARB.texture_compression import _EXTENSION_NAME + +def glInitTextureCompressionARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glCompressedTexImage3DARB.data size not checked against imageSize +glCompressedTexImage3DARB=wrapper.wrapper(glCompressedTexImage3DARB).setInputArraySize( + 'data', None +) +# INPUT glCompressedTexImage2DARB.data size not checked against imageSize +glCompressedTexImage2DARB=wrapper.wrapper(glCompressedTexImage2DARB).setInputArraySize( + 'data', None +) +# INPUT glCompressedTexImage1DARB.data size not checked against imageSize +glCompressedTexImage1DARB=wrapper.wrapper(glCompressedTexImage1DARB).setInputArraySize( + 'data', None +) +# INPUT glCompressedTexSubImage3DARB.data size not checked against imageSize +glCompressedTexSubImage3DARB=wrapper.wrapper(glCompressedTexSubImage3DARB).setInputArraySize( + 'data', None +) +# INPUT glCompressedTexSubImage2DARB.data size not checked against imageSize +glCompressedTexSubImage2DARB=wrapper.wrapper(glCompressedTexSubImage2DARB).setInputArraySize( + 'data', None +) +# INPUT glCompressedTexSubImage1DARB.data size not checked against imageSize +glCompressedTexSubImage1DARB=wrapper.wrapper(glCompressedTexSubImage1DARB).setInputArraySize( + 'data', None +) +# OUTPUT glGetCompressedTexImageARB.img COMPSIZE(target, level) +### END AUTOGENERATED SECTION +from OpenGL.GL import images + +for dimensions in (1,2,3): + for function in ('glCompressedTexImage%sDARB','glCompressedTexSubImage%sDARB'): + name = function%(dimensions,) + globals()[ name ] = images.compressedImageFunction( + globals()[ name ] + ) + try: + del name, function + except NameError as err: + pass + try: + del dimensions + except NameError as err: + pass + +if glGetCompressedTexImageARB: + def glGetCompressedTexImageARB( target, level, img=None ): + """Retrieve a compressed texture image""" + if img is None: + length = glget.glGetTexLevelParameteriv( + target, 0, + GL_TEXTURE_COMPRESSED_IMAGE_SIZE_ARB, + ) + img = arrays.ArrayDataType.zeros( (length,), GL_1_0.GL_UNSIGNED_BYTE ) + return glGetCompressedTexImageARB(target, 0, img); diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/texture_compression_bptc.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/texture_compression_bptc.py new file mode 100644 index 00000000..42f677e8 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/texture_compression_bptc.py @@ -0,0 +1,42 @@ +'''OpenGL extension ARB.texture_compression_bptc + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.texture_compression_bptc to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides additional texture compression functionality + specific to the BPTC and BPTC_FLOAT compressed texture formats (called BC7 + and BC6H respectively in Microsoft's DirectX API), subject to all the + requirements and limitations described by the extension + GL_ARB_texture_compression. + + Traditional block compression methods as typified by s3tc and latc + compress a block of pixels into indicies along a gradient. This works well + for smooth images, but can have quality issues along sharp edges and + strong chrominance transitions. To improve quality in these problematic + cases, the BPTC formats can divide each block into multiple partitions, + each of which are compressed using an independent gradient. + + In addition, it is desirable to directly support high dynamic range + imagery in compressed formats, which is accomplished by the BPTC_FLOAT + formats. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/texture_compression_bptc.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.texture_compression_bptc import * +from OpenGL.raw.GL.ARB.texture_compression_bptc import _EXTENSION_NAME + +def glInitTextureCompressionBptcARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/texture_compression_rgtc.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/texture_compression_rgtc.py new file mode 100644 index 00000000..e6a555f3 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/texture_compression_rgtc.py @@ -0,0 +1,44 @@ +'''OpenGL extension ARB.texture_compression_rgtc + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.texture_compression_rgtc to provide a more +Python-friendly API + +Overview (from the spec) + + This extension introduces four new block-based texture compression + formats suited for unsigned and signed red and red-green textures + (hence the name "rgtc" for Red-Green Texture Compression). + + These formats are designed to reduce the storage requirements + and memory bandwidth required for red and red-green textures by + a factor of 2-to-1 over conventional uncompressed luminance and + luminance-alpha textures with 8-bit components (GL_LUMINANCE8 and + GL_LUMINANCE8_ALPHA8). + + The compressed signed red-green format is reasonably suited for + storing compressed normal maps. + + This extension uses the same compression format as the + EXT_texture_compression_latc extension except the color data is stored + in the red and green components rather than luminance and alpha. + Representing compressed red and green components is consistent with + the BC4 and BC5 compressed formats supported by DirectX 10. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/texture_compression_rgtc.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.texture_compression_rgtc import * +from OpenGL.raw.GL.ARB.texture_compression_rgtc import _EXTENSION_NAME + +def glInitTextureCompressionRgtcARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/texture_cube_map.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/texture_cube_map.py new file mode 100644 index 00000000..2344f17f --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/texture_cube_map.py @@ -0,0 +1,72 @@ +'''OpenGL extension ARB.texture_cube_map + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.texture_cube_map to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides a new texture generation scheme for cube + map textures. Instead of the current texture providing a 1D, 2D, + or 3D lookup into a 1D, 2D, or 3D texture image, the texture is a + set of six 2D images representing the faces of a cube. The (s,t,r) + texture coordinates are treated as a direction vector emanating from + the center of a cube. At texture generation time, the interpolated + per-fragment (s,t,r) selects one cube face 2D image based on the + largest magnitude coordinate (the major axis). A new 2D (s,t) is + calculated by dividing the two other coordinates (the minor axes + values) by the major axis value. Then the new (s,t) is used to + lookup into the selected 2D texture image face of the cube map. + + Unlike a standard 1D, 2D, or 3D texture that have just one target, + a cube map texture has six targets, one for each of its six 2D texture + image cube faces. All these targets must be consistent, complete, + and have equal width and height (ie, square dimensions). + + This extension also provides two new texture coordinate generation modes + for use in conjunction with cube map texturing. The reflection map + mode generates texture coordinates (s,t,r) matching the vertex's + eye-space reflection vector. The reflection map mode + is useful for environment mapping without the singularity inherent + in sphere mapping. The normal map mode generates texture coordinates + (s,t,r) matching the vertex's transformed eye-space + normal. The normal map mode is useful for sophisticated cube + map texturing-based diffuse lighting models. + + The intent of the new texgen functionality is that an application using + cube map texturing can use the new texgen modes to automatically + generate the reflection or normal vectors used to look up into the + cube map texture. + + An application note: When using cube mapping with dynamic cube + maps (meaning the cube map texture is re-rendered every frame), + by keeping the cube map's orientation pointing at the eye position, + the texgen-computed reflection or normal vector texture coordinates + can be always properly oriented for the cube map. However if the + cube map is static (meaning that when view changes, the cube map + texture is not updated), the texture matrix must be used to rotate + the texgen-computed reflection or normal vector texture coordinates + to match the orientation of the cube map. The rotation can be + computed based on two vectors: 1) the direction vector from the cube + map center to the eye position (both in world coordinates), and 2) + the cube map orientation in world coordinates. The axis of rotation + is the cross product of these two vectors; the angle of rotation is + the arcsin of the dot product of these two vectors. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/texture_cube_map.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.texture_cube_map import * +from OpenGL.raw.GL.ARB.texture_cube_map import _EXTENSION_NAME + +def glInitTextureCubeMapARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/texture_cube_map_array.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/texture_cube_map_array.py new file mode 100644 index 00000000..c100e0c0 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/texture_cube_map_array.py @@ -0,0 +1,51 @@ +'''OpenGL extension ARB.texture_cube_map_array + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.texture_cube_map_array to provide a more +Python-friendly API + +Overview (from the spec) + + The GL_EXT_texture_array extension, and subsequently OpenGL 3.0 have + introduced the concept of one- and two-dimensional array textures. + An array texture is an ordered set of images with the same size and + format. Each image in an array texture has a unique level. This + extension expands texture array support to include cube map + textures. + + A cube map array texture is a 2-dimensional array texture that may + contain many cube map layers. Each cube map layer is a unique cube + map image set. Images in a cube map array have the same size and + format limitations as one- and two-dimensional array textures. A + cube map array texture is specified using TexImage3D in a similar + manner to two-dimensional arrays. Cube map array textures can be + bound to a render targets of a frame buffer object as + two-dimensional arrays are using FramebufferTextureLayer. + + When accessed by a programmable shader, a cube map array texture + acts as a single unit. The "s", "t", "r" texture coordinates are + treated as a regular cube map texture fetch. The "q" texture is + treated as an unnormalized floating-point value identifying the + layer of the cube map array texture. Cube map array texture lookups + do not filter between layers. + + This extension does not provide for the use of cube map array + textures with fixed-function fragment processing. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/texture_cube_map_array.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.texture_cube_map_array import * +from OpenGL.raw.GL.ARB.texture_cube_map_array import _EXTENSION_NAME + +def glInitTextureCubeMapArrayARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/texture_env_add.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/texture_env_add.py new file mode 100644 index 00000000..e9266d1c --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/texture_env_add.py @@ -0,0 +1,36 @@ +'''OpenGL extension ARB.texture_env_add + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.texture_env_add to provide a more +Python-friendly API + +Overview (from the spec) + + New texture environment function ADD is supported with the following + equation: + Cv = min(1, Cf + Ct) + + New function may be specified by calling TexEnv with ADD token. + + One possible application is to add a specular highlight texture to + a Gouraud-shaded primitive to emulate Phong shading, in a single + pass. + + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/texture_env_add.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.texture_env_add import * +from OpenGL.raw.GL.ARB.texture_env_add import _EXTENSION_NAME + +def glInitTextureEnvAddARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/texture_env_combine.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/texture_env_combine.py new file mode 100644 index 00000000..8260db7c --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/texture_env_combine.py @@ -0,0 +1,45 @@ +'''OpenGL extension ARB.texture_env_combine + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.texture_env_combine to provide a more +Python-friendly API + +Overview (from the spec) + + New texture environment function COMBINE_ARB allows programmable + texture combiner operations, including: + + REPLACE Arg0 + MODULATE Arg0 * Arg1 + ADD Arg0 + Arg1 + ADD_SIGNED_ARB Arg0 + Arg1 - 0.5 + SUBTRACT_ARB Arg0 - Arg1 + INTERPOLATE_ARB Arg0 * (Arg2) + Arg1 * (1-Arg2) + + where Arg0, Arg1 and Arg2 are derived from + + PRIMARY_COLOR_ARB primary color of incoming fragment + TEXTURE texture color of corresponding texture unit + CONSTANT_ARB texture environment constant color + PREVIOUS_ARB result of previous texture environment; on + texture unit 0, this maps to PRIMARY_COLOR_ARB + + In addition, the result may be scaled by 1.0, 2.0 or 4.0. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/texture_env_combine.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.texture_env_combine import * +from OpenGL.raw.GL.ARB.texture_env_combine import _EXTENSION_NAME + +def glInitTextureEnvCombineARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/texture_env_crossbar.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/texture_env_crossbar.py new file mode 100644 index 00000000..b2459ef1 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/texture_env_crossbar.py @@ -0,0 +1,32 @@ +'''OpenGL extension ARB.texture_env_crossbar + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.texture_env_crossbar to provide a more +Python-friendly API + +Overview (from the spec) + + This extension adds the capability to use the texture color from + other texture units as sources to the COMBINE_ARB enviornment + function. The ARB_texture_env_combine extension defined texture + enviornment functions which could use the color from the + current texture unit as a source. This extension adds + the ability to use the color from any texture unit as a source. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/texture_env_crossbar.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.texture_env_crossbar import * +from OpenGL.raw.GL.ARB.texture_env_crossbar import _EXTENSION_NAME + +def glInitTextureEnvCrossbarARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/texture_env_dot3.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/texture_env_dot3.py new file mode 100644 index 00000000..e8a4c4fb --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/texture_env_dot3.py @@ -0,0 +1,34 @@ +'''OpenGL extension ARB.texture_env_dot3 + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.texture_env_dot3 to provide a more +Python-friendly API + +Overview (from the spec) + + Adds new operation to the texture combiner operations. + + DOT3_RGB_ARB Arg0 Arg1 + DOT3_RGBA_ARB Arg0 Arg1 + + where Arg0, Arg1 are specified by parameter of + TexEnvf, TexEnvi, TexEnvfv, and TexEnviv when the + parameter value is SOURCE0_RGB_ARB and SOURCE1_RGB_ARB. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/texture_env_dot3.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.texture_env_dot3 import * +from OpenGL.raw.GL.ARB.texture_env_dot3 import _EXTENSION_NAME + +def glInitTextureEnvDot3ARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/texture_filter_anisotropic.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/texture_filter_anisotropic.py new file mode 100644 index 00000000..fc268761 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/texture_filter_anisotropic.py @@ -0,0 +1,64 @@ +'''OpenGL extension ARB.texture_filter_anisotropic + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.texture_filter_anisotropic to provide a more +Python-friendly API + +Overview (from the spec) + + Texture mapping using OpenGL's existing mipmap texture filtering + modes assumes that the projection of the pixel filter footprint into + texture space is a square (ie, isotropic). In practice however, the + footprint may be long and narrow (ie, anisotropic). Consequently, + mipmap filtering severely blurs images on surfaces angled obliquely + away from the viewer. + + Several approaches exist for improving texture sampling by accounting + for the anisotropic nature of the pixel filter footprint into texture + space. This extension provides a general mechanism for supporting + anisotropic texturing filtering schemes without specifying a + particular formulation of anisotropic filtering. + + The extension permits the OpenGL application to specify on a per-texture + or -sampler object basis the maximum degree of anisotropy to account for + in texture filtering. + + Increasing the maximum degree of anisotropy may + improve texture filtering, but may also significantly reduce the + implementation's texture filtering rate. Implementations are free + to clamp the specified degree of anisotropy to the implementation's + maximum supported degree of anisotropy. + + A sampler or texture's maximum degree of anisotropy is specified + independently from its minification and magnification filter (as + opposed to being supported as an entirely new filtering mode). + Implementations are free to use the specified minification and + magnification filter to select a particular anisotropic texture + filtering scheme. For example, a NEAREST filter with a maximum + degree of anisotropy of two could be treated as a 2-tap filter that + accounts for the direction of anisotropy. Implementations are also + permitted to ignore the minification or magnification filter and + implement the highest quality of anisotropic filtering possible. + + Applications seeking the highest quality anisotropic filtering + available are advised to request a LINEAR_MIPMAP_LINEAR minification + filter, a LINEAR magnification filter, and a large maximum degree + of anisotropy. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/texture_filter_anisotropic.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.texture_filter_anisotropic import * +from OpenGL.raw.GL.ARB.texture_filter_anisotropic import _EXTENSION_NAME + +def glInitTextureFilterAnisotropicARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/texture_filter_minmax.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/texture_filter_minmax.py new file mode 100644 index 00000000..705e8ced --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/texture_filter_minmax.py @@ -0,0 +1,39 @@ +'''OpenGL extension ARB.texture_filter_minmax + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.texture_filter_minmax to provide a more +Python-friendly API + +Overview (from the spec) + + In unextended OpenGL, minification and magnification filters such as + LINEAR allow texture lookups to returned a filtered texel value produced + by computing an weighted average of a collection of texels in the + neighborhood of the texture coordinate provided. + + This extension provides a new texture and sampler parameter + (TEXTURE_REDUCTION_MODE_ARB) which allows applications to produce a + filtered texel value by computing a component-wise minimum (MIN) or + maximum (MAX) of the texels that would normally be averaged. The + reduction mode is orthogonal to the minification and magnification filter + parameters. The filter parameters are used to identify the set of texels + used to produce a final filtered value; the reduction mode identifies how + these texels are combined. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/texture_filter_minmax.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.texture_filter_minmax import * +from OpenGL.raw.GL.ARB.texture_filter_minmax import _EXTENSION_NAME + +def glInitTextureFilterMinmaxARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/texture_float.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/texture_float.py new file mode 100644 index 00000000..097b7f7f --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/texture_float.py @@ -0,0 +1,33 @@ +'''OpenGL extension ARB.texture_float + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.texture_float to provide a more +Python-friendly API + +Overview (from the spec) + + This extension adds texture internal formats with 16- and 32-bit + floating-point components. The 32-bit floating-point components + are in the standard IEEE float format. The 16-bit floating-point + components have 1 sign bit, 5 exponent bits, and 10 mantissa bits. + Floating-point components are clamped to the limits of the range + representable by their format. + + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/texture_float.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.texture_float import * +from OpenGL.raw.GL.ARB.texture_float import _EXTENSION_NAME + +def glInitTextureFloatARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/texture_gather.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/texture_gather.py new file mode 100644 index 00000000..fd757d5c --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/texture_gather.py @@ -0,0 +1,32 @@ +'''OpenGL extension ARB.texture_gather + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.texture_gather to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides a new set of texture functions + (textureGather) to the shading language that determine 2x2 footprint + that are used for linear filtering in a texture lookup, and return a + vector consisting of the first component from each of the four + texels in the footprint. + + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/texture_gather.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.texture_gather import * +from OpenGL.raw.GL.ARB.texture_gather import _EXTENSION_NAME + +def glInitTextureGatherARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/texture_mirror_clamp_to_edge.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/texture_mirror_clamp_to_edge.py new file mode 100644 index 00000000..d4dc277d --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/texture_mirror_clamp_to_edge.py @@ -0,0 +1,35 @@ +'''OpenGL extension ARB.texture_mirror_clamp_to_edge + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.texture_mirror_clamp_to_edge to provide a more +Python-friendly API + +Overview (from the spec) + + ARB_texture_mirror_clamp_to_edge extends the set of texture wrap modes to + include an additional mode (GL_MIRROR_CLAMP_TO_EDGE) that effectively uses + a texture map twice as large as the original image in which the additional + half of the new image is a mirror image of the original image. + + This new mode relaxes the need to generate images whose opposite edges + match by using the original image to generate a matching "mirror image". + This mode allows the texture to be mirrored only once in the negative + s, t, and r directions. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/texture_mirror_clamp_to_edge.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.texture_mirror_clamp_to_edge import * +from OpenGL.raw.GL.ARB.texture_mirror_clamp_to_edge import _EXTENSION_NAME + +def glInitTextureMirrorClampToEdgeARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/texture_mirrored_repeat.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/texture_mirrored_repeat.py new file mode 100644 index 00000000..6815ee6c --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/texture_mirrored_repeat.py @@ -0,0 +1,34 @@ +'''OpenGL extension ARB.texture_mirrored_repeat + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.texture_mirrored_repeat to provide a more +Python-friendly API + +Overview (from the spec) + + ARB_texture_mirrored_repeat extends the set of texture wrap modes to + include a mode (GL_MIRRORED_REPEAT_ARB) that effectively uses a texture + map twice as large at the original image in which the additional half, + for each coordinate, of the new image is a mirror image of the original + image. + + This new mode relaxes the need to generate images whose opposite edges + match by using the original image to generate a matching "mirror image". + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/texture_mirrored_repeat.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.texture_mirrored_repeat import * +from OpenGL.raw.GL.ARB.texture_mirrored_repeat import _EXTENSION_NAME + +def glInitTextureMirroredRepeatARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/texture_multisample.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/texture_multisample.py new file mode 100644 index 00000000..8ee64fd3 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/texture_multisample.py @@ -0,0 +1,40 @@ +'''OpenGL extension ARB.texture_multisample + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.texture_multisample to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides support for two new types of "multisample + textures" - two-dimensional and two-dimensional array - as well as + mechanisms to fetch a specific sample from such a texture in a shader, + and to attach such textures to FBOs for rendering. + + This extension also includes the following functionality, first described + in NV_explicit_multisample: + + * A query in the API to query the location of samples within the pixel + + * An explicit control for the multisample sample mask to augment the + control provided by SampleCoverage + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/texture_multisample.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.texture_multisample import * +from OpenGL.raw.GL.ARB.texture_multisample import _EXTENSION_NAME + +def glInitTextureMultisampleARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +glGetMultisamplefv=wrapper.wrapper(glGetMultisamplefv).setOutput( + 'val',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/texture_non_power_of_two.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/texture_non_power_of_two.py new file mode 100644 index 00000000..007d007a --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/texture_non_power_of_two.py @@ -0,0 +1,44 @@ +'''OpenGL extension ARB.texture_non_power_of_two + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.texture_non_power_of_two to provide a more +Python-friendly API + +Overview (from the spec) + + Conventional OpenGL texturing is limited to images with + power-of-two dimensions and an optional 1-texel border. + ARB_texture_non_power_of_two extension relaxes the size restrictions + for the 1D, 2D, cube map, and 3D texture targets. + + There is no additional procedural or enumerant api introduced by this + extension except that an implementation which exports the extension + string will allow an application to pass in texture dimensions for + the 1D, 2D, cube map, and 3D targets that may or may not be a power + of two. + + An implementation which supports relaxing traditional GL's + power-of-two size restrictions across all texture targets will export + the extension string: "ARB_texture_non_power_of_two". + + When this extension is supported, mipmapping, automatic mipmap + generation, and all the conventional wrap modes are supported for + non-power-of-two textures + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/texture_non_power_of_two.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.texture_non_power_of_two import * +from OpenGL.raw.GL.ARB.texture_non_power_of_two import _EXTENSION_NAME + +def glInitTextureNonPowerOfTwoARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/texture_query_levels.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/texture_query_levels.py new file mode 100644 index 00000000..667dad67 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/texture_query_levels.py @@ -0,0 +1,46 @@ +'''OpenGL extension ARB.texture_query_levels + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.texture_query_levels to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides a new set of texture functions + (textureQueryLevels) in the OpenGL Shading Language that exposes the + number of accessible mipmap levels in the texture associated with a GLSL + sampler variable. The set of accessible levels includes all the levels of + the texture defined either through TexImage*, TexStorage*, or TextureView* + (ARB_texture_view) APIs that are not below the TEXTURE_BASE_LEVEL or above + the TEXTURE_MAX_LEVEL parameters. For textures defined with TexImage*, + the set of resident levels is somewhat implementation-dependent. For + fully defined results, applications should use TexStorage*/TextureView + unless the texture has a full mipmap chain and is used with a mipmapped + minification filter. + + These functions means that shaders are not required to manually recompute, + approximate, or maintain a uniform holding a pre-computed level count, + since the true level count is already available to the + implementation. This value can be used to avoid black or leaking pixel + artifacts for rendering methods which are using texture images as memory + pages (eg: virtual textures); methods that can't only rely on the fixed + pipeline texture functions which take advantage of TEXTURE_MAX_LEVEL for + their sampling. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/texture_query_levels.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.texture_query_levels import * +from OpenGL.raw.GL.ARB.texture_query_levels import _EXTENSION_NAME + +def glInitTextureQueryLevelsARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/texture_query_lod.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/texture_query_lod.py new file mode 100644 index 00000000..9a1a6478 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/texture_query_lod.py @@ -0,0 +1,30 @@ +'''OpenGL extension ARB.texture_query_lod + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.texture_query_lod to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides a new set of fragment shader texture + functions (textureLOD) that return the results of automatic + level-of-detail computations that would be performed if a texture + lookup were performed. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/texture_query_lod.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.texture_query_lod import * +from OpenGL.raw.GL.ARB.texture_query_lod import _EXTENSION_NAME + +def glInitTextureQueryLodARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/texture_rectangle.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/texture_rectangle.py new file mode 100644 index 00000000..312224d0 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/texture_rectangle.py @@ -0,0 +1,55 @@ +'''OpenGL extension ARB.texture_rectangle + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.texture_rectangle to provide a more +Python-friendly API + +Overview (from the spec) + + OpenGL texturing is limited to images with power-of-two dimensions + and an optional 1-texel border. The ARB_texture_rectangle extension + adds a new texture target that supports 2D textures without requiring + power-of-two dimensions. + + Non-power-of-two sized (NPOTS) textures are useful for storing video + images that do not have power-of-two sized (POTS). Re-sampling + artifacts are avoided and less texture memory may be required by + using non-power-of-two sized textures. Non-power-of-two sized + textures are also useful for shadow maps and window-space texturing. + + However, non-power-of-two sized textures have limitations that + do not apply to power-of-two sized textures. NPOTS textures may + not use mipmap filtering; POTS textures support both mipmapped + and non-mipmapped filtering. NPOTS textures support only the + GL_CLAMP, GL_CLAMP_TO_EDGE, and GL_CLAMP_TO_BORDER wrap modes; + POTS textures support GL_CLAMP_TO_EDGE, GL_REPEAT, GL_CLAMP, + GL_MIRRORED_REPEAT, and GL_CLAMP_TO_BORDER (and GL_MIRROR_CLAMP_ATI + and GL_MIRROR_CLAMP_TO_EDGE_ATI if ATI_texture_mirror_once is + supported) . NPOTS textures do not support an optional 1-texel + border; POTS textures do support an optional 1-texel border. + + NPOTS textures are accessed by dimension-dependent (aka + non-normalized) texture coordinates. So instead of thinking of + the texture image lying in a [0..1]x[0..1] range, the NPOTS texture + image lies in a [0..w]x[0..h] range. + + This extension adds a new texture target and related state (proxy, + binding, max texture size). + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/texture_rectangle.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.texture_rectangle import * +from OpenGL.raw.GL.ARB.texture_rectangle import _EXTENSION_NAME + +def glInitTextureRectangleARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/texture_rg.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/texture_rg.py new file mode 100644 index 00000000..91891464 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/texture_rg.py @@ -0,0 +1,74 @@ +'''OpenGL extension ARB.texture_rg + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.texture_rg to provide a more +Python-friendly API + +Overview (from the spec) + + Historically one- and two- component textures have been specified in OpenGL + using the intensity, luminance or luminance-alpha (I/L/LA) formats. + With the advent of programmable shaders and render-to-texture capabilites + these legacy formats carry some historical artifacts which are no longer + useful. + + For example, when sampling from such textures, the luminance values + are replicated across the color components, and the intensity values are + replicated across both the color and alpha components. This is no + longer necessary with programmable shaders. + + It is also desirable to be able to render to one- and two- + component format textures using capabilities such as framebuffer + objects (FBO), but rendering to I/L/LA formats is under-specified + (specifically how to map R/G/B/A values to I/L/A texture channels). + + This extension adds new base internal formats for the one-component RED + and two-component RG (red green) texture formats as well as sized + internal formats for fixed-point, floating-point and pure integer texture + formats. The new texure formats can be used for texturing as well + as for rendering into with framebuffer objects. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/texture_rg.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.texture_rg import * +from OpenGL.raw.GL.ARB.texture_rg import _EXTENSION_NAME + +def glInitTextureRgARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION +from OpenGL import images as _images +_images.COMPONENT_COUNTS.update( { +GL_R16:1, +GL_R16F:1, +GL_R16I:1, +GL_R16UI:1, +GL_R32F:1, +GL_R32I:1, +GL_R32UI:1, +GL_R8:1, +GL_R8I:1, +GL_R8UI:1, + +GL_RG:2, +GL_RG16:2, +GL_RG16F:2, +GL_RG16I:2, +GL_RG16UI:2, +GL_RG32F:2, +GL_RG32I:2, +GL_RG32UI:2, +GL_RG8:2, +GL_RG8I:2, +GL_RG8UI:2, +GL_RG_INTEGER:2, +}) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/texture_rgb10_a2ui.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/texture_rgb10_a2ui.py new file mode 100644 index 00000000..b6f6c366 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/texture_rgb10_a2ui.py @@ -0,0 +1,34 @@ +'''OpenGL extension ARB.texture_rgb10_a2ui + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.texture_rgb10_a2ui to provide a more +Python-friendly API + +Overview (from the spec) + + This extension adds support for the following data format: + + A new texturing format for unsigned 10.10.10.2 integer textures. + + OpenGL has supported RGB10 and RGB10_A2 formats for a very long time. + This extension provides a variant of RGB10_A2 which supports unsigned + integer data (in contrast to the above "unsigned normalized integer" + formats). + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/texture_rgb10_a2ui.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.texture_rgb10_a2ui import * +from OpenGL.raw.GL.ARB.texture_rgb10_a2ui import _EXTENSION_NAME + +def glInitTextureRgb10A2UiARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/texture_stencil8.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/texture_stencil8.py new file mode 100644 index 00000000..abd2fd36 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/texture_stencil8.py @@ -0,0 +1,29 @@ +'''OpenGL extension ARB.texture_stencil8 + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.texture_stencil8 to provide a more +Python-friendly API + +Overview (from the spec) + + This extension accepts STENCIL_INDEX8 as a texture internal format, and + adds STENCIL_INDEX8 to the required internal format list. This removes the + need to use renderbuffers if a stencil-only format is desired. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/texture_stencil8.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.texture_stencil8 import * +from OpenGL.raw.GL.ARB.texture_stencil8 import _EXTENSION_NAME + +def glInitTextureStencil8ARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/texture_storage.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/texture_storage.py new file mode 100644 index 00000000..4c33c5fc --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/texture_storage.py @@ -0,0 +1,45 @@ +'''OpenGL extension ARB.texture_storage + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.texture_storage to provide a more +Python-friendly API + +Overview (from the spec) + + The texture image specification commands in OpenGL allow each level + to be separately specified with different sizes, formats, types and + so on, and only imposes consistency checks at draw time. This adds + overhead for implementations. + + This extension provides a mechanism for specifying the entire + structure of a texture in a single call, allowing certain + consistency checks and memory allocations to be done up front. Once + specified, the format and dimensions of the image array become + immutable, to simplify completeness checks in the implementation. + + When using this extension, it is no longer possible to supply texture + data using TexImage*. Instead, data can be uploaded using TexSubImage*, + or produced by other means (such as render-to-texture, mipmap generation, + or rendering to a sibling EGLImage). + + This extension has complicated interactions with other extensions. + The goal of most of these interactions is to ensure that a texture + is always mipmap complete (and cube complete for cubemap textures). + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/texture_storage.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.texture_storage import * +from OpenGL.raw.GL.ARB.texture_storage import _EXTENSION_NAME + +def glInitTextureStorageARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/texture_storage_multisample.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/texture_storage_multisample.py new file mode 100644 index 00000000..b71ba01d --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/texture_storage_multisample.py @@ -0,0 +1,37 @@ +'''OpenGL extension ARB.texture_storage_multisample + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.texture_storage_multisample to provide a more +Python-friendly API + +Overview (from the spec) + + The ARB_texture_storage extension and OpenGL 4.2 introduced the concept + of immutable texture objects. With these objects, once their data store + has been sized and allocated, it could not be resized for the lifetime + of the objects (although its content could be updated). OpenGL + implementations may be able to take advantage of the knowledge that the + underlying data store of certain objects cannot be deleted or otherwise + reallocated without destruction of the whole object (normally, a much + heavier weight and less frequent operation). Immutable storage + for all types of textures besides multisample and buffer textures was + introduced by ARB_texture_storage. For completeness, this extension + introduces immutable storage for multisampled textures. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/texture_storage_multisample.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.texture_storage_multisample import * +from OpenGL.raw.GL.ARB.texture_storage_multisample import _EXTENSION_NAME + +def glInitTextureStorageMultisampleARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/texture_swizzle.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/texture_swizzle.py new file mode 100644 index 00000000..2f9c73ce --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/texture_swizzle.py @@ -0,0 +1,46 @@ +'''OpenGL extension ARB.texture_swizzle + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.texture_swizzle to provide a more +Python-friendly API + +Overview (from the spec) + + Classic OpenGL texture formats conflate texture storage and + interpretation, and assume that textures represent color. In + modern applications, a significant quantity of textures don't + represent color, but rather data like shadow maps, normal maps, + page tables, occlusion data, etc.. For the latter class of data, + calling the data "RGBA" is just a convenient mapping of what the + data is onto the current model, but isn't an accurate reflection + of the reality of the data. + + The existing texture formats provide an almost orthogonal set of + data types, sizes, and number of components, but the mappings of + this storage into what the shader or fixed-function pipeline + fetches is very much non-orthogonal. Previous extensions have + added some of the most demanded missing formats, but the problem + has not been solved once and for all. + + This extension provides a mechanism to swizzle the components + of a texture before they are applied according to the texture + environment in fixed-function or as they are returned to the + shader. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/texture_swizzle.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.texture_swizzle import * +from OpenGL.raw.GL.ARB.texture_swizzle import _EXTENSION_NAME + +def glInitTextureSwizzleARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/texture_view.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/texture_view.py new file mode 100644 index 00000000..5b2071e8 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/texture_view.py @@ -0,0 +1,52 @@ +'''OpenGL extension ARB.texture_view + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.texture_view to provide a more +Python-friendly API + +Overview (from the spec) + + This extension allows a texture's data store to be "viewed" in multiple + ways, either reinterpreting the data format/type as a different format/ + type with the same element size, or by clamping the mipmap level range + or array slice range. + + The goals of this extension are to avoid having these alternate views + become shared mutable containers of shared mutable objects, and to add + the views to the API in a minimally invasive way. + + No new object types are added. Conceptually, a texture object is split + into the following parts: + + - A data store holding texel data. + - State describing which portions of the data store to use, and how + to interpret the data elements. + - An embedded sampler object. + - Various other texture parameters. + + With this extension, multiple textures can share a data store and have + different state describing which portions of the data store to use and how + to interpret the data elements. The data store is refcounted and not + destroyed until the last texture sharing it is deleted. + + This extension leverages the ARB_texture_storage concept of an "immutable + texture". Views can only be created of textures created with TexStorage. + + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/texture_view.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.texture_view import * +from OpenGL.raw.GL.ARB.texture_view import _EXTENSION_NAME + +def glInitTextureViewARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/timer_query.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/timer_query.py new file mode 100644 index 00000000..64c951ea --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/timer_query.py @@ -0,0 +1,51 @@ +'''OpenGL extension ARB.timer_query + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.timer_query to provide a more +Python-friendly API + +Overview (from the spec) + + Applications can benefit from accurate timing information in a number of + different ways. During application development, timing information can + help identify application or driver bottlenecks. At run time, + applications can use timing information to dynamically adjust the amount + of detail in a scene to achieve constant frame rates. OpenGL + implementations have historically provided little to no useful timing + information. Applications can get some idea of timing by reading timers + on the CPU, but these timers are not synchronized with the graphics + rendering pipeline. Reading a CPU timer does not guarantee the completion + of a potentially large amount of graphics work accumulated before the + timer is read, and will thus produce wildly inaccurate results. + glFinish() can be used to determine when previous rendering commands have + been completed, but will idle the graphics pipeline and adversely affect + application performance. + + This extension provides a query mechanism that can be used to determine + the amount of time it takes to fully complete a set of GL commands, and + without stalling the rendering pipeline. It uses the query object + mechanisms first introduced in the occlusion query extension, which allow + time intervals to be polled asynchronously by the application. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/timer_query.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.timer_query import * +from OpenGL.raw.GL.ARB.timer_query import _EXTENSION_NAME + +def glInitTimerQueryARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +glGetQueryObjecti64v=wrapper.wrapper(glGetQueryObjecti64v).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetQueryObjectui64v=wrapper.wrapper(glGetQueryObjectui64v).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/transform_feedback2.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/transform_feedback2.py new file mode 100644 index 00000000..6c38fe91 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/transform_feedback2.py @@ -0,0 +1,56 @@ +'''OpenGL extension ARB.transform_feedback2 + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.transform_feedback2 to provide a more +Python-friendly API + +Overview (from the spec) + + The EXT_transform_feedback extension allows applications to capture + primitives to one or more buffer objects when transformed by the GL. + This extension provides a few additional capabilities to these extensions, + making transform feedback mode more useful. + + First, it provides transform feedback objects which encapsulate transform + feedback-related state, allowing applications to replace the entire + transform feedback configuration in a single bind call. Second, it + provides the ability to pause and resume transform feedback operations. + When transform feedback is paused, applications may render without + transform feedback or may use transform feedback with different state and + a different transform feedback object. When transform feedback is + resumed, additional primitives are captured and appended to previously + captured primitives for the object. + + Additionally, this extension provides the ability to draw primitives + captured in transform feedback mode without querying the captured + primitive count. The command DrawTransformFeedback() is equivalent to + glDrawArrays(, 0, ), where is the number of vertices + captured to buffer objects during the last transform feedback capture + operation on the transform feedback object used. This draw operation only + provides a vertex count -- it does not automatically set up vertex array + state or vertex buffer object bindings, which must be done separately by + the application. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/transform_feedback2.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.transform_feedback2 import * +from OpenGL.raw.GL.ARB.transform_feedback2 import _EXTENSION_NAME + +def glInitTransformFeedback2ARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glDeleteTransformFeedbacks.ids size not checked against n +glDeleteTransformFeedbacks=wrapper.wrapper(glDeleteTransformFeedbacks).setInputArraySize( + 'ids', None +) +glGenTransformFeedbacks=wrapper.wrapper(glGenTransformFeedbacks).setOutput( + 'ids',size=lambda x:(x,),pnameArg='n',orPassIn=True +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/transform_feedback3.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/transform_feedback3.py new file mode 100644 index 00000000..5b911363 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/transform_feedback3.py @@ -0,0 +1,75 @@ +'''OpenGL extension ARB.transform_feedback3 + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.transform_feedback3 to provide a more +Python-friendly API + +Overview (from the spec) + + This extension further extends the transform feedback capabilities + provided by the EXT_transform_feedback, NV_transform_feedback, and + NV_transform_feedback2 extensions. Those extensions provided a new + transform feedback mode, where selected vertex attributes can be recorded + to a buffer object for each primitive processed by the GL. + + This extension provides increased flexibility in how vertex attributes can + be written to buffer objects. Previous extensions allowed applications to + record a set of attributes interleaved into a single buffer object + (interleaved mode) or to record into multiple objects, but with only a + single attribute per buffer (separate mode). This extension extends + interleaved mode to write into multiple buffers, with multiple attributes + per buffer. This capability is supported for all three styles of + transform feedback: + + - "EXT"-style GLSL transform feedback (EXT_transform_feedback), where a + list of varyings is provided prior to linking a program object and is + used whenever that program object is used. + + - "NV"-style GLSL transform feedback (NV_transform_feedback), where + "locations" of active varyings are queried after linking and are then + passed to a function that sets the active transform feedback varyings + for the program object. Unlike the "EXT"-style mode, the set of + varyings to capture can be changed without relinking. + + - Transform feedback for fixed-function or assembly vertex/geometry + shaders (NV_transform_feedback), where applications specify a set of + canonical attribute enums/numbers to capture. + + Additionally, this extension adds new support for multiple separate + vertex streams. New geometry shader functionality provided by the + ARB_gpu_shader5 and NV_gpu_program5 extensions allows geometry shaders + to direct each vertex arbitrarily at a specified vertex stream. For + example, a geometry program might write each "regular" vertex it emits + to one vertex stream while writing some per-primitive data it computes + to a second vertex stream. This extension allows applications to + choose a vertex stream for each buffer object it writes to, and allows + the vertices written to each vertex stream to be recorded in separate + buffer objects. Only one stream may be selected for rasterization, + and in the initial implementation, the geometry shader output topology + must be POINTS if multiple streams are used. When geometry shaders + are not used, or when an old geometry shader not writing multiple + streams is used, all vertices produced by the GL are directed at the + stream numbered zero. The set of transform feedback-related query + targets is extended to accommodate multiple vertex streams, so it is + possible to count the number of processed and recorded primitives for + each stream separately. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/transform_feedback3.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.transform_feedback3 import * +from OpenGL.raw.GL.ARB.transform_feedback3 import _EXTENSION_NAME + +def glInitTransformFeedback3ARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +glGetQueryIndexediv=wrapper.wrapper(glGetQueryIndexediv).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/transform_feedback_instanced.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/transform_feedback_instanced.py new file mode 100644 index 00000000..1cf1add3 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/transform_feedback_instanced.py @@ -0,0 +1,36 @@ +'''OpenGL extension ARB.transform_feedback_instanced + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.transform_feedback_instanced to provide a more +Python-friendly API + +Overview (from the spec) + + Multiple instances of geometry may be specified to the GL by calling + functions such as DrawArraysInstanced and DrawElementsInstanced. Further, + the results of a transform feedback operation may be returned to the GL + by calling DrawTransformFeedback, or DrawTransformFeedbackStream. However, + it is not presently possible to draw multiple instances of data + transform feedback without using a query and the resulting round trip from + server to client. + + This extension adds functionality to draw multiple instances of the result + of a transform feedback operation. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/transform_feedback_instanced.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.transform_feedback_instanced import * +from OpenGL.raw.GL.ARB.transform_feedback_instanced import _EXTENSION_NAME + +def glInitTransformFeedbackInstancedARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/transform_feedback_overflow_query.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/transform_feedback_overflow_query.py new file mode 100644 index 00000000..ad75a0ea --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/transform_feedback_overflow_query.py @@ -0,0 +1,29 @@ +'''OpenGL extension ARB.transform_feedback_overflow_query + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.transform_feedback_overflow_query to provide a more +Python-friendly API + +Overview (from the spec) + + This extension adds new query types which can be used to detect overflow + of transform feedback buffers. The new query types are also accepted by + conditional rendering commands. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/transform_feedback_overflow_query.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.transform_feedback_overflow_query import * +from OpenGL.raw.GL.ARB.transform_feedback_overflow_query import _EXTENSION_NAME + +def glInitTransformFeedbackOverflowQueryARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/transpose_matrix.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/transpose_matrix.py new file mode 100644 index 00000000..1e3b484a --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/transpose_matrix.py @@ -0,0 +1,48 @@ +'''OpenGL extension ARB.transpose_matrix + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.transpose_matrix to provide a more +Python-friendly API + +Overview (from the spec) + + New functions and tokens are added allowing application matrices + stored in row major order rather than column major order to be + transferred to the OpenGL implementation. This allows an application + to use standard C-language 2-dimensional arrays (m[row][col]) and + have the array indices match the expected matrix row and column indexes. + These arrays are referred to as transpose matrices since they are + the transpose of the standard matrices passed to OpenGL. + + This extension adds an interface for transfering data to and from the + OpenGL pipeline, it does not change any OpenGL processing or imply any + changes in state representation. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/transpose_matrix.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.transpose_matrix import * +from OpenGL.raw.GL.ARB.transpose_matrix import _EXTENSION_NAME + +def glInitTransposeMatrixARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +glLoadTransposeMatrixfARB=wrapper.wrapper(glLoadTransposeMatrixfARB).setInputArraySize( + 'm', 16 +) +glLoadTransposeMatrixdARB=wrapper.wrapper(glLoadTransposeMatrixdARB).setInputArraySize( + 'm', 16 +) +glMultTransposeMatrixfARB=wrapper.wrapper(glMultTransposeMatrixfARB).setInputArraySize( + 'm', 16 +) +glMultTransposeMatrixdARB=wrapper.wrapper(glMultTransposeMatrixdARB).setInputArraySize( + 'm', 16 +) +### END AUTOGENERATED SECTION diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/uniform_buffer_object.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/uniform_buffer_object.py new file mode 100644 index 00000000..726ed796 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/uniform_buffer_object.py @@ -0,0 +1,155 @@ +'''OpenGL extension ARB.uniform_buffer_object + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.uniform_buffer_object to provide a more +Python-friendly API + +Overview (from the spec) + + This extension introduces the concept of a group of GLSL uniforms + known as a "uniform block", and the API mechanisms to store "uniform + blocks" in GL buffer objects. + + The extension also defines both a standard cross-platform layout in + memory for uniform block data, as well as mechanisms to allow the GL + to optimize the data layout in an implementation-defined manner. + + Prior to this extension, the existing interface for modification of + uniform values allowed modification of large numbers of values using + glUniform* calls, but only for a single uniform name (or a uniform + array) at a time. However, updating uniforms in this manner may not + map well to heterogenous uniform data structures defined for a GL + application and in these cases, the application is forced to either: + + A) restructure their uniform data definitions into arrays + or + B) make an excessive number of calls through the GL interface + to one of the Uniform* variants. + + These solutions have their disadvantages. Solution A imposes + considerable development overhead on the application developer. + Solution B may impose considerable run-time overhead on the + application if the number of uniforms modified in a given frame of + rendering is sufficiently large. + + This extension provides a better alternative to either (A) or (B) by + allowing buffer object backing for the storage associated with all + uniforms of a given GLSL program. + + Storing uniform blocks in buffer objects enables several key use + cases: + + - sharing of uniform data storage between program objects and + between program stages + + - rapid swapping of sets of previously defined uniforms by storing + sets of uniform data on the GL server + + - rapid updates of uniform data from both the client and the server + + The data storage for a uniform block can be declared to use one of + three layouts in memory: packed, shared, or std140. + + - "packed" uniform blocks have an implementation-dependent data + layout for efficiency, and unused uniforms may be eliminated by + the compiler to save space. + + - "shared" uniform blocks, the default layout, have an implementation- + dependent data layout for efficiency, but the layout will be uniquely + determined by the structure of the block, allowing data storage to be + shared across programs. + + - "std140" uniform blocks have a standard cross-platform cross-vendor + layout (see below). Unused uniforms will not be eliminated. + + Any uniforms not declared in a named uniform block are said to + be part of the "default uniform block". + + While uniforms in the default uniform block are updated with + glUniform* entry points and can have static initializers, uniforms + in named uniform blocks are not. Instead, uniform block data is updated + using the routines that update buffer objects and can not use static + initializers. + + Rules and Concepts Guiding this Specification: + + For reference, a uniform has a "uniform index" (subsequently + referred to as "u_index) and also a "uniform location" to + efficiently identify it in the uniform data store of the + implementation. We subsequently refer to this uniform data store of + the implementation as the "uniform database". + + A "uniform block" only has a "uniform block index" used for queries + and connecting the "uniform block" to a buffer object. A "uniform + block" has no "location" because "uniform blocks" are not updated + directly. The buffer object APIs are used instead. + + Properties of Uniforms and uniform blocks: + + a) A uniform is "active" if it exists in the database and has a valid + u_index. + b) A "uniform block" is "active" if it exists in the database and + has a valid ub_index. + c) Uniforms and "uniform blocks" can be inactive because they don't + exist in the source, or because they have been removed by dead + code elimination. + d) An inactive uniform has u_index == INVALID_INDEX. + e) An inactive uniform block has ub_index == INVALID_INDEX. + f) A u_index or ub_index of INVALID_INDEX generates the + INVALID_VALUE error if given as a function argument. + g) The default uniform block, which is not assigned any ub_index, uses a + private, internal data storage, and does not have any buffer object + associated with it. + h) An active uniform that is a member of the default uniform block has + location >= 0 and it has offset == stride == -1. + i) An active uniform that is a member of a named uniform block has + location == -1. + j) A uniform location of -1 is silently ignored if given as a function + argument. + k) Uniform block declarations may not be nested + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/uniform_buffer_object.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.uniform_buffer_object import * +from OpenGL.raw.GL.ARB.uniform_buffer_object import _EXTENSION_NAME + +def glInitUniformBufferObjectARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glGetUniformIndices.uniformNames size not checked against 'uniformCount' +glGetUniformIndices=wrapper.wrapper(glGetUniformIndices).setOutput( + 'uniformIndices',size=_glgets._glget_size_mapping,pnameArg='uniformCount',orPassIn=True +).setInputArraySize( + 'uniformNames', None +) +# OUTPUT glGetActiveUniformsiv.params COMPSIZE(uniformCount, pname) +# INPUT glGetActiveUniformsiv.uniformIndices size not checked against uniformCount +glGetActiveUniformsiv=wrapper.wrapper(glGetActiveUniformsiv).setInputArraySize( + 'uniformIndices', None +) +glGetActiveUniformName=wrapper.wrapper(glGetActiveUniformName).setOutput( + 'length',size=(1,),orPassIn=True +).setOutput( + 'uniformName',size=lambda x:(x,),pnameArg='bufSize',orPassIn=True +) +# INPUT glGetUniformBlockIndex.uniformBlockName size not checked against '' +glGetUniformBlockIndex=wrapper.wrapper(glGetUniformBlockIndex).setInputArraySize( + 'uniformBlockName', None +) +# OUTPUT glGetActiveUniformBlockiv.params COMPSIZE(program, uniformBlockIndex, pname) +glGetActiveUniformBlockName=wrapper.wrapper(glGetActiveUniformBlockName).setOutput( + 'length',size=(1,),orPassIn=True +).setOutput( + 'uniformBlockName',size=lambda x:(x,),pnameArg='bufSize',orPassIn=True +) +glGetIntegeri_v=wrapper.wrapper(glGetIntegeri_v).setOutput( + 'data',size=_glgets._glget_size_mapping,pnameArg='target',orPassIn=True +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/vboimplementation.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/vboimplementation.py new file mode 100644 index 00000000..e4baa6cd --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/vboimplementation.py @@ -0,0 +1,38 @@ +from OpenGL.arrays import vbo +from OpenGL.GL.ARB import vertex_buffer_object +from OpenGL.GL.ARB import uniform_buffer_object +from OpenGL.GL.ARB import texture_buffer_object +from OpenGL.GL.ARB import enhanced_layouts + +class Implementation( vbo.Implementation ): + """OpenGL ARB extension-based implementation of VBO interfaces""" + def __init__( self ): + for name in self.EXPORTED_NAMES: + source = name + if name.startswith( 'GL_'): + source = name + '_ARB' + else: + source = name + 'ARB' + found = False + for source_extension in ( + vertex_buffer_object, + uniform_buffer_object, + texture_buffer_object, + enhanced_layouts, + ): + try: + setattr( self, name, getattr( source_extension, source )) + except AttributeError as err: + try: + setattr( self, name, getattr( source_extension, name )) + except AttributeError as err: + pass + else: + found = True + else: + found =True + break + assert found, name + if self.glGenBuffers: + self.available = True +Implementation.register() diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/vertex_array_bgra.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/vertex_array_bgra.py new file mode 100644 index 00000000..8c81035d --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/vertex_array_bgra.py @@ -0,0 +1,80 @@ +'''OpenGL extension ARB.vertex_array_bgra + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.vertex_array_bgra to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides a single new component format for vertex + arrays to read 4-component unsigned byte vertex attributes with a + BGRA component ordering. + + OpenGL expects vertex arrays containing 4 unsigned bytes per + element to be in the RGBA, STRQ, or XYZW order (reading components + left-to-right in their lower address to higher address order). + Essentially the order the components appear in memory is the order + the components appear in the resulting vertex attribute vector. + + However Direct3D has color (diffuse and specular) vertex arrays + containing 4 unsigned bytes per element that are in a BGRA order + (again reading components left-to-right in their lower address + to higher address order). Direct3D calls this "ARGB" reading the + components in the opposite order (reading components left-to-right + in their higher address to lower address order). This ordering is + generalized in the DirectX 10 by the DXGI_FORMAT_B8G8R8A8_UNORM + format. + + For an OpenGL application to source color data from a vertex + buffer formatted for Direct3D's color array format conventions, + the application is forced to either: + + 1. Rely on a vertex program or shader to swizzle the color components + from the BGRA to conventional RGBA order. + + 2. Re-order the color data components in the vertex buffer from + Direct3D's native BGRA order to OpenGL's native RGBA order. + + Neither option is entirely satisfactory. + + Option 1 means vertex shaders have to be re-written to source colors + differently. If the same vertex shader is used with vertex arrays + configured to source the color as 4 floating-point color components, + the swizzle for BGRA colors stored as 4 unsigned bytes is no longer + appropriate. The shader's swizzling of colors becomes dependent on + the type and number of color components. Ideally the vertex shader + should be independent from the format and component ordering of the + data it sources. + + Option 2 is expensive because vertex buffers may have to be + reformatted prior to use. OpenGL treats the memory for vertex arrays + (whether client-side memory or buffer objects) as essentially untyped + memory and vertex arrays can be stored separately, interleaved, + or even interwoven (where multiple arrays overlap with differing + strides and formats). + + Rather than force a re-ordering of either vertex array components + in memory or a vertex array format-dependent re-ordering of vertex + shader inputs, OpenGL can simply provide a vertex array format that + matches the Direct3D color component ordering. + + This approach mimics that of the EXT_bgra extension for pixel and + texel formats except for vertex instead of image data. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/vertex_array_bgra.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.vertex_array_bgra import * +from OpenGL.raw.GL.ARB.vertex_array_bgra import _EXTENSION_NAME + +def glInitVertexArrayBgraARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/vertex_array_object.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/vertex_array_object.py new file mode 100644 index 00000000..5edda685 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/vertex_array_object.py @@ -0,0 +1,47 @@ +'''OpenGL extension ARB.vertex_array_object + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.vertex_array_object to provide a more +Python-friendly API + +Overview (from the spec) + + This extension introduces named vertex array objects which encapsulate + vertex array state on the client side. These objects allow applications + to rapidly switch between large sets of array state. In addition, layered + libraries can return to the default array state by simply creating and + binding a new vertex array object. + + This extension differs from GL_APPLE_vertex_array_object in that client + memory cannot be accessed through a non-zero vertex array object. It also + differs in that vertex array objects are explicitly not sharable between + contexts. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/vertex_array_object.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.vertex_array_object import * +from OpenGL.raw.GL.ARB.vertex_array_object import _EXTENSION_NAME + +def glInitVertexArrayObjectARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glDeleteVertexArrays.arrays size not checked against n +glDeleteVertexArrays=wrapper.wrapper(glDeleteVertexArrays).setInputArraySize( + 'arrays', None +) +glGenVertexArrays=wrapper.wrapper(glGenVertexArrays).setOutput( + 'arrays',size=lambda x:(x,),pnameArg='n',orPassIn=True +) +### END AUTOGENERATED SECTION + +glGenVertexArrays = wrapper.wrapper(glGenVertexArrays).setOutput( + 'arrays', lambda n, array=None: (n,), 'n', arrayType = arrays.GLuintArray, + orPassIn=True, +) diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/vertex_attrib_64bit.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/vertex_attrib_64bit.py new file mode 100644 index 00000000..498ef6b5 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/vertex_attrib_64bit.py @@ -0,0 +1,84 @@ +'''OpenGL extension ARB.vertex_attrib_64bit + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.vertex_attrib_64bit to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides OpenGL shading language support for vertex shader + inputs with 64-bit floating-point components and OpenGL API support for + specifying the value of those inputs using vertex array or immediate mode + entry points. This builds on the support for general-purpose support for + 64-bit floating-point values in the ARB_gpu_shader_fp64 extension. + + This extension provides a new class of vertex attribute functions, + beginning with "VertexAttribL" ("L" for "long"), that can be used to + specify attributes with 64-bit floating-point components. This extension + provides no automatic type conversion between attribute and shader + variables; single-precision attributes are not automatically converted to + double-precision or vice versa. For shader variables with 64-bit + component types, the "VertexAttribL" functions must be used to specify + attribute values. For other shader variables, the "VertexAttribL" + functions must not be used. If a vertex attribute is specified using the + wrong attribute function, the values of the corresponding shader input are + undefined. This approach requiring matching types is identical to that + used for the "VertexAttribI" functions provided by OpenGL 3.0 and the + EXT_gpu_shader4 extension. + + Additionally, some vertex shader inputs using the wider 64-bit components + may count double against the implementation-dependent limit on the number + of vertex shader attribute vectors. A 64-bit scalar or a two-component + vector consumes only a single generic vertex attribute; three- and + four-component "long" may count as two. This approach is similar to the + one used in the current GL where matrix attributes consume multiple + attributes. + + Note that 64-bit generic vertex attributes were nominally supported + beginning with the introduction of vertex shaders in OpenGL 2.0. However, + the OpenGL Shading Language at the time had no support for 64-bit data + types, so any such values were automatically converted to 32-bit. + + Support for 64-bit floating-point vertex attributes in this extension can + be combined with other extensions. In particular, this extension provides + an entry point that can be used with EXT_direct_state_access to directly + set state for any vertex array object. Also, the related + NV_vertex_attrib_integer_64bit extension provides an entry point to + specify bindless vertex attribute arrays with 64-bit components, integer + or floating-point. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/vertex_attrib_64bit.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.vertex_attrib_64bit import * +from OpenGL.raw.GL.ARB.vertex_attrib_64bit import _EXTENSION_NAME + +def glInitVertexAttrib64BitARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +glVertexAttribL1dv=wrapper.wrapper(glVertexAttribL1dv).setInputArraySize( + 'v', 1 +) +glVertexAttribL2dv=wrapper.wrapper(glVertexAttribL2dv).setInputArraySize( + 'v', 2 +) +glVertexAttribL3dv=wrapper.wrapper(glVertexAttribL3dv).setInputArraySize( + 'v', 3 +) +glVertexAttribL4dv=wrapper.wrapper(glVertexAttribL4dv).setInputArraySize( + 'v', 4 +) +# INPUT glVertexAttribLPointer.pointer size not checked against size +glVertexAttribLPointer=wrapper.wrapper(glVertexAttribLPointer).setInputArraySize( + 'pointer', None +) +glGetVertexAttribLdv=wrapper.wrapper(glGetVertexAttribLdv).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/vertex_attrib_binding.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/vertex_attrib_binding.py new file mode 100644 index 00000000..94d7f371 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/vertex_attrib_binding.py @@ -0,0 +1,61 @@ +'''OpenGL extension ARB.vertex_attrib_binding + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.vertex_attrib_binding to provide a more +Python-friendly API + +Overview (from the spec) + + OpenGL currently supports (at least) 16 vertex attributes and 16 vertex + buffer bindings, with a fixed mapping between vertex attributes and + vertex buffer bindings. This extension allows the application to change + the mapping between attributes and bindings, which can make it more + efficient to update vertex buffer bindings for interleaved vertex formats + where many attributes share the same buffer. + + This extension also separates the vertex binding update from the vertex + attribute format update, which saves applications the effort of + redundantly specifying the same format state over and over. + + Conceptually, this extension splits the state for generic vertex attribute + arrays into: + + - An array of vertex buffer binding points, each of which specifies: + + - a bound buffer object, + + - a starting offset for the vertex attribute data in that buffer object, + + - a stride used by all attributes using that binding point, and + + - a frequency divisor used by all attributes using that binding point. + + - An array of generic vertex attribute format information records, each of + which specifies: + + - a reference to one of the new buffer binding points above, + + - a component count and format, and a normalization flag for the + attribute data, and + + - the offset of the attribute data relative to the base offset of each + vertex found at the associated binding point. + + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/vertex_attrib_binding.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.vertex_attrib_binding import * +from OpenGL.raw.GL.ARB.vertex_attrib_binding import _EXTENSION_NAME + +def glInitVertexAttribBindingARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/vertex_blend.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/vertex_blend.py new file mode 100644 index 00000000..1b077a58 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/vertex_blend.py @@ -0,0 +1,77 @@ +'''OpenGL extension ARB.vertex_blend + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.vertex_blend to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides the ability to replace the single + modelview transformation with a set of n vertex units. (Where + n is constrained to an implementation defined maximum.) Each + unit has its own modelview transform matrix. For each unit, + there is a current weight associated with the vertex. When + this extension is enabled the vertices are transformed by + the modelview matrices of all of the enabled units. Afterward, + these results are scaled by the weights for the respective + units and then summed to create the eye-space vertex. A + similar procedure is followed for the normals, except they + are transformed by the inverse transpose of the modelview + matrices. + + This extension is an orthoganalized version of functionality + already provided by other 3D graphics API's. + + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/vertex_blend.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.vertex_blend import * +from OpenGL.raw.GL.ARB.vertex_blend import _EXTENSION_NAME + +def glInitVertexBlendARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glWeightbvARB.weights size not checked against size +glWeightbvARB=wrapper.wrapper(glWeightbvARB).setInputArraySize( + 'weights', None +) +# INPUT glWeightsvARB.weights size not checked against size +glWeightsvARB=wrapper.wrapper(glWeightsvARB).setInputArraySize( + 'weights', None +) +# INPUT glWeightivARB.weights size not checked against size +glWeightivARB=wrapper.wrapper(glWeightivARB).setInputArraySize( + 'weights', None +) +# INPUT glWeightfvARB.weights size not checked against size +glWeightfvARB=wrapper.wrapper(glWeightfvARB).setInputArraySize( + 'weights', None +) +# INPUT glWeightdvARB.weights size not checked against size +glWeightdvARB=wrapper.wrapper(glWeightdvARB).setInputArraySize( + 'weights', None +) +# INPUT glWeightubvARB.weights size not checked against size +glWeightubvARB=wrapper.wrapper(glWeightubvARB).setInputArraySize( + 'weights', None +) +# INPUT glWeightusvARB.weights size not checked against size +glWeightusvARB=wrapper.wrapper(glWeightusvARB).setInputArraySize( + 'weights', None +) +# INPUT glWeightuivARB.weights size not checked against size +glWeightuivARB=wrapper.wrapper(glWeightuivARB).setInputArraySize( + 'weights', None +) +# INPUT glWeightPointerARB.pointer size not checked against 'type,stride' +glWeightPointerARB=wrapper.wrapper(glWeightPointerARB).setInputArraySize( + 'pointer', None +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/vertex_buffer_object.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/vertex_buffer_object.py new file mode 100644 index 00000000..a6743144 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/vertex_buffer_object.py @@ -0,0 +1,167 @@ +'''OpenGL extension ARB.vertex_buffer_object + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.vertex_buffer_object to provide a more +Python-friendly API + +Overview (from the spec) + + This extension defines an interface that allows various types of data + (especially vertex array data) to be cached in high-performance + graphics memory on the server, thereby increasing the rate of data + transfers. + + Chunks of data are encapsulated within "buffer objects", which + conceptually are nothing more than arrays of bytes, just like any + chunk of memory. An API is provided whereby applications can read + from or write to buffers, either via the GL itself (glBufferData, + glBufferSubData, glGetBufferSubData) or via a pointer to the memory. + + The latter technique is known as "mapping" a buffer. When an + application maps a buffer, it is given a pointer to the memory. When + the application finishes reading from or writing to the memory, it is + required to "unmap" the buffer before it is once again permitted to + use that buffer as a GL data source or sink. Mapping often allows + applications to eliminate an extra data copy otherwise required to + access the buffer, thereby enhancing performance. In addition, + requiring that applications unmap the buffer to use it as a data + source or sink ensures that certain classes of latent synchronization + bugs cannot occur. + + Although this extension only defines hooks for buffer objects to be + used with OpenGL's vertex array APIs, the API defined in this + extension permits buffer objects to be used as either data sources or + sinks for any GL command that takes a pointer as an argument. + Normally, in the absence of this extension, a pointer passed into the + GL is simply a pointer to the user's data. This extension defines + a mechanism whereby this pointer is used not as a pointer to the data + itself, but as an offset into a currently bound buffer object. The + buffer object ID zero is reserved, and when buffer object zero is + bound to a given target, the commands affected by that buffer binding + behave normally. When a nonzero buffer ID is bound, then the pointer + represents an offset. + + In the case of vertex arrays, this extension defines not merely one + binding for all attributes, but a separate binding for each + individual attribute. As a result, applications can source their + attributes from multiple buffers. An application might, for example, + have a model with constant texture coordinates and variable geometry. + The texture coordinates might be retrieved from a buffer object with + the usage mode "STATIC_DRAW", indicating to the GL that the + application does not expect to update the contents of the buffer + frequently or even at all, while the vertices might be retrieved from + a buffer object with the usage mode "STREAM_DRAW", indicating that + the vertices will be updated on a regular basis. + + In addition, a binding is defined by which applications can source + index data (as used by DrawElements, DrawRangeElements, and + MultiDrawElements) from a buffer object. On some platforms, this + enables very large models to be rendered with no more than a few + small commands to the graphics device. + + It is expected that a future extension will allow sourcing pixel data + from and writing pixel data to a buffer object. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/vertex_buffer_object.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.vertex_buffer_object import * +from OpenGL.raw.GL.ARB.vertex_buffer_object import _EXTENSION_NAME + +def glInitVertexBufferObjectARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glDeleteBuffersARB.buffers size not checked against n +glDeleteBuffersARB=wrapper.wrapper(glDeleteBuffersARB).setInputArraySize( + 'buffers', None +) +glGenBuffersARB=wrapper.wrapper(glGenBuffersARB).setOutput( + 'buffers',size=lambda x:(x,),pnameArg='n',orPassIn=True +) +# INPUT glBufferDataARB.data size not checked against size +glBufferDataARB=wrapper.wrapper(glBufferDataARB).setInputArraySize( + 'data', None +) +# INPUT glBufferSubDataARB.data size not checked against size +glBufferSubDataARB=wrapper.wrapper(glBufferSubDataARB).setInputArraySize( + 'data', None +) +glGetBufferSubDataARB=wrapper.wrapper(glGetBufferSubDataARB).setOutput( + 'data',size=lambda x:(x,),pnameArg='size',orPassIn=True +) +glGetBufferParameterivARB=wrapper.wrapper(glGetBufferParameterivARB).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetBufferPointervARB=wrapper.wrapper(glGetBufferPointervARB).setOutput( + 'params',size=(1,),orPassIn=True +) +### END AUTOGENERATED SECTION +from OpenGL.lazywrapper import lazy as _lazy +from OpenGL.arrays import ArrayDatatype +from OpenGL._bytes import long,integer_types + +@_lazy( glBufferDataARB ) +def glBufferDataARB( baseOperation, target, size, data=None, usage=None ): + """Copy given data into the currently bound vertex-buffer-data object + + target -- the symbolic constant indicating which buffer type is intended + size -- if provided, the count-in-bytes of the array + data -- data-pointer to be used, may be None to initialize without + copying over a data-set + usage -- hint to the driver as to how to set up access to the buffer + + Note: parameter "size" can be omitted, which makes the signature + glBufferData( target, data, usage ) + instead of: + glBufferData( target, size, data, usage ) + """ + if usage is None: + usage = data + data = size + size = None + data = ArrayDatatype.asArray( data ) + if size is None: + size = ArrayDatatype.arrayByteCount( data ) + return baseOperation( target, size, data, usage ) + +@_lazy( glBufferSubDataARB ) +def glBufferSubDataARB( baseOperation, target, offset, size=None, data=None ): + """Copy subset of data into the currently bound vertex-buffer-data object + + target -- the symbolic constant indicating which buffer type is intended + offset -- offset from beginning of buffer at which to copy bytes + size -- the count-in-bytes of the array (if an int/long), if None, + calculate size from data, if an array and data is None, use as + data (i.e. the parameter can be omitted and calculated) + data -- data-pointer to be used, may be None to initialize without + copying over a data-set + + Note that if size is not an int/long it is considered to be data + *iff* data is None + """ + if size is None: + if data is None: + raise TypeError( "Need data or size" ) + elif (not isinstance( size, integer_types)) and (data is None): + data = size + size = None + try: + if size is not None: + size = int( size ) + except TypeError as err: + if data is not None: + raise TypeError( + """Expect an integer size *or* a data-array, not both""" + ) + data = size + size = None + data = ArrayDatatype.asArray( data ) + if size is None: + size = ArrayDatatype.arrayByteCount( data ) + return baseOperation( target, offset, size, data ) diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/vertex_program.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/vertex_program.py new file mode 100644 index 00000000..4955eade --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/vertex_program.py @@ -0,0 +1,235 @@ +'''OpenGL extension ARB.vertex_program + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.vertex_program to provide a more +Python-friendly API + +Overview (from the spec) + + Unextended OpenGL mandates a certain set of configurable per-vertex + computations defining vertex transformation, texture coordinate generation + and transformation, and lighting. Several extensions have added further + per-vertex computations to OpenGL. For example, extensions have defined + new texture coordinate generation modes (ARB_texture_cube_map, + NV_texgen_reflection, NV_texgen_emboss), new vertex transformation modes + (ARB_vertex_blend, EXT_vertex_weighting), new lighting modes (OpenGL 1.2's + separate specular and rescale normal functionality), several modes for fog + distance generation (NV_fog_distance), and eye-distance point size + attenuation (EXT/ARB_point_parameters). + + Each such extension adds a small set of relatively inflexible + per-vertex computations. + + This inflexibility is in contrast to the typical flexibility provided by + the underlying programmable floating point engines (whether micro-coded + vertex engines, DSPs, or CPUs) that are traditionally used to implement + OpenGL's per-vertex computations. The purpose of this extension is to + expose to the OpenGL application writer a significant degree of per-vertex + programmability for computing vertex parameters. + + For the purposes of discussing this extension, a vertex program is a + sequence of floating-point 4-component vector operations that determines + how a set of program parameters (defined outside of OpenGL's Begin/End + pair) and an input set of per-vertex parameters are transformed to a set + of per-vertex result parameters. + + The per-vertex computations for standard OpenGL given a particular set of + lighting and texture coordinate generation modes (along with any state for + extensions defining per-vertex computations) is, in essence, a vertex + program. However, the sequence of operations is defined implicitly by the + current OpenGL state settings rather than defined explicitly as a sequence + of instructions. + + This extension provides an explicit mechanism for defining vertex program + instruction sequences for application-defined vertex programs. In order + to define such vertex programs, this extension defines a vertex + programming model including a floating-point 4-component vector + instruction set and a relatively large set of floating-point 4-component + registers. + + The extension's vertex programming model is designed for efficient + hardware implementation and to support a wide variety of vertex programs. + By design, the entire set of existing vertex programs defined by existing + OpenGL per-vertex computation extensions can be implemented using the + extension's vertex programming model. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/vertex_program.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.vertex_program import * +from OpenGL.raw.GL.ARB.vertex_program import _EXTENSION_NAME + +def glInitVertexProgramARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +glVertexAttrib1dvARB=wrapper.wrapper(glVertexAttrib1dvARB).setInputArraySize( + 'v', 1 +) +glVertexAttrib1fvARB=wrapper.wrapper(glVertexAttrib1fvARB).setInputArraySize( + 'v', 1 +) +glVertexAttrib1svARB=wrapper.wrapper(glVertexAttrib1svARB).setInputArraySize( + 'v', 1 +) +glVertexAttrib2dvARB=wrapper.wrapper(glVertexAttrib2dvARB).setInputArraySize( + 'v', 2 +) +glVertexAttrib2fvARB=wrapper.wrapper(glVertexAttrib2fvARB).setInputArraySize( + 'v', 2 +) +glVertexAttrib2svARB=wrapper.wrapper(glVertexAttrib2svARB).setInputArraySize( + 'v', 2 +) +glVertexAttrib3dvARB=wrapper.wrapper(glVertexAttrib3dvARB).setInputArraySize( + 'v', 3 +) +glVertexAttrib3fvARB=wrapper.wrapper(glVertexAttrib3fvARB).setInputArraySize( + 'v', 3 +) +glVertexAttrib3svARB=wrapper.wrapper(glVertexAttrib3svARB).setInputArraySize( + 'v', 3 +) +glVertexAttrib4NbvARB=wrapper.wrapper(glVertexAttrib4NbvARB).setInputArraySize( + 'v', 4 +) +glVertexAttrib4NivARB=wrapper.wrapper(glVertexAttrib4NivARB).setInputArraySize( + 'v', 4 +) +glVertexAttrib4NsvARB=wrapper.wrapper(glVertexAttrib4NsvARB).setInputArraySize( + 'v', 4 +) +glVertexAttrib4NubvARB=wrapper.wrapper(glVertexAttrib4NubvARB).setInputArraySize( + 'v', 4 +) +glVertexAttrib4NuivARB=wrapper.wrapper(glVertexAttrib4NuivARB).setInputArraySize( + 'v', 4 +) +glVertexAttrib4NusvARB=wrapper.wrapper(glVertexAttrib4NusvARB).setInputArraySize( + 'v', 4 +) +glVertexAttrib4bvARB=wrapper.wrapper(glVertexAttrib4bvARB).setInputArraySize( + 'v', 4 +) +glVertexAttrib4dvARB=wrapper.wrapper(glVertexAttrib4dvARB).setInputArraySize( + 'v', 4 +) +glVertexAttrib4fvARB=wrapper.wrapper(glVertexAttrib4fvARB).setInputArraySize( + 'v', 4 +) +glVertexAttrib4ivARB=wrapper.wrapper(glVertexAttrib4ivARB).setInputArraySize( + 'v', 4 +) +glVertexAttrib4svARB=wrapper.wrapper(glVertexAttrib4svARB).setInputArraySize( + 'v', 4 +) +glVertexAttrib4ubvARB=wrapper.wrapper(glVertexAttrib4ubvARB).setInputArraySize( + 'v', 4 +) +glVertexAttrib4uivARB=wrapper.wrapper(glVertexAttrib4uivARB).setInputArraySize( + 'v', 4 +) +glVertexAttrib4usvARB=wrapper.wrapper(glVertexAttrib4usvARB).setInputArraySize( + 'v', 4 +) +# INPUT glVertexAttribPointerARB.pointer size not checked against 'size,type,stride' +glVertexAttribPointerARB=wrapper.wrapper(glVertexAttribPointerARB).setInputArraySize( + 'pointer', None +) +# INPUT glProgramStringARB.string size not checked against len +glProgramStringARB=wrapper.wrapper(glProgramStringARB).setInputArraySize( + 'string', None +) +# INPUT glDeleteProgramsARB.programs size not checked against n +glDeleteProgramsARB=wrapper.wrapper(glDeleteProgramsARB).setInputArraySize( + 'programs', None +) +glGenProgramsARB=wrapper.wrapper(glGenProgramsARB).setOutput( + 'programs',size=lambda x:(x,),pnameArg='n',orPassIn=True +) +glProgramEnvParameter4dvARB=wrapper.wrapper(glProgramEnvParameter4dvARB).setInputArraySize( + 'params', 4 +) +glProgramEnvParameter4fvARB=wrapper.wrapper(glProgramEnvParameter4fvARB).setInputArraySize( + 'params', 4 +) +glProgramLocalParameter4dvARB=wrapper.wrapper(glProgramLocalParameter4dvARB).setInputArraySize( + 'params', 4 +) +glProgramLocalParameter4fvARB=wrapper.wrapper(glProgramLocalParameter4fvARB).setInputArraySize( + 'params', 4 +) +glGetProgramEnvParameterdvARB=wrapper.wrapper(glGetProgramEnvParameterdvARB).setOutput( + 'params',size=(4,),orPassIn=True +) +glGetProgramEnvParameterfvARB=wrapper.wrapper(glGetProgramEnvParameterfvARB).setOutput( + 'params',size=(4,),orPassIn=True +) +glGetProgramLocalParameterdvARB=wrapper.wrapper(glGetProgramLocalParameterdvARB).setOutput( + 'params',size=(4,),orPassIn=True +) +glGetProgramLocalParameterfvARB=wrapper.wrapper(glGetProgramLocalParameterfvARB).setOutput( + 'params',size=(4,),orPassIn=True +) +glGetProgramivARB=wrapper.wrapper(glGetProgramivARB).setOutput( + 'params',size=(1,),orPassIn=True +) +# OUTPUT glGetProgramStringARB.string COMPSIZE(target, pname) +glGetVertexAttribdvARB=wrapper.wrapper(glGetVertexAttribdvARB).setOutput( + 'params',size=(4,),orPassIn=True +) +glGetVertexAttribfvARB=wrapper.wrapper(glGetVertexAttribfvARB).setOutput( + 'params',size=(4,),orPassIn=True +) +glGetVertexAttribivARB=wrapper.wrapper(glGetVertexAttribivARB).setOutput( + 'params',size=(4,),orPassIn=True +) +glGetVertexAttribPointervARB=wrapper.wrapper(glGetVertexAttribPointervARB).setOutput( + 'pointer',size=(1,),orPassIn=True +) +### END AUTOGENERATED SECTION +from OpenGL.lazywrapper import lazy as _lazy + +from OpenGL import converters, error, contextdata +from OpenGL.arrays.arraydatatype import ArrayDatatype +# Note: sizes here are == the only documented sizes I could find, +# may need a lookup table some day... + +@_lazy( glVertexAttribPointerARB ) +def glVertexAttribPointerARB( + baseOperation, index, size, type, + normalized, stride, pointer, +): + """Set an attribute pointer for a given shader (index) + + index -- the index of the generic vertex to bind, see + glGetAttribLocation for retrieval of the value, + note that index is a global variable, not per-shader + size -- number of basic elements per record, 1,2,3, or 4 + type -- enum constant for data-type + normalized -- whether to perform int to float + normalization on integer-type values + stride -- stride in machine units (bytes) between + consecutive records, normally used to create + "interleaved" arrays + pointer -- data-pointer which provides the data-values, + normally a vertex-buffer-object or offset into the + same. + + This implementation stores a copy of the data-pointer + in the contextdata structure in order to prevent null- + reference errors in the renderer. + """ + array = ArrayDatatype.asArray( pointer, type ) + key = ('vertex-attrib',index) + contextdata.setValue( key, array ) + return baseOperation( + index, size, type, + normalized, stride, + ArrayDatatype.voidDataPointer( array ) + ) diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/vertex_shader.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/vertex_shader.py new file mode 100644 index 00000000..c5aee8c3 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/vertex_shader.py @@ -0,0 +1,157 @@ +'''OpenGL extension ARB.vertex_shader + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.vertex_shader to provide a more +Python-friendly API + +Overview (from the spec) + + This extension adds programmable vertex level processing to OpenGL. The + application can write vertex shaders in a high level language as defined + in the OpenGL Shading Language specification. The language itself is not + discussed here. A vertex shader replaces the transformation, texture + coordinate generation and lighting parts of OpenGL, and it also adds + texture access at the vertex level. Furthermore, management of vertex + shader objects and loading generic attributes are discussed. A vertex + shader object, attached to a program object, can be compiled and linked + to produce an executable that runs on the vertex processor in OpenGL. + This extension also defines how such an executable interacts with the + fixed functionality vertex processing of OpenGL 1.4. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/vertex_shader.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.vertex_shader import * +from OpenGL.raw.GL.ARB.vertex_shader import _EXTENSION_NAME + +def glInitVertexShaderARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +glVertexAttrib1fvARB=wrapper.wrapper(glVertexAttrib1fvARB).setInputArraySize( + 'v', 1 +) +glVertexAttrib1svARB=wrapper.wrapper(glVertexAttrib1svARB).setInputArraySize( + 'v', 1 +) +glVertexAttrib1dvARB=wrapper.wrapper(glVertexAttrib1dvARB).setInputArraySize( + 'v', 1 +) +glVertexAttrib2fvARB=wrapper.wrapper(glVertexAttrib2fvARB).setInputArraySize( + 'v', 2 +) +glVertexAttrib2svARB=wrapper.wrapper(glVertexAttrib2svARB).setInputArraySize( + 'v', 2 +) +glVertexAttrib2dvARB=wrapper.wrapper(glVertexAttrib2dvARB).setInputArraySize( + 'v', 2 +) +glVertexAttrib3fvARB=wrapper.wrapper(glVertexAttrib3fvARB).setInputArraySize( + 'v', 3 +) +glVertexAttrib3svARB=wrapper.wrapper(glVertexAttrib3svARB).setInputArraySize( + 'v', 3 +) +glVertexAttrib3dvARB=wrapper.wrapper(glVertexAttrib3dvARB).setInputArraySize( + 'v', 3 +) +glVertexAttrib4fvARB=wrapper.wrapper(glVertexAttrib4fvARB).setInputArraySize( + 'v', 4 +) +glVertexAttrib4svARB=wrapper.wrapper(glVertexAttrib4svARB).setInputArraySize( + 'v', 4 +) +glVertexAttrib4dvARB=wrapper.wrapper(glVertexAttrib4dvARB).setInputArraySize( + 'v', 4 +) +glVertexAttrib4ivARB=wrapper.wrapper(glVertexAttrib4ivARB).setInputArraySize( + 'v', 4 +) +glVertexAttrib4bvARB=wrapper.wrapper(glVertexAttrib4bvARB).setInputArraySize( + 'v', 4 +) +glVertexAttrib4ubvARB=wrapper.wrapper(glVertexAttrib4ubvARB).setInputArraySize( + 'v', 4 +) +glVertexAttrib4usvARB=wrapper.wrapper(glVertexAttrib4usvARB).setInputArraySize( + 'v', 4 +) +glVertexAttrib4uivARB=wrapper.wrapper(glVertexAttrib4uivARB).setInputArraySize( + 'v', 4 +) +glVertexAttrib4NbvARB=wrapper.wrapper(glVertexAttrib4NbvARB).setInputArraySize( + 'v', 4 +) +glVertexAttrib4NsvARB=wrapper.wrapper(glVertexAttrib4NsvARB).setInputArraySize( + 'v', 4 +) +glVertexAttrib4NivARB=wrapper.wrapper(glVertexAttrib4NivARB).setInputArraySize( + 'v', 4 +) +glVertexAttrib4NubvARB=wrapper.wrapper(glVertexAttrib4NubvARB).setInputArraySize( + 'v', 4 +) +glVertexAttrib4NusvARB=wrapper.wrapper(glVertexAttrib4NusvARB).setInputArraySize( + 'v', 4 +) +glVertexAttrib4NuivARB=wrapper.wrapper(glVertexAttrib4NuivARB).setInputArraySize( + 'v', 4 +) +# INPUT glVertexAttribPointerARB.pointer size not checked against 'size,type,stride' +glVertexAttribPointerARB=wrapper.wrapper(glVertexAttribPointerARB).setInputArraySize( + 'pointer', None +) +glGetActiveAttribARB=wrapper.wrapper(glGetActiveAttribARB).setOutput( + 'length',size=(1,),orPassIn=True +).setOutput( + 'name',size=lambda x:(x,),pnameArg='maxLength',orPassIn=True +).setOutput( + 'size',size=(1,),orPassIn=True +).setOutput( + 'type',size=(1,),orPassIn=True +) +glGetVertexAttribdvARB=wrapper.wrapper(glGetVertexAttribdvARB).setOutput( + 'params',size=(4,),orPassIn=True +) +glGetVertexAttribfvARB=wrapper.wrapper(glGetVertexAttribfvARB).setOutput( + 'params',size=(4,),orPassIn=True +) +glGetVertexAttribivARB=wrapper.wrapper(glGetVertexAttribivARB).setOutput( + 'params',size=(4,),orPassIn=True +) +glGetVertexAttribPointervARB=wrapper.wrapper(glGetVertexAttribPointervARB).setOutput( + 'pointer',size=(1,),orPassIn=True +) +### END AUTOGENERATED SECTION +from OpenGL._bytes import bytes, _NULL_8_BYTE, as_8_bit +from OpenGL.lazywrapper import lazy as _lazy +from OpenGL.GL.ARB.shader_objects import glGetObjectParameterivARB + +@_lazy( glGetActiveAttribARB ) +def glGetActiveAttribARB(baseOperation, program, index): + """Retrieve the name, size and type of the uniform of the index in the program""" + max_index = int(glGetObjectParameterivARB( program, GL_OBJECT_ACTIVE_ATTRIBUTES_ARB )) + length = int(glGetObjectParameterivARB( program, GL_OBJECT_ACTIVE_ATTRIBUTE_MAX_LENGTH_ARB)) + if index < max_index and index >= 0 and length > 0: + length,name,size,type = baseOperation( program, index ) + if hasattr(name,'tostring'): + name = name.tostring().rstrip(b'\000') + elif hasattr(name,'value'): + name = name.value + return name,size,type + raise IndexError('index out of range from zero to %i' % (max_index - 1, )) + +@_lazy( glGetAttribLocationARB ) +def glGetAttribLocationARB( baseOperation, program, name ): + """Check that name is a string with a null byte at the end of it""" + if not name: + raise ValueError( """Non-null name required""" ) + name = as_8_bit( name ) + if name[-1] != _NULL_8_BYTE: + name = name + _NULL_8_BYTE + return baseOperation( program, name ) diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/vertex_type_10f_11f_11f_rev.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/vertex_type_10f_11f_11f_rev.py new file mode 100644 index 00000000..2e860851 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/vertex_type_10f_11f_11f_rev.py @@ -0,0 +1,35 @@ +'''OpenGL extension ARB.vertex_type_10f_11f_11f_rev + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.vertex_type_10f_11f_11f_rev to provide a more +Python-friendly API + +Overview (from the spec) + + This extension adds the following data format: + + A new vertex attribute data format: a packed 11.11.10 unsigned + float vertex data format. This vertex data format can be used + to describe a compressed 3 component stream of values that can + be represented by 10- or 11-bit unsigned floating point values. + + The UNSIGNED_INT_10F_11F_11F_REV vertex attribute type is + equivalent to the R11F_G11F_B10F texture internal format. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/vertex_type_10f_11f_11f_rev.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.vertex_type_10f_11f_11f_rev import * +from OpenGL.raw.GL.ARB.vertex_type_10f_11f_11f_rev import _EXTENSION_NAME + +def glInitVertexType10F11F11FRevARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/vertex_type_2_10_10_10_rev.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/vertex_type_2_10_10_10_rev.py new file mode 100644 index 00000000..524a45c2 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/vertex_type_2_10_10_10_rev.py @@ -0,0 +1,91 @@ +'''OpenGL extension ARB.vertex_type_2_10_10_10_rev + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.vertex_type_2_10_10_10_rev to provide a more +Python-friendly API + +Overview (from the spec) + + This extension adds the following data formats: + + Two new vertex attribute data formats: a signed 2.10.10.10 and an + unsigned 2.10.10.10 vertex data format. These vertex data formats + describe a 4 component stream which can be used to store normals or + other attributes in a quantized form. Normals, tangents, binormals + and other vertex attributes can often be specified at reduced + precision without introducing noticeable artifacts, reducing the + amount of memory and memory bandwidth they consume. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/vertex_type_2_10_10_10_rev.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.vertex_type_2_10_10_10_rev import * +from OpenGL.raw.GL.ARB.vertex_type_2_10_10_10_rev import _EXTENSION_NAME + +def glInitVertexType2101010RevARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +glVertexAttribP1uiv=wrapper.wrapper(glVertexAttribP1uiv).setInputArraySize( + 'value', 1 +) +glVertexAttribP2uiv=wrapper.wrapper(glVertexAttribP2uiv).setInputArraySize( + 'value', 1 +) +glVertexAttribP3uiv=wrapper.wrapper(glVertexAttribP3uiv).setInputArraySize( + 'value', 1 +) +glVertexAttribP4uiv=wrapper.wrapper(glVertexAttribP4uiv).setInputArraySize( + 'value', 1 +) +glVertexP2uiv=wrapper.wrapper(glVertexP2uiv).setInputArraySize( + 'value', 1 +) +glVertexP3uiv=wrapper.wrapper(glVertexP3uiv).setInputArraySize( + 'value', 1 +) +glVertexP4uiv=wrapper.wrapper(glVertexP4uiv).setInputArraySize( + 'value', 1 +) +glTexCoordP1uiv=wrapper.wrapper(glTexCoordP1uiv).setInputArraySize( + 'coords', 1 +) +glTexCoordP2uiv=wrapper.wrapper(glTexCoordP2uiv).setInputArraySize( + 'coords', 1 +) +glTexCoordP3uiv=wrapper.wrapper(glTexCoordP3uiv).setInputArraySize( + 'coords', 1 +) +glTexCoordP4uiv=wrapper.wrapper(glTexCoordP4uiv).setInputArraySize( + 'coords', 1 +) +glMultiTexCoordP1uiv=wrapper.wrapper(glMultiTexCoordP1uiv).setInputArraySize( + 'coords', 1 +) +glMultiTexCoordP2uiv=wrapper.wrapper(glMultiTexCoordP2uiv).setInputArraySize( + 'coords', 1 +) +glMultiTexCoordP3uiv=wrapper.wrapper(glMultiTexCoordP3uiv).setInputArraySize( + 'coords', 1 +) +glMultiTexCoordP4uiv=wrapper.wrapper(glMultiTexCoordP4uiv).setInputArraySize( + 'coords', 1 +) +glNormalP3uiv=wrapper.wrapper(glNormalP3uiv).setInputArraySize( + 'coords', 1 +) +glColorP3uiv=wrapper.wrapper(glColorP3uiv).setInputArraySize( + 'color', 1 +) +glColorP4uiv=wrapper.wrapper(glColorP4uiv).setInputArraySize( + 'color', 1 +) +glSecondaryColorP3uiv=wrapper.wrapper(glSecondaryColorP3uiv).setInputArraySize( + 'color', 1 +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/viewport_array.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/viewport_array.py new file mode 100644 index 00000000..cfd9833a --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/viewport_array.py @@ -0,0 +1,72 @@ +'''OpenGL extension ARB.viewport_array + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.viewport_array to provide a more +Python-friendly API + +Overview (from the spec) + + OpenGL is modeled on a pipeline of operations. The final stage in this + pipeline before rasterization is the viewport transformation. This stage + transforms vertices from view space into window coordinates and allows the + application to specify a rectangular region of screen space into which + OpenGL should draw primitives. Unextended OpenGL implementations provide a + single viewport per context. In order to draw primitives into multiple + viewports, the OpenGL viewport may be changed between several draw calls. + With the advent of Geometry Shaders, it has become possible for an + application to amplify geometry and produce multiple output primitives + for each primitive input to the Geometry Shader. It is possible to direct + these primitives to render into a selected render target. However, all + render targets share the same, global OpenGL viewport. + + This extension enhances OpenGL by providing a mechanism to expose multiple + viewports. Each viewport is specified as a rectangle. The destination + viewport may be selected per-primitive by the geometry shader. This allows + the Geometry Shader to produce different versions of primitives destined + for separate viewport rectangles on the same surface. Additionally, when + combined with multiple framebuffer attachments, it allows a different + viewport rectangle to be selected for each. This extension also exposes a + separate scissor rectangle for each viewport. Finally, the viewport bounds + are now floating point quantities allowing fractional pixel offsets to be + applied during the viewport transform. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/viewport_array.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.viewport_array import * +from OpenGL.raw.GL.ARB.viewport_array import _EXTENSION_NAME + +def glInitViewportArrayARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glViewportArrayv.v size not checked against 'count' +glViewportArrayv=wrapper.wrapper(glViewportArrayv).setInputArraySize( + 'v', None +) +glViewportIndexedfv=wrapper.wrapper(glViewportIndexedfv).setInputArraySize( + 'v', 4 +) +# INPUT glScissorArrayv.v size not checked against 'count' +glScissorArrayv=wrapper.wrapper(glScissorArrayv).setInputArraySize( + 'v', None +) +glScissorIndexedv=wrapper.wrapper(glScissorIndexedv).setInputArraySize( + 'v', 4 +) +# INPUT glDepthRangeArrayv.v size not checked against 'count' +glDepthRangeArrayv=wrapper.wrapper(glDepthRangeArrayv).setInputArraySize( + 'v', None +) +glGetFloati_v=wrapper.wrapper(glGetFloati_v).setOutput( + 'data',size=_glgets._glget_size_mapping,pnameArg='target',orPassIn=True +) +glGetDoublei_v=wrapper.wrapper(glGetDoublei_v).setOutput( + 'data',size=_glgets._glget_size_mapping,pnameArg='target',orPassIn=True +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/window_pos.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/window_pos.py new file mode 100644 index 00000000..ae1e7bda --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARB/window_pos.py @@ -0,0 +1,66 @@ +'''OpenGL extension ARB.window_pos + +This module customises the behaviour of the +OpenGL.raw.GL.ARB.window_pos to provide a more +Python-friendly API + +Overview (from the spec) + + In order to set the current raster position to a specific window + coordinate with the RasterPos command, the modelview matrix, projection + matrix and viewport must be set very carefully. Furthermore, if the + desired window coordinate is outside of the window's bounds one must rely + on a subtle side-effect of the Bitmap command in order to avoid frustum + clipping. + + This extension provides a set of functions to directly set the current + raster position in window coordinates, bypassing the modelview matrix, the + projection matrix and the viewport-to-window mapping. Furthermore, clip + testing is not performed, so that the current raster position is always + valid. + + This greatly simplifies the process of setting the current raster position + to a specific window coordinate prior to calling DrawPixels, CopyPixels or + Bitmap. Many matrix operations can be avoided when mixing 2D and 3D + rendering. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/window_pos.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ARB.window_pos import * +from OpenGL.raw.GL.ARB.window_pos import _EXTENSION_NAME + +def glInitWindowPosARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +glWindowPos2dvARB=wrapper.wrapper(glWindowPos2dvARB).setInputArraySize( + 'v', 2 +) +glWindowPos2fvARB=wrapper.wrapper(glWindowPos2fvARB).setInputArraySize( + 'v', 2 +) +glWindowPos2ivARB=wrapper.wrapper(glWindowPos2ivARB).setInputArraySize( + 'v', 2 +) +glWindowPos2svARB=wrapper.wrapper(glWindowPos2svARB).setInputArraySize( + 'v', 2 +) +glWindowPos3dvARB=wrapper.wrapper(glWindowPos3dvARB).setInputArraySize( + 'v', 3 +) +glWindowPos3fvARB=wrapper.wrapper(glWindowPos3fvARB).setInputArraySize( + 'v', 3 +) +glWindowPos3ivARB=wrapper.wrapper(glWindowPos3ivARB).setInputArraySize( + 'v', 3 +) +glWindowPos3svARB=wrapper.wrapper(glWindowPos3svARB).setInputArraySize( + 'v', 3 +) +### END AUTOGENERATED SECTION diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARM/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ARM/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ARM/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ARM/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ARM/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..3db104b6 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ARM/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ATI/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ATI/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ATI/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ATI/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ATI/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..19285b23 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ATI/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ATI/__pycache__/draw_buffers.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ATI/__pycache__/draw_buffers.cpython-312.pyc new file mode 100644 index 00000000..8fe089b8 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ATI/__pycache__/draw_buffers.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ATI/__pycache__/element_array.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ATI/__pycache__/element_array.cpython-312.pyc new file mode 100644 index 00000000..e13fa4ee Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ATI/__pycache__/element_array.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ATI/__pycache__/envmap_bumpmap.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ATI/__pycache__/envmap_bumpmap.cpython-312.pyc new file mode 100644 index 00000000..b5089f6e Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ATI/__pycache__/envmap_bumpmap.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ATI/__pycache__/fragment_shader.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ATI/__pycache__/fragment_shader.cpython-312.pyc new file mode 100644 index 00000000..e27aad11 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ATI/__pycache__/fragment_shader.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ATI/__pycache__/map_object_buffer.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ATI/__pycache__/map_object_buffer.cpython-312.pyc new file mode 100644 index 00000000..ab3c13ea Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ATI/__pycache__/map_object_buffer.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ATI/__pycache__/meminfo.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ATI/__pycache__/meminfo.cpython-312.pyc new file mode 100644 index 00000000..fbd96243 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ATI/__pycache__/meminfo.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ATI/__pycache__/pixel_format_float.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ATI/__pycache__/pixel_format_float.cpython-312.pyc new file mode 100644 index 00000000..41f008e7 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ATI/__pycache__/pixel_format_float.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ATI/__pycache__/pn_triangles.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ATI/__pycache__/pn_triangles.cpython-312.pyc new file mode 100644 index 00000000..2273a9e5 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ATI/__pycache__/pn_triangles.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ATI/__pycache__/separate_stencil.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ATI/__pycache__/separate_stencil.cpython-312.pyc new file mode 100644 index 00000000..87b5b8e1 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ATI/__pycache__/separate_stencil.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ATI/__pycache__/text_fragment_shader.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ATI/__pycache__/text_fragment_shader.cpython-312.pyc new file mode 100644 index 00000000..86af63d0 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ATI/__pycache__/text_fragment_shader.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ATI/__pycache__/texture_env_combine3.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ATI/__pycache__/texture_env_combine3.cpython-312.pyc new file mode 100644 index 00000000..573bc4ba Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ATI/__pycache__/texture_env_combine3.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ATI/__pycache__/texture_float.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ATI/__pycache__/texture_float.cpython-312.pyc new file mode 100644 index 00000000..66a5f631 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ATI/__pycache__/texture_float.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ATI/__pycache__/texture_mirror_once.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ATI/__pycache__/texture_mirror_once.cpython-312.pyc new file mode 100644 index 00000000..2189f72f Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ATI/__pycache__/texture_mirror_once.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ATI/__pycache__/vertex_array_object.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ATI/__pycache__/vertex_array_object.cpython-312.pyc new file mode 100644 index 00000000..93089f59 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ATI/__pycache__/vertex_array_object.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ATI/__pycache__/vertex_attrib_array_object.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ATI/__pycache__/vertex_attrib_array_object.cpython-312.pyc new file mode 100644 index 00000000..ba1f83ae Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ATI/__pycache__/vertex_attrib_array_object.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ATI/__pycache__/vertex_streams.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/ATI/__pycache__/vertex_streams.cpython-312.pyc new file mode 100644 index 00000000..9af9e7aa Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/ATI/__pycache__/vertex_streams.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ATI/draw_buffers.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ATI/draw_buffers.py new file mode 100644 index 00000000..67fa73f9 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ATI/draw_buffers.py @@ -0,0 +1,48 @@ +'''OpenGL extension ATI.draw_buffers + +This module customises the behaviour of the +OpenGL.raw.GL.ATI.draw_buffers to provide a more +Python-friendly API + +Overview (from the spec) + + This extension extends ARB_fragment_program to allow multiple output + colors, and provides a mechanism for directing those outputs to + multiple color buffers. + + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ATI/draw_buffers.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ATI.draw_buffers import * +from OpenGL.raw.GL.ATI.draw_buffers import _EXTENSION_NAME + +def glInitDrawBuffersATI(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glDrawBuffersATI.bufs size not checked against n +glDrawBuffersATI=wrapper.wrapper(glDrawBuffersATI).setInputArraySize( + 'bufs', None +) +### END AUTOGENERATED SECTION +from OpenGL.lazywrapper import lazy as _lazy +@_lazy( glDrawBuffersATI ) +def glDrawBuffersATI( baseOperation, n=None, bufs=None ): + """glDrawBuffersATI( bufs ) -> bufs + + Wrapper will calculate n from dims of bufs if only + one argument is provided... + """ + if bufs is None: + bufs = n + n = None + bufs = arrays.GLenumArray.asArray( bufs ) + if n is None: + n = arrays.GLenumArray.arraySize( bufs ) + return baseOperation( n,bufs ) diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ATI/element_array.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ATI/element_array.py new file mode 100644 index 00000000..fa1a4ab0 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ATI/element_array.py @@ -0,0 +1,42 @@ +'''OpenGL extension ATI.element_array + +This module customises the behaviour of the +OpenGL.raw.GL.ATI.element_array to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides a mechanism for an application to create + an array of index data for use in specifying geometric primitives. + + This extension is most useful when used in conjunction with the + ATI_vertex_array_object extension. ATI_vertex_array_object + provides an interface for storing vertex array data in persistent, + hardware-addressable memory. In cases where large amounts of + vertex data are in use, the index data used to construct + primitives (typically as passed to the GL through DrawElements) + can impose a significant bandwidth burden. ATI_element_array + allows the application to specify independent arrays of elements, + which can then be cached using ATI_vertex_array_object. + + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ATI/element_array.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ATI.element_array import * +from OpenGL.raw.GL.ATI.element_array import _EXTENSION_NAME + +def glInitElementArrayATI(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glElementPointerATI.pointer size not checked against 'type' +glElementPointerATI=wrapper.wrapper(glElementPointerATI).setInputArraySize( + 'pointer', None +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ATI/envmap_bumpmap.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ATI/envmap_bumpmap.py new file mode 100644 index 00000000..66cfe857 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ATI/envmap_bumpmap.py @@ -0,0 +1,54 @@ +'''OpenGL extension ATI.envmap_bumpmap + +This module customises the behaviour of the +OpenGL.raw.GL.ATI.envmap_bumpmap to provide a more +Python-friendly API + +Overview (from the spec) + + This extension adds environment mapped bump mapping (EMBM) to the GL. + The method exposed by this extension is to use a dependent texture + read on a bumpmap (du,dv) texture to offset the texture coordinates + read into a map on another texture unit. This (du,dv) offset is also + rotated through a user-specified rotation matrix to get the texture + coordinates into the appropriate space. + + A new texture format is introduced in order for specifying the (du,dv) + bumpmap texture. This map represents -1 <= du,dv <= 1 offsets to + be applied to the texture coordinates used to read into the base + map. Additionally, the (du,dv) offsets are transformed by a rotation + matrix that this extension allows the user to specify. Further, a + new color operation is added to EXT_texture_env_combine to specify + both that bumpmapping is enabled and which texture unit to apply + the bump offset to. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ATI/envmap_bumpmap.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ATI.envmap_bumpmap import * +from OpenGL.raw.GL.ATI.envmap_bumpmap import _EXTENSION_NAME + +def glInitEnvmapBumpmapATI(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glTexBumpParameterivATI.param size not checked against 'pname' +glTexBumpParameterivATI=wrapper.wrapper(glTexBumpParameterivATI).setInputArraySize( + 'param', None +) +# INPUT glTexBumpParameterfvATI.param size not checked against 'pname' +glTexBumpParameterfvATI=wrapper.wrapper(glTexBumpParameterfvATI).setInputArraySize( + 'param', None +) +glGetTexBumpParameterivATI=wrapper.wrapper(glGetTexBumpParameterivATI).setOutput( + 'param',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetTexBumpParameterfvATI=wrapper.wrapper(glGetTexBumpParameterfvATI).setOutput( + 'param',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ATI/fragment_shader.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ATI/fragment_shader.py new file mode 100644 index 00000000..ada67626 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ATI/fragment_shader.py @@ -0,0 +1,46 @@ +'''OpenGL extension ATI.fragment_shader + +This module customises the behaviour of the +OpenGL.raw.GL.ATI.fragment_shader to provide a more +Python-friendly API + +Overview (from the spec) + + This extension exposes a powerful fragment shading model which + provides a very general means of expressing fragment color blending + and dependent texture address modification. The programming is + a register-based model in which there is a fixed number of + instructions, texture lookups, read/write registers, and constants. + + The fragment shader extension provides a unified instruction set + for operating on address or color data and eliminates the + distinction between the two. This extension provides all the + interfaces necessary to fully expose this programmable fragment + shader in GL. + + Although conceived as a device-independent extension which would + expose the capabilities of future generations of hardware, changing + trends in programmable hardware have affected the lifespan of this + extension. For this reason you will now find a fixed set of + features and resources exposed, and the queries to determine this + set have been deprecated. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ATI/fragment_shader.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ATI.fragment_shader import * +from OpenGL.raw.GL.ATI.fragment_shader import _EXTENSION_NAME + +def glInitFragmentShaderATI(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +glSetFragmentShaderConstantATI=wrapper.wrapper(glSetFragmentShaderConstantATI).setInputArraySize( + 'value', 4 +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ATI/map_object_buffer.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ATI/map_object_buffer.py new file mode 100644 index 00000000..fee67ae1 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ATI/map_object_buffer.py @@ -0,0 +1,31 @@ +'''OpenGL extension ATI.map_object_buffer + +This module customises the behaviour of the +OpenGL.raw.GL.ATI.map_object_buffer to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides a mechanism for an application to obtain + the virtual address of an object buffer. This allows the + application to directly update the contents of an object buffer + and avoid any intermediate copies. + + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ATI/map_object_buffer.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ATI.map_object_buffer import * +from OpenGL.raw.GL.ATI.map_object_buffer import _EXTENSION_NAME + +def glInitMapObjectBufferATI(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ATI/meminfo.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ATI/meminfo.py new file mode 100644 index 00000000..d9554366 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ATI/meminfo.py @@ -0,0 +1,33 @@ +'''OpenGL extension ATI.meminfo + +This module customises the behaviour of the +OpenGL.raw.GL.ATI.meminfo to provide a more +Python-friendly API + +Overview (from the spec) + + Traditionally, OpenGL has treated resource management as a task of hardware + virtualization hidden from applications. While providing great portability, + this shielding of information can prevent applications from making + intelligent decisions on the management of resources they create. For + instance, an application may be better served by choosing a different + rendering method if there is not sufficient resources to efficiently + utilize its preferred method. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ATI/meminfo.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ATI.meminfo import * +from OpenGL.raw.GL.ATI.meminfo import _EXTENSION_NAME + +def glInitMeminfoATI(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ATI/pixel_format_float.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ATI/pixel_format_float.py new file mode 100644 index 00000000..7d4b3a47 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ATI/pixel_format_float.py @@ -0,0 +1,23 @@ +'''OpenGL extension ATI.pixel_format_float + +This module customises the behaviour of the +OpenGL.raw.GL.ATI.pixel_format_float to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ATI/pixel_format_float.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ATI.pixel_format_float import * +from OpenGL.raw.GL.ATI.pixel_format_float import _EXTENSION_NAME + +def glInitPixelFormatFloatATI(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ATI/pn_triangles.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ATI/pn_triangles.py new file mode 100644 index 00000000..31dea8f1 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ATI/pn_triangles.py @@ -0,0 +1,38 @@ +'''OpenGL extension ATI.pn_triangles + +This module customises the behaviour of the +OpenGL.raw.GL.ATI.pn_triangles to provide a more +Python-friendly API + +Overview (from the spec) + + ATI_pn_triangles provides a path for enabling the GL to internally + tessellate input geometry into curved patches. The extension allows the + user to tune the amount of tessellation to be performed on each triangle as + a global state value. The intent of PN Triangle tessellation is + typically to produce geometry with a smoother silhouette and more organic + shape. + + The tessellated patch will replace the triangles input into the GL. + The GL will generate new vertices in object-space, prior to geometry + transformation. Only the vertices and normals are required to produce + proper results, and the rest of the information per vertex is interpolated + linearly across the patch. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ATI/pn_triangles.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ATI.pn_triangles import * +from OpenGL.raw.GL.ATI.pn_triangles import _EXTENSION_NAME + +def glInitPnTrianglesATI(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ATI/separate_stencil.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ATI/separate_stencil.py new file mode 100644 index 00000000..72237a85 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ATI/separate_stencil.py @@ -0,0 +1,29 @@ +'''OpenGL extension ATI.separate_stencil + +This module customises the behaviour of the +OpenGL.raw.GL.ATI.separate_stencil to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides the ability to modify the stencil buffer + differently based on the facing direction of the primitive that + generated the fragment. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ATI/separate_stencil.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ATI.separate_stencil import * +from OpenGL.raw.GL.ATI.separate_stencil import _EXTENSION_NAME + +def glInitSeparateStencilATI(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ATI/text_fragment_shader.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ATI/text_fragment_shader.py new file mode 100644 index 00000000..a2ebe5b8 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ATI/text_fragment_shader.py @@ -0,0 +1,84 @@ +'''OpenGL extension ATI.text_fragment_shader + +This module customises the behaviour of the +OpenGL.raw.GL.ATI.text_fragment_shader to provide a more +Python-friendly API + +Overview (from the spec) + + The ATI_fragment_shader extension exposes a powerful fragment + processing model that provides a very general means of expressing + fragment color blending and dependent texture address modification. + The processing is termed a fragment shader or fragment program and + is specifed using a register-based model in which there are fixed + numbers of instructions, texture lookups, read/write registers, and + constants. + + ATI_fragment_shader provides a unified instruction set + for operating on address or color data and eliminates the + distinction between the two. That extension provides all the + interfaces necessary to fully expose this programmable fragment + processor in GL. + + ATI_text_fragment_shader is a redefinition of the + ATI_fragment_shader functionality, using a slightly different + interface. The intent of creating ATI_text_fragment_shader is to + take a step towards treating fragment programs similar to other + programmable parts of the GL rendering pipeline, specifically + vertex programs. This new interface is intended to appear + similar to the ARB_vertex_program API, within the limits of the + feature set exposed by the original ATI_fragment_shader extension. + + The most significant differences between the two extensions are: + + (1) ATI_fragment_shader provides a procedural function call + interface to specify the fragment program, whereas + ATI_text_fragment_shader uses a textual string to specify + the program. The fundamental syntax and constructs of the + program "language" remain the same. + + (2) The program object managment portions of the interface, + namely the routines used to create, bind, and delete program + objects and set program constants are managed + using the framework defined by ARB_vertex_program. + + (3) ATI_fragment_shader refers to the description of the + programmable fragment processing as a "fragment shader". + In keeping with the desire to treat all programmable parts + of the pipeline consistently, ATI_text_fragment_shader refers + to these as "fragment programs". The name of the extension is + left as ATI_text_fragment_shader instead of + ATI_text_fragment_program in order to indicate the underlying + similarity between the API's of the two extensions, and to + differentiate it from any other potential extensions that + may be able to move even further in the direction of treating + fragment programs as just another programmable area of the + GL pipeline. + + Although ATI_fragment_shader was originally conceived as a + device-independent extension that would expose the capabilities of + future generations of hardware, changing trends in programmable + hardware have affected the lifespan of this extension. For this + reason you will now find a fixed set of features and resources + exposed, and the queries to determine this set have been deprecated + in ATI_fragment_shader. Further, in ATI_text_fragment_shader, + most of these resource limits are fixed by the text grammar and + the queries have been removed altogether. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ATI/text_fragment_shader.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ATI.text_fragment_shader import * +from OpenGL.raw.GL.ATI.text_fragment_shader import _EXTENSION_NAME + +def glInitTextFragmentShaderATI(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ATI/texture_env_combine3.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ATI/texture_env_combine3.py new file mode 100644 index 00000000..d32877a5 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ATI/texture_env_combine3.py @@ -0,0 +1,44 @@ +'''OpenGL extension ATI.texture_env_combine3 + +This module customises the behaviour of the +OpenGL.raw.GL.ATI.texture_env_combine3 to provide a more +Python-friendly API + +Overview (from the spec) + + Adds new set of operations to the texture combiner operations. + + MODULATE_ADD_ATI Arg0 * Arg2 + Arg1 + MODULATE_SIGNED_ADD_ATI Arg0 * Arg2 + Arg1 - 0.5 + MODULATE_SUBTRACT_ATI Arg0 * Arg2 - Arg1 + + where Arg0, Arg1 and Arg2 are derived from + + PRIMARY_COLOR_ARB primary color of incoming fragment + TEXTURE texture color of corresponding texture unit + CONSTANT_ARB texture environment constant color + PREVIOUS_ARB result of previous texture environment; on + texture unit 0, this maps to PRIMARY_COLOR_ARB + + In addition, the result may be scaled by 1.0, 2.0 or 4.0. + + Note that in addition to providing more flexible equations new source + inputs have been added for zero and one. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ATI/texture_env_combine3.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ATI.texture_env_combine3 import * +from OpenGL.raw.GL.ATI.texture_env_combine3 import _EXTENSION_NAME + +def glInitTextureEnvCombine3ATI(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ATI/texture_float.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ATI/texture_float.py new file mode 100644 index 00000000..727b2c08 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ATI/texture_float.py @@ -0,0 +1,33 @@ +'''OpenGL extension ATI.texture_float + +This module customises the behaviour of the +OpenGL.raw.GL.ATI.texture_float to provide a more +Python-friendly API + +Overview (from the spec) + + This extension adds texture internal formats with 32 and 16 bit + floating-point components. The 32 bit floating-point components + are in the standard IEEE float format. The 16 bit floating-point + components have 1 sign bit, 5 exponent bits, and 10 mantissa bits. + Floating-point components are clamped to the limits of the range + representable by their format. + + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ATI/texture_float.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ATI.texture_float import * +from OpenGL.raw.GL.ATI.texture_float import _EXTENSION_NAME + +def glInitTextureFloatATI(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ATI/texture_mirror_once.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ATI/texture_mirror_once.py new file mode 100644 index 00000000..2c57ba8f --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ATI/texture_mirror_once.py @@ -0,0 +1,36 @@ +'''OpenGL extension ATI.texture_mirror_once + +This module customises the behaviour of the +OpenGL.raw.GL.ATI.texture_mirror_once to provide a more +Python-friendly API + +Overview (from the spec) + + ATI_texture_mirror_once extends the set of texture wrap modes to + include two modes (GL_MIRROR_CLAMP_ATI, GL_MIRROR_CLAMP_TO_EDGE_ATI) + that effectively use a texture map twice as large as the original image + in which the additional half of the new image is a mirror image of the + original image. + + This new mode relaxes the need to generate images whose opposite edges + match by using the original image to generate a matching "mirror image". + This mode allows the texture to be mirrored only once in the negative + s, t, and r directions. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ATI/texture_mirror_once.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ATI.texture_mirror_once import * +from OpenGL.raw.GL.ATI.texture_mirror_once import _EXTENSION_NAME + +def glInitTextureMirrorOnceATI(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ATI/vertex_array_object.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ATI/vertex_array_object.py new file mode 100644 index 00000000..59258195 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ATI/vertex_array_object.py @@ -0,0 +1,56 @@ +'''OpenGL extension ATI.vertex_array_object + +This module customises the behaviour of the +OpenGL.raw.GL.ATI.vertex_array_object to provide a more +Python-friendly API + +Overview (from the spec) + + This extension defines an interface that allows multiple sets of + vertex array data to be cached in persistent server-side memory. + It is intended to allow client data to be stored in memory that + can be directly accessed by graphics hardware. + + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ATI/vertex_array_object.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ATI.vertex_array_object import * +from OpenGL.raw.GL.ATI.vertex_array_object import _EXTENSION_NAME + +def glInitVertexArrayObjectATI(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glNewObjectBufferATI.pointer size not checked against size +glNewObjectBufferATI=wrapper.wrapper(glNewObjectBufferATI).setInputArraySize( + 'pointer', None +) +# INPUT glUpdateObjectBufferATI.pointer size not checked against size +glUpdateObjectBufferATI=wrapper.wrapper(glUpdateObjectBufferATI).setInputArraySize( + 'pointer', None +) +glGetObjectBufferfvATI=wrapper.wrapper(glGetObjectBufferfvATI).setOutput( + 'params',size=(1,),orPassIn=True +) +glGetObjectBufferivATI=wrapper.wrapper(glGetObjectBufferivATI).setOutput( + 'params',size=(1,),orPassIn=True +) +glGetArrayObjectfvATI=wrapper.wrapper(glGetArrayObjectfvATI).setOutput( + 'params',size=(1,),orPassIn=True +) +glGetArrayObjectivATI=wrapper.wrapper(glGetArrayObjectivATI).setOutput( + 'params',size=(1,),orPassIn=True +) +glGetVariantArrayObjectfvATI=wrapper.wrapper(glGetVariantArrayObjectfvATI).setOutput( + 'params',size=(1,),orPassIn=True +) +glGetVariantArrayObjectivATI=wrapper.wrapper(glGetVariantArrayObjectivATI).setOutput( + 'params',size=(1,),orPassIn=True +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ATI/vertex_attrib_array_object.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ATI/vertex_attrib_array_object.py new file mode 100644 index 00000000..8e8ac557 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ATI/vertex_attrib_array_object.py @@ -0,0 +1,36 @@ +'''OpenGL extension ATI.vertex_attrib_array_object + +This module customises the behaviour of the +OpenGL.raw.GL.ATI.vertex_attrib_array_object to provide a more +Python-friendly API + +Overview (from the spec) + + This extension defines an interface that allows multiple sets of + generic vertex attribute data to be cached in persistent server-side + memory. It is intended to allow client data to be stored in memory + that can be directly accessed by graphics hardware. + + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ATI/vertex_attrib_array_object.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ATI.vertex_attrib_array_object import * +from OpenGL.raw.GL.ATI.vertex_attrib_array_object import _EXTENSION_NAME + +def glInitVertexAttribArrayObjectATI(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +glGetVertexAttribArrayObjectfvATI=wrapper.wrapper(glGetVertexAttribArrayObjectfvATI).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetVertexAttribArrayObjectivATI=wrapper.wrapper(glGetVertexAttribArrayObjectivATI).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/ATI/vertex_streams.py b/venv/lib/python3.12/site-packages/OpenGL/GL/ATI/vertex_streams.py new file mode 100644 index 00000000..a44e9e74 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/ATI/vertex_streams.py @@ -0,0 +1,96 @@ +'''OpenGL extension ATI.vertex_streams + +This module customises the behaviour of the +OpenGL.raw.GL.ATI.vertex_streams to provide a more +Python-friendly API + +Overview (from the spec) + + This extension adds the ability to handle sets of auxilliary + vertex and normal coordinates. These sets of auxilliary + coordinates are termed streams, and can be routed selectively + into the blend stages provided by the vertex blending extension. + This functionality enables software animation techniques such + as keyframe vertex morphing. + + + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ATI/vertex_streams.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.ATI.vertex_streams import * +from OpenGL.raw.GL.ATI.vertex_streams import _EXTENSION_NAME + +def glInitVertexStreamsATI(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +glVertexStream1svATI=wrapper.wrapper(glVertexStream1svATI).setInputArraySize( + 'coords', 1 +) +glVertexStream1ivATI=wrapper.wrapper(glVertexStream1ivATI).setInputArraySize( + 'coords', 1 +) +glVertexStream1fvATI=wrapper.wrapper(glVertexStream1fvATI).setInputArraySize( + 'coords', 1 +) +glVertexStream1dvATI=wrapper.wrapper(glVertexStream1dvATI).setInputArraySize( + 'coords', 1 +) +glVertexStream2svATI=wrapper.wrapper(glVertexStream2svATI).setInputArraySize( + 'coords', 2 +) +glVertexStream2ivATI=wrapper.wrapper(glVertexStream2ivATI).setInputArraySize( + 'coords', 2 +) +glVertexStream2fvATI=wrapper.wrapper(glVertexStream2fvATI).setInputArraySize( + 'coords', 2 +) +glVertexStream2dvATI=wrapper.wrapper(glVertexStream2dvATI).setInputArraySize( + 'coords', 2 +) +glVertexStream3svATI=wrapper.wrapper(glVertexStream3svATI).setInputArraySize( + 'coords', 3 +) +glVertexStream3ivATI=wrapper.wrapper(glVertexStream3ivATI).setInputArraySize( + 'coords', 3 +) +glVertexStream3fvATI=wrapper.wrapper(glVertexStream3fvATI).setInputArraySize( + 'coords', 3 +) +glVertexStream3dvATI=wrapper.wrapper(glVertexStream3dvATI).setInputArraySize( + 'coords', 3 +) +glVertexStream4svATI=wrapper.wrapper(glVertexStream4svATI).setInputArraySize( + 'coords', 4 +) +glVertexStream4ivATI=wrapper.wrapper(glVertexStream4ivATI).setInputArraySize( + 'coords', 4 +) +glVertexStream4fvATI=wrapper.wrapper(glVertexStream4fvATI).setInputArraySize( + 'coords', 4 +) +glVertexStream4dvATI=wrapper.wrapper(glVertexStream4dvATI).setInputArraySize( + 'coords', 4 +) +glNormalStream3bvATI=wrapper.wrapper(glNormalStream3bvATI).setInputArraySize( + 'coords', 3 +) +glNormalStream3svATI=wrapper.wrapper(glNormalStream3svATI).setInputArraySize( + 'coords', 3 +) +glNormalStream3ivATI=wrapper.wrapper(glNormalStream3ivATI).setInputArraySize( + 'coords', 3 +) +glNormalStream3fvATI=wrapper.wrapper(glNormalStream3fvATI).setInputArraySize( + 'coords', 3 +) +glNormalStream3dvATI=wrapper.wrapper(glNormalStream3dvATI).setInputArraySize( + 'coords', 3 +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/DFX/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/GL/DFX/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/DFX/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/DFX/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/DFX/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..da47f7bf Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/DFX/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/DFX/__pycache__/multisample.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/DFX/__pycache__/multisample.cpython-312.pyc new file mode 100644 index 00000000..1a06d1b2 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/DFX/__pycache__/multisample.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/DFX/__pycache__/tbuffer.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/DFX/__pycache__/tbuffer.cpython-312.pyc new file mode 100644 index 00000000..7e5344bc Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/DFX/__pycache__/tbuffer.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/DFX/__pycache__/texture_compression_FXT1.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/DFX/__pycache__/texture_compression_FXT1.cpython-312.pyc new file mode 100644 index 00000000..6d1108d5 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/DFX/__pycache__/texture_compression_FXT1.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/DFX/multisample.py b/venv/lib/python3.12/site-packages/OpenGL/GL/DFX/multisample.py new file mode 100644 index 00000000..3c3dfd3f --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/DFX/multisample.py @@ -0,0 +1,65 @@ +'''OpenGL extension DFX.multisample + +This module customises the behaviour of the +OpenGL.raw.GL.DFX.multisample to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides a mechanism to antialias all GL primitives: + points, lines, polygons, bitmaps, and images. The technique is to + sample all primitives multiple times at each pixel. The color sample + values are resolved to a single, displayable color each time a pixel + is updated, so the antialiasing appears to be automatic at the + application level. Because each sample includes depth and stencil + information, the depth and stencil functions perform equivalently to + the single-sample mode. + + An additional buffer, called the multisample buffer, is added to the + framebuffer. Pixel sample values, including color, depth, and + stencil values, are stored in this buffer. When the framebuffer + includes a multisample buffer, it does not also include separate + depth or stencil buffers, even if the multisample buffer does not + store depth or stencil values. Color buffers (left/right, + front/back, and aux) do coexist with the multisample buffer, + however. + + Multisample antialiasing is most valuable for rendering polygons, + because it requires no sorting for hidden surface elimination, and + it correctly handles adjacent polygons, object silhouettes, and even + intersecting polygons. If only points or lines are being rendered, + the "smooth" antialiasing mechanism provided by the base GL may + result in a higher quality image. + + This extension is a subset of SGIS_multisample. It differs in these + key ways: + + * Fragment alpha values are not affected by the fragment sample mask + * The sample locations may or may not be fixed. Thus, there is no + support for rendering the scene multiple times with different + sample points. + * Fragment masks are not computed for images or for bitmasks. + + Because of these differences a new extension was created. However, + it is not expected that this extension will co-exist with + SGIS_multisample. Because of this and the fact that there are only + 32 push/pop bits the MULTISAMPLE_BIT_SGIS state value is the same as + MUTLISAMPLE_BIT_3DFX. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/DFX/multisample.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.DFX.multisample import * +from OpenGL.raw.GL.DFX.multisample import _EXTENSION_NAME + +def glInitMultisampleDFX(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/DFX/tbuffer.py b/venv/lib/python3.12/site-packages/OpenGL/GL/DFX/tbuffer.py new file mode 100644 index 00000000..0ff932cc --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/DFX/tbuffer.py @@ -0,0 +1,29 @@ +'''OpenGL extension DFX.tbuffer + +This module customises the behaviour of the +OpenGL.raw.GL.DFX.tbuffer to provide a more +Python-friendly API + +Overview (from the spec) + + This extension allows a write mask to be defined for the fragment + mask which is created during multisample rendering. This can be used + to create effects such as motion blur and depth of field. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/DFX/tbuffer.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.DFX.tbuffer import * +from OpenGL.raw.GL.DFX.tbuffer import _EXTENSION_NAME + +def glInitTbufferDFX(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/DFX/texture_compression_FXT1.py b/venv/lib/python3.12/site-packages/OpenGL/GL/DFX/texture_compression_FXT1.py new file mode 100644 index 00000000..7e5f0bff --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/DFX/texture_compression_FXT1.py @@ -0,0 +1,42 @@ +'''OpenGL extension DFX.texture_compression_FXT1 + +This module customises the behaviour of the +OpenGL.raw.GL.DFX.texture_compression_FXT1 to provide a more +Python-friendly API + +Overview (from the spec) + + This extension additional texture compression functionality 's FXT1 + format, specific to 3dfxsubject to all the requirements and + limitations described by the extension GL_ARB_texture_compression. + The FXT1 texture format supports only 2D and 3D images without + borders. + + Because 3dfx expects to make continual improvement to its FXT1 + compressor implementation, 3dfx recommends that to achieve best + visual quality applications adopt the following procedure with + respect to reuse of textures compressed by the GL: + + 1) Save the RENDERER and VERSION strings along with images + compressed by the GL; + 2) Before reuse of the textures, compare the stored strings with + strings newly returned from the current GL; + 3) If out-of-date, repeat the compression and storage steps. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/DFX/texture_compression_FXT1.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.DFX.texture_compression_FXT1 import * +from OpenGL.raw.GL.DFX.texture_compression_FXT1 import _EXTENSION_NAME + +def glInitTextureCompressionFxt1DFX(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/DMP/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/GL/DMP/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/DMP/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/DMP/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/DMP/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..825e4a8a Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/DMP/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/EGL_image_storage.py b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/EGL_image_storage.py new file mode 100644 index 00000000..f625a022 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/EGL_image_storage.py @@ -0,0 +1,45 @@ +'''OpenGL extension EXT.EGL_image_storage + +This module customises the behaviour of the +OpenGL.raw.GL.EXT.EGL_image_storage to provide a more +Python-friendly API + +Overview (from the spec) + + The OpenGL ES extension OES_EGL_image provides a mechanism for creating + GL textures sharing storage with EGLImage objects (in other words, creating + GL texture EGLImage targets). The extension was written against the + OpenGL ES 2.0 specification, which does not have the concept of immutable + textures. As a result, it specifies that respecification of a texture by + calling TexImage* on a texture that is an EGLImage target causes it to be + implicitly orphaned. In most cases, this is not the desired behavior, but + rather a result of an application error. + + This extension provides a mechanism for creating texture objects that are + both EGLImage targets and immutable. Since immutable textures cannot be + respecified, they also cannot accidentally be orphaned, and attempts to do + so generate errors instead of resulting in well-defined, but often + undesirable and surprising behavior. It provides a strong guarantee that + texture data that is intended to be shared will remain shared. + + EGL extension specifications are located in the EGL Registry at + + http://www.khronos.org/registry/egl/ + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/EGL_image_storage.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.EXT.EGL_image_storage import * +from OpenGL.raw.GL.EXT.EGL_image_storage import _EXTENSION_NAME + +def glInitEglImageStorageEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/EGL_sync.py b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/EGL_sync.py new file mode 100644 index 00000000..daccbde9 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/EGL_sync.py @@ -0,0 +1,32 @@ +'''OpenGL extension EXT.EGL_sync + +This module customises the behaviour of the +OpenGL.raw.GL.EXT.EGL_sync to provide a more +Python-friendly API + +Overview (from the spec) + + This extension extends EGL_KHR_fence_sync with client API support for + OpenGL (compatibility or core profiles) as an EXT extension. + + The "GL_EXT_EGL_sync" string indicates that a fence sync object can be + created in association with a fence command placed in the command stream + of a bound OpenGL context. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/EGL_sync.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.EXT.EGL_sync import * +from OpenGL.raw.GL.EXT.EGL_sync import _EXTENSION_NAME + +def glInitEglSyncEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/GL_422_pixels.py b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/GL_422_pixels.py new file mode 100644 index 00000000..c0016890 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/GL_422_pixels.py @@ -0,0 +1,41 @@ +'''OpenGL extension EXT.GL_422_pixels + +This module customises the behaviour of the +OpenGL.raw.GL.EXT.GL_422_pixels to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides support for converting 422 pixels in host + memory to 444 pixels as part of the pixel storage operation. + + The pixel unpack storage operation treats a 422 pixel as a 2 element + format where the first element is C (chrominance) and the second + element is L (luminance). Luminance is present on all pixels; a full + chrominance value requires two pixels. + + The pixel pack storage operation converts RGB to a 422 pixel defined as + a 2 element format where the first element stored is C (chrominance) + and the second element stored is L (luminance). Luminance is present + on all pixels; a full chrominance value requires two pixels. + + Both averaging and non-averaging is supported for green and blue + assignments for pack and unpack operations. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/GL_422_pixels.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.EXT.GL_422_pixels import * +from OpenGL.raw.GL.EXT.GL_422_pixels import _EXTENSION_NAME + +def glInitGl422PixelsEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/EGL_image_storage.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/EGL_image_storage.cpython-312.pyc new file mode 100644 index 00000000..7aa8a615 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/EGL_image_storage.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/EGL_sync.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/EGL_sync.cpython-312.pyc new file mode 100644 index 00000000..69cf33f3 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/EGL_sync.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/GL_422_pixels.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/GL_422_pixels.cpython-312.pyc new file mode 100644 index 00000000..5f08e9a7 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/GL_422_pixels.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..a1b44e16 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/abgr.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/abgr.cpython-312.pyc new file mode 100644 index 00000000..d4649092 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/abgr.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/bgra.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/bgra.cpython-312.pyc new file mode 100644 index 00000000..b96c18b6 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/bgra.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/bindable_uniform.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/bindable_uniform.cpython-312.pyc new file mode 100644 index 00000000..b296fe6a Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/bindable_uniform.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/blend_color.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/blend_color.cpython-312.pyc new file mode 100644 index 00000000..513b5be3 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/blend_color.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/blend_equation_separate.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/blend_equation_separate.cpython-312.pyc new file mode 100644 index 00000000..80816818 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/blend_equation_separate.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/blend_func_separate.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/blend_func_separate.cpython-312.pyc new file mode 100644 index 00000000..5b66dfc5 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/blend_func_separate.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/blend_logic_op.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/blend_logic_op.cpython-312.pyc new file mode 100644 index 00000000..9c5820cf Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/blend_logic_op.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/blend_minmax.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/blend_minmax.cpython-312.pyc new file mode 100644 index 00000000..3ee8d23f Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/blend_minmax.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/blend_subtract.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/blend_subtract.cpython-312.pyc new file mode 100644 index 00000000..c2c28db3 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/blend_subtract.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/clip_volume_hint.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/clip_volume_hint.cpython-312.pyc new file mode 100644 index 00000000..0a0d9ba2 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/clip_volume_hint.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/cmyka.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/cmyka.cpython-312.pyc new file mode 100644 index 00000000..87551f2f Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/cmyka.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/color_subtable.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/color_subtable.cpython-312.pyc new file mode 100644 index 00000000..b3a83235 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/color_subtable.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/compiled_vertex_array.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/compiled_vertex_array.cpython-312.pyc new file mode 100644 index 00000000..98320eff Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/compiled_vertex_array.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/convolution.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/convolution.cpython-312.pyc new file mode 100644 index 00000000..77fcde6c Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/convolution.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/coordinate_frame.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/coordinate_frame.cpython-312.pyc new file mode 100644 index 00000000..e021bb0e Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/coordinate_frame.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/copy_texture.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/copy_texture.cpython-312.pyc new file mode 100644 index 00000000..d03cd11c Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/copy_texture.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/cull_vertex.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/cull_vertex.cpython-312.pyc new file mode 100644 index 00000000..bb3830fc Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/cull_vertex.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/debug_label.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/debug_label.cpython-312.pyc new file mode 100644 index 00000000..d4bee0ff Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/debug_label.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/debug_marker.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/debug_marker.cpython-312.pyc new file mode 100644 index 00000000..011c4427 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/debug_marker.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/depth_bounds_test.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/depth_bounds_test.cpython-312.pyc new file mode 100644 index 00000000..5bbedb85 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/depth_bounds_test.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/direct_state_access.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/direct_state_access.cpython-312.pyc new file mode 100644 index 00000000..63693ab7 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/direct_state_access.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/draw_buffers2.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/draw_buffers2.cpython-312.pyc new file mode 100644 index 00000000..cccde45a Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/draw_buffers2.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/draw_instanced.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/draw_instanced.cpython-312.pyc new file mode 100644 index 00000000..44a8c856 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/draw_instanced.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/draw_range_elements.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/draw_range_elements.cpython-312.pyc new file mode 100644 index 00000000..a5c5334e Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/draw_range_elements.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/external_buffer.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/external_buffer.cpython-312.pyc new file mode 100644 index 00000000..aa081b7b Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/external_buffer.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/fog_coord.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/fog_coord.cpython-312.pyc new file mode 100644 index 00000000..e1d3063f Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/fog_coord.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/framebuffer_blit.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/framebuffer_blit.cpython-312.pyc new file mode 100644 index 00000000..9ed4b718 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/framebuffer_blit.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/framebuffer_multisample.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/framebuffer_multisample.cpython-312.pyc new file mode 100644 index 00000000..20d3d282 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/framebuffer_multisample.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/framebuffer_multisample_blit_scaled.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/framebuffer_multisample_blit_scaled.cpython-312.pyc new file mode 100644 index 00000000..a2353f7b Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/framebuffer_multisample_blit_scaled.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/framebuffer_object.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/framebuffer_object.cpython-312.pyc new file mode 100644 index 00000000..581d9230 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/framebuffer_object.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/framebuffer_sRGB.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/framebuffer_sRGB.cpython-312.pyc new file mode 100644 index 00000000..acd67382 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/framebuffer_sRGB.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/geometry_shader4.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/geometry_shader4.cpython-312.pyc new file mode 100644 index 00000000..6285e5af Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/geometry_shader4.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/gpu_program_parameters.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/gpu_program_parameters.cpython-312.pyc new file mode 100644 index 00000000..72917381 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/gpu_program_parameters.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/gpu_shader4.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/gpu_shader4.cpython-312.pyc new file mode 100644 index 00000000..eff27f70 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/gpu_shader4.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/histogram.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/histogram.cpython-312.pyc new file mode 100644 index 00000000..2329905e Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/histogram.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/index_array_formats.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/index_array_formats.cpython-312.pyc new file mode 100644 index 00000000..13406177 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/index_array_formats.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/index_func.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/index_func.cpython-312.pyc new file mode 100644 index 00000000..3da0ce4e Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/index_func.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/index_material.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/index_material.cpython-312.pyc new file mode 100644 index 00000000..e1e8d92d Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/index_material.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/index_texture.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/index_texture.cpython-312.pyc new file mode 100644 index 00000000..527cc572 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/index_texture.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/light_texture.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/light_texture.cpython-312.pyc new file mode 100644 index 00000000..dca36598 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/light_texture.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/memory_object.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/memory_object.cpython-312.pyc new file mode 100644 index 00000000..2a15b5ca Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/memory_object.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/memory_object_fd.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/memory_object_fd.cpython-312.pyc new file mode 100644 index 00000000..509d94ed Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/memory_object_fd.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/memory_object_win32.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/memory_object_win32.cpython-312.pyc new file mode 100644 index 00000000..7a542dc3 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/memory_object_win32.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/misc_attribute.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/misc_attribute.cpython-312.pyc new file mode 100644 index 00000000..271878ee Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/misc_attribute.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/multi_draw_arrays.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/multi_draw_arrays.cpython-312.pyc new file mode 100644 index 00000000..5b7b8a5a Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/multi_draw_arrays.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/multisample.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/multisample.cpython-312.pyc new file mode 100644 index 00000000..ef4fedcb Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/multisample.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/multiview_tessellation_geometry_shader.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/multiview_tessellation_geometry_shader.cpython-312.pyc new file mode 100644 index 00000000..b22f6b99 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/multiview_tessellation_geometry_shader.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/multiview_texture_multisample.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/multiview_texture_multisample.cpython-312.pyc new file mode 100644 index 00000000..d45e3b65 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/multiview_texture_multisample.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/multiview_timer_query.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/multiview_timer_query.cpython-312.pyc new file mode 100644 index 00000000..5f29c74e Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/multiview_timer_query.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/packed_depth_stencil.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/packed_depth_stencil.cpython-312.pyc new file mode 100644 index 00000000..5b52f388 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/packed_depth_stencil.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/packed_float.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/packed_float.cpython-312.pyc new file mode 100644 index 00000000..eb76a956 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/packed_float.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/packed_pixels.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/packed_pixels.cpython-312.pyc new file mode 100644 index 00000000..c2969179 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/packed_pixels.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/paletted_texture.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/paletted_texture.cpython-312.pyc new file mode 100644 index 00000000..b1cc49a4 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/paletted_texture.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/pixel_buffer_object.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/pixel_buffer_object.cpython-312.pyc new file mode 100644 index 00000000..967a78a9 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/pixel_buffer_object.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/pixel_transform.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/pixel_transform.cpython-312.pyc new file mode 100644 index 00000000..dd1e645a Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/pixel_transform.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/pixel_transform_color_table.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/pixel_transform_color_table.cpython-312.pyc new file mode 100644 index 00000000..aba179a3 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/pixel_transform_color_table.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/point_parameters.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/point_parameters.cpython-312.pyc new file mode 100644 index 00000000..c374b1d2 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/point_parameters.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/polygon_offset.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/polygon_offset.cpython-312.pyc new file mode 100644 index 00000000..1f8c2259 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/polygon_offset.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/polygon_offset_clamp.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/polygon_offset_clamp.cpython-312.pyc new file mode 100644 index 00000000..60618be3 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/polygon_offset_clamp.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/post_depth_coverage.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/post_depth_coverage.cpython-312.pyc new file mode 100644 index 00000000..f0250291 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/post_depth_coverage.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/provoking_vertex.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/provoking_vertex.cpython-312.pyc new file mode 100644 index 00000000..2392b14b Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/provoking_vertex.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/raster_multisample.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/raster_multisample.cpython-312.pyc new file mode 100644 index 00000000..fbcc536f Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/raster_multisample.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/rescale_normal.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/rescale_normal.cpython-312.pyc new file mode 100644 index 00000000..cfc099ab Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/rescale_normal.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/secondary_color.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/secondary_color.cpython-312.pyc new file mode 100644 index 00000000..dc7e1bdf Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/secondary_color.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/semaphore.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/semaphore.cpython-312.pyc new file mode 100644 index 00000000..4715d80e Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/semaphore.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/semaphore_fd.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/semaphore_fd.cpython-312.pyc new file mode 100644 index 00000000..b9603deb Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/semaphore_fd.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/semaphore_win32.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/semaphore_win32.cpython-312.pyc new file mode 100644 index 00000000..8854ef52 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/semaphore_win32.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/separate_shader_objects.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/separate_shader_objects.cpython-312.pyc new file mode 100644 index 00000000..11a035eb Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/separate_shader_objects.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/separate_specular_color.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/separate_specular_color.cpython-312.pyc new file mode 100644 index 00000000..bf199aa1 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/separate_specular_color.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/shader_framebuffer_fetch.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/shader_framebuffer_fetch.cpython-312.pyc new file mode 100644 index 00000000..92a48f36 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/shader_framebuffer_fetch.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/shader_framebuffer_fetch_non_coherent.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/shader_framebuffer_fetch_non_coherent.cpython-312.pyc new file mode 100644 index 00000000..cf5b07a6 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/shader_framebuffer_fetch_non_coherent.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/shader_image_load_formatted.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/shader_image_load_formatted.cpython-312.pyc new file mode 100644 index 00000000..f24043dd Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/shader_image_load_formatted.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/shader_image_load_store.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/shader_image_load_store.cpython-312.pyc new file mode 100644 index 00000000..75302862 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/shader_image_load_store.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/shader_integer_mix.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/shader_integer_mix.cpython-312.pyc new file mode 100644 index 00000000..cded6b89 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/shader_integer_mix.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/shadow_funcs.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/shadow_funcs.cpython-312.pyc new file mode 100644 index 00000000..d1872d35 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/shadow_funcs.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/shared_texture_palette.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/shared_texture_palette.cpython-312.pyc new file mode 100644 index 00000000..af34e686 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/shared_texture_palette.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/sparse_texture2.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/sparse_texture2.cpython-312.pyc new file mode 100644 index 00000000..642d8830 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/sparse_texture2.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/stencil_clear_tag.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/stencil_clear_tag.cpython-312.pyc new file mode 100644 index 00000000..8e2da9c6 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/stencil_clear_tag.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/stencil_two_side.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/stencil_two_side.cpython-312.pyc new file mode 100644 index 00000000..e4dc7b8d Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/stencil_two_side.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/stencil_wrap.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/stencil_wrap.cpython-312.pyc new file mode 100644 index 00000000..6305558d Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/stencil_wrap.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/subtexture.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/subtexture.cpython-312.pyc new file mode 100644 index 00000000..393ce955 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/subtexture.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/texture.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/texture.cpython-312.pyc new file mode 100644 index 00000000..f08eef0c Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/texture.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/texture3D.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/texture3D.cpython-312.pyc new file mode 100644 index 00000000..66c010e9 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/texture3D.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/texture_array.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/texture_array.cpython-312.pyc new file mode 100644 index 00000000..b0929dbf Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/texture_array.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/texture_buffer_object.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/texture_buffer_object.cpython-312.pyc new file mode 100644 index 00000000..e9ebb939 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/texture_buffer_object.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/texture_compression_latc.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/texture_compression_latc.cpython-312.pyc new file mode 100644 index 00000000..5b1b7908 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/texture_compression_latc.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/texture_compression_rgtc.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/texture_compression_rgtc.cpython-312.pyc new file mode 100644 index 00000000..917463a3 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/texture_compression_rgtc.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/texture_compression_s3tc.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/texture_compression_s3tc.cpython-312.pyc new file mode 100644 index 00000000..c50daaa5 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/texture_compression_s3tc.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/texture_cube_map.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/texture_cube_map.cpython-312.pyc new file mode 100644 index 00000000..74c8ec36 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/texture_cube_map.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/texture_env_add.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/texture_env_add.cpython-312.pyc new file mode 100644 index 00000000..24683ebb Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/texture_env_add.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/texture_env_combine.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/texture_env_combine.cpython-312.pyc new file mode 100644 index 00000000..11353d19 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/texture_env_combine.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/texture_env_dot3.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/texture_env_dot3.cpython-312.pyc new file mode 100644 index 00000000..47944564 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/texture_env_dot3.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/texture_filter_anisotropic.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/texture_filter_anisotropic.cpython-312.pyc new file mode 100644 index 00000000..8f774f73 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/texture_filter_anisotropic.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/texture_filter_minmax.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/texture_filter_minmax.cpython-312.pyc new file mode 100644 index 00000000..1755d821 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/texture_filter_minmax.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/texture_integer.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/texture_integer.cpython-312.pyc new file mode 100644 index 00000000..4e3381a3 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/texture_integer.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/texture_lod_bias.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/texture_lod_bias.cpython-312.pyc new file mode 100644 index 00000000..753e0af7 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/texture_lod_bias.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/texture_mirror_clamp.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/texture_mirror_clamp.cpython-312.pyc new file mode 100644 index 00000000..e0ab68ba Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/texture_mirror_clamp.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/texture_object.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/texture_object.cpython-312.pyc new file mode 100644 index 00000000..3a88613f Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/texture_object.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/texture_perturb_normal.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/texture_perturb_normal.cpython-312.pyc new file mode 100644 index 00000000..59c5bf53 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/texture_perturb_normal.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/texture_sRGB.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/texture_sRGB.cpython-312.pyc new file mode 100644 index 00000000..bebf2e22 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/texture_sRGB.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/texture_sRGB_R8.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/texture_sRGB_R8.cpython-312.pyc new file mode 100644 index 00000000..0012dfac Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/texture_sRGB_R8.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/texture_sRGB_decode.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/texture_sRGB_decode.cpython-312.pyc new file mode 100644 index 00000000..9032d218 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/texture_sRGB_decode.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/texture_shadow_lod.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/texture_shadow_lod.cpython-312.pyc new file mode 100644 index 00000000..f3957845 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/texture_shadow_lod.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/texture_shared_exponent.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/texture_shared_exponent.cpython-312.pyc new file mode 100644 index 00000000..fe3d6a2a Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/texture_shared_exponent.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/texture_snorm.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/texture_snorm.cpython-312.pyc new file mode 100644 index 00000000..67b1096a Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/texture_snorm.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/texture_swizzle.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/texture_swizzle.cpython-312.pyc new file mode 100644 index 00000000..82bc55c4 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/texture_swizzle.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/timer_query.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/timer_query.cpython-312.pyc new file mode 100644 index 00000000..c401076e Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/timer_query.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/transform_feedback.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/transform_feedback.cpython-312.pyc new file mode 100644 index 00000000..99556028 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/transform_feedback.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/vertex_array.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/vertex_array.cpython-312.pyc new file mode 100644 index 00000000..8f13d49b Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/vertex_array.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/vertex_array_bgra.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/vertex_array_bgra.cpython-312.pyc new file mode 100644 index 00000000..408f571b Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/vertex_array_bgra.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/vertex_attrib_64bit.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/vertex_attrib_64bit.cpython-312.pyc new file mode 100644 index 00000000..d93dd3b2 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/vertex_attrib_64bit.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/vertex_shader.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/vertex_shader.cpython-312.pyc new file mode 100644 index 00000000..07f95548 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/vertex_shader.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/vertex_weighting.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/vertex_weighting.cpython-312.pyc new file mode 100644 index 00000000..ff40275d Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/vertex_weighting.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/win32_keyed_mutex.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/win32_keyed_mutex.cpython-312.pyc new file mode 100644 index 00000000..f210b9fe Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/win32_keyed_mutex.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/window_rectangles.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/window_rectangles.cpython-312.pyc new file mode 100644 index 00000000..97904180 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/window_rectangles.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/x11_sync_object.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/x11_sync_object.cpython-312.pyc new file mode 100644 index 00000000..0fedb5ef Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/__pycache__/x11_sync_object.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/abgr.py b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/abgr.py new file mode 100644 index 00000000..1679e4ef --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/abgr.py @@ -0,0 +1,32 @@ +'''OpenGL extension EXT.abgr + +This module customises the behaviour of the +OpenGL.raw.GL.EXT.abgr to provide a more +Python-friendly API + +Overview (from the spec) + + EXT_abgr extends the list of host-memory color formats. Specifically, + it provides a reverse-order alternative to image format RGBA. The ABGR + component order matches the cpack Iris GL format on big-endian machines. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/abgr.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.EXT.abgr import * +from OpenGL.raw.GL.EXT.abgr import _EXTENSION_NAME + +def glInitAbgrEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION +from OpenGL import images as _i + +_i.COMPONENT_COUNTS[ GL_ABGR_EXT ] = 4 diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/bgra.py b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/bgra.py new file mode 100644 index 00000000..832eba3b --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/bgra.py @@ -0,0 +1,30 @@ +'''OpenGL extension EXT.bgra + +This module customises the behaviour of the +OpenGL.raw.GL.EXT.bgra to provide a more +Python-friendly API + +Overview (from the spec) + + EXT_bgra extends the list of host-memory color formats. + Specifically, it provides formats which match the memory layout of + Windows DIBs so that applications can use the same data in both + Windows API calls and OpenGL pixel API calls. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/bgra.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.EXT.bgra import * +from OpenGL.raw.GL.EXT.bgra import _EXTENSION_NAME + +def glInitBgraEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/bindable_uniform.py b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/bindable_uniform.py new file mode 100644 index 00000000..58103a44 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/bindable_uniform.py @@ -0,0 +1,44 @@ +'''OpenGL extension EXT.bindable_uniform + +This module customises the behaviour of the +OpenGL.raw.GL.EXT.bindable_uniform to provide a more +Python-friendly API + +Overview (from the spec) + + This extension introduces the concept of bindable uniforms to the OpenGL + Shading Language. A uniform variable can be declared bindable, which + means that the storage for the uniform is not allocated by the + compiler/linker anymore, but is backed by a buffer object. This buffer + object is bound to the bindable uniform through the new command + UniformBufferEXT(). Binding needs to happen after linking a program + object. + + Binding different buffer objects to a bindable uniform allows an + application to easily use different "uniform data sets", without having to + re-specify the data every time. + + A buffer object can be bound to bindable uniforms in different program + objects. If those bindable uniforms are all of the same type, accessing a + bindable uniform in program object A will result in the same data if the + same access is made in program object B. This provides a mechanism for + 'environment uniforms', uniform values that can be shared among multiple + program objects. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/bindable_uniform.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.EXT.bindable_uniform import * +from OpenGL.raw.GL.EXT.bindable_uniform import _EXTENSION_NAME + +def glInitBindableUniformEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/blend_color.py b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/blend_color.py new file mode 100644 index 00000000..71466692 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/blend_color.py @@ -0,0 +1,30 @@ +'''OpenGL extension EXT.blend_color + +This module customises the behaviour of the +OpenGL.raw.GL.EXT.blend_color to provide a more +Python-friendly API + +Overview (from the spec) + + Blending capability is extended by defining a constant color that can + be included in blending equations. A typical usage is blending two + RGB images. Without the constant blend factor, one image must have + an alpha channel with each pixel set to the desired blend factor. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/blend_color.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.EXT.blend_color import * +from OpenGL.raw.GL.EXT.blend_color import _EXTENSION_NAME + +def glInitBlendColorEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/blend_equation_separate.py b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/blend_equation_separate.py new file mode 100644 index 00000000..5a68c273 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/blend_equation_separate.py @@ -0,0 +1,38 @@ +'''OpenGL extension EXT.blend_equation_separate + +This module customises the behaviour of the +OpenGL.raw.GL.EXT.blend_equation_separate to provide a more +Python-friendly API + +Overview (from the spec) + + EXT_blend_func_separate introduced separate RGB and alpha blend + factors. EXT_blend_minmax introduced a distinct blend equation for + combining source and destination blend terms. (EXT_blend_subtract & + EXT_blend_logic_op added other blend equation modes.) OpenGL 1.4 + integrated both functionalities into the core standard. + + While there are separate blend functions for the RGB and alpha blend + factors, OpenGL 1.4 provides a single blend equation that applies + to both RGB and alpha portions of blending. + + This extension provides a separate blend equation for RGB and alpha + to match the generality available for blend factors. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/blend_equation_separate.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.EXT.blend_equation_separate import * +from OpenGL.raw.GL.EXT.blend_equation_separate import _EXTENSION_NAME + +def glInitBlendEquationSeparateEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/blend_func_separate.py b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/blend_func_separate.py new file mode 100644 index 00000000..28702d4e --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/blend_func_separate.py @@ -0,0 +1,31 @@ +'''OpenGL extension EXT.blend_func_separate + +This module customises the behaviour of the +OpenGL.raw.GL.EXT.blend_func_separate to provide a more +Python-friendly API + +Overview (from the spec) + + Blending capability is extended by defining a function that allows + independent setting of the RGB and alpha blend factors for blend + operations that require source and destination blend factors. It + is not always desired that the blending used for RGB is also applied + to alpha. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/blend_func_separate.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.EXT.blend_func_separate import * +from OpenGL.raw.GL.EXT.blend_func_separate import _EXTENSION_NAME + +def glInitBlendFuncSeparateEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/blend_logic_op.py b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/blend_logic_op.py new file mode 100644 index 00000000..f4df0480 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/blend_logic_op.py @@ -0,0 +1,32 @@ +'''OpenGL extension EXT.blend_logic_op + +This module customises the behaviour of the +OpenGL.raw.GL.EXT.blend_logic_op to provide a more +Python-friendly API + +Overview (from the spec) + + A single additional blending equation is specified using the interface + defined by EXT_blend_minmax. This equation is a simple logical + combination of the source and destination colors, where the specific + logical operation is as specified by LogicOp. While only the XOR + operation may find wide application, the generality of full logical + operations is allowed. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/blend_logic_op.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.EXT.blend_logic_op import * +from OpenGL.raw.GL.EXT.blend_logic_op import _EXTENSION_NAME + +def glInitBlendLogicOpEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/blend_minmax.py b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/blend_minmax.py new file mode 100644 index 00000000..b348b435 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/blend_minmax.py @@ -0,0 +1,35 @@ +'''OpenGL extension EXT.blend_minmax + +This module customises the behaviour of the +OpenGL.raw.GL.EXT.blend_minmax to provide a more +Python-friendly API + +Overview (from the spec) + + Blending capability is extended by respecifying the entire blend + equation. While this document defines only two new equations, the + BlendEquationEXT procedure that it defines will be used by subsequent + extensions to define additional blending equations. + + The two new equations defined by this extension produce the minimum + (or maximum) color components of the source and destination colors. + Taking the maximum is useful for applications such as maximum projection + in medical imaging. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/blend_minmax.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.EXT.blend_minmax import * +from OpenGL.raw.GL.EXT.blend_minmax import _EXTENSION_NAME + +def glInitBlendMinmaxEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/blend_subtract.py b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/blend_subtract.py new file mode 100644 index 00000000..8deab31c --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/blend_subtract.py @@ -0,0 +1,31 @@ +'''OpenGL extension EXT.blend_subtract + +This module customises the behaviour of the +OpenGL.raw.GL.EXT.blend_subtract to provide a more +Python-friendly API + +Overview (from the spec) + + Two additional blending equations are specified using the interface + defined by EXT_blend_minmax. These equations are similar to the + default blending equation, but produce the difference of its left + and right hand sides, rather than the sum. Image differences are + useful in many image processing applications. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/blend_subtract.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.EXT.blend_subtract import * +from OpenGL.raw.GL.EXT.blend_subtract import _EXTENSION_NAME + +def glInitBlendSubtractEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/clip_volume_hint.py b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/clip_volume_hint.py new file mode 100644 index 00000000..2ee27bc9 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/clip_volume_hint.py @@ -0,0 +1,32 @@ +'''OpenGL extension EXT.clip_volume_hint + +This module customises the behaviour of the +OpenGL.raw.GL.EXT.clip_volume_hint to provide a more +Python-friendly API + +Overview (from the spec) + + EXT_clip_volume_hint provides a mechanism for applications to + indicate that they do not require clip volume clipping for + primitives. It allows applications to maximize performance in + situations where they know that clipping is unnecessary. + EXT_clip_volume_hint is only an indication, though, and + implementations are free to ignore it. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/clip_volume_hint.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.EXT.clip_volume_hint import * +from OpenGL.raw.GL.EXT.clip_volume_hint import _EXTENSION_NAME + +def glInitClipVolumeHintEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/cmyka.py b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/cmyka.py new file mode 100644 index 00000000..0d934872 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/cmyka.py @@ -0,0 +1,44 @@ +'''OpenGL extension EXT.cmyka + +This module customises the behaviour of the +OpenGL.raw.GL.EXT.cmyka to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides a simple method for OpenGL to read and store + images whose pixels have CMYK or CMYKA formats. The algorithms used to + convert to RGBA from CMYKA and to convert back from RGBA to CMYKA are of + the "black-box" nature, meaning that the application has little control + over how the conversion is done. Also, this black-box mechanism is + available only for transfers to or from memory, not for internal copies + of pixel data (such as invoked by CopyPixels, CopyTexImage1D, etc.) + However, the defined mechanism nicely handles 5-component CMYKA images, + and it is very easy to use. + + A more configurable and potentially higher quality color conversion can + be implemented using the color tables, the color matrix, and possibly 3D + and 4D texture lookup. Such a color conversion also applies to copied + pixel data. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/cmyka.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.EXT.cmyka import * +from OpenGL.raw.GL.EXT.cmyka import _EXTENSION_NAME + +def glInitCmykaEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION +from OpenGL import images as _i + +_i.COMPONENT_COUNTS[ GL_CMYK_EXT ] = 4 +_i.COMPONENT_COUNTS[ GL_CMYKA_EXT ] = 5 diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/color_subtable.py b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/color_subtable.py new file mode 100644 index 00000000..cfc06a50 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/color_subtable.py @@ -0,0 +1,34 @@ +'''OpenGL extension EXT.color_subtable + +This module customises the behaviour of the +OpenGL.raw.GL.EXT.color_subtable to provide a more +Python-friendly API + +Overview (from the spec) + + This extension allows a portion of a color table to be redefined. + If EXT_copy_texture is implemented, this extension also defines a + method to load a portion of a color lookup table from the + framebuffer. + + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/color_subtable.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.EXT.color_subtable import * +from OpenGL.raw.GL.EXT.color_subtable import _EXTENSION_NAME + +def glInitColorSubtableEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glColorSubTableEXT.data size not checked against 'format,type,count' +glColorSubTableEXT=wrapper.wrapper(glColorSubTableEXT).setInputArraySize( + 'data', None +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/compiled_vertex_array.py b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/compiled_vertex_array.py new file mode 100644 index 00000000..72b362c0 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/compiled_vertex_array.py @@ -0,0 +1,41 @@ +'''OpenGL extension EXT.compiled_vertex_array + +This module customises the behaviour of the +OpenGL.raw.GL.EXT.compiled_vertex_array to provide a more +Python-friendly API + +Overview (from the spec) + + This extension defines an interface which allows static vertex array + data to be cached or pre-compiled for more efficient rendering. This + is useful for implementations which can cache the transformed results + of array data for reuse by several DrawArrays, ArrayElement, or + DrawElements commands. It is also useful for implementations which + can transfer array data to fast memory for more efficient processing. + + For example, rendering an M by N mesh of quadrilaterals can be + accomplished by setting up vertex arrays containing all of the + vertexes in the mesh and issuing M DrawElements commands each of + which operate on 2 * N vertexes. Each DrawElements command after + the first will share N vertexes with the preceding DrawElements + command. If the vertex array data is locked while the DrawElements + commands are executed, then OpenGL may be able to transform each + of these shared vertexes just once. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/compiled_vertex_array.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.EXT.compiled_vertex_array import * +from OpenGL.raw.GL.EXT.compiled_vertex_array import _EXTENSION_NAME + +def glInitCompiledVertexArrayEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/convolution.py b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/convolution.py new file mode 100644 index 00000000..7d14063d --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/convolution.py @@ -0,0 +1,67 @@ +'''OpenGL extension EXT.convolution + +This module customises the behaviour of the +OpenGL.raw.GL.EXT.convolution to provide a more +Python-friendly API + +Overview (from the spec) + + This extension defines 1 and 2 dimensional convolution operations + at a fixed location in the pixel transfer process. Thus pixel drawing, + reading, and copying, as well as texture image definition, are all + candidates for convolution. The convolution kernels are themselves + treated as 1 and 2 dimensional images, which can be loaded from + application memory or from the framebuffer. + + This extension is designed to accommodate 3D convolution, but the + API is left for a future extension. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/convolution.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.EXT.convolution import * +from OpenGL.raw.GL.EXT.convolution import _EXTENSION_NAME + +def glInitConvolutionEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glConvolutionFilter1DEXT.image size not checked against 'format,type,width' +glConvolutionFilter1DEXT=wrapper.wrapper(glConvolutionFilter1DEXT).setInputArraySize( + 'image', None +) +# INPUT glConvolutionFilter2DEXT.image size not checked against 'format,type,width,height' +glConvolutionFilter2DEXT=wrapper.wrapper(glConvolutionFilter2DEXT).setInputArraySize( + 'image', None +) +# INPUT glConvolutionParameterfvEXT.params size not checked against 'pname' +glConvolutionParameterfvEXT=wrapper.wrapper(glConvolutionParameterfvEXT).setInputArraySize( + 'params', None +) +# INPUT glConvolutionParameterivEXT.params size not checked against 'pname' +glConvolutionParameterivEXT=wrapper.wrapper(glConvolutionParameterivEXT).setInputArraySize( + 'params', None +) +# OUTPUT glGetConvolutionFilterEXT.image COMPSIZE(target, format, type) +glGetConvolutionParameterfvEXT=wrapper.wrapper(glGetConvolutionParameterfvEXT).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetConvolutionParameterivEXT=wrapper.wrapper(glGetConvolutionParameterivEXT).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +# OUTPUT glGetSeparableFilterEXT.column COMPSIZE(target, format, type) +# OUTPUT glGetSeparableFilterEXT.row COMPSIZE(target, format, type) +# OUTPUT glGetSeparableFilterEXT.span COMPSIZE(target, format, type) +# INPUT glSeparableFilter2DEXT.column size not checked against 'target,format,type,height' +# INPUT glSeparableFilter2DEXT.row size not checked against 'target,format,type,width' +glSeparableFilter2DEXT=wrapper.wrapper(glSeparableFilter2DEXT).setInputArraySize( + 'column', None +).setInputArraySize( + 'row', None +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/coordinate_frame.py b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/coordinate_frame.py new file mode 100644 index 00000000..d90fa0c0 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/coordinate_frame.py @@ -0,0 +1,67 @@ +'''OpenGL extension EXT.coordinate_frame + +This module customises the behaviour of the +OpenGL.raw.GL.EXT.coordinate_frame to provide a more +Python-friendly API + +Overview (from the spec) + + This extension allows specifying a per-vertex tangent and binormal + vector in addition to the normal vector, defining a coordinate frame. + The coordinate frame is used in additional extensions which also build + on fragment lighting to achieve bump mapping. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/coordinate_frame.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.EXT.coordinate_frame import * +from OpenGL.raw.GL.EXT.coordinate_frame import _EXTENSION_NAME + +def glInitCoordinateFrameEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +glTangent3bvEXT=wrapper.wrapper(glTangent3bvEXT).setInputArraySize( + 'v', 3 +) +glTangent3dvEXT=wrapper.wrapper(glTangent3dvEXT).setInputArraySize( + 'v', 3 +) +glTangent3fvEXT=wrapper.wrapper(glTangent3fvEXT).setInputArraySize( + 'v', 3 +) +glTangent3ivEXT=wrapper.wrapper(glTangent3ivEXT).setInputArraySize( + 'v', 3 +) +glTangent3svEXT=wrapper.wrapper(glTangent3svEXT).setInputArraySize( + 'v', 3 +) +glBinormal3bvEXT=wrapper.wrapper(glBinormal3bvEXT).setInputArraySize( + 'v', 3 +) +glBinormal3dvEXT=wrapper.wrapper(glBinormal3dvEXT).setInputArraySize( + 'v', 3 +) +glBinormal3fvEXT=wrapper.wrapper(glBinormal3fvEXT).setInputArraySize( + 'v', 3 +) +glBinormal3ivEXT=wrapper.wrapper(glBinormal3ivEXT).setInputArraySize( + 'v', 3 +) +glBinormal3svEXT=wrapper.wrapper(glBinormal3svEXT).setInputArraySize( + 'v', 3 +) +# INPUT glTangentPointerEXT.pointer size not checked against 'type,stride' +glTangentPointerEXT=wrapper.wrapper(glTangentPointerEXT).setInputArraySize( + 'pointer', None +) +# INPUT glBinormalPointerEXT.pointer size not checked against 'type,stride' +glBinormalPointerEXT=wrapper.wrapper(glBinormalPointerEXT).setInputArraySize( + 'pointer', None +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/copy_texture.py b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/copy_texture.py new file mode 100644 index 00000000..d970d67c --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/copy_texture.py @@ -0,0 +1,31 @@ +'''OpenGL extension EXT.copy_texture + +This module customises the behaviour of the +OpenGL.raw.GL.EXT.copy_texture to provide a more +Python-friendly API + +Overview (from the spec) + + This extension defines methods to load texture images directly from the + framebuffer. Methods are defined for both complete and partial + replacement of a texture image. Because it is not possible to define + an entire 3D texture using a 2D framebuffer image, 3D textures are + supported only for partial replacement. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/copy_texture.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.EXT.copy_texture import * +from OpenGL.raw.GL.EXT.copy_texture import _EXTENSION_NAME + +def glInitCopyTextureEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/cull_vertex.py b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/cull_vertex.py new file mode 100644 index 00000000..fe34f921 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/cull_vertex.py @@ -0,0 +1,42 @@ +'''OpenGL extension EXT.cull_vertex + +This module customises the behaviour of the +OpenGL.raw.GL.EXT.cull_vertex to provide a more +Python-friendly API + +Overview (from the spec) + + This extension introduces a method for culling vertexes in object + space based on the value of the dot product between the normal at + the vertex and a culling eye direction. + + Culling a polygon by examining its vertexes in object space can be + more efficient than screen space polygon culling since the transformation + to screen space (which may include a division by w) can be avoided for + culled vertexes. Also, vertex culling can be computed before vertexes + are assembled into primitives. This is a useful property when drawing + meshes with shared vertexes, since a vertex can be culled once, and the + resulting state can be used for all primitives which share the vertex. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/cull_vertex.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.EXT.cull_vertex import * +from OpenGL.raw.GL.EXT.cull_vertex import _EXTENSION_NAME + +def glInitCullVertexEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +glCullParameterdvEXT=wrapper.wrapper(glCullParameterdvEXT).setOutput( + 'params',size=(4,),orPassIn=True +) +glCullParameterfvEXT=wrapper.wrapper(glCullParameterfvEXT).setOutput( + 'params',size=(4,),orPassIn=True +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/debug_label.py b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/debug_label.py new file mode 100644 index 00000000..d89314bb --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/debug_label.py @@ -0,0 +1,43 @@ +'''OpenGL extension EXT.debug_label + +This module customises the behaviour of the +OpenGL.raw.GL.EXT.debug_label to provide a more +Python-friendly API + +Overview (from the spec) + + This extension defines a mechanism for OpenGL and OpenGL ES applications to + label their objects (textures, buffers, shaders, etc.) with a descriptive + string. + + When profiling or debugging such an application within a debugger or + profiler it is difficult to identify resources from their object names. + Even when the resource itself is viewed it can be problematic to + differentiate between similar resources. Attaching a label to an object + helps obviate this difficulty. + + The intended purpose of this is purely to improve the user experience + within OpenGL and OpenGL ES development tools. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/debug_label.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.EXT.debug_label import * +from OpenGL.raw.GL.EXT.debug_label import _EXTENSION_NAME + +def glInitDebugLabelEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glGetObjectLabelEXT.label size not checked against bufSize +glGetObjectLabelEXT=wrapper.wrapper(glGetObjectLabelEXT).setInputArraySize( + 'label', None +).setInputArraySize( + 'length', 1 +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/debug_marker.py b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/debug_marker.py new file mode 100644 index 00000000..63f26563 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/debug_marker.py @@ -0,0 +1,38 @@ +'''OpenGL extension EXT.debug_marker + +This module customises the behaviour of the +OpenGL.raw.GL.EXT.debug_marker to provide a more +Python-friendly API + +Overview (from the spec) + + This extension defines a mechanism for OpenGL and OpenGL ES applications to + annotate their command stream with markers for discrete events and groups + of commands using descriptive text markers. + + When profiling or debugging such an application within a debugger or + profiler it is difficult to relate the commands within the command stream + to the elements of the scene or parts of the program code to which they + correspond. Markers help obviate this by allowing applications to specify + this link. + + The intended purpose of this is purely to improve the user experience + within OpenGL and OpenGL ES development tools. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/debug_marker.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.EXT.debug_marker import * +from OpenGL.raw.GL.EXT.debug_marker import _EXTENSION_NAME + +def glInitDebugMarkerEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/depth_bounds_test.py b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/depth_bounds_test.py new file mode 100644 index 00000000..bf4ab902 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/depth_bounds_test.py @@ -0,0 +1,67 @@ +'''OpenGL extension EXT.depth_bounds_test + +This module customises the behaviour of the +OpenGL.raw.GL.EXT.depth_bounds_test to provide a more +Python-friendly API + +Overview (from the spec) + + This extension adds a new per-fragment test that is, logically, + after the scissor test and before the alpha test. The depth bounds + test compares the depth value stored at the location given by the + incoming fragment's (xw,yw) coordinates to a user-defined minimum + and maximum depth value. If the stored depth value is outside the + user-defined range (exclusive), the incoming fragment is discarded. + + Unlike the depth test, the depth bounds test has NO dependency on + the fragment's window-space depth value. + + This functionality is useful in the context of attenuated stenciled + shadow volume rendering. To motivate the functionality's utility + in this context, we first describe how conventional scissor testing + can be used to optimize shadow volume rendering. + + If an attenuated light source's illumination can be bounded to a + rectangle in XY window-space, the conventional scissor test can be + used to discard shadow volume fragments that are guaranteed to be + outside the light source's window-space XY rectangle. The stencil + increments and decrements that would otherwise be generated by these + scissored fragments are inconsequential because the light source's + illumination can pre-determined to be fully attenuated outside the + scissored region. In other words, the scissor test can be used to + discard shadow volume fragments rendered outside the scissor, thereby + improving performance, without affecting the ultimate illumination + of these pixels with respect to the attenuated light source. + + This scissoring optimization can be used both when rendering + the stenciled shadow volumes to update stencil (incrementing and + decrementing the stencil buffer) AND when adding the illumination + contribution of attenuated light source's. + + In a similar fashion, we can compute the attenuated light source's + window-space Z bounds (zmin,zmax) of consequential illumination. + Unless a depth value (in the depth buffer) at a pixel is within + the range [zmin,zmax], the light source's illumination can be + pre-determined to be inconsequential for the pixel. Said another + way, the pixel being illuminated is either far enough in front of + or behind the attenuated light source so that the light source's + illumination for the pixel is fully attenuated. The depth bounds + test can perform this test. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/depth_bounds_test.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.EXT.depth_bounds_test import * +from OpenGL.raw.GL.EXT.depth_bounds_test import _EXTENSION_NAME + +def glInitDepthBoundsTestEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/direct_state_access.py b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/direct_state_access.py new file mode 100644 index 00000000..6ba92072 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/direct_state_access.py @@ -0,0 +1,720 @@ +'''OpenGL extension EXT.direct_state_access + +This module customises the behaviour of the +OpenGL.raw.GL.EXT.direct_state_access to provide a more +Python-friendly API + +Overview (from the spec) + + This extension introduces a set of new "direct state access" + commands (meaning no selector is involved) to access (update and + query) OpenGL state that previously depended on the OpenGL state + selectors for access. These new commands supplement the existing + selector-based OpenGL commands to access the same state. + + The intent of this extension is to make it more efficient for + libraries to avoid disturbing selector and latched state. The + extension also allows more efficient command usage by eliminating + the need for selector update commands. + + Two derivative advantages of this extension are 1) display lists + can be executed using these commands that avoid disturbing selectors + that subsequent commands may depend on, and 2) drivers implemented + with a dual-thread partitioning with OpenGL command buffering from + an application thread and then OpenGL command dispatching in a + concurrent driver thread can avoid thread synchronization created by + selector saving, setting, command execution, and selector restoration. + + This extension does not itself add any new OpenGL state. + + We call a state variable in OpenGL an "OpenGL state selector" or + simply a "selector" if OpenGL commands depend on the state variable + to determine what state to query or update. The matrix mode and + active texture are both selectors. Object bindings for buffers, + programs, textures, and framebuffer objects are also selectors. + + We call OpenGL state "latched" if the state is set by one OpenGL + command but then that state is saved by a subsequent command or the + state determines how client memory or buffer object memory is accessed + by a subsequent command. The array and element array buffer bindings + are latched by vertex array specification commands to determine + which buffer a given vertex array uses. Vertex array state and pixel + pack/unpack state decides how client memory or buffer object memory is + accessed by subsequent vertex pulling or image specification commands. + + The existence of selectors and latched state in the OpenGL API + reduces the number of parameters to various sets of OpenGL commands + but complicates the access to state for layered libraries which seek + to access state without disturbing other state, namely the state of + state selectors and latched state. In many cases, selectors and + latched state were introduced by extensions as OpenGL evolved to + minimize the disruption to the OpenGL API when new functionality, + particularly the pluralization of existing functionality as when + texture objects and later multiple texture units, was introduced. + + The OpenGL API involves several selectors (listed in historical + order of introduction): + + o The matrix mode. + + o The current bound texture for each supported texture target. + + o The active texture. + + o The active client texture. + + o The current bound program for each supported program target. + + o The current bound buffer for each supported buffer target. + + o The current GLSL program. + + o The current framebuffer object. + + The new selector-free update commands can be compiled into display + lists. + + The OpenGL API has latched state for vertex array buffer objects + and pixel store state. When an application issues a GL command to + unpack or pack pixels (for example, glTexImage2D or glReadPixels + respectively), the current unpack and pack pixel store state + determines how the pixels are unpacked from/packed to client memory + or pixel buffer objects. For example, consider: + + glPixelStorei(GL_UNPACK_SWAP_BYTES, GL_TRUE); + glPixelStorei(GL_UNPACK_ROW_LENGTH, 640); + glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 47); + glDrawPixels(100, 100, GL_RGB, GL_FLOAT, pixels); + + The unpack swap bytes and row length state set by the preceding + glPixelStorei commands (as well as the 6 other unpack pixel store + state variables) control how data is read (unpacked) from buffer of + data pointed to by pixels. The glBindBuffer command also specifies + an unpack buffer object (47) so the pixel pointer is actually treated + as a byte offset into buffer object 47. + + When an application issues a command to configure a vertex array, + the current array buffer state is latched as the binding for the + particular vertex array being specified. For example, consider: + + glBindBuffer(GL_ARRAY_BUFFER, 23); + glVertexPointer(3, GL_FLOAT, 12, pointer); + + The glBindBuffer command updates the array buffering binding + (GL_ARRAY_BUFFER_BINDING) to the buffer object named 23. The + subsequent glVertexPointer command specifies explicit parameters + for the size, type, stride, and pointer to access the position + vertex array BUT ALSO latches the current array buffer binding for + the vertex array buffer binding (GL_VERTEX_ARRAY_BUFFER_BINDING). + Effectively the current array buffer binding buffer object becomes + an implicit fifth parameter to glVertexPointer and this applies to + all the gl*Pointer vertex array specification commands. + + Selectors and latched state create problems for layered libraries + using OpenGL because selectors require the selector state to be + modified to update some other state and latched state means implicit + state can affect the operation of commands specifying, packing, or + unpacking data through pointers/offsets. For layered libraries, + a state update performed by the library may attempt to save the + selector state, set the selector, update/query some state the + selector controls, and then restore the selector to its saved state. + Layered libraries can skip the selector save/restore but this risks + introducing uncertainty about the state of a selector after calling + layered library routines. Such selector side-effects are difficult + to document and lead to compatibility issues as the layered library + evolves or its usage varies. For latched state, layered libraries + may find commands such as glDrawPixels do not work as expected + because latched pixel store state is not what the library expects. + Querying or pushing the latched state, setting the latched state + explicitly, performing the operation involving latched state, and + then restoring or popping the latched state avoids entanglements + with latched state but at considerable cost. + + EXAMPLE USAGE OF THIS EXTENSION'S FUNCTIONALITY + + Consider the following routine to set the modelview matrix involving + the matrix mode selector: + + void setModelviewMatrix(const GLfloat matrix[16]) + { + GLenum savedMatrixMode; + + glGetIntegerv(GL_MATRIX_MODE, &savedMatrixMode); + glMatrixMode(GL_MODELVIEW); + glLoadMatrixf(matrix); + glMatrixMode(savedMatrixMode); + } + + Notice that four OpenGL commands are required to update the current + modelview matrix without disturbing the matrix mode selector. + + OpenGL query commands can also substantially reduce the performance + of modern OpenGL implementations which may off-load OpenGL state + processing to another CPU core/thread or to the GPU itself. + + An alternative to querying the selector is to use the + glPushAttrib/glPopAttrib commands. However this approach typically + involves pushing far more state than simply the one or two selectors + that need to be saved and restored. Because so much state is + associated with a given push/pop attribute bit, the glPushAttrib + and glPopAttrib commands are considerably more costly than the + save/restore approach. Additionally glPushAttrib risks overflowing + the attribute stack. + + The reliability and performance of layered libraries and applications + can be improved by adding to the OpenGL API a new set of commands + to access directly OpenGL state that otherwise involves selectors + to access. + + The above example can be reimplemented more efficiently and without + selector side-effects: + + void setModelviewMatrix(const GLfloat matrix[16]) + { + glMatrixLoadfEXT(GL_MODELVIEW, matrix); + } + + Consider a layered library seeking to load a texture: + + void loadTexture(GLint texobj, GLint width, GLint height, + void *data) + { + glBindTexture(GL_TEXTURE_2D, texobj); + glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB8, + width, height, GL_RGB, GL_FLOAT, data); + } + + The library expects the data to be packed into the buffer pointed + to by data. But what if the current pixel unpack buffer binding + is not zero so the current pixel unpack buffer, rather than client + memory, will be read? Or what if the application has modified + the GL_UNPACK_ROW_LENGTH pixel store state before loadTexture + is called? + + We can fix the routine by calling glBindBuffer(GL_PIXEL_UNPACK_BUFFER, + 0) and setting all the pixel store unpack state to the initial state + the loadTexture routine expects, but this is expensive. It also risks + disturbing the state so when loadTexture returns to the application, + the application doesn't realize the current texture object (for + whatever texture unit the current active texture happens to be) and + pixel store state has changed. + + We can more efficiently implement this routine without disturbing + selector or latched state as follows: + + void loadTexture(GLint texobj, GLint width, GLint height, + void *data) + { + glPushClientAttribDefaultEXT(GL_CLIENT_PIXEL_STORE_BIT); + glTextureImage2D(texobj, GL_TEXTURE_2D, 0, GL_RGB8, + width, height, GL_RGB, GL_FLOAT, data); + glPopClientAttrib(); + } + + Now loadTexture does not have to worry about inappropriately + configured pixel store state or a non-zero pixel unpack buffer + binding. And loadTexture has no unintended side-effects for + selector or latched state (assuming the client attrib state does + not overflow). + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/direct_state_access.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.EXT.direct_state_access import * +from OpenGL.raw.GL.EXT.direct_state_access import _EXTENSION_NAME + +def glInitDirectStateAccessEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +glMatrixLoadfEXT=wrapper.wrapper(glMatrixLoadfEXT).setInputArraySize( + 'm', 16 +) +glMatrixLoaddEXT=wrapper.wrapper(glMatrixLoaddEXT).setInputArraySize( + 'm', 16 +) +glMatrixMultfEXT=wrapper.wrapper(glMatrixMultfEXT).setInputArraySize( + 'm', 16 +) +glMatrixMultdEXT=wrapper.wrapper(glMatrixMultdEXT).setInputArraySize( + 'm', 16 +) +# INPUT glTextureParameterfvEXT.params size not checked against 'pname' +glTextureParameterfvEXT=wrapper.wrapper(glTextureParameterfvEXT).setInputArraySize( + 'params', None +) +# INPUT glTextureParameterivEXT.params size not checked against 'pname' +glTextureParameterivEXT=wrapper.wrapper(glTextureParameterivEXT).setInputArraySize( + 'params', None +) +# INPUT glTextureImage1DEXT.pixels size not checked against 'format,type,width' +glTextureImage1DEXT=wrapper.wrapper(glTextureImage1DEXT).setInputArraySize( + 'pixels', None +) +# INPUT glTextureImage2DEXT.pixels size not checked against 'format,type,width,height' +glTextureImage2DEXT=wrapper.wrapper(glTextureImage2DEXT).setInputArraySize( + 'pixels', None +) +# INPUT glTextureSubImage1DEXT.pixels size not checked against 'format,type,width' +glTextureSubImage1DEXT=wrapper.wrapper(glTextureSubImage1DEXT).setInputArraySize( + 'pixels', None +) +# INPUT glTextureSubImage2DEXT.pixels size not checked against 'format,type,width,height' +glTextureSubImage2DEXT=wrapper.wrapper(glTextureSubImage2DEXT).setInputArraySize( + 'pixels', None +) +# OUTPUT glGetTextureImageEXT.pixels COMPSIZE(target, level, format, type) +glGetTextureParameterfvEXT=wrapper.wrapper(glGetTextureParameterfvEXT).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetTextureParameterivEXT=wrapper.wrapper(glGetTextureParameterivEXT).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetTextureLevelParameterfvEXT=wrapper.wrapper(glGetTextureLevelParameterfvEXT).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetTextureLevelParameterivEXT=wrapper.wrapper(glGetTextureLevelParameterivEXT).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +# INPUT glTextureImage3DEXT.pixels size not checked against 'format,type,width,height,depth' +glTextureImage3DEXT=wrapper.wrapper(glTextureImage3DEXT).setInputArraySize( + 'pixels', None +) +# INPUT glTextureSubImage3DEXT.pixels size not checked against 'format,type,width,height,depth' +glTextureSubImage3DEXT=wrapper.wrapper(glTextureSubImage3DEXT).setInputArraySize( + 'pixels', None +) +# INPUT glMultiTexCoordPointerEXT.pointer size not checked against 'size,type,stride' +glMultiTexCoordPointerEXT=wrapper.wrapper(glMultiTexCoordPointerEXT).setInputArraySize( + 'pointer', None +) +# INPUT glMultiTexEnvfvEXT.params size not checked against 'pname' +glMultiTexEnvfvEXT=wrapper.wrapper(glMultiTexEnvfvEXT).setInputArraySize( + 'params', None +) +# INPUT glMultiTexEnvivEXT.params size not checked against 'pname' +glMultiTexEnvivEXT=wrapper.wrapper(glMultiTexEnvivEXT).setInputArraySize( + 'params', None +) +# INPUT glMultiTexGendvEXT.params size not checked against 'pname' +glMultiTexGendvEXT=wrapper.wrapper(glMultiTexGendvEXT).setInputArraySize( + 'params', None +) +# INPUT glMultiTexGenfvEXT.params size not checked against 'pname' +glMultiTexGenfvEXT=wrapper.wrapper(glMultiTexGenfvEXT).setInputArraySize( + 'params', None +) +# INPUT glMultiTexGenivEXT.params size not checked against 'pname' +glMultiTexGenivEXT=wrapper.wrapper(glMultiTexGenivEXT).setInputArraySize( + 'params', None +) +glGetMultiTexEnvfvEXT=wrapper.wrapper(glGetMultiTexEnvfvEXT).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetMultiTexEnvivEXT=wrapper.wrapper(glGetMultiTexEnvivEXT).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetMultiTexGendvEXT=wrapper.wrapper(glGetMultiTexGendvEXT).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetMultiTexGenfvEXT=wrapper.wrapper(glGetMultiTexGenfvEXT).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetMultiTexGenivEXT=wrapper.wrapper(glGetMultiTexGenivEXT).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +# INPUT glMultiTexParameterivEXT.params size not checked against 'pname' +glMultiTexParameterivEXT=wrapper.wrapper(glMultiTexParameterivEXT).setInputArraySize( + 'params', None +) +# INPUT glMultiTexParameterfvEXT.params size not checked against 'pname' +glMultiTexParameterfvEXT=wrapper.wrapper(glMultiTexParameterfvEXT).setInputArraySize( + 'params', None +) +# INPUT glMultiTexImage1DEXT.pixels size not checked against 'format,type,width' +glMultiTexImage1DEXT=wrapper.wrapper(glMultiTexImage1DEXT).setInputArraySize( + 'pixels', None +) +# INPUT glMultiTexImage2DEXT.pixels size not checked against 'format,type,width,height' +glMultiTexImage2DEXT=wrapper.wrapper(glMultiTexImage2DEXT).setInputArraySize( + 'pixels', None +) +# INPUT glMultiTexSubImage1DEXT.pixels size not checked against 'format,type,width' +glMultiTexSubImage1DEXT=wrapper.wrapper(glMultiTexSubImage1DEXT).setInputArraySize( + 'pixels', None +) +# INPUT glMultiTexSubImage2DEXT.pixels size not checked against 'format,type,width,height' +glMultiTexSubImage2DEXT=wrapper.wrapper(glMultiTexSubImage2DEXT).setInputArraySize( + 'pixels', None +) +# OUTPUT glGetMultiTexImageEXT.pixels COMPSIZE(target, level, format, type) +glGetMultiTexParameterfvEXT=wrapper.wrapper(glGetMultiTexParameterfvEXT).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetMultiTexParameterivEXT=wrapper.wrapper(glGetMultiTexParameterivEXT).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetMultiTexLevelParameterfvEXT=wrapper.wrapper(glGetMultiTexLevelParameterfvEXT).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetMultiTexLevelParameterivEXT=wrapper.wrapper(glGetMultiTexLevelParameterivEXT).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +# INPUT glMultiTexImage3DEXT.pixels size not checked against 'format,type,width,height,depth' +glMultiTexImage3DEXT=wrapper.wrapper(glMultiTexImage3DEXT).setInputArraySize( + 'pixels', None +) +# INPUT glMultiTexSubImage3DEXT.pixels size not checked against 'format,type,width,height,depth' +glMultiTexSubImage3DEXT=wrapper.wrapper(glMultiTexSubImage3DEXT).setInputArraySize( + 'pixels', None +) +glGetFloatIndexedvEXT=wrapper.wrapper(glGetFloatIndexedvEXT).setOutput( + 'data',size=_glgets._glget_size_mapping,pnameArg='target',orPassIn=True +) +glGetDoubleIndexedvEXT=wrapper.wrapper(glGetDoubleIndexedvEXT).setOutput( + 'data',size=_glgets._glget_size_mapping,pnameArg='target',orPassIn=True +) +glGetPointerIndexedvEXT=wrapper.wrapper(glGetPointerIndexedvEXT).setOutput( + 'data',size=(1,),orPassIn=True +) +glGetIntegerIndexedvEXT=wrapper.wrapper(glGetIntegerIndexedvEXT).setOutput( + 'data',size=_glgets._glget_size_mapping,pnameArg='target',orPassIn=True +) +glGetBooleanIndexedvEXT=wrapper.wrapper(glGetBooleanIndexedvEXT).setOutput( + 'data',size=_glgets._glget_size_mapping,pnameArg='target',orPassIn=True +) +# INPUT glCompressedTextureImage3DEXT.bits size not checked against imageSize +glCompressedTextureImage3DEXT=wrapper.wrapper(glCompressedTextureImage3DEXT).setInputArraySize( + 'bits', None +) +# INPUT glCompressedTextureImage2DEXT.bits size not checked against imageSize +glCompressedTextureImage2DEXT=wrapper.wrapper(glCompressedTextureImage2DEXT).setInputArraySize( + 'bits', None +) +# INPUT glCompressedTextureImage1DEXT.bits size not checked against imageSize +glCompressedTextureImage1DEXT=wrapper.wrapper(glCompressedTextureImage1DEXT).setInputArraySize( + 'bits', None +) +# INPUT glCompressedTextureSubImage3DEXT.bits size not checked against imageSize +glCompressedTextureSubImage3DEXT=wrapper.wrapper(glCompressedTextureSubImage3DEXT).setInputArraySize( + 'bits', None +) +# INPUT glCompressedTextureSubImage2DEXT.bits size not checked against imageSize +glCompressedTextureSubImage2DEXT=wrapper.wrapper(glCompressedTextureSubImage2DEXT).setInputArraySize( + 'bits', None +) +# INPUT glCompressedTextureSubImage1DEXT.bits size not checked against imageSize +glCompressedTextureSubImage1DEXT=wrapper.wrapper(glCompressedTextureSubImage1DEXT).setInputArraySize( + 'bits', None +) +# OUTPUT glGetCompressedTextureImageEXT.img COMPSIZE(target, lod) +# INPUT glCompressedMultiTexImage3DEXT.bits size not checked against imageSize +glCompressedMultiTexImage3DEXT=wrapper.wrapper(glCompressedMultiTexImage3DEXT).setInputArraySize( + 'bits', None +) +# INPUT glCompressedMultiTexImage2DEXT.bits size not checked against imageSize +glCompressedMultiTexImage2DEXT=wrapper.wrapper(glCompressedMultiTexImage2DEXT).setInputArraySize( + 'bits', None +) +# INPUT glCompressedMultiTexImage1DEXT.bits size not checked against imageSize +glCompressedMultiTexImage1DEXT=wrapper.wrapper(glCompressedMultiTexImage1DEXT).setInputArraySize( + 'bits', None +) +# INPUT glCompressedMultiTexSubImage3DEXT.bits size not checked against imageSize +glCompressedMultiTexSubImage3DEXT=wrapper.wrapper(glCompressedMultiTexSubImage3DEXT).setInputArraySize( + 'bits', None +) +# INPUT glCompressedMultiTexSubImage2DEXT.bits size not checked against imageSize +glCompressedMultiTexSubImage2DEXT=wrapper.wrapper(glCompressedMultiTexSubImage2DEXT).setInputArraySize( + 'bits', None +) +# INPUT glCompressedMultiTexSubImage1DEXT.bits size not checked against imageSize +glCompressedMultiTexSubImage1DEXT=wrapper.wrapper(glCompressedMultiTexSubImage1DEXT).setInputArraySize( + 'bits', None +) +# OUTPUT glGetCompressedMultiTexImageEXT.img COMPSIZE(target, lod) +glMatrixLoadTransposefEXT=wrapper.wrapper(glMatrixLoadTransposefEXT).setInputArraySize( + 'm', 16 +) +glMatrixLoadTransposedEXT=wrapper.wrapper(glMatrixLoadTransposedEXT).setInputArraySize( + 'm', 16 +) +glMatrixMultTransposefEXT=wrapper.wrapper(glMatrixMultTransposefEXT).setInputArraySize( + 'm', 16 +) +glMatrixMultTransposedEXT=wrapper.wrapper(glMatrixMultTransposedEXT).setInputArraySize( + 'm', 16 +) +# INPUT glNamedBufferDataEXT.data size not checked against 'size' +glNamedBufferDataEXT=wrapper.wrapper(glNamedBufferDataEXT).setInputArraySize( + 'data', None +) +# INPUT glNamedBufferSubDataEXT.data size not checked against 'size' +glNamedBufferSubDataEXT=wrapper.wrapper(glNamedBufferSubDataEXT).setInputArraySize( + 'data', None +) +glGetNamedBufferParameterivEXT=wrapper.wrapper(glGetNamedBufferParameterivEXT).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetNamedBufferPointervEXT=wrapper.wrapper(glGetNamedBufferPointervEXT).setOutput( + 'params',size=(1,),orPassIn=True +) +glGetNamedBufferSubDataEXT=wrapper.wrapper(glGetNamedBufferSubDataEXT).setOutput( + 'data',size=_glgets._glget_size_mapping,pnameArg='size',orPassIn=True +) +# INPUT glProgramUniform1fvEXT.value size not checked against count +glProgramUniform1fvEXT=wrapper.wrapper(glProgramUniform1fvEXT).setInputArraySize( + 'value', None +) +# INPUT glProgramUniform2fvEXT.value size not checked against count*2 +glProgramUniform2fvEXT=wrapper.wrapper(glProgramUniform2fvEXT).setInputArraySize( + 'value', None +) +# INPUT glProgramUniform3fvEXT.value size not checked against count*3 +glProgramUniform3fvEXT=wrapper.wrapper(glProgramUniform3fvEXT).setInputArraySize( + 'value', None +) +# INPUT glProgramUniform4fvEXT.value size not checked against count*4 +glProgramUniform4fvEXT=wrapper.wrapper(glProgramUniform4fvEXT).setInputArraySize( + 'value', None +) +# INPUT glProgramUniform1ivEXT.value size not checked against count +glProgramUniform1ivEXT=wrapper.wrapper(glProgramUniform1ivEXT).setInputArraySize( + 'value', None +) +# INPUT glProgramUniform2ivEXT.value size not checked against count*2 +glProgramUniform2ivEXT=wrapper.wrapper(glProgramUniform2ivEXT).setInputArraySize( + 'value', None +) +# INPUT glProgramUniform3ivEXT.value size not checked against count*3 +glProgramUniform3ivEXT=wrapper.wrapper(glProgramUniform3ivEXT).setInputArraySize( + 'value', None +) +# INPUT glProgramUniform4ivEXT.value size not checked against count*4 +glProgramUniform4ivEXT=wrapper.wrapper(glProgramUniform4ivEXT).setInputArraySize( + 'value', None +) +# INPUT glProgramUniformMatrix2fvEXT.value size not checked against count*4 +glProgramUniformMatrix2fvEXT=wrapper.wrapper(glProgramUniformMatrix2fvEXT).setInputArraySize( + 'value', None +) +# INPUT glProgramUniformMatrix3fvEXT.value size not checked against count*9 +glProgramUniformMatrix3fvEXT=wrapper.wrapper(glProgramUniformMatrix3fvEXT).setInputArraySize( + 'value', None +) +# INPUT glProgramUniformMatrix4fvEXT.value size not checked against count*16 +glProgramUniformMatrix4fvEXT=wrapper.wrapper(glProgramUniformMatrix4fvEXT).setInputArraySize( + 'value', None +) +# INPUT glProgramUniformMatrix2x3fvEXT.value size not checked against count*6 +glProgramUniformMatrix2x3fvEXT=wrapper.wrapper(glProgramUniformMatrix2x3fvEXT).setInputArraySize( + 'value', None +) +# INPUT glProgramUniformMatrix3x2fvEXT.value size not checked against count*6 +glProgramUniformMatrix3x2fvEXT=wrapper.wrapper(glProgramUniformMatrix3x2fvEXT).setInputArraySize( + 'value', None +) +# INPUT glProgramUniformMatrix2x4fvEXT.value size not checked against count*8 +glProgramUniformMatrix2x4fvEXT=wrapper.wrapper(glProgramUniformMatrix2x4fvEXT).setInputArraySize( + 'value', None +) +# INPUT glProgramUniformMatrix4x2fvEXT.value size not checked against count*8 +glProgramUniformMatrix4x2fvEXT=wrapper.wrapper(glProgramUniformMatrix4x2fvEXT).setInputArraySize( + 'value', None +) +# INPUT glProgramUniformMatrix3x4fvEXT.value size not checked against count*12 +glProgramUniformMatrix3x4fvEXT=wrapper.wrapper(glProgramUniformMatrix3x4fvEXT).setInputArraySize( + 'value', None +) +# INPUT glProgramUniformMatrix4x3fvEXT.value size not checked against count*12 +glProgramUniformMatrix4x3fvEXT=wrapper.wrapper(glProgramUniformMatrix4x3fvEXT).setInputArraySize( + 'value', None +) +# INPUT glTextureParameterIivEXT.params size not checked against 'pname' +glTextureParameterIivEXT=wrapper.wrapper(glTextureParameterIivEXT).setInputArraySize( + 'params', None +) +# INPUT glTextureParameterIuivEXT.params size not checked against 'pname' +glTextureParameterIuivEXT=wrapper.wrapper(glTextureParameterIuivEXT).setInputArraySize( + 'params', None +) +glGetTextureParameterIivEXT=wrapper.wrapper(glGetTextureParameterIivEXT).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetTextureParameterIuivEXT=wrapper.wrapper(glGetTextureParameterIuivEXT).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +# INPUT glMultiTexParameterIivEXT.params size not checked against 'pname' +glMultiTexParameterIivEXT=wrapper.wrapper(glMultiTexParameterIivEXT).setInputArraySize( + 'params', None +) +# INPUT glMultiTexParameterIuivEXT.params size not checked against 'pname' +glMultiTexParameterIuivEXT=wrapper.wrapper(glMultiTexParameterIuivEXT).setInputArraySize( + 'params', None +) +glGetMultiTexParameterIivEXT=wrapper.wrapper(glGetMultiTexParameterIivEXT).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetMultiTexParameterIuivEXT=wrapper.wrapper(glGetMultiTexParameterIuivEXT).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +# INPUT glProgramUniform1uivEXT.value size not checked against count +glProgramUniform1uivEXT=wrapper.wrapper(glProgramUniform1uivEXT).setInputArraySize( + 'value', None +) +# INPUT glProgramUniform2uivEXT.value size not checked against count*2 +glProgramUniform2uivEXT=wrapper.wrapper(glProgramUniform2uivEXT).setInputArraySize( + 'value', None +) +# INPUT glProgramUniform3uivEXT.value size not checked against count*3 +glProgramUniform3uivEXT=wrapper.wrapper(glProgramUniform3uivEXT).setInputArraySize( + 'value', None +) +# INPUT glProgramUniform4uivEXT.value size not checked against count*4 +glProgramUniform4uivEXT=wrapper.wrapper(glProgramUniform4uivEXT).setInputArraySize( + 'value', None +) +# INPUT glNamedProgramLocalParameters4fvEXT.params size not checked against count*4 +glNamedProgramLocalParameters4fvEXT=wrapper.wrapper(glNamedProgramLocalParameters4fvEXT).setInputArraySize( + 'params', None +) +glNamedProgramLocalParameterI4ivEXT=wrapper.wrapper(glNamedProgramLocalParameterI4ivEXT).setInputArraySize( + 'params', 4 +) +# INPUT glNamedProgramLocalParametersI4ivEXT.params size not checked against count*4 +glNamedProgramLocalParametersI4ivEXT=wrapper.wrapper(glNamedProgramLocalParametersI4ivEXT).setInputArraySize( + 'params', None +) +glNamedProgramLocalParameterI4uivEXT=wrapper.wrapper(glNamedProgramLocalParameterI4uivEXT).setInputArraySize( + 'params', 4 +) +# INPUT glNamedProgramLocalParametersI4uivEXT.params size not checked against count*4 +glNamedProgramLocalParametersI4uivEXT=wrapper.wrapper(glNamedProgramLocalParametersI4uivEXT).setInputArraySize( + 'params', None +) +glGetNamedProgramLocalParameterIivEXT=wrapper.wrapper(glGetNamedProgramLocalParameterIivEXT).setOutput( + 'params',size=(4,),orPassIn=True +) +glGetNamedProgramLocalParameterIuivEXT=wrapper.wrapper(glGetNamedProgramLocalParameterIuivEXT).setOutput( + 'params',size=(4,),orPassIn=True +) +# INPUT glGetFloati_vEXT.params size not checked against 'pname' +glGetFloati_vEXT=wrapper.wrapper(glGetFloati_vEXT).setInputArraySize( + 'params', None +) +# INPUT glGetDoublei_vEXT.params size not checked against 'pname' +glGetDoublei_vEXT=wrapper.wrapper(glGetDoublei_vEXT).setInputArraySize( + 'params', None +) +glGetPointeri_vEXT=wrapper.wrapper(glGetPointeri_vEXT).setInputArraySize( + 'params', 1 +) +# INPUT glNamedProgramStringEXT.string size not checked against len +glNamedProgramStringEXT=wrapper.wrapper(glNamedProgramStringEXT).setInputArraySize( + 'string', None +) +glNamedProgramLocalParameter4dvEXT=wrapper.wrapper(glNamedProgramLocalParameter4dvEXT).setInputArraySize( + 'params', 4 +) +glNamedProgramLocalParameter4fvEXT=wrapper.wrapper(glNamedProgramLocalParameter4fvEXT).setInputArraySize( + 'params', 4 +) +glGetNamedProgramLocalParameterdvEXT=wrapper.wrapper(glGetNamedProgramLocalParameterdvEXT).setOutput( + 'params',size=(4,),orPassIn=True +) +glGetNamedProgramLocalParameterfvEXT=wrapper.wrapper(glGetNamedProgramLocalParameterfvEXT).setOutput( + 'params',size=(4,),orPassIn=True +) +glGetNamedProgramivEXT=wrapper.wrapper(glGetNamedProgramivEXT).setOutput( + 'params',size=(1,),orPassIn=True +) +# OUTPUT glGetNamedProgramStringEXT.string COMPSIZE(program, pname) +glGetNamedRenderbufferParameterivEXT=wrapper.wrapper(glGetNamedRenderbufferParameterivEXT).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetNamedFramebufferAttachmentParameterivEXT=wrapper.wrapper(glGetNamedFramebufferAttachmentParameterivEXT).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +# INPUT glFramebufferDrawBuffersEXT.bufs size not checked against n +glFramebufferDrawBuffersEXT=wrapper.wrapper(glFramebufferDrawBuffersEXT).setInputArraySize( + 'bufs', None +) +glGetFramebufferParameterivEXT=wrapper.wrapper(glGetFramebufferParameterivEXT).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetVertexArrayPointervEXT=wrapper.wrapper(glGetVertexArrayPointervEXT).setInputArraySize( + 'param', 1 +) +# INPUT glNamedBufferStorageEXT.data size not checked against size +glNamedBufferStorageEXT=wrapper.wrapper(glNamedBufferStorageEXT).setInputArraySize( + 'data', None +) +# INPUT glClearNamedBufferDataEXT.data size not checked against 'format,type' +glClearNamedBufferDataEXT=wrapper.wrapper(glClearNamedBufferDataEXT).setInputArraySize( + 'data', None +) +# INPUT glClearNamedBufferSubDataEXT.data size not checked against 'format,type' +glClearNamedBufferSubDataEXT=wrapper.wrapper(glClearNamedBufferSubDataEXT).setInputArraySize( + 'data', None +) +glGetNamedFramebufferParameterivEXT=wrapper.wrapper(glGetNamedFramebufferParameterivEXT).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +# INPUT glProgramUniform1dvEXT.value size not checked against count +glProgramUniform1dvEXT=wrapper.wrapper(glProgramUniform1dvEXT).setInputArraySize( + 'value', None +) +# INPUT glProgramUniform2dvEXT.value size not checked against count*2 +glProgramUniform2dvEXT=wrapper.wrapper(glProgramUniform2dvEXT).setInputArraySize( + 'value', None +) +# INPUT glProgramUniform3dvEXT.value size not checked against count*3 +glProgramUniform3dvEXT=wrapper.wrapper(glProgramUniform3dvEXT).setInputArraySize( + 'value', None +) +# INPUT glProgramUniform4dvEXT.value size not checked against count*4 +glProgramUniform4dvEXT=wrapper.wrapper(glProgramUniform4dvEXT).setInputArraySize( + 'value', None +) +# INPUT glProgramUniformMatrix2dvEXT.value size not checked against count*4 +glProgramUniformMatrix2dvEXT=wrapper.wrapper(glProgramUniformMatrix2dvEXT).setInputArraySize( + 'value', None +) +# INPUT glProgramUniformMatrix3dvEXT.value size not checked against count*9 +glProgramUniformMatrix3dvEXT=wrapper.wrapper(glProgramUniformMatrix3dvEXT).setInputArraySize( + 'value', None +) +# INPUT glProgramUniformMatrix4dvEXT.value size not checked against count*16 +glProgramUniformMatrix4dvEXT=wrapper.wrapper(glProgramUniformMatrix4dvEXT).setInputArraySize( + 'value', None +) +# INPUT glProgramUniformMatrix2x3dvEXT.value size not checked against count*6 +glProgramUniformMatrix2x3dvEXT=wrapper.wrapper(glProgramUniformMatrix2x3dvEXT).setInputArraySize( + 'value', None +) +# INPUT glProgramUniformMatrix2x4dvEXT.value size not checked against count*8 +glProgramUniformMatrix2x4dvEXT=wrapper.wrapper(glProgramUniformMatrix2x4dvEXT).setInputArraySize( + 'value', None +) +# INPUT glProgramUniformMatrix3x2dvEXT.value size not checked against count*6 +glProgramUniformMatrix3x2dvEXT=wrapper.wrapper(glProgramUniformMatrix3x2dvEXT).setInputArraySize( + 'value', None +) +# INPUT glProgramUniformMatrix3x4dvEXT.value size not checked against count*12 +glProgramUniformMatrix3x4dvEXT=wrapper.wrapper(glProgramUniformMatrix3x4dvEXT).setInputArraySize( + 'value', None +) +# INPUT glProgramUniformMatrix4x2dvEXT.value size not checked against count*8 +glProgramUniformMatrix4x2dvEXT=wrapper.wrapper(glProgramUniformMatrix4x2dvEXT).setInputArraySize( + 'value', None +) +# INPUT glProgramUniformMatrix4x3dvEXT.value size not checked against count*12 +glProgramUniformMatrix4x3dvEXT=wrapper.wrapper(glProgramUniformMatrix4x3dvEXT).setInputArraySize( + 'value', None +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/draw_buffers2.py b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/draw_buffers2.py new file mode 100644 index 00000000..c62525c9 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/draw_buffers2.py @@ -0,0 +1,40 @@ +'''OpenGL extension EXT.draw_buffers2 + +This module customises the behaviour of the +OpenGL.raw.GL.EXT.draw_buffers2 to provide a more +Python-friendly API + +Overview (from the spec) + + This extension builds upon the ARB_draw_buffers extension and provides + separate blend enables and color write masks for each color output. In + ARB_draw_buffers (part of OpenGL 2.0), separate values can be written to + each color buffer, but the blend enable and color write mask are global + and apply to all color outputs. + + While this extension does provide separate blend enables, it does not + provide separate blend functions or blend equations per color output. + + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/draw_buffers2.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.EXT.draw_buffers2 import * +from OpenGL.raw.GL.EXT.draw_buffers2 import _EXTENSION_NAME + +def glInitDrawBuffers2EXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +glGetBooleanIndexedvEXT=wrapper.wrapper(glGetBooleanIndexedvEXT).setOutput( + 'data',size=_glgets._glget_size_mapping,pnameArg='target',orPassIn=True +) +glGetIntegerIndexedvEXT=wrapper.wrapper(glGetIntegerIndexedvEXT).setOutput( + 'data',size=_glgets._glget_size_mapping,pnameArg='target',orPassIn=True +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/draw_instanced.py b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/draw_instanced.py new file mode 100644 index 00000000..40d1159e --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/draw_instanced.py @@ -0,0 +1,33 @@ +'''OpenGL extension EXT.draw_instanced + +This module customises the behaviour of the +OpenGL.raw.GL.EXT.draw_instanced to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides the means to render multiple instances of + an object with a single draw call, and an "instance ID" variable + which can be used by the vertex program to compute per-instance + values, typically an object's transform. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/draw_instanced.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.EXT.draw_instanced import * +from OpenGL.raw.GL.EXT.draw_instanced import _EXTENSION_NAME + +def glInitDrawInstancedEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glDrawElementsInstancedEXT.indices size not checked against 'count,type' +glDrawElementsInstancedEXT=wrapper.wrapper(glDrawElementsInstancedEXT).setInputArraySize( + 'indices', None +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/draw_range_elements.py b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/draw_range_elements.py new file mode 100644 index 00000000..0683d475 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/draw_range_elements.py @@ -0,0 +1,32 @@ +'''OpenGL extension EXT.draw_range_elements + +This module customises the behaviour of the +OpenGL.raw.GL.EXT.draw_range_elements to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/draw_range_elements.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.EXT.draw_range_elements import * +from OpenGL.raw.GL.EXT.draw_range_elements import _EXTENSION_NAME + +def glInitDrawRangeElementsEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glDrawRangeElementsEXT.indices size not checked against 'count,type' +glDrawRangeElementsEXT=wrapper.wrapper(glDrawRangeElementsEXT).setInputArraySize( + 'indices', None +) +### END AUTOGENERATED SECTION + +glDrawRangeElementsEXT = wrapper.wrapper( glDrawRangeElementsEXT ).setPyConverter( + 'indices', arrays.AsArrayOfType( 'indices', 'type' ), +).setReturnValues( + wrapper.returnPyArgument( 'indices' ) +) \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/external_buffer.py b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/external_buffer.py new file mode 100644 index 00000000..9d940fe7 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/external_buffer.py @@ -0,0 +1,62 @@ +'''OpenGL extension EXT.external_buffer + +This module customises the behaviour of the +OpenGL.raw.GL.EXT.external_buffer to provide a more +Python-friendly API + +Overview (from the spec) + + Extension EXT_buffer_storage introduced immutable storage buffers to + OpenGL ES. This extension allows the data store for an immutable buffer to + be sourced from an external EGLClientBuffer, allowing sharing of EGL client + buffers across APIs, across processes, and across different processing + cores such as the GPU, CPU, and DSP. + + Operations can then be performed on the external buffer using standard + GL buffer object procedures. The data in the allocation is not copied to + the buffer object's data store; the external allocation represents a single + memory allocation that can be shared across multiple GL objects -- this + aspect is similar to EGL external images. On the other hand, the external + buffer does not provide lifetime guarantees including orphaning and sibling + behavior as provided by EGL external images. + + The EGLClientBuffer must be allocated in a way which permits this shared + access. For example, on Android via a shareable Android hardware buffer. + This extension does not enable support for arbitrary EGLClientBuffers to be + used as an external buffer. + + It is the application's responsibility to ensure synchronization between + operations performed by separate components (DSP / CPU / GPU) and processes + on the external buffer. Additionally the application is responsible for + avoiding violating existing GL spec requirements. For example, mapping a + single shared allocation to two GL buffer objects and then performing + CopyBufferSubData such that the read and write regions overlap would + violate the existing CopyBufferSubData spec regarding copies performed + with the same buffer set for source and destination. + + The application must take any steps necessary to ensure memory access to + the external buffer behaves as required by the application. For example, + preventing compilation differences in data padding from causing data to be + inadvertently corrupted by using defined structure alignment methods such + as the std140 layout qualifier. The application is responsible for + managing the lifetime of the external buffer, ensuring that the external + buffer is not deleted as long as there are any GL buffer objects referring + to it. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/external_buffer.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.EXT.external_buffer import * +from OpenGL.raw.GL.EXT.external_buffer import _EXTENSION_NAME + +def glInitExternalBufferEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/fog_coord.py b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/fog_coord.py new file mode 100644 index 00000000..eaacee92 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/fog_coord.py @@ -0,0 +1,38 @@ +'''OpenGL extension EXT.fog_coord + +This module customises the behaviour of the +OpenGL.raw.GL.EXT.fog_coord to provide a more +Python-friendly API + +Overview (from the spec) + + This extension allows specifying an explicit per-vertex fog + coordinate to be used in fog computations, rather than using a + fragment depth-based fog equation. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/fog_coord.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.EXT.fog_coord import * +from OpenGL.raw.GL.EXT.fog_coord import _EXTENSION_NAME + +def glInitFogCoordEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +glFogCoordfvEXT=wrapper.wrapper(glFogCoordfvEXT).setInputArraySize( + 'coord', 1 +) +glFogCoorddvEXT=wrapper.wrapper(glFogCoorddvEXT).setInputArraySize( + 'coord', 1 +) +# INPUT glFogCoordPointerEXT.pointer size not checked against 'type,stride' +glFogCoordPointerEXT=wrapper.wrapper(glFogCoordPointerEXT).setInputArraySize( + 'pointer', None +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/framebuffer_blit.py b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/framebuffer_blit.py new file mode 100644 index 00000000..4f2c83bf --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/framebuffer_blit.py @@ -0,0 +1,32 @@ +'''OpenGL extension EXT.framebuffer_blit + +This module customises the behaviour of the +OpenGL.raw.GL.EXT.framebuffer_blit to provide a more +Python-friendly API + +Overview (from the spec) + + This extension modifies EXT_framebuffer_object by splitting the + framebuffer object binding point into separate DRAW and READ + bindings. This allows copying directly from one framebuffer to + another. In addition, a new high performance blit function is + added to facilitate these blits and perform some data conversion + where allowed. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/framebuffer_blit.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.EXT.framebuffer_blit import * +from OpenGL.raw.GL.EXT.framebuffer_blit import _EXTENSION_NAME + +def glInitFramebufferBlitEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/framebuffer_multisample.py b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/framebuffer_multisample.py new file mode 100644 index 00000000..1645c620 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/framebuffer_multisample.py @@ -0,0 +1,96 @@ +'''OpenGL extension EXT.framebuffer_multisample + +This module customises the behaviour of the +OpenGL.raw.GL.EXT.framebuffer_multisample to provide a more +Python-friendly API + +Overview (from the spec) + + This extension extends the EXT_framebuffer_object framework to + enable multisample rendering. + + The new operation RenderbufferStorageMultisampleEXT() allocates + storage for a renderbuffer object that can be used as a multisample + buffer. A multisample render buffer image differs from a + single-sample render buffer image in that a multisample image has a + number of SAMPLES that is greater than zero. No method is provided + for creating multisample texture images. + + All of the framebuffer-attachable images attached to a framebuffer + object must have the same number of SAMPLES or else the framebuffer + object is not "framebuffer complete". If a framebuffer object with + multisample attachments is "framebuffer complete", then the + framebuffer object behaves as if SAMPLE_BUFFERS is one. + + In traditional multisample rendering, where + DRAW_FRAMEBUFFER_BINDING_EXT is zero and SAMPLE_BUFFERS is one, the + GL spec states that "the color sample values are resolved to a + single, displayable color each time a pixel is updated." There are, + however, several modern hardware implementations that do not + actually resolve for each sample update, but instead postpones the + resolve operation to a later time and resolve a batch of sample + updates at a time. This is OK as long as the implementation behaves + "as if" it had resolved a sample-at-a-time. Unfortunately, however, + honoring the "as if" rule can sometimes degrade performance. + + In contrast, when DRAW_FRAMEBUFFER_BINDING_EXT is an + application-created framebuffer object, MULTISAMPLE is enabled, and + SAMPLE_BUFFERS is one, there is no implicit per-sample-update + resolve. Instead, the application explicitly controls when the + resolve operation is performed. The resolve operation is affected + by calling BlitFramebufferEXT (provided by the EXT_framebuffer_blit + extension) where the source is a multisample application-created + framebuffer object and the destination is a single-sample + framebuffer object (either application-created or window-system + provided). + + This design for multisample resolve more closely matches current + hardware, but still permits implementations which choose to resolve + a single sample at a time. If hardware that implementes the + multisample resolution "one sample at a time" exposes + EXT_framebuffer_multisample, it could perform the implicit resolve + to a driver-managed hidden surface, then read from that surface when + the application calls BlitFramebufferEXT. + + Another motivation for granting the application explicit control + over the multisample resolve operation has to do with the + flexibility afforded by EXT_framebuffer_object. Previously, a + drawable (window or pbuffer) had exclusive access to all of its + buffers. There was no mechanism for sharing a buffer across + multiple drawables. Under EXT_framebuffer_object, however, a + mechanism exists for sharing a framebuffer-attachable image across + several framebuffer objects, as well as sharing an image between a + framebuffer object and a texture. If we had retained the "implicit" + resolve from traditional multisampled rendering, and allowed the + creation of "multisample" format renderbuffers, then this type of + sharing would have lead to two problematic situations: + + * Two contexts, which shared renderbuffers, might perform + competing resolve operations into the same single-sample buffer + with ambiguous results. + + * It would have introduced the unfortunate ability to use the + single-sample buffer as a texture while MULTISAMPLE is ENABLED. + + By using the BlitFramebufferEXT from EXT_framebuffer_blit as an + explicit resolve to serialize access to the multisampled contents + and eliminate the implicit per-sample resolve operation, we avoid + both of these problems. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/framebuffer_multisample.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.EXT.framebuffer_multisample import * +from OpenGL.raw.GL.EXT.framebuffer_multisample import _EXTENSION_NAME + +def glInitFramebufferMultisampleEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/framebuffer_multisample_blit_scaled.py b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/framebuffer_multisample_blit_scaled.py new file mode 100644 index 00000000..c667773a --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/framebuffer_multisample_blit_scaled.py @@ -0,0 +1,57 @@ +'''OpenGL extension EXT.framebuffer_multisample_blit_scaled + +This module customises the behaviour of the +OpenGL.raw.GL.EXT.framebuffer_multisample_blit_scaled to provide a more +Python-friendly API + +Overview (from the spec) + + This extension relaxes some of the restrictions associated with + multisample resolve operations, specifically to allow a combined + resolve and scale operation through a single call to BlitFramebuffer. + It also adds two new filter types to control the quality of the + combined scaled resolve operation. + + In traditional multisampled framebuffer rendering, color samples + must be explicitly resolved via BlitFramebuffer before any other + operation on the resulting pixel values can be performed. This + multisample resolve operation must be done using a BlitFramebuffer + call where the dimensions of the source and destination rectangles + are identical. If the resulting pixel values need to be copied to a + texture with different dimensions, these resolved values can then be + scaled with a second call to BlitFramebuffer. + + By requiring two separate calls to BlitFramebuffer, the quality + of final image can be maintained to a certain degree. The samples + are first resolved, and then these resolved values can be filtered + to produce the final image. This image quality comes at the price + of increased memory usage and lower performance. However, the + scaling blit can still introduce artifacts, particularly if it is + done with a simple bilinear filter. + + The new filter types introduced by this extension allow the scaled + resolve to be done with a single call to BlitFramebuffer. Not all + samples from the read framebuffer are required to be be used when + producing the final pixel values, and there may be a loss in quality + when compared to an image produced by a separate resolve and scale. + However, the single-pass scaled resolve blit should be faster than + the traditional two-pass resolve then scale blits. + + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/framebuffer_multisample_blit_scaled.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.EXT.framebuffer_multisample_blit_scaled import * +from OpenGL.raw.GL.EXT.framebuffer_multisample_blit_scaled import _EXTENSION_NAME + +def glInitFramebufferMultisampleBlitScaledEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/framebuffer_object.py b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/framebuffer_object.py new file mode 100644 index 00000000..5ac82c62 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/framebuffer_object.py @@ -0,0 +1,133 @@ +'''OpenGL extension EXT.framebuffer_object + +This module customises the behaviour of the +OpenGL.raw.GL.EXT.framebuffer_object to provide a more +Python-friendly API + +Overview (from the spec) + + This extension defines a simple interface for drawing to rendering + destinations other than the buffers provided to the GL by the + window-system. + + In this extension, these newly defined rendering destinations are + known collectively as "framebuffer-attachable images". This + extension provides a mechanism for attaching framebuffer-attachable + images to the GL framebuffer as one of the standard GL logical + buffers: color, depth, and stencil. (Attaching a + framebuffer-attachable image to the accum logical buffer is left for + a future extension to define). When a framebuffer-attachable image + is attached to the framebuffer, it is used as the source and + destination of fragment operations as described in Chapter 4. + + By allowing the use of a framebuffer-attachable image as a rendering + destination, this extension enables a form of "offscreen" rendering. + Furthermore, "render to texture" is supported by allowing the images + of a texture to be used as framebuffer-attachable images. A + particular image of a texture object is selected for use as a + framebuffer-attachable image by specifying the mipmap level, cube + map face (for a cube map texture), and z-offset (for a 3D texture) + that identifies the image. The "render to texture" semantics of + this extension are similar to performing traditional rendering to + the framebuffer, followed immediately by a call to CopyTexSubImage. + However, by using this extension instead, an application can achieve + the same effect, but with the advantage that the GL can usually + eliminate the data copy that would have been incurred by calling + CopyTexSubImage. + + This extension also defines a new GL object type, called a + "renderbuffer", which encapsulates a single 2D pixel image. The + image of renderbuffer can be used as a framebuffer-attachable image + for generalized offscreen rendering and it also provides a means to + support rendering to GL logical buffer types which have no + corresponding texture format (stencil, accum, etc). A renderbuffer + is similar to a texture in that both renderbuffers and textures can + be independently allocated and shared among multiple contexts. The + framework defined by this extension is general enough that support + for attaching images from GL objects other than textures and + renderbuffers could be added by layered extensions. + + To facilitate efficient switching between collections of + framebuffer-attachable images, this extension introduces another new + GL object, called a framebuffer object. A framebuffer object + contains the state that defines the traditional GL framebuffer, + including its set of images. Prior to this extension, it was the + window-system which defined and managed this collection of images, + traditionally by grouping them into a "drawable". The window-system + API's would also provide a function (i.e., wglMakeCurrent, + glXMakeCurrent, aglSetDrawable, etc.) to bind a drawable with a GL + context (as is done in the WGL_ARB_pbuffer extension). In this + extension however, this functionality is subsumed by the GL and the + GL provides the function BindFramebufferEXT to bind a framebuffer + object to the current context. Later, the context can bind back to + the window-system-provided framebuffer in order to display rendered + content. + + Previous extensions that enabled rendering to a texture have been + much more complicated. One example is the combination of + ARB_pbuffer and ARB_render_texture, both of which are window-system + extensions. This combination requires calling MakeCurrent, an + operation that may be expensive, to switch between the window and + the pbuffer drawables. An application must create one pbuffer per + renderable texture in order to portably use ARB_render_texture. An + application must maintain at least one GL context per texture + format, because each context can only operate on a single + pixelformat or FBConfig. All of these characteristics make + ARB_render_texture both inefficient and cumbersome to use. + + EXT_framebuffer_object, on the other hand, is both simpler to use + and more efficient than ARB_render_texture. The + EXT_framebuffer_object API is contained wholly within the GL API and + has no (non-portable) window-system components. Under + EXT_framebuffer_object, it is not necessary to create a second GL + context when rendering to a texture image whose format differs from + that of the window. Finally, unlike the pbuffers of + ARB_render_texture, a single framebuffer object can facilitate + rendering to an unlimited number of texture objects. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/framebuffer_object.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.EXT.framebuffer_object import * +from OpenGL.raw.GL.EXT.framebuffer_object import _EXTENSION_NAME + +def glInitFramebufferObjectEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glDeleteRenderbuffersEXT.renderbuffers size not checked against n +glDeleteRenderbuffersEXT=wrapper.wrapper(glDeleteRenderbuffersEXT).setInputArraySize( + 'renderbuffers', None +) +glGenRenderbuffersEXT=wrapper.wrapper(glGenRenderbuffersEXT).setOutput( + 'renderbuffers',size=lambda x:(x,),pnameArg='n',orPassIn=True +) +glGetRenderbufferParameterivEXT=wrapper.wrapper(glGetRenderbufferParameterivEXT).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +# INPUT glDeleteFramebuffersEXT.framebuffers size not checked against n +glDeleteFramebuffersEXT=wrapper.wrapper(glDeleteFramebuffersEXT).setInputArraySize( + 'framebuffers', None +) +glGenFramebuffersEXT=wrapper.wrapper(glGenFramebuffersEXT).setOutput( + 'framebuffers',size=lambda x:(x,),pnameArg='n',orPassIn=True +) +glGetFramebufferAttachmentParameterivEXT=wrapper.wrapper(glGetFramebufferAttachmentParameterivEXT).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +### END AUTOGENERATED SECTION +from OpenGL.lazywrapper import lazy as _lazy + +@_lazy( glDeleteFramebuffersEXT ) +def glDeleteFramebuffersEXT( baseOperation, n, framebuffers=None ): + """glDeleteFramebuffersEXT( framebuffers ) -> None + """ + if framebuffers is None: + framebuffers = arrays.GLuintArray.asArray( n ) + n = arrays.GLuintArray.arraySize( framebuffers ) + return baseOperation( n, framebuffers ) diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/framebuffer_sRGB.py b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/framebuffer_sRGB.py new file mode 100644 index 00000000..09f5696c --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/framebuffer_sRGB.py @@ -0,0 +1,55 @@ +'''OpenGL extension EXT.framebuffer_sRGB + +This module customises the behaviour of the +OpenGL.raw.GL.EXT.framebuffer_sRGB to provide a more +Python-friendly API + +Overview (from the spec) + + Conventionally, OpenGL assumes framebuffer color components are stored + in a linear color space. In particular, framebuffer blending is a + linear operation. + + The sRGB color space is based on typical (non-linear) monitor + characteristics expected in a dimly lit office. It has been + standardized by the International Electrotechnical Commission (IEC) + as IEC 61966-2-1. The sRGB color space roughly corresponds to 2.2 + gamma correction. + + This extension adds a framebuffer capability for sRGB framebuffer + update and blending. When blending is disabled but the new sRGB + updated mode is enabled (assume the framebuffer supports the + capability), high-precision linear color component values for red, + green, and blue generated by fragment coloring are encoded for sRGB + prior to being written into the framebuffer. When blending is enabled + along with the new sRGB update mode, red, green, and blue framebuffer + color components are treated as sRGB values that are converted to + linear color values, blended with the high-precision color values + generated by fragment coloring, and then the blend result is encoded + for sRGB just prior to being written into the framebuffer. + + The primary motivation for this extension is that it allows OpenGL + applications to render into a framebuffer that is scanned to a monitor + configured to assume framebuffer color values are sRGB encoded. + This assumption is roughly true of most PC monitors with default + gamma correction. This allows applications to achieve faithful + color reproduction for OpenGL rendering without adjusting the + monitor's gamma correction. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/framebuffer_sRGB.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.EXT.framebuffer_sRGB import * +from OpenGL.raw.GL.EXT.framebuffer_sRGB import _EXTENSION_NAME + +def glInitFramebufferSrgbEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/geometry_shader4.py b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/geometry_shader4.py new file mode 100644 index 00000000..3daf9bf2 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/geometry_shader4.py @@ -0,0 +1,53 @@ +'''OpenGL extension EXT.geometry_shader4 + +This module customises the behaviour of the +OpenGL.raw.GL.EXT.geometry_shader4 to provide a more +Python-friendly API + +Overview (from the spec) + + EXT_geometry_shader4 defines a new shader type available to be run on the + GPU, called a geometry shader. Geometry shaders are run after vertices are + transformed, but prior to color clamping, flat shading and clipping. + + A geometry shader begins with a single primitive (point, line, + triangle). It can read the attributes of any of the vertices in the + primitive and use them to generate new primitives. A geometry shader has a + fixed output primitive type (point, line strip, or triangle strip) and + emits vertices to define a new primitive. A geometry shader can emit + multiple disconnected primitives. The primitives emitted by the geometry + shader are clipped and then processed like an equivalent OpenGL primitive + specified by the application. + + Furthermore, EXT_geometry_shader4 provides four additional primitive + types: lines with adjacency, line strips with adjacency, separate + triangles with adjacency, and triangle strips with adjacency. Some of the + vertices specified in these new primitive types are not part of the + ordinary primitives, instead they represent neighboring vertices that are + adjacent to the two line segment end points (lines/strips) or the three + triangle edges (triangles/tstrips). These vertices can be accessed by + geometry shaders and used to match up the vertices emitted by the geometry + shader with those of neighboring primitives. + + Since geometry shaders expect a specific input primitive type, an error + will occur if the application presents primitives of a different type. + For example, if a geometry shader expects points, an error will occur at + Begin() time, if a primitive mode of TRIANGLES is specified. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/geometry_shader4.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.EXT.geometry_shader4 import * +from OpenGL.raw.GL.EXT.geometry_shader4 import _EXTENSION_NAME + +def glInitGeometryShader4EXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/gpu_program_parameters.py b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/gpu_program_parameters.py new file mode 100644 index 00000000..45946fca --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/gpu_program_parameters.py @@ -0,0 +1,44 @@ +'''OpenGL extension EXT.gpu_program_parameters + +This module customises the behaviour of the +OpenGL.raw.GL.EXT.gpu_program_parameters to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides a new set of procedures to load multiple + consecutive program environment parameters more efficiently, via a single + GL call instead of multiple calls. This will reduce the amount of CPU + overhead involved in loading parameters. + + With the existing ARB_vertex_program and ARB_fragment_program APIs, + program parameters must be loaded one at a time, via separate calls. + While the NV_vertex_program extension provides a set of similar functions + that can be used to load program environment parameters (which are + equivalent to "program parameters" in NV_vertex_program), no such function + exists for program local parameters. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/gpu_program_parameters.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.EXT.gpu_program_parameters import * +from OpenGL.raw.GL.EXT.gpu_program_parameters import _EXTENSION_NAME + +def glInitGpuProgramParametersEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glProgramEnvParameters4fvEXT.params size not checked against count*4 +glProgramEnvParameters4fvEXT=wrapper.wrapper(glProgramEnvParameters4fvEXT).setInputArraySize( + 'params', None +) +# INPUT glProgramLocalParameters4fvEXT.params size not checked against count*4 +glProgramLocalParameters4fvEXT=wrapper.wrapper(glProgramLocalParameters4fvEXT).setInputArraySize( + 'params', None +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/gpu_shader4.py b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/gpu_shader4.py new file mode 100644 index 00000000..65c51f20 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/gpu_shader4.py @@ -0,0 +1,147 @@ +'''OpenGL extension EXT.gpu_shader4 + +This module customises the behaviour of the +OpenGL.raw.GL.EXT.gpu_shader4 to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides a set of new features to the OpenGL Shading + Language and related APIs to support capabilities of new hardware. In + particular, this extension provides the following functionality: + + * New texture lookup functions are provided that allow shaders to + access individual texels using integer coordinates referring to the + texel location and level of detail. No filtering is performed. These + functions allow applications to use textures as one-, two-, and + three-dimensional arrays. + + * New texture lookup functions are provided that allow shaders to query + the dimensions of a specific level-of-detail image of a texture + object. + + * New texture lookup functions variants are provided that allow shaders + to pass a constant integer vector used to offset the texel locations + used during the lookup to assist in custom texture filtering + operations. + + * New texture lookup functions are provided that allow shaders to + access one- and two-dimensional array textures. The second, or third, + coordinate is used to select the layer of the array to access. + + * New "Grad" texture lookup functions are provided that allow shaders + to explicitely pass in derivative values which are used by the GL to + compute the level-of-detail when performing a texture lookup. + + * A new texture lookup function is provided to access a buffer texture. + + * The existing absolute LOD texture lookup functions are no longer + restricted to the vertex shader only. + + * The ability to specify and use cubemap textures with a + DEPTH_COMPONENT internal format. This also enables shadow mapping on + cubemaps. The 'q' coordinate is used as the reference value for + comparisons. A set of new texture lookup functions is provided to + lookup into shadow cubemaps. + + * The ability to specify if varying variables are interpolated in a + non-perspective correct manner, if they are flat shaded or, if + multi-sampling, if centroid sampling should be performed. + + * Full signed integer and unsigned integer support in the OpenGL + Shading Language: + + - Integers are defined as 32 bit values using two's complement. + + - Unsigned integers and vectors thereof are added. + + - New texture lookup functions are provided that return integer + values. These functions are to be used in conjunction with new + texture formats whose components are actual integers, rather + than integers that encode a floating-point value. To support + these lookup functions, new integer and unsigned-integer + sampler types are introduced. + + - Integer bitwise operators are now enabled. + + - Several built-in functions and operators now operate on + integers or vectors of integers. + + - New vertex attribute functions are added that load integer + attribute data and can be referenced in a vertex shader as + integer data. + + - New uniform loading commands are added to load unsigned integer + data. + + - Varying variables can now be (unsigned) integers. If declared + as such, they have to be flat shaded. + + - Fragment shaders can define their own output variables, and + declare them to be of type floating-point, integer or unsigned + integer. These variables are bound to a fragment color index + with the new API command BindFragDataLocationEXT(), and directed + to buffers using the existing DrawBuffer or DrawBuffers API + commands. + + * Added new built-in functions truncate() and round() to the shading + language. + + * A new built-in variable accessible from within vertex shaders that + holds the index implicitly passed to ArrayElement to specify the + vertex. This is called the vertex ID. + + * A new built-in variable accessible from within fragment and geometry + shaders that hold the index of the currently processed + primitive. This is called the primitive ID. + + This extension also briefly mentions a new shader type, called a geometry + shader. A geometry shader is run after vertices are transformed, but + before clipping. A geometry shader begins with a single primitive (point, + line, triangle. It can read the attributes of any of the vertices in the + primitive and use them to generate new primitives. A geometry shader has a + fixed output primitive type (point, line strip, or triangle strip) and + emits vertices to define a new primitive. Geometry shaders are discussed + in detail in the GL_EXT_geometry_shader4 specification. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/gpu_shader4.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.EXT.gpu_shader4 import * +from OpenGL.raw.GL.EXT.gpu_shader4 import _EXTENSION_NAME + +def glInitGpuShader4EXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# OUTPUT glGetUniformuivEXT.params COMPSIZE(program, location) +# INPUT glBindFragDataLocationEXT.name size not checked against 'name' +glBindFragDataLocationEXT=wrapper.wrapper(glBindFragDataLocationEXT).setInputArraySize( + 'name', None +) +# INPUT glGetFragDataLocationEXT.name size not checked against 'name' +glGetFragDataLocationEXT=wrapper.wrapper(glGetFragDataLocationEXT).setInputArraySize( + 'name', None +) +# INPUT glUniform1uivEXT.value size not checked against count +glUniform1uivEXT=wrapper.wrapper(glUniform1uivEXT).setInputArraySize( + 'value', None +) +# INPUT glUniform2uivEXT.value size not checked against count*2 +glUniform2uivEXT=wrapper.wrapper(glUniform2uivEXT).setInputArraySize( + 'value', None +) +# INPUT glUniform3uivEXT.value size not checked against count*3 +glUniform3uivEXT=wrapper.wrapper(glUniform3uivEXT).setInputArraySize( + 'value', None +) +# INPUT glUniform4uivEXT.value size not checked against count*4 +glUniform4uivEXT=wrapper.wrapper(glUniform4uivEXT).setInputArraySize( + 'value', None +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/histogram.py b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/histogram.py new file mode 100644 index 00000000..dc7291ef --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/histogram.py @@ -0,0 +1,52 @@ +'''OpenGL extension EXT.histogram + +This module customises the behaviour of the +OpenGL.raw.GL.EXT.histogram to provide a more +Python-friendly API + +Overview (from the spec) + + This extension defines pixel operations that count occurences of + specific color component values (histogram) and that track the minimum + and maximum color component values (minmax). An optional mode allows + pixel data to be discarded after the histogram and/or minmax operations + are completed. Otherwise the pixel data continue on to the next + operation unaffected. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/histogram.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.EXT.histogram import * +from OpenGL.raw.GL.EXT.histogram import _EXTENSION_NAME + +def glInitHistogramEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# OUTPUT glGetHistogramEXT.values COMPSIZE(target, format, type) +glGetHistogramParameterfvEXT=wrapper.wrapper(glGetHistogramParameterfvEXT).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetHistogramParameterivEXT=wrapper.wrapper(glGetHistogramParameterivEXT).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +# OUTPUT glGetMinmaxEXT.values COMPSIZE(target, format, type) +glGetMinmaxParameterfvEXT=wrapper.wrapper(glGetMinmaxParameterfvEXT).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetMinmaxParameterivEXT=wrapper.wrapper(glGetMinmaxParameterivEXT).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +### END AUTOGENERATED SECTION + +glGetHistogramParameterfvEXT = wrapper.wrapper(glGetHistogramParameterfvEXT).setOutput( + "params",(1,), orPassIn=True +) +glGetHistogramParameterivEXT = wrapper.wrapper(glGetHistogramParameterivEXT).setOutput( + "params",(1,), orPassIn=True +) diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/index_array_formats.py b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/index_array_formats.py new file mode 100644 index 00000000..e675f6a9 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/index_array_formats.py @@ -0,0 +1,29 @@ +'''OpenGL extension EXT.index_array_formats + +This module customises the behaviour of the +OpenGL.raw.GL.EXT.index_array_formats to provide a more +Python-friendly API + +Overview (from the spec) + + This extends the number of packed vertex formats accepted by + InterleavedArrays to include formats which specify color indexes + rather than RGBA colors. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/index_array_formats.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.EXT.index_array_formats import * +from OpenGL.raw.GL.EXT.index_array_formats import _EXTENSION_NAME + +def glInitIndexArrayFormatsEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/index_func.py b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/index_func.py new file mode 100644 index 00000000..392fedc8 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/index_func.py @@ -0,0 +1,29 @@ +'''OpenGL extension EXT.index_func + +This module customises the behaviour of the +OpenGL.raw.GL.EXT.index_func to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides a way to discard fragments when a comparison + between the fragment's index value and a reference index fails. This + may be used similarly to the alpha test which is available in RGBA mode. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/index_func.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.EXT.index_func import * +from OpenGL.raw.GL.EXT.index_func import _EXTENSION_NAME + +def glInitIndexFuncEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/index_material.py b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/index_material.py new file mode 100644 index 00000000..2002488d --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/index_material.py @@ -0,0 +1,35 @@ +'''OpenGL extension EXT.index_material + +This module customises the behaviour of the +OpenGL.raw.GL.EXT.index_material to provide a more +Python-friendly API + +Overview (from the spec) + + This extends color index lighting to include a way for the current + index to contribute to the color index produced by lighting. This + works much like ColorMaterial does for RGBA lighting by allowing + one or more color index material properties to be attached to the + current index. + + The color index lighting formula is also modified so that the lit + color index may be bitwise shifted in order to allow greater control + when using lighting and fog together in color index mode. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/index_material.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.EXT.index_material import * +from OpenGL.raw.GL.EXT.index_material import _EXTENSION_NAME + +def glInitIndexMaterialEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/index_texture.py b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/index_texture.py new file mode 100644 index 00000000..cb9c3176 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/index_texture.py @@ -0,0 +1,34 @@ +'''OpenGL extension EXT.index_texture + +This module customises the behaviour of the +OpenGL.raw.GL.EXT.index_texture to provide a more +Python-friendly API + +Overview (from the spec) + + This extends the definition of texturing so that it is supported + in color index mode. This extension builds on the notion of + texture images which have color index internal formats which was + introduced in EXT_paletted_texture. + + This extension also introduces a new texture environment function + ADD which is useful for combining lighting and texturing in + color index mode. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/index_texture.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.EXT.index_texture import * +from OpenGL.raw.GL.EXT.index_texture import _EXTENSION_NAME + +def glInitIndexTextureEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/light_texture.py b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/light_texture.py new file mode 100644 index 00000000..adc4bd6b --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/light_texture.py @@ -0,0 +1,44 @@ +'''OpenGL extension EXT.light_texture + +This module customises the behaviour of the +OpenGL.raw.GL.EXT.light_texture to provide a more +Python-friendly API + +Overview (from the spec) + + This extension defines a general mechanism for substituting the + fragment color computed during texture environment processing in + place of other fragment attributes such as the fragment normal, or + as sources for some of the computations in the fragment processing + pipeline, for example as material or light parameters in the + fragment lighting computations. + + + Cf ----------------------+ + | +-> to lighting parameters + v | + +------------+ +--------+ +-------------+ + | | | | | | + | texel |------->| texenv |-----| texture |---> Cf' (to Light Environment + | generation | | | | application | or Fog) + | | | | | | + +------------+ +--------+ +-------------+ + + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/light_texture.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.EXT.light_texture import * +from OpenGL.raw.GL.EXT.light_texture import _EXTENSION_NAME + +def glInitLightTextureEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/memory_object.py b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/memory_object.py new file mode 100644 index 00000000..c70de435 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/memory_object.py @@ -0,0 +1,34 @@ +'''OpenGL extension EXT.memory_object + +This module customises the behaviour of the +OpenGL.raw.GL.EXT.memory_object to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/memory_object.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.EXT.memory_object import * +from OpenGL.raw.GL.EXT.memory_object import _EXTENSION_NAME + +def glInitMemoryObjectEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glGetUnsignedBytevEXT.data size not checked against 'pname' +glGetUnsignedBytevEXT=wrapper.wrapper(glGetUnsignedBytevEXT).setInputArraySize( + 'data', None +) +# INPUT glGetUnsignedBytei_vEXT.data size not checked against 'target' +glGetUnsignedBytei_vEXT=wrapper.wrapper(glGetUnsignedBytei_vEXT).setInputArraySize( + 'data', None +) +# INPUT glDeleteMemoryObjectsEXT.memoryObjects size not checked against n +glDeleteMemoryObjectsEXT=wrapper.wrapper(glDeleteMemoryObjectsEXT).setInputArraySize( + 'memoryObjects', None +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/memory_object_fd.py b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/memory_object_fd.py new file mode 100644 index 00000000..82756c77 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/memory_object_fd.py @@ -0,0 +1,23 @@ +'''OpenGL extension EXT.memory_object_fd + +This module customises the behaviour of the +OpenGL.raw.GL.EXT.memory_object_fd to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/memory_object_fd.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.EXT.memory_object_fd import * +from OpenGL.raw.GL.EXT.memory_object_fd import _EXTENSION_NAME + +def glInitMemoryObjectFdEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/memory_object_win32.py b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/memory_object_win32.py new file mode 100644 index 00000000..40664aaf --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/memory_object_win32.py @@ -0,0 +1,23 @@ +'''OpenGL extension EXT.memory_object_win32 + +This module customises the behaviour of the +OpenGL.raw.GL.EXT.memory_object_win32 to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/memory_object_win32.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.EXT.memory_object_win32 import * +from OpenGL.raw.GL.EXT.memory_object_win32 import _EXTENSION_NAME + +def glInitMemoryObjectWin32EXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/misc_attribute.py b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/misc_attribute.py new file mode 100644 index 00000000..f3502e74 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/misc_attribute.py @@ -0,0 +1,30 @@ +'''OpenGL extension EXT.misc_attribute + +This module customises the behaviour of the +OpenGL.raw.GL.EXT.misc_attribute to provide a more +Python-friendly API + +Overview (from the spec) + + EXT_misc_attribute extends the list of attribute groups. It provides + a miscellaneous group, controlled by the MISC_BIT_EXT bit, that contains + the attribute state of extensions that don't logically fit in any other + group. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/misc_attribute.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.EXT.misc_attribute import * +from OpenGL.raw.GL.EXT.misc_attribute import _EXTENSION_NAME + +def glInitMiscAttributeEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/multi_draw_arrays.py b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/multi_draw_arrays.py new file mode 100644 index 00000000..23749505 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/multi_draw_arrays.py @@ -0,0 +1,44 @@ +'''OpenGL extension EXT.multi_draw_arrays + +This module customises the behaviour of the +OpenGL.raw.GL.EXT.multi_draw_arrays to provide a more +Python-friendly API + +Overview (from the spec) + + These functions behave identically to the standard OpenGL 1.1 functions + glDrawArrays() and glDrawElements() except they handle multiple lists of + vertices in one call. Their main purpose is to allow one function call + to render more than one primitive such as triangle strip, triangle fan, + etc. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/multi_draw_arrays.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.EXT.multi_draw_arrays import * +from OpenGL.raw.GL.EXT.multi_draw_arrays import _EXTENSION_NAME + +def glInitMultiDrawArraysEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glMultiDrawArraysEXT.count size not checked against 'primcount' +# INPUT glMultiDrawArraysEXT.first size not checked against 'primcount' +glMultiDrawArraysEXT=wrapper.wrapper(glMultiDrawArraysEXT).setInputArraySize( + 'count', None +).setInputArraySize( + 'first', None +) +# INPUT glMultiDrawElementsEXT.count size not checked against 'primcount' +# INPUT glMultiDrawElementsEXT.indices size not checked against 'primcount' +glMultiDrawElementsEXT=wrapper.wrapper(glMultiDrawElementsEXT).setInputArraySize( + 'count', None +).setInputArraySize( + 'indices', None +) +### END AUTOGENERATED SECTION diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/multisample.py b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/multisample.py new file mode 100644 index 00000000..c0fe2b81 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/multisample.py @@ -0,0 +1,23 @@ +'''OpenGL extension EXT.multisample + +This module customises the behaviour of the +OpenGL.raw.GL.EXT.multisample to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/multisample.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.EXT.multisample import * +from OpenGL.raw.GL.EXT.multisample import _EXTENSION_NAME + +def glInitMultisampleEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/multiview_tessellation_geometry_shader.py b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/multiview_tessellation_geometry_shader.py new file mode 100644 index 00000000..85a8b91b --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/multiview_tessellation_geometry_shader.py @@ -0,0 +1,48 @@ +'''OpenGL extension EXT.multiview_tessellation_geometry_shader + +This module customises the behaviour of the +OpenGL.raw.GL.EXT.multiview_tessellation_geometry_shader to provide a more +Python-friendly API + +Overview (from the spec) + + OVR_multiview introduced multiview rendering to OpenGL and OpenGL ES. + + This extension removes one of the limitations of the OVR_multiview + extension by allowing the use of tessellation control, tessellation + evaluation, and geometry shaders during multiview rendering. + OVR_multiview by itself forbids the use of any of these shader types. + + When using tessellation control, tessellation evaluation, and geometry + shaders during multiview rendering, any such shader must use the + "num_views" layout qualifier provided by the matching shading language + extension to specify a view count. The view count specified in these + shaders must match the count specified in the vertex shader. Additionally, + the shading language extension allows these shaders to use the + gl_ViewID_OVR built-in to handle tessellation or geometry shader processing + differently for each view. + + OVR_multiview2 extends OVR_multiview by allowing view-dependent values + for any vertex attributes instead of just the position. This new extension + does not imply the availability of OVR_multiview2, but if both are available, + view-dependent values for any vertex attributes are also allowed in + tessellation control, tessellation evaluation, and geometry shaders. + + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/multiview_tessellation_geometry_shader.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.EXT.multiview_tessellation_geometry_shader import * +from OpenGL.raw.GL.EXT.multiview_tessellation_geometry_shader import _EXTENSION_NAME + +def glInitMultiviewTessellationGeometryShaderEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/multiview_texture_multisample.py b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/multiview_texture_multisample.py new file mode 100644 index 00000000..2440bea9 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/multiview_texture_multisample.py @@ -0,0 +1,52 @@ +'''OpenGL extension EXT.multiview_texture_multisample + +This module customises the behaviour of the +OpenGL.raw.GL.EXT.multiview_texture_multisample to provide a more +Python-friendly API + +Overview (from the spec) + + OVR_multiview introduced multiview rendering to OpenGL and OpenGL ES. + + This extension removes one of the limitations of the OVR_multiview + extension by allowing the use of multisample textures during multiview rendering. + + This is one of two extensions that allow multisampling when using + OVR_multiview. Each supports one of the two different approaches to + multisampling in OpenGL and OpenGL ES: + + Core OpenGL and OpenGL ES 3.1+ have explicit support for multisample + texture types, such as TEXTURE_2D_MULTISAMPLE. Applications can access + the values of individual samples and can explicitly "resolve" the + samples of each pixel down to a single color. + + The extension EXT_multisampled_render_to_texture provides support for + multisampled rendering to non-multisample texture types, such as + TEXTURE_2D. The individual samples for each pixel are maintained + internally by the implementation and can not be accessed directly + by applications. These samples are eventually resolved implicitly to + a single color for each pixel. + + This extension supports the first multisampling style with multiview + rendering; the OVR_multiview_multisampled_render_to_texture extension + supports the second style. Note that support for one of these multiview + extensions does not imply support for the other. + + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/multiview_texture_multisample.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.EXT.multiview_texture_multisample import * +from OpenGL.raw.GL.EXT.multiview_texture_multisample import _EXTENSION_NAME + +def glInitMultiviewTextureMultisampleEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/multiview_timer_query.py b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/multiview_timer_query.py new file mode 100644 index 00000000..0f94282f --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/multiview_timer_query.py @@ -0,0 +1,32 @@ +'''OpenGL extension EXT.multiview_timer_query + +This module customises the behaviour of the +OpenGL.raw.GL.EXT.multiview_timer_query to provide a more +Python-friendly API + +Overview (from the spec) + + OVR_multiview introduced multiview rendering to OpenGL and OpenGL ES. + This extension removes one of the limitations of the OVR_multiview + extension by allowing the use of timer queries during multiview rendering. + OVR_multiview does not specify defined behavior for such usage + (if implemented in OpenGL or if EXT_disjoint_timer_query is present). + + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/multiview_timer_query.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.EXT.multiview_timer_query import * +from OpenGL.raw.GL.EXT.multiview_timer_query import _EXTENSION_NAME + +def glInitMultiviewTimerQueryEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/packed_depth_stencil.py b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/packed_depth_stencil.py new file mode 100644 index 00000000..6afc6b13 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/packed_depth_stencil.py @@ -0,0 +1,112 @@ +'''OpenGL extension EXT.packed_depth_stencil + +This module customises the behaviour of the +OpenGL.raw.GL.EXT.packed_depth_stencil to provide a more +Python-friendly API + +Overview (from the spec) + + Many OpenGL implementations have chosen to interleave the depth and + stencil buffers into one buffer, often with 24 bits of depth + precision and 8 bits of stencil data. 32 bits is more than is + needed for the depth buffer much of the time; a 24-bit depth buffer, + on the other hand, requires that reads and writes of depth data be + unaligned with respect to power-of-two boundaries. On the other + hand, 8 bits of stencil data is more than sufficient for most + applications, so it is only natural to pack the two buffers into a + single buffer with both depth and stencil data. OpenGL never + provides direct access to the buffers, so the OpenGL implementation + can provide an interface to applications where it appears the one + merged buffer is composed of two logical buffers. + + One disadvantage of this scheme is that OpenGL lacks any means by + which this packed data can be handled efficiently. For example, + when an application reads from the 24-bit depth buffer, using the + type GL_UNSIGNED_SHORT will lose 8 bits of data, while + GL_UNSIGNED_INT has 8 too many. Both require expensive format + conversion operations. A 24-bit format would be no more suitable, + because it would also suffer from the unaligned memory accesses that + made the standalone 24-bit depth buffer an unattractive proposition + in the first place. + + Many applications, such as parallel rendering applications, may also + wish to draw to or read back from both the depth and stencil buffers + at the same time. Currently this requires two separate operations, + reducing performance. Since the buffers are interleaved, drawing to + or reading from both should be no more expensive than using just + one; in some cases, it may even be cheaper. + + This extension provides a new data format, GL_DEPTH_STENCIL_EXT, + that can be used with the glDrawPixels, glReadPixels, and + glCopyPixels commands, as well as a packed data type, + GL_UNSIGNED_INT_24_8_EXT, that is meant to be used with + GL_DEPTH_STENCIL_EXT. No other data types are supported with + GL_DEPTH_STENCIL_EXT. If ARB_depth_texture or SGIX_depth_texture is + supported, GL_DEPTH_STENCIL_EXT/GL_UNSIGNED_INT_24_8_EXT data can + also be used for textures; this provides a more efficient way to + supply data for a 24-bit depth texture. + + GL_DEPTH_STENCIL_EXT data, when passed through the pixel path, + undergoes both depth and stencil operations. The depth data is + scaled and biased by the current GL_DEPTH_SCALE and GL_DEPTH_BIAS, + while the stencil data is shifted and offset by the current + GL_INDEX_SHIFT and GL_INDEX_OFFSET. The stencil data is also put + through the stencil-to-stencil pixel map. + + glDrawPixels of GL_DEPTH_STENCIL_EXT data operates similarly to that + of GL_STENCIL_INDEX data, bypassing the OpenGL fragment pipeline + entirely, unlike the treatment of GL_DEPTH_COMPONENT data. The + stencil and depth masks are applied, as are the pixel ownership and + scissor tests, but all other operations are skipped. + + glReadPixels of GL_DEPTH_STENCIL_EXT data reads back a rectangle + from both the depth and stencil buffers. + + glCopyPixels of GL_DEPTH_STENCIL_EXT data copies a rectangle from + both the depth and stencil buffers. Like glDrawPixels, it applies + both the stencil and depth masks but skips the remainder of the + OpenGL fragment pipeline. + + glTex[Sub]Image[1,2,3]D of GL_DEPTH_STENCIL_EXT data loads depth and + stencil data into a depth_stencil texture. glGetTexImage of + GL_DEPTH_STENCIL_EXT data can be used to retrieve depth and stencil + data from a depth/stencil texture. + + In addition, a new base internal format, GL_DEPTH_STENCIL_EXT, can + be used by both texture images and renderbuffer storage. When an + image with a DEPTH_STENCIL_EXT internal format is attached to both + the depth and stencil attachment points of a framebuffer object (see + EXT_framebuffer_object), then it becomes both the depth and stencil + buffers of the framebuffer. This fits nicely with hardware that + interleaves both depth and stencil data into a single buffer. When + a texture with DEPTH_STENCIL_EXT data is bound for texturing, only + the depth component is accessible through the texture fetcher. The + stencil data can be written with TexImage or CopyTexImage, and can + be read with GetTexImage. When a DEPTH_STENCIL_EXT image is + attached to the stencil attachment of the bound framebuffer object, + the stencil data can be accessed through any operation that reads + from or writes to the framebuffer's stencil buffer. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/packed_depth_stencil.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.EXT.packed_depth_stencil import * +from OpenGL.raw.GL.EXT.packed_depth_stencil import _EXTENSION_NAME + +def glInitPackedDepthStencilEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION +# Setup the new image types +from OpenGL import images +from OpenGL.raw.GL.VERSION.GL_1_1 import GL_UNSIGNED_INT +images.TYPE_TO_ARRAYTYPE[ GL_UNSIGNED_INT_24_8_EXT ] = GL_UNSIGNED_INT +images.TIGHT_PACK_FORMATS[ GL_UNSIGNED_INT_24_8_EXT ] = 4 +images.COMPONENT_COUNTS[ GL_DEPTH_STENCIL_EXT ] = 4 diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/packed_float.py b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/packed_float.py new file mode 100644 index 00000000..3bdb678f --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/packed_float.py @@ -0,0 +1,44 @@ +'''OpenGL extension EXT.packed_float + +This module customises the behaviour of the +OpenGL.raw.GL.EXT.packed_float to provide a more +Python-friendly API + +Overview (from the spec) + + This extension adds a new 3-component floating-point texture format + that fits within a single 32-bit word. This format stores 5 bits + of biased exponent per component in the same manner as 16-bit + floating-point formats, but rather than 10 mantissa bits, the red, + green, and blue components have 6, 6, and 5 bits respectively. + Each mantissa is assumed to have an implied leading one except in the + denorm exponent case. There is no sign bit so only non-negative + values can be represented. Positive infinity, positive denorms, + and positive NaN values are representable. The value of the fourth + component returned by a texture fetch is always 1.0. + + This extension also provides support for rendering into an unsigned + floating-point rendering format with the assumption that the texture + format described above could also be advertised as an unsigned + floating-point format for rendering. + + The extension also provides a pixel external format for specifying + packed float values directly. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/packed_float.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.EXT.packed_float import * +from OpenGL.raw.GL.EXT.packed_float import _EXTENSION_NAME + +def glInitPackedFloatEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/packed_pixels.py b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/packed_pixels.py new file mode 100644 index 00000000..8a836a2d --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/packed_pixels.py @@ -0,0 +1,34 @@ +'''OpenGL extension EXT.packed_pixels + +This module customises the behaviour of the +OpenGL.raw.GL.EXT.packed_pixels to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides support for packed pixels in host memory. A + packed pixel is represented entirely by one unsigned byte, one + unsigned short, or one unsigned integer. The fields with the packed + pixel are not proper machine types, but the pixel as a whole is. Thus + the pixel storage modes, including PACK_SKIP_PIXELS, PACK_ROW_LENGTH, + PACK_SKIP_ROWS, PACK_IMAGE_HEIGHT_EXT, PACK_SKIP_IMAGES_EXT, + PACK_SWAP_BYTES, PACK_ALIGNMENT, and their unpacking counterparts all + work correctly with packed pixels. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/packed_pixels.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.EXT.packed_pixels import * +from OpenGL.raw.GL.EXT.packed_pixels import _EXTENSION_NAME + +def glInitPackedPixelsEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/paletted_texture.py b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/paletted_texture.py new file mode 100644 index 00000000..af756bcc --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/paletted_texture.py @@ -0,0 +1,74 @@ +'''OpenGL extension EXT.paletted_texture + +This module customises the behaviour of the +OpenGL.raw.GL.EXT.paletted_texture to provide a more +Python-friendly API + +Overview (from the spec) + + EXT_paletted_texture defines new texture formats and new calls to + support the use of paletted textures in OpenGL. A paletted texture is + defined by giving both a palette of colors and a set of image data which + is composed of indices into the palette. The paletted texture cannot + function properly without both pieces of information so it increases the + work required to define a texture. This is offset by the fact that the + overall amount of texture data can be reduced dramatically by factoring + redundant information out of the logical view of the texture and placing + it in the palette. + + Paletted textures provide several advantages over full-color textures: + + * As mentioned above, the amount of data required to define a + texture can be greatly reduced over what would be needed for full-color + specification. For example, consider a source texture that has only 256 + distinct colors in a 256 by 256 pixel grid. Full-color representation + requires three bytes per pixel, taking 192K of texture data. By putting + the distinct colors in a palette only eight bits are required per pixel, + reducing the 192K to 64K plus 768 bytes for the palette. Now add an + alpha channel to the texture. The full-color representation increases + by 64K while the paletted version would only increase by 256 bytes. + This reduction in space required is particularly important for hardware + accelerators where texture space is limited. + + * Paletted textures allow easy reuse of texture data for images + which require many similar but slightly different colored objects. + Consider a driving simulation with heavy traffic on the road. Many of + the cars will be similar but with different color schemes. If + full-color textures are used a separate texture would be needed for each + color scheme, while paletted textures allow the same basic index data to + be reused for each car, with a different palette to change the final + colors. + + * Paletted textures also allow use of all the palette tricks + developed for paletted displays. Simple animation can be done, along + with strobing, glowing and other palette-cycling effects. All of these + techniques can enhance the visual richness of a scene with very little + data. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/paletted_texture.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.EXT.paletted_texture import * +from OpenGL.raw.GL.EXT.paletted_texture import _EXTENSION_NAME + +def glInitPalettedTextureEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glColorTableEXT.table size not checked against 'format,type,width' +glColorTableEXT=wrapper.wrapper(glColorTableEXT).setInputArraySize( + 'table', None +) +# OUTPUT glGetColorTableEXT.data COMPSIZE(target, format, type) +glGetColorTableParameterivEXT=wrapper.wrapper(glGetColorTableParameterivEXT).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetColorTableParameterfvEXT=wrapper.wrapper(glGetColorTableParameterfvEXT).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/pixel_buffer_object.py b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/pixel_buffer_object.py new file mode 100644 index 00000000..c552c1c1 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/pixel_buffer_object.py @@ -0,0 +1,74 @@ +'''OpenGL extension EXT.pixel_buffer_object + +This module customises the behaviour of the +OpenGL.raw.GL.EXT.pixel_buffer_object to provide a more +Python-friendly API + +Overview (from the spec) + + This extension expands on the interface provided by buffer objects. + It is intended to permit buffer objects to be used not only with + vertex array data, but also with pixel data. + Buffer objects were promoted from the ARB_vertex_buffer_object + extension in OpenGL 1.5. + + Recall that buffer objects conceptually are nothing more than arrays + of bytes, just like any chunk of memory. Buffer objects allow GL + commands to source data from a buffer object by binding the buffer + object to a given target and then overloading a certain set of GL + commands' pointer arguments to refer to offsets inside the buffer, + rather than pointers to user memory. An offset is encoded in a + pointer by adding the offset to a null pointer. + + This extension does not add any new functionality to buffer + objects themselves. It simply adds two new targets to which buffer + objects can be bound: PIXEL_PACK_BUFFER and PIXEL_UNPACK_BUFFER. + When a buffer object is bound to the PIXEL_PACK_BUFFER target, + commands such as ReadPixels write their data into a buffer object. + When a buffer object is bound to the PIXEL_UNPACK_BUFFER target, + commands such as DrawPixels read their data from a buffer object. + + There are a wide variety of applications for such functionality. + Some of the most interesting ones are: + + - "Render to vertex array." The application can use a fragment + program to render some image into one of its buffers, then read + this image out into a buffer object via ReadPixels. Then, it can + use this buffer object as a source of vertex data. + + - Streaming textures. If the application uses MapBuffer/UnmapBuffer + to write its data for TexSubImage into a buffer object, at least + one of the data copies usually required to download a texture can + be eliminated, significantly increasing texture download + performance. + + - Asynchronous ReadPixels. If an application needs to read back a + number of images and process them with the CPU, the existing GL + interface makes it nearly impossible to pipeline this operation. + The driver will typically send the hardware a readback command + when ReadPixels is called, and then wait for all of the data to + be available before returning control to the application. Then, + the application can either process the data immediately or call + ReadPixels again; in neither case will the readback overlap with + the processing. If the application issues several readbacks into + several buffer objects, however, and then maps each one to process + its data, then the readbacks can proceed in parallel with the data + processing. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/pixel_buffer_object.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.EXT.pixel_buffer_object import * +from OpenGL.raw.GL.EXT.pixel_buffer_object import _EXTENSION_NAME + +def glInitPixelBufferObjectEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/pixel_transform.py b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/pixel_transform.py new file mode 100644 index 00000000..ecb3503b --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/pixel_transform.py @@ -0,0 +1,44 @@ +'''OpenGL extension EXT.pixel_transform + +This module customises the behaviour of the +OpenGL.raw.GL.EXT.pixel_transform to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides support for scaling, rotation, translation and + shearing of two-dimensional pixel rectangles in the pixel rasterizer. + The transformation is defined via a 4x4 matrix, where only those entries + which apply as a 2D affine transformation will be accepted and used. + These matrices can be manipulated using the same functions as the other + OpenGL matrix stacks. + + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/pixel_transform.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.EXT.pixel_transform import * +from OpenGL.raw.GL.EXT.pixel_transform import _EXTENSION_NAME + +def glInitPixelTransformEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +glPixelTransformParameterivEXT=wrapper.wrapper(glPixelTransformParameterivEXT).setInputArraySize( + 'params', 1 +) +glPixelTransformParameterfvEXT=wrapper.wrapper(glPixelTransformParameterfvEXT).setInputArraySize( + 'params', 1 +) +glGetPixelTransformParameterivEXT=wrapper.wrapper(glGetPixelTransformParameterivEXT).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetPixelTransformParameterfvEXT=wrapper.wrapper(glGetPixelTransformParameterfvEXT).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/pixel_transform_color_table.py b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/pixel_transform_color_table.py new file mode 100644 index 00000000..13d31525 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/pixel_transform_color_table.py @@ -0,0 +1,28 @@ +'''OpenGL extension EXT.pixel_transform_color_table + +This module customises the behaviour of the +OpenGL.raw.GL.EXT.pixel_transform_color_table to provide a more +Python-friendly API + +Overview (from the spec) + + This extension defines a color table that is applied immediately + after the pixel transformation operation. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/pixel_transform_color_table.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.EXT.pixel_transform_color_table import * +from OpenGL.raw.GL.EXT.pixel_transform_color_table import _EXTENSION_NAME + +def glInitPixelTransformColorTableEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/point_parameters.py b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/point_parameters.py new file mode 100644 index 00000000..d946bcda --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/point_parameters.py @@ -0,0 +1,77 @@ +'''OpenGL extension EXT.point_parameters + +This module customises the behaviour of the +OpenGL.raw.GL.EXT.point_parameters to provide a more +Python-friendly API + +Overview (from the spec) + + This extension supports additional geometric characteristics of points. It + can be used to render particles or tiny light sources, commonly referred + as "Light points". + + The raster brightness of a point is a function of the point area, point + color, point transparency, and the response of the display's electron gun + and phosphor. The point area and the point transparency are derived from the + point size, currently provided with the parameter of glPointSize. + + The primary motivation is to allow the size of a point to be affected by + distance attenuation. When distance attenuation has an effect, the final + point size decreases as the distance of the point from the eye increases. + + The secondary motivation is a mean to control the mapping from the point + size to the raster point area and point transparency. This is done in order + to increase the dynamic range of the raster brightness of points. In other + words, the alpha component of a point may be decreased (and its transparency + increased) as its area shrinks below a defined threshold. + + This extension defines a derived point size to be closely related to point + brightness. The brightness of a point is given by: + + 1 + dist_atten(d) = ------------------- + a + b * d + c * d^2 + + brightness(Pe) = Brightness * dist_atten(|Pe|) + + where 'Pe' is the point in eye coordinates, and 'Brightness' is some initial + value proportional to the square of the size provided with glPointSize. Here + we simplify the raster brightness to be a function of the rasterized point + area and point transparency. + + brightness(Pe) brightness(Pe) >= Threshold_Area + area(Pe) = + Threshold_Area Otherwise + + factor(Pe) = brightness(Pe)/Threshold_Area + + alpha(Pe) = Alpha * factor(Pe) + + where 'Alpha' comes with the point color (possibly modified by lighting). + + 'Threshold_Area' above is in area units. Thus, it is proportional to the + square of the threshold provided by the programmer through this extension. + + The new point size derivation method applies to all points, while the + threshold applies to multisample points only. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/point_parameters.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.EXT.point_parameters import * +from OpenGL.raw.GL.EXT.point_parameters import _EXTENSION_NAME + +def glInitPointParametersEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glPointParameterfvEXT.params size not checked against 'pname' +glPointParameterfvEXT=wrapper.wrapper(glPointParameterfvEXT).setInputArraySize( + 'params', None +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/polygon_offset.py b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/polygon_offset.py new file mode 100644 index 00000000..ba2534d0 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/polygon_offset.py @@ -0,0 +1,37 @@ +'''OpenGL extension EXT.polygon_offset + +This module customises the behaviour of the +OpenGL.raw.GL.EXT.polygon_offset to provide a more +Python-friendly API + +Overview (from the spec) + + The depth values of fragments generated by rendering polygons are + displaced by an amount that is proportional to the maximum absolute + value of the depth slope of the polygon, measured and applied in window + coordinates. This displacement allows lines (or points) and polygons + in the same plane to be rendered without interaction -- the lines + rendered either completely in front of or behind the polygons + (depending on the sign of the offset factor). It also allows multiple + coplanar polygons to be rendered without interaction, if different + offset factors are used for each polygon. Applications include + rendering hidden-line images, rendering solids with highlighted edges, + and applying `decals' to surfaces. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/polygon_offset.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.EXT.polygon_offset import * +from OpenGL.raw.GL.EXT.polygon_offset import _EXTENSION_NAME + +def glInitPolygonOffsetEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/polygon_offset_clamp.py b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/polygon_offset_clamp.py new file mode 100644 index 00000000..b32c5b9a --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/polygon_offset_clamp.py @@ -0,0 +1,35 @@ +'''OpenGL extension EXT.polygon_offset_clamp + +This module customises the behaviour of the +OpenGL.raw.GL.EXT.polygon_offset_clamp to provide a more +Python-friendly API + +Overview (from the spec) + + This extension adds a new parameter to the polygon offset function + that clamps the calculated offset to a minimum or maximum value. + The clamping functionality is useful when polygons are nearly + parallel to the view direction because their high slopes can result + in arbitrarily large polygon offsets. In the particular case of + shadow mapping, the lack of clamping can produce the appearance of + unwanted holes when the shadow casting polygons are offset beyond + the shadow receiving polygons, and this problem can be alleviated by + enforcing a maximum offset value. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/polygon_offset_clamp.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.EXT.polygon_offset_clamp import * +from OpenGL.raw.GL.EXT.polygon_offset_clamp import _EXTENSION_NAME + +def glInitPolygonOffsetClampEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/post_depth_coverage.py b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/post_depth_coverage.py new file mode 100644 index 00000000..99f8884e --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/post_depth_coverage.py @@ -0,0 +1,37 @@ +'''OpenGL extension EXT.post_depth_coverage + +This module customises the behaviour of the +OpenGL.raw.GL.EXT.post_depth_coverage to provide a more +Python-friendly API + +Overview (from the spec) + + This extension allows the fragment shader to control whether values in + gl_SampleMaskIn[] reflect the coverage after application of the early + depth and stencil tests. This feature can be enabled with the following + layout qualifier in the fragment shader: + + layout(post_depth_coverage) in; + + To use this feature, early fragment tests must also be enabled in the + fragment shader via: + + layout(early_fragment_tests) in; + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/post_depth_coverage.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.EXT.post_depth_coverage import * +from OpenGL.raw.GL.EXT.post_depth_coverage import _EXTENSION_NAME + +def glInitPostDepthCoverageEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/provoking_vertex.py b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/provoking_vertex.py new file mode 100644 index 00000000..2710b670 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/provoking_vertex.py @@ -0,0 +1,52 @@ +'''OpenGL extension EXT.provoking_vertex + +This module customises the behaviour of the +OpenGL.raw.GL.EXT.provoking_vertex to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides an alternative provoking vertex convention + for rendering lines, triangles, and (optionally depending on the + implementation) quads. + + The provoking vertex of a primitive is the vertex that determines the + constant primary and secondary colors when flat shading is enabled. + + In OpenGL, the provoking vertex for triangle, quad, line, and + (trivially) point primitives is the last vertex used to assemble + the primitive. The polygon primitive is an exception in OpenGL where + the first vertex of a polygon primitive determines the color of the + polygon, even if actually broken into triangles and/or quads. + + See section 2.14.7 (Flatshading) of the OpenGL 2.1 specification, + particularly Table 2.12 for more details. + + Alternatively the provoking vertex could be the first vertex of + the primitive. Other APIs with flat-shading functionality such + as Reality Lab and Direct3D have adopted the "first vertex of the + primitive" convention to determine the provoking vertex. However, + these APIs lack quads so do not have a defined provoking vertex + convention for quads. + + The motivation for this extension is to allow applications developed + for APIs with a "first vertex of the primitive" provoking vertex to + be easily converted to OpenGL. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/provoking_vertex.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.EXT.provoking_vertex import * +from OpenGL.raw.GL.EXT.provoking_vertex import _EXTENSION_NAME + +def glInitProvokingVertexEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/raster_multisample.py b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/raster_multisample.py new file mode 100644 index 00000000..11d8ad95 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/raster_multisample.py @@ -0,0 +1,42 @@ +'''OpenGL extension EXT.raster_multisample + +This module customises the behaviour of the +OpenGL.raw.GL.EXT.raster_multisample to provide a more +Python-friendly API + +Overview (from the spec) + + This extension allows rendering to a non-multisample color buffer while + rasterizing with more than one sample. The result of rasterization + (coverage) is available in the gl_SampleMaskIn[] fragment shader input, + multisample rasterization is enabled for all primitives, and several per- + fragment operations operate at the raster sample rate. + + When using the functionality provided by this extension, depth, stencil, + and depth bounds tests must be disabled, and a multisample draw + framebuffer must not be used. + + A fragment's "coverage", or "effective raster samples" is considered to + have "N bits" (as opposed to "one bit" corresponding to the single color + sample) through the fragment shader, in the sample mask output, through + the multisample fragment operations and occlusion query, until the coverage + is finally "reduced" to a single bit in a new "Coverage Reduction" stage + that occurs before blending. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/raster_multisample.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.EXT.raster_multisample import * +from OpenGL.raw.GL.EXT.raster_multisample import _EXTENSION_NAME + +def glInitRasterMultisampleEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/rescale_normal.py b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/rescale_normal.py new file mode 100644 index 00000000..425f0685 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/rescale_normal.py @@ -0,0 +1,34 @@ +'''OpenGL extension EXT.rescale_normal + +This module customises the behaviour of the +OpenGL.raw.GL.EXT.rescale_normal to provide a more +Python-friendly API + +Overview (from the spec) + + When normal rescaling is enabled a new operation is added to the + transformation of the normal vector into eye coordinates. The normal vector + is rescaled after it is multiplied by the inverse modelview matrix and + before it is normalized. + + The rescale factor is chosen so that in many cases normal vectors with unit + length in object coordinates will not need to be normalized as they + are transformed into eye coordinates. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/rescale_normal.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.EXT.rescale_normal import * +from OpenGL.raw.GL.EXT.rescale_normal import _EXTENSION_NAME + +def glInitRescaleNormalEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/secondary_color.py b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/secondary_color.py new file mode 100644 index 00000000..097623ea --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/secondary_color.py @@ -0,0 +1,57 @@ +'''OpenGL extension EXT.secondary_color + +This module customises the behaviour of the +OpenGL.raw.GL.EXT.secondary_color to provide a more +Python-friendly API + +Overview (from the spec) + + This extension allows specifying the RGB components of the secondary + color used in the Color Sum stage, instead of using the default + (0,0,0,0) color. It applies only in RGBA mode and when LIGHTING is + disabled. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/secondary_color.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.EXT.secondary_color import * +from OpenGL.raw.GL.EXT.secondary_color import _EXTENSION_NAME + +def glInitSecondaryColorEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +glSecondaryColor3bvEXT=wrapper.wrapper(glSecondaryColor3bvEXT).setInputArraySize( + 'v', 3 +) +glSecondaryColor3dvEXT=wrapper.wrapper(glSecondaryColor3dvEXT).setInputArraySize( + 'v', 3 +) +glSecondaryColor3fvEXT=wrapper.wrapper(glSecondaryColor3fvEXT).setInputArraySize( + 'v', 3 +) +glSecondaryColor3ivEXT=wrapper.wrapper(glSecondaryColor3ivEXT).setInputArraySize( + 'v', 3 +) +glSecondaryColor3svEXT=wrapper.wrapper(glSecondaryColor3svEXT).setInputArraySize( + 'v', 3 +) +glSecondaryColor3ubvEXT=wrapper.wrapper(glSecondaryColor3ubvEXT).setInputArraySize( + 'v', 3 +) +glSecondaryColor3uivEXT=wrapper.wrapper(glSecondaryColor3uivEXT).setInputArraySize( + 'v', 3 +) +glSecondaryColor3usvEXT=wrapper.wrapper(glSecondaryColor3usvEXT).setInputArraySize( + 'v', 3 +) +# INPUT glSecondaryColorPointerEXT.pointer size not checked against 'size,type,stride' +glSecondaryColorPointerEXT=wrapper.wrapper(glSecondaryColorPointerEXT).setInputArraySize( + 'pointer', None +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/semaphore.py b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/semaphore.py new file mode 100644 index 00000000..73ccd7fd --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/semaphore.py @@ -0,0 +1,58 @@ +'''OpenGL extension EXT.semaphore + +This module customises the behaviour of the +OpenGL.raw.GL.EXT.semaphore to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/semaphore.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.EXT.semaphore import * +from OpenGL.raw.GL.EXT.semaphore import _EXTENSION_NAME + +def glInitSemaphoreEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glGetUnsignedBytevEXT.data size not checked against 'pname' +glGetUnsignedBytevEXT=wrapper.wrapper(glGetUnsignedBytevEXT).setInputArraySize( + 'data', None +) +# INPUT glGetUnsignedBytei_vEXT.data size not checked against 'target' +glGetUnsignedBytei_vEXT=wrapper.wrapper(glGetUnsignedBytei_vEXT).setInputArraySize( + 'data', None +) +# INPUT glGenSemaphoresEXT.semaphores size not checked against n +glGenSemaphoresEXT=wrapper.wrapper(glGenSemaphoresEXT).setInputArraySize( + 'semaphores', None +) +# INPUT glDeleteSemaphoresEXT.semaphores size not checked against n +glDeleteSemaphoresEXT=wrapper.wrapper(glDeleteSemaphoresEXT).setInputArraySize( + 'semaphores', None +) +# INPUT glWaitSemaphoreEXT.buffers size not checked against 'numBufferBarriers' +# INPUT glWaitSemaphoreEXT.srcLayouts size not checked against 'numTextureBarriers' +# INPUT glWaitSemaphoreEXT.textures size not checked against 'numTextureBarriers' +glWaitSemaphoreEXT=wrapper.wrapper(glWaitSemaphoreEXT).setInputArraySize( + 'buffers', None +).setInputArraySize( + 'srcLayouts', None +).setInputArraySize( + 'textures', None +) +# INPUT glSignalSemaphoreEXT.buffers size not checked against 'numBufferBarriers' +# INPUT glSignalSemaphoreEXT.dstLayouts size not checked against 'numTextureBarriers' +# INPUT glSignalSemaphoreEXT.textures size not checked against 'numTextureBarriers' +glSignalSemaphoreEXT=wrapper.wrapper(glSignalSemaphoreEXT).setInputArraySize( + 'buffers', None +).setInputArraySize( + 'dstLayouts', None +).setInputArraySize( + 'textures', None +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/semaphore_fd.py b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/semaphore_fd.py new file mode 100644 index 00000000..da84cf3f --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/semaphore_fd.py @@ -0,0 +1,23 @@ +'''OpenGL extension EXT.semaphore_fd + +This module customises the behaviour of the +OpenGL.raw.GL.EXT.semaphore_fd to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/semaphore_fd.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.EXT.semaphore_fd import * +from OpenGL.raw.GL.EXT.semaphore_fd import _EXTENSION_NAME + +def glInitSemaphoreFdEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/semaphore_win32.py b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/semaphore_win32.py new file mode 100644 index 00000000..7ee4abcb --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/semaphore_win32.py @@ -0,0 +1,23 @@ +'''OpenGL extension EXT.semaphore_win32 + +This module customises the behaviour of the +OpenGL.raw.GL.EXT.semaphore_win32 to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/semaphore_win32.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.EXT.semaphore_win32 import * +from OpenGL.raw.GL.EXT.semaphore_win32 import _EXTENSION_NAME + +def glInitSemaphoreWin32EXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/separate_shader_objects.py b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/separate_shader_objects.py new file mode 100644 index 00000000..429d09c4 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/separate_shader_objects.py @@ -0,0 +1,128 @@ +'''OpenGL extension EXT.separate_shader_objects + +This module customises the behaviour of the +OpenGL.raw.GL.EXT.separate_shader_objects to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/separate_shader_objects.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.EXT.separate_shader_objects import * +from OpenGL.raw.GL.EXT.separate_shader_objects import _EXTENSION_NAME + +def glInitSeparateShaderObjectsEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glCreateShaderProgramvEXT.strings size not checked against count +glCreateShaderProgramvEXT=wrapper.wrapper(glCreateShaderProgramvEXT).setInputArraySize( + 'strings', None +) +# INPUT glDeleteProgramPipelinesEXT.pipelines size not checked against n +glDeleteProgramPipelinesEXT=wrapper.wrapper(glDeleteProgramPipelinesEXT).setInputArraySize( + 'pipelines', None +) +# INPUT glGenProgramPipelinesEXT.pipelines size not checked against n +glGenProgramPipelinesEXT=wrapper.wrapper(glGenProgramPipelinesEXT).setInputArraySize( + 'pipelines', None +) +# INPUT glGetProgramPipelineInfoLogEXT.infoLog size not checked against bufSize +glGetProgramPipelineInfoLogEXT=wrapper.wrapper(glGetProgramPipelineInfoLogEXT).setInputArraySize( + 'infoLog', None +).setInputArraySize( + 'length', 1 +) +# INPUT glProgramUniform1fvEXT.value size not checked against count +glProgramUniform1fvEXT=wrapper.wrapper(glProgramUniform1fvEXT).setInputArraySize( + 'value', None +) +# INPUT glProgramUniform1ivEXT.value size not checked against count +glProgramUniform1ivEXT=wrapper.wrapper(glProgramUniform1ivEXT).setInputArraySize( + 'value', None +) +# INPUT glProgramUniform2fvEXT.value size not checked against count*2 +glProgramUniform2fvEXT=wrapper.wrapper(glProgramUniform2fvEXT).setInputArraySize( + 'value', None +) +# INPUT glProgramUniform2ivEXT.value size not checked against count*2 +glProgramUniform2ivEXT=wrapper.wrapper(glProgramUniform2ivEXT).setInputArraySize( + 'value', None +) +# INPUT glProgramUniform3fvEXT.value size not checked against count*3 +glProgramUniform3fvEXT=wrapper.wrapper(glProgramUniform3fvEXT).setInputArraySize( + 'value', None +) +# INPUT glProgramUniform3ivEXT.value size not checked against count*3 +glProgramUniform3ivEXT=wrapper.wrapper(glProgramUniform3ivEXT).setInputArraySize( + 'value', None +) +# INPUT glProgramUniform4fvEXT.value size not checked against count*4 +glProgramUniform4fvEXT=wrapper.wrapper(glProgramUniform4fvEXT).setInputArraySize( + 'value', None +) +# INPUT glProgramUniform4ivEXT.value size not checked against count*4 +glProgramUniform4ivEXT=wrapper.wrapper(glProgramUniform4ivEXT).setInputArraySize( + 'value', None +) +# INPUT glProgramUniformMatrix2fvEXT.value size not checked against count*4 +glProgramUniformMatrix2fvEXT=wrapper.wrapper(glProgramUniformMatrix2fvEXT).setInputArraySize( + 'value', None +) +# INPUT glProgramUniformMatrix3fvEXT.value size not checked against count*9 +glProgramUniformMatrix3fvEXT=wrapper.wrapper(glProgramUniformMatrix3fvEXT).setInputArraySize( + 'value', None +) +# INPUT glProgramUniformMatrix4fvEXT.value size not checked against count*16 +glProgramUniformMatrix4fvEXT=wrapper.wrapper(glProgramUniformMatrix4fvEXT).setInputArraySize( + 'value', None +) +# INPUT glProgramUniform1uivEXT.value size not checked against count +glProgramUniform1uivEXT=wrapper.wrapper(glProgramUniform1uivEXT).setInputArraySize( + 'value', None +) +# INPUT glProgramUniform2uivEXT.value size not checked against count*2 +glProgramUniform2uivEXT=wrapper.wrapper(glProgramUniform2uivEXT).setInputArraySize( + 'value', None +) +# INPUT glProgramUniform3uivEXT.value size not checked against count*3 +glProgramUniform3uivEXT=wrapper.wrapper(glProgramUniform3uivEXT).setInputArraySize( + 'value', None +) +# INPUT glProgramUniform4uivEXT.value size not checked against count*4 +glProgramUniform4uivEXT=wrapper.wrapper(glProgramUniform4uivEXT).setInputArraySize( + 'value', None +) +# INPUT glProgramUniformMatrix4fvEXT.value size not checked against count*16 +glProgramUniformMatrix4fvEXT=wrapper.wrapper(glProgramUniformMatrix4fvEXT).setInputArraySize( + 'value', None +) +# INPUT glProgramUniformMatrix2x3fvEXT.value size not checked against count*6 +glProgramUniformMatrix2x3fvEXT=wrapper.wrapper(glProgramUniformMatrix2x3fvEXT).setInputArraySize( + 'value', None +) +# INPUT glProgramUniformMatrix3x2fvEXT.value size not checked against count*6 +glProgramUniformMatrix3x2fvEXT=wrapper.wrapper(glProgramUniformMatrix3x2fvEXT).setInputArraySize( + 'value', None +) +# INPUT glProgramUniformMatrix2x4fvEXT.value size not checked against count*8 +glProgramUniformMatrix2x4fvEXT=wrapper.wrapper(glProgramUniformMatrix2x4fvEXT).setInputArraySize( + 'value', None +) +# INPUT glProgramUniformMatrix4x2fvEXT.value size not checked against count*8 +glProgramUniformMatrix4x2fvEXT=wrapper.wrapper(glProgramUniformMatrix4x2fvEXT).setInputArraySize( + 'value', None +) +# INPUT glProgramUniformMatrix3x4fvEXT.value size not checked against count*12 +glProgramUniformMatrix3x4fvEXT=wrapper.wrapper(glProgramUniformMatrix3x4fvEXT).setInputArraySize( + 'value', None +) +# INPUT glProgramUniformMatrix4x3fvEXT.value size not checked against count*12 +glProgramUniformMatrix4x3fvEXT=wrapper.wrapper(glProgramUniformMatrix4x3fvEXT).setInputArraySize( + 'value', None +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/separate_specular_color.py b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/separate_specular_color.py new file mode 100644 index 00000000..73315666 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/separate_specular_color.py @@ -0,0 +1,55 @@ +'''OpenGL extension EXT.separate_specular_color + +This module customises the behaviour of the +OpenGL.raw.GL.EXT.separate_specular_color to provide a more +Python-friendly API + +Overview (from the spec) + + This extension adds a second color to rasterization when lighting is + enabled. Its purpose is to produce textured objects with specular + highlights which are the color of the lights. It applies only to + rgba lighting. + + The two colors are computed at the vertexes. They are both clamped, + flat-shaded, clipped, and converted to fixed-point just like the + current rgba color (see Figure 2.8). Rasterization interpolates + both colors to fragments. If texture is enabled, the first (or + primary) color is the input to the texture environment; the fragment + color is the sum of the second color and the color resulting from + texture application. If texture is not enabled, the fragment color + is the sum of the two colors. + + A new control to LightModel*, LIGHT_MODEL_COLOR_CONTROL_EXT, manages + the values of the two colors. It takes values: SINGLE_COLOR_EXT, a + compatibility mode, and SEPARATE_SPECULAR_COLOR_EXT, the object of + this extension. In single color mode, the primary color is the + current final color and the secondary color is 0.0. In separate + specular mode, the primary color is the sum of the ambient, diffuse, + and emissive terms of final color and the secondary color is the + specular term. + + There is much concern that this extension may not be compatible with + the future direction of OpenGL with regards to better lighting and + shading models. Until those impacts are resolved, serious + consideration should be given before adding to the interface + specified herein (for example, allowing the user to specify a + second input color). + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/separate_specular_color.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.EXT.separate_specular_color import * +from OpenGL.raw.GL.EXT.separate_specular_color import _EXTENSION_NAME + +def glInitSeparateSpecularColorEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/shader_framebuffer_fetch.py b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/shader_framebuffer_fetch.py new file mode 100644 index 00000000..a5207a3b --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/shader_framebuffer_fetch.py @@ -0,0 +1,58 @@ +'''OpenGL extension EXT.shader_framebuffer_fetch + +This module customises the behaviour of the +OpenGL.raw.GL.EXT.shader_framebuffer_fetch to provide a more +Python-friendly API + +Overview (from the spec) + + Conventional OpenGL blending provides a configurable series of operations + that can be used to combine the output values from a fragment shader with + the values already in the framebuffer. While these operations are + suitable for basic image compositing, other compositing operations or + operations that treat fragment output as something other than a color + (normals, for instance) may not be expressible without multiple passes or + render-to-texture operations. + + This extension provides a mechanism whereby a fragment shader may read + existing framebuffer data as input. This can be used to implement + compositing operations that would have been inconvenient or impossible with + fixed-function blending. It can also be used to apply a function to the + framebuffer color, by writing a shader which uses the existing framebuffer + color as its only input. + + This extension provides two alternative name strings: + + - GL_EXT_shader_framebuffer_fetch guarantees full coherency between + framebuffer reads and writes. If this extension string is exposed, the + result of reading from the framebuffer from a fragment shader invocation + is guaranteed to reflect values written by any previous overlapping + samples in API primitive order, unless requested otherwise in the shader + source using the noncoherent layout qualifier. + + - GL_EXT_shader_framebuffer_fetch_non_coherent provides limited implicit + coherency guarantees. Instead, the application is expected to call the + FramebufferFetchBarrierEXT command for previous framebuffer writes to + become visible to subsequent fragment shader invocations. For this + extension to give well-defined results applications may have to split + rendering into multiple passes separated with FramebufferFetchBarrierEXT + calls. The functionality provided by this extension is requested in the + shader source using the noncoherent layout qualifier. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/shader_framebuffer_fetch.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.EXT.shader_framebuffer_fetch import * +from OpenGL.raw.GL.EXT.shader_framebuffer_fetch import _EXTENSION_NAME + +def glInitShaderFramebufferFetchEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/shader_framebuffer_fetch_non_coherent.py b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/shader_framebuffer_fetch_non_coherent.py new file mode 100644 index 00000000..4b09c421 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/shader_framebuffer_fetch_non_coherent.py @@ -0,0 +1,23 @@ +'''OpenGL extension EXT.shader_framebuffer_fetch_non_coherent + +This module customises the behaviour of the +OpenGL.raw.GL.EXT.shader_framebuffer_fetch_non_coherent to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/shader_framebuffer_fetch_non_coherent.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.EXT.shader_framebuffer_fetch_non_coherent import * +from OpenGL.raw.GL.EXT.shader_framebuffer_fetch_non_coherent import _EXTENSION_NAME + +def glInitShaderFramebufferFetchNonCoherentEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/shader_image_load_formatted.py b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/shader_image_load_formatted.py new file mode 100644 index 00000000..5a27ff99 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/shader_image_load_formatted.py @@ -0,0 +1,32 @@ +'''OpenGL extension EXT.shader_image_load_formatted + +This module customises the behaviour of the +OpenGL.raw.GL.EXT.shader_image_load_formatted to provide a more +Python-friendly API + +Overview (from the spec) + + ARB_shader_image_load_store (and OpenGL 4.2) added support for + random access load and store from/to texture images, but due to + hardware limitations, loads were required to declare the image + format in the shader source. This extension relaxes that + requirement, and the return values from imageLoad can be format- + converted based on the format of the image binding. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/shader_image_load_formatted.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.EXT.shader_image_load_formatted import * +from OpenGL.raw.GL.EXT.shader_image_load_formatted import _EXTENSION_NAME + +def glInitShaderImageLoadFormattedEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/shader_image_load_store.py b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/shader_image_load_store.py new file mode 100644 index 00000000..93551963 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/shader_image_load_store.py @@ -0,0 +1,70 @@ +'''OpenGL extension EXT.shader_image_load_store + +This module customises the behaviour of the +OpenGL.raw.GL.EXT.shader_image_load_store to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides GLSL built-in functions allowing shaders to load + from, store to, and perform atomic read-modify-write operations to a + single level of a texture object from any shader stage. These built-in + functions are named imageLoad(), imageStore(), and imageAtomic*(), + respectively, and accept integer texel coordinates to identify the texel + accessed. The extension adds the notion of "image units" to the OpenGL + API, to which texture levels are bound for access by the GLSL built-in + functions. To allow shaders to specify the image unit to access, GLSL + provides a new set of data types ("image*") similar to samplers. Each + image variable is assigned an integer value to identify an image unit to + access, which is specified using Uniform*() APIs in a manner similar to + samplers. For implementations supporting the NV_gpu_program5 extensions, + assembly language instructions to perform image loads, stores, and atomics + are also provided. + + This extension also provides the capability to explicitly enable "early" + per-fragment tests, where operations like depth and stencil testing are + performed prior to fragment shader execution. In unextended OpenGL, + fragment shaders never have any side effects and implementations can + sometimes perform per-fragment tests and discard some fragments prior to + executing the fragment shader. Since this extension allows fragment + shaders to write to texture and buffer object memory using the built-in + image functions, such optimizations could lead to non-deterministic + results. To avoid this, implementations supporting this extension may not + perform such optimizations on shaders having such side effects. However, + enabling early per-fragment tests guarantees that such tests will be + performed prior to fragment shader execution, and ensures that image + stores and atomics will not be performed by fragment shader invocations + where these per-fragment tests fail. + + Finally, this extension provides both a GLSL built-in function and an + OpenGL API function allowing applications some control over the ordering + of image loads, stores, and atomics relative to other OpenGL pipeline + operations accessing the same memory. Because the extension provides the + ability to perform random accesses to texture or buffer object memory, + such accesses are not easily tracked by the OpenGL driver. To avoid the + need for heavy-handed synchronization at the driver level, this extension + requires manual synchronization. The MemoryBarrierEXT() OpenGL API + function allows applications to specify a bitfield indicating the set of + OpenGL API operations to synchronize relative to shader memory access. + The memoryBarrier() GLSL built-in function provides a synchronization + point within a given shader invocation to ensure that all memory accesses + performed prior to the synchronization point complete prior to any started + after the synchronization point. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/shader_image_load_store.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.EXT.shader_image_load_store import * +from OpenGL.raw.GL.EXT.shader_image_load_store import _EXTENSION_NAME + +def glInitShaderImageLoadStoreEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/shader_integer_mix.py b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/shader_integer_mix.py new file mode 100644 index 00000000..c73a95cb --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/shader_integer_mix.py @@ -0,0 +1,30 @@ +'''OpenGL extension EXT.shader_integer_mix + +This module customises the behaviour of the +OpenGL.raw.GL.EXT.shader_integer_mix to provide a more +Python-friendly API + +Overview (from the spec) + + GLSL 1.30 (and GLSL ES 3.00) expanded the mix() built-in function to + operate on a boolean third argument that does not interpolate but + selects. This extension extends mix() to select between int, uint, + and bool components. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/shader_integer_mix.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.EXT.shader_integer_mix import * +from OpenGL.raw.GL.EXT.shader_integer_mix import _EXTENSION_NAME + +def glInitShaderIntegerMixEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/shadow_funcs.py b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/shadow_funcs.py new file mode 100644 index 00000000..7dc91960 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/shadow_funcs.py @@ -0,0 +1,29 @@ +'''OpenGL extension EXT.shadow_funcs + +This module customises the behaviour of the +OpenGL.raw.GL.EXT.shadow_funcs to provide a more +Python-friendly API + +Overview (from the spec) + + This extension generalizes the GL_ARB_shadow extension to support all + eight binary texture comparison functions rather than just GL_LEQUAL + and GL_GEQUAL. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/shadow_funcs.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.EXT.shadow_funcs import * +from OpenGL.raw.GL.EXT.shadow_funcs import _EXTENSION_NAME + +def glInitShadowFuncsEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/shared_texture_palette.py b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/shared_texture_palette.py new file mode 100644 index 00000000..818fe69a --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/shared_texture_palette.py @@ -0,0 +1,33 @@ +'''OpenGL extension EXT.shared_texture_palette + +This module customises the behaviour of the +OpenGL.raw.GL.EXT.shared_texture_palette to provide a more +Python-friendly API + +Overview (from the spec) + + EXT_shared_texture_palette defines a shared texture palette which may be + used in place of the texture object palettes provided by + EXT_paletted_texture. This is useful for rapidly changing a palette + common to many textures, rather than having to reload the new palette + for each texture. The extension acts as a switch, causing all lookups + that would normally be done on the texture's palette to instead use the + shared palette. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/shared_texture_palette.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.EXT.shared_texture_palette import * +from OpenGL.raw.GL.EXT.shared_texture_palette import _EXTENSION_NAME + +def glInitSharedTexturePaletteEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/sparse_texture2.py b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/sparse_texture2.py new file mode 100644 index 00000000..e424c965 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/sparse_texture2.py @@ -0,0 +1,53 @@ +'''OpenGL extension EXT.sparse_texture2 + +This module customises the behaviour of the +OpenGL.raw.GL.EXT.sparse_texture2 to provide a more +Python-friendly API + +Overview (from the spec) + + This extension builds on the ARB_sparse_texture extension, providing the + following new functionality: + + * New built-in GLSL texture lookup and image load functions are provided + that return information on whether the texels accessed for the texture + lookup accessed uncommitted texture memory. + + * New built-in GLSL texture lookup functions are provided that specify a + minimum level of detail to use for lookups where the level of detail + is computed automatically. This allows shaders to avoid accessing + unpopulated portions of high-resolution levels of detail when it knows + that the memory accessed is unpopulated, either from a priori + knowledge or from feedback provided by the return value of previously + executed "sparse" texture lookup functions. + + * Reads of uncommitted texture memory will act as though such memory + were filled with zeroes; previously, the values returned by reads were + undefined. + + * Standard implementation-independent virtual page sizes for internal + formats required to be supported with sparse textures. These standard + sizes can be requested by leaving VIRTUAL_PAGE_SIZE_INDEX_ARB at its + initial value (0). + + * Support for creating sparse multisample and multisample array textures + is added. However, the virtual page sizes for such textures remain + fully implementation-dependent. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/sparse_texture2.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.EXT.sparse_texture2 import * +from OpenGL.raw.GL.EXT.sparse_texture2 import _EXTENSION_NAME + +def glInitSparseTexture2EXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/stencil_clear_tag.py b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/stencil_clear_tag.py new file mode 100644 index 00000000..7c80994d --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/stencil_clear_tag.py @@ -0,0 +1,84 @@ +'''OpenGL extension EXT.stencil_clear_tag + +This module customises the behaviour of the +OpenGL.raw.GL.EXT.stencil_clear_tag to provide a more +Python-friendly API + +Overview (from the spec) + + Stencil-only framebuffer clears are increasingly common as 3D + applications are now using rendering algorithms such as stenciled + shadow volume rendering for multiple light sources in a single frame, + recent "soft" stenciled shadow volume techniques, and stencil-based + constructive solid geometry techniques. In such algorithms there + are multiple stencil buffer clears for each depth buffer clear. + Additionally in most cases, these algorithms do not require all + of the 8 typical stencil bitplanes for their stencil requirements. + In such cases, there is the potential for unused stencil bitplanes + to encode a "stencil clear tag" in such a way to reduce the number + of actual stencil clears. The idea is that switching to an unused + stencil clear tag logically corresponds to when an application would + otherwise perform a framebuffer-wide stencil clear. + + This extension exposes an inexpensive hardware mechanism for + amortizing the cost of multiple stencil-only clears by using a + client-specified number of upper bits of the stencil buffer to + maintain a per-pixel stencil tag. + + The upper bits of each stencil value is treated as a tag that + indicates the state of the upper bits of the "stencil clear tag" state + when the stencil value was last written. If a stencil value is read + and its upper bits containing its tag do NOT match the current upper + bits of the stencil clear tag state, the stencil value is substituted + with the lower bits of the stencil clear tag (the reset value). + Either way, the upper tag bits of the stencil value are ignored by + subsequent stencil function and operation processing of the stencil + value. + + When a stencil value is written to the stencil buffer, its upper bits + are overridden with the upper bits of the current stencil clear tag + state so subsequent reads, prior to any subsequent stencil clear + tag state change, properly return the updated lower bits. + + In this way, the stencil clear tag functionality provides a way to + replace multiple bandwidth-intensive stencil clears with very + inexpensive update of the stencil clear tag state. + + If used as expected with the client specifying 3 bits for the stencil + tag, every 7 of 8 stencil-only clears of the entire stencil buffer can + be substituted for an update of the current stencil clear tag rather + than an actual update of all the framebuffer's stencil values. Still, + every 8th clear must be an actual stencil clear. The net effect is + that the aggregate cost of stencil clears is reduced by a factor of + 1/(2^n) where n is the number of bits devoted to the stencil tag. + + The application specifies two new pieces of state: 1) the number of + upper stencil bits, n, assigned to maintain the tag bits for each + stencil value within the stencil buffer, and 2) a stencil clear tag + value that packs the current tag and a reset value into a single + integer values. The upper n bits of the stencil clear tag value + specify the current tag while the lower s-min(n,s) bits specify + the current reset value, where s is the number of bitplanes in the + stencil buffer and n is the current number of stencil tag bits. + + If zero stencil clear tag bits are assigned to the stencil tag + encoding, then the stencil buffer operates in the conventional + manner. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/stencil_clear_tag.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.EXT.stencil_clear_tag import * +from OpenGL.raw.GL.EXT.stencil_clear_tag import _EXTENSION_NAME + +def glInitStencilClearTagEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/stencil_two_side.py b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/stencil_two_side.py new file mode 100644 index 00000000..47671736 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/stencil_two_side.py @@ -0,0 +1,32 @@ +'''OpenGL extension EXT.stencil_two_side + +This module customises the behaviour of the +OpenGL.raw.GL.EXT.stencil_two_side to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides two-sided stencil testing where the + stencil-related state (stencil operations, reference value, compare + mask, and write mask) may be different for front- and back-facing + polygons. Two-sided stencil testing may improve the performance + of stenciled shadow volume and Constructive Solid Geometry (CSG) + rendering algorithms. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/stencil_two_side.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.EXT.stencil_two_side import * +from OpenGL.raw.GL.EXT.stencil_two_side import _EXTENSION_NAME + +def glInitStencilTwoSideEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/stencil_wrap.py b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/stencil_wrap.py new file mode 100644 index 00000000..5641e7e8 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/stencil_wrap.py @@ -0,0 +1,43 @@ +'''OpenGL extension EXT.stencil_wrap + +This module customises the behaviour of the +OpenGL.raw.GL.EXT.stencil_wrap to provide a more +Python-friendly API + +Overview (from the spec) + + Various algorithms use the stencil buffer to "count" the number of + surfaces that a ray passes through. As the ray passes into an object, + the stencil buffer is incremented. As the ray passes out of an object, + the stencil buffer is decremented. + + GL requires that the stencil increment operation clamps to its maximum + value. For algorithms that depend on the difference between the sum + of the increments and the sum of the decrements, clamping causes an + erroneous result. + + This extension provides an enable for both maximum and minimum wrapping + of stencil values. Instead, the stencil value wraps in both directions. + + Two additional stencil operations are specified. These new operations + are similiar to the existing INCR and DECR operations, but they wrap + their result instead of saturating it. This functionality matches + the new stencil operations introduced by DirectX 6. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/stencil_wrap.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.EXT.stencil_wrap import * +from OpenGL.raw.GL.EXT.stencil_wrap import _EXTENSION_NAME + +def glInitStencilWrapEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/subtexture.py b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/subtexture.py new file mode 100644 index 00000000..459eba6a --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/subtexture.py @@ -0,0 +1,42 @@ +'''OpenGL extension EXT.subtexture + +This module customises the behaviour of the +OpenGL.raw.GL.EXT.subtexture to provide a more +Python-friendly API + +Overview (from the spec) + + This extension allows a contiguous portion of an already-existing + texture image to be redefined, without affecting the remaining portion + of the image, or any of the other state that describe the texture. No + provision is made to query a subregion of a texture. + + Semantics for null image pointers are defined for TexImage1D, + TexImage2D, and TexImage3DEXT. Null image pointers can be used by + applications to effectively support texture arrays whose dimensions + are not a power of 2. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/subtexture.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.EXT.subtexture import * +from OpenGL.raw.GL.EXT.subtexture import _EXTENSION_NAME + +def glInitSubtextureEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glTexSubImage1DEXT.pixels size not checked against 'format,type,width' +glTexSubImage1DEXT=wrapper.wrapper(glTexSubImage1DEXT).setInputArraySize( + 'pixels', None +) +# INPUT glTexSubImage2DEXT.pixels size not checked against 'format,type,width,height' +glTexSubImage2DEXT=wrapper.wrapper(glTexSubImage2DEXT).setInputArraySize( + 'pixels', None +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/texture.py b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/texture.py new file mode 100644 index 00000000..64033df8 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/texture.py @@ -0,0 +1,50 @@ +'''OpenGL extension EXT.texture + +This module customises the behaviour of the +OpenGL.raw.GL.EXT.texture to provide a more +Python-friendly API + +Overview (from the spec) + + The original intention of this extension was simply to support various + numeric resolutions of color components in texture images. While it + accomplishes this, it also accomplishes a larger task, that of + formalizing the notion of an internal format for images, corresponding + to the external format that already existed for image data in host + memory. This notion of an internal image format will be used + extensively in later extensions, especially those concerned with pixel + manipulation. + + The idea of an internal format is simple: rather than treating a + retained image as having 1, 2, 3, or 4 components, treat it as though + it has a specific format, such as LUMINANCE_ALPHA, or just ALPHA. Then + define the semantics of the use of internal images with these formats in + a consistent way. Because texture mapping is already defined in GL, the + semantics for internal-format images were chosen to match those of the 1, + 2, 3, and 4 component internal images that already existed. The new + semantics are a superset of the old ones, however, so this extension + adds capabilities to GL, as well as allowing internal resolutions to be + specified. + + This extension also defines a robust method for applications to + determine what combinations of texture dimensions and resolutions are + supported by an implementation. It also introduces a new texture + environment: REPLACE_EXT. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/texture.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.EXT.texture import * +from OpenGL.raw.GL.EXT.texture import _EXTENSION_NAME + +def glInitTextureEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/texture3D.py b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/texture3D.py new file mode 100644 index 00000000..439fbc70 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/texture3D.py @@ -0,0 +1,40 @@ +'''OpenGL extension EXT.texture3D + +This module customises the behaviour of the +OpenGL.raw.GL.EXT.texture3D to provide a more +Python-friendly API + +Overview (from the spec) + + This extension defines 3-dimensional texture mapping. In order to + define a 3D texture image conveniently, this extension also defines the + in-memory formats for 3D images, and adds pixel storage modes to support + them. + + One important application of 3D textures is rendering volumes of image + data. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/texture3D.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.EXT.texture3D import * +from OpenGL.raw.GL.EXT.texture3D import _EXTENSION_NAME + +def glInitTexture3DEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glTexImage3DEXT.pixels size not checked against 'format,type,width,height,depth' +glTexImage3DEXT=wrapper.wrapper(glTexImage3DEXT).setInputArraySize( + 'pixels', None +) +# INPUT glTexSubImage3DEXT.pixels size not checked against 'format,type,width,height,depth' +glTexSubImage3DEXT=wrapper.wrapper(glTexSubImage3DEXT).setInputArraySize( + 'pixels', None +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/texture_array.py b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/texture_array.py new file mode 100644 index 00000000..3b8a498c --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/texture_array.py @@ -0,0 +1,56 @@ +'''OpenGL extension EXT.texture_array + +This module customises the behaviour of the +OpenGL.raw.GL.EXT.texture_array to provide a more +Python-friendly API + +Overview (from the spec) + + This extension introduces the notion of one- and two-dimensional array + textures. An array texture is a collection of one- and two-dimensional + images of identical size and format, arranged in layers. A + one-dimensional array texture is specified using TexImage2D; a + two-dimensional array texture is specified using TexImage3D. The height + (1D array) or depth (2D array) specify the number of layers in the image. + + An array texture is accessed as a single unit in a programmable shader, + using a single coordinate vector. A single layer is selected, and that + layer is then accessed as though it were a one- or two-dimensional + texture. The layer used is specified using the "t" or "r" texture + coordinate for 1D and 2D array textures, respectively. The layer + coordinate is provided as an unnormalized floating-point value in the + range [0,-1], where is the number of layers in the array texture. + Texture lookups do not filter between layers, though such filtering can be + achieved using programmable shaders. When mipmapping is used, each level + of an array texture has the same number of layers as the base level; the + number of layers is not reduced as the image size decreases. + + Array textures can be rendered to by binding them to a framebuffer object + (EXT_framebuffer_object). A single layer of an array texture can be bound + using normal framebuffer object mechanisms, or an entire array texture can + be bound and rendered to using the layered rendering mechanisms provided + by NV_geometry_program4. + + This extension does not provide for the use of array textures with + fixed-function fragment processing. Such support could be added by + providing an additional extension allowing applications to pass the new + target enumerants (TEXTURE_1D_ARRAY_EXT and TEXTURE_2D_ARRAY_EXT) to + Enable and Disable. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/texture_array.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.EXT.texture_array import * +from OpenGL.raw.GL.EXT.texture_array import _EXTENSION_NAME + +def glInitTextureArrayEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/texture_buffer_object.py b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/texture_buffer_object.py new file mode 100644 index 00000000..4fd8e21c --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/texture_buffer_object.py @@ -0,0 +1,58 @@ +'''OpenGL extension EXT.texture_buffer_object + +This module customises the behaviour of the +OpenGL.raw.GL.EXT.texture_buffer_object to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides a new texture type, called a buffer texture. + Buffer textures are one-dimensional arrays of texels whose storage comes + from an attached buffer object. When a buffer object is bound to a buffer + texture, a format is specified, and the data in the buffer object is + treated as an array of texels of the specified format. + + The use of a buffer object to provide storage allows the texture data to + be specified in a number of different ways: via buffer object loads + (BufferData), direct CPU writes (MapBuffer), framebuffer readbacks + (EXT_pixel_buffer_object extension). A buffer object can also be loaded + by transform feedback (NV_transform_feedback extension), which captures + selected transformed attributes of vertices processed by the GL. Several + of these mechanisms do not require an extra data copy, which would be + required when using conventional TexImage-like entry points. + + Buffer textures do not support mipmapping, texture lookups with normalized + floating-point texture coordinates, and texture filtering of any sort, and + may not be used in fixed-function fragment processing. They can be + accessed via single texel fetch operations in programmable shaders. For + assembly shaders (NV_gpu_program4), the TXF instruction is used. For GLSL + (EXT_gpu_shader4), a new sampler type and texel fetch function are used. + + Buffer textures can be substantially larger than equivalent + one-dimensional textures; the maximum texture size supported for buffer + textures in the initial implementation of this extension is 2^27 texels, + versus 2^13 (8192) texels for otherwise equivalent one-dimensional + textures. (Note that this extension only guarantees support for buffer + textures with 2^16 texels, but we expect most implementations to exceed + that substantially.) When a buffer object is attached to a buffer + texture, a size is not specified; rather, the number of texels in the + texture is taken by dividing the size of the buffer object by the size of + each texel. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/texture_buffer_object.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.EXT.texture_buffer_object import * +from OpenGL.raw.GL.EXT.texture_buffer_object import _EXTENSION_NAME + +def glInitTextureBufferObjectEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/texture_compression_latc.py b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/texture_compression_latc.py new file mode 100644 index 00000000..cb9a9c02 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/texture_compression_latc.py @@ -0,0 +1,39 @@ +'''OpenGL extension EXT.texture_compression_latc + +This module customises the behaviour of the +OpenGL.raw.GL.EXT.texture_compression_latc to provide a more +Python-friendly API + +Overview (from the spec) + + This extension introduces four new block-based texture compression + formats suited for unsigned and signed luminance and luminance-alpha + textures (hence the name "latc" for Luminance-Alpha Texture + Compression). + + These formats are designed to reduce the storage requirements and + memory bandwidth required for luminance and luminance-alpha textures + by a factor of 2-to-1 over conventional uncompressed luminance and + luminance-alpha textures with 8-bit components (GL_LUMINANCE8 and + GL_LUMINANCE8_ALPHA8). + + The compressed signed luminance-alpha format is reasonably suited + for storing compressed normal maps. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/texture_compression_latc.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.EXT.texture_compression_latc import * +from OpenGL.raw.GL.EXT.texture_compression_latc import _EXTENSION_NAME + +def glInitTextureCompressionLatcEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/texture_compression_rgtc.py b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/texture_compression_rgtc.py new file mode 100644 index 00000000..a97a2d3b --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/texture_compression_rgtc.py @@ -0,0 +1,44 @@ +'''OpenGL extension EXT.texture_compression_rgtc + +This module customises the behaviour of the +OpenGL.raw.GL.EXT.texture_compression_rgtc to provide a more +Python-friendly API + +Overview (from the spec) + + This extension introduces four new block-based texture compression + formats suited for unsigned and signed red and red-green textures + (hence the name "rgtc" for Red-Green Texture Compression). + + These formats are designed to reduce the storage requirements + and memory bandwidth required for red and red-green textures by + a factor of 2-to-1 over conventional uncompressed luminance and + luminance-alpha textures with 8-bit components (GL_LUMINANCE8 and + GL_LUMINANCE8_ALPHA8). + + The compressed signed red-green format is reasonably suited for + storing compressed normal maps. + + This extension uses the same compression format as the + EXT_texture_compression_latc extension except the color data is stored + in the red and green components rather than luminance and alpha. + Representing compressed red and green components is consistent with + the BC4 and BC5 compressed formats supported by DirectX 10. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/texture_compression_rgtc.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.EXT.texture_compression_rgtc import * +from OpenGL.raw.GL.EXT.texture_compression_rgtc import _EXTENSION_NAME + +def glInitTextureCompressionRgtcEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/texture_compression_s3tc.py b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/texture_compression_s3tc.py new file mode 100644 index 00000000..3961da42 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/texture_compression_s3tc.py @@ -0,0 +1,34 @@ +'''OpenGL extension EXT.texture_compression_s3tc + +This module customises the behaviour of the +OpenGL.raw.GL.EXT.texture_compression_s3tc to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides additional texture compression functionality + specific to S3's S3TC format (called DXTC in Microsoft's DirectX API), + subject to all the requirements and limitations described by the extension + GL_ARB_texture_compression. + + This extension supports DXT1, DXT3, and DXT5 texture compression formats. + For the DXT1 image format, this specification supports an RGB-only mode + and a special RGBA mode with single-bit "transparent" alpha. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/texture_compression_s3tc.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.EXT.texture_compression_s3tc import * +from OpenGL.raw.GL.EXT.texture_compression_s3tc import _EXTENSION_NAME + +def glInitTextureCompressionS3TcEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/texture_cube_map.py b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/texture_cube_map.py new file mode 100644 index 00000000..32cfd06b --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/texture_cube_map.py @@ -0,0 +1,72 @@ +'''OpenGL extension EXT.texture_cube_map + +This module customises the behaviour of the +OpenGL.raw.GL.EXT.texture_cube_map to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides a new texture generation scheme for cube + map textures. Instead of the current texture providing a 1D, 2D, + or 3D lookup into a 1D, 2D, or 3D texture image, the texture is a + set of six 2D images representing the faces of a cube. The (s,t,r) + texture coordinates are treated as a direction vector emanating from + the center of a cube. At texture generation time, the interpolated + per-fragment (s,t,r) selects one cube face 2D image based on the + largest magnitude coordinate (the major axis). A new 2D (s,t) is + calculated by dividing the two other coordinates (the minor axes + values) by the major axis value. Then the new (s,t) is used to + lookup into the selected 2D texture image face of the cube map. + + Unlike a standard 1D, 2D, or 3D texture that have just one target, + a cube map texture has six targets, one for each of its six 2D texture + image cube faces. All these targets must be consistent, complete, + and have a square dimension. + + This extension also provides two new texture coordinate generation modes + for use in conjunction with cube map texturing. The reflection map + mode generates texture coordinates (s,t,r) matching the vertex's + eye-space reflection vector. The reflection map mode + is useful for environment mapping without the singularity inherent + in sphere mapping. The normal map mode generates texture coordinates + (s,t,r) matching the vertex's transformed eye-space + normal. The normal map mode is useful for sophisticated cube + map texturing-based diffuse lighting models. + + The intent of the new texgen functionality is that an application using + cube map texturing can use the new texgen modes to automatically + generate the reflection or normal vectors used to look up into the + cube map texture. + + An application note: When using cube mapping with dynamic cube + maps (meaning the cube map texture is re-rendered every frame), + by keeping the cube map's orientation pointing at the eye position, + the texgen-computed reflection or normal vector texture coordinates + can be always properly oriented for the cube map. However if the + cube map is static (meaning that when view changes, the cube map + texture is not updated), the texture matrix must be used to rotate + the computed texgen-computed reflection or normal vector texture + coordinates to match the orientation of the cube map. The rotation + can be computed based on two vectors: 1) the direction vector from + the cube map center to the eye position (both in world coordinates), + and 2) the cube map orientation in world coordinates. The axis of + rotation is the cross product of these two vectors; the angle of + rotation is the arcsin of the dot product of these two vectors. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/texture_cube_map.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.EXT.texture_cube_map import * +from OpenGL.raw.GL.EXT.texture_cube_map import _EXTENSION_NAME + +def glInitTextureCubeMapEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/texture_env_add.py b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/texture_env_add.py new file mode 100644 index 00000000..b9e677ef --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/texture_env_add.py @@ -0,0 +1,32 @@ +'''OpenGL extension EXT.texture_env_add + +This module customises the behaviour of the +OpenGL.raw.GL.EXT.texture_env_add to provide a more +Python-friendly API + +Overview (from the spec) + + New texture environment function ADD is supported with the following + equation: + Cv = min(1, Cf + Ct) + + New function may be specified by calling TexEnv with ADD token. + + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/texture_env_add.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.EXT.texture_env_add import * +from OpenGL.raw.GL.EXT.texture_env_add import _EXTENSION_NAME + +def glInitTextureEnvAddEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/texture_env_combine.py b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/texture_env_combine.py new file mode 100644 index 00000000..327f497b --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/texture_env_combine.py @@ -0,0 +1,46 @@ +'''OpenGL extension EXT.texture_env_combine + +This module customises the behaviour of the +OpenGL.raw.GL.EXT.texture_env_combine to provide a more +Python-friendly API + +Overview (from the spec) + + New texture environment function COMBINE_EXT allows programmable + texture combiner operations, including: + + REPLACE Arg0 + MODULATE Arg0 * Arg1 + ADD Arg0 + Arg1 + ADD_SIGNED_EXT Arg0 + Arg1 - 0.5 + INTERPOLATE_EXT Arg0 * (Arg2) + Arg1 * (1-Arg2) + + where Arg0, Arg1 and Arg2 are derived from + + PRIMARY_COLOR_EXT primary color of incoming fragment + TEXTURE texture color of corresponding texture unit + CONSTANT_EXT texture environment constant color + PREVIOUS_EXT result of previous texture environment; on + texture unit 0, this maps to PRIMARY_COLOR_EXT + + and Arg2 is restricted to the alpha component of the corresponding source. + + In addition, the result may be scaled by 1.0, 2.0 or 4.0. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/texture_env_combine.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.EXT.texture_env_combine import * +from OpenGL.raw.GL.EXT.texture_env_combine import _EXTENSION_NAME + +def glInitTextureEnvCombineEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/texture_env_dot3.py b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/texture_env_dot3.py new file mode 100644 index 00000000..d865dfb1 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/texture_env_dot3.py @@ -0,0 +1,41 @@ +'''OpenGL extension EXT.texture_env_dot3 + +This module customises the behaviour of the +OpenGL.raw.GL.EXT.texture_env_dot3 to provide a more +Python-friendly API + +Overview (from the spec) + + Adds new operation to the texture combiner operations. + + DOT3_RGB_EXT Arg0 Arg1 + DOT3_RGBA_EXT Arg0 Arg1 + + where Arg0, Arg1 are derived from + + PRIMARY_COLOR_EXT primary color of incoming fragment + TEXTURE texture color of corresponding texture unit + CONSTANT_EXT texture environment constant color + PREVIOUS_EXT result of previous texture environment; on + texture unit 0, this maps to PRIMARY_COLOR_EXT + + This operaion can only be performed if SOURCE0_RGB_EXT, + SOURCE1_RGB_EXT are defined. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/texture_env_dot3.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.EXT.texture_env_dot3 import * +from OpenGL.raw.GL.EXT.texture_env_dot3 import _EXTENSION_NAME + +def glInitTextureEnvDot3EXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/texture_filter_anisotropic.py b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/texture_filter_anisotropic.py new file mode 100644 index 00000000..212ba6c9 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/texture_filter_anisotropic.py @@ -0,0 +1,64 @@ +'''OpenGL extension EXT.texture_filter_anisotropic + +This module customises the behaviour of the +OpenGL.raw.GL.EXT.texture_filter_anisotropic to provide a more +Python-friendly API + +Overview (from the spec) + + Texture mapping using OpenGL's existing mipmap texture filtering + modes assumes that the projection of the pixel filter footprint into + texture space is a square (ie, isotropic). In practice however, the + footprint may be long and narrow (ie, anisotropic). Consequently, + mipmap filtering severely blurs images on surfaces angled obliquely + away from the viewer. + + Several approaches exist for improving texture sampling by accounting + for the anisotropic nature of the pixel filter footprint into texture + space. This extension provides a general mechanism for supporting + anisotropic texturing filtering schemes without specifying a + particular formulation of anisotropic filtering. + + The extension permits the OpenGL application to specify on + a per-texture object basis the maximum degree of anisotropy to + account for in texture filtering. + + Increasing a texture object's maximum degree of anisotropy may + improve texture filtering but may also significantly reduce the + implementation's texture filtering rate. Implementations are free + to clamp the specified degree of anisotropy to the implementation's + maximum supported degree of anisotropy. + + A texture's maximum degree of anisotropy is specified independent + from the texture's minification and magnification filter (as + opposed to being supported as an entirely new filtering mode). + Implementations are free to use the specified minification and + magnification filter to select a particular anisotropic texture + filtering scheme. For example, a NEAREST filter with a maximum + degree of anisotropy of two could be treated as a 2-tap filter that + accounts for the direction of anisotropy. Implementations are also + permitted to ignore the minification or magnification filter and + implement the highest quality of anisotropic filtering possible. + + Applications seeking the highest quality anisotropic filtering + available are advised to request a LINEAR_MIPMAP_LINEAR minification + filter, a LINEAR magnification filter, and a large maximum degree + of anisotropy. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/texture_filter_anisotropic.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.EXT.texture_filter_anisotropic import * +from OpenGL.raw.GL.EXT.texture_filter_anisotropic import _EXTENSION_NAME + +def glInitTextureFilterAnisotropicEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/texture_filter_minmax.py b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/texture_filter_minmax.py new file mode 100644 index 00000000..35cd2d1a --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/texture_filter_minmax.py @@ -0,0 +1,39 @@ +'''OpenGL extension EXT.texture_filter_minmax + +This module customises the behaviour of the +OpenGL.raw.GL.EXT.texture_filter_minmax to provide a more +Python-friendly API + +Overview (from the spec) + + In unextended OpenGL 4.3, minification and magnification filters such as + LINEAR allow texture lookups to returned a filtered texel value produced + by computing an weighted average of a collection of texels in the + neighborhood of the texture coordinate provided. + + This extension provides a new texture and sampler parameter + (TEXTURE_REDUCTION_MODE_EXT) which allows applications to produce a + filtered texel value by computing a component-wise minimum (MIN) or + maximum (MAX) of the texels that would normally be averaged. The + reduction mode is orthogonal to the minification and magnification filter + parameters. The filter parameters are used to identify the set of texels + used to produce a final filtered value; the reduction mode identifies how + these texels are combined. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/texture_filter_minmax.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.EXT.texture_filter_minmax import * +from OpenGL.raw.GL.EXT.texture_filter_minmax import _EXTENSION_NAME + +def glInitTextureFilterMinmaxEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/texture_integer.py b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/texture_integer.py new file mode 100644 index 00000000..0fc5ff09 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/texture_integer.py @@ -0,0 +1,87 @@ +'''OpenGL extension EXT.texture_integer + +This module customises the behaviour of the +OpenGL.raw.GL.EXT.texture_integer to provide a more +Python-friendly API + +Overview (from the spec) + + Fixed-point textures in unextended OpenGL have integer components, + but those values are taken to represent floating-point values in + the range [0,1]. These integer components are considered + "normalized" integers. When such a texture is accessed by a + shader or by fixed-function fragment processing, floating-point + values are returned. + + This extension provides a set of new "unnormalized" integer texture + formats. Formats with both signed and unsigned integers are provided. In + these formats, the components are treated as true integers. When such + textures are accessed by a shader, actual integer values are returned. + + Pixel operations that read from or write to a texture or color + buffer with unnormalized integer components follow a path similar + to that used for color index pixel operations, except that more + than one component may be provided at once. Integer values flow + through the pixel processing pipe, and no pixel transfer + operations are performed. Integer format enumerants used for such + operations indicate unnormalized integer data. + + Textures or render buffers with unnormalized integer formats may also be + attached to framebuffer objects to receive fragment color values written + by a fragment shader. Per-fragment operations that require floating-point + color components, including multisample alpha operations, alpha test, + blending, and dithering, have no effect when the corresponding colors are + written to an integer color buffer. The NV_gpu_program4 and + EXT_gpu_shader4 extensions add the capability to fragment programs and + fragment shaders to write signed and unsigned integer output values. + + This extension does not enforce type consistency for texture accesses or + between fragment shaders and the corresponding framebuffer attachments. + The results of a texture lookup from an integer texture are undefined: + + * for fixed-function fragment processing, or + + * for shader texture accesses expecting floating-point return values. + + The color components used for per-fragment operations and written into a + color buffer are undefined: + + * for fixed-function fragment processing with an integer color buffer, + + * for fragment shaders that write floating-point color components to an + integer color buffer, or + + * for fragment shaders that write integer color components to a color + buffer with floating point or normalized integer components. + + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/texture_integer.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.EXT.texture_integer import * +from OpenGL.raw.GL.EXT.texture_integer import _EXTENSION_NAME + +def glInitTextureIntegerEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glTexParameterIivEXT.params size not checked against 'pname' +glTexParameterIivEXT=wrapper.wrapper(glTexParameterIivEXT).setInputArraySize( + 'params', None +) +# INPUT glTexParameterIuivEXT.params size not checked against 'pname' +glTexParameterIuivEXT=wrapper.wrapper(glTexParameterIuivEXT).setInputArraySize( + 'params', None +) +glGetTexParameterIivEXT=wrapper.wrapper(glGetTexParameterIivEXT).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetTexParameterIuivEXT=wrapper.wrapper(glGetTexParameterIuivEXT).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/texture_lod_bias.py b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/texture_lod_bias.py new file mode 100644 index 00000000..84400acf --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/texture_lod_bias.py @@ -0,0 +1,41 @@ +'''OpenGL extension EXT.texture_lod_bias + +This module customises the behaviour of the +OpenGL.raw.GL.EXT.texture_lod_bias to provide a more +Python-friendly API + +Overview (from the spec) + + OpenGL computes a texture level-of-detail parameter, called lambda + in the GL specification, that determines which mipmap levels and + their relative mipmap weights for use in mipmapped texture filtering. + + This extension provides a means to bias the lambda computation + by a constant (signed) value. This bias can provide a way to blur + or pseudo-sharpen OpenGL's standard texture filtering. + + This blurring or pseudo-sharpening may be useful for special effects + (such as depth-of-field effects) or image processing techniques + (where the mipmap levels act as pre-downsampled image versions). + On some implementations, increasing the texture lod bias may improve + texture filtering performance (at the cost of texture bluriness). + + The extension mimics functionality found in Direct3D. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/texture_lod_bias.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.EXT.texture_lod_bias import * +from OpenGL.raw.GL.EXT.texture_lod_bias import _EXTENSION_NAME + +def glInitTextureLodBiasEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/texture_mirror_clamp.py b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/texture_mirror_clamp.py new file mode 100644 index 00000000..fb43f0f7 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/texture_mirror_clamp.py @@ -0,0 +1,36 @@ +'''OpenGL extension EXT.texture_mirror_clamp + +This module customises the behaviour of the +OpenGL.raw.GL.EXT.texture_mirror_clamp to provide a more +Python-friendly API + +Overview (from the spec) + + EXT_texture_mirror_clamp extends the set of texture wrap modes to + include three modes (GL_MIRROR_CLAMP_EXT, GL_MIRROR_CLAMP_TO_EDGE_EXT, + GL_MIRROR_CLAMP_TO_BORDER_EXT) that effectively use a texture map + twice as large as the original image in which the additional half + of the new image is a mirror image of the original image. + + This new mode relaxes the need to generate images whose opposite + edges match by using the original image to generate a matching + "mirror image". This mode allows the texture to be mirrored only + once in the negative s, t, and r directions. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/texture_mirror_clamp.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.EXT.texture_mirror_clamp import * +from OpenGL.raw.GL.EXT.texture_mirror_clamp import _EXTENSION_NAME + +def glInitTextureMirrorClampEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/texture_object.py b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/texture_object.py new file mode 100644 index 00000000..8d7abf25 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/texture_object.py @@ -0,0 +1,49 @@ +'''OpenGL extension EXT.texture_object + +This module customises the behaviour of the +OpenGL.raw.GL.EXT.texture_object to provide a more +Python-friendly API + +Overview (from the spec) + + This extension introduces named texture objects. The only way to name + a texture in GL 1.0 is by defining it as a single display list. Because + display lists cannot be edited, these objects are static. Yet it is + important to be able to change the images and parameters of a texture. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/texture_object.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.EXT.texture_object import * +from OpenGL.raw.GL.EXT.texture_object import _EXTENSION_NAME + +def glInitTextureObjectEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glAreTexturesResidentEXT.textures size not checked against n +glAreTexturesResidentEXT=wrapper.wrapper(glAreTexturesResidentEXT).setOutput( + 'residences',size=lambda x:(x,),pnameArg='n',orPassIn=True +).setInputArraySize( + 'textures', None +) +# INPUT glDeleteTexturesEXT.textures size not checked against n +glDeleteTexturesEXT=wrapper.wrapper(glDeleteTexturesEXT).setInputArraySize( + 'textures', None +) +glGenTexturesEXT=wrapper.wrapper(glGenTexturesEXT).setOutput( + 'textures',size=lambda x:(x,),pnameArg='n',orPassIn=True +) +# INPUT glPrioritizeTexturesEXT.priorities size not checked against n +# INPUT glPrioritizeTexturesEXT.textures size not checked against n +glPrioritizeTexturesEXT=wrapper.wrapper(glPrioritizeTexturesEXT).setInputArraySize( + 'priorities', None +).setInputArraySize( + 'textures', None +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/texture_perturb_normal.py b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/texture_perturb_normal.py new file mode 100644 index 00000000..007d4033 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/texture_perturb_normal.py @@ -0,0 +1,30 @@ +'''OpenGL extension EXT.texture_perturb_normal + +This module customises the behaviour of the +OpenGL.raw.GL.EXT.texture_perturb_normal to provide a more +Python-friendly API + +Overview (from the spec) + + This extension defines a mechanism for using texture values to perturb + the fragment normal vector prior to fragment lighting. It enables a + direct implementation of the original formulation of bump mapping by + Blinn. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/texture_perturb_normal.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.EXT.texture_perturb_normal import * +from OpenGL.raw.GL.EXT.texture_perturb_normal import _EXTENSION_NAME + +def glInitTexturePerturbNormalEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/texture_sRGB.py b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/texture_sRGB.py new file mode 100644 index 00000000..8be3a0cc --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/texture_sRGB.py @@ -0,0 +1,39 @@ +'''OpenGL extension EXT.texture_sRGB + +This module customises the behaviour of the +OpenGL.raw.GL.EXT.texture_sRGB to provide a more +Python-friendly API + +Overview (from the spec) + + Conventional texture formats assume a linear color space. So for + a conventional internal texture format such as GL_RGB8, the 256 + discrete values for each 8-bit color component map linearly and + uniformly to the [0,1] range. + + The sRGB color space is based on typical (non-linear) monitor + characteristics expected in a dimly lit office. It has been + standardized by the International Electrotechnical Commission (IEC) + as IEC 61966-2-1. The sRGB color space roughly corresponds to 2.2 + gamma correction. + + This extension adds a few new uncompressed and compressed color + texture formats with sRGB color components. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/texture_sRGB.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.EXT.texture_sRGB import * +from OpenGL.raw.GL.EXT.texture_sRGB import _EXTENSION_NAME + +def glInitTextureSrgbEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/texture_sRGB_R8.py b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/texture_sRGB_R8.py new file mode 100644 index 00000000..567a15dd --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/texture_sRGB_R8.py @@ -0,0 +1,29 @@ +'''OpenGL extension EXT.texture_sRGB_R8 + +This module customises the behaviour of the +OpenGL.raw.GL.EXT.texture_sRGB_R8 to provide a more +Python-friendly API + +Overview (from the spec) + + This extension introduces SR8_EXT as an acceptable internal format. + This allows efficient sRGB sampling for source images stored as a separate + texture per channel. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/texture_sRGB_R8.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.EXT.texture_sRGB_R8 import * +from OpenGL.raw.GL.EXT.texture_sRGB_R8 import _EXTENSION_NAME + +def glInitTextureSrgbR8EXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/texture_sRGB_decode.py b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/texture_sRGB_decode.py new file mode 100644 index 00000000..eeabdafe --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/texture_sRGB_decode.py @@ -0,0 +1,41 @@ +'''OpenGL extension EXT.texture_sRGB_decode + +This module customises the behaviour of the +OpenGL.raw.GL.EXT.texture_sRGB_decode to provide a more +Python-friendly API + +Overview (from the spec) + + The EXT_texture_sRGB extension (promoted to core in OpenGL 2.1) + provides a texture format stored in the sRGB color space. Sampling one + of these textures will always return the color value decoded into a + linear color space. However, an application may wish to sample and + retrieve the undecoded sRGB data from the texture and manipulate + that directly. + + This extension adds a Texture Parameter and Sampler Object parameter to + allow sRGB textures to be read directly, without decoding. + + The new parameter, TEXTURE_SRGB_DECODE_EXT controls whether the + decoding happens at sample time. It only applies to textures with an + internal format that is sRGB and is ignored for all other textures. + This value defaults to DECODE_EXT, which indicates the texture + should be decoded to linear color space. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/texture_sRGB_decode.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.EXT.texture_sRGB_decode import * +from OpenGL.raw.GL.EXT.texture_sRGB_decode import _EXTENSION_NAME + +def glInitTextureSrgbDecodeEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/texture_shadow_lod.py b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/texture_shadow_lod.py new file mode 100644 index 00000000..e1012586 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/texture_shadow_lod.py @@ -0,0 +1,35 @@ +'''OpenGL extension EXT.texture_shadow_lod + +This module customises the behaviour of the +OpenGL.raw.GL.EXT.texture_shadow_lod to provide a more +Python-friendly API + +Overview (from the spec) + + This extension adds support for various shadow sampler types with texture + functions having interactions with the LOD of texture lookups. Modern + shading languages support LOD queries for shadow sampler types, but until + now the OpenGL Shading Language Specification has excluded multiple texture + function overloads involving LOD calculations with various shadow samplers. + Shading languages for other APIs do support the equivalent LOD-based + texture sampling functions for these types which has made porting between + those shading languages to GLSL cumbersome and has required the usage of + sub-optimal workarounds. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/texture_shadow_lod.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.EXT.texture_shadow_lod import * +from OpenGL.raw.GL.EXT.texture_shadow_lod import _EXTENSION_NAME + +def glInitTextureShadowLodEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/texture_shared_exponent.py b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/texture_shared_exponent.py new file mode 100644 index 00000000..e6ee285a --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/texture_shared_exponent.py @@ -0,0 +1,45 @@ +'''OpenGL extension EXT.texture_shared_exponent + +This module customises the behaviour of the +OpenGL.raw.GL.EXT.texture_shared_exponent to provide a more +Python-friendly API + +Overview (from the spec) + + Existing texture formats provide either fixed-point formats with + limited range and precision but with compact encodings (allowing 32 + or fewer bits per multi-component texel), or floating-point formats + with tremendous range and precision but without compact encodings + (typically 16 or 32 bits per component). + + This extension adds a new packed format and new internal texture + format for encoding 3-component vectors (typically RGB colors) with + a single 5-bit exponent (biased up by 15) and three 9-bit mantissas + for each respective component. There is no sign bit so all three + components must be non-negative. The fractional mantissas are + stored without an implied 1 to the left of the decimal point. + Neither infinity nor not-a-number (NaN) are representable in this + shared exponent format. + + This 32 bits/texel shared exponent format is particularly well-suited + to high dynamic range (HDR) applications where light intensity is + typically stored as non-negative red, green, and blue components + with considerable range. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/texture_shared_exponent.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.EXT.texture_shared_exponent import * +from OpenGL.raw.GL.EXT.texture_shared_exponent import _EXTENSION_NAME + +def glInitTextureSharedExponentEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/texture_snorm.py b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/texture_snorm.py new file mode 100644 index 00000000..f424b40c --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/texture_snorm.py @@ -0,0 +1,36 @@ +'''OpenGL extension EXT.texture_snorm + +This module customises the behaviour of the +OpenGL.raw.GL.EXT.texture_snorm to provide a more +Python-friendly API + +Overview (from the spec) + + Fixed-point textures in unextended OpenGL have integer components, + but those values are taken to represent floating-point values in + the range [0.0,1.0]. These integer components are considered + "unsigned normalized" integers. When such a texture is accessed by + a shader or by fixed-function fragment processing, floating-point + values are returned in the range [0.0,1.0]. + + This extension provides a set of new "signed normalized" integer + texture formats. These are taken to represent a floating-point + value in the range [-1.0,1.0] with an exact 0.0. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/texture_snorm.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.EXT.texture_snorm import * +from OpenGL.raw.GL.EXT.texture_snorm import _EXTENSION_NAME + +def glInitTextureSnormEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/texture_swizzle.py b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/texture_swizzle.py new file mode 100644 index 00000000..a3b0c817 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/texture_swizzle.py @@ -0,0 +1,46 @@ +'''OpenGL extension EXT.texture_swizzle + +This module customises the behaviour of the +OpenGL.raw.GL.EXT.texture_swizzle to provide a more +Python-friendly API + +Overview (from the spec) + + Classic OpenGL texture formats conflate texture storage and + interpretation, and assume that textures represent color. In + modern applications, a significant quantity of textures don't + represent color, but rather data like shadow maps, normal maps, + page tables, occlusion data, etc.. For the latter class of data, + calling the data "RGBA" is just a convenient mapping of what the + data is onto the current model, but isn't an accurate reflection + of the reality of the data. + + The existing texture formats provide an almost orthogonal set of + data types, sizes, and number of components, but the mappings of + this storage into what the shader or fixed-function pipeline + fetches is very much non-orthogonal. Previous extensions have + added some of the most demanded missing formats, but the problem + has not been solved once and for all. + + This extension provides a mechanism to swizzle the components + of a texture before they are applied according to the texture + environment in fixed-function or as they are returned to the + shader. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/texture_swizzle.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.EXT.texture_swizzle import * +from OpenGL.raw.GL.EXT.texture_swizzle import _EXTENSION_NAME + +def glInitTextureSwizzleEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/timer_query.py b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/timer_query.py new file mode 100644 index 00000000..65d9a554 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/timer_query.py @@ -0,0 +1,51 @@ +'''OpenGL extension EXT.timer_query + +This module customises the behaviour of the +OpenGL.raw.GL.EXT.timer_query to provide a more +Python-friendly API + +Overview (from the spec) + + Applications can benefit from accurate timing information in a number of + different ways. During application development, timing information can + help identify application or driver bottlenecks. At run time, + applications can use timing information to dynamically adjust the amount + of detail in a scene to achieve constant frame rates. OpenGL + implementations have historically provided little to no useful timing + information. Applications can get some idea of timing by reading timers + on the CPU, but these timers are not synchronized with the graphics + rendering pipeline. Reading a CPU timer does not guarantee the completion + of a potentially large amount of graphics work accumulated before the + timer is read, and will thus produce wildly inaccurate results. + glFinish() can be used to determine when previous rendering commands have + been completed, but will idle the graphics pipeline and adversely affect + application performance. + + This extension provides a query mechanism that can be used to determine + the amount of time it takes to fully complete a set of GL commands, and + without stalling the rendering pipeline. It uses the query object + mechanisms first introduced in the occlusion query extension, which allow + time intervals to be polled asynchronously by the application. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/timer_query.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.EXT.timer_query import * +from OpenGL.raw.GL.EXT.timer_query import _EXTENSION_NAME + +def glInitTimerQueryEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +glGetQueryObjecti64vEXT=wrapper.wrapper(glGetQueryObjecti64vEXT).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetQueryObjectui64vEXT=wrapper.wrapper(glGetQueryObjectui64vEXT).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/transform_feedback.py b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/transform_feedback.py new file mode 100644 index 00000000..5d317dc9 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/transform_feedback.py @@ -0,0 +1,67 @@ +'''OpenGL extension EXT.transform_feedback + +This module customises the behaviour of the +OpenGL.raw.GL.EXT.transform_feedback to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides a new mode to the GL, called transform feedback, + which records selected vertex attributes for each primitive processed by + the GL. The selected attributes are written into buffer objects, and can + be written with each attribute in a separate buffer object or with all + attributes interleaved into a single buffer object. If a geometry shader + is active, the primitives recorded are those emitted by the geometry + shader. Otherwise, transform feedback captures primitives whose vertices + are transformed by a vertex shader. In either case, the primitives + captured are those generated prior to clipping. Transform feedback mode + captures the values of specified varying variables emitted from GLSL + vertex or geometry shaders. + + The vertex data recorded in transform feedback mode is stored into buffer + objects as an array of vertex attributes. The regular representation and + the use of buffer objects allows the recorded data to be processed + directly by the GL without requiring CPU intervention to copy data. In + particular, transform feedback data can be used for vertex arrays (via + vertex buffer objects), as the source for pixel data (via pixel buffer + objects), as shader constant data (via the NV_parameter_buffer_object or + EXT_bindable_uniform extensions), or via any other extension that makes + use of buffer objects. + + This extension introduces new query object support to allow transform + feedback mode to operate asynchronously. Query objects allow applications + to determine when transform feedback results are complete, as well as the + number of primitives processed and written back to buffer objects while in + transform feedback mode. This extension also provides a new rasterizer + discard enable, which allows applications to use transform feedback to + capture vertex attributes without rendering anything. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/transform_feedback.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.EXT.transform_feedback import * +from OpenGL.raw.GL.EXT.transform_feedback import _EXTENSION_NAME + +def glInitTransformFeedbackEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glTransformFeedbackVaryingsEXT.varyings size not checked against count +glTransformFeedbackVaryingsEXT=wrapper.wrapper(glTransformFeedbackVaryingsEXT).setInputArraySize( + 'varyings', None +) +glGetTransformFeedbackVaryingEXT=wrapper.wrapper(glGetTransformFeedbackVaryingEXT).setOutput( + 'length',size=(1,),orPassIn=True +).setOutput( + 'name',size=lambda x:(x,),pnameArg='bufSize',orPassIn=True +).setOutput( + 'size',size=(1,),orPassIn=True +).setOutput( + 'type',size=(1,),orPassIn=True +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/vertex_array.py b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/vertex_array.py new file mode 100644 index 00000000..a95b2a73 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/vertex_array.py @@ -0,0 +1,64 @@ +'''OpenGL extension EXT.vertex_array + +This module customises the behaviour of the +OpenGL.raw.GL.EXT.vertex_array to provide a more +Python-friendly API + +Overview (from the spec) + + This extension adds the ability to specify multiple geometric primitives + with very few subroutine calls. Instead of calling an OpenGL procedure + to pass each individual vertex, normal, or color, separate arrays + of vertexes, normals, and colors are prespecified, and are used to + define a sequence of primitives (all of the same type) when a single + call is made to DrawArraysEXT. A stride mechanism is provided so that + an application can choose to keep all vertex data staggered in a + single array, or sparsely in separate arrays. Single-array storage + may optimize performance on some implementations. + + This extension also supports the rendering of individual array elements, + each specified as an index into the enabled arrays. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/vertex_array.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.EXT.vertex_array import * +from OpenGL.raw.GL.EXT.vertex_array import _EXTENSION_NAME + +def glInitVertexArrayEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glColorPointerEXT.pointer size not checked against 'size,type,stride,count' +glColorPointerEXT=wrapper.wrapper(glColorPointerEXT).setInputArraySize( + 'pointer', None +) +# INPUT glEdgeFlagPointerEXT.pointer size not checked against 'stride,count' +glEdgeFlagPointerEXT=wrapper.wrapper(glEdgeFlagPointerEXT).setInputArraySize( + 'pointer', None +) +glGetPointervEXT=wrapper.wrapper(glGetPointervEXT).setOutput( + 'params',size=(1,),orPassIn=True +) +# INPUT glIndexPointerEXT.pointer size not checked against 'type,stride,count' +glIndexPointerEXT=wrapper.wrapper(glIndexPointerEXT).setInputArraySize( + 'pointer', None +) +# INPUT glNormalPointerEXT.pointer size not checked against 'type,stride,count' +glNormalPointerEXT=wrapper.wrapper(glNormalPointerEXT).setInputArraySize( + 'pointer', None +) +# INPUT glTexCoordPointerEXT.pointer size not checked against 'size,type,stride,count' +glTexCoordPointerEXT=wrapper.wrapper(glTexCoordPointerEXT).setInputArraySize( + 'pointer', None +) +# INPUT glVertexPointerEXT.pointer size not checked against 'size,type,stride,count' +glVertexPointerEXT=wrapper.wrapper(glVertexPointerEXT).setInputArraySize( + 'pointer', None +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/vertex_array_bgra.py b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/vertex_array_bgra.py new file mode 100644 index 00000000..a5d1e37d --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/vertex_array_bgra.py @@ -0,0 +1,80 @@ +'''OpenGL extension EXT.vertex_array_bgra + +This module customises the behaviour of the +OpenGL.raw.GL.EXT.vertex_array_bgra to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides a single new component format for vertex + arrays to read 4-component unsigned byte vertex attributes with a + BGRA component ordering. + + OpenGL expects vertex arrays containing 4 unsigned bytes per + element to be in the RGBA, STRQ, or XYZW order (reading components + left-to-right in their lower address to higher address order). + Essentially the order the components appear in memory is the order + the components appear in the resulting vertex attribute vector. + + However Direct3D has color (diffuse and specular) vertex arrays + containing 4 unsigned bytes per element that are in a BGRA order + (again reading components left-to-right in their lower address + to higher address order). Direct3D calls this "ARGB" reading the + components in the opposite order (reading components left-to-right + in their higher address to lower address order). This ordering is + generalized in the DirectX 10 by the DXGI_FORMAT_B8G8R8A8_UNORM + format. + + For an OpenGL application to source color data from a vertex + buffer formatted for Direct3D's color array format conventions, + the application is forced to either: + + 1. Rely on a vertex program or shader to swizzle the color components + from the BGRA to conventional RGBA order. + + 2. Re-order the color data components in the vertex buffer from + Direct3D's native BGRA order to OpenGL's native RGBA order. + + Neither option is entirely satisfactory. + + Option 1 means vertex shaders have to be re-written to source colors + differently. If the same vertex shader is used with vertex arrays + configured to source the color as 4 floating-point color components, + the swizzle for BGRA colors stored as 4 unsigned bytes is no longer + appropriate. The shader's swizzling of colors becomes dependent on + the type and number of color components. Ideally the vertex shader + should be independent from the format and component ordering of the + data it sources. + + Option 2 is expensive because vertex buffers may have to be + reformatted prior to use. OpenGL treats the memory for vertex arrays + (whether client-side memory or buffer objects) as essentially untyped + memory and vertex arrays can be stored separately, interleaved, + or even interwoven (where multiple arrays overlap with differing + strides and formats). + + Rather than force a re-ordering of either vertex array components + in memory or a vertex array format-dependent re-ordering of vertex + shader inputs, OpenGL can simply provide a vertex array format that + matches the Direct3D color component ordering. + + This approach mimics that of the EXT_bgra extension for pixel and + texel formats except for vertex instead of image data. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/vertex_array_bgra.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.EXT.vertex_array_bgra import * +from OpenGL.raw.GL.EXT.vertex_array_bgra import _EXTENSION_NAME + +def glInitVertexArrayBgraEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/vertex_attrib_64bit.py b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/vertex_attrib_64bit.py new file mode 100644 index 00000000..1ae4ebab --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/vertex_attrib_64bit.py @@ -0,0 +1,85 @@ +'''OpenGL extension EXT.vertex_attrib_64bit + +This module customises the behaviour of the +OpenGL.raw.GL.EXT.vertex_attrib_64bit to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides OpenGL shading language support for vertex shader + inputs with 64-bit floating-point components and OpenGL API support for + specifying the value of those inputs using vertex array or immediate mode + entry points. This builds on the support for general-purpose support for + 64-bit floating-point values in the ARB_gpu_shader_fp64 extension. + + This extension provides a new class of vertex attribute functions, + beginning with "VertexAttribL" ("L" for "long"), that can be used to + specify attributes with 64-bit floating-point components. This extension + provides no automatic type conversion between attribute and shader + variables; single-precision attributes are not automatically converted to + double-precision or vice versa. For shader variables with 64-bit + component types, the "VertexAttribL" functions must be used to specify + attribute values. For other shader variables, the "VertexAttribL" + functions must not be used. If a vertex attribute is specified using the + wrong attribute function, the values of the corresponding shader input are + undefined. This approach requiring matching types is identical to that + used for the "VertexAttribI" functions provided by OpenGL 3.0 and the + EXT_gpu_shader4 extension. + + Additionally, some vertex shader inputs using the wider 64-bit components + may count double against the implementation-dependent limit on the number + of vertex shader attribute vectors. A 64-bit scalar or a two-component + vector consumes only a single generic vertex attribute; three- and + four-component "long" may count as two. This approach is similar to the + one used in the current GL where matrix attributes consume multiple + attributes. + + Note that 64-bit generic vertex attributes were nominally supported + beginning with the introduction of vertex shaders in OpenGL 2.0. However, + the OpenGL Shading Language at the time had no support for 64-bit data + types, so any such values were automatically converted to 32-bit. + + Support for 64-bit floating-point vertex attributes in this extension can + be combined with other extensions. In particular, this extension provides + an entry point that can be used with EXT_direct_state_access to directly + set state for any vertex array object. Also, the related + NV_vertex_attrib_integer_64bit extension provides an entry point to + specify bindless vertex attribute arrays with 64-bit components, integer + or floating-point. + + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/vertex_attrib_64bit.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.EXT.vertex_attrib_64bit import * +from OpenGL.raw.GL.EXT.vertex_attrib_64bit import _EXTENSION_NAME + +def glInitVertexAttrib64BitEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +glVertexAttribL1dvEXT=wrapper.wrapper(glVertexAttribL1dvEXT).setInputArraySize( + 'v', 1 +) +glVertexAttribL2dvEXT=wrapper.wrapper(glVertexAttribL2dvEXT).setInputArraySize( + 'v', 2 +) +glVertexAttribL3dvEXT=wrapper.wrapper(glVertexAttribL3dvEXT).setInputArraySize( + 'v', 3 +) +glVertexAttribL4dvEXT=wrapper.wrapper(glVertexAttribL4dvEXT).setInputArraySize( + 'v', 4 +) +# INPUT glVertexAttribLPointerEXT.pointer size not checked against size +glVertexAttribLPointerEXT=wrapper.wrapper(glVertexAttribLPointerEXT).setInputArraySize( + 'pointer', None +) +glGetVertexAttribLdvEXT=wrapper.wrapper(glGetVertexAttribLdvEXT).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/vertex_shader.py b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/vertex_shader.py new file mode 100644 index 00000000..8e820c1d --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/vertex_shader.py @@ -0,0 +1,105 @@ +'''OpenGL extension EXT.vertex_shader + +This module customises the behaviour of the +OpenGL.raw.GL.EXT.vertex_shader to provide a more +Python-friendly API + +Overview (from the spec) + + EXT_vertex_shader adds a flexible way to change the per-vertex + processing in the GL pipeline. It provides a method to replace + the fixed vertex/normal transform and lighting with a user + specified means of generating processed vertices, texture + coordinates, color, and secondary color, along with a primitive's + associated state. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/vertex_shader.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.EXT.vertex_shader import * +from OpenGL.raw.GL.EXT.vertex_shader import _EXTENSION_NAME + +def glInitVertexShaderEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glSetInvariantEXT.addr size not checked against 'id,type' +glSetInvariantEXT=wrapper.wrapper(glSetInvariantEXT).setInputArraySize( + 'addr', None +) +# INPUT glSetLocalConstantEXT.addr size not checked against 'id,type' +glSetLocalConstantEXT=wrapper.wrapper(glSetLocalConstantEXT).setInputArraySize( + 'addr', None +) +# INPUT glVariantbvEXT.addr size not checked against 'id' +glVariantbvEXT=wrapper.wrapper(glVariantbvEXT).setInputArraySize( + 'addr', None +) +# INPUT glVariantsvEXT.addr size not checked against 'id' +glVariantsvEXT=wrapper.wrapper(glVariantsvEXT).setInputArraySize( + 'addr', None +) +# INPUT glVariantivEXT.addr size not checked against 'id' +glVariantivEXT=wrapper.wrapper(glVariantivEXT).setInputArraySize( + 'addr', None +) +# INPUT glVariantfvEXT.addr size not checked against 'id' +glVariantfvEXT=wrapper.wrapper(glVariantfvEXT).setInputArraySize( + 'addr', None +) +# INPUT glVariantdvEXT.addr size not checked against 'id' +glVariantdvEXT=wrapper.wrapper(glVariantdvEXT).setInputArraySize( + 'addr', None +) +# INPUT glVariantubvEXT.addr size not checked against 'id' +glVariantubvEXT=wrapper.wrapper(glVariantubvEXT).setInputArraySize( + 'addr', None +) +# INPUT glVariantusvEXT.addr size not checked against 'id' +glVariantusvEXT=wrapper.wrapper(glVariantusvEXT).setInputArraySize( + 'addr', None +) +# INPUT glVariantuivEXT.addr size not checked against 'id' +glVariantuivEXT=wrapper.wrapper(glVariantuivEXT).setInputArraySize( + 'addr', None +) +# INPUT glVariantPointerEXT.addr size not checked against 'id,type,stride' +glVariantPointerEXT=wrapper.wrapper(glVariantPointerEXT).setInputArraySize( + 'addr', None +) +glGetVariantBooleanvEXT=wrapper.wrapper(glGetVariantBooleanvEXT).setOutput( + 'data',size=_glgets._glget_size_mapping,pnameArg='id',orPassIn=True +) +glGetVariantIntegervEXT=wrapper.wrapper(glGetVariantIntegervEXT).setOutput( + 'data',size=_glgets._glget_size_mapping,pnameArg='id',orPassIn=True +) +glGetVariantFloatvEXT=wrapper.wrapper(glGetVariantFloatvEXT).setOutput( + 'data',size=_glgets._glget_size_mapping,pnameArg='id',orPassIn=True +) +glGetVariantPointervEXT=wrapper.wrapper(glGetVariantPointervEXT).setOutput( + 'data',size=_glgets._glget_size_mapping,pnameArg='id',orPassIn=True +) +glGetInvariantBooleanvEXT=wrapper.wrapper(glGetInvariantBooleanvEXT).setOutput( + 'data',size=_glgets._glget_size_mapping,pnameArg='id',orPassIn=True +) +glGetInvariantIntegervEXT=wrapper.wrapper(glGetInvariantIntegervEXT).setOutput( + 'data',size=_glgets._glget_size_mapping,pnameArg='id',orPassIn=True +) +glGetInvariantFloatvEXT=wrapper.wrapper(glGetInvariantFloatvEXT).setOutput( + 'data',size=_glgets._glget_size_mapping,pnameArg='id',orPassIn=True +) +glGetLocalConstantBooleanvEXT=wrapper.wrapper(glGetLocalConstantBooleanvEXT).setOutput( + 'data',size=_glgets._glget_size_mapping,pnameArg='id',orPassIn=True +) +glGetLocalConstantIntegervEXT=wrapper.wrapper(glGetLocalConstantIntegervEXT).setOutput( + 'data',size=_glgets._glget_size_mapping,pnameArg='id',orPassIn=True +) +glGetLocalConstantFloatvEXT=wrapper.wrapper(glGetLocalConstantFloatvEXT).setOutput( + 'data',size=_glgets._glget_size_mapping,pnameArg='id',orPassIn=True +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/vertex_weighting.py b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/vertex_weighting.py new file mode 100644 index 00000000..0cf46a5a --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/vertex_weighting.py @@ -0,0 +1,48 @@ +'''OpenGL extension EXT.vertex_weighting + +This module customises the behaviour of the +OpenGL.raw.GL.EXT.vertex_weighting to provide a more +Python-friendly API + +Overview (from the spec) + + The intent of this extension is to provide a means for blending + geometry based on two slightly differing modelview matrices. + The blending is based on a vertex weighting that can change on a + per-vertex basis. This provides a primitive form of skinning. + + A second modelview matrix transform is introduced. When vertex + weighting is enabled, the incoming vertex object coordinates are + transformed by both the primary and secondary modelview matrices; + likewise, the incoming normal coordinates are transformed by the + inverses of both the primary and secondary modelview matrices. + The resulting two position coordinates and two normal coordinates + are blended based on the per-vertex vertex weight and then combined + by addition. The transformed, weighted, and combined vertex position + and normal are then used by OpenGL as the eye-space position and + normal for lighting, texture coordinate, generation, clipping, + and further vertex transformation. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/vertex_weighting.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.EXT.vertex_weighting import * +from OpenGL.raw.GL.EXT.vertex_weighting import _EXTENSION_NAME + +def glInitVertexWeightingEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +glVertexWeightfvEXT=wrapper.wrapper(glVertexWeightfvEXT).setInputArraySize( + 'weight', 1 +) +# INPUT glVertexWeightPointerEXT.pointer size not checked against 'type,stride' +glVertexWeightPointerEXT=wrapper.wrapper(glVertexWeightPointerEXT).setInputArraySize( + 'pointer', None +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/win32_keyed_mutex.py b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/win32_keyed_mutex.py new file mode 100644 index 00000000..fdaa518f --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/win32_keyed_mutex.py @@ -0,0 +1,31 @@ +'''OpenGL extension EXT.win32_keyed_mutex + +This module customises the behaviour of the +OpenGL.raw.GL.EXT.win32_keyed_mutex to provide a more +Python-friendly API + +Overview (from the spec) + + Direct3D image objects may have a built-in synchronization primitive + associated with them that can be used to synchronize access to their + contents across process and API boundaries. This extension provides + access to that synchronization primitive via two new commands that + operate on GL memory objects. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/win32_keyed_mutex.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.EXT.win32_keyed_mutex import * +from OpenGL.raw.GL.EXT.win32_keyed_mutex import _EXTENSION_NAME + +def glInitWin32KeyedMutexEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/window_rectangles.py b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/window_rectangles.py new file mode 100644 index 00000000..651a2298 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/window_rectangles.py @@ -0,0 +1,52 @@ +'''OpenGL extension EXT.window_rectangles + +This module customises the behaviour of the +OpenGL.raw.GL.EXT.window_rectangles to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides additional orthogonally aligned "window + rectangles" specified in window-space coordinates that restrict + rasterization of all primitive types (geometry, images, paths) + and framebuffer clears. + + When rendering to the framebuffer of an on-screen window, these + window rectangles are ignored so these window rectangles apply to + rendering to non-zero framebuffer objects only. + + From zero to an implementation-dependent limit (specified by + GL_MAX_WINDOW_RECTANGLES_EXT) number of window rectangles can be + operational at once. When one or more window rectangles are active, + rasterized fragments can either survive if the fragment is within + any of the operational window rectangles (GL_INCLUSIVE_EXT mode) or + be rejected if the fragment is within any of the operational window + rectangles (GL_EXCLUSIVE_EXT mode). + + These window rectangles operate orthogonally to the existing scissor + test functionality. + + This extension has specification language for both OpenGL and ES so + EXT_window_rectangles can be implemented and advertised for either + or both API contexts. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/window_rectangles.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.EXT.window_rectangles import * +from OpenGL.raw.GL.EXT.window_rectangles import _EXTENSION_NAME + +def glInitWindowRectanglesEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glWindowRectanglesEXT.box size not checked against 'count' +glWindowRectanglesEXT=wrapper.wrapper(glWindowRectanglesEXT).setInputArraySize( + 'box', None +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/x11_sync_object.py b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/x11_sync_object.py new file mode 100644 index 00000000..6626bf9c --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/EXT/x11_sync_object.py @@ -0,0 +1,46 @@ +'''OpenGL extension EXT.x11_sync_object + +This module customises the behaviour of the +OpenGL.raw.GL.EXT.x11_sync_object to provide a more +Python-friendly API + +Overview (from the spec) + + Synchronization objects added the ability to better coordinate + operations between multiple GL command streams. However, it is + desirable to have the same level of coordination between GL + command streams and external rendering APIs. This extension + introduces two new concepts to build upon the synchronization + infrastructure provided by ARB_sync: + + 1) A means to import an X Synchronization Fence object into the + GL and use it as a sync object. + + 2) The concept of a reusable sync object. + + The latter is necessary because the import operation is expensive + and performing it every time a synchronization point was reached + would make the synchronization prohibitively slow. + + This extension stops short of allowing the GL to change the state + of imported/reusable sync objects, but does not add any language + that would prohibit such functionality from being added in a + subsequent extension. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/x11_sync_object.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.EXT.x11_sync_object import * +from OpenGL.raw.GL.EXT.x11_sync_object import _EXTENSION_NAME + +def glInitX11SyncObjectEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/FJ/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/GL/FJ/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/FJ/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/FJ/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/FJ/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..e6a9be2c Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/FJ/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/GREMEDY/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/GL/GREMEDY/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/GREMEDY/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/GREMEDY/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/GREMEDY/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..d31c1206 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/GREMEDY/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/GREMEDY/__pycache__/frame_terminator.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/GREMEDY/__pycache__/frame_terminator.cpython-312.pyc new file mode 100644 index 00000000..b111b559 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/GREMEDY/__pycache__/frame_terminator.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/GREMEDY/__pycache__/string_marker.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/GREMEDY/__pycache__/string_marker.cpython-312.pyc new file mode 100644 index 00000000..4ee108b5 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/GREMEDY/__pycache__/string_marker.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/GREMEDY/frame_terminator.py b/venv/lib/python3.12/site-packages/OpenGL/GL/GREMEDY/frame_terminator.py new file mode 100644 index 00000000..2634d80f --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/GREMEDY/frame_terminator.py @@ -0,0 +1,47 @@ +'''OpenGL extension GREMEDY.frame_terminator + +This module customises the behaviour of the +OpenGL.raw.GL.GREMEDY.frame_terminator to provide a more +Python-friendly API + +Overview (from the spec) + + This extension defines a mechanism that enables marking the end + of render frames within the OpenGL stream. + + When debugging or profiling an OpenGL application, the debuggers + and profilers needs to know when a render frame is ended. This + is important for frame per second measurements, statistical analysis, + marking and clearing stream loggers logs, performance counters + sampling and more. + + When an application uses off screen buffers, the debugger / profiler + cannot be guaranteed that the application will call a certain function at + the end of each off-screen frame (e.g: SwapBuffers / glClear / etc). + This extension enables the application to notify the debugger / profiler + whenever a render frame is ended. + + This extension is mainly useful for debuggers and profilers. It is not + expected that standard drivers would implement this extension. The main + point of having this extension is to allow applications to have a clean + way of accessing this functionality only when they are run under the + control of a debugger / profiler, without having to recompile or change + the application source code. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/GREMEDY/frame_terminator.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.GREMEDY.frame_terminator import * +from OpenGL.raw.GL.GREMEDY.frame_terminator import _EXTENSION_NAME + +def glInitFrameTerminatorGREMEDY(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/GREMEDY/string_marker.py b/venv/lib/python3.12/site-packages/OpenGL/GL/GREMEDY/string_marker.py new file mode 100644 index 00000000..119c931c --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/GREMEDY/string_marker.py @@ -0,0 +1,54 @@ +'''OpenGL extension GREMEDY.string_marker + +This module customises the behaviour of the +OpenGL.raw.GL.GREMEDY.string_marker to provide a more +Python-friendly API + +Overview (from the spec) + + This extension defines a mechanism to insert textual markers into + the OpenGL stream. + + When debugging or profiling an OpenGL application some of the most + important tools are stream loggers, which just output a list of the + called OpenGL commands, and profilers, which show at which points + the pipeline is bottlenecked for a given part of the frame. The + problem in using these is that there is a definite loss of + information between the application and the used debugger/profiler. + The application generally has a pretty good idea what is rendered + when (e.g. rendering background, landscape, building, players, + particle effects, bullets etc.), but the debugger/profiler only + sees the OpenGL stream. To analyze the stream developers have to + guess what is done when by following the program code and the log + output in parallel, which can get difficult for systems that + restructure their internal pipeline or do lazy changes. + + This extension is really only useful for these debuggers and + profilers, and not for actual drivers. In fact, it is not expected + that any standard driver would ever implement this extension. The + main point of having this extension is to allow applications to have a + clean way of accessing this functionality only when they are run + under the control of a debugger/profiler, without having to + recompile or change the application source code. + + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/GREMEDY/string_marker.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.GREMEDY.string_marker import * +from OpenGL.raw.GL.GREMEDY.string_marker import _EXTENSION_NAME + +def glInitStringMarkerGREMEDY(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glStringMarkerGREMEDY.string size not checked against len +glStringMarkerGREMEDY=wrapper.wrapper(glStringMarkerGREMEDY).setInputArraySize( + 'string', None +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/HP/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/GL/HP/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/HP/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/HP/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/HP/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..67760aa5 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/HP/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/HP/__pycache__/convolution_border_modes.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/HP/__pycache__/convolution_border_modes.cpython-312.pyc new file mode 100644 index 00000000..999b1cb7 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/HP/__pycache__/convolution_border_modes.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/HP/__pycache__/image_transform.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/HP/__pycache__/image_transform.cpython-312.pyc new file mode 100644 index 00000000..d60a1165 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/HP/__pycache__/image_transform.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/HP/__pycache__/occlusion_test.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/HP/__pycache__/occlusion_test.cpython-312.pyc new file mode 100644 index 00000000..1396662b Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/HP/__pycache__/occlusion_test.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/HP/__pycache__/texture_lighting.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/HP/__pycache__/texture_lighting.cpython-312.pyc new file mode 100644 index 00000000..74c1b1b3 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/HP/__pycache__/texture_lighting.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/HP/convolution_border_modes.py b/venv/lib/python3.12/site-packages/OpenGL/GL/HP/convolution_border_modes.py new file mode 100644 index 00000000..33bd2769 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/HP/convolution_border_modes.py @@ -0,0 +1,28 @@ +'''OpenGL extension HP.convolution_border_modes + +This module customises the behaviour of the +OpenGL.raw.GL.HP.convolution_border_modes to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides some additional border modes for the + EXT_convolution extension. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/HP/convolution_border_modes.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.HP.convolution_border_modes import * +from OpenGL.raw.GL.HP.convolution_border_modes import _EXTENSION_NAME + +def glInitConvolutionBorderModesHP(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/HP/image_transform.py b/venv/lib/python3.12/site-packages/OpenGL/GL/HP/image_transform.py new file mode 100644 index 00000000..57a5ce21 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/HP/image_transform.py @@ -0,0 +1,47 @@ +'''OpenGL extension HP.image_transform + +This module customises the behaviour of the +OpenGL.raw.GL.HP.image_transform to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides support for scaling, rotation, and translation + of two-dimensional pixel rectangles at a fixed location in the pixel + transfer process. The 2D image transformation attributes are specified + as individual values so that that implementations may easily detect + scaling and rotation values that lend themselves to optimization. 2D + image transformation occurs immediately after the post-convolution color + table stage of the pixel pipeline. This extension also defines a color + table that is applied immediately after the image transformation operation. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/HP/image_transform.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.HP.image_transform import * +from OpenGL.raw.GL.HP.image_transform import _EXTENSION_NAME + +def glInitImageTransformHP(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glImageTransformParameterivHP.params size not checked against 'pname' +glImageTransformParameterivHP=wrapper.wrapper(glImageTransformParameterivHP).setInputArraySize( + 'params', None +) +# INPUT glImageTransformParameterfvHP.params size not checked against 'pname' +glImageTransformParameterfvHP=wrapper.wrapper(glImageTransformParameterfvHP).setInputArraySize( + 'params', None +) +glGetImageTransformParameterivHP=wrapper.wrapper(glGetImageTransformParameterivHP).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetImageTransformParameterfvHP=wrapper.wrapper(glGetImageTransformParameterfvHP).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/HP/occlusion_test.py b/venv/lib/python3.12/site-packages/OpenGL/GL/HP/occlusion_test.py new file mode 100644 index 00000000..2d52815f --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/HP/occlusion_test.py @@ -0,0 +1,26 @@ +'''OpenGL extension HP.occlusion_test + +This module customises the behaviour of the +OpenGL.raw.GL.HP.occlusion_test to provide a more +Python-friendly API + +Overview (from the spec) + + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/HP/occlusion_test.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.HP.occlusion_test import * +from OpenGL.raw.GL.HP.occlusion_test import _EXTENSION_NAME + +def glInitOcclusionTestHP(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/HP/texture_lighting.py b/venv/lib/python3.12/site-packages/OpenGL/GL/HP/texture_lighting.py new file mode 100644 index 00000000..e2b555c6 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/HP/texture_lighting.py @@ -0,0 +1,29 @@ +'''OpenGL extension HP.texture_lighting + +This module customises the behaviour of the +OpenGL.raw.GL.HP.texture_lighting to provide a more +Python-friendly API + +Overview (from the spec) + + This extension defines a mechanism for applications to request + that color originating from specular lighting be added to + the fragment color _after_ texture application. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/HP/texture_lighting.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.HP.texture_lighting import * +from OpenGL.raw.GL.HP.texture_lighting import _EXTENSION_NAME + +def glInitTextureLightingHP(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/IBM/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/GL/IBM/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/IBM/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/IBM/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/IBM/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..e152612b Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/IBM/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/IBM/__pycache__/cull_vertex.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/IBM/__pycache__/cull_vertex.cpython-312.pyc new file mode 100644 index 00000000..ce77e768 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/IBM/__pycache__/cull_vertex.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/IBM/__pycache__/multimode_draw_arrays.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/IBM/__pycache__/multimode_draw_arrays.cpython-312.pyc new file mode 100644 index 00000000..751c3d39 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/IBM/__pycache__/multimode_draw_arrays.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/IBM/__pycache__/rasterpos_clip.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/IBM/__pycache__/rasterpos_clip.cpython-312.pyc new file mode 100644 index 00000000..4ac962d5 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/IBM/__pycache__/rasterpos_clip.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/IBM/__pycache__/static_data.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/IBM/__pycache__/static_data.cpython-312.pyc new file mode 100644 index 00000000..87eda6d0 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/IBM/__pycache__/static_data.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/IBM/__pycache__/texture_mirrored_repeat.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/IBM/__pycache__/texture_mirrored_repeat.cpython-312.pyc new file mode 100644 index 00000000..ab0c241e Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/IBM/__pycache__/texture_mirrored_repeat.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/IBM/__pycache__/vertex_array_lists.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/IBM/__pycache__/vertex_array_lists.cpython-312.pyc new file mode 100644 index 00000000..7a7215d1 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/IBM/__pycache__/vertex_array_lists.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/IBM/cull_vertex.py b/venv/lib/python3.12/site-packages/OpenGL/GL/IBM/cull_vertex.py new file mode 100644 index 00000000..cc0ed975 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/IBM/cull_vertex.py @@ -0,0 +1,32 @@ +'''OpenGL extension IBM.cull_vertex + +This module customises the behaviour of the +OpenGL.raw.GL.IBM.cull_vertex to provide a more +Python-friendly API + +Overview (from the spec) + + IBM_cull_vertex provides a subset of the vertex culling functionality + found in EXT_cull_vertex without providing a guarantee that faces will + be culled because of it. EXT_cull_vertex is a technically superior + solution, but the vertex culling aspect of IBM_cull_vertex provides + generally useful function cheaply (without imposing the mandated + culling found in EXT_cull_vertex). + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/IBM/cull_vertex.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.IBM.cull_vertex import * +from OpenGL.raw.GL.IBM.cull_vertex import _EXTENSION_NAME + +def glInitCullVertexIBM(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/IBM/multimode_draw_arrays.py b/venv/lib/python3.12/site-packages/OpenGL/GL/IBM/multimode_draw_arrays.py new file mode 100644 index 00000000..713b4114 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/IBM/multimode_draw_arrays.py @@ -0,0 +1,55 @@ +'''OpenGL extension IBM.multimode_draw_arrays + +This module customises the behaviour of the +OpenGL.raw.GL.IBM.multimode_draw_arrays to provide a more +Python-friendly API + +Overview (from the spec) + + These functions behave identically to the standard OpenGL 1.1 functions + glDrawArrays() and glDrawElements() except they handle multiple lists of + vertices and multiple primitive modes in one call. Their main purpose is + to allow one function call to render more than one primitive regardless + of the primitive mode. + + This extension is similar to the EXT_multi_draw_arrays extension + except that it accomodates the specification of a unique mode for + each primitive. + + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/IBM/multimode_draw_arrays.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.IBM.multimode_draw_arrays import * +from OpenGL.raw.GL.IBM.multimode_draw_arrays import _EXTENSION_NAME + +def glInitMultimodeDrawArraysIBM(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glMultiModeDrawArraysIBM.count size not checked against 'primcount' +# INPUT glMultiModeDrawArraysIBM.first size not checked against 'primcount' +# INPUT glMultiModeDrawArraysIBM.mode size not checked against 'primcount' +glMultiModeDrawArraysIBM=wrapper.wrapper(glMultiModeDrawArraysIBM).setInputArraySize( + 'count', None +).setInputArraySize( + 'first', None +).setInputArraySize( + 'mode', None +) +# INPUT glMultiModeDrawElementsIBM.count size not checked against 'primcount' +# INPUT glMultiModeDrawElementsIBM.indices size not checked against 'primcount' +# INPUT glMultiModeDrawElementsIBM.mode size not checked against 'primcount' +glMultiModeDrawElementsIBM=wrapper.wrapper(glMultiModeDrawElementsIBM).setInputArraySize( + 'count', None +).setInputArraySize( + 'indices', None +).setInputArraySize( + 'mode', None +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/IBM/rasterpos_clip.py b/venv/lib/python3.12/site-packages/OpenGL/GL/IBM/rasterpos_clip.py new file mode 100644 index 00000000..600b17c9 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/IBM/rasterpos_clip.py @@ -0,0 +1,34 @@ +'''OpenGL extension IBM.rasterpos_clip + +This module customises the behaviour of the +OpenGL.raw.GL.IBM.rasterpos_clip to provide a more +Python-friendly API + +Overview (from the spec) + + IBM_rasterpos_clip extends the semantics of the RasterPos functions. It + provides an enable that allows a raster position that would normally be + clipped to be treated as a valid (albeit out-of-viewport) position. + + This extension allows applications to specify geometry-aligned pixel + primitives that may be partially off-screen. These primitives are + tested on a pixel-by-pixel basis without being rejected completely + because of an invalid raster position. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/IBM/rasterpos_clip.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.IBM.rasterpos_clip import * +from OpenGL.raw.GL.IBM.rasterpos_clip import _EXTENSION_NAME + +def glInitRasterposClipIBM(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/IBM/static_data.py b/venv/lib/python3.12/site-packages/OpenGL/GL/IBM/static_data.py new file mode 100644 index 00000000..7bc7d597 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/IBM/static_data.py @@ -0,0 +1,38 @@ +'''OpenGL extension IBM.static_data + +This module customises the behaviour of the +OpenGL.raw.GL.IBM.static_data to provide a more +Python-friendly API + +Overview (from the spec) + + The OpenGL specification requires that data be bound at call time. The + IBM_static_data extension relaxes the bind-at-call semantics allowing + an implementation to dereference pointers some time after the + corresponding calls. + + Because of the bind-at-call sematics of standard OpenGL, an + implementation is required to either copy or fully process data at the + time it is provided by the application. Copying data substantially + increases the demands on the memory subsystem; processing the data may + result in ineffective amortization of fixed costs. Neither copying nor + processing allows multiple rendering threads to operate on the original + data. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/IBM/static_data.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.IBM.static_data import * +from OpenGL.raw.GL.IBM.static_data import _EXTENSION_NAME + +def glInitStaticDataIBM(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/IBM/texture_mirrored_repeat.py b/venv/lib/python3.12/site-packages/OpenGL/GL/IBM/texture_mirrored_repeat.py new file mode 100644 index 00000000..4146ec61 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/IBM/texture_mirrored_repeat.py @@ -0,0 +1,33 @@ +'''OpenGL extension IBM.texture_mirrored_repeat + +This module customises the behaviour of the +OpenGL.raw.GL.IBM.texture_mirrored_repeat to provide a more +Python-friendly API + +Overview (from the spec) + + IBM_texture_mirrored_repeat extends the set of texture wrap modes to + include a mode (GL_MIRRORED_REPEAT_IBM) that effectively uses a texture + map twice as large at the original image in which the additional half of + the new image is a mirror image of the original image. + + This new mode relaxes the need to generate images whose opposite edges + match by using the original image to generate a matching "mirror image". + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/IBM/texture_mirrored_repeat.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.IBM.texture_mirrored_repeat import * +from OpenGL.raw.GL.IBM.texture_mirrored_repeat import _EXTENSION_NAME + +def glInitTextureMirroredRepeatIBM(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/IBM/vertex_array_lists.py b/venv/lib/python3.12/site-packages/OpenGL/GL/IBM/vertex_array_lists.py new file mode 100644 index 00000000..7f3f38e9 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/IBM/vertex_array_lists.py @@ -0,0 +1,95 @@ +'''OpenGL extension IBM.vertex_array_lists + +This module customises the behaviour of the +OpenGL.raw.GL.IBM.vertex_array_lists to provide a more +Python-friendly API + +Overview (from the spec) + + This extension introduces seven (7) new functions that set the + vertex array pointers. However, instead of a single pointer, these + functions provide a list of array pointers that can be used by the + EXT_multi_draw_arrays and IBM_multimode_draw_arrays extension + functions to draw from multiple of vertex arrays. The first + primitive will use the first array in the list, the second primitive + will use the second array in the list, and so forth. If a glDrawArray, + DrawElements, or DrawRangeElements function is used, then + only the first vertex array in the list is used. + + When a vertex array list is specified, only the list pointer + is kept by the underlying OpenGL function. Therefore, the list + must be staticly defined for the entire duration of its usage, + much in the same manner as the vertex arrays themselves. Also + note that the list function can therefore also be used to change + array pointers without making a OpenGL API function call. + + A value of zero (0) can be used to force all primitives + of a multi-vertex array to use only the first vertex array in + the list. + + The parameter of the list pointer functions differs from + that of the non-list vertex array pointer functions in that 1) + both negative and positive strides are accepted thusly allowing + vertex lists to be rendered in reverse order; 2) a of + zero (0) results in no stride and can be used to specify a single + vertex attribute for each vertex of the primitive. + + These new functions are a superset of the standard OpenGL 1.2 vertex + array (non-list) pointer functions and share common state. Therefore, + the list pointer and non-list pointer functions can be used + interchangably. + + New queries are provided by this extension so that ZAPdb can be extended + to query the list pointer state whenever a vertex array function + is traced. The pointer returned by a query of *_ARRAY_POINTER returns + the first entry in the array list. + + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/IBM/vertex_array_lists.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.IBM.vertex_array_lists import * +from OpenGL.raw.GL.IBM.vertex_array_lists import _EXTENSION_NAME + +def glInitVertexArrayListsIBM(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glColorPointerListIBM.pointer size not checked against 'size,type,stride' +glColorPointerListIBM=wrapper.wrapper(glColorPointerListIBM).setInputArraySize( + 'pointer', None +) +# INPUT glSecondaryColorPointerListIBM.pointer size not checked against 'size,type,stride' +glSecondaryColorPointerListIBM=wrapper.wrapper(glSecondaryColorPointerListIBM).setInputArraySize( + 'pointer', None +) +# INPUT glEdgeFlagPointerListIBM.pointer size not checked against 'stride' +glEdgeFlagPointerListIBM=wrapper.wrapper(glEdgeFlagPointerListIBM).setInputArraySize( + 'pointer', None +) +# INPUT glFogCoordPointerListIBM.pointer size not checked against 'type,stride' +glFogCoordPointerListIBM=wrapper.wrapper(glFogCoordPointerListIBM).setInputArraySize( + 'pointer', None +) +# INPUT glIndexPointerListIBM.pointer size not checked against 'type,stride' +glIndexPointerListIBM=wrapper.wrapper(glIndexPointerListIBM).setInputArraySize( + 'pointer', None +) +# INPUT glNormalPointerListIBM.pointer size not checked against 'type,stride' +glNormalPointerListIBM=wrapper.wrapper(glNormalPointerListIBM).setInputArraySize( + 'pointer', None +) +# INPUT glTexCoordPointerListIBM.pointer size not checked against 'size,type,stride' +glTexCoordPointerListIBM=wrapper.wrapper(glTexCoordPointerListIBM).setInputArraySize( + 'pointer', None +) +# INPUT glVertexPointerListIBM.pointer size not checked against 'size,type,stride' +glVertexPointerListIBM=wrapper.wrapper(glVertexPointerListIBM).setInputArraySize( + 'pointer', None +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/IMG/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/GL/IMG/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/IMG/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/IMG/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/IMG/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..6a7ed856 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/IMG/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/INGR/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/GL/INGR/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/INGR/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/INGR/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/INGR/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..392d694a Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/INGR/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/INGR/__pycache__/blend_func_separate.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/INGR/__pycache__/blend_func_separate.cpython-312.pyc new file mode 100644 index 00000000..3fbeea00 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/INGR/__pycache__/blend_func_separate.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/INGR/__pycache__/color_clamp.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/INGR/__pycache__/color_clamp.cpython-312.pyc new file mode 100644 index 00000000..4f996ae8 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/INGR/__pycache__/color_clamp.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/INGR/__pycache__/interlace_read.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/INGR/__pycache__/interlace_read.cpython-312.pyc new file mode 100644 index 00000000..c06bc01c Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/INGR/__pycache__/interlace_read.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/INGR/blend_func_separate.py b/venv/lib/python3.12/site-packages/OpenGL/GL/INGR/blend_func_separate.py new file mode 100644 index 00000000..8473371c --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/INGR/blend_func_separate.py @@ -0,0 +1,23 @@ +'''OpenGL extension INGR.blend_func_separate + +This module customises the behaviour of the +OpenGL.raw.GL.INGR.blend_func_separate to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/INGR/blend_func_separate.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.INGR.blend_func_separate import * +from OpenGL.raw.GL.INGR.blend_func_separate import _EXTENSION_NAME + +def glInitBlendFuncSeparateINGR(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/INGR/color_clamp.py b/venv/lib/python3.12/site-packages/OpenGL/GL/INGR/color_clamp.py new file mode 100644 index 00000000..42404f1f --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/INGR/color_clamp.py @@ -0,0 +1,31 @@ +'''OpenGL extension INGR.color_clamp + +This module customises the behaviour of the +OpenGL.raw.GL.INGR.color_clamp to provide a more +Python-friendly API + +Overview (from the spec) + + Various RGBA color space conversions require clamping to values + in a more constrained range than [0, 1]. This extension allows + the definition of independent color clamp values for each of the + four color components as part of the Final Conversion in the pixel + transfer path for draws, reads, and copies. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/INGR/color_clamp.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.INGR.color_clamp import * +from OpenGL.raw.GL.INGR.color_clamp import _EXTENSION_NAME + +def glInitColorClampINGR(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/INGR/interlace_read.py b/venv/lib/python3.12/site-packages/OpenGL/GL/INGR/interlace_read.py new file mode 100644 index 00000000..127352ab --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/INGR/interlace_read.py @@ -0,0 +1,30 @@ +'''OpenGL extension INGR.interlace_read + +This module customises the behaviour of the +OpenGL.raw.GL.INGR.interlace_read to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides a way to skip rows of pixels when reading + or copying pixel rectangles. This extension is complementary to + the EXT_interlace extension except that it has no affect on getting + texture images. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/INGR/interlace_read.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.INGR.interlace_read import * +from OpenGL.raw.GL.INGR.interlace_read import _EXTENSION_NAME + +def glInitInterlaceReadINGR(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/INTEL/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/GL/INTEL/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/INTEL/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/INTEL/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/INTEL/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..002a1de3 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/INTEL/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/INTEL/__pycache__/blackhole_render.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/INTEL/__pycache__/blackhole_render.cpython-312.pyc new file mode 100644 index 00000000..8f9b22f6 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/INTEL/__pycache__/blackhole_render.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/INTEL/__pycache__/conservative_rasterization.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/INTEL/__pycache__/conservative_rasterization.cpython-312.pyc new file mode 100644 index 00000000..c95a5376 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/INTEL/__pycache__/conservative_rasterization.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/INTEL/__pycache__/fragment_shader_ordering.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/INTEL/__pycache__/fragment_shader_ordering.cpython-312.pyc new file mode 100644 index 00000000..76ad8f4f Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/INTEL/__pycache__/fragment_shader_ordering.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/INTEL/__pycache__/framebuffer_CMAA.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/INTEL/__pycache__/framebuffer_CMAA.cpython-312.pyc new file mode 100644 index 00000000..c6853049 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/INTEL/__pycache__/framebuffer_CMAA.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/INTEL/__pycache__/map_texture.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/INTEL/__pycache__/map_texture.cpython-312.pyc new file mode 100644 index 00000000..9a4c9039 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/INTEL/__pycache__/map_texture.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/INTEL/__pycache__/parallel_arrays.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/INTEL/__pycache__/parallel_arrays.cpython-312.pyc new file mode 100644 index 00000000..06765097 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/INTEL/__pycache__/parallel_arrays.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/INTEL/__pycache__/performance_query.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/INTEL/__pycache__/performance_query.cpython-312.pyc new file mode 100644 index 00000000..49f2e334 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/INTEL/__pycache__/performance_query.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/INTEL/blackhole_render.py b/venv/lib/python3.12/site-packages/OpenGL/GL/INTEL/blackhole_render.py new file mode 100644 index 00000000..b27855de --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/INTEL/blackhole_render.py @@ -0,0 +1,34 @@ +'''OpenGL extension INTEL.blackhole_render + +This module customises the behaviour of the +OpenGL.raw.GL.INTEL.blackhole_render to provide a more +Python-friendly API + +Overview (from the spec) + + The purpose of this extension is to allow an application to disable all + rendering operations emitted to the GPU through the OpenGL rendering + commands (Draw*, DispatchCompute*, BlitFramebuffer, etc...). Changes to the + OpenGL pipeline are not affected. + + New preprocessor #defines are added to the OpenGL Shading Language: + + #define GL_INTEL_blackhole_render 1 + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/INTEL/blackhole_render.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.INTEL.blackhole_render import * +from OpenGL.raw.GL.INTEL.blackhole_render import _EXTENSION_NAME + +def glInitBlackholeRenderINTEL(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/INTEL/conservative_rasterization.py b/venv/lib/python3.12/site-packages/OpenGL/GL/INTEL/conservative_rasterization.py new file mode 100644 index 00000000..5b90126f --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/INTEL/conservative_rasterization.py @@ -0,0 +1,41 @@ +'''OpenGL extension INTEL.conservative_rasterization + +This module customises the behaviour of the +OpenGL.raw.GL.INTEL.conservative_rasterization to provide a more +Python-friendly API + +Overview (from the spec) + + Regular rasterization includes fragments with at least one + sample covered by a polygon. Conservative rasterization includes all + fragments that are at least partially covered by the polygon. + + In some use cases, it is also important to know if a fragment is fully + covered by a polygon, i.e. if all parts of the fragment are within the + polygon. An application may, for example, want to process fully covered + fragments different from the "edge" pixels. This extension adds an option + for the fragment shader to receive this information via gl_SampleMaskIn[]. + + This extension affects only polygons in FILL mode and specifically does not + imply any changes in processing of lines or points. + + Conservative rasterization automatically disables polygon antialiasing + rasterization if enabled by POLYGON_SMOOTH. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/INTEL/conservative_rasterization.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.INTEL.conservative_rasterization import * +from OpenGL.raw.GL.INTEL.conservative_rasterization import _EXTENSION_NAME + +def glInitConservativeRasterizationINTEL(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/INTEL/fragment_shader_ordering.py b/venv/lib/python3.12/site-packages/OpenGL/GL/INTEL/fragment_shader_ordering.py new file mode 100644 index 00000000..64dd93cf --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/INTEL/fragment_shader_ordering.py @@ -0,0 +1,51 @@ +'''OpenGL extension INTEL.fragment_shader_ordering + +This module customises the behaviour of the +OpenGL.raw.GL.INTEL.fragment_shader_ordering to provide a more +Python-friendly API + +Overview (from the spec) + + Graphics devices may execute in parallel fragment shaders referring to the + same window xy coordinates. Framebuffer writes are guaranteed to be + processed in primitive rasterization order, but there is no order guarantee + for other instructions and image or buffer object accesses in + particular. + + The extension introduces a new GLSL built-in function, + beginFragmentShaderOrderingINTEL(), which blocks execution of a fragment + shader invocation until invocations from previous primitives that map to + the same xy window coordinates (and same sample when per-sample shading + is active) complete their execution. All memory transactions from previous + fragment shader invocations are made visible to the fragment shader + invocation that called beginFragmentShaderOrderingINTEL() when the function + returns. + + Including the following line in a shader can be used to control the + language features described in this extension: + + #extension GL_INTEL_fragment_shader_ordering : + + where is as specified in section 3.3. + + New preprocessor #defines are added to the OpenGL Shading Language: + + #define GL_INTEL_fragment_shader_ordering 1 + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/INTEL/fragment_shader_ordering.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.INTEL.fragment_shader_ordering import * +from OpenGL.raw.GL.INTEL.fragment_shader_ordering import _EXTENSION_NAME + +def glInitFragmentShaderOrderingINTEL(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/INTEL/framebuffer_CMAA.py b/venv/lib/python3.12/site-packages/OpenGL/GL/INTEL/framebuffer_CMAA.py new file mode 100644 index 00000000..37eebbee --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/INTEL/framebuffer_CMAA.py @@ -0,0 +1,42 @@ +'''OpenGL extension INTEL.framebuffer_CMAA + +This module customises the behaviour of the +OpenGL.raw.GL.INTEL.framebuffer_CMAA to provide a more +Python-friendly API + +Overview (from the spec) + + Multisampling is a mechanism to antialias all GL primitives and is part of + the GL specification. + + Better visual quality can be achieved by applying multisampling. However, + on certain platforms it comes at a high performance cost. In general, the + greater number of samples per pixel, the bigger the cost. + + Conservative Morphological Anti-Aliasing (CMAA) is an alternative approach + to antialiasing, which operates on the final image. This post processing + technique results in image quality comparable to multisampling at much + lower cost and better performance. + + This extension incorporates an optimized CMAA algorithm implementation into + the GL implementation. + + For more information on CMAA refer to http://software.intel.com. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/INTEL/framebuffer_CMAA.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.INTEL.framebuffer_CMAA import * +from OpenGL.raw.GL.INTEL.framebuffer_CMAA import _EXTENSION_NAME + +def glInitFramebufferCmaaINTEL(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/INTEL/map_texture.py b/venv/lib/python3.12/site-packages/OpenGL/GL/INTEL/map_texture.py new file mode 100644 index 00000000..80134475 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/INTEL/map_texture.py @@ -0,0 +1,43 @@ +'''OpenGL extension INTEL.map_texture + +This module customises the behaviour of the +OpenGL.raw.GL.INTEL.map_texture to provide a more +Python-friendly API + +Overview (from the spec) + Systems with integrated GPUs can share the same physical memory between CPU + and GPU. This feature, if exposed by API, can bring significant performance + benefits for graphics applications by reducing the complexity of + uploading/accessing texture contents. This extension enables CPU direct + access to the GPU memory holding textures. + + The problem with texture memory directly exposed to clients is that + textures are often 'tiled'. Texels are kept in specific layout to improve + locality of reference and thus performance of texturing. This 'tiling' + is specific to particular hardware and would be thus difficult to use. + + This extension allows to create textures with 'linear' layout which allows + for simplified access on user side (potentially sacrificing some + performance during texture sampling). + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/INTEL/map_texture.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.INTEL.map_texture import * +from OpenGL.raw.GL.INTEL.map_texture import _EXTENSION_NAME + +def glInitMapTextureINTEL(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +glMapTexture2DINTEL=wrapper.wrapper(glMapTexture2DINTEL).setInputArraySize( + 'layout', 1 +).setInputArraySize( + 'stride', 1 +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/INTEL/parallel_arrays.py b/venv/lib/python3.12/site-packages/OpenGL/GL/INTEL/parallel_arrays.py new file mode 100644 index 00000000..5c4a6236 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/INTEL/parallel_arrays.py @@ -0,0 +1,38 @@ +'''OpenGL extension INTEL.parallel_arrays + +This module customises the behaviour of the +OpenGL.raw.GL.INTEL.parallel_arrays to provide a more +Python-friendly API + +Overview (from the spec) + + This extension adds the ability to format vertex arrays in a way that's + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/INTEL/parallel_arrays.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.INTEL.parallel_arrays import * +from OpenGL.raw.GL.INTEL.parallel_arrays import _EXTENSION_NAME + +def glInitParallelArraysINTEL(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +glVertexPointervINTEL=wrapper.wrapper(glVertexPointervINTEL).setInputArraySize( + 'pointer', 4 +) +glNormalPointervINTEL=wrapper.wrapper(glNormalPointervINTEL).setInputArraySize( + 'pointer', 4 +) +glColorPointervINTEL=wrapper.wrapper(glColorPointervINTEL).setInputArraySize( + 'pointer', 4 +) +glTexCoordPointervINTEL=wrapper.wrapper(glTexCoordPointervINTEL).setInputArraySize( + 'pointer', 4 +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/INTEL/performance_query.py b/venv/lib/python3.12/site-packages/OpenGL/GL/INTEL/performance_query.py new file mode 100644 index 00000000..59de464f --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/INTEL/performance_query.py @@ -0,0 +1,64 @@ +'''OpenGL extension INTEL.performance_query + +This module customises the behaviour of the +OpenGL.raw.GL.INTEL.performance_query to provide a more +Python-friendly API + +Overview (from the spec) + + The purpose of this extension is to expose Intel proprietary hardware + performance counters to the OpenGL applications. Performance counters may + count: + + - number of hardware events such as number of spawned vertex shaders. In + this case the results represent the number of events. + + - duration of certain activity, like time took by all fragment shader + invocations. In that case the result usually represents the number of + clocks in which the particular HW unit was busy. In order to use such + counter efficiently, it should be normalized to the range of <0,1> by + dividing its value by the number of render clocks. + + - used throughput of certain memory types such as texture memory. In that + case the result of performance counter usually represents the number of + bytes transferred between GPU and memory. + + This extension specifies universal API to manage performance counters on + different Intel hardware platforms. Performance counters are grouped + together into proprietary, hardware-specific, fixed sets of counters that + are measured together by the GPU. + + It is assumed that performance counters are started and ended on any + arbitrary boundaries during rendering. + + A set of performance counters is represented by a unique query type. Each + query type is identified by assigned name and ID. Multiple query types + (sets of performance counters) are supported by the Intel hardware. However + each Intel hardware generation supports different sets of performance + counters. Therefore the query types between hardware generations can be + different. The definition of query types and their results structures can + be learned through the API. It is also documented in a separate document of + Intel OGL Performance Counters Specification issued per each new hardware + generation. + + The API allows to create multiple instances of any query type and to sample + different fragments of 3D rendering with such instances. Query instances + are identified with handles. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/INTEL/performance_query.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.INTEL.performance_query import * +from OpenGL.raw.GL.INTEL.performance_query import _EXTENSION_NAME + +def glInitPerformanceQueryINTEL(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/KHR/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/GL/KHR/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/KHR/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/KHR/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..53630bc8 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/KHR/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/KHR/__pycache__/blend_equation_advanced.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/KHR/__pycache__/blend_equation_advanced.cpython-312.pyc new file mode 100644 index 00000000..fe454adc Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/KHR/__pycache__/blend_equation_advanced.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/KHR/__pycache__/blend_equation_advanced_coherent.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/KHR/__pycache__/blend_equation_advanced_coherent.cpython-312.pyc new file mode 100644 index 00000000..e6944b35 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/KHR/__pycache__/blend_equation_advanced_coherent.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/KHR/__pycache__/context_flush_control.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/KHR/__pycache__/context_flush_control.cpython-312.pyc new file mode 100644 index 00000000..a3e968da Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/KHR/__pycache__/context_flush_control.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/KHR/__pycache__/debug.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/KHR/__pycache__/debug.cpython-312.pyc new file mode 100644 index 00000000..6b15a1e0 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/KHR/__pycache__/debug.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/KHR/__pycache__/no_error.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/KHR/__pycache__/no_error.cpython-312.pyc new file mode 100644 index 00000000..f444e45b Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/KHR/__pycache__/no_error.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/KHR/__pycache__/parallel_shader_compile.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/KHR/__pycache__/parallel_shader_compile.cpython-312.pyc new file mode 100644 index 00000000..5bfc4ee2 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/KHR/__pycache__/parallel_shader_compile.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/KHR/__pycache__/robust_buffer_access_behavior.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/KHR/__pycache__/robust_buffer_access_behavior.cpython-312.pyc new file mode 100644 index 00000000..1c62d022 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/KHR/__pycache__/robust_buffer_access_behavior.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/KHR/__pycache__/robustness.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/KHR/__pycache__/robustness.cpython-312.pyc new file mode 100644 index 00000000..ca4e66a3 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/KHR/__pycache__/robustness.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/KHR/__pycache__/shader_subgroup.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/KHR/__pycache__/shader_subgroup.cpython-312.pyc new file mode 100644 index 00000000..bd9a0696 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/KHR/__pycache__/shader_subgroup.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/KHR/__pycache__/texture_compression_astc_hdr.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/KHR/__pycache__/texture_compression_astc_hdr.cpython-312.pyc new file mode 100644 index 00000000..254ce94b Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/KHR/__pycache__/texture_compression_astc_hdr.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/KHR/__pycache__/texture_compression_astc_ldr.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/KHR/__pycache__/texture_compression_astc_ldr.cpython-312.pyc new file mode 100644 index 00000000..6a73b70b Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/KHR/__pycache__/texture_compression_astc_ldr.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/KHR/__pycache__/texture_compression_astc_sliced_3d.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/KHR/__pycache__/texture_compression_astc_sliced_3d.cpython-312.pyc new file mode 100644 index 00000000..33959979 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/KHR/__pycache__/texture_compression_astc_sliced_3d.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/KHR/blend_equation_advanced.py b/venv/lib/python3.12/site-packages/OpenGL/GL/KHR/blend_equation_advanced.py new file mode 100644 index 00000000..e978fc4b --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/KHR/blend_equation_advanced.py @@ -0,0 +1,85 @@ +'''OpenGL extension KHR.blend_equation_advanced + +This module customises the behaviour of the +OpenGL.raw.GL.KHR.blend_equation_advanced to provide a more +Python-friendly API + +Overview (from the spec) + + This extension adds a number of "advanced" blending equations that can be + used to perform new color blending operations, many of which are more + complex than the standard blend modes provided by unextended OpenGL. This + extension provides two different extension string entries: + + - KHR_blend_equation_advanced: Provides the new blending equations, but + guarantees defined results only if each sample is touched no more than + once in any single rendering pass. The command BlendBarrierKHR() is + provided to indicate a boundary between passes. + + - KHR_blend_equation_advanced_coherent: Provides the new blending + equations, and guarantees that blending is done coherently and in API + primitive order. An enable is provided to allow implementations to opt + out of fully coherent blending and instead behave as though only + KHR_blend_equation_advanced were supported. + + Some implementations may support KHR_blend_equation_advanced without + supporting KHR_blend_equation_advanced_coherent. + + In unextended OpenGL, the set of blending equations is limited, and can be + expressed very simply. The MIN and MAX blend equations simply compute + component-wise minimums or maximums of source and destination color + components. The FUNC_ADD, FUNC_SUBTRACT, and FUNC_REVERSE_SUBTRACT + multiply the source and destination colors by source and destination + factors and either add the two products together or subtract one from the + other. This limited set of operations supports many common blending + operations but precludes the use of more sophisticated transparency and + blending operations commonly available in many dedicated imaging APIs. + + This extension provides a number of new "advanced" blending equations. + Unlike traditional blending operations using the FUNC_ADD equation, these + blending equations do not use source and destination factors specified by + BlendFunc. Instead, each blend equation specifies a complete equation + based on the source and destination colors. These new blend equations are + used for both RGB and alpha components; they may not be used to perform + separate RGB and alpha blending (via functions like + BlendEquationSeparate). + + These blending operations are performed using premultiplied source and + destination colors, where RGB colors produced by the fragment shader and + stored in the framebuffer are considered to be multiplied by alpha + (coverage). Many of these advanced blending equations are formulated + where the result of blending source and destination colors with partial + coverage have three separate contributions: from the portions covered by + both the source and the destination, from the portion covered only by the + source, and from the portion covered only by the destination. Such + equations are defined assuming that the source and destination coverage + have no spatial correlation within the pixel. + + In addition to the coherency issues on implementations not supporting + KHR_blend_equation_advanced_coherent, this extension has several + limitations worth noting. First, the new blend equations are not + supported while rendering to more than one color buffer at once; an + INVALID_OPERATION will be generated if an application attempts to render + any primitives in this unsupported configuration. Additionally, blending + precision may be limited to 16-bit floating-point, which could result in a + loss of precision and dynamic range for framebuffer formats with 32-bit + floating-point components, and in a loss of precision for formats with 12- + and 16-bit signed or unsigned normalized integer components. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/KHR/blend_equation_advanced.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.KHR.blend_equation_advanced import * +from OpenGL.raw.GL.KHR.blend_equation_advanced import _EXTENSION_NAME + +def glInitBlendEquationAdvancedKHR(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/KHR/blend_equation_advanced_coherent.py b/venv/lib/python3.12/site-packages/OpenGL/GL/KHR/blend_equation_advanced_coherent.py new file mode 100644 index 00000000..ab949cd7 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/KHR/blend_equation_advanced_coherent.py @@ -0,0 +1,23 @@ +'''OpenGL extension KHR.blend_equation_advanced_coherent + +This module customises the behaviour of the +OpenGL.raw.GL.KHR.blend_equation_advanced_coherent to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/KHR/blend_equation_advanced_coherent.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.KHR.blend_equation_advanced_coherent import * +from OpenGL.raw.GL.KHR.blend_equation_advanced_coherent import _EXTENSION_NAME + +def glInitBlendEquationAdvancedCoherentKHR(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/KHR/context_flush_control.py b/venv/lib/python3.12/site-packages/OpenGL/GL/KHR/context_flush_control.py new file mode 100644 index 00000000..1134d4bb --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/KHR/context_flush_control.py @@ -0,0 +1,52 @@ +'''OpenGL extension KHR.context_flush_control + +This module customises the behaviour of the +OpenGL.raw.GL.KHR.context_flush_control to provide a more +Python-friendly API + +Overview (from the spec) + + OpenGL and OpenGL ES have long supported multiple contexts. The + semantics of switching contexts is generally left to window system + binding APIs such as WGL, GLX and EGL. Most of these APIs (if not all) + specify that when the current context for a thread is changed, the + outgoing context performs an implicit flush of any commands that have + been issued to that point. OpenGL and OpenGL ES define a flush as + sending any pending commands for execution and that this action will + result in their completion in finite time. + + This behavior has subtle consequences. For example, if an application is + rendering to the front buffer and switches contexts, it may assume that + any rendering performed thus far will eventually be visible to the user. + With recent introduction of shared memory buffers, there become inumerable + ways in which applications may observe side effects of an implicit flush + (or lack thereof). + + In general, a full flush is not the desired behavior of the application. + Nonetheless, applications that switch contexts frequently suffer the + performance consequences of this unless implementations make special + considerations for them, which is generally untenable. + + The EGL, GLX, and WGL extensions add new context creation parameters + that allow an application to specify the behavior that is desired when a + context is made non-current, and specifically to opt out of the implicit + flush behavior. The GL extension allows querying the context flush + behavior. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/KHR/context_flush_control.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.KHR.context_flush_control import * +from OpenGL.raw.GL.KHR.context_flush_control import _EXTENSION_NAME + +def glInitContextFlushControlKHR(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/KHR/debug.py b/venv/lib/python3.12/site-packages/OpenGL/GL/KHR/debug.py new file mode 100644 index 00000000..8bb6e44c --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/KHR/debug.py @@ -0,0 +1,206 @@ +'''OpenGL extension KHR.debug + +This module customises the behaviour of the +OpenGL.raw.GL.KHR.debug to provide a more +Python-friendly API + +Overview (from the spec) + + This extension allows the GL to notify applications when various events + occur that may be useful during application development, debugging and + profiling. + + These events are represented in the form of enumerable messages with a + human-readable string representation. Examples of debug events include + incorrect use of the GL, warnings of undefined behavior, and performance + warnings. + + A message is uniquely identified by a source, a type and an + implementation-dependent ID within the source and type pair. + + A message's source identifies the origin of the message and can either + describe components of the GL, the window system, third-party external + sources such as external debuggers, or even the application itself. + + The type of the message roughly identifies the nature of the event that + caused the message. Examples include errors, performance warnings, + warnings about undefined behavior or notifications identifying that the + application is within a specific section of the application code. + + A message's ID for a given source and type further distinguishes messages + within namespaces. For example, an error caused by a negative parameter + value or an invalid internal texture format are both errors generated by + the API, but would likely have different message IDs. + + Each message is also assigned to a severity level that denotes roughly how + "important" that message is in comparison to other messages across all + sources and types. For example, notification of a GL error would likely + have a higher severity than a performance warning due to redundant state + changes. + + Furthermore, every message contains an implementation-dependent string + representation that provides a useful description of the event. + + Messages are communicated to the application through an application- + defined callback function that is called by the GL implementation on each + debug message. The motivation for the callback routine is to free + application developers from actively having to query whether a GL error, + or any other debuggable event has happened after each call to a GL + function. With a callback, developers can keep their code free of debug + checks, set breakpoints in the callback function, and only have to react + to messages as they occur. In situations where using a callback is not + possible, a message log is also provided that stores only copies of recent + messages until they are actively queried. + + To control the volume of debug output, messages can be disabled either + individually by ID, or entire sets of messages can be turned off based on + combination of source and type, through the entire application code or + only section of the code encapsulated in debug groups. A debug group may + also be used to annotate the command stream using descriptive texts. + + This extension also defines debug markers, a mechanism for the OpenGL + application to annotate the command stream with markers for discrete + events. + + When profiling or debugging an OpenGL application with a built-in or an + external debugger or profiler, it is difficult to relate the commands + within the command stream to the elements of the scene or parts of the + program code to which they correspond. Debug markers and debug groups help + obviate this by allowing applications to specify this link. For example, a + debug marker can be used to identify the beginning of a frame in the + command stream and a debug group can encapsulate a specific command stream + to identify a rendering pass. Debug groups also allow control of the debug + outputs volume per section of an application code providing an effective + way to handle the massive amount of debug outputs that drivers can + generate. + + Some existing implementations of ARB_debug_output only expose the + ARB_debug_output extension string if the context was created with the + debug flag {GLX|WGL}_CONTEXT_DEBUG_BIT_ARB as specified in + {GLX|WGL}_ARB_create_context. The behavior is not obvious when the + functionality is brought into the OpenGL core specification because the + extension string and function entry points must always exist. + + This extension modifies the existing ARB_debug_output extension to allow + implementations to always have an empty message log. The specific messages + written to the message log or callback routines are already implementation + defined, so this specification simply makes it explicit that it's fine for + there to be zero messages generated, even when a GL error occurs, which is + useful if the context is non-debug. + + Debug output can be enabled and disabled by changing the DEBUG_OUTPUT + state. It is implementation defined how much debug output is generated if + the context was created without the CONTEXT_DEBUG_BIT set. This is a new + query bit added to the existing GL_CONTEXT_FLAGS state to specify whether + the context was created with debug enabled. + + Finally, this extension defines a mechanism for OpenGL applications to + label their objects (textures, buffers, shaders, etc.) with a descriptive + string. + + When profiling or debugging an OpenGL application within an external or + built-in (debut output API) debugger or profiler it is difficult to + identify objects from their object names (integers). + + Even when the object itself is viewed it can be problematic to + differentiate between similar objects. Attaching a descriptive string, a + label, to an object obviates this difficulty. + + The intended purpose of this extension is purely to improve the user + experience within OpenGL development tools and application built-in + profilers and debuggers. This extension typically improves OpenGL + programmers efficiency by allowing them to instantly detect issues and the + reason for these issues giving him more time to focus on adding new + features to an OpenGL application. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/KHR/debug.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.KHR.debug import * +from OpenGL.raw.GL.KHR.debug import _EXTENSION_NAME + +def glInitDebugKHR(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glDebugMessageControl.ids size not checked against count +glDebugMessageControl=wrapper.wrapper(glDebugMessageControl).setInputArraySize( + 'ids', None +) +# INPUT glDebugMessageInsert.buf size not checked against 'buf,length' +glDebugMessageInsert=wrapper.wrapper(glDebugMessageInsert).setInputArraySize( + 'buf', None +) +glGetDebugMessageLog=wrapper.wrapper(glGetDebugMessageLog).setOutput( + 'ids',size=lambda x:(x,),pnameArg='count',orPassIn=True +).setOutput( + 'lengths',size=lambda x:(x,),pnameArg='count',orPassIn=True +).setOutput( + 'messageLog',size=lambda x:(x,),pnameArg='bufSize',orPassIn=True +).setOutput( + 'severities',size=lambda x:(x,),pnameArg='count',orPassIn=True +).setOutput( + 'sources',size=lambda x:(x,),pnameArg='count',orPassIn=True +).setOutput( + 'types',size=lambda x:(x,),pnameArg='count',orPassIn=True +) +# INPUT glPushDebugGroup.message size not checked against 'message,length' +glPushDebugGroup=wrapper.wrapper(glPushDebugGroup).setInputArraySize( + 'message', None +) +# INPUT glObjectLabel.label size not checked against 'label,length' +glObjectLabel=wrapper.wrapper(glObjectLabel).setInputArraySize( + 'label', None +) +glGetObjectLabel=wrapper.wrapper(glGetObjectLabel).setOutput( + 'label',size=lambda x:(x,),pnameArg='bufSize',orPassIn=True +).setOutput( + 'length',size=(1,),orPassIn=True +) +# INPUT glObjectPtrLabel.label size not checked against 'label,length' +glObjectPtrLabel=wrapper.wrapper(glObjectPtrLabel).setInputArraySize( + 'label', None +) +glGetObjectPtrLabel=wrapper.wrapper(glGetObjectPtrLabel).setOutput( + 'label',size=lambda x:(x,),pnameArg='bufSize',orPassIn=True +).setOutput( + 'length',size=(1,),orPassIn=True +) +glGetPointerv=wrapper.wrapper(glGetPointerv).setOutput( + 'params',size=(1,),orPassIn=True +) +# INPUT glGetDebugMessageLogKHR.ids size not checked against count +# INPUT glGetDebugMessageLogKHR.lengths size not checked against count +# INPUT glGetDebugMessageLogKHR.messageLog size not checked against bufSize +# INPUT glGetDebugMessageLogKHR.severities size not checked against count +# INPUT glGetDebugMessageLogKHR.sources size not checked against count +# INPUT glGetDebugMessageLogKHR.types size not checked against count +glGetDebugMessageLogKHR=wrapper.wrapper(glGetDebugMessageLogKHR).setInputArraySize( + 'ids', None +).setInputArraySize( + 'lengths', None +).setInputArraySize( + 'messageLog', None +).setInputArraySize( + 'severities', None +).setInputArraySize( + 'sources', None +).setInputArraySize( + 'types', None +) +# INPUT glGetObjectLabelKHR.label size not checked against bufSize +glGetObjectLabelKHR=wrapper.wrapper(glGetObjectLabelKHR).setInputArraySize( + 'label', None +) +# INPUT glGetObjectPtrLabelKHR.label size not checked against bufSize +glGetObjectPtrLabelKHR=wrapper.wrapper(glGetObjectPtrLabelKHR).setInputArraySize( + 'label', None +).setInputArraySize( + 'length', 1 +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/KHR/no_error.py b/venv/lib/python3.12/site-packages/OpenGL/GL/KHR/no_error.py new file mode 100644 index 00000000..b4ee693b --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/KHR/no_error.py @@ -0,0 +1,34 @@ +'''OpenGL extension KHR.no_error + +This module customises the behaviour of the +OpenGL.raw.GL.KHR.no_error to provide a more +Python-friendly API + +Overview (from the spec) + + With this extension enabled any behavior that generates a GL error will + have undefined behavior. The reason this extension exists is performance + can be increased and power usage decreased. When this mode is used, a GL + driver can have undefined behavior where it would have generated a GL error + without this extension. This could include application termination. In + general this extension should be used after you have verified all the GL + errors are removed, and an application is not the kind that would check + for GL errors and adjust behavior based on those errors. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/KHR/no_error.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.KHR.no_error import * +from OpenGL.raw.GL.KHR.no_error import _EXTENSION_NAME + +def glInitNoErrorKHR(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/KHR/parallel_shader_compile.py b/venv/lib/python3.12/site-packages/OpenGL/GL/KHR/parallel_shader_compile.py new file mode 100644 index 00000000..96de600e --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/KHR/parallel_shader_compile.py @@ -0,0 +1,32 @@ +'''OpenGL extension KHR.parallel_shader_compile + +This module customises the behaviour of the +OpenGL.raw.GL.KHR.parallel_shader_compile to provide a more +Python-friendly API + +Overview (from the spec) + + Compiling GLSL into implementation-specific code can be a time consuming + process, so a GL implementation may wish to perform the compilation in a + separate CPU thread. This extension provides a mechanism for the application + to provide a hint to limit the number of threads it wants to be used to + compile shaders, as well as a query to determine if the compilation process + is complete. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/KHR/parallel_shader_compile.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.KHR.parallel_shader_compile import * +from OpenGL.raw.GL.KHR.parallel_shader_compile import _EXTENSION_NAME + +def glInitParallelShaderCompileKHR(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/KHR/robust_buffer_access_behavior.py b/venv/lib/python3.12/site-packages/OpenGL/GL/KHR/robust_buffer_access_behavior.py new file mode 100644 index 00000000..85141426 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/KHR/robust_buffer_access_behavior.py @@ -0,0 +1,36 @@ +'''OpenGL extension KHR.robust_buffer_access_behavior + +This module customises the behaviour of the +OpenGL.raw.GL.KHR.robust_buffer_access_behavior to provide a more +Python-friendly API + +Overview (from the spec) + + This extension specifies the behavior of out-of-bounds buffer and + array accesses. This is an improvement over the existing + KHR_robustness extension which states that the application should + not crash, but that behavior is otherwise undefined. This extension + specifies the access protection provided by the GL to ensure that + out-of-bounds accesses cannot read from or write to data not owned + by the application. All accesses are contained within the buffer + object and program area they reference. These additional robustness + guarantees apply to contexts created with the robust access flag + set. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/KHR/robust_buffer_access_behavior.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.KHR.robust_buffer_access_behavior import * +from OpenGL.raw.GL.KHR.robust_buffer_access_behavior import _EXTENSION_NAME + +def glInitRobustBufferAccessBehaviorKHR(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/KHR/robustness.py b/venv/lib/python3.12/site-packages/OpenGL/GL/KHR/robustness.py new file mode 100644 index 00000000..5b5fd399 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/KHR/robustness.py @@ -0,0 +1,111 @@ +'''OpenGL extension KHR.robustness + +This module customises the behaviour of the +OpenGL.raw.GL.KHR.robustness to provide a more +Python-friendly API + +Overview (from the spec) + + Several recent trends in how OpenGL ES integrates into modern computer + systems have created new requirements for robustness and security for GL + rendering contexts. + + Additionally GPU architectures now support hardware fault detection; + for example, video memory supporting ECC (error correcting codes) + and error detection. GL contexts should be capable of recovering + from hardware faults such as uncorrectable memory errors. Along with + recovery from such hardware faults, the recovery mechanism can + also allow recovery from video memory access exceptions and system + software failures. System software failures can be due to device + changes or driver failures. + + GL queries that return (write) some number of bytes to a + buffer indicated by a pointer parameter introduce risk of buffer + overflows that might be exploitable by malware. To address this, + queries with return value sizes that are not expressed directly by + the parameters to the query itself are given additional API + functions with an additional parameter that specifies the number of + bytes in the buffer and never writing bytes beyond that limit. This + is particularly useful for multi-threaded usage of GL contexts + in a "share group" where one context can change objects in ways that + can cause buffer overflows for another context's GL queries. + + The original ARB_vertex_buffer_object extension includes an issue + that explicitly states program termination is allowed when + out-of-bounds vertex buffer object fetches occur. Modern graphics + hardware is capable of well-defined behavior in the case of out-of- + bounds vertex buffer object fetches. Older hardware may require + extra checks to enforce well-defined (and termination free) + behavior, but this expense is warranted when processing potentially + untrusted content. + + The intent of this extension is to address some specific robustness + goals: + + * For all existing GL queries, provide additional "safe" APIs + that limit data written to user pointers to a buffer size in + bytes that is an explicit additional parameter of the query. + + * Provide a mechanism for a GL application to learn about + graphics resets that affect the context. When a graphics reset + occurs, the GL context becomes unusable and the application + must create a new context to continue operation. Detecting a + graphics reset happens through an inexpensive query. + + * Define behavior of OpenGL calls made after a graphics reset. + + * Provide an enable to guarantee that out-of-bounds buffer object + accesses by the GPU will have deterministic behavior and preclude + application instability or termination due to an incorrect buffer + access. Such accesses include vertex buffer fetches of + attributes and indices, and indexed reads of uniforms or + parameters from buffers. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/KHR/robustness.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.KHR.robustness import * +from OpenGL.raw.GL.KHR.robustness import _EXTENSION_NAME + +def glInitRobustnessKHR(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glReadnPixels.data size not checked against bufSize +glReadnPixels=wrapper.wrapper(glReadnPixels).setInputArraySize( + 'data', None +) +# INPUT glGetnUniformfv.params size not checked against bufSize +glGetnUniformfv=wrapper.wrapper(glGetnUniformfv).setInputArraySize( + 'params', None +) +# INPUT glGetnUniformiv.params size not checked against bufSize +glGetnUniformiv=wrapper.wrapper(glGetnUniformiv).setInputArraySize( + 'params', None +) +# INPUT glGetnUniformuiv.params size not checked against bufSize +glGetnUniformuiv=wrapper.wrapper(glGetnUniformuiv).setInputArraySize( + 'params', None +) +# INPUT glReadnPixelsKHR.data size not checked against bufSize +glReadnPixelsKHR=wrapper.wrapper(glReadnPixelsKHR).setInputArraySize( + 'data', None +) +# INPUT glGetnUniformfvKHR.params size not checked against bufSize +glGetnUniformfvKHR=wrapper.wrapper(glGetnUniformfvKHR).setInputArraySize( + 'params', None +) +# INPUT glGetnUniformivKHR.params size not checked against bufSize +glGetnUniformivKHR=wrapper.wrapper(glGetnUniformivKHR).setInputArraySize( + 'params', None +) +# INPUT glGetnUniformuivKHR.params size not checked against bufSize +glGetnUniformuivKHR=wrapper.wrapper(glGetnUniformuivKHR).setInputArraySize( + 'params', None +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/KHR/shader_subgroup.py b/venv/lib/python3.12/site-packages/OpenGL/GL/KHR/shader_subgroup.py new file mode 100644 index 00000000..f28abbe9 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/KHR/shader_subgroup.py @@ -0,0 +1,45 @@ +'''OpenGL extension KHR.shader_subgroup + +This module customises the behaviour of the +OpenGL.raw.GL.KHR.shader_subgroup to provide a more +Python-friendly API + +Overview (from the spec) + + This extension enables support for the KHR_shader_subgroup shading + language extension in OpenGL and OpenGL ES. + + The extension adds API queries to be able to query + + - the size of subgroups in this implementation (SUBGROUP_SIZE_KHR) + - which shader stages support subgroup operations + (SUBGROUP_SUPPORTED_STAGES_KHR) + - which subgroup features are supported (SUBGROUP_SUPPORTED_FEATURES_KHR) + - whether quad subgroup operations are supported in all + stages supporting subgroup operations (SUBGROUP_QUAD_ALL_STAGES_KHR) + + In OpenGL implementations supporting SPIR-V, this extension enables the + minimal subset of SPIR-V 1.3 which is required to support the subgroup + features that are supported by the implementation. + + In OpenGL ES implementations, this extension does NOT add support for + SPIR-V or for any of the built-in shading language functions (8.18) + that have genDType (double) prototypes. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/KHR/shader_subgroup.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.KHR.shader_subgroup import * +from OpenGL.raw.GL.KHR.shader_subgroup import _EXTENSION_NAME + +def glInitShaderSubgroupKHR(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/KHR/texture_compression_astc_hdr.py b/venv/lib/python3.12/site-packages/OpenGL/GL/KHR/texture_compression_astc_hdr.py new file mode 100644 index 00000000..7cb38f43 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/KHR/texture_compression_astc_hdr.py @@ -0,0 +1,41 @@ +'''OpenGL extension KHR.texture_compression_astc_hdr + +This module customises the behaviour of the +OpenGL.raw.GL.KHR.texture_compression_astc_hdr to provide a more +Python-friendly API + +Overview (from the spec) + + Adaptive Scalable Texture Compression (ASTC) is a new texture + compression technology that offers unprecendented flexibility, while + producing better or comparable results than existing texture + compressions at all bit rates. It includes support for 2D and + slice-based 3D textures, with low and high dynamic range, at bitrates + from below 1 bit/pixel up to 8 bits/pixel in fine steps. + + The goal of these extensions is to support the full 2D profile of the + ASTC texture compression specification, and allow construction of 3D + textures from multiple compressed 2D slices. + + ASTC-compressed textures are handled in OpenGL ES and OpenGL by adding + new supported formats to the existing commands for defining and updating + compressed textures, and defining the interaction of the ASTC formats + with each texture target. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/KHR/texture_compression_astc_hdr.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.KHR.texture_compression_astc_hdr import * +from OpenGL.raw.GL.KHR.texture_compression_astc_hdr import _EXTENSION_NAME + +def glInitTextureCompressionAstcHdrKHR(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/KHR/texture_compression_astc_ldr.py b/venv/lib/python3.12/site-packages/OpenGL/GL/KHR/texture_compression_astc_ldr.py new file mode 100644 index 00000000..f186a725 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/KHR/texture_compression_astc_ldr.py @@ -0,0 +1,23 @@ +'''OpenGL extension KHR.texture_compression_astc_ldr + +This module customises the behaviour of the +OpenGL.raw.GL.KHR.texture_compression_astc_ldr to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/KHR/texture_compression_astc_ldr.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.KHR.texture_compression_astc_ldr import * +from OpenGL.raw.GL.KHR.texture_compression_astc_ldr import _EXTENSION_NAME + +def glInitTextureCompressionAstcLdrKHR(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/KHR/texture_compression_astc_sliced_3d.py b/venv/lib/python3.12/site-packages/OpenGL/GL/KHR/texture_compression_astc_sliced_3d.py new file mode 100644 index 00000000..6963276a --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/KHR/texture_compression_astc_sliced_3d.py @@ -0,0 +1,37 @@ +'''OpenGL extension KHR.texture_compression_astc_sliced_3d + +This module customises the behaviour of the +OpenGL.raw.GL.KHR.texture_compression_astc_sliced_3d to provide a more +Python-friendly API + +Overview (from the spec) + + Adaptive Scalable Texture Compression (ASTC) is a new texture + compression technology that offers unprecendented flexibility, while + producing better or comparable results than existing texture + compressions at all bit rates. It includes support for 2D and + slice-based 3D textures, with low and high dynamic range, at bitrates + from below 1 bit/pixel up to 8 bits/pixel in fine steps. + + This extension extends the functionality of + GL_KHR_texture_compression_astc_ldr to include slice-based 3D textures + for textures using the LDR profile in the same way as the HDR profile + allows slice-based 3D textures. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/KHR/texture_compression_astc_sliced_3d.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.KHR.texture_compression_astc_sliced_3d import * +from OpenGL.raw.GL.KHR.texture_compression_astc_sliced_3d import _EXTENSION_NAME + +def glInitTextureCompressionAstcSliced3DKHR(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/MESA/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/GL/MESA/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/MESA/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/MESA/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/MESA/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..fc04293e Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/MESA/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/MESA/__pycache__/framebuffer_flip_y.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/MESA/__pycache__/framebuffer_flip_y.cpython-312.pyc new file mode 100644 index 00000000..bceeb652 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/MESA/__pycache__/framebuffer_flip_y.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/MESA/__pycache__/pack_invert.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/MESA/__pycache__/pack_invert.cpython-312.pyc new file mode 100644 index 00000000..02d8a379 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/MESA/__pycache__/pack_invert.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/MESA/__pycache__/program_binary_formats.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/MESA/__pycache__/program_binary_formats.cpython-312.pyc new file mode 100644 index 00000000..bfbb3c3d Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/MESA/__pycache__/program_binary_formats.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/MESA/__pycache__/resize_buffers.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/MESA/__pycache__/resize_buffers.cpython-312.pyc new file mode 100644 index 00000000..ec6e7b89 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/MESA/__pycache__/resize_buffers.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/MESA/__pycache__/shader_integer_functions.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/MESA/__pycache__/shader_integer_functions.cpython-312.pyc new file mode 100644 index 00000000..187f27bb Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/MESA/__pycache__/shader_integer_functions.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/MESA/__pycache__/tile_raster_order.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/MESA/__pycache__/tile_raster_order.cpython-312.pyc new file mode 100644 index 00000000..10ea9816 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/MESA/__pycache__/tile_raster_order.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/MESA/__pycache__/window_pos.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/MESA/__pycache__/window_pos.cpython-312.pyc new file mode 100644 index 00000000..88cb73a5 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/MESA/__pycache__/window_pos.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/MESA/__pycache__/ycbcr_texture.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/MESA/__pycache__/ycbcr_texture.cpython-312.pyc new file mode 100644 index 00000000..3d5e99e7 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/MESA/__pycache__/ycbcr_texture.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/MESA/framebuffer_flip_y.py b/venv/lib/python3.12/site-packages/OpenGL/GL/MESA/framebuffer_flip_y.py new file mode 100644 index 00000000..9b679cb1 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/MESA/framebuffer_flip_y.py @@ -0,0 +1,41 @@ +'''OpenGL extension MESA.framebuffer_flip_y + +This module customises the behaviour of the +OpenGL.raw.GL.MESA.framebuffer_flip_y to provide a more +Python-friendly API + +Overview (from the spec) + + This extension defines a new framebuffer parameter, + GL_FRAMEBUFFER_FLIP_Y_MESA, that changes the behavior of the reads and + writes to the framebuffer attachment points. When GL_FRAMEBUFFER_FLIP_Y_MESA + is GL_TRUE, render commands and pixel transfer operations access the + backing store of each attachment point with an y-inverted coordinate + system. This y-inversion is relative to the coordinate system set when + GL_FRAMEBUFFER_FLIP_Y_MESA is GL_FALSE. + + Access through TexSubImage2D and similar calls will notice the effect of + the flip when they are not attached to framebuffer objects because + GL_FRAMEBUFFER_FLIP_Y_MESA is associated with the framebuffer object and + not the attachment points. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/MESA/framebuffer_flip_y.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.MESA.framebuffer_flip_y import * +from OpenGL.raw.GL.MESA.framebuffer_flip_y import _EXTENSION_NAME + +def glInitFramebufferFlipYMESA(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glGetFramebufferParameterivMESA.params size not checked against 'pname' +glGetFramebufferParameterivMESA=wrapper.wrapper(glGetFramebufferParameterivMESA).setInputArraySize( + 'params', None +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/MESA/pack_invert.py b/venv/lib/python3.12/site-packages/OpenGL/GL/MESA/pack_invert.py new file mode 100644 index 00000000..0c2f6c8d --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/MESA/pack_invert.py @@ -0,0 +1,37 @@ +'''OpenGL extension MESA.pack_invert + +This module customises the behaviour of the +OpenGL.raw.GL.MESA.pack_invert to provide a more +Python-friendly API + +Overview (from the spec) + + This extension adds a new pixel storage parameter to indicate that + images are to be packed in top-to-bottom order instead of OpenGL's + conventional bottom-to-top order. Only pixel packing can be + inverted (i.e. for glReadPixels, glGetTexImage, glGetConvolutionFilter, + etc). + + Almost all known image file formats store images in top-to-bottom + order. As it is, OpenGL reads images from the frame buffer in + bottom-to-top order. Thus, images usually have to be inverted before + writing them to a file with image I/O libraries. This extension + allows images to be read such that inverting isn't needed. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/MESA/pack_invert.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.MESA.pack_invert import * +from OpenGL.raw.GL.MESA.pack_invert import _EXTENSION_NAME + +def glInitPackInvertMESA(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/MESA/program_binary_formats.py b/venv/lib/python3.12/site-packages/OpenGL/GL/MESA/program_binary_formats.py new file mode 100644 index 00000000..e43c5e98 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/MESA/program_binary_formats.py @@ -0,0 +1,28 @@ +'''OpenGL extension MESA.program_binary_formats + +This module customises the behaviour of the +OpenGL.raw.GL.MESA.program_binary_formats to provide a more +Python-friendly API + +Overview (from the spec) + + The get_program_binary exensions require a GLenum binaryFormat. + This extension documents that format for use with Mesa. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/MESA/program_binary_formats.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.MESA.program_binary_formats import * +from OpenGL.raw.GL.MESA.program_binary_formats import _EXTENSION_NAME + +def glInitProgramBinaryFormatsMESA(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/MESA/resize_buffers.py b/venv/lib/python3.12/site-packages/OpenGL/GL/MESA/resize_buffers.py new file mode 100644 index 00000000..10f13ad5 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/MESA/resize_buffers.py @@ -0,0 +1,41 @@ +'''OpenGL extension MESA.resize_buffers + +This module customises the behaviour of the +OpenGL.raw.GL.MESA.resize_buffers to provide a more +Python-friendly API + +Overview (from the spec) + + Mesa is often used as a client library with no integration with + the computer's window system (an X server, for example). And since + Mesa does not have an event loop nor window system callbacks, it + cannot properly respond to window system events. In particular, + Mesa cannot automatically detect when a window has been resized. + + Mesa's glViewport command queries the current window size and updates + its internal data structors accordingly. This normally works fine + since most applications call glViewport in responce to window size + changes. + + In some situations, however, the application may not call glViewport + when a window size changes but would still like Mesa to adjust to + the new window size. This extension exports a new function to solve + this problem. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/MESA/resize_buffers.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.MESA.resize_buffers import * +from OpenGL.raw.GL.MESA.resize_buffers import _EXTENSION_NAME + +def glInitResizeBuffersMESA(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/MESA/shader_integer_functions.py b/venv/lib/python3.12/site-packages/OpenGL/GL/MESA/shader_integer_functions.py new file mode 100644 index 00000000..dbc03a4b --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/MESA/shader_integer_functions.py @@ -0,0 +1,63 @@ +'''OpenGL extension MESA.shader_integer_functions + +This module customises the behaviour of the +OpenGL.raw.GL.MESA.shader_integer_functions to provide a more +Python-friendly API + +Overview (from the spec) + + GL_ARB_gpu_shader5 extends GLSL in a number of useful ways. Much of this + added functionality requires significant hardware support. There are many + aspects, however, that can be easily implmented on any GPU with "real" + integer support (as opposed to simulating integers using floating point + calculations). + + This extension provides a set of new features to the OpenGL Shading + Language to support capabilities of these GPUs, extending the + capabilities of version 1.30 of the OpenGL Shading Language and version + 3.00 of the OpenGL ES Shading Language. Shaders using the new + functionality provided by this extension should enable this + functionality via the construct + + #extension GL_MESA_shader_integer_functions : require (or enable) + + This extension provides a variety of new features for all shader types, + including: + + * support for implicitly converting signed integer types to unsigned + types, as well as more general implicit conversion and function + overloading infrastructure to support new data types introduced by + other extensions; + + * new built-in functions supporting: + + * splitting a floating-point number into a significand and exponent + (frexp), or building a floating-point number from a significand and + exponent (ldexp); + + * integer bitfield manipulation, including functions to find the + position of the most or least significant set bit, count the number + of one bits, and bitfield insertion, extraction, and reversal; + + * extended integer precision math, including add with carry, subtract + with borrow, and extenended multiplication; + + The resulting extension is a strict subset of GL_ARB_gpu_shader5. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/MESA/shader_integer_functions.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.MESA.shader_integer_functions import * +from OpenGL.raw.GL.MESA.shader_integer_functions import _EXTENSION_NAME + +def glInitShaderIntegerFunctionsMESA(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/MESA/tile_raster_order.py b/venv/lib/python3.12/site-packages/OpenGL/GL/MESA/tile_raster_order.py new file mode 100644 index 00000000..741e52e1 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/MESA/tile_raster_order.py @@ -0,0 +1,31 @@ +'''OpenGL extension MESA.tile_raster_order + +This module customises the behaviour of the +OpenGL.raw.GL.MESA.tile_raster_order to provide a more +Python-friendly API + +Overview (from the spec) + + This extension extends the sampling-from-the-framebuffer behavior provided + by GL_ARB_texture_barrier to allow setting the rasterization order of the + scene, so that overlapping blits can be implemented. This can be used for + scrolling or window movement within in 2D scenes, without first copying to + a temporary. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/MESA/tile_raster_order.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.MESA.tile_raster_order import * +from OpenGL.raw.GL.MESA.tile_raster_order import _EXTENSION_NAME + +def glInitTileRasterOrderMESA(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/MESA/window_pos.py b/venv/lib/python3.12/site-packages/OpenGL/GL/MESA/window_pos.py new file mode 100644 index 00000000..ed71ed14 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/MESA/window_pos.py @@ -0,0 +1,76 @@ +'''OpenGL extension MESA.window_pos + +This module customises the behaviour of the +OpenGL.raw.GL.MESA.window_pos to provide a more +Python-friendly API + +Overview (from the spec) + + In order to set the current raster position to a specific window + coordinate with the RasterPos command, the modelview matrix, projection + matrix and viewport must be set very carefully. Furthermore, if the + desired window coordinate is outside of the window's bounds one must + rely on a subtle side-effect of the Bitmap command in order to circumvent + frustum clipping. + + This extension provides a set of functions to directly set the + current raster position, bypassing the modelview matrix, the + projection matrix and the viewport to window mapping. Furthermore, + clip testing is not performed. + + This greatly simplifies the process of setting the current raster + position to a specific window coordinate prior to calling DrawPixels, + CopyPixels or Bitmap. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/MESA/window_pos.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.MESA.window_pos import * +from OpenGL.raw.GL.MESA.window_pos import _EXTENSION_NAME + +def glInitWindowPosMESA(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +glWindowPos2dvMESA=wrapper.wrapper(glWindowPos2dvMESA).setInputArraySize( + 'v', 2 +) +glWindowPos2fvMESA=wrapper.wrapper(glWindowPos2fvMESA).setInputArraySize( + 'v', 2 +) +glWindowPos2ivMESA=wrapper.wrapper(glWindowPos2ivMESA).setInputArraySize( + 'v', 2 +) +glWindowPos2svMESA=wrapper.wrapper(glWindowPos2svMESA).setInputArraySize( + 'v', 2 +) +glWindowPos3dvMESA=wrapper.wrapper(glWindowPos3dvMESA).setInputArraySize( + 'v', 3 +) +glWindowPos3fvMESA=wrapper.wrapper(glWindowPos3fvMESA).setInputArraySize( + 'v', 3 +) +glWindowPos3ivMESA=wrapper.wrapper(glWindowPos3ivMESA).setInputArraySize( + 'v', 3 +) +glWindowPos3svMESA=wrapper.wrapper(glWindowPos3svMESA).setInputArraySize( + 'v', 3 +) +glWindowPos4dvMESA=wrapper.wrapper(glWindowPos4dvMESA).setInputArraySize( + 'v', 4 +) +glWindowPos4fvMESA=wrapper.wrapper(glWindowPos4fvMESA).setInputArraySize( + 'v', 4 +) +glWindowPos4ivMESA=wrapper.wrapper(glWindowPos4ivMESA).setInputArraySize( + 'v', 4 +) +glWindowPos4svMESA=wrapper.wrapper(glWindowPos4svMESA).setInputArraySize( + 'v', 4 +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/MESA/ycbcr_texture.py b/venv/lib/python3.12/site-packages/OpenGL/GL/MESA/ycbcr_texture.py new file mode 100644 index 00000000..e3bdaff8 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/MESA/ycbcr_texture.py @@ -0,0 +1,39 @@ +'''OpenGL extension MESA.ycbcr_texture + +This module customises the behaviour of the +OpenGL.raw.GL.MESA.ycbcr_texture to provide a more +Python-friendly API + +Overview (from the spec) + + This extension supports texture images stored in the YCbCr format. + There is no support for converting YCbCr images to RGB or vice versa + during pixel transfer. The texture's YCbCr colors are converted to + RGB during texture sampling, after-which, all the usual per-fragment + operations take place. Only 2D texture images are supported (not + glDrawPixels, glReadPixels, etc). + + A YCbCr pixel (texel) is a 16-bit unsigned short with two components. + The first component is luminance (Y). For pixels in even-numbered + image columns, the second component is Cb. For pixels in odd-numbered + image columns, the second component is Cr. If one were to convert the + data to RGB one would need to examine two pixels from columns N and N+1 + (where N is even) to deduce the RGB color. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/MESA/ycbcr_texture.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.MESA.ycbcr_texture import * +from OpenGL.raw.GL.MESA.ycbcr_texture import _EXTENSION_NAME + +def glInitYcbcrTextureMESA(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/MESAX/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/GL/MESAX/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/MESAX/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/MESAX/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..1689e999 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/MESAX/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/MESAX/__pycache__/texture_stack.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/MESAX/__pycache__/texture_stack.cpython-312.pyc new file mode 100644 index 00000000..d5839941 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/MESAX/__pycache__/texture_stack.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/MESAX/texture_stack.py b/venv/lib/python3.12/site-packages/OpenGL/GL/MESAX/texture_stack.py new file mode 100644 index 00000000..0a5f922c --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/MESAX/texture_stack.py @@ -0,0 +1,66 @@ +'''OpenGL extension MESAX.texture_stack + +This module customises the behaviour of the +OpenGL.raw.GL.MESAX.texture_stack to provide a more +Python-friendly API + +Overview (from the spec) + + There are a number of circumstances where an application may wish to + blend two textures out of a larger set of textures. Moreover, in some + cases the selected textures may vary on a per-fragment basis within + a polygon. Several examples include: + + 1. High dynamic range textures. The application stores several + different "exposures" of an image as different textures. On a + per-fragment basis, the application selects which exposures are + used. + + 2. A terrain engine where the altitude of a point determines the + texture applied to it. If the transition is from beach sand to + grass to rocks to snow, the application will store each texture + in a different texture map, and dynamically select which two + textures to blend at run-time. + + 3. Storing short video clips in textures. Each depth slice is a + single frame of video. + + Several solutions to this problem have been proposed, but they either + involve using a separate texture unit for each texture map or using 3D + textures without mipmaps. Both of these options have major drawbacks. + + This extension provides a third alternative that eliminates the major + drawbacks of both previous methods. A new texture target, + TEXTURE_2D_STACK, is added that functions identically to TEXTURE_3D in + all aspects except the sizes of the non-base level images. In + traditional 3D texturing, the size of the N+1 LOD is half the size + of the N LOD in all three dimensions. For the TEXTURE_2D_STACK target, + the height and width of the N+1 LOD is halved, but the depth is the + same for all levels of detail. The texture then becomes a "stack" of + 2D textures. The per-fragment texel is selected by the R texture + coordinate. + + References: + + http://www.opengl.org/discussion_boards/cgi_directory/ultimatebb.cgi?ubb=get_topic;f=3;t=011557 + http://www.opengl.org/discussion_boards/cgi_directory/ultimatebb.cgi?ubb=get_topic;f=3;t=000516 + http://www.opengl.org/discussion_boards/cgi_directory/ultimatebb.cgi?ubb=get_topic;f=3;t=011903 + http://www.delphi3d.net/articles/viewarticle.php?article=terraintex.htm + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/MESAX/texture_stack.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.MESAX.texture_stack import * +from OpenGL.raw.GL.MESAX.texture_stack import _EXTENSION_NAME + +def glInitTextureStackMESAX(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..07a00185 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/alpha_to_coverage_dither_control.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/alpha_to_coverage_dither_control.cpython-312.pyc new file mode 100644 index 00000000..1cc2f4e7 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/alpha_to_coverage_dither_control.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/bindless_multi_draw_indirect.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/bindless_multi_draw_indirect.cpython-312.pyc new file mode 100644 index 00000000..6ec49e46 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/bindless_multi_draw_indirect.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/bindless_multi_draw_indirect_count.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/bindless_multi_draw_indirect_count.cpython-312.pyc new file mode 100644 index 00000000..6d112658 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/bindless_multi_draw_indirect_count.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/bindless_texture.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/bindless_texture.cpython-312.pyc new file mode 100644 index 00000000..a954b37d Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/bindless_texture.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/blend_equation_advanced.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/blend_equation_advanced.cpython-312.pyc new file mode 100644 index 00000000..b7a21798 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/blend_equation_advanced.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/blend_equation_advanced_coherent.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/blend_equation_advanced_coherent.cpython-312.pyc new file mode 100644 index 00000000..b25deb35 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/blend_equation_advanced_coherent.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/blend_minmax_factor.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/blend_minmax_factor.cpython-312.pyc new file mode 100644 index 00000000..2b8b9af6 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/blend_minmax_factor.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/blend_square.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/blend_square.cpython-312.pyc new file mode 100644 index 00000000..3bb4714f Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/blend_square.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/clip_space_w_scaling.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/clip_space_w_scaling.cpython-312.pyc new file mode 100644 index 00000000..f1fd8500 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/clip_space_w_scaling.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/command_list.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/command_list.cpython-312.pyc new file mode 100644 index 00000000..5dd81be2 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/command_list.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/compute_program5.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/compute_program5.cpython-312.pyc new file mode 100644 index 00000000..12a45fae Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/compute_program5.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/compute_shader_derivatives.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/compute_shader_derivatives.cpython-312.pyc new file mode 100644 index 00000000..316d6681 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/compute_shader_derivatives.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/conditional_render.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/conditional_render.cpython-312.pyc new file mode 100644 index 00000000..0774e498 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/conditional_render.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/conservative_raster.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/conservative_raster.cpython-312.pyc new file mode 100644 index 00000000..fb4395c4 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/conservative_raster.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/conservative_raster_dilate.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/conservative_raster_dilate.cpython-312.pyc new file mode 100644 index 00000000..927343aa Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/conservative_raster_dilate.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/conservative_raster_pre_snap.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/conservative_raster_pre_snap.cpython-312.pyc new file mode 100644 index 00000000..e4f340b4 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/conservative_raster_pre_snap.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/conservative_raster_pre_snap_triangles.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/conservative_raster_pre_snap_triangles.cpython-312.pyc new file mode 100644 index 00000000..fd7f03fd Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/conservative_raster_pre_snap_triangles.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/conservative_raster_underestimation.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/conservative_raster_underestimation.cpython-312.pyc new file mode 100644 index 00000000..89c04c3f Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/conservative_raster_underestimation.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/copy_depth_to_color.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/copy_depth_to_color.cpython-312.pyc new file mode 100644 index 00000000..f3bb4a5b Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/copy_depth_to_color.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/copy_image.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/copy_image.cpython-312.pyc new file mode 100644 index 00000000..e2bfb785 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/copy_image.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/deep_texture3D.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/deep_texture3D.cpython-312.pyc new file mode 100644 index 00000000..6e9cdd80 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/deep_texture3D.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/depth_buffer_float.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/depth_buffer_float.cpython-312.pyc new file mode 100644 index 00000000..09045279 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/depth_buffer_float.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/depth_clamp.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/depth_clamp.cpython-312.pyc new file mode 100644 index 00000000..3d3ba148 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/depth_clamp.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/draw_texture.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/draw_texture.cpython-312.pyc new file mode 100644 index 00000000..abbcfab1 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/draw_texture.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/draw_vulkan_image.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/draw_vulkan_image.cpython-312.pyc new file mode 100644 index 00000000..269e157d Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/draw_vulkan_image.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/evaluators.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/evaluators.cpython-312.pyc new file mode 100644 index 00000000..f5ecb034 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/evaluators.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/explicit_multisample.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/explicit_multisample.cpython-312.pyc new file mode 100644 index 00000000..d8e2ffe3 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/explicit_multisample.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/fence.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/fence.cpython-312.pyc new file mode 100644 index 00000000..1fecae1d Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/fence.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/fill_rectangle.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/fill_rectangle.cpython-312.pyc new file mode 100644 index 00000000..b23273b1 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/fill_rectangle.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/float_buffer.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/float_buffer.cpython-312.pyc new file mode 100644 index 00000000..a7dedcee Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/float_buffer.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/fog_distance.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/fog_distance.cpython-312.pyc new file mode 100644 index 00000000..ff641ad1 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/fog_distance.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/fragment_coverage_to_color.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/fragment_coverage_to_color.cpython-312.pyc new file mode 100644 index 00000000..04088046 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/fragment_coverage_to_color.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/fragment_program.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/fragment_program.cpython-312.pyc new file mode 100644 index 00000000..99c6903e Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/fragment_program.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/fragment_program2.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/fragment_program2.cpython-312.pyc new file mode 100644 index 00000000..d7c4b924 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/fragment_program2.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/fragment_program4.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/fragment_program4.cpython-312.pyc new file mode 100644 index 00000000..3949d85b Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/fragment_program4.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/fragment_program_option.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/fragment_program_option.cpython-312.pyc new file mode 100644 index 00000000..25c544ac Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/fragment_program_option.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/fragment_shader_barycentric.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/fragment_shader_barycentric.cpython-312.pyc new file mode 100644 index 00000000..7befec02 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/fragment_shader_barycentric.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/fragment_shader_interlock.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/fragment_shader_interlock.cpython-312.pyc new file mode 100644 index 00000000..02bc3cde Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/fragment_shader_interlock.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/framebuffer_mixed_samples.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/framebuffer_mixed_samples.cpython-312.pyc new file mode 100644 index 00000000..a9066310 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/framebuffer_mixed_samples.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/framebuffer_multisample_coverage.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/framebuffer_multisample_coverage.cpython-312.pyc new file mode 100644 index 00000000..21f8380f Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/framebuffer_multisample_coverage.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/geometry_program4.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/geometry_program4.cpython-312.pyc new file mode 100644 index 00000000..6d1b3101 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/geometry_program4.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/geometry_shader4.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/geometry_shader4.cpython-312.pyc new file mode 100644 index 00000000..f79a149d Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/geometry_shader4.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/geometry_shader_passthrough.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/geometry_shader_passthrough.cpython-312.pyc new file mode 100644 index 00000000..8d5e1480 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/geometry_shader_passthrough.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/gpu_multicast.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/gpu_multicast.cpython-312.pyc new file mode 100644 index 00000000..abcd076f Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/gpu_multicast.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/gpu_program4.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/gpu_program4.cpython-312.pyc new file mode 100644 index 00000000..7bdc4ec9 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/gpu_program4.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/gpu_program5.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/gpu_program5.cpython-312.pyc new file mode 100644 index 00000000..739cf7c9 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/gpu_program5.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/gpu_program5_mem_extended.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/gpu_program5_mem_extended.cpython-312.pyc new file mode 100644 index 00000000..546f2bc9 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/gpu_program5_mem_extended.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/gpu_shader5.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/gpu_shader5.cpython-312.pyc new file mode 100644 index 00000000..b086c964 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/gpu_shader5.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/half_float.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/half_float.cpython-312.pyc new file mode 100644 index 00000000..d67e269f Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/half_float.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/internalformat_sample_query.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/internalformat_sample_query.cpython-312.pyc new file mode 100644 index 00000000..e6a133aa Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/internalformat_sample_query.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/light_max_exponent.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/light_max_exponent.cpython-312.pyc new file mode 100644 index 00000000..cf725b10 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/light_max_exponent.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/memory_attachment.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/memory_attachment.cpython-312.pyc new file mode 100644 index 00000000..620d0ca3 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/memory_attachment.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/mesh_shader.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/mesh_shader.cpython-312.pyc new file mode 100644 index 00000000..3b622840 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/mesh_shader.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/multisample_coverage.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/multisample_coverage.cpython-312.pyc new file mode 100644 index 00000000..6bdafd6c Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/multisample_coverage.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/multisample_filter_hint.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/multisample_filter_hint.cpython-312.pyc new file mode 100644 index 00000000..e6b789c4 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/multisample_filter_hint.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/occlusion_query.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/occlusion_query.cpython-312.pyc new file mode 100644 index 00000000..733b7e3a Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/occlusion_query.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/packed_depth_stencil.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/packed_depth_stencil.cpython-312.pyc new file mode 100644 index 00000000..f47d3dc5 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/packed_depth_stencil.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/parameter_buffer_object.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/parameter_buffer_object.cpython-312.pyc new file mode 100644 index 00000000..9b611900 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/parameter_buffer_object.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/parameter_buffer_object2.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/parameter_buffer_object2.cpython-312.pyc new file mode 100644 index 00000000..2eae8902 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/parameter_buffer_object2.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/path_rendering.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/path_rendering.cpython-312.pyc new file mode 100644 index 00000000..92a83250 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/path_rendering.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/path_rendering_shared_edge.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/path_rendering_shared_edge.cpython-312.pyc new file mode 100644 index 00000000..6ae50586 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/path_rendering_shared_edge.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/pixel_data_range.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/pixel_data_range.cpython-312.pyc new file mode 100644 index 00000000..2c8b0b7b Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/pixel_data_range.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/point_sprite.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/point_sprite.cpython-312.pyc new file mode 100644 index 00000000..db1209ed Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/point_sprite.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/present_video.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/present_video.cpython-312.pyc new file mode 100644 index 00000000..5f7fa225 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/present_video.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/primitive_restart.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/primitive_restart.cpython-312.pyc new file mode 100644 index 00000000..eb6dcffa Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/primitive_restart.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/query_resource.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/query_resource.cpython-312.pyc new file mode 100644 index 00000000..07ddd423 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/query_resource.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/query_resource_tag.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/query_resource_tag.cpython-312.pyc new file mode 100644 index 00000000..00cbcee6 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/query_resource_tag.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/register_combiners.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/register_combiners.cpython-312.pyc new file mode 100644 index 00000000..84a7b8bc Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/register_combiners.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/register_combiners2.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/register_combiners2.cpython-312.pyc new file mode 100644 index 00000000..cf28b683 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/register_combiners2.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/representative_fragment_test.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/representative_fragment_test.cpython-312.pyc new file mode 100644 index 00000000..c0cc8636 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/representative_fragment_test.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/robustness_video_memory_purge.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/robustness_video_memory_purge.cpython-312.pyc new file mode 100644 index 00000000..9b17d7b1 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/robustness_video_memory_purge.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/sample_locations.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/sample_locations.cpython-312.pyc new file mode 100644 index 00000000..3c5af0c7 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/sample_locations.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/sample_mask_override_coverage.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/sample_mask_override_coverage.cpython-312.pyc new file mode 100644 index 00000000..4859b940 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/sample_mask_override_coverage.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/scissor_exclusive.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/scissor_exclusive.cpython-312.pyc new file mode 100644 index 00000000..e015f4b3 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/scissor_exclusive.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/shader_atomic_counters.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/shader_atomic_counters.cpython-312.pyc new file mode 100644 index 00000000..73dfe868 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/shader_atomic_counters.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/shader_atomic_float.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/shader_atomic_float.cpython-312.pyc new file mode 100644 index 00000000..47056980 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/shader_atomic_float.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/shader_atomic_float64.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/shader_atomic_float64.cpython-312.pyc new file mode 100644 index 00000000..0a5234b7 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/shader_atomic_float64.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/shader_atomic_fp16_vector.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/shader_atomic_fp16_vector.cpython-312.pyc new file mode 100644 index 00000000..a819ae51 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/shader_atomic_fp16_vector.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/shader_atomic_int64.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/shader_atomic_int64.cpython-312.pyc new file mode 100644 index 00000000..61d64126 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/shader_atomic_int64.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/shader_buffer_load.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/shader_buffer_load.cpython-312.pyc new file mode 100644 index 00000000..bae29ac2 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/shader_buffer_load.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/shader_buffer_store.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/shader_buffer_store.cpython-312.pyc new file mode 100644 index 00000000..91504465 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/shader_buffer_store.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/shader_storage_buffer_object.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/shader_storage_buffer_object.cpython-312.pyc new file mode 100644 index 00000000..cb3fd510 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/shader_storage_buffer_object.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/shader_subgroup_partitioned.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/shader_subgroup_partitioned.cpython-312.pyc new file mode 100644 index 00000000..141196c9 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/shader_subgroup_partitioned.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/shader_texture_footprint.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/shader_texture_footprint.cpython-312.pyc new file mode 100644 index 00000000..0398ca7c Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/shader_texture_footprint.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/shader_thread_group.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/shader_thread_group.cpython-312.pyc new file mode 100644 index 00000000..65fd81e0 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/shader_thread_group.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/shader_thread_shuffle.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/shader_thread_shuffle.cpython-312.pyc new file mode 100644 index 00000000..072d3d8b Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/shader_thread_shuffle.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/shading_rate_image.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/shading_rate_image.cpython-312.pyc new file mode 100644 index 00000000..0072246d Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/shading_rate_image.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/stereo_view_rendering.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/stereo_view_rendering.cpython-312.pyc new file mode 100644 index 00000000..bda07025 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/stereo_view_rendering.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/tessellation_program5.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/tessellation_program5.cpython-312.pyc new file mode 100644 index 00000000..584924ce Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/tessellation_program5.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/texgen_emboss.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/texgen_emboss.cpython-312.pyc new file mode 100644 index 00000000..a912cbc9 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/texgen_emboss.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/texgen_reflection.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/texgen_reflection.cpython-312.pyc new file mode 100644 index 00000000..28667cf5 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/texgen_reflection.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/texture_barrier.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/texture_barrier.cpython-312.pyc new file mode 100644 index 00000000..ede8981a Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/texture_barrier.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/texture_compression_vtc.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/texture_compression_vtc.cpython-312.pyc new file mode 100644 index 00000000..5e38e2c6 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/texture_compression_vtc.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/texture_env_combine4.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/texture_env_combine4.cpython-312.pyc new file mode 100644 index 00000000..3d4a64e5 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/texture_env_combine4.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/texture_expand_normal.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/texture_expand_normal.cpython-312.pyc new file mode 100644 index 00000000..ec29363a Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/texture_expand_normal.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/texture_multisample.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/texture_multisample.cpython-312.pyc new file mode 100644 index 00000000..2627f586 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/texture_multisample.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/texture_rectangle.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/texture_rectangle.cpython-312.pyc new file mode 100644 index 00000000..ab72f736 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/texture_rectangle.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/texture_rectangle_compressed.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/texture_rectangle_compressed.cpython-312.pyc new file mode 100644 index 00000000..01cc7ba9 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/texture_rectangle_compressed.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/texture_shader.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/texture_shader.cpython-312.pyc new file mode 100644 index 00000000..768f545f Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/texture_shader.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/texture_shader2.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/texture_shader2.cpython-312.pyc new file mode 100644 index 00000000..d6dae4c5 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/texture_shader2.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/texture_shader3.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/texture_shader3.cpython-312.pyc new file mode 100644 index 00000000..f634f01e Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/texture_shader3.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/transform_feedback.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/transform_feedback.cpython-312.pyc new file mode 100644 index 00000000..4a340fd7 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/transform_feedback.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/transform_feedback2.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/transform_feedback2.cpython-312.pyc new file mode 100644 index 00000000..572fe070 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/transform_feedback2.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/uniform_buffer_unified_memory.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/uniform_buffer_unified_memory.cpython-312.pyc new file mode 100644 index 00000000..02ceb8bc Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/uniform_buffer_unified_memory.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/vdpau_interop.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/vdpau_interop.cpython-312.pyc new file mode 100644 index 00000000..dcdd96e3 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/vdpau_interop.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/vdpau_interop2.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/vdpau_interop2.cpython-312.pyc new file mode 100644 index 00000000..9ed31863 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/vdpau_interop2.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/vertex_array_range.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/vertex_array_range.cpython-312.pyc new file mode 100644 index 00000000..6d346940 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/vertex_array_range.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/vertex_array_range2.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/vertex_array_range2.cpython-312.pyc new file mode 100644 index 00000000..9444fbb1 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/vertex_array_range2.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/vertex_attrib_integer_64bit.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/vertex_attrib_integer_64bit.cpython-312.pyc new file mode 100644 index 00000000..cb9cd039 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/vertex_attrib_integer_64bit.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/vertex_buffer_unified_memory.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/vertex_buffer_unified_memory.cpython-312.pyc new file mode 100644 index 00000000..3fb935f0 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/vertex_buffer_unified_memory.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/vertex_program.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/vertex_program.cpython-312.pyc new file mode 100644 index 00000000..24c094ed Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/vertex_program.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/vertex_program1_1.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/vertex_program1_1.cpython-312.pyc new file mode 100644 index 00000000..bb387ca6 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/vertex_program1_1.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/vertex_program2.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/vertex_program2.cpython-312.pyc new file mode 100644 index 00000000..81a9fe19 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/vertex_program2.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/vertex_program2_option.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/vertex_program2_option.cpython-312.pyc new file mode 100644 index 00000000..c621a791 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/vertex_program2_option.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/vertex_program3.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/vertex_program3.cpython-312.pyc new file mode 100644 index 00000000..b1a715cf Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/vertex_program3.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/vertex_program4.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/vertex_program4.cpython-312.pyc new file mode 100644 index 00000000..3797fe08 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/vertex_program4.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/video_capture.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/video_capture.cpython-312.pyc new file mode 100644 index 00000000..0bd13ab8 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/video_capture.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/viewport_array2.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/viewport_array2.cpython-312.pyc new file mode 100644 index 00000000..6cd6d6c2 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/viewport_array2.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/viewport_swizzle.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/viewport_swizzle.cpython-312.pyc new file mode 100644 index 00000000..a5c62249 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/__pycache__/viewport_swizzle.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/alpha_to_coverage_dither_control.py b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/alpha_to_coverage_dither_control.py new file mode 100644 index 00000000..dc9df2f6 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/alpha_to_coverage_dither_control.py @@ -0,0 +1,30 @@ +'''OpenGL extension NV.alpha_to_coverage_dither_control + +This module customises the behaviour of the +OpenGL.raw.GL.NV.alpha_to_coverage_dither_control to provide a more +Python-friendly API + +Overview (from the spec) + + NV_alpha_to_coverage_dither_control_triangles provides a new mechanism + to control whether dithering is applied when the existing alpha to coverage + functionality is used. + + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/alpha_to_coverage_dither_control.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.NV.alpha_to_coverage_dither_control import * +from OpenGL.raw.GL.NV.alpha_to_coverage_dither_control import _EXTENSION_NAME + +def glInitAlphaToCoverageDitherControlNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/bindless_multi_draw_indirect.py b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/bindless_multi_draw_indirect.py new file mode 100644 index 00000000..a03b49ac --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/bindless_multi_draw_indirect.py @@ -0,0 +1,43 @@ +'''OpenGL extension NV.bindless_multi_draw_indirect + +This module customises the behaviour of the +OpenGL.raw.GL.NV.bindless_multi_draw_indirect to provide a more +Python-friendly API + +Overview (from the spec) + + This extension combines NV_vertex_buffer_unified_memory and + ARB_multi_draw_indirect to allow the processing of multiple drawing + commands, whose vertex and index data can be sourced from arbitrary + buffer locations, by a single function call. + + The NV_vertex_buffer_unified_memory extension provided a mechanism to + specify vertex attrib and element array locations using GPU addresses. + Prior to this extension, these addresses had to be set through explicit + function calls. Now the ability to set the pointer addresses indirectly + by extending the GL_ARB_draw_indirect mechanism has been added. + + Combined with other "bindless" extensions, such as NV_bindless_texture and + NV_shader_buffer_load, it is now possible for the GPU to create draw + commands that source all resource inputs, which are common to change + frequently between draw calls from the GPU: vertex and index buffers, + samplers, images and other shader input data stored in buffers. + + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/bindless_multi_draw_indirect.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.NV.bindless_multi_draw_indirect import * +from OpenGL.raw.GL.NV.bindless_multi_draw_indirect import _EXTENSION_NAME + +def glInitBindlessMultiDrawIndirectNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/bindless_multi_draw_indirect_count.py b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/bindless_multi_draw_indirect_count.py new file mode 100644 index 00000000..bdb3f166 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/bindless_multi_draw_indirect_count.py @@ -0,0 +1,30 @@ +'''OpenGL extension NV.bindless_multi_draw_indirect_count + +This module customises the behaviour of the +OpenGL.raw.GL.NV.bindless_multi_draw_indirect_count to provide a more +Python-friendly API + +Overview (from the spec) + + This extension adds the possibility to define the number of drawcalls within + a multi-draw-indirect call from the GPU, as provided by ARB_indirect_parameters, + for the functions added in NV_bindless_multi_draw_indirect. + + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/bindless_multi_draw_indirect_count.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.NV.bindless_multi_draw_indirect_count import * +from OpenGL.raw.GL.NV.bindless_multi_draw_indirect_count import _EXTENSION_NAME + +def glInitBindlessMultiDrawIndirectCountNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/bindless_texture.py b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/bindless_texture.py new file mode 100644 index 00000000..e9713a45 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/bindless_texture.py @@ -0,0 +1,76 @@ +'''OpenGL extension NV.bindless_texture + +This module customises the behaviour of the +OpenGL.raw.GL.NV.bindless_texture to provide a more +Python-friendly API + +Overview (from the spec) + + This extension allows OpenGL applications to access texture objects in + shaders without first binding each texture to one of a limited number of + texture image units. Using this extension, an application can query a + 64-bit unsigned integer texture handle for each texture that it wants to + access and then use that handle directly in GLSL or assembly-based + shaders. The ability to access textures without having to bind and/or + re-bind them is similar to the capability provided by the + NV_shader_buffer_load extension that allows shaders to access buffer + objects without binding them. In both cases, these extensions + significantly reduce the amount of API and internal GL driver overhead + needed to manage resource bindings. + + This extension also provides similar capability for the image load, store, + and atomic functionality provided by OpenGL 4.2, OpenGL ES 3.1 and the + ARB_shader_image_load_store and EXT_shader_image_load_store extensions, + where a texture can be accessed without first binding it to an image unit. + An image handle can be extracted from a texture object using an API with a + set of parameters similar to those for BindImageTextureEXT. + + This extension adds no new data types to GLSL. Instead, it uses existing + sampler and image data types and allows them to be populated with texture + and image handles. This extension does permit sampler and image data + types to be used in more contexts than in unextended GLSL 4.00. In + particular, sampler and image types may be used as shader inputs/outputs, + temporary variables, and uniform block members, and may be assigned to by + shader code. Constructors are provided to convert 64-bit unsigned integer + values to and from sampler and image data types. Additionally, new APIs + are provided to load values for sampler and image uniforms with 64-bit + handle inputs. The use of existing integer-based Uniform* APIs is still + permitted, in which case the integer specified will identify a texture + image or image unit. For samplers and images with values specified as + texture image or image units, the GL implemenation will translate the unit + number to an internal handle as required. + + To access texture or image resources using handles, the handles must first + be made resident. Accessing a texture or image by handle without first + making it resident can result in undefined results, including program + termination. Since the amount of texture memory required by an + application may exceed the amount of memory available to the system, this + extension provides API calls allowing applications to manage overall + texture memory consumption by making a texture resident and non-resident + as required. + + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/bindless_texture.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.NV.bindless_texture import * +from OpenGL.raw.GL.NV.bindless_texture import _EXTENSION_NAME + +def glInitBindlessTextureNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glUniformHandleui64vNV.value size not checked against count +glUniformHandleui64vNV=wrapper.wrapper(glUniformHandleui64vNV).setInputArraySize( + 'value', None +) +# INPUT glProgramUniformHandleui64vNV.values size not checked against count +glProgramUniformHandleui64vNV=wrapper.wrapper(glProgramUniformHandleui64vNV).setInputArraySize( + 'values', None +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/blend_equation_advanced.py b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/blend_equation_advanced.py new file mode 100644 index 00000000..5f9280db --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/blend_equation_advanced.py @@ -0,0 +1,99 @@ +'''OpenGL extension NV.blend_equation_advanced + +This module customises the behaviour of the +OpenGL.raw.GL.NV.blend_equation_advanced to provide a more +Python-friendly API + +Overview (from the spec) + + This extension adds a number of "advanced" blending equations that can be + used to perform new color blending operations, many of which are more + complex than the standard blend modes provided by unextended OpenGL. This + extension provides two different extension string entries: + + - NV_blend_equation_advanced: Provides the new blending equations, but + guarantees defined results only if each sample is touched no more than + once in any single rendering pass. The command BlendBarrierNV() is + provided to indicate a boundary between passes. + + - NV_blend_equation_advanced_coherent: Provides the new blending + equations, and guarantees that blending is done coherently and in API + primitive ordering. An enable is provided to allow implementations to + opt out of fully coherent blending and instead behave as though only + NV_blend_equation_advanced were supported. + + Some implementations may support NV_blend_equation_advanced without + supporting NV_blend_equation_advanced_coherent. + + In unextended OpenGL, the set of blending equations is limited, and can be + expressed very simply. The MIN and MAX blend equations simply compute + component-wise minimums or maximums of source and destination color + components. The FUNC_ADD, FUNC_SUBTRACT, and FUNC_REVERSE_SUBTRACT + multiply the source and destination colors by source and destination + factors and either add the two products together or subtract one from the + other. This limited set of operations supports many common blending + operations but precludes the use of more sophisticated transparency and + blending operations commonly available in many dedicated imaging APIs. + + This extension provides a number of new "advanced" blending equations. + Unlike traditional blending operations using the FUNC_ADD equation, these + blending equations do not use source and destination factors specified by + BlendFunc. Instead, each blend equation specifies a complete equation + based on the source and destination colors. These new blend equations are + used for both RGB and alpha components; they may not be used to perform + separate RGB and alpha blending (via functions like + BlendEquationSeparate). + + These blending operations are performed using premultiplied colors, where + RGB colors stored in the framebuffer are considered to be multiplied by + alpha (coverage). The fragment color may be considered premultiplied or + non-premultiplied, according the BLEND_PREMULTIPLIED_SRC_NV blending + parameter (as specified by the new BlendParameteriNV function). If + fragment color is considered non-premultiplied, the (R,G,B) color + components are multiplied by the alpha component prior to blending. For + non-premultiplied color components in the range [0,1], the corresponding + premultiplied color component would have values in the range [0*A,1*A]. + + Many of these advanced blending equations are formulated where the result + of blending source and destination colors with partial coverage have three + separate contributions: from the portions covered by both the source and + the destination, from the portion covered only by the source, and from the + portion covered only by the destination. The blend parameter + BLEND_OVERLAP_NV can be used to specify a correlation between source and + destination pixel coverage. If set to CONJOINT_NV, the source and + destination are considered to have maximal overlap, as would be the case + if drawing two objects on top of each other. If set to DISJOINT_NV, the + source and destination are considered to have minimal overlap, as would be + the case when rendering a complex polygon tessellated into individual + non-intersecting triangles. If set to UNCORRELATED_NV (default), the + source and destination coverage are assumed to have no spatial correlation + within the pixel. + + In addition to the coherency issues on implementations not supporting + NV_blend_equation_advanced_coherent, this extension has several + limitations worth noting. First, the new blend equations are not + supported while rendering to more than one color buffer at once; an + INVALID_OPERATION will be generated if an application attempts to render + any primitives in this unsupported configuration. Additionally, blending + precision may be limited to 16-bit floating-point, which could result in a + loss of precision and dynamic range for framebuffer formats with 32-bit + floating-point components, and in a loss of precision for formats with 12- + and 16-bit signed or unsigned normalized integer components. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/blend_equation_advanced.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.NV.blend_equation_advanced import * +from OpenGL.raw.GL.NV.blend_equation_advanced import _EXTENSION_NAME + +def glInitBlendEquationAdvancedNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/blend_equation_advanced_coherent.py b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/blend_equation_advanced_coherent.py new file mode 100644 index 00000000..2c4f63b8 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/blend_equation_advanced_coherent.py @@ -0,0 +1,23 @@ +'''OpenGL extension NV.blend_equation_advanced_coherent + +This module customises the behaviour of the +OpenGL.raw.GL.NV.blend_equation_advanced_coherent to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/blend_equation_advanced_coherent.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.NV.blend_equation_advanced_coherent import * +from OpenGL.raw.GL.NV.blend_equation_advanced_coherent import _EXTENSION_NAME + +def glInitBlendEquationAdvancedCoherentNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/blend_minmax_factor.py b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/blend_minmax_factor.py new file mode 100644 index 00000000..a8f56197 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/blend_minmax_factor.py @@ -0,0 +1,41 @@ +'''OpenGL extension NV.blend_minmax_factor + +This module customises the behaviour of the +OpenGL.raw.GL.NV.blend_minmax_factor to provide a more +Python-friendly API + +Overview (from the spec) + + The EXT_blend_minmax extension extended the GL's blending + functionality to allow the blending equation to be specified by the + application. That extension introduced the MIN_EXT and MAX_EXT blend + equations, which caused the result of the blend equation to become + the minimum or maximum of the source color and destination color, + respectively. + + The MIN_EXT and MAX_EXT blend equations, however, do not include the + source or destination blend factors in the arguments to the min and + max functions. This extension provides two new blend equations that + produce the minimum or maximum of the products of the source color + and source factor, and the destination color and destination factor. + + This NVIDIA extension has some limitations relative to the + AMD_blend_minmax_factor extension. See issues #1, #2, and #3. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/blend_minmax_factor.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.NV.blend_minmax_factor import * +from OpenGL.raw.GL.NV.blend_minmax_factor import _EXTENSION_NAME + +def glInitBlendMinmaxFactorNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/blend_square.py b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/blend_square.py new file mode 100644 index 00000000..a9ef2fd7 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/blend_square.py @@ -0,0 +1,37 @@ +'''OpenGL extension NV.blend_square + +This module customises the behaviour of the +OpenGL.raw.GL.NV.blend_square to provide a more +Python-friendly API + +Overview (from the spec) + + It is useful to be able to multiply a number by itself in the blending + stages -- for example, in certain types of specular lighting effects + where a result from a dot product needs to be taken to a high power. + + This extension provides four additional blending factors to permit + this and other effects: SRC_COLOR and ONE_MINUS_SRC_COLOR for source + blending factors, and DST_COLOR and ONE_MINUS_DST_COLOR for destination + blending factors. + + Direct3D provides capability bits for advertising these additional + blend modes. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/blend_square.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.NV.blend_square import * +from OpenGL.raw.GL.NV.blend_square import _EXTENSION_NAME + +def glInitBlendSquareNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/clip_space_w_scaling.py b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/clip_space_w_scaling.py new file mode 100644 index 00000000..476585e9 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/clip_space_w_scaling.py @@ -0,0 +1,55 @@ +'''OpenGL extension NV.clip_space_w_scaling + +This module customises the behaviour of the +OpenGL.raw.GL.NV.clip_space_w_scaling to provide a more +Python-friendly API + +Overview (from the spec) + + Virtual Reality (VR) applications often involve a post-processing step to + apply a "barrel" distortion to the rendered image to correct the + "pincushion" distortion introduced by the optics in a VR device. The + barrel distorted image has lower resolution along the edges compared to + the center. Since the original image is rendered at high resolution, + which is uniform across the complete image, a lot of pixels towards the + edges do not make it to the final post-processed image. + + This extension also provides a mechanism to render VR scenes at a + non-uniform resolution, in particular a resolution that falls linearly + from the center towards the edges. This is achieved by scaling the "w" + coordinate of the vertices in the clip space before perspective divide. + The clip space "w" coordinate of the vertices may be offset as of a + function of "x" and "y" coordinates as follows: + + w' = w + Ax + By + + In the intended use case for viewport position scaling, an application + should use a set of 4 viewports, one for each of the 4 quadrants of a + Cartesian coordinate system. Each viewport is set to the dimension of the + image, but is scissored to the quadrant it represents. The application + should specify A and B coefficients of the w-scaling equation above, + that have the same value, but different signs, for each of the viewports. + The signs of A and B should match the signs of X and Y for the quadrant + that they represent such that the value of "w'" will always be greater + than or equal to the original "w" value for the entire image. Since the + offset to "w", (Ax + By), is always positive and increases with the + absolute values of "x" and "y", the effective resolution will fall off + linearly from the center of the image to its edges. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/clip_space_w_scaling.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.NV.clip_space_w_scaling import * +from OpenGL.raw.GL.NV.clip_space_w_scaling import _EXTENSION_NAME + +def glInitClipSpaceWScalingNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/command_list.py b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/command_list.py new file mode 100644 index 00000000..276651ad --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/command_list.py @@ -0,0 +1,66 @@ +'''OpenGL extension NV.command_list + +This module customises the behaviour of the +OpenGL.raw.GL.NV.command_list to provide a more +Python-friendly API + +Overview (from the spec) + + This extension adds a few new features designed to provide very low + overhead batching and replay of rendering commands and state changes: + + - A state object, which stores a pre-validated representation of the + the state of (almost) the entire pipeline. + + - A more flexible and extensible MultiDrawIndirect (MDI) type of mechanism, using + a token-based command stream, allowing to setup binding state and emit draw calls. + + - A set of functions to execute a list of the token-based command streams with state object + changes interleaved with the streams. + + - Command lists enabling compilation and reuse of sequences of command + streams and state object changes. + + Because state objects reflect the state of the entire pipeline, it is + expected that they can be pre-validated and executed efficiently. It is + also expected that when state objects are combined into a command list, + the command list can diff consecutive state objects to produce a reduced/ + optimized set of state changes specific to that transition. + + The token-based command stream can also be stored in regular buffer objects + and therefore be modified by the server itself. This allows more + complex work creation than the original MDI approach, which was limited + to emitting draw calls only. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/command_list.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.NV.command_list import * +from OpenGL.raw.GL.NV.command_list import _EXTENSION_NAME + +def glInitCommandListNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glCreateStatesNV.states size not checked against n +glCreateStatesNV=wrapper.wrapper(glCreateStatesNV).setInputArraySize( + 'states', None +) +# INPUT glDeleteStatesNV.states size not checked against n +glDeleteStatesNV=wrapper.wrapper(glDeleteStatesNV).setInputArraySize( + 'states', None +) +# INPUT glCreateCommandListsNV.lists size not checked against n +glCreateCommandListsNV=wrapper.wrapper(glCreateCommandListsNV).setInputArraySize( + 'lists', None +) +# INPUT glDeleteCommandListsNV.lists size not checked against n +glDeleteCommandListsNV=wrapper.wrapper(glDeleteCommandListsNV).setInputArraySize( + 'lists', None +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/compute_program5.py b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/compute_program5.py new file mode 100644 index 00000000..dc923956 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/compute_program5.py @@ -0,0 +1,32 @@ +'''OpenGL extension NV.compute_program5 + +This module customises the behaviour of the +OpenGL.raw.GL.NV.compute_program5 to provide a more +Python-friendly API + +Overview (from the spec) + + This extension builds on the ARB_compute_shader extension to provide new + assembly compute program capability for OpenGL. ARB_compute_shader adds + the basic functionality, including the ability to dispatch compute work. + This extension provides the ability to write a compute program in + assembly, using the same basic syntax and capability set found in the + NV_gpu_program4 and NV_gpu_program5 extensions. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/compute_program5.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.NV.compute_program5 import * +from OpenGL.raw.GL.NV.compute_program5 import _EXTENSION_NAME + +def glInitComputeProgram5NV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/compute_shader_derivatives.py b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/compute_shader_derivatives.py new file mode 100644 index 00000000..a49e9d37 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/compute_shader_derivatives.py @@ -0,0 +1,36 @@ +'''OpenGL extension NV.compute_shader_derivatives + +This module customises the behaviour of the +OpenGL.raw.GL.NV.compute_shader_derivatives to provide a more +Python-friendly API + +Overview (from the spec) + + This extension adds OpenGL and OpenGL ES API support for the OpenGL + Shading Language (GLSL) extension "NV_compute_shader_derivatives". + + That extension, when enabled, allows applications to use derivatives in + compute shaders. It adds compute shader support for explicit derivative + built-in functions like dFdx(), automatic derivative computation in + texture lookup functions like texture(), use of the optional LOD bias + parameter to adjust the computed level of detail values in texture lookup + functions, and the texture level of detail query function + textureQueryLod(). + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/compute_shader_derivatives.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.NV.compute_shader_derivatives import * +from OpenGL.raw.GL.NV.compute_shader_derivatives import _EXTENSION_NAME + +def glInitComputeShaderDerivativesNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/conditional_render.py b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/conditional_render.py new file mode 100644 index 00000000..d1672898 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/conditional_render.py @@ -0,0 +1,52 @@ +'''OpenGL extension NV.conditional_render + +This module customises the behaviour of the +OpenGL.raw.GL.NV.conditional_render to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides support for conditional rendering based on the + results of an occlusion query. This mechanism allows an application to + potentially reduce the latency between the completion of an occlusion + query and the rendering commands depending on its result. It additionally + allows the decision of whether to render to be made without application + intervention. + + This extension defines two new functions, BeginConditionalRenderNV and + EndConditionalRenderNV, between which rendering commands may be discarded + based on the results of an occlusion query. If the specified occlusion + query returns a non-zero value, rendering commands between these calls are + executed. If the occlusion query returns a value of zero, all rendering + commands between the calls are discarded. + + If the occlusion query results are not available when + BeginConditionalRenderNV is executed, the parameter specifies + whether the GL should wait for the query to complete or should simply + render the subsequent geometry unconditionally. + + Additionally, the extension provides a set of "by region" modes, allowing + for implementations that divide rendering work by screen regions to + perform the conditional query test on a region-by-region basis without + checking the query results from other regions. Such a mode is useful for + cases like split-frame SLI, where a frame is divided between multiple + GPUs, each of which has its own occlusion query hardware. + + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/conditional_render.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.NV.conditional_render import * +from OpenGL.raw.GL.NV.conditional_render import _EXTENSION_NAME + +def glInitConditionalRenderNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/conservative_raster.py b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/conservative_raster.py new file mode 100644 index 00000000..a2951269 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/conservative_raster.py @@ -0,0 +1,42 @@ +'''OpenGL extension NV.conservative_raster + +This module customises the behaviour of the +OpenGL.raw.GL.NV.conservative_raster to provide a more +Python-friendly API + +Overview (from the spec) + + This extension adds a "conservative" rasterization mode where any pixel + that is partially covered, even if no sample location is covered, is + treated as fully covered and a corresponding fragment will be shaded. + + A new control is also added to modify window coordinate snapping + precision. + + These controls can be used to implement "binning" to a low-resolution + render target, for example to determine which tiles of a sparse texture + need to be populated. An app can construct a framebuffer where there is + one pixel per tile in the sparse texture, and adjust the number of + subpixel bits such that snapping occurs to the same effective grid as when + rendering to the sparse texture. Then triangles should cover (at least) + the same pixels in the low-res framebuffer as they do tiles in the sparse + texture. + + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/conservative_raster.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.NV.conservative_raster import * +from OpenGL.raw.GL.NV.conservative_raster import _EXTENSION_NAME + +def glInitConservativeRasterNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/conservative_raster_dilate.py b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/conservative_raster_dilate.py new file mode 100644 index 00000000..4d9c0f90 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/conservative_raster_dilate.py @@ -0,0 +1,36 @@ +'''OpenGL extension NV.conservative_raster_dilate + +This module customises the behaviour of the +OpenGL.raw.GL.NV.conservative_raster_dilate to provide a more +Python-friendly API + +Overview (from the spec) + + This extension extends the conservative rasterization functionality + provided by NV_conservative_raster. It provides a new control to generate + an "over-conservative" rasterization by dilating primitives prior to + rasterization. + + When using conservative raster to bin geometry, this extension provides a + programmable overlap region between adjacent primitives. Regular + rasterization bins triangles with a shared edge uniquely into pixels. + Conservative raster has a one-pixel overlap along the shared edge. Using + a half-pixel raster dilation, this overlap region increases to two pixels. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/conservative_raster_dilate.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.NV.conservative_raster_dilate import * +from OpenGL.raw.GL.NV.conservative_raster_dilate import _EXTENSION_NAME + +def glInitConservativeRasterDilateNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/conservative_raster_pre_snap.py b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/conservative_raster_pre_snap.py new file mode 100644 index 00000000..d5b3af61 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/conservative_raster_pre_snap.py @@ -0,0 +1,31 @@ +'''OpenGL extension NV.conservative_raster_pre_snap + +This module customises the behaviour of the +OpenGL.raw.GL.NV.conservative_raster_pre_snap to provide a more +Python-friendly API + +Overview (from the spec) + + NV_conservative_raster_pre_snap_triangles provides a new mode to achieve + rasterization of triangles that is conservative w.r.t the triangle at + infinite precision i.e. before it is snapped to the sub-pixel grid. This + extension provides a new mode that expands this functionality to lines and + points. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/conservative_raster_pre_snap.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.NV.conservative_raster_pre_snap import * +from OpenGL.raw.GL.NV.conservative_raster_pre_snap import _EXTENSION_NAME + +def glInitConservativeRasterPreSnapNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/conservative_raster_pre_snap_triangles.py b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/conservative_raster_pre_snap_triangles.py new file mode 100644 index 00000000..3cfda2fc --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/conservative_raster_pre_snap_triangles.py @@ -0,0 +1,47 @@ +'''OpenGL extension NV.conservative_raster_pre_snap_triangles + +This module customises the behaviour of the +OpenGL.raw.GL.NV.conservative_raster_pre_snap_triangles to provide a more +Python-friendly API + +Overview (from the spec) + + When CONSERVATIVE_RASTERIZATION_NV is enabled, the fragments generated for + a primitive are conservative with respect to the primitive after snapping + to sub-pixel grid. This extension provides a new mode of rasterization + for triangles where the fragments generated are conservative with respect + to the primitive at infinite precision before vertex snapping. + + When the conservative raster mode is set to CONSERVATIVE_RASTER_MODE_PRE_- + SNAP_TRIANGLES, triangles are rasterized more conservatively, and may + generate fragments not generated when the mode is CONSERVATIVE_RASTER_MODE_- + POST_SNAP (default). In particular it may generate fragments for pixels + covered by triangles with zero area, or for pixels that are adjacent to + but not covered by any triangle. This modified behavior may be useful in + compensating for rounding errors caused by snapping vertex positions to a + sub-pixel grid during rasterization. It's possible that a non-degenerate + triangle becomes degenerate due to snapping. It's additionally possible + that rounding errors in computing the position of a vertex or from + snapping may cause a primitive that would cover a pixel at infinite + precision to fail to cover the pixel post-snap. Rasterizing such + primitives more conservatively may be useful for "binning" algorithms + described in NV_conservative_raster. + + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/conservative_raster_pre_snap_triangles.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.NV.conservative_raster_pre_snap_triangles import * +from OpenGL.raw.GL.NV.conservative_raster_pre_snap_triangles import _EXTENSION_NAME + +def glInitConservativeRasterPreSnapTrianglesNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/conservative_raster_underestimation.py b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/conservative_raster_underestimation.py new file mode 100644 index 00000000..531c39be --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/conservative_raster_underestimation.py @@ -0,0 +1,36 @@ +'''OpenGL extension NV.conservative_raster_underestimation + +This module customises the behaviour of the +OpenGL.raw.GL.NV.conservative_raster_underestimation to provide a more +Python-friendly API + +Overview (from the spec) + + The extension NV_conservative_raster provides a new rasterization mode + known as "Overestimated Conservative Rasterization", where any pixel that + is partially covered, even if no sample location is covered, is treated as + fully covered and a corresponding fragment will be shaded. There is also + an "Underestimated Conservative Rasterization" variant, where only the + pixels that are completely covered by the primitive are rasterized. + + This extension provides the underestimated conservative rasterization + information for each fragment in the fragment shader through a new + built-in gl_FragFullyCoveredNV. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/conservative_raster_underestimation.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.NV.conservative_raster_underestimation import * +from OpenGL.raw.GL.NV.conservative_raster_underestimation import _EXTENSION_NAME + +def glInitConservativeRasterUnderestimationNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/copy_depth_to_color.py b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/copy_depth_to_color.py new file mode 100644 index 00000000..28176d3c --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/copy_depth_to_color.py @@ -0,0 +1,58 @@ +'''OpenGL extension NV.copy_depth_to_color + +This module customises the behaviour of the +OpenGL.raw.GL.NV.copy_depth_to_color to provide a more +Python-friendly API + +Overview (from the spec) + + Some applications, especially systems for distributed OpenGL + rendering, would like to have a fast way of copying their depth + buffer into a color buffer; for example, this allows the depth buffer + to be scanned out, allowing downstream compositing operations. + + To do this operation in unextended OpenGL, the app must use + glReadPixels of GL_DEPTH_COMPONENT data, followed by glDrawPixels of + RGBA data. However, this typically will not provide adequate + performance. + + This extension provides a way to copy the depth data directly into + the color buffer, by adding two new options for the "type" parameter + of glCopyPixels: GL_DEPTH_STENCIL_TO_RGBA_NV and + GL_DEPTH_STENCIL_TO_BGRA_NV. + + Typically, OpenGL implementations support many more bits of depth + precision than color precision per channel. On many PC platforms, it + is common, for example, to have 24 bits of depth, 8 bits of stencil, + and 8 bits of red, green, blue, and alpha. + + In such a framebuffer configuration, the most effective way to copy + the data without this extension would be to perform a glReadPixels of + GL_UNSIGNED_INT_24_8_NV/GL_DEPTH_STENCIL_NV (using the existing + NV_packed_depth_stencil extension), followed by a glDrawPixels of + GL_UNSIGNED_INT_8_8_8_8/GL_RGBA or GL_BGRA data. This places the + depth data in the color channels and the stencil data in the alpha + channel. + + This extension's new operations concatenates these two operations, + providing a CopyPixels command that does both of these steps in one. + This provides a large performance speedup, since no pixel data must + be transfered across the bus. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/copy_depth_to_color.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.NV.copy_depth_to_color import * +from OpenGL.raw.GL.NV.copy_depth_to_color import _EXTENSION_NAME + +def glInitCopyDepthToColorNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/copy_image.py b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/copy_image.py new file mode 100644 index 00000000..39572758 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/copy_image.py @@ -0,0 +1,32 @@ +'''OpenGL extension NV.copy_image + +This module customises the behaviour of the +OpenGL.raw.GL.NV.copy_image to provide a more +Python-friendly API + +Overview (from the spec) + + This extension enables efficient image data transfer between image + objects (i.e. textures and renderbuffers) without the need to bind + the objects or otherwise configure the rendering pipeline. The + WGL and GLX versions allow copying between images in different + contexts, even if those contexts are in different sharelists or + even on different physical devices. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/copy_image.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.NV.copy_image import * +from OpenGL.raw.GL.NV.copy_image import _EXTENSION_NAME + +def glInitCopyImageNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/deep_texture3D.py b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/deep_texture3D.py new file mode 100644 index 00000000..b9ebb51c --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/deep_texture3D.py @@ -0,0 +1,32 @@ +'''OpenGL extension NV.deep_texture3D + +This module customises the behaviour of the +OpenGL.raw.GL.NV.deep_texture3D to provide a more +Python-friendly API + +Overview (from the spec) + + Some applications require 3D textures that have a significant number of + slices, but less resolution in width and height. In the current spec, the + maximum value for the size of all three dimensions is specified by a + single value. This extension adds a second set of limits against which 3D + textures can be checked if an application needs deeper textures than would + be allowed by the symmetric texture limits. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/deep_texture3D.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.NV.deep_texture3D import * +from OpenGL.raw.GL.NV.deep_texture3D import _EXTENSION_NAME + +def glInitDeepTexture3DNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/depth_buffer_float.py b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/depth_buffer_float.py new file mode 100644 index 00000000..4c45b1e2 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/depth_buffer_float.py @@ -0,0 +1,48 @@ +'''OpenGL extension NV.depth_buffer_float + +This module customises the behaviour of the +OpenGL.raw.GL.NV.depth_buffer_float to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides new texture internal formats whose depth + components are stored as 32-bit floating-point values, rather than the + normalized unsigned integers used in existing depth formats. + Floating-point depth textures support all the functionality supported for + fixed-point depth textures, including shadow mapping and rendering support + via EXT_framebuffer_object. Floating-point depth textures can store + values outside the range [0,1]. + + By default, OpenGL entry points taking depth values implicitly clamp the + values to the range [0,1]. This extension provides new DepthClear, + DepthRange, and DepthBoundsEXT entry points that allow applications to + specify depth values that are not clamped. + + Additionally, this extension provides new packed depth/stencil pixel + formats (see EXT_packed_depth_stencil) that have 64-bit pixels consisting + of a 32-bit floating-point depth value, 8 bits of stencil, and 24 unused + bites. A packed depth/stencil texture internal format is also provided. + + This extension does not provide support for WGL or GLX pixel formats with + floating-point depth buffers. The existing (but not commonly used) + WGL_EXT_depth_float extension could be used for this purpose. + + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/depth_buffer_float.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.NV.depth_buffer_float import * +from OpenGL.raw.GL.NV.depth_buffer_float import _EXTENSION_NAME + +def glInitDepthBufferFloatNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/depth_clamp.py b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/depth_clamp.py new file mode 100644 index 00000000..8a672bfe --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/depth_clamp.py @@ -0,0 +1,54 @@ +'''OpenGL extension NV.depth_clamp + +This module customises the behaviour of the +OpenGL.raw.GL.NV.depth_clamp to provide a more +Python-friendly API + +Overview (from the spec) + + Conventional OpenGL clips geometric primitives to a clip volume + with six faces, two of which are the near and far clip planes. + Clipping to the near and far planes of the clip volume ensures that + interpolated depth values (after the depth range transform) must be + in the [0,1] range. + + In some rendering applications such as shadow volumes, it is useful + to allow line and polygon primitives to be rasterized without + clipping the primitive to the near or far clip volume planes (side + clip volume planes clip normally). Without the near and far clip + planes, rasterization (pixel coverage determination) in X and Y + can proceed normally if we ignore the near and far clip planes. + The one major issue is that fragments of a primitive may extend + beyond the conventional window space depth range for depth values + (typically the range [0,1]). Rather than discarding fragments that + defy the window space depth range (effectively what near and far + plane clipping accomplish), the depth values can be clamped to the + current depth range. + + This extension provides exactly such functionality. This + functionality is useful to obviate the need for near plane capping + of stenciled shadow volumes. The functionality may also be useful + for rendering geometry "beyond" the far plane if an alternative + algorithm (rather than depth testing) for hidden surface removal is + applied to such geometry (specifically, the painter's algorithm). + Similar situations at the near clip plane can be avoided at the + near clip plane where apparently solid objects can be "seen through" + if they intersect the near clip plane. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/depth_clamp.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.NV.depth_clamp import * +from OpenGL.raw.GL.NV.depth_clamp import _EXTENSION_NAME + +def glInitDepthClampNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/draw_texture.py b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/draw_texture.py new file mode 100644 index 00000000..15b66ece --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/draw_texture.py @@ -0,0 +1,47 @@ +'''OpenGL extension NV.draw_texture + +This module customises the behaviour of the +OpenGL.raw.GL.NV.draw_texture to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides a new function, DrawTextureNV(), allowing + applications to draw an screen-aligned rectangle displaying some or all of + the contents of a two-dimensional or rectangle texture. Callers specify a + texture object, an optional sampler object, window coordinates of the + rectangle to draw, and texture coordinates corresponding to the corners of + the rectangle. For each fragment produced by the rectangle, DrawTextureNV + interpolates the texture coordinates, performs a texture lookup, and uses + the texture result as the fragment color. + + No shaders are used by DrawTextureNV; the results of the texture lookup + are used in lieu of a fragment shader output. The fragments generated are + processed by all per-fragment operations. In particular, + DrawTextureNV() fully supports blending and multisampling. + + While this functionality can be obtained in unextended OpenGL by drawing a + rectangle and using a fragment shader to do a texture lookup, + DrawTextureNV() is likely to have better power efficiency on + implementations supporting this extension. Additionally, use of this + extension frees the application developer from having to set up + specialized shaders, transformation matrices, vertex attributes, and + various other state in order to render the rectangle. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/draw_texture.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.NV.draw_texture import * +from OpenGL.raw.GL.NV.draw_texture import _EXTENSION_NAME + +def glInitDrawTextureNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/draw_vulkan_image.py b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/draw_vulkan_image.py new file mode 100644 index 00000000..ab22bb07 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/draw_vulkan_image.py @@ -0,0 +1,53 @@ +'''OpenGL extension NV.draw_vulkan_image + +This module customises the behaviour of the +OpenGL.raw.GL.NV.draw_vulkan_image to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides a new function, DrawVkImageNV(), allowing + applications to draw a screen-aligned rectangle displaying some or all of + the contents of a two-dimensional Vulkan VkImage. Callers specify a + Vulkan VkImage handle, an optional OpenGL sampler object, window + coordinates of the rectangle to draw, and texture coordinates corresponding + to the corners of the rectangle. For each fragment produced by the + rectangle, DrawVkImageNV interpolates the texture coordinates, performs + a texture lookup, and uses the texture result as the fragment color. + + No shaders are used by DrawVkImageNV; the results of the texture lookup + are used in lieu of a fragment shader output. The fragments generated are + processed by all per-fragment operations. In particular, + DrawVkImageNV() fully supports blending and multisampling. + + In order to synchronize between Vulkan and OpenGL there are three other + functions provided; WaitVkSemaphoreNV(), SignalVkSemaphoreNV() and + SignalVkFenceNV(). These allow OpenGL to wait for Vulkan to complete work + and also Vulkan to wait for OpenGL to complete work. Together OpenGL + and Vulkan can synchronize on the server without application + interation. + + Finally the function GetVkProcAddrNV() is provided to allow the OpenGL + context to query the Vulkan entry points directly and avoid having to + load them through the typical Vulkan loader. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/draw_vulkan_image.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.NV.draw_vulkan_image import * +from OpenGL.raw.GL.NV.draw_vulkan_image import _EXTENSION_NAME + +def glInitDrawVulkanImageNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glGetVkProcAddrNV.name size not checked against 'name' +glGetVkProcAddrNV=wrapper.wrapper(glGetVkProcAddrNV).setInputArraySize( + 'name', None +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/evaluators.py b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/evaluators.py new file mode 100644 index 00000000..378316d9 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/evaluators.py @@ -0,0 +1,103 @@ +'''OpenGL extension NV.evaluators + +This module customises the behaviour of the +OpenGL.raw.GL.NV.evaluators to provide a more +Python-friendly API + +Overview (from the spec) + + OpenGL evaluators provide applications with the capability to + specify polynomial or rational curves and surfaces using control + points relative to the Bezier basis. The curves and surfaces are + then drawn by evaluating the polynomials provided at various values + for the u parameter of a curve or the (u,v) parameters of a surface. + A tensor product formulation is used for the surfaces. + + For various historical reasons, evaluators have not been + particularly popular as an interface for drawing curves and surfaces. + This extension proposes a new interface for surfaces that provides a + number of significant enhancements to the functionality provided by + the original OpenGL evaluators. + + Many implementations never optimized evaluators, so applications + often implemented their own algorithms instead. This extension + relaxes some restrictions that make it difficult to optimize + evaluators. + + Also, new vertex attributes have been added to OpenGL through + extensions, including multiple sets of texture coordinates, a + secondary color, a fog coordinate, a vertex weight, and others. + The extensions which added these vertex attributes never bothered + to update the functionality of evaluators, since they were used so + little in the first place. In turn, evaluators have become more and + more out of date, making it even less likely that developers will + want to use them. Most of the attributes are not a big loss, but + support for multiple sets of texture coordinates would be absolutely + essential to developers considering the use of evaluators. + + OpenGL evaluators only support rectangular patches, not triangular + patches. Although triangular patches can be converted into + rectangular patches, direct support for triangular patches is likely + to be more efficient. + + The tessellation algorithm used is too inflexible for most purposes; + only the number of rows and columns can be specified. Adjacent + patches must then have identical numbers of rows and columns, or + severe cracking will occur. Ideally, a number of subdivisions could + be specified for all four sides of a rectangular patch and for all + three of a triangular patch. This extension goes one step further + and allows those numbers to be specified in floating-point, providing + a mechanism for smoothly changing the level of detail of the surface. + + Meshes evaluated with EvalMesh are required to match up exactly + with equivalent meshes evaluated with EvalCoord or EvalPoint. + This makes it difficult or impossible to use optimizations such as + forward differencing. + + Finally, little attention is given to some of the difficult problems + that can arise when multiple patches are drawn. Depending on the + way evaluators are implemented, and depending on the orientation of + edges, numerical accuracy problems can cause cracks to appear between + patches with the same boundary control points. This extension makes + guarantees that an edge shared between two patches will match up + exactly under certain conditions. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/evaluators.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.NV.evaluators import * +from OpenGL.raw.GL.NV.evaluators import _EXTENSION_NAME + +def glInitEvaluatorsNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glMapControlPointsNV.points size not checked against 'target,uorder,vorder' +glMapControlPointsNV=wrapper.wrapper(glMapControlPointsNV).setInputArraySize( + 'points', None +) +# INPUT glMapParameterivNV.params size not checked against 'target,pname' +glMapParameterivNV=wrapper.wrapper(glMapParameterivNV).setInputArraySize( + 'params', None +) +# INPUT glMapParameterfvNV.params size not checked against 'target,pname' +glMapParameterfvNV=wrapper.wrapper(glMapParameterfvNV).setInputArraySize( + 'params', None +) +glGetMapControlPointsNV=wrapper.wrapper(glGetMapControlPointsNV).setOutput( + 'points',size=_glgets._glget_size_mapping,pnameArg='target',orPassIn=True +) +# OUTPUT glGetMapParameterivNV.params COMPSIZE(target, pname) +# OUTPUT glGetMapParameterfvNV.params COMPSIZE(target, pname) +glGetMapAttribParameterivNV=wrapper.wrapper(glGetMapAttribParameterivNV).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetMapAttribParameterfvNV=wrapper.wrapper(glGetMapAttribParameterfvNV).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/explicit_multisample.py b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/explicit_multisample.py new file mode 100644 index 00000000..268bb61f --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/explicit_multisample.py @@ -0,0 +1,45 @@ +'''OpenGL extension NV.explicit_multisample + +This module customises the behaviour of the +OpenGL.raw.GL.NV.explicit_multisample to provide a more +Python-friendly API + +Overview (from the spec) + + In traditional multisample specs, the API only allows access to the samples + indirectly through methods such as coverage values and downsampled + readbacks. NV_explicit_multisample adds a set of new capabilities to allow + more precise control over the use of multisamples. Specifically, it adds: + + * A query in the API to query the location of samples within the pixel + + * An explicit control for the multisample sample mask to augment the + control provided by SampleCoverage + + * A new texture target to wrap a renderbuffer and allow a restricted class + of accesses to the samples + + * The ability to fetch a specific sample from a multisampled texture from + within a shader + + * A program option to enable the new behavior + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/explicit_multisample.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.NV.explicit_multisample import * +from OpenGL.raw.GL.NV.explicit_multisample import _EXTENSION_NAME + +def glInitExplicitMultisampleNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +glGetMultisamplefvNV=wrapper.wrapper(glGetMultisamplefvNV).setOutput( + 'val',size=(2,),orPassIn=True +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/fence.py b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/fence.py new file mode 100644 index 00000000..b0e3d54d --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/fence.py @@ -0,0 +1,62 @@ +'''OpenGL extension NV.fence + +This module customises the behaviour of the +OpenGL.raw.GL.NV.fence to provide a more +Python-friendly API + +Overview (from the spec) + + The goal of this extension is provide a finer granularity of + synchronizing GL command completion than offered by standard OpenGL, + which offers only two mechanisms for synchronization: Flush and Finish. + Since Flush merely assures the user that the commands complete in a + finite (though undetermined) amount of time, it is, thus, of only + modest utility. Finish, on the other hand, stalls CPU execution + until all pending GL commands have completed. This extension offers + a middle ground - the ability to "finish" a subset of the command + stream, and the ability to determine whether a given command has + completed or not. + + This extension introduces the concept of a "fence" to the OpenGL + command stream. Once the fence is inserted into the command stream, it + can be queried for a given condition - typically, its completion. + Moreover, the application may also request a partial Finish -- that is, + all commands prior to the fence will be forced to complete until control + is returned to the calling process. These new mechanisms allow for + synchronization between the host CPU and the GPU, which may be accessing + the same resources (typically memory). + + This extension is useful in conjunction with NV_vertex_array_range + to determine when vertex information has been pulled from the + vertex array range. Once a fence has been tested TRUE or finished, + all vertex indices issued before the fence must have been pulled. + This ensures that the vertex data memory corresponding to the issued + vertex indices can be safely modified (assuming no other outstanding + vertex indices are issued subsequent to the fence). + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/fence.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.NV.fence import * +from OpenGL.raw.GL.NV.fence import _EXTENSION_NAME + +def glInitFenceNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glDeleteFencesNV.fences size not checked against n +glDeleteFencesNV=wrapper.wrapper(glDeleteFencesNV).setInputArraySize( + 'fences', None +) +glGenFencesNV=wrapper.wrapper(glGenFencesNV).setOutput( + 'fences',size=lambda x:(x,),pnameArg='n',orPassIn=True +) +glGetFenceivNV=wrapper.wrapper(glGetFenceivNV).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/fill_rectangle.py b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/fill_rectangle.py new file mode 100644 index 00000000..f253dea1 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/fill_rectangle.py @@ -0,0 +1,32 @@ +'''OpenGL extension NV.fill_rectangle + +This module customises the behaviour of the +OpenGL.raw.GL.NV.fill_rectangle to provide a more +Python-friendly API + +Overview (from the spec) + + This extension adds a new PolygonMode setting where a triangle is + rasterized by computing and filling its axis-aligned screen-space bounding + box, disregarding the actual triangle edges. This can be useful for + drawing a rectangle without being split into two triangles with an + internal edge. It is also useful to minimize the number of primitives + that need to be drawn, particularly for a user-interface. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/fill_rectangle.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.NV.fill_rectangle import * +from OpenGL.raw.GL.NV.fill_rectangle import _EXTENSION_NAME + +def glInitFillRectangleNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/float_buffer.py b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/float_buffer.py new file mode 100644 index 00000000..9f487d7c --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/float_buffer.py @@ -0,0 +1,91 @@ +'''OpenGL extension NV.float_buffer + +This module customises the behaviour of the +OpenGL.raw.GL.NV.float_buffer to provide a more +Python-friendly API + +Overview (from the spec) + + This extension builds upon NV_fragment_program to provide a framebuffer + and texture format that allows fragment programs to read and write + unconstrained floating point data. + + In unextended OpenGL, most computations dealing with color or depth + buffers are typically constrained to operate on values in the range [0,1]. + Computational results are also typically clamped to the range [0,1]. + Color, texture, and depth buffers themselves also hold values mapped to + the range [0,1]. + + The NV_fragment_program extension provides a general computational model + that supports floating-point numbers constrained only by the precision of + the underlying data types. The quantites computed by fragment programs do + not necessarily correspond in number or in range to conventional + attributes such as RGBA colors or depth values. Because of the range and + precision constraints imposed by conventional fixed-point color buffers, + it may be difficult (if not impossible) to use them to implement certain + multi-pass algorithms. + + To enhance the extended range and precision available through fragment + programs, this extension provides floating-point RGBA color buffers that + can be used instead of conventional fixed-point RGBA color buffers. A + floating-point RGBA color buffer consists of one to four floating-point + components stored in the 16- or 32-bit floating-point formats (fp16 or + fp32) defined in the NV_half_float and NV_fragment_program extensions. + + When a floating-point color buffer is used, the results of fragment + programs, as written to the "x", "y", "z", and "w" components of the + o[COLR] or o[COLH] output registers, are written directly to the color + buffer without any clamping or modification. Certain per-fragment + operations are bypassed when rendering to floating-point color buffers. + + A floating-point color buffer can also be used as a texture map, either by + reading back the contents and then using conventional TexImage calls, or + by using the buffer directly via the ARB_render_texture extension or + the EXT_framebuffer_object extension. + + This extension has many uses. Some possible uses include: + + (1) Multi-pass algorithms with arbitrary intermediate results that + don't have to be artifically forced into the range [0,1]. In + addition, intermediate results can be written without having to + worry about out-of-range values. + + (2) Deferred shading algorithms where an expensive fragment program is + executed only after depth testing is fully complete. Instead, a + simple program is executed, which stores the parameters necessary + to produce a final result. After the entire scene is rendered, a + second pass is executed over the entire frame buffer to execute + the complex fragment program using the results written to the + floating-point color buffer in the first pass. This will save the + cost of applying complex fragment programs to fragments that will + not appear in the final image. + + (3) Use floating-point texture maps to evaluate functions with + arbitrary ranges. Arbitrary functions with a finite domain can be + approximated using a texture map holding sample results and + piecewise linear approximation. + + There are several significant limitations on the use of floating-point + color buffers. First, floating-point color buffers do not support frame + buffer blending. Second, floating-point texture maps do not support + mipmapping or any texture filtering other than NEAREST. Third, + floating-point texture maps must be 2D, and must use the + NV_texture_rectangle extension. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/float_buffer.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.NV.float_buffer import * +from OpenGL.raw.GL.NV.float_buffer import _EXTENSION_NAME + +def glInitFloatBufferNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/fog_distance.py b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/fog_distance.py new file mode 100644 index 00000000..becab6c5 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/fog_distance.py @@ -0,0 +1,56 @@ +'''OpenGL extension NV.fog_distance + +This module customises the behaviour of the +OpenGL.raw.GL.NV.fog_distance to provide a more +Python-friendly API + +Overview (from the spec) + + Ideally, the fog distance (used to compute the fog factor as + described in Section 3.10) should be computed as the per-fragment + Euclidean distance to the fragment center from the eye. In practice, + implementations "may choose to approximate the eye-coordinate + distance from the eye to each fragment center by abs(ze). Further, + [the fog factor] f need not be computed at each fragment, but may + be computed at each vertex and interpolated as other data are." + + This extension provides the application specific control over how + OpenGL computes the distance used in computing the fog factor. + + The extension supports three fog distance modes: "eye plane absolute", + where the fog distance is the absolute planar distance from the eye + plane (i.e., OpenGL's standard implementation allowance as cited above); + "eye plane", where the fog distance is the signed planar distance + from the eye plane; and "eye radial", where the fog distance is + computed as a Euclidean distance. In the case of the eye radial + fog distance mode, the distance may be computed per-vertex and then + interpolated per-fragment. + + The intent of this extension is to provide applications with better + control over the tradeoff between performance and fog quality. + The "eye planar" modes (signed or absolute) are straightforward + to implement with good performance, but scenes are consistently + under-fogged at the edges of the field of view. The "eye radial" + mode can provide for more accurate fog at the edges of the field of + view, but this assumes that either the eye radial fog distance is + computed per-fragment, or if the fog distance is computed per-vertex + and then interpolated per-fragment, then the scene must be + sufficiently tessellated. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/fog_distance.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.NV.fog_distance import * +from OpenGL.raw.GL.NV.fog_distance import _EXTENSION_NAME + +def glInitFogDistanceNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/fragment_coverage_to_color.py b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/fragment_coverage_to_color.py new file mode 100644 index 00000000..baeee22f --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/fragment_coverage_to_color.py @@ -0,0 +1,38 @@ +'''OpenGL extension NV.fragment_coverage_to_color + +This module customises the behaviour of the +OpenGL.raw.GL.NV.fragment_coverage_to_color to provide a more +Python-friendly API + +Overview (from the spec) + + This extension allows the fragment coverage value, represented as an + integer bitfield, to be substituted for a color output being written to a + single-component color buffer with integer components (e.g., R8UI). The + capability provided by this extension is different from simply writing the + gl_SampleMask fragment shader output in that the coverage value written to + the framebuffer is taken after alpha test, stencil test, and depth test, + as well as after the multisample fragment operations such as + alpha-to-coverage. + + This functionality may be useful for deferred rendering algorithms, where + the second pass needs to know which samples belong to which original + fragments. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/fragment_coverage_to_color.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.NV.fragment_coverage_to_color import * +from OpenGL.raw.GL.NV.fragment_coverage_to_color import _EXTENSION_NAME + +def glInitFragmentCoverageToColorNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/fragment_program.py b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/fragment_program.py new file mode 100644 index 00000000..98a461b3 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/fragment_program.py @@ -0,0 +1,99 @@ +'''OpenGL extension NV.fragment_program + +This module customises the behaviour of the +OpenGL.raw.GL.NV.fragment_program to provide a more +Python-friendly API + +Overview (from the spec) + + OpenGL mandates a certain set of configurable per-fragment computations + defining texture lookup, texture environment, color sum, and fog + operations. Each of these areas provide a useful but limited set of fixed + operations. For example, unextended OpenGL 1.2.1 provides only four + texture environment modes, color sum, and three fog modes. Many OpenGL + extensions have either improved existing functionality or introduced new + configurable fragment operations. While these extensions have enabled new + and interesting rendering effects, the set of effects is limited by the + set of special modes introduced by the extension. This lack of + flexibility is in contrast to the high-level of programmability of + general-purpose CPUs and other (frequently software-based) shading + languages. The purpose of this extension is to expose to the OpenGL + application writer an unprecedented degree of programmability in the + computation of final fragment colors and depth values. + + This extension provides a mechanism for defining fragment program + instruction sequences for application-defined fragment programs. When in + fragment program mode, a program is executed each time a fragment is + produced by rasterization. The inputs for the program are the attributes + (position, colors, texture coordinates) associated with the fragment and a + set of constant registers. A fragment program can perform mathematical + computations and texture lookups using arbitrary texture coordinates. The + results of a fragment program are new color and depth values for the + fragment. + + This extension defines a programming model including a 4-component vector + instruction set, 16- and 32-bit floating-point data types, and a + relatively large set of temporary registers. The programming model also + includes a condition code vector which can be used to mask register writes + at run-time or kill fragments altogether. The syntax, program + instructions, and general semantics are similar to those in the + NV_vertex_program and NV_vertex_program2 extensions, which provide for the + execution of an arbitrary program each time the GL receives a vertex. + + The fragment program execution environment is designed for efficient + hardware implementation and to support a wide variety of programs. By + design, the entire set of existing fragment programs defined by existing + OpenGL per-fragment computation extensions can be implemented using the + extension's programming model. + + The fragment program execution environment accesses textures via + arbitrarily computed texture coordinates. As such, there is no necessary + correspondence between the texture coordinates and texture maps previously + lumped into a single "texture unit". This extension separates the notion + of "texture coordinate sets" and "texture image units" (texture maps and + associated parameters), allowing implementations with a different number + of each. The initial implementation of this extension will support 8 + texture coordinate sets and 16 texture image units. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/fragment_program.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.NV.fragment_program import * +from OpenGL.raw.GL.NV.fragment_program import _EXTENSION_NAME + +def glInitFragmentProgramNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +glProgramNamedParameter4fNV=wrapper.wrapper(glProgramNamedParameter4fNV).setInputArraySize( + 'name', 1 +) +glProgramNamedParameter4fvNV=wrapper.wrapper(glProgramNamedParameter4fvNV).setInputArraySize( + 'name', 1 +).setInputArraySize( + 'v', 4 +) +glProgramNamedParameter4dNV=wrapper.wrapper(glProgramNamedParameter4dNV).setInputArraySize( + 'name', 1 +) +glProgramNamedParameter4dvNV=wrapper.wrapper(glProgramNamedParameter4dvNV).setInputArraySize( + 'name', 1 +).setInputArraySize( + 'v', 4 +) +glGetProgramNamedParameterfvNV=wrapper.wrapper(glGetProgramNamedParameterfvNV).setInputArraySize( + 'name', 1 +).setOutput( + 'params',size=(4,),orPassIn=True +) +glGetProgramNamedParameterdvNV=wrapper.wrapper(glGetProgramNamedParameterdvNV).setInputArraySize( + 'name', 1 +).setOutput( + 'params',size=(4,),orPassIn=True +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/fragment_program2.py b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/fragment_program2.py new file mode 100644 index 00000000..5fcfc5fa --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/fragment_program2.py @@ -0,0 +1,57 @@ +'''OpenGL extension NV.fragment_program2 + +This module customises the behaviour of the +OpenGL.raw.GL.NV.fragment_program2 to provide a more +Python-friendly API + +Overview (from the spec) + + This extension, like the NV_fragment_program_option extension, provides + additional fragment program functionality to extend the standard + ARB_fragment_program language and execution environment. ARB programs + wishing to use this added functionality need only add: + + OPTION NV_fragment_program2; + + to the beginning of their fragment programs. + + New functionality provided by this extension, above and beyond that + already provided by the NV_fragment_program_option extension, includes: + + + * structured branching support, including data-dependent IF tests, loops + supporting a fixed number of iterations, and a data-dependent loop + exit instruction (BRK), + + * subroutine calls, + + * instructions to perform vector normalization, divide vector components + by a scalar, and perform two-component dot products (with or without a + scalar add), + + * an instruction to perform a texture lookup with an explicit LOD, + + * a loop index register for indirect access into the texture coordinate + attribute array, and + + * a facing attribute that indicates whether the fragment is generated + from a front- or back-facing primitive. + + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/fragment_program2.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.NV.fragment_program2 import * +from OpenGL.raw.GL.NV.fragment_program2 import _EXTENSION_NAME + +def glInitFragmentProgram2NV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/fragment_program4.py b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/fragment_program4.py new file mode 100644 index 00000000..9f96ef61 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/fragment_program4.py @@ -0,0 +1,50 @@ +'''OpenGL extension NV.fragment_program4 + +This module customises the behaviour of the +OpenGL.raw.GL.NV.fragment_program4 to provide a more +Python-friendly API + +Overview (from the spec) + + This extension builds on the common assembly instruction set + infrastructure provided by NV_gpu_program4, adding fragment + program-specific features. + + This extension provides interpolation modifiers to fragment program + attributes allowing programs to specify that specified attributes be + flat-shaded (constant over a primitive), centroid-sampled (multisample + rendering), or interpolated linearly in screen space. The set of input + and output bindings provided includes all bindings supported by + ARB_fragment_program. Additional input bindings are provided to determine + whether fragments were generated by front- or back-facing primitives + ("fragment.facing"), to identify the individual primitive used to generate + the fragment ("primitive.id"), and to determine distances to user clip + planes ("fragment.clip[n]"). Additionally generic input attributes allow + a fragment program to receive a greater number of attributes from previous + pipeline stages than possible using only the pre-defined fixed-function + attributes. + + By and large, programs written to ARB_fragment_program can be ported + directly by simply changing the program header from "!!ARBfp1.0" to + "!!NVfp4.0", and then modifying instructions to take advantage of the + expanded feature set. There are a small number of areas where this + extension is not a functional superset of previous fragment program + extensions, which are documented in the NV_gpu_program4 specification. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/fragment_program4.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.NV.fragment_program4 import * +from OpenGL.raw.GL.NV.fragment_program4 import _EXTENSION_NAME + +def glInitFragmentProgram4NV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/fragment_program_option.py b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/fragment_program_option.py new file mode 100644 index 00000000..8c8b308e --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/fragment_program_option.py @@ -0,0 +1,56 @@ +'''OpenGL extension NV.fragment_program_option + +This module customises the behaviour of the +OpenGL.raw.GL.NV.fragment_program_option to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides additional fragment program functionality + to extend the standard ARB_fragment_program language and execution + environment. ARB programs wishing to use this added functionality + need only add: + + OPTION NV_fragment_program; + + to the beginning of their fragment programs. + + The functionality provided by this extension, which is roughly + equivalent to that provided by the NV_fragment_program extension, + includes: + + * increased control over precision in arithmetic computations and + storage, + + * data-dependent conditional writemasks, + + * an absolute value operator on scalar and swizzled operand loads, + + * instructions to compute partial derivatives, and perform texture + lookups using specified partial derivatives, + + * fully orthogonal "set on" instructions, + + * instructions to compute reflection vector and perform a 2D + coordinate transform, and + + * instructions to pack and unpack multiple quantities into a single + component. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/fragment_program_option.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.NV.fragment_program_option import * +from OpenGL.raw.GL.NV.fragment_program_option import _EXTENSION_NAME + +def glInitFragmentProgramOptionNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/fragment_shader_barycentric.py b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/fragment_shader_barycentric.py new file mode 100644 index 00000000..83c28df4 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/fragment_shader_barycentric.py @@ -0,0 +1,32 @@ +'''OpenGL extension NV.fragment_shader_barycentric + +This module customises the behaviour of the +OpenGL.raw.GL.NV.fragment_shader_barycentric to provide a more +Python-friendly API + +Overview (from the spec) + + This extension advertises OpenGL support for the OpenGL Shading Language + (GLSL) extension "NV_fragment_shader_barycentric", which provides fragment + shader built-in variables holding barycentric weight vectors that identify + the location of the fragment within its primitive. Additionally, the GLSL + extension allows fragment the ability to read raw attribute values for + each of the vertices of the primitive that produced the fragment. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/fragment_shader_barycentric.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.NV.fragment_shader_barycentric import * +from OpenGL.raw.GL.NV.fragment_shader_barycentric import _EXTENSION_NAME + +def glInitFragmentShaderBarycentricNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/fragment_shader_interlock.py b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/fragment_shader_interlock.py new file mode 100644 index 00000000..19082f3f --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/fragment_shader_interlock.py @@ -0,0 +1,79 @@ +'''OpenGL extension NV.fragment_shader_interlock + +This module customises the behaviour of the +OpenGL.raw.GL.NV.fragment_shader_interlock to provide a more +Python-friendly API + +Overview (from the spec) + + In unextended OpenGL 4.3 or OpenGL ES 3.1, applications may produce a + large number of fragment shader invocations that perform loads and + stores to memory using image uniforms, atomic counter uniforms, + buffer variables, or pointers. The order in which loads and stores + to common addresses are performed by different fragment shader + invocations is largely undefined. For algorithms that use shader + writes and touch the same pixels more than once, one or more of the + following techniques may be required to ensure proper execution ordering: + + * inserting Finish or WaitSync commands to drain the pipeline between + different "passes" or "layers"; + + * using only atomic memory operations to write to shader memory (which + may be relatively slow and limits how memory may be updated); or + + * injecting spin loops into shaders to prevent multiple shader + invocations from touching the same memory concurrently. + + This extension provides new GLSL built-in functions + beginInvocationInterlockNV() and endInvocationInterlockNV() that delimit a + critical section of fragment shader code. For pairs of shader invocations + with "overlapping" coverage in a given pixel, the OpenGL implementation + will guarantee that the critical section of the fragment shader will be + executed for only one fragment at a time. + + There are four different interlock modes supported by this extension, + which are identified by layout qualifiers. The qualifiers + "pixel_interlock_ordered" and "pixel_interlock_unordered" provides mutual + exclusion in the critical section for any pair of fragments corresponding + to the same pixel. When using multisampling, the qualifiers + "sample_interlock_ordered" and "sample_interlock_unordered" only provide + mutual exclusion for pairs of fragments that both cover at least one + common sample in the same pixel; these are recommended for performance if + shaders use per-sample data structures. + + Additionally, when the "pixel_interlock_ordered" or + "sample_interlock_ordered" layout qualifier is used, the interlock also + guarantees that the critical section for multiple shader invocations with + "overlapping" coverage will be executed in the order in which the + primitives were processed by the GL. Such a guarantee is useful for + applications like blending in the fragment shader, where an application + requires that fragment values to be composited in the framebuffer in + primitive order. + + This extension can be useful for algorithms that need to access per-pixel + data structures via shader loads and stores. Such algorithms using this + extension can access such data structures in the critical section without + worrying about other invocations for the same pixel accessing the data + structures concurrently. Additionally, the ordering guarantees are useful + for cases where the API ordering of fragments is meaningful. For example, + applications may be able to execute programmable blending operations in + the fragment shader, where the destination buffer is read via image loads + and the final value is written via image stores. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/fragment_shader_interlock.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.NV.fragment_shader_interlock import * +from OpenGL.raw.GL.NV.fragment_shader_interlock import _EXTENSION_NAME + +def glInitFragmentShaderInterlockNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/framebuffer_mixed_samples.py b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/framebuffer_mixed_samples.py new file mode 100644 index 00000000..a107edc3 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/framebuffer_mixed_samples.py @@ -0,0 +1,79 @@ +'''OpenGL extension NV.framebuffer_mixed_samples + +This module customises the behaviour of the +OpenGL.raw.GL.NV.framebuffer_mixed_samples to provide a more +Python-friendly API + +Overview (from the spec) + + This extension allows multisample rendering with a raster and + depth/stencil sample count that is larger than the color sample count. + Rasterization and the results of the depth and stencil tests together + determine the portion of a pixel that is "covered". It can be useful to + evaluate coverage at a higher frequency than color samples are stored. + This coverage is then "reduced" to a collection of covered color samples, + each having an opacity value corresponding to the fraction of the color + sample covered. The opacity can optionally be blended into individual + color samples. + + In the current hardware incarnation both depth and stencil testing are + supported with mixed samples, although the API accommodates supporting + only one or the other. + + Rendering with fewer color samples than depth/stencil samples can greatly + reduce the amount of memory and bandwidth consumed by the color buffer. + However, converting the coverage values into opacity can introduce + artifacts where triangles share edges and may not be suitable for normal + triangle mesh rendering. + + One expected use case for this functionality is Stencil-then-Cover path + rendering (NV_path_rendering). The stencil step determines the coverage + (in the stencil buffer) for an entire path at the higher sample frequency, + and then the cover step can draw the path into the lower frequency color + buffer using the coverage information to antialias path edges. With this + two-step process, internal edges are fully covered when antialiasing is + applied and there is no corruption on these edges. + + The key features of this extension are: + + - It allows a framebuffer object to be considered complete when its depth + or stencil samples are a multiple of the number of color samples. + + - It redefines SAMPLES to be the number of depth/stencil samples (if any); + otherwise, it uses the number of color samples. SAMPLE_BUFFERS is one if + there are multisample depth/stencil attachments. Multisample + rasterization and multisample fragment ops are allowed if SAMPLE_BUFFERS + is one. + + - It replaces several error checks involving SAMPLE_BUFFERS by error + checks directly referencing the number of samples in the relevant + attachments. + + - A coverage reduction step is added to Per-Fragment Operations which + converts a set of covered raster/depth/stencil samples to a set of + covered color samples. The coverage reduction step also includes an + optional coverage modulation step, multiplying color values by a + fractional opacity corresponding to the number of associated + raster/depth/stencil samples covered. + + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/framebuffer_mixed_samples.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.NV.framebuffer_mixed_samples import * +from OpenGL.raw.GL.NV.framebuffer_mixed_samples import _EXTENSION_NAME + +def glInitFramebufferMixedSamplesNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glCoverageModulationTableNV.v size not checked against n +glCoverageModulationTableNV=wrapper.wrapper(glCoverageModulationTableNV).setInputArraySize( + 'v', None +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/framebuffer_multisample_coverage.py b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/framebuffer_multisample_coverage.py new file mode 100644 index 00000000..65e3f78f --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/framebuffer_multisample_coverage.py @@ -0,0 +1,45 @@ +'''OpenGL extension NV.framebuffer_multisample_coverage + +This module customises the behaviour of the +OpenGL.raw.GL.NV.framebuffer_multisample_coverage to provide a more +Python-friendly API + +Overview (from the spec) + + This extension extends the EXT_framebuffer_multisample + specification by providing a new function, + RenderBufferStorageMultisampleCoverageNV, that distinguishes + between color samples and coverage samples. + + EXT_framebuffer_multisample introduced the function + RenderbufferStorageMultisampleEXT as a method of defining the + storage parameters for a multisample render buffer. This function + takes a parameter. Using rules provided by the + specification, the parameter is resolved to an actual + number of samples that is supported by the underlying hardware. + EXT_framebuffer_multisample does not specify whether + refers to coverage samples or color samples. + + This extension adds the function + RenderbufferStorageMultisamplCoverageNV, which takes a + parameter as well as a parameter. + These two parameters give developers more fine grained control over + the quality of multisampled images. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/framebuffer_multisample_coverage.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.NV.framebuffer_multisample_coverage import * +from OpenGL.raw.GL.NV.framebuffer_multisample_coverage import _EXTENSION_NAME + +def glInitFramebufferMultisampleCoverageNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/geometry_program4.py b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/geometry_program4.py new file mode 100644 index 00000000..481e6a50 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/geometry_program4.py @@ -0,0 +1,67 @@ +'''OpenGL extension NV.geometry_program4 + +This module customises the behaviour of the +OpenGL.raw.GL.NV.geometry_program4 to provide a more +Python-friendly API + +Overview (from the spec) + + NV_geometry_program4 defines a new type of program available to be run on + the GPU, called a geometry program. Geometry programs are run on full + primitives after vertices are transformed, but prior to flat shading and + clipping. + + A geometry program begins with a single primitive - a point, line, or + triangle. Quads and polygons are allowed, but are decomposed into + individual triangles prior to geometry program execution. It can read the + attributes of any of the vertex in the primitive and use them to generate + new primitives. A geometry program has a fixed output primitive type, + either a point, a line strip, or a triangle strip. It emits vertices + (using the EMIT opcode) to define the output primitive. The attributes of + emitted vertices are specified by writing to the same set of result + bindings (e.g., "result.position") provided for vertex programs. + Additionally, a geometry program can emit multiple disconnected primitives + by using the ENDPRIM opcode, which is roughly equivalent to calling End + and then Begin again. The primitives emitted by the geometry program are + then clipped and then processed like an equivalent OpenGL primitive + specified by the application. + + This extension provides four additional primitive types: lines with + adjacency, line strips with adjacency, separate triangles with adjacency, + and triangle strips with adjacency. Some of the vertices specified in + these new primitive types are not part of the ordinary primitives. + Instead, they represent neighboring vertices that are adjacent to the two + line segment end points (lines/strips) or the three triangle edges + (triangles/tstrips). These "adjacency" vertices can be accessed by + geometry programs and used to match up the outputs of the geometry program + with those of neighboring primitives. + + Additionally, geometry programs allow for layered rendering, where entire + three-dimensional, cube map, or array textures (EXT_texture_array) can be + bound to the current framebuffer. Geometry programs can use the + "result.layer" binding to select a layer or cube map face to render to. + Each primitive emitted by such a geometry program is rendered to the layer + taken from its provoking vertex. + + Since geometry programs expect a specific input primitive type, an error + will occur if the application presents primtives of a different type. For + example, if an enabled geometry program expects points, an error will + occur at Begin() time, if a primitive mode of TRIANGLES is specified. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/geometry_program4.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.NV.geometry_program4 import * +from OpenGL.raw.GL.NV.geometry_program4 import _EXTENSION_NAME + +def glInitGeometryProgram4NV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/geometry_shader4.py b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/geometry_shader4.py new file mode 100644 index 00000000..828d66b4 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/geometry_shader4.py @@ -0,0 +1,37 @@ +'''OpenGL extension NV.geometry_shader4 + +This module customises the behaviour of the +OpenGL.raw.GL.NV.geometry_shader4 to provide a more +Python-friendly API + +Overview (from the spec) + + This extension builds upon the EXT_geometry_shader4 specification to + provide two additional capabilities: + + * Support for QUADS, QUAD_STRIP, and POLYGON primitive types when + geometry shaders are enabled. Such primitives will be tessellated + into individual triangles. + + * Setting the value of GEOMETRY_VERTICES_OUT_EXT will take effect + immediately. It is not necessary to link the program object in + order for this change to take effect, as is the case in the EXT + version of this extension. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/geometry_shader4.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.NV.geometry_shader4 import * +from OpenGL.raw.GL.NV.geometry_shader4 import _EXTENSION_NAME + +def glInitGeometryShader4NV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/geometry_shader_passthrough.py b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/geometry_shader_passthrough.py new file mode 100644 index 00000000..494103ce --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/geometry_shader_passthrough.py @@ -0,0 +1,99 @@ +'''OpenGL extension NV.geometry_shader_passthrough + +This module customises the behaviour of the +OpenGL.raw.GL.NV.geometry_shader_passthrough to provide a more +Python-friendly API + +Overview (from the spec) + + Geometry shaders provide the ability for applications to process each + primitive sent through the GL using a programmable shader. While geometry + shaders can be used to perform a number of different operations, including + subdividing primitives and changing primitive type, one common use case + treats geometry shaders as largely "passthrough". In this use case, the + bulk of the geometry shader code simply copies inputs from each vertex of + the input primitive to corresponding outputs in the vertices of the output + primitive. Such shaders might also compute values for additional built-in + or user-defined per-primitive attributes (e.g., gl_Layer) to be assigned + to all the vertices of the output primitive. + + This extension provides a shading language abstraction to express such + shaders without requiring explicit logic to manually copy attributes from + input vertices to output vertices. For example, consider the following + simple geometry shader in unextended OpenGL: + + layout(triangles) in; + layout(triangle_strip) out; + layout(max_vertices=3) out; + + in Inputs { + vec2 texcoord; + vec4 baseColor; + } v_in[]; + out Outputs { + vec2 texcoord; + vec4 baseColor; + }; + + void main() + { + int layer = compute_layer(); + for (int i = 0; i < 3; i++) { + gl_Position = gl_in[i].gl_Position; + texcoord = v_in[i].texcoord; + baseColor = v_in[i].baseColor; + gl_Layer = layer; + EmitVertex(); + } + } + + In this shader, the inputs "gl_Position", "Inputs.texcoord", and + "Inputs.baseColor" are simply copied from the input vertex to the + corresponding output vertex. The only "interesting" work done by the + geometry shader is computing and emitting a gl_Layer value for the + primitive. + + The following geometry shader, using this extension, is equivalent: + + #extension GL_NV_geometry_shader_passthrough : require + + layout(triangles) in; + // No output primitive layout qualifiers required. + + // Redeclare gl_PerVertex to pass through "gl_Position". + layout(passthrough) in gl_PerVertex { + vec4 gl_Position; + } gl_in[]; + + // Declare "Inputs" with "passthrough" to automatically copy members. + layout(passthrough) in Inputs { + vec2 texcoord; + vec4 baseColor; + } v_in[]; + + // No output block declaration required. + + void main() + { + // The shader simply computes and writes gl_Layer. We don't + // loop over three vertices or call EmitVertex(). + gl_Layer = compute_layer(); + } + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/geometry_shader_passthrough.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.NV.geometry_shader_passthrough import * +from OpenGL.raw.GL.NV.geometry_shader_passthrough import _EXTENSION_NAME + +def glInitGeometryShaderPassthroughNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/gpu_multicast.py b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/gpu_multicast.py new file mode 100644 index 00000000..70c19aae --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/gpu_multicast.py @@ -0,0 +1,56 @@ +'''OpenGL extension NV.gpu_multicast + +This module customises the behaviour of the +OpenGL.raw.GL.NV.gpu_multicast to provide a more +Python-friendly API + +Overview (from the spec) + + This extension enables novel multi-GPU rendering techniques by providing application control + over a group of linked GPUs with identical hardware configuration. + + Multi-GPU rendering techniques fall into two categories: implicit and explicit. Existing + explicit approaches like WGL_NV_gpu_affinity have two main drawbacks: CPU overhead and + application complexity. An application must manage one context per GPU and multi-pump the API + stream. Implicit multi-GPU rendering techniques avoid these issues by broadcasting rendering + from one context to multiple GPUs. Common implicit approaches include alternate-frame + rendering (AFR), split-frame rendering (SFR) and multi-GPU anti-aliasing. They each have + drawbacks. AFR scales nicely but interacts poorly with inter-frame dependencies. SFR can + improve latency but has challenges with offscreen rendering and scaling of vertex processing. + With multi-GPU anti-aliasing, each GPU renders the same content with alternate sample + positions and the driver blends the result to improve quality. This also has issues with + offscreen rendering and can conflict with other anti-aliasing techniques. + + These issues with implicit multi-GPU rendering all have the same root cause: the driver lacks + adequate knowledge to accelerate every application. To resolve this, NV_gpu_multicast + provides fine-grained, explicit application control over multiple GPUs with a single context. + + Key points: + + - One context controls multiple GPUs. Every GPU in the linked group can access every object. + + - Rendering is broadcast. Each draw is repeated across all GPUs in the linked group. + + - Each GPU gets its own instance of all framebuffers, allowing individualized output for each + GPU. Input data can be customized for each GPU using buffers created with the storage flag, + PER_GPU_STORAGE_BIT_NV and a new API, MulticastBufferSubDataNV. + + - New interfaces provide mechanisms to transfer textures and buffers from one GPU to another. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/gpu_multicast.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.NV.gpu_multicast import * +from OpenGL.raw.GL.NV.gpu_multicast import _EXTENSION_NAME + +def glInitGpuMulticastNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/gpu_program4.py b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/gpu_program4.py new file mode 100644 index 00000000..84e86f0f --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/gpu_program4.py @@ -0,0 +1,100 @@ +'''OpenGL extension NV.gpu_program4 + +This module customises the behaviour of the +OpenGL.raw.GL.NV.gpu_program4 to provide a more +Python-friendly API + +Overview (from the spec) + + This specification documents the common instruction set and basic + functionality provided by NVIDIA's 4th generation of assembly instruction + sets supporting programmable graphics pipeline stages. + + The instruction set builds upon the basic framework provided by the + ARB_vertex_program and ARB_fragment_program extensions to expose + considerably more capable hardware. In addition to new capabilities for + vertex and fragment programs, this extension provides a new program type + (geometry programs) further described in the NV_geometry_program4 + specification. + + NV_gpu_program4 provides a unified instruction set -- all instruction set + features are available for all program types, except for a small number of + features that make sense only for a specific program type. It provides + fully capable signed and unsigned integer data types, along with a set of + arithmetic, logical, and data type conversion instructions capable of + operating on integers. It also provides a uniform set of structured + branching constructs (if tests, loops, and subroutines) that fully support + run-time condition testing. + + This extension provides several new texture mapping capabilities. Shadow + cube maps are supported, where cube map faces can encode depth values. + Texture lookup instructions can include an immediate texel offset, which + can assist in advanced filtering. New instructions are provided to fetch + a single texel by address in a texture map (TXF) and query the size of a + specified texture level (TXQ). + + By and large, vertex and fragment programs written to ARB_vertex_program + and ARB_fragment_program can be ported directly by simply changing the + program header from "!!ARBvp1.0" or "!!ARBfp1.0" to "!!NVvp4.0" or + "!!NVfp4.0", and then modifying the code to take advantage of the expanded + feature set. There are a small number of areas where this extension is + not a functional superset of previous vertex program extensions, which are + documented in this specification. + + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/gpu_program4.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.NV.gpu_program4 import * +from OpenGL.raw.GL.NV.gpu_program4 import _EXTENSION_NAME + +def glInitGpuProgram4NV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +glProgramLocalParameterI4ivNV=wrapper.wrapper(glProgramLocalParameterI4ivNV).setInputArraySize( + 'params', 4 +) +# INPUT glProgramLocalParametersI4ivNV.params size not checked against count*4 +glProgramLocalParametersI4ivNV=wrapper.wrapper(glProgramLocalParametersI4ivNV).setInputArraySize( + 'params', None +) +glProgramLocalParameterI4uivNV=wrapper.wrapper(glProgramLocalParameterI4uivNV).setInputArraySize( + 'params', 4 +) +# INPUT glProgramLocalParametersI4uivNV.params size not checked against count*4 +glProgramLocalParametersI4uivNV=wrapper.wrapper(glProgramLocalParametersI4uivNV).setInputArraySize( + 'params', None +) +glProgramEnvParameterI4ivNV=wrapper.wrapper(glProgramEnvParameterI4ivNV).setInputArraySize( + 'params', 4 +) +# INPUT glProgramEnvParametersI4ivNV.params size not checked against count*4 +glProgramEnvParametersI4ivNV=wrapper.wrapper(glProgramEnvParametersI4ivNV).setInputArraySize( + 'params', None +) +glProgramEnvParameterI4uivNV=wrapper.wrapper(glProgramEnvParameterI4uivNV).setInputArraySize( + 'params', 4 +) +# INPUT glProgramEnvParametersI4uivNV.params size not checked against count*4 +glProgramEnvParametersI4uivNV=wrapper.wrapper(glProgramEnvParametersI4uivNV).setInputArraySize( + 'params', None +) +glGetProgramLocalParameterIivNV=wrapper.wrapper(glGetProgramLocalParameterIivNV).setOutput( + 'params',size=(4,),orPassIn=True +) +glGetProgramLocalParameterIuivNV=wrapper.wrapper(glGetProgramLocalParameterIuivNV).setOutput( + 'params',size=(4,),orPassIn=True +) +glGetProgramEnvParameterIivNV=wrapper.wrapper(glGetProgramEnvParameterIivNV).setOutput( + 'params',size=(4,),orPassIn=True +) +glGetProgramEnvParameterIuivNV=wrapper.wrapper(glGetProgramEnvParameterIuivNV).setOutput( + 'params',size=(4,),orPassIn=True +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/gpu_program5.py b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/gpu_program5.py new file mode 100644 index 00000000..945e7208 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/gpu_program5.py @@ -0,0 +1,149 @@ +'''OpenGL extension NV.gpu_program5 + +This module customises the behaviour of the +OpenGL.raw.GL.NV.gpu_program5 to provide a more +Python-friendly API + +Overview (from the spec) + + This specification documents the common instruction set and basic + functionality provided by NVIDIA's 5th generation of assembly instruction + sets supporting programmable graphics pipeline stages. + + The instruction set builds upon the basic framework provided by the + ARB_vertex_program and ARB_fragment_program extensions to expose + considerably more capable hardware. In addition to new capabilities for + vertex and fragment programs, this extension provides new functionality + for geometry programs as originally described in the NV_geometry_program4 + specification, and serves as the basis for the new tessellation control + and evaluation programs described in the NV_tessellation_program5 + extension. + + Programs using the functionality provided by this extension should begin + with the program headers "!!NVvp5.0" (vertex programs), "!!NVtcp5.0" + (tessellation control programs), "!!NVtep5.0" (tessellation evaluation + programs), "!!NVgp5.0" (geometry programs), and "!!NVfp5.0" (fragment + programs). + + This extension provides a variety of new features, including: + + * support for 64-bit integer operations; + + * the ability to dynamically index into an array of texture units or + program parameter buffers; + + * extending texel offset support to allow loading texel offsets from + regular integer operands computed at run-time, instead of requiring + that the offsets be constants encoded in texture instructions; + + * extending TXG (texture gather) support to return the 2x2 footprint + from any component of the texture image instead of always returning + the first (x) component; + + * extending TXG to support shadow comparisons in conjunction with a + depth texture, via the SHADOW* targets; + + * further extending texture gather support to provide a new opcode + (TXGO) that applies a separate texel offset vector to each of the four + samples returned by the instruction; + + * bit manipulation instructions, including ones to find the position of + the most or least significant set bit, bitfield insertion and + extraction, and bit reversal; + + * a general data conversion instruction (CVT) supporting conversion + between any two data types supported by this extension; and + + * new instructions to compute the composite of a set of boolean + conditions a group of shader threads. + + This extension also provides some new capabilities for individual program + types, including: + + * support for instanced geometry programs, where a geometry program may + be run multiple times for each primitive; + + * support for emitting vertices in a geometry program where each vertex + emitted may be directed at a specified vertex stream and captured + using the ARB_transform_feedback3 extension; + + * support for interpolating an attribute at a programmable offset + relative to the pixel center (IPAO), at a programmable sample number + (IPAS), or at the fragment's centroid location (IPAC) in a fragment + program; + + * support for reading a mask of covered samples in a fragment program; + + * support for reading a point sprite coordinate directly in a fragment + program, without overriding a texture coordinate; + + * support for reading patch primitives and per-patch attributes + (introduced by ARB_tessellation_shader) in a geometry program; and + + * support for multiple output vectors for a single color output in a + fragment program (as used by ARB_blend_func_extended). + + This extension also provides optional support for 64-bit-per-component + variables and 64-bit floating-point arithmetic. These features are + supported if and only if "NV_gpu_program_fp64" is found in the extension + string. + + This extension incorporates the memory access operations from the + NV_shader_buffer_load and NV_parameter_buffer_object2 extensions, + originally built as add-ons to NV_gpu_program4. It also provides the + following new capabilities: + + * support for the features without requiring a separate OPTION keyword; + + * support for indexing into an array of constant buffers using the LDC + opcode added by NV_parameter_buffer_object2; + + * support for storing into buffer objects at a specified GPU address + using the STORE opcode, an allowing applications to create READ_WRITE + and WRITE_ONLY mappings when making a buffer object resident using the + API mechanisms in the NV_shader_buffer_store extension; + + * storage instruction modifiers to allow loading and storing 64-bit + component values; + + * support for atomic memory transactions using the ATOM opcode, where + the instruction atomically reads the memory pointed to by a pointer, + performs a specified computation, stores the results of that + computation, and returns the original value read; + + * support for memory barrier transactions using the MEMBAR opcode, which + ensures that all memory stores issued prior to the opcode complete + prior to any subsequent memory transactions; and + + * a fragment program option to specify that depth and stencil tests are + performed prior to fragment program execution. + + Additionally, the assembly program languages supported by this extension + include support for reading, writing, and performing atomic memory + operations on texture image data using the opcodes and mechanisms + documented in the "Dependencies on NV_gpu_program5" section of the + EXT_shader_image_load_store extension. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/gpu_program5.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.NV.gpu_program5 import * +from OpenGL.raw.GL.NV.gpu_program5 import _EXTENSION_NAME + +def glInitGpuProgram5NV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glProgramSubroutineParametersuivNV.params size not checked against count +glProgramSubroutineParametersuivNV=wrapper.wrapper(glProgramSubroutineParametersuivNV).setInputArraySize( + 'params', None +) +glGetProgramSubroutineParameteruivNV=wrapper.wrapper(glGetProgramSubroutineParameteruivNV).setOutput( + 'param',size=_glgets._glget_size_mapping,pnameArg='target',orPassIn=True +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/gpu_program5_mem_extended.py b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/gpu_program5_mem_extended.py new file mode 100644 index 00000000..ff462a3a --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/gpu_program5_mem_extended.py @@ -0,0 +1,62 @@ +'''OpenGL extension NV.gpu_program5_mem_extended + +This module customises the behaviour of the +OpenGL.raw.GL.NV.gpu_program5_mem_extended to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides a new set of storage modifiers that can be used by + NV_gpu_program5 assembly program instructions loading from or storing to + various forms of GPU memory. In particular, we provide support for loads + and stores using the storage modifiers: + + .F16X2 .F16X4 .F16 (for 16-bit floating-point scalars/vectors) + .S8X2 .S8X4 (for 8-bit signed integer vectors) + .S16X2 .S16X4 (for 16-bit signed integer vectors) + .U8X2 .U8X4 (for 8-bit unsigned integer vectors) + .U16X2 .U16X4 (for 16-bit unsigned integer vectors) + + These modifiers are allowed for the following load/store instructions: + + LDC Load from constant buffer + + LOAD Global load + STORE Global store + + LOADIM Image load (via EXT_shader_image_load_store) + STOREIM Image store (via EXT_shader_image_load_store) + + LDB Load from storage buffer (via + NV_shader_storage_buffer_object) + STB Store to storage buffer (via + NV_shader_storage_buffer_object) + + LDS Load from shared memory (via NV_compute_program5) + STS Store to shared memory (via NV_compute_program5) + + For assembly programs prior to this extension, it was necessary to access + memory using packed types and then unpack with additional shader + instructions. + + Similar capabilities have already been provided in the OpenGL Shading + Language (GLSL) via the NV_gpu_shader5 extension, using the extended data + types provided there (e.g., "float16_t", "u8vec4", "s16vec2"). + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/gpu_program5_mem_extended.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.NV.gpu_program5_mem_extended import * +from OpenGL.raw.GL.NV.gpu_program5_mem_extended import _EXTENSION_NAME + +def glInitGpuProgram5MemExtendedNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/gpu_shader5.py b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/gpu_shader5.py new file mode 100644 index 00000000..55255db2 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/gpu_shader5.py @@ -0,0 +1,154 @@ +'''OpenGL extension NV.gpu_shader5 + +This module customises the behaviour of the +OpenGL.raw.GL.NV.gpu_shader5 to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides a set of new features to the OpenGL Shading + Language and related APIs to support capabilities of new GPUs. Shaders + using the new functionality provided by this extension should enable this + functionality via the construct + + #extension GL_NV_gpu_shader5 : require (or enable) + + This extension was developed concurrently with the ARB_gpu_shader5 + extension, and provides a superset of the features provided there. The + features common to both extensions are documented in the ARB_gpu_shader5 + specification; this document describes only the addition language features + not available via ARB_gpu_shader5. A shader that enables this extension + via an #extension directive also implicitly enables the common + capabilities provided by ARB_gpu_shader5. + + In addition to the capabilities of ARB_gpu_shader5, this extension + provides a variety of new features for all shader types, including: + + * support for a full set of 8-, 16-, 32-, and 64-bit scalar and vector + data types, including uniform API, uniform buffer object, and shader + input and output support; + + * the ability to aggregate samplers into arrays, index these arrays with + arbitrary expressions, and not require that non-constant indices be + uniform across all shader invocations; + + * new built-in functions to pack and unpack 64-bit integer types into a + two-component 32-bit integer vector; + + * new built-in functions to pack and unpack 32-bit unsigned integer + types into a two-component 16-bit floating-point vector; + + * new built-in functions to convert double-precision floating-point + values to or from their 64-bit integer bit encodings; + + * new built-in functions to compute the composite of a set of boolean + conditions a group of shader threads; + + * vector relational functions supporting comparisons of vectors of 8-, + 16-, and 64-bit integer types or 16-bit floating-point types; and + + * extending texel offset support to allow loading texel offsets from + regular integer operands computed at run-time, except for lookups with + gradients (textureGrad*). + + This extension also provides additional support for processing patch + primitives (introduced by ARB_tessellation_shader). + ARB_tessellation_shader requires the use of a tessellation evaluation + shader when processing patches, which means that patches will never + survive past the tessellation pipeline stage. This extension lifts that + restriction, and allows patches to proceed further in the pipeline and be + used + + * as input to a geometry shader, using a new "patches" layout qualifier; + + * as input to transform feedback; + + * by fixed-function rasterization stages, in which case the patches are + drawn as independent points. + + Additionally, it allows geometry shaders to read per-patch attributes + written by a tessellation control shader using input variables declared + with "patch in". + + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/gpu_shader5.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.NV.gpu_shader5 import * +from OpenGL.raw.GL.NV.gpu_shader5 import _EXTENSION_NAME + +def glInitGpuShader5NV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glUniform1i64vNV.value size not checked against count +glUniform1i64vNV=wrapper.wrapper(glUniform1i64vNV).setInputArraySize( + 'value', None +) +# INPUT glUniform2i64vNV.value size not checked against count*2 +glUniform2i64vNV=wrapper.wrapper(glUniform2i64vNV).setInputArraySize( + 'value', None +) +# INPUT glUniform3i64vNV.value size not checked against count*3 +glUniform3i64vNV=wrapper.wrapper(glUniform3i64vNV).setInputArraySize( + 'value', None +) +# INPUT glUniform4i64vNV.value size not checked against count*4 +glUniform4i64vNV=wrapper.wrapper(glUniform4i64vNV).setInputArraySize( + 'value', None +) +# INPUT glUniform1ui64vNV.value size not checked against count +glUniform1ui64vNV=wrapper.wrapper(glUniform1ui64vNV).setInputArraySize( + 'value', None +) +# INPUT glUniform2ui64vNV.value size not checked against count*2 +glUniform2ui64vNV=wrapper.wrapper(glUniform2ui64vNV).setInputArraySize( + 'value', None +) +# INPUT glUniform3ui64vNV.value size not checked against count*3 +glUniform3ui64vNV=wrapper.wrapper(glUniform3ui64vNV).setInputArraySize( + 'value', None +) +# INPUT glUniform4ui64vNV.value size not checked against count*4 +glUniform4ui64vNV=wrapper.wrapper(glUniform4ui64vNV).setInputArraySize( + 'value', None +) +# OUTPUT glGetUniformi64vNV.params COMPSIZE(program, location) +# INPUT glProgramUniform1i64vNV.value size not checked against count +glProgramUniform1i64vNV=wrapper.wrapper(glProgramUniform1i64vNV).setInputArraySize( + 'value', None +) +# INPUT glProgramUniform2i64vNV.value size not checked against count*2 +glProgramUniform2i64vNV=wrapper.wrapper(glProgramUniform2i64vNV).setInputArraySize( + 'value', None +) +# INPUT glProgramUniform3i64vNV.value size not checked against count*3 +glProgramUniform3i64vNV=wrapper.wrapper(glProgramUniform3i64vNV).setInputArraySize( + 'value', None +) +# INPUT glProgramUniform4i64vNV.value size not checked against count*4 +glProgramUniform4i64vNV=wrapper.wrapper(glProgramUniform4i64vNV).setInputArraySize( + 'value', None +) +# INPUT glProgramUniform1ui64vNV.value size not checked against count +glProgramUniform1ui64vNV=wrapper.wrapper(glProgramUniform1ui64vNV).setInputArraySize( + 'value', None +) +# INPUT glProgramUniform2ui64vNV.value size not checked against count*2 +glProgramUniform2ui64vNV=wrapper.wrapper(glProgramUniform2ui64vNV).setInputArraySize( + 'value', None +) +# INPUT glProgramUniform3ui64vNV.value size not checked against count*3 +glProgramUniform3ui64vNV=wrapper.wrapper(glProgramUniform3ui64vNV).setInputArraySize( + 'value', None +) +# INPUT glProgramUniform4ui64vNV.value size not checked against count*4 +glProgramUniform4ui64vNV=wrapper.wrapper(glProgramUniform4ui64vNV).setInputArraySize( + 'value', None +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/half_float.py b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/half_float.py new file mode 100644 index 00000000..d1c4b394 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/half_float.py @@ -0,0 +1,119 @@ +'''OpenGL extension NV.half_float + +This module customises the behaviour of the +OpenGL.raw.GL.NV.half_float to provide a more +Python-friendly API + +Overview (from the spec) + + This extension introduces a new storage format and data type for + half-precision (16-bit) floating-point quantities. The floating-point + format is very similar to the IEEE single-precision floating-point + standard, except that it has only 5 exponent bits and 10 mantissa bits. + Half-precision floats are smaller than full precision floats and provide a + larger dynamic range than similarly-sized normalized scalar data types. + + This extension allows applications to use half-precision floating point + data when specifying vertices or pixel data. It adds new commands to + specify vertex attributes using the new data type, and extends the + existing vertex array and image specification commands to accept the new + data type. + + This storage format is also used to represent 16-bit components in the + floating-point frame buffers, as defined in the NV_float_buffer extension. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/half_float.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.NV.half_float import * +from OpenGL.raw.GL.NV.half_float import _EXTENSION_NAME + +def glInitHalfFloatNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +glVertex2hvNV=wrapper.wrapper(glVertex2hvNV).setInputArraySize( + 'v', 2 +) +glVertex3hvNV=wrapper.wrapper(glVertex3hvNV).setInputArraySize( + 'v', 3 +) +glVertex4hvNV=wrapper.wrapper(glVertex4hvNV).setInputArraySize( + 'v', 4 +) +glNormal3hvNV=wrapper.wrapper(glNormal3hvNV).setInputArraySize( + 'v', 3 +) +glColor3hvNV=wrapper.wrapper(glColor3hvNV).setInputArraySize( + 'v', 3 +) +glColor4hvNV=wrapper.wrapper(glColor4hvNV).setInputArraySize( + 'v', 4 +) +glTexCoord1hvNV=wrapper.wrapper(glTexCoord1hvNV).setInputArraySize( + 'v', 1 +) +glTexCoord2hvNV=wrapper.wrapper(glTexCoord2hvNV).setInputArraySize( + 'v', 2 +) +glTexCoord3hvNV=wrapper.wrapper(glTexCoord3hvNV).setInputArraySize( + 'v', 3 +) +glTexCoord4hvNV=wrapper.wrapper(glTexCoord4hvNV).setInputArraySize( + 'v', 4 +) +glMultiTexCoord1hvNV=wrapper.wrapper(glMultiTexCoord1hvNV).setInputArraySize( + 'v', 1 +) +glMultiTexCoord2hvNV=wrapper.wrapper(glMultiTexCoord2hvNV).setInputArraySize( + 'v', 2 +) +glMultiTexCoord3hvNV=wrapper.wrapper(glMultiTexCoord3hvNV).setInputArraySize( + 'v', 3 +) +glMultiTexCoord4hvNV=wrapper.wrapper(glMultiTexCoord4hvNV).setInputArraySize( + 'v', 4 +) +glFogCoordhvNV=wrapper.wrapper(glFogCoordhvNV).setInputArraySize( + 'fog', 1 +) +glSecondaryColor3hvNV=wrapper.wrapper(glSecondaryColor3hvNV).setInputArraySize( + 'v', 3 +) +glVertexWeighthvNV=wrapper.wrapper(glVertexWeighthvNV).setInputArraySize( + 'weight', 1 +) +glVertexAttrib1hvNV=wrapper.wrapper(glVertexAttrib1hvNV).setInputArraySize( + 'v', 1 +) +glVertexAttrib2hvNV=wrapper.wrapper(glVertexAttrib2hvNV).setInputArraySize( + 'v', 2 +) +glVertexAttrib3hvNV=wrapper.wrapper(glVertexAttrib3hvNV).setInputArraySize( + 'v', 3 +) +glVertexAttrib4hvNV=wrapper.wrapper(glVertexAttrib4hvNV).setInputArraySize( + 'v', 4 +) +# INPUT glVertexAttribs1hvNV.v size not checked against n +glVertexAttribs1hvNV=wrapper.wrapper(glVertexAttribs1hvNV).setInputArraySize( + 'v', None +) +# INPUT glVertexAttribs2hvNV.v size not checked against n +glVertexAttribs2hvNV=wrapper.wrapper(glVertexAttribs2hvNV).setInputArraySize( + 'v', None +) +# INPUT glVertexAttribs3hvNV.v size not checked against n +glVertexAttribs3hvNV=wrapper.wrapper(glVertexAttribs3hvNV).setInputArraySize( + 'v', None +) +# INPUT glVertexAttribs4hvNV.v size not checked against n +glVertexAttribs4hvNV=wrapper.wrapper(glVertexAttribs4hvNV).setInputArraySize( + 'v', None +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/internalformat_sample_query.py b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/internalformat_sample_query.py new file mode 100644 index 00000000..d71d6165 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/internalformat_sample_query.py @@ -0,0 +1,64 @@ +'''OpenGL extension NV.internalformat_sample_query + +This module customises the behaviour of the +OpenGL.raw.GL.NV.internalformat_sample_query to provide a more +Python-friendly API + +Overview (from the spec) + + Some OpenGL implementations support modes of multisampling which have + properties which are non-obvious to applications and/or which may not be + standards conformant. The idea of non-conformant AA modes is not new, + and is exposed in both GLX and EGL with config caveats and the + GLX_NON_CONFORMANT_CONFIG for GLX and EGL_NON_CONFORMANT_CONFIG for EGL, + or by querying the EGL_CONFORMANT attribute in newer versions of EGL. + + Both of these mechanisms operate on a per-config basis, which works as + intended for window-based configs. However, with the advent of + application-created FBOs, it is now possible to do all the multisample + operations in an application-created FBO and never use a multisample + window. + + This extension further extends the internalformat query mechanism + (first introduced by ARB_internalformat_query and extended in + ARB_internalformat_query2) and introduces a mechanism for a + implementation to report properties of formats that may also be + dependent on the number of samples. This includes information + such as whether the combination of format and samples should be + considered conformant. This enables an implementation to report + caveats which might apply to both window and FBO-based rendering + configurations. + + Some NVIDIA drivers support multisample modes which are internally + implemented as a combination of multisampling and automatic + supersampling in order to obtain a higher level of anti-aliasing than + can be directly supported by hardware. This extension allows those + properties to be queried by an application with the MULTISAMPLES_NV, + SUPERSAMPLE_SCALE_X_NV and SUPERSAMPLE_SCALE_Y_NV properties. For + example, a 16xAA mode might be implemented by using 4 samples and + up-scaling by a factor of 2 in each of the x- and y-dimensions. + In this example, the driver might report MULTSAMPLES_NV of 4, + SUPERSAMPLE_SCALE_X_NV of 2, SUPERSAMPLE_SCALE_Y_NV of 2 and + CONFORMANT_NV of FALSE. + + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/internalformat_sample_query.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.NV.internalformat_sample_query import * +from OpenGL.raw.GL.NV.internalformat_sample_query import _EXTENSION_NAME + +def glInitInternalformatSampleQueryNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glGetInternalformatSampleivNV.params size not checked against bufSize +glGetInternalformatSampleivNV=wrapper.wrapper(glGetInternalformatSampleivNV).setInputArraySize( + 'params', None +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/light_max_exponent.py b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/light_max_exponent.py new file mode 100644 index 00000000..c4b854ae --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/light_max_exponent.py @@ -0,0 +1,37 @@ +'''OpenGL extension NV.light_max_exponent + +This module customises the behaviour of the +OpenGL.raw.GL.NV.light_max_exponent to provide a more +Python-friendly API + +Overview (from the spec) + + Default OpenGL does not permit a shininess or spot exponent over + 128.0. This extension permits implementations to support and + advertise a maximum shininess and spot exponent beyond 128.0. + + Note that extremely high exponents for shininess and/or spot light + cutoff will require sufficiently high tessellation for acceptable + lighting results. + + Paul Deifenbach's thesis suggests that higher exponents are + necessary to approximate BRDFs with per-vertex ligthing and + multiple passes. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/light_max_exponent.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.NV.light_max_exponent import * +from OpenGL.raw.GL.NV.light_max_exponent import _EXTENSION_NAME + +def glInitLightMaxExponentNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/memory_attachment.py b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/memory_attachment.py new file mode 100644 index 00000000..b3935b94 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/memory_attachment.py @@ -0,0 +1,31 @@ +'''OpenGL extension NV.memory_attachment + +This module customises the behaviour of the +OpenGL.raw.GL.NV.memory_attachment to provide a more +Python-friendly API + +Overview (from the spec) + + This extension extends the memory objects introduced with EXT_memory_object + to allow existing textures and buffers to be migrated to an imported memory + allocation. The primary use-case of this extension is plug-in development + where resource management (creation, deletion, sizing etc.) is handled by + inaccessible host application code. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/memory_attachment.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.NV.memory_attachment import * +from OpenGL.raw.GL.NV.memory_attachment import _EXTENSION_NAME + +def glInitMemoryAttachmentNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/mesh_shader.py b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/mesh_shader.py new file mode 100644 index 00000000..630a9545 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/mesh_shader.py @@ -0,0 +1,33 @@ +'''OpenGL extension NV.mesh_shader + +This module customises the behaviour of the +OpenGL.raw.GL.NV.mesh_shader to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides a new mechanism allowing applications to use two + new programmable shader types -- the task and mesh shader -- to generate + collections of geometric primitives to be processed by fixed-function + primitive assembly and rasterization logic. When the task and mesh + shaders are drawn, they replace the standard programmable vertex + processing pipeline, including vertex array attribute fetching, vertex + shader processing, tessellation, and the geometry shader processing. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/mesh_shader.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.NV.mesh_shader import * +from OpenGL.raw.GL.NV.mesh_shader import _EXTENSION_NAME + +def glInitMeshShaderNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/multisample_coverage.py b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/multisample_coverage.py new file mode 100644 index 00000000..bb16d1f0 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/multisample_coverage.py @@ -0,0 +1,49 @@ +'''OpenGL extension NV.multisample_coverage + +This module customises the behaviour of the +OpenGL.raw.GL.NV.multisample_coverage to provide a more +Python-friendly API + +Overview (from the spec) + + The ARB_multisample extension provides a mechanism for antialiasing + primitives. This mechanism allows an application to request an + additional buffer, the multisample buffer, that is added to the + framebuffer. An application can request the number of samples per + fragment that are stored in the multisample buffer. Rendering + proceeds by writing color, depth, and stencil values for each + sample to the multisample buffer. The results are automatically + resolved to a single displayable color each time a pixel is + updated. + + Coverage Sample Anti-Aliasing (CSAA) is an extension to multisample + antialiasing. The technique separates "samples" into two types of + samples. "Color samples" are samples with color, depth, and + stencil information stored in the multisample buffer. "Coverage + samples" include both color samples and additional samples that only + provide pixel coverage information. + + This extension follows the example of the + NV_framebuffer_multisample_coverage extension, which adds CSAA + support for framebuffer objects. The base description of + multisample rendering is written in terms of coverage samples and + color samples. The windows system notion of "samples" + (SAMPLES_ARB) is layered on top of coverage and color samples. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/multisample_coverage.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.NV.multisample_coverage import * +from OpenGL.raw.GL.NV.multisample_coverage import _EXTENSION_NAME + +def glInitMultisampleCoverageNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/multisample_filter_hint.py b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/multisample_filter_hint.py new file mode 100644 index 00000000..20f2e467 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/multisample_filter_hint.py @@ -0,0 +1,38 @@ +'''OpenGL extension NV.multisample_filter_hint + +This module customises the behaviour of the +OpenGL.raw.GL.NV.multisample_filter_hint to provide a more +Python-friendly API + +Overview (from the spec) + + OpenGL multisampling typically assumes that the samples of a given + pixel are weighted uniformly and averaged to compute the pixel's + resolved color. This extension provides a hint that permits + implementations to provide an alternative method of resolving the + color of multisampled pixels. + + As an example of such an alternative method, NVIDIA's GeForce3 GPU + provides a technique known as Quincunx filtering. This technique + is used in two-sample multisampling, but it blends the pixel's two + samples and three additional samples from adjacent pixels. The sample + pattern is analogous to the 5 pattern on a die. The quality of this + technique is widely regarded as comparable to 4 sample multisampling. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/multisample_filter_hint.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.NV.multisample_filter_hint import * +from OpenGL.raw.GL.NV.multisample_filter_hint import _EXTENSION_NAME + +def glInitMultisampleFilterHintNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/occlusion_query.py b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/occlusion_query.py new file mode 100644 index 00000000..6752d5ac --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/occlusion_query.py @@ -0,0 +1,91 @@ +'''OpenGL extension NV.occlusion_query + +This module customises the behaviour of the +OpenGL.raw.GL.NV.occlusion_query to provide a more +Python-friendly API + +Overview (from the spec) + + The HP_occlusion_test extension defines a mechanism whereby an + application can query the visibility of an object, where "visible" + means that at least one pixel passes the depth and stencil tests. + + The HP extension has two major shortcomings. + + - It returns the result as a simple GL_TRUE/GL_FALSE result, when in + fact it is often useful to know exactly how many pixels passed. + - It provides only a simple "stop-and-wait" model for using multiple + queries. The application begins an occlusion test and ends it; + then, at some later point, it asks for the result, at which point + the driver must stop and wait until the result from the previous + test is back before the application can even begin the next one. + This is a very simple model, but its performance is mediocre when + an application wishes to perform many queries, and it eliminates + most of the opportunites for parallelism between the CPU and GPU. + + This extension solves both of those problems. It returns as its + result the number of pixels that pass, and it provides an interface + conceptually similar to that of NV_fence that allows applications to + issue many occlusion queries before asking for the result of any one. + As a result, they can overlap the time it takes for the occlusion + query results to be returned with other, more useful work, such as + rendering other parts of the scene or performing other computations + on the CPU. + + There are many situations where a pixel count, rather than a boolean + result, is useful. + + - If the visibility test is an object bounding box being used to + decide whether to skip the object, sometimes it can be acceptable, + and beneficial to performance, to skip an object if less than some + threshold number of pixels could be visible. + - Knowing the number of pixels visible in the bounding box may also + help decide what level of detail a model should be drawn with. If + only a few pixels are visible, a low-detail model may be + acceptable. In general, this allows level-of-detail mechanisms to + be slightly less ad hoc. + - "Depth peeling" techniques, such as order-independent transparency, + would typically like to know when to stop rendering more layers; it + is difficult to come up with a way to determine a priori how many + layers to use. A boolean count allows applications to stop when + more layers will not affect the image at all, but this will likely + be unacceptable for performance, with minimal gains to image + quality. Instead, it makes more sense to stop rendering when the + number of pixels goes below a threshold; this should provide better + results than any of these other algorithms. + - Occlusion queries can be used as a replacement for glReadPixels of + the depth buffer to determine whether, say, a light source is + visible for the purposes of a lens flare effect or a halo to + simulate glare. Pixel counts allow you to compute the percentage + of the light source that is visible, and the brightness of these + effects can be modulated accordingly. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/occlusion_query.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.NV.occlusion_query import * +from OpenGL.raw.GL.NV.occlusion_query import _EXTENSION_NAME + +def glInitOcclusionQueryNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +glGenOcclusionQueriesNV=wrapper.wrapper(glGenOcclusionQueriesNV).setOutput( + 'ids',size=lambda x:(x,),pnameArg='n',orPassIn=True +) +# INPUT glDeleteOcclusionQueriesNV.ids size not checked against n +glDeleteOcclusionQueriesNV=wrapper.wrapper(glDeleteOcclusionQueriesNV).setInputArraySize( + 'ids', None +) +glGetOcclusionQueryivNV=wrapper.wrapper(glGetOcclusionQueryivNV).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetOcclusionQueryuivNV=wrapper.wrapper(glGetOcclusionQueryuivNV).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/packed_depth_stencil.py b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/packed_depth_stencil.py new file mode 100644 index 00000000..fc4aedf1 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/packed_depth_stencil.py @@ -0,0 +1,94 @@ +'''OpenGL extension NV.packed_depth_stencil + +This module customises the behaviour of the +OpenGL.raw.GL.NV.packed_depth_stencil to provide a more +Python-friendly API + +Overview (from the spec) + + Many OpenGL implementations have chosen to interleave the depth and + stencil buffers into one buffer, often with 24 bits of depth + precision and 8 bits of stencil data. 32 bits is more than is needed + for the depth buffer much of the time; a 24-bit depth buffer, on the + other hand, requires that reads and writes of depth data be unaligned + with respect to power-of-two boundaries. On the other hand, 8 bits + of stencil data is more than sufficient for most applications, so it + is only natural to pack the two buffers into a single buffer with + both depth and stencil data. OpenGL never provides direct access to + the buffers, so the OpenGL implementation can provide an interface to + applications where it appears the one merged buffer is composed of + two logical buffers. + + One disadvantage of this scheme is that OpenGL lacks any means by + which this packed data can be handled efficiently. For example, when + an application reads from the 24-bit depth buffer, using the type + GL_UNSIGNED_SHORT will lose 8 bits of data, while GL_UNSIGNED_INT has + 8 too many. Both require expensive format conversion operations. A + 24-bit format would be no more suitable, because it would also suffer + from the unaligned memory accesses that made the standalone 24-bit + depth buffer an unattractive proposition in the first place. + + Many applications, such as parallel rendering applications, may also + wish to draw to or read back from both the depth and stencil buffers + at the same time. Currently this requires two separate operations, + reducing performance. Since the buffers are interleaved, drawing to + or reading from both should be no more expensive than using just one; + in some cases, it may even be cheaper. + + This extension provides a new data format, GL_DEPTH_STENCIL_NV, that + can be used with the glDrawPixels, glReadPixels, and glCopyPixels + commands, as well as a packed data type, GL_UNSIGNED_INT_24_8_NV, + that is meant to be used with GL_DEPTH_STENCIL_NV. No other formats + are supported with GL_DEPTH_STENCIL_NV. If SGIX_depth_texture is + supported, GL_DEPTH_STENCIL_NV/GL_UNSIGNED_INT_24_8_NV data can also + be used for textures; this provides a more efficient way to supply + data for a 24-bit depth texture. + + GL_DEPTH_STENCIL_NV data, when passed through the pixel path, + undergoes both depth and stencil operations. The depth data is + scaled and biased by the current GL_DEPTH_SCALE and GL_DEPTH_BIAS, + while the stencil data is shifted and offset by the current + GL_INDEX_SHIFT and GL_INDEX_OFFSET. The stencil data is also put + through the stencil-to-stencil pixel map. + + glDrawPixels of GL_DEPTH_STENCIL_NV data operates similarly to that + of GL_STENCIL_INDEX data, bypassing the OpenGL fragment pipeline + entirely, unlike the treatment of GL_DEPTH_COMPONENT data. The + stencil and depth masks are applied, as are the pixel ownership and + scissor tests, but all other operations are skipped. + + glReadPixels of GL_DEPTH_STENCIL_NV data reads back a rectangle from + both the depth and stencil buffers. + + glCopyPixels of GL_DEPTH_STENCIL_NV data copies a rectangle from + both the depth and stencil buffers. Like glDrawPixels, it applies + both the stencil and depth masks but skips the remainder of the + OpenGL fragment pipeline. + + glTex[Sub]Image[1,2,3]D of GL_DEPTH_STENCIL_NV data loads depth data + into a depth texture. glGetTexImage of GL_DEPTH_STENCIL_NV data can + be used to retrieve depth data from a depth texture. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/packed_depth_stencil.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.NV.packed_depth_stencil import * +from OpenGL.raw.GL.NV.packed_depth_stencil import _EXTENSION_NAME + +def glInitPackedDepthStencilNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION +# Setup the new image types +from OpenGL import images +from OpenGL.raw.GL.VERSION.GL_1_1 import GL_UNSIGNED_INT +images.TYPE_TO_ARRAYTYPE[ GL_UNSIGNED_INT_24_8_NV ] = GL_UNSIGNED_INT +images.TIGHT_PACK_FORMATS[ GL_UNSIGNED_INT_24_8_NV ] = 4 +images.COMPONENT_COUNTS[ GL_DEPTH_STENCIL_NV ] = 4 diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/parameter_buffer_object.py b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/parameter_buffer_object.py new file mode 100644 index 00000000..ac5fd7ee --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/parameter_buffer_object.py @@ -0,0 +1,56 @@ +'''OpenGL extension NV.parameter_buffer_object + +This module customises the behaviour of the +OpenGL.raw.GL.NV.parameter_buffer_object to provide a more +Python-friendly API + +Overview (from the spec) + + This extension, in conjunction with NV_gpu_program4, provides a new type + of program parameter than can be used as a constant during vertex, + fragment, or geometry program execution. Each program target has a set of + parameter buffer binding points to which buffer objects can be attached. + + A vertex, fragment, or geometry program can read data from the attached + buffer objects using a binding of the form "program.buffer[a][b]". This + binding reads data from the buffer object attached to binding point . + The buffer object attached is treated either as an array of 32-bit words + or an array of four-component vectors, and the binding above reads the + array element numbered . + + The use of buffer objects allows applications to change large blocks of + program parameters at once, simply by binding a new buffer object. It + also provides a number of new ways to load parameter values, including + readback from the frame buffer (EXT_pixel_buffer_object), transform + feedback (NV_transform_feedback), buffer object loading functions such as + MapBuffer and BufferData, as well as dedicated parameter buffer update + functions provided by this extension. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/parameter_buffer_object.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.NV.parameter_buffer_object import * +from OpenGL.raw.GL.NV.parameter_buffer_object import _EXTENSION_NAME + +def glInitParameterBufferObjectNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glProgramBufferParametersfvNV.params size not checked against count +glProgramBufferParametersfvNV=wrapper.wrapper(glProgramBufferParametersfvNV).setInputArraySize( + 'params', None +) +# INPUT glProgramBufferParametersIivNV.params size not checked against count +glProgramBufferParametersIivNV=wrapper.wrapper(glProgramBufferParametersIivNV).setInputArraySize( + 'params', None +) +# INPUT glProgramBufferParametersIuivNV.params size not checked against count +glProgramBufferParametersIuivNV=wrapper.wrapper(glProgramBufferParametersIuivNV).setInputArraySize( + 'params', None +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/parameter_buffer_object2.py b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/parameter_buffer_object2.py new file mode 100644 index 00000000..e00c44f1 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/parameter_buffer_object2.py @@ -0,0 +1,52 @@ +'''OpenGL extension NV.parameter_buffer_object2 + +This module customises the behaviour of the +OpenGL.raw.GL.NV.parameter_buffer_object2 to provide a more +Python-friendly API + +Overview (from the spec) + + This extension builds on the NV_parameter_buffer_object extension to + provide additional flexibility in sourcing data from buffer objects. + + The original NV_parameter_buffer_object (PaBO) extension provided the + ability to bind buffer objects to a set of numbered binding points and + access them in assembly programs as though they were arrays of 32-bit + scalars (via the BUFFER variable type) or arrays of four-component vectors + with 32-bit scalar components (via the BUFFER4 variable type). However, + the functionality it provided had some significant limits on flexibility. + Since any given buffer binding point could be used either as a BUFFER or + BUFFER4, but not both, programs couldn't do both 32- and 128-bit fetches + from a single binding point. Additionally, No support was provided for + 8-, 16-, or 64-bit fetches, though they could be emulated using a larger + loads, with bitfield operations and/or write masking to put components in + the right places. Indexing was supported, but strides were limited to 4- + and 16-byte multiples, depending on whether BUFFER or BUFFER4 is used. + + This new extension provides the buffer variable declaration type CBUFFER + to specify a buffer that is treated as an array of bytes, rather than an + array of words or vectors. The LDC instruction allows programs to extract + a vector of data from a CBUFFER variable, using a size and component count + specified in the opcode modifier. 1-, 2-, and 4-component fetches are + supported. The LDC instruction supports byte offsets using normal array + indexing mechanisms; both run-time and immediate offsets are supported. + Offsets used for a buffer object fetch are required to be aligned to the + size of the fetch (1, 2, 4, 8, or 16 bytes). + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/parameter_buffer_object2.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.NV.parameter_buffer_object2 import * +from OpenGL.raw.GL.NV.parameter_buffer_object2 import _EXTENSION_NAME + +def glInitParameterBufferObject2NV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/path_rendering.py b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/path_rendering.py new file mode 100644 index 00000000..63d37433 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/path_rendering.py @@ -0,0 +1,564 @@ +'''OpenGL extension NV.path_rendering + +This module customises the behaviour of the +OpenGL.raw.GL.NV.path_rendering to provide a more +Python-friendly API + +Overview (from the spec) + + Conventional OpenGL supports rendering images (pixel rectangles and + bitmaps) and simple geometric primitives (points, lines, polygons). + + This extension adds a new rendering paradigm, known as path rendering, + for rendering filled and stroked paths. Path rendering is not novel + but rather a standard part of most resolution-independent 2D rendering + systems such as Flash, PDF, Silverlight, SVG, Java 2D, Office + drawings, TrueType fonts, PostScript and its fonts, Quartz 2D, XML + Paper Specification (XPS), and OpenVG. What is novel is the ability + to mix path rendering with arbitrary OpenGL 3D rendering and imaging. + + With this extension, path rendering becomes a first-class rendering + mode within the OpenGL graphics system that can be arbitrarily mixed + with existing OpenGL rendering and can take advantage of OpenGL's + existing mechanisms for texturing, programmability, and per-fragment + operations. + + Unlike geometric primitive rendering, paths are specified on a 2D + (non-projective) plane rather than in 3D (projective) space. + Even though the path is defined in a 2D plane, every path can + be transformed into 3D clip space allowing for 3D view frustum & + user-defined clipping, depth offset, and depth testing in the same + manner as geometric primitive rendering. + + Both geometric primitive rendering and path rendering support + rasterization of edges defined by line segments; however, path + rendering also allows path segments to be specified by Bezier (cubic + or quadratic) curves or partial elliptical arcs. This allows path + rendering to define truly curved primitive boundaries unlike the + straight edges of line and polygon primitives. Whereas geometric + primitive rendering requires convex polygons for well-defined + rendering results, path rendering allows (and encourages!) concave + and curved outlines to be specified. These paths are even allowed + to self-intersect. + + When filling closed paths, the winding of paths (counterclockwise + or clockwise) determines whether pixels are inside or outside of + the path. + + Paths can also be stroked whereby, conceptually, a fixed-width "brush" + is pulled along the path such that the brush remains orthogonal to + the gradient of each path segment. Samples within the sweep of this + brush are considered inside the stroke of the path. + + This extension supports path rendering through a sequence of three + operations: + + 1. Path specification is the process of creating and updating + a path object consisting of a set of path commands and a + corresponding set of 2D vertices. + + Path commands can be specified explicitly from path command + and coordinate data, parsed from a string based on standard + grammars for representing paths, or specified by a particular + glyph of standard font representations. Also new paths can + be specified by weighting one or more existing paths so long + as all the weighted paths have consistent command sequences. + + Each path object contains zero or more subpaths specified + by a sequence of line segments, partial elliptical arcs, + and (cubic or quadratic) Bezier curve segments. Each path + may contain multiple subpaths that can be closed (forming + a contour) or open. + + 2. Path stenciling is the process of updating the stencil buffer + based on a path's coverage transformed into window space. + + Path stenciling can determine either the filled or stroked + coverage of a path. + + The details of path stenciling are explained within the core + of the specification. + + Stenciling a stroked path supports all the standard + embellishments for path stroking such as end caps, join + styles, miter limits, dashing, and dash caps. These stroking + properties specified are parameters of path objects. + + 3. Path covering is the process of emitting simple (convex & + planar) geometry that (conservatively) "covers" the path's + sample coverage in the stencil buffer. During path covering, + stencil testing can be configured to discard fragments not + within the actual coverage of the path as determined by + prior path stenciling. + + Path covering can cover either the filled or stroked coverage + of a path. + + The details of path covering are explained within the core + of the specification. + + To render a path object into the color buffer, an application specifies + a path object and then uses a two-step rendering process. First, the + path object is stenciled whereby the path object's stroked or filled + coverage is rasterized into the stencil buffer. Second, the path object + is covered whereby conservative bounding geometry for the path is + transformed and rasterized with stencil testing configured to test against + the coverage information written to the stencil buffer in the first step + so that only fragments covered by the path are written during this second + step. Also during this second step written pixels typically have + their stencil value reset (so there's no need for clearing the + stencil buffer between rendering each path). + + Here is an example of specifying and then rendering a five-point + star and a heart as a path using Scalable Vector Graphics (SVG) + path description syntax: + + GLuint pathObj = 42; + const char *svgPathString = + // star + "M100,180 L40,10 L190,120 L10,120 L160,10 z" + // heart + "M300 300 C 100 400,100 200,300 100,500 200,500 400,300 300Z"; + glPathStringNV(pathObj, GL_PATH_FORMAT_SVG_NV, + (GLsizei)strlen(svgPathString), svgPathString); + + Alternatively applications oriented around the PostScript imaging + model can use the PostScript user path syntax instead: + + const char *psPathString = + // star + "100 180 moveto" + " 40 10 lineto 190 120 lineto 10 120 lineto 160 10 lineto closepath" + // heart + " 300 300 moveto" + " 100 400 100 200 300 100 curveto" + " 500 200 500 400 300 300 curveto closepath"; + glPathStringNV(pathObj, GL_PATH_FORMAT_PS_NV, + (GLsizei)strlen(psPathString), psPathString); + + The PostScript path syntax also supports compact and precise binary + encoding and includes PostScript-style circular arcs. + + Or the path's command and coordinates can be specified explicitly: + + static const GLubyte pathCommands[10] = + { GL_MOVE_TO_NV, GL_LINE_TO_NV, GL_LINE_TO_NV, GL_LINE_TO_NV, + GL_LINE_TO_NV, GL_CLOSE_PATH_NV, + 'M', 'C', 'C', 'Z' }; // character aliases + static const GLshort pathCoords[12][2] = + { {100, 180}, {40, 10}, {190, 120}, {10, 120}, {160, 10}, + {300,300}, {100,400}, {100,200}, {300,100}, + {500,200}, {500,400}, {300,300} }; + glPathCommandsNV(pathObj, 10, pathCommands, 24, GL_SHORT, pathCoords); + + Before rendering to a window with a stencil buffer, clear the stencil + buffer to zero and the color buffer to black: + + glClearStencil(0); + glClearColor(0,0,0,0); + glStencilMask(~0); + glClear(GL_COLOR_BUFFER_BIT | GL_STENCIL_BUFFER_BIT); + + Use an orthographic path-to-clip-space transform to map the + [0..500]x[0..400] range of the star's path coordinates to the [-1..1] + clip space cube: + + glMatrixLoadIdentityEXT(GL_PROJECTION); + glMatrixLoadIdentityEXT(GL_MODELVIEW); + glMatrixOrthoEXT(GL_MODELVIEW, 0, 500, 0, 400, -1, 1); + + Stencil the path: + + glStencilFillPathNV(pathObj, GL_COUNT_UP_NV, 0x1F); + + The 0x1F mask means the counting uses modulo-32 arithmetic. In + principle the star's path is simple enough (having a maximum winding + number of 2) that modulo-4 arithmetic would be sufficient so the mask + could be 0x3. Or a mask of all 1's (~0) could be used to count with + all available stencil bits. + + Now that the coverage of the star and the heart have been rasterized + into the stencil buffer, cover the path with a non-zero fill style + (indicated by the GL_NOTEQUAL stencil function with a zero reference + value): + + glEnable(GL_STENCIL_TEST); + glStencilFunc(GL_NOTEQUAL, 0, 0x1F); + glStencilOp(GL_KEEP, GL_KEEP, GL_ZERO); + glColor3f(1,1,0); // yellow + glCoverFillPathNV(pathObj, GL_BOUNDING_BOX_NV); + + The result is a yellow star (with a filled center) to the left of + a yellow heart. + + The GL_ZERO stencil operation ensures that any covered samples + (meaning those with non-zero stencil values) are zero'ed when + the path cover is rasterized. This allows subsequent paths to be + rendered without clearing the stencil buffer again. + + A similar two-step rendering process can draw a white outline + over the star and heart. + + Before rendering, configure the path object with desirable path + parameters for stroking. Specify a wider 6.5-unit stroke and + the round join style: + + glPathParameteriNV(pathObj, GL_PATH_JOIN_STYLE_NV, GL_ROUND_NV); + glPathParameterfNV(pathObj, GL_PATH_STROKE_WIDTH_NV, 6.5); + + Now stencil the path's stroked coverage into the stencil buffer, + setting the stencil to 0x1 for all stencil samples within the + transformed path. + + glStencilStrokePathNV(pathObj, 0x1, ~0); + + Cover the path's stroked coverage (with a hull this time instead + of a bounding box; the choice doesn't really matter here) while + stencil testing that writes white to the color buffer and again + zero the stencil buffer. + + glColor3f(1,1,1); // white + glCoverStrokePathNV(pathObj, GL_CONVEX_HULL_NV); + + In this example, constant color shading is used but the application + can specify their own arbitrary shading and/or blending operations, + whether with Cg compiled to fragment program assembly, GLSL, or + fixed-function fragment processing. + + More complex path rendering is possible such as clipping one path to + another arbitrary path. This is because stencil testing (as well + as depth testing, depth bound test, clip planes, and scissoring) + can restrict path stenciling. + + Now let's render the word "OpenGL" atop the star and heart. + + First create a sequence of path objects for the glyphs for the + characters in "OpenGL": + + GLuint glyphBase = glGenPathsNV(6); + const unsigned char *word = "OpenGL"; + const GLsizei wordLen = (GLsizei)strlen(word); + const GLfloat emScale = 2048; // match TrueType convention + GLuint templatePathObject = ~0; // Non-existent path object + glPathGlyphsNV(glyphBase, + GL_SYSTEM_FONT_NAME_NV, "Helvetica", GL_BOLD_BIT_NV, + wordLen, GL_UNSIGNED_BYTE, word, + GL_SKIP_MISSING_GLYPH_NV, ~0, emScale); + glPathGlyphsNV(glyphBase, + GL_SYSTEM_FONT_NAME_NV, "Arial", GL_BOLD_BIT_NV, + wordLen, GL_UNSIGNED_BYTE, word, + GL_SKIP_MISSING_GLYPH_NV, ~0, emScale); + glPathGlyphsNV(glyphBase, + GL_STANDARD_FONT_NAME_NV, "Sans", GL_BOLD_BIT_NV, + wordLen, GL_UNSIGNED_BYTE, word, + GL_USE_MISSING_GLYPH_NV, ~0, emScale); + + Glyphs are loaded for three different fonts in priority order: + Helvetica first, then Arial, and if neither of those loads, use the + standard sans-serif font. If a prior glPathGlyphsNV is successful + and specifies the path object range, the subsequent glPathGlyphsNV + commands silently avoid re-specifying the already existent path + objects. + + Now query the (kerned) separations for the word "OpenGL" and build + a set of horizontal translations advancing each successive glyph by + its kerning distance with the following glyph. + + GLfloat xtranslate[6+1]; // wordLen+1 + glGetPathSpacingNV(GL_ACCUM_ADJACENT_PAIRS_NV, + wordLen+1, GL_UNSIGNED_BYTE, + "\000\001\002\003\004\005\005", // repeat last letter twice + glyphBase, + 1.0f, 1.0f, + GL_TRANSLATE_X_NV, + xtranslate); + + Next determine the font-wide vertical minimum and maximum for the + font face by querying the per-font metrics of any one of the glyphs + from the font face. + + GLfloat yMinMax[2]; + glGetPathMetricRangeNV(GL_FONT_Y_MIN_BOUNDS_BIT_NV|GL_FONT_Y_MAX_BOUNDS_BIT_NV, + glyphBase, /*count*/1, + 2*sizeof(GLfloat), + yMinMax); + + Use an orthographic path-to-clip-space transform to map the + word's bounds to the [-1..1] clip space cube: + + glMatrixLoadIdentityEXT(GL_PROJECTION); + glMatrixOrthoEXT(GL_MODELVIEW, + 0, xtranslate[6], yMinMax[0], yMinMax[1], + -1, 1); + + Stencil the filled paths of the sequence of glyphs for "OpenGL", + each transformed by the appropriate 2D translations for spacing. + + glStencilFillPathInstancedNV(6, GL_UNSIGNED_BYTE, + "\000\001\002\003\004\005", + glyphBase, + GL_PATH_FILL_MODE_NV, 0xFF, + GL_TRANSLATE_X_NV, xtranslate); + + Cover the bounding box union of the glyphs with 50% gray. + + glEnable(GL_STENCIL_TEST); + glStencilFunc(GL_NOTEQUAL, 0, 0xFF); + glStencilOp(GL_KEEP, GL_KEEP, GL_ZERO); + glColor3f(0.5,0.5,0.5); // 50% gray + glCoverFillPathInstancedNV(6, GL_UNSIGNED_BYTE, + "\000\001\002\003\004\005", + glyphBase, + GL_BOUNDING_BOX_OF_BOUNDING_BOXES_NV, + GL_TRANSLATE_X_NV, xtranslate); + + Voila, the word "OpenGL" in gray is now stenciled into the framebuffer. + + Instead of solid 50% gray, the cover operation can apply a linear + gradient that changes from green (RGB=0,1,0) at the top of the word + "OpenGL" to blue (RGB=0,0,1) at the bottom of "OpenGL": + + GLfloat rgbGen[3][3] = { + 0, 0, 0, // red = constant zero + 0, 1, 0, // green = varies with y from bottom (0) to top (1) + 0, -1, 1 // blue = varies with y from bottom (1) to top (0) + }; + glPathColorGenNV(GL_PRIMARY_COLOR, GL_PATH_OBJECT_BOUNDING_BOX_NV, + GL_RGB, &rgbGen[0][0]); + + Instead of loading just the glyphs for the characters in "OpenGL", + the entire character set could be loaded. This allows the characters + of the string to be mapped (offset by the glyphBase) to path object names. + A range of glyphs can be loaded like this: + + const int numChars = 256; // ISO/IEC 8859-1 8-bit character range + GLuint glyphBase = glGenPathsNV(numChars); + glPathGlyphRangeNV(glyphBase, + GL_SYSTEM_FONT_NAME_NV, "Helvetica", GL_BOLD_BIT_NV, + 0, numChars, + GL_SKIP_MISSING_GLYPH_NV, ~0, emScale); + glPathGlyphRangeNV(glyphBase, + GL_SYSTEM_FONT_NAME_NV, "Arial", GL_BOLD_BIT_NV, + 0, numChars, + GL_SKIP_MISSING_GLYPH_NV, ~0, emScale); + glPathGlyphRangeNV(glyphBase, + GL_STANDARD_FONT_NAME_NV, "Sans", GL_BOLD_BIT_NV, + 0, numChars, + GL_USE_MISSING_GLYPH_NV, ~0, emScale); + + Given a range of glyphs loaded as path objects, (kerned) spacing + information can now be queried for the string: + + glGetPathSpacingNV(GL_ACCUM_ADJACENT_PAIRS_NV, + 7, GL_UNSIGNED_BYTE, "OpenGLL", // repeat L to get final spacing + glyphBase, + 1.0f, 1.0f, + GL_TRANSLATE_X_NV, + kerning); + + Using the range of glyphs, stenciling and covering the instanced + paths for "OpenGL" can be done this way: + + glStencilFillPathInstancedNV(6, GL_UNSIGNED_BYTE, "OpenGL", + glyphBase, + GL_PATH_FILL_MODE_NV, 0xFF, + GL_TRANSLATE_X_NV, xtranslate); + + glCoverFillPathInstancedNV(6, GL_UNSIGNED_BYTE, "OpenGL", + glyphBase, + GL_BOUNDING_BOX_OF_BOUNDING_BOXES_NV, + GL_TRANSLATE_X_NV, xtranslate); + + The "stencil" and "cover" steps can be combined in a single command: + + glStencilThenCoverFillPathInstancedNV(6, GL_UNSIGNED_BYTE, "OpenGL", + glyphBase, + GL_PATH_FILL_MODE_NV, 0xFF, + GL_BOUNDING_BOX_OF_BOUNDING_BOXES_NV + GL_TRANSLATE_X_NV, xtranslate); + + XXX add path clipping example to demonstrate glPathStencilFuncNV. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/path_rendering.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.NV.path_rendering import * +from OpenGL.raw.GL.NV.path_rendering import _EXTENSION_NAME + +def glInitPathRenderingNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glPathCommandsNV.commands size not checked against numCommands +# INPUT glPathCommandsNV.coords size not checked against 'numCoords,coordType' +glPathCommandsNV=wrapper.wrapper(glPathCommandsNV).setInputArraySize( + 'commands', None +).setInputArraySize( + 'coords', None +) +# INPUT glPathCoordsNV.coords size not checked against 'numCoords,coordType' +glPathCoordsNV=wrapper.wrapper(glPathCoordsNV).setInputArraySize( + 'coords', None +) +# INPUT glPathSubCommandsNV.commands size not checked against numCommands +# INPUT glPathSubCommandsNV.coords size not checked against 'numCoords,coordType' +glPathSubCommandsNV=wrapper.wrapper(glPathSubCommandsNV).setInputArraySize( + 'commands', None +).setInputArraySize( + 'coords', None +) +# INPUT glPathSubCoordsNV.coords size not checked against 'numCoords,coordType' +glPathSubCoordsNV=wrapper.wrapper(glPathSubCoordsNV).setInputArraySize( + 'coords', None +) +# INPUT glPathStringNV.pathString size not checked against length +glPathStringNV=wrapper.wrapper(glPathStringNV).setInputArraySize( + 'pathString', None +) +# INPUT glPathGlyphsNV.charcodes size not checked against 'numGlyphs,type,charcodes' +# INPUT glPathGlyphsNV.fontName size not checked against 'fontTarget,fontName' +glPathGlyphsNV=wrapper.wrapper(glPathGlyphsNV).setInputArraySize( + 'charcodes', None +).setInputArraySize( + 'fontName', None +) +# INPUT glPathGlyphRangeNV.fontName size not checked against 'fontTarget,fontName' +glPathGlyphRangeNV=wrapper.wrapper(glPathGlyphRangeNV).setInputArraySize( + 'fontName', None +) +# INPUT glWeightPathsNV.paths size not checked against numPaths +# INPUT glWeightPathsNV.weights size not checked against numPaths +glWeightPathsNV=wrapper.wrapper(glWeightPathsNV).setInputArraySize( + 'paths', None +).setInputArraySize( + 'weights', None +) +# INPUT glTransformPathNV.transformValues size not checked against 'transformType' +glTransformPathNV=wrapper.wrapper(glTransformPathNV).setInputArraySize( + 'transformValues', None +) +# INPUT glPathParameterivNV.value size not checked against 'pname' +glPathParameterivNV=wrapper.wrapper(glPathParameterivNV).setInputArraySize( + 'value', None +) +# INPUT glPathParameterfvNV.value size not checked against 'pname' +glPathParameterfvNV=wrapper.wrapper(glPathParameterfvNV).setInputArraySize( + 'value', None +) +# INPUT glPathDashArrayNV.dashArray size not checked against dashCount +glPathDashArrayNV=wrapper.wrapper(glPathDashArrayNV).setInputArraySize( + 'dashArray', None +) +# INPUT glStencilFillPathInstancedNV.paths size not checked against 'numPaths,pathNameType,paths' +# INPUT glStencilFillPathInstancedNV.transformValues size not checked against 'numPaths,transformType' +glStencilFillPathInstancedNV=wrapper.wrapper(glStencilFillPathInstancedNV).setInputArraySize( + 'paths', None +).setInputArraySize( + 'transformValues', None +) +# INPUT glStencilStrokePathInstancedNV.paths size not checked against 'numPaths,pathNameType,paths' +# INPUT glStencilStrokePathInstancedNV.transformValues size not checked against 'numPaths,transformType' +glStencilStrokePathInstancedNV=wrapper.wrapper(glStencilStrokePathInstancedNV).setInputArraySize( + 'paths', None +).setInputArraySize( + 'transformValues', None +) +# INPUT glCoverFillPathInstancedNV.paths size not checked against 'numPaths,pathNameType,paths' +# INPUT glCoverFillPathInstancedNV.transformValues size not checked against 'numPaths,transformType' +glCoverFillPathInstancedNV=wrapper.wrapper(glCoverFillPathInstancedNV).setInputArraySize( + 'paths', None +).setInputArraySize( + 'transformValues', None +) +# INPUT glCoverStrokePathInstancedNV.paths size not checked against 'numPaths,pathNameType,paths' +# INPUT glCoverStrokePathInstancedNV.transformValues size not checked against 'numPaths,transformType' +glCoverStrokePathInstancedNV=wrapper.wrapper(glCoverStrokePathInstancedNV).setInputArraySize( + 'paths', None +).setInputArraySize( + 'transformValues', None +) +glGetPathParameterivNV=wrapper.wrapper(glGetPathParameterivNV).setOutput( + 'value',size=(4,),orPassIn=True +) +glGetPathParameterfvNV=wrapper.wrapper(glGetPathParameterfvNV).setOutput( + 'value',size=(4,),orPassIn=True +) +glGetPathCommandsNV=wrapper.wrapper(glGetPathCommandsNV).setOutput( + 'commands',size=_glgets._glget_size_mapping,pnameArg='path',orPassIn=True +) +glGetPathCoordsNV=wrapper.wrapper(glGetPathCoordsNV).setOutput( + 'coords',size=_glgets._glget_size_mapping,pnameArg='path',orPassIn=True +) +glGetPathDashArrayNV=wrapper.wrapper(glGetPathDashArrayNV).setOutput( + 'dashArray',size=_glgets._glget_size_mapping,pnameArg='path',orPassIn=True +) +# OUTPUT glGetPathMetricsNV.metrics COMPSIZE(metricQueryMask, numPaths, stride) +# INPUT glGetPathMetricsNV.paths size not checked against 'numPaths,pathNameType,paths' +glGetPathMetricsNV=wrapper.wrapper(glGetPathMetricsNV).setInputArraySize( + 'paths', None +) +# OUTPUT glGetPathMetricRangeNV.metrics COMPSIZE(metricQueryMask, numPaths, stride) +# INPUT glGetPathSpacingNV.paths size not checked against 'numPaths,pathNameType,paths' +# OUTPUT glGetPathSpacingNV.returnedSpacing COMPSIZE(pathListMode, numPaths) +glGetPathSpacingNV=wrapper.wrapper(glGetPathSpacingNV).setInputArraySize( + 'paths', None +) +glPointAlongPathNV=wrapper.wrapper(glPointAlongPathNV).setOutput( + 'tangentX',size=(1,),orPassIn=True +).setOutput( + 'tangentY',size=(1,),orPassIn=True +).setOutput( + 'x',size=(1,),orPassIn=True +).setOutput( + 'y',size=(1,),orPassIn=True +) +# INPUT glPathColorGenNV.coeffs size not checked against 'genMode,colorFormat' +glPathColorGenNV=wrapper.wrapper(glPathColorGenNV).setInputArraySize( + 'coeffs', None +) +# INPUT glPathTexGenNV.coeffs size not checked against 'genMode,components' +glPathTexGenNV=wrapper.wrapper(glPathTexGenNV).setInputArraySize( + 'coeffs', None +) +glGetPathColorGenivNV=wrapper.wrapper(glGetPathColorGenivNV).setOutput( + 'value',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetPathColorGenfvNV=wrapper.wrapper(glGetPathColorGenfvNV).setOutput( + 'value',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetPathTexGenivNV=wrapper.wrapper(glGetPathTexGenivNV).setOutput( + 'value',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetPathTexGenfvNV=wrapper.wrapper(glGetPathTexGenfvNV).setOutput( + 'value',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glMatrixLoadTransposefEXT=wrapper.wrapper(glMatrixLoadTransposefEXT).setInputArraySize( + 'm', 16 +) +glMatrixLoadTransposedEXT=wrapper.wrapper(glMatrixLoadTransposedEXT).setInputArraySize( + 'm', 16 +) +glMatrixLoadfEXT=wrapper.wrapper(glMatrixLoadfEXT).setInputArraySize( + 'm', 16 +) +glMatrixLoaddEXT=wrapper.wrapper(glMatrixLoaddEXT).setInputArraySize( + 'm', 16 +) +glMatrixMultTransposefEXT=wrapper.wrapper(glMatrixMultTransposefEXT).setInputArraySize( + 'm', 16 +) +glMatrixMultTransposedEXT=wrapper.wrapper(glMatrixMultTransposedEXT).setInputArraySize( + 'm', 16 +) +glMatrixMultfEXT=wrapper.wrapper(glMatrixMultfEXT).setInputArraySize( + 'm', 16 +) +glMatrixMultdEXT=wrapper.wrapper(glMatrixMultdEXT).setInputArraySize( + 'm', 16 +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/path_rendering_shared_edge.py b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/path_rendering_shared_edge.py new file mode 100644 index 00000000..18a9508a --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/path_rendering_shared_edge.py @@ -0,0 +1,36 @@ +'''OpenGL extension NV.path_rendering_shared_edge + +This module customises the behaviour of the +OpenGL.raw.GL.NV.path_rendering_shared_edge to provide a more +Python-friendly API + +Overview (from the spec) + + This extension introduces a new path command modifier to the + NV_path_rendering extension to indicate that a path command represents an + edge (either straight or curved) that is shared with another path. + + When used in conjunction with NV_framebuffer_mixed_samples, a shared edge + (or a whole path including shared edges) will use modified rasterization + rules in order to ensure that groups of raster samples associated with a + given coverage sample will all produce consistent coverage results, in + order to avoid artifacts described further in the issues section at the + end of this document. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/path_rendering_shared_edge.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.NV.path_rendering_shared_edge import * +from OpenGL.raw.GL.NV.path_rendering_shared_edge import _EXTENSION_NAME + +def glInitPathRenderingSharedEdgeNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/pixel_data_range.py b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/pixel_data_range.py new file mode 100644 index 00000000..9e54a198 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/pixel_data_range.py @@ -0,0 +1,85 @@ +'''OpenGL extension NV.pixel_data_range + +This module customises the behaviour of the +OpenGL.raw.GL.NV.pixel_data_range to provide a more +Python-friendly API + +Overview (from the spec) + + The vertex array range extension is intended to improve the + efficiency of OpenGL vertex arrays. OpenGL vertex arrays' coherency + model and ability to access memory from arbitrary locations in memory + prevented implementations from using DMA (Direct Memory Access) + operations. + + Many image-intensive applications, such as those that use dynamically + generated textures, face similar problems. These applications would + like to be able to sustain throughputs of hundreds of millions of + pixels per second through DrawPixels and hundreds of millions of + texels per second through TexSubImage. + + However, the same restrictions that limited vertex throughput also + limit pixel throughput. + + By the time that any pixel operation that reads data from user memory + returns, OpenGL requires that it must be safe for the application to + start using that memory for a different purpose. This coherency + model prevents asynchronous DMA transfers directly out of the user's + buffer. + + There are also no restrictions on the pointer provided to pixel + operations or on the size of the data. To facilitate DMA + implementations, the driver needs to know in advance what region of + the address space to lock down. + + Vertex arrays faced both of these restrictions already, but pixel + operations have one additional complicating factor -- they are + bidirectional. Vertex array data is always being transfered from the + application to the driver and the HW, whereas pixel operations + sometimes transfer data to the application from the driver and HW. + Note that the types of memory that are suitable for DMA for reading + and writing purposes are often different. For example, on many PC + platforms, DMA pulling is best accomplished with write-combined + (uncached) AGP memory, while pushing data should use cached memory so + that the application can read the data efficiently once it has been + read back over the AGP bus. + + This extension defines an API where an application can specify two + pixel data ranges, which are analogous to vertex array ranges, except + that one is for operations where the application is reading data + (e.g. glReadPixels) and one is for operations where the application + is writing data (e.g. glDrawPixels, glTexSubImage2D, etc.). Each + pixel data range has a pointer to its start and a length in bytes. + + When the pixel data range is enabled, and if the pointer specified + as the argument to a pixel operation is inside the corresponding + pixel data range, the implementation may choose to asynchronously + pull data from the pixel data range or push data to the pixel data + range. Data pulled from outside the pixel data range is undefined, + while pushing data to outside the pixel data range produces undefined + results. + + The application may synchronize with the hardware in one of two ways: + by flushing the pixel data range (or causing an implicit flush) or by + using the NV_fence extension to insert fences in the command stream. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/pixel_data_range.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.NV.pixel_data_range import * +from OpenGL.raw.GL.NV.pixel_data_range import _EXTENSION_NAME + +def glInitPixelDataRangeNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glPixelDataRangeNV.pointer size not checked against length +glPixelDataRangeNV=wrapper.wrapper(glPixelDataRangeNV).setInputArraySize( + 'pointer', None +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/point_sprite.py b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/point_sprite.py new file mode 100644 index 00000000..d9419ae8 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/point_sprite.py @@ -0,0 +1,51 @@ +'''OpenGL extension NV.point_sprite + +This module customises the behaviour of the +OpenGL.raw.GL.NV.point_sprite to provide a more +Python-friendly API + +Overview (from the spec) + + Applications such as particle systems usually must use OpenGL quads + rather than points to render their geometry, since they would like to + use a custom-drawn texture for each particle, rather than the + traditional OpenGL round antialiased points, and each fragment in + a point has the same texture coordinates as every other fragment. + + Unfortunately, specifying the geometry for these quads can be quite + expensive, since it quadruples the amount of geometry required, and + it may also require the application to do extra processing to compute + the location of each vertex. + + The goal of this extension is to allow such apps to use points rather + than quads. When GL_POINT_SPRITE_NV is enabled, the state of point + antialiasing is ignored. For each texture unit, the app can then + specify whether to replace the existing texture coordinates with + point sprite texture coordinates, which are interpolated across the + point. Finally, the app can set a global parameter for the way to + generate the R coordinate for point sprites; the R coordinate can + either be zero, the input S coordinate, or the input R coordinate. + This allows applications to use a 3D texture to represent a point + sprite that goes through an animation, with filtering between frames, + for example. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/point_sprite.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.NV.point_sprite import * +from OpenGL.raw.GL.NV.point_sprite import _EXTENSION_NAME + +def glInitPointSpriteNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glPointParameterivNV.params size not checked against 'pname' +glPointParameterivNV=wrapper.wrapper(glPointParameterivNV).setInputArraySize( + 'params', None +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/present_video.py b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/present_video.py new file mode 100644 index 00000000..6e584719 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/present_video.py @@ -0,0 +1,51 @@ +'''OpenGL extension NV.present_video + +This module customises the behaviour of the +OpenGL.raw.GL.NV.present_video to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides a mechanism for displaying textures and + renderbuffers on auxiliary video output devices. It allows an + application to specify separate buffers for the individual + fields used with interlaced output. It also provides a way + to present frames or field pairs simultaneously in two separate + video streams. It also allows an application to request when images + should be displayed, and to obtain feedback on exactly when images + are actually first displayed. + + This specification attempts to avoid language that would tie it to + any particular hardware or vendor. However, it should be noted that + it has been designed specifically for use with NVIDIA SDI products + and the features and limitations of the spec compliment those of + NVIDIA's line of SDI video output devices. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/present_video.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.NV.present_video import * +from OpenGL.raw.GL.NV.present_video import _EXTENSION_NAME + +def glInitPresentVideoNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +glGetVideoivNV=wrapper.wrapper(glGetVideoivNV).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetVideouivNV=wrapper.wrapper(glGetVideouivNV).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetVideoi64vNV=wrapper.wrapper(glGetVideoi64vNV).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetVideoui64vNV=wrapper.wrapper(glGetVideoui64vNV).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/primitive_restart.py b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/primitive_restart.py new file mode 100644 index 00000000..d435bfeb --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/primitive_restart.py @@ -0,0 +1,49 @@ +'''OpenGL extension NV.primitive_restart + +This module customises the behaviour of the +OpenGL.raw.GL.NV.primitive_restart to provide a more +Python-friendly API + +Overview (from the spec) + + This extension allows applications to easily and inexpensively + restart a primitive in its middle. A "primitive restart" is simply + the same as an End command, followed by another Begin command with + the same mode as the original. The typical expected use of this + feature is to draw a mesh with many triangle strips, though primitive + restarts are legal for all primitive types, even for points (where + they are not useful). + + Although the EXT_multi_draw_arrays extension did reduce the overhead + of such drawing techniques, they still remain more expensive than one + would like. + + This extension provides an extremely lightweight primitive restart, + which is accomplished by allowing the application to choose a special + index number that signals that a primitive restart should occur, + rather than a vertex being provoked. This index can be an arbitrary + 32-bit integer for maximum application convenience. + + In addition, for full orthogonality, a special OpenGL command is + provided to restart primitives when in immediate mode. This command + is not likely to increase performance in any significant fashion, but + providing it greatly simplifies the specification and implementation + of display list compilation and indirect rendering. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/primitive_restart.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.NV.primitive_restart import * +from OpenGL.raw.GL.NV.primitive_restart import _EXTENSION_NAME + +def glInitPrimitiveRestartNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/query_resource.py b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/query_resource.py new file mode 100644 index 00000000..6c9595ef --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/query_resource.py @@ -0,0 +1,45 @@ +'''OpenGL extension NV.query_resource + +This module customises the behaviour of the +OpenGL.raw.GL.NV.query_resource to provide a more +Python-friendly API + +Overview (from the spec) + + OpenGL implementations manage the residence of textures, shaders, and + other graphical objects in GPU accessible memory (whether in on-board + video memory or addressable system memory is implementation dependent). + With more insight into OpenGL's memory usage 1) applications could make + educated decisions on better utilizing the limited GPU resources, + 2) users could better optimize their workflow when working with multiple + tools, and 3) administrators can make better decisions regarding resource + allocation and system configurations. + + The purpose of this extension is to return a more detailed breakdown + of memory usage in terms of the OpenGL objects residing in memory + (textures, render buffers, buffer objects, system reserved objects, ...). + This extension differs from GL_NVX_gpu_memory_info in that this extension + returns detailed memory usage at the object level for video memory while + the other extension only reports total vidmem usage. + + For the purposes of this specification the term vidmem refers to video + memory resident on the graphics card that is directly accessible to the + GPU at the highest performance level. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/query_resource.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.NV.query_resource import * +from OpenGL.raw.GL.NV.query_resource import _EXTENSION_NAME + +def glInitQueryResourceNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/query_resource_tag.py b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/query_resource_tag.py new file mode 100644 index 00000000..089be1bf --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/query_resource_tag.py @@ -0,0 +1,38 @@ +'''OpenGL extension NV.query_resource_tag + +This module customises the behaviour of the +OpenGL.raw.GL.NV.query_resource_tag to provide a more +Python-friendly API + +Overview (from the spec) + + This extension adds the capability to associate a tag with one or more + memory resource allocations. This tag can be reported back during + queryResource operations and also be used to limit resource reporting to + only those allocations with the specified tag. A tag is a previously + reserved id and an optional text string. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/query_resource_tag.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.NV.query_resource_tag import * +from OpenGL.raw.GL.NV.query_resource_tag import _EXTENSION_NAME + +def glInitQueryResourceTagNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glGenQueryResourceTagNV.tagIds size not checked against n +glGenQueryResourceTagNV=wrapper.wrapper(glGenQueryResourceTagNV).setInputArraySize( + 'tagIds', None +) +# INPUT glDeleteQueryResourceTagNV.tagIds size not checked against n +glDeleteQueryResourceTagNV=wrapper.wrapper(glDeleteQueryResourceTagNV).setInputArraySize( + 'tagIds', None +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/register_combiners.py b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/register_combiners.py new file mode 100644 index 00000000..fa516d08 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/register_combiners.py @@ -0,0 +1,117 @@ +'''OpenGL extension NV.register_combiners + +This module customises the behaviour of the +OpenGL.raw.GL.NV.register_combiners to provide a more +Python-friendly API + +Overview (from the spec) + + NVIDIA's next-generation graphics processor and its derivative + designs support an extremely configurable mechanism know as "register + combiners" for computing fragment colors. + + The register combiner mechanism is a significant redesign of NVIDIA's + original TNT combiner mechanism as introduced by NVIDIA's RIVA + TNT graphics processor. Familiarity with the TNT combiners will + help the reader appreciate the greatly enhanced register combiners + functionality (see the NV_texture_env_combine4 OpenGL extension + specification for this background). The register combiner mechanism + has the following enhanced functionality: + + The numeric range of combiner computations is from [-1,1] + (instead of TNT's [0,1] numeric range), + + The set of available combiner inputs is expanded to include the + secondary color, fog color, fog factor, and a second combiner + constant color (TNT's available combiner inputs consist of + only zero, a single combiner constant color, the primary color, + texture 0, texture 1, and, in the case of combiner 1, the result + of combiner 0). + + Each combiner variable input can be independently scaled and + biased into several possible numeric ranges (TNT can only + complement combiner inputs). + + Each combiner stage computes three distinct outputs (instead + TNT's single combiner output). + + The output operations include support for computing dot products + (TNT has no support for computing dot products). + + After each output operation, there is a configurable scale and bias + applied (TNT's combiner operations builds in a scale and/or bias + into some of its combiner operations). + + Each input variable for each combiner stage is fetched from any + entry in a combiner register set. Moreover, the outputs of each + combiner stage are written into the register set of the subsequent + combiner stage (TNT could only use the result from combiner 0 as + a possible input to combiner 1; TNT lacks the notion of an + input/output register set). + + The register combiner mechanism supports at least two general + combiner stages and then a special final combiner stage appropriate + for applying a color sum and fog computation (TNT provides two + simpler combiner stages, and TNT's color sum and fog stages are + hard-wired and not subsumed by the combiner mechanism as in register + combiners). + + The register combiners fit into the OpenGL pipeline as a rasterization + processing stage operating in parallel to the traditional OpenGL + texture environment, color sum, AND fog application. Enabling this + extension bypasses OpenGL's existing texture environment, color + sum, and fog application processing and instead use the register + combiners. The combiner and texture environment state is orthogonal + so modifying combiner state does not change the traditional OpenGL + texture environment state and the texture environment state is + ignored when combiners are enabled. + + OpenGL application developers can use the register combiner mechanism + for very sophisticated shading techniques. For example, an + approximation of Blinn's bump mapping technique can be achieved with + the combiner mechanism. Additionally, multi-pass shading models + that require several passes with unextended OpenGL 1.2 functionality + can be implemented in several fewer passes with register combiners. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/register_combiners.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.NV.register_combiners import * +from OpenGL.raw.GL.NV.register_combiners import _EXTENSION_NAME + +def glInitRegisterCombinersNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glCombinerParameterfvNV.params size not checked against 'pname' +glCombinerParameterfvNV=wrapper.wrapper(glCombinerParameterfvNV).setInputArraySize( + 'params', None +) +# INPUT glCombinerParameterivNV.params size not checked against 'pname' +glCombinerParameterivNV=wrapper.wrapper(glCombinerParameterivNV).setInputArraySize( + 'params', None +) +glGetCombinerInputParameterfvNV=wrapper.wrapper(glGetCombinerInputParameterfvNV).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetCombinerInputParameterivNV=wrapper.wrapper(glGetCombinerInputParameterivNV).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetCombinerOutputParameterfvNV=wrapper.wrapper(glGetCombinerOutputParameterfvNV).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetCombinerOutputParameterivNV=wrapper.wrapper(glGetCombinerOutputParameterivNV).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetFinalCombinerInputParameterfvNV=wrapper.wrapper(glGetFinalCombinerInputParameterfvNV).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetFinalCombinerInputParameterivNV=wrapper.wrapper(glGetFinalCombinerInputParameterivNV).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/register_combiners2.py b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/register_combiners2.py new file mode 100644 index 00000000..b20e135c --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/register_combiners2.py @@ -0,0 +1,58 @@ +'''OpenGL extension NV.register_combiners2 + +This module customises the behaviour of the +OpenGL.raw.GL.NV.register_combiners2 to provide a more +Python-friendly API + +Overview (from the spec) + + The NV_register_combiners extension provides a powerful fragment + coloring mechanism. This specification extends the register combiners + functionality to support more color constant values that are unique + for each general combiner stage. + + The base register combiners functionality supports only two color + constants. These two constants are available in every general + combiner stage and in the final combiner. + + When many general combiner stages are supported, more than two + unique color constants is often required. The obvious way to extend + the register combiners is to add several more color constant + registers. But adding new unique color constant registers is + expensive for hardware implementation because every color constant + register must be available as an input to any stage. + + In practice however, it is the total set of general combiner stages + that requires more color constants, not each and every individual + general combiner stage. Each individual general combiner stage + typically requires only one or two color constants. + + By keeping two color constant registers but making these two registers + contain two unique color constant values for each general combiner + stage, the hardware expense of supporting multiple color constants + is minimized. Additionally, this scheme scales appropriately as + more general combiner stages are added. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/register_combiners2.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.NV.register_combiners2 import * +from OpenGL.raw.GL.NV.register_combiners2 import _EXTENSION_NAME + +def glInitRegisterCombiners2NV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glCombinerStageParameterfvNV.params size not checked against 'pname' +glCombinerStageParameterfvNV=wrapper.wrapper(glCombinerStageParameterfvNV).setInputArraySize( + 'params', None +) +glGetCombinerStageParameterfvNV=wrapper.wrapper(glGetCombinerStageParameterfvNV).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/representative_fragment_test.py b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/representative_fragment_test.py new file mode 100644 index 00000000..79351cfc --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/representative_fragment_test.py @@ -0,0 +1,52 @@ +'''OpenGL extension NV.representative_fragment_test + +This module customises the behaviour of the +OpenGL.raw.GL.NV.representative_fragment_test to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides a new _representative fragment test_ that allows + implementations to reduce the amount of rasterization and fragment + processing work performed for each point, line, or triangle primitive. For + any primitive that produces one or more fragments that pass all other + early fragment tests, the implementation is permitted to choose one or + more "representative" fragments for processing and discard all other + fragments. For draw calls rendering multiple points, lines, or triangles + arranged in lists, strips, or fans, the representative fragment test is + performed independently for each of those primitives. + + This extension is useful for applications that use an early render pass + to determine the full set of primitives that would be visible in the final + scene. In this render pass, such applications would set up a fragment + shader that enables early fragment tests and writes to an image or shader + storage buffer to record the ID of the primitive that generated the + fragment. Without this extension, the shader would record the ID + separately for each visible fragment of each primitive. With this + extension, fewer stores will be performed, particularly for large + primitives. + + The representative fragment test has no effect if early fragment tests are + not enabled via the fragment shader. The set of fragments discarded by the + representative fragment test is implementation-dependent and may vary from + frame to frame. In some cases, the representative fragment test may not + discard any fragments for a given primitive. + + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/representative_fragment_test.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.NV.representative_fragment_test import * +from OpenGL.raw.GL.NV.representative_fragment_test import _EXTENSION_NAME + +def glInitRepresentativeFragmentTestNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/robustness_video_memory_purge.py b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/robustness_video_memory_purge.py new file mode 100644 index 00000000..d6c295f7 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/robustness_video_memory_purge.py @@ -0,0 +1,48 @@ +'''OpenGL extension NV.robustness_video_memory_purge + +This module customises the behaviour of the +OpenGL.raw.GL.NV.robustness_video_memory_purge to provide a more +Python-friendly API + +Overview (from the spec) + + Allow applications to be notified when video memory has been purged. + + The NVIDIA OpenGL driver architecture on Linux has a limitation: + resources located in video memory are not persistent across certain + events. VT switches, suspend/resume events, and mode switching + events may erase the contents of video memory. Any resource that + is located exclusively in video memory, such as framebuffer objects + (FBOs), will be lost. As the OpenGL specification makes no mention + of events where the video memory is allowed to be cleared, the + driver attempts to hide this fact from the application, but cannot + do it for all resources. + + This extension provides a way for applications to discover when video + memory content has been lost, so that the application can re-populate + the video memory content as necessary. + + This extension will have a limited lifespan, as planned architectural + evolutions in the NVIDIA Linux driver stack will allow + video memory to be persistent. Any driver that exposes this + extension is a driver that considers video memory to be + volatile. Once the driver stack has been improved, the extension + will no longer be exposed. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/robustness_video_memory_purge.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.NV.robustness_video_memory_purge import * +from OpenGL.raw.GL.NV.robustness_video_memory_purge import _EXTENSION_NAME + +def glInitRobustnessVideoMemoryPurgeNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/sample_locations.py b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/sample_locations.py new file mode 100644 index 00000000..5d4ceb3e --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/sample_locations.py @@ -0,0 +1,56 @@ +'''OpenGL extension NV.sample_locations + +This module customises the behaviour of the +OpenGL.raw.GL.NV.sample_locations to provide a more +Python-friendly API + +Overview (from the spec) + + This extension allows an application to modify the locations of samples + within a pixel used in multisample rasterization. Additionally, it allows + applications to specify different sample locations for each pixel in a + group of adjacent pixels, which may increase antialiasing quality + (particularly if a custom resolve shader is used that takes advantage of + these different locations). + + It is common for implementations to optimize the storage of depth values + by storing values that can be used to reconstruct depth at each sample + location, rather than storing separate depth values for each sample. For + example, the depth values from a single triangle can be represented using + plane equations. When the depth value for a sample is needed, it is + automatically evaluated at the sample location. Modifying the sample + locations causes the reconstruction to no longer evaluate the same depth + values as when the samples were originally generated. This extension + provides a command to "resolve" and store per-sample depth values using + the currently programmed sample locations, which allows the application to + manage this issue if/when necessary. + + The programmable sample locations are used during rasterization and for + evaluation of depth functions during normal geometric rendering. The + programmable locations are associated with a framebuffer object rather + than an individual depth buffer, so if the depth buffer is used as a + texture the texture sampling may be done at the standard sample + locations. Additionally, commands that do not render geometric primitives + (e.g. ReadPixels, BlitFramebuffer, CopyTexSubImage2D, etc.) may use the + standard sample locations to resolve depth functions rather than the + programmable locations. If a single depth buffer is used at different + times with different sample locations, the depth functions may be + interpreted using the current sample locations. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/sample_locations.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.NV.sample_locations import * +from OpenGL.raw.GL.NV.sample_locations import _EXTENSION_NAME + +def glInitSampleLocationsNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/sample_mask_override_coverage.py b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/sample_mask_override_coverage.py new file mode 100644 index 00000000..9a112627 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/sample_mask_override_coverage.py @@ -0,0 +1,33 @@ +'''OpenGL extension NV.sample_mask_override_coverage + +This module customises the behaviour of the +OpenGL.raw.GL.NV.sample_mask_override_coverage to provide a more +Python-friendly API + +Overview (from the spec) + + This extension allows the fragment shader to control whether the + gl_SampleMask output can enable samples that were not covered by the + original primitive, or that failed the early depth/stencil tests. + This can be enabled by redeclaring the gl_SampleMask output with the + "override_coverage" layout qualifier: + + layout(override_coverage) out int gl_SampleMask[]; + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/sample_mask_override_coverage.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.NV.sample_mask_override_coverage import * +from OpenGL.raw.GL.NV.sample_mask_override_coverage import _EXTENSION_NAME + +def glInitSampleMaskOverrideCoverageNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/scissor_exclusive.py b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/scissor_exclusive.py new file mode 100644 index 00000000..f2ab24ef --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/scissor_exclusive.py @@ -0,0 +1,41 @@ +'''OpenGL extension NV.scissor_exclusive + +This module customises the behaviour of the +OpenGL.raw.GL.NV.scissor_exclusive to provide a more +Python-friendly API + +Overview (from the spec) + + In unextended OpenGL, applications can enable a per-viewport scissor test + (SCISSOR_TEST) where fragments are discarded if their (x,y) coordinates + lie outside the corresponding scissor rectangle. In this extension, we + provide a separate per-viewport exclusive scissor test, where fragments + are discarded if their (x,y) coordinates lie *inside* the corresponding + exclusive scissor rectangle. + + The regular (inclusive) scissor test and exclusive scissor test are + orthogonal; applications can enable either or both tests for each + viewport. If both tests are enabled, fragments will be discarded unless + their (x,y) coordinates are both inside the regular scissor rectangle and + outside the exclusive scissor rectangle. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/scissor_exclusive.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.NV.scissor_exclusive import * +from OpenGL.raw.GL.NV.scissor_exclusive import _EXTENSION_NAME + +def glInitScissorExclusiveNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glScissorExclusiveArrayvNV.v size not checked against 'count' +glScissorExclusiveArrayvNV=wrapper.wrapper(glScissorExclusiveArrayvNV).setInputArraySize( + 'v', None +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/shader_atomic_counters.py b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/shader_atomic_counters.py new file mode 100644 index 00000000..786c012e --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/shader_atomic_counters.py @@ -0,0 +1,34 @@ +'''OpenGL extension NV.shader_atomic_counters + +This module customises the behaviour of the +OpenGL.raw.GL.NV.shader_atomic_counters to provide a more +Python-friendly API + +Overview (from the spec) + + This extension builds upon the ARB_shader_atomic_counters and + NV_gpu_program5 extensions to provide assembly language support for + incrementing, decrementing, and querying the values of atomic counters + stored in buffer object memory. + + The extension uses the same set of atomic counter buffer binding points as + the ARB_shader_atomic_counters extension; applications using this + extension should use the APIs specified there to bind buffers. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/shader_atomic_counters.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.NV.shader_atomic_counters import * +from OpenGL.raw.GL.NV.shader_atomic_counters import _EXTENSION_NAME + +def glInitShaderAtomicCountersNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/shader_atomic_float.py b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/shader_atomic_float.py new file mode 100644 index 00000000..528bf278 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/shader_atomic_float.py @@ -0,0 +1,39 @@ +'''OpenGL extension NV.shader_atomic_float + +This module customises the behaviour of the +OpenGL.raw.GL.NV.shader_atomic_float to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides GLSL built-in functions and assembly opcodes + allowing shaders to perform atomic read-modify-write operations to buffer + or texture memory with floating-point components. The set of atomic + operations provided by this extension is limited to adds and exchanges. + Providing atomic add support allows shaders to atomically accumulate the + sum of floating-point values into buffer or texture memory across multiple + (possibly concurrent) shader invocations. + + This extension provides GLSL support for atomics targeting image uniforms + (if GLSL 4.20, ARB_shader_image_load_store, or EXT_shader_image_load_store + is supported) or floating-point pointers (if NV_gpu_shader5 is supported). + Additionally, assembly opcodes for these operations is also provided if + NV_gpu_program5 is supported. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/shader_atomic_float.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.NV.shader_atomic_float import * +from OpenGL.raw.GL.NV.shader_atomic_float import _EXTENSION_NAME + +def glInitShaderAtomicFloatNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/shader_atomic_float64.py b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/shader_atomic_float64.py new file mode 100644 index 00000000..ae031b33 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/shader_atomic_float64.py @@ -0,0 +1,38 @@ +'''OpenGL extension NV.shader_atomic_float64 + +This module customises the behaviour of the +OpenGL.raw.GL.NV.shader_atomic_float64 to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides GLSL built-in functions and assembly opcodes + allowing shaders to perform atomic read-modify-write operations to buffer + or shared memory with double-precision floating-point components. The set + of atomic operations provided by this extension is limited to adds and + exchanges. Providing atomic add support allows shaders to atomically + accumulate the sum of double-precision floating-point values into buffer + memory across multiple (possibly concurrent) shader invocations. + + This extension provides GLSL support for atomics targeting double-precision + floating-point pointers (if NV_gpu_shader5 is supported). + Additionally, assembly opcodes for these operations are also provided if + NV_gpu_program5 is supported. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/shader_atomic_float64.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.NV.shader_atomic_float64 import * +from OpenGL.raw.GL.NV.shader_atomic_float64 import _EXTENSION_NAME + +def glInitShaderAtomicFloat64NV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/shader_atomic_fp16_vector.py b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/shader_atomic_fp16_vector.py new file mode 100644 index 00000000..ee1a621b --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/shader_atomic_fp16_vector.py @@ -0,0 +1,30 @@ +'''OpenGL extension NV.shader_atomic_fp16_vector + +This module customises the behaviour of the +OpenGL.raw.GL.NV.shader_atomic_fp16_vector to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides GLSL built-in functions and assembly opcodes + allowing shaders to perform a limited set of atomic read-modify-write + operations to buffer or texture memory with 16-bit floating point vector + surface formats. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/shader_atomic_fp16_vector.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.NV.shader_atomic_fp16_vector import * +from OpenGL.raw.GL.NV.shader_atomic_fp16_vector import _EXTENSION_NAME + +def glInitShaderAtomicFp16VectorNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/shader_atomic_int64.py b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/shader_atomic_int64.py new file mode 100644 index 00000000..7673c1ea --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/shader_atomic_int64.py @@ -0,0 +1,30 @@ +'''OpenGL extension NV.shader_atomic_int64 + +This module customises the behaviour of the +OpenGL.raw.GL.NV.shader_atomic_int64 to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides additional GLSL built-in functions and assembly + opcodes allowing shaders to perform additional atomic read-modify-write + operations on 64-bit signed and unsigned integers stored in buffer object + memory. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/shader_atomic_int64.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.NV.shader_atomic_int64 import * +from OpenGL.raw.GL.NV.shader_atomic_int64 import _EXTENSION_NAME + +def glInitShaderAtomicInt64NV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/shader_buffer_load.py b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/shader_buffer_load.py new file mode 100644 index 00000000..a4c96456 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/shader_buffer_load.py @@ -0,0 +1,135 @@ +'''OpenGL extension NV.shader_buffer_load + +This module customises the behaviour of the +OpenGL.raw.GL.NV.shader_buffer_load to provide a more +Python-friendly API + +Overview (from the spec) + + At a very coarse level, GL has evolved in a way that allows + applications to replace many of the original state machine variables + with blocks of user-defined data. For example, the current vertex + state has been augmented by vertex buffer objects, fixed-function + shading state and parameters have been replaced by shaders/programs + and constant buffers, etc.. Applications switch between coarse sets + of state by binding objects to the context or to other container + objects (e.g. vertex array objects) instead of manipulating state + variables of the context. In terms of the number of GL commands + required to draw an object, modern applications are orders of + magnitude more efficient than legacy applications, but this explosion + of objects bound to other objects has led to a new bottleneck - + pointer chasing and CPU L2 cache misses in the driver, and general + L2 cache pollution. + + This extension provides a mechanism to read from a flat, 64-bit GPU + address space from programs/shaders, to query GPU addresses of buffer + objects at the API level, and to bind buffer objects to the context in + such a way that they can be accessed via their GPU addresses in any + shader stage. + + The intent is that applications can avoid re-binding buffer objects + or updating constants between each Draw call and instead simply use + a VertexAttrib (or TexCoord, or InstanceID, or...) to "point" to the + new object's state. In this way, one of the cheapest "state" updates + (from the CPU's point of view) can be used to effect a significant + state change in the shader similarly to how a pointer change may on + the CPU. At the same time, this relieves the limits on how many + buffer objects can be accessed at once by shaders, and allows these + buffer object accesses to be exposed as C-style pointer dereferences + in the shading language. + + As a very simple example, imagine packing a group of similar objects' + constants into a single buffer object and pointing your program + at object by setting "glVertexAttribI1iEXT(attrLoc, i);" + and using a shader as such: + + struct MyObjectType { + mat4x4 modelView; + vec4 materialPropertyX; + // etc. + }; + uniform MyObjectType *allObjects; + in int objectID; // bound to attrLoc + + ... + + mat4x4 thisObjectsMatrix = allObjects[objectID].modelView; + // do transform, shading, etc. + + This is beneficial in much the same way that texture arrays allow + choosing between similar, but independent, texture maps with a single + coordinate identifying which slice of the texture to use. It also + resembles instancing, where a lightweight change (incrementing the + instance ID) can be used to generate a different and interesting + result, but with additional flexibility over instancing because the + values are app-controlled and not a single incrementing counter. + + Dependent pointer fetches are allowed, so more complex scene graph + structures can be built into buffer objects providing significant new + flexibility in the use of shaders. Another simple example, showing + something you can't do with existing functionality, is to do dependent + fetches into many buffer objects: + + GenBuffers(N, dataBuffers); + GenBuffers(1, &pointerBuffer); + + GLuint64EXT gpuAddrs[N]; + for (i = 0; i < N; ++i) { + BindBuffer(target, dataBuffers[i]); + BufferData(target, size[i], myData[i], STATIC_DRAW); + + // get the address of this buffer and make it resident. + GetBufferParameterui64vNV(target, BUFFER_GPU_ADDRESS, + gpuaddrs[i]); + MakeBufferResidentNV(target, READ_ONLY); + } + + GLuint64EXT pointerBufferAddr; + BindBuffer(target, pointerBuffer); + BufferData(target, sizeof(GLuint64EXT)*N, gpuAddrs, STATIC_DRAW); + GetBufferParameterui64vNV(target, BUFFER_GPU_ADDRESS, + &pointerBufferAddr); + MakeBufferResidentNV(target, READ_ONLY); + + // now in the shader, we can use a double indirection + vec4 **ptrToBuffers = pointerBufferAddr; + vec4 *ptrToBufferI = ptrToBuffers[i]; + + This allows simultaneous access to more buffers than + EXT_bindable_uniform (MAX_VERTEX_BINDABLE_UNIFORMS, etc.) and each + can be larger than MAX_BINDABLE_UNIFORM_SIZE. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/shader_buffer_load.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.NV.shader_buffer_load import * +from OpenGL.raw.GL.NV.shader_buffer_load import _EXTENSION_NAME + +def glInitShaderBufferLoadNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +glGetBufferParameterui64vNV=wrapper.wrapper(glGetBufferParameterui64vNV).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetNamedBufferParameterui64vNV=wrapper.wrapper(glGetNamedBufferParameterui64vNV).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetIntegerui64vNV=wrapper.wrapper(glGetIntegerui64vNV).setOutput( + 'result',size=_glgets._glget_size_mapping,pnameArg='value',orPassIn=True +) +# INPUT glUniformui64vNV.value size not checked against count +glUniformui64vNV=wrapper.wrapper(glUniformui64vNV).setInputArraySize( + 'value', None +) +# OUTPUT glGetUniformui64vNV.params COMPSIZE(program, location) +# INPUT glProgramUniformui64vNV.value size not checked against count +glProgramUniformui64vNV=wrapper.wrapper(glProgramUniformui64vNV).setInputArraySize( + 'value', None +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/shader_buffer_store.py b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/shader_buffer_store.py new file mode 100644 index 00000000..02b1c721 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/shader_buffer_store.py @@ -0,0 +1,50 @@ +'''OpenGL extension NV.shader_buffer_store + +This module customises the behaviour of the +OpenGL.raw.GL.NV.shader_buffer_store to provide a more +Python-friendly API + +Overview (from the spec) + + This extension builds upon the mechanisms added by the + NV_shader_buffer_load extension to allow shaders to perform random-access + reads to buffer object memory without using dedicated buffer object + binding points. Instead, it allowed an application to make a buffer + object resident, query a GPU address (pointer) for the buffer object, and + then use that address as a pointer in shader code. This approach allows + shaders to access a large number of buffer objects without needing to + repeatedly bind buffers to a limited number of fixed-functionality binding + points. + + This extension lifts the restriction from NV_shader_buffer_load that + disallows writes. In particular, the MakeBufferResidentNV function now + allows READ_WRITE and WRITE_ONLY access modes, and the shading language is + extended to allow shaders to write through (GPU address) pointers. + Additionally, the extension provides built-in functions to perform atomic + memory transactions to buffer object memory. + + As with the shader writes provided by the EXT_shader_image_load_store + extension, writes to buffer object memory using this extension are weakly + ordered to allow for parallel or distributed shader execution. The + EXT_shader_image_load_store extension provides mechanisms allowing for + finer control of memory transaction order, and those mechanisms apply + equally to buffer object stores using this extension. + + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/shader_buffer_store.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.NV.shader_buffer_store import * +from OpenGL.raw.GL.NV.shader_buffer_store import _EXTENSION_NAME + +def glInitShaderBufferStoreNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/shader_storage_buffer_object.py b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/shader_storage_buffer_object.py new file mode 100644 index 00000000..4748743c --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/shader_storage_buffer_object.py @@ -0,0 +1,34 @@ +'''OpenGL extension NV.shader_storage_buffer_object + +This module customises the behaviour of the +OpenGL.raw.GL.NV.shader_storage_buffer_object to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides assembly language support for shader storage + buffers (from the ARB_shader_storage_buffer_object extension) for all + program types supported by NV_gpu_program5, including compute programs + added by the NV_compute_program5 extension. + + Assembly programs using this extension can read and write to the memory of + buffer objects bound to the binding points provided by + ARB_shader_storage_buffer_object. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/shader_storage_buffer_object.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.NV.shader_storage_buffer_object import * +from OpenGL.raw.GL.NV.shader_storage_buffer_object import _EXTENSION_NAME + +def glInitShaderStorageBufferObjectNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/shader_subgroup_partitioned.py b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/shader_subgroup_partitioned.py new file mode 100644 index 00000000..b968d78a --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/shader_subgroup_partitioned.py @@ -0,0 +1,38 @@ +'''OpenGL extension NV.shader_subgroup_partitioned + +This module customises the behaviour of the +OpenGL.raw.GL.NV.shader_subgroup_partitioned to provide a more +Python-friendly API + +Overview (from the spec) + + This extension enables support for the NV_shader_subgroup_partitioned + shading language extension in OpenGL and OpenGL ES. + + This extension adds a new SUBGROUP_FEATURE_PARTITIONED_BIT_NV feature bit + that is returned by queryies for SUBGROUP_SUPPORTED_FEATURES_KHR. + + In OpenGL implementations supporting SPIR-V, this extension enables + support for the SPV_NV_shader_subgroup_partitioned extension. + + In OpenGL ES implementations, this extension does NOT add support for + SPIR-V or for any of the built-in shading language functions (8.18) + that have genDType (double) prototypes. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/shader_subgroup_partitioned.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.NV.shader_subgroup_partitioned import * +from OpenGL.raw.GL.NV.shader_subgroup_partitioned import _EXTENSION_NAME + +def glInitShaderSubgroupPartitionedNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/shader_texture_footprint.py b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/shader_texture_footprint.py new file mode 100644 index 00000000..51075280 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/shader_texture_footprint.py @@ -0,0 +1,74 @@ +'''OpenGL extension NV.shader_texture_footprint + +This module customises the behaviour of the +OpenGL.raw.GL.NV.shader_texture_footprint to provide a more +Python-friendly API + +Overview (from the spec) + + This extension adds OpenGL API support for the OpenGL Shading Language + (GLSL) extension "NV_shader_texture_footprint". That extension adds a new + set of texture query functions ("textureFootprint*NV") to GLSL. These + built-in functions prepare to perform a filtered texture lookup based on + coordinates and other parameters passed in by the calling code. However, + instead of returning data from the provided texture image, these query + functions instead return data identifying the _texture footprint_ for an + equivalent texture access. The texture footprint identifies a set of + texels that may be accessed in order to return a filtered result for the + texture access. + + The footprint itself is a structure that includes integer values that + identify a small neighborhood of texels in the texture being accessed and + a bitfield that indicates which texels in that neighborhood would be used. + Each bit in the returned bitfield identifies whether any texel in a small + aligned block of texels would be fetched by the texture lookup. The size + of each block is specified by an access _granularity_ provided by the + shader. The minimum granularity supported by this extension is 2x2 (for + 2D textures) and 2x2x2 (for 3D textures); the maximum granularity is + 256x256 (for 2D textures) or 64x32x32 (for 3D textures). Each footprint + query returns the footprint from a single texture level. When using + minification filters that combine accesses from multiple mipmap levels, + shaders must perform separate queries for the two levels accessed ("fine" + and "coarse"). The footprint query also returns a flag indicating if the + texture lookup would access texels from only one mipmap level or from two + neighboring levels. + + This extension should be useful for multi-pass rendering operations that + do an initial expensive rendering pass to produce a first image that is + then used as a texture for a second pass. If the second pass ends up + accessing only portions of the first image (e.g., due to visibility), the + work spent rendering the non-accessed portion of the first image was + wasted. With this feature, an application can limit this waste using an + initial pass over the geometry in the second image that performs a + footprint query for each visible pixel to determine the set of pixels that + it needs from the first image. This pass would accumulate an aggregate + footprint of all visible pixels into a separate "footprint texture" using + shader atomics. Then, when rendering the first image, the application can + kill all shading work for pixels not in this aggregate footprint. + + The implementation of this extension has a number of limitations. The + texture footprint query functions are only supported for two- and + three-dimensional textures (TEXTURE_2D, TEXTURE_3D). Texture footprint + evaluation only supports the CLAMP_TO_EDGE wrap mode; results are + undefined for all other wrap modes. The implementation supports only a + limited set of granularity values and does not support separate coverage + information for each texel in the original texture. + + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/shader_texture_footprint.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.NV.shader_texture_footprint import * +from OpenGL.raw.GL.NV.shader_texture_footprint import _EXTENSION_NAME + +def glInitShaderTextureFootprintNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/shader_thread_group.py b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/shader_thread_group.py new file mode 100644 index 00000000..4249098e --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/shader_thread_group.py @@ -0,0 +1,66 @@ +'''OpenGL extension NV.shader_thread_group + +This module customises the behaviour of the +OpenGL.raw.GL.NV.shader_thread_group to provide a more +Python-friendly API + +Overview (from the spec) + + Implementations of the OpenGL Shading Language may, but are not required + to, run multiple shader threads for a single stage as a SIMD thread group, + where individual execution threads are assigned to thread groups in an + undefined, implementation-dependent order. This extension provides a set + of new features to the OpenGL Shading Language to query thread states and + to share data between fragments within a 2x2 pixel quad. + + More specifically the following functionalities were added: + + * New uniform variables and tokens to query the number of threads in a + warp, the number of warps running on a SM and the number of SMs on the + GPU. + + * New shader inputs to query the thread id, the warp id and the SM id. + + * New shader inputs to query if a fragment shader thread is a helper + thread. + + * New shader built-in functions to query the state of a Boolean condition + over all threads in a thread group. + + * New shader built-in functions to query which threads are active within + a thread group. + + * New fragment shader built-in functions to share data between fragments + within a 2x2 pixel quad. + + Shaders using the new functionalities provided by this extension should + enable this functionality via the construct + + #extension GL_NV_shader_thread_group : require (or enable) + + This extension also specifies some modifications to the program assembly + language to support the thread state query and thread data sharing + functionalities. + + Note that in this extension specification warp and thread group have the + same meaning. A warp is a group of threads that get executed in lockstep. + Each thread in a warp executes the same instruction of a program, but on + different data. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/shader_thread_group.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.NV.shader_thread_group import * +from OpenGL.raw.GL.NV.shader_thread_group import _EXTENSION_NAME + +def glInitShaderThreadGroupNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/shader_thread_shuffle.py b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/shader_thread_shuffle.py new file mode 100644 index 00000000..ad258d27 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/shader_thread_shuffle.py @@ -0,0 +1,40 @@ +'''OpenGL extension NV.shader_thread_shuffle + +This module customises the behaviour of the +OpenGL.raw.GL.NV.shader_thread_shuffle to provide a more +Python-friendly API + +Overview (from the spec) + + Implementations of the OpenGL Shading Language may, but are not required, + to run multiple shader threads for a single stage as a SIMD thread group, + where individual execution threads are assigned to thread groups in an + undefined, implementation-dependent order. This extension provides a set + of new features to the OpenGL Shading Language to share data between + multiple threads within a thread group. + + Shaders using the new functionalities provided by this extension should + enable this functionality via the construct + + #extension GL_NV_shader_thread_shuffle : require (or enable) + + This extension also specifies some modifications to the program assembly + language to support the thread data sharing functionalities. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/shader_thread_shuffle.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.NV.shader_thread_shuffle import * +from OpenGL.raw.GL.NV.shader_thread_shuffle import _EXTENSION_NAME + +def glInitShaderThreadShuffleNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/shading_rate_image.py b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/shading_rate_image.py new file mode 100644 index 00000000..73373547 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/shading_rate_image.py @@ -0,0 +1,78 @@ +'''OpenGL extension NV.shading_rate_image + +This module customises the behaviour of the +OpenGL.raw.GL.NV.shading_rate_image to provide a more +Python-friendly API + +Overview (from the spec) + + By default, OpenGL runs a fragment shader once for each pixel covered by a + primitive being rasterized. When using multisampling, the outputs of that + fragment shader are broadcast to each covered sample of the fragment's + pixel. When using multisampling, applications can also request that the + fragment shader be run once per color sample (when using the "sample" + qualifier on one or more active fragment shader inputs), or run a fixed + number of times per pixel using SAMPLE_SHADING enable and the + MinSampleShading frequency value. In all of these approaches, the number + of fragment shader invocations per pixel is fixed, based on API state. + + This extension allows applications to bind and enable a shading rate image + that can be used to vary the number of fragment shader invocations across + the framebuffer. This can be useful for applications like eye tracking + for virtual reality, where the portion of the framebuffer that the user is + looking at directly can be processed at high frequency, while distant + corners of the image can be processed at lower frequency. The shading + rate image is an immutable-format two-dimensional or two-dimensional array + texture that uses a format of R8UI. Each texel represents a fixed-size + rectangle in the framebuffer, covering 16x16 pixels in the initial + implementation of this extension. When rasterizing a primitive covering + one of these rectangles, the OpenGL implementation reads the texel in the + bound shading rate image and looks up the fetched value in a palette of + shading rates. The shading rate used can vary from (finest) 16 fragment + shader invocations per pixel to (coarsest) one fragment shader invocation + for each 4x4 block of pixels. + + When this extension is advertised by an OpenGL implementation, the + implementation must also support the GLSL extension + "GL_NV_shading_rate_image" (documented separately), which provides new + built-in variables that allow fragment shaders to determine the effective + shading rate used for each fragment. Additionally, the GLSL extension also + provides new layout qualifiers allowing the interlock functionality provided + by ARB_fragment_shader_interlock to guarantee mutual exclusion across an + entire fragment when the shading rate specifies multiple pixels per fragment + shader invocation. + + Note that this extension requires the use of a framebuffer object; the + shading rate image and related state are ignored when rendering to the + default framebuffer. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/shading_rate_image.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.NV.shading_rate_image import * +from OpenGL.raw.GL.NV.shading_rate_image import _EXTENSION_NAME + +def glInitShadingRateImageNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +glGetShadingRateImagePaletteNV=wrapper.wrapper(glGetShadingRateImagePaletteNV).setInputArraySize( + 'rate', 1 +) +glGetShadingRateSampleLocationivNV=wrapper.wrapper(glGetShadingRateSampleLocationivNV).setInputArraySize( + 'location', 3 +) +# INPUT glShadingRateImagePaletteNV.rates size not checked against count +glShadingRateImagePaletteNV=wrapper.wrapper(glShadingRateImagePaletteNV).setInputArraySize( + 'rates', None +) +# INPUT glShadingRateSampleOrderCustomNV.locations size not checked against 'rate,samples' +glShadingRateSampleOrderCustomNV=wrapper.wrapper(glShadingRateSampleOrderCustomNV).setInputArraySize( + 'locations', None +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/stereo_view_rendering.py b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/stereo_view_rendering.py new file mode 100644 index 00000000..28ed2862 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/stereo_view_rendering.py @@ -0,0 +1,47 @@ +'''OpenGL extension NV.stereo_view_rendering + +This module customises the behaviour of the +OpenGL.raw.GL.NV.stereo_view_rendering to provide a more +Python-friendly API + +Overview (from the spec) + + Virtual reality (VR) applications often render a single logical scene + from multiple views corresponding to a pair of eyes. The views (eyes) are + separated by a fixed offset in the X direction. + + Traditionally, multiple views are rendered via multiple rendering passes. + This is expensive for the GPU because the objects in the scene must be + transformed, rasterized, shaded, and fragment processed redundantly. This + is expensive for the CPU because the scene graph needs to be visited + multiple times and driver validation happens for each view. Rendering N + passes tends to take N times longer than a single pass. + + This extension provides a mechanism to render binocular (stereo) views + from a single stream of OpenGL rendering commands. Vertex, tessellation, + and geometry (VTG) shaders can output two positions for each vertex + corresponding to the two eye views. A built-in "gl_SecondaryPositionNV" + is added to specify the second position. The positions from each view may + be sent to different viewports and/or layers. A built-in + "gl_SecondaryViewportMaskNV[]" is also added to specify the viewport mask + for the second view. A new layout-qualifier "secondary_view_offset" is + added for built-in output "gl_Layer" which allows for the geometry from + each view to be sent to different layers for rendering. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/stereo_view_rendering.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.NV.stereo_view_rendering import * +from OpenGL.raw.GL.NV.stereo_view_rendering import _EXTENSION_NAME + +def glInitStereoViewRenderingNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/tessellation_program5.py b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/tessellation_program5.py new file mode 100644 index 00000000..9e1270c7 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/tessellation_program5.py @@ -0,0 +1,99 @@ +'''OpenGL extension NV.tessellation_program5 + +This module customises the behaviour of the +OpenGL.raw.GL.NV.tessellation_program5 to provide a more +Python-friendly API + +Overview (from the spec) + + This extension, in conjunction with the ARB_tessellation_shader extension, + introduces a new tessellation stage to the OpenGL primitive processing + pipeline. The ARB_tessellation_shader extension provides programmable + shading functionality using the OpenGL Shading Language as its base; this + extension provides assembly programmable shaders building on the family of + assembly programmability extensions including ARB_vertex_program, + ARB_fragment_program, NV_gpu_program4, and NV_geometry_program4. + + This extension adds a new basic primitive type, called a patch, which + consists of an array of vertices plus some associated per-patch state. It + also adds two new assembly program types: a tessellation control program + that transforms a patch into a new patch and a tessellation evaluation + program that computes the position and attributes of each vertex produced + by the tesselator. + + When tessellation is active, it begins by running the optional + tessellation control program, if enabled. This program consumes a + variable-size input patch and produces a new fixed-size output patch. The + output patch consists of an array of vertices, and a set of per-patch + attributes. The per-patch attributes include tessellation levels that + control how finely the patch will be tessellated. For each patch + processed, multiple tessellation control program invocations are performed + -- one per output patch vertex. Each tessellation control program + invocation writes all the attributes of its corresponding output patch + vertex. A tessellation control program may also read the per-vertex + outputs of other tessellation control program invocations, as well as read + and write shared per-patch outputs. The tessellation control program + invocations for a single patch effectively run as a group. The GL + automatically synchronizes threads to ensure that when executing a given + instruction, all previous instructions have completed for all program + invocations in the group. + + The tessellation primitive generator then decomposes a patch into a new + set of primitives using the tessellation levels to determine how finely + tessellated the output should be. The primitive generator begins with + either a triangle or a quad, and splits each outer edge of the primitive + into a number of segments approximately equal to the corresponding element + of the outer tessellation level array. The interior of the primitive is + tessellated according to elements of the inner tessellation level array. + The primitive generator has three modes: TRIANGLES and QUADS split a + triangular or quad-shaped patch into a set of triangles that cover the + original patch; ISOLINES_NV splits a quad-shaped patch into a set of line + strips spanning the patch. Each vertex generated by the tessellation + primitive generator is assigned a (u,v) or (u,v,w) coordinate indicating + its relative location in the subdivided triangle or quad. + + For each vertex produced by the tessellation primitive generator, the + tessellation evaluation program is run to compute its position and other + attributes of the vertex, using its (u,v) or (u,v,w) coordinate. When + computing the final vertex attributes, the tessellation evaluation program + can also read the attributes of any of the vertices of the patch written + by the tessellation control program. Tessellation evaluation program + invocations are completely independent, although all invocations for a + single patch share the same collection of input vertices and per-patch + attributes. + + The tessellator operates on vertices after they have been transformed by a + vertex program or fixed-function vertex processing. The primitives + generated by the tessellator are passed further down the OpenGL pipeline, + where they can be used as inputs to geometry programs, transform feedback, + and the rasterizer. + + The tessellation control and evaluation programs are both optional. If + neither program type is present, the tessellation stage has no effect. If + no tessellation control program is present, the input patch provided by + the application is passed directly to the tessellation primitive + generator, and a set of fixed tessellation level parameters (specified via + the PatchParameterfv function) is used to control primitive generation. + If no tessellation evaluation program is present, the output patch + produced by the tessellation control program is passed as a patch to + subsequent pipeline stages, where it can be consumed by geometry programs, + transform feedback, or the rasterizer. + + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/tessellation_program5.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.NV.tessellation_program5 import * +from OpenGL.raw.GL.NV.tessellation_program5 import _EXTENSION_NAME + +def glInitTessellationProgram5NV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/texgen_emboss.py b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/texgen_emboss.py new file mode 100644 index 00000000..0acfe13c --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/texgen_emboss.py @@ -0,0 +1,43 @@ +'''OpenGL extension NV.texgen_emboss + +This module customises the behaviour of the +OpenGL.raw.GL.NV.texgen_emboss to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides a new texture coordinate generation mode + suitable for multitexture-based embossing (or bump mapping) effects. + + Given two texture units, this extension generates the texture + coordinates of a second texture unit (an odd-numbered texture unit) + as a perturbation of a first texture unit (an even-numbered texture + unit one less than the second texture unit). The perturbation is + based on the normal, tangent, and light vectors. The normal vector + is supplied by glNormal; the light vector is supplied as a direction + vector to a specified OpenGL light's position; and the tanget + vector is supplied by the second texture unit's current texture + coordinate. The perturbation is also scaled by program-supplied + scaling constants. + + If both texture units are bound to the same texture representing a + height field, by subtracting the difference between the resulting two + filtered texels, programs can achieve a per-pixel embossing effect. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/texgen_emboss.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.NV.texgen_emboss import * +from OpenGL.raw.GL.NV.texgen_emboss import _EXTENSION_NAME + +def glInitTexgenEmbossNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/texgen_reflection.py b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/texgen_reflection.py new file mode 100644 index 00000000..d8cbf423 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/texgen_reflection.py @@ -0,0 +1,35 @@ +'''OpenGL extension NV.texgen_reflection + +This module customises the behaviour of the +OpenGL.raw.GL.NV.texgen_reflection to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides two new texture coordinate generation modes + that are useful texture-based lighting and environment mapping. + The reflection map mode generates texture coordinates (s,t,r) + matching the vertex's eye-space reflection vector. The reflection + map mode is useful for environment mapping without the singularity + inherent in sphere mapping. The normal map mode generates texture + coordinates (s,t,r) matching the vertex's transformed eye-space + normal. The normal map mode is useful for sophisticated cube map + texturing-based diffuse lighting models. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/texgen_reflection.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.NV.texgen_reflection import * +from OpenGL.raw.GL.NV.texgen_reflection import _EXTENSION_NAME + +def glInitTexgenReflectionNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/texture_barrier.py b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/texture_barrier.py new file mode 100644 index 00000000..44ffa386 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/texture_barrier.py @@ -0,0 +1,29 @@ +'''OpenGL extension NV.texture_barrier + +This module customises the behaviour of the +OpenGL.raw.GL.NV.texture_barrier to provide a more +Python-friendly API + +Overview (from the spec) + + This extension relaxes the restrictions on rendering to a currently + bound texture and provides a mechanism to avoid read-after-write + hazards. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/texture_barrier.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.NV.texture_barrier import * +from OpenGL.raw.GL.NV.texture_barrier import _EXTENSION_NAME + +def glInitTextureBarrierNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/texture_compression_vtc.py b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/texture_compression_vtc.py new file mode 100644 index 00000000..278acfee --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/texture_compression_vtc.py @@ -0,0 +1,31 @@ +'''OpenGL extension NV.texture_compression_vtc + +This module customises the behaviour of the +OpenGL.raw.GL.NV.texture_compression_vtc to provide a more +Python-friendly API + +Overview (from the spec) + + This extension adds support for the VTC 3D texture compression + formats, which are analogous to the S3TC texture compression formats, + with the addition of some retiling in the Z direction. VTC has the + same compression ratio as S3TC and uses 4x4x1, 4x4x2, (4x4x3 when + non-power-of-two textures are supported), or 4x4x4 blocks. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/texture_compression_vtc.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.NV.texture_compression_vtc import * +from OpenGL.raw.GL.NV.texture_compression_vtc import _EXTENSION_NAME + +def glInitTextureCompressionVtcNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/texture_env_combine4.py b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/texture_env_combine4.py new file mode 100644 index 00000000..f31e74c5 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/texture_env_combine4.py @@ -0,0 +1,43 @@ +'''OpenGL extension NV.texture_env_combine4 + +This module customises the behaviour of the +OpenGL.raw.GL.NV.texture_env_combine4 to provide a more +Python-friendly API + +Overview (from the spec) + + New texture environment function COMBINE4_NV allows programmable + texture combiner operations, including + + ADD Arg0 * Arg1 + Arg2 * Arg3 + ADD_SIGNED_EXT Arg0 * Arg1 + Arg2 * Arg3 - 0.5 + + where Arg0, Arg1, Arg2 and Arg3 are derived from + + ZERO the value 0 + PRIMARY_COLOR_EXT primary color of incoming fragment + TEXTURE texture color of corresponding texture unit + CONSTANT_EXT texture environment constant color + PREVIOUS_EXT result of previous texture environment; on + texture unit 0, this maps to PRIMARY_COLOR_EXT + TEXTURE_ARB texture color of the th texture unit + + In addition, the result may be scaled by 1.0, 2.0 or 4.0. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/texture_env_combine4.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.NV.texture_env_combine4 import * +from OpenGL.raw.GL.NV.texture_env_combine4 import _EXTENSION_NAME + +def glInitTextureEnvCombine4NV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/texture_expand_normal.py b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/texture_expand_normal.py new file mode 100644 index 00000000..64ac0870 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/texture_expand_normal.py @@ -0,0 +1,35 @@ +'''OpenGL extension NV.texture_expand_normal + +This module customises the behaviour of the +OpenGL.raw.GL.NV.texture_expand_normal to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides a remapping mode where unsigned texture + components (in the range [0,1]) can be treated as though they + contained signed data (in the range [-1,+1]). This allows + applications to easily encode signed data into unsigned texture + formats. + + The functionality of this extension is nearly identical to the + EXPAND_NORMAL_NV remapping mode provided in the NV_register_combiners + extension, although it applies even if register combiners are used. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/texture_expand_normal.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.NV.texture_expand_normal import * +from OpenGL.raw.GL.NV.texture_expand_normal import _EXTENSION_NAME + +def glInitTextureExpandNormalNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/texture_multisample.py b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/texture_multisample.py new file mode 100644 index 00000000..243a1b24 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/texture_multisample.py @@ -0,0 +1,40 @@ +'''OpenGL extension NV.texture_multisample + +This module customises the behaviour of the +OpenGL.raw.GL.NV.texture_multisample to provide a more +Python-friendly API + +Overview (from the spec) + + This specification extends NV_gpu_program4 to support per-sample fetching + from multisample textures described in ARB_texture_multisample. + Specifically, it adds: + + * The TXFMS sample fetch instruction. + + * Texture targets corresponding to the multisample textures added by + ARB_texture_multisample. + + * A program option to enable these features. + + This specification also extends the ARB_texture_multisample extension + by adding support for EXT_direct_state_access and VCAA multisample + coverage with seperate and parameters. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/texture_multisample.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.NV.texture_multisample import * +from OpenGL.raw.GL.NV.texture_multisample import _EXTENSION_NAME + +def glInitTextureMultisampleNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/texture_rectangle.py b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/texture_rectangle.py new file mode 100644 index 00000000..df44e87b --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/texture_rectangle.py @@ -0,0 +1,53 @@ +'''OpenGL extension NV.texture_rectangle + +This module customises the behaviour of the +OpenGL.raw.GL.NV.texture_rectangle to provide a more +Python-friendly API + +Overview (from the spec) + + OpenGL texturing is limited to images with power-of-two dimensions + and an optional 1-texel border. NV_texture_rectangle extension + adds a new texture target that supports 2D textures without requiring + power-of-two dimensions. + + Non-power-of-two dimensioned textures are useful for storing + video images that do not have power-of-two dimensions. Re-sampling + artifacts are avoided and less texture memory may be required by using + non-power-of-two dimensioned textures. Non-power-of-two dimensioned + textures are also useful for shadow maps and window-space texturing. + + However, non-power-of-two dimensioned (NPOTD) textures have + limitations that do not apply to power-of-two dimensioned (POT) + textures. NPOTD textures may not use mipmap filtering; POTD + textures support both mipmapped and non-mipmapped filtering. + NPOTD textures support only the GL_CLAMP, GL_CLAMP_TO_EDGE, + and GL_CLAMP_TO_BORDER_ARB wrap modes; POTD textures support + GL_CLAMP_TO_EDGE, GL_REPEAT, GL_CLAMP, GL_MIRRORED_REPEAT_IBM, + and GL_CLAMP_TO_BORDER. NPOTD textures do not support an optional + 1-texel border; POTD textures do support an optional 1-texel border. + + NPOTD textures are accessed by non-normalized texture coordinates. + So instead of thinking of the texture image lying in a [0..1]x[0..1] + range, the NPOTD texture image lies in a [0..w]x[0..h] range. + + This extension adds a new texture target and related state (proxy, + binding, max texture size). + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/texture_rectangle.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.NV.texture_rectangle import * +from OpenGL.raw.GL.NV.texture_rectangle import _EXTENSION_NAME + +def glInitTextureRectangleNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/texture_rectangle_compressed.py b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/texture_rectangle_compressed.py new file mode 100644 index 00000000..8704261b --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/texture_rectangle_compressed.py @@ -0,0 +1,29 @@ +'''OpenGL extension NV.texture_rectangle_compressed + +This module customises the behaviour of the +OpenGL.raw.GL.NV.texture_rectangle_compressed to provide a more +Python-friendly API + +Overview (from the spec) + + This extension allows applications to use compressed texture formats + with the TEXTURE_RECTANGLE texture target, removing an old limitation + that prohibited such usage globally for rectangle textures. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/texture_rectangle_compressed.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.NV.texture_rectangle_compressed import * +from OpenGL.raw.GL.NV.texture_rectangle_compressed import _EXTENSION_NAME + +def glInitTextureRectangleCompressedNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/texture_shader.py b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/texture_shader.py new file mode 100644 index 00000000..495b5609 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/texture_shader.py @@ -0,0 +1,198 @@ +'''OpenGL extension NV.texture_shader + +This module customises the behaviour of the +OpenGL.raw.GL.NV.texture_shader to provide a more +Python-friendly API + +Overview (from the spec) + + Standard OpenGL and the ARB_multitexture extension define a + straightforward direct mechanism for mapping sets of texture + coordinates to filtered colors. This extension provides a more + functional mechanism. + + OpenGL's standard texturing mechanism defines a set of texture + targets. Each texture target defines how the texture image + is specified and accessed via a set of texture coordinates. + OpenGL 1.0 defines the 1D and 2D texture targets. OpenGL 1.2 + (and/or the EXT_texture3D extension) defines the 3D texture target. + The ARB_texture_cube_map extension defines the cube map texture + target. Each texture unit's texture coordinate set is mapped to a + color using the unit's highest priority enabled texture target. + + This extension introduces texture shader stages. A sequence of + texture shader stages provides a more flexible mechanism for mapping + sets of texture coordinates to texture unit RGBA results than standard + OpenGL. + + When the texture shader enable is on, the extension replaces the + conventional OpenGL mechanism for mapping sets of texture coordinates + to filtered colors with this extension's sequence of texture shader + stages. + + Each texture shader stage runs one of 21 canned texture shader + programs. These programs support conventional OpenGL texture + mapping but also support dependent texture accesses, dot product + texture programs, and special modes. (3D texture mapping + texture shader operations are NOT provided by this extension; + 3D texture mapping texture shader operations are added by the + NV_texture_shader2 extension that is layered on this extension. + See the NV_texture_shader2 specification.) + + To facilitate the new texture shader programs, this extension + introduces several new texture formats and variations on existing + formats. Existing color texture formats are extended by introducing + new signed variants. Two new types of texture formats (beyond colors) + are also introduced. Texture offset groups encode two signed offsets, + and optionally a magnitude or a magnitude and an intensity. The new + HILO (pronounced high-low) formats provide possibly signed, high + precision (16-bit) two-component textures. + + Each program takes as input the stage's interpolated texture + coordinate set (s,t,r,q). Each program generates two results: + a shader stage result that may be used as an input to subsequent + shader stage programs, and a texture unit RGBA result that becomes the + texture color used by the texture unit's texture environment function + or becomes the initial value for the corresponding texture register + for register combiners. The texture unit RGBA result is always + an RGBA color, but the shader stage result may be one of an RGBA + color, a HILO value, a texture offset group, a floating-point value, + or an invalid result. When both results are RGBA colors, the shader + stage result and the texture unit RGBA result are usually identical + (though not in all cases). + + Additionally, certain programs have a side-effect such as culling + the fragment or replacing the fragment's depth value. + + The twenty-one programs are briefly described: + + + + 1. NONE - Always generates a (0,0,0,0) texture unit RGBA result. + Equivalent to disabling all texture targets in conventional + OpenGL. + + + + 2. TEXTURE_1D - Accesses a 1D texture via (s/q). + + 3. TEXTURE_2D - Accesses a 2D texture via (s/q,t/q). + + 4. TEXTURE_RECTANGLE_NV - Accesses a rectangular texture via (s/q,t/q). + + 5. TEXTURE_CUBE_MAP_ARB - Accesses a cube map texture via (s,t,r). + + + + 6. PASS_THROUGH_NV - Converts a texture coordinate (s,t,r,q) + directly to a [0,1] clamped (r,g,b,a) texture unit RGBA result. + + 7. CULL_FRAGMENT_NV - Culls the fragment based on the whether each + (s,t,r,q) is "greater than or equal to zero" or "less than zero". + + + + 8. OFFSET_TEXTURE_2D_NV - Transforms the signed (ds,dt) components + of a previous texture unit by a 2x2 floating-point matrix and + then uses the result to offset the stage's texture coordinates + for a 2D non-projective texture. + + 9. OFFSET_TEXTURE_2D_SCALE_NV - Same as above except the magnitude + component of the previous texture unit result scales the red, + green, and blue components of the unsigned RGBA texture 2D + access. + + 10. OFFSET_TEXTURE_RECTANGLE_NV - Similar to OFFSET_TEXTURE_2D_NV + except that the texture access is into a rectangular + non-projective texture. + + 11. OFFSET_TEXTURE_RECTANGLE_SCALE_NV - Similar to + OFFSET_TEXTURE_2D_SCALE_NV except that the texture access is + into a rectangular non-projective texture. + + + + 12. DEPENDENT_AR_TEXTURE_2D_NV - Converts the alpha and red + components of a previous shader result into an (s,t) texture + coordinate set to access a 2D non-projective texture. + + 13. DEPENDENT_GB_TEXTURE_2D_NV - Converts the green and blue + components of a previous shader result into an (s,t) texture + coordinate set to access a 2D non-projective texture. + + + + 14. DOT_PRODUCT_NV - Computes the dot product of the texture + shader's texture coordinate set (s,t,r) with some mapping of the + components of a previous texture shader result. The component + mapping depends on the type (RGBA or HILO) and signedness of + the stage's previous texture input. Other dot product texture + programs use the result of this program to compose a texture + coordinate set for a dependent texture access. The color result + is undefined. + + 15. DOT_PRODUCT_TEXTURE_2D_NV - When preceded by a DOT_PRODUCT_NV + program in the previous texture shader stage, computes a second + similar dot product and composes the two dot products into (s,t) + texture coordinate set to access a 2D non-projective texture. + + 16. DOT_PRODUCT_TEXTURE_RECTANGLE_NV - Similar to + DOT_PRODUCT_TEXTURE_2D_NV except that the texture acces is into + a rectangular non-projective texture. + + 17. DOT_PRODUCT_TEXTURE_CUBE_MAP_NV - When preceded by two + DOT_PRODUCT_NV programs in the previous two texture shader + stages, computes a third similar dot product and composes the + three dot products into (s,t,r) texture coordinate set to access + a cube map texture. + + 18. DOT_PRODUCT_REFLECT_CUBE_MAP_NV - When preceded by two + DOT_PRODUCT_NV programs in the previous two texture shader + stages, computes a third similar dot product and composes the + three dot products into a normal vector (Nx,Ny,Nz). An eye + vector (Ex,Ey,Ez) is composed from the q texture coordinates of + the three stages. A reflection vector (Rx,Ry,Rz) is computed + based on the normal and eye vectors. The reflection vector + forms an (s,t,r) texture coordinate set to access a cube map + texture. + + 19. DOT_PRODUCT_CONST_EYE_REFLECT_CUBE_MAP_NV - Operates like + DOT_PRODUCT_REFLECT_CUBE_MAP_NV except that the eye vector + (Ex,Ey,Ez) is a user-defined constant rather than composed from + the q coordinates of the three stages. + + 20. DOT_PRODUCT_DIFFUSE_CUBE_MAP_NV - When used instead of the second + DOT_PRODUCT_NV program preceding + a DOT_PRODUCT_REFLECT_CUBE_MAP_NV or + DOT_PRODUCT_CONST_EYE_REFLECT_CUBE_MAP_NV stage, the normal + vector forms an (s,t,r) texture coordinate set to access a + cube map texture. + + + + 21. DOT_PRODUCT_DEPTH_REPLACE_NV - When preceded by a DOT_PRODUCT_NV + program in the previous texture shader stage, computes a second + similar dot product and replaces the fragment's window-space + depth value with the first dot product results divided by + the second. The texture unit RGBA result is (0,0,0,0). + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/texture_shader.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.NV.texture_shader import * +from OpenGL.raw.GL.NV.texture_shader import _EXTENSION_NAME + +def glInitTextureShaderNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION +GL_OFFSET_TEXTURE_2D_BIAS_NV = GL_OFFSET_TEXTURE_BIAS_NV # alias +GL_OFFSET_TEXTURE_2D_MATRIX_NV = GL_OFFSET_TEXTURE_MATRIX_NV # alias +GL_OFFSET_TEXTURE_2D_SCALE_NV = GL_OFFSET_TEXTURE_SCALE_NV # alias diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/texture_shader2.py b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/texture_shader2.py new file mode 100644 index 00000000..38a2f259 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/texture_shader2.py @@ -0,0 +1,45 @@ +'''OpenGL extension NV.texture_shader2 + +This module customises the behaviour of the +OpenGL.raw.GL.NV.texture_shader2 to provide a more +Python-friendly API + +Overview (from the spec) + + This extension extends the NV_texture_shader functionality to + support texture shader operations for 3D textures. + + See the NV_texture_shader extension for information about the + texture shader operational model. + + The two new texture shader operations are: + + + + 22. TEXTURE_3D - Accesses a 3D texture via (s/q,t/q,r/q). + + + + 23. DOT_PRODUCT_TEXTURE_3D_NV - When preceded by two DOT_PRODUCT_NV + programs in the previous two texture shader stages, computes a + third similar dot product and composes the three dot products + into (s,t,r) texture coordinate set to access a 3D non-projective + texture. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/texture_shader2.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.NV.texture_shader2 import * +from OpenGL.raw.GL.NV.texture_shader2 import _EXTENSION_NAME + +def glInitTextureShader2NV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/texture_shader3.py b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/texture_shader3.py new file mode 100644 index 00000000..7644ff4b --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/texture_shader3.py @@ -0,0 +1,118 @@ +'''OpenGL extension NV.texture_shader3 + +This module customises the behaviour of the +OpenGL.raw.GL.NV.texture_shader3 to provide a more +Python-friendly API + +Overview (from the spec) + + NV_texture_shader3 extends the NV_texture_shader functionality by + adding several new texture shader operations, extending several + existing texture shader operations, adding a new HILO8 internal + format, and adding new and more flexible re-mapping modes for dot + product and dependent texture shader operations. + + See the NV_texture_shader extension for information about the + texture shader operational model. + + The fourteen new texture shader operations are: + + + + 24. OFFSET_PROJECTIVE_TEXTURE_2D_NV - Transforms the signed (ds,dt) + components of a previous texture unit by a 2x2 floating-point + matrix and then uses the result to offset the stage's texture + coordinates for a 2D non-projective texture. + + 25. OFFSET_PROJECTIVE_TEXTURE_2D_SCALE_NV - Same as above except + the magnitude component of the previous texture unit result + scales the red, green, and blue components of the unsigned RGBA + texture 2D access. + + 26. OFFSET_PROJECTIVE_TEXTURE_RECTANGLE_NV - Similar to + OFFSET_TEXTURE_2D_NV except that the texture access is into a + rectangular non-projective texture. + + 27. OFFSET_PROJECTIVE_TEXTURE_RECTANGLE_SCALE_NV - Similar to + OFFSET_PROJECTIVE_TEXTURE_2D_SCALE_NV except that the texture + access is into a rectangular non-projective texture. + + 28. OFFSET_HILO_TEXTURE_2D_NV - Similar to OFFSET_TEXTURE_2D_NV + but uses a (higher-precision) HILO base format texture rather + than a DSDT-type base format. + + 29. OFFSET_HILO_TEXTURE_RECTANGLE_NV - Similar to + OFFSET_TEXTURE_RECTANGLE_NV but uses a (higher-precision) + HILO base format texture rather than a DSDT-type base format. + + 30. OFFSET_HILO_PROJECTIVE_TEXTURE_2D_NV - Similar to + OFFSET_PROJECTIVE_TEXTURE_2D_NV but uses a (higher-precision) + HILO base format texture rather than a DSDT-type base format. + + 31. OFFSET_HILO_PROJECTIVE_TEXTURE_RECTANGLE_NV - Similar to + OFFSET_PROJECTIVE_TEXTURE_RECTANGLE_NV but uses a + (higher-precision) HILO base format texture rather than a + DSDT-type base format. + + (There are no "offset HILO texture scale" operations because + HILO textures have only two components with no third component + for scaling.) + + + + 32. DEPENDENT_HILO_TEXTURE_2D_NV - Converts the hi and lo components + of a previous shader HILO result into an (s,t) texture coordinate + set to access a 2D non-projective texture. + + 33. DEPENDENT_RGB_TEXTURE_3D_NV - Converts the red, green, and + blue components of a previous shader RGBA result into an (s,t,r) + texture coordinate set to access a 3D non-projective texture. + + 34. DEPENDENT_RGB_TEXTURE_CUBE_MAP_NV - Converts the red, green, + and blue components of a previous shader RGBA result into an + (s,t,r) texture coordinate set to access a cube map texture. + + + + 35. DOT_PRODUCT_PASS_THROUGH_NV - Computes a dot product in the + manner of the DOT_PRODUCT_NV operation and the result is [0,1] + clamped and smeared to generate the texture unit RGBA result. + + + + 36. DOT_PRODUCT_TEXTURE_1D_NV - Computes a dot product in the manner + of the DOT_PRODUCT_NV operation and uses the result as the s + texture coordinate to access a 2D non-projective texture. + + + + 37. DOT_PRODUCT_AFFINE_DEPTH_REPLACE_NV - Computes a dot product + in the manner of the DOT_PRODUCT_NV operation and the result + is [0,1] clamped and replaces the fragment's window-space + depth value. The texture unit RGBA result is (0,0,0,0). + + Two new internal texture formats have been added: HILO8_NV and + SIGNED_HILO8_NV. These texture formats allow HILO textures to be + stored in half the space; still the filtering for these internal + texture formats is done with 16-bit precision. + + One new unsigned RGBA dot product mapping mode (FORCE_BLUE_TO_ONE_NV) + forces the blue component to be 1.0 before computing a dot product. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/texture_shader3.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.NV.texture_shader3 import * +from OpenGL.raw.GL.NV.texture_shader3 import _EXTENSION_NAME + +def glInitTextureShader3NV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/transform_feedback.py b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/transform_feedback.py new file mode 100644 index 00000000..10cc9b5f --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/transform_feedback.py @@ -0,0 +1,90 @@ +'''OpenGL extension NV.transform_feedback + +This module customises the behaviour of the +OpenGL.raw.GL.NV.transform_feedback to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides a new mode to the GL, called transform feedback, + which records vertex attributes of the primitives processed by the GL. + The selected attributes are written into buffer objects, and can be + written with each attribute in a separate buffer object or with all + attributes interleaved into a single buffer object. If a geometry program + or shader is active, the primitives recorded are those emitted by the + geometry program. Otherwise, transform feedback captures primitives whose + vertex are transformed by a vertex program or shader, or by fixed-function + vertex processing. In either case, the primitives captured are those + generated prior to clipping. Transform feedback mode is capable of + capturing transformed vertex data generated by fixed-function vertex + processing, outputs from assembly vertex or geometry programs, or varying + variables emitted from GLSL vertex or geometry shaders. + + The vertex data recorded in transform feedback mode is stored into buffer + objects as an array of vertex attributes. The regular representation and + the use of buffer objects allows the recorded data to be processed + directly by the GL without requiring CPU intervention to copy data. In + particular, transform feedback data can be used for vertex arrays (via + vertex buffer objects), as the source for pixel data (via pixel buffer + objects), as program constant data (via the NV_parameter_buffer_object or + EXT_bindable_uniform extension), or via any other extension that makes use + of buffer objects. + + This extension introduces new query object support to allow transform + feedback mode to operate asynchronously. Query objects allow applications + to determine when transform feedback results are complete, as well as the + number of primitives processed and written back to buffer objects while in + transform feedback mode. This extension also provides a new rasterizer + discard enable, which allows applications to use transform feedback to + capture vertex attributes without rendering anything. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/transform_feedback.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.NV.transform_feedback import * +from OpenGL.raw.GL.NV.transform_feedback import _EXTENSION_NAME + +def glInitTransformFeedbackNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glTransformFeedbackAttribsNV.attribs size not checked against 'count' +glTransformFeedbackAttribsNV=wrapper.wrapper(glTransformFeedbackAttribsNV).setInputArraySize( + 'attribs', None +) +# INPUT glTransformFeedbackVaryingsNV.locations size not checked against count +glTransformFeedbackVaryingsNV=wrapper.wrapper(glTransformFeedbackVaryingsNV).setInputArraySize( + 'locations', None +) +# INPUT glActiveVaryingNV.name size not checked against 'name' +glActiveVaryingNV=wrapper.wrapper(glActiveVaryingNV).setInputArraySize( + 'name', None +) +# INPUT glGetVaryingLocationNV.name size not checked against 'name' +glGetVaryingLocationNV=wrapper.wrapper(glGetVaryingLocationNV).setInputArraySize( + 'name', None +) +# OUTPUT glGetActiveVaryingNV.name COMPSIZE(program, index, bufSize) +glGetActiveVaryingNV=wrapper.wrapper(glGetActiveVaryingNV).setOutput( + 'length',size=(1,),orPassIn=True +).setOutput( + 'size',size=(1,),orPassIn=True +).setOutput( + 'type',size=(1,),orPassIn=True +) +glGetTransformFeedbackVaryingNV=wrapper.wrapper(glGetTransformFeedbackVaryingNV).setOutput( + 'location',size=(1,),orPassIn=True +) +# INPUT glTransformFeedbackStreamAttribsNV.attribs size not checked against count +# INPUT glTransformFeedbackStreamAttribsNV.bufstreams size not checked against nbuffers +glTransformFeedbackStreamAttribsNV=wrapper.wrapper(glTransformFeedbackStreamAttribsNV).setInputArraySize( + 'attribs', None +).setInputArraySize( + 'bufstreams', None +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/transform_feedback2.py b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/transform_feedback2.py new file mode 100644 index 00000000..9c02a7cd --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/transform_feedback2.py @@ -0,0 +1,57 @@ +'''OpenGL extension NV.transform_feedback2 + +This module customises the behaviour of the +OpenGL.raw.GL.NV.transform_feedback2 to provide a more +Python-friendly API + +Overview (from the spec) + + The NV_transform_feedback and EXT_transform_feedback extensions allow + applications to capture primitives to one or more buffer objects when + transformed by the GL. This extension provides a few additional + capabilities to these extensions, making transform feedback mode + more useful. + + First, it provides transform feedback objects encapsulating transform + feedback-related state, allowing applications to replace the entire + transform feedback configuration in a single bind call. Second, it + provides the ability to pause and resume transform feedback operations. + When transform feedback is paused, applications may render without + transform feedback or may use transform feedback with different state and + a different transform feedback object. When transform feedback is + resumed, additional primitives are captured and appended to previously + captured primitives for the object. + + Additionally, this extension provides the ability to draw primitives + captured in transform feedback mode without querying the captured + primitive count. The command DrawTransformFeedbackNV() is equivalent to + glDrawArrays(, 0, ), where is the number of vertices + captured to buffer objects during the last transform feedback capture + operation on the transform feedback object used. This draw operation only + provides a vertex count -- it does not automatically set up vertex array + state or vertex buffer object bindings, which must be done separately by + the application. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/transform_feedback2.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.NV.transform_feedback2 import * +from OpenGL.raw.GL.NV.transform_feedback2 import _EXTENSION_NAME + +def glInitTransformFeedback2NV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glDeleteTransformFeedbacksNV.ids size not checked against n +glDeleteTransformFeedbacksNV=wrapper.wrapper(glDeleteTransformFeedbacksNV).setInputArraySize( + 'ids', None +) +glGenTransformFeedbacksNV=wrapper.wrapper(glGenTransformFeedbacksNV).setOutput( + 'ids',size=lambda x:(x,),pnameArg='n',orPassIn=True +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/uniform_buffer_unified_memory.py b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/uniform_buffer_unified_memory.py new file mode 100644 index 00000000..eb7a0987 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/uniform_buffer_unified_memory.py @@ -0,0 +1,35 @@ +'''OpenGL extension NV.uniform_buffer_unified_memory + +This module customises the behaviour of the +OpenGL.raw.GL.NV.uniform_buffer_unified_memory to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides a mechanism to specify uniform buffers + using GPU addresses. + + Binding uniform buffers is one of the most frequent and expensive + operations in many GL applications, due to the cost of chasing + pointers and binding objects described in the overview of + NV_shader_buffer_load. The intent of this extension is to enable a + way for the application to specify uniform buffer state that alleviates + the overhead of object binds and driver memory management. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/uniform_buffer_unified_memory.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.NV.uniform_buffer_unified_memory import * +from OpenGL.raw.GL.NV.uniform_buffer_unified_memory import _EXTENSION_NAME + +def glInitUniformBufferUnifiedMemoryNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/vdpau_interop.py b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/vdpau_interop.py new file mode 100644 index 00000000..1932949c --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/vdpau_interop.py @@ -0,0 +1,58 @@ +'''OpenGL extension NV.vdpau_interop + +This module customises the behaviour of the +OpenGL.raw.GL.NV.vdpau_interop to provide a more +Python-friendly API + +Overview (from the spec) + + This extension allows VDPAU video and output surfaces to be used + for texturing and rendering. + + This allows the GL to process and display the content of video + streams decoded using VDPAU. + + Alternatively, the GL may modify VDPAU surfaces in-place, and VDPAU + may then process and/or display those surfaces itself. + + This allows the GL to be used to combine application user-interface + elements with decoded video, implement custom video-processing + algorithms, etc. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/vdpau_interop.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.NV.vdpau_interop import * +from OpenGL.raw.GL.NV.vdpau_interop import _EXTENSION_NAME + +def glInitVdpauInteropNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glVDPAURegisterVideoSurfaceNV.textureNames size not checked against numTextureNames +glVDPAURegisterVideoSurfaceNV=wrapper.wrapper(glVDPAURegisterVideoSurfaceNV).setInputArraySize( + 'textureNames', None +) +# INPUT glVDPAURegisterOutputSurfaceNV.textureNames size not checked against numTextureNames +# glVDPAURegisterOutputSurfaceNV.vdpSurface is OUTPUT without known output size +glVDPAURegisterOutputSurfaceNV=wrapper.wrapper(glVDPAURegisterOutputSurfaceNV).setInputArraySize( + 'textureNames', None +) +# glVDPAUGetSurfaceivNV.length is OUTPUT without known output size +glVDPAUGetSurfaceivNV=wrapper.wrapper(glVDPAUGetSurfaceivNV).setOutput( + 'values',size=lambda x:(x,),pnameArg='bufSize',orPassIn=True +) +# INPUT glVDPAUMapSurfacesNV.surfaces size not checked against numSurfaces +glVDPAUMapSurfacesNV=wrapper.wrapper(glVDPAUMapSurfacesNV).setInputArraySize( + 'surfaces', None +) +# INPUT glVDPAUUnmapSurfacesNV.surfaces size not checked against numSurface +glVDPAUUnmapSurfacesNV=wrapper.wrapper(glVDPAUUnmapSurfacesNV).setInputArraySize( + 'surfaces', None +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/vdpau_interop2.py b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/vdpau_interop2.py new file mode 100644 index 00000000..5859d124 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/vdpau_interop2.py @@ -0,0 +1,31 @@ +'''OpenGL extension NV.vdpau_interop2 + +This module customises the behaviour of the +OpenGL.raw.GL.NV.vdpau_interop2 to provide a more +Python-friendly API + +Overview (from the spec) + + This extension allows VDPAU video surfaces to be used + either with frame or field structures for texturing and rendering. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/vdpau_interop2.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.NV.vdpau_interop2 import * +from OpenGL.raw.GL.NV.vdpau_interop2 import _EXTENSION_NAME + +def glInitVdpauInterop2NV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glVDPAURegisterVideoSurfaceWithPictureStructureNV.textureNames size not checked against numTextureNames +glVDPAURegisterVideoSurfaceWithPictureStructureNV=wrapper.wrapper(glVDPAURegisterVideoSurfaceWithPictureStructureNV).setInputArraySize( + 'textureNames', None +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/vertex_array_range.py b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/vertex_array_range.py new file mode 100644 index 00000000..c55c32da --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/vertex_array_range.py @@ -0,0 +1,101 @@ +'''OpenGL extension NV.vertex_array_range + +This module customises the behaviour of the +OpenGL.raw.GL.NV.vertex_array_range to provide a more +Python-friendly API + +Overview (from the spec) + + The goal of this extension is to permit extremely high vertex + processing rates via OpenGL vertex arrays even when the CPU lacks + the necessary data movement bandwidth to keep up with the rate + at which the vertex engine can consume vertices. CPUs can keep + up if they can just pass vertex indices to the hardware and + let the hardware "pull" the actual vertex data via Direct Memory + Access (DMA). Unfortunately, the current OpenGL 1.1 vertex array + functionality has semantic constraints that make such an approach + hard. Hence, the vertex array range extension. + + This extension provides a mechanism for deferring the pulling of + vertex array elements to facilitate DMAed pulling of vertices for + fast, efficient vertex array transfers. The OpenGL client need only + pass vertex indices to the hardware which can DMA the actual index's + vertex data directly out of the client address space. + + The OpenGL 1.1 vertex array functionality specifies a fairly strict + coherency model for when OpenGL extracts vertex data from a vertex + array and when the application can update the in memory + vertex array data. The OpenGL 1.1 specification says "Changes + made to array data between the execution of Begin and the + corresponding execution of End may affect calls to ArrayElement + that are made within the same Begin/End period in non-sequential + ways. That is, a call to ArrayElement that precedes a change to + array data may access the changed data, and a call that follows + a change to array data may access the original data." + + This means that by the time End returns (and DrawArrays and + DrawElements return since they have implicit Ends), the actual vertex + array data must be transferred to OpenGL. This strict coherency model + prevents us from simply passing vertex element indices to the hardware + and having the hardware "pull" the vertex data out (which is often + long after the End for the primitive has returned to the application). + + Relaxing this coherency model and bounding the range from which + vertex array data can be pulled is key to making OpenGL vertex + array transfers faster and more efficient. + + The first task of the vertex array range extension is to relax + the coherency model so that hardware can indeed "pull" vertex + data from the OpenGL client's address space long after the application + has completed sending the geometry primitives requiring the vertex + data. + + The second problem with the OpenGL 1.1 vertex array functionality is + the lack of any guidance from the API about what region of memory + vertices can be pulled from. There is no size limit for OpenGL 1.1 + vertex arrays. Any vertex index that points to valid data in all + enabled arrays is fair game. This makes it hard for a vertex DMA + engine to pull vertices since they can be potentially pulled from + anywhere in the OpenGL client address space. + + The vertex array range extension specifies a range of the OpenGL + client's address space where vertices can be pulled. Vertex indices + that access any array elements outside the vertex array range + are specified to be undefined. This permits hardware to DMA from + finite regions of OpenGL client address space, making DMA engine + implementation tractable. + + The extension is specified such that an (error free) OpenGL client + using the vertex array range functionality could no-op its vertex + array range commands and operate equivalently to using (if slower + than) the vertex array range functionality. + + Because different memory types (local graphics memory, AGP memory) + have different DMA bandwidths and caching behavior, this extension + includes a window system dependent memory allocator to allocate + cleanly the most appropriate memory for constructing a vertex array + range. The memory allocator provided allows the application to + tradeoff the desired CPU read frequency, CPU write frequency, and + memory priority while still leaving it up to OpenGL implementation + the exact memory type to be allocated. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/vertex_array_range.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.NV.vertex_array_range import * +from OpenGL.raw.GL.NV.vertex_array_range import _EXTENSION_NAME + +def glInitVertexArrayRangeNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glVertexArrayRangeNV.pointer size not checked against 'length' +glVertexArrayRangeNV=wrapper.wrapper(glVertexArrayRangeNV).setInputArraySize( + 'pointer', None +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/vertex_array_range2.py b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/vertex_array_range2.py new file mode 100644 index 00000000..cc5d37cd --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/vertex_array_range2.py @@ -0,0 +1,36 @@ +'''OpenGL extension NV.vertex_array_range2 + +This module customises the behaviour of the +OpenGL.raw.GL.NV.vertex_array_range2 to provide a more +Python-friendly API + +Overview (from the spec) + + Enabling and disabling the vertex array range is specified by the + original NV_vertex_array_range extension specification to flush the + vertex array range implicitly. In retrospect, this semantic is + extremely misconceived and creates terrible performance problems + for any application that wishes to mix conventional vertex arrays + with vertex arrange range-enabled vertex arrays. + + This extension provides a new token for enabling/disabling the + vertex array range that does NOT perform an implicit vertex array + range flush when the enable/disable is performed. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/vertex_array_range2.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.NV.vertex_array_range2 import * +from OpenGL.raw.GL.NV.vertex_array_range2 import _EXTENSION_NAME + +def glInitVertexArrayRange2NV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/vertex_attrib_integer_64bit.py b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/vertex_attrib_integer_64bit.py new file mode 100644 index 00000000..5c408a3c --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/vertex_attrib_integer_64bit.py @@ -0,0 +1,64 @@ +'''OpenGL extension NV.vertex_attrib_integer_64bit + +This module customises the behaviour of the +OpenGL.raw.GL.NV.vertex_attrib_integer_64bit to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides support for specifying vertex attributes with + 64-bit integer components, analagous to the 64-bit floating point support + added in EXT_vertex_attrib_64bit. + + Additionally, it provides the VertexAttribLFormatNV entry point to specify + bindless vertex attribute arrays with 64-bit integer or floating-point + components in conjunction with the NV_vertex_buffer_unified_memory + extension. + + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/vertex_attrib_integer_64bit.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.NV.vertex_attrib_integer_64bit import * +from OpenGL.raw.GL.NV.vertex_attrib_integer_64bit import _EXTENSION_NAME + +def glInitVertexAttribInteger64BitNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +glVertexAttribL1i64vNV=wrapper.wrapper(glVertexAttribL1i64vNV).setInputArraySize( + 'v', 1 +) +glVertexAttribL2i64vNV=wrapper.wrapper(glVertexAttribL2i64vNV).setInputArraySize( + 'v', 2 +) +glVertexAttribL3i64vNV=wrapper.wrapper(glVertexAttribL3i64vNV).setInputArraySize( + 'v', 3 +) +glVertexAttribL4i64vNV=wrapper.wrapper(glVertexAttribL4i64vNV).setInputArraySize( + 'v', 4 +) +glVertexAttribL1ui64vNV=wrapper.wrapper(glVertexAttribL1ui64vNV).setInputArraySize( + 'v', 1 +) +glVertexAttribL2ui64vNV=wrapper.wrapper(glVertexAttribL2ui64vNV).setInputArraySize( + 'v', 2 +) +glVertexAttribL3ui64vNV=wrapper.wrapper(glVertexAttribL3ui64vNV).setInputArraySize( + 'v', 3 +) +glVertexAttribL4ui64vNV=wrapper.wrapper(glVertexAttribL4ui64vNV).setInputArraySize( + 'v', 4 +) +glGetVertexAttribLi64vNV=wrapper.wrapper(glGetVertexAttribLi64vNV).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetVertexAttribLui64vNV=wrapper.wrapper(glGetVertexAttribLui64vNV).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/vertex_buffer_unified_memory.py b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/vertex_buffer_unified_memory.py new file mode 100644 index 00000000..3bd5a5ba --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/vertex_buffer_unified_memory.py @@ -0,0 +1,37 @@ +'''OpenGL extension NV.vertex_buffer_unified_memory + +This module customises the behaviour of the +OpenGL.raw.GL.NV.vertex_buffer_unified_memory to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides a mechanism to specify vertex attrib and + element array locations using GPU addresses. + + Binding vertex buffers is one of the most frequent and expensive + operations in many GL applications, due to the cost of chasing + pointers and binding objects described in the Overview of + NV_shader_buffer_load. The intent of this extension is to enable a + way for the application to specify vertex attrib state that alleviates + the overhead of object binds and driver memory management. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/vertex_buffer_unified_memory.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.NV.vertex_buffer_unified_memory import * +from OpenGL.raw.GL.NV.vertex_buffer_unified_memory import _EXTENSION_NAME + +def glInitVertexBufferUnifiedMemoryNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +glGetIntegerui64i_vNV=wrapper.wrapper(glGetIntegerui64i_vNV).setOutput( + 'result',size=_glgets._glget_size_mapping,pnameArg='value',orPassIn=True +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/vertex_program.py b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/vertex_program.py new file mode 100644 index 00000000..9f187f7f --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/vertex_program.py @@ -0,0 +1,229 @@ +'''OpenGL extension NV.vertex_program + +This module customises the behaviour of the +OpenGL.raw.GL.NV.vertex_program to provide a more +Python-friendly API + +Overview (from the spec) + + Unextended OpenGL mandates a certain set of configurable per-vertex + computations defining vertex transformation, texture coordinate + generation and transformation, and lighting. Several extensions + have added further per-vertex computations to OpenGL. For example, + extensions have defined new texture coordinate generation modes + (ARB_texture_cube_map, NV_texgen_reflection, NV_texgen_emboss), new + vertex transformation modes (EXT_vertex_weighting), new lighting modes + (OpenGL 1.2's separate specular and rescale normal functionality), + several modes for fog distance generation (NV_fog_distance), and + eye-distance point size attenuation (EXT_point_parameters). + + Each such extension adds a small set of relatively inflexible + per-vertex computations. + + This inflexibility is in contrast to the typical flexibility provided + by the underlying programmable floating point engines (whether + micro-coded vertex engines, DSPs, or CPUs) that are traditionally used + to implement OpenGL's per-vertex computations. The purpose of this + extension is to expose to the OpenGL application writer a significant + degree of per-vertex programmability for computing vertex parameters. + + For the purposes of discussing this extension, a vertex program is + a sequence of floating-point 4-component vector operations that + determines how a set of program parameters (defined outside of + OpenGL's begin/end pair) and an input set of per-vertex parameters + are transformed to a set of per-vertex output parameters. + + The per-vertex computations for standard OpenGL given a particular + set of lighting and texture coordinate generation modes (along with + any state for extensions defining per-vertex computations) is, in + essence, a vertex program. However, the sequence of operations is + defined implicitly by the current OpenGL state settings rather than + defined explicitly as a sequence of instructions. + + This extension provides an explicit mechanism for defining vertex + program instruction sequences for application-defined vertex programs. + In order to define such vertex programs, this extension defines + a vertex programming model including a floating-point 4-component + vector instruction set and a relatively large set of floating-point + 4-component registers. + + The extension's vertex programming model is designed for efficient + hardware implementation and to support a wide variety of vertex + programs. By design, the entire set of existing vertex programs + defined by existing OpenGL per-vertex computation extensions can be + implemented using the extension's vertex programming model. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/vertex_program.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.NV.vertex_program import * +from OpenGL.raw.GL.NV.vertex_program import _EXTENSION_NAME + +def glInitVertexProgramNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glAreProgramsResidentNV.programs size not checked against n +glAreProgramsResidentNV=wrapper.wrapper(glAreProgramsResidentNV).setInputArraySize( + 'programs', None +).setOutput( + 'residences',size=lambda x:(x,),pnameArg='n',orPassIn=True +) +# INPUT glDeleteProgramsNV.programs size not checked against n +glDeleteProgramsNV=wrapper.wrapper(glDeleteProgramsNV).setInputArraySize( + 'programs', None +) +glExecuteProgramNV=wrapper.wrapper(glExecuteProgramNV).setInputArraySize( + 'params', 4 +) +glGenProgramsNV=wrapper.wrapper(glGenProgramsNV).setOutput( + 'programs',size=lambda x:(x,),pnameArg='n',orPassIn=True +) +glGetProgramParameterdvNV=wrapper.wrapper(glGetProgramParameterdvNV).setOutput( + 'params',size=(4,),orPassIn=True +) +glGetProgramParameterfvNV=wrapper.wrapper(glGetProgramParameterfvNV).setOutput( + 'params',size=(4,),orPassIn=True +) +glGetProgramivNV=wrapper.wrapper(glGetProgramivNV).setOutput( + 'params',size=(4,),orPassIn=True +) +# OUTPUT glGetProgramStringNV.program COMPSIZE(id, pname) +glGetTrackMatrixivNV=wrapper.wrapper(glGetTrackMatrixivNV).setOutput( + 'params',size=(1,),orPassIn=True +) +glGetVertexAttribdvNV=wrapper.wrapper(glGetVertexAttribdvNV).setOutput( + 'params',size=(1,),orPassIn=True +) +glGetVertexAttribfvNV=wrapper.wrapper(glGetVertexAttribfvNV).setOutput( + 'params',size=(1,),orPassIn=True +) +glGetVertexAttribivNV=wrapper.wrapper(glGetVertexAttribivNV).setOutput( + 'params',size=(1,),orPassIn=True +) +glGetVertexAttribPointervNV=wrapper.wrapper(glGetVertexAttribPointervNV).setOutput( + 'pointer',size=(1,),orPassIn=True +) +# INPUT glLoadProgramNV.program size not checked against len +glLoadProgramNV=wrapper.wrapper(glLoadProgramNV).setInputArraySize( + 'program', None +) +glProgramParameter4dvNV=wrapper.wrapper(glProgramParameter4dvNV).setInputArraySize( + 'v', 4 +) +glProgramParameter4fvNV=wrapper.wrapper(glProgramParameter4fvNV).setInputArraySize( + 'v', 4 +) +# INPUT glProgramParameters4dvNV.v size not checked against count*4 +glProgramParameters4dvNV=wrapper.wrapper(glProgramParameters4dvNV).setInputArraySize( + 'v', None +) +# INPUT glProgramParameters4fvNV.v size not checked against count*4 +glProgramParameters4fvNV=wrapper.wrapper(glProgramParameters4fvNV).setInputArraySize( + 'v', None +) +# INPUT glRequestResidentProgramsNV.programs size not checked against n +glRequestResidentProgramsNV=wrapper.wrapper(glRequestResidentProgramsNV).setInputArraySize( + 'programs', None +) +# INPUT glVertexAttribPointerNV.pointer size not checked against 'fsize,type,stride' +glVertexAttribPointerNV=wrapper.wrapper(glVertexAttribPointerNV).setInputArraySize( + 'pointer', None +) +glVertexAttrib1dvNV=wrapper.wrapper(glVertexAttrib1dvNV).setInputArraySize( + 'v', 1 +) +glVertexAttrib1fvNV=wrapper.wrapper(glVertexAttrib1fvNV).setInputArraySize( + 'v', 1 +) +glVertexAttrib1svNV=wrapper.wrapper(glVertexAttrib1svNV).setInputArraySize( + 'v', 1 +) +glVertexAttrib2dvNV=wrapper.wrapper(glVertexAttrib2dvNV).setInputArraySize( + 'v', 2 +) +glVertexAttrib2fvNV=wrapper.wrapper(glVertexAttrib2fvNV).setInputArraySize( + 'v', 2 +) +glVertexAttrib2svNV=wrapper.wrapper(glVertexAttrib2svNV).setInputArraySize( + 'v', 2 +) +glVertexAttrib3dvNV=wrapper.wrapper(glVertexAttrib3dvNV).setInputArraySize( + 'v', 3 +) +glVertexAttrib3fvNV=wrapper.wrapper(glVertexAttrib3fvNV).setInputArraySize( + 'v', 3 +) +glVertexAttrib3svNV=wrapper.wrapper(glVertexAttrib3svNV).setInputArraySize( + 'v', 3 +) +glVertexAttrib4dvNV=wrapper.wrapper(glVertexAttrib4dvNV).setInputArraySize( + 'v', 4 +) +glVertexAttrib4fvNV=wrapper.wrapper(glVertexAttrib4fvNV).setInputArraySize( + 'v', 4 +) +glVertexAttrib4svNV=wrapper.wrapper(glVertexAttrib4svNV).setInputArraySize( + 'v', 4 +) +glVertexAttrib4ubvNV=wrapper.wrapper(glVertexAttrib4ubvNV).setInputArraySize( + 'v', 4 +) +# INPUT glVertexAttribs1dvNV.v size not checked against count +glVertexAttribs1dvNV=wrapper.wrapper(glVertexAttribs1dvNV).setInputArraySize( + 'v', None +) +# INPUT glVertexAttribs1fvNV.v size not checked against count +glVertexAttribs1fvNV=wrapper.wrapper(glVertexAttribs1fvNV).setInputArraySize( + 'v', None +) +# INPUT glVertexAttribs1svNV.v size not checked against count +glVertexAttribs1svNV=wrapper.wrapper(glVertexAttribs1svNV).setInputArraySize( + 'v', None +) +# INPUT glVertexAttribs2dvNV.v size not checked against count*2 +glVertexAttribs2dvNV=wrapper.wrapper(glVertexAttribs2dvNV).setInputArraySize( + 'v', None +) +# INPUT glVertexAttribs2fvNV.v size not checked against count*2 +glVertexAttribs2fvNV=wrapper.wrapper(glVertexAttribs2fvNV).setInputArraySize( + 'v', None +) +# INPUT glVertexAttribs2svNV.v size not checked against count*2 +glVertexAttribs2svNV=wrapper.wrapper(glVertexAttribs2svNV).setInputArraySize( + 'v', None +) +# INPUT glVertexAttribs3dvNV.v size not checked against count*3 +glVertexAttribs3dvNV=wrapper.wrapper(glVertexAttribs3dvNV).setInputArraySize( + 'v', None +) +# INPUT glVertexAttribs3fvNV.v size not checked against count*3 +glVertexAttribs3fvNV=wrapper.wrapper(glVertexAttribs3fvNV).setInputArraySize( + 'v', None +) +# INPUT glVertexAttribs3svNV.v size not checked against count*3 +glVertexAttribs3svNV=wrapper.wrapper(glVertexAttribs3svNV).setInputArraySize( + 'v', None +) +# INPUT glVertexAttribs4dvNV.v size not checked against count*4 +glVertexAttribs4dvNV=wrapper.wrapper(glVertexAttribs4dvNV).setInputArraySize( + 'v', None +) +# INPUT glVertexAttribs4fvNV.v size not checked against count*4 +glVertexAttribs4fvNV=wrapper.wrapper(glVertexAttribs4fvNV).setInputArraySize( + 'v', None +) +# INPUT glVertexAttribs4svNV.v size not checked against count*4 +glVertexAttribs4svNV=wrapper.wrapper(glVertexAttribs4svNV).setInputArraySize( + 'v', None +) +# INPUT glVertexAttribs4ubvNV.v size not checked against count*4 +glVertexAttribs4ubvNV=wrapper.wrapper(glVertexAttribs4ubvNV).setInputArraySize( + 'v', None +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/vertex_program1_1.py b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/vertex_program1_1.py new file mode 100644 index 00000000..3f3b437d --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/vertex_program1_1.py @@ -0,0 +1,48 @@ +'''OpenGL extension NV.vertex_program1_1 + +This module customises the behaviour of the +OpenGL.raw.GL.NV.vertex_program1_1 to provide a more +Python-friendly API + +Overview (from the spec) + + This extension adds four new vertex program instructions (DPH, + RCC, SUB, and ABS). + + This extension also supports a position-invariant vertex program + option. A vertex program is position-invariant when it generates + the _exact_ same homogenuous position and window space position + for a vertex as conventional OpenGL transformation (ignoring vertex + blending and weighting). + + By default, vertex programs are _not_ guaranteed to be + position-invariant because there is no guarantee made that the way + a vertex program might compute its homogenous position is exactly + identical to the way conventional OpenGL transformation computes + its homogenous positions. In a position-invariant vertex program, + the homogeneous position (HPOS) is not output by the program. + Instead, the OpenGL implementation is expected to compute the HPOS + for position-invariant vertex programs in a manner exactly identical + to how the homogenous position and window position are computed + for a vertex by conventional OpenGL transformation. In this way + position-invariant vertex programs guarantee correct multi-pass + rendering semantics in cases where multiple passes are rendered and + the second and subsequent passes use a GL_EQUAL depth test. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/vertex_program1_1.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.NV.vertex_program1_1 import * +from OpenGL.raw.GL.NV.vertex_program1_1 import _EXTENSION_NAME + +def glInitVertexProgram11NV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/vertex_program2.py b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/vertex_program2.py new file mode 100644 index 00000000..37980028 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/vertex_program2.py @@ -0,0 +1,117 @@ +'''OpenGL extension NV.vertex_program2 + +This module customises the behaviour of the +OpenGL.raw.GL.NV.vertex_program2 to provide a more +Python-friendly API + +Overview (from the spec) + + This extension further enhances the concept of vertex programmability + introduced by the NV_vertex_program extension, and extended by + NV_vertex_program1_1. These extensions create a separate vertex program + mode where the configurable vertex transformation operations in unextended + OpenGL are replaced by a user-defined program. + + This extension introduces the VP2 execution environment, which extends the + VP1 execution environment introduced in NV_vertex_program. The VP2 + environment provides several language features not present in previous + vertex programming execution environments: + + * Branch instructions allow a program to jump to another instruction + specified in the program. + + * Branching support allows for up to four levels of subroutine + calls/returns. + + * A four-component condition code register allows an application to + compute a component-wise write mask at run time and apply that mask to + register writes. + + * Conditional branches are supported, where the condition code register + is used to determine if a branch should be taken. + + * Programmable user clipping is supported support (via the CLP0-CLP5 + clip distance registers). Primitives are clipped to the area where + the interpolated clip distances are greater than or equal to zero. + + * Instructions can perform a component-wise absolute value operation on + any operand load. + + The VP2 execution environment provides a number of new instructions, and + extends the semantics of several instructions already defined in + NV_vertex_program. + + * ARR: Operates like ARL, except that float-to-int conversion is done + by rounding. Equivalent results could be achieved (less efficiently) + in NV_vertex program using an ADD/ARL sequence and a program parameter + holding the value 0.5. + + * BRA, CAL, RET: Branch, subroutine call, and subroutine return + instructions. + + * COS, SIN: Adds support for high-precision sine and cosine + computations. + + * FLR, FRC: Adds support for computing the floor and fractional portion + of floating-point vector components. Equivalent results could be + achieved (less efficiently) in NV_vertex_program using the EXP + instruction to compute the fractional portion of one component at a + time. + + * EX2, LG2: Adds support for high-precision exponentiation and + logarithm computations. + + * ARA: Adds pairs of components of an address register; useful for + looping and other operations. + + * SEQ, SFL, SGT, SLE, SNE, STR: Add six new "set on" instructions, + similar to the SLT and SGE instructions defined in NV_vertex_program. + Equivalent results could be achieved (less efficiently) in + NV_vertex_program with multiple SLT, SGE, and arithmetic instructions. + + * SSG: Adds a new "set sign" operation, which produces a vector holding + negative one for negative components, zero for components with a value + of zero, and positive one for positive components. Equivalent results + could be achieved (less efficiently) in NV_vertex_program with + multiple SLT, SGE, and arithmetic instructions. + + * The ARL instruction is extended to operate on four components instead + of a single component. + + * All instructions that produce integer or floating-point result vectors + have variants that update the condition code register based on the + result vector. + + This extension also raises some of the resource limitations in the + NV_vertex_program extension. + + * 256 program parameter registers (versus 96 in NV_vertex_program). + + * 16 temporary registers (versus 12 in NV_vertex_program). + + * Two four-component integer address registers (versus one + single-component register in NV_vertex_program). + + * 256 total vertex program instructions (versus 128 in + NV_vertex_program). + + * Including loops, programs can execute up to 64K instructions. + + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/vertex_program2.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.NV.vertex_program2 import * +from OpenGL.raw.GL.NV.vertex_program2 import _EXTENSION_NAME + +def glInitVertexProgram2NV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/vertex_program2_option.py b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/vertex_program2_option.py new file mode 100644 index 00000000..ff08bbc8 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/vertex_program2_option.py @@ -0,0 +1,57 @@ +'''OpenGL extension NV.vertex_program2_option + +This module customises the behaviour of the +OpenGL.raw.GL.NV.vertex_program2_option to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides additional vertex program functionality + to extend the standard ARB_vertex_program language and execution + environment. ARB programs wishing to use this added functionality + need only add: + + OPTION NV_vertex_program2; + + to the beginning of their vertex programs. + + The functionality provided by this extension, which is roughly + equivalent to that provided by the NV_vertex_program2 extension, + includes: + + * general purpose dynamic branching, + + * subroutine calls, + + * data-dependent conditional write masks, + + * programmable user clip distances, + + * address registers with four components (instead of just one), + + * absolute value operator on scalar and swizzled operand loads, + + * rudimentary address register math, + + * SIN and COS trigonometry instructions, and + + * fully orthogonal "set on" instructions, including a "set sign" + instruction. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/vertex_program2_option.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.NV.vertex_program2_option import * +from OpenGL.raw.GL.NV.vertex_program2_option import _EXTENSION_NAME + +def glInitVertexProgram2OptionNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/vertex_program3.py b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/vertex_program3.py new file mode 100644 index 00000000..78758809 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/vertex_program3.py @@ -0,0 +1,46 @@ +'''OpenGL extension NV.vertex_program3 + +This module customises the behaviour of the +OpenGL.raw.GL.NV.vertex_program3 to provide a more +Python-friendly API + +Overview (from the spec) + + This extension, like the NV_vertex_program2_option extension, + provides additional vertex program functionality to extend the + standard ARB_vertex_program language and execution environment. + ARB programs wishing to use this added functionality need only add: + + OPTION NV_vertex_program3; + + to the beginning of their vertex programs. + + New functionality provided by this extension, above and beyond that + already provided by NV_vertex_program2_option extension, includes: + + * texture lookups in vertex programs, + + * ability to push and pop address registers on the stack, + + * address register-relative addressing for vertex attribute and + result arrays, and + + * a second four-component condition code. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/vertex_program3.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.NV.vertex_program3 import * +from OpenGL.raw.GL.NV.vertex_program3 import _EXTENSION_NAME + +def glInitVertexProgram3NV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/vertex_program4.py b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/vertex_program4.py new file mode 100644 index 00000000..dcca9d89 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/vertex_program4.py @@ -0,0 +1,95 @@ +'''OpenGL extension NV.vertex_program4 + +This module customises the behaviour of the +OpenGL.raw.GL.NV.vertex_program4 to provide a more +Python-friendly API + +Overview (from the spec) + + This extension builds on the common assembly instruction set + infrastructure provided by NV_gpu_program4, adding vertex program-specific + features. + + This extension provides the ability to specify integer vertex attributes + that are passed to vertex programs using integer data types, rather than + being converted to floating-point values as in existing vertex attribute + functions. The set of input and output bindings provided includes all + bindings supported by ARB_vertex_program. This extension provides + additional input bindings identifying the index of the vertex when vertex + arrays are used ("vertex.id") and the instance number when instanced + arrays are used ("vertex.instance", requires EXT_draw_instanced). It + also provides output bindings allowing vertex programs to directly specify + clip distances (for user clipping) plus a set of generic attributes that + allow programs to pass a greater number of attributes to subsequent + pipeline stages than is possible using only the pre-defined fixed-function + vertex outputs. + + By and large, programs written to ARB_vertex_program can be ported + directly by simply changing the program header from "!!ARBvp1.0" to + "!!NVvp4.0", and then modifying instructions to take advantage of the + expanded feature set. There are a small number of areas where this + extension is not a functional superset of previous vertex program + extensions, which are documented in the NV_gpu_program4 specification. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/vertex_program4.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.NV.vertex_program4 import * +from OpenGL.raw.GL.NV.vertex_program4 import _EXTENSION_NAME + +def glInitVertexProgram4NV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +glVertexAttribI1ivEXT=wrapper.wrapper(glVertexAttribI1ivEXT).setInputArraySize( + 'v', 1 +) +glVertexAttribI2ivEXT=wrapper.wrapper(glVertexAttribI2ivEXT).setInputArraySize( + 'v', 2 +) +glVertexAttribI3ivEXT=wrapper.wrapper(glVertexAttribI3ivEXT).setInputArraySize( + 'v', 3 +) +glVertexAttribI4ivEXT=wrapper.wrapper(glVertexAttribI4ivEXT).setInputArraySize( + 'v', 4 +) +glVertexAttribI1uivEXT=wrapper.wrapper(glVertexAttribI1uivEXT).setInputArraySize( + 'v', 1 +) +glVertexAttribI2uivEXT=wrapper.wrapper(glVertexAttribI2uivEXT).setInputArraySize( + 'v', 2 +) +glVertexAttribI3uivEXT=wrapper.wrapper(glVertexAttribI3uivEXT).setInputArraySize( + 'v', 3 +) +glVertexAttribI4uivEXT=wrapper.wrapper(glVertexAttribI4uivEXT).setInputArraySize( + 'v', 4 +) +glVertexAttribI4bvEXT=wrapper.wrapper(glVertexAttribI4bvEXT).setInputArraySize( + 'v', 4 +) +glVertexAttribI4svEXT=wrapper.wrapper(glVertexAttribI4svEXT).setInputArraySize( + 'v', 4 +) +glVertexAttribI4ubvEXT=wrapper.wrapper(glVertexAttribI4ubvEXT).setInputArraySize( + 'v', 4 +) +glVertexAttribI4usvEXT=wrapper.wrapper(glVertexAttribI4usvEXT).setInputArraySize( + 'v', 4 +) +# INPUT glVertexAttribIPointerEXT.pointer size not checked against 'size,type,stride' +glVertexAttribIPointerEXT=wrapper.wrapper(glVertexAttribIPointerEXT).setInputArraySize( + 'pointer', None +) +glGetVertexAttribIivEXT=wrapper.wrapper(glGetVertexAttribIivEXT).setOutput( + 'params',size=(1,),orPassIn=True +) +glGetVertexAttribIuivEXT=wrapper.wrapper(glGetVertexAttribIuivEXT).setOutput( + 'params',size=(1,),orPassIn=True +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/video_capture.py b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/video_capture.py new file mode 100644 index 00000000..4d159277 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/video_capture.py @@ -0,0 +1,56 @@ +'''OpenGL extension NV.video_capture + +This module customises the behaviour of the +OpenGL.raw.GL.NV.video_capture to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides a mechanism for streaming video data + directly into texture objects and buffer objects. Applications can + then display video streams in interactive 3D scenes and/or + manipulate the video data using the GL's image processing + capabilities. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/video_capture.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.NV.video_capture import * +from OpenGL.raw.GL.NV.video_capture import _EXTENSION_NAME + +def glInitVideoCaptureNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +glGetVideoCaptureivNV=wrapper.wrapper(glGetVideoCaptureivNV).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetVideoCaptureStreamivNV=wrapper.wrapper(glGetVideoCaptureStreamivNV).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetVideoCaptureStreamfvNV=wrapper.wrapper(glGetVideoCaptureStreamfvNV).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetVideoCaptureStreamdvNV=wrapper.wrapper(glGetVideoCaptureStreamdvNV).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +# glVideoCaptureNV.capture_time is OUTPUT without known output size +# glVideoCaptureNV.sequence_num is OUTPUT without known output size +# INPUT glVideoCaptureStreamParameterivNV.params size not checked against 'pname' +glVideoCaptureStreamParameterivNV=wrapper.wrapper(glVideoCaptureStreamParameterivNV).setInputArraySize( + 'params', None +) +# INPUT glVideoCaptureStreamParameterfvNV.params size not checked against 'pname' +glVideoCaptureStreamParameterfvNV=wrapper.wrapper(glVideoCaptureStreamParameterfvNV).setInputArraySize( + 'params', None +) +# INPUT glVideoCaptureStreamParameterdvNV.params size not checked against 'pname' +glVideoCaptureStreamParameterdvNV=wrapper.wrapper(glVideoCaptureStreamParameterdvNV).setInputArraySize( + 'params', None +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/viewport_array2.py b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/viewport_array2.py new file mode 100644 index 00000000..c0e4fe1c --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/viewport_array2.py @@ -0,0 +1,45 @@ +'''OpenGL extension NV.viewport_array2 + +This module customises the behaviour of the +OpenGL.raw.GL.NV.viewport_array2 to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides new support allowing a single primitive to be + broadcast to multiple viewports and/or multiple layers. A shader output + gl_ViewportMask[] is provided, allowing a single primitive to be output to + multiple viewports simultaneously. Also, a new shader option is provided + to control whether the effective viewport index is added into gl_Layer. + These capabilities allow a single primitive to be output to multiple + layers simultaneously. + + The gl_ViewportMask[] output is available in vertex, tessellation + control, tessellation evaluation, and geometry shaders. gl_ViewportIndex + and gl_Layer are also made available in all these shader stages. The + actual viewport index or mask and render target layer values are taken + from the last active shader stage from this set of stages. + + This extension is a superset of the GL_AMD_vertex_shader_layer and + GL_AMD_vertex_shader_viewport_index extensions, and thus those extension + strings are expected to be exported if GL_NV_viewport_array2 is + supported. This extension includes the edits for those extensions, recast + against the reorganized OpenGL 4.3 specification. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/viewport_array2.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.NV.viewport_array2 import * +from OpenGL.raw.GL.NV.viewport_array2 import _EXTENSION_NAME + +def glInitViewportArray2NV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NV/viewport_swizzle.py b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/viewport_swizzle.py new file mode 100644 index 00000000..88641cdd --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/NV/viewport_swizzle.py @@ -0,0 +1,41 @@ +'''OpenGL extension NV.viewport_swizzle + +This module customises the behaviour of the +OpenGL.raw.GL.NV.viewport_swizzle to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides a new per-viewport swizzle that can modify the + position of primitives sent to each viewport. New viewport swizzle state + is added for each viewport, and a new position vector is computed for each + vertex by selecting from and optionally negating any of the four + components of the original position vector. + + This new viewport swizzle is useful for a number of algorithms, including + single-pass cubemap rendering (broadcasting a primitive to multiple faces + and reorienting the vertex position for each face) and voxel + rasterization. The per-viewport component remapping and negation provided + by the swizzle allows application code to re-orient three-dimensional + geometry with a view along any of the X, Y, or Z axes. If a perspective + projection and depth buffering is required, 1/W buffering should be used, + as described in the single-pass cubemap rendering example in the "Issues" + section below. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/viewport_swizzle.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.NV.viewport_swizzle import * +from OpenGL.raw.GL.NV.viewport_swizzle import _EXTENSION_NAME + +def glInitViewportSwizzleNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NVX/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/GL/NVX/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NVX/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/NVX/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..1f6af17d Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/NVX/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NVX/__pycache__/blend_equation_advanced_multi_draw_buffers.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/NVX/__pycache__/blend_equation_advanced_multi_draw_buffers.cpython-312.pyc new file mode 100644 index 00000000..4cbba8cc Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/NVX/__pycache__/blend_equation_advanced_multi_draw_buffers.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NVX/__pycache__/conditional_render.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/NVX/__pycache__/conditional_render.cpython-312.pyc new file mode 100644 index 00000000..285fab28 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/NVX/__pycache__/conditional_render.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NVX/__pycache__/gpu_memory_info.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/NVX/__pycache__/gpu_memory_info.cpython-312.pyc new file mode 100644 index 00000000..4805bd3e Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/NVX/__pycache__/gpu_memory_info.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NVX/__pycache__/gpu_multicast2.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/NVX/__pycache__/gpu_multicast2.cpython-312.pyc new file mode 100644 index 00000000..76321b91 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/NVX/__pycache__/gpu_multicast2.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NVX/__pycache__/linked_gpu_multicast.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/NVX/__pycache__/linked_gpu_multicast.cpython-312.pyc new file mode 100644 index 00000000..5a9f8bfe Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/NVX/__pycache__/linked_gpu_multicast.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NVX/__pycache__/progress_fence.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/NVX/__pycache__/progress_fence.cpython-312.pyc new file mode 100644 index 00000000..9582000a Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/NVX/__pycache__/progress_fence.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NVX/blend_equation_advanced_multi_draw_buffers.py b/venv/lib/python3.12/site-packages/OpenGL/GL/NVX/blend_equation_advanced_multi_draw_buffers.py new file mode 100644 index 00000000..d8109997 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/NVX/blend_equation_advanced_multi_draw_buffers.py @@ -0,0 +1,34 @@ +'''OpenGL extension NVX.blend_equation_advanced_multi_draw_buffers + +This module customises the behaviour of the +OpenGL.raw.GL.NVX.blend_equation_advanced_multi_draw_buffers to provide a more +Python-friendly API + +Overview (from the spec) + + This extension adds support for using advanced blend equations + introduced with NV_blend_equation_advanced (and standardized + by KHR_blend_equation_advanced) in conjunction with multiple + draw buffers. The NV_blend_equation_advanced extension supports + advanced blending equations only when rending to a single color + buffer using fragment color zero and throws and INVALID_OPERATION + error when multiple draw buffers are used. This extension removes + this restriction. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NVX/blend_equation_advanced_multi_draw_buffers.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.NVX.blend_equation_advanced_multi_draw_buffers import * +from OpenGL.raw.GL.NVX.blend_equation_advanced_multi_draw_buffers import _EXTENSION_NAME + +def glInitBlendEquationAdvancedMultiDrawBuffersNVX(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NVX/conditional_render.py b/venv/lib/python3.12/site-packages/OpenGL/GL/NVX/conditional_render.py new file mode 100644 index 00000000..b9f820ae --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/NVX/conditional_render.py @@ -0,0 +1,39 @@ +'''OpenGL extension NVX.conditional_render + +This module customises the behaviour of the +OpenGL.raw.GL.NVX.conditional_render to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides support for conditional rendering based on the + results of an occlusion query. This mechanism allows an application to + potentially reduce the latency between the completion of an occlusion + query and the rendering commands depending on its result. It additionally + allows the decision of whether to render to be made without application + intervention. + + This extension defines two new functions, BeginConditionalRenderNVX and + EndConditionalRenderNVX, between which rendering commands may be discarded + based on the results of an occlusion query. If the specified occlusion + query returns a non-zero value, rendering commands between these calls are + executed. If the occlusion query returns a value of zero, all rendering + commands between the calls are discarded. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NVX/conditional_render.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.NVX.conditional_render import * +from OpenGL.raw.GL.NVX.conditional_render import _EXTENSION_NAME + +def glInitConditionalRenderNVX(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NVX/gpu_memory_info.py b/venv/lib/python3.12/site-packages/OpenGL/GL/NVX/gpu_memory_info.py new file mode 100644 index 00000000..c7cdf716 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/NVX/gpu_memory_info.py @@ -0,0 +1,50 @@ +'''OpenGL extension NVX.gpu_memory_info + +This module customises the behaviour of the +OpenGL.raw.GL.NVX.gpu_memory_info to provide a more +Python-friendly API + +Overview (from the spec) + + Most graphics systems offer a limited amount of onboard + high-performance memory for storing textures, geometric + primitives, and other data used for rendering. + + OpenGL implementations are expected to manage the residence of + objects (that is, the memory pools in which objects are placed) + automatically. This is simple for applications to use, and the + high level of abstraction allows many different underlying + hardware implementations. However performance sensitive + applications that are willing to adjust their usage of these memory + resources in order to maintain their desired performance are unable + to determine when the limited onboard memory resources are + approaching full utilization and swapping (with its related + performance impact) is imminent. + + GL_NVX_gpu_memory_info provides applications visibility into GPU + hardware memory utilization in order to allow the application to + effectively manage its resource allocations in the scope of the + current available GPU memory. This information is made available + to the applications in the form of the total available resource + size (after initial system allocations) and the current available + resource (e.g. free memory) as well as a count of the number and + total size of evictions of data from GPU memory since the last time + this information was queried from this context using this extension. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NVX/gpu_memory_info.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.NVX.gpu_memory_info import * +from OpenGL.raw.GL.NVX.gpu_memory_info import _EXTENSION_NAME + +def glInitGpuMemoryInfoNVX(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NVX/gpu_multicast2.py b/venv/lib/python3.12/site-packages/OpenGL/GL/NVX/gpu_multicast2.py new file mode 100644 index 00000000..56cf94b0 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/NVX/gpu_multicast2.py @@ -0,0 +1,61 @@ +'''OpenGL extension NVX.gpu_multicast2 + +This module customises the behaviour of the +OpenGL.raw.GL.NVX.gpu_multicast2 to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides additional mechanisms that influence multicast rendering which is + simultaneous rendering to multiple GPUs. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NVX/gpu_multicast2.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.NVX.gpu_multicast2 import * +from OpenGL.raw.GL.NVX.gpu_multicast2 import _EXTENSION_NAME + +def glInitGpuMulticast2NVX(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glMulticastViewportArrayvNVX.v size not checked against 'count' +glMulticastViewportArrayvNVX=wrapper.wrapper(glMulticastViewportArrayvNVX).setInputArraySize( + 'v', None +) +# INPUT glMulticastScissorArrayvNVX.v size not checked against 'count' +glMulticastScissorArrayvNVX=wrapper.wrapper(glMulticastScissorArrayvNVX).setInputArraySize( + 'v', None +) +# INPUT glAsyncCopyBufferSubDataNVX.fenceValueArray size not checked against waitSemaphoreCount +# INPUT glAsyncCopyBufferSubDataNVX.signalSemaphoreArray size not checked against signalSemaphoreCount +# INPUT glAsyncCopyBufferSubDataNVX.signalValueArray size not checked against signalSemaphoreCount +# INPUT glAsyncCopyBufferSubDataNVX.waitSemaphoreArray size not checked against waitSemaphoreCount +glAsyncCopyBufferSubDataNVX=wrapper.wrapper(glAsyncCopyBufferSubDataNVX).setInputArraySize( + 'fenceValueArray', None +).setInputArraySize( + 'signalSemaphoreArray', None +).setInputArraySize( + 'signalValueArray', None +).setInputArraySize( + 'waitSemaphoreArray', None +) +# INPUT glAsyncCopyImageSubDataNVX.signalSemaphoreArray size not checked against signalSemaphoreCount +# INPUT glAsyncCopyImageSubDataNVX.signalValueArray size not checked against signalSemaphoreCount +# INPUT glAsyncCopyImageSubDataNVX.waitSemaphoreArray size not checked against waitSemaphoreCount +# INPUT glAsyncCopyImageSubDataNVX.waitValueArray size not checked against waitSemaphoreCount +glAsyncCopyImageSubDataNVX=wrapper.wrapper(glAsyncCopyImageSubDataNVX).setInputArraySize( + 'signalSemaphoreArray', None +).setInputArraySize( + 'signalValueArray', None +).setInputArraySize( + 'waitSemaphoreArray', None +).setInputArraySize( + 'waitValueArray', None +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NVX/linked_gpu_multicast.py b/venv/lib/python3.12/site-packages/OpenGL/GL/NVX/linked_gpu_multicast.py new file mode 100644 index 00000000..e4553cb4 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/NVX/linked_gpu_multicast.py @@ -0,0 +1,58 @@ +'''OpenGL extension NVX.linked_gpu_multicast + +This module customises the behaviour of the +OpenGL.raw.GL.NVX.linked_gpu_multicast to provide a more +Python-friendly API + +Overview (from the spec) + + This extension enables novel multi-GPU rendering techniques by providing application control + over a group of linked GPUs with identical hardware configuration. + + Multi-GPU rendering techniques fall into two categories: implicit and explicit. Existing + explicit approaches like WGL_NV_gpu_affinity have two main drawbacks: CPU overhead and + application complexity. An application must manage one context per GPU and multi-pump the API + stream. Implicit multi-GPU rendering techniques avoid these issues by broadcasting rendering + from one context to multiple GPUs. Common implicit approaches include alternate-frame + rendering (AFR), split-frame rendering (SFR) and multi-GPU anti-aliasing. They each have + drawbacks. AFR scales nicely but interacts poorly with inter-frame dependencies. SFR can + improve latency but has challenges with offscreen rendering and scaling of vertex processing. + With multi-GPU anti-aliasing, each GPU renders the same content with alternate sample + positions and the driver blends the result to improve quality. This also has issues with + offscreen rendering and can conflict with other anti-aliasing techniques. + + These issues with implicit multi-GPU rendering all have the same root cause: the driver lacks + adequate knowledge to accelerate every application. To resolve this, NVX_linked_gpu_multicast + provides application control over multiple GPUs with a single context. + + Key points: + + - One context controls multiple GPUs. Every GPU in the linked group can access every object. + + - Rendering is broadcast. Each draw is repeated across all GPUs in the linked group. + + - Each GPU gets its own instance of all framebuffers and attached textures, allowing + individualized output for each GPU. Input data can be customized for each GPU using buffers + created with the storage flag, LGPU_SEPARATE_STORAGE_BIT_NVX and a new API, + LGPUNamedBufferSubDataNVX. + + - Textures can be transferred from one GPU to another using LGPUCopyImageSubDataNVX. + + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NVX/linked_gpu_multicast.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.NVX.linked_gpu_multicast import * +from OpenGL.raw.GL.NVX.linked_gpu_multicast import _EXTENSION_NAME + +def glInitLinkedGpuMulticastNVX(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/NVX/progress_fence.py b/venv/lib/python3.12/site-packages/OpenGL/GL/NVX/progress_fence.py new file mode 100644 index 00000000..2a0a0ba1 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/NVX/progress_fence.py @@ -0,0 +1,62 @@ +'''OpenGL extension NVX.progress_fence + +This module customises the behaviour of the +OpenGL.raw.GL.NVX.progress_fence to provide a more +Python-friendly API + +Overview (from the spec) + + This extension uses the concept of GL semaphores as defined in + GL_EXT_semaphore to better coordinate operations between multiple + GPU command streams. A semaphore type called "progress fence" is + derived from the GL semaphore. The progress fence semaphore is + created by CreateProgressFenceNVX() returning the name of a newly + created semaphore object. Like other semaphores, these are signaled + by the GL server. Each signal operation is queued in the GPU command + stream with an associated fence value that is written to the semaphore + at the completion of a signal operation. + + A GL server wait can be added to the command stream using WaitSemaphoreui64NVX. + This blocks the GPU until the progress fence semaphore reaches or exceeds the + specified fence value. + + A GL client wait can be initiated using ClientWaitSemaphoreui64NVX. + This blocks the CPU until the specified fence value is reached. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NVX/progress_fence.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.NVX.progress_fence import * +from OpenGL.raw.GL.NVX.progress_fence import _EXTENSION_NAME + +def glInitProgressFenceNVX(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glSignalSemaphoreui64NVX.fenceValueArray size not checked against fenceObjectCount +# INPUT glSignalSemaphoreui64NVX.semaphoreArray size not checked against fenceObjectCount +glSignalSemaphoreui64NVX=wrapper.wrapper(glSignalSemaphoreui64NVX).setInputArraySize( + 'fenceValueArray', None +).setInputArraySize( + 'semaphoreArray', None +) +# INPUT glWaitSemaphoreui64NVX.fenceValueArray size not checked against fenceObjectCount +# INPUT glWaitSemaphoreui64NVX.semaphoreArray size not checked against fenceObjectCount +glWaitSemaphoreui64NVX=wrapper.wrapper(glWaitSemaphoreui64NVX).setInputArraySize( + 'fenceValueArray', None +).setInputArraySize( + 'semaphoreArray', None +) +# INPUT glClientWaitSemaphoreui64NVX.fenceValueArray size not checked against fenceObjectCount +# INPUT glClientWaitSemaphoreui64NVX.semaphoreArray size not checked against fenceObjectCount +glClientWaitSemaphoreui64NVX=wrapper.wrapper(glClientWaitSemaphoreui64NVX).setInputArraySize( + 'fenceValueArray', None +).setInputArraySize( + 'semaphoreArray', None +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/OES/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/GL/OES/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/OES/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/OES/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/OES/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..325bf827 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/OES/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/OES/__pycache__/byte_coordinates.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/OES/__pycache__/byte_coordinates.cpython-312.pyc new file mode 100644 index 00000000..c0a46947 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/OES/__pycache__/byte_coordinates.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/OES/__pycache__/compressed_paletted_texture.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/OES/__pycache__/compressed_paletted_texture.cpython-312.pyc new file mode 100644 index 00000000..140642bd Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/OES/__pycache__/compressed_paletted_texture.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/OES/__pycache__/fixed_point.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/OES/__pycache__/fixed_point.cpython-312.pyc new file mode 100644 index 00000000..e1fdcff2 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/OES/__pycache__/fixed_point.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/OES/__pycache__/query_matrix.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/OES/__pycache__/query_matrix.cpython-312.pyc new file mode 100644 index 00000000..8b9e2be0 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/OES/__pycache__/query_matrix.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/OES/__pycache__/read_format.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/OES/__pycache__/read_format.cpython-312.pyc new file mode 100644 index 00000000..054d922b Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/OES/__pycache__/read_format.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/OES/__pycache__/single_precision.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/OES/__pycache__/single_precision.cpython-312.pyc new file mode 100644 index 00000000..eb97af9c Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/OES/__pycache__/single_precision.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/OES/byte_coordinates.py b/venv/lib/python3.12/site-packages/OpenGL/GL/OES/byte_coordinates.py new file mode 100644 index 00000000..8ac5943a --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/OES/byte_coordinates.py @@ -0,0 +1,63 @@ +'''OpenGL extension OES.byte_coordinates + +This module customises the behaviour of the +OpenGL.raw.GL.OES.byte_coordinates to provide a more +Python-friendly API + +Overview (from the spec) + + This extension allows specifying, additionally to all existing + values, byte-valued vertex and texture coordinates to be used. + + The main reason for introducing the byte-argument is to allow + storing data more compactly on memory-restricted environments. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/OES/byte_coordinates.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.OES.byte_coordinates import * +from OpenGL.raw.GL.OES.byte_coordinates import _EXTENSION_NAME + +def glInitByteCoordinatesOES(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +glMultiTexCoord1bvOES=wrapper.wrapper(glMultiTexCoord1bvOES).setInputArraySize( + 'coords', 1 +) +glMultiTexCoord2bvOES=wrapper.wrapper(glMultiTexCoord2bvOES).setInputArraySize( + 'coords', 2 +) +glMultiTexCoord3bvOES=wrapper.wrapper(glMultiTexCoord3bvOES).setInputArraySize( + 'coords', 3 +) +glMultiTexCoord4bvOES=wrapper.wrapper(glMultiTexCoord4bvOES).setInputArraySize( + 'coords', 4 +) +glTexCoord1bvOES=wrapper.wrapper(glTexCoord1bvOES).setInputArraySize( + 'coords', 1 +) +glTexCoord2bvOES=wrapper.wrapper(glTexCoord2bvOES).setInputArraySize( + 'coords', 2 +) +glTexCoord3bvOES=wrapper.wrapper(glTexCoord3bvOES).setInputArraySize( + 'coords', 3 +) +glTexCoord4bvOES=wrapper.wrapper(glTexCoord4bvOES).setInputArraySize( + 'coords', 4 +) +glVertex2bvOES=wrapper.wrapper(glVertex2bvOES).setInputArraySize( + 'coords', 2 +) +glVertex3bvOES=wrapper.wrapper(glVertex3bvOES).setInputArraySize( + 'coords', 3 +) +glVertex4bvOES=wrapper.wrapper(glVertex4bvOES).setInputArraySize( + 'coords', 4 +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/OES/compressed_paletted_texture.py b/venv/lib/python3.12/site-packages/OpenGL/GL/OES/compressed_paletted_texture.py new file mode 100644 index 00000000..7d408788 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/OES/compressed_paletted_texture.py @@ -0,0 +1,60 @@ +'''OpenGL extension OES.compressed_paletted_texture + +This module customises the behaviour of the +OpenGL.raw.GL.OES.compressed_paletted_texture to provide a more +Python-friendly API + +Overview (from the spec) + + The goal of this extension is to allow direct support of palettized + textures in OpenGL ES. + + Palettized textures are implemented in OpenGL ES using the + CompressedTexImage2D call. The definition of the following parameters + "level" and "internalformat" in the CompressedTexImage2D call have + been extended to support paletted textures. + + A paletted texture is described by the following data: + + palette format + can be R5_G6_B5, RGBA4, RGB5_A1, RGB8, or RGBA8 + + number of bits to represent texture data + can be 4 bits or 8 bits per texel. The number of bits + also detemine the size of the palette. For 4 bits/texel + the palette size is 16 entries and for 8 bits/texel the + palette size will be 256 entries. + + The palette format and bits/texel are encoded in the + "internalformat" parameter. + + palette data and texture mip-levels + The palette data followed by all necessary mip levels are + passed in "data" parameter of CompressedTexImage2D. + + The size of palette is given by palette format and bits / texel. + A palette format of RGB_565 with 4 bits/texel imply a palette + size of 2 bytes/palette entry * 16 entries = 32 bytes. + + The level value is used to indicate how many mip levels + are described. Negative level values are used to define + the number of miplevels described in the "data" component. + A level of zero indicates a single mip-level. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/OES/compressed_paletted_texture.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.OES.compressed_paletted_texture import * +from OpenGL.raw.GL.OES.compressed_paletted_texture import _EXTENSION_NAME + +def glInitCompressedPalettedTextureOES(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/OES/fixed_point.py b/venv/lib/python3.12/site-packages/OpenGL/GL/OES/fixed_point.py new file mode 100644 index 00000000..848a957d --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/OES/fixed_point.py @@ -0,0 +1,215 @@ +'''OpenGL extension OES.fixed_point + +This module customises the behaviour of the +OpenGL.raw.GL.OES.fixed_point to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides the capability, for platforms that do + not have efficient floating-point support, to input data in a + fixed-point format, i.e., a scaled-integer format. There are + several ways a platform could try to solve the problem, such as + using integer only commands, but there are many OpenGL commands + that have only floating-point or double-precision floating-point + parameters. Also, it is likely that any credible application + running on such a platform will need to perform some computations + and will already be using some form of fixed-point representation. + This extension solves the problem by adding new ``fixed', and + ``clamp fixed'' data types based on a a two's complement + S15.16 representation. New versions of commands are created + with an 'x' suffix that take fixed or clampx parameters. + + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/OES/fixed_point.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.OES.fixed_point import * +from OpenGL.raw.GL.OES.fixed_point import _EXTENSION_NAME + +def glInitFixedPointOES(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +glClipPlanexOES=wrapper.wrapper(glClipPlanexOES).setInputArraySize( + 'equation', 4 +) +# INPUT glFogxvOES.param size not checked against 'pname' +glFogxvOES=wrapper.wrapper(glFogxvOES).setInputArraySize( + 'param', None +) +glGetClipPlanexOES=wrapper.wrapper(glGetClipPlanexOES).setOutput( + 'equation',size=(4,),orPassIn=True +) +glGetFixedvOES=wrapper.wrapper(glGetFixedvOES).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetTexEnvxvOES=wrapper.wrapper(glGetTexEnvxvOES).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetTexParameterxvOES=wrapper.wrapper(glGetTexParameterxvOES).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +# INPUT glLightModelxvOES.param size not checked against 'pname' +glLightModelxvOES=wrapper.wrapper(glLightModelxvOES).setInputArraySize( + 'param', None +) +# INPUT glLightxvOES.params size not checked against 'pname' +glLightxvOES=wrapper.wrapper(glLightxvOES).setInputArraySize( + 'params', None +) +glLoadMatrixxOES=wrapper.wrapper(glLoadMatrixxOES).setInputArraySize( + 'm', 16 +) +# INPUT glMaterialxvOES.param size not checked against 'pname' +glMaterialxvOES=wrapper.wrapper(glMaterialxvOES).setInputArraySize( + 'param', None +) +glMultMatrixxOES=wrapper.wrapper(glMultMatrixxOES).setInputArraySize( + 'm', 16 +) +# INPUT glPointParameterxvOES.params size not checked against 'pname' +glPointParameterxvOES=wrapper.wrapper(glPointParameterxvOES).setInputArraySize( + 'params', None +) +# INPUT glTexEnvxvOES.params size not checked against 'pname' +glTexEnvxvOES=wrapper.wrapper(glTexEnvxvOES).setInputArraySize( + 'params', None +) +# INPUT glTexParameterxvOES.params size not checked against 'pname' +glTexParameterxvOES=wrapper.wrapper(glTexParameterxvOES).setInputArraySize( + 'params', None +) +# INPUT glGetLightxvOES.params size not checked against 'pname' +glGetLightxvOES=wrapper.wrapper(glGetLightxvOES).setInputArraySize( + 'params', None +) +# INPUT glGetMaterialxvOES.params size not checked against 'pname' +glGetMaterialxvOES=wrapper.wrapper(glGetMaterialxvOES).setInputArraySize( + 'params', None +) +# INPUT glBitmapxOES.bitmap size not checked against 'width,height' +glBitmapxOES=wrapper.wrapper(glBitmapxOES).setInputArraySize( + 'bitmap', None +) +glColor3xvOES=wrapper.wrapper(glColor3xvOES).setInputArraySize( + 'components', 3 +) +glColor4xvOES=wrapper.wrapper(glColor4xvOES).setInputArraySize( + 'components', 4 +) +# INPUT glConvolutionParameterxvOES.params size not checked against 'pname' +glConvolutionParameterxvOES=wrapper.wrapper(glConvolutionParameterxvOES).setInputArraySize( + 'params', None +) +glEvalCoord1xvOES=wrapper.wrapper(glEvalCoord1xvOES).setInputArraySize( + 'coords', 1 +) +glEvalCoord2xvOES=wrapper.wrapper(glEvalCoord2xvOES).setInputArraySize( + 'coords', 2 +) +# INPUT glFeedbackBufferxOES.buffer size not checked against n +glFeedbackBufferxOES=wrapper.wrapper(glFeedbackBufferxOES).setInputArraySize( + 'buffer', None +) +glGetConvolutionParameterxvOES=wrapper.wrapper(glGetConvolutionParameterxvOES).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetHistogramParameterxvOES=wrapper.wrapper(glGetHistogramParameterxvOES).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetLightxOES=wrapper.wrapper(glGetLightxOES).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetMapxvOES=wrapper.wrapper(glGetMapxvOES).setOutput( + 'v',size=_glgets._glget_size_mapping,pnameArg='query',orPassIn=True +) +glGetPixelMapxv=wrapper.wrapper(glGetPixelMapxv).setOutput( + 'values',size=lambda x:(x,),pnameArg='size',orPassIn=True +) +glGetTexGenxvOES=wrapper.wrapper(glGetTexGenxvOES).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetTexLevelParameterxvOES=wrapper.wrapper(glGetTexLevelParameterxvOES).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glIndexxvOES=wrapper.wrapper(glIndexxvOES).setInputArraySize( + 'component', 1 +) +glLoadTransposeMatrixxOES=wrapper.wrapper(glLoadTransposeMatrixxOES).setInputArraySize( + 'm', 16 +) +glMultTransposeMatrixxOES=wrapper.wrapper(glMultTransposeMatrixxOES).setInputArraySize( + 'm', 16 +) +glMultiTexCoord1xvOES=wrapper.wrapper(glMultiTexCoord1xvOES).setInputArraySize( + 'coords', 1 +) +glMultiTexCoord2xvOES=wrapper.wrapper(glMultiTexCoord2xvOES).setInputArraySize( + 'coords', 2 +) +glMultiTexCoord3xvOES=wrapper.wrapper(glMultiTexCoord3xvOES).setInputArraySize( + 'coords', 3 +) +glMultiTexCoord4xvOES=wrapper.wrapper(glMultiTexCoord4xvOES).setInputArraySize( + 'coords', 4 +) +glNormal3xvOES=wrapper.wrapper(glNormal3xvOES).setInputArraySize( + 'coords', 3 +) +# INPUT glPixelMapx.values size not checked against size +glPixelMapx=wrapper.wrapper(glPixelMapx).setInputArraySize( + 'values', None +) +# INPUT glPrioritizeTexturesxOES.priorities size not checked against n +# INPUT glPrioritizeTexturesxOES.textures size not checked against n +glPrioritizeTexturesxOES=wrapper.wrapper(glPrioritizeTexturesxOES).setInputArraySize( + 'priorities', None +).setInputArraySize( + 'textures', None +) +glRasterPos2xvOES=wrapper.wrapper(glRasterPos2xvOES).setInputArraySize( + 'coords', 2 +) +glRasterPos3xvOES=wrapper.wrapper(glRasterPos3xvOES).setInputArraySize( + 'coords', 3 +) +glRasterPos4xvOES=wrapper.wrapper(glRasterPos4xvOES).setInputArraySize( + 'coords', 4 +) +glRectxvOES=wrapper.wrapper(glRectxvOES).setInputArraySize( + 'v1', 2 +).setInputArraySize( + 'v2', 2 +) +glTexCoord1xvOES=wrapper.wrapper(glTexCoord1xvOES).setInputArraySize( + 'coords', 1 +) +glTexCoord2xvOES=wrapper.wrapper(glTexCoord2xvOES).setInputArraySize( + 'coords', 2 +) +glTexCoord3xvOES=wrapper.wrapper(glTexCoord3xvOES).setInputArraySize( + 'coords', 3 +) +glTexCoord4xvOES=wrapper.wrapper(glTexCoord4xvOES).setInputArraySize( + 'coords', 4 +) +# INPUT glTexGenxvOES.params size not checked against 'pname' +glTexGenxvOES=wrapper.wrapper(glTexGenxvOES).setInputArraySize( + 'params', None +) +glVertex2xvOES=wrapper.wrapper(glVertex2xvOES).setInputArraySize( + 'coords', 2 +) +glVertex3xvOES=wrapper.wrapper(glVertex3xvOES).setInputArraySize( + 'coords', 3 +) +glVertex4xvOES=wrapper.wrapper(glVertex4xvOES).setInputArraySize( + 'coords', 4 +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/OES/query_matrix.py b/venv/lib/python3.12/site-packages/OpenGL/GL/OES/query_matrix.py new file mode 100644 index 00000000..281627a2 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/OES/query_matrix.py @@ -0,0 +1,40 @@ +'''OpenGL extension OES.query_matrix + +This module customises the behaviour of the +OpenGL.raw.GL.OES.query_matrix to provide a more +Python-friendly API + +Overview (from the spec) + + Many applications may need to query the contents and status of the + current matrix at least for debugging purposes, especially as the + implementations are allowed to implement matrix machinery either in + any (possibly proprietary) floating point format, or in a fixed point + format that has the range and accuracy of at least 16.16 (signed 16 bit + integer part, unsigned 16 bit fractional part). + + This extension is intended to allow application to query the components + of the matrix and also their status, regardless whether the internal + representation is in fixed point or floating point. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/OES/query_matrix.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.OES.query_matrix import * +from OpenGL.raw.GL.OES.query_matrix import _EXTENSION_NAME + +def glInitQueryMatrixOES(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +glQueryMatrixxOES=wrapper.wrapper(glQueryMatrixxOES).setOutput( + 'exponent',size=(16,),orPassIn=True +).setOutput( + 'mantissa',size=(16,),orPassIn=True +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/OES/read_format.py b/venv/lib/python3.12/site-packages/OpenGL/GL/OES/read_format.py new file mode 100644 index 00000000..f76d4ca5 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/OES/read_format.py @@ -0,0 +1,36 @@ +'''OpenGL extension OES.read_format + +This module customises the behaviour of the +OpenGL.raw.GL.OES.read_format to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides the capability to query an OpenGL + implementation for a preferred type and format combination + for use with reading the color buffer with the ReadPixels + command. The purpose is to enable embedded implementations + to support a greatly reduced set of type/format combinations + and provide a mechanism for applications to determine which + implementation-specific combination is supported. + + The preferred type and format combination returned may depend + on the read surface bound to the current GL context. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/OES/read_format.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.OES.read_format import * +from OpenGL.raw.GL.OES.read_format import _EXTENSION_NAME + +def glInitReadFormatOES(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/OES/single_precision.py b/venv/lib/python3.12/site-packages/OpenGL/GL/OES/single_precision.py new file mode 100644 index 00000000..574e2fed --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/OES/single_precision.py @@ -0,0 +1,37 @@ +'''OpenGL extension OES.single_precision + +This module customises the behaviour of the +OpenGL.raw.GL.OES.single_precision to provide a more +Python-friendly API + +Overview (from the spec) + + This extension adds commands with single-precision floating-point + parameters corresponding to the commands that only variants that + accept double-precision floating-point input. This allows an + application to avoid using double-precision floating-point + data types. New commands are added with an 'f' prefix. + + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/OES/single_precision.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.OES.single_precision import * +from OpenGL.raw.GL.OES.single_precision import _EXTENSION_NAME + +def glInitSinglePrecisionOES(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +glClipPlanefOES=wrapper.wrapper(glClipPlanefOES).setInputArraySize( + 'equation', 4 +) +glGetClipPlanefOES=wrapper.wrapper(glGetClipPlanefOES).setOutput( + 'equation',size=(4,),orPassIn=True +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/OML/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/GL/OML/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/OML/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/OML/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/OML/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..95bbef9d Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/OML/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/OML/__pycache__/interlace.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/OML/__pycache__/interlace.cpython-312.pyc new file mode 100644 index 00000000..fc40e5c7 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/OML/__pycache__/interlace.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/OML/__pycache__/resample.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/OML/__pycache__/resample.cpython-312.pyc new file mode 100644 index 00000000..e7a3de5c Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/OML/__pycache__/resample.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/OML/__pycache__/subsample.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/OML/__pycache__/subsample.cpython-312.pyc new file mode 100644 index 00000000..9f09c374 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/OML/__pycache__/subsample.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/OML/interlace.py b/venv/lib/python3.12/site-packages/OpenGL/GL/OML/interlace.py new file mode 100644 index 00000000..f071b1cf --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/OML/interlace.py @@ -0,0 +1,38 @@ +'''OpenGL extension OML.interlace + +This module customises the behaviour of the +OpenGL.raw.GL.OML.interlace to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides a way to interlace rows of pixels when + drawing, reading, or copying pixel rectangles or texture images. In + this context, interlacing means skiping over rows of pixels or + texels in the destination. This is useful for dealing with video + data since a single frame of video is typically composed from two + images or fields: one image specifying the data for even rows of the + frame and the other image specifying the data for odd rows of the + frame. + + The functionality provided by this extension is a combination + of the older SGIX_interlace and INGR_interlace_read extensions, + with changes applying interlacing to texture image queries. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/OML/interlace.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.OML.interlace import * +from OpenGL.raw.GL.OML.interlace import _EXTENSION_NAME + +def glInitInterlaceOML(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/OML/resample.py b/venv/lib/python3.12/site-packages/OpenGL/GL/OML/resample.py new file mode 100644 index 00000000..8bef7880 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/OML/resample.py @@ -0,0 +1,42 @@ +'''OpenGL extension OML.resample + +This module customises the behaviour of the +OpenGL.raw.GL.OML.resample to provide a more +Python-friendly API + +Overview (from the spec) + + This extension enhances the resampling capabilities of the + OML_subsample extension. It is loosely based on the SGIX_resample + extension. + + When converting data from subsampled to uniform sampling, upsampling + may be performed by one of three methods: component replication, + zero fill, or adjacent neighbor averaging. + + When converting data from uniform sampling to subsampled form, + downsampling may be performed only by component decimation (point + sampling) or averaging. + + Upsampling and downsampling filters other than those defined by this + extension may be performed by appropriate use of convolution and + other pixel transfer operations. The zero fill unpacking mode is + included to assist applications wanting to define their own filters. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/OML/resample.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.OML.resample import * +from OpenGL.raw.GL.OML.resample import _EXTENSION_NAME + +def glInitResampleOML(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/OML/subsample.py b/venv/lib/python3.12/site-packages/OpenGL/GL/OML/subsample.py new file mode 100644 index 00000000..940b5745 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/OML/subsample.py @@ -0,0 +1,53 @@ +'''OpenGL extension OML.subsample + +This module customises the behaviour of the +OpenGL.raw.GL.OML.subsample to provide a more +Python-friendly API + +Overview (from the spec) + + Many video image formats and compression techniques utilize various + component subsamplings, so it is necessary to provide a mechanism to + specify the up- and down-sampling of components as pixel data is + drawn from and read back to the client. Though subsampled components + are normally associated with the video color space, YCrCb, use of + subsampling in OpenGL does not imply a specific color space. Color + space conversion may be performed using other extensions or core + capabilities such as the color matrix. + + This extension defines two new pixel storage formats representing + subsampled data on the client. It is loosely based on the + SGIX_subsample extension, but specifies subsampling with the data + format parameter rather than pixel packing parameters. It also + adds support for CYA subsampled data. + + When pixel data is received from the client and an unpacking + upsampling mode other than PIXEL_SUBSAMPLE_NONE_OML is specified, + upsampling is performed via replication, unless otherwise specified + by UNPACK_RESAMPLE_OML. + + Similarly, when pixel data is read back to the client and a packing + downsampling mode other than PIXEL_SUBSAMPLE_NONE_OML is specified, + downsampling is performed via simple component decimation (point + sampling), unless otherwise specified by PACK_RESAMPLE_OML. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/OML/subsample.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.OML.subsample import * +from OpenGL.raw.GL.OML.subsample import _EXTENSION_NAME + +def glInitSubsampleOML(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION +from OpenGL import images as _i +_i.COMPONENT_COUNTS[ GL_FORMAT_SUBSAMPLE_24_24_OML ] = 1 # must be GL_UNSIGNED_INT_10_10_10_2 +_i.COMPONENT_COUNTS[ GL_FORMAT_SUBSAMPLE_244_244_OML ] = 1 # must be GL_UNSIGNED_INT_10_10_10_2 diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/OVR/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/GL/OVR/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/OVR/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/OVR/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/OVR/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..18baf7dd Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/OVR/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/OVR/__pycache__/multiview.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/OVR/__pycache__/multiview.cpython-312.pyc new file mode 100644 index 00000000..fc11189d Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/OVR/__pycache__/multiview.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/OVR/__pycache__/multiview2.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/OVR/__pycache__/multiview2.cpython-312.pyc new file mode 100644 index 00000000..dd326776 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/OVR/__pycache__/multiview2.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/OVR/multiview.py b/venv/lib/python3.12/site-packages/OpenGL/GL/OVR/multiview.py new file mode 100644 index 00000000..23c75406 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/OVR/multiview.py @@ -0,0 +1,56 @@ +'''OpenGL extension OVR.multiview + +This module customises the behaviour of the +OpenGL.raw.GL.OVR.multiview to provide a more +Python-friendly API + +Overview (from the spec) + + The method of stereo rendering supported in OpenGL is currently achieved by + rendering to the two eye buffers sequentially. This typically incurs double + the application and driver overhead, despite the fact that the command + streams and render states are almost identical. + + This extension seeks to address the inefficiency of sequential multiview + rendering by adding a means to render to multiple elements of a 2D texture + array simultaneously. In multiview rendering, draw calls are instanced into + each corresponding element of the texture array. The vertex program uses a + new gl_ViewID_OVR variable to compute per-view values, typically the vertex + position and view-dependent variables like reflection. + + The formulation of this extension is high level in order to allow + implementation freedom. On existing hardware, applications and drivers can + realize the benefits of a single scene traversal, even if all GPU work is + fully duplicated per-view. But future support could enable simultaneous + rendering via multi-GPU, tile-based architectures could sort geometry into + tiles for multiple views in a single pass, and the implementation could even + choose to interleave at the fragment level for better texture cache + utilization and more coherent fragment shader branching. + + The most obvious use case in this model is to support two simultaneous + views: one view for each eye. However, we also anticipate a usage where two + views are rendered per eye, where one has a wide field of view and the other + has a narrow one. The nature of wide field of view planar projection is + that the sample density can become unacceptably low in the view direction. + By rendering two inset eye views per eye, we can get the required sample + density in the center of projection without wasting samples, memory, and + time by oversampling in the periphery. + + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/OVR/multiview.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.OVR.multiview import * +from OpenGL.raw.GL.OVR.multiview import _EXTENSION_NAME + +def glInitMultiviewOVR(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/OVR/multiview2.py b/venv/lib/python3.12/site-packages/OpenGL/GL/OVR/multiview2.py new file mode 100644 index 00000000..ea5a2192 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/OVR/multiview2.py @@ -0,0 +1,30 @@ +'''OpenGL extension OVR.multiview2 + +This module customises the behaviour of the +OpenGL.raw.GL.OVR.multiview2 to provide a more +Python-friendly API + +Overview (from the spec) + + + This extension relaxes the restriction in OVR_multiview that only gl_Position + can depend on ViewID in the vertex shader. With this change, view-dependent + outputs like reflection vectors and similar are allowed. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/OVR/multiview2.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.OVR.multiview2 import * +from OpenGL.raw.GL.OVR.multiview2 import _EXTENSION_NAME + +def glInitMultiview2OVR(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/PGI/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/GL/PGI/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/PGI/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/PGI/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/PGI/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..0131824a Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/PGI/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/PGI/__pycache__/misc_hints.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/PGI/__pycache__/misc_hints.cpython-312.pyc new file mode 100644 index 00000000..70e2dc9c Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/PGI/__pycache__/misc_hints.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/PGI/__pycache__/vertex_hints.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/PGI/__pycache__/vertex_hints.cpython-312.pyc new file mode 100644 index 00000000..cd727360 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/PGI/__pycache__/vertex_hints.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/PGI/misc_hints.py b/venv/lib/python3.12/site-packages/OpenGL/GL/PGI/misc_hints.py new file mode 100644 index 00000000..b49f68ca --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/PGI/misc_hints.py @@ -0,0 +1,28 @@ +'''OpenGL extension PGI.misc_hints + +This module customises the behaviour of the +OpenGL.raw.GL.PGI.misc_hints to provide a more +Python-friendly API + +Overview (from the spec) + + The extension allows the app to give various hints regarding + desired level of conformance, performance, features, etc. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/PGI/misc_hints.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.PGI.misc_hints import * +from OpenGL.raw.GL.PGI.misc_hints import _EXTENSION_NAME + +def glInitMiscHintsPGI(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/PGI/vertex_hints.py b/venv/lib/python3.12/site-packages/OpenGL/GL/PGI/vertex_hints.py new file mode 100644 index 00000000..5aa17278 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/PGI/vertex_hints.py @@ -0,0 +1,28 @@ +'''OpenGL extension PGI.vertex_hints + +This module customises the behaviour of the +OpenGL.raw.GL.PGI.vertex_hints to provide a more +Python-friendly API + +Overview (from the spec) + + The extension allows the app to give hints regarding what kinds of + OpenGL function calls will happen between Begin/End pairs. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/PGI/vertex_hints.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.PGI.vertex_hints import * +from OpenGL.raw.GL.PGI.vertex_hints import _EXTENSION_NAME + +def glInitVertexHintsPGI(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/QCOM/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/GL/QCOM/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/QCOM/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/QCOM/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/QCOM/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..ca4d5991 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/QCOM/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/REND/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/GL/REND/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/REND/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/REND/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/REND/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..d49c7907 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/REND/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/REND/__pycache__/screen_coordinates.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/REND/__pycache__/screen_coordinates.cpython-312.pyc new file mode 100644 index 00000000..7ae228b8 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/REND/__pycache__/screen_coordinates.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/REND/screen_coordinates.py b/venv/lib/python3.12/site-packages/OpenGL/GL/REND/screen_coordinates.py new file mode 100644 index 00000000..5fafc750 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/REND/screen_coordinates.py @@ -0,0 +1,70 @@ +'''OpenGL extension REND.screen_coordinates + +This module customises the behaviour of the +OpenGL.raw.GL.REND.screen_coordinates to provide a more +Python-friendly API + +Overview (from the spec) + + This extension allows the specification of screen coordinate vertex + data. Screen coordinate vertices completely bypass transformation, + texture generation, lighting and frustum clipping. It also allow for + fewer floating point computations to the performed by OpenGL. + + If we get screen coordinate inputs then in order to perspectively + correct data (eg texture), the input data currently has to be + specified in one of the following manners + + 1. Specify all the data normally + eg. + glTexture2T(s, t); + and the coordinates as + glVertex4T(x*w, y*w, z*w, w); + or + 2. Divide each data by w + eg. + glTexture4T(s/w, t/w, r/w, q/w); + and the coordinates as + glVertex3T(x, y, z); + + Most hardware already performs some form of correction of the + coordinate data with respect to the w term prior to interpolation. + This is normally in the form of a multiplication of the terms by the + inverse w. It would be much more efficient to simply specify screen + coordinates as shown in the following example + glTexture2T(s, t, r, q); + and the coordinates as + glVertex4T(x, y, z, w); + and allow the hardware to bring the interpolated terms into a linear + screen space. + + Additionally if the application derives screen coordinates it is + also highly likely that the 1/w term may already be computed. So it + would be advantageous to be able to specify 1/w directly instead of + w in the input screen coordinates. + + For hardware that linearly interpolates data, the hardware + interpolates the following data: + s/w, t/w, r/w, q/w, x, y, z + If the input w represents the original 1/w, then the hardware can + avoid the division and instead interpolate: + s*w, t*w, r*w, q*w, x, y, z + + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/REND/screen_coordinates.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.REND.screen_coordinates import * +from OpenGL.raw.GL.REND.screen_coordinates import _EXTENSION_NAME + +def glInitScreenCoordinatesREND(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/S3/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/GL/S3/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/S3/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/S3/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/S3/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..a0ff4c7e Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/S3/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/S3/__pycache__/s3tc.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/S3/__pycache__/s3tc.cpython-312.pyc new file mode 100644 index 00000000..cbd1e93e Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/S3/__pycache__/s3tc.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/S3/s3tc.py b/venv/lib/python3.12/site-packages/OpenGL/GL/S3/s3tc.py new file mode 100644 index 00000000..acc28070 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/S3/s3tc.py @@ -0,0 +1,28 @@ +'''OpenGL extension S3.s3tc + +This module customises the behaviour of the +OpenGL.raw.GL.S3.s3tc to provide a more +Python-friendly API + +Overview (from the spec) + + This extension allows specifying texture data in compressed S3TC + format. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/S3/s3tc.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.S3.s3tc import * +from OpenGL.raw.GL.S3.s3tc import _EXTENSION_NAME + +def glInitS3TcS3(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/SGI/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/GL/SGI/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/SGI/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/SGI/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/SGI/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..bfb5b6a7 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/SGI/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/SGI/__pycache__/color_matrix.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/SGI/__pycache__/color_matrix.cpython-312.pyc new file mode 100644 index 00000000..7af9a444 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/SGI/__pycache__/color_matrix.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/SGI/__pycache__/color_table.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/SGI/__pycache__/color_table.cpython-312.pyc new file mode 100644 index 00000000..36e1323c Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/SGI/__pycache__/color_table.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/SGI/__pycache__/texture_color_table.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/SGI/__pycache__/texture_color_table.cpython-312.pyc new file mode 100644 index 00000000..18a7dfc4 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/SGI/__pycache__/texture_color_table.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/SGI/color_matrix.py b/venv/lib/python3.12/site-packages/OpenGL/GL/SGI/color_matrix.py new file mode 100644 index 00000000..13f61842 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/SGI/color_matrix.py @@ -0,0 +1,46 @@ +'''OpenGL extension SGI.color_matrix + +This module customises the behaviour of the +OpenGL.raw.GL.SGI.color_matrix to provide a more +Python-friendly API + +Overview (from the spec) + + This extension adds a 4x4 matrix stack to the pixel transfer path. The + matrix operates on RGBA pixel groups, using the equation + + C' = MC, + + where + + |R| + C = |G| + |B| + |A| + + and M is the 4x4 matrix on the top of the color matrix stack. After + the matrix multiplication, each resulting color component is scaled + and biased by a programmed amount. Color matrix multiplication follows + convolution (and the scale, and bias that are associated with + convolution.) + + The color matrix can be used to reassign and duplicate color components. + It can also be used to implement simple color space conversions. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/SGI/color_matrix.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.SGI.color_matrix import * +from OpenGL.raw.GL.SGI.color_matrix import _EXTENSION_NAME + +def glInitColorMatrixSGI(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/SGI/color_table.py b/venv/lib/python3.12/site-packages/OpenGL/GL/SGI/color_table.py new file mode 100644 index 00000000..ed3145e6 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/SGI/color_table.py @@ -0,0 +1,57 @@ +'''OpenGL extension SGI.color_table + +This module customises the behaviour of the +OpenGL.raw.GL.SGI.color_table to provide a more +Python-friendly API + +Overview (from the spec) + + This extension defines a new RGBA-format color lookup mechanism. It does + not replace the color lookups defined by the GL Specification, but rather + provides additional lookup capabilities with different operation. The key + difference is that the new lookup tables are treated as 1-dimensional images + with internal formats, like texture images and convolution filter images. + From this follows the fact that the new tables can operate on a subset of + the components of passing pixel groups. For example, a table with internal + format ALPHA modifies only the A component of each pixel group, leaving the + R, G, and B components unmodified. + + If EXT_copy_texture is implemented, this extension also defines methods to + initialize the color lookup tables from the framebuffer, in addition to the + standard memory source mechanisms. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/SGI/color_table.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.SGI.color_table import * +from OpenGL.raw.GL.SGI.color_table import _EXTENSION_NAME + +def glInitColorTableSGI(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glColorTableSGI.table size not checked against 'format,type,width' +glColorTableSGI=wrapper.wrapper(glColorTableSGI).setInputArraySize( + 'table', None +) +# INPUT glColorTableParameterfvSGI.params size not checked against 'pname' +glColorTableParameterfvSGI=wrapper.wrapper(glColorTableParameterfvSGI).setInputArraySize( + 'params', None +) +# INPUT glColorTableParameterivSGI.params size not checked against 'pname' +glColorTableParameterivSGI=wrapper.wrapper(glColorTableParameterivSGI).setInputArraySize( + 'params', None +) +# OUTPUT glGetColorTableSGI.table COMPSIZE(target, format, type) +glGetColorTableParameterfvSGI=wrapper.wrapper(glGetColorTableParameterfvSGI).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetColorTableParameterivSGI=wrapper.wrapper(glGetColorTableParameterivSGI).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/SGI/texture_color_table.py b/venv/lib/python3.12/site-packages/OpenGL/GL/SGI/texture_color_table.py new file mode 100644 index 00000000..a917dbe3 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/SGI/texture_color_table.py @@ -0,0 +1,41 @@ +'''OpenGL extension SGI.texture_color_table + +This module customises the behaviour of the +OpenGL.raw.GL.SGI.texture_color_table to provide a more +Python-friendly API + +Overview (from the spec) + + This extension adds a color lookup table to the texture mechanism. + The table is applied to the filtered result of a texture lookup, + before that result is used in the texture environment equations. + + The definition and application of the texture color table are + similar to those of the color tables defined in SGI_color_table, + though it is not necessary for that extension to be implemented. + + Texture color tables can be used to expand luminance or intensity + textures to full RGBA, and also to linearize the results of color + space conversions implemented by multidimensional texture table + lookup. + + This specification has been updated to define its interaction with + multitexture. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/SGI/texture_color_table.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.SGI.texture_color_table import * +from OpenGL.raw.GL.SGI.texture_color_table import _EXTENSION_NAME + +def glInitTextureColorTableSGI(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/SGIS/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIS/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIS/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/SGIS/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIS/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..50eec129 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIS/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/SGIS/__pycache__/detail_texture.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIS/__pycache__/detail_texture.cpython-312.pyc new file mode 100644 index 00000000..9c4ebe24 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIS/__pycache__/detail_texture.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/SGIS/__pycache__/fog_function.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIS/__pycache__/fog_function.cpython-312.pyc new file mode 100644 index 00000000..d1e8bb76 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIS/__pycache__/fog_function.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/SGIS/__pycache__/generate_mipmap.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIS/__pycache__/generate_mipmap.cpython-312.pyc new file mode 100644 index 00000000..6eaf5f6d Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIS/__pycache__/generate_mipmap.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/SGIS/__pycache__/multisample.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIS/__pycache__/multisample.cpython-312.pyc new file mode 100644 index 00000000..8329d62c Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIS/__pycache__/multisample.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/SGIS/__pycache__/pixel_texture.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIS/__pycache__/pixel_texture.cpython-312.pyc new file mode 100644 index 00000000..24c03eba Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIS/__pycache__/pixel_texture.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/SGIS/__pycache__/point_line_texgen.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIS/__pycache__/point_line_texgen.cpython-312.pyc new file mode 100644 index 00000000..b1398277 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIS/__pycache__/point_line_texgen.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/SGIS/__pycache__/point_parameters.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIS/__pycache__/point_parameters.cpython-312.pyc new file mode 100644 index 00000000..ab7cd93e Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIS/__pycache__/point_parameters.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/SGIS/__pycache__/sharpen_texture.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIS/__pycache__/sharpen_texture.cpython-312.pyc new file mode 100644 index 00000000..7ba394ed Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIS/__pycache__/sharpen_texture.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/SGIS/__pycache__/texture4D.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIS/__pycache__/texture4D.cpython-312.pyc new file mode 100644 index 00000000..07934445 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIS/__pycache__/texture4D.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/SGIS/__pycache__/texture_border_clamp.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIS/__pycache__/texture_border_clamp.cpython-312.pyc new file mode 100644 index 00000000..bf6a709c Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIS/__pycache__/texture_border_clamp.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/SGIS/__pycache__/texture_color_mask.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIS/__pycache__/texture_color_mask.cpython-312.pyc new file mode 100644 index 00000000..332d19b9 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIS/__pycache__/texture_color_mask.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/SGIS/__pycache__/texture_edge_clamp.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIS/__pycache__/texture_edge_clamp.cpython-312.pyc new file mode 100644 index 00000000..8755c14e Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIS/__pycache__/texture_edge_clamp.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/SGIS/__pycache__/texture_filter4.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIS/__pycache__/texture_filter4.cpython-312.pyc new file mode 100644 index 00000000..99122b08 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIS/__pycache__/texture_filter4.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/SGIS/__pycache__/texture_lod.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIS/__pycache__/texture_lod.cpython-312.pyc new file mode 100644 index 00000000..d9bdd660 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIS/__pycache__/texture_lod.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/SGIS/__pycache__/texture_select.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIS/__pycache__/texture_select.cpython-312.pyc new file mode 100644 index 00000000..e61933fb Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIS/__pycache__/texture_select.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/SGIS/detail_texture.py b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIS/detail_texture.py new file mode 100644 index 00000000..b8397458 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIS/detail_texture.py @@ -0,0 +1,44 @@ +'''OpenGL extension SGIS.detail_texture + +This module customises the behaviour of the +OpenGL.raw.GL.SGIS.detail_texture to provide a more +Python-friendly API + +Overview (from the spec) + + This extension introduces texture magnification filters that blend + between the level 0 image and a separately defined "detail" image. + The detail image represents the characteristics of the high frequency + subband image above the band-limited level 0 image. The detail image is + typically a rectangular portion of the subband image which is modified + so that it can be repeated without discontinuities along its edges. + Detail blending can be enabled for all color channels, for the alpha + channel only, or for the red, green, and blue channels only. It is + available only for 2D textures. + + WARNING - Silicon Graphics has filed for patent protection for some + of the techniques described in this extension document. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/SGIS/detail_texture.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.SGIS.detail_texture import * +from OpenGL.raw.GL.SGIS.detail_texture import _EXTENSION_NAME + +def glInitDetailTextureSGIS(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glDetailTexFuncSGIS.points size not checked against n*2 +glDetailTexFuncSGIS=wrapper.wrapper(glDetailTexFuncSGIS).setInputArraySize( + 'points', None +) +glGetDetailTexFuncSGIS=wrapper.wrapper(glGetDetailTexFuncSGIS).setOutput( + 'points',size=_glgets._glget_size_mapping,pnameArg='target',orPassIn=True +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/SGIS/fog_function.py b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIS/fog_function.py new file mode 100644 index 00000000..96d76b55 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIS/fog_function.py @@ -0,0 +1,39 @@ +'''OpenGL extension SGIS.fog_function + +This module customises the behaviour of the +OpenGL.raw.GL.SGIS.fog_function to provide a more +Python-friendly API + +Overview (from the spec) + + This extension allows to define application-specific fog blend-factor + function. Function is defined by the set of the "control" points and + should be monotonic. Each control point represented as a pair of the + eye-space distance value and corresponding value of the fog blending + factor. The minimum number of control points is one. The maximum + number is implementation dependent. + + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/SGIS/fog_function.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.SGIS.fog_function import * +from OpenGL.raw.GL.SGIS.fog_function import _EXTENSION_NAME + +def glInitFogFunctionSGIS(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glFogFuncSGIS.points size not checked against n*2 +glFogFuncSGIS=wrapper.wrapper(glFogFuncSGIS).setInputArraySize( + 'points', None +) +glGetFogFuncSGIS=wrapper.wrapper(glGetFogFuncSGIS).setOutput( + 'points',size=_glgets._glget_size_mapping,pnameArg='',orPassIn=True +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/SGIS/generate_mipmap.py b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIS/generate_mipmap.py new file mode 100644 index 00000000..f3bf051a --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIS/generate_mipmap.py @@ -0,0 +1,30 @@ +'''OpenGL extension SGIS.generate_mipmap + +This module customises the behaviour of the +OpenGL.raw.GL.SGIS.generate_mipmap to provide a more +Python-friendly API + +Overview (from the spec) + + This extension defines a mechanism by which OpenGL can derive the + entire set of mipmap arrays when provided with only the base level + array. Automatic mipmap generation is particularly useful when + texture images are being provided as a video stream. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/SGIS/generate_mipmap.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.SGIS.generate_mipmap import * +from OpenGL.raw.GL.SGIS.generate_mipmap import _EXTENSION_NAME + +def glInitGenerateMipmapSGIS(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/SGIS/multisample.py b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIS/multisample.py new file mode 100644 index 00000000..aa1e2b60 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIS/multisample.py @@ -0,0 +1,51 @@ +'''OpenGL extension SGIS.multisample + +This module customises the behaviour of the +OpenGL.raw.GL.SGIS.multisample to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides a mechanism to antialias all GL primitives: + points, lines, polygons, bitmaps, and images. The technique is to + sample all primitives multiple times at each pixel. The color sample + values are resolved to a single, displayable color each time a pixel + is updated, so the antialiasing appears to be automatic at the + application level. Because each sample includes depth and stencil + information, the depth and stencil functions perform equivalently + to the single-sample mode. + + An additional buffer, called the multisample buffer, is added to + the framebuffer. Pixel sample values, including color, depth, and + stencil values, are stored in this buffer. When the framebuffer + includes a multisample buffer, it does not also include separate + depth or stencil buffers, even if the multisample buffer does not + store depth or stencil values. Color buffers (left/right, front/ + back, and aux) do coexist with the multisample buffer, however. + + Multisample antialiasing is most valuable for rendering polygons, + because it requires no sorting for hidden surface elimination, and + it correctly handles adjacent polygons, object silhouettes, and + even intersecting polygons. If only points or lines are being + rendered, the "smooth" antialiasing mechanism provided by the base + GL may result in a higher quality image. This extension is designed + to allow multisample and smooth antialiasing techniques to be + alternated during the rendering of a single scene. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/SGIS/multisample.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.SGIS.multisample import * +from OpenGL.raw.GL.SGIS.multisample import _EXTENSION_NAME + +def glInitMultisampleSGIS(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/SGIS/pixel_texture.py b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIS/pixel_texture.py new file mode 100644 index 00000000..4b84d82e --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIS/pixel_texture.py @@ -0,0 +1,81 @@ +'''OpenGL extension SGIS.pixel_texture + +This module customises the behaviour of the +OpenGL.raw.GL.SGIS.pixel_texture to provide a more +Python-friendly API + +Overview (from the spec) + + The geometry rasterization and pixel pipeline "convert to fragment" + stages each produce fragments. The fragments are processed by + a unified per fragment pipeline that begins with the application + of the texture to the fragment color. Because the pixel pipeline + shares the per fragment processing with the geometry pipeline, the + fragments produced by the pixel pipeline must have the same fields + as the ones produced by the geometry pipeline. When + pixel groups are being converted to fragments, the parts + of the fragment that aren't derived from the pixel groups + are taken from the associated values in the current raster position. + + A fragment consists of x and y window coordinates and their + associated color value, depth value, and texture coordinates. + In the 1.1 OpenGL specification, when the pixel group is RGBA + the fragment color is always derived from the pixel group, + and the depth value and texture coordinates always come + from the raster position. + + This extension provides a way to specify how the texture coordinates + of the fragments can be derived from RGBA pixel groups. When + this option is enabled, the source of the fragment color value + when the pixel group is RGBA can be specified to come from either + the raster position or the pixel group. + + Deriving the fragment texture coordinates from the pixel group + effectively converts a color image into a texture coordinate image. + The multidimensional texture mapping lookup logic also makes this + extension useful for implementing multidimensional color lookups. + Multidimensional color lookups can be used to implement very + accurate color space conversions. + + Deriving texture coordinates from the pixel groups in the pixel + pipeline introduces a problem with the lambda parameter in the + texture mapping equations. When texture coordinates are + being taken from the current raster position texture coordinates, + the texture coordinate values don't change from pixel to pixel, + and the equation for calculating lambda always produces zero. + Enabling pixel_texture introduces changes in the texture + coordinates from pixel to pixel which are not necessarily + meaningful for texture lookups. This problem is addressed + by specifying that lambda is always set to zero when pixel_texture + is enabled. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/SGIS/pixel_texture.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.SGIS.pixel_texture import * +from OpenGL.raw.GL.SGIS.pixel_texture import _EXTENSION_NAME + +def glInitPixelTextureSGIS(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glPixelTexGenParameterivSGIS.params size not checked against 'pname' +glPixelTexGenParameterivSGIS=wrapper.wrapper(glPixelTexGenParameterivSGIS).setInputArraySize( + 'params', None +) +# INPUT glPixelTexGenParameterfvSGIS.params size not checked against 'pname' +glPixelTexGenParameterfvSGIS=wrapper.wrapper(glPixelTexGenParameterfvSGIS).setInputArraySize( + 'params', None +) +glGetPixelTexGenParameterivSGIS=wrapper.wrapper(glGetPixelTexGenParameterivSGIS).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetPixelTexGenParameterfvSGIS=wrapper.wrapper(glGetPixelTexGenParameterfvSGIS).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/SGIS/point_line_texgen.py b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIS/point_line_texgen.py new file mode 100644 index 00000000..1b9b4e3d --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIS/point_line_texgen.py @@ -0,0 +1,29 @@ +'''OpenGL extension SGIS.point_line_texgen + +This module customises the behaviour of the +OpenGL.raw.GL.SGIS.point_line_texgen to provide a more +Python-friendly API + +Overview (from the spec) + + This extension adds two texture coordinate generation modes, both + which generate a texture coordinate based on the minimum distance + from a vertex to a specified line. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/SGIS/point_line_texgen.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.SGIS.point_line_texgen import * +from OpenGL.raw.GL.SGIS.point_line_texgen import _EXTENSION_NAME + +def glInitPointLineTexgenSGIS(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/SGIS/point_parameters.py b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIS/point_parameters.py new file mode 100644 index 00000000..503c5c0b --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIS/point_parameters.py @@ -0,0 +1,26 @@ +'''OpenGL extension SGIS.point_parameters + +This module customises the behaviour of the +OpenGL.raw.GL.SGIS.point_parameters to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/SGIS/point_parameters.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.SGIS.point_parameters import * +from OpenGL.raw.GL.SGIS.point_parameters import _EXTENSION_NAME + +def glInitPointParametersSGIS(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glPointParameterfvSGIS.params size not checked against 'pname' +glPointParameterfvSGIS=wrapper.wrapper(glPointParameterfvSGIS).setInputArraySize( + 'params', None +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/SGIS/sharpen_texture.py b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIS/sharpen_texture.py new file mode 100644 index 00000000..365529b1 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIS/sharpen_texture.py @@ -0,0 +1,36 @@ +'''OpenGL extension SGIS.sharpen_texture + +This module customises the behaviour of the +OpenGL.raw.GL.SGIS.sharpen_texture to provide a more +Python-friendly API + +Overview (from the spec) + + This extension introduces texture magnification filters that sharpen + the resulting image by extrapolating from the level 1 image to the + level 0 image. Sharpening can be enabled for all color channels, for + the alpha channel only, or for the red, green, and blue channels only. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/SGIS/sharpen_texture.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.SGIS.sharpen_texture import * +from OpenGL.raw.GL.SGIS.sharpen_texture import _EXTENSION_NAME + +def glInitSharpenTextureSGIS(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glSharpenTexFuncSGIS.points size not checked against n*2 +glSharpenTexFuncSGIS=wrapper.wrapper(glSharpenTexFuncSGIS).setInputArraySize( + 'points', None +) +glGetSharpenTexFuncSGIS=wrapper.wrapper(glGetSharpenTexFuncSGIS).setOutput( + 'points',size=_glgets._glget_size_mapping,pnameArg='target',orPassIn=True +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/SGIS/texture4D.py b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIS/texture4D.py new file mode 100644 index 00000000..0f201095 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIS/texture4D.py @@ -0,0 +1,58 @@ +'''OpenGL extension SGIS.texture4D + +This module customises the behaviour of the +OpenGL.raw.GL.SGIS.texture4D to provide a more +Python-friendly API + +Overview (from the spec) + + This extension defines 4-dimensional texture mapping. If EXT_subtexture + is supported, this extension also defines a mechanism to redefine a + portion of an existing 4-dimensional texture image. Because + EXT_texture3D is required, this extension utilizes the 3-dimensional + image support defined in by EXT_texture3D as a base for 4-dimensional + image manipulation. + + The 4th dimension has an abstract, rather than physical, reference + and will be called "extent", since the definition of extent is "that which + specifies the range or magnitude of an area or volume." + + Four-dimensional texture mapping is more constrained than its one, two, + and three-dimensional counterparts. Mipmapping is not supported, so + only the level-zero 4-dimensional texture image can be defined. Cubic + filtering is not supported, so the border width must be either zero or + one. + + Four-dimensional textures are used primarily as color lookup tables for + color conversion. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/SGIS/texture4D.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.SGIS.texture4D import * +from OpenGL.raw.GL.SGIS.texture4D import _EXTENSION_NAME + +def glInitTexture4DSGIS(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glTexImage4DSGIS.pixels size not checked against 'format,type,width,height,depth,size4d' +glTexImage4DSGIS=wrapper.wrapper(glTexImage4DSGIS).setInputArraySize( + 'pixels', None +) +# INPUT glTexSubImage4DSGIS.pixels size not checked against 'format,type,width,height,depth,size4d' +glTexSubImage4DSGIS=wrapper.wrapper(glTexSubImage4DSGIS).setInputArraySize( + 'pixels', None +) +### END AUTOGENERATED SECTION + +from OpenGL.GL import images as _i +_i.images.RANK_PACKINGS.setdefault(4,[]).extend([ + (_i.GL_1_1.glPixelStorei,GL_PACK_SKIP_VOLUMES_SGIS, 0), + (_i.GL_1_1.glPixelStorei,GL_PACK_IMAGE_DEPTH_SGIS, 0), +]) diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/SGIS/texture_border_clamp.py b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIS/texture_border_clamp.py new file mode 100644 index 00000000..ce0b4418 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIS/texture_border_clamp.py @@ -0,0 +1,40 @@ +'''OpenGL extension SGIS.texture_border_clamp + +This module customises the behaviour of the +OpenGL.raw.GL.SGIS.texture_border_clamp to provide a more +Python-friendly API + +Overview (from the spec) + + The base OpenGL provides clamping such that the texture coordinates are + limited to exactly the range [0,1]. When a texture coordinate is + clamped using this algorithm, the texture sampling filter straddles the + edge of the texture image, taking 1/2 its sample values from within the + texture image, and the other 1/2 from the texture border. It is + sometimes desirable for a texture to be clamped to the border color, + rather than to an average of the border and edge colors. + + This extension defines an additional texture clamping algorithm. + CLAMP_TO_BORDER_SGIS clamps texture coordinates at all mipmap levels + such that NEAREST and LINEAR filters return the color of the border + texels. When used with FILTER4 filters, the filter operation of + CLAMP_TO_BORDER_SGIS is defined but doesn't result in a nice + clamp-to-border color. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/SGIS/texture_border_clamp.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.SGIS.texture_border_clamp import * +from OpenGL.raw.GL.SGIS.texture_border_clamp import _EXTENSION_NAME + +def glInitTextureBorderClampSGIS(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/SGIS/texture_color_mask.py b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIS/texture_color_mask.py new file mode 100644 index 00000000..4f558f3e --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIS/texture_color_mask.py @@ -0,0 +1,36 @@ +'''OpenGL extension SGIS.texture_color_mask + +This module customises the behaviour of the +OpenGL.raw.GL.SGIS.texture_color_mask to provide a more +Python-friendly API + +Overview (from the spec) + + This extension implements the same functionality for texture + updates that glColorMask implements for color buffer updates. + Masks for updating textures with indexed internal formats + (the analog for glIndexMask) should be supported by a separate extension. + + The extension allows an application to update a subset of + components in an existing texture. The masks are applied after + all pixel transfer operations have been performed, immediately + prior to writing the texel value into texture memory. They + apply to all texture updates. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/SGIS/texture_color_mask.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.SGIS.texture_color_mask import * +from OpenGL.raw.GL.SGIS.texture_color_mask import _EXTENSION_NAME + +def glInitTextureColorMaskSGIS(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/SGIS/texture_edge_clamp.py b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIS/texture_edge_clamp.py new file mode 100644 index 00000000..85c494e1 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIS/texture_edge_clamp.py @@ -0,0 +1,44 @@ +'''OpenGL extension SGIS.texture_edge_clamp + +This module customises the behaviour of the +OpenGL.raw.GL.SGIS.texture_edge_clamp to provide a more +Python-friendly API + +Overview (from the spec) + + The base OpenGL provides clamping such that the texture coordinates are + limited to exactly the range [0,1]. When a texture coordinate is + clamped using this algorithm, the texture sampling filter straddles the + edge of the texture image, taking 1/2 its sample values from within the + texture image, and the other 1/2 from the texture border. It is + sometimes desirable to clamp a texture without requiring a border, and + without using the constant border color. + + This extension defines a new texture clamping algorithm. + CLAMP_TO_EDGE_SGIS clamps texture coordinates at all mipmap levels such + that the texture filter never samples a border texel. When used with a + NEAREST or a LINEAR filter, the color returned when clamping is derived + only from texels at the edge of the texture image. When used with + FILTER4 filters, the filter operations of CLAMP_TO_EDGE_SGIS are defined + but don't result in a nice clamp-to-edge color. + + CLAMP_TO_EDGE_SGIS is supported by 1, 2, and 3-dimensional textures + only. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/SGIS/texture_edge_clamp.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.SGIS.texture_edge_clamp import * +from OpenGL.raw.GL.SGIS.texture_edge_clamp import _EXTENSION_NAME + +def glInitTextureEdgeClampSGIS(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/SGIS/texture_filter4.py b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIS/texture_filter4.py new file mode 100644 index 00000000..8a6479d2 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIS/texture_filter4.py @@ -0,0 +1,36 @@ +'''OpenGL extension SGIS.texture_filter4 + +This module customises the behaviour of the +OpenGL.raw.GL.SGIS.texture_filter4 to provide a more +Python-friendly API + +Overview (from the spec) + + This extension allows 1D and 2D textures to be filtered using an + application-defined, four sample per dimension filter. (In addition to + the NEAREST and LINEAR filters defined in the original GL Specification.) + Such filtering results in higher image quality. It is defined only + for non-mipmapped filters. The filter that is specified must be + symmetric and separable (in the 2D case). + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/SGIS/texture_filter4.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.SGIS.texture_filter4 import * +from OpenGL.raw.GL.SGIS.texture_filter4 import _EXTENSION_NAME + +def glInitTextureFilter4SGIS(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# OUTPUT glGetTexFilterFuncSGIS.weights COMPSIZE(target, filter) +# INPUT glTexFilterFuncSGIS.weights size not checked against n +glTexFilterFuncSGIS=wrapper.wrapper(glTexFilterFuncSGIS).setInputArraySize( + 'weights', None +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/SGIS/texture_lod.py b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIS/texture_lod.py new file mode 100644 index 00000000..589d679c --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIS/texture_lod.py @@ -0,0 +1,47 @@ +'''OpenGL extension SGIS.texture_lod + +This module customises the behaviour of the +OpenGL.raw.GL.SGIS.texture_lod to provide a more +Python-friendly API + +Overview (from the spec) + + This extension imposes two constraints related to the texture level of + detail parameter LOD, which is represented by the Greek character lambda + in the GL Specification. One constraint clamps LOD to a specified + floating point range. The other limits the selection of mipmap image + arrays to a subset of the arrays that would otherwise be considered. + + Together these constraints allow a large texture to be loaded and + used initially at low resolution, and to have its resolution raised + gradually as more resolution is desired or available. Image array + specification is necessarily integral, rather than continuous. By + providing separate, continuous clamping of the LOD parameter, it is + possible to avoid "popping" artifacts when higher resolution images + are provided. + + Note: because the shape of the mipmap array is always determined by + the dimensions of the level 0 array, this array must be loaded for + mipmapping to be active. If the level 0 array is specified with a + null image pointer, however, no actual data transfer will take + place. And a sufficiently tuned implementation might not even + allocate space for a level 0 array so specified until true image + data were presented. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/SGIS/texture_lod.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.SGIS.texture_lod import * +from OpenGL.raw.GL.SGIS.texture_lod import _EXTENSION_NAME + +def glInitTextureLodSGIS(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/SGIS/texture_select.py b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIS/texture_select.py new file mode 100644 index 00000000..57904fa4 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIS/texture_select.py @@ -0,0 +1,44 @@ +'''OpenGL extension SGIS.texture_select + +This module customises the behaviour of the +OpenGL.raw.GL.SGIS.texture_select to provide a more +Python-friendly API + +Overview (from the spec) + + This extension introduces several new texture internal formats. The + purpose of these new formats is to reorganize the components of a + texture into groups of components. The currently selected group + effectively becomes the internal format. + + Also, two new texture parameters are introduced that control the + selection of these groups of components. + + For example, assume a texture internal format of DUAL_LUMINANCE4_SGIS is + specified. Now there are two groups of components, where each group has + a format of LUMINANCE4. One of the two LUMINANCE groups is always + selected. components can be selected and then interpreted as a LUMINANCE + texture. + + The purpose of this extension is allow better utilization of texture + memory by subdividing the internal representation of a texel into 1, 2, + or 4 smaller texels. Additionally, this may improve performance of + texture downloads. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/SGIS/texture_select.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.SGIS.texture_select import * +from OpenGL.raw.GL.SGIS.texture_select import _EXTENSION_NAME + +def glInitTextureSelectSGIS(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..062d477d Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/__pycache__/async_.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/__pycache__/async_.cpython-312.pyc new file mode 100644 index 00000000..b897b71a Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/__pycache__/async_.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/__pycache__/async_histogram.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/__pycache__/async_histogram.cpython-312.pyc new file mode 100644 index 00000000..73afadfb Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/__pycache__/async_histogram.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/__pycache__/async_pixel.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/__pycache__/async_pixel.cpython-312.pyc new file mode 100644 index 00000000..74f3c228 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/__pycache__/async_pixel.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/__pycache__/blend_alpha_minmax.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/__pycache__/blend_alpha_minmax.cpython-312.pyc new file mode 100644 index 00000000..d492d3d1 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/__pycache__/blend_alpha_minmax.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/__pycache__/calligraphic_fragment.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/__pycache__/calligraphic_fragment.cpython-312.pyc new file mode 100644 index 00000000..86799854 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/__pycache__/calligraphic_fragment.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/__pycache__/clipmap.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/__pycache__/clipmap.cpython-312.pyc new file mode 100644 index 00000000..48383a2d Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/__pycache__/clipmap.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/__pycache__/convolution_accuracy.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/__pycache__/convolution_accuracy.cpython-312.pyc new file mode 100644 index 00000000..f0c9d092 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/__pycache__/convolution_accuracy.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/__pycache__/depth_pass_instrument.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/__pycache__/depth_pass_instrument.cpython-312.pyc new file mode 100644 index 00000000..102f839c Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/__pycache__/depth_pass_instrument.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/__pycache__/depth_texture.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/__pycache__/depth_texture.cpython-312.pyc new file mode 100644 index 00000000..7c16c4af Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/__pycache__/depth_texture.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/__pycache__/flush_raster.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/__pycache__/flush_raster.cpython-312.pyc new file mode 100644 index 00000000..c9e88f04 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/__pycache__/flush_raster.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/__pycache__/fog_offset.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/__pycache__/fog_offset.cpython-312.pyc new file mode 100644 index 00000000..606fcd71 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/__pycache__/fog_offset.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/__pycache__/fragment_lighting.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/__pycache__/fragment_lighting.cpython-312.pyc new file mode 100644 index 00000000..52711b91 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/__pycache__/fragment_lighting.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/__pycache__/framezoom.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/__pycache__/framezoom.cpython-312.pyc new file mode 100644 index 00000000..70539aeb Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/__pycache__/framezoom.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/__pycache__/igloo_interface.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/__pycache__/igloo_interface.cpython-312.pyc new file mode 100644 index 00000000..ba14bad6 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/__pycache__/igloo_interface.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/__pycache__/instruments.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/__pycache__/instruments.cpython-312.pyc new file mode 100644 index 00000000..14f1fd01 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/__pycache__/instruments.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/__pycache__/interlace.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/__pycache__/interlace.cpython-312.pyc new file mode 100644 index 00000000..f4464240 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/__pycache__/interlace.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/__pycache__/ir_instrument1.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/__pycache__/ir_instrument1.cpython-312.pyc new file mode 100644 index 00000000..696c58a7 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/__pycache__/ir_instrument1.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/__pycache__/list_priority.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/__pycache__/list_priority.cpython-312.pyc new file mode 100644 index 00000000..c63d5442 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/__pycache__/list_priority.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/__pycache__/pixel_texture.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/__pycache__/pixel_texture.cpython-312.pyc new file mode 100644 index 00000000..7c5dd05a Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/__pycache__/pixel_texture.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/__pycache__/pixel_tiles.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/__pycache__/pixel_tiles.cpython-312.pyc new file mode 100644 index 00000000..73de83ef Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/__pycache__/pixel_tiles.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/__pycache__/polynomial_ffd.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/__pycache__/polynomial_ffd.cpython-312.pyc new file mode 100644 index 00000000..55fc9292 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/__pycache__/polynomial_ffd.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/__pycache__/reference_plane.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/__pycache__/reference_plane.cpython-312.pyc new file mode 100644 index 00000000..01827385 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/__pycache__/reference_plane.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/__pycache__/resample.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/__pycache__/resample.cpython-312.pyc new file mode 100644 index 00000000..8b0a183d Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/__pycache__/resample.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/__pycache__/scalebias_hint.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/__pycache__/scalebias_hint.cpython-312.pyc new file mode 100644 index 00000000..dd76ae70 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/__pycache__/scalebias_hint.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/__pycache__/shadow.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/__pycache__/shadow.cpython-312.pyc new file mode 100644 index 00000000..07ed2597 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/__pycache__/shadow.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/__pycache__/shadow_ambient.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/__pycache__/shadow_ambient.cpython-312.pyc new file mode 100644 index 00000000..90fdc783 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/__pycache__/shadow_ambient.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/__pycache__/sprite.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/__pycache__/sprite.cpython-312.pyc new file mode 100644 index 00000000..ad4fff08 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/__pycache__/sprite.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/__pycache__/subsample.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/__pycache__/subsample.cpython-312.pyc new file mode 100644 index 00000000..e6906d8d Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/__pycache__/subsample.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/__pycache__/tag_sample_buffer.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/__pycache__/tag_sample_buffer.cpython-312.pyc new file mode 100644 index 00000000..4ae775f4 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/__pycache__/tag_sample_buffer.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/__pycache__/texture_add_env.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/__pycache__/texture_add_env.cpython-312.pyc new file mode 100644 index 00000000..fa8d9360 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/__pycache__/texture_add_env.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/__pycache__/texture_coordinate_clamp.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/__pycache__/texture_coordinate_clamp.cpython-312.pyc new file mode 100644 index 00000000..4b34b173 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/__pycache__/texture_coordinate_clamp.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/__pycache__/texture_lod_bias.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/__pycache__/texture_lod_bias.cpython-312.pyc new file mode 100644 index 00000000..6de09f32 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/__pycache__/texture_lod_bias.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/__pycache__/texture_multi_buffer.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/__pycache__/texture_multi_buffer.cpython-312.pyc new file mode 100644 index 00000000..8fdbab98 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/__pycache__/texture_multi_buffer.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/__pycache__/texture_scale_bias.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/__pycache__/texture_scale_bias.cpython-312.pyc new file mode 100644 index 00000000..148c78d7 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/__pycache__/texture_scale_bias.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/__pycache__/vertex_preclip.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/__pycache__/vertex_preclip.cpython-312.pyc new file mode 100644 index 00000000..e6d8d2d9 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/__pycache__/vertex_preclip.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/__pycache__/ycrcb.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/__pycache__/ycrcb.cpython-312.pyc new file mode 100644 index 00000000..f5ab6d21 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/__pycache__/ycrcb.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/__pycache__/ycrcb_subsample.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/__pycache__/ycrcb_subsample.cpython-312.pyc new file mode 100644 index 00000000..831d7015 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/__pycache__/ycrcb_subsample.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/__pycache__/ycrcba.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/__pycache__/ycrcba.cpython-312.pyc new file mode 100644 index 00000000..6d88d09e Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/__pycache__/ycrcba.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/async_.py b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/async_.py new file mode 100644 index 00000000..30b7a483 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/async_.py @@ -0,0 +1,72 @@ +'''OpenGL extension SGIX.async_ + +This module customises the behaviour of the +OpenGL.raw.GL.SGIX.async_ to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides a framework for asynchronous OpenGL + commands. It also provides commands allowing a program to wait + for the completion of asynchronous commands. + + Asynchronous commands have two properties: + + 1) Asynchronous commands are non-blocking. For example, an + asynchronous ReadPixels command returns control to the program + immediately rather than blocking until the command completes. + This property allows the program to issue other OpenGL commands in + parallel with the execution of commands that normally block. + + 2) Asynchronous commands may complete out-of-order with respect to + other OpenGL commands. For example, an asynchronous TexImage + command may complete after subsequent OpenGL commands issued by + the program rather than maintaining the normal serial order of the + OpenGL command stream. This property allows the graphics + accelerator to execute asynchronous commands in parallel with the + normal command stream, for instance using a secondary path to + transfer data from or to the host, without doing any dependency + checking. + + Programs that issue asynchronous commands must also be able to + determine when the commands have completed. The completion status + may be needed so that results can be retrieved (e.g. the image + data from a ReadPixels command) or so that dependent commands can + be issued (e.g. drawing commands that use texture data downloaded + by an earlier asynchronous command). This extension provides + fine-grain control over asynchronous commands by introducing a + mechanism for determining the status of individual commands. + + Each invocation of an asynchronous command is associated with an + integer called a "marker." A program specifies a marker before it + issues an asynchronous command. The program may later issue a + command to query if any asynchronous commands have completed. The + query commands return a marker to identify the command that + completed. This extension provides both blocking and non-blocking + query commands. + + This extension does not define any asynchronous commands. + See SGIX_async_pixel for the asynchronous pixel commands. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/SGIX/async_.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.SGIX.async_ import * +from OpenGL.raw.GL.SGIX.async_ import _EXTENSION_NAME + +def glInitAsyncSGIX(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +glFinishAsyncSGIX=wrapper.wrapper(glFinishAsyncSGIX).setOutput( + 'markerp',size=(1,),orPassIn=True +) +glPollAsyncSGIX=wrapper.wrapper(glPollAsyncSGIX).setOutput( + 'markerp',size=(1,),orPassIn=True +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/async_histogram.py b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/async_histogram.py new file mode 100644 index 00000000..53063a4e --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/async_histogram.py @@ -0,0 +1,30 @@ +'''OpenGL extension SGIX.async_histogram + +This module customises the behaviour of the +OpenGL.raw.GL.SGIX.async_histogram to provide a more +Python-friendly API + +Overview (from the spec) + + This extension introduces a new asynchronous mode for histogram + and minmax readbacks. It allows programs to get the contents of a + histogram or minmax table without blocking and to continue issuing + graphics commands during the readback. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/SGIX/async_histogram.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.SGIX.async_histogram import * +from OpenGL.raw.GL.SGIX.async_histogram import _EXTENSION_NAME + +def glInitAsyncHistogramSGIX(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/async_pixel.py b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/async_pixel.py new file mode 100644 index 00000000..9517e394 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/async_pixel.py @@ -0,0 +1,35 @@ +'''OpenGL extension SGIX.async_pixel + +This module customises the behaviour of the +OpenGL.raw.GL.SGIX.async_pixel to provide a more +Python-friendly API + +Overview (from the spec) + + This extension introduces a new asynchronous mode for texture + download, pixel download and pixel readback commands. It allows + programs to transfer textures or images between the host and the + graphics accelerator in parallel with the execution of other + graphics commands (possibly taking advantage of a secondary path + to the graphics accelerator). It also allows programs to issue + non-blocking pixel readback commands that return immediately after + they are issued so that the program can issue other commands while + the readback takes place. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/SGIX/async_pixel.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.SGIX.async_pixel import * +from OpenGL.raw.GL.SGIX.async_pixel import _EXTENSION_NAME + +def glInitAsyncPixelSGIX(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/blend_alpha_minmax.py b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/blend_alpha_minmax.py new file mode 100644 index 00000000..0f026351 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/blend_alpha_minmax.py @@ -0,0 +1,32 @@ +'''OpenGL extension SGIX.blend_alpha_minmax + +This module customises the behaviour of the +OpenGL.raw.GL.SGIX.blend_alpha_minmax to provide a more +Python-friendly API + +Overview (from the spec) + + Two additional blending equations are specified using the interface + defined by EXT_blend_minmax. These equations are similar to the + MIN_EXT and MAX_EXT blending equations, but the outcome for all four + color components is determined by a comparison of just the alpha + component's source and destination values. These equations are useful + in image processing and advanced shading algorithms. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/SGIX/blend_alpha_minmax.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.SGIX.blend_alpha_minmax import * +from OpenGL.raw.GL.SGIX.blend_alpha_minmax import _EXTENSION_NAME + +def glInitBlendAlphaMinmaxSGIX(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/calligraphic_fragment.py b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/calligraphic_fragment.py new file mode 100644 index 00000000..b0566c41 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/calligraphic_fragment.py @@ -0,0 +1,32 @@ +'''OpenGL extension SGIX.calligraphic_fragment + +This module customises the behaviour of the +OpenGL.raw.GL.SGIX.calligraphic_fragment to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides a minimal mechanism to control the copying of + fragment information to external hardware such as a calligraphic + display interface. The initial implementation is intended to support + the calligraphic interface on InfiniteReality. On InfiniteReality + when the interface is enabled, fragment information consisting of + some color and coverage data is sent to the interface. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/SGIX/calligraphic_fragment.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.SGIX.calligraphic_fragment import * +from OpenGL.raw.GL.SGIX.calligraphic_fragment import _EXTENSION_NAME + +def glInitCalligraphicFragmentSGIX(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/clipmap.py b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/clipmap.py new file mode 100644 index 00000000..d693a892 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/clipmap.py @@ -0,0 +1,31 @@ +'''OpenGL extension SGIX.clipmap + +This module customises the behaviour of the +OpenGL.raw.GL.SGIX.clipmap to provide a more +Python-friendly API + +Overview (from the spec) + + Mipmaps provide a general but expensive solution when the texture image + is very large. This extension defines clipmaps, which occupy a small + subset of the memory required by equivalent mipmaps, but provide much + of the mipmap rendering capabilities. Clipmaps are especially useful + for rendering terrain. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/SGIX/clipmap.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.SGIX.clipmap import * +from OpenGL.raw.GL.SGIX.clipmap import _EXTENSION_NAME + +def glInitClipmapSGIX(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/convolution_accuracy.py b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/convolution_accuracy.py new file mode 100644 index 00000000..23d21059 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/convolution_accuracy.py @@ -0,0 +1,28 @@ +'''OpenGL extension SGIX.convolution_accuracy + +This module customises the behaviour of the +OpenGL.raw.GL.SGIX.convolution_accuracy to provide a more +Python-friendly API + +Overview (from the spec) + + This extension adds an accuracy hint for convolution. It + allows the program to trade off precision for speed. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/SGIX/convolution_accuracy.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.SGIX.convolution_accuracy import * +from OpenGL.raw.GL.SGIX.convolution_accuracy import _EXTENSION_NAME + +def glInitConvolutionAccuracySGIX(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/depth_pass_instrument.py b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/depth_pass_instrument.py new file mode 100644 index 00000000..a72da9f4 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/depth_pass_instrument.py @@ -0,0 +1,39 @@ +'''OpenGL extension SGIX.depth_pass_instrument + +This module customises the behaviour of the +OpenGL.raw.GL.SGIX.depth_pass_instrument to provide a more +Python-friendly API + +Overview (from the spec) + + This extension defines an instrument that uses the API defined in + SGIX_instruments. The instrument specified by this extension is a + counter of the number of fragments which passed the Z test during + rasterization. The maximum value of the counter is an + implementation-dependent constant. + + Some systems may maintain counters on different parts of the + system. For example, a system with a frame buffer distributed + across multiple chips may maintain a count of the fragments which + passed the depth test on each individual chip. In this extension, + a queriable constant is defined that indicates the number of + responses to expect when a measurement is taken. This + mechanism allows GL implementations to be as efficient as possible. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/SGIX/depth_pass_instrument.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.SGIX.depth_pass_instrument import * +from OpenGL.raw.GL.SGIX.depth_pass_instrument import _EXTENSION_NAME + +def glInitDepthPassInstrumentSGIX(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/depth_texture.py b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/depth_texture.py new file mode 100644 index 00000000..3406d143 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/depth_texture.py @@ -0,0 +1,34 @@ +'''OpenGL extension SGIX.depth_texture + +This module customises the behaviour of the +OpenGL.raw.GL.SGIX.depth_texture to provide a more +Python-friendly API + +Overview (from the spec) + + This extension defines a new depth texture format. An important + application of depth texture images is shadow casting, but separating + this from the shadow extension allows for the potential use of depth + textures in other applications such as image-based rendering or + displacement mapping. This extension does not define new depth-texture + environment functions, such as filtering or applying the depth values + computed from a texture, but leaves this to other extensions, such as + the shadow extension. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/SGIX/depth_texture.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.SGIX.depth_texture import * +from OpenGL.raw.GL.SGIX.depth_texture import _EXTENSION_NAME + +def glInitDepthTextureSGIX(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/flush_raster.py b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/flush_raster.py new file mode 100644 index 00000000..7dd6c303 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/flush_raster.py @@ -0,0 +1,38 @@ +'''OpenGL extension SGIX.flush_raster + +This module customises the behaviour of the +OpenGL.raw.GL.SGIX.flush_raster to provide a more +Python-friendly API + +Overview (from the spec) + + This extensions provides a way to ensure that all raster operations + currently in the pipeline will be completed before the next + raster operation begins. We define a raster operation as an operation + that involves the rasterization stage of the OpenGL pipeline. + The implementation is free to decide what consitutes flushing the + raster subsystem. + + The motivation is to allow accurate instrumentation by + including this call before stopping rasterization measurements. + There are cases where Finish() is used, but a FlushRaster() + would suffice, so this extension is deliberately kept independent + of the instruments extension. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/SGIX/flush_raster.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.SGIX.flush_raster import * +from OpenGL.raw.GL.SGIX.flush_raster import _EXTENSION_NAME + +def glInitFlushRasterSGIX(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/fog_offset.py b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/fog_offset.py new file mode 100644 index 00000000..b54ca2e0 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/fog_offset.py @@ -0,0 +1,40 @@ +'''OpenGL extension SGIX.fog_offset + +This module customises the behaviour of the +OpenGL.raw.GL.SGIX.fog_offset to provide a more +Python-friendly API + +Overview (from the spec) + + This extension allows fragments to look brighter in a foggy + environment, by biasing the fragment eye-coordinate distance prior + to fog computation. A reference point in eye space (rx ry rz) and an offset + amount toward the viewpoint (f_o) are specified. When fog offset is + enabled, the offset amount will be subtracted from the fragment + distance, making objects appear less foggy. + + If fog computation is done in screen-space coordinates under + perspective projection, the reference point is used in adjusting the + fog offset to be correct for fragments whose depth is close to that + point. The reference point should be redefined when it becomes too + far away from the primitives being drawn. Under orthographic + projection, or if fog computation is done in eye-space coordinates, + the reference point is ignored. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/SGIX/fog_offset.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.SGIX.fog_offset import * +from OpenGL.raw.GL.SGIX.fog_offset import _EXTENSION_NAME + +def glInitFogOffsetSGIX(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/fragment_lighting.py b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/fragment_lighting.py new file mode 100644 index 00000000..d4d6cbeb --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/fragment_lighting.py @@ -0,0 +1,58 @@ +'''OpenGL extension SGIX.fragment_lighting + +This module customises the behaviour of the +OpenGL.raw.GL.SGIX.fragment_lighting to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/SGIX/fragment_lighting.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.SGIX.fragment_lighting import * +from OpenGL.raw.GL.SGIX.fragment_lighting import _EXTENSION_NAME + +def glInitFragmentLightingSGIX(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glFragmentLightfvSGIX.params size not checked against 'pname' +glFragmentLightfvSGIX=wrapper.wrapper(glFragmentLightfvSGIX).setInputArraySize( + 'params', None +) +# INPUT glFragmentLightivSGIX.params size not checked against 'pname' +glFragmentLightivSGIX=wrapper.wrapper(glFragmentLightivSGIX).setInputArraySize( + 'params', None +) +# INPUT glFragmentLightModelfvSGIX.params size not checked against 'pname' +glFragmentLightModelfvSGIX=wrapper.wrapper(glFragmentLightModelfvSGIX).setInputArraySize( + 'params', None +) +# INPUT glFragmentLightModelivSGIX.params size not checked against 'pname' +glFragmentLightModelivSGIX=wrapper.wrapper(glFragmentLightModelivSGIX).setInputArraySize( + 'params', None +) +# INPUT glFragmentMaterialfvSGIX.params size not checked against 'pname' +glFragmentMaterialfvSGIX=wrapper.wrapper(glFragmentMaterialfvSGIX).setInputArraySize( + 'params', None +) +# INPUT glFragmentMaterialivSGIX.params size not checked against 'pname' +glFragmentMaterialivSGIX=wrapper.wrapper(glFragmentMaterialivSGIX).setInputArraySize( + 'params', None +) +glGetFragmentLightfvSGIX=wrapper.wrapper(glGetFragmentLightfvSGIX).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetFragmentLightivSGIX=wrapper.wrapper(glGetFragmentLightivSGIX).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetFragmentMaterialfvSGIX=wrapper.wrapper(glGetFragmentMaterialfvSGIX).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetFragmentMaterialivSGIX=wrapper.wrapper(glGetFragmentMaterialivSGIX).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/framezoom.py b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/framezoom.py new file mode 100644 index 00000000..b1dac4e7 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/framezoom.py @@ -0,0 +1,47 @@ +'''OpenGL extension SGIX.framezoom + +This module customises the behaviour of the +OpenGL.raw.GL.SGIX.framezoom to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides a additional way to rasterize geometric + primitives and pixel rectangles. The techique is to reduce the + number of pixels rasterized and (possibly) the number of depth and + stencil operations performed per primitive. Each pixel is zoomed + up and used to render an N x N block of screen pixels. The + implementation is free to choose the number of stencil and z pixels + that will correspond to each N x N block. + + This extension provides an opportunity to the implementation to + perform expensive raster operations at a reduced resolution, + increasing performance. Such operations may include + texture-mapping, depth & stencil tests, etc. The hardware should + be allowed to perform operations that it accelerates at full + hardware speed. + + The visual result will be the same as if a scene were rendered into + a small window, and then that buffer was copied and zoomed up into + a large window. + + All OpenGL parameters that effect rasterization size will implicitly + be multipled by N (this includes point size, line width, etc). + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/SGIX/framezoom.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.SGIX.framezoom import * +from OpenGL.raw.GL.SGIX.framezoom import _EXTENSION_NAME + +def glInitFramezoomSGIX(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/igloo_interface.py b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/igloo_interface.py new file mode 100644 index 00000000..d197d55b --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/igloo_interface.py @@ -0,0 +1,32 @@ +'''OpenGL extension SGIX.igloo_interface + +This module customises the behaviour of the +OpenGL.raw.GL.SGIX.igloo_interface to provide a more +Python-friendly API + +Overview (from the spec) + + This is an SGI internal (e.g. not documented or intended to be used + directly by applications) extension used only to help support + emulation of IrisGL through OpenGL. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/SGIX/igloo_interface.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.SGIX.igloo_interface import * +from OpenGL.raw.GL.SGIX.igloo_interface import _EXTENSION_NAME + +def glInitIglooInterfaceSGIX(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glIglooInterfaceSGIX.params size not checked against 'pname' +glIglooInterfaceSGIX=wrapper.wrapper(glIglooInterfaceSGIX).setInputArraySize( + 'params', None +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/instruments.py b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/instruments.py new file mode 100644 index 00000000..b7a8ddf1 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/instruments.py @@ -0,0 +1,64 @@ +'''OpenGL extension SGIX.instruments + +This module customises the behaviour of the +OpenGL.raw.GL.SGIX.instruments to provide a more +Python-friendly API + +Overview (from the spec) + + This extension allows the gathering and return of performance + measurements from within the graphics pipeline by adding + instrumentation. + + There are two reasons to do this. The first is as a part of some + type of fixed-frame-rate load management scheme. If we know that + the pipeline is stalled or struggling to process the amount of + data we have given it so far, we can reduce the level of detail of + the remaining objects in the current frame or the next frame, or + adjust the framebuffer resolution for the next frame if we have a + video-zoom capability available. We can call this type of + instrumentation Load Monitoring. + + The second is for performance tuning and debugging of an + application. It might tell us how many triangles were culled or + clipped before being rasterized. We can call this simply Tuning. + + Load Monitoring requires that the instrumentation and the access + of the measurements be efficient, otherwise the instrumentation + itself will reduce performance more than any load-management + scheme could hope to offset. Tuning does not have the same + requirements. + + The proposed extension adds a call to setup a measurements return + buffer, similar to FeedbackBuffer but with an asynchrounous + behavior to prevent filling the pipeline with NOP's while waiting + for the data to be returned. + + Note that although the extension has been specified without any + particular instruments, defining either a device dependent or + device independent instrument should be as simple as introducing + an extension consisting primarily of a new enumerant to identify + the instrument. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/SGIX/instruments.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.SGIX.instruments import * +from OpenGL.raw.GL.SGIX.instruments import _EXTENSION_NAME + +def glInitInstrumentsSGIX(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +glInstrumentsBufferSGIX=wrapper.wrapper(glInstrumentsBufferSGIX).setOutput( + 'buffer',size=lambda x:(x,),pnameArg='size',orPassIn=True +) +glPollInstrumentsSGIX=wrapper.wrapper(glPollInstrumentsSGIX).setOutput( + 'marker_p',size=(1,),orPassIn=True +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/interlace.py b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/interlace.py new file mode 100644 index 00000000..64813514 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/interlace.py @@ -0,0 +1,33 @@ +'''OpenGL extension SGIX.interlace + +This module customises the behaviour of the +OpenGL.raw.GL.SGIX.interlace to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides a way to interlace rows of pixels when + rasterizing pixel rectangles, and loading texture images. In this + context, interlacing means skiping over rows of pixels or texels + in the destination. This is useful for dealing with video data + since a single frame of video is typically composed from two images + or fields: one image specifying the data for even rows of the frame + and the other image specifying the data for odd rows of the frame. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/SGIX/interlace.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.SGIX.interlace import * +from OpenGL.raw.GL.SGIX.interlace import _EXTENSION_NAME + +def glInitInterlaceSGIX(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/ir_instrument1.py b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/ir_instrument1.py new file mode 100644 index 00000000..0d920006 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/ir_instrument1.py @@ -0,0 +1,26 @@ +'''OpenGL extension SGIX.ir_instrument1 + +This module customises the behaviour of the +OpenGL.raw.GL.SGIX.ir_instrument1 to provide a more +Python-friendly API + +Overview (from the spec) + + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/SGIX/ir_instrument1.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.SGIX.ir_instrument1 import * +from OpenGL.raw.GL.SGIX.ir_instrument1 import _EXTENSION_NAME + +def glInitIrInstrument1SGIX(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/list_priority.py b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/list_priority.py new file mode 100644 index 00000000..596f2512 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/list_priority.py @@ -0,0 +1,43 @@ +'''OpenGL extension SGIX.list_priority + +This module customises the behaviour of the +OpenGL.raw.GL.SGIX.list_priority to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides a mechanism for specifying the relative + importance of display lists. This information can be used by + an OpenGL implementation to guide the placement of display + list data in a storage hierarchy. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/SGIX/list_priority.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.SGIX.list_priority import * +from OpenGL.raw.GL.SGIX.list_priority import _EXTENSION_NAME + +def glInitListPrioritySGIX(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +glGetListParameterfvSGIX=wrapper.wrapper(glGetListParameterfvSGIX).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetListParameterivSGIX=wrapper.wrapper(glGetListParameterivSGIX).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +# INPUT glListParameterfvSGIX.params size not checked against 'pname' +glListParameterfvSGIX=wrapper.wrapper(glListParameterfvSGIX).setInputArraySize( + 'params', None +) +# INPUT glListParameterivSGIX.params size not checked against 'pname' +glListParameterivSGIX=wrapper.wrapper(glListParameterivSGIX).setInputArraySize( + 'params', None +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/pixel_texture.py b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/pixel_texture.py new file mode 100644 index 00000000..de193028 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/pixel_texture.py @@ -0,0 +1,32 @@ +'''OpenGL extension SGIX.pixel_texture + +This module customises the behaviour of the +OpenGL.raw.GL.SGIX.pixel_texture to provide a more +Python-friendly API + +Overview (from the spec) + + This extension allows the color components of pixel groups to be used as + texture coordinates, effectively converting a color image into a texture + coordinate image. Because texture mapping is essentially a + multidimensional table lookup, this conversion supports multidimensional + color lookups for images. Such multidimensional lookups can be used to + implement very accurate color space conversions. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/SGIX/pixel_texture.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.SGIX.pixel_texture import * +from OpenGL.raw.GL.SGIX.pixel_texture import _EXTENSION_NAME + +def glInitPixelTextureSGIX(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/pixel_tiles.py b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/pixel_tiles.py new file mode 100644 index 00000000..6c16d8fb --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/pixel_tiles.py @@ -0,0 +1,58 @@ +'''OpenGL extension SGIX.pixel_tiles + +This module customises the behaviour of the +OpenGL.raw.GL.SGIX.pixel_tiles to provide a more +Python-friendly API + +Overview (from the spec) + + This extension deals with the interaction of existing GL functions that + read pixels from memory, applications that use grids of tiles of pixels, + and convolution. + + Applications that deal with large multi-dimensional images sometimes + break the image into a grid of rectangular tiles of pixels. Such an + approach can help control memory use and expedite roaming through an + image that is large with respect to the available memory. + + GL functions that cause pixels to be read from memory (e.g., DrawPixels + and TexImage2D) assume the pixels are stored as a single series of rows + of pixels. The grid of tiles is essentially a sequence of the structures + that the pixel reading functions assume. When an application that uses + tiling uses a GL function such as DrawPixels, it must iterate + through the tiles, either coalescing the tiles into a single tile in + preparation for a single GL call or calling the GL function for each tile. + + The convolution operation imposes strict ordering on the way pixels + in a subimage that crosses tile boundaries must be transferred: the rows + of pixels transferred must span the entire subimage. Applications + that use tiles of pixels and convolution must copy the subimage to be + transferred from the grid of tiles to a contiguous region, then pass the + now-contiguous rows of pixels to the convolution function. If the + coalescing of tiles is not needed for some other reason or is not a + side effect of some necessary operation, it is just redundant movement + of the pixels. + + This extension seeks to eliminate the extra copy of data by extending the + existing GL functions to accept, as a source of pixels in memory, a + grid of tiles of pixels in addition to the current sequence of rows + of pixels. + + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/SGIX/pixel_tiles.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.SGIX.pixel_tiles import * +from OpenGL.raw.GL.SGIX.pixel_tiles import _EXTENSION_NAME + +def glInitPixelTilesSGIX(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/polynomial_ffd.py b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/polynomial_ffd.py new file mode 100644 index 00000000..512e1e46 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/polynomial_ffd.py @@ -0,0 +1,45 @@ +'''OpenGL extension SGIX.polynomial_ffd + +This module customises the behaviour of the +OpenGL.raw.GL.SGIX.polynomial_ffd to provide a more +Python-friendly API + +Overview (from the spec) + + This extension adds the capability to alter vertex coordinates, the + corresponding normal coordinates, and texture coordinates based on a + client-specified trivariate polynomial functions. These functions may be + thought of as a warping of object/texture space (or, alternatively, as a + warping of the object embedded in object/texture space). + + Deformations of space are used for a variety of modeling effects, including + character animation. The deformation specified in this extension is one of + a variety of mappings that have been proposed. + + Only 3D to 3D deformation are considered. We shall not consider + homogeneous deformations. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/SGIX/polynomial_ffd.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.SGIX.polynomial_ffd import * +from OpenGL.raw.GL.SGIX.polynomial_ffd import _EXTENSION_NAME + +def glInitPolynomialFfdSGIX(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glDeformationMap3dSGIX.points size not checked against 'target,ustride,uorder,vstride,vorder,wstride,worder' +glDeformationMap3dSGIX=wrapper.wrapper(glDeformationMap3dSGIX).setInputArraySize( + 'points', None +) +# INPUT glDeformationMap3fSGIX.points size not checked against 'target,ustride,uorder,vstride,vorder,wstride,worder' +glDeformationMap3fSGIX=wrapper.wrapper(glDeformationMap3fSGIX).setInputArraySize( + 'points', None +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/reference_plane.py b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/reference_plane.py new file mode 100644 index 00000000..30010958 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/reference_plane.py @@ -0,0 +1,49 @@ +'''OpenGL extension SGIX.reference_plane + +This module customises the behaviour of the +OpenGL.raw.GL.SGIX.reference_plane to provide a more +Python-friendly API + +Overview (from the spec) + + This extension allows a group of coplanar primitives to be rendered + without depth-buffering artifacts. This is accomplished by generating + the depth values for all the primitives from a single ``reference plane'' + rather than from the primitives themselves. This ensures that all the + primitives in the group have exactly the same depth value at any given + sample point, no matter what imprecision may exist in the original + specifications of the primitives or in the GL's coordinate transformation + process. + + The reference plane is defined by a four-component plane equation. + When glReferencePlaneSGIX is called, equation is transformed by the + transpose-adjoint of a matrix that is the complete object-coordinate + to clip-coordinate transformation. The resulting clip-coordinate + coefficients are transformed by the current viewport when the reference + plane is enabled. + + The reference plane is enabled and disabled with glEnable and glDisable. + + If the reference plane is enabled, a fragment (xf,yf,zf) will have a + new z coordinate generated from (xf,yf) by giving it the same z value + that the reference plane would have at (xf,yf). + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/SGIX/reference_plane.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.SGIX.reference_plane import * +from OpenGL.raw.GL.SGIX.reference_plane import _EXTENSION_NAME + +def glInitReferencePlaneSGIX(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +glReferencePlaneSGIX=wrapper.wrapper(glReferencePlaneSGIX).setInputArraySize( + 'equation', 4 +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/resample.py b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/resample.py new file mode 100644 index 00000000..0ebc2f22 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/resample.py @@ -0,0 +1,43 @@ +'''OpenGL extension SGIX.resample + +This module customises the behaviour of the +OpenGL.raw.GL.SGIX.resample to provide a more +Python-friendly API + +Overview (from the spec) + + This extension enhances the unpacking resampling capabilities + of the SGIX_subsample extension. + + When pixel data is received from the client and an unpacking + upsampling mode other than PIXEL_SUBSAMPLE_RATE_4444_SGIX is + specified, the upsampling is performed via one of two methods: + RESAMPLE_REPLICATE_SGIX, RESAMPLE_ZERO_FILL_SGIX. + Replicate and zero fill are provided to + give the application greatest performance and control over the + filtering process. + + However, when pixel data is read back to the client and a + packing downsampling mode other than PIXEL_SUBSAMPLE_RATE_4444_SGIX + is specified, downsampling is + performed via simple component decimation (point sampling). That is, + only the RESAMPLE_DECIMATE_SGIX is valid. + + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/SGIX/resample.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.SGIX.resample import * +from OpenGL.raw.GL.SGIX.resample import _EXTENSION_NAME + +def glInitResampleSGIX(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/scalebias_hint.py b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/scalebias_hint.py new file mode 100644 index 00000000..5fb4dd38 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/scalebias_hint.py @@ -0,0 +1,30 @@ +'''OpenGL extension SGIX.scalebias_hint + +This module customises the behaviour of the +OpenGL.raw.GL.SGIX.scalebias_hint to provide a more +Python-friendly API + +Overview (from the spec) + + This extension adds an precision hint for scaling and biasing + arithmetic. For large scale factors, hinting GL_NICEST produces the + most accurate results. The hint only applies to Octane2 VPro + graphics systems, to work around a hardware issue. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/SGIX/scalebias_hint.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.SGIX.scalebias_hint import * +from OpenGL.raw.GL.SGIX.scalebias_hint import _EXTENSION_NAME + +def glInitScalebiasHintSGIX(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/shadow.py b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/shadow.py new file mode 100644 index 00000000..d00e826e --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/shadow.py @@ -0,0 +1,31 @@ +'''OpenGL extension SGIX.shadow + +This module customises the behaviour of the +OpenGL.raw.GL.SGIX.shadow to provide a more +Python-friendly API + +Overview (from the spec) + + This extension defines two new operations to be performed on texture + values before they are passed on to the filtering subsystem. These + operations perform either a <= or >= test on the value from texture + memory and the iterated R value, and return 1.0 or 0.0 if the test + passes or fails, respectively. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/SGIX/shadow.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.SGIX.shadow import * +from OpenGL.raw.GL.SGIX.shadow import _EXTENSION_NAME + +def glInitShadowSGIX(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/shadow_ambient.py b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/shadow_ambient.py new file mode 100644 index 00000000..5afc3d1a --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/shadow_ambient.py @@ -0,0 +1,33 @@ +'''OpenGL extension SGIX.shadow_ambient + +This module customises the behaviour of the +OpenGL.raw.GL.SGIX.shadow_ambient to provide a more +Python-friendly API + +Overview (from the spec) + + This extension allows a value other than 0.0 to be returned by the + SGIX_shadow operation in the case when the shadow test passes. + With this extension any floating point value in the range [0.0, + 1.0] can be returned as the texture value when an object is in + shadow. This allows the (untextured) ambient lighting and direct + shadowed lighting from a single light source to be computed in a + single pass. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/SGIX/shadow_ambient.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.SGIX.shadow_ambient import * +from OpenGL.raw.GL.SGIX.shadow_ambient import _EXTENSION_NAME + +def glInitShadowAmbientSGIX(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/sprite.py b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/sprite.py new file mode 100644 index 00000000..dd3cded9 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/sprite.py @@ -0,0 +1,79 @@ +'''OpenGL extension SGIX.sprite + +This module customises the behaviour of the +OpenGL.raw.GL.SGIX.sprite to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides support for viewpoint dependent alignment + of geometry, in particular geometry that rotates about a point or + a specified axis to face the eye point. The primary use is for + quickly rendering roughly cylindrically or spherically symmetric + objects, e.g. trees, smoke, clouds, etc. using geometry textured + with a partially transparent texture map. + + Rendering sprite geometry requires applying a transformation to + primitives before the current model view. This matrix includes a + rotation which is computed based on the current model view matrix + and a translation which is specified explicitly + (SPRITE_TRANSLATION_SGIX). The current model view matrix itself + is not modified. + + Primitives are first transformed by a rotation, depending on the + sprite mode: + + SPRITE_AXIAL_SGIX: The front of the object is rotated about + an axis so that it faces the eye as much as the axis + constraint allows. This is used for roughly rendering cylindrical + objects such as trees in visual simulation. + + SPRITE_OBJECT_ALIGNED_SGIX: The front of the object is + rotated about a point to face the eye with the remaining + rotational degree of freedom specified by aligning the top + of the object with a specified axis in object coordinates. + This is used for spherical objects and special effects such + as smoke which must maintain an alignment in object + coordinates for realism. + + SPRITE_EYE_ALIGNED_SGIX: The front of the object is rotated + about a point to face the eye with the remaining rotational + degree of freedom specified by aligning the top of the object + with a specified axis in eye coordinates. This is used for + rendering sprites which must maintain an alignment on the + screen, such as 3D annotations. + + The axis of rotation or alignment, SPRITE_AXIS_SGIX, can be + an arbitrary direction to support geocentric coordinate frames + in which "up" is not along X, Y or Z. + + Sprite geometry is modeled in a canonical frame: +Z is the up + vector. -Y is the front vector which is rotated to point towards + the eye. In the discussion below, the eye vector is the vector to + the eye from the origin of the model view frame translated by the + sprite position. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/SGIX/sprite.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.SGIX.sprite import * +from OpenGL.raw.GL.SGIX.sprite import _EXTENSION_NAME + +def glInitSpriteSGIX(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glSpriteParameterfvSGIX.params size not checked against 'pname' +glSpriteParameterfvSGIX=wrapper.wrapper(glSpriteParameterfvSGIX).setInputArraySize( + 'params', None +) +# INPUT glSpriteParameterivSGIX.params size not checked against 'pname' +glSpriteParameterivSGIX=wrapper.wrapper(glSpriteParameterivSGIX).setInputArraySize( + 'params', None +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/subsample.py b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/subsample.py new file mode 100644 index 00000000..21239d7b --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/subsample.py @@ -0,0 +1,52 @@ +'''OpenGL extension SGIX.subsample + +This module customises the behaviour of the +OpenGL.raw.GL.SGIX.subsample to provide a more +Python-friendly API + +Overview (from the spec) + + Many video image formats and compression techniques utilize + various component subsamplings, so it is necessary to provide a + mechanism to specify the up- and down-sampling of components as + pixel data is drawn from and read back to the client. Though + subsampled components are normally associated with the video + color space, YCrCb, use of subsampling in OpenGL does not imply + a specific color space. + + This extension defines new pixel storage modes that are used in + the conversion of image data to and from component subsampled + formats on the client side. The extension defines a new pixel + storage mode to specify these sampling patterns, there are + three legal values (PIXEL_SUBSAMPLE_4444_SGIX, + PIXEL_SUBSAMPLE_4242_SGIX, and + PIXEL_SUBSAMPLE_2424_SGIX). + + When pixel data is received from the client and an unpacking + upsampling mode other than PIXEL_SUBSAMPLE_4444_SGIX is + specified, the upsampling is performed via replication, + unless otherwise specified by RESAMPLE_SGIX. + + Similarly, when pixel data is read back to the client and a + packing downsampling mode other than + PIXEL_SUBSAMPLE_4444_SGIX is specified, downsampling is + performed via simple component decimation (point sampling), + unless otherwise specified by RESAMPLE_SGIX. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/SGIX/subsample.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.SGIX.subsample import * +from OpenGL.raw.GL.SGIX.subsample import _EXTENSION_NAME + +def glInitSubsampleSGIX(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/tag_sample_buffer.py b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/tag_sample_buffer.py new file mode 100644 index 00000000..53a41684 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/tag_sample_buffer.py @@ -0,0 +1,32 @@ +'''OpenGL extension SGIX.tag_sample_buffer + +This module customises the behaviour of the +OpenGL.raw.GL.SGIX.tag_sample_buffer to provide a more +Python-friendly API + +Overview (from the spec) + + The extensions defines a special purpose fast multisample clear. + This clear can be used with some restrictions as a significantly + faster alternative to Clear(DEPTH_BUFFER_BIT). + + The extension is based on the RealityEngine architecture and will + probably never be supported by any other architecture. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/SGIX/tag_sample_buffer.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.SGIX.tag_sample_buffer import * +from OpenGL.raw.GL.SGIX.tag_sample_buffer import _EXTENSION_NAME + +def glInitTagSampleBufferSGIX(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/texture_add_env.py b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/texture_add_env.py new file mode 100644 index 00000000..afc08284 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/texture_add_env.py @@ -0,0 +1,34 @@ +'''OpenGL extension SGIX.texture_add_env + +This module customises the behaviour of the +OpenGL.raw.GL.SGIX.texture_add_env to provide a more +Python-friendly API + +Overview (from the spec) + + New texture environment function ADD is supported with the following + equation: + Cv = Cf + CcCt + Cb + + New function may be specified by calling glTexEnv with GL_ADD token. + New parameter Cb (bias) may be specified by calling TexEnv with + TEXTURE_ENV_BIAS_SGIX token. + + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/SGIX/texture_add_env.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.SGIX.texture_add_env import * +from OpenGL.raw.GL.SGIX.texture_add_env import _EXTENSION_NAME + +def glInitTextureAddEnvSGIX(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/texture_coordinate_clamp.py b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/texture_coordinate_clamp.py new file mode 100644 index 00000000..355a77bd --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/texture_coordinate_clamp.py @@ -0,0 +1,31 @@ +'''OpenGL extension SGIX.texture_coordinate_clamp + +This module customises the behaviour of the +OpenGL.raw.GL.SGIX.texture_coordinate_clamp to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides a mechanism to specify the maximum texture coordinate + clamping values. Standard OpenGL always clamps the upper bound to 1.0 when + the wrap mode is set to CLAMP. This mechanism can be used to guarantee + that non-existent texel data will not be accessed when the texture image has + dimensions that are not a power of 2. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/SGIX/texture_coordinate_clamp.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.SGIX.texture_coordinate_clamp import * +from OpenGL.raw.GL.SGIX.texture_coordinate_clamp import _EXTENSION_NAME + +def glInitTextureCoordinateClampSGIX(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/texture_lod_bias.py b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/texture_lod_bias.py new file mode 100644 index 00000000..ddb7b74d --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/texture_lod_bias.py @@ -0,0 +1,43 @@ +'''OpenGL extension SGIX.texture_lod_bias + +This module customises the behaviour of the +OpenGL.raw.GL.SGIX.texture_lod_bias to provide a more +Python-friendly API + +Overview (from the spec) + + This extension modifies the calculation of texture level of detail + parameter LOD, which is represented by the Greek character lambda + in the GL Specification. The LOD equation assumes that a 2^n x 2^m x 2^l + texture is band limited at 2^(n-1), 2^(m-1), 2^(l-1). Often a texture is + oversampled or filtered such that the texture is band limited at lower + frequencies in one or more dimensions. The result is that texture-mapped + primitives appear excessively blurry. This extension provides biases + for n, m, and l in the LOD calculation to to compensate for under or over + sampled texture images. Mipmapped textures can be made to appear sharper or + blurrier by supplying a negative or positive bias respectively. + + Examples of textures which can benefit from this LOD control include + video-capture images which are filtered differently horizontally and + vertically; a texture which appears blurry because it is mapped with + a nonuniform scale, such as a road texture which is repeated hundreds of + times in one dimension and only once in the other; and textures which + had to be magnified to a power-of-two for mipmapping. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/SGIX/texture_lod_bias.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.SGIX.texture_lod_bias import * +from OpenGL.raw.GL.SGIX.texture_lod_bias import _EXTENSION_NAME + +def glInitTextureLodBiasSGIX(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/texture_multi_buffer.py b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/texture_multi_buffer.py new file mode 100644 index 00000000..ce56994d --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/texture_multi_buffer.py @@ -0,0 +1,53 @@ +'''OpenGL extension SGIX.texture_multi_buffer + +This module customises the behaviour of the +OpenGL.raw.GL.SGIX.texture_multi_buffer to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides an API for the application to specify that + the OpenGL should handle multiple textures in such a way that, + wherever possible, a texture definition or redefinition can occur + in parallel with rendering that uses a different texture. + + The texture_object extension allows the simultaneous definition + of multiple textures; any texture that is not being used for + rendering can, in principle, have its definition or operations + in its definition (e.g. downloading to hardware) occur in parallel + with the use of another texture. This is true as long as all + redefinitions strictly follow any use of the previous definition. + + Conceptually this is similar to frame buffer double-buffering, + except that the intent here is to simply provide a hint to the + OpenGL to promote such double-buffering if and wherever possible. + The effect of such a hint is to speed up operations without + affecting the result. The user on any particular system must be + knowledgable and prepared to accept any trade-offs which follow + from such a hint. + + GL_FASTEST in this context means that texture multi-buffering + is being used whenever possible to improve performance. + Generally, textures that are adjacent in a sequence of multiple + texture definitions have the greatest chance of being in + different buffers. The number of buffers available at any time + depends on various factors, such as the machine being used and + the textures' internal formats. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/SGIX/texture_multi_buffer.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.SGIX.texture_multi_buffer import * +from OpenGL.raw.GL.SGIX.texture_multi_buffer import _EXTENSION_NAME + +def glInitTextureMultiBufferSGIX(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/texture_scale_bias.py b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/texture_scale_bias.py new file mode 100644 index 00000000..ca7db979 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/texture_scale_bias.py @@ -0,0 +1,38 @@ +'''OpenGL extension SGIX.texture_scale_bias + +This module customises the behaviour of the +OpenGL.raw.GL.SGIX.texture_scale_bias to provide a more +Python-friendly API + +Overview (from the spec) + + This extension adds scale, bias, and clamp to [0, 1] operations to the + texture pipeline. + These operations are applied to the filtered result of a texture lookup, + before that result is used in the texture environment equations and + before the texture color lookup table of SGI_texture_color_table, + if that extension exists. + These operations are distinct from the scale, bias, and clamp operations + that appear in the SGI_color_table extension, which are used to + define a color lookup table. + + Scale and bias operations on texels can be used to better utilize the + color resolution of a particular texture internal format (see EXT_texture). + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/SGIX/texture_scale_bias.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.SGIX.texture_scale_bias import * +from OpenGL.raw.GL.SGIX.texture_scale_bias import _EXTENSION_NAME + +def glInitTextureScaleBiasSGIX(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/vertex_preclip.py b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/vertex_preclip.py new file mode 100644 index 00000000..fd010974 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/vertex_preclip.py @@ -0,0 +1,39 @@ +'''OpenGL extension SGIX.vertex_preclip + +This module customises the behaviour of the +OpenGL.raw.GL.SGIX.vertex_preclip to provide a more +Python-friendly API + +Overview (from the spec) + + Certain graphics subsystems are capable of performing fast + 2D viewport or, in some cases, 3D volume "scissoring" operations + within some coordinate range much faster that the host CPU could + re-tesselate clipped primitives. + + This extension introduces the notion of an extended rasterizable view + volume that is an expansion of the clip-space view volume. This volume + is the space within which a particular graphics system is much more + efficient at rejecting fragments that lie outside the view volume than + it is at performing strict view volume clipping. + + Clip-checking can be turned on or off through the glEnable/glDisable + mechanism, and can be further controlled by using glHint. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/SGIX/vertex_preclip.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.SGIX.vertex_preclip import * +from OpenGL.raw.GL.SGIX.vertex_preclip import _EXTENSION_NAME + +def glInitVertexPreclipSGIX(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/ycrcb.py b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/ycrcb.py new file mode 100644 index 00000000..d480d018 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/ycrcb.py @@ -0,0 +1,52 @@ +'''OpenGL extension SGIX.ycrcb + +This module customises the behaviour of the +OpenGL.raw.GL.SGIX.ycrcb to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides a method for OpenGL to read and store + images that are defined in standard YCRCB 422 and 444 video formats. + As with the CYMK extension, conversion to RGBA takes place immediately + following the unpack pixel store, and preceding the pack pixel store + operations, and is only available on transfers to and from memory. + The algorithms that convert between YCRCB and RGBA are "black-box" + in nature, and left undefined by the extension. + + Two new formats are added, YCRCB_422_SGIX and YCRCB_444_SGIX. + + To handle the difference in sampling rate for 422 video, the pixel + storage operations treat YCRCB_422_SGIX as a 2 component format, + where the first component represents chroma, and the second luma. + The chroma component alternates between Cb and Cr values on + a per pixel basis. If the specified image parameter is not + a multiple of 2, then fragments or texels that result from processing + the th column of pixels will have undefined color value. + + YCRCB_444_SGIX is defined as a 3 component format representing + the Cb, Y, and Cr values per pixel. + + As with the CMYK extension, this extension doesn't preclude the + possiblity of other higher quality conversion methods. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/SGIX/ycrcb.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.SGIX.ycrcb import * +from OpenGL.raw.GL.SGIX.ycrcb import _EXTENSION_NAME + +def glInitYcrcbSGIX(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION +from OpenGL import images as _i +_i.COMPONENT_COUNTS[ GL_YCRCB_422_SGIX ] = 1 # must be GL_UNSIGNED_BYTE +_i.COMPONENT_COUNTS[ GL_YCRCB_444_SGIX ] = 1 # must be GL_UNSIGNED_SHORT diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/ycrcb_subsample.py b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/ycrcb_subsample.py new file mode 100644 index 00000000..62b652d6 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/ycrcb_subsample.py @@ -0,0 +1,27 @@ +'''OpenGL extension SGIX.ycrcb_subsample + +This module customises the behaviour of the +OpenGL.raw.GL.SGIX.ycrcb_subsample to provide a more +Python-friendly API + +Overview (from the spec) + + (Need to construct a real extension spec based on this) + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/SGIX/ycrcb_subsample.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.SGIX.ycrcb_subsample import * +from OpenGL.raw.GL.SGIX.ycrcb_subsample import _EXTENSION_NAME + +def glInitYcrcbSubsampleSGIX(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/ycrcba.py b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/ycrcba.py new file mode 100644 index 00000000..0870fafe --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/SGIX/ycrcba.py @@ -0,0 +1,47 @@ +'''OpenGL extension SGIX.ycrcba + +This module customises the behaviour of the +OpenGL.raw.GL.SGIX.ycrcba to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides a method for OpenGL to read and store + images that are defined in standard YCRCB and YCRCBA video color + spaces. As with the CYMK extension, conversion to RGBA takes place + immediately following the unpack pixel store, and preceding the + pack pixel store operations, and is only available on transfers to + and from memory. The algorithms that convert between YCRCB and + RGBA are "black-box" in nature, and left undefined by the + extension, however it is recommended that conversion comply with + the CCIR standard. This extension specifies the format of a pixel + rectangle independent of component subsampling. Component + subsampling is specified using a separate extension. + + Two new formats are added, YCRCB_SGIX and YCRCBA_SGIX. + + YCRCB_SGIX is defined as a 3 component format representing the Cb, + Y, and Cr values per pixel. YCRCBA_SGIX is defined as a 4 component + format representing Cb, Y, Cr, and A values per pixel. + + As with the CMYK extension, this extension doesn't preclude the + possibility of other higher quality conversion methods. + + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/SGIX/ycrcba.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.SGIX.ycrcba import * +from OpenGL.raw.GL.SGIX.ycrcba import _EXTENSION_NAME + +def glInitYcrcbaSGIX(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/SUN/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/GL/SUN/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/SUN/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/SUN/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/SUN/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..56bc9151 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/SUN/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/SUN/__pycache__/convolution_border_modes.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/SUN/__pycache__/convolution_border_modes.cpython-312.pyc new file mode 100644 index 00000000..eb928ffa Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/SUN/__pycache__/convolution_border_modes.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/SUN/__pycache__/global_alpha.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/SUN/__pycache__/global_alpha.cpython-312.pyc new file mode 100644 index 00000000..52881496 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/SUN/__pycache__/global_alpha.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/SUN/__pycache__/mesh_array.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/SUN/__pycache__/mesh_array.cpython-312.pyc new file mode 100644 index 00000000..f8bfcde8 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/SUN/__pycache__/mesh_array.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/SUN/__pycache__/slice_accum.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/SUN/__pycache__/slice_accum.cpython-312.pyc new file mode 100644 index 00000000..5d876007 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/SUN/__pycache__/slice_accum.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/SUN/__pycache__/triangle_list.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/SUN/__pycache__/triangle_list.cpython-312.pyc new file mode 100644 index 00000000..ca2b295c Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/SUN/__pycache__/triangle_list.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/SUN/__pycache__/vertex.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/SUN/__pycache__/vertex.cpython-312.pyc new file mode 100644 index 00000000..f6a73205 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/SUN/__pycache__/vertex.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/SUN/convolution_border_modes.py b/venv/lib/python3.12/site-packages/OpenGL/GL/SUN/convolution_border_modes.py new file mode 100644 index 00000000..de3db636 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/SUN/convolution_border_modes.py @@ -0,0 +1,28 @@ +'''OpenGL extension SUN.convolution_border_modes + +This module customises the behaviour of the +OpenGL.raw.GL.SUN.convolution_border_modes to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides an additional border mode for the + EXT_convolution extension. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/SUN/convolution_border_modes.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.SUN.convolution_border_modes import * +from OpenGL.raw.GL.SUN.convolution_border_modes import _EXTENSION_NAME + +def glInitConvolutionBorderModesSUN(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/SUN/global_alpha.py b/venv/lib/python3.12/site-packages/OpenGL/GL/SUN/global_alpha.py new file mode 100644 index 00000000..467298fa --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/SUN/global_alpha.py @@ -0,0 +1,49 @@ +'''OpenGL extension SUN.global_alpha + +This module customises the behaviour of the +OpenGL.raw.GL.SUN.global_alpha to provide a more +Python-friendly API + +Overview (from the spec) + + Transparency is done in OpenGL using alpha blending. An alpha value + of 0.0 is used for fully transparent objects, while an alpha value + of 1.0 is used for fully opaque objects. A value of 0.25 is 75% + transparent, and so on. + + OpenGL defines alpha as a component of the vertex color state. + Whenever a color is set, the alpha component is set along with the + red, green, and blue components. This means that transparency + can't be changed for primitives with per-vertex colors without + modifying the color of each vertex, replacing the old alpha + component with the new alpha component. This can be very expensive + for objects that are drawn using vertex arrays; it all but + precludes the use of display lists. + + This extension defines a new global alpha attribute that can be + used to specify an alpha factor that is independent from the alpha + component of the color value. The global alpha factor is + multiplied by the fragment's alpha value after primitive + rasterization and prior to texture mapping, replacing the + fragment's alpha value. The global alpha extension is only + specified in RGBA mode and must be applied prior to any texture + mapping operation. It is enabled by a new GLOBAL_ALPHA flag. + + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/SUN/global_alpha.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.SUN.global_alpha import * +from OpenGL.raw.GL.SUN.global_alpha import _EXTENSION_NAME + +def glInitGlobalAlphaSUN(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/SUN/mesh_array.py b/venv/lib/python3.12/site-packages/OpenGL/GL/SUN/mesh_array.py new file mode 100644 index 00000000..e1795bac --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/SUN/mesh_array.py @@ -0,0 +1,33 @@ +'''OpenGL extension SUN.mesh_array + +This module customises the behaviour of the +OpenGL.raw.GL.SUN.mesh_array to provide a more +Python-friendly API + +Overview (from the spec) + + + This extension defines a new mesh primitive. + The primitive can only be used with vertex arrays and cannot be used in + immediate mode. The application must arrange the vertices in row major format. + For example if a quad mesh is 4 vertices wide the, vertices in the first + row are the first 4 vertices and vertices in the second row are vertices 5 + through 8. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/SUN/mesh_array.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.SUN.mesh_array import * +from OpenGL.raw.GL.SUN.mesh_array import _EXTENSION_NAME + +def glInitMeshArraySUN(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/SUN/slice_accum.py b/venv/lib/python3.12/site-packages/OpenGL/GL/SUN/slice_accum.py new file mode 100644 index 00000000..61ea3a3f --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/SUN/slice_accum.py @@ -0,0 +1,30 @@ +'''OpenGL extension SUN.slice_accum + +This module customises the behaviour of the +OpenGL.raw.GL.SUN.slice_accum to provide a more +Python-friendly API + +Overview (from the spec) + + + This extension defines a new accumulation operation which enables the accumulation + buffer to be used for alpha compositing. This enables higher precision alpha + blending than what can be accomplished using the blend operation. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/SUN/slice_accum.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.SUN.slice_accum import * +from OpenGL.raw.GL.SUN.slice_accum import _EXTENSION_NAME + +def glInitSliceAccumSUN(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/SUN/triangle_list.py b/venv/lib/python3.12/site-packages/OpenGL/GL/SUN/triangle_list.py new file mode 100644 index 00000000..76efc5c2 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/SUN/triangle_list.py @@ -0,0 +1,78 @@ +'''OpenGL extension SUN.triangle_list + +This module customises the behaviour of the +OpenGL.raw.GL.SUN.triangle_list to provide a more +Python-friendly API + +Overview (from the spec) + + OpenGL has two chained triangle primitives, TRIANGLE_STRIP and + TRIANGLE_FAN. For multiple, consecutive triangle strips or + triangle fans, the overhead of Begin and End, or separate calls to + DrawArrays, can be significant depending on the number of triangles + per strip or fan. + + Many surface tessellators produce triangle strips with very few + triangles per strip before needing to restart a new strip. Even + sophisticated tessellators typically need to restart a new strip, + or switch from a triangle strip to a triangle fan, many times + within a single object. Such tessellators can often produce a more + efficient tessellation--one with fewer vertices--by mixing strips + and fans within the same object. The ability to switch from one to + the other without restarting the strip or fan yields even more + savings. Unfortunately, the overhead of switching from a triangle + strip to a triangle fan, or vice versa, can reduce, or even + eliminate the benefit gained from reducing the number of vertices. + + A new triangle list primitive, along with an associated replacement + code attribute, is defined by this extension to allow multiple + triangle strips and fans to be specified within the same Begin/End + pair or from a single call to DrawArrays. The triangle list + extension also provides the means to switch between triangle strips + and triangle fans with or without restarting the strip or fan. + + TRIANGLE_LIST is a new primitive type (i.e., new Begin mode) that + uses the ReplacementCodeSUN state attribute to determine whether the + current vertex replaces the oldest vertex, as in a triangle strip, + the middle vertex, as in a triangle fan, or restarts a new chained + triangle list. The first vertex of a new triangle list is + implicitly treated as a RESTART. The first three vertices complete + the first triangle, after which the replacement codes of the vertex + are used. The two vertices immediately following a + restart--including the implicit restart on the first vertex--are + ignored. The ReplacementCodeSUN attribute is part of the vertex + state, and is only used by the TRIANGLE_LIST primitive. + + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/SUN/triangle_list.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.SUN.triangle_list import * +from OpenGL.raw.GL.SUN.triangle_list import _EXTENSION_NAME + +def glInitTriangleListSUN(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glReplacementCodeuivSUN.code size not checked against '' +glReplacementCodeuivSUN=wrapper.wrapper(glReplacementCodeuivSUN).setInputArraySize( + 'code', None +) +# INPUT glReplacementCodeusvSUN.code size not checked against '' +glReplacementCodeusvSUN=wrapper.wrapper(glReplacementCodeusvSUN).setInputArraySize( + 'code', None +) +# INPUT glReplacementCodeubvSUN.code size not checked against '' +glReplacementCodeubvSUN=wrapper.wrapper(glReplacementCodeubvSUN).setInputArraySize( + 'code', None +) +# INPUT glReplacementCodePointerSUN.pointer size not checked against 'type,stride' +glReplacementCodePointerSUN=wrapper.wrapper(glReplacementCodePointerSUN).setInputArraySize( + 'pointer', None +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/SUN/vertex.py b/venv/lib/python3.12/site-packages/OpenGL/GL/SUN/vertex.py new file mode 100644 index 00000000..9b7d1bed --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/SUN/vertex.py @@ -0,0 +1,166 @@ +'''OpenGL extension SUN.vertex + +This module customises the behaviour of the +OpenGL.raw.GL.SUN.vertex to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides new GL commands to specify vertex data such as + color and normal along with the vertex in one single GL command in order to + minimize the overhead in making GL commands for each set of vertex data. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/SUN/vertex.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.SUN.vertex import * +from OpenGL.raw.GL.SUN.vertex import _EXTENSION_NAME + +def glInitVertexSUN(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +glColor4ubVertex2fvSUN=wrapper.wrapper(glColor4ubVertex2fvSUN).setInputArraySize( + 'c', 4 +).setInputArraySize( + 'v', 2 +) +glColor4ubVertex3fvSUN=wrapper.wrapper(glColor4ubVertex3fvSUN).setInputArraySize( + 'c', 4 +).setInputArraySize( + 'v', 3 +) +glColor3fVertex3fvSUN=wrapper.wrapper(glColor3fVertex3fvSUN).setInputArraySize( + 'c', 3 +).setInputArraySize( + 'v', 3 +) +glNormal3fVertex3fvSUN=wrapper.wrapper(glNormal3fVertex3fvSUN).setInputArraySize( + 'n', 3 +).setInputArraySize( + 'v', 3 +) +glColor4fNormal3fVertex3fvSUN=wrapper.wrapper(glColor4fNormal3fVertex3fvSUN).setInputArraySize( + 'c', 4 +).setInputArraySize( + 'n', 3 +).setInputArraySize( + 'v', 3 +) +glTexCoord2fVertex3fvSUN=wrapper.wrapper(glTexCoord2fVertex3fvSUN).setInputArraySize( + 'tc', 2 +).setInputArraySize( + 'v', 3 +) +glTexCoord4fVertex4fvSUN=wrapper.wrapper(glTexCoord4fVertex4fvSUN).setInputArraySize( + 'tc', 4 +).setInputArraySize( + 'v', 4 +) +glTexCoord2fColor4ubVertex3fvSUN=wrapper.wrapper(glTexCoord2fColor4ubVertex3fvSUN).setInputArraySize( + 'c', 4 +).setInputArraySize( + 'tc', 2 +).setInputArraySize( + 'v', 3 +) +glTexCoord2fColor3fVertex3fvSUN=wrapper.wrapper(glTexCoord2fColor3fVertex3fvSUN).setInputArraySize( + 'c', 3 +).setInputArraySize( + 'tc', 2 +).setInputArraySize( + 'v', 3 +) +glTexCoord2fNormal3fVertex3fvSUN=wrapper.wrapper(glTexCoord2fNormal3fVertex3fvSUN).setInputArraySize( + 'n', 3 +).setInputArraySize( + 'tc', 2 +).setInputArraySize( + 'v', 3 +) +glTexCoord2fColor4fNormal3fVertex3fvSUN=wrapper.wrapper(glTexCoord2fColor4fNormal3fVertex3fvSUN).setInputArraySize( + 'c', 4 +).setInputArraySize( + 'n', 3 +).setInputArraySize( + 'tc', 2 +).setInputArraySize( + 'v', 3 +) +glTexCoord4fColor4fNormal3fVertex4fvSUN=wrapper.wrapper(glTexCoord4fColor4fNormal3fVertex4fvSUN).setInputArraySize( + 'c', 4 +).setInputArraySize( + 'n', 3 +).setInputArraySize( + 'tc', 4 +).setInputArraySize( + 'v', 4 +) +glReplacementCodeuiVertex3fvSUN=wrapper.wrapper(glReplacementCodeuiVertex3fvSUN).setInputArraySize( + 'rc', 1 +).setInputArraySize( + 'v', 3 +) +glReplacementCodeuiColor4ubVertex3fvSUN=wrapper.wrapper(glReplacementCodeuiColor4ubVertex3fvSUN).setInputArraySize( + 'c', 4 +).setInputArraySize( + 'rc', 1 +).setInputArraySize( + 'v', 3 +) +glReplacementCodeuiColor3fVertex3fvSUN=wrapper.wrapper(glReplacementCodeuiColor3fVertex3fvSUN).setInputArraySize( + 'c', 3 +).setInputArraySize( + 'rc', 1 +).setInputArraySize( + 'v', 3 +) +glReplacementCodeuiNormal3fVertex3fvSUN=wrapper.wrapper(glReplacementCodeuiNormal3fVertex3fvSUN).setInputArraySize( + 'n', 3 +).setInputArraySize( + 'rc', 1 +).setInputArraySize( + 'v', 3 +) +glReplacementCodeuiColor4fNormal3fVertex3fvSUN=wrapper.wrapper(glReplacementCodeuiColor4fNormal3fVertex3fvSUN).setInputArraySize( + 'c', 4 +).setInputArraySize( + 'n', 3 +).setInputArraySize( + 'rc', 1 +).setInputArraySize( + 'v', 3 +) +glReplacementCodeuiTexCoord2fVertex3fvSUN=wrapper.wrapper(glReplacementCodeuiTexCoord2fVertex3fvSUN).setInputArraySize( + 'rc', 1 +).setInputArraySize( + 'tc', 2 +).setInputArraySize( + 'v', 3 +) +glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN=wrapper.wrapper(glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN).setInputArraySize( + 'n', 3 +).setInputArraySize( + 'rc', 1 +).setInputArraySize( + 'tc', 2 +).setInputArraySize( + 'v', 3 +) +glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN=wrapper.wrapper(glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN).setInputArraySize( + 'c', 4 +).setInputArraySize( + 'n', 3 +).setInputArraySize( + 'rc', 1 +).setInputArraySize( + 'tc', 2 +).setInputArraySize( + 'v', 3 +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/SUNX/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/GL/SUNX/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/SUNX/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/SUNX/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/SUNX/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..65e08b8b Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/SUNX/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/SUNX/__pycache__/constant_data.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/SUNX/__pycache__/constant_data.cpython-312.pyc new file mode 100644 index 00000000..878a5bea Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/SUNX/__pycache__/constant_data.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/SUNX/constant_data.py b/venv/lib/python3.12/site-packages/OpenGL/GL/SUNX/constant_data.py new file mode 100644 index 00000000..63764b81 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/SUNX/constant_data.py @@ -0,0 +1,32 @@ +'''OpenGL extension SUNX.constant_data + +This module customises the behaviour of the +OpenGL.raw.GL.SUNX.constant_data to provide a more +Python-friendly API + +Overview (from the spec) + + This extension allows the pixel data specified by the + application to be used internally without making a second copy. + This extension affects how the pixel data in client memory is + interpreted and therefore affects DrawPixels, Bitmap, + PolygonStipple, TexImage1D, TexImage2D, TexImage3DEXT, + ColorTableSGI. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/SUNX/constant_data.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.SUNX.constant_data import * +from OpenGL.raw.GL.SUNX.constant_data import _EXTENSION_NAME + +def glInitConstantDataSUNX(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/VERSION/GL_1_0.py b/venv/lib/python3.12/site-packages/OpenGL/GL/VERSION/GL_1_0.py new file mode 100644 index 00000000..b83246a5 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/VERSION/GL_1_0.py @@ -0,0 +1,456 @@ +'''OpenGL extension VERSION.GL_1_0 + +This module customises the behaviour of the +OpenGL.raw.GL.VERSION.GL_1_0 to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/VERSION/GL_1_0.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.VERSION.GL_1_0 import * +from OpenGL.raw.GL.VERSION.GL_1_0 import _EXTENSION_NAME + +def glInitGl10VERSION(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glTexParameterfv.params size not checked against 'pname' +glTexParameterfv=wrapper.wrapper(glTexParameterfv).setInputArraySize( + 'params', None +) +# INPUT glTexParameteriv.params size not checked against 'pname' +glTexParameteriv=wrapper.wrapper(glTexParameteriv).setInputArraySize( + 'params', None +) +# INPUT glTexImage1D.pixels size not checked against 'format,type,width' +glTexImage1D=wrapper.wrapper(glTexImage1D).setInputArraySize( + 'pixels', None +) +# INPUT glTexImage2D.pixels size not checked against 'format,type,width,height' +glTexImage2D=wrapper.wrapper(glTexImage2D).setInputArraySize( + 'pixels', None +) +# OUTPUT glReadPixels.pixels COMPSIZE(format, type, width, height) +glGetBooleanv=wrapper.wrapper(glGetBooleanv).setOutput( + 'data',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetDoublev=wrapper.wrapper(glGetDoublev).setOutput( + 'data',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetFloatv=wrapper.wrapper(glGetFloatv).setOutput( + 'data',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetIntegerv=wrapper.wrapper(glGetIntegerv).setOutput( + 'data',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +# OUTPUT glGetTexImage.pixels COMPSIZE(target, level, format, type) +glGetTexParameterfv=wrapper.wrapper(glGetTexParameterfv).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetTexParameteriv=wrapper.wrapper(glGetTexParameteriv).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetTexLevelParameterfv=wrapper.wrapper(glGetTexLevelParameterfv).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetTexLevelParameteriv=wrapper.wrapper(glGetTexLevelParameteriv).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +# INPUT glCallLists.lists size not checked against 'n,type' +glCallLists=wrapper.wrapper(glCallLists).setInputArraySize( + 'lists', None +) +# INPUT glBitmap.bitmap size not checked against 'width,height' +glBitmap=wrapper.wrapper(glBitmap).setInputArraySize( + 'bitmap', None +) +glColor3bv=wrapper.wrapper(glColor3bv).setInputArraySize( + 'v', 3 +) +glColor3dv=wrapper.wrapper(glColor3dv).setInputArraySize( + 'v', 3 +) +glColor3fv=wrapper.wrapper(glColor3fv).setInputArraySize( + 'v', 3 +) +glColor3iv=wrapper.wrapper(glColor3iv).setInputArraySize( + 'v', 3 +) +glColor3sv=wrapper.wrapper(glColor3sv).setInputArraySize( + 'v', 3 +) +glColor3ubv=wrapper.wrapper(glColor3ubv).setInputArraySize( + 'v', 3 +) +glColor3uiv=wrapper.wrapper(glColor3uiv).setInputArraySize( + 'v', 3 +) +glColor3usv=wrapper.wrapper(glColor3usv).setInputArraySize( + 'v', 3 +) +glColor4bv=wrapper.wrapper(glColor4bv).setInputArraySize( + 'v', 4 +) +glColor4dv=wrapper.wrapper(glColor4dv).setInputArraySize( + 'v', 4 +) +glColor4fv=wrapper.wrapper(glColor4fv).setInputArraySize( + 'v', 4 +) +glColor4iv=wrapper.wrapper(glColor4iv).setInputArraySize( + 'v', 4 +) +glColor4sv=wrapper.wrapper(glColor4sv).setInputArraySize( + 'v', 4 +) +glColor4ubv=wrapper.wrapper(glColor4ubv).setInputArraySize( + 'v', 4 +) +glColor4uiv=wrapper.wrapper(glColor4uiv).setInputArraySize( + 'v', 4 +) +glColor4usv=wrapper.wrapper(glColor4usv).setInputArraySize( + 'v', 4 +) +glEdgeFlagv=wrapper.wrapper(glEdgeFlagv).setInputArraySize( + 'flag', 1 +) +glIndexdv=wrapper.wrapper(glIndexdv).setInputArraySize( + 'c', 1 +) +glIndexfv=wrapper.wrapper(glIndexfv).setInputArraySize( + 'c', 1 +) +glIndexiv=wrapper.wrapper(glIndexiv).setInputArraySize( + 'c', 1 +) +glIndexsv=wrapper.wrapper(glIndexsv).setInputArraySize( + 'c', 1 +) +glNormal3bv=wrapper.wrapper(glNormal3bv).setInputArraySize( + 'v', 3 +) +glNormal3dv=wrapper.wrapper(glNormal3dv).setInputArraySize( + 'v', 3 +) +glNormal3fv=wrapper.wrapper(glNormal3fv).setInputArraySize( + 'v', 3 +) +glNormal3iv=wrapper.wrapper(glNormal3iv).setInputArraySize( + 'v', 3 +) +glNormal3sv=wrapper.wrapper(glNormal3sv).setInputArraySize( + 'v', 3 +) +glRasterPos2dv=wrapper.wrapper(glRasterPos2dv).setInputArraySize( + 'v', 2 +) +glRasterPos2fv=wrapper.wrapper(glRasterPos2fv).setInputArraySize( + 'v', 2 +) +glRasterPos2iv=wrapper.wrapper(glRasterPos2iv).setInputArraySize( + 'v', 2 +) +glRasterPos2sv=wrapper.wrapper(glRasterPos2sv).setInputArraySize( + 'v', 2 +) +glRasterPos3dv=wrapper.wrapper(glRasterPos3dv).setInputArraySize( + 'v', 3 +) +glRasterPos3fv=wrapper.wrapper(glRasterPos3fv).setInputArraySize( + 'v', 3 +) +glRasterPos3iv=wrapper.wrapper(glRasterPos3iv).setInputArraySize( + 'v', 3 +) +glRasterPos3sv=wrapper.wrapper(glRasterPos3sv).setInputArraySize( + 'v', 3 +) +glRasterPos4dv=wrapper.wrapper(glRasterPos4dv).setInputArraySize( + 'v', 4 +) +glRasterPos4fv=wrapper.wrapper(glRasterPos4fv).setInputArraySize( + 'v', 4 +) +glRasterPos4iv=wrapper.wrapper(glRasterPos4iv).setInputArraySize( + 'v', 4 +) +glRasterPos4sv=wrapper.wrapper(glRasterPos4sv).setInputArraySize( + 'v', 4 +) +glRectdv=wrapper.wrapper(glRectdv).setInputArraySize( + 'v1', 2 +).setInputArraySize( + 'v2', 2 +) +glRectfv=wrapper.wrapper(glRectfv).setInputArraySize( + 'v1', 2 +).setInputArraySize( + 'v2', 2 +) +glRectiv=wrapper.wrapper(glRectiv).setInputArraySize( + 'v1', 2 +).setInputArraySize( + 'v2', 2 +) +glRectsv=wrapper.wrapper(glRectsv).setInputArraySize( + 'v1', 2 +).setInputArraySize( + 'v2', 2 +) +glTexCoord1dv=wrapper.wrapper(glTexCoord1dv).setInputArraySize( + 'v', 1 +) +glTexCoord1fv=wrapper.wrapper(glTexCoord1fv).setInputArraySize( + 'v', 1 +) +glTexCoord1iv=wrapper.wrapper(glTexCoord1iv).setInputArraySize( + 'v', 1 +) +glTexCoord1sv=wrapper.wrapper(glTexCoord1sv).setInputArraySize( + 'v', 1 +) +glTexCoord2dv=wrapper.wrapper(glTexCoord2dv).setInputArraySize( + 'v', 2 +) +glTexCoord2fv=wrapper.wrapper(glTexCoord2fv).setInputArraySize( + 'v', 2 +) +glTexCoord2iv=wrapper.wrapper(glTexCoord2iv).setInputArraySize( + 'v', 2 +) +glTexCoord2sv=wrapper.wrapper(glTexCoord2sv).setInputArraySize( + 'v', 2 +) +glTexCoord3dv=wrapper.wrapper(glTexCoord3dv).setInputArraySize( + 'v', 3 +) +glTexCoord3fv=wrapper.wrapper(glTexCoord3fv).setInputArraySize( + 'v', 3 +) +glTexCoord3iv=wrapper.wrapper(glTexCoord3iv).setInputArraySize( + 'v', 3 +) +glTexCoord3sv=wrapper.wrapper(glTexCoord3sv).setInputArraySize( + 'v', 3 +) +glTexCoord4dv=wrapper.wrapper(glTexCoord4dv).setInputArraySize( + 'v', 4 +) +glTexCoord4fv=wrapper.wrapper(glTexCoord4fv).setInputArraySize( + 'v', 4 +) +glTexCoord4iv=wrapper.wrapper(glTexCoord4iv).setInputArraySize( + 'v', 4 +) +glTexCoord4sv=wrapper.wrapper(glTexCoord4sv).setInputArraySize( + 'v', 4 +) +glVertex2dv=wrapper.wrapper(glVertex2dv).setInputArraySize( + 'v', 2 +) +glVertex2fv=wrapper.wrapper(glVertex2fv).setInputArraySize( + 'v', 2 +) +glVertex2iv=wrapper.wrapper(glVertex2iv).setInputArraySize( + 'v', 2 +) +glVertex2sv=wrapper.wrapper(glVertex2sv).setInputArraySize( + 'v', 2 +) +glVertex3dv=wrapper.wrapper(glVertex3dv).setInputArraySize( + 'v', 3 +) +glVertex3fv=wrapper.wrapper(glVertex3fv).setInputArraySize( + 'v', 3 +) +glVertex3iv=wrapper.wrapper(glVertex3iv).setInputArraySize( + 'v', 3 +) +glVertex3sv=wrapper.wrapper(glVertex3sv).setInputArraySize( + 'v', 3 +) +glVertex4dv=wrapper.wrapper(glVertex4dv).setInputArraySize( + 'v', 4 +) +glVertex4fv=wrapper.wrapper(glVertex4fv).setInputArraySize( + 'v', 4 +) +glVertex4iv=wrapper.wrapper(glVertex4iv).setInputArraySize( + 'v', 4 +) +glVertex4sv=wrapper.wrapper(glVertex4sv).setInputArraySize( + 'v', 4 +) +glClipPlane=wrapper.wrapper(glClipPlane).setInputArraySize( + 'equation', 4 +) +# INPUT glFogfv.params size not checked against 'pname' +glFogfv=wrapper.wrapper(glFogfv).setInputArraySize( + 'params', None +) +# INPUT glFogiv.params size not checked against 'pname' +glFogiv=wrapper.wrapper(glFogiv).setInputArraySize( + 'params', None +) +# INPUT glLightfv.params size not checked against 'pname' +glLightfv=wrapper.wrapper(glLightfv).setInputArraySize( + 'params', None +) +# INPUT glLightiv.params size not checked against 'pname' +glLightiv=wrapper.wrapper(glLightiv).setInputArraySize( + 'params', None +) +# INPUT glLightModelfv.params size not checked against 'pname' +glLightModelfv=wrapper.wrapper(glLightModelfv).setInputArraySize( + 'params', None +) +# INPUT glLightModeliv.params size not checked against 'pname' +glLightModeliv=wrapper.wrapper(glLightModeliv).setInputArraySize( + 'params', None +) +# INPUT glMaterialfv.params size not checked against 'pname' +glMaterialfv=wrapper.wrapper(glMaterialfv).setInputArraySize( + 'params', None +) +# INPUT glMaterialiv.params size not checked against 'pname' +glMaterialiv=wrapper.wrapper(glMaterialiv).setInputArraySize( + 'params', None +) +# INPUT glPolygonStipple.mask size not checked against '' +glPolygonStipple=wrapper.wrapper(glPolygonStipple).setInputArraySize( + 'mask', None +) +# INPUT glTexEnvfv.params size not checked against 'pname' +glTexEnvfv=wrapper.wrapper(glTexEnvfv).setInputArraySize( + 'params', None +) +# INPUT glTexEnviv.params size not checked against 'pname' +glTexEnviv=wrapper.wrapper(glTexEnviv).setInputArraySize( + 'params', None +) +# INPUT glTexGendv.params size not checked against 'pname' +glTexGendv=wrapper.wrapper(glTexGendv).setInputArraySize( + 'params', None +) +# INPUT glTexGenfv.params size not checked against 'pname' +glTexGenfv=wrapper.wrapper(glTexGenfv).setInputArraySize( + 'params', None +) +# INPUT glTexGeniv.params size not checked against 'pname' +glTexGeniv=wrapper.wrapper(glTexGeniv).setInputArraySize( + 'params', None +) +glFeedbackBuffer=wrapper.wrapper(glFeedbackBuffer).setOutput( + 'buffer',size=lambda x:(x,),pnameArg='size',orPassIn=True +) +glSelectBuffer=wrapper.wrapper(glSelectBuffer).setOutput( + 'buffer',size=lambda x:(x,),pnameArg='size',orPassIn=True +) +# INPUT glMap1d.points size not checked against 'target,stride,order' +glMap1d=wrapper.wrapper(glMap1d).setInputArraySize( + 'points', None +) +# INPUT glMap1f.points size not checked against 'target,stride,order' +glMap1f=wrapper.wrapper(glMap1f).setInputArraySize( + 'points', None +) +# INPUT glMap2d.points size not checked against 'target,ustride,uorder,vstride,vorder' +glMap2d=wrapper.wrapper(glMap2d).setInputArraySize( + 'points', None +) +# INPUT glMap2f.points size not checked against 'target,ustride,uorder,vstride,vorder' +glMap2f=wrapper.wrapper(glMap2f).setInputArraySize( + 'points', None +) +glEvalCoord1dv=wrapper.wrapper(glEvalCoord1dv).setInputArraySize( + 'u', 1 +) +glEvalCoord1fv=wrapper.wrapper(glEvalCoord1fv).setInputArraySize( + 'u', 1 +) +glEvalCoord2dv=wrapper.wrapper(glEvalCoord2dv).setInputArraySize( + 'u', 2 +) +glEvalCoord2fv=wrapper.wrapper(glEvalCoord2fv).setInputArraySize( + 'u', 2 +) +# INPUT glPixelMapfv.values size not checked against mapsize +glPixelMapfv=wrapper.wrapper(glPixelMapfv).setInputArraySize( + 'values', None +) +# INPUT glPixelMapuiv.values size not checked against mapsize +glPixelMapuiv=wrapper.wrapper(glPixelMapuiv).setInputArraySize( + 'values', None +) +# INPUT glPixelMapusv.values size not checked against mapsize +glPixelMapusv=wrapper.wrapper(glPixelMapusv).setInputArraySize( + 'values', None +) +# INPUT glDrawPixels.pixels size not checked against 'format,type,width,height' +glDrawPixels=wrapper.wrapper(glDrawPixels).setInputArraySize( + 'pixels', None +) +glGetClipPlane=wrapper.wrapper(glGetClipPlane).setOutput( + 'equation',size=(4,),orPassIn=True +) +glGetLightfv=wrapper.wrapper(glGetLightfv).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetLightiv=wrapper.wrapper(glGetLightiv).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +# OUTPUT glGetMapdv.v COMPSIZE(target, query) +# OUTPUT glGetMapfv.v COMPSIZE(target, query) +# OUTPUT glGetMapiv.v COMPSIZE(target, query) +glGetMaterialfv=wrapper.wrapper(glGetMaterialfv).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetMaterialiv=wrapper.wrapper(glGetMaterialiv).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetPixelMapfv=wrapper.wrapper(glGetPixelMapfv).setOutput( + 'values',size=_glgets._glget_size_mapping,pnameArg='map',orPassIn=True +) +glGetPixelMapuiv=wrapper.wrapper(glGetPixelMapuiv).setOutput( + 'values',size=_glgets._glget_size_mapping,pnameArg='map',orPassIn=True +) +glGetPixelMapusv=wrapper.wrapper(glGetPixelMapusv).setOutput( + 'values',size=_glgets._glget_size_mapping,pnameArg='map',orPassIn=True +) +glGetPolygonStipple=wrapper.wrapper(glGetPolygonStipple).setOutput( + 'mask',size=lambda x:(x,),pnameArg='128.0',orPassIn=True +) +glGetTexEnvfv=wrapper.wrapper(glGetTexEnvfv).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetTexEnviv=wrapper.wrapper(glGetTexEnviv).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetTexGendv=wrapper.wrapper(glGetTexGendv).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetTexGenfv=wrapper.wrapper(glGetTexGenfv).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetTexGeniv=wrapper.wrapper(glGetTexGeniv).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glLoadMatrixf=wrapper.wrapper(glLoadMatrixf).setInputArraySize( + 'm', 16 +) +glLoadMatrixd=wrapper.wrapper(glLoadMatrixd).setInputArraySize( + 'm', 16 +) +glMultMatrixf=wrapper.wrapper(glMultMatrixf).setInputArraySize( + 'm', 16 +) +glMultMatrixd=wrapper.wrapper(glMultMatrixd).setInputArraySize( + 'm', 16 +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/VERSION/GL_1_1.py b/venv/lib/python3.12/site-packages/OpenGL/GL/VERSION/GL_1_1.py new file mode 100644 index 00000000..cb74de46 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/VERSION/GL_1_1.py @@ -0,0 +1,100 @@ +'''OpenGL extension VERSION.GL_1_1 + +This module customises the behaviour of the +OpenGL.raw.GL.VERSION.GL_1_1 to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/VERSION/GL_1_1.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.VERSION.GL_1_1 import * +from OpenGL.raw.GL.VERSION.GL_1_1 import _EXTENSION_NAME + +def glInitGl11VERSION(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glDrawElements.indices size not checked against 'count,type' +glDrawElements=wrapper.wrapper(glDrawElements).setInputArraySize( + 'indices', None +) +glGetPointerv=wrapper.wrapper(glGetPointerv).setOutput( + 'params',size=(1,),orPassIn=True +) +# INPUT glTexSubImage1D.pixels size not checked against 'format,type,width' +glTexSubImage1D=wrapper.wrapper(glTexSubImage1D).setInputArraySize( + 'pixels', None +) +# INPUT glTexSubImage2D.pixels size not checked against 'format,type,width,height' +glTexSubImage2D=wrapper.wrapper(glTexSubImage2D).setInputArraySize( + 'pixels', None +) +# INPUT glDeleteTextures.textures size not checked against n +glDeleteTextures=wrapper.wrapper(glDeleteTextures).setInputArraySize( + 'textures', None +) +glGenTextures=wrapper.wrapper(glGenTextures).setOutput( + 'textures',size=lambda x:(x,),pnameArg='n',orPassIn=True +) +# INPUT glColorPointer.pointer size not checked against 'size,type,stride' +glColorPointer=wrapper.wrapper(glColorPointer).setInputArraySize( + 'pointer', None +) +# INPUT glEdgeFlagPointer.pointer size not checked against 'stride' +glEdgeFlagPointer=wrapper.wrapper(glEdgeFlagPointer).setInputArraySize( + 'pointer', None +) +# INPUT glIndexPointer.pointer size not checked against 'type,stride' +glIndexPointer=wrapper.wrapper(glIndexPointer).setInputArraySize( + 'pointer', None +) +# INPUT glInterleavedArrays.pointer size not checked against 'format,stride' +glInterleavedArrays=wrapper.wrapper(glInterleavedArrays).setInputArraySize( + 'pointer', None +) +# INPUT glNormalPointer.pointer size not checked against 'type,stride' +glNormalPointer=wrapper.wrapper(glNormalPointer).setInputArraySize( + 'pointer', None +) +# INPUT glTexCoordPointer.pointer size not checked against 'size,type,stride' +glTexCoordPointer=wrapper.wrapper(glTexCoordPointer).setInputArraySize( + 'pointer', None +) +# INPUT glVertexPointer.pointer size not checked against 'size,type,stride' +glVertexPointer=wrapper.wrapper(glVertexPointer).setInputArraySize( + 'pointer', None +) +# INPUT glAreTexturesResident.textures size not checked against n +glAreTexturesResident=wrapper.wrapper(glAreTexturesResident).setOutput( + 'residences',size=lambda x:(x,),pnameArg='n',orPassIn=True +).setInputArraySize( + 'textures', None +) +# INPUT glPrioritizeTextures.priorities size not checked against n +# INPUT glPrioritizeTextures.textures size not checked against n +glPrioritizeTextures=wrapper.wrapper(glPrioritizeTextures).setInputArraySize( + 'priorities', None +).setInputArraySize( + 'textures', None +) +glIndexubv=wrapper.wrapper(glIndexubv).setInputArraySize( + 'c', 1 +) +### END AUTOGENERATED SECTION +from OpenGL.GL.VERSION.GL_1_0 import * +GL_MODELVIEW0_EXT = GL_MODELVIEW # alias +GL_MODELVIEW0_MATRIX_EXT = GL_MODELVIEW_MATRIX # alias +GL_MODELVIEW0_STACK_DEPTH_EXT = GL_MODELVIEW_STACK_DEPTH # alias +GL_TEXTURE_COMPONENTS = GL_TEXTURE_INTERNAL_FORMAT # alias + +# See: http://lists.freedesktop.org/archives/mesa-dev/2011-October/013095.html +# basically these names were present for a while in the .spec files but were not +# actually used officially, the mapped values here are what is supposed to get +# used instead. +GL_DEPTH_BUFFER = GL_DEPTH +GL_STENCIL_BUFFER = GL_STENCIL diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/VERSION/GL_1_2.py b/venv/lib/python3.12/site-packages/OpenGL/GL/VERSION/GL_1_2.py new file mode 100644 index 00000000..bfe23e18 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/VERSION/GL_1_2.py @@ -0,0 +1,49 @@ +'''OpenGL extension VERSION.GL_1_2 + +This module customises the behaviour of the +OpenGL.raw.GL.VERSION.GL_1_2 to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/VERSION/GL_1_2.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.VERSION.GL_1_2 import * +from OpenGL.raw.GL.VERSION.GL_1_2 import _EXTENSION_NAME + +def glInitGl12VERSION(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glDrawRangeElements.indices size not checked against 'count,type' +glDrawRangeElements=wrapper.wrapper(glDrawRangeElements).setInputArraySize( + 'indices', None +) +# INPUT glTexImage3D.pixels size not checked against 'format,type,width,height,depth' +glTexImage3D=wrapper.wrapper(glTexImage3D).setInputArraySize( + 'pixels', None +) +# INPUT glTexSubImage3D.pixels size not checked against 'format,type,width,height,depth' +glTexSubImage3D=wrapper.wrapper(glTexSubImage3D).setInputArraySize( + 'pixels', None +) +### END AUTOGENERATED SECTION +from OpenGL.GL.ARB.imaging import * +from OpenGL.GL.VERSION.GL_1_2_images import * + +GL_POINT_SIZE_GRANULARITY = GL_SMOOTH_POINT_SIZE_GRANULARITY # alias +GL_POINT_SIZE_RANGE = GL_SMOOTH_POINT_SIZE_RANGE # alias +GL_LINE_WIDTH_GRANULARITY = GL_SMOOTH_LINE_WIDTH_GRANULARITY # alias +GL_LINE_WIDTH_RANGE = GL_SMOOTH_LINE_WIDTH_RANGE # alias + +glDrawRangeElements = wrapper.wrapper( glDrawRangeElements ).setPyConverter( + 'indices', arrays.AsArrayOfType( 'indices', 'type' ), +).setReturnValues( + wrapper.returnPyArgument( 'indices' ) +) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/VERSION/GL_1_2_images.py b/venv/lib/python3.12/site-packages/OpenGL/GL/VERSION/GL_1_2_images.py new file mode 100644 index 00000000..8b385ff1 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/VERSION/GL_1_2_images.py @@ -0,0 +1,55 @@ +"""Version 1.2 Image-handling functions + +Almost all of the 1.2 enhancements are image-handling-related, +so this is, most of the 1.2 wrapper code... + +Note that the functions that manually wrap certain operations are +guarded by if simple.functionName checks, so that you can use +if functionName to see if the function is available at run-time. +""" +from OpenGL import wrapper, constants, arrays +from OpenGL.raw.GL.ARB import imaging +from OpenGL.raw.GL.VERSION import GL_1_2 as _simple +from OpenGL.GL.ARB.imaging import * + +from OpenGL.GL import images +import ctypes + +for suffix,arrayConstant in [ + ('b', constants.GL_BYTE), + ('f', constants.GL_FLOAT), + ('i', constants.GL_INT), + ('s', constants.GL_SHORT), + ('ub', constants.GL_UNSIGNED_BYTE), + ('ui', constants.GL_UNSIGNED_INT), + ('us', constants.GL_UNSIGNED_SHORT), +]: + for functionName in ( + 'glTexImage3D', + 'glTexSubImage3D', # extension/1.2 standard + ): + functionName, function = images.typedImageFunction( + suffix, arrayConstant, getattr(_simple, functionName), + ) + globals()[functionName] = function + try: + del function, functionName + except NameError as err: + pass + try: + del suffix,arrayConstant + except NameError as err: + pass + +glTexImage3D = images.setDimensionsAsInts( + images.setImageInput( + _simple.glTexImage3D, + typeName = 'type', + ) +) +glTexSubImage3D = images.setDimensionsAsInts( + images.setImageInput( + _simple.glTexSubImage3D, + typeName = 'type', + ) +) diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/VERSION/GL_1_3.py b/venv/lib/python3.12/site-packages/OpenGL/GL/VERSION/GL_1_3.py new file mode 100644 index 00000000..1e3e5dde --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/VERSION/GL_1_3.py @@ -0,0 +1,143 @@ +'''OpenGL extension VERSION.GL_1_3 + +This module customises the behaviour of the +OpenGL.raw.GL.VERSION.GL_1_3 to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/VERSION/GL_1_3.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.VERSION.GL_1_3 import * +from OpenGL.raw.GL.VERSION.GL_1_3 import _EXTENSION_NAME + +def glInitGl13VERSION(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glCompressedTexImage3D.data size not checked against imageSize +glCompressedTexImage3D=wrapper.wrapper(glCompressedTexImage3D).setInputArraySize( + 'data', None +) +# INPUT glCompressedTexImage2D.data size not checked against imageSize +glCompressedTexImage2D=wrapper.wrapper(glCompressedTexImage2D).setInputArraySize( + 'data', None +) +# INPUT glCompressedTexImage1D.data size not checked against imageSize +glCompressedTexImage1D=wrapper.wrapper(glCompressedTexImage1D).setInputArraySize( + 'data', None +) +# INPUT glCompressedTexSubImage3D.data size not checked against imageSize +glCompressedTexSubImage3D=wrapper.wrapper(glCompressedTexSubImage3D).setInputArraySize( + 'data', None +) +# INPUT glCompressedTexSubImage2D.data size not checked against imageSize +glCompressedTexSubImage2D=wrapper.wrapper(glCompressedTexSubImage2D).setInputArraySize( + 'data', None +) +# INPUT glCompressedTexSubImage1D.data size not checked against imageSize +glCompressedTexSubImage1D=wrapper.wrapper(glCompressedTexSubImage1D).setInputArraySize( + 'data', None +) +# OUTPUT glGetCompressedTexImage.img COMPSIZE(target, level) +glMultiTexCoord1dv=wrapper.wrapper(glMultiTexCoord1dv).setInputArraySize( + 'v', 1 +) +glMultiTexCoord1fv=wrapper.wrapper(glMultiTexCoord1fv).setInputArraySize( + 'v', 1 +) +glMultiTexCoord1iv=wrapper.wrapper(glMultiTexCoord1iv).setInputArraySize( + 'v', 1 +) +glMultiTexCoord1sv=wrapper.wrapper(glMultiTexCoord1sv).setInputArraySize( + 'v', 1 +) +glMultiTexCoord2dv=wrapper.wrapper(glMultiTexCoord2dv).setInputArraySize( + 'v', 2 +) +glMultiTexCoord2fv=wrapper.wrapper(glMultiTexCoord2fv).setInputArraySize( + 'v', 2 +) +glMultiTexCoord2iv=wrapper.wrapper(glMultiTexCoord2iv).setInputArraySize( + 'v', 2 +) +glMultiTexCoord2sv=wrapper.wrapper(glMultiTexCoord2sv).setInputArraySize( + 'v', 2 +) +glMultiTexCoord3dv=wrapper.wrapper(glMultiTexCoord3dv).setInputArraySize( + 'v', 3 +) +glMultiTexCoord3fv=wrapper.wrapper(glMultiTexCoord3fv).setInputArraySize( + 'v', 3 +) +glMultiTexCoord3iv=wrapper.wrapper(glMultiTexCoord3iv).setInputArraySize( + 'v', 3 +) +glMultiTexCoord3sv=wrapper.wrapper(glMultiTexCoord3sv).setInputArraySize( + 'v', 3 +) +glMultiTexCoord4dv=wrapper.wrapper(glMultiTexCoord4dv).setInputArraySize( + 'v', 4 +) +glMultiTexCoord4fv=wrapper.wrapper(glMultiTexCoord4fv).setInputArraySize( + 'v', 4 +) +glMultiTexCoord4iv=wrapper.wrapper(glMultiTexCoord4iv).setInputArraySize( + 'v', 4 +) +glMultiTexCoord4sv=wrapper.wrapper(glMultiTexCoord4sv).setInputArraySize( + 'v', 4 +) +glLoadTransposeMatrixf=wrapper.wrapper(glLoadTransposeMatrixf).setInputArraySize( + 'm', 16 +) +glLoadTransposeMatrixd=wrapper.wrapper(glLoadTransposeMatrixd).setInputArraySize( + 'm', 16 +) +glMultTransposeMatrixf=wrapper.wrapper(glMultTransposeMatrixf).setInputArraySize( + 'm', 16 +) +glMultTransposeMatrixd=wrapper.wrapper(glMultTransposeMatrixd).setInputArraySize( + 'm', 16 +) +### END AUTOGENERATED SECTION +GL_SRC0_ALPHA = GL_SOURCE0_ALPHA # alias +GL_SRC0_RGB = GL_SOURCE0_RGB # alias +GL_SRC1_ALPHA = GL_SOURCE1_ALPHA # alias +GL_SRC1_RGB = GL_SOURCE1_RGB # alias +GL_SRC2_ALPHA = GL_SOURCE2_ALPHA # alias +GL_SRC2_RGB = GL_SOURCE2_RGB # alias + +from OpenGL import wrapper +from OpenGL.raw.GL.VERSION import GL_1_3 as _simple +from OpenGL.GL import images, glget + +for dimensions in (1,2,3): + for function in ('glCompressedTexImage%sD','glCompressedTexSubImage%sD'): + name = function%(dimensions,) + globals()[ name ] = images.compressedImageFunction( + getattr( _simple, name ) + ) + try: + del name, function + except NameError as err: + pass + try: + del dimensions + except NameError as err: + pass + +if _simple.glGetCompressedTexImage: + def glGetCompressedTexImage( target, level, img=None ): + """Retrieve a compressed texture image""" + if img is None: + length = glget.glGetTexLevelParameteriv( + target, 0, + _simple.GL_TEXTURE_COMPRESSED_IMAGE_SIZE_ARB, + ) + img = arrays.ArrayDataType.zeros( (length,), constants.GL_UNSIGNED_BYTE ) + return _simple.glGetCompressedTexImage(target, 0, img); diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/VERSION/GL_1_4.py b/venv/lib/python3.12/site-packages/OpenGL/GL/VERSION/GL_1_4.py new file mode 100644 index 00000000..21c70169 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/VERSION/GL_1_4.py @@ -0,0 +1,113 @@ +'''OpenGL extension VERSION.GL_1_4 + +This module customises the behaviour of the +OpenGL.raw.GL.VERSION.GL_1_4 to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/VERSION/GL_1_4.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.VERSION.GL_1_4 import * +from OpenGL.raw.GL.VERSION.GL_1_4 import _EXTENSION_NAME + +def glInitGl14VERSION(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glMultiDrawArrays.count size not checked against 'drawcount' +# INPUT glMultiDrawArrays.first size not checked against 'count' +glMultiDrawArrays=wrapper.wrapper(glMultiDrawArrays).setInputArraySize( + 'count', None +).setInputArraySize( + 'first', None +) +# INPUT glMultiDrawElements.count size not checked against 'drawcount' +# INPUT glMultiDrawElements.indices size not checked against 'drawcount' +glMultiDrawElements=wrapper.wrapper(glMultiDrawElements).setInputArraySize( + 'count', None +).setInputArraySize( + 'indices', None +) +# INPUT glPointParameterfv.params size not checked against 'pname' +glPointParameterfv=wrapper.wrapper(glPointParameterfv).setInputArraySize( + 'params', None +) +# INPUT glPointParameteriv.params size not checked against 'pname' +glPointParameteriv=wrapper.wrapper(glPointParameteriv).setInputArraySize( + 'params', None +) +glFogCoordfv=wrapper.wrapper(glFogCoordfv).setInputArraySize( + 'coord', 1 +) +glFogCoorddv=wrapper.wrapper(glFogCoorddv).setInputArraySize( + 'coord', 1 +) +# INPUT glFogCoordPointer.pointer size not checked against 'type,stride' +glFogCoordPointer=wrapper.wrapper(glFogCoordPointer).setInputArraySize( + 'pointer', None +) +glSecondaryColor3bv=wrapper.wrapper(glSecondaryColor3bv).setInputArraySize( + 'v', 3 +) +glSecondaryColor3dv=wrapper.wrapper(glSecondaryColor3dv).setInputArraySize( + 'v', 3 +) +glSecondaryColor3fv=wrapper.wrapper(glSecondaryColor3fv).setInputArraySize( + 'v', 3 +) +glSecondaryColor3iv=wrapper.wrapper(glSecondaryColor3iv).setInputArraySize( + 'v', 3 +) +glSecondaryColor3sv=wrapper.wrapper(glSecondaryColor3sv).setInputArraySize( + 'v', 3 +) +glSecondaryColor3ubv=wrapper.wrapper(glSecondaryColor3ubv).setInputArraySize( + 'v', 3 +) +glSecondaryColor3uiv=wrapper.wrapper(glSecondaryColor3uiv).setInputArraySize( + 'v', 3 +) +glSecondaryColor3usv=wrapper.wrapper(glSecondaryColor3usv).setInputArraySize( + 'v', 3 +) +# INPUT glSecondaryColorPointer.pointer size not checked against 'size,type,stride' +glSecondaryColorPointer=wrapper.wrapper(glSecondaryColorPointer).setInputArraySize( + 'pointer', None +) +glWindowPos2dv=wrapper.wrapper(glWindowPos2dv).setInputArraySize( + 'v', 2 +) +glWindowPos2fv=wrapper.wrapper(glWindowPos2fv).setInputArraySize( + 'v', 2 +) +glWindowPos2iv=wrapper.wrapper(glWindowPos2iv).setInputArraySize( + 'v', 2 +) +glWindowPos2sv=wrapper.wrapper(glWindowPos2sv).setInputArraySize( + 'v', 2 +) +glWindowPos3dv=wrapper.wrapper(glWindowPos3dv).setInputArraySize( + 'v', 3 +) +glWindowPos3fv=wrapper.wrapper(glWindowPos3fv).setInputArraySize( + 'v', 3 +) +glWindowPos3iv=wrapper.wrapper(glWindowPos3iv).setInputArraySize( + 'v', 3 +) +glWindowPos3sv=wrapper.wrapper(glWindowPos3sv).setInputArraySize( + 'v', 3 +) +### END AUTOGENERATED SECTION +GL_CURRENT_FOG_COORD = GL_CURRENT_FOG_COORDINATE # alias +GL_FOG_COORD = GL_FOG_COORDINATE # alias +GL_FOG_COORD_ARRAY = GL_FOG_COORDINATE_ARRAY # alias +GL_FOG_COORD_ARRAY_POINTER = GL_FOG_COORDINATE_ARRAY_POINTER # alias +GL_FOG_COORD_ARRAY_STRIDE = GL_FOG_COORDINATE_ARRAY_STRIDE # alias +GL_FOG_COORD_ARRAY_TYPE = GL_FOG_COORDINATE_ARRAY_TYPE # alias +GL_FOG_COORD_SRC = GL_FOG_COORDINATE_SOURCE # alias diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/VERSION/GL_1_5.py b/venv/lib/python3.12/site-packages/OpenGL/GL/VERSION/GL_1_5.py new file mode 100644 index 00000000..fbf15846 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/VERSION/GL_1_5.py @@ -0,0 +1,157 @@ +'''OpenGL extension VERSION.GL_1_5 + +This module customises the behaviour of the +OpenGL.raw.GL.VERSION.GL_1_5 to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/VERSION/GL_1_5.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.VERSION.GL_1_5 import * +from OpenGL.raw.GL.VERSION.GL_1_5 import _EXTENSION_NAME + +def glInitGl15VERSION(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +glGenQueries=wrapper.wrapper(glGenQueries).setOutput( + 'ids',size=lambda x:(x,),pnameArg='n',orPassIn=True +) +# INPUT glDeleteQueries.ids size not checked against n +glDeleteQueries=wrapper.wrapper(glDeleteQueries).setInputArraySize( + 'ids', None +) +glGetQueryiv=wrapper.wrapper(glGetQueryiv).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetQueryObjectiv=wrapper.wrapper(glGetQueryObjectiv).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetQueryObjectuiv=wrapper.wrapper(glGetQueryObjectuiv).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +# INPUT glDeleteBuffers.buffers size not checked against n +glDeleteBuffers=wrapper.wrapper(glDeleteBuffers).setInputArraySize( + 'buffers', None +) +glGenBuffers=wrapper.wrapper(glGenBuffers).setOutput( + 'buffers',size=lambda x:(x,),pnameArg='n',orPassIn=True +) +# INPUT glBufferData.data size not checked against size +glBufferData=wrapper.wrapper(glBufferData).setInputArraySize( + 'data', None +) +# INPUT glBufferSubData.data size not checked against size +glBufferSubData=wrapper.wrapper(glBufferSubData).setInputArraySize( + 'data', None +) +glGetBufferSubData=wrapper.wrapper(glGetBufferSubData).setOutput( + 'data',size=lambda x:(x,),pnameArg='size',orPassIn=True +) +glGetBufferParameteriv=wrapper.wrapper(glGetBufferParameteriv).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetBufferPointerv=wrapper.wrapper(glGetBufferPointerv).setOutput( + 'params',size=(1,),orPassIn=True +) +### END AUTOGENERATED SECTION +from OpenGL.lazywrapper import lazy as _lazy +from OpenGL.arrays import ArrayDatatype +from OpenGL._bytes import integer_types + +@_lazy( glBufferData ) +def glBufferData( baseOperation, target, size, data=None, usage=None ): + """Copy given data into the currently bound vertex-buffer-data object + + target -- the symbolic constant indicating which buffer type is intended + size -- if provided, the count-in-bytes of the array + data -- data-pointer to be used, may be None to initialize without + copying over a data-set + usage -- hint to the driver as to how to set up access to the buffer + + Note: parameter "size" can be omitted, which makes the signature + glBufferData( target, data, usage ) + instead of: + glBufferData( target, size, data, usage ) + """ + if usage is None: + usage = data + data = size + size = None + data = ArrayDatatype.asArray( data ) + if size is None: + size = ArrayDatatype.arrayByteCount( data ) + return baseOperation( target, size, data, usage ) + +@_lazy( glBufferSubData ) +def glBufferSubData( baseOperation, target, offset, size=None, data=None ): + """Copy subset of data into the currently bound vertex-buffer-data object + + target -- the symbolic constant indicating which buffer type is intended + offset -- offset from beginning of buffer at which to copy bytes + size -- the count-in-bytes of the array (if an int/long), if None, + calculate size from data, if an array and data is None, use as + data (i.e. the parameter can be omitted and calculated) + data -- data-pointer to be used, may be None to initialize without + copying over a data-set + + Note that if size is not an int/long it is considered to be data + *iff* data is None + """ + if size is None: + if data is None: + raise TypeError( "Need data or size" ) + elif (not isinstance( size, integer_types)) and (data is None): + data = size + size = None + try: + if size is not None: + size = int( size ) + except TypeError: + if data is not None: + raise TypeError( + """Expect an integer size *or* a data-array, not both""" + ) + data = size + size = None + data = ArrayDatatype.asArray( data ) + if size is None: + size = ArrayDatatype.arrayByteCount( data ) + return baseOperation( target, offset, size, data ) + +@_lazy( glGetBufferPointerv ) +def glGetBufferPointerv( baseOperation, target, pname, params=None ): + """Retrieve a ctypes pointer to buffer's data""" + if params is None: + size = glGetBufferParameteriv( target, GL_BUFFER_SIZE ) + data = arrays.ArrayDatatype.zeros( (size,), GL_UNSIGNED_BYTE ) + baseOperation( target, pname, ctypes.byref( data ) ) + return data + else: + return baseOperation( target, pname, params ) + +@_lazy( glDeleteQueries ) +def glDeleteQueries( baseOperation, n, ids=None ): + if ids is None: + ids = arrays.GLuintArray.asArray( n ) + n = arrays.GLuintArray.arraySize( ids ) + else: + ids = arrays.GLuintArray.asArray( ids ) + return baseOperation( n,ids ) +@_lazy( glGenQueries ) +def glGenQueries( baseOperation, n, ids=None ): + """Generate n queries, if ids is None, is allocated + + returns array of ids + """ + if ids is None: + ids = arrays.GLuintArray.zeros( (n,)) + else: + ids = arrays.GLuintArray.asArray( ids ) + baseOperation( n, ids ) + return ids diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/VERSION/GL_2_0.py b/venv/lib/python3.12/site-packages/OpenGL/GL/VERSION/GL_2_0.py new file mode 100644 index 00000000..d6a87072 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/VERSION/GL_2_0.py @@ -0,0 +1,489 @@ +'''OpenGL extension VERSION.GL_2_0 + +This module customises the behaviour of the +OpenGL.raw.GL.VERSION.GL_2_0 to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/VERSION/GL_2_0.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.VERSION.GL_2_0 import * +from OpenGL.raw.GL.VERSION.GL_2_0 import _EXTENSION_NAME + +def glInitGl20VERSION(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glDrawBuffers.bufs size not checked against n +glDrawBuffers=wrapper.wrapper(glDrawBuffers).setInputArraySize( + 'bufs', None +) +glGetActiveAttrib=wrapper.wrapper(glGetActiveAttrib).setOutput( + 'length',size=(1,),orPassIn=True +).setOutput( + 'name',size=lambda x:(x,),pnameArg='bufSize',orPassIn=True +).setOutput( + 'size',size=(1,),orPassIn=True +).setOutput( + 'type',size=(1,),orPassIn=True +) +glGetActiveUniform=wrapper.wrapper(glGetActiveUniform).setOutput( + 'length',size=(1,),orPassIn=True +).setOutput( + 'name',size=lambda x:(x,),pnameArg='bufSize',orPassIn=True +).setOutput( + 'size',size=(1,),orPassIn=True +).setOutput( + 'type',size=(1,),orPassIn=True +) +# glGetAttachedShaders.obj is OUTPUT without known output size +# INPUT glGetAttachedShaders.shaders size not checked against maxCount +glGetAttachedShaders=wrapper.wrapper(glGetAttachedShaders).setOutput( + 'count',size=(1,),orPassIn=True +).setInputArraySize( + 'shaders', None +) +glGetProgramiv=wrapper.wrapper(glGetProgramiv).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetProgramInfoLog=wrapper.wrapper(glGetProgramInfoLog).setOutput( + 'infoLog',size=lambda x:(x,),pnameArg='bufSize',orPassIn=True +).setOutput( + 'length',size=(1,),orPassIn=True +) +glGetShaderiv=wrapper.wrapper(glGetShaderiv).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetShaderInfoLog=wrapper.wrapper(glGetShaderInfoLog).setOutput( + 'infoLog',size=lambda x:(x,),pnameArg='bufSize',orPassIn=True +).setOutput( + 'length',size=(1,),orPassIn=True +) +glGetShaderSource=wrapper.wrapper(glGetShaderSource).setOutput( + 'length',size=(1,),orPassIn=True +).setOutput( + 'source',size=lambda x:(x,),pnameArg='bufSize',orPassIn=True +) +# glGetUniformfv.params is OUTPUT without known output size +# glGetUniformiv.params is OUTPUT without known output size +glGetVertexAttribdv=wrapper.wrapper(glGetVertexAttribdv).setOutput( + 'params',size=(4,),orPassIn=True +) +glGetVertexAttribfv=wrapper.wrapper(glGetVertexAttribfv).setOutput( + 'params',size=(4,),orPassIn=True +) +glGetVertexAttribiv=wrapper.wrapper(glGetVertexAttribiv).setOutput( + 'params',size=(4,),orPassIn=True +) +glGetVertexAttribPointerv=wrapper.wrapper(glGetVertexAttribPointerv).setOutput( + 'pointer',size=(1,),orPassIn=True +) +# INPUT glShaderSource.length size not checked against count +# INPUT glShaderSource.string size not checked against count +glShaderSource=wrapper.wrapper(glShaderSource).setInputArraySize( + 'length', None +).setInputArraySize( + 'string', None +) +# INPUT glUniform1fv.value size not checked against count +glUniform1fv=wrapper.wrapper(glUniform1fv).setInputArraySize( + 'value', None +) +# INPUT glUniform2fv.value size not checked against count*2 +glUniform2fv=wrapper.wrapper(glUniform2fv).setInputArraySize( + 'value', None +) +# INPUT glUniform3fv.value size not checked against count*3 +glUniform3fv=wrapper.wrapper(glUniform3fv).setInputArraySize( + 'value', None +) +# INPUT glUniform4fv.value size not checked against count*4 +glUniform4fv=wrapper.wrapper(glUniform4fv).setInputArraySize( + 'value', None +) +# INPUT glUniform1iv.value size not checked against count +glUniform1iv=wrapper.wrapper(glUniform1iv).setInputArraySize( + 'value', None +) +# INPUT glUniform2iv.value size not checked against count*2 +glUniform2iv=wrapper.wrapper(glUniform2iv).setInputArraySize( + 'value', None +) +# INPUT glUniform3iv.value size not checked against count*3 +glUniform3iv=wrapper.wrapper(glUniform3iv).setInputArraySize( + 'value', None +) +# INPUT glUniform4iv.value size not checked against count*4 +glUniform4iv=wrapper.wrapper(glUniform4iv).setInputArraySize( + 'value', None +) +# INPUT glUniformMatrix2fv.value size not checked against count*4 +glUniformMatrix2fv=wrapper.wrapper(glUniformMatrix2fv).setInputArraySize( + 'value', None +) +# INPUT glUniformMatrix3fv.value size not checked against count*9 +glUniformMatrix3fv=wrapper.wrapper(glUniformMatrix3fv).setInputArraySize( + 'value', None +) +# INPUT glUniformMatrix4fv.value size not checked against count*16 +glUniformMatrix4fv=wrapper.wrapper(glUniformMatrix4fv).setInputArraySize( + 'value', None +) +glVertexAttrib1dv=wrapper.wrapper(glVertexAttrib1dv).setInputArraySize( + 'v', 1 +) +glVertexAttrib1fv=wrapper.wrapper(glVertexAttrib1fv).setInputArraySize( + 'v', 1 +) +glVertexAttrib1sv=wrapper.wrapper(glVertexAttrib1sv).setInputArraySize( + 'v', 1 +) +glVertexAttrib2dv=wrapper.wrapper(glVertexAttrib2dv).setInputArraySize( + 'v', 2 +) +glVertexAttrib2fv=wrapper.wrapper(glVertexAttrib2fv).setInputArraySize( + 'v', 2 +) +glVertexAttrib2sv=wrapper.wrapper(glVertexAttrib2sv).setInputArraySize( + 'v', 2 +) +glVertexAttrib3dv=wrapper.wrapper(glVertexAttrib3dv).setInputArraySize( + 'v', 3 +) +glVertexAttrib3fv=wrapper.wrapper(glVertexAttrib3fv).setInputArraySize( + 'v', 3 +) +glVertexAttrib3sv=wrapper.wrapper(glVertexAttrib3sv).setInputArraySize( + 'v', 3 +) +glVertexAttrib4Nbv=wrapper.wrapper(glVertexAttrib4Nbv).setInputArraySize( + 'v', 4 +) +glVertexAttrib4Niv=wrapper.wrapper(glVertexAttrib4Niv).setInputArraySize( + 'v', 4 +) +glVertexAttrib4Nsv=wrapper.wrapper(glVertexAttrib4Nsv).setInputArraySize( + 'v', 4 +) +glVertexAttrib4Nubv=wrapper.wrapper(glVertexAttrib4Nubv).setInputArraySize( + 'v', 4 +) +glVertexAttrib4Nuiv=wrapper.wrapper(glVertexAttrib4Nuiv).setInputArraySize( + 'v', 4 +) +glVertexAttrib4Nusv=wrapper.wrapper(glVertexAttrib4Nusv).setInputArraySize( + 'v', 4 +) +glVertexAttrib4bv=wrapper.wrapper(glVertexAttrib4bv).setInputArraySize( + 'v', 4 +) +glVertexAttrib4dv=wrapper.wrapper(glVertexAttrib4dv).setInputArraySize( + 'v', 4 +) +glVertexAttrib4fv=wrapper.wrapper(glVertexAttrib4fv).setInputArraySize( + 'v', 4 +) +glVertexAttrib4iv=wrapper.wrapper(glVertexAttrib4iv).setInputArraySize( + 'v', 4 +) +glVertexAttrib4sv=wrapper.wrapper(glVertexAttrib4sv).setInputArraySize( + 'v', 4 +) +glVertexAttrib4ubv=wrapper.wrapper(glVertexAttrib4ubv).setInputArraySize( + 'v', 4 +) +glVertexAttrib4uiv=wrapper.wrapper(glVertexAttrib4uiv).setInputArraySize( + 'v', 4 +) +glVertexAttrib4usv=wrapper.wrapper(glVertexAttrib4usv).setInputArraySize( + 'v', 4 +) +# INPUT glVertexAttribPointer.pointer size not checked against 'size,type,stride' +glVertexAttribPointer=wrapper.wrapper(glVertexAttribPointer).setInputArraySize( + 'pointer', None +) +### END AUTOGENERATED SECTION +import OpenGL +from OpenGL import _configflags +from OpenGL._bytes import bytes, _NULL_8_BYTE, as_8_bit +from OpenGL.raw.GL.ARB.shader_objects import GL_OBJECT_COMPILE_STATUS_ARB as GL_OBJECT_COMPILE_STATUS +from OpenGL.raw.GL.ARB.shader_objects import GL_OBJECT_LINK_STATUS_ARB as GL_OBJECT_LINK_STATUS +from OpenGL.raw.GL.ARB.shader_objects import GL_OBJECT_ACTIVE_UNIFORMS_ARB as GL_OBJECT_ACTIVE_UNIFORMS +from OpenGL.raw.GL.ARB.shader_objects import GL_OBJECT_ACTIVE_UNIFORM_MAX_LENGTH_ARB as GL_OBJECT_ACTIVE_UNIFORM_MAX_LENGTH +from OpenGL.lazywrapper import lazy as _lazy +from OpenGL.raw.GL import _errors + +from OpenGL import converters, error, contextdata +from OpenGL.arrays.arraydatatype import ArrayDatatype, GLenumArray +GL_INFO_LOG_LENGTH = constant.Constant( 'GL_INFO_LOG_LENGTH', 0x8B84 ) + +glShaderSource = platform.createExtensionFunction( + 'glShaderSource', dll=platform.PLATFORM.GL, + resultType=None, + argTypes=(_types.GLhandle, _types.GLsizei, ctypes.POINTER(ctypes.c_char_p), arrays.GLintArray,), + doc = 'glShaderSource( GLhandle(shaderObj),[bytes(string),...]) -> None', + argNames = ('shaderObj', 'count', 'string', 'length',), + extension = _EXTENSION_NAME, +) +conv = converters.StringLengths( name='string' ) +glShaderSource = wrapper.wrapper( + glShaderSource +).setPyConverter( + 'count' # number of strings +).setPyConverter( + 'length' # lengths of strings +).setPyConverter( + 'string', conv.stringArray +).setCResolver( + 'string', conv.stringArrayForC, +).setCConverter( + 'length', conv, +).setCConverter( + 'count', conv.totalCount, +) +try: + del conv +except NameError as err: + pass + +@_lazy( glGetShaderiv ) +def glGetShaderiv( baseOperation, shader, pname, status=None ): + """Retrieve the integer parameter for the given shader + + shader -- shader ID to query + pname -- parameter name + status -- pointer to integer to receive status or None to + return the parameter as an integer value + + returns + integer if status parameter is None + status if status parameter is not None + """ + if status is None: + status = arrays.GLintArray.zeros( (1,)) + status[0] = 1 + baseOperation( + shader, pname, status + ) + return status[0] + else: + baseOperation( + shader, pname, status + ) + return status + +def _afterCheck( key ): + """Generate an error-checking function for compilation operations""" + if key == GL_OBJECT_COMPILE_STATUS: + getter = glGetShaderiv + else: + getter = glGetProgramiv + def GLSLCheckError( + result, + baseOperation=None, + cArguments=None, + *args + ): + result = _errors._error_checker.glCheckError( result, baseOperation, cArguments, *args ) + status = ctypes.c_int() + getter( cArguments[0], key, ctypes.byref(status)) + status = status.value + if not status: + raise error.GLError( + result = result, + baseOperation = baseOperation, + cArguments = cArguments, + description= glGetShaderInfoLog( cArguments[0] ) + ) + return result + return GLSLCheckError + +if _configflags.ERROR_CHECKING: + glCompileShader.errcheck = _afterCheck( GL_OBJECT_COMPILE_STATUS ) +if _configflags.ERROR_CHECKING: + glLinkProgram.errcheck = _afterCheck( GL_OBJECT_LINK_STATUS ) +## Not sure why, but these give invalid operation :( +##if glValidateProgram and OpenGL.ERROR_CHECKING: +## glValidateProgram.errcheck = _afterCheck( GL_OBJECT_VALIDATE_STATUS ) + +@_lazy( glGetShaderInfoLog ) +def glGetShaderInfoLog( baseOperation, obj ): + """Retrieve the shader's error messages as a Python string + + returns string which is '' if no message + """ + length = int(glGetShaderiv(obj, GL_INFO_LOG_LENGTH)) + if length > 0: + log = ctypes.create_string_buffer(length) + baseOperation(obj, length, None, log) + return log.value.strip(_NULL_8_BYTE) # null-termination + return '' +@_lazy( glGetProgramInfoLog ) +def glGetProgramInfoLog( baseOperation, obj ): + """Retrieve the shader program's error messages as a Python string + + returns string which is '' if no message + """ + length = int(glGetProgramiv(obj, GL_INFO_LOG_LENGTH)) + if length > 0: + log = ctypes.create_string_buffer(length) + baseOperation(obj, length, None, log) + return log.value.strip(_NULL_8_BYTE) # null-termination + return '' + +@_lazy( glGetAttachedShaders ) +def glGetAttachedShaders( baseOperation, obj ): + """Retrieve the attached objects as an array of GLhandle instances""" + length= glGetProgramiv( obj, GL_ATTACHED_SHADERS ) + if length > 0: + storage = arrays.GLuintArray.zeros( (length,)) + baseOperation( obj, length, None, storage ) + return storage + return arrays.GLuintArray.zeros( (0,)) + + +@_lazy( glGetShaderSource ) +def glGetShaderSource( baseOperation, obj ): + """Retrieve the program/shader's source code as a Python string + + returns string which is '' if no source code + """ + length = int(glGetShaderiv(obj, GL_SHADER_SOURCE_LENGTH)) + if length > 0: + source = ctypes.create_string_buffer(length) + baseOperation(obj, length, None, source) + return source.value.strip(_NULL_8_BYTE) # null-termination + return '' + +@_lazy( glGetActiveAttrib ) +def glGetActiveAttrib(baseOperation, program, index, bufSize=None,*args): + """Retrieves information about the attribute variable. + + program -- specifies the program to be queried + index -- index of the attribute to be queried + + Following parameters are optional: + + bufSize -- determines the size of the buffer (limits number of bytes written), + if not provided, will be GL_ACTIVE_ATTRIBUTE_MAX_LENGTH + length -- pointer-to-GLsizei that will hold the resulting length of the name + size -- pointer-to-GLint that will hold the size of the attribute + type -- pointer-to-GLenum that will hold the type constant of the attribute + name -- pointer-to-GLchar that will hold the (null-terminated) name string + + returns (bytes) name, (int)size, (enum)type + """ + if bufSize is None: + bufSize = int(glGetProgramiv( program, GL_ACTIVE_ATTRIBUTE_MAX_LENGTH)) + if bufSize <= 0: + raise RuntimeError( 'Active attribute length reported', bufsize ) + name,size,type = baseOperation( program, index, bufSize, *args )[1:] + if hasattr(name,'tostring'): + name = name.tostring().rstrip(b'\000') + elif hasattr(name,'value'): + name = name.value + return name,size,type + +@_lazy( glGetActiveUniform ) +def glGetActiveUniform(baseOperation,program, index,bufSize=None,*args): + """Retrieve the name, size and type of the uniform of the index in the program + + program -- specifies the program to be queried + index -- index of the uniform to be queried + + Following parameters are optional: + + bufSize -- determines the size of the buffer (limits number of bytes written), + if not provided, will be GL_OBJECT_ACTIVE_UNIFORM_MAX_LENGTH + length -- pointer-to-GLsizei that will hold the resulting length of the name + size -- pointer-to-GLint that will hold the size of the attribute + type -- pointer-to-GLenum that will hold the type constant of the attribute + name -- pointer-to-GLchar that will hold the (null-terminated) name string + + returns (bytes) name, (int)size, (enum)type + """ + max_index = int(glGetProgramiv( program, GL_ACTIVE_UNIFORMS )) + if bufSize is None: + bufSize = int(glGetProgramiv( program, GL_ACTIVE_UNIFORM_MAX_LENGTH)) + if index < max_index and index >= 0: + length,name,size,type = baseOperation( program, index, bufSize, *args ) + if hasattr(name,'tostring'): + name = name.tostring().rstrip(b'\000') + elif hasattr(name,'value'): + name = name.value + return name,size,type + raise IndexError( 'Index %s out of range 0 to %i' % (index, max_index - 1, ) ) + +@_lazy( glGetUniformLocation ) +def glGetUniformLocation( baseOperation, program, name ): + """Check that name is a string with a null byte at the end of it""" + if not name: + raise ValueError( """Non-null name required""" ) + name = as_8_bit( name ) + if name[-1] != _NULL_8_BYTE: + name = name + _NULL_8_BYTE + return baseOperation( program, name ) +@_lazy( glGetAttribLocation ) +def glGetAttribLocation( baseOperation, program, name ): + """Check that name is a string with a null byte at the end of it""" + if not name: + raise ValueError( """Non-null name required""" ) + + name = as_8_bit( name ) + if name[-1] != _NULL_8_BYTE: + name = name + _NULL_8_BYTE + return baseOperation( program, name ) + +@_lazy( glVertexAttribPointer ) +def glVertexAttribPointer( + baseOperation, index, size, type, + normalized, stride, pointer, +): + """Set an attribute pointer for a given shader (index) + + index -- the index of the generic vertex to bind, see + glGetAttribLocation for retrieval of the value, + note that index is a global variable, not per-shader + size -- number of basic elements per record, 1,2,3, or 4 + type -- enum constant for data-type + normalized -- whether to perform int to float + normalization on integer-type values + stride -- stride in machine units (bytes) between + consecutive records, normally used to create + "interleaved" arrays + pointer -- data-pointer which provides the data-values, + normally a vertex-buffer-object or offset into the + same. + + This implementation stores a copy of the data-pointer + in the contextdata structure in order to prevent null- + reference errors in the renderer. + """ + array = ArrayDatatype.asArray( pointer, type ) + key = ('vertex-attrib',index) + contextdata.setValue( key, array ) + return baseOperation( + index, size, type, + normalized, stride, + ArrayDatatype.voidDataPointer( array ) + ) + +@_lazy( glDrawBuffers ) +def glDrawBuffers( baseOperation, n=None, bufs=None ): + """glDrawBuffers( bufs ) -> bufs + + Wrapper will calculate n from dims of bufs if only + one argument is provided... + """ + if bufs is None: + bufs = n + n = None + bufs = arrays.GLenumArray.asArray( bufs ) + if n is None: + n = arrays.GLenumArray.arraySize( bufs ) + return baseOperation( n,bufs ) diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/VERSION/GL_2_1.py b/venv/lib/python3.12/site-packages/OpenGL/GL/VERSION/GL_2_1.py new file mode 100644 index 00000000..35b75ae4 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/VERSION/GL_2_1.py @@ -0,0 +1,46 @@ +'''OpenGL extension VERSION.GL_2_1 + +This module customises the behaviour of the +OpenGL.raw.GL.VERSION.GL_2_1 to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/VERSION/GL_2_1.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.VERSION.GL_2_1 import * +from OpenGL.raw.GL.VERSION.GL_2_1 import _EXTENSION_NAME + +def glInitGl21VERSION(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glUniformMatrix2x3fv.value size not checked against count*6 +glUniformMatrix2x3fv=wrapper.wrapper(glUniformMatrix2x3fv).setInputArraySize( + 'value', None +) +# INPUT glUniformMatrix3x2fv.value size not checked against count*6 +glUniformMatrix3x2fv=wrapper.wrapper(glUniformMatrix3x2fv).setInputArraySize( + 'value', None +) +# INPUT glUniformMatrix2x4fv.value size not checked against count*8 +glUniformMatrix2x4fv=wrapper.wrapper(glUniformMatrix2x4fv).setInputArraySize( + 'value', None +) +# INPUT glUniformMatrix4x2fv.value size not checked against count*8 +glUniformMatrix4x2fv=wrapper.wrapper(glUniformMatrix4x2fv).setInputArraySize( + 'value', None +) +# INPUT glUniformMatrix3x4fv.value size not checked against count*12 +glUniformMatrix3x4fv=wrapper.wrapper(glUniformMatrix3x4fv).setInputArraySize( + 'value', None +) +# INPUT glUniformMatrix4x3fv.value size not checked against count*12 +glUniformMatrix4x3fv=wrapper.wrapper(glUniformMatrix4x3fv).setInputArraySize( + 'value', None +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/VERSION/GL_3_0.py b/venv/lib/python3.12/site-packages/OpenGL/GL/VERSION/GL_3_0.py new file mode 100644 index 00000000..fb4f0376 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/VERSION/GL_3_0.py @@ -0,0 +1,167 @@ +'''OpenGL extension VERSION.GL_3_0 + +This module customises the behaviour of the +OpenGL.raw.GL.VERSION.GL_3_0 to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/VERSION/GL_3_0.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.VERSION.GL_3_0 import * +from OpenGL.raw.GL.VERSION.GL_3_0 import _EXTENSION_NAME + +def glInitGl30VERSION(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +glGetBooleani_v=wrapper.wrapper(glGetBooleani_v).setOutput( + 'data',size=_glgets._glget_size_mapping,pnameArg='target',orPassIn=True +) +glGetIntegeri_v=wrapper.wrapper(glGetIntegeri_v).setOutput( + 'data',size=_glgets._glget_size_mapping,pnameArg='target',orPassIn=True +) +# INPUT glTransformFeedbackVaryings.varyings size not checked against count +glTransformFeedbackVaryings=wrapper.wrapper(glTransformFeedbackVaryings).setInputArraySize( + 'varyings', None +) +glGetTransformFeedbackVarying=wrapper.wrapper(glGetTransformFeedbackVarying).setOutput( + 'length',size=(1,),orPassIn=True +).setOutput( + 'name',size=lambda x:(x,),pnameArg='bufSize',orPassIn=True +).setOutput( + 'size',size=(1,),orPassIn=True +).setOutput( + 'type',size=(1,),orPassIn=True +) +# INPUT glVertexAttribIPointer.pointer size not checked against 'size,type,stride' +glVertexAttribIPointer=wrapper.wrapper(glVertexAttribIPointer).setInputArraySize( + 'pointer', None +) +glGetVertexAttribIiv=wrapper.wrapper(glGetVertexAttribIiv).setOutput( + 'params',size=(1,),orPassIn=True +) +glGetVertexAttribIuiv=wrapper.wrapper(glGetVertexAttribIuiv).setOutput( + 'params',size=(1,),orPassIn=True +) +glVertexAttribI1iv=wrapper.wrapper(glVertexAttribI1iv).setInputArraySize( + 'v', 1 +) +glVertexAttribI2iv=wrapper.wrapper(glVertexAttribI2iv).setInputArraySize( + 'v', 2 +) +glVertexAttribI3iv=wrapper.wrapper(glVertexAttribI3iv).setInputArraySize( + 'v', 3 +) +glVertexAttribI4iv=wrapper.wrapper(glVertexAttribI4iv).setInputArraySize( + 'v', 4 +) +glVertexAttribI1uiv=wrapper.wrapper(glVertexAttribI1uiv).setInputArraySize( + 'v', 1 +) +glVertexAttribI2uiv=wrapper.wrapper(glVertexAttribI2uiv).setInputArraySize( + 'v', 2 +) +glVertexAttribI3uiv=wrapper.wrapper(glVertexAttribI3uiv).setInputArraySize( + 'v', 3 +) +glVertexAttribI4uiv=wrapper.wrapper(glVertexAttribI4uiv).setInputArraySize( + 'v', 4 +) +glVertexAttribI4bv=wrapper.wrapper(glVertexAttribI4bv).setInputArraySize( + 'v', 4 +) +glVertexAttribI4sv=wrapper.wrapper(glVertexAttribI4sv).setInputArraySize( + 'v', 4 +) +glVertexAttribI4ubv=wrapper.wrapper(glVertexAttribI4ubv).setInputArraySize( + 'v', 4 +) +glVertexAttribI4usv=wrapper.wrapper(glVertexAttribI4usv).setInputArraySize( + 'v', 4 +) +# OUTPUT glGetUniformuiv.params COMPSIZE(program, location) +# INPUT glBindFragDataLocation.name size not checked against 'name' +glBindFragDataLocation=wrapper.wrapper(glBindFragDataLocation).setInputArraySize( + 'name', None +) +# INPUT glGetFragDataLocation.name size not checked against 'name' +glGetFragDataLocation=wrapper.wrapper(glGetFragDataLocation).setInputArraySize( + 'name', None +) +# INPUT glUniform1uiv.value size not checked against count +glUniform1uiv=wrapper.wrapper(glUniform1uiv).setInputArraySize( + 'value', None +) +# INPUT glUniform2uiv.value size not checked against count*2 +glUniform2uiv=wrapper.wrapper(glUniform2uiv).setInputArraySize( + 'value', None +) +# INPUT glUniform3uiv.value size not checked against count*3 +glUniform3uiv=wrapper.wrapper(glUniform3uiv).setInputArraySize( + 'value', None +) +# INPUT glUniform4uiv.value size not checked against count*4 +glUniform4uiv=wrapper.wrapper(glUniform4uiv).setInputArraySize( + 'value', None +) +# INPUT glTexParameterIiv.params size not checked against 'pname' +glTexParameterIiv=wrapper.wrapper(glTexParameterIiv).setInputArraySize( + 'params', None +) +# INPUT glTexParameterIuiv.params size not checked against 'pname' +glTexParameterIuiv=wrapper.wrapper(glTexParameterIuiv).setInputArraySize( + 'params', None +) +glGetTexParameterIiv=wrapper.wrapper(glGetTexParameterIiv).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetTexParameterIuiv=wrapper.wrapper(glGetTexParameterIuiv).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +# INPUT glClearBufferiv.value size not checked against 'buffer' +glClearBufferiv=wrapper.wrapper(glClearBufferiv).setInputArraySize( + 'value', None +) +# INPUT glClearBufferuiv.value size not checked against 'buffer' +glClearBufferuiv=wrapper.wrapper(glClearBufferuiv).setInputArraySize( + 'value', None +) +# INPUT glClearBufferfv.value size not checked against 'buffer' +glClearBufferfv=wrapper.wrapper(glClearBufferfv).setInputArraySize( + 'value', None +) +# INPUT glDeleteRenderbuffers.renderbuffers size not checked against n +glDeleteRenderbuffers=wrapper.wrapper(glDeleteRenderbuffers).setInputArraySize( + 'renderbuffers', None +) +glGenRenderbuffers=wrapper.wrapper(glGenRenderbuffers).setOutput( + 'renderbuffers',size=lambda x:(x,),pnameArg='n',orPassIn=True +) +glGetRenderbufferParameteriv=wrapper.wrapper(glGetRenderbufferParameteriv).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +# INPUT glDeleteFramebuffers.framebuffers size not checked against n +glDeleteFramebuffers=wrapper.wrapper(glDeleteFramebuffers).setInputArraySize( + 'framebuffers', None +) +glGenFramebuffers=wrapper.wrapper(glGenFramebuffers).setOutput( + 'framebuffers',size=lambda x:(x,),pnameArg='n',orPassIn=True +) +glGetFramebufferAttachmentParameteriv=wrapper.wrapper(glGetFramebufferAttachmentParameteriv).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +# INPUT glDeleteVertexArrays.arrays size not checked against n +glDeleteVertexArrays=wrapper.wrapper(glDeleteVertexArrays).setInputArraySize( + 'arrays', None +) +glGenVertexArrays=wrapper.wrapper(glGenVertexArrays).setOutput( + 'arrays',size=lambda x:(x,),pnameArg='n',orPassIn=True +) +### END AUTOGENERATED SECTION +from ctypes import c_char_p +glGetStringi.restype = c_char_p diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/VERSION/GL_3_1.py b/venv/lib/python3.12/site-packages/OpenGL/GL/VERSION/GL_3_1.py new file mode 100644 index 00000000..2bdf7df3 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/VERSION/GL_3_1.py @@ -0,0 +1,55 @@ +'''OpenGL extension VERSION.GL_3_1 + +This module customises the behaviour of the +OpenGL.raw.GL.VERSION.GL_3_1 to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/VERSION/GL_3_1.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.VERSION.GL_3_1 import * +from OpenGL.raw.GL.VERSION.GL_3_1 import _EXTENSION_NAME + +def glInitGl31VERSION(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glDrawElementsInstanced.indices size not checked against 'count,type' +glDrawElementsInstanced=wrapper.wrapper(glDrawElementsInstanced).setInputArraySize( + 'indices', None +) +# INPUT glGetUniformIndices.uniformNames size not checked against 'uniformCount' +glGetUniformIndices=wrapper.wrapper(glGetUniformIndices).setOutput( + 'uniformIndices',size=_glgets._glget_size_mapping,pnameArg='uniformCount',orPassIn=True +).setInputArraySize( + 'uniformNames', None +) +# OUTPUT glGetActiveUniformsiv.params COMPSIZE(uniformCount, pname) +# INPUT glGetActiveUniformsiv.uniformIndices size not checked against uniformCount +glGetActiveUniformsiv=wrapper.wrapper(glGetActiveUniformsiv).setInputArraySize( + 'uniformIndices', None +) +glGetActiveUniformName=wrapper.wrapper(glGetActiveUniformName).setOutput( + 'length',size=(1,),orPassIn=True +).setOutput( + 'uniformName',size=lambda x:(x,),pnameArg='bufSize',orPassIn=True +) +# INPUT glGetUniformBlockIndex.uniformBlockName size not checked against '' +glGetUniformBlockIndex=wrapper.wrapper(glGetUniformBlockIndex).setInputArraySize( + 'uniformBlockName', None +) +# OUTPUT glGetActiveUniformBlockiv.params COMPSIZE(program, uniformBlockIndex, pname) +glGetActiveUniformBlockName=wrapper.wrapper(glGetActiveUniformBlockName).setOutput( + 'length',size=(1,),orPassIn=True +).setOutput( + 'uniformBlockName',size=lambda x:(x,),pnameArg='bufSize',orPassIn=True +) +glGetIntegeri_v=wrapper.wrapper(glGetIntegeri_v).setOutput( + 'data',size=_glgets._glget_size_mapping,pnameArg='target',orPassIn=True +) +### END AUTOGENERATED SECTION diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/VERSION/GL_3_2.py b/venv/lib/python3.12/site-packages/OpenGL/GL/VERSION/GL_3_2.py new file mode 100644 index 00000000..a68cac64 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/VERSION/GL_3_2.py @@ -0,0 +1,61 @@ +'''OpenGL extension VERSION.GL_3_2 + +This module customises the behaviour of the +OpenGL.raw.GL.VERSION.GL_3_2 to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/VERSION/GL_3_2.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.VERSION.GL_3_2 import * +from OpenGL.raw.GL.VERSION.GL_3_2 import _EXTENSION_NAME + +def glInitGl32VERSION(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glDrawElementsBaseVertex.indices size not checked against 'count,type' +glDrawElementsBaseVertex=wrapper.wrapper(glDrawElementsBaseVertex).setInputArraySize( + 'indices', None +) +# INPUT glDrawRangeElementsBaseVertex.indices size not checked against 'count,type' +glDrawRangeElementsBaseVertex=wrapper.wrapper(glDrawRangeElementsBaseVertex).setInputArraySize( + 'indices', None +) +# INPUT glDrawElementsInstancedBaseVertex.indices size not checked against 'count,type' +glDrawElementsInstancedBaseVertex=wrapper.wrapper(glDrawElementsInstancedBaseVertex).setInputArraySize( + 'indices', None +) +# INPUT glMultiDrawElementsBaseVertex.basevertex size not checked against 'drawcount' +# INPUT glMultiDrawElementsBaseVertex.count size not checked against 'drawcount' +# INPUT glMultiDrawElementsBaseVertex.indices size not checked against 'drawcount' +glMultiDrawElementsBaseVertex=wrapper.wrapper(glMultiDrawElementsBaseVertex).setInputArraySize( + 'basevertex', None +).setInputArraySize( + 'count', None +).setInputArraySize( + 'indices', None +) +glGetInteger64v=wrapper.wrapper(glGetInteger64v).setOutput( + 'data',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetSynciv=wrapper.wrapper(glGetSynciv).setOutput( + 'length',size=(1,),orPassIn=True +).setOutput( + 'values',size=lambda x:(x,),pnameArg='bufSize',orPassIn=True +) +glGetInteger64i_v=wrapper.wrapper(glGetInteger64i_v).setOutput( + 'data',size=_glgets._glget_size_mapping,pnameArg='target',orPassIn=True +) +glGetBufferParameteri64v=wrapper.wrapper(glGetBufferParameteri64v).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetMultisamplefv=wrapper.wrapper(glGetMultisamplefv).setOutput( + 'val',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +### END AUTOGENERATED SECTION diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/VERSION/GL_3_3.py b/venv/lib/python3.12/site-packages/OpenGL/GL/VERSION/GL_3_3.py new file mode 100644 index 00000000..10822b36 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/VERSION/GL_3_3.py @@ -0,0 +1,120 @@ +'''OpenGL extension VERSION.GL_3_3 + +This module customises the behaviour of the +OpenGL.raw.GL.VERSION.GL_3_3 to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/VERSION/GL_3_3.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.VERSION.GL_3_3 import * +from OpenGL.raw.GL.VERSION.GL_3_3 import _EXTENSION_NAME + +def glInitGl33VERSION(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +glGenSamplers=wrapper.wrapper(glGenSamplers).setOutput( + 'samplers',size=lambda x:(x,),pnameArg='count',orPassIn=True +) +# INPUT glDeleteSamplers.samplers size not checked against count +glDeleteSamplers=wrapper.wrapper(glDeleteSamplers).setInputArraySize( + 'samplers', None +) +# INPUT glSamplerParameteriv.param size not checked against 'pname' +glSamplerParameteriv=wrapper.wrapper(glSamplerParameteriv).setInputArraySize( + 'param', None +) +# INPUT glSamplerParameterfv.param size not checked against 'pname' +glSamplerParameterfv=wrapper.wrapper(glSamplerParameterfv).setInputArraySize( + 'param', None +) +# INPUT glSamplerParameterIiv.param size not checked against 'pname' +glSamplerParameterIiv=wrapper.wrapper(glSamplerParameterIiv).setInputArraySize( + 'param', None +) +# INPUT glSamplerParameterIuiv.param size not checked against 'pname' +glSamplerParameterIuiv=wrapper.wrapper(glSamplerParameterIuiv).setInputArraySize( + 'param', None +) +glGetSamplerParameteriv=wrapper.wrapper(glGetSamplerParameteriv).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetSamplerParameterIiv=wrapper.wrapper(glGetSamplerParameterIiv).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetSamplerParameterfv=wrapper.wrapper(glGetSamplerParameterfv).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetSamplerParameterIuiv=wrapper.wrapper(glGetSamplerParameterIuiv).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetQueryObjecti64v=wrapper.wrapper(glGetQueryObjecti64v).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetQueryObjectui64v=wrapper.wrapper(glGetQueryObjectui64v).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glVertexAttribP1uiv=wrapper.wrapper(glVertexAttribP1uiv).setInputArraySize( + 'value', 1 +) +glVertexAttribP2uiv=wrapper.wrapper(glVertexAttribP2uiv).setInputArraySize( + 'value', 1 +) +glVertexAttribP3uiv=wrapper.wrapper(glVertexAttribP3uiv).setInputArraySize( + 'value', 1 +) +glVertexAttribP4uiv=wrapper.wrapper(glVertexAttribP4uiv).setInputArraySize( + 'value', 1 +) +glVertexP2uiv=wrapper.wrapper(glVertexP2uiv).setInputArraySize( + 'value', 1 +) +glVertexP3uiv=wrapper.wrapper(glVertexP3uiv).setInputArraySize( + 'value', 1 +) +glVertexP4uiv=wrapper.wrapper(glVertexP4uiv).setInputArraySize( + 'value', 1 +) +glTexCoordP1uiv=wrapper.wrapper(glTexCoordP1uiv).setInputArraySize( + 'coords', 1 +) +glTexCoordP2uiv=wrapper.wrapper(glTexCoordP2uiv).setInputArraySize( + 'coords', 1 +) +glTexCoordP3uiv=wrapper.wrapper(glTexCoordP3uiv).setInputArraySize( + 'coords', 1 +) +glTexCoordP4uiv=wrapper.wrapper(glTexCoordP4uiv).setInputArraySize( + 'coords', 1 +) +glMultiTexCoordP1uiv=wrapper.wrapper(glMultiTexCoordP1uiv).setInputArraySize( + 'coords', 1 +) +glMultiTexCoordP2uiv=wrapper.wrapper(glMultiTexCoordP2uiv).setInputArraySize( + 'coords', 1 +) +glMultiTexCoordP3uiv=wrapper.wrapper(glMultiTexCoordP3uiv).setInputArraySize( + 'coords', 1 +) +glMultiTexCoordP4uiv=wrapper.wrapper(glMultiTexCoordP4uiv).setInputArraySize( + 'coords', 1 +) +glNormalP3uiv=wrapper.wrapper(glNormalP3uiv).setInputArraySize( + 'coords', 1 +) +glColorP3uiv=wrapper.wrapper(glColorP3uiv).setInputArraySize( + 'color', 1 +) +glColorP4uiv=wrapper.wrapper(glColorP4uiv).setInputArraySize( + 'color', 1 +) +glSecondaryColorP3uiv=wrapper.wrapper(glSecondaryColorP3uiv).setInputArraySize( + 'color', 1 +) +### END AUTOGENERATED SECTION diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/VERSION/GL_4_0.py b/venv/lib/python3.12/site-packages/OpenGL/GL/VERSION/GL_4_0.py new file mode 100644 index 00000000..829c3b64 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/VERSION/GL_4_0.py @@ -0,0 +1,112 @@ +'''OpenGL extension VERSION.GL_4_0 + +This module customises the behaviour of the +OpenGL.raw.GL.VERSION.GL_4_0 to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/VERSION/GL_4_0.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.VERSION.GL_4_0 import * +from OpenGL.raw.GL.VERSION.GL_4_0 import _EXTENSION_NAME + +def glInitGl40VERSION(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glUniform1dv.value size not checked against count +glUniform1dv=wrapper.wrapper(glUniform1dv).setInputArraySize( + 'value', None +) +# INPUT glUniform2dv.value size not checked against count*2 +glUniform2dv=wrapper.wrapper(glUniform2dv).setInputArraySize( + 'value', None +) +# INPUT glUniform3dv.value size not checked against count*3 +glUniform3dv=wrapper.wrapper(glUniform3dv).setInputArraySize( + 'value', None +) +# INPUT glUniform4dv.value size not checked against count*4 +glUniform4dv=wrapper.wrapper(glUniform4dv).setInputArraySize( + 'value', None +) +# INPUT glUniformMatrix2dv.value size not checked against count*4 +glUniformMatrix2dv=wrapper.wrapper(glUniformMatrix2dv).setInputArraySize( + 'value', None +) +# INPUT glUniformMatrix3dv.value size not checked against count*9 +glUniformMatrix3dv=wrapper.wrapper(glUniformMatrix3dv).setInputArraySize( + 'value', None +) +# INPUT glUniformMatrix4dv.value size not checked against count*16 +glUniformMatrix4dv=wrapper.wrapper(glUniformMatrix4dv).setInputArraySize( + 'value', None +) +# INPUT glUniformMatrix2x3dv.value size not checked against count*6 +glUniformMatrix2x3dv=wrapper.wrapper(glUniformMatrix2x3dv).setInputArraySize( + 'value', None +) +# INPUT glUniformMatrix2x4dv.value size not checked against count*8 +glUniformMatrix2x4dv=wrapper.wrapper(glUniformMatrix2x4dv).setInputArraySize( + 'value', None +) +# INPUT glUniformMatrix3x2dv.value size not checked against count*6 +glUniformMatrix3x2dv=wrapper.wrapper(glUniformMatrix3x2dv).setInputArraySize( + 'value', None +) +# INPUT glUniformMatrix3x4dv.value size not checked against count*12 +glUniformMatrix3x4dv=wrapper.wrapper(glUniformMatrix3x4dv).setInputArraySize( + 'value', None +) +# INPUT glUniformMatrix4x2dv.value size not checked against count*8 +glUniformMatrix4x2dv=wrapper.wrapper(glUniformMatrix4x2dv).setInputArraySize( + 'value', None +) +# INPUT glUniformMatrix4x3dv.value size not checked against count*12 +glUniformMatrix4x3dv=wrapper.wrapper(glUniformMatrix4x3dv).setInputArraySize( + 'value', None +) +# OUTPUT glGetUniformdv.params COMPSIZE(program, location) +glGetActiveSubroutineUniformiv=wrapper.wrapper(glGetActiveSubroutineUniformiv).setOutput( + 'values',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetActiveSubroutineUniformName=wrapper.wrapper(glGetActiveSubroutineUniformName).setOutput( + 'length',size=(1,),orPassIn=True +).setOutput( + 'name',size=lambda x:(x,),pnameArg='bufsize',orPassIn=True +) +glGetActiveSubroutineName=wrapper.wrapper(glGetActiveSubroutineName).setOutput( + 'length',size=(1,),orPassIn=True +).setOutput( + 'name',size=lambda x:(x,),pnameArg='bufsize',orPassIn=True +) +# INPUT glUniformSubroutinesuiv.indices size not checked against count +glUniformSubroutinesuiv=wrapper.wrapper(glUniformSubroutinesuiv).setInputArraySize( + 'indices', None +) +glGetUniformSubroutineuiv=wrapper.wrapper(glGetUniformSubroutineuiv).setOutput( + 'params',size=(1,),orPassIn=True +) +glGetProgramStageiv=wrapper.wrapper(glGetProgramStageiv).setOutput( + 'values',size=(1,),orPassIn=True +) +# INPUT glPatchParameterfv.values size not checked against 'pname' +glPatchParameterfv=wrapper.wrapper(glPatchParameterfv).setInputArraySize( + 'values', None +) +# INPUT glDeleteTransformFeedbacks.ids size not checked against n +glDeleteTransformFeedbacks=wrapper.wrapper(glDeleteTransformFeedbacks).setInputArraySize( + 'ids', None +) +glGenTransformFeedbacks=wrapper.wrapper(glGenTransformFeedbacks).setOutput( + 'ids',size=lambda x:(x,),pnameArg='n',orPassIn=True +) +glGetQueryIndexediv=wrapper.wrapper(glGetQueryIndexediv).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +### END AUTOGENERATED SECTION diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/VERSION/GL_4_1.py b/venv/lib/python3.12/site-packages/OpenGL/GL/VERSION/GL_4_1.py new file mode 100644 index 00000000..a41470d5 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/VERSION/GL_4_1.py @@ -0,0 +1,249 @@ +'''OpenGL extension VERSION.GL_4_1 + +This module customises the behaviour of the +OpenGL.raw.GL.VERSION.GL_4_1 to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/VERSION/GL_4_1.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.VERSION.GL_4_1 import * +from OpenGL.raw.GL.VERSION.GL_4_1 import _EXTENSION_NAME + +def glInitGl41VERSION(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glShaderBinary.binary size not checked against length +# INPUT glShaderBinary.shaders size not checked against count +glShaderBinary=wrapper.wrapper(glShaderBinary).setInputArraySize( + 'binary', None +).setInputArraySize( + 'shaders', None +) +glGetShaderPrecisionFormat=wrapper.wrapper(glGetShaderPrecisionFormat).setOutput( + 'precision',size=(1,),orPassIn=True +).setOutput( + 'range',size=(2,),orPassIn=True +) +glGetProgramBinary=wrapper.wrapper(glGetProgramBinary).setOutput( + 'binary',size=lambda x:(x,),pnameArg='bufSize',orPassIn=True +).setOutput( + 'binaryFormat',size=(1,),orPassIn=True +).setOutput( + 'length',size=(1,),orPassIn=True +) +# INPUT glProgramBinary.binary size not checked against length +glProgramBinary=wrapper.wrapper(glProgramBinary).setInputArraySize( + 'binary', None +) +# INPUT glCreateShaderProgramv.strings size not checked against count +glCreateShaderProgramv=wrapper.wrapper(glCreateShaderProgramv).setInputArraySize( + 'strings', None +) +# INPUT glDeleteProgramPipelines.pipelines size not checked against n +glDeleteProgramPipelines=wrapper.wrapper(glDeleteProgramPipelines).setInputArraySize( + 'pipelines', None +) +glGenProgramPipelines=wrapper.wrapper(glGenProgramPipelines).setOutput( + 'pipelines',size=lambda x:(x,),pnameArg='n',orPassIn=True +) +glGetProgramPipelineiv=wrapper.wrapper(glGetProgramPipelineiv).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +# INPUT glProgramUniform1iv.value size not checked against count +glProgramUniform1iv=wrapper.wrapper(glProgramUniform1iv).setInputArraySize( + 'value', None +) +# INPUT glProgramUniform1fv.value size not checked against count +glProgramUniform1fv=wrapper.wrapper(glProgramUniform1fv).setInputArraySize( + 'value', None +) +# INPUT glProgramUniform1dv.value size not checked against count +glProgramUniform1dv=wrapper.wrapper(glProgramUniform1dv).setInputArraySize( + 'value', None +) +# INPUT glProgramUniform1uiv.value size not checked against count +glProgramUniform1uiv=wrapper.wrapper(glProgramUniform1uiv).setInputArraySize( + 'value', None +) +# INPUT glProgramUniform2iv.value size not checked against count*2 +glProgramUniform2iv=wrapper.wrapper(glProgramUniform2iv).setInputArraySize( + 'value', None +) +# INPUT glProgramUniform2fv.value size not checked against count*2 +glProgramUniform2fv=wrapper.wrapper(glProgramUniform2fv).setInputArraySize( + 'value', None +) +# INPUT glProgramUniform2dv.value size not checked against count*2 +glProgramUniform2dv=wrapper.wrapper(glProgramUniform2dv).setInputArraySize( + 'value', None +) +# INPUT glProgramUniform2uiv.value size not checked against count*2 +glProgramUniform2uiv=wrapper.wrapper(glProgramUniform2uiv).setInputArraySize( + 'value', None +) +# INPUT glProgramUniform3iv.value size not checked against count*3 +glProgramUniform3iv=wrapper.wrapper(glProgramUniform3iv).setInputArraySize( + 'value', None +) +# INPUT glProgramUniform3fv.value size not checked against count*3 +glProgramUniform3fv=wrapper.wrapper(glProgramUniform3fv).setInputArraySize( + 'value', None +) +# INPUT glProgramUniform3dv.value size not checked against count*3 +glProgramUniform3dv=wrapper.wrapper(glProgramUniform3dv).setInputArraySize( + 'value', None +) +# INPUT glProgramUniform3uiv.value size not checked against count*3 +glProgramUniform3uiv=wrapper.wrapper(glProgramUniform3uiv).setInputArraySize( + 'value', None +) +# INPUT glProgramUniform4iv.value size not checked against count*4 +glProgramUniform4iv=wrapper.wrapper(glProgramUniform4iv).setInputArraySize( + 'value', None +) +# INPUT glProgramUniform4fv.value size not checked against count*4 +glProgramUniform4fv=wrapper.wrapper(glProgramUniform4fv).setInputArraySize( + 'value', None +) +# INPUT glProgramUniform4dv.value size not checked against count*4 +glProgramUniform4dv=wrapper.wrapper(glProgramUniform4dv).setInputArraySize( + 'value', None +) +# INPUT glProgramUniform4uiv.value size not checked against count*4 +glProgramUniform4uiv=wrapper.wrapper(glProgramUniform4uiv).setInputArraySize( + 'value', None +) +# INPUT glProgramUniformMatrix2fv.value size not checked against count*4 +glProgramUniformMatrix2fv=wrapper.wrapper(glProgramUniformMatrix2fv).setInputArraySize( + 'value', None +) +# INPUT glProgramUniformMatrix3fv.value size not checked against count*9 +glProgramUniformMatrix3fv=wrapper.wrapper(glProgramUniformMatrix3fv).setInputArraySize( + 'value', None +) +# INPUT glProgramUniformMatrix4fv.value size not checked against count*16 +glProgramUniformMatrix4fv=wrapper.wrapper(glProgramUniformMatrix4fv).setInputArraySize( + 'value', None +) +# INPUT glProgramUniformMatrix2dv.value size not checked against count*4 +glProgramUniformMatrix2dv=wrapper.wrapper(glProgramUniformMatrix2dv).setInputArraySize( + 'value', None +) +# INPUT glProgramUniformMatrix3dv.value size not checked against count*9 +glProgramUniformMatrix3dv=wrapper.wrapper(glProgramUniformMatrix3dv).setInputArraySize( + 'value', None +) +# INPUT glProgramUniformMatrix4dv.value size not checked against count*16 +glProgramUniformMatrix4dv=wrapper.wrapper(glProgramUniformMatrix4dv).setInputArraySize( + 'value', None +) +# INPUT glProgramUniformMatrix2x3fv.value size not checked against count*6 +glProgramUniformMatrix2x3fv=wrapper.wrapper(glProgramUniformMatrix2x3fv).setInputArraySize( + 'value', None +) +# INPUT glProgramUniformMatrix3x2fv.value size not checked against count*6 +glProgramUniformMatrix3x2fv=wrapper.wrapper(glProgramUniformMatrix3x2fv).setInputArraySize( + 'value', None +) +# INPUT glProgramUniformMatrix2x4fv.value size not checked against count*8 +glProgramUniformMatrix2x4fv=wrapper.wrapper(glProgramUniformMatrix2x4fv).setInputArraySize( + 'value', None +) +# INPUT glProgramUniformMatrix4x2fv.value size not checked against count*8 +glProgramUniformMatrix4x2fv=wrapper.wrapper(glProgramUniformMatrix4x2fv).setInputArraySize( + 'value', None +) +# INPUT glProgramUniformMatrix3x4fv.value size not checked against count*12 +glProgramUniformMatrix3x4fv=wrapper.wrapper(glProgramUniformMatrix3x4fv).setInputArraySize( + 'value', None +) +# INPUT glProgramUniformMatrix4x3fv.value size not checked against count*12 +glProgramUniformMatrix4x3fv=wrapper.wrapper(glProgramUniformMatrix4x3fv).setInputArraySize( + 'value', None +) +# INPUT glProgramUniformMatrix2x3dv.value size not checked against count*6 +glProgramUniformMatrix2x3dv=wrapper.wrapper(glProgramUniformMatrix2x3dv).setInputArraySize( + 'value', None +) +# INPUT glProgramUniformMatrix3x2dv.value size not checked against count*6 +glProgramUniformMatrix3x2dv=wrapper.wrapper(glProgramUniformMatrix3x2dv).setInputArraySize( + 'value', None +) +# INPUT glProgramUniformMatrix2x4dv.value size not checked against count*8 +glProgramUniformMatrix2x4dv=wrapper.wrapper(glProgramUniformMatrix2x4dv).setInputArraySize( + 'value', None +) +# INPUT glProgramUniformMatrix4x2dv.value size not checked against count*8 +glProgramUniformMatrix4x2dv=wrapper.wrapper(glProgramUniformMatrix4x2dv).setInputArraySize( + 'value', None +) +# INPUT glProgramUniformMatrix3x4dv.value size not checked against count*12 +glProgramUniformMatrix3x4dv=wrapper.wrapper(glProgramUniformMatrix3x4dv).setInputArraySize( + 'value', None +) +# INPUT glProgramUniformMatrix4x3dv.value size not checked against count*12 +glProgramUniformMatrix4x3dv=wrapper.wrapper(glProgramUniformMatrix4x3dv).setInputArraySize( + 'value', None +) +glGetProgramPipelineInfoLog=wrapper.wrapper(glGetProgramPipelineInfoLog).setOutput( + 'infoLog',size=lambda x:(x,),pnameArg='bufSize',orPassIn=True +).setOutput( + 'length',size=(1,),orPassIn=True +) +glVertexAttribL1dv=wrapper.wrapper(glVertexAttribL1dv).setInputArraySize( + 'v', 1 +) +glVertexAttribL2dv=wrapper.wrapper(glVertexAttribL2dv).setInputArraySize( + 'v', 2 +) +glVertexAttribL3dv=wrapper.wrapper(glVertexAttribL3dv).setInputArraySize( + 'v', 3 +) +glVertexAttribL4dv=wrapper.wrapper(glVertexAttribL4dv).setInputArraySize( + 'v', 4 +) +# INPUT glVertexAttribLPointer.pointer size not checked against size +glVertexAttribLPointer=wrapper.wrapper(glVertexAttribLPointer).setInputArraySize( + 'pointer', None +) +glGetVertexAttribLdv=wrapper.wrapper(glGetVertexAttribLdv).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +# INPUT glViewportArrayv.v size not checked against 'count' +glViewportArrayv=wrapper.wrapper(glViewportArrayv).setInputArraySize( + 'v', None +) +glViewportIndexedfv=wrapper.wrapper(glViewportIndexedfv).setInputArraySize( + 'v', 4 +) +# INPUT glScissorArrayv.v size not checked against 'count' +glScissorArrayv=wrapper.wrapper(glScissorArrayv).setInputArraySize( + 'v', None +) +glScissorIndexedv=wrapper.wrapper(glScissorIndexedv).setInputArraySize( + 'v', 4 +) +# INPUT glDepthRangeArrayv.v size not checked against 'count' +glDepthRangeArrayv=wrapper.wrapper(glDepthRangeArrayv).setInputArraySize( + 'v', None +) +glGetFloati_v=wrapper.wrapper(glGetFloati_v).setOutput( + 'data',size=_glgets._glget_size_mapping,pnameArg='target',orPassIn=True +) +glGetDoublei_v=wrapper.wrapper(glGetDoublei_v).setOutput( + 'data',size=_glgets._glget_size_mapping,pnameArg='target',orPassIn=True +) +### END AUTOGENERATED SECTION +from OpenGL.GL.ARB.ES2_compatibility import * +from OpenGL.GL.ARB.get_program_binary import * +from OpenGL.GL.ARB.separate_shader_objects import * +from OpenGL.GL.ARB.shader_precision import * +from OpenGL.GL.ARB.vertex_attrib_64bit import * +from OpenGL.GL.ARB.viewport_array import * diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/VERSION/GL_4_2.py b/venv/lib/python3.12/site-packages/OpenGL/GL/VERSION/GL_4_2.py new file mode 100644 index 00000000..97224a8e --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/VERSION/GL_4_2.py @@ -0,0 +1,48 @@ +'''OpenGL extension VERSION.GL_4_2 + +This module customises the behaviour of the +OpenGL.raw.GL.VERSION.GL_4_2 to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/VERSION/GL_4_2.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.VERSION.GL_4_2 import * +from OpenGL.raw.GL.VERSION.GL_4_2 import _EXTENSION_NAME + +def glInitGl42VERSION(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glDrawElementsInstancedBaseInstance.indices size not checked against count +glDrawElementsInstancedBaseInstance=wrapper.wrapper(glDrawElementsInstancedBaseInstance).setInputArraySize( + 'indices', None +) +# INPUT glDrawElementsInstancedBaseVertexBaseInstance.indices size not checked against count +glDrawElementsInstancedBaseVertexBaseInstance=wrapper.wrapper(glDrawElementsInstancedBaseVertexBaseInstance).setInputArraySize( + 'indices', None +) +glGetInternalformativ=wrapper.wrapper(glGetInternalformativ).setOutput( + 'params',size=lambda x:(x,),pnameArg='bufSize',orPassIn=True +) +glGetActiveAtomicCounterBufferiv=wrapper.wrapper(glGetActiveAtomicCounterBufferiv).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +### END AUTOGENERATED SECTION + +from OpenGL.GL.ARB.base_instance import * +from OpenGL.GL.ARB.shading_language_420pack import * +from OpenGL.GL.ARB.transform_feedback_instanced import * +from OpenGL.GL.ARB.compressed_texture_pixel_storage import * +from OpenGL.GL.ARB.conservative_depth import * +from OpenGL.GL.ARB.internalformat_query import * +from OpenGL.GL.ARB.map_buffer_alignment import * +from OpenGL.GL.ARB.shader_atomic_counters import * +from OpenGL.GL.ARB.shader_image_load_store import * +from OpenGL.GL.ARB.shading_language_packing import * +from OpenGL.GL.ARB.texture_storage import * diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/VERSION/GL_4_3.py b/venv/lib/python3.12/site-packages/OpenGL/GL/VERSION/GL_4_3.py new file mode 100644 index 00000000..c6fef267 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/VERSION/GL_4_3.py @@ -0,0 +1,153 @@ +'''OpenGL extension VERSION.GL_4_3 + +This module customises the behaviour of the +OpenGL.raw.GL.VERSION.GL_4_3 to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/VERSION/GL_4_3.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.VERSION.GL_4_3 import * +from OpenGL.raw.GL.VERSION.GL_4_3 import _EXTENSION_NAME + +def glInitGl43VERSION(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glClearBufferData.data size not checked against 'format,type' +glClearBufferData=wrapper.wrapper(glClearBufferData).setInputArraySize( + 'data', None +) +# INPUT glClearBufferSubData.data size not checked against 'format,type' +glClearBufferSubData=wrapper.wrapper(glClearBufferSubData).setInputArraySize( + 'data', None +) +glGetFramebufferParameteriv=wrapper.wrapper(glGetFramebufferParameteriv).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetInternalformati64v=wrapper.wrapper(glGetInternalformati64v).setOutput( + 'params',size=lambda x:(x,),pnameArg='bufSize',orPassIn=True +) +# INPUT glInvalidateFramebuffer.attachments size not checked against numAttachments +glInvalidateFramebuffer=wrapper.wrapper(glInvalidateFramebuffer).setInputArraySize( + 'attachments', None +) +# INPUT glInvalidateSubFramebuffer.attachments size not checked against numAttachments +glInvalidateSubFramebuffer=wrapper.wrapper(glInvalidateSubFramebuffer).setInputArraySize( + 'attachments', None +) +# INPUT glMultiDrawArraysIndirect.indirect size not checked against 'drawcount,stride' +glMultiDrawArraysIndirect=wrapper.wrapper(glMultiDrawArraysIndirect).setInputArraySize( + 'indirect', None +) +# INPUT glMultiDrawElementsIndirect.indirect size not checked against 'drawcount,stride' +glMultiDrawElementsIndirect=wrapper.wrapper(glMultiDrawElementsIndirect).setInputArraySize( + 'indirect', None +) +glGetProgramInterfaceiv=wrapper.wrapper(glGetProgramInterfaceiv).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +# INPUT glGetProgramResourceIndex.name size not checked against 'name' +glGetProgramResourceIndex=wrapper.wrapper(glGetProgramResourceIndex).setInputArraySize( + 'name', None +) +glGetProgramResourceName=wrapper.wrapper(glGetProgramResourceName).setOutput( + 'length',size=(1,),orPassIn=True +).setOutput( + 'name',size=lambda x:(x,),pnameArg='bufSize',orPassIn=True +) +# INPUT glGetProgramResourceiv.props size not checked against propCount +glGetProgramResourceiv=wrapper.wrapper(glGetProgramResourceiv).setOutput( + 'length',size=(1,),orPassIn=True +).setOutput( + 'params',size=lambda x:(x,),pnameArg='bufSize',orPassIn=True +).setInputArraySize( + 'props', None +) +# INPUT glGetProgramResourceLocation.name size not checked against 'name' +glGetProgramResourceLocation=wrapper.wrapper(glGetProgramResourceLocation).setInputArraySize( + 'name', None +) +# INPUT glGetProgramResourceLocationIndex.name size not checked against 'name' +glGetProgramResourceLocationIndex=wrapper.wrapper(glGetProgramResourceLocationIndex).setInputArraySize( + 'name', None +) +# INPUT glDebugMessageControl.ids size not checked against count +glDebugMessageControl=wrapper.wrapper(glDebugMessageControl).setInputArraySize( + 'ids', None +) +# INPUT glDebugMessageInsert.buf size not checked against 'buf,length' +glDebugMessageInsert=wrapper.wrapper(glDebugMessageInsert).setInputArraySize( + 'buf', None +) +glGetDebugMessageLog=wrapper.wrapper(glGetDebugMessageLog).setOutput( + 'ids',size=lambda x:(x,),pnameArg='count',orPassIn=True +).setOutput( + 'lengths',size=lambda x:(x,),pnameArg='count',orPassIn=True +).setOutput( + 'messageLog',size=lambda x:(x,),pnameArg='bufSize',orPassIn=True +).setOutput( + 'severities',size=lambda x:(x,),pnameArg='count',orPassIn=True +).setOutput( + 'sources',size=lambda x:(x,),pnameArg='count',orPassIn=True +).setOutput( + 'types',size=lambda x:(x,),pnameArg='count',orPassIn=True +) +# INPUT glPushDebugGroup.message size not checked against 'message,length' +glPushDebugGroup=wrapper.wrapper(glPushDebugGroup).setInputArraySize( + 'message', None +) +# INPUT glObjectLabel.label size not checked against 'label,length' +glObjectLabel=wrapper.wrapper(glObjectLabel).setInputArraySize( + 'label', None +) +glGetObjectLabel=wrapper.wrapper(glGetObjectLabel).setOutput( + 'label',size=lambda x:(x,),pnameArg='bufSize',orPassIn=True +).setOutput( + 'length',size=(1,),orPassIn=True +) +# INPUT glObjectPtrLabel.label size not checked against 'label,length' +glObjectPtrLabel=wrapper.wrapper(glObjectPtrLabel).setInputArraySize( + 'label', None +) +glGetObjectPtrLabel=wrapper.wrapper(glGetObjectPtrLabel).setOutput( + 'label',size=lambda x:(x,),pnameArg='bufSize',orPassIn=True +).setOutput( + 'length',size=(1,),orPassIn=True +) +glGetPointerv=wrapper.wrapper(glGetPointerv).setOutput( + 'params',size=(1,),orPassIn=True +) +### END AUTOGENERATED SECTION + +from OpenGL.GL.ARB.arrays_of_arrays import * +from OpenGL.GL.ARB.fragment_layer_viewport import * +from OpenGL.GL.ARB.shader_image_size import * +from OpenGL.GL.ARB.ES3_compatibility import * +from OpenGL.GL.ARB.clear_buffer_object import * +from OpenGL.GL.ARB.compute_shader import * +from OpenGL.GL.ARB.copy_image import * +# Extension registry no longer defines these extensions? +#from OpenGL.GL.ARB.debug_group import * +#from OpenGL.GL.ARB.debug_label import * +#from OpenGL.GL.ARB.debug_output2 import * +from OpenGL.GL.KHR.debug import * +from OpenGL.GL.ARB.explicit_uniform_location import * +from OpenGL.GL.ARB.framebuffer_no_attachments import * +from OpenGL.GL.ARB.internalformat_query2 import * +from OpenGL.GL.ARB.invalidate_subdata import * +from OpenGL.GL.ARB.multi_draw_indirect import * +from OpenGL.GL.ARB.program_interface_query import * +from OpenGL.GL.ARB.robust_buffer_access_behavior import * +from OpenGL.GL.ARB.shader_storage_buffer_object import * +from OpenGL.GL.ARB.stencil_texturing import * +from OpenGL.GL.ARB.texture_buffer_range import * +from OpenGL.GL.ARB.texture_query_levels import * +from OpenGL.GL.ARB.texture_storage_multisample import * +from OpenGL.GL.ARB.texture_view import * +from OpenGL.GL.ARB.vertex_attrib_binding import * diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/VERSION/GL_4_4.py b/venv/lib/python3.12/site-packages/OpenGL/GL/VERSION/GL_4_4.py new file mode 100644 index 00000000..4fbd8367 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/VERSION/GL_4_4.py @@ -0,0 +1,70 @@ +'''OpenGL extension VERSION.GL_4_4 + +This module customises the behaviour of the +OpenGL.raw.GL.VERSION.GL_4_4 to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/VERSION/GL_4_4.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.VERSION.GL_4_4 import * +from OpenGL.raw.GL.VERSION.GL_4_4 import _EXTENSION_NAME + +def glInitGl44VERSION(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glBufferStorage.data size not checked against size +glBufferStorage=wrapper.wrapper(glBufferStorage).setInputArraySize( + 'data', None +) +# INPUT glClearTexImage.data size not checked against 'format,type' +glClearTexImage=wrapper.wrapper(glClearTexImage).setInputArraySize( + 'data', None +) +# INPUT glClearTexSubImage.data size not checked against 'format,type' +glClearTexSubImage=wrapper.wrapper(glClearTexSubImage).setInputArraySize( + 'data', None +) +# INPUT glBindBuffersBase.buffers size not checked against count +glBindBuffersBase=wrapper.wrapper(glBindBuffersBase).setInputArraySize( + 'buffers', None +) +# INPUT glBindBuffersRange.buffers size not checked against count +# INPUT glBindBuffersRange.offsets size not checked against count +# INPUT glBindBuffersRange.sizes size not checked against count +glBindBuffersRange=wrapper.wrapper(glBindBuffersRange).setInputArraySize( + 'buffers', None +).setInputArraySize( + 'offsets', None +).setInputArraySize( + 'sizes', None +) +# INPUT glBindTextures.textures size not checked against count +glBindTextures=wrapper.wrapper(glBindTextures).setInputArraySize( + 'textures', None +) +# INPUT glBindSamplers.samplers size not checked against count +glBindSamplers=wrapper.wrapper(glBindSamplers).setInputArraySize( + 'samplers', None +) +# INPUT glBindImageTextures.textures size not checked against count +glBindImageTextures=wrapper.wrapper(glBindImageTextures).setInputArraySize( + 'textures', None +) +# INPUT glBindVertexBuffers.buffers size not checked against count +# INPUT glBindVertexBuffers.offsets size not checked against count +# INPUT glBindVertexBuffers.strides size not checked against count +glBindVertexBuffers=wrapper.wrapper(glBindVertexBuffers).setInputArraySize( + 'buffers', None +).setInputArraySize( + 'offsets', None +).setInputArraySize( + 'strides', None +) +### END AUTOGENERATED SECTION diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/VERSION/GL_4_5.py b/venv/lib/python3.12/site-packages/OpenGL/GL/VERSION/GL_4_5.py new file mode 100644 index 00000000..ab5eb766 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/VERSION/GL_4_5.py @@ -0,0 +1,90 @@ +'''OpenGL extension VERSION.GL_4_5 + +This module customises the behaviour of the +OpenGL.raw.GL.VERSION.GL_4_5 to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/VERSION/GL_4_5.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.VERSION.GL_4_5 import * +from OpenGL.raw.GL.VERSION.GL_4_5 import _EXTENSION_NAME + +def glInitGl45VERSION(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glCreateTransformFeedbacks.ids size not checked against n +glCreateTransformFeedbacks=wrapper.wrapper(glCreateTransformFeedbacks).setInputArraySize( + 'ids', None +) +# INPUT glCreateBuffers.buffers size not checked against n +glCreateBuffers=wrapper.wrapper(glCreateBuffers).setInputArraySize( + 'buffers', None +) +# INPUT glNamedBufferStorage.data size not checked against size +glNamedBufferStorage=wrapper.wrapper(glNamedBufferStorage).setInputArraySize( + 'data', None +) +# INPUT glNamedBufferSubData.data size not checked against 'size' +glNamedBufferSubData=wrapper.wrapper(glNamedBufferSubData).setInputArraySize( + 'data', None +) +# INPUT glCreateFramebuffers.framebuffers size not checked against n +glCreateFramebuffers=wrapper.wrapper(glCreateFramebuffers).setInputArraySize( + 'framebuffers', None +) +# INPUT glCreateRenderbuffers.renderbuffers size not checked against n +glCreateRenderbuffers=wrapper.wrapper(glCreateRenderbuffers).setInputArraySize( + 'renderbuffers', None +) +# INPUT glCreateTextures.textures size not checked against n +glCreateTextures=wrapper.wrapper(glCreateTextures).setInputArraySize( + 'textures', None +) +# INPUT glCreateVertexArrays.arrays size not checked against n +glCreateVertexArrays=wrapper.wrapper(glCreateVertexArrays).setInputArraySize( + 'arrays', None +) +# INPUT glCreateSamplers.samplers size not checked against n +glCreateSamplers=wrapper.wrapper(glCreateSamplers).setInputArraySize( + 'samplers', None +) +# INPUT glCreateProgramPipelines.pipelines size not checked against n +glCreateProgramPipelines=wrapper.wrapper(glCreateProgramPipelines).setInputArraySize( + 'pipelines', None +) +# INPUT glCreateQueries.ids size not checked against n +glCreateQueries=wrapper.wrapper(glCreateQueries).setInputArraySize( + 'ids', None +) +# INPUT glGetnTexImage.pixels size not checked against bufSize +glGetnTexImage=wrapper.wrapper(glGetnTexImage).setInputArraySize( + 'pixels', None +) +# INPUT glGetnUniformdv.params size not checked against bufSize +glGetnUniformdv=wrapper.wrapper(glGetnUniformdv).setInputArraySize( + 'params', None +) +# INPUT glGetnUniformfv.params size not checked against bufSize +glGetnUniformfv=wrapper.wrapper(glGetnUniformfv).setInputArraySize( + 'params', None +) +# INPUT glGetnUniformiv.params size not checked against bufSize +glGetnUniformiv=wrapper.wrapper(glGetnUniformiv).setInputArraySize( + 'params', None +) +# INPUT glGetnUniformuiv.params size not checked against bufSize +glGetnUniformuiv=wrapper.wrapper(glGetnUniformuiv).setInputArraySize( + 'params', None +) +# INPUT glReadnPixels.data size not checked against bufSize +glReadnPixels=wrapper.wrapper(glReadnPixels).setInputArraySize( + 'data', None +) +### END AUTOGENERATED SECTION diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/VERSION/GL_4_6.py b/venv/lib/python3.12/site-packages/OpenGL/GL/VERSION/GL_4_6.py new file mode 100644 index 00000000..b406e3f0 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/VERSION/GL_4_6.py @@ -0,0 +1,23 @@ +'''OpenGL extension VERSION.GL_4_6 + +This module customises the behaviour of the +OpenGL.raw.GL.VERSION.GL_4_6 to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/VERSION/GL_4_6.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.VERSION.GL_4_6 import * +from OpenGL.raw.GL.VERSION.GL_4_6 import _EXTENSION_NAME + +def glInitGl46VERSION(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/VERSION/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/GL/VERSION/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/VERSION/__pycache__/GL_1_0.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/VERSION/__pycache__/GL_1_0.cpython-312.pyc new file mode 100644 index 00000000..52580713 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/VERSION/__pycache__/GL_1_0.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/VERSION/__pycache__/GL_1_1.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/VERSION/__pycache__/GL_1_1.cpython-312.pyc new file mode 100644 index 00000000..ee49f493 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/VERSION/__pycache__/GL_1_1.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/VERSION/__pycache__/GL_1_2.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/VERSION/__pycache__/GL_1_2.cpython-312.pyc new file mode 100644 index 00000000..389350e1 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/VERSION/__pycache__/GL_1_2.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/VERSION/__pycache__/GL_1_2_images.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/VERSION/__pycache__/GL_1_2_images.cpython-312.pyc new file mode 100644 index 00000000..c8f847a1 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/VERSION/__pycache__/GL_1_2_images.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/VERSION/__pycache__/GL_1_3.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/VERSION/__pycache__/GL_1_3.cpython-312.pyc new file mode 100644 index 00000000..50bc4686 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/VERSION/__pycache__/GL_1_3.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/VERSION/__pycache__/GL_1_4.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/VERSION/__pycache__/GL_1_4.cpython-312.pyc new file mode 100644 index 00000000..1a4bfd4b Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/VERSION/__pycache__/GL_1_4.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/VERSION/__pycache__/GL_1_5.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/VERSION/__pycache__/GL_1_5.cpython-312.pyc new file mode 100644 index 00000000..103e0a77 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/VERSION/__pycache__/GL_1_5.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/VERSION/__pycache__/GL_2_0.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/VERSION/__pycache__/GL_2_0.cpython-312.pyc new file mode 100644 index 00000000..25b33e36 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/VERSION/__pycache__/GL_2_0.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/VERSION/__pycache__/GL_2_1.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/VERSION/__pycache__/GL_2_1.cpython-312.pyc new file mode 100644 index 00000000..4a03e443 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/VERSION/__pycache__/GL_2_1.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/VERSION/__pycache__/GL_3_0.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/VERSION/__pycache__/GL_3_0.cpython-312.pyc new file mode 100644 index 00000000..9dd0bc7a Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/VERSION/__pycache__/GL_3_0.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/VERSION/__pycache__/GL_3_1.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/VERSION/__pycache__/GL_3_1.cpython-312.pyc new file mode 100644 index 00000000..61a0f7e0 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/VERSION/__pycache__/GL_3_1.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/VERSION/__pycache__/GL_3_2.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/VERSION/__pycache__/GL_3_2.cpython-312.pyc new file mode 100644 index 00000000..1df6599c Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/VERSION/__pycache__/GL_3_2.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/VERSION/__pycache__/GL_3_3.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/VERSION/__pycache__/GL_3_3.cpython-312.pyc new file mode 100644 index 00000000..9b8de915 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/VERSION/__pycache__/GL_3_3.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/VERSION/__pycache__/GL_4_0.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/VERSION/__pycache__/GL_4_0.cpython-312.pyc new file mode 100644 index 00000000..63401b17 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/VERSION/__pycache__/GL_4_0.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/VERSION/__pycache__/GL_4_1.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/VERSION/__pycache__/GL_4_1.cpython-312.pyc new file mode 100644 index 00000000..6ef564e6 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/VERSION/__pycache__/GL_4_1.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/VERSION/__pycache__/GL_4_2.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/VERSION/__pycache__/GL_4_2.cpython-312.pyc new file mode 100644 index 00000000..99a10207 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/VERSION/__pycache__/GL_4_2.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/VERSION/__pycache__/GL_4_3.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/VERSION/__pycache__/GL_4_3.cpython-312.pyc new file mode 100644 index 00000000..5d38a2a5 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/VERSION/__pycache__/GL_4_3.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/VERSION/__pycache__/GL_4_4.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/VERSION/__pycache__/GL_4_4.cpython-312.pyc new file mode 100644 index 00000000..211a2205 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/VERSION/__pycache__/GL_4_4.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/VERSION/__pycache__/GL_4_5.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/VERSION/__pycache__/GL_4_5.cpython-312.pyc new file mode 100644 index 00000000..441dcc72 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/VERSION/__pycache__/GL_4_5.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/VERSION/__pycache__/GL_4_6.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/VERSION/__pycache__/GL_4_6.cpython-312.pyc new file mode 100644 index 00000000..60a2e704 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/VERSION/__pycache__/GL_4_6.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/VERSION/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/VERSION/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..5c0d5c48 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/VERSION/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/VIV/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/GL/VIV/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/VIV/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/VIV/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/VIV/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..29fd6848 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/VIV/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/WIN/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/GL/WIN/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/WIN/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/WIN/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/WIN/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..9f0d2494 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/WIN/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/WIN/__pycache__/phong_shading.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/WIN/__pycache__/phong_shading.cpython-312.pyc new file mode 100644 index 00000000..99789db0 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/WIN/__pycache__/phong_shading.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/WIN/__pycache__/specular_fog.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/WIN/__pycache__/specular_fog.cpython-312.pyc new file mode 100644 index 00000000..d6da8bf6 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/WIN/__pycache__/specular_fog.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/WIN/phong_shading.py b/venv/lib/python3.12/site-packages/OpenGL/GL/WIN/phong_shading.py new file mode 100644 index 00000000..17472ac6 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/WIN/phong_shading.py @@ -0,0 +1,39 @@ +'''OpenGL extension WIN.phong_shading + +This module customises the behaviour of the +OpenGL.raw.GL.WIN.phong_shading to provide a more +Python-friendly API + +Overview (from the spec) + + WIN_phong_shading enables rendering Phong shaded primitives using OpenGL. + Phong shading is a well known shading technique documented + in most graphics texts. + + As opposed to Gouraud (or smooth) shading, which simply calculates the + normals at the vertices and then interpolates the colors of the pixels, + Phong shading involves interpolating an individual normal for every pixel, + and then applying the shading model to each pixel based on its normal + component. + + While Phong shading requires substantially more computation than does + Gouraud shading, the resulting images are more realistic, especially if the + primitives are large. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/WIN/phong_shading.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.WIN.phong_shading import * +from OpenGL.raw.GL.WIN.phong_shading import _EXTENSION_NAME + +def glInitPhongShadingWIN(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/WIN/specular_fog.py b/venv/lib/python3.12/site-packages/OpenGL/GL/WIN/specular_fog.py new file mode 100644 index 00000000..e1ad4e58 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/WIN/specular_fog.py @@ -0,0 +1,50 @@ +'''OpenGL extension WIN.specular_fog + +This module customises the behaviour of the +OpenGL.raw.GL.WIN.specular_fog to provide a more +Python-friendly API + +Overview (from the spec) + + Specularly lit textures enhance the realism of a scene greatly. + Using the current OpenGL lighting model, one cannot obtain specularly lit + textures. This is because in the current OpenGL lighting model lighting + is done ahead of texturing and texture-functions such as modulate are + inadequate for such a simulation. What needs to be addressed is that, + somehow an additional interpolant (specular color of that material) needs + to be propagated till that stage of the pipeline where texture-mapping is + performed. This interpolant is then added on to the fragment's color + resulting from the texturing process before proceeding with the rest of + the pipeline. + + This can be addressed very easily in software, but hardware + is not so malleable. Currently most hardware does not support such a + + lighting model. However, some current hardware does support fogging, + which takes place in the pipeline after texturing. This hardware + assumes that the fog blend factor f is computed per-vertex and + interpolates the value across the primitive. The WIN_specular_fog + extension enables the use of such existing fog circuitry to obtain + specularly lit textures without much performance degradation. + + To use it the programmer simply enables the extension with a call to + Enable with the appropriate enumerant and sets the fog color to the + desired specular color. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/WIN/specular_fog.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GL import _types, _glgets +from OpenGL.raw.GL.WIN.specular_fog import * +from OpenGL.raw.GL.WIN.specular_fog import _EXTENSION_NAME + +def glInitSpecularFogWIN(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/GL/__init__.py new file mode 100644 index 00000000..a8ca459a --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/__init__.py @@ -0,0 +1,49 @@ +"""OpenGL.GL, the core GL library and extensions to it""" +# early import of our modules to prevent import loops... +from OpenGL import error as _error +from OpenGL.GL.VERSION.GL_1_1 import * +from OpenGL.GL.pointers import * +from OpenGL.GL.images import * + +from OpenGL.GL.exceptional import * + +from OpenGL.GL.glget import * + +from OpenGL.GL.VERSION.GL_1_2 import * +from OpenGL.GL.VERSION.GL_1_3 import * +from OpenGL.GL.VERSION.GL_1_4 import * +from OpenGL.GL.VERSION.GL_1_5 import * +from OpenGL.GL.VERSION.GL_2_0 import * +from OpenGL.GL.VERSION.GL_2_1 import * +from OpenGL.GL.VERSION.GL_3_0 import * +from OpenGL.GL.VERSION.GL_3_1 import * +from OpenGL.GL.VERSION.GL_3_2 import * +from OpenGL.GL.VERSION.GL_3_3 import * +from OpenGL.GL.VERSION.GL_4_0 import * +from OpenGL.GL.VERSION.GL_4_1 import * +from OpenGL.GL.VERSION.GL_4_2 import * +from OpenGL.GL.VERSION.GL_4_3 import * +from OpenGL.GL.VERSION.GL_4_4 import * +from OpenGL.GL.VERSION.GL_4_5 import * +from OpenGL.GL.VERSION.GL_4_6 import * + +from OpenGL.error import * +GLerror = GLError + +# Now the aliases... +glRotate = glRotated +glTranslate = glTranslated +glLight = glLightfv +glTexCoord = glTexCoord2d +glScale = glScaled +#glColor = glColor3f +glNormal = glNormal3d + +glGetBoolean = glGetBooleanv +glGetDouble = glGetDoublev +glGetFloat = glGetFloatv +glGetInteger = glGetIntegerv +glGetPolygonStippleub = glGetPolygonStipple + +from OpenGL.GL import vboimplementation as _core_implementation +from OpenGL.GL.ARB import vboimplementation as _arb_implementation diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..a0031943 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/__pycache__/exceptional.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/__pycache__/exceptional.cpython-312.pyc new file mode 100644 index 00000000..5de254d9 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/__pycache__/exceptional.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/__pycache__/feedback.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/__pycache__/feedback.cpython-312.pyc new file mode 100644 index 00000000..4ebc6b6d Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/__pycache__/feedback.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/__pycache__/framebufferobjects.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/__pycache__/framebufferobjects.cpython-312.pyc new file mode 100644 index 00000000..0ba13b5a Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/__pycache__/framebufferobjects.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/__pycache__/glget.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/__pycache__/glget.cpython-312.pyc new file mode 100644 index 00000000..cb1e0c13 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/__pycache__/glget.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/__pycache__/images.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/__pycache__/images.cpython-312.pyc new file mode 100644 index 00000000..ebe970d7 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/__pycache__/images.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/__pycache__/pointers.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/__pycache__/pointers.cpython-312.pyc new file mode 100644 index 00000000..2bce4a58 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/__pycache__/pointers.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/__pycache__/selection.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/__pycache__/selection.cpython-312.pyc new file mode 100644 index 00000000..a15cab5d Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/__pycache__/selection.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/__pycache__/shaders.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/__pycache__/shaders.cpython-312.pyc new file mode 100644 index 00000000..27bbd061 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/__pycache__/shaders.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/__pycache__/vboimplementation.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GL/__pycache__/vboimplementation.cpython-312.pyc new file mode 100644 index 00000000..cf5ae486 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GL/__pycache__/vboimplementation.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/exceptional.py b/venv/lib/python3.12/site-packages/OpenGL/GL/exceptional.py new file mode 100644 index 00000000..4d083783 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/exceptional.py @@ -0,0 +1,264 @@ +"""Exceptional cases that need some extra wrapping""" +from OpenGL import arrays +from OpenGL.arrays.arraydatatype import GLfloatArray +from OpenGL.lazywrapper import lazy as _lazy +from OpenGL.GL.VERSION import GL_1_1 as full +from OpenGL.raw.GL import _errors +from OpenGL._bytes import bytes +from OpenGL import _configflags +from OpenGL._null import NULL as _NULL +import ctypes + +__all__ = [ + 'glBegin', + 'glCallLists', + 'glColor', + 'glDeleteTextures', + 'glEnd', + 'glMap1d', + 'glMap1f', + 'glMap2d', + 'glMap2f', + 'glMaterial', + 'glRasterPos', + 'glTexParameter', + 'glVertex', + 'glAreTexturesResident', +] + +glRasterPosDispatch = { + 2: full.glRasterPos2d, + 3: full.glRasterPos3d, + 4: full.glRasterPos4d, +} + +if _configflags.ERROR_CHECKING: + @_lazy( full.glBegin ) + def glBegin( baseFunction, mode ): + """Begin GL geometry-definition mode, disable automatic error checking""" + _errors._error_checker.onBegin( ) + return baseFunction( mode ) + @_lazy( full.glEnd ) + def glEnd( baseFunction ): + """Finish GL geometry-definition mode, re-enable automatic error checking""" + _errors._error_checker.onEnd( ) + return baseFunction( ) +else: + glBegin = full.glBegin + glEnd = full.glEnd + +@_lazy( full.glDeleteTextures ) +def glDeleteTextures( baseFunction, size, array=_NULL ): + """Delete specified set of textures + + If array is *not* passed then `size` must be a `GLuintArray` + compatible object which can be sized using `arraySize`, the + result of which will be used as size. + """ + if array is _NULL: + ptr = arrays.GLuintArray.asArray( size ) + size = arrays.GLuintArray.arraySize( ptr ) + else: + ptr = array + return baseFunction( size, ptr ) + + +def glMap2( baseFunction, arrayType ): + def glMap2( target, u1, u2, v1, v2, points): + """glMap2(target, u1, u2, v1, v2, points[][][]) -> None + + This is a completely non-standard signature which doesn't allow for most + of the funky uses with strides and the like, but it has been like this for + a very long time... + """ + ptr = arrayType.asArray( points ) + uorder,vorder,vstride = arrayType.dimensions( ptr ) + ustride = vstride*vorder + return baseFunction( + target, + u1, u2, + ustride, uorder, + v1, v2, + vstride, vorder, + ptr + ) + glMap2.__name__ = baseFunction.__name__ + glMap2.baseFunction = baseFunction + return glMap2 +glMap2d = glMap2( full.glMap2d, arrays.GLdoubleArray ) +glMap2f = glMap2( full.glMap2f, arrays.GLfloatArray ) +try: + del glMap2 +except NameError as err: + pass + +def glMap1( baseFunction, arrayType ): + def glMap1(target,u1,u2,points): + """glMap1(target, u1, u2, points[][][]) -> None + + This is a completely non-standard signature which doesn't allow for most + of the funky uses with strides and the like, but it has been like this for + a very long time... + """ + ptr = arrayType.asArray( points ) + dims = arrayType.dimensions( ptr ) + uorder = dims[0] + ustride = dims[1] + return baseFunction( target, u1,u2,ustride,uorder, ptr ) + glMap1.__name__ == baseFunction.__name__ + glMap1.baseFunction = baseFunction + return glMap1 +glMap1d = glMap1( full.glMap1d, arrays.GLdoubleArray ) +glMap1f = glMap1( full.glMap1f, arrays.GLfloatArray ) +try: + del glMap1 +except NameError as err: + pass + +def glRasterPos( *args ): + """Choose glRasterPosX based on number of args""" + if len(args) == 1: + # v form... + args = args[0] + function = glRasterPosDispatch[ len(args) ] + return function( *args ) + +glVertexDispatch = { + 2: full.glVertex2d, + 3: full.glVertex3d, + 4: full.glVertex4d, +} +def glVertex( *args ): + """Choose glVertexX based on number of args""" + if len(args) == 1: + # v form... + args = args[0] + return glVertexDispatch[ len(args) ]( *args ) + +@_lazy( full.glCallLists ) +def glCallLists( baseFunction, lists, *args ): + """glCallLists( bytes( lists ) or lists[] ) -> None + + Restricted version of glCallLists, takes a string or a GLuint compatible + array data-type and passes into the base function. + """ + if not len(args): + if isinstance( lists, bytes ): + return baseFunction( + len(lists), + full.GL_UNSIGNED_BYTE, + ctypes.c_void_p(arrays.GLubyteArray.dataPointer( lists )), + ) + ptr = arrays.GLuintArray.asArray( lists ) + size = arrays.GLuintArray.arraySize( ptr ) + return baseFunction( + size, + full.GL_UNSIGNED_INT, + ctypes.c_void_p( arrays.GLuintArray.dataPointer(ptr)) + ) + return baseFunction( lists, *args ) + +def glTexParameter( target, pname, parameter ): + """Set a texture parameter, choose underlying call based on pname and parameter""" + if isinstance( parameter, float ): + return full.glTexParameterf( target, pname, parameter ) + elif isinstance( parameter, int ): + return full.glTexParameteri( target, pname, parameter ) + else: + value = GLfloatArray.asArray( parameter, full.GL_FLOAT ) + return full.glTexParameterfv( target, pname, value ) + +def glMaterial( faces, constant, *args ): + """glMaterial -- convenience function to dispatch on argument type + + If passed a single argument in args, calls: + glMaterialfv( faces, constant, args[0] ) + else calls: + glMaterialf( faces, constant, *args ) + """ + if len(args) == 1: + arg = GLfloatArray.asArray( args[0] ) + if arg is None: + raise ValueError( """Null value in glMaterial: %s"""%(args,) ) + return full.glMaterialfv( faces, constant, arg ) + else: + return full.glMaterialf( faces, constant, *args ) + +glColorDispatch = { + 3: full.glColor3fv, + 4: full.glColor4fv, +} + +def glColor( *args ): + """glColor*f* -- convenience function to dispatch on argument type + + dispatches to glColor3f, glColor2f, glColor4f, glColor3f, glColor2f, glColor4f + depending on the arguments passed... + """ + arglen = len(args) + if arglen == 1: + arg = arrays.GLfloatArray.asArray( args[0] ) + function = glColorDispatch[arrays.GLfloatArray.arraySize( arg )] + return function( arg ) + elif arglen == 2: + return full.glColor2d( *args ) + elif arglen == 3: + return full.glColor3d( *args ) + elif arglen == 4: + return full.glColor4d( *args ) + else: + raise ValueError( """Don't know how to handle arguments: %s"""%(args,)) + + +# Rectagle coordinates, +@_lazy( full.glAreTexturesResident ) +def glAreTexturesResident( baseFunction, *args ): + """Allow both Pythonic and C-style calls to glAreTexturesResident + + glAreTexturesResident( arrays.GLuintArray( textures) ) + + or + + glAreTexturesResident( int(n), arrays.GLuintArray( textures), arrays.GLuboolean( output) ) + + or + + glAreTexturesResident( int(n), arrays.GLuintArray( textures) ) + + returns the output arrays.GLubooleanArray + """ + if len(args) == 1: + # Pythonic form... + textures = args[0] + textures = arrays.GLuintArray.asArray( textures ) + n = arrays.GLuintArray.arraySize(textures) + output = arrays.GLbooleanArray.zeros( (n,)) + elif len(args) == 2: + try: + n = int( args[0] ) + except TypeError: + textures = args[0] + textures = arrays.GLuintArray.asArray( textures ) + + n = arrays.GLuintArray.arraySize(textures) + output = args[1] + output = arrays.GLbooleanArray.asArray( output ) + else: + textures = args[1] + textures = arrays.GLuintArray.asArray( textures ) + + output = arrays.GLbooleanArray.zeros( (n,)) + elif len(args) == 3: + n,textures,output = args + textures = arrays.GLuintArray.asArray( textures ) + output = arrays.GLbooleanArray.asArray( output ) + else: + raise TypeError( """Expected 1 to 3 arguments to glAreTexturesResident""" ) + texturePtr = arrays.GLuintArray.typedPointer( textures ) + outputPtr = arrays.GLbooleanArray.typedPointer( output ) + result = baseFunction( n, texturePtr, outputPtr ) + if result: + # weirdness of the C api, doesn't produce values if all are true + for i in range(len(output)): + output[i] = 1 + return output diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/feedback.py b/venv/lib/python3.12/site-packages/OpenGL/GL/feedback.py new file mode 100644 index 00000000..209858d1 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/feedback.py @@ -0,0 +1,86 @@ +"""Utility module to parse a Feedback buffer""" +from OpenGL import contextdata +from OpenGL.GL.VERSION import GL_1_1 as _simple + +def parseFeedback( buffer, entryCount ): + """Parse the feedback buffer into Python object records""" + bufferIndex = 0 + result = [] + getVertex = createGetVertex( ) + while bufferIndex < entryCount: + token = int(buffer[bufferIndex]) + bufferIndex += 1 + if token in SINGLE_VERTEX_TOKENS: + vData, bufferIndex = getVertex( buffer, bufferIndex ) + result.append( (SINGLE_VERTEX_TOKENS.get(token), Vertex(*vData)) ) + elif token in DOUBLE_VERTEX_TOKENS: + vData, bufferIndex = getVertex( buffer, bufferIndex ) + vData2, bufferIndex = getVertex( buffer, bufferIndex ) + result.append( ( + DOUBLE_VERTEX_TOKENS.get(token), + Vertex(*vData), + Vertex(*vData2), + ) ) + elif token == _simple.GL_PASS_THROUGH_TOKEN: + result.append( (_simple.GL_PASS_THROUGH_TOKEN, buffer[bufferIndex])) + bufferIndex += 1 + elif token == _simple.GL_POLYGON_TOKEN: + temp = [_simple.GL_POLYGON_TOKEN] + count = int(buffer[bufferIndex]) + bufferIndex += 1 + for item in range(count): + vData,bufferIndex = getVertex( buffer, bufferIndex ) + temp.append( Vertex(*vData)) + result.append( tuple(temp)) + else: + raise ValueError( + """Unrecognised token %r in feedback stream"""%(token,) + ) + return result + +SINGLE_VERTEX_TOKENS = { + _simple.GL_BITMAP_TOKEN: _simple.GL_BITMAP_TOKEN, + _simple.GL_COPY_PIXEL_TOKEN: _simple.GL_COPY_PIXEL_TOKEN, + _simple.GL_DRAW_PIXEL_TOKEN: _simple.GL_DRAW_PIXEL_TOKEN, + _simple.GL_POINT_TOKEN: _simple.GL_POINT_TOKEN, +} +DOUBLE_VERTEX_TOKENS = { + _simple.GL_LINE_TOKEN: _simple.GL_LINE_TOKEN, + _simple.GL_LINE_RESET_TOKEN: _simple.GL_LINE_RESET_TOKEN, +} +class Vertex( object ): + """Simplistic holder for vertex data from a feedback buffer""" + __slots__ = ('vertex','color','texture') + def __init__( self, vertex,color=None,texture=None): + """Store values for access""" + self.vertex = vertex + self.color = color + self.texture = texture +def createGetVertex( ): + mode = contextdata.getValue( "GL_FEEDBACK_BUFFER_TYPE" ) + indexMode = _simple.glGetBooleanv( _simple.GL_INDEX_MODE ) + colorSize = [ 4,1 ][ int(indexMode) ] + if mode in (_simple.GL_2D,_simple.GL_3D): + if mode == _simple.GL_2D: + size = 2 + else: + size = 3 + def getVertex( buffer, bufferIndex ): + end = bufferIndex+size + return (buffer[bufferIndex:end],None,None),end + elif mode == _simple.GL_3D_COLOR: + def getVertex( buffer, bufferIndex ): + end = bufferIndex+3 + colorEnd = end + colorSize + return (buffer[bufferIndex:end],buffer[end:colorEnd],None),colorEnd + else: + if mode == _simple.GL_3D_COLOR_TEXTURE: + size = 3 + else: + size = 4 + def getVertex( buffer, bufferIndex ): + end = bufferIndex+size + colorEnd = end + colorSize + textureEnd = colorEnd + 4 + return (buffer[bufferIndex:end],buffer[end:colorEnd],buffer[colorEnd:textureEnd]),textureEnd + return getVertex diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/framebufferobjects.py b/venv/lib/python3.12/site-packages/OpenGL/GL/framebufferobjects.py new file mode 100644 index 00000000..7ac60491 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/framebufferobjects.py @@ -0,0 +1,57 @@ +"""Convenience API for using Frame Buffer Objects""" +from OpenGL.extensions import alternate +from OpenGL.GL.ARB.framebuffer_object import * +from OpenGL.GL.EXT.framebuffer_object import * +from OpenGL.GL.EXT.framebuffer_multisample import * +from OpenGL.GL.EXT.framebuffer_blit import * + +glBindFramebuffer = alternate(glBindFramebuffer,glBindFramebufferEXT) +glBindRenderbuffer = alternate( glBindRenderbuffer, glBindRenderbufferEXT ) +glCheckFramebufferStatus = alternate( glCheckFramebufferStatus, glCheckFramebufferStatusEXT ) +glDeleteFramebuffers = alternate( glDeleteFramebuffers, glDeleteFramebuffersEXT ) +glDeleteRenderbuffers = alternate( glDeleteRenderbuffers, glDeleteRenderbuffersEXT ) +glFramebufferRenderbuffer = alternate( glFramebufferRenderbuffer, glFramebufferRenderbufferEXT ) +glFramebufferTexture1D = alternate( glFramebufferTexture1D, glFramebufferTexture1DEXT ) +glFramebufferTexture2D = alternate( glFramebufferTexture2D, glFramebufferTexture2DEXT ) +glFramebufferTexture3D = alternate( glFramebufferTexture3D, glFramebufferTexture3DEXT ) +glGenFramebuffers = alternate( glGenFramebuffers, glGenFramebuffersEXT ) +glGenRenderbuffers = alternate( glGenRenderbuffers, glGenRenderbuffersEXT ) +glGenerateMipmap = alternate( glGenerateMipmap, glGenerateMipmapEXT ) +glGetFramebufferAttachmentParameteriv = alternate( glGetFramebufferAttachmentParameteriv, glGetFramebufferAttachmentParameterivEXT ) +glGetRenderbufferParameteriv = alternate( glGetRenderbufferParameteriv, glGetRenderbufferParameterivEXT ) +glIsFramebuffer = alternate( glIsFramebuffer, glIsFramebufferEXT ) +glIsRenderbuffer = alternate( glIsRenderbuffer, glIsRenderbufferEXT ) +glRenderbufferStorage = alternate( glRenderbufferStorage, glRenderbufferStorageEXT ) + +glBlitFramebuffer = alternate( glBlitFramebuffer, glBlitFramebufferEXT ) +glRenderbufferStorageMultisample = alternate( glRenderbufferStorageMultisample, glRenderbufferStorageMultisampleEXT ) + +# this entry point is new to the ARB version of the extensions +#glFramebufferTextureLayer = alternate( glFramebufferTextureLayer, glFramebufferTextureLayerEXT ) + + +def checkFramebufferStatus(): + """Utility method to check status and raise errors""" + status = glCheckFramebufferStatus( GL_FRAMEBUFFER ) + if status == GL_FRAMEBUFFER_COMPLETE: + return True + from OpenGL.error import GLError + description = None + for error_constant in [ + GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT, + GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT, + GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS, + GL_FRAMEBUFFER_INCOMPLETE_FORMATS, + GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER, + GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER, + GL_FRAMEBUFFER_UNSUPPORTED, + ]: + if status == error_constant: + status = error_constant + description = str(status) + raise GLError( + err=status, + result=status, + baseOperation=glCheckFramebufferStatus, + description=description, + ) diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/glget.py b/venv/lib/python3.12/site-packages/OpenGL/GL/glget.py new file mode 100644 index 00000000..287eb519 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/glget.py @@ -0,0 +1,23 @@ +"""Implementation of the special "glGet" functions + +For comparison, here's what a straightforward implementation looks like: + + def glGetDoublev( pname ): + "Natural writing of glGetDoublev using standard ctypes" + output = c_double*sizes.get( pname ) + result = output() + result = platform.PLATFORM.GL.glGetDoublev( pname, byref(result) ) + return Numeric.array( result ) +""" +from OpenGL.GL.VERSION import GL_1_1 as _simple +import ctypes +GLenum = ctypes.c_uint +GLsize = GLsizei = ctypes.c_int + +__all__ = ( + 'glGetString', +) + +glGetString = _simple.glGetString +glGetString.restype = ctypes.c_char_p +glGetString.__doc__ = """glGetString( constant ) -> Current string value""" diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/images.py b/venv/lib/python3.12/site-packages/OpenGL/GL/images.py new file mode 100644 index 00000000..50b9c74e --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/images.py @@ -0,0 +1,630 @@ +"""Image-handling routines + +### Unresolved: + + Following methods are not yet resolved due to my not being sure how the + function should be wrapped: + + glCompressedTexImage3D + glCompressedTexImage2D + glCompressedTexImage1D + glCompressedTexSubImage3D + glCompressedTexSubImage2D + glCompressedTexSubImage1D +""" +from OpenGL.raw.GL.VERSION import GL_1_1,GL_1_2, GL_3_0 +from OpenGL import images, arrays, wrapper +from OpenGL.arrays import arraydatatype +from OpenGL._bytes import bytes,integer_types +from OpenGL.raw.GL import _types +import ctypes + +def asInt( value ): + if isinstance( value, float ): + return int(round(value,0)) + return value + +## update the image tables with standard image types... +images.COMPONENT_COUNTS.update( { + GL_1_1.GL_BITMAP : 1, # must be GL_UNSIGNED_BYTE + + GL_1_1.GL_RED : 1, + GL_1_1.GL_GREEN : 1, + GL_1_1.GL_BLUE : 1, + GL_1_1.GL_ALPHA : 1, + GL_3_0.GL_RED_INTEGER : 1, + GL_3_0.GL_GREEN_INTEGER : 1, + GL_3_0.GL_BLUE_INTEGER : 1, + GL_3_0.GL_ALPHA_INTEGER : 1, + GL_1_1.GL_LUMINANCE : 1, + GL_1_1.GL_LUMINANCE_ALPHA : 2, + GL_1_1.GL_COLOR_INDEX : 1, + GL_1_1.GL_STENCIL_INDEX : 1, + GL_1_1.GL_DEPTH_COMPONENT : 1, + + GL_1_1.GL_RGB : 3, + GL_1_2.GL_BGR : 3, + GL_3_0.GL_RGB16F : 3, + GL_3_0.GL_RGB16I : 3, + GL_3_0.GL_RGB16UI : 3, + GL_3_0.GL_RGB32F : 3, + GL_3_0.GL_RGB32I : 3, + GL_3_0.GL_RGB32UI : 3, + GL_3_0.GL_RGB8I : 3, + GL_3_0.GL_RGB8UI : 3, + GL_3_0.GL_RGB9_E5 : 3, + GL_3_0.GL_RGB_INTEGER : 3, + + GL_1_1.GL_RGBA : 4, + GL_1_2.GL_BGRA : 4, + GL_3_0.GL_RGBA16F : 4, + GL_3_0.GL_RGBA16I : 4, + GL_3_0.GL_RGBA16UI : 4, + GL_3_0.GL_RGBA32F : 4, + GL_3_0.GL_RGBA32I : 4, + GL_3_0.GL_RGBA32UI : 4, + GL_3_0.GL_RGBA8I : 4, + GL_3_0.GL_RGBA8UI : 4, + GL_3_0.GL_RGBA_INTEGER : 4, +} ) + +images.TYPE_TO_ARRAYTYPE.update( { + GL_3_0.GL_HALF_FLOAT : GL_3_0.GL_HALF_FLOAT, + GL_1_2.GL_UNSIGNED_BYTE_3_3_2 : GL_1_1.GL_UNSIGNED_BYTE, + GL_1_2.GL_UNSIGNED_BYTE_2_3_3_REV : GL_1_1.GL_UNSIGNED_BYTE, + GL_1_2.GL_UNSIGNED_SHORT_4_4_4_4 : GL_1_1.GL_UNSIGNED_SHORT, + GL_1_2.GL_UNSIGNED_SHORT_4_4_4_4_REV : GL_1_1.GL_UNSIGNED_SHORT, + GL_1_2.GL_UNSIGNED_SHORT_5_5_5_1 : GL_1_1.GL_UNSIGNED_SHORT, + GL_1_2.GL_UNSIGNED_SHORT_1_5_5_5_REV : GL_1_1.GL_UNSIGNED_SHORT, + GL_1_2.GL_UNSIGNED_SHORT_5_6_5 : GL_1_1.GL_UNSIGNED_SHORT, + GL_1_2.GL_UNSIGNED_SHORT_5_6_5_REV : GL_1_1.GL_UNSIGNED_SHORT, + GL_1_2.GL_UNSIGNED_INT_8_8_8_8 : GL_1_1.GL_UNSIGNED_INT, + GL_1_2.GL_UNSIGNED_INT_8_8_8_8_REV : GL_1_1.GL_UNSIGNED_INT, + GL_1_2.GL_UNSIGNED_INT_10_10_10_2 : GL_1_1.GL_UNSIGNED_INT, + GL_1_2.GL_UNSIGNED_INT_2_10_10_10_REV : GL_1_1.GL_UNSIGNED_INT, + GL_1_1.GL_UNSIGNED_BYTE : GL_1_1.GL_UNSIGNED_BYTE, + GL_1_1.GL_BYTE: GL_1_1.GL_BYTE, + GL_1_1.GL_UNSIGNED_SHORT : GL_1_1.GL_UNSIGNED_SHORT, + GL_1_1.GL_SHORT : GL_1_1.GL_SHORT, + GL_1_1.GL_UNSIGNED_INT : GL_1_1.GL_UNSIGNED_INT, + GL_1_1.GL_INT : GL_1_1.GL_INT, + GL_1_1.GL_FLOAT : GL_1_1.GL_FLOAT, + GL_1_1.GL_DOUBLE : GL_1_1.GL_DOUBLE, + GL_1_1.GL_BITMAP : GL_1_1.GL_UNSIGNED_BYTE, +} ) +images.TIGHT_PACK_FORMATS.update({ + GL_1_2.GL_UNSIGNED_BYTE_3_3_2 : 3, + GL_1_2.GL_UNSIGNED_BYTE_2_3_3_REV : 3, + GL_1_2.GL_UNSIGNED_SHORT_4_4_4_4 : 4, + GL_1_2.GL_UNSIGNED_SHORT_4_4_4_4_REV : 4, + GL_1_2.GL_UNSIGNED_SHORT_5_5_5_1 : 4, + GL_1_2.GL_UNSIGNED_SHORT_1_5_5_5_REV : 4, + GL_1_2.GL_UNSIGNED_SHORT_5_6_5 : 3, + GL_1_2.GL_UNSIGNED_SHORT_5_6_5_REV : 3, + GL_1_2.GL_UNSIGNED_INT_8_8_8_8 : 4, + GL_1_2.GL_UNSIGNED_INT_8_8_8_8_REV : 4, + GL_1_2.GL_UNSIGNED_INT_10_10_10_2 : 4, + GL_1_2.GL_UNSIGNED_INT_2_10_10_10_REV : 4, + GL_1_1.GL_BITMAP: 8, # single bits, 8 of them... +}) + +images.RANK_PACKINGS.update( { + 4: [ + # Note the sgis parameters are skipped here unless you import + # the sgis texture4D extension... + (GL_1_1.glPixelStorei,GL_1_1.GL_PACK_ALIGNMENT, 1), + ], + 3: [ + (GL_1_1.glPixelStorei,GL_1_2.GL_PACK_SKIP_IMAGES, 0), + (GL_1_1.glPixelStorei,GL_1_2.GL_PACK_IMAGE_HEIGHT, 0), + (GL_1_1.glPixelStorei,GL_1_1.GL_PACK_ALIGNMENT, 1), + ], + 2: [ + (GL_1_1.glPixelStorei,GL_1_1.GL_PACK_ROW_LENGTH, 0), + (GL_1_1.glPixelStorei,GL_1_1.GL_PACK_SKIP_ROWS, 0), + (GL_1_1.glPixelStorei,GL_1_1.GL_PACK_ALIGNMENT, 1), + ], + 1: [ + (GL_1_1.glPixelStorei,GL_1_1.GL_PACK_SKIP_PIXELS, 0), + (GL_1_1.glPixelStorei,GL_1_1.GL_PACK_ALIGNMENT, 1), + ], +} ) + + +__all__ = ( + 'glReadPixels', + 'glReadPixelsb', + 'glReadPixelsd', + 'glReadPixelsf', + 'glReadPixelsi', + 'glReadPixelss', + 'glReadPixelsub', + 'glReadPixelsui', + 'glReadPixelsus', + + 'glGetTexImage', + + 'glDrawPixels', + 'glDrawPixelsb', + 'glDrawPixelsf', + 'glDrawPixelsi', + 'glDrawPixelss', + 'glDrawPixelsub', + 'glDrawPixelsui', + 'glDrawPixelsus', + + + 'glTexSubImage2D', + 'glTexSubImage1D', + #'glTexSubImage3D', + + 'glTexImage1D', + 'glTexImage2D', + #'glTexImage3D', + + 'glGetTexImageb', + 'glGetTexImaged', + 'glGetTexImagef', + 'glGetTexImagei', + 'glGetTexImages', + 'glGetTexImageub', + 'glGetTexImageui', + 'glGetTexImageus', + 'glTexImage1Db', + 'glTexImage2Db', + #'glTexImage3Db', + 'glTexSubImage1Db', + 'glTexSubImage2Db', + #'glTexSubImage3Db', + 'glTexImage1Df', + 'glTexImage2Df', + #'glTexImage3Df', + 'glTexSubImage1Df', + 'glTexSubImage2Df', + #'glTexSubImage3Df', + 'glTexImage1Di', + 'glTexImage2Di', + #'glTexImage3Di', + 'glTexSubImage1Di', + 'glTexSubImage2Di', + #'glTexSubImage3Di', + 'glTexImage1Ds', + 'glTexImage2Ds', + #'glTexImage3Ds', + 'glTexSubImage1Ds', + 'glTexSubImage2Ds', + #'glTexSubImage3Ds', + 'glTexImage1Dub', + 'glTexImage2Dub', + #'glTexImage3Dub', + 'glTexSubImage1Dub', + 'glTexSubImage2Dub', + #'glTexSubImage3Dub', + 'glTexImage1Dui', + 'glTexImage2Dui', + #'glTexImage3Dui', + 'glTexSubImage1Dui', + 'glTexSubImage2Dui', + #'glTexSubImage3Dui', + 'glTexImage1Dus', + 'glTexImage2Dus', + #'glTexImage3Dus', + 'glTexSubImage1Dus', + 'glTexSubImage2Dus', + #'glTexSubImage3Dus', + + #'glColorTable', + #'glGetColorTable', + #'glColorSubTable', + + #'glConvolutionFilter1D', + #'glConvolutionFilter2D', + #'glGetConvolutionFilter', + #'glSeparableFilter2D', + #'glGetSeparableFilter', + + #'glGetMinmax', +) + +def _get_texture_level_dims(target,level): + """Retrieve texture dims for given level and target""" + dims = [] + dim = _types.GLuint() + GL_1_1.glGetTexLevelParameteriv( target, level, GL_1_1.GL_TEXTURE_WIDTH, dim ) + dims = [dim.value] + if target != GL_1_1.GL_TEXTURE_1D: + GL_1_1.glGetTexLevelParameteriv( target, level, GL_1_1.GL_TEXTURE_HEIGHT, dim ) + dims.append( dim.value ) + if target != GL_1_1.GL_TEXTURE_2D: + GL_1_1.glGetTexLevelParameteriv( target, level, GL_1_2.GL_TEXTURE_DEPTH, dim ) + dims.append( dim.value ) + return dims + +for suffix,type in [ + ('b',GL_1_1.GL_BYTE), + ('d',GL_1_1.GL_DOUBLE), + ('f',GL_1_1.GL_FLOAT), + ('i',GL_1_1.GL_INT), + ('s',GL_1_1.GL_SHORT), + ('ub',GL_1_1.GL_UNSIGNED_BYTE), + ('ui',GL_1_1.GL_UNSIGNED_INT), + ('us',GL_1_1.GL_UNSIGNED_SHORT), +]: + def glReadPixels( x,y,width,height,format,type=type, array=None, outputType=bytes ): + """Read specified pixels from the current display buffer + + This typed version returns data in your specified default + array data-type format, or in the passed array, which will + be converted to the array-type required by the format. + """ + x,y,width,height = asInt(x),asInt(y),asInt(width),asInt(height) + arrayType = arrays.GL_CONSTANT_TO_ARRAY_TYPE[ images.TYPE_TO_ARRAYTYPE.get(type,type) ] + + if array is None: + array = imageData = images.SetupPixelRead( format, (width,height), type ) + owned = True + else: + if isinstance( array, integer_types): + imageData = ctypes.c_void_p( array ) + else: + array = arrayType.asArray( array ) + imageData = arrayType.voidDataPointer( array ) + owned = False + GL_1_1.glReadPixels( + x,y, + width, height, + format,type, + imageData + ) + if owned and outputType is bytes: + return images.returnFormat( array, type ) + else: + return array + globals()["glReadPixels%s"%(suffix,)] = glReadPixels + def glGetTexImage( target, level,format,type=type, array=None, outputType=bytes ): + """Get a texture-level as an image + + target -- enum constant for the texture engine to be read + level -- the mip-map level to read + format -- image format to read out the data + type -- data-type into which to read the data + array -- optional array/offset into which to store the value + + outputType -- default (bytes) provides string output of the + results iff OpenGL.UNSIGNED_BYTE_IMAGES_AS_STRING is True + and type == GL_UNSIGNED_BYTE. Any other value will cause + output in the default array output format. + + returns the pixel data array in the format defined by the + format, type and outputType + """ + arrayType = arrays.GL_CONSTANT_TO_ARRAY_TYPE[ images.TYPE_TO_ARRAYTYPE.get(type,type) ] + if array is None: + dims = _get_texture_level_dims(target,level) + array = imageData = images.SetupPixelRead( format, tuple(dims), type ) + owned = True + else: + if isinstance( array, integer_types): + imageData = ctypes.c_void_p( array ) + else: + array = arrayType.asArray( array ) + imageData = arrayType.voidDataPointer( array ) + owned = False + GL_1_1.glGetTexImage( + target, level, format, type, imageData + ) + if owned and outputType is bytes: + return images.returnFormat( array, type ) + else: + return array + globals()["glGetTexImage%s"%(suffix,)] = glGetTexImage +## def glGetTexSubImage( target, level,format,type ): +## """Get a texture-level as an image""" +## dims = [GL_1_1.glGetTexLevelParameteriv( target, level, GL_1_1.GL_TEXTURE_WIDTH )] +## if target != GL_1_1.GL_TEXTURE_1D: +## dims.append( GL_1_1.glGetTexLevelParameteriv( target, level, GL_1_1.GL_TEXTURE_HEIGHT ) ) +## if target != GL_1_1.GL_TEXTURE_2D: +## dims.append( GL_1_1.glGetTexLevelParameteriv( target, level, GL_1_2.GL_TEXTURE_DEPTH ) ) +## array = images.SetupPixelRead( format, tuple(dims), type ) +## arrayType = arrays.GL_CONSTANT_TO_ARRAY_TYPE[ images.TYPE_TO_ARRAYTYPE.get(type,type) ] +## GL_1_1.glGetTexImage( +## target, level, format, type, ctypes.c_void_p( arrayType.dataPointer(array)) +## ) +## return array +## "%s = glGetTexImage"%(suffix) + try: + del suffix,type + except NameError as err: + pass +# Now the real glReadPixels... +def glReadPixels( x,y,width,height,format,type, array=None, outputType=bytes ): + """Read specified pixels from the current display buffer + + x,y,width,height -- location and dimensions of the image to read + from the buffer + format -- pixel format for the resulting data + type -- data-format for the resulting data + array -- optional array/offset into which to store the value + outputType -- default (bytes) provides string output of the + results iff OpenGL.UNSIGNED_BYTE_IMAGES_AS_STRING is True + and type == GL_UNSIGNED_BYTE. Any other value will cause + output in the default array output format. + + returns the pixel data array in the format defined by the + format, type and outputType + """ + x,y,width,height = asInt(x),asInt(y),asInt(width),asInt(height) + + arrayType = arrays.GL_CONSTANT_TO_ARRAY_TYPE[ images.TYPE_TO_ARRAYTYPE.get(type,type) ] + if array is None: + array = imageData = images.SetupPixelRead( format, (width,height), type ) + owned = True + else: + if isinstance( array, integer_types): + imageData = ctypes.c_void_p( array ) + else: + array = arrayType.asArray( array ) + imageData = arrayType.voidDataPointer( array ) + owned = False + + GL_1_1.glReadPixels( + x,y,width,height, + format,type, + imageData + ) + if owned and outputType is bytes: + return images.returnFormat( array, type ) + else: + return array + +def glGetTexImage( target, level,format,type, array=None, outputType=bytes ): + """Get a texture-level as an image + + target -- enum constant for the texture engine to be read + level -- the mip-map level to read + format -- image format to read out the data + type -- data-type into which to read the data + array -- optional array/offset into which to store the value + + outputType -- default (bytes) provides string output of the + results iff OpenGL.UNSIGNED_BYTE_IMAGES_AS_STRING is True + and type == GL_UNSIGNED_BYTE. Any other value will cause + output in the default array output format. + + returns the pixel data array in the format defined by the + format, type and outputType + """ + arrayType = arrays.GL_CONSTANT_TO_ARRAY_TYPE[ images.TYPE_TO_ARRAYTYPE.get(type,type) ] + if array is None: + dims = _get_texture_level_dims(target,level) + array = imageData = images.SetupPixelRead( format, tuple(dims), type ) + else: + if isinstance( array, integer_types): + imageData = ctypes.c_void_p( array ) + else: + array = arrayType.asArray( array ) + imageData = arrayType.voidDataPointer( array ) + GL_1_1.glGetTexImage( + target, level, format, type, imageData + ) + if outputType is bytes: + return images.returnFormat( array, type ) + else: + return array + + +INT_DIMENSION_NAMES = [ + 'width','height','depth','x','y','z', + 'xoffset','yoffset','zoffset', + 'start', 'count', +] +def asWrapper( value ): + if not isinstance( value, wrapper.Wrapper ): + return wrapper.wrapper( value ) + return value + +def asIntConverter( value, *args ): + if isinstance( value, float ): + return int(round(value,0)) + return value + +def setDimensionsAsInts( baseOperation ): + """Set arguments with names in INT_DIMENSION_NAMES to asInt processing""" + baseOperation = asWrapper( baseOperation ) + argNames = getattr( baseOperation, 'pyConverterNames', baseOperation.argNames ) + for i,argName in enumerate(argNames): + if argName in INT_DIMENSION_NAMES: + baseOperation.setPyConverter( argName, asIntConverter ) + return baseOperation + + + +class ImageInputConverter( object ): + def __init__( self, rank, pixelsName=None, typeName='type' ): + self.rank = rank + self.typeName = typeName + self.pixelsName = pixelsName + def finalise( self, wrapper ): + """Get our pixel index from the wrapper""" + self.typeIndex = wrapper.pyArgIndex( self.typeName ) + self.pixelsIndex = wrapper.pyArgIndex( self.pixelsName ) + def __call__( self, arg, baseOperation, pyArgs ): + """pyConverter for the pixels argument""" + images.setupDefaultTransferMode() + images.rankPacking( self.rank ) + type = pyArgs[ self.typeIndex ] + arrayType = arrays.GL_CONSTANT_TO_ARRAY_TYPE[ images.TYPE_TO_ARRAYTYPE[ type ] ] + return arrayType.asArray( arg ) +# def cResolver( self, array ): +# return array +# return ctypes.c_void_p( arrays.ArrayDatatype.dataPointer( array ) ) + +class TypedImageInputConverter( ImageInputConverter ): + def __init__( self, rank, pixelsName, arrayType, typeName=None ): + self.rank = rank + self.arrayType = arrayType + self.pixelsName = pixelsName + self.typeName = typeName + def __call__( self, arg, baseOperation, pyArgs ): + """The pyConverter for the pixels""" + images.setupDefaultTransferMode() + images.rankPacking( self.rank ) + return self.arrayType.asArray( arg ) + def finalise( self, wrapper ): + """Get our pixel index from the wrapper""" + self.pixelsIndex = wrapper.pyArgIndex( self.pixelsName ) + def width( self, pyArgs, index, wrappedOperation ): + """Extract the width from the pixels argument""" + return self.arrayType.dimensions( pyArgs[self.pixelsIndex] )[0] + def height( self, pyArgs, index, wrappedOperation ): + """Extract the height from the pixels argument""" + return self.arrayType.dimensions( pyArgs[self.pixelsIndex] )[1] + def depth( self, pyArgs, index, wrappedOperation ): + """Extract the depth from the pixels argument""" + return self.arrayType.dimensions( pyArgs[self.pixelsIndex] )[2] + def type( self, pyArgs, index, wrappedOperation ): + """Provide the item-type argument from our stored value + + This is used for pre-bound processing where we want to provide + the type by implication... + """ + return self.typeName + +class CompressedImageConverter( object ): + def finalise( self, wrapper ): + """Get our pixel index from the wrapper""" + self.dataIndex = wrapper.pyArgIndex( 'data' ) + def __call__( self, pyArgs, index, wrappedOperation ): + """Create a data-size measurement for our image""" + arg = pyArgs[ self.dataIndex ] + return arraydatatype.ArrayDatatype.arrayByteCount(arg) + + + +DIMENSION_NAMES = ( + 'width','height','depth' +) +PIXEL_NAMES = ( + 'pixels', 'row', 'column', +) +DATA_SIZE_NAMES = ( + 'imageSize', +) + +def setImageInput( + baseOperation, arrayType=None, dimNames=DIMENSION_NAMES, + pixelName="pixels", typeName=None +): + """Determine how to convert "pixels" into an image-compatible argument""" + baseOperation = asWrapper( baseOperation ) + # rank is the count of width,height,depth arguments... + rank = len([ + # rank is the number of dims we want, not the number we give... + argName for argName in baseOperation.argNames + if argName in dimNames + ]) + 1 + if arrayType: + converter = TypedImageInputConverter( rank, pixelName, arrayType, typeName=typeName ) + for i,argName in enumerate(baseOperation.argNames): + if argName in dimNames: + baseOperation.setPyConverter( argName ) + baseOperation.setCConverter( argName, getattr(converter,argName) ) + elif argName == 'type' and typeName is not None: + baseOperation.setPyConverter( argName ) + baseOperation.setCConverter( argName, converter.type ) + else: + converter = ImageInputConverter( rank, pixelsName=pixelName, typeName=typeName or 'type' ) + for argName in baseOperation.argNames: + if argName in DATA_SIZE_NAMES: + baseOperation.setPyConverter( argName ) + baseOperation.setCConverter( argName, converter.imageDataSize ) + baseOperation.setPyConverter( + pixelName, converter, + ) +# baseOperation.setCResolver( +# pixelName, converter.cResolver +# ) + return baseOperation + +glDrawPixels = setDimensionsAsInts( + setImageInput( + GL_1_1.glDrawPixels + ) +) +glTexSubImage2D = setDimensionsAsInts( + setImageInput( + GL_1_1.glTexSubImage2D + ) +) +glTexSubImage1D = setDimensionsAsInts( + setImageInput( + GL_1_1.glTexSubImage1D + ) +) +glTexImage2D = setDimensionsAsInts( + setImageInput( + GL_1_1.glTexImage2D + ) +) +glTexImage1D = setDimensionsAsInts( + setImageInput( + GL_1_1.glTexImage1D + ) +) + +def typedImageFunction( suffix, arrayConstant, baseFunction ): + """Produce a typed version of the given image function""" + functionName = baseFunction.__name__ + functionName = '%(functionName)s%(suffix)s'%locals() + arrayType = arrays.GL_CONSTANT_TO_ARRAY_TYPE[ arrayConstant ] + function = setDimensionsAsInts( + setImageInput( + baseFunction, + arrayType, + typeName = arrayConstant, + ) + ) + return functionName, function + +def _setDataSize( baseFunction, argument='imageSize' ): + """Set the data-size value to come from the data field""" + converter = CompressedImageConverter() + return asWrapper( baseFunction ).setPyConverter( + argument + ).setCConverter( argument, converter ) + +def compressedImageFunction( baseFunction ): + """Set the imageSize and dimensions-as-ints converters for baseFunction""" + return setDimensionsAsInts( + _setDataSize( + baseFunction, argument='imageSize' + ) + ) + +for suffix,arrayConstant in [ + ('b', GL_1_1.GL_BYTE), + ('f', GL_1_1.GL_FLOAT), + ('i', GL_1_1.GL_INT), + ('s', GL_1_1.GL_SHORT), + ('ub', GL_1_1.GL_UNSIGNED_BYTE), + ('ui', GL_1_1.GL_UNSIGNED_INT), + ('us', GL_1_1.GL_UNSIGNED_SHORT), +]: + for functionName in ( + 'glTexImage1D','glTexImage2D', + 'glTexSubImage1D','glTexSubImage2D', + 'glDrawPixels', + #'glTexSubImage3D','glTexImage3D', # extension/1.2 standard + ): + functionName, function = typedImageFunction( + suffix, arrayConstant, getattr(GL_1_1,functionName), + ) + globals()[functionName] = function + try: + del function, functionName + except NameError as err: + pass + try: + del suffix,arrayConstant + except NameError as err: + pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/pointers.py b/venv/lib/python3.12/site-packages/OpenGL/GL/pointers.py new file mode 100644 index 00000000..1906a081 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/pointers.py @@ -0,0 +1,308 @@ +"""Implementations for "held-pointers" of various types + +This argument type is special because it is stored, that is, it +needs to be cached on our side so that the memory address does not +go out-of-scope + +storedPointers = {} +def glVertexPointerd( array ): + "Natural writing of glVertexPointerd using standard ctypes" + arg2 = GL_DOUBLE + arg3 = 0 # stride + arg4 = arrays.asArray(array, GL_DOUBLE) + arg1 = arrays.arraySize( arg4, 'd' ) + platform.PLATFORM.GL.glVertexPointer( arg1, arg2, arg3, arrays.ArrayDatatype.dataPointer(arg4) ) + # only store if we successfully set the value... + storedPointers[ GL_VERTEX_ARRAY ] = arg4 + return arg4 +""" +from OpenGL import platform, error, wrapper, contextdata, converters, constant +from OpenGL.arrays import arrayhelpers, arraydatatype +from OpenGL.raw.GL.VERSION import GL_1_1 as _simple +import ctypes + +GLsizei = ctypes.c_int +GLenum = ctypes.c_uint +GLint = ctypes.c_int +# OpenGL-ctypes variables that mimic OpenGL constant operation... +GL_INTERLEAVED_ARRAY_POINTER = constant.Constant( 'GL_INTERLEAVED_ARRAY_POINTER', -32910 ) + +__all__ = ( + 'glColorPointer', + 'glColorPointerb','glColorPointerd','glColorPointerf','glColorPointeri', + 'glColorPointers','glColorPointerub','glColorPointerui','glColorPointerus', + 'glEdgeFlagPointer', + 'glEdgeFlagPointerb', + 'glIndexPointer', + 'glIndexPointerb','glIndexPointerd','glIndexPointerf', + 'glIndexPointeri','glIndexPointers','glIndexPointerub', + 'glNormalPointer', + 'glNormalPointerb', + 'glNormalPointerd','glNormalPointerf','glNormalPointeri','glNormalPointers', + 'glTexCoordPointer', + 'glTexCoordPointerb','glTexCoordPointerd','glTexCoordPointerf', + 'glTexCoordPointeri','glTexCoordPointers', + 'glVertexPointer', + 'glVertexPointerb','glVertexPointerd','glVertexPointerf','glVertexPointeri', + 'glVertexPointers', + 'glDrawElements','glDrawElementsui','glDrawElementsub','glDrawElementsus', + 'glFeedbackBuffer', + 'glSelectBuffer', + 'glRenderMode', + 'glGetPointerv', + 'glInterleavedArrays', + 'GL_INTERLEAVED_ARRAY_POINTER', +) + + +# Have to create *new* ctypes wrappers for the platform object! +# We can't just alter the default one since we have different ways of +# calling it + +POINTER_FUNCTION_DATA = [ + ('glColorPointerd', _simple.glColorPointer, _simple.GL_DOUBLE, _simple.GL_COLOR_ARRAY_POINTER, 0, 3), + ('glColorPointerf', _simple.glColorPointer, _simple.GL_FLOAT, _simple.GL_COLOR_ARRAY_POINTER, 0, 3), + ('glColorPointeri', _simple.glColorPointer, _simple.GL_INT, _simple.GL_COLOR_ARRAY_POINTER, 0, 3), + ('glColorPointers', _simple.glColorPointer, _simple.GL_SHORT, _simple.GL_COLOR_ARRAY_POINTER, 0, 3), + ('glColorPointerub', _simple.glColorPointer, _simple.GL_UNSIGNED_BYTE, _simple.GL_COLOR_ARRAY_POINTER, 0, 3), + # these data-types are mapped from diff Numeric types + ('glColorPointerb', _simple.glColorPointer, _simple.GL_BYTE, _simple.GL_COLOR_ARRAY_POINTER, 0, 3), + ('glColorPointerui', _simple.glColorPointer, _simple.GL_UNSIGNED_INT, _simple.GL_COLOR_ARRAY_POINTER, 0, 3), + ('glColorPointerus', _simple.glColorPointer, _simple.GL_UNSIGNED_SHORT, _simple.GL_COLOR_ARRAY_POINTER, 0, 3), + + ('glEdgeFlagPointerb', _simple.glEdgeFlagPointer, _simple.GL_BYTE, _simple.GL_EDGE_FLAG_ARRAY_POINTER, 2, None), + + ('glIndexPointerd', _simple.glIndexPointer, _simple.GL_DOUBLE, _simple.GL_INDEX_ARRAY_POINTER, 1, None), + ('glIndexPointerf', _simple.glIndexPointer, _simple.GL_FLOAT, _simple.GL_INDEX_ARRAY_POINTER, 1, None), + ('glIndexPointeri', _simple.glIndexPointer, _simple.GL_INT, _simple.GL_INDEX_ARRAY_POINTER, 1, None), + ('glIndexPointerub', _simple.glIndexPointer, _simple.GL_UNSIGNED_BYTE, _simple.GL_INDEX_ARRAY_POINTER, 1, None), + ('glIndexPointers', _simple.glIndexPointer, _simple.GL_SHORT, _simple.GL_INDEX_ARRAY_POINTER, 1, None), + # these data-types are mapped from diff Numeric types + ('glIndexPointerb', _simple.glIndexPointer, _simple.GL_BYTE, _simple.GL_INDEX_ARRAY_POINTER, 1, None), + + ('glNormalPointerd', _simple.glNormalPointer, _simple.GL_DOUBLE, _simple.GL_NORMAL_ARRAY_POINTER, 1, None), + ('glNormalPointerf', _simple.glNormalPointer, _simple.GL_FLOAT, _simple.GL_NORMAL_ARRAY_POINTER, 1, None), + ('glNormalPointeri', _simple.glNormalPointer, _simple.GL_INT, _simple.GL_NORMAL_ARRAY_POINTER, 1, None), + ('glNormalPointerb', _simple.glNormalPointer, _simple.GL_BYTE, _simple.GL_NORMAL_ARRAY_POINTER, 1, None), + ('glNormalPointers', _simple.glNormalPointer, _simple.GL_SHORT, _simple.GL_NORMAL_ARRAY_POINTER, 1, None), + + ('glTexCoordPointerd', _simple.glTexCoordPointer, _simple.GL_DOUBLE, _simple.GL_TEXTURE_COORD_ARRAY_POINTER, 0, 2), + ('glTexCoordPointerf', _simple.glTexCoordPointer, _simple.GL_FLOAT, _simple.GL_TEXTURE_COORD_ARRAY_POINTER, 0, 2), + ('glTexCoordPointeri', _simple.glTexCoordPointer, _simple.GL_INT, _simple.GL_TEXTURE_COORD_ARRAY_POINTER, 0, 2), + ('glTexCoordPointerb', _simple.glTexCoordPointer, _simple.GL_BYTE, _simple.GL_TEXTURE_COORD_ARRAY_POINTER, 0, 2), + ('glTexCoordPointers', _simple.glTexCoordPointer, _simple.GL_SHORT, _simple.GL_TEXTURE_COORD_ARRAY_POINTER, 0, 2), + + ('glVertexPointerd', _simple.glVertexPointer, _simple.GL_DOUBLE, _simple.GL_VERTEX_ARRAY_POINTER, 0, 3), + ('glVertexPointerf', _simple.glVertexPointer, _simple.GL_FLOAT, _simple.GL_VERTEX_ARRAY_POINTER, 0, 3), + ('glVertexPointeri', _simple.glVertexPointer, _simple.GL_INT, _simple.GL_VERTEX_ARRAY_POINTER, 0, 3), + ('glVertexPointerb', _simple.glVertexPointer, _simple.GL_INT, _simple.GL_VERTEX_ARRAY_POINTER, 0, 3), + ('glVertexPointers', _simple.glVertexPointer, _simple.GL_SHORT, _simple.GL_VERTEX_ARRAY_POINTER, 0, 3), +] +def wrapPointerFunction( name, baseFunction, glType, arrayType,startArgs, defaultSize ): + """Wrap the given pointer-setting function""" + function= wrapper.wrapper( baseFunction ) + if 'ptr' in baseFunction.argNames: + pointer_name = 'ptr' + else: + pointer_name = 'pointer' + assert not getattr( function, 'pyConverters', None ), """Reusing wrappers?""" + if arrayType: + arrayModuleType = arraydatatype.GL_CONSTANT_TO_ARRAY_TYPE[ glType ] + function.setPyConverter( pointer_name, arrayhelpers.asArrayType(arrayModuleType) ) + else: + function.setPyConverter( pointer_name, arrayhelpers.AsArrayOfType(pointer_name,'type') ) + function.setCConverter( pointer_name, converters.getPyArgsName( pointer_name ) ) + if 'size' in function.argNames: + function.setPyConverter( 'size' ) + function.setCConverter( 'size', arrayhelpers.arraySizeOfFirstType(arrayModuleType,defaultSize) ) + if 'type' in function.argNames: + function.setPyConverter( 'type' ) + function.setCConverter( 'type', glType ) + if 'stride' in function.argNames: + function.setPyConverter( 'stride' ) + function.setCConverter( 'stride', 0 ) + function.setStoreValues( arrayhelpers.storePointerType( pointer_name, arrayType ) ) + function.setReturnValues( wrapper.returnPyArgument( pointer_name ) ) + return name,function + + + +for name,function in [ + wrapPointerFunction( *args ) + for args in POINTER_FUNCTION_DATA +]: + globals()[name] = function +try: + del name, function +except NameError as err: + pass + +glVertexPointer = wrapper.wrapper( _simple.glVertexPointer ).setPyConverter( + 'pointer', arrayhelpers.AsArrayOfType( 'pointer', 'type' ), +).setStoreValues( + arrayhelpers.storePointerType( 'pointer', _simple.GL_VERTEX_ARRAY_POINTER ) +).setReturnValues( + wrapper.returnPyArgument( 'pointer' ) +) +glTexCoordPointer = wrapper.wrapper( _simple.glTexCoordPointer ).setPyConverter( + 'pointer', arrayhelpers.AsArrayOfType( 'pointer', 'type' ), +).setStoreValues( + arrayhelpers.storePointerType( 'pointer', _simple.GL_TEXTURE_COORD_ARRAY_POINTER ) +).setReturnValues( + wrapper.returnPyArgument( 'pointer' ) +) +glNormalPointer = wrapper.wrapper( _simple.glNormalPointer ).setPyConverter( + 'pointer', arrayhelpers.AsArrayOfType( 'pointer', 'type' ), +).setStoreValues( + arrayhelpers.storePointerType( 'pointer', _simple.GL_NORMAL_ARRAY_POINTER ) +).setReturnValues( + wrapper.returnPyArgument( 'pointer' ) +) +glIndexPointer = wrapper.wrapper( _simple.glIndexPointer ).setPyConverter( + 'pointer', arrayhelpers.AsArrayOfType( 'pointer', 'type' ), +).setStoreValues( + arrayhelpers.storePointerType( 'pointer', _simple.GL_INDEX_ARRAY_POINTER ) +).setReturnValues( + wrapper.returnPyArgument( 'pointer' ) +) +glEdgeFlagPointer = wrapper.wrapper( _simple.glEdgeFlagPointer ).setPyConverter( + # XXX type is wrong! + 'pointer', arrayhelpers.AsArrayTyped( 'pointer', arraydatatype.GLushortArray ), +).setStoreValues( + arrayhelpers.storePointerType( 'pointer', _simple.GL_EDGE_FLAG_ARRAY_POINTER ) +).setReturnValues( + wrapper.returnPyArgument( 'pointer' ) +) +glColorPointer = wrapper.wrapper( _simple.glColorPointer ).setPyConverter( + 'pointer', arrayhelpers.AsArrayOfType( 'pointer', 'type' ), +).setStoreValues( + arrayhelpers.storePointerType( 'pointer', _simple.GL_COLOR_ARRAY_POINTER ) +).setReturnValues( + wrapper.returnPyArgument( 'pointer' ) +) +glInterleavedArrays = wrapper.wrapper( _simple.glInterleavedArrays ).setStoreValues( + arrayhelpers.storePointerType( 'pointer', GL_INTERLEAVED_ARRAY_POINTER ) +).setReturnValues( + wrapper.returnPyArgument( 'pointer' ) +) + + +glDrawElements = wrapper.wrapper( _simple.glDrawElements ).setPyConverter( + 'indices', arrayhelpers.AsArrayOfType( 'indices', 'type' ), +).setReturnValues( + wrapper.returnPyArgument( 'indices' ) +) + +def glDrawElementsTyped( type, suffix ): + arrayType = arraydatatype.GL_CONSTANT_TO_ARRAY_TYPE[ type ] + function = wrapper.wrapper( + _simple.glDrawElements + ).setPyConverter('type').setCConverter( + 'type', type + ).setPyConverter('count').setCConverter( + 'count', arrayhelpers.AsArrayTypedSize( 'indices', arrayType ), + ).setPyConverter( + 'indices', arrayhelpers.AsArrayTyped( 'indices', arrayType ), + ).setReturnValues( + wrapper.returnPyArgument( 'indices' ) + ) + return function +for type,suffix in ((_simple.GL_UNSIGNED_BYTE,'ub'),(_simple.GL_UNSIGNED_INT,'ui'),(_simple.GL_UNSIGNED_SHORT,'us')): + globals()['glDrawElements%(suffix)s'%globals()] = glDrawElementsTyped( type,suffix ) +try: + del type,suffix,glDrawElementsTyped +except NameError as err: + pass + +# create buffer of given size and return it for future reference +# keep a per-context weakref around to allow us to return the original +# array we returned IFF the user has kept a reference as well... +def glSelectBuffer( size, buffer = None ): + """Create a selection buffer of the given size + """ + if buffer is None: + buffer = arraydatatype.GLuintArray.zeros( (size,) ) + _simple.glSelectBuffer( size, buffer ) + contextdata.setValue( _simple.GL_SELECTION_BUFFER_POINTER, buffer ) + return buffer +def glFeedbackBuffer( size, type, buffer = None ): + """Create a selection buffer of the given size + """ + if buffer is None: + buffer = arraydatatype.GLfloatArray.zeros( (size,) ) + _simple.glFeedbackBuffer( size, type, buffer ) + contextdata.setValue( _simple.GL_FEEDBACK_BUFFER_POINTER, buffer ) + contextdata.setValue( "GL_FEEDBACK_BUFFER_TYPE", type ) + return buffer + +def glRenderMode( newMode ): + """Change to the given rendering mode + + If the current mode is GL_FEEDBACK or GL_SELECT, return + the current buffer appropriate to the mode + """ + # must get the current mode to determine operation... + from OpenGL.GL import glGetIntegerv + from OpenGL.GL import selection, feedback + currentMode = glGetIntegerv( _simple.GL_RENDER_MODE ) + try: + currentMode = currentMode[0] + except (TypeError,ValueError,IndexError) as err: + pass + if currentMode in (_simple.GL_RENDER,0): + # no array needs to be returned... + return _simple.glRenderMode( newMode ) + result = _simple.glRenderMode( newMode ) + # result is now an integer telling us how many elements were copied... + + if result < 0: + if currentMode == _simple.GL_SELECT: + raise error.GLError( + _simple.GL_STACK_OVERFLOW, + "glSelectBuffer too small to hold selection results", + ) + elif currentMode == _simple.GL_FEEDBACK: + raise error.GLError( + _simple.GL_STACK_OVERFLOW, + "glFeedbackBuffer too small to hold selection results", + ) + else: + raise error.GLError( + _simple.GL_STACK_OVERFLOW, + "Unknown glRenderMode buffer (%s) too small to hold selection results"%( + currentMode, + ), + ) + # Okay, now that the easy cases are out of the way... + # Do we have a pre-stored pointer about which the user already knows? + context = platform.GetCurrentContext() + if context == 0: + raise error.Error( + """Returning from glRenderMode without a valid context!""" + ) + arrayConstant, wrapperFunction = { + _simple.GL_FEEDBACK: (_simple.GL_FEEDBACK_BUFFER_POINTER,feedback.parseFeedback), + _simple.GL_SELECT: (_simple.GL_SELECTION_BUFFER_POINTER, selection.GLSelectRecord.fromArray), + }[ currentMode ] + current = contextdata.getValue( arrayConstant ) + # XXX check to see if it's the *same* array we set currently! + if current is None: + current = glGetPointerv( arrayConstant ) + # XXX now, can turn the array into the appropriate wrapper type... + if wrapperFunction: + current = wrapperFunction( current, result ) + return current + +# XXX this belongs in the GL module, not here! +def glGetPointerv( constant ): + """Retrieve a stored pointer constant""" + # do we have a cached version of the pointer? + # get the base pointer from the underlying operation + vp = ctypes.voidp() + _simple.glGetPointerv( constant, ctypes.byref(vp) ) + current = contextdata.getValue( constant ) + if current is not None: + if arraydatatype.ArrayDatatype.dataPointer( current ) == vp.value: + return current + # XXX should be coercing to the proper type and converting to an array + return vp diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/selection.py b/venv/lib/python3.12/site-packages/OpenGL/GL/selection.py new file mode 100644 index 00000000..5f26bff9 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/selection.py @@ -0,0 +1,64 @@ +"""Selection-buffer handling code + +This code is resonsible for turning gluint * +arrays into structured representations for use +by Python-level code. +""" +from OpenGL._bytes import integer_types + +def uintToLong( value ): + if value < 0: + # array type without a uint, so represented as an int + value = (value & 0x7fffffff) + 0x80000000 + return value + +class GLSelectRecord( object ): + """Minimalist object for storing an OpenGL selection-buffer record + + Provides near and far as *float* values by dividing by + self.DISTANCE_DIVISOR (2**32-1) + From the spec: + Depth values (which are in the range [0,1]) are multiplied by + 2^32 - 1, before being placed in the hit record. + + Names are unmodified, so normally are slices of the array passed in + to GLSelectRecord.fromArray( array ) + """ + DISTANCE_DIVISOR = float((2**32)-1) + __slots__ = ('near','far','names') + def fromArray( cls, array, total ): + """Produce list with all records from the array""" + result = [] + index = 0 + arrayLength = len(array) + for item in range( total ): + if index + 2 >= arrayLength: + break + count = array[index] + near = array[index+1] + far = array[index+2] + names = [ uintToLong(v) for v in array[index+3:index+3+count]] + result.append( cls( near, far, names ) ) + index += 3+count + return result + fromArray = classmethod( fromArray ) + + def __init__( self, near, far, names ): + """Initialise/store the values""" + self.near = self.convertDistance( near ) + self.far = self.convertDistance( far ) + self.names = names + def convertDistance( self, value ): + """Convert a distance value from array uint to 0.0-1.0 range float""" + return uintToLong( value ) / self.DISTANCE_DIVISOR + def __getitem__( self, key ): + """Allow for treating the record as a three-tuple""" + if isinstance( key, integer_types): + return (self.near,self.far,self.names)[key] + elif key in self.__slots__: + try: + return getattr( self, key ) + except AttributeError as err: + raise KeyError( """Don't have an index/key %r for %s instant"""%( + key, self.__class__, + )) diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/shaders.py b/venv/lib/python3.12/site-packages/OpenGL/GL/shaders.py new file mode 100644 index 00000000..a6a45720 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/shaders.py @@ -0,0 +1,250 @@ +"""Convenience module providing common shader entry points + +The point of this module is to allow client code to use +OpenGL Core names to reference shader-related operations +even if the local hardware only supports ARB extension-based +shader rendering. + +There are also two utility methods compileProgram and compileShader +which make it easy to create demos which are shader-using. +""" +import logging +log = logging.getLogger( __name__ ) +from OpenGL import GL +from OpenGL.GL.ARB import ( + shader_objects, fragment_shader, vertex_shader, vertex_program, + geometry_shader4, separate_shader_objects, get_program_binary, +) +from OpenGL.extensions import alternate +from OpenGL._bytes import bytes,unicode,as_8_bit + +__all__ = [ + 'glAttachShader', + 'glDeleteShader', + 'glGetProgramInfoLog', + 'glGetShaderInfoLog', + 'glGetProgramiv', + 'glGetShaderiv', + 'compileProgram', + 'compileShader', + 'GL_VALIDATE_STATUS', + 'GL_LINK_STATUS', + 'ShaderCompilationError', + 'ShaderValidationError', + 'ShaderLinkError', + # automatically added stuff here... +] + +def _alt( base, name ): + if hasattr( GL, base ): + root = getattr( GL, base ) + if hasattr(root,'__call__'): + globals()[base] = alternate( + getattr(GL,base), + getattr(module,name) + ) + __all__.append( base ) + else: + globals()[base] = root + __all__.append( base ) + return True + return False +_excludes = ['glGetProgramiv'] +for module in ( + shader_objects,fragment_shader,vertex_shader,vertex_program, + geometry_shader4, +): + for name in dir(module): + found = None + for suffix in ('ObjectARB','_ARB','ARB'): + if name.endswith( suffix ): + found = False + base = name[:-(len(suffix))] + if base not in _excludes: + if _alt( base, name ): + found = True + break + if found is False: + log.debug( '''Found no alternate for: %s.%s''', + module.__name__,name, + ) + +glAttachShader = alternate( GL.glAttachShader,shader_objects.glAttachObjectARB ) +glDetachShader = alternate( GL.glDetachShader,shader_objects.glDetachObjectARB ) +glDeleteShader = alternate( GL.glDeleteShader,shader_objects.glDeleteObjectARB ) +glGetAttachedShaders = alternate( GL.glGetAttachedShaders, shader_objects.glGetAttachedObjectsARB ) + +glGetProgramInfoLog = alternate( GL.glGetProgramInfoLog, shader_objects.glGetInfoLogARB ) +glGetShaderInfoLog = alternate( GL.glGetShaderInfoLog, shader_objects.glGetInfoLogARB ) + +glGetShaderiv = alternate( GL.glGetShaderiv, shader_objects.glGetObjectParameterivARB ) +glGetProgramiv = alternate( GL.glGetProgramiv, shader_objects.glGetObjectParameterivARB ) + +GL_VALIDATE_STATUS = GL.GL_VALIDATE_STATUS +GL_COMPILE_STATUS = GL.GL_COMPILE_STATUS +GL_LINK_STATUS = GL.GL_LINK_STATUS +GL_FALSE = GL.GL_FALSE +GL_TRUE = GL.GL_TRUE + +class ShaderProgram( int ): + """Integer sub-class with context-manager operation""" + validated = False + def __enter__( self ): + """Start use of the program""" + glUseProgram( self ) + def __exit__( self, typ, val, tb ): + """Stop use of the program""" + glUseProgram( 0 ) + + def check_validate( self ): + """Check that the program validates + + Validation has to occur *after* linking/loading + + raises ShaderValidationError on failures + """ + glValidateProgram( self ) + validation = glGetProgramiv( self, GL_VALIDATE_STATUS ) + if validation == GL_FALSE: + raise ShaderValidationError( + """Validation failure (%r): %s"""%( + validation, + glGetProgramInfoLog( self ), + )) + self.validated = True + return self + + def check_linked( self ): + """Check link status for this program + + raises ShaderLinkError on failures + """ + link_status = glGetProgramiv( self, GL_LINK_STATUS ) + if link_status == GL_FALSE: + raise ShaderLinkError( + """Link failure (%s): %s"""%( + link_status, + glGetProgramInfoLog( self ), + )) + return self + + def retrieve( self ): + """Attempt to retrieve binary for this compiled shader + + Note that binaries for a program are *not* generally portable, + they should be used solely for caching compiled programs for + local use; i.e. to reduce compilation overhead. + + returns (format,binaryData) for the shader program + """ + from OpenGL.raw.GL._types import GLint,GLenum + from OpenGL.arrays import GLbyteArray + size = GLint() + glGetProgramiv( self, get_program_binary.GL_PROGRAM_BINARY_LENGTH, size ) + result = GLbyteArray.zeros( (size.value,)) + size2 = GLint() + format = GLenum() + get_program_binary.glGetProgramBinary( self, size.value, size2, format, result ) + return format.value, result + def load( self, format, binary, validate=True ): + """Attempt to load binary-format for a pre-compiled shader + + See notes in retrieve + """ + get_program_binary.glProgramBinary( self, format, binary, len(binary)) + if validate: + self.check_validate() + self.check_linked() + return self + +def compileProgram(*shaders, **named): + """Create a new program, attach shaders and validate + + shaders -- arbitrary number of shaders to attach to the + generated program. + separable (keyword only) -- set the separable flag to allow + for partial installation of shader into the pipeline (see + glUseProgramStages) + retrievable (keyword only) -- set the retrievable flag to + allow retrieval of the program binary representation, (see + glProgramBinary, glGetProgramBinary) + validate (keyword only) -- if False, suppress automatic + validation against current GL state. In advanced usage + the validation can produce spurious errors. Note: this + function is *not* really intended for advanced usage, + if you're finding yourself specifying this flag you + likely should be using your own shader management code. + + This convenience function is *not* standard OpenGL, + but it does wind up being fairly useful for demos + and the like. You may wish to copy it to your code + base to guard against PyOpenGL changes. + + Usage: + + shader = compileProgram( + compileShader( source, GL_VERTEX_SHADER ), + compileShader( source2, GL_FRAGMENT_SHADER ), + ) + glUseProgram( shader ) + + Note: + If (and only if) validation of the linked program + *passes* then the passed-in shader objects will be + deleted from the GL. + + returns ShaderProgram() (GLuint) program reference + raises RuntimeError subclasses { + ShaderCompilationError, ShaderValidationError, ShaderLinkError, + } when a link/validation failure occurs + """ + program = glCreateProgram() + if named.get('separable'): + glProgramParameteri( program, separate_shader_objects.GL_PROGRAM_SEPARABLE, GL_TRUE ) + if named.get('retrievable'): + glProgramParameteri( program, get_program_binary.GL_PROGRAM_BINARY_RETRIEVABLE_HINT, GL_TRUE ) + for shader in shaders: + glAttachShader(program, shader) + program = ShaderProgram( program ) + glLinkProgram(program) + if named.get('validate', True): + program.check_validate() + program.check_linked() + for shader in shaders: + glDeleteShader(shader) + return program +def compileShader( source, shaderType ): + """Compile shader source of given type + + source -- GLSL source-code for the shader + shaderType -- GLenum GL_VERTEX_SHADER, GL_FRAGMENT_SHADER, etc, + + returns GLuint compiled shader reference + raises RuntimeError when a compilation failure occurs + """ + if isinstance( source, (bytes,unicode)): + source = [ source ] + source = [ as_8_bit(s) for s in source ] + shader = glCreateShader(shaderType) + glShaderSource( shader, source ) + glCompileShader( shader ) + result = glGetShaderiv( shader, GL_COMPILE_STATUS ) + if not(result): + # TODO: this will be wrong if the user has + # disabled traditional unpacking array support. + raise ShaderCompilationError( + """Shader compile failure (%s): %s"""%( + result, + glGetShaderInfoLog( shader ), + ), + source, + shaderType, + ) + return shader + +class ShaderCompilationError(RuntimeError): + """Raised when a shader compilation fails""" +class ShaderValidationError(RuntimeError): + """Raised when a program fails to validate""" +class ShaderLinkError(RuntimeError): + """Raised when a shader link fails""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GL/vboimplementation.py b/venv/lib/python3.12/site-packages/OpenGL/GL/vboimplementation.py new file mode 100644 index 00000000..4be972c4 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GL/vboimplementation.py @@ -0,0 +1,21 @@ +from OpenGL.arrays import vbo +from OpenGL.GL.VERSION import GL_1_5, GL_3_0, GL_3_1 + +class Implementation( vbo.Implementation ): + """OpenGL-based implementation of VBO interfaces""" + def __init__( self ): + for name in self.EXPORTED_NAMES: + found = False + for source in (GL_1_5,GL_3_0, GL_3_1): + try: + setattr( self, name, getattr( source, name )) + except AttributeError as err: + pass + else: + found = True + break + assert found, name + if GL_1_5.glBufferData: + self.available = True + +Implementation.register() diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLE/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/GLE/__init__.py new file mode 100644 index 00000000..fcad99d5 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLE/__init__.py @@ -0,0 +1,5 @@ +"""GL Extrusion Routine Library (GLE) wrapper for OpenGL-ctypes""" +from OpenGL.raw.GLE import * +from OpenGL.raw.GLE.annotations import * + +from OpenGL.GLE.exceptional import * \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLE/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLE/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..2baa94fa Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLE/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLE/__pycache__/exceptional.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLE/__pycache__/exceptional.cpython-312.pyc new file mode 100644 index 00000000..ee600e52 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLE/__pycache__/exceptional.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLE/exceptional.py b/venv/lib/python3.12/site-packages/OpenGL/GLE/exceptional.py new file mode 100644 index 00000000..0f68cdfc --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLE/exceptional.py @@ -0,0 +1,43 @@ +"""GLE exceptional functions (specialised signatures""" +from OpenGL.raw import GLE as raw +from OpenGL.raw.GLE import annotations as _simple + +from OpenGL import wrapper, arrays + +class _lengthOfArgname( object ): + """Calculates the length of a given argname over a divisor value""" + def __init__( self, arrayName, divisor, arrayType = arrays.GLdoubleArray ): + self.arrayName = arrayName + self.divisor = divisor + self.arrayType = arrayType + def finalise( self, wrapper ): + self.arrayIndex = wrapper.pyArgIndex( self.arrayName ) + def __call__( self, pyArgs, index, wrappedOperation ): + """Get the length of pyArgs[2], a glDoubleArray""" + return self.arrayType.arraySize( pyArgs[self.arrayIndex] )//self.divisor +def _baseWrap( base, lengthName='ncp', contourName='contour', divisor=2 ): + """Do the basic wrapping operation for a GLE function""" + return wrapper.wrapper( base ).setPyConverter( + lengthName, + ).setCConverter( + lengthName, _lengthOfArgname( contourName, divisor, arrays.GLdoubleArray ), + ) + +gleLathe = _baseWrap( _simple.gleLathe ) +glePolyCone = _baseWrap( _simple.glePolyCone, 'npoints', 'point_array', 3) +glePolyCylinder = _baseWrap( _simple.glePolyCylinder, 'npoints', 'point_array', 3) +gleScrew = _baseWrap( _simple.gleScrew ) +gleSpiral = _baseWrap( _simple.gleSpiral ) + +gleExtrusion = _baseWrap( + _baseWrap( _simple.gleExtrusion ), + 'npoints', 'point_array', 3 +) +gleSuperExtrusion = _baseWrap( + _baseWrap( _simple.gleSuperExtrusion ), + 'npoints', 'point_array', 3 +) +gleTwistExtrusion = _baseWrap( + _baseWrap( _simple.gleTwistExtrusion ), + 'npoints', 'point_array', 3 +) \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/AMD/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/GLES1/AMD/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES1/AMD/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/AMD/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES1/AMD/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..bf24ded8 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES1/AMD/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/AMD/__pycache__/compressed_3DC_texture.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES1/AMD/__pycache__/compressed_3DC_texture.cpython-312.pyc new file mode 100644 index 00000000..b87a9e84 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES1/AMD/__pycache__/compressed_3DC_texture.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/AMD/__pycache__/compressed_ATC_texture.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES1/AMD/__pycache__/compressed_ATC_texture.cpython-312.pyc new file mode 100644 index 00000000..65de417c Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES1/AMD/__pycache__/compressed_ATC_texture.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/AMD/compressed_3DC_texture.py b/venv/lib/python3.12/site-packages/OpenGL/GLES1/AMD/compressed_3DC_texture.py new file mode 100644 index 00000000..8344c39f --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES1/AMD/compressed_3DC_texture.py @@ -0,0 +1,73 @@ +'''OpenGL extension AMD.compressed_3DC_texture + +This module customises the behaviour of the +OpenGL.raw.GLES1.AMD.compressed_3DC_texture to provide a more +Python-friendly API + +Overview (from the spec) + + Two compression formats are introduced: + + - A compression format for two component textures. When used to store + normal vectors, the two components are commonly used with a fragment + shader that derives the third component. + + - A compression format for single component textures. The single component + may be used as a luminance or an alpha value. + + There are a large number of games that use luminance only and/or alpha only + textures. For example, monochrome light maps used in a few popular games + are 8-bit luminance textures. This extension describes a compression format + that provides a 2:1 compression ratio for 8-bit single channel textures. + + Normal maps are special textures that are used to add detail to 3D surfaces. + They are an extension of earlier "bump map" textures, which contained per- + pixel height values and were used to create the appearance of bumpiness on + otherwise smooth surfaces. Normal maps contain more detailed surface + information, allowing them to represent much more complex shapes. + + Normal mapping is one of the key features that makes the current generation + of games look so much better than earlier titles. A limitation to the + effectiveness of this technique is the size of the textures required. In an + ideal case where every surface has both a color texture map and a normal + texture map, the texture memory and bandwidth requirements would double + compared to using color maps alone. + + In fact, the problem is much worse because existing block based compression + methods such as DXTc, ETC, and S3TC are ineffective at compressing normal + maps. They tend to have trouble capturing the small edges and subtle + curvature that normal maps are designed to capture, and they also introduce + unsightly block artifacts. + + Because normal maps are used to capture light reflections and realistic + surface highlights, these problems are amplified relative to their impact on + color textures. The results are sufficiently poor that game artists and + developers would rather not use normal map compression at all on most + surfaces, and instead limit themselves to lower resolution maps on selected + parts of the rendered scene. + + 3DC provides an ideal solution to the normal map compression problem. It + provides up to 4:1 compression of normal maps, with image quality that is + virtually indistinguishable from the uncompressed version. The technique is + hardware accelerated, so the performance impact is minimal. Thus, + developers are freed to use higher resolution, more detailed normal maps, + and/or use them on all of the objects in a scene rather than just a select + few. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/AMD/compressed_3DC_texture.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES1 import _types, _glgets +from OpenGL.raw.GLES1.AMD.compressed_3DC_texture import * +from OpenGL.raw.GLES1.AMD.compressed_3DC_texture import _EXTENSION_NAME + +def glInitCompressed3DcTextureAMD(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/AMD/compressed_ATC_texture.py b/venv/lib/python3.12/site-packages/OpenGL/GLES1/AMD/compressed_ATC_texture.py new file mode 100644 index 00000000..117deffb --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES1/AMD/compressed_ATC_texture.py @@ -0,0 +1,36 @@ +'''OpenGL extension AMD.compressed_ATC_texture + +This module customises the behaviour of the +OpenGL.raw.GLES1.AMD.compressed_ATC_texture to provide a more +Python-friendly API + +Overview (from the spec) + + This extension enables support for ATC compressed texture formats. ATC is + AMD's proprietary compression algorithm for compressing textures for + handheld devices to save on power consumption, memory footprint and + bandwidth. + + Three compression formats are introduced: + + - A compression format for RGB textures. + - A compression format for RGBA textures using explicit alpha encoding. + - A compression format for RGBA textures using interpolated alpha encoding. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/AMD/compressed_ATC_texture.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES1 import _types, _glgets +from OpenGL.raw.GLES1.AMD.compressed_ATC_texture import * +from OpenGL.raw.GLES1.AMD.compressed_ATC_texture import _EXTENSION_NAME + +def glInitCompressedAtcTextureAMD(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/APPLE/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/GLES1/APPLE/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES1/APPLE/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/APPLE/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES1/APPLE/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..4c610f90 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES1/APPLE/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/APPLE/__pycache__/copy_texture_levels.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES1/APPLE/__pycache__/copy_texture_levels.cpython-312.pyc new file mode 100644 index 00000000..85923937 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES1/APPLE/__pycache__/copy_texture_levels.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/APPLE/__pycache__/framebuffer_multisample.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES1/APPLE/__pycache__/framebuffer_multisample.cpython-312.pyc new file mode 100644 index 00000000..52ee6fa4 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES1/APPLE/__pycache__/framebuffer_multisample.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/APPLE/__pycache__/sync.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES1/APPLE/__pycache__/sync.cpython-312.pyc new file mode 100644 index 00000000..405328e3 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES1/APPLE/__pycache__/sync.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/APPLE/__pycache__/texture_2D_limited_npot.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES1/APPLE/__pycache__/texture_2D_limited_npot.cpython-312.pyc new file mode 100644 index 00000000..931606d5 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES1/APPLE/__pycache__/texture_2D_limited_npot.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/APPLE/__pycache__/texture_format_BGRA8888.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES1/APPLE/__pycache__/texture_format_BGRA8888.cpython-312.pyc new file mode 100644 index 00000000..a0b78cab Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES1/APPLE/__pycache__/texture_format_BGRA8888.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/APPLE/__pycache__/texture_max_level.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES1/APPLE/__pycache__/texture_max_level.cpython-312.pyc new file mode 100644 index 00000000..6f163629 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES1/APPLE/__pycache__/texture_max_level.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/APPLE/copy_texture_levels.py b/venv/lib/python3.12/site-packages/OpenGL/GLES1/APPLE/copy_texture_levels.py new file mode 100644 index 00000000..18d5f76a --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES1/APPLE/copy_texture_levels.py @@ -0,0 +1,49 @@ +'''OpenGL extension APPLE.copy_texture_levels + +This module customises the behaviour of the +OpenGL.raw.GLES1.APPLE.copy_texture_levels to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides an efficient path for copying a contiguous subset of mipmap + levels from one texture to the matching subset of mipmap levels of another texture, + where matches are determined by the equality of a level's dimensions. + + This extension is dependent on the existence of the extension EXT_texture_storage. + Immutable textures are used to guarantee that storage is allocated up front for the + source and destination textures and that the internal formats of those textures are + sized the same. + + An efficient copy can be achieved by implementations because the internal storage + requirements are the same between textures and will remain unchanged when moving data. + It is expected that in all cases, moving levels from one texture to another is a + simple copy operation without any necessary conversion. This extension can be used as + an alternative to TEXTURE_BASE_LEVEL. In some implementations, changing the value of + TEXTURE_BASE_LEVEL can incur a costly re-allocation at runtime. + + Texture streaming is an expected use case for this extension. For example, a developer + may want to stream in a larger base level for a given texture from a storage device. + To achieve this, a copy of the current mipmap levels are made into a destination + whose storage was specified to accommodate the source levels and the larger base + level. The efficiency of the copy without conversion allows for the smaller mipmap + levels to be in place while the larger base level is being read from the storage + device and uploaded. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/APPLE/copy_texture_levels.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES1 import _types, _glgets +from OpenGL.raw.GLES1.APPLE.copy_texture_levels import * +from OpenGL.raw.GLES1.APPLE.copy_texture_levels import _EXTENSION_NAME + +def glInitCopyTextureLevelsAPPLE(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/APPLE/framebuffer_multisample.py b/venv/lib/python3.12/site-packages/OpenGL/GLES1/APPLE/framebuffer_multisample.py new file mode 100644 index 00000000..7f4e965a --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES1/APPLE/framebuffer_multisample.py @@ -0,0 +1,51 @@ +'''OpenGL extension APPLE.framebuffer_multisample + +This module customises the behaviour of the +OpenGL.raw.GLES1.APPLE.framebuffer_multisample to provide a more +Python-friendly API + +Overview (from the spec) + + This extension extends the framebuffer object framework to + enable multisample rendering. + + The new operation RenderbufferStorageMultisampleAPPLE() allocates + storage for a renderbuffer object that can be used as a multisample + buffer. A multisample render buffer image differs from a + single-sample render buffer image in that a multisample image has a + number of SAMPLES that is greater than zero. No method is provided + for creating multisample texture images. + + All of the framebuffer-attachable images attached to a framebuffer + object must have the same number of SAMPLES or else the framebuffer + object is not "framebuffer complete". If a framebuffer object with + multisample attachments is "framebuffer complete", then the + framebuffer object behaves as if SAMPLE_BUFFERS is one. + + The resolve operation is affected by calling + ResolveMultisampleFramebufferAPPLE where the source is a multisample + application-created framebuffer object and the destination is a + single-sample framebuffer object. Separate read and draw framebuffer + object binding points are established to facilitate the resolve. + + Scissoring may be used in conjunction with + ResolveMultisampleFramebufferAPPLE to resolve only a portion of the + framebuffer. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/APPLE/framebuffer_multisample.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES1 import _types, _glgets +from OpenGL.raw.GLES1.APPLE.framebuffer_multisample import * +from OpenGL.raw.GLES1.APPLE.framebuffer_multisample import _EXTENSION_NAME + +def glInitFramebufferMultisampleAPPLE(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/APPLE/sync.py b/venv/lib/python3.12/site-packages/OpenGL/GLES1/APPLE/sync.py new file mode 100644 index 00000000..da276cc6 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES1/APPLE/sync.py @@ -0,0 +1,48 @@ +'''OpenGL extension APPLE.sync + +This module customises the behaviour of the +OpenGL.raw.GLES1.APPLE.sync to provide a more +Python-friendly API + +Overview (from the spec) + + This extension introduces the concept of "sync objects". Sync + objects are a synchronization primitive - a representation of events + whose completion status can be tested or waited upon. One specific + type of sync object, the "fence sync object", is supported in this + extension, and additional types can easily be added in the future. + + Fence sync objects have corresponding fences, which are inserted + into the OpenGL command stream at the time the sync object is + created. A sync object can be queried for a given condition. The + only condition supported for fence sync objects is completion of the + corresponding fence command. Fence completion allows applications to + request a partial Finish, wherein all commands prior to the fence + will be forced to complete before control is returned to the calling + process. + + These new mechanisms allow for synchronization between the host CPU + and the GPU, which may be accessing the same resources (typically + memory), as well as between multiple GL contexts bound to multiple + threads in the host CPU. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/APPLE/sync.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES1 import _types, _glgets +from OpenGL.raw.GLES1.APPLE.sync import * +from OpenGL.raw.GLES1.APPLE.sync import _EXTENSION_NAME + +def glInitSyncAPPLE(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glGetSyncivAPPLE.values size not checked against bufSize +glGetSyncivAPPLE=wrapper.wrapper(glGetSyncivAPPLE).setInputArraySize( + 'values', None +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/APPLE/texture_2D_limited_npot.py b/venv/lib/python3.12/site-packages/OpenGL/GLES1/APPLE/texture_2D_limited_npot.py new file mode 100644 index 00000000..8ef61144 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES1/APPLE/texture_2D_limited_npot.py @@ -0,0 +1,42 @@ +'''OpenGL extension APPLE.texture_2D_limited_npot + +This module customises the behaviour of the +OpenGL.raw.GLES1.APPLE.texture_2D_limited_npot to provide a more +Python-friendly API + +Overview (from the spec) + + Conventional OpenGL ES 1.X texturing is limited to images with + power-of-two (POT) dimensions. APPLE_texture_2D_limited_npot extension + relaxes these size restrictions for 2D textures. The restrictions remain + in place for cube map and 3D textures, if supported. + + There is no additional procedural or enumerant API introduced by this + extension except that an implementation which exports the extension string + will allow an application to pass in 2D texture dimensions that may or may + not be a power of two. + + In the absence of OES_texture_npot, which lifts these restrictions, neither + mipmapping nor wrap modes other than CLAMP_TO_EDGE are supported in + conjunction with NPOT 2D textures. A NPOT 2D texture with a wrap mode that + is not CLAMP_TO_EDGE or a minfilter that is not NEAREST or LINEAR is + considered incomplete. If such a texture is bound to a texture unit, it is + as if texture mapping were disabled for that texture unit. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/APPLE/texture_2D_limited_npot.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES1 import _types, _glgets +from OpenGL.raw.GLES1.APPLE.texture_2D_limited_npot import * +from OpenGL.raw.GLES1.APPLE.texture_2D_limited_npot import _EXTENSION_NAME + +def glInitTexture2DLimitedNpotAPPLE(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/APPLE/texture_format_BGRA8888.py b/venv/lib/python3.12/site-packages/OpenGL/GLES1/APPLE/texture_format_BGRA8888.py new file mode 100644 index 00000000..2b6ed953 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES1/APPLE/texture_format_BGRA8888.py @@ -0,0 +1,29 @@ +'''OpenGL extension APPLE.texture_format_BGRA8888 + +This module customises the behaviour of the +OpenGL.raw.GLES1.APPLE.texture_format_BGRA8888 to provide a more +Python-friendly API + +Overview (from the spec) + + This extension introduces BGRA_EXT as an acceptable external format. + This avoids byte swizzling when loading RGBA internal format + textures, which may be stored in BGRA order internally. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/APPLE/texture_format_BGRA8888.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES1 import _types, _glgets +from OpenGL.raw.GLES1.APPLE.texture_format_BGRA8888 import * +from OpenGL.raw.GLES1.APPLE.texture_format_BGRA8888 import _EXTENSION_NAME + +def glInitTextureFormatBgra8888APPLE(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/APPLE/texture_max_level.py b/venv/lib/python3.12/site-packages/OpenGL/GLES1/APPLE/texture_max_level.py new file mode 100644 index 00000000..c6b357ca --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES1/APPLE/texture_max_level.py @@ -0,0 +1,30 @@ +'''OpenGL extension APPLE.texture_max_level + +This module customises the behaviour of the +OpenGL.raw.GLES1.APPLE.texture_max_level to provide a more +Python-friendly API + +Overview (from the spec) + + This extension allows an application to specify the maximum (coarsest) + mipmap level that may be selected for the specified texture. This maximum + level is also used to determine which mip levels are considered when + determining texture completeness. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/APPLE/texture_max_level.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES1 import _types, _glgets +from OpenGL.raw.GLES1.APPLE.texture_max_level import * +from OpenGL.raw.GLES1.APPLE.texture_max_level import _EXTENSION_NAME + +def glInitTextureMaxLevelAPPLE(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/ARM/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/GLES1/ARM/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES1/ARM/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/ARM/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES1/ARM/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..c2bf87ca Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES1/ARM/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/ARM/__pycache__/rgba8.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES1/ARM/__pycache__/rgba8.cpython-312.pyc new file mode 100644 index 00000000..aa01a600 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES1/ARM/__pycache__/rgba8.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/ARM/rgba8.py b/venv/lib/python3.12/site-packages/OpenGL/GLES1/ARM/rgba8.py new file mode 100644 index 00000000..7a427fb6 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES1/ARM/rgba8.py @@ -0,0 +1,28 @@ +'''OpenGL extension ARM.rgba8 + +This module customises the behaviour of the +OpenGL.raw.GLES1.ARM.rgba8 to provide a more +Python-friendly API + +Overview (from the spec) + + This extension enables a RGBA8 renderbuffer storage format. + It is similar to OES_rgb8_rgba8, but only exposes RGBA8. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARM/rgba8.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES1 import _types, _glgets +from OpenGL.raw.GLES1.ARM.rgba8 import * +from OpenGL.raw.GLES1.ARM.rgba8 import _EXTENSION_NAME + +def glInitRgba8ARM(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/EXT/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/GLES1/EXT/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES1/EXT/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/EXT/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES1/EXT/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..54b0e556 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES1/EXT/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/EXT/__pycache__/blend_minmax.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES1/EXT/__pycache__/blend_minmax.cpython-312.pyc new file mode 100644 index 00000000..acdb561e Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES1/EXT/__pycache__/blend_minmax.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/EXT/__pycache__/debug_marker.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES1/EXT/__pycache__/debug_marker.cpython-312.pyc new file mode 100644 index 00000000..098e4e99 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES1/EXT/__pycache__/debug_marker.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/EXT/__pycache__/discard_framebuffer.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES1/EXT/__pycache__/discard_framebuffer.cpython-312.pyc new file mode 100644 index 00000000..228d13dc Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES1/EXT/__pycache__/discard_framebuffer.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/EXT/__pycache__/map_buffer_range.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES1/EXT/__pycache__/map_buffer_range.cpython-312.pyc new file mode 100644 index 00000000..b3a6b0bf Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES1/EXT/__pycache__/map_buffer_range.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/EXT/__pycache__/multi_draw_arrays.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES1/EXT/__pycache__/multi_draw_arrays.cpython-312.pyc new file mode 100644 index 00000000..6a7185db Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES1/EXT/__pycache__/multi_draw_arrays.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/EXT/__pycache__/multisampled_render_to_texture.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES1/EXT/__pycache__/multisampled_render_to_texture.cpython-312.pyc new file mode 100644 index 00000000..5a855522 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES1/EXT/__pycache__/multisampled_render_to_texture.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/EXT/__pycache__/read_format_bgra.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES1/EXT/__pycache__/read_format_bgra.cpython-312.pyc new file mode 100644 index 00000000..b96a545e Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES1/EXT/__pycache__/read_format_bgra.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/EXT/__pycache__/robustness.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES1/EXT/__pycache__/robustness.cpython-312.pyc new file mode 100644 index 00000000..0a26f4b9 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES1/EXT/__pycache__/robustness.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/EXT/__pycache__/sRGB.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES1/EXT/__pycache__/sRGB.cpython-312.pyc new file mode 100644 index 00000000..2837c4d4 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES1/EXT/__pycache__/sRGB.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/EXT/__pycache__/texture_compression_dxt1.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES1/EXT/__pycache__/texture_compression_dxt1.cpython-312.pyc new file mode 100644 index 00000000..62c2075f Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES1/EXT/__pycache__/texture_compression_dxt1.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/EXT/__pycache__/texture_filter_anisotropic.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES1/EXT/__pycache__/texture_filter_anisotropic.cpython-312.pyc new file mode 100644 index 00000000..fbbcfda8 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES1/EXT/__pycache__/texture_filter_anisotropic.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/EXT/__pycache__/texture_format_BGRA8888.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES1/EXT/__pycache__/texture_format_BGRA8888.cpython-312.pyc new file mode 100644 index 00000000..03bfb048 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES1/EXT/__pycache__/texture_format_BGRA8888.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/EXT/__pycache__/texture_lod_bias.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES1/EXT/__pycache__/texture_lod_bias.cpython-312.pyc new file mode 100644 index 00000000..eddccb43 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES1/EXT/__pycache__/texture_lod_bias.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/EXT/__pycache__/texture_storage.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES1/EXT/__pycache__/texture_storage.cpython-312.pyc new file mode 100644 index 00000000..41310da8 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES1/EXT/__pycache__/texture_storage.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/EXT/blend_minmax.py b/venv/lib/python3.12/site-packages/OpenGL/GLES1/EXT/blend_minmax.py new file mode 100644 index 00000000..3a18756f --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES1/EXT/blend_minmax.py @@ -0,0 +1,35 @@ +'''OpenGL extension EXT.blend_minmax + +This module customises the behaviour of the +OpenGL.raw.GLES1.EXT.blend_minmax to provide a more +Python-friendly API + +Overview (from the spec) + + Blending capability is extended by respecifying the entire blend + equation. While this document defines only two new equations, the + BlendEquationEXT procedure that it defines will be used by subsequent + extensions to define additional blending equations. + + The two new equations defined by this extension produce the minimum + (or maximum) color components of the source and destination colors. + Taking the maximum is useful for applications such as maximum projection + in medical imaging. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/blend_minmax.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES1 import _types, _glgets +from OpenGL.raw.GLES1.EXT.blend_minmax import * +from OpenGL.raw.GLES1.EXT.blend_minmax import _EXTENSION_NAME + +def glInitBlendMinmaxEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/EXT/debug_marker.py b/venv/lib/python3.12/site-packages/OpenGL/GLES1/EXT/debug_marker.py new file mode 100644 index 00000000..44c1772e --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES1/EXT/debug_marker.py @@ -0,0 +1,38 @@ +'''OpenGL extension EXT.debug_marker + +This module customises the behaviour of the +OpenGL.raw.GLES1.EXT.debug_marker to provide a more +Python-friendly API + +Overview (from the spec) + + This extension defines a mechanism for OpenGL and OpenGL ES applications to + annotate their command stream with markers for discrete events and groups + of commands using descriptive text markers. + + When profiling or debugging such an application within a debugger or + profiler it is difficult to relate the commands within the command stream + to the elements of the scene or parts of the program code to which they + correspond. Markers help obviate this by allowing applications to specify + this link. + + The intended purpose of this is purely to improve the user experience + within OpenGL and OpenGL ES development tools. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/debug_marker.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES1 import _types, _glgets +from OpenGL.raw.GLES1.EXT.debug_marker import * +from OpenGL.raw.GLES1.EXT.debug_marker import _EXTENSION_NAME + +def glInitDebugMarkerEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/EXT/discard_framebuffer.py b/venv/lib/python3.12/site-packages/OpenGL/GLES1/EXT/discard_framebuffer.py new file mode 100644 index 00000000..3cf51232 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES1/EXT/discard_framebuffer.py @@ -0,0 +1,52 @@ +'''OpenGL extension EXT.discard_framebuffer + +This module customises the behaviour of the +OpenGL.raw.GLES1.EXT.discard_framebuffer to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides a new command, DiscardFramebufferEXT, which + causes the contents of the named framebuffer attachable images to become + undefined. The contents of the specified buffers are undefined until a + subsequent operation modifies the content, and only the modified region + is guaranteed to hold valid content. Effective usage of this command + may provide an implementation with new optimization opportunities. + + Some OpenGL ES implementations cache framebuffer images in a small pool + of fast memory. Before rendering, these implementations must load the + existing contents of one or more of the logical buffers (color, depth, + stencil, etc.) into this memory. After rendering, some or all of these + buffers are likewise stored back to external memory so their contents can + be used again in the future. In many applications, some or all of the + logical buffers are cleared at the start of rendering. If so, the + effort to load or store those buffers is wasted. + + Even without this extension, if a frame of rendering begins with a full- + screen Clear, an OpenGL ES implementation may optimize away the loading + of framebuffer contents prior to rendering the frame. With this extension, + an application can use DiscardFramebufferEXT to signal that framebuffer + contents will no longer be needed. In this case an OpenGL ES + implementation may also optimize away the storing back of framebuffer + contents after rendering the frame. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/discard_framebuffer.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES1 import _types, _glgets +from OpenGL.raw.GLES1.EXT.discard_framebuffer import * +from OpenGL.raw.GLES1.EXT.discard_framebuffer import _EXTENSION_NAME + +def glInitDiscardFramebufferEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glDiscardFramebufferEXT.attachments size not checked against numAttachments +glDiscardFramebufferEXT=wrapper.wrapper(glDiscardFramebufferEXT).setInputArraySize( + 'attachments', None +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/EXT/map_buffer_range.py b/venv/lib/python3.12/site-packages/OpenGL/GLES1/EXT/map_buffer_range.py new file mode 100644 index 00000000..c9e05f92 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES1/EXT/map_buffer_range.py @@ -0,0 +1,46 @@ +'''OpenGL extension EXT.map_buffer_range + +This module customises the behaviour of the +OpenGL.raw.GLES1.EXT.map_buffer_range to provide a more +Python-friendly API + +Overview (from the spec) + + EXT_map_buffer_range expands the buffer object API to allow greater + performance when a client application only needs to write to a sub-range + of a buffer object. To that end, this extension introduces two new buffer + object features: non-serialized buffer modification and explicit sub-range + flushing for mapped buffer objects. + + OpenGL requires that commands occur in a FIFO manner meaning that any + changes to buffer objects either block until the data has been processed by + the OpenGL pipeline or else create extra copies to avoid such a block. By + providing a method to asynchronously modify buffer object data, an + application is then able to manage the synchronization points themselves + and modify ranges of data contained by a buffer object even though OpenGL + might still be using other parts of it. + + This extension also provides a method for explicitly flushing ranges of a + mapped buffer object so OpenGL does not have to assume that the entire + range may have been modified. Further, it allows the application to more + precisely specify its intent with respect to reading, writing, and whether + the previous contents of a mapped range of interest need be preserved + prior to modification. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/map_buffer_range.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES1 import _types, _glgets +from OpenGL.raw.GLES1.EXT.map_buffer_range import * +from OpenGL.raw.GLES1.EXT.map_buffer_range import _EXTENSION_NAME + +def glInitMapBufferRangeEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/EXT/multi_draw_arrays.py b/venv/lib/python3.12/site-packages/OpenGL/GLES1/EXT/multi_draw_arrays.py new file mode 100644 index 00000000..8bc4456e --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES1/EXT/multi_draw_arrays.py @@ -0,0 +1,44 @@ +'''OpenGL extension EXT.multi_draw_arrays + +This module customises the behaviour of the +OpenGL.raw.GLES1.EXT.multi_draw_arrays to provide a more +Python-friendly API + +Overview (from the spec) + + These functions behave identically to the standard OpenGL 1.1 functions + glDrawArrays() and glDrawElements() except they handle multiple lists of + vertices in one call. Their main purpose is to allow one function call + to render more than one primitive such as triangle strip, triangle fan, + etc. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/multi_draw_arrays.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES1 import _types, _glgets +from OpenGL.raw.GLES1.EXT.multi_draw_arrays import * +from OpenGL.raw.GLES1.EXT.multi_draw_arrays import _EXTENSION_NAME + +def glInitMultiDrawArraysEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glMultiDrawArraysEXT.count size not checked against 'primcount' +# INPUT glMultiDrawArraysEXT.first size not checked against 'primcount' +glMultiDrawArraysEXT=wrapper.wrapper(glMultiDrawArraysEXT).setInputArraySize( + 'count', None +).setInputArraySize( + 'first', None +) +# INPUT glMultiDrawElementsEXT.count size not checked against 'primcount' +# INPUT glMultiDrawElementsEXT.indices size not checked against 'primcount' +glMultiDrawElementsEXT=wrapper.wrapper(glMultiDrawElementsEXT).setInputArraySize( + 'count', None +).setInputArraySize( + 'indices', None +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/EXT/multisampled_render_to_texture.py b/venv/lib/python3.12/site-packages/OpenGL/GLES1/EXT/multisampled_render_to_texture.py new file mode 100644 index 00000000..928d9203 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES1/EXT/multisampled_render_to_texture.py @@ -0,0 +1,51 @@ +'''OpenGL extension EXT.multisampled_render_to_texture + +This module customises the behaviour of the +OpenGL.raw.GLES1.EXT.multisampled_render_to_texture to provide a more +Python-friendly API + +Overview (from the spec) + + This extension introduces functionality to perform multisampled + rendering to a color renderable texture, without requiring an + explicit resolve of multisample data. + + Some GPU architectures - such as tile-based renderers - are + capable of performing multisampled rendering by storing + multisample data in internal high-speed memory and downsampling the + data when writing out to external memory after rendering has + finished. Since per-sample data is never written out to external + memory, this approach saves bandwidth and storage space. In this + case multisample data gets discarded, however this is acceptable + in most cases. + + The extension provides a new command, FramebufferTexture2DMultisampleEXT, + which attaches a texture level to a framebuffer and enables + multisampled rendering to that texture level. + + When the texture level is flushed or used as a source or destination + for any operation other than drawing to it, an implicit resolve of + multisampled color data may be performed. After such a resolve, the + multisampled color data is discarded. + + In order to allow the use of multisampled depth and stencil buffers + when performing multisampled rendering to a texture, the extension + also adds the command RenderbufferStorageMultisampleEXT. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/multisampled_render_to_texture.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES1 import _types, _glgets +from OpenGL.raw.GLES1.EXT.multisampled_render_to_texture import * +from OpenGL.raw.GLES1.EXT.multisampled_render_to_texture import _EXTENSION_NAME + +def glInitMultisampledRenderToTextureEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/EXT/read_format_bgra.py b/venv/lib/python3.12/site-packages/OpenGL/GLES1/EXT/read_format_bgra.py new file mode 100644 index 00000000..7b88d8ce --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES1/EXT/read_format_bgra.py @@ -0,0 +1,46 @@ +'''OpenGL extension EXT.read_format_bgra + +This module customises the behaviour of the +OpenGL.raw.GLES1.EXT.read_format_bgra to provide a more +Python-friendly API + +Overview (from the spec) + + This extension is intended to supplement the GL_OES_read_format + extension by adding support for more format/type combinations to be used + when calling ReadPixels. ReadPixels currently accepts one fixed + format/type combination (format RGBA and type UNSIGNED_BYTE) for + portability, and an implementation specific format/type combination + queried using the tokens IMPLEMENTATION_COLOR_READ_FORMAT_OES and + IMPLEMENTATION_COLOR_READ_TYPE_OES (GL_OES_read_format extension). This + extension adds the following format/type combinations to those currently + allowed to be returned by GetIntegerV: + + format type + ------ ---- + BGRA_EXT UNSIGNED_BYTE + BGRA_EXT UNSIGNED_SHORT_4_4_4_4_REV_EXT + BGRA_EXT UNSIGNED_SHORT_1_5_5_5_REV_EXT + + E.g. Calling GetIntegerv with a parameter of + IMPLEMENTATION_COLOR_READ_FORMAT_OES can now return BGRA_EXT, with the + corresponding call to GetIntegerv using a parameter of + IMPLEMENTATION_COLOR_READ_TYPE_OES returning UNSIGNED_BYTE; + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/read_format_bgra.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES1 import _types, _glgets +from OpenGL.raw.GLES1.EXT.read_format_bgra import * +from OpenGL.raw.GLES1.EXT.read_format_bgra import _EXTENSION_NAME + +def glInitReadFormatBgraEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/EXT/robustness.py b/venv/lib/python3.12/site-packages/OpenGL/GLES1/EXT/robustness.py new file mode 100644 index 00000000..0933f45e --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES1/EXT/robustness.py @@ -0,0 +1,89 @@ +'''OpenGL extension EXT.robustness + +This module customises the behaviour of the +OpenGL.raw.GLES1.EXT.robustness to provide a more +Python-friendly API + +Overview (from the spec) + + Several recent trends in how OpenGL integrates into modern computer + systems have created new requirements for robustness and security + for OpenGL rendering contexts. + + Additionally GPU architectures now support hardware fault detection; + for example, video memory supporting ECC (error correcting codes) + and error detection. OpenGL contexts should be capable of recovering + from hardware faults such as uncorrectable memory errors. Along with + recovery from such hardware faults, the recovery mechanism can + also allow recovery from video memory access exceptions and system + software failures. System software failures can be due to device + changes or driver failures. + + OpenGL queries that that return (write) some number of bytes to a + buffer indicated by a pointer parameter introduce risk of buffer + overflows that might be exploitable by malware. To address this, + queries with return value sizes that are not expressed directly by + the parameters to the query itself are given additional API + functions with an additional parameter that specifies the number of + bytes in the buffer and never writing bytes beyond that limit. This + is particularly useful for multi-threaded usage of OpenGL contexts + in a "share group" where one context can change objects in ways that + can cause buffer overflows for another context's OpenGL queries. + + The original ARB_vertex_buffer_object extension includes an issue + that explicitly states program termination is allowed when + out-of-bounds vertex buffer object fetches occur. Modern graphics + hardware is capable well-defined behavior in the case of out-of- + bounds vertex buffer object fetches. Older hardware may require + extra checks to enforce well-defined (and termination free) + behavior, but this expense is warranted when processing potentially + untrusted content. + + The intent of this extension is to address some specific robustness + goals: + + * For all existing OpenGL queries, provide additional "safe" APIs + that limit data written to user pointers to a buffer size in + bytes that is an explicit additional parameter of the query. + + * Provide a mechanism for an OpenGL application to learn about + graphics resets that affect the context. When a graphics reset + occurs, the OpenGL context becomes unusable and the application + must create a new context to continue operation. Detecting a + graphics reset happens through an inexpensive query. + + * Provide an enable to guarantee that out-of-bounds buffer object + accesses by the GPU will have deterministic behavior and preclude + application instability or termination due to an incorrect buffer + access. Such accesses include vertex buffer fetches of + attributes and indices, and indexed reads of uniforms or + parameters from buffers. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/robustness.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES1 import _types, _glgets +from OpenGL.raw.GLES1.EXT.robustness import * +from OpenGL.raw.GLES1.EXT.robustness import _EXTENSION_NAME + +def glInitRobustnessEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glReadnPixelsEXT.data size not checked against bufSize +glReadnPixelsEXT=wrapper.wrapper(glReadnPixelsEXT).setInputArraySize( + 'data', None +) +# INPUT glGetnUniformfvEXT.params size not checked against bufSize +glGetnUniformfvEXT=wrapper.wrapper(glGetnUniformfvEXT).setInputArraySize( + 'params', None +) +# INPUT glGetnUniformivEXT.params size not checked against bufSize +glGetnUniformivEXT=wrapper.wrapper(glGetnUniformivEXT).setInputArraySize( + 'params', None +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/EXT/sRGB.py b/venv/lib/python3.12/site-packages/OpenGL/GLES1/EXT/sRGB.py new file mode 100644 index 00000000..8d86d18e --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES1/EXT/sRGB.py @@ -0,0 +1,54 @@ +'''OpenGL extension EXT.sRGB + +This module customises the behaviour of the +OpenGL.raw.GLES1.EXT.sRGB to provide a more +Python-friendly API + +Overview (from the spec) + + The sRGB color space is based on typical (non-linear) response of the human + eye. It has been standardized by the International Electrotechnical + Commission (IEC) as IEC 61966-2-1. The transfer function of sRGB roughly + corresponds to a power function with a gamma of 2.2. + + FRAMEBUFFERS + + OpenGL assumes framebuffer color components are stored in a linear color + space. In particular, framebuffer blending is a linear operation. + + This extension adds a framebuffer capability for sRGB framebuffer update + and blending. When blending is disabled but the new sRGB updated mode is + enabled (assume the framebuffer supports the capability), high-precision + linear color component values for red, green, and blue generated by + fragment coloring are encoded for sRGB prior to being written into the + framebuffer. When blending is enabled along with the new sRGB update mode, + red, green, and blue framebuffer color components are treated as sRGB + values that are converted to linear color values, blended with the high- + precision color values generated by fragment coloring, and then the blend + result is encoded for sRGB just prior to being written into the + framebuffer. + + TEXTURES + + Conventional texture formats assume a linear color space. So for a + conventional internal texture format such as GL_RGB8, the 256 discrete + values for each 8-bit color component map linearly and uniformly to the + [0,1] range. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/sRGB.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES1 import _types, _glgets +from OpenGL.raw.GLES1.EXT.sRGB import * +from OpenGL.raw.GLES1.EXT.sRGB import _EXTENSION_NAME + +def glInitSrgbEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/EXT/texture_compression_dxt1.py b/venv/lib/python3.12/site-packages/OpenGL/GLES1/EXT/texture_compression_dxt1.py new file mode 100644 index 00000000..e1392664 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES1/EXT/texture_compression_dxt1.py @@ -0,0 +1,52 @@ +'''OpenGL extension EXT.texture_compression_dxt1 + +This module customises the behaviour of the +OpenGL.raw.GLES1.EXT.texture_compression_dxt1 to provide a more +Python-friendly API + +Overview (from the spec) + + Support of EXT_texture_compression_s3tc is attractive for OpenGL-ES + implementations because it provides compressed textures that allow + for significantly reduced texture storage. Reducing texture storage is + advantageous because of the smaller memory capacity of many embedded + systems compared to desktop systems. Smaller textures also provide a + welcome performance advantage since embedded platforms typically provide + less performance than desktop systems. S3TC compressed textures + are widely supported and used by applications. The DXT1 format is + used in the vast majority of cases in which S3TC compressed textures + are used. + + However, EXT_texture_compression_s3tc specifies functionality that is + burdensome for an OpenGL-ES implementation. In particular it requires + that the driver provide the capability to compress textures into + S3TC texture formats, as an S3TC texture format is accepted as the + parameter of TexImage2D and CopyTexImage2D. Further, + EXT_texture_compression_s3tc may require conversion from one S3TC + format to another during CompressedTexSubImage2D if the + parameter does not match the of the texture image + previously created by TexImage2D. + + In an OpenGL-ES implementation it is therefore advantageous to support + a limited subset of EXT_texture_compression_s3tc: Restrict supported + texture formats to DXT1 and restrict supported operations to those + that do not require texture compression into an S3TC texture format or + decompression from an S3TC texture format. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/texture_compression_dxt1.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES1 import _types, _glgets +from OpenGL.raw.GLES1.EXT.texture_compression_dxt1 import * +from OpenGL.raw.GLES1.EXT.texture_compression_dxt1 import _EXTENSION_NAME + +def glInitTextureCompressionDxt1EXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/EXT/texture_filter_anisotropic.py b/venv/lib/python3.12/site-packages/OpenGL/GLES1/EXT/texture_filter_anisotropic.py new file mode 100644 index 00000000..f88d13f9 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES1/EXT/texture_filter_anisotropic.py @@ -0,0 +1,64 @@ +'''OpenGL extension EXT.texture_filter_anisotropic + +This module customises the behaviour of the +OpenGL.raw.GLES1.EXT.texture_filter_anisotropic to provide a more +Python-friendly API + +Overview (from the spec) + + Texture mapping using OpenGL's existing mipmap texture filtering + modes assumes that the projection of the pixel filter footprint into + texture space is a square (ie, isotropic). In practice however, the + footprint may be long and narrow (ie, anisotropic). Consequently, + mipmap filtering severely blurs images on surfaces angled obliquely + away from the viewer. + + Several approaches exist for improving texture sampling by accounting + for the anisotropic nature of the pixel filter footprint into texture + space. This extension provides a general mechanism for supporting + anisotropic texturing filtering schemes without specifying a + particular formulation of anisotropic filtering. + + The extension permits the OpenGL application to specify on + a per-texture object basis the maximum degree of anisotropy to + account for in texture filtering. + + Increasing a texture object's maximum degree of anisotropy may + improve texture filtering but may also significantly reduce the + implementation's texture filtering rate. Implementations are free + to clamp the specified degree of anisotropy to the implementation's + maximum supported degree of anisotropy. + + A texture's maximum degree of anisotropy is specified independent + from the texture's minification and magnification filter (as + opposed to being supported as an entirely new filtering mode). + Implementations are free to use the specified minification and + magnification filter to select a particular anisotropic texture + filtering scheme. For example, a NEAREST filter with a maximum + degree of anisotropy of two could be treated as a 2-tap filter that + accounts for the direction of anisotropy. Implementations are also + permitted to ignore the minification or magnification filter and + implement the highest quality of anisotropic filtering possible. + + Applications seeking the highest quality anisotropic filtering + available are advised to request a LINEAR_MIPMAP_LINEAR minification + filter, a LINEAR magnification filter, and a large maximum degree + of anisotropy. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/texture_filter_anisotropic.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES1 import _types, _glgets +from OpenGL.raw.GLES1.EXT.texture_filter_anisotropic import * +from OpenGL.raw.GLES1.EXT.texture_filter_anisotropic import _EXTENSION_NAME + +def glInitTextureFilterAnisotropicEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/EXT/texture_format_BGRA8888.py b/venv/lib/python3.12/site-packages/OpenGL/GLES1/EXT/texture_format_BGRA8888.py new file mode 100644 index 00000000..1708931a --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES1/EXT/texture_format_BGRA8888.py @@ -0,0 +1,57 @@ +'''OpenGL extension EXT.texture_format_BGRA8888 + +This module customises the behaviour of the +OpenGL.raw.GLES1.EXT.texture_format_BGRA8888 to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides an additional format and type combination + for use when specifying texture data. The current allowed combinations + are: + + Internal Format External Format Type Bytes per Pixel + --------------- --------------- ---- --------------- + RGBA RGBA UNSIGNED_BYTE 4 + RGB RGB UNSIGNED_BYTE 3 + RGBA RGBA UNSIGNED_SHORT_4_4_4_4 2 + RGBA RGBA UNSIGNED_SHORT_5_5_5_1 2 + RGB RGB UNSIGNED_SHORT_5_6_5 2 + LUMINANCE_ALPHA LUMINANCE_ALPHA UNSIGNED_BYTE 2 + LUMINANCE LUMINANCE UNSIGNED_BYTE 1 + ALPHA ALPHA UNSIGNED_BYTE 1 + + + This table is extended to include format BGRA_EXT and type UNSIGNED_BYTE: + + Internal Format External Format Type Bytes per Pixel + --------------- --------------- ---- --------------- + BGRA_EXT BGRA_EXT UNSIGNED_BYTE 4 + RGBA RGBA UNSIGNED_BYTE 4 + RGB RGB UNSIGNED_BYTE 3 + RGBA RGBA UNSIGNED_SHORT_4_4_4_4 2 + RGBA RGBA UNSIGNED_SHORT_5_5_5_1 2 + RGB RGB UNSIGNED_SHORT_5_6_5 2 + LUMINANCE_ALPHA LUMINANCE_ALPHA UNSIGNED_BYTE 2 + LUMINANCE LUMINANCE UNSIGNED_BYTE 1 + ALPHA ALPHA UNSIGNED_BYTE 1 + + This format is renderable in versions of OpenGL ES from 2.0 onwards. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/texture_format_BGRA8888.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES1 import _types, _glgets +from OpenGL.raw.GLES1.EXT.texture_format_BGRA8888 import * +from OpenGL.raw.GLES1.EXT.texture_format_BGRA8888 import _EXTENSION_NAME + +def glInitTextureFormatBgra8888EXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/EXT/texture_lod_bias.py b/venv/lib/python3.12/site-packages/OpenGL/GLES1/EXT/texture_lod_bias.py new file mode 100644 index 00000000..ff3e3fc2 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES1/EXT/texture_lod_bias.py @@ -0,0 +1,41 @@ +'''OpenGL extension EXT.texture_lod_bias + +This module customises the behaviour of the +OpenGL.raw.GLES1.EXT.texture_lod_bias to provide a more +Python-friendly API + +Overview (from the spec) + + OpenGL computes a texture level-of-detail parameter, called lambda + in the GL specification, that determines which mipmap levels and + their relative mipmap weights for use in mipmapped texture filtering. + + This extension provides a means to bias the lambda computation + by a constant (signed) value. This bias can provide a way to blur + or pseudo-sharpen OpenGL's standard texture filtering. + + This blurring or pseudo-sharpening may be useful for special effects + (such as depth-of-field effects) or image processing techniques + (where the mipmap levels act as pre-downsampled image versions). + On some implementations, increasing the texture lod bias may improve + texture filtering performance (at the cost of texture bluriness). + + The extension mimics functionality found in Direct3D. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/texture_lod_bias.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES1 import _types, _glgets +from OpenGL.raw.GLES1.EXT.texture_lod_bias import * +from OpenGL.raw.GLES1.EXT.texture_lod_bias import _EXTENSION_NAME + +def glInitTextureLodBiasEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/EXT/texture_storage.py b/venv/lib/python3.12/site-packages/OpenGL/GLES1/EXT/texture_storage.py new file mode 100644 index 00000000..4b880d36 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES1/EXT/texture_storage.py @@ -0,0 +1,45 @@ +'''OpenGL extension EXT.texture_storage + +This module customises the behaviour of the +OpenGL.raw.GLES1.EXT.texture_storage to provide a more +Python-friendly API + +Overview (from the spec) + + The texture image specification commands in OpenGL allow each level + to be separately specified with different sizes, formats, types and + so on, and only imposes consistency checks at draw time. This adds + overhead for implementations. + + This extension provides a mechanism for specifying the entire + structure of a texture in a single call, allowing certain + consistency checks and memory allocations to be done up front. Once + specified, the format and dimensions of the image array become + immutable, to simplify completeness checks in the implementation. + + When using this extension, it is no longer possible to supply texture + data using TexImage*. Instead, data can be uploaded using TexSubImage*, + or produced by other means (such as render-to-texture, mipmap generation, + or rendering to a sibling EGLImage). + + This extension has complicated interactions with other extensions. + The goal of most of these interactions is to ensure that a texture + is always mipmap complete (and cube complete for cubemap textures). + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/texture_storage.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES1 import _types, _glgets +from OpenGL.raw.GLES1.EXT.texture_storage import * +from OpenGL.raw.GLES1.EXT.texture_storage import _EXTENSION_NAME + +def glInitTextureStorageEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/IMG/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/GLES1/IMG/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES1/IMG/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/IMG/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES1/IMG/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..d88be059 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES1/IMG/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/IMG/__pycache__/multisampled_render_to_texture.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES1/IMG/__pycache__/multisampled_render_to_texture.cpython-312.pyc new file mode 100644 index 00000000..5a0a5984 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES1/IMG/__pycache__/multisampled_render_to_texture.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/IMG/__pycache__/read_format.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES1/IMG/__pycache__/read_format.cpython-312.pyc new file mode 100644 index 00000000..3bdf302e Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES1/IMG/__pycache__/read_format.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/IMG/__pycache__/texture_compression_pvrtc.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES1/IMG/__pycache__/texture_compression_pvrtc.cpython-312.pyc new file mode 100644 index 00000000..fe0ea899 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES1/IMG/__pycache__/texture_compression_pvrtc.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/IMG/__pycache__/texture_env_enhanced_fixed_function.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES1/IMG/__pycache__/texture_env_enhanced_fixed_function.cpython-312.pyc new file mode 100644 index 00000000..7d987ef6 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES1/IMG/__pycache__/texture_env_enhanced_fixed_function.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/IMG/__pycache__/user_clip_plane.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES1/IMG/__pycache__/user_clip_plane.cpython-312.pyc new file mode 100644 index 00000000..ae5a7497 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES1/IMG/__pycache__/user_clip_plane.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/IMG/multisampled_render_to_texture.py b/venv/lib/python3.12/site-packages/OpenGL/GLES1/IMG/multisampled_render_to_texture.py new file mode 100644 index 00000000..a87816e1 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES1/IMG/multisampled_render_to_texture.py @@ -0,0 +1,51 @@ +'''OpenGL extension IMG.multisampled_render_to_texture + +This module customises the behaviour of the +OpenGL.raw.GLES1.IMG.multisampled_render_to_texture to provide a more +Python-friendly API + +Overview (from the spec) + + This extension introduces functionality to perform multisampled + rendering to a color renderable texture, without requiring an + explicit resolve of multisample data. + + Some GPU architectures - such as tile-based renderers - are + capable of performing multisampled rendering by storing + multisample data in internal high-speed memory and downsampling the + data when writing out to external memory after rendering has + finished. Since per-sample data is never written out to external + memory, this approach saves bandwidth and storage space. In this + case multisample data gets discarded, however this is acceptable + in most cases. + + The extension provides a new command, FramebufferTexture2DMultisampleIMG, + which attaches a texture level to a framebuffer and enables + multisampled rendering to that texture level. + + When the texture level is used as a source or destination for any + operation other than drawing to it, an implicit resolve of + multisampled color data is performed. After such a resolve, the + multisampled color data is discarded. + + In order to allow the use of multisampled depth and stencil buffers + when performing multisampled rendering to a texture, the extension + also adds the command RenderbufferStorageMultisampleIMG. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/IMG/multisampled_render_to_texture.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES1 import _types, _glgets +from OpenGL.raw.GLES1.IMG.multisampled_render_to_texture import * +from OpenGL.raw.GLES1.IMG.multisampled_render_to_texture import _EXTENSION_NAME + +def glInitMultisampledRenderToTextureIMG(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/IMG/read_format.py b/venv/lib/python3.12/site-packages/OpenGL/GLES1/IMG/read_format.py new file mode 100644 index 00000000..38286623 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES1/IMG/read_format.py @@ -0,0 +1,45 @@ +'''OpenGL extension IMG.read_format + +This module customises the behaviour of the +OpenGL.raw.GLES1.IMG.read_format to provide a more +Python-friendly API + +Overview (from the spec) + + This extension is intended to supplement the GL_OES_read_format + extension by adding support for more format/type combinations to be used + when calling ReadPixels. ReadPixels currently accepts one fixed + format/type combination (format RGBA and type UNSIGNED_BYTE) for + portability, and an implementation specific format/type combination + queried using the tokens IMPLEMENTATION_COLOR_READ_FORMAT_OES and + IMPLEMENTATION_COLOR_READ_TYPE_OES (GL_OES_read_format extension). This + extension adds the following format/type combinations to those currently + allowed to be returned by GetIntegerV: + + format type + ------ ---- + BGRA_IMG UNSIGNED_BYTE + BGRA_IMG UNSIGNED_SHORT_4_4_4_4_REV_IMG + + E.g. Calling GetIntegerv with a parameter of + IMPLEMENTATION_COLOR_READ_FORMAT_OES can now return BGRA, with the + corresponding call to GetIntegerv using a parameter of + IMPLEMENTATION_COLOR_READ_TYPE_OES returning UNSIGNED_BYTE; + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/IMG/read_format.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES1 import _types, _glgets +from OpenGL.raw.GLES1.IMG.read_format import * +from OpenGL.raw.GLES1.IMG.read_format import _EXTENSION_NAME + +def glInitReadFormatIMG(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/IMG/texture_compression_pvrtc.py b/venv/lib/python3.12/site-packages/OpenGL/GLES1/IMG/texture_compression_pvrtc.py new file mode 100644 index 00000000..15c0ae27 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES1/IMG/texture_compression_pvrtc.py @@ -0,0 +1,36 @@ +'''OpenGL extension IMG.texture_compression_pvrtc + +This module customises the behaviour of the +OpenGL.raw.GLES1.IMG.texture_compression_pvrtc to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides additional texture compression functionality + specific to Imagination Technologies PowerVR Texture compression format + (called PVRTC) subject to all the requirements and limitations described + by the OpenGL 1.3 specifications. + + This extension supports 4 and 2 bit per pixel texture compression + formats. Because the compression of PVRTC is very CPU intensive, + it is not appropriate to carry out compression on the target + platform. Therefore this extension only supports the loading of + compressed texture data. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/IMG/texture_compression_pvrtc.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES1 import _types, _glgets +from OpenGL.raw.GLES1.IMG.texture_compression_pvrtc import * +from OpenGL.raw.GLES1.IMG.texture_compression_pvrtc import _EXTENSION_NAME + +def glInitTextureCompressionPvrtcIMG(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/IMG/texture_env_enhanced_fixed_function.py b/venv/lib/python3.12/site-packages/OpenGL/GLES1/IMG/texture_env_enhanced_fixed_function.py new file mode 100644 index 00000000..28f8705d --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES1/IMG/texture_env_enhanced_fixed_function.py @@ -0,0 +1,33 @@ +'''OpenGL extension IMG.texture_env_enhanced_fixed_function + +This module customises the behaviour of the +OpenGL.raw.GLES1.IMG.texture_env_enhanced_fixed_function to provide a more +Python-friendly API + +Overview (from the spec) + + This extension adds new texture environment functions to allow use of + of blend modes supported in some early MBX-lite devices, including dot3 functionality. + It is superceded by OpenGL-ES 1.1 which includes tex_env_combine. + + New functions may be specified by calling TexEnv with the following tokens: + MODULATE_COLOR_IMG, RECIP_ADD_SIGNED_ALPHA_IMG, TEXTURE_ALPHA_MODULATE_IMG, + FACTOR_ALPHA_MODULATE_IMG, FRAGMENT_ALPHA_MODULATE_IMG, ADD_BLEND_IMG, DOT3_RGBA. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/IMG/texture_env_enhanced_fixed_function.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES1 import _types, _glgets +from OpenGL.raw.GLES1.IMG.texture_env_enhanced_fixed_function import * +from OpenGL.raw.GLES1.IMG.texture_env_enhanced_fixed_function import _EXTENSION_NAME + +def glInitTextureEnvEnhancedFixedFunctionIMG(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/IMG/user_clip_plane.py b/venv/lib/python3.12/site-packages/OpenGL/GLES1/IMG/user_clip_plane.py new file mode 100644 index 00000000..f3d7dffb --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES1/IMG/user_clip_plane.py @@ -0,0 +1,33 @@ +'''OpenGL extension IMG.user_clip_plane + +This module customises the behaviour of the +OpenGL.raw.GLES1.IMG.user_clip_plane to provide a more +Python-friendly API + +Overview (from the spec) + + The OpenGL ES 1.0 Specification does not support user clip planes. This extension + adds the support for clip planes. This extension was superceded by OpenGL ES 1.1 + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/IMG/user_clip_plane.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES1 import _types, _glgets +from OpenGL.raw.GLES1.IMG.user_clip_plane import * +from OpenGL.raw.GLES1.IMG.user_clip_plane import _EXTENSION_NAME + +def glInitUserClipPlaneIMG(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +glClipPlanefIMG=wrapper.wrapper(glClipPlanefIMG).setInputArraySize( + 'eqn', 4 +) +glClipPlanexIMG=wrapper.wrapper(glClipPlanexIMG).setInputArraySize( + 'eqn', 4 +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/KHR/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/GLES1/KHR/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES1/KHR/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/KHR/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES1/KHR/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..5884809c Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES1/KHR/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/KHR/__pycache__/debug.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES1/KHR/__pycache__/debug.cpython-312.pyc new file mode 100644 index 00000000..7d88225e Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES1/KHR/__pycache__/debug.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/KHR/debug.py b/venv/lib/python3.12/site-packages/OpenGL/GLES1/KHR/debug.py new file mode 100644 index 00000000..9f3a60b6 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES1/KHR/debug.py @@ -0,0 +1,206 @@ +'''OpenGL extension KHR.debug + +This module customises the behaviour of the +OpenGL.raw.GLES1.KHR.debug to provide a more +Python-friendly API + +Overview (from the spec) + + This extension allows the GL to notify applications when various events + occur that may be useful during application development, debugging and + profiling. + + These events are represented in the form of enumerable messages with a + human-readable string representation. Examples of debug events include + incorrect use of the GL, warnings of undefined behavior, and performance + warnings. + + A message is uniquely identified by a source, a type and an + implementation-dependent ID within the source and type pair. + + A message's source identifies the origin of the message and can either + describe components of the GL, the window system, third-party external + sources such as external debuggers, or even the application itself. + + The type of the message roughly identifies the nature of the event that + caused the message. Examples include errors, performance warnings, + warnings about undefined behavior or notifications identifying that the + application is within a specific section of the application code. + + A message's ID for a given source and type further distinguishes messages + within namespaces. For example, an error caused by a negative parameter + value or an invalid internal texture format are both errors generated by + the API, but would likely have different message IDs. + + Each message is also assigned to a severity level that denotes roughly how + "important" that message is in comparison to other messages across all + sources and types. For example, notification of a GL error would likely + have a higher severity than a performance warning due to redundant state + changes. + + Furthermore, every message contains an implementation-dependent string + representation that provides a useful description of the event. + + Messages are communicated to the application through an application- + defined callback function that is called by the GL implementation on each + debug message. The motivation for the callback routine is to free + application developers from actively having to query whether a GL error, + or any other debuggable event has happened after each call to a GL + function. With a callback, developers can keep their code free of debug + checks, set breakpoints in the callback function, and only have to react + to messages as they occur. In situations where using a callback is not + possible, a message log is also provided that stores only copies of recent + messages until they are actively queried. + + To control the volume of debug output, messages can be disabled either + individually by ID, or entire sets of messages can be turned off based on + combination of source and type, through the entire application code or + only section of the code encapsulated in debug groups. A debug group may + also be used to annotate the command stream using descriptive texts. + + This extension also defines debug markers, a mechanism for the OpenGL + application to annotate the command stream with markers for discrete + events. + + When profiling or debugging an OpenGL application with a built-in or an + external debugger or profiler, it is difficult to relate the commands + within the command stream to the elements of the scene or parts of the + program code to which they correspond. Debug markers and debug groups help + obviate this by allowing applications to specify this link. For example, a + debug marker can be used to identify the beginning of a frame in the + command stream and a debug group can encapsulate a specific command stream + to identify a rendering pass. Debug groups also allow control of the debug + outputs volume per section of an application code providing an effective + way to handle the massive amount of debug outputs that drivers can + generate. + + Some existing implementations of ARB_debug_output only expose the + ARB_debug_output extension string if the context was created with the + debug flag {GLX|WGL}_CONTEXT_DEBUG_BIT_ARB as specified in + {GLX|WGL}_ARB_create_context. The behavior is not obvious when the + functionality is brought into the OpenGL core specification because the + extension string and function entry points must always exist. + + This extension modifies the existing ARB_debug_output extension to allow + implementations to always have an empty message log. The specific messages + written to the message log or callback routines are already implementation + defined, so this specification simply makes it explicit that it's fine for + there to be zero messages generated, even when a GL error occurs, which is + useful if the context is non-debug. + + Debug output can be enabled and disabled by changing the DEBUG_OUTPUT + state. It is implementation defined how much debug output is generated if + the context was created without the CONTEXT_DEBUG_BIT set. This is a new + query bit added to the existing GL_CONTEXT_FLAGS state to specify whether + the context was created with debug enabled. + + Finally, this extension defines a mechanism for OpenGL applications to + label their objects (textures, buffers, shaders, etc.) with a descriptive + string. + + When profiling or debugging an OpenGL application within an external or + built-in (debut output API) debugger or profiler it is difficult to + identify objects from their object names (integers). + + Even when the object itself is viewed it can be problematic to + differentiate between similar objects. Attaching a descriptive string, a + label, to an object obviates this difficulty. + + The intended purpose of this extension is purely to improve the user + experience within OpenGL development tools and application built-in + profilers and debuggers. This extension typically improves OpenGL + programmers efficiency by allowing them to instantly detect issues and the + reason for these issues giving him more time to focus on adding new + features to an OpenGL application. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/KHR/debug.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES1 import _types, _glgets +from OpenGL.raw.GLES1.KHR.debug import * +from OpenGL.raw.GLES1.KHR.debug import _EXTENSION_NAME + +def glInitDebugKHR(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glDebugMessageControl.ids size not checked against count +glDebugMessageControl=wrapper.wrapper(glDebugMessageControl).setInputArraySize( + 'ids', None +) +# INPUT glDebugMessageInsert.buf size not checked against 'buf,length' +glDebugMessageInsert=wrapper.wrapper(glDebugMessageInsert).setInputArraySize( + 'buf', None +) +glGetDebugMessageLog=wrapper.wrapper(glGetDebugMessageLog).setOutput( + 'ids',size=lambda x:(x,),pnameArg='count',orPassIn=True +).setOutput( + 'lengths',size=lambda x:(x,),pnameArg='count',orPassIn=True +).setOutput( + 'messageLog',size=lambda x:(x,),pnameArg='bufSize',orPassIn=True +).setOutput( + 'severities',size=lambda x:(x,),pnameArg='count',orPassIn=True +).setOutput( + 'sources',size=lambda x:(x,),pnameArg='count',orPassIn=True +).setOutput( + 'types',size=lambda x:(x,),pnameArg='count',orPassIn=True +) +# INPUT glPushDebugGroup.message size not checked against 'message,length' +glPushDebugGroup=wrapper.wrapper(glPushDebugGroup).setInputArraySize( + 'message', None +) +# INPUT glObjectLabel.label size not checked against 'label,length' +glObjectLabel=wrapper.wrapper(glObjectLabel).setInputArraySize( + 'label', None +) +glGetObjectLabel=wrapper.wrapper(glGetObjectLabel).setOutput( + 'label',size=lambda x:(x,),pnameArg='bufSize',orPassIn=True +).setOutput( + 'length',size=(1,),orPassIn=True +) +# INPUT glObjectPtrLabel.label size not checked against 'label,length' +glObjectPtrLabel=wrapper.wrapper(glObjectPtrLabel).setInputArraySize( + 'label', None +) +glGetObjectPtrLabel=wrapper.wrapper(glGetObjectPtrLabel).setOutput( + 'label',size=lambda x:(x,),pnameArg='bufSize',orPassIn=True +).setOutput( + 'length',size=(1,),orPassIn=True +) +glGetPointerv=wrapper.wrapper(glGetPointerv).setOutput( + 'params',size=(1,),orPassIn=True +) +# INPUT glGetDebugMessageLogKHR.ids size not checked against count +# INPUT glGetDebugMessageLogKHR.lengths size not checked against count +# INPUT glGetDebugMessageLogKHR.messageLog size not checked against bufSize +# INPUT glGetDebugMessageLogKHR.severities size not checked against count +# INPUT glGetDebugMessageLogKHR.sources size not checked against count +# INPUT glGetDebugMessageLogKHR.types size not checked against count +glGetDebugMessageLogKHR=wrapper.wrapper(glGetDebugMessageLogKHR).setInputArraySize( + 'ids', None +).setInputArraySize( + 'lengths', None +).setInputArraySize( + 'messageLog', None +).setInputArraySize( + 'severities', None +).setInputArraySize( + 'sources', None +).setInputArraySize( + 'types', None +) +# INPUT glGetObjectLabelKHR.label size not checked against bufSize +glGetObjectLabelKHR=wrapper.wrapper(glGetObjectLabelKHR).setInputArraySize( + 'label', None +) +# INPUT glGetObjectPtrLabelKHR.label size not checked against bufSize +glGetObjectPtrLabelKHR=wrapper.wrapper(glGetObjectPtrLabelKHR).setInputArraySize( + 'label', None +).setInputArraySize( + 'length', 1 +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/NV/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/GLES1/NV/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES1/NV/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/NV/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES1/NV/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..8c84a7ee Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES1/NV/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/NV/__pycache__/fence.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES1/NV/__pycache__/fence.cpython-312.pyc new file mode 100644 index 00000000..ec852d9d Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES1/NV/__pycache__/fence.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/NV/fence.py b/venv/lib/python3.12/site-packages/OpenGL/GLES1/NV/fence.py new file mode 100644 index 00000000..4fa61105 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES1/NV/fence.py @@ -0,0 +1,62 @@ +'''OpenGL extension NV.fence + +This module customises the behaviour of the +OpenGL.raw.GLES1.NV.fence to provide a more +Python-friendly API + +Overview (from the spec) + + The goal of this extension is provide a finer granularity of + synchronizing GL command completion than offered by standard OpenGL, + which offers only two mechanisms for synchronization: Flush and Finish. + Since Flush merely assures the user that the commands complete in a + finite (though undetermined) amount of time, it is, thus, of only + modest utility. Finish, on the other hand, stalls CPU execution + until all pending GL commands have completed. This extension offers + a middle ground - the ability to "finish" a subset of the command + stream, and the ability to determine whether a given command has + completed or not. + + This extension introduces the concept of a "fence" to the OpenGL + command stream. Once the fence is inserted into the command stream, it + can be queried for a given condition - typically, its completion. + Moreover, the application may also request a partial Finish -- that is, + all commands prior to the fence will be forced to complete until control + is returned to the calling process. These new mechanisms allow for + synchronization between the host CPU and the GPU, which may be accessing + the same resources (typically memory). + + This extension is useful in conjunction with NV_vertex_array_range + to determine when vertex information has been pulled from the + vertex array range. Once a fence has been tested TRUE or finished, + all vertex indices issued before the fence must have been pulled. + This ensures that the vertex data memory corresponding to the issued + vertex indices can be safely modified (assuming no other outstanding + vertex indices are issued subsequent to the fence). + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/fence.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES1 import _types, _glgets +from OpenGL.raw.GLES1.NV.fence import * +from OpenGL.raw.GLES1.NV.fence import _EXTENSION_NAME + +def glInitFenceNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glDeleteFencesNV.fences size not checked against n +glDeleteFencesNV=wrapper.wrapper(glDeleteFencesNV).setInputArraySize( + 'fences', None +) +glGenFencesNV=wrapper.wrapper(glGenFencesNV).setOutput( + 'fences',size=lambda x:(x,),pnameArg='n',orPassIn=True +) +glGetFenceivNV=wrapper.wrapper(glGetFenceivNV).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/EGL_image.py b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/EGL_image.py new file mode 100644 index 00000000..8bdbd189 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/EGL_image.py @@ -0,0 +1,43 @@ +'''OpenGL extension OES.EGL_image + +This module customises the behaviour of the +OpenGL.raw.GLES1.OES.EGL_image to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides a mechanism for creating texture and + renderbuffer objects sharing storage with specified EGLImage objects + (such objects are referred to as "EGLImage targets"). + + The companion EGL_KHR_image_base and EGL_KHR_image extensions + provide the definition and rationale for EGLImage objects. + + Other EGL extensions, such as EGL_KHR_gl_texture_2D_image, + EGL_KHR_gl_texture_cubemap_image, EGL_KHR_gl_texture_3D_image, + EGL_KHR_gl_renderbuffer_image, and EGL_KHR_vg_parent_image, define + the related functionality of creating EGLImage objects from + "EGLImage sources" such as OpenGL ES texture or renderbuffers or + OpenVG VGImage objects. + + EGL extension specifications are located in the EGL Registry at + + http://www.khronos.org/registry/egl/ + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/OES/EGL_image.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES1 import _types, _glgets +from OpenGL.raw.GLES1.OES.EGL_image import * +from OpenGL.raw.GLES1.OES.EGL_image import _EXTENSION_NAME + +def glInitEglImageOES(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/EGL_image_external.py b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/EGL_image_external.py new file mode 100644 index 00000000..9bffb18e --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/EGL_image_external.py @@ -0,0 +1,37 @@ +'''OpenGL extension OES.EGL_image_external + +This module customises the behaviour of the +OpenGL.raw.GLES1.OES.EGL_image_external to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides a mechanism for creating EGLImage texture targets + from EGLImages. This extension defines a new texture target, + TEXTURE_EXTERNAL_OES. This texture target can only be specified using an + EGLImage. There is no support for most of the functions that manipulate + other texture targets (e.g. you cannot use gl*Tex*Image*() functions with + TEXTURE_EXTERNAL_OES). Also, TEXTURE_EXTERNAL_OES targets never have more + than a single LOD level. Because of these restrictions, it is possible to + bind EGLImages which have internal formats not otherwise supported by + OpenGL ES. For example some implementations may allow EGLImages with + planar or interleaved YUV data to be GLES texture target siblings. It is + up to the implementation exactly what formats are accepted. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/OES/EGL_image_external.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES1 import _types, _glgets +from OpenGL.raw.GLES1.OES.EGL_image_external import * +from OpenGL.raw.GLES1.OES.EGL_image_external import _EXTENSION_NAME + +def glInitEglImageExternalOES(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/__pycache__/EGL_image.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/__pycache__/EGL_image.cpython-312.pyc new file mode 100644 index 00000000..bc6eb16f Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/__pycache__/EGL_image.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/__pycache__/EGL_image_external.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/__pycache__/EGL_image_external.cpython-312.pyc new file mode 100644 index 00000000..a0c4c156 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/__pycache__/EGL_image_external.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..128327f8 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/__pycache__/blend_equation_separate.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/__pycache__/blend_equation_separate.cpython-312.pyc new file mode 100644 index 00000000..5fd8eabe Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/__pycache__/blend_equation_separate.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/__pycache__/blend_func_separate.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/__pycache__/blend_func_separate.cpython-312.pyc new file mode 100644 index 00000000..4b35e216 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/__pycache__/blend_func_separate.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/__pycache__/blend_subtract.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/__pycache__/blend_subtract.cpython-312.pyc new file mode 100644 index 00000000..917ec5f2 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/__pycache__/blend_subtract.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/__pycache__/byte_coordinates.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/__pycache__/byte_coordinates.cpython-312.pyc new file mode 100644 index 00000000..657d5946 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/__pycache__/byte_coordinates.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/__pycache__/compressed_ETC1_RGB8_sub_texture.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/__pycache__/compressed_ETC1_RGB8_sub_texture.cpython-312.pyc new file mode 100644 index 00000000..014607ef Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/__pycache__/compressed_ETC1_RGB8_sub_texture.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/__pycache__/compressed_ETC1_RGB8_texture.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/__pycache__/compressed_ETC1_RGB8_texture.cpython-312.pyc new file mode 100644 index 00000000..1b8d1b6e Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/__pycache__/compressed_ETC1_RGB8_texture.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/__pycache__/compressed_paletted_texture.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/__pycache__/compressed_paletted_texture.cpython-312.pyc new file mode 100644 index 00000000..134edf3c Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/__pycache__/compressed_paletted_texture.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/__pycache__/depth24.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/__pycache__/depth24.cpython-312.pyc new file mode 100644 index 00000000..c44a224d Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/__pycache__/depth24.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/__pycache__/depth32.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/__pycache__/depth32.cpython-312.pyc new file mode 100644 index 00000000..624ca634 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/__pycache__/depth32.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/__pycache__/draw_texture.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/__pycache__/draw_texture.cpython-312.pyc new file mode 100644 index 00000000..7943deea Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/__pycache__/draw_texture.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/__pycache__/element_index_uint.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/__pycache__/element_index_uint.cpython-312.pyc new file mode 100644 index 00000000..4991773a Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/__pycache__/element_index_uint.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/__pycache__/extended_matrix_palette.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/__pycache__/extended_matrix_palette.cpython-312.pyc new file mode 100644 index 00000000..d0bdc5aa Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/__pycache__/extended_matrix_palette.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/__pycache__/fbo_render_mipmap.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/__pycache__/fbo_render_mipmap.cpython-312.pyc new file mode 100644 index 00000000..ae10e5f8 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/__pycache__/fbo_render_mipmap.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/__pycache__/fixed_point.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/__pycache__/fixed_point.cpython-312.pyc new file mode 100644 index 00000000..59d887ab Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/__pycache__/fixed_point.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/__pycache__/framebuffer_object.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/__pycache__/framebuffer_object.cpython-312.pyc new file mode 100644 index 00000000..d34aef80 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/__pycache__/framebuffer_object.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/__pycache__/mapbuffer.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/__pycache__/mapbuffer.cpython-312.pyc new file mode 100644 index 00000000..7ed271b1 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/__pycache__/mapbuffer.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/__pycache__/matrix_get.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/__pycache__/matrix_get.cpython-312.pyc new file mode 100644 index 00000000..36e2dec2 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/__pycache__/matrix_get.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/__pycache__/matrix_palette.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/__pycache__/matrix_palette.cpython-312.pyc new file mode 100644 index 00000000..70162959 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/__pycache__/matrix_palette.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/__pycache__/packed_depth_stencil.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/__pycache__/packed_depth_stencil.cpython-312.pyc new file mode 100644 index 00000000..8943f29d Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/__pycache__/packed_depth_stencil.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/__pycache__/point_size_array.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/__pycache__/point_size_array.cpython-312.pyc new file mode 100644 index 00000000..f4a4e578 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/__pycache__/point_size_array.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/__pycache__/point_sprite.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/__pycache__/point_sprite.cpython-312.pyc new file mode 100644 index 00000000..0045e98f Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/__pycache__/point_sprite.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/__pycache__/query_matrix.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/__pycache__/query_matrix.cpython-312.pyc new file mode 100644 index 00000000..96673aff Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/__pycache__/query_matrix.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/__pycache__/read_format.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/__pycache__/read_format.cpython-312.pyc new file mode 100644 index 00000000..8db058b0 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/__pycache__/read_format.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/__pycache__/required_internalformat.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/__pycache__/required_internalformat.cpython-312.pyc new file mode 100644 index 00000000..4a8c5f0b Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/__pycache__/required_internalformat.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/__pycache__/rgb8_rgba8.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/__pycache__/rgb8_rgba8.cpython-312.pyc new file mode 100644 index 00000000..8cac4683 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/__pycache__/rgb8_rgba8.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/__pycache__/single_precision.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/__pycache__/single_precision.cpython-312.pyc new file mode 100644 index 00000000..cdd79b42 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/__pycache__/single_precision.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/__pycache__/stencil1.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/__pycache__/stencil1.cpython-312.pyc new file mode 100644 index 00000000..74c098bc Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/__pycache__/stencil1.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/__pycache__/stencil4.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/__pycache__/stencil4.cpython-312.pyc new file mode 100644 index 00000000..6eaa72eb Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/__pycache__/stencil4.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/__pycache__/stencil8.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/__pycache__/stencil8.cpython-312.pyc new file mode 100644 index 00000000..54c3bb78 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/__pycache__/stencil8.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/__pycache__/stencil_wrap.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/__pycache__/stencil_wrap.cpython-312.pyc new file mode 100644 index 00000000..03d06025 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/__pycache__/stencil_wrap.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/__pycache__/surfaceless_context.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/__pycache__/surfaceless_context.cpython-312.pyc new file mode 100644 index 00000000..cfc679cf Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/__pycache__/surfaceless_context.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/__pycache__/texture_cube_map.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/__pycache__/texture_cube_map.cpython-312.pyc new file mode 100644 index 00000000..5eb551d2 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/__pycache__/texture_cube_map.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/__pycache__/texture_env_crossbar.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/__pycache__/texture_env_crossbar.cpython-312.pyc new file mode 100644 index 00000000..0493746b Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/__pycache__/texture_env_crossbar.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/__pycache__/texture_mirrored_repeat.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/__pycache__/texture_mirrored_repeat.cpython-312.pyc new file mode 100644 index 00000000..5a1ced9a Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/__pycache__/texture_mirrored_repeat.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/__pycache__/texture_npot.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/__pycache__/texture_npot.cpython-312.pyc new file mode 100644 index 00000000..2fff411b Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/__pycache__/texture_npot.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/__pycache__/vertex_array_object.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/__pycache__/vertex_array_object.cpython-312.pyc new file mode 100644 index 00000000..8a39a871 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/__pycache__/vertex_array_object.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/blend_equation_separate.py b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/blend_equation_separate.py new file mode 100644 index 00000000..8900f91a --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/blend_equation_separate.py @@ -0,0 +1,30 @@ +'''OpenGL extension OES.blend_equation_separate + +This module customises the behaviour of the +OpenGL.raw.GLES1.OES.blend_equation_separate to provide a more +Python-friendly API + +Overview (from the spec) + + OpenGL ES 1.1 provides a single blend equation that applies to both RGB + and alpha portions of blending. This extension provides a separate blend + equation for RGB and alpha to match the generality available for blend + factors. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/OES/blend_equation_separate.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES1 import _types, _glgets +from OpenGL.raw.GLES1.OES.blend_equation_separate import * +from OpenGL.raw.GLES1.OES.blend_equation_separate import _EXTENSION_NAME + +def glInitBlendEquationSeparateOES(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/blend_func_separate.py b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/blend_func_separate.py new file mode 100644 index 00000000..30b2fa88 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/blend_func_separate.py @@ -0,0 +1,31 @@ +'''OpenGL extension OES.blend_func_separate + +This module customises the behaviour of the +OpenGL.raw.GLES1.OES.blend_func_separate to provide a more +Python-friendly API + +Overview (from the spec) + + Blending capability is extended by defining a function that allows + independent setting of the RGB and alpha blend factors for blend + operations that require source and destination blend factors. It + is not always desired that the blending used for RGB is also applied + to alpha. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/OES/blend_func_separate.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES1 import _types, _glgets +from OpenGL.raw.GLES1.OES.blend_func_separate import * +from OpenGL.raw.GLES1.OES.blend_func_separate import _EXTENSION_NAME + +def glInitBlendFuncSeparateOES(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/blend_subtract.py b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/blend_subtract.py new file mode 100644 index 00000000..c3c35166 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/blend_subtract.py @@ -0,0 +1,36 @@ +'''OpenGL extension OES.blend_subtract + +This module customises the behaviour of the +OpenGL.raw.GLES1.OES.blend_subtract to provide a more +Python-friendly API + +Overview (from the spec) + + Blending capability is extended by respecifying the entire blend + equation. While this document defines only two new equations, the + BlendEquationOES procedure that it defines will be used by subsequent + extensions to define additional blending equations. + + In addition to the default blending equation, two new blending equations + are specified. These equations are similar to the default blending + equation, but produce the difference of its left and right hand sides, + rather than the sum. Image differences are useful in many image + processing applications. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/OES/blend_subtract.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES1 import _types, _glgets +from OpenGL.raw.GLES1.OES.blend_subtract import * +from OpenGL.raw.GLES1.OES.blend_subtract import _EXTENSION_NAME + +def glInitBlendSubtractOES(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/byte_coordinates.py b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/byte_coordinates.py new file mode 100644 index 00000000..d3c9adb2 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/byte_coordinates.py @@ -0,0 +1,63 @@ +'''OpenGL extension OES.byte_coordinates + +This module customises the behaviour of the +OpenGL.raw.GLES1.OES.byte_coordinates to provide a more +Python-friendly API + +Overview (from the spec) + + This extension allows specifying, additionally to all existing + values, byte-valued vertex and texture coordinates to be used. + + The main reason for introducing the byte-argument is to allow + storing data more compactly on memory-restricted environments. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/OES/byte_coordinates.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES1 import _types, _glgets +from OpenGL.raw.GLES1.OES.byte_coordinates import * +from OpenGL.raw.GLES1.OES.byte_coordinates import _EXTENSION_NAME + +def glInitByteCoordinatesOES(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +glMultiTexCoord1bvOES=wrapper.wrapper(glMultiTexCoord1bvOES).setInputArraySize( + 'coords', 1 +) +glMultiTexCoord2bvOES=wrapper.wrapper(glMultiTexCoord2bvOES).setInputArraySize( + 'coords', 2 +) +glMultiTexCoord3bvOES=wrapper.wrapper(glMultiTexCoord3bvOES).setInputArraySize( + 'coords', 3 +) +glMultiTexCoord4bvOES=wrapper.wrapper(glMultiTexCoord4bvOES).setInputArraySize( + 'coords', 4 +) +glTexCoord1bvOES=wrapper.wrapper(glTexCoord1bvOES).setInputArraySize( + 'coords', 1 +) +glTexCoord2bvOES=wrapper.wrapper(glTexCoord2bvOES).setInputArraySize( + 'coords', 2 +) +glTexCoord3bvOES=wrapper.wrapper(glTexCoord3bvOES).setInputArraySize( + 'coords', 3 +) +glTexCoord4bvOES=wrapper.wrapper(glTexCoord4bvOES).setInputArraySize( + 'coords', 4 +) +glVertex2bvOES=wrapper.wrapper(glVertex2bvOES).setInputArraySize( + 'coords', 2 +) +glVertex3bvOES=wrapper.wrapper(glVertex3bvOES).setInputArraySize( + 'coords', 3 +) +glVertex4bvOES=wrapper.wrapper(glVertex4bvOES).setInputArraySize( + 'coords', 4 +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/compressed_ETC1_RGB8_sub_texture.py b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/compressed_ETC1_RGB8_sub_texture.py new file mode 100644 index 00000000..b354e76e --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/compressed_ETC1_RGB8_sub_texture.py @@ -0,0 +1,23 @@ +'''OpenGL extension OES.compressed_ETC1_RGB8_sub_texture + +This module customises the behaviour of the +OpenGL.raw.GLES1.OES.compressed_ETC1_RGB8_sub_texture to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/OES/compressed_ETC1_RGB8_sub_texture.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES1 import _types, _glgets +from OpenGL.raw.GLES1.OES.compressed_ETC1_RGB8_sub_texture import * +from OpenGL.raw.GLES1.OES.compressed_ETC1_RGB8_sub_texture import _EXTENSION_NAME + +def glInitCompressedEtc1Rgb8SubTextureOES(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/compressed_ETC1_RGB8_texture.py b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/compressed_ETC1_RGB8_texture.py new file mode 100644 index 00000000..aae097ab --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/compressed_ETC1_RGB8_texture.py @@ -0,0 +1,37 @@ +'''OpenGL extension OES.compressed_ETC1_RGB8_texture + +This module customises the behaviour of the +OpenGL.raw.GLES1.OES.compressed_ETC1_RGB8_texture to provide a more +Python-friendly API + +Overview (from the spec) + + The goal of this extension is to allow direct support of + compressed textures in the Ericsson Texture Compression (ETC) + formats in OpenGL ES. + + ETC-compressed textures are handled in OpenGL ES using the + CompressedTexImage2D call. + + The definition of the "internalformat" parameter in the + CompressedTexImage2D call has been extended to support + ETC-compressed textures. + + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/OES/compressed_ETC1_RGB8_texture.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES1 import _types, _glgets +from OpenGL.raw.GLES1.OES.compressed_ETC1_RGB8_texture import * +from OpenGL.raw.GLES1.OES.compressed_ETC1_RGB8_texture import _EXTENSION_NAME + +def glInitCompressedEtc1Rgb8TextureOES(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/compressed_paletted_texture.py b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/compressed_paletted_texture.py new file mode 100644 index 00000000..607821c0 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/compressed_paletted_texture.py @@ -0,0 +1,60 @@ +'''OpenGL extension OES.compressed_paletted_texture + +This module customises the behaviour of the +OpenGL.raw.GLES1.OES.compressed_paletted_texture to provide a more +Python-friendly API + +Overview (from the spec) + + The goal of this extension is to allow direct support of palettized + textures in OpenGL ES. + + Palettized textures are implemented in OpenGL ES using the + CompressedTexImage2D call. The definition of the following parameters + "level" and "internalformat" in the CompressedTexImage2D call have + been extended to support paletted textures. + + A paletted texture is described by the following data: + + palette format + can be R5_G6_B5, RGBA4, RGB5_A1, RGB8, or RGBA8 + + number of bits to represent texture data + can be 4 bits or 8 bits per texel. The number of bits + also detemine the size of the palette. For 4 bits/texel + the palette size is 16 entries and for 8 bits/texel the + palette size will be 256 entries. + + The palette format and bits/texel are encoded in the + "internalformat" parameter. + + palette data and texture mip-levels + The palette data followed by all necessary mip levels are + passed in "data" parameter of CompressedTexImage2D. + + The size of palette is given by palette format and bits / texel. + A palette format of RGB_565 with 4 bits/texel imply a palette + size of 2 bytes/palette entry * 16 entries = 32 bytes. + + The level value is used to indicate how many mip levels + are described. Negative level values are used to define + the number of miplevels described in the "data" component. + A level of zero indicates a single mip-level. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/OES/compressed_paletted_texture.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES1 import _types, _glgets +from OpenGL.raw.GLES1.OES.compressed_paletted_texture import * +from OpenGL.raw.GLES1.OES.compressed_paletted_texture import _EXTENSION_NAME + +def glInitCompressedPalettedTextureOES(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/depth24.py b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/depth24.py new file mode 100644 index 00000000..ebea98b8 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/depth24.py @@ -0,0 +1,28 @@ +'''OpenGL extension OES.depth24 + +This module customises the behaviour of the +OpenGL.raw.GLES1.OES.depth24 to provide a more +Python-friendly API + +Overview (from the spec) + + This extension enables 24-bit depth components as a valid + render buffer storage format. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/OES/depth24.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES1 import _types, _glgets +from OpenGL.raw.GLES1.OES.depth24 import * +from OpenGL.raw.GLES1.OES.depth24 import _EXTENSION_NAME + +def glInitDepth24OES(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/depth32.py b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/depth32.py new file mode 100644 index 00000000..298774b9 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/depth32.py @@ -0,0 +1,28 @@ +'''OpenGL extension OES.depth32 + +This module customises the behaviour of the +OpenGL.raw.GLES1.OES.depth32 to provide a more +Python-friendly API + +Overview (from the spec) + + This extension enables 32-bit depth components as a valid + render buffer storage format. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/OES/depth32.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES1 import _types, _glgets +from OpenGL.raw.GLES1.OES.depth32 import * +from OpenGL.raw.GLES1.OES.depth32 import _EXTENSION_NAME + +def glInitDepth32OES(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/draw_texture.py b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/draw_texture.py new file mode 100644 index 00000000..26872c45 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/draw_texture.py @@ -0,0 +1,60 @@ +'''OpenGL extension OES.draw_texture + +This module customises the behaviour of the +OpenGL.raw.GLES1.OES.draw_texture to provide a more +Python-friendly API + +Overview (from the spec) + + This extension defines a mechanism for writing pixel + rectangles from one or more textures to a rectangular + region of the screen. This capability is useful for + fast rendering of background paintings, bitmapped font + glyphs, and 2D framing elements in games. This + extension is primarily intended for use with OpenGL ES. + + The extension relies on a new piece of texture state + called the texture crop rectangle, which defines a + rectangular subregion of a texture object. These + subregions are used as sources of pixels for the texture + drawing function. + + Applications use this extension by configuring the + texture crop rectangle for one or more textures via + ActiveTexture() and TexParameteriv() with pname equal to + TEXTURE_CROP_RECT_OES. They then request a drawing + operation using DrawTex{sifx}[v]OES(). The effect of + the latter function is to generate a screen-aligned + target rectangle, with texture coordinates chosen to map + the texture crop rectangle(s) linearly to fragments in + the target rectangle. The fragments are then processed + in accordance with the fragment pipeline state. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/OES/draw_texture.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES1 import _types, _glgets +from OpenGL.raw.GLES1.OES.draw_texture import * +from OpenGL.raw.GLES1.OES.draw_texture import _EXTENSION_NAME + +def glInitDrawTextureOES(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +glDrawTexsvOES=wrapper.wrapper(glDrawTexsvOES).setInputArraySize( + 'coords', 5 +) +glDrawTexivOES=wrapper.wrapper(glDrawTexivOES).setInputArraySize( + 'coords', 5 +) +glDrawTexxvOES=wrapper.wrapper(glDrawTexxvOES).setInputArraySize( + 'coords', 5 +) +glDrawTexfvOES=wrapper.wrapper(glDrawTexfvOES).setInputArraySize( + 'coords', 5 +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/element_index_uint.py b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/element_index_uint.py new file mode 100644 index 00000000..4386ab4b --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/element_index_uint.py @@ -0,0 +1,29 @@ +'''OpenGL extension OES.element_index_uint + +This module customises the behaviour of the +OpenGL.raw.GLES1.OES.element_index_uint to provide a more +Python-friendly API + +Overview (from the spec) + + OpenGL ES 1.0 supports DrawElements with value of + UNSIGNED_BYTE and UNSIGNED_SHORT. This extension adds + support for UNSIGNED_INT values. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/OES/element_index_uint.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES1 import _types, _glgets +from OpenGL.raw.GLES1.OES.element_index_uint import * +from OpenGL.raw.GLES1.OES.element_index_uint import _EXTENSION_NAME + +def glInitElementIndexUintOES(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/extended_matrix_palette.py b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/extended_matrix_palette.py new file mode 100644 index 00000000..0e0a31dc --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/extended_matrix_palette.py @@ -0,0 +1,52 @@ +'''OpenGL extension OES.extended_matrix_palette + +This module customises the behaviour of the +OpenGL.raw.GLES1.OES.extended_matrix_palette to provide a more +Python-friendly API + +Overview (from the spec) + + The OES_matrix_palette extension added the ability to support vertex skinning + in OpenGL ES. One issue with OES_matrix_palette is that the minimum size of + the matrix palette is very small. This leads to applications having to break + geometry into smaller primitive sets called via. glDrawElements. This has an + impact on the overall performance of the OpenGL ES implementation. In general, + hardware implementations prefer primitive packets with as many triangles as + possible. The default minimum size defined in OES_matrix_palette is not + sufficient to allow this. The OES_extended_matrix_palette extension increases + this minimum from 9 to 32. + + Another issue is that it is very difficult for ISVs to handle different + size matrix palettes as it affects how they store their geometry + in the database - may require multiple representations which is + not really feasible. So the minimum size is going to be what most ISVs + will use. + + By extending the minimum size of the matrix palette, we remove this + fragmentation and allow applications to render geometry with minimal + number of calls to glDrawElements or glDrawArrays. The OpenGL ES + implementation can support this without requiring any additional hardware + by breaking the primitive, plus it gives implementations the flexibility + to accelerate with a bigger matrix palette if they choose to do so. + + Additionally, feedback has also been received to increase the number of + matrices that are blend per vertex from 3 to 4. The OES_extended_matrix_palette + extension increases the minium number of matrices / vertex to 4. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/OES/extended_matrix_palette.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES1 import _types, _glgets +from OpenGL.raw.GLES1.OES.extended_matrix_palette import * +from OpenGL.raw.GLES1.OES.extended_matrix_palette import _EXTENSION_NAME + +def glInitExtendedMatrixPaletteOES(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/fbo_render_mipmap.py b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/fbo_render_mipmap.py new file mode 100644 index 00000000..ac0cf7f7 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/fbo_render_mipmap.py @@ -0,0 +1,34 @@ +'''OpenGL extension OES.fbo_render_mipmap + +This module customises the behaviour of the +OpenGL.raw.GLES1.OES.fbo_render_mipmap to provide a more +Python-friendly API + +Overview (from the spec) + + OES_framebuffer_object allows rendering to the base level of a + texture only. This extension removes this limitation by + allowing implementations to support rendering to any mip-level + of a texture(s) that is attached to a framebuffer object(s). + + If this extension is supported, FramebufferTexture2DOES, and + FramebufferTexture3DOES can be used to render directly into + any mip level of a texture image + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/OES/fbo_render_mipmap.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES1 import _types, _glgets +from OpenGL.raw.GLES1.OES.fbo_render_mipmap import * +from OpenGL.raw.GLES1.OES.fbo_render_mipmap import _EXTENSION_NAME + +def glInitFboRenderMipmapOES(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/fixed_point.py b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/fixed_point.py new file mode 100644 index 00000000..2caa2a5c --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/fixed_point.py @@ -0,0 +1,215 @@ +'''OpenGL extension OES.fixed_point + +This module customises the behaviour of the +OpenGL.raw.GLES1.OES.fixed_point to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides the capability, for platforms that do + not have efficient floating-point support, to input data in a + fixed-point format, i.e., a scaled-integer format. There are + several ways a platform could try to solve the problem, such as + using integer only commands, but there are many OpenGL commands + that have only floating-point or double-precision floating-point + parameters. Also, it is likely that any credible application + running on such a platform will need to perform some computations + and will already be using some form of fixed-point representation. + This extension solves the problem by adding new ``fixed', and + ``clamp fixed'' data types based on a a two's complement + S15.16 representation. New versions of commands are created + with an 'x' suffix that take fixed or clampx parameters. + + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/OES/fixed_point.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES1 import _types, _glgets +from OpenGL.raw.GLES1.OES.fixed_point import * +from OpenGL.raw.GLES1.OES.fixed_point import _EXTENSION_NAME + +def glInitFixedPointOES(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +glClipPlanexOES=wrapper.wrapper(glClipPlanexOES).setInputArraySize( + 'equation', 4 +) +# INPUT glFogxvOES.param size not checked against 'pname' +glFogxvOES=wrapper.wrapper(glFogxvOES).setInputArraySize( + 'param', None +) +glGetClipPlanexOES=wrapper.wrapper(glGetClipPlanexOES).setOutput( + 'equation',size=(4,),orPassIn=True +) +glGetFixedvOES=wrapper.wrapper(glGetFixedvOES).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetTexEnvxvOES=wrapper.wrapper(glGetTexEnvxvOES).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetTexParameterxvOES=wrapper.wrapper(glGetTexParameterxvOES).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +# INPUT glLightModelxvOES.param size not checked against 'pname' +glLightModelxvOES=wrapper.wrapper(glLightModelxvOES).setInputArraySize( + 'param', None +) +# INPUT glLightxvOES.params size not checked against 'pname' +glLightxvOES=wrapper.wrapper(glLightxvOES).setInputArraySize( + 'params', None +) +glLoadMatrixxOES=wrapper.wrapper(glLoadMatrixxOES).setInputArraySize( + 'm', 16 +) +# INPUT glMaterialxvOES.param size not checked against 'pname' +glMaterialxvOES=wrapper.wrapper(glMaterialxvOES).setInputArraySize( + 'param', None +) +glMultMatrixxOES=wrapper.wrapper(glMultMatrixxOES).setInputArraySize( + 'm', 16 +) +# INPUT glPointParameterxvOES.params size not checked against 'pname' +glPointParameterxvOES=wrapper.wrapper(glPointParameterxvOES).setInputArraySize( + 'params', None +) +# INPUT glTexEnvxvOES.params size not checked against 'pname' +glTexEnvxvOES=wrapper.wrapper(glTexEnvxvOES).setInputArraySize( + 'params', None +) +# INPUT glTexParameterxvOES.params size not checked against 'pname' +glTexParameterxvOES=wrapper.wrapper(glTexParameterxvOES).setInputArraySize( + 'params', None +) +# INPUT glGetLightxvOES.params size not checked against 'pname' +glGetLightxvOES=wrapper.wrapper(glGetLightxvOES).setInputArraySize( + 'params', None +) +# INPUT glGetMaterialxvOES.params size not checked against 'pname' +glGetMaterialxvOES=wrapper.wrapper(glGetMaterialxvOES).setInputArraySize( + 'params', None +) +# INPUT glBitmapxOES.bitmap size not checked against 'width,height' +glBitmapxOES=wrapper.wrapper(glBitmapxOES).setInputArraySize( + 'bitmap', None +) +glColor3xvOES=wrapper.wrapper(glColor3xvOES).setInputArraySize( + 'components', 3 +) +glColor4xvOES=wrapper.wrapper(glColor4xvOES).setInputArraySize( + 'components', 4 +) +# INPUT glConvolutionParameterxvOES.params size not checked against 'pname' +glConvolutionParameterxvOES=wrapper.wrapper(glConvolutionParameterxvOES).setInputArraySize( + 'params', None +) +glEvalCoord1xvOES=wrapper.wrapper(glEvalCoord1xvOES).setInputArraySize( + 'coords', 1 +) +glEvalCoord2xvOES=wrapper.wrapper(glEvalCoord2xvOES).setInputArraySize( + 'coords', 2 +) +# INPUT glFeedbackBufferxOES.buffer size not checked against n +glFeedbackBufferxOES=wrapper.wrapper(glFeedbackBufferxOES).setInputArraySize( + 'buffer', None +) +glGetConvolutionParameterxvOES=wrapper.wrapper(glGetConvolutionParameterxvOES).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetHistogramParameterxvOES=wrapper.wrapper(glGetHistogramParameterxvOES).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetLightxOES=wrapper.wrapper(glGetLightxOES).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetMapxvOES=wrapper.wrapper(glGetMapxvOES).setOutput( + 'v',size=_glgets._glget_size_mapping,pnameArg='query',orPassIn=True +) +glGetPixelMapxv=wrapper.wrapper(glGetPixelMapxv).setOutput( + 'values',size=lambda x:(x,),pnameArg='size',orPassIn=True +) +glGetTexGenxvOES=wrapper.wrapper(glGetTexGenxvOES).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetTexLevelParameterxvOES=wrapper.wrapper(glGetTexLevelParameterxvOES).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glIndexxvOES=wrapper.wrapper(glIndexxvOES).setInputArraySize( + 'component', 1 +) +glLoadTransposeMatrixxOES=wrapper.wrapper(glLoadTransposeMatrixxOES).setInputArraySize( + 'm', 16 +) +glMultTransposeMatrixxOES=wrapper.wrapper(glMultTransposeMatrixxOES).setInputArraySize( + 'm', 16 +) +glMultiTexCoord1xvOES=wrapper.wrapper(glMultiTexCoord1xvOES).setInputArraySize( + 'coords', 1 +) +glMultiTexCoord2xvOES=wrapper.wrapper(glMultiTexCoord2xvOES).setInputArraySize( + 'coords', 2 +) +glMultiTexCoord3xvOES=wrapper.wrapper(glMultiTexCoord3xvOES).setInputArraySize( + 'coords', 3 +) +glMultiTexCoord4xvOES=wrapper.wrapper(glMultiTexCoord4xvOES).setInputArraySize( + 'coords', 4 +) +glNormal3xvOES=wrapper.wrapper(glNormal3xvOES).setInputArraySize( + 'coords', 3 +) +# INPUT glPixelMapx.values size not checked against size +glPixelMapx=wrapper.wrapper(glPixelMapx).setInputArraySize( + 'values', None +) +# INPUT glPrioritizeTexturesxOES.priorities size not checked against n +# INPUT glPrioritizeTexturesxOES.textures size not checked against n +glPrioritizeTexturesxOES=wrapper.wrapper(glPrioritizeTexturesxOES).setInputArraySize( + 'priorities', None +).setInputArraySize( + 'textures', None +) +glRasterPos2xvOES=wrapper.wrapper(glRasterPos2xvOES).setInputArraySize( + 'coords', 2 +) +glRasterPos3xvOES=wrapper.wrapper(glRasterPos3xvOES).setInputArraySize( + 'coords', 3 +) +glRasterPos4xvOES=wrapper.wrapper(glRasterPos4xvOES).setInputArraySize( + 'coords', 4 +) +glRectxvOES=wrapper.wrapper(glRectxvOES).setInputArraySize( + 'v1', 2 +).setInputArraySize( + 'v2', 2 +) +glTexCoord1xvOES=wrapper.wrapper(glTexCoord1xvOES).setInputArraySize( + 'coords', 1 +) +glTexCoord2xvOES=wrapper.wrapper(glTexCoord2xvOES).setInputArraySize( + 'coords', 2 +) +glTexCoord3xvOES=wrapper.wrapper(glTexCoord3xvOES).setInputArraySize( + 'coords', 3 +) +glTexCoord4xvOES=wrapper.wrapper(glTexCoord4xvOES).setInputArraySize( + 'coords', 4 +) +# INPUT glTexGenxvOES.params size not checked against 'pname' +glTexGenxvOES=wrapper.wrapper(glTexGenxvOES).setInputArraySize( + 'params', None +) +glVertex2xvOES=wrapper.wrapper(glVertex2xvOES).setInputArraySize( + 'coords', 2 +) +glVertex3xvOES=wrapper.wrapper(glVertex3xvOES).setInputArraySize( + 'coords', 3 +) +glVertex4xvOES=wrapper.wrapper(glVertex4xvOES).setInputArraySize( + 'coords', 4 +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/framebuffer_object.py b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/framebuffer_object.py new file mode 100644 index 00000000..901477ed --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/framebuffer_object.py @@ -0,0 +1,129 @@ +'''OpenGL extension OES.framebuffer_object + +This module customises the behaviour of the +OpenGL.raw.GLES1.OES.framebuffer_object to provide a more +Python-friendly API + +Overview (from the spec) + + This extension defines a simple interface for drawing to rendering + destinations other than the buffers provided to the GL by the + window-system. OES_framebuffer_object is a simplified version + of EXT_framebuffer_object with modifications to match the needs of + OpenGL ES. + + In this extension, these newly defined rendering destinations are + known collectively as "framebuffer-attachable images". This + extension provides a mechanism for attaching framebuffer-attachable + images to the GL framebuffer as one of the standard GL logical + buffers: color, depth, and stencil. When a framebuffer-attachable + image is attached to the framebuffer, it is used as the source and + destination of fragment operations as described in Chapter 4. + + By allowing the use of a framebuffer-attachable image as a rendering + destination, this extension enables a form of "offscreen" rendering. + Furthermore, "render to texture" is supported by allowing the images + of a texture to be used as framebuffer-attachable images. A + particular image of a texture object is selected for use as a + framebuffer-attachable image by specifying the mipmap level, cube + map face (for a cube map texture) that identifies the image. + The "render to texture" semantics of this extension are similar to + performing traditional rendering to the framebuffer, followed + immediately by a call to CopyTexSubImage. However, by using this + extension instead, an application can achieve the same effect, + but with the advantage that the GL can usually eliminate the data copy + that would have been incurred by calling CopyTexSubImage. + + This extension also defines a new GL object type, called a + "renderbuffer", which encapsulates a single 2D pixel image. The + image of renderbuffer can be used as a framebuffer-attachable image + for generalized offscreen rendering and it also provides a means to + support rendering to GL logical buffer types which have no + corresponding texture format (stencil, etc). A renderbuffer + is similar to a texture in that both renderbuffers and textures can + be independently allocated and shared among multiple contexts. The + framework defined by this extension is general enough that support + for attaching images from GL objects other than textures and + renderbuffers could be added by layered extensions. + + To facilitate efficient switching between collections of + framebuffer-attachable images, this extension introduces another new + GL object, called a framebuffer object. A framebuffer object + contains the state that defines the traditional GL framebuffer, + including its set of images. Prior to this extension, it was the + window-system which defined and managed this collection of images, + traditionally by grouping them into a "drawable". The window-system + APIs would also provide a function (i.e., eglMakeCurrent) to bind a + drawable with a GL context. In this extension, however, this + functionality is subsumed by the GL and the GL provides the function + BindFramebufferOES to bind a framebuffer object to the current context. + Later, the context can bind back to the window-system-provided framebuffer + in order to display rendered content. + + Previous extensions that enabled rendering to a texture have been + much more complicated. One example is the combination of + ARB_pbuffer and ARB_render_texture, both of which are window-system + extensions. This combination requires calling MakeCurrent, an + operation that may be expensive, to switch between the window and + the pbuffer drawables. An application must create one pbuffer per + renderable texture in order to portably use ARB_render_texture. An + application must maintain at least one GL context per texture + format, because each context can only operate on a single + pixelformat or FBConfig. All of these characteristics make + ARB_render_texture both inefficient and cumbersome to use. + + OES_framebuffer_object, on the other hand, is both simpler to use + and more efficient than ARB_render_texture. The + OES_framebuffer_object API is contained wholly within the GL API and + has no (non-portable) window-system components. Under + OES_framebuffer_object, it is not necessary to create a second GL + context when rendering to a texture image whose format differs from + that of the window. Finally, unlike the pbuffers of + ARB_render_texture, a single framebuffer object can facilitate + rendering to an unlimited number of texture objects. + + Please refer to the EXT_framebuffer_object extension for a + detailed explaination of how framebuffer objects are supposed to work, + the issues and their resolution. This extension can be found at + http://oss.sgi.com/projects/ogl-sample/registry/EXT/framebuffer_object.txt + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/OES/framebuffer_object.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES1 import _types, _glgets +from OpenGL.raw.GLES1.OES.framebuffer_object import * +from OpenGL.raw.GLES1.OES.framebuffer_object import _EXTENSION_NAME + +def glInitFramebufferObjectOES(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glDeleteRenderbuffersOES.renderbuffers size not checked against n +glDeleteRenderbuffersOES=wrapper.wrapper(glDeleteRenderbuffersOES).setInputArraySize( + 'renderbuffers', None +) +# INPUT glGenRenderbuffersOES.renderbuffers size not checked against n +glGenRenderbuffersOES=wrapper.wrapper(glGenRenderbuffersOES).setInputArraySize( + 'renderbuffers', None +) +# INPUT glGetRenderbufferParameterivOES.params size not checked against 'pname' +glGetRenderbufferParameterivOES=wrapper.wrapper(glGetRenderbufferParameterivOES).setInputArraySize( + 'params', None +) +# INPUT glDeleteFramebuffersOES.framebuffers size not checked against n +glDeleteFramebuffersOES=wrapper.wrapper(glDeleteFramebuffersOES).setInputArraySize( + 'framebuffers', None +) +# INPUT glGenFramebuffersOES.framebuffers size not checked against n +glGenFramebuffersOES=wrapper.wrapper(glGenFramebuffersOES).setInputArraySize( + 'framebuffers', None +) +# INPUT glGetFramebufferAttachmentParameterivOES.params size not checked against 'pname' +glGetFramebufferAttachmentParameterivOES=wrapper.wrapper(glGetFramebufferAttachmentParameterivOES).setInputArraySize( + 'params', None +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/mapbuffer.py b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/mapbuffer.py new file mode 100644 index 00000000..1b4e5fdd --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/mapbuffer.py @@ -0,0 +1,29 @@ +'''OpenGL extension OES.mapbuffer + +This module customises the behaviour of the +OpenGL.raw.GLES1.OES.mapbuffer to provide a more +Python-friendly API + +Overview (from the spec) + + This extension adds to the vertex buffer object functionality supported + by OpenGL ES 1.1 or ES 2.0 by allowing the entire data storage of a + buffer object to be mapped into the client's address space. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/OES/mapbuffer.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES1 import _types, _glgets +from OpenGL.raw.GLES1.OES.mapbuffer import * +from OpenGL.raw.GLES1.OES.mapbuffer import _EXTENSION_NAME + +def glInitMapbufferOES(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/matrix_get.py b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/matrix_get.py new file mode 100644 index 00000000..04b989ff --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/matrix_get.py @@ -0,0 +1,48 @@ +'''OpenGL extension OES.matrix_get + +This module customises the behaviour of the +OpenGL.raw.GLES1.OES.matrix_get to provide a more +Python-friendly API + +Overview (from the spec) + + Many applications require the ability to be able to read the + GL matrices. OpenGL ES 1.1 will allow an application to read + the matrices using the GetFloatv command for the common profile + and the GetFixedv command for the common-lite profile. + + In cases where the common-lite implementation stores matrices + and performs matrix operations internally using floating pt + (example would be OpenGL ES implementations that support JSR184 etc.) + the GL cannot return the floating pt matrix elements since the float + data type is not supported by the common-lite profile. + Using GetFixedv to get the matrix data will result in a loss of + information. + + To take care of this issue, new tokens are proposed by this + extension. These tokens will allow the GL to return a + representation of the floating pt matrix elements as as an array + of integers, according to the IEEE 754 floating pt "single format" + bit layout. + + Bit 31 represents the sign of the floating pt number. + Bits 30 - 23 represent the exponent of the floating pt number. + Bits 22 - 0 represent the mantissa of the floating pt number. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/OES/matrix_get.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES1 import _types, _glgets +from OpenGL.raw.GLES1.OES.matrix_get import * +from OpenGL.raw.GLES1.OES.matrix_get import _EXTENSION_NAME + +def glInitMatrixGetOES(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/matrix_palette.py b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/matrix_palette.py new file mode 100644 index 00000000..b422aafc --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/matrix_palette.py @@ -0,0 +1,55 @@ +'''OpenGL extension OES.matrix_palette + +This module customises the behaviour of the +OpenGL.raw.GLES1.OES.matrix_palette to provide a more +Python-friendly API + +Overview (from the spec) + + This extension adds the ability to support vertex skinning in OpenGL ES. + A simplified version of the ARB_matrix_palette extension is used to + define OES_matrix_palette extension. + + This extension allow OpenGL ES to support a palette of matrices. The matrix + palette defines a set of matrices that can be used to transform a vertex. + The matrix palette is not part of the model view matrix stack and is enabled + by setting the MATRIX_MODE to MATRIX_PALETTE_OES. + + The n vertex units use a palette of m modelview matrices (where n and m are + constrained to implementation defined maxima.) Each vertex has a set of n + indices into the palette, and a corresponding set of n weights. + Matrix indices and weights can be changed for each vertex. + + When this extension is utilized, the enabled units transform each + vertex by the modelview matrices specified by the vertices' + respective indices. These results are subsequently scaled by the + weights of the respective units and then summed to create the + eyespace vertex. + + A similar procedure is followed for normals. Normals, however, + are transformed by the inverse transpose of the modelview matrix. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/OES/matrix_palette.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES1 import _types, _glgets +from OpenGL.raw.GLES1.OES.matrix_palette import * +from OpenGL.raw.GLES1.OES.matrix_palette import _EXTENSION_NAME + +def glInitMatrixPaletteOES(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glMatrixIndexPointerOES.pointer size not checked against 'size,type,stride' +glMatrixIndexPointerOES=wrapper.wrapper(glMatrixIndexPointerOES).setInputArraySize( + 'pointer', None +) +# INPUT glWeightPointerOES.pointer size not checked against 'type,stride' +glWeightPointerOES=wrapper.wrapper(glWeightPointerOES).setInputArraySize( + 'pointer', None +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/packed_depth_stencil.py b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/packed_depth_stencil.py new file mode 100644 index 00000000..a08a4a5a --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/packed_depth_stencil.py @@ -0,0 +1,61 @@ +'''OpenGL extension OES.packed_depth_stencil + +This module customises the behaviour of the +OpenGL.raw.GLES1.OES.packed_depth_stencil to provide a more +Python-friendly API + +Overview (from the spec) + + Many OpenGL implementations have chosen to interleave the depth and stencil + buffers into one buffer, often with 24 bits of depth precision and 8 bits of + stencil data. 32 bits is more than is needed for the depth buffer much of + the time; a 24-bit depth buffer, on the other hand, requires that reads and + writes of depth data be unaligned with respect to power-of-two boundaries. + On the other hand, 8 bits of stencil data is more than sufficient for most + applications, so it is only natural to pack the two buffers into a single + buffer with both depth and stencil data. OpenGL never provides direct + access to the buffers, so the OpenGL implementation can provide an interface + to applications where it appears the one merged buffer is composed of two + logical buffers. + + One disadvantage of this scheme is that OpenGL lacks any means by which this + packed data can be handled efficiently. For example, when an application + reads from the 24-bit depth buffer, using the type GL_UNSIGNED_SHORT will + lose 8 bits of data, while GL_UNSIGNED_INT has 8 too many. Both require + expensive format conversion operations. A 24-bit format would be no more + suitable, because it would also suffer from the unaligned memory accesses + that made the standalone 24-bit depth buffer an unattractive proposition in + the first place. + + If OES_depth_texture is supported, a new data format, GL_DEPTH_STENCIL_OES, + as well as a packed data type, UNSIGNED_INT_24_8_OES, together can be used + with glTex[Sub]Image2D. This provides an efficient way to supply data for a + 24-bit depth texture. When a texture with DEPTH_STENCIL_OES data is bound + for texturing, only the depth component is accessible through the texture + fetcher. + + This extension also provides a new sized internal format, + DEPTH24_STENCIL8_OES, which can be used for renderbuffer storage. When a + renderbuffer or texture image with a DEPTH_STENCIL_OES base internal format + is attached to both the depth and stencil attachment points of a framebuffer + object, then it becomes both the depth and stencil buffers of the + framebuffer. This fits nicely with hardware that interleaves both depth and + stencil data into a single buffer. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/OES/packed_depth_stencil.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES1 import _types, _glgets +from OpenGL.raw.GLES1.OES.packed_depth_stencil import * +from OpenGL.raw.GLES1.OES.packed_depth_stencil import _EXTENSION_NAME + +def glInitPackedDepthStencilOES(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/point_size_array.py b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/point_size_array.py new file mode 100644 index 00000000..990d9116 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/point_size_array.py @@ -0,0 +1,42 @@ +'''OpenGL extension OES.point_size_array + +This module customises the behaviour of the +OpenGL.raw.GLES1.OES.point_size_array to provide a more +Python-friendly API + +Overview (from the spec) + + This extension extends how points and point sprites are rendered + by allowing an array of point sizes instead of a fixed input point + size given by PointSize. This provides flexibility for applications + to do particle effects. + + The vertex arrays will be extended to include a point size array. + The point size array can be enabled/disabled via POINT_SIZE_ARRAY_OES. + + The point size array, if enabled, controls the sizes used to render + points and point sprites. If point size array is enabled, the point + size defined by PointSize is ignored. The point sizes supplied in the + point size arrays will be the sizes used to render both points and + point sprites. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/OES/point_size_array.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES1 import _types, _glgets +from OpenGL.raw.GLES1.OES.point_size_array import * +from OpenGL.raw.GLES1.OES.point_size_array import _EXTENSION_NAME + +def glInitPointSizeArrayOES(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glPointSizePointerOES.pointer size not checked against 'type,stride' +glPointSizePointerOES=wrapper.wrapper(glPointSizePointerOES).setInputArraySize( + 'pointer', None +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/point_sprite.py b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/point_sprite.py new file mode 100644 index 00000000..04ba47fd --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/point_sprite.py @@ -0,0 +1,43 @@ +'''OpenGL extension OES.point_sprite + +This module customises the behaviour of the +OpenGL.raw.GLES1.OES.point_sprite to provide a more +Python-friendly API + +Overview (from the spec) + + Applications such as particle systems have tended to use OpenGL quads + rather than points to render their geometry, since they would like + to use a custom-drawn texture for each particle, rather than the + traditional OpenGL round antialiased points, and each fragment in + a point has the same texture coordinates as every other fragment. + + Unfortunately, specifying the geometry for these quads can be + expensive, since it quadruples the amount of geometry required, and + may also require the application to do extra processing to compute + the location of each vertex. + + The purpose of this extension is to allow such applications to use + points rather than quads. When GL_POINT_SPRITE_OES is enabled, + the state of point antialiasing is ignored. For each texture unit, + the app can then specify whether to replace the existing texture + coordinates with point sprite texture coordinates, which are + interpolated across the point. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/OES/point_sprite.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES1 import _types, _glgets +from OpenGL.raw.GLES1.OES.point_sprite import * +from OpenGL.raw.GLES1.OES.point_sprite import _EXTENSION_NAME + +def glInitPointSpriteOES(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/query_matrix.py b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/query_matrix.py new file mode 100644 index 00000000..06c8835f --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/query_matrix.py @@ -0,0 +1,40 @@ +'''OpenGL extension OES.query_matrix + +This module customises the behaviour of the +OpenGL.raw.GLES1.OES.query_matrix to provide a more +Python-friendly API + +Overview (from the spec) + + Many applications may need to query the contents and status of the + current matrix at least for debugging purposes, especially as the + implementations are allowed to implement matrix machinery either in + any (possibly proprietary) floating point format, or in a fixed point + format that has the range and accuracy of at least 16.16 (signed 16 bit + integer part, unsigned 16 bit fractional part). + + This extension is intended to allow application to query the components + of the matrix and also their status, regardless whether the internal + representation is in fixed point or floating point. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/OES/query_matrix.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES1 import _types, _glgets +from OpenGL.raw.GLES1.OES.query_matrix import * +from OpenGL.raw.GLES1.OES.query_matrix import _EXTENSION_NAME + +def glInitQueryMatrixOES(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +glQueryMatrixxOES=wrapper.wrapper(glQueryMatrixxOES).setOutput( + 'exponent',size=(16,),orPassIn=True +).setOutput( + 'mantissa',size=(16,),orPassIn=True +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/read_format.py b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/read_format.py new file mode 100644 index 00000000..76737181 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/read_format.py @@ -0,0 +1,36 @@ +'''OpenGL extension OES.read_format + +This module customises the behaviour of the +OpenGL.raw.GLES1.OES.read_format to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides the capability to query an OpenGL + implementation for a preferred type and format combination + for use with reading the color buffer with the ReadPixels + command. The purpose is to enable embedded implementations + to support a greatly reduced set of type/format combinations + and provide a mechanism for applications to determine which + implementation-specific combination is supported. + + The preferred type and format combination returned may depend + on the read surface bound to the current GL context. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/OES/read_format.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES1 import _types, _glgets +from OpenGL.raw.GLES1.OES.read_format import * +from OpenGL.raw.GLES1.OES.read_format import _EXTENSION_NAME + +def glInitReadFormatOES(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/required_internalformat.py b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/required_internalformat.py new file mode 100644 index 00000000..92157334 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/required_internalformat.py @@ -0,0 +1,73 @@ +'''OpenGL extension OES.required_internalformat + +This module customises the behaviour of the +OpenGL.raw.GLES1.OES.required_internalformat to provide a more +Python-friendly API + +Overview (from the spec) + + The ES 1.1 API allows an implementation to store texture data internally + with arbitrary precision, regardless of the format and type of the data + supplied by the application. Similarly, ES allows an implementation to + choose an arbitrary precision for the internal storage of image data + allocated by glRenderbufferStorageOES. + + While this allows flexibility for implementations, it does mean that an + application does not have a reliable means to request the implementation + maintain a specific precision or to find out what precision the + implementation will maintain for a given texture or renderbuffer image. + + For reference, "Desktop" OpenGL uses the argument to + glTexImage*, glCopyTexImage* and glRenderbufferStorageEXT as a hint, + defining the particular base format and precision that the application wants + the implementation to maintain when storing the image data. Further, the + application can choose an with a different base internal + format than the source format specified by . The implementation is + not required to exactly match the precision specified by + when choosing an internal storage precision, but it is required to match the + base internal format of . + + In addition, ES 1.1 does not allow an implementation to fail a request to + glTexImage2D for any of the legal and combinations listed in + Table 3.4, even if the implementation does not natively support data stored + in that external and . However, there are no additional + requirements placed on the implementation. The ES implementation is free to + store the texture data with lower precision than originally specified, for + instance. Further, since ES removes the ability to query the texture object + to find out what internal format it chose, there is no way for the + application to find out that this has happened. + + This extension addresses the situation in two ways: + + 1) This extension introduces the ability for an application to specify + the desired "sized" internal formats for texture image allocation. + + 2) This extension guarantees to maintain at least the specified + precision of all available sized internal formats. + + An implementation that exports this extension is committing to support all + of the legal values for in Tables 3.4, 3.4.x, and 3.4.y, + subject to the extension dependencies described herein. That is to say, the + implementation is guaranteeing that choosing an argument + with a value from these tables will not cause an image allocation request to + fail. Furthermore, it is guaranteeing that for any sized internal format, + the renderbuffer or texture data will be stored with at least the precision + prescribed by the sized internal format. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/OES/required_internalformat.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES1 import _types, _glgets +from OpenGL.raw.GLES1.OES.required_internalformat import * +from OpenGL.raw.GLES1.OES.required_internalformat import _EXTENSION_NAME + +def glInitRequiredInternalformatOES(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/rgb8_rgba8.py b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/rgb8_rgba8.py new file mode 100644 index 00000000..7516fff2 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/rgb8_rgba8.py @@ -0,0 +1,28 @@ +'''OpenGL extension OES.rgb8_rgba8 + +This module customises the behaviour of the +OpenGL.raw.GLES1.OES.rgb8_rgba8 to provide a more +Python-friendly API + +Overview (from the spec) + + This extension enables RGB8 and RGBA8 renderbuffer + storage formats + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/OES/rgb8_rgba8.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES1 import _types, _glgets +from OpenGL.raw.GLES1.OES.rgb8_rgba8 import * +from OpenGL.raw.GLES1.OES.rgb8_rgba8 import _EXTENSION_NAME + +def glInitRgb8Rgba8OES(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/single_precision.py b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/single_precision.py new file mode 100644 index 00000000..d67e1d50 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/single_precision.py @@ -0,0 +1,37 @@ +'''OpenGL extension OES.single_precision + +This module customises the behaviour of the +OpenGL.raw.GLES1.OES.single_precision to provide a more +Python-friendly API + +Overview (from the spec) + + This extension adds commands with single-precision floating-point + parameters corresponding to the commands that only variants that + accept double-precision floating-point input. This allows an + application to avoid using double-precision floating-point + data types. New commands are added with an 'f' prefix. + + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/OES/single_precision.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES1 import _types, _glgets +from OpenGL.raw.GLES1.OES.single_precision import * +from OpenGL.raw.GLES1.OES.single_precision import _EXTENSION_NAME + +def glInitSinglePrecisionOES(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +glClipPlanefOES=wrapper.wrapper(glClipPlanefOES).setInputArraySize( + 'equation', 4 +) +glGetClipPlanefOES=wrapper.wrapper(glGetClipPlanefOES).setOutput( + 'equation',size=(4,),orPassIn=True +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/stencil1.py b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/stencil1.py new file mode 100644 index 00000000..6e9fc2ab --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/stencil1.py @@ -0,0 +1,28 @@ +'''OpenGL extension OES.stencil1 + +This module customises the behaviour of the +OpenGL.raw.GLES1.OES.stencil1 to provide a more +Python-friendly API + +Overview (from the spec) + + This extension enables 1-bit stencil component as a valid + render buffer storage format. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/OES/stencil1.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES1 import _types, _glgets +from OpenGL.raw.GLES1.OES.stencil1 import * +from OpenGL.raw.GLES1.OES.stencil1 import _EXTENSION_NAME + +def glInitStencil1OES(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/stencil4.py b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/stencil4.py new file mode 100644 index 00000000..b4a5215c --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/stencil4.py @@ -0,0 +1,28 @@ +'''OpenGL extension OES.stencil4 + +This module customises the behaviour of the +OpenGL.raw.GLES1.OES.stencil4 to provide a more +Python-friendly API + +Overview (from the spec) + + This extension enables 4-bit stencil component as a valid + render buffer storage format. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/OES/stencil4.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES1 import _types, _glgets +from OpenGL.raw.GLES1.OES.stencil4 import * +from OpenGL.raw.GLES1.OES.stencil4 import _EXTENSION_NAME + +def glInitStencil4OES(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/stencil8.py b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/stencil8.py new file mode 100644 index 00000000..e55a889e --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/stencil8.py @@ -0,0 +1,28 @@ +'''OpenGL extension OES.stencil8 + +This module customises the behaviour of the +OpenGL.raw.GLES1.OES.stencil8 to provide a more +Python-friendly API + +Overview (from the spec) + + This extension enables 8-bit stencil component as a valid + render buffer storage format. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/OES/stencil8.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES1 import _types, _glgets +from OpenGL.raw.GLES1.OES.stencil8 import * +from OpenGL.raw.GLES1.OES.stencil8 import _EXTENSION_NAME + +def glInitStencil8OES(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/stencil_wrap.py b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/stencil_wrap.py new file mode 100644 index 00000000..0d9aa27f --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/stencil_wrap.py @@ -0,0 +1,23 @@ +'''OpenGL extension OES.stencil_wrap + +This module customises the behaviour of the +OpenGL.raw.GLES1.OES.stencil_wrap to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/OES/stencil_wrap.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES1 import _types, _glgets +from OpenGL.raw.GLES1.OES.stencil_wrap import * +from OpenGL.raw.GLES1.OES.stencil_wrap import _EXTENSION_NAME + +def glInitStencilWrapOES(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/surfaceless_context.py b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/surfaceless_context.py new file mode 100644 index 00000000..d17ea233 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/surfaceless_context.py @@ -0,0 +1,33 @@ +'''OpenGL extension OES.surfaceless_context + +This module customises the behaviour of the +OpenGL.raw.GLES1.OES.surfaceless_context to provide a more +Python-friendly API + +Overview (from the spec) + + Applications that only want to render to framebuffer objects should + not need to create a throw-away EGL surface (typically a 1x1 + pbuffer) just to get a current context. The EGL extension + KHR_surfaceless_context provides a mechanism for making a context + current without a surface. This extensions specifies the behaviour + of OpenGL ES 1.x and OpenGL ES 2.0 when such a context is made + current. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/OES/surfaceless_context.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES1 import _types, _glgets +from OpenGL.raw.GLES1.OES.surfaceless_context import * +from OpenGL.raw.GLES1.OES.surfaceless_context import _EXTENSION_NAME + +def glInitSurfacelessContextOES(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/texture_cube_map.py b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/texture_cube_map.py new file mode 100644 index 00000000..90421819 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/texture_cube_map.py @@ -0,0 +1,94 @@ +'''OpenGL extension OES.texture_cube_map + +This module customises the behaviour of the +OpenGL.raw.GLES1.OES.texture_cube_map to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides a new texture generation scheme for cube + map textures. Instead of the current texture providing a 1D, 2D, + or 3D lookup into a 1D, 2D, or 3D texture image, the texture is a + set of six 2D images representing the faces of a cube. The (s,t,r) + texture coordinates are treated as a direction vector emanating from + the center of a cube. At texture generation time, the interpolated + per-fragment (s,t,r) selects one cube face 2D image based on the + largest magnitude coordinate (the major axis). A new 2D (s,t) is + calculated by dividing the two other coordinates (the minor axes + values) by the major axis value. Then the new (s,t) is used to + lookup into the selected 2D texture image face of the cube map. + + Unlike a standard 1D, 2D, or 3D texture that have just one target, + a cube map texture has six targets, one for each of its six 2D texture + image cube faces. All these targets must be consistent, complete, + and have equal width and height (ie, square dimensions). + + This extension also provides two new texture coordinate generation modes + for use in conjunction with cube map texturing. The reflection map + mode generates texture coordinates (s,t,r) matching the vertex's + eye-space reflection vector. The reflection map mode + is useful for environment mapping without the singularity inherent + in sphere mapping. The normal map mode generates texture coordinates + (s,t,r) matching the vertex's transformed eye-space + normal. The normal map mode is useful for sophisticated cube + map texturing-based diffuse lighting models. + + The intent of the new texgen functionality is that an application using + cube map texturing can use the new texgen modes to automatically + generate the reflection or normal vectors used to look up into the + cube map texture. + + An application note: When using cube mapping with dynamic cube + maps (meaning the cube map texture is re-rendered every frame), + by keeping the cube map's orientation pointing at the eye position, + the texgen-computed reflection or normal vector texture coordinates + can be always properly oriented for the cube map. However if the + cube map is static (meaning that when view changes, the cube map + texture is not updated), the texture matrix must be used to rotate + the texgen-computed reflection or normal vector texture coordinates + to match the orientation of the cube map. The rotation can be + computed based on two vectors: 1) the direction vector from the cube + map center to the eye position (both in world coordinates), and 2) + the cube map orientation in world coordinates. The axis of rotation + is the cross product of these two vectors; the angle of rotation is + the arcsin of the dot product of these two vectors. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/OES/texture_cube_map.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES1 import _types, _glgets +from OpenGL.raw.GLES1.OES.texture_cube_map import * +from OpenGL.raw.GLES1.OES.texture_cube_map import _EXTENSION_NAME + +def glInitTextureCubeMapOES(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glTexGenfvOES.params size not checked against 'pname' +glTexGenfvOES=wrapper.wrapper(glTexGenfvOES).setInputArraySize( + 'params', None +) +# INPUT glTexGenivOES.params size not checked against 'pname' +glTexGenivOES=wrapper.wrapper(glTexGenivOES).setInputArraySize( + 'params', None +) +# INPUT glTexGenxvOES.params size not checked against 'pname' +glTexGenxvOES=wrapper.wrapper(glTexGenxvOES).setInputArraySize( + 'params', None +) +# INPUT glGetTexGenfvOES.params size not checked against 'pname' +glGetTexGenfvOES=wrapper.wrapper(glGetTexGenfvOES).setInputArraySize( + 'params', None +) +# INPUT glGetTexGenivOES.params size not checked against 'pname' +glGetTexGenivOES=wrapper.wrapper(glGetTexGenivOES).setInputArraySize( + 'params', None +) +glGetTexGenxvOES=wrapper.wrapper(glGetTexGenxvOES).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/texture_env_crossbar.py b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/texture_env_crossbar.py new file mode 100644 index 00000000..c8075f8e --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/texture_env_crossbar.py @@ -0,0 +1,32 @@ +'''OpenGL extension OES.texture_env_crossbar + +This module customises the behaviour of the +OpenGL.raw.GLES1.OES.texture_env_crossbar to provide a more +Python-friendly API + +Overview (from the spec) + + This extension adds the capability to use the texture color from + other texture units as sources to the COMBINE enviornment + function. OpenGL ES 1.1 defined texture combine functions which + could use the color from the current texture unit as a source. + This extension adds the ability to use the color from any texture + unit as a source. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/OES/texture_env_crossbar.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES1 import _types, _glgets +from OpenGL.raw.GLES1.OES.texture_env_crossbar import * +from OpenGL.raw.GLES1.OES.texture_env_crossbar import _EXTENSION_NAME + +def glInitTextureEnvCrossbarOES(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/texture_mirrored_repeat.py b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/texture_mirrored_repeat.py new file mode 100644 index 00000000..1b001c35 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/texture_mirrored_repeat.py @@ -0,0 +1,34 @@ +'''OpenGL extension OES.texture_mirrored_repeat + +This module customises the behaviour of the +OpenGL.raw.GLES1.OES.texture_mirrored_repeat to provide a more +Python-friendly API + +Overview (from the spec) + + This extension extends the set of texture wrap modes to + include a mode (GL_MIRRORED_REPEAT) that effectively uses a texture + map twice as large at the original image in which the additional half, + for each coordinate, of the new image is a mirror image of the original + image. + + This new mode relaxes the need to generate images whose opposite edges + match by using the original image to generate a matching "mirror image". + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/OES/texture_mirrored_repeat.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES1 import _types, _glgets +from OpenGL.raw.GLES1.OES.texture_mirrored_repeat import * +from OpenGL.raw.GLES1.OES.texture_mirrored_repeat import _EXTENSION_NAME + +def glInitTextureMirroredRepeatOES(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/texture_npot.py b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/texture_npot.py new file mode 100644 index 00000000..3e4d9414 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/texture_npot.py @@ -0,0 +1,40 @@ +'''OpenGL extension OES.texture_npot + +This module customises the behaviour of the +OpenGL.raw.GLES1.OES.texture_npot to provide a more +Python-friendly API + +Overview (from the spec) + + This extension adds support for the REPEAT and MIRRORED_REPEAT + texture wrap modes and the minification filters supported for + non-power of two 2D textures, cubemaps and for 3D textures, if + the OES_texture_3D extension is supported. + + Section 3.8.2 of the OpenGL ES 2.0 specification describes + rules for sampling from an incomplete texture. There were specific + rules added for non-power of two textures i.e. if the texture wrap + mode is not CLAMP_TO_EDGE or minification filter is not NEAREST or + LINEAR and the texture is a non-power-of-two texture, then sampling + the texture will return (0, 0, 0, 1). + + These rules are no longer applied by an implementation that supports + this extension. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/OES/texture_npot.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES1 import _types, _glgets +from OpenGL.raw.GLES1.OES.texture_npot import * +from OpenGL.raw.GLES1.OES.texture_npot import _EXTENSION_NAME + +def glInitTextureNpotOES(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/vertex_array_object.py b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/vertex_array_object.py new file mode 100644 index 00000000..9eeb5909 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES1/OES/vertex_array_object.py @@ -0,0 +1,39 @@ +'''OpenGL extension OES.vertex_array_object + +This module customises the behaviour of the +OpenGL.raw.GLES1.OES.vertex_array_object to provide a more +Python-friendly API + +Overview (from the spec) + + This extension introduces vertex array objects which encapsulate + vertex array states on the server side (vertex buffer objects). + These objects aim to keep pointers to vertex data and to provide + names for different sets of vertex data. Therefore applications are + allowed to rapidly switch between different sets of vertex array + state, and to easily return to the default vertex array state. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/OES/vertex_array_object.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES1 import _types, _glgets +from OpenGL.raw.GLES1.OES.vertex_array_object import * +from OpenGL.raw.GLES1.OES.vertex_array_object import _EXTENSION_NAME + +def glInitVertexArrayObjectOES(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glDeleteVertexArraysOES.arrays size not checked against n +glDeleteVertexArraysOES=wrapper.wrapper(glDeleteVertexArraysOES).setInputArraySize( + 'arrays', None +) +# INPUT glGenVertexArraysOES.arrays size not checked against n +glGenVertexArraysOES=wrapper.wrapper(glGenVertexArraysOES).setInputArraySize( + 'arrays', None +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/QCOM/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/GLES1/QCOM/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES1/QCOM/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/QCOM/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES1/QCOM/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..02e081b8 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES1/QCOM/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/QCOM/__pycache__/driver_control.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES1/QCOM/__pycache__/driver_control.cpython-312.pyc new file mode 100644 index 00000000..0163fc94 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES1/QCOM/__pycache__/driver_control.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/QCOM/__pycache__/extended_get.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES1/QCOM/__pycache__/extended_get.cpython-312.pyc new file mode 100644 index 00000000..74d1480a Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES1/QCOM/__pycache__/extended_get.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/QCOM/__pycache__/extended_get2.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES1/QCOM/__pycache__/extended_get2.cpython-312.pyc new file mode 100644 index 00000000..a6bec9f1 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES1/QCOM/__pycache__/extended_get2.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/QCOM/__pycache__/perfmon_global_mode.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES1/QCOM/__pycache__/perfmon_global_mode.cpython-312.pyc new file mode 100644 index 00000000..8294a9ae Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES1/QCOM/__pycache__/perfmon_global_mode.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/QCOM/__pycache__/tiled_rendering.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES1/QCOM/__pycache__/tiled_rendering.cpython-312.pyc new file mode 100644 index 00000000..a4a807cf Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES1/QCOM/__pycache__/tiled_rendering.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/QCOM/__pycache__/writeonly_rendering.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES1/QCOM/__pycache__/writeonly_rendering.cpython-312.pyc new file mode 100644 index 00000000..3ea46337 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES1/QCOM/__pycache__/writeonly_rendering.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/QCOM/driver_control.py b/venv/lib/python3.12/site-packages/OpenGL/GLES1/QCOM/driver_control.py new file mode 100644 index 00000000..3bc337fd --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES1/QCOM/driver_control.py @@ -0,0 +1,47 @@ +'''OpenGL extension QCOM.driver_control + +This module customises the behaviour of the +OpenGL.raw.GLES1.QCOM.driver_control to provide a more +Python-friendly API + +Overview (from the spec) + + This extension exposes special control features in a driver to a + developer. A use of these controls would be to override state or + implement special modes of operation. One common example might be an + IFH or infinitely fast hardware mode. In this mode none of draw + commands would be sent to the GPU so no image would be displayed, + but all the driver software overhead would still happen thus + enabling developers to analyze driver overhead separate from GPU + performance. Some uses of this extension could invalidate future + rendering and thus should only be used by developers for debugging + and performance profiling purposes. + + The extension is general enough to allow the implementation to + choose which controls to expose and to provide a textual description + of those controls to developers. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/QCOM/driver_control.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES1 import _types, _glgets +from OpenGL.raw.GLES1.QCOM.driver_control import * +from OpenGL.raw.GLES1.QCOM.driver_control import _EXTENSION_NAME + +def glInitDriverControlQCOM(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glGetDriverControlsQCOM.driverControls size not checked against size +glGetDriverControlsQCOM=wrapper.wrapper(glGetDriverControlsQCOM).setInputArraySize( + 'driverControls', None +) +# INPUT glGetDriverControlStringQCOM.driverControlString size not checked against bufSize +glGetDriverControlStringQCOM=wrapper.wrapper(glGetDriverControlStringQCOM).setInputArraySize( + 'driverControlString', None +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/QCOM/extended_get.py b/venv/lib/python3.12/site-packages/OpenGL/GLES1/QCOM/extended_get.py new file mode 100644 index 00000000..2cc95c4e --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES1/QCOM/extended_get.py @@ -0,0 +1,45 @@ +'''OpenGL extension QCOM.extended_get + +This module customises the behaviour of the +OpenGL.raw.GLES1.QCOM.extended_get to provide a more +Python-friendly API + +Overview (from the spec) + + This extension enables instrumenting the driver for debugging of OpenGL ES + applications. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/QCOM/extended_get.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES1 import _types, _glgets +from OpenGL.raw.GLES1.QCOM.extended_get import * +from OpenGL.raw.GLES1.QCOM.extended_get import _EXTENSION_NAME + +def glInitExtendedGetQCOM(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glExtGetBuffersQCOM.buffers size not checked against maxBuffers +glExtGetBuffersQCOM=wrapper.wrapper(glExtGetBuffersQCOM).setInputArraySize( + 'buffers', None +).setInputArraySize( + 'numBuffers', 1 +) +# INPUT glExtGetRenderbuffersQCOM.renderbuffers size not checked against maxRenderbuffers +glExtGetRenderbuffersQCOM=wrapper.wrapper(glExtGetRenderbuffersQCOM).setInputArraySize( + 'numRenderbuffers', 1 +).setInputArraySize( + 'renderbuffers', None +) +# INPUT glExtGetFramebuffersQCOM.framebuffers size not checked against maxFramebuffers +glExtGetFramebuffersQCOM=wrapper.wrapper(glExtGetFramebuffersQCOM).setInputArraySize( + 'framebuffers', None +).setInputArraySize( + 'numFramebuffers', 1 +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/QCOM/extended_get2.py b/venv/lib/python3.12/site-packages/OpenGL/GLES1/QCOM/extended_get2.py new file mode 100644 index 00000000..fd93b51f --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES1/QCOM/extended_get2.py @@ -0,0 +1,39 @@ +'''OpenGL extension QCOM.extended_get2 + +This module customises the behaviour of the +OpenGL.raw.GLES1.QCOM.extended_get2 to provide a more +Python-friendly API + +Overview (from the spec) + + This extension enables instrumenting the driver for debugging of OpenGL ES + applications. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/QCOM/extended_get2.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES1 import _types, _glgets +from OpenGL.raw.GLES1.QCOM.extended_get2 import * +from OpenGL.raw.GLES1.QCOM.extended_get2 import _EXTENSION_NAME + +def glInitExtendedGet2QCOM(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glExtGetShadersQCOM.shaders size not checked against maxShaders +glExtGetShadersQCOM=wrapper.wrapper(glExtGetShadersQCOM).setInputArraySize( + 'numShaders', 1 +).setInputArraySize( + 'shaders', None +) +# INPUT glExtGetProgramsQCOM.programs size not checked against maxPrograms +glExtGetProgramsQCOM=wrapper.wrapper(glExtGetProgramsQCOM).setInputArraySize( + 'numPrograms', 1 +).setInputArraySize( + 'programs', None +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/QCOM/perfmon_global_mode.py b/venv/lib/python3.12/site-packages/OpenGL/GLES1/QCOM/perfmon_global_mode.py new file mode 100644 index 00000000..0f73cbd8 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES1/QCOM/perfmon_global_mode.py @@ -0,0 +1,23 @@ +'''OpenGL extension QCOM.perfmon_global_mode + +This module customises the behaviour of the +OpenGL.raw.GLES1.QCOM.perfmon_global_mode to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/QCOM/perfmon_global_mode.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES1 import _types, _glgets +from OpenGL.raw.GLES1.QCOM.perfmon_global_mode import * +from OpenGL.raw.GLES1.QCOM.perfmon_global_mode import _EXTENSION_NAME + +def glInitPerfmonGlobalModeQCOM(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/QCOM/tiled_rendering.py b/venv/lib/python3.12/site-packages/OpenGL/GLES1/QCOM/tiled_rendering.py new file mode 100644 index 00000000..b9f65471 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES1/QCOM/tiled_rendering.py @@ -0,0 +1,99 @@ +'''OpenGL extension QCOM.tiled_rendering + +This module customises the behaviour of the +OpenGL.raw.GLES1.QCOM.tiled_rendering to provide a more +Python-friendly API + +Overview (from the spec) + + In the handheld graphics space, a typical challenge is achieving efficient + rendering performance given the different characteristics of the various + types of graphics memory. Some types of memory ("slow" memory) are less + expensive but have low bandwidth, higher latency, and/or higher power + consumption, while other types ("fast" memory) are more expensive but have + higher bandwidth, lower latency, and/or lower power consumption. In many + cases, it is more efficient for a graphics processing unit (GPU) to render + directly to fast memory, but at most common display resolutions it is not + practical for a device to contain enough fast memory to accommodate both the + full color and depth/stencil buffers (the frame buffer). In some devices, + this problem can be addressed by providing both types of memory; a large + amount of slow memory that is sufficient to store the entire frame buffer, + and a small, dedicated amount of fast memory that allows the GPU to render + with optimal performance. The challenge lies in finding a way for the GPU + to render to fast memory when it is not large enough to contain the actual + frame buffer. + + One approach to solving this problem is to design the GPU and/or driver + using a tiled rendering architecture. With this approach the render target + is subdivided into a number of individual tiles, which are sized to fit + within the available amount of fast memory. Under normal operation, the + entire scene will be rendered to each individual tile using a multi-pass + technique, in which primitives that lie entirely outside of the tile being + rendered are trivially discarded. After each tile has been rendered, its + contents are saved out to the actual frame buffer in slow memory (a process + referred to as the "resolve"). The resolve introduces significant overhead, + both for the CPU and the GPU. However, even with this additional overhead, + rendering using this method is usually more efficient than rendering + directly to slow memory. + + This extension allows the application to specify a rectangular tile + rendering area and have full control over the resolves for that area. The + information given to the driver through this API can be used to perform + various optimizations in the driver and hardware. One example optimization + is being able to reduce the size or number of the resolves. Another + optimization might be to reduce the number of passes needed in the tiling + approach mentioned above. Even traditional rendering GPUs that don't use + tiles may benefit from this extension depending on their implemention of + certain common GPU operations. + + One typical use case could involve an application only rendering to select + portions of the render target using this technique (which shall be referred + to as "application tiling"), leaving all other portions of the render target + untouched. Therefore, in order to preserve the contents of the untouched + portions of the render target, the application must request an EGL (or other + context management API) configuration with a non-destructive swap. A + destructive swap may only be used safely if the application renders to the + entire area of the render target during each frame (otherwise the contents + of the untouched portions of the frame buffer will be undefined). + + Additionally, care must be taken to avoid the cost of mixing rendering with + and without application tiling within a single frame. Rendering without + application tiling ("normal" rendering) is most efficient when all of the + rendering for the entire scene can be encompassed within a single resolve. + If any portions of the scene are rendered prior to that resolve (such as via + a prior resolve, or via application tiling), then that resolve becomes much + more heavyweight. When this occurs, prior to rendering each tile the fast + memory must be populated with the existing contents of the frame buffer + region corresponding to that tile. This operation can double the cost of + resolves, so it is recommended that applications avoid mixing application + tiling and normal rendering within a single frame. If both rendering + methods must be used in the same frame, then the most efficient approach is + to perform all normal rendering first, followed by rendering done with + application tiling. An implicit resolve will occur (if needed) at the start + of application tiling, so any pending normal rendering operations will be + flushed at the time application tiling is initiated. This extension + provides interfaces for the application to communicate to the driver whether + or not rendering done with application tiling depends on the existing + contents of the specified tile, and whether or not the rendered contents of + the specified tile need to be preserved upon completion. This mechanism can + be used to obtain optimal performance, e.g. when the application knows that + every pixel in a tile will be completely rendered or when the resulting + contents of the depth/stencil buffers do not need to be preserved. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/QCOM/tiled_rendering.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES1 import _types, _glgets +from OpenGL.raw.GLES1.QCOM.tiled_rendering import * +from OpenGL.raw.GLES1.QCOM.tiled_rendering import _EXTENSION_NAME + +def glInitTiledRenderingQCOM(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/QCOM/writeonly_rendering.py b/venv/lib/python3.12/site-packages/OpenGL/GLES1/QCOM/writeonly_rendering.py new file mode 100644 index 00000000..9d6fb0a2 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES1/QCOM/writeonly_rendering.py @@ -0,0 +1,26 @@ +'''OpenGL extension QCOM.writeonly_rendering + +This module customises the behaviour of the +OpenGL.raw.GLES1.QCOM.writeonly_rendering to provide a more +Python-friendly API + +Overview (from the spec) + + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/QCOM/writeonly_rendering.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES1 import _types, _glgets +from OpenGL.raw.GLES1.QCOM.writeonly_rendering import * +from OpenGL.raw.GLES1.QCOM.writeonly_rendering import _EXTENSION_NAME + +def glInitWriteonlyRenderingQCOM(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/VERSION/GLES1_1_0.py b/venv/lib/python3.12/site-packages/OpenGL/GLES1/VERSION/GLES1_1_0.py new file mode 100644 index 00000000..06267c39 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES1/VERSION/GLES1_1_0.py @@ -0,0 +1,218 @@ +'''OpenGL extension VERSION.GLES1_1_0 + +This module customises the behaviour of the +OpenGL.raw.GLES1.VERSION.GLES1_1_0 to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/VERSION/GLES1_1_0.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES1 import _types, _glgets +from OpenGL.raw.GLES1.VERSION.GLES1_1_0 import * +from OpenGL.raw.GLES1.VERSION.GLES1_1_0 import _EXTENSION_NAME + +def glInitGles110VERSION(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +glClipPlanef=wrapper.wrapper(glClipPlanef).setInputArraySize( + 'eqn', 4 +) +# INPUT glFogfv.params size not checked against 'pname' +glFogfv=wrapper.wrapper(glFogfv).setInputArraySize( + 'params', None +) +glGetClipPlanef=wrapper.wrapper(glGetClipPlanef).setInputArraySize( + 'equation', 4 +) +glGetFloatv=wrapper.wrapper(glGetFloatv).setOutput( + 'data',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetLightfv=wrapper.wrapper(glGetLightfv).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetMaterialfv=wrapper.wrapper(glGetMaterialfv).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetTexEnvfv=wrapper.wrapper(glGetTexEnvfv).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetTexParameterfv=wrapper.wrapper(glGetTexParameterfv).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +# INPUT glLightModelfv.params size not checked against 'pname' +glLightModelfv=wrapper.wrapper(glLightModelfv).setInputArraySize( + 'params', None +) +# INPUT glLightfv.params size not checked against 'pname' +glLightfv=wrapper.wrapper(glLightfv).setInputArraySize( + 'params', None +) +glLoadMatrixf=wrapper.wrapper(glLoadMatrixf).setInputArraySize( + 'm', 16 +) +# INPUT glMaterialfv.params size not checked against 'pname' +glMaterialfv=wrapper.wrapper(glMaterialfv).setInputArraySize( + 'params', None +) +glMultMatrixf=wrapper.wrapper(glMultMatrixf).setInputArraySize( + 'm', 16 +) +# INPUT glPointParameterfv.params size not checked against 'pname' +glPointParameterfv=wrapper.wrapper(glPointParameterfv).setInputArraySize( + 'params', None +) +# INPUT glTexEnvfv.params size not checked against 'pname' +glTexEnvfv=wrapper.wrapper(glTexEnvfv).setInputArraySize( + 'params', None +) +# INPUT glTexParameterfv.params size not checked against 'pname' +glTexParameterfv=wrapper.wrapper(glTexParameterfv).setInputArraySize( + 'params', None +) +# INPUT glBufferData.data size not checked against size +glBufferData=wrapper.wrapper(glBufferData).setInputArraySize( + 'data', None +) +# INPUT glBufferSubData.data size not checked against size +glBufferSubData=wrapper.wrapper(glBufferSubData).setInputArraySize( + 'data', None +) +glClipPlanex=wrapper.wrapper(glClipPlanex).setInputArraySize( + 'equation', 4 +) +# INPUT glColorPointer.pointer size not checked against 'size,type,stride' +glColorPointer=wrapper.wrapper(glColorPointer).setInputArraySize( + 'pointer', None +) +# INPUT glCompressedTexImage2D.data size not checked against imageSize +glCompressedTexImage2D=wrapper.wrapper(glCompressedTexImage2D).setInputArraySize( + 'data', None +) +# INPUT glCompressedTexSubImage2D.data size not checked against imageSize +glCompressedTexSubImage2D=wrapper.wrapper(glCompressedTexSubImage2D).setInputArraySize( + 'data', None +) +# INPUT glDeleteBuffers.buffers size not checked against n +glDeleteBuffers=wrapper.wrapper(glDeleteBuffers).setInputArraySize( + 'buffers', None +) +# INPUT glDeleteTextures.textures size not checked against n +glDeleteTextures=wrapper.wrapper(glDeleteTextures).setInputArraySize( + 'textures', None +) +# INPUT glDrawElements.indices size not checked against 'count,type' +glDrawElements=wrapper.wrapper(glDrawElements).setInputArraySize( + 'indices', None +) +# INPUT glFogxv.param size not checked against 'pname' +glFogxv=wrapper.wrapper(glFogxv).setInputArraySize( + 'param', None +) +glGetBooleanv=wrapper.wrapper(glGetBooleanv).setOutput( + 'data',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetBufferParameteriv=wrapper.wrapper(glGetBufferParameteriv).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetClipPlanex=wrapper.wrapper(glGetClipPlanex).setInputArraySize( + 'equation', 4 +) +glGenBuffers=wrapper.wrapper(glGenBuffers).setOutput( + 'buffers',size=lambda x:(x,),pnameArg='n',orPassIn=True +) +glGenTextures=wrapper.wrapper(glGenTextures).setOutput( + 'textures',size=lambda x:(x,),pnameArg='n',orPassIn=True +) +glGetIntegerv=wrapper.wrapper(glGetIntegerv).setOutput( + 'data',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +# INPUT glGetLightxv.params size not checked against 'pname' +glGetLightxv=wrapper.wrapper(glGetLightxv).setInputArraySize( + 'params', None +) +# INPUT glGetMaterialxv.params size not checked against 'pname' +glGetMaterialxv=wrapper.wrapper(glGetMaterialxv).setInputArraySize( + 'params', None +) +glGetPointerv=wrapper.wrapper(glGetPointerv).setOutput( + 'params',size=(1,),orPassIn=True +) +glGetTexEnviv=wrapper.wrapper(glGetTexEnviv).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +# INPUT glGetTexEnvxv.params size not checked against 'pname' +glGetTexEnvxv=wrapper.wrapper(glGetTexEnvxv).setInputArraySize( + 'params', None +) +glGetTexParameteriv=wrapper.wrapper(glGetTexParameteriv).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +# INPUT glGetTexParameterxv.params size not checked against 'pname' +glGetTexParameterxv=wrapper.wrapper(glGetTexParameterxv).setInputArraySize( + 'params', None +) +# INPUT glLightModelxv.param size not checked against 'pname' +glLightModelxv=wrapper.wrapper(glLightModelxv).setInputArraySize( + 'param', None +) +# INPUT glLightxv.params size not checked against 'pname' +glLightxv=wrapper.wrapper(glLightxv).setInputArraySize( + 'params', None +) +glLoadMatrixx=wrapper.wrapper(glLoadMatrixx).setInputArraySize( + 'm', 16 +) +# INPUT glMaterialxv.param size not checked against 'pname' +glMaterialxv=wrapper.wrapper(glMaterialxv).setInputArraySize( + 'param', None +) +glMultMatrixx=wrapper.wrapper(glMultMatrixx).setInputArraySize( + 'm', 16 +) +# INPUT glNormalPointer.pointer size not checked against 'type,stride' +glNormalPointer=wrapper.wrapper(glNormalPointer).setInputArraySize( + 'pointer', None +) +# INPUT glPointParameterxv.params size not checked against 'pname' +glPointParameterxv=wrapper.wrapper(glPointParameterxv).setInputArraySize( + 'params', None +) +# OUTPUT glReadPixels.pixels COMPSIZE(format, type, width, height) +# INPUT glTexCoordPointer.pointer size not checked against 'size,type,stride' +glTexCoordPointer=wrapper.wrapper(glTexCoordPointer).setInputArraySize( + 'pointer', None +) +# INPUT glTexEnviv.params size not checked against 'pname' +glTexEnviv=wrapper.wrapper(glTexEnviv).setInputArraySize( + 'params', None +) +# INPUT glTexEnvxv.params size not checked against 'pname' +glTexEnvxv=wrapper.wrapper(glTexEnvxv).setInputArraySize( + 'params', None +) +# INPUT glTexImage2D.pixels size not checked against 'format,type,width,height' +glTexImage2D=wrapper.wrapper(glTexImage2D).setInputArraySize( + 'pixels', None +) +# INPUT glTexParameteriv.params size not checked against 'pname' +glTexParameteriv=wrapper.wrapper(glTexParameteriv).setInputArraySize( + 'params', None +) +# INPUT glTexParameterxv.params size not checked against 'pname' +glTexParameterxv=wrapper.wrapper(glTexParameterxv).setInputArraySize( + 'params', None +) +# INPUT glTexSubImage2D.pixels size not checked against 'format,type,width,height' +glTexSubImage2D=wrapper.wrapper(glTexSubImage2D).setInputArraySize( + 'pixels', None +) +# INPUT glVertexPointer.pointer size not checked against 'size,type,stride' +glVertexPointer=wrapper.wrapper(glVertexPointer).setInputArraySize( + 'pointer', None +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/VERSION/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/GLES1/VERSION/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES1/VERSION/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/VERSION/__pycache__/GLES1_1_0.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES1/VERSION/__pycache__/GLES1_1_0.cpython-312.pyc new file mode 100644 index 00000000..9ba636cb Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES1/VERSION/__pycache__/GLES1_1_0.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/VERSION/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES1/VERSION/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..ca59c25a Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES1/VERSION/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/GLES1/__init__.py new file mode 100644 index 00000000..18af696f --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES1/__init__.py @@ -0,0 +1,3 @@ +"""OpenGL.EGL the portable interface to GL environments""" +from OpenGL.raw.GLES1._types import * +from OpenGL.GLES1.VERSION.GLES1_1_0 import * diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES1/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES1/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..2dc717d1 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES1/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/AMD/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/AMD/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/AMD/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/AMD/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/AMD/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..da128c03 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/AMD/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/AMD/__pycache__/compressed_3DC_texture.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/AMD/__pycache__/compressed_3DC_texture.cpython-312.pyc new file mode 100644 index 00000000..a54e7251 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/AMD/__pycache__/compressed_3DC_texture.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/AMD/__pycache__/compressed_ATC_texture.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/AMD/__pycache__/compressed_ATC_texture.cpython-312.pyc new file mode 100644 index 00000000..d6dd0331 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/AMD/__pycache__/compressed_ATC_texture.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/AMD/__pycache__/framebuffer_multisample_advanced.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/AMD/__pycache__/framebuffer_multisample_advanced.cpython-312.pyc new file mode 100644 index 00000000..5882ce2e Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/AMD/__pycache__/framebuffer_multisample_advanced.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/AMD/__pycache__/performance_monitor.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/AMD/__pycache__/performance_monitor.cpython-312.pyc new file mode 100644 index 00000000..828dbfde Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/AMD/__pycache__/performance_monitor.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/AMD/__pycache__/program_binary_Z400.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/AMD/__pycache__/program_binary_Z400.cpython-312.pyc new file mode 100644 index 00000000..11a47a8a Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/AMD/__pycache__/program_binary_Z400.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/AMD/compressed_3DC_texture.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/AMD/compressed_3DC_texture.py new file mode 100644 index 00000000..4c781651 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/AMD/compressed_3DC_texture.py @@ -0,0 +1,73 @@ +'''OpenGL extension AMD.compressed_3DC_texture + +This module customises the behaviour of the +OpenGL.raw.GLES2.AMD.compressed_3DC_texture to provide a more +Python-friendly API + +Overview (from the spec) + + Two compression formats are introduced: + + - A compression format for two component textures. When used to store + normal vectors, the two components are commonly used with a fragment + shader that derives the third component. + + - A compression format for single component textures. The single component + may be used as a luminance or an alpha value. + + There are a large number of games that use luminance only and/or alpha only + textures. For example, monochrome light maps used in a few popular games + are 8-bit luminance textures. This extension describes a compression format + that provides a 2:1 compression ratio for 8-bit single channel textures. + + Normal maps are special textures that are used to add detail to 3D surfaces. + They are an extension of earlier "bump map" textures, which contained per- + pixel height values and were used to create the appearance of bumpiness on + otherwise smooth surfaces. Normal maps contain more detailed surface + information, allowing them to represent much more complex shapes. + + Normal mapping is one of the key features that makes the current generation + of games look so much better than earlier titles. A limitation to the + effectiveness of this technique is the size of the textures required. In an + ideal case where every surface has both a color texture map and a normal + texture map, the texture memory and bandwidth requirements would double + compared to using color maps alone. + + In fact, the problem is much worse because existing block based compression + methods such as DXTc, ETC, and S3TC are ineffective at compressing normal + maps. They tend to have trouble capturing the small edges and subtle + curvature that normal maps are designed to capture, and they also introduce + unsightly block artifacts. + + Because normal maps are used to capture light reflections and realistic + surface highlights, these problems are amplified relative to their impact on + color textures. The results are sufficiently poor that game artists and + developers would rather not use normal map compression at all on most + surfaces, and instead limit themselves to lower resolution maps on selected + parts of the rendered scene. + + 3DC provides an ideal solution to the normal map compression problem. It + provides up to 4:1 compression of normal maps, with image quality that is + virtually indistinguishable from the uncompressed version. The technique is + hardware accelerated, so the performance impact is minimal. Thus, + developers are freed to use higher resolution, more detailed normal maps, + and/or use them on all of the objects in a scene rather than just a select + few. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/AMD/compressed_3DC_texture.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.AMD.compressed_3DC_texture import * +from OpenGL.raw.GLES2.AMD.compressed_3DC_texture import _EXTENSION_NAME + +def glInitCompressed3DcTextureAMD(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/AMD/compressed_ATC_texture.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/AMD/compressed_ATC_texture.py new file mode 100644 index 00000000..49a47482 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/AMD/compressed_ATC_texture.py @@ -0,0 +1,36 @@ +'''OpenGL extension AMD.compressed_ATC_texture + +This module customises the behaviour of the +OpenGL.raw.GLES2.AMD.compressed_ATC_texture to provide a more +Python-friendly API + +Overview (from the spec) + + This extension enables support for ATC compressed texture formats. ATC is + AMD's proprietary compression algorithm for compressing textures for + handheld devices to save on power consumption, memory footprint and + bandwidth. + + Three compression formats are introduced: + + - A compression format for RGB textures. + - A compression format for RGBA textures using explicit alpha encoding. + - A compression format for RGBA textures using interpolated alpha encoding. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/AMD/compressed_ATC_texture.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.AMD.compressed_ATC_texture import * +from OpenGL.raw.GLES2.AMD.compressed_ATC_texture import _EXTENSION_NAME + +def glInitCompressedAtcTextureAMD(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/AMD/framebuffer_multisample_advanced.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/AMD/framebuffer_multisample_advanced.py new file mode 100644 index 00000000..7fdc44e1 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/AMD/framebuffer_multisample_advanced.py @@ -0,0 +1,46 @@ +'''OpenGL extension AMD.framebuffer_multisample_advanced + +This module customises the behaviour of the +OpenGL.raw.GLES2.AMD.framebuffer_multisample_advanced to provide a more +Python-friendly API + +Overview (from the spec) + + This extension extends ARB_framebuffer_object by allowing compromises + between image quality and memory footprint of multisample + antialiasing. + + ARB_framebuffer_object introduced RenderbufferStorageMultisample + as a method of defining the parameters for a multisample render + buffer. This function takes a parameter that has strict + requirements on behavior such that no compromises in the final image + quality are allowed. Additionally, ARB_framebuffer_object requires + that all framebuffer attachments have the same number of samples. + + This extension extends ARB_framebuffer_object by providing a new + function, RenderbufferStorageMultisampleAdvancedAMD, that + distinguishes between samples and storage samples for color + renderbuffers where the number of storage samples can be less than + the number of samples. This extension also allows non-matching sample + counts between color and depth/stencil renderbuffers. + + This extension does not require any specific combination of sample + counts to be supported. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/AMD/framebuffer_multisample_advanced.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.AMD.framebuffer_multisample_advanced import * +from OpenGL.raw.GLES2.AMD.framebuffer_multisample_advanced import _EXTENSION_NAME + +def glInitFramebufferMultisampleAdvancedAMD(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/AMD/performance_monitor.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/AMD/performance_monitor.py new file mode 100644 index 00000000..d50a373b --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/AMD/performance_monitor.py @@ -0,0 +1,71 @@ +'''OpenGL extension AMD.performance_monitor + +This module customises the behaviour of the +OpenGL.raw.GLES2.AMD.performance_monitor to provide a more +Python-friendly API + +Overview (from the spec) + + This extension enables the capture and reporting of performance monitors. + Performance monitors contain groups of counters which hold arbitrary counted + data. Typically, the counters hold information on performance-related + counters in the underlying hardware. The extension is general enough to + allow the implementation to choose which counters to expose and pick the + data type and range of the counters. The extension also allows counting to + start and end on arbitrary boundaries during rendering. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/AMD/performance_monitor.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.AMD.performance_monitor import * +from OpenGL.raw.GLES2.AMD.performance_monitor import _EXTENSION_NAME + +def glInitPerformanceMonitorAMD(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +glGetPerfMonitorGroupsAMD=wrapper.wrapper(glGetPerfMonitorGroupsAMD).setOutput( + 'groups',size=lambda x:(x,),pnameArg='groupsSize',orPassIn=True +).setOutput( + 'numGroups',size=(1,),orPassIn=True +) +glGetPerfMonitorCountersAMD=wrapper.wrapper(glGetPerfMonitorCountersAMD).setOutput( + 'counters',size=lambda x:(x,),pnameArg='counterSize',orPassIn=True +).setOutput( + 'maxActiveCounters',size=(1,),orPassIn=True +).setOutput( + 'numCounters',size=(1,),orPassIn=True +) +glGetPerfMonitorGroupStringAMD=wrapper.wrapper(glGetPerfMonitorGroupStringAMD).setOutput( + 'groupString',size=lambda x:(x,),pnameArg='bufSize',orPassIn=True +).setOutput( + 'length',size=(1,),orPassIn=True +) +glGetPerfMonitorCounterStringAMD=wrapper.wrapper(glGetPerfMonitorCounterStringAMD).setOutput( + 'counterString',size=lambda x:(x,),pnameArg='bufSize',orPassIn=True +).setOutput( + 'length',size=(1,),orPassIn=True +) +glGetPerfMonitorCounterInfoAMD=wrapper.wrapper(glGetPerfMonitorCounterInfoAMD).setOutput( + 'data',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGenPerfMonitorsAMD=wrapper.wrapper(glGenPerfMonitorsAMD).setOutput( + 'monitors',size=lambda x:(x,),pnameArg='n',orPassIn=True +) +glDeletePerfMonitorsAMD=wrapper.wrapper(glDeletePerfMonitorsAMD).setOutput( + 'monitors',size=lambda x:(x,),pnameArg='n',orPassIn=True +) +glSelectPerfMonitorCountersAMD=wrapper.wrapper(glSelectPerfMonitorCountersAMD).setOutput( + 'counterList',size=lambda x:(x,),pnameArg='numCounters',orPassIn=True +) +glGetPerfMonitorCounterDataAMD=wrapper.wrapper(glGetPerfMonitorCounterDataAMD).setOutput( + 'bytesWritten',size=(1,),orPassIn=True +).setOutput( + 'data',size=lambda x:(x,),pnameArg='dataSize',orPassIn=True +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/AMD/program_binary_Z400.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/AMD/program_binary_Z400.py new file mode 100644 index 00000000..0231c149 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/AMD/program_binary_Z400.py @@ -0,0 +1,42 @@ +'''OpenGL extension AMD.program_binary_Z400 + +This module customises the behaviour of the +OpenGL.raw.GLES2.AMD.program_binary_Z400 to provide a more +Python-friendly API + +Overview (from the spec) + + AMD provides an offline shader compiler as part of its suite of SDK tools + for AMD's Z400 family of embedded graphics accelerator IP. This extension + makes available a program binary format, Z400_BINARY_AMD. + + The offline shader compiler accepts a pair of OpenGL Shading Language + (GLSL) source shaders: one vertex shader and one fragment shader. It + outputs a compiled, optimized, and pre-linked program binary which can then + be loaded into a program objects via the ProgramBinaryOES command. + + Applications are recommended to use the OES_get_program_binary extension's + program binary retrieval mechanism for install-time shader compilation where + applicable. That cross-vendor extension provides the performance benefits + of loading pre-compiled program binaries, while providing the portability of + deploying GLSL source shaders with the application rather than vendor- + specific binaries. The details of this extension are obviated by the use + of that extension. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/AMD/program_binary_Z400.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.AMD.program_binary_Z400 import * +from OpenGL.raw.GLES2.AMD.program_binary_Z400 import _EXTENSION_NAME + +def glInitProgramBinaryZ400AMD(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/ANDROID/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/ANDROID/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/ANDROID/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/ANDROID/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/ANDROID/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..feda7eef Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/ANDROID/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/ANDROID/__pycache__/extension_pack_es31a.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/ANDROID/__pycache__/extension_pack_es31a.cpython-312.pyc new file mode 100644 index 00000000..06cb2509 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/ANDROID/__pycache__/extension_pack_es31a.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/ANDROID/extension_pack_es31a.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/ANDROID/extension_pack_es31a.py new file mode 100644 index 00000000..9ddfdc28 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/ANDROID/extension_pack_es31a.py @@ -0,0 +1,37 @@ +'''OpenGL extension ANDROID.extension_pack_es31a + +This module customises the behaviour of the +OpenGL.raw.GLES2.ANDROID.extension_pack_es31a to provide a more +Python-friendly API + +Overview (from the spec) + + This extension changes little functionality directly. Instead it serves to + roll up the 20 extensions it requires, allowing applications to check for + all of them at once, and enable all of their shading language features with + a single #extension statement. The Android platform provides special support + outside of OpenGL ES to help applications target this set of extensions. + + In addition, this extension ensures support for images, shader storage + buffers, and atomic counters in fragment shaders. In unextended OpenGL ES + the minimum value of the relevant implementation-defined limits is zero; + this extension raises these minimums to match the minimums for compute + shaders. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ANDROID/extension_pack_es31a.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.ANDROID.extension_pack_es31a import * +from OpenGL.raw.GLES2.ANDROID.extension_pack_es31a import _EXTENSION_NAME + +def glInitExtensionPackEs31AANDROID(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/ANGLE/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/ANGLE/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/ANGLE/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/ANGLE/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/ANGLE/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..9a2a0506 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/ANGLE/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/ANGLE/__pycache__/depth_texture.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/ANGLE/__pycache__/depth_texture.cpython-312.pyc new file mode 100644 index 00000000..07037653 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/ANGLE/__pycache__/depth_texture.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/ANGLE/__pycache__/framebuffer_blit.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/ANGLE/__pycache__/framebuffer_blit.cpython-312.pyc new file mode 100644 index 00000000..e2da7e25 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/ANGLE/__pycache__/framebuffer_blit.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/ANGLE/__pycache__/framebuffer_multisample.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/ANGLE/__pycache__/framebuffer_multisample.cpython-312.pyc new file mode 100644 index 00000000..427d41c6 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/ANGLE/__pycache__/framebuffer_multisample.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/ANGLE/__pycache__/instanced_arrays.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/ANGLE/__pycache__/instanced_arrays.cpython-312.pyc new file mode 100644 index 00000000..217088d8 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/ANGLE/__pycache__/instanced_arrays.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/ANGLE/__pycache__/pack_reverse_row_order.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/ANGLE/__pycache__/pack_reverse_row_order.cpython-312.pyc new file mode 100644 index 00000000..2b972f07 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/ANGLE/__pycache__/pack_reverse_row_order.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/ANGLE/__pycache__/program_binary.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/ANGLE/__pycache__/program_binary.cpython-312.pyc new file mode 100644 index 00000000..bc82d82d Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/ANGLE/__pycache__/program_binary.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/ANGLE/__pycache__/texture_compression_dxt3.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/ANGLE/__pycache__/texture_compression_dxt3.cpython-312.pyc new file mode 100644 index 00000000..8bbdbcc4 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/ANGLE/__pycache__/texture_compression_dxt3.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/ANGLE/__pycache__/texture_compression_dxt5.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/ANGLE/__pycache__/texture_compression_dxt5.cpython-312.pyc new file mode 100644 index 00000000..7344f1e2 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/ANGLE/__pycache__/texture_compression_dxt5.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/ANGLE/__pycache__/texture_usage.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/ANGLE/__pycache__/texture_usage.cpython-312.pyc new file mode 100644 index 00000000..65bee759 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/ANGLE/__pycache__/texture_usage.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/ANGLE/__pycache__/translated_shader_source.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/ANGLE/__pycache__/translated_shader_source.cpython-312.pyc new file mode 100644 index 00000000..bdd68502 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/ANGLE/__pycache__/translated_shader_source.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/ANGLE/depth_texture.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/ANGLE/depth_texture.py new file mode 100644 index 00000000..9bf5039f --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/ANGLE/depth_texture.py @@ -0,0 +1,36 @@ +'''OpenGL extension ANGLE.depth_texture + +This module customises the behaviour of the +OpenGL.raw.GLES2.ANGLE.depth_texture to provide a more +Python-friendly API + +Overview (from the spec) + + This extension defines support for 2D depth and depth-stencil + textures in an OpenGL ES implementation. + + This extension incorporates the depth texturing functionality of + OES_depth_texture and OES_packed_depth_stencil, but does not + provide the ability to load existing data via TexImage2D or + TexSubImage2D. This extension also allows implementation + variability in which components from a sampled depth texture + contain the depth data. Depth textures created with this + extension only support 1 level. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ANGLE/depth_texture.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.ANGLE.depth_texture import * +from OpenGL.raw.GLES2.ANGLE.depth_texture import _EXTENSION_NAME + +def glInitDepthTextureANGLE(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/ANGLE/framebuffer_blit.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/ANGLE/framebuffer_blit.py new file mode 100644 index 00000000..a26a76b1 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/ANGLE/framebuffer_blit.py @@ -0,0 +1,32 @@ +'''OpenGL extension ANGLE.framebuffer_blit + +This module customises the behaviour of the +OpenGL.raw.GLES2.ANGLE.framebuffer_blit to provide a more +Python-friendly API + +Overview (from the spec) + + This extension modifies framebuffer objects by splitting the + framebuffer object binding point into separate DRAW and READ + bindings. This allows copying directly from one framebuffer to + another. In addition, a new high performance blit function is + added to facilitate these blits and perform some data conversion + where allowed. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ANGLE/framebuffer_blit.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.ANGLE.framebuffer_blit import * +from OpenGL.raw.GLES2.ANGLE.framebuffer_blit import _EXTENSION_NAME + +def glInitFramebufferBlitANGLE(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/ANGLE/framebuffer_multisample.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/ANGLE/framebuffer_multisample.py new file mode 100644 index 00000000..4878173a --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/ANGLE/framebuffer_multisample.py @@ -0,0 +1,48 @@ +'''OpenGL extension ANGLE.framebuffer_multisample + +This module customises the behaviour of the +OpenGL.raw.GLES2.ANGLE.framebuffer_multisample to provide a more +Python-friendly API + +Overview (from the spec) + + This extension extends the framebuffer object framework to + enable multisample rendering. + + The new operation RenderbufferStorageMultisampleANGLE() allocates + storage for a renderbuffer object that can be used as a multisample + buffer. A multisample render buffer image differs from a + single-sample render buffer image in that a multisample image has a + number of SAMPLES that is greater than zero. No method is provided + for creating multisample texture images. + + All of the framebuffer-attachable images attached to a framebuffer + object must have the same number of SAMPLES or else the framebuffer + object is not "framebuffer complete". If a framebuffer object with + multisample attachments is "framebuffer complete", then the + framebuffer object behaves as if SAMPLE_BUFFERS is one. + + The resolve operation is affected by calling + BlitFramebufferANGLE (provided by the ANGLE_framebuffer_blit + extension) where the source is a multisample application-created + framebuffer object and the destination is a single-sample + framebuffer object (either application-created or window-system + provided). + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ANGLE/framebuffer_multisample.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.ANGLE.framebuffer_multisample import * +from OpenGL.raw.GLES2.ANGLE.framebuffer_multisample import _EXTENSION_NAME + +def glInitFramebufferMultisampleANGLE(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/ANGLE/instanced_arrays.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/ANGLE/instanced_arrays.py new file mode 100644 index 00000000..126863fa --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/ANGLE/instanced_arrays.py @@ -0,0 +1,49 @@ +'''OpenGL extension ANGLE.instanced_arrays + +This module customises the behaviour of the +OpenGL.raw.GLES2.ANGLE.instanced_arrays to provide a more +Python-friendly API + +Overview (from the spec) + + A common use case in GL for some applications is to be able to + draw the same object, or groups of similar objects that share + vertex data, primitive count and type, multiple times. This + extension provides a means of accelerating such use cases while + restricting the number of API calls, and keeping the amount of + duplicate data to a minimum. + + This extension introduces an array "divisor" for generic + vertex array attributes, which when non-zero specifies that the + attribute is "instanced." An instanced attribute does not + advance per-vertex as usual, but rather after every + conceptual draw calls. + + (Attributes which aren't instanced are repeated in their entirety + for every conceptual draw call.) + + By specifying transform data in an instanced attribute or series + of instanced attributes, vertex shaders can, in concert with the + instancing draw calls, draw multiple instances of an object with + one draw call. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ANGLE/instanced_arrays.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.ANGLE.instanced_arrays import * +from OpenGL.raw.GLES2.ANGLE.instanced_arrays import _EXTENSION_NAME + +def glInitInstancedArraysANGLE(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glDrawElementsInstancedANGLE.indices size not checked against 'count,type' +glDrawElementsInstancedANGLE=wrapper.wrapper(glDrawElementsInstancedANGLE).setInputArraySize( + 'indices', None +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/ANGLE/pack_reverse_row_order.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/ANGLE/pack_reverse_row_order.py new file mode 100644 index 00000000..a5baa243 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/ANGLE/pack_reverse_row_order.py @@ -0,0 +1,37 @@ +'''OpenGL extension ANGLE.pack_reverse_row_order + +This module customises the behaviour of the +OpenGL.raw.GLES2.ANGLE.pack_reverse_row_order to provide a more +Python-friendly API + +Overview (from the spec) + + This extension introduces a mechanism to allow reversing the order + in which image rows are written into a pack destination. This + effectively allows an application to flip the results of a ReadPixels + in the y direction operation without having to render upside down. + + The coordinate system of OpenGL is vertically reversed in comparison to a + number of other graphics systems such as native windowing APIs. Applications + that perform ReadPixels may have to either render to an intermediate color + buffer before calling ReadPixels or perform a flip in software after + ReadPixels. In some systems the GL can perform the row reversal during + ReadPixels without incurring additional cost. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ANGLE/pack_reverse_row_order.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.ANGLE.pack_reverse_row_order import * +from OpenGL.raw.GLES2.ANGLE.pack_reverse_row_order import _EXTENSION_NAME + +def glInitPackReverseRowOrderANGLE(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/ANGLE/program_binary.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/ANGLE/program_binary.py new file mode 100644 index 00000000..b1d6d66c --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/ANGLE/program_binary.py @@ -0,0 +1,29 @@ +'''OpenGL extension ANGLE.program_binary + +This module customises the behaviour of the +OpenGL.raw.GLES2.ANGLE.program_binary to provide a more +Python-friendly API + +Overview (from the spec) + + This extension makes available a program binary format, + PROGRAM_BINARY_ANGLE. It enables retrieving and loading of pre-linked + ANGLE program objects. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ANGLE/program_binary.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.ANGLE.program_binary import * +from OpenGL.raw.GLES2.ANGLE.program_binary import _EXTENSION_NAME + +def glInitProgramBinaryANGLE(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/ANGLE/texture_compression_dxt3.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/ANGLE/texture_compression_dxt3.py new file mode 100644 index 00000000..e4172769 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/ANGLE/texture_compression_dxt3.py @@ -0,0 +1,23 @@ +'''OpenGL extension ANGLE.texture_compression_dxt3 + +This module customises the behaviour of the +OpenGL.raw.GLES2.ANGLE.texture_compression_dxt3 to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ANGLE/texture_compression_dxt3.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.ANGLE.texture_compression_dxt3 import * +from OpenGL.raw.GLES2.ANGLE.texture_compression_dxt3 import _EXTENSION_NAME + +def glInitTextureCompressionDxt3ANGLE(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/ANGLE/texture_compression_dxt5.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/ANGLE/texture_compression_dxt5.py new file mode 100644 index 00000000..8d98c32a --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/ANGLE/texture_compression_dxt5.py @@ -0,0 +1,23 @@ +'''OpenGL extension ANGLE.texture_compression_dxt5 + +This module customises the behaviour of the +OpenGL.raw.GLES2.ANGLE.texture_compression_dxt5 to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ANGLE/texture_compression_dxt5.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.ANGLE.texture_compression_dxt5 import * +from OpenGL.raw.GLES2.ANGLE.texture_compression_dxt5 import _EXTENSION_NAME + +def glInitTextureCompressionDxt5ANGLE(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/ANGLE/texture_usage.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/ANGLE/texture_usage.py new file mode 100644 index 00000000..f80dd4cd --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/ANGLE/texture_usage.py @@ -0,0 +1,39 @@ +'''OpenGL extension ANGLE.texture_usage + +This module customises the behaviour of the +OpenGL.raw.GLES2.ANGLE.texture_usage to provide a more +Python-friendly API + +Overview (from the spec) + + In some implementations it is advantageous to know the expected + usage of a texture before the backing storage for it is allocated. + This can help to inform the implementation's choice of format + and type of memory used for the allocation. If the usage is not + known in advance, the implementation essentially has to make a + guess as to how it will be used. If it is later proven wrong, + it may need to perform costly re-allocations and/or reformatting + of the texture data, resulting in reduced performance. + + This extension adds a texture usage flag that is specified via + the TEXTURE_USAGE_ANGLE TexParameter. This can be used to + indicate that the application knows that this texture will be + used for rendering. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ANGLE/texture_usage.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.ANGLE.texture_usage import * +from OpenGL.raw.GLES2.ANGLE.texture_usage import _EXTENSION_NAME + +def glInitTextureUsageANGLE(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/ANGLE/translated_shader_source.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/ANGLE/translated_shader_source.py new file mode 100644 index 00000000..84172572 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/ANGLE/translated_shader_source.py @@ -0,0 +1,36 @@ +'''OpenGL extension ANGLE.translated_shader_source + +This module customises the behaviour of the +OpenGL.raw.GLES2.ANGLE.translated_shader_source to provide a more +Python-friendly API + +Overview (from the spec) + + WebGL uses the GLSL ES 2.0 spec on all platforms, and translates these + shaders to the host platform's native language (HLSL, GLSL, and even GLSL + ES). For debugging purposes, it is useful to be able to examine the shader + after translation. + + This extension addes a new function to query the translated shader source, + and adds a new enum for GetShaderiv's parameter to query the + translated shader source length. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ANGLE/translated_shader_source.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.ANGLE.translated_shader_source import * +from OpenGL.raw.GLES2.ANGLE.translated_shader_source import _EXTENSION_NAME + +def glInitTranslatedShaderSourceANGLE(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +glGetTranslatedShaderSourceANGLE=wrapper.wrapper(glGetTranslatedShaderSourceANGLE).setInputArraySize( + 'length', 1 +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/APPLE/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/APPLE/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/APPLE/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/APPLE/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/APPLE/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..226c2d21 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/APPLE/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/APPLE/__pycache__/clip_distance.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/APPLE/__pycache__/clip_distance.cpython-312.pyc new file mode 100644 index 00000000..fb8f3309 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/APPLE/__pycache__/clip_distance.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/APPLE/__pycache__/color_buffer_packed_float.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/APPLE/__pycache__/color_buffer_packed_float.cpython-312.pyc new file mode 100644 index 00000000..27c12fba Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/APPLE/__pycache__/color_buffer_packed_float.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/APPLE/__pycache__/copy_texture_levels.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/APPLE/__pycache__/copy_texture_levels.cpython-312.pyc new file mode 100644 index 00000000..2b536cf4 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/APPLE/__pycache__/copy_texture_levels.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/APPLE/__pycache__/framebuffer_multisample.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/APPLE/__pycache__/framebuffer_multisample.cpython-312.pyc new file mode 100644 index 00000000..dca16bb0 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/APPLE/__pycache__/framebuffer_multisample.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/APPLE/__pycache__/rgb_422.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/APPLE/__pycache__/rgb_422.cpython-312.pyc new file mode 100644 index 00000000..197a852f Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/APPLE/__pycache__/rgb_422.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/APPLE/__pycache__/sync.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/APPLE/__pycache__/sync.cpython-312.pyc new file mode 100644 index 00000000..eb706265 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/APPLE/__pycache__/sync.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/APPLE/__pycache__/texture_format_BGRA8888.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/APPLE/__pycache__/texture_format_BGRA8888.cpython-312.pyc new file mode 100644 index 00000000..65ef588f Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/APPLE/__pycache__/texture_format_BGRA8888.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/APPLE/__pycache__/texture_max_level.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/APPLE/__pycache__/texture_max_level.cpython-312.pyc new file mode 100644 index 00000000..3da5ecb8 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/APPLE/__pycache__/texture_max_level.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/APPLE/__pycache__/texture_packed_float.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/APPLE/__pycache__/texture_packed_float.cpython-312.pyc new file mode 100644 index 00000000..09dc174c Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/APPLE/__pycache__/texture_packed_float.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/APPLE/clip_distance.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/APPLE/clip_distance.py new file mode 100644 index 00000000..fd5b6c8d --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/APPLE/clip_distance.py @@ -0,0 +1,30 @@ +'''OpenGL extension APPLE.clip_distance + +This module customises the behaviour of the +OpenGL.raw.GLES2.APPLE.clip_distance to provide a more +Python-friendly API + +Overview (from the spec) + + This extension adds support for hardware clip planes to OpenGL ES 2.0 + and 3.0. These were present in OpenGL ES 1.1, but were removed to + better match certain hardware. Since they're useful for certain + applications, notable CAD, we return them here. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/APPLE/clip_distance.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.APPLE.clip_distance import * +from OpenGL.raw.GLES2.APPLE.clip_distance import _EXTENSION_NAME + +def glInitClipDistanceAPPLE(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/APPLE/color_buffer_packed_float.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/APPLE/color_buffer_packed_float.py new file mode 100644 index 00000000..0a23f890 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/APPLE/color_buffer_packed_float.py @@ -0,0 +1,29 @@ +'''OpenGL extension APPLE.color_buffer_packed_float + +This module customises the behaviour of the +OpenGL.raw.GLES2.APPLE.color_buffer_packed_float to provide a more +Python-friendly API + +Overview (from the spec) + + This extension allows two packed floating point formats + R11F_G11F_B10F and as RGB9_E5 defined in APPLE_texture_packed_float or + OpenGL ES 3.0 or to be rendered to via framebuffer objects. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/APPLE/color_buffer_packed_float.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.APPLE.color_buffer_packed_float import * +from OpenGL.raw.GLES2.APPLE.color_buffer_packed_float import _EXTENSION_NAME + +def glInitColorBufferPackedFloatAPPLE(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/APPLE/copy_texture_levels.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/APPLE/copy_texture_levels.py new file mode 100644 index 00000000..168ca0fa --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/APPLE/copy_texture_levels.py @@ -0,0 +1,49 @@ +'''OpenGL extension APPLE.copy_texture_levels + +This module customises the behaviour of the +OpenGL.raw.GLES2.APPLE.copy_texture_levels to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides an efficient path for copying a contiguous subset of mipmap + levels from one texture to the matching subset of mipmap levels of another texture, + where matches are determined by the equality of a level's dimensions. + + This extension is dependent on the existence of the extension EXT_texture_storage. + Immutable textures are used to guarantee that storage is allocated up front for the + source and destination textures and that the internal formats of those textures are + sized the same. + + An efficient copy can be achieved by implementations because the internal storage + requirements are the same between textures and will remain unchanged when moving data. + It is expected that in all cases, moving levels from one texture to another is a + simple copy operation without any necessary conversion. This extension can be used as + an alternative to TEXTURE_BASE_LEVEL. In some implementations, changing the value of + TEXTURE_BASE_LEVEL can incur a costly re-allocation at runtime. + + Texture streaming is an expected use case for this extension. For example, a developer + may want to stream in a larger base level for a given texture from a storage device. + To achieve this, a copy of the current mipmap levels are made into a destination + whose storage was specified to accommodate the source levels and the larger base + level. The efficiency of the copy without conversion allows for the smaller mipmap + levels to be in place while the larger base level is being read from the storage + device and uploaded. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/APPLE/copy_texture_levels.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.APPLE.copy_texture_levels import * +from OpenGL.raw.GLES2.APPLE.copy_texture_levels import _EXTENSION_NAME + +def glInitCopyTextureLevelsAPPLE(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/APPLE/framebuffer_multisample.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/APPLE/framebuffer_multisample.py new file mode 100644 index 00000000..1e702968 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/APPLE/framebuffer_multisample.py @@ -0,0 +1,51 @@ +'''OpenGL extension APPLE.framebuffer_multisample + +This module customises the behaviour of the +OpenGL.raw.GLES2.APPLE.framebuffer_multisample to provide a more +Python-friendly API + +Overview (from the spec) + + This extension extends the framebuffer object framework to + enable multisample rendering. + + The new operation RenderbufferStorageMultisampleAPPLE() allocates + storage for a renderbuffer object that can be used as a multisample + buffer. A multisample render buffer image differs from a + single-sample render buffer image in that a multisample image has a + number of SAMPLES that is greater than zero. No method is provided + for creating multisample texture images. + + All of the framebuffer-attachable images attached to a framebuffer + object must have the same number of SAMPLES or else the framebuffer + object is not "framebuffer complete". If a framebuffer object with + multisample attachments is "framebuffer complete", then the + framebuffer object behaves as if SAMPLE_BUFFERS is one. + + The resolve operation is affected by calling + ResolveMultisampleFramebufferAPPLE where the source is a multisample + application-created framebuffer object and the destination is a + single-sample framebuffer object. Separate read and draw framebuffer + object binding points are established to facilitate the resolve. + + Scissoring may be used in conjunction with + ResolveMultisampleFramebufferAPPLE to resolve only a portion of the + framebuffer. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/APPLE/framebuffer_multisample.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.APPLE.framebuffer_multisample import * +from OpenGL.raw.GLES2.APPLE.framebuffer_multisample import _EXTENSION_NAME + +def glInitFramebufferMultisampleAPPLE(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/APPLE/rgb_422.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/APPLE/rgb_422.py new file mode 100644 index 00000000..5b3ef0df --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/APPLE/rgb_422.py @@ -0,0 +1,64 @@ +'''OpenGL extension APPLE.rgb_422 + +This module customises the behaviour of the +OpenGL.raw.GLES2.APPLE.rgb_422 to provide a more +Python-friendly API + +Overview (from the spec) + + A common storage format for video data is 8-bit 422, with every four + bytes encoding two pixels. Within the four bytes there are two + luminance samples, and two chrominance samples that are shared between + both pixels. + + There is a previous extension, namely GL_APPLE_ycbcr_422 that provided + transparent support for this kind of data. However, that extension + left the exact conversion from Y'CbCr to RGB undefined. In reality, + it really had always been based on the ITU-R BT.601 standard, which + meant it was not particularly useful for dealing with high definition + video data, which is encoded using the Rec. 709 standard. + + In some cases the original extension was implemented via fixed function + hardware, but on more modern graphics processors this is done via + a combination of 422 sampling formats and fragment shader instructions. + + This extension essentially exposes a "raw" 422 texture format that + allows developers to access the raw pre-converted Y'CbCr components + so that they have full control over the colorspace conversion. + + In order to avoid defining entirely new color channels within GL, + the Y, Cb and Cr color channels within the 422 data are mapped into + the existing green, blue and red color channels, respectively. Developers + must write their own fragment shader/program to perform the desired + color space transformation. + + Note: Because of the use of the packed UNSIGNED_SHORT_8_8[_REV] types, the + correct type to use based on the layout of the data in memory (Cb Y Cr Y + versus Y Cb Y Cr) will necessarily be sensitive to host endianness. + + This extension differs from the EXT_422_pixels extension in a couple of + ways. First, this extension defines only a single new format, while + relying on two new type arguments to differentiate between the two + component orderings. Second, this extension provides no defined method + of filtering the chroma values between adjacent pixels. And lastly, + the color channel assignments are slightly different, essentially to + match more closely the rough meanings of the Y, Cb and Cr values in + 422 video data. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/APPLE/rgb_422.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.APPLE.rgb_422 import * +from OpenGL.raw.GLES2.APPLE.rgb_422 import _EXTENSION_NAME + +def glInitRgb422APPLE(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/APPLE/sync.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/APPLE/sync.py new file mode 100644 index 00000000..adc5f9a1 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/APPLE/sync.py @@ -0,0 +1,48 @@ +'''OpenGL extension APPLE.sync + +This module customises the behaviour of the +OpenGL.raw.GLES2.APPLE.sync to provide a more +Python-friendly API + +Overview (from the spec) + + This extension introduces the concept of "sync objects". Sync + objects are a synchronization primitive - a representation of events + whose completion status can be tested or waited upon. One specific + type of sync object, the "fence sync object", is supported in this + extension, and additional types can easily be added in the future. + + Fence sync objects have corresponding fences, which are inserted + into the OpenGL command stream at the time the sync object is + created. A sync object can be queried for a given condition. The + only condition supported for fence sync objects is completion of the + corresponding fence command. Fence completion allows applications to + request a partial Finish, wherein all commands prior to the fence + will be forced to complete before control is returned to the calling + process. + + These new mechanisms allow for synchronization between the host CPU + and the GPU, which may be accessing the same resources (typically + memory), as well as between multiple GL contexts bound to multiple + threads in the host CPU. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/APPLE/sync.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.APPLE.sync import * +from OpenGL.raw.GLES2.APPLE.sync import _EXTENSION_NAME + +def glInitSyncAPPLE(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glGetSyncivAPPLE.values size not checked against bufSize +glGetSyncivAPPLE=wrapper.wrapper(glGetSyncivAPPLE).setInputArraySize( + 'values', None +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/APPLE/texture_format_BGRA8888.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/APPLE/texture_format_BGRA8888.py new file mode 100644 index 00000000..11a14aae --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/APPLE/texture_format_BGRA8888.py @@ -0,0 +1,29 @@ +'''OpenGL extension APPLE.texture_format_BGRA8888 + +This module customises the behaviour of the +OpenGL.raw.GLES2.APPLE.texture_format_BGRA8888 to provide a more +Python-friendly API + +Overview (from the spec) + + This extension introduces BGRA_EXT as an acceptable external format. + This avoids byte swizzling when loading RGBA internal format + textures, which may be stored in BGRA order internally. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/APPLE/texture_format_BGRA8888.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.APPLE.texture_format_BGRA8888 import * +from OpenGL.raw.GLES2.APPLE.texture_format_BGRA8888 import _EXTENSION_NAME + +def glInitTextureFormatBgra8888APPLE(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/APPLE/texture_max_level.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/APPLE/texture_max_level.py new file mode 100644 index 00000000..f77be0a3 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/APPLE/texture_max_level.py @@ -0,0 +1,30 @@ +'''OpenGL extension APPLE.texture_max_level + +This module customises the behaviour of the +OpenGL.raw.GLES2.APPLE.texture_max_level to provide a more +Python-friendly API + +Overview (from the spec) + + This extension allows an application to specify the maximum (coarsest) + mipmap level that may be selected for the specified texture. This maximum + level is also used to determine which mip levels are considered when + determining texture completeness. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/APPLE/texture_max_level.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.APPLE.texture_max_level import * +from OpenGL.raw.GLES2.APPLE.texture_max_level import _EXTENSION_NAME + +def glInitTextureMaxLevelAPPLE(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/APPLE/texture_packed_float.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/APPLE/texture_packed_float.py new file mode 100644 index 00000000..c804e4e1 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/APPLE/texture_packed_float.py @@ -0,0 +1,45 @@ +'''OpenGL extension APPLE.texture_packed_float + +This module customises the behaviour of the +OpenGL.raw.GLES2.APPLE.texture_packed_float to provide a more +Python-friendly API + +Overview (from the spec) + + This extension adds two new 3-component floating-point texture formats + that fit within a single 32-bit word called R11F_G11F_B10F and RGB9_E5 + + The first RGB format, R11F_G11F_B10F, stores 5 bits of biased exponent + per component in the same manner as 16-bit floating-point formats, but + rather than 10 mantissa bits, the red, green, and blue components have + 6, 6, and 5 bits respectively. Each mantissa is assumed to have an + implied leading one except in the denorm exponent case. There is no + sign bit so only non-negative values can be represented. Positive + infinity, positivedenorms, and positive NaN values are representable. + The value of the fourth component returned by a texture fetch is always + 1.0. + + The second RGB format, RGB9_E5, stores a single 5-bit exponent (biased + up by 15) and three 9-bit mantissas for each respective component. + There is no sign bit so all three components must be non-negative. + The fractional mantissas are stored without an implied 1 to the left + of the decimal point. Neither infinity nor not-a-number (NaN) are + representable in this shared exponent format. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/APPLE/texture_packed_float.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.APPLE.texture_packed_float import * +from OpenGL.raw.GLES2.APPLE.texture_packed_float import _EXTENSION_NAME + +def glInitTexturePackedFloatAPPLE(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/ARM/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/ARM/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/ARM/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/ARM/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/ARM/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..5b99145f Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/ARM/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/ARM/__pycache__/mali_program_binary.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/ARM/__pycache__/mali_program_binary.cpython-312.pyc new file mode 100644 index 00000000..86b917a6 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/ARM/__pycache__/mali_program_binary.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/ARM/__pycache__/mali_shader_binary.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/ARM/__pycache__/mali_shader_binary.cpython-312.pyc new file mode 100644 index 00000000..cf0d6434 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/ARM/__pycache__/mali_shader_binary.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/ARM/__pycache__/rgba8.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/ARM/__pycache__/rgba8.cpython-312.pyc new file mode 100644 index 00000000..6ff70ae5 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/ARM/__pycache__/rgba8.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/ARM/__pycache__/shader_framebuffer_fetch.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/ARM/__pycache__/shader_framebuffer_fetch.cpython-312.pyc new file mode 100644 index 00000000..09d29ce6 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/ARM/__pycache__/shader_framebuffer_fetch.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/ARM/__pycache__/shader_framebuffer_fetch_depth_stencil.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/ARM/__pycache__/shader_framebuffer_fetch_depth_stencil.cpython-312.pyc new file mode 100644 index 00000000..113b2158 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/ARM/__pycache__/shader_framebuffer_fetch_depth_stencil.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/ARM/mali_program_binary.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/ARM/mali_program_binary.py new file mode 100644 index 00000000..59d79497 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/ARM/mali_program_binary.py @@ -0,0 +1,34 @@ +'''OpenGL extension ARM.mali_program_binary + +This module customises the behaviour of the +OpenGL.raw.GLES2.ARM.mali_program_binary to provide a more +Python-friendly API + +Overview (from the spec) + + The OES_get_program_binary extension enables applications to retrieve program + binaries using GetProgramBinaryOES and reload them using ProgramBinaryOES. + + The mechanism for retrieval and reloading of program binaries is vendor + agnostic, but the binary format itself is vendor specific. + + This extension adds a token to identify program binaries that are + compatible with the ARM Mali family of GPUs. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARM/mali_program_binary.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.ARM.mali_program_binary import * +from OpenGL.raw.GLES2.ARM.mali_program_binary import _EXTENSION_NAME + +def glInitMaliProgramBinaryARM(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/ARM/mali_shader_binary.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/ARM/mali_shader_binary.py new file mode 100644 index 00000000..52fd1a60 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/ARM/mali_shader_binary.py @@ -0,0 +1,34 @@ +'''OpenGL extension ARM.mali_shader_binary + +This module customises the behaviour of the +OpenGL.raw.GLES2.ARM.mali_shader_binary to provide a more +Python-friendly API + +Overview (from the spec) + + This extension enables OpenGL ES 2.0 applications running on ARM + Mali graphics cores to use shaders precompiled with the Mali ESSL + shader compiler. + + The shader objects loaded with this extension are equivalent to + shaders created from source, i.e. there are no additional + restrictions on which other shader objects they can be linked to, + nor on which OpenGL ES states they can be used with. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARM/mali_shader_binary.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.ARM.mali_shader_binary import * +from OpenGL.raw.GLES2.ARM.mali_shader_binary import _EXTENSION_NAME + +def glInitMaliShaderBinaryARM(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/ARM/rgba8.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/ARM/rgba8.py new file mode 100644 index 00000000..0e73d27e --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/ARM/rgba8.py @@ -0,0 +1,28 @@ +'''OpenGL extension ARM.rgba8 + +This module customises the behaviour of the +OpenGL.raw.GLES2.ARM.rgba8 to provide a more +Python-friendly API + +Overview (from the spec) + + This extension enables a RGBA8 renderbuffer storage format. + It is similar to OES_rgb8_rgba8, but only exposes RGBA8. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARM/rgba8.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.ARM.rgba8 import * +from OpenGL.raw.GLES2.ARM.rgba8 import _EXTENSION_NAME + +def glInitRgba8ARM(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/ARM/shader_framebuffer_fetch.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/ARM/shader_framebuffer_fetch.py new file mode 100644 index 00000000..db4872eb --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/ARM/shader_framebuffer_fetch.py @@ -0,0 +1,37 @@ +'''OpenGL extension ARM.shader_framebuffer_fetch + +This module customises the behaviour of the +OpenGL.raw.GLES2.ARM.shader_framebuffer_fetch to provide a more +Python-friendly API + +Overview (from the spec) + + This extension enables fragment shaders to read existing framebuffer + data as input. This permits use-cases such as programmable blending, + and other operations that may not be possible to implement with + fixed-function blending. + + This extension also adds the ability to indicate that a shader should + be run once per sample instead of once per pixel. + + Reading framebuffer data as input in combination with multiple render + targets (MRT) may not be supported by all implementations. This + extension allows applications to query for this capability. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARM/shader_framebuffer_fetch.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.ARM.shader_framebuffer_fetch import * +from OpenGL.raw.GLES2.ARM.shader_framebuffer_fetch import _EXTENSION_NAME + +def glInitShaderFramebufferFetchARM(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/ARM/shader_framebuffer_fetch_depth_stencil.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/ARM/shader_framebuffer_fetch_depth_stencil.py new file mode 100644 index 00000000..4fff7797 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/ARM/shader_framebuffer_fetch_depth_stencil.py @@ -0,0 +1,38 @@ +'''OpenGL extension ARM.shader_framebuffer_fetch_depth_stencil + +This module customises the behaviour of the +OpenGL.raw.GLES2.ARM.shader_framebuffer_fetch_depth_stencil to provide a more +Python-friendly API + +Overview (from the spec) + + Existing extensions, such as EXT_shader_framebuffer_fetch, allow fragment + shaders to read existing framebuffer color data as input. This enables + use-cases such as programmable blending, and other operations that may not + be possible to implement with fixed-function blending. + + This extension adds similar capabilities for depth and stencil values. + + One use-case for this is soft depth-blending of particles. Normally, this + would require two render passes: one that writes out the depth values of the + background geometry to a depth texture, and one that renders the particles + while reading from the depth texture to do the blending. This extension + allows this to be done in a single pass. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARM/shader_framebuffer_fetch_depth_stencil.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.ARM.shader_framebuffer_fetch_depth_stencil import * +from OpenGL.raw.GLES2.ARM.shader_framebuffer_fetch_depth_stencil import _EXTENSION_NAME + +def glInitShaderFramebufferFetchDepthStencilARM(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/DMP/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/DMP/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/DMP/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/DMP/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/DMP/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..aa6ab482 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/DMP/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/DMP/__pycache__/program_binary.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/DMP/__pycache__/program_binary.cpython-312.pyc new file mode 100644 index 00000000..29fb0084 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/DMP/__pycache__/program_binary.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/DMP/__pycache__/shader_binary.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/DMP/__pycache__/shader_binary.cpython-312.pyc new file mode 100644 index 00000000..b19a6c73 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/DMP/__pycache__/shader_binary.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/DMP/program_binary.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/DMP/program_binary.py new file mode 100644 index 00000000..fd6d0796 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/DMP/program_binary.py @@ -0,0 +1,28 @@ +'''OpenGL extension DMP.program_binary + +This module customises the behaviour of the +OpenGL.raw.GLES2.DMP.program_binary to provide a more +Python-friendly API + +Overview (from the spec) + + This extension enables loading precompiled program binaries compatible with + chips designed by Digital Media Professionals Inc. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/DMP/program_binary.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.DMP.program_binary import * +from OpenGL.raw.GLES2.DMP.program_binary import _EXTENSION_NAME + +def glInitProgramBinaryDMP(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/DMP/shader_binary.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/DMP/shader_binary.py new file mode 100644 index 00000000..9446e5d0 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/DMP/shader_binary.py @@ -0,0 +1,28 @@ +'''OpenGL extension DMP.shader_binary + +This module customises the behaviour of the +OpenGL.raw.GLES2.DMP.shader_binary to provide a more +Python-friendly API + +Overview (from the spec) + + This extension enables loading precompiled binary shaders compatible with + chips designed by Digital Media Professionals Inc. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/DMP/shader_binary.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.DMP.shader_binary import * +from OpenGL.raw.GLES2.DMP.shader_binary import _EXTENSION_NAME + +def glInitShaderBinaryDMP(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/ES/VERSION_3_2.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/ES/VERSION_3_2.py new file mode 100644 index 00000000..34fb09e2 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/ES/VERSION_3_2.py @@ -0,0 +1,124 @@ +'''OpenGL extension ES.VERSION_3_2 + +This module customises the behaviour of the +OpenGL.raw.GLES2.ES.VERSION_3_2 to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ES/VERSION_3_2.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.ES.VERSION_3_2 import * +from OpenGL.raw.GLES2.ES.VERSION_3_2 import _EXTENSION_NAME + +def glInitVersion32ES(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glDebugMessageControl.ids size not checked against count +glDebugMessageControl=wrapper.wrapper(glDebugMessageControl).setInputArraySize( + 'ids', None +) +# INPUT glDebugMessageInsert.buf size not checked against 'buf,length' +glDebugMessageInsert=wrapper.wrapper(glDebugMessageInsert).setInputArraySize( + 'buf', None +) +glGetDebugMessageLog=wrapper.wrapper(glGetDebugMessageLog).setOutput( + 'ids',size=lambda x:(x,),pnameArg='count',orPassIn=True +).setOutput( + 'lengths',size=lambda x:(x,),pnameArg='count',orPassIn=True +).setOutput( + 'messageLog',size=lambda x:(x,),pnameArg='bufSize',orPassIn=True +).setOutput( + 'severities',size=lambda x:(x,),pnameArg='count',orPassIn=True +).setOutput( + 'sources',size=lambda x:(x,),pnameArg='count',orPassIn=True +).setOutput( + 'types',size=lambda x:(x,),pnameArg='count',orPassIn=True +) +# INPUT glPushDebugGroup.message size not checked against 'message,length' +glPushDebugGroup=wrapper.wrapper(glPushDebugGroup).setInputArraySize( + 'message', None +) +# INPUT glObjectLabel.label size not checked against 'label,length' +glObjectLabel=wrapper.wrapper(glObjectLabel).setInputArraySize( + 'label', None +) +glGetObjectLabel=wrapper.wrapper(glGetObjectLabel).setOutput( + 'label',size=lambda x:(x,),pnameArg='bufSize',orPassIn=True +).setOutput( + 'length',size=(1,),orPassIn=True +) +# INPUT glObjectPtrLabel.label size not checked against 'label,length' +glObjectPtrLabel=wrapper.wrapper(glObjectPtrLabel).setInputArraySize( + 'label', None +) +glGetObjectPtrLabel=wrapper.wrapper(glGetObjectPtrLabel).setOutput( + 'label',size=lambda x:(x,),pnameArg='bufSize',orPassIn=True +).setOutput( + 'length',size=(1,),orPassIn=True +) +glGetPointerv=wrapper.wrapper(glGetPointerv).setOutput( + 'params',size=(1,),orPassIn=True +) +# INPUT glDrawElementsBaseVertex.indices size not checked against 'count,type' +glDrawElementsBaseVertex=wrapper.wrapper(glDrawElementsBaseVertex).setInputArraySize( + 'indices', None +) +# INPUT glDrawRangeElementsBaseVertex.indices size not checked against 'count,type' +glDrawRangeElementsBaseVertex=wrapper.wrapper(glDrawRangeElementsBaseVertex).setInputArraySize( + 'indices', None +) +# INPUT glDrawElementsInstancedBaseVertex.indices size not checked against 'count,type' +glDrawElementsInstancedBaseVertex=wrapper.wrapper(glDrawElementsInstancedBaseVertex).setInputArraySize( + 'indices', None +) +# INPUT glReadnPixels.data size not checked against bufSize +glReadnPixels=wrapper.wrapper(glReadnPixels).setInputArraySize( + 'data', None +) +# INPUT glGetnUniformfv.params size not checked against bufSize +glGetnUniformfv=wrapper.wrapper(glGetnUniformfv).setInputArraySize( + 'params', None +) +# INPUT glGetnUniformiv.params size not checked against bufSize +glGetnUniformiv=wrapper.wrapper(glGetnUniformiv).setInputArraySize( + 'params', None +) +# INPUT glGetnUniformuiv.params size not checked against bufSize +glGetnUniformuiv=wrapper.wrapper(glGetnUniformuiv).setInputArraySize( + 'params', None +) +# INPUT glTexParameterIiv.params size not checked against 'pname' +glTexParameterIiv=wrapper.wrapper(glTexParameterIiv).setInputArraySize( + 'params', None +) +# INPUT glTexParameterIuiv.params size not checked against 'pname' +glTexParameterIuiv=wrapper.wrapper(glTexParameterIuiv).setInputArraySize( + 'params', None +) +glGetTexParameterIiv=wrapper.wrapper(glGetTexParameterIiv).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetTexParameterIuiv=wrapper.wrapper(glGetTexParameterIuiv).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +# INPUT glSamplerParameterIiv.param size not checked against 'pname' +glSamplerParameterIiv=wrapper.wrapper(glSamplerParameterIiv).setInputArraySize( + 'param', None +) +# INPUT glSamplerParameterIuiv.param size not checked against 'pname' +glSamplerParameterIuiv=wrapper.wrapper(glSamplerParameterIuiv).setInputArraySize( + 'param', None +) +glGetSamplerParameterIiv=wrapper.wrapper(glGetSamplerParameterIiv).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetSamplerParameterIuiv=wrapper.wrapper(glGetSamplerParameterIuiv).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/ES/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/ES/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/ES/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/ES/__pycache__/VERSION_3_2.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/ES/__pycache__/VERSION_3_2.cpython-312.pyc new file mode 100644 index 00000000..4599a174 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/ES/__pycache__/VERSION_3_2.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/ES/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/ES/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..02a06ef3 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/ES/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/EGL_image_array.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/EGL_image_array.py new file mode 100644 index 00000000..80d5abbb --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/EGL_image_array.py @@ -0,0 +1,34 @@ +'''OpenGL extension EXT.EGL_image_array + +This module customises the behaviour of the +OpenGL.raw.GLES2.EXT.EGL_image_array to provide a more +Python-friendly API + +Overview (from the spec) + + This extension adds functionality to that provided by OES_EGL_image in + order to support EGLImage 2D arrays. It extends the existing + EGLImageTargetTexture2DOES entry point from OES_EGL_image. Render buffers + are not extended to include array support. + + EGLImage 2D arrays can be created using extended versions of eglCreateImageKHR. + For example, EGL_ANDROID_image_native_buffer can import image array native buffers + on devices where such native buffers can be created. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/EGL_image_array.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.EXT.EGL_image_array import * +from OpenGL.raw.GLES2.EXT.EGL_image_array import _EXTENSION_NAME + +def glInitEglImageArrayEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/EGL_image_storage.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/EGL_image_storage.py new file mode 100644 index 00000000..8d6c346f --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/EGL_image_storage.py @@ -0,0 +1,45 @@ +'''OpenGL extension EXT.EGL_image_storage + +This module customises the behaviour of the +OpenGL.raw.GLES2.EXT.EGL_image_storage to provide a more +Python-friendly API + +Overview (from the spec) + + The OpenGL ES extension OES_EGL_image provides a mechanism for creating + GL textures sharing storage with EGLImage objects (in other words, creating + GL texture EGLImage targets). The extension was written against the + OpenGL ES 2.0 specification, which does not have the concept of immutable + textures. As a result, it specifies that respecification of a texture by + calling TexImage* on a texture that is an EGLImage target causes it to be + implicitly orphaned. In most cases, this is not the desired behavior, but + rather a result of an application error. + + This extension provides a mechanism for creating texture objects that are + both EGLImage targets and immutable. Since immutable textures cannot be + respecified, they also cannot accidentally be orphaned, and attempts to do + so generate errors instead of resulting in well-defined, but often + undesirable and surprising behavior. It provides a strong guarantee that + texture data that is intended to be shared will remain shared. + + EGL extension specifications are located in the EGL Registry at + + http://www.khronos.org/registry/egl/ + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/EGL_image_storage.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.EXT.EGL_image_storage import * +from OpenGL.raw.GLES2.EXT.EGL_image_storage import _EXTENSION_NAME + +def glInitEglImageStorageEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/YUV_target.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/YUV_target.py new file mode 100644 index 00000000..a272a7fb --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/YUV_target.py @@ -0,0 +1,41 @@ +'''OpenGL extension EXT.YUV_target + +This module customises the behaviour of the +OpenGL.raw.GLES2.EXT.YUV_target to provide a more +Python-friendly API + +Overview (from the spec) + + This extension adds support for three new YUV related items: first + rendering to YUV images, second sampling from YUV images while keeping the + data in YUV space, third it defines a new built in function that does + conversion from RGB to YUV with controls to choose ITU-R BT.601-7, + ITU-R BT.601-7 Full range (JFIF images), or ITU-R BT.709-5 standard. + + This new functionality is layered on top of the OES_EGL_image_external + extension. + + To perform the YUV rendering capability in this extension an application + will attach a texture to the framebuffer object as the color attachment. + If the texture has a target type of TEXTURE_EXTERNAL_OES with YUV color + format then the GL driver can use this framebuffer object as the render + target, TEXTURE_EXTERNAL_OES target with RGB color format are not allowed + with this extension. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/YUV_target.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.EXT.YUV_target import * +from OpenGL.raw.GLES2.EXT.YUV_target import _EXTENSION_NAME + +def glInitYuvTargetEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/EGL_image_array.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/EGL_image_array.cpython-312.pyc new file mode 100644 index 00000000..3441277d Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/EGL_image_array.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/EGL_image_storage.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/EGL_image_storage.cpython-312.pyc new file mode 100644 index 00000000..a0ea2707 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/EGL_image_storage.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/YUV_target.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/YUV_target.cpython-312.pyc new file mode 100644 index 00000000..210f8e6f Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/YUV_target.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..926402ef Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/base_instance.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/base_instance.cpython-312.pyc new file mode 100644 index 00000000..4147fa46 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/base_instance.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/blend_func_extended.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/blend_func_extended.cpython-312.pyc new file mode 100644 index 00000000..a4562aa5 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/blend_func_extended.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/blend_minmax.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/blend_minmax.cpython-312.pyc new file mode 100644 index 00000000..f9eb58c5 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/blend_minmax.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/buffer_storage.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/buffer_storage.cpython-312.pyc new file mode 100644 index 00000000..2b86a547 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/buffer_storage.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/clear_texture.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/clear_texture.cpython-312.pyc new file mode 100644 index 00000000..e119e890 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/clear_texture.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/clip_control.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/clip_control.cpython-312.pyc new file mode 100644 index 00000000..30e6ef38 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/clip_control.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/clip_cull_distance.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/clip_cull_distance.cpython-312.pyc new file mode 100644 index 00000000..ec38d8ce Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/clip_cull_distance.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/color_buffer_float.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/color_buffer_float.cpython-312.pyc new file mode 100644 index 00000000..39e6d2ef Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/color_buffer_float.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/color_buffer_half_float.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/color_buffer_half_float.cpython-312.pyc new file mode 100644 index 00000000..cab20320 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/color_buffer_half_float.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/conservative_depth.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/conservative_depth.cpython-312.pyc new file mode 100644 index 00000000..e0cea549 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/conservative_depth.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/copy_image.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/copy_image.cpython-312.pyc new file mode 100644 index 00000000..b0aede64 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/copy_image.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/debug_label.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/debug_label.cpython-312.pyc new file mode 100644 index 00000000..460a4afc Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/debug_label.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/debug_marker.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/debug_marker.cpython-312.pyc new file mode 100644 index 00000000..28159392 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/debug_marker.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/depth_clamp.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/depth_clamp.cpython-312.pyc new file mode 100644 index 00000000..3a5413ad Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/depth_clamp.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/discard_framebuffer.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/discard_framebuffer.cpython-312.pyc new file mode 100644 index 00000000..0717a79f Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/discard_framebuffer.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/disjoint_timer_query.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/disjoint_timer_query.cpython-312.pyc new file mode 100644 index 00000000..fd081cfd Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/disjoint_timer_query.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/draw_buffers.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/draw_buffers.cpython-312.pyc new file mode 100644 index 00000000..96d5464a Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/draw_buffers.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/draw_buffers_indexed.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/draw_buffers_indexed.cpython-312.pyc new file mode 100644 index 00000000..0094f026 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/draw_buffers_indexed.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/draw_elements_base_vertex.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/draw_elements_base_vertex.cpython-312.pyc new file mode 100644 index 00000000..dc705a36 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/draw_elements_base_vertex.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/draw_instanced.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/draw_instanced.cpython-312.pyc new file mode 100644 index 00000000..7364fc5f Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/draw_instanced.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/draw_transform_feedback.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/draw_transform_feedback.cpython-312.pyc new file mode 100644 index 00000000..b9be945c Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/draw_transform_feedback.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/external_buffer.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/external_buffer.cpython-312.pyc new file mode 100644 index 00000000..733117b3 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/external_buffer.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/float_blend.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/float_blend.cpython-312.pyc new file mode 100644 index 00000000..ca2c4aa1 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/float_blend.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/geometry_point_size.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/geometry_point_size.cpython-312.pyc new file mode 100644 index 00000000..4c05cfe4 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/geometry_point_size.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/geometry_shader.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/geometry_shader.cpython-312.pyc new file mode 100644 index 00000000..c9f9b9bf Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/geometry_shader.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/gpu_shader5.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/gpu_shader5.cpython-312.pyc new file mode 100644 index 00000000..71e20fa0 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/gpu_shader5.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/instanced_arrays.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/instanced_arrays.cpython-312.pyc new file mode 100644 index 00000000..6bd5de8d Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/instanced_arrays.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/map_buffer_range.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/map_buffer_range.cpython-312.pyc new file mode 100644 index 00000000..b3074036 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/map_buffer_range.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/memory_object.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/memory_object.cpython-312.pyc new file mode 100644 index 00000000..c18a18dc Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/memory_object.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/memory_object_fd.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/memory_object_fd.cpython-312.pyc new file mode 100644 index 00000000..d7568857 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/memory_object_fd.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/memory_object_win32.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/memory_object_win32.cpython-312.pyc new file mode 100644 index 00000000..4fe255a5 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/memory_object_win32.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/multi_draw_arrays.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/multi_draw_arrays.cpython-312.pyc new file mode 100644 index 00000000..c7088bb6 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/multi_draw_arrays.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/multi_draw_indirect.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/multi_draw_indirect.cpython-312.pyc new file mode 100644 index 00000000..0f4f49af Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/multi_draw_indirect.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/multisampled_compatibility.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/multisampled_compatibility.cpython-312.pyc new file mode 100644 index 00000000..ae8a4e35 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/multisampled_compatibility.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/multisampled_render_to_texture.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/multisampled_render_to_texture.cpython-312.pyc new file mode 100644 index 00000000..f4812544 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/multisampled_render_to_texture.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/multiview_draw_buffers.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/multiview_draw_buffers.cpython-312.pyc new file mode 100644 index 00000000..196a4327 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/multiview_draw_buffers.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/multiview_tessellation_geometry_shader.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/multiview_tessellation_geometry_shader.cpython-312.pyc new file mode 100644 index 00000000..37d38431 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/multiview_tessellation_geometry_shader.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/multiview_texture_multisample.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/multiview_texture_multisample.cpython-312.pyc new file mode 100644 index 00000000..6a6e6064 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/multiview_texture_multisample.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/multiview_timer_query.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/multiview_timer_query.cpython-312.pyc new file mode 100644 index 00000000..23b3bb85 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/multiview_timer_query.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/occlusion_query_boolean.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/occlusion_query_boolean.cpython-312.pyc new file mode 100644 index 00000000..ad7ff35a Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/occlusion_query_boolean.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/polygon_offset_clamp.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/polygon_offset_clamp.cpython-312.pyc new file mode 100644 index 00000000..48646d31 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/polygon_offset_clamp.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/post_depth_coverage.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/post_depth_coverage.cpython-312.pyc new file mode 100644 index 00000000..2fcd10e0 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/post_depth_coverage.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/primitive_bounding_box.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/primitive_bounding_box.cpython-312.pyc new file mode 100644 index 00000000..03995933 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/primitive_bounding_box.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/protected_textures.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/protected_textures.cpython-312.pyc new file mode 100644 index 00000000..fe2f1d80 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/protected_textures.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/pvrtc_sRGB.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/pvrtc_sRGB.cpython-312.pyc new file mode 100644 index 00000000..c8995fdf Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/pvrtc_sRGB.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/raster_multisample.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/raster_multisample.cpython-312.pyc new file mode 100644 index 00000000..570a10c4 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/raster_multisample.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/read_format_bgra.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/read_format_bgra.cpython-312.pyc new file mode 100644 index 00000000..ca7b5b8f Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/read_format_bgra.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/render_snorm.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/render_snorm.cpython-312.pyc new file mode 100644 index 00000000..5c01eb34 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/render_snorm.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/robustness.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/robustness.cpython-312.pyc new file mode 100644 index 00000000..64458588 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/robustness.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/sRGB.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/sRGB.cpython-312.pyc new file mode 100644 index 00000000..80da77c7 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/sRGB.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/sRGB_write_control.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/sRGB_write_control.cpython-312.pyc new file mode 100644 index 00000000..10035f75 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/sRGB_write_control.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/semaphore.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/semaphore.cpython-312.pyc new file mode 100644 index 00000000..1e382403 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/semaphore.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/semaphore_fd.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/semaphore_fd.cpython-312.pyc new file mode 100644 index 00000000..ae9be83b Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/semaphore_fd.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/semaphore_win32.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/semaphore_win32.cpython-312.pyc new file mode 100644 index 00000000..cee1fe67 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/semaphore_win32.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/separate_shader_objects.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/separate_shader_objects.cpython-312.pyc new file mode 100644 index 00000000..76c89ad0 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/separate_shader_objects.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/shader_framebuffer_fetch.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/shader_framebuffer_fetch.cpython-312.pyc new file mode 100644 index 00000000..800b317a Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/shader_framebuffer_fetch.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/shader_framebuffer_fetch_non_coherent.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/shader_framebuffer_fetch_non_coherent.cpython-312.pyc new file mode 100644 index 00000000..b831487c Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/shader_framebuffer_fetch_non_coherent.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/shader_group_vote.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/shader_group_vote.cpython-312.pyc new file mode 100644 index 00000000..28e05043 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/shader_group_vote.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/shader_implicit_conversions.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/shader_implicit_conversions.cpython-312.pyc new file mode 100644 index 00000000..92edc3c3 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/shader_implicit_conversions.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/shader_integer_mix.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/shader_integer_mix.cpython-312.pyc new file mode 100644 index 00000000..9ff15c6e Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/shader_integer_mix.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/shader_io_blocks.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/shader_io_blocks.cpython-312.pyc new file mode 100644 index 00000000..516ff66a Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/shader_io_blocks.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/shader_non_constant_global_initializers.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/shader_non_constant_global_initializers.cpython-312.pyc new file mode 100644 index 00000000..6d8cabda Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/shader_non_constant_global_initializers.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/shader_pixel_local_storage.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/shader_pixel_local_storage.cpython-312.pyc new file mode 100644 index 00000000..dd6c31dc Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/shader_pixel_local_storage.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/shader_pixel_local_storage2.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/shader_pixel_local_storage2.cpython-312.pyc new file mode 100644 index 00000000..28760e18 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/shader_pixel_local_storage2.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/shader_texture_lod.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/shader_texture_lod.cpython-312.pyc new file mode 100644 index 00000000..9a980fe6 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/shader_texture_lod.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/shadow_samplers.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/shadow_samplers.cpython-312.pyc new file mode 100644 index 00000000..6c39f8af Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/shadow_samplers.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/sparse_texture.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/sparse_texture.cpython-312.pyc new file mode 100644 index 00000000..c82a04aa Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/sparse_texture.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/sparse_texture2.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/sparse_texture2.cpython-312.pyc new file mode 100644 index 00000000..e301eb1a Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/sparse_texture2.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/tessellation_point_size.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/tessellation_point_size.cpython-312.pyc new file mode 100644 index 00000000..041d8185 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/tessellation_point_size.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/tessellation_shader.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/tessellation_shader.cpython-312.pyc new file mode 100644 index 00000000..1311d555 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/tessellation_shader.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/texture_border_clamp.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/texture_border_clamp.cpython-312.pyc new file mode 100644 index 00000000..f1b16aef Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/texture_border_clamp.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/texture_buffer.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/texture_buffer.cpython-312.pyc new file mode 100644 index 00000000..1abf1963 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/texture_buffer.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/texture_compression_astc_decode_mode.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/texture_compression_astc_decode_mode.cpython-312.pyc new file mode 100644 index 00000000..17e50890 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/texture_compression_astc_decode_mode.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/texture_compression_bptc.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/texture_compression_bptc.cpython-312.pyc new file mode 100644 index 00000000..6f8c6313 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/texture_compression_bptc.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/texture_compression_dxt1.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/texture_compression_dxt1.cpython-312.pyc new file mode 100644 index 00000000..3e9d8a2c Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/texture_compression_dxt1.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/texture_compression_rgtc.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/texture_compression_rgtc.cpython-312.pyc new file mode 100644 index 00000000..0f6bd955 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/texture_compression_rgtc.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/texture_compression_s3tc.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/texture_compression_s3tc.cpython-312.pyc new file mode 100644 index 00000000..1a47e816 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/texture_compression_s3tc.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/texture_compression_s3tc_srgb.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/texture_compression_s3tc_srgb.cpython-312.pyc new file mode 100644 index 00000000..08a446cc Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/texture_compression_s3tc_srgb.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/texture_cube_map_array.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/texture_cube_map_array.cpython-312.pyc new file mode 100644 index 00000000..855c1dab Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/texture_cube_map_array.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/texture_filter_anisotropic.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/texture_filter_anisotropic.cpython-312.pyc new file mode 100644 index 00000000..d6781674 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/texture_filter_anisotropic.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/texture_filter_minmax.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/texture_filter_minmax.cpython-312.pyc new file mode 100644 index 00000000..f2e287aa Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/texture_filter_minmax.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/texture_format_BGRA8888.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/texture_format_BGRA8888.cpython-312.pyc new file mode 100644 index 00000000..7f4a237d Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/texture_format_BGRA8888.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/texture_format_sRGB_override.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/texture_format_sRGB_override.cpython-312.pyc new file mode 100644 index 00000000..406b4c05 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/texture_format_sRGB_override.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/texture_mirror_clamp_to_edge.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/texture_mirror_clamp_to_edge.cpython-312.pyc new file mode 100644 index 00000000..9b6873a5 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/texture_mirror_clamp_to_edge.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/texture_norm16.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/texture_norm16.cpython-312.pyc new file mode 100644 index 00000000..4427cf5b Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/texture_norm16.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/texture_query_lod.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/texture_query_lod.cpython-312.pyc new file mode 100644 index 00000000..ed385853 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/texture_query_lod.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/texture_rg.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/texture_rg.cpython-312.pyc new file mode 100644 index 00000000..7b80c1be Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/texture_rg.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/texture_sRGB_R8.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/texture_sRGB_R8.cpython-312.pyc new file mode 100644 index 00000000..278eb4ef Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/texture_sRGB_R8.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/texture_sRGB_RG8.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/texture_sRGB_RG8.cpython-312.pyc new file mode 100644 index 00000000..d4bc9e96 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/texture_sRGB_RG8.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/texture_sRGB_decode.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/texture_sRGB_decode.cpython-312.pyc new file mode 100644 index 00000000..5d0242ac Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/texture_sRGB_decode.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/texture_shadow_lod.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/texture_shadow_lod.cpython-312.pyc new file mode 100644 index 00000000..388d51fa Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/texture_shadow_lod.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/texture_storage.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/texture_storage.cpython-312.pyc new file mode 100644 index 00000000..1ad5ffa2 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/texture_storage.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/texture_type_2_10_10_10_REV.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/texture_type_2_10_10_10_REV.cpython-312.pyc new file mode 100644 index 00000000..d74ac13d Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/texture_type_2_10_10_10_REV.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/texture_view.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/texture_view.cpython-312.pyc new file mode 100644 index 00000000..6cae6d65 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/texture_view.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/unpack_subimage.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/unpack_subimage.cpython-312.pyc new file mode 100644 index 00000000..d973659c Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/unpack_subimage.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/win32_keyed_mutex.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/win32_keyed_mutex.cpython-312.pyc new file mode 100644 index 00000000..0ef9dcab Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/win32_keyed_mutex.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/window_rectangles.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/window_rectangles.cpython-312.pyc new file mode 100644 index 00000000..bd6410c2 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/__pycache__/window_rectangles.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/base_instance.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/base_instance.py new file mode 100644 index 00000000..b790656f --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/base_instance.py @@ -0,0 +1,50 @@ +'''OpenGL extension EXT.base_instance + +This module customises the behaviour of the +OpenGL.raw.GLES2.EXT.base_instance to provide a more +Python-friendly API + +Overview (from the spec) + + This extension allows the offset within buffer objects used for instanced + rendering to be specified. This is congruent with the parameter + in glDrawArrays and the parameter in glDrawElements. When + instanced rendering is performed (for example, through + glDrawArraysInstanced), instanced vertex attributes whose vertex attribute + divisors are non-zero are fetched from enabled vertex arrays per-instance + rather than per-vertex. However, in unextended OpenGL ES, there is no way + to define the offset into those arrays from which the attributes are + fetched. This extension adds that offset in the form of a + parameter to several new procedures. + + The parameter is added to the index of the array element, + after division by the vertex attribute divisor. This allows several sets of + instanced vertex attribute data to be stored in a single vertex array, and + the base offset of that data to be specified for each draw. Further, this + extension exposes the parameter as the final and previously + undefined structure member of the draw-indirect data structure. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/base_instance.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.EXT.base_instance import * +from OpenGL.raw.GLES2.EXT.base_instance import _EXTENSION_NAME + +def glInitBaseInstanceEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glDrawElementsInstancedBaseInstanceEXT.indices size not checked against count +glDrawElementsInstancedBaseInstanceEXT=wrapper.wrapper(glDrawElementsInstancedBaseInstanceEXT).setInputArraySize( + 'indices', None +) +# INPUT glDrawElementsInstancedBaseVertexBaseInstanceEXT.indices size not checked against count +glDrawElementsInstancedBaseVertexBaseInstanceEXT=wrapper.wrapper(glDrawElementsInstancedBaseVertexBaseInstanceEXT).setInputArraySize( + 'indices', None +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/blend_func_extended.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/blend_func_extended.py new file mode 100644 index 00000000..ea638dad --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/blend_func_extended.py @@ -0,0 +1,59 @@ +'''OpenGL extension EXT.blend_func_extended + +This module customises the behaviour of the +OpenGL.raw.GLES2.EXT.blend_func_extended to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides an ES version of the ARB_blend_func_extended + functionality. + + Traditional OpenGL includes fixed-function blending that combines + source colors with the existing content of a render buffer in + a variety of ways. A number of extensions have enhanced this + functionality by adding further sources of blending weights and + methods to combine them. However, the inputs to the fixed-function + blending units are constrained to a source color (as output from + fragment shading), destination color (as the current content of the + frame buffer) or constants that may be used in their place. + + This extension adds new blending functions whereby a fragment + shader may output two colors, one of which is treated as the + source color, and the other used as a blending factor for either + source or destination colors. Furthermore, this extension increases + orthogonality by allowing the SRC_ALPHA_SATURATE function to be used + as the destination weight. + + Because of the limitations of the OpenGL ES 2.0 shading language, + new built-in variables (gl_SecondaryFragColorEXT, + gl_SecondaryFragDataEXT) are added to the ES 1.00 shading language + rather than introduce more complex features for user-defined fragment + outputs. Because such built-in variable are deprecated in ES 3.0, + these variables are NOT available in the OpenGL ES 3.xx shading + language verisons. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/blend_func_extended.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.EXT.blend_func_extended import * +from OpenGL.raw.GLES2.EXT.blend_func_extended import _EXTENSION_NAME + +def glInitBlendFuncExtendedEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glBindFragDataLocationEXT.name size not checked against 'name' +glBindFragDataLocationEXT=wrapper.wrapper(glBindFragDataLocationEXT).setInputArraySize( + 'name', None +) +# INPUT glGetProgramResourceLocationIndexEXT.name size not checked against 'name' +glGetProgramResourceLocationIndexEXT=wrapper.wrapper(glGetProgramResourceLocationIndexEXT).setInputArraySize( + 'name', None +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/blend_minmax.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/blend_minmax.py new file mode 100644 index 00000000..d5aa2364 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/blend_minmax.py @@ -0,0 +1,35 @@ +'''OpenGL extension EXT.blend_minmax + +This module customises the behaviour of the +OpenGL.raw.GLES2.EXT.blend_minmax to provide a more +Python-friendly API + +Overview (from the spec) + + Blending capability is extended by respecifying the entire blend + equation. While this document defines only two new equations, the + BlendEquationEXT procedure that it defines will be used by subsequent + extensions to define additional blending equations. + + The two new equations defined by this extension produce the minimum + (or maximum) color components of the source and destination colors. + Taking the maximum is useful for applications such as maximum projection + in medical imaging. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/blend_minmax.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.EXT.blend_minmax import * +from OpenGL.raw.GLES2.EXT.blend_minmax import _EXTENSION_NAME + +def glInitBlendMinmaxEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/buffer_storage.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/buffer_storage.py new file mode 100644 index 00000000..206dcd40 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/buffer_storage.py @@ -0,0 +1,48 @@ +'''OpenGL extension EXT.buffer_storage + +This module customises the behaviour of the +OpenGL.raw.GLES2.EXT.buffer_storage to provide a more +Python-friendly API + +Overview (from the spec) + + OpenGL ES has long supported buffer objects as a means of storing data + that may be used to source vertex attributes, pixel data for textures, + uniforms and other elements. In un-extended ES, buffer data stores + are mutable - that is, they may be de-allocated or resized while they + are in use. The GL_EXT_texture_storage extension added immutable storage + for texture objects (and was subsequently incorporated into OpenGL ES 3.0). + This extension further applies the concept of immutable storage to + buffer objects. If an implementation is aware of a buffer's immutability, + it may be able to make certain assumptions or apply particular + optimizations in order to increase performance or reliability. + + Furthermore, this extension allows applications to pass additional + information about a requested allocation to the implementation which it + may use to select memory heaps, caching behavior or allocation strategies. + + Finally, this extension introduces the concept of persistent client + mappings of buffer objects, which allow clients to retain pointers to a + buffer's data store returned as the result of a mapping, and to issue + drawing commands while those mappings are in place. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/buffer_storage.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.EXT.buffer_storage import * +from OpenGL.raw.GLES2.EXT.buffer_storage import _EXTENSION_NAME + +def glInitBufferStorageEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glBufferStorageEXT.data size not checked against size +glBufferStorageEXT=wrapper.wrapper(glBufferStorageEXT).setInputArraySize( + 'data', None +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/clear_texture.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/clear_texture.py new file mode 100644 index 00000000..ec708889 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/clear_texture.py @@ -0,0 +1,59 @@ +'''OpenGL extension EXT.clear_texture + +This module customises the behaviour of the +OpenGL.raw.GLES2.EXT.clear_texture to provide a more +Python-friendly API + +Overview (from the spec) + + Texture objects are fundamental to the operation of OpenGL. They are + used as a source for texture sampling and destination for rendering + as well as being accessed in shaders for image load/store operations + It is also possible to invalidate the contents of a texture. It is + currently only possible to set texture image data to known values by + uploading some or all of a image array from application memory or by + attaching it to a framebuffer object and using the Clear or ClearBuffer + commands. + + Both uploading initial texture data and clearing by attaching to a + framebuffer have potential disadvantages when one simply wants to + initialize texture data to a known value. Uploading initial data + requires the application to allocate a (potentially large) chunk + of memory and transferring that to the GL. This can be a costly + operation both in terms of memory bandwidth and power usage. + Alternatively, attaching a texture level to a framebuffer to clear it + may not be possible if the texture format isn't supported for + rendering, or even if it is, attaching the image to a framebuffer object + may cause the texture to be allocated in certain types of memory, which + it may otherwise not need to be placed in. + + This extension solves these problems by providing a mechanism whereby + the contents of a texture image array can be set to known values by + using the ClearTexImageEXT or ClearTexSubImageEXT commands. These commands + can also be useful for initializing an image that will be used for + atomic shader operations. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/clear_texture.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.EXT.clear_texture import * +from OpenGL.raw.GLES2.EXT.clear_texture import _EXTENSION_NAME + +def glInitClearTextureEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glClearTexImageEXT.data size not checked against 'format,type' +glClearTexImageEXT=wrapper.wrapper(glClearTexImageEXT).setInputArraySize( + 'data', None +) +# INPUT glClearTexSubImageEXT.data size not checked against 'format,type' +glClearTexSubImageEXT=wrapper.wrapper(glClearTexSubImageEXT).setInputArraySize( + 'data', None +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/clip_control.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/clip_control.py new file mode 100644 index 00000000..43a5e2fb --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/clip_control.py @@ -0,0 +1,35 @@ +'''OpenGL extension EXT.clip_control + +This module customises the behaviour of the +OpenGL.raw.GLES2.EXT.clip_control to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides additional clip control modes to configure how + clip space is mapped to window space. This extension's goal is to 1) + allow OpenGL to effectively match Direct3D's coordinate system + conventions, and 2) potentially improve the numerical precision of the Z + coordinate mapping. + + This extension is a port of GL_ARB_clip_control to OpenGL ES. For the + complete overview of this extension, refer to the "Overview" section of + GL_ARB_clip_control. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/clip_control.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.EXT.clip_control import * +from OpenGL.raw.GLES2.EXT.clip_control import _EXTENSION_NAME + +def glInitClipControlEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/clip_cull_distance.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/clip_cull_distance.py new file mode 100644 index 00000000..b5314b55 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/clip_cull_distance.py @@ -0,0 +1,30 @@ +'''OpenGL extension EXT.clip_cull_distance + +This module customises the behaviour of the +OpenGL.raw.GLES2.EXT.clip_cull_distance to provide a more +Python-friendly API + +Overview (from the spec) + + This extension adds support for hardware clip planes and cull + distances to OpenGL ES. The language for this extension is based + on the OpenGL 4.5 API Specification (May 28, 2015) and + ARB_clip_distance. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/clip_cull_distance.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.EXT.clip_cull_distance import * +from OpenGL.raw.GLES2.EXT.clip_cull_distance import _EXTENSION_NAME + +def glInitClipCullDistanceEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/color_buffer_float.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/color_buffer_float.py new file mode 100644 index 00000000..b43d797c --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/color_buffer_float.py @@ -0,0 +1,28 @@ +'''OpenGL extension EXT.color_buffer_float + +This module customises the behaviour of the +OpenGL.raw.GLES2.EXT.color_buffer_float to provide a more +Python-friendly API + +Overview (from the spec) + + This extension allows a variety of floating point formats to be + rendered to via framebuffer objects. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/color_buffer_float.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.EXT.color_buffer_float import * +from OpenGL.raw.GLES2.EXT.color_buffer_float import _EXTENSION_NAME + +def glInitColorBufferFloatEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/color_buffer_half_float.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/color_buffer_half_float.py new file mode 100644 index 00000000..a37c8ad0 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/color_buffer_half_float.py @@ -0,0 +1,33 @@ +'''OpenGL extension EXT.color_buffer_half_float + +This module customises the behaviour of the +OpenGL.raw.GLES2.EXT.color_buffer_half_float to provide a more +Python-friendly API + +Overview (from the spec) + + This extension allows 16-bit floating point formats as defined in + OES_texture_half_float to be rendered to via framebuffer objects. + + When using floating-point formats, certain color clamps are disabled. + + This extension also updates the framebuffer object API to allow querying + attachment component types. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/color_buffer_half_float.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.EXT.color_buffer_half_float import * +from OpenGL.raw.GLES2.EXT.color_buffer_half_float import _EXTENSION_NAME + +def glInitColorBufferHalfFloatEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/conservative_depth.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/conservative_depth.py new file mode 100644 index 00000000..056f3bb9 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/conservative_depth.py @@ -0,0 +1,39 @@ +'''OpenGL extension EXT.conservative_depth + +This module customises the behaviour of the +OpenGL.raw.GLES2.EXT.conservative_depth to provide a more +Python-friendly API + +Overview (from the spec) + + There is a common optimization for hardware accelerated implementation of + OpenGL ES which relies on an early depth test to be run before the fragment + shader so that the shader evaluation can be skipped if the fragment ends + up being discarded because it is occluded. + + This optimization does not affect the final rendering, and is typically + possible when the fragment does not change the depth programmatically. + (i.e.: it does not write to the built-in gl_FragDepth output). There are, + however a class of operations on the depth in the shader which could + still be performed while allowing the early depth test to operate. + + This extension allows the application to pass enough information to the + GL implementation to activate such optimizations safely. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/conservative_depth.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.EXT.conservative_depth import * +from OpenGL.raw.GLES2.EXT.conservative_depth import _EXTENSION_NAME + +def glInitConservativeDepthEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/copy_image.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/copy_image.py new file mode 100644 index 00000000..8cfc44ae --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/copy_image.py @@ -0,0 +1,45 @@ +'''OpenGL extension EXT.copy_image + +This module customises the behaviour of the +OpenGL.raw.GLES2.EXT.copy_image to provide a more +Python-friendly API + +Overview (from the spec) + + This extension enables efficient image data transfer between image + objects (i.e. textures and renderbuffers) without the need to bind + the objects or otherwise configure the rendering pipeline. + + This is accomplised by adding a new entry-point CopyImageSubData, + which takes a named source and destination. + + CopyImageSubData does not perform general-purpose conversions + such as scaling, resizing, blending, color-space, or format + conversions. It should be considered to operate in a manner + similar to a CPU memcpy, but using the GPU for the copy. + + CopyImageSubData supports copies between images with different + internal formats, if the formats are compatible as described in + this extension. + + CopyImageSubData also supports copying between compressed and + uncompressed images if the compressed block / uncompressed texel + sizes are the same. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/copy_image.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.EXT.copy_image import * +from OpenGL.raw.GLES2.EXT.copy_image import _EXTENSION_NAME + +def glInitCopyImageEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/debug_label.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/debug_label.py new file mode 100644 index 00000000..76d04023 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/debug_label.py @@ -0,0 +1,43 @@ +'''OpenGL extension EXT.debug_label + +This module customises the behaviour of the +OpenGL.raw.GLES2.EXT.debug_label to provide a more +Python-friendly API + +Overview (from the spec) + + This extension defines a mechanism for OpenGL and OpenGL ES applications to + label their objects (textures, buffers, shaders, etc.) with a descriptive + string. + + When profiling or debugging such an application within a debugger or + profiler it is difficult to identify resources from their object names. + Even when the resource itself is viewed it can be problematic to + differentiate between similar resources. Attaching a label to an object + helps obviate this difficulty. + + The intended purpose of this is purely to improve the user experience + within OpenGL and OpenGL ES development tools. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/debug_label.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.EXT.debug_label import * +from OpenGL.raw.GLES2.EXT.debug_label import _EXTENSION_NAME + +def glInitDebugLabelEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glGetObjectLabelEXT.label size not checked against bufSize +glGetObjectLabelEXT=wrapper.wrapper(glGetObjectLabelEXT).setInputArraySize( + 'label', None +).setInputArraySize( + 'length', 1 +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/debug_marker.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/debug_marker.py new file mode 100644 index 00000000..dc0219c5 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/debug_marker.py @@ -0,0 +1,38 @@ +'''OpenGL extension EXT.debug_marker + +This module customises the behaviour of the +OpenGL.raw.GLES2.EXT.debug_marker to provide a more +Python-friendly API + +Overview (from the spec) + + This extension defines a mechanism for OpenGL and OpenGL ES applications to + annotate their command stream with markers for discrete events and groups + of commands using descriptive text markers. + + When profiling or debugging such an application within a debugger or + profiler it is difficult to relate the commands within the command stream + to the elements of the scene or parts of the program code to which they + correspond. Markers help obviate this by allowing applications to specify + this link. + + The intended purpose of this is purely to improve the user experience + within OpenGL and OpenGL ES development tools. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/debug_marker.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.EXT.debug_marker import * +from OpenGL.raw.GLES2.EXT.debug_marker import _EXTENSION_NAME + +def glInitDebugMarkerEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/depth_clamp.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/depth_clamp.py new file mode 100644 index 00000000..315dfb72 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/depth_clamp.py @@ -0,0 +1,54 @@ +'''OpenGL extension EXT.depth_clamp + +This module customises the behaviour of the +OpenGL.raw.GLES2.EXT.depth_clamp to provide a more +Python-friendly API + +Overview (from the spec) + + Conventional OpenGL clips geometric primitives to a clip volume + with six faces, two of which are the near and far clip planes. + Clipping to the near and far planes of the clip volume ensures that + interpolated depth values (after the depth range transform) must be + in the [0,1] range. + + In some rendering applications such as shadow volumes, it is useful + to allow line and polygon primitives to be rasterized without + clipping the primitive to the near or far clip volume planes (side + clip volume planes clip normally). Without the near and far clip + planes, rasterization (pixel coverage determination) in X and Y + can proceed normally if we ignore the near and far clip planes. + The one major issue is that fragments of a primitive may extend + beyond the conventional window space depth range for depth values + (typically the range [0,1]). Rather than discarding fragments that + defy the window space depth range (effectively what near and far + plane clipping accomplish), the depth values can be clamped to the + current depth range. + + This extension provides exactly such functionality. This + functionality is useful to obviate the need for near plane capping + of stenciled shadow volumes. The functionality may also be useful + for rendering geometry "beyond" the far plane if an alternative + algorithm (rather than depth testing) for hidden surface removal is + applied to such geometry (specifically, the painter's algorithm). + Similar situations at the near clip plane can be avoided at the + near clip plane where apparently solid objects can be "seen through" + if they intersect the near clip plane. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/depth_clamp.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.EXT.depth_clamp import * +from OpenGL.raw.GLES2.EXT.depth_clamp import _EXTENSION_NAME + +def glInitDepthClampEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/discard_framebuffer.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/discard_framebuffer.py new file mode 100644 index 00000000..904a8535 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/discard_framebuffer.py @@ -0,0 +1,52 @@ +'''OpenGL extension EXT.discard_framebuffer + +This module customises the behaviour of the +OpenGL.raw.GLES2.EXT.discard_framebuffer to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides a new command, DiscardFramebufferEXT, which + causes the contents of the named framebuffer attachable images to become + undefined. The contents of the specified buffers are undefined until a + subsequent operation modifies the content, and only the modified region + is guaranteed to hold valid content. Effective usage of this command + may provide an implementation with new optimization opportunities. + + Some OpenGL ES implementations cache framebuffer images in a small pool + of fast memory. Before rendering, these implementations must load the + existing contents of one or more of the logical buffers (color, depth, + stencil, etc.) into this memory. After rendering, some or all of these + buffers are likewise stored back to external memory so their contents can + be used again in the future. In many applications, some or all of the + logical buffers are cleared at the start of rendering. If so, the + effort to load or store those buffers is wasted. + + Even without this extension, if a frame of rendering begins with a full- + screen Clear, an OpenGL ES implementation may optimize away the loading + of framebuffer contents prior to rendering the frame. With this extension, + an application can use DiscardFramebufferEXT to signal that framebuffer + contents will no longer be needed. In this case an OpenGL ES + implementation may also optimize away the storing back of framebuffer + contents after rendering the frame. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/discard_framebuffer.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.EXT.discard_framebuffer import * +from OpenGL.raw.GLES2.EXT.discard_framebuffer import _EXTENSION_NAME + +def glInitDiscardFramebufferEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glDiscardFramebufferEXT.attachments size not checked against numAttachments +glDiscardFramebufferEXT=wrapper.wrapper(glDiscardFramebufferEXT).setInputArraySize( + 'attachments', None +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/disjoint_timer_query.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/disjoint_timer_query.py new file mode 100644 index 00000000..a01ff891 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/disjoint_timer_query.py @@ -0,0 +1,71 @@ +'''OpenGL extension EXT.disjoint_timer_query + +This module customises the behaviour of the +OpenGL.raw.GLES2.EXT.disjoint_timer_query to provide a more +Python-friendly API + +Overview (from the spec) + + Applications can benefit from accurate timing information in a number of + different ways. During application development, timing information can + help identify application or driver bottlenecks. At run time, + applications can use timing information to dynamically adjust the amount + of detail in a scene to achieve constant frame rates. OpenGL + implementations have historically provided little to no useful timing + information. Applications can get some idea of timing by reading timers + on the CPU, but these timers are not synchronized with the graphics + rendering pipeline. Reading a CPU timer does not guarantee the completion + of a potentially large amount of graphics work accumulated before the + timer is read, and will thus produce wildly inaccurate results. + glFinish() can be used to determine when previous rendering commands have + been completed, but will idle the graphics pipeline and adversely affect + application performance. + + This extension provides a query mechanism that can be used to determine + the amount of time it takes to fully complete a set of GL commands, and + without stalling the rendering pipeline. It uses the query object + mechanisms first introduced in the occlusion query extension, which allow + time intervals to be polled asynchronously by the application. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/disjoint_timer_query.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.EXT.disjoint_timer_query import * +from OpenGL.raw.GLES2.EXT.disjoint_timer_query import _EXTENSION_NAME + +def glInitDisjointTimerQueryEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glGenQueriesEXT.ids size not checked against n +glGenQueriesEXT=wrapper.wrapper(glGenQueriesEXT).setInputArraySize( + 'ids', None +) +# INPUT glDeleteQueriesEXT.ids size not checked against n +glDeleteQueriesEXT=wrapper.wrapper(glDeleteQueriesEXT).setInputArraySize( + 'ids', None +) +# INPUT glGetQueryivEXT.params size not checked against 'pname' +glGetQueryivEXT=wrapper.wrapper(glGetQueryivEXT).setInputArraySize( + 'params', None +) +# INPUT glGetQueryObjectivEXT.params size not checked against 'pname' +glGetQueryObjectivEXT=wrapper.wrapper(glGetQueryObjectivEXT).setInputArraySize( + 'params', None +) +# INPUT glGetQueryObjectuivEXT.params size not checked against 'pname' +glGetQueryObjectuivEXT=wrapper.wrapper(glGetQueryObjectuivEXT).setInputArraySize( + 'params', None +) +glGetQueryObjecti64vEXT=wrapper.wrapper(glGetQueryObjecti64vEXT).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetQueryObjectui64vEXT=wrapper.wrapper(glGetQueryObjectui64vEXT).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/draw_buffers.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/draw_buffers.py new file mode 100644 index 00000000..1b22d3ab --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/draw_buffers.py @@ -0,0 +1,53 @@ +'''OpenGL extension EXT.draw_buffers + +This module customises the behaviour of the +OpenGL.raw.GLES2.EXT.draw_buffers to provide a more +Python-friendly API + +Overview (from the spec) + + This extension increases the number of available framebuffer object + color attachment points, extends OpenGL ES 2.0 to allow multiple output + colors, and provides a mechanism for directing those outputs to + multiple color buffers. + + This extension is similar to the combination of the GL_NV_draw_buffers + and GL_NV_fbo_color_attachments extensions, but imposes certain + restrictions informed by the OpenGL ES 3.0 API. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/draw_buffers.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.EXT.draw_buffers import * +from OpenGL.raw.GLES2.EXT.draw_buffers import _EXTENSION_NAME + +def glInitDrawBuffersEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glDrawBuffersEXT.bufs size not checked against n +glDrawBuffersEXT=wrapper.wrapper(glDrawBuffersEXT).setInputArraySize( + 'bufs', None +) +### END AUTOGENERATED SECTION +from OpenGL.lazywrapper import lazy as _lazy + +@_lazy( glDrawBuffers ) +def glDrawBuffers( baseOperation, n=None, bufs=None ): + """glDrawBuffers( bufs ) -> bufs + + Wrapper will calculate n from dims of bufs if only + one argument is provided... + """ + if bufs is None: + bufs = n + n = None + bufs = arrays.GLenumArray.asArray( bufs ) + if n is None: + n = arrays.GLenumArray.arraySize( bufs ) + return baseOperation( n,bufs ) diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/draw_buffers_indexed.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/draw_buffers_indexed.py new file mode 100644 index 00000000..fadc9b38 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/draw_buffers_indexed.py @@ -0,0 +1,43 @@ +'''OpenGL extension EXT.draw_buffers_indexed + +This module customises the behaviour of the +OpenGL.raw.GLES2.EXT.draw_buffers_indexed to provide a more +Python-friendly API + +Overview (from the spec) + + This extension builds upon the EXT_draw_buffers extension. + In EXT_draw_buffers (part of OpenGL ES 3.0), separate values could + be written to each color buffer, but the blend enable, blend functions, + blend equations and color write masks are global and apply to all color + outputs. + + This extension provides the ability to independently + * enable or disable blending, + * set the blend equations, + * set the blend functions, and + * set the color write masks + per color output. + + This extension introduces indexed versions of the enable, + blend equation, blend function, and color mask commands, as + well as associated indexed queries in order to control and + query these states independently on a per-color output basis. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/draw_buffers_indexed.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.EXT.draw_buffers_indexed import * +from OpenGL.raw.GLES2.EXT.draw_buffers_indexed import _EXTENSION_NAME + +def glInitDrawBuffersIndexedEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/draw_elements_base_vertex.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/draw_elements_base_vertex.py new file mode 100644 index 00000000..a3878d23 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/draw_elements_base_vertex.py @@ -0,0 +1,101 @@ +'''OpenGL extension EXT.draw_elements_base_vertex + +This module customises the behaviour of the +OpenGL.raw.GLES2.EXT.draw_elements_base_vertex to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides a method to specify a "base vertex offset" + value which is effectively added to every vertex index that is + transferred through DrawElements. + + This mechanism can be used to decouple a set of indices from the + actual vertex array that it is referencing. This is useful if an + application stores multiple indexed models in a single vertex array. + The same index array can be used to draw the model no matter where + it ends up in a larger vertex array simply by changing the base + vertex value. Without this functionality, it would be necessary to + rebind all the vertex attributes every time geometry is switched and + this can have larger performance penalty. + + For example consider the (very contrived and simple) example of + drawing two triangles to form a quad. In the typical example you + have the following setup: + + vertices indices + ---------- ----- + 0 | (-1, 1) | 0 | 0 | + 1 | (-1, -1) | 1 | 1 | + 2 | ( 1, -1) | 2 | 2 | + 3 | ( 1, 1) | 3 | 3 | + ---------- 4 | 0 | + 5 | 2 | + ----- + which is normally rendered with the call + + DrawElements(TRIANGLES, 6, UNSIGNED_BYTE, &indices). + + Now consider the case where the vertices you want to draw are not at + the start of a vertex array but are instead located at offset 100 + into a larger array: + + vertices2 indices2 + ---------- ----- + .... 0 | 100 | + 100 | (-1, 1) | 1 | 101 | + 101 | (-1, -1) | 2 | 102 | + 102 | ( 1, -1) | 3 | 103 | + 103 | ( 1, 1) | 4 | 100 | + .... 5 | 102 | + ---------- ----- + + The typical choices for rendering this are to rebind your vertex + attributes with an additional offset of 100*stride, or to create an + new array of indices (as indices2 in the example). However both + rebinding vertex attributes and rebuilding index arrays can be quite + costly activities. + + With the new drawing commands introduced by this extension you can + instead draw using vertices2 and the new draw call: + + DrawElementsBaseVertexEXT(TRIANGLES, 6, UNSIGNED_BYTE, &indices, 100) + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/draw_elements_base_vertex.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.EXT.draw_elements_base_vertex import * +from OpenGL.raw.GLES2.EXT.draw_elements_base_vertex import _EXTENSION_NAME + +def glInitDrawElementsBaseVertexEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glDrawElementsBaseVertexEXT.indices size not checked against 'count,type' +glDrawElementsBaseVertexEXT=wrapper.wrapper(glDrawElementsBaseVertexEXT).setInputArraySize( + 'indices', None +) +# INPUT glDrawRangeElementsBaseVertexEXT.indices size not checked against 'count,type' +glDrawRangeElementsBaseVertexEXT=wrapper.wrapper(glDrawRangeElementsBaseVertexEXT).setInputArraySize( + 'indices', None +) +# INPUT glDrawElementsInstancedBaseVertexEXT.indices size not checked against 'count,type' +glDrawElementsInstancedBaseVertexEXT=wrapper.wrapper(glDrawElementsInstancedBaseVertexEXT).setInputArraySize( + 'indices', None +) +# INPUT glMultiDrawElementsBaseVertexEXT.basevertex size not checked against 'drawcount' +# INPUT glMultiDrawElementsBaseVertexEXT.count size not checked against 'drawcount' +# INPUT glMultiDrawElementsBaseVertexEXT.indices size not checked against 'drawcount' +glMultiDrawElementsBaseVertexEXT=wrapper.wrapper(glMultiDrawElementsBaseVertexEXT).setInputArraySize( + 'basevertex', None +).setInputArraySize( + 'count', None +).setInputArraySize( + 'indices', None +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/draw_instanced.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/draw_instanced.py new file mode 100644 index 00000000..5d5e72d3 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/draw_instanced.py @@ -0,0 +1,33 @@ +'''OpenGL extension EXT.draw_instanced + +This module customises the behaviour of the +OpenGL.raw.GLES2.EXT.draw_instanced to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides the means to render multiple instances of + an object with a single draw call, and an "instance ID" variable + which can be used by the vertex program to compute per-instance + values, typically an object's transform. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/draw_instanced.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.EXT.draw_instanced import * +from OpenGL.raw.GLES2.EXT.draw_instanced import _EXTENSION_NAME + +def glInitDrawInstancedEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glDrawElementsInstancedEXT.indices size not checked against 'count,type' +glDrawElementsInstancedEXT=wrapper.wrapper(glDrawElementsInstancedEXT).setInputArraySize( + 'indices', None +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/draw_transform_feedback.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/draw_transform_feedback.py new file mode 100644 index 00000000..cdd5b664 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/draw_transform_feedback.py @@ -0,0 +1,34 @@ +'''OpenGL extension EXT.draw_transform_feedback + +This module customises the behaviour of the +OpenGL.raw.GLES2.EXT.draw_transform_feedback to provide a more +Python-friendly API + +Overview (from the spec) + + This extension adds the DrawTransformFeedback commands. These + were omitted from OpenGL ES 3.0 because the number of vertices + captured by transform feedback could never be different than + the number drawn during capture. The addition of geometry shaders + in OpenGL ES 3.2 broke that assumption but, due to an oversight, + DrawTransformFeedback et al were not reinstated. The + DrawTransformFeedback commands unlock the full potential of + geometry shaders. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/draw_transform_feedback.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.EXT.draw_transform_feedback import * +from OpenGL.raw.GLES2.EXT.draw_transform_feedback import _EXTENSION_NAME + +def glInitDrawTransformFeedbackEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/external_buffer.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/external_buffer.py new file mode 100644 index 00000000..2e57ca98 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/external_buffer.py @@ -0,0 +1,62 @@ +'''OpenGL extension EXT.external_buffer + +This module customises the behaviour of the +OpenGL.raw.GLES2.EXT.external_buffer to provide a more +Python-friendly API + +Overview (from the spec) + + Extension EXT_buffer_storage introduced immutable storage buffers to + OpenGL ES. This extension allows the data store for an immutable buffer to + be sourced from an external EGLClientBuffer, allowing sharing of EGL client + buffers across APIs, across processes, and across different processing + cores such as the GPU, CPU, and DSP. + + Operations can then be performed on the external buffer using standard + GL buffer object procedures. The data in the allocation is not copied to + the buffer object's data store; the external allocation represents a single + memory allocation that can be shared across multiple GL objects -- this + aspect is similar to EGL external images. On the other hand, the external + buffer does not provide lifetime guarantees including orphaning and sibling + behavior as provided by EGL external images. + + The EGLClientBuffer must be allocated in a way which permits this shared + access. For example, on Android via a shareable Android hardware buffer. + This extension does not enable support for arbitrary EGLClientBuffers to be + used as an external buffer. + + It is the application's responsibility to ensure synchronization between + operations performed by separate components (DSP / CPU / GPU) and processes + on the external buffer. Additionally the application is responsible for + avoiding violating existing GL spec requirements. For example, mapping a + single shared allocation to two GL buffer objects and then performing + CopyBufferSubData such that the read and write regions overlap would + violate the existing CopyBufferSubData spec regarding copies performed + with the same buffer set for source and destination. + + The application must take any steps necessary to ensure memory access to + the external buffer behaves as required by the application. For example, + preventing compilation differences in data padding from causing data to be + inadvertently corrupted by using defined structure alignment methods such + as the std140 layout qualifier. The application is responsible for + managing the lifetime of the external buffer, ensuring that the external + buffer is not deleted as long as there are any GL buffer objects referring + to it. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/external_buffer.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.EXT.external_buffer import * +from OpenGL.raw.GLES2.EXT.external_buffer import _EXTENSION_NAME + +def glInitExternalBufferEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/float_blend.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/float_blend.py new file mode 100644 index 00000000..b109e6f8 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/float_blend.py @@ -0,0 +1,29 @@ +'''OpenGL extension EXT.float_blend + +This module customises the behaviour of the +OpenGL.raw.GLES2.EXT.float_blend to provide a more +Python-friendly API + +Overview (from the spec) + + This extension expands upon the EXT_color_buffer_float extension + to allow support for blending with 32-bit floating-point color + buffers. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/float_blend.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.EXT.float_blend import * +from OpenGL.raw.GLES2.EXT.float_blend import _EXTENSION_NAME + +def glInitFloatBlendEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/geometry_point_size.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/geometry_point_size.py new file mode 100644 index 00000000..e2623766 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/geometry_point_size.py @@ -0,0 +1,23 @@ +'''OpenGL extension EXT.geometry_point_size + +This module customises the behaviour of the +OpenGL.raw.GLES2.EXT.geometry_point_size to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/geometry_point_size.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.EXT.geometry_point_size import * +from OpenGL.raw.GLES2.EXT.geometry_point_size import _EXTENSION_NAME + +def glInitGeometryPointSizeEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/geometry_shader.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/geometry_shader.py new file mode 100644 index 00000000..b8d731af --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/geometry_shader.py @@ -0,0 +1,70 @@ +'''OpenGL extension EXT.geometry_shader + +This module customises the behaviour of the +OpenGL.raw.GLES2.EXT.geometry_shader to provide a more +Python-friendly API + +Overview (from the spec) + + EXT_geometry_shader defines a new shader type available to be run on the + GPU, called a geometry shader. Geometry shaders are run after vertices are + transformed, but prior to color clamping, flatshading and clipping. + + A geometry shader begins with a single primitive (point, line, + triangle). It can read the attributes of any of the vertices in the + primitive and use them to generate new primitives. A geometry shader has a + fixed output primitive type (point, line strip, or triangle strip) and + emits vertices to define a new primitive. A geometry shader can emit + multiple disconnected primitives. The primitives emitted by the geometry + shader are clipped and then processed like an equivalent primitive + specified by the application. + + Furthermore, EXT_geometry_shader provides four additional primitive + types: lines with adjacency, line strips with adjacency, separate + triangles with adjacency, and triangle strips with adjacency. Some of the + vertices specified in these new primitive types are not part of the + ordinary primitives, instead they represent neighboring vertices that are + adjacent to the two line segment end points (lines/strips) or the three + triangle edges (triangles/tstrips). These vertices can be accessed by + geometry shaders and used to match up the vertices emitted by the geometry + shader with those of neighboring primitives. + + Since geometry shaders expect a specific input primitive type, an error + will occur if the application presents primitives of a different type. + For example, if a geometry shader expects points, an error will occur at + drawing time if a primitive mode of TRIANGLES is specified. + + This extension also adds the notion of layered framebuffer attachments + and framebuffers that can be used in conjunction with geometry shaders + to allow programs to direct primitives to a face of a cube map or layer + of a three-dimensional texture or two-dimensional array texture. The + layer used for rendering can be selected by the geometry shader at run + time. The framebuffer layer count present in GL 4.x and removed from + ES 3.1 is restored. + + Not all geometry shader implementations have the ability to write the + point size from a geometry shader. Thus a second extension string and + shading language enable are provided for implementations which do + support geometry shader point size. + + This extension relies on the EXT_shader_io_blocks extension to provide + the required functionality for declaring input and output blocks and + interfacing between shaders. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/geometry_shader.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.EXT.geometry_shader import * +from OpenGL.raw.GLES2.EXT.geometry_shader import _EXTENSION_NAME + +def glInitGeometryShaderEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/gpu_shader5.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/gpu_shader5.py new file mode 100644 index 00000000..60d3693f --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/gpu_shader5.py @@ -0,0 +1,62 @@ +'''OpenGL extension EXT.gpu_shader5 + +This module customises the behaviour of the +OpenGL.raw.GLES2.EXT.gpu_shader5 to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides a set of new features to the OpenGL ES Shading + Language and related APIs to support capabilities of new GPUs, extending + the capabilities of version 3.10 of the OpenGL ES Shading Language. + Shaders using the new functionality provided by this extension should + enable this functionality via the construct + + #extension GL_EXT_gpu_shader5 : require (or enable) + + This extension provides a variety of new features for all shader types, + including: + + * support for indexing into arrays of opaque types (samplers, + and atomic counters) using dynamically uniform integer expressions; + + * support for indexing into arrays of images and shader storage blocks + using only constant integral expressions; + + * extending the uniform block capability to allow shaders to index + into an array of uniform blocks; + + * a "precise" qualifier allowing computations to be carried out exactly + as specified in the shader source to avoid optimization-induced + invariance issues (which might cause cracking in tessellation); + + * new built-in functions supporting: + + * fused floating-point multiply-add operations; + + * extending the textureGather() built-in functions provided by + OpenGL ES Shading Language 3.10: + + * allowing shaders to use arbitrary offsets computed at run-time to + select a 2x2 footprint to gather from; and + * allowing shaders to use separate independent offsets for each of + the four texels returned, instead of requiring a fixed 2x2 + footprint. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/gpu_shader5.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.EXT.gpu_shader5 import * +from OpenGL.raw.GLES2.EXT.gpu_shader5 import _EXTENSION_NAME + +def glInitGpuShader5EXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/instanced_arrays.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/instanced_arrays.py new file mode 100644 index 00000000..88e3fe67 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/instanced_arrays.py @@ -0,0 +1,49 @@ +'''OpenGL extension EXT.instanced_arrays + +This module customises the behaviour of the +OpenGL.raw.GLES2.EXT.instanced_arrays to provide a more +Python-friendly API + +Overview (from the spec) + + A common use case in GL for some applications is to be able to + draw the same object, or groups of similar objects that share + vertex data, primitive count and type, multiple times. This + extension provides a means of accelerating such use cases while + reducing the number of API calls, and keeping the amount of + duplicate data to a minimum. + + This extension introduces an array "divisor" for generic + vertex array attributes, which when non-zero specifies that the + attribute is "instanced." An instanced attribute does not + advance per-vertex as usual, but rather after every + conceptual draw calls. + + (Attributes which aren't instanced are repeated in their entirety + for every conceptual draw call.) + + By specifying transform data in an instanced attribute or series + of instanced attributes, vertex shaders can, in concert with the + instancing draw calls, draw multiple instances of an object with + one draw call. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/instanced_arrays.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.EXT.instanced_arrays import * +from OpenGL.raw.GLES2.EXT.instanced_arrays import _EXTENSION_NAME + +def glInitInstancedArraysEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glDrawElementsInstancedEXT.indices size not checked against 'count,type' +glDrawElementsInstancedEXT=wrapper.wrapper(glDrawElementsInstancedEXT).setInputArraySize( + 'indices', None +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/map_buffer_range.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/map_buffer_range.py new file mode 100644 index 00000000..3372e7b2 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/map_buffer_range.py @@ -0,0 +1,46 @@ +'''OpenGL extension EXT.map_buffer_range + +This module customises the behaviour of the +OpenGL.raw.GLES2.EXT.map_buffer_range to provide a more +Python-friendly API + +Overview (from the spec) + + EXT_map_buffer_range expands the buffer object API to allow greater + performance when a client application only needs to write to a sub-range + of a buffer object. To that end, this extension introduces two new buffer + object features: non-serialized buffer modification and explicit sub-range + flushing for mapped buffer objects. + + OpenGL requires that commands occur in a FIFO manner meaning that any + changes to buffer objects either block until the data has been processed by + the OpenGL pipeline or else create extra copies to avoid such a block. By + providing a method to asynchronously modify buffer object data, an + application is then able to manage the synchronization points themselves + and modify ranges of data contained by a buffer object even though OpenGL + might still be using other parts of it. + + This extension also provides a method for explicitly flushing ranges of a + mapped buffer object so OpenGL does not have to assume that the entire + range may have been modified. Further, it allows the application to more + precisely specify its intent with respect to reading, writing, and whether + the previous contents of a mapped range of interest need be preserved + prior to modification. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/map_buffer_range.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.EXT.map_buffer_range import * +from OpenGL.raw.GLES2.EXT.map_buffer_range import _EXTENSION_NAME + +def glInitMapBufferRangeEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/memory_object.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/memory_object.py new file mode 100644 index 00000000..d95c4df2 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/memory_object.py @@ -0,0 +1,34 @@ +'''OpenGL extension EXT.memory_object + +This module customises the behaviour of the +OpenGL.raw.GLES2.EXT.memory_object to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/memory_object.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.EXT.memory_object import * +from OpenGL.raw.GLES2.EXT.memory_object import _EXTENSION_NAME + +def glInitMemoryObjectEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glGetUnsignedBytevEXT.data size not checked against 'pname' +glGetUnsignedBytevEXT=wrapper.wrapper(glGetUnsignedBytevEXT).setInputArraySize( + 'data', None +) +# INPUT glGetUnsignedBytei_vEXT.data size not checked against 'target' +glGetUnsignedBytei_vEXT=wrapper.wrapper(glGetUnsignedBytei_vEXT).setInputArraySize( + 'data', None +) +# INPUT glDeleteMemoryObjectsEXT.memoryObjects size not checked against n +glDeleteMemoryObjectsEXT=wrapper.wrapper(glDeleteMemoryObjectsEXT).setInputArraySize( + 'memoryObjects', None +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/memory_object_fd.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/memory_object_fd.py new file mode 100644 index 00000000..78858845 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/memory_object_fd.py @@ -0,0 +1,23 @@ +'''OpenGL extension EXT.memory_object_fd + +This module customises the behaviour of the +OpenGL.raw.GLES2.EXT.memory_object_fd to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/memory_object_fd.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.EXT.memory_object_fd import * +from OpenGL.raw.GLES2.EXT.memory_object_fd import _EXTENSION_NAME + +def glInitMemoryObjectFdEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/memory_object_win32.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/memory_object_win32.py new file mode 100644 index 00000000..834dcee8 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/memory_object_win32.py @@ -0,0 +1,23 @@ +'''OpenGL extension EXT.memory_object_win32 + +This module customises the behaviour of the +OpenGL.raw.GLES2.EXT.memory_object_win32 to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/memory_object_win32.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.EXT.memory_object_win32 import * +from OpenGL.raw.GLES2.EXT.memory_object_win32 import _EXTENSION_NAME + +def glInitMemoryObjectWin32EXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/multi_draw_arrays.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/multi_draw_arrays.py new file mode 100644 index 00000000..212bb846 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/multi_draw_arrays.py @@ -0,0 +1,44 @@ +'''OpenGL extension EXT.multi_draw_arrays + +This module customises the behaviour of the +OpenGL.raw.GLES2.EXT.multi_draw_arrays to provide a more +Python-friendly API + +Overview (from the spec) + + These functions behave identically to the standard OpenGL 1.1 functions + glDrawArrays() and glDrawElements() except they handle multiple lists of + vertices in one call. Their main purpose is to allow one function call + to render more than one primitive such as triangle strip, triangle fan, + etc. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/multi_draw_arrays.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.EXT.multi_draw_arrays import * +from OpenGL.raw.GLES2.EXT.multi_draw_arrays import _EXTENSION_NAME + +def glInitMultiDrawArraysEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glMultiDrawArraysEXT.count size not checked against 'primcount' +# INPUT glMultiDrawArraysEXT.first size not checked against 'primcount' +glMultiDrawArraysEXT=wrapper.wrapper(glMultiDrawArraysEXT).setInputArraySize( + 'count', None +).setInputArraySize( + 'first', None +) +# INPUT glMultiDrawElementsEXT.count size not checked against 'primcount' +# INPUT glMultiDrawElementsEXT.indices size not checked against 'primcount' +glMultiDrawElementsEXT=wrapper.wrapper(glMultiDrawElementsEXT).setInputArraySize( + 'count', None +).setInputArraySize( + 'indices', None +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/multi_draw_indirect.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/multi_draw_indirect.py new file mode 100644 index 00000000..992eb709 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/multi_draw_indirect.py @@ -0,0 +1,45 @@ +'''OpenGL extension EXT.multi_draw_indirect + +This module customises the behaviour of the +OpenGL.raw.GLES2.EXT.multi_draw_indirect to provide a more +Python-friendly API + +Overview (from the spec) + + The ARB_draw_indirect extension (included in OpenGL 4.0 and OpenGL ES 3.1) + introduced mechanisms whereby the parameters for a draw function may be + provided in a structure contained in a buffer object rather than as + parameters to the drawing procedure. This is known as an indirect draw and + is exposed as two new functions, glDrawArraysIndirect and + glDrawElementsIndirect. Each of these functions generates a single batch + of primitives. + + This extension builds on this functionality by providing procedures to + invoke multiple draws from a single procedure call. This allows large + batches of drawing commands to be assembled in server memory (via a buffer + object) which may then be dispatched through a single function call. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/multi_draw_indirect.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.EXT.multi_draw_indirect import * +from OpenGL.raw.GLES2.EXT.multi_draw_indirect import _EXTENSION_NAME + +def glInitMultiDrawIndirectEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glMultiDrawArraysIndirectEXT.indirect size not checked against 'drawcount,stride' +glMultiDrawArraysIndirectEXT=wrapper.wrapper(glMultiDrawArraysIndirectEXT).setInputArraySize( + 'indirect', None +) +# INPUT glMultiDrawElementsIndirectEXT.indirect size not checked against 'drawcount,stride' +glMultiDrawElementsIndirectEXT=wrapper.wrapper(glMultiDrawElementsIndirectEXT).setInputArraySize( + 'indirect', None +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/multisampled_compatibility.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/multisampled_compatibility.py new file mode 100644 index 00000000..0dd6071f --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/multisampled_compatibility.py @@ -0,0 +1,23 @@ +'''OpenGL extension EXT.multisampled_compatibility + +This module customises the behaviour of the +OpenGL.raw.GLES2.EXT.multisampled_compatibility to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/multisampled_compatibility.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.EXT.multisampled_compatibility import * +from OpenGL.raw.GLES2.EXT.multisampled_compatibility import _EXTENSION_NAME + +def glInitMultisampledCompatibilityEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/multisampled_render_to_texture.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/multisampled_render_to_texture.py new file mode 100644 index 00000000..e574a9d0 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/multisampled_render_to_texture.py @@ -0,0 +1,51 @@ +'''OpenGL extension EXT.multisampled_render_to_texture + +This module customises the behaviour of the +OpenGL.raw.GLES2.EXT.multisampled_render_to_texture to provide a more +Python-friendly API + +Overview (from the spec) + + This extension introduces functionality to perform multisampled + rendering to a color renderable texture, without requiring an + explicit resolve of multisample data. + + Some GPU architectures - such as tile-based renderers - are + capable of performing multisampled rendering by storing + multisample data in internal high-speed memory and downsampling the + data when writing out to external memory after rendering has + finished. Since per-sample data is never written out to external + memory, this approach saves bandwidth and storage space. In this + case multisample data gets discarded, however this is acceptable + in most cases. + + The extension provides a new command, FramebufferTexture2DMultisampleEXT, + which attaches a texture level to a framebuffer and enables + multisampled rendering to that texture level. + + When the texture level is flushed or used as a source or destination + for any operation other than drawing to it, an implicit resolve of + multisampled color data may be performed. After such a resolve, the + multisampled color data is discarded. + + In order to allow the use of multisampled depth and stencil buffers + when performing multisampled rendering to a texture, the extension + also adds the command RenderbufferStorageMultisampleEXT. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/multisampled_render_to_texture.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.EXT.multisampled_render_to_texture import * +from OpenGL.raw.GLES2.EXT.multisampled_render_to_texture import _EXTENSION_NAME + +def glInitMultisampledRenderToTextureEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/multiview_draw_buffers.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/multiview_draw_buffers.py new file mode 100644 index 00000000..a6d65973 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/multiview_draw_buffers.py @@ -0,0 +1,59 @@ +'''OpenGL extension EXT.multiview_draw_buffers + +This module customises the behaviour of the +OpenGL.raw.GLES2.EXT.multiview_draw_buffers to provide a more +Python-friendly API + +Overview (from the spec) + + This extension allows selecting among draw buffers as the + rendering target. This may be among multiple primary buffers + pertaining to platform-specific stereoscopic or multiview displays + or among offscreen framebuffer object color attachments. + + To remove any artificial limitations imposed on the number of + possible buffers, draw buffers are identified not as individual + enums, but as pairs of values consisting of an enum representing + buffer locations such as COLOR_ATTACHMENT_EXT or MULTIVIEW_EXT, + and an integer representing an identifying index of buffers of this + location. These (location, index) pairs are used to specify draw + buffer targets using a new DrawBuffersIndexedEXT call. + + Rendering to buffers of location MULTIVIEW_EXT associated with the + context allows rendering to multiview buffers created by EGL using + EGL_EXT_multiview_window for stereoscopic displays. + + Rendering to COLOR_ATTACHMENT_EXT buffers allows implementations to + increase the number of potential color attachments indefinitely to + renderbuffers and textures. + + This extension allows the traditional quad buffer stereoscopic + rendering method that has proven effective by indicating a left or + right draw buffer and rendering to each accordingly, but is also + dynamic enough to handle an arbitrary number of color buffer targets + all using the same shader. This grants the user maximum flexibility + as well as a familiar interface. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/multiview_draw_buffers.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.EXT.multiview_draw_buffers import * +from OpenGL.raw.GLES2.EXT.multiview_draw_buffers import _EXTENSION_NAME + +def glInitMultiviewDrawBuffersEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glDrawBuffersIndexedEXT.indices size not checked against n +# INPUT glDrawBuffersIndexedEXT.location size not checked against n +glDrawBuffersIndexedEXT=wrapper.wrapper(glDrawBuffersIndexedEXT).setInputArraySize( + 'indices', None +).setInputArraySize( + 'location', None +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/multiview_tessellation_geometry_shader.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/multiview_tessellation_geometry_shader.py new file mode 100644 index 00000000..31b864a3 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/multiview_tessellation_geometry_shader.py @@ -0,0 +1,48 @@ +'''OpenGL extension EXT.multiview_tessellation_geometry_shader + +This module customises the behaviour of the +OpenGL.raw.GLES2.EXT.multiview_tessellation_geometry_shader to provide a more +Python-friendly API + +Overview (from the spec) + + OVR_multiview introduced multiview rendering to OpenGL and OpenGL ES. + + This extension removes one of the limitations of the OVR_multiview + extension by allowing the use of tessellation control, tessellation + evaluation, and geometry shaders during multiview rendering. + OVR_multiview by itself forbids the use of any of these shader types. + + When using tessellation control, tessellation evaluation, and geometry + shaders during multiview rendering, any such shader must use the + "num_views" layout qualifier provided by the matching shading language + extension to specify a view count. The view count specified in these + shaders must match the count specified in the vertex shader. Additionally, + the shading language extension allows these shaders to use the + gl_ViewID_OVR built-in to handle tessellation or geometry shader processing + differently for each view. + + OVR_multiview2 extends OVR_multiview by allowing view-dependent values + for any vertex attributes instead of just the position. This new extension + does not imply the availability of OVR_multiview2, but if both are available, + view-dependent values for any vertex attributes are also allowed in + tessellation control, tessellation evaluation, and geometry shaders. + + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/multiview_tessellation_geometry_shader.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.EXT.multiview_tessellation_geometry_shader import * +from OpenGL.raw.GLES2.EXT.multiview_tessellation_geometry_shader import _EXTENSION_NAME + +def glInitMultiviewTessellationGeometryShaderEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/multiview_texture_multisample.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/multiview_texture_multisample.py new file mode 100644 index 00000000..26a94d47 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/multiview_texture_multisample.py @@ -0,0 +1,52 @@ +'''OpenGL extension EXT.multiview_texture_multisample + +This module customises the behaviour of the +OpenGL.raw.GLES2.EXT.multiview_texture_multisample to provide a more +Python-friendly API + +Overview (from the spec) + + OVR_multiview introduced multiview rendering to OpenGL and OpenGL ES. + + This extension removes one of the limitations of the OVR_multiview + extension by allowing the use of multisample textures during multiview rendering. + + This is one of two extensions that allow multisampling when using + OVR_multiview. Each supports one of the two different approaches to + multisampling in OpenGL and OpenGL ES: + + Core OpenGL and OpenGL ES 3.1+ have explicit support for multisample + texture types, such as TEXTURE_2D_MULTISAMPLE. Applications can access + the values of individual samples and can explicitly "resolve" the + samples of each pixel down to a single color. + + The extension EXT_multisampled_render_to_texture provides support for + multisampled rendering to non-multisample texture types, such as + TEXTURE_2D. The individual samples for each pixel are maintained + internally by the implementation and can not be accessed directly + by applications. These samples are eventually resolved implicitly to + a single color for each pixel. + + This extension supports the first multisampling style with multiview + rendering; the OVR_multiview_multisampled_render_to_texture extension + supports the second style. Note that support for one of these multiview + extensions does not imply support for the other. + + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/multiview_texture_multisample.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.EXT.multiview_texture_multisample import * +from OpenGL.raw.GLES2.EXT.multiview_texture_multisample import _EXTENSION_NAME + +def glInitMultiviewTextureMultisampleEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/multiview_timer_query.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/multiview_timer_query.py new file mode 100644 index 00000000..7aae5d94 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/multiview_timer_query.py @@ -0,0 +1,32 @@ +'''OpenGL extension EXT.multiview_timer_query + +This module customises the behaviour of the +OpenGL.raw.GLES2.EXT.multiview_timer_query to provide a more +Python-friendly API + +Overview (from the spec) + + OVR_multiview introduced multiview rendering to OpenGL and OpenGL ES. + This extension removes one of the limitations of the OVR_multiview + extension by allowing the use of timer queries during multiview rendering. + OVR_multiview does not specify defined behavior for such usage + (if implemented in OpenGL or if EXT_disjoint_timer_query is present). + + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/multiview_timer_query.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.EXT.multiview_timer_query import * +from OpenGL.raw.GLES2.EXT.multiview_timer_query import _EXTENSION_NAME + +def glInitMultiviewTimerQueryEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/occlusion_query_boolean.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/occlusion_query_boolean.py new file mode 100644 index 00000000..b0e7e7f3 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/occlusion_query_boolean.py @@ -0,0 +1,52 @@ +'''OpenGL extension EXT.occlusion_query_boolean + +This module customises the behaviour of the +OpenGL.raw.GLES2.EXT.occlusion_query_boolean to provide a more +Python-friendly API + +Overview (from the spec) + + This extension defines a mechanism whereby an application can + query whether any pixels (or, more precisely, samples) are drawn + by a primitive or group of primitives. + + The primary purpose of such a query (hereafter referred to as an + "occlusion query") is to determine the visibility of an object. + Typically, the application will render the major occluders in the + scene, then perform an occlusion query for each detail object in + the scene. On subsequent frames, the previous results of the + occlusion queries can be used to decide whether to draw an object + or not. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/occlusion_query_boolean.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.EXT.occlusion_query_boolean import * +from OpenGL.raw.GLES2.EXT.occlusion_query_boolean import _EXTENSION_NAME + +def glInitOcclusionQueryBooleanEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glGenQueriesEXT.ids size not checked against n +glGenQueriesEXT=wrapper.wrapper(glGenQueriesEXT).setInputArraySize( + 'ids', None +) +# INPUT glDeleteQueriesEXT.ids size not checked against n +glDeleteQueriesEXT=wrapper.wrapper(glDeleteQueriesEXT).setInputArraySize( + 'ids', None +) +# INPUT glGetQueryivEXT.params size not checked against 'pname' +glGetQueryivEXT=wrapper.wrapper(glGetQueryivEXT).setInputArraySize( + 'params', None +) +# INPUT glGetQueryObjectuivEXT.params size not checked against 'pname' +glGetQueryObjectuivEXT=wrapper.wrapper(glGetQueryObjectuivEXT).setInputArraySize( + 'params', None +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/polygon_offset_clamp.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/polygon_offset_clamp.py new file mode 100644 index 00000000..18174563 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/polygon_offset_clamp.py @@ -0,0 +1,35 @@ +'''OpenGL extension EXT.polygon_offset_clamp + +This module customises the behaviour of the +OpenGL.raw.GLES2.EXT.polygon_offset_clamp to provide a more +Python-friendly API + +Overview (from the spec) + + This extension adds a new parameter to the polygon offset function + that clamps the calculated offset to a minimum or maximum value. + The clamping functionality is useful when polygons are nearly + parallel to the view direction because their high slopes can result + in arbitrarily large polygon offsets. In the particular case of + shadow mapping, the lack of clamping can produce the appearance of + unwanted holes when the shadow casting polygons are offset beyond + the shadow receiving polygons, and this problem can be alleviated by + enforcing a maximum offset value. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/polygon_offset_clamp.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.EXT.polygon_offset_clamp import * +from OpenGL.raw.GLES2.EXT.polygon_offset_clamp import _EXTENSION_NAME + +def glInitPolygonOffsetClampEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/post_depth_coverage.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/post_depth_coverage.py new file mode 100644 index 00000000..651f649d --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/post_depth_coverage.py @@ -0,0 +1,37 @@ +'''OpenGL extension EXT.post_depth_coverage + +This module customises the behaviour of the +OpenGL.raw.GLES2.EXT.post_depth_coverage to provide a more +Python-friendly API + +Overview (from the spec) + + This extension allows the fragment shader to control whether values in + gl_SampleMaskIn[] reflect the coverage after application of the early + depth and stencil tests. This feature can be enabled with the following + layout qualifier in the fragment shader: + + layout(post_depth_coverage) in; + + To use this feature, early fragment tests must also be enabled in the + fragment shader via: + + layout(early_fragment_tests) in; + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/post_depth_coverage.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.EXT.post_depth_coverage import * +from OpenGL.raw.GLES2.EXT.post_depth_coverage import _EXTENSION_NAME + +def glInitPostDepthCoverageEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/primitive_bounding_box.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/primitive_bounding_box.py new file mode 100644 index 00000000..a920d716 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/primitive_bounding_box.py @@ -0,0 +1,51 @@ +'''OpenGL extension EXT.primitive_bounding_box + +This module customises the behaviour of the +OpenGL.raw.GLES2.EXT.primitive_bounding_box to provide a more +Python-friendly API + +Overview (from the spec) + + On tile-based architectures, transformed primitives are generally written + out to memory before rasterization, and then read back from memory for each + tile they intersect. When geometry expands during transformation due to + tessellation or one-to-many geometry shaders, the external bandwidth + required grows proportionally. This extension provides a way for + implementations to know which tiles incoming geometry will intersect before + fully transforming (and expanding) the geometry. This allows them to only + store the unexpanded geometry in memory, and perform expansion on-chip for + each intersected tile. + + New state is added to hold an axis-aligned bounding box which is assumed to + contain any geometry submitted. An implementation is allowed to ignore any + portions of primitives outside the bounding box; thus if a primitive extends + outside of a tile into a neighboring tile that the bounding box didn't + intersect, the implementation is not required to render those portions. The + tessellation control shader is optionally able to specify a per-patch + bounding box that overrides the bounding box state for primitives generated + from that patch, in order to provide tighter bounds. + + The typical usage is that an application will have an object-space bounding + volume for a primitive or group of primitives, either calculated at runtime + or provided with the mesh by the authoring tool or content pipeline. It will + transform this volume to clip space, compute an axis-aligned bounding box + that contains the transformed bounding volume, and provide that at either + per-patch or per-draw granularity. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/primitive_bounding_box.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.EXT.primitive_bounding_box import * +from OpenGL.raw.GLES2.EXT.primitive_bounding_box import _EXTENSION_NAME + +def glInitPrimitiveBoundingBoxEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/protected_textures.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/protected_textures.py new file mode 100644 index 00000000..d0cb54a5 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/protected_textures.py @@ -0,0 +1,51 @@ +'''OpenGL extension EXT.protected_textures + +This module customises the behaviour of the +OpenGL.raw.GLES2.EXT.protected_textures to provide a more +Python-friendly API + +Overview (from the spec) + + This extension requires another extension like EGL_EXT_protected_content to + have created a protected context. A protected context enables the + driver to put the GPU into a protected mode where it is able to operate on + protected surfaces. + + This extension enables allocating standard GL textures as protected + surfaces. Previously these textures would have had to have been created as + special EGL surfaces. This allows use-cases such as depth, stencil, or + mipmapped textures to be supported as destinations for rendering within + a protected context. + + An explanation of undefined behavior in this extension: Several places + in this extension mention undefined behavior can result, which can + include program termination. The reason for this is because one way + to handle protected content is by using a protected virtual to physical + memory translation layer. With this sort of solution a system may generate + read or write faults when a non-protected context tries to access the + buffer. Depending on the system these faults might be ignored or they might + cause process termination. This undefined behavior should not include + actually allowing copying any protected content to a non-protected surface. + + This extension does not guarantee that the implementation abides by a + system's digital rights management requirements. It must be verified beyond + the existence of this extension that the implementation of this extension is + trustworthy according to the requirements of a content protection system. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/protected_textures.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.EXT.protected_textures import * +from OpenGL.raw.GLES2.EXT.protected_textures import _EXTENSION_NAME + +def glInitProtectedTexturesEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/pvrtc_sRGB.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/pvrtc_sRGB.py new file mode 100644 index 00000000..3eb018e0 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/pvrtc_sRGB.py @@ -0,0 +1,54 @@ +'''OpenGL extension EXT.pvrtc_sRGB + +This module customises the behaviour of the +OpenGL.raw.GLES2.EXT.pvrtc_sRGB to provide a more +Python-friendly API + +Overview (from the spec) + + The response from electronic display systems given RGB tristimulus values + for each pixel is non-linear. Gamma correction is the process of encoding + or decoding images in a manner that will correct for non-linear response + profiles of output devices. The displayed results of gamma-corrected pixel + data are more consistent and predictable for the author of such pixel data + than it would otherwise be with linearly encoded pixel data. + + This EXT_pvrtc_sRGB extension specifies additional tokens for gamma + corrected PVRTC compressed sRGB data. + + Texture assets are developed and evaluated for use in OpenGL applications + using electronic displays with non-linear responses. This extension + provides a better measure of consistency between textures developed within + an asset toolchain and their final rendered result with an OpenGL + application that uses those textures. + + Conventional OpenGL texture tristimulus values as well as their alpha + component are encoded linearly. The textures introduced by this extension + are encoded with gamma correction in the tristimulus components but + linearly in the alpha component. + + When gamma corrected texture samples are fetched and operated on by ALU + operations in an OpenGL shading program those samples will be converted + from gamma corrected space to linear space for logical simplicity and + performance of the shader. + + Texture filtering operations as well as mipmap generation are carried out + in linear space. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/pvrtc_sRGB.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.EXT.pvrtc_sRGB import * +from OpenGL.raw.GLES2.EXT.pvrtc_sRGB import _EXTENSION_NAME + +def glInitPvrtcSrgbEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/raster_multisample.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/raster_multisample.py new file mode 100644 index 00000000..91243fac --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/raster_multisample.py @@ -0,0 +1,42 @@ +'''OpenGL extension EXT.raster_multisample + +This module customises the behaviour of the +OpenGL.raw.GLES2.EXT.raster_multisample to provide a more +Python-friendly API + +Overview (from the spec) + + This extension allows rendering to a non-multisample color buffer while + rasterizing with more than one sample. The result of rasterization + (coverage) is available in the gl_SampleMaskIn[] fragment shader input, + multisample rasterization is enabled for all primitives, and several per- + fragment operations operate at the raster sample rate. + + When using the functionality provided by this extension, depth, stencil, + and depth bounds tests must be disabled, and a multisample draw + framebuffer must not be used. + + A fragment's "coverage", or "effective raster samples" is considered to + have "N bits" (as opposed to "one bit" corresponding to the single color + sample) through the fragment shader, in the sample mask output, through + the multisample fragment operations and occlusion query, until the coverage + is finally "reduced" to a single bit in a new "Coverage Reduction" stage + that occurs before blending. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/raster_multisample.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.EXT.raster_multisample import * +from OpenGL.raw.GLES2.EXT.raster_multisample import _EXTENSION_NAME + +def glInitRasterMultisampleEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/read_format_bgra.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/read_format_bgra.py new file mode 100644 index 00000000..8779f9ce --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/read_format_bgra.py @@ -0,0 +1,46 @@ +'''OpenGL extension EXT.read_format_bgra + +This module customises the behaviour of the +OpenGL.raw.GLES2.EXT.read_format_bgra to provide a more +Python-friendly API + +Overview (from the spec) + + This extension is intended to supplement the GL_OES_read_format + extension by adding support for more format/type combinations to be used + when calling ReadPixels. ReadPixels currently accepts one fixed + format/type combination (format RGBA and type UNSIGNED_BYTE) for + portability, and an implementation specific format/type combination + queried using the tokens IMPLEMENTATION_COLOR_READ_FORMAT_OES and + IMPLEMENTATION_COLOR_READ_TYPE_OES (GL_OES_read_format extension). This + extension adds the following format/type combinations to those currently + allowed to be returned by GetIntegerV: + + format type + ------ ---- + BGRA_EXT UNSIGNED_BYTE + BGRA_EXT UNSIGNED_SHORT_4_4_4_4_REV_EXT + BGRA_EXT UNSIGNED_SHORT_1_5_5_5_REV_EXT + + E.g. Calling GetIntegerv with a parameter of + IMPLEMENTATION_COLOR_READ_FORMAT_OES can now return BGRA_EXT, with the + corresponding call to GetIntegerv using a parameter of + IMPLEMENTATION_COLOR_READ_TYPE_OES returning UNSIGNED_BYTE; + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/read_format_bgra.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.EXT.read_format_bgra import * +from OpenGL.raw.GLES2.EXT.read_format_bgra import _EXTENSION_NAME + +def glInitReadFormatBgraEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/render_snorm.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/render_snorm.py new file mode 100644 index 00000000..6e597651 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/render_snorm.py @@ -0,0 +1,31 @@ +'''OpenGL extension EXT.render_snorm + +This module customises the behaviour of the +OpenGL.raw.GLES2.EXT.render_snorm to provide a more +Python-friendly API + +Overview (from the spec) + + OpenGL ES 3.1 supports a variety of signed normalized texture and + renderbuffer formats which are not color-renderable. + + This extension enables signed normalized texture and renderbuffer + formats to be color-renderable. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/render_snorm.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.EXT.render_snorm import * +from OpenGL.raw.GLES2.EXT.render_snorm import _EXTENSION_NAME + +def glInitRenderSnormEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/robustness.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/robustness.py new file mode 100644 index 00000000..c0ce14fe --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/robustness.py @@ -0,0 +1,89 @@ +'''OpenGL extension EXT.robustness + +This module customises the behaviour of the +OpenGL.raw.GLES2.EXT.robustness to provide a more +Python-friendly API + +Overview (from the spec) + + Several recent trends in how OpenGL integrates into modern computer + systems have created new requirements for robustness and security + for OpenGL rendering contexts. + + Additionally GPU architectures now support hardware fault detection; + for example, video memory supporting ECC (error correcting codes) + and error detection. OpenGL contexts should be capable of recovering + from hardware faults such as uncorrectable memory errors. Along with + recovery from such hardware faults, the recovery mechanism can + also allow recovery from video memory access exceptions and system + software failures. System software failures can be due to device + changes or driver failures. + + OpenGL queries that that return (write) some number of bytes to a + buffer indicated by a pointer parameter introduce risk of buffer + overflows that might be exploitable by malware. To address this, + queries with return value sizes that are not expressed directly by + the parameters to the query itself are given additional API + functions with an additional parameter that specifies the number of + bytes in the buffer and never writing bytes beyond that limit. This + is particularly useful for multi-threaded usage of OpenGL contexts + in a "share group" where one context can change objects in ways that + can cause buffer overflows for another context's OpenGL queries. + + The original ARB_vertex_buffer_object extension includes an issue + that explicitly states program termination is allowed when + out-of-bounds vertex buffer object fetches occur. Modern graphics + hardware is capable well-defined behavior in the case of out-of- + bounds vertex buffer object fetches. Older hardware may require + extra checks to enforce well-defined (and termination free) + behavior, but this expense is warranted when processing potentially + untrusted content. + + The intent of this extension is to address some specific robustness + goals: + + * For all existing OpenGL queries, provide additional "safe" APIs + that limit data written to user pointers to a buffer size in + bytes that is an explicit additional parameter of the query. + + * Provide a mechanism for an OpenGL application to learn about + graphics resets that affect the context. When a graphics reset + occurs, the OpenGL context becomes unusable and the application + must create a new context to continue operation. Detecting a + graphics reset happens through an inexpensive query. + + * Provide an enable to guarantee that out-of-bounds buffer object + accesses by the GPU will have deterministic behavior and preclude + application instability or termination due to an incorrect buffer + access. Such accesses include vertex buffer fetches of + attributes and indices, and indexed reads of uniforms or + parameters from buffers. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/robustness.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.EXT.robustness import * +from OpenGL.raw.GLES2.EXT.robustness import _EXTENSION_NAME + +def glInitRobustnessEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glReadnPixelsEXT.data size not checked against bufSize +glReadnPixelsEXT=wrapper.wrapper(glReadnPixelsEXT).setInputArraySize( + 'data', None +) +# INPUT glGetnUniformfvEXT.params size not checked against bufSize +glGetnUniformfvEXT=wrapper.wrapper(glGetnUniformfvEXT).setInputArraySize( + 'params', None +) +# INPUT glGetnUniformivEXT.params size not checked against bufSize +glGetnUniformivEXT=wrapper.wrapper(glGetnUniformivEXT).setInputArraySize( + 'params', None +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/sRGB.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/sRGB.py new file mode 100644 index 00000000..699036c6 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/sRGB.py @@ -0,0 +1,54 @@ +'''OpenGL extension EXT.sRGB + +This module customises the behaviour of the +OpenGL.raw.GLES2.EXT.sRGB to provide a more +Python-friendly API + +Overview (from the spec) + + The sRGB color space is based on typical (non-linear) response of the human + eye. It has been standardized by the International Electrotechnical + Commission (IEC) as IEC 61966-2-1. The transfer function of sRGB roughly + corresponds to a power function with a gamma of 2.2. + + FRAMEBUFFERS + + OpenGL assumes framebuffer color components are stored in a linear color + space. In particular, framebuffer blending is a linear operation. + + This extension adds a framebuffer capability for sRGB framebuffer update + and blending. When blending is disabled but the new sRGB updated mode is + enabled (assume the framebuffer supports the capability), high-precision + linear color component values for red, green, and blue generated by + fragment coloring are encoded for sRGB prior to being written into the + framebuffer. When blending is enabled along with the new sRGB update mode, + red, green, and blue framebuffer color components are treated as sRGB + values that are converted to linear color values, blended with the high- + precision color values generated by fragment coloring, and then the blend + result is encoded for sRGB just prior to being written into the + framebuffer. + + TEXTURES + + Conventional texture formats assume a linear color space. So for a + conventional internal texture format such as GL_RGB8, the 256 discrete + values for each 8-bit color component map linearly and uniformly to the + [0,1] range. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/sRGB.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.EXT.sRGB import * +from OpenGL.raw.GLES2.EXT.sRGB import _EXTENSION_NAME + +def glInitSrgbEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/sRGB_write_control.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/sRGB_write_control.py new file mode 100644 index 00000000..ae06e563 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/sRGB_write_control.py @@ -0,0 +1,33 @@ +'''OpenGL extension EXT.sRGB_write_control + +This module customises the behaviour of the +OpenGL.raw.GLES2.EXT.sRGB_write_control to provide a more +Python-friendly API + +Overview (from the spec) + + This extension's intent is to expose new functionality which allows an + application the ability to decide if the conversion from linear space to + sRGB is necessary by enabling or disabling this conversion at framebuffer + write or blending time. An application which passes non-linear vector data + to a shader may not want the color conversion occurring, and by disabling + conversion the application can be simplified, sometimes in very significant + and more optimal ways. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/sRGB_write_control.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.EXT.sRGB_write_control import * +from OpenGL.raw.GLES2.EXT.sRGB_write_control import _EXTENSION_NAME + +def glInitSrgbWriteControlEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/semaphore.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/semaphore.py new file mode 100644 index 00000000..0e36944c --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/semaphore.py @@ -0,0 +1,58 @@ +'''OpenGL extension EXT.semaphore + +This module customises the behaviour of the +OpenGL.raw.GLES2.EXT.semaphore to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/semaphore.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.EXT.semaphore import * +from OpenGL.raw.GLES2.EXT.semaphore import _EXTENSION_NAME + +def glInitSemaphoreEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glGetUnsignedBytevEXT.data size not checked against 'pname' +glGetUnsignedBytevEXT=wrapper.wrapper(glGetUnsignedBytevEXT).setInputArraySize( + 'data', None +) +# INPUT glGetUnsignedBytei_vEXT.data size not checked against 'target' +glGetUnsignedBytei_vEXT=wrapper.wrapper(glGetUnsignedBytei_vEXT).setInputArraySize( + 'data', None +) +# INPUT glGenSemaphoresEXT.semaphores size not checked against n +glGenSemaphoresEXT=wrapper.wrapper(glGenSemaphoresEXT).setInputArraySize( + 'semaphores', None +) +# INPUT glDeleteSemaphoresEXT.semaphores size not checked against n +glDeleteSemaphoresEXT=wrapper.wrapper(glDeleteSemaphoresEXT).setInputArraySize( + 'semaphores', None +) +# INPUT glWaitSemaphoreEXT.buffers size not checked against 'numBufferBarriers' +# INPUT glWaitSemaphoreEXT.srcLayouts size not checked against 'numTextureBarriers' +# INPUT glWaitSemaphoreEXT.textures size not checked against 'numTextureBarriers' +glWaitSemaphoreEXT=wrapper.wrapper(glWaitSemaphoreEXT).setInputArraySize( + 'buffers', None +).setInputArraySize( + 'srcLayouts', None +).setInputArraySize( + 'textures', None +) +# INPUT glSignalSemaphoreEXT.buffers size not checked against 'numBufferBarriers' +# INPUT glSignalSemaphoreEXT.dstLayouts size not checked against 'numTextureBarriers' +# INPUT glSignalSemaphoreEXT.textures size not checked against 'numTextureBarriers' +glSignalSemaphoreEXT=wrapper.wrapper(glSignalSemaphoreEXT).setInputArraySize( + 'buffers', None +).setInputArraySize( + 'dstLayouts', None +).setInputArraySize( + 'textures', None +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/semaphore_fd.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/semaphore_fd.py new file mode 100644 index 00000000..a8fc3aba --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/semaphore_fd.py @@ -0,0 +1,23 @@ +'''OpenGL extension EXT.semaphore_fd + +This module customises the behaviour of the +OpenGL.raw.GLES2.EXT.semaphore_fd to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/semaphore_fd.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.EXT.semaphore_fd import * +from OpenGL.raw.GLES2.EXT.semaphore_fd import _EXTENSION_NAME + +def glInitSemaphoreFdEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/semaphore_win32.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/semaphore_win32.py new file mode 100644 index 00000000..d6629097 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/semaphore_win32.py @@ -0,0 +1,23 @@ +'''OpenGL extension EXT.semaphore_win32 + +This module customises the behaviour of the +OpenGL.raw.GLES2.EXT.semaphore_win32 to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/semaphore_win32.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.EXT.semaphore_win32 import * +from OpenGL.raw.GLES2.EXT.semaphore_win32 import _EXTENSION_NAME + +def glInitSemaphoreWin32EXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/separate_shader_objects.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/separate_shader_objects.py new file mode 100644 index 00000000..f0533cb9 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/separate_shader_objects.py @@ -0,0 +1,128 @@ +'''OpenGL extension EXT.separate_shader_objects + +This module customises the behaviour of the +OpenGL.raw.GLES2.EXT.separate_shader_objects to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/separate_shader_objects.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.EXT.separate_shader_objects import * +from OpenGL.raw.GLES2.EXT.separate_shader_objects import _EXTENSION_NAME + +def glInitSeparateShaderObjectsEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glCreateShaderProgramvEXT.strings size not checked against count +glCreateShaderProgramvEXT=wrapper.wrapper(glCreateShaderProgramvEXT).setInputArraySize( + 'strings', None +) +# INPUT glDeleteProgramPipelinesEXT.pipelines size not checked against n +glDeleteProgramPipelinesEXT=wrapper.wrapper(glDeleteProgramPipelinesEXT).setInputArraySize( + 'pipelines', None +) +# INPUT glGenProgramPipelinesEXT.pipelines size not checked against n +glGenProgramPipelinesEXT=wrapper.wrapper(glGenProgramPipelinesEXT).setInputArraySize( + 'pipelines', None +) +# INPUT glGetProgramPipelineInfoLogEXT.infoLog size not checked against bufSize +glGetProgramPipelineInfoLogEXT=wrapper.wrapper(glGetProgramPipelineInfoLogEXT).setInputArraySize( + 'infoLog', None +).setInputArraySize( + 'length', 1 +) +# INPUT glProgramUniform1fvEXT.value size not checked against count +glProgramUniform1fvEXT=wrapper.wrapper(glProgramUniform1fvEXT).setInputArraySize( + 'value', None +) +# INPUT glProgramUniform1ivEXT.value size not checked against count +glProgramUniform1ivEXT=wrapper.wrapper(glProgramUniform1ivEXT).setInputArraySize( + 'value', None +) +# INPUT glProgramUniform2fvEXT.value size not checked against count*2 +glProgramUniform2fvEXT=wrapper.wrapper(glProgramUniform2fvEXT).setInputArraySize( + 'value', None +) +# INPUT glProgramUniform2ivEXT.value size not checked against count*2 +glProgramUniform2ivEXT=wrapper.wrapper(glProgramUniform2ivEXT).setInputArraySize( + 'value', None +) +# INPUT glProgramUniform3fvEXT.value size not checked against count*3 +glProgramUniform3fvEXT=wrapper.wrapper(glProgramUniform3fvEXT).setInputArraySize( + 'value', None +) +# INPUT glProgramUniform3ivEXT.value size not checked against count*3 +glProgramUniform3ivEXT=wrapper.wrapper(glProgramUniform3ivEXT).setInputArraySize( + 'value', None +) +# INPUT glProgramUniform4fvEXT.value size not checked against count*4 +glProgramUniform4fvEXT=wrapper.wrapper(glProgramUniform4fvEXT).setInputArraySize( + 'value', None +) +# INPUT glProgramUniform4ivEXT.value size not checked against count*4 +glProgramUniform4ivEXT=wrapper.wrapper(glProgramUniform4ivEXT).setInputArraySize( + 'value', None +) +# INPUT glProgramUniformMatrix2fvEXT.value size not checked against count*4 +glProgramUniformMatrix2fvEXT=wrapper.wrapper(glProgramUniformMatrix2fvEXT).setInputArraySize( + 'value', None +) +# INPUT glProgramUniformMatrix3fvEXT.value size not checked against count*9 +glProgramUniformMatrix3fvEXT=wrapper.wrapper(glProgramUniformMatrix3fvEXT).setInputArraySize( + 'value', None +) +# INPUT glProgramUniformMatrix4fvEXT.value size not checked against count*16 +glProgramUniformMatrix4fvEXT=wrapper.wrapper(glProgramUniformMatrix4fvEXT).setInputArraySize( + 'value', None +) +# INPUT glProgramUniform1uivEXT.value size not checked against count +glProgramUniform1uivEXT=wrapper.wrapper(glProgramUniform1uivEXT).setInputArraySize( + 'value', None +) +# INPUT glProgramUniform2uivEXT.value size not checked against count*2 +glProgramUniform2uivEXT=wrapper.wrapper(glProgramUniform2uivEXT).setInputArraySize( + 'value', None +) +# INPUT glProgramUniform3uivEXT.value size not checked against count*3 +glProgramUniform3uivEXT=wrapper.wrapper(glProgramUniform3uivEXT).setInputArraySize( + 'value', None +) +# INPUT glProgramUniform4uivEXT.value size not checked against count*4 +glProgramUniform4uivEXT=wrapper.wrapper(glProgramUniform4uivEXT).setInputArraySize( + 'value', None +) +# INPUT glProgramUniformMatrix4fvEXT.value size not checked against count*16 +glProgramUniformMatrix4fvEXT=wrapper.wrapper(glProgramUniformMatrix4fvEXT).setInputArraySize( + 'value', None +) +# INPUT glProgramUniformMatrix2x3fvEXT.value size not checked against count*6 +glProgramUniformMatrix2x3fvEXT=wrapper.wrapper(glProgramUniformMatrix2x3fvEXT).setInputArraySize( + 'value', None +) +# INPUT glProgramUniformMatrix3x2fvEXT.value size not checked against count*6 +glProgramUniformMatrix3x2fvEXT=wrapper.wrapper(glProgramUniformMatrix3x2fvEXT).setInputArraySize( + 'value', None +) +# INPUT glProgramUniformMatrix2x4fvEXT.value size not checked against count*8 +glProgramUniformMatrix2x4fvEXT=wrapper.wrapper(glProgramUniformMatrix2x4fvEXT).setInputArraySize( + 'value', None +) +# INPUT glProgramUniformMatrix4x2fvEXT.value size not checked against count*8 +glProgramUniformMatrix4x2fvEXT=wrapper.wrapper(glProgramUniformMatrix4x2fvEXT).setInputArraySize( + 'value', None +) +# INPUT glProgramUniformMatrix3x4fvEXT.value size not checked against count*12 +glProgramUniformMatrix3x4fvEXT=wrapper.wrapper(glProgramUniformMatrix3x4fvEXT).setInputArraySize( + 'value', None +) +# INPUT glProgramUniformMatrix4x3fvEXT.value size not checked against count*12 +glProgramUniformMatrix4x3fvEXT=wrapper.wrapper(glProgramUniformMatrix4x3fvEXT).setInputArraySize( + 'value', None +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/shader_framebuffer_fetch.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/shader_framebuffer_fetch.py new file mode 100644 index 00000000..4bab7708 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/shader_framebuffer_fetch.py @@ -0,0 +1,58 @@ +'''OpenGL extension EXT.shader_framebuffer_fetch + +This module customises the behaviour of the +OpenGL.raw.GLES2.EXT.shader_framebuffer_fetch to provide a more +Python-friendly API + +Overview (from the spec) + + Conventional OpenGL blending provides a configurable series of operations + that can be used to combine the output values from a fragment shader with + the values already in the framebuffer. While these operations are + suitable for basic image compositing, other compositing operations or + operations that treat fragment output as something other than a color + (normals, for instance) may not be expressible without multiple passes or + render-to-texture operations. + + This extension provides a mechanism whereby a fragment shader may read + existing framebuffer data as input. This can be used to implement + compositing operations that would have been inconvenient or impossible with + fixed-function blending. It can also be used to apply a function to the + framebuffer color, by writing a shader which uses the existing framebuffer + color as its only input. + + This extension provides two alternative name strings: + + - GL_EXT_shader_framebuffer_fetch guarantees full coherency between + framebuffer reads and writes. If this extension string is exposed, the + result of reading from the framebuffer from a fragment shader invocation + is guaranteed to reflect values written by any previous overlapping + samples in API primitive order, unless requested otherwise in the shader + source using the noncoherent layout qualifier. + + - GL_EXT_shader_framebuffer_fetch_non_coherent provides limited implicit + coherency guarantees. Instead, the application is expected to call the + FramebufferFetchBarrierEXT command for previous framebuffer writes to + become visible to subsequent fragment shader invocations. For this + extension to give well-defined results applications may have to split + rendering into multiple passes separated with FramebufferFetchBarrierEXT + calls. The functionality provided by this extension is requested in the + shader source using the noncoherent layout qualifier. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/shader_framebuffer_fetch.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.EXT.shader_framebuffer_fetch import * +from OpenGL.raw.GLES2.EXT.shader_framebuffer_fetch import _EXTENSION_NAME + +def glInitShaderFramebufferFetchEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/shader_framebuffer_fetch_non_coherent.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/shader_framebuffer_fetch_non_coherent.py new file mode 100644 index 00000000..f5d4670e --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/shader_framebuffer_fetch_non_coherent.py @@ -0,0 +1,23 @@ +'''OpenGL extension EXT.shader_framebuffer_fetch_non_coherent + +This module customises the behaviour of the +OpenGL.raw.GLES2.EXT.shader_framebuffer_fetch_non_coherent to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/shader_framebuffer_fetch_non_coherent.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.EXT.shader_framebuffer_fetch_non_coherent import * +from OpenGL.raw.GLES2.EXT.shader_framebuffer_fetch_non_coherent import _EXTENSION_NAME + +def glInitShaderFramebufferFetchNonCoherentEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/shader_group_vote.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/shader_group_vote.py new file mode 100644 index 00000000..3eba4853 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/shader_group_vote.py @@ -0,0 +1,77 @@ +'''OpenGL extension EXT.shader_group_vote + +This module customises the behaviour of the +OpenGL.raw.GLES2.EXT.shader_group_vote to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides new built-in functions to compute the composite of + a set of boolean conditions across a group of shader invocations. These + composite results may be used to execute shaders more efficiently on a + single-instruction multiple-data (SIMD) processor. The set of shader + invocations across which boolean conditions are evaluated is + implementation-dependent, and this extension provides no guarantee over + how individual shader invocations are assigned to such sets. In + particular, the set of shader invocations has no necessary relationship + with the compute shader workgroup -- a pair of shader invocations + in a single compute shader workgroup may end up in different sets used by + these built-ins. + + Compute shaders operate on an explicitly specified group of threads (a + workgroup), but many implementations of OpenGL ES 3.0 will even group + non-compute shader invocations and execute them in a SIMD fashion. When + executing code like + + if (condition) { + result = do_fast_path(); + } else { + result = do_general_path(); + } + + where diverges between invocations, a SIMD implementation + might first call do_fast_path() for the invocations where is + true and leave the other invocations dormant. Once do_fast_path() + returns, it might call do_general_path() for invocations where + is false and leave the other invocations dormant. In this case, the + shader executes *both* the fast and the general path and might be better + off just using the general path for all invocations. + + This extension provides the ability to avoid divergent execution by + evaluting a condition across an entire SIMD invocation group using code + like: + + if (allInvocationsEXT(condition)) { + result = do_fast_path(); + } else { + result = do_general_path(); + } + + The built-in function allInvocationsEXT() will return the same value for + all invocations in the group, so the group will either execute + do_fast_path() or do_general_path(), but never both. For example, shader + code might want to evaluate a complex function iteratively by starting + with an approximation of the result and then refining the approximation. + Some input values may require a small number of iterations to generate an + accurate result (do_fast_path) while others require a larger number + (do_general_path). In another example, shader code might want to evaluate + a complex function (do_general_path) that can be greatly simplified when + assuming a specific value for one of its inputs (do_fast_path). + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/shader_group_vote.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.EXT.shader_group_vote import * +from OpenGL.raw.GLES2.EXT.shader_group_vote import _EXTENSION_NAME + +def glInitShaderGroupVoteEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/shader_implicit_conversions.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/shader_implicit_conversions.py new file mode 100644 index 00000000..d46e8086 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/shader_implicit_conversions.py @@ -0,0 +1,30 @@ +'''OpenGL extension EXT.shader_implicit_conversions + +This module customises the behaviour of the +OpenGL.raw.GLES2.EXT.shader_implicit_conversions to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides support for implicitly converting signed integer + types to unsigned types, as well as more general implicit conversion and + function overloading infrastructure to support new data types introduced by + other extensions. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/shader_implicit_conversions.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.EXT.shader_implicit_conversions import * +from OpenGL.raw.GLES2.EXT.shader_implicit_conversions import _EXTENSION_NAME + +def glInitShaderImplicitConversionsEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/shader_integer_mix.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/shader_integer_mix.py new file mode 100644 index 00000000..277a23e0 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/shader_integer_mix.py @@ -0,0 +1,30 @@ +'''OpenGL extension EXT.shader_integer_mix + +This module customises the behaviour of the +OpenGL.raw.GLES2.EXT.shader_integer_mix to provide a more +Python-friendly API + +Overview (from the spec) + + GLSL 1.30 (and GLSL ES 3.00) expanded the mix() built-in function to + operate on a boolean third argument that does not interpolate but + selects. This extension extends mix() to select between int, uint, + and bool components. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/shader_integer_mix.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.EXT.shader_integer_mix import * +from OpenGL.raw.GLES2.EXT.shader_integer_mix import _EXTENSION_NAME + +def glInitShaderIntegerMixEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/shader_io_blocks.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/shader_io_blocks.py new file mode 100644 index 00000000..14f71994 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/shader_io_blocks.py @@ -0,0 +1,49 @@ +'''OpenGL extension EXT.shader_io_blocks + +This module customises the behaviour of the +OpenGL.raw.GLES2.EXT.shader_io_blocks to provide a more +Python-friendly API + +Overview (from the spec) + + This extension extends the functionality of interface blocks to + support input and output interfaces in the OpenGL ES Shading Language. + + Input and output interface blocks are used for forming the + interfaces between vertex, tessellation control, tessellation + evaluation, geometry and fragment shaders. This accommodates passing + arrays between stages, which otherwise would require multi-dimensional + array support for tessellation control outputs and for tessellation + control, tessellation evaluation, and geometry shader inputs. + + This extension provides support for application defined + interface blocks which are used for passing application-specific + information between shader stages. + + This extension moves the built-in "per-vertex" in/out variables + to a new built-in gl_PerVertex block. This is necessary for + tessellation and geometry shaders which require a separate + instance for each vertex, but it can also be useful for vertex + shaders. + + Finally, this extension allows the redeclaration of the + gl_PerVertex block in order to reduce the set of variables that must + be passed between shaders. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/shader_io_blocks.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.EXT.shader_io_blocks import * +from OpenGL.raw.GLES2.EXT.shader_io_blocks import _EXTENSION_NAME + +def glInitShaderIoBlocksEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/shader_non_constant_global_initializers.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/shader_non_constant_global_initializers.py new file mode 100644 index 00000000..b1ff8544 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/shader_non_constant_global_initializers.py @@ -0,0 +1,30 @@ +'''OpenGL extension EXT.shader_non_constant_global_initializers + +This module customises the behaviour of the +OpenGL.raw.GLES2.EXT.shader_non_constant_global_initializers to provide a more +Python-friendly API + +Overview (from the spec) + + This extension adds the ability to use non-constant initializers for + global variables in the OpenGL ES Shading Language specifications. + This functionality is already present in the OpenGL Shading language + specification. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/shader_non_constant_global_initializers.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.EXT.shader_non_constant_global_initializers import * +from OpenGL.raw.GLES2.EXT.shader_non_constant_global_initializers import _EXTENSION_NAME + +def glInitShaderNonConstantGlobalInitializersEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/shader_pixel_local_storage.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/shader_pixel_local_storage.py new file mode 100644 index 00000000..cc1e4555 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/shader_pixel_local_storage.py @@ -0,0 +1,50 @@ +'''OpenGL extension EXT.shader_pixel_local_storage + +This module customises the behaviour of the +OpenGL.raw.GLES2.EXT.shader_pixel_local_storage to provide a more +Python-friendly API + +Overview (from the spec) + + Techniques such as deferred shading and deferred lighting are often + implemented by attaching multiple color render targets to a framebuffer + object, rendering the required intermediate data, and then sampling from + this data as textures. While flexible, this approach consumes a large + amount of external memory bandwidth, which is at a premium on mobile + devices. + + Observing that the intermediate or "G-buffer" data is often only written to + and read by shaders executing for the same pixel position, tile-based + renderers can offer a more efficient alternative by keeping the data on-GPU. + This allows large amounts of data to be kept per-pixel, with zero external + memory bandwidth impact. + + This extension provides a way for applications to pass information between + fragment shader invocations covering the same pixel by introducing the + concept of pixel local storage. Pixel local storage is an on-chip memory + storage that can be efficiently accessed by fragments being processed by + the GL. The format of data stored in the pixel local storage is independent + of the format of the currently attached framebuffer. The data in pixel local + storage is not written back to main memory. Access to pixel local storage + is controlled via glEnable and glDisable. If commands that implicitly or + explicitly flush the GL command stream are issued when pixel local storage + is enabled then the contents of the pixel local storage becomes undefined + for subsequent commands. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/shader_pixel_local_storage.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.EXT.shader_pixel_local_storage import * +from OpenGL.raw.GLES2.EXT.shader_pixel_local_storage import _EXTENSION_NAME + +def glInitShaderPixelLocalStorageEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/shader_pixel_local_storage2.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/shader_pixel_local_storage2.py new file mode 100644 index 00000000..b0114f17 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/shader_pixel_local_storage2.py @@ -0,0 +1,43 @@ +'''OpenGL extension EXT.shader_pixel_local_storage2 + +This module customises the behaviour of the +OpenGL.raw.GLES2.EXT.shader_pixel_local_storage2 to provide a more +Python-friendly API + +Overview (from the spec) + + This extension builds on EXT_shader_pixel_local_storage by lifting the + restriction that pixel local storage is not supported when rendering to + multiple draw buffers. + + Moreover, pixel local storage values are no longer lost when writing to + user-defined fragment outputs, and, correspondingly, framebuffer pixel + values do not always become undefined when the shader writes to pixel local + storage. + + This extension adds the following capabilities: + - support for pixel local storage in combination with multiple user- + defined fragment outputs + - support for clearing pixel local storage variables + - support for multi-word pixel local storage variables + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/shader_pixel_local_storage2.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.EXT.shader_pixel_local_storage2 import * +from OpenGL.raw.GLES2.EXT.shader_pixel_local_storage2 import _EXTENSION_NAME + +def glInitShaderPixelLocalStorage2EXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glClearPixelLocalStorageuiEXT.values size not checked against n +glClearPixelLocalStorageuiEXT=wrapper.wrapper(glClearPixelLocalStorageuiEXT).setInputArraySize( + 'values', None +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/shader_texture_lod.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/shader_texture_lod.py new file mode 100644 index 00000000..1f99ac51 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/shader_texture_lod.py @@ -0,0 +1,92 @@ +'''OpenGL extension EXT.shader_texture_lod + +This module customises the behaviour of the +OpenGL.raw.GLES2.EXT.shader_texture_lod to provide a more +Python-friendly API + +Overview (from the spec) + + This extension adds additional texture functions to the + OpenGL ES Shading Language which provide the shader writer + with explicit control of LOD. + + Mipmap texture fetches and anisotropic texture fetches + require implicit derivatives to calculate rho, lambda + and/or the line of anisotropy. These implicit derivatives + will be undefined for texture fetches occurring inside + non-uniform control flow or for vertex shader texture + fetches, resulting in undefined texels. + + The additional texture functions introduced with + this extension provide explicit control of LOD + (isotropic texture functions) or provide explicit + derivatives (anisotropic texture functions). + + Anisotropic texture functions return defined texels + for mipmap texture fetches or anisotropic texture fetches, + even inside non-uniform control flow. Isotropic texture + functions return defined texels for mipmap texture fetches, + even inside non-uniform control flow. However, isotropic + texture functions return undefined texels for anisotropic + texture fetches. + + The existing isotropic vertex texture functions: + + vec4 texture2DLodEXT(sampler2D sampler, + vec2 coord, + float lod); + vec4 texture2DProjLodEXT(sampler2D sampler, + vec3 coord, + float lod); + vec4 texture2DProjLodEXT(sampler2D sampler, + vec4 coord, + float lod); + + vec4 textureCubeLodEXT(samplerCube sampler, + vec3 coord, + float lod); + + are added to the built-in functions for fragment shaders + with "EXT" suffix appended. + + New anisotropic texture functions, providing explicit + derivatives: + + vec4 texture2DGradEXT(sampler2D sampler, + vec2 P, + vec2 dPdx, + vec2 dPdy); + vec4 texture2DProjGradEXT(sampler2D sampler, + vec3 P, + vec2 dPdx, + vec2 dPdy); + vec4 texture2DProjGradEXT(sampler2D sampler, + vec4 P, + vec2 dPdx, + vec2 dPdy); + + vec4 textureCubeGradEXT(samplerCube sampler, + vec3 P, + vec3 dPdx, + vec3 dPdy); + + are added to the built-in functions for vertex shaders + and fragment shaders. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/shader_texture_lod.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.EXT.shader_texture_lod import * +from OpenGL.raw.GLES2.EXT.shader_texture_lod import _EXTENSION_NAME + +def glInitShaderTextureLodEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/shadow_samplers.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/shadow_samplers.py new file mode 100644 index 00000000..d63cc29f --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/shadow_samplers.py @@ -0,0 +1,29 @@ +'''OpenGL extension EXT.shadow_samplers + +This module customises the behaviour of the +OpenGL.raw.GLES2.EXT.shadow_samplers to provide a more +Python-friendly API + +Overview (from the spec) + + This extension supports comparing the texture R coordinate to a depth + texture value returning the result as a float value in the range [0,1]. + This can be used to implement shadow maps. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/shadow_samplers.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.EXT.shadow_samplers import * +from OpenGL.raw.GLES2.EXT.shadow_samplers import _EXTENSION_NAME + +def glInitShadowSamplersEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/sparse_texture.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/sparse_texture.py new file mode 100644 index 00000000..4f1729cf --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/sparse_texture.py @@ -0,0 +1,42 @@ +'''OpenGL extension EXT.sparse_texture + +This module customises the behaviour of the +OpenGL.raw.GLES2.EXT.sparse_texture to provide a more +Python-friendly API + +Overview (from the spec) + + Recent advances in application complexity and a desire for higher + resolutions have pushed texture sizes up considerably. Often, the amount + of physical memory available to a graphics processor is a limiting factor + in the performance of texture-heavy applications. Once the available + physical memory is exhausted, paging may occur bringing performance down + considerably - or worse, the application may fail. Nevertheless, the amount + of address space available to the graphics processor has increased to the + point where many gigabytes - or even terabytes of address space may be + usable even though that amount of physical memory is not present. + + This extension allows the separation of the graphics processor's address + space (reservation) from the requirement that all textures must be + physically backed (commitment). This exposes a limited form of + virtualization for textures. Use cases include sparse (or partially + resident) textures, texture paging, on-demand and delayed loading of + texture assets and application controlled level of detail. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/sparse_texture.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.EXT.sparse_texture import * +from OpenGL.raw.GLES2.EXT.sparse_texture import _EXTENSION_NAME + +def glInitSparseTextureEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/sparse_texture2.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/sparse_texture2.py new file mode 100644 index 00000000..66b3da10 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/sparse_texture2.py @@ -0,0 +1,53 @@ +'''OpenGL extension EXT.sparse_texture2 + +This module customises the behaviour of the +OpenGL.raw.GLES2.EXT.sparse_texture2 to provide a more +Python-friendly API + +Overview (from the spec) + + This extension builds on the ARB_sparse_texture extension, providing the + following new functionality: + + * New built-in GLSL texture lookup and image load functions are provided + that return information on whether the texels accessed for the texture + lookup accessed uncommitted texture memory. + + * New built-in GLSL texture lookup functions are provided that specify a + minimum level of detail to use for lookups where the level of detail + is computed automatically. This allows shaders to avoid accessing + unpopulated portions of high-resolution levels of detail when it knows + that the memory accessed is unpopulated, either from a priori + knowledge or from feedback provided by the return value of previously + executed "sparse" texture lookup functions. + + * Reads of uncommitted texture memory will act as though such memory + were filled with zeroes; previously, the values returned by reads were + undefined. + + * Standard implementation-independent virtual page sizes for internal + formats required to be supported with sparse textures. These standard + sizes can be requested by leaving VIRTUAL_PAGE_SIZE_INDEX_ARB at its + initial value (0). + + * Support for creating sparse multisample and multisample array textures + is added. However, the virtual page sizes for such textures remain + fully implementation-dependent. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/sparse_texture2.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.EXT.sparse_texture2 import * +from OpenGL.raw.GLES2.EXT.sparse_texture2 import _EXTENSION_NAME + +def glInitSparseTexture2EXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/tessellation_point_size.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/tessellation_point_size.py new file mode 100644 index 00000000..82c81e87 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/tessellation_point_size.py @@ -0,0 +1,23 @@ +'''OpenGL extension EXT.tessellation_point_size + +This module customises the behaviour of the +OpenGL.raw.GLES2.EXT.tessellation_point_size to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/tessellation_point_size.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.EXT.tessellation_point_size import * +from OpenGL.raw.GLES2.EXT.tessellation_point_size import _EXTENSION_NAME + +def glInitTessellationPointSizeEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/tessellation_shader.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/tessellation_shader.py new file mode 100644 index 00000000..3ffe7128 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/tessellation_shader.py @@ -0,0 +1,100 @@ +'''OpenGL extension EXT.tessellation_shader + +This module customises the behaviour of the +OpenGL.raw.GLES2.EXT.tessellation_shader to provide a more +Python-friendly API + +Overview (from the spec) + + This extension introduces new tessellation stages and two new shader types + to the OpenGL ES primitive processing pipeline. These pipeline stages + operate on a new basic primitive type, called a patch. A patch consists + of a fixed-size collection of vertices, each with per-vertex attributes, + plus a number of associated per-patch attributes. Tessellation control + shaders transform an input patch specified by the application, computing + per-vertex and per-patch attributes for a new output patch. A + fixed-function tessellation primitive generator subdivides the patch, and + tessellation evaluation shaders are used to compute the position and + attributes of each vertex produced by the tessellator. + + When tessellation is active, it begins by running the optional + tessellation control shader. This shader consumes an input patch and + produces a new fixed-size output patch. The output patch consists of an + array of vertices, and a set of per-patch attributes. The per-patch + attributes include tessellation levels that control how finely the patch + will be tessellated. For each patch processed, multiple tessellation + control shader invocations are performed -- one per output patch vertex. + Each tessellation control shader invocation writes all the attributes of + its corresponding output patch vertex. A tessellation control shader may + also read the per-vertex outputs of other tessellation control shader + invocations, as well as read and write shared per-patch outputs. The + tessellation control shader invocations for a single patch effectively run + as a group. A built-in barrier() function is provided to allow + synchronization points where no shader invocation will continue until all + shader invocations have reached the barrier. + + The tessellation primitive generator then decomposes a patch into a new + set of primitives using the tessellation levels to determine how finely + tessellated the output should be. The primitive generator begins with + either a triangle or a quad, and splits each outer edge of the primitive + into a number of segments approximately equal to the corresponding element + of the outer tessellation level array. The interior of the primitive is + tessellated according to elements of the inner tessellation level array. + The primitive generator has three modes: "triangles" and "quads" split a + triangular or quad-shaped patch into a set of triangles that cover the + original patch; "isolines" splits a quad-shaped patch into a set of line + strips running across the patch horizontally. Each vertex generated by + the tessellation primitive generator is assigned a (u,v) or (u,v,w) + coordinate indicating its relative location in the subdivided triangle or + quad. + + For each vertex produced by the tessellation primitive generator, the + tessellation evaluation shader is run to compute its position and other + attributes of the vertex, using its (u,v) or (u,v,w) coordinate. When + computing final vertex attributes, the tessellation evaluation shader can + also read the attributes of any of the vertices of the patch written by + the tessellation control shader. Tessellation evaluation shader + invocations are completely independent, although all invocations for a + single patch share the same collection of input vertices and per-patch + attributes. + + The tessellator operates on vertices after they have been transformed by a + vertex shader. The primitives generated by the tessellator are passed + further down the OpenGL ES pipeline, where they can be used as inputs to + geometry shaders, transform feedback, and the rasterizer. + + The tessellation control and evaluation shaders are both optional. If + neither shader type is present, the tessellation stage has no effect. + However, if either a tessellation control or a tessellation evaluation + shader is present, the other must also be present. + + Not all tessellation shader implementations have the ability to write the + point size from a tessellation shader. Thus a second extension string and + shading language enable are provided for implementations which do + support tessellation shader point size. + + This extension relies on the EXT_shader_io_blocks extension to provide + the required functionality for declaring input and output blocks and + interfacing between shaders. + + This extension relies on the EXT_gpu_shader5 extension to provide the + 'precise' and 'fma' functionality which are necessary to ensure crack-free + tessellation. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/tessellation_shader.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.EXT.tessellation_shader import * +from OpenGL.raw.GLES2.EXT.tessellation_shader import _EXTENSION_NAME + +def glInitTessellationShaderEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/texture_border_clamp.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/texture_border_clamp.py new file mode 100644 index 00000000..57a9a121 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/texture_border_clamp.py @@ -0,0 +1,68 @@ +'''OpenGL extension EXT.texture_border_clamp + +This module customises the behaviour of the +OpenGL.raw.GLES2.EXT.texture_border_clamp to provide a more +Python-friendly API + +Overview (from the spec) + + OpenGL ES provides only a single clamping wrap mode: CLAMP_TO_EDGE. + However, the ability to clamp to a constant border color can be + useful to quickly detect texture coordinates that exceed their + expected limits or to dummy out any such accesses with transparency + or a neutral color in tiling or light maps. + + This extension defines an additional texture clamping algorithm. + CLAMP_TO_BORDER_EXT clamps texture coordinates at all mipmap levels + such that NEAREST and LINEAR filters of clamped coordinates return + only the constant border color. This does not add the ability for + textures to specify borders using glTexImage2D, but only to clamp + to a constant border value set using glTexParameter and + glSamplerParameter. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/texture_border_clamp.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.EXT.texture_border_clamp import * +from OpenGL.raw.GLES2.EXT.texture_border_clamp import _EXTENSION_NAME + +def glInitTextureBorderClampEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glTexParameterIivEXT.params size not checked against 'pname' +glTexParameterIivEXT=wrapper.wrapper(glTexParameterIivEXT).setInputArraySize( + 'params', None +) +# INPUT glTexParameterIuivEXT.params size not checked against 'pname' +glTexParameterIuivEXT=wrapper.wrapper(glTexParameterIuivEXT).setInputArraySize( + 'params', None +) +glGetTexParameterIivEXT=wrapper.wrapper(glGetTexParameterIivEXT).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetTexParameterIuivEXT=wrapper.wrapper(glGetTexParameterIuivEXT).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +# INPUT glSamplerParameterIivEXT.param size not checked against 'pname' +glSamplerParameterIivEXT=wrapper.wrapper(glSamplerParameterIivEXT).setInputArraySize( + 'param', None +) +# INPUT glSamplerParameterIuivEXT.param size not checked against 'pname' +glSamplerParameterIuivEXT=wrapper.wrapper(glSamplerParameterIuivEXT).setInputArraySize( + 'param', None +) +# INPUT glGetSamplerParameterIivEXT.params size not checked against 'pname' +glGetSamplerParameterIivEXT=wrapper.wrapper(glGetSamplerParameterIivEXT).setInputArraySize( + 'params', None +) +# INPUT glGetSamplerParameterIuivEXT.params size not checked against 'pname' +glGetSamplerParameterIuivEXT=wrapper.wrapper(glGetSamplerParameterIuivEXT).setInputArraySize( + 'params', None +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/texture_buffer.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/texture_buffer.py new file mode 100644 index 00000000..28f77a85 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/texture_buffer.py @@ -0,0 +1,63 @@ +'''OpenGL extension EXT.texture_buffer + +This module customises the behaviour of the +OpenGL.raw.GLES2.EXT.texture_buffer to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides a new texture type, called a buffer texture. + Buffer textures are one-dimensional arrays of texels whose storage comes + from an attached buffer object. When a buffer object is bound to a + buffer texture, a format is specified, and the data in the buffer object + is treated as an array of texels of the specified format. + + The use of a buffer object to provide storage allows the texture data to + be specified in a number of different ways: via buffer object loads + (BufferData), direct CPU writes (MapBuffer), or framebuffer readbacks to + pixel buffer objects (ReadPixels). A buffer object can also be loaded by + transform feedback, which captures + selected transformed attributes of vertices processed by the GL. Several + of these mechanisms do not require an extra data copy, which would be + required when using conventional TexImage-like entry points. + + Buffer textures do not support mipmapping, texture lookups with + normalized floating-point texture coordinates, and texture filtering of + any sort. + They can be accessed via single texel fetch operations in programmable + shaders, using a new sampler type and texel fetch function, and + access can be controlled using the same memory barrier operations + as for other texture types. + + Buffer textures are treated as (potentially large) one-dimensional + textures; the maximum texture size supported for buffer textures in the + initial implementation of this extension is 2^27 texels (note that this + extension only guarantees support for buffer textures with 2^16 texels, + but we expect most implementations to exceed that substantially). When a + buffer object is attached to a buffer texture, a size is not specified; + rather, the number of texels in the texture is taken by dividing the size + of the buffer object by the size of each texel. + + This extension also allows a sub-range of the buffer's data store to + be attached to a texture. This can be used, for example, to allow multiple + buffer textures to be backed by independent sub-ranges of the same buffer + object, or for different sub-ranges of a single buffer object to be used + for different purposes. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/texture_buffer.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.EXT.texture_buffer import * +from OpenGL.raw.GLES2.EXT.texture_buffer import _EXTENSION_NAME + +def glInitTextureBufferEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/texture_compression_astc_decode_mode.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/texture_compression_astc_decode_mode.py new file mode 100644 index 00000000..f286d0ef --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/texture_compression_astc_decode_mode.py @@ -0,0 +1,54 @@ +'''OpenGL extension EXT.texture_compression_astc_decode_mode + +This module customises the behaviour of the +OpenGL.raw.GLES2.EXT.texture_compression_astc_decode_mode to provide a more +Python-friendly API + +Overview (from the spec) + + Adaptive Scalable Texture Compression (ASTC) is a texture compression + technology that is exposed by existing extensions and specifications. + + The existing specifications require that low dynamic range (LDR) + textures are decompressed to FP16 values per component. In many cases, + decompressing LDR textures to a lower precision intermediate result gives + acceptable image quality. Source material for LDR textures is typically + authored as 8-bit UNORM values, so decoding to FP16 values adds little + value. On the other hand, reducing precision of the decoded result + reduces the size of the decompressed data, potentially improving texture + cache performance and saving power. + + The goal of this extension is to enable this efficiency gain on existing + ASTC texture data. This is achieved by giving the application the ability + to select the decoding precision. + + Two decoding options are provided by + GL_EXT_texture_compression_astc_decode_mode + - Decode to FP16: This is the default, and matches the required behavior + in existing APIs. + - Decode to UNORM8: This is provided as an option in LDR mode. + + If GL_EXT_texture_compression_astc_decode_mode_rgb9e5 is supported, then + a third decoding option is provided: + - Decode to RGB9_E5: This is provided as an option in both LDR and HDR + mode. In this mode, negative values cannot be represented and are + clamped to zero. The alpha component is ignored, and the results + are as if alpha was 1.0. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/texture_compression_astc_decode_mode.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.EXT.texture_compression_astc_decode_mode import * +from OpenGL.raw.GLES2.EXT.texture_compression_astc_decode_mode import _EXTENSION_NAME + +def glInitTextureCompressionAstcDecodeModeEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/texture_compression_bptc.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/texture_compression_bptc.py new file mode 100644 index 00000000..2f95e497 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/texture_compression_bptc.py @@ -0,0 +1,40 @@ +'''OpenGL extension EXT.texture_compression_bptc + +This module customises the behaviour of the +OpenGL.raw.GLES2.EXT.texture_compression_bptc to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides additional texture compression functionality + specific to the BPTC and BPTC_FLOAT compressed texture formats (called BC7 + and BC6H respectively in Microsoft's DirectX API). + + Traditional block compression methods as typified by s3tc and latc + compress a block of pixels into indicies along a gradient. This works well + for smooth images, but can have quality issues along sharp edges and + strong chrominance transitions. To improve quality in these problematic + cases, the BPTC formats can divide each block into multiple partitions, + each of which are compressed using an independent gradient. + + In addition, it is desirable to directly support high dynamic range + imagery in compressed formats, which is accomplished by the BPTC_FLOAT + formats. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/texture_compression_bptc.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.EXT.texture_compression_bptc import * +from OpenGL.raw.GLES2.EXT.texture_compression_bptc import _EXTENSION_NAME + +def glInitTextureCompressionBptcEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/texture_compression_dxt1.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/texture_compression_dxt1.py new file mode 100644 index 00000000..85de491a --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/texture_compression_dxt1.py @@ -0,0 +1,52 @@ +'''OpenGL extension EXT.texture_compression_dxt1 + +This module customises the behaviour of the +OpenGL.raw.GLES2.EXT.texture_compression_dxt1 to provide a more +Python-friendly API + +Overview (from the spec) + + Support of EXT_texture_compression_s3tc is attractive for OpenGL-ES + implementations because it provides compressed textures that allow + for significantly reduced texture storage. Reducing texture storage is + advantageous because of the smaller memory capacity of many embedded + systems compared to desktop systems. Smaller textures also provide a + welcome performance advantage since embedded platforms typically provide + less performance than desktop systems. S3TC compressed textures + are widely supported and used by applications. The DXT1 format is + used in the vast majority of cases in which S3TC compressed textures + are used. + + However, EXT_texture_compression_s3tc specifies functionality that is + burdensome for an OpenGL-ES implementation. In particular it requires + that the driver provide the capability to compress textures into + S3TC texture formats, as an S3TC texture format is accepted as the + parameter of TexImage2D and CopyTexImage2D. Further, + EXT_texture_compression_s3tc may require conversion from one S3TC + format to another during CompressedTexSubImage2D if the + parameter does not match the of the texture image + previously created by TexImage2D. + + In an OpenGL-ES implementation it is therefore advantageous to support + a limited subset of EXT_texture_compression_s3tc: Restrict supported + texture formats to DXT1 and restrict supported operations to those + that do not require texture compression into an S3TC texture format or + decompression from an S3TC texture format. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/texture_compression_dxt1.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.EXT.texture_compression_dxt1 import * +from OpenGL.raw.GLES2.EXT.texture_compression_dxt1 import _EXTENSION_NAME + +def glInitTextureCompressionDxt1EXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/texture_compression_rgtc.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/texture_compression_rgtc.py new file mode 100644 index 00000000..0e21ec05 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/texture_compression_rgtc.py @@ -0,0 +1,44 @@ +'''OpenGL extension EXT.texture_compression_rgtc + +This module customises the behaviour of the +OpenGL.raw.GLES2.EXT.texture_compression_rgtc to provide a more +Python-friendly API + +Overview (from the spec) + + This extension introduces four new block-based texture compression + formats suited for unsigned and signed red and red-green textures + (hence the name "rgtc" for Red-Green Texture Compression). + + These formats are designed to reduce the storage requirements + and memory bandwidth required for red and red-green textures by + a factor of 2-to-1 over conventional uncompressed luminance and + luminance-alpha textures with 8-bit components (GL_LUMINANCE8 and + GL_LUMINANCE8_ALPHA8). + + The compressed signed red-green format is reasonably suited for + storing compressed normal maps. + + This extension uses the same compression format as the + EXT_texture_compression_latc extension except the color data is stored + in the red and green components rather than luminance and alpha. + Representing compressed red and green components is consistent with + the BC4 and BC5 compressed formats supported by DirectX 10. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/texture_compression_rgtc.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.EXT.texture_compression_rgtc import * +from OpenGL.raw.GLES2.EXT.texture_compression_rgtc import _EXTENSION_NAME + +def glInitTextureCompressionRgtcEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/texture_compression_s3tc.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/texture_compression_s3tc.py new file mode 100644 index 00000000..8eb52094 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/texture_compression_s3tc.py @@ -0,0 +1,34 @@ +'''OpenGL extension EXT.texture_compression_s3tc + +This module customises the behaviour of the +OpenGL.raw.GLES2.EXT.texture_compression_s3tc to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides additional texture compression functionality + specific to S3's S3TC format (called DXTC in Microsoft's DirectX API), + subject to all the requirements and limitations described by the extension + GL_ARB_texture_compression. + + This extension supports DXT1, DXT3, and DXT5 texture compression formats. + For the DXT1 image format, this specification supports an RGB-only mode + and a special RGBA mode with single-bit "transparent" alpha. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/texture_compression_s3tc.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.EXT.texture_compression_s3tc import * +from OpenGL.raw.GLES2.EXT.texture_compression_s3tc import _EXTENSION_NAME + +def glInitTextureCompressionS3TcEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/texture_compression_s3tc_srgb.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/texture_compression_s3tc_srgb.py new file mode 100644 index 00000000..a9878e22 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/texture_compression_s3tc_srgb.py @@ -0,0 +1,28 @@ +'''OpenGL extension EXT.texture_compression_s3tc_srgb + +This module customises the behaviour of the +OpenGL.raw.GLES2.EXT.texture_compression_s3tc_srgb to provide a more +Python-friendly API + +Overview (from the spec) + + This extension adds new compressed color texture formats using S3TC with + nonlinear sRGB color components. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/texture_compression_s3tc_srgb.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.EXT.texture_compression_s3tc_srgb import * +from OpenGL.raw.GLES2.EXT.texture_compression_s3tc_srgb import _EXTENSION_NAME + +def glInitTextureCompressionS3TcSrgbEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/texture_cube_map_array.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/texture_cube_map_array.py new file mode 100644 index 00000000..2ffdebd3 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/texture_cube_map_array.py @@ -0,0 +1,45 @@ +'''OpenGL extension EXT.texture_cube_map_array + +This module customises the behaviour of the +OpenGL.raw.GLES2.EXT.texture_cube_map_array to provide a more +Python-friendly API + +Overview (from the spec) + + OpenGL ES 3.1 supports two-dimensional array textures. An array texture + is an ordered set of images with the same size and format. Each image in + an array texture has a unique level. This extension expands texture + array support to include cube map textures. + + A cube map array texture is a two-dimensional array texture that may + contain many cube map layers. Each cube map layer is a unique cube map + image set. Images in a cube map array have the same size and format + limitations as two-dimensional array textures. A cube map array texture + is specified using TexImage3D or TexStorage3D in a similar manner to + two-dimensional arrays. Cube map array textures can be bound to a render + targets of a frame buffer object just as two-dimensional arrays are, + using FramebufferTextureLayer. + + When accessed by a shader, a cube map array texture acts as a single + unit. The "s", "t", "r" texture coordinates are treated as a regular + cube map texture fetch. The "q" texture is treated as an unnormalized + floating-point value identifying the layer of the cube map array + texture. Cube map array texture lookups do not filter between layers. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/texture_cube_map_array.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.EXT.texture_cube_map_array import * +from OpenGL.raw.GLES2.EXT.texture_cube_map_array import _EXTENSION_NAME + +def glInitTextureCubeMapArrayEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/texture_filter_anisotropic.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/texture_filter_anisotropic.py new file mode 100644 index 00000000..c292256a --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/texture_filter_anisotropic.py @@ -0,0 +1,64 @@ +'''OpenGL extension EXT.texture_filter_anisotropic + +This module customises the behaviour of the +OpenGL.raw.GLES2.EXT.texture_filter_anisotropic to provide a more +Python-friendly API + +Overview (from the spec) + + Texture mapping using OpenGL's existing mipmap texture filtering + modes assumes that the projection of the pixel filter footprint into + texture space is a square (ie, isotropic). In practice however, the + footprint may be long and narrow (ie, anisotropic). Consequently, + mipmap filtering severely blurs images on surfaces angled obliquely + away from the viewer. + + Several approaches exist for improving texture sampling by accounting + for the anisotropic nature of the pixel filter footprint into texture + space. This extension provides a general mechanism for supporting + anisotropic texturing filtering schemes without specifying a + particular formulation of anisotropic filtering. + + The extension permits the OpenGL application to specify on + a per-texture object basis the maximum degree of anisotropy to + account for in texture filtering. + + Increasing a texture object's maximum degree of anisotropy may + improve texture filtering but may also significantly reduce the + implementation's texture filtering rate. Implementations are free + to clamp the specified degree of anisotropy to the implementation's + maximum supported degree of anisotropy. + + A texture's maximum degree of anisotropy is specified independent + from the texture's minification and magnification filter (as + opposed to being supported as an entirely new filtering mode). + Implementations are free to use the specified minification and + magnification filter to select a particular anisotropic texture + filtering scheme. For example, a NEAREST filter with a maximum + degree of anisotropy of two could be treated as a 2-tap filter that + accounts for the direction of anisotropy. Implementations are also + permitted to ignore the minification or magnification filter and + implement the highest quality of anisotropic filtering possible. + + Applications seeking the highest quality anisotropic filtering + available are advised to request a LINEAR_MIPMAP_LINEAR minification + filter, a LINEAR magnification filter, and a large maximum degree + of anisotropy. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/texture_filter_anisotropic.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.EXT.texture_filter_anisotropic import * +from OpenGL.raw.GLES2.EXT.texture_filter_anisotropic import _EXTENSION_NAME + +def glInitTextureFilterAnisotropicEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/texture_filter_minmax.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/texture_filter_minmax.py new file mode 100644 index 00000000..7126ff0d --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/texture_filter_minmax.py @@ -0,0 +1,39 @@ +'''OpenGL extension EXT.texture_filter_minmax + +This module customises the behaviour of the +OpenGL.raw.GLES2.EXT.texture_filter_minmax to provide a more +Python-friendly API + +Overview (from the spec) + + In unextended OpenGL 4.3, minification and magnification filters such as + LINEAR allow texture lookups to returned a filtered texel value produced + by computing an weighted average of a collection of texels in the + neighborhood of the texture coordinate provided. + + This extension provides a new texture and sampler parameter + (TEXTURE_REDUCTION_MODE_EXT) which allows applications to produce a + filtered texel value by computing a component-wise minimum (MIN) or + maximum (MAX) of the texels that would normally be averaged. The + reduction mode is orthogonal to the minification and magnification filter + parameters. The filter parameters are used to identify the set of texels + used to produce a final filtered value; the reduction mode identifies how + these texels are combined. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/texture_filter_minmax.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.EXT.texture_filter_minmax import * +from OpenGL.raw.GLES2.EXT.texture_filter_minmax import _EXTENSION_NAME + +def glInitTextureFilterMinmaxEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/texture_format_BGRA8888.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/texture_format_BGRA8888.py new file mode 100644 index 00000000..b76bace9 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/texture_format_BGRA8888.py @@ -0,0 +1,57 @@ +'''OpenGL extension EXT.texture_format_BGRA8888 + +This module customises the behaviour of the +OpenGL.raw.GLES2.EXT.texture_format_BGRA8888 to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides an additional format and type combination + for use when specifying texture data. The current allowed combinations + are: + + Internal Format External Format Type Bytes per Pixel + --------------- --------------- ---- --------------- + RGBA RGBA UNSIGNED_BYTE 4 + RGB RGB UNSIGNED_BYTE 3 + RGBA RGBA UNSIGNED_SHORT_4_4_4_4 2 + RGBA RGBA UNSIGNED_SHORT_5_5_5_1 2 + RGB RGB UNSIGNED_SHORT_5_6_5 2 + LUMINANCE_ALPHA LUMINANCE_ALPHA UNSIGNED_BYTE 2 + LUMINANCE LUMINANCE UNSIGNED_BYTE 1 + ALPHA ALPHA UNSIGNED_BYTE 1 + + + This table is extended to include format BGRA_EXT and type UNSIGNED_BYTE: + + Internal Format External Format Type Bytes per Pixel + --------------- --------------- ---- --------------- + BGRA_EXT BGRA_EXT UNSIGNED_BYTE 4 + RGBA RGBA UNSIGNED_BYTE 4 + RGB RGB UNSIGNED_BYTE 3 + RGBA RGBA UNSIGNED_SHORT_4_4_4_4 2 + RGBA RGBA UNSIGNED_SHORT_5_5_5_1 2 + RGB RGB UNSIGNED_SHORT_5_6_5 2 + LUMINANCE_ALPHA LUMINANCE_ALPHA UNSIGNED_BYTE 2 + LUMINANCE LUMINANCE UNSIGNED_BYTE 1 + ALPHA ALPHA UNSIGNED_BYTE 1 + + This format is renderable in versions of OpenGL ES from 2.0 onwards. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/texture_format_BGRA8888.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.EXT.texture_format_BGRA8888 import * +from OpenGL.raw.GLES2.EXT.texture_format_BGRA8888 import _EXTENSION_NAME + +def glInitTextureFormatBgra8888EXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/texture_format_sRGB_override.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/texture_format_sRGB_override.py new file mode 100644 index 00000000..ad11dce5 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/texture_format_sRGB_override.py @@ -0,0 +1,33 @@ +'''OpenGL extension EXT.texture_format_sRGB_override + +This module customises the behaviour of the +OpenGL.raw.GLES2.EXT.texture_format_sRGB_override to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides a new texture parameter to override the internal + format of a texture object; allowing a non-sRGB format to be overridden to + a corresponding sRGB format. For example, an RGB8 texture can be overridden + to SRGB8. Such an override will cause the RGB components to be "decoded" from + sRGB color space to linear as part of texture filtering. This can be useful for + applications where a texture was written with sRGB data using EXT_sRGB_write_control + or when sampling from an EGLImage that is known to contain sRGB color values. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/texture_format_sRGB_override.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.EXT.texture_format_sRGB_override import * +from OpenGL.raw.GLES2.EXT.texture_format_sRGB_override import _EXTENSION_NAME + +def glInitTextureFormatSrgbOverrideEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/texture_mirror_clamp_to_edge.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/texture_mirror_clamp_to_edge.py new file mode 100644 index 00000000..e568912f --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/texture_mirror_clamp_to_edge.py @@ -0,0 +1,35 @@ +'''OpenGL extension EXT.texture_mirror_clamp_to_edge + +This module customises the behaviour of the +OpenGL.raw.GLES2.EXT.texture_mirror_clamp_to_edge to provide a more +Python-friendly API + +Overview (from the spec) + + EXT_texture_mirror_clamp_to_edge extends the set of texture wrap modes to + include an additional mode (GL_MIRROR_CLAMP_TO_EDGE_EXT) that effectively uses + a texture map twice as large as the original image in which the additional + half of the new image is a mirror image of the original image. + + This new mode relaxes the need to generate images whose opposite edges + match by using the original image to generate a matching "mirror image". + This mode allows the texture to be mirrored only once in the negative + s, t, and r directions. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/texture_mirror_clamp_to_edge.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.EXT.texture_mirror_clamp_to_edge import * +from OpenGL.raw.GLES2.EXT.texture_mirror_clamp_to_edge import _EXTENSION_NAME + +def glInitTextureMirrorClampToEdgeEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/texture_norm16.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/texture_norm16.py new file mode 100644 index 00000000..1629565b --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/texture_norm16.py @@ -0,0 +1,32 @@ +'''OpenGL extension EXT.texture_norm16 + +This module customises the behaviour of the +OpenGL.raw.GLES2.EXT.texture_norm16 to provide a more +Python-friendly API + +Overview (from the spec) + + OpenGL ES 3.1 supports 8-bit (signed) normalized textures. + + This extension provides a set of new 16 bit signed normalized and + unsigned normalized fixed point texture, renderbuffer and + texture buffer formats. + + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/texture_norm16.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.EXT.texture_norm16 import * +from OpenGL.raw.GLES2.EXT.texture_norm16 import _EXTENSION_NAME + +def glInitTextureNorm16EXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/texture_query_lod.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/texture_query_lod.py new file mode 100644 index 00000000..afa53615 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/texture_query_lod.py @@ -0,0 +1,29 @@ +'''OpenGL extension EXT.texture_query_lod + +This module customises the behaviour of the +OpenGL.raw.GLES2.EXT.texture_query_lod to provide a more +Python-friendly API + +Overview (from the spec) + + This extension adds a new set of fragment shader texture functions + (textureLOD) that return the results of automatic level-of-detail + computations that would be performed if a texture lookup were performed. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/texture_query_lod.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.EXT.texture_query_lod import * +from OpenGL.raw.GLES2.EXT.texture_query_lod import _EXTENSION_NAME + +def glInitTextureQueryLodEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/texture_rg.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/texture_rg.py new file mode 100644 index 00000000..502f22e6 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/texture_rg.py @@ -0,0 +1,51 @@ +'''OpenGL extension EXT.texture_rg + +This module customises the behaviour of the +OpenGL.raw.GLES2.EXT.texture_rg to provide a more +Python-friendly API + +Overview (from the spec) + + Historically one- and two-component textures have been specified in OpenGL + ES using the luminance or luminance-alpha (L/LA) formats. With the advent + of programmable shaders and render-to-texture capabilities these legacy + formats carry some historical artifacts which are no longer useful. + + For example, when sampling from such textures, the luminance values are + replicated across the color components. This is no longer necessary with + programmable shaders. + + It is also desirable to be able to render to one- and two-component format + textures using capabilities such as framebuffer objects (FBO), but + rendering to L/LA formats is under-specified (specifically how to map + R/G/B/A values to L/A texture channels). + + This extension adds new base internal formats for one-component RED and + two-component RG (red green) textures as well as sized RED and RG internal + formats for renderbuffers. The RED and RG texture formats can be used for + both texturing and rendering into with framebuffer objects. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/texture_rg.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.EXT.texture_rg import * +from OpenGL.raw.GLES2.EXT.texture_rg import _EXTENSION_NAME + +def glInitTextureRgEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION +from OpenGL import images as _images +_images.COMPONENT_COUNTS.update( { +GL_R8_EXT:1, +GL_RED_EXT:1, +GL_RG8_EXT:2, +GL_RG_EXT:2, +}) diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/texture_sRGB_R8.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/texture_sRGB_R8.py new file mode 100644 index 00000000..6dca3ce5 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/texture_sRGB_R8.py @@ -0,0 +1,29 @@ +'''OpenGL extension EXT.texture_sRGB_R8 + +This module customises the behaviour of the +OpenGL.raw.GLES2.EXT.texture_sRGB_R8 to provide a more +Python-friendly API + +Overview (from the spec) + + This extension introduces SR8_EXT as an acceptable internal format. + This allows efficient sRGB sampling for source images stored as a separate + texture per channel. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/texture_sRGB_R8.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.EXT.texture_sRGB_R8 import * +from OpenGL.raw.GLES2.EXT.texture_sRGB_R8 import _EXTENSION_NAME + +def glInitTextureSrgbR8EXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/texture_sRGB_RG8.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/texture_sRGB_RG8.py new file mode 100644 index 00000000..775f5735 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/texture_sRGB_RG8.py @@ -0,0 +1,29 @@ +'''OpenGL extension EXT.texture_sRGB_RG8 + +This module customises the behaviour of the +OpenGL.raw.GLES2.EXT.texture_sRGB_RG8 to provide a more +Python-friendly API + +Overview (from the spec) + + This extension introduces SRG8_EXT as an acceptable internal format. + This allows efficient sRGB sampling for source images stored with 2 + channels. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/texture_sRGB_RG8.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.EXT.texture_sRGB_RG8 import * +from OpenGL.raw.GLES2.EXT.texture_sRGB_RG8 import _EXTENSION_NAME + +def glInitTextureSrgbRg8EXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/texture_sRGB_decode.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/texture_sRGB_decode.py new file mode 100644 index 00000000..15c54ad6 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/texture_sRGB_decode.py @@ -0,0 +1,41 @@ +'''OpenGL extension EXT.texture_sRGB_decode + +This module customises the behaviour of the +OpenGL.raw.GLES2.EXT.texture_sRGB_decode to provide a more +Python-friendly API + +Overview (from the spec) + + The EXT_texture_sRGB extension (promoted to core in OpenGL 2.1) + provides a texture format stored in the sRGB color space. Sampling one + of these textures will always return the color value decoded into a + linear color space. However, an application may wish to sample and + retrieve the undecoded sRGB data from the texture and manipulate + that directly. + + This extension adds a Texture Parameter and Sampler Object parameter to + allow sRGB textures to be read directly, without decoding. + + The new parameter, TEXTURE_SRGB_DECODE_EXT controls whether the + decoding happens at sample time. It only applies to textures with an + internal format that is sRGB and is ignored for all other textures. + This value defaults to DECODE_EXT, which indicates the texture + should be decoded to linear color space. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/texture_sRGB_decode.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.EXT.texture_sRGB_decode import * +from OpenGL.raw.GLES2.EXT.texture_sRGB_decode import _EXTENSION_NAME + +def glInitTextureSrgbDecodeEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/texture_shadow_lod.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/texture_shadow_lod.py new file mode 100644 index 00000000..0bfdcbde --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/texture_shadow_lod.py @@ -0,0 +1,35 @@ +'''OpenGL extension EXT.texture_shadow_lod + +This module customises the behaviour of the +OpenGL.raw.GLES2.EXT.texture_shadow_lod to provide a more +Python-friendly API + +Overview (from the spec) + + This extension adds support for various shadow sampler types with texture + functions having interactions with the LOD of texture lookups. Modern + shading languages support LOD queries for shadow sampler types, but until + now the OpenGL Shading Language Specification has excluded multiple texture + function overloads involving LOD calculations with various shadow samplers. + Shading languages for other APIs do support the equivalent LOD-based + texture sampling functions for these types which has made porting between + those shading languages to GLSL cumbersome and has required the usage of + sub-optimal workarounds. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/texture_shadow_lod.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.EXT.texture_shadow_lod import * +from OpenGL.raw.GLES2.EXT.texture_shadow_lod import _EXTENSION_NAME + +def glInitTextureShadowLodEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/texture_storage.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/texture_storage.py new file mode 100644 index 00000000..359a00bf --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/texture_storage.py @@ -0,0 +1,45 @@ +'''OpenGL extension EXT.texture_storage + +This module customises the behaviour of the +OpenGL.raw.GLES2.EXT.texture_storage to provide a more +Python-friendly API + +Overview (from the spec) + + The texture image specification commands in OpenGL allow each level + to be separately specified with different sizes, formats, types and + so on, and only imposes consistency checks at draw time. This adds + overhead for implementations. + + This extension provides a mechanism for specifying the entire + structure of a texture in a single call, allowing certain + consistency checks and memory allocations to be done up front. Once + specified, the format and dimensions of the image array become + immutable, to simplify completeness checks in the implementation. + + When using this extension, it is no longer possible to supply texture + data using TexImage*. Instead, data can be uploaded using TexSubImage*, + or produced by other means (such as render-to-texture, mipmap generation, + or rendering to a sibling EGLImage). + + This extension has complicated interactions with other extensions. + The goal of most of these interactions is to ensure that a texture + is always mipmap complete (and cube complete for cubemap textures). + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/texture_storage.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.EXT.texture_storage import * +from OpenGL.raw.GLES2.EXT.texture_storage import _EXTENSION_NAME + +def glInitTextureStorageEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/texture_type_2_10_10_10_REV.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/texture_type_2_10_10_10_REV.py new file mode 100644 index 00000000..f71a1e01 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/texture_type_2_10_10_10_REV.py @@ -0,0 +1,28 @@ +'''OpenGL extension EXT.texture_type_2_10_10_10_REV + +This module customises the behaviour of the +OpenGL.raw.GLES2.EXT.texture_type_2_10_10_10_REV to provide a more +Python-friendly API + +Overview (from the spec) + + This extension adds a new texture data type, unsigned 2.10.10.10 ABGR, + which can be used with RGB or RGBA formats. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/texture_type_2_10_10_10_REV.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.EXT.texture_type_2_10_10_10_REV import * +from OpenGL.raw.GLES2.EXT.texture_type_2_10_10_10_REV import _EXTENSION_NAME + +def glInitTextureType2101010RevEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/texture_view.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/texture_view.py new file mode 100644 index 00000000..9212b901 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/texture_view.py @@ -0,0 +1,52 @@ +'''OpenGL extension EXT.texture_view + +This module customises the behaviour of the +OpenGL.raw.GLES2.EXT.texture_view to provide a more +Python-friendly API + +Overview (from the spec) + + This extension allows a texture's data store to be "viewed" in multiple + ways, either reinterpreting the data format/type as a different format/ + type with the same element size, or by clamping the mipmap level range + or array slice range. + + The goals of this extension are to avoid having these alternate views + become shared mutable containers of shared mutable objects, and to add + the views to the API in a minimally invasive way. + + No new object types are added. Conceptually, a texture object is split + into the following parts: + + - A data store holding texel data. + - State describing which portions of the data store to use, and how + to interpret the data elements. + - An embedded sampler object. + - Various other texture parameters. + + With this extension, multiple textures can share a data store and have + different state describing which portions of the data store to use and + how to interpret the data elements. The data store is refcounted and not + destroyed until the last texture sharing it is deleted. + + This extension leverages the concept of an "immutable texture". + Views can only be created of textures created with TexStorage*. + + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/texture_view.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.EXT.texture_view import * +from OpenGL.raw.GLES2.EXT.texture_view import _EXTENSION_NAME + +def glInitTextureViewEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/unpack_subimage.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/unpack_subimage.py new file mode 100644 index 00000000..c8ca1e75 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/unpack_subimage.py @@ -0,0 +1,31 @@ +'''OpenGL extension EXT.unpack_subimage + +This module customises the behaviour of the +OpenGL.raw.GLES2.EXT.unpack_subimage to provide a more +Python-friendly API + +Overview (from the spec) + + This OpenGL ES 2.0 extension adds support for GL_UNPACK_ROW_LENGTH, + GL_UNPACK_SKIP_ROWS and GL_UNPACK_SKIP_PIXELS as valid enums to + PixelStore. The functionality is the same as in OpenGL. These are + useful for updating textures with a sub-rectangle of pixel data + coming from a larger image in host memory. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/unpack_subimage.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.EXT.unpack_subimage import * +from OpenGL.raw.GLES2.EXT.unpack_subimage import _EXTENSION_NAME + +def glInitUnpackSubimageEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/win32_keyed_mutex.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/win32_keyed_mutex.py new file mode 100644 index 00000000..42775447 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/win32_keyed_mutex.py @@ -0,0 +1,31 @@ +'''OpenGL extension EXT.win32_keyed_mutex + +This module customises the behaviour of the +OpenGL.raw.GLES2.EXT.win32_keyed_mutex to provide a more +Python-friendly API + +Overview (from the spec) + + Direct3D image objects may have a built-in synchronization primitive + associated with them that can be used to synchronize access to their + contents across process and API boundaries. This extension provides + access to that synchronization primitive via two new commands that + operate on GL memory objects. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/win32_keyed_mutex.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.EXT.win32_keyed_mutex import * +from OpenGL.raw.GLES2.EXT.win32_keyed_mutex import _EXTENSION_NAME + +def glInitWin32KeyedMutexEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/window_rectangles.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/window_rectangles.py new file mode 100644 index 00000000..6944b4a1 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/EXT/window_rectangles.py @@ -0,0 +1,52 @@ +'''OpenGL extension EXT.window_rectangles + +This module customises the behaviour of the +OpenGL.raw.GLES2.EXT.window_rectangles to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides additional orthogonally aligned "window + rectangles" specified in window-space coordinates that restrict + rasterization of all primitive types (geometry, images, paths) + and framebuffer clears. + + When rendering to the framebuffer of an on-screen window, these + window rectangles are ignored so these window rectangles apply to + rendering to non-zero framebuffer objects only. + + From zero to an implementation-dependent limit (specified by + GL_MAX_WINDOW_RECTANGLES_EXT) number of window rectangles can be + operational at once. When one or more window rectangles are active, + rasterized fragments can either survive if the fragment is within + any of the operational window rectangles (GL_INCLUSIVE_EXT mode) or + be rejected if the fragment is within any of the operational window + rectangles (GL_EXCLUSIVE_EXT mode). + + These window rectangles operate orthogonally to the existing scissor + test functionality. + + This extension has specification language for both OpenGL and ES so + EXT_window_rectangles can be implemented and advertised for either + or both API contexts. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/window_rectangles.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.EXT.window_rectangles import * +from OpenGL.raw.GLES2.EXT.window_rectangles import _EXTENSION_NAME + +def glInitWindowRectanglesEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glWindowRectanglesEXT.box size not checked against 'count' +glWindowRectanglesEXT=wrapper.wrapper(glWindowRectanglesEXT).setInputArraySize( + 'box', None +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/FJ/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/FJ/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/FJ/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/FJ/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/FJ/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..cc88cc75 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/FJ/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/FJ/__pycache__/shader_binary_GCCSO.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/FJ/__pycache__/shader_binary_GCCSO.cpython-312.pyc new file mode 100644 index 00000000..f9c1b305 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/FJ/__pycache__/shader_binary_GCCSO.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/FJ/shader_binary_GCCSO.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/FJ/shader_binary_GCCSO.py new file mode 100644 index 00000000..142bb086 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/FJ/shader_binary_GCCSO.py @@ -0,0 +1,28 @@ +'''OpenGL extension FJ.shader_binary_GCCSO + +This module customises the behaviour of the +OpenGL.raw.GLES2.FJ.shader_binary_GCCSO to provide a more +Python-friendly API + +Overview (from the spec) + + This extension enables loading precompiled binary shaders compatible with + chips designed by Fujitsu Semiconductor. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/FJ/shader_binary_GCCSO.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.FJ.shader_binary_GCCSO import * +from OpenGL.raw.GLES2.FJ.shader_binary_GCCSO import _EXTENSION_NAME + +def glInitShaderBinaryGccsoFJ(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/IMG/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/IMG/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/IMG/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/IMG/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/IMG/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..ded344fd Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/IMG/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/IMG/__pycache__/bindless_texture.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/IMG/__pycache__/bindless_texture.cpython-312.pyc new file mode 100644 index 00000000..eb88596d Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/IMG/__pycache__/bindless_texture.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/IMG/__pycache__/framebuffer_downsample.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/IMG/__pycache__/framebuffer_downsample.cpython-312.pyc new file mode 100644 index 00000000..792cb818 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/IMG/__pycache__/framebuffer_downsample.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/IMG/__pycache__/multisampled_render_to_texture.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/IMG/__pycache__/multisampled_render_to_texture.cpython-312.pyc new file mode 100644 index 00000000..c1be64e2 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/IMG/__pycache__/multisampled_render_to_texture.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/IMG/__pycache__/program_binary.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/IMG/__pycache__/program_binary.cpython-312.pyc new file mode 100644 index 00000000..d2028257 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/IMG/__pycache__/program_binary.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/IMG/__pycache__/read_format.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/IMG/__pycache__/read_format.cpython-312.pyc new file mode 100644 index 00000000..df82546c Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/IMG/__pycache__/read_format.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/IMG/__pycache__/shader_binary.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/IMG/__pycache__/shader_binary.cpython-312.pyc new file mode 100644 index 00000000..da965f1e Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/IMG/__pycache__/shader_binary.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/IMG/__pycache__/texture_compression_pvrtc.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/IMG/__pycache__/texture_compression_pvrtc.cpython-312.pyc new file mode 100644 index 00000000..f43bef99 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/IMG/__pycache__/texture_compression_pvrtc.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/IMG/__pycache__/texture_compression_pvrtc2.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/IMG/__pycache__/texture_compression_pvrtc2.cpython-312.pyc new file mode 100644 index 00000000..bb087bc1 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/IMG/__pycache__/texture_compression_pvrtc2.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/IMG/__pycache__/texture_filter_cubic.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/IMG/__pycache__/texture_filter_cubic.cpython-312.pyc new file mode 100644 index 00000000..ef434730 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/IMG/__pycache__/texture_filter_cubic.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/IMG/bindless_texture.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/IMG/bindless_texture.py new file mode 100644 index 00000000..f3f5c43c --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/IMG/bindless_texture.py @@ -0,0 +1,50 @@ +'''OpenGL extension IMG.bindless_texture + +This module customises the behaviour of the +OpenGL.raw.GLES2.IMG.bindless_texture to provide a more +Python-friendly API + +Overview (from the spec) + + This extension allows OpenGL ES applications to access texture objects in + shaders without first binding each texture to one of a limited number of + texture image units. Using this extension, an application can query a + 64-bit unsigned integer texture handle for each texture that it wants to + access and then use that handle directly in GLSL ES. This extensions + significantly reduces the amount of API and internal GL driver overhead + needed to manage resource bindings. + + This extension adds no new data types to GLSL. Instead, it uses existing + sampler data types and allows them to be populated with texture handles. + This extension also permits sampler types to be used as uniform block + members as well as default uniforms. Additionally, new APIs are provided to + load values for sampler uniforms with 64-bit handle inputs. The use of + existing integer-based Uniform* APIs is still permitted, in which case the + integer specified will identify a texture image. For samplers with values + specified as texture image units, the GL implementation will translate the + unit number to an internal handle as required. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/IMG/bindless_texture.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.IMG.bindless_texture import * +from OpenGL.raw.GLES2.IMG.bindless_texture import _EXTENSION_NAME + +def glInitBindlessTextureIMG(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glUniformHandleui64vIMG.value size not checked against count +glUniformHandleui64vIMG=wrapper.wrapper(glUniformHandleui64vIMG).setInputArraySize( + 'value', None +) +# INPUT glProgramUniformHandleui64vIMG.values size not checked against count +glProgramUniformHandleui64vIMG=wrapper.wrapper(glProgramUniformHandleui64vIMG).setInputArraySize( + 'values', None +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/IMG/framebuffer_downsample.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/IMG/framebuffer_downsample.py new file mode 100644 index 00000000..670a00e4 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/IMG/framebuffer_downsample.py @@ -0,0 +1,36 @@ +'''OpenGL extension IMG.framebuffer_downsample + +This module customises the behaviour of the +OpenGL.raw.GLES2.IMG.framebuffer_downsample to provide a more +Python-friendly API + +Overview (from the spec) + + This extension introduces the ability to attach color buffers to a + framebuffer that are at a lower resolution than the framebuffer itself, with + the GPU automatically downsampling the color attachment to fit. + + This can be useful for various post-process rendering techniques where it is + desirable to generate downsampled images in an efficient manner, or for a + lower resolution post-process technique. + + This extension exposes at least a 2 x 2 downscale. Other downsampling modes + may be exposed on the system and this can be queried. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/IMG/framebuffer_downsample.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.IMG.framebuffer_downsample import * +from OpenGL.raw.GLES2.IMG.framebuffer_downsample import _EXTENSION_NAME + +def glInitFramebufferDownsampleIMG(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/IMG/multisampled_render_to_texture.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/IMG/multisampled_render_to_texture.py new file mode 100644 index 00000000..550d7b74 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/IMG/multisampled_render_to_texture.py @@ -0,0 +1,51 @@ +'''OpenGL extension IMG.multisampled_render_to_texture + +This module customises the behaviour of the +OpenGL.raw.GLES2.IMG.multisampled_render_to_texture to provide a more +Python-friendly API + +Overview (from the spec) + + This extension introduces functionality to perform multisampled + rendering to a color renderable texture, without requiring an + explicit resolve of multisample data. + + Some GPU architectures - such as tile-based renderers - are + capable of performing multisampled rendering by storing + multisample data in internal high-speed memory and downsampling the + data when writing out to external memory after rendering has + finished. Since per-sample data is never written out to external + memory, this approach saves bandwidth and storage space. In this + case multisample data gets discarded, however this is acceptable + in most cases. + + The extension provides a new command, FramebufferTexture2DMultisampleIMG, + which attaches a texture level to a framebuffer and enables + multisampled rendering to that texture level. + + When the texture level is used as a source or destination for any + operation other than drawing to it, an implicit resolve of + multisampled color data is performed. After such a resolve, the + multisampled color data is discarded. + + In order to allow the use of multisampled depth and stencil buffers + when performing multisampled rendering to a texture, the extension + also adds the command RenderbufferStorageMultisampleIMG. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/IMG/multisampled_render_to_texture.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.IMG.multisampled_render_to_texture import * +from OpenGL.raw.GLES2.IMG.multisampled_render_to_texture import _EXTENSION_NAME + +def glInitMultisampledRenderToTextureIMG(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/IMG/program_binary.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/IMG/program_binary.py new file mode 100644 index 00000000..dd460b55 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/IMG/program_binary.py @@ -0,0 +1,29 @@ +'''OpenGL extension IMG.program_binary + +This module customises the behaviour of the +OpenGL.raw.GLES2.IMG.program_binary to provide a more +Python-friendly API + +Overview (from the spec) + + This extension makes available a program binary format, SGX_PROGRAM_BINARY_IMG. + It enables retrieving and loading of pre-linked program objects on chips designed + by Imagination Technologies. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/IMG/program_binary.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.IMG.program_binary import * +from OpenGL.raw.GLES2.IMG.program_binary import _EXTENSION_NAME + +def glInitProgramBinaryIMG(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/IMG/read_format.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/IMG/read_format.py new file mode 100644 index 00000000..892e6033 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/IMG/read_format.py @@ -0,0 +1,45 @@ +'''OpenGL extension IMG.read_format + +This module customises the behaviour of the +OpenGL.raw.GLES2.IMG.read_format to provide a more +Python-friendly API + +Overview (from the spec) + + This extension is intended to supplement the GL_OES_read_format + extension by adding support for more format/type combinations to be used + when calling ReadPixels. ReadPixels currently accepts one fixed + format/type combination (format RGBA and type UNSIGNED_BYTE) for + portability, and an implementation specific format/type combination + queried using the tokens IMPLEMENTATION_COLOR_READ_FORMAT_OES and + IMPLEMENTATION_COLOR_READ_TYPE_OES (GL_OES_read_format extension). This + extension adds the following format/type combinations to those currently + allowed to be returned by GetIntegerV: + + format type + ------ ---- + BGRA_IMG UNSIGNED_BYTE + BGRA_IMG UNSIGNED_SHORT_4_4_4_4_REV_IMG + + E.g. Calling GetIntegerv with a parameter of + IMPLEMENTATION_COLOR_READ_FORMAT_OES can now return BGRA, with the + corresponding call to GetIntegerv using a parameter of + IMPLEMENTATION_COLOR_READ_TYPE_OES returning UNSIGNED_BYTE; + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/IMG/read_format.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.IMG.read_format import * +from OpenGL.raw.GLES2.IMG.read_format import _EXTENSION_NAME + +def glInitReadFormatIMG(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/IMG/shader_binary.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/IMG/shader_binary.py new file mode 100644 index 00000000..24a2d1bf --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/IMG/shader_binary.py @@ -0,0 +1,28 @@ +'''OpenGL extension IMG.shader_binary + +This module customises the behaviour of the +OpenGL.raw.GLES2.IMG.shader_binary to provide a more +Python-friendly API + +Overview (from the spec) + + This extension enables loading precompiled binary shaders compatible with + chips designed by Imagination Technologies. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/IMG/shader_binary.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.IMG.shader_binary import * +from OpenGL.raw.GLES2.IMG.shader_binary import _EXTENSION_NAME + +def glInitShaderBinaryIMG(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/IMG/texture_compression_pvrtc.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/IMG/texture_compression_pvrtc.py new file mode 100644 index 00000000..e0a4f312 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/IMG/texture_compression_pvrtc.py @@ -0,0 +1,36 @@ +'''OpenGL extension IMG.texture_compression_pvrtc + +This module customises the behaviour of the +OpenGL.raw.GLES2.IMG.texture_compression_pvrtc to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides additional texture compression functionality + specific to Imagination Technologies PowerVR Texture compression format + (called PVRTC) subject to all the requirements and limitations described + by the OpenGL 1.3 specifications. + + This extension supports 4 and 2 bit per pixel texture compression + formats. Because the compression of PVRTC is very CPU intensive, + it is not appropriate to carry out compression on the target + platform. Therefore this extension only supports the loading of + compressed texture data. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/IMG/texture_compression_pvrtc.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.IMG.texture_compression_pvrtc import * +from OpenGL.raw.GLES2.IMG.texture_compression_pvrtc import _EXTENSION_NAME + +def glInitTextureCompressionPvrtcIMG(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/IMG/texture_compression_pvrtc2.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/IMG/texture_compression_pvrtc2.py new file mode 100644 index 00000000..a5092b36 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/IMG/texture_compression_pvrtc2.py @@ -0,0 +1,36 @@ +'''OpenGL extension IMG.texture_compression_pvrtc2 + +This module customises the behaviour of the +OpenGL.raw.GLES2.IMG.texture_compression_pvrtc2 to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides additional texture compression functionality + specific to Imagination Technologies PowerVR Texture compression format + (called PVRTC2) subject to all the requirements and limitations + described by the OpenGL ES 2.0 specification. + + This extension supports 4 and 2 bit per pixel texture compression + formats. Because the compression of PVRTC2 is CPU intensive, + it is not appropriate to carry out compression on the target + platform. Therefore this extension only supports the loading of + compressed texture data. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/IMG/texture_compression_pvrtc2.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.IMG.texture_compression_pvrtc2 import * +from OpenGL.raw.GLES2.IMG.texture_compression_pvrtc2 import _EXTENSION_NAME + +def glInitTextureCompressionPvrtc2IMG(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/IMG/texture_filter_cubic.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/IMG/texture_filter_cubic.py new file mode 100644 index 00000000..3766f3ea --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/IMG/texture_filter_cubic.py @@ -0,0 +1,39 @@ +'''OpenGL extension IMG.texture_filter_cubic + +This module customises the behaviour of the +OpenGL.raw.GLES2.IMG.texture_filter_cubic to provide a more +Python-friendly API + +Overview (from the spec) + + OpenGL ES provides two sampling methods available; nearest neighbor or + linear filtering, with optional MIP Map sampling modes added to move between + differently sized textures when downsampling. + + This extension adds an additional, high quality cubic filtering mode, using + a Catmull-Rom bicubic filter. Performing this kind of filtering can be done + in a shader by using 16 samples, but this can be inefficient. The cubic + filter mode exposes an optimized high quality texture sampling using fixed + functionality. + + This extension affects the way textures are sampled, by modifying the way + texels within the same MIP-Map level are sampled and resolved. It does not + affect MIP-Map filtering, which is still limited to linear or nearest. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/IMG/texture_filter_cubic.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.IMG.texture_filter_cubic import * +from OpenGL.raw.GLES2.IMG.texture_filter_cubic import _EXTENSION_NAME + +def glInitTextureFilterCubicIMG(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/INTEL/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/INTEL/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/INTEL/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/INTEL/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/INTEL/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..c2bfb824 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/INTEL/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/INTEL/__pycache__/blackhole_render.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/INTEL/__pycache__/blackhole_render.cpython-312.pyc new file mode 100644 index 00000000..16bdd826 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/INTEL/__pycache__/blackhole_render.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/INTEL/__pycache__/conservative_rasterization.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/INTEL/__pycache__/conservative_rasterization.cpython-312.pyc new file mode 100644 index 00000000..3cb30771 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/INTEL/__pycache__/conservative_rasterization.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/INTEL/__pycache__/framebuffer_CMAA.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/INTEL/__pycache__/framebuffer_CMAA.cpython-312.pyc new file mode 100644 index 00000000..a1ba1dfe Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/INTEL/__pycache__/framebuffer_CMAA.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/INTEL/__pycache__/performance_query.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/INTEL/__pycache__/performance_query.cpython-312.pyc new file mode 100644 index 00000000..cbaf2166 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/INTEL/__pycache__/performance_query.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/INTEL/blackhole_render.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/INTEL/blackhole_render.py new file mode 100644 index 00000000..0506a71d --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/INTEL/blackhole_render.py @@ -0,0 +1,34 @@ +'''OpenGL extension INTEL.blackhole_render + +This module customises the behaviour of the +OpenGL.raw.GLES2.INTEL.blackhole_render to provide a more +Python-friendly API + +Overview (from the spec) + + The purpose of this extension is to allow an application to disable all + rendering operations emitted to the GPU through the OpenGL rendering + commands (Draw*, DispatchCompute*, BlitFramebuffer, etc...). Changes to the + OpenGL pipeline are not affected. + + New preprocessor #defines are added to the OpenGL Shading Language: + + #define GL_INTEL_blackhole_render 1 + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/INTEL/blackhole_render.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.INTEL.blackhole_render import * +from OpenGL.raw.GLES2.INTEL.blackhole_render import _EXTENSION_NAME + +def glInitBlackholeRenderINTEL(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/INTEL/conservative_rasterization.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/INTEL/conservative_rasterization.py new file mode 100644 index 00000000..68c14593 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/INTEL/conservative_rasterization.py @@ -0,0 +1,41 @@ +'''OpenGL extension INTEL.conservative_rasterization + +This module customises the behaviour of the +OpenGL.raw.GLES2.INTEL.conservative_rasterization to provide a more +Python-friendly API + +Overview (from the spec) + + Regular rasterization includes fragments with at least one + sample covered by a polygon. Conservative rasterization includes all + fragments that are at least partially covered by the polygon. + + In some use cases, it is also important to know if a fragment is fully + covered by a polygon, i.e. if all parts of the fragment are within the + polygon. An application may, for example, want to process fully covered + fragments different from the "edge" pixels. This extension adds an option + for the fragment shader to receive this information via gl_SampleMaskIn[]. + + This extension affects only polygons in FILL mode and specifically does not + imply any changes in processing of lines or points. + + Conservative rasterization automatically disables polygon antialiasing + rasterization if enabled by POLYGON_SMOOTH. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/INTEL/conservative_rasterization.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.INTEL.conservative_rasterization import * +from OpenGL.raw.GLES2.INTEL.conservative_rasterization import _EXTENSION_NAME + +def glInitConservativeRasterizationINTEL(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/INTEL/framebuffer_CMAA.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/INTEL/framebuffer_CMAA.py new file mode 100644 index 00000000..fbcffacc --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/INTEL/framebuffer_CMAA.py @@ -0,0 +1,42 @@ +'''OpenGL extension INTEL.framebuffer_CMAA + +This module customises the behaviour of the +OpenGL.raw.GLES2.INTEL.framebuffer_CMAA to provide a more +Python-friendly API + +Overview (from the spec) + + Multisampling is a mechanism to antialias all GL primitives and is part of + the GL specification. + + Better visual quality can be achieved by applying multisampling. However, + on certain platforms it comes at a high performance cost. In general, the + greater number of samples per pixel, the bigger the cost. + + Conservative Morphological Anti-Aliasing (CMAA) is an alternative approach + to antialiasing, which operates on the final image. This post processing + technique results in image quality comparable to multisampling at much + lower cost and better performance. + + This extension incorporates an optimized CMAA algorithm implementation into + the GL implementation. + + For more information on CMAA refer to http://software.intel.com. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/INTEL/framebuffer_CMAA.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.INTEL.framebuffer_CMAA import * +from OpenGL.raw.GLES2.INTEL.framebuffer_CMAA import _EXTENSION_NAME + +def glInitFramebufferCmaaINTEL(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/INTEL/performance_query.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/INTEL/performance_query.py new file mode 100644 index 00000000..a102b886 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/INTEL/performance_query.py @@ -0,0 +1,64 @@ +'''OpenGL extension INTEL.performance_query + +This module customises the behaviour of the +OpenGL.raw.GLES2.INTEL.performance_query to provide a more +Python-friendly API + +Overview (from the spec) + + The purpose of this extension is to expose Intel proprietary hardware + performance counters to the OpenGL applications. Performance counters may + count: + + - number of hardware events such as number of spawned vertex shaders. In + this case the results represent the number of events. + + - duration of certain activity, like time took by all fragment shader + invocations. In that case the result usually represents the number of + clocks in which the particular HW unit was busy. In order to use such + counter efficiently, it should be normalized to the range of <0,1> by + dividing its value by the number of render clocks. + + - used throughput of certain memory types such as texture memory. In that + case the result of performance counter usually represents the number of + bytes transferred between GPU and memory. + + This extension specifies universal API to manage performance counters on + different Intel hardware platforms. Performance counters are grouped + together into proprietary, hardware-specific, fixed sets of counters that + are measured together by the GPU. + + It is assumed that performance counters are started and ended on any + arbitrary boundaries during rendering. + + A set of performance counters is represented by a unique query type. Each + query type is identified by assigned name and ID. Multiple query types + (sets of performance counters) are supported by the Intel hardware. However + each Intel hardware generation supports different sets of performance + counters. Therefore the query types between hardware generations can be + different. The definition of query types and their results structures can + be learned through the API. It is also documented in a separate document of + Intel OGL Performance Counters Specification issued per each new hardware + generation. + + The API allows to create multiple instances of any query type and to sample + different fragments of 3D rendering with such instances. Query instances + are identified with handles. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/INTEL/performance_query.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.INTEL.performance_query import * +from OpenGL.raw.GLES2.INTEL.performance_query import _EXTENSION_NAME + +def glInitPerformanceQueryINTEL(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/KHR/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/KHR/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/KHR/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/KHR/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/KHR/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..ecf22879 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/KHR/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/KHR/__pycache__/blend_equation_advanced.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/KHR/__pycache__/blend_equation_advanced.cpython-312.pyc new file mode 100644 index 00000000..45322be3 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/KHR/__pycache__/blend_equation_advanced.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/KHR/__pycache__/blend_equation_advanced_coherent.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/KHR/__pycache__/blend_equation_advanced_coherent.cpython-312.pyc new file mode 100644 index 00000000..b10c0c31 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/KHR/__pycache__/blend_equation_advanced_coherent.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/KHR/__pycache__/context_flush_control.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/KHR/__pycache__/context_flush_control.cpython-312.pyc new file mode 100644 index 00000000..ca4c554d Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/KHR/__pycache__/context_flush_control.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/KHR/__pycache__/debug.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/KHR/__pycache__/debug.cpython-312.pyc new file mode 100644 index 00000000..add6c21a Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/KHR/__pycache__/debug.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/KHR/__pycache__/no_error.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/KHR/__pycache__/no_error.cpython-312.pyc new file mode 100644 index 00000000..3df93396 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/KHR/__pycache__/no_error.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/KHR/__pycache__/parallel_shader_compile.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/KHR/__pycache__/parallel_shader_compile.cpython-312.pyc new file mode 100644 index 00000000..95d24616 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/KHR/__pycache__/parallel_shader_compile.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/KHR/__pycache__/robust_buffer_access_behavior.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/KHR/__pycache__/robust_buffer_access_behavior.cpython-312.pyc new file mode 100644 index 00000000..aabe77bf Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/KHR/__pycache__/robust_buffer_access_behavior.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/KHR/__pycache__/robustness.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/KHR/__pycache__/robustness.cpython-312.pyc new file mode 100644 index 00000000..68b2e648 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/KHR/__pycache__/robustness.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/KHR/__pycache__/shader_subgroup.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/KHR/__pycache__/shader_subgroup.cpython-312.pyc new file mode 100644 index 00000000..c6502919 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/KHR/__pycache__/shader_subgroup.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/KHR/__pycache__/texture_compression_astc_hdr.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/KHR/__pycache__/texture_compression_astc_hdr.cpython-312.pyc new file mode 100644 index 00000000..3e8440c3 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/KHR/__pycache__/texture_compression_astc_hdr.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/KHR/__pycache__/texture_compression_astc_ldr.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/KHR/__pycache__/texture_compression_astc_ldr.cpython-312.pyc new file mode 100644 index 00000000..1dcbedd3 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/KHR/__pycache__/texture_compression_astc_ldr.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/KHR/__pycache__/texture_compression_astc_sliced_3d.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/KHR/__pycache__/texture_compression_astc_sliced_3d.cpython-312.pyc new file mode 100644 index 00000000..876dda3b Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/KHR/__pycache__/texture_compression_astc_sliced_3d.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/KHR/blend_equation_advanced.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/KHR/blend_equation_advanced.py new file mode 100644 index 00000000..c66087df --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/KHR/blend_equation_advanced.py @@ -0,0 +1,85 @@ +'''OpenGL extension KHR.blend_equation_advanced + +This module customises the behaviour of the +OpenGL.raw.GLES2.KHR.blend_equation_advanced to provide a more +Python-friendly API + +Overview (from the spec) + + This extension adds a number of "advanced" blending equations that can be + used to perform new color blending operations, many of which are more + complex than the standard blend modes provided by unextended OpenGL. This + extension provides two different extension string entries: + + - KHR_blend_equation_advanced: Provides the new blending equations, but + guarantees defined results only if each sample is touched no more than + once in any single rendering pass. The command BlendBarrierKHR() is + provided to indicate a boundary between passes. + + - KHR_blend_equation_advanced_coherent: Provides the new blending + equations, and guarantees that blending is done coherently and in API + primitive order. An enable is provided to allow implementations to opt + out of fully coherent blending and instead behave as though only + KHR_blend_equation_advanced were supported. + + Some implementations may support KHR_blend_equation_advanced without + supporting KHR_blend_equation_advanced_coherent. + + In unextended OpenGL, the set of blending equations is limited, and can be + expressed very simply. The MIN and MAX blend equations simply compute + component-wise minimums or maximums of source and destination color + components. The FUNC_ADD, FUNC_SUBTRACT, and FUNC_REVERSE_SUBTRACT + multiply the source and destination colors by source and destination + factors and either add the two products together or subtract one from the + other. This limited set of operations supports many common blending + operations but precludes the use of more sophisticated transparency and + blending operations commonly available in many dedicated imaging APIs. + + This extension provides a number of new "advanced" blending equations. + Unlike traditional blending operations using the FUNC_ADD equation, these + blending equations do not use source and destination factors specified by + BlendFunc. Instead, each blend equation specifies a complete equation + based on the source and destination colors. These new blend equations are + used for both RGB and alpha components; they may not be used to perform + separate RGB and alpha blending (via functions like + BlendEquationSeparate). + + These blending operations are performed using premultiplied source and + destination colors, where RGB colors produced by the fragment shader and + stored in the framebuffer are considered to be multiplied by alpha + (coverage). Many of these advanced blending equations are formulated + where the result of blending source and destination colors with partial + coverage have three separate contributions: from the portions covered by + both the source and the destination, from the portion covered only by the + source, and from the portion covered only by the destination. Such + equations are defined assuming that the source and destination coverage + have no spatial correlation within the pixel. + + In addition to the coherency issues on implementations not supporting + KHR_blend_equation_advanced_coherent, this extension has several + limitations worth noting. First, the new blend equations are not + supported while rendering to more than one color buffer at once; an + INVALID_OPERATION will be generated if an application attempts to render + any primitives in this unsupported configuration. Additionally, blending + precision may be limited to 16-bit floating-point, which could result in a + loss of precision and dynamic range for framebuffer formats with 32-bit + floating-point components, and in a loss of precision for formats with 12- + and 16-bit signed or unsigned normalized integer components. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/KHR/blend_equation_advanced.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.KHR.blend_equation_advanced import * +from OpenGL.raw.GLES2.KHR.blend_equation_advanced import _EXTENSION_NAME + +def glInitBlendEquationAdvancedKHR(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/KHR/blend_equation_advanced_coherent.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/KHR/blend_equation_advanced_coherent.py new file mode 100644 index 00000000..be576860 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/KHR/blend_equation_advanced_coherent.py @@ -0,0 +1,23 @@ +'''OpenGL extension KHR.blend_equation_advanced_coherent + +This module customises the behaviour of the +OpenGL.raw.GLES2.KHR.blend_equation_advanced_coherent to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/KHR/blend_equation_advanced_coherent.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.KHR.blend_equation_advanced_coherent import * +from OpenGL.raw.GLES2.KHR.blend_equation_advanced_coherent import _EXTENSION_NAME + +def glInitBlendEquationAdvancedCoherentKHR(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/KHR/context_flush_control.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/KHR/context_flush_control.py new file mode 100644 index 00000000..ceee25f4 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/KHR/context_flush_control.py @@ -0,0 +1,52 @@ +'''OpenGL extension KHR.context_flush_control + +This module customises the behaviour of the +OpenGL.raw.GLES2.KHR.context_flush_control to provide a more +Python-friendly API + +Overview (from the spec) + + OpenGL and OpenGL ES have long supported multiple contexts. The + semantics of switching contexts is generally left to window system + binding APIs such as WGL, GLX and EGL. Most of these APIs (if not all) + specify that when the current context for a thread is changed, the + outgoing context performs an implicit flush of any commands that have + been issued to that point. OpenGL and OpenGL ES define a flush as + sending any pending commands for execution and that this action will + result in their completion in finite time. + + This behavior has subtle consequences. For example, if an application is + rendering to the front buffer and switches contexts, it may assume that + any rendering performed thus far will eventually be visible to the user. + With recent introduction of shared memory buffers, there become inumerable + ways in which applications may observe side effects of an implicit flush + (or lack thereof). + + In general, a full flush is not the desired behavior of the application. + Nonetheless, applications that switch contexts frequently suffer the + performance consequences of this unless implementations make special + considerations for them, which is generally untenable. + + The EGL, GLX, and WGL extensions add new context creation parameters + that allow an application to specify the behavior that is desired when a + context is made non-current, and specifically to opt out of the implicit + flush behavior. The GL extension allows querying the context flush + behavior. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/KHR/context_flush_control.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.KHR.context_flush_control import * +from OpenGL.raw.GLES2.KHR.context_flush_control import _EXTENSION_NAME + +def glInitContextFlushControlKHR(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/KHR/debug.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/KHR/debug.py new file mode 100644 index 00000000..baf2d067 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/KHR/debug.py @@ -0,0 +1,206 @@ +'''OpenGL extension KHR.debug + +This module customises the behaviour of the +OpenGL.raw.GLES2.KHR.debug to provide a more +Python-friendly API + +Overview (from the spec) + + This extension allows the GL to notify applications when various events + occur that may be useful during application development, debugging and + profiling. + + These events are represented in the form of enumerable messages with a + human-readable string representation. Examples of debug events include + incorrect use of the GL, warnings of undefined behavior, and performance + warnings. + + A message is uniquely identified by a source, a type and an + implementation-dependent ID within the source and type pair. + + A message's source identifies the origin of the message and can either + describe components of the GL, the window system, third-party external + sources such as external debuggers, or even the application itself. + + The type of the message roughly identifies the nature of the event that + caused the message. Examples include errors, performance warnings, + warnings about undefined behavior or notifications identifying that the + application is within a specific section of the application code. + + A message's ID for a given source and type further distinguishes messages + within namespaces. For example, an error caused by a negative parameter + value or an invalid internal texture format are both errors generated by + the API, but would likely have different message IDs. + + Each message is also assigned to a severity level that denotes roughly how + "important" that message is in comparison to other messages across all + sources and types. For example, notification of a GL error would likely + have a higher severity than a performance warning due to redundant state + changes. + + Furthermore, every message contains an implementation-dependent string + representation that provides a useful description of the event. + + Messages are communicated to the application through an application- + defined callback function that is called by the GL implementation on each + debug message. The motivation for the callback routine is to free + application developers from actively having to query whether a GL error, + or any other debuggable event has happened after each call to a GL + function. With a callback, developers can keep their code free of debug + checks, set breakpoints in the callback function, and only have to react + to messages as they occur. In situations where using a callback is not + possible, a message log is also provided that stores only copies of recent + messages until they are actively queried. + + To control the volume of debug output, messages can be disabled either + individually by ID, or entire sets of messages can be turned off based on + combination of source and type, through the entire application code or + only section of the code encapsulated in debug groups. A debug group may + also be used to annotate the command stream using descriptive texts. + + This extension also defines debug markers, a mechanism for the OpenGL + application to annotate the command stream with markers for discrete + events. + + When profiling or debugging an OpenGL application with a built-in or an + external debugger or profiler, it is difficult to relate the commands + within the command stream to the elements of the scene or parts of the + program code to which they correspond. Debug markers and debug groups help + obviate this by allowing applications to specify this link. For example, a + debug marker can be used to identify the beginning of a frame in the + command stream and a debug group can encapsulate a specific command stream + to identify a rendering pass. Debug groups also allow control of the debug + outputs volume per section of an application code providing an effective + way to handle the massive amount of debug outputs that drivers can + generate. + + Some existing implementations of ARB_debug_output only expose the + ARB_debug_output extension string if the context was created with the + debug flag {GLX|WGL}_CONTEXT_DEBUG_BIT_ARB as specified in + {GLX|WGL}_ARB_create_context. The behavior is not obvious when the + functionality is brought into the OpenGL core specification because the + extension string and function entry points must always exist. + + This extension modifies the existing ARB_debug_output extension to allow + implementations to always have an empty message log. The specific messages + written to the message log or callback routines are already implementation + defined, so this specification simply makes it explicit that it's fine for + there to be zero messages generated, even when a GL error occurs, which is + useful if the context is non-debug. + + Debug output can be enabled and disabled by changing the DEBUG_OUTPUT + state. It is implementation defined how much debug output is generated if + the context was created without the CONTEXT_DEBUG_BIT set. This is a new + query bit added to the existing GL_CONTEXT_FLAGS state to specify whether + the context was created with debug enabled. + + Finally, this extension defines a mechanism for OpenGL applications to + label their objects (textures, buffers, shaders, etc.) with a descriptive + string. + + When profiling or debugging an OpenGL application within an external or + built-in (debut output API) debugger or profiler it is difficult to + identify objects from their object names (integers). + + Even when the object itself is viewed it can be problematic to + differentiate between similar objects. Attaching a descriptive string, a + label, to an object obviates this difficulty. + + The intended purpose of this extension is purely to improve the user + experience within OpenGL development tools and application built-in + profilers and debuggers. This extension typically improves OpenGL + programmers efficiency by allowing them to instantly detect issues and the + reason for these issues giving him more time to focus on adding new + features to an OpenGL application. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/KHR/debug.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.KHR.debug import * +from OpenGL.raw.GLES2.KHR.debug import _EXTENSION_NAME + +def glInitDebugKHR(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glDebugMessageControl.ids size not checked against count +glDebugMessageControl=wrapper.wrapper(glDebugMessageControl).setInputArraySize( + 'ids', None +) +# INPUT glDebugMessageInsert.buf size not checked against 'buf,length' +glDebugMessageInsert=wrapper.wrapper(glDebugMessageInsert).setInputArraySize( + 'buf', None +) +glGetDebugMessageLog=wrapper.wrapper(glGetDebugMessageLog).setOutput( + 'ids',size=lambda x:(x,),pnameArg='count',orPassIn=True +).setOutput( + 'lengths',size=lambda x:(x,),pnameArg='count',orPassIn=True +).setOutput( + 'messageLog',size=lambda x:(x,),pnameArg='bufSize',orPassIn=True +).setOutput( + 'severities',size=lambda x:(x,),pnameArg='count',orPassIn=True +).setOutput( + 'sources',size=lambda x:(x,),pnameArg='count',orPassIn=True +).setOutput( + 'types',size=lambda x:(x,),pnameArg='count',orPassIn=True +) +# INPUT glPushDebugGroup.message size not checked against 'message,length' +glPushDebugGroup=wrapper.wrapper(glPushDebugGroup).setInputArraySize( + 'message', None +) +# INPUT glObjectLabel.label size not checked against 'label,length' +glObjectLabel=wrapper.wrapper(glObjectLabel).setInputArraySize( + 'label', None +) +glGetObjectLabel=wrapper.wrapper(glGetObjectLabel).setOutput( + 'label',size=lambda x:(x,),pnameArg='bufSize',orPassIn=True +).setOutput( + 'length',size=(1,),orPassIn=True +) +# INPUT glObjectPtrLabel.label size not checked against 'label,length' +glObjectPtrLabel=wrapper.wrapper(glObjectPtrLabel).setInputArraySize( + 'label', None +) +glGetObjectPtrLabel=wrapper.wrapper(glGetObjectPtrLabel).setOutput( + 'label',size=lambda x:(x,),pnameArg='bufSize',orPassIn=True +).setOutput( + 'length',size=(1,),orPassIn=True +) +glGetPointerv=wrapper.wrapper(glGetPointerv).setOutput( + 'params',size=(1,),orPassIn=True +) +# INPUT glGetDebugMessageLogKHR.ids size not checked against count +# INPUT glGetDebugMessageLogKHR.lengths size not checked against count +# INPUT glGetDebugMessageLogKHR.messageLog size not checked against bufSize +# INPUT glGetDebugMessageLogKHR.severities size not checked against count +# INPUT glGetDebugMessageLogKHR.sources size not checked against count +# INPUT glGetDebugMessageLogKHR.types size not checked against count +glGetDebugMessageLogKHR=wrapper.wrapper(glGetDebugMessageLogKHR).setInputArraySize( + 'ids', None +).setInputArraySize( + 'lengths', None +).setInputArraySize( + 'messageLog', None +).setInputArraySize( + 'severities', None +).setInputArraySize( + 'sources', None +).setInputArraySize( + 'types', None +) +# INPUT glGetObjectLabelKHR.label size not checked against bufSize +glGetObjectLabelKHR=wrapper.wrapper(glGetObjectLabelKHR).setInputArraySize( + 'label', None +) +# INPUT glGetObjectPtrLabelKHR.label size not checked against bufSize +glGetObjectPtrLabelKHR=wrapper.wrapper(glGetObjectPtrLabelKHR).setInputArraySize( + 'label', None +).setInputArraySize( + 'length', 1 +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/KHR/no_error.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/KHR/no_error.py new file mode 100644 index 00000000..a8b6ba06 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/KHR/no_error.py @@ -0,0 +1,34 @@ +'''OpenGL extension KHR.no_error + +This module customises the behaviour of the +OpenGL.raw.GLES2.KHR.no_error to provide a more +Python-friendly API + +Overview (from the spec) + + With this extension enabled any behavior that generates a GL error will + have undefined behavior. The reason this extension exists is performance + can be increased and power usage decreased. When this mode is used, a GL + driver can have undefined behavior where it would have generated a GL error + without this extension. This could include application termination. In + general this extension should be used after you have verified all the GL + errors are removed, and an application is not the kind that would check + for GL errors and adjust behavior based on those errors. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/KHR/no_error.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.KHR.no_error import * +from OpenGL.raw.GLES2.KHR.no_error import _EXTENSION_NAME + +def glInitNoErrorKHR(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/KHR/parallel_shader_compile.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/KHR/parallel_shader_compile.py new file mode 100644 index 00000000..d73730ac --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/KHR/parallel_shader_compile.py @@ -0,0 +1,32 @@ +'''OpenGL extension KHR.parallel_shader_compile + +This module customises the behaviour of the +OpenGL.raw.GLES2.KHR.parallel_shader_compile to provide a more +Python-friendly API + +Overview (from the spec) + + Compiling GLSL into implementation-specific code can be a time consuming + process, so a GL implementation may wish to perform the compilation in a + separate CPU thread. This extension provides a mechanism for the application + to provide a hint to limit the number of threads it wants to be used to + compile shaders, as well as a query to determine if the compilation process + is complete. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/KHR/parallel_shader_compile.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.KHR.parallel_shader_compile import * +from OpenGL.raw.GLES2.KHR.parallel_shader_compile import _EXTENSION_NAME + +def glInitParallelShaderCompileKHR(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/KHR/robust_buffer_access_behavior.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/KHR/robust_buffer_access_behavior.py new file mode 100644 index 00000000..9f2e595d --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/KHR/robust_buffer_access_behavior.py @@ -0,0 +1,36 @@ +'''OpenGL extension KHR.robust_buffer_access_behavior + +This module customises the behaviour of the +OpenGL.raw.GLES2.KHR.robust_buffer_access_behavior to provide a more +Python-friendly API + +Overview (from the spec) + + This extension specifies the behavior of out-of-bounds buffer and + array accesses. This is an improvement over the existing + KHR_robustness extension which states that the application should + not crash, but that behavior is otherwise undefined. This extension + specifies the access protection provided by the GL to ensure that + out-of-bounds accesses cannot read from or write to data not owned + by the application. All accesses are contained within the buffer + object and program area they reference. These additional robustness + guarantees apply to contexts created with the robust access flag + set. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/KHR/robust_buffer_access_behavior.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.KHR.robust_buffer_access_behavior import * +from OpenGL.raw.GLES2.KHR.robust_buffer_access_behavior import _EXTENSION_NAME + +def glInitRobustBufferAccessBehaviorKHR(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/KHR/robustness.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/KHR/robustness.py new file mode 100644 index 00000000..bfbbf361 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/KHR/robustness.py @@ -0,0 +1,111 @@ +'''OpenGL extension KHR.robustness + +This module customises the behaviour of the +OpenGL.raw.GLES2.KHR.robustness to provide a more +Python-friendly API + +Overview (from the spec) + + Several recent trends in how OpenGL ES integrates into modern computer + systems have created new requirements for robustness and security for GL + rendering contexts. + + Additionally GPU architectures now support hardware fault detection; + for example, video memory supporting ECC (error correcting codes) + and error detection. GL contexts should be capable of recovering + from hardware faults such as uncorrectable memory errors. Along with + recovery from such hardware faults, the recovery mechanism can + also allow recovery from video memory access exceptions and system + software failures. System software failures can be due to device + changes or driver failures. + + GL queries that return (write) some number of bytes to a + buffer indicated by a pointer parameter introduce risk of buffer + overflows that might be exploitable by malware. To address this, + queries with return value sizes that are not expressed directly by + the parameters to the query itself are given additional API + functions with an additional parameter that specifies the number of + bytes in the buffer and never writing bytes beyond that limit. This + is particularly useful for multi-threaded usage of GL contexts + in a "share group" where one context can change objects in ways that + can cause buffer overflows for another context's GL queries. + + The original ARB_vertex_buffer_object extension includes an issue + that explicitly states program termination is allowed when + out-of-bounds vertex buffer object fetches occur. Modern graphics + hardware is capable of well-defined behavior in the case of out-of- + bounds vertex buffer object fetches. Older hardware may require + extra checks to enforce well-defined (and termination free) + behavior, but this expense is warranted when processing potentially + untrusted content. + + The intent of this extension is to address some specific robustness + goals: + + * For all existing GL queries, provide additional "safe" APIs + that limit data written to user pointers to a buffer size in + bytes that is an explicit additional parameter of the query. + + * Provide a mechanism for a GL application to learn about + graphics resets that affect the context. When a graphics reset + occurs, the GL context becomes unusable and the application + must create a new context to continue operation. Detecting a + graphics reset happens through an inexpensive query. + + * Define behavior of OpenGL calls made after a graphics reset. + + * Provide an enable to guarantee that out-of-bounds buffer object + accesses by the GPU will have deterministic behavior and preclude + application instability or termination due to an incorrect buffer + access. Such accesses include vertex buffer fetches of + attributes and indices, and indexed reads of uniforms or + parameters from buffers. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/KHR/robustness.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.KHR.robustness import * +from OpenGL.raw.GLES2.KHR.robustness import _EXTENSION_NAME + +def glInitRobustnessKHR(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glReadnPixels.data size not checked against bufSize +glReadnPixels=wrapper.wrapper(glReadnPixels).setInputArraySize( + 'data', None +) +# INPUT glGetnUniformfv.params size not checked against bufSize +glGetnUniformfv=wrapper.wrapper(glGetnUniformfv).setInputArraySize( + 'params', None +) +# INPUT glGetnUniformiv.params size not checked against bufSize +glGetnUniformiv=wrapper.wrapper(glGetnUniformiv).setInputArraySize( + 'params', None +) +# INPUT glGetnUniformuiv.params size not checked against bufSize +glGetnUniformuiv=wrapper.wrapper(glGetnUniformuiv).setInputArraySize( + 'params', None +) +# INPUT glReadnPixelsKHR.data size not checked against bufSize +glReadnPixelsKHR=wrapper.wrapper(glReadnPixelsKHR).setInputArraySize( + 'data', None +) +# INPUT glGetnUniformfvKHR.params size not checked against bufSize +glGetnUniformfvKHR=wrapper.wrapper(glGetnUniformfvKHR).setInputArraySize( + 'params', None +) +# INPUT glGetnUniformivKHR.params size not checked against bufSize +glGetnUniformivKHR=wrapper.wrapper(glGetnUniformivKHR).setInputArraySize( + 'params', None +) +# INPUT glGetnUniformuivKHR.params size not checked against bufSize +glGetnUniformuivKHR=wrapper.wrapper(glGetnUniformuivKHR).setInputArraySize( + 'params', None +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/KHR/shader_subgroup.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/KHR/shader_subgroup.py new file mode 100644 index 00000000..051a51b8 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/KHR/shader_subgroup.py @@ -0,0 +1,45 @@ +'''OpenGL extension KHR.shader_subgroup + +This module customises the behaviour of the +OpenGL.raw.GLES2.KHR.shader_subgroup to provide a more +Python-friendly API + +Overview (from the spec) + + This extension enables support for the KHR_shader_subgroup shading + language extension in OpenGL and OpenGL ES. + + The extension adds API queries to be able to query + + - the size of subgroups in this implementation (SUBGROUP_SIZE_KHR) + - which shader stages support subgroup operations + (SUBGROUP_SUPPORTED_STAGES_KHR) + - which subgroup features are supported (SUBGROUP_SUPPORTED_FEATURES_KHR) + - whether quad subgroup operations are supported in all + stages supporting subgroup operations (SUBGROUP_QUAD_ALL_STAGES_KHR) + + In OpenGL implementations supporting SPIR-V, this extension enables the + minimal subset of SPIR-V 1.3 which is required to support the subgroup + features that are supported by the implementation. + + In OpenGL ES implementations, this extension does NOT add support for + SPIR-V or for any of the built-in shading language functions (8.18) + that have genDType (double) prototypes. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/KHR/shader_subgroup.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.KHR.shader_subgroup import * +from OpenGL.raw.GLES2.KHR.shader_subgroup import _EXTENSION_NAME + +def glInitShaderSubgroupKHR(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/KHR/texture_compression_astc_hdr.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/KHR/texture_compression_astc_hdr.py new file mode 100644 index 00000000..fad7fdd0 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/KHR/texture_compression_astc_hdr.py @@ -0,0 +1,41 @@ +'''OpenGL extension KHR.texture_compression_astc_hdr + +This module customises the behaviour of the +OpenGL.raw.GLES2.KHR.texture_compression_astc_hdr to provide a more +Python-friendly API + +Overview (from the spec) + + Adaptive Scalable Texture Compression (ASTC) is a new texture + compression technology that offers unprecendented flexibility, while + producing better or comparable results than existing texture + compressions at all bit rates. It includes support for 2D and + slice-based 3D textures, with low and high dynamic range, at bitrates + from below 1 bit/pixel up to 8 bits/pixel in fine steps. + + The goal of these extensions is to support the full 2D profile of the + ASTC texture compression specification, and allow construction of 3D + textures from multiple compressed 2D slices. + + ASTC-compressed textures are handled in OpenGL ES and OpenGL by adding + new supported formats to the existing commands for defining and updating + compressed textures, and defining the interaction of the ASTC formats + with each texture target. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/KHR/texture_compression_astc_hdr.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.KHR.texture_compression_astc_hdr import * +from OpenGL.raw.GLES2.KHR.texture_compression_astc_hdr import _EXTENSION_NAME + +def glInitTextureCompressionAstcHdrKHR(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/KHR/texture_compression_astc_ldr.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/KHR/texture_compression_astc_ldr.py new file mode 100644 index 00000000..bbd8c928 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/KHR/texture_compression_astc_ldr.py @@ -0,0 +1,23 @@ +'''OpenGL extension KHR.texture_compression_astc_ldr + +This module customises the behaviour of the +OpenGL.raw.GLES2.KHR.texture_compression_astc_ldr to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/KHR/texture_compression_astc_ldr.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.KHR.texture_compression_astc_ldr import * +from OpenGL.raw.GLES2.KHR.texture_compression_astc_ldr import _EXTENSION_NAME + +def glInitTextureCompressionAstcLdrKHR(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/KHR/texture_compression_astc_sliced_3d.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/KHR/texture_compression_astc_sliced_3d.py new file mode 100644 index 00000000..5b591f4f --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/KHR/texture_compression_astc_sliced_3d.py @@ -0,0 +1,37 @@ +'''OpenGL extension KHR.texture_compression_astc_sliced_3d + +This module customises the behaviour of the +OpenGL.raw.GLES2.KHR.texture_compression_astc_sliced_3d to provide a more +Python-friendly API + +Overview (from the spec) + + Adaptive Scalable Texture Compression (ASTC) is a new texture + compression technology that offers unprecendented flexibility, while + producing better or comparable results than existing texture + compressions at all bit rates. It includes support for 2D and + slice-based 3D textures, with low and high dynamic range, at bitrates + from below 1 bit/pixel up to 8 bits/pixel in fine steps. + + This extension extends the functionality of + GL_KHR_texture_compression_astc_ldr to include slice-based 3D textures + for textures using the LDR profile in the same way as the HDR profile + allows slice-based 3D textures. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/KHR/texture_compression_astc_sliced_3d.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.KHR.texture_compression_astc_sliced_3d import * +from OpenGL.raw.GLES2.KHR.texture_compression_astc_sliced_3d import _EXTENSION_NAME + +def glInitTextureCompressionAstcSliced3DKHR(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/MESA/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/MESA/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/MESA/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/MESA/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/MESA/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..6169f6b8 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/MESA/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/MESA/__pycache__/framebuffer_flip_y.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/MESA/__pycache__/framebuffer_flip_y.cpython-312.pyc new file mode 100644 index 00000000..90eb22f5 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/MESA/__pycache__/framebuffer_flip_y.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/MESA/__pycache__/program_binary_formats.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/MESA/__pycache__/program_binary_formats.cpython-312.pyc new file mode 100644 index 00000000..a1a14ead Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/MESA/__pycache__/program_binary_formats.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/MESA/__pycache__/shader_integer_functions.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/MESA/__pycache__/shader_integer_functions.cpython-312.pyc new file mode 100644 index 00000000..f3d32b48 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/MESA/__pycache__/shader_integer_functions.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/MESA/framebuffer_flip_y.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/MESA/framebuffer_flip_y.py new file mode 100644 index 00000000..65abd50c --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/MESA/framebuffer_flip_y.py @@ -0,0 +1,41 @@ +'''OpenGL extension MESA.framebuffer_flip_y + +This module customises the behaviour of the +OpenGL.raw.GLES2.MESA.framebuffer_flip_y to provide a more +Python-friendly API + +Overview (from the spec) + + This extension defines a new framebuffer parameter, + GL_FRAMEBUFFER_FLIP_Y_MESA, that changes the behavior of the reads and + writes to the framebuffer attachment points. When GL_FRAMEBUFFER_FLIP_Y_MESA + is GL_TRUE, render commands and pixel transfer operations access the + backing store of each attachment point with an y-inverted coordinate + system. This y-inversion is relative to the coordinate system set when + GL_FRAMEBUFFER_FLIP_Y_MESA is GL_FALSE. + + Access through TexSubImage2D and similar calls will notice the effect of + the flip when they are not attached to framebuffer objects because + GL_FRAMEBUFFER_FLIP_Y_MESA is associated with the framebuffer object and + not the attachment points. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/MESA/framebuffer_flip_y.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.MESA.framebuffer_flip_y import * +from OpenGL.raw.GLES2.MESA.framebuffer_flip_y import _EXTENSION_NAME + +def glInitFramebufferFlipYMESA(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glGetFramebufferParameterivMESA.params size not checked against 'pname' +glGetFramebufferParameterivMESA=wrapper.wrapper(glGetFramebufferParameterivMESA).setInputArraySize( + 'params', None +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/MESA/program_binary_formats.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/MESA/program_binary_formats.py new file mode 100644 index 00000000..9531badb --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/MESA/program_binary_formats.py @@ -0,0 +1,28 @@ +'''OpenGL extension MESA.program_binary_formats + +This module customises the behaviour of the +OpenGL.raw.GLES2.MESA.program_binary_formats to provide a more +Python-friendly API + +Overview (from the spec) + + The get_program_binary exensions require a GLenum binaryFormat. + This extension documents that format for use with Mesa. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/MESA/program_binary_formats.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.MESA.program_binary_formats import * +from OpenGL.raw.GLES2.MESA.program_binary_formats import _EXTENSION_NAME + +def glInitProgramBinaryFormatsMESA(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/MESA/shader_integer_functions.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/MESA/shader_integer_functions.py new file mode 100644 index 00000000..0cd0d66a --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/MESA/shader_integer_functions.py @@ -0,0 +1,63 @@ +'''OpenGL extension MESA.shader_integer_functions + +This module customises the behaviour of the +OpenGL.raw.GLES2.MESA.shader_integer_functions to provide a more +Python-friendly API + +Overview (from the spec) + + GL_ARB_gpu_shader5 extends GLSL in a number of useful ways. Much of this + added functionality requires significant hardware support. There are many + aspects, however, that can be easily implmented on any GPU with "real" + integer support (as opposed to simulating integers using floating point + calculations). + + This extension provides a set of new features to the OpenGL Shading + Language to support capabilities of these GPUs, extending the + capabilities of version 1.30 of the OpenGL Shading Language and version + 3.00 of the OpenGL ES Shading Language. Shaders using the new + functionality provided by this extension should enable this + functionality via the construct + + #extension GL_MESA_shader_integer_functions : require (or enable) + + This extension provides a variety of new features for all shader types, + including: + + * support for implicitly converting signed integer types to unsigned + types, as well as more general implicit conversion and function + overloading infrastructure to support new data types introduced by + other extensions; + + * new built-in functions supporting: + + * splitting a floating-point number into a significand and exponent + (frexp), or building a floating-point number from a significand and + exponent (ldexp); + + * integer bitfield manipulation, including functions to find the + position of the most or least significant set bit, count the number + of one bits, and bitfield insertion, extraction, and reversal; + + * extended integer precision math, including add with carry, subtract + with borrow, and extenended multiplication; + + The resulting extension is a strict subset of GL_ARB_gpu_shader5. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/MESA/shader_integer_functions.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.MESA.shader_integer_functions import * +from OpenGL.raw.GLES2.MESA.shader_integer_functions import _EXTENSION_NAME + +def glInitShaderIntegerFunctionsMESA(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..4f8b9315 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/bindless_texture.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/bindless_texture.cpython-312.pyc new file mode 100644 index 00000000..588e1685 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/bindless_texture.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/blend_equation_advanced.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/blend_equation_advanced.cpython-312.pyc new file mode 100644 index 00000000..00235802 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/blend_equation_advanced.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/blend_equation_advanced_coherent.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/blend_equation_advanced_coherent.cpython-312.pyc new file mode 100644 index 00000000..0af242a8 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/blend_equation_advanced_coherent.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/blend_minmax_factor.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/blend_minmax_factor.cpython-312.pyc new file mode 100644 index 00000000..993edacf Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/blend_minmax_factor.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/clip_space_w_scaling.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/clip_space_w_scaling.cpython-312.pyc new file mode 100644 index 00000000..25cd00a4 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/clip_space_w_scaling.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/compute_shader_derivatives.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/compute_shader_derivatives.cpython-312.pyc new file mode 100644 index 00000000..aca93bb5 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/compute_shader_derivatives.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/conditional_render.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/conditional_render.cpython-312.pyc new file mode 100644 index 00000000..307a36b1 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/conditional_render.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/conservative_raster.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/conservative_raster.cpython-312.pyc new file mode 100644 index 00000000..64baded8 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/conservative_raster.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/conservative_raster_pre_snap.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/conservative_raster_pre_snap.cpython-312.pyc new file mode 100644 index 00000000..c623c7a1 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/conservative_raster_pre_snap.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/conservative_raster_pre_snap_triangles.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/conservative_raster_pre_snap_triangles.cpython-312.pyc new file mode 100644 index 00000000..dd86594e Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/conservative_raster_pre_snap_triangles.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/copy_buffer.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/copy_buffer.cpython-312.pyc new file mode 100644 index 00000000..45473806 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/copy_buffer.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/coverage_sample.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/coverage_sample.cpython-312.pyc new file mode 100644 index 00000000..a5531665 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/coverage_sample.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/depth_nonlinear.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/depth_nonlinear.cpython-312.pyc new file mode 100644 index 00000000..143b00a7 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/depth_nonlinear.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/draw_buffers.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/draw_buffers.cpython-312.pyc new file mode 100644 index 00000000..1e4a3e26 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/draw_buffers.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/draw_instanced.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/draw_instanced.cpython-312.pyc new file mode 100644 index 00000000..90f3092e Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/draw_instanced.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/draw_vulkan_image.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/draw_vulkan_image.cpython-312.pyc new file mode 100644 index 00000000..0a1e76ab Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/draw_vulkan_image.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/explicit_attrib_location.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/explicit_attrib_location.cpython-312.pyc new file mode 100644 index 00000000..8c8f3ea7 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/explicit_attrib_location.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/fbo_color_attachments.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/fbo_color_attachments.cpython-312.pyc new file mode 100644 index 00000000..776222ba Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/fbo_color_attachments.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/fence.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/fence.cpython-312.pyc new file mode 100644 index 00000000..3629fb2d Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/fence.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/fill_rectangle.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/fill_rectangle.cpython-312.pyc new file mode 100644 index 00000000..1128a3e8 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/fill_rectangle.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/fragment_coverage_to_color.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/fragment_coverage_to_color.cpython-312.pyc new file mode 100644 index 00000000..54af67cc Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/fragment_coverage_to_color.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/fragment_shader_barycentric.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/fragment_shader_barycentric.cpython-312.pyc new file mode 100644 index 00000000..49504106 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/fragment_shader_barycentric.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/fragment_shader_interlock.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/fragment_shader_interlock.cpython-312.pyc new file mode 100644 index 00000000..ce5a1cab Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/fragment_shader_interlock.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/framebuffer_blit.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/framebuffer_blit.cpython-312.pyc new file mode 100644 index 00000000..6e8aa395 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/framebuffer_blit.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/framebuffer_mixed_samples.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/framebuffer_mixed_samples.cpython-312.pyc new file mode 100644 index 00000000..593c746f Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/framebuffer_mixed_samples.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/framebuffer_multisample.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/framebuffer_multisample.cpython-312.pyc new file mode 100644 index 00000000..fd693ff7 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/framebuffer_multisample.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/generate_mipmap_sRGB.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/generate_mipmap_sRGB.cpython-312.pyc new file mode 100644 index 00000000..51751bce Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/generate_mipmap_sRGB.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/geometry_shader_passthrough.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/geometry_shader_passthrough.cpython-312.pyc new file mode 100644 index 00000000..f840979f Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/geometry_shader_passthrough.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/gpu_shader5.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/gpu_shader5.cpython-312.pyc new file mode 100644 index 00000000..9633ef08 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/gpu_shader5.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/image_formats.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/image_formats.cpython-312.pyc new file mode 100644 index 00000000..b2086bf2 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/image_formats.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/instanced_arrays.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/instanced_arrays.cpython-312.pyc new file mode 100644 index 00000000..bb581e4f Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/instanced_arrays.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/internalformat_sample_query.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/internalformat_sample_query.cpython-312.pyc new file mode 100644 index 00000000..339a5a63 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/internalformat_sample_query.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/memory_attachment.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/memory_attachment.cpython-312.pyc new file mode 100644 index 00000000..726ed4aa Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/memory_attachment.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/mesh_shader.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/mesh_shader.cpython-312.pyc new file mode 100644 index 00000000..0f5a92c9 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/mesh_shader.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/non_square_matrices.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/non_square_matrices.cpython-312.pyc new file mode 100644 index 00000000..d436ce18 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/non_square_matrices.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/path_rendering.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/path_rendering.cpython-312.pyc new file mode 100644 index 00000000..3e2b590c Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/path_rendering.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/path_rendering_shared_edge.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/path_rendering_shared_edge.cpython-312.pyc new file mode 100644 index 00000000..2b61e922 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/path_rendering_shared_edge.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/pixel_buffer_object.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/pixel_buffer_object.cpython-312.pyc new file mode 100644 index 00000000..f5469976 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/pixel_buffer_object.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/polygon_mode.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/polygon_mode.cpython-312.pyc new file mode 100644 index 00000000..86817228 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/polygon_mode.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/read_buffer.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/read_buffer.cpython-312.pyc new file mode 100644 index 00000000..9f6abb40 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/read_buffer.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/read_buffer_front.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/read_buffer_front.cpython-312.pyc new file mode 100644 index 00000000..96ea97f9 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/read_buffer_front.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/read_depth.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/read_depth.cpython-312.pyc new file mode 100644 index 00000000..def299c3 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/read_depth.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/read_depth_stencil.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/read_depth_stencil.cpython-312.pyc new file mode 100644 index 00000000..9a1cfc72 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/read_depth_stencil.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/read_stencil.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/read_stencil.cpython-312.pyc new file mode 100644 index 00000000..f1d82d5a Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/read_stencil.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/representative_fragment_test.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/representative_fragment_test.cpython-312.pyc new file mode 100644 index 00000000..b3a5e929 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/representative_fragment_test.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/sRGB_formats.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/sRGB_formats.cpython-312.pyc new file mode 100644 index 00000000..5ff25c82 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/sRGB_formats.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/sample_locations.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/sample_locations.cpython-312.pyc new file mode 100644 index 00000000..baa1ceec Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/sample_locations.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/sample_mask_override_coverage.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/sample_mask_override_coverage.cpython-312.pyc new file mode 100644 index 00000000..5252787c Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/sample_mask_override_coverage.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/scissor_exclusive.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/scissor_exclusive.cpython-312.pyc new file mode 100644 index 00000000..fd3c9373 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/scissor_exclusive.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/shader_atomic_fp16_vector.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/shader_atomic_fp16_vector.cpython-312.pyc new file mode 100644 index 00000000..0fea0dd1 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/shader_atomic_fp16_vector.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/shader_noperspective_interpolation.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/shader_noperspective_interpolation.cpython-312.pyc new file mode 100644 index 00000000..95b6730a Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/shader_noperspective_interpolation.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/shader_subgroup_partitioned.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/shader_subgroup_partitioned.cpython-312.pyc new file mode 100644 index 00000000..d9709704 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/shader_subgroup_partitioned.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/shader_texture_footprint.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/shader_texture_footprint.cpython-312.pyc new file mode 100644 index 00000000..085bdbf7 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/shader_texture_footprint.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/shading_rate_image.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/shading_rate_image.cpython-312.pyc new file mode 100644 index 00000000..7819e068 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/shading_rate_image.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/shadow_samplers_array.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/shadow_samplers_array.cpython-312.pyc new file mode 100644 index 00000000..2d1d322d Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/shadow_samplers_array.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/shadow_samplers_cube.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/shadow_samplers_cube.cpython-312.pyc new file mode 100644 index 00000000..e528906d Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/shadow_samplers_cube.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/stereo_view_rendering.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/stereo_view_rendering.cpython-312.pyc new file mode 100644 index 00000000..8567582d Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/stereo_view_rendering.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/texture_border_clamp.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/texture_border_clamp.cpython-312.pyc new file mode 100644 index 00000000..3219385a Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/texture_border_clamp.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/texture_compression_s3tc_update.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/texture_compression_s3tc_update.cpython-312.pyc new file mode 100644 index 00000000..94b2cdcc Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/texture_compression_s3tc_update.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/texture_npot_2D_mipmap.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/texture_npot_2D_mipmap.cpython-312.pyc new file mode 100644 index 00000000..ba6027bc Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/texture_npot_2D_mipmap.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/viewport_array.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/viewport_array.cpython-312.pyc new file mode 100644 index 00000000..00f63fe0 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/viewport_array.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/viewport_array2.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/viewport_array2.cpython-312.pyc new file mode 100644 index 00000000..8c1c96d9 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/viewport_array2.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/viewport_swizzle.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/viewport_swizzle.cpython-312.pyc new file mode 100644 index 00000000..96507cf1 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/__pycache__/viewport_swizzle.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/bindless_texture.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/bindless_texture.py new file mode 100644 index 00000000..92422e2a --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/bindless_texture.py @@ -0,0 +1,76 @@ +'''OpenGL extension NV.bindless_texture + +This module customises the behaviour of the +OpenGL.raw.GLES2.NV.bindless_texture to provide a more +Python-friendly API + +Overview (from the spec) + + This extension allows OpenGL applications to access texture objects in + shaders without first binding each texture to one of a limited number of + texture image units. Using this extension, an application can query a + 64-bit unsigned integer texture handle for each texture that it wants to + access and then use that handle directly in GLSL or assembly-based + shaders. The ability to access textures without having to bind and/or + re-bind them is similar to the capability provided by the + NV_shader_buffer_load extension that allows shaders to access buffer + objects without binding them. In both cases, these extensions + significantly reduce the amount of API and internal GL driver overhead + needed to manage resource bindings. + + This extension also provides similar capability for the image load, store, + and atomic functionality provided by OpenGL 4.2, OpenGL ES 3.1 and the + ARB_shader_image_load_store and EXT_shader_image_load_store extensions, + where a texture can be accessed without first binding it to an image unit. + An image handle can be extracted from a texture object using an API with a + set of parameters similar to those for BindImageTextureEXT. + + This extension adds no new data types to GLSL. Instead, it uses existing + sampler and image data types and allows them to be populated with texture + and image handles. This extension does permit sampler and image data + types to be used in more contexts than in unextended GLSL 4.00. In + particular, sampler and image types may be used as shader inputs/outputs, + temporary variables, and uniform block members, and may be assigned to by + shader code. Constructors are provided to convert 64-bit unsigned integer + values to and from sampler and image data types. Additionally, new APIs + are provided to load values for sampler and image uniforms with 64-bit + handle inputs. The use of existing integer-based Uniform* APIs is still + permitted, in which case the integer specified will identify a texture + image or image unit. For samplers and images with values specified as + texture image or image units, the GL implemenation will translate the unit + number to an internal handle as required. + + To access texture or image resources using handles, the handles must first + be made resident. Accessing a texture or image by handle without first + making it resident can result in undefined results, including program + termination. Since the amount of texture memory required by an + application may exceed the amount of memory available to the system, this + extension provides API calls allowing applications to manage overall + texture memory consumption by making a texture resident and non-resident + as required. + + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/bindless_texture.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.NV.bindless_texture import * +from OpenGL.raw.GLES2.NV.bindless_texture import _EXTENSION_NAME + +def glInitBindlessTextureNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glUniformHandleui64vNV.value size not checked against count +glUniformHandleui64vNV=wrapper.wrapper(glUniformHandleui64vNV).setInputArraySize( + 'value', None +) +# INPUT glProgramUniformHandleui64vNV.values size not checked against count +glProgramUniformHandleui64vNV=wrapper.wrapper(glProgramUniformHandleui64vNV).setInputArraySize( + 'values', None +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/blend_equation_advanced.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/blend_equation_advanced.py new file mode 100644 index 00000000..e73a3297 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/blend_equation_advanced.py @@ -0,0 +1,99 @@ +'''OpenGL extension NV.blend_equation_advanced + +This module customises the behaviour of the +OpenGL.raw.GLES2.NV.blend_equation_advanced to provide a more +Python-friendly API + +Overview (from the spec) + + This extension adds a number of "advanced" blending equations that can be + used to perform new color blending operations, many of which are more + complex than the standard blend modes provided by unextended OpenGL. This + extension provides two different extension string entries: + + - NV_blend_equation_advanced: Provides the new blending equations, but + guarantees defined results only if each sample is touched no more than + once in any single rendering pass. The command BlendBarrierNV() is + provided to indicate a boundary between passes. + + - NV_blend_equation_advanced_coherent: Provides the new blending + equations, and guarantees that blending is done coherently and in API + primitive ordering. An enable is provided to allow implementations to + opt out of fully coherent blending and instead behave as though only + NV_blend_equation_advanced were supported. + + Some implementations may support NV_blend_equation_advanced without + supporting NV_blend_equation_advanced_coherent. + + In unextended OpenGL, the set of blending equations is limited, and can be + expressed very simply. The MIN and MAX blend equations simply compute + component-wise minimums or maximums of source and destination color + components. The FUNC_ADD, FUNC_SUBTRACT, and FUNC_REVERSE_SUBTRACT + multiply the source and destination colors by source and destination + factors and either add the two products together or subtract one from the + other. This limited set of operations supports many common blending + operations but precludes the use of more sophisticated transparency and + blending operations commonly available in many dedicated imaging APIs. + + This extension provides a number of new "advanced" blending equations. + Unlike traditional blending operations using the FUNC_ADD equation, these + blending equations do not use source and destination factors specified by + BlendFunc. Instead, each blend equation specifies a complete equation + based on the source and destination colors. These new blend equations are + used for both RGB and alpha components; they may not be used to perform + separate RGB and alpha blending (via functions like + BlendEquationSeparate). + + These blending operations are performed using premultiplied colors, where + RGB colors stored in the framebuffer are considered to be multiplied by + alpha (coverage). The fragment color may be considered premultiplied or + non-premultiplied, according the BLEND_PREMULTIPLIED_SRC_NV blending + parameter (as specified by the new BlendParameteriNV function). If + fragment color is considered non-premultiplied, the (R,G,B) color + components are multiplied by the alpha component prior to blending. For + non-premultiplied color components in the range [0,1], the corresponding + premultiplied color component would have values in the range [0*A,1*A]. + + Many of these advanced blending equations are formulated where the result + of blending source and destination colors with partial coverage have three + separate contributions: from the portions covered by both the source and + the destination, from the portion covered only by the source, and from the + portion covered only by the destination. The blend parameter + BLEND_OVERLAP_NV can be used to specify a correlation between source and + destination pixel coverage. If set to CONJOINT_NV, the source and + destination are considered to have maximal overlap, as would be the case + if drawing two objects on top of each other. If set to DISJOINT_NV, the + source and destination are considered to have minimal overlap, as would be + the case when rendering a complex polygon tessellated into individual + non-intersecting triangles. If set to UNCORRELATED_NV (default), the + source and destination coverage are assumed to have no spatial correlation + within the pixel. + + In addition to the coherency issues on implementations not supporting + NV_blend_equation_advanced_coherent, this extension has several + limitations worth noting. First, the new blend equations are not + supported while rendering to more than one color buffer at once; an + INVALID_OPERATION will be generated if an application attempts to render + any primitives in this unsupported configuration. Additionally, blending + precision may be limited to 16-bit floating-point, which could result in a + loss of precision and dynamic range for framebuffer formats with 32-bit + floating-point components, and in a loss of precision for formats with 12- + and 16-bit signed or unsigned normalized integer components. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/blend_equation_advanced.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.NV.blend_equation_advanced import * +from OpenGL.raw.GLES2.NV.blend_equation_advanced import _EXTENSION_NAME + +def glInitBlendEquationAdvancedNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/blend_equation_advanced_coherent.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/blend_equation_advanced_coherent.py new file mode 100644 index 00000000..75d65c59 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/blend_equation_advanced_coherent.py @@ -0,0 +1,23 @@ +'''OpenGL extension NV.blend_equation_advanced_coherent + +This module customises the behaviour of the +OpenGL.raw.GLES2.NV.blend_equation_advanced_coherent to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/blend_equation_advanced_coherent.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.NV.blend_equation_advanced_coherent import * +from OpenGL.raw.GLES2.NV.blend_equation_advanced_coherent import _EXTENSION_NAME + +def glInitBlendEquationAdvancedCoherentNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/blend_minmax_factor.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/blend_minmax_factor.py new file mode 100644 index 00000000..6a4aa403 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/blend_minmax_factor.py @@ -0,0 +1,41 @@ +'''OpenGL extension NV.blend_minmax_factor + +This module customises the behaviour of the +OpenGL.raw.GLES2.NV.blend_minmax_factor to provide a more +Python-friendly API + +Overview (from the spec) + + The EXT_blend_minmax extension extended the GL's blending + functionality to allow the blending equation to be specified by the + application. That extension introduced the MIN_EXT and MAX_EXT blend + equations, which caused the result of the blend equation to become + the minimum or maximum of the source color and destination color, + respectively. + + The MIN_EXT and MAX_EXT blend equations, however, do not include the + source or destination blend factors in the arguments to the min and + max functions. This extension provides two new blend equations that + produce the minimum or maximum of the products of the source color + and source factor, and the destination color and destination factor. + + This NVIDIA extension has some limitations relative to the + AMD_blend_minmax_factor extension. See issues #1, #2, and #3. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/blend_minmax_factor.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.NV.blend_minmax_factor import * +from OpenGL.raw.GLES2.NV.blend_minmax_factor import _EXTENSION_NAME + +def glInitBlendMinmaxFactorNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/clip_space_w_scaling.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/clip_space_w_scaling.py new file mode 100644 index 00000000..41cef64e --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/clip_space_w_scaling.py @@ -0,0 +1,55 @@ +'''OpenGL extension NV.clip_space_w_scaling + +This module customises the behaviour of the +OpenGL.raw.GLES2.NV.clip_space_w_scaling to provide a more +Python-friendly API + +Overview (from the spec) + + Virtual Reality (VR) applications often involve a post-processing step to + apply a "barrel" distortion to the rendered image to correct the + "pincushion" distortion introduced by the optics in a VR device. The + barrel distorted image has lower resolution along the edges compared to + the center. Since the original image is rendered at high resolution, + which is uniform across the complete image, a lot of pixels towards the + edges do not make it to the final post-processed image. + + This extension also provides a mechanism to render VR scenes at a + non-uniform resolution, in particular a resolution that falls linearly + from the center towards the edges. This is achieved by scaling the "w" + coordinate of the vertices in the clip space before perspective divide. + The clip space "w" coordinate of the vertices may be offset as of a + function of "x" and "y" coordinates as follows: + + w' = w + Ax + By + + In the intended use case for viewport position scaling, an application + should use a set of 4 viewports, one for each of the 4 quadrants of a + Cartesian coordinate system. Each viewport is set to the dimension of the + image, but is scissored to the quadrant it represents. The application + should specify A and B coefficients of the w-scaling equation above, + that have the same value, but different signs, for each of the viewports. + The signs of A and B should match the signs of X and Y for the quadrant + that they represent such that the value of "w'" will always be greater + than or equal to the original "w" value for the entire image. Since the + offset to "w", (Ax + By), is always positive and increases with the + absolute values of "x" and "y", the effective resolution will fall off + linearly from the center of the image to its edges. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/clip_space_w_scaling.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.NV.clip_space_w_scaling import * +from OpenGL.raw.GLES2.NV.clip_space_w_scaling import _EXTENSION_NAME + +def glInitClipSpaceWScalingNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/compute_shader_derivatives.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/compute_shader_derivatives.py new file mode 100644 index 00000000..7d8c8cb6 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/compute_shader_derivatives.py @@ -0,0 +1,36 @@ +'''OpenGL extension NV.compute_shader_derivatives + +This module customises the behaviour of the +OpenGL.raw.GLES2.NV.compute_shader_derivatives to provide a more +Python-friendly API + +Overview (from the spec) + + This extension adds OpenGL and OpenGL ES API support for the OpenGL + Shading Language (GLSL) extension "NV_compute_shader_derivatives". + + That extension, when enabled, allows applications to use derivatives in + compute shaders. It adds compute shader support for explicit derivative + built-in functions like dFdx(), automatic derivative computation in + texture lookup functions like texture(), use of the optional LOD bias + parameter to adjust the computed level of detail values in texture lookup + functions, and the texture level of detail query function + textureQueryLod(). + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/compute_shader_derivatives.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.NV.compute_shader_derivatives import * +from OpenGL.raw.GLES2.NV.compute_shader_derivatives import _EXTENSION_NAME + +def glInitComputeShaderDerivativesNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/conditional_render.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/conditional_render.py new file mode 100644 index 00000000..54218a69 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/conditional_render.py @@ -0,0 +1,52 @@ +'''OpenGL extension NV.conditional_render + +This module customises the behaviour of the +OpenGL.raw.GLES2.NV.conditional_render to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides support for conditional rendering based on the + results of an occlusion query. This mechanism allows an application to + potentially reduce the latency between the completion of an occlusion + query and the rendering commands depending on its result. It additionally + allows the decision of whether to render to be made without application + intervention. + + This extension defines two new functions, BeginConditionalRenderNV and + EndConditionalRenderNV, between which rendering commands may be discarded + based on the results of an occlusion query. If the specified occlusion + query returns a non-zero value, rendering commands between these calls are + executed. If the occlusion query returns a value of zero, all rendering + commands between the calls are discarded. + + If the occlusion query results are not available when + BeginConditionalRenderNV is executed, the parameter specifies + whether the GL should wait for the query to complete or should simply + render the subsequent geometry unconditionally. + + Additionally, the extension provides a set of "by region" modes, allowing + for implementations that divide rendering work by screen regions to + perform the conditional query test on a region-by-region basis without + checking the query results from other regions. Such a mode is useful for + cases like split-frame SLI, where a frame is divided between multiple + GPUs, each of which has its own occlusion query hardware. + + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/conditional_render.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.NV.conditional_render import * +from OpenGL.raw.GLES2.NV.conditional_render import _EXTENSION_NAME + +def glInitConditionalRenderNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/conservative_raster.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/conservative_raster.py new file mode 100644 index 00000000..5f34fa79 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/conservative_raster.py @@ -0,0 +1,42 @@ +'''OpenGL extension NV.conservative_raster + +This module customises the behaviour of the +OpenGL.raw.GLES2.NV.conservative_raster to provide a more +Python-friendly API + +Overview (from the spec) + + This extension adds a "conservative" rasterization mode where any pixel + that is partially covered, even if no sample location is covered, is + treated as fully covered and a corresponding fragment will be shaded. + + A new control is also added to modify window coordinate snapping + precision. + + These controls can be used to implement "binning" to a low-resolution + render target, for example to determine which tiles of a sparse texture + need to be populated. An app can construct a framebuffer where there is + one pixel per tile in the sparse texture, and adjust the number of + subpixel bits such that snapping occurs to the same effective grid as when + rendering to the sparse texture. Then triangles should cover (at least) + the same pixels in the low-res framebuffer as they do tiles in the sparse + texture. + + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/conservative_raster.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.NV.conservative_raster import * +from OpenGL.raw.GLES2.NV.conservative_raster import _EXTENSION_NAME + +def glInitConservativeRasterNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/conservative_raster_pre_snap.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/conservative_raster_pre_snap.py new file mode 100644 index 00000000..fc86e5de --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/conservative_raster_pre_snap.py @@ -0,0 +1,31 @@ +'''OpenGL extension NV.conservative_raster_pre_snap + +This module customises the behaviour of the +OpenGL.raw.GLES2.NV.conservative_raster_pre_snap to provide a more +Python-friendly API + +Overview (from the spec) + + NV_conservative_raster_pre_snap_triangles provides a new mode to achieve + rasterization of triangles that is conservative w.r.t the triangle at + infinite precision i.e. before it is snapped to the sub-pixel grid. This + extension provides a new mode that expands this functionality to lines and + points. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/conservative_raster_pre_snap.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.NV.conservative_raster_pre_snap import * +from OpenGL.raw.GLES2.NV.conservative_raster_pre_snap import _EXTENSION_NAME + +def glInitConservativeRasterPreSnapNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/conservative_raster_pre_snap_triangles.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/conservative_raster_pre_snap_triangles.py new file mode 100644 index 00000000..f3ba7f19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/conservative_raster_pre_snap_triangles.py @@ -0,0 +1,47 @@ +'''OpenGL extension NV.conservative_raster_pre_snap_triangles + +This module customises the behaviour of the +OpenGL.raw.GLES2.NV.conservative_raster_pre_snap_triangles to provide a more +Python-friendly API + +Overview (from the spec) + + When CONSERVATIVE_RASTERIZATION_NV is enabled, the fragments generated for + a primitive are conservative with respect to the primitive after snapping + to sub-pixel grid. This extension provides a new mode of rasterization + for triangles where the fragments generated are conservative with respect + to the primitive at infinite precision before vertex snapping. + + When the conservative raster mode is set to CONSERVATIVE_RASTER_MODE_PRE_- + SNAP_TRIANGLES, triangles are rasterized more conservatively, and may + generate fragments not generated when the mode is CONSERVATIVE_RASTER_MODE_- + POST_SNAP (default). In particular it may generate fragments for pixels + covered by triangles with zero area, or for pixels that are adjacent to + but not covered by any triangle. This modified behavior may be useful in + compensating for rounding errors caused by snapping vertex positions to a + sub-pixel grid during rasterization. It's possible that a non-degenerate + triangle becomes degenerate due to snapping. It's additionally possible + that rounding errors in computing the position of a vertex or from + snapping may cause a primitive that would cover a pixel at infinite + precision to fail to cover the pixel post-snap. Rasterizing such + primitives more conservatively may be useful for "binning" algorithms + described in NV_conservative_raster. + + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/conservative_raster_pre_snap_triangles.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.NV.conservative_raster_pre_snap_triangles import * +from OpenGL.raw.GLES2.NV.conservative_raster_pre_snap_triangles import _EXTENSION_NAME + +def glInitConservativeRasterPreSnapTrianglesNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/copy_buffer.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/copy_buffer.py new file mode 100644 index 00000000..3bec550e --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/copy_buffer.py @@ -0,0 +1,30 @@ +'''OpenGL extension NV.copy_buffer + +This module customises the behaviour of the +OpenGL.raw.GLES2.NV.copy_buffer to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides a mechanism to do an accelerated copy from one + buffer object to another. This may be useful to load buffer objects + in a "loading thread" while minimizing cost and synchronization effort + in the "rendering thread." + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/copy_buffer.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.NV.copy_buffer import * +from OpenGL.raw.GLES2.NV.copy_buffer import _EXTENSION_NAME + +def glInitCopyBufferNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/coverage_sample.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/coverage_sample.py new file mode 100644 index 00000000..dd8f254f --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/coverage_sample.py @@ -0,0 +1,23 @@ +'''OpenGL extension NV.coverage_sample + +This module customises the behaviour of the +OpenGL.raw.GLES2.NV.coverage_sample to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/coverage_sample.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.NV.coverage_sample import * +from OpenGL.raw.GLES2.NV.coverage_sample import _EXTENSION_NAME + +def glInitCoverageSampleNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/depth_nonlinear.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/depth_nonlinear.py new file mode 100644 index 00000000..6fbbe323 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/depth_nonlinear.py @@ -0,0 +1,23 @@ +'''OpenGL extension NV.depth_nonlinear + +This module customises the behaviour of the +OpenGL.raw.GLES2.NV.depth_nonlinear to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/depth_nonlinear.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.NV.depth_nonlinear import * +from OpenGL.raw.GLES2.NV.depth_nonlinear import _EXTENSION_NAME + +def glInitDepthNonlinearNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/draw_buffers.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/draw_buffers.py new file mode 100644 index 00000000..c4c3a275 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/draw_buffers.py @@ -0,0 +1,38 @@ +'''OpenGL extension NV.draw_buffers + +This module customises the behaviour of the +OpenGL.raw.GLES2.NV.draw_buffers to provide a more +Python-friendly API + +Overview (from the spec) + + This extension extends OpenGL ES 2.0 to allow multiple output + colors, and provides a mechanism for directing those outputs to + multiple color buffers. + + This extension serves a similar purpose to ARB_draw_buffers except + that this is for OpenGL ES 2.0. + + When OpenGL ES 3.0 is present, this extension relaxes the order + restriction on color attachments to draw framebuffer objects. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/draw_buffers.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.NV.draw_buffers import * +from OpenGL.raw.GLES2.NV.draw_buffers import _EXTENSION_NAME + +def glInitDrawBuffersNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glDrawBuffersNV.bufs size not checked against n +glDrawBuffersNV=wrapper.wrapper(glDrawBuffersNV).setInputArraySize( + 'bufs', None +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/draw_instanced.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/draw_instanced.py new file mode 100644 index 00000000..dc9a3e79 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/draw_instanced.py @@ -0,0 +1,47 @@ +'''OpenGL extension NV.draw_instanced + +This module customises the behaviour of the +OpenGL.raw.GLES2.NV.draw_instanced to provide a more +Python-friendly API + +Overview (from the spec) + + A common use case in GL for some applications is to be able to + draw the same object, or groups of similar objects that share + vertex data, primitive count and type, multiple times. This + extension provides a means of accelerating such use cases while + limiting the number of required API calls, and keeping the amount + of duplicate data to a minimum. + + This extension introduces two draw calls which are conceptually + equivalent to a series of draw calls. Each conceptual call in + this series is considered an "instance" of the actual draw call. + + This extension also introduces a read-only built-in variable to + GLSL which contains the "instance ID." This variable initially + contains 0, but increases by one after each conceptual draw call. + + By using the instance ID or multiples thereof as an index into + a uniform array containing transform data, vertex shaders can + draw multiple instances of an object with a single draw call. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/draw_instanced.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.NV.draw_instanced import * +from OpenGL.raw.GLES2.NV.draw_instanced import _EXTENSION_NAME + +def glInitDrawInstancedNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glDrawElementsInstancedNV.indices size not checked against 'count,type' +glDrawElementsInstancedNV=wrapper.wrapper(glDrawElementsInstancedNV).setInputArraySize( + 'indices', None +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/draw_vulkan_image.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/draw_vulkan_image.py new file mode 100644 index 00000000..e0702195 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/draw_vulkan_image.py @@ -0,0 +1,53 @@ +'''OpenGL extension NV.draw_vulkan_image + +This module customises the behaviour of the +OpenGL.raw.GLES2.NV.draw_vulkan_image to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides a new function, DrawVkImageNV(), allowing + applications to draw a screen-aligned rectangle displaying some or all of + the contents of a two-dimensional Vulkan VkImage. Callers specify a + Vulkan VkImage handle, an optional OpenGL sampler object, window + coordinates of the rectangle to draw, and texture coordinates corresponding + to the corners of the rectangle. For each fragment produced by the + rectangle, DrawVkImageNV interpolates the texture coordinates, performs + a texture lookup, and uses the texture result as the fragment color. + + No shaders are used by DrawVkImageNV; the results of the texture lookup + are used in lieu of a fragment shader output. The fragments generated are + processed by all per-fragment operations. In particular, + DrawVkImageNV() fully supports blending and multisampling. + + In order to synchronize between Vulkan and OpenGL there are three other + functions provided; WaitVkSemaphoreNV(), SignalVkSemaphoreNV() and + SignalVkFenceNV(). These allow OpenGL to wait for Vulkan to complete work + and also Vulkan to wait for OpenGL to complete work. Together OpenGL + and Vulkan can synchronize on the server without application + interation. + + Finally the function GetVkProcAddrNV() is provided to allow the OpenGL + context to query the Vulkan entry points directly and avoid having to + load them through the typical Vulkan loader. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/draw_vulkan_image.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.NV.draw_vulkan_image import * +from OpenGL.raw.GLES2.NV.draw_vulkan_image import _EXTENSION_NAME + +def glInitDrawVulkanImageNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glGetVkProcAddrNV.name size not checked against 'name' +glGetVkProcAddrNV=wrapper.wrapper(glGetVkProcAddrNV).setInputArraySize( + 'name', None +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/explicit_attrib_location.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/explicit_attrib_location.py new file mode 100644 index 00000000..f7a0ba8d --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/explicit_attrib_location.py @@ -0,0 +1,31 @@ +'''OpenGL extension NV.explicit_attrib_location + +This module customises the behaviour of the +OpenGL.raw.GLES2.NV.explicit_attrib_location to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides a method to pre-assign attribute locations + to named vertex shader inputs. This allows applications to globally + assign a particular semantic meaning, such as diffuse color or + vertex normal, to a particular attribute location without knowing + how that attribute will be named in any particular shader. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/explicit_attrib_location.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.NV.explicit_attrib_location import * +from OpenGL.raw.GLES2.NV.explicit_attrib_location import _EXTENSION_NAME + +def glInitExplicitAttribLocationNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/fbo_color_attachments.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/fbo_color_attachments.py new file mode 100644 index 00000000..4933c05e --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/fbo_color_attachments.py @@ -0,0 +1,28 @@ +'''OpenGL extension NV.fbo_color_attachments + +This module customises the behaviour of the +OpenGL.raw.GLES2.NV.fbo_color_attachments to provide a more +Python-friendly API + +Overview (from the spec) + + This extension increases the number of available framebuffer object + color attachment points. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/fbo_color_attachments.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.NV.fbo_color_attachments import * +from OpenGL.raw.GLES2.NV.fbo_color_attachments import _EXTENSION_NAME + +def glInitFboColorAttachmentsNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/fence.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/fence.py new file mode 100644 index 00000000..27f2bb10 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/fence.py @@ -0,0 +1,62 @@ +'''OpenGL extension NV.fence + +This module customises the behaviour of the +OpenGL.raw.GLES2.NV.fence to provide a more +Python-friendly API + +Overview (from the spec) + + The goal of this extension is provide a finer granularity of + synchronizing GL command completion than offered by standard OpenGL, + which offers only two mechanisms for synchronization: Flush and Finish. + Since Flush merely assures the user that the commands complete in a + finite (though undetermined) amount of time, it is, thus, of only + modest utility. Finish, on the other hand, stalls CPU execution + until all pending GL commands have completed. This extension offers + a middle ground - the ability to "finish" a subset of the command + stream, and the ability to determine whether a given command has + completed or not. + + This extension introduces the concept of a "fence" to the OpenGL + command stream. Once the fence is inserted into the command stream, it + can be queried for a given condition - typically, its completion. + Moreover, the application may also request a partial Finish -- that is, + all commands prior to the fence will be forced to complete until control + is returned to the calling process. These new mechanisms allow for + synchronization between the host CPU and the GPU, which may be accessing + the same resources (typically memory). + + This extension is useful in conjunction with NV_vertex_array_range + to determine when vertex information has been pulled from the + vertex array range. Once a fence has been tested TRUE or finished, + all vertex indices issued before the fence must have been pulled. + This ensures that the vertex data memory corresponding to the issued + vertex indices can be safely modified (assuming no other outstanding + vertex indices are issued subsequent to the fence). + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/fence.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.NV.fence import * +from OpenGL.raw.GLES2.NV.fence import _EXTENSION_NAME + +def glInitFenceNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glDeleteFencesNV.fences size not checked against n +glDeleteFencesNV=wrapper.wrapper(glDeleteFencesNV).setInputArraySize( + 'fences', None +) +glGenFencesNV=wrapper.wrapper(glGenFencesNV).setOutput( + 'fences',size=lambda x:(x,),pnameArg='n',orPassIn=True +) +glGetFenceivNV=wrapper.wrapper(glGetFenceivNV).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/fill_rectangle.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/fill_rectangle.py new file mode 100644 index 00000000..f06e4be9 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/fill_rectangle.py @@ -0,0 +1,32 @@ +'''OpenGL extension NV.fill_rectangle + +This module customises the behaviour of the +OpenGL.raw.GLES2.NV.fill_rectangle to provide a more +Python-friendly API + +Overview (from the spec) + + This extension adds a new PolygonMode setting where a triangle is + rasterized by computing and filling its axis-aligned screen-space bounding + box, disregarding the actual triangle edges. This can be useful for + drawing a rectangle without being split into two triangles with an + internal edge. It is also useful to minimize the number of primitives + that need to be drawn, particularly for a user-interface. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/fill_rectangle.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.NV.fill_rectangle import * +from OpenGL.raw.GLES2.NV.fill_rectangle import _EXTENSION_NAME + +def glInitFillRectangleNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/fragment_coverage_to_color.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/fragment_coverage_to_color.py new file mode 100644 index 00000000..f026b4fe --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/fragment_coverage_to_color.py @@ -0,0 +1,38 @@ +'''OpenGL extension NV.fragment_coverage_to_color + +This module customises the behaviour of the +OpenGL.raw.GLES2.NV.fragment_coverage_to_color to provide a more +Python-friendly API + +Overview (from the spec) + + This extension allows the fragment coverage value, represented as an + integer bitfield, to be substituted for a color output being written to a + single-component color buffer with integer components (e.g., R8UI). The + capability provided by this extension is different from simply writing the + gl_SampleMask fragment shader output in that the coverage value written to + the framebuffer is taken after alpha test, stencil test, and depth test, + as well as after the multisample fragment operations such as + alpha-to-coverage. + + This functionality may be useful for deferred rendering algorithms, where + the second pass needs to know which samples belong to which original + fragments. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/fragment_coverage_to_color.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.NV.fragment_coverage_to_color import * +from OpenGL.raw.GLES2.NV.fragment_coverage_to_color import _EXTENSION_NAME + +def glInitFragmentCoverageToColorNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/fragment_shader_barycentric.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/fragment_shader_barycentric.py new file mode 100644 index 00000000..4743efb5 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/fragment_shader_barycentric.py @@ -0,0 +1,32 @@ +'''OpenGL extension NV.fragment_shader_barycentric + +This module customises the behaviour of the +OpenGL.raw.GLES2.NV.fragment_shader_barycentric to provide a more +Python-friendly API + +Overview (from the spec) + + This extension advertises OpenGL support for the OpenGL Shading Language + (GLSL) extension "NV_fragment_shader_barycentric", which provides fragment + shader built-in variables holding barycentric weight vectors that identify + the location of the fragment within its primitive. Additionally, the GLSL + extension allows fragment the ability to read raw attribute values for + each of the vertices of the primitive that produced the fragment. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/fragment_shader_barycentric.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.NV.fragment_shader_barycentric import * +from OpenGL.raw.GLES2.NV.fragment_shader_barycentric import _EXTENSION_NAME + +def glInitFragmentShaderBarycentricNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/fragment_shader_interlock.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/fragment_shader_interlock.py new file mode 100644 index 00000000..a5173a9a --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/fragment_shader_interlock.py @@ -0,0 +1,79 @@ +'''OpenGL extension NV.fragment_shader_interlock + +This module customises the behaviour of the +OpenGL.raw.GLES2.NV.fragment_shader_interlock to provide a more +Python-friendly API + +Overview (from the spec) + + In unextended OpenGL 4.3 or OpenGL ES 3.1, applications may produce a + large number of fragment shader invocations that perform loads and + stores to memory using image uniforms, atomic counter uniforms, + buffer variables, or pointers. The order in which loads and stores + to common addresses are performed by different fragment shader + invocations is largely undefined. For algorithms that use shader + writes and touch the same pixels more than once, one or more of the + following techniques may be required to ensure proper execution ordering: + + * inserting Finish or WaitSync commands to drain the pipeline between + different "passes" or "layers"; + + * using only atomic memory operations to write to shader memory (which + may be relatively slow and limits how memory may be updated); or + + * injecting spin loops into shaders to prevent multiple shader + invocations from touching the same memory concurrently. + + This extension provides new GLSL built-in functions + beginInvocationInterlockNV() and endInvocationInterlockNV() that delimit a + critical section of fragment shader code. For pairs of shader invocations + with "overlapping" coverage in a given pixel, the OpenGL implementation + will guarantee that the critical section of the fragment shader will be + executed for only one fragment at a time. + + There are four different interlock modes supported by this extension, + which are identified by layout qualifiers. The qualifiers + "pixel_interlock_ordered" and "pixel_interlock_unordered" provides mutual + exclusion in the critical section for any pair of fragments corresponding + to the same pixel. When using multisampling, the qualifiers + "sample_interlock_ordered" and "sample_interlock_unordered" only provide + mutual exclusion for pairs of fragments that both cover at least one + common sample in the same pixel; these are recommended for performance if + shaders use per-sample data structures. + + Additionally, when the "pixel_interlock_ordered" or + "sample_interlock_ordered" layout qualifier is used, the interlock also + guarantees that the critical section for multiple shader invocations with + "overlapping" coverage will be executed in the order in which the + primitives were processed by the GL. Such a guarantee is useful for + applications like blending in the fragment shader, where an application + requires that fragment values to be composited in the framebuffer in + primitive order. + + This extension can be useful for algorithms that need to access per-pixel + data structures via shader loads and stores. Such algorithms using this + extension can access such data structures in the critical section without + worrying about other invocations for the same pixel accessing the data + structures concurrently. Additionally, the ordering guarantees are useful + for cases where the API ordering of fragments is meaningful. For example, + applications may be able to execute programmable blending operations in + the fragment shader, where the destination buffer is read via image loads + and the final value is written via image stores. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/fragment_shader_interlock.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.NV.fragment_shader_interlock import * +from OpenGL.raw.GLES2.NV.fragment_shader_interlock import _EXTENSION_NAME + +def glInitFragmentShaderInterlockNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/framebuffer_blit.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/framebuffer_blit.py new file mode 100644 index 00000000..40d761c3 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/framebuffer_blit.py @@ -0,0 +1,32 @@ +'''OpenGL extension NV.framebuffer_blit + +This module customises the behaviour of the +OpenGL.raw.GLES2.NV.framebuffer_blit to provide a more +Python-friendly API + +Overview (from the spec) + + This extension modifies OpenGL ES 2.0 by splitting the + framebuffer object binding point into separate DRAW and READ + bindings. This allows copying directly from one framebuffer to + another. In addition, a new high performance blit function is + added to facilitate these blits and perform some data conversion + where allowed. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/framebuffer_blit.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.NV.framebuffer_blit import * +from OpenGL.raw.GLES2.NV.framebuffer_blit import _EXTENSION_NAME + +def glInitFramebufferBlitNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/framebuffer_mixed_samples.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/framebuffer_mixed_samples.py new file mode 100644 index 00000000..a18f5055 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/framebuffer_mixed_samples.py @@ -0,0 +1,79 @@ +'''OpenGL extension NV.framebuffer_mixed_samples + +This module customises the behaviour of the +OpenGL.raw.GLES2.NV.framebuffer_mixed_samples to provide a more +Python-friendly API + +Overview (from the spec) + + This extension allows multisample rendering with a raster and + depth/stencil sample count that is larger than the color sample count. + Rasterization and the results of the depth and stencil tests together + determine the portion of a pixel that is "covered". It can be useful to + evaluate coverage at a higher frequency than color samples are stored. + This coverage is then "reduced" to a collection of covered color samples, + each having an opacity value corresponding to the fraction of the color + sample covered. The opacity can optionally be blended into individual + color samples. + + In the current hardware incarnation both depth and stencil testing are + supported with mixed samples, although the API accommodates supporting + only one or the other. + + Rendering with fewer color samples than depth/stencil samples can greatly + reduce the amount of memory and bandwidth consumed by the color buffer. + However, converting the coverage values into opacity can introduce + artifacts where triangles share edges and may not be suitable for normal + triangle mesh rendering. + + One expected use case for this functionality is Stencil-then-Cover path + rendering (NV_path_rendering). The stencil step determines the coverage + (in the stencil buffer) for an entire path at the higher sample frequency, + and then the cover step can draw the path into the lower frequency color + buffer using the coverage information to antialias path edges. With this + two-step process, internal edges are fully covered when antialiasing is + applied and there is no corruption on these edges. + + The key features of this extension are: + + - It allows a framebuffer object to be considered complete when its depth + or stencil samples are a multiple of the number of color samples. + + - It redefines SAMPLES to be the number of depth/stencil samples (if any); + otherwise, it uses the number of color samples. SAMPLE_BUFFERS is one if + there are multisample depth/stencil attachments. Multisample + rasterization and multisample fragment ops are allowed if SAMPLE_BUFFERS + is one. + + - It replaces several error checks involving SAMPLE_BUFFERS by error + checks directly referencing the number of samples in the relevant + attachments. + + - A coverage reduction step is added to Per-Fragment Operations which + converts a set of covered raster/depth/stencil samples to a set of + covered color samples. The coverage reduction step also includes an + optional coverage modulation step, multiplying color values by a + fractional opacity corresponding to the number of associated + raster/depth/stencil samples covered. + + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/framebuffer_mixed_samples.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.NV.framebuffer_mixed_samples import * +from OpenGL.raw.GLES2.NV.framebuffer_mixed_samples import _EXTENSION_NAME + +def glInitFramebufferMixedSamplesNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glCoverageModulationTableNV.v size not checked against n +glCoverageModulationTableNV=wrapper.wrapper(glCoverageModulationTableNV).setInputArraySize( + 'v', None +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/framebuffer_multisample.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/framebuffer_multisample.py new file mode 100644 index 00000000..fa45c8b8 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/framebuffer_multisample.py @@ -0,0 +1,48 @@ +'''OpenGL extension NV.framebuffer_multisample + +This module customises the behaviour of the +OpenGL.raw.GLES2.NV.framebuffer_multisample to provide a more +Python-friendly API + +Overview (from the spec) + + This extension extends the framebuffer object framework to + enable multisample rendering. + + The new operation RenderbufferStorageMultisampleNV() allocates + storage for a renderbuffer object that can be used as a multisample + buffer. A multisample render buffer image differs from a + single-sample render buffer image in that a multisample image has a + number of SAMPLES that is greater than zero. No method is provided + for creating multisample texture images. + + All of the framebuffer-attachable images attached to a framebuffer + object must have the same number of SAMPLES or else the framebuffer + object is not "framebuffer complete". If a framebuffer object with + multisample attachments is "framebuffer complete", then the + framebuffer object behaves as if SAMPLE_BUFFERS is one. + + A resolve operation is executed by calling + BlitFramebufferNV (provided by the NV_framebuffer_blit + extension) where the source is a multisample framebuffer object + and the destination is a single-sample framebuffer object. + Source and destination framebuffer may be either application-created + or window-system provided. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/framebuffer_multisample.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.NV.framebuffer_multisample import * +from OpenGL.raw.GLES2.NV.framebuffer_multisample import _EXTENSION_NAME + +def glInitFramebufferMultisampleNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/generate_mipmap_sRGB.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/generate_mipmap_sRGB.py new file mode 100644 index 00000000..9e9b8ea2 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/generate_mipmap_sRGB.py @@ -0,0 +1,28 @@ +'''OpenGL extension NV.generate_mipmap_sRGB + +This module customises the behaviour of the +OpenGL.raw.GLES2.NV.generate_mipmap_sRGB to provide a more +Python-friendly API + +Overview (from the spec) + + EXT_sRGB requires GenerateMipmap() to throw INVALID_OPERATION on textures + with sRGB encoding. NV_generate_mipmap_sRGB lifts this restriction. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/generate_mipmap_sRGB.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.NV.generate_mipmap_sRGB import * +from OpenGL.raw.GLES2.NV.generate_mipmap_sRGB import _EXTENSION_NAME + +def glInitGenerateMipmapSrgbNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/geometry_shader_passthrough.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/geometry_shader_passthrough.py new file mode 100644 index 00000000..a48d4e12 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/geometry_shader_passthrough.py @@ -0,0 +1,99 @@ +'''OpenGL extension NV.geometry_shader_passthrough + +This module customises the behaviour of the +OpenGL.raw.GLES2.NV.geometry_shader_passthrough to provide a more +Python-friendly API + +Overview (from the spec) + + Geometry shaders provide the ability for applications to process each + primitive sent through the GL using a programmable shader. While geometry + shaders can be used to perform a number of different operations, including + subdividing primitives and changing primitive type, one common use case + treats geometry shaders as largely "passthrough". In this use case, the + bulk of the geometry shader code simply copies inputs from each vertex of + the input primitive to corresponding outputs in the vertices of the output + primitive. Such shaders might also compute values for additional built-in + or user-defined per-primitive attributes (e.g., gl_Layer) to be assigned + to all the vertices of the output primitive. + + This extension provides a shading language abstraction to express such + shaders without requiring explicit logic to manually copy attributes from + input vertices to output vertices. For example, consider the following + simple geometry shader in unextended OpenGL: + + layout(triangles) in; + layout(triangle_strip) out; + layout(max_vertices=3) out; + + in Inputs { + vec2 texcoord; + vec4 baseColor; + } v_in[]; + out Outputs { + vec2 texcoord; + vec4 baseColor; + }; + + void main() + { + int layer = compute_layer(); + for (int i = 0; i < 3; i++) { + gl_Position = gl_in[i].gl_Position; + texcoord = v_in[i].texcoord; + baseColor = v_in[i].baseColor; + gl_Layer = layer; + EmitVertex(); + } + } + + In this shader, the inputs "gl_Position", "Inputs.texcoord", and + "Inputs.baseColor" are simply copied from the input vertex to the + corresponding output vertex. The only "interesting" work done by the + geometry shader is computing and emitting a gl_Layer value for the + primitive. + + The following geometry shader, using this extension, is equivalent: + + #extension GL_NV_geometry_shader_passthrough : require + + layout(triangles) in; + // No output primitive layout qualifiers required. + + // Redeclare gl_PerVertex to pass through "gl_Position". + layout(passthrough) in gl_PerVertex { + vec4 gl_Position; + } gl_in[]; + + // Declare "Inputs" with "passthrough" to automatically copy members. + layout(passthrough) in Inputs { + vec2 texcoord; + vec4 baseColor; + } v_in[]; + + // No output block declaration required. + + void main() + { + // The shader simply computes and writes gl_Layer. We don't + // loop over three vertices or call EmitVertex(). + gl_Layer = compute_layer(); + } + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/geometry_shader_passthrough.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.NV.geometry_shader_passthrough import * +from OpenGL.raw.GLES2.NV.geometry_shader_passthrough import _EXTENSION_NAME + +def glInitGeometryShaderPassthroughNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/gpu_shader5.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/gpu_shader5.py new file mode 100644 index 00000000..86c4f449 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/gpu_shader5.py @@ -0,0 +1,154 @@ +'''OpenGL extension NV.gpu_shader5 + +This module customises the behaviour of the +OpenGL.raw.GLES2.NV.gpu_shader5 to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides a set of new features to the OpenGL Shading + Language and related APIs to support capabilities of new GPUs. Shaders + using the new functionality provided by this extension should enable this + functionality via the construct + + #extension GL_NV_gpu_shader5 : require (or enable) + + This extension was developed concurrently with the ARB_gpu_shader5 + extension, and provides a superset of the features provided there. The + features common to both extensions are documented in the ARB_gpu_shader5 + specification; this document describes only the addition language features + not available via ARB_gpu_shader5. A shader that enables this extension + via an #extension directive also implicitly enables the common + capabilities provided by ARB_gpu_shader5. + + In addition to the capabilities of ARB_gpu_shader5, this extension + provides a variety of new features for all shader types, including: + + * support for a full set of 8-, 16-, 32-, and 64-bit scalar and vector + data types, including uniform API, uniform buffer object, and shader + input and output support; + + * the ability to aggregate samplers into arrays, index these arrays with + arbitrary expressions, and not require that non-constant indices be + uniform across all shader invocations; + + * new built-in functions to pack and unpack 64-bit integer types into a + two-component 32-bit integer vector; + + * new built-in functions to pack and unpack 32-bit unsigned integer + types into a two-component 16-bit floating-point vector; + + * new built-in functions to convert double-precision floating-point + values to or from their 64-bit integer bit encodings; + + * new built-in functions to compute the composite of a set of boolean + conditions a group of shader threads; + + * vector relational functions supporting comparisons of vectors of 8-, + 16-, and 64-bit integer types or 16-bit floating-point types; and + + * extending texel offset support to allow loading texel offsets from + regular integer operands computed at run-time, except for lookups with + gradients (textureGrad*). + + This extension also provides additional support for processing patch + primitives (introduced by ARB_tessellation_shader). + ARB_tessellation_shader requires the use of a tessellation evaluation + shader when processing patches, which means that patches will never + survive past the tessellation pipeline stage. This extension lifts that + restriction, and allows patches to proceed further in the pipeline and be + used + + * as input to a geometry shader, using a new "patches" layout qualifier; + + * as input to transform feedback; + + * by fixed-function rasterization stages, in which case the patches are + drawn as independent points. + + Additionally, it allows geometry shaders to read per-patch attributes + written by a tessellation control shader using input variables declared + with "patch in". + + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/gpu_shader5.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.NV.gpu_shader5 import * +from OpenGL.raw.GLES2.NV.gpu_shader5 import _EXTENSION_NAME + +def glInitGpuShader5NV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glUniform1i64vNV.value size not checked against count +glUniform1i64vNV=wrapper.wrapper(glUniform1i64vNV).setInputArraySize( + 'value', None +) +# INPUT glUniform2i64vNV.value size not checked against count*2 +glUniform2i64vNV=wrapper.wrapper(glUniform2i64vNV).setInputArraySize( + 'value', None +) +# INPUT glUniform3i64vNV.value size not checked against count*3 +glUniform3i64vNV=wrapper.wrapper(glUniform3i64vNV).setInputArraySize( + 'value', None +) +# INPUT glUniform4i64vNV.value size not checked against count*4 +glUniform4i64vNV=wrapper.wrapper(glUniform4i64vNV).setInputArraySize( + 'value', None +) +# INPUT glUniform1ui64vNV.value size not checked against count +glUniform1ui64vNV=wrapper.wrapper(glUniform1ui64vNV).setInputArraySize( + 'value', None +) +# INPUT glUniform2ui64vNV.value size not checked against count*2 +glUniform2ui64vNV=wrapper.wrapper(glUniform2ui64vNV).setInputArraySize( + 'value', None +) +# INPUT glUniform3ui64vNV.value size not checked against count*3 +glUniform3ui64vNV=wrapper.wrapper(glUniform3ui64vNV).setInputArraySize( + 'value', None +) +# INPUT glUniform4ui64vNV.value size not checked against count*4 +glUniform4ui64vNV=wrapper.wrapper(glUniform4ui64vNV).setInputArraySize( + 'value', None +) +# OUTPUT glGetUniformi64vNV.params COMPSIZE(program, location) +# INPUT glProgramUniform1i64vNV.value size not checked against count +glProgramUniform1i64vNV=wrapper.wrapper(glProgramUniform1i64vNV).setInputArraySize( + 'value', None +) +# INPUT glProgramUniform2i64vNV.value size not checked against count*2 +glProgramUniform2i64vNV=wrapper.wrapper(glProgramUniform2i64vNV).setInputArraySize( + 'value', None +) +# INPUT glProgramUniform3i64vNV.value size not checked against count*3 +glProgramUniform3i64vNV=wrapper.wrapper(glProgramUniform3i64vNV).setInputArraySize( + 'value', None +) +# INPUT glProgramUniform4i64vNV.value size not checked against count*4 +glProgramUniform4i64vNV=wrapper.wrapper(glProgramUniform4i64vNV).setInputArraySize( + 'value', None +) +# INPUT glProgramUniform1ui64vNV.value size not checked against count +glProgramUniform1ui64vNV=wrapper.wrapper(glProgramUniform1ui64vNV).setInputArraySize( + 'value', None +) +# INPUT glProgramUniform2ui64vNV.value size not checked against count*2 +glProgramUniform2ui64vNV=wrapper.wrapper(glProgramUniform2ui64vNV).setInputArraySize( + 'value', None +) +# INPUT glProgramUniform3ui64vNV.value size not checked against count*3 +glProgramUniform3ui64vNV=wrapper.wrapper(glProgramUniform3ui64vNV).setInputArraySize( + 'value', None +) +# INPUT glProgramUniform4ui64vNV.value size not checked against count*4 +glProgramUniform4ui64vNV=wrapper.wrapper(glProgramUniform4ui64vNV).setInputArraySize( + 'value', None +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/image_formats.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/image_formats.py new file mode 100644 index 00000000..7f335974 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/image_formats.py @@ -0,0 +1,30 @@ +'''OpenGL extension NV.image_formats + +This module customises the behaviour of the +OpenGL.raw.GLES2.NV.image_formats to provide a more +Python-friendly API + +Overview (from the spec) + + OpenGL ES 3.1 specifies a variety of formats required to be usable + with texture images. This extension introduces the texture image + formats missing for parity with OpenGL 4.4. + + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/image_formats.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.NV.image_formats import * +from OpenGL.raw.GLES2.NV.image_formats import _EXTENSION_NAME + +def glInitImageFormatsNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/instanced_arrays.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/instanced_arrays.py new file mode 100644 index 00000000..895df3c9 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/instanced_arrays.py @@ -0,0 +1,52 @@ +'''OpenGL extension NV.instanced_arrays + +This module customises the behaviour of the +OpenGL.raw.GLES2.NV.instanced_arrays to provide a more +Python-friendly API + +Overview (from the spec) + + A common use case in GL for some applications is to be able to + draw the same object, or groups of similar objects that share + vertex data, primitive count and type, multiple times. This + extension provides a means of accelerating such use cases while + limiting the number of required API calls, and keeping the amount + of duplicate data to a minimum. + + In particular, this extension specifies an alternative to the + read-only shader variable introduced by NV_draw_instanced. It + uses the same draw calls introduced by that extension, but + redefines them so that a vertex shader can instead use vertex + array attributes as a source of instance data. + + This extension introduces an array "divisor" for generic + vertex array attributes, which when non-zero specifies that the + attribute is "instanced." An instanced attribute does not + advance per-vertex as usual, but rather after every + conceptual draw calls. + + (Attributes which aren't instanced are repeated in their entirety + for every conceptual draw call.) + + By specifying transform data in an instanced attribute or series + of instanced attributes, vertex shaders can, in concert with the + instancing draw calls, draw multiple instances of an object with + one draw call. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/instanced_arrays.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.NV.instanced_arrays import * +from OpenGL.raw.GLES2.NV.instanced_arrays import _EXTENSION_NAME + +def glInitInstancedArraysNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/internalformat_sample_query.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/internalformat_sample_query.py new file mode 100644 index 00000000..951fc2bc --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/internalformat_sample_query.py @@ -0,0 +1,64 @@ +'''OpenGL extension NV.internalformat_sample_query + +This module customises the behaviour of the +OpenGL.raw.GLES2.NV.internalformat_sample_query to provide a more +Python-friendly API + +Overview (from the spec) + + Some OpenGL implementations support modes of multisampling which have + properties which are non-obvious to applications and/or which may not be + standards conformant. The idea of non-conformant AA modes is not new, + and is exposed in both GLX and EGL with config caveats and the + GLX_NON_CONFORMANT_CONFIG for GLX and EGL_NON_CONFORMANT_CONFIG for EGL, + or by querying the EGL_CONFORMANT attribute in newer versions of EGL. + + Both of these mechanisms operate on a per-config basis, which works as + intended for window-based configs. However, with the advent of + application-created FBOs, it is now possible to do all the multisample + operations in an application-created FBO and never use a multisample + window. + + This extension further extends the internalformat query mechanism + (first introduced by ARB_internalformat_query and extended in + ARB_internalformat_query2) and introduces a mechanism for a + implementation to report properties of formats that may also be + dependent on the number of samples. This includes information + such as whether the combination of format and samples should be + considered conformant. This enables an implementation to report + caveats which might apply to both window and FBO-based rendering + configurations. + + Some NVIDIA drivers support multisample modes which are internally + implemented as a combination of multisampling and automatic + supersampling in order to obtain a higher level of anti-aliasing than + can be directly supported by hardware. This extension allows those + properties to be queried by an application with the MULTISAMPLES_NV, + SUPERSAMPLE_SCALE_X_NV and SUPERSAMPLE_SCALE_Y_NV properties. For + example, a 16xAA mode might be implemented by using 4 samples and + up-scaling by a factor of 2 in each of the x- and y-dimensions. + In this example, the driver might report MULTSAMPLES_NV of 4, + SUPERSAMPLE_SCALE_X_NV of 2, SUPERSAMPLE_SCALE_Y_NV of 2 and + CONFORMANT_NV of FALSE. + + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/internalformat_sample_query.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.NV.internalformat_sample_query import * +from OpenGL.raw.GLES2.NV.internalformat_sample_query import _EXTENSION_NAME + +def glInitInternalformatSampleQueryNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glGetInternalformatSampleivNV.params size not checked against bufSize +glGetInternalformatSampleivNV=wrapper.wrapper(glGetInternalformatSampleivNV).setInputArraySize( + 'params', None +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/memory_attachment.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/memory_attachment.py new file mode 100644 index 00000000..d49076ef --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/memory_attachment.py @@ -0,0 +1,31 @@ +'''OpenGL extension NV.memory_attachment + +This module customises the behaviour of the +OpenGL.raw.GLES2.NV.memory_attachment to provide a more +Python-friendly API + +Overview (from the spec) + + This extension extends the memory objects introduced with EXT_memory_object + to allow existing textures and buffers to be migrated to an imported memory + allocation. The primary use-case of this extension is plug-in development + where resource management (creation, deletion, sizing etc.) is handled by + inaccessible host application code. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/memory_attachment.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.NV.memory_attachment import * +from OpenGL.raw.GLES2.NV.memory_attachment import _EXTENSION_NAME + +def glInitMemoryAttachmentNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/mesh_shader.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/mesh_shader.py new file mode 100644 index 00000000..34da6d99 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/mesh_shader.py @@ -0,0 +1,33 @@ +'''OpenGL extension NV.mesh_shader + +This module customises the behaviour of the +OpenGL.raw.GLES2.NV.mesh_shader to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides a new mechanism allowing applications to use two + new programmable shader types -- the task and mesh shader -- to generate + collections of geometric primitives to be processed by fixed-function + primitive assembly and rasterization logic. When the task and mesh + shaders are drawn, they replace the standard programmable vertex + processing pipeline, including vertex array attribute fetching, vertex + shader processing, tessellation, and the geometry shader processing. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/mesh_shader.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.NV.mesh_shader import * +from OpenGL.raw.GLES2.NV.mesh_shader import _EXTENSION_NAME + +def glInitMeshShaderNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/non_square_matrices.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/non_square_matrices.py new file mode 100644 index 00000000..67685bca --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/non_square_matrices.py @@ -0,0 +1,50 @@ +'''OpenGL extension NV.non_square_matrices + +This module customises the behaviour of the +OpenGL.raw.GLES2.NV.non_square_matrices to provide a more +Python-friendly API + +Overview (from the spec) + + This extension adds support for non-square matrix variables in GLSL shaders. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/non_square_matrices.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.NV.non_square_matrices import * +from OpenGL.raw.GLES2.NV.non_square_matrices import _EXTENSION_NAME + +def glInitNonSquareMatricesNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glUniformMatrix2x3fvNV.value size not checked against count*6 +glUniformMatrix2x3fvNV=wrapper.wrapper(glUniformMatrix2x3fvNV).setInputArraySize( + 'value', None +) +# INPUT glUniformMatrix3x2fvNV.value size not checked against count*6 +glUniformMatrix3x2fvNV=wrapper.wrapper(glUniformMatrix3x2fvNV).setInputArraySize( + 'value', None +) +# INPUT glUniformMatrix2x4fvNV.value size not checked against count*8 +glUniformMatrix2x4fvNV=wrapper.wrapper(glUniformMatrix2x4fvNV).setInputArraySize( + 'value', None +) +# INPUT glUniformMatrix4x2fvNV.value size not checked against count*8 +glUniformMatrix4x2fvNV=wrapper.wrapper(glUniformMatrix4x2fvNV).setInputArraySize( + 'value', None +) +# INPUT glUniformMatrix3x4fvNV.value size not checked against count*12 +glUniformMatrix3x4fvNV=wrapper.wrapper(glUniformMatrix3x4fvNV).setInputArraySize( + 'value', None +) +# INPUT glUniformMatrix4x3fvNV.value size not checked against count*12 +glUniformMatrix4x3fvNV=wrapper.wrapper(glUniformMatrix4x3fvNV).setInputArraySize( + 'value', None +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/path_rendering.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/path_rendering.py new file mode 100644 index 00000000..b693c453 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/path_rendering.py @@ -0,0 +1,564 @@ +'''OpenGL extension NV.path_rendering + +This module customises the behaviour of the +OpenGL.raw.GLES2.NV.path_rendering to provide a more +Python-friendly API + +Overview (from the spec) + + Conventional OpenGL supports rendering images (pixel rectangles and + bitmaps) and simple geometric primitives (points, lines, polygons). + + This extension adds a new rendering paradigm, known as path rendering, + for rendering filled and stroked paths. Path rendering is not novel + but rather a standard part of most resolution-independent 2D rendering + systems such as Flash, PDF, Silverlight, SVG, Java 2D, Office + drawings, TrueType fonts, PostScript and its fonts, Quartz 2D, XML + Paper Specification (XPS), and OpenVG. What is novel is the ability + to mix path rendering with arbitrary OpenGL 3D rendering and imaging. + + With this extension, path rendering becomes a first-class rendering + mode within the OpenGL graphics system that can be arbitrarily mixed + with existing OpenGL rendering and can take advantage of OpenGL's + existing mechanisms for texturing, programmability, and per-fragment + operations. + + Unlike geometric primitive rendering, paths are specified on a 2D + (non-projective) plane rather than in 3D (projective) space. + Even though the path is defined in a 2D plane, every path can + be transformed into 3D clip space allowing for 3D view frustum & + user-defined clipping, depth offset, and depth testing in the same + manner as geometric primitive rendering. + + Both geometric primitive rendering and path rendering support + rasterization of edges defined by line segments; however, path + rendering also allows path segments to be specified by Bezier (cubic + or quadratic) curves or partial elliptical arcs. This allows path + rendering to define truly curved primitive boundaries unlike the + straight edges of line and polygon primitives. Whereas geometric + primitive rendering requires convex polygons for well-defined + rendering results, path rendering allows (and encourages!) concave + and curved outlines to be specified. These paths are even allowed + to self-intersect. + + When filling closed paths, the winding of paths (counterclockwise + or clockwise) determines whether pixels are inside or outside of + the path. + + Paths can also be stroked whereby, conceptually, a fixed-width "brush" + is pulled along the path such that the brush remains orthogonal to + the gradient of each path segment. Samples within the sweep of this + brush are considered inside the stroke of the path. + + This extension supports path rendering through a sequence of three + operations: + + 1. Path specification is the process of creating and updating + a path object consisting of a set of path commands and a + corresponding set of 2D vertices. + + Path commands can be specified explicitly from path command + and coordinate data, parsed from a string based on standard + grammars for representing paths, or specified by a particular + glyph of standard font representations. Also new paths can + be specified by weighting one or more existing paths so long + as all the weighted paths have consistent command sequences. + + Each path object contains zero or more subpaths specified + by a sequence of line segments, partial elliptical arcs, + and (cubic or quadratic) Bezier curve segments. Each path + may contain multiple subpaths that can be closed (forming + a contour) or open. + + 2. Path stenciling is the process of updating the stencil buffer + based on a path's coverage transformed into window space. + + Path stenciling can determine either the filled or stroked + coverage of a path. + + The details of path stenciling are explained within the core + of the specification. + + Stenciling a stroked path supports all the standard + embellishments for path stroking such as end caps, join + styles, miter limits, dashing, and dash caps. These stroking + properties specified are parameters of path objects. + + 3. Path covering is the process of emitting simple (convex & + planar) geometry that (conservatively) "covers" the path's + sample coverage in the stencil buffer. During path covering, + stencil testing can be configured to discard fragments not + within the actual coverage of the path as determined by + prior path stenciling. + + Path covering can cover either the filled or stroked coverage + of a path. + + The details of path covering are explained within the core + of the specification. + + To render a path object into the color buffer, an application specifies + a path object and then uses a two-step rendering process. First, the + path object is stenciled whereby the path object's stroked or filled + coverage is rasterized into the stencil buffer. Second, the path object + is covered whereby conservative bounding geometry for the path is + transformed and rasterized with stencil testing configured to test against + the coverage information written to the stencil buffer in the first step + so that only fragments covered by the path are written during this second + step. Also during this second step written pixels typically have + their stencil value reset (so there's no need for clearing the + stencil buffer between rendering each path). + + Here is an example of specifying and then rendering a five-point + star and a heart as a path using Scalable Vector Graphics (SVG) + path description syntax: + + GLuint pathObj = 42; + const char *svgPathString = + // star + "M100,180 L40,10 L190,120 L10,120 L160,10 z" + // heart + "M300 300 C 100 400,100 200,300 100,500 200,500 400,300 300Z"; + glPathStringNV(pathObj, GL_PATH_FORMAT_SVG_NV, + (GLsizei)strlen(svgPathString), svgPathString); + + Alternatively applications oriented around the PostScript imaging + model can use the PostScript user path syntax instead: + + const char *psPathString = + // star + "100 180 moveto" + " 40 10 lineto 190 120 lineto 10 120 lineto 160 10 lineto closepath" + // heart + " 300 300 moveto" + " 100 400 100 200 300 100 curveto" + " 500 200 500 400 300 300 curveto closepath"; + glPathStringNV(pathObj, GL_PATH_FORMAT_PS_NV, + (GLsizei)strlen(psPathString), psPathString); + + The PostScript path syntax also supports compact and precise binary + encoding and includes PostScript-style circular arcs. + + Or the path's command and coordinates can be specified explicitly: + + static const GLubyte pathCommands[10] = + { GL_MOVE_TO_NV, GL_LINE_TO_NV, GL_LINE_TO_NV, GL_LINE_TO_NV, + GL_LINE_TO_NV, GL_CLOSE_PATH_NV, + 'M', 'C', 'C', 'Z' }; // character aliases + static const GLshort pathCoords[12][2] = + { {100, 180}, {40, 10}, {190, 120}, {10, 120}, {160, 10}, + {300,300}, {100,400}, {100,200}, {300,100}, + {500,200}, {500,400}, {300,300} }; + glPathCommandsNV(pathObj, 10, pathCommands, 24, GL_SHORT, pathCoords); + + Before rendering to a window with a stencil buffer, clear the stencil + buffer to zero and the color buffer to black: + + glClearStencil(0); + glClearColor(0,0,0,0); + glStencilMask(~0); + glClear(GL_COLOR_BUFFER_BIT | GL_STENCIL_BUFFER_BIT); + + Use an orthographic path-to-clip-space transform to map the + [0..500]x[0..400] range of the star's path coordinates to the [-1..1] + clip space cube: + + glMatrixLoadIdentityEXT(GL_PROJECTION); + glMatrixLoadIdentityEXT(GL_MODELVIEW); + glMatrixOrthoEXT(GL_MODELVIEW, 0, 500, 0, 400, -1, 1); + + Stencil the path: + + glStencilFillPathNV(pathObj, GL_COUNT_UP_NV, 0x1F); + + The 0x1F mask means the counting uses modulo-32 arithmetic. In + principle the star's path is simple enough (having a maximum winding + number of 2) that modulo-4 arithmetic would be sufficient so the mask + could be 0x3. Or a mask of all 1's (~0) could be used to count with + all available stencil bits. + + Now that the coverage of the star and the heart have been rasterized + into the stencil buffer, cover the path with a non-zero fill style + (indicated by the GL_NOTEQUAL stencil function with a zero reference + value): + + glEnable(GL_STENCIL_TEST); + glStencilFunc(GL_NOTEQUAL, 0, 0x1F); + glStencilOp(GL_KEEP, GL_KEEP, GL_ZERO); + glColor3f(1,1,0); // yellow + glCoverFillPathNV(pathObj, GL_BOUNDING_BOX_NV); + + The result is a yellow star (with a filled center) to the left of + a yellow heart. + + The GL_ZERO stencil operation ensures that any covered samples + (meaning those with non-zero stencil values) are zero'ed when + the path cover is rasterized. This allows subsequent paths to be + rendered without clearing the stencil buffer again. + + A similar two-step rendering process can draw a white outline + over the star and heart. + + Before rendering, configure the path object with desirable path + parameters for stroking. Specify a wider 6.5-unit stroke and + the round join style: + + glPathParameteriNV(pathObj, GL_PATH_JOIN_STYLE_NV, GL_ROUND_NV); + glPathParameterfNV(pathObj, GL_PATH_STROKE_WIDTH_NV, 6.5); + + Now stencil the path's stroked coverage into the stencil buffer, + setting the stencil to 0x1 for all stencil samples within the + transformed path. + + glStencilStrokePathNV(pathObj, 0x1, ~0); + + Cover the path's stroked coverage (with a hull this time instead + of a bounding box; the choice doesn't really matter here) while + stencil testing that writes white to the color buffer and again + zero the stencil buffer. + + glColor3f(1,1,1); // white + glCoverStrokePathNV(pathObj, GL_CONVEX_HULL_NV); + + In this example, constant color shading is used but the application + can specify their own arbitrary shading and/or blending operations, + whether with Cg compiled to fragment program assembly, GLSL, or + fixed-function fragment processing. + + More complex path rendering is possible such as clipping one path to + another arbitrary path. This is because stencil testing (as well + as depth testing, depth bound test, clip planes, and scissoring) + can restrict path stenciling. + + Now let's render the word "OpenGL" atop the star and heart. + + First create a sequence of path objects for the glyphs for the + characters in "OpenGL": + + GLuint glyphBase = glGenPathsNV(6); + const unsigned char *word = "OpenGL"; + const GLsizei wordLen = (GLsizei)strlen(word); + const GLfloat emScale = 2048; // match TrueType convention + GLuint templatePathObject = ~0; // Non-existent path object + glPathGlyphsNV(glyphBase, + GL_SYSTEM_FONT_NAME_NV, "Helvetica", GL_BOLD_BIT_NV, + wordLen, GL_UNSIGNED_BYTE, word, + GL_SKIP_MISSING_GLYPH_NV, ~0, emScale); + glPathGlyphsNV(glyphBase, + GL_SYSTEM_FONT_NAME_NV, "Arial", GL_BOLD_BIT_NV, + wordLen, GL_UNSIGNED_BYTE, word, + GL_SKIP_MISSING_GLYPH_NV, ~0, emScale); + glPathGlyphsNV(glyphBase, + GL_STANDARD_FONT_NAME_NV, "Sans", GL_BOLD_BIT_NV, + wordLen, GL_UNSIGNED_BYTE, word, + GL_USE_MISSING_GLYPH_NV, ~0, emScale); + + Glyphs are loaded for three different fonts in priority order: + Helvetica first, then Arial, and if neither of those loads, use the + standard sans-serif font. If a prior glPathGlyphsNV is successful + and specifies the path object range, the subsequent glPathGlyphsNV + commands silently avoid re-specifying the already existent path + objects. + + Now query the (kerned) separations for the word "OpenGL" and build + a set of horizontal translations advancing each successive glyph by + its kerning distance with the following glyph. + + GLfloat xtranslate[6+1]; // wordLen+1 + glGetPathSpacingNV(GL_ACCUM_ADJACENT_PAIRS_NV, + wordLen+1, GL_UNSIGNED_BYTE, + "\000\001\002\003\004\005\005", // repeat last letter twice + glyphBase, + 1.0f, 1.0f, + GL_TRANSLATE_X_NV, + xtranslate); + + Next determine the font-wide vertical minimum and maximum for the + font face by querying the per-font metrics of any one of the glyphs + from the font face. + + GLfloat yMinMax[2]; + glGetPathMetricRangeNV(GL_FONT_Y_MIN_BOUNDS_BIT_NV|GL_FONT_Y_MAX_BOUNDS_BIT_NV, + glyphBase, /*count*/1, + 2*sizeof(GLfloat), + yMinMax); + + Use an orthographic path-to-clip-space transform to map the + word's bounds to the [-1..1] clip space cube: + + glMatrixLoadIdentityEXT(GL_PROJECTION); + glMatrixOrthoEXT(GL_MODELVIEW, + 0, xtranslate[6], yMinMax[0], yMinMax[1], + -1, 1); + + Stencil the filled paths of the sequence of glyphs for "OpenGL", + each transformed by the appropriate 2D translations for spacing. + + glStencilFillPathInstancedNV(6, GL_UNSIGNED_BYTE, + "\000\001\002\003\004\005", + glyphBase, + GL_PATH_FILL_MODE_NV, 0xFF, + GL_TRANSLATE_X_NV, xtranslate); + + Cover the bounding box union of the glyphs with 50% gray. + + glEnable(GL_STENCIL_TEST); + glStencilFunc(GL_NOTEQUAL, 0, 0xFF); + glStencilOp(GL_KEEP, GL_KEEP, GL_ZERO); + glColor3f(0.5,0.5,0.5); // 50% gray + glCoverFillPathInstancedNV(6, GL_UNSIGNED_BYTE, + "\000\001\002\003\004\005", + glyphBase, + GL_BOUNDING_BOX_OF_BOUNDING_BOXES_NV, + GL_TRANSLATE_X_NV, xtranslate); + + Voila, the word "OpenGL" in gray is now stenciled into the framebuffer. + + Instead of solid 50% gray, the cover operation can apply a linear + gradient that changes from green (RGB=0,1,0) at the top of the word + "OpenGL" to blue (RGB=0,0,1) at the bottom of "OpenGL": + + GLfloat rgbGen[3][3] = { + 0, 0, 0, // red = constant zero + 0, 1, 0, // green = varies with y from bottom (0) to top (1) + 0, -1, 1 // blue = varies with y from bottom (1) to top (0) + }; + glPathColorGenNV(GL_PRIMARY_COLOR, GL_PATH_OBJECT_BOUNDING_BOX_NV, + GL_RGB, &rgbGen[0][0]); + + Instead of loading just the glyphs for the characters in "OpenGL", + the entire character set could be loaded. This allows the characters + of the string to be mapped (offset by the glyphBase) to path object names. + A range of glyphs can be loaded like this: + + const int numChars = 256; // ISO/IEC 8859-1 8-bit character range + GLuint glyphBase = glGenPathsNV(numChars); + glPathGlyphRangeNV(glyphBase, + GL_SYSTEM_FONT_NAME_NV, "Helvetica", GL_BOLD_BIT_NV, + 0, numChars, + GL_SKIP_MISSING_GLYPH_NV, ~0, emScale); + glPathGlyphRangeNV(glyphBase, + GL_SYSTEM_FONT_NAME_NV, "Arial", GL_BOLD_BIT_NV, + 0, numChars, + GL_SKIP_MISSING_GLYPH_NV, ~0, emScale); + glPathGlyphRangeNV(glyphBase, + GL_STANDARD_FONT_NAME_NV, "Sans", GL_BOLD_BIT_NV, + 0, numChars, + GL_USE_MISSING_GLYPH_NV, ~0, emScale); + + Given a range of glyphs loaded as path objects, (kerned) spacing + information can now be queried for the string: + + glGetPathSpacingNV(GL_ACCUM_ADJACENT_PAIRS_NV, + 7, GL_UNSIGNED_BYTE, "OpenGLL", // repeat L to get final spacing + glyphBase, + 1.0f, 1.0f, + GL_TRANSLATE_X_NV, + kerning); + + Using the range of glyphs, stenciling and covering the instanced + paths for "OpenGL" can be done this way: + + glStencilFillPathInstancedNV(6, GL_UNSIGNED_BYTE, "OpenGL", + glyphBase, + GL_PATH_FILL_MODE_NV, 0xFF, + GL_TRANSLATE_X_NV, xtranslate); + + glCoverFillPathInstancedNV(6, GL_UNSIGNED_BYTE, "OpenGL", + glyphBase, + GL_BOUNDING_BOX_OF_BOUNDING_BOXES_NV, + GL_TRANSLATE_X_NV, xtranslate); + + The "stencil" and "cover" steps can be combined in a single command: + + glStencilThenCoverFillPathInstancedNV(6, GL_UNSIGNED_BYTE, "OpenGL", + glyphBase, + GL_PATH_FILL_MODE_NV, 0xFF, + GL_BOUNDING_BOX_OF_BOUNDING_BOXES_NV + GL_TRANSLATE_X_NV, xtranslate); + + XXX add path clipping example to demonstrate glPathStencilFuncNV. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/path_rendering.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.NV.path_rendering import * +from OpenGL.raw.GLES2.NV.path_rendering import _EXTENSION_NAME + +def glInitPathRenderingNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glPathCommandsNV.commands size not checked against numCommands +# INPUT glPathCommandsNV.coords size not checked against 'numCoords,coordType' +glPathCommandsNV=wrapper.wrapper(glPathCommandsNV).setInputArraySize( + 'commands', None +).setInputArraySize( + 'coords', None +) +# INPUT glPathCoordsNV.coords size not checked against 'numCoords,coordType' +glPathCoordsNV=wrapper.wrapper(glPathCoordsNV).setInputArraySize( + 'coords', None +) +# INPUT glPathSubCommandsNV.commands size not checked against numCommands +# INPUT glPathSubCommandsNV.coords size not checked against 'numCoords,coordType' +glPathSubCommandsNV=wrapper.wrapper(glPathSubCommandsNV).setInputArraySize( + 'commands', None +).setInputArraySize( + 'coords', None +) +# INPUT glPathSubCoordsNV.coords size not checked against 'numCoords,coordType' +glPathSubCoordsNV=wrapper.wrapper(glPathSubCoordsNV).setInputArraySize( + 'coords', None +) +# INPUT glPathStringNV.pathString size not checked against length +glPathStringNV=wrapper.wrapper(glPathStringNV).setInputArraySize( + 'pathString', None +) +# INPUT glPathGlyphsNV.charcodes size not checked against 'numGlyphs,type,charcodes' +# INPUT glPathGlyphsNV.fontName size not checked against 'fontTarget,fontName' +glPathGlyphsNV=wrapper.wrapper(glPathGlyphsNV).setInputArraySize( + 'charcodes', None +).setInputArraySize( + 'fontName', None +) +# INPUT glPathGlyphRangeNV.fontName size not checked against 'fontTarget,fontName' +glPathGlyphRangeNV=wrapper.wrapper(glPathGlyphRangeNV).setInputArraySize( + 'fontName', None +) +# INPUT glWeightPathsNV.paths size not checked against numPaths +# INPUT glWeightPathsNV.weights size not checked against numPaths +glWeightPathsNV=wrapper.wrapper(glWeightPathsNV).setInputArraySize( + 'paths', None +).setInputArraySize( + 'weights', None +) +# INPUT glTransformPathNV.transformValues size not checked against 'transformType' +glTransformPathNV=wrapper.wrapper(glTransformPathNV).setInputArraySize( + 'transformValues', None +) +# INPUT glPathParameterivNV.value size not checked against 'pname' +glPathParameterivNV=wrapper.wrapper(glPathParameterivNV).setInputArraySize( + 'value', None +) +# INPUT glPathParameterfvNV.value size not checked against 'pname' +glPathParameterfvNV=wrapper.wrapper(glPathParameterfvNV).setInputArraySize( + 'value', None +) +# INPUT glPathDashArrayNV.dashArray size not checked against dashCount +glPathDashArrayNV=wrapper.wrapper(glPathDashArrayNV).setInputArraySize( + 'dashArray', None +) +# INPUT glStencilFillPathInstancedNV.paths size not checked against 'numPaths,pathNameType,paths' +# INPUT glStencilFillPathInstancedNV.transformValues size not checked against 'numPaths,transformType' +glStencilFillPathInstancedNV=wrapper.wrapper(glStencilFillPathInstancedNV).setInputArraySize( + 'paths', None +).setInputArraySize( + 'transformValues', None +) +# INPUT glStencilStrokePathInstancedNV.paths size not checked against 'numPaths,pathNameType,paths' +# INPUT glStencilStrokePathInstancedNV.transformValues size not checked against 'numPaths,transformType' +glStencilStrokePathInstancedNV=wrapper.wrapper(glStencilStrokePathInstancedNV).setInputArraySize( + 'paths', None +).setInputArraySize( + 'transformValues', None +) +# INPUT glCoverFillPathInstancedNV.paths size not checked against 'numPaths,pathNameType,paths' +# INPUT glCoverFillPathInstancedNV.transformValues size not checked against 'numPaths,transformType' +glCoverFillPathInstancedNV=wrapper.wrapper(glCoverFillPathInstancedNV).setInputArraySize( + 'paths', None +).setInputArraySize( + 'transformValues', None +) +# INPUT glCoverStrokePathInstancedNV.paths size not checked against 'numPaths,pathNameType,paths' +# INPUT glCoverStrokePathInstancedNV.transformValues size not checked against 'numPaths,transformType' +glCoverStrokePathInstancedNV=wrapper.wrapper(glCoverStrokePathInstancedNV).setInputArraySize( + 'paths', None +).setInputArraySize( + 'transformValues', None +) +glGetPathParameterivNV=wrapper.wrapper(glGetPathParameterivNV).setOutput( + 'value',size=(4,),orPassIn=True +) +glGetPathParameterfvNV=wrapper.wrapper(glGetPathParameterfvNV).setOutput( + 'value',size=(4,),orPassIn=True +) +glGetPathCommandsNV=wrapper.wrapper(glGetPathCommandsNV).setOutput( + 'commands',size=_glgets._glget_size_mapping,pnameArg='path',orPassIn=True +) +glGetPathCoordsNV=wrapper.wrapper(glGetPathCoordsNV).setOutput( + 'coords',size=_glgets._glget_size_mapping,pnameArg='path',orPassIn=True +) +glGetPathDashArrayNV=wrapper.wrapper(glGetPathDashArrayNV).setOutput( + 'dashArray',size=_glgets._glget_size_mapping,pnameArg='path',orPassIn=True +) +# OUTPUT glGetPathMetricsNV.metrics COMPSIZE(metricQueryMask, numPaths, stride) +# INPUT glGetPathMetricsNV.paths size not checked against 'numPaths,pathNameType,paths' +glGetPathMetricsNV=wrapper.wrapper(glGetPathMetricsNV).setInputArraySize( + 'paths', None +) +# OUTPUT glGetPathMetricRangeNV.metrics COMPSIZE(metricQueryMask, numPaths, stride) +# INPUT glGetPathSpacingNV.paths size not checked against 'numPaths,pathNameType,paths' +# OUTPUT glGetPathSpacingNV.returnedSpacing COMPSIZE(pathListMode, numPaths) +glGetPathSpacingNV=wrapper.wrapper(glGetPathSpacingNV).setInputArraySize( + 'paths', None +) +glPointAlongPathNV=wrapper.wrapper(glPointAlongPathNV).setOutput( + 'tangentX',size=(1,),orPassIn=True +).setOutput( + 'tangentY',size=(1,),orPassIn=True +).setOutput( + 'x',size=(1,),orPassIn=True +).setOutput( + 'y',size=(1,),orPassIn=True +) +# INPUT glPathColorGenNV.coeffs size not checked against 'genMode,colorFormat' +glPathColorGenNV=wrapper.wrapper(glPathColorGenNV).setInputArraySize( + 'coeffs', None +) +# INPUT glPathTexGenNV.coeffs size not checked against 'genMode,components' +glPathTexGenNV=wrapper.wrapper(glPathTexGenNV).setInputArraySize( + 'coeffs', None +) +glGetPathColorGenivNV=wrapper.wrapper(glGetPathColorGenivNV).setOutput( + 'value',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetPathColorGenfvNV=wrapper.wrapper(glGetPathColorGenfvNV).setOutput( + 'value',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetPathTexGenivNV=wrapper.wrapper(glGetPathTexGenivNV).setOutput( + 'value',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetPathTexGenfvNV=wrapper.wrapper(glGetPathTexGenfvNV).setOutput( + 'value',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glMatrixLoadTransposefEXT=wrapper.wrapper(glMatrixLoadTransposefEXT).setInputArraySize( + 'm', 16 +) +glMatrixLoadTransposedEXT=wrapper.wrapper(glMatrixLoadTransposedEXT).setInputArraySize( + 'm', 16 +) +glMatrixLoadfEXT=wrapper.wrapper(glMatrixLoadfEXT).setInputArraySize( + 'm', 16 +) +glMatrixLoaddEXT=wrapper.wrapper(glMatrixLoaddEXT).setInputArraySize( + 'm', 16 +) +glMatrixMultTransposefEXT=wrapper.wrapper(glMatrixMultTransposefEXT).setInputArraySize( + 'm', 16 +) +glMatrixMultTransposedEXT=wrapper.wrapper(glMatrixMultTransposedEXT).setInputArraySize( + 'm', 16 +) +glMatrixMultfEXT=wrapper.wrapper(glMatrixMultfEXT).setInputArraySize( + 'm', 16 +) +glMatrixMultdEXT=wrapper.wrapper(glMatrixMultdEXT).setInputArraySize( + 'm', 16 +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/path_rendering_shared_edge.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/path_rendering_shared_edge.py new file mode 100644 index 00000000..3d7f6397 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/path_rendering_shared_edge.py @@ -0,0 +1,36 @@ +'''OpenGL extension NV.path_rendering_shared_edge + +This module customises the behaviour of the +OpenGL.raw.GLES2.NV.path_rendering_shared_edge to provide a more +Python-friendly API + +Overview (from the spec) + + This extension introduces a new path command modifier to the + NV_path_rendering extension to indicate that a path command represents an + edge (either straight or curved) that is shared with another path. + + When used in conjunction with NV_framebuffer_mixed_samples, a shared edge + (or a whole path including shared edges) will use modified rasterization + rules in order to ensure that groups of raster samples associated with a + given coverage sample will all produce consistent coverage results, in + order to avoid artifacts described further in the issues section at the + end of this document. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/path_rendering_shared_edge.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.NV.path_rendering_shared_edge import * +from OpenGL.raw.GLES2.NV.path_rendering_shared_edge import _EXTENSION_NAME + +def glInitPathRenderingSharedEdgeNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/pixel_buffer_object.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/pixel_buffer_object.py new file mode 100644 index 00000000..5e3b4c50 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/pixel_buffer_object.py @@ -0,0 +1,71 @@ +'''OpenGL extension NV.pixel_buffer_object + +This module customises the behaviour of the +OpenGL.raw.GLES2.NV.pixel_buffer_object to provide a more +Python-friendly API + +Overview (from the spec) + + This extension permits buffer objects to be used not only with vertex + array data, but also with pixel data. The intent is to provide more + acceleration opportunities for OpenGL pixel commands. + + While a single buffer object can be bound for both vertex arrays and + pixel commands, we use the designations vertex buffer object (VBO) + and pixel buffer object (PBO) to indicate their particular usage in + a given situation. + + This extension does not add any new functionality to buffer objects + themselves. It simply adds two new targets to which buffer objects + can be bound: GL_PIXEL_PACK_BUFFER_NV and GL_PIXEL_UNPACK_BUFFER_NV. + When a buffer object is bound to the GL_PIXEL_PACK_BUFFER_NV target, + commands such as glReadPixels pack (write) their data into a buffer + object. When a buffer object is bound to the GL_PIXEL_UNPACK_BUFFER_NV + target, commands such as glTexImage2D unpack (read) their + data from a buffer object. + + There are a several approaches to improve graphics performance + with PBOs. Some of the most interesting approaches are: + + - Streaming texture updates: If the application uses + glMapBufferOES/glMapBufferRangeEXT/glUnmapBufferOES to write + its data for glTexSubImage into a buffer object, at least one of + the data copies usually required to download a texture can be + eliminated, significantly increasing texture download performance. + + - Asynchronous glReadPixels: If an application needs to read back a + number of images and process them with the CPU, the existing GL + interface makes it nearly impossible to pipeline this operation. + The driver will typically send the hardware a readback command + when glReadPixels is called, and then wait for all of the data to + be available before returning control to the application. Then, + the application can either process the data immediately or call + glReadPixels again; in neither case will the readback overlap with + the processing. If the application issues several readbacks + into several buffer objects, however, and then maps each one to + process its data, then the readbacks can proceed in parallel with + the data processing. + + - Render to vertex array: The application can use a fragment + program to render some image into one of its buffers, then read + this image out into a buffer object via glReadPixels. Then, it can + use this buffer object as a source of vertex data. + + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/pixel_buffer_object.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.NV.pixel_buffer_object import * +from OpenGL.raw.GLES2.NV.pixel_buffer_object import _EXTENSION_NAME + +def glInitPixelBufferObjectNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/polygon_mode.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/polygon_mode.py new file mode 100644 index 00000000..2bae9a8c --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/polygon_mode.py @@ -0,0 +1,35 @@ +'''OpenGL extension NV.polygon_mode + +This module customises the behaviour of the +OpenGL.raw.GLES2.NV.polygon_mode to provide a more +Python-friendly API + +Overview (from the spec) + + This extension adds a PolygonModeNV entry point which can be used to change + the polygon rasterization method. Using this extension, state consistent + with rendering triangle primitives can trivially be toggled to render + primitives as lines or points. In addition, independent enables are + provided for polygon offset in conjunction with these new point and line + polygon modes. + + This introduces a level of support for PolygonMode comparable with the + OpenGL 4.3 core profile. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/polygon_mode.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.NV.polygon_mode import * +from OpenGL.raw.GLES2.NV.polygon_mode import _EXTENSION_NAME + +def glInitPolygonModeNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/read_buffer.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/read_buffer.py new file mode 100644 index 00000000..896d927f --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/read_buffer.py @@ -0,0 +1,50 @@ +'''OpenGL extension NV.read_buffer + +This module customises the behaviour of the +OpenGL.raw.GLES2.NV.read_buffer to provide a more +Python-friendly API + +Overview (from the spec) + + Unextended OpenGL ES 2.0 only supports using ReadPixels to read from + the default color buffer of the currently-bound framebuffer. + However, it is useful for debugging to be able to read from + non-default color buffers. Particularly, when the NV_draw_buffers + extension is supported, each framebuffer may contain multiple color + buffers. This extension provides a mechanism to select which color + buffer to read from. + + This document describes two extensions to allow an implementation to + support a subset of the total functionality. + + The NV_read_buffer extension adds the command ReadBufferNV, which is + used to select which color buffer of the currently-bound framebuffer + to use as the source for subsequent calls to ReadPixels, + CopyTexImage2D, and CopyTexSubImage2D. If the system-provided + framebuffer is bound, then ReadBufferNV accepts value BACK. If a + user-created FBO is bound, then ReadBufferNV accepts COLOR_ATTACHMENT0. + Additionally, if the NV_draw_buffers extension is supported, + ReadBufferNV accepts COLOR_ATTACHMENTn_NV (n is 0 to 15). + + The NV_read_buffer_front extension requires NV_read_buffer and adds + the ability to select the system-provided FRONT color buffer as the + source for read operations when the system-provided framebuffer is + bound and contains both a front and back buffer. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/read_buffer.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.NV.read_buffer import * +from OpenGL.raw.GLES2.NV.read_buffer import _EXTENSION_NAME + +def glInitReadBufferNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/read_buffer_front.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/read_buffer_front.py new file mode 100644 index 00000000..c08b65c8 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/read_buffer_front.py @@ -0,0 +1,23 @@ +'''OpenGL extension NV.read_buffer_front + +This module customises the behaviour of the +OpenGL.raw.GLES2.NV.read_buffer_front to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/read_buffer_front.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.NV.read_buffer_front import * +from OpenGL.raw.GLES2.NV.read_buffer_front import _EXTENSION_NAME + +def glInitReadBufferFrontNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/read_depth.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/read_depth.py new file mode 100644 index 00000000..50581bb9 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/read_depth.py @@ -0,0 +1,23 @@ +'''OpenGL extension NV.read_depth + +This module customises the behaviour of the +OpenGL.raw.GLES2.NV.read_depth to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/read_depth.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.NV.read_depth import * +from OpenGL.raw.GLES2.NV.read_depth import _EXTENSION_NAME + +def glInitReadDepthNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/read_depth_stencil.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/read_depth_stencil.py new file mode 100644 index 00000000..23349ca4 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/read_depth_stencil.py @@ -0,0 +1,43 @@ +'''OpenGL extension NV.read_depth_stencil + +This module customises the behaviour of the +OpenGL.raw.GLES2.NV.read_depth_stencil to provide a more +Python-friendly API + +Overview (from the spec) + + Unextended OpenGL-ES 2.0 only supports using ReadPixels to read from the + default color buffer of the currently-bound framebuffer. However, it is + useful for debugging to be able to read from depth and stencil buffers. + This extension re-introduces these features into OpenGL-ES 2.0. + + This document describes several extensions in order to allow an + implementation to support a subset of the total functionality. + + The NV_read_depth extension allows reading from the depth buffer using + ReadPixels. + + The NV_read_stencil extension allows reading from the stencil buffer using + ReadPixels. + + The NV_read_depth_stencil extension allows reading from packed + depth-stencil buffers using ReadPixels. + + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/read_depth_stencil.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.NV.read_depth_stencil import * +from OpenGL.raw.GLES2.NV.read_depth_stencil import _EXTENSION_NAME + +def glInitReadDepthStencilNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/read_stencil.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/read_stencil.py new file mode 100644 index 00000000..b2af467f --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/read_stencil.py @@ -0,0 +1,23 @@ +'''OpenGL extension NV.read_stencil + +This module customises the behaviour of the +OpenGL.raw.GLES2.NV.read_stencil to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/read_stencil.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.NV.read_stencil import * +from OpenGL.raw.GLES2.NV.read_stencil import _EXTENSION_NAME + +def glInitReadStencilNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/representative_fragment_test.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/representative_fragment_test.py new file mode 100644 index 00000000..bf8210f4 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/representative_fragment_test.py @@ -0,0 +1,52 @@ +'''OpenGL extension NV.representative_fragment_test + +This module customises the behaviour of the +OpenGL.raw.GLES2.NV.representative_fragment_test to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides a new _representative fragment test_ that allows + implementations to reduce the amount of rasterization and fragment + processing work performed for each point, line, or triangle primitive. For + any primitive that produces one or more fragments that pass all other + early fragment tests, the implementation is permitted to choose one or + more "representative" fragments for processing and discard all other + fragments. For draw calls rendering multiple points, lines, or triangles + arranged in lists, strips, or fans, the representative fragment test is + performed independently for each of those primitives. + + This extension is useful for applications that use an early render pass + to determine the full set of primitives that would be visible in the final + scene. In this render pass, such applications would set up a fragment + shader that enables early fragment tests and writes to an image or shader + storage buffer to record the ID of the primitive that generated the + fragment. Without this extension, the shader would record the ID + separately for each visible fragment of each primitive. With this + extension, fewer stores will be performed, particularly for large + primitives. + + The representative fragment test has no effect if early fragment tests are + not enabled via the fragment shader. The set of fragments discarded by the + representative fragment test is implementation-dependent and may vary from + frame to frame. In some cases, the representative fragment test may not + discard any fragments for a given primitive. + + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/representative_fragment_test.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.NV.representative_fragment_test import * +from OpenGL.raw.GLES2.NV.representative_fragment_test import _EXTENSION_NAME + +def glInitRepresentativeFragmentTestNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/sRGB_formats.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/sRGB_formats.py new file mode 100644 index 00000000..fbd19602 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/sRGB_formats.py @@ -0,0 +1,40 @@ +'''OpenGL extension NV.sRGB_formats + +This module customises the behaviour of the +OpenGL.raw.GLES2.NV.sRGB_formats to provide a more +Python-friendly API + +Overview (from the spec) + + This extension adds new uncompressed and compressed color texture + formats with nonlinear sRGB color components. + + Luminance and luminance alpha provide support for textures + containing sRGB values with identical red, green, and blue + components. + + Compressed texture formats using S3TC and ETC1 compression + algorithms are also added to provide compressed sRGB texture + options. + + Finally, sized variant of sRGB, sLuminace, and sLuminance_alpha are + provided for immutable textures defined using the EXT_texture_storage + extension. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/sRGB_formats.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.NV.sRGB_formats import * +from OpenGL.raw.GLES2.NV.sRGB_formats import _EXTENSION_NAME + +def glInitSrgbFormatsNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/sample_locations.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/sample_locations.py new file mode 100644 index 00000000..70d6c592 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/sample_locations.py @@ -0,0 +1,56 @@ +'''OpenGL extension NV.sample_locations + +This module customises the behaviour of the +OpenGL.raw.GLES2.NV.sample_locations to provide a more +Python-friendly API + +Overview (from the spec) + + This extension allows an application to modify the locations of samples + within a pixel used in multisample rasterization. Additionally, it allows + applications to specify different sample locations for each pixel in a + group of adjacent pixels, which may increase antialiasing quality + (particularly if a custom resolve shader is used that takes advantage of + these different locations). + + It is common for implementations to optimize the storage of depth values + by storing values that can be used to reconstruct depth at each sample + location, rather than storing separate depth values for each sample. For + example, the depth values from a single triangle can be represented using + plane equations. When the depth value for a sample is needed, it is + automatically evaluated at the sample location. Modifying the sample + locations causes the reconstruction to no longer evaluate the same depth + values as when the samples were originally generated. This extension + provides a command to "resolve" and store per-sample depth values using + the currently programmed sample locations, which allows the application to + manage this issue if/when necessary. + + The programmable sample locations are used during rasterization and for + evaluation of depth functions during normal geometric rendering. The + programmable locations are associated with a framebuffer object rather + than an individual depth buffer, so if the depth buffer is used as a + texture the texture sampling may be done at the standard sample + locations. Additionally, commands that do not render geometric primitives + (e.g. ReadPixels, BlitFramebuffer, CopyTexSubImage2D, etc.) may use the + standard sample locations to resolve depth functions rather than the + programmable locations. If a single depth buffer is used at different + times with different sample locations, the depth functions may be + interpreted using the current sample locations. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/sample_locations.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.NV.sample_locations import * +from OpenGL.raw.GLES2.NV.sample_locations import _EXTENSION_NAME + +def glInitSampleLocationsNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/sample_mask_override_coverage.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/sample_mask_override_coverage.py new file mode 100644 index 00000000..2ff50298 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/sample_mask_override_coverage.py @@ -0,0 +1,33 @@ +'''OpenGL extension NV.sample_mask_override_coverage + +This module customises the behaviour of the +OpenGL.raw.GLES2.NV.sample_mask_override_coverage to provide a more +Python-friendly API + +Overview (from the spec) + + This extension allows the fragment shader to control whether the + gl_SampleMask output can enable samples that were not covered by the + original primitive, or that failed the early depth/stencil tests. + This can be enabled by redeclaring the gl_SampleMask output with the + "override_coverage" layout qualifier: + + layout(override_coverage) out int gl_SampleMask[]; + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/sample_mask_override_coverage.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.NV.sample_mask_override_coverage import * +from OpenGL.raw.GLES2.NV.sample_mask_override_coverage import _EXTENSION_NAME + +def glInitSampleMaskOverrideCoverageNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/scissor_exclusive.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/scissor_exclusive.py new file mode 100644 index 00000000..fb0315d4 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/scissor_exclusive.py @@ -0,0 +1,41 @@ +'''OpenGL extension NV.scissor_exclusive + +This module customises the behaviour of the +OpenGL.raw.GLES2.NV.scissor_exclusive to provide a more +Python-friendly API + +Overview (from the spec) + + In unextended OpenGL, applications can enable a per-viewport scissor test + (SCISSOR_TEST) where fragments are discarded if their (x,y) coordinates + lie outside the corresponding scissor rectangle. In this extension, we + provide a separate per-viewport exclusive scissor test, where fragments + are discarded if their (x,y) coordinates lie *inside* the corresponding + exclusive scissor rectangle. + + The regular (inclusive) scissor test and exclusive scissor test are + orthogonal; applications can enable either or both tests for each + viewport. If both tests are enabled, fragments will be discarded unless + their (x,y) coordinates are both inside the regular scissor rectangle and + outside the exclusive scissor rectangle. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/scissor_exclusive.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.NV.scissor_exclusive import * +from OpenGL.raw.GLES2.NV.scissor_exclusive import _EXTENSION_NAME + +def glInitScissorExclusiveNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glScissorExclusiveArrayvNV.v size not checked against 'count' +glScissorExclusiveArrayvNV=wrapper.wrapper(glScissorExclusiveArrayvNV).setInputArraySize( + 'v', None +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/shader_atomic_fp16_vector.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/shader_atomic_fp16_vector.py new file mode 100644 index 00000000..2c4209b2 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/shader_atomic_fp16_vector.py @@ -0,0 +1,30 @@ +'''OpenGL extension NV.shader_atomic_fp16_vector + +This module customises the behaviour of the +OpenGL.raw.GLES2.NV.shader_atomic_fp16_vector to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides GLSL built-in functions and assembly opcodes + allowing shaders to perform a limited set of atomic read-modify-write + operations to buffer or texture memory with 16-bit floating point vector + surface formats. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/shader_atomic_fp16_vector.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.NV.shader_atomic_fp16_vector import * +from OpenGL.raw.GLES2.NV.shader_atomic_fp16_vector import _EXTENSION_NAME + +def glInitShaderAtomicFp16VectorNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/shader_noperspective_interpolation.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/shader_noperspective_interpolation.py new file mode 100644 index 00000000..fef9760d --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/shader_noperspective_interpolation.py @@ -0,0 +1,44 @@ +'''OpenGL extension NV.shader_noperspective_interpolation + +This module customises the behaviour of the +OpenGL.raw.GLES2.NV.shader_noperspective_interpolation to provide a more +Python-friendly API + +Overview (from the spec) + + In OpenGL 3.0 and later, and in other APIs, there are three types of + interpolation qualifiers that are available for fragment shader inputs: + flat, smooth, and noperspective. The 'flat' qualifier indicates that no + interpolation should be used. This is mandatory for integer-type + variables. The 'smooth' qualifier indicates that interpolation should be + performed in a perspective0correct manner. This is the default for + floating-point type variables. The 'noperspective' qualifier indicates + that interpolation should be performed linearly in screen space. + + While perspective-correct (smooth) and non-interpolated (flat) are the + two types of interpolation that most commonly used, there are important + use cases for linear (noperspective) interpolation. In particular, in + some work loads where screen-space aligned geometry is common, the use of + linear interpolation can result in performance and/or power improvements. + + The smooth and flat interpolation qualifiers are already supported in + OpenGL ES 3.0 and later. This extension adds support for noperspective + interpolation to OpenGL ES. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/shader_noperspective_interpolation.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.NV.shader_noperspective_interpolation import * +from OpenGL.raw.GLES2.NV.shader_noperspective_interpolation import _EXTENSION_NAME + +def glInitShaderNoperspectiveInterpolationNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/shader_subgroup_partitioned.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/shader_subgroup_partitioned.py new file mode 100644 index 00000000..deddfd00 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/shader_subgroup_partitioned.py @@ -0,0 +1,38 @@ +'''OpenGL extension NV.shader_subgroup_partitioned + +This module customises the behaviour of the +OpenGL.raw.GLES2.NV.shader_subgroup_partitioned to provide a more +Python-friendly API + +Overview (from the spec) + + This extension enables support for the NV_shader_subgroup_partitioned + shading language extension in OpenGL and OpenGL ES. + + This extension adds a new SUBGROUP_FEATURE_PARTITIONED_BIT_NV feature bit + that is returned by queryies for SUBGROUP_SUPPORTED_FEATURES_KHR. + + In OpenGL implementations supporting SPIR-V, this extension enables + support for the SPV_NV_shader_subgroup_partitioned extension. + + In OpenGL ES implementations, this extension does NOT add support for + SPIR-V or for any of the built-in shading language functions (8.18) + that have genDType (double) prototypes. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/shader_subgroup_partitioned.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.NV.shader_subgroup_partitioned import * +from OpenGL.raw.GLES2.NV.shader_subgroup_partitioned import _EXTENSION_NAME + +def glInitShaderSubgroupPartitionedNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/shader_texture_footprint.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/shader_texture_footprint.py new file mode 100644 index 00000000..ae1cac71 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/shader_texture_footprint.py @@ -0,0 +1,74 @@ +'''OpenGL extension NV.shader_texture_footprint + +This module customises the behaviour of the +OpenGL.raw.GLES2.NV.shader_texture_footprint to provide a more +Python-friendly API + +Overview (from the spec) + + This extension adds OpenGL API support for the OpenGL Shading Language + (GLSL) extension "NV_shader_texture_footprint". That extension adds a new + set of texture query functions ("textureFootprint*NV") to GLSL. These + built-in functions prepare to perform a filtered texture lookup based on + coordinates and other parameters passed in by the calling code. However, + instead of returning data from the provided texture image, these query + functions instead return data identifying the _texture footprint_ for an + equivalent texture access. The texture footprint identifies a set of + texels that may be accessed in order to return a filtered result for the + texture access. + + The footprint itself is a structure that includes integer values that + identify a small neighborhood of texels in the texture being accessed and + a bitfield that indicates which texels in that neighborhood would be used. + Each bit in the returned bitfield identifies whether any texel in a small + aligned block of texels would be fetched by the texture lookup. The size + of each block is specified by an access _granularity_ provided by the + shader. The minimum granularity supported by this extension is 2x2 (for + 2D textures) and 2x2x2 (for 3D textures); the maximum granularity is + 256x256 (for 2D textures) or 64x32x32 (for 3D textures). Each footprint + query returns the footprint from a single texture level. When using + minification filters that combine accesses from multiple mipmap levels, + shaders must perform separate queries for the two levels accessed ("fine" + and "coarse"). The footprint query also returns a flag indicating if the + texture lookup would access texels from only one mipmap level or from two + neighboring levels. + + This extension should be useful for multi-pass rendering operations that + do an initial expensive rendering pass to produce a first image that is + then used as a texture for a second pass. If the second pass ends up + accessing only portions of the first image (e.g., due to visibility), the + work spent rendering the non-accessed portion of the first image was + wasted. With this feature, an application can limit this waste using an + initial pass over the geometry in the second image that performs a + footprint query for each visible pixel to determine the set of pixels that + it needs from the first image. This pass would accumulate an aggregate + footprint of all visible pixels into a separate "footprint texture" using + shader atomics. Then, when rendering the first image, the application can + kill all shading work for pixels not in this aggregate footprint. + + The implementation of this extension has a number of limitations. The + texture footprint query functions are only supported for two- and + three-dimensional textures (TEXTURE_2D, TEXTURE_3D). Texture footprint + evaluation only supports the CLAMP_TO_EDGE wrap mode; results are + undefined for all other wrap modes. The implementation supports only a + limited set of granularity values and does not support separate coverage + information for each texel in the original texture. + + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/shader_texture_footprint.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.NV.shader_texture_footprint import * +from OpenGL.raw.GLES2.NV.shader_texture_footprint import _EXTENSION_NAME + +def glInitShaderTextureFootprintNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/shading_rate_image.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/shading_rate_image.py new file mode 100644 index 00000000..bb9e91bd --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/shading_rate_image.py @@ -0,0 +1,78 @@ +'''OpenGL extension NV.shading_rate_image + +This module customises the behaviour of the +OpenGL.raw.GLES2.NV.shading_rate_image to provide a more +Python-friendly API + +Overview (from the spec) + + By default, OpenGL runs a fragment shader once for each pixel covered by a + primitive being rasterized. When using multisampling, the outputs of that + fragment shader are broadcast to each covered sample of the fragment's + pixel. When using multisampling, applications can also request that the + fragment shader be run once per color sample (when using the "sample" + qualifier on one or more active fragment shader inputs), or run a fixed + number of times per pixel using SAMPLE_SHADING enable and the + MinSampleShading frequency value. In all of these approaches, the number + of fragment shader invocations per pixel is fixed, based on API state. + + This extension allows applications to bind and enable a shading rate image + that can be used to vary the number of fragment shader invocations across + the framebuffer. This can be useful for applications like eye tracking + for virtual reality, where the portion of the framebuffer that the user is + looking at directly can be processed at high frequency, while distant + corners of the image can be processed at lower frequency. The shading + rate image is an immutable-format two-dimensional or two-dimensional array + texture that uses a format of R8UI. Each texel represents a fixed-size + rectangle in the framebuffer, covering 16x16 pixels in the initial + implementation of this extension. When rasterizing a primitive covering + one of these rectangles, the OpenGL implementation reads the texel in the + bound shading rate image and looks up the fetched value in a palette of + shading rates. The shading rate used can vary from (finest) 16 fragment + shader invocations per pixel to (coarsest) one fragment shader invocation + for each 4x4 block of pixels. + + When this extension is advertised by an OpenGL implementation, the + implementation must also support the GLSL extension + "GL_NV_shading_rate_image" (documented separately), which provides new + built-in variables that allow fragment shaders to determine the effective + shading rate used for each fragment. Additionally, the GLSL extension also + provides new layout qualifiers allowing the interlock functionality provided + by ARB_fragment_shader_interlock to guarantee mutual exclusion across an + entire fragment when the shading rate specifies multiple pixels per fragment + shader invocation. + + Note that this extension requires the use of a framebuffer object; the + shading rate image and related state are ignored when rendering to the + default framebuffer. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/shading_rate_image.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.NV.shading_rate_image import * +from OpenGL.raw.GLES2.NV.shading_rate_image import _EXTENSION_NAME + +def glInitShadingRateImageNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +glGetShadingRateImagePaletteNV=wrapper.wrapper(glGetShadingRateImagePaletteNV).setInputArraySize( + 'rate', 1 +) +glGetShadingRateSampleLocationivNV=wrapper.wrapper(glGetShadingRateSampleLocationivNV).setInputArraySize( + 'location', 3 +) +# INPUT glShadingRateImagePaletteNV.rates size not checked against count +glShadingRateImagePaletteNV=wrapper.wrapper(glShadingRateImagePaletteNV).setInputArraySize( + 'rates', None +) +# INPUT glShadingRateSampleOrderCustomNV.locations size not checked against 'rate,samples' +glShadingRateSampleOrderCustomNV=wrapper.wrapper(glShadingRateSampleOrderCustomNV).setInputArraySize( + 'locations', None +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/shadow_samplers_array.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/shadow_samplers_array.py new file mode 100644 index 00000000..f355da56 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/shadow_samplers_array.py @@ -0,0 +1,29 @@ +'''OpenGL extension NV.shadow_samplers_array + +This module customises the behaviour of the +OpenGL.raw.GLES2.NV.shadow_samplers_array to provide a more +Python-friendly API + +Overview (from the spec) + + This extension expands the shadow map capability described in + EXT_shadow_samplers to include support for shadow samplers of 2D + array textures. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/shadow_samplers_array.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.NV.shadow_samplers_array import * +from OpenGL.raw.GLES2.NV.shadow_samplers_array import _EXTENSION_NAME + +def glInitShadowSamplersArrayNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/shadow_samplers_cube.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/shadow_samplers_cube.py new file mode 100644 index 00000000..d75233c2 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/shadow_samplers_cube.py @@ -0,0 +1,29 @@ +'''OpenGL extension NV.shadow_samplers_cube + +This module customises the behaviour of the +OpenGL.raw.GLES2.NV.shadow_samplers_cube to provide a more +Python-friendly API + +Overview (from the spec) + + This extension expands the shadow map capability described in + EXT_shadow_samplers to include support for shadow samplers of cube + map textures. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/shadow_samplers_cube.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.NV.shadow_samplers_cube import * +from OpenGL.raw.GLES2.NV.shadow_samplers_cube import _EXTENSION_NAME + +def glInitShadowSamplersCubeNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/stereo_view_rendering.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/stereo_view_rendering.py new file mode 100644 index 00000000..6f200484 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/stereo_view_rendering.py @@ -0,0 +1,47 @@ +'''OpenGL extension NV.stereo_view_rendering + +This module customises the behaviour of the +OpenGL.raw.GLES2.NV.stereo_view_rendering to provide a more +Python-friendly API + +Overview (from the spec) + + Virtual reality (VR) applications often render a single logical scene + from multiple views corresponding to a pair of eyes. The views (eyes) are + separated by a fixed offset in the X direction. + + Traditionally, multiple views are rendered via multiple rendering passes. + This is expensive for the GPU because the objects in the scene must be + transformed, rasterized, shaded, and fragment processed redundantly. This + is expensive for the CPU because the scene graph needs to be visited + multiple times and driver validation happens for each view. Rendering N + passes tends to take N times longer than a single pass. + + This extension provides a mechanism to render binocular (stereo) views + from a single stream of OpenGL rendering commands. Vertex, tessellation, + and geometry (VTG) shaders can output two positions for each vertex + corresponding to the two eye views. A built-in "gl_SecondaryPositionNV" + is added to specify the second position. The positions from each view may + be sent to different viewports and/or layers. A built-in + "gl_SecondaryViewportMaskNV[]" is also added to specify the viewport mask + for the second view. A new layout-qualifier "secondary_view_offset" is + added for built-in output "gl_Layer" which allows for the geometry from + each view to be sent to different layers for rendering. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/stereo_view_rendering.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.NV.stereo_view_rendering import * +from OpenGL.raw.GLES2.NV.stereo_view_rendering import _EXTENSION_NAME + +def glInitStereoViewRenderingNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/texture_border_clamp.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/texture_border_clamp.py new file mode 100644 index 00000000..bc08fbf1 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/texture_border_clamp.py @@ -0,0 +1,38 @@ +'''OpenGL extension NV.texture_border_clamp + +This module customises the behaviour of the +OpenGL.raw.GLES2.NV.texture_border_clamp to provide a more +Python-friendly API + +Overview (from the spec) + + OpenGL ES provides only a single clamping wrap mode: CLAMP_TO_EDGE. + However, the ability to clamp to a constant border color can be + useful to quickly detect texture coordinates that exceed their + expected limits or to dummy out any such accesses with transparency + or a neutral color in tiling or light maps. + + This extension defines an additional texture clamping algorithm. + CLAMP_TO_BORDER_NV clamps texture coordinates at all mipmap levels + such that NEAREST and LINEAR filters of clamped coordinates return + only the constant border color. This does not add the ability for + textures to specify borders using glTexImage2D, but only to clamp + to a constant border value set using glTexParameter. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/texture_border_clamp.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.NV.texture_border_clamp import * +from OpenGL.raw.GLES2.NV.texture_border_clamp import _EXTENSION_NAME + +def glInitTextureBorderClampNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/texture_compression_s3tc_update.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/texture_compression_s3tc_update.py new file mode 100644 index 00000000..1e71f33a --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/texture_compression_s3tc_update.py @@ -0,0 +1,32 @@ +'''OpenGL extension NV.texture_compression_s3tc_update + +This module customises the behaviour of the +OpenGL.raw.GLES2.NV.texture_compression_s3tc_update to provide a more +Python-friendly API + +Overview (from the spec) + + This extension allows for full or partial image updates to a + compressed 2D texture from an uncompressed texel data buffer using + TexImage2D and TexSubImage2D. Consquently, if a compressed internal + format is used, all the restrictions associated with compressed + textures will apply. These include sub-image updates aligned to 4x4 + pixel blocks and the restriction on usage as render targets. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/texture_compression_s3tc_update.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.NV.texture_compression_s3tc_update import * +from OpenGL.raw.GLES2.NV.texture_compression_s3tc_update import _EXTENSION_NAME + +def glInitTextureCompressionS3TcUpdateNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/texture_npot_2D_mipmap.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/texture_npot_2D_mipmap.py new file mode 100644 index 00000000..ba820a0f --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/texture_npot_2D_mipmap.py @@ -0,0 +1,41 @@ +'''OpenGL extension NV.texture_npot_2D_mipmap + +This module customises the behaviour of the +OpenGL.raw.GLES2.NV.texture_npot_2D_mipmap to provide a more +Python-friendly API + +Overview (from the spec) + + Conventional OpenGL ES 2.0 allows the use of non-power-of-two (NPOT) + textures with the limitation that mipmap minification filters can + not be used. This extension relaxes this restriction and adds + limited mipmap support for 2D NPOT textures. + + With this extension, NPOT textures are specified and applied + identically to mipmapped power-of-two 2D textures with the following + limitations: + + - The texture wrap modes must be CLAMP_TO_EDGE. + + - Coordinates used for texture sampling on an NPOT texture using a + mipmapped minification filter must lie within the range [0,1]. + Coordinate clamping is not performed by the GL in this case, + causing values outside this range to produce undefined results. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/texture_npot_2D_mipmap.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.NV.texture_npot_2D_mipmap import * +from OpenGL.raw.GLES2.NV.texture_npot_2D_mipmap import _EXTENSION_NAME + +def glInitTextureNpot2DMipmapNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/viewport_array.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/viewport_array.py new file mode 100644 index 00000000..aa5beb72 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/viewport_array.py @@ -0,0 +1,66 @@ +'''OpenGL extension NV.viewport_array + +This module customises the behaviour of the +OpenGL.raw.GLES2.NV.viewport_array to provide a more +Python-friendly API + +Overview (from the spec) + + OpenGL ES is modeled on a pipeline of operations. The final stage in this + pipeline before rasterization is the viewport transformation. This stage + transforms vertices from view space into window coordinates and allows the + application to specify a rectangular region of screen space into which + OpenGL should draw primitives. Unextended OpenGL implementations provide a + single viewport per context. In order to draw primitives into multiple + viewports, the OpenGL viewport may be changed between several draw calls. + With the advent of Geometry Shaders, it has become possible for an + application to amplify geometry and produce multiple output primitives for + each primitive input to the Geometry Shader. It is possible to direct these + primitives to render into a selected render target. However, all render + targets share the same, global OpenGL viewport. + + This extension enhances OpenGL by providing a mechanism to expose multiple + viewports. Each viewport is specified as a rectangle. The destination + viewport may be selected per-primitive by the geometry shader. This allows + the Geometry Shader to produce different versions of primitives destined + for separate viewport rectangles on the same surface. Additionally, when + combined with multiple framebuffer attachments, it allows a different + viewport rectangle to be selected for each. This extension also exposes a + separate scissor rectangle for each viewport. Finally, the viewport bounds + are now floating point quantities allowing fractional pixel offsets to be + applied during the viewport transform. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/viewport_array.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.NV.viewport_array import * +from OpenGL.raw.GLES2.NV.viewport_array import _EXTENSION_NAME + +def glInitViewportArrayNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glViewportArrayvNV.v size not checked against 'count' +glViewportArrayvNV=wrapper.wrapper(glViewportArrayvNV).setInputArraySize( + 'v', None +) +glViewportIndexedfvNV=wrapper.wrapper(glViewportIndexedfvNV).setInputArraySize( + 'v', 4 +) +# INPUT glScissorArrayvNV.v size not checked against 'count' +glScissorArrayvNV=wrapper.wrapper(glScissorArrayvNV).setInputArraySize( + 'v', None +) +glScissorIndexedvNV=wrapper.wrapper(glScissorIndexedvNV).setInputArraySize( + 'v', 4 +) +# INPUT glGetFloati_vNV.data size not checked against 'target' +glGetFloati_vNV=wrapper.wrapper(glGetFloati_vNV).setInputArraySize( + 'data', None +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/viewport_array2.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/viewport_array2.py new file mode 100644 index 00000000..448154a3 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/viewport_array2.py @@ -0,0 +1,45 @@ +'''OpenGL extension NV.viewport_array2 + +This module customises the behaviour of the +OpenGL.raw.GLES2.NV.viewport_array2 to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides new support allowing a single primitive to be + broadcast to multiple viewports and/or multiple layers. A shader output + gl_ViewportMask[] is provided, allowing a single primitive to be output to + multiple viewports simultaneously. Also, a new shader option is provided + to control whether the effective viewport index is added into gl_Layer. + These capabilities allow a single primitive to be output to multiple + layers simultaneously. + + The gl_ViewportMask[] output is available in vertex, tessellation + control, tessellation evaluation, and geometry shaders. gl_ViewportIndex + and gl_Layer are also made available in all these shader stages. The + actual viewport index or mask and render target layer values are taken + from the last active shader stage from this set of stages. + + This extension is a superset of the GL_AMD_vertex_shader_layer and + GL_AMD_vertex_shader_viewport_index extensions, and thus those extension + strings are expected to be exported if GL_NV_viewport_array2 is + supported. This extension includes the edits for those extensions, recast + against the reorganized OpenGL 4.3 specification. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/viewport_array2.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.NV.viewport_array2 import * +from OpenGL.raw.GLES2.NV.viewport_array2 import _EXTENSION_NAME + +def glInitViewportArray2NV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/viewport_swizzle.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/viewport_swizzle.py new file mode 100644 index 00000000..52b0295b --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NV/viewport_swizzle.py @@ -0,0 +1,41 @@ +'''OpenGL extension NV.viewport_swizzle + +This module customises the behaviour of the +OpenGL.raw.GLES2.NV.viewport_swizzle to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides a new per-viewport swizzle that can modify the + position of primitives sent to each viewport. New viewport swizzle state + is added for each viewport, and a new position vector is computed for each + vertex by selecting from and optionally negating any of the four + components of the original position vector. + + This new viewport swizzle is useful for a number of algorithms, including + single-pass cubemap rendering (broadcasting a primitive to multiple faces + and reorienting the vertex position for each face) and voxel + rasterization. The per-viewport component remapping and negation provided + by the swizzle allows application code to re-orient three-dimensional + geometry with a view along any of the X, Y, or Z axes. If a perspective + projection and depth buffering is required, 1/W buffering should be used, + as described in the single-pass cubemap rendering example in the "Issues" + section below. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/viewport_swizzle.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.NV.viewport_swizzle import * +from OpenGL.raw.GLES2.NV.viewport_swizzle import _EXTENSION_NAME + +def glInitViewportSwizzleNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/NVX/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NVX/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NVX/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/NVX/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NVX/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..c39764f0 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NVX/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/NVX/__pycache__/blend_equation_advanced_multi_draw_buffers.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NVX/__pycache__/blend_equation_advanced_multi_draw_buffers.cpython-312.pyc new file mode 100644 index 00000000..897f164c Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NVX/__pycache__/blend_equation_advanced_multi_draw_buffers.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/NVX/blend_equation_advanced_multi_draw_buffers.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NVX/blend_equation_advanced_multi_draw_buffers.py new file mode 100644 index 00000000..65c69838 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/NVX/blend_equation_advanced_multi_draw_buffers.py @@ -0,0 +1,34 @@ +'''OpenGL extension NVX.blend_equation_advanced_multi_draw_buffers + +This module customises the behaviour of the +OpenGL.raw.GLES2.NVX.blend_equation_advanced_multi_draw_buffers to provide a more +Python-friendly API + +Overview (from the spec) + + This extension adds support for using advanced blend equations + introduced with NV_blend_equation_advanced (and standardized + by KHR_blend_equation_advanced) in conjunction with multiple + draw buffers. The NV_blend_equation_advanced extension supports + advanced blending equations only when rending to a single color + buffer using fragment color zero and throws and INVALID_OPERATION + error when multiple draw buffers are used. This extension removes + this restriction. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NVX/blend_equation_advanced_multi_draw_buffers.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.NVX.blend_equation_advanced_multi_draw_buffers import * +from OpenGL.raw.GLES2.NVX.blend_equation_advanced_multi_draw_buffers import _EXTENSION_NAME + +def glInitBlendEquationAdvancedMultiDrawBuffersNVX(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/EGL_image.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/EGL_image.py new file mode 100644 index 00000000..41ca71fc --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/EGL_image.py @@ -0,0 +1,43 @@ +'''OpenGL extension OES.EGL_image + +This module customises the behaviour of the +OpenGL.raw.GLES2.OES.EGL_image to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides a mechanism for creating texture and + renderbuffer objects sharing storage with specified EGLImage objects + (such objects are referred to as "EGLImage targets"). + + The companion EGL_KHR_image_base and EGL_KHR_image extensions + provide the definition and rationale for EGLImage objects. + + Other EGL extensions, such as EGL_KHR_gl_texture_2D_image, + EGL_KHR_gl_texture_cubemap_image, EGL_KHR_gl_texture_3D_image, + EGL_KHR_gl_renderbuffer_image, and EGL_KHR_vg_parent_image, define + the related functionality of creating EGLImage objects from + "EGLImage sources" such as OpenGL ES texture or renderbuffers or + OpenVG VGImage objects. + + EGL extension specifications are located in the EGL Registry at + + http://www.khronos.org/registry/egl/ + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/OES/EGL_image.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.OES.EGL_image import * +from OpenGL.raw.GLES2.OES.EGL_image import _EXTENSION_NAME + +def glInitEglImageOES(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/EGL_image_external.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/EGL_image_external.py new file mode 100644 index 00000000..bc3778d7 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/EGL_image_external.py @@ -0,0 +1,37 @@ +'''OpenGL extension OES.EGL_image_external + +This module customises the behaviour of the +OpenGL.raw.GLES2.OES.EGL_image_external to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides a mechanism for creating EGLImage texture targets + from EGLImages. This extension defines a new texture target, + TEXTURE_EXTERNAL_OES. This texture target can only be specified using an + EGLImage. There is no support for most of the functions that manipulate + other texture targets (e.g. you cannot use gl*Tex*Image*() functions with + TEXTURE_EXTERNAL_OES). Also, TEXTURE_EXTERNAL_OES targets never have more + than a single LOD level. Because of these restrictions, it is possible to + bind EGLImages which have internal formats not otherwise supported by + OpenGL ES. For example some implementations may allow EGLImages with + planar or interleaved YUV data to be GLES texture target siblings. It is + up to the implementation exactly what formats are accepted. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/OES/EGL_image_external.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.OES.EGL_image_external import * +from OpenGL.raw.GLES2.OES.EGL_image_external import _EXTENSION_NAME + +def glInitEglImageExternalOES(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/EGL_image_external_essl3.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/EGL_image_external_essl3.py new file mode 100644 index 00000000..f5904003 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/EGL_image_external_essl3.py @@ -0,0 +1,30 @@ +'''OpenGL extension OES.EGL_image_external_essl3 + +This module customises the behaviour of the +OpenGL.raw.GLES2.OES.EGL_image_external_essl3 to provide a more +Python-friendly API + +Overview (from the spec) + + OES_EGL_image_external provides a mechanism for creating EGLImage texture + targets from EGLImages, but only specified language interactions for the + OpenGL ES Shading Language version 1.0. This extension adds support for + versions 3.x of the OpenGL ES Shading Language. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/OES/EGL_image_external_essl3.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.OES.EGL_image_external_essl3 import * +from OpenGL.raw.GLES2.OES.EGL_image_external_essl3 import _EXTENSION_NAME + +def glInitEglImageExternalEssl3OES(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/EGL_image.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/EGL_image.cpython-312.pyc new file mode 100644 index 00000000..feed5fb1 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/EGL_image.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/EGL_image_external.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/EGL_image_external.cpython-312.pyc new file mode 100644 index 00000000..57a5ce5f Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/EGL_image_external.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/EGL_image_external_essl3.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/EGL_image_external_essl3.cpython-312.pyc new file mode 100644 index 00000000..2fe13615 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/EGL_image_external_essl3.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..9dd04ee1 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/compressed_ETC1_RGB8_sub_texture.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/compressed_ETC1_RGB8_sub_texture.cpython-312.pyc new file mode 100644 index 00000000..a9252481 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/compressed_ETC1_RGB8_sub_texture.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/compressed_ETC1_RGB8_texture.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/compressed_ETC1_RGB8_texture.cpython-312.pyc new file mode 100644 index 00000000..7e6fe3cc Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/compressed_ETC1_RGB8_texture.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/compressed_paletted_texture.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/compressed_paletted_texture.cpython-312.pyc new file mode 100644 index 00000000..214a0264 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/compressed_paletted_texture.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/copy_image.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/copy_image.cpython-312.pyc new file mode 100644 index 00000000..ffa30abe Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/copy_image.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/depth24.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/depth24.cpython-312.pyc new file mode 100644 index 00000000..299e8152 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/depth24.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/depth32.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/depth32.cpython-312.pyc new file mode 100644 index 00000000..63409a2a Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/depth32.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/depth_texture.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/depth_texture.cpython-312.pyc new file mode 100644 index 00000000..acab65b8 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/depth_texture.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/draw_buffers_indexed.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/draw_buffers_indexed.cpython-312.pyc new file mode 100644 index 00000000..1fece456 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/draw_buffers_indexed.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/draw_elements_base_vertex.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/draw_elements_base_vertex.cpython-312.pyc new file mode 100644 index 00000000..f708feb8 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/draw_elements_base_vertex.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/element_index_uint.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/element_index_uint.cpython-312.pyc new file mode 100644 index 00000000..681accf6 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/element_index_uint.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/fbo_render_mipmap.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/fbo_render_mipmap.cpython-312.pyc new file mode 100644 index 00000000..c388af39 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/fbo_render_mipmap.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/fragment_precision_high.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/fragment_precision_high.cpython-312.pyc new file mode 100644 index 00000000..1342d848 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/fragment_precision_high.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/geometry_point_size.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/geometry_point_size.cpython-312.pyc new file mode 100644 index 00000000..76aa9d9c Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/geometry_point_size.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/geometry_shader.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/geometry_shader.cpython-312.pyc new file mode 100644 index 00000000..c50931ea Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/geometry_shader.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/get_program_binary.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/get_program_binary.cpython-312.pyc new file mode 100644 index 00000000..4354c2f9 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/get_program_binary.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/gpu_shader5.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/gpu_shader5.cpython-312.pyc new file mode 100644 index 00000000..90bb474c Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/gpu_shader5.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/mapbuffer.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/mapbuffer.cpython-312.pyc new file mode 100644 index 00000000..94f9cffd Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/mapbuffer.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/packed_depth_stencil.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/packed_depth_stencil.cpython-312.pyc new file mode 100644 index 00000000..f0a6927b Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/packed_depth_stencil.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/primitive_bounding_box.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/primitive_bounding_box.cpython-312.pyc new file mode 100644 index 00000000..3238ea6b Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/primitive_bounding_box.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/required_internalformat.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/required_internalformat.cpython-312.pyc new file mode 100644 index 00000000..5b5d24e8 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/required_internalformat.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/rgb8_rgba8.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/rgb8_rgba8.cpython-312.pyc new file mode 100644 index 00000000..f85d0df7 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/rgb8_rgba8.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/sample_shading.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/sample_shading.cpython-312.pyc new file mode 100644 index 00000000..d33f03c8 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/sample_shading.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/sample_variables.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/sample_variables.cpython-312.pyc new file mode 100644 index 00000000..bc5f1703 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/sample_variables.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/shader_image_atomic.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/shader_image_atomic.cpython-312.pyc new file mode 100644 index 00000000..ac32d685 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/shader_image_atomic.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/shader_io_blocks.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/shader_io_blocks.cpython-312.pyc new file mode 100644 index 00000000..6bd47c6d Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/shader_io_blocks.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/shader_multisample_interpolation.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/shader_multisample_interpolation.cpython-312.pyc new file mode 100644 index 00000000..677e00df Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/shader_multisample_interpolation.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/standard_derivatives.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/standard_derivatives.cpython-312.pyc new file mode 100644 index 00000000..3c2fcc78 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/standard_derivatives.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/stencil1.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/stencil1.cpython-312.pyc new file mode 100644 index 00000000..5e296228 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/stencil1.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/stencil4.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/stencil4.cpython-312.pyc new file mode 100644 index 00000000..b4a025d5 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/stencil4.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/surfaceless_context.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/surfaceless_context.cpython-312.pyc new file mode 100644 index 00000000..6d882b89 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/surfaceless_context.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/tessellation_point_size.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/tessellation_point_size.cpython-312.pyc new file mode 100644 index 00000000..24633a86 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/tessellation_point_size.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/tessellation_shader.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/tessellation_shader.cpython-312.pyc new file mode 100644 index 00000000..607a952b Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/tessellation_shader.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/texture_3D.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/texture_3D.cpython-312.pyc new file mode 100644 index 00000000..2acfb63b Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/texture_3D.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/texture_border_clamp.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/texture_border_clamp.cpython-312.pyc new file mode 100644 index 00000000..4c99045e Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/texture_border_clamp.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/texture_buffer.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/texture_buffer.cpython-312.pyc new file mode 100644 index 00000000..514fbdd1 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/texture_buffer.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/texture_compression_astc.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/texture_compression_astc.cpython-312.pyc new file mode 100644 index 00000000..b08ef28d Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/texture_compression_astc.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/texture_cube_map_array.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/texture_cube_map_array.cpython-312.pyc new file mode 100644 index 00000000..c82f41e9 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/texture_cube_map_array.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/texture_float.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/texture_float.cpython-312.pyc new file mode 100644 index 00000000..5a3fedc9 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/texture_float.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/texture_float_linear.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/texture_float_linear.cpython-312.pyc new file mode 100644 index 00000000..dcafcb4d Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/texture_float_linear.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/texture_half_float.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/texture_half_float.cpython-312.pyc new file mode 100644 index 00000000..70b001d2 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/texture_half_float.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/texture_half_float_linear.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/texture_half_float_linear.cpython-312.pyc new file mode 100644 index 00000000..3030b22e Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/texture_half_float_linear.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/texture_npot.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/texture_npot.cpython-312.pyc new file mode 100644 index 00000000..4d42cdda Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/texture_npot.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/texture_stencil8.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/texture_stencil8.cpython-312.pyc new file mode 100644 index 00000000..0126fcb2 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/texture_stencil8.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/texture_storage_multisample_2d_array.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/texture_storage_multisample_2d_array.cpython-312.pyc new file mode 100644 index 00000000..3801865a Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/texture_storage_multisample_2d_array.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/texture_view.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/texture_view.cpython-312.pyc new file mode 100644 index 00000000..2b5bda48 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/texture_view.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/vertex_array_object.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/vertex_array_object.cpython-312.pyc new file mode 100644 index 00000000..f1529bf7 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/vertex_array_object.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/vertex_half_float.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/vertex_half_float.cpython-312.pyc new file mode 100644 index 00000000..f5e405f7 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/vertex_half_float.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/vertex_type_10_10_10_2.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/vertex_type_10_10_10_2.cpython-312.pyc new file mode 100644 index 00000000..cd5f769d Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/vertex_type_10_10_10_2.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/viewport_array.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/viewport_array.cpython-312.pyc new file mode 100644 index 00000000..822cc656 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/__pycache__/viewport_array.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/compressed_ETC1_RGB8_sub_texture.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/compressed_ETC1_RGB8_sub_texture.py new file mode 100644 index 00000000..612d5e34 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/compressed_ETC1_RGB8_sub_texture.py @@ -0,0 +1,23 @@ +'''OpenGL extension OES.compressed_ETC1_RGB8_sub_texture + +This module customises the behaviour of the +OpenGL.raw.GLES2.OES.compressed_ETC1_RGB8_sub_texture to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/OES/compressed_ETC1_RGB8_sub_texture.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.OES.compressed_ETC1_RGB8_sub_texture import * +from OpenGL.raw.GLES2.OES.compressed_ETC1_RGB8_sub_texture import _EXTENSION_NAME + +def glInitCompressedEtc1Rgb8SubTextureOES(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/compressed_ETC1_RGB8_texture.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/compressed_ETC1_RGB8_texture.py new file mode 100644 index 00000000..d205916a --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/compressed_ETC1_RGB8_texture.py @@ -0,0 +1,37 @@ +'''OpenGL extension OES.compressed_ETC1_RGB8_texture + +This module customises the behaviour of the +OpenGL.raw.GLES2.OES.compressed_ETC1_RGB8_texture to provide a more +Python-friendly API + +Overview (from the spec) + + The goal of this extension is to allow direct support of + compressed textures in the Ericsson Texture Compression (ETC) + formats in OpenGL ES. + + ETC-compressed textures are handled in OpenGL ES using the + CompressedTexImage2D call. + + The definition of the "internalformat" parameter in the + CompressedTexImage2D call has been extended to support + ETC-compressed textures. + + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/OES/compressed_ETC1_RGB8_texture.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.OES.compressed_ETC1_RGB8_texture import * +from OpenGL.raw.GLES2.OES.compressed_ETC1_RGB8_texture import _EXTENSION_NAME + +def glInitCompressedEtc1Rgb8TextureOES(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/compressed_paletted_texture.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/compressed_paletted_texture.py new file mode 100644 index 00000000..168a67ab --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/compressed_paletted_texture.py @@ -0,0 +1,60 @@ +'''OpenGL extension OES.compressed_paletted_texture + +This module customises the behaviour of the +OpenGL.raw.GLES2.OES.compressed_paletted_texture to provide a more +Python-friendly API + +Overview (from the spec) + + The goal of this extension is to allow direct support of palettized + textures in OpenGL ES. + + Palettized textures are implemented in OpenGL ES using the + CompressedTexImage2D call. The definition of the following parameters + "level" and "internalformat" in the CompressedTexImage2D call have + been extended to support paletted textures. + + A paletted texture is described by the following data: + + palette format + can be R5_G6_B5, RGBA4, RGB5_A1, RGB8, or RGBA8 + + number of bits to represent texture data + can be 4 bits or 8 bits per texel. The number of bits + also detemine the size of the palette. For 4 bits/texel + the palette size is 16 entries and for 8 bits/texel the + palette size will be 256 entries. + + The palette format and bits/texel are encoded in the + "internalformat" parameter. + + palette data and texture mip-levels + The palette data followed by all necessary mip levels are + passed in "data" parameter of CompressedTexImage2D. + + The size of palette is given by palette format and bits / texel. + A palette format of RGB_565 with 4 bits/texel imply a palette + size of 2 bytes/palette entry * 16 entries = 32 bytes. + + The level value is used to indicate how many mip levels + are described. Negative level values are used to define + the number of miplevels described in the "data" component. + A level of zero indicates a single mip-level. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/OES/compressed_paletted_texture.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.OES.compressed_paletted_texture import * +from OpenGL.raw.GLES2.OES.compressed_paletted_texture import _EXTENSION_NAME + +def glInitCompressedPalettedTextureOES(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/copy_image.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/copy_image.py new file mode 100644 index 00000000..9b98bfb5 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/copy_image.py @@ -0,0 +1,45 @@ +'''OpenGL extension OES.copy_image + +This module customises the behaviour of the +OpenGL.raw.GLES2.OES.copy_image to provide a more +Python-friendly API + +Overview (from the spec) + + This extension enables efficient image data transfer between image + objects (i.e. textures and renderbuffers) without the need to bind + the objects or otherwise configure the rendering pipeline. + + This is accomplised by adding a new entry-point CopyImageSubData, + which takes a named source and destination. + + CopyImageSubData does not perform general-purpose conversions + such as scaling, resizing, blending, color-space, or format + conversions. It should be considered to operate in a manner + similar to a CPU memcpy, but using the GPU for the copy. + + CopyImageSubData supports copies between images with different + internal formats, if the formats are compatible as described in + this extension. + + CopyImageSubData also supports copying between compressed and + uncompressed images if the compressed block / uncompressed texel + sizes are the same. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/OES/copy_image.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.OES.copy_image import * +from OpenGL.raw.GLES2.OES.copy_image import _EXTENSION_NAME + +def glInitCopyImageOES(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/depth24.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/depth24.py new file mode 100644 index 00000000..b61e6f10 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/depth24.py @@ -0,0 +1,28 @@ +'''OpenGL extension OES.depth24 + +This module customises the behaviour of the +OpenGL.raw.GLES2.OES.depth24 to provide a more +Python-friendly API + +Overview (from the spec) + + This extension enables 24-bit depth components as a valid + render buffer storage format. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/OES/depth24.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.OES.depth24 import * +from OpenGL.raw.GLES2.OES.depth24 import _EXTENSION_NAME + +def glInitDepth24OES(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/depth32.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/depth32.py new file mode 100644 index 00000000..409333b2 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/depth32.py @@ -0,0 +1,28 @@ +'''OpenGL extension OES.depth32 + +This module customises the behaviour of the +OpenGL.raw.GLES2.OES.depth32 to provide a more +Python-friendly API + +Overview (from the spec) + + This extension enables 32-bit depth components as a valid + render buffer storage format. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/OES/depth32.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.OES.depth32 import * +from OpenGL.raw.GLES2.OES.depth32 import _EXTENSION_NAME + +def glInitDepth32OES(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/depth_texture.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/depth_texture.py new file mode 100644 index 00000000..f8a1e4f4 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/depth_texture.py @@ -0,0 +1,30 @@ +'''OpenGL extension OES.depth_texture + +This module customises the behaviour of the +OpenGL.raw.GLES2.OES.depth_texture to provide a more +Python-friendly API + +Overview (from the spec) + + This extension defines a new texture format that stores depth values in + the texture. Depth texture images are widely used for shadow casting but + can also be used for other effects such as image based rendering, displacement + mapping etc. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/OES/depth_texture.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.OES.depth_texture import * +from OpenGL.raw.GLES2.OES.depth_texture import _EXTENSION_NAME + +def glInitDepthTextureOES(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/draw_buffers_indexed.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/draw_buffers_indexed.py new file mode 100644 index 00000000..d55eb0af --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/draw_buffers_indexed.py @@ -0,0 +1,43 @@ +'''OpenGL extension OES.draw_buffers_indexed + +This module customises the behaviour of the +OpenGL.raw.GLES2.OES.draw_buffers_indexed to provide a more +Python-friendly API + +Overview (from the spec) + + This extension builds upon the EXT_draw_buffers extension. + In EXT_draw_buffers (part of OpenGL ES 3.0), separate values could + be written to each color buffer, but the blend enable, blend functions, + blend equations and color write masks are global and apply to all color + outputs. + + This extension provides the ability to independently + * enable or disable blending, + * set the blend equations, + * set the blend functions, and + * set the color write masks + per color output. + + This extension introduces indexed versions of the enable, + blend equation, blend function, and color mask commands, as + well as associated indexed queries in order to control and + query these states independently on a per-color output basis. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/OES/draw_buffers_indexed.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.OES.draw_buffers_indexed import * +from OpenGL.raw.GLES2.OES.draw_buffers_indexed import _EXTENSION_NAME + +def glInitDrawBuffersIndexedOES(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/draw_elements_base_vertex.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/draw_elements_base_vertex.py new file mode 100644 index 00000000..1eea674b --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/draw_elements_base_vertex.py @@ -0,0 +1,101 @@ +'''OpenGL extension OES.draw_elements_base_vertex + +This module customises the behaviour of the +OpenGL.raw.GLES2.OES.draw_elements_base_vertex to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides a method to specify a "base vertex offset" + value which is effectively added to every vertex index that is + transferred through DrawElements. + + This mechanism can be used to decouple a set of indices from the + actual vertex array that it is referencing. This is useful if an + application stores multiple indexed models in a single vertex array. + The same index array can be used to draw the model no matter where + it ends up in a larger vertex array simply by changing the base + vertex value. Without this functionality, it would be necessary to + rebind all the vertex attributes every time geometry is switched and + this can have larger performance penalty. + + For example consider the (very contrived and simple) example of + drawing two triangles to form a quad. In the typical example you + have the following setup: + + vertices indices + ---------- ----- + 0 | (-1, 1) | 0 | 0 | + 1 | (-1, -1) | 1 | 1 | + 2 | ( 1, -1) | 2 | 2 | + 3 | ( 1, 1) | 3 | 3 | + ---------- 4 | 0 | + 5 | 2 | + ----- + which is normally rendered with the call + + DrawElements(TRIANGLES, 6, UNSIGNED_BYTE, &indices). + + Now consider the case where the vertices you want to draw are not at + the start of a vertex array but are instead located at offset 100 + into a larger array: + + vertices2 indices2 + ---------- ----- + .... 0 | 100 | + 100 | (-1, 1) | 1 | 101 | + 101 | (-1, -1) | 2 | 102 | + 102 | ( 1, -1) | 3 | 103 | + 103 | ( 1, 1) | 4 | 100 | + .... 5 | 102 | + ---------- ----- + + The typical choices for rendering this are to rebind your vertex + attributes with an additional offset of 100*stride, or to create an + new array of indices (as indices2 in the example). However both + rebinding vertex attributes and rebuilding index arrays can be quite + costly activities. + + With the new drawing commands introduced by this extension you can + instead draw using vertices2 and the new draw call: + + DrawElementsBaseVertexOES(TRIANGLES, 6, UNSIGNED_BYTE, &indices, 100) + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/OES/draw_elements_base_vertex.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.OES.draw_elements_base_vertex import * +from OpenGL.raw.GLES2.OES.draw_elements_base_vertex import _EXTENSION_NAME + +def glInitDrawElementsBaseVertexOES(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glDrawElementsBaseVertexOES.indices size not checked against 'count,type' +glDrawElementsBaseVertexOES=wrapper.wrapper(glDrawElementsBaseVertexOES).setInputArraySize( + 'indices', None +) +# INPUT glDrawRangeElementsBaseVertexOES.indices size not checked against 'count,type' +glDrawRangeElementsBaseVertexOES=wrapper.wrapper(glDrawRangeElementsBaseVertexOES).setInputArraySize( + 'indices', None +) +# INPUT glDrawElementsInstancedBaseVertexOES.indices size not checked against 'count,type' +glDrawElementsInstancedBaseVertexOES=wrapper.wrapper(glDrawElementsInstancedBaseVertexOES).setInputArraySize( + 'indices', None +) +# INPUT glMultiDrawElementsBaseVertexEXT.basevertex size not checked against 'drawcount' +# INPUT glMultiDrawElementsBaseVertexEXT.count size not checked against 'drawcount' +# INPUT glMultiDrawElementsBaseVertexEXT.indices size not checked against 'drawcount' +glMultiDrawElementsBaseVertexEXT=wrapper.wrapper(glMultiDrawElementsBaseVertexEXT).setInputArraySize( + 'basevertex', None +).setInputArraySize( + 'count', None +).setInputArraySize( + 'indices', None +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/element_index_uint.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/element_index_uint.py new file mode 100644 index 00000000..b224a0fa --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/element_index_uint.py @@ -0,0 +1,29 @@ +'''OpenGL extension OES.element_index_uint + +This module customises the behaviour of the +OpenGL.raw.GLES2.OES.element_index_uint to provide a more +Python-friendly API + +Overview (from the spec) + + OpenGL ES 1.0 supports DrawElements with value of + UNSIGNED_BYTE and UNSIGNED_SHORT. This extension adds + support for UNSIGNED_INT values. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/OES/element_index_uint.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.OES.element_index_uint import * +from OpenGL.raw.GLES2.OES.element_index_uint import _EXTENSION_NAME + +def glInitElementIndexUintOES(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/fbo_render_mipmap.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/fbo_render_mipmap.py new file mode 100644 index 00000000..e2598b2a --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/fbo_render_mipmap.py @@ -0,0 +1,34 @@ +'''OpenGL extension OES.fbo_render_mipmap + +This module customises the behaviour of the +OpenGL.raw.GLES2.OES.fbo_render_mipmap to provide a more +Python-friendly API + +Overview (from the spec) + + OES_framebuffer_object allows rendering to the base level of a + texture only. This extension removes this limitation by + allowing implementations to support rendering to any mip-level + of a texture(s) that is attached to a framebuffer object(s). + + If this extension is supported, FramebufferTexture2DOES, and + FramebufferTexture3DOES can be used to render directly into + any mip level of a texture image + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/OES/fbo_render_mipmap.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.OES.fbo_render_mipmap import * +from OpenGL.raw.GLES2.OES.fbo_render_mipmap import _EXTENSION_NAME + +def glInitFboRenderMipmapOES(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/fragment_precision_high.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/fragment_precision_high.py new file mode 100644 index 00000000..00e91042 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/fragment_precision_high.py @@ -0,0 +1,30 @@ +'''OpenGL extension OES.fragment_precision_high + +This module customises the behaviour of the +OpenGL.raw.GLES2.OES.fragment_precision_high to provide a more +Python-friendly API + +Overview (from the spec) + + This extension has been withdrawn. See the specification of + GetShaderPrecisionFormat in section 6.1.8 of the OpenGL ES 2.0 + Specification to determine within the API if high-precision fragment + shader varyings are supported by the implementation. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/OES/fragment_precision_high.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.OES.fragment_precision_high import * +from OpenGL.raw.GLES2.OES.fragment_precision_high import _EXTENSION_NAME + +def glInitFragmentPrecisionHighOES(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/geometry_point_size.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/geometry_point_size.py new file mode 100644 index 00000000..2a2bc634 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/geometry_point_size.py @@ -0,0 +1,23 @@ +'''OpenGL extension OES.geometry_point_size + +This module customises the behaviour of the +OpenGL.raw.GLES2.OES.geometry_point_size to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/OES/geometry_point_size.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.OES.geometry_point_size import * +from OpenGL.raw.GLES2.OES.geometry_point_size import _EXTENSION_NAME + +def glInitGeometryPointSizeOES(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/geometry_shader.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/geometry_shader.py new file mode 100644 index 00000000..acd3a7d7 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/geometry_shader.py @@ -0,0 +1,70 @@ +'''OpenGL extension OES.geometry_shader + +This module customises the behaviour of the +OpenGL.raw.GLES2.OES.geometry_shader to provide a more +Python-friendly API + +Overview (from the spec) + + OES_geometry_shader defines a new shader type available to be run on the + GPU, called a geometry shader. Geometry shaders are run after vertices are + transformed, but prior to color clamping, flatshading and clipping. + + A geometry shader begins with a single primitive (point, line, + triangle). It can read the attributes of any of the vertices in the + primitive and use them to generate new primitives. A geometry shader has a + fixed output primitive type (point, line strip, or triangle strip) and + emits vertices to define a new primitive. A geometry shader can emit + multiple disconnected primitives. The primitives emitted by the geometry + shader are clipped and then processed like an equivalent primitive + specified by the application. + + Furthermore, OES_geometry_shader provides four additional primitive + types: lines with adjacency, line strips with adjacency, separate + triangles with adjacency, and triangle strips with adjacency. Some of the + vertices specified in these new primitive types are not part of the + ordinary primitives, instead they represent neighboring vertices that are + adjacent to the two line segment end points (lines/strips) or the three + triangle edges (triangles/tstrips). These vertices can be accessed by + geometry shaders and used to match up the vertices emitted by the geometry + shader with those of neighboring primitives. + + Since geometry shaders expect a specific input primitive type, an error + will occur if the application presents primitives of a different type. + For example, if a geometry shader expects points, an error will occur at + drawing time if a primitive mode of TRIANGLES is specified. + + This extension also adds the notion of layered framebuffer attachments + and framebuffers that can be used in conjunction with geometry shaders + to allow programs to direct primitives to a face of a cube map or layer + of a three-dimensional texture or two-dimensional array texture. The + layer used for rendering can be selected by the geometry shader at run + time. The framebuffer layer count present in GL 4.x and removed from + ES 3.1 is restored. + + Not all geometry shader implementations have the ability to write the + point size from a geometry shader. Thus a second extension string and + shading language enable are provided for implementations which do + support geometry shader point size. + + This extension relies on the OES_shader_io_blocks extension to provide + the required functionality for declaring input and output blocks and + interfacing between shaders. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/OES/geometry_shader.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.OES.geometry_shader import * +from OpenGL.raw.GLES2.OES.geometry_shader import _EXTENSION_NAME + +def glInitGeometryShaderOES(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/get_program_binary.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/get_program_binary.py new file mode 100644 index 00000000..c29eca68 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/get_program_binary.py @@ -0,0 +1,60 @@ +'''OpenGL extension OES.get_program_binary + +This module customises the behaviour of the +OpenGL.raw.GLES2.OES.get_program_binary to provide a more +Python-friendly API + +Overview (from the spec) + + This extension introduces two new commands. GetProgramBinaryOES empowers an + application to use the GL itself as an offline compiler. The resulting + program binary can be reloaded into the GL via ProgramBinaryOES. This is a + very useful path for applications that wish to remain portable by shipping + pure GLSL source shaders, yet would like to avoid the cost of compiling + their shaders at runtime. Instead an application can supply its GLSL source + shaders during first application run, or even during installation. The + application then compiles and links its shaders and reads back the program + binaries. On subsequent runs, only the program binaries need be supplied! + Though the level of optimization may not be identical -- the offline shader + compiler may have the luxury of more aggressive optimization at its + disposal -- program binaries generated online by the GL are interchangeable + with those generated offline by an SDK tool. + + Note that an implementation supporting this extension need not include an + online compiler. That is, it is not required to support loading GLSL shader + sources via the ShaderSource command. A query of boolean value + SHADER_COMPILER can be used to determine if an implementation supports a + shader compiler. If not, the GetProgramBinaryOES command is rendered + virtually useless, but the ProgramBinaryOES command may still be used by + vendor extensions as a standard method for loading offline-compiled program + binaries. + + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/OES/get_program_binary.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.OES.get_program_binary import * +from OpenGL.raw.GLES2.OES.get_program_binary import _EXTENSION_NAME + +def glInitGetProgramBinaryOES(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glGetProgramBinaryOES.binary size not checked against bufSize +glGetProgramBinaryOES=wrapper.wrapper(glGetProgramBinaryOES).setInputArraySize( + 'binary', None +).setInputArraySize( + 'binaryFormat', 1 +).setInputArraySize( + 'length', 1 +) +# INPUT glProgramBinaryOES.binary size not checked against length +glProgramBinaryOES=wrapper.wrapper(glProgramBinaryOES).setInputArraySize( + 'binary', None +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/gpu_shader5.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/gpu_shader5.py new file mode 100644 index 00000000..e43a5e2e --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/gpu_shader5.py @@ -0,0 +1,62 @@ +'''OpenGL extension OES.gpu_shader5 + +This module customises the behaviour of the +OpenGL.raw.GLES2.OES.gpu_shader5 to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides a set of new features to the OpenGL ES Shading + Language and related APIs to support capabilities of new GPUs, extending + the capabilities of version 3.10 of the OpenGL ES Shading Language. + Shaders using the new functionality provided by this extension should + enable this functionality via the construct + + #extension GL_OES_gpu_shader5 : require (or enable) + + This extension provides a variety of new features for all shader types, + including: + + * support for indexing into arrays of opaque types (samplers, + and atomic counters) using dynamically uniform integer expressions; + + * support for indexing into arrays of images and shader storage blocks + using only constant integral expressions; + + * extending the uniform block capability to allow shaders to index + into an array of uniform blocks; + + * a "precise" qualifier allowing computations to be carried out exactly + as specified in the shader source to avoid optimization-induced + invariance issues (which might cause cracking in tessellation); + + * new built-in functions supporting: + + * fused floating-point multiply-add operations; + + * extending the textureGather() built-in functions provided by + OpenGL ES Shading Language 3.10: + + * allowing shaders to use arbitrary offsets computed at run-time to + select a 2x2 footprint to gather from; and + * allowing shaders to use separate independent offsets for each of + the four texels returned, instead of requiring a fixed 2x2 + footprint. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/OES/gpu_shader5.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.OES.gpu_shader5 import * +from OpenGL.raw.GLES2.OES.gpu_shader5 import _EXTENSION_NAME + +def glInitGpuShader5OES(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/mapbuffer.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/mapbuffer.py new file mode 100644 index 00000000..ab0b7672 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/mapbuffer.py @@ -0,0 +1,29 @@ +'''OpenGL extension OES.mapbuffer + +This module customises the behaviour of the +OpenGL.raw.GLES2.OES.mapbuffer to provide a more +Python-friendly API + +Overview (from the spec) + + This extension adds to the vertex buffer object functionality supported + by OpenGL ES 1.1 or ES 2.0 by allowing the entire data storage of a + buffer object to be mapped into the client's address space. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/OES/mapbuffer.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.OES.mapbuffer import * +from OpenGL.raw.GLES2.OES.mapbuffer import _EXTENSION_NAME + +def glInitMapbufferOES(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/packed_depth_stencil.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/packed_depth_stencil.py new file mode 100644 index 00000000..32ff819f --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/packed_depth_stencil.py @@ -0,0 +1,61 @@ +'''OpenGL extension OES.packed_depth_stencil + +This module customises the behaviour of the +OpenGL.raw.GLES2.OES.packed_depth_stencil to provide a more +Python-friendly API + +Overview (from the spec) + + Many OpenGL implementations have chosen to interleave the depth and stencil + buffers into one buffer, often with 24 bits of depth precision and 8 bits of + stencil data. 32 bits is more than is needed for the depth buffer much of + the time; a 24-bit depth buffer, on the other hand, requires that reads and + writes of depth data be unaligned with respect to power-of-two boundaries. + On the other hand, 8 bits of stencil data is more than sufficient for most + applications, so it is only natural to pack the two buffers into a single + buffer with both depth and stencil data. OpenGL never provides direct + access to the buffers, so the OpenGL implementation can provide an interface + to applications where it appears the one merged buffer is composed of two + logical buffers. + + One disadvantage of this scheme is that OpenGL lacks any means by which this + packed data can be handled efficiently. For example, when an application + reads from the 24-bit depth buffer, using the type GL_UNSIGNED_SHORT will + lose 8 bits of data, while GL_UNSIGNED_INT has 8 too many. Both require + expensive format conversion operations. A 24-bit format would be no more + suitable, because it would also suffer from the unaligned memory accesses + that made the standalone 24-bit depth buffer an unattractive proposition in + the first place. + + If OES_depth_texture is supported, a new data format, GL_DEPTH_STENCIL_OES, + as well as a packed data type, UNSIGNED_INT_24_8_OES, together can be used + with glTex[Sub]Image2D. This provides an efficient way to supply data for a + 24-bit depth texture. When a texture with DEPTH_STENCIL_OES data is bound + for texturing, only the depth component is accessible through the texture + fetcher. + + This extension also provides a new sized internal format, + DEPTH24_STENCIL8_OES, which can be used for renderbuffer storage. When a + renderbuffer or texture image with a DEPTH_STENCIL_OES base internal format + is attached to both the depth and stencil attachment points of a framebuffer + object, then it becomes both the depth and stencil buffers of the + framebuffer. This fits nicely with hardware that interleaves both depth and + stencil data into a single buffer. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/OES/packed_depth_stencil.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.OES.packed_depth_stencil import * +from OpenGL.raw.GLES2.OES.packed_depth_stencil import _EXTENSION_NAME + +def glInitPackedDepthStencilOES(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/primitive_bounding_box.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/primitive_bounding_box.py new file mode 100644 index 00000000..f747fdf4 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/primitive_bounding_box.py @@ -0,0 +1,51 @@ +'''OpenGL extension OES.primitive_bounding_box + +This module customises the behaviour of the +OpenGL.raw.GLES2.OES.primitive_bounding_box to provide a more +Python-friendly API + +Overview (from the spec) + + On tile-based architectures, transformed primitives are generally written + out to memory before rasterization, and then read back from memory for each + tile they intersect. When geometry expands during transformation due to + tessellation or one-to-many geometry shaders, the external bandwidth + required grows proportionally. This extension provides a way for + implementations to know which tiles incoming geometry will intersect before + fully transforming (and expanding) the geometry. This allows them to only + store the unexpanded geometry in memory, and perform expansion on-chip for + each intersected tile. + + New state is added to hold an axis-aligned bounding box which is assumed to + contain any geometry submitted. An implementation is allowed to ignore any + portions of primitives outside the bounding box; thus if a primitive extends + outside of a tile into a neighboring tile that the bounding box didn't + intersect, the implementation is not required to render those portions. The + tessellation control shader is optionally able to specify a per-patch + bounding box that overrides the bounding box state for primitives generated + from that patch, in order to provide tighter bounds. + + The typical usage is that an application will have an object-space bounding + volume for a primitive or group of primitives, either calculated at runtime + or provided with the mesh by the authoring tool or content pipeline. It will + transform this volume to clip space, compute an axis-aligned bounding box + that contains the transformed bounding volume, and provide that at either + per-patch or per-draw granularity. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/OES/primitive_bounding_box.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.OES.primitive_bounding_box import * +from OpenGL.raw.GLES2.OES.primitive_bounding_box import _EXTENSION_NAME + +def glInitPrimitiveBoundingBoxOES(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/required_internalformat.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/required_internalformat.py new file mode 100644 index 00000000..97353c8f --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/required_internalformat.py @@ -0,0 +1,73 @@ +'''OpenGL extension OES.required_internalformat + +This module customises the behaviour of the +OpenGL.raw.GLES2.OES.required_internalformat to provide a more +Python-friendly API + +Overview (from the spec) + + The ES 1.1 API allows an implementation to store texture data internally + with arbitrary precision, regardless of the format and type of the data + supplied by the application. Similarly, ES allows an implementation to + choose an arbitrary precision for the internal storage of image data + allocated by glRenderbufferStorageOES. + + While this allows flexibility for implementations, it does mean that an + application does not have a reliable means to request the implementation + maintain a specific precision or to find out what precision the + implementation will maintain for a given texture or renderbuffer image. + + For reference, "Desktop" OpenGL uses the argument to + glTexImage*, glCopyTexImage* and glRenderbufferStorageEXT as a hint, + defining the particular base format and precision that the application wants + the implementation to maintain when storing the image data. Further, the + application can choose an with a different base internal + format than the source format specified by . The implementation is + not required to exactly match the precision specified by + when choosing an internal storage precision, but it is required to match the + base internal format of . + + In addition, ES 1.1 does not allow an implementation to fail a request to + glTexImage2D for any of the legal and combinations listed in + Table 3.4, even if the implementation does not natively support data stored + in that external and . However, there are no additional + requirements placed on the implementation. The ES implementation is free to + store the texture data with lower precision than originally specified, for + instance. Further, since ES removes the ability to query the texture object + to find out what internal format it chose, there is no way for the + application to find out that this has happened. + + This extension addresses the situation in two ways: + + 1) This extension introduces the ability for an application to specify + the desired "sized" internal formats for texture image allocation. + + 2) This extension guarantees to maintain at least the specified + precision of all available sized internal formats. + + An implementation that exports this extension is committing to support all + of the legal values for in Tables 3.4, 3.4.x, and 3.4.y, + subject to the extension dependencies described herein. That is to say, the + implementation is guaranteeing that choosing an argument + with a value from these tables will not cause an image allocation request to + fail. Furthermore, it is guaranteeing that for any sized internal format, + the renderbuffer or texture data will be stored with at least the precision + prescribed by the sized internal format. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/OES/required_internalformat.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.OES.required_internalformat import * +from OpenGL.raw.GLES2.OES.required_internalformat import _EXTENSION_NAME + +def glInitRequiredInternalformatOES(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/rgb8_rgba8.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/rgb8_rgba8.py new file mode 100644 index 00000000..1736c6e6 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/rgb8_rgba8.py @@ -0,0 +1,28 @@ +'''OpenGL extension OES.rgb8_rgba8 + +This module customises the behaviour of the +OpenGL.raw.GLES2.OES.rgb8_rgba8 to provide a more +Python-friendly API + +Overview (from the spec) + + This extension enables RGB8 and RGBA8 renderbuffer + storage formats + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/OES/rgb8_rgba8.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.OES.rgb8_rgba8 import * +from OpenGL.raw.GLES2.OES.rgb8_rgba8 import _EXTENSION_NAME + +def glInitRgb8Rgba8OES(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/sample_shading.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/sample_shading.py new file mode 100644 index 00000000..f0223de4 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/sample_shading.py @@ -0,0 +1,43 @@ +'''OpenGL extension OES.sample_shading + +This module customises the behaviour of the +OpenGL.raw.GLES2.OES.sample_shading to provide a more +Python-friendly API + +Overview (from the spec) + + In standard multisample rendering, an implementation is allowed to + assign the same sets of fragment shader input values to each sample. + This can cause aliasing where the fragment shader input values are + used to generate a result that doesn't antialias itself, for example + with alpha-tested transparency. + + This extension adds the ability to explicitly request that an + implementation use a minimum number of unique set of fragment + computation inputs when multisampling a pixel. Specifying such a + requirement can reduce aliasing that results from evaluating the + fragment computations too few times per pixel. + + This extension adds new global state that controls the minimum + number of samples for which attribute data is independently + interpolated. When enabled, all fragment-shading operations + are executed independently on each sample. + + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/OES/sample_shading.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.OES.sample_shading import * +from OpenGL.raw.GLES2.OES.sample_shading import _EXTENSION_NAME + +def glInitSampleShadingOES(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/sample_variables.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/sample_variables.py new file mode 100644 index 00000000..376735e0 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/sample_variables.py @@ -0,0 +1,46 @@ +'''OpenGL extension OES.sample_variables + +This module customises the behaviour of the +OpenGL.raw.GLES2.OES.sample_variables to provide a more +Python-friendly API + +Overview (from the spec) + + This extension allows fragment shaders more control over multisample + rendering. The mask of samples covered by a fragment can be read by + the shader and individual samples can be masked out. Additionally + fragment shaders can be run on individual samples and the sample's + ID and position read to allow better interaction with multisample + resources such as textures. + + In multisample rendering, an implementation is allowed to assign the + same sets of fragment shader input values to each sample, which then + allows the optimization where the shader is only evaluated once and + then distributed to the samples that have been determined to be + covered by the primitive currently being rasterized. This extension + does not change how values are interpolated, but it makes some details + of the current sample available. This means that where these features + are used (gl_SampleID and gl_SamplePosition), implementations must + run the fragment shader for each sample. + + In order to obtain per-sample interpolation on fragment inputs, either + OES_sample_shading or OES_shader_multisample_interpolation must + be used in conjunction with the features from this extension. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/OES/sample_variables.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.OES.sample_variables import * +from OpenGL.raw.GLES2.OES.sample_variables import _EXTENSION_NAME + +def glInitSampleVariablesOES(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/shader_image_atomic.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/shader_image_atomic.py new file mode 100644 index 00000000..3d82e027 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/shader_image_atomic.py @@ -0,0 +1,31 @@ +'''OpenGL extension OES.shader_image_atomic + +This module customises the behaviour of the +OpenGL.raw.GLES2.OES.shader_image_atomic to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides built-in functions allowing shaders to perform + atomic read-modify-write operations to a single level of a texture + object from any shader stage. These built-in functions are named + imageAtomic*(), and accept integer texel coordinates to identify the + texel accessed. These built-in functions extend the Images in ESSL 3.10. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/OES/shader_image_atomic.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.OES.shader_image_atomic import * +from OpenGL.raw.GLES2.OES.shader_image_atomic import _EXTENSION_NAME + +def glInitShaderImageAtomicOES(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/shader_io_blocks.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/shader_io_blocks.py new file mode 100644 index 00000000..a3252937 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/shader_io_blocks.py @@ -0,0 +1,49 @@ +'''OpenGL extension OES.shader_io_blocks + +This module customises the behaviour of the +OpenGL.raw.GLES2.OES.shader_io_blocks to provide a more +Python-friendly API + +Overview (from the spec) + + This extension extends the functionality of interface blocks to + support input and output interfaces in the OpenGL ES Shading Language. + + Input and output interface blocks are used for forming the + interfaces between vertex, tessellation control, tessellation + evaluation, geometry and fragment shaders. This accommodates passing + arrays between stages, which otherwise would require multi-dimensional + array support for tessellation control outputs and for tessellation + control, tessellation evaluation, and geometry shader inputs. + + This extension provides support for application defined + interface blocks which are used for passing application-specific + information between shader stages. + + This extension moves the built-in "per-vertex" in/out variables + to a new built-in gl_PerVertex block. This is necessary for + tessellation and geometry shaders which require a separate + instance for each vertex, but it can also be useful for vertex + shaders. + + Finally, this extension allows the redeclaration of the + gl_PerVertex block in order to reduce the set of variables that must + be passed between shaders. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/OES/shader_io_blocks.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.OES.shader_io_blocks import * +from OpenGL.raw.GLES2.OES.shader_io_blocks import _EXTENSION_NAME + +def glInitShaderIoBlocksOES(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/shader_multisample_interpolation.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/shader_multisample_interpolation.py new file mode 100644 index 00000000..7ece8786 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/shader_multisample_interpolation.py @@ -0,0 +1,42 @@ +'''OpenGL extension OES.shader_multisample_interpolation + +This module customises the behaviour of the +OpenGL.raw.GLES2.OES.shader_multisample_interpolation to provide a more +Python-friendly API + +Overview (from the spec) + + In standard multisample rendering, an implementation is allowed to + assign the same sets of fragment shader input values to each sample. + This can cause aliasing where the fragment shader input values are + used to generate a result that doesn't antialias itself, for example + with alpha-tested transparency. + + This extension adds the "sample" qualifier that can be used on vertex + outputs and fragment inputs. When the "sample" qualifier is used, the + fragment shader is invoked separately for each covered sample and + all such qualified interpolants must be evaluated at the corresponding + sample point. + + This extension provides built-in fragment shader functions to provide + fine-grained control over interpolation, including interpolating a + fragment shader input at a programmable offset relative to the pixel + center, a specific sample number, or at the centroid. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/OES/shader_multisample_interpolation.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.OES.shader_multisample_interpolation import * +from OpenGL.raw.GLES2.OES.shader_multisample_interpolation import _EXTENSION_NAME + +def glInitShaderMultisampleInterpolationOES(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/standard_derivatives.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/standard_derivatives.py new file mode 100644 index 00000000..87c6f690 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/standard_derivatives.py @@ -0,0 +1,30 @@ +'''OpenGL extension OES.standard_derivatives + +This module customises the behaviour of the +OpenGL.raw.GLES2.OES.standard_derivatives to provide a more +Python-friendly API + +Overview (from the spec) + + The standard derivative built-in functions and semantics from OpenGL 2.0 are + optional for OpenGL ES 2.0. When this extension is available, these + built-in functions are also available, as is a hint controlling the + quality/performance trade off. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/OES/standard_derivatives.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.OES.standard_derivatives import * +from OpenGL.raw.GLES2.OES.standard_derivatives import _EXTENSION_NAME + +def glInitStandardDerivativesOES(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/stencil1.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/stencil1.py new file mode 100644 index 00000000..a4147b10 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/stencil1.py @@ -0,0 +1,28 @@ +'''OpenGL extension OES.stencil1 + +This module customises the behaviour of the +OpenGL.raw.GLES2.OES.stencil1 to provide a more +Python-friendly API + +Overview (from the spec) + + This extension enables 1-bit stencil component as a valid + render buffer storage format. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/OES/stencil1.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.OES.stencil1 import * +from OpenGL.raw.GLES2.OES.stencil1 import _EXTENSION_NAME + +def glInitStencil1OES(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/stencil4.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/stencil4.py new file mode 100644 index 00000000..38356162 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/stencil4.py @@ -0,0 +1,28 @@ +'''OpenGL extension OES.stencil4 + +This module customises the behaviour of the +OpenGL.raw.GLES2.OES.stencil4 to provide a more +Python-friendly API + +Overview (from the spec) + + This extension enables 4-bit stencil component as a valid + render buffer storage format. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/OES/stencil4.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.OES.stencil4 import * +from OpenGL.raw.GLES2.OES.stencil4 import _EXTENSION_NAME + +def glInitStencil4OES(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/surfaceless_context.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/surfaceless_context.py new file mode 100644 index 00000000..78bf5477 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/surfaceless_context.py @@ -0,0 +1,33 @@ +'''OpenGL extension OES.surfaceless_context + +This module customises the behaviour of the +OpenGL.raw.GLES2.OES.surfaceless_context to provide a more +Python-friendly API + +Overview (from the spec) + + Applications that only want to render to framebuffer objects should + not need to create a throw-away EGL surface (typically a 1x1 + pbuffer) just to get a current context. The EGL extension + KHR_surfaceless_context provides a mechanism for making a context + current without a surface. This extensions specifies the behaviour + of OpenGL ES 1.x and OpenGL ES 2.0 when such a context is made + current. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/OES/surfaceless_context.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.OES.surfaceless_context import * +from OpenGL.raw.GLES2.OES.surfaceless_context import _EXTENSION_NAME + +def glInitSurfacelessContextOES(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/tessellation_point_size.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/tessellation_point_size.py new file mode 100644 index 00000000..67ff3ea7 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/tessellation_point_size.py @@ -0,0 +1,23 @@ +'''OpenGL extension OES.tessellation_point_size + +This module customises the behaviour of the +OpenGL.raw.GLES2.OES.tessellation_point_size to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/OES/tessellation_point_size.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.OES.tessellation_point_size import * +from OpenGL.raw.GLES2.OES.tessellation_point_size import _EXTENSION_NAME + +def glInitTessellationPointSizeOES(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/tessellation_shader.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/tessellation_shader.py new file mode 100644 index 00000000..68e25eda --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/tessellation_shader.py @@ -0,0 +1,100 @@ +'''OpenGL extension OES.tessellation_shader + +This module customises the behaviour of the +OpenGL.raw.GLES2.OES.tessellation_shader to provide a more +Python-friendly API + +Overview (from the spec) + + This extension introduces new tessellation stages and two new shader types + to the OpenGL ES primitive processing pipeline. These pipeline stages + operate on a new basic primitive type, called a patch. A patch consists + of a fixed-size collection of vertices, each with per-vertex attributes, + plus a number of associated per-patch attributes. Tessellation control + shaders transform an input patch specified by the application, computing + per-vertex and per-patch attributes for a new output patch. A + fixed-function tessellation primitive generator subdivides the patch, and + tessellation evaluation shaders are used to compute the position and + attributes of each vertex produced by the tessellator. + + When tessellation is active, it begins by running the optional + tessellation control shader. This shader consumes an input patch and + produces a new fixed-size output patch. The output patch consists of an + array of vertices, and a set of per-patch attributes. The per-patch + attributes include tessellation levels that control how finely the patch + will be tessellated. For each patch processed, multiple tessellation + control shader invocations are performed -- one per output patch vertex. + Each tessellation control shader invocation writes all the attributes of + its corresponding output patch vertex. A tessellation control shader may + also read the per-vertex outputs of other tessellation control shader + invocations, as well as read and write shared per-patch outputs. The + tessellation control shader invocations for a single patch effectively run + as a group. A built-in barrier() function is provided to allow + synchronization points where no shader invocation will continue until all + shader invocations have reached the barrier. + + The tessellation primitive generator then decomposes a patch into a new + set of primitives using the tessellation levels to determine how finely + tessellated the output should be. The primitive generator begins with + either a triangle or a quad, and splits each outer edge of the primitive + into a number of segments approximately equal to the corresponding element + of the outer tessellation level array. The interior of the primitive is + tessellated according to elements of the inner tessellation level array. + The primitive generator has three modes: "triangles" and "quads" split a + triangular or quad-shaped patch into a set of triangles that cover the + original patch; "isolines" splits a quad-shaped patch into a set of line + strips running across the patch horizontally. Each vertex generated by + the tessellation primitive generator is assigned a (u,v) or (u,v,w) + coordinate indicating its relative location in the subdivided triangle or + quad. + + For each vertex produced by the tessellation primitive generator, the + tessellation evaluation shader is run to compute its position and other + attributes of the vertex, using its (u,v) or (u,v,w) coordinate. When + computing final vertex attributes, the tessellation evaluation shader can + also read the attributes of any of the vertices of the patch written by + the tessellation control shader. Tessellation evaluation shader + invocations are completely independent, although all invocations for a + single patch share the same collection of input vertices and per-patch + attributes. + + The tessellator operates on vertices after they have been transformed by a + vertex shader. The primitives generated by the tessellator are passed + further down the OpenGL ES pipeline, where they can be used as inputs to + geometry shaders, transform feedback, and the rasterizer. + + The tessellation control and evaluation shaders are both optional. If + neither shader type is present, the tessellation stage has no effect. + However, if either a tessellation control or a tessellation evaluation + shader is present, the other must also be present. + + Not all tessellation shader implementations have the ability to write the + point size from a tessellation shader. Thus a second extension string and + shading language enable are provided for implementations which do + support tessellation shader point size. + + This extension relies on the OES_shader_io_blocks or EXT_shader_io_blocks + extension to provide the required functionality for declaring input and + output blocks and interfacing between shaders. + + This extension relies on the OES_gpu_shader5 or EXT_gpu_shader5 extension + to provide the 'precise' and 'fma' functionality which are necessary to + ensure crack-free tessellation. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/OES/tessellation_shader.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.OES.tessellation_shader import * +from OpenGL.raw.GLES2.OES.tessellation_shader import _EXTENSION_NAME + +def glInitTessellationShaderOES(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/texture_3D.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/texture_3D.py new file mode 100644 index 00000000..68333fe0 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/texture_3D.py @@ -0,0 +1,48 @@ +'''OpenGL extension OES.texture_3D + +This module customises the behaviour of the +OpenGL.raw.GLES2.OES.texture_3D to provide a more +Python-friendly API + +Overview (from the spec) + + This extension adds support for 3D textures. The OpenGL ES 2.0 texture wrap + modes and mip-mapping is supported for power of two 3D textures. Mip- + mapping and texture wrap modes other than CLAMP_TO_EDGE are not supported + for non-power of two 3D textures. + + The OES_texture_npot extension, if supported, will enable mip-mapping and + other wrap modes for non-power of two 3D textures. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/OES/texture_3D.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.OES.texture_3D import * +from OpenGL.raw.GLES2.OES.texture_3D import _EXTENSION_NAME + +def glInitTexture3DOES(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glTexImage3DOES.pixels size not checked against 'format,type,width,height,depth' +glTexImage3DOES=wrapper.wrapper(glTexImage3DOES).setInputArraySize( + 'pixels', None +) +# INPUT glTexSubImage3DOES.pixels size not checked against 'format,type,width,height,depth' +glTexSubImage3DOES=wrapper.wrapper(glTexSubImage3DOES).setInputArraySize( + 'pixels', None +) +# INPUT glCompressedTexImage3DOES.data size not checked against imageSize +glCompressedTexImage3DOES=wrapper.wrapper(glCompressedTexImage3DOES).setInputArraySize( + 'data', None +) +# INPUT glCompressedTexSubImage3DOES.data size not checked against imageSize +glCompressedTexSubImage3DOES=wrapper.wrapper(glCompressedTexSubImage3DOES).setInputArraySize( + 'data', None +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/texture_border_clamp.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/texture_border_clamp.py new file mode 100644 index 00000000..5069a136 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/texture_border_clamp.py @@ -0,0 +1,70 @@ +'''OpenGL extension OES.texture_border_clamp + +This module customises the behaviour of the +OpenGL.raw.GLES2.OES.texture_border_clamp to provide a more +Python-friendly API + +Overview (from the spec) + + OpenGL ES provides only a single clamping wrap mode: CLAMP_TO_EDGE. + However, the ability to clamp to a constant border color can be + useful to quickly detect texture coordinates that exceed their + expected limits or to dummy out any such accesses with transparency + or a neutral color in tiling or light maps. + + This extension defines an additional texture clamping algorithm. + CLAMP_TO_BORDER_OES clamps texture coordinates at all mipmap levels + such that NEAREST and LINEAR filters of clamped coordinates return + only the constant border color. This does not add the ability for + textures to specify borders using glTexImage2D, but only to clamp + to a constant border value set using glTexParameter and + glSamplerParameter. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/OES/texture_border_clamp.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.OES.texture_border_clamp import * +from OpenGL.raw.GLES2.OES.texture_border_clamp import _EXTENSION_NAME + +def glInitTextureBorderClampOES(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glTexParameterIivOES.params size not checked against 'pname' +glTexParameterIivOES=wrapper.wrapper(glTexParameterIivOES).setInputArraySize( + 'params', None +) +# INPUT glTexParameterIuivOES.params size not checked against 'pname' +glTexParameterIuivOES=wrapper.wrapper(glTexParameterIuivOES).setInputArraySize( + 'params', None +) +# INPUT glGetTexParameterIivOES.params size not checked against 'pname' +glGetTexParameterIivOES=wrapper.wrapper(glGetTexParameterIivOES).setInputArraySize( + 'params', None +) +# INPUT glGetTexParameterIuivOES.params size not checked against 'pname' +glGetTexParameterIuivOES=wrapper.wrapper(glGetTexParameterIuivOES).setInputArraySize( + 'params', None +) +# INPUT glSamplerParameterIivOES.param size not checked against 'pname' +glSamplerParameterIivOES=wrapper.wrapper(glSamplerParameterIivOES).setInputArraySize( + 'param', None +) +# INPUT glSamplerParameterIuivOES.param size not checked against 'pname' +glSamplerParameterIuivOES=wrapper.wrapper(glSamplerParameterIuivOES).setInputArraySize( + 'param', None +) +# INPUT glGetSamplerParameterIivOES.params size not checked against 'pname' +glGetSamplerParameterIivOES=wrapper.wrapper(glGetSamplerParameterIivOES).setInputArraySize( + 'params', None +) +# INPUT glGetSamplerParameterIuivOES.params size not checked against 'pname' +glGetSamplerParameterIuivOES=wrapper.wrapper(glGetSamplerParameterIuivOES).setInputArraySize( + 'params', None +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/texture_buffer.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/texture_buffer.py new file mode 100644 index 00000000..1b49b0a5 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/texture_buffer.py @@ -0,0 +1,63 @@ +'''OpenGL extension OES.texture_buffer + +This module customises the behaviour of the +OpenGL.raw.GLES2.OES.texture_buffer to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides a new texture type, called a buffer texture. + Buffer textures are one-dimensional arrays of texels whose storage comes + from an attached buffer object. When a buffer object is bound to a + buffer texture, a format is specified, and the data in the buffer object + is treated as an array of texels of the specified format. + + The use of a buffer object to provide storage allows the texture data to + be specified in a number of different ways: via buffer object loads + (BufferData), direct CPU writes (MapBuffer), or framebuffer readbacks to + pixel buffer objects (ReadPixels). A buffer object can also be loaded by + transform feedback, which captures + selected transformed attributes of vertices processed by the GL. Several + of these mechanisms do not require an extra data copy, which would be + required when using conventional TexImage-like entry points. + + Buffer textures do not support mipmapping, texture lookups with + normalized floating-point texture coordinates, and texture filtering of + any sort. + They can be accessed via single texel fetch operations in programmable + shaders, using a new sampler type and texel fetch function, and + access can be controlled using the same memory barrier operations + as for other texture types. + + Buffer textures are treated as (potentially large) one-dimensional + textures; the maximum texture size supported for buffer textures in the + initial implementation of this extension is 2^27 texels (note that this + extension only guarantees support for buffer textures with 2^16 texels, + but we expect most implementations to exceed that substantially). When a + buffer object is attached to a buffer texture, a size is not specified; + rather, the number of texels in the texture is taken by dividing the size + of the buffer object by the size of each texel. + + This extension also allows a sub-range of the buffer's data store to + be attached to a texture. This can be used, for example, to allow multiple + buffer textures to be backed by independent sub-ranges of the same buffer + object, or for different sub-ranges of a single buffer object to be used + for different purposes. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/OES/texture_buffer.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.OES.texture_buffer import * +from OpenGL.raw.GLES2.OES.texture_buffer import _EXTENSION_NAME + +def glInitTextureBufferOES(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/texture_compression_astc.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/texture_compression_astc.py new file mode 100644 index 00000000..30f00a2a --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/texture_compression_astc.py @@ -0,0 +1,39 @@ +'''OpenGL extension OES.texture_compression_astc + +This module customises the behaviour of the +OpenGL.raw.GLES2.OES.texture_compression_astc to provide a more +Python-friendly API + +Overview (from the spec) + + Adaptive Scalable Texture Compression (ASTC) is a new texture + compression technology that offers unprecendented flexibility, + while producing better or comparable results than existing texture + compressions at all bit rates. It includes support for 2D and 3D + textures, with low and high dynamic range, at bitrates from below + 1 bit/pixel up to 8 bits/pixel in fine steps. + + The goal of this extension is to support the full profile of the + ASTC texture compression specification. + + ASTC-compressed textures are handled in OpenGL ES and OpenGL by + adding new supported formats to the existing mechanisms for handling + compressed textures. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/OES/texture_compression_astc.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.OES.texture_compression_astc import * +from OpenGL.raw.GLES2.OES.texture_compression_astc import _EXTENSION_NAME + +def glInitTextureCompressionAstcOES(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/texture_cube_map_array.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/texture_cube_map_array.py new file mode 100644 index 00000000..ab4c4cd8 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/texture_cube_map_array.py @@ -0,0 +1,45 @@ +'''OpenGL extension OES.texture_cube_map_array + +This module customises the behaviour of the +OpenGL.raw.GLES2.OES.texture_cube_map_array to provide a more +Python-friendly API + +Overview (from the spec) + + OpenGL ES 3.1 supports two-dimensional array textures. An array texture + is an ordered set of images with the same size and format. Each image in + an array texture has a unique level. This extension expands texture + array support to include cube map textures. + + A cube map array texture is a two-dimensional array texture that may + contain many cube map layers. Each cube map layer is a unique cube map + image set. Images in a cube map array have the same size and format + limitations as two-dimensional array textures. A cube map array texture + is specified using TexImage3D or TexStorage3D in a similar manner to + two-dimensional arrays. Cube map array textures can be bound to a render + targets of a frame buffer object just as two-dimensional arrays are, + using FramebufferTextureLayer. + + When accessed by a shader, a cube map array texture acts as a single + unit. The "s", "t", "r" texture coordinates are treated as a regular + cube map texture fetch. The "q" texture is treated as an unnormalized + floating-point value identifying the layer of the cube map array + texture. Cube map array texture lookups do not filter between layers. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/OES/texture_cube_map_array.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.OES.texture_cube_map_array import * +from OpenGL.raw.GLES2.OES.texture_cube_map_array import _EXTENSION_NAME + +def glInitTextureCubeMapArrayOES(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/texture_float.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/texture_float.py new file mode 100644 index 00000000..2a38fd71 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/texture_float.py @@ -0,0 +1,41 @@ +'''OpenGL extension OES.texture_float + +This module customises the behaviour of the +OpenGL.raw.GLES2.OES.texture_float to provide a more +Python-friendly API + +Overview (from the spec) + + These extensions add texture formats with 16- (aka half float) and 32-bit + floating-point components. The 32-bit floating-point components + are in the standard IEEE float format. The 16-bit floating-point + components have 1 sign bit, 5 exponent bits, and 10 mantissa bits. + Floating-point components are clamped to the limits of the range + representable by their format. + + The OES_texture_half_float extension string indicates that the + implementation supports 16-bit floating pt texture formats. + + The OES_texture_float extension string indicates that the + implementation supports 32-bit floating pt texture formats. + + Both these extensions only require NEAREST magnification filter and + NEAREST, and NEAREST_MIPMAP_NEAREST minification filters to be supported. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/OES/texture_float.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.OES.texture_float import * +from OpenGL.raw.GLES2.OES.texture_float import _EXTENSION_NAME + +def glInitTextureFloatOES(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/texture_float_linear.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/texture_float_linear.py new file mode 100644 index 00000000..5cf28b03 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/texture_float_linear.py @@ -0,0 +1,36 @@ +'''OpenGL extension OES.texture_float_linear + +This module customises the behaviour of the +OpenGL.raw.GLES2.OES.texture_float_linear to provide a more +Python-friendly API + +Overview (from the spec) + + These extensions expand upon the OES_texture_half_float and + OES_texture_float extensions by allowing support for LINEAR + magnification filter and LINEAR, NEAREST_MIPMAP_LINEAR, + LINEAR_MIPMAP_NEAREST and LINEAR_MIPMAP_NEAREST minification + filters. + + When implemented against OpenGL ES 3.0 or later versions, the + existing sized 32-bit floating-point formats become texture-filterable, + but no new formats are added. + + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/OES/texture_float_linear.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.OES.texture_float_linear import * +from OpenGL.raw.GLES2.OES.texture_float_linear import _EXTENSION_NAME + +def glInitTextureFloatLinearOES(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/texture_half_float.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/texture_half_float.py new file mode 100644 index 00000000..ce12c336 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/texture_half_float.py @@ -0,0 +1,23 @@ +'''OpenGL extension OES.texture_half_float + +This module customises the behaviour of the +OpenGL.raw.GLES2.OES.texture_half_float to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/OES/texture_half_float.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.OES.texture_half_float import * +from OpenGL.raw.GLES2.OES.texture_half_float import _EXTENSION_NAME + +def glInitTextureHalfFloatOES(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/texture_half_float_linear.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/texture_half_float_linear.py new file mode 100644 index 00000000..c50a2463 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/texture_half_float_linear.py @@ -0,0 +1,23 @@ +'''OpenGL extension OES.texture_half_float_linear + +This module customises the behaviour of the +OpenGL.raw.GLES2.OES.texture_half_float_linear to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/OES/texture_half_float_linear.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.OES.texture_half_float_linear import * +from OpenGL.raw.GLES2.OES.texture_half_float_linear import _EXTENSION_NAME + +def glInitTextureHalfFloatLinearOES(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/texture_npot.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/texture_npot.py new file mode 100644 index 00000000..95bef1cc --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/texture_npot.py @@ -0,0 +1,40 @@ +'''OpenGL extension OES.texture_npot + +This module customises the behaviour of the +OpenGL.raw.GLES2.OES.texture_npot to provide a more +Python-friendly API + +Overview (from the spec) + + This extension adds support for the REPEAT and MIRRORED_REPEAT + texture wrap modes and the minification filters supported for + non-power of two 2D textures, cubemaps and for 3D textures, if + the OES_texture_3D extension is supported. + + Section 3.8.2 of the OpenGL ES 2.0 specification describes + rules for sampling from an incomplete texture. There were specific + rules added for non-power of two textures i.e. if the texture wrap + mode is not CLAMP_TO_EDGE or minification filter is not NEAREST or + LINEAR and the texture is a non-power-of-two texture, then sampling + the texture will return (0, 0, 0, 1). + + These rules are no longer applied by an implementation that supports + this extension. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/OES/texture_npot.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.OES.texture_npot import * +from OpenGL.raw.GLES2.OES.texture_npot import _EXTENSION_NAME + +def glInitTextureNpotOES(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/texture_stencil8.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/texture_stencil8.py new file mode 100644 index 00000000..6530bb2d --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/texture_stencil8.py @@ -0,0 +1,29 @@ +'''OpenGL extension OES.texture_stencil8 + +This module customises the behaviour of the +OpenGL.raw.GLES2.OES.texture_stencil8 to provide a more +Python-friendly API + +Overview (from the spec) + + This extension accepts STENCIL_INDEX8 as a texture internal format, and + adds STENCIL_INDEX8 to the required internal format list. This removes the + need to use renderbuffers if a stencil-only format is desired. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/OES/texture_stencil8.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.OES.texture_stencil8 import * +from OpenGL.raw.GLES2.OES.texture_stencil8 import _EXTENSION_NAME + +def glInitTextureStencil8OES(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/texture_storage_multisample_2d_array.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/texture_storage_multisample_2d_array.py new file mode 100644 index 00000000..ee446971 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/texture_storage_multisample_2d_array.py @@ -0,0 +1,30 @@ +'''OpenGL extension OES.texture_storage_multisample_2d_array + +This module customises the behaviour of the +OpenGL.raw.GLES2.OES.texture_storage_multisample_2d_array to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides support for a new type of immutable texture, + two-dimensional multisample array textures. It depends on functionality + introduced in OpenGL ES 3.1 to support two-dimensional multisample + (non-array) textures. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/OES/texture_storage_multisample_2d_array.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.OES.texture_storage_multisample_2d_array import * +from OpenGL.raw.GLES2.OES.texture_storage_multisample_2d_array import _EXTENSION_NAME + +def glInitTextureStorageMultisample2DArrayOES(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/texture_view.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/texture_view.py new file mode 100644 index 00000000..185bcfa1 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/texture_view.py @@ -0,0 +1,52 @@ +'''OpenGL extension OES.texture_view + +This module customises the behaviour of the +OpenGL.raw.GLES2.OES.texture_view to provide a more +Python-friendly API + +Overview (from the spec) + + This extension allows a texture's data store to be "viewed" in multiple + ways, either reinterpreting the data format/type as a different format/ + type with the same element size, or by clamping the mipmap level range + or array slice range. + + The goals of this extension are to avoid having these alternate views + become shared mutable containers of shared mutable objects, and to add + the views to the API in a minimally invasive way. + + No new object types are added. Conceptually, a texture object is split + into the following parts: + + - A data store holding texel data. + - State describing which portions of the data store to use, and how + to interpret the data elements. + - An embedded sampler object. + - Various other texture parameters. + + With this extension, multiple textures can share a data store and have + different state describing which portions of the data store to use and + how to interpret the data elements. The data store is refcounted and not + destroyed until the last texture sharing it is deleted. + + This extension leverages the concept of an "immutable texture". + Views can only be created of textures created with TexStorage*. + + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/OES/texture_view.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.OES.texture_view import * +from OpenGL.raw.GLES2.OES.texture_view import _EXTENSION_NAME + +def glInitTextureViewOES(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/vertex_array_object.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/vertex_array_object.py new file mode 100644 index 00000000..71dbd52b --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/vertex_array_object.py @@ -0,0 +1,39 @@ +'''OpenGL extension OES.vertex_array_object + +This module customises the behaviour of the +OpenGL.raw.GLES2.OES.vertex_array_object to provide a more +Python-friendly API + +Overview (from the spec) + + This extension introduces vertex array objects which encapsulate + vertex array states on the server side (vertex buffer objects). + These objects aim to keep pointers to vertex data and to provide + names for different sets of vertex data. Therefore applications are + allowed to rapidly switch between different sets of vertex array + state, and to easily return to the default vertex array state. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/OES/vertex_array_object.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.OES.vertex_array_object import * +from OpenGL.raw.GLES2.OES.vertex_array_object import _EXTENSION_NAME + +def glInitVertexArrayObjectOES(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glDeleteVertexArraysOES.arrays size not checked against n +glDeleteVertexArraysOES=wrapper.wrapper(glDeleteVertexArraysOES).setInputArraySize( + 'arrays', None +) +# INPUT glGenVertexArraysOES.arrays size not checked against n +glGenVertexArraysOES=wrapper.wrapper(glGenVertexArraysOES).setInputArraySize( + 'arrays', None +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/vertex_half_float.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/vertex_half_float.py new file mode 100644 index 00000000..f0be5490 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/vertex_half_float.py @@ -0,0 +1,41 @@ +'''OpenGL extension OES.vertex_half_float + +This module customises the behaviour of the +OpenGL.raw.GLES2.OES.vertex_half_float to provide a more +Python-friendly API + +Overview (from the spec) + + This extension adds a 16-bit floating pt data type (aka half float) + to vertex data specified using vertex arrays. The 16-bit floating-point + components have 1 sign bit, 5 exponent bits, and 10 mantissa bits. + + The half float data type can be very useful in specifying vertex attribute + data such as color, normals, texture coordinates etc. By using half floats + instead of floats, we reduce the memory requirements by half. Not only does + the memory footprint reduce by half, but the memory bandwidth required for + vertex transformations also reduces by the same amount approximately. + Another advantage of using half floats over short/byte data types is that we + do not needto scale the data. For example, using SHORT for texture coordinates + implies that we need to scale the input texture coordinates in the shader or + set an appropriate scale matrix as the texture matrix for fixed function pipeline. + Doing these additional scaling operations impacts vertex transformation + performance. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/OES/vertex_half_float.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.OES.vertex_half_float import * +from OpenGL.raw.GLES2.OES.vertex_half_float import _EXTENSION_NAME + +def glInitVertexHalfFloatOES(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/vertex_type_10_10_10_2.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/vertex_type_10_10_10_2.py new file mode 100644 index 00000000..5dadf9ea --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/vertex_type_10_10_10_2.py @@ -0,0 +1,34 @@ +'''OpenGL extension OES.vertex_type_10_10_10_2 + +This module customises the behaviour of the +OpenGL.raw.GLES2.OES.vertex_type_10_10_10_2 to provide a more +Python-friendly API + +Overview (from the spec) + + This extension adds the following data formats: + + Two new vertex attribute data formats: a signed 10.10.10.2 and an unsigned + 10.10.10.2 vertex data format. These vertex data formats describe a 3- or 4-tuple + stream which can be used to store normals or other attributes in a quantized + form. Normals, tangents, binormals and other vertex attributes can often be specified + at reduced precision without introducing noticeable artifacts, reducing the + amount of memory and memory bandwidth they consume. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/OES/vertex_type_10_10_10_2.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.OES.vertex_type_10_10_10_2 import * +from OpenGL.raw.GLES2.OES.vertex_type_10_10_10_2 import _EXTENSION_NAME + +def glInitVertexType1010102OES(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/viewport_array.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/viewport_array.py new file mode 100644 index 00000000..d8f68b21 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OES/viewport_array.py @@ -0,0 +1,66 @@ +'''OpenGL extension OES.viewport_array + +This module customises the behaviour of the +OpenGL.raw.GLES2.OES.viewport_array to provide a more +Python-friendly API + +Overview (from the spec) + + OpenGL ES is modeled on a pipeline of operations. The final stage in this + pipeline before rasterization is the viewport transformation. This stage + transforms vertices from view space into window coordinates and allows the + application to specify a rectangular region of screen space into which + OpenGL ES should draw primitives. Unextended OpenGL ES implementations provide a + single viewport per context. In order to draw primitives into multiple + viewports, the OpenGL ES viewport may be changed between several draw calls. + With the advent of Geometry Shaders, it has become possible for an + application to amplify geometry and produce multiple output primitives + for each primitive input to the Geometry Shader. It is possible to direct + these primitives to render into a selected render target. However, all + render targets share the same, global OpenGL ES viewport. + + This extension enhances OpenGL ES by providing a mechanism to expose multiple + viewports. Each viewport is specified as a rectangle. The destination + viewport may be selected per-primitive by the geometry shader. This allows + the Geometry Shader to produce different versions of primitives destined + for separate viewport rectangles on the same surface. Additionally, when + combined with multiple framebuffer attachments, it allows a different + viewport rectangle to be selected for each. This extension also exposes a + separate scissor rectangle for each viewport. Finally, the viewport bounds + are now floating point quantities allowing fractional pixel offsets to be + applied during the viewport transform. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/OES/viewport_array.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.OES.viewport_array import * +from OpenGL.raw.GLES2.OES.viewport_array import _EXTENSION_NAME + +def glInitViewportArrayOES(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glViewportArrayvOES.v size not checked against 'count' +glViewportArrayvOES=wrapper.wrapper(glViewportArrayvOES).setInputArraySize( + 'v', None +) +glViewportIndexedfvOES=wrapper.wrapper(glViewportIndexedfvOES).setInputArraySize( + 'v', 4 +) +# INPUT glScissorArrayvOES.v size not checked against 'count' +glScissorArrayvOES=wrapper.wrapper(glScissorArrayvOES).setInputArraySize( + 'v', None +) +glScissorIndexedvOES=wrapper.wrapper(glScissorIndexedvOES).setInputArraySize( + 'v', 4 +) +# INPUT glGetFloati_vOES.data size not checked against 'target' +glGetFloati_vOES=wrapper.wrapper(glGetFloati_vOES).setInputArraySize( + 'data', None +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/OVR/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OVR/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OVR/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/OVR/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OVR/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..bc3104cb Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OVR/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/OVR/__pycache__/multiview.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OVR/__pycache__/multiview.cpython-312.pyc new file mode 100644 index 00000000..dc012fc0 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OVR/__pycache__/multiview.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/OVR/__pycache__/multiview2.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OVR/__pycache__/multiview2.cpython-312.pyc new file mode 100644 index 00000000..083b947a Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OVR/__pycache__/multiview2.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/OVR/__pycache__/multiview_multisampled_render_to_texture.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OVR/__pycache__/multiview_multisampled_render_to_texture.cpython-312.pyc new file mode 100644 index 00000000..0149b3a0 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OVR/__pycache__/multiview_multisampled_render_to_texture.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/OVR/multiview.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OVR/multiview.py new file mode 100644 index 00000000..811cbd2e --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OVR/multiview.py @@ -0,0 +1,56 @@ +'''OpenGL extension OVR.multiview + +This module customises the behaviour of the +OpenGL.raw.GLES2.OVR.multiview to provide a more +Python-friendly API + +Overview (from the spec) + + The method of stereo rendering supported in OpenGL is currently achieved by + rendering to the two eye buffers sequentially. This typically incurs double + the application and driver overhead, despite the fact that the command + streams and render states are almost identical. + + This extension seeks to address the inefficiency of sequential multiview + rendering by adding a means to render to multiple elements of a 2D texture + array simultaneously. In multiview rendering, draw calls are instanced into + each corresponding element of the texture array. The vertex program uses a + new gl_ViewID_OVR variable to compute per-view values, typically the vertex + position and view-dependent variables like reflection. + + The formulation of this extension is high level in order to allow + implementation freedom. On existing hardware, applications and drivers can + realize the benefits of a single scene traversal, even if all GPU work is + fully duplicated per-view. But future support could enable simultaneous + rendering via multi-GPU, tile-based architectures could sort geometry into + tiles for multiple views in a single pass, and the implementation could even + choose to interleave at the fragment level for better texture cache + utilization and more coherent fragment shader branching. + + The most obvious use case in this model is to support two simultaneous + views: one view for each eye. However, we also anticipate a usage where two + views are rendered per eye, where one has a wide field of view and the other + has a narrow one. The nature of wide field of view planar projection is + that the sample density can become unacceptably low in the view direction. + By rendering two inset eye views per eye, we can get the required sample + density in the center of projection without wasting samples, memory, and + time by oversampling in the periphery. + + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/OVR/multiview.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.OVR.multiview import * +from OpenGL.raw.GLES2.OVR.multiview import _EXTENSION_NAME + +def glInitMultiviewOVR(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/OVR/multiview2.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OVR/multiview2.py new file mode 100644 index 00000000..1b147010 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OVR/multiview2.py @@ -0,0 +1,30 @@ +'''OpenGL extension OVR.multiview2 + +This module customises the behaviour of the +OpenGL.raw.GLES2.OVR.multiview2 to provide a more +Python-friendly API + +Overview (from the spec) + + + This extension relaxes the restriction in OVR_multiview that only gl_Position + can depend on ViewID in the vertex shader. With this change, view-dependent + outputs like reflection vectors and similar are allowed. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/OVR/multiview2.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.OVR.multiview2 import * +from OpenGL.raw.GLES2.OVR.multiview2 import _EXTENSION_NAME + +def glInitMultiview2OVR(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/OVR/multiview_multisampled_render_to_texture.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OVR/multiview_multisampled_render_to_texture.py new file mode 100644 index 00000000..b4bdbdc7 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/OVR/multiview_multisampled_render_to_texture.py @@ -0,0 +1,30 @@ +'''OpenGL extension OVR.multiview_multisampled_render_to_texture + +This module customises the behaviour of the +OpenGL.raw.GLES2.OVR.multiview_multisampled_render_to_texture to provide a more +Python-friendly API + +Overview (from the spec) + + This extension brings to multiview rendering the functionality + originally introduced in EXT_multisampled_render_to_texture. + Essentially this just means adding one new function for + multisample multiview array attachments in the framebuffer object. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/OVR/multiview_multisampled_render_to_texture.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.OVR.multiview_multisampled_render_to_texture import * +from OpenGL.raw.GLES2.OVR.multiview_multisampled_render_to_texture import _EXTENSION_NAME + +def glInitMultiviewMultisampledRenderToTextureOVR(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/QCOM/YUV_texture_gather.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/QCOM/YUV_texture_gather.py new file mode 100644 index 00000000..f83d08d2 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/QCOM/YUV_texture_gather.py @@ -0,0 +1,30 @@ +'''OpenGL extension QCOM.YUV_texture_gather + +This module customises the behaviour of the +OpenGL.raw.GLES2.QCOM.YUV_texture_gather to provide a more +Python-friendly API + +Overview (from the spec) + + Extension EXT_gpu_shader5 introduced the texture gather built-in functions. + Extension EXT_YUV_target adds the ability to sample from YUV textures, but + does not include gather functions. This extension allows gather function + to be used in combination with the YUV textures exposed in EXT_YUV_target. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/QCOM/YUV_texture_gather.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.QCOM.YUV_texture_gather import * +from OpenGL.raw.GLES2.QCOM.YUV_texture_gather import _EXTENSION_NAME + +def glInitYuvTextureGatherQCOM(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/QCOM/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/QCOM/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/QCOM/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/QCOM/__pycache__/YUV_texture_gather.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/QCOM/__pycache__/YUV_texture_gather.cpython-312.pyc new file mode 100644 index 00000000..10cb64a0 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/QCOM/__pycache__/YUV_texture_gather.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/QCOM/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/QCOM/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..7b3a2c96 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/QCOM/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/QCOM/__pycache__/alpha_test.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/QCOM/__pycache__/alpha_test.cpython-312.pyc new file mode 100644 index 00000000..909c4f6b Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/QCOM/__pycache__/alpha_test.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/QCOM/__pycache__/binning_control.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/QCOM/__pycache__/binning_control.cpython-312.pyc new file mode 100644 index 00000000..1e0da8cb Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/QCOM/__pycache__/binning_control.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/QCOM/__pycache__/driver_control.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/QCOM/__pycache__/driver_control.cpython-312.pyc new file mode 100644 index 00000000..46f2e72d Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/QCOM/__pycache__/driver_control.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/QCOM/__pycache__/extended_get.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/QCOM/__pycache__/extended_get.cpython-312.pyc new file mode 100644 index 00000000..0aeeb682 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/QCOM/__pycache__/extended_get.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/QCOM/__pycache__/extended_get2.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/QCOM/__pycache__/extended_get2.cpython-312.pyc new file mode 100644 index 00000000..d279f0d1 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/QCOM/__pycache__/extended_get2.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/QCOM/__pycache__/framebuffer_foveated.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/QCOM/__pycache__/framebuffer_foveated.cpython-312.pyc new file mode 100644 index 00000000..b02e63a2 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/QCOM/__pycache__/framebuffer_foveated.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/QCOM/__pycache__/perfmon_global_mode.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/QCOM/__pycache__/perfmon_global_mode.cpython-312.pyc new file mode 100644 index 00000000..bfd7f4a1 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/QCOM/__pycache__/perfmon_global_mode.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/QCOM/__pycache__/shader_framebuffer_fetch_noncoherent.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/QCOM/__pycache__/shader_framebuffer_fetch_noncoherent.cpython-312.pyc new file mode 100644 index 00000000..5f6aa6a0 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/QCOM/__pycache__/shader_framebuffer_fetch_noncoherent.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/QCOM/__pycache__/shader_framebuffer_fetch_rate.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/QCOM/__pycache__/shader_framebuffer_fetch_rate.cpython-312.pyc new file mode 100644 index 00000000..75e5e57e Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/QCOM/__pycache__/shader_framebuffer_fetch_rate.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/QCOM/__pycache__/texture_foveated.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/QCOM/__pycache__/texture_foveated.cpython-312.pyc new file mode 100644 index 00000000..86adfc33 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/QCOM/__pycache__/texture_foveated.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/QCOM/__pycache__/texture_foveated_subsampled_layout.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/QCOM/__pycache__/texture_foveated_subsampled_layout.cpython-312.pyc new file mode 100644 index 00000000..3ca43c6a Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/QCOM/__pycache__/texture_foveated_subsampled_layout.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/QCOM/__pycache__/tiled_rendering.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/QCOM/__pycache__/tiled_rendering.cpython-312.pyc new file mode 100644 index 00000000..4f161f28 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/QCOM/__pycache__/tiled_rendering.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/QCOM/__pycache__/writeonly_rendering.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/QCOM/__pycache__/writeonly_rendering.cpython-312.pyc new file mode 100644 index 00000000..539e965d Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/QCOM/__pycache__/writeonly_rendering.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/QCOM/alpha_test.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/QCOM/alpha_test.py new file mode 100644 index 00000000..dcc0ab28 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/QCOM/alpha_test.py @@ -0,0 +1,30 @@ +'''OpenGL extension QCOM.alpha_test + +This module customises the behaviour of the +OpenGL.raw.GLES2.QCOM.alpha_test to provide a more +Python-friendly API + +Overview (from the spec) + + This extension reintroduces the alpha test per-fragment operation + from OpenGL ES 1.x. Some hardware has a dedicated unit capable of + performing this operation, and it can save ALU operations in the fragment + shader by avoiding the conditional discard. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/QCOM/alpha_test.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.QCOM.alpha_test import * +from OpenGL.raw.GLES2.QCOM.alpha_test import _EXTENSION_NAME + +def glInitAlphaTestQCOM(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/QCOM/binning_control.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/QCOM/binning_control.py new file mode 100644 index 00000000..6f76b6a2 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/QCOM/binning_control.py @@ -0,0 +1,31 @@ +'''OpenGL extension QCOM.binning_control + +This module customises the behaviour of the +OpenGL.raw.GLES2.QCOM.binning_control to provide a more +Python-friendly API + +Overview (from the spec) + + This extension adds some new hints to give more control to application + developers over the driver's binning algorithm. + + Only change this state right before changing rendertargets or right after + a swap or there will be a large performance penalty. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/QCOM/binning_control.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.QCOM.binning_control import * +from OpenGL.raw.GLES2.QCOM.binning_control import _EXTENSION_NAME + +def glInitBinningControlQCOM(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/QCOM/driver_control.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/QCOM/driver_control.py new file mode 100644 index 00000000..b2b1c19e --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/QCOM/driver_control.py @@ -0,0 +1,47 @@ +'''OpenGL extension QCOM.driver_control + +This module customises the behaviour of the +OpenGL.raw.GLES2.QCOM.driver_control to provide a more +Python-friendly API + +Overview (from the spec) + + This extension exposes special control features in a driver to a + developer. A use of these controls would be to override state or + implement special modes of operation. One common example might be an + IFH or infinitely fast hardware mode. In this mode none of draw + commands would be sent to the GPU so no image would be displayed, + but all the driver software overhead would still happen thus + enabling developers to analyze driver overhead separate from GPU + performance. Some uses of this extension could invalidate future + rendering and thus should only be used by developers for debugging + and performance profiling purposes. + + The extension is general enough to allow the implementation to + choose which controls to expose and to provide a textual description + of those controls to developers. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/QCOM/driver_control.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.QCOM.driver_control import * +from OpenGL.raw.GLES2.QCOM.driver_control import _EXTENSION_NAME + +def glInitDriverControlQCOM(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glGetDriverControlsQCOM.driverControls size not checked against size +glGetDriverControlsQCOM=wrapper.wrapper(glGetDriverControlsQCOM).setInputArraySize( + 'driverControls', None +) +# INPUT glGetDriverControlStringQCOM.driverControlString size not checked against bufSize +glGetDriverControlStringQCOM=wrapper.wrapper(glGetDriverControlStringQCOM).setInputArraySize( + 'driverControlString', None +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/QCOM/extended_get.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/QCOM/extended_get.py new file mode 100644 index 00000000..aab8e99b --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/QCOM/extended_get.py @@ -0,0 +1,45 @@ +'''OpenGL extension QCOM.extended_get + +This module customises the behaviour of the +OpenGL.raw.GLES2.QCOM.extended_get to provide a more +Python-friendly API + +Overview (from the spec) + + This extension enables instrumenting the driver for debugging of OpenGL ES + applications. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/QCOM/extended_get.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.QCOM.extended_get import * +from OpenGL.raw.GLES2.QCOM.extended_get import _EXTENSION_NAME + +def glInitExtendedGetQCOM(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glExtGetBuffersQCOM.buffers size not checked against maxBuffers +glExtGetBuffersQCOM=wrapper.wrapper(glExtGetBuffersQCOM).setInputArraySize( + 'buffers', None +).setInputArraySize( + 'numBuffers', 1 +) +# INPUT glExtGetRenderbuffersQCOM.renderbuffers size not checked against maxRenderbuffers +glExtGetRenderbuffersQCOM=wrapper.wrapper(glExtGetRenderbuffersQCOM).setInputArraySize( + 'numRenderbuffers', 1 +).setInputArraySize( + 'renderbuffers', None +) +# INPUT glExtGetFramebuffersQCOM.framebuffers size not checked against maxFramebuffers +glExtGetFramebuffersQCOM=wrapper.wrapper(glExtGetFramebuffersQCOM).setInputArraySize( + 'framebuffers', None +).setInputArraySize( + 'numFramebuffers', 1 +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/QCOM/extended_get2.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/QCOM/extended_get2.py new file mode 100644 index 00000000..bbec74ae --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/QCOM/extended_get2.py @@ -0,0 +1,39 @@ +'''OpenGL extension QCOM.extended_get2 + +This module customises the behaviour of the +OpenGL.raw.GLES2.QCOM.extended_get2 to provide a more +Python-friendly API + +Overview (from the spec) + + This extension enables instrumenting the driver for debugging of OpenGL ES + applications. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/QCOM/extended_get2.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.QCOM.extended_get2 import * +from OpenGL.raw.GLES2.QCOM.extended_get2 import _EXTENSION_NAME + +def glInitExtendedGet2QCOM(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glExtGetShadersQCOM.shaders size not checked against maxShaders +glExtGetShadersQCOM=wrapper.wrapper(glExtGetShadersQCOM).setInputArraySize( + 'numShaders', 1 +).setInputArraySize( + 'shaders', None +) +# INPUT glExtGetProgramsQCOM.programs size not checked against maxPrograms +glExtGetProgramsQCOM=wrapper.wrapper(glExtGetProgramsQCOM).setInputArraySize( + 'numPrograms', 1 +).setInputArraySize( + 'programs', None +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/QCOM/framebuffer_foveated.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/QCOM/framebuffer_foveated.py new file mode 100644 index 00000000..9a1baa4f --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/QCOM/framebuffer_foveated.py @@ -0,0 +1,59 @@ +'''OpenGL extension QCOM.framebuffer_foveated + +This module customises the behaviour of the +OpenGL.raw.GLES2.QCOM.framebuffer_foveated to provide a more +Python-friendly API + +Overview (from the spec) + + Foveated rendering is a technique that aims to reduce fragment processing + workload and bandwidth by reducing the average resolution of a framebuffer. + Perceived image quality is kept high by leaving the focal point of + rendering at full resolution. + + It exists in two major forms: + + - Static foveated(lens matched) rendering: where the gaze point is + fixed with a large fovea region and designed to match up with the lens + characteristics. + - Eye-tracked foveated rendering: where the gaze point is continuously + tracked by a sensor to allow a smaller fovea region (further reducing + average resolution) + + Traditionally foveated rendering involves breaking a framebuffer's area + into smaller regions such as bins, tiles, viewports, or layers which are + rendered to individually. Each of these regions has the geometry projected + or scaled differently so that the net resolution of these layers is less + than the original framebuffer's resolution. When these regions are mapped + back to the original framebuffer, they create a rendered result with + decreased quality as pixels get further from the focal point. + + Foveated rendering is currently achieved by large modifications to an + applications render pipelines to manually implement the required geometry + amplifications, blits, and projection changes. This presents a large + implementation cost to an application developer and is generally + inefficient as it can not make use of a platforms unique hardware features + or optimized software paths. This extension aims to address these problems + by exposing foveated rendering in an explicit and vendor neutral way, and by + providing an interface with minimal changes to how an application specifies + its framebuffer. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/QCOM/framebuffer_foveated.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.QCOM.framebuffer_foveated import * +from OpenGL.raw.GLES2.QCOM.framebuffer_foveated import _EXTENSION_NAME + +def glInitFramebufferFoveatedQCOM(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +glFramebufferFoveationConfigQCOM=wrapper.wrapper(glFramebufferFoveationConfigQCOM).setInputArraySize( + 'providedFeatures', 1 +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/QCOM/perfmon_global_mode.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/QCOM/perfmon_global_mode.py new file mode 100644 index 00000000..8fe3ff11 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/QCOM/perfmon_global_mode.py @@ -0,0 +1,23 @@ +'''OpenGL extension QCOM.perfmon_global_mode + +This module customises the behaviour of the +OpenGL.raw.GLES2.QCOM.perfmon_global_mode to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/QCOM/perfmon_global_mode.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.QCOM.perfmon_global_mode import * +from OpenGL.raw.GLES2.QCOM.perfmon_global_mode import _EXTENSION_NAME + +def glInitPerfmonGlobalModeQCOM(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/QCOM/shader_framebuffer_fetch_noncoherent.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/QCOM/shader_framebuffer_fetch_noncoherent.py new file mode 100644 index 00000000..b9cbb0f2 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/QCOM/shader_framebuffer_fetch_noncoherent.py @@ -0,0 +1,39 @@ +'''OpenGL extension QCOM.shader_framebuffer_fetch_noncoherent + +This module customises the behaviour of the +OpenGL.raw.GLES2.QCOM.shader_framebuffer_fetch_noncoherent to provide a more +Python-friendly API + +Overview (from the spec) + + Existing extensions such as EXT_shader_framebuffer_fetch and + ARM_shader_framebuffer_fetch_depth_stencil allow fragment + shaders to read existing framebuffer color or depth/stencil data as input. + This extension adds support for reading those same inputs with + relaxed coherency requirements. This mode can avoid expensive + per-primitive flushes of the pixel pipeline and may offer performance + improvements in some implementations. + + When the relaxed coherency mode is enabled, reads of the framebuffer data + by the fragment shader will guarantee defined results only if each sample + is touched no more than once in any single rendering pass. The command + FramebufferFetchBarrierQCOM() is provided to indicate a boundary between + passes. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/QCOM/shader_framebuffer_fetch_noncoherent.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.QCOM.shader_framebuffer_fetch_noncoherent import * +from OpenGL.raw.GLES2.QCOM.shader_framebuffer_fetch_noncoherent import _EXTENSION_NAME + +def glInitShaderFramebufferFetchNoncoherentQCOM(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/QCOM/shader_framebuffer_fetch_rate.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/QCOM/shader_framebuffer_fetch_rate.py new file mode 100644 index 00000000..90c2cac0 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/QCOM/shader_framebuffer_fetch_rate.py @@ -0,0 +1,44 @@ +'''OpenGL extension QCOM.shader_framebuffer_fetch_rate + +This module customises the behaviour of the +OpenGL.raw.GLES2.QCOM.shader_framebuffer_fetch_rate to provide a more +Python-friendly API + +Overview (from the spec) + + When certain built-ins (e.g. gl_LastFragData, gl_LastFragStencilARM) + are referenced in the shader, the shader is required to execute at sample-rate + if the attachments are multisampled. In some use-cases executing such shaders + at fragment-rate is actually the preferred behavior. When this extension is + enabled, such GLSL shaders will execute at fragment-rate and the built-in + will return a per-fragment value. This avoids the significant performance + penalty that would otherwise be incurred with sample-rate shading. + + The following built-ins are affected when the this extension is enabled: + + gl_LastFragData (from EXT_shader_framebuffer_fetch) + gl_LastFragDepthARM (from ARM_shader_framebuffer_fetch_depth_stencil) + + The following built-ins are disallowed when this extension is enabled: + + gl_SampleID + gl_SamplePosition + interpolateAtSample() + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/QCOM/shader_framebuffer_fetch_rate.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.QCOM.shader_framebuffer_fetch_rate import * +from OpenGL.raw.GLES2.QCOM.shader_framebuffer_fetch_rate import _EXTENSION_NAME + +def glInitShaderFramebufferFetchRateQCOM(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/QCOM/texture_foveated.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/QCOM/texture_foveated.py new file mode 100644 index 00000000..bde88a77 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/QCOM/texture_foveated.py @@ -0,0 +1,57 @@ +'''OpenGL extension QCOM.texture_foveated + +This module customises the behaviour of the +OpenGL.raw.GLES2.QCOM.texture_foveated to provide a more +Python-friendly API + +Overview (from the spec) + + Foveated rendering is a technique that aims to reduce fragment processing + workload and bandwidth by reducing the average resolution of a render target. + Perceived image quality is kept high by leaving the focal point of + rendering at full resolution. + + It exists in two major forms: + + - Static foveated (lens matched) rendering: where the gaze point is + fixed with a large fovea region and designed to match up with the lens + characteristics. + - Eye-tracked foveated rendering: where the gaze point is continuously + tracked by a sensor to allow a smaller fovea region (further reducing + average resolution) + + Traditionally foveated rendering involves breaking a render target's area + into smaller regions such as bins, tiles, viewports, or layers which are + rendered to individually. Each of these regions has the geometry projected + or scaled differently so that the net resolution of these layers is less + than the original render target's resolution. When these regions are mapped + back to the original render target, they create a rendered result with + decreased quality as pixels get further from the focal point. + + Foveated rendering is currently achieved by large modifications to an + applications render pipelines to manually implement the required geometry + amplifications, blits, and projection changes. This presents a large + implementation cost to an application developer and is generally + inefficient as it can not make use of a platforms unique hardware features + or optimized software paths. This extension aims to address these problems + by exposing foveated rendering in an explicit and vendor neutral way, and by + providing an interface with minimal changes to how an application specifies + its render targets. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/QCOM/texture_foveated.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.QCOM.texture_foveated import * +from OpenGL.raw.GLES2.QCOM.texture_foveated import _EXTENSION_NAME + +def glInitTextureFoveatedQCOM(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/QCOM/texture_foveated_subsampled_layout.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/QCOM/texture_foveated_subsampled_layout.py new file mode 100644 index 00000000..962f5e8d --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/QCOM/texture_foveated_subsampled_layout.py @@ -0,0 +1,41 @@ +'''OpenGL extension QCOM.texture_foveated_subsampled_layout + +This module customises the behaviour of the +OpenGL.raw.GLES2.QCOM.texture_foveated_subsampled_layout to provide a more +Python-friendly API + +Overview (from the spec) + + This extension builds on QCOM_texture_foveated by introducing a new foveation + method bit that aims to reduce memory bandwidth by avoiding the upscaling that + occurred as part of the original extension. + + With the original FOVEATION_SCALED_BIN_METHOD_BIT_QCOM foveation method, + the render target in system memory is entirely populated. The lower + resolution framebuffer data is upscaled to fill the entire render target. + The subsampled layout method introduced in this extension leaves the + framebuffer data at the calculated lower density and instead samples + directly from the the lower resolution texels. + + The primary usecase this is targeting is traditional VR pipeline. The + application eye buffers would be rendered as textures with a subsampled layout + and then sampled by the warp process. Sampling from a texture with a + subsampled layout requires a new sampler layout qualifier. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/QCOM/texture_foveated_subsampled_layout.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.QCOM.texture_foveated_subsampled_layout import * +from OpenGL.raw.GLES2.QCOM.texture_foveated_subsampled_layout import _EXTENSION_NAME + +def glInitTextureFoveatedSubsampledLayoutQCOM(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/QCOM/tiled_rendering.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/QCOM/tiled_rendering.py new file mode 100644 index 00000000..352f9855 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/QCOM/tiled_rendering.py @@ -0,0 +1,99 @@ +'''OpenGL extension QCOM.tiled_rendering + +This module customises the behaviour of the +OpenGL.raw.GLES2.QCOM.tiled_rendering to provide a more +Python-friendly API + +Overview (from the spec) + + In the handheld graphics space, a typical challenge is achieving efficient + rendering performance given the different characteristics of the various + types of graphics memory. Some types of memory ("slow" memory) are less + expensive but have low bandwidth, higher latency, and/or higher power + consumption, while other types ("fast" memory) are more expensive but have + higher bandwidth, lower latency, and/or lower power consumption. In many + cases, it is more efficient for a graphics processing unit (GPU) to render + directly to fast memory, but at most common display resolutions it is not + practical for a device to contain enough fast memory to accommodate both the + full color and depth/stencil buffers (the frame buffer). In some devices, + this problem can be addressed by providing both types of memory; a large + amount of slow memory that is sufficient to store the entire frame buffer, + and a small, dedicated amount of fast memory that allows the GPU to render + with optimal performance. The challenge lies in finding a way for the GPU + to render to fast memory when it is not large enough to contain the actual + frame buffer. + + One approach to solving this problem is to design the GPU and/or driver + using a tiled rendering architecture. With this approach the render target + is subdivided into a number of individual tiles, which are sized to fit + within the available amount of fast memory. Under normal operation, the + entire scene will be rendered to each individual tile using a multi-pass + technique, in which primitives that lie entirely outside of the tile being + rendered are trivially discarded. After each tile has been rendered, its + contents are saved out to the actual frame buffer in slow memory (a process + referred to as the "resolve"). The resolve introduces significant overhead, + both for the CPU and the GPU. However, even with this additional overhead, + rendering using this method is usually more efficient than rendering + directly to slow memory. + + This extension allows the application to specify a rectangular tile + rendering area and have full control over the resolves for that area. The + information given to the driver through this API can be used to perform + various optimizations in the driver and hardware. One example optimization + is being able to reduce the size or number of the resolves. Another + optimization might be to reduce the number of passes needed in the tiling + approach mentioned above. Even traditional rendering GPUs that don't use + tiles may benefit from this extension depending on their implemention of + certain common GPU operations. + + One typical use case could involve an application only rendering to select + portions of the render target using this technique (which shall be referred + to as "application tiling"), leaving all other portions of the render target + untouched. Therefore, in order to preserve the contents of the untouched + portions of the render target, the application must request an EGL (or other + context management API) configuration with a non-destructive swap. A + destructive swap may only be used safely if the application renders to the + entire area of the render target during each frame (otherwise the contents + of the untouched portions of the frame buffer will be undefined). + + Additionally, care must be taken to avoid the cost of mixing rendering with + and without application tiling within a single frame. Rendering without + application tiling ("normal" rendering) is most efficient when all of the + rendering for the entire scene can be encompassed within a single resolve. + If any portions of the scene are rendered prior to that resolve (such as via + a prior resolve, or via application tiling), then that resolve becomes much + more heavyweight. When this occurs, prior to rendering each tile the fast + memory must be populated with the existing contents of the frame buffer + region corresponding to that tile. This operation can double the cost of + resolves, so it is recommended that applications avoid mixing application + tiling and normal rendering within a single frame. If both rendering + methods must be used in the same frame, then the most efficient approach is + to perform all normal rendering first, followed by rendering done with + application tiling. An implicit resolve will occur (if needed) at the start + of application tiling, so any pending normal rendering operations will be + flushed at the time application tiling is initiated. This extension + provides interfaces for the application to communicate to the driver whether + or not rendering done with application tiling depends on the existing + contents of the specified tile, and whether or not the rendered contents of + the specified tile need to be preserved upon completion. This mechanism can + be used to obtain optimal performance, e.g. when the application knows that + every pixel in a tile will be completely rendered or when the resulting + contents of the depth/stencil buffers do not need to be preserved. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/QCOM/tiled_rendering.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.QCOM.tiled_rendering import * +from OpenGL.raw.GLES2.QCOM.tiled_rendering import _EXTENSION_NAME + +def glInitTiledRenderingQCOM(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/QCOM/writeonly_rendering.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/QCOM/writeonly_rendering.py new file mode 100644 index 00000000..61f2160e --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/QCOM/writeonly_rendering.py @@ -0,0 +1,26 @@ +'''OpenGL extension QCOM.writeonly_rendering + +This module customises the behaviour of the +OpenGL.raw.GLES2.QCOM.writeonly_rendering to provide a more +Python-friendly API + +Overview (from the spec) + + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/QCOM/writeonly_rendering.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.QCOM.writeonly_rendering import * +from OpenGL.raw.GLES2.QCOM.writeonly_rendering import _EXTENSION_NAME + +def glInitWriteonlyRenderingQCOM(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/VERSION/GLES2_2_0.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/VERSION/GLES2_2_0.py new file mode 100644 index 00000000..cb4182ed --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/VERSION/GLES2_2_0.py @@ -0,0 +1,450 @@ +'''OpenGL extension VERSION.GLES2_2_0 + +This module customises the behaviour of the +OpenGL.raw.GLES2.VERSION.GLES2_2_0 to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/VERSION/GLES2_2_0.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.VERSION.GLES2_2_0 import * +from OpenGL.raw.GLES2.VERSION.GLES2_2_0 import _EXTENSION_NAME + +def glInitGles220VERSION(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glBufferData.data size not checked against size +glBufferData=wrapper.wrapper(glBufferData).setInputArraySize( + 'data', None +) +# INPUT glBufferSubData.data size not checked against size +glBufferSubData=wrapper.wrapper(glBufferSubData).setInputArraySize( + 'data', None +) +# INPUT glCompressedTexImage2D.data size not checked against imageSize +glCompressedTexImage2D=wrapper.wrapper(glCompressedTexImage2D).setInputArraySize( + 'data', None +) +# INPUT glCompressedTexSubImage2D.data size not checked against imageSize +glCompressedTexSubImage2D=wrapper.wrapper(glCompressedTexSubImage2D).setInputArraySize( + 'data', None +) +# INPUT glDeleteBuffers.buffers size not checked against n +glDeleteBuffers=wrapper.wrapper(glDeleteBuffers).setInputArraySize( + 'buffers', None +) +# INPUT glDeleteFramebuffers.framebuffers size not checked against n +glDeleteFramebuffers=wrapper.wrapper(glDeleteFramebuffers).setInputArraySize( + 'framebuffers', None +) +# INPUT glDeleteRenderbuffers.renderbuffers size not checked against n +glDeleteRenderbuffers=wrapper.wrapper(glDeleteRenderbuffers).setInputArraySize( + 'renderbuffers', None +) +# INPUT glDeleteTextures.textures size not checked against n +glDeleteTextures=wrapper.wrapper(glDeleteTextures).setInputArraySize( + 'textures', None +) +# INPUT glDrawElements.indices size not checked against 'count,type' +glDrawElements=wrapper.wrapper(glDrawElements).setInputArraySize( + 'indices', None +) +glGenBuffers=wrapper.wrapper(glGenBuffers).setOutput( + 'buffers',size=lambda x:(x,),pnameArg='n',orPassIn=True +) +glGenFramebuffers=wrapper.wrapper(glGenFramebuffers).setOutput( + 'framebuffers',size=lambda x:(x,),pnameArg='n',orPassIn=True +) +glGenRenderbuffers=wrapper.wrapper(glGenRenderbuffers).setOutput( + 'renderbuffers',size=lambda x:(x,),pnameArg='n',orPassIn=True +) +glGenTextures=wrapper.wrapper(glGenTextures).setOutput( + 'textures',size=lambda x:(x,),pnameArg='n',orPassIn=True +) +glGetActiveAttrib=wrapper.wrapper(glGetActiveAttrib).setOutput( + 'length',size=(1,),orPassIn=True +).setOutput( + 'name',size=lambda x:(x,),pnameArg='bufSize',orPassIn=True +).setOutput( + 'size',size=(1,),orPassIn=True +).setOutput( + 'type',size=(1,),orPassIn=True +) +glGetActiveUniform=wrapper.wrapper(glGetActiveUniform).setOutput( + 'length',size=(1,),orPassIn=True +).setOutput( + 'name',size=lambda x:(x,),pnameArg='bufSize',orPassIn=True +).setOutput( + 'size',size=(1,),orPassIn=True +).setOutput( + 'type',size=(1,),orPassIn=True +) +# glGetAttachedShaders.obj is OUTPUT without known output size +# INPUT glGetAttachedShaders.shaders size not checked against maxCount +glGetAttachedShaders=wrapper.wrapper(glGetAttachedShaders).setOutput( + 'count',size=(1,),orPassIn=True +).setInputArraySize( + 'shaders', None +) +glGetBooleanv=wrapper.wrapper(glGetBooleanv).setOutput( + 'data',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetBufferParameteriv=wrapper.wrapper(glGetBufferParameteriv).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetFloatv=wrapper.wrapper(glGetFloatv).setOutput( + 'data',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetFramebufferAttachmentParameteriv=wrapper.wrapper(glGetFramebufferAttachmentParameteriv).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetIntegerv=wrapper.wrapper(glGetIntegerv).setOutput( + 'data',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetProgramiv=wrapper.wrapper(glGetProgramiv).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetProgramInfoLog=wrapper.wrapper(glGetProgramInfoLog).setOutput( + 'infoLog',size=lambda x:(x,),pnameArg='bufSize',orPassIn=True +).setOutput( + 'length',size=(1,),orPassIn=True +) +glGetRenderbufferParameteriv=wrapper.wrapper(glGetRenderbufferParameteriv).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetShaderiv=wrapper.wrapper(glGetShaderiv).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetShaderInfoLog=wrapper.wrapper(glGetShaderInfoLog).setOutput( + 'infoLog',size=lambda x:(x,),pnameArg='bufSize',orPassIn=True +).setOutput( + 'length',size=(1,),orPassIn=True +) +glGetShaderPrecisionFormat=wrapper.wrapper(glGetShaderPrecisionFormat).setOutput( + 'precision',size=(1,),orPassIn=True +).setOutput( + 'range',size=(2,),orPassIn=True +) +glGetShaderSource=wrapper.wrapper(glGetShaderSource).setOutput( + 'length',size=(1,),orPassIn=True +).setOutput( + 'source',size=lambda x:(x,),pnameArg='bufSize',orPassIn=True +) +glGetTexParameterfv=wrapper.wrapper(glGetTexParameterfv).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetTexParameteriv=wrapper.wrapper(glGetTexParameteriv).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +# glGetUniformfv.params is OUTPUT without known output size +# glGetUniformiv.params is OUTPUT without known output size +glGetVertexAttribfv=wrapper.wrapper(glGetVertexAttribfv).setOutput( + 'params',size=(4,),orPassIn=True +) +glGetVertexAttribiv=wrapper.wrapper(glGetVertexAttribiv).setOutput( + 'params',size=(4,),orPassIn=True +) +glGetVertexAttribPointerv=wrapper.wrapper(glGetVertexAttribPointerv).setOutput( + 'pointer',size=(1,),orPassIn=True +) +# OUTPUT glReadPixels.pixels COMPSIZE(format, type, width, height) +# INPUT glShaderBinary.binary size not checked against length +# INPUT glShaderBinary.shaders size not checked against count +glShaderBinary=wrapper.wrapper(glShaderBinary).setInputArraySize( + 'binary', None +).setInputArraySize( + 'shaders', None +) +# INPUT glShaderSource.length size not checked against count +# INPUT glShaderSource.string size not checked against count +glShaderSource=wrapper.wrapper(glShaderSource).setInputArraySize( + 'length', None +).setInputArraySize( + 'string', None +) +# INPUT glTexImage2D.pixels size not checked against 'format,type,width,height' +glTexImage2D=wrapper.wrapper(glTexImage2D).setInputArraySize( + 'pixels', None +) +# INPUT glTexParameterfv.params size not checked against 'pname' +glTexParameterfv=wrapper.wrapper(glTexParameterfv).setInputArraySize( + 'params', None +) +# INPUT glTexParameteriv.params size not checked against 'pname' +glTexParameteriv=wrapper.wrapper(glTexParameteriv).setInputArraySize( + 'params', None +) +# INPUT glTexSubImage2D.pixels size not checked against 'format,type,width,height' +glTexSubImage2D=wrapper.wrapper(glTexSubImage2D).setInputArraySize( + 'pixels', None +) +# INPUT glUniform1fv.value size not checked against count +glUniform1fv=wrapper.wrapper(glUniform1fv).setInputArraySize( + 'value', None +) +# INPUT glUniform1iv.value size not checked against count +glUniform1iv=wrapper.wrapper(glUniform1iv).setInputArraySize( + 'value', None +) +# INPUT glUniform2fv.value size not checked against count*2 +glUniform2fv=wrapper.wrapper(glUniform2fv).setInputArraySize( + 'value', None +) +# INPUT glUniform2iv.value size not checked against count*2 +glUniform2iv=wrapper.wrapper(glUniform2iv).setInputArraySize( + 'value', None +) +# INPUT glUniform3fv.value size not checked against count*3 +glUniform3fv=wrapper.wrapper(glUniform3fv).setInputArraySize( + 'value', None +) +# INPUT glUniform3iv.value size not checked against count*3 +glUniform3iv=wrapper.wrapper(glUniform3iv).setInputArraySize( + 'value', None +) +# INPUT glUniform4fv.value size not checked against count*4 +glUniform4fv=wrapper.wrapper(glUniform4fv).setInputArraySize( + 'value', None +) +# INPUT glUniform4iv.value size not checked against count*4 +glUniform4iv=wrapper.wrapper(glUniform4iv).setInputArraySize( + 'value', None +) +# INPUT glUniformMatrix2fv.value size not checked against count*4 +glUniformMatrix2fv=wrapper.wrapper(glUniformMatrix2fv).setInputArraySize( + 'value', None +) +# INPUT glUniformMatrix3fv.value size not checked against count*9 +glUniformMatrix3fv=wrapper.wrapper(glUniformMatrix3fv).setInputArraySize( + 'value', None +) +# INPUT glUniformMatrix4fv.value size not checked against count*16 +glUniformMatrix4fv=wrapper.wrapper(glUniformMatrix4fv).setInputArraySize( + 'value', None +) +glVertexAttrib1fv=wrapper.wrapper(glVertexAttrib1fv).setInputArraySize( + 'v', 1 +) +glVertexAttrib2fv=wrapper.wrapper(glVertexAttrib2fv).setInputArraySize( + 'v', 2 +) +glVertexAttrib3fv=wrapper.wrapper(glVertexAttrib3fv).setInputArraySize( + 'v', 3 +) +glVertexAttrib4fv=wrapper.wrapper(glVertexAttrib4fv).setInputArraySize( + 'v', 4 +) +# INPUT glVertexAttribPointer.pointer size not checked against 'size,type,stride' +glVertexAttribPointer=wrapper.wrapper(glVertexAttribPointer).setInputArraySize( + 'pointer', None +) +### END AUTOGENERATED SECTION +from OpenGL import converters +from OpenGL.lazywrapper import lazy as _lazy +from OpenGL._bytes import _NULL_8_BYTE +from OpenGL import contextdata + +glShaderSource = platform.createExtensionFunction( + 'glShaderSource', dll=platform.PLATFORM.GLES2, + resultType=None, + argTypes=(_types.GLhandle, _types.GLsizei, ctypes.POINTER(ctypes.c_char_p), arrays.GLintArray,), + doc = 'glShaderSource( GLhandle(shaderObj),[bytes(string),...]) -> None', + argNames = ('shaderObj', 'count', 'string', 'length',), + extension = _EXTENSION_NAME, +) + +conv = converters.StringLengths( name='string' ) +glShaderSource = wrapper.wrapper( + glShaderSource +).setPyConverter( + 'count' # number of strings +).setPyConverter( + 'length' # lengths of strings +).setPyConverter( + 'string', conv.stringArray +).setCResolver( + 'string', conv.stringArrayForC, +).setCConverter( + 'length', conv, +).setCConverter( + 'count', conv.totalCount, +) +try: + del conv +except NameError as err: + pass + + +@_lazy( glGetShaderInfoLog ) +def glGetShaderInfoLog( baseOperation, obj ): + """Retrieve the shader's error messages as a Python string + + returns string which is '' if no message + """ + target = GLsizei() + glGetShaderiv(obj, GL_INFO_LOG_LENGTH,target) + length = target.value + if length > 0: + log = ctypes.create_string_buffer(length) + baseOperation(obj, length, None, log) + return log.value.strip(_NULL_8_BYTE) # null-termination + return '' +@_lazy( glGetProgramInfoLog ) +def glGetProgramInfoLog( baseOperation, obj ): + """Retrieve the shader program's error messages as a Python string + + returns string which is '' if no message + """ + target = GLsizei() + glGetProgramiv(obj, GL_INFO_LOG_LENGTH,target) + length = target.value + if length > 0: + log = ctypes.create_string_buffer(length) + baseOperation(obj, length, None, log) + return log.value.strip(_NULL_8_BYTE) # null-termination + return '' + +@_lazy( glGetAttachedShaders ) +def glGetAttachedShaders( baseOperation, obj ): + """Retrieve the attached objects as an array of GLhandle instances""" + length= glGetProgramiv( obj, GL_ATTACHED_SHADERS ) + if length > 0: + storage = arrays.GLuintArray.zeros( (length,)) + baseOperation( obj, length, None, storage ) + return storage + return arrays.GLuintArray.zeros( (0,)) + + +@_lazy( glGetShaderSource ) +def glGetShaderSource( baseOperation, obj ): + """Retrieve the program/shader's source code as a Python string + + returns string which is '' if no source code + """ + length = int(glGetShaderiv(obj, GL_SHADER_SOURCE_LENGTH)) + if length > 0: + source = ctypes.create_string_buffer(length) + baseOperation(obj, length, None, source) + return source.value.strip(_NULL_8_BYTE) # null-termination + return '' + +@_lazy( glGetActiveUniform ) +def glGetActiveUniform(baseOperation,program, index,bufSize=None,*args): + """Retrieve the name, size and type of the uniform of the index in the program + + program -- specifies the program to be queried + index -- index of the uniform to be queried + + Following parameters are optional: + + bufSize -- determines the size of the buffer (limits number of bytes written), + if not provided, will be GL_OBJECT_ACTIVE_UNIFORM_MAX_LENGTH + length -- pointer-to-GLsizei that will hold the resulting length of the name + size -- pointer-to-GLint that will hold the size of the attribute + type -- pointer-to-GLenum that will hold the type constant of the attribute + name -- pointer-to-GLchar that will hold the (null-terminated) name string + + returns (bytes) name, (int)size, (enum)type + """ + max_index = int(glGetProgramiv( program, GL_ACTIVE_UNIFORMS )) + if bufSize is None: + bufSize = int(glGetProgramiv( program, GL_ACTIVE_UNIFORM_MAX_LENGTH)) + if index < max_index and index >= 0: + length,name,size,type = baseOperation( program, index, bufSize, *args ) + if hasattr(name,'tostring'): + name = name.tostring().rstrip(b'\000') + elif hasattr(name,'value'): + name = name.value + return name,size,type + raise IndexError( 'Index %s out of range 0 to %i' % (index, max_index - 1, ) ) + +@_lazy( glGetActiveAttrib ) +def glGetActiveAttrib(baseOperation, program, index, bufSize=None,*args): + """Retrieves information about the attribute variable. + + program -- specifies the program to be queried + index -- index of the attribute to be queried + + Following parameters are optional: + + bufSize -- determines the size of the buffer (limits number of bytes written), + if not provided, will be GL_ACTIVE_ATTRIBUTE_MAX_LENGTH + length -- pointer-to-GLsizei that will hold the resulting length of the name + size -- pointer-to-GLint that will hold the size of the attribute + type -- pointer-to-GLenum that will hold the type constant of the attribute + name -- pointer-to-GLchar that will hold the (null-terminated) name string + + returns (bytes) name, (int)size, (enum)type + """ + if bufSize is None: + bufSize = int(glGetProgramiv( program, GL_ACTIVE_ATTRIBUTE_MAX_LENGTH)) + if bufSize <= 0: + raise RuntimeError( 'Active attribute length reported', bufsize ) + name,size,type = baseOperation( program, index, bufSize, *args )[1:] + if hasattr(name,'tostring'): + name = name.tostring().rstrip(b'\000') + elif hasattr(name,'value'): + name = name.value + return name,size,type + + +@_lazy( glGetUniformLocation ) +def glGetUniformLocation( baseOperation, program, name ): + """Check that name is a string with a null byte at the end of it""" + if not name: + raise ValueError( """Non-null name required""" ) + name = as_8_bit( name ) + if name[-1] != _NULL_8_BYTE: + name = name + _NULL_8_BYTE + return baseOperation( program, name ) +@_lazy( glGetAttribLocation ) +def glGetAttribLocation( baseOperation, program, name ): + """Check that name is a string with a null byte at the end of it""" + if not name: + raise ValueError( """Non-null name required""" ) + + name = as_8_bit( name ) + if name[-1] != _NULL_8_BYTE: + name = name + _NULL_8_BYTE + return baseOperation( program, name ) + +@_lazy( glVertexAttribPointer ) +def glVertexAttribPointer( + baseOperation, index, size, type, + normalized, stride, pointer, +): + """Set an attribute pointer for a given shader (index) + + index -- the index of the generic vertex to bind, see + glGetAttribLocation for retrieval of the value, + note that index is a global variable, not per-shader + size -- number of basic elements per record, 1,2,3, or 4 + type -- enum constant for data-type + normalized -- whether to perform int to float + normalization on integer-type values + stride -- stride in machine units (bytes) between + consecutive records, normally used to create + "interleaved" arrays + pointer -- data-pointer which provides the data-values, + normally a vertex-buffer-object or offset into the + same. + + This implementation stores a copy of the data-pointer + in the contextdata structure in order to prevent null- + reference errors in the renderer. + """ + array = arrays.ArrayDatatype.asArray( pointer, type ) + key = ('vertex-attrib',index) + contextdata.setValue( key, array ) + return baseOperation( + index, size, type, + normalized, stride, + arrays.ArrayDatatype.voidDataPointer( array ) + ) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/VERSION/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/VERSION/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/VERSION/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/VERSION/__pycache__/GLES2_2_0.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/VERSION/__pycache__/GLES2_2_0.cpython-312.pyc new file mode 100644 index 00000000..9da7b69c Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/VERSION/__pycache__/GLES2_2_0.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/VERSION/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/VERSION/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..f981b0c6 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/VERSION/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/VIV/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/VIV/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/VIV/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/VIV/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/VIV/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..6b30f9a1 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/VIV/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/VIV/__pycache__/shader_binary.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/VIV/__pycache__/shader_binary.cpython-312.pyc new file mode 100644 index 00000000..d0914e2a Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/VIV/__pycache__/shader_binary.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/VIV/shader_binary.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/VIV/shader_binary.py new file mode 100644 index 00000000..30609145 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/VIV/shader_binary.py @@ -0,0 +1,28 @@ +'''OpenGL extension VIV.shader_binary + +This module customises the behaviour of the +OpenGL.raw.GLES2.VIV.shader_binary to provide a more +Python-friendly API + +Overview (from the spec) + + This extension enables loading precompiled binary shaders compatible with + chips designed by Vivante Corporation. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/VIV/shader_binary.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES2 import _types, _glgets +from OpenGL.raw.GLES2.VIV.shader_binary import * +from OpenGL.raw.GLES2.VIV.shader_binary import _EXTENSION_NAME + +def glInitShaderBinaryVIV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/__init__.py new file mode 100644 index 00000000..c4f8c9d2 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/__init__.py @@ -0,0 +1,5 @@ +"""OpenGL.EGL the portable interface to GL environments""" +from OpenGL.raw.GLES2._types import * +from OpenGL.GLES2.VERSION.GLES2_2_0 import * + +from OpenGL.GLES2 import vboimplementation as _gles2_implementation diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..ae1b0c9a Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/__pycache__/shaders.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/__pycache__/shaders.cpython-312.pyc new file mode 100644 index 00000000..cc56ed36 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/__pycache__/shaders.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/__pycache__/vboimplementation.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES2/__pycache__/vboimplementation.cpython-312.pyc new file mode 100644 index 00000000..8e9b0467 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES2/__pycache__/vboimplementation.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/shaders.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/shaders.py new file mode 100644 index 00000000..d8d88688 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/shaders.py @@ -0,0 +1,164 @@ +"""Convenience module providing common shader entry points + +The point of this module is to allow client code to use +OpenGL Core names to reference shader-related operations +even if the local hardware only supports ARB extension-based +shader rendering. + +There are also two utility methods compileProgram and compileShader +which make it easy to create demos which are shader-using. +""" +import logging +logging.basicConfig() +log = logging.getLogger( __name__ ) +from OpenGL.GLES2 import * +from OpenGL._bytes import bytes,unicode,as_8_bit + +__all__ = [ + 'compileProgram', + 'compileShader', +] + +class ShaderProgram( int ): + """Integer sub-class with context-manager operation""" + def __enter__( self ): + """Start use of the program""" + glUseProgram( self ) + def __exit__( self, typ, val, tb ): + """Stop use of the program""" + glUseProgram( 0 ) + + def check_validate( self ): + """Check that the program validates + + Validation has to occur *after* linking/loading + + raises RuntimeError on failures + """ + glValidateProgram( self ) + validation = glGetProgramiv( self, GL_VALIDATE_STATUS ) + if validation == GL_FALSE: + raise RuntimeError( + """Validation failure (%s): %s"""%( + validation, + glGetProgramInfoLog( self ), + )) + return self + + def check_linked( self ): + """Check link status for this program + + raises RuntimeError on failures + """ + link_status = glGetProgramiv( self, GL_LINK_STATUS ) + if link_status == GL_FALSE: + raise RuntimeError( + """Link failure (%s): %s"""%( + link_status, + glGetProgramInfoLog( self ), + )) + return self + + def retrieve( self ): + """Attempt to retrieve binary for this compiled shader + + Note that binaries for a program are *not* generally portable, + they should be used solely for caching compiled programs for + local use; i.e. to reduce compilation overhead. + + returns (format,binaryData) for the shader program + """ + from OpenGL.raw.GL._types import GLint,GLenum + from OpenGL.arrays import GLbyteArray + size = GLint() + glGetProgramiv( self, get_program_binary.GL_PROGRAM_BINARY_LENGTH, size ) + result = GLbyteArray.zeros( (size.value,)) + size2 = GLint() + format = GLenum() + get_program_binary.glGetProgramBinary( self, size.value, size2, format, result ) + return format.value, result + def load( self, format, binary ): + """Attempt to load binary-format for a pre-compiled shader + + See notes in retrieve + """ + get_program_binary.glProgramBinary( self, format, binary, len(binary)) + self.check_validate() + self.check_linked() + return self + +def compileProgram(*shaders, **named): + """Create a new program, attach shaders and validate + + shaders -- arbitrary number of shaders to attach to the + generated program. + separable (keyword only) -- set the separable flag to allow + for partial installation of shader into the pipeline (see + glUseProgramStages) + retrievable (keyword only) -- set the retrievable flag to + allow retrieval of the program binary representation, (see + glProgramBinary, glGetProgramBinary) + + This convenience function is *not* standard OpenGL, + but it does wind up being fairly useful for demos + and the like. You may wish to copy it to your code + base to guard against PyOpenGL changes. + + Usage: + + shader = compileProgram( + compileShader( source, GL_VERTEX_SHADER ), + compileShader( source2, GL_FRAGMENT_SHADER ), + ) + glUseProgram( shader ) + + Note: + If (and only if) validation of the linked program + *passes* then the passed-in shader objects will be + deleted from the GL. + + returns ShaderProgram() (GLuint) program reference + raises RuntimeError when a link/validation failure occurs + """ + program = glCreateProgram() + if named.get('separable'): + glProgramParameteri( program, separate_shader_objects.GL_PROGRAM_SEPARABLE, GL_TRUE ) + if named.get('retrievable'): + glProgramParameteri( program, get_program_binary.GL_PROGRAM_BINARY_RETRIEVABLE_HINT, GL_TRUE ) + for shader in shaders: + glAttachShader(program, shader) + program = ShaderProgram( program ) + glLinkProgram(program) + program.check_validate() + program.check_linked() + for shader in shaders: + glDeleteShader(shader) + return program +def compileShader( source, shaderType ): + """Compile shader source of given type + + source -- GLSL source-code for the shader + shaderType -- GLenum GL_VERTEX_SHADER, GL_FRAGMENT_SHADER, etc, + + returns GLuint compiled shader reference + raises RuntimeError when a compilation failure occurs + """ + if isinstance( source, (bytes,unicode)): + source = [ source ] + source = [ as_8_bit(s) for s in source ] + shader = glCreateShader(shaderType) + glShaderSource( shader, source ) + glCompileShader( shader ) + result = glGetShaderiv( shader, GL_COMPILE_STATUS ) + if result == GL_FALSE: + # TODO: this will be wrong if the user has + # disabled traditional unpacking array support. + raise RuntimeError( + """Shader compile failure (%s): %s"""%( + result, + glGetShaderInfoLog( shader ), + ), + source, + shaderType, + ) + return shader diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES2/vboimplementation.py b/venv/lib/python3.12/site-packages/OpenGL/GLES2/vboimplementation.py new file mode 100644 index 00000000..fb7811b1 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES2/vboimplementation.py @@ -0,0 +1,20 @@ +from OpenGL.arrays import vbo +from OpenGL.GLES2.VERSION import GLES2_2_0 +from OpenGL.GLES2.OES import mapbuffer + +class Implementation( vbo.Implementation ): + """OpenGL-based implementation of VBO interfaces""" + def __init__( self ): + for name in self.EXPORTED_NAMES: + for source in [ GLES2_2_0, mapbuffer ]: + for possible in (name,name+'OES'): + try: + setattr( self, name, getattr( source, possible )) + except AttributeError as err: + pass + else: + found = True + assert found, name + if GLES2_2_0.glBufferData: + self.available = True +Implementation.register() diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES3/VERSION/GLES3_3_0.py b/venv/lib/python3.12/site-packages/OpenGL/GLES3/VERSION/GLES3_3_0.py new file mode 100644 index 00000000..d24ed5f6 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES3/VERSION/GLES3_3_0.py @@ -0,0 +1,248 @@ +'''OpenGL extension VERSION.GLES3_3_0 + +This module customises the behaviour of the +OpenGL.raw.GLES3.VERSION.GLES3_3_0 to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/VERSION/GLES3_3_0.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES3 import _types, _glgets +from OpenGL.raw.GLES3.VERSION.GLES3_3_0 import * +from OpenGL.raw.GLES3.VERSION.GLES3_3_0 import _EXTENSION_NAME + +def glInitGles330VERSION(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +# INPUT glDrawRangeElements.indices size not checked against 'count,type' +glDrawRangeElements=wrapper.wrapper(glDrawRangeElements).setInputArraySize( + 'indices', None +) +# INPUT glTexImage3D.pixels size not checked against 'format,type,width,height,depth' +glTexImage3D=wrapper.wrapper(glTexImage3D).setInputArraySize( + 'pixels', None +) +# INPUT glTexSubImage3D.pixels size not checked against 'format,type,width,height,depth' +glTexSubImage3D=wrapper.wrapper(glTexSubImage3D).setInputArraySize( + 'pixels', None +) +# INPUT glCompressedTexImage3D.data size not checked against imageSize +glCompressedTexImage3D=wrapper.wrapper(glCompressedTexImage3D).setInputArraySize( + 'data', None +) +# INPUT glCompressedTexSubImage3D.data size not checked against imageSize +glCompressedTexSubImage3D=wrapper.wrapper(glCompressedTexSubImage3D).setInputArraySize( + 'data', None +) +glGenQueries=wrapper.wrapper(glGenQueries).setOutput( + 'ids',size=lambda x:(x,),pnameArg='n',orPassIn=True +) +# INPUT glDeleteQueries.ids size not checked against n +glDeleteQueries=wrapper.wrapper(glDeleteQueries).setInputArraySize( + 'ids', None +) +glGetQueryiv=wrapper.wrapper(glGetQueryiv).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetQueryObjectuiv=wrapper.wrapper(glGetQueryObjectuiv).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetBufferPointerv=wrapper.wrapper(glGetBufferPointerv).setOutput( + 'params',size=(1,),orPassIn=True +) +# INPUT glDrawBuffers.bufs size not checked against n +glDrawBuffers=wrapper.wrapper(glDrawBuffers).setInputArraySize( + 'bufs', None +) +# INPUT glUniformMatrix2x3fv.value size not checked against count*6 +glUniformMatrix2x3fv=wrapper.wrapper(glUniformMatrix2x3fv).setInputArraySize( + 'value', None +) +# INPUT glUniformMatrix3x2fv.value size not checked against count*6 +glUniformMatrix3x2fv=wrapper.wrapper(glUniformMatrix3x2fv).setInputArraySize( + 'value', None +) +# INPUT glUniformMatrix2x4fv.value size not checked against count*8 +glUniformMatrix2x4fv=wrapper.wrapper(glUniformMatrix2x4fv).setInputArraySize( + 'value', None +) +# INPUT glUniformMatrix4x2fv.value size not checked against count*8 +glUniformMatrix4x2fv=wrapper.wrapper(glUniformMatrix4x2fv).setInputArraySize( + 'value', None +) +# INPUT glUniformMatrix3x4fv.value size not checked against count*12 +glUniformMatrix3x4fv=wrapper.wrapper(glUniformMatrix3x4fv).setInputArraySize( + 'value', None +) +# INPUT glUniformMatrix4x3fv.value size not checked against count*12 +glUniformMatrix4x3fv=wrapper.wrapper(glUniformMatrix4x3fv).setInputArraySize( + 'value', None +) +# INPUT glDeleteVertexArrays.arrays size not checked against n +glDeleteVertexArrays=wrapper.wrapper(glDeleteVertexArrays).setInputArraySize( + 'arrays', None +) +glGenVertexArrays=wrapper.wrapper(glGenVertexArrays).setOutput( + 'arrays',size=lambda x:(x,),pnameArg='n',orPassIn=True +) +glGetIntegeri_v=wrapper.wrapper(glGetIntegeri_v).setOutput( + 'data',size=_glgets._glget_size_mapping,pnameArg='target',orPassIn=True +) +# INPUT glTransformFeedbackVaryings.varyings size not checked against count +glTransformFeedbackVaryings=wrapper.wrapper(glTransformFeedbackVaryings).setInputArraySize( + 'varyings', None +) +glGetTransformFeedbackVarying=wrapper.wrapper(glGetTransformFeedbackVarying).setOutput( + 'length',size=(1,),orPassIn=True +).setOutput( + 'name',size=lambda x:(x,),pnameArg='bufSize',orPassIn=True +).setOutput( + 'size',size=(1,),orPassIn=True +).setOutput( + 'type',size=(1,),orPassIn=True +) +# INPUT glVertexAttribIPointer.pointer size not checked against 'size,type,stride' +glVertexAttribIPointer=wrapper.wrapper(glVertexAttribIPointer).setInputArraySize( + 'pointer', None +) +glGetVertexAttribIiv=wrapper.wrapper(glGetVertexAttribIiv).setOutput( + 'params',size=(1,),orPassIn=True +) +glGetVertexAttribIuiv=wrapper.wrapper(glGetVertexAttribIuiv).setOutput( + 'params',size=(1,),orPassIn=True +) +glVertexAttribI4iv=wrapper.wrapper(glVertexAttribI4iv).setInputArraySize( + 'v', 4 +) +glVertexAttribI4uiv=wrapper.wrapper(glVertexAttribI4uiv).setInputArraySize( + 'v', 4 +) +# OUTPUT glGetUniformuiv.params COMPSIZE(program, location) +# INPUT glGetFragDataLocation.name size not checked against 'name' +glGetFragDataLocation=wrapper.wrapper(glGetFragDataLocation).setInputArraySize( + 'name', None +) +# INPUT glUniform1uiv.value size not checked against count +glUniform1uiv=wrapper.wrapper(glUniform1uiv).setInputArraySize( + 'value', None +) +# INPUT glUniform2uiv.value size not checked against count*2 +glUniform2uiv=wrapper.wrapper(glUniform2uiv).setInputArraySize( + 'value', None +) +# INPUT glUniform3uiv.value size not checked against count*3 +glUniform3uiv=wrapper.wrapper(glUniform3uiv).setInputArraySize( + 'value', None +) +# INPUT glUniform4uiv.value size not checked against count*4 +glUniform4uiv=wrapper.wrapper(glUniform4uiv).setInputArraySize( + 'value', None +) +# INPUT glClearBufferiv.value size not checked against 'buffer' +glClearBufferiv=wrapper.wrapper(glClearBufferiv).setInputArraySize( + 'value', None +) +# INPUT glClearBufferuiv.value size not checked against 'buffer' +glClearBufferuiv=wrapper.wrapper(glClearBufferuiv).setInputArraySize( + 'value', None +) +# INPUT glClearBufferfv.value size not checked against 'buffer' +glClearBufferfv=wrapper.wrapper(glClearBufferfv).setInputArraySize( + 'value', None +) +# INPUT glGetUniformIndices.uniformNames size not checked against 'uniformCount' +glGetUniformIndices=wrapper.wrapper(glGetUniformIndices).setOutput( + 'uniformIndices',size=_glgets._glget_size_mapping,pnameArg='uniformCount',orPassIn=True +).setInputArraySize( + 'uniformNames', None +) +# OUTPUT glGetActiveUniformsiv.params COMPSIZE(uniformCount, pname) +# INPUT glGetActiveUniformsiv.uniformIndices size not checked against uniformCount +glGetActiveUniformsiv=wrapper.wrapper(glGetActiveUniformsiv).setInputArraySize( + 'uniformIndices', None +) +# INPUT glGetUniformBlockIndex.uniformBlockName size not checked against '' +glGetUniformBlockIndex=wrapper.wrapper(glGetUniformBlockIndex).setInputArraySize( + 'uniformBlockName', None +) +# OUTPUT glGetActiveUniformBlockiv.params COMPSIZE(program, uniformBlockIndex, pname) +glGetActiveUniformBlockName=wrapper.wrapper(glGetActiveUniformBlockName).setOutput( + 'length',size=(1,),orPassIn=True +).setOutput( + 'uniformBlockName',size=lambda x:(x,),pnameArg='bufSize',orPassIn=True +) +# INPUT glDrawElementsInstanced.indices size not checked against 'count,type' +glDrawElementsInstanced=wrapper.wrapper(glDrawElementsInstanced).setInputArraySize( + 'indices', None +) +glGetInteger64v=wrapper.wrapper(glGetInteger64v).setOutput( + 'data',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetSynciv=wrapper.wrapper(glGetSynciv).setOutput( + 'length',size=(1,),orPassIn=True +).setOutput( + 'values',size=lambda x:(x,),pnameArg='bufSize',orPassIn=True +) +glGetInteger64i_v=wrapper.wrapper(glGetInteger64i_v).setOutput( + 'data',size=_glgets._glget_size_mapping,pnameArg='target',orPassIn=True +) +glGetBufferParameteri64v=wrapper.wrapper(glGetBufferParameteri64v).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGenSamplers=wrapper.wrapper(glGenSamplers).setOutput( + 'samplers',size=lambda x:(x,),pnameArg='count',orPassIn=True +) +# INPUT glDeleteSamplers.samplers size not checked against count +glDeleteSamplers=wrapper.wrapper(glDeleteSamplers).setInputArraySize( + 'samplers', None +) +# INPUT glSamplerParameteriv.param size not checked against 'pname' +glSamplerParameteriv=wrapper.wrapper(glSamplerParameteriv).setInputArraySize( + 'param', None +) +# INPUT glSamplerParameterfv.param size not checked against 'pname' +glSamplerParameterfv=wrapper.wrapper(glSamplerParameterfv).setInputArraySize( + 'param', None +) +glGetSamplerParameteriv=wrapper.wrapper(glGetSamplerParameteriv).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetSamplerParameterfv=wrapper.wrapper(glGetSamplerParameterfv).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +# INPUT glDeleteTransformFeedbacks.ids size not checked against n +glDeleteTransformFeedbacks=wrapper.wrapper(glDeleteTransformFeedbacks).setInputArraySize( + 'ids', None +) +glGenTransformFeedbacks=wrapper.wrapper(glGenTransformFeedbacks).setOutput( + 'ids',size=lambda x:(x,),pnameArg='n',orPassIn=True +) +glGetProgramBinary=wrapper.wrapper(glGetProgramBinary).setOutput( + 'binary',size=lambda x:(x,),pnameArg='bufSize',orPassIn=True +).setOutput( + 'binaryFormat',size=(1,),orPassIn=True +).setOutput( + 'length',size=(1,),orPassIn=True +) +# INPUT glProgramBinary.binary size not checked against length +glProgramBinary=wrapper.wrapper(glProgramBinary).setInputArraySize( + 'binary', None +) +# INPUT glInvalidateFramebuffer.attachments size not checked against numAttachments +glInvalidateFramebuffer=wrapper.wrapper(glInvalidateFramebuffer).setInputArraySize( + 'attachments', None +) +# INPUT glInvalidateSubFramebuffer.attachments size not checked against numAttachments +glInvalidateSubFramebuffer=wrapper.wrapper(glInvalidateSubFramebuffer).setInputArraySize( + 'attachments', None +) +glGetInternalformativ=wrapper.wrapper(glGetInternalformativ).setOutput( + 'params',size=lambda x:(x,),pnameArg='bufSize',orPassIn=True +) +### END AUTOGENERATED SECTION + diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES3/VERSION/GLES3_3_1.py b/venv/lib/python3.12/site-packages/OpenGL/GLES3/VERSION/GLES3_3_1.py new file mode 100644 index 00000000..1527cd75 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES3/VERSION/GLES3_3_1.py @@ -0,0 +1,164 @@ +'''OpenGL extension VERSION.GLES3_3_1 + +This module customises the behaviour of the +OpenGL.raw.GLES3.VERSION.GLES3_3_1 to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/VERSION/GLES3_3_1.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLES3 import _types, _glgets +from OpenGL.raw.GLES3.VERSION.GLES3_3_1 import * +from OpenGL.raw.GLES3.VERSION.GLES3_3_1 import _EXTENSION_NAME + +def glInitGles331VERSION(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + +glGetFramebufferParameteriv=wrapper.wrapper(glGetFramebufferParameteriv).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetProgramInterfaceiv=wrapper.wrapper(glGetProgramInterfaceiv).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +# INPUT glGetProgramResourceIndex.name size not checked against 'name' +glGetProgramResourceIndex=wrapper.wrapper(glGetProgramResourceIndex).setInputArraySize( + 'name', None +) +glGetProgramResourceName=wrapper.wrapper(glGetProgramResourceName).setOutput( + 'length',size=(1,),orPassIn=True +).setOutput( + 'name',size=lambda x:(x,),pnameArg='bufSize',orPassIn=True +) +# INPUT glGetProgramResourceiv.props size not checked against propCount +glGetProgramResourceiv=wrapper.wrapper(glGetProgramResourceiv).setOutput( + 'length',size=(1,),orPassIn=True +).setOutput( + 'params',size=lambda x:(x,),pnameArg='bufSize',orPassIn=True +).setInputArraySize( + 'props', None +) +# INPUT glGetProgramResourceLocation.name size not checked against 'name' +glGetProgramResourceLocation=wrapper.wrapper(glGetProgramResourceLocation).setInputArraySize( + 'name', None +) +# INPUT glCreateShaderProgramv.strings size not checked against count +glCreateShaderProgramv=wrapper.wrapper(glCreateShaderProgramv).setInputArraySize( + 'strings', None +) +# INPUT glDeleteProgramPipelines.pipelines size not checked against n +glDeleteProgramPipelines=wrapper.wrapper(glDeleteProgramPipelines).setInputArraySize( + 'pipelines', None +) +glGenProgramPipelines=wrapper.wrapper(glGenProgramPipelines).setOutput( + 'pipelines',size=lambda x:(x,),pnameArg='n',orPassIn=True +) +glGetProgramPipelineiv=wrapper.wrapper(glGetProgramPipelineiv).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +# INPUT glProgramUniform1iv.value size not checked against count +glProgramUniform1iv=wrapper.wrapper(glProgramUniform1iv).setInputArraySize( + 'value', None +) +# INPUT glProgramUniform2iv.value size not checked against count*2 +glProgramUniform2iv=wrapper.wrapper(glProgramUniform2iv).setInputArraySize( + 'value', None +) +# INPUT glProgramUniform3iv.value size not checked against count*3 +glProgramUniform3iv=wrapper.wrapper(glProgramUniform3iv).setInputArraySize( + 'value', None +) +# INPUT glProgramUniform4iv.value size not checked against count*4 +glProgramUniform4iv=wrapper.wrapper(glProgramUniform4iv).setInputArraySize( + 'value', None +) +# INPUT glProgramUniform1uiv.value size not checked against count +glProgramUniform1uiv=wrapper.wrapper(glProgramUniform1uiv).setInputArraySize( + 'value', None +) +# INPUT glProgramUniform2uiv.value size not checked against count*2 +glProgramUniform2uiv=wrapper.wrapper(glProgramUniform2uiv).setInputArraySize( + 'value', None +) +# INPUT glProgramUniform3uiv.value size not checked against count*3 +glProgramUniform3uiv=wrapper.wrapper(glProgramUniform3uiv).setInputArraySize( + 'value', None +) +# INPUT glProgramUniform4uiv.value size not checked against count*4 +glProgramUniform4uiv=wrapper.wrapper(glProgramUniform4uiv).setInputArraySize( + 'value', None +) +# INPUT glProgramUniform1fv.value size not checked against count +glProgramUniform1fv=wrapper.wrapper(glProgramUniform1fv).setInputArraySize( + 'value', None +) +# INPUT glProgramUniform2fv.value size not checked against count*2 +glProgramUniform2fv=wrapper.wrapper(glProgramUniform2fv).setInputArraySize( + 'value', None +) +# INPUT glProgramUniform3fv.value size not checked against count*3 +glProgramUniform3fv=wrapper.wrapper(glProgramUniform3fv).setInputArraySize( + 'value', None +) +# INPUT glProgramUniform4fv.value size not checked against count*4 +glProgramUniform4fv=wrapper.wrapper(glProgramUniform4fv).setInputArraySize( + 'value', None +) +# INPUT glProgramUniformMatrix2fv.value size not checked against count*4 +glProgramUniformMatrix2fv=wrapper.wrapper(glProgramUniformMatrix2fv).setInputArraySize( + 'value', None +) +# INPUT glProgramUniformMatrix3fv.value size not checked against count*9 +glProgramUniformMatrix3fv=wrapper.wrapper(glProgramUniformMatrix3fv).setInputArraySize( + 'value', None +) +# INPUT glProgramUniformMatrix4fv.value size not checked against count*16 +glProgramUniformMatrix4fv=wrapper.wrapper(glProgramUniformMatrix4fv).setInputArraySize( + 'value', None +) +# INPUT glProgramUniformMatrix2x3fv.value size not checked against count*6 +glProgramUniformMatrix2x3fv=wrapper.wrapper(glProgramUniformMatrix2x3fv).setInputArraySize( + 'value', None +) +# INPUT glProgramUniformMatrix3x2fv.value size not checked against count*6 +glProgramUniformMatrix3x2fv=wrapper.wrapper(glProgramUniformMatrix3x2fv).setInputArraySize( + 'value', None +) +# INPUT glProgramUniformMatrix2x4fv.value size not checked against count*8 +glProgramUniformMatrix2x4fv=wrapper.wrapper(glProgramUniformMatrix2x4fv).setInputArraySize( + 'value', None +) +# INPUT glProgramUniformMatrix4x2fv.value size not checked against count*8 +glProgramUniformMatrix4x2fv=wrapper.wrapper(glProgramUniformMatrix4x2fv).setInputArraySize( + 'value', None +) +# INPUT glProgramUniformMatrix3x4fv.value size not checked against count*12 +glProgramUniformMatrix3x4fv=wrapper.wrapper(glProgramUniformMatrix3x4fv).setInputArraySize( + 'value', None +) +# INPUT glProgramUniformMatrix4x3fv.value size not checked against count*12 +glProgramUniformMatrix4x3fv=wrapper.wrapper(glProgramUniformMatrix4x3fv).setInputArraySize( + 'value', None +) +glGetProgramPipelineInfoLog=wrapper.wrapper(glGetProgramPipelineInfoLog).setOutput( + 'infoLog',size=lambda x:(x,),pnameArg='bufSize',orPassIn=True +).setOutput( + 'length',size=(1,),orPassIn=True +) +glGetBooleani_v=wrapper.wrapper(glGetBooleani_v).setOutput( + 'data',size=_glgets._glget_size_mapping,pnameArg='target',orPassIn=True +) +glGetMultisamplefv=wrapper.wrapper(glGetMultisamplefv).setOutput( + 'val',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetTexLevelParameteriv=wrapper.wrapper(glGetTexLevelParameteriv).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +glGetTexLevelParameterfv=wrapper.wrapper(glGetTexLevelParameterfv).setOutput( + 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True +) +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES3/VERSION/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/GLES3/VERSION/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES3/VERSION/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES3/VERSION/__pycache__/GLES3_3_0.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES3/VERSION/__pycache__/GLES3_3_0.cpython-312.pyc new file mode 100644 index 00000000..6cd9f33d Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES3/VERSION/__pycache__/GLES3_3_0.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES3/VERSION/__pycache__/GLES3_3_1.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES3/VERSION/__pycache__/GLES3_3_1.cpython-312.pyc new file mode 100644 index 00000000..eb9e3685 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES3/VERSION/__pycache__/GLES3_3_1.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES3/VERSION/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES3/VERSION/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..f1b0bf99 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES3/VERSION/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES3/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/GLES3/__init__.py new file mode 100644 index 00000000..dda0e4ed --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES3/__init__.py @@ -0,0 +1,5 @@ +"""OpenGL.EGL the portable interface to GL environments""" +from OpenGL.raw.GLES3._types import * +from OpenGL.GLES2.VERSION.GLES2_2_0 import * +from OpenGL.GLES3.VERSION.GLES3_3_0 import * +from OpenGL.GLES3.VERSION.GLES3_3_1 import * diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES3/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES3/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..d4b50d4a Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES3/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES3/__pycache__/vboimplementation.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLES3/__pycache__/vboimplementation.cpython-312.pyc new file mode 100644 index 00000000..f94653ba Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLES3/__pycache__/vboimplementation.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLES3/vboimplementation.py b/venv/lib/python3.12/site-packages/OpenGL/GLES3/vboimplementation.py new file mode 100644 index 00000000..1e5fa060 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLES3/vboimplementation.py @@ -0,0 +1,20 @@ +from OpenGL.arrays import vbo +from OpenGL.GLES3.VERSION import GLES3_3_0 +from OpenGL.GLES3.OES import mapbuffer + +class Implementation( vbo.Implementation ): + """OpenGL-based implementation of VBO interfaces""" + def __init__( self ): + for name in self.EXPORTED_NAMES: + for source in [ GLES3_3_0, mapbuffer ]: + for possible in (name,name+'OES'): + try: + setattr( self, name, getattr( source, possible )) + except AttributeError as err: + pass + else: + found = True + assert found, name + if GLES3_3_0.glBufferData: + self.available = True +Implementation.register() diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLU/EXT/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/GLU/EXT/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLU/EXT/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLU/EXT/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..04a6bbf1 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLU/EXT/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLU/EXT/__pycache__/nurbs_tessellator.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLU/EXT/__pycache__/nurbs_tessellator.cpython-312.pyc new file mode 100644 index 00000000..08adaa0c Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLU/EXT/__pycache__/nurbs_tessellator.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLU/EXT/__pycache__/object_space_tess.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLU/EXT/__pycache__/object_space_tess.cpython-312.pyc new file mode 100644 index 00000000..e1052aad Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLU/EXT/__pycache__/object_space_tess.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLU/EXT/nurbs_tessellator.py b/venv/lib/python3.12/site-packages/OpenGL/GLU/EXT/nurbs_tessellator.py new file mode 100644 index 00000000..884e17ff --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLU/EXT/nurbs_tessellator.py @@ -0,0 +1,25 @@ +'''GLU extension EXT.nurbs_tessellator +''' +from OpenGL import extensions +from OpenGL.raw.GL import _types +from OpenGL.raw.GLU import constants + +GLU_NURBS_BEGIN_EXT = _types.GLU_NURBS_BEGIN_EXT +GLU_NURBS_VERTEX_EXT = _types.GLU_NURBS_VERTEX_EXT +GLU_NURBS_COLOR_EXT = _types.GLU_NURBS_COLOR_EXT +GLU_NURBS_TEX_COORD_EXT = _types.GLU_NURBS_TEX_COORD_EXT +GLU_NURBS_END_EXT = _types.GLU_NURBS_END_EXT +GLU_NURBS_BEGIN_DATA_EXT = _types.GLU_NURBS_BEGIN_DATA_EXT +GLU_NURBS_VERTEX_DATA_EXT = _types.GLU_NURBS_VERTEX_DATA_EXT +GLU_NURBS_NORMAL_DATA_EXT = _types.GLU_NURBS_NORMAL_DATA_EXT +GLU_NURBS_COLOR_DATA_EXT = _types.GLU_NURBS_COLOR_DATA_EXT +GLU_NURBS_TEX_COORD_DATA_EXT = _types.GLU_NURBS_TEX_COORD_DATA_EXT +GLU_NURBS_END_DATA_EXT = _types.GLU_NURBS_END_DATA_EXT +GLU_NURBS_MODE_EXT = _types.GLU_NURBS_MODE_EXT +GLU_NURBS_TESSELLATOR_EXT = _types.GLU_NURBS_TESSELLATOR_EXT +GLU_NURBS_RENDERER_EXT = _types.GLU_NURBS_RENDERER_EXT + + +def gluInitNurbsTessellatorEXT(): + '''Return boolean indicating whether this module is available''' + return extensions.hasGLUExtension('GLU_EXT_nurbs_tessellator') diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLU/EXT/object_space_tess.py b/venv/lib/python3.12/site-packages/OpenGL/GLU/EXT/object_space_tess.py new file mode 100644 index 00000000..54db19ff --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLU/EXT/object_space_tess.py @@ -0,0 +1,12 @@ +'''GLU extension EXT.object_space_tess +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes + +GLU_OBJECT_PARAMETRIC_ERROR_EXT = constant.Constant( 'GLU_OBJECT_PARAMETRIC_ERROR_EXT', 100208 ) +GLU_OBJECT_PATH_LENGTH_EXT = constant.Constant( 'GLU_OBJECT_PATH_LENGTH_EXT', 100209) + +def gluInitObjectSpaceTessEXT(): + '''Return boolean indicating whether this module is available''' + return extensions.hasGLUExtension( 'GLU_EXT_object_space_tess' ) diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLU/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/GLU/__init__.py new file mode 100644 index 00000000..f5d7b5a4 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLU/__init__.py @@ -0,0 +1,14 @@ +"""The GLU library implementation via ctypes""" +from OpenGL import platform +from OpenGL.error import * +from OpenGL.raw.GLU import * +from OpenGL.raw.GLU.annotations import * + +from OpenGL.GLU.quadrics import * +from OpenGL.GLU.projection import * +from OpenGL.GLU.tess import * +from OpenGL.GLU.glunurbs import * +import ctypes + +gluErrorString.restype = ctypes.c_char_p +gluGetString.restype = ctypes.c_char_p \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLU/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLU/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..85fd91d0 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLU/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLU/__pycache__/glunurbs.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLU/__pycache__/glunurbs.cpython-312.pyc new file mode 100644 index 00000000..a97110a3 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLU/__pycache__/glunurbs.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLU/__pycache__/glustruct.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLU/__pycache__/glustruct.cpython-312.pyc new file mode 100644 index 00000000..3ad87f15 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLU/__pycache__/glustruct.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLU/__pycache__/projection.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLU/__pycache__/projection.cpython-312.pyc new file mode 100644 index 00000000..21b8283c Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLU/__pycache__/projection.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLU/__pycache__/quadrics.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLU/__pycache__/quadrics.cpython-312.pyc new file mode 100644 index 00000000..77b53e2a Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLU/__pycache__/quadrics.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLU/__pycache__/tess.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLU/__pycache__/tess.cpython-312.pyc new file mode 100644 index 00000000..d8fb5855 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLU/__pycache__/tess.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLU/glunurbs.py b/venv/lib/python3.12/site-packages/OpenGL/GLU/glunurbs.py new file mode 100644 index 00000000..f98f734d --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLU/glunurbs.py @@ -0,0 +1,288 @@ +"""Implementation of GLU Nurbs structure and callback methods + +Same basic pattern as seen with the gluTess* functions, just need to +add some bookkeeping to the structure class so that we can keep the +Python function references alive during the calling process. +""" +from OpenGL.raw import GLU as _simple +from OpenGL import platform, converters, wrapper +from OpenGL.GLU import glustruct +from OpenGL.lazywrapper import lazy as _lazy +from OpenGL import arrays, error +import ctypes +import weakref +from OpenGL.platform import PLATFORM +import OpenGL +from OpenGL import _configflags + +__all__ = ( + 'GLUnurbs', + 'gluNewNurbsRenderer', + 'gluNurbsCallback', + 'gluNurbsCallbackData', + 'gluNurbsCallbackDataEXT', + 'gluNurbsCurve', + 'gluNurbsSurface', + 'gluPwlCurve', +) + +# /usr/include/GL/glu.h 242 +class GLUnurbs(glustruct.GLUStruct, _simple.GLUnurbs): + """GLU Nurbs structure with oor and callback storage support + + IMPORTANT NOTE: the texture coordinate callback receives a raw ctypes + data-pointer, as without knowing what type of evaluation is being done + (1D or 2D) we cannot safely determine the size of the array to convert + it. This is a limitation of the C implementation. To convert to regular + data-pointer, just call yourNurb.ptrAsArray( ptr, size, arrays.GLfloatArray ) + with the size of data you expect. + """ + FUNCTION_TYPE = PLATFORM.functionTypeFor(PLATFORM.GLU) + CALLBACK_FUNCTION_REGISTRARS = { + # mapping from "which" to a function that should take 3 parameters, + # the nurb, the which and the function pointer... + } + CALLBACK_TYPES = { + # mapping from "which" GLU enumeration to a ctypes function type + _simple.GLU_NURBS_BEGIN: FUNCTION_TYPE( + None, _simple.GLenum + ), + _simple.GLU_NURBS_BEGIN_DATA: FUNCTION_TYPE( + None, _simple.GLenum, ctypes.POINTER(_simple.GLvoid) + ), + _simple.GLU_NURBS_VERTEX: FUNCTION_TYPE( + None, ctypes.POINTER(_simple.GLfloat) + ), + _simple.GLU_NURBS_VERTEX_DATA: FUNCTION_TYPE( + None, ctypes.POINTER(_simple.GLfloat), ctypes.POINTER(_simple.GLvoid) + ), + _simple.GLU_NURBS_NORMAL: FUNCTION_TYPE( + None, ctypes.POINTER(_simple.GLfloat) + ), + _simple.GLU_NURBS_NORMAL_DATA: FUNCTION_TYPE( + None, ctypes.POINTER(_simple.GLfloat), ctypes.POINTER(_simple.GLvoid) + ), + _simple.GLU_NURBS_COLOR: FUNCTION_TYPE( + None, ctypes.POINTER(_simple.GLfloat) + ), + _simple.GLU_NURBS_COLOR_DATA: FUNCTION_TYPE( + None, ctypes.POINTER(_simple.GLfloat), ctypes.POINTER(_simple.GLvoid) + ), + _simple.GLU_NURBS_TEXTURE_COORD: FUNCTION_TYPE( + None, ctypes.POINTER(_simple.GLfloat) + ), + _simple.GLU_NURBS_TEXTURE_COORD_DATA: FUNCTION_TYPE( + None, ctypes.POINTER(_simple.GLfloat), ctypes.POINTER(_simple.GLvoid) + ), + _simple.GLU_NURBS_END:FUNCTION_TYPE( + None + ), + _simple.GLU_NURBS_END_DATA: FUNCTION_TYPE( + None, ctypes.POINTER(_simple.GLvoid) + ), + _simple.GLU_NURBS_ERROR:FUNCTION_TYPE( + None, _simple.GLenum, + ), + } + WRAPPER_METHODS = { + _simple.GLU_NURBS_BEGIN: None, + _simple.GLU_NURBS_BEGIN_DATA: '_justOOR', + _simple.GLU_NURBS_VERTEX: '_vec3', + _simple.GLU_NURBS_VERTEX_DATA: '_vec3', + _simple.GLU_NURBS_NORMAL: '_vec3', + _simple.GLU_NURBS_NORMAL_DATA: '_vec3', + _simple.GLU_NURBS_COLOR: '_vec4', + _simple.GLU_NURBS_COLOR_DATA: '_vec4', + _simple.GLU_NURBS_TEXTURE_COORD: '_tex', + _simple.GLU_NURBS_TEXTURE_COORD_DATA: '_tex', + _simple.GLU_NURBS_END: None, + _simple.GLU_NURBS_END_DATA: '_justOOR', + _simple.GLU_NURBS_ERROR: None, + } + def _justOOR( self, function ): + """Just do OOR on the last argument...""" + def getOOR( *args ): + args = args[:-1] + (self.originalObject(args[-1]),) + return function( *args ) + return getOOR + def _vec3( self, function, size=3 ): + """Convert first arg to size-element array, do OOR on arg2 if present""" + def vec( *args ): + vec = self.ptrAsArray(args[0],size,arrays.GLfloatArray) + if len(args) > 1: + oor = self.originalObject(args[1]) + return function( vec, oor ) + else: + return function( vec ) + return vec + def _vec4( self, function ): + """Size-4 vector version...""" + return self._vec3( function, 4 ) + def _tex( self, function ): + """Texture coordinate callback + + NOTE: there is no way for *us* to tell what size the array is, you will + get back a raw data-point, not an array, as you do for all other callback + types!!! + """ + def oor( *args ): + if len(args) > 1: + oor = self.originalObject(args[1]) + return function( args[0], oor ) + else: + return function( args[0] ) + return oor + +# XXX yes, this is a side-effect... +_simple.gluNewNurbsRenderer.restype = ctypes.POINTER( GLUnurbs ) + +def _callbackWithType( funcType ): + """Get gluNurbsCallback function with set last arg-type""" + result = platform.copyBaseFunction( + _simple.gluNurbsCallback + ) + result.argtypes = [ctypes.POINTER(GLUnurbs), _simple.GLenum, funcType] + assert result.argtypes[-1] == funcType + return result + +for (c,funcType) in GLUnurbs.CALLBACK_TYPES.items(): + cb = _callbackWithType( funcType ) + GLUnurbs.CALLBACK_FUNCTION_REGISTRARS[ c ] = cb + assert funcType == GLUnurbs.CALLBACK_TYPES[c] + assert cb.argtypes[-1] == funcType +try: + del c,cb, funcType +except NameError as err: + pass + +def gluNurbsCallback( nurb, which, CallBackFunc ): + """Dispatch to the nurb's addCallback operation""" + return nurb.addCallback( which, CallBackFunc ) + +@_lazy( _simple.gluNewNurbsRenderer ) +def gluNewNurbsRenderer( baseFunction ): + """Return a new nurbs renderer for the system (dereferences pointer)""" + newSet = baseFunction() + new = newSet[0] + #new.__class__ = GLUnurbs # yes, I know, ick + return new + +@_lazy( _simple.gluNurbsCallbackData ) +def gluNurbsCallbackData( baseFunction, nurb, userData ): + """Note the Python object for use as userData by the nurb""" + return baseFunction( + nurb, nurb.noteObject( userData ) + ) + +MAX_ORDER = 8 +def checkOrder( order,knotCount,name ): + """Check that order is valid...""" + if order < 1: + raise error.GLUError( + """%s should be 1 or more, is %s"""%( name,order,) + ) + elif order > MAX_ORDER: + raise error.GLUError( + """%s should be %s or less, is %s"""%( name, MAX_ORDER, order) + ) + elif knotCount < (2*order): + raise error.GLUError( + """Knotcount must be at least 2x %s is %s should be at least %s"""%( name, knotCount, 2*order) + ) +def checkKnots( knots, name ): + """Check that knots are in ascending order""" + if len(knots): + knot = knots[0] + for next in knots[1:]: + if next < knot: + raise error.GLUError( + """%s has decreasing knot %s after %s"""%( name, next, knot ) + ) + +@_lazy( _simple.gluNurbsCallbackDataEXT ) +def gluNurbsCallbackDataEXT( baseFunction,nurb, userData ): + """Note the Python object for use as userData by the nurb""" + return baseFunction( + nurb, nurb.noteObject( userData ) + ) + +@_lazy( _simple.gluNurbsCurve ) +def gluNurbsCurve( baseFunction, nurb, knots, control, type ): + """Pythonic version of gluNurbsCurve + + Calculates knotCount, stride, and order automatically + """ + knots = arrays.GLfloatArray.asArray( knots ) + knotCount = arrays.GLfloatArray.arraySize( knots ) + control = arrays.GLfloatArray.asArray( control ) + try: + length,step = arrays.GLfloatArray.dimensions( control ) + except ValueError as err: + raise error.GLUError( """Need a 2-dimensional control array""" ) + order = knotCount - length + if _configflags.ERROR_CHECKING: + checkOrder( order, knotCount, 'order of NURBS curve') + checkKnots( knots, 'knots of NURBS curve') + return baseFunction( + nurb, knotCount, knots, step, control, order, type, + ) + +@_lazy( _simple.gluNurbsSurface ) +def gluNurbsSurface( baseFunction, nurb, sKnots, tKnots, control, type ): + """Pythonic version of gluNurbsSurface + + Calculates knotCount, stride, and order automatically + """ + sKnots = arrays.GLfloatArray.asArray( sKnots ) + sKnotCount = arrays.GLfloatArray.arraySize( sKnots ) + tKnots = arrays.GLfloatArray.asArray( tKnots ) + tKnotCount = arrays.GLfloatArray.arraySize( tKnots ) + control = arrays.GLfloatArray.asArray( control ) + + try: + length,width,step = arrays.GLfloatArray.dimensions( control ) + except ValueError as err: + raise error.GLUError( """Need a 3-dimensional control array""" ) + sOrder = sKnotCount - length + tOrder = tKnotCount - width + sStride = width*step + tStride = step + if _configflags.ERROR_CHECKING: + checkOrder( sOrder, sKnotCount, 'sOrder of NURBS surface') + checkOrder( tOrder, tKnotCount, 'tOrder of NURBS surface') + checkKnots( sKnots, 'sKnots of NURBS surface') + checkKnots( tKnots, 'tKnots of NURBS surface') + if not (sKnotCount-sOrder)*(tKnotCount-tOrder) == length*width: + raise error.GLUError( + """Invalid NURB structure""", + nurb, sKnotCount, sKnots, tKnotCount, tKnots, + sStride, tStride, control, + sOrder,tOrder, + type + ) + + result = baseFunction( + nurb, sKnotCount, sKnots, tKnotCount, tKnots, + sStride, tStride, control, + sOrder,tOrder, + type + ) + return result + +@_lazy( _simple.gluPwlCurve ) +def gluPwlCurve( baseFunction, nurb, data, type ): + """gluPwlCurve -- piece-wise linear curve within GLU context + + data -- the data-array + type -- determines number of elements/data-point + """ + data = arrays.GLfloatArray.asArray( data ) + if type == _simple.GLU_MAP1_TRIM_2: + divisor = 2 + elif type == _simple.GLU_MAP_TRIM_3: + divisor = 3 + else: + raise ValueError( """Unrecognised type constant: %s"""%(type)) + size = arrays.GLfloatArray.arraySize( data ) + size = int(size//divisor) + return baseFunction( nurb, size, data, divisor, type ) diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLU/glustruct.py b/venv/lib/python3.12/site-packages/OpenGL/GLU/glustruct.py new file mode 100644 index 00000000..d5d18b4e --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLU/glustruct.py @@ -0,0 +1,87 @@ +"""Base class for GLU callback-caching structures""" +import ctypes +import weakref +from OpenGL._bytes import long, integer_types + +class GLUStruct( object ): + """Mix-in class for GLU Structures that want to retain references to callbacks + + Also provides original-object-return for the "datapointer" style paremters + + Each sub-class must override: + CALLBACK_TYPES -- maps a "which" constant to a function type + CALLBACK_FUNCTION_REGISTRARS -- maps a "which" constant to the + registration function for functions of that type + WRAPPER_METHODS -- maps a "which" consant to a method of the structure + that produces a callable around the function which takes care of + input/output arguments, data conversions, error handling and the + like. + Creates a dictionary member dataPointers if original-object-return is used + Creates a dictionary member callbacks if callback registration is used + """ + def getAsParam( self ): + """Gets as a ctypes pointer to the underlying structure""" + return ctypes.pointer( self ) + _as_parameter_ = property( getAsParam ) + CALLBACK_TYPES = None + CALLBACK_FUNCTION_REGISTRARS = None + WRAPPER_METHODS = None + def noteObject( self, object ): + """Note object for later retrieval as a Python object pointer + + This is the registration point for "original object return", returns + a void pointer to the Python object, though this is, effectively, an + opaque value. + """ + identity = id(object) + try: + self.dataPointers[ identity ] = object + except AttributeError as err: + self.dataPointers = { identity: object } + return identity + def originalObject( self, voidPointer ): + """Given a void-pointer, try to find our original Python object""" + if isinstance( voidPointer, integer_types): + identity = voidPointer + elif voidPointer is None: + return None + else: + try: + identity = voidPointer.value + except AttributeError as err: + identity = voidPointer[0] + try: + return self.dataPointers[ identity ] + except (KeyError,AttributeError) as err: + return voidPointer + def addCallback( self, which, function ): + """Register a callback for this structure object""" + callbackType = self.CALLBACK_TYPES.get( which ) + if not callbackType: + raise ValueError( + """Don't have a registered callback type for %r"""%( + which, + ) + ) + wrapperMethod = self.WRAPPER_METHODS.get( which ) + if wrapperMethod is not None: + function = getattr(self,wrapperMethod)( function ) + cCallback = callbackType( function ) + # XXX this is ugly, query to ctypes list on how to fix it... + try: + self.CALLBACK_FUNCTION_REGISTRARS[which]( self, which, cCallback ) + except ctypes.ArgumentError as err: + err.args += (which,cCallback) + raise + #gluTessCallbackBase( self, which, cCallback) + # XXX catch errors! + if getattr( self, 'callbacks', None ) is None: + self.callbacks = {} + self.callbacks[ which ] = cCallback + return cCallback + def ptrAsArray( self, ptr, length, type ): + """Copy length values from ptr into new array of given type""" + result = type.zeros( (length,) ) + for i in range(length): + result[i] = ptr[i] + return result diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLU/projection.py b/venv/lib/python3.12/site-packages/OpenGL/GLU/projection.py new file mode 100644 index 00000000..93d2cbc2 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLU/projection.py @@ -0,0 +1,100 @@ +"""glu[Un]Project[4] convenience wrappers""" +from OpenGL.raw import GLU as _simple +from OpenGL import GL +from OpenGL.lazywrapper import lazy as _lazy +import ctypes +POINTER = ctypes.POINTER + +@_lazy( _simple.gluProject ) +def gluProject( baseFunction, objX, objY, objZ, model=None, proj=None, view=None ): + """Convenience wrapper for gluProject + + Automatically fills in the model, projection and viewing matrices + if not provided. + + returns (winX,winY,winZ) doubles + """ + if model is None: + model = GL.glGetDoublev( GL.GL_MODELVIEW_MATRIX ) + if proj is None: + proj = GL.glGetDoublev( GL.GL_PROJECTION_MATRIX ) + if view is None: + view = GL.glGetIntegerv( GL.GL_VIEWPORT ) + winX = _simple.GLdouble( 0.0 ) + winY = _simple.GLdouble( 0.0 ) + winZ = _simple.GLdouble( 0.0 ) + result = baseFunction( + objX,objY,objZ, + model,proj,view, + winX,winY,winZ, + ) + # On Ubuntu 9.10 we see a None come out of baseFunction, + # despite it having a return-type specified of GLint! + if result is not None and result != _simple.GLU_TRUE: + raise ValueError( """Projection failed!""" ) + return winX.value, winY.value, winZ.value + +@_lazy( _simple.gluUnProject ) +def gluUnProject( baseFunction, winX, winY, winZ, model=None, proj=None, view=None ): + """Convenience wrapper for gluUnProject + + Automatically fills in the model, projection and viewing matrices + if not provided. + + returns (objX,objY,objZ) doubles + """ + if model is None: + model = GL.glGetDoublev( GL.GL_MODELVIEW_MATRIX ) + if proj is None: + proj = GL.glGetDoublev( GL.GL_PROJECTION_MATRIX ) + if view is None: + view = GL.glGetIntegerv( GL.GL_VIEWPORT ) + objX = _simple.GLdouble( 0.0 ) + objY = _simple.GLdouble( 0.0 ) + objZ = _simple.GLdouble( 0.0 ) + result = baseFunction( + winX,winY,winZ, + model,proj,view, + ctypes.byref(objX),ctypes.byref(objY),ctypes.byref(objZ), + ) + if not result: + raise ValueError( """Projection failed!""" ) + return objX.value, objY.value, objZ.value +@_lazy( _simple.gluUnProject4 ) +def gluUnProject4( + baseFunction, + winX, winY, winZ, clipW, + model=None, proj=None, view=None, + near=0.0, far=1.0 +): + """Convenience wrapper for gluUnProject + + Automatically fills in the model, projection and viewing matrices + if not provided. + + returns (objX,objY,objZ) doubles + """ + if model is None: + model = GL.glGetDoublev( GL.GL_MODELVIEW_MATRIX ) + if proj is None: + proj = GL.glGetDoublev( GL.GL_PROJECTION_MATRIX ) + if view is None: + view = GL.glGetIntegerv( GL.GL_VIEWPORT ) + objX = _simple.GLdouble( 0.0 ) + objY = _simple.GLdouble( 0.0 ) + objZ = _simple.GLdouble( 0.0 ) + objW = _simple.GLdouble( 0.0 ) + result = baseFunction( + winX,winY,winZ, + model,proj,view, + ctypes.byref(objX),ctypes.byref(objY),ctypes.byref(objZ),ctypes.byref(objW) + ) + if not result: + raise ValueError( """Projection failed!""" ) + return objX.value, objY.value, objZ.value, objW.value + +__all__ = ( + 'gluProject', + 'gluUnProject', + 'gluUnProject4', +) diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLU/quadrics.py b/venv/lib/python3.12/site-packages/OpenGL/GLU/quadrics.py new file mode 100644 index 00000000..eba4de1f --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLU/quadrics.py @@ -0,0 +1,56 @@ +"""Wrapper/Implementation of the GLU quadrics object for PyOpenGL""" +from OpenGL.raw import GLU as _simple +from OpenGL.platform import createBaseFunction, PLATFORM +import ctypes + +class GLUQuadric( _simple.GLUquadric ): + """Implementation class for GLUQuadric classes in PyOpenGL""" + FUNCTION_TYPE = PLATFORM.functionTypeFor(PLATFORM.GLU) + CALLBACK_TYPES = { + # mapping from "which" GLU enumeration to a ctypes function type + _simple.GLU_ERROR : FUNCTION_TYPE( None, _simple.GLenum ) + } + def addCallback( self, which, function ): + """Register a callback for the quadric object + + At the moment only GLU_ERROR is supported by OpenGL, but + we allow for the possibility of more callbacks in the future... + """ + callbackType = self.CALLBACK_TYPES.get( which ) + if not callbackType: + raise ValueError( + """Don't have a registered callback type for %r"""%( + which, + ) + ) + if not isinstance( function, callbackType ): + cCallback = callbackType( function ) + else: + cCallback = function + PLATFORM.GLU.gluQuadricCallback( self, which, cCallback ) + # XXX catch errors! + if getattr( self, 'callbacks', None ) is None: + self.callbacks = {} + self.callbacks[ which ] = cCallback + return cCallback +GLUquadric = GLUQuadric + +def gluQuadricCallback( quadric, which=_simple.GLU_ERROR, function=None ): + """Set the GLU error callback function""" + return quadric.addCallback( which, function ) + +# Override to produce instances of the sub-class... +gluNewQuadric = createBaseFunction( + 'gluNewQuadric', dll=PLATFORM.GLU, resultType=ctypes.POINTER(GLUQuadric), + argTypes=[], + doc="""gluNewQuadric( ) -> GLUQuadric + +Create a new GLUQuadric object""", + argNames=[], +) + +__all__ = ( + 'gluNewQuadric', + 'gluQuadricCallback', + 'GLUQuadric', +) diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLU/tess.py b/venv/lib/python3.12/site-packages/OpenGL/GLU/tess.py new file mode 100644 index 00000000..cdb53cb4 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLU/tess.py @@ -0,0 +1,267 @@ +"""Wrapper/Implementation of the GLU tessellator objects for PyOpenGL""" +from OpenGL.raw import GLU as _simple +from OpenGL.raw.GL.VERSION import GL_1_1 +from OpenGL.platform import createBaseFunction +from OpenGL.GLU import glustruct +from OpenGL import arrays, wrapper +from OpenGL.platform import PLATFORM + +GLU = PLATFORM.GLU +from OpenGL.lazywrapper import lazy as _lazy +import ctypes + + +class GLUtesselator(glustruct.GLUStruct, _simple.GLUtesselator): + """Implementation class for GLUTessellator structures in OpenGL-ctypes""" + + FUNCTION_TYPE = PLATFORM.functionTypeFor(PLATFORM.GLU) + CALLBACK_TYPES = { + # mapping from "which" GLU enumeration to a ctypes function type + _simple.GLU_TESS_BEGIN: FUNCTION_TYPE(None, _simple.GLenum), + _simple.GLU_TESS_BEGIN_DATA: FUNCTION_TYPE( + None, _simple.GLenum, ctypes.c_void_p + ), + _simple.GLU_TESS_EDGE_FLAG: FUNCTION_TYPE(None, _simple.GLboolean), + _simple.GLU_TESS_EDGE_FLAG_DATA: FUNCTION_TYPE( + None, _simple.GLboolean, ctypes.c_void_p + ), + _simple.GLU_TESS_VERTEX: FUNCTION_TYPE(None, ctypes.c_void_p), + _simple.GLU_TESS_VERTEX_DATA: FUNCTION_TYPE( + None, ctypes.c_void_p, ctypes.c_void_p + ), + _simple.GLU_TESS_END: FUNCTION_TYPE(None), + _simple.GLU_TESS_END_DATA: FUNCTION_TYPE(None, ctypes.c_void_p), + _simple.GLU_TESS_COMBINE: FUNCTION_TYPE( + None, + ctypes.POINTER(_simple.GLdouble), + ctypes.POINTER(ctypes.c_void_p), + ctypes.POINTER(_simple.GLfloat), + ctypes.POINTER(ctypes.c_void_p), + ), + _simple.GLU_TESS_COMBINE_DATA: FUNCTION_TYPE( + None, + ctypes.POINTER(_simple.GLdouble), + ctypes.POINTER(ctypes.c_void_p), + ctypes.POINTER(_simple.GLfloat), + ctypes.POINTER(ctypes.c_void_p), + ctypes.c_void_p, + ), + _simple.GLU_TESS_ERROR: FUNCTION_TYPE(None, _simple.GLenum), + _simple.GLU_TESS_ERROR_DATA: FUNCTION_TYPE( + None, _simple.GLenum, ctypes.c_void_p + ), + _simple.GLU_ERROR: FUNCTION_TYPE(None, _simple.GLenum), + } + WRAPPER_METHODS = { + _simple.GLU_TESS_BEGIN_DATA: 'dataWrapper', + _simple.GLU_TESS_EDGE_FLAG_DATA: 'dataWrapper', + _simple.GLU_TESS_VERTEX: 'vertexWrapper', + _simple.GLU_TESS_VERTEX_DATA: 'vertexWrapper', + _simple.GLU_TESS_END_DATA: 'dataWrapper', + _simple.GLU_TESS_COMBINE: 'combineWrapper', + _simple.GLU_TESS_COMBINE_DATA: 'combineWrapper', + _simple.GLU_TESS_ERROR_DATA: 'dataWrapper', + } + + def gluTessVertex(self, location, data=None): + """Add a vertex to this tessellator, storing data for later lookup""" + vertexCache = getattr(self, 'vertexCache', None) + if vertexCache is None: + self.vertexCache = [] + vertexCache = self.vertexCache + location = arrays.GLdoubleArray.asArray(location, GL_1_1.GL_DOUBLE) + if arrays.GLdoubleArray.arraySize(location) != 3: + raise ValueError( + """Require 3 doubles for array location, got: %s""" % (location,) + ) + oorValue = self.noteObject(data) + vp = ctypes.c_void_p(oorValue) + self.vertexCache.append(location) + return gluTessVertexBase(self, location, vp) + + def gluTessBeginPolygon(self, data): + """Note the object pointer to return it as a Python object""" + return _simple.gluTessBeginPolygon(self, ctypes.c_void_p(self.noteObject(data))) + + def combineWrapper(self, function): + """Wrap a Python function with ctypes-compatible wrapper for combine callback + + For a Python combine callback, the signature looks like this: + def combine( + GLdouble coords[3], + void *vertex_data[4], + GLfloat weight[4] + ): + return data + While the C signature looks like this: + void combine( + GLdouble coords[3], + void *vertex_data[4], + GLfloat weight[4], + void **outData + ) + """ + if (function is not None) and (not hasattr(function, '__call__')): + raise TypeError("""Require a callable callback, got: %s""" % (function,)) + + def wrap(coords, vertex_data, weight, outData, *args): + """The run-time wrapper around the function""" + coords = self.ptrAsArray(coords, 3, arrays.GLdoubleArray) + weight = self.ptrAsArray(weight, 4, arrays.GLfloatArray) + # find the original python objects for vertex data + vertex_data = [self.originalObject(vertex_data[i]) for i in range(4)] + args = tuple([self.originalObject(x) for x in args]) + try: + result = function(coords, vertex_data, weight, *args) + except Exception as err: + raise err.__class__( + """Failure during combine callback %r with args( %s,%s,%s,*%s):\n%s""" + % ( + function, + coords, + vertex_data, + weight, + args, + str(err), + ) + ) + outP = ctypes.c_void_p(self.noteObject(result)) + if outData: + outData[0] = outP + else: + raise RuntimeError("Null outData passed to callback") + return None + + return wrap + + def dataWrapper(self, function): + """Wrap a function which only has the one data-pointer as last arg""" + if (function is not None) and (not hasattr(function, '__call__')): + raise TypeError("""Require a callable callback, got: %s""" % (function,)) + + def wrap(*args): + """Just return the original object for polygon_data""" + args = args[:-1] + (self.originalObject(args[-1]),) + try: + return function(*args) + except Exception as err: + err.args += (function, args) + raise + + return wrap + + def dataWrapper2(self, function): + """Wrap a function which has two data-pointers as last args""" + if (function is not None) and (not hasattr(function, '__call__')): + raise TypeError("""Require a callable callback, got: %s""" % (function,)) + + def wrap(*args): + """Just return the original object for polygon_data""" + args = args[:-2] + ( + self.originalObject(args[-2]), + self.originalObject(args[-1]), + ) + try: + return function(*args) + except Exception as err: + err.args += (function, args) + raise + + return wrap + + def vertexWrapper(self, function): + """Converts a vertex-pointer into an OOR vertex for processing""" + if (function is not None) and (not hasattr(function, '__call__')): + raise TypeError("""Require a callable callback, got: %s""" % (function,)) + + def wrap(vertex, data=None): + """Just return the original object for polygon_data""" + vertex = self.originalObject(vertex) + try: + if data is not None: + data = self.originalObject(data) + return function(vertex, data) + else: + return function(vertex) + except Exception as err: + err.args += (function, (vertex, data)) + raise + + return wrap + + +c = funcType = None +GLUtesselator.CALLBACK_FUNCTION_REGISTRARS = dict( + [ + ( + c, + createBaseFunction( + 'gluTessCallback', + dll=GLU, + resultType=None, + argTypes=[ctypes.POINTER(GLUtesselator), _simple.GLenum, funcType], + doc='gluTessCallback( POINTER(GLUtesselator)(tess), GLenum(which), _GLUfuncptr(CallBackFunc) ) -> None', + argNames=('tess', 'which', 'CallBackFunc'), + ), + ) + for (c, funcType) in GLUtesselator.CALLBACK_TYPES.items() + ] +) +try: + del c, funcType +except NameError as err: + pass + + +def gluTessCallback(tess, which, function): + """Set a given gluTessellator callback for the given tessellator""" + return tess.addCallback(which, function) + + +def gluTessBeginPolygon(tess, data): + """Start definition of polygon in the tessellator""" + return tess.gluTessBeginPolygon(data) + + +def gluTessVertex(tess, location, data=None): + """Add a vertex to the tessellator's current polygon""" + return tess.gluTessVertex(location, data) + + +# /usr/include/GL/glu.h 293 +@_lazy( + createBaseFunction( + 'gluNewTess', + dll=GLU, + resultType=ctypes.POINTER(GLUtesselator), + doc='gluNewTess( ) -> POINTER(GLUtesselator)', + ) +) +def gluNewTess(baseFunction): + """Get a new tessellator object (just unpacks the pointer for you)""" + return baseFunction()[0] + + +@_lazy(_simple.gluGetTessProperty) +def gluGetTessProperty(baseFunction, tess, which, data=None): + """Retrieve single double for a tessellator property""" + if data is None: + data = _simple.GLdouble(0.0) + baseFunction(tess, which, data) + return data.value + else: + return baseFunction(tess, which, data) + + +gluTessVertexBase = wrapper.wrapper(_simple.gluTessVertex).setInputArraySize( + 'location', + 3, +) + +__all__ = ( + 'gluNewTess', + 'gluGetTessProperty', + 'gluTessBeginPolygon', + 'gluTessCallback', + 'gluTessVertex', +) diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLUT/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/GLUT/__init__.py new file mode 100644 index 00000000..6b0bddfe --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLUT/__init__.py @@ -0,0 +1,12 @@ +"""The GLUT library implementation via ctypes""" +from OpenGL.raw.GLUT import * + +from OpenGL.GLUT.special import * +from OpenGL.GLUT.fonts import * +from OpenGL.GLUT.freeglut import * +from OpenGL.GLUT.osx import * + +if glutLeaveMainLoop: + HAVE_FREEGLUT = True +else: + HAVE_FREEGLUT = False diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLUT/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLUT/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..cc04a335 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLUT/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLUT/__pycache__/fonts.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLUT/__pycache__/fonts.cpython-312.pyc new file mode 100644 index 00000000..729b9d6e Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLUT/__pycache__/fonts.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLUT/__pycache__/freeglut.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLUT/__pycache__/freeglut.cpython-312.pyc new file mode 100644 index 00000000..20f8d7a9 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLUT/__pycache__/freeglut.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLUT/__pycache__/osx.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLUT/__pycache__/osx.cpython-312.pyc new file mode 100644 index 00000000..4b58c8b5 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLUT/__pycache__/osx.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLUT/__pycache__/special.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLUT/__pycache__/special.cpython-312.pyc new file mode 100644 index 00000000..46db28df Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLUT/__pycache__/special.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLUT/fonts.py b/venv/lib/python3.12/site-packages/OpenGL/GLUT/fonts.py new file mode 100644 index 00000000..91edd5da --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLUT/fonts.py @@ -0,0 +1,35 @@ +"""Load font "constants" (actually void *s) from the GLUT DLL""" +from OpenGL import platform +import logging +_log = logging.getLogger( 'OpenGL.GLUT.fonts' ) + +for name in [ + 'GLUT_STROKE_ROMAN', + 'GLUT_STROKE_MONO_ROMAN', + 'GLUT_BITMAP_9_BY_15', + 'GLUT_BITMAP_8_BY_13', + 'GLUT_BITMAP_TIMES_ROMAN_10', + 'GLUT_BITMAP_TIMES_ROMAN_24', + 'GLUT_BITMAP_HELVETICA_10', + 'GLUT_BITMAP_HELVETICA_12', + 'GLUT_BITMAP_HELVETICA_18', +]: + try: + # Win32 just has pointers to values 1,2,3,etc + # GLX has pointers to font structures... + p = platform.getGLUTFontPointer( name ) + except (ValueError,AttributeError) as err: + if platform.PLATFORM.GLUT: + _log.warning( '''Unable to load font: %s''', name ) + globals()[name] = None + else: + globals()[name] = p + try: + del p + except NameError as err: + pass + +try: + del platform, name +except NameError as err: + pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLUT/freeglut.py b/venv/lib/python3.12/site-packages/OpenGL/GLUT/freeglut.py new file mode 100644 index 00000000..28eb387d --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLUT/freeglut.py @@ -0,0 +1,304 @@ +"""FreeGLUT extensions to the GLUT API + +This module will provide the FreeGLUT extensions if they are available +from the GLUT module. Note that any other implementation that also provides +these entry points will also retrieve the entry points with this module. +""" +# flags 'freeglut_ext.xml -l /usr/lib64/libglut.so -o freeglut_ext.py -v -kf' +from OpenGL import platform, arrays +from OpenGL import constant +FUNCTION_TYPE = platform.PLATFORM.functionTypeFor( platform.PLATFORM.GLUT ) +from OpenGL.GLUT import special +from OpenGL import wrapper as _wrapper +from OpenGL.raw.GL._types import * + +import ctypes +c_int = ctypes.c_int +c_char_p = ctypes.c_char_p +c_ubyte = ctypes.c_ubyte +c_void_p = ctypes.c_void_p + +GLUT_DEBUG = constant.Constant( 'GLUT_DEBUG', 0x0001 ) +GLUT_FORWARD_COMPATIBLE = constant.Constant( 'GLUT_FORWARD_COMPATIBLE', 0x0002) + +GLUT_ACTION_EXIT = constant.Constant( 'GLUT_ACTION_EXIT', 0 ) +GLUT_ACTION_GLUTMAINLOOP_RETURNS = constant.Constant( 'GLUT_ACTION_GLUTMAINLOOP_RETURNS', 1 ) +GLUT_ACTION_CONTINUE_EXECUTION = constant.Constant( 'GLUT_ACTION_CONTINUE_EXECUTION', 2 ) + +GLUT_INIT_MAJOR_VERSION = constant.Constant( 'GLUT_INIT_MAJOR_VERSION', 0x0200 ) +GLUT_INIT_MINOR_VERSION = constant.Constant( 'GLUT_INIT_MINOR_VERSION', 0x0201 ) +GLUT_INIT_FLAGS = constant.Constant( 'GLUT_INIT_FLAGS', 0x0202 ) + +GLUT_CREATE_NEW_CONTEXT = constant.Constant( 'GLUT_CREATE_NEW_CONTEXT', 0 ) +GLUT_USE_CURRENT_CONTEXT = constant.Constant( 'GLUT_USE_CURRENT_CONTEXT', 1 ) + +GLUT_ACTION_ON_WINDOW_CLOSE = constant.Constant( 'GLUT_ACTION_ON_WINDOW_CLOSE', 0x01F9 ) +GLUT_WINDOW_BORDER_WIDTH = constant.Constant( 'GLUT_WINDOW_BORDER_WIDTH', 0x01FA ) +GLUT_WINDOW_HEADER_HEIGHT = constant.Constant( 'GLUT_USE_CURRENT_CONTEXT', 0x01FB ) +#GLUT_VERSION = constant.Constant( 'GLUT_VERSION', 0x01FC ) +GLUT_RENDERING_CONTEXT = constant.Constant( 'GLUT_RENDERING_CONTEXT', 0x01FD ) + +GLUT_ALLOW_DIRECT_CONTEXT=1 +GLUT_AUX=0x1000 +GLUT_AUX1=0x1000 +GLUT_AUX2=0x2000 +GLUT_AUX3=0x4000 +GLUT_AUX4=0x8000 +GLUT_BORDERLESS=0x0800 +GLUT_CAPTIONLESS=0x0400 +GLUT_COMPATIBILITY_PROFILE=0x0002 +GLUT_CORE_PROFILE=0x0001 +GLUT_DIRECT_RENDERING=0x01 +GLUT_FORCE_DIRECT_CONTEXT=3 +GLUT_FORCE_INDIRECT_CONTEXT=0 +GLUT_FULL_SCREEN=0x01 +GLUT_INIT_PROFILE=0x0203 +GLUT_KEY_BEGIN=0x006 +GLUT_KEY_DELETE=0x006 +GLUT_KEY_NUM_LOCK=0x006 +GLUT_SRGB=0x1000 +GLUT_TRY_DIRECT_CONTEXT=2 + +# /usr/include/GL/freeglut_ext.h 63 +glutMainLoopEvent = platform.createBaseFunction( + 'glutMainLoopEvent', dll=platform.PLATFORM.GLUT, resultType=None, + argTypes=[], + doc='glutMainLoopEvent( ) -> None', + argNames=(), +) +# /usr/include/GL/freeglut_ext.h 64 +glutLeaveMainLoop = platform.createBaseFunction( + 'glutLeaveMainLoop', dll=platform.PLATFORM.GLUT, resultType=None, + argTypes=[], + doc='glutLeaveMainLoop( ) -> None', + argNames=(), +) + +# /usr/include/GL/freeglut_ext.h 69 +##glutMouseWheelFunc = platform.createBaseFunction( +## 'glutMouseWheelFunc', dll=platform.PLATFORM.GLUT, resultType=None, +## argTypes=[FUNCTION_TYPE(None, c_int, c_int, c_int, c_int)], +## doc='glutMouseWheelFunc( FUNCTION_TYPE(None, c_int, c_int, c_int, c_int)(callback) ) -> None', +## argNames=('callback',), +##) +glutMouseWheelFunc = special.GLUTCallback( + 'MouseWheel', (c_int, c_int, c_int, c_int,), ('wheel','direction','x','y'), +) + + +# /usr/include/GL/freeglut_ext.h 70 +##glutCloseFunc = platform.createBaseFunction( +## 'glutCloseFunc', dll=platform.PLATFORM.GLUT, resultType=None, +## argTypes=[FUNCTION_TYPE(None)], +## doc='glutCloseFunc( FUNCTION_TYPE(None)(callback) ) -> None', +## argNames=('callback',), +##) +glutCloseFunc = special.GLUTCallback( + 'Close', (), (), +) + +# /usr/include/GL/freeglut_ext.h 71 +##glutWMCloseFunc = platform.createBaseFunction( +## 'glutWMCloseFunc', dll=platform.PLATFORM.GLUT, resultType=None, +## argTypes=[FUNCTION_TYPE(None)], +## doc='glutWMCloseFunc( FUNCTION_TYPE(None)(callback) ) -> None', +## argNames=('callback',), +##) +glutWMCloseFunc = special.GLUTCallback( + 'WMClose', (), (), +) + +# /usr/include/GL/freeglut_ext.h 73 +##glutMenuDestroyFunc = platform.createBaseFunction( +## 'glutMenuDestroyFunc', dll=platform.PLATFORM.GLUT, resultType=None, +## argTypes=[FUNCTION_TYPE(None)], +## doc='glutMenuDestroyFunc( FUNCTION_TYPE(None)(callback) ) -> None', +## argNames=('callback',), +##) +glutMenuDestroyFunc = special.GLUTCallback( + 'MenuDestroy', (), (), +) + +# /usr/include/GL/freeglut_ext.h 78 +glutSetOption = platform.createBaseFunction( + 'glutSetOption', dll=platform.PLATFORM.GLUT, resultType=None, + argTypes=[GLenum, c_int], + doc='glutSetOption( GLenum(option_flag), c_int(value) ) -> None', + argNames=('option_flag', 'value'), +) + +# /usr/include/GL/freeglut_ext.h 80 +glutGetWindowData = platform.createBaseFunction( + 'glutGetWindowData', dll=platform.PLATFORM.GLUT, resultType=c_void_p, + argTypes=[], + doc='glutGetWindowData( ) -> c_void_p', + argNames=(), +) + +# /usr/include/GL/freeglut_ext.h 81 +glutSetWindowData = platform.createBaseFunction( + 'glutSetWindowData', dll=platform.PLATFORM.GLUT, resultType=None, + argTypes=[c_void_p], + doc='glutSetWindowData( c_void_p(data) ) -> None', + argNames=('data',), +) + +# /usr/include/GL/freeglut_ext.h 82 +glutGetMenuData = platform.createBaseFunction( + 'glutGetMenuData', dll=platform.PLATFORM.GLUT, resultType=c_void_p, + argTypes=[], + doc='glutGetMenuData( ) -> c_void_p', + argNames=(), +) + +# /usr/include/GL/freeglut_ext.h 83 +glutSetMenuData = platform.createBaseFunction( + 'glutSetMenuData', dll=platform.PLATFORM.GLUT, resultType=None, + argTypes=[c_void_p], + doc='glutSetMenuData( c_void_p(data) ) -> None', + argNames=('data',), +) + +# /usr/include/GL/freeglut_ext.h 88 +glutBitmapHeight = platform.createBaseFunction( + 'glutBitmapHeight', dll=platform.PLATFORM.GLUT, resultType=c_int, + argTypes=[c_void_p], + doc='glutBitmapHeight( c_void_p(font) ) -> c_int', + argNames=('font',), +) + +# /usr/include/GL/freeglut_ext.h 89 +glutStrokeHeight = platform.createBaseFunction( + 'glutStrokeHeight', dll=platform.PLATFORM.GLUT, resultType=GLfloat, + argTypes=[c_void_p], + doc='glutStrokeHeight( c_void_p(font) ) -> GLfloat', + argNames=('font',), +) + +# /usr/include/GL/freeglut_ext.h 90 +glutBitmapString = platform.createBaseFunction( + 'glutBitmapString', dll=platform.PLATFORM.GLUT, resultType=None, + argTypes=[c_void_p, c_char_p], + doc='glutBitmapString( c_void_p(font), POINTER(c_ubyte)(string) ) -> None', + argNames=('font', 'string'), +) + +# /usr/include/GL/freeglut_ext.h 91 +glutStrokeString = platform.createBaseFunction( + 'glutStrokeString', dll=platform.PLATFORM.GLUT, resultType=None, + argTypes=[c_void_p, c_char_p], + doc='glutStrokeString( c_void_p(font), POINTER(c_ubyte)(string) ) -> None', + argNames=('font', 'string'), +) + +# /usr/include/GL/freeglut_ext.h 96 +glutWireRhombicDodecahedron = platform.createBaseFunction( + 'glutWireRhombicDodecahedron', dll=platform.PLATFORM.GLUT, resultType=None, + argTypes=[], + doc='glutWireRhombicDodecahedron( ) -> None', + argNames=(), +) + +# /usr/include/GL/freeglut_ext.h 97 +glutSolidRhombicDodecahedron = platform.createBaseFunction( + 'glutSolidRhombicDodecahedron', dll=platform.PLATFORM.GLUT, resultType=None, + argTypes=[], + doc='glutSolidRhombicDodecahedron( ) -> None', + argNames=(), +) + +# /usr/include/GL/freeglut_ext.h 98 +glutWireSierpinskiSponge = platform.createBaseFunction( + 'glutWireSierpinskiSponge', dll=platform.PLATFORM.GLUT, resultType=None, + argTypes=[c_int, arrays.GLdoubleArray, GLdouble], + doc='glutWireSierpinskiSponge( c_int(num_levels), arrays.GLdoubleArray(offset), GLdouble(scale) ) -> None', + argNames=('num_levels', 'offset', 'scale'), +) + +glutWireSierpinskiSponge = _wrapper.wrapper( glutWireSierpinskiSponge ).setInputArraySize( + 'offset', +) + +# /usr/include/GL/freeglut_ext.h 99 +glutSolidSierpinskiSponge = platform.createBaseFunction( + 'glutSolidSierpinskiSponge', dll=platform.PLATFORM.GLUT, resultType=None, + argTypes=[c_int, arrays.GLdoubleArray, GLdouble], + doc='glutSolidSierpinskiSponge( c_int(num_levels), arrays.GLdoubleArray(offset), GLdouble(scale) ) -> None', + argNames=('num_levels', 'offset', 'scale'), +) + +glutSolidSierpinskiSponge = _wrapper.wrapper( glutSolidSierpinskiSponge ).setInputArraySize( + 'offset', +) + +# /usr/include/GL/freeglut_ext.h 100 +glutWireCylinder = platform.createBaseFunction( + 'glutWireCylinder', dll=platform.PLATFORM.GLUT, resultType=None, + argTypes=[GLdouble, GLdouble, GLint, GLint], + doc='glutWireCylinder( GLdouble(radius), GLdouble(height), GLint(slices), GLint(stacks) ) -> None', + argNames=('radius', 'height', 'slices', 'stacks'), +) + +# /usr/include/GL/freeglut_ext.h 101 +glutSolidCylinder = platform.createBaseFunction( + 'glutSolidCylinder', dll=platform.PLATFORM.GLUT, resultType=None, + argTypes=[GLdouble, GLdouble, GLint, GLint], + doc='glutSolidCylinder( GLdouble(radius), GLdouble(height), GLint(slices), GLint(stacks) ) -> None', + argNames=('radius', 'height', 'slices', 'stacks'), +) + +# /usr/include/GL/freeglut_ext.h 106 +glutGetProcAddress = platform.createBaseFunction( + 'glutGetProcAddress', dll=platform.PLATFORM.GLUT, resultType=c_void_p, + argTypes=[c_char_p], + doc='glutGetProcAddress( STRING(procName) ) -> c_void_p', + argNames=('procName',), +) + +glutInitContextFlags = platform.createBaseFunction( + 'glutInitContextFlags', dll=platform.PLATFORM.GLUT, resultType=None, + argTypes=[GLint], + doc='glutInitContextFlags( GLint(flags) ) -> None', + argNames = ('flags',), +) +glutInitContextProfile = platform.createBaseFunction( + 'glutInitContextProfile', dll=platform.PLATFORM.GLUT, resultType=None, + argTypes=[GLint], + doc='glutInitContextProfile( GLint(profile) ) -> None', + argNames = ('profile',), +) +glutInitContextVersion = platform.createBaseFunction( + 'glutInitContextVersion', dll=platform.PLATFORM.GLUT, resultType=None, + argTypes=[GLint,GLint], + doc='glutInitContextVersion( GLint(majorVersion), GLint(minorVersion) ) -> None', + argNames = ('majorVersion','minorVersion'), +) +glutFullScreenToggle = platform.createBaseFunction( + 'glutFullScreenToggle', dll=platform.PLATFORM.GLUT, resultType=None, + argTypes=[], + doc='glutFullScreenToggle( ) -> None', + argNames = (), +) + +# TODO: this entry point is quite messy, needs a wrapper that creates size, then makes a result +# object that will de-allocate the memory for the result when finished. Bleh. +glutGetModeValues = platform.createBaseFunction( + 'glutGetModeValues', dll=platform.PLATFORM.GLUT, resultType=ctypes.POINTER(GLint), + argTypes=[GLint,ctypes.POINTER(GLint)], + doc='glutInitContextVersion( GLenum(mode), POINTER(GLint)(size) ) -> POINTER(GLint)', + argNames = ('mode','size'), +) + +fgDeinitialize = platform.createBaseFunction( + 'fgDeinitialize', dll=platform.PLATFORM.GLUT, resultType = None, + argTypes=[GLint], + doc ='''fgDeinitialize () -> None + +Exposed to allow client code to work around an AMD/FGLRX bug on +GLX platforms. FGLRX and FreeGLUT both register cleanup functions +that unless registered in the correct order, will cause seg-faults. + +To work around this, call fgDeinitialize(False) before doing a +sys.exit() or similar call that terminates your GLUT mainloop. +''', +) diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLUT/osx.py b/venv/lib/python3.12/site-packages/OpenGL/GLUT/osx.py new file mode 100644 index 00000000..468a2f6c --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLUT/osx.py @@ -0,0 +1,18 @@ +"""OSX specific extensions to GLUT""" +from OpenGL import platform +from OpenGL import constant +from OpenGL.GLUT import special + +GLUT_NO_RECOVERY = constant.Constant( 'GLUT_NO_RECOVERY', 1024) +GLUT_3_2_CORE_PROFILE = constant.Constant( 'GLUT_3_2_CORE_PROFILE', 2048) + +glutCheckLoop = platform.createBaseFunction( + 'glutCheckLoop', dll=platform.PLATFORM.GLUT, resultType=None, + argTypes=[], + doc='glutCheckLoop( ) -> None', + argNames=(), +) + +glutWMCloseFunc = special.GLUTCallback( + 'WMClose', (), (), +) diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLUT/special.py b/venv/lib/python3.12/site-packages/OpenGL/GLUT/special.py new file mode 100644 index 00000000..da3930ec --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLUT/special.py @@ -0,0 +1,352 @@ +"""GLUT functions requiring special handling to provide Pythonic wrappers + +Note: + GLUT callbacks are controlled by a flag in the platform module. The + GLUT_GUARD_CALLBACKS flag controls whether to wrap passed functions + with error-checking and context-validity checking code so that the + callbacks will only trigger if there is a valid context. This is done + so that systems such as Win32 will not continue running GLUT callbacks + after the system has exited. + + Note: + This is not a problem with FreeGLUT on Linux, so Linux does not + add the extra overhead of the wrapper function. + Note: + This hack does *not* prevent hanging if there is no GLUT callback + being triggered. I.e. if you create a GLUT program that doesn't + explicitly call exit and doesn't call display or the like in a timer + then your app will hang on exit on Win32. + +XXX the platform-specific stuff should be getting done in the +platform module *not* in the module here! +""" +from OpenGL.platform import CurrentContextIsValid, GLUT_GUARD_CALLBACKS, PLATFORM +GLUT = PLATFORM.GLUT +from OpenGL import contextdata, error, platform, logs +from OpenGL.raw import GLUT as _simple +from OpenGL._bytes import bytes, unicode,as_8_bit +import ctypes, os, sys, traceback +PLATFORM = platform.PLATFORM +FUNCTION_TYPE = _simple.CALLBACK_FUNCTION_TYPE +from OpenGL._bytes import long, integer_types + +_log = logs.getLog( 'OpenGL.GLUT.special' ) + +if os.name == "nt": + _log.info( """Using NT-specific GLUT calls with exit callbacks""" ) + _exitfunctype = FUNCTION_TYPE( None, ctypes.c_int ) + __glutInitWithExit = platform.createBaseFunction( + '__glutInitWithExit', dll=platform.PLATFORM.GLUT, resultType=None, + argTypes=[ctypes.POINTER(ctypes.c_int),ctypes.POINTER(ctypes.c_char_p),_exitfunctype], + doc='glutInit( POINTER(c_int)(pargc), POINTER(STRING)(argv) ) -> None', + argNames=('pargc', 'argv'), + ) + __glutCreateWindowWithExit = platform.createBaseFunction( + '__glutCreateWindowWithExit', dll=platform.PLATFORM.GLUT, resultType=ctypes.c_int, + argTypes=[ctypes.c_char_p,_exitfunctype], + doc='glutCreateWindow( STRING(title) ) -> c_int', + argNames=('title',), + ) + __glutCreateMenuWithExit = platform.createBaseFunction( + '__glutCreateMenuWithExit', dll=platform.PLATFORM.GLUT, resultType=ctypes.c_int, + argTypes=[FUNCTION_TYPE(None, ctypes.c_int),_exitfunctype], + doc='glutCreateMenu( FUNCTION_TYPE(None, c_int)(callback) ) -> c_int', + argNames=('callback',), + ) +else: + # Linux, OSX, etceteras + __glutInitWithExit = None +if __glutInitWithExit: + # Normal platforms + Win32 w/ FreeGLUT (SF#2813722) + import sys + _exitfunc = _exitfunctype(sys.exit) + + def _base_glutInit(pargc, argv): + """Overrides base glut init with exit-function-aware version""" + return __glutInitWithExit(pargc, argv, _exitfunc) + def glutCreateWindow(title): + """Create window with given title + + This is the Win32-specific version that handles + registration of an exit-function handler + """ + return __glutCreateWindowWithExit(title, _exitfunc) + def glutCreateMenu(callback): + """Create menu with given callback + + This is the Win32-specific version that handles + registration of an exit-function callback. + """ + return __glutCreateMenuWithExit(callback, _exitfunc) +else: + _base_glutInit = platform.nullFunction( + 'glutInit', GLUT, + resultType=None, + argTypes=(ctypes.POINTER(ctypes.c_int),ctypes.POINTER( ctypes.c_char_p )), + doc = 'Initialize the GLUT library', argNames = ('argcp','argv'), + module = __name__, + error_checker = None, + ) +##_base_glutDisplayFunc = GLUT.glutDisplayFunc +##_base_glutIdleFunc = GLUT.glutIdleFunc +##_base_glutEntryFunc = GLUT.glutEntryFunc +##_base_glutReshapeFunc = GLUT.glutReshapeFunc +_base_glutDestroyWindow = getattr(GLUT, 'glutDestroyWindow', None) + +class GLUTCallback( object ): + """Class implementing GLUT Callback registration functions""" + def __init__( self, typeName, parameterTypes, parameterNames ): + """Initialise the glut callback instance""" + self.typeName = typeName + def describe( typ, name ): + return '(int) %s'%(name) + self.__doc__ = """Specify handler for GLUT %r events + def handler( %s ): + return None"""%( typeName, ", ".join([ + describe( typ,name ) + for (typ,name) in zip( parameterTypes, parameterNames ) + ])) + try: + self.wrappedOperation = getattr( GLUT, 'glut%sFunc'%(typeName) ) + except AttributeError as err: + def failFunction( *args, **named ): + from OpenGL import error + raise error.NullFunctionError( + """Undefined GLUT callback function %s, check for bool(%s) before calling"""%( + typeName, 'glut%sFunc'%(typeName), + ) + ) + self.wrappedOperation = failFunction + self.callbackType = FUNCTION_TYPE( None, *parameterTypes ) + self.CONTEXT_DATA_KEY = 'glut%sFunc'%(typeName, ) + argNames = ('function',) + def __call__( self, function, *args ): + if GLUT_GUARD_CALLBACKS and hasattr( function,'__call__' ): + def safeCall( *args, **named ): + """Safe calling of GUI callbacks, exits on failures""" + try: + if not CurrentContextIsValid(): + raise RuntimeError( """No valid context!""" ) + return function( *args, **named ) + except Exception as err: + traceback.print_exc() + sys.stderr.write( """GLUT %s callback %s with %s,%s failed: returning None %s\n"""%( + self.typeName, function, args, named, err, + )) + os._exit(1) + #return None + finalFunction = safeCall + else: + finalFunction = function + if hasattr( finalFunction,'__call__' ): + cCallback = self.callbackType( finalFunction ) + else: + cCallback = function + # keep the function alive as long as the cCallback is... + #cCallback.function = function + contextdata.setValue( self.CONTEXT_DATA_KEY, cCallback ) + self.wrappedOperation( cCallback, *args ) + return cCallback +class GLUTTimerCallback( GLUTCallback ): + """GLUT timer callbacks (completely nonstandard wrt other GLUT callbacks)""" + def __call__( self, milliseconds, function, value ): + cCallback = self.callbackType( function ) + # timers should de-register as soon as they are called... + # Note: there's no good key to use! we want to allow for + # multiple instances of the same function with the same value + # which means we have nothing that can store it properly... + callbacks = contextdata.getValue( self.CONTEXT_DATA_KEY ) + if callbacks is None: + callbacks = [] + contextdata.setValue( self.CONTEXT_DATA_KEY, callbacks ) + def deregister( value ): + try: + function( value ) + finally: + for item in callbacks: + if item.function is deregister: + callbacks.remove( item ) + item.function = None + break + if not callbacks: + contextdata.delValue( self.CONTEXT_DATA_KEY ) + cCallback = self.callbackType( deregister ) + cCallback.function = deregister + callbacks.append( cCallback ) + self.wrappedOperation( milliseconds, cCallback, value ) + return cCallback + +class GLUTMenuCallback( object ): + """Place to collect the GLUT Menu manipulation special code""" + callbackType = FUNCTION_TYPE( ctypes.c_int, ctypes.c_int ) + def glutCreateMenu( cls, func ): + """Create a new (current) menu, return small integer identifier + + func( int ) -- Function taking a single integer reflecting + the user's choice, the value passed to glutAddMenuEntry + + return menuID (small integer) + """ + cCallback = cls.callbackType( func ) + menu = _simple.glutCreateMenu( cCallback ) + contextdata.setValue( ('menucallback',menu), (cCallback,func) ) + return menu + glutCreateMenu.argNames = [ 'func' ] + glutCreateMenu = classmethod( glutCreateMenu ) + def glutDestroyMenu( cls, menu ): + """Destroy (cleanup) the given menu + + Deregister's the interal pointer to the menu callback + + returns None + """ + result = _simple.glutDestroyMenu( menu ) + contextdata.delValue( ('menucallback',menu) ) + return result + glutDestroyMenu.argNames = [ 'menu' ] + glutDestroyMenu = classmethod( glutDestroyMenu ) + +glutCreateMenu = GLUTMenuCallback.glutCreateMenu +#glutCreateMenu.wrappedOperation = _simple.glutCreateMenu +glutDestroyMenu = GLUTMenuCallback.glutDestroyMenu +#glutDestroyMenu.wrappedOperation = _simple.glutDestroyMenu + +glutButtonBoxFunc = GLUTCallback( + 'ButtonBox', (ctypes.c_int,ctypes.c_int), ('button','state'), +) +glutDialsFunc = GLUTCallback( + 'Dials', (ctypes.c_int,ctypes.c_int), ('dial','value'), +) +glutDisplayFunc = GLUTCallback( + 'Display', (), (), +) +glutEntryFunc = GLUTCallback( + 'Entry', (ctypes.c_int,), ('state',), +) +glutIdleFunc = GLUTCallback( + 'Idle', (), (), +) +glutJoystickFunc = GLUTCallback( + 'Joystick', (ctypes.c_uint,ctypes.c_int,ctypes.c_int,ctypes.c_int), ('buttonMask','x','y','z'), +) +glutKeyboardFunc = GLUTCallback( + 'Keyboard', (ctypes.c_char,ctypes.c_int,ctypes.c_int), ('key','x','y'), +) +glutKeyboardUpFunc = GLUTCallback( + 'KeyboardUp', (ctypes.c_char,ctypes.c_int,ctypes.c_int), ('key','x','y'), +) +glutMenuStatusFunc = GLUTCallback( + 'MenuStatus', (ctypes.c_int,ctypes.c_int,ctypes.c_int), ('status','x','y'), +) +glutMenuStateFunc = GLUTCallback( + 'MenuState', (ctypes.c_int,), ('status',), +) +glutMotionFunc = GLUTCallback( + 'Motion', (ctypes.c_int,ctypes.c_int), ('x','y'), +) +glutMouseFunc = GLUTCallback( + 'Mouse', (ctypes.c_int,ctypes.c_int,ctypes.c_int,ctypes.c_int), ('button','state','x','y'), +) +glutOverlayDisplayFunc = GLUTCallback( + 'OverlayDisplay', (), (), +) +glutPassiveMotionFunc = GLUTCallback( + 'PassiveMotion', (ctypes.c_int,ctypes.c_int), ('x','y'), +) +glutReshapeFunc = GLUTCallback( + 'Reshape', (ctypes.c_int,ctypes.c_int), ('width','height'), +) +glutSpaceballButtonFunc = GLUTCallback( + 'SpaceballButton', (ctypes.c_int,ctypes.c_int), ('button','state'), +) +glutSpaceballMotionFunc = GLUTCallback( + 'SpaceballMotion', (ctypes.c_int,ctypes.c_int,ctypes.c_int), ('x','y','z'), +) +glutSpaceballRotateFunc = GLUTCallback( + 'SpaceballRotate', (ctypes.c_int,ctypes.c_int,ctypes.c_int), ('x','y','z'), +) +glutSpecialFunc = GLUTCallback( + 'Special', (ctypes.c_int,ctypes.c_int,ctypes.c_int), ('key','x','y'), +) +glutSpecialUpFunc = GLUTCallback( + 'SpecialUp', (ctypes.c_int,ctypes.c_int,ctypes.c_int), ('key','x','y'), +) +glutTabletButtonFunc = GLUTCallback( + 'TabletButton', (ctypes.c_int,ctypes.c_int,ctypes.c_int,ctypes.c_int), ('button','state','x','y',), +) +glutTabletButtonFunc = GLUTCallback( + 'TabletButton', (ctypes.c_int,ctypes.c_int,ctypes.c_int,ctypes.c_int), ('button','state','x','y',), +) +glutTabletMotionFunc = GLUTCallback( + 'TabletMotion', (ctypes.c_int,ctypes.c_int), ('x','y',), +) +glutVisibilityFunc = GLUTCallback( + 'Visibility', (ctypes.c_int,), ('state',), +) +glutWindowStatusFunc = GLUTCallback( + 'WindowStatus', (ctypes.c_int,), ('state',), +) + +# glutTimerFunc is unlike any other GLUT callback-registration... +glutTimerFunc = GLUTTimerCallback( + 'Timer', (ctypes.c_int,), ('value',), +) + +INITIALIZED = False +def glutInit( *args ): + """Initialise the GLUT library""" + global INITIALIZED + if INITIALIZED: + return args + INITIALIZED = True + if args: + arg,args = args[0],args[1:] + count = None + if isinstance(arg, integer_types): + # raw API style, (count, values) + count = arg + if count != len(args): + raise ValueError( """Specified count of %s does not match length (%s) of argument list %s"""%( + count, len(args), args, + )) + elif isinstance( arg, (bytes,unicode)): + # passing in a sequence of strings as individual arguments + args = (arg,)+args + count = len(args) + else: + args = arg + count = len(args) + else: + count=0 + args = [] + args = [as_8_bit(x) for x in args] + if not count: + count, args = 1, [as_8_bit('foo')] + holder = (ctypes.c_char_p * len(args))() + for i,arg in enumerate(args): + holder[i] = arg + count = ctypes.c_int( count ) + import os + currentDirectory = os.getcwd() + try: + # XXX need to check for error condition here... + _base_glutInit( ctypes.byref(count), holder ) + finally: + os.chdir( currentDirectory ) + return [ + holder[i] for i in range( count.value ) + ] +glutInit.wrappedOperation = _simple.glutInit + +def glutDestroyWindow( window ): + """Want to destroy the window, we need to do some cleanup...""" + context = 0 + try: + GLUT.glutSetWindow(window) + context = contextdata.getContext() + result = contextdata.cleanupContext( context ) + _log.info( """Cleaning up context data for window %s: %s""", window, result ) + except Exception as err: + _log.error( """Error attempting to clean up context data for GLUT window %s: %s""", window, result ) + return _base_glutDestroyWindow( window ) +glutDestroyWindow.wrappedOperation = _simple.glutDestroyWindow diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/AMD/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/GLX/AMD/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLX/AMD/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/AMD/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLX/AMD/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..6dba62f9 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLX/AMD/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/AMD/__pycache__/gpu_association.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLX/AMD/__pycache__/gpu_association.cpython-312.pyc new file mode 100644 index 00000000..35ff1a5f Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLX/AMD/__pycache__/gpu_association.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/AMD/gpu_association.py b/venv/lib/python3.12/site-packages/OpenGL/GLX/AMD/gpu_association.py new file mode 100644 index 00000000..f515293b --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLX/AMD/gpu_association.py @@ -0,0 +1,23 @@ +'''OpenGL extension AMD.gpu_association + +This module customises the behaviour of the +OpenGL.raw.GLX.AMD.gpu_association to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/AMD/gpu_association.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLX import _types, _glgets +from OpenGL.raw.GLX.AMD.gpu_association import * +from OpenGL.raw.GLX.AMD.gpu_association import _EXTENSION_NAME + +def glInitGpuAssociationAMD(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/ARB/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/GLX/ARB/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLX/ARB/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/ARB/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLX/ARB/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..0ffab1df Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLX/ARB/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/ARB/__pycache__/context_flush_control.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLX/ARB/__pycache__/context_flush_control.cpython-312.pyc new file mode 100644 index 00000000..e1a4daf8 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLX/ARB/__pycache__/context_flush_control.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/ARB/__pycache__/create_context.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLX/ARB/__pycache__/create_context.cpython-312.pyc new file mode 100644 index 00000000..221a7d62 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLX/ARB/__pycache__/create_context.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/ARB/__pycache__/create_context_no_error.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLX/ARB/__pycache__/create_context_no_error.cpython-312.pyc new file mode 100644 index 00000000..3e8eb37b Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLX/ARB/__pycache__/create_context_no_error.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/ARB/__pycache__/create_context_profile.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLX/ARB/__pycache__/create_context_profile.cpython-312.pyc new file mode 100644 index 00000000..c80af1b4 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLX/ARB/__pycache__/create_context_profile.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/ARB/__pycache__/create_context_robustness.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLX/ARB/__pycache__/create_context_robustness.cpython-312.pyc new file mode 100644 index 00000000..5dc77e6e Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLX/ARB/__pycache__/create_context_robustness.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/ARB/__pycache__/fbconfig_float.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLX/ARB/__pycache__/fbconfig_float.cpython-312.pyc new file mode 100644 index 00000000..30fc8c70 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLX/ARB/__pycache__/fbconfig_float.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/ARB/__pycache__/framebuffer_sRGB.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLX/ARB/__pycache__/framebuffer_sRGB.cpython-312.pyc new file mode 100644 index 00000000..dd5e193b Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLX/ARB/__pycache__/framebuffer_sRGB.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/ARB/__pycache__/get_proc_address.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLX/ARB/__pycache__/get_proc_address.cpython-312.pyc new file mode 100644 index 00000000..9b9b41e1 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLX/ARB/__pycache__/get_proc_address.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/ARB/__pycache__/multisample.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLX/ARB/__pycache__/multisample.cpython-312.pyc new file mode 100644 index 00000000..52b282b2 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLX/ARB/__pycache__/multisample.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/ARB/__pycache__/robustness_application_isolation.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLX/ARB/__pycache__/robustness_application_isolation.cpython-312.pyc new file mode 100644 index 00000000..7fc1771e Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLX/ARB/__pycache__/robustness_application_isolation.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/ARB/__pycache__/robustness_share_group_isolation.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLX/ARB/__pycache__/robustness_share_group_isolation.cpython-312.pyc new file mode 100644 index 00000000..56491913 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLX/ARB/__pycache__/robustness_share_group_isolation.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/ARB/__pycache__/vertex_buffer_object.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLX/ARB/__pycache__/vertex_buffer_object.cpython-312.pyc new file mode 100644 index 00000000..afeb9089 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLX/ARB/__pycache__/vertex_buffer_object.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/ARB/context_flush_control.py b/venv/lib/python3.12/site-packages/OpenGL/GLX/ARB/context_flush_control.py new file mode 100644 index 00000000..2017a0c3 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLX/ARB/context_flush_control.py @@ -0,0 +1,23 @@ +'''OpenGL extension ARB.context_flush_control + +This module customises the behaviour of the +OpenGL.raw.GLX.ARB.context_flush_control to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/context_flush_control.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLX import _types, _glgets +from OpenGL.raw.GLX.ARB.context_flush_control import * +from OpenGL.raw.GLX.ARB.context_flush_control import _EXTENSION_NAME + +def glInitContextFlushControlARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/ARB/create_context.py b/venv/lib/python3.12/site-packages/OpenGL/GLX/ARB/create_context.py new file mode 100644 index 00000000..793295cf --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLX/ARB/create_context.py @@ -0,0 +1,23 @@ +'''OpenGL extension ARB.create_context + +This module customises the behaviour of the +OpenGL.raw.GLX.ARB.create_context to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/create_context.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLX import _types, _glgets +from OpenGL.raw.GLX.ARB.create_context import * +from OpenGL.raw.GLX.ARB.create_context import _EXTENSION_NAME + +def glInitCreateContextARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/ARB/create_context_no_error.py b/venv/lib/python3.12/site-packages/OpenGL/GLX/ARB/create_context_no_error.py new file mode 100644 index 00000000..8346e8a6 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLX/ARB/create_context_no_error.py @@ -0,0 +1,30 @@ +'''OpenGL extension ARB.create_context_no_error + +This module customises the behaviour of the +OpenGL.raw.GLX.ARB.create_context_no_error to provide a more +Python-friendly API + +Overview (from the spec) + + This extension allows the creation of an OpenGL or OpenGL ES context that + doesn't generate errors if the context supports a no error mode. The + implications of this feature are discussed in the GL_KHR_no_error + extension. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/create_context_no_error.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLX import _types, _glgets +from OpenGL.raw.GLX.ARB.create_context_no_error import * +from OpenGL.raw.GLX.ARB.create_context_no_error import _EXTENSION_NAME + +def glInitCreateContextNoErrorARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/ARB/create_context_profile.py b/venv/lib/python3.12/site-packages/OpenGL/GLX/ARB/create_context_profile.py new file mode 100644 index 00000000..a2cdbce1 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLX/ARB/create_context_profile.py @@ -0,0 +1,23 @@ +'''OpenGL extension ARB.create_context_profile + +This module customises the behaviour of the +OpenGL.raw.GLX.ARB.create_context_profile to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/create_context_profile.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLX import _types, _glgets +from OpenGL.raw.GLX.ARB.create_context_profile import * +from OpenGL.raw.GLX.ARB.create_context_profile import _EXTENSION_NAME + +def glInitCreateContextProfileARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/ARB/create_context_robustness.py b/venv/lib/python3.12/site-packages/OpenGL/GLX/ARB/create_context_robustness.py new file mode 100644 index 00000000..42aab048 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLX/ARB/create_context_robustness.py @@ -0,0 +1,23 @@ +'''OpenGL extension ARB.create_context_robustness + +This module customises the behaviour of the +OpenGL.raw.GLX.ARB.create_context_robustness to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/create_context_robustness.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLX import _types, _glgets +from OpenGL.raw.GLX.ARB.create_context_robustness import * +from OpenGL.raw.GLX.ARB.create_context_robustness import _EXTENSION_NAME + +def glInitCreateContextRobustnessARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/ARB/fbconfig_float.py b/venv/lib/python3.12/site-packages/OpenGL/GLX/ARB/fbconfig_float.py new file mode 100644 index 00000000..e1940fa0 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLX/ARB/fbconfig_float.py @@ -0,0 +1,23 @@ +'''OpenGL extension ARB.fbconfig_float + +This module customises the behaviour of the +OpenGL.raw.GLX.ARB.fbconfig_float to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/fbconfig_float.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLX import _types, _glgets +from OpenGL.raw.GLX.ARB.fbconfig_float import * +from OpenGL.raw.GLX.ARB.fbconfig_float import _EXTENSION_NAME + +def glInitFbconfigFloatARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/ARB/framebuffer_sRGB.py b/venv/lib/python3.12/site-packages/OpenGL/GLX/ARB/framebuffer_sRGB.py new file mode 100644 index 00000000..0c4c785f --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLX/ARB/framebuffer_sRGB.py @@ -0,0 +1,55 @@ +'''OpenGL extension ARB.framebuffer_sRGB + +This module customises the behaviour of the +OpenGL.raw.GLX.ARB.framebuffer_sRGB to provide a more +Python-friendly API + +Overview (from the spec) + + Conventionally, OpenGL assumes framebuffer color components are stored + in a linear color space. In particular, framebuffer blending is a + linear operation. + + The sRGB color space is based on typical (non-linear) monitor + characteristics expected in a dimly lit office. It has been + standardized by the International Electrotechnical Commission (IEC) + as IEC 61966-2-1. The sRGB color space roughly corresponds to 2.2 + gamma correction. + + This extension adds a framebuffer capability for sRGB framebuffer + update and blending. When blending is disabled but the new sRGB + updated mode is enabled (assume the framebuffer supports the + capability), high-precision linear color component values for red, + green, and blue generated by fragment coloring are encoded for sRGB + prior to being written into the framebuffer. When blending is enabled + along with the new sRGB update mode, red, green, and blue framebuffer + color components are treated as sRGB values that are converted to + linear color values, blended with the high-precision color values + generated by fragment coloring, and then the blend result is encoded + for sRGB just prior to being written into the framebuffer. + + The primary motivation for this extension is that it allows OpenGL + applications to render into a framebuffer that is scanned to a monitor + configured to assume framebuffer color values are sRGB encoded. + This assumption is roughly true of most PC monitors with default + gamma correction. This allows applications to achieve faithful + color reproduction for OpenGL rendering without adjusting the + monitor's gamma correction. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/framebuffer_sRGB.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLX import _types, _glgets +from OpenGL.raw.GLX.ARB.framebuffer_sRGB import * +from OpenGL.raw.GLX.ARB.framebuffer_sRGB import _EXTENSION_NAME + +def glInitFramebufferSrgbARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/ARB/get_proc_address.py b/venv/lib/python3.12/site-packages/OpenGL/GLX/ARB/get_proc_address.py new file mode 100644 index 00000000..c33ec405 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLX/ARB/get_proc_address.py @@ -0,0 +1,23 @@ +'''OpenGL extension ARB.get_proc_address + +This module customises the behaviour of the +OpenGL.raw.GLX.ARB.get_proc_address to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/get_proc_address.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLX import _types, _glgets +from OpenGL.raw.GLX.ARB.get_proc_address import * +from OpenGL.raw.GLX.ARB.get_proc_address import _EXTENSION_NAME + +def glInitGetProcAddressARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/ARB/multisample.py b/venv/lib/python3.12/site-packages/OpenGL/GLX/ARB/multisample.py new file mode 100644 index 00000000..6dece4c6 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLX/ARB/multisample.py @@ -0,0 +1,51 @@ +'''OpenGL extension ARB.multisample + +This module customises the behaviour of the +OpenGL.raw.GLX.ARB.multisample to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides a mechanism to antialias all GL primitives: + points, lines, polygons, bitmaps, and images. The technique is to + sample all primitives multiple times at each pixel. The color + sample values are resolved to a single, displayable color each time + a pixel is updated, so the antialiasing appears to be automatic at + the application level. Because each sample includes depth and + stencil information, the depth and stencil functions perform + equivalently to the single-sample mode. + + An additional buffer, called the multisample buffer, is added to + the framebuffer. Pixel sample values, including color, depth, and + stencil values, are stored in this buffer. When the framebuffer + includes a multisample buffer, it does not also include separate + depth or stencil buffers, even if the multisample buffer does not + store depth or stencil values. Color buffers (left/right, front/ + back, and aux) do coexist with the multisample buffer, however. + + Multisample antialiasing is most valuable for rendering polygons, + because it requires no sorting for hidden surface elimination, and + it correctly handles adjacent polygons, object silhouettes, and + even intersecting polygons. If only points or lines are being + rendered, the "smooth" antialiasing mechanism provided by the base + GL may result in a higher quality image. This extension is + designed to allow multisample and smooth antialiasing techniques + to be alternated during the rendering of a single scene. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/multisample.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLX import _types, _glgets +from OpenGL.raw.GLX.ARB.multisample import * +from OpenGL.raw.GLX.ARB.multisample import _EXTENSION_NAME + +def glInitMultisampleARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/ARB/robustness_application_isolation.py b/venv/lib/python3.12/site-packages/OpenGL/GLX/ARB/robustness_application_isolation.py new file mode 100644 index 00000000..06e1e328 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLX/ARB/robustness_application_isolation.py @@ -0,0 +1,40 @@ +'''OpenGL extension ARB.robustness_application_isolation + +This module customises the behaviour of the +OpenGL.raw.GLX.ARB.robustness_application_isolation to provide a more +Python-friendly API + +Overview (from the spec) + + GL_ARB_robustness and supporting window system extensions allow + creating an OpenGL context supporting graphics reset notification + behavior. GL_ARB_robustness_isolation provides stronger + guarantees about the possible side-effects of a graphics reset. + + It is expected that there may be a performance cost associated + with isolating an application or share group from other contexts + on the GPU. For this reason, GL_ARB_robustness_isolation is + phrased as an opt-in mechanism, with a new context creation bit + defined in the window system bindings. It is expected that + implementations might only advertise the strings in this extension + if both the implementation supports the desired isolation + properties, and the context was created with the appropriate reset + isolation bit. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/robustness_application_isolation.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLX import _types, _glgets +from OpenGL.raw.GLX.ARB.robustness_application_isolation import * +from OpenGL.raw.GLX.ARB.robustness_application_isolation import _EXTENSION_NAME + +def glInitRobustnessApplicationIsolationARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/ARB/robustness_share_group_isolation.py b/venv/lib/python3.12/site-packages/OpenGL/GLX/ARB/robustness_share_group_isolation.py new file mode 100644 index 00000000..ec1601d5 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLX/ARB/robustness_share_group_isolation.py @@ -0,0 +1,23 @@ +'''OpenGL extension ARB.robustness_share_group_isolation + +This module customises the behaviour of the +OpenGL.raw.GLX.ARB.robustness_share_group_isolation to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/robustness_share_group_isolation.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLX import _types, _glgets +from OpenGL.raw.GLX.ARB.robustness_share_group_isolation import * +from OpenGL.raw.GLX.ARB.robustness_share_group_isolation import _EXTENSION_NAME + +def glInitRobustnessShareGroupIsolationARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/ARB/vertex_buffer_object.py b/venv/lib/python3.12/site-packages/OpenGL/GLX/ARB/vertex_buffer_object.py new file mode 100644 index 00000000..bfbb2004 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLX/ARB/vertex_buffer_object.py @@ -0,0 +1,81 @@ +'''OpenGL extension ARB.vertex_buffer_object + +This module customises the behaviour of the +OpenGL.raw.GLX.ARB.vertex_buffer_object to provide a more +Python-friendly API + +Overview (from the spec) + + This extension defines an interface that allows various types of data + (especially vertex array data) to be cached in high-performance + graphics memory on the server, thereby increasing the rate of data + transfers. + + Chunks of data are encapsulated within "buffer objects", which + conceptually are nothing more than arrays of bytes, just like any + chunk of memory. An API is provided whereby applications can read + from or write to buffers, either via the GL itself (glBufferData, + glBufferSubData, glGetBufferSubData) or via a pointer to the memory. + + The latter technique is known as "mapping" a buffer. When an + application maps a buffer, it is given a pointer to the memory. When + the application finishes reading from or writing to the memory, it is + required to "unmap" the buffer before it is once again permitted to + use that buffer as a GL data source or sink. Mapping often allows + applications to eliminate an extra data copy otherwise required to + access the buffer, thereby enhancing performance. In addition, + requiring that applications unmap the buffer to use it as a data + source or sink ensures that certain classes of latent synchronization + bugs cannot occur. + + Although this extension only defines hooks for buffer objects to be + used with OpenGL's vertex array APIs, the API defined in this + extension permits buffer objects to be used as either data sources or + sinks for any GL command that takes a pointer as an argument. + Normally, in the absence of this extension, a pointer passed into the + GL is simply a pointer to the user's data. This extension defines + a mechanism whereby this pointer is used not as a pointer to the data + itself, but as an offset into a currently bound buffer object. The + buffer object ID zero is reserved, and when buffer object zero is + bound to a given target, the commands affected by that buffer binding + behave normally. When a nonzero buffer ID is bound, then the pointer + represents an offset. + + In the case of vertex arrays, this extension defines not merely one + binding for all attributes, but a separate binding for each + individual attribute. As a result, applications can source their + attributes from multiple buffers. An application might, for example, + have a model with constant texture coordinates and variable geometry. + The texture coordinates might be retrieved from a buffer object with + the usage mode "STATIC_DRAW", indicating to the GL that the + application does not expect to update the contents of the buffer + frequently or even at all, while the vertices might be retrieved from + a buffer object with the usage mode "STREAM_DRAW", indicating that + the vertices will be updated on a regular basis. + + In addition, a binding is defined by which applications can source + index data (as used by DrawElements, DrawRangeElements, and + MultiDrawElements) from a buffer object. On some platforms, this + enables very large models to be rendered with no more than a few + small commands to the graphics device. + + It is expected that a future extension will allow sourcing pixel data + from and writing pixel data to a buffer object. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/vertex_buffer_object.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLX import _types, _glgets +from OpenGL.raw.GLX.ARB.vertex_buffer_object import * +from OpenGL.raw.GLX.ARB.vertex_buffer_object import _EXTENSION_NAME + +def glInitVertexBufferObjectARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/DFX/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/GLX/DFX/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLX/DFX/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/DFX/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLX/DFX/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..33bcbe88 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLX/DFX/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/DFX/__pycache__/multisample.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLX/DFX/__pycache__/multisample.cpython-312.pyc new file mode 100644 index 00000000..ff262539 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLX/DFX/__pycache__/multisample.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/DFX/multisample.py b/venv/lib/python3.12/site-packages/OpenGL/GLX/DFX/multisample.py new file mode 100644 index 00000000..ff067659 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLX/DFX/multisample.py @@ -0,0 +1,65 @@ +'''OpenGL extension DFX.multisample + +This module customises the behaviour of the +OpenGL.raw.GLX.DFX.multisample to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides a mechanism to antialias all GL primitives: + points, lines, polygons, bitmaps, and images. The technique is to + sample all primitives multiple times at each pixel. The color sample + values are resolved to a single, displayable color each time a pixel + is updated, so the antialiasing appears to be automatic at the + application level. Because each sample includes depth and stencil + information, the depth and stencil functions perform equivalently to + the single-sample mode. + + An additional buffer, called the multisample buffer, is added to the + framebuffer. Pixel sample values, including color, depth, and + stencil values, are stored in this buffer. When the framebuffer + includes a multisample buffer, it does not also include separate + depth or stencil buffers, even if the multisample buffer does not + store depth or stencil values. Color buffers (left/right, + front/back, and aux) do coexist with the multisample buffer, + however. + + Multisample antialiasing is most valuable for rendering polygons, + because it requires no sorting for hidden surface elimination, and + it correctly handles adjacent polygons, object silhouettes, and even + intersecting polygons. If only points or lines are being rendered, + the "smooth" antialiasing mechanism provided by the base GL may + result in a higher quality image. + + This extension is a subset of SGIS_multisample. It differs in these + key ways: + + * Fragment alpha values are not affected by the fragment sample mask + * The sample locations may or may not be fixed. Thus, there is no + support for rendering the scene multiple times with different + sample points. + * Fragment masks are not computed for images or for bitmasks. + + Because of these differences a new extension was created. However, + it is not expected that this extension will co-exist with + SGIS_multisample. Because of this and the fact that there are only + 32 push/pop bits the MULTISAMPLE_BIT_SGIS state value is the same as + MUTLISAMPLE_BIT_3DFX. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/DFX/multisample.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLX import _types, _glgets +from OpenGL.raw.GLX.DFX.multisample import * +from OpenGL.raw.GLX.DFX.multisample import _EXTENSION_NAME + +def glInitMultisampleDFX(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/EXT/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/GLX/EXT/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLX/EXT/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/EXT/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLX/EXT/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..2b629fab Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLX/EXT/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/EXT/__pycache__/buffer_age.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLX/EXT/__pycache__/buffer_age.cpython-312.pyc new file mode 100644 index 00000000..f2eff573 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLX/EXT/__pycache__/buffer_age.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/EXT/__pycache__/context_priority.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLX/EXT/__pycache__/context_priority.cpython-312.pyc new file mode 100644 index 00000000..9b5185e0 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLX/EXT/__pycache__/context_priority.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/EXT/__pycache__/create_context_es2_profile.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLX/EXT/__pycache__/create_context_es2_profile.cpython-312.pyc new file mode 100644 index 00000000..9d27d94c Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLX/EXT/__pycache__/create_context_es2_profile.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/EXT/__pycache__/create_context_es_profile.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLX/EXT/__pycache__/create_context_es_profile.cpython-312.pyc new file mode 100644 index 00000000..eca3dd2b Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLX/EXT/__pycache__/create_context_es_profile.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/EXT/__pycache__/fbconfig_packed_float.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLX/EXT/__pycache__/fbconfig_packed_float.cpython-312.pyc new file mode 100644 index 00000000..248401de Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLX/EXT/__pycache__/fbconfig_packed_float.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/EXT/__pycache__/framebuffer_sRGB.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLX/EXT/__pycache__/framebuffer_sRGB.cpython-312.pyc new file mode 100644 index 00000000..a433e376 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLX/EXT/__pycache__/framebuffer_sRGB.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/EXT/__pycache__/import_context.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLX/EXT/__pycache__/import_context.cpython-312.pyc new file mode 100644 index 00000000..117d033f Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLX/EXT/__pycache__/import_context.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/EXT/__pycache__/libglvnd.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLX/EXT/__pycache__/libglvnd.cpython-312.pyc new file mode 100644 index 00000000..64e86093 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLX/EXT/__pycache__/libglvnd.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/EXT/__pycache__/no_config_context.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLX/EXT/__pycache__/no_config_context.cpython-312.pyc new file mode 100644 index 00000000..999cac41 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLX/EXT/__pycache__/no_config_context.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/EXT/__pycache__/stereo_tree.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLX/EXT/__pycache__/stereo_tree.cpython-312.pyc new file mode 100644 index 00000000..bfc753a0 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLX/EXT/__pycache__/stereo_tree.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/EXT/__pycache__/swap_control.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLX/EXT/__pycache__/swap_control.cpython-312.pyc new file mode 100644 index 00000000..1e61351c Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLX/EXT/__pycache__/swap_control.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/EXT/__pycache__/swap_control_tear.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLX/EXT/__pycache__/swap_control_tear.cpython-312.pyc new file mode 100644 index 00000000..2e9f462f Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLX/EXT/__pycache__/swap_control_tear.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/EXT/__pycache__/texture_from_pixmap.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLX/EXT/__pycache__/texture_from_pixmap.cpython-312.pyc new file mode 100644 index 00000000..b8bf855a Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLX/EXT/__pycache__/texture_from_pixmap.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/EXT/__pycache__/visual_info.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLX/EXT/__pycache__/visual_info.cpython-312.pyc new file mode 100644 index 00000000..94f8354f Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLX/EXT/__pycache__/visual_info.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/EXT/__pycache__/visual_rating.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLX/EXT/__pycache__/visual_rating.cpython-312.pyc new file mode 100644 index 00000000..0130b472 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLX/EXT/__pycache__/visual_rating.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/EXT/buffer_age.py b/venv/lib/python3.12/site-packages/OpenGL/GLX/EXT/buffer_age.py new file mode 100644 index 00000000..b47d8635 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLX/EXT/buffer_age.py @@ -0,0 +1,23 @@ +'''OpenGL extension EXT.buffer_age + +This module customises the behaviour of the +OpenGL.raw.GLX.EXT.buffer_age to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/buffer_age.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLX import _types, _glgets +from OpenGL.raw.GLX.EXT.buffer_age import * +from OpenGL.raw.GLX.EXT.buffer_age import _EXTENSION_NAME + +def glInitBufferAgeEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/EXT/context_priority.py b/venv/lib/python3.12/site-packages/OpenGL/GLX/EXT/context_priority.py new file mode 100644 index 00000000..b62ff7ce --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLX/EXT/context_priority.py @@ -0,0 +1,23 @@ +'''OpenGL extension EXT.context_priority + +This module customises the behaviour of the +OpenGL.raw.GLX.EXT.context_priority to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/context_priority.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLX import _types, _glgets +from OpenGL.raw.GLX.EXT.context_priority import * +from OpenGL.raw.GLX.EXT.context_priority import _EXTENSION_NAME + +def glInitContextPriorityEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/EXT/create_context_es2_profile.py b/venv/lib/python3.12/site-packages/OpenGL/GLX/EXT/create_context_es2_profile.py new file mode 100644 index 00000000..d9ac78a2 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLX/EXT/create_context_es2_profile.py @@ -0,0 +1,23 @@ +'''OpenGL extension EXT.create_context_es2_profile + +This module customises the behaviour of the +OpenGL.raw.GLX.EXT.create_context_es2_profile to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/create_context_es2_profile.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLX import _types, _glgets +from OpenGL.raw.GLX.EXT.create_context_es2_profile import * +from OpenGL.raw.GLX.EXT.create_context_es2_profile import _EXTENSION_NAME + +def glInitCreateContextEs2ProfileEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/EXT/create_context_es_profile.py b/venv/lib/python3.12/site-packages/OpenGL/GLX/EXT/create_context_es_profile.py new file mode 100644 index 00000000..7e9e3998 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLX/EXT/create_context_es_profile.py @@ -0,0 +1,23 @@ +'''OpenGL extension EXT.create_context_es_profile + +This module customises the behaviour of the +OpenGL.raw.GLX.EXT.create_context_es_profile to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/create_context_es_profile.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLX import _types, _glgets +from OpenGL.raw.GLX.EXT.create_context_es_profile import * +from OpenGL.raw.GLX.EXT.create_context_es_profile import _EXTENSION_NAME + +def glInitCreateContextEsProfileEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/EXT/fbconfig_packed_float.py b/venv/lib/python3.12/site-packages/OpenGL/GLX/EXT/fbconfig_packed_float.py new file mode 100644 index 00000000..483f28a4 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLX/EXT/fbconfig_packed_float.py @@ -0,0 +1,23 @@ +'''OpenGL extension EXT.fbconfig_packed_float + +This module customises the behaviour of the +OpenGL.raw.GLX.EXT.fbconfig_packed_float to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/fbconfig_packed_float.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLX import _types, _glgets +from OpenGL.raw.GLX.EXT.fbconfig_packed_float import * +from OpenGL.raw.GLX.EXT.fbconfig_packed_float import _EXTENSION_NAME + +def glInitFbconfigPackedFloatEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/EXT/framebuffer_sRGB.py b/venv/lib/python3.12/site-packages/OpenGL/GLX/EXT/framebuffer_sRGB.py new file mode 100644 index 00000000..f80f7200 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLX/EXT/framebuffer_sRGB.py @@ -0,0 +1,55 @@ +'''OpenGL extension EXT.framebuffer_sRGB + +This module customises the behaviour of the +OpenGL.raw.GLX.EXT.framebuffer_sRGB to provide a more +Python-friendly API + +Overview (from the spec) + + Conventionally, OpenGL assumes framebuffer color components are stored + in a linear color space. In particular, framebuffer blending is a + linear operation. + + The sRGB color space is based on typical (non-linear) monitor + characteristics expected in a dimly lit office. It has been + standardized by the International Electrotechnical Commission (IEC) + as IEC 61966-2-1. The sRGB color space roughly corresponds to 2.2 + gamma correction. + + This extension adds a framebuffer capability for sRGB framebuffer + update and blending. When blending is disabled but the new sRGB + updated mode is enabled (assume the framebuffer supports the + capability), high-precision linear color component values for red, + green, and blue generated by fragment coloring are encoded for sRGB + prior to being written into the framebuffer. When blending is enabled + along with the new sRGB update mode, red, green, and blue framebuffer + color components are treated as sRGB values that are converted to + linear color values, blended with the high-precision color values + generated by fragment coloring, and then the blend result is encoded + for sRGB just prior to being written into the framebuffer. + + The primary motivation for this extension is that it allows OpenGL + applications to render into a framebuffer that is scanned to a monitor + configured to assume framebuffer color values are sRGB encoded. + This assumption is roughly true of most PC monitors with default + gamma correction. This allows applications to achieve faithful + color reproduction for OpenGL rendering without adjusting the + monitor's gamma correction. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/framebuffer_sRGB.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLX import _types, _glgets +from OpenGL.raw.GLX.EXT.framebuffer_sRGB import * +from OpenGL.raw.GLX.EXT.framebuffer_sRGB import _EXTENSION_NAME + +def glInitFramebufferSrgbEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/EXT/import_context.py b/venv/lib/python3.12/site-packages/OpenGL/GLX/EXT/import_context.py new file mode 100644 index 00000000..7c19c008 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLX/EXT/import_context.py @@ -0,0 +1,23 @@ +'''OpenGL extension EXT.import_context + +This module customises the behaviour of the +OpenGL.raw.GLX.EXT.import_context to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/import_context.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLX import _types, _glgets +from OpenGL.raw.GLX.EXT.import_context import * +from OpenGL.raw.GLX.EXT.import_context import _EXTENSION_NAME + +def glInitImportContextEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/EXT/libglvnd.py b/venv/lib/python3.12/site-packages/OpenGL/GLX/EXT/libglvnd.py new file mode 100644 index 00000000..e58b56f4 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLX/EXT/libglvnd.py @@ -0,0 +1,23 @@ +'''OpenGL extension EXT.libglvnd + +This module customises the behaviour of the +OpenGL.raw.GLX.EXT.libglvnd to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/libglvnd.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLX import _types, _glgets +from OpenGL.raw.GLX.EXT.libglvnd import * +from OpenGL.raw.GLX.EXT.libglvnd import _EXTENSION_NAME + +def glInitLibglvndEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/EXT/no_config_context.py b/venv/lib/python3.12/site-packages/OpenGL/GLX/EXT/no_config_context.py new file mode 100644 index 00000000..cdf32fcc --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLX/EXT/no_config_context.py @@ -0,0 +1,23 @@ +'''OpenGL extension EXT.no_config_context + +This module customises the behaviour of the +OpenGL.raw.GLX.EXT.no_config_context to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/no_config_context.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLX import _types, _glgets +from OpenGL.raw.GLX.EXT.no_config_context import * +from OpenGL.raw.GLX.EXT.no_config_context import _EXTENSION_NAME + +def glInitNoConfigContextEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/EXT/stereo_tree.py b/venv/lib/python3.12/site-packages/OpenGL/GLX/EXT/stereo_tree.py new file mode 100644 index 00000000..1f824154 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLX/EXT/stereo_tree.py @@ -0,0 +1,23 @@ +'''OpenGL extension EXT.stereo_tree + +This module customises the behaviour of the +OpenGL.raw.GLX.EXT.stereo_tree to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/stereo_tree.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLX import _types, _glgets +from OpenGL.raw.GLX.EXT.stereo_tree import * +from OpenGL.raw.GLX.EXT.stereo_tree import _EXTENSION_NAME + +def glInitStereoTreeEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/EXT/swap_control.py b/venv/lib/python3.12/site-packages/OpenGL/GLX/EXT/swap_control.py new file mode 100644 index 00000000..ebd700df --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLX/EXT/swap_control.py @@ -0,0 +1,31 @@ +'''OpenGL extension EXT.swap_control + +This module customises the behaviour of the +OpenGL.raw.GLX.EXT.swap_control to provide a more +Python-friendly API + +Overview (from the spec) + + This extension allows an application to specify a minimum + periodicity of color buffer swaps, measured in video frame periods, + for a particular drawable. It also allows an application to query + the swap interval and the implementation-dependent maximum swap + interval of a drawable. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/swap_control.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLX import _types, _glgets +from OpenGL.raw.GLX.EXT.swap_control import * +from OpenGL.raw.GLX.EXT.swap_control import _EXTENSION_NAME + +def glInitSwapControlEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/EXT/swap_control_tear.py b/venv/lib/python3.12/site-packages/OpenGL/GLX/EXT/swap_control_tear.py new file mode 100644 index 00000000..127710ad --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLX/EXT/swap_control_tear.py @@ -0,0 +1,23 @@ +'''OpenGL extension EXT.swap_control_tear + +This module customises the behaviour of the +OpenGL.raw.GLX.EXT.swap_control_tear to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/swap_control_tear.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLX import _types, _glgets +from OpenGL.raw.GLX.EXT.swap_control_tear import * +from OpenGL.raw.GLX.EXT.swap_control_tear import _EXTENSION_NAME + +def glInitSwapControlTearEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/EXT/texture_from_pixmap.py b/venv/lib/python3.12/site-packages/OpenGL/GLX/EXT/texture_from_pixmap.py new file mode 100644 index 00000000..8cb6f94f --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLX/EXT/texture_from_pixmap.py @@ -0,0 +1,23 @@ +'''OpenGL extension EXT.texture_from_pixmap + +This module customises the behaviour of the +OpenGL.raw.GLX.EXT.texture_from_pixmap to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/texture_from_pixmap.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLX import _types, _glgets +from OpenGL.raw.GLX.EXT.texture_from_pixmap import * +from OpenGL.raw.GLX.EXT.texture_from_pixmap import _EXTENSION_NAME + +def glInitTextureFromPixmapEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/EXT/visual_info.py b/venv/lib/python3.12/site-packages/OpenGL/GLX/EXT/visual_info.py new file mode 100644 index 00000000..739df8fb --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLX/EXT/visual_info.py @@ -0,0 +1,23 @@ +'''OpenGL extension EXT.visual_info + +This module customises the behaviour of the +OpenGL.raw.GLX.EXT.visual_info to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/visual_info.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLX import _types, _glgets +from OpenGL.raw.GLX.EXT.visual_info import * +from OpenGL.raw.GLX.EXT.visual_info import _EXTENSION_NAME + +def glInitVisualInfoEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/EXT/visual_rating.py b/venv/lib/python3.12/site-packages/OpenGL/GLX/EXT/visual_rating.py new file mode 100644 index 00000000..00083483 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLX/EXT/visual_rating.py @@ -0,0 +1,23 @@ +'''OpenGL extension EXT.visual_rating + +This module customises the behaviour of the +OpenGL.raw.GLX.EXT.visual_rating to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/visual_rating.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLX import _types, _glgets +from OpenGL.raw.GLX.EXT.visual_rating import * +from OpenGL.raw.GLX.EXT.visual_rating import _EXTENSION_NAME + +def glInitVisualRatingEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/INTEL/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/GLX/INTEL/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLX/INTEL/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/INTEL/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLX/INTEL/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..c8caee5a Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLX/INTEL/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/INTEL/__pycache__/swap_event.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLX/INTEL/__pycache__/swap_event.cpython-312.pyc new file mode 100644 index 00000000..7887552f Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLX/INTEL/__pycache__/swap_event.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/INTEL/swap_event.py b/venv/lib/python3.12/site-packages/OpenGL/GLX/INTEL/swap_event.py new file mode 100644 index 00000000..8bf84df8 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLX/INTEL/swap_event.py @@ -0,0 +1,23 @@ +'''OpenGL extension INTEL.swap_event + +This module customises the behaviour of the +OpenGL.raw.GLX.INTEL.swap_event to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/INTEL/swap_event.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLX import _types, _glgets +from OpenGL.raw.GLX.INTEL.swap_event import * +from OpenGL.raw.GLX.INTEL.swap_event import _EXTENSION_NAME + +def glInitSwapEventINTEL(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/MESA/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/GLX/MESA/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLX/MESA/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/MESA/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLX/MESA/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..b8974654 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLX/MESA/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/MESA/__pycache__/agp_offset.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLX/MESA/__pycache__/agp_offset.cpython-312.pyc new file mode 100644 index 00000000..bf34b8c1 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLX/MESA/__pycache__/agp_offset.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/MESA/__pycache__/copy_sub_buffer.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLX/MESA/__pycache__/copy_sub_buffer.cpython-312.pyc new file mode 100644 index 00000000..167559c7 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLX/MESA/__pycache__/copy_sub_buffer.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/MESA/__pycache__/pixmap_colormap.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLX/MESA/__pycache__/pixmap_colormap.cpython-312.pyc new file mode 100644 index 00000000..43ca6133 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLX/MESA/__pycache__/pixmap_colormap.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/MESA/__pycache__/query_renderer.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLX/MESA/__pycache__/query_renderer.cpython-312.pyc new file mode 100644 index 00000000..2aa7ba47 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLX/MESA/__pycache__/query_renderer.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/MESA/__pycache__/release_buffers.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLX/MESA/__pycache__/release_buffers.cpython-312.pyc new file mode 100644 index 00000000..b5de18ba Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLX/MESA/__pycache__/release_buffers.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/MESA/__pycache__/set_3dfx_mode.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLX/MESA/__pycache__/set_3dfx_mode.cpython-312.pyc new file mode 100644 index 00000000..b45c2c32 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLX/MESA/__pycache__/set_3dfx_mode.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/MESA/__pycache__/swap_control.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLX/MESA/__pycache__/swap_control.cpython-312.pyc new file mode 100644 index 00000000..ac919642 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLX/MESA/__pycache__/swap_control.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/MESA/agp_offset.py b/venv/lib/python3.12/site-packages/OpenGL/GLX/MESA/agp_offset.py new file mode 100644 index 00000000..63abfec2 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLX/MESA/agp_offset.py @@ -0,0 +1,23 @@ +'''OpenGL extension MESA.agp_offset + +This module customises the behaviour of the +OpenGL.raw.GLX.MESA.agp_offset to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/MESA/agp_offset.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLX import _types, _glgets +from OpenGL.raw.GLX.MESA.agp_offset import * +from OpenGL.raw.GLX.MESA.agp_offset import _EXTENSION_NAME + +def glInitAgpOffsetMESA(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/MESA/copy_sub_buffer.py b/venv/lib/python3.12/site-packages/OpenGL/GLX/MESA/copy_sub_buffer.py new file mode 100644 index 00000000..6695449a --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLX/MESA/copy_sub_buffer.py @@ -0,0 +1,23 @@ +'''OpenGL extension MESA.copy_sub_buffer + +This module customises the behaviour of the +OpenGL.raw.GLX.MESA.copy_sub_buffer to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/MESA/copy_sub_buffer.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLX import _types, _glgets +from OpenGL.raw.GLX.MESA.copy_sub_buffer import * +from OpenGL.raw.GLX.MESA.copy_sub_buffer import _EXTENSION_NAME + +def glInitCopySubBufferMESA(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/MESA/pixmap_colormap.py b/venv/lib/python3.12/site-packages/OpenGL/GLX/MESA/pixmap_colormap.py new file mode 100644 index 00000000..5a9ecd83 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLX/MESA/pixmap_colormap.py @@ -0,0 +1,23 @@ +'''OpenGL extension MESA.pixmap_colormap + +This module customises the behaviour of the +OpenGL.raw.GLX.MESA.pixmap_colormap to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/MESA/pixmap_colormap.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLX import _types, _glgets +from OpenGL.raw.GLX.MESA.pixmap_colormap import * +from OpenGL.raw.GLX.MESA.pixmap_colormap import _EXTENSION_NAME + +def glInitPixmapColormapMESA(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/MESA/query_renderer.py b/venv/lib/python3.12/site-packages/OpenGL/GLX/MESA/query_renderer.py new file mode 100644 index 00000000..a6a88e0b --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLX/MESA/query_renderer.py @@ -0,0 +1,23 @@ +'''OpenGL extension MESA.query_renderer + +This module customises the behaviour of the +OpenGL.raw.GLX.MESA.query_renderer to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/MESA/query_renderer.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLX import _types, _glgets +from OpenGL.raw.GLX.MESA.query_renderer import * +from OpenGL.raw.GLX.MESA.query_renderer import _EXTENSION_NAME + +def glInitQueryRendererMESA(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/MESA/release_buffers.py b/venv/lib/python3.12/site-packages/OpenGL/GLX/MESA/release_buffers.py new file mode 100644 index 00000000..bd6b84b2 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLX/MESA/release_buffers.py @@ -0,0 +1,23 @@ +'''OpenGL extension MESA.release_buffers + +This module customises the behaviour of the +OpenGL.raw.GLX.MESA.release_buffers to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/MESA/release_buffers.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLX import _types, _glgets +from OpenGL.raw.GLX.MESA.release_buffers import * +from OpenGL.raw.GLX.MESA.release_buffers import _EXTENSION_NAME + +def glInitReleaseBuffersMESA(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/MESA/set_3dfx_mode.py b/venv/lib/python3.12/site-packages/OpenGL/GLX/MESA/set_3dfx_mode.py new file mode 100644 index 00000000..fffbf313 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLX/MESA/set_3dfx_mode.py @@ -0,0 +1,23 @@ +'''OpenGL extension MESA.set_3dfx_mode + +This module customises the behaviour of the +OpenGL.raw.GLX.MESA.set_3dfx_mode to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/MESA/set_3dfx_mode.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLX import _types, _glgets +from OpenGL.raw.GLX.MESA.set_3dfx_mode import * +from OpenGL.raw.GLX.MESA.set_3dfx_mode import _EXTENSION_NAME + +def glInitSet3DfxModeMESA(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/MESA/swap_control.py b/venv/lib/python3.12/site-packages/OpenGL/GLX/MESA/swap_control.py new file mode 100644 index 00000000..a3db15cb --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLX/MESA/swap_control.py @@ -0,0 +1,23 @@ +'''OpenGL extension MESA.swap_control + +This module customises the behaviour of the +OpenGL.raw.GLX.MESA.swap_control to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/MESA/swap_control.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLX import _types, _glgets +from OpenGL.raw.GLX.MESA.swap_control import * +from OpenGL.raw.GLX.MESA.swap_control import _EXTENSION_NAME + +def glInitSwapControlMESA(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/NV/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/GLX/NV/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLX/NV/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/NV/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLX/NV/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..acd90e10 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLX/NV/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/NV/__pycache__/copy_buffer.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLX/NV/__pycache__/copy_buffer.cpython-312.pyc new file mode 100644 index 00000000..fb41cfee Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLX/NV/__pycache__/copy_buffer.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/NV/__pycache__/copy_image.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLX/NV/__pycache__/copy_image.cpython-312.pyc new file mode 100644 index 00000000..34f8813e Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLX/NV/__pycache__/copy_image.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/NV/__pycache__/delay_before_swap.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLX/NV/__pycache__/delay_before_swap.cpython-312.pyc new file mode 100644 index 00000000..0fe1eaf0 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLX/NV/__pycache__/delay_before_swap.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/NV/__pycache__/float_buffer.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLX/NV/__pycache__/float_buffer.cpython-312.pyc new file mode 100644 index 00000000..74d4d197 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLX/NV/__pycache__/float_buffer.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/NV/__pycache__/multigpu_context.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLX/NV/__pycache__/multigpu_context.cpython-312.pyc new file mode 100644 index 00000000..a1678e34 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLX/NV/__pycache__/multigpu_context.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/NV/__pycache__/multisample_coverage.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLX/NV/__pycache__/multisample_coverage.cpython-312.pyc new file mode 100644 index 00000000..68d1ea83 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLX/NV/__pycache__/multisample_coverage.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/NV/__pycache__/present_video.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLX/NV/__pycache__/present_video.cpython-312.pyc new file mode 100644 index 00000000..41638639 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLX/NV/__pycache__/present_video.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/NV/__pycache__/robustness_video_memory_purge.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLX/NV/__pycache__/robustness_video_memory_purge.cpython-312.pyc new file mode 100644 index 00000000..ebbd0891 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLX/NV/__pycache__/robustness_video_memory_purge.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/NV/__pycache__/swap_group.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLX/NV/__pycache__/swap_group.cpython-312.pyc new file mode 100644 index 00000000..e538d407 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLX/NV/__pycache__/swap_group.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/NV/__pycache__/video_capture.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLX/NV/__pycache__/video_capture.cpython-312.pyc new file mode 100644 index 00000000..15b59dbd Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLX/NV/__pycache__/video_capture.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/NV/__pycache__/video_out.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLX/NV/__pycache__/video_out.cpython-312.pyc new file mode 100644 index 00000000..001134d7 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLX/NV/__pycache__/video_out.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/NV/__pycache__/video_output.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLX/NV/__pycache__/video_output.cpython-312.pyc new file mode 100644 index 00000000..577e45b5 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLX/NV/__pycache__/video_output.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/NV/copy_buffer.py b/venv/lib/python3.12/site-packages/OpenGL/GLX/NV/copy_buffer.py new file mode 100644 index 00000000..9020885b --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLX/NV/copy_buffer.py @@ -0,0 +1,30 @@ +'''OpenGL extension NV.copy_buffer + +This module customises the behaviour of the +OpenGL.raw.GLX.NV.copy_buffer to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides a mechanism to do an accelerated copy from one + buffer object to another. This may be useful to load buffer objects + in a "loading thread" while minimizing cost and synchronization effort + in the "rendering thread." + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/copy_buffer.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLX import _types, _glgets +from OpenGL.raw.GLX.NV.copy_buffer import * +from OpenGL.raw.GLX.NV.copy_buffer import _EXTENSION_NAME + +def glInitCopyBufferNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/NV/copy_image.py b/venv/lib/python3.12/site-packages/OpenGL/GLX/NV/copy_image.py new file mode 100644 index 00000000..535ab1c7 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLX/NV/copy_image.py @@ -0,0 +1,32 @@ +'''OpenGL extension NV.copy_image + +This module customises the behaviour of the +OpenGL.raw.GLX.NV.copy_image to provide a more +Python-friendly API + +Overview (from the spec) + + This extension enables efficient image data transfer between image + objects (i.e. textures and renderbuffers) without the need to bind + the objects or otherwise configure the rendering pipeline. The + WGL and GLX versions allow copying between images in different + contexts, even if those contexts are in different sharelists or + even on different physical devices. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/copy_image.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLX import _types, _glgets +from OpenGL.raw.GLX.NV.copy_image import * +from OpenGL.raw.GLX.NV.copy_image import _EXTENSION_NAME + +def glInitCopyImageNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/NV/delay_before_swap.py b/venv/lib/python3.12/site-packages/OpenGL/GLX/NV/delay_before_swap.py new file mode 100644 index 00000000..0290357a --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLX/NV/delay_before_swap.py @@ -0,0 +1,23 @@ +'''OpenGL extension NV.delay_before_swap + +This module customises the behaviour of the +OpenGL.raw.GLX.NV.delay_before_swap to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/delay_before_swap.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLX import _types, _glgets +from OpenGL.raw.GLX.NV.delay_before_swap import * +from OpenGL.raw.GLX.NV.delay_before_swap import _EXTENSION_NAME + +def glInitDelayBeforeSwapNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/NV/float_buffer.py b/venv/lib/python3.12/site-packages/OpenGL/GLX/NV/float_buffer.py new file mode 100644 index 00000000..b3fc56a5 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLX/NV/float_buffer.py @@ -0,0 +1,91 @@ +'''OpenGL extension NV.float_buffer + +This module customises the behaviour of the +OpenGL.raw.GLX.NV.float_buffer to provide a more +Python-friendly API + +Overview (from the spec) + + This extension builds upon NV_fragment_program to provide a framebuffer + and texture format that allows fragment programs to read and write + unconstrained floating point data. + + In unextended OpenGL, most computations dealing with color or depth + buffers are typically constrained to operate on values in the range [0,1]. + Computational results are also typically clamped to the range [0,1]. + Color, texture, and depth buffers themselves also hold values mapped to + the range [0,1]. + + The NV_fragment_program extension provides a general computational model + that supports floating-point numbers constrained only by the precision of + the underlying data types. The quantites computed by fragment programs do + not necessarily correspond in number or in range to conventional + attributes such as RGBA colors or depth values. Because of the range and + precision constraints imposed by conventional fixed-point color buffers, + it may be difficult (if not impossible) to use them to implement certain + multi-pass algorithms. + + To enhance the extended range and precision available through fragment + programs, this extension provides floating-point RGBA color buffers that + can be used instead of conventional fixed-point RGBA color buffers. A + floating-point RGBA color buffer consists of one to four floating-point + components stored in the 16- or 32-bit floating-point formats (fp16 or + fp32) defined in the NV_half_float and NV_fragment_program extensions. + + When a floating-point color buffer is used, the results of fragment + programs, as written to the "x", "y", "z", and "w" components of the + o[COLR] or o[COLH] output registers, are written directly to the color + buffer without any clamping or modification. Certain per-fragment + operations are bypassed when rendering to floating-point color buffers. + + A floating-point color buffer can also be used as a texture map, either by + reading back the contents and then using conventional TexImage calls, or + by using the buffer directly via the ARB_render_texture extension or + the EXT_framebuffer_object extension. + + This extension has many uses. Some possible uses include: + + (1) Multi-pass algorithms with arbitrary intermediate results that + don't have to be artifically forced into the range [0,1]. In + addition, intermediate results can be written without having to + worry about out-of-range values. + + (2) Deferred shading algorithms where an expensive fragment program is + executed only after depth testing is fully complete. Instead, a + simple program is executed, which stores the parameters necessary + to produce a final result. After the entire scene is rendered, a + second pass is executed over the entire frame buffer to execute + the complex fragment program using the results written to the + floating-point color buffer in the first pass. This will save the + cost of applying complex fragment programs to fragments that will + not appear in the final image. + + (3) Use floating-point texture maps to evaluate functions with + arbitrary ranges. Arbitrary functions with a finite domain can be + approximated using a texture map holding sample results and + piecewise linear approximation. + + There are several significant limitations on the use of floating-point + color buffers. First, floating-point color buffers do not support frame + buffer blending. Second, floating-point texture maps do not support + mipmapping or any texture filtering other than NEAREST. Third, + floating-point texture maps must be 2D, and must use the + NV_texture_rectangle extension. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/float_buffer.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLX import _types, _glgets +from OpenGL.raw.GLX.NV.float_buffer import * +from OpenGL.raw.GLX.NV.float_buffer import _EXTENSION_NAME + +def glInitFloatBufferNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/NV/multigpu_context.py b/venv/lib/python3.12/site-packages/OpenGL/GLX/NV/multigpu_context.py new file mode 100644 index 00000000..13e6fc12 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLX/NV/multigpu_context.py @@ -0,0 +1,23 @@ +'''OpenGL extension NV.multigpu_context + +This module customises the behaviour of the +OpenGL.raw.GLX.NV.multigpu_context to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/multigpu_context.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLX import _types, _glgets +from OpenGL.raw.GLX.NV.multigpu_context import * +from OpenGL.raw.GLX.NV.multigpu_context import _EXTENSION_NAME + +def glInitMultigpuContextNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/NV/multisample_coverage.py b/venv/lib/python3.12/site-packages/OpenGL/GLX/NV/multisample_coverage.py new file mode 100644 index 00000000..087ea3e7 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLX/NV/multisample_coverage.py @@ -0,0 +1,49 @@ +'''OpenGL extension NV.multisample_coverage + +This module customises the behaviour of the +OpenGL.raw.GLX.NV.multisample_coverage to provide a more +Python-friendly API + +Overview (from the spec) + + The ARB_multisample extension provides a mechanism for antialiasing + primitives. This mechanism allows an application to request an + additional buffer, the multisample buffer, that is added to the + framebuffer. An application can request the number of samples per + fragment that are stored in the multisample buffer. Rendering + proceeds by writing color, depth, and stencil values for each + sample to the multisample buffer. The results are automatically + resolved to a single displayable color each time a pixel is + updated. + + Coverage Sample Anti-Aliasing (CSAA) is an extension to multisample + antialiasing. The technique separates "samples" into two types of + samples. "Color samples" are samples with color, depth, and + stencil information stored in the multisample buffer. "Coverage + samples" include both color samples and additional samples that only + provide pixel coverage information. + + This extension follows the example of the + NV_framebuffer_multisample_coverage extension, which adds CSAA + support for framebuffer objects. The base description of + multisample rendering is written in terms of coverage samples and + color samples. The windows system notion of "samples" + (SAMPLES_ARB) is layered on top of coverage and color samples. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/multisample_coverage.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLX import _types, _glgets +from OpenGL.raw.GLX.NV.multisample_coverage import * +from OpenGL.raw.GLX.NV.multisample_coverage import _EXTENSION_NAME + +def glInitMultisampleCoverageNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/NV/present_video.py b/venv/lib/python3.12/site-packages/OpenGL/GLX/NV/present_video.py new file mode 100644 index 00000000..c83f54b9 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLX/NV/present_video.py @@ -0,0 +1,40 @@ +'''OpenGL extension NV.present_video + +This module customises the behaviour of the +OpenGL.raw.GLX.NV.present_video to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides a mechanism for displaying textures and + renderbuffers on auxiliary video output devices. It allows an + application to specify separate buffers for the individual + fields used with interlaced output. It also provides a way + to present frames or field pairs simultaneously in two separate + video streams. It also allows an application to request when images + should be displayed, and to obtain feedback on exactly when images + are actually first displayed. + + This specification attempts to avoid language that would tie it to + any particular hardware or vendor. However, it should be noted that + it has been designed specifically for use with NVIDIA SDI products + and the features and limitations of the spec compliment those of + NVIDIA's line of SDI video output devices. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/present_video.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLX import _types, _glgets +from OpenGL.raw.GLX.NV.present_video import * +from OpenGL.raw.GLX.NV.present_video import _EXTENSION_NAME + +def glInitPresentVideoNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/NV/robustness_video_memory_purge.py b/venv/lib/python3.12/site-packages/OpenGL/GLX/NV/robustness_video_memory_purge.py new file mode 100644 index 00000000..a923fc96 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLX/NV/robustness_video_memory_purge.py @@ -0,0 +1,48 @@ +'''OpenGL extension NV.robustness_video_memory_purge + +This module customises the behaviour of the +OpenGL.raw.GLX.NV.robustness_video_memory_purge to provide a more +Python-friendly API + +Overview (from the spec) + + Allow applications to be notified when video memory has been purged. + + The NVIDIA OpenGL driver architecture on Linux has a limitation: + resources located in video memory are not persistent across certain + events. VT switches, suspend/resume events, and mode switching + events may erase the contents of video memory. Any resource that + is located exclusively in video memory, such as framebuffer objects + (FBOs), will be lost. As the OpenGL specification makes no mention + of events where the video memory is allowed to be cleared, the + driver attempts to hide this fact from the application, but cannot + do it for all resources. + + This extension provides a way for applications to discover when video + memory content has been lost, so that the application can re-populate + the video memory content as necessary. + + This extension will have a limited lifespan, as planned architectural + evolutions in the NVIDIA Linux driver stack will allow + video memory to be persistent. Any driver that exposes this + extension is a driver that considers video memory to be + volatile. Once the driver stack has been improved, the extension + will no longer be exposed. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/robustness_video_memory_purge.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLX import _types, _glgets +from OpenGL.raw.GLX.NV.robustness_video_memory_purge import * +from OpenGL.raw.GLX.NV.robustness_video_memory_purge import _EXTENSION_NAME + +def glInitRobustnessVideoMemoryPurgeNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/NV/swap_group.py b/venv/lib/python3.12/site-packages/OpenGL/GLX/NV/swap_group.py new file mode 100644 index 00000000..229ba3bb --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLX/NV/swap_group.py @@ -0,0 +1,23 @@ +'''OpenGL extension NV.swap_group + +This module customises the behaviour of the +OpenGL.raw.GLX.NV.swap_group to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/swap_group.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLX import _types, _glgets +from OpenGL.raw.GLX.NV.swap_group import * +from OpenGL.raw.GLX.NV.swap_group import _EXTENSION_NAME + +def glInitSwapGroupNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/NV/video_capture.py b/venv/lib/python3.12/site-packages/OpenGL/GLX/NV/video_capture.py new file mode 100644 index 00000000..dcd7b541 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLX/NV/video_capture.py @@ -0,0 +1,31 @@ +'''OpenGL extension NV.video_capture + +This module customises the behaviour of the +OpenGL.raw.GLX.NV.video_capture to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides a mechanism for streaming video data + directly into texture objects and buffer objects. Applications can + then display video streams in interactive 3D scenes and/or + manipulate the video data using the GL's image processing + capabilities. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/video_capture.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLX import _types, _glgets +from OpenGL.raw.GLX.NV.video_capture import * +from OpenGL.raw.GLX.NV.video_capture import _EXTENSION_NAME + +def glInitVideoCaptureNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/NV/video_out.py b/venv/lib/python3.12/site-packages/OpenGL/GLX/NV/video_out.py new file mode 100644 index 00000000..fe1cb3a9 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLX/NV/video_out.py @@ -0,0 +1,23 @@ +'''OpenGL extension NV.video_out + +This module customises the behaviour of the +OpenGL.raw.GLX.NV.video_out to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/video_out.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLX import _types, _glgets +from OpenGL.raw.GLX.NV.video_out import * +from OpenGL.raw.GLX.NV.video_out import _EXTENSION_NAME + +def glInitVideoOutNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/NV/video_output.py b/venv/lib/python3.12/site-packages/OpenGL/GLX/NV/video_output.py new file mode 100644 index 00000000..cb1eeaa1 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLX/NV/video_output.py @@ -0,0 +1,23 @@ +'''OpenGL extension NV.video_output + +This module customises the behaviour of the +OpenGL.raw.GLX.NV.video_output to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/video_output.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLX import _types, _glgets +from OpenGL.raw.GLX.NV.video_output import * +from OpenGL.raw.GLX.NV.video_output import _EXTENSION_NAME + +def glInitVideoOutputNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/OML/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/GLX/OML/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLX/OML/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/OML/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLX/OML/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..125c1e02 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLX/OML/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/OML/__pycache__/swap_method.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLX/OML/__pycache__/swap_method.cpython-312.pyc new file mode 100644 index 00000000..1ff6544b Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLX/OML/__pycache__/swap_method.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/OML/__pycache__/sync_control.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLX/OML/__pycache__/sync_control.cpython-312.pyc new file mode 100644 index 00000000..36088f3f Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLX/OML/__pycache__/sync_control.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/OML/swap_method.py b/venv/lib/python3.12/site-packages/OpenGL/GLX/OML/swap_method.py new file mode 100644 index 00000000..0e7bc332 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLX/OML/swap_method.py @@ -0,0 +1,23 @@ +'''OpenGL extension OML.swap_method + +This module customises the behaviour of the +OpenGL.raw.GLX.OML.swap_method to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/OML/swap_method.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLX import _types, _glgets +from OpenGL.raw.GLX.OML.swap_method import * +from OpenGL.raw.GLX.OML.swap_method import _EXTENSION_NAME + +def glInitSwapMethodOML(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/OML/sync_control.py b/venv/lib/python3.12/site-packages/OpenGL/GLX/OML/sync_control.py new file mode 100644 index 00000000..904b6201 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLX/OML/sync_control.py @@ -0,0 +1,23 @@ +'''OpenGL extension OML.sync_control + +This module customises the behaviour of the +OpenGL.raw.GLX.OML.sync_control to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/OML/sync_control.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLX import _types, _glgets +from OpenGL.raw.GLX.OML.sync_control import * +from OpenGL.raw.GLX.OML.sync_control import _EXTENSION_NAME + +def glInitSyncControlOML(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/SGI/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/GLX/SGI/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLX/SGI/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/SGI/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLX/SGI/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..53002d33 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLX/SGI/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/SGI/__pycache__/cushion.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLX/SGI/__pycache__/cushion.cpython-312.pyc new file mode 100644 index 00000000..e3dc098d Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLX/SGI/__pycache__/cushion.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/SGI/__pycache__/make_current_read.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLX/SGI/__pycache__/make_current_read.cpython-312.pyc new file mode 100644 index 00000000..1ee5147b Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLX/SGI/__pycache__/make_current_read.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/SGI/__pycache__/swap_control.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLX/SGI/__pycache__/swap_control.cpython-312.pyc new file mode 100644 index 00000000..aa7daff5 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLX/SGI/__pycache__/swap_control.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/SGI/__pycache__/video_sync.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLX/SGI/__pycache__/video_sync.cpython-312.pyc new file mode 100644 index 00000000..764efb27 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLX/SGI/__pycache__/video_sync.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/SGI/cushion.py b/venv/lib/python3.12/site-packages/OpenGL/GLX/SGI/cushion.py new file mode 100644 index 00000000..d77424f0 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLX/SGI/cushion.py @@ -0,0 +1,23 @@ +'''OpenGL extension SGI.cushion + +This module customises the behaviour of the +OpenGL.raw.GLX.SGI.cushion to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/SGI/cushion.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLX import _types, _glgets +from OpenGL.raw.GLX.SGI.cushion import * +from OpenGL.raw.GLX.SGI.cushion import _EXTENSION_NAME + +def glInitCushionSGI(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/SGI/make_current_read.py b/venv/lib/python3.12/site-packages/OpenGL/GLX/SGI/make_current_read.py new file mode 100644 index 00000000..490d168a --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLX/SGI/make_current_read.py @@ -0,0 +1,23 @@ +'''OpenGL extension SGI.make_current_read + +This module customises the behaviour of the +OpenGL.raw.GLX.SGI.make_current_read to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/SGI/make_current_read.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLX import _types, _glgets +from OpenGL.raw.GLX.SGI.make_current_read import * +from OpenGL.raw.GLX.SGI.make_current_read import _EXTENSION_NAME + +def glInitMakeCurrentReadSGI(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/SGI/swap_control.py b/venv/lib/python3.12/site-packages/OpenGL/GLX/SGI/swap_control.py new file mode 100644 index 00000000..a2351b7a --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLX/SGI/swap_control.py @@ -0,0 +1,23 @@ +'''OpenGL extension SGI.swap_control + +This module customises the behaviour of the +OpenGL.raw.GLX.SGI.swap_control to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/SGI/swap_control.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLX import _types, _glgets +from OpenGL.raw.GLX.SGI.swap_control import * +from OpenGL.raw.GLX.SGI.swap_control import _EXTENSION_NAME + +def glInitSwapControlSGI(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/SGI/video_sync.py b/venv/lib/python3.12/site-packages/OpenGL/GLX/SGI/video_sync.py new file mode 100644 index 00000000..15c7af90 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLX/SGI/video_sync.py @@ -0,0 +1,23 @@ +'''OpenGL extension SGI.video_sync + +This module customises the behaviour of the +OpenGL.raw.GLX.SGI.video_sync to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/SGI/video_sync.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLX import _types, _glgets +from OpenGL.raw.GLX.SGI.video_sync import * +from OpenGL.raw.GLX.SGI.video_sync import _EXTENSION_NAME + +def glInitVideoSyncSGI(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/SGIS/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/GLX/SGIS/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLX/SGIS/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/SGIS/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLX/SGIS/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..b850cf7d Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLX/SGIS/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/SGIS/__pycache__/blended_overlay.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLX/SGIS/__pycache__/blended_overlay.cpython-312.pyc new file mode 100644 index 00000000..d2b5b087 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLX/SGIS/__pycache__/blended_overlay.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/SGIS/__pycache__/multisample.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLX/SGIS/__pycache__/multisample.cpython-312.pyc new file mode 100644 index 00000000..4cc0d6a9 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLX/SGIS/__pycache__/multisample.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/SGIS/__pycache__/shared_multisample.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLX/SGIS/__pycache__/shared_multisample.cpython-312.pyc new file mode 100644 index 00000000..102140ad Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLX/SGIS/__pycache__/shared_multisample.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/SGIS/blended_overlay.py b/venv/lib/python3.12/site-packages/OpenGL/GLX/SGIS/blended_overlay.py new file mode 100644 index 00000000..30b1329f --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLX/SGIS/blended_overlay.py @@ -0,0 +1,23 @@ +'''OpenGL extension SGIS.blended_overlay + +This module customises the behaviour of the +OpenGL.raw.GLX.SGIS.blended_overlay to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/SGIS/blended_overlay.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLX import _types, _glgets +from OpenGL.raw.GLX.SGIS.blended_overlay import * +from OpenGL.raw.GLX.SGIS.blended_overlay import _EXTENSION_NAME + +def glInitBlendedOverlaySGIS(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/SGIS/multisample.py b/venv/lib/python3.12/site-packages/OpenGL/GLX/SGIS/multisample.py new file mode 100644 index 00000000..e21ef0f4 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLX/SGIS/multisample.py @@ -0,0 +1,51 @@ +'''OpenGL extension SGIS.multisample + +This module customises the behaviour of the +OpenGL.raw.GLX.SGIS.multisample to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides a mechanism to antialias all GL primitives: + points, lines, polygons, bitmaps, and images. The technique is to + sample all primitives multiple times at each pixel. The color sample + values are resolved to a single, displayable color each time a pixel + is updated, so the antialiasing appears to be automatic at the + application level. Because each sample includes depth and stencil + information, the depth and stencil functions perform equivalently + to the single-sample mode. + + An additional buffer, called the multisample buffer, is added to + the framebuffer. Pixel sample values, including color, depth, and + stencil values, are stored in this buffer. When the framebuffer + includes a multisample buffer, it does not also include separate + depth or stencil buffers, even if the multisample buffer does not + store depth or stencil values. Color buffers (left/right, front/ + back, and aux) do coexist with the multisample buffer, however. + + Multisample antialiasing is most valuable for rendering polygons, + because it requires no sorting for hidden surface elimination, and + it correctly handles adjacent polygons, object silhouettes, and + even intersecting polygons. If only points or lines are being + rendered, the "smooth" antialiasing mechanism provided by the base + GL may result in a higher quality image. This extension is designed + to allow multisample and smooth antialiasing techniques to be + alternated during the rendering of a single scene. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/SGIS/multisample.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLX import _types, _glgets +from OpenGL.raw.GLX.SGIS.multisample import * +from OpenGL.raw.GLX.SGIS.multisample import _EXTENSION_NAME + +def glInitMultisampleSGIS(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/SGIS/shared_multisample.py b/venv/lib/python3.12/site-packages/OpenGL/GLX/SGIS/shared_multisample.py new file mode 100644 index 00000000..aedc5046 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLX/SGIS/shared_multisample.py @@ -0,0 +1,93 @@ +'''OpenGL extension SGIS.shared_multisample + +This module customises the behaviour of the +OpenGL.raw.GLX.SGIS.shared_multisample to provide a more +Python-friendly API + +Overview (from the spec) + + While the OpenGL multisample extension (SGIS_multisample) provides + good out-of-order antialiasing via subpixel samples, multisample + hardware is very expensive because it multiplies the per-pixel + framebuffer memory required to maintain color, depth, and stencil + state by the number of samples. + + The cost-sensitive Location Based Entertainment (LBE) market + desires good quality antialiasing, but the cost of maintaining + multisample memory for every pixel in the framebuffer managed area + is often prohibitive. Low-end multi-channel visual simulation may + have similar cost constraints. + + LBE applications typically render several channels that are output + to different video display devices. For example, an LBE + application may render four 800x600 resolution channels, one per + game player. While the total managed area may be 1600x1200, each + channel ends up being rendered serially. With traditional + multisampling (as specified by SGIS_multisample), multisample + memory must be retained across the entire 1600x1200 managed area + though in fact the application is never using more than an 800x600 + rectangle of multisample pixel state at any given time. + + This sharing of multisample framebuffer state can result in a + substantial competitive advantage for high-end multi-channel + multisampling hardware for LBE applications. Unlike a "cheap PC + per seat" solution, a high-end solution can be amortized by sharing + both texture and multisample memory between the multiple channels + (as well as host resources such as disk and CPUs). For cheap PCs + to have the same amount of texture memory and quality of + antialiasing, texture and multisample memory have to be replicated + in every PC. + + In a typical windowed environment, the entire framebuffer managed + area must retain multisample state because windows can be moved + dynamically and resized (up to the entire size of the managed + area). For LBE applications though, the layout of channel + subrectangles in the framebuffer managed area is static and the + LBE application monopolizes the graphics device (no other + concurrent windowed apps). Because of their channel-oriented, + dedicated, cost-sensitive nature, LBE applications can benefit from + a means to share the available multisample memory resources among + all the channels. + + The SGIS_shared_multisample extension specifies a single + multisample buffer subrectangle sized smaller than the total + managed area that is both shared among multiple windows and + repositionable within in a window. + + Use of the SGIS_shared_multisample extension is predicated on + specially configuring the window system, typically via a command + line option added to the window system server's startup command. + When run in this mode, OpenGL applications will see the + GL_SGIS_shared_multisample string advertised in the GL_EXTENSIONS + string (along with the GL_SGIS_multisample string). In this mode, + the behavior of multisample extension changes. Instead of the + multisample buffer memory being retained per-pixel across the + entire managed area, multisample memory is shared among multisample + windows and repositionable within a multisample window. + + Switching windows or repositioning the multisample subrectangle + will make undefined the shared state within the multisample, depth, + stencil, and accumulation buffers. + + When rendering into a multisample window, fragments that fall + outside the window's multisample subrectangle are discarded + (scissored). By default, the window's multisample rectangle is + positioned at its window origin. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/SGIS/shared_multisample.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLX import _types, _glgets +from OpenGL.raw.GLX.SGIS.shared_multisample import * +from OpenGL.raw.GLX.SGIS.shared_multisample import _EXTENSION_NAME + +def glInitSharedMultisampleSGIS(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/SGIX/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/GLX/SGIX/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLX/SGIX/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/SGIX/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLX/SGIX/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..77d9a579 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLX/SGIX/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/SGIX/__pycache__/dmbuffer.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLX/SGIX/__pycache__/dmbuffer.cpython-312.pyc new file mode 100644 index 00000000..34bcafd0 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLX/SGIX/__pycache__/dmbuffer.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/SGIX/__pycache__/fbconfig.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLX/SGIX/__pycache__/fbconfig.cpython-312.pyc new file mode 100644 index 00000000..5f56f1eb Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLX/SGIX/__pycache__/fbconfig.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/SGIX/__pycache__/hyperpipe.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLX/SGIX/__pycache__/hyperpipe.cpython-312.pyc new file mode 100644 index 00000000..7736b37e Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLX/SGIX/__pycache__/hyperpipe.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/SGIX/__pycache__/pbuffer.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLX/SGIX/__pycache__/pbuffer.cpython-312.pyc new file mode 100644 index 00000000..f6d24940 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLX/SGIX/__pycache__/pbuffer.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/SGIX/__pycache__/swap_barrier.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLX/SGIX/__pycache__/swap_barrier.cpython-312.pyc new file mode 100644 index 00000000..2eae00d2 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLX/SGIX/__pycache__/swap_barrier.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/SGIX/__pycache__/swap_group.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLX/SGIX/__pycache__/swap_group.cpython-312.pyc new file mode 100644 index 00000000..f1544d3e Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLX/SGIX/__pycache__/swap_group.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/SGIX/__pycache__/video_resize.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLX/SGIX/__pycache__/video_resize.cpython-312.pyc new file mode 100644 index 00000000..55635af5 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLX/SGIX/__pycache__/video_resize.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/SGIX/__pycache__/video_source.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLX/SGIX/__pycache__/video_source.cpython-312.pyc new file mode 100644 index 00000000..f2acc7e8 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLX/SGIX/__pycache__/video_source.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/SGIX/__pycache__/visual_select_group.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLX/SGIX/__pycache__/visual_select_group.cpython-312.pyc new file mode 100644 index 00000000..54ba43b4 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLX/SGIX/__pycache__/visual_select_group.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/SGIX/dmbuffer.py b/venv/lib/python3.12/site-packages/OpenGL/GLX/SGIX/dmbuffer.py new file mode 100644 index 00000000..d7f78537 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLX/SGIX/dmbuffer.py @@ -0,0 +1,23 @@ +'''OpenGL extension SGIX.dmbuffer + +This module customises the behaviour of the +OpenGL.raw.GLX.SGIX.dmbuffer to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/SGIX/dmbuffer.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLX import _types, _glgets +from OpenGL.raw.GLX.SGIX.dmbuffer import * +from OpenGL.raw.GLX.SGIX.dmbuffer import _EXTENSION_NAME + +def glInitDmbufferSGIX(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/SGIX/fbconfig.py b/venv/lib/python3.12/site-packages/OpenGL/GLX/SGIX/fbconfig.py new file mode 100644 index 00000000..101552a9 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLX/SGIX/fbconfig.py @@ -0,0 +1,23 @@ +'''OpenGL extension SGIX.fbconfig + +This module customises the behaviour of the +OpenGL.raw.GLX.SGIX.fbconfig to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/SGIX/fbconfig.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLX import _types, _glgets +from OpenGL.raw.GLX.SGIX.fbconfig import * +from OpenGL.raw.GLX.SGIX.fbconfig import _EXTENSION_NAME + +def glInitFbconfigSGIX(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/SGIX/hyperpipe.py b/venv/lib/python3.12/site-packages/OpenGL/GLX/SGIX/hyperpipe.py new file mode 100644 index 00000000..c7cd0d0f --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLX/SGIX/hyperpipe.py @@ -0,0 +1,23 @@ +'''OpenGL extension SGIX.hyperpipe + +This module customises the behaviour of the +OpenGL.raw.GLX.SGIX.hyperpipe to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/SGIX/hyperpipe.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLX import _types, _glgets +from OpenGL.raw.GLX.SGIX.hyperpipe import * +from OpenGL.raw.GLX.SGIX.hyperpipe import _EXTENSION_NAME + +def glInitHyperpipeSGIX(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/SGIX/pbuffer.py b/venv/lib/python3.12/site-packages/OpenGL/GLX/SGIX/pbuffer.py new file mode 100644 index 00000000..95d331c5 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLX/SGIX/pbuffer.py @@ -0,0 +1,23 @@ +'''OpenGL extension SGIX.pbuffer + +This module customises the behaviour of the +OpenGL.raw.GLX.SGIX.pbuffer to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/SGIX/pbuffer.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLX import _types, _glgets +from OpenGL.raw.GLX.SGIX.pbuffer import * +from OpenGL.raw.GLX.SGIX.pbuffer import _EXTENSION_NAME + +def glInitPbufferSGIX(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/SGIX/swap_barrier.py b/venv/lib/python3.12/site-packages/OpenGL/GLX/SGIX/swap_barrier.py new file mode 100644 index 00000000..1777cad9 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLX/SGIX/swap_barrier.py @@ -0,0 +1,23 @@ +'''OpenGL extension SGIX.swap_barrier + +This module customises the behaviour of the +OpenGL.raw.GLX.SGIX.swap_barrier to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/SGIX/swap_barrier.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLX import _types, _glgets +from OpenGL.raw.GLX.SGIX.swap_barrier import * +from OpenGL.raw.GLX.SGIX.swap_barrier import _EXTENSION_NAME + +def glInitSwapBarrierSGIX(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/SGIX/swap_group.py b/venv/lib/python3.12/site-packages/OpenGL/GLX/SGIX/swap_group.py new file mode 100644 index 00000000..d282236d --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLX/SGIX/swap_group.py @@ -0,0 +1,23 @@ +'''OpenGL extension SGIX.swap_group + +This module customises the behaviour of the +OpenGL.raw.GLX.SGIX.swap_group to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/SGIX/swap_group.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLX import _types, _glgets +from OpenGL.raw.GLX.SGIX.swap_group import * +from OpenGL.raw.GLX.SGIX.swap_group import _EXTENSION_NAME + +def glInitSwapGroupSGIX(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/SGIX/video_resize.py b/venv/lib/python3.12/site-packages/OpenGL/GLX/SGIX/video_resize.py new file mode 100644 index 00000000..31aedd5b --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLX/SGIX/video_resize.py @@ -0,0 +1,23 @@ +'''OpenGL extension SGIX.video_resize + +This module customises the behaviour of the +OpenGL.raw.GLX.SGIX.video_resize to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/SGIX/video_resize.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLX import _types, _glgets +from OpenGL.raw.GLX.SGIX.video_resize import * +from OpenGL.raw.GLX.SGIX.video_resize import _EXTENSION_NAME + +def glInitVideoResizeSGIX(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/SGIX/video_source.py b/venv/lib/python3.12/site-packages/OpenGL/GLX/SGIX/video_source.py new file mode 100644 index 00000000..666b05ad --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLX/SGIX/video_source.py @@ -0,0 +1,23 @@ +'''OpenGL extension SGIX.video_source + +This module customises the behaviour of the +OpenGL.raw.GLX.SGIX.video_source to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/SGIX/video_source.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLX import _types, _glgets +from OpenGL.raw.GLX.SGIX.video_source import * +from OpenGL.raw.GLX.SGIX.video_source import _EXTENSION_NAME + +def glInitVideoSourceSGIX(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/SGIX/visual_select_group.py b/venv/lib/python3.12/site-packages/OpenGL/GLX/SGIX/visual_select_group.py new file mode 100644 index 00000000..401495e5 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLX/SGIX/visual_select_group.py @@ -0,0 +1,23 @@ +'''OpenGL extension SGIX.visual_select_group + +This module customises the behaviour of the +OpenGL.raw.GLX.SGIX.visual_select_group to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/SGIX/visual_select_group.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLX import _types, _glgets +from OpenGL.raw.GLX.SGIX.visual_select_group import * +from OpenGL.raw.GLX.SGIX.visual_select_group import _EXTENSION_NAME + +def glInitVisualSelectGroupSGIX(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/SUN/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/GLX/SUN/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLX/SUN/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/SUN/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLX/SUN/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..24f9df8a Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLX/SUN/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/SUN/__pycache__/get_transparent_index.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLX/SUN/__pycache__/get_transparent_index.cpython-312.pyc new file mode 100644 index 00000000..dca03826 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLX/SUN/__pycache__/get_transparent_index.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/SUN/get_transparent_index.py b/venv/lib/python3.12/site-packages/OpenGL/GLX/SUN/get_transparent_index.py new file mode 100644 index 00000000..b410aae9 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLX/SUN/get_transparent_index.py @@ -0,0 +1,23 @@ +'''OpenGL extension SUN.get_transparent_index + +This module customises the behaviour of the +OpenGL.raw.GLX.SUN.get_transparent_index to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/SUN/get_transparent_index.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLX import _types, _glgets +from OpenGL.raw.GLX.SUN.get_transparent_index import * +from OpenGL.raw.GLX.SUN.get_transparent_index import _EXTENSION_NAME + +def glInitGetTransparentIndexSUN(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/VERSION/GLX_1_0.py b/venv/lib/python3.12/site-packages/OpenGL/GLX/VERSION/GLX_1_0.py new file mode 100644 index 00000000..2ac67d41 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLX/VERSION/GLX_1_0.py @@ -0,0 +1,23 @@ +'''OpenGL extension VERSION.GLX_1_0 + +This module customises the behaviour of the +OpenGL.raw.GLX.VERSION.GLX_1_0 to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/VERSION/GLX_1_0.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLX import _types, _glgets +from OpenGL.raw.GLX.VERSION.GLX_1_0 import * +from OpenGL.raw.GLX.VERSION.GLX_1_0 import _EXTENSION_NAME + +def glInitGlx10VERSION(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/VERSION/GLX_1_1.py b/venv/lib/python3.12/site-packages/OpenGL/GLX/VERSION/GLX_1_1.py new file mode 100644 index 00000000..cdf646e0 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLX/VERSION/GLX_1_1.py @@ -0,0 +1,23 @@ +'''OpenGL extension VERSION.GLX_1_1 + +This module customises the behaviour of the +OpenGL.raw.GLX.VERSION.GLX_1_1 to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/VERSION/GLX_1_1.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLX import _types, _glgets +from OpenGL.raw.GLX.VERSION.GLX_1_1 import * +from OpenGL.raw.GLX.VERSION.GLX_1_1 import _EXTENSION_NAME + +def glInitGlx11VERSION(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/VERSION/GLX_1_2.py b/venv/lib/python3.12/site-packages/OpenGL/GLX/VERSION/GLX_1_2.py new file mode 100644 index 00000000..517542be --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLX/VERSION/GLX_1_2.py @@ -0,0 +1,23 @@ +'''OpenGL extension VERSION.GLX_1_2 + +This module customises the behaviour of the +OpenGL.raw.GLX.VERSION.GLX_1_2 to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/VERSION/GLX_1_2.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLX import _types, _glgets +from OpenGL.raw.GLX.VERSION.GLX_1_2 import * +from OpenGL.raw.GLX.VERSION.GLX_1_2 import _EXTENSION_NAME + +def glInitGlx12VERSION(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/VERSION/GLX_1_3.py b/venv/lib/python3.12/site-packages/OpenGL/GLX/VERSION/GLX_1_3.py new file mode 100644 index 00000000..53d63705 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLX/VERSION/GLX_1_3.py @@ -0,0 +1,23 @@ +'''OpenGL extension VERSION.GLX_1_3 + +This module customises the behaviour of the +OpenGL.raw.GLX.VERSION.GLX_1_3 to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/VERSION/GLX_1_3.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLX import _types, _glgets +from OpenGL.raw.GLX.VERSION.GLX_1_3 import * +from OpenGL.raw.GLX.VERSION.GLX_1_3 import _EXTENSION_NAME + +def glInitGlx13VERSION(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/VERSION/GLX_1_4.py b/venv/lib/python3.12/site-packages/OpenGL/GLX/VERSION/GLX_1_4.py new file mode 100644 index 00000000..7bd18f7e --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLX/VERSION/GLX_1_4.py @@ -0,0 +1,23 @@ +'''OpenGL extension VERSION.GLX_1_4 + +This module customises the behaviour of the +OpenGL.raw.GLX.VERSION.GLX_1_4 to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/VERSION/GLX_1_4.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.GLX import _types, _glgets +from OpenGL.raw.GLX.VERSION.GLX_1_4 import * +from OpenGL.raw.GLX.VERSION.GLX_1_4 import _EXTENSION_NAME + +def glInitGlx14VERSION(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/VERSION/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/GLX/VERSION/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLX/VERSION/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/VERSION/__pycache__/GLX_1_0.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLX/VERSION/__pycache__/GLX_1_0.cpython-312.pyc new file mode 100644 index 00000000..936e79ea Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLX/VERSION/__pycache__/GLX_1_0.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/VERSION/__pycache__/GLX_1_1.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLX/VERSION/__pycache__/GLX_1_1.cpython-312.pyc new file mode 100644 index 00000000..2b6f5576 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLX/VERSION/__pycache__/GLX_1_1.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/VERSION/__pycache__/GLX_1_2.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLX/VERSION/__pycache__/GLX_1_2.cpython-312.pyc new file mode 100644 index 00000000..b3c5122d Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLX/VERSION/__pycache__/GLX_1_2.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/VERSION/__pycache__/GLX_1_3.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLX/VERSION/__pycache__/GLX_1_3.cpython-312.pyc new file mode 100644 index 00000000..53420eb8 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLX/VERSION/__pycache__/GLX_1_3.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/VERSION/__pycache__/GLX_1_4.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLX/VERSION/__pycache__/GLX_1_4.cpython-312.pyc new file mode 100644 index 00000000..ee049886 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLX/VERSION/__pycache__/GLX_1_4.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/VERSION/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLX/VERSION/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..56e5f7ff Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLX/VERSION/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/GLX/__init__.py new file mode 100644 index 00000000..201982b2 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/GLX/__init__.py @@ -0,0 +1,7 @@ +"""Platform-specific functions/support for the xorg/X11 windowing system""" +from OpenGL.raw.GLX._types import * +from OpenGL.GLX.VERSION.GLX_1_0 import * +from OpenGL.GLX.VERSION.GLX_1_1 import * +from OpenGL.GLX.VERSION.GLX_1_2 import * +from OpenGL.GLX.VERSION.GLX_1_3 import * +from OpenGL.GLX.VERSION.GLX_1_4 import * diff --git a/venv/lib/python3.12/site-packages/OpenGL/GLX/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/GLX/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..0c2e5e25 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/GLX/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/Tk/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/Tk/__init__.py new file mode 100644 index 00000000..231c79ba --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/Tk/__init__.py @@ -0,0 +1,576 @@ +"""Traditional PyOpenGL interface to Togl + +This module provides access to the Tkinter Togl widget +with a relatively "thick" wrapper API that creates a set +of default "examination" operations. + +Note that many (most) Linux distributions have +now split out the Tkinter bindings into a separate package, +and that Togl must be separately downloaded (a script is +provided in the source distribution which downloads and +installs Togl 2.0 binaries for you). + +Because of the complexity and fragility of the installation, +it is recommended that you use Pygame, wxPython, PyGtk, or +PyQt for real-world projects, and GLUT or Pygame for simple +demo/testing interfaces. + +The Togl project is located here: + + http://togl.sourceforge.net/ +""" +# A class that creates an opengl widget. +# Mike Hartshorn +# Department of Chemistry +# University of York, UK +import os,sys, logging +_log = logging.getLogger( 'OpenGL.Tk' ) +from OpenGL.GL import * +from OpenGL.GLU import * +try: + from tkinter import _default_root + from tkinter import * + from tkinter import dialog +except ImportError as err: + try: + from Tkinter import _default_root + from Tkinter import * + import Dialog as dialog + except ImportError as err: + _log.error( """Unable to import Tkinter, likely need to install a separate package (python-tk) to have Tkinter support. You likely also want to run the src/togl.py script in the PyOpenGL source distribution to install the Togl widget""" ) + raise +import math + +def glTranslateScene(s, x, y, mousex, mousey): + glMatrixMode(GL_MODELVIEW) + mat = glGetDoublev(GL_MODELVIEW_MATRIX) + glLoadIdentity() + glTranslatef(s * (x - mousex), s * (mousey - y), 0.0) + glMultMatrixd(mat) + + +def glRotateScene(s, xcenter, ycenter, zcenter, x, y, mousex, mousey): + glMatrixMode(GL_MODELVIEW) + mat = glGetDoublev(GL_MODELVIEW_MATRIX) + glLoadIdentity() + glTranslatef(xcenter, ycenter, zcenter) + glRotatef(s * (y - mousey), 1., 0., 0.) + glRotatef(s * (x - mousex), 0., 1., 0.) + glTranslatef(-xcenter, -ycenter, -zcenter) + glMultMatrixd(mat) + + +def sub(x, y): + return list(map(lambda a, b: a-b, x, y)) + + +def dot(x, y): + t = 0 + for i in range(len(x)): + t = t + x[i]*y[i] + return t + + +def glDistFromLine(x, p1, p2): + f = list(map(lambda x, y: x-y, p2, p1)) + g = list(map(lambda x, y: x-y, x, p1)) + return dot(g, g) - dot(f, g)**2/dot(f, f) + + +# Keith Junius provided many changes to Togl +TOGL_NORMAL = 1 +TOGL_OVERLAY = 2 + +def v3distsq(a,b): + d = ( a[0] - b[0], a[1] - b[1], a[2] - b[2] ) + return d[0]*d[0] + d[1]*d[1] + d[2]*d[2] + +# new version from Daniel Faken (Daniel_Faken@brown.edu) for static +# loading comptability +if _default_root is None: + _default_root = Tk() + +# Add this file's directory to Tcl's search path +# This code is intended to work with the src/togl.py script +# which will populate the directory with the appropriate +# Binary Togl distribution. Note that Togl 2.0 and above +# uses "stubs", so we don't care what Tk version we are using, +# but that a different build is required for 64-bit Python. +# Thus the directory structure is *not* the same as the +# original PyOpenGL versions. +if sys.maxsize > 2**32: + suffix = '-64' +else: + suffix = '' +try: + TOGL_DLL_PATH = os.path.join( + os.path.dirname(__file__), + 'togl-'+ sys.platform + suffix, + ) +except NameError as err: + # no __file__, likely running as an egg + TOGL_DLL_PATH = "" + +if not os.path.isdir( TOGL_DLL_PATH ): + _log.warning( 'Expected Tk Togl installation in %s', TOGL_DLL_PATH ) +_log.info( 'Loading Togl from: %s', TOGL_DLL_PATH ) +_default_root.tk.call('lappend', 'auto_path', TOGL_DLL_PATH) +try: + _default_root.tk.call('package', 'require', 'Togl') + _default_root.tk.eval('load {} Togl') +except TclError as err: + _log.error( """Failure loading Togl package: %s, on debian systems this is provided by `libtogl2`""", err ) + if _default_root: + _default_root.destroy() + raise + +# This code is needed to avoid faults on sys.exit() +# [DAA, Jan 1998], updated by mcfletch 2009 +import atexit +def cleanup(): + try: + import tkinter + except ImportError: + import Tkinter as tkinter + try: + if tkinter._default_root: tkinter._default_root.destroy() + except (TclError,AttributeError): + pass + tkinter._default_root = None +atexit.register( cleanup ) + +class Togl(Widget): + """ + Togl Widget + Keith Junius + Department of Biophysical Chemistry + University of Groningen, The Netherlands + Very basic widget which provides access to Togl functions. + """ + def __init__(self, master=None, cnf={}, **kw): + Widget.__init__(self, master, 'togl', cnf, kw) + + + def render(self): + return + + + def swapbuffers(self): + self.tk.call(self._w, 'swapbuffers') + + + def makecurrent(self): + self.tk.call(self._w, 'makecurrent') + + + def alloccolor(self, red, green, blue): + return self.tk.getint(self.tk.call(self._w, 'alloccolor', red, green, blue)) + + + def freecolor(self, index): + self.tk.call(self._w, 'freecolor', index) + + + def setcolor(self, index, red, green, blue): + self.tk.call(self._w, 'setcolor', index, red, green, blue) + + + def loadbitmapfont(self, fontname): + return self.tk.getint(self.tk.call(self._w, 'loadbitmapfont', fontname)) + + + def unloadbitmapfont(self, fontbase): + self.tk.call(self._w, 'unloadbitmapfont', fontbase) + + + def uselayer(self, layer): + self.tk.call(self._w, 'uselayer', layer) + + + def showoverlay(self): + self.tk.call(self._w, 'showoverlay') + + + def hideoverlay(self): + self.tk.call(self._w, 'hideoverlay') + + + def existsoverlay(self): + return self.tk.getboolean(self.tk.call(self._w, 'existsoverlay')) + + + def getoverlaytransparentvalue(self): + return self.tk.getint(self.tk.call(self._w, 'getoverlaytransparentvalue')) + + + def ismappedoverlay(self): + return self.tk.getboolean(self.tk.call(self._w, 'ismappedoverlay')) + + + def alloccoloroverlay(self, red, green, blue): + return self.tk.getint(self.tk.call(self._w, 'alloccoloroverlay', red, green, blue)) + + + def freecoloroverlay(self, index): + self.tk.call(self._w, 'freecoloroverlay', index) + + + +class RawOpengl(Widget, Misc): + """Widget without any sophisticated bindings\ + by Tom Schwaller""" + + + def __init__(self, master=None, cnf={}, **kw): + Widget.__init__(self, master, 'togl', cnf, kw) + self.bind('', self.tkMap) + self.bind('', self.tkExpose) + self.bind('', self.tkExpose) + + + def tkRedraw(self, *dummy): + # This must be outside of a pushmatrix, since a resize event + # will call redraw recursively. + self.update_idletasks() + self.tk.call(self._w, 'makecurrent') + _mode = glGetDoublev(GL_MATRIX_MODE) + try: + glMatrixMode(GL_PROJECTION) + glPushMatrix() + try: + self.redraw() + glFlush() + finally: + glPopMatrix() + finally: + glMatrixMode(_mode) + self.tk.call(self._w, 'swapbuffers') + + + def tkMap(self, *dummy): + self.tkExpose() + + + def tkExpose(self, *dummy): + self.tkRedraw() + + + + +class Opengl(RawOpengl): + """\ +Tkinter bindings for an Opengl widget. +Mike Hartshorn +Department of Chemistry +University of York, UK +http://www.yorvic.york.ac.uk/~mjh/ +""" + + def __init__(self, master=None, cnf={}, **kw): + """\ + Create an opengl widget. + Arrange for redraws when the window is exposed or when + it changes size.""" + + #Widget.__init__(self, master, 'togl', cnf, kw) + RawOpengl.__init__(*(self, master, cnf), **kw) + self.initialised = 0 + + # Current coordinates of the mouse. + self.xmouse = 0 + self.ymouse = 0 + + # Where we are centering. + self.xcenter = 0.0 + self.ycenter = 0.0 + self.zcenter = 0.0 + + # The _back color + self.r_back = 1. + self.g_back = 0. + self.b_back = 1. + + # Where the eye is + self.distance = 10.0 + + # Field of view in y direction + self.fovy = 30.0 + + # Position of clipping planes. + self.near = 0.1 + self.far = 1000.0 + + # Is the widget allowed to autospin? + self.autospin_allowed = 0 + + # Is the widget currently autospinning? + self.autospin = 0 + + # Basic bindings for the virtual trackball + self.bind('', self.tkMap) + self.bind('', self.tkExpose) + self.bind('', self.tkExpose) + self.bind('', self.tkHandlePick) + #self.bind('', self.tkHandlePick) + self.bind('', self.tkRecordMouse) + self.bind('', self.tkTranslate) + self.bind('', self.StartRotate) + self.bind('', self.tkRotate) + self.bind('', self.tkAutoSpin) + self.bind('', self.tkRecordMouse) + self.bind('', self.tkScale) + + + def help(self): + """Help for the widget.""" + + d = dialog.Dialog(None, {'title': 'Viewer help', + 'text': 'Button-1: Translate\n' + 'Button-2: Rotate\n' + 'Button-3: Zoom\n' + 'Reset: Resets transformation to identity\n', + 'bitmap': 'questhead', + 'default': 0, + 'strings': ('Done', 'Ok')}) + assert d + + def activate(self): + """Cause this Opengl widget to be the current destination for drawing.""" + + self.tk.call(self._w, 'makecurrent') + + + # This should almost certainly be part of some derived class. + # But I have put it here for convenience. + def basic_lighting(self): + """\ + Set up some basic lighting (single infinite light source). + + Also switch on the depth buffer.""" + + self.activate() + light_position = (1, 1, 1, 0) + glLightfv(GL_LIGHT0, GL_POSITION, light_position) + glEnable(GL_LIGHTING) + glEnable(GL_LIGHT0) + glDepthFunc(GL_LESS) + glEnable(GL_DEPTH_TEST) + glMatrixMode(GL_MODELVIEW) + glLoadIdentity() + + def set_background(self, r, g, b): + """Change the background colour of the widget.""" + + self.r_back = r + self.g_back = g + self.b_back = b + + self.tkRedraw() + + + def set_centerpoint(self, x, y, z): + """Set the new center point for the model. + This is where we are looking.""" + + self.xcenter = x + self.ycenter = y + self.zcenter = z + + self.tkRedraw() + + + def set_eyepoint(self, distance): + """Set how far the eye is from the position we are looking.""" + + self.distance = distance + self.tkRedraw() + + + def reset(self): + """Reset rotation matrix for this widget.""" + + glMatrixMode(GL_MODELVIEW) + glLoadIdentity() + self.tkRedraw() + + + def tkHandlePick(self, event): + """Handle a pick on the scene.""" + + if hasattr(self, 'pick'): + # here we need to use glu.UnProject + + # Tk and X have their origin top left, + # while Opengl has its origin bottom left. + # So we need to subtract y from the window height to get + # the proper pick position for Opengl + + realy = self.winfo_height() - event.y + + p1 = gluUnProject(event.x, realy, 0.) + p2 = gluUnProject(event.x, realy, 1.) + + if self.pick(self, p1, p2): + """If the pick method returns true we redraw the scene.""" + + self.tkRedraw() + + + def tkRecordMouse(self, event): + """Record the current mouse position.""" + + self.xmouse = event.x + self.ymouse = event.y + + + def StartRotate(self, event): + # Switch off any autospinning if it was happening + + self.autospin = 0 + self.tkRecordMouse(event) + + + def tkScale(self, event): + """Scale the scene. Achieved by moving the eye position. + + Dragging up zooms in, while dragging down zooms out + """ + scale = 1 - 0.01 * (event.y - self.ymouse) + # do some sanity checks, scale no more than + # 1:1000 on any given click+drag + if scale < 0.001: + scale = 0.001 + elif scale > 1000: + scale = 1000 + self.distance = self.distance * scale + self.tkRedraw() + self.tkRecordMouse(event) + + + def do_AutoSpin(self): + self.activate() + + glRotateScene(0.5, self.xcenter, self.ycenter, self.zcenter, self.yspin, self.xspin, 0, 0) + self.tkRedraw() + + if self.autospin: + self.after(10, self.do_AutoSpin) + + + def tkAutoSpin(self, event): + """Perform autospin of scene.""" + + self.after(4) + self.update_idletasks() + + # This could be done with one call to pointerxy but I'm not sure + # it would any quicker as we would have to split up the resulting + # string and then conv + + x = self.tk.getint(self.tk.call('winfo', 'pointerx', self._w)) + y = self.tk.getint(self.tk.call('winfo', 'pointery', self._w)) + + if self.autospin_allowed: + if x != event.x_root and y != event.y_root: + self.autospin = 1 + + self.yspin = x - event.x_root + self.xspin = y - event.y_root + + self.after(10, self.do_AutoSpin) + + + def tkRotate(self, event): + """Perform rotation of scene.""" + + self.activate() + glRotateScene(0.5, self.xcenter, self.ycenter, self.zcenter, event.x, event.y, self.xmouse, self.ymouse) + self.tkRedraw() + self.tkRecordMouse(event) + + + def tkTranslate(self, event): + """Perform translation of scene.""" + + self.activate() + + # Scale mouse translations to object viewplane so object tracks with mouse + win_height = max( 1,self.winfo_height() ) + obj_c = ( self.xcenter, self.ycenter, self.zcenter ) + win = gluProject( obj_c[0], obj_c[1], obj_c[2]) + obj = gluUnProject( win[0], win[1] + 0.5 * win_height, win[2]) + dist = math.sqrt( v3distsq( obj, obj_c ) ) + scale = abs( dist / ( 0.5 * win_height ) ) + + glTranslateScene(scale, event.x, event.y, self.xmouse, self.ymouse) + self.tkRedraw() + self.tkRecordMouse(event) + + + def tkRedraw(self, *dummy): + """Cause the opengl widget to redraw itself.""" + + if not self.initialised: return + self.activate() + + glPushMatrix() # Protect our matrix + self.update_idletasks() + self.activate() + w = self.winfo_width() + h = self.winfo_height() + glViewport(0, 0, w, h) + + # Clear the background and depth buffer. + glClearColor(self.r_back, self.g_back, self.b_back, 0.) + glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT) + + glMatrixMode(GL_PROJECTION) + glLoadIdentity() + gluPerspective(self.fovy, float(w)/float(h), self.near, self.far) + + if 0: + # Now translate the scene origin away from the world origin + glMatrixMode(GL_MODELVIEW) + mat = glGetDoublev(GL_MODELVIEW_MATRIX) + glLoadIdentity() + glTranslatef(-self.xcenter, -self.ycenter, -(self.zcenter+self.distance)) + glMultMatrixd(mat) + else: + gluLookAt(self.xcenter, self.ycenter, self.zcenter + self.distance, + self.xcenter, self.ycenter, self.zcenter, + 0., 1., 0.) + glMatrixMode(GL_MODELVIEW) + + # Call objects redraw method. + self.redraw(self) + glFlush() # Tidy up + glPopMatrix() # Restore the matrix + + self.tk.call(self._w, 'swapbuffers') + def redraw( self, *args, **named ): + """Prevent access errors if user doesn't set redraw fast enough""" + + + def tkMap(self, *dummy): + """Cause the opengl widget to redraw itself.""" + + self.tkExpose() + + + def tkExpose(self, *dummy): + """Redraw the widget. + Make it active, update tk events, call redraw procedure and + swap the buffers. Note: swapbuffers is clever enough to + only swap double buffered visuals.""" + + self.activate() + if not self.initialised: + self.basic_lighting() + self.initialised = 1 + self.tkRedraw() + + + def tkPrint(self, file): + """Turn the current scene into PostScript via the feedback buffer.""" + + self.activate() diff --git a/venv/lib/python3.12/site-packages/OpenGL/Tk/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/Tk/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..d8028bb5 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/Tk/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/AMD/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/WGL/AMD/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/WGL/AMD/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/AMD/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/WGL/AMD/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..09929793 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/WGL/AMD/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/AMD/__pycache__/gpu_association.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/WGL/AMD/__pycache__/gpu_association.cpython-312.pyc new file mode 100644 index 00000000..c0ed7a1b Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/WGL/AMD/__pycache__/gpu_association.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/AMD/gpu_association.py b/venv/lib/python3.12/site-packages/OpenGL/WGL/AMD/gpu_association.py new file mode 100644 index 00000000..936cbea4 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/WGL/AMD/gpu_association.py @@ -0,0 +1,23 @@ +'''OpenGL extension AMD.gpu_association + +This module customises the behaviour of the +OpenGL.raw.WGL.AMD.gpu_association to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/AMD/gpu_association.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.WGL import _types, _glgets +from OpenGL.raw.WGL.AMD.gpu_association import * +from OpenGL.raw.WGL.AMD.gpu_association import _EXTENSION_NAME + +def glInitGpuAssociationAMD(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/ARB/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/WGL/ARB/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/WGL/ARB/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/ARB/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/WGL/ARB/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..3c7cac15 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/WGL/ARB/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/ARB/__pycache__/buffer_region.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/WGL/ARB/__pycache__/buffer_region.cpython-312.pyc new file mode 100644 index 00000000..d0014d19 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/WGL/ARB/__pycache__/buffer_region.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/ARB/__pycache__/context_flush_control.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/WGL/ARB/__pycache__/context_flush_control.cpython-312.pyc new file mode 100644 index 00000000..4b756e9b Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/WGL/ARB/__pycache__/context_flush_control.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/ARB/__pycache__/create_context.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/WGL/ARB/__pycache__/create_context.cpython-312.pyc new file mode 100644 index 00000000..094e9588 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/WGL/ARB/__pycache__/create_context.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/ARB/__pycache__/create_context_no_error.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/WGL/ARB/__pycache__/create_context_no_error.cpython-312.pyc new file mode 100644 index 00000000..2c786574 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/WGL/ARB/__pycache__/create_context_no_error.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/ARB/__pycache__/create_context_profile.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/WGL/ARB/__pycache__/create_context_profile.cpython-312.pyc new file mode 100644 index 00000000..87eee4fe Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/WGL/ARB/__pycache__/create_context_profile.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/ARB/__pycache__/create_context_robustness.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/WGL/ARB/__pycache__/create_context_robustness.cpython-312.pyc new file mode 100644 index 00000000..4888d2be Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/WGL/ARB/__pycache__/create_context_robustness.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/ARB/__pycache__/extensions_string.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/WGL/ARB/__pycache__/extensions_string.cpython-312.pyc new file mode 100644 index 00000000..4e2b7813 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/WGL/ARB/__pycache__/extensions_string.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/ARB/__pycache__/framebuffer_sRGB.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/WGL/ARB/__pycache__/framebuffer_sRGB.cpython-312.pyc new file mode 100644 index 00000000..92b35e23 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/WGL/ARB/__pycache__/framebuffer_sRGB.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/ARB/__pycache__/make_current_read.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/WGL/ARB/__pycache__/make_current_read.cpython-312.pyc new file mode 100644 index 00000000..f7c5bc0f Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/WGL/ARB/__pycache__/make_current_read.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/ARB/__pycache__/multisample.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/WGL/ARB/__pycache__/multisample.cpython-312.pyc new file mode 100644 index 00000000..f976ee41 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/WGL/ARB/__pycache__/multisample.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/ARB/__pycache__/pbuffer.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/WGL/ARB/__pycache__/pbuffer.cpython-312.pyc new file mode 100644 index 00000000..52fa06f6 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/WGL/ARB/__pycache__/pbuffer.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/ARB/__pycache__/pixel_format.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/WGL/ARB/__pycache__/pixel_format.cpython-312.pyc new file mode 100644 index 00000000..e98b371d Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/WGL/ARB/__pycache__/pixel_format.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/ARB/__pycache__/pixel_format_float.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/WGL/ARB/__pycache__/pixel_format_float.cpython-312.pyc new file mode 100644 index 00000000..946996bb Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/WGL/ARB/__pycache__/pixel_format_float.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/ARB/__pycache__/render_texture.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/WGL/ARB/__pycache__/render_texture.cpython-312.pyc new file mode 100644 index 00000000..11d5c77a Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/WGL/ARB/__pycache__/render_texture.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/ARB/__pycache__/robustness_application_isolation.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/WGL/ARB/__pycache__/robustness_application_isolation.cpython-312.pyc new file mode 100644 index 00000000..3b3cbea7 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/WGL/ARB/__pycache__/robustness_application_isolation.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/ARB/__pycache__/robustness_share_group_isolation.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/WGL/ARB/__pycache__/robustness_share_group_isolation.cpython-312.pyc new file mode 100644 index 00000000..0d6af78c Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/WGL/ARB/__pycache__/robustness_share_group_isolation.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/ARB/buffer_region.py b/venv/lib/python3.12/site-packages/OpenGL/WGL/ARB/buffer_region.py new file mode 100644 index 00000000..fbe4a12a --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/WGL/ARB/buffer_region.py @@ -0,0 +1,23 @@ +'''OpenGL extension ARB.buffer_region + +This module customises the behaviour of the +OpenGL.raw.WGL.ARB.buffer_region to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/buffer_region.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.WGL import _types, _glgets +from OpenGL.raw.WGL.ARB.buffer_region import * +from OpenGL.raw.WGL.ARB.buffer_region import _EXTENSION_NAME + +def glInitBufferRegionARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/ARB/context_flush_control.py b/venv/lib/python3.12/site-packages/OpenGL/WGL/ARB/context_flush_control.py new file mode 100644 index 00000000..441bea58 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/WGL/ARB/context_flush_control.py @@ -0,0 +1,23 @@ +'''OpenGL extension ARB.context_flush_control + +This module customises the behaviour of the +OpenGL.raw.WGL.ARB.context_flush_control to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/context_flush_control.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.WGL import _types, _glgets +from OpenGL.raw.WGL.ARB.context_flush_control import * +from OpenGL.raw.WGL.ARB.context_flush_control import _EXTENSION_NAME + +def glInitContextFlushControlARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/ARB/create_context.py b/venv/lib/python3.12/site-packages/OpenGL/WGL/ARB/create_context.py new file mode 100644 index 00000000..69c9b33a --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/WGL/ARB/create_context.py @@ -0,0 +1,23 @@ +'''OpenGL extension ARB.create_context + +This module customises the behaviour of the +OpenGL.raw.WGL.ARB.create_context to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/create_context.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.WGL import _types, _glgets +from OpenGL.raw.WGL.ARB.create_context import * +from OpenGL.raw.WGL.ARB.create_context import _EXTENSION_NAME + +def glInitCreateContextARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/ARB/create_context_no_error.py b/venv/lib/python3.12/site-packages/OpenGL/WGL/ARB/create_context_no_error.py new file mode 100644 index 00000000..2067083a --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/WGL/ARB/create_context_no_error.py @@ -0,0 +1,30 @@ +'''OpenGL extension ARB.create_context_no_error + +This module customises the behaviour of the +OpenGL.raw.WGL.ARB.create_context_no_error to provide a more +Python-friendly API + +Overview (from the spec) + + This extension allows the creation of an OpenGL or OpenGL ES context that + doesn't generate errors if the context supports a no error mode. The + implications of this feature are discussed in the GL_KHR_no_error + extension. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/create_context_no_error.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.WGL import _types, _glgets +from OpenGL.raw.WGL.ARB.create_context_no_error import * +from OpenGL.raw.WGL.ARB.create_context_no_error import _EXTENSION_NAME + +def glInitCreateContextNoErrorARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/ARB/create_context_profile.py b/venv/lib/python3.12/site-packages/OpenGL/WGL/ARB/create_context_profile.py new file mode 100644 index 00000000..f7b54d2b --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/WGL/ARB/create_context_profile.py @@ -0,0 +1,23 @@ +'''OpenGL extension ARB.create_context_profile + +This module customises the behaviour of the +OpenGL.raw.WGL.ARB.create_context_profile to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/create_context_profile.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.WGL import _types, _glgets +from OpenGL.raw.WGL.ARB.create_context_profile import * +from OpenGL.raw.WGL.ARB.create_context_profile import _EXTENSION_NAME + +def glInitCreateContextProfileARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/ARB/create_context_robustness.py b/venv/lib/python3.12/site-packages/OpenGL/WGL/ARB/create_context_robustness.py new file mode 100644 index 00000000..b721316d --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/WGL/ARB/create_context_robustness.py @@ -0,0 +1,23 @@ +'''OpenGL extension ARB.create_context_robustness + +This module customises the behaviour of the +OpenGL.raw.WGL.ARB.create_context_robustness to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/create_context_robustness.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.WGL import _types, _glgets +from OpenGL.raw.WGL.ARB.create_context_robustness import * +from OpenGL.raw.WGL.ARB.create_context_robustness import _EXTENSION_NAME + +def glInitCreateContextRobustnessARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/ARB/extensions_string.py b/venv/lib/python3.12/site-packages/OpenGL/WGL/ARB/extensions_string.py new file mode 100644 index 00000000..810de93c --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/WGL/ARB/extensions_string.py @@ -0,0 +1,23 @@ +'''OpenGL extension ARB.extensions_string + +This module customises the behaviour of the +OpenGL.raw.WGL.ARB.extensions_string to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/extensions_string.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.WGL import _types, _glgets +from OpenGL.raw.WGL.ARB.extensions_string import * +from OpenGL.raw.WGL.ARB.extensions_string import _EXTENSION_NAME + +def glInitExtensionsStringARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/ARB/framebuffer_sRGB.py b/venv/lib/python3.12/site-packages/OpenGL/WGL/ARB/framebuffer_sRGB.py new file mode 100644 index 00000000..0e5b04fe --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/WGL/ARB/framebuffer_sRGB.py @@ -0,0 +1,55 @@ +'''OpenGL extension ARB.framebuffer_sRGB + +This module customises the behaviour of the +OpenGL.raw.WGL.ARB.framebuffer_sRGB to provide a more +Python-friendly API + +Overview (from the spec) + + Conventionally, OpenGL assumes framebuffer color components are stored + in a linear color space. In particular, framebuffer blending is a + linear operation. + + The sRGB color space is based on typical (non-linear) monitor + characteristics expected in a dimly lit office. It has been + standardized by the International Electrotechnical Commission (IEC) + as IEC 61966-2-1. The sRGB color space roughly corresponds to 2.2 + gamma correction. + + This extension adds a framebuffer capability for sRGB framebuffer + update and blending. When blending is disabled but the new sRGB + updated mode is enabled (assume the framebuffer supports the + capability), high-precision linear color component values for red, + green, and blue generated by fragment coloring are encoded for sRGB + prior to being written into the framebuffer. When blending is enabled + along with the new sRGB update mode, red, green, and blue framebuffer + color components are treated as sRGB values that are converted to + linear color values, blended with the high-precision color values + generated by fragment coloring, and then the blend result is encoded + for sRGB just prior to being written into the framebuffer. + + The primary motivation for this extension is that it allows OpenGL + applications to render into a framebuffer that is scanned to a monitor + configured to assume framebuffer color values are sRGB encoded. + This assumption is roughly true of most PC monitors with default + gamma correction. This allows applications to achieve faithful + color reproduction for OpenGL rendering without adjusting the + monitor's gamma correction. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/framebuffer_sRGB.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.WGL import _types, _glgets +from OpenGL.raw.WGL.ARB.framebuffer_sRGB import * +from OpenGL.raw.WGL.ARB.framebuffer_sRGB import _EXTENSION_NAME + +def glInitFramebufferSrgbARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/ARB/make_current_read.py b/venv/lib/python3.12/site-packages/OpenGL/WGL/ARB/make_current_read.py new file mode 100644 index 00000000..7d9a4f00 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/WGL/ARB/make_current_read.py @@ -0,0 +1,23 @@ +'''OpenGL extension ARB.make_current_read + +This module customises the behaviour of the +OpenGL.raw.WGL.ARB.make_current_read to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/make_current_read.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.WGL import _types, _glgets +from OpenGL.raw.WGL.ARB.make_current_read import * +from OpenGL.raw.WGL.ARB.make_current_read import _EXTENSION_NAME + +def glInitMakeCurrentReadARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/ARB/multisample.py b/venv/lib/python3.12/site-packages/OpenGL/WGL/ARB/multisample.py new file mode 100644 index 00000000..fd4e88b0 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/WGL/ARB/multisample.py @@ -0,0 +1,51 @@ +'''OpenGL extension ARB.multisample + +This module customises the behaviour of the +OpenGL.raw.WGL.ARB.multisample to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides a mechanism to antialias all GL primitives: + points, lines, polygons, bitmaps, and images. The technique is to + sample all primitives multiple times at each pixel. The color + sample values are resolved to a single, displayable color each time + a pixel is updated, so the antialiasing appears to be automatic at + the application level. Because each sample includes depth and + stencil information, the depth and stencil functions perform + equivalently to the single-sample mode. + + An additional buffer, called the multisample buffer, is added to + the framebuffer. Pixel sample values, including color, depth, and + stencil values, are stored in this buffer. When the framebuffer + includes a multisample buffer, it does not also include separate + depth or stencil buffers, even if the multisample buffer does not + store depth or stencil values. Color buffers (left/right, front/ + back, and aux) do coexist with the multisample buffer, however. + + Multisample antialiasing is most valuable for rendering polygons, + because it requires no sorting for hidden surface elimination, and + it correctly handles adjacent polygons, object silhouettes, and + even intersecting polygons. If only points or lines are being + rendered, the "smooth" antialiasing mechanism provided by the base + GL may result in a higher quality image. This extension is + designed to allow multisample and smooth antialiasing techniques + to be alternated during the rendering of a single scene. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/multisample.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.WGL import _types, _glgets +from OpenGL.raw.WGL.ARB.multisample import * +from OpenGL.raw.WGL.ARB.multisample import _EXTENSION_NAME + +def glInitMultisampleARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/ARB/pbuffer.py b/venv/lib/python3.12/site-packages/OpenGL/WGL/ARB/pbuffer.py new file mode 100644 index 00000000..5d34f15b --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/WGL/ARB/pbuffer.py @@ -0,0 +1,23 @@ +'''OpenGL extension ARB.pbuffer + +This module customises the behaviour of the +OpenGL.raw.WGL.ARB.pbuffer to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/pbuffer.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.WGL import _types, _glgets +from OpenGL.raw.WGL.ARB.pbuffer import * +from OpenGL.raw.WGL.ARB.pbuffer import _EXTENSION_NAME + +def glInitPbufferARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/ARB/pixel_format.py b/venv/lib/python3.12/site-packages/OpenGL/WGL/ARB/pixel_format.py new file mode 100644 index 00000000..33400c51 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/WGL/ARB/pixel_format.py @@ -0,0 +1,23 @@ +'''OpenGL extension ARB.pixel_format + +This module customises the behaviour of the +OpenGL.raw.WGL.ARB.pixel_format to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/pixel_format.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.WGL import _types, _glgets +from OpenGL.raw.WGL.ARB.pixel_format import * +from OpenGL.raw.WGL.ARB.pixel_format import _EXTENSION_NAME + +def glInitPixelFormatARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/ARB/pixel_format_float.py b/venv/lib/python3.12/site-packages/OpenGL/WGL/ARB/pixel_format_float.py new file mode 100644 index 00000000..a272b47c --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/WGL/ARB/pixel_format_float.py @@ -0,0 +1,23 @@ +'''OpenGL extension ARB.pixel_format_float + +This module customises the behaviour of the +OpenGL.raw.WGL.ARB.pixel_format_float to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/pixel_format_float.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.WGL import _types, _glgets +from OpenGL.raw.WGL.ARB.pixel_format_float import * +from OpenGL.raw.WGL.ARB.pixel_format_float import _EXTENSION_NAME + +def glInitPixelFormatFloatARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/ARB/render_texture.py b/venv/lib/python3.12/site-packages/OpenGL/WGL/ARB/render_texture.py new file mode 100644 index 00000000..7098f7de --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/WGL/ARB/render_texture.py @@ -0,0 +1,23 @@ +'''OpenGL extension ARB.render_texture + +This module customises the behaviour of the +OpenGL.raw.WGL.ARB.render_texture to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/render_texture.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.WGL import _types, _glgets +from OpenGL.raw.WGL.ARB.render_texture import * +from OpenGL.raw.WGL.ARB.render_texture import _EXTENSION_NAME + +def glInitRenderTextureARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/ARB/robustness_application_isolation.py b/venv/lib/python3.12/site-packages/OpenGL/WGL/ARB/robustness_application_isolation.py new file mode 100644 index 00000000..a2e7c6e6 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/WGL/ARB/robustness_application_isolation.py @@ -0,0 +1,40 @@ +'''OpenGL extension ARB.robustness_application_isolation + +This module customises the behaviour of the +OpenGL.raw.WGL.ARB.robustness_application_isolation to provide a more +Python-friendly API + +Overview (from the spec) + + GL_ARB_robustness and supporting window system extensions allow + creating an OpenGL context supporting graphics reset notification + behavior. GL_ARB_robustness_isolation provides stronger + guarantees about the possible side-effects of a graphics reset. + + It is expected that there may be a performance cost associated + with isolating an application or share group from other contexts + on the GPU. For this reason, GL_ARB_robustness_isolation is + phrased as an opt-in mechanism, with a new context creation bit + defined in the window system bindings. It is expected that + implementations might only advertise the strings in this extension + if both the implementation supports the desired isolation + properties, and the context was created with the appropriate reset + isolation bit. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/robustness_application_isolation.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.WGL import _types, _glgets +from OpenGL.raw.WGL.ARB.robustness_application_isolation import * +from OpenGL.raw.WGL.ARB.robustness_application_isolation import _EXTENSION_NAME + +def glInitRobustnessApplicationIsolationARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/ARB/robustness_share_group_isolation.py b/venv/lib/python3.12/site-packages/OpenGL/WGL/ARB/robustness_share_group_isolation.py new file mode 100644 index 00000000..126b0306 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/WGL/ARB/robustness_share_group_isolation.py @@ -0,0 +1,23 @@ +'''OpenGL extension ARB.robustness_share_group_isolation + +This module customises the behaviour of the +OpenGL.raw.WGL.ARB.robustness_share_group_isolation to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ARB/robustness_share_group_isolation.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.WGL import _types, _glgets +from OpenGL.raw.WGL.ARB.robustness_share_group_isolation import * +from OpenGL.raw.WGL.ARB.robustness_share_group_isolation import _EXTENSION_NAME + +def glInitRobustnessShareGroupIsolationARB(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/ATI/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/WGL/ATI/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/WGL/ATI/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/ATI/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/WGL/ATI/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..d6a1e1a3 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/WGL/ATI/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/ATI/__pycache__/pixel_format_float.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/WGL/ATI/__pycache__/pixel_format_float.cpython-312.pyc new file mode 100644 index 00000000..208d9be4 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/WGL/ATI/__pycache__/pixel_format_float.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/ATI/__pycache__/render_texture_rectangle.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/WGL/ATI/__pycache__/render_texture_rectangle.cpython-312.pyc new file mode 100644 index 00000000..77f9714d Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/WGL/ATI/__pycache__/render_texture_rectangle.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/ATI/pixel_format_float.py b/venv/lib/python3.12/site-packages/OpenGL/WGL/ATI/pixel_format_float.py new file mode 100644 index 00000000..03ca5bc4 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/WGL/ATI/pixel_format_float.py @@ -0,0 +1,23 @@ +'''OpenGL extension ATI.pixel_format_float + +This module customises the behaviour of the +OpenGL.raw.WGL.ATI.pixel_format_float to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ATI/pixel_format_float.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.WGL import _types, _glgets +from OpenGL.raw.WGL.ATI.pixel_format_float import * +from OpenGL.raw.WGL.ATI.pixel_format_float import _EXTENSION_NAME + +def glInitPixelFormatFloatATI(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/ATI/render_texture_rectangle.py b/venv/lib/python3.12/site-packages/OpenGL/WGL/ATI/render_texture_rectangle.py new file mode 100644 index 00000000..b23e7b60 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/WGL/ATI/render_texture_rectangle.py @@ -0,0 +1,23 @@ +'''OpenGL extension ATI.render_texture_rectangle + +This module customises the behaviour of the +OpenGL.raw.WGL.ATI.render_texture_rectangle to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/ATI/render_texture_rectangle.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.WGL import _types, _glgets +from OpenGL.raw.WGL.ATI.render_texture_rectangle import * +from OpenGL.raw.WGL.ATI.render_texture_rectangle import _EXTENSION_NAME + +def glInitRenderTextureRectangleATI(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/DFX/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/WGL/DFX/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/WGL/DFX/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/DFX/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/WGL/DFX/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..940fc963 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/WGL/DFX/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/DFX/__pycache__/multisample.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/WGL/DFX/__pycache__/multisample.cpython-312.pyc new file mode 100644 index 00000000..12547148 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/WGL/DFX/__pycache__/multisample.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/DFX/multisample.py b/venv/lib/python3.12/site-packages/OpenGL/WGL/DFX/multisample.py new file mode 100644 index 00000000..2ba21cbe --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/WGL/DFX/multisample.py @@ -0,0 +1,65 @@ +'''OpenGL extension DFX.multisample + +This module customises the behaviour of the +OpenGL.raw.WGL.DFX.multisample to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides a mechanism to antialias all GL primitives: + points, lines, polygons, bitmaps, and images. The technique is to + sample all primitives multiple times at each pixel. The color sample + values are resolved to a single, displayable color each time a pixel + is updated, so the antialiasing appears to be automatic at the + application level. Because each sample includes depth and stencil + information, the depth and stencil functions perform equivalently to + the single-sample mode. + + An additional buffer, called the multisample buffer, is added to the + framebuffer. Pixel sample values, including color, depth, and + stencil values, are stored in this buffer. When the framebuffer + includes a multisample buffer, it does not also include separate + depth or stencil buffers, even if the multisample buffer does not + store depth or stencil values. Color buffers (left/right, + front/back, and aux) do coexist with the multisample buffer, + however. + + Multisample antialiasing is most valuable for rendering polygons, + because it requires no sorting for hidden surface elimination, and + it correctly handles adjacent polygons, object silhouettes, and even + intersecting polygons. If only points or lines are being rendered, + the "smooth" antialiasing mechanism provided by the base GL may + result in a higher quality image. + + This extension is a subset of SGIS_multisample. It differs in these + key ways: + + * Fragment alpha values are not affected by the fragment sample mask + * The sample locations may or may not be fixed. Thus, there is no + support for rendering the scene multiple times with different + sample points. + * Fragment masks are not computed for images or for bitmasks. + + Because of these differences a new extension was created. However, + it is not expected that this extension will co-exist with + SGIS_multisample. Because of this and the fact that there are only + 32 push/pop bits the MULTISAMPLE_BIT_SGIS state value is the same as + MUTLISAMPLE_BIT_3DFX. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/DFX/multisample.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.WGL import _types, _glgets +from OpenGL.raw.WGL.DFX.multisample import * +from OpenGL.raw.WGL.DFX.multisample import _EXTENSION_NAME + +def glInitMultisampleDFX(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/DL/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/WGL/DL/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/WGL/DL/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/DL/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/WGL/DL/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..dd1569b6 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/WGL/DL/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/DL/__pycache__/stereo_control.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/WGL/DL/__pycache__/stereo_control.cpython-312.pyc new file mode 100644 index 00000000..b3313bb3 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/WGL/DL/__pycache__/stereo_control.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/DL/stereo_control.py b/venv/lib/python3.12/site-packages/OpenGL/WGL/DL/stereo_control.py new file mode 100644 index 00000000..c8f4b910 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/WGL/DL/stereo_control.py @@ -0,0 +1,23 @@ +'''OpenGL extension DL.stereo_control + +This module customises the behaviour of the +OpenGL.raw.WGL.DL.stereo_control to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/DL/stereo_control.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.WGL import _types, _glgets +from OpenGL.raw.WGL.DL.stereo_control import * +from OpenGL.raw.WGL.DL.stereo_control import _EXTENSION_NAME + +def glInitStereoControlDL(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/EXT/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/WGL/EXT/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/WGL/EXT/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/EXT/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/WGL/EXT/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..00ddd9bc Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/WGL/EXT/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/EXT/__pycache__/colorspace.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/WGL/EXT/__pycache__/colorspace.cpython-312.pyc new file mode 100644 index 00000000..06317919 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/WGL/EXT/__pycache__/colorspace.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/EXT/__pycache__/create_context_es2_profile.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/WGL/EXT/__pycache__/create_context_es2_profile.cpython-312.pyc new file mode 100644 index 00000000..5a769606 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/WGL/EXT/__pycache__/create_context_es2_profile.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/EXT/__pycache__/create_context_es_profile.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/WGL/EXT/__pycache__/create_context_es_profile.cpython-312.pyc new file mode 100644 index 00000000..6a7931ae Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/WGL/EXT/__pycache__/create_context_es_profile.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/EXT/__pycache__/depth_float.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/WGL/EXT/__pycache__/depth_float.cpython-312.pyc new file mode 100644 index 00000000..36018336 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/WGL/EXT/__pycache__/depth_float.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/EXT/__pycache__/display_color_table.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/WGL/EXT/__pycache__/display_color_table.cpython-312.pyc new file mode 100644 index 00000000..05fff692 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/WGL/EXT/__pycache__/display_color_table.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/EXT/__pycache__/extensions_string.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/WGL/EXT/__pycache__/extensions_string.cpython-312.pyc new file mode 100644 index 00000000..0bb59ebd Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/WGL/EXT/__pycache__/extensions_string.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/EXT/__pycache__/framebuffer_sRGB.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/WGL/EXT/__pycache__/framebuffer_sRGB.cpython-312.pyc new file mode 100644 index 00000000..f4dbeb2e Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/WGL/EXT/__pycache__/framebuffer_sRGB.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/EXT/__pycache__/make_current_read.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/WGL/EXT/__pycache__/make_current_read.cpython-312.pyc new file mode 100644 index 00000000..aa8b11a1 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/WGL/EXT/__pycache__/make_current_read.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/EXT/__pycache__/multisample.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/WGL/EXT/__pycache__/multisample.cpython-312.pyc new file mode 100644 index 00000000..9798a032 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/WGL/EXT/__pycache__/multisample.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/EXT/__pycache__/pbuffer.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/WGL/EXT/__pycache__/pbuffer.cpython-312.pyc new file mode 100644 index 00000000..e8af0bcf Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/WGL/EXT/__pycache__/pbuffer.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/EXT/__pycache__/pixel_format.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/WGL/EXT/__pycache__/pixel_format.cpython-312.pyc new file mode 100644 index 00000000..7f8cc98b Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/WGL/EXT/__pycache__/pixel_format.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/EXT/__pycache__/pixel_format_packed_float.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/WGL/EXT/__pycache__/pixel_format_packed_float.cpython-312.pyc new file mode 100644 index 00000000..7a3d1b45 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/WGL/EXT/__pycache__/pixel_format_packed_float.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/EXT/__pycache__/swap_control.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/WGL/EXT/__pycache__/swap_control.cpython-312.pyc new file mode 100644 index 00000000..a756fae7 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/WGL/EXT/__pycache__/swap_control.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/EXT/__pycache__/swap_control_tear.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/WGL/EXT/__pycache__/swap_control_tear.cpython-312.pyc new file mode 100644 index 00000000..c397d7e3 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/WGL/EXT/__pycache__/swap_control_tear.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/EXT/colorspace.py b/venv/lib/python3.12/site-packages/OpenGL/WGL/EXT/colorspace.py new file mode 100644 index 00000000..adb696ca --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/WGL/EXT/colorspace.py @@ -0,0 +1,23 @@ +'''OpenGL extension EXT.colorspace + +This module customises the behaviour of the +OpenGL.raw.WGL.EXT.colorspace to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/colorspace.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.WGL import _types, _glgets +from OpenGL.raw.WGL.EXT.colorspace import * +from OpenGL.raw.WGL.EXT.colorspace import _EXTENSION_NAME + +def glInitColorspaceEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/EXT/create_context_es2_profile.py b/venv/lib/python3.12/site-packages/OpenGL/WGL/EXT/create_context_es2_profile.py new file mode 100644 index 00000000..9b9274da --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/WGL/EXT/create_context_es2_profile.py @@ -0,0 +1,23 @@ +'''OpenGL extension EXT.create_context_es2_profile + +This module customises the behaviour of the +OpenGL.raw.WGL.EXT.create_context_es2_profile to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/create_context_es2_profile.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.WGL import _types, _glgets +from OpenGL.raw.WGL.EXT.create_context_es2_profile import * +from OpenGL.raw.WGL.EXT.create_context_es2_profile import _EXTENSION_NAME + +def glInitCreateContextEs2ProfileEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/EXT/create_context_es_profile.py b/venv/lib/python3.12/site-packages/OpenGL/WGL/EXT/create_context_es_profile.py new file mode 100644 index 00000000..0c6653ec --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/WGL/EXT/create_context_es_profile.py @@ -0,0 +1,23 @@ +'''OpenGL extension EXT.create_context_es_profile + +This module customises the behaviour of the +OpenGL.raw.WGL.EXT.create_context_es_profile to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/create_context_es_profile.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.WGL import _types, _glgets +from OpenGL.raw.WGL.EXT.create_context_es_profile import * +from OpenGL.raw.WGL.EXT.create_context_es_profile import _EXTENSION_NAME + +def glInitCreateContextEsProfileEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/EXT/depth_float.py b/venv/lib/python3.12/site-packages/OpenGL/WGL/EXT/depth_float.py new file mode 100644 index 00000000..e3ffabc8 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/WGL/EXT/depth_float.py @@ -0,0 +1,23 @@ +'''OpenGL extension EXT.depth_float + +This module customises the behaviour of the +OpenGL.raw.WGL.EXT.depth_float to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/depth_float.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.WGL import _types, _glgets +from OpenGL.raw.WGL.EXT.depth_float import * +from OpenGL.raw.WGL.EXT.depth_float import _EXTENSION_NAME + +def glInitDepthFloatEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/EXT/display_color_table.py b/venv/lib/python3.12/site-packages/OpenGL/WGL/EXT/display_color_table.py new file mode 100644 index 00000000..11a0f625 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/WGL/EXT/display_color_table.py @@ -0,0 +1,23 @@ +'''OpenGL extension EXT.display_color_table + +This module customises the behaviour of the +OpenGL.raw.WGL.EXT.display_color_table to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/display_color_table.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.WGL import _types, _glgets +from OpenGL.raw.WGL.EXT.display_color_table import * +from OpenGL.raw.WGL.EXT.display_color_table import _EXTENSION_NAME + +def glInitDisplayColorTableEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/EXT/extensions_string.py b/venv/lib/python3.12/site-packages/OpenGL/WGL/EXT/extensions_string.py new file mode 100644 index 00000000..20d5bd1f --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/WGL/EXT/extensions_string.py @@ -0,0 +1,23 @@ +'''OpenGL extension EXT.extensions_string + +This module customises the behaviour of the +OpenGL.raw.WGL.EXT.extensions_string to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/extensions_string.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.WGL import _types, _glgets +from OpenGL.raw.WGL.EXT.extensions_string import * +from OpenGL.raw.WGL.EXT.extensions_string import _EXTENSION_NAME + +def glInitExtensionsStringEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/EXT/framebuffer_sRGB.py b/venv/lib/python3.12/site-packages/OpenGL/WGL/EXT/framebuffer_sRGB.py new file mode 100644 index 00000000..6eb3ee57 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/WGL/EXT/framebuffer_sRGB.py @@ -0,0 +1,55 @@ +'''OpenGL extension EXT.framebuffer_sRGB + +This module customises the behaviour of the +OpenGL.raw.WGL.EXT.framebuffer_sRGB to provide a more +Python-friendly API + +Overview (from the spec) + + Conventionally, OpenGL assumes framebuffer color components are stored + in a linear color space. In particular, framebuffer blending is a + linear operation. + + The sRGB color space is based on typical (non-linear) monitor + characteristics expected in a dimly lit office. It has been + standardized by the International Electrotechnical Commission (IEC) + as IEC 61966-2-1. The sRGB color space roughly corresponds to 2.2 + gamma correction. + + This extension adds a framebuffer capability for sRGB framebuffer + update and blending. When blending is disabled but the new sRGB + updated mode is enabled (assume the framebuffer supports the + capability), high-precision linear color component values for red, + green, and blue generated by fragment coloring are encoded for sRGB + prior to being written into the framebuffer. When blending is enabled + along with the new sRGB update mode, red, green, and blue framebuffer + color components are treated as sRGB values that are converted to + linear color values, blended with the high-precision color values + generated by fragment coloring, and then the blend result is encoded + for sRGB just prior to being written into the framebuffer. + + The primary motivation for this extension is that it allows OpenGL + applications to render into a framebuffer that is scanned to a monitor + configured to assume framebuffer color values are sRGB encoded. + This assumption is roughly true of most PC monitors with default + gamma correction. This allows applications to achieve faithful + color reproduction for OpenGL rendering without adjusting the + monitor's gamma correction. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/framebuffer_sRGB.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.WGL import _types, _glgets +from OpenGL.raw.WGL.EXT.framebuffer_sRGB import * +from OpenGL.raw.WGL.EXT.framebuffer_sRGB import _EXTENSION_NAME + +def glInitFramebufferSrgbEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/EXT/make_current_read.py b/venv/lib/python3.12/site-packages/OpenGL/WGL/EXT/make_current_read.py new file mode 100644 index 00000000..92711c3e --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/WGL/EXT/make_current_read.py @@ -0,0 +1,23 @@ +'''OpenGL extension EXT.make_current_read + +This module customises the behaviour of the +OpenGL.raw.WGL.EXT.make_current_read to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/make_current_read.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.WGL import _types, _glgets +from OpenGL.raw.WGL.EXT.make_current_read import * +from OpenGL.raw.WGL.EXT.make_current_read import _EXTENSION_NAME + +def glInitMakeCurrentReadEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/EXT/multisample.py b/venv/lib/python3.12/site-packages/OpenGL/WGL/EXT/multisample.py new file mode 100644 index 00000000..786e4a6a --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/WGL/EXT/multisample.py @@ -0,0 +1,23 @@ +'''OpenGL extension EXT.multisample + +This module customises the behaviour of the +OpenGL.raw.WGL.EXT.multisample to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/multisample.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.WGL import _types, _glgets +from OpenGL.raw.WGL.EXT.multisample import * +from OpenGL.raw.WGL.EXT.multisample import _EXTENSION_NAME + +def glInitMultisampleEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/EXT/pbuffer.py b/venv/lib/python3.12/site-packages/OpenGL/WGL/EXT/pbuffer.py new file mode 100644 index 00000000..906d6895 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/WGL/EXT/pbuffer.py @@ -0,0 +1,23 @@ +'''OpenGL extension EXT.pbuffer + +This module customises the behaviour of the +OpenGL.raw.WGL.EXT.pbuffer to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/pbuffer.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.WGL import _types, _glgets +from OpenGL.raw.WGL.EXT.pbuffer import * +from OpenGL.raw.WGL.EXT.pbuffer import _EXTENSION_NAME + +def glInitPbufferEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/EXT/pixel_format.py b/venv/lib/python3.12/site-packages/OpenGL/WGL/EXT/pixel_format.py new file mode 100644 index 00000000..425e60e8 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/WGL/EXT/pixel_format.py @@ -0,0 +1,23 @@ +'''OpenGL extension EXT.pixel_format + +This module customises the behaviour of the +OpenGL.raw.WGL.EXT.pixel_format to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/pixel_format.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.WGL import _types, _glgets +from OpenGL.raw.WGL.EXT.pixel_format import * +from OpenGL.raw.WGL.EXT.pixel_format import _EXTENSION_NAME + +def glInitPixelFormatEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/EXT/pixel_format_packed_float.py b/venv/lib/python3.12/site-packages/OpenGL/WGL/EXT/pixel_format_packed_float.py new file mode 100644 index 00000000..cca25654 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/WGL/EXT/pixel_format_packed_float.py @@ -0,0 +1,23 @@ +'''OpenGL extension EXT.pixel_format_packed_float + +This module customises the behaviour of the +OpenGL.raw.WGL.EXT.pixel_format_packed_float to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/pixel_format_packed_float.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.WGL import _types, _glgets +from OpenGL.raw.WGL.EXT.pixel_format_packed_float import * +from OpenGL.raw.WGL.EXT.pixel_format_packed_float import _EXTENSION_NAME + +def glInitPixelFormatPackedFloatEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/EXT/swap_control.py b/venv/lib/python3.12/site-packages/OpenGL/WGL/EXT/swap_control.py new file mode 100644 index 00000000..22639780 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/WGL/EXT/swap_control.py @@ -0,0 +1,31 @@ +'''OpenGL extension EXT.swap_control + +This module customises the behaviour of the +OpenGL.raw.WGL.EXT.swap_control to provide a more +Python-friendly API + +Overview (from the spec) + + This extension allows an application to specify a minimum + periodicity of color buffer swaps, measured in video frame periods, + for a particular drawable. It also allows an application to query + the swap interval and the implementation-dependent maximum swap + interval of a drawable. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/swap_control.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.WGL import _types, _glgets +from OpenGL.raw.WGL.EXT.swap_control import * +from OpenGL.raw.WGL.EXT.swap_control import _EXTENSION_NAME + +def glInitSwapControlEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/EXT/swap_control_tear.py b/venv/lib/python3.12/site-packages/OpenGL/WGL/EXT/swap_control_tear.py new file mode 100644 index 00000000..1ea4c0c1 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/WGL/EXT/swap_control_tear.py @@ -0,0 +1,23 @@ +'''OpenGL extension EXT.swap_control_tear + +This module customises the behaviour of the +OpenGL.raw.WGL.EXT.swap_control_tear to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/EXT/swap_control_tear.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.WGL import _types, _glgets +from OpenGL.raw.WGL.EXT.swap_control_tear import * +from OpenGL.raw.WGL.EXT.swap_control_tear import _EXTENSION_NAME + +def glInitSwapControlTearEXT(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/I3D/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/WGL/I3D/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/WGL/I3D/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/I3D/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/WGL/I3D/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..9a4d4e71 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/WGL/I3D/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/I3D/__pycache__/digital_video_control.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/WGL/I3D/__pycache__/digital_video_control.cpython-312.pyc new file mode 100644 index 00000000..f7be4f92 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/WGL/I3D/__pycache__/digital_video_control.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/I3D/__pycache__/gamma.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/WGL/I3D/__pycache__/gamma.cpython-312.pyc new file mode 100644 index 00000000..e02a8079 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/WGL/I3D/__pycache__/gamma.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/I3D/__pycache__/genlock.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/WGL/I3D/__pycache__/genlock.cpython-312.pyc new file mode 100644 index 00000000..ab25bb6a Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/WGL/I3D/__pycache__/genlock.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/I3D/__pycache__/image_buffer.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/WGL/I3D/__pycache__/image_buffer.cpython-312.pyc new file mode 100644 index 00000000..a1795576 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/WGL/I3D/__pycache__/image_buffer.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/I3D/__pycache__/swap_frame_lock.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/WGL/I3D/__pycache__/swap_frame_lock.cpython-312.pyc new file mode 100644 index 00000000..45c7ecc7 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/WGL/I3D/__pycache__/swap_frame_lock.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/I3D/__pycache__/swap_frame_usage.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/WGL/I3D/__pycache__/swap_frame_usage.cpython-312.pyc new file mode 100644 index 00000000..d0565918 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/WGL/I3D/__pycache__/swap_frame_usage.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/I3D/digital_video_control.py b/venv/lib/python3.12/site-packages/OpenGL/WGL/I3D/digital_video_control.py new file mode 100644 index 00000000..4b72e384 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/WGL/I3D/digital_video_control.py @@ -0,0 +1,23 @@ +'''OpenGL extension I3D.digital_video_control + +This module customises the behaviour of the +OpenGL.raw.WGL.I3D.digital_video_control to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/I3D/digital_video_control.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.WGL import _types, _glgets +from OpenGL.raw.WGL.I3D.digital_video_control import * +from OpenGL.raw.WGL.I3D.digital_video_control import _EXTENSION_NAME + +def glInitDigitalVideoControlI3D(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/I3D/gamma.py b/venv/lib/python3.12/site-packages/OpenGL/WGL/I3D/gamma.py new file mode 100644 index 00000000..0fc226a4 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/WGL/I3D/gamma.py @@ -0,0 +1,23 @@ +'''OpenGL extension I3D.gamma + +This module customises the behaviour of the +OpenGL.raw.WGL.I3D.gamma to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/I3D/gamma.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.WGL import _types, _glgets +from OpenGL.raw.WGL.I3D.gamma import * +from OpenGL.raw.WGL.I3D.gamma import _EXTENSION_NAME + +def glInitGammaI3D(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/I3D/genlock.py b/venv/lib/python3.12/site-packages/OpenGL/WGL/I3D/genlock.py new file mode 100644 index 00000000..4d9c55b0 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/WGL/I3D/genlock.py @@ -0,0 +1,23 @@ +'''OpenGL extension I3D.genlock + +This module customises the behaviour of the +OpenGL.raw.WGL.I3D.genlock to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/I3D/genlock.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.WGL import _types, _glgets +from OpenGL.raw.WGL.I3D.genlock import * +from OpenGL.raw.WGL.I3D.genlock import _EXTENSION_NAME + +def glInitGenlockI3D(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/I3D/image_buffer.py b/venv/lib/python3.12/site-packages/OpenGL/WGL/I3D/image_buffer.py new file mode 100644 index 00000000..8a059f96 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/WGL/I3D/image_buffer.py @@ -0,0 +1,23 @@ +'''OpenGL extension I3D.image_buffer + +This module customises the behaviour of the +OpenGL.raw.WGL.I3D.image_buffer to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/I3D/image_buffer.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.WGL import _types, _glgets +from OpenGL.raw.WGL.I3D.image_buffer import * +from OpenGL.raw.WGL.I3D.image_buffer import _EXTENSION_NAME + +def glInitImageBufferI3D(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/I3D/swap_frame_lock.py b/venv/lib/python3.12/site-packages/OpenGL/WGL/I3D/swap_frame_lock.py new file mode 100644 index 00000000..567da9a3 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/WGL/I3D/swap_frame_lock.py @@ -0,0 +1,23 @@ +'''OpenGL extension I3D.swap_frame_lock + +This module customises the behaviour of the +OpenGL.raw.WGL.I3D.swap_frame_lock to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/I3D/swap_frame_lock.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.WGL import _types, _glgets +from OpenGL.raw.WGL.I3D.swap_frame_lock import * +from OpenGL.raw.WGL.I3D.swap_frame_lock import _EXTENSION_NAME + +def glInitSwapFrameLockI3D(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/I3D/swap_frame_usage.py b/venv/lib/python3.12/site-packages/OpenGL/WGL/I3D/swap_frame_usage.py new file mode 100644 index 00000000..99a85eee --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/WGL/I3D/swap_frame_usage.py @@ -0,0 +1,23 @@ +'''OpenGL extension I3D.swap_frame_usage + +This module customises the behaviour of the +OpenGL.raw.WGL.I3D.swap_frame_usage to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/I3D/swap_frame_usage.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.WGL import _types, _glgets +from OpenGL.raw.WGL.I3D.swap_frame_usage import * +from OpenGL.raw.WGL.I3D.swap_frame_usage import _EXTENSION_NAME + +def glInitSwapFrameUsageI3D(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/NV/DX_interop.py b/venv/lib/python3.12/site-packages/OpenGL/WGL/NV/DX_interop.py new file mode 100644 index 00000000..2f3bac1a --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/WGL/NV/DX_interop.py @@ -0,0 +1,23 @@ +'''OpenGL extension NV.DX_interop + +This module customises the behaviour of the +OpenGL.raw.WGL.NV.DX_interop to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/DX_interop.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.WGL import _types, _glgets +from OpenGL.raw.WGL.NV.DX_interop import * +from OpenGL.raw.WGL.NV.DX_interop import _EXTENSION_NAME + +def glInitDxInteropNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/NV/DX_interop2.py b/venv/lib/python3.12/site-packages/OpenGL/WGL/NV/DX_interop2.py new file mode 100644 index 00000000..880f9c81 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/WGL/NV/DX_interop2.py @@ -0,0 +1,23 @@ +'''OpenGL extension NV.DX_interop2 + +This module customises the behaviour of the +OpenGL.raw.WGL.NV.DX_interop2 to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/DX_interop2.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.WGL import _types, _glgets +from OpenGL.raw.WGL.NV.DX_interop2 import * +from OpenGL.raw.WGL.NV.DX_interop2 import _EXTENSION_NAME + +def glInitDxInterop2NV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/NV/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/WGL/NV/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/WGL/NV/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/NV/__pycache__/DX_interop.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/WGL/NV/__pycache__/DX_interop.cpython-312.pyc new file mode 100644 index 00000000..b4776829 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/WGL/NV/__pycache__/DX_interop.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/NV/__pycache__/DX_interop2.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/WGL/NV/__pycache__/DX_interop2.cpython-312.pyc new file mode 100644 index 00000000..1819a31c Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/WGL/NV/__pycache__/DX_interop2.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/NV/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/WGL/NV/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..dc09d7ac Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/WGL/NV/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/NV/__pycache__/copy_image.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/WGL/NV/__pycache__/copy_image.cpython-312.pyc new file mode 100644 index 00000000..a30dc081 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/WGL/NV/__pycache__/copy_image.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/NV/__pycache__/delay_before_swap.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/WGL/NV/__pycache__/delay_before_swap.cpython-312.pyc new file mode 100644 index 00000000..36588291 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/WGL/NV/__pycache__/delay_before_swap.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/NV/__pycache__/float_buffer.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/WGL/NV/__pycache__/float_buffer.cpython-312.pyc new file mode 100644 index 00000000..01c7e78c Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/WGL/NV/__pycache__/float_buffer.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/NV/__pycache__/gpu_affinity.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/WGL/NV/__pycache__/gpu_affinity.cpython-312.pyc new file mode 100644 index 00000000..99d6dfd5 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/WGL/NV/__pycache__/gpu_affinity.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/NV/__pycache__/multigpu_context.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/WGL/NV/__pycache__/multigpu_context.cpython-312.pyc new file mode 100644 index 00000000..4f213d1c Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/WGL/NV/__pycache__/multigpu_context.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/NV/__pycache__/multisample_coverage.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/WGL/NV/__pycache__/multisample_coverage.cpython-312.pyc new file mode 100644 index 00000000..5c27f6bf Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/WGL/NV/__pycache__/multisample_coverage.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/NV/__pycache__/present_video.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/WGL/NV/__pycache__/present_video.cpython-312.pyc new file mode 100644 index 00000000..d5acb712 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/WGL/NV/__pycache__/present_video.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/NV/__pycache__/render_depth_texture.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/WGL/NV/__pycache__/render_depth_texture.cpython-312.pyc new file mode 100644 index 00000000..51748b04 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/WGL/NV/__pycache__/render_depth_texture.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/NV/__pycache__/render_texture_rectangle.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/WGL/NV/__pycache__/render_texture_rectangle.cpython-312.pyc new file mode 100644 index 00000000..1b84f7d0 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/WGL/NV/__pycache__/render_texture_rectangle.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/NV/__pycache__/swap_group.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/WGL/NV/__pycache__/swap_group.cpython-312.pyc new file mode 100644 index 00000000..f87a7a1a Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/WGL/NV/__pycache__/swap_group.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/NV/__pycache__/vertex_array_range.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/WGL/NV/__pycache__/vertex_array_range.cpython-312.pyc new file mode 100644 index 00000000..5a1045fd Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/WGL/NV/__pycache__/vertex_array_range.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/NV/__pycache__/video_capture.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/WGL/NV/__pycache__/video_capture.cpython-312.pyc new file mode 100644 index 00000000..fc935fde Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/WGL/NV/__pycache__/video_capture.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/NV/__pycache__/video_output.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/WGL/NV/__pycache__/video_output.cpython-312.pyc new file mode 100644 index 00000000..56b585f8 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/WGL/NV/__pycache__/video_output.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/NV/copy_image.py b/venv/lib/python3.12/site-packages/OpenGL/WGL/NV/copy_image.py new file mode 100644 index 00000000..bf77bd85 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/WGL/NV/copy_image.py @@ -0,0 +1,32 @@ +'''OpenGL extension NV.copy_image + +This module customises the behaviour of the +OpenGL.raw.WGL.NV.copy_image to provide a more +Python-friendly API + +Overview (from the spec) + + This extension enables efficient image data transfer between image + objects (i.e. textures and renderbuffers) without the need to bind + the objects or otherwise configure the rendering pipeline. The + WGL and GLX versions allow copying between images in different + contexts, even if those contexts are in different sharelists or + even on different physical devices. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/copy_image.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.WGL import _types, _glgets +from OpenGL.raw.WGL.NV.copy_image import * +from OpenGL.raw.WGL.NV.copy_image import _EXTENSION_NAME + +def glInitCopyImageNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/NV/delay_before_swap.py b/venv/lib/python3.12/site-packages/OpenGL/WGL/NV/delay_before_swap.py new file mode 100644 index 00000000..997a1c90 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/WGL/NV/delay_before_swap.py @@ -0,0 +1,23 @@ +'''OpenGL extension NV.delay_before_swap + +This module customises the behaviour of the +OpenGL.raw.WGL.NV.delay_before_swap to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/delay_before_swap.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.WGL import _types, _glgets +from OpenGL.raw.WGL.NV.delay_before_swap import * +from OpenGL.raw.WGL.NV.delay_before_swap import _EXTENSION_NAME + +def glInitDelayBeforeSwapNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/NV/float_buffer.py b/venv/lib/python3.12/site-packages/OpenGL/WGL/NV/float_buffer.py new file mode 100644 index 00000000..e1202fc6 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/WGL/NV/float_buffer.py @@ -0,0 +1,91 @@ +'''OpenGL extension NV.float_buffer + +This module customises the behaviour of the +OpenGL.raw.WGL.NV.float_buffer to provide a more +Python-friendly API + +Overview (from the spec) + + This extension builds upon NV_fragment_program to provide a framebuffer + and texture format that allows fragment programs to read and write + unconstrained floating point data. + + In unextended OpenGL, most computations dealing with color or depth + buffers are typically constrained to operate on values in the range [0,1]. + Computational results are also typically clamped to the range [0,1]. + Color, texture, and depth buffers themselves also hold values mapped to + the range [0,1]. + + The NV_fragment_program extension provides a general computational model + that supports floating-point numbers constrained only by the precision of + the underlying data types. The quantites computed by fragment programs do + not necessarily correspond in number or in range to conventional + attributes such as RGBA colors or depth values. Because of the range and + precision constraints imposed by conventional fixed-point color buffers, + it may be difficult (if not impossible) to use them to implement certain + multi-pass algorithms. + + To enhance the extended range and precision available through fragment + programs, this extension provides floating-point RGBA color buffers that + can be used instead of conventional fixed-point RGBA color buffers. A + floating-point RGBA color buffer consists of one to four floating-point + components stored in the 16- or 32-bit floating-point formats (fp16 or + fp32) defined in the NV_half_float and NV_fragment_program extensions. + + When a floating-point color buffer is used, the results of fragment + programs, as written to the "x", "y", "z", and "w" components of the + o[COLR] or o[COLH] output registers, are written directly to the color + buffer without any clamping or modification. Certain per-fragment + operations are bypassed when rendering to floating-point color buffers. + + A floating-point color buffer can also be used as a texture map, either by + reading back the contents and then using conventional TexImage calls, or + by using the buffer directly via the ARB_render_texture extension or + the EXT_framebuffer_object extension. + + This extension has many uses. Some possible uses include: + + (1) Multi-pass algorithms with arbitrary intermediate results that + don't have to be artifically forced into the range [0,1]. In + addition, intermediate results can be written without having to + worry about out-of-range values. + + (2) Deferred shading algorithms where an expensive fragment program is + executed only after depth testing is fully complete. Instead, a + simple program is executed, which stores the parameters necessary + to produce a final result. After the entire scene is rendered, a + second pass is executed over the entire frame buffer to execute + the complex fragment program using the results written to the + floating-point color buffer in the first pass. This will save the + cost of applying complex fragment programs to fragments that will + not appear in the final image. + + (3) Use floating-point texture maps to evaluate functions with + arbitrary ranges. Arbitrary functions with a finite domain can be + approximated using a texture map holding sample results and + piecewise linear approximation. + + There are several significant limitations on the use of floating-point + color buffers. First, floating-point color buffers do not support frame + buffer blending. Second, floating-point texture maps do not support + mipmapping or any texture filtering other than NEAREST. Third, + floating-point texture maps must be 2D, and must use the + NV_texture_rectangle extension. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/float_buffer.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.WGL import _types, _glgets +from OpenGL.raw.WGL.NV.float_buffer import * +from OpenGL.raw.WGL.NV.float_buffer import _EXTENSION_NAME + +def glInitFloatBufferNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/NV/gpu_affinity.py b/venv/lib/python3.12/site-packages/OpenGL/WGL/NV/gpu_affinity.py new file mode 100644 index 00000000..8497fcfa --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/WGL/NV/gpu_affinity.py @@ -0,0 +1,23 @@ +'''OpenGL extension NV.gpu_affinity + +This module customises the behaviour of the +OpenGL.raw.WGL.NV.gpu_affinity to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/gpu_affinity.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.WGL import _types, _glgets +from OpenGL.raw.WGL.NV.gpu_affinity import * +from OpenGL.raw.WGL.NV.gpu_affinity import _EXTENSION_NAME + +def glInitGpuAffinityNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/NV/multigpu_context.py b/venv/lib/python3.12/site-packages/OpenGL/WGL/NV/multigpu_context.py new file mode 100644 index 00000000..4de9e3bc --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/WGL/NV/multigpu_context.py @@ -0,0 +1,23 @@ +'''OpenGL extension NV.multigpu_context + +This module customises the behaviour of the +OpenGL.raw.WGL.NV.multigpu_context to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/multigpu_context.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.WGL import _types, _glgets +from OpenGL.raw.WGL.NV.multigpu_context import * +from OpenGL.raw.WGL.NV.multigpu_context import _EXTENSION_NAME + +def glInitMultigpuContextNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/NV/multisample_coverage.py b/venv/lib/python3.12/site-packages/OpenGL/WGL/NV/multisample_coverage.py new file mode 100644 index 00000000..927f6ce8 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/WGL/NV/multisample_coverage.py @@ -0,0 +1,49 @@ +'''OpenGL extension NV.multisample_coverage + +This module customises the behaviour of the +OpenGL.raw.WGL.NV.multisample_coverage to provide a more +Python-friendly API + +Overview (from the spec) + + The ARB_multisample extension provides a mechanism for antialiasing + primitives. This mechanism allows an application to request an + additional buffer, the multisample buffer, that is added to the + framebuffer. An application can request the number of samples per + fragment that are stored in the multisample buffer. Rendering + proceeds by writing color, depth, and stencil values for each + sample to the multisample buffer. The results are automatically + resolved to a single displayable color each time a pixel is + updated. + + Coverage Sample Anti-Aliasing (CSAA) is an extension to multisample + antialiasing. The technique separates "samples" into two types of + samples. "Color samples" are samples with color, depth, and + stencil information stored in the multisample buffer. "Coverage + samples" include both color samples and additional samples that only + provide pixel coverage information. + + This extension follows the example of the + NV_framebuffer_multisample_coverage extension, which adds CSAA + support for framebuffer objects. The base description of + multisample rendering is written in terms of coverage samples and + color samples. The windows system notion of "samples" + (SAMPLES_ARB) is layered on top of coverage and color samples. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/multisample_coverage.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.WGL import _types, _glgets +from OpenGL.raw.WGL.NV.multisample_coverage import * +from OpenGL.raw.WGL.NV.multisample_coverage import _EXTENSION_NAME + +def glInitMultisampleCoverageNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/NV/present_video.py b/venv/lib/python3.12/site-packages/OpenGL/WGL/NV/present_video.py new file mode 100644 index 00000000..431c1497 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/WGL/NV/present_video.py @@ -0,0 +1,40 @@ +'''OpenGL extension NV.present_video + +This module customises the behaviour of the +OpenGL.raw.WGL.NV.present_video to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides a mechanism for displaying textures and + renderbuffers on auxiliary video output devices. It allows an + application to specify separate buffers for the individual + fields used with interlaced output. It also provides a way + to present frames or field pairs simultaneously in two separate + video streams. It also allows an application to request when images + should be displayed, and to obtain feedback on exactly when images + are actually first displayed. + + This specification attempts to avoid language that would tie it to + any particular hardware or vendor. However, it should be noted that + it has been designed specifically for use with NVIDIA SDI products + and the features and limitations of the spec compliment those of + NVIDIA's line of SDI video output devices. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/present_video.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.WGL import _types, _glgets +from OpenGL.raw.WGL.NV.present_video import * +from OpenGL.raw.WGL.NV.present_video import _EXTENSION_NAME + +def glInitPresentVideoNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/NV/render_depth_texture.py b/venv/lib/python3.12/site-packages/OpenGL/WGL/NV/render_depth_texture.py new file mode 100644 index 00000000..53def347 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/WGL/NV/render_depth_texture.py @@ -0,0 +1,23 @@ +'''OpenGL extension NV.render_depth_texture + +This module customises the behaviour of the +OpenGL.raw.WGL.NV.render_depth_texture to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/render_depth_texture.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.WGL import _types, _glgets +from OpenGL.raw.WGL.NV.render_depth_texture import * +from OpenGL.raw.WGL.NV.render_depth_texture import _EXTENSION_NAME + +def glInitRenderDepthTextureNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/NV/render_texture_rectangle.py b/venv/lib/python3.12/site-packages/OpenGL/WGL/NV/render_texture_rectangle.py new file mode 100644 index 00000000..c730845d --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/WGL/NV/render_texture_rectangle.py @@ -0,0 +1,23 @@ +'''OpenGL extension NV.render_texture_rectangle + +This module customises the behaviour of the +OpenGL.raw.WGL.NV.render_texture_rectangle to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/render_texture_rectangle.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.WGL import _types, _glgets +from OpenGL.raw.WGL.NV.render_texture_rectangle import * +from OpenGL.raw.WGL.NV.render_texture_rectangle import _EXTENSION_NAME + +def glInitRenderTextureRectangleNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/NV/swap_group.py b/venv/lib/python3.12/site-packages/OpenGL/WGL/NV/swap_group.py new file mode 100644 index 00000000..ef9998f9 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/WGL/NV/swap_group.py @@ -0,0 +1,23 @@ +'''OpenGL extension NV.swap_group + +This module customises the behaviour of the +OpenGL.raw.WGL.NV.swap_group to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/swap_group.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.WGL import _types, _glgets +from OpenGL.raw.WGL.NV.swap_group import * +from OpenGL.raw.WGL.NV.swap_group import _EXTENSION_NAME + +def glInitSwapGroupNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/NV/vertex_array_range.py b/venv/lib/python3.12/site-packages/OpenGL/WGL/NV/vertex_array_range.py new file mode 100644 index 00000000..78958aa7 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/WGL/NV/vertex_array_range.py @@ -0,0 +1,98 @@ +'''OpenGL extension NV.vertex_array_range + +This module customises the behaviour of the +OpenGL.raw.WGL.NV.vertex_array_range to provide a more +Python-friendly API + +Overview (from the spec) + + The goal of this extension is to permit extremely high vertex + processing rates via OpenGL vertex arrays even when the CPU lacks + the necessary data movement bandwidth to keep up with the rate + at which the vertex engine can consume vertices. CPUs can keep + up if they can just pass vertex indices to the hardware and + let the hardware "pull" the actual vertex data via Direct Memory + Access (DMA). Unfortunately, the current OpenGL 1.1 vertex array + functionality has semantic constraints that make such an approach + hard. Hence, the vertex array range extension. + + This extension provides a mechanism for deferring the pulling of + vertex array elements to facilitate DMAed pulling of vertices for + fast, efficient vertex array transfers. The OpenGL client need only + pass vertex indices to the hardware which can DMA the actual index's + vertex data directly out of the client address space. + + The OpenGL 1.1 vertex array functionality specifies a fairly strict + coherency model for when OpenGL extracts vertex data from a vertex + array and when the application can update the in memory + vertex array data. The OpenGL 1.1 specification says "Changes + made to array data between the execution of Begin and the + corresponding execution of End may affect calls to ArrayElement + that are made within the same Begin/End period in non-sequential + ways. That is, a call to ArrayElement that precedes a change to + array data may access the changed data, and a call that follows + a change to array data may access the original data." + + This means that by the time End returns (and DrawArrays and + DrawElements return since they have implicit Ends), the actual vertex + array data must be transferred to OpenGL. This strict coherency model + prevents us from simply passing vertex element indices to the hardware + and having the hardware "pull" the vertex data out (which is often + long after the End for the primitive has returned to the application). + + Relaxing this coherency model and bounding the range from which + vertex array data can be pulled is key to making OpenGL vertex + array transfers faster and more efficient. + + The first task of the vertex array range extension is to relax + the coherency model so that hardware can indeed "pull" vertex + data from the OpenGL client's address space long after the application + has completed sending the geometry primitives requiring the vertex + data. + + The second problem with the OpenGL 1.1 vertex array functionality is + the lack of any guidance from the API about what region of memory + vertices can be pulled from. There is no size limit for OpenGL 1.1 + vertex arrays. Any vertex index that points to valid data in all + enabled arrays is fair game. This makes it hard for a vertex DMA + engine to pull vertices since they can be potentially pulled from + anywhere in the OpenGL client address space. + + The vertex array range extension specifies a range of the OpenGL + client's address space where vertices can be pulled. Vertex indices + that access any array elements outside the vertex array range + are specified to be undefined. This permits hardware to DMA from + finite regions of OpenGL client address space, making DMA engine + implementation tractable. + + The extension is specified such that an (error free) OpenGL client + using the vertex array range functionality could no-op its vertex + array range commands and operate equivalently to using (if slower + than) the vertex array range functionality. + + Because different memory types (local graphics memory, AGP memory) + have different DMA bandwidths and caching behavior, this extension + includes a window system dependent memory allocator to allocate + cleanly the most appropriate memory for constructing a vertex array + range. The memory allocator provided allows the application to + tradeoff the desired CPU read frequency, CPU write frequency, and + memory priority while still leaving it up to OpenGL implementation + the exact memory type to be allocated. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/vertex_array_range.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.WGL import _types, _glgets +from OpenGL.raw.WGL.NV.vertex_array_range import * +from OpenGL.raw.WGL.NV.vertex_array_range import _EXTENSION_NAME + +def glInitVertexArrayRangeNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/NV/video_capture.py b/venv/lib/python3.12/site-packages/OpenGL/WGL/NV/video_capture.py new file mode 100644 index 00000000..ae532acd --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/WGL/NV/video_capture.py @@ -0,0 +1,31 @@ +'''OpenGL extension NV.video_capture + +This module customises the behaviour of the +OpenGL.raw.WGL.NV.video_capture to provide a more +Python-friendly API + +Overview (from the spec) + + This extension provides a mechanism for streaming video data + directly into texture objects and buffer objects. Applications can + then display video streams in interactive 3D scenes and/or + manipulate the video data using the GL's image processing + capabilities. + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/video_capture.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.WGL import _types, _glgets +from OpenGL.raw.WGL.NV.video_capture import * +from OpenGL.raw.WGL.NV.video_capture import _EXTENSION_NAME + +def glInitVideoCaptureNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/NV/video_output.py b/venv/lib/python3.12/site-packages/OpenGL/WGL/NV/video_output.py new file mode 100644 index 00000000..4b436505 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/WGL/NV/video_output.py @@ -0,0 +1,23 @@ +'''OpenGL extension NV.video_output + +This module customises the behaviour of the +OpenGL.raw.WGL.NV.video_output to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/NV/video_output.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.WGL import _types, _glgets +from OpenGL.raw.WGL.NV.video_output import * +from OpenGL.raw.WGL.NV.video_output import _EXTENSION_NAME + +def glInitVideoOutputNV(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/OML/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/WGL/OML/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/WGL/OML/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/OML/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/WGL/OML/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..368c0881 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/WGL/OML/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/OML/__pycache__/sync_control.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/WGL/OML/__pycache__/sync_control.cpython-312.pyc new file mode 100644 index 00000000..f9c1047a Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/WGL/OML/__pycache__/sync_control.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/OML/sync_control.py b/venv/lib/python3.12/site-packages/OpenGL/WGL/OML/sync_control.py new file mode 100644 index 00000000..6970b320 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/WGL/OML/sync_control.py @@ -0,0 +1,23 @@ +'''OpenGL extension OML.sync_control + +This module customises the behaviour of the +OpenGL.raw.WGL.OML.sync_control to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/OML/sync_control.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.WGL import _types, _glgets +from OpenGL.raw.WGL.OML.sync_control import * +from OpenGL.raw.WGL.OML.sync_control import _EXTENSION_NAME + +def glInitSyncControlOML(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/VERSION/WGL_1_0.py b/venv/lib/python3.12/site-packages/OpenGL/WGL/VERSION/WGL_1_0.py new file mode 100644 index 00000000..e15b4445 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/WGL/VERSION/WGL_1_0.py @@ -0,0 +1,25 @@ +'''OpenGL extension VERSION.WGL_1_0 + +This module customises the behaviour of the +OpenGL.raw.WGL.VERSION.WGL_1_0 to provide a more +Python-friendly API + +The official definition of this extension is available here: +http://www.opengl.org/registry/specs/VERSION/WGL_1_0.txt +''' +from OpenGL import platform, constant, arrays +from OpenGL import extensions, wrapper +import ctypes +from OpenGL.raw.WGL import _types, _glgets +from OpenGL.raw.WGL.VERSION.WGL_1_0 import * +from OpenGL.raw.WGL.VERSION.WGL_1_0 import _EXTENSION_NAME + +def glInitWgl10VERSION(): + '''Return boolean indicating whether this extension is available''' + from OpenGL import extensions + return extensions.hasGLExtension( _EXTENSION_NAME ) + + +### END AUTOGENERATED SECTION + +wglGetCurrentDC.restyle = ctypes.HDC diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/VERSION/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/WGL/VERSION/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/WGL/VERSION/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/VERSION/__pycache__/WGL_1_0.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/WGL/VERSION/__pycache__/WGL_1_0.cpython-312.pyc new file mode 100644 index 00000000..0fc9b78c Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/WGL/VERSION/__pycache__/WGL_1_0.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/VERSION/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/WGL/VERSION/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..6596ec78 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/WGL/VERSION/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/WGL/__init__.py new file mode 100644 index 00000000..fc26708d --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/WGL/__init__.py @@ -0,0 +1,3 @@ +from OpenGL.raw.WGL.VERSION.WGL_1_0 import * + +wglUseFontBitmaps = wglUseFontBitmapsW diff --git a/venv/lib/python3.12/site-packages/OpenGL/WGL/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/WGL/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..5a5a28f6 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/WGL/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/__init__.py new file mode 100644 index 00000000..f9cc6bfc --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/__init__.py @@ -0,0 +1,375 @@ +"""ctypes-based OpenGL wrapper for Python + +This is the PyOpenGL 3.x tree, it attempts to provide +a largely compatible API for code written with the +PyOpenGL 2.x series using the ctypes foreign function +interface system. + +Configuration Variables: + +There are a few configuration variables in this top-level +module. Applications should be the only code that tweaks +these variables, mid-level libraries should not take it +upon themselves to disable/enable features at this level. +The implication there is that your library code should be +able to work with any of the valid configurations available +with these sets of flags. + +Further, once any entry point has been loaded, the variables +can no longer be updated. The OpenGL._confligflags module +imports the variables from this location, and once that +import occurs the flags should no longer be changed. + + ERROR_CHECKING -- if set to a False value before + importing any OpenGL.* libraries will completely + disable error-checking. This can dramatically + improve performance, but makes debugging far + harder. + + This is intended to be turned off *only* in a + production environment where you *know* that + your code is entirely free of situations where you + use exception-handling to handle error conditions, + i.e. where you are explicitly checking for errors + everywhere they can occur in your code. + + Default: True + + ERROR_LOGGING -- If True, then wrap array-handler + functions with error-logging operations so that all exceptions + will be reported to log objects in OpenGL.logs, note that + this means you will get lots of error logging whenever you + have code that tests by trying something and catching an + error, this is intended to be turned on only during + development so that you can see why something is failing. + + Errors are normally logged to the OpenGL.errors logger. + + Only triggers if ERROR_CHECKING is True + + Default: False + + ERROR_ON_COPY -- if set to a True value before + importing the numpy/lists support modules, will + cause array operations to raise + OpenGL.error.CopyError if the operation + would cause a data-copy in order to make the + passed data-type match the target data-type. + + This effectively disables all list/tuple array + support, as they are inherently copy-based. + + This feature allows for optimisation of your + application. It should only be enabled during + testing stages to prevent raising errors on + recoverable conditions at run-time. + + Default: False + + CONTEXT_CHECKING -- if set to True, PyOpenGL will wrap + *every* GL and GLU call with a check to see if there + is a valid context. If there is no valid context + then will throw OpenGL.errors.NoContext. This is an + *extremely* slow check and is not enabled by default, + intended to be enabled in order to track down (wrong) + code that uses GL/GLU entry points before the context + has been initialized (something later Linux GLs are + very picky about). + + Default: False + + STORE_POINTERS -- if set to True, PyOpenGL array operations + will attempt to store references to pointers which are + being passed in order to prevent memory-access failures + if the pointed-to-object goes out of scope. This + behaviour is primarily intended to allow temporary arrays + to be created without causing memory errors, thus it is + trading off performance for safety. + + To use this flag effectively, you will want to first set + ERROR_ON_COPY to True and eliminate all cases where you + are copying arrays. Copied arrays *will* segfault your + application deep within the GL if you disable this feature! + + Once you have eliminated all copying of arrays in your + application, you will further need to be sure that all + arrays which are passed to the GL are stored for at least + the time period for which they are active in the GL. That + is, you must be sure that your array objects live at least + until they are no longer bound in the GL. This is something + you need to confirm by thinking about your application's + structure. + + When you are sure your arrays won't cause seg-faults, you + can set STORE_POINTERS=False in your application and enjoy + a (slight) speed up. + + Note: this flag is *only* observed when ERROR_ON_COPY == True, + as a safety measure to prevent pointless segfaults + + Default: True + + WARN_ON_FORMAT_UNAVAILABLE -- If True, generates + logging-module warn-level events when a FormatHandler + plugin is not loadable (with traceback). + + Default: False + + FULL_LOGGING -- If True, then wrap functions with + logging operations which reports each call along with its + arguments to the OpenGL.calltrace logger at the INFO + level. This is *extremely* slow. You should *not* enable + this in production code! + + You will need to have a logging configuration (e.g. + logging.basicConfig() + ) call in your top-level script to see the results of the + logging. + + Default: False + + ALLOW_NUMPY_SCALARS -- if True, we will wrap + all GLint/GLfloat calls conversions with wrappers + that allow for passing numpy scalar values. + + Note that this is experimental, *not* reliable, + and very slow! + + Note that byte/char types are not wrapped. + + Default: False + + UNSIGNED_BYTE_IMAGES_AS_STRING -- if True, we will return + GL_UNSIGNED_BYTE image-data as strings, instead of arrays + for glReadPixels and glGetTexImage + + Default: True + + FORWARD_COMPATIBLE_ONLY -- only include OpenGL 3.1 compatible + entry points. Note that this will generally break most + PyOpenGL code that hasn't been explicitly made "legacy free" + via a significant rewrite. + + Default: False + + SIZE_1_ARRAY_UNPACK -- if True, unpack size-1 arrays to be + scalar values, as done in PyOpenGL 1.5 -> 3.0.0, that is, + if a glGenList( 1 ) is done, return a uint rather than + an array of uints. + + Default: True + + USE_ACCELERATE -- if True, attempt to use the OpenGL_accelerate + package to provide Cython-coded accelerators for core wrapping + operations. + + Default: True + + MODULE_ANNOTATIONS -- if True, attempt to annotate alternates() and + constants to track in which module they are defined (only useful + for the documentation-generation passes, really). + + Default: False + + TYPE_ANNOTATIONS -- if True, set up type annotations in __annotations__ + on raw functions. This is mostly just so that people can play + with the use of e.g. mypy or the like, but the values put in the + annotations dictionary are generally either ctypes types or + ArrayDataType references, so this isn't *likely* to be all that useful + without further work. +""" +from OpenGL.version import __version__ +import os + + +def environ_key(name, default): + composed = "PYOPENGL_%s" % name.upper() + if composed in os.environ: + value = os.environ[composed] + if value.lower() in ("1", "true"): + return True + else: + return False + return os.environ.get(composed, default) + + +ERROR_CHECKING = environ_key("ERROR_CHECKING", True) +ERROR_LOGGING = environ_key("ERROR_LOGGING", False) +ERROR_ON_COPY = environ_key("ERROR_ON_COPY", False) +ARRAY_SIZE_CHECKING = environ_key("ARRAY_SIZE_CHECKING", True) +STORE_POINTERS = environ_key("STORE_POINTERS", True) +WARN_ON_FORMAT_UNAVAILABLE = False +FORWARD_COMPATIBLE_ONLY = False +SIZE_1_ARRAY_UNPACK = True +USE_ACCELERATE = environ_key("USE_ACCELERATE", True) +CONTEXT_CHECKING = environ_key("CONTEXT_CHECKING", False) + +FULL_LOGGING = environ_key("FULL_LOGGING", False) +ALLOW_NUMPY_SCALARS = environ_key("ALLOW_NUMPY_SCALARS", False) +UNSIGNED_BYTE_IMAGES_AS_STRING = environ_key("UNSIGNED_BYTE_IMAGES_AS_STRING", True) +MODULE_ANNOTATIONS = False +TYPE_ANNOTATIONS = False + + +# Declarations of plugins provided by PyOpenGL itself +from OpenGL.plugins import PlatformPlugin, FormatHandler + +PlatformPlugin("nt", "OpenGL.platform.win32.Win32Platform") +PlatformPlugin("darwin", "OpenGL.platform.darwin.DarwinPlatform") +PlatformPlugin("linux2", "OpenGL.platform.glx.GLXPlatform") +PlatformPlugin("linux", "OpenGL.platform.glx.GLXPlatform") +PlatformPlugin("glx", "OpenGL.platform.glx.GLXPlatform") +PlatformPlugin("posix", "OpenGL.platform.glx.GLXPlatform") +PlatformPlugin("x11", "OpenGL.platform.glx.GLXPlatform") # xdg session type +PlatformPlugin("osmesa", "OpenGL.platform.osmesa.OSMesaPlatform") +PlatformPlugin("egl", "OpenGL.platform.egl.EGLPlatform") +PlatformPlugin("wayland", "OpenGL.platform.egl.EGLPlatform") # xdg session type +PlatformPlugin( + "xwayland", "OpenGL.platform.egl.EGLPlatform" +) # xdg session type, but use egl even though normally you'd expect GLX + + +def setPlatform(key): + """Programatically set the platform to use for PyOpenGL + + Note: you must do this *before* you import e.g. GL.* or GLES.* + as the extension procedure lookup is platform dependent + + The PYOPENGL_PLATFORM environment variable is likely more useful + for a *user* choosing a platform, but in cases where the programmer + needs to choose the platform (e.g. to allow using Pygame-GLX + under wayland) you can call `setPlatform('glx')` to force the + use of the glx plugin. + """ + os.environ["PYOPENGL_PLATFORM"] = key + + +import sys + +if sys.version_info[0] < 3: + # Python 3.x renames the built-in module + _bi = "__builtin__" +else: + _bi = "builtins" + +FormatHandler( + "none", "OpenGL.arrays.nones.NoneHandler", [_bi + ".NoneType"], isOutput=False +) + +if sys.version_info[0] < 3: + FormatHandler( + "str", "OpenGL.arrays.strings.StringHandler", [_bi + ".str"], isOutput=False + ) + FormatHandler( + "unicode", + "OpenGL.arrays.strings.UnicodeHandler", + [_bi + ".unicode"], + isOutput=False, + ) +else: + FormatHandler( + "bytes", "OpenGL.arrays.strings.StringHandler", [_bi + ".bytes"], isOutput=False + ) + FormatHandler( + "str", "OpenGL.arrays.strings.UnicodeHandler", [_bi + ".str"], isOutput=False + ) + +FormatHandler( + "list", + "OpenGL.arrays.lists.ListHandler", + [ + _bi + ".list", + _bi + ".tuple", + ], + isOutput=False, +) +FormatHandler( + "numbers", + "OpenGL.arrays.numbers.NumberHandler", + [ + _bi + ".int", + _bi + ".float", + _bi + ".long", + ], + isOutput=False, +) +FormatHandler( + "ctypesarrays", + "OpenGL.arrays.ctypesarrays.CtypesArrayHandler", + [ + "_ctypes.ArrayType", + "_ctypes.PyCArrayType", + "_ctypes.Array", + "_ctypes.array.Array", + ], + isOutput=True, +) +FormatHandler( + "ctypesparameter", + "OpenGL.arrays.ctypesparameters.CtypesParameterHandler", + [ + _bi + ".CArgObject", + "ctypes.c_uint", + "ctypes.c_int", + "ctypes.c_float", + "ctypes.c_double", + "ctypes.c_ulong", + "ctypes.c_long", + "ctypes.c_longlong", + ], + isOutput=True, +) +FormatHandler( + "ctypespointer", + "OpenGL.arrays.ctypespointers.CtypesPointerHandler", + [ + "ctypes.c_void_p", + "_ctypes._Pointer", + "ctypes.c_char_p", + "_ctypes.pointer._Pointer", + ], + isOutput=False, +) +FormatHandler( + "numpy", + "OpenGL.arrays.numpymodule.NumpyHandler", + [ + "numpy.ndarray", + "numpy.core.memmap.memmap", + "numpy.uint8", + "numpy.uint16", + "numpy.uint32", + "numpy.uint64", + "numpy.int8", + "numpy.int16", + "numpy.int32", + "numpy.int64", + "numpy.float16", + "numpy.float32", + "numpy.float64", + "numpy.float128", + ], + isOutput=True, +) +FormatHandler( + "buffer", + "OpenGL.arrays.buffers.BufferHandler", + [ + "OpenGL.arrays._buffers.Py_buffer", + _bi + ".memoryview", + _bi + ".bytearray", + ], + isOutput=True, +) +FormatHandler( + "vbo", + "OpenGL.arrays.vbo.VBOHandler", + ["OpenGL.arrays.vbo.VBO", "OpenGL_accelerate.vbo.VBO"], + isOutput=False, +) +FormatHandler( + "vbooffset", + "OpenGL.arrays.vbo.VBOOffsetHandler", + ["OpenGL.arrays.vbo.VBOOffset", "OpenGL_accelerate.vbo.VBOOffset"], + isOutput=False, +) diff --git a/venv/lib/python3.12/site-packages/OpenGL/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..10714196 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/__pycache__/_bytes.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/__pycache__/_bytes.cpython-312.pyc new file mode 100644 index 00000000..de25f25d Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/__pycache__/_bytes.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/__pycache__/_configflags.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/__pycache__/_configflags.cpython-312.pyc new file mode 100644 index 00000000..e8666c31 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/__pycache__/_configflags.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/__pycache__/_null.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/__pycache__/_null.cpython-312.pyc new file mode 100644 index 00000000..9e458c71 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/__pycache__/_null.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/__pycache__/_opaque.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/__pycache__/_opaque.cpython-312.pyc new file mode 100644 index 00000000..4feeffa6 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/__pycache__/_opaque.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/__pycache__/acceleratesupport.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/__pycache__/acceleratesupport.cpython-312.pyc new file mode 100644 index 00000000..141e0083 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/__pycache__/acceleratesupport.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/__pycache__/constant.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/__pycache__/constant.cpython-312.pyc new file mode 100644 index 00000000..02b7aeff Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/__pycache__/constant.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/__pycache__/constants.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/__pycache__/constants.cpython-312.pyc new file mode 100644 index 00000000..f722af33 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/__pycache__/constants.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/__pycache__/contextdata.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/__pycache__/contextdata.cpython-312.pyc new file mode 100644 index 00000000..2b30d8e0 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/__pycache__/contextdata.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/__pycache__/converters.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/__pycache__/converters.cpython-312.pyc new file mode 100644 index 00000000..8b0bf990 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/__pycache__/converters.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/__pycache__/error.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/__pycache__/error.cpython-312.pyc new file mode 100644 index 00000000..524473e1 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/__pycache__/error.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/__pycache__/extensions.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/__pycache__/extensions.cpython-312.pyc new file mode 100644 index 00000000..2a0a614a Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/__pycache__/extensions.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/__pycache__/images.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/__pycache__/images.cpython-312.pyc new file mode 100644 index 00000000..f2fba820 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/__pycache__/images.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/__pycache__/latebind.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/__pycache__/latebind.cpython-312.pyc new file mode 100644 index 00000000..af214b4c Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/__pycache__/latebind.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/__pycache__/lazywrapper.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/__pycache__/lazywrapper.cpython-312.pyc new file mode 100644 index 00000000..c6ae0fc2 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/__pycache__/lazywrapper.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/__pycache__/logs.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/__pycache__/logs.cpython-312.pyc new file mode 100644 index 00000000..8394025f Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/__pycache__/logs.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/__pycache__/plugins.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/__pycache__/plugins.cpython-312.pyc new file mode 100644 index 00000000..be1bc8a5 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/__pycache__/plugins.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/__pycache__/version.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/__pycache__/version.cpython-312.pyc new file mode 100644 index 00000000..ea48d1c3 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/__pycache__/version.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/__pycache__/wrapper.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/__pycache__/wrapper.cpython-312.pyc new file mode 100644 index 00000000..48dd631b Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/__pycache__/wrapper.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/_bytes.py b/venv/lib/python3.12/site-packages/OpenGL/_bytes.py new file mode 100644 index 00000000..f19479c2 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/_bytes.py @@ -0,0 +1,92 @@ +"""8-bit string definitions for Python 2/3 compatibility + +Defines the following which allow for dealing with Python 3 breakages: + + STR_IS_BYTES + STR_IS_UNICODE + + Easily checked booleans for type identities + + _NULL_8_BYTE + + An 8-bit byte with NULL (0) value + + as_8_bit( x, encoding='utf-8') + + Returns the value as the 8-bit version + + unicode -- always pointing to the unicode type + bytes -- always pointing to the 8-bit bytes type +""" +import sys + +STR_IS_BYTES = True + +if sys.version_info[:2] < (2,6): + # no bytes, traditional setup... + bytes = str +else: + bytes = bytes +try: + long = long +except NameError as err: + long = int +if sys.version_info[:2] < (3,0): + # traditional setup, with bytes defined... + unicode = unicode + _NULL_8_BYTE = '\000' + def as_8_bit( x, encoding='utf-8' ): + if isinstance( x, unicode ): + return x.encode( encoding ) + return bytes( x ) + integer_types = int,long + def as_str( x, encoding='utf-8'): + """Produce a native string (i.e. different on python 2 and 3)""" + if isinstance(x,bytes): + return x + elif isinstance(x,unicode): + return x.encode(encoding) + else: + return str(x) +else: + # new setup, str is now unicode... + STR_IS_BYTES = False + _NULL_8_BYTE = bytes( '\000','latin1' ) + def as_8_bit( x, encoding='utf-8' ): + if isinstance( x,unicode ): + return x.encode(encoding) + elif isinstance( x, bytes ): + # Note: this can create an 8-bit string that is *not* in encoding, + # but that is potentially exactly what we wanted, as these can + # be arbitrary byte-streams being passed to C functions + return x + return str(x).encode( encoding ) + unicode = str + integer_types = int, + def as_str( x, encoding='utf-8'): + """Produce a native string (i.e. different on python 2 and 3)""" + if isinstance(x,unicode): + return x + elif isinstance(x,bytes): + return x.decode(encoding) + else: + return str(x) + +STR_IS_UNICODE = not STR_IS_BYTES +if hasattr( sys, 'maxsize' ): + maxsize = sys.maxsize +else: + maxsize = sys.maxint + +def as_unicode(x,encoding='utf-8'): + """Ensure is a unicode object given default encoding""" + if isinstance(x,unicode): + return x + elif isinstance(x,bytes): + try: + return x.decode(encoding) + except UnicodeDecodeError as err: + return x.decode('latin-1') + else: + return unicode(x) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/_configflags.py b/venv/lib/python3.12/site-packages/OpenGL/_configflags.py new file mode 100644 index 00000000..5e99c98a --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/_configflags.py @@ -0,0 +1,19 @@ +"""Holds the import-time constants for various configuration flags""" +from OpenGL import ( + ERROR_CHECKING, + ERROR_LOGGING, + ERROR_ON_COPY, + ARRAY_SIZE_CHECKING, + STORE_POINTERS, + WARN_ON_FORMAT_UNAVAILABLE, + FORWARD_COMPATIBLE_ONLY, + SIZE_1_ARRAY_UNPACK, + USE_ACCELERATE, + CONTEXT_CHECKING, + + FULL_LOGGING, + ALLOW_NUMPY_SCALARS, + UNSIGNED_BYTE_IMAGES_AS_STRING, + MODULE_ANNOTATIONS, + TYPE_ANNOTATIONS, +) diff --git a/venv/lib/python3.12/site-packages/OpenGL/_null.py b/venv/lib/python3.12/site-packages/OpenGL/_null.py new file mode 100644 index 00000000..c2198139 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/_null.py @@ -0,0 +1,2 @@ +"""Just a NULL object for reference by other modules""" +NULL = object() diff --git a/venv/lib/python3.12/site-packages/OpenGL/_opaque.py b/venv/lib/python3.12/site-packages/OpenGL/_opaque.py new file mode 100644 index 00000000..ceb3aed1 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/_opaque.py @@ -0,0 +1,25 @@ +"""Data-type definitions for EGL/GLES""" +import ctypes +pointer = ctypes.pointer + +class _Opaque( ctypes.Structure ): + """An Opaque Structure reference (base class)""" +class _opaque_pointer( ctypes.POINTER( _Opaque ) ): + _type_ = _Opaque + @classmethod + def from_param( cls, value ): + return ctypes.cast( value, cls ) + @property + def address( self ): + return ctypes.addressof( self.contents ) + @property + def as_voidp( self ): + return ctypes.c_voidp( self.address ) + def __hash__(self): + """Allow these pointers to be used as keys in dictionaries""" + return self.address +def opaque_pointer_cls( name ): + """Create an Opaque pointer class for the given name""" + typ = type( name, (_Opaque,), {} ) + p_typ = type( name+'_pointer', (_opaque_pointer,), {'_type_':typ}) + return p_typ diff --git a/venv/lib/python3.12/site-packages/OpenGL/acceleratesupport.py b/venv/lib/python3.12/site-packages/OpenGL/acceleratesupport.py new file mode 100644 index 00000000..5dab688d --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/acceleratesupport.py @@ -0,0 +1,24 @@ +"""Common code for accelerated modules""" +import logging +from OpenGL import _configflags + +needed_version = (3, 1, 6) +_log = logging.getLogger("OpenGL.acceleratesupport") +try: + import OpenGL_accelerate + + if _configflags.USE_ACCELERATE: + if OpenGL_accelerate.__version_tuple__ < needed_version: + _log.warning( + """Incompatible version of OpenGL_accelerate found, need at least %s found %s""", + needed_version, + OpenGL_accelerate.__version_tuple__, + ) + raise ImportError("""Old version of OpenGL_accelerate""") + ACCELERATE_AVAILABLE = True + _log.debug("""OpenGL_accelerate module loaded""") + else: + raise ImportError("""Acceleration disabled""") +except ImportError as err: + _log.info("""No OpenGL_accelerate module loaded: %s""", err) + ACCELERATE_AVAILABLE = False diff --git a/venv/lib/python3.12/site-packages/OpenGL/arrays/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/arrays/__init__.py new file mode 100644 index 00000000..b6aca351 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/arrays/__init__.py @@ -0,0 +1,21 @@ +"""Abstraction point for handling of data-pointers in OpenGL + +The purpose of this package is to allow for the registration and dispatch +of handlers for different data-types in such a way that you can add new +data-types to the set of types which PyOpenGL will handle as arguments +to functions requiring typed pointers. + +Possible data types: + Numpy arrays + Numarray arrays + PyGame surfaces + PyMedia buffers + Python buffer-objects + Memory-mapped files + PIL images +""" +import ctypes +import OpenGL +from OpenGL.arrays.arraydatatype import * +from OpenGL.arrays import formathandler +from OpenGL.arrays.arrayhelpers import * diff --git a/venv/lib/python3.12/site-packages/OpenGL/arrays/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/arrays/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..0c0d70bc Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/arrays/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/arrays/__pycache__/_arrayconstants.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/arrays/__pycache__/_arrayconstants.cpython-312.pyc new file mode 100644 index 00000000..b585b514 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/arrays/__pycache__/_arrayconstants.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/arrays/__pycache__/_buffers.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/arrays/__pycache__/_buffers.cpython-312.pyc new file mode 100644 index 00000000..8e4e9259 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/arrays/__pycache__/_buffers.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/arrays/__pycache__/_strings.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/arrays/__pycache__/_strings.cpython-312.pyc new file mode 100644 index 00000000..19919594 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/arrays/__pycache__/_strings.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/arrays/__pycache__/arraydatatype.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/arrays/__pycache__/arraydatatype.cpython-312.pyc new file mode 100644 index 00000000..63b957fe Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/arrays/__pycache__/arraydatatype.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/arrays/__pycache__/arrayhelpers.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/arrays/__pycache__/arrayhelpers.cpython-312.pyc new file mode 100644 index 00000000..cab4b042 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/arrays/__pycache__/arrayhelpers.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/arrays/__pycache__/buffers.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/arrays/__pycache__/buffers.cpython-312.pyc new file mode 100644 index 00000000..f9b37149 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/arrays/__pycache__/buffers.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/arrays/__pycache__/ctypesarrays.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/arrays/__pycache__/ctypesarrays.cpython-312.pyc new file mode 100644 index 00000000..7629503b Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/arrays/__pycache__/ctypesarrays.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/arrays/__pycache__/ctypesparameters.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/arrays/__pycache__/ctypesparameters.cpython-312.pyc new file mode 100644 index 00000000..ab303023 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/arrays/__pycache__/ctypesparameters.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/arrays/__pycache__/ctypespointers.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/arrays/__pycache__/ctypespointers.cpython-312.pyc new file mode 100644 index 00000000..8ae1c69d Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/arrays/__pycache__/ctypespointers.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/arrays/__pycache__/formathandler.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/arrays/__pycache__/formathandler.cpython-312.pyc new file mode 100644 index 00000000..1fd6398c Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/arrays/__pycache__/formathandler.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/arrays/__pycache__/lists.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/arrays/__pycache__/lists.cpython-312.pyc new file mode 100644 index 00000000..d40258b2 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/arrays/__pycache__/lists.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/arrays/__pycache__/nones.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/arrays/__pycache__/nones.cpython-312.pyc new file mode 100644 index 00000000..f24418e2 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/arrays/__pycache__/nones.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/arrays/__pycache__/numbers.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/arrays/__pycache__/numbers.cpython-312.pyc new file mode 100644 index 00000000..370137a9 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/arrays/__pycache__/numbers.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/arrays/__pycache__/numpybuffers.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/arrays/__pycache__/numpybuffers.cpython-312.pyc new file mode 100644 index 00000000..6f0a174a Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/arrays/__pycache__/numpybuffers.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/arrays/__pycache__/numpymodule.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/arrays/__pycache__/numpymodule.cpython-312.pyc new file mode 100644 index 00000000..570ad20f Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/arrays/__pycache__/numpymodule.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/arrays/__pycache__/strings.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/arrays/__pycache__/strings.cpython-312.pyc new file mode 100644 index 00000000..1aeec482 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/arrays/__pycache__/strings.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/arrays/__pycache__/vbo.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/arrays/__pycache__/vbo.cpython-312.pyc new file mode 100644 index 00000000..905157dc Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/arrays/__pycache__/vbo.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/arrays/_arrayconstants.py b/venv/lib/python3.12/site-packages/OpenGL/arrays/_arrayconstants.py new file mode 100644 index 00000000..dcf9cb13 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/arrays/_arrayconstants.py @@ -0,0 +1,52 @@ +import ctypes +from OpenGL.constant import Constant +from OpenGL._bytes import bytes,unicode,as_8_bit, long +from OpenGL._opaque import opaque_pointer_cls as _opaque_pointer_cls +sizeof = ctypes.sizeof + +GL_FALSE = Constant( 'GL_FALSE', 0x0 ) +GL_TRUE = Constant( 'GL_TRUE', 0x1 ) +GL_BYTE = Constant( 'GL_BYTE', 0x1400 ) +GL_UNSIGNED_BYTE = Constant( 'GL_UNSIGNED_BYTE', 0x1401 ) +GL_SHORT = Constant( 'GL_SHORT', 0x1402 ) +GL_UNSIGNED_SHORT = Constant( 'GL_UNSIGNED_SHORT', 0x1403 ) +GL_INT = Constant( 'GL_INT', 0x1404 ) +GL_UNSIGNED_INT = Constant( 'GL_UNSIGNED_INT', 0x1405 ) +GL_UNSIGNED_INT64 = Constant( 'GL_UNSIGNED_INT64_AMD', 0x8BC2 ) +GL_FLOAT = Constant( 'GL_FLOAT', 0x1406 ) +GL_DOUBLE = Constant( 'GL_DOUBLE', 0x140a ) +GL_CHAR = bytes +GL_HALF_FLOAT = Constant( 'GL_HALF_FLOAT_ARB',0x140B) +GL_HALF_NV = Constant( 'GL_HALF_NV', 0x1401 ) +GL_VOID_P = object() + +BYTE_SIZES = { + GL_BYTE: 1, + GL_CHAR: 1, + GL_UNSIGNED_BYTE: 1, + GL_SHORT: 2, + GL_UNSIGNED_SHORT: 2, + GL_INT: 4, + GL_UNSIGNED_INT: 4, + GL_UNSIGNED_INT64: 8, + GL_HALF_FLOAT: 2, + GL_FLOAT: 4, + GL_DOUBLE: 8, +} + +ARRAY_TO_GL_TYPE_MAPPING = { + 'c': GL_UNSIGNED_BYTE, + 'e': GL_HALF_FLOAT, + 'f': GL_FLOAT, + 'b': GL_BYTE, + 'i': GL_INT, + 'l': GL_INT, + '?': GL_INT,# Boolean + 'd': GL_DOUBLE, + 'L': GL_UNSIGNED_INT, + 'h': GL_SHORT, + 'H': GL_UNSIGNED_SHORT, + 'B': GL_UNSIGNED_BYTE, + 'I': GL_UNSIGNED_INT, + None: None, +} diff --git a/venv/lib/python3.12/site-packages/OpenGL/arrays/_buffers.py b/venv/lib/python3.12/site-packages/OpenGL/arrays/_buffers.py new file mode 100644 index 00000000..8d18af72 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/arrays/_buffers.py @@ -0,0 +1,105 @@ +#! /usr/bin/env python +"""Python 3.x buffer-handling (currently just for bytes/bytearray types) +""" +import ctypes,sys +if sys.version_info[:2] < (2,6): + raise ImportError( 'Buffer interface only usable on Python 2.6+' ) +from ._arrayconstants import * + +PyBUF_SIMPLE = 0 +PyBUF_WRITABLE = PyBUF_WRITEABLE = 0x0001 +PyBUF_ND = 0x0008 +PyBUF_STRIDES = (0x0010 | PyBUF_ND) +PyBUF_CONTIG = (PyBUF_ND | PyBUF_WRITABLE) +PyBUF_CONTIG_RO = (PyBUF_ND) +PyBUF_C_CONTIGUOUS = (0x0020 | PyBUF_STRIDES) +PyBUF_FORMAT = 0x0004 + +# Python 2.6 doesn't define this... +c_ssize_t = getattr( ctypes, 'c_ssize_t',ctypes.c_ulong) + +_fields_ = [ + ('buf',ctypes.c_void_p), + ('obj',ctypes.c_void_p), + ('len',c_ssize_t), + ('itemsize',c_ssize_t), + + ('readonly',ctypes.c_int), + ('ndim',ctypes.c_int), + ('format',ctypes.c_char_p), + ('shape',ctypes.POINTER(c_ssize_t)), + ('strides',ctypes.POINTER(c_ssize_t)), + ('suboffsets',ctypes.POINTER(c_ssize_t)), +] + + +if sys.version_info[:2] <= (2,6) or sys.version_info[:2] >= (3,3): + # Original structure was eventually restored in 3.3, so just + # 2.7 through 3.2 uses the "enhanced" structure below + _fields_.extend( [ + ('internal',ctypes.c_void_p), + ] ) +else: + # Sigh, this structure seems to have changed with Python 3.x... + _fields_.extend( [ + ('smalltable',ctypes.c_size_t*2), + ('internal',ctypes.c_void_p), + ] ) + +class Py_buffer(ctypes.Structure): + """Wrapper around the Python buffer structure...""" + @classmethod + def from_object( cls, object, flags=PyBUF_STRIDES|PyBUF_FORMAT|PyBUF_C_CONTIGUOUS ): + """Create a new Py_buffer referencing ram of object""" + if not CheckBuffer( object ): + raise TypeError( "%s type does not support Buffer Protocol"%(object.__class__,)) + buf = cls() + # deallocation of the buf causes glibc abort :( + result = GetBuffer( object, buf, flags ) + if result != 0: + raise ValueError( "Unable to retrieve Buffer from %s"%(object,)) + if not buf.buf: + raise ValueError( "Null pointer result from %s"%(object,) ) + return buf + _fields_ = _fields_ + @property + def dims( self ): + return self.shape[:self.ndim] + def __len__( self ): + return self.shape[0] + @property + def dim_strides( self ): + if self.strides: + return self.strides[:self.ndim] + return None + def __enter__(self): + pass + def __exit__( self, exc_type=None, exc_value=None, traceback=None): + if self.obj: + ReleaseBuffer( self ) + def __del__( self ): + if self.obj: + ReleaseBuffer( self ) + +BUFFER_POINTER = ctypes.POINTER( Py_buffer ) + + +try: + CheckBuffer = ctypes.pythonapi.PyObject_CheckBuffer + CheckBuffer.argtypes = [ctypes.py_object] + CheckBuffer.restype = ctypes.c_int +except AttributeError as err: + # Python 2.6 doesn't appear to have CheckBuffer support... + CheckBuffer = lambda x: True + +IncRef = ctypes.pythonapi.Py_IncRef +IncRef.argtypes = [ ctypes.py_object ] + +GetBuffer = ctypes.pythonapi.PyObject_GetBuffer +GetBuffer.argtypes = [ ctypes.py_object, BUFFER_POINTER, ctypes.c_int ] +GetBuffer.restype = ctypes.c_int + +ReleaseBuffer = ctypes.pythonapi.PyBuffer_Release +ReleaseBuffer.argtypes = [ BUFFER_POINTER ] +ReleaseBuffer.restype = None + diff --git a/venv/lib/python3.12/site-packages/OpenGL/arrays/_strings.py b/venv/lib/python3.12/site-packages/OpenGL/arrays/_strings.py new file mode 100644 index 00000000..66aa5047 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/arrays/_strings.py @@ -0,0 +1,69 @@ +"""Run-time calculation of offset into Python string structure + +Does a scan to find the digits of pi in a string structure +in order to produce an offset that can be used to produce +data-pointers from Python strings. + +Porting note: + + Currently this uses id( str a ) to get the base address + of the Python string. Python implementations where id( a ) + is *not* the memory address of the string will not work! +""" +from __future__ import print_function +import ctypes +from OpenGL._bytes import bytes +PI_DIGITS = '31415926535897931' + +def calculateOffset( ): + """Calculates the data-pointer offset for strings + + This does a sequential scan for 100 bytes from the id + of a string to find special data-value stored in the + string (the digits of PI). It produces a dataPointer + function which adds that offset to the id of the + passed strings. + """ + finalOffset = None + a = PI_DIGITS + # XXX NOT portable across Python implmentations!!! + initial = id(a) + targetType = ctypes.POINTER( ctypes.c_char ) + for offset in range( 100 ): + vector = ctypes.cast( initial+offset,targetType ) + allMatched = True + for index,digit in enumerate( a ): + if vector[index] != digit: + allMatched = False + break + if allMatched: + finalOffset = offset + break + if finalOffset is not None: + def dataPointer( data ): + """Return the data-pointer from the array using calculated offset + + data -- a Python string + + Returns the raw data-pointer to the internal buffer of the passed string + """ + if not isinstance( data, bytes ): + raise TypeError( + """This function can only handle Python strings! Got %s"""%( + type(data), + ) + ) + return id(data) + finalOffset + # just for later reference... + dataPointer.offset = finalOffset + return dataPointer + raise RuntimeError( + """Unable to determine dataPointer offset for strings!""" + ) + +dataPointer = calculateOffset() + +if __name__ == "__main__": + a = 'this' + print((id(a), dataPointer( a ), dataPointer(a) - id(a))) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/arrays/arraydatatype.py b/venv/lib/python3.12/site-packages/OpenGL/arrays/arraydatatype.py new file mode 100644 index 00000000..82fa0c22 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/arrays/arraydatatype.py @@ -0,0 +1,372 @@ +"""Array data-type implementations (abstraction points for GL array types""" +import ctypes +import OpenGL + +assert OpenGL +from OpenGL.raw.GL import _types +from OpenGL import plugins +from OpenGL.arrays import formathandler, _arrayconstants as GL_1_1 +from OpenGL import logs + +_log = logs.getLog("OpenGL.arrays.arraydatatype") +try: + unicode +except NameError: + unicode = str + +from OpenGL import acceleratesupport + +ADT = None +if acceleratesupport.ACCELERATE_AVAILABLE: + try: + from OpenGL_accelerate.arraydatatype import ArrayDatatype as ADT + except ImportError as err: + _log.warning("Unable to load ArrayDatatype accelerator from OpenGL_accelerate") +if ADT is None: + # Python-coded version + class HandlerRegistry(dict): + GENERIC_OUTPUT_PREFERENCES = ["numpy", "ctypesarrays"] + + def __init__(self, plugin_match): + self.match = plugin_match + self.output_handler = None + self.preferredOutput = None + self.all_output_handlers = [] + + def __call__(self, value): + """Lookup of handler for given value""" + try: + typ = value.__class__ + except AttributeError: + typ = type(value) + handler = self.get(typ) + if not handler: + if hasattr(typ, "__mro__"): + for base in typ.__mro__: + handler = self.get(base) + if not handler: + handler = self.match(base) + if handler: + handler = handler.load() + if handler: + handler = handler() + if handler: + self[typ] = handler + if hasattr(handler, "registerEquivalent"): + handler.registerEquivalent(typ, base) + return handler + print(self.keys()) + raise TypeError( + """No array-type handler for type %s.%s (value: %s) registered""" + % (typ.__module__, typ.__name__, repr(value)[:50]) + ) + return handler + + def handler_by_plugin_name(self, name): + plugin = plugins.FormatHandler.by_name(name) + if plugin: + try: + return plugin.load() + except ImportError: + return None + else: + raise RuntimeError("No handler of name %s found" % (name,)) + + def get_output_handler(self): + """Fast-path lookup for output handler object""" + if self.output_handler is None: + if self.preferredOutput is not None: + self.output_handler = self.handler_by_plugin_name( + self.preferredOutput + ) + if not self.output_handler: + for preferred in self.GENERIC_OUTPUT_PREFERENCES: + self.output_handler = self.handler_by_plugin_name(preferred) + if self.output_handler: + break + if not self.output_handler: + raise RuntimeError( + """Unable to find any output handler at all (not even ctypes/numpy ones!)""" + ) + return self.output_handler + + def register(self, handler, types=None): + """Register this class as handler for given set of types""" + if not isinstance(types, (list, tuple)): + types = [types] + for type in types: + self[type] = handler + if handler.isOutput: + self.all_output_handlers.append(handler) + + def registerReturn(self, handler): + """Register this handler as the default return-type handler""" + if isinstance(handler, (str, unicode)): + self.preferredOutput = handler + self.output_handler = None + else: + self.preferredOutput = None + self.output_handler = handler + + GLOBAL_REGISTRY = HandlerRegistry(plugins.FormatHandler.match) + formathandler.FormatHandler.TYPE_REGISTRY = GLOBAL_REGISTRY + + class ArrayDatatype(object): + """Mix-in for array datatype classes + + The ArrayDatatype marker essentially is used to mark a particular argument + as having an "array" type, which means that it is eligible for handling + via the arrays sub-package and its registered handlers. + """ + + typeConstant = None + handler = GLOBAL_REGISTRY + getHandler = GLOBAL_REGISTRY.__call__ + returnHandler = GLOBAL_REGISTRY.get_output_handler + isAccelerated = False + + @classmethod + def getRegistry(cls): + """Get our handler registry""" + return cls.handler + + def from_param(cls, value, typeConstant=None): + """Given a value in a known data-pointer type, convert to a ctypes pointer""" + return cls.getHandler(value).from_param(value, cls.typeConstant) + + from_param = classmethod(logs.logOnFail(from_param, _log)) + + def dataPointer(cls, value): + """Given a value in a known data-pointer type, return long for pointer""" + try: + return cls.getHandler(value).dataPointer(value) + except Exception: + _log.warning( + """Failure in dataPointer for %s instance %s""", + type(value), + value, + ) + raise + + dataPointer = classmethod(logs.logOnFail(dataPointer, _log)) + + def voidDataPointer(cls, value): + """Given value in a known data-pointer type, return void_p for pointer""" + pointer = cls.dataPointer(value) + try: + return ctypes.c_void_p(pointer) + except TypeError: + return pointer + + voidDataPointer = classmethod(logs.logOnFail(voidDataPointer, _log)) + + def typedPointer(cls, value): + """Return a pointer-to-base-type pointer for given value""" + return ctypes.cast(cls.dataPointer(value), ctypes.POINTER(cls.baseType)) + + typedPointer = classmethod(typedPointer) + + def asArray(cls, value, typeCode=None): + """Given a value, convert to preferred array representation""" + return cls.getHandler(value).asArray(value, typeCode or cls.typeConstant) + + asArray = classmethod(logs.logOnFail(asArray, _log)) + + def arrayToGLType(cls, value): + """Given a data-value, guess the OpenGL type of the corresponding pointer + + Note: this is not currently used in PyOpenGL and may be removed + eventually. + """ + return cls.getHandler(value).arrayToGLType(value) + + arrayToGLType = classmethod(logs.logOnFail(arrayToGLType, _log)) + + def arraySize(cls, value, typeCode=None): + """Given a data-value, calculate dimensions for the array (number-of-units)""" + return cls.getHandler(value).arraySize(value, typeCode or cls.typeConstant) + + arraySize = classmethod(logs.logOnFail(arraySize, _log)) + + def unitSize(cls, value, typeCode=None): + """Determine unit size of an array (if possible) + + Uses our local type if defined, otherwise asks the handler to guess... + """ + return cls.getHandler(value).unitSize(value, typeCode or cls.typeConstant) + + unitSize = classmethod(logs.logOnFail(unitSize, _log)) + + def zeros(cls, dims, typeCode=None): + """Allocate a return array of the given dimensions filled with zeros""" + return cls.returnHandler().zeros(dims, typeCode or cls.typeConstant) + + zeros = classmethod(logs.logOnFail(zeros, _log)) + + def dimensions(cls, value): + """Given a data-value, get the dimensions (assumes full structure info)""" + return cls.getHandler(value).dimensions(value) + + dimensions = classmethod(logs.logOnFail(dimensions, _log)) + + def arrayByteCount(cls, value): + """Given a data-value, try to determine number of bytes it's final form occupies + + For most data-types this is arraySize() * atomic-unit-size + """ + return cls.getHandler(value).arrayByteCount(value) + + arrayByteCount = classmethod(logs.logOnFail(arrayByteCount, _log)) + + # the final array data-type classes... + class GLclampdArray(ArrayDatatype, ctypes.POINTER(_types.GLclampd)): + """Array datatype for GLclampd types""" + + baseType = _types.GLclampd + typeConstant = _types.GL_DOUBLE + + class GLclampfArray(ArrayDatatype, ctypes.POINTER(_types.GLclampf)): + """Array datatype for GLclampf types""" + + baseType = _types.GLclampf + typeConstant = _types.GL_FLOAT + + class GLfloat16Array(ArrayDatatype, ctypes.POINTER(_types.GLushort)): + """Array datatype for float16 as GLushort types""" + + baseType = _types.GLushort + typeConstant = _types.GL_HALF_FLOAT + + class GLfloatArray(ArrayDatatype, ctypes.POINTER(_types.GLfloat)): + """Array datatype for GLfloat types""" + + baseType = _types.GLfloat + typeConstant = _types.GL_FLOAT + + class GLdoubleArray(ArrayDatatype, ctypes.POINTER(_types.GLdouble)): + """Array datatype for GLdouble types""" + + baseType = _types.GLdouble + typeConstant = _types.GL_DOUBLE + + class GLbyteArray(ArrayDatatype, ctypes.POINTER(_types.GLbyte)): + """Array datatype for GLbyte types""" + + baseType = _types.GLbyte + typeConstant = _types.GL_BYTE + + class GLcharArray(ArrayDatatype, ctypes.c_char_p): + """Array datatype for ARB extension pointers-to-arrays""" + + baseType = _types.GLchar + typeConstant = _types.GL_BYTE + + GLcharARBArray = GLcharArray + + class GLshortArray(ArrayDatatype, ctypes.POINTER(_types.GLshort)): + """Array datatype for GLshort types""" + + baseType = _types.GLshort + typeConstant = _types.GL_SHORT + + class GLintArray(ArrayDatatype, ctypes.POINTER(_types.GLint)): + """Array datatype for GLint types""" + + baseType = _types.GLint + typeConstant = _types.GL_INT + + class GLubyteArray(ArrayDatatype, ctypes.POINTER(_types.GLubyte)): + """Array datatype for GLubyte types""" + + baseType = _types.GLubyte + typeConstant = _types.GL_UNSIGNED_BYTE + + GLbooleanArray = GLubyteArray + + class GLushortArray(ArrayDatatype, ctypes.POINTER(_types.GLushort)): + """Array datatype for GLushort types""" + + baseType = _types.GLushort + typeConstant = _types.GL_UNSIGNED_SHORT + + class GLuintArray(ArrayDatatype, ctypes.POINTER(_types.GLuint)): + """Array datatype for GLuint types""" + + baseType = _types.GLuint + typeConstant = _types.GL_UNSIGNED_INT + + class GLint64Array(ArrayDatatype, ctypes.POINTER(_types.GLint64)): + """Array datatype for GLuint types""" + + baseType = _types.GLint64 + typeConstant = None # TODO: find out what this should be! + + class GLuint64Array(ArrayDatatype, ctypes.POINTER(_types.GLuint64)): + """Array datatype for GLuint types""" + + baseType = _types.GLuint64 + typeConstant = _types.GL_UNSIGNED_INT64 + + class GLenumArray(ArrayDatatype, ctypes.POINTER(_types.GLenum)): + """Array datatype for GLenum types""" + + baseType = _types.GLenum + typeConstant = _types.GL_UNSIGNED_INT + + class GLsizeiArray(ArrayDatatype, ctypes.POINTER(_types.GLsizei)): + """Array datatype for GLsizei types""" + + baseType = _types.GLsizei + typeConstant = _types.GL_INT + + class GLvoidpArray(ArrayDatatype, ctypes.POINTER(_types.GLvoid)): + """Array datatype for GLenum types""" + + baseType = _types.GLvoidp + typeConstant = _types.GL_VOID_P + + class GLfixedArray(ArrayDatatype, ctypes.POINTER(_types.GLfixed)): + baseType = _types.GLfixed + typeConstant = _types.GL_FIXED + +else: + # Cython-coded array handler + _log.debug("Using accelerated ArrayDatatype") + ArrayDatatype = ADT(None, None) + GLclampdArray = ADT(GL_1_1.GL_DOUBLE, _types.GLclampd) + GLclampfArray = ADT(GL_1_1.GL_FLOAT, _types.GLclampf) + GLdoubleArray = ADT(GL_1_1.GL_DOUBLE, _types.GLdouble) + GLfloat16Array = ADT(GL_1_1.GL_HALF_FLOAT, _types.GLushort) + GLfloatArray = ADT(GL_1_1.GL_FLOAT, _types.GLfloat) + GLbyteArray = ADT(GL_1_1.GL_BYTE, _types.GLbyte) + GLcharArray = GLcharARBArray = ADT(GL_1_1.GL_BYTE, _types.GLchar) + GLshortArray = ADT(GL_1_1.GL_SHORT, _types.GLshort) + GLintArray = ADT(GL_1_1.GL_INT, _types.GLint) + GLubyteArray = GLbooleanArray = ADT(GL_1_1.GL_UNSIGNED_BYTE, _types.GLubyte) + GLushortArray = ADT(GL_1_1.GL_UNSIGNED_SHORT, _types.GLushort) + GLuintArray = ADT(GL_1_1.GL_UNSIGNED_INT, _types.GLuint) + GLint64Array = ADT(None, _types.GLint64) + GLuint64Array = ADT(GL_1_1.GL_UNSIGNED_INT64, _types.GLuint64) + GLenumArray = ADT(GL_1_1.GL_UNSIGNED_INT, _types.GLenum) + GLsizeiArray = ADT(GL_1_1.GL_INT, _types.GLsizei) + GLvoidpArray = ADT(_types.GL_VOID_P, _types.GLvoidp) + GLfixedArray = ADT(_types.GL_FIXED, _types.GLfixed) + +EGLAttribArray = GLintArray + + +GL_CONSTANT_TO_ARRAY_TYPE = { + GL_1_1.GL_HALF_FLOAT: GLfloat16Array, + GL_1_1.GL_DOUBLE: GLclampdArray, + GL_1_1.GL_FLOAT: GLclampfArray, + GL_1_1.GL_FLOAT: GLfloatArray, + GL_1_1.GL_DOUBLE: GLdoubleArray, + GL_1_1.GL_BYTE: GLbyteArray, + GL_1_1.GL_SHORT: GLshortArray, + GL_1_1.GL_INT: GLintArray, + GL_1_1.GL_UNSIGNED_BYTE: GLubyteArray, + GL_1_1.GL_UNSIGNED_SHORT: GLushortArray, + GL_1_1.GL_UNSIGNED_INT: GLuintArray, + _types.GL_FIXED: GLfixedArray, + # GL_1_1.GL_UNSIGNED_INT : GLenumArray, +} diff --git a/venv/lib/python3.12/site-packages/OpenGL/arrays/arrayhelpers.py b/venv/lib/python3.12/site-packages/OpenGL/arrays/arrayhelpers.py new file mode 100644 index 00000000..662e30d3 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/arrays/arrayhelpers.py @@ -0,0 +1,182 @@ +"""Helper functions for wrapping array-using operations + +These are functions intended to be used in wrapping +GL functions that deal with OpenGL array data-types. +""" +import OpenGL +import ctypes +from OpenGL import _configflags +from OpenGL import contextdata, error, converters +from OpenGL.arrays import arraydatatype +from OpenGL._bytes import bytes,unicode +import logging +_log = logging.getLogger( 'OpenGL.arrays.arrayhelpers' ) +from OpenGL import acceleratesupport +AsArrayTypedSizeChecked = None +if acceleratesupport.ACCELERATE_AVAILABLE: + try: + from OpenGL_accelerate.arraydatatype import AsArrayTypedSizeChecked + from OpenGL_accelerate.wrapper import returnPyArgumentIndex + from OpenGL_accelerate.arraydatatype import ( + AsArrayOfType,AsArrayTyped,AsArrayTypedSize + ) + except ImportError as err: + _log.warning( + "Unable to load arrayhelpers accelerator from OpenGL_accelerate" + ) +if AsArrayTypedSizeChecked is None: + def returnPointer( result,baseOperation,pyArgs,cArgs, ): + """Return the converted object as result of function + + Note: this is a hack that always returns pyArgs[0]! + """ + return pyArgs[0] + class AsArrayOfType( converters.PyConverter ): + """Given arrayName and typeName coerce arrayName to array of type typeName + + TODO: It should be possible to drop this if ERROR_ON_COPY, + as array inputs always have to be the final objects in that + case. + """ + argNames = ( 'arrayName','typeName' ) + indexLookups = ( + ('arrayIndex', 'arrayName','pyArgIndex'), + ('typeIndex', 'typeName','pyArgIndex'), + ) + def __init__( self, arrayName='pointer', typeName='type' ): + self.arrayName = arrayName + self.typeName = typeName + def __call__( self, arg, wrappedOperation, args): + """Get the arg as an array of the appropriate type""" + type = args[ self.typeIndex ] + arrayType = arraydatatype.GL_CONSTANT_TO_ARRAY_TYPE[ type ] + return arrayType.asArray( arg ) + class AsArrayTyped( converters.PyConverter ): + """Given arrayName and arrayType, convert arrayName to array of type + + TODO: It should be possible to drop this if ERROR_ON_COPY, + as array inputs always have to be the final objects in that + case. + """ + argNames = ( 'arrayName','arrayType' ) + indexLookups = ( + ('arrayIndex', 'arrayName','pyArgIndex'), + ) + def __init__( self, arrayName='pointer', arrayType=None ): + self.arrayName = arrayName + self.arrayType = arrayType + def __call__( self, arg, wrappedOperation, args): + """Get the arg as an array of the appropriate type""" + return self.arrayType.asArray( arg ) + class AsArrayTypedSize( converters.CConverter ): + """Given arrayName and arrayType, determine size of arrayName + """ + argNames = ( 'arrayName','arrayType' ) + indexLookups = ( + ('arrayIndex', 'arrayName','pyArgIndex'), + ) + def __init__( self, arrayName='pointer', arrayType=None ): + self.arrayName = arrayName + self.arrayType = arrayType + def __call__( self, pyArgs, index, wrappedOperation ): + """Get the arg as an array of the appropriate type""" + return self.arrayType.arraySize( pyArgs[self.arrayIndex ] ) +else: + returnPointer = returnPyArgumentIndex( 0 ) + +if not _configflags.ERROR_ON_COPY: + def asArrayType( typ, size=None ): + """Create PyConverter to get first argument as array of type""" + return converters.CallFuncPyConverter( typ.asArray ) +else: + def asArrayType( typ, size=None ): + """No converter required""" + return None + +if not _configflags.ARRAY_SIZE_CHECKING: + asArrayTypeSize = asArrayType +else: + if AsArrayTypedSizeChecked: + asArrayTypeSize = AsArrayTypedSizeChecked + else: + def asArrayTypeSize( typ, size ): + """Create PyConverter function to get array as type and check size + + Produces a raw function, not a PyConverter instance + """ + asArray = typ.asArray + dataType = typ.typeConstant + arraySize = typ.arraySize + expectedBytes = ctypes.sizeof( typ.baseType ) * size + def asArraySize( incoming, function, args ): + handler = typ.getHandler( incoming ) + result = handler.asArray( incoming, dataType ) + # check that the number of bytes expected is present... + byteSize = handler.arrayByteCount( result ) + if byteSize != expectedBytes: + raise ValueError( + """Expected %r byte array, got %r byte array"""%( + expectedBytes, + byteSize, + ), + incoming, + ) + return result + return asArraySize + + +if not _configflags.ERROR_ON_COPY: + def asVoidArray( ): + """Create PyConverter returning incoming as an array of any type""" + from OpenGL.arrays import ArrayDatatype + return converters.CallFuncPyConverter( ArrayDatatype.asArray ) +else: + def asVoidArray( ): + """If there's no copying allowed, we can use default passing""" + return None + +class storePointerType( object ): + """Store named pointer value in context indexed by constant + + pointerName -- named pointer argument + constant -- constant used to index in the context storage + + Note: OpenGL.STORE_POINTERS can be set with ERROR_ON_COPY + to ignore this storage operation. + + Stores the pyArgs (i.e. result of pyConverters) for the named + pointer argument... + """ + def __init__( self, pointerName, constant ): + self.pointerName = pointerName + self.constant = constant + def finalise( self, wrapper ): + self.pointerIndex = wrapper.pyArgIndex( self.pointerName ) + def __call__( self, result, baseOperation, pyArgs, cArgs ): + contextdata.setValue( self.constant, pyArgs[self.pointerIndex] ) + + +def setInputArraySizeType( baseOperation, size, type, argName=0 ): + """Decorate function with vector-handling code for a single argument + + if OpenGL.ERROR_ON_COPY is False, then we return the + named argument, converting to the passed array type, + optionally checking that the array matches size. + + if OpenGL.ERROR_ON_COPY is True, then we will dramatically + simplify this function, only wrapping if size is True, i.e. + only wrapping if we intend to do a size check on the array. + """ + from OpenGL import wrapper + return wrapper.wrapper( baseOperation ).setInputArraySize( argName, size ) + +def arraySizeOfFirstType( typ, default ): + unitSize = typ.unitSize + def arraySizeOfFirst( pyArgs, index, baseOperation ): + """Return the array size of the first argument""" + array = pyArgs[0] + if array is None: + return default + else: + return unitSize( array ) + return arraySizeOfFirst diff --git a/venv/lib/python3.12/site-packages/OpenGL/arrays/buffers.py b/venv/lib/python3.12/site-packages/OpenGL/arrays/buffers.py new file mode 100644 index 00000000..6c47a68d --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/arrays/buffers.py @@ -0,0 +1,98 @@ +#! /usr/bin/env python +"""Test for a buffer-protocol-based access mechanism + +Will *only* work for Python 2.6+, and pretty much just works for strings +under 2.6 (in terms of the common object types). +""" +import sys,operator,logging,traceback +from OpenGL.arrays import _buffers +from OpenGL.raw.GL import _types +#from OpenGL.raw.GL.VERSION import GL_1_1 +from OpenGL.arrays import formathandler +from OpenGL import _configflags +from OpenGL import acceleratesupport +_log = logging.getLogger( __name__ ) +try: + reduce +except NameError as err: + from functools import reduce + +MemoryviewHandler = BufferHandler = None +if sys.version_info[:2] > (2,6): + # Only Python 2.7+ has memoryview support, and the accelerate module + # requires memoryviews to be able to pass around the buffer structures + if acceleratesupport.ACCELERATE_AVAILABLE: + try: + from OpenGL_accelerate.buffers_formathandler import MemoryviewHandler + except ImportError as err: + traceback.print_exc() + _log.warning( + "Unable to load buffers_formathandler accelerator from OpenGL_accelerate" + ) + else: + BufferHandler = MemoryviewHandler +if not BufferHandler: + class BufferHandler( formathandler.FormatHandler ): + """Buffer-protocol data-type handler for OpenGL""" + isOutput=False + ERROR_ON_COPY = _configflags.ERROR_ON_COPY + if sys.version_info[0] >= 3: + @classmethod + def from_param( cls, value, typeCode=None ): + if not isinstance( value, _buffers.Py_buffer ): + value = cls.asArray( value ) + #raise TypeError( """Can't convert value to py-buffer in from_param""" ) + # TODO: only do this IFF value.internal is None + return _types.GLvoidp( value.buf ) +# return value + else: + @classmethod + def from_param( cls, value, typeCode=None ): + if not isinstance( value, _buffers.Py_buffer ): + value = cls.asArray( value ) + #raise TypeError( """Can't convert value to py-buffer in from_param""" ) + return value.buf + def dataPointer( value ): + if not isinstance( value, _buffers.Py_buffer ): + value = _buffers.Py_buffer.from_object( value ) + return value.buf + dataPointer = staticmethod( dataPointer ) + @classmethod + def zeros( cls, dims, typeCode=None ): + """Currently don't allow strings as output types!""" + raise NotImplementedError( "Generic buffer type does not have output capability" ) + return cls.asArray( bytearray( b'\000'*reduce(operator.mul,dims)*BYTE_SIZES[typeCode] ) ) + @classmethod + def ones( cls, dims, typeCode=None ): + """Currently don't allow strings as output types!""" + raise NotImplementedError( """Have not implemented ones for buffer type""" ) + @classmethod + def arrayToGLType( cls, value ): + """Given a value, guess OpenGL type of the corresponding pointer""" + format = value.format + if format in ARRAY_TO_GL_TYPE_MAPPING: + return ARRAY_TO_GL_TYPE_MAPPING[format] + raise TypeError( 'Unknown format: %r'%(format,)) + @classmethod + def arraySize( cls, value, typeCode = None ): + """Given a data-value, calculate ravelled size for the array""" + return value.len // value.itemsize + @classmethod + def arrayByteCount( cls, value, typeCode = None ): + """Given a data-value, calculate number of bytes required to represent""" + return value.len + @classmethod + def unitSize( cls, value, default=None ): + return value.dims[-1] + @classmethod + def asArray( cls, value, typeCode=None ): + """Convert given value to an array value of given typeCode""" + buf = _buffers.Py_buffer.from_object( value ) + return buf + @classmethod + def dimensions( cls, value, typeCode=None ): + """Determine dimensions of the passed array value (if possible)""" + return value.dims + +ARRAY_TO_GL_TYPE_MAPPING = _buffers.ARRAY_TO_GL_TYPE_MAPPING +BYTE_SIZES = _buffers.BYTE_SIZES diff --git a/venv/lib/python3.12/site-packages/OpenGL/arrays/ctypesarrays.py b/venv/lib/python3.12/site-packages/OpenGL/arrays/ctypesarrays.py new file mode 100644 index 00000000..99c7cb7c --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/arrays/ctypesarrays.py @@ -0,0 +1,148 @@ +"""ctypes sized data-arrays as a data-formatmechanism + +XXX we have to use _ctypes.Array as the type descriminator, +would be nice to have it available from the public module +""" +REGISTRY_NAME = 'ctypesarrays' +import ctypes, _ctypes + +from OpenGL.raw.GL import _types +from OpenGL.arrays import _arrayconstants as GL_1_1 +from OpenGL import constant +from OpenGL.arrays import formathandler +from OpenGL._bytes import bytes,unicode +import operator + +class CtypesArrayHandler( formathandler.FormatHandler ): + """Ctypes Array-type-specific data-type handler for OpenGL""" + @classmethod + def from_param( cls, value, typeCode=None ): + return ctypes.byref( value ) + dataPointer = staticmethod( ctypes.addressof ) + HANDLED_TYPES = (_ctypes.Array, ) + isOutput = True + @classmethod + def voidDataPointer( cls, value ): + """Given value in a known data-pointer type, return void_p for pointer""" + return ctypes.byref( value ) + @classmethod + def zeros( cls, dims, typeCode ): + """Return Numpy array of zeros in given size""" + type = GL_TYPE_TO_ARRAY_MAPPING[ typeCode ] + for dim in dims: + type *= int(dim) + return type() # should expicitly set to 0s + @classmethod + def ones( cls, dims, typeCode='d' ): + """Return numpy array of ones in given size""" + raise NotImplementedError( """Haven't got a good ones implementation yet""" ) +## type = GL_TYPE_TO_ARRAY_MAPPING[ typeCode ] +## for dim in dims: +## type *= dim +## return type() # should expicitly set to 0s + @classmethod + def arrayToGLType( cls, value ): + """Given a value, guess OpenGL type of the corresponding pointer""" + result = None + typ = value._type_ + while hasattr(typ,'_type_') and typ not in ARRAY_TO_GL_TYPE_MAPPING: + typ = typ._type_ + result = ARRAY_TO_GL_TYPE_MAPPING.get( typ ) + if result is not None: + return result + raise TypeError( + """Don't know GL type for array of type %r, known types: %s\nvalue:%s"""%( + value._type_, list(ARRAY_TO_GL_TYPE_MAPPING.keys()), value, + ) + ) + @classmethod + def arraySize( cls, value, typeCode = None ): + """Given a data-value, calculate dimensions for the array""" + try: + return value.__class__.__component_count__ + except AttributeError as err: + dims = 1 + for length in cls.dims( value ): + dims *= length + value.__class__.__component_count__ = dims + return dims + @classmethod + def arrayByteCount( cls, value, typeCode = None ): + """Given a data-value, calculate number of bytes required to represent""" + return ctypes.sizeof( value ) + @classmethod + def types( cls, value ): + """Produce iterable producing all composite types""" + dimObject = value + while dimObject is not None: + yield dimObject + dimObject = getattr( dimObject, '_type_', None ) + if isinstance( dimObject, (bytes,unicode)): + dimObject = None + @classmethod + def dims( cls, value ): + """Produce iterable of all dimensions""" + try: + return value.__class__.__dimensions__ + except AttributeError as err: + dimensions = [] + for base in cls.types( value ): + length = getattr( base, '_length_', None) + if length is not None: + dimensions.append( length ) + dimensions = tuple( dimensions ) + value.__class__.__dimensions__ = dimensions + return dimensions + @classmethod + def asArray( cls, value, typeCode=None ): + """Convert given value to an array value of given typeCode""" + return value + @classmethod + def unitSize( cls, value, typeCode=None ): + """Determine unit size of an array (if possible)""" + try: + return value.__class__.__min_dimension__ + except AttributeError as err: + dim = cls.dims( value )[-1] + value.__class__.__min_dimension__ = dim + return dim + @classmethod + def dimensions( cls, value, typeCode=None ): + """Determine dimensions of the passed array value (if possible)""" + return tuple( cls.dims(value) ) + + +ARRAY_TO_GL_TYPE_MAPPING = { + _types.GLdouble: GL_1_1.GL_DOUBLE, + _types.GLfloat: GL_1_1.GL_FLOAT, + _types.GLint: GL_1_1.GL_INT, + _types.GLuint: GL_1_1.GL_UNSIGNED_INT, + _types.GLshort: GL_1_1.GL_SHORT, + _types.GLushort: GL_1_1.GL_UNSIGNED_SHORT, + + _types.GLchar: GL_1_1.GL_CHAR, + _types.GLbyte: GL_1_1.GL_BYTE, + _types.GLubyte: GL_1_1.GL_UNSIGNED_BYTE, +} +GL_TYPE_TO_ARRAY_MAPPING = { + _types.GL_VOID_P: _types.GLvoidp, + GL_1_1.GL_DOUBLE: _types.GLdouble, + GL_1_1.GL_FLOAT: _types.GLfloat, + GL_1_1.GL_INT: _types.GLint, + GL_1_1.GL_UNSIGNED_INT: _types.GLuint, + GL_1_1.GL_SHORT: _types.GLshort, + GL_1_1.GL_UNSIGNED_SHORT: _types.GLushort, + + GL_1_1.GL_CHAR: _types.GLchar, + GL_1_1.GL_BYTE: _types.GLbyte, + GL_1_1.GL_UNSIGNED_BYTE: _types.GLubyte, + 'f': _types.GLfloat, + 'd': _types.GLdouble, + 'i': _types.GLint, + 'I': _types.GLuint, + 'h': _types.GLshort, + 'H': _types.GLushort, + 'b': _types.GLbyte, + 'B': _types.GLubyte, + 's': _types.GLchar, +} diff --git a/venv/lib/python3.12/site-packages/OpenGL/arrays/ctypesparameters.py b/venv/lib/python3.12/site-packages/OpenGL/arrays/ctypesparameters.py new file mode 100644 index 00000000..cf922ab1 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/arrays/ctypesparameters.py @@ -0,0 +1,152 @@ +"""ctypes single-value "parameter" arguments (e.g. byref) +""" +REGISTRY_NAME = 'ctypeparameter' +import ctypes, _ctypes +from OpenGL.raw.GL import _types +from OpenGL.arrays import _arrayconstants as GL_1_1 +from OpenGL import constant +from OpenGL.arrays import formathandler +from OpenGL._bytes import bytes,unicode,as_8_bit +import operator + +c = ctypes.c_float(0) +ParamaterType = ctypes.byref(c).__class__ +DIRECT_RETURN_TYPES = ( + ParamaterType, + # these pointer types are implemented as _SimpleCData + # despite being pointers... + ctypes.c_void_p, + ctypes.c_char_p, + ctypes.c_wchar_p, +) +try: + del c +except NameError as err: + pass + +class CtypesParameterHandler( formathandler.FormatHandler ): + """Ctypes Paramater-type-specific data-type handler for OpenGL""" + isOutput = True + HANDLED_TYPES = (ParamaterType, _ctypes._SimpleCData) + def from_param( cls, value, typeCode=None ): + if isinstance( value, DIRECT_RETURN_TYPES ): + return value + else: + return ctypes.byref( value ) + from_param = voidDataPointer = classmethod( from_param ) + def dataPointer( cls, value ): + if isinstance( value, DIRECT_RETURN_TYPES ): + return value + else: + return ctypes.addressof( value ) + dataPointer = classmethod( dataPointer ) + def zeros( self, dims, typeCode ): + """Return Numpy array of zeros in given size""" + type = GL_TYPE_TO_ARRAY_MAPPING[ typeCode ] + for dim in dims: + type *= dim + return type() # should expicitly set to 0s + def ones( self, dims, typeCode='d' ): + """Return numpy array of ones in given size""" + raise NotImplementedError( """Haven't got a good ones implementation yet""" ) +## type = GL_TYPE_TO_ARRAY_MAPPING[ typeCode ] +## for dim in dims: +## type *= dim +## return type() # should expicitly set to 0s + def arrayToGLType( self, value ): + """Given a value, guess OpenGL type of the corresponding pointer""" + if isinstance( value, ParamaterType ): + value = value._obj + result = ARRAY_TO_GL_TYPE_MAPPING.get( value._type_ ) + if result is not None: + return result + raise TypeError( + """Don't know GL type for array of type %r, known types: %s\nvalue:%s"""%( + value._type_, list(ARRAY_TO_GL_TYPE_MAPPING.keys()), value, + ) + ) + def arraySize( self, value, typeCode = None ): + """Given a data-value, calculate dimensions for the array""" + if isinstance( value, ParamaterType ): + value = value._obj + dims = 1 + for base in self.types( value ): + length = getattr( base, '_length_', None) + if length is not None: + dims *= length + return dims + def arrayByteCount( self, value, typeCode = None ): + """Given a data-value, calculate number of bytes required to represent""" + if isinstance( value, ParamaterType ): + value = value._obj + return ctypes.sizeof( value ) + def types( self, value ): + """Produce iterable producing all composite types""" + if isinstance( value, ParamaterType ): + value = value._obj + dimObject = value + while dimObject is not None: + yield dimObject + dimObject = getattr( dimObject, '_type_', None ) + if isinstance( dimObject, (bytes,unicode)): + dimObject = None + def dims( self, value ): + """Produce iterable of all dimensions""" + if isinstance( value, ParamaterType ): + value = value._obj + for base in self.types( value ): + length = getattr( base, '_length_', None) + if length is not None: + yield length + def asArray( self, value, typeCode=None ): + """Convert given value to an array value of given typeCode""" + if isinstance( value, DIRECT_RETURN_TYPES ): + return value + if isinstance( value, ParamaterType ): + value = value._obj + return ctypes.byref( value ) + def unitSize( self, value, typeCode=None ): + """Determine unit size of an array (if possible)""" + if isinstance( value, ParamaterType ): + value = value._obj + return tuple(self.dims(value))[-1] + def dimensions( self, value, typeCode=None ): + """Determine dimensions of the passed array value (if possible)""" + if isinstance( value, ParamaterType ): + value = value._obj + return tuple( self.dims(value) ) + + +ARRAY_TO_GL_TYPE_MAPPING = { + _types.GLdouble: GL_1_1.GL_DOUBLE, + _types.GLfloat: GL_1_1.GL_FLOAT, + _types.GLint: GL_1_1.GL_INT, + _types.GLuint: GL_1_1.GL_UNSIGNED_INT, + _types.GLshort: GL_1_1.GL_SHORT, + _types.GLushort: GL_1_1.GL_UNSIGNED_SHORT, + + _types.GLchar: GL_1_1.GL_CHAR, + _types.GLbyte: GL_1_1.GL_BYTE, + _types.GLubyte: GL_1_1.GL_UNSIGNED_BYTE, +} +GL_TYPE_TO_ARRAY_MAPPING = { + GL_1_1.GL_DOUBLE: _types.GLdouble, + GL_1_1.GL_FLOAT: _types.GLfloat, + GL_1_1.GL_INT: _types.GLint, + GL_1_1.GL_UNSIGNED_INT: _types.GLuint, + GL_1_1.GL_SHORT: _types.GLshort, + GL_1_1.GL_UNSIGNED_SHORT: _types.GLushort, + + GL_1_1.GL_CHAR: _types.GLchar, + GL_1_1.GL_BYTE: _types.GLbyte, + GL_1_1.GL_UNSIGNED_BYTE: _types.GLubyte, + 'f': _types.GLfloat, + 'd': _types.GLdouble, + 'i': _types.GLint, + 'I': _types.GLuint, + 'h': _types.GLshort, + 'H': _types.GLushort, + 'b': _types.GLbyte, + 'B': _types.GLubyte, + 's': _types.GLchar, +} diff --git a/venv/lib/python3.12/site-packages/OpenGL/arrays/ctypespointers.py b/venv/lib/python3.12/site-packages/OpenGL/arrays/ctypespointers.py new file mode 100644 index 00000000..9facab60 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/arrays/ctypespointers.py @@ -0,0 +1,91 @@ +"""ctypes data-pointers as a data-format mechanism +""" +REGISTRY_NAME = 'ctypespointers' +import ctypes, _ctypes +from OpenGL.raw.GL import _types +from OpenGL.arrays import _arrayconstants as GL_1_1 +from OpenGL import constant +from OpenGL.arrays import formathandler +import operator + +class CtypesPointerHandler( formathandler.FormatHandler ): + """Ctypes Pointer-type-specific data-type handler for OpenGL + + Because pointers do not have size information we can't use + them for output of data, but they can be used for certain + types of input... + """ + @classmethod + def from_param( cls, value, typeCode=None ): + return value + @classmethod + def dataPointer( cls, value ): + return value.value + HANDLED_TYPES = (ctypes._Pointer, ) + isOutput=False + def voidDataPointer( cls, value ): + """Given value in a known data-pointer type, return void_p for pointer""" + return ctypes.cast( value, ctypes.c_void_p ) + def zeros( self, dims, typeCode ): + """Return Numpy array of zeros in given size""" + raise NotImplementedError( """Sized output doesn't yet work...""" ) + def ones( self, dims, typeCode='d' ): + """Return numpy array of ones in given size""" + raise NotImplementedError( """Haven't got a good ones implementation yet""" ) + def arrayToGLType( self, value ): + """Given a value, guess OpenGL type of the corresponding pointer""" + result = ARRAY_TO_GL_TYPE_MAPPING.get( value._type_ ) + if result is not None: + return result + raise TypeError( + """Don't know GL type for array of type %r, known types: %s\nvalue:%s"""%( + value._type_, list(ARRAY_TO_GL_TYPE_MAPPING.keys()), value, + ) + ) + def arraySize( self, value, typeCode = None ): + """Given a data-value, calculate dimensions for the array""" + raise NotImplementedError( """Haven't got an arraySize implementation""" ) + def asArray( self, value, typeCode=None ): + """Convert given value to an array value of given typeCode""" + return value + def unitSize( self, value, typeCode=None ): + """Determine unit size of an array (if possible)""" + return 1 + def dimensions( self, value, typeCode=None ): + """Determine dimensions of the passed array value (if possible)""" + raise NotImplementedError( """Haven't got a dimensions implementation""" ) + + +ARRAY_TO_GL_TYPE_MAPPING = { + _types.GLdouble: GL_1_1.GL_DOUBLE, + _types.GLfloat: GL_1_1.GL_FLOAT, + _types.GLint: GL_1_1.GL_INT, + _types.GLuint: GL_1_1.GL_UNSIGNED_INT, + _types.GLshort: GL_1_1.GL_SHORT, + _types.GLushort: GL_1_1.GL_UNSIGNED_SHORT, + + _types.GLchar: GL_1_1.GL_CHAR, + _types.GLbyte: GL_1_1.GL_BYTE, + _types.GLubyte: GL_1_1.GL_UNSIGNED_BYTE, +} +GL_TYPE_TO_ARRAY_MAPPING = { + GL_1_1.GL_DOUBLE: _types.GLdouble, + GL_1_1.GL_FLOAT: _types.GLfloat, + GL_1_1.GL_INT: _types.GLint, + GL_1_1.GL_UNSIGNED_INT: _types.GLuint, + GL_1_1.GL_SHORT: _types.GLshort, + GL_1_1.GL_UNSIGNED_SHORT: _types.GLushort, + + GL_1_1.GL_CHAR: _types.GLchar, + GL_1_1.GL_BYTE: _types.GLbyte, + GL_1_1.GL_UNSIGNED_BYTE: _types.GLubyte, + 'f': _types.GLfloat, + 'd': _types.GLdouble, + 'i': _types.GLint, + 'I': _types.GLuint, + 'h': _types.GLshort, + 'H': _types.GLushort, + 'b': _types.GLbyte, + 'B': _types.GLubyte, + 's': _types.GLchar, +} diff --git a/venv/lib/python3.12/site-packages/OpenGL/arrays/formathandler.py b/venv/lib/python3.12/site-packages/OpenGL/arrays/formathandler.py new file mode 100644 index 00000000..11b72d93 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/arrays/formathandler.py @@ -0,0 +1,93 @@ +"""Base class for the various Python data-format storage type APIs + +Data-type handlers are specified using OpenGL.plugins module +""" +import ctypes +from OpenGL import plugins + +class FormatHandler( object ): + """Abstract class describing the handler interface + + Each data-type handler is responsible for providing a number of methods + which allow it to manipulate (and create) instances of the data-type + it represents. + """ + LAZY_TYPE_REGISTRY = {} # more registrations + HANDLER_REGISTRY = {} + baseType = None + typeConstant = None + HANDLED_TYPES = () + preferredOutput = None + isOutput = False + GENERIC_OUTPUT_PREFERENCES = ['numpy','ctypesarrays'] + ALL_OUTPUT_HANDLERS = [] + def loadAll( cls ): + """Load all OpenGL.plugins-registered FormatHandler classes + """ + for entrypoint in plugins.FormatHandler.all(): + cls.loadPlugin( entrypoint ) + @classmethod + def loadPlugin( cls, entrypoint ): + """Load a single entry-point via plugins module""" + if not entrypoint.loaded: + from OpenGL.arrays.arraydatatype import ArrayDatatype + try: + plugin_class = entrypoint.load() + except ImportError as err: + from OpenGL import logs + from OpenGL._configflags import WARN_ON_FORMAT_UNAVAILABLE + _log = logs.getLog( 'OpenGL.formathandler' ) + if WARN_ON_FORMAT_UNAVAILABLE: + logFunc = _log.warn + else: + logFunc = _log.info + logFunc( + 'Unable to load registered array format handler %s:\n%s', + entrypoint.name, _log.getException( err ) + ) + else: + handler = plugin_class() + #handler.register( handler.HANDLED_TYPES ) + ArrayDatatype.getRegistry()[ entrypoint.name ] = handler + return handler + entrypoint.loaded = True + @classmethod + def typeLookup( cls, type ): + """Lookup handler by data-type""" + registry = ArrayDatatype.getRegistry() + try: + return registry[ type ] + except KeyError as err: + key = '%s.%s'%(type.__module__,type.__name__) + plugin = cls.LAZY_TYPE_REGISTRY.get( key ) + if plugin: + cls.loadPlugin( plugin ) + return registry[ type ] + raise KeyError( """Unable to find data-format handler for %s"""%( type,)) + loadAll = classmethod( loadAll ) + + def register( self, types=None ): + """Register this class as handler for given set of types""" + from OpenGL.arrays.arraydatatype import ArrayDatatype + ArrayDatatype.getRegistry().register( self, types ) + def registerReturn( self ): + """Register this handler as the default return-type handler""" + from OpenGL.arrays.arraydatatype import ArrayDatatype + ArrayDatatype.getRegistry().registerReturn( self ) + + def from_param( self, value, typeCode=None ): + """Convert to a ctypes pointer value""" + def dataPointer( self, value ): + """return long for pointer value""" + def asArray( self, value, typeCode=None ): + """Given a value, convert to array representation""" + def arrayToGLType( self, value ): + """Given a value, guess OpenGL type of the corresponding pointer""" + def arraySize( self, value, typeCode = None ): + """Given a data-value, calculate dimensions for the array""" + def unitSize( self, value, typeCode=None ): + """Determine unit size of an array (if possible)""" + if self.baseType is not None: + return + def dimensions( self, value, typeCode=None ): + """Determine dimensions of the passed array value (if possible)""" diff --git a/venv/lib/python3.12/site-packages/OpenGL/arrays/lists.py b/venv/lib/python3.12/site-packages/OpenGL/arrays/lists.py new file mode 100644 index 00000000..b704200d --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/arrays/lists.py @@ -0,0 +1,206 @@ +"""Lists/tuples as data-format for storage + +Note: + This implementation is *far* less efficient than using Numpy + to support lists/tuples, as the code here is all available in + C-level code there. This implementation is required to allow + for usage without numpy installed. +""" +REGISTRY_NAME = 'lists' +import ctypes, _ctypes +# Note: these are the same definitions as for GLES, so we are not cross-polluting +from OpenGL.raw.GL import _types +from OpenGL.arrays import _arrayconstants as GL_1_1 +from OpenGL import constant, error +from OpenGL._configflags import ERROR_ON_COPY +from OpenGL.arrays import formathandler +from OpenGL._bytes import bytes,unicode,as_8_bit +HANDLED_TYPES = (list,tuple) +import operator + +def err_on_copy( func ): + """Decorator which raises informative error if we try to copy while ERROR_ON_COPY""" + if not ERROR_ON_COPY: + return func + else: + def raiseErrorOnCopy( self, value, *args, **named ): + raise error.CopyError( + """%s passed, cannot copy with ERROR_ON_COPY set, please use an array type which has native data-pointer support (e.g. numpy or ctypes arrays)"""%( value.__class__.__name__, ) + ) + raiseErrorOnCopy.__name__ = getattr(func,'__name__','raiseErrorOnCopy') + return raiseErrorOnCopy + +class ListHandler( formathandler.FormatHandler ): + """Storage of array data in Python lists/arrays + + This mechanism, unlike multi-dimensional arrays, is not necessarily + uniform in type or dimension, so we have to do a lot of extra checks + to make sure that we get a correctly-structured array. That, as + well as the need to copy the arrays in Python code, makes this a far + less efficient implementation than the numpy implementation, which + does all the same things, but does them all in C code. + + Note: as an *output* format, this format handler produces ctypes + arrays, not Python lists, this is done for convenience in coding + the implementation, mostly. + """ + @err_on_copy + def from_param( self, instance, typeCode=None ): + try: + return ctypes.byref( instance ) + except (TypeError,AttributeError) as err: + array = self.asArray( instance, typeCode ) + pp = ctypes.c_void_p( ctypes.addressof( array ) ) + pp._temporary_array_ = (array,) + return pp + dataPointer = staticmethod( ctypes.addressof ) + HANDLED_TYPES = HANDLED_TYPES + isOutput = True + @err_on_copy + @classmethod + def voidDataPointer( cls, value ): + """Given value in a known data-pointer type, return void_p for pointer""" + return ctypes.byref( value ) + @classmethod + def zeros( cls, dims, typeCode ): + """Return array of zeros in given size""" + type = GL_TYPE_TO_ARRAY_MAPPING[ typeCode ] + for dim in dims: + type *= dim + return type() # should expicitly set to 0s + @classmethod + def dimsOf( cls, x ): + """Calculate total dimension-set of the elements in x + + This is *extremely* messy, as it has to track nested arrays + where the arrays could be different sizes on all sorts of + levels... + """ + try: + dimensions = [ len(x) ] + except (TypeError,AttributeError,ValueError) as err: + return [] + else: + childDimension = None + for child in x: + newDimension = cls.dimsOf( child ) + if childDimension is not None: + if newDimension != childDimension: + raise ValueError( + """Non-uniform array encountered: %s versus %s"""%( + newDimension, childDimension, + ), x + ) + + @classmethod + def arrayToGLType( cls, value ): + """Given a value, guess OpenGL type of the corresponding pointer""" + + result = ARRAY_TO_GL_TYPE_MAPPING.get( value._type_ ) + if result is not None: + return result + raise TypeError( + """Don't know GL type for array of type %r, known types: %s\nvalue:%s"""%( + value._type_, list(ARRAY_TO_GL_TYPE_MAPPING.keys()), value, + ) + ) + @classmethod + def arraySize( cls, value, typeCode = None ): + """Given a data-value, calculate dimensions for the array""" + dims = 1 + for base in cls.types( value ): + length = getattr( base, '_length_', None) + if length is not None: + dims *= length + return dims + @classmethod + def types( cls, value ): + """Produce iterable producing all composite types""" + dimObject = value + while dimObject is not None: + yield dimObject + dimObject = getattr( dimObject, '_type_', None ) + if isinstance( dimObject, (bytes,unicode)): + dimObject = None + @classmethod + def dims( cls, value ): + """Produce iterable of all dimensions""" + for base in cls.types( value ): + length = getattr( base, '_length_', None) + if length is not None: + yield length + @err_on_copy + @classmethod + def asArray( cls, value, typeCode=None ): + """Convert given value to a ctypes array value of given typeCode + + This does a *lot* of work just to get the data into the correct + format. It's not going to be anywhere near as fast as a numpy + or similar approach! + """ + if typeCode is None: + raise NotImplementedError( """Haven't implemented type-inference for lists yet""" ) + arrayType = GL_TYPE_TO_ARRAY_MAPPING[ typeCode ] + if isinstance( value, (list,tuple)): + subItems = [ + cls.asArray( item, typeCode ) + for item in value + ] + if subItems: + for dim in cls.dimensions( subItems[0] )[::-1]: + arrayType *= dim + arrayType *= len( subItems ) + result = arrayType() + result[:] = subItems + return result + else: + return arrayType( value ) + @err_on_copy + @classmethod + def unitSize( cls, value, typeCode=None ): + """Determine unit size of an array (if possible)""" + return tuple(cls.dims(value))[-1] + @err_on_copy + @classmethod + def dimensions( cls, value, typeCode=None ): + """Determine dimensions of the passed array value (if possible)""" + return tuple( cls.dims(value) ) + @classmethod + def arrayByteCount( cls, value, typeCode = None ): + """Given a data-value, calculate number of bytes required to represent""" + return ctypes.sizeof( value ) + + +ARRAY_TO_GL_TYPE_MAPPING = { + _types.GLdouble: GL_1_1.GL_DOUBLE, + _types.GLfloat: GL_1_1.GL_FLOAT, + _types.GLint: GL_1_1.GL_INT, + _types.GLuint: GL_1_1.GL_UNSIGNED_INT, + _types.GLshort: GL_1_1.GL_SHORT, + _types.GLushort: GL_1_1.GL_UNSIGNED_SHORT, + + _types.GLchar: GL_1_1.GL_CHAR, + _types.GLbyte: GL_1_1.GL_BYTE, + _types.GLubyte: GL_1_1.GL_UNSIGNED_BYTE, +} +GL_TYPE_TO_ARRAY_MAPPING = { + GL_1_1.GL_DOUBLE: _types.GLdouble, + GL_1_1.GL_FLOAT: _types.GLfloat, + GL_1_1.GL_INT: _types.GLint, + GL_1_1.GL_UNSIGNED_INT: _types.GLuint, + GL_1_1.GL_SHORT: _types.GLshort, + GL_1_1.GL_UNSIGNED_SHORT: _types.GLushort, + + GL_1_1.GL_CHAR: _types.GLchar, + GL_1_1.GL_BYTE: _types.GLbyte, + GL_1_1.GL_UNSIGNED_BYTE: _types.GLubyte, + 'f': _types.GLfloat, + 'd': _types.GLdouble, + 'i': _types.GLint, + 'I': _types.GLuint, + 'h': _types.GLshort, + 'H': _types.GLushort, + 'b': _types.GLbyte, + 'B': _types.GLubyte, + 's': _types.GLchar, +} diff --git a/venv/lib/python3.12/site-packages/OpenGL/arrays/nones.py b/venv/lib/python3.12/site-packages/OpenGL/arrays/nones.py new file mode 100644 index 00000000..5c5056ce --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/arrays/nones.py @@ -0,0 +1,53 @@ +"""Passing of None as an array data-type +""" +REGISTRY_NAME = 'nones' +import logging +_log = logging.getLogger( 'OpenGL.arrays.nones' ) + +from OpenGL import acceleratesupport +NoneHandler = None +if acceleratesupport.ACCELERATE_AVAILABLE: + try: + from OpenGL_accelerate.nones_formathandler import NoneHandler + except ImportError as err: + _log.warning( + "Unable to load nones_formathandler accelerator from OpenGL_accelerate" + ) +if NoneHandler is None: + from OpenGL.arrays import formathandler + class NoneHandler( formathandler.FormatHandler ): + """Numpy-specific data-type handler for OpenGL""" + HANDLED_TYPES = (type(None), ) + def from_param( self, value, typeCode=None ): + """Convert to a ctypes pointer value""" + return None + def dataPointer( self, value ): + """return long for pointer value""" + return None + def voidDataPointer( cls, value ): + """Given value in a known data-pointer type, return void_p for pointer""" + return None + def asArray( self, value, typeCode=None ): + """Given a value, convert to array representation""" + return None + def arrayToGLType( self, value ): + """Given a value, guess OpenGL type of the corresponding pointer""" + raise TypeError( """Can't guess type of a NULL pointer""" ) + def arraySize( self, value, typeCode = None ): + """Given a data-value, calculate dimensions for the array""" + return 0 + def arrayByteCount( self, value, typeCode = None ): + """Given a data-value, calculate number of bytes required to represent""" + return 0 + def zeros( self, shape, typeCode= None ): + """Create an array of given shape with given typeCode""" + raise TypeError( """Can't create NULL pointer filled with values""" ) + def ones( self, shape, typeCode= None ): + """Create an array of given shape with given typeCode""" + raise TypeError( """Can't create NULL pointer filled with values""" ) + def unitSize( self, value, typeCode=None ): + """Determine unit size of an array (if possible)""" + raise TypeError( """Can't determine unit size of a null pointer""" ) + def dimensions( self, value, typeCode=None ): + """Determine dimensions of the passed array value (if possible)""" + return (0,) diff --git a/venv/lib/python3.12/site-packages/OpenGL/arrays/numbers.py b/venv/lib/python3.12/site-packages/OpenGL/arrays/numbers.py new file mode 100644 index 00000000..2214b090 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/arrays/numbers.py @@ -0,0 +1,117 @@ +"""Numbers passed as array handling code for PyOpenGL +""" +REGISTRY_NAME = 'numbers' +from OpenGL.raw.GL import _types +from OpenGL.raw.GL.VERSION import GL_1_1 +from OpenGL.arrays import formathandler +import ctypes +from OpenGL._bytes import long, integer_types + +n = c = None + + +class NumberHandler(formathandler.FormatHandler): + """Allows the user to pass a bald Python float,int, etceteras as an array-of-1""" + + HANDLED_TYPES = integer_types + ( + float, + _types.GLdouble, + _types.GLfloat, + _types.GLint, + _types.GLshort, + _types.GLuint, + _types.GLulong, + _types.GLushort, + _types.GLclampf, + _types.GLclampd, + ) + + def from_param(self, value, typeCode=None): + """If it's a ctypes value, pass on, otherwise do asArray""" + try: + return ctypes.byref(value) + except TypeError as err: + err.args += ( + ' If you have ERROR_ON_COPY enabled, remember to pass in an array to array-requiring functions.', + ) + raise + + dataPointer = from_param + + def zeros(self, dims, typeCode=None): + """Currently don't allow Number as output types!""" + raise NotImplemented( + """Number data-type not allowed as an output array format""" + ) + + def ones(self, dims, typeCode=None): + """Currently don't allow Number as output types!""" + raise NotImplemented( + """Number data-type not allowed as an output array format""" + ) + + def arrayToGLType(self, value): + """Given a value, guess OpenGL type of the corresponding pointer""" + if value.__class__ in TARGET_TYPES: + return TARGET_TYPES[value.__class__] + else: + guess = DEFAULT_TYPES.get(value.__class__) + if guess is not None: + return guess[1] + raise TypeError( + """Can't guess array data-type for %r types""" % (type(value)) + ) + + def arraySize(self, value, typeCode=None): + """Given a data-value, calculate ravelled size for the array""" + return 1 + + def asArray(self, value, typeCode=None): + """Convert given value to an array value of given typeCode""" + + if value.__class__ in TARGET_TYPES: + return value + targetType = CONSTANT_TO_TYPE.get(typeCode) + if targetType is not None: + return targetType(value) + raise TypeError( + """Don't know how to convert %r to an array type""" % (typeCode,) + ) + + def unitSize(self, value, typeCode=None): + """Determine unit size of an array (if possible)""" + return 1 # there's only 1 possible value in the set... + + def registerEquivalent(self, typ, base): + """Register a sub-class for handling as the base-type""" + global TARGET_TYPE_TUPLE + for source in (DEFAULT_TYPES, TARGET_TYPES, BYTE_SIZES): + if base in source: + source[typ] = source[base] + if base in TARGET_TYPES: + TARGET_TYPE_TUPLE = TARGET_TYPE_TUPLE + (base,) + + +DEFAULT_TYPES = { + float: (_types.GLdouble, GL_1_1.GL_DOUBLE), + int: (_types.GLint, GL_1_1.GL_INT), + long: (_types.GLint, GL_1_1.GL_INT), +} +TARGET_TYPES = dict( + [(getattr(_types, n), c) for (n, c) in _types.ARRAY_TYPE_TO_CONSTANT] +) +TARGET_TYPE_TUPLE = tuple( + [getattr(_types, n) for (n, c) in _types.ARRAY_TYPE_TO_CONSTANT] +) +CONSTANT_TO_TYPE = dict( + [(c, getattr(_types, n)) for (n, c) in _types.ARRAY_TYPE_TO_CONSTANT] +) + +BYTE_SIZES = dict( + [(c, ctypes.sizeof(getattr(_types, n))) for (n, c) in _types.ARRAY_TYPE_TO_CONSTANT] +) + +try: + del n, c +except NameError as err: + pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/arrays/numpybuffers.py b/venv/lib/python3.12/site-packages/OpenGL/arrays/numpybuffers.py new file mode 100644 index 00000000..9ab207ae --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/arrays/numpybuffers.py @@ -0,0 +1,120 @@ +"""Buffer based Numpy plugin (not used) + +This API is no more useful than the direct Numpy version, as Numpy already +gives us the details we need *when using the accelerator module* at a low +level, with very fast access. When using the non-accelerated version the +ctypes version *might* show some performance benefits, but it's not going +to be fast no matter what we do without C-level code. +""" +REGISTRY_NAME = 'numpybuffers' +import operator +try: + import numpy +except ImportError as err: + raise ImportError( """No numpy module present: %s"""%(err)) +from OpenGL.arrays import buffers +from OpenGL.raw.GL import _types +from OpenGL.raw.GL.VERSION import GL_1_1 +from OpenGL import constant, error +class NumpyHandler( buffers.BufferHandler ): + @classmethod + def zeros( cls, dims, typeCode ): + """Return Numpy array of zeros in given size""" + return numpy.zeros( dims, GL_TYPE_TO_ARRAY_MAPPING[typeCode]) + + @classmethod + def asArray( cls, value, typeCode=None ): + """Convert given value to an array value of given typeCode""" + return super(NumpyHandler,cls).asArray( cls.contiguous(value,typeCode), typeCode ) + @classmethod + def contiguous( cls, source, typeCode=None ): + """Get contiguous array from source + + source -- numpy Python array (or compatible object) + for use as the data source. If this is not a contiguous + array of the given typeCode, a copy will be made, + otherwise will just be returned unchanged. + typeCode -- optional 1-character typeCode specifier for + the numpy.array function. + + All gl*Pointer calls should use contiguous arrays, as non- + contiguous arrays will be re-copied on every rendering pass. + Although this doesn't raise an error, it does tend to slow + down rendering. + """ + typeCode = GL_TYPE_TO_ARRAY_MAPPING[ typeCode ] + try: + contiguous = source.flags.contiguous + except AttributeError as err: + if typeCode: + return numpy.ascontiguousarray( source, typeCode ) + else: + return numpy.ascontiguousarray( source ) + else: + if contiguous and (typeCode is None or typeCode==source.dtype.char): + return source + elif (contiguous and cls.ERROR_ON_COPY): + from OpenGL import error + raise error.CopyError( + """Array of type %r passed, required array of type %r""", + source.dtype.char, typeCode, + ) + else: + # We have to do astype to avoid errors about unsafe conversions + # XXX Confirm that this will *always* create a new contiguous array + # XXX Guard against wacky conversion types like uint to float, where + # we really don't want to have the C-level conversion occur. + # XXX ascontiguousarray is apparently now available in numpy! + if cls.ERROR_ON_COPY: + from OpenGL import error + raise error.CopyError( + """Non-contiguous array passed""", + source, + ) + if typeCode is None: + typeCode = source.dtype.char + return numpy.ascontiguousarray( source, typeCode ) +try: + numpy.array( [1], 's' ) + SHORT_TYPE = 's' +except TypeError as err: + SHORT_TYPE = 'h' + USHORT_TYPE = 'H' + +def lookupDtype( char ): + return numpy.zeros( (1,), dtype=char ).dtype + +ARRAY_TO_GL_TYPE_MAPPING = { + lookupDtype('d'): GL_1_1.GL_DOUBLE, + lookupDtype('f'): GL_1_1.GL_FLOAT, + lookupDtype('i'): GL_1_1.GL_INT, + lookupDtype(SHORT_TYPE): GL_1_1.GL_SHORT, + lookupDtype(USHORT_TYPE): GL_1_1.GL_UNSIGNED_SHORT, + lookupDtype('B'): GL_1_1.GL_UNSIGNED_BYTE, + lookupDtype('c'): GL_1_1.GL_UNSIGNED_BYTE, + lookupDtype('b'): GL_1_1.GL_BYTE, + lookupDtype('I'): GL_1_1.GL_UNSIGNED_INT, + #lookupDtype('P'), GL_1_1.GL_VOID_P, # normally duplicates another type (e.g. 'I') + None: None, +} +GL_TYPE_TO_ARRAY_MAPPING = { + GL_1_1.GL_DOUBLE: lookupDtype('d'), + GL_1_1.GL_FLOAT:lookupDtype('f'), + GL_1_1.GL_INT: lookupDtype('i'), + GL_1_1.GL_BYTE: lookupDtype('b'), + GL_1_1.GL_SHORT: lookupDtype(SHORT_TYPE), + GL_1_1.GL_UNSIGNED_INT: lookupDtype('I'), + GL_1_1.GL_UNSIGNED_BYTE: lookupDtype('B'), + GL_1_1.GL_UNSIGNED_SHORT: lookupDtype(USHORT_TYPE), + _types.GL_VOID_P: lookupDtype('P'), + None: None, + 'f': lookupDtype('f'), + 'd': lookupDtype('d'), + 'i': lookupDtype('i'), + 'I': lookupDtype('I'), + 'h': lookupDtype('h'), + 'H': lookupDtype('H'), + 'b': lookupDtype('b'), + 'B': lookupDtype('B'), + 's': lookupDtype('B'), +} diff --git a/venv/lib/python3.12/site-packages/OpenGL/arrays/numpymodule.py b/venv/lib/python3.12/site-packages/OpenGL/arrays/numpymodule.py new file mode 100644 index 00000000..1f604fae --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/arrays/numpymodule.py @@ -0,0 +1,272 @@ +"""Numpy (new version) module implementation of the OpenGL-ctypes array interfaces + +XXX Need to register handlers for all of the scalar types that numpy returns, +would like to have all return values be int/float if they are of compatible +type as well. +""" +REGISTRY_NAME = 'numpy' +import logging +from OpenGL import _configflags +_log = logging.getLogger( __name__ ) +try: + import numpy +except ImportError as err: + raise ImportError( """No numpy module present: %s"""%(err)) +import OpenGL +assert OpenGL +import ctypes +from OpenGL._bytes import long +from OpenGL.raw.GL import _types +from OpenGL.raw.GL.VERSION import GL_1_1 +from OpenGL import error +from OpenGL.arrays import formathandler +c_void_p = ctypes.c_void_p +from OpenGL import acceleratesupport +NumpyHandler = None +if acceleratesupport.ACCELERATE_AVAILABLE: + try: + from OpenGL_accelerate.numpy_formathandler import NumpyHandler + except ImportError as err: + _log.warning( + "Unable to load numpy_formathandler accelerator from OpenGL_accelerate" + ) +if NumpyHandler is None: + # numpy's array interface has changed over time :( + testArray = numpy.array( [1,2,3,4],'i' ) + # Numpy's "ctypes" interface actually creates a new ctypes object + # in python for every access of the .ctypes attribute... which can take + # ridiculously large periods when you multiply it by millions of iterations + if hasattr(testArray,'__array_interface__'): + def dataPointer( cls, instance ): + """Convert given instance to a data-pointer value (integer)""" + try: + return long(instance.__array_interface__['data'][0]) + except AttributeError: + instance = cls.asArray( instance ) + try: + return long(instance.__array_interface__['data'][0]) + except AttributeError: + return long(instance.__array_data__[0],0) + else: + def dataPointer( cls, instance ): + """Convert given instance to a data-pointer value (integer)""" + try: + return long(instance.__array_data__[0],0) + except AttributeError: + instance = cls.asArray( instance ) + try: + return long(instance.__array_interface__['data'][0]) + except AttributeError: + return long(instance.__array_data__[0],0) + try: + del testArray + except NameError as err: + pass + dataPointer = classmethod( dataPointer ) + + + class NumpyHandler( formathandler.FormatHandler ): + """Numpy-specific data-type handler for OpenGL + + Attributes: + + ERROR_ON_COPY -- if True, will raise errors + if we have to copy an array object in order to produce + a contiguous array of the correct type. + """ + HANDLED_TYPES = ( + numpy.ndarray, + numpy.bool_, + numpy.intc, + numpy.uintc, + numpy.int8, + numpy.uint8, + numpy.int16, + numpy.uint16, + numpy.int32, + numpy.uint32, + numpy.int64, + numpy.uint64, + numpy.int64, + numpy.uint64, + numpy.float16, + numpy.float32, + numpy.float64, + numpy.complex64, + numpy.complex128, + numpy.bytes_, + numpy.str_, + numpy.void, + numpy.datetime64, + numpy.timedelta64, + )# list, tuple ) + if hasattr(numpy,'float128'): + HANDLED_TYPES += (numpy.float128,) + if hasattr(numpy,'complex256'): + HANDLED_TYPES += (numpy.complex256,) + dataPointer = dataPointer + isOutput = True + ERROR_ON_COPY = _configflags.ERROR_ON_COPY + @classmethod + def zeros( cls, dims, typeCode ): + """Return Numpy array of zeros in given size""" + dims = numpy.array( dims, dtype='i') + return numpy.zeros( dims, GL_TYPE_TO_ARRAY_MAPPING[typeCode]) + @classmethod + def arrayToGLType( cls, value ): + """Given a value, guess OpenGL type of the corresponding pointer""" + typeCode = value.dtype + constant = ARRAY_TO_GL_TYPE_MAPPING.get( typeCode ) + if constant is None: + raise TypeError( + """Don't know GL type for array of type %r, known types: %s\nvalue:%s"""%( + typeCode, list(ARRAY_TO_GL_TYPE_MAPPING.keys()), value, + ) + ) + return constant + + @classmethod + def arraySize( cls, value, typeCode = None ): + """Given a data-value, calculate dimensions for the array""" + return value.size + @classmethod + def arrayByteCount( cls, value, typeCode = None ): + """Given a data-value, calculate number of bytes required to represent""" + try: + return value.nbytes + except AttributeError: + if cls.ERROR_ON_COPY: + raise error.CopyError( + """Non-numpy array passed to numpy arrayByteCount: %s""", + type(value), + ) + value = cls.asArray( value, typeCode ) + return value.nbytes + @classmethod + def asArray( cls, value, typeCode=None ): + """Convert given value to an array value of given typeCode""" + if value is None: + return value + else: + return cls.contiguous( value, typeCode ) + + @classmethod + def contiguous( cls, source, typeCode=None ): + """Get contiguous array from source + + source -- numpy Python array (or compatible object) + for use as the data source. If this is not a contiguous + array of the given typeCode, a copy will be made, + otherwise will just be returned unchanged. + typeCode -- optional 1-character typeCode specifier for + the numpy.array function. + + All gl*Pointer calls should use contiguous arrays, as non- + contiguous arrays will be re-copied on every rendering pass. + Although this doesn't raise an error, it does tend to slow + down rendering. + """ + typeCode = GL_TYPE_TO_ARRAY_MAPPING[ typeCode ] + try: + contiguous = source.flags.contiguous + except AttributeError: + if typeCode: + return numpy.ascontiguousarray( source, typeCode ) + else: + return numpy.ascontiguousarray( source ) + else: + if contiguous and (typeCode is None or typeCode==source.dtype.char): + return source + elif (contiguous and cls.ERROR_ON_COPY): + from OpenGL import error + raise error.CopyError( + """Array of type %r passed, required array of type %r""", + source.dtype.char, typeCode, + ) + else: + # We have to do astype to avoid errors about unsafe conversions + # XXX Confirm that this will *always* create a new contiguous array + # XXX Guard against wacky conversion types like uint to float, where + # we really don't want to have the C-level conversion occur. + # XXX ascontiguousarray is apparently now available in numpy! + if cls.ERROR_ON_COPY: + from OpenGL import error + raise error.CopyError( + """Non-contiguous array passed""", + source, + ) + if typeCode is None: + typeCode = source.dtype.char + return numpy.ascontiguousarray( source, typeCode ) + @classmethod + def unitSize( cls, value, typeCode=None ): + """Determine unit size of an array (if possible)""" + return value.shape[-1] + @classmethod + def dimensions( cls, value, typeCode=None ): + """Determine dimensions of the passed array value (if possible)""" + return value.shape + @classmethod + def from_param( cls, instance, typeCode=None ): + try: + pointer = cls.dataPointer( instance ) + except TypeError: + array = cls.asArray( instance, typeCode ) + pp = cls.dataPointer( array ) + pp._temporary_array_ = (array,) + return pp + else: + if typeCode and instance.dtype != GL_TYPE_TO_ARRAY_MAPPING[ typeCode ]: + raise error.CopyError( + """Array of type %r passed, required array of type %r""", + instance.dtype.char, typeCode, + ) + return c_void_p( pointer ) + +try: + numpy.array( [1], 's' ) + SHORT_TYPE = 's' +except TypeError as err: + SHORT_TYPE = 'h' + USHORT_TYPE = 'H' + +def lookupDtype( char ): + return numpy.zeros( (1,), dtype=char ).dtype + +ARRAY_TO_GL_TYPE_MAPPING = { + lookupDtype('d'): GL_1_1.GL_DOUBLE, + lookupDtype('f'): GL_1_1.GL_FLOAT, + lookupDtype('e'): _types.GL_HALF_FLOAT, + lookupDtype('i'): GL_1_1.GL_INT, + lookupDtype(SHORT_TYPE): GL_1_1.GL_SHORT, + lookupDtype(USHORT_TYPE): GL_1_1.GL_UNSIGNED_SHORT, + lookupDtype('B'): GL_1_1.GL_UNSIGNED_BYTE, + lookupDtype('c'): GL_1_1.GL_UNSIGNED_BYTE, + lookupDtype('b'): GL_1_1.GL_BYTE, + lookupDtype('I'): GL_1_1.GL_UNSIGNED_INT, + #lookupDtype('P'), _types.GL_VOID_P, # normally duplicates another type (e.g. 'I') + None: None, +} +GL_TYPE_TO_ARRAY_MAPPING = { + GL_1_1.GL_DOUBLE: lookupDtype('d'), + GL_1_1.GL_FLOAT:lookupDtype('f'), + _types.GL_HALF_FLOAT: lookupDtype('e'), + GL_1_1.GL_INT: lookupDtype('i'), + GL_1_1.GL_BYTE: lookupDtype('b'), + GL_1_1.GL_SHORT: lookupDtype(SHORT_TYPE), + GL_1_1.GL_UNSIGNED_INT: lookupDtype('I'), + GL_1_1.GL_UNSIGNED_BYTE: lookupDtype('B'), + GL_1_1.GL_UNSIGNED_SHORT: lookupDtype(USHORT_TYPE), + _types.GL_VOID_P: lookupDtype('P'), + None: None, + 'e': lookupDtype('e'), + 'f': lookupDtype('f'), + 'd': lookupDtype('d'), + 'i': lookupDtype('i'), + 'I': lookupDtype('I'), + 'h': lookupDtype('h'), + 'H': lookupDtype('H'), + 'b': lookupDtype('b'), + 'B': lookupDtype('B'), + 's': lookupDtype('B'), +} diff --git a/venv/lib/python3.12/site-packages/OpenGL/arrays/strings.py b/venv/lib/python3.12/site-packages/OpenGL/arrays/strings.py new file mode 100644 index 00000000..40aa7d97 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/arrays/strings.py @@ -0,0 +1,83 @@ +"""String-array-handling code for PyOpenGL +""" +from OpenGL.raw.GL import _types +from OpenGL.raw.GL.VERSION import GL_1_1 +from OpenGL.arrays import formathandler +import ctypes +from OpenGL import _bytes, error +from OpenGL._configflags import ERROR_ON_COPY + +def dataPointer( value, typeCode=None ): + return ctypes.cast(ctypes.c_char_p(value), + ctypes.c_void_p).value + +class StringHandler( formathandler.FormatHandler ): + """String-specific data-type handler for OpenGL""" + HANDLED_TYPES = (_bytes.bytes, ) + @classmethod + def from_param( cls, value, typeCode=None ): + return ctypes.c_void_p( dataPointer( value ) ) + dataPointer = staticmethod( dataPointer ) + def zeros( self, dims, typeCode=None ): + """Currently don't allow strings as output types!""" + raise NotImplemented( """Don't currently support strings as output arrays""" ) + def ones( self, dims, typeCode=None ): + """Currently don't allow strings as output types!""" + raise NotImplemented( """Don't currently support strings as output arrays""" ) + def arrayToGLType( self, value ): + """Given a value, guess OpenGL type of the corresponding pointer""" + raise NotImplemented( """Can't guess data-type from a string-type argument""" ) + def arraySize( self, value, typeCode = None ): + """Given a data-value, calculate ravelled size for the array""" + # need to get bits-per-element... + byteCount = BYTE_SIZES[ typeCode ] + return len(value)//byteCount + def arrayByteCount( self, value, typeCode = None ): + """Given a data-value, calculate number of bytes required to represent""" + return len(value) + def asArray( self, value, typeCode=None ): + """Convert given value to an array value of given typeCode""" + if isinstance( value, bytes ): + return value + elif hasattr( value, 'tostring' ): + return value.tostring() + elif hasattr( value, 'raw' ): + return value.raw + # could convert types to string here, but we're not registered for + # anything save string types... + raise TypeError( """String handler got non-string object: %r"""%(type(value))) + def dimensions( self, value, typeCode=None ): + """Determine dimensions of the passed array value (if possible)""" + raise TypeError( + """Cannot calculate dimensions for a String data-type""" + ) + +class UnicodeHandler( StringHandler ): + HANDLED_TYPES = (_bytes.unicode,) + @classmethod + def from_param( cls, value, typeCode=None ): + # TODO: raise CopyError if the flag is set! + converted = _bytes.as_8_bit( value ) + result = StringHandler.from_param( converted ) + if converted is not value: + if ERROR_ON_COPY: + raise error.CopyError( + """Unicode string passed, cannot copy with ERROR_ON_COPY set, please use 8-bit strings""" + ) + result._temporary_array_ = converted + return result + def asArray( self, value, typeCode=None ): + value = _bytes.as_8_bit( value ) + return StringHandler.asArray( self, value, typeCode=typeCode ) + + +BYTE_SIZES = { + GL_1_1.GL_DOUBLE: ctypes.sizeof( _types.GLdouble ), + GL_1_1.GL_FLOAT: ctypes.sizeof( _types.GLfloat ), + GL_1_1.GL_INT: ctypes.sizeof( _types.GLint ), + GL_1_1.GL_SHORT: ctypes.sizeof( _types.GLshort ), + GL_1_1.GL_UNSIGNED_BYTE: ctypes.sizeof( _types.GLubyte ), + GL_1_1.GL_UNSIGNED_SHORT: ctypes.sizeof( _types.GLshort ), + GL_1_1.GL_BYTE: ctypes.sizeof( _types.GLbyte ), + GL_1_1.GL_UNSIGNED_INT: ctypes.sizeof( _types.GLuint ), +} diff --git a/venv/lib/python3.12/site-packages/OpenGL/arrays/vbo.py b/venv/lib/python3.12/site-packages/OpenGL/arrays/vbo.py new file mode 100644 index 00000000..362c2527 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/arrays/vbo.py @@ -0,0 +1,465 @@ +"""VertexBufferObject helper class + +Basic usage: + + my_data = numpy.array( data, 'f') + my_vbo = vbo.VBO( my_data ) + ... + my_vbo.bind() + try: + ... + glVertexPointer( my_vbo, ... ) + ... + glNormalPointer( my_vbo + 12, ... ) + finally: + my_vbo.unbind() + + or + + with my_vbo: + ... + glVertexPointer( my_vbo, ... ) + ... + glNormalPointer( my_vbo + 12, ... ) + +See the OpenGLContext shader tutorials for a gentle introduction on the +usage of VBO objects: + + http://pyopengl.sourceforge.net/context/tutorials/shader_intro.xhtml + +This implementation will choose either the ARB or Core (OpenGL 1.5) +implementation of the VBO functions. +""" +from OpenGL.arrays.arraydatatype import ArrayDatatype +from OpenGL.arrays.formathandler import FormatHandler +from OpenGL.raw.GL import _types +from OpenGL import error +from OpenGL._bytes import bytes,unicode,as_8_bit +import ctypes,logging +_log = logging.getLogger( 'OpenGL.arrays.vbo' ) +from OpenGL._bytes import long, integer_types + +import weakref +__all__ = ('VBO','VBOHandler','mapVBO') + +class Implementation( object ): + """Abstraction point for the various implementations that can be used + """ + IMPLEMENTATION_CLASSES = [] + CHOSEN = None + @classmethod + def register( cls ): + cls.IMPLEMENTATION_CLASSES.append( cls ) + + @classmethod + def get_implementation( cls, *args ): + if cls.CHOSEN is None: + for possible in cls.IMPLEMENTATION_CLASSES: + implementation = possible() + if possible: + Implementation.CHOSEN = implementation + break + return cls.CHOSEN + + EXPORTED_NAMES = '''glGenBuffers + glBindBuffer + glBufferData + glBufferSubData + glDeleteBuffers + glMapBuffer + glUnmapBuffer + GL_STATIC_DRAW + GL_STATIC_READ + GL_STATIC_COPY + GL_DYNAMIC_DRAW + GL_DYNAMIC_READ + GL_DYNAMIC_COPY + GL_STREAM_DRAW + GL_STREAM_READ + GL_STREAM_COPY + GL_ARRAY_BUFFER + GL_ELEMENT_ARRAY_BUFFER + GL_UNIFORM_BUFFER + GL_TEXTURE_BUFFER + GL_TRANSFORM_FEEDBACK_BUFFER'''.split() + available = False + def _arbname( self, name ): + return ( + (name.startswith( 'gl' ) and name.endswith( 'ARB' )) or + (name.startswith( 'GL_' ) and name.endswith( 'ARB' )) + ) and (name != 'glInitVertexBufferObjectARB') + def basename( self, name ): + if name.endswith( '_ARB' ): + return name[:-4] + elif name.endswith( 'ARB' ): + return name[:-3] + else: + return name + def __nonzero__( self ): + return self.available + __bool__ = __nonzero__ + def deleter( self, buffers, key): + """Produce a deleter callback to delete the given buffer""" + # these values are stored here to avoid them being cleaned up + # to non during module deletion and causing errors to be raised + nfe = error.NullFunctionError + gluint = _types.GLuint + def doBufferDeletion( *args, **named ): + while buffers: + try: + buffer = buffers.pop() + except IndexError as err: + break + else: + try: + # Note that to avoid ERROR_ON_COPY issues + # we have to pass an array-compatible type here... + buf = gluint( buffer ) + self.glDeleteBuffers(1, buf) + except (AttributeError, nfe, TypeError) as err: + pass + try: + self._DELETERS_.pop( key ) + except KeyError as err: + pass + return doBufferDeletion + _DELETERS_ = {} + +get_implementation = Implementation.get_implementation + +from OpenGL import acceleratesupport +VBO = None +if acceleratesupport.ACCELERATE_AVAILABLE: + try: + from OpenGL_accelerate.vbo import ( + VBO,VBOOffset,VBOHandler,VBOOffsetHandler, + ) + except ImportError as err: + _log.warning( + "Unable to load VBO accelerator from OpenGL_accelerate" + ) +if VBO is None: + class VBO( object ): + """Instances can be passed into array-handling routines + + You can check for whether VBOs are supported by accessing the implementation: + + if bool(vbo.get_implementation()): + # vbo version of code + else: + # fallback version of code + """ + copied = False + _no_cache_ = True # do not cache in context data arrays + def __init__( + self, data, usage='GL_DYNAMIC_DRAW', + target='GL_ARRAY_BUFFER', size=None, + ): + """Initialize the VBO object + + data -- PyOpenGL-compatible array-data structure, numpy arrays, ctypes arrays, etc. + usage -- OpenGL usage constant describing expected data-flow patterns (this is a hint + to the GL about where/how to cache the data) + + GL_STATIC_DRAW_ARB + GL_STATIC_READ_ARB + GL_STATIC_COPY_ARB + GL_DYNAMIC_DRAW_ARB + GL_DYNAMIC_READ_ARB + GL_DYNAMIC_COPY_ARB + GL_STREAM_DRAW_ARB + GL_STREAM_READ_ARB + GL_STREAM_COPY_ARB + + DRAW constants suggest to the card that the data will be primarily used to draw + on the card. READ that the data will be read back into the GL. COPY means that + the data will be used both for DRAW and READ operations. + + STATIC suggests that the data will only be written once (or a small number of times). + DYNAMIC suggests that the data will be used a small number of times before being + discarded. + STREAM suggests that the data will be updated approximately every time that it is + used (that is, it will likely only be used once). + + target -- VBO target to which to bind (array or indices) + GL_ARRAY_BUFFER -- array-data binding + GL_ELEMENT_ARRAY_BUFFER -- index-data binding + GL_UNIFORM_BUFFER -- used to pass mid-size arrays of data packed into a buffer + GL_TEXTURE_BUFFER -- used to pass large arrays of data as a pseudo-texture + GL_TRANSFORM_FEEDBACK_BUFFER -- used to receive transformed vertices for processing + + size -- if not provided, will use arrayByteCount to determine the size of the data-array, + thus this value (number of bytes) is required when using opaque data-structures, + (such as ctypes pointers) as the array data-source. + """ + self.usage = usage + self.set_array( data, size ) + self.target = target + self.buffers = [] + self._copy_segments = [] + _I_ = None + implementation = property( get_implementation, ) + def resolve( self, value ): + """Resolve string constant to constant""" + if isinstance( value, (bytes,unicode)): + return getattr( self.implementation, self.implementation.basename( value ) ) + return value + def set_array( self, data, size=None ): + """Update our entire array with new data + + data -- PyOpenGL-compatible array-data structure, numpy arrays, ctypes arrays, etc. + size -- if not provided, will use arrayByteCount to determine the size of the data-array, + thus this value (number of bytes) is required when using opaque data-structures, + (such as ctypes pointers) as the array data-source. + """ + self.data = data + self.copied = False + if size is not None: + self.size = size + elif self.data is not None: + self.size = ArrayDatatype.arrayByteCount( self.data ) + def __setitem__( self, slice, array): + """Set slice of data on the array and vbo (if copied already) + + slice -- the Python slice object determining how the data should + be copied into the vbo/array + array -- something array-compatible that will be used as the + source of the data, note that the data-format will have to + be the same as the internal data-array to work properly, if + not, the amount of data copied will be wrong. + + This is a reasonably complex operation, it has to have all sorts + of state-aware changes to correctly map the source into the low-level + OpenGL view of the buffer (which is just bytes as far as the GL + is concerned). + """ + if slice.step and not slice.step == 1: + raise NotImplemented( """Don't know how to map stepped arrays yet""" ) + # TODO: handle e.g. mapping character data into an integer data-set + data = ArrayDatatype.asArray( array ) + data_length = ArrayDatatype.arrayByteCount( array ) + start = (slice.start or 0) + stop = (slice.stop or len(self.data)) + if start < 0: + start += len(self.data) + start = max((start,0)) + if stop < 0: + stop += len(self.data) + stop = max((stop,0)) + self.data[ slice ] = data + if self.copied and self.buffers: + if start-stop == len(self.data): + # re-copy the whole data-set + self.copied = False + elif len(data): + # now the fun part, we need to make the array match the + # structure of the array we're going to copy into and make + # the "size" parameter match the value we're going to copy in, + # note that a 2D array (rather than a 1D array) may require + # multiple mappings to copy into the memory area... + + # find the step size from the dimensions and base size... + size = ArrayDatatype.arrayByteCount( self.data[0] ) + #baseSize = ArrayDatatype.unitSize( data ) + # now create the start and distance values... + start *= size + stop *= size + # wait until the last moment (bind) to copy the data... + self._copy_segments.append( + (start,(stop-start), data) + ) + def __len__( self ): + """Delegate length/truth checks to our data-array""" + return len( self.data ) + def __getattr__( self, key ): + """Delegate failing attribute lookups to our data-array""" + if key not in ('data','usage','target','buffers', 'copied','_I_','implementation','_copy_segments' ): + return getattr( self.data, key ) + else: + raise AttributeError( key ) + def create_buffers( self ): + """Create the internal buffer(s)""" + assert not self.buffers, """Already created the buffer""" + self.buffers = [ long(self.implementation.glGenBuffers(1)) ] + self.target = self.resolve( self.target ) + self.usage = self.resolve( self.usage ) + self.implementation._DELETERS_[ id(self) ] = weakref.ref( self, self.implementation.deleter( self.buffers, id(self) )) + return self.buffers + def copy_data( self ): + """Copy our data into the buffer on the GL side (if required) + + Ensures that the GL's version of the data in the VBO matches our + internal view of the data, either by copying the entire data-set + over with glBufferData or by updating the already-transferred + data with glBufferSubData. + """ + assert self.buffers, """Should do create_buffers before copy_data""" + if self.copied: + if self._copy_segments: + while self._copy_segments: + start,size,data = self._copy_segments.pop(0) + dataptr = ArrayDatatype.voidDataPointer( data ) + self.implementation.glBufferSubData(self.target, start, size, dataptr) + else: + if self.data is not None and self.size is None: + self.size = ArrayDatatype.arrayByteCount( self.data ) + self.implementation.glBufferData( + self.target, + self.size, + self.data, + self.usage, + ) + self.copied = True + def delete( self ): + """Delete this buffer explicitly""" + if self.buffers: + while self.buffers: + try: + self.implementation.glDeleteBuffers(1, self.buffers.pop(0)) + except (AttributeError,error.NullFunctionError) as err: + pass + def __int__( self ): + """Get our VBO id""" + if not self.buffers: + self.create_buffers() + return self.buffers[0] + def bind( self ): + """Bind this buffer for use in vertex calls + + If we have not yet created our implementation-level VBO, then we + will create it before binding. Once bound, calls self.copy_data() + """ + if not self.buffers: + buffers = self.create_buffers() + self.implementation.glBindBuffer( self.target, self.buffers[0]) + self.copy_data() + def unbind( self ): + """Unbind the buffer (make normal array operations active)""" + self.implementation.glBindBuffer( self.target,0 ) + + def __add__( self, other ): + """Add an integer to this VBO (create a VBOOffset)""" + if hasattr( other, 'offset' ): + other = other.offset + assert isinstance( other, integer_types ), """Only know how to add integer/long offsets""" + return VBOOffset( self, other ) + + __enter__ = bind + def __exit__( self, exc_type=None, exc_val=None, exc_tb=None ): + """Context manager exit""" + self.unbind() + return False # do not supress exceptions... + + class VBOOffset( object ): + """Offset into a VBO instance + + This class is normally instantiated by doing a my_vbo + int operation, + it can be passed to VBO requiring operations and will generate the + appropriate integer offset value to be passed in. + """ + def __init__( self, vbo, offset ): + """Initialize the offset with vbo and offset (unsigned integer)""" + self.vbo = vbo + self.offset = offset + def __getattr__( self, key ): + """Delegate any undefined attribute save vbo to our vbo""" + if key != 'vbo': + return getattr( self.vbo, key ) + raise AttributeError( 'No %r key in VBOOffset'%(key,)) + def __add__( self, other ): + """Allow adding integers or other VBOOffset instances + + returns a VBOOffset to the this VBO with other.offset + self.offset + or, if other has no offset, returns VBOOffset with self.offset + other + """ + if hasattr( other, 'offset' ): + other = other.offset + return VBOOffset( self.vbo, self.offset + other ) + + class VBOHandler( FormatHandler ): + """Handles VBO instances passed in as array data + + This FormatHandler is registered with PyOpenGL on import of this module + to provide handling of VBO objects as array data-sources + """ + vp0 = ctypes.c_void_p( 0 ) + def dataPointer( self, instance ): + """Retrieve data-pointer from the instance's data + + Is always NULL, to indicate use of the bound pointer + """ + return 0 + def from_param( self, instance, typeCode=None ): + """Always returns c_void_p(0)""" + return self.vp0 + def zeros( self, dims, typeCode ): + """Not implemented""" + raise NotImplemented( """Don't have VBO output support yet""" ) + ones = zeros + def asArray( self, value, typeCode=None ): + """Given a value, convert to array representation""" + return value + def arrayToGLType( self, value ): + """Given a value, guess OpenGL type of the corresponding pointer""" + return ArrayDatatype.arrayToGLType( value.data ) + def arrayByteCount( self, value ): + return ArrayDatatype.arrayByteCount( value.data ) + def arraySize( self, value, typeCode = None ): + """Given a data-value, calculate dimensions for the array""" + return ArrayDatatype.arraySize( value.data ) + def unitSize( self, value, typeCode=None ): + """Determine unit size of an array (if possible)""" + return ArrayDatatype.unitSize( value.data ) + def dimensions( self, value, typeCode=None ): + """Determine dimensions of the passed array value (if possible)""" + return ArrayDatatype.dimensions( value.data ) + + class VBOOffsetHandler( VBOHandler ): + """Handles VBOOffset instances passed in as array data + + Registered on module import to provide support for VBOOffset instances + as sources for array data. + """ + def dataPointer( self, instance ): + """Retrieve data-pointer from the instance's data + + returns instance' offset + """ + return instance.offset + def from_param( self, instance, typeCode=None ): + """Returns a c_void_p( instance.offset )""" + return ctypes.c_void_p( instance.offset ) + +_cleaners = {} +def _cleaner( vbo ): + """Construct a mapped-array cleaner function to unmap vbo.target""" + def clean( ref ): + try: + _cleaners.pop( vbo ) + except Exception as err: + pass + else: + vbo.implementation.glUnmapBuffer( vbo.target ) + return clean + +def mapVBO( vbo, access=0x88BA ): # GL_READ_WRITE + """Map the given buffer into a numpy array... + + Method taken from: + http://www.mail-archive.com/numpy-discussion@lists.sourceforge.net/msg01161.html + + This should be considered an *experimental* API, + it is not guaranteed to be available in future revisions + of this library! + + Simplification to use ctypes cast from comment by 'sashimi' on my blog... + """ + from numpy import frombuffer + vp = vbo.implementation.glMapBuffer( vbo.target, access ) + # TODO: obviously this is not the right way to do this should allow each format + # handler to convert the pointer in their own way... + vp_array = ctypes.cast(vp, ctypes.POINTER(ctypes.c_byte*vbo.size) ) + # Note: we could have returned the raw ctypes.c_byte array instead... + array = frombuffer( vp_array, 'B' ) + _cleaners[vbo] = weakref.ref( array, _cleaner( vbo )) + return array diff --git a/venv/lib/python3.12/site-packages/OpenGL/constant.py b/venv/lib/python3.12/site-packages/OpenGL/constant.py new file mode 100644 index 00000000..ae64ba7d --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/constant.py @@ -0,0 +1,78 @@ +"""Implementation of OpenGL constant objects""" +import sys +from OpenGL._bytes import bytes,unicode,as_8_bit, long, integer_types, maxsize +from OpenGL import _configflags + +class Constant( object ): + """OpenGL constant that displays itself as a name rather than a value + + The purpose of this class is to make debugging OpenGL code easier, + as you recieve messages that say what value you passed in in a + human-readable form, rather than as a bald number that requires + lookup and disambiguation in the header file. + """ + def __new__( cls, name, value=None ): + """Initialise the constant with the given name and value""" + if not isinstance( value, Constant ): + if isinstance( value, float ) and cls is not FloatConstant: + return FloatConstant( name, value ) + elif isinstance( value, int ) and cls is not IntConstant: + return IntConstant( name, value ) + elif isinstance( value, long ) and cls is not LongConstant: + return LongConstant( name, value ) + elif isinstance( value, (bytes,unicode) ) and cls is not StringConstant: + return StringConstant( name, as_8_bit(value) ) + if isinstance( value, integer_types ): + if value > maxsize: # TODO: I'm guessing this should really by sizeof GLint, not + value = - (value & maxsize) + base = super(Constant,cls).__new__( cls, value ) + base.name = name + if _configflags.MODULE_ANNOTATIONS: + frame = sys._getframe().f_back + if frame and frame.f_back and '__name__' in frame.f_back.f_globals: + base.__module__ = frame.f_back.f_globals['__name__'] + return base + def __repr__( self ): + """Return the name, rather than the bald value""" + return self.name + def __getnewargs__( self ): + """Produce the new arguments for recreating the instance""" + return (self.name,) + super( Constant, self ).__getnewargs__() + +class NumericConstant( Constant ): + """Base class for numeric-value constants""" + def __str__( self ): + """Return the value as a human-friendly string""" + return '%s (%s)'%(self.name,super(Constant,self).__str__()) + def __getstate__(self): + """Retrieve state for pickle and the like""" + return self.name + def __setstate__( self, state ): + self.name = state + +class IntConstant( NumericConstant, int ): + """Integer constant""" +if int is not long: + class LongConstant( NumericConstant, long ): + """Long integer constant""" +else: + LongConstant = IntConstant +class FloatConstant( NumericConstant, float ): + """Float constant""" + +class StringConstant( Constant, bytes ): + """String constants""" + def __repr__( self ): + """Return the value as a human-friendly string""" + return '%s (%s)'%(self.name,super(Constant,self).__str__()) + +if __name__ == "__main__": + x = IntConstant( 'testint', 3 ) + y = FloatConstant( 'testfloat', 3.0 ) + z = StringConstant( 'teststr', 'some testing string' ) + + import pickle + for val in x,y,z: + restored = pickle.loads( pickle.dumps( val )) + assert restored == val, (str(restored),str(val)) + assert restored.name == val.name, (restored.name,val.name) diff --git a/venv/lib/python3.12/site-packages/OpenGL/constants.py b/venv/lib/python3.12/site-packages/OpenGL/constants.py new file mode 100644 index 00000000..132a440b --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/constants.py @@ -0,0 +1,3 @@ +"""Backward-compatibility module to provide core-GL constant names""" +from OpenGL.raw.GL._types import * +from OpenGL.arrays._arrayconstants import * diff --git a/venv/lib/python3.12/site-packages/OpenGL/contextdata.py b/venv/lib/python3.12/site-packages/OpenGL/contextdata.py new file mode 100644 index 00000000..2639631c --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/contextdata.py @@ -0,0 +1,131 @@ +"""Storage of per-context values of various types + +Because OpenGL needs persistent references to the +objects we're constructing to shadow Python objects, +we have to store references to the objects somewhere + +For any given Python GUI library, we can use a weakref +to the library's representation of the GL context to +call the cleanup function. That means some per-GUI +library code in OpenGL (or the library), but it gives +us very natural operations within OpenGL. + +Note: you can entirely disable use of this module by +setting: + + OpenGL.ERROR_ON_COPY = True + OpenGL.STORE_POINTERS = False + +before importing OpenGL functionality. +""" +from OpenGL import platform +import weakref +storedPointers = { + # map from contextID: { constant: value } +} +storedWeakPointers = { + # map from contextID: WeakValueDictionary({ constant: value }) +} +STORAGES = [ storedPointers, storedWeakPointers ] + +def getContext( context = None ): + """Get the context (if passed, just return) + + context -- the context ID, if None, the current context + """ + if context is None: + context = platform.GetCurrentContext() + if context == 0: + from OpenGL import error + raise error.Error( + """Attempt to retrieve context when no valid context""" + ) + return context +def setValue( constant, value, context=None, weak=False ): + """Set a stored value for the given context + + constant -- Normally a GL constant value, but can be any hashable value + value -- the value to be stored. If weak is true must be + weak-reference-able. If None, then the value will be deleted from + the storage + context -- the context identifier for which we're storing the value + weak -- if true, value will be stored with a weakref + Note: you should always pass the same value for "weak" for a given + constant, otherwise you will create two storages for the constant. + """ + if getattr( value, '_no_cache_', False ): + return + context = getContext( context ) + if weak: + storage = storedWeakPointers + cls = weakref.WeakValueDictionary + else: + storage = storedPointers + cls = dict + current = storage.get( context ) + if current is None: + storage[context] = current = cls() + previous = current.get( constant ) + if value is None: + try: + del current[ constant ] + except (KeyError,TypeError,ValueError) as err: + pass + else: + # XXX potential for failure here if a non-weakref-able objects + # is being stored with weak == True + current[ constant ] = value + return previous +def delValue( constant, context=None ): + """Delete the specified value for the given context + + constant -- Normally a GL constant value, but can be any hashable value + context -- the context identifier for which we're storing the value + """ + context = getContext( context ) + found = False + for storage in STORAGES: + contextStorage = storage.get( context ) + if contextStorage: + try: + del contextStorage[ constant ] + found = True + except KeyError as err: + pass + return found + +def getValue( constant, context = None ): + """Get a stored value for the given constant + + constant -- unique ID for the type of data being retrieved + context -- the context ID, if None, the current context + """ + context = getContext( context ) + for storage in STORAGES: + contextStorage = storage.get( context ) + if contextStorage: + value = contextStorage.get( constant ) + if value is not None: + return value + return None + +def cleanupContext( context=None ): + """Cleanup all held pointer objects for the given context + + Warning: this is dangerous, as if you call it before a context + is destroyed you may release memory held by the context and cause + a protection fault when the GL goes to render the scene! + + Normally you will want to get the context ID explicitly and then + register cleanupContext as a weakref callback to your GUI library + Context object with the (now invalid) context ID as parameter. + """ + if context is None: + context = platform.GetCurrentContext() + for storage in STORAGES: + try: + del storedPointers[ context ] + except KeyError as err: + return False + else: + return True diff --git a/venv/lib/python3.12/site-packages/OpenGL/converters.py b/venv/lib/python3.12/site-packages/OpenGL/converters.py new file mode 100644 index 00000000..91d34db2 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/converters.py @@ -0,0 +1,316 @@ +"""Implementations for common converter types""" +import ctypes,logging +from OpenGL._bytes import bytes, unicode, as_8_bit +from OpenGL._null import NULL +_log = logging.getLogger( 'OpenGL.converters' ) + +class Converter( object ): + """Base class for Converter types + + Converter objects are callable objects used with the + OpenGL.wrapper.Wrapper class to simplify the wrapping + of functions by collecting commonly used functionality + into a reusable function. + + Each Converter has two (class) attributes: + + argNames -- list of argument names for initialisation + indexLookups -- set of (indexname, argName,methodName) values + to lookup on wrapper. These allow us to use argument-name + references to refer to which arguments to use when + processing (prevents the need to revise pointers when + we change the API for a function). + + Converters can be any of the Wrapper API helper functions, + so the callable interface can vary among Converter classes. + """ + argNames = ( ) + indexLookups = ( ) + def __init__( self, *args, **named ): + """Store arguments in attributes + + *args -- mapped to self.argNames in order to set attributes + **named -- mapped to self.argNames by name to set attributes + """ + argNames = list(self.argNames) + for a in self.argNames: + if a in named: + setattr( self, a, named[a] ) + argNames.remove( a ) + for a,value in zip( argNames, args ): + setattr( self, a, value ) + def finalise( self, wrapper ): + """Look up our indices (where appropriate)""" + for indexname,argName,methodName in self.indexLookups: + setattr( + self, indexname, + getattr(wrapper,methodName)(getattr( self, argName )) + ) + +# Definitions of the abstract interfaces... +class PyConverter( Converter ): + """Converter sub-class for use in Wrapper.pyConverters + + This class just defines the interface for a pyConverter-style + Converter object + """ + def __call__( self, incoming, function, arguments ): + """Convert incoming argument into compatable data-types + + incoming -- the Python argument for this parameter + function -- the wrapper.Wrapper class we are supporting + arguments -- the complete set of arguments passed to the + function + + + """ + raise NotImplemented( """%s class doesn't implement __call__"""%( + self.__class__.__name__, + )) + +class CConverter( Converter ): + """Converter sub-class for use in Wrapper.cConverters + + This class just defines the interface for a cConverter-style + Converter object + """ + def __call__( self, pyArgs, index, baseOperation ): + """Calculate C-compatible Python object from Python arguments + + pyArgs -- set of Python argument objects converted by + pyConverters from the incoming arguments + index -- our index in baseOperation.cConverters + baseOperation -- the Wrapper object which we are supporting + """ + raise NotImplemented( """%s class doesn't implement __call__"""%( + self.__class__.__name__, + )) +class ReturnValues( Converter ): + """Converter sub-class for use as Wrapper.returnValues + + This class just defines the interface for a returnValues-style + Converter object + """ + def __call__( self, result, baseOperation, pyArgs, cArgs ): + """Return a final value to the caller + + result -- the raw ctypes result value + baseOperation -- the Wrapper object which we are supporting + pyArgs -- the set of Python arguments produced by pyConverters + cArgs -- the set of C-compatible arguments produced by CConverter + + return the Python object for the final result + """ + raise NotImplemented( """%s class doesn't implement __call__"""%( + self.__class__.__name__, + )) + +# Now the concrete classes... +from OpenGL import acceleratesupport +CallFuncPyConverter = None +if acceleratesupport.ACCELERATE_AVAILABLE: + try: + from OpenGL_accelerate.wrapper import ( + CallFuncPyConverter, DefaultCConverter, getPyArgsName, + ) + from OpenGL_accelerate.arraydatatype import ( + Output,SizedOutput,OutputOrInput,SizedOutputOrInput + ) + from OpenGL_accelerate.wrapper import ( + returnCArgument, returnPyArgument, + ) + except ImportError as err: + _log.warning( + "Unable to load converters accelerators (wrapper, arraydatatype) from OpenGL_accelerate" + ) + CallFuncPyConverter = None +if CallFuncPyConverter is None: + class CallFuncPyConverter( PyConverter ): + """PyConverter that takes a callable and calls it on incoming""" + def __init__( self, function ): + """Store the function""" + self.function = function + def __call__( self, incoming, function, argument ): + """Call our function on incoming""" + return self.function( incoming ) + class DefaultCConverter( CConverter ): + """NULL or Default CConverter, returns same-named Python argument + + Used primarily to allow for specifying a converter that explicitly + says "use the default behaviour". This is *not* a finalise-ing + converter, it is passed in the index explicitly and just retrieves + that index from pyArgs when called. + + Raises informative errors if the index cannot be resolved in pyArgs + """ + def __init__( self, index ): + """Just store index for future access""" + self.index = index + def __call__( self, pyArgs, index, wrapper ): + """Return pyArgs[self.index] or raise a ValueError""" + try: + return pyArgs[ self.index ] + except IndexError: + raise ValueError( + """Expected parameter index %r, but pyArgs only length %s"""%( + self.index, + len(pyArgs ) + )) + class getPyArgsName( CConverter ): + """CConverter returning named Python argument + + Intended for use in cConverters, the function returned + retrieves the named pyArg and returns it when called. + """ + argNames = ('name',) + indexLookups = [ ('index','name', 'pyArgIndex' ), ] + __slots__ = ( 'index', 'name') + def __call__( self, pyArgs, index, baseOperation ): + """Return pyArgs[ self.index ]""" + try: + return pyArgs[ self.index ] + except AttributeError: + raise RuntimeError( """"Did not resolve parameter index for %r"""%(self.name)) + + class Output( CConverter ): + """CConverter generating static-size typed output arrays + + Produces an output array of given type (arrayType) and + size using self.lookup() to determine the size of the + array to be produced, where the lookup function is passed + as an initialisation argument. + + Provides also: + + oldStyleReturn( ... ) for use in the default case of + PyOpenGL compatability mode, where result arrays of + size (1,) are returned as scalar values. + """ + argNames = ('name','size','arrayType' ) + indexLookups = [ + ('outIndex','name', 'cArgIndex' ), + ] + __slots__ = ('index','size','arrayType','outIndex','inIndex') + def __call__( self, pyArgs, index, baseOperation ): + """Return pyArgs[ self.index ]""" + return self.arrayType.zeros( self.getSize(pyArgs) ) + def getSize( self, pyArgs ): + """Retrieve the array size for this argument""" + return self.size + def oldStyleReturn( self, result, baseOperation, pyArgs, cArgs ): + """Retrieve cArgs[ self.index ]""" + result = cArgs[ self.outIndex ] + try: + thisSize = self.getSize(pyArgs) + except KeyError: + return result + if thisSize == (1,): + try: + return result[0] + except (IndexError,TypeError): + return result + else: + return result + class OutputOrInput( Output ): + DO_OUTPUT = (None,NULL) + def __call__( self, pyArgs, index, baseOperation ): + for do_output in self.DO_OUTPUT: + if pyArgs[index] is do_output: + return super( OutputOrInput,self ).__call__( pyArgs, index, baseOperation ) + return self.arrayType.asArray( pyArgs[index] ) + + class SizedOutput( Output ): + """Output generating dynamically-sized typed output arrays + + Takes an extra parameter "specifier", which is the name of + a Python argument to be passed to the lookup function in order + to determine the appropriate size for the output array. + """ + argNames = ('name','specifier','lookup','arrayType' ) + indexLookups = [ + ('outIndex','name', 'cArgIndex' ), + ('index','specifier', 'pyArgIndex' ), + ] + __slots__ = ('index','outIndex','specifier','lookup','arrayType') + def getSize( self, pyArgs ): + """Retrieve the array size for this argument""" + try: + specifier = pyArgs[ self.index ] + except AttributeError: + raise RuntimeError( """"Did not resolve parameter index for %r"""%(self.name)) + else: + try: + return self.lookup( specifier ) + except KeyError: + raise KeyError( """Unknown specifier %s"""%( specifier )) + class SizedOutputOrInput( SizedOutput ): + DO_OUTPUT = (None,NULL) + def __call__( self, pyArgs, index, baseOperation ): + for do_output in self.DO_OUTPUT: + if pyArgs[index] is do_output: + return super( SizedOutputOrInput,self ).__call__( pyArgs, index, baseOperation ) + return self.arrayType.asArray( pyArgs[index] ) + class returnCArgument( ReturnValues ): + """ReturnValues returning the named cArgs value""" + argNames = ('name',) + indexLookups = [ ('index','name', 'cArgIndex' ), ] + __slots__ = ( 'index', 'name' ) + def __call__( self, result, baseOperation, pyArgs, cArgs ): + """Retrieve cArgs[ self.index ]""" + return cArgs[self.index] + + class returnPyArgument( ReturnValues ): + """ReturnValues returning the named pyArgs value""" + argNames = ('name',) + indexLookups = [ ('index','name', 'pyArgIndex' ), ] + __slots__ = ( 'index', 'name' ) + def __call__( self, result, baseOperation, pyArgs, cArgs ): + """Retrieve pyArgs[ self.index ]""" + return pyArgs[self.index] + +class StringLengths( CConverter ): + """CConverter for processing array-of-pointers-to-strings data-type + + Converter is a CConverter for the array-of-lengths for a + array-of-pointers-to-strings data-type used to pass a set + of code fragments to the GLSL compiler. + + Provides also: + + stringArray -- PyConverter callable ensuring list-of-strings + format for the python argument + + stringArrayForC -- CResolver converting the array to + POINTER(c_char_p) format for passing to C + + totalCount -- CConverter callable giving count of string + pointers (that is, length of the pointer array) + """ + argNames = ('name',) + indexLookups = [ ('index','name', 'pyArgIndex' ), ] + __slots__ = () + def __call__( self, pyArgs, index, baseOperation ): + """Get array of length integers for string contents""" + from OpenGL.raw.GL import _types + tmp = [len(x) for x in pyArgs[self.index]] + a_type = _types.GLint * len(tmp) + return a_type( *tmp ) + def totalCount( self, pyArgs, index, baseOperation ): + """Get array of length integers for string contents""" + return len(pyArgs[self.index]) + def stringArray( self, arg, baseOperation, args ): + """Create basic array-of-strings object from pyArg""" + if isinstance( arg, (bytes,unicode) ): + arg = [arg] + value = [as_8_bit(x) for x in arg] + return value + def stringArrayForC( self, strings ): + """Create a ctypes pointer to char-pointer set""" + from OpenGL import arrays + result = (ctypes.c_char_p * len(strings))() + for i,s in enumerate(strings): + result[i] = ctypes.cast( + arrays.GLcharARBArray.dataPointer(s), + ctypes.c_char_p, + ) + return result diff --git a/venv/lib/python3.12/site-packages/OpenGL/error.py b/venv/lib/python3.12/site-packages/OpenGL/error.py new file mode 100644 index 00000000..dbeb804a --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/error.py @@ -0,0 +1,248 @@ +"""Implementation of OpenGL errors/exceptions + +Note that OpenGL-ctypes will also throw standard errors, +such as TypeError or ValueError when appropriate. + +ErrorChecker is an _ErrorChecker instance that allows you +to register a new error-checking function for use +throughout the system. +""" +import logging +_log = logging.getLogger( 'OpenGL.error' ) +from OpenGL import platform, _configflags +from ctypes import ArgumentError +__all__ = ( + "Error",'GLError','GLUError','GLUTError', + 'GLerror','GLUerror','GLUTerror','ArgumentError', +) + +class Error( Exception ): + """Base class for all PyOpenGL-specific exception classes""" +class NoContext( Error ): + """Raised to indicate that there is no currently active context + + Technically almost *any* OpenGL call can segfault if there is + no active context. The OpenGL.CHECK_CONTEXT flag, if enabled + will cause this error to be raised whenever a GL or GLU call is + issued (via PyOpenGL) if there is no currently valid context. + """ +class CopyError( Error ): + """Raised to indicate that operation requires data-copying + + if you set: + OpenGL.ERROR_ON_COPY = True + + before importing OpenGL.GL, this error will be raised when + a passed argument would require a copy to be made. + """ + +class NullFunctionError( Error ): + """Error raised when an undefined function is called""" + +class GLError( Error ): + """OpenGL core error implementation class + + Primary purpose of this error class is to allow for + annotating an error with more details about the calling + environment so that it's easier to debug errors in the + wrapping process. + + Attributes: + + err -- the OpenGL error code for the error + result -- the OpenGL result code for the operation + baseOperation -- the "function" being called + pyArgs -- the translated set of Python arguments + cArgs -- the Python objects matching 1:1 the C arguments + cArguments -- ctypes-level arguments to the operation, + often raw integers for pointers and the like + description -- OpenGL description of the error (textual) + """ + def __init__( + self, + err=None, + result=None, + cArguments=None, + baseOperation=None, + pyArgs=None, + cArgs=None, + description=None, + ): + """Initialise the GLError, storing metadata for later display""" + ( + self.err, self.result, self.cArguments, + self.baseOperation, self.pyArgs, self.cArgs, + self.description + ) = ( + err, result, cArguments, + baseOperation, pyArgs, cArgs, + description + ) + DISPLAY_ORDER = ( + 'err', + 'description', + 'baseOperation', + 'pyArgs', + 'cArgs', + 'cArguments', + 'result', + ) + def __str__( self ): + """Create a fully formatted representation of the error""" + args = [] + for property in self.DISPLAY_ORDER: + value = getattr( self, property, None ) + if value is not None or property=='description': + formatFunction = 'format_%s'%(property) + if hasattr( self, formatFunction ): + args.append( getattr(self,formatFunction)( property, value )) + else: + args.append( '%s = %s'%( + property, + self.shortRepr( value ), + )) + return '%s(\n\t%s\n)'%(self.__class__.__name__, ',\n\t'.join( + [x for x in args if x] + )) + def __repr__( self ): + """Produce a much shorter version of the error as a string""" + return '%s( %s )'%( + self.__class__.__name__, + ", ".join([x for x in [ + 'err=%s'%(self.err), + self.format_description( 'description', self.description ) or '', + self.format_baseOperation( 'baseOperation', self.baseOperation ) or '', + ] if x]) + ) + def format_description( self, property, value ): + """Format description using GLU's gluErrorString""" + if value is None and self.err is not None: + try: + from OpenGL.GLU import gluErrorString + self.description = value = gluErrorString( self.err ) + except Exception as err: + return None + if value is None: + return None + return '%s = %s'%( + property, + self.shortRepr( value ), + ) + def shortRepr( self, value, firstLevel=True ): + """Retrieve short representation of the given value""" + if isinstance( value, (list,tuple) ) and value and len(repr(value))>=40: + if isinstance( value, list ): + template = '[\n\t\t%s\n\t]' + else: + template = '(\n\t\t%s,\n\t)' + return template%( ",\n\t\t".join( + [ + self.shortRepr(x,False) for x in value + ] + )) + r = repr( value ) + if len(r) < 120: + return r + else: + return r[:117] + '...' + def format_baseOperation( self, property, value ): + """Format a baseOperation reference for display""" + if hasattr( value, '__name__' ): + return '%s = %s'%( property, value.__name__ ) + else: + return '%s = %r'%( property, value ) + +class GLUError( Error ): + """GLU error implementation class""" + +class GLUTError( Error ): + """GLUT error implementation class""" +class EGLError( GLError ): + """EGL error implementation class""" + +if _configflags.ERROR_CHECKING: + from OpenGL import acceleratesupport + _ErrorChecker = None + if acceleratesupport.ACCELERATE_AVAILABLE: + try: + from OpenGL_accelerate.errorchecker import _ErrorChecker + except ImportError as err: + _log.warning( """OpenGL_accelerate seems to be installed, but unable to import error checking entry point!""" ) + if _ErrorChecker is None: + class _ErrorChecker( object ): + """Per-API error-checking object + + Attributes: + _registeredChecker -- the checking function enabled when + not doing onBegin/onEnd processing + _currentChecker -- currently active checking function + """ + _getErrors = None + def __init__( self, platform, baseOperation=None, noErrorResult=0, errorClass=GLError ): + """Initialize from a platform module/reference""" + self._isValid = platform.CurrentContextIsValid + self._getErrors = baseOperation + self._noErrorResult = noErrorResult + self._errorClass = errorClass + if self._getErrors: + if _configflags.CONTEXT_CHECKING: + self._registeredChecker = self.safeGetError + else: + self._registeredChecker = self._getErrors + else: + self._registeredChecker = self.nullGetError + self._currentChecker = self._registeredChecker + def __bool__( self ): + """We are "true" if we actually do anything""" + if self._registeredChecker is self.nullGetError: + return False + return True + def safeGetError( self ): + """Check for error, testing for context before operation""" + if self._isValid(): + return self._getErrors() + return None + def nullGetError( self ): + """Used as error-checker when no error checking should be done""" + return self._noErrorResult + def glCheckError( + self, + result, + baseOperation=None, + cArguments=None, + *args + ): + """Base GL Error checker compatible with new ctypes errcheck protocol + + This function will raise a GLError with just the calling information + available at the C-calling level, i.e. the error code, cArguments, + baseOperation and result. Higher-level code is responsible for any + extra annotations. + + Note: + glCheckError relies on glBegin/glEnd interactions to + prevent glGetError being called during a glBegin/glEnd + sequence. If you are calling glBegin/glEnd in C you + should call onBegin and onEnd appropriately. + """ + err = self._currentChecker() + if err != self._noErrorResult: + raise self._errorClass( + err, + result, + cArguments = cArguments, + baseOperation = baseOperation, + ) + return result + def onBegin( self ): + """Called by glBegin to record the fact that glGetError won't work""" + self._currentChecker = self.nullGetError + def onEnd( self ): + """Called by glEnd to record the fact that glGetError will work""" + self._currentChecker = self._registeredChecker +else: + _ErrorChecker = None +# Compatibility with PyOpenGL 2.x series +GLUerror = GLUError +GLerror = GLError +GLUTerror = GLUTError diff --git a/venv/lib/python3.12/site-packages/OpenGL/extensions.py b/venv/lib/python3.12/site-packages/OpenGL/extensions.py new file mode 100644 index 00000000..d4af5b68 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/extensions.py @@ -0,0 +1,256 @@ +"""Extension module support methods + +This module provides the tools required to check whether +an extension is available +""" +from OpenGL.latebind import LateBind +from OpenGL._bytes import bytes,unicode,as_8_bit +import OpenGL as root +import sys +import logging +_log = logging.getLogger( 'OpenGL.extensions' ) +VERSION_PREFIX = as_8_bit('GL_VERSION_GL_') +CURRENT_GL_VERSION = None +AVAILABLE_GL_EXTENSIONS = [] +AVAILABLE_GLU_EXTENSIONS = [] + +# version tuple -> list of implicitly included extensions... +VERSION_EXTENSIONS = [ + ((3,0), [ + as_8_bit('GL_ARB_vertex_array_object'), + as_8_bit('GL_ARB_texture_buffer_object'), + as_8_bit('GL_ARB_framebuffer_object'), + as_8_bit('GL_ARB_map_buffer_range'), + ]), + ((3,1), [ + as_8_bit('GL_ARB_copy_buffer'), + as_8_bit('GL_ARB_uniform_buffer_object'), + ]), + ((3,2), [ + as_8_bit('GL_ARB_draw_elements_base_vertex'), + as_8_bit('GL_ARB_provoking_vertex'), + as_8_bit('GL_ARB_sync'), + as_8_bit('GL_ARB_texture_multisample'), + ]), + ((3,3), [ + as_8_bit('GL_ARB_texture_multisample'), + as_8_bit('GL_ARB_blend_func_extended'), + as_8_bit('GL_ARB_sampler_objects'), + as_8_bit('GL_ARB_explicit_attrib_location'), + as_8_bit('GL_ARB_occlusion_query2'), + as_8_bit('GL_ARB_shader_bit_encoding'), + as_8_bit('GL_ARB_texture_rgb10_a2ui'), + as_8_bit('GL_ARB_texture_swizzle'), + as_8_bit('GL_ARB_timer_query'), + as_8_bit('GL_ARB_vertex_type_2_10_10_10_rev'), + ]), + ((4,0), [ + as_8_bit('GL_ARB_texture_query_lod'), + as_8_bit('GL_ARB_draw_indirect'), + as_8_bit('GL_ARB_gpu_shader5'), + as_8_bit('GL_ARB_gpu_shader_fp64'), + as_8_bit('GL_ARB_shader_subroutine'), + as_8_bit('GL_ARB_tessellation_shader'), + as_8_bit('GL_ARB_texture_buffer_object_rgb32'), + as_8_bit('GL_ARB_texture_cube_map_array'), + as_8_bit('GL_ARB_texture_gather'), + as_8_bit('GL_ARB_transform_feedback2'), + as_8_bit('GL_ARB_transform_feedback3'), + ]), + ((4,1), [ + as_8_bit('GL_ARB_ES2_compatibility'), + as_8_bit('GL_ARB_get_program_binary'), + as_8_bit('GL_ARB_separate_shader_objects'), + as_8_bit('GL_ARB_shader_precision'), + as_8_bit('GL_ARB_vertex_attrib_64bit'), + as_8_bit('GL_ARB_viewport_array'), + ]), + ((4,2), [ + as_8_bit('GL_ARB_base_instance'), + as_8_bit('GL_ARB_shading_language_420pack'), + as_8_bit('GL_ARB_transform_feedback_instanced'), + as_8_bit('GL_ARB_compressed_texture_pixel_storage'), + as_8_bit('GL_ARB_conservative_depth'), + as_8_bit('GL_ARB_internalformat_query'), + as_8_bit('GL_ARB_map_buffer_alignment'), + as_8_bit('GL_ARB_shader_atomic_counters'), + as_8_bit('GL_ARB_shader_image_load_store'), + as_8_bit('GL_ARB_shading_language_packing'), + as_8_bit('GL_ARB_texture_storage'), + ]), +] + +class ExtensionQuerier( object ): + prefix = None + version_prefix = None + assumed_version = [1,0] + + version = extensions = None + version_string = extensions_string = None + + registered = [] + def __init__( self ): + self.registered.append( self ) + + @classmethod + def hasExtension( self, specifier ): + for registered in self.registered: + result = registered( specifier ) + if result: + return result + return False + + def __call__( self, specifier ): + specifier = as_8_bit(specifier).replace(as_8_bit('.'),as_8_bit('_')) + if not specifier.startswith( as_8_bit(self.prefix) ): + return None + + if specifier.startswith( as_8_bit(self.version_prefix) ): + specifier = [ + int(x) + for x in specifier[ len(self.version_prefix):].split(as_8_bit('_')) + ] + if specifier[:2] <= self.assumed_version: + return True + version = self.getVersion() + if not version: + return version + return specifier <= version + else: + extensions = self.getExtensions() + return extensions and specifier in extensions + def getVersion( self ): + if not self.version: + self.version = self.pullVersion() + return self.version + def getExtensions( self ): + if not self.extensions: + self.extensions = self.pullExtensions() + return self.extensions + +class _GLQuerier( ExtensionQuerier ): + prefix = as_8_bit('GL_') + version_prefix = as_8_bit('GL_VERSION_GL_') + assumed_version = [1,1] + def pullVersion( self ): + """Retrieve 2-int declaration of major/minor GL version + + returns [int(major),int(minor)] or False if not loaded + """ + from OpenGL import platform + if not platform.PLATFORM.CurrentContextIsValid(): + return False + from OpenGL.raw.GL.VERSION.GL_1_1 import glGetString + from OpenGL.raw.GL.VERSION.GL_1_1 import GL_VERSION + new = glGetString( GL_VERSION ) + + self.version_string = new + if new: + return [ + int(x) for x in new.split(as_8_bit(' '),1)[0].split( as_8_bit('.') ) + ] + else: + return False # not yet loaded/supported + def pullExtensions( self ): + from OpenGL import platform + if not platform.PLATFORM.CurrentContextIsValid(): + return False + from OpenGL.raw.GL._types import GLint + from OpenGL.raw.GL.VERSION.GL_1_1 import glGetString, glGetError + from OpenGL.raw.GL.VERSION.GL_1_1 import GL_EXTENSIONS + from OpenGL import error + try: + extensions = glGetString( GL_EXTENSIONS ) + if glGetError(): + raise error.GLError() + if extensions: + extensions = extensions.split() + else: + return False + except (AttributeError, error.GLError): + # OpenGL 3.0 deprecates glGetString( GL_EXTENSIONS ) + from OpenGL.raw.GL.VERSION.GL_3_0 import GL_NUM_EXTENSIONS, glGetStringi + from OpenGL.raw.GL.VERSION.GL_1_1 import glGetIntegerv + count = GLint() + glGetIntegerv( GL_NUM_EXTENSIONS, count ) + extensions = [] + for i in range( count.value ): + extension = glGetStringi( GL_EXTENSIONS, i ) + extensions.append( + extension + ) + # Add included-by-reference extensions... + version = self.getVersion() + if not version: + # should not be possible? + return version + check = tuple( version[:2] ) + for (v,v_exts) in VERSION_EXTENSIONS: + if v <= check: + for v_ext in v_exts: + if v_ext not in extensions: + extensions.append( as_8_bit(v_ext) ) + else: + break + return extensions +GLQuerier = _GLQuerier() +class _GLUQuerier( ExtensionQuerier ): + prefix = as_8_bit('GLU_') + version_prefix = as_8_bit('GLU_VERSION_GL_') + def pullVersion( self ): + from OpenGL.GLU import gluGetString,GLU_VERSION + return [ + int(x) for x in gluGetString( GLU_VERSION ).split(as_8_bit('_')) + if x.isdigit() + ] + def pullExtensions( self ): + from OpenGL.GLU import gluGetString,GLU_EXTENSIONS + return gluGetString( GLU_EXTENSIONS ).split() +GLUQuerier = _GLUQuerier() + +def hasExtension( specifier ): + return ExtensionQuerier.hasExtension( specifier ) +hasGLExtension = hasGLUExtension = hasExtension + +class _Alternate( LateBind ): + def __init__( self, name, *alternates ): + """Initialize set of alternative implementations of the same function""" + self.__name__ = name + self._alternatives = alternates + if root.MODULE_ANNOTATIONS: + frame = sys._getframe().f_back + if frame and frame.f_back and '__name__' in frame.f_back.f_globals: + self.__module__ = frame.f_back.f_globals['__name__'] + def __bool__( self ): + from OpenGL import error + try: + return bool( self.getFinalCall()) + except error.NullFunctionError as err: + return False + __nonzero__ = __bool__ # Python 2.6 compatibility + def finalise( self ): + """Call, doing a late lookup and bind to find an implementation""" + for alternate in self._alternatives: + if alternate: +# _log.info( +# """Chose alternate: %s from %s""", +# alternate.__name__, +# ", ".join([x.__name__ for x in self._alternatives]) +# ) + return alternate + from OpenGL import error + raise error.NullFunctionError( + """Attempt to call an undefined alternate function (%s), check for bool(%s) before calling"""%( + ', '.join([x.__name__ for x in self._alternatives]), + self.__name__, + ) + ) +def alternate( name, *functions ): + """Construct a callable that functions as the first implementation found of given set of alternatives + + if name is a function then its name will be used.... + """ + if not isinstance( name, (bytes,unicode)): + functions = (name,)+functions + name = name.__name__ + return type( name, (_Alternate,), {} )( name, *functions ) diff --git a/venv/lib/python3.12/site-packages/OpenGL/images.py b/venv/lib/python3.12/site-packages/OpenGL/images.py new file mode 100644 index 00000000..73637aca --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/images.py @@ -0,0 +1,167 @@ +"""Image/texture implementation code + +This module provides the Pan-OpenGL operations required to support OpenGL +image handling. Most of this code is simply boilerplate code that sets +OpenGL parameters such that normal Pythonic assumptions about data-ordering +are met to allow easier interaction with other projects (such as PIL or +Numpy). + +Generally speaking, there are 3 pieces of information which control how +an image is processed in the system: + + format -- this is the pixel format, such as GL_RGB/GL_RED/GL_ABGR_EXT + dims -- tuple of dimensions for the image, (width,height,depth) order + type -- the storage data-type for the image, normally GL_UNSIGNED_BYTE + when working in Python, but all of the standard OpenGL types for + images can be used if you happen to have your data in some exotic + format. + + OpenGL.UNSIGNED_BYTE_IMAGES_AS_STRING -- if this global value is set, + then read of unsigned byte images using glReadPixels and + glGetTexImage produces a string instead of the default array format. + +Attributes of Note: + + COMPONENT_COUNTS -- used to lookup how many units of a + given storage type are required to store a unit in a given format + + TYPE_TO_ARRAYTYPE -- maps Image storage types to their array data-type + constants, i.e. maps GL_UNSIGNED_SHORT_4_4_4_4 to GL_UNSIGNED_SHORT + so that we can use the standard array types for manipulating + image arrays. + + RANK_PACKINGS -- commands required to set up default array-transfer + operations for an array of the specified rank. + +New image formats and types will need to be registered here to be supported, +this means that extension modules which add image types/formats need to alter +the tables described above! + + XXX Should be an API to handle that instead of direct modification. + +""" +from OpenGL.raw.GL.VERSION import GL_1_1 as _simple +from OpenGL import arrays +from OpenGL import error +from OpenGL import _configflags +import ctypes + +def SetupPixelRead( format, dims, type): + """Setup transfer mode for a read into a numpy array return the array + + Calls setupDefaultTransferMode, sets rankPacking and then + returns a createTargetArray for the parameters. + """ + setupDefaultTransferMode() + # XXX this is wrong? dims may grow or it may not, depends on whether + # the format can fit in the type or not, but rank is a property of the + # image itself? Don't know, should test. + rankPacking( len(dims)+1 ) + return createTargetArray( format, dims, type ) + +def setupDefaultTransferMode( ): + """Set pixel transfer mode to assumed internal structure of arrays + + Basically OpenGL-ctypes (and PyOpenGL) assume that your image data is in + non-byte-swapped order, with big-endian ordering of bytes (though that + seldom matters in image data). These assumptions are normally correct + when dealing with Python libraries which expose byte-arrays. + """ + try: + _simple.glPixelStorei(_simple.GL_PACK_SWAP_BYTES, 0) + _simple.glPixelStorei(_simple.GL_PACK_LSB_FIRST, 0) + except error.GLError: + # GLES doesn't support pixel storage swapping... + pass + +def rankPacking( rank ): + """Set the pixel-transfer modes for a given image "rank" (# of dims) + + Uses RANK_PACKINGS table to issue calls to glPixelStorei + """ + for func,which,arg in RANK_PACKINGS[rank]: + try: + func(which,arg) + except error.GLError: + pass + +def createTargetArray( format, dims, type ): + """Create storage array for given parameters + + If storage type requires > 1 unit per format pixel, then dims will be + extended by 1, so in the common case of RGB and GL_UNSIGNED_BYTE you + will wind up with an array of dims + (3,) dimensions. See + COMPONENT_COUNTS for table which controls which formats produce + larger dimensions. The secondary table TIGHT_PACK_FORMATS overrides + this case, so that image formats registered as TIGHT_PACK_FORMATS + only ever return a dims-shaped value. TIGHT_PACK_FORMATS will raise + ValueErrors if they are used with a format that does not have the same + number of components as they define. + + Note that the base storage type must provide a zeros method. The zeros + method relies on their being a registered default array-implementation for + the storage type. The default installation of OpenGL-ctypes will use + Numpy arrays for returning the result. + """ + # calculate the number of storage elements required to store + # a single pixel of format, that's the dimension of the resulting array + componentCount = formatToComponentCount( format ) + if componentCount > 1: + if type not in TIGHT_PACK_FORMATS: + # requires multiple elements to store a single pixel (common) + # e.g. byte array (typeBits = 8) with RGB (24) or RGBA (32) + dims += (componentCount, ) + elif TIGHT_PACK_FORMATS[ type ] < componentCount: + raise ValueError( + """Image type: %s supports %s components, but format %s requires %s components"""%( + type, + TIGHT_PACK_FORMATS[ type ], + format, + componentCount, + ) + ) + arrayType = arrays.GL_CONSTANT_TO_ARRAY_TYPE[ TYPE_TO_ARRAYTYPE.get(type,type) ] + return arrayType.zeros( dims ) + +def formatToComponentCount( format ): + """Given an OpenGL image format specification, get components/pixel""" + size = COMPONENT_COUNTS.get( format ) + if size is None: + raise ValueError( """Unrecognised image format: %r"""%(format,)) + return size + +def returnFormat( data, type ): + """Perform compatibility conversion for PyOpenGL 2.x image-as string results + + Uses OpenGL.UNSIGNED_BYTE_IMAGES_AS_STRING to control whether to perform the + conversions. + """ + if _configflags.UNSIGNED_BYTE_IMAGES_AS_STRING: + if type == _simple.GL_UNSIGNED_BYTE: + if hasattr( data, 'tobytes' ): + return data.tobytes() + elif hasattr( data, 'tostring' ): + return data.tostring() + elif hasattr( data, 'raw' ): + return data.raw + elif hasattr( data, '_type_' ): + s = ctypes.string_at( ctypes.cast( data, ctypes.c_voidp ), ctypes.sizeof( data )) + result = s[:] # copy into a new string + return result + return data + + +COMPONENT_COUNTS = { + # Image-format-constant: number-of-components (integer) +} +TYPE_TO_BITS = { + # GL-image-storage-type-constant: number-of-bits (integer) +} +TYPE_TO_ARRAYTYPE = { + # GL-image-storage-type-constant: GL-datatype (constant) +} +TIGHT_PACK_FORMATS = { +} +RANK_PACKINGS = { + # rank (integer): list of (function,**arg) to setup for that rank +} diff --git a/venv/lib/python3.12/site-packages/OpenGL/latebind.py b/venv/lib/python3.12/site-packages/OpenGL/latebind.py new file mode 100644 index 00000000..3b01133f --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/latebind.py @@ -0,0 +1,63 @@ +"""Late-bound base-class (with acceleration)""" +from OpenGL import acceleratesupport +LateBind = Curry = None +if acceleratesupport.ACCELERATE_AVAILABLE: + try: + from OpenGL_accelerate.latebind import LateBind, Curry + except ImportError as err: + pass +if LateBind is None: + class LateBind(object): + """Provides a __call__ which dispatches to self._finalCall + + When called without self._finalCall() makes a call to + self.finalise() and then calls self._finalCall() + """ + _finalCall = None + def setFinalCall( self, finalCall ): + """Set our finalCall to the callable object given""" + self._finalCall = finalCall + def getFinalCall( self ): + """Retrieve and/or bind and retrieve final call""" + if not self._finalCall: + self._finalCall = self.finalise() + return self._finalCall + + + def finalise( self ): + """Finalise our target to our final callable object + + return final callable + """ + def __nonzero__(self): + """Resolve our final call and check for empty/nonzero on it""" + return bool(self.getFinalCall()) + def __call__( self, *args, **named ): + """Call self._finalCall, calling finalise() first if not already called + + There's actually *no* reason to unpack and repack the arguments, + but unfortunately I don't know of a Cython syntax to specify + that. + """ + try: + return self._finalCall( *args, **named ) + except (TypeError,AttributeError) as err: + if self._finalCall is None: + self._finalCall = self.finalise() + return self._finalCall( *args, **named ) +if Curry is None: + class Curry(object): + """Provides a simple Curry which can bind (only) the first element + + This is used by lazywrapper, which explains the weird naming + of the two attributes... + """ + wrapperFunction = None + baseFunction = None + def __init__( self, wrapperFunction, baseFunction ): + """Stores self.wrapperFunction and self.baseFunction""" + self.baseFunction = baseFunction + self.wrapperFunction = wrapperFunction + def __call__( self, *args, **named ): + """returns self.wrapperFunction( self.baseFunction, *args, **named )""" + return self.wrapperFunction( self.baseFunction, *args, **named ) diff --git a/venv/lib/python3.12/site-packages/OpenGL/lazywrapper.py b/venv/lib/python3.12/site-packages/OpenGL/lazywrapper.py new file mode 100644 index 00000000..9f955c35 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/lazywrapper.py @@ -0,0 +1,59 @@ +"""Simplistic wrapper decorator for Python-coded wrappers""" +from OpenGL.latebind import Curry +from OpenGL import MODULE_ANNOTATIONS + +class _LazyWrapper( Curry ): + """Marker to tell us that an object is a lazy wrapper""" + +def lazy( baseFunction ): + """Produce a lazy-binding decorator that uses baseFunction + + Allows simple implementation of wrappers where the + whole of the wrapper can be summed up as do 1 thing + then call base function with the cleaned up result. + + Passes baseFunction in as the first argument of the + wrapped function, all other parameters are passed + unchanged. The wrapper class created has __nonzero__ + and similar common wrapper entry points defined. + """ + def wrap( wrapper ): + """Wrap wrapper with baseFunction""" + def __bool__( self ): + return bool( baseFunction ) + def __repr__( self ): + return '%s( %r )'%( + 'OpenGL.lazywrapper.lazy', + baseFunction.__name__, + ) + _with_wrapper = type( wrapper.__name__, (_LazyWrapper,), { + '__repr__': __repr__, + '__doc__': wrapper.__doc__, + '__nonzero__': __bool__, + '__bool__': __bool__, + 'wrappedOperation': baseFunction, + 'restype': getattr(wrapper, 'restype',getattr(baseFunction,'restype',None)), + } ) + with_wrapper = _with_wrapper(wrapper,baseFunction) + with_wrapper.__name__ = wrapper.__name__ + if hasattr( baseFunction, '__module__' ): + with_wrapper.__module__ = baseFunction.__module__ + return with_wrapper + return wrap + + +if __name__ == "__main__": + from OpenGL.raw import GLU + func = GLU.gluNurbsCallbackData + output = [] + def testwrap( base ): + "Testing" + output.append( base ) + testlazy = lazy( func )( testwrap ) + testlazy( ) + assert testlazy.__doc__ == "Testing" + assert testlazy.__class__.__name__ == 'testwrap' + assert testlazy.__name__ == 'testwrap' + assert testlazy.baseFunction is func + assert testlazy.wrapperFunction is testwrap + assert output diff --git a/venv/lib/python3.12/site-packages/OpenGL/logs.py b/venv/lib/python3.12/site-packages/OpenGL/logs.py new file mode 100644 index 00000000..0c60c50d --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/logs.py @@ -0,0 +1,91 @@ +"""Fix missing-API problems in logging module (circa Python 2.3) + +Adds constants to the log objects. +Adds getException(err) to log objects to retrieve +formatted exception or err if traceback not available. +""" +import traceback, logging +from OpenGL._configflags import ERROR_LOGGING, FULL_LOGGING +getLog = logging.getLogger + +def getException(error): + """Get formatted traceback from exception""" + try: + return traceback.format_exc( limit=10 ) + except Exception as err: + return str( error ) + +logging.Logger.getException = staticmethod( getException ) +logging.Logger.err = logging.Logger.error +logging.Logger.DEBUG = logging.DEBUG +logging.Logger.WARN = logging.WARN +logging.Logger.INFO = logging.INFO +logging.Logger.ERR = logging.Logger.ERROR = logging.ERROR + +if FULL_LOGGING: + getLog( 'OpenGL.calltrace' ).setLevel( logging.INFO ) + +class _LoggedFunction( object ): + """Proxy that overrides __call__ to log arguments""" + def __init__( self, base, log ): + self.__dict__[''] = base + self.__dict__['log'] = log + def __setattr__( self, key, value ): + if key != '': + setattr( self.__dict__[''], key, value ) + else: + self.__dict__[''] = value + def __getattr__( self, key ): + if key == '': + return self.__dict__[''] + else: + return getattr( self.__dict__[''], key ) +class _FullLoggedFunction( _LoggedFunction ): + """Fully-logged function wrapper (logs all call params to OpenGL.calltrace)""" + _callTrace = getLog( 'OpenGL.calltrace' ) + def __call__( self, *args, **named ): + argRepr = [] + function = getattr( self, '' ) + for arg in args: + argRepr.append( repr(arg) ) + for key,value in named.items(): + argRepr.append( '%s = %s'%( key,repr(value)) ) + argRepr = ",".join( argRepr ) + self._callTrace.info( '%s( %s )', function.__name__, argRepr ) + try: + return function( *args, **named ) + except Exception as err: + self.log.warning( + """Failure on %s: %s""", function.__name__, self.log.getException( err ) + ) + raise +class _ErrorLoggedFunction ( _LoggedFunction ): + """On-error-logged function wrapper""" + def __call__( self, *args, **named ): + function = getattr( self, '' ) + try: + return function( *args, **named ) + except Exception as err: + self.log.warning( + """Failure on %s: %s""", function.__name__, self.log.getException( err ) + ) + raise + + +def logOnFail( function, log ): + """Produce possible log-wrapped version of function + + function -- callable object to be wrapped + log -- the log to which to log information + + Uses ERROR_LOGGING and FULL_LOGGING + to determine whether/how to wrap the function. + """ + if ERROR_LOGGING or FULL_LOGGING: + if FULL_LOGGING: + loggedFunction = _FullLoggedFunction( function, log ) + else: + loggedFunction = _ErrorLoggedFunction( function, log ) + return loggedFunction + else: + return function diff --git a/venv/lib/python3.12/site-packages/OpenGL/osmesa/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/osmesa/__init__.py new file mode 100644 index 00000000..9904ed39 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/osmesa/__init__.py @@ -0,0 +1,2 @@ +from OpenGL.raw.osmesa._types import * +from OpenGL.raw.osmesa.mesa import * diff --git a/venv/lib/python3.12/site-packages/OpenGL/osmesa/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/osmesa/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..e57f8c05 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/osmesa/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/platform/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/platform/__init__.py new file mode 100644 index 00000000..0d621556 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/platform/__init__.py @@ -0,0 +1,98 @@ +"""Abstraction for the platform-specific code in PyOpenGL + +Each supported platform has a module which provides the +specific functionality required to support the base OpenGL +functionality on that platform. These modules are +registered using plugins in the: + + OpenGL.plugin.PlatformPlugin + +objects. To support a new platform you'll need to create +a new PlatformPlugin instance *before* you import +OpenGL.platform . Once you have a working platform +module, please consider contributing it back to the project. + +See baseplatform.BasePlatform for the core functionality +of a platform implementation. See the various platform +specific modules for examples to use when porting. +""" +import os, sys +from OpenGL.plugins import PlatformPlugin +from OpenGL import _configflags + +XDG = 'XDG_SESSION_TYPE' +WAYLAND_DISPLAY = 'WAYLAND_DISPLAY' + +def _load( ): + """Load the os.name plugin for the platform functionality""" + # Linux override keys... + guessing_key = None + if ( + sys.platform in ('linux','linux2') + and not 'PYOPENGL_PLATFORM' in os.environ + ): + if 'WAYLAND_DISPLAY' in os.environ: + guessing_key = 'wayland' + elif 'DISPLAY' in os.environ: + guessing_key = 'linux' + + key = ( + os.environ.get( 'PYOPENGL_PLATFORM'), + os.environ.get( 'XDG_SESSION_TYPE','').lower(), + guessing_key, + sys.platform, + os.name, + ) + plugin = PlatformPlugin.match( key ) + plugin_class = plugin.load() + plugin.loaded = True + # create instance of this platform implementation + plugin = plugin_class() + + # install into the platform module's namespace now + plugin.install(globals()) + return plugin + +_load() + +def types(resultType,*argTypes): + """Decorator to add returnType, argTypes and argNames to a function""" + def add_types( function ): + """Adds the given metadata to the function, introspects var names from declaration""" + function.resultType = resultType + function.argTypes = argTypes + if hasattr( function, 'func_code' ): # python 2.x + function.argNames = function.func_code.co_varnames + else: + function.argNames = function.__code__.co_varnames + if _configflags.TYPE_ANNOTATIONS: + function.__annotations__ = { + 'return': resultType, + } + for name,typ in zip(function.argNames,argTypes): + function.__annotations__[name] = typ + return function + return add_types + +def unpack_constants( constants, namespace ): + """Create constants and add to the namespace""" + from OpenGL.constant import Constant + for line in constants.splitlines(): + if line and line.split(): + name,value = line.split() + namespace[name] = Constant( name, int(value,16) ) + +def createFunction( function, dll,extension, deprecated=False, error_checker=None, force_extension=False ): + """Allows the more compact declaration format to use the old-style constructor""" + return nullFunction( + function.__name__, + dll or PLATFORM.GL, + resultType = function.resultType, + argTypes = function.argTypes, + doc = None, argNames = function.argNames, + extension = extension, + deprecated = deprecated, + module = function.__module__, + error_checker = error_checker, + force_extension = force_extension or getattr(function,'force_extension',force_extension), + ) diff --git a/venv/lib/python3.12/site-packages/OpenGL/platform/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/platform/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..4fcc1057 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/platform/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/platform/__pycache__/baseplatform.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/platform/__pycache__/baseplatform.cpython-312.pyc new file mode 100644 index 00000000..fef797a7 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/platform/__pycache__/baseplatform.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/platform/__pycache__/ctypesloader.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/platform/__pycache__/ctypesloader.cpython-312.pyc new file mode 100644 index 00000000..553ada1c Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/platform/__pycache__/ctypesloader.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/platform/__pycache__/darwin.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/platform/__pycache__/darwin.cpython-312.pyc new file mode 100644 index 00000000..84f7d821 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/platform/__pycache__/darwin.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/platform/__pycache__/egl.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/platform/__pycache__/egl.cpython-312.pyc new file mode 100644 index 00000000..456219de Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/platform/__pycache__/egl.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/platform/__pycache__/entrypoint31.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/platform/__pycache__/entrypoint31.cpython-312.pyc new file mode 100644 index 00000000..57dc926a Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/platform/__pycache__/entrypoint31.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/platform/__pycache__/glx.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/platform/__pycache__/glx.cpython-312.pyc new file mode 100644 index 00000000..194ec2f6 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/platform/__pycache__/glx.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/platform/__pycache__/osmesa.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/platform/__pycache__/osmesa.cpython-312.pyc new file mode 100644 index 00000000..def4568c Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/platform/__pycache__/osmesa.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/platform/__pycache__/win32.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/platform/__pycache__/win32.cpython-312.pyc new file mode 100644 index 00000000..72fa405f Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/platform/__pycache__/win32.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/platform/baseplatform.py b/venv/lib/python3.12/site-packages/OpenGL/platform/baseplatform.py new file mode 100644 index 00000000..645f371e --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/platform/baseplatform.py @@ -0,0 +1,437 @@ +"""Base class for platform implementations +""" +import ctypes +from OpenGL.platform import ctypesloader +from OpenGL._bytes import as_8_bit +import sys, logging +from OpenGL import _configflags +from OpenGL import logs, MODULE_ANNOTATIONS +log = logging.getLogger(__name__) + +class lazy_property( object ): + def __init__( self, function ): + self.fget = function + def __get__( self, obj, cls ): + value = self.fget( obj ) + setattr( obj, self.fget.__name__, value) + return value + +class _CheckContext( object ): + def __init__( self, func, ccisvalid ): + self.func = func + self.ccisvalid = ccisvalid + def __setattr__( self, key, value ): + if key not in ('func','ccisvalid'): + return setattr( self.func, key, value ) + else: + self.__dict__[key] = value + def __repr__( self ): + if getattr( self.func, '__doc__', None ): + return self.func.__doc__ + else: + return repr( self.func ) + def __getattr__( self, key ): + if key != 'func': + return getattr(self.func, key ) + raise AttributeError( key ) + def __call__( self, *args, **named ): + if not self.ccisvalid(): + from OpenGL import error + raise error.NoContext( self.func.__name__, args, named ) + return self.func( *args, **named ) + +def _find_module( exclude = (__name__,)): + frame = sys._getframe() + while frame and '__name__' in frame.f_globals: + if exclude: + if not frame.f_globals['__name__'] in exclude: + return frame.f_globals['__name__'] + + else: + return frame.f_globals['__name__'] + frame = frame.f_back + return None + +class BasePlatform( object ): + """Base class for per-platform implementations + + Attributes of note: + + EXPORTED_NAMES -- set of names exported via the platform + module's namespace... + + GL, GLU, GLUT, GLE, GLES1, GLES2, GLES3 -- ctypes libraries + + DEFAULT_FUNCTION_TYPE -- used as the default function + type for functions unless overridden on a per-DLL + basis with a "FunctionType" member + + GLUT_GUARD_CALLBACKS -- if True, the GLUT wrappers + will provide guarding wrappers to prevent GLUT + errors with uninitialised GLUT. + + EXTENSIONS_USE_BASE_FUNCTIONS -- if True, uses regular + dll attribute-based lookup to retrieve extension + function pointers. + """ + + EXPORTED_NAMES = [ + 'GetCurrentContext', + 'CurrentContextIsValid', + 'createBaseFunction', + 'createExtensionFunction', + 'copyBaseFunction', + 'getGLUTFontPointer', + 'nullFunction', + 'GLUT_GUARD_CALLBACKS', + ] + + + DEFAULT_FUNCTION_TYPE = None + GLUT_GUARD_CALLBACKS = False + EXTENSIONS_USE_BASE_FUNCTIONS = False + + def install( self, namespace ): + """Install this platform instance into the platform module""" + for name in self.EXPORTED_NAMES: + namespace[ name ] = getattr(self,name,None) + namespace['PLATFORM'] = self + return self + + def functionTypeFor( self, dll ): + """Given a DLL, determine appropriate function type...""" + if hasattr( dll, 'FunctionType' ): + return dll.FunctionType + else: + return self.DEFAULT_FUNCTION_TYPE + + def errorChecking( self, func, dll, error_checker=None ): + """Add error checking to the function if appropriate""" + from OpenGL import error + if error_checker and _configflags.ERROR_CHECKING: + #GLUT spec says error-checking is basically undefined... + # there *may* be GL errors on GLUT calls that e.g. render + # geometry, but that's all basically "maybe" stuff... + func.errcheck = error_checker.glCheckError + return func + def wrapContextCheck( self, func, dll ): + """Wrap function with context-checking if appropriate""" + if _configflags.CONTEXT_CHECKING and dll is self.GL and func.__name__ not in ( + 'glGetString', + 'glGetStringi', + 'glGetIntegerv', + ) and not func.__name__.startswith( 'glX' ): + return _CheckContext( func, self.CurrentContextIsValid ) + return func + def wrapLogging( self, func ): + """Wrap function with logging operations if appropriate""" + return logs.logOnFail( func, logs.getLog( 'OpenGL.errors' )) + + def finalArgType( self, typ ): + """Retrieve a final type for arg-type""" + if typ == ctypes.POINTER( None ) and not getattr( typ, 'final',False): + from OpenGL.arrays import ArrayDatatype + return ArrayDatatype + else: + return typ + def constructFunction( + self, + functionName, dll, + resultType=ctypes.c_int, argTypes=(), + doc = None, argNames = (), + extension = None, + deprecated = False, + module = None, + force_extension = False, + error_checker = None, + ): + """Core operation to create a new base ctypes function + + raises AttributeError if can't find the procedure... + """ + is_core = (not extension) or extension.split('_')[1] == 'VERSION' + if (not is_core) and not self.checkExtension( extension ): + raise AttributeError( """Extension not available""" ) + argTypes = [ self.finalArgType( t ) for t in argTypes ] + + if force_extension or ((not is_core) and (not self.EXTENSIONS_USE_BASE_FUNCTIONS)): + # what about the VERSION values??? + pointer = self.getExtensionProcedure( as_8_bit(functionName) ) + if pointer: + func = self.functionTypeFor( dll )( + resultType, + *argTypes + )( + pointer + ) + else: + raise AttributeError( """Extension %r available, but no pointer for function %r"""%(extension,functionName)) + else: + func = ctypesloader.buildFunction( + self.functionTypeFor( dll )( + resultType, + *argTypes + ), + functionName, + dll, + ) + func.__doc__ = doc + func.argNames = list(argNames or ()) + func.__name__ = functionName + func.DLL = dll + func.extension = extension + func.deprecated = deprecated + func = self.wrapLogging( + self.wrapContextCheck( + self.errorChecking( func, dll, error_checker=error_checker ), + dll, + ) + ) + if MODULE_ANNOTATIONS: + if not module: + module = _find_module( ) + if module: + func.__module__ = module + return func + + def createBaseFunction( + self, + functionName, dll, + resultType=ctypes.c_int, argTypes=(), + doc = None, argNames = (), + extension = None, + deprecated = False, + module = None, + error_checker = None, + ): + """Create a base function for given name + + Normally you can just use the dll.name hook to get the object, + but we want to be able to create different bindings for the + same function, so we do the work manually here to produce a + base function from a DLL. + """ + from OpenGL import wrapper + result = None + try: + if ( + _configflags.FORWARD_COMPATIBLE_ONLY and + dll is self.GL and + deprecated + ): + result = self.nullFunction( + functionName, dll=dll, + resultType=resultType, + argTypes=argTypes, + doc = doc, argNames = argNames, + extension = extension, + deprecated = deprecated, + error_checker = error_checker, + ) + else: + result = self.constructFunction( + functionName, dll, + resultType=resultType, argTypes=argTypes, + doc = doc, argNames = argNames, + extension = extension, + error_checker = error_checker, + ) + except AttributeError as err: + result = self.nullFunction( + functionName, dll=dll, + resultType=resultType, + argTypes=argTypes, + doc = doc, argNames = argNames, + extension = extension, + error_checker = error_checker, + ) + if MODULE_ANNOTATIONS: + if not module: + module = _find_module( ) + if module: + result.__module__ = module + return result + def checkExtension( self, name ): + """Check whether the given extension is supported by current context""" +# if not name or name in ('GL_VERSION_GL_1_0', 'GL_VERSION_GL_1_1'): +# return True +# if name.startswith( 'EGL_' ) or name.startswith( 'GLX_' ) or name.startswith( 'WGL_' ): +# # we can't check these extensions, have to rely on the function resolution +# return True + if not name: + return True + context = self.GetCurrentContext() + if context: + from OpenGL import contextdata + set = contextdata.getValue( 'extensions', context=context ) + if set is None: + set = {} + contextdata.setValue( + 'extensions', set, context=context, weak=False + ) + current = set.get( name ) + if current is None: + from OpenGL import extensions + result = extensions.ExtensionQuerier.hasExtension( name ) + set[name] = result + return result + return current + else: + from OpenGL import extensions + return extensions.ExtensionQuerier.hasExtension( name ) + createExtensionFunction = createBaseFunction + + def copyBaseFunction( self, original ): + """Create a new base function based on an already-created function + + This is normally used to provide type-specific convenience versions of + a definition created by the automated generator. + """ + from OpenGL import wrapper, error + if isinstance( original, _NullFunctionPointer ): + return self.nullFunction( + original.__name__, + original.DLL, + resultType = original.restype, + argTypes= original.argtypes, + doc = original.__doc__, + argNames = original.argNames, + extension = original.extension, + deprecated = original.deprecated, + error_checker = original.error_checker, + ) + elif hasattr( original, 'originalFunction' ): + original = original.originalFunction + return self.createBaseFunction( + original.__name__, original.DLL, + resultType=original.restype, argTypes=original.argtypes, + doc = original.__doc__, argNames = original.argNames, + extension = original.extension, + deprecated = original.deprecated, + error_checker = original.errcheck, + ) + def nullFunction( + self, + functionName, dll, + resultType=ctypes.c_int, + argTypes=(), + doc = None, argNames = (), + extension = None, + deprecated = False, + module = None, + error_checker = None, + force_extension = False, + ): + """Construct a "null" function pointer""" + if deprecated: + base = _DeprecatedFunctionPointer + else: + base = _NullFunctionPointer + cls = type( functionName, (base,), { + '__doc__': doc, + 'deprecated': deprecated, + } ) + if MODULE_ANNOTATIONS: + if not module: + module = _find_module( ) + if module: + cls.__module__ = module + return cls( + functionName, dll, resultType, argTypes, argNames, extension=extension, doc=doc, + error_checker = error_checker, force_extension=force_extension, + ) + def GetCurrentContext( self ): + """Retrieve opaque pointer for the current context""" + raise NotImplementedError( + """Platform does not define a GetCurrentContext function""" + ) + def getGLUTFontPointer(self, constant ): + """Retrieve a GLUT font pointer for this platform""" + raise NotImplementedError( + """Platform does not define a GLUT font retrieval function""" + ) + # names that are normally just references to other items... + @lazy_property + def CurrentContextIsValid( self ): + return self.GetCurrentContext + @lazy_property + def OpenGL(self): return self.GL + +class _NullFunctionPointer( object ): + """Function-pointer-like object for undefined functions""" + def __init__( + self, name, dll, resultType, argTypes, argNames, + extension=None, doc=None, deprecated=False, + error_checker = None, force_extension=None, + ): + from OpenGL import error + self.__name__ = name + self.DLL = dll + self.argNames = argNames + self.argtypes = argTypes + self.errcheck = None + self.restype = resultType + self.extension = extension + self.doc = doc + self.deprecated = deprecated + self.error_checker = error_checker + self.force_extension = force_extension + resolved = False + def __nonzero__( self ): + """Make this object appear to be NULL""" + if (not self.resolved) and (self.extension or self.force_extension): + self.load() + return self.resolved + __bool__ = __nonzero__ + def load( self ): + """Attempt to load the function again, presumably with a context this time""" + try: + from OpenGL import platform + except ImportError: + if log: + log.info('Platform import failed (likely during shutdown)') + return None + try: + func = platform.PLATFORM.constructFunction( + self.__name__, self.DLL, + resultType=self.restype, + argTypes=self.argtypes, + doc = self.doc, + argNames = self.argNames, + extension = self.extension, + error_checker = self.error_checker, + force_extension = self.force_extension, + ) + except AttributeError as err: + return None + else: + # now short-circuit so that we don't need to check again... + self.__class__.__call__ = staticmethod( func.__call__ ) + self.resolved = True + return func + return None + def __call__( self, *args, **named ): + if self.load(): + return self( *args, **named ) + else: + try: + from OpenGL import error + except ImportError as err: + # Python interpreter is shutting down... + pass + else: + raise error.NullFunctionError( + """Attempt to call an undefined function %s, check for bool(%s) before calling"""%( + self.__name__, self.__name__, + ) + ) + +class _DeprecatedFunctionPointer( _NullFunctionPointer ): + deprecated = True + def __call__( self, *args, **named ): + from OpenGL import error + raise error.NullFunctionError( + """Attempt to call a deprecated function %s while OpenGL in FORWARD_COMPATIBLE_ONLY mode. Set OpenGL.FORWARD_COMPATIBLE_ONLY to False to use legacy entry points"""%( + self.__name__, + ) + ) diff --git a/venv/lib/python3.12/site-packages/OpenGL/platform/ctypesloader.py b/venv/lib/python3.12/site-packages/OpenGL/platform/ctypesloader.py new file mode 100644 index 00000000..d9ff0069 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/platform/ctypesloader.py @@ -0,0 +1,96 @@ +"""ctypes abstraction layer + +We keep rewriting functions as the main entry points change, +so let's just localise the changes here... +""" +import ctypes, logging, os, sys +_log = logging.getLogger( 'OpenGL.platform.ctypesloader' ) +#_log.setLevel( logging.DEBUG ) +ctypes_version = [ + int(x) for x in ctypes.__version__.split('.') +] +from ctypes import util +import OpenGL + +DLL_DIRECTORY = os.path.join( os.path.dirname( OpenGL.__file__ ), 'DLLS' ) + +def loadLibrary( dllType, name, mode = ctypes.RTLD_GLOBAL ): + """Load a given library by name with the given mode + + dllType -- the standard ctypes pointer to a dll type, such as + ctypes.cdll or ctypes.windll or the underlying ctypes.CDLL or + ctypes.WinDLL classes. + name -- a short module name, e.g. 'GL' or 'GLU' + mode -- ctypes.RTLD_GLOBAL or ctypes.RTLD_LOCAL, + controls whether the module resolves names via other + modules already loaded into this process. GL modules + generally need to be loaded with GLOBAL flags + + returns the ctypes C-module object + """ + if isinstance( dllType, ctypes.LibraryLoader ): + dllType = dllType._dlltype + if sys.platform.startswith('linux'): + return _loadLibraryPosix(dllType, name, mode) + else: + return _loadLibraryWindows(dllType, name, mode) + + +def _loadLibraryPosix(dllType, name, mode): + """Load a given library for posix systems + + The problem with util.find_library is that it does not respect linker runtime variables like + LD_LIBRARY_PATH. + + Also we cannot rely on libGLU.so to be available, for example. Most of Linux distributions will + ship only libGLU.so.1 by default. Files ending with .so are normally used when compiling and are + provided by dev packages. + + returns the ctypes C-module object + """ + prefix = 'lib' + suffix = '.so' + base_name = prefix + name + suffix + + filenames_to_try = [base_name] + # If a .so is missing, let's try libs with so version (e.g libGLU.so.9, libGLU.so.8 and so on) + filenames_to_try.extend(list(reversed([ + base_name + '.%i' % i for i in range(0, 10) + ]))) + err = None + + for filename in filenames_to_try: + try: + result = dllType(filename, mode) + _log.debug( 'Loaded %s => %s %s', base_name, filename, result) + return result + except Exception as current_err: + err = current_err + + _log.info('''Failed to load library ( %r ): %s''', filename, err or 'No filenames available to guess?') + +def _loadLibraryWindows(dllType, name, mode): + """Load a given library for Windows systems + + returns the ctypes C-module object + """ + fullName = None + try: + fullName = util.find_library( name ) + if fullName is not None: + name = fullName + elif os.path.isfile( os.path.join( DLL_DIRECTORY, name + '.dll' )): + name = os.path.join( DLL_DIRECTORY, name + '.dll' ) + except Exception as err: + _log.info( '''Failed on util.find_library( %r ): %s''', name, err ) + # Should the call fail, we just try to load the base filename... + pass + try: + return dllType( name, mode ) + except Exception as err: + err.args += (name,fullName) + raise + +def buildFunction( functionType, name, dll ): + """Abstract away the ctypes function-creation operation""" + return functionType( (name, dll), ) diff --git a/venv/lib/python3.12/site-packages/OpenGL/platform/darwin.py b/venv/lib/python3.12/site-packages/OpenGL/platform/darwin.py new file mode 100644 index 00000000..bc0516bb --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/platform/darwin.py @@ -0,0 +1,83 @@ +"""Darwin (MacOSX)-specific platform features + +This was implemented with the help of the following links: +[1] Apple's Mac OS X OpenGL interfaces: http://developer.apple.com/qa/qa2001/qa1269.html +[2] As above, but updated: http://developer.apple.com/documentation/GraphicsImaging/Conceptual/OpenGL-MacProgGuide/opengl_pg_concepts/chapter_2_section_3.html +[3] CGL reference: http://developer.apple.com/documentation/GraphicsImaging/Reference/CGL_OpenGL/index.html#//apple_ref/doc/uid/TP40001186 +[4] Intro to OpenGL on Mac OS X: http://developer.apple.com/documentation/GraphicsImaging/Conceptual/OpenGL-MacProgGuide/opengl_intro/chapter_1_section_1.html#//apple_ref/doc/uid/TP40001987-CH207-TP9 + +About the CGL API, (from [1]): +CGL or Core OpenGL is the lowest accessible interface API for OpenGL. +It knows nothing about windowing systems but can be used directly to +find both renderer information and as a full screen or off screen +interface. It is accessible from both Cocoa and Carbon and is what both +NSGL and AGL are built on. A complete Pbuffer interface is also provided. +Functionality is provided in via the OpenGL framework and applications +can include the OpenGL.h header to access CGL's functionality. Developers +can see an example of using CGL with Carbon in the Carbon CGL code sample. + +Documentation and header files are found in: +/System/Library/Frameworks/OpenGL.framework +/System/Library/Frameworks/GLUT.framework + +""" +import ctypes, ctypes.util +from OpenGL.platform import baseplatform, ctypesloader + +class DarwinPlatform( baseplatform.BasePlatform ): + """Darwin (OSX) platform implementation""" + DEFAULT_FUNCTION_TYPE = staticmethod( ctypes.CFUNCTYPE ) + EXTENSIONS_USE_BASE_FUNCTIONS = True + + @baseplatform.lazy_property + def GL(self): + try: + return ctypesloader.loadLibrary( + ctypes.cdll, + 'OpenGL', + mode=ctypes.RTLD_GLOBAL + ) + except OSError as err: + raise ImportError("Unable to load OpenGL library", *err.args) + @baseplatform.lazy_property + def GLU(self): return self.GL + @baseplatform.lazy_property + def CGL(self): return self.GL + + @baseplatform.lazy_property + def GLUT( self ): + try: + return ctypesloader.loadLibrary( + ctypes.cdll, + 'GLUT', + mode=ctypes.RTLD_GLOBAL + ) + except OSError: + return None + @baseplatform.lazy_property + def GLE(self): return self.GLUT + + @baseplatform.lazy_property + def GetCurrentContext( self ): + return self.CGL.CGLGetCurrentContext + + def getGLUTFontPointer( self, constant ): + """Platform specific function to retrieve a GLUT font pointer + + GLUTAPI void *glutBitmap9By15; + #define GLUT_BITMAP_9_BY_15 (&glutBitmap9By15) + + Key here is that we want the addressof the pointer in the DLL, + not the pointer in the DLL. That is, our pointer is to the + pointer defined in the DLL, we don't want the *value* stored in + that pointer. + """ + name = [ x.title() for x in constant.split( '_' )[1:] ] + internal = 'glut' + "".join( [x.title() for x in name] ) + pointer = ctypes.c_void_p.in_dll( self.GLUT, internal ) + return ctypes.c_void_p(ctypes.addressof(pointer)) + + @baseplatform.lazy_property + def glGetError( self ): + return self.GL.glGetError + diff --git a/venv/lib/python3.12/site-packages/OpenGL/platform/egl.py b/venv/lib/python3.12/site-packages/OpenGL/platform/egl.py new file mode 100644 index 00000000..55fbb0be --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/platform/egl.py @@ -0,0 +1,122 @@ +"""EGL (cross-platform) platform library""" +import ctypes, ctypes.util +from OpenGL.platform import baseplatform, ctypesloader + +class EGLPlatform( baseplatform.BasePlatform ): + """EGL platform for opengl-es only platforms""" + @baseplatform.lazy_property + def GLES1(self): + try: + return ctypesloader.loadLibrary( + ctypes.cdll, + 'GLESv1_CM', # ick + mode=ctypes.RTLD_GLOBAL + ) + except OSError: + return None + @baseplatform.lazy_property + def GLES2(self): + try: + return ctypesloader.loadLibrary( + ctypes.cdll, + 'GLESv2', + mode=ctypes.RTLD_GLOBAL + ) + except OSError: + return None + @baseplatform.lazy_property + def GLES3(self): + # implementers guide says to use the same name for the DLL + return self.GLES2 + @baseplatform.lazy_property + def GL(self): + try: + for name in ('OpenGL','GL'): + lib = ctypesloader.loadLibrary( + ctypes.cdll, + name, + mode=ctypes.RTLD_GLOBAL + ) + if lib: + return lib + raise OSError("No GL/OpenGL library available") + except OSError: + return self.GLES2 or self.GLES1 + @baseplatform.lazy_property + def GLU(self): + try: + return ctypesloader.loadLibrary( + ctypes.cdll, + 'GLU', + mode=ctypes.RTLD_GLOBAL + ) + except OSError: + return None + @baseplatform.lazy_property + def GLUT( self ): + try: + return ctypesloader.loadLibrary( + ctypes.cdll, + 'glut', + mode=ctypes.RTLD_GLOBAL + ) + except OSError: + return None + @baseplatform.lazy_property + def OpenGL(self): return self.GL + + @baseplatform.lazy_property + def EGL(self): + # TODO: the raspberry pi crashes on trying to load EGL module + # because the EGL library requires a structure from GLES2 without + # linking to that library... Github issue is here: + # https://github.com/raspberrypi/firmware/issues/110 + import os + if os.path.exists('/proc/cpuinfo'): + info = open('/proc/cpuinfo').read() + if 'BCM2708' in info or 'BCM2709' in info: + assert self.GLES2 + try: + return ctypesloader.loadLibrary( + ctypes.cdll, + 'EGL', + mode=ctypes.RTLD_GLOBAL + ) + except OSError as err: + raise ImportError("Unable to load EGL library", *err.args) + @baseplatform.lazy_property + def getExtensionProcedure( self ): + eglGetProcAddress = self.EGL.eglGetProcAddress + eglGetProcAddress.restype = ctypes.c_void_p + return eglGetProcAddress + @baseplatform.lazy_property + def GLE( self ): + try: + return ctypesloader.loadLibrary( + ctypes.cdll, + 'gle', + mode=ctypes.RTLD_GLOBAL + ) + except OSError: + return None + + DEFAULT_FUNCTION_TYPE = staticmethod( ctypes.CFUNCTYPE ) + @baseplatform.lazy_property + def GetCurrentContext( self ): + return self.EGL.eglGetCurrentContext + + def getGLUTFontPointer( self, constant ): + """Platform specific function to retrieve a GLUT font pointer + + GLUTAPI void *glutBitmap9By15; + #define GLUT_BITMAP_9_BY_15 (&glutBitmap9By15) + + Key here is that we want the addressof the pointer in the DLL, + not the pointer in the DLL. That is, our pointer is to the + pointer defined in the DLL, we don't want the *value* stored in + that pointer. + """ + name = [ x.title() for x in constant.split( '_' )[1:] ] + internal = 'glut' + "".join( [x.title() for x in name] ) + pointer = ctypes.c_void_p.in_dll( self.GLUT, internal ) + return ctypes.c_void_p(ctypes.addressof(pointer)) diff --git a/venv/lib/python3.12/site-packages/OpenGL/platform/entrypoint31.py b/venv/lib/python3.12/site-packages/OpenGL/platform/entrypoint31.py new file mode 100644 index 00000000..a729275a --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/platform/entrypoint31.py @@ -0,0 +1,192 @@ +"""List of forward-compatible entry points for OpenGL 3.1 + +Taken from the list at: + + http://www.devklog.net/2008/08/23/forward-compatible-opengl-3-entry-points/ +""" +records = """glActiveTexture +glAttachShader +glBeginConditionalRender +glBeginQuery +glBeginTransformFeedback +glBindAttribLocation +glBindBuffer +glBindBufferBase +glBindBufferRange +glBindFragDataLocation +glBindFramebuffer +glBindRenderbuffer +glBindTexture +glBindVertexArray +glBlendColor +glBlendEquation +glBlendEquationSeparate +glBlendFunc +glBlendFuncSeparate +glBlitFramebuffer +glBufferData +glBufferSubData +glCheckFramebufferStatus +glClampColor +glClear +glClearBuffer* +glClearColor +glClearDepth +glClearStencil +glClipPlane +glColorMask* +glCompileShader +glCompressedTexImage* +glCompressedTexSubImage* +glCopyPixels +glCopyTexImage* +glCopyTexSubImage* +glCreateProgram +glCreateShader +glCullFace +glDeleteBuffers +glDeleteFramebuffers +glDeleteProgram +glDeleteQueries +glDeleteRenderbuffers +glDeleteShader +glDeleteTextures +glDeleteVertexArrays +glDepthFunc +glDepthMask +glDepthRange +glDetachShader +glDisable +glDisableVertexAttribArray +glDrawArrays +glDrawBuffer +glDrawBuffers +glDrawElements +glDrawRangeElements +glEnable +glEnableVertexAttribArray +glEndConditionalRender +glEndQuery +glEndTransformFeedback +glFinish +glFlush +glFlushMappedBufferRange +glFramebufferRenderbuffer +glFramebufferTexture* +glFramebufferTextureLayer +glFrontFace +glGenBuffers +glGenerateMipmap +glGenFramebuffers +glGenQueries +glGenRenderbuffers +glGenTextures +glGenVertexArrays +glGetActiveAttrib +glGetActiveUniform +glGetAttachedShaders +glGetAttribLocation +glGetBooleanv +glGetBufferParameter* +glGetBufferPointer* +glGetBufferSubData +glGetClipPlane +glGetCompressedTexImage +glGetDoublev +glGetError +glGetFloatv +glGetFragDataLocation +glGetFramebufferAttachmentParameter* +glGetIntegerv +glGetProgram* +glGetProgramInfoLog +glGetQuery* +glGetQueryObject* +glGetRenderbufferParameter* +glGetShader* +glGetShaderInfoLog +glGetShaderSource +glGetString +glGetTexEnv* +glGetTexImage +glGetTexLevelParameter* +glGetTexParameter* +glGetTransformFeedbackVaryings +glGetUniform* +glGetUniformLocation +glGetVertexAttrib* +glGetVertexAttribIPointer* +glGetVertexAttribPointer* +glHint +glIsBuffer +glIsEnabled +glIsFramebuffer +glIsProgram +glIsQuery +glIsRenderbuffer +glIsShader +glIsTexture +glIsVertexArray +glLineWidth +glLinkProgram +glLogicOp +glMapBuffer +glMapBufferRange +glMultiDrawArrays +glMultiDrawElements +glPixelStore* +glPointParameter* +glPointSize +glPolygonMode +glReadBuffer +glReadPixels +glRenderbufferStorage +glRenderbufferStorageMultisample +glSampleCoverage +glScissor +glShadeModel +glShaderSource +glStencilFunc +glStencilFuncSeparate +glStencilMask +glStencilMaskSeparate +glStencilOp +glStencilOpSeparate +glTexEnv +glTexImage* +glTexParameter* +glTexSubImage* +glTransformFeedbackVaryings +glUniform1* +glUniform2* +glUniform3* +glUniform4* +glUniformMatrix2* +glUniformMatrix2x3* +glUniformMatrix2x4* +glUniformMatrix3* +glUniformMatrix3x2* +glUniformMatrix3x4* +glUniformMatrix4* +glUniformMatrix4x2* +glUniformMatrix4x3* +glUnmapBuffer +glUseProgram +glValidateProgram +glVertexAttrib1* +glVertexAttrib2* +glVertexAttrib3* +glVertexAttrib4* +glVertexAttrib4N* +glVertexAttribI* +glVertexAttribI4 +glVertexAttribIPointer +glVertexAttribPointer +glViewport""".splitlines() +def deprecated( name ): + for allowed in records: + if name == allowed: + return False + elif allowed.endswith( '*' ) and allowed.startswith(name[:len(allowed)-1]): + return False + return True \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/platform/glx.py b/venv/lib/python3.12/site-packages/OpenGL/platform/glx.py new file mode 100644 index 00000000..3fd684ac --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/platform/glx.py @@ -0,0 +1,120 @@ +"""GLX (x-windows)-specific platform features""" +import ctypes, ctypes.util +from OpenGL.platform import baseplatform, ctypesloader + + +class GLXPlatform(baseplatform.BasePlatform): + """Posix (Linux, FreeBSD, etceteras) implementation for PyOpenGL""" + + # On Linux (and, I assume, most GLX platforms, we have to load + # GL and GLU with the "global" flag to allow GLUT to resolve its + # references to GL/GLU functions). + @baseplatform.lazy_property + def GL(self): + try: + return ctypesloader.loadLibrary( + ctypes.cdll, "OpenGL", mode=ctypes.RTLD_GLOBAL + ) + except OSError as err: + try: + # libGL was the original name, older devices likely still need it... + return ctypesloader.loadLibrary( + ctypes.cdll, "GL", mode=ctypes.RTLD_GLOBAL + ) + except OSError as err: + raise ImportError("Unable to load OpenGL library", *err.args) + + @baseplatform.lazy_property + def GLU(self): + try: + return ctypesloader.loadLibrary(ctypes.cdll, "GLU", mode=ctypes.RTLD_GLOBAL) + except OSError: + return None + + @baseplatform.lazy_property + def GLUT(self): + try: + return ctypesloader.loadLibrary( + ctypes.cdll, "glut", mode=ctypes.RTLD_GLOBAL + ) + except OSError: + return None + + @baseplatform.lazy_property + def GLX(self): + try: + return ctypesloader.loadLibrary(ctypes.cdll, "GLX", mode=ctypes.RTLD_GLOBAL) + except OSError as err: + return self.GL + + @baseplatform.lazy_property + def GLES1(self): + try: + return ctypesloader.loadLibrary( + ctypes.cdll, "GLESv1_CM", mode=ctypes.RTLD_GLOBAL # ick + ) + except OSError: + return None + + @baseplatform.lazy_property + def GLES2(self): + try: + return ctypesloader.loadLibrary( + ctypes.cdll, "GLESv2", mode=ctypes.RTLD_GLOBAL + ) + except OSError: + return None + + @baseplatform.lazy_property + def GLES3(self): + # implementers guide says to use the same name for the DLL + return self.GLES2 + + @baseplatform.lazy_property + def EGL(self): + return ctypesloader.loadLibrary(ctypes.cdll, 'EGL') + + @baseplatform.lazy_property + def glXGetProcAddressARB(self): + base = self.GLX.glXGetProcAddressARB + base.restype = ctypes.c_void_p + return base + + @baseplatform.lazy_property + def getExtensionProcedure(self): + return self.glXGetProcAddressARB + + @baseplatform.lazy_property + def GLE(self): + try: + return ctypesloader.loadLibrary(ctypes.cdll, "gle", mode=ctypes.RTLD_GLOBAL) + except OSError: + return None + + DEFAULT_FUNCTION_TYPE = staticmethod(ctypes.CFUNCTYPE) + + # This loads the GLX functions from the GL .so, not sure if that's + # really kosher... + @baseplatform.lazy_property + def GetCurrentContext(self): + return self.GLX.glXGetCurrentContext + + def getGLUTFontPointer(self, constant): + """Platform specific function to retrieve a GLUT font pointer + + GLUTAPI void *glutBitmap9By15; + #define GLUT_BITMAP_9_BY_15 (&glutBitmap9By15) + + Key here is that we want the addressof the pointer in the DLL, + not the pointer in the DLL. That is, our pointer is to the + pointer defined in the DLL, we don't want the *value* stored in + that pointer. + """ + name = [x.title() for x in constant.split("_")[1:]] + internal = "glut" + "".join([x.title() for x in name]) + pointer = ctypes.c_void_p.in_dll(self.GLUT, internal) + return ctypes.c_void_p(ctypes.addressof(pointer)) + + @baseplatform.lazy_property + def glGetError(self): + return self.GL.glGetError diff --git a/venv/lib/python3.12/site-packages/OpenGL/platform/osmesa.py b/venv/lib/python3.12/site-packages/OpenGL/platform/osmesa.py new file mode 100644 index 00000000..15cf23f8 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/platform/osmesa.py @@ -0,0 +1,92 @@ +"""OSMesa-specific features + +To request an OSMesa context, you need to run your script with: + + PYOPENGL_PLATFORM=osmesa + +defined in your shell/execution environment. +""" +import ctypes, ctypes.util +from OpenGL.platform import baseplatform, ctypesloader +from OpenGL.constant import Constant +from OpenGL.raw.osmesa import _types + +class OSMesaPlatform( baseplatform.BasePlatform ): + """OSMesa implementation for PyOpenGL""" + EXPORTED_NAMES = baseplatform.BasePlatform.EXPORTED_NAMES[:] + [ + 'OSMesa', + ] + @baseplatform.lazy_property + def GL(self): + try: + return ctypesloader.loadLibrary( + ctypes.cdll, + 'OSMesa', + mode=ctypes.RTLD_GLOBAL + ) + except OSError as err: + raise ImportError("Unable to load OpenGL library", *err.args) + @baseplatform.lazy_property + def GLU(self): + try: + return ctypesloader.loadLibrary( + ctypes.cdll, + 'GLU', + mode=ctypes.RTLD_GLOBAL + ) + except OSError as err: + return None + @baseplatform.lazy_property + def GLUT( self ): + try: + return ctypesloader.loadLibrary( + ctypes.cdll, + 'glut', + mode=ctypes.RTLD_GLOBAL + ) + except OSError as err: + return None + @baseplatform.lazy_property + def GLE( self ): + try: + return ctypesloader.loadLibrary( + ctypes.cdll, + 'gle', + mode=ctypes.RTLD_GLOBAL + ) + except OSError as err: + return None + @baseplatform.lazy_property + def OSMesa( self ): return self.GL + + DEFAULT_FUNCTION_TYPE = staticmethod( ctypes.CFUNCTYPE ) + + @baseplatform.lazy_property + def GetCurrentContext( self ): + function = self.OSMesa.OSMesaGetCurrentContext + function.restype = _types.OSMesaContext + return function + @baseplatform.lazy_property + def CurrentContextIsValid( self ): return self.GetCurrentContext + + @baseplatform.lazy_property + def getExtensionProcedure( self ): + function = self.OSMesa.OSMesaGetProcAddress + function.restype = ctypes.c_void_p + return function + + def getGLUTFontPointer( self, constant ): + """Platform specific function to retrieve a GLUT font pointer + + GLUTAPI void *glutBitmap9By15; + #define GLUT_BITMAP_9_BY_15 (&glutBitmap9By15) + + Key here is that we want the addressof the pointer in the DLL, + not the pointer in the DLL. That is, our pointer is to the + pointer defined in the DLL, we don't want the *value* stored in + that pointer. + """ + name = [ x.title() for x in constant.split( '_' )[1:] ] + internal = 'glut' + "".join( [x.title() for x in name] ) + pointer = ctypes.c_void_p.in_dll( self.GLUT, internal ) + return ctypes.c_void_p(ctypes.addressof(pointer)) diff --git a/venv/lib/python3.12/site-packages/OpenGL/platform/win32.py b/venv/lib/python3.12/site-packages/OpenGL/platform/win32.py new file mode 100644 index 00000000..619e6c84 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/platform/win32.py @@ -0,0 +1,154 @@ +"""Windows-specific platform features""" +import ctypes +import platform +from OpenGL.platform import ctypesloader, baseplatform +import sys + +if sys.hexversion < 0x2070000: + vc = 'vc7' +elif sys.hexversion >= 0x3050000: + vc = 'vc14' +elif sys.hexversion >= 0x3030000: + vc = 'vc10' +else: + vc = 'vc9' + +def _size(): + return platform.architecture()[0].strip( 'bits' ) +size = _size() + +class Win32Platform( baseplatform.BasePlatform ): + """Win32-specific platform implementation""" + + GLUT_GUARD_CALLBACKS = True + @baseplatform.lazy_property + def GL(self): + try: + return ctypesloader.loadLibrary( + ctypes.windll, 'opengl32', mode = ctypes.RTLD_GLOBAL + ) + except OSError as err: + raise ImportError("Unable to load OpenGL library", *err.args) + @baseplatform.lazy_property + def GLU(self): + try: + return ctypesloader.loadLibrary( + ctypes.windll, 'glu32', mode = ctypes.RTLD_GLOBAL + ) + except OSError: + return None + @baseplatform.lazy_property + def GLUT( self ): + for possible in ('freeglut%s.%s'%(size,vc,), 'glut%s.%s'%(size,vc,)): + # Prefer FreeGLUT if the user has installed it, fallback to the included + # GLUT if it is installed + try: + return ctypesloader.loadLibrary( + ctypes.windll, possible, mode = ctypes.RTLD_GLOBAL + ) + except WindowsError: + pass + return None + @baseplatform.lazy_property + def GLE( self ): + for libName in ('gle%s.%s'%(size,vc,), 'opengle%s.%s'%(size,vc,)): + try: + GLE = ctypesloader.loadLibrary( ctypes.cdll, libName ) + GLE.FunctionType = ctypes.CFUNCTYPE + return GLE + except WindowsError: + pass + else: + break + return None + + DEFAULT_FUNCTION_TYPE = staticmethod( ctypes.WINFUNCTYPE ) + # Win32 GLUT uses different types for callbacks and functions... + GLUT_CALLBACK_TYPE = staticmethod( ctypes.CFUNCTYPE ) + GDI32 = ctypes.windll.gdi32 + @baseplatform.lazy_property + def WGL( self ): + return self.OpenGL + @baseplatform.lazy_property + def getExtensionProcedure( self ): + wglGetProcAddress = self.OpenGL.wglGetProcAddress + wglGetProcAddress.restype = ctypes.c_void_p + return wglGetProcAddress + + GLUT_FONT_CONSTANTS = { + 'GLUT_STROKE_ROMAN': ctypes.c_void_p( 0), + 'GLUT_STROKE_MONO_ROMAN': ctypes.c_void_p( 1), + 'GLUT_BITMAP_9_BY_15': ctypes.c_void_p( 2), + 'GLUT_BITMAP_8_BY_13': ctypes.c_void_p( 3), + 'GLUT_BITMAP_TIMES_ROMAN_10': ctypes.c_void_p( 4), + 'GLUT_BITMAP_TIMES_ROMAN_24': ctypes.c_void_p( 5), + 'GLUT_BITMAP_HELVETICA_10': ctypes.c_void_p( 6), + 'GLUT_BITMAP_HELVETICA_12': ctypes.c_void_p( 7), + 'GLUT_BITMAP_HELVETICA_18': ctypes.c_void_p( 8), + } + + + def getGLUTFontPointer( self,constant ): + """Platform specific function to retrieve a GLUT font pointer + + GLUTAPI void *glutBitmap9By15; + #define GLUT_BITMAP_9_BY_15 (&glutBitmap9By15) + + Key here is that we want the addressof the pointer in the DLL, + not the pointer in the DLL. That is, our pointer is to the + pointer defined in the DLL, we don't want the *value* stored in + that pointer. + """ + return self.GLUT_FONT_CONSTANTS[ constant ] + + @baseplatform.lazy_property + def GetCurrentContext( self ): + wglGetCurrentContext = self.GL.wglGetCurrentContext + wglGetCurrentContext.restype = ctypes.c_void_p + return wglGetCurrentContext + + def constructFunction( + self, + functionName, dll, + resultType=ctypes.c_int, argTypes=(), + doc = None, argNames = (), + extension = None, + deprecated = False, + module = None, + force_extension = False, + error_checker = None, + ): + """Override construct function to do win32-specific hacks to find entry points""" + try: + return super( Win32Platform, self ).constructFunction( + functionName, dll, + resultType, argTypes, + doc, argNames, + extension, + deprecated, + module, + error_checker=error_checker, + ) + except AttributeError: + try: + return super( Win32Platform, self ).constructFunction( + functionName, self.GDI32, + resultType, argTypes, + doc, argNames, + extension, + deprecated, + module, + error_checker=error_checker, + ) + except AttributeError: + return super( Win32Platform, self ).constructFunction( + functionName, dll, + resultType, argTypes, + doc, argNames, + extension, + deprecated, + module, + force_extension = True, + error_checker=error_checker, + ) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/plugins.py b/venv/lib/python3.12/site-packages/OpenGL/plugins.py new file mode 100644 index 00000000..fb91c720 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/plugins.py @@ -0,0 +1,76 @@ +"""Simple plug-in mechanism to provide replacement for setuptools plugins""" +import logging +log = logging.getLogger(__name__) + +class Plugin( object ): + """Base class for plugins to be loaded""" + loaded = False + def __init__( self, name, import_path, check = None, **named ): + """Register the plug-in""" + self.name = name + self.import_path = import_path + self.check = check + self.registry.append( self ) + self.__dict__.update( named ) + def load( self ): + """Attempt to load and return our entry point""" + try: + return importByName( self.import_path ) + except ImportError as err: + log.warning( + 'Unable to import %s: %s', + self.import_path, + err + ) + return None + @classmethod + def match( cls, *args ): + """Match to return the plugin which is appropriate to load""" + @classmethod + def all( cls ): + """Iterate over all registered plugins""" + return cls.registry[:] + @classmethod + def by_name( cls, name ): + for instance in cls.all(): + if instance.name == name: + return instance + return None + +def importByName( fullName ): + """Import a class by name""" + name = fullName.split(".") + moduleName = name[:-1] + className = name[-1] + module = __import__( ".".join(moduleName), {}, {}, moduleName) + return getattr( module, className ) + + +class PlatformPlugin( Plugin ): + """Platform-level plugin registration""" + registry = [] + @classmethod + def match( cls, key ): + """Determine what platform module to load + + key -- (sys.platform,os.name) key to load + """ + for possible in key: + # prefer sys.platform, *then* os.name + for plugin in cls.registry: + if plugin.name == possible: + return plugin + raise KeyError( """No platform plugin registered for %s"""%(key,)) + +class FormatHandler( Plugin ): + """Data-type storage-format handler""" + registry = [] + @classmethod + def match( cls, value ): + """Lookup appropriate handler based on value (a type)""" + key = '%s.%s'%( value.__module__, value.__name__ ) + for plugin in cls.registry: + set = getattr( plugin, 'check', ()) + if set and key in set: + return plugin + return None diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/ANDROID/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/ANDROID/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/ANDROID/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/ANDROID/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/ANDROID/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..1b9affbd Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/ANDROID/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/ANDROID/__pycache__/blob_cache.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/ANDROID/__pycache__/blob_cache.cpython-312.pyc new file mode 100644 index 00000000..a17e607a Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/ANDROID/__pycache__/blob_cache.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/ANDROID/__pycache__/framebuffer_target.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/ANDROID/__pycache__/framebuffer_target.cpython-312.pyc new file mode 100644 index 00000000..688df5e2 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/ANDROID/__pycache__/framebuffer_target.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/ANDROID/__pycache__/image_native_buffer.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/ANDROID/__pycache__/image_native_buffer.cpython-312.pyc new file mode 100644 index 00000000..b3ea1241 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/ANDROID/__pycache__/image_native_buffer.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/ANDROID/__pycache__/native_fence_sync.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/ANDROID/__pycache__/native_fence_sync.cpython-312.pyc new file mode 100644 index 00000000..a0e41ea3 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/ANDROID/__pycache__/native_fence_sync.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/ANDROID/__pycache__/recordable.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/ANDROID/__pycache__/recordable.cpython-312.pyc new file mode 100644 index 00000000..94c0bb74 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/ANDROID/__pycache__/recordable.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/ANDROID/blob_cache.py b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/ANDROID/blob_cache.py new file mode 100644 index 00000000..2c9b047a --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/ANDROID/blob_cache.py @@ -0,0 +1,17 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.EGL import _types as _cs +# End users want this... +from OpenGL.raw.EGL._types import * +from OpenGL.raw.EGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'EGL_ANDROID_blob_cache' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.EGL,'EGL_ANDROID_blob_cache',error_checker=_errors._error_checker) + +@_f +@_p.types(None,_cs.EGLDisplay,_cs.EGLSetBlobFuncANDROID,_cs.EGLGetBlobFuncANDROID) +def eglSetBlobCacheFuncsANDROID(dpy,set,get):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/ANDROID/framebuffer_target.py b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/ANDROID/framebuffer_target.py new file mode 100644 index 00000000..3ace5696 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/ANDROID/framebuffer_target.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.EGL import _types as _cs +# End users want this... +from OpenGL.raw.EGL._types import * +from OpenGL.raw.EGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'EGL_ANDROID_framebuffer_target' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.EGL,'EGL_ANDROID_framebuffer_target',error_checker=_errors._error_checker) +EGL_FRAMEBUFFER_TARGET_ANDROID=_C('EGL_FRAMEBUFFER_TARGET_ANDROID',0x3147) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/ANDROID/image_native_buffer.py b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/ANDROID/image_native_buffer.py new file mode 100644 index 00000000..c42e4465 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/ANDROID/image_native_buffer.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.EGL import _types as _cs +# End users want this... +from OpenGL.raw.EGL._types import * +from OpenGL.raw.EGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'EGL_ANDROID_image_native_buffer' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.EGL,'EGL_ANDROID_image_native_buffer',error_checker=_errors._error_checker) +EGL_NATIVE_BUFFER_ANDROID=_C('EGL_NATIVE_BUFFER_ANDROID',0x3140) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/ANDROID/native_fence_sync.py b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/ANDROID/native_fence_sync.py new file mode 100644 index 00000000..4589377d --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/ANDROID/native_fence_sync.py @@ -0,0 +1,20 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.EGL import _types as _cs +# End users want this... +from OpenGL.raw.EGL._types import * +from OpenGL.raw.EGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'EGL_ANDROID_native_fence_sync' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.EGL,'EGL_ANDROID_native_fence_sync',error_checker=_errors._error_checker) +EGL_NO_NATIVE_FENCE_FD_ANDROID=_C('EGL_NO_NATIVE_FENCE_FD_ANDROID',-1) +EGL_SYNC_NATIVE_FENCE_ANDROID=_C('EGL_SYNC_NATIVE_FENCE_ANDROID',0x3144) +EGL_SYNC_NATIVE_FENCE_FD_ANDROID=_C('EGL_SYNC_NATIVE_FENCE_FD_ANDROID',0x3145) +EGL_SYNC_NATIVE_FENCE_SIGNALED_ANDROID=_C('EGL_SYNC_NATIVE_FENCE_SIGNALED_ANDROID',0x3146) +@_f +@_p.types(_cs.EGLint,_cs.EGLDisplay,_cs.EGLSyncKHR) +def eglDupNativeFenceFDANDROID(dpy,sync):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/ANDROID/recordable.py b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/ANDROID/recordable.py new file mode 100644 index 00000000..96ebeb02 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/ANDROID/recordable.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.EGL import _types as _cs +# End users want this... +from OpenGL.raw.EGL._types import * +from OpenGL.raw.EGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'EGL_ANDROID_recordable' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.EGL,'EGL_ANDROID_recordable',error_checker=_errors._error_checker) +EGL_RECORDABLE_ANDROID=_C('EGL_RECORDABLE_ANDROID',0x3142) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/ANGLE/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/ANGLE/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/ANGLE/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/ANGLE/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/ANGLE/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..5746b146 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/ANGLE/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/ANGLE/__pycache__/d3d_share_handle_client_buffer.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/ANGLE/__pycache__/d3d_share_handle_client_buffer.cpython-312.pyc new file mode 100644 index 00000000..3aa18de1 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/ANGLE/__pycache__/d3d_share_handle_client_buffer.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/ANGLE/__pycache__/device_d3d.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/ANGLE/__pycache__/device_d3d.cpython-312.pyc new file mode 100644 index 00000000..148704ac Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/ANGLE/__pycache__/device_d3d.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/ANGLE/__pycache__/query_surface_pointer.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/ANGLE/__pycache__/query_surface_pointer.cpython-312.pyc new file mode 100644 index 00000000..376e9064 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/ANGLE/__pycache__/query_surface_pointer.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/ANGLE/__pycache__/surface_d3d_texture_2d_share_handle.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/ANGLE/__pycache__/surface_d3d_texture_2d_share_handle.cpython-312.pyc new file mode 100644 index 00000000..c6e5b716 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/ANGLE/__pycache__/surface_d3d_texture_2d_share_handle.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/ANGLE/__pycache__/window_fixed_size.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/ANGLE/__pycache__/window_fixed_size.cpython-312.pyc new file mode 100644 index 00000000..0d848dbc Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/ANGLE/__pycache__/window_fixed_size.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/ANGLE/d3d_share_handle_client_buffer.py b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/ANGLE/d3d_share_handle_client_buffer.py new file mode 100644 index 00000000..700b5e34 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/ANGLE/d3d_share_handle_client_buffer.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.EGL import _types as _cs +# End users want this... +from OpenGL.raw.EGL._types import * +from OpenGL.raw.EGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'EGL_ANGLE_d3d_share_handle_client_buffer' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.EGL,'EGL_ANGLE_d3d_share_handle_client_buffer',error_checker=_errors._error_checker) +EGL_D3D_TEXTURE_2D_SHARE_HANDLE_ANGLE=_C('EGL_D3D_TEXTURE_2D_SHARE_HANDLE_ANGLE',0x3200) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/ANGLE/device_d3d.py b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/ANGLE/device_d3d.py new file mode 100644 index 00000000..c50da9ca --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/ANGLE/device_d3d.py @@ -0,0 +1,16 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.EGL import _types as _cs +# End users want this... +from OpenGL.raw.EGL._types import * +from OpenGL.raw.EGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'EGL_ANGLE_device_d3d' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.EGL,'EGL_ANGLE_device_d3d',error_checker=_errors._error_checker) +EGL_D3D11_DEVICE_ANGLE=_C('EGL_D3D11_DEVICE_ANGLE',0x33A1) +EGL_D3D9_DEVICE_ANGLE=_C('EGL_D3D9_DEVICE_ANGLE',0x33A0) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/ANGLE/query_surface_pointer.py b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/ANGLE/query_surface_pointer.py new file mode 100644 index 00000000..fb8486ec --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/ANGLE/query_surface_pointer.py @@ -0,0 +1,17 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.EGL import _types as _cs +# End users want this... +from OpenGL.raw.EGL._types import * +from OpenGL.raw.EGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'EGL_ANGLE_query_surface_pointer' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.EGL,'EGL_ANGLE_query_surface_pointer',error_checker=_errors._error_checker) + +@_f +@_p.types(_cs.EGLBoolean,_cs.EGLDisplay,_cs.EGLSurface,_cs.EGLint,arrays.GLvoidpArray) +def eglQuerySurfacePointerANGLE(dpy,surface,attribute,value):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/ANGLE/surface_d3d_texture_2d_share_handle.py b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/ANGLE/surface_d3d_texture_2d_share_handle.py new file mode 100644 index 00000000..32a06b8f --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/ANGLE/surface_d3d_texture_2d_share_handle.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.EGL import _types as _cs +# End users want this... +from OpenGL.raw.EGL._types import * +from OpenGL.raw.EGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'EGL_ANGLE_surface_d3d_texture_2d_share_handle' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.EGL,'EGL_ANGLE_surface_d3d_texture_2d_share_handle',error_checker=_errors._error_checker) +EGL_D3D_TEXTURE_2D_SHARE_HANDLE_ANGLE=_C('EGL_D3D_TEXTURE_2D_SHARE_HANDLE_ANGLE',0x3200) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/ANGLE/window_fixed_size.py b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/ANGLE/window_fixed_size.py new file mode 100644 index 00000000..cf97b40a --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/ANGLE/window_fixed_size.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.EGL import _types as _cs +# End users want this... +from OpenGL.raw.EGL._types import * +from OpenGL.raw.EGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'EGL_ANGLE_window_fixed_size' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.EGL,'EGL_ANGLE_window_fixed_size',error_checker=_errors._error_checker) +EGL_FIXED_SIZE_ANGLE=_C('EGL_FIXED_SIZE_ANGLE',0x3201) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/ARM/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/ARM/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/ARM/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/ARM/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/ARM/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..3c4b188a Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/ARM/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/ARM/__pycache__/pixmap_multisample_discard.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/ARM/__pycache__/pixmap_multisample_discard.cpython-312.pyc new file mode 100644 index 00000000..dd965b64 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/ARM/__pycache__/pixmap_multisample_discard.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/ARM/pixmap_multisample_discard.py b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/ARM/pixmap_multisample_discard.py new file mode 100644 index 00000000..a713ce7d --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/ARM/pixmap_multisample_discard.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.EGL import _types as _cs +# End users want this... +from OpenGL.raw.EGL._types import * +from OpenGL.raw.EGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'EGL_ARM_pixmap_multisample_discard' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.EGL,'EGL_ARM_pixmap_multisample_discard',error_checker=_errors._error_checker) +EGL_DISCARD_SAMPLES_ARM=_C('EGL_DISCARD_SAMPLES_ARM',0x3286) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/EXT/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/EXT/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/EXT/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/EXT/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/EXT/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..1923e57d Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/EXT/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/EXT/__pycache__/buffer_age.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/EXT/__pycache__/buffer_age.cpython-312.pyc new file mode 100644 index 00000000..cb12c509 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/EXT/__pycache__/buffer_age.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/EXT/__pycache__/client_extensions.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/EXT/__pycache__/client_extensions.cpython-312.pyc new file mode 100644 index 00000000..4a498ca5 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/EXT/__pycache__/client_extensions.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/EXT/__pycache__/create_context_robustness.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/EXT/__pycache__/create_context_robustness.cpython-312.pyc new file mode 100644 index 00000000..feae5a7a Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/EXT/__pycache__/create_context_robustness.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/EXT/__pycache__/device_base.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/EXT/__pycache__/device_base.cpython-312.pyc new file mode 100644 index 00000000..1771f094 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/EXT/__pycache__/device_base.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/EXT/__pycache__/device_drm.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/EXT/__pycache__/device_drm.cpython-312.pyc new file mode 100644 index 00000000..5e7e7421 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/EXT/__pycache__/device_drm.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/EXT/__pycache__/device_enumeration.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/EXT/__pycache__/device_enumeration.cpython-312.pyc new file mode 100644 index 00000000..e5f3c49e Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/EXT/__pycache__/device_enumeration.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/EXT/__pycache__/device_openwf.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/EXT/__pycache__/device_openwf.cpython-312.pyc new file mode 100644 index 00000000..2838bdf2 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/EXT/__pycache__/device_openwf.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/EXT/__pycache__/device_query.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/EXT/__pycache__/device_query.cpython-312.pyc new file mode 100644 index 00000000..3a36c305 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/EXT/__pycache__/device_query.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/EXT/__pycache__/image_dma_buf_import.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/EXT/__pycache__/image_dma_buf_import.cpython-312.pyc new file mode 100644 index 00000000..89fa1924 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/EXT/__pycache__/image_dma_buf_import.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/EXT/__pycache__/multiview_window.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/EXT/__pycache__/multiview_window.cpython-312.pyc new file mode 100644 index 00000000..431b43c4 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/EXT/__pycache__/multiview_window.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/EXT/__pycache__/output_base.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/EXT/__pycache__/output_base.cpython-312.pyc new file mode 100644 index 00000000..3b9fe806 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/EXT/__pycache__/output_base.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/EXT/__pycache__/output_drm.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/EXT/__pycache__/output_drm.cpython-312.pyc new file mode 100644 index 00000000..6034d8b1 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/EXT/__pycache__/output_drm.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/EXT/__pycache__/output_openwf.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/EXT/__pycache__/output_openwf.cpython-312.pyc new file mode 100644 index 00000000..99bc54e3 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/EXT/__pycache__/output_openwf.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/EXT/__pycache__/platform_base.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/EXT/__pycache__/platform_base.cpython-312.pyc new file mode 100644 index 00000000..2315a196 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/EXT/__pycache__/platform_base.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/EXT/__pycache__/platform_device.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/EXT/__pycache__/platform_device.cpython-312.pyc new file mode 100644 index 00000000..d23c5fb2 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/EXT/__pycache__/platform_device.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/EXT/__pycache__/platform_wayland.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/EXT/__pycache__/platform_wayland.cpython-312.pyc new file mode 100644 index 00000000..2a7c20b9 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/EXT/__pycache__/platform_wayland.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/EXT/__pycache__/platform_x11.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/EXT/__pycache__/platform_x11.cpython-312.pyc new file mode 100644 index 00000000..32950013 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/EXT/__pycache__/platform_x11.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/EXT/__pycache__/protected_surface.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/EXT/__pycache__/protected_surface.cpython-312.pyc new file mode 100644 index 00000000..98e504b6 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/EXT/__pycache__/protected_surface.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/EXT/__pycache__/stream_consumer_egloutput.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/EXT/__pycache__/stream_consumer_egloutput.cpython-312.pyc new file mode 100644 index 00000000..bd88a97f Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/EXT/__pycache__/stream_consumer_egloutput.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/EXT/__pycache__/swap_buffers_with_damage.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/EXT/__pycache__/swap_buffers_with_damage.cpython-312.pyc new file mode 100644 index 00000000..190fb771 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/EXT/__pycache__/swap_buffers_with_damage.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/EXT/__pycache__/yuv_surface.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/EXT/__pycache__/yuv_surface.cpython-312.pyc new file mode 100644 index 00000000..b93a65e8 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/EXT/__pycache__/yuv_surface.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/EXT/buffer_age.py b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/EXT/buffer_age.py new file mode 100644 index 00000000..92344a97 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/EXT/buffer_age.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.EGL import _types as _cs +# End users want this... +from OpenGL.raw.EGL._types import * +from OpenGL.raw.EGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'EGL_EXT_buffer_age' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.EGL,'EGL_EXT_buffer_age',error_checker=_errors._error_checker) +EGL_BUFFER_AGE_EXT=_C('EGL_BUFFER_AGE_EXT',0x313D) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/EXT/client_extensions.py b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/EXT/client_extensions.py new file mode 100644 index 00000000..ac505cb8 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/EXT/client_extensions.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.EGL import _types as _cs +# End users want this... +from OpenGL.raw.EGL._types import * +from OpenGL.raw.EGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'EGL_EXT_client_extensions' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.EGL,'EGL_EXT_client_extensions',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/EXT/create_context_robustness.py b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/EXT/create_context_robustness.py new file mode 100644 index 00000000..53d67e93 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/EXT/create_context_robustness.py @@ -0,0 +1,18 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.EGL import _types as _cs +# End users want this... +from OpenGL.raw.EGL._types import * +from OpenGL.raw.EGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'EGL_EXT_create_context_robustness' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.EGL,'EGL_EXT_create_context_robustness',error_checker=_errors._error_checker) +EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY_EXT=_C('EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY_EXT',0x3138) +EGL_CONTEXT_OPENGL_ROBUST_ACCESS_EXT=_C('EGL_CONTEXT_OPENGL_ROBUST_ACCESS_EXT',0x30BF) +EGL_LOSE_CONTEXT_ON_RESET_EXT=_C('EGL_LOSE_CONTEXT_ON_RESET_EXT',0x31BF) +EGL_NO_RESET_NOTIFICATION_EXT=_C('EGL_NO_RESET_NOTIFICATION_EXT',0x31BE) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/EXT/device_base.py b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/EXT/device_base.py new file mode 100644 index 00000000..891763b6 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/EXT/device_base.py @@ -0,0 +1,28 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.EGL import _types as _cs +# End users want this... +from OpenGL.raw.EGL._types import * +from OpenGL.raw.EGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'EGL_EXT_device_base' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.EGL,'EGL_EXT_device_base',error_checker=_errors._error_checker) +EGL_BAD_DEVICE_EXT=_C('EGL_BAD_DEVICE_EXT',0x322B) +EGL_DEVICE_EXT=_C('EGL_DEVICE_EXT',0x322C) +# EGL_NO_DEVICE_EXT=_C('EGL_NO_DEVICE_EXT',((EGLDeviceEXT)(0))) +@_f +@_p.types(_cs.EGLBoolean,_cs.EGLDeviceEXT,_cs.EGLint,arrays.EGLAttribArray) +def eglQueryDeviceAttribEXT(device,attribute,value):pass +@_f +@_p.types(ctypes.c_char_p,_cs.EGLDeviceEXT,_cs.EGLint) +def eglQueryDeviceStringEXT(device,name):pass +@_f +@_p.types(_cs.EGLBoolean,_cs.EGLint,ctypes.POINTER(_cs.EGLDeviceEXT),arrays.GLintArray) +def eglQueryDevicesEXT(max_devices,devices,num_devices):pass +@_f +@_p.types(_cs.EGLBoolean,_cs.EGLDisplay,_cs.EGLint,arrays.EGLAttribArray) +def eglQueryDisplayAttribEXT(dpy,attribute,value):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/EXT/device_drm.py b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/EXT/device_drm.py new file mode 100644 index 00000000..14159ae0 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/EXT/device_drm.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.EGL import _types as _cs +# End users want this... +from OpenGL.raw.EGL._types import * +from OpenGL.raw.EGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'EGL_EXT_device_drm' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.EGL,'EGL_EXT_device_drm',error_checker=_errors._error_checker) +EGL_DRM_DEVICE_FILE_EXT=_C('EGL_DRM_DEVICE_FILE_EXT',0x3233) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/EXT/device_enumeration.py b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/EXT/device_enumeration.py new file mode 100644 index 00000000..66908c3a --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/EXT/device_enumeration.py @@ -0,0 +1,17 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.EGL import _types as _cs +# End users want this... +from OpenGL.raw.EGL._types import * +from OpenGL.raw.EGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'EGL_EXT_device_enumeration' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.EGL,'EGL_EXT_device_enumeration',error_checker=_errors._error_checker) + +@_f +@_p.types(_cs.EGLBoolean,_cs.EGLint,ctypes.POINTER(_cs.EGLDeviceEXT),arrays.GLintArray) +def eglQueryDevicesEXT(max_devices,devices,num_devices):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/EXT/device_openwf.py b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/EXT/device_openwf.py new file mode 100644 index 00000000..50969895 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/EXT/device_openwf.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.EGL import _types as _cs +# End users want this... +from OpenGL.raw.EGL._types import * +from OpenGL.raw.EGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'EGL_EXT_device_openwf' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.EGL,'EGL_EXT_device_openwf',error_checker=_errors._error_checker) +EGL_OPENWF_DEVICE_ID_EXT=_C('EGL_OPENWF_DEVICE_ID_EXT',0x3237) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/EXT/device_query.py b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/EXT/device_query.py new file mode 100644 index 00000000..f717cff9 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/EXT/device_query.py @@ -0,0 +1,25 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.EGL import _types as _cs +# End users want this... +from OpenGL.raw.EGL._types import * +from OpenGL.raw.EGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'EGL_EXT_device_query' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.EGL,'EGL_EXT_device_query',error_checker=_errors._error_checker) +EGL_BAD_DEVICE_EXT=_C('EGL_BAD_DEVICE_EXT',0x322B) +EGL_DEVICE_EXT=_C('EGL_DEVICE_EXT',0x322C) +# EGL_NO_DEVICE_EXT=_C('EGL_NO_DEVICE_EXT',((EGLDeviceEXT)(0))) +@_f +@_p.types(_cs.EGLBoolean,_cs.EGLDeviceEXT,_cs.EGLint,arrays.EGLAttribArray) +def eglQueryDeviceAttribEXT(device,attribute,value):pass +@_f +@_p.types(ctypes.c_char_p,_cs.EGLDeviceEXT,_cs.EGLint) +def eglQueryDeviceStringEXT(device,name):pass +@_f +@_p.types(_cs.EGLBoolean,_cs.EGLDisplay,_cs.EGLint,arrays.EGLAttribArray) +def eglQueryDisplayAttribEXT(dpy,attribute,value):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/EXT/image_dma_buf_import.py b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/EXT/image_dma_buf_import.py new file mode 100644 index 00000000..10da5d0c --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/EXT/image_dma_buf_import.py @@ -0,0 +1,36 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.EGL import _types as _cs +# End users want this... +from OpenGL.raw.EGL._types import * +from OpenGL.raw.EGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'EGL_EXT_image_dma_buf_import' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.EGL,'EGL_EXT_image_dma_buf_import',error_checker=_errors._error_checker) +EGL_DMA_BUF_PLANE0_FD_EXT=_C('EGL_DMA_BUF_PLANE0_FD_EXT',0x3272) +EGL_DMA_BUF_PLANE0_OFFSET_EXT=_C('EGL_DMA_BUF_PLANE0_OFFSET_EXT',0x3273) +EGL_DMA_BUF_PLANE0_PITCH_EXT=_C('EGL_DMA_BUF_PLANE0_PITCH_EXT',0x3274) +EGL_DMA_BUF_PLANE1_FD_EXT=_C('EGL_DMA_BUF_PLANE1_FD_EXT',0x3275) +EGL_DMA_BUF_PLANE1_OFFSET_EXT=_C('EGL_DMA_BUF_PLANE1_OFFSET_EXT',0x3276) +EGL_DMA_BUF_PLANE1_PITCH_EXT=_C('EGL_DMA_BUF_PLANE1_PITCH_EXT',0x3277) +EGL_DMA_BUF_PLANE2_FD_EXT=_C('EGL_DMA_BUF_PLANE2_FD_EXT',0x3278) +EGL_DMA_BUF_PLANE2_OFFSET_EXT=_C('EGL_DMA_BUF_PLANE2_OFFSET_EXT',0x3279) +EGL_DMA_BUF_PLANE2_PITCH_EXT=_C('EGL_DMA_BUF_PLANE2_PITCH_EXT',0x327A) +EGL_ITU_REC2020_EXT=_C('EGL_ITU_REC2020_EXT',0x3281) +EGL_ITU_REC601_EXT=_C('EGL_ITU_REC601_EXT',0x327F) +EGL_ITU_REC709_EXT=_C('EGL_ITU_REC709_EXT',0x3280) +EGL_LINUX_DMA_BUF_EXT=_C('EGL_LINUX_DMA_BUF_EXT',0x3270) +EGL_LINUX_DRM_FOURCC_EXT=_C('EGL_LINUX_DRM_FOURCC_EXT',0x3271) +EGL_SAMPLE_RANGE_HINT_EXT=_C('EGL_SAMPLE_RANGE_HINT_EXT',0x327C) +EGL_YUV_CHROMA_HORIZONTAL_SITING_HINT_EXT=_C('EGL_YUV_CHROMA_HORIZONTAL_SITING_HINT_EXT',0x327D) +EGL_YUV_CHROMA_SITING_0_5_EXT=_C('EGL_YUV_CHROMA_SITING_0_5_EXT',0x3285) +EGL_YUV_CHROMA_SITING_0_EXT=_C('EGL_YUV_CHROMA_SITING_0_EXT',0x3284) +EGL_YUV_CHROMA_VERTICAL_SITING_HINT_EXT=_C('EGL_YUV_CHROMA_VERTICAL_SITING_HINT_EXT',0x327E) +EGL_YUV_COLOR_SPACE_HINT_EXT=_C('EGL_YUV_COLOR_SPACE_HINT_EXT',0x327B) +EGL_YUV_FULL_RANGE_EXT=_C('EGL_YUV_FULL_RANGE_EXT',0x3282) +EGL_YUV_NARROW_RANGE_EXT=_C('EGL_YUV_NARROW_RANGE_EXT',0x3283) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/EXT/multiview_window.py b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/EXT/multiview_window.py new file mode 100644 index 00000000..f0b8032d --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/EXT/multiview_window.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.EGL import _types as _cs +# End users want this... +from OpenGL.raw.EGL._types import * +from OpenGL.raw.EGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'EGL_EXT_multiview_window' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.EGL,'EGL_EXT_multiview_window',error_checker=_errors._error_checker) +EGL_MULTIVIEW_VIEW_COUNT_EXT=_C('EGL_MULTIVIEW_VIEW_COUNT_EXT',0x3134) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/EXT/output_base.py b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/EXT/output_base.py new file mode 100644 index 00000000..a94dc287 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/EXT/output_base.py @@ -0,0 +1,42 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.EGL import _types as _cs +# End users want this... +from OpenGL.raw.EGL._types import * +from OpenGL.raw.EGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'EGL_EXT_output_base' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.EGL,'EGL_EXT_output_base',error_checker=_errors._error_checker) +EGL_BAD_OUTPUT_LAYER_EXT=_C('EGL_BAD_OUTPUT_LAYER_EXT',0x322D) +EGL_BAD_OUTPUT_PORT_EXT=_C('EGL_BAD_OUTPUT_PORT_EXT',0x322E) +# EGL_NO_OUTPUT_LAYER_EXT=_C('EGL_NO_OUTPUT_LAYER_EXT',((EGLOutputLayerEXT)0)) +# EGL_NO_OUTPUT_PORT_EXT=_C('EGL_NO_OUTPUT_PORT_EXT',((EGLOutputPortEXT)0)) +EGL_SWAP_INTERVAL_EXT=_C('EGL_SWAP_INTERVAL_EXT',0x322F) +@_f +@_p.types(_cs.EGLBoolean,_cs.EGLDisplay,arrays.EGLAttribArray,ctypes.POINTER(_cs.EGLOutputLayerEXT),_cs.EGLint,arrays.GLintArray) +def eglGetOutputLayersEXT(dpy,attrib_list,layers,max_layers,num_layers):pass +@_f +@_p.types(_cs.EGLBoolean,_cs.EGLDisplay,arrays.EGLAttribArray,ctypes.POINTER(_cs.EGLOutputPortEXT),_cs.EGLint,arrays.GLintArray) +def eglGetOutputPortsEXT(dpy,attrib_list,ports,max_ports,num_ports):pass +@_f +@_p.types(_cs.EGLBoolean,_cs.EGLDisplay,_cs.EGLOutputLayerEXT,_cs.EGLint,_cs.EGLAttrib) +def eglOutputLayerAttribEXT(dpy,layer,attribute,value):pass +@_f +@_p.types(_cs.EGLBoolean,_cs.EGLDisplay,_cs.EGLOutputPortEXT,_cs.EGLint,_cs.EGLAttrib) +def eglOutputPortAttribEXT(dpy,port,attribute,value):pass +@_f +@_p.types(_cs.EGLBoolean,_cs.EGLDisplay,_cs.EGLOutputLayerEXT,_cs.EGLint,arrays.EGLAttribArray) +def eglQueryOutputLayerAttribEXT(dpy,layer,attribute,value):pass +@_f +@_p.types(ctypes.c_char_p,_cs.EGLDisplay,_cs.EGLOutputLayerEXT,_cs.EGLint) +def eglQueryOutputLayerStringEXT(dpy,layer,name):pass +@_f +@_p.types(_cs.EGLBoolean,_cs.EGLDisplay,_cs.EGLOutputPortEXT,_cs.EGLint,arrays.EGLAttribArray) +def eglQueryOutputPortAttribEXT(dpy,port,attribute,value):pass +@_f +@_p.types(ctypes.c_char_p,_cs.EGLDisplay,_cs.EGLOutputPortEXT,_cs.EGLint) +def eglQueryOutputPortStringEXT(dpy,port,name):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/EXT/output_drm.py b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/EXT/output_drm.py new file mode 100644 index 00000000..087bce0d --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/EXT/output_drm.py @@ -0,0 +1,17 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.EGL import _types as _cs +# End users want this... +from OpenGL.raw.EGL._types import * +from OpenGL.raw.EGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'EGL_EXT_output_drm' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.EGL,'EGL_EXT_output_drm',error_checker=_errors._error_checker) +EGL_DRM_CONNECTOR_EXT=_C('EGL_DRM_CONNECTOR_EXT',0x3236) +EGL_DRM_CRTC_EXT=_C('EGL_DRM_CRTC_EXT',0x3234) +EGL_DRM_PLANE_EXT=_C('EGL_DRM_PLANE_EXT',0x3235) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/EXT/output_openwf.py b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/EXT/output_openwf.py new file mode 100644 index 00000000..64800468 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/EXT/output_openwf.py @@ -0,0 +1,16 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.EGL import _types as _cs +# End users want this... +from OpenGL.raw.EGL._types import * +from OpenGL.raw.EGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'EGL_EXT_output_openwf' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.EGL,'EGL_EXT_output_openwf',error_checker=_errors._error_checker) +EGL_OPENWF_PIPELINE_ID_EXT=_C('EGL_OPENWF_PIPELINE_ID_EXT',0x3238) +EGL_OPENWF_PORT_ID_EXT=_C('EGL_OPENWF_PORT_ID_EXT',0x3239) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/EXT/platform_base.py b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/EXT/platform_base.py new file mode 100644 index 00000000..18455632 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/EXT/platform_base.py @@ -0,0 +1,23 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.EGL import _types as _cs +# End users want this... +from OpenGL.raw.EGL._types import * +from OpenGL.raw.EGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'EGL_EXT_platform_base' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.EGL,'EGL_EXT_platform_base',error_checker=_errors._error_checker) + +@_f +@_p.types(_cs.EGLSurface,_cs.EGLDisplay,_cs.EGLConfig,ctypes.c_void_p,arrays.GLintArray) +def eglCreatePlatformPixmapSurfaceEXT(dpy,config,native_pixmap,attrib_list):pass +@_f +@_p.types(_cs.EGLSurface,_cs.EGLDisplay,_cs.EGLConfig,ctypes.c_void_p,arrays.GLintArray) +def eglCreatePlatformWindowSurfaceEXT(dpy,config,native_window,attrib_list):pass +@_f +@_p.types(_cs.EGLDisplay,_cs.EGLenum,ctypes.c_void_p,arrays.GLintArray) +def eglGetPlatformDisplayEXT(platform,native_display,attrib_list):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/EXT/platform_device.py b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/EXT/platform_device.py new file mode 100644 index 00000000..cfea14a1 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/EXT/platform_device.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.EGL import _types as _cs +# End users want this... +from OpenGL.raw.EGL._types import * +from OpenGL.raw.EGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'EGL_EXT_platform_device' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.EGL,'EGL_EXT_platform_device',error_checker=_errors._error_checker) +EGL_PLATFORM_DEVICE_EXT=_C('EGL_PLATFORM_DEVICE_EXT',0x313F) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/EXT/platform_wayland.py b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/EXT/platform_wayland.py new file mode 100644 index 00000000..d49f9167 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/EXT/platform_wayland.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.EGL import _types as _cs +# End users want this... +from OpenGL.raw.EGL._types import * +from OpenGL.raw.EGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'EGL_EXT_platform_wayland' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.EGL,'EGL_EXT_platform_wayland',error_checker=_errors._error_checker) +EGL_PLATFORM_WAYLAND_EXT=_C('EGL_PLATFORM_WAYLAND_EXT',0x31D8) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/EXT/platform_x11.py b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/EXT/platform_x11.py new file mode 100644 index 00000000..2fe15b93 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/EXT/platform_x11.py @@ -0,0 +1,16 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.EGL import _types as _cs +# End users want this... +from OpenGL.raw.EGL._types import * +from OpenGL.raw.EGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'EGL_EXT_platform_x11' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.EGL,'EGL_EXT_platform_x11',error_checker=_errors._error_checker) +EGL_PLATFORM_X11_EXT=_C('EGL_PLATFORM_X11_EXT',0x31D5) +EGL_PLATFORM_X11_SCREEN_EXT=_C('EGL_PLATFORM_X11_SCREEN_EXT',0x31D6) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/EXT/protected_surface.py b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/EXT/protected_surface.py new file mode 100644 index 00000000..b7c3701f --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/EXT/protected_surface.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.EGL import _types as _cs +# End users want this... +from OpenGL.raw.EGL._types import * +from OpenGL.raw.EGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'EGL_EXT_protected_surface' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.EGL,'EGL_EXT_protected_surface',error_checker=_errors._error_checker) +EGL_PROTECTED_CONTENT_EXT=_C('EGL_PROTECTED_CONTENT_EXT',0x32C0) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/EXT/stream_consumer_egloutput.py b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/EXT/stream_consumer_egloutput.py new file mode 100644 index 00000000..04ac1467 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/EXT/stream_consumer_egloutput.py @@ -0,0 +1,17 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.EGL import _types as _cs +# End users want this... +from OpenGL.raw.EGL._types import * +from OpenGL.raw.EGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'EGL_EXT_stream_consumer_egloutput' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.EGL,'EGL_EXT_stream_consumer_egloutput',error_checker=_errors._error_checker) + +@_f +@_p.types(_cs.EGLBoolean,_cs.EGLDisplay,_cs.EGLStreamKHR,_cs.EGLOutputLayerEXT) +def eglStreamConsumerOutputEXT(dpy,stream,layer):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/EXT/swap_buffers_with_damage.py b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/EXT/swap_buffers_with_damage.py new file mode 100644 index 00000000..ca419dc7 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/EXT/swap_buffers_with_damage.py @@ -0,0 +1,17 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.EGL import _types as _cs +# End users want this... +from OpenGL.raw.EGL._types import * +from OpenGL.raw.EGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'EGL_EXT_swap_buffers_with_damage' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.EGL,'EGL_EXT_swap_buffers_with_damage',error_checker=_errors._error_checker) + +@_f +@_p.types(_cs.EGLBoolean,_cs.EGLDisplay,_cs.EGLSurface,arrays.GLintArray,_cs.EGLint) +def eglSwapBuffersWithDamageEXT(dpy,surface,rects,n_rects):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/EXT/yuv_surface.py b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/EXT/yuv_surface.py new file mode 100644 index 00000000..5ee49751 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/EXT/yuv_surface.py @@ -0,0 +1,39 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.EGL import _types as _cs +# End users want this... +from OpenGL.raw.EGL._types import * +from OpenGL.raw.EGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'EGL_EXT_yuv_surface' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.EGL,'EGL_EXT_yuv_surface',error_checker=_errors._error_checker) +EGL_YUV_BUFFER_EXT=_C('EGL_YUV_BUFFER_EXT',0x3300) +EGL_YUV_CSC_STANDARD_2020_EXT=_C('EGL_YUV_CSC_STANDARD_2020_EXT',0x330D) +EGL_YUV_CSC_STANDARD_601_EXT=_C('EGL_YUV_CSC_STANDARD_601_EXT',0x330B) +EGL_YUV_CSC_STANDARD_709_EXT=_C('EGL_YUV_CSC_STANDARD_709_EXT',0x330C) +EGL_YUV_CSC_STANDARD_EXT=_C('EGL_YUV_CSC_STANDARD_EXT',0x330A) +EGL_YUV_DEPTH_RANGE_EXT=_C('EGL_YUV_DEPTH_RANGE_EXT',0x3317) +EGL_YUV_DEPTH_RANGE_FULL_EXT=_C('EGL_YUV_DEPTH_RANGE_FULL_EXT',0x3319) +EGL_YUV_DEPTH_RANGE_LIMITED_EXT=_C('EGL_YUV_DEPTH_RANGE_LIMITED_EXT',0x3318) +EGL_YUV_NUMBER_OF_PLANES_EXT=_C('EGL_YUV_NUMBER_OF_PLANES_EXT',0x3311) +EGL_YUV_ORDER_AYUV_EXT=_C('EGL_YUV_ORDER_AYUV_EXT',0x3308) +EGL_YUV_ORDER_EXT=_C('EGL_YUV_ORDER_EXT',0x3301) +EGL_YUV_ORDER_UYVY_EXT=_C('EGL_YUV_ORDER_UYVY_EXT',0x3305) +EGL_YUV_ORDER_VYUY_EXT=_C('EGL_YUV_ORDER_VYUY_EXT',0x3307) +EGL_YUV_ORDER_YUV_EXT=_C('EGL_YUV_ORDER_YUV_EXT',0x3302) +EGL_YUV_ORDER_YUYV_EXT=_C('EGL_YUV_ORDER_YUYV_EXT',0x3304) +EGL_YUV_ORDER_YVU_EXT=_C('EGL_YUV_ORDER_YVU_EXT',0x3303) +EGL_YUV_ORDER_YVYU_EXT=_C('EGL_YUV_ORDER_YVYU_EXT',0x3306) +EGL_YUV_PLANE_BPP_0_EXT=_C('EGL_YUV_PLANE_BPP_0_EXT',0x331B) +EGL_YUV_PLANE_BPP_10_EXT=_C('EGL_YUV_PLANE_BPP_10_EXT',0x331D) +EGL_YUV_PLANE_BPP_8_EXT=_C('EGL_YUV_PLANE_BPP_8_EXT',0x331C) +EGL_YUV_PLANE_BPP_EXT=_C('EGL_YUV_PLANE_BPP_EXT',0x331A) +EGL_YUV_SUBSAMPLE_4_2_0_EXT=_C('EGL_YUV_SUBSAMPLE_4_2_0_EXT',0x3313) +EGL_YUV_SUBSAMPLE_4_2_2_EXT=_C('EGL_YUV_SUBSAMPLE_4_2_2_EXT',0x3314) +EGL_YUV_SUBSAMPLE_4_4_4_EXT=_C('EGL_YUV_SUBSAMPLE_4_4_4_EXT',0x3315) +EGL_YUV_SUBSAMPLE_EXT=_C('EGL_YUV_SUBSAMPLE_EXT',0x3312) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/HI/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/HI/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/HI/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/HI/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/HI/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..11ce8e00 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/HI/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/HI/__pycache__/clientpixmap.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/HI/__pycache__/clientpixmap.cpython-312.pyc new file mode 100644 index 00000000..87426f53 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/HI/__pycache__/clientpixmap.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/HI/__pycache__/colorformats.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/HI/__pycache__/colorformats.cpython-312.pyc new file mode 100644 index 00000000..5dff0108 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/HI/__pycache__/colorformats.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/HI/clientpixmap.py b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/HI/clientpixmap.py new file mode 100644 index 00000000..16accbf9 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/HI/clientpixmap.py @@ -0,0 +1,17 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.EGL import _types as _cs +# End users want this... +from OpenGL.raw.EGL._types import * +from OpenGL.raw.EGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'EGL_HI_clientpixmap' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.EGL,'EGL_HI_clientpixmap',error_checker=_errors._error_checker) +EGL_CLIENT_PIXMAP_POINTER_HI=_C('EGL_CLIENT_PIXMAP_POINTER_HI',0x8F74) +@_f +@_p.types(_cs.EGLSurface,_cs.EGLDisplay,_cs.EGLConfig,ctypes.POINTER(_cs.EGLClientPixmapHI)) +def eglCreatePixmapSurfaceHI(dpy,config,pixmap):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/HI/colorformats.py b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/HI/colorformats.py new file mode 100644 index 00000000..555c18cb --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/HI/colorformats.py @@ -0,0 +1,18 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.EGL import _types as _cs +# End users want this... +from OpenGL.raw.EGL._types import * +from OpenGL.raw.EGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'EGL_HI_colorformats' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.EGL,'EGL_HI_colorformats',error_checker=_errors._error_checker) +EGL_COLOR_ARGB_HI=_C('EGL_COLOR_ARGB_HI',0x8F73) +EGL_COLOR_FORMAT_HI=_C('EGL_COLOR_FORMAT_HI',0x8F70) +EGL_COLOR_RGBA_HI=_C('EGL_COLOR_RGBA_HI',0x8F72) +EGL_COLOR_RGB_HI=_C('EGL_COLOR_RGB_HI',0x8F71) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/IMG/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/IMG/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/IMG/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/IMG/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/IMG/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..c51b59b5 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/IMG/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/IMG/__pycache__/context_priority.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/IMG/__pycache__/context_priority.cpython-312.pyc new file mode 100644 index 00000000..7e3af4ec Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/IMG/__pycache__/context_priority.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/IMG/context_priority.py b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/IMG/context_priority.py new file mode 100644 index 00000000..cf052e83 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/IMG/context_priority.py @@ -0,0 +1,18 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.EGL import _types as _cs +# End users want this... +from OpenGL.raw.EGL._types import * +from OpenGL.raw.EGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'EGL_IMG_context_priority' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.EGL,'EGL_IMG_context_priority',error_checker=_errors._error_checker) +EGL_CONTEXT_PRIORITY_HIGH_IMG=_C('EGL_CONTEXT_PRIORITY_HIGH_IMG',0x3101) +EGL_CONTEXT_PRIORITY_LEVEL_IMG=_C('EGL_CONTEXT_PRIORITY_LEVEL_IMG',0x3100) +EGL_CONTEXT_PRIORITY_LOW_IMG=_C('EGL_CONTEXT_PRIORITY_LOW_IMG',0x3103) +EGL_CONTEXT_PRIORITY_MEDIUM_IMG=_C('EGL_CONTEXT_PRIORITY_MEDIUM_IMG',0x3102) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..528c7768 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/__pycache__/cl_event.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/__pycache__/cl_event.cpython-312.pyc new file mode 100644 index 00000000..491ee35c Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/__pycache__/cl_event.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/__pycache__/cl_event2.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/__pycache__/cl_event2.cpython-312.pyc new file mode 100644 index 00000000..2c8dd2e8 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/__pycache__/cl_event2.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/__pycache__/client_get_all_proc_addresses.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/__pycache__/client_get_all_proc_addresses.cpython-312.pyc new file mode 100644 index 00000000..23f338f6 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/__pycache__/client_get_all_proc_addresses.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/__pycache__/config_attribs.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/__pycache__/config_attribs.cpython-312.pyc new file mode 100644 index 00000000..cb11c128 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/__pycache__/config_attribs.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/__pycache__/create_context.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/__pycache__/create_context.cpython-312.pyc new file mode 100644 index 00000000..6442faa2 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/__pycache__/create_context.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/__pycache__/create_context_no_error.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/__pycache__/create_context_no_error.cpython-312.pyc new file mode 100644 index 00000000..333561e0 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/__pycache__/create_context_no_error.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/__pycache__/debug.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/__pycache__/debug.cpython-312.pyc new file mode 100644 index 00000000..917f1e1e Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/__pycache__/debug.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/__pycache__/fence_sync.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/__pycache__/fence_sync.cpython-312.pyc new file mode 100644 index 00000000..d41fdf02 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/__pycache__/fence_sync.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/__pycache__/get_all_proc_addresses.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/__pycache__/get_all_proc_addresses.cpython-312.pyc new file mode 100644 index 00000000..4ddaff98 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/__pycache__/get_all_proc_addresses.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/__pycache__/gl_colorspace.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/__pycache__/gl_colorspace.cpython-312.pyc new file mode 100644 index 00000000..e1b243a9 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/__pycache__/gl_colorspace.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/__pycache__/gl_renderbuffer_image.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/__pycache__/gl_renderbuffer_image.cpython-312.pyc new file mode 100644 index 00000000..61f9b630 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/__pycache__/gl_renderbuffer_image.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/__pycache__/gl_texture_2D_image.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/__pycache__/gl_texture_2D_image.cpython-312.pyc new file mode 100644 index 00000000..186628d1 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/__pycache__/gl_texture_2D_image.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/__pycache__/gl_texture_3D_image.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/__pycache__/gl_texture_3D_image.cpython-312.pyc new file mode 100644 index 00000000..cefb45d4 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/__pycache__/gl_texture_3D_image.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/__pycache__/gl_texture_cubemap_image.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/__pycache__/gl_texture_cubemap_image.cpython-312.pyc new file mode 100644 index 00000000..8da3f03c Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/__pycache__/gl_texture_cubemap_image.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/__pycache__/image.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/__pycache__/image.cpython-312.pyc new file mode 100644 index 00000000..ffa26d2d Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/__pycache__/image.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/__pycache__/image_base.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/__pycache__/image_base.cpython-312.pyc new file mode 100644 index 00000000..0400708f Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/__pycache__/image_base.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/__pycache__/image_pixmap.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/__pycache__/image_pixmap.cpython-312.pyc new file mode 100644 index 00000000..3a427324 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/__pycache__/image_pixmap.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/__pycache__/lock_surface.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/__pycache__/lock_surface.cpython-312.pyc new file mode 100644 index 00000000..392c8354 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/__pycache__/lock_surface.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/__pycache__/lock_surface2.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/__pycache__/lock_surface2.cpython-312.pyc new file mode 100644 index 00000000..bde9ee03 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/__pycache__/lock_surface2.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/__pycache__/lock_surface3.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/__pycache__/lock_surface3.cpython-312.pyc new file mode 100644 index 00000000..838c834b Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/__pycache__/lock_surface3.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/__pycache__/partial_update.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/__pycache__/partial_update.cpython-312.pyc new file mode 100644 index 00000000..7567614c Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/__pycache__/partial_update.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/__pycache__/platform_android.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/__pycache__/platform_android.cpython-312.pyc new file mode 100644 index 00000000..8e710e13 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/__pycache__/platform_android.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/__pycache__/platform_gbm.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/__pycache__/platform_gbm.cpython-312.pyc new file mode 100644 index 00000000..aee0f2df Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/__pycache__/platform_gbm.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/__pycache__/platform_wayland.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/__pycache__/platform_wayland.cpython-312.pyc new file mode 100644 index 00000000..27676107 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/__pycache__/platform_wayland.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/__pycache__/platform_x11.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/__pycache__/platform_x11.cpython-312.pyc new file mode 100644 index 00000000..1dd70426 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/__pycache__/platform_x11.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/__pycache__/reusable_sync.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/__pycache__/reusable_sync.cpython-312.pyc new file mode 100644 index 00000000..67bf421a Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/__pycache__/reusable_sync.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/__pycache__/stream.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/__pycache__/stream.cpython-312.pyc new file mode 100644 index 00000000..3118b29e Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/__pycache__/stream.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/__pycache__/stream_consumer_gltexture.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/__pycache__/stream_consumer_gltexture.cpython-312.pyc new file mode 100644 index 00000000..6b8b2bf7 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/__pycache__/stream_consumer_gltexture.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/__pycache__/stream_cross_process_fd.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/__pycache__/stream_cross_process_fd.cpython-312.pyc new file mode 100644 index 00000000..34bd530b Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/__pycache__/stream_cross_process_fd.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/__pycache__/stream_fifo.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/__pycache__/stream_fifo.cpython-312.pyc new file mode 100644 index 00000000..908f9bd3 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/__pycache__/stream_fifo.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/__pycache__/stream_producer_aldatalocator.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/__pycache__/stream_producer_aldatalocator.cpython-312.pyc new file mode 100644 index 00000000..606b2fd7 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/__pycache__/stream_producer_aldatalocator.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/__pycache__/stream_producer_eglsurface.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/__pycache__/stream_producer_eglsurface.cpython-312.pyc new file mode 100644 index 00000000..1ca5d9dc Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/__pycache__/stream_producer_eglsurface.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/__pycache__/surfaceless_context.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/__pycache__/surfaceless_context.cpython-312.pyc new file mode 100644 index 00000000..92c4fb99 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/__pycache__/surfaceless_context.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/__pycache__/swap_buffers_with_damage.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/__pycache__/swap_buffers_with_damage.cpython-312.pyc new file mode 100644 index 00000000..41ac8595 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/__pycache__/swap_buffers_with_damage.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/__pycache__/vg_parent_image.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/__pycache__/vg_parent_image.cpython-312.pyc new file mode 100644 index 00000000..ee0778c7 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/__pycache__/vg_parent_image.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/__pycache__/wait_sync.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/__pycache__/wait_sync.cpython-312.pyc new file mode 100644 index 00000000..b8422c5a Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/__pycache__/wait_sync.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/cl_event.py b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/cl_event.py new file mode 100644 index 00000000..ceb2b4eb --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/cl_event.py @@ -0,0 +1,17 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.EGL import _types as _cs +# End users want this... +from OpenGL.raw.EGL._types import * +from OpenGL.raw.EGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'EGL_KHR_cl_event' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.EGL,'EGL_KHR_cl_event',error_checker=_errors._error_checker) +EGL_CL_EVENT_HANDLE_KHR=_C('EGL_CL_EVENT_HANDLE_KHR',0x309C) +EGL_SYNC_CL_EVENT_COMPLETE_KHR=_C('EGL_SYNC_CL_EVENT_COMPLETE_KHR',0x30FF) +EGL_SYNC_CL_EVENT_KHR=_C('EGL_SYNC_CL_EVENT_KHR',0x30FE) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/cl_event2.py b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/cl_event2.py new file mode 100644 index 00000000..3615c039 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/cl_event2.py @@ -0,0 +1,19 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.EGL import _types as _cs +# End users want this... +from OpenGL.raw.EGL._types import * +from OpenGL.raw.EGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'EGL_KHR_cl_event2' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.EGL,'EGL_KHR_cl_event2',error_checker=_errors._error_checker) +EGL_CL_EVENT_HANDLE_KHR=_C('EGL_CL_EVENT_HANDLE_KHR',0x309C) +EGL_SYNC_CL_EVENT_COMPLETE_KHR=_C('EGL_SYNC_CL_EVENT_COMPLETE_KHR',0x30FF) +EGL_SYNC_CL_EVENT_KHR=_C('EGL_SYNC_CL_EVENT_KHR',0x30FE) +@_f +@_p.types(_cs.EGLSyncKHR,_cs.EGLDisplay,_cs.EGLenum,ctypes.POINTER(_cs.EGLAttribKHR)) +def eglCreateSync64KHR(dpy,type,attrib_list):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/client_get_all_proc_addresses.py b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/client_get_all_proc_addresses.py new file mode 100644 index 00000000..cedd449a --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/client_get_all_proc_addresses.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.EGL import _types as _cs +# End users want this... +from OpenGL.raw.EGL._types import * +from OpenGL.raw.EGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'EGL_KHR_client_get_all_proc_addresses' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.EGL,'EGL_KHR_client_get_all_proc_addresses',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/config_attribs.py b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/config_attribs.py new file mode 100644 index 00000000..569110a4 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/config_attribs.py @@ -0,0 +1,17 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.EGL import _types as _cs +# End users want this... +from OpenGL.raw.EGL._types import * +from OpenGL.raw.EGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'EGL_KHR_config_attribs' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.EGL,'EGL_KHR_config_attribs',error_checker=_errors._error_checker) +EGL_CONFORMANT_KHR=_C('EGL_CONFORMANT_KHR',0x3042) +EGL_VG_ALPHA_FORMAT_PRE_BIT_KHR=_C('EGL_VG_ALPHA_FORMAT_PRE_BIT_KHR',0x0040) +EGL_VG_COLORSPACE_LINEAR_BIT_KHR=_C('EGL_VG_COLORSPACE_LINEAR_BIT_KHR',0x0020) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/create_context.py b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/create_context.py new file mode 100644 index 00000000..89a25aa7 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/create_context.py @@ -0,0 +1,28 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.EGL import _types as _cs +# End users want this... +from OpenGL.raw.EGL._types import * +from OpenGL.raw.EGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'EGL_KHR_create_context' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.EGL,'EGL_KHR_create_context',error_checker=_errors._error_checker) +EGL_CONTEXT_FLAGS_KHR=_C('EGL_CONTEXT_FLAGS_KHR',0x30FC) +EGL_CONTEXT_MAJOR_VERSION_KHR=_C('EGL_CONTEXT_MAJOR_VERSION_KHR',0x3098) +EGL_CONTEXT_MINOR_VERSION_KHR=_C('EGL_CONTEXT_MINOR_VERSION_KHR',0x30FB) +EGL_CONTEXT_OPENGL_COMPATIBILITY_PROFILE_BIT_KHR=_C('EGL_CONTEXT_OPENGL_COMPATIBILITY_PROFILE_BIT_KHR',0x00000002) +EGL_CONTEXT_OPENGL_CORE_PROFILE_BIT_KHR=_C('EGL_CONTEXT_OPENGL_CORE_PROFILE_BIT_KHR',0x00000001) +EGL_CONTEXT_OPENGL_DEBUG_BIT_KHR=_C('EGL_CONTEXT_OPENGL_DEBUG_BIT_KHR',0x00000001) +EGL_CONTEXT_OPENGL_FORWARD_COMPATIBLE_BIT_KHR=_C('EGL_CONTEXT_OPENGL_FORWARD_COMPATIBLE_BIT_KHR',0x00000002) +EGL_CONTEXT_OPENGL_PROFILE_MASK_KHR=_C('EGL_CONTEXT_OPENGL_PROFILE_MASK_KHR',0x30FD) +EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY_KHR=_C('EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY_KHR',0x31BD) +EGL_CONTEXT_OPENGL_ROBUST_ACCESS_BIT_KHR=_C('EGL_CONTEXT_OPENGL_ROBUST_ACCESS_BIT_KHR',0x00000004) +EGL_LOSE_CONTEXT_ON_RESET_KHR=_C('EGL_LOSE_CONTEXT_ON_RESET_KHR',0x31BF) +EGL_NO_RESET_NOTIFICATION_KHR=_C('EGL_NO_RESET_NOTIFICATION_KHR',0x31BE) +EGL_OPENGL_ES3_BIT=_C('EGL_OPENGL_ES3_BIT',0x00000040) +EGL_OPENGL_ES3_BIT_KHR=_C('EGL_OPENGL_ES3_BIT_KHR',0x00000040) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/create_context_no_error.py b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/create_context_no_error.py new file mode 100644 index 00000000..a022eb43 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/create_context_no_error.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.EGL import _types as _cs +# End users want this... +from OpenGL.raw.EGL._types import * +from OpenGL.raw.EGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'EGL_KHR_create_context_no_error' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.EGL,'EGL_KHR_create_context_no_error',error_checker=_errors._error_checker) +EGL_CONTEXT_OPENGL_NO_ERROR_KHR=_C('EGL_CONTEXT_OPENGL_NO_ERROR_KHR',0x31B3) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/debug.py b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/debug.py new file mode 100644 index 00000000..e69b4472 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/debug.py @@ -0,0 +1,34 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.EGL import _types as _cs +# End users want this... +from OpenGL.raw.EGL._types import * +from OpenGL.raw.EGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'EGL_KHR_debug' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.EGL,'EGL_KHR_debug',error_checker=_errors._error_checker) +EGL_DEBUG_CALLBACK_KHR=_C('EGL_DEBUG_CALLBACK_KHR',0x33B8) +EGL_DEBUG_MSG_CRITICAL_KHR=_C('EGL_DEBUG_MSG_CRITICAL_KHR',0x33B9) +EGL_DEBUG_MSG_ERROR_KHR=_C('EGL_DEBUG_MSG_ERROR_KHR',0x33BA) +EGL_DEBUG_MSG_INFO_KHR=_C('EGL_DEBUG_MSG_INFO_KHR',0x33BC) +EGL_DEBUG_MSG_WARN_KHR=_C('EGL_DEBUG_MSG_WARN_KHR',0x33BB) +EGL_OBJECT_CONTEXT_KHR=_C('EGL_OBJECT_CONTEXT_KHR',0x33B2) +EGL_OBJECT_DISPLAY_KHR=_C('EGL_OBJECT_DISPLAY_KHR',0x33B1) +EGL_OBJECT_IMAGE_KHR=_C('EGL_OBJECT_IMAGE_KHR',0x33B4) +EGL_OBJECT_STREAM_KHR=_C('EGL_OBJECT_STREAM_KHR',0x33B6) +EGL_OBJECT_SURFACE_KHR=_C('EGL_OBJECT_SURFACE_KHR',0x33B3) +EGL_OBJECT_SYNC_KHR=_C('EGL_OBJECT_SYNC_KHR',0x33B5) +EGL_OBJECT_THREAD_KHR=_C('EGL_OBJECT_THREAD_KHR',0x33B0) +@_f +@_p.types(_cs.EGLint,_cs.EGLDEBUGPROCKHR,arrays.EGLAttribArray) +def eglDebugMessageControlKHR(callback,attrib_list):pass +@_f +@_p.types(_cs.EGLint,_cs.EGLDisplay,_cs.EGLenum,_cs.EGLObjectKHR,_cs.EGLLabelKHR) +def eglLabelObjectKHR(display,objectType,object,label):pass +@_f +@_p.types(_cs.EGLBoolean,_cs.EGLint,arrays.EGLAttribArray) +def eglQueryDebugKHR(attribute,value):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/fence_sync.py b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/fence_sync.py new file mode 100644 index 00000000..e2b86023 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/fence_sync.py @@ -0,0 +1,28 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.EGL import _types as _cs +# End users want this... +from OpenGL.raw.EGL._types import * +from OpenGL.raw.EGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'EGL_KHR_fence_sync' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.EGL,'EGL_KHR_fence_sync',error_checker=_errors._error_checker) +EGL_SYNC_CONDITION_KHR=_C('EGL_SYNC_CONDITION_KHR',0x30F8) +EGL_SYNC_FENCE_KHR=_C('EGL_SYNC_FENCE_KHR',0x30F9) +EGL_SYNC_PRIOR_COMMANDS_COMPLETE_KHR=_C('EGL_SYNC_PRIOR_COMMANDS_COMPLETE_KHR',0x30F0) +@_f +@_p.types(_cs.EGLint,_cs.EGLDisplay,_cs.EGLSyncKHR,_cs.EGLint,_cs.EGLTimeKHR) +def eglClientWaitSyncKHR(dpy,sync,flags,timeout):pass +@_f +@_p.types(_cs.EGLSyncKHR,_cs.EGLDisplay,_cs.EGLenum,arrays.GLintArray) +def eglCreateSyncKHR(dpy,type,attrib_list):pass +@_f +@_p.types(_cs.EGLBoolean,_cs.EGLDisplay,_cs.EGLSyncKHR) +def eglDestroySyncKHR(dpy,sync):pass +@_f +@_p.types(_cs.EGLBoolean,_cs.EGLDisplay,_cs.EGLSyncKHR,_cs.EGLint,arrays.GLintArray) +def eglGetSyncAttribKHR(dpy,sync,attribute,value):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/get_all_proc_addresses.py b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/get_all_proc_addresses.py new file mode 100644 index 00000000..feb261b1 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/get_all_proc_addresses.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.EGL import _types as _cs +# End users want this... +from OpenGL.raw.EGL._types import * +from OpenGL.raw.EGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'EGL_KHR_get_all_proc_addresses' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.EGL,'EGL_KHR_get_all_proc_addresses',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/gl_colorspace.py b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/gl_colorspace.py new file mode 100644 index 00000000..a3af176b --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/gl_colorspace.py @@ -0,0 +1,17 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.EGL import _types as _cs +# End users want this... +from OpenGL.raw.EGL._types import * +from OpenGL.raw.EGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'EGL_KHR_gl_colorspace' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.EGL,'EGL_KHR_gl_colorspace',error_checker=_errors._error_checker) +EGL_GL_COLORSPACE_KHR=_C('EGL_GL_COLORSPACE_KHR',0x309D) +EGL_GL_COLORSPACE_LINEAR_KHR=_C('EGL_GL_COLORSPACE_LINEAR_KHR',0x308A) +EGL_GL_COLORSPACE_SRGB_KHR=_C('EGL_GL_COLORSPACE_SRGB_KHR',0x3089) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/gl_renderbuffer_image.py b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/gl_renderbuffer_image.py new file mode 100644 index 00000000..c01aeac3 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/gl_renderbuffer_image.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.EGL import _types as _cs +# End users want this... +from OpenGL.raw.EGL._types import * +from OpenGL.raw.EGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'EGL_KHR_gl_renderbuffer_image' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.EGL,'EGL_KHR_gl_renderbuffer_image',error_checker=_errors._error_checker) +EGL_GL_RENDERBUFFER_KHR=_C('EGL_GL_RENDERBUFFER_KHR',0x30B9) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/gl_texture_2D_image.py b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/gl_texture_2D_image.py new file mode 100644 index 00000000..6675b7d4 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/gl_texture_2D_image.py @@ -0,0 +1,16 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.EGL import _types as _cs +# End users want this... +from OpenGL.raw.EGL._types import * +from OpenGL.raw.EGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'EGL_KHR_gl_texture_2D_image' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.EGL,'EGL_KHR_gl_texture_2D_image',error_checker=_errors._error_checker) +EGL_GL_TEXTURE_2D_KHR=_C('EGL_GL_TEXTURE_2D_KHR',0x30B1) +EGL_GL_TEXTURE_LEVEL_KHR=_C('EGL_GL_TEXTURE_LEVEL_KHR',0x30BC) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/gl_texture_3D_image.py b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/gl_texture_3D_image.py new file mode 100644 index 00000000..80142eb3 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/gl_texture_3D_image.py @@ -0,0 +1,16 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.EGL import _types as _cs +# End users want this... +from OpenGL.raw.EGL._types import * +from OpenGL.raw.EGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'EGL_KHR_gl_texture_3D_image' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.EGL,'EGL_KHR_gl_texture_3D_image',error_checker=_errors._error_checker) +EGL_GL_TEXTURE_3D_KHR=_C('EGL_GL_TEXTURE_3D_KHR',0x30B2) +EGL_GL_TEXTURE_ZOFFSET_KHR=_C('EGL_GL_TEXTURE_ZOFFSET_KHR',0x30BD) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/gl_texture_cubemap_image.py b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/gl_texture_cubemap_image.py new file mode 100644 index 00000000..9e089e1f --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/gl_texture_cubemap_image.py @@ -0,0 +1,20 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.EGL import _types as _cs +# End users want this... +from OpenGL.raw.EGL._types import * +from OpenGL.raw.EGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'EGL_KHR_gl_texture_cubemap_image' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.EGL,'EGL_KHR_gl_texture_cubemap_image',error_checker=_errors._error_checker) +EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_X_KHR=_C('EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_X_KHR',0x30B4) +EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_KHR=_C('EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_KHR',0x30B6) +EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_KHR=_C('EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_KHR',0x30B8) +EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_X_KHR=_C('EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_X_KHR',0x30B3) +EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_Y_KHR=_C('EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_Y_KHR',0x30B5) +EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_Z_KHR=_C('EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_Z_KHR',0x30B7) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/image.py b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/image.py new file mode 100644 index 00000000..950ffb13 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/image.py @@ -0,0 +1,21 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.EGL import _types as _cs +# End users want this... +from OpenGL.raw.EGL._types import * +from OpenGL.raw.EGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'EGL_KHR_image' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.EGL,'EGL_KHR_image',error_checker=_errors._error_checker) +EGL_NATIVE_PIXMAP_KHR=_C('EGL_NATIVE_PIXMAP_KHR',0x30B0) +# EGL_NO_IMAGE_KHR=_C('EGL_NO_IMAGE_KHR',((EGLImageKHR)0)) +@_f +@_p.types(_cs.EGLImageKHR,_cs.EGLDisplay,_cs.EGLContext,_cs.EGLenum,_cs.EGLClientBuffer,arrays.GLintArray) +def eglCreateImageKHR(dpy,ctx,target,buffer,attrib_list):pass +@_f +@_p.types(_cs.EGLBoolean,_cs.EGLDisplay,_cs.EGLImageKHR) +def eglDestroyImageKHR(dpy,image):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/image_base.py b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/image_base.py new file mode 100644 index 00000000..d8377256 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/image_base.py @@ -0,0 +1,21 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.EGL import _types as _cs +# End users want this... +from OpenGL.raw.EGL._types import * +from OpenGL.raw.EGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'EGL_KHR_image_base' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.EGL,'EGL_KHR_image_base',error_checker=_errors._error_checker) +EGL_IMAGE_PRESERVED_KHR=_C('EGL_IMAGE_PRESERVED_KHR',0x30D2) +# EGL_NO_IMAGE_KHR=_C('EGL_NO_IMAGE_KHR',((EGLImageKHR)0)) +@_f +@_p.types(_cs.EGLImageKHR,_cs.EGLDisplay,_cs.EGLContext,_cs.EGLenum,_cs.EGLClientBuffer,arrays.GLintArray) +def eglCreateImageKHR(dpy,ctx,target,buffer,attrib_list):pass +@_f +@_p.types(_cs.EGLBoolean,_cs.EGLDisplay,_cs.EGLImageKHR) +def eglDestroyImageKHR(dpy,image):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/image_pixmap.py b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/image_pixmap.py new file mode 100644 index 00000000..88f54a17 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/image_pixmap.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.EGL import _types as _cs +# End users want this... +from OpenGL.raw.EGL._types import * +from OpenGL.raw.EGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'EGL_KHR_image_pixmap' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.EGL,'EGL_KHR_image_pixmap',error_checker=_errors._error_checker) +EGL_NATIVE_PIXMAP_KHR=_C('EGL_NATIVE_PIXMAP_KHR',0x30B0) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/lock_surface.py b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/lock_surface.py new file mode 100644 index 00000000..5ee39619 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/lock_surface.py @@ -0,0 +1,40 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.EGL import _types as _cs +# End users want this... +from OpenGL.raw.EGL._types import * +from OpenGL.raw.EGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'EGL_KHR_lock_surface' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.EGL,'EGL_KHR_lock_surface',error_checker=_errors._error_checker) +EGL_BITMAP_ORIGIN_KHR=_C('EGL_BITMAP_ORIGIN_KHR',0x30C8) +EGL_BITMAP_PITCH_KHR=_C('EGL_BITMAP_PITCH_KHR',0x30C7) +EGL_BITMAP_PIXEL_ALPHA_OFFSET_KHR=_C('EGL_BITMAP_PIXEL_ALPHA_OFFSET_KHR',0x30CC) +EGL_BITMAP_PIXEL_BLUE_OFFSET_KHR=_C('EGL_BITMAP_PIXEL_BLUE_OFFSET_KHR',0x30CB) +EGL_BITMAP_PIXEL_GREEN_OFFSET_KHR=_C('EGL_BITMAP_PIXEL_GREEN_OFFSET_KHR',0x30CA) +EGL_BITMAP_PIXEL_LUMINANCE_OFFSET_KHR=_C('EGL_BITMAP_PIXEL_LUMINANCE_OFFSET_KHR',0x30CD) +EGL_BITMAP_PIXEL_RED_OFFSET_KHR=_C('EGL_BITMAP_PIXEL_RED_OFFSET_KHR',0x30C9) +EGL_BITMAP_POINTER_KHR=_C('EGL_BITMAP_POINTER_KHR',0x30C6) +EGL_FORMAT_RGBA_8888_EXACT_KHR=_C('EGL_FORMAT_RGBA_8888_EXACT_KHR',0x30C2) +EGL_FORMAT_RGBA_8888_KHR=_C('EGL_FORMAT_RGBA_8888_KHR',0x30C3) +EGL_FORMAT_RGB_565_EXACT_KHR=_C('EGL_FORMAT_RGB_565_EXACT_KHR',0x30C0) +EGL_FORMAT_RGB_565_KHR=_C('EGL_FORMAT_RGB_565_KHR',0x30C1) +EGL_LOCK_SURFACE_BIT_KHR=_C('EGL_LOCK_SURFACE_BIT_KHR',0x0080) +EGL_LOCK_USAGE_HINT_KHR=_C('EGL_LOCK_USAGE_HINT_KHR',0x30C5) +EGL_LOWER_LEFT_KHR=_C('EGL_LOWER_LEFT_KHR',0x30CE) +EGL_MAP_PRESERVE_PIXELS_KHR=_C('EGL_MAP_PRESERVE_PIXELS_KHR',0x30C4) +EGL_MATCH_FORMAT_KHR=_C('EGL_MATCH_FORMAT_KHR',0x3043) +EGL_OPTIMAL_FORMAT_BIT_KHR=_C('EGL_OPTIMAL_FORMAT_BIT_KHR',0x0100) +EGL_READ_SURFACE_BIT_KHR=_C('EGL_READ_SURFACE_BIT_KHR',0x0001) +EGL_UPPER_LEFT_KHR=_C('EGL_UPPER_LEFT_KHR',0x30CF) +EGL_WRITE_SURFACE_BIT_KHR=_C('EGL_WRITE_SURFACE_BIT_KHR',0x0002) +@_f +@_p.types(_cs.EGLBoolean,_cs.EGLDisplay,_cs.EGLSurface,arrays.GLintArray) +def eglLockSurfaceKHR(dpy,surface,attrib_list):pass +@_f +@_p.types(_cs.EGLBoolean,_cs.EGLDisplay,_cs.EGLSurface) +def eglUnlockSurfaceKHR(dpy,surface):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/lock_surface2.py b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/lock_surface2.py new file mode 100644 index 00000000..00a76deb --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/lock_surface2.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.EGL import _types as _cs +# End users want this... +from OpenGL.raw.EGL._types import * +from OpenGL.raw.EGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'EGL_KHR_lock_surface2' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.EGL,'EGL_KHR_lock_surface2',error_checker=_errors._error_checker) +EGL_BITMAP_PIXEL_SIZE_KHR=_C('EGL_BITMAP_PIXEL_SIZE_KHR',0x3110) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/lock_surface3.py b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/lock_surface3.py new file mode 100644 index 00000000..061450a3 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/lock_surface3.py @@ -0,0 +1,44 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.EGL import _types as _cs +# End users want this... +from OpenGL.raw.EGL._types import * +from OpenGL.raw.EGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'EGL_KHR_lock_surface3' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.EGL,'EGL_KHR_lock_surface3',error_checker=_errors._error_checker) +EGL_BITMAP_ORIGIN_KHR=_C('EGL_BITMAP_ORIGIN_KHR',0x30C8) +EGL_BITMAP_PITCH_KHR=_C('EGL_BITMAP_PITCH_KHR',0x30C7) +EGL_BITMAP_PIXEL_ALPHA_OFFSET_KHR=_C('EGL_BITMAP_PIXEL_ALPHA_OFFSET_KHR',0x30CC) +EGL_BITMAP_PIXEL_BLUE_OFFSET_KHR=_C('EGL_BITMAP_PIXEL_BLUE_OFFSET_KHR',0x30CB) +EGL_BITMAP_PIXEL_GREEN_OFFSET_KHR=_C('EGL_BITMAP_PIXEL_GREEN_OFFSET_KHR',0x30CA) +EGL_BITMAP_PIXEL_LUMINANCE_OFFSET_KHR=_C('EGL_BITMAP_PIXEL_LUMINANCE_OFFSET_KHR',0x30CD) +EGL_BITMAP_PIXEL_RED_OFFSET_KHR=_C('EGL_BITMAP_PIXEL_RED_OFFSET_KHR',0x30C9) +EGL_BITMAP_PIXEL_SIZE_KHR=_C('EGL_BITMAP_PIXEL_SIZE_KHR',0x3110) +EGL_BITMAP_POINTER_KHR=_C('EGL_BITMAP_POINTER_KHR',0x30C6) +EGL_FORMAT_RGBA_8888_EXACT_KHR=_C('EGL_FORMAT_RGBA_8888_EXACT_KHR',0x30C2) +EGL_FORMAT_RGBA_8888_KHR=_C('EGL_FORMAT_RGBA_8888_KHR',0x30C3) +EGL_FORMAT_RGB_565_EXACT_KHR=_C('EGL_FORMAT_RGB_565_EXACT_KHR',0x30C0) +EGL_FORMAT_RGB_565_KHR=_C('EGL_FORMAT_RGB_565_KHR',0x30C1) +EGL_LOCK_SURFACE_BIT_KHR=_C('EGL_LOCK_SURFACE_BIT_KHR',0x0080) +EGL_LOCK_USAGE_HINT_KHR=_C('EGL_LOCK_USAGE_HINT_KHR',0x30C5) +EGL_LOWER_LEFT_KHR=_C('EGL_LOWER_LEFT_KHR',0x30CE) +EGL_MAP_PRESERVE_PIXELS_KHR=_C('EGL_MAP_PRESERVE_PIXELS_KHR',0x30C4) +EGL_MATCH_FORMAT_KHR=_C('EGL_MATCH_FORMAT_KHR',0x3043) +EGL_OPTIMAL_FORMAT_BIT_KHR=_C('EGL_OPTIMAL_FORMAT_BIT_KHR',0x0100) +EGL_READ_SURFACE_BIT_KHR=_C('EGL_READ_SURFACE_BIT_KHR',0x0001) +EGL_UPPER_LEFT_KHR=_C('EGL_UPPER_LEFT_KHR',0x30CF) +EGL_WRITE_SURFACE_BIT_KHR=_C('EGL_WRITE_SURFACE_BIT_KHR',0x0002) +@_f +@_p.types(_cs.EGLBoolean,_cs.EGLDisplay,_cs.EGLSurface,arrays.GLintArray) +def eglLockSurfaceKHR(dpy,surface,attrib_list):pass +@_f +@_p.types(_cs.EGLBoolean,_cs.EGLDisplay,_cs.EGLSurface,_cs.EGLint,ctypes.POINTER(_cs.EGLAttribKHR)) +def eglQuerySurface64KHR(dpy,surface,attribute,value):pass +@_f +@_p.types(_cs.EGLBoolean,_cs.EGLDisplay,_cs.EGLSurface) +def eglUnlockSurfaceKHR(dpy,surface):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/partial_update.py b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/partial_update.py new file mode 100644 index 00000000..f584e93c --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/partial_update.py @@ -0,0 +1,17 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.EGL import _types as _cs +# End users want this... +from OpenGL.raw.EGL._types import * +from OpenGL.raw.EGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'EGL_KHR_partial_update' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.EGL,'EGL_KHR_partial_update',error_checker=_errors._error_checker) +EGL_BUFFER_AGE_KHR=_C('EGL_BUFFER_AGE_KHR',0x313D) +@_f +@_p.types(_cs.EGLBoolean,_cs.EGLDisplay,_cs.EGLSurface,arrays.GLintArray,_cs.EGLint) +def eglSetDamageRegionKHR(dpy,surface,rects,n_rects):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/platform_android.py b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/platform_android.py new file mode 100644 index 00000000..0537311a --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/platform_android.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.EGL import _types as _cs +# End users want this... +from OpenGL.raw.EGL._types import * +from OpenGL.raw.EGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'EGL_KHR_platform_android' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.EGL,'EGL_KHR_platform_android',error_checker=_errors._error_checker) +EGL_PLATFORM_ANDROID_KHR=_C('EGL_PLATFORM_ANDROID_KHR',0x3141) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/platform_gbm.py b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/platform_gbm.py new file mode 100644 index 00000000..fc4ffbbd --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/platform_gbm.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.EGL import _types as _cs +# End users want this... +from OpenGL.raw.EGL._types import * +from OpenGL.raw.EGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'EGL_KHR_platform_gbm' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.EGL,'EGL_KHR_platform_gbm',error_checker=_errors._error_checker) +EGL_PLATFORM_GBM_KHR=_C('EGL_PLATFORM_GBM_KHR',0x31D7) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/platform_wayland.py b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/platform_wayland.py new file mode 100644 index 00000000..73244c8e --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/platform_wayland.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.EGL import _types as _cs +# End users want this... +from OpenGL.raw.EGL._types import * +from OpenGL.raw.EGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'EGL_KHR_platform_wayland' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.EGL,'EGL_KHR_platform_wayland',error_checker=_errors._error_checker) +EGL_PLATFORM_WAYLAND_KHR=_C('EGL_PLATFORM_WAYLAND_KHR',0x31D8) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/platform_x11.py b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/platform_x11.py new file mode 100644 index 00000000..4075a5ca --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/platform_x11.py @@ -0,0 +1,16 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.EGL import _types as _cs +# End users want this... +from OpenGL.raw.EGL._types import * +from OpenGL.raw.EGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'EGL_KHR_platform_x11' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.EGL,'EGL_KHR_platform_x11',error_checker=_errors._error_checker) +EGL_PLATFORM_X11_KHR=_C('EGL_PLATFORM_X11_KHR',0x31D5) +EGL_PLATFORM_X11_SCREEN_KHR=_C('EGL_PLATFORM_X11_SCREEN_KHR',0x31D6) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/reusable_sync.py b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/reusable_sync.py new file mode 100644 index 00000000..c43015d1 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/reusable_sync.py @@ -0,0 +1,38 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.EGL import _types as _cs +# End users want this... +from OpenGL.raw.EGL._types import * +from OpenGL.raw.EGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'EGL_KHR_reusable_sync' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.EGL,'EGL_KHR_reusable_sync',error_checker=_errors._error_checker) +EGL_CONDITION_SATISFIED_KHR=_C('EGL_CONDITION_SATISFIED_KHR',0x30F6) +EGL_FOREVER_KHR=_C('EGL_FOREVER_KHR',0xFFFFFFFFFFFFFFFF) +# EGL_NO_SYNC_KHR=_C('EGL_NO_SYNC_KHR',((EGLSyncKHR)0)) +EGL_SIGNALED_KHR=_C('EGL_SIGNALED_KHR',0x30F2) +EGL_SYNC_FLUSH_COMMANDS_BIT_KHR=_C('EGL_SYNC_FLUSH_COMMANDS_BIT_KHR',0x0001) +EGL_SYNC_REUSABLE_KHR=_C('EGL_SYNC_REUSABLE_KHR',0x30FA) +EGL_SYNC_STATUS_KHR=_C('EGL_SYNC_STATUS_KHR',0x30F1) +EGL_SYNC_TYPE_KHR=_C('EGL_SYNC_TYPE_KHR',0x30F7) +EGL_TIMEOUT_EXPIRED_KHR=_C('EGL_TIMEOUT_EXPIRED_KHR',0x30F5) +EGL_UNSIGNALED_KHR=_C('EGL_UNSIGNALED_KHR',0x30F3) +@_f +@_p.types(_cs.EGLint,_cs.EGLDisplay,_cs.EGLSyncKHR,_cs.EGLint,_cs.EGLTimeKHR) +def eglClientWaitSyncKHR(dpy,sync,flags,timeout):pass +@_f +@_p.types(_cs.EGLSyncKHR,_cs.EGLDisplay,_cs.EGLenum,arrays.GLintArray) +def eglCreateSyncKHR(dpy,type,attrib_list):pass +@_f +@_p.types(_cs.EGLBoolean,_cs.EGLDisplay,_cs.EGLSyncKHR) +def eglDestroySyncKHR(dpy,sync):pass +@_f +@_p.types(_cs.EGLBoolean,_cs.EGLDisplay,_cs.EGLSyncKHR,_cs.EGLint,arrays.GLintArray) +def eglGetSyncAttribKHR(dpy,sync,attribute,value):pass +@_f +@_p.types(_cs.EGLBoolean,_cs.EGLDisplay,_cs.EGLSyncKHR,_cs.EGLenum) +def eglSignalSyncKHR(dpy,sync,mode):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/stream.py b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/stream.py new file mode 100644 index 00000000..2fcca881 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/stream.py @@ -0,0 +1,41 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.EGL import _types as _cs +# End users want this... +from OpenGL.raw.EGL._types import * +from OpenGL.raw.EGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'EGL_KHR_stream' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.EGL,'EGL_KHR_stream',error_checker=_errors._error_checker) +EGL_BAD_STATE_KHR=_C('EGL_BAD_STATE_KHR',0x321C) +EGL_BAD_STREAM_KHR=_C('EGL_BAD_STREAM_KHR',0x321B) +EGL_CONSUMER_FRAME_KHR=_C('EGL_CONSUMER_FRAME_KHR',0x3213) +EGL_CONSUMER_LATENCY_USEC_KHR=_C('EGL_CONSUMER_LATENCY_USEC_KHR',0x3210) +# EGL_NO_STREAM_KHR=_C('EGL_NO_STREAM_KHR',((EGLStreamKHR)0)) +EGL_PRODUCER_FRAME_KHR=_C('EGL_PRODUCER_FRAME_KHR',0x3212) +EGL_STREAM_STATE_CONNECTING_KHR=_C('EGL_STREAM_STATE_CONNECTING_KHR',0x3216) +EGL_STREAM_STATE_CREATED_KHR=_C('EGL_STREAM_STATE_CREATED_KHR',0x3215) +EGL_STREAM_STATE_DISCONNECTED_KHR=_C('EGL_STREAM_STATE_DISCONNECTED_KHR',0x321A) +EGL_STREAM_STATE_EMPTY_KHR=_C('EGL_STREAM_STATE_EMPTY_KHR',0x3217) +EGL_STREAM_STATE_KHR=_C('EGL_STREAM_STATE_KHR',0x3214) +EGL_STREAM_STATE_NEW_FRAME_AVAILABLE_KHR=_C('EGL_STREAM_STATE_NEW_FRAME_AVAILABLE_KHR',0x3218) +EGL_STREAM_STATE_OLD_FRAME_AVAILABLE_KHR=_C('EGL_STREAM_STATE_OLD_FRAME_AVAILABLE_KHR',0x3219) +@_f +@_p.types(_cs.EGLStreamKHR,_cs.EGLDisplay,arrays.GLintArray) +def eglCreateStreamKHR(dpy,attrib_list):pass +@_f +@_p.types(_cs.EGLBoolean,_cs.EGLDisplay,_cs.EGLStreamKHR) +def eglDestroyStreamKHR(dpy,stream):pass +@_f +@_p.types(_cs.EGLBoolean,_cs.EGLDisplay,_cs.EGLStreamKHR,_cs.EGLenum,arrays.GLintArray) +def eglQueryStreamKHR(dpy,stream,attribute,value):pass +@_f +@_p.types(_cs.EGLBoolean,_cs.EGLDisplay,_cs.EGLStreamKHR,_cs.EGLenum,arrays.GLuint64Array) +def eglQueryStreamu64KHR(dpy,stream,attribute,value):pass +@_f +@_p.types(_cs.EGLBoolean,_cs.EGLDisplay,_cs.EGLStreamKHR,_cs.EGLenum,_cs.EGLint) +def eglStreamAttribKHR(dpy,stream,attribute,value):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/stream_consumer_gltexture.py b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/stream_consumer_gltexture.py new file mode 100644 index 00000000..934f1dd4 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/stream_consumer_gltexture.py @@ -0,0 +1,23 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.EGL import _types as _cs +# End users want this... +from OpenGL.raw.EGL._types import * +from OpenGL.raw.EGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'EGL_KHR_stream_consumer_gltexture' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.EGL,'EGL_KHR_stream_consumer_gltexture',error_checker=_errors._error_checker) +EGL_CONSUMER_ACQUIRE_TIMEOUT_USEC_KHR=_C('EGL_CONSUMER_ACQUIRE_TIMEOUT_USEC_KHR',0x321E) +@_f +@_p.types(_cs.EGLBoolean,_cs.EGLDisplay,_cs.EGLStreamKHR) +def eglStreamConsumerAcquireKHR(dpy,stream):pass +@_f +@_p.types(_cs.EGLBoolean,_cs.EGLDisplay,_cs.EGLStreamKHR) +def eglStreamConsumerGLTextureExternalKHR(dpy,stream):pass +@_f +@_p.types(_cs.EGLBoolean,_cs.EGLDisplay,_cs.EGLStreamKHR) +def eglStreamConsumerReleaseKHR(dpy,stream):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/stream_cross_process_fd.py b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/stream_cross_process_fd.py new file mode 100644 index 00000000..aee1d0fc --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/stream_cross_process_fd.py @@ -0,0 +1,20 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.EGL import _types as _cs +# End users want this... +from OpenGL.raw.EGL._types import * +from OpenGL.raw.EGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'EGL_KHR_stream_cross_process_fd' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.EGL,'EGL_KHR_stream_cross_process_fd',error_checker=_errors._error_checker) +# EGL_NO_FILE_DESCRIPTOR_KHR=_C('EGL_NO_FILE_DESCRIPTOR_KHR',((EGLNativeFileDescriptorKHR)(-1))) +@_f +@_p.types(_cs.EGLStreamKHR,_cs.EGLDisplay,_cs.EGLNativeFileDescriptorKHR) +def eglCreateStreamFromFileDescriptorKHR(dpy,file_descriptor):pass +@_f +@_p.types(_cs.EGLNativeFileDescriptorKHR,_cs.EGLDisplay,_cs.EGLStreamKHR) +def eglGetStreamFileDescriptorKHR(dpy,stream):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/stream_fifo.py b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/stream_fifo.py new file mode 100644 index 00000000..1b91955c --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/stream_fifo.py @@ -0,0 +1,20 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.EGL import _types as _cs +# End users want this... +from OpenGL.raw.EGL._types import * +from OpenGL.raw.EGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'EGL_KHR_stream_fifo' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.EGL,'EGL_KHR_stream_fifo',error_checker=_errors._error_checker) +EGL_STREAM_FIFO_LENGTH_KHR=_C('EGL_STREAM_FIFO_LENGTH_KHR',0x31FC) +EGL_STREAM_TIME_CONSUMER_KHR=_C('EGL_STREAM_TIME_CONSUMER_KHR',0x31FE) +EGL_STREAM_TIME_NOW_KHR=_C('EGL_STREAM_TIME_NOW_KHR',0x31FD) +EGL_STREAM_TIME_PRODUCER_KHR=_C('EGL_STREAM_TIME_PRODUCER_KHR',0x31FF) +@_f +@_p.types(_cs.EGLBoolean,_cs.EGLDisplay,_cs.EGLStreamKHR,_cs.EGLenum,arrays.GLuint64Array) +def eglQueryStreamTimeKHR(dpy,stream,attribute,value):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/stream_producer_aldatalocator.py b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/stream_producer_aldatalocator.py new file mode 100644 index 00000000..c03a120c --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/stream_producer_aldatalocator.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.EGL import _types as _cs +# End users want this... +from OpenGL.raw.EGL._types import * +from OpenGL.raw.EGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'EGL_KHR_stream_producer_aldatalocator' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.EGL,'EGL_KHR_stream_producer_aldatalocator',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/stream_producer_eglsurface.py b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/stream_producer_eglsurface.py new file mode 100644 index 00000000..3f441e90 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/stream_producer_eglsurface.py @@ -0,0 +1,17 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.EGL import _types as _cs +# End users want this... +from OpenGL.raw.EGL._types import * +from OpenGL.raw.EGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'EGL_KHR_stream_producer_eglsurface' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.EGL,'EGL_KHR_stream_producer_eglsurface',error_checker=_errors._error_checker) +EGL_STREAM_BIT_KHR=_C('EGL_STREAM_BIT_KHR',0x0800) +@_f +@_p.types(_cs.EGLSurface,_cs.EGLDisplay,_cs.EGLConfig,_cs.EGLStreamKHR,arrays.GLintArray) +def eglCreateStreamProducerSurfaceKHR(dpy,config,stream,attrib_list):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/surfaceless_context.py b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/surfaceless_context.py new file mode 100644 index 00000000..09121f48 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/surfaceless_context.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.EGL import _types as _cs +# End users want this... +from OpenGL.raw.EGL._types import * +from OpenGL.raw.EGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'EGL_KHR_surfaceless_context' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.EGL,'EGL_KHR_surfaceless_context',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/swap_buffers_with_damage.py b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/swap_buffers_with_damage.py new file mode 100644 index 00000000..06cf72d1 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/swap_buffers_with_damage.py @@ -0,0 +1,17 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.EGL import _types as _cs +# End users want this... +from OpenGL.raw.EGL._types import * +from OpenGL.raw.EGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'EGL_KHR_swap_buffers_with_damage' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.EGL,'EGL_KHR_swap_buffers_with_damage',error_checker=_errors._error_checker) + +@_f +@_p.types(_cs.EGLBoolean,_cs.EGLDisplay,_cs.EGLSurface,arrays.GLintArray,_cs.EGLint) +def eglSwapBuffersWithDamageKHR(dpy,surface,rects,n_rects):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/vg_parent_image.py b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/vg_parent_image.py new file mode 100644 index 00000000..b3eb9c2b --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/vg_parent_image.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.EGL import _types as _cs +# End users want this... +from OpenGL.raw.EGL._types import * +from OpenGL.raw.EGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'EGL_KHR_vg_parent_image' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.EGL,'EGL_KHR_vg_parent_image',error_checker=_errors._error_checker) +EGL_VG_PARENT_IMAGE_KHR=_C('EGL_VG_PARENT_IMAGE_KHR',0x30BA) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/wait_sync.py b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/wait_sync.py new file mode 100644 index 00000000..31418234 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/KHR/wait_sync.py @@ -0,0 +1,17 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.EGL import _types as _cs +# End users want this... +from OpenGL.raw.EGL._types import * +from OpenGL.raw.EGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'EGL_KHR_wait_sync' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.EGL,'EGL_KHR_wait_sync',error_checker=_errors._error_checker) + +@_f +@_p.types(_cs.EGLint,_cs.EGLDisplay,_cs.EGLSyncKHR,_cs.EGLint) +def eglWaitSyncKHR(dpy,sync,flags):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/MESA/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/MESA/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/MESA/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/MESA/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/MESA/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..43dfe674 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/MESA/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/MESA/__pycache__/drm_image.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/MESA/__pycache__/drm_image.cpython-312.pyc new file mode 100644 index 00000000..6c043f86 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/MESA/__pycache__/drm_image.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/MESA/__pycache__/image_dma_buf_export.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/MESA/__pycache__/image_dma_buf_export.cpython-312.pyc new file mode 100644 index 00000000..4abf514c Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/MESA/__pycache__/image_dma_buf_export.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/MESA/__pycache__/platform_gbm.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/MESA/__pycache__/platform_gbm.cpython-312.pyc new file mode 100644 index 00000000..45af3e4e Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/MESA/__pycache__/platform_gbm.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/MESA/drm_image.py b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/MESA/drm_image.py new file mode 100644 index 00000000..6a173322 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/MESA/drm_image.py @@ -0,0 +1,26 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.EGL import _types as _cs +# End users want this... +from OpenGL.raw.EGL._types import * +from OpenGL.raw.EGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'EGL_MESA_drm_image' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.EGL,'EGL_MESA_drm_image',error_checker=_errors._error_checker) +EGL_DRM_BUFFER_FORMAT_ARGB32_MESA=_C('EGL_DRM_BUFFER_FORMAT_ARGB32_MESA',0x31D2) +EGL_DRM_BUFFER_FORMAT_MESA=_C('EGL_DRM_BUFFER_FORMAT_MESA',0x31D0) +EGL_DRM_BUFFER_MESA=_C('EGL_DRM_BUFFER_MESA',0x31D3) +EGL_DRM_BUFFER_STRIDE_MESA=_C('EGL_DRM_BUFFER_STRIDE_MESA',0x31D4) +EGL_DRM_BUFFER_USE_MESA=_C('EGL_DRM_BUFFER_USE_MESA',0x31D1) +EGL_DRM_BUFFER_USE_SCANOUT_MESA=_C('EGL_DRM_BUFFER_USE_SCANOUT_MESA',0x00000001) +EGL_DRM_BUFFER_USE_SHARE_MESA=_C('EGL_DRM_BUFFER_USE_SHARE_MESA',0x00000002) +@_f +@_p.types(_cs.EGLImageKHR,_cs.EGLDisplay,arrays.GLintArray) +def eglCreateDRMImageMESA(dpy,attrib_list):pass +@_f +@_p.types(_cs.EGLBoolean,_cs.EGLDisplay,_cs.EGLImageKHR,arrays.GLintArray,arrays.GLintArray,arrays.GLintArray) +def eglExportDRMImageMESA(dpy,image,name,handle,stride):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/MESA/image_dma_buf_export.py b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/MESA/image_dma_buf_export.py new file mode 100644 index 00000000..376dce02 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/MESA/image_dma_buf_export.py @@ -0,0 +1,20 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.EGL import _types as _cs +# End users want this... +from OpenGL.raw.EGL._types import * +from OpenGL.raw.EGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'EGL_MESA_image_dma_buf_export' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.EGL,'EGL_MESA_image_dma_buf_export',error_checker=_errors._error_checker) + +@_f +@_p.types(_cs.EGLBoolean,_cs.EGLDisplay,_cs.EGLImageKHR,ctypes.POINTER(_cs.c_int),arrays.GLintArray,arrays.GLintArray) +def eglExportDMABUFImageMESA(dpy,image,fds,strides,offsets):pass +@_f +@_p.types(_cs.EGLBoolean,_cs.EGLDisplay,_cs.EGLImageKHR,ctypes.POINTER(_cs.c_int),ctypes.POINTER(_cs.c_int),arrays.GLuint64Array) +def eglExportDMABUFImageQueryMESA(dpy,image,fourcc,num_planes,modifiers):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/MESA/platform_gbm.py b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/MESA/platform_gbm.py new file mode 100644 index 00000000..72c80410 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/MESA/platform_gbm.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.EGL import _types as _cs +# End users want this... +from OpenGL.raw.EGL._types import * +from OpenGL.raw.EGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'EGL_MESA_platform_gbm' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.EGL,'EGL_MESA_platform_gbm',error_checker=_errors._error_checker) +EGL_PLATFORM_GBM_MESA=_C('EGL_PLATFORM_GBM_MESA',0x31D7) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/NOK/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/NOK/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/NOK/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/NOK/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/NOK/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..5df3d9be Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/NOK/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/NOK/__pycache__/swap_region.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/NOK/__pycache__/swap_region.cpython-312.pyc new file mode 100644 index 00000000..866f3ee1 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/NOK/__pycache__/swap_region.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/NOK/__pycache__/swap_region2.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/NOK/__pycache__/swap_region2.cpython-312.pyc new file mode 100644 index 00000000..be300a63 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/NOK/__pycache__/swap_region2.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/NOK/__pycache__/texture_from_pixmap.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/NOK/__pycache__/texture_from_pixmap.cpython-312.pyc new file mode 100644 index 00000000..8dd7deb5 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/NOK/__pycache__/texture_from_pixmap.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/NOK/swap_region.py b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/NOK/swap_region.py new file mode 100644 index 00000000..232fbcac --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/NOK/swap_region.py @@ -0,0 +1,17 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.EGL import _types as _cs +# End users want this... +from OpenGL.raw.EGL._types import * +from OpenGL.raw.EGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'EGL_NOK_swap_region' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.EGL,'EGL_NOK_swap_region',error_checker=_errors._error_checker) + +@_f +@_p.types(_cs.EGLBoolean,_cs.EGLDisplay,_cs.EGLSurface,_cs.EGLint,arrays.GLintArray) +def eglSwapBuffersRegionNOK(dpy,surface,numRects,rects):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/NOK/swap_region2.py b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/NOK/swap_region2.py new file mode 100644 index 00000000..e2157e1b --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/NOK/swap_region2.py @@ -0,0 +1,17 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.EGL import _types as _cs +# End users want this... +from OpenGL.raw.EGL._types import * +from OpenGL.raw.EGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'EGL_NOK_swap_region2' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.EGL,'EGL_NOK_swap_region2',error_checker=_errors._error_checker) + +@_f +@_p.types(_cs.EGLBoolean,_cs.EGLDisplay,_cs.EGLSurface,_cs.EGLint,arrays.GLintArray) +def eglSwapBuffersRegion2NOK(dpy,surface,numRects,rects):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/NOK/texture_from_pixmap.py b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/NOK/texture_from_pixmap.py new file mode 100644 index 00000000..8f17d3ef --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/NOK/texture_from_pixmap.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.EGL import _types as _cs +# End users want this... +from OpenGL.raw.EGL._types import * +from OpenGL.raw.EGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'EGL_NOK_texture_from_pixmap' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.EGL,'EGL_NOK_texture_from_pixmap',error_checker=_errors._error_checker) +EGL_Y_INVERTED_NOK=_C('EGL_Y_INVERTED_NOK',0x307F) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/NV/EGL_3dvision_surface.py b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/NV/EGL_3dvision_surface.py new file mode 100644 index 00000000..eaeb2946 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/NV/EGL_3dvision_surface.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.EGL import _types as _cs +# End users want this... +from OpenGL.raw.EGL._types import * +from OpenGL.raw.EGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'EGL_NV_EGL_3dvision_surface' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.EGL,'EGL_NV_EGL_3dvision_surface',error_checker=_errors._error_checker) +EGL_AUTO_STEREO_NV=_C('EGL_AUTO_STEREO_NV',0x3136) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/NV/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/NV/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/NV/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/NV/__pycache__/EGL_3dvision_surface.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/NV/__pycache__/EGL_3dvision_surface.cpython-312.pyc new file mode 100644 index 00000000..96daddad Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/NV/__pycache__/EGL_3dvision_surface.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/NV/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/NV/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..5d6697ad Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/NV/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/NV/__pycache__/coverage_sample.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/NV/__pycache__/coverage_sample.cpython-312.pyc new file mode 100644 index 00000000..3a934408 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/NV/__pycache__/coverage_sample.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/NV/__pycache__/coverage_sample_resolve.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/NV/__pycache__/coverage_sample_resolve.cpython-312.pyc new file mode 100644 index 00000000..0f576864 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/NV/__pycache__/coverage_sample_resolve.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/NV/__pycache__/cuda_event.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/NV/__pycache__/cuda_event.cpython-312.pyc new file mode 100644 index 00000000..9b9d902b Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/NV/__pycache__/cuda_event.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/NV/__pycache__/depth_nonlinear.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/NV/__pycache__/depth_nonlinear.cpython-312.pyc new file mode 100644 index 00000000..75699528 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/NV/__pycache__/depth_nonlinear.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/NV/__pycache__/device_cuda.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/NV/__pycache__/device_cuda.cpython-312.pyc new file mode 100644 index 00000000..fb701cbd Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/NV/__pycache__/device_cuda.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/NV/__pycache__/native_query.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/NV/__pycache__/native_query.cpython-312.pyc new file mode 100644 index 00000000..a52143b4 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/NV/__pycache__/native_query.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/NV/__pycache__/post_convert_rounding.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/NV/__pycache__/post_convert_rounding.cpython-312.pyc new file mode 100644 index 00000000..c03376f0 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/NV/__pycache__/post_convert_rounding.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/NV/__pycache__/post_sub_buffer.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/NV/__pycache__/post_sub_buffer.cpython-312.pyc new file mode 100644 index 00000000..b4ce9f60 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/NV/__pycache__/post_sub_buffer.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/NV/__pycache__/stream_consumer_gltexture_yuv.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/NV/__pycache__/stream_consumer_gltexture_yuv.cpython-312.pyc new file mode 100644 index 00000000..7de36bd0 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/NV/__pycache__/stream_consumer_gltexture_yuv.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/NV/__pycache__/stream_metadata.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/NV/__pycache__/stream_metadata.cpython-312.pyc new file mode 100644 index 00000000..c77e70b8 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/NV/__pycache__/stream_metadata.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/NV/__pycache__/stream_sync.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/NV/__pycache__/stream_sync.cpython-312.pyc new file mode 100644 index 00000000..e6f34dd2 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/NV/__pycache__/stream_sync.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/NV/__pycache__/sync.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/NV/__pycache__/sync.cpython-312.pyc new file mode 100644 index 00000000..bb1cf2d2 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/NV/__pycache__/sync.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/NV/__pycache__/system_time.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/NV/__pycache__/system_time.cpython-312.pyc new file mode 100644 index 00000000..d90c8dc9 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/NV/__pycache__/system_time.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/NV/coverage_sample.py b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/NV/coverage_sample.py new file mode 100644 index 00000000..4d19e711 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/NV/coverage_sample.py @@ -0,0 +1,16 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.EGL import _types as _cs +# End users want this... +from OpenGL.raw.EGL._types import * +from OpenGL.raw.EGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'EGL_NV_coverage_sample' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.EGL,'EGL_NV_coverage_sample',error_checker=_errors._error_checker) +EGL_COVERAGE_BUFFERS_NV=_C('EGL_COVERAGE_BUFFERS_NV',0x30E0) +EGL_COVERAGE_SAMPLES_NV=_C('EGL_COVERAGE_SAMPLES_NV',0x30E1) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/NV/coverage_sample_resolve.py b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/NV/coverage_sample_resolve.py new file mode 100644 index 00000000..1adb50bb --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/NV/coverage_sample_resolve.py @@ -0,0 +1,17 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.EGL import _types as _cs +# End users want this... +from OpenGL.raw.EGL._types import * +from OpenGL.raw.EGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'EGL_NV_coverage_sample_resolve' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.EGL,'EGL_NV_coverage_sample_resolve',error_checker=_errors._error_checker) +EGL_COVERAGE_SAMPLE_RESOLVE_DEFAULT_NV=_C('EGL_COVERAGE_SAMPLE_RESOLVE_DEFAULT_NV',0x3132) +EGL_COVERAGE_SAMPLE_RESOLVE_NONE_NV=_C('EGL_COVERAGE_SAMPLE_RESOLVE_NONE_NV',0x3133) +EGL_COVERAGE_SAMPLE_RESOLVE_NV=_C('EGL_COVERAGE_SAMPLE_RESOLVE_NV',0x3131) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/NV/cuda_event.py b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/NV/cuda_event.py new file mode 100644 index 00000000..e9e2334f --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/NV/cuda_event.py @@ -0,0 +1,17 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.EGL import _types as _cs +# End users want this... +from OpenGL.raw.EGL._types import * +from OpenGL.raw.EGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'EGL_NV_cuda_event' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.EGL,'EGL_NV_cuda_event',error_checker=_errors._error_checker) +EGL_CUDA_EVENT_HANDLE_NV=_C('EGL_CUDA_EVENT_HANDLE_NV',0x323B) +EGL_SYNC_CUDA_EVENT_COMPLETE_NV=_C('EGL_SYNC_CUDA_EVENT_COMPLETE_NV',0x323D) +EGL_SYNC_CUDA_EVENT_NV=_C('EGL_SYNC_CUDA_EVENT_NV',0x323C) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/NV/depth_nonlinear.py b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/NV/depth_nonlinear.py new file mode 100644 index 00000000..f7d7bfa0 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/NV/depth_nonlinear.py @@ -0,0 +1,17 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.EGL import _types as _cs +# End users want this... +from OpenGL.raw.EGL._types import * +from OpenGL.raw.EGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'EGL_NV_depth_nonlinear' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.EGL,'EGL_NV_depth_nonlinear',error_checker=_errors._error_checker) +EGL_DEPTH_ENCODING_NONE_NV=_C('EGL_DEPTH_ENCODING_NONE_NV',0) +EGL_DEPTH_ENCODING_NONLINEAR_NV=_C('EGL_DEPTH_ENCODING_NONLINEAR_NV',0x30E3) +EGL_DEPTH_ENCODING_NV=_C('EGL_DEPTH_ENCODING_NV',0x30E2) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/NV/device_cuda.py b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/NV/device_cuda.py new file mode 100644 index 00000000..eaab2677 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/NV/device_cuda.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.EGL import _types as _cs +# End users want this... +from OpenGL.raw.EGL._types import * +from OpenGL.raw.EGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'EGL_NV_device_cuda' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.EGL,'EGL_NV_device_cuda',error_checker=_errors._error_checker) +EGL_CUDA_DEVICE_NV=_C('EGL_CUDA_DEVICE_NV',0x323A) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/NV/native_query.py b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/NV/native_query.py new file mode 100644 index 00000000..f5809acd --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/NV/native_query.py @@ -0,0 +1,23 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.EGL import _types as _cs +# End users want this... +from OpenGL.raw.EGL._types import * +from OpenGL.raw.EGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'EGL_NV_native_query' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.EGL,'EGL_NV_native_query',error_checker=_errors._error_checker) + +@_f +@_p.types(_cs.EGLBoolean,_cs.EGLDisplay,arrays.GLvoidpArray) +def eglQueryNativeDisplayNV(dpy,display_id):pass +@_f +@_p.types(_cs.EGLBoolean,_cs.EGLDisplay,_cs.EGLSurface,arrays.GLvoidpArray) +def eglQueryNativePixmapNV(dpy,surf,pixmap):pass +@_f +@_p.types(_cs.EGLBoolean,_cs.EGLDisplay,_cs.EGLSurface,arrays.GLvoidpArray) +def eglQueryNativeWindowNV(dpy,surf,window):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/NV/post_convert_rounding.py b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/NV/post_convert_rounding.py new file mode 100644 index 00000000..5ff2f116 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/NV/post_convert_rounding.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.EGL import _types as _cs +# End users want this... +from OpenGL.raw.EGL._types import * +from OpenGL.raw.EGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'EGL_NV_post_convert_rounding' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.EGL,'EGL_NV_post_convert_rounding',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/NV/post_sub_buffer.py b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/NV/post_sub_buffer.py new file mode 100644 index 00000000..0b90fb05 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/NV/post_sub_buffer.py @@ -0,0 +1,17 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.EGL import _types as _cs +# End users want this... +from OpenGL.raw.EGL._types import * +from OpenGL.raw.EGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'EGL_NV_post_sub_buffer' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.EGL,'EGL_NV_post_sub_buffer',error_checker=_errors._error_checker) +EGL_POST_SUB_BUFFER_SUPPORTED_NV=_C('EGL_POST_SUB_BUFFER_SUPPORTED_NV',0x30BE) +@_f +@_p.types(_cs.EGLBoolean,_cs.EGLDisplay,_cs.EGLSurface,_cs.EGLint,_cs.EGLint,_cs.EGLint,_cs.EGLint) +def eglPostSubBufferNV(dpy,surface,x,y,width,height):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/NV/stream_consumer_gltexture_yuv.py b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/NV/stream_consumer_gltexture_yuv.py new file mode 100644 index 00000000..0f1859f5 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/NV/stream_consumer_gltexture_yuv.py @@ -0,0 +1,21 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.EGL import _types as _cs +# End users want this... +from OpenGL.raw.EGL._types import * +from OpenGL.raw.EGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'EGL_NV_stream_consumer_gltexture_yuv' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.EGL,'EGL_NV_stream_consumer_gltexture_yuv',error_checker=_errors._error_checker) +EGL_YUV_BUFFER_EXT=_C('EGL_YUV_BUFFER_EXT',0x3300) +EGL_YUV_NUMBER_OF_PLANES_EXT=_C('EGL_YUV_NUMBER_OF_PLANES_EXT',0x3311) +EGL_YUV_PLANE0_TEXTURE_UNIT_NV=_C('EGL_YUV_PLANE0_TEXTURE_UNIT_NV',0x332C) +EGL_YUV_PLANE1_TEXTURE_UNIT_NV=_C('EGL_YUV_PLANE1_TEXTURE_UNIT_NV',0x332D) +EGL_YUV_PLANE2_TEXTURE_UNIT_NV=_C('EGL_YUV_PLANE2_TEXTURE_UNIT_NV',0x332E) +@_f +@_p.types(_cs.EGLBoolean,_cs.EGLDisplay,_cs.EGLStreamKHR,_cs.EGLAttrib) +def eglStreamConsumerGLTextureExternalAttribsNV(dpy,stream,*attrib_list):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/NV/stream_metadata.py b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/NV/stream_metadata.py new file mode 100644 index 00000000..8d762755 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/NV/stream_metadata.py @@ -0,0 +1,36 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.EGL import _types as _cs +# End users want this... +from OpenGL.raw.EGL._types import * +from OpenGL.raw.EGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'EGL_NV_stream_metadata' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.EGL,'EGL_NV_stream_metadata',error_checker=_errors._error_checker) +EGL_CONSUMER_METADATA_NV=_C('EGL_CONSUMER_METADATA_NV',0x3254) +EGL_MAX_STREAM_METADATA_BLOCKS_NV=_C('EGL_MAX_STREAM_METADATA_BLOCKS_NV',0x3250) +EGL_MAX_STREAM_METADATA_BLOCK_SIZE_NV=_C('EGL_MAX_STREAM_METADATA_BLOCK_SIZE_NV',0x3251) +EGL_MAX_STREAM_METADATA_TOTAL_SIZE_NV=_C('EGL_MAX_STREAM_METADATA_TOTAL_SIZE_NV',0x3252) +EGL_METADATA0_SIZE_NV=_C('EGL_METADATA0_SIZE_NV',0x3255) +EGL_METADATA0_TYPE_NV=_C('EGL_METADATA0_TYPE_NV',0x3259) +EGL_METADATA1_SIZE_NV=_C('EGL_METADATA1_SIZE_NV',0x3256) +EGL_METADATA1_TYPE_NV=_C('EGL_METADATA1_TYPE_NV',0x325A) +EGL_METADATA2_SIZE_NV=_C('EGL_METADATA2_SIZE_NV',0x3257) +EGL_METADATA2_TYPE_NV=_C('EGL_METADATA2_TYPE_NV',0x325B) +EGL_METADATA3_SIZE_NV=_C('EGL_METADATA3_SIZE_NV',0x3258) +EGL_METADATA3_TYPE_NV=_C('EGL_METADATA3_TYPE_NV',0x325C) +EGL_PENDING_METADATA_NV=_C('EGL_PENDING_METADATA_NV',0x3328) +EGL_PRODUCER_METADATA_NV=_C('EGL_PRODUCER_METADATA_NV',0x3253) +@_f +@_p.types(_cs.EGLBoolean,_cs.EGLDisplay,_cs.EGLint,arrays.EGLAttribArray) +def eglQueryDisplayAttribNV(dpy,attribute,value):pass +@_f +@_p.types(_cs.EGLBoolean,_cs.EGLDisplay,_cs.EGLStreamKHR,_cs.EGLenum,_cs.EGLint,_cs.EGLint,_cs.EGLint,ctypes.c_void_p) +def eglQueryStreamMetadataNV(dpy,stream,name,n,offset,size,data):pass +@_f +@_p.types(_cs.EGLBoolean,_cs.EGLDisplay,_cs.EGLStreamKHR,_cs.EGLint,_cs.EGLint,_cs.EGLint,ctypes.c_void_p) +def eglSetStreamMetadataNV(dpy,stream,n,offset,size,data):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/NV/stream_sync.py b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/NV/stream_sync.py new file mode 100644 index 00000000..467705c9 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/NV/stream_sync.py @@ -0,0 +1,18 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.EGL import _types as _cs +# End users want this... +from OpenGL.raw.EGL._types import * +from OpenGL.raw.EGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'EGL_NV_stream_sync' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.EGL,'EGL_NV_stream_sync',error_checker=_errors._error_checker) +EGL_SYNC_NEW_FRAME_NV=_C('EGL_SYNC_NEW_FRAME_NV',0x321F) +EGL_SYNC_TYPE_KHR=_C('EGL_SYNC_TYPE_KHR',0x30F7) +@_f +@_p.types(_cs.EGLSyncKHR,_cs.EGLDisplay,_cs.EGLStreamKHR,_cs.EGLenum,arrays.GLintArray) +def eglCreateStreamSyncNV(dpy,stream,type,attrib_list):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/NV/sync.py b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/NV/sync.py new file mode 100644 index 00000000..d2e52f74 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/NV/sync.py @@ -0,0 +1,44 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.EGL import _types as _cs +# End users want this... +from OpenGL.raw.EGL._types import * +from OpenGL.raw.EGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'EGL_NV_sync' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.EGL,'EGL_NV_sync',error_checker=_errors._error_checker) +EGL_ALREADY_SIGNALED_NV=_C('EGL_ALREADY_SIGNALED_NV',0x30EA) +EGL_CONDITION_SATISFIED_NV=_C('EGL_CONDITION_SATISFIED_NV',0x30EC) +EGL_FOREVER_NV=_C('EGL_FOREVER_NV',0xFFFFFFFFFFFFFFFF) +# EGL_NO_SYNC_NV=_C('EGL_NO_SYNC_NV',((EGLSyncNV)0)) +EGL_SIGNALED_NV=_C('EGL_SIGNALED_NV',0x30E8) +EGL_SYNC_CONDITION_NV=_C('EGL_SYNC_CONDITION_NV',0x30EE) +EGL_SYNC_FENCE_NV=_C('EGL_SYNC_FENCE_NV',0x30EF) +EGL_SYNC_FLUSH_COMMANDS_BIT_NV=_C('EGL_SYNC_FLUSH_COMMANDS_BIT_NV',0x0001) +EGL_SYNC_PRIOR_COMMANDS_COMPLETE_NV=_C('EGL_SYNC_PRIOR_COMMANDS_COMPLETE_NV',0x30E6) +EGL_SYNC_STATUS_NV=_C('EGL_SYNC_STATUS_NV',0x30E7) +EGL_SYNC_TYPE_NV=_C('EGL_SYNC_TYPE_NV',0x30ED) +EGL_TIMEOUT_EXPIRED_NV=_C('EGL_TIMEOUT_EXPIRED_NV',0x30EB) +EGL_UNSIGNALED_NV=_C('EGL_UNSIGNALED_NV',0x30E9) +@_f +@_p.types(_cs.EGLint,_cs.EGLSyncNV,_cs.EGLint,_cs.EGLTimeNV) +def eglClientWaitSyncNV(sync,flags,timeout):pass +@_f +@_p.types(_cs.EGLSyncNV,_cs.EGLDisplay,_cs.EGLenum,arrays.GLintArray) +def eglCreateFenceSyncNV(dpy,condition,attrib_list):pass +@_f +@_p.types(_cs.EGLBoolean,_cs.EGLSyncNV) +def eglDestroySyncNV(sync):pass +@_f +@_p.types(_cs.EGLBoolean,_cs.EGLSyncNV) +def eglFenceNV(sync):pass +@_f +@_p.types(_cs.EGLBoolean,_cs.EGLSyncNV,_cs.EGLint,arrays.GLintArray) +def eglGetSyncAttribNV(sync,attribute,value):pass +@_f +@_p.types(_cs.EGLBoolean,_cs.EGLSyncNV,_cs.EGLenum) +def eglSignalSyncNV(sync,mode):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/NV/system_time.py b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/NV/system_time.py new file mode 100644 index 00000000..14e0521f --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/NV/system_time.py @@ -0,0 +1,20 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.EGL import _types as _cs +# End users want this... +from OpenGL.raw.EGL._types import * +from OpenGL.raw.EGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'EGL_NV_system_time' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.EGL,'EGL_NV_system_time',error_checker=_errors._error_checker) + +@_f +@_p.types(_cs.EGLuint64NV,) +def eglGetSystemTimeFrequencyNV():pass +@_f +@_p.types(_cs.EGLuint64NV,) +def eglGetSystemTimeNV():pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/TIZEN/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/TIZEN/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/TIZEN/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/TIZEN/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/TIZEN/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..ad3c7a47 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/TIZEN/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/TIZEN/__pycache__/image_native_buffer.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/TIZEN/__pycache__/image_native_buffer.cpython-312.pyc new file mode 100644 index 00000000..6a4adc5d Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/TIZEN/__pycache__/image_native_buffer.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/TIZEN/__pycache__/image_native_surface.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/TIZEN/__pycache__/image_native_surface.cpython-312.pyc new file mode 100644 index 00000000..ed63e6f1 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/TIZEN/__pycache__/image_native_surface.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/TIZEN/image_native_buffer.py b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/TIZEN/image_native_buffer.py new file mode 100644 index 00000000..b83a232f --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/TIZEN/image_native_buffer.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.EGL import _types as _cs +# End users want this... +from OpenGL.raw.EGL._types import * +from OpenGL.raw.EGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'EGL_TIZEN_image_native_buffer' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.EGL,'EGL_TIZEN_image_native_buffer',error_checker=_errors._error_checker) +EGL_NATIVE_BUFFER_TIZEN=_C('EGL_NATIVE_BUFFER_TIZEN',0x32A0) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/TIZEN/image_native_surface.py b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/TIZEN/image_native_surface.py new file mode 100644 index 00000000..698acbff --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/TIZEN/image_native_surface.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.EGL import _types as _cs +# End users want this... +from OpenGL.raw.EGL._types import * +from OpenGL.raw.EGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'EGL_TIZEN_image_native_surface' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.EGL,'EGL_TIZEN_image_native_surface',error_checker=_errors._error_checker) +EGL_NATIVE_SURFACE_TIZEN=_C('EGL_NATIVE_SURFACE_TIZEN',0x32A1) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/VERSION/EGL_1_0.py b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/VERSION/EGL_1_0.py new file mode 100644 index 00000000..3b569a6f --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/VERSION/EGL_1_0.py @@ -0,0 +1,144 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.EGL import _types as _cs +# End users want this... +from OpenGL.raw.EGL._types import * +from OpenGL.raw.EGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'EGL_VERSION_EGL_1_0' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.EGL,'EGL_VERSION_EGL_1_0',error_checker=_errors._error_checker) +EGL_ALPHA_SIZE=_C('EGL_ALPHA_SIZE',0x3021) +EGL_BAD_ACCESS=_C('EGL_BAD_ACCESS',0x3002) +EGL_BAD_ALLOC=_C('EGL_BAD_ALLOC',0x3003) +EGL_BAD_ATTRIBUTE=_C('EGL_BAD_ATTRIBUTE',0x3004) +EGL_BAD_CONFIG=_C('EGL_BAD_CONFIG',0x3005) +EGL_BAD_CONTEXT=_C('EGL_BAD_CONTEXT',0x3006) +EGL_BAD_CURRENT_SURFACE=_C('EGL_BAD_CURRENT_SURFACE',0x3007) +EGL_BAD_DISPLAY=_C('EGL_BAD_DISPLAY',0x3008) +EGL_BAD_MATCH=_C('EGL_BAD_MATCH',0x3009) +EGL_BAD_NATIVE_PIXMAP=_C('EGL_BAD_NATIVE_PIXMAP',0x300A) +EGL_BAD_NATIVE_WINDOW=_C('EGL_BAD_NATIVE_WINDOW',0x300B) +EGL_BAD_PARAMETER=_C('EGL_BAD_PARAMETER',0x300C) +EGL_BAD_SURFACE=_C('EGL_BAD_SURFACE',0x300D) +EGL_BLUE_SIZE=_C('EGL_BLUE_SIZE',0x3022) +EGL_BUFFER_SIZE=_C('EGL_BUFFER_SIZE',0x3020) +EGL_CONFIG_CAVEAT=_C('EGL_CONFIG_CAVEAT',0x3027) +EGL_CONFIG_ID=_C('EGL_CONFIG_ID',0x3028) +EGL_CORE_NATIVE_ENGINE=_C('EGL_CORE_NATIVE_ENGINE',0x305B) +EGL_DEPTH_SIZE=_C('EGL_DEPTH_SIZE',0x3025) +# EGL_DONT_CARE=_C('EGL_DONT_CARE',((EGLint)-1)) +EGL_DRAW=_C('EGL_DRAW',0x3059) +EGL_EXTENSIONS=_C('EGL_EXTENSIONS',0x3055) +EGL_FALSE=_C('EGL_FALSE',0) +EGL_GREEN_SIZE=_C('EGL_GREEN_SIZE',0x3023) +EGL_HEIGHT=_C('EGL_HEIGHT',0x3056) +EGL_LARGEST_PBUFFER=_C('EGL_LARGEST_PBUFFER',0x3058) +EGL_LEVEL=_C('EGL_LEVEL',0x3029) +EGL_MAX_PBUFFER_HEIGHT=_C('EGL_MAX_PBUFFER_HEIGHT',0x302A) +EGL_MAX_PBUFFER_PIXELS=_C('EGL_MAX_PBUFFER_PIXELS',0x302B) +EGL_MAX_PBUFFER_WIDTH=_C('EGL_MAX_PBUFFER_WIDTH',0x302C) +EGL_NATIVE_RENDERABLE=_C('EGL_NATIVE_RENDERABLE',0x302D) +EGL_NATIVE_VISUAL_ID=_C('EGL_NATIVE_VISUAL_ID',0x302E) +EGL_NATIVE_VISUAL_TYPE=_C('EGL_NATIVE_VISUAL_TYPE',0x302F) +EGL_NONE=_C('EGL_NONE',0x3038) +EGL_NON_CONFORMANT_CONFIG=_C('EGL_NON_CONFORMANT_CONFIG',0x3051) +EGL_NOT_INITIALIZED=_C('EGL_NOT_INITIALIZED',0x3001) +# EGL_NO_CONTEXT=_C('EGL_NO_CONTEXT',((EGLContext)0)) +# EGL_NO_DISPLAY=_C('EGL_NO_DISPLAY',((EGLDisplay)0)) +# EGL_NO_SURFACE=_C('EGL_NO_SURFACE',((EGLSurface)0)) +EGL_PBUFFER_BIT=_C('EGL_PBUFFER_BIT',0x0001) +EGL_PIXMAP_BIT=_C('EGL_PIXMAP_BIT',0x0002) +EGL_READ=_C('EGL_READ',0x305A) +EGL_RED_SIZE=_C('EGL_RED_SIZE',0x3024) +EGL_SAMPLES=_C('EGL_SAMPLES',0x3031) +EGL_SAMPLE_BUFFERS=_C('EGL_SAMPLE_BUFFERS',0x3032) +EGL_SLOW_CONFIG=_C('EGL_SLOW_CONFIG',0x3050) +EGL_STENCIL_SIZE=_C('EGL_STENCIL_SIZE',0x3026) +EGL_SUCCESS=_C('EGL_SUCCESS',0x3000) +EGL_SURFACE_TYPE=_C('EGL_SURFACE_TYPE',0x3033) +EGL_TRANSPARENT_BLUE_VALUE=_C('EGL_TRANSPARENT_BLUE_VALUE',0x3035) +EGL_TRANSPARENT_GREEN_VALUE=_C('EGL_TRANSPARENT_GREEN_VALUE',0x3036) +EGL_TRANSPARENT_RED_VALUE=_C('EGL_TRANSPARENT_RED_VALUE',0x3037) +EGL_TRANSPARENT_RGB=_C('EGL_TRANSPARENT_RGB',0x3052) +EGL_TRANSPARENT_TYPE=_C('EGL_TRANSPARENT_TYPE',0x3034) +EGL_TRUE=_C('EGL_TRUE',1) +EGL_VENDOR=_C('EGL_VENDOR',0x3053) +EGL_VERSION=_C('EGL_VERSION',0x3054) +EGL_WIDTH=_C('EGL_WIDTH',0x3057) +EGL_WINDOW_BIT=_C('EGL_WINDOW_BIT',0x0004) +@_f +@_p.types(_cs.EGLBoolean,_cs.EGLDisplay,arrays.GLintArray,arrays.GLvoidpArray,_cs.EGLint,arrays.GLintArray) +def eglChooseConfig(dpy,attrib_list,configs,config_size,num_config):pass +@_f +@_p.types(_cs.EGLBoolean,_cs.EGLDisplay,_cs.EGLSurface,_cs.EGLNativePixmapType) +def eglCopyBuffers(dpy,surface,target):pass +@_f +@_p.types(_cs.EGLContext,_cs.EGLDisplay,_cs.EGLConfig,_cs.EGLContext,arrays.GLintArray) +def eglCreateContext(dpy,config,share_context,attrib_list):pass +@_f +@_p.types(_cs.EGLSurface,_cs.EGLDisplay,_cs.EGLConfig,arrays.GLintArray) +def eglCreatePbufferSurface(dpy,config,attrib_list):pass +@_f +@_p.types(_cs.EGLSurface,_cs.EGLDisplay,_cs.EGLConfig,_cs.EGLNativePixmapType,arrays.GLintArray) +def eglCreatePixmapSurface(dpy,config,pixmap,attrib_list):pass +@_f +@_p.types(_cs.EGLSurface,_cs.EGLDisplay,_cs.EGLConfig,_cs.EGLNativeWindowType,arrays.GLintArray) +def eglCreateWindowSurface(dpy,config,win,attrib_list):pass +@_f +@_p.types(_cs.EGLBoolean,_cs.EGLDisplay,_cs.EGLContext) +def eglDestroyContext(dpy,ctx):pass +@_f +@_p.types(_cs.EGLBoolean,_cs.EGLDisplay,_cs.EGLSurface) +def eglDestroySurface(dpy,surface):pass +@_f +@_p.types(_cs.EGLBoolean,_cs.EGLDisplay,_cs.EGLConfig,_cs.EGLint,arrays.GLintArray) +def eglGetConfigAttrib(dpy,config,attribute,value):pass +@_f +@_p.types(_cs.EGLBoolean,_cs.EGLDisplay,arrays.GLvoidpArray,_cs.EGLint,arrays.GLintArray) +def eglGetConfigs(dpy,configs,config_size,num_config):pass +@_f +@_p.types(_cs.EGLDisplay,) +def eglGetCurrentDisplay():pass +@_f +@_p.types(_cs.EGLSurface,_cs.EGLint) +def eglGetCurrentSurface(readdraw):pass +@_f +@_p.types(_cs.EGLDisplay,_cs.EGLNativeDisplayType) +def eglGetDisplay(display_id):pass +@_f +@_p.types(_cs.EGLint,) +def eglGetError():pass +@_f +@_p.types(ctypes.c_void_p,arrays.GLbyteArray) +def eglGetProcAddress(procname):pass +@_f +@_p.types(_cs.EGLBoolean,_cs.EGLDisplay,arrays.GLintArray,arrays.GLintArray) +def eglInitialize(dpy,major,minor):pass +@_f +@_p.types(_cs.EGLBoolean,_cs.EGLDisplay,_cs.EGLSurface,_cs.EGLSurface,_cs.EGLContext) +def eglMakeCurrent(dpy,draw,read,ctx):pass +@_f +@_p.types(_cs.EGLBoolean,_cs.EGLDisplay,_cs.EGLContext,_cs.EGLint,arrays.GLintArray) +def eglQueryContext(dpy,ctx,attribute,value):pass +@_f +@_p.types(ctypes.c_char_p,_cs.EGLDisplay,_cs.EGLint) +def eglQueryString(dpy,name):pass +@_f +@_p.types(_cs.EGLBoolean,_cs.EGLDisplay,_cs.EGLSurface,_cs.EGLint,arrays.GLintArray) +def eglQuerySurface(dpy,surface,attribute,value):pass +@_f +@_p.types(_cs.EGLBoolean,_cs.EGLDisplay,_cs.EGLSurface) +def eglSwapBuffers(dpy,surface):pass +@_f +@_p.types(_cs.EGLBoolean,_cs.EGLDisplay) +def eglTerminate(dpy):pass +@_f +@_p.types(_cs.EGLBoolean,) +def eglWaitGL():pass +@_f +@_p.types(_cs.EGLBoolean,_cs.EGLint) +def eglWaitNative(engine):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/VERSION/EGL_1_1.py b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/VERSION/EGL_1_1.py new file mode 100644 index 00000000..f765260d --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/VERSION/EGL_1_1.py @@ -0,0 +1,39 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.EGL import _types as _cs +# End users want this... +from OpenGL.raw.EGL._types import * +from OpenGL.raw.EGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'EGL_VERSION_EGL_1_1' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.EGL,'EGL_VERSION_EGL_1_1',error_checker=_errors._error_checker) +EGL_BACK_BUFFER=_C('EGL_BACK_BUFFER',0x3084) +EGL_BIND_TO_TEXTURE_RGB=_C('EGL_BIND_TO_TEXTURE_RGB',0x3039) +EGL_BIND_TO_TEXTURE_RGBA=_C('EGL_BIND_TO_TEXTURE_RGBA',0x303A) +EGL_CONTEXT_LOST=_C('EGL_CONTEXT_LOST',0x300E) +EGL_MAX_SWAP_INTERVAL=_C('EGL_MAX_SWAP_INTERVAL',0x303C) +EGL_MIN_SWAP_INTERVAL=_C('EGL_MIN_SWAP_INTERVAL',0x303B) +EGL_MIPMAP_LEVEL=_C('EGL_MIPMAP_LEVEL',0x3083) +EGL_MIPMAP_TEXTURE=_C('EGL_MIPMAP_TEXTURE',0x3082) +EGL_NO_TEXTURE=_C('EGL_NO_TEXTURE',0x305C) +EGL_TEXTURE_2D=_C('EGL_TEXTURE_2D',0x305F) +EGL_TEXTURE_FORMAT=_C('EGL_TEXTURE_FORMAT',0x3080) +EGL_TEXTURE_RGB=_C('EGL_TEXTURE_RGB',0x305D) +EGL_TEXTURE_RGBA=_C('EGL_TEXTURE_RGBA',0x305E) +EGL_TEXTURE_TARGET=_C('EGL_TEXTURE_TARGET',0x3081) +@_f +@_p.types(_cs.EGLBoolean,_cs.EGLDisplay,_cs.EGLSurface,_cs.EGLint) +def eglBindTexImage(dpy,surface,buffer):pass +@_f +@_p.types(_cs.EGLBoolean,_cs.EGLDisplay,_cs.EGLSurface,_cs.EGLint) +def eglReleaseTexImage(dpy,surface,buffer):pass +@_f +@_p.types(_cs.EGLBoolean,_cs.EGLDisplay,_cs.EGLSurface,_cs.EGLint,_cs.EGLint) +def eglSurfaceAttrib(dpy,surface,attribute,value):pass +@_f +@_p.types(_cs.EGLBoolean,_cs.EGLDisplay,_cs.EGLint) +def eglSwapInterval(dpy,interval):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/VERSION/EGL_1_2.py b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/VERSION/EGL_1_2.py new file mode 100644 index 00000000..23777145 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/VERSION/EGL_1_2.py @@ -0,0 +1,57 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.EGL import _types as _cs +# End users want this... +from OpenGL.raw.EGL._types import * +from OpenGL.raw.EGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'EGL_VERSION_EGL_1_2' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.EGL,'EGL_VERSION_EGL_1_2',error_checker=_errors._error_checker) +EGL_ALPHA_FORMAT=_C('EGL_ALPHA_FORMAT',0x3088) +EGL_ALPHA_FORMAT_NONPRE=_C('EGL_ALPHA_FORMAT_NONPRE',0x308B) +EGL_ALPHA_FORMAT_PRE=_C('EGL_ALPHA_FORMAT_PRE',0x308C) +EGL_ALPHA_MASK_SIZE=_C('EGL_ALPHA_MASK_SIZE',0x303E) +EGL_BUFFER_DESTROYED=_C('EGL_BUFFER_DESTROYED',0x3095) +EGL_BUFFER_PRESERVED=_C('EGL_BUFFER_PRESERVED',0x3094) +EGL_CLIENT_APIS=_C('EGL_CLIENT_APIS',0x308D) +EGL_COLORSPACE=_C('EGL_COLORSPACE',0x3087) +EGL_COLORSPACE_LINEAR=_C('EGL_COLORSPACE_LINEAR',0x308A) +EGL_COLORSPACE_sRGB=_C('EGL_COLORSPACE_sRGB',0x3089) +EGL_COLOR_BUFFER_TYPE=_C('EGL_COLOR_BUFFER_TYPE',0x303F) +EGL_CONTEXT_CLIENT_TYPE=_C('EGL_CONTEXT_CLIENT_TYPE',0x3097) +EGL_DISPLAY_SCALING=_C('EGL_DISPLAY_SCALING',10000) +EGL_HORIZONTAL_RESOLUTION=_C('EGL_HORIZONTAL_RESOLUTION',0x3090) +EGL_LUMINANCE_BUFFER=_C('EGL_LUMINANCE_BUFFER',0x308F) +EGL_LUMINANCE_SIZE=_C('EGL_LUMINANCE_SIZE',0x303D) +EGL_OPENGL_ES_API=_C('EGL_OPENGL_ES_API',0x30A0) +EGL_OPENGL_ES_BIT=_C('EGL_OPENGL_ES_BIT',0x0001) +EGL_OPENVG_API=_C('EGL_OPENVG_API',0x30A1) +EGL_OPENVG_BIT=_C('EGL_OPENVG_BIT',0x0002) +EGL_OPENVG_IMAGE=_C('EGL_OPENVG_IMAGE',0x3096) +EGL_PIXEL_ASPECT_RATIO=_C('EGL_PIXEL_ASPECT_RATIO',0x3092) +EGL_RENDERABLE_TYPE=_C('EGL_RENDERABLE_TYPE',0x3040) +EGL_RENDER_BUFFER=_C('EGL_RENDER_BUFFER',0x3086) +EGL_RGB_BUFFER=_C('EGL_RGB_BUFFER',0x308E) +EGL_SINGLE_BUFFER=_C('EGL_SINGLE_BUFFER',0x3085) +EGL_SWAP_BEHAVIOR=_C('EGL_SWAP_BEHAVIOR',0x3093) +# EGL_UNKNOWN=_C('EGL_UNKNOWN',((EGLint)-1)) +EGL_VERTICAL_RESOLUTION=_C('EGL_VERTICAL_RESOLUTION',0x3091) +@_f +@_p.types(_cs.EGLBoolean,_cs.EGLenum) +def eglBindAPI(api):pass +@_f +@_p.types(_cs.EGLSurface,_cs.EGLDisplay,_cs.EGLenum,_cs.EGLClientBuffer,_cs.EGLConfig,arrays.GLintArray) +def eglCreatePbufferFromClientBuffer(dpy,buftype,buffer,config,attrib_list):pass +@_f +@_p.types(_cs.EGLenum,) +def eglQueryAPI():pass +@_f +@_p.types(_cs.EGLBoolean,) +def eglReleaseThread():pass +@_f +@_p.types(_cs.EGLBoolean,) +def eglWaitClient():pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/VERSION/EGL_1_3.py b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/VERSION/EGL_1_3.py new file mode 100644 index 00000000..7888b68e --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/VERSION/EGL_1_3.py @@ -0,0 +1,26 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.EGL import _types as _cs +# End users want this... +from OpenGL.raw.EGL._types import * +from OpenGL.raw.EGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'EGL_VERSION_EGL_1_3' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.EGL,'EGL_VERSION_EGL_1_3',error_checker=_errors._error_checker) +EGL_CONFORMANT=_C('EGL_CONFORMANT',0x3042) +EGL_CONTEXT_CLIENT_VERSION=_C('EGL_CONTEXT_CLIENT_VERSION',0x3098) +EGL_MATCH_NATIVE_PIXMAP=_C('EGL_MATCH_NATIVE_PIXMAP',0x3041) +EGL_OPENGL_ES2_BIT=_C('EGL_OPENGL_ES2_BIT',0x0004) +EGL_VG_ALPHA_FORMAT=_C('EGL_VG_ALPHA_FORMAT',0x3088) +EGL_VG_ALPHA_FORMAT_NONPRE=_C('EGL_VG_ALPHA_FORMAT_NONPRE',0x308B) +EGL_VG_ALPHA_FORMAT_PRE=_C('EGL_VG_ALPHA_FORMAT_PRE',0x308C) +EGL_VG_ALPHA_FORMAT_PRE_BIT=_C('EGL_VG_ALPHA_FORMAT_PRE_BIT',0x0040) +EGL_VG_COLORSPACE=_C('EGL_VG_COLORSPACE',0x3087) +EGL_VG_COLORSPACE_LINEAR=_C('EGL_VG_COLORSPACE_LINEAR',0x308A) +EGL_VG_COLORSPACE_LINEAR_BIT=_C('EGL_VG_COLORSPACE_LINEAR_BIT',0x0020) +EGL_VG_COLORSPACE_sRGB=_C('EGL_VG_COLORSPACE_sRGB',0x3089) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/VERSION/EGL_1_4.py b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/VERSION/EGL_1_4.py new file mode 100644 index 00000000..8910a344 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/VERSION/EGL_1_4.py @@ -0,0 +1,24 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.EGL import _types as _cs +# End users want this... +from OpenGL.raw.EGL._types import * +from OpenGL.raw.EGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'EGL_VERSION_EGL_1_4' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.EGL,'EGL_VERSION_EGL_1_4',error_checker=_errors._error_checker) +# EGL_DEFAULT_DISPLAY=_C('EGL_DEFAULT_DISPLAY',((EGLNativeDisplayType)0)) +EGL_MULTISAMPLE_RESOLVE=_C('EGL_MULTISAMPLE_RESOLVE',0x3099) +EGL_MULTISAMPLE_RESOLVE_BOX=_C('EGL_MULTISAMPLE_RESOLVE_BOX',0x309B) +EGL_MULTISAMPLE_RESOLVE_BOX_BIT=_C('EGL_MULTISAMPLE_RESOLVE_BOX_BIT',0x0200) +EGL_MULTISAMPLE_RESOLVE_DEFAULT=_C('EGL_MULTISAMPLE_RESOLVE_DEFAULT',0x309A) +EGL_OPENGL_API=_C('EGL_OPENGL_API',0x30A2) +EGL_OPENGL_BIT=_C('EGL_OPENGL_BIT',0x0008) +EGL_SWAP_BEHAVIOR_PRESERVED_BIT=_C('EGL_SWAP_BEHAVIOR_PRESERVED_BIT',0x0400) +@_f +@_p.types(_cs.EGLContext,) +def eglGetCurrentContext():pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/VERSION/EGL_1_5.py b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/VERSION/EGL_1_5.py new file mode 100644 index 00000000..0853e9e3 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/VERSION/EGL_1_5.py @@ -0,0 +1,88 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.EGL import _types as _cs +# End users want this... +from OpenGL.raw.EGL._types import * +from OpenGL.raw.EGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'EGL_VERSION_EGL_1_5' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.EGL,'EGL_VERSION_EGL_1_5',error_checker=_errors._error_checker) +EGL_CL_EVENT_HANDLE=_C('EGL_CL_EVENT_HANDLE',0x309C) +EGL_CONDITION_SATISFIED=_C('EGL_CONDITION_SATISFIED',0x30F6) +EGL_CONTEXT_MAJOR_VERSION=_C('EGL_CONTEXT_MAJOR_VERSION',0x3098) +EGL_CONTEXT_MINOR_VERSION=_C('EGL_CONTEXT_MINOR_VERSION',0x30FB) +EGL_CONTEXT_OPENGL_COMPATIBILITY_PROFILE_BIT=_C('EGL_CONTEXT_OPENGL_COMPATIBILITY_PROFILE_BIT',0x00000002) +EGL_CONTEXT_OPENGL_CORE_PROFILE_BIT=_C('EGL_CONTEXT_OPENGL_CORE_PROFILE_BIT',0x00000001) +EGL_CONTEXT_OPENGL_DEBUG=_C('EGL_CONTEXT_OPENGL_DEBUG',0x31B0) +EGL_CONTEXT_OPENGL_FORWARD_COMPATIBLE=_C('EGL_CONTEXT_OPENGL_FORWARD_COMPATIBLE',0x31B1) +EGL_CONTEXT_OPENGL_PROFILE_MASK=_C('EGL_CONTEXT_OPENGL_PROFILE_MASK',0x30FD) +EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY=_C('EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY',0x31BD) +EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY=_C('EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY',0x31BD) +EGL_CONTEXT_OPENGL_ROBUST_ACCESS=_C('EGL_CONTEXT_OPENGL_ROBUST_ACCESS',0x31B2) +EGL_CONTEXT_OPENGL_ROBUST_ACCESS=_C('EGL_CONTEXT_OPENGL_ROBUST_ACCESS',0x31B2) +EGL_FOREVER=_C('EGL_FOREVER',0xFFFFFFFFFFFFFFFF) +EGL_GL_COLORSPACE=_C('EGL_GL_COLORSPACE',0x309D) +EGL_GL_COLORSPACE_LINEAR=_C('EGL_GL_COLORSPACE_LINEAR',0x308A) +EGL_GL_COLORSPACE_SRGB=_C('EGL_GL_COLORSPACE_SRGB',0x3089) +EGL_GL_RENDERBUFFER=_C('EGL_GL_RENDERBUFFER',0x30B9) +EGL_GL_TEXTURE_2D=_C('EGL_GL_TEXTURE_2D',0x30B1) +EGL_GL_TEXTURE_3D=_C('EGL_GL_TEXTURE_3D',0x30B2) +EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_X=_C('EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_X',0x30B4) +EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_Y=_C('EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_Y',0x30B6) +EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_Z=_C('EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_Z',0x30B8) +EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_X=_C('EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_X',0x30B3) +EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_Y=_C('EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_Y',0x30B5) +EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_Z=_C('EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_Z',0x30B7) +EGL_GL_TEXTURE_LEVEL=_C('EGL_GL_TEXTURE_LEVEL',0x30BC) +EGL_GL_TEXTURE_ZOFFSET=_C('EGL_GL_TEXTURE_ZOFFSET',0x30BD) +EGL_IMAGE_PRESERVED=_C('EGL_IMAGE_PRESERVED',0x30D2) +EGL_LOSE_CONTEXT_ON_RESET=_C('EGL_LOSE_CONTEXT_ON_RESET',0x31BF) +# EGL_NO_IMAGE=_C('EGL_NO_IMAGE',((EGLImage)0)) +EGL_NO_RESET_NOTIFICATION=_C('EGL_NO_RESET_NOTIFICATION',0x31BE) +# EGL_NO_SYNC=_C('EGL_NO_SYNC',((EGLSync)0)) +EGL_OPENGL_ES3_BIT=_C('EGL_OPENGL_ES3_BIT',0x00000040) +EGL_SIGNALED=_C('EGL_SIGNALED',0x30F2) +EGL_SYNC_CL_EVENT=_C('EGL_SYNC_CL_EVENT',0x30FE) +EGL_SYNC_CL_EVENT_COMPLETE=_C('EGL_SYNC_CL_EVENT_COMPLETE',0x30FF) +EGL_SYNC_CONDITION=_C('EGL_SYNC_CONDITION',0x30F8) +EGL_SYNC_FENCE=_C('EGL_SYNC_FENCE',0x30F9) +EGL_SYNC_FLUSH_COMMANDS_BIT=_C('EGL_SYNC_FLUSH_COMMANDS_BIT',0x0001) +EGL_SYNC_PRIOR_COMMANDS_COMPLETE=_C('EGL_SYNC_PRIOR_COMMANDS_COMPLETE',0x30F0) +EGL_SYNC_STATUS=_C('EGL_SYNC_STATUS',0x30F1) +EGL_SYNC_TYPE=_C('EGL_SYNC_TYPE',0x30F7) +EGL_TIMEOUT_EXPIRED=_C('EGL_TIMEOUT_EXPIRED',0x30F5) +EGL_UNSIGNALED=_C('EGL_UNSIGNALED',0x30F3) +@_f +@_p.types(_cs.EGLint,_cs.EGLDisplay,_cs.EGLSync,_cs.EGLint,_cs.EGLTime) +def eglClientWaitSync(dpy,sync,flags,timeout):pass +@_f +@_p.types(_cs.EGLImage,_cs.EGLDisplay,_cs.EGLContext,_cs.EGLenum,_cs.EGLClientBuffer,arrays.EGLAttribArray) +def eglCreateImage(dpy,ctx,target,buffer,attrib_list):pass +@_f +@_p.types(_cs.EGLSurface,_cs.EGLDisplay,_cs.EGLConfig,ctypes.c_void_p,arrays.EGLAttribArray) +def eglCreatePlatformPixmapSurface(dpy,config,native_pixmap,attrib_list):pass +@_f +@_p.types(_cs.EGLSurface,_cs.EGLDisplay,_cs.EGLConfig,ctypes.c_void_p,arrays.EGLAttribArray) +def eglCreatePlatformWindowSurface(dpy,config,native_window,attrib_list):pass +@_f +@_p.types(_cs.EGLSync,_cs.EGLDisplay,_cs.EGLenum,arrays.EGLAttribArray) +def eglCreateSync(dpy,type,attrib_list):pass +@_f +@_p.types(_cs.EGLBoolean,_cs.EGLDisplay,_cs.EGLImage) +def eglDestroyImage(dpy,image):pass +@_f +@_p.types(_cs.EGLBoolean,_cs.EGLDisplay,_cs.EGLSync) +def eglDestroySync(dpy,sync):pass +@_f +@_p.types(_cs.EGLDisplay,_cs.EGLenum,ctypes.c_void_p,arrays.EGLAttribArray) +def eglGetPlatformDisplay(platform,native_display,attrib_list):pass +@_f +@_p.types(_cs.EGLBoolean,_cs.EGLDisplay,_cs.EGLSync,_cs.EGLint,arrays.EGLAttribArray) +def eglGetSyncAttrib(dpy,sync,attribute,value):pass +@_f +@_p.types(_cs.EGLBoolean,_cs.EGLDisplay,_cs.EGLSync,_cs.EGLint) +def eglWaitSync(dpy,sync,flags):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/VERSION/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/VERSION/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/VERSION/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/VERSION/__pycache__/EGL_1_0.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/VERSION/__pycache__/EGL_1_0.cpython-312.pyc new file mode 100644 index 00000000..06864a6e Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/VERSION/__pycache__/EGL_1_0.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/VERSION/__pycache__/EGL_1_1.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/VERSION/__pycache__/EGL_1_1.cpython-312.pyc new file mode 100644 index 00000000..afea61b6 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/VERSION/__pycache__/EGL_1_1.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/VERSION/__pycache__/EGL_1_2.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/VERSION/__pycache__/EGL_1_2.cpython-312.pyc new file mode 100644 index 00000000..93f0c330 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/VERSION/__pycache__/EGL_1_2.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/VERSION/__pycache__/EGL_1_3.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/VERSION/__pycache__/EGL_1_3.cpython-312.pyc new file mode 100644 index 00000000..480776e3 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/VERSION/__pycache__/EGL_1_3.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/VERSION/__pycache__/EGL_1_4.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/VERSION/__pycache__/EGL_1_4.cpython-312.pyc new file mode 100644 index 00000000..1de2e2e4 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/VERSION/__pycache__/EGL_1_4.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/VERSION/__pycache__/EGL_1_5.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/VERSION/__pycache__/EGL_1_5.cpython-312.pyc new file mode 100644 index 00000000..5c2c4a76 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/VERSION/__pycache__/EGL_1_5.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/VERSION/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/VERSION/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..04a742ee Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/VERSION/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..b61b5a54 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/__pycache__/_errors.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/__pycache__/_errors.cpython-312.pyc new file mode 100644 index 00000000..975d931a Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/__pycache__/_errors.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/__pycache__/_glgets.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/__pycache__/_glgets.cpython-312.pyc new file mode 100644 index 00000000..dbf2626b Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/__pycache__/_glgets.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/__pycache__/_types.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/__pycache__/_types.cpython-312.pyc new file mode 100644 index 00000000..463a2dd5 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/__pycache__/_types.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/_errors.py b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/_errors.py new file mode 100644 index 00000000..4ad7f776 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/_errors.py @@ -0,0 +1,21 @@ +from OpenGL.error import _ErrorChecker, EGLError +from OpenGL import platform as _p + +class EGLError( EGLError ): + @property + def err(self): + from OpenGL.EGL import debug + return debug.eglErrorName(self.__dict__.get('err')) + @err.setter + def err(self, value): + self.__dict__['err'] = value + +if _ErrorChecker: + _error_checker = _ErrorChecker( + _p.PLATFORM, + _p.PLATFORM.EGL.eglGetError, + 0x3000, # EGL_SUCCESS, + errorClass = EGLError, + ) +else: + _ErrorChecker = None diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/_glgets.py b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/_glgets.py new file mode 100644 index 00000000..76bcbaca --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/_glgets.py @@ -0,0 +1,8 @@ +"""glGet* auto-generation of output arrays (DO NOT EDIT, AUTOGENERATED)""" +try: + from OpenGL.raw.GL._lookupint import LookupInt as _L +except ImportError: + def _L(*args): + raise RuntimeError( "Need to define a lookupint for this api" ) +_glget_size_mapping = _m = {} + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/_types.py b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/_types.py new file mode 100644 index 00000000..1b175334 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/EGL/_types.py @@ -0,0 +1,134 @@ +"""Data-type definitions for EGL/GLES""" +import ctypes +from OpenGL._opaque import opaque_pointer_cls as _opaque_pointer_cls +from OpenGL import platform as _p +from OpenGL import extensions +from OpenGL._bytes import as_8_bit + +class _EGLQuerier( extensions.ExtensionQuerier ): + prefix = as_8_bit('EGL_') + assumed_version = [1,0] + version_prefix = as_8_bit('EGL_VERSION_EGL_') + def getDisplay( self ): + """Retrieve the currently-bound, or the default, display""" + from OpenGL.EGL import ( + eglGetCurrentDisplay, eglGetDisplay, EGL_DEFAULT_DISPLAY, + ) + return eglGetCurrentDisplay() or eglGetDisplay(EGL_DEFAULT_DISPLAY) + + def pullVersion( self ): + from OpenGL.EGL import ( + eglQueryString, EGL_VERSION + ) + return eglQueryString( self.getDisplay(), EGL_VERSION ) + def pullExtensions( self ): + from OpenGL.EGL import eglQueryString, EGL_EXTENSIONS + return eglQueryString( self.getDisplay(), EGL_EXTENSIONS ) +EGLQuerier=_EGLQuerier() + +EGLBoolean = ctypes.c_uint32 +EGLenum = ctypes.c_uint32 +EGLint = c_int = ctypes.c_int32 + +EGLConfig = _opaque_pointer_cls( 'EGLConfig' ) +EGLContext = _opaque_pointer_cls( 'EGLContext' ) +EGLDisplay = _opaque_pointer_cls( 'EGLDisplay' ) +EGLSurface = _opaque_pointer_cls( 'EGLSurface' ) +EGLClientBuffer = _opaque_pointer_cls( 'EGLClientBuffer' ) +EGLImageKHR = EGLImage = _opaque_pointer_cls( 'EGLImageKHR' ) +EGLDeviceEXT = _opaque_pointer_cls( 'EGLDeviceEXT' ) +EGLOutputLayerEXT = _opaque_pointer_cls( 'EGLOutputLayerEXT' ) +EGLOutputPortEXT = _opaque_pointer_cls( 'EGLOutputPortEXT' ) + +EGLScreenMESA = ctypes.c_ulong +EGLModeMESA = ctypes.c_ulong + +EGLNativeFileDescriptorKHR = ctypes.c_int + +EGLSyncKHR = EGLSyncNV = EGLSync = _opaque_pointer_cls( 'EGLSync' ) +EGLTimeKHR = EGLTimeNV = EGLTime = ctypes.c_ulonglong +EGLuint64KHR = EGLuint64NV = ctypes.c_ulonglong +EGLStreamKHR = _opaque_pointer_cls( 'EGLStream' ) +EGLsizeiANDROID = ctypes.c_size_t +EGLAttribKHR = EGLAttrib = ctypes.POINTER( ctypes.c_int32 ) + +class EGLClientPixmapHI( ctypes.Structure): + _fields_ = [ + ('pData',ctypes.c_voidp), + ('iWidth',EGLint), + ('iHeight',EGLint), + ('iStride',EGLint), + ] +class wl_display( ctypes.Structure): + """Opaque structure from Mesa Wayland API""" + _fields_ = [] + +# These are X11... no good, really... +EGLNativeDisplayType = _opaque_pointer_cls( 'EGLNativeDisplayType' ) +EGLNativePixmapType = _opaque_pointer_cls( 'EGLNativePixmapType' ) +EGLNativeWindowType = _opaque_pointer_cls( 'EGLNativeWindowType' ) + +NativeDisplayType = EGLNativeDisplayType +NativePixmapType = EGLNativePixmapType +NativeWindowType = EGLNativeWindowType + +# Callback types, this is a hack to avoid making the +# khr module depend on the platform or needing to change generator for now... +CALLBACK_TYPE = _p.PLATFORM.functionTypeFor( _p.PLATFORM.EGL ) +EGLSetBlobFuncANDROID = CALLBACK_TYPE( ctypes.c_voidp, EGLsizeiANDROID, ctypes.c_voidp, EGLsizeiANDROID ) +EGLGetBlobFuncANDROID = CALLBACK_TYPE( ctypes.c_voidp, EGLsizeiANDROID, ctypes.c_voidp, EGLsizeiANDROID ) + +EGL_DEFAULT_DISPLAY = EGLNativeDisplayType() +EGL_NO_CONTEXT = EGLContext() +EGL_NO_DISPLAY = EGLDisplay() +EGL_NO_SURFACE = EGLSurface() +EGL_DONT_CARE = -1 + +raw_eglQueryString = _p.PLATFORM.EGL.eglQueryString +raw_eglQueryString.restype = ctypes.c_char_p +raw_eglQueryString.__doc__ = """Raw version of eglQueryString that does not check for availability""" + +_VERSION_PREFIX = 'EGL_VERSION_EGL_' + + +[ + 'EGLAttrib', + 'EGLAttribKHR', + 'EGLBoolean', + 'EGLClientBuffer', + 'EGLClientPixmapHI', + 'EGLConfig', + 'EGLContext', + 'EGLDisplay', + 'EGLGetBlobFuncANDROID', + 'EGLImageKHR', + 'EGLModeMESA', + 'EGLNativeDisplayType', + 'EGLNativeFileDescriptorKHR', + 'EGLNativePixmapType', + 'EGLNativeWindowType', + 'EGLScreenMESA', + 'EGLSetBlobFuncANDROID', + 'EGLStreamKHR', + 'EGLSurface', + 'EGLSyncKHR', + 'EGLSyncNV', + 'EGLSync', + 'EGLTimeKHR', + 'EGLTimeNV', + 'EGLTime', + 'EGL_DEFAULT_DISPLAY', + 'EGL_DONT_CARE', + 'EGL_NO_CONTEXT', + 'EGL_NO_DISPLAY', + 'EGL_NO_SURFACE', + 'EGLenum', + 'EGLint', + 'EGLsizeiANDROID', + 'EGLuint64KHR', + 'EGLuint64NV', + 'NativeDisplayType', + 'NativePixmapType', + 'NativeWindowType', + 'wl_display', +] diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..feeb1e1e Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/__pycache__/blend_minmax_factor.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/__pycache__/blend_minmax_factor.cpython-312.pyc new file mode 100644 index 00000000..ca8d4306 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/__pycache__/blend_minmax_factor.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/__pycache__/conservative_depth.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/__pycache__/conservative_depth.cpython-312.pyc new file mode 100644 index 00000000..60d7b594 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/__pycache__/conservative_depth.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/__pycache__/debug_output.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/__pycache__/debug_output.cpython-312.pyc new file mode 100644 index 00000000..5510cdad Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/__pycache__/debug_output.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/__pycache__/depth_clamp_separate.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/__pycache__/depth_clamp_separate.cpython-312.pyc new file mode 100644 index 00000000..3d73eba5 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/__pycache__/depth_clamp_separate.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/__pycache__/draw_buffers_blend.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/__pycache__/draw_buffers_blend.cpython-312.pyc new file mode 100644 index 00000000..4aaaf808 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/__pycache__/draw_buffers_blend.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/__pycache__/framebuffer_multisample_advanced.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/__pycache__/framebuffer_multisample_advanced.cpython-312.pyc new file mode 100644 index 00000000..473730d0 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/__pycache__/framebuffer_multisample_advanced.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/__pycache__/framebuffer_sample_positions.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/__pycache__/framebuffer_sample_positions.cpython-312.pyc new file mode 100644 index 00000000..d2add935 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/__pycache__/framebuffer_sample_positions.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/__pycache__/gcn_shader.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/__pycache__/gcn_shader.cpython-312.pyc new file mode 100644 index 00000000..fa96f462 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/__pycache__/gcn_shader.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/__pycache__/gpu_shader_half_float.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/__pycache__/gpu_shader_half_float.cpython-312.pyc new file mode 100644 index 00000000..4841a928 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/__pycache__/gpu_shader_half_float.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/__pycache__/gpu_shader_int16.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/__pycache__/gpu_shader_int16.cpython-312.pyc new file mode 100644 index 00000000..a54fb8bf Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/__pycache__/gpu_shader_int16.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/__pycache__/gpu_shader_int64.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/__pycache__/gpu_shader_int64.cpython-312.pyc new file mode 100644 index 00000000..638c1778 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/__pycache__/gpu_shader_int64.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/__pycache__/interleaved_elements.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/__pycache__/interleaved_elements.cpython-312.pyc new file mode 100644 index 00000000..f154fbf8 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/__pycache__/interleaved_elements.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/__pycache__/multi_draw_indirect.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/__pycache__/multi_draw_indirect.cpython-312.pyc new file mode 100644 index 00000000..1d3d178b Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/__pycache__/multi_draw_indirect.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/__pycache__/name_gen_delete.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/__pycache__/name_gen_delete.cpython-312.pyc new file mode 100644 index 00000000..3045c213 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/__pycache__/name_gen_delete.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/__pycache__/occlusion_query_event.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/__pycache__/occlusion_query_event.cpython-312.pyc new file mode 100644 index 00000000..6c8e6f5b Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/__pycache__/occlusion_query_event.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/__pycache__/performance_monitor.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/__pycache__/performance_monitor.cpython-312.pyc new file mode 100644 index 00000000..94cc206f Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/__pycache__/performance_monitor.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/__pycache__/pinned_memory.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/__pycache__/pinned_memory.cpython-312.pyc new file mode 100644 index 00000000..08e22164 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/__pycache__/pinned_memory.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/__pycache__/query_buffer_object.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/__pycache__/query_buffer_object.cpython-312.pyc new file mode 100644 index 00000000..1db33ab6 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/__pycache__/query_buffer_object.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/__pycache__/sample_positions.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/__pycache__/sample_positions.cpython-312.pyc new file mode 100644 index 00000000..777e9e13 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/__pycache__/sample_positions.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/__pycache__/seamless_cubemap_per_texture.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/__pycache__/seamless_cubemap_per_texture.cpython-312.pyc new file mode 100644 index 00000000..29e1510a Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/__pycache__/seamless_cubemap_per_texture.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/__pycache__/shader_atomic_counter_ops.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/__pycache__/shader_atomic_counter_ops.cpython-312.pyc new file mode 100644 index 00000000..a0c3a78c Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/__pycache__/shader_atomic_counter_ops.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/__pycache__/shader_ballot.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/__pycache__/shader_ballot.cpython-312.pyc new file mode 100644 index 00000000..80c03ab7 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/__pycache__/shader_ballot.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/__pycache__/shader_explicit_vertex_parameter.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/__pycache__/shader_explicit_vertex_parameter.cpython-312.pyc new file mode 100644 index 00000000..e249eaec Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/__pycache__/shader_explicit_vertex_parameter.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/__pycache__/shader_gpu_shader_half_float_fetch.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/__pycache__/shader_gpu_shader_half_float_fetch.cpython-312.pyc new file mode 100644 index 00000000..426785da Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/__pycache__/shader_gpu_shader_half_float_fetch.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/__pycache__/shader_image_load_store_lod.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/__pycache__/shader_image_load_store_lod.cpython-312.pyc new file mode 100644 index 00000000..7286141e Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/__pycache__/shader_image_load_store_lod.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/__pycache__/shader_stencil_export.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/__pycache__/shader_stencil_export.cpython-312.pyc new file mode 100644 index 00000000..5cf7c06c Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/__pycache__/shader_stencil_export.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/__pycache__/shader_trinary_minmax.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/__pycache__/shader_trinary_minmax.cpython-312.pyc new file mode 100644 index 00000000..1ce396e0 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/__pycache__/shader_trinary_minmax.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/__pycache__/sparse_texture.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/__pycache__/sparse_texture.cpython-312.pyc new file mode 100644 index 00000000..42a5930c Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/__pycache__/sparse_texture.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/__pycache__/stencil_operation_extended.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/__pycache__/stencil_operation_extended.cpython-312.pyc new file mode 100644 index 00000000..fa1ce5e9 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/__pycache__/stencil_operation_extended.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/__pycache__/texture_gather_bias_lod.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/__pycache__/texture_gather_bias_lod.cpython-312.pyc new file mode 100644 index 00000000..734e2d75 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/__pycache__/texture_gather_bias_lod.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/__pycache__/texture_texture4.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/__pycache__/texture_texture4.cpython-312.pyc new file mode 100644 index 00000000..23a2e364 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/__pycache__/texture_texture4.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/__pycache__/transform_feedback3_lines_triangles.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/__pycache__/transform_feedback3_lines_triangles.cpython-312.pyc new file mode 100644 index 00000000..d1a9452d Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/__pycache__/transform_feedback3_lines_triangles.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/__pycache__/transform_feedback4.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/__pycache__/transform_feedback4.cpython-312.pyc new file mode 100644 index 00000000..d3a4ddb2 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/__pycache__/transform_feedback4.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/__pycache__/vertex_shader_layer.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/__pycache__/vertex_shader_layer.cpython-312.pyc new file mode 100644 index 00000000..36a7b930 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/__pycache__/vertex_shader_layer.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/__pycache__/vertex_shader_tessellator.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/__pycache__/vertex_shader_tessellator.cpython-312.pyc new file mode 100644 index 00000000..8d6cdd4f Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/__pycache__/vertex_shader_tessellator.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/__pycache__/vertex_shader_viewport_index.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/__pycache__/vertex_shader_viewport_index.cpython-312.pyc new file mode 100644 index 00000000..86312d1b Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/__pycache__/vertex_shader_viewport_index.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/blend_minmax_factor.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/blend_minmax_factor.py new file mode 100644 index 00000000..9e041227 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/blend_minmax_factor.py @@ -0,0 +1,16 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_AMD_blend_minmax_factor' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_AMD_blend_minmax_factor',error_checker=_errors._error_checker) +GL_FACTOR_MAX_AMD=_C('GL_FACTOR_MAX_AMD',0x901D) +GL_FACTOR_MIN_AMD=_C('GL_FACTOR_MIN_AMD',0x901C) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/conservative_depth.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/conservative_depth.py new file mode 100644 index 00000000..a8a71e1c --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/conservative_depth.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_AMD_conservative_depth' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_AMD_conservative_depth',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/debug_output.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/debug_output.py new file mode 100644 index 00000000..1515f0ab --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/debug_output.py @@ -0,0 +1,39 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_AMD_debug_output' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_AMD_debug_output',error_checker=_errors._error_checker) +GL_DEBUG_CATEGORY_API_ERROR_AMD=_C('GL_DEBUG_CATEGORY_API_ERROR_AMD',0x9149) +GL_DEBUG_CATEGORY_APPLICATION_AMD=_C('GL_DEBUG_CATEGORY_APPLICATION_AMD',0x914F) +GL_DEBUG_CATEGORY_DEPRECATION_AMD=_C('GL_DEBUG_CATEGORY_DEPRECATION_AMD',0x914B) +GL_DEBUG_CATEGORY_OTHER_AMD=_C('GL_DEBUG_CATEGORY_OTHER_AMD',0x9150) +GL_DEBUG_CATEGORY_PERFORMANCE_AMD=_C('GL_DEBUG_CATEGORY_PERFORMANCE_AMD',0x914D) +GL_DEBUG_CATEGORY_SHADER_COMPILER_AMD=_C('GL_DEBUG_CATEGORY_SHADER_COMPILER_AMD',0x914E) +GL_DEBUG_CATEGORY_UNDEFINED_BEHAVIOR_AMD=_C('GL_DEBUG_CATEGORY_UNDEFINED_BEHAVIOR_AMD',0x914C) +GL_DEBUG_CATEGORY_WINDOW_SYSTEM_AMD=_C('GL_DEBUG_CATEGORY_WINDOW_SYSTEM_AMD',0x914A) +GL_DEBUG_LOGGED_MESSAGES_AMD=_C('GL_DEBUG_LOGGED_MESSAGES_AMD',0x9145) +GL_DEBUG_SEVERITY_HIGH_AMD=_C('GL_DEBUG_SEVERITY_HIGH_AMD',0x9146) +GL_DEBUG_SEVERITY_LOW_AMD=_C('GL_DEBUG_SEVERITY_LOW_AMD',0x9148) +GL_DEBUG_SEVERITY_MEDIUM_AMD=_C('GL_DEBUG_SEVERITY_MEDIUM_AMD',0x9147) +GL_MAX_DEBUG_LOGGED_MESSAGES_AMD=_C('GL_MAX_DEBUG_LOGGED_MESSAGES_AMD',0x9144) +GL_MAX_DEBUG_MESSAGE_LENGTH_AMD=_C('GL_MAX_DEBUG_MESSAGE_LENGTH_AMD',0x9143) +@_f +@_p.types(None,_cs.GLDEBUGPROCAMD,ctypes.c_void_p) +def glDebugMessageCallbackAMD(callback,userParam):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLsizei,arrays.GLuintArray,_cs.GLboolean) +def glDebugMessageEnableAMD(category,severity,count,ids,enabled):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLuint,_cs.GLsizei,arrays.GLcharArray) +def glDebugMessageInsertAMD(category,severity,id,length,buf):pass +@_f +@_p.types(_cs.GLuint,_cs.GLuint,_cs.GLsizei,arrays.GLuintArray,arrays.GLuintArray,arrays.GLuintArray,arrays.GLsizeiArray,arrays.GLcharArray) +def glGetDebugMessageLogAMD(count,bufsize,categories,severities,ids,lengths,message):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/depth_clamp_separate.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/depth_clamp_separate.py new file mode 100644 index 00000000..0a0552f2 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/depth_clamp_separate.py @@ -0,0 +1,16 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_AMD_depth_clamp_separate' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_AMD_depth_clamp_separate',error_checker=_errors._error_checker) +GL_DEPTH_CLAMP_FAR_AMD=_C('GL_DEPTH_CLAMP_FAR_AMD',0x901F) +GL_DEPTH_CLAMP_NEAR_AMD=_C('GL_DEPTH_CLAMP_NEAR_AMD',0x901E) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/draw_buffers_blend.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/draw_buffers_blend.py new file mode 100644 index 00000000..48c2ad9f --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/draw_buffers_blend.py @@ -0,0 +1,26 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_AMD_draw_buffers_blend' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_AMD_draw_buffers_blend',error_checker=_errors._error_checker) + +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum) +def glBlendEquationIndexedAMD(buf,mode):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLenum) +def glBlendEquationSeparateIndexedAMD(buf,modeRGB,modeAlpha):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLenum) +def glBlendFuncIndexedAMD(buf,src,dst):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLenum,_cs.GLenum,_cs.GLenum) +def glBlendFuncSeparateIndexedAMD(buf,srcRGB,dstRGB,srcAlpha,dstAlpha):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/framebuffer_multisample_advanced.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/framebuffer_multisample_advanced.py new file mode 100644 index 00000000..c31e6adf --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/framebuffer_multisample_advanced.py @@ -0,0 +1,25 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_AMD_framebuffer_multisample_advanced' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_AMD_framebuffer_multisample_advanced',error_checker=_errors._error_checker) +GL_MAX_COLOR_FRAMEBUFFER_SAMPLES_AMD=_C('GL_MAX_COLOR_FRAMEBUFFER_SAMPLES_AMD',0x91B3) +GL_MAX_COLOR_FRAMEBUFFER_STORAGE_SAMPLES_AMD=_C('GL_MAX_COLOR_FRAMEBUFFER_STORAGE_SAMPLES_AMD',0x91B4) +GL_MAX_DEPTH_STENCIL_FRAMEBUFFER_SAMPLES_AMD=_C('GL_MAX_DEPTH_STENCIL_FRAMEBUFFER_SAMPLES_AMD',0x91B5) +GL_NUM_SUPPORTED_MULTISAMPLE_MODES_AMD=_C('GL_NUM_SUPPORTED_MULTISAMPLE_MODES_AMD',0x91B6) +GL_RENDERBUFFER_STORAGE_SAMPLES_AMD=_C('GL_RENDERBUFFER_STORAGE_SAMPLES_AMD',0x91B2) +GL_SUPPORTED_MULTISAMPLE_MODES_AMD=_C('GL_SUPPORTED_MULTISAMPLE_MODES_AMD',0x91B7) +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizei,_cs.GLsizei,_cs.GLenum,_cs.GLsizei,_cs.GLsizei) +def glNamedRenderbufferStorageMultisampleAdvancedAMD(renderbuffer,samples,storageSamples,internalformat,width,height):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizei,_cs.GLsizei,_cs.GLenum,_cs.GLsizei,_cs.GLsizei) +def glRenderbufferStorageMultisampleAdvancedAMD(target,samples,storageSamples,internalformat,width,height):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/framebuffer_sample_positions.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/framebuffer_sample_positions.py new file mode 100644 index 00000000..1bf52792 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/framebuffer_sample_positions.py @@ -0,0 +1,29 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_AMD_framebuffer_sample_positions' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_AMD_framebuffer_sample_positions',error_checker=_errors._error_checker) +GL_ALL_PIXELS_AMD=_C('GL_ALL_PIXELS_AMD',0xFFFFFFFF) +GL_PIXELS_PER_SAMPLE_PATTERN_X_AMD=_C('GL_PIXELS_PER_SAMPLE_PATTERN_X_AMD',0x91AE) +GL_PIXELS_PER_SAMPLE_PATTERN_Y_AMD=_C('GL_PIXELS_PER_SAMPLE_PATTERN_Y_AMD',0x91AF) +GL_SUBSAMPLE_DISTANCE_AMD=_C('GL_SUBSAMPLE_DISTANCE_AMD',0x883F) +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,_cs.GLuint,arrays.GLfloatArray) +def glFramebufferSamplePositionsfvAMD(target,numsamples,pixelindex,values):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLuint,_cs.GLuint,_cs.GLsizei,arrays.GLfloatArray) +def glGetFramebufferParameterfvAMD(target,pname,numsamples,pixelindex,size,values):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLuint,_cs.GLuint,_cs.GLsizei,arrays.GLfloatArray) +def glGetNamedFramebufferParameterfvAMD(framebuffer,pname,numsamples,pixelindex,size,values):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLuint,arrays.GLfloatArray) +def glNamedFramebufferSamplePositionsfvAMD(framebuffer,numsamples,pixelindex,values):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/gcn_shader.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/gcn_shader.py new file mode 100644 index 00000000..cdb407db --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/gcn_shader.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_AMD_gcn_shader' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_AMD_gcn_shader',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/gpu_shader_half_float.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/gpu_shader_half_float.py new file mode 100644 index 00000000..731dfcb0 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/gpu_shader_half_float.py @@ -0,0 +1,27 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_AMD_gpu_shader_half_float' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_AMD_gpu_shader_half_float',error_checker=_errors._error_checker) +GL_FLOAT16_MAT2_AMD=_C('GL_FLOAT16_MAT2_AMD',0x91C5) +GL_FLOAT16_MAT2x3_AMD=_C('GL_FLOAT16_MAT2x3_AMD',0x91C8) +GL_FLOAT16_MAT2x4_AMD=_C('GL_FLOAT16_MAT2x4_AMD',0x91C9) +GL_FLOAT16_MAT3_AMD=_C('GL_FLOAT16_MAT3_AMD',0x91C6) +GL_FLOAT16_MAT3x2_AMD=_C('GL_FLOAT16_MAT3x2_AMD',0x91CA) +GL_FLOAT16_MAT3x4_AMD=_C('GL_FLOAT16_MAT3x4_AMD',0x91CB) +GL_FLOAT16_MAT4_AMD=_C('GL_FLOAT16_MAT4_AMD',0x91C7) +GL_FLOAT16_MAT4x2_AMD=_C('GL_FLOAT16_MAT4x2_AMD',0x91CC) +GL_FLOAT16_MAT4x3_AMD=_C('GL_FLOAT16_MAT4x3_AMD',0x91CD) +GL_FLOAT16_NV=_C('GL_FLOAT16_NV',0x8FF8) +GL_FLOAT16_VEC2_NV=_C('GL_FLOAT16_VEC2_NV',0x8FF9) +GL_FLOAT16_VEC3_NV=_C('GL_FLOAT16_VEC3_NV',0x8FFA) +GL_FLOAT16_VEC4_NV=_C('GL_FLOAT16_VEC4_NV',0x8FFB) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/gpu_shader_int16.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/gpu_shader_int16.py new file mode 100644 index 00000000..582c02a5 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/gpu_shader_int16.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_AMD_gpu_shader_int16' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_AMD_gpu_shader_int16',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/gpu_shader_int64.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/gpu_shader_int64.py new file mode 100644 index 00000000..dd0a1291 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/gpu_shader_int64.py @@ -0,0 +1,143 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_AMD_gpu_shader_int64' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_AMD_gpu_shader_int64',error_checker=_errors._error_checker) +GL_FLOAT16_NV=_C('GL_FLOAT16_NV',0x8FF8) +GL_FLOAT16_VEC2_NV=_C('GL_FLOAT16_VEC2_NV',0x8FF9) +GL_FLOAT16_VEC3_NV=_C('GL_FLOAT16_VEC3_NV',0x8FFA) +GL_FLOAT16_VEC4_NV=_C('GL_FLOAT16_VEC4_NV',0x8FFB) +GL_INT16_NV=_C('GL_INT16_NV',0x8FE4) +GL_INT16_VEC2_NV=_C('GL_INT16_VEC2_NV',0x8FE5) +GL_INT16_VEC3_NV=_C('GL_INT16_VEC3_NV',0x8FE6) +GL_INT16_VEC4_NV=_C('GL_INT16_VEC4_NV',0x8FE7) +GL_INT64_NV=_C('GL_INT64_NV',0x140E) +GL_INT64_VEC2_NV=_C('GL_INT64_VEC2_NV',0x8FE9) +GL_INT64_VEC3_NV=_C('GL_INT64_VEC3_NV',0x8FEA) +GL_INT64_VEC4_NV=_C('GL_INT64_VEC4_NV',0x8FEB) +GL_INT8_NV=_C('GL_INT8_NV',0x8FE0) +GL_INT8_VEC2_NV=_C('GL_INT8_VEC2_NV',0x8FE1) +GL_INT8_VEC3_NV=_C('GL_INT8_VEC3_NV',0x8FE2) +GL_INT8_VEC4_NV=_C('GL_INT8_VEC4_NV',0x8FE3) +GL_UNSIGNED_INT16_NV=_C('GL_UNSIGNED_INT16_NV',0x8FF0) +GL_UNSIGNED_INT16_VEC2_NV=_C('GL_UNSIGNED_INT16_VEC2_NV',0x8FF1) +GL_UNSIGNED_INT16_VEC3_NV=_C('GL_UNSIGNED_INT16_VEC3_NV',0x8FF2) +GL_UNSIGNED_INT16_VEC4_NV=_C('GL_UNSIGNED_INT16_VEC4_NV',0x8FF3) +GL_UNSIGNED_INT64_NV=_C('GL_UNSIGNED_INT64_NV',0x140F) +GL_UNSIGNED_INT64_VEC2_NV=_C('GL_UNSIGNED_INT64_VEC2_NV',0x8FF5) +GL_UNSIGNED_INT64_VEC3_NV=_C('GL_UNSIGNED_INT64_VEC3_NV',0x8FF6) +GL_UNSIGNED_INT64_VEC4_NV=_C('GL_UNSIGNED_INT64_VEC4_NV',0x8FF7) +GL_UNSIGNED_INT8_NV=_C('GL_UNSIGNED_INT8_NV',0x8FEC) +GL_UNSIGNED_INT8_VEC2_NV=_C('GL_UNSIGNED_INT8_VEC2_NV',0x8FED) +GL_UNSIGNED_INT8_VEC3_NV=_C('GL_UNSIGNED_INT8_VEC3_NV',0x8FEE) +GL_UNSIGNED_INT8_VEC4_NV=_C('GL_UNSIGNED_INT8_VEC4_NV',0x8FEF) +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,arrays.GLint64Array) +def glGetUniformi64vNV(program,location,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,arrays.GLuint64Array) +def glGetUniformui64vNV(program,location,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLint64EXT) +def glProgramUniform1i64NV(program,location,x):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLint64Array) +def glProgramUniform1i64vNV(program,location,count,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLuint64EXT) +def glProgramUniform1ui64NV(program,location,x):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLuint64Array) +def glProgramUniform1ui64vNV(program,location,count,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLint64EXT,_cs.GLint64EXT) +def glProgramUniform2i64NV(program,location,x,y):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLint64Array) +def glProgramUniform2i64vNV(program,location,count,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLuint64EXT,_cs.GLuint64EXT) +def glProgramUniform2ui64NV(program,location,x,y):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLuint64Array) +def glProgramUniform2ui64vNV(program,location,count,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLint64EXT,_cs.GLint64EXT,_cs.GLint64EXT) +def glProgramUniform3i64NV(program,location,x,y,z):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLint64Array) +def glProgramUniform3i64vNV(program,location,count,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLuint64EXT,_cs.GLuint64EXT,_cs.GLuint64EXT) +def glProgramUniform3ui64NV(program,location,x,y,z):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLuint64Array) +def glProgramUniform3ui64vNV(program,location,count,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLint64EXT,_cs.GLint64EXT,_cs.GLint64EXT,_cs.GLint64EXT) +def glProgramUniform4i64NV(program,location,x,y,z,w):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLint64Array) +def glProgramUniform4i64vNV(program,location,count,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLuint64EXT,_cs.GLuint64EXT,_cs.GLuint64EXT,_cs.GLuint64EXT) +def glProgramUniform4ui64NV(program,location,x,y,z,w):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLuint64Array) +def glProgramUniform4ui64vNV(program,location,count,value):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLint64EXT) +def glUniform1i64NV(location,x):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLsizei,arrays.GLint64Array) +def glUniform1i64vNV(location,count,value):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLuint64EXT) +def glUniform1ui64NV(location,x):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLsizei,arrays.GLuint64Array) +def glUniform1ui64vNV(location,count,value):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLint64EXT,_cs.GLint64EXT) +def glUniform2i64NV(location,x,y):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLsizei,arrays.GLint64Array) +def glUniform2i64vNV(location,count,value):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLuint64EXT,_cs.GLuint64EXT) +def glUniform2ui64NV(location,x,y):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLsizei,arrays.GLuint64Array) +def glUniform2ui64vNV(location,count,value):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLint64EXT,_cs.GLint64EXT,_cs.GLint64EXT) +def glUniform3i64NV(location,x,y,z):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLsizei,arrays.GLint64Array) +def glUniform3i64vNV(location,count,value):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLuint64EXT,_cs.GLuint64EXT,_cs.GLuint64EXT) +def glUniform3ui64NV(location,x,y,z):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLsizei,arrays.GLuint64Array) +def glUniform3ui64vNV(location,count,value):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLint64EXT,_cs.GLint64EXT,_cs.GLint64EXT,_cs.GLint64EXT) +def glUniform4i64NV(location,x,y,z,w):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLsizei,arrays.GLint64Array) +def glUniform4i64vNV(location,count,value):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLuint64EXT,_cs.GLuint64EXT,_cs.GLuint64EXT,_cs.GLuint64EXT) +def glUniform4ui64NV(location,x,y,z,w):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLsizei,arrays.GLuint64Array) +def glUniform4ui64vNV(location,count,value):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/interleaved_elements.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/interleaved_elements.py new file mode 100644 index 00000000..e84d31f7 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/interleaved_elements.py @@ -0,0 +1,25 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_AMD_interleaved_elements' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_AMD_interleaved_elements',error_checker=_errors._error_checker) +GL_ALPHA=_C('GL_ALPHA',0x1906) +GL_BLUE=_C('GL_BLUE',0x1905) +GL_GREEN=_C('GL_GREEN',0x1904) +GL_RED=_C('GL_RED',0x1903) +GL_RG16UI=_C('GL_RG16UI',0x823A) +GL_RG8UI=_C('GL_RG8UI',0x8238) +GL_RGBA8UI=_C('GL_RGBA8UI',0x8D7C) +GL_VERTEX_ELEMENT_SWIZZLE_AMD=_C('GL_VERTEX_ELEMENT_SWIZZLE_AMD',0x91A4) +GL_VERTEX_ID_SWIZZLE_AMD=_C('GL_VERTEX_ID_SWIZZLE_AMD',0x91A5) +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLint) +def glVertexAttribParameteriAMD(index,pname,param):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/multi_draw_indirect.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/multi_draw_indirect.py new file mode 100644 index 00000000..6ada410c --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/multi_draw_indirect.py @@ -0,0 +1,20 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_AMD_multi_draw_indirect' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_AMD_multi_draw_indirect',error_checker=_errors._error_checker) + +@_f +@_p.types(None,_cs.GLenum,ctypes.c_void_p,_cs.GLsizei,_cs.GLsizei) +def glMultiDrawArraysIndirectAMD(mode,indirect,primcount,stride):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,ctypes.c_void_p,_cs.GLsizei,_cs.GLsizei) +def glMultiDrawElementsIndirectAMD(mode,type,indirect,primcount,stride):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/name_gen_delete.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/name_gen_delete.py new file mode 100644 index 00000000..dfc6d2b0 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/name_gen_delete.py @@ -0,0 +1,27 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_AMD_name_gen_delete' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_AMD_name_gen_delete',error_checker=_errors._error_checker) +GL_DATA_BUFFER_AMD=_C('GL_DATA_BUFFER_AMD',0x9151) +GL_PERFORMANCE_MONITOR_AMD=_C('GL_PERFORMANCE_MONITOR_AMD',0x9152) +GL_QUERY_OBJECT_AMD=_C('GL_QUERY_OBJECT_AMD',0x9153) +GL_SAMPLER_OBJECT_AMD=_C('GL_SAMPLER_OBJECT_AMD',0x9155) +GL_VERTEX_ARRAY_OBJECT_AMD=_C('GL_VERTEX_ARRAY_OBJECT_AMD',0x9154) +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,arrays.GLuintArray) +def glDeleteNamesAMD(identifier,num,names):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,arrays.GLuintArray) +def glGenNamesAMD(identifier,num,names):pass +@_f +@_p.types(_cs.GLboolean,_cs.GLenum,_cs.GLuint) +def glIsNameAMD(identifier,name):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/occlusion_query_event.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/occlusion_query_event.py new file mode 100644 index 00000000..c2770d46 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/occlusion_query_event.py @@ -0,0 +1,22 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_AMD_occlusion_query_event' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_AMD_occlusion_query_event',error_checker=_errors._error_checker) +GL_OCCLUSION_QUERY_EVENT_MASK_AMD=_C('GL_OCCLUSION_QUERY_EVENT_MASK_AMD',0x874F) +GL_QUERY_ALL_EVENT_BITS_AMD=_C('GL_QUERY_ALL_EVENT_BITS_AMD',0xFFFFFFFF) +GL_QUERY_DEPTH_BOUNDS_FAIL_EVENT_BIT_AMD=_C('GL_QUERY_DEPTH_BOUNDS_FAIL_EVENT_BIT_AMD',0x00000008) +GL_QUERY_DEPTH_FAIL_EVENT_BIT_AMD=_C('GL_QUERY_DEPTH_FAIL_EVENT_BIT_AMD',0x00000002) +GL_QUERY_DEPTH_PASS_EVENT_BIT_AMD=_C('GL_QUERY_DEPTH_PASS_EVENT_BIT_AMD',0x00000001) +GL_QUERY_STENCIL_FAIL_EVENT_BIT_AMD=_C('GL_QUERY_STENCIL_FAIL_EVENT_BIT_AMD',0x00000004) +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,_cs.GLenum,_cs.GLuint) +def glQueryObjectParameteruiAMD(target,id,pname,param):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/performance_monitor.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/performance_monitor.py new file mode 100644 index 00000000..02e4d41a --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/performance_monitor.py @@ -0,0 +1,53 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_AMD_performance_monitor' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_AMD_performance_monitor',error_checker=_errors._error_checker) +GL_COUNTER_RANGE_AMD=_C('GL_COUNTER_RANGE_AMD',0x8BC1) +GL_COUNTER_TYPE_AMD=_C('GL_COUNTER_TYPE_AMD',0x8BC0) +GL_PERCENTAGE_AMD=_C('GL_PERCENTAGE_AMD',0x8BC3) +GL_PERFMON_RESULT_AMD=_C('GL_PERFMON_RESULT_AMD',0x8BC6) +GL_PERFMON_RESULT_AVAILABLE_AMD=_C('GL_PERFMON_RESULT_AVAILABLE_AMD',0x8BC4) +GL_PERFMON_RESULT_SIZE_AMD=_C('GL_PERFMON_RESULT_SIZE_AMD',0x8BC5) +GL_UNSIGNED_INT64_AMD=_C('GL_UNSIGNED_INT64_AMD',0x8BC2) +@_f +@_p.types(None,_cs.GLuint) +def glBeginPerfMonitorAMD(monitor):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray) +def glDeletePerfMonitorsAMD(n,monitors):pass +@_f +@_p.types(None,_cs.GLuint) +def glEndPerfMonitorAMD(monitor):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray) +def glGenPerfMonitorsAMD(n,monitors):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLsizei,arrays.GLuintArray,arrays.GLintArray) +def glGetPerfMonitorCounterDataAMD(monitor,pname,dataSize,data,bytesWritten):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLenum,ctypes.c_void_p) +def glGetPerfMonitorCounterInfoAMD(group,counter,pname,data):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLsizei,arrays.GLsizeiArray,arrays.GLcharArray) +def glGetPerfMonitorCounterStringAMD(group,counter,bufSize,length,counterString):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLintArray,arrays.GLintArray,_cs.GLsizei,arrays.GLuintArray) +def glGetPerfMonitorCountersAMD(group,numCounters,maxActiveCounters,counterSize,counters):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizei,arrays.GLsizeiArray,arrays.GLcharArray) +def glGetPerfMonitorGroupStringAMD(group,bufSize,length,groupString):pass +@_f +@_p.types(None,arrays.GLintArray,_cs.GLsizei,arrays.GLuintArray) +def glGetPerfMonitorGroupsAMD(numGroups,groupsSize,groups):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLboolean,_cs.GLuint,_cs.GLint,arrays.GLuintArray) +def glSelectPerfMonitorCountersAMD(monitor,enable,group,numCounters,counterList):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/pinned_memory.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/pinned_memory.py new file mode 100644 index 00000000..9b50e710 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/pinned_memory.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_AMD_pinned_memory' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_AMD_pinned_memory',error_checker=_errors._error_checker) +GL_EXTERNAL_VIRTUAL_MEMORY_BUFFER_AMD=_C('GL_EXTERNAL_VIRTUAL_MEMORY_BUFFER_AMD',0x9160) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/query_buffer_object.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/query_buffer_object.py new file mode 100644 index 00000000..6ae9f967 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/query_buffer_object.py @@ -0,0 +1,17 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_AMD_query_buffer_object' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_AMD_query_buffer_object',error_checker=_errors._error_checker) +GL_QUERY_BUFFER_AMD=_C('GL_QUERY_BUFFER_AMD',0x9192) +GL_QUERY_BUFFER_BINDING_AMD=_C('GL_QUERY_BUFFER_BINDING_AMD',0x9193) +GL_QUERY_RESULT_NO_WAIT_AMD=_C('GL_QUERY_RESULT_NO_WAIT_AMD',0x9194) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/sample_positions.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/sample_positions.py new file mode 100644 index 00000000..4eb16581 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/sample_positions.py @@ -0,0 +1,17 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_AMD_sample_positions' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_AMD_sample_positions',error_checker=_errors._error_checker) +GL_SUBSAMPLE_DISTANCE_AMD=_C('GL_SUBSAMPLE_DISTANCE_AMD',0x883F) +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,arrays.GLfloatArray) +def glSetMultisamplefvAMD(pname,index,val):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/seamless_cubemap_per_texture.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/seamless_cubemap_per_texture.py new file mode 100644 index 00000000..80a94793 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/seamless_cubemap_per_texture.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_AMD_seamless_cubemap_per_texture' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_AMD_seamless_cubemap_per_texture',error_checker=_errors._error_checker) +GL_TEXTURE_CUBE_MAP_SEAMLESS=_C('GL_TEXTURE_CUBE_MAP_SEAMLESS',0x884F) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/shader_atomic_counter_ops.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/shader_atomic_counter_ops.py new file mode 100644 index 00000000..5e2a169f --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/shader_atomic_counter_ops.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_AMD_shader_atomic_counter_ops' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_AMD_shader_atomic_counter_ops',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/shader_ballot.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/shader_ballot.py new file mode 100644 index 00000000..76e1d03a --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/shader_ballot.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_AMD_shader_ballot' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_AMD_shader_ballot',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/shader_explicit_vertex_parameter.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/shader_explicit_vertex_parameter.py new file mode 100644 index 00000000..de591b32 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/shader_explicit_vertex_parameter.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_AMD_shader_explicit_vertex_parameter' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_AMD_shader_explicit_vertex_parameter',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/shader_gpu_shader_half_float_fetch.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/shader_gpu_shader_half_float_fetch.py new file mode 100644 index 00000000..942d878d --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/shader_gpu_shader_half_float_fetch.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_AMD_shader_gpu_shader_half_float_fetch' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_AMD_shader_gpu_shader_half_float_fetch',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/shader_image_load_store_lod.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/shader_image_load_store_lod.py new file mode 100644 index 00000000..8ab3aaa9 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/shader_image_load_store_lod.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_AMD_shader_image_load_store_lod' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_AMD_shader_image_load_store_lod',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/shader_stencil_export.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/shader_stencil_export.py new file mode 100644 index 00000000..94f52534 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/shader_stencil_export.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_AMD_shader_stencil_export' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_AMD_shader_stencil_export',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/shader_trinary_minmax.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/shader_trinary_minmax.py new file mode 100644 index 00000000..380704ca --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/shader_trinary_minmax.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_AMD_shader_trinary_minmax' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_AMD_shader_trinary_minmax',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/sparse_texture.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/sparse_texture.py new file mode 100644 index 00000000..52061b6e --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/sparse_texture.py @@ -0,0 +1,28 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_AMD_sparse_texture' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_AMD_sparse_texture',error_checker=_errors._error_checker) +GL_MAX_SPARSE_3D_TEXTURE_SIZE_AMD=_C('GL_MAX_SPARSE_3D_TEXTURE_SIZE_AMD',0x9199) +GL_MAX_SPARSE_ARRAY_TEXTURE_LAYERS=_C('GL_MAX_SPARSE_ARRAY_TEXTURE_LAYERS',0x919A) +GL_MAX_SPARSE_TEXTURE_SIZE_AMD=_C('GL_MAX_SPARSE_TEXTURE_SIZE_AMD',0x9198) +GL_MIN_LOD_WARNING_AMD=_C('GL_MIN_LOD_WARNING_AMD',0x919C) +GL_MIN_SPARSE_LEVEL_AMD=_C('GL_MIN_SPARSE_LEVEL_AMD',0x919B) +GL_TEXTURE_STORAGE_SPARSE_BIT_AMD=_C('GL_TEXTURE_STORAGE_SPARSE_BIT_AMD',0x00000001) +GL_VIRTUAL_PAGE_SIZE_X_AMD=_C('GL_VIRTUAL_PAGE_SIZE_X_AMD',0x9195) +GL_VIRTUAL_PAGE_SIZE_Y_AMD=_C('GL_VIRTUAL_PAGE_SIZE_Y_AMD',0x9196) +GL_VIRTUAL_PAGE_SIZE_Z_AMD=_C('GL_VIRTUAL_PAGE_SIZE_Z_AMD',0x9197) +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLsizei,_cs.GLsizei,_cs.GLsizei,_cs.GLsizei,_cs.GLbitfield) +def glTexStorageSparseAMD(target,internalFormat,width,height,depth,layers,flags):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLenum,_cs.GLsizei,_cs.GLsizei,_cs.GLsizei,_cs.GLsizei,_cs.GLbitfield) +def glTextureStorageSparseAMD(texture,target,internalFormat,width,height,depth,layers,flags):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/stencil_operation_extended.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/stencil_operation_extended.py new file mode 100644 index 00000000..ee67477f --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/stencil_operation_extended.py @@ -0,0 +1,20 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_AMD_stencil_operation_extended' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_AMD_stencil_operation_extended',error_checker=_errors._error_checker) +GL_REPLACE_VALUE_AMD=_C('GL_REPLACE_VALUE_AMD',0x874B) +GL_SET_AMD=_C('GL_SET_AMD',0x874A) +GL_STENCIL_BACK_OP_VALUE_AMD=_C('GL_STENCIL_BACK_OP_VALUE_AMD',0x874D) +GL_STENCIL_OP_VALUE_AMD=_C('GL_STENCIL_OP_VALUE_AMD',0x874C) +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint) +def glStencilOpValueAMD(face,value):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/texture_gather_bias_lod.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/texture_gather_bias_lod.py new file mode 100644 index 00000000..e654c006 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/texture_gather_bias_lod.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_AMD_texture_gather_bias_lod' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_AMD_texture_gather_bias_lod',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/texture_texture4.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/texture_texture4.py new file mode 100644 index 00000000..f5022127 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/texture_texture4.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_AMD_texture_texture4' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_AMD_texture_texture4',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/transform_feedback3_lines_triangles.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/transform_feedback3_lines_triangles.py new file mode 100644 index 00000000..7a25ccb4 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/transform_feedback3_lines_triangles.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_AMD_transform_feedback3_lines_triangles' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_AMD_transform_feedback3_lines_triangles',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/transform_feedback4.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/transform_feedback4.py new file mode 100644 index 00000000..89c9a34a --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/transform_feedback4.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_AMD_transform_feedback4' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_AMD_transform_feedback4',error_checker=_errors._error_checker) +GL_STREAM_RASTERIZATION_AMD=_C('GL_STREAM_RASTERIZATION_AMD',0x91A0) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/vertex_shader_layer.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/vertex_shader_layer.py new file mode 100644 index 00000000..7cd46156 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/vertex_shader_layer.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_AMD_vertex_shader_layer' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_AMD_vertex_shader_layer',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/vertex_shader_tessellator.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/vertex_shader_tessellator.py new file mode 100644 index 00000000..4ada609b --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/vertex_shader_tessellator.py @@ -0,0 +1,26 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_AMD_vertex_shader_tessellator' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_AMD_vertex_shader_tessellator',error_checker=_errors._error_checker) +GL_CONTINUOUS_AMD=_C('GL_CONTINUOUS_AMD',0x9007) +GL_DISCRETE_AMD=_C('GL_DISCRETE_AMD',0x9006) +GL_INT_SAMPLER_BUFFER_AMD=_C('GL_INT_SAMPLER_BUFFER_AMD',0x9002) +GL_SAMPLER_BUFFER_AMD=_C('GL_SAMPLER_BUFFER_AMD',0x9001) +GL_TESSELLATION_FACTOR_AMD=_C('GL_TESSELLATION_FACTOR_AMD',0x9005) +GL_TESSELLATION_MODE_AMD=_C('GL_TESSELLATION_MODE_AMD',0x9004) +GL_UNSIGNED_INT_SAMPLER_BUFFER_AMD=_C('GL_UNSIGNED_INT_SAMPLER_BUFFER_AMD',0x9003) +@_f +@_p.types(None,_cs.GLfloat) +def glTessellationFactorAMD(factor):pass +@_f +@_p.types(None,_cs.GLenum) +def glTessellationModeAMD(mode):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/vertex_shader_viewport_index.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/vertex_shader_viewport_index.py new file mode 100644 index 00000000..d1de6d0b --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/AMD/vertex_shader_viewport_index.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_AMD_vertex_shader_viewport_index' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_AMD_vertex_shader_viewport_index',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ANGLE/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ANGLE/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ANGLE/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ANGLE/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ANGLE/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..20c128a7 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ANGLE/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/APPLE/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/APPLE/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/APPLE/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/APPLE/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/APPLE/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..978d37b6 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/APPLE/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/APPLE/__pycache__/aux_depth_stencil.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/APPLE/__pycache__/aux_depth_stencil.cpython-312.pyc new file mode 100644 index 00000000..61cc177b Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/APPLE/__pycache__/aux_depth_stencil.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/APPLE/__pycache__/client_storage.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/APPLE/__pycache__/client_storage.cpython-312.pyc new file mode 100644 index 00000000..8135abc6 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/APPLE/__pycache__/client_storage.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/APPLE/__pycache__/element_array.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/APPLE/__pycache__/element_array.cpython-312.pyc new file mode 100644 index 00000000..b3ac1291 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/APPLE/__pycache__/element_array.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/APPLE/__pycache__/fence.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/APPLE/__pycache__/fence.cpython-312.pyc new file mode 100644 index 00000000..6e500e3f Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/APPLE/__pycache__/fence.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/APPLE/__pycache__/float_pixels.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/APPLE/__pycache__/float_pixels.cpython-312.pyc new file mode 100644 index 00000000..58777528 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/APPLE/__pycache__/float_pixels.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/APPLE/__pycache__/flush_buffer_range.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/APPLE/__pycache__/flush_buffer_range.cpython-312.pyc new file mode 100644 index 00000000..b204a799 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/APPLE/__pycache__/flush_buffer_range.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/APPLE/__pycache__/object_purgeable.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/APPLE/__pycache__/object_purgeable.cpython-312.pyc new file mode 100644 index 00000000..6552a60f Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/APPLE/__pycache__/object_purgeable.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/APPLE/__pycache__/rgb_422.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/APPLE/__pycache__/rgb_422.cpython-312.pyc new file mode 100644 index 00000000..9222e89b Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/APPLE/__pycache__/rgb_422.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/APPLE/__pycache__/row_bytes.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/APPLE/__pycache__/row_bytes.cpython-312.pyc new file mode 100644 index 00000000..f11be4af Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/APPLE/__pycache__/row_bytes.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/APPLE/__pycache__/specular_vector.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/APPLE/__pycache__/specular_vector.cpython-312.pyc new file mode 100644 index 00000000..c0dd246e Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/APPLE/__pycache__/specular_vector.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/APPLE/__pycache__/texture_range.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/APPLE/__pycache__/texture_range.cpython-312.pyc new file mode 100644 index 00000000..ca9ad81c Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/APPLE/__pycache__/texture_range.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/APPLE/__pycache__/transform_hint.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/APPLE/__pycache__/transform_hint.cpython-312.pyc new file mode 100644 index 00000000..e1446085 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/APPLE/__pycache__/transform_hint.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/APPLE/__pycache__/vertex_array_object.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/APPLE/__pycache__/vertex_array_object.cpython-312.pyc new file mode 100644 index 00000000..54c44aea Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/APPLE/__pycache__/vertex_array_object.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/APPLE/__pycache__/vertex_array_range.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/APPLE/__pycache__/vertex_array_range.cpython-312.pyc new file mode 100644 index 00000000..c5610701 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/APPLE/__pycache__/vertex_array_range.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/APPLE/__pycache__/vertex_program_evaluators.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/APPLE/__pycache__/vertex_program_evaluators.cpython-312.pyc new file mode 100644 index 00000000..e06004ef Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/APPLE/__pycache__/vertex_program_evaluators.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/APPLE/__pycache__/ycbcr_422.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/APPLE/__pycache__/ycbcr_422.cpython-312.pyc new file mode 100644 index 00000000..8dca87da Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/APPLE/__pycache__/ycbcr_422.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/APPLE/aux_depth_stencil.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/APPLE/aux_depth_stencil.py new file mode 100644 index 00000000..42239f6e --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/APPLE/aux_depth_stencil.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_APPLE_aux_depth_stencil' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_APPLE_aux_depth_stencil',error_checker=_errors._error_checker) +GL_AUX_DEPTH_STENCIL_APPLE=_C('GL_AUX_DEPTH_STENCIL_APPLE',0x8A14) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/APPLE/client_storage.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/APPLE/client_storage.py new file mode 100644 index 00000000..5dc016b0 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/APPLE/client_storage.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_APPLE_client_storage' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_APPLE_client_storage',error_checker=_errors._error_checker) +GL_UNPACK_CLIENT_STORAGE_APPLE=_C('GL_UNPACK_CLIENT_STORAGE_APPLE',0x85B2) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/APPLE/element_array.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/APPLE/element_array.py new file mode 100644 index 00000000..d1b0413f --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/APPLE/element_array.py @@ -0,0 +1,31 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_APPLE_element_array' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_APPLE_element_array',error_checker=_errors._error_checker) +GL_ELEMENT_ARRAY_APPLE=_C('GL_ELEMENT_ARRAY_APPLE',0x8A0C) +GL_ELEMENT_ARRAY_POINTER_APPLE=_C('GL_ELEMENT_ARRAY_POINTER_APPLE',0x8A0E) +GL_ELEMENT_ARRAY_TYPE_APPLE=_C('GL_ELEMENT_ARRAY_TYPE_APPLE',0x8A0D) +@_f +@_p.types(None,_cs.GLenum,_cs.GLint,_cs.GLsizei) +def glDrawElementArrayAPPLE(mode,first,count):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,_cs.GLuint,_cs.GLint,_cs.GLsizei) +def glDrawRangeElementArrayAPPLE(mode,start,end,first,count):pass +@_f +@_p.types(None,_cs.GLenum,ctypes.c_void_p) +def glElementPointerAPPLE(type,pointer):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLintArray,arrays.GLsizeiArray,_cs.GLsizei) +def glMultiDrawElementArrayAPPLE(mode,first,count,primcount):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,_cs.GLuint,arrays.GLintArray,arrays.GLsizeiArray,_cs.GLsizei) +def glMultiDrawRangeElementArrayAPPLE(mode,start,end,first,count,primcount):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/APPLE/fence.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/APPLE/fence.py new file mode 100644 index 00000000..ce128959 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/APPLE/fence.py @@ -0,0 +1,39 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_APPLE_fence' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_APPLE_fence',error_checker=_errors._error_checker) +GL_DRAW_PIXELS_APPLE=_C('GL_DRAW_PIXELS_APPLE',0x8A0A) +GL_FENCE_APPLE=_C('GL_FENCE_APPLE',0x8A0B) +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray) +def glDeleteFencesAPPLE(n,fences):pass +@_f +@_p.types(None,_cs.GLuint) +def glFinishFenceAPPLE(fence):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLint) +def glFinishObjectAPPLE(object,name):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray) +def glGenFencesAPPLE(n,fences):pass +@_f +@_p.types(_cs.GLboolean,_cs.GLuint) +def glIsFenceAPPLE(fence):pass +@_f +@_p.types(None,_cs.GLuint) +def glSetFenceAPPLE(fence):pass +@_f +@_p.types(_cs.GLboolean,_cs.GLuint) +def glTestFenceAPPLE(fence):pass +@_f +@_p.types(_cs.GLboolean,_cs.GLenum,_cs.GLuint) +def glTestObjectAPPLE(object,name):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/APPLE/float_pixels.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/APPLE/float_pixels.py new file mode 100644 index 00000000..dd8fcf11 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/APPLE/float_pixels.py @@ -0,0 +1,28 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_APPLE_float_pixels' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_APPLE_float_pixels',error_checker=_errors._error_checker) +GL_ALPHA_FLOAT16_APPLE=_C('GL_ALPHA_FLOAT16_APPLE',0x881C) +GL_ALPHA_FLOAT32_APPLE=_C('GL_ALPHA_FLOAT32_APPLE',0x8816) +GL_COLOR_FLOAT_APPLE=_C('GL_COLOR_FLOAT_APPLE',0x8A0F) +GL_HALF_APPLE=_C('GL_HALF_APPLE',0x140B) +GL_INTENSITY_FLOAT16_APPLE=_C('GL_INTENSITY_FLOAT16_APPLE',0x881D) +GL_INTENSITY_FLOAT32_APPLE=_C('GL_INTENSITY_FLOAT32_APPLE',0x8817) +GL_LUMINANCE_ALPHA_FLOAT16_APPLE=_C('GL_LUMINANCE_ALPHA_FLOAT16_APPLE',0x881F) +GL_LUMINANCE_ALPHA_FLOAT32_APPLE=_C('GL_LUMINANCE_ALPHA_FLOAT32_APPLE',0x8819) +GL_LUMINANCE_FLOAT16_APPLE=_C('GL_LUMINANCE_FLOAT16_APPLE',0x881E) +GL_LUMINANCE_FLOAT32_APPLE=_C('GL_LUMINANCE_FLOAT32_APPLE',0x8818) +GL_RGBA_FLOAT16_APPLE=_C('GL_RGBA_FLOAT16_APPLE',0x881A) +GL_RGBA_FLOAT32_APPLE=_C('GL_RGBA_FLOAT32_APPLE',0x8814) +GL_RGB_FLOAT16_APPLE=_C('GL_RGB_FLOAT16_APPLE',0x881B) +GL_RGB_FLOAT32_APPLE=_C('GL_RGB_FLOAT32_APPLE',0x8815) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/APPLE/flush_buffer_range.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/APPLE/flush_buffer_range.py new file mode 100644 index 00000000..60f96ec0 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/APPLE/flush_buffer_range.py @@ -0,0 +1,21 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_APPLE_flush_buffer_range' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_APPLE_flush_buffer_range',error_checker=_errors._error_checker) +GL_BUFFER_FLUSHING_UNMAP_APPLE=_C('GL_BUFFER_FLUSHING_UNMAP_APPLE',0x8A13) +GL_BUFFER_SERIALIZED_MODIFY_APPLE=_C('GL_BUFFER_SERIALIZED_MODIFY_APPLE',0x8A12) +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLint) +def glBufferParameteriAPPLE(target,pname,param):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLintptr,_cs.GLsizeiptr) +def glFlushMappedBufferRangeAPPLE(target,offset,size):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/APPLE/object_purgeable.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/APPLE/object_purgeable.py new file mode 100644 index 00000000..0b389a56 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/APPLE/object_purgeable.py @@ -0,0 +1,28 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_APPLE_object_purgeable' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_APPLE_object_purgeable',error_checker=_errors._error_checker) +GL_BUFFER_OBJECT_APPLE=_C('GL_BUFFER_OBJECT_APPLE',0x85B3) +GL_PURGEABLE_APPLE=_C('GL_PURGEABLE_APPLE',0x8A1D) +GL_RELEASED_APPLE=_C('GL_RELEASED_APPLE',0x8A19) +GL_RETAINED_APPLE=_C('GL_RETAINED_APPLE',0x8A1B) +GL_UNDEFINED_APPLE=_C('GL_UNDEFINED_APPLE',0x8A1C) +GL_VOLATILE_APPLE=_C('GL_VOLATILE_APPLE',0x8A1A) +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,_cs.GLenum,arrays.GLintArray) +def glGetObjectParameterivAPPLE(objectType,name,pname,params):pass +@_f +@_p.types(_cs.GLenum,_cs.GLenum,_cs.GLuint,_cs.GLenum) +def glObjectPurgeableAPPLE(objectType,name,option):pass +@_f +@_p.types(_cs.GLenum,_cs.GLenum,_cs.GLuint,_cs.GLenum) +def glObjectUnpurgeableAPPLE(objectType,name,option):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/APPLE/rgb_422.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/APPLE/rgb_422.py new file mode 100644 index 00000000..855465a8 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/APPLE/rgb_422.py @@ -0,0 +1,18 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_APPLE_rgb_422' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_APPLE_rgb_422',error_checker=_errors._error_checker) +GL_RGB_422_APPLE=_C('GL_RGB_422_APPLE',0x8A1F) +GL_RGB_RAW_422_APPLE=_C('GL_RGB_RAW_422_APPLE',0x8A51) +GL_UNSIGNED_SHORT_8_8_APPLE=_C('GL_UNSIGNED_SHORT_8_8_APPLE',0x85BA) +GL_UNSIGNED_SHORT_8_8_REV_APPLE=_C('GL_UNSIGNED_SHORT_8_8_REV_APPLE',0x85BB) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/APPLE/row_bytes.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/APPLE/row_bytes.py new file mode 100644 index 00000000..17679c27 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/APPLE/row_bytes.py @@ -0,0 +1,16 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_APPLE_row_bytes' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_APPLE_row_bytes',error_checker=_errors._error_checker) +GL_PACK_ROW_BYTES_APPLE=_C('GL_PACK_ROW_BYTES_APPLE',0x8A15) +GL_UNPACK_ROW_BYTES_APPLE=_C('GL_UNPACK_ROW_BYTES_APPLE',0x8A16) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/APPLE/specular_vector.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/APPLE/specular_vector.py new file mode 100644 index 00000000..68af15ec --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/APPLE/specular_vector.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_APPLE_specular_vector' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_APPLE_specular_vector',error_checker=_errors._error_checker) +GL_LIGHT_MODEL_SPECULAR_VECTOR_APPLE=_C('GL_LIGHT_MODEL_SPECULAR_VECTOR_APPLE',0x85B0) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/APPLE/texture_range.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/APPLE/texture_range.py new file mode 100644 index 00000000..e17c491d --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/APPLE/texture_range.py @@ -0,0 +1,25 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_APPLE_texture_range' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_APPLE_texture_range',error_checker=_errors._error_checker) +GL_STORAGE_CACHED_APPLE=_C('GL_STORAGE_CACHED_APPLE',0x85BE) +GL_STORAGE_PRIVATE_APPLE=_C('GL_STORAGE_PRIVATE_APPLE',0x85BD) +GL_STORAGE_SHARED_APPLE=_C('GL_STORAGE_SHARED_APPLE',0x85BF) +GL_TEXTURE_RANGE_LENGTH_APPLE=_C('GL_TEXTURE_RANGE_LENGTH_APPLE',0x85B7) +GL_TEXTURE_RANGE_POINTER_APPLE=_C('GL_TEXTURE_RANGE_POINTER_APPLE',0x85B8) +GL_TEXTURE_STORAGE_HINT_APPLE=_C('GL_TEXTURE_STORAGE_HINT_APPLE',0x85BC) +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLvoidpArray) +def glGetTexParameterPointervAPPLE(target,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizei,ctypes.c_void_p) +def glTextureRangeAPPLE(target,length,pointer):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/APPLE/transform_hint.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/APPLE/transform_hint.py new file mode 100644 index 00000000..95582309 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/APPLE/transform_hint.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_APPLE_transform_hint' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_APPLE_transform_hint',error_checker=_errors._error_checker) +GL_TRANSFORM_HINT_APPLE=_C('GL_TRANSFORM_HINT_APPLE',0x85B1) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/APPLE/vertex_array_object.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/APPLE/vertex_array_object.py new file mode 100644 index 00000000..27a1b1f6 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/APPLE/vertex_array_object.py @@ -0,0 +1,26 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_APPLE_vertex_array_object' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_APPLE_vertex_array_object',error_checker=_errors._error_checker) +GL_VERTEX_ARRAY_BINDING_APPLE=_C('GL_VERTEX_ARRAY_BINDING_APPLE',0x85B5) +@_f +@_p.types(None,_cs.GLuint) +def glBindVertexArrayAPPLE(array):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray) +def glDeleteVertexArraysAPPLE(n,arrays):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray) +def glGenVertexArraysAPPLE(n,arrays):pass +@_f +@_p.types(_cs.GLboolean,_cs.GLuint) +def glIsVertexArrayAPPLE(array):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/APPLE/vertex_array_range.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/APPLE/vertex_array_range.py new file mode 100644 index 00000000..eff2f28d --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/APPLE/vertex_array_range.py @@ -0,0 +1,29 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_APPLE_vertex_array_range' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_APPLE_vertex_array_range',error_checker=_errors._error_checker) +GL_STORAGE_CACHED_APPLE=_C('GL_STORAGE_CACHED_APPLE',0x85BE) +GL_STORAGE_CLIENT_APPLE=_C('GL_STORAGE_CLIENT_APPLE',0x85B4) +GL_STORAGE_SHARED_APPLE=_C('GL_STORAGE_SHARED_APPLE',0x85BF) +GL_VERTEX_ARRAY_RANGE_APPLE=_C('GL_VERTEX_ARRAY_RANGE_APPLE',0x851D) +GL_VERTEX_ARRAY_RANGE_LENGTH_APPLE=_C('GL_VERTEX_ARRAY_RANGE_LENGTH_APPLE',0x851E) +GL_VERTEX_ARRAY_RANGE_POINTER_APPLE=_C('GL_VERTEX_ARRAY_RANGE_POINTER_APPLE',0x8521) +GL_VERTEX_ARRAY_STORAGE_HINT_APPLE=_C('GL_VERTEX_ARRAY_STORAGE_HINT_APPLE',0x851F) +@_f +@_p.types(None,_cs.GLsizei,ctypes.c_void_p) +def glFlushVertexArrayRangeAPPLE(length,pointer):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLint) +def glVertexArrayParameteriAPPLE(pname,param):pass +@_f +@_p.types(None,_cs.GLsizei,ctypes.c_void_p) +def glVertexArrayRangeAPPLE(length,pointer):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/APPLE/vertex_program_evaluators.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/APPLE/vertex_program_evaluators.py new file mode 100644 index 00000000..6bb5f7a1 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/APPLE/vertex_program_evaluators.py @@ -0,0 +1,44 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_APPLE_vertex_program_evaluators' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_APPLE_vertex_program_evaluators',error_checker=_errors._error_checker) +GL_VERTEX_ATTRIB_MAP1_APPLE=_C('GL_VERTEX_ATTRIB_MAP1_APPLE',0x8A00) +GL_VERTEX_ATTRIB_MAP1_COEFF_APPLE=_C('GL_VERTEX_ATTRIB_MAP1_COEFF_APPLE',0x8A03) +GL_VERTEX_ATTRIB_MAP1_DOMAIN_APPLE=_C('GL_VERTEX_ATTRIB_MAP1_DOMAIN_APPLE',0x8A05) +GL_VERTEX_ATTRIB_MAP1_ORDER_APPLE=_C('GL_VERTEX_ATTRIB_MAP1_ORDER_APPLE',0x8A04) +GL_VERTEX_ATTRIB_MAP1_SIZE_APPLE=_C('GL_VERTEX_ATTRIB_MAP1_SIZE_APPLE',0x8A02) +GL_VERTEX_ATTRIB_MAP2_APPLE=_C('GL_VERTEX_ATTRIB_MAP2_APPLE',0x8A01) +GL_VERTEX_ATTRIB_MAP2_COEFF_APPLE=_C('GL_VERTEX_ATTRIB_MAP2_COEFF_APPLE',0x8A07) +GL_VERTEX_ATTRIB_MAP2_DOMAIN_APPLE=_C('GL_VERTEX_ATTRIB_MAP2_DOMAIN_APPLE',0x8A09) +GL_VERTEX_ATTRIB_MAP2_ORDER_APPLE=_C('GL_VERTEX_ATTRIB_MAP2_ORDER_APPLE',0x8A08) +GL_VERTEX_ATTRIB_MAP2_SIZE_APPLE=_C('GL_VERTEX_ATTRIB_MAP2_SIZE_APPLE',0x8A06) +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum) +def glDisableVertexAttribAPPLE(index,pname):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum) +def glEnableVertexAttribAPPLE(index,pname):pass +@_f +@_p.types(_cs.GLboolean,_cs.GLuint,_cs.GLenum) +def glIsVertexAttribEnabledAPPLE(index,pname):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLdouble,_cs.GLdouble,_cs.GLint,_cs.GLint,arrays.GLdoubleArray) +def glMapVertexAttrib1dAPPLE(index,size,u1,u2,stride,order,points):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLfloat,_cs.GLfloat,_cs.GLint,_cs.GLint,arrays.GLfloatArray) +def glMapVertexAttrib1fAPPLE(index,size,u1,u2,stride,order,points):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLdouble,_cs.GLdouble,_cs.GLint,_cs.GLint,_cs.GLdouble,_cs.GLdouble,_cs.GLint,_cs.GLint,arrays.GLdoubleArray) +def glMapVertexAttrib2dAPPLE(index,size,u1,u2,ustride,uorder,v1,v2,vstride,vorder,points):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLfloat,_cs.GLfloat,_cs.GLint,_cs.GLint,_cs.GLfloat,_cs.GLfloat,_cs.GLint,_cs.GLint,arrays.GLfloatArray) +def glMapVertexAttrib2fAPPLE(index,size,u1,u2,ustride,uorder,v1,v2,vstride,vorder,points):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/APPLE/ycbcr_422.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/APPLE/ycbcr_422.py new file mode 100644 index 00000000..8faf775d --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/APPLE/ycbcr_422.py @@ -0,0 +1,17 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_APPLE_ycbcr_422' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_APPLE_ycbcr_422',error_checker=_errors._error_checker) +GL_UNSIGNED_SHORT_8_8_APPLE=_C('GL_UNSIGNED_SHORT_8_8_APPLE',0x85BA) +GL_UNSIGNED_SHORT_8_8_REV_APPLE=_C('GL_UNSIGNED_SHORT_8_8_REV_APPLE',0x85BB) +GL_YCBCR_422_APPLE=_C('GL_YCBCR_422_APPLE',0x85B9) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/ES2_compatibility.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/ES2_compatibility.py new file mode 100644 index 00000000..03b93ca4 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/ES2_compatibility.py @@ -0,0 +1,44 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_ES2_compatibility' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_ES2_compatibility',error_checker=_errors._error_checker) +GL_FIXED=_C('GL_FIXED',0x140C) +GL_HIGH_FLOAT=_C('GL_HIGH_FLOAT',0x8DF2) +GL_HIGH_INT=_C('GL_HIGH_INT',0x8DF5) +GL_IMPLEMENTATION_COLOR_READ_FORMAT=_C('GL_IMPLEMENTATION_COLOR_READ_FORMAT',0x8B9B) +GL_IMPLEMENTATION_COLOR_READ_TYPE=_C('GL_IMPLEMENTATION_COLOR_READ_TYPE',0x8B9A) +GL_LOW_FLOAT=_C('GL_LOW_FLOAT',0x8DF0) +GL_LOW_INT=_C('GL_LOW_INT',0x8DF3) +GL_MAX_FRAGMENT_UNIFORM_VECTORS=_C('GL_MAX_FRAGMENT_UNIFORM_VECTORS',0x8DFD) +GL_MAX_VARYING_VECTORS=_C('GL_MAX_VARYING_VECTORS',0x8DFC) +GL_MAX_VERTEX_UNIFORM_VECTORS=_C('GL_MAX_VERTEX_UNIFORM_VECTORS',0x8DFB) +GL_MEDIUM_FLOAT=_C('GL_MEDIUM_FLOAT',0x8DF1) +GL_MEDIUM_INT=_C('GL_MEDIUM_INT',0x8DF4) +GL_NUM_SHADER_BINARY_FORMATS=_C('GL_NUM_SHADER_BINARY_FORMATS',0x8DF9) +GL_RGB565=_C('GL_RGB565',0x8D62) +GL_SHADER_BINARY_FORMATS=_C('GL_SHADER_BINARY_FORMATS',0x8DF8) +GL_SHADER_COMPILER=_C('GL_SHADER_COMPILER',0x8DFA) +@_f +@_p.types(None,_cs.GLfloat) +def glClearDepthf(d):pass +@_f +@_p.types(None,_cs.GLfloat,_cs.GLfloat) +def glDepthRangef(n,f):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLintArray,arrays.GLintArray) +def glGetShaderPrecisionFormat(shadertype,precisiontype,range,precision):pass +@_f +@_p.types(None,) +def glReleaseShaderCompiler():pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray,_cs.GLenum,ctypes.c_void_p,_cs.GLsizei) +def glShaderBinary(count,shaders,binaryformat,binary,length):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/ES3_1_compatibility.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/ES3_1_compatibility.py new file mode 100644 index 00000000..b055041c --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/ES3_1_compatibility.py @@ -0,0 +1,17 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_ES3_1_compatibility' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_ES3_1_compatibility',error_checker=_errors._error_checker) +GL_BACK=_C('GL_BACK',0x0405) +@_f +@_p.types(None,_cs.GLbitfield) +def glMemoryBarrierByRegion(barriers):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/ES3_2_compatibility.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/ES3_2_compatibility.py new file mode 100644 index 00000000..dfa41641 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/ES3_2_compatibility.py @@ -0,0 +1,19 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_ES3_2_compatibility' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_ES3_2_compatibility',error_checker=_errors._error_checker) +GL_MULTISAMPLE_LINE_WIDTH_GRANULARITY_ARB=_C('GL_MULTISAMPLE_LINE_WIDTH_GRANULARITY_ARB',0x9382) +GL_MULTISAMPLE_LINE_WIDTH_RANGE_ARB=_C('GL_MULTISAMPLE_LINE_WIDTH_RANGE_ARB',0x9381) +GL_PRIMITIVE_BOUNDING_BOX_ARB=_C('GL_PRIMITIVE_BOUNDING_BOX_ARB',0x92BE) +@_f +@_p.types(None,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat) +def glPrimitiveBoundingBoxARB(minX,minY,minZ,minW,maxX,maxY,maxZ,maxW):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/ES3_compatibility.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/ES3_compatibility.py new file mode 100644 index 00000000..634d1fc9 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/ES3_compatibility.py @@ -0,0 +1,27 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_ES3_compatibility' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_ES3_compatibility',error_checker=_errors._error_checker) +GL_ANY_SAMPLES_PASSED_CONSERVATIVE=_C('GL_ANY_SAMPLES_PASSED_CONSERVATIVE',0x8D6A) +GL_COMPRESSED_R11_EAC=_C('GL_COMPRESSED_R11_EAC',0x9270) +GL_COMPRESSED_RG11_EAC=_C('GL_COMPRESSED_RG11_EAC',0x9272) +GL_COMPRESSED_RGB8_ETC2=_C('GL_COMPRESSED_RGB8_ETC2',0x9274) +GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2=_C('GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2',0x9276) +GL_COMPRESSED_RGBA8_ETC2_EAC=_C('GL_COMPRESSED_RGBA8_ETC2_EAC',0x9278) +GL_COMPRESSED_SIGNED_R11_EAC=_C('GL_COMPRESSED_SIGNED_R11_EAC',0x9271) +GL_COMPRESSED_SIGNED_RG11_EAC=_C('GL_COMPRESSED_SIGNED_RG11_EAC',0x9273) +GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC=_C('GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC',0x9279) +GL_COMPRESSED_SRGB8_ETC2=_C('GL_COMPRESSED_SRGB8_ETC2',0x9275) +GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2=_C('GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2',0x9277) +GL_MAX_ELEMENT_INDEX=_C('GL_MAX_ELEMENT_INDEX',0x8D6B) +GL_PRIMITIVE_RESTART_FIXED_INDEX=_C('GL_PRIMITIVE_RESTART_FIXED_INDEX',0x8D69) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/ES2_compatibility.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/ES2_compatibility.cpython-312.pyc new file mode 100644 index 00000000..e720a1ad Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/ES2_compatibility.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/ES3_1_compatibility.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/ES3_1_compatibility.cpython-312.pyc new file mode 100644 index 00000000..f8c85fa4 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/ES3_1_compatibility.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/ES3_2_compatibility.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/ES3_2_compatibility.cpython-312.pyc new file mode 100644 index 00000000..7898f940 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/ES3_2_compatibility.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/ES3_compatibility.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/ES3_compatibility.cpython-312.pyc new file mode 100644 index 00000000..b1b46a7f Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/ES3_compatibility.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..5f83445f Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/arrays_of_arrays.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/arrays_of_arrays.cpython-312.pyc new file mode 100644 index 00000000..1dc1eacb Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/arrays_of_arrays.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/base_instance.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/base_instance.cpython-312.pyc new file mode 100644 index 00000000..9f3429a8 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/base_instance.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/bindless_texture.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/bindless_texture.cpython-312.pyc new file mode 100644 index 00000000..a4fde749 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/bindless_texture.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/blend_func_extended.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/blend_func_extended.cpython-312.pyc new file mode 100644 index 00000000..c62a6014 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/blend_func_extended.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/buffer_storage.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/buffer_storage.cpython-312.pyc new file mode 100644 index 00000000..6da8c0db Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/buffer_storage.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/cl_event.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/cl_event.cpython-312.pyc new file mode 100644 index 00000000..97efb1bc Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/cl_event.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/clear_buffer_object.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/clear_buffer_object.cpython-312.pyc new file mode 100644 index 00000000..cfdace7c Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/clear_buffer_object.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/clear_texture.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/clear_texture.cpython-312.pyc new file mode 100644 index 00000000..3e92cc6b Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/clear_texture.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/clip_control.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/clip_control.cpython-312.pyc new file mode 100644 index 00000000..ad363ecc Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/clip_control.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/color_buffer_float.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/color_buffer_float.cpython-312.pyc new file mode 100644 index 00000000..38ff0a48 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/color_buffer_float.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/compatibility.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/compatibility.cpython-312.pyc new file mode 100644 index 00000000..025a6489 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/compatibility.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/compressed_texture_pixel_storage.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/compressed_texture_pixel_storage.cpython-312.pyc new file mode 100644 index 00000000..3a3d9dca Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/compressed_texture_pixel_storage.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/compute_shader.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/compute_shader.cpython-312.pyc new file mode 100644 index 00000000..1d8f1da2 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/compute_shader.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/compute_variable_group_size.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/compute_variable_group_size.cpython-312.pyc new file mode 100644 index 00000000..0173cfc1 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/compute_variable_group_size.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/conditional_render_inverted.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/conditional_render_inverted.cpython-312.pyc new file mode 100644 index 00000000..9094d67c Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/conditional_render_inverted.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/conservative_depth.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/conservative_depth.cpython-312.pyc new file mode 100644 index 00000000..1885657b Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/conservative_depth.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/copy_buffer.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/copy_buffer.cpython-312.pyc new file mode 100644 index 00000000..f05c9775 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/copy_buffer.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/copy_image.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/copy_image.cpython-312.pyc new file mode 100644 index 00000000..a436a667 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/copy_image.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/cull_distance.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/cull_distance.cpython-312.pyc new file mode 100644 index 00000000..cc7b76b8 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/cull_distance.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/debug_output.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/debug_output.cpython-312.pyc new file mode 100644 index 00000000..2fa3492c Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/debug_output.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/depth_buffer_float.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/depth_buffer_float.cpython-312.pyc new file mode 100644 index 00000000..0382c902 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/depth_buffer_float.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/depth_clamp.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/depth_clamp.cpython-312.pyc new file mode 100644 index 00000000..0b330c4b Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/depth_clamp.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/depth_texture.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/depth_texture.cpython-312.pyc new file mode 100644 index 00000000..5db4a334 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/depth_texture.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/derivative_control.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/derivative_control.cpython-312.pyc new file mode 100644 index 00000000..5417b311 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/derivative_control.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/direct_state_access.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/direct_state_access.cpython-312.pyc new file mode 100644 index 00000000..55731723 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/direct_state_access.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/draw_buffers.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/draw_buffers.cpython-312.pyc new file mode 100644 index 00000000..e7c6b4da Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/draw_buffers.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/draw_buffers_blend.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/draw_buffers_blend.cpython-312.pyc new file mode 100644 index 00000000..1a14c641 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/draw_buffers_blend.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/draw_elements_base_vertex.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/draw_elements_base_vertex.cpython-312.pyc new file mode 100644 index 00000000..37de4504 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/draw_elements_base_vertex.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/draw_indirect.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/draw_indirect.cpython-312.pyc new file mode 100644 index 00000000..58dc9f59 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/draw_indirect.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/draw_instanced.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/draw_instanced.cpython-312.pyc new file mode 100644 index 00000000..90f74f02 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/draw_instanced.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/enhanced_layouts.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/enhanced_layouts.cpython-312.pyc new file mode 100644 index 00000000..82dc9347 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/enhanced_layouts.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/explicit_attrib_location.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/explicit_attrib_location.cpython-312.pyc new file mode 100644 index 00000000..e3f43cfe Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/explicit_attrib_location.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/explicit_uniform_location.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/explicit_uniform_location.cpython-312.pyc new file mode 100644 index 00000000..b865cb6f Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/explicit_uniform_location.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/fragment_coord_conventions.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/fragment_coord_conventions.cpython-312.pyc new file mode 100644 index 00000000..880d5904 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/fragment_coord_conventions.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/fragment_layer_viewport.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/fragment_layer_viewport.cpython-312.pyc new file mode 100644 index 00000000..83c42c63 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/fragment_layer_viewport.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/fragment_program.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/fragment_program.cpython-312.pyc new file mode 100644 index 00000000..2062bdd8 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/fragment_program.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/fragment_program_shadow.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/fragment_program_shadow.cpython-312.pyc new file mode 100644 index 00000000..91a7f538 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/fragment_program_shadow.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/fragment_shader.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/fragment_shader.cpython-312.pyc new file mode 100644 index 00000000..63ec0582 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/fragment_shader.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/fragment_shader_interlock.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/fragment_shader_interlock.cpython-312.pyc new file mode 100644 index 00000000..eab50c6c Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/fragment_shader_interlock.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/framebuffer_no_attachments.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/framebuffer_no_attachments.cpython-312.pyc new file mode 100644 index 00000000..7aff7cfc Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/framebuffer_no_attachments.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/framebuffer_object.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/framebuffer_object.cpython-312.pyc new file mode 100644 index 00000000..415f5a1d Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/framebuffer_object.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/framebuffer_sRGB.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/framebuffer_sRGB.cpython-312.pyc new file mode 100644 index 00000000..bb2bec25 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/framebuffer_sRGB.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/geometry_shader4.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/geometry_shader4.cpython-312.pyc new file mode 100644 index 00000000..5d5b5ec5 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/geometry_shader4.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/get_program_binary.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/get_program_binary.cpython-312.pyc new file mode 100644 index 00000000..ff5e2cd0 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/get_program_binary.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/get_texture_sub_image.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/get_texture_sub_image.cpython-312.pyc new file mode 100644 index 00000000..b731da2c Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/get_texture_sub_image.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/gl_spirv.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/gl_spirv.cpython-312.pyc new file mode 100644 index 00000000..3037b36c Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/gl_spirv.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/gpu_shader5.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/gpu_shader5.cpython-312.pyc new file mode 100644 index 00000000..7e5fa87e Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/gpu_shader5.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/gpu_shader_fp64.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/gpu_shader_fp64.cpython-312.pyc new file mode 100644 index 00000000..c55f75dc Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/gpu_shader_fp64.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/gpu_shader_int64.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/gpu_shader_int64.cpython-312.pyc new file mode 100644 index 00000000..ca3641e0 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/gpu_shader_int64.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/half_float_pixel.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/half_float_pixel.cpython-312.pyc new file mode 100644 index 00000000..624dde39 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/half_float_pixel.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/half_float_vertex.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/half_float_vertex.cpython-312.pyc new file mode 100644 index 00000000..4e976a17 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/half_float_vertex.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/imaging.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/imaging.cpython-312.pyc new file mode 100644 index 00000000..75c5baf3 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/imaging.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/indirect_parameters.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/indirect_parameters.cpython-312.pyc new file mode 100644 index 00000000..39954943 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/indirect_parameters.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/instanced_arrays.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/instanced_arrays.cpython-312.pyc new file mode 100644 index 00000000..83cea58d Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/instanced_arrays.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/internalformat_query.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/internalformat_query.cpython-312.pyc new file mode 100644 index 00000000..0e02f816 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/internalformat_query.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/internalformat_query2.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/internalformat_query2.cpython-312.pyc new file mode 100644 index 00000000..9e750fd7 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/internalformat_query2.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/invalidate_subdata.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/invalidate_subdata.cpython-312.pyc new file mode 100644 index 00000000..d990e211 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/invalidate_subdata.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/map_buffer_alignment.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/map_buffer_alignment.cpython-312.pyc new file mode 100644 index 00000000..86675004 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/map_buffer_alignment.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/map_buffer_range.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/map_buffer_range.cpython-312.pyc new file mode 100644 index 00000000..33127dd9 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/map_buffer_range.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/matrix_palette.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/matrix_palette.cpython-312.pyc new file mode 100644 index 00000000..92dee2dd Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/matrix_palette.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/multi_bind.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/multi_bind.cpython-312.pyc new file mode 100644 index 00000000..6dbf89f3 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/multi_bind.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/multi_draw_indirect.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/multi_draw_indirect.cpython-312.pyc new file mode 100644 index 00000000..1215cb26 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/multi_draw_indirect.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/multisample.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/multisample.cpython-312.pyc new file mode 100644 index 00000000..e90daf6d Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/multisample.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/multitexture.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/multitexture.cpython-312.pyc new file mode 100644 index 00000000..ad0211f8 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/multitexture.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/occlusion_query.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/occlusion_query.cpython-312.pyc new file mode 100644 index 00000000..bcd99917 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/occlusion_query.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/occlusion_query2.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/occlusion_query2.cpython-312.pyc new file mode 100644 index 00000000..05125f50 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/occlusion_query2.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/parallel_shader_compile.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/parallel_shader_compile.cpython-312.pyc new file mode 100644 index 00000000..a8f01c75 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/parallel_shader_compile.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/pipeline_statistics_query.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/pipeline_statistics_query.cpython-312.pyc new file mode 100644 index 00000000..37e5d7be Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/pipeline_statistics_query.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/pixel_buffer_object.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/pixel_buffer_object.cpython-312.pyc new file mode 100644 index 00000000..ad82cc28 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/pixel_buffer_object.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/point_parameters.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/point_parameters.cpython-312.pyc new file mode 100644 index 00000000..61074472 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/point_parameters.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/point_sprite.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/point_sprite.cpython-312.pyc new file mode 100644 index 00000000..c7e0ed32 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/point_sprite.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/polygon_offset_clamp.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/polygon_offset_clamp.cpython-312.pyc new file mode 100644 index 00000000..5c79377b Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/polygon_offset_clamp.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/post_depth_coverage.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/post_depth_coverage.cpython-312.pyc new file mode 100644 index 00000000..f9de1daf Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/post_depth_coverage.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/program_interface_query.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/program_interface_query.cpython-312.pyc new file mode 100644 index 00000000..c8025a11 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/program_interface_query.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/provoking_vertex.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/provoking_vertex.cpython-312.pyc new file mode 100644 index 00000000..ead0595d Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/provoking_vertex.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/query_buffer_object.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/query_buffer_object.cpython-312.pyc new file mode 100644 index 00000000..418c3f4b Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/query_buffer_object.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/robust_buffer_access_behavior.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/robust_buffer_access_behavior.cpython-312.pyc new file mode 100644 index 00000000..0ae595e7 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/robust_buffer_access_behavior.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/robustness.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/robustness.cpython-312.pyc new file mode 100644 index 00000000..b9582c33 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/robustness.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/robustness_isolation.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/robustness_isolation.cpython-312.pyc new file mode 100644 index 00000000..1c18d5c4 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/robustness_isolation.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/sample_locations.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/sample_locations.cpython-312.pyc new file mode 100644 index 00000000..15306a55 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/sample_locations.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/sample_shading.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/sample_shading.cpython-312.pyc new file mode 100644 index 00000000..4bcd35a3 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/sample_shading.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/sampler_objects.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/sampler_objects.cpython-312.pyc new file mode 100644 index 00000000..545f6c13 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/sampler_objects.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/seamless_cube_map.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/seamless_cube_map.cpython-312.pyc new file mode 100644 index 00000000..781be7df Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/seamless_cube_map.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/seamless_cubemap_per_texture.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/seamless_cubemap_per_texture.cpython-312.pyc new file mode 100644 index 00000000..9abc4f5f Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/seamless_cubemap_per_texture.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/separate_shader_objects.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/separate_shader_objects.cpython-312.pyc new file mode 100644 index 00000000..1bac40a2 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/separate_shader_objects.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/shader_atomic_counter_ops.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/shader_atomic_counter_ops.cpython-312.pyc new file mode 100644 index 00000000..fce674c8 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/shader_atomic_counter_ops.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/shader_atomic_counters.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/shader_atomic_counters.cpython-312.pyc new file mode 100644 index 00000000..b9911294 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/shader_atomic_counters.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/shader_ballot.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/shader_ballot.cpython-312.pyc new file mode 100644 index 00000000..e89ed3f2 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/shader_ballot.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/shader_bit_encoding.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/shader_bit_encoding.cpython-312.pyc new file mode 100644 index 00000000..39415071 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/shader_bit_encoding.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/shader_clock.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/shader_clock.cpython-312.pyc new file mode 100644 index 00000000..2c7af12e Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/shader_clock.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/shader_draw_parameters.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/shader_draw_parameters.cpython-312.pyc new file mode 100644 index 00000000..523a1f0a Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/shader_draw_parameters.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/shader_group_vote.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/shader_group_vote.cpython-312.pyc new file mode 100644 index 00000000..7a67714d Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/shader_group_vote.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/shader_image_load_store.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/shader_image_load_store.cpython-312.pyc new file mode 100644 index 00000000..32353498 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/shader_image_load_store.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/shader_image_size.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/shader_image_size.cpython-312.pyc new file mode 100644 index 00000000..24771179 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/shader_image_size.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/shader_objects.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/shader_objects.cpython-312.pyc new file mode 100644 index 00000000..fd3aa79b Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/shader_objects.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/shader_precision.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/shader_precision.cpython-312.pyc new file mode 100644 index 00000000..8e65f6b0 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/shader_precision.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/shader_stencil_export.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/shader_stencil_export.cpython-312.pyc new file mode 100644 index 00000000..4ee4dcbd Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/shader_stencil_export.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/shader_storage_buffer_object.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/shader_storage_buffer_object.cpython-312.pyc new file mode 100644 index 00000000..753c47d8 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/shader_storage_buffer_object.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/shader_subroutine.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/shader_subroutine.cpython-312.pyc new file mode 100644 index 00000000..b085795c Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/shader_subroutine.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/shader_texture_image_samples.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/shader_texture_image_samples.cpython-312.pyc new file mode 100644 index 00000000..ee35f2da Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/shader_texture_image_samples.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/shader_texture_lod.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/shader_texture_lod.cpython-312.pyc new file mode 100644 index 00000000..019c7cf5 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/shader_texture_lod.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/shader_viewport_layer_array.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/shader_viewport_layer_array.cpython-312.pyc new file mode 100644 index 00000000..b785606b Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/shader_viewport_layer_array.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/shading_language_100.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/shading_language_100.cpython-312.pyc new file mode 100644 index 00000000..e82ac731 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/shading_language_100.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/shading_language_420pack.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/shading_language_420pack.cpython-312.pyc new file mode 100644 index 00000000..03dc0301 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/shading_language_420pack.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/shading_language_include.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/shading_language_include.cpython-312.pyc new file mode 100644 index 00000000..40a940bd Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/shading_language_include.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/shading_language_packing.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/shading_language_packing.cpython-312.pyc new file mode 100644 index 00000000..c39ab857 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/shading_language_packing.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/shadow.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/shadow.cpython-312.pyc new file mode 100644 index 00000000..10755ad1 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/shadow.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/shadow_ambient.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/shadow_ambient.cpython-312.pyc new file mode 100644 index 00000000..def363b2 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/shadow_ambient.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/sparse_buffer.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/sparse_buffer.cpython-312.pyc new file mode 100644 index 00000000..d828f5cb Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/sparse_buffer.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/sparse_texture.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/sparse_texture.cpython-312.pyc new file mode 100644 index 00000000..6caf44c1 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/sparse_texture.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/sparse_texture2.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/sparse_texture2.cpython-312.pyc new file mode 100644 index 00000000..8cc7e749 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/sparse_texture2.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/sparse_texture_clamp.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/sparse_texture_clamp.cpython-312.pyc new file mode 100644 index 00000000..b38ab210 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/sparse_texture_clamp.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/spirv_extensions.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/spirv_extensions.cpython-312.pyc new file mode 100644 index 00000000..87b06570 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/spirv_extensions.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/stencil_texturing.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/stencil_texturing.cpython-312.pyc new file mode 100644 index 00000000..3c3c867d Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/stencil_texturing.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/sync.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/sync.cpython-312.pyc new file mode 100644 index 00000000..e0c20dd0 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/sync.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/tessellation_shader.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/tessellation_shader.cpython-312.pyc new file mode 100644 index 00000000..363428d7 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/tessellation_shader.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/texture_barrier.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/texture_barrier.cpython-312.pyc new file mode 100644 index 00000000..82567607 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/texture_barrier.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/texture_border_clamp.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/texture_border_clamp.cpython-312.pyc new file mode 100644 index 00000000..bc14d5fe Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/texture_border_clamp.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/texture_buffer_object.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/texture_buffer_object.cpython-312.pyc new file mode 100644 index 00000000..c4dc3949 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/texture_buffer_object.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/texture_buffer_object_rgb32.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/texture_buffer_object_rgb32.cpython-312.pyc new file mode 100644 index 00000000..27312861 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/texture_buffer_object_rgb32.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/texture_buffer_range.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/texture_buffer_range.cpython-312.pyc new file mode 100644 index 00000000..6002e971 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/texture_buffer_range.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/texture_compression.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/texture_compression.cpython-312.pyc new file mode 100644 index 00000000..7fbc2754 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/texture_compression.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/texture_compression_bptc.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/texture_compression_bptc.cpython-312.pyc new file mode 100644 index 00000000..4abfaaa6 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/texture_compression_bptc.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/texture_compression_rgtc.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/texture_compression_rgtc.cpython-312.pyc new file mode 100644 index 00000000..3f664409 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/texture_compression_rgtc.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/texture_cube_map.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/texture_cube_map.cpython-312.pyc new file mode 100644 index 00000000..a9583776 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/texture_cube_map.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/texture_cube_map_array.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/texture_cube_map_array.cpython-312.pyc new file mode 100644 index 00000000..39de66be Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/texture_cube_map_array.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/texture_env_add.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/texture_env_add.cpython-312.pyc new file mode 100644 index 00000000..687423fe Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/texture_env_add.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/texture_env_combine.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/texture_env_combine.cpython-312.pyc new file mode 100644 index 00000000..b23efb2d Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/texture_env_combine.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/texture_env_crossbar.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/texture_env_crossbar.cpython-312.pyc new file mode 100644 index 00000000..bf8afe0b Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/texture_env_crossbar.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/texture_env_dot3.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/texture_env_dot3.cpython-312.pyc new file mode 100644 index 00000000..e4a3fdfc Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/texture_env_dot3.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/texture_filter_anisotropic.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/texture_filter_anisotropic.cpython-312.pyc new file mode 100644 index 00000000..238a154b Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/texture_filter_anisotropic.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/texture_filter_minmax.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/texture_filter_minmax.cpython-312.pyc new file mode 100644 index 00000000..1e6aa040 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/texture_filter_minmax.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/texture_float.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/texture_float.cpython-312.pyc new file mode 100644 index 00000000..9c344812 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/texture_float.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/texture_gather.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/texture_gather.cpython-312.pyc new file mode 100644 index 00000000..095c1048 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/texture_gather.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/texture_mirror_clamp_to_edge.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/texture_mirror_clamp_to_edge.cpython-312.pyc new file mode 100644 index 00000000..7456b94f Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/texture_mirror_clamp_to_edge.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/texture_mirrored_repeat.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/texture_mirrored_repeat.cpython-312.pyc new file mode 100644 index 00000000..25ecbb71 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/texture_mirrored_repeat.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/texture_multisample.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/texture_multisample.cpython-312.pyc new file mode 100644 index 00000000..6d722eda Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/texture_multisample.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/texture_non_power_of_two.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/texture_non_power_of_two.cpython-312.pyc new file mode 100644 index 00000000..d357e81e Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/texture_non_power_of_two.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/texture_query_levels.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/texture_query_levels.cpython-312.pyc new file mode 100644 index 00000000..65eb9388 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/texture_query_levels.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/texture_query_lod.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/texture_query_lod.cpython-312.pyc new file mode 100644 index 00000000..6c490187 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/texture_query_lod.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/texture_rectangle.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/texture_rectangle.cpython-312.pyc new file mode 100644 index 00000000..a1dedf49 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/texture_rectangle.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/texture_rg.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/texture_rg.cpython-312.pyc new file mode 100644 index 00000000..550684fc Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/texture_rg.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/texture_rgb10_a2ui.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/texture_rgb10_a2ui.cpython-312.pyc new file mode 100644 index 00000000..0c09203b Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/texture_rgb10_a2ui.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/texture_stencil8.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/texture_stencil8.cpython-312.pyc new file mode 100644 index 00000000..95d68e23 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/texture_stencil8.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/texture_storage.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/texture_storage.cpython-312.pyc new file mode 100644 index 00000000..52de5703 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/texture_storage.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/texture_storage_multisample.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/texture_storage_multisample.cpython-312.pyc new file mode 100644 index 00000000..3fdd19b5 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/texture_storage_multisample.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/texture_swizzle.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/texture_swizzle.cpython-312.pyc new file mode 100644 index 00000000..73c8f419 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/texture_swizzle.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/texture_view.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/texture_view.cpython-312.pyc new file mode 100644 index 00000000..90751504 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/texture_view.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/timer_query.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/timer_query.cpython-312.pyc new file mode 100644 index 00000000..987b2729 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/timer_query.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/transform_feedback2.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/transform_feedback2.cpython-312.pyc new file mode 100644 index 00000000..96e1fb2c Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/transform_feedback2.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/transform_feedback3.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/transform_feedback3.cpython-312.pyc new file mode 100644 index 00000000..02759432 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/transform_feedback3.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/transform_feedback_instanced.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/transform_feedback_instanced.cpython-312.pyc new file mode 100644 index 00000000..6981bcaf Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/transform_feedback_instanced.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/transform_feedback_overflow_query.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/transform_feedback_overflow_query.cpython-312.pyc new file mode 100644 index 00000000..e0299068 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/transform_feedback_overflow_query.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/transpose_matrix.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/transpose_matrix.cpython-312.pyc new file mode 100644 index 00000000..e3724707 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/transpose_matrix.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/uniform_buffer_object.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/uniform_buffer_object.cpython-312.pyc new file mode 100644 index 00000000..e9b0e7ff Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/uniform_buffer_object.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/vertex_array_bgra.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/vertex_array_bgra.cpython-312.pyc new file mode 100644 index 00000000..16fb4bbd Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/vertex_array_bgra.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/vertex_array_object.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/vertex_array_object.cpython-312.pyc new file mode 100644 index 00000000..a1320551 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/vertex_array_object.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/vertex_attrib_64bit.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/vertex_attrib_64bit.cpython-312.pyc new file mode 100644 index 00000000..4831bffd Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/vertex_attrib_64bit.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/vertex_attrib_binding.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/vertex_attrib_binding.cpython-312.pyc new file mode 100644 index 00000000..1e909f07 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/vertex_attrib_binding.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/vertex_blend.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/vertex_blend.cpython-312.pyc new file mode 100644 index 00000000..04da6a84 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/vertex_blend.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/vertex_buffer_object.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/vertex_buffer_object.cpython-312.pyc new file mode 100644 index 00000000..d8ee343c Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/vertex_buffer_object.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/vertex_program.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/vertex_program.cpython-312.pyc new file mode 100644 index 00000000..00346bad Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/vertex_program.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/vertex_shader.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/vertex_shader.cpython-312.pyc new file mode 100644 index 00000000..11ab9a15 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/vertex_shader.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/vertex_type_10f_11f_11f_rev.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/vertex_type_10f_11f_11f_rev.cpython-312.pyc new file mode 100644 index 00000000..80b65bd6 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/vertex_type_10f_11f_11f_rev.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/vertex_type_2_10_10_10_rev.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/vertex_type_2_10_10_10_rev.cpython-312.pyc new file mode 100644 index 00000000..b21aecf8 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/vertex_type_2_10_10_10_rev.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/viewport_array.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/viewport_array.cpython-312.pyc new file mode 100644 index 00000000..7ab9c607 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/viewport_array.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/window_pos.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/window_pos.cpython-312.pyc new file mode 100644 index 00000000..9484f551 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/__pycache__/window_pos.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/arrays_of_arrays.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/arrays_of_arrays.py new file mode 100644 index 00000000..1a602872 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/arrays_of_arrays.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_arrays_of_arrays' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_arrays_of_arrays',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/base_instance.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/base_instance.py new file mode 100644 index 00000000..0c571c8f --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/base_instance.py @@ -0,0 +1,23 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_base_instance' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_base_instance',error_checker=_errors._error_checker) + +@_f +@_p.types(None,_cs.GLenum,_cs.GLint,_cs.GLsizei,_cs.GLsizei,_cs.GLuint) +def glDrawArraysInstancedBaseInstance(mode,first,count,instancecount,baseinstance):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizei,_cs.GLenum,ctypes.c_void_p,_cs.GLsizei,_cs.GLuint) +def glDrawElementsInstancedBaseInstance(mode,count,type,indices,instancecount,baseinstance):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizei,_cs.GLenum,ctypes.c_void_p,_cs.GLsizei,_cs.GLint,_cs.GLuint) +def glDrawElementsInstancedBaseVertexBaseInstance(mode,count,type,indices,instancecount,basevertex,baseinstance):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/bindless_texture.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/bindless_texture.py new file mode 100644 index 00000000..d2bc6e3b --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/bindless_texture.py @@ -0,0 +1,62 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_bindless_texture' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_bindless_texture',error_checker=_errors._error_checker) +GL_UNSIGNED_INT64_ARB=_C('GL_UNSIGNED_INT64_ARB',0x140F) +@_f +@_p.types(_cs.GLuint64,_cs.GLuint,_cs.GLint,_cs.GLboolean,_cs.GLint,_cs.GLenum) +def glGetImageHandleARB(texture,level,layered,layer,format):pass +@_f +@_p.types(_cs.GLuint64,_cs.GLuint) +def glGetTextureHandleARB(texture):pass +@_f +@_p.types(_cs.GLuint64,_cs.GLuint,_cs.GLuint) +def glGetTextureSamplerHandleARB(texture,sampler):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLuint64Array) +def glGetVertexAttribLui64vARB(index,pname,params):pass +@_f +@_p.types(_cs.GLboolean,_cs.GLuint64) +def glIsImageHandleResidentARB(handle):pass +@_f +@_p.types(_cs.GLboolean,_cs.GLuint64) +def glIsTextureHandleResidentARB(handle):pass +@_f +@_p.types(None,_cs.GLuint64) +def glMakeImageHandleNonResidentARB(handle):pass +@_f +@_p.types(None,_cs.GLuint64,_cs.GLenum) +def glMakeImageHandleResidentARB(handle,access):pass +@_f +@_p.types(None,_cs.GLuint64) +def glMakeTextureHandleNonResidentARB(handle):pass +@_f +@_p.types(None,_cs.GLuint64) +def glMakeTextureHandleResidentARB(handle):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLuint64) +def glProgramUniformHandleui64ARB(program,location,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLuint64Array) +def glProgramUniformHandleui64vARB(program,location,count,values):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLuint64) +def glUniformHandleui64ARB(location,value):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLsizei,arrays.GLuint64Array) +def glUniformHandleui64vARB(location,count,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint64EXT) +def glVertexAttribL1ui64ARB(index,x):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLuint64Array) +def glVertexAttribL1ui64vARB(index,v):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/blend_func_extended.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/blend_func_extended.py new file mode 100644 index 00000000..d41478a8 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/blend_func_extended.py @@ -0,0 +1,24 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_blend_func_extended' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_blend_func_extended',error_checker=_errors._error_checker) +GL_MAX_DUAL_SOURCE_DRAW_BUFFERS=_C('GL_MAX_DUAL_SOURCE_DRAW_BUFFERS',0x88FC) +GL_ONE_MINUS_SRC1_ALPHA=_C('GL_ONE_MINUS_SRC1_ALPHA',0x88FB) +GL_ONE_MINUS_SRC1_COLOR=_C('GL_ONE_MINUS_SRC1_COLOR',0x88FA) +GL_SRC1_ALPHA=_C('GL_SRC1_ALPHA',0x8589) +GL_SRC1_COLOR=_C('GL_SRC1_COLOR',0x88F9) +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLuint,arrays.GLcharArray) +def glBindFragDataLocationIndexed(program,colorNumber,index,name):pass +@_f +@_p.types(_cs.GLint,_cs.GLuint,arrays.GLcharArray) +def glGetFragDataIndex(program,name):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/buffer_storage.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/buffer_storage.py new file mode 100644 index 00000000..027bcd1c --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/buffer_storage.py @@ -0,0 +1,25 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_buffer_storage' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_buffer_storage',error_checker=_errors._error_checker) +GL_BUFFER_IMMUTABLE_STORAGE=_C('GL_BUFFER_IMMUTABLE_STORAGE',0x821F) +GL_BUFFER_STORAGE_FLAGS=_C('GL_BUFFER_STORAGE_FLAGS',0x8220) +GL_CLIENT_MAPPED_BUFFER_BARRIER_BIT=_C('GL_CLIENT_MAPPED_BUFFER_BARRIER_BIT',0x00004000) +GL_CLIENT_STORAGE_BIT=_C('GL_CLIENT_STORAGE_BIT',0x0200) +GL_DYNAMIC_STORAGE_BIT=_C('GL_DYNAMIC_STORAGE_BIT',0x0100) +GL_MAP_COHERENT_BIT=_C('GL_MAP_COHERENT_BIT',0x0080) +GL_MAP_PERSISTENT_BIT=_C('GL_MAP_PERSISTENT_BIT',0x0040) +GL_MAP_READ_BIT=_C('GL_MAP_READ_BIT',0x0001) +GL_MAP_WRITE_BIT=_C('GL_MAP_WRITE_BIT',0x0002) +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizeiptr,ctypes.c_void_p,_cs.GLbitfield) +def glBufferStorage(target,size,data,flags):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/cl_event.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/cl_event.py new file mode 100644 index 00000000..c1cf4eb2 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/cl_event.py @@ -0,0 +1,18 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_cl_event' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_cl_event',error_checker=_errors._error_checker) +GL_SYNC_CL_EVENT_ARB=_C('GL_SYNC_CL_EVENT_ARB',0x8240) +GL_SYNC_CL_EVENT_COMPLETE_ARB=_C('GL_SYNC_CL_EVENT_COMPLETE_ARB',0x8241) +@_f +@_p.types(_cs.GLsync,ctypes.POINTER(_cs._cl_context),ctypes.POINTER(_cs._cl_event),_cs.GLbitfield) +def glCreateSyncFromCLeventARB(context,event,flags):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/clear_buffer_object.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/clear_buffer_object.py new file mode 100644 index 00000000..c1ecfa9f --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/clear_buffer_object.py @@ -0,0 +1,20 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_clear_buffer_object' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_clear_buffer_object',error_checker=_errors._error_checker) + +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLenum,_cs.GLenum,ctypes.c_void_p) +def glClearBufferData(target,internalformat,format,type,data):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLintptr,_cs.GLsizeiptr,_cs.GLenum,_cs.GLenum,ctypes.c_void_p) +def glClearBufferSubData(target,internalformat,offset,size,format,type,data):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/clear_texture.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/clear_texture.py new file mode 100644 index 00000000..6f0070dd --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/clear_texture.py @@ -0,0 +1,20 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_clear_texture' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_clear_texture',error_checker=_errors._error_checker) +GL_CLEAR_TEXTURE=_C('GL_CLEAR_TEXTURE',0x9365) +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLenum,_cs.GLenum,ctypes.c_void_p) +def glClearTexImage(texture,level,format,type,data):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLsizei,_cs.GLsizei,_cs.GLenum,_cs.GLenum,ctypes.c_void_p) +def glClearTexSubImage(texture,level,xoffset,yoffset,zoffset,width,height,depth,format,type,data):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/clip_control.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/clip_control.py new file mode 100644 index 00000000..e6dbfaf9 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/clip_control.py @@ -0,0 +1,22 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_clip_control' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_clip_control',error_checker=_errors._error_checker) +GL_CLIP_DEPTH_MODE=_C('GL_CLIP_DEPTH_MODE',0x935D) +GL_CLIP_ORIGIN=_C('GL_CLIP_ORIGIN',0x935C) +GL_LOWER_LEFT=_C('GL_LOWER_LEFT',0x8CA1) +GL_NEGATIVE_ONE_TO_ONE=_C('GL_NEGATIVE_ONE_TO_ONE',0x935E) +GL_UPPER_LEFT=_C('GL_UPPER_LEFT',0x8CA2) +GL_ZERO_TO_ONE=_C('GL_ZERO_TO_ONE',0x935F) +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum) +def glClipControl(origin,depth):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/color_buffer_float.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/color_buffer_float.py new file mode 100644 index 00000000..d2cb3d16 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/color_buffer_float.py @@ -0,0 +1,21 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_color_buffer_float' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_color_buffer_float',error_checker=_errors._error_checker) +GL_CLAMP_FRAGMENT_COLOR_ARB=_C('GL_CLAMP_FRAGMENT_COLOR_ARB',0x891B) +GL_CLAMP_READ_COLOR_ARB=_C('GL_CLAMP_READ_COLOR_ARB',0x891C) +GL_CLAMP_VERTEX_COLOR_ARB=_C('GL_CLAMP_VERTEX_COLOR_ARB',0x891A) +GL_FIXED_ONLY_ARB=_C('GL_FIXED_ONLY_ARB',0x891D) +GL_RGBA_FLOAT_MODE_ARB=_C('GL_RGBA_FLOAT_MODE_ARB',0x8820) +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum) +def glClampColorARB(target,clamp):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/compatibility.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/compatibility.py new file mode 100644 index 00000000..b344ce50 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/compatibility.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_compatibility' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_compatibility',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/compressed_texture_pixel_storage.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/compressed_texture_pixel_storage.py new file mode 100644 index 00000000..4ae51e41 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/compressed_texture_pixel_storage.py @@ -0,0 +1,22 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_compressed_texture_pixel_storage' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_compressed_texture_pixel_storage',error_checker=_errors._error_checker) +GL_PACK_COMPRESSED_BLOCK_DEPTH=_C('GL_PACK_COMPRESSED_BLOCK_DEPTH',0x912D) +GL_PACK_COMPRESSED_BLOCK_HEIGHT=_C('GL_PACK_COMPRESSED_BLOCK_HEIGHT',0x912C) +GL_PACK_COMPRESSED_BLOCK_SIZE=_C('GL_PACK_COMPRESSED_BLOCK_SIZE',0x912E) +GL_PACK_COMPRESSED_BLOCK_WIDTH=_C('GL_PACK_COMPRESSED_BLOCK_WIDTH',0x912B) +GL_UNPACK_COMPRESSED_BLOCK_DEPTH=_C('GL_UNPACK_COMPRESSED_BLOCK_DEPTH',0x9129) +GL_UNPACK_COMPRESSED_BLOCK_HEIGHT=_C('GL_UNPACK_COMPRESSED_BLOCK_HEIGHT',0x9128) +GL_UNPACK_COMPRESSED_BLOCK_SIZE=_C('GL_UNPACK_COMPRESSED_BLOCK_SIZE',0x912A) +GL_UNPACK_COMPRESSED_BLOCK_WIDTH=_C('GL_UNPACK_COMPRESSED_BLOCK_WIDTH',0x9127) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/compute_shader.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/compute_shader.py new file mode 100644 index 00000000..37e7a106 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/compute_shader.py @@ -0,0 +1,37 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_compute_shader' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_compute_shader',error_checker=_errors._error_checker) +GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_COMPUTE_SHADER=_C('GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_COMPUTE_SHADER',0x90ED) +GL_COMPUTE_SHADER=_C('GL_COMPUTE_SHADER',0x91B9) +GL_COMPUTE_SHADER_BIT=_C('GL_COMPUTE_SHADER_BIT',0x00000020) +GL_COMPUTE_WORK_GROUP_SIZE=_C('GL_COMPUTE_WORK_GROUP_SIZE',0x8267) +GL_DISPATCH_INDIRECT_BUFFER=_C('GL_DISPATCH_INDIRECT_BUFFER',0x90EE) +GL_DISPATCH_INDIRECT_BUFFER_BINDING=_C('GL_DISPATCH_INDIRECT_BUFFER_BINDING',0x90EF) +GL_MAX_COMBINED_COMPUTE_UNIFORM_COMPONENTS=_C('GL_MAX_COMBINED_COMPUTE_UNIFORM_COMPONENTS',0x8266) +GL_MAX_COMPUTE_ATOMIC_COUNTERS=_C('GL_MAX_COMPUTE_ATOMIC_COUNTERS',0x8265) +GL_MAX_COMPUTE_ATOMIC_COUNTER_BUFFERS=_C('GL_MAX_COMPUTE_ATOMIC_COUNTER_BUFFERS',0x8264) +GL_MAX_COMPUTE_IMAGE_UNIFORMS=_C('GL_MAX_COMPUTE_IMAGE_UNIFORMS',0x91BD) +GL_MAX_COMPUTE_SHARED_MEMORY_SIZE=_C('GL_MAX_COMPUTE_SHARED_MEMORY_SIZE',0x8262) +GL_MAX_COMPUTE_TEXTURE_IMAGE_UNITS=_C('GL_MAX_COMPUTE_TEXTURE_IMAGE_UNITS',0x91BC) +GL_MAX_COMPUTE_UNIFORM_BLOCKS=_C('GL_MAX_COMPUTE_UNIFORM_BLOCKS',0x91BB) +GL_MAX_COMPUTE_UNIFORM_COMPONENTS=_C('GL_MAX_COMPUTE_UNIFORM_COMPONENTS',0x8263) +GL_MAX_COMPUTE_WORK_GROUP_COUNT=_C('GL_MAX_COMPUTE_WORK_GROUP_COUNT',0x91BE) +GL_MAX_COMPUTE_WORK_GROUP_INVOCATIONS=_C('GL_MAX_COMPUTE_WORK_GROUP_INVOCATIONS',0x90EB) +GL_MAX_COMPUTE_WORK_GROUP_SIZE=_C('GL_MAX_COMPUTE_WORK_GROUP_SIZE',0x91BF) +GL_UNIFORM_BLOCK_REFERENCED_BY_COMPUTE_SHADER=_C('GL_UNIFORM_BLOCK_REFERENCED_BY_COMPUTE_SHADER',0x90EC) +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLuint) +def glDispatchCompute(num_groups_x,num_groups_y,num_groups_z):pass +@_f +@_p.types(None,_cs.GLintptr) +def glDispatchComputeIndirect(indirect):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/compute_variable_group_size.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/compute_variable_group_size.py new file mode 100644 index 00000000..74c45845 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/compute_variable_group_size.py @@ -0,0 +1,20 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_compute_variable_group_size' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_compute_variable_group_size',error_checker=_errors._error_checker) +GL_MAX_COMPUTE_FIXED_GROUP_INVOCATIONS_ARB=_C('GL_MAX_COMPUTE_FIXED_GROUP_INVOCATIONS_ARB',0x90EB) +GL_MAX_COMPUTE_FIXED_GROUP_SIZE_ARB=_C('GL_MAX_COMPUTE_FIXED_GROUP_SIZE_ARB',0x91BF) +GL_MAX_COMPUTE_VARIABLE_GROUP_INVOCATIONS_ARB=_C('GL_MAX_COMPUTE_VARIABLE_GROUP_INVOCATIONS_ARB',0x9344) +GL_MAX_COMPUTE_VARIABLE_GROUP_SIZE_ARB=_C('GL_MAX_COMPUTE_VARIABLE_GROUP_SIZE_ARB',0x9345) +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLuint,_cs.GLuint,_cs.GLuint,_cs.GLuint) +def glDispatchComputeGroupSizeARB(num_groups_x,num_groups_y,num_groups_z,group_size_x,group_size_y,group_size_z):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/conditional_render_inverted.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/conditional_render_inverted.py new file mode 100644 index 00000000..6bd8a22b --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/conditional_render_inverted.py @@ -0,0 +1,18 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_conditional_render_inverted' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_conditional_render_inverted',error_checker=_errors._error_checker) +GL_QUERY_BY_REGION_NO_WAIT_INVERTED=_C('GL_QUERY_BY_REGION_NO_WAIT_INVERTED',0x8E1A) +GL_QUERY_BY_REGION_WAIT_INVERTED=_C('GL_QUERY_BY_REGION_WAIT_INVERTED',0x8E19) +GL_QUERY_NO_WAIT_INVERTED=_C('GL_QUERY_NO_WAIT_INVERTED',0x8E18) +GL_QUERY_WAIT_INVERTED=_C('GL_QUERY_WAIT_INVERTED',0x8E17) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/conservative_depth.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/conservative_depth.py new file mode 100644 index 00000000..1c0939a3 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/conservative_depth.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_conservative_depth' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_conservative_depth',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/copy_buffer.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/copy_buffer.py new file mode 100644 index 00000000..0d145565 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/copy_buffer.py @@ -0,0 +1,18 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_copy_buffer' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_copy_buffer',error_checker=_errors._error_checker) +GL_COPY_READ_BUFFER=_C('GL_COPY_READ_BUFFER',0x8F36) +GL_COPY_WRITE_BUFFER=_C('GL_COPY_WRITE_BUFFER',0x8F37) +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLintptr,_cs.GLintptr,_cs.GLsizeiptr) +def glCopyBufferSubData(readTarget,writeTarget,readOffset,writeOffset,size):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/copy_image.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/copy_image.py new file mode 100644 index 00000000..5b02d773 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/copy_image.py @@ -0,0 +1,17 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_copy_image' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_copy_image',error_checker=_errors._error_checker) + +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLuint,_cs.GLenum,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLsizei,_cs.GLsizei) +def glCopyImageSubData(srcName,srcTarget,srcLevel,srcX,srcY,srcZ,dstName,dstTarget,dstLevel,dstX,dstY,dstZ,srcWidth,srcHeight,srcDepth):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/cull_distance.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/cull_distance.py new file mode 100644 index 00000000..0019f4c6 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/cull_distance.py @@ -0,0 +1,16 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_cull_distance' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_cull_distance',error_checker=_errors._error_checker) +GL_MAX_COMBINED_CLIP_AND_CULL_DISTANCES=_C('GL_MAX_COMBINED_CLIP_AND_CULL_DISTANCES',0x82FA) +GL_MAX_CULL_DISTANCES=_C('GL_MAX_CULL_DISTANCES',0x82F9) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/debug_output.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/debug_output.py new file mode 100644 index 00000000..b636a37b --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/debug_output.py @@ -0,0 +1,47 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_debug_output' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_debug_output',error_checker=_errors._error_checker) +GL_DEBUG_CALLBACK_FUNCTION_ARB=_C('GL_DEBUG_CALLBACK_FUNCTION_ARB',0x8244) +GL_DEBUG_CALLBACK_USER_PARAM_ARB=_C('GL_DEBUG_CALLBACK_USER_PARAM_ARB',0x8245) +GL_DEBUG_LOGGED_MESSAGES_ARB=_C('GL_DEBUG_LOGGED_MESSAGES_ARB',0x9145) +GL_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH_ARB=_C('GL_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH_ARB',0x8243) +GL_DEBUG_OUTPUT_SYNCHRONOUS_ARB=_C('GL_DEBUG_OUTPUT_SYNCHRONOUS_ARB',0x8242) +GL_DEBUG_SEVERITY_HIGH_ARB=_C('GL_DEBUG_SEVERITY_HIGH_ARB',0x9146) +GL_DEBUG_SEVERITY_LOW_ARB=_C('GL_DEBUG_SEVERITY_LOW_ARB',0x9148) +GL_DEBUG_SEVERITY_MEDIUM_ARB=_C('GL_DEBUG_SEVERITY_MEDIUM_ARB',0x9147) +GL_DEBUG_SOURCE_API_ARB=_C('GL_DEBUG_SOURCE_API_ARB',0x8246) +GL_DEBUG_SOURCE_APPLICATION_ARB=_C('GL_DEBUG_SOURCE_APPLICATION_ARB',0x824A) +GL_DEBUG_SOURCE_OTHER_ARB=_C('GL_DEBUG_SOURCE_OTHER_ARB',0x824B) +GL_DEBUG_SOURCE_SHADER_COMPILER_ARB=_C('GL_DEBUG_SOURCE_SHADER_COMPILER_ARB',0x8248) +GL_DEBUG_SOURCE_THIRD_PARTY_ARB=_C('GL_DEBUG_SOURCE_THIRD_PARTY_ARB',0x8249) +GL_DEBUG_SOURCE_WINDOW_SYSTEM_ARB=_C('GL_DEBUG_SOURCE_WINDOW_SYSTEM_ARB',0x8247) +GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR_ARB=_C('GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR_ARB',0x824D) +GL_DEBUG_TYPE_ERROR_ARB=_C('GL_DEBUG_TYPE_ERROR_ARB',0x824C) +GL_DEBUG_TYPE_OTHER_ARB=_C('GL_DEBUG_TYPE_OTHER_ARB',0x8251) +GL_DEBUG_TYPE_PERFORMANCE_ARB=_C('GL_DEBUG_TYPE_PERFORMANCE_ARB',0x8250) +GL_DEBUG_TYPE_PORTABILITY_ARB=_C('GL_DEBUG_TYPE_PORTABILITY_ARB',0x824F) +GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR_ARB=_C('GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR_ARB',0x824E) +GL_MAX_DEBUG_LOGGED_MESSAGES_ARB=_C('GL_MAX_DEBUG_LOGGED_MESSAGES_ARB',0x9144) +GL_MAX_DEBUG_MESSAGE_LENGTH_ARB=_C('GL_MAX_DEBUG_MESSAGE_LENGTH_ARB',0x9143) +@_f +@_p.types(None,_cs.GLDEBUGPROCARB,ctypes.c_void_p) +def glDebugMessageCallbackARB(callback,userParam):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLenum,_cs.GLsizei,arrays.GLuintArray,_cs.GLboolean) +def glDebugMessageControlARB(source,type,severity,count,ids,enabled):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLuint,_cs.GLenum,_cs.GLsizei,arrays.GLcharArray) +def glDebugMessageInsertARB(source,type,id,severity,length,buf):pass +@_f +@_p.types(_cs.GLuint,_cs.GLuint,_cs.GLsizei,arrays.GLuintArray,arrays.GLuintArray,arrays.GLuintArray,arrays.GLuintArray,arrays.GLsizeiArray,arrays.GLcharArray) +def glGetDebugMessageLogARB(count,bufSize,sources,types,ids,severities,lengths,messageLog):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/depth_buffer_float.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/depth_buffer_float.py new file mode 100644 index 00000000..24d4fe0f --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/depth_buffer_float.py @@ -0,0 +1,17 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_depth_buffer_float' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_depth_buffer_float',error_checker=_errors._error_checker) +GL_DEPTH32F_STENCIL8=_C('GL_DEPTH32F_STENCIL8',0x8CAD) +GL_DEPTH_COMPONENT32F=_C('GL_DEPTH_COMPONENT32F',0x8CAC) +GL_FLOAT_32_UNSIGNED_INT_24_8_REV=_C('GL_FLOAT_32_UNSIGNED_INT_24_8_REV',0x8DAD) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/depth_clamp.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/depth_clamp.py new file mode 100644 index 00000000..4328d936 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/depth_clamp.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_depth_clamp' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_depth_clamp',error_checker=_errors._error_checker) +GL_DEPTH_CLAMP=_C('GL_DEPTH_CLAMP',0x864F) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/depth_texture.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/depth_texture.py new file mode 100644 index 00000000..9d24879a --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/depth_texture.py @@ -0,0 +1,19 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_depth_texture' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_depth_texture',error_checker=_errors._error_checker) +GL_DEPTH_COMPONENT16_ARB=_C('GL_DEPTH_COMPONENT16_ARB',0x81A5) +GL_DEPTH_COMPONENT24_ARB=_C('GL_DEPTH_COMPONENT24_ARB',0x81A6) +GL_DEPTH_COMPONENT32_ARB=_C('GL_DEPTH_COMPONENT32_ARB',0x81A7) +GL_DEPTH_TEXTURE_MODE_ARB=_C('GL_DEPTH_TEXTURE_MODE_ARB',0x884B) +GL_TEXTURE_DEPTH_SIZE_ARB=_C('GL_TEXTURE_DEPTH_SIZE_ARB',0x884A) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/derivative_control.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/derivative_control.py new file mode 100644 index 00000000..7ebfae7a --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/derivative_control.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_derivative_control' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_derivative_control',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/direct_state_access.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/direct_state_access.py new file mode 100644 index 00000000..858848db --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/direct_state_access.py @@ -0,0 +1,317 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_direct_state_access' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_direct_state_access',error_checker=_errors._error_checker) +GL_QUERY_TARGET=_C('GL_QUERY_TARGET',0x82EA) +GL_TEXTURE_BINDING_1D=_C('GL_TEXTURE_BINDING_1D',0x8068) +GL_TEXTURE_BINDING_1D_ARRAY=_C('GL_TEXTURE_BINDING_1D_ARRAY',0x8C1C) +GL_TEXTURE_BINDING_2D=_C('GL_TEXTURE_BINDING_2D',0x8069) +GL_TEXTURE_BINDING_2D_ARRAY=_C('GL_TEXTURE_BINDING_2D_ARRAY',0x8C1D) +GL_TEXTURE_BINDING_2D_MULTISAMPLE=_C('GL_TEXTURE_BINDING_2D_MULTISAMPLE',0x9104) +GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY=_C('GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY',0x9105) +GL_TEXTURE_BINDING_3D=_C('GL_TEXTURE_BINDING_3D',0x806A) +GL_TEXTURE_BINDING_BUFFER=_C('GL_TEXTURE_BINDING_BUFFER',0x8C2C) +GL_TEXTURE_BINDING_CUBE_MAP=_C('GL_TEXTURE_BINDING_CUBE_MAP',0x8514) +GL_TEXTURE_BINDING_CUBE_MAP_ARRAY=_C('GL_TEXTURE_BINDING_CUBE_MAP_ARRAY',0x900A) +GL_TEXTURE_BINDING_RECTANGLE=_C('GL_TEXTURE_BINDING_RECTANGLE',0x84F6) +GL_TEXTURE_TARGET=_C('GL_TEXTURE_TARGET',0x1006) +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint) +def glBindTextureUnit(unit,texture):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLbitfield,_cs.GLenum) +def glBlitNamedFramebuffer(readFramebuffer,drawFramebuffer,srcX0,srcY0,srcX1,srcY1,dstX0,dstY0,dstX1,dstY1,mask,filter):pass +@_f +@_p.types(_cs.GLenum,_cs.GLuint,_cs.GLenum) +def glCheckNamedFramebufferStatus(framebuffer,target):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLenum,_cs.GLenum,ctypes.c_void_p) +def glClearNamedBufferData(buffer,internalformat,format,type,data):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLintptr,_cs.GLsizeiptr,_cs.GLenum,_cs.GLenum,ctypes.c_void_p) +def glClearNamedBufferSubData(buffer,internalformat,offset,size,format,type,data):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLint,_cs.GLfloat,_cs.GLint) +def glClearNamedFramebufferfi(framebuffer,buffer,drawbuffer,depth,stencil):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLint,arrays.GLfloatArray) +def glClearNamedFramebufferfv(framebuffer,buffer,drawbuffer,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLint,arrays.GLintArray) +def glClearNamedFramebufferiv(framebuffer,buffer,drawbuffer,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLint,arrays.GLuintArray) +def glClearNamedFramebufferuiv(framebuffer,buffer,drawbuffer,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLenum,_cs.GLsizei,ctypes.c_void_p) +def glCompressedTextureSubImage1D(texture,level,xoffset,width,format,imageSize,data):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLsizei,_cs.GLenum,_cs.GLsizei,ctypes.c_void_p) +def glCompressedTextureSubImage2D(texture,level,xoffset,yoffset,width,height,format,imageSize,data):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLsizei,_cs.GLsizei,_cs.GLenum,_cs.GLsizei,ctypes.c_void_p) +def glCompressedTextureSubImage3D(texture,level,xoffset,yoffset,zoffset,width,height,depth,format,imageSize,data):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLintptr,_cs.GLintptr,_cs.GLsizeiptr) +def glCopyNamedBufferSubData(readBuffer,writeBuffer,readOffset,writeOffset,size):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLsizei) +def glCopyTextureSubImage1D(texture,level,xoffset,x,y,width):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLsizei) +def glCopyTextureSubImage2D(texture,level,xoffset,yoffset,x,y,width,height):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLsizei) +def glCopyTextureSubImage3D(texture,level,xoffset,yoffset,zoffset,x,y,width,height):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray) +def glCreateBuffers(n,buffers):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray) +def glCreateFramebuffers(n,framebuffers):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray) +def glCreateProgramPipelines(n,pipelines):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizei,arrays.GLuintArray) +def glCreateQueries(target,n,ids):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray) +def glCreateRenderbuffers(n,renderbuffers):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray) +def glCreateSamplers(n,samplers):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizei,arrays.GLuintArray) +def glCreateTextures(target,n,textures):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray) +def glCreateTransformFeedbacks(n,ids):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray) +def glCreateVertexArrays(n,arrays):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint) +def glDisableVertexArrayAttrib(vaobj,index):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint) +def glEnableVertexArrayAttrib(vaobj,index):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLintptr,_cs.GLsizeiptr) +def glFlushMappedNamedBufferRange(buffer,offset,length):pass +@_f +@_p.types(None,_cs.GLuint) +def glGenerateTextureMipmap(texture):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,ctypes.c_void_p) +def glGetCompressedTextureImage(texture,level,bufSize,pixels):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLint64Array) +def glGetNamedBufferParameteri64v(buffer,pname,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLintArray) +def glGetNamedBufferParameteriv(buffer,pname,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLvoidpArray) +def glGetNamedBufferPointerv(buffer,pname,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLintptr,_cs.GLsizeiptr,ctypes.c_void_p) +def glGetNamedBufferSubData(buffer,offset,size,data):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLenum,arrays.GLintArray) +def glGetNamedFramebufferAttachmentParameteriv(framebuffer,attachment,pname,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLintArray) +def glGetNamedFramebufferParameteriv(framebuffer,pname,param):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLintArray) +def glGetNamedRenderbufferParameteriv(renderbuffer,pname,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLenum,_cs.GLintptr) +def glGetQueryBufferObjecti64v(id,buffer,pname,offset):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLenum,_cs.GLintptr) +def glGetQueryBufferObjectiv(id,buffer,pname,offset):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLenum,_cs.GLintptr) +def glGetQueryBufferObjectui64v(id,buffer,pname,offset):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLenum,_cs.GLintptr) +def glGetQueryBufferObjectuiv(id,buffer,pname,offset):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLenum,_cs.GLenum,_cs.GLsizei,ctypes.c_void_p) +def glGetTextureImage(texture,level,format,type,bufSize,pixels):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLenum,arrays.GLfloatArray) +def glGetTextureLevelParameterfv(texture,level,pname,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLenum,arrays.GLintArray) +def glGetTextureLevelParameteriv(texture,level,pname,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLintArray) +def glGetTextureParameterIiv(texture,pname,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLuintArray) +def glGetTextureParameterIuiv(texture,pname,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLfloatArray) +def glGetTextureParameterfv(texture,pname,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLintArray) +def glGetTextureParameteriv(texture,pname,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLuint,arrays.GLint64Array) +def glGetTransformFeedbacki64_v(xfb,pname,index,param):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLuint,arrays.GLintArray) +def glGetTransformFeedbacki_v(xfb,pname,index,param):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLintArray) +def glGetTransformFeedbackiv(xfb,pname,param):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLenum,arrays.GLint64Array) +def glGetVertexArrayIndexed64iv(vaobj,index,pname,param):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLenum,arrays.GLintArray) +def glGetVertexArrayIndexediv(vaobj,index,pname,param):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLintArray) +def glGetVertexArrayiv(vaobj,pname,param):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizei,arrays.GLuintArray) +def glInvalidateNamedFramebufferData(framebuffer,numAttachments,attachments):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizei,arrays.GLuintArray,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLsizei) +def glInvalidateNamedFramebufferSubData(framebuffer,numAttachments,attachments,x,y,width,height):pass +@_f +@_p.types(ctypes.c_void_p,_cs.GLuint,_cs.GLenum) +def glMapNamedBuffer(buffer,access):pass +@_f +@_p.types(ctypes.c_void_p,_cs.GLuint,_cs.GLintptr,_cs.GLsizeiptr,_cs.GLbitfield) +def glMapNamedBufferRange(buffer,offset,length,access):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizeiptr,ctypes.c_void_p,_cs.GLenum) +def glNamedBufferData(buffer,size,data,usage):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizeiptr,ctypes.c_void_p,_cs.GLbitfield) +def glNamedBufferStorage(buffer,size,data,flags):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLintptr,_cs.GLsizeiptr,ctypes.c_void_p) +def glNamedBufferSubData(buffer,offset,size,data):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum) +def glNamedFramebufferDrawBuffer(framebuffer,buf):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizei,arrays.GLuintArray) +def glNamedFramebufferDrawBuffers(framebuffer,n,bufs):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLint) +def glNamedFramebufferParameteri(framebuffer,pname,param):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum) +def glNamedFramebufferReadBuffer(framebuffer,src):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLenum,_cs.GLuint) +def glNamedFramebufferRenderbuffer(framebuffer,attachment,renderbuffertarget,renderbuffer):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLuint,_cs.GLint) +def glNamedFramebufferTexture(framebuffer,attachment,texture,level):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLuint,_cs.GLint,_cs.GLint) +def glNamedFramebufferTextureLayer(framebuffer,attachment,texture,level,layer):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLsizei,_cs.GLsizei) +def glNamedRenderbufferStorage(renderbuffer,internalformat,width,height):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizei,_cs.GLenum,_cs.GLsizei,_cs.GLsizei) +def glNamedRenderbufferStorageMultisample(renderbuffer,samples,internalformat,width,height):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLuint) +def glTextureBuffer(texture,internalformat,buffer):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLuint,_cs.GLintptr,_cs.GLsizeiptr) +def glTextureBufferRange(texture,internalformat,buffer,offset,size):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLintArray) +def glTextureParameterIiv(texture,pname,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLuintArray) +def glTextureParameterIuiv(texture,pname,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLfloat) +def glTextureParameterf(texture,pname,param):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLfloatArray) +def glTextureParameterfv(texture,pname,param):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLint) +def glTextureParameteri(texture,pname,param):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLintArray) +def glTextureParameteriv(texture,pname,param):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizei,_cs.GLenum,_cs.GLsizei) +def glTextureStorage1D(texture,levels,internalformat,width):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizei,_cs.GLenum,_cs.GLsizei,_cs.GLsizei) +def glTextureStorage2D(texture,levels,internalformat,width,height):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizei,_cs.GLenum,_cs.GLsizei,_cs.GLsizei,_cs.GLboolean) +def glTextureStorage2DMultisample(texture,samples,internalformat,width,height,fixedsamplelocations):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizei,_cs.GLenum,_cs.GLsizei,_cs.GLsizei,_cs.GLsizei) +def glTextureStorage3D(texture,levels,internalformat,width,height,depth):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizei,_cs.GLenum,_cs.GLsizei,_cs.GLsizei,_cs.GLsizei,_cs.GLboolean) +def glTextureStorage3DMultisample(texture,samples,internalformat,width,height,depth,fixedsamplelocations):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLenum,_cs.GLenum,ctypes.c_void_p) +def glTextureSubImage1D(texture,level,xoffset,width,format,type,pixels):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLsizei,_cs.GLenum,_cs.GLenum,ctypes.c_void_p) +def glTextureSubImage2D(texture,level,xoffset,yoffset,width,height,format,type,pixels):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLsizei,_cs.GLsizei,_cs.GLenum,_cs.GLenum,ctypes.c_void_p) +def glTextureSubImage3D(texture,level,xoffset,yoffset,zoffset,width,height,depth,format,type,pixels):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLuint) +def glTransformFeedbackBufferBase(xfb,index,buffer):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLuint,_cs.GLintptr,_cs.GLsizeiptr) +def glTransformFeedbackBufferRange(xfb,index,buffer,offset,size):pass +@_f +@_p.types(_cs.GLboolean,_cs.GLuint) +def glUnmapNamedBuffer(buffer):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLuint) +def glVertexArrayAttribBinding(vaobj,attribindex,bindingindex):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLint,_cs.GLenum,_cs.GLboolean,_cs.GLuint) +def glVertexArrayAttribFormat(vaobj,attribindex,size,type,normalized,relativeoffset):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLint,_cs.GLenum,_cs.GLuint) +def glVertexArrayAttribIFormat(vaobj,attribindex,size,type,relativeoffset):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLint,_cs.GLenum,_cs.GLuint) +def glVertexArrayAttribLFormat(vaobj,attribindex,size,type,relativeoffset):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLuint) +def glVertexArrayBindingDivisor(vaobj,bindingindex,divisor):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint) +def glVertexArrayElementBuffer(vaobj,buffer):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLuint,_cs.GLintptr,_cs.GLsizei) +def glVertexArrayVertexBuffer(vaobj,bindingindex,buffer,offset,stride):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLsizei,arrays.GLuintArray,ctypes.POINTER(_cs.GLintptr),arrays.GLsizeiArray) +def glVertexArrayVertexBuffers(vaobj,first,count,buffers,offsets,strides):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/draw_buffers.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/draw_buffers.py new file mode 100644 index 00000000..2119dcad --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/draw_buffers.py @@ -0,0 +1,33 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_draw_buffers' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_draw_buffers',error_checker=_errors._error_checker) +GL_DRAW_BUFFER0_ARB=_C('GL_DRAW_BUFFER0_ARB',0x8825) +GL_DRAW_BUFFER10_ARB=_C('GL_DRAW_BUFFER10_ARB',0x882F) +GL_DRAW_BUFFER11_ARB=_C('GL_DRAW_BUFFER11_ARB',0x8830) +GL_DRAW_BUFFER12_ARB=_C('GL_DRAW_BUFFER12_ARB',0x8831) +GL_DRAW_BUFFER13_ARB=_C('GL_DRAW_BUFFER13_ARB',0x8832) +GL_DRAW_BUFFER14_ARB=_C('GL_DRAW_BUFFER14_ARB',0x8833) +GL_DRAW_BUFFER15_ARB=_C('GL_DRAW_BUFFER15_ARB',0x8834) +GL_DRAW_BUFFER1_ARB=_C('GL_DRAW_BUFFER1_ARB',0x8826) +GL_DRAW_BUFFER2_ARB=_C('GL_DRAW_BUFFER2_ARB',0x8827) +GL_DRAW_BUFFER3_ARB=_C('GL_DRAW_BUFFER3_ARB',0x8828) +GL_DRAW_BUFFER4_ARB=_C('GL_DRAW_BUFFER4_ARB',0x8829) +GL_DRAW_BUFFER5_ARB=_C('GL_DRAW_BUFFER5_ARB',0x882A) +GL_DRAW_BUFFER6_ARB=_C('GL_DRAW_BUFFER6_ARB',0x882B) +GL_DRAW_BUFFER7_ARB=_C('GL_DRAW_BUFFER7_ARB',0x882C) +GL_DRAW_BUFFER8_ARB=_C('GL_DRAW_BUFFER8_ARB',0x882D) +GL_DRAW_BUFFER9_ARB=_C('GL_DRAW_BUFFER9_ARB',0x882E) +GL_MAX_DRAW_BUFFERS_ARB=_C('GL_MAX_DRAW_BUFFERS_ARB',0x8824) +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray) +def glDrawBuffersARB(n,bufs):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/draw_buffers_blend.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/draw_buffers_blend.py new file mode 100644 index 00000000..30e273de --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/draw_buffers_blend.py @@ -0,0 +1,26 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_draw_buffers_blend' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_draw_buffers_blend',error_checker=_errors._error_checker) + +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLenum) +def glBlendEquationSeparateiARB(buf,modeRGB,modeAlpha):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum) +def glBlendEquationiARB(buf,mode):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLenum,_cs.GLenum,_cs.GLenum) +def glBlendFuncSeparateiARB(buf,srcRGB,dstRGB,srcAlpha,dstAlpha):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLenum) +def glBlendFunciARB(buf,src,dst):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/draw_elements_base_vertex.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/draw_elements_base_vertex.py new file mode 100644 index 00000000..e1e0eba8 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/draw_elements_base_vertex.py @@ -0,0 +1,26 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_draw_elements_base_vertex' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_draw_elements_base_vertex',error_checker=_errors._error_checker) + +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizei,_cs.GLenum,ctypes.c_void_p,_cs.GLint) +def glDrawElementsBaseVertex(mode,count,type,indices,basevertex):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizei,_cs.GLenum,ctypes.c_void_p,_cs.GLsizei,_cs.GLint) +def glDrawElementsInstancedBaseVertex(mode,count,type,indices,instancecount,basevertex):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,_cs.GLuint,_cs.GLsizei,_cs.GLenum,ctypes.c_void_p,_cs.GLint) +def glDrawRangeElementsBaseVertex(mode,start,end,count,type,indices,basevertex):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLsizeiArray,_cs.GLenum,arrays.GLvoidpArray,_cs.GLsizei,arrays.GLintArray) +def glMultiDrawElementsBaseVertex(mode,count,type,indices,drawcount,basevertex):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/draw_indirect.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/draw_indirect.py new file mode 100644 index 00000000..910ff6b1 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/draw_indirect.py @@ -0,0 +1,21 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_draw_indirect' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_draw_indirect',error_checker=_errors._error_checker) +GL_DRAW_INDIRECT_BUFFER=_C('GL_DRAW_INDIRECT_BUFFER',0x8F3F) +GL_DRAW_INDIRECT_BUFFER_BINDING=_C('GL_DRAW_INDIRECT_BUFFER_BINDING',0x8F43) +@_f +@_p.types(None,_cs.GLenum,ctypes.c_void_p) +def glDrawArraysIndirect(mode,indirect):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,ctypes.c_void_p) +def glDrawElementsIndirect(mode,type,indirect):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/draw_instanced.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/draw_instanced.py new file mode 100644 index 00000000..8729a724 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/draw_instanced.py @@ -0,0 +1,20 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_draw_instanced' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_draw_instanced',error_checker=_errors._error_checker) + +@_f +@_p.types(None,_cs.GLenum,_cs.GLint,_cs.GLsizei,_cs.GLsizei) +def glDrawArraysInstancedARB(mode,first,count,primcount):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizei,_cs.GLenum,ctypes.c_void_p,_cs.GLsizei) +def glDrawElementsInstancedARB(mode,count,type,indices,primcount):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/enhanced_layouts.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/enhanced_layouts.py new file mode 100644 index 00000000..937338ab --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/enhanced_layouts.py @@ -0,0 +1,18 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_enhanced_layouts' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_enhanced_layouts',error_checker=_errors._error_checker) +GL_LOCATION_COMPONENT=_C('GL_LOCATION_COMPONENT',0x934A) +GL_TRANSFORM_FEEDBACK_BUFFER=_C('GL_TRANSFORM_FEEDBACK_BUFFER',0x8C8E) +GL_TRANSFORM_FEEDBACK_BUFFER_INDEX=_C('GL_TRANSFORM_FEEDBACK_BUFFER_INDEX',0x934B) +GL_TRANSFORM_FEEDBACK_BUFFER_STRIDE=_C('GL_TRANSFORM_FEEDBACK_BUFFER_STRIDE',0x934C) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/explicit_attrib_location.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/explicit_attrib_location.py new file mode 100644 index 00000000..45661f5f --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/explicit_attrib_location.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_explicit_attrib_location' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_explicit_attrib_location',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/explicit_uniform_location.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/explicit_uniform_location.py new file mode 100644 index 00000000..a9200180 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/explicit_uniform_location.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_explicit_uniform_location' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_explicit_uniform_location',error_checker=_errors._error_checker) +GL_MAX_UNIFORM_LOCATIONS=_C('GL_MAX_UNIFORM_LOCATIONS',0x826E) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/fragment_coord_conventions.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/fragment_coord_conventions.py new file mode 100644 index 00000000..24114b0c --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/fragment_coord_conventions.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_fragment_coord_conventions' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_fragment_coord_conventions',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/fragment_layer_viewport.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/fragment_layer_viewport.py new file mode 100644 index 00000000..da55b887 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/fragment_layer_viewport.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_fragment_layer_viewport' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_fragment_layer_viewport',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/fragment_program.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/fragment_program.py new file mode 100644 index 00000000..917eb803 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/fragment_program.py @@ -0,0 +1,148 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_fragment_program' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_fragment_program',error_checker=_errors._error_checker) +GL_CURRENT_MATRIX_ARB=_C('GL_CURRENT_MATRIX_ARB',0x8641) +GL_CURRENT_MATRIX_STACK_DEPTH_ARB=_C('GL_CURRENT_MATRIX_STACK_DEPTH_ARB',0x8640) +GL_FRAGMENT_PROGRAM_ARB=_C('GL_FRAGMENT_PROGRAM_ARB',0x8804) +GL_MATRIX0_ARB=_C('GL_MATRIX0_ARB',0x88C0) +GL_MATRIX10_ARB=_C('GL_MATRIX10_ARB',0x88CA) +GL_MATRIX11_ARB=_C('GL_MATRIX11_ARB',0x88CB) +GL_MATRIX12_ARB=_C('GL_MATRIX12_ARB',0x88CC) +GL_MATRIX13_ARB=_C('GL_MATRIX13_ARB',0x88CD) +GL_MATRIX14_ARB=_C('GL_MATRIX14_ARB',0x88CE) +GL_MATRIX15_ARB=_C('GL_MATRIX15_ARB',0x88CF) +GL_MATRIX16_ARB=_C('GL_MATRIX16_ARB',0x88D0) +GL_MATRIX17_ARB=_C('GL_MATRIX17_ARB',0x88D1) +GL_MATRIX18_ARB=_C('GL_MATRIX18_ARB',0x88D2) +GL_MATRIX19_ARB=_C('GL_MATRIX19_ARB',0x88D3) +GL_MATRIX1_ARB=_C('GL_MATRIX1_ARB',0x88C1) +GL_MATRIX20_ARB=_C('GL_MATRIX20_ARB',0x88D4) +GL_MATRIX21_ARB=_C('GL_MATRIX21_ARB',0x88D5) +GL_MATRIX22_ARB=_C('GL_MATRIX22_ARB',0x88D6) +GL_MATRIX23_ARB=_C('GL_MATRIX23_ARB',0x88D7) +GL_MATRIX24_ARB=_C('GL_MATRIX24_ARB',0x88D8) +GL_MATRIX25_ARB=_C('GL_MATRIX25_ARB',0x88D9) +GL_MATRIX26_ARB=_C('GL_MATRIX26_ARB',0x88DA) +GL_MATRIX27_ARB=_C('GL_MATRIX27_ARB',0x88DB) +GL_MATRIX28_ARB=_C('GL_MATRIX28_ARB',0x88DC) +GL_MATRIX29_ARB=_C('GL_MATRIX29_ARB',0x88DD) +GL_MATRIX2_ARB=_C('GL_MATRIX2_ARB',0x88C2) +GL_MATRIX30_ARB=_C('GL_MATRIX30_ARB',0x88DE) +GL_MATRIX31_ARB=_C('GL_MATRIX31_ARB',0x88DF) +GL_MATRIX3_ARB=_C('GL_MATRIX3_ARB',0x88C3) +GL_MATRIX4_ARB=_C('GL_MATRIX4_ARB',0x88C4) +GL_MATRIX5_ARB=_C('GL_MATRIX5_ARB',0x88C5) +GL_MATRIX6_ARB=_C('GL_MATRIX6_ARB',0x88C6) +GL_MATRIX7_ARB=_C('GL_MATRIX7_ARB',0x88C7) +GL_MATRIX8_ARB=_C('GL_MATRIX8_ARB',0x88C8) +GL_MATRIX9_ARB=_C('GL_MATRIX9_ARB',0x88C9) +GL_MAX_PROGRAM_ALU_INSTRUCTIONS_ARB=_C('GL_MAX_PROGRAM_ALU_INSTRUCTIONS_ARB',0x880B) +GL_MAX_PROGRAM_ATTRIBS_ARB=_C('GL_MAX_PROGRAM_ATTRIBS_ARB',0x88AD) +GL_MAX_PROGRAM_ENV_PARAMETERS_ARB=_C('GL_MAX_PROGRAM_ENV_PARAMETERS_ARB',0x88B5) +GL_MAX_PROGRAM_INSTRUCTIONS_ARB=_C('GL_MAX_PROGRAM_INSTRUCTIONS_ARB',0x88A1) +GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB=_C('GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB',0x88B4) +GL_MAX_PROGRAM_MATRICES_ARB=_C('GL_MAX_PROGRAM_MATRICES_ARB',0x862F) +GL_MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB=_C('GL_MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB',0x862E) +GL_MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB=_C('GL_MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB',0x880E) +GL_MAX_PROGRAM_NATIVE_ATTRIBS_ARB=_C('GL_MAX_PROGRAM_NATIVE_ATTRIBS_ARB',0x88AF) +GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB=_C('GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB',0x88A3) +GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB=_C('GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB',0x88AB) +GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB=_C('GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB',0x88A7) +GL_MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB=_C('GL_MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB',0x8810) +GL_MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB=_C('GL_MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB',0x880F) +GL_MAX_PROGRAM_PARAMETERS_ARB=_C('GL_MAX_PROGRAM_PARAMETERS_ARB',0x88A9) +GL_MAX_PROGRAM_TEMPORARIES_ARB=_C('GL_MAX_PROGRAM_TEMPORARIES_ARB',0x88A5) +GL_MAX_PROGRAM_TEX_INDIRECTIONS_ARB=_C('GL_MAX_PROGRAM_TEX_INDIRECTIONS_ARB',0x880D) +GL_MAX_PROGRAM_TEX_INSTRUCTIONS_ARB=_C('GL_MAX_PROGRAM_TEX_INSTRUCTIONS_ARB',0x880C) +GL_MAX_TEXTURE_COORDS_ARB=_C('GL_MAX_TEXTURE_COORDS_ARB',0x8871) +GL_MAX_TEXTURE_IMAGE_UNITS_ARB=_C('GL_MAX_TEXTURE_IMAGE_UNITS_ARB',0x8872) +GL_PROGRAM_ALU_INSTRUCTIONS_ARB=_C('GL_PROGRAM_ALU_INSTRUCTIONS_ARB',0x8805) +GL_PROGRAM_ATTRIBS_ARB=_C('GL_PROGRAM_ATTRIBS_ARB',0x88AC) +GL_PROGRAM_BINDING_ARB=_C('GL_PROGRAM_BINDING_ARB',0x8677) +GL_PROGRAM_ERROR_POSITION_ARB=_C('GL_PROGRAM_ERROR_POSITION_ARB',0x864B) +GL_PROGRAM_ERROR_STRING_ARB=_C('GL_PROGRAM_ERROR_STRING_ARB',0x8874) +GL_PROGRAM_FORMAT_ARB=_C('GL_PROGRAM_FORMAT_ARB',0x8876) +GL_PROGRAM_FORMAT_ASCII_ARB=_C('GL_PROGRAM_FORMAT_ASCII_ARB',0x8875) +GL_PROGRAM_INSTRUCTIONS_ARB=_C('GL_PROGRAM_INSTRUCTIONS_ARB',0x88A0) +GL_PROGRAM_LENGTH_ARB=_C('GL_PROGRAM_LENGTH_ARB',0x8627) +GL_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB=_C('GL_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB',0x8808) +GL_PROGRAM_NATIVE_ATTRIBS_ARB=_C('GL_PROGRAM_NATIVE_ATTRIBS_ARB',0x88AE) +GL_PROGRAM_NATIVE_INSTRUCTIONS_ARB=_C('GL_PROGRAM_NATIVE_INSTRUCTIONS_ARB',0x88A2) +GL_PROGRAM_NATIVE_PARAMETERS_ARB=_C('GL_PROGRAM_NATIVE_PARAMETERS_ARB',0x88AA) +GL_PROGRAM_NATIVE_TEMPORARIES_ARB=_C('GL_PROGRAM_NATIVE_TEMPORARIES_ARB',0x88A6) +GL_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB=_C('GL_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB',0x880A) +GL_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB=_C('GL_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB',0x8809) +GL_PROGRAM_PARAMETERS_ARB=_C('GL_PROGRAM_PARAMETERS_ARB',0x88A8) +GL_PROGRAM_STRING_ARB=_C('GL_PROGRAM_STRING_ARB',0x8628) +GL_PROGRAM_TEMPORARIES_ARB=_C('GL_PROGRAM_TEMPORARIES_ARB',0x88A4) +GL_PROGRAM_TEX_INDIRECTIONS_ARB=_C('GL_PROGRAM_TEX_INDIRECTIONS_ARB',0x8807) +GL_PROGRAM_TEX_INSTRUCTIONS_ARB=_C('GL_PROGRAM_TEX_INSTRUCTIONS_ARB',0x8806) +GL_PROGRAM_UNDER_NATIVE_LIMITS_ARB=_C('GL_PROGRAM_UNDER_NATIVE_LIMITS_ARB',0x88B6) +GL_TRANSPOSE_CURRENT_MATRIX_ARB=_C('GL_TRANSPOSE_CURRENT_MATRIX_ARB',0x88B7) +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint) +def glBindProgramARB(target,program):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray) +def glDeleteProgramsARB(n,programs):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray) +def glGenProgramsARB(n,programs):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,arrays.GLdoubleArray) +def glGetProgramEnvParameterdvARB(target,index,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,arrays.GLfloatArray) +def glGetProgramEnvParameterfvARB(target,index,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,arrays.GLdoubleArray) +def glGetProgramLocalParameterdvARB(target,index,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,arrays.GLfloatArray) +def glGetProgramLocalParameterfvARB(target,index,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,ctypes.c_void_p) +def glGetProgramStringARB(target,pname,string):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLintArray) +def glGetProgramivARB(target,pname,params):pass +@_f +@_p.types(_cs.GLboolean,_cs.GLuint) +def glIsProgramARB(program):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,_cs.GLdouble,_cs.GLdouble,_cs.GLdouble,_cs.GLdouble) +def glProgramEnvParameter4dARB(target,index,x,y,z,w):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,arrays.GLdoubleArray) +def glProgramEnvParameter4dvARB(target,index,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat) +def glProgramEnvParameter4fARB(target,index,x,y,z,w):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,arrays.GLfloatArray) +def glProgramEnvParameter4fvARB(target,index,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,_cs.GLdouble,_cs.GLdouble,_cs.GLdouble,_cs.GLdouble) +def glProgramLocalParameter4dARB(target,index,x,y,z,w):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,arrays.GLdoubleArray) +def glProgramLocalParameter4dvARB(target,index,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat) +def glProgramLocalParameter4fARB(target,index,x,y,z,w):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,arrays.GLfloatArray) +def glProgramLocalParameter4fvARB(target,index,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLsizei,ctypes.c_void_p) +def glProgramStringARB(target,format,len,string):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/fragment_program_shadow.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/fragment_program_shadow.py new file mode 100644 index 00000000..7e649401 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/fragment_program_shadow.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_fragment_program_shadow' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_fragment_program_shadow',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/fragment_shader.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/fragment_shader.py new file mode 100644 index 00000000..89beac6b --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/fragment_shader.py @@ -0,0 +1,17 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_fragment_shader' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_fragment_shader',error_checker=_errors._error_checker) +GL_FRAGMENT_SHADER_ARB=_C('GL_FRAGMENT_SHADER_ARB',0x8B30) +GL_FRAGMENT_SHADER_DERIVATIVE_HINT_ARB=_C('GL_FRAGMENT_SHADER_DERIVATIVE_HINT_ARB',0x8B8B) +GL_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB=_C('GL_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB',0x8B49) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/fragment_shader_interlock.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/fragment_shader_interlock.py new file mode 100644 index 00000000..ab44d51b --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/fragment_shader_interlock.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_fragment_shader_interlock' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_fragment_shader_interlock',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/framebuffer_no_attachments.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/framebuffer_no_attachments.py new file mode 100644 index 00000000..b89feeef --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/framebuffer_no_attachments.py @@ -0,0 +1,28 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_framebuffer_no_attachments' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_framebuffer_no_attachments',error_checker=_errors._error_checker) +GL_FRAMEBUFFER_DEFAULT_FIXED_SAMPLE_LOCATIONS=_C('GL_FRAMEBUFFER_DEFAULT_FIXED_SAMPLE_LOCATIONS',0x9314) +GL_FRAMEBUFFER_DEFAULT_HEIGHT=_C('GL_FRAMEBUFFER_DEFAULT_HEIGHT',0x9311) +GL_FRAMEBUFFER_DEFAULT_LAYERS=_C('GL_FRAMEBUFFER_DEFAULT_LAYERS',0x9312) +GL_FRAMEBUFFER_DEFAULT_SAMPLES=_C('GL_FRAMEBUFFER_DEFAULT_SAMPLES',0x9313) +GL_FRAMEBUFFER_DEFAULT_WIDTH=_C('GL_FRAMEBUFFER_DEFAULT_WIDTH',0x9310) +GL_MAX_FRAMEBUFFER_HEIGHT=_C('GL_MAX_FRAMEBUFFER_HEIGHT',0x9316) +GL_MAX_FRAMEBUFFER_LAYERS=_C('GL_MAX_FRAMEBUFFER_LAYERS',0x9317) +GL_MAX_FRAMEBUFFER_SAMPLES=_C('GL_MAX_FRAMEBUFFER_SAMPLES',0x9318) +GL_MAX_FRAMEBUFFER_WIDTH=_C('GL_MAX_FRAMEBUFFER_WIDTH',0x9315) +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLint) +def glFramebufferParameteri(target,pname,param):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLintArray) +def glGetFramebufferParameteriv(target,pname,params):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/framebuffer_object.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/framebuffer_object.py new file mode 100644 index 00000000..c4b1bd0f --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/framebuffer_object.py @@ -0,0 +1,146 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_framebuffer_object' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_framebuffer_object',error_checker=_errors._error_checker) +GL_COLOR_ATTACHMENT0=_C('GL_COLOR_ATTACHMENT0',0x8CE0) +GL_COLOR_ATTACHMENT1=_C('GL_COLOR_ATTACHMENT1',0x8CE1) +GL_COLOR_ATTACHMENT10=_C('GL_COLOR_ATTACHMENT10',0x8CEA) +GL_COLOR_ATTACHMENT11=_C('GL_COLOR_ATTACHMENT11',0x8CEB) +GL_COLOR_ATTACHMENT12=_C('GL_COLOR_ATTACHMENT12',0x8CEC) +GL_COLOR_ATTACHMENT13=_C('GL_COLOR_ATTACHMENT13',0x8CED) +GL_COLOR_ATTACHMENT14=_C('GL_COLOR_ATTACHMENT14',0x8CEE) +GL_COLOR_ATTACHMENT15=_C('GL_COLOR_ATTACHMENT15',0x8CEF) +GL_COLOR_ATTACHMENT2=_C('GL_COLOR_ATTACHMENT2',0x8CE2) +GL_COLOR_ATTACHMENT3=_C('GL_COLOR_ATTACHMENT3',0x8CE3) +GL_COLOR_ATTACHMENT4=_C('GL_COLOR_ATTACHMENT4',0x8CE4) +GL_COLOR_ATTACHMENT5=_C('GL_COLOR_ATTACHMENT5',0x8CE5) +GL_COLOR_ATTACHMENT6=_C('GL_COLOR_ATTACHMENT6',0x8CE6) +GL_COLOR_ATTACHMENT7=_C('GL_COLOR_ATTACHMENT7',0x8CE7) +GL_COLOR_ATTACHMENT8=_C('GL_COLOR_ATTACHMENT8',0x8CE8) +GL_COLOR_ATTACHMENT9=_C('GL_COLOR_ATTACHMENT9',0x8CE9) +GL_DEPTH24_STENCIL8=_C('GL_DEPTH24_STENCIL8',0x88F0) +GL_DEPTH_ATTACHMENT=_C('GL_DEPTH_ATTACHMENT',0x8D00) +GL_DEPTH_STENCIL=_C('GL_DEPTH_STENCIL',0x84F9) +GL_DEPTH_STENCIL_ATTACHMENT=_C('GL_DEPTH_STENCIL_ATTACHMENT',0x821A) +GL_DRAW_FRAMEBUFFER=_C('GL_DRAW_FRAMEBUFFER',0x8CA9) +GL_DRAW_FRAMEBUFFER_BINDING=_C('GL_DRAW_FRAMEBUFFER_BINDING',0x8CA6) +GL_FRAMEBUFFER=_C('GL_FRAMEBUFFER',0x8D40) +GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE=_C('GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE',0x8215) +GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE=_C('GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE',0x8214) +GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING=_C('GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING',0x8210) +GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE=_C('GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE',0x8211) +GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE=_C('GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE',0x8216) +GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE=_C('GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE',0x8213) +GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME=_C('GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME',0x8CD1) +GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE=_C('GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE',0x8CD0) +GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE=_C('GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE',0x8212) +GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE=_C('GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE',0x8217) +GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE=_C('GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE',0x8CD3) +GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER=_C('GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER',0x8CD4) +GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL=_C('GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL',0x8CD2) +GL_FRAMEBUFFER_BINDING=_C('GL_FRAMEBUFFER_BINDING',0x8CA6) +GL_FRAMEBUFFER_COMPLETE=_C('GL_FRAMEBUFFER_COMPLETE',0x8CD5) +GL_FRAMEBUFFER_DEFAULT=_C('GL_FRAMEBUFFER_DEFAULT',0x8218) +GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT=_C('GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT',0x8CD6) +GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER=_C('GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER',0x8CDB) +GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT=_C('GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT',0x8CD7) +GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE=_C('GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE',0x8D56) +GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER=_C('GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER',0x8CDC) +GL_FRAMEBUFFER_UNDEFINED=_C('GL_FRAMEBUFFER_UNDEFINED',0x8219) +GL_FRAMEBUFFER_UNSUPPORTED=_C('GL_FRAMEBUFFER_UNSUPPORTED',0x8CDD) +GL_INDEX=_C('GL_INDEX',0x8222) +GL_INVALID_FRAMEBUFFER_OPERATION=_C('GL_INVALID_FRAMEBUFFER_OPERATION',0x0506) +GL_MAX_COLOR_ATTACHMENTS=_C('GL_MAX_COLOR_ATTACHMENTS',0x8CDF) +GL_MAX_RENDERBUFFER_SIZE=_C('GL_MAX_RENDERBUFFER_SIZE',0x84E8) +GL_MAX_SAMPLES=_C('GL_MAX_SAMPLES',0x8D57) +GL_READ_FRAMEBUFFER=_C('GL_READ_FRAMEBUFFER',0x8CA8) +GL_READ_FRAMEBUFFER_BINDING=_C('GL_READ_FRAMEBUFFER_BINDING',0x8CAA) +GL_RENDERBUFFER=_C('GL_RENDERBUFFER',0x8D41) +GL_RENDERBUFFER_ALPHA_SIZE=_C('GL_RENDERBUFFER_ALPHA_SIZE',0x8D53) +GL_RENDERBUFFER_BINDING=_C('GL_RENDERBUFFER_BINDING',0x8CA7) +GL_RENDERBUFFER_BLUE_SIZE=_C('GL_RENDERBUFFER_BLUE_SIZE',0x8D52) +GL_RENDERBUFFER_DEPTH_SIZE=_C('GL_RENDERBUFFER_DEPTH_SIZE',0x8D54) +GL_RENDERBUFFER_GREEN_SIZE=_C('GL_RENDERBUFFER_GREEN_SIZE',0x8D51) +GL_RENDERBUFFER_HEIGHT=_C('GL_RENDERBUFFER_HEIGHT',0x8D43) +GL_RENDERBUFFER_INTERNAL_FORMAT=_C('GL_RENDERBUFFER_INTERNAL_FORMAT',0x8D44) +GL_RENDERBUFFER_RED_SIZE=_C('GL_RENDERBUFFER_RED_SIZE',0x8D50) +GL_RENDERBUFFER_SAMPLES=_C('GL_RENDERBUFFER_SAMPLES',0x8CAB) +GL_RENDERBUFFER_STENCIL_SIZE=_C('GL_RENDERBUFFER_STENCIL_SIZE',0x8D55) +GL_RENDERBUFFER_WIDTH=_C('GL_RENDERBUFFER_WIDTH',0x8D42) +GL_STENCIL_ATTACHMENT=_C('GL_STENCIL_ATTACHMENT',0x8D20) +GL_STENCIL_INDEX1=_C('GL_STENCIL_INDEX1',0x8D46) +GL_STENCIL_INDEX16=_C('GL_STENCIL_INDEX16',0x8D49) +GL_STENCIL_INDEX4=_C('GL_STENCIL_INDEX4',0x8D47) +GL_STENCIL_INDEX8=_C('GL_STENCIL_INDEX8',0x8D48) +GL_TEXTURE_STENCIL_SIZE=_C('GL_TEXTURE_STENCIL_SIZE',0x88F1) +GL_UNSIGNED_INT_24_8=_C('GL_UNSIGNED_INT_24_8',0x84FA) +GL_UNSIGNED_NORMALIZED=_C('GL_UNSIGNED_NORMALIZED',0x8C17) +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint) +def glBindFramebuffer(target,framebuffer):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint) +def glBindRenderbuffer(target,renderbuffer):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLbitfield,_cs.GLenum) +def glBlitFramebuffer(srcX0,srcY0,srcX1,srcY1,dstX0,dstY0,dstX1,dstY1,mask,filter):pass +@_f +@_p.types(_cs.GLenum,_cs.GLenum) +def glCheckFramebufferStatus(target):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray) +def glDeleteFramebuffers(n,framebuffers):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray) +def glDeleteRenderbuffers(n,renderbuffers):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLenum,_cs.GLuint) +def glFramebufferRenderbuffer(target,attachment,renderbuffertarget,renderbuffer):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLenum,_cs.GLuint,_cs.GLint) +def glFramebufferTexture1D(target,attachment,textarget,texture,level):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLenum,_cs.GLuint,_cs.GLint) +def glFramebufferTexture2D(target,attachment,textarget,texture,level):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLenum,_cs.GLuint,_cs.GLint,_cs.GLint) +def glFramebufferTexture3D(target,attachment,textarget,texture,level,zoffset):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLuint,_cs.GLint,_cs.GLint) +def glFramebufferTextureLayer(target,attachment,texture,level,layer):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray) +def glGenFramebuffers(n,framebuffers):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray) +def glGenRenderbuffers(n,renderbuffers):pass +@_f +@_p.types(None,_cs.GLenum) +def glGenerateMipmap(target):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLenum,arrays.GLintArray) +def glGetFramebufferAttachmentParameteriv(target,attachment,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLintArray) +def glGetRenderbufferParameteriv(target,pname,params):pass +@_f +@_p.types(_cs.GLboolean,_cs.GLuint) +def glIsFramebuffer(framebuffer):pass +@_f +@_p.types(_cs.GLboolean,_cs.GLuint) +def glIsRenderbuffer(renderbuffer):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLsizei,_cs.GLsizei) +def glRenderbufferStorage(target,internalformat,width,height):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizei,_cs.GLenum,_cs.GLsizei,_cs.GLsizei) +def glRenderbufferStorageMultisample(target,samples,internalformat,width,height):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/framebuffer_sRGB.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/framebuffer_sRGB.py new file mode 100644 index 00000000..9648d683 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/framebuffer_sRGB.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_framebuffer_sRGB' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_framebuffer_sRGB',error_checker=_errors._error_checker) +GL_FRAMEBUFFER_SRGB=_C('GL_FRAMEBUFFER_SRGB',0x8DB9) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/geometry_shader4.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/geometry_shader4.py new file mode 100644 index 00000000..d294ba75 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/geometry_shader4.py @@ -0,0 +1,45 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_geometry_shader4' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_geometry_shader4',error_checker=_errors._error_checker) +GL_FRAMEBUFFER_ATTACHMENT_LAYERED_ARB=_C('GL_FRAMEBUFFER_ATTACHMENT_LAYERED_ARB',0x8DA7) +GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER=_C('GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER',0x8CD4) +GL_FRAMEBUFFER_INCOMPLETE_LAYER_COUNT_ARB=_C('GL_FRAMEBUFFER_INCOMPLETE_LAYER_COUNT_ARB',0x8DA9) +GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS_ARB=_C('GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS_ARB',0x8DA8) +GL_GEOMETRY_INPUT_TYPE_ARB=_C('GL_GEOMETRY_INPUT_TYPE_ARB',0x8DDB) +GL_GEOMETRY_OUTPUT_TYPE_ARB=_C('GL_GEOMETRY_OUTPUT_TYPE_ARB',0x8DDC) +GL_GEOMETRY_SHADER_ARB=_C('GL_GEOMETRY_SHADER_ARB',0x8DD9) +GL_GEOMETRY_VERTICES_OUT_ARB=_C('GL_GEOMETRY_VERTICES_OUT_ARB',0x8DDA) +GL_LINES_ADJACENCY_ARB=_C('GL_LINES_ADJACENCY_ARB',0x000A) +GL_LINE_STRIP_ADJACENCY_ARB=_C('GL_LINE_STRIP_ADJACENCY_ARB',0x000B) +GL_MAX_GEOMETRY_OUTPUT_VERTICES_ARB=_C('GL_MAX_GEOMETRY_OUTPUT_VERTICES_ARB',0x8DE0) +GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_ARB=_C('GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_ARB',0x8C29) +GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS_ARB=_C('GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS_ARB',0x8DE1) +GL_MAX_GEOMETRY_UNIFORM_COMPONENTS_ARB=_C('GL_MAX_GEOMETRY_UNIFORM_COMPONENTS_ARB',0x8DDF) +GL_MAX_GEOMETRY_VARYING_COMPONENTS_ARB=_C('GL_MAX_GEOMETRY_VARYING_COMPONENTS_ARB',0x8DDD) +GL_MAX_VARYING_COMPONENTS=_C('GL_MAX_VARYING_COMPONENTS',0x8B4B) +GL_MAX_VERTEX_VARYING_COMPONENTS_ARB=_C('GL_MAX_VERTEX_VARYING_COMPONENTS_ARB',0x8DDE) +GL_PROGRAM_POINT_SIZE_ARB=_C('GL_PROGRAM_POINT_SIZE_ARB',0x8642) +GL_TRIANGLES_ADJACENCY_ARB=_C('GL_TRIANGLES_ADJACENCY_ARB',0x000C) +GL_TRIANGLE_STRIP_ADJACENCY_ARB=_C('GL_TRIANGLE_STRIP_ADJACENCY_ARB',0x000D) +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLuint,_cs.GLint) +def glFramebufferTextureARB(target,attachment,texture,level):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLuint,_cs.GLint,_cs.GLenum) +def glFramebufferTextureFaceARB(target,attachment,texture,level,face):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLuint,_cs.GLint,_cs.GLint) +def glFramebufferTextureLayerARB(target,attachment,texture,level,layer):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLint) +def glProgramParameteriARB(program,pname,value):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/get_program_binary.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/get_program_binary.py new file mode 100644 index 00000000..8bec7a78 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/get_program_binary.py @@ -0,0 +1,26 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_get_program_binary' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_get_program_binary',error_checker=_errors._error_checker) +GL_NUM_PROGRAM_BINARY_FORMATS=_C('GL_NUM_PROGRAM_BINARY_FORMATS',0x87FE) +GL_PROGRAM_BINARY_FORMATS=_C('GL_PROGRAM_BINARY_FORMATS',0x87FF) +GL_PROGRAM_BINARY_LENGTH=_C('GL_PROGRAM_BINARY_LENGTH',0x8741) +GL_PROGRAM_BINARY_RETRIEVABLE_HINT=_C('GL_PROGRAM_BINARY_RETRIEVABLE_HINT',0x8257) +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizei,arrays.GLsizeiArray,arrays.GLuintArray,ctypes.c_void_p) +def glGetProgramBinary(program,bufSize,length,binaryFormat,binary):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,ctypes.c_void_p,_cs.GLsizei) +def glProgramBinary(program,binaryFormat,binary,length):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLint) +def glProgramParameteri(program,pname,value):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/get_texture_sub_image.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/get_texture_sub_image.py new file mode 100644 index 00000000..16d743df --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/get_texture_sub_image.py @@ -0,0 +1,20 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_get_texture_sub_image' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_get_texture_sub_image',error_checker=_errors._error_checker) + +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLsizei,_cs.GLsizei,_cs.GLsizei,ctypes.c_void_p) +def glGetCompressedTextureSubImage(texture,level,xoffset,yoffset,zoffset,width,height,depth,bufSize,pixels):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLsizei,_cs.GLsizei,_cs.GLenum,_cs.GLenum,_cs.GLsizei,ctypes.c_void_p) +def glGetTextureSubImage(texture,level,xoffset,yoffset,zoffset,width,height,depth,format,type,bufSize,pixels):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/gl_spirv.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/gl_spirv.py new file mode 100644 index 00000000..738f4943 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/gl_spirv.py @@ -0,0 +1,18 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_gl_spirv' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_gl_spirv',error_checker=_errors._error_checker) +GL_SHADER_BINARY_FORMAT_SPIR_V_ARB=_C('GL_SHADER_BINARY_FORMAT_SPIR_V_ARB',0x9551) +GL_SPIR_V_BINARY_ARB=_C('GL_SPIR_V_BINARY_ARB',0x9552) +@_f +@_p.types(None,_cs.GLuint,arrays.GLcharArray,_cs.GLuint,arrays.GLuintArray,arrays.GLuintArray) +def glSpecializeShaderARB(shader,pEntryPoint,numSpecializationConstants,pConstantIndex,pConstantValue):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/gpu_shader5.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/gpu_shader5.py new file mode 100644 index 00000000..a891be23 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/gpu_shader5.py @@ -0,0 +1,20 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_gpu_shader5' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_gpu_shader5',error_checker=_errors._error_checker) +GL_FRAGMENT_INTERPOLATION_OFFSET_BITS=_C('GL_FRAGMENT_INTERPOLATION_OFFSET_BITS',0x8E5D) +GL_GEOMETRY_SHADER_INVOCATIONS=_C('GL_GEOMETRY_SHADER_INVOCATIONS',0x887F) +GL_MAX_FRAGMENT_INTERPOLATION_OFFSET=_C('GL_MAX_FRAGMENT_INTERPOLATION_OFFSET',0x8E5C) +GL_MAX_GEOMETRY_SHADER_INVOCATIONS=_C('GL_MAX_GEOMETRY_SHADER_INVOCATIONS',0x8E5A) +GL_MAX_VERTEX_STREAMS=_C('GL_MAX_VERTEX_STREAMS',0x8E71) +GL_MIN_FRAGMENT_INTERPOLATION_OFFSET=_C('GL_MIN_FRAGMENT_INTERPOLATION_OFFSET',0x8E5B) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/gpu_shader_fp64.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/gpu_shader_fp64.py new file mode 100644 index 00000000..a53b32cb --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/gpu_shader_fp64.py @@ -0,0 +1,80 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_gpu_shader_fp64' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_gpu_shader_fp64',error_checker=_errors._error_checker) +GL_DOUBLE=_C('GL_DOUBLE',0x140A) +GL_DOUBLE_MAT2=_C('GL_DOUBLE_MAT2',0x8F46) +GL_DOUBLE_MAT2x3=_C('GL_DOUBLE_MAT2x3',0x8F49) +GL_DOUBLE_MAT2x4=_C('GL_DOUBLE_MAT2x4',0x8F4A) +GL_DOUBLE_MAT3=_C('GL_DOUBLE_MAT3',0x8F47) +GL_DOUBLE_MAT3x2=_C('GL_DOUBLE_MAT3x2',0x8F4B) +GL_DOUBLE_MAT3x4=_C('GL_DOUBLE_MAT3x4',0x8F4C) +GL_DOUBLE_MAT4=_C('GL_DOUBLE_MAT4',0x8F48) +GL_DOUBLE_MAT4x2=_C('GL_DOUBLE_MAT4x2',0x8F4D) +GL_DOUBLE_MAT4x3=_C('GL_DOUBLE_MAT4x3',0x8F4E) +GL_DOUBLE_VEC2=_C('GL_DOUBLE_VEC2',0x8FFC) +GL_DOUBLE_VEC3=_C('GL_DOUBLE_VEC3',0x8FFD) +GL_DOUBLE_VEC4=_C('GL_DOUBLE_VEC4',0x8FFE) +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,arrays.GLdoubleArray) +def glGetUniformdv(program,location,params):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLdouble) +def glUniform1d(location,x):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLsizei,arrays.GLdoubleArray) +def glUniform1dv(location,count,value):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLdouble,_cs.GLdouble) +def glUniform2d(location,x,y):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLsizei,arrays.GLdoubleArray) +def glUniform2dv(location,count,value):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLdouble,_cs.GLdouble,_cs.GLdouble) +def glUniform3d(location,x,y,z):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLsizei,arrays.GLdoubleArray) +def glUniform3dv(location,count,value):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLdouble,_cs.GLdouble,_cs.GLdouble,_cs.GLdouble) +def glUniform4d(location,x,y,z,w):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLsizei,arrays.GLdoubleArray) +def glUniform4dv(location,count,value):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLsizei,_cs.GLboolean,arrays.GLdoubleArray) +def glUniformMatrix2dv(location,count,transpose,value):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLsizei,_cs.GLboolean,arrays.GLdoubleArray) +def glUniformMatrix2x3dv(location,count,transpose,value):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLsizei,_cs.GLboolean,arrays.GLdoubleArray) +def glUniformMatrix2x4dv(location,count,transpose,value):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLsizei,_cs.GLboolean,arrays.GLdoubleArray) +def glUniformMatrix3dv(location,count,transpose,value):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLsizei,_cs.GLboolean,arrays.GLdoubleArray) +def glUniformMatrix3x2dv(location,count,transpose,value):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLsizei,_cs.GLboolean,arrays.GLdoubleArray) +def glUniformMatrix3x4dv(location,count,transpose,value):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLsizei,_cs.GLboolean,arrays.GLdoubleArray) +def glUniformMatrix4dv(location,count,transpose,value):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLsizei,_cs.GLboolean,arrays.GLdoubleArray) +def glUniformMatrix4x2dv(location,count,transpose,value):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLsizei,_cs.GLboolean,arrays.GLdoubleArray) +def glUniformMatrix4x3dv(location,count,transpose,value):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/gpu_shader_int64.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/gpu_shader_int64.py new file mode 100644 index 00000000..e14818c9 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/gpu_shader_int64.py @@ -0,0 +1,129 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_gpu_shader_int64' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_gpu_shader_int64',error_checker=_errors._error_checker) +GL_INT64_ARB=_C('GL_INT64_ARB',0x140E) +GL_INT64_VEC2_ARB=_C('GL_INT64_VEC2_ARB',0x8FE9) +GL_INT64_VEC3_ARB=_C('GL_INT64_VEC3_ARB',0x8FEA) +GL_INT64_VEC4_ARB=_C('GL_INT64_VEC4_ARB',0x8FEB) +GL_UNSIGNED_INT64_ARB=_C('GL_UNSIGNED_INT64_ARB',0x140F) +GL_UNSIGNED_INT64_VEC2_ARB=_C('GL_UNSIGNED_INT64_VEC2_ARB',0x8FF5) +GL_UNSIGNED_INT64_VEC3_ARB=_C('GL_UNSIGNED_INT64_VEC3_ARB',0x8FF6) +GL_UNSIGNED_INT64_VEC4_ARB=_C('GL_UNSIGNED_INT64_VEC4_ARB',0x8FF7) +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,arrays.GLint64Array) +def glGetUniformi64vARB(program,location,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,arrays.GLuint64Array) +def glGetUniformui64vARB(program,location,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLint64Array) +def glGetnUniformi64vARB(program,location,bufSize,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLuint64Array) +def glGetnUniformui64vARB(program,location,bufSize,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLint64) +def glProgramUniform1i64ARB(program,location,x):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLint64Array) +def glProgramUniform1i64vARB(program,location,count,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLuint64) +def glProgramUniform1ui64ARB(program,location,x):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLuint64Array) +def glProgramUniform1ui64vARB(program,location,count,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLint64,_cs.GLint64) +def glProgramUniform2i64ARB(program,location,x,y):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLint64Array) +def glProgramUniform2i64vARB(program,location,count,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLuint64,_cs.GLuint64) +def glProgramUniform2ui64ARB(program,location,x,y):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLuint64Array) +def glProgramUniform2ui64vARB(program,location,count,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLint64,_cs.GLint64,_cs.GLint64) +def glProgramUniform3i64ARB(program,location,x,y,z):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLint64Array) +def glProgramUniform3i64vARB(program,location,count,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLuint64,_cs.GLuint64,_cs.GLuint64) +def glProgramUniform3ui64ARB(program,location,x,y,z):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLuint64Array) +def glProgramUniform3ui64vARB(program,location,count,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLint64,_cs.GLint64,_cs.GLint64,_cs.GLint64) +def glProgramUniform4i64ARB(program,location,x,y,z,w):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLint64Array) +def glProgramUniform4i64vARB(program,location,count,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLuint64,_cs.GLuint64,_cs.GLuint64,_cs.GLuint64) +def glProgramUniform4ui64ARB(program,location,x,y,z,w):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLuint64Array) +def glProgramUniform4ui64vARB(program,location,count,value):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLint64) +def glUniform1i64ARB(location,x):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLsizei,arrays.GLint64Array) +def glUniform1i64vARB(location,count,value):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLuint64) +def glUniform1ui64ARB(location,x):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLsizei,arrays.GLuint64Array) +def glUniform1ui64vARB(location,count,value):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLint64,_cs.GLint64) +def glUniform2i64ARB(location,x,y):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLsizei,arrays.GLint64Array) +def glUniform2i64vARB(location,count,value):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLuint64,_cs.GLuint64) +def glUniform2ui64ARB(location,x,y):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLsizei,arrays.GLuint64Array) +def glUniform2ui64vARB(location,count,value):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLint64,_cs.GLint64,_cs.GLint64) +def glUniform3i64ARB(location,x,y,z):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLsizei,arrays.GLint64Array) +def glUniform3i64vARB(location,count,value):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLuint64,_cs.GLuint64,_cs.GLuint64) +def glUniform3ui64ARB(location,x,y,z):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLsizei,arrays.GLuint64Array) +def glUniform3ui64vARB(location,count,value):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLint64,_cs.GLint64,_cs.GLint64,_cs.GLint64) +def glUniform4i64ARB(location,x,y,z,w):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLsizei,arrays.GLint64Array) +def glUniform4i64vARB(location,count,value):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLuint64,_cs.GLuint64,_cs.GLuint64,_cs.GLuint64) +def glUniform4ui64ARB(location,x,y,z,w):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLsizei,arrays.GLuint64Array) +def glUniform4ui64vARB(location,count,value):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/half_float_pixel.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/half_float_pixel.py new file mode 100644 index 00000000..49665e23 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/half_float_pixel.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_half_float_pixel' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_half_float_pixel',error_checker=_errors._error_checker) +GL_HALF_FLOAT_ARB=_C('GL_HALF_FLOAT_ARB',0x140B) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/half_float_vertex.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/half_float_vertex.py new file mode 100644 index 00000000..b1ae42b5 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/half_float_vertex.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_half_float_vertex' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_half_float_vertex',error_checker=_errors._error_checker) +GL_HALF_FLOAT=_C('GL_HALF_FLOAT',0x140B) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/imaging.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/imaging.py new file mode 100644 index 00000000..429122b7 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/imaging.py @@ -0,0 +1,190 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_imaging' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_imaging',error_checker=_errors._error_checker) +GL_BLEND_COLOR=_C('GL_BLEND_COLOR',0x8005) +GL_BLEND_EQUATION=_C('GL_BLEND_EQUATION',0x8009) +GL_COLOR_MATRIX=_C('GL_COLOR_MATRIX',0x80B1) +GL_COLOR_MATRIX_STACK_DEPTH=_C('GL_COLOR_MATRIX_STACK_DEPTH',0x80B2) +GL_COLOR_TABLE=_C('GL_COLOR_TABLE',0x80D0) +GL_COLOR_TABLE_ALPHA_SIZE=_C('GL_COLOR_TABLE_ALPHA_SIZE',0x80DD) +GL_COLOR_TABLE_BIAS=_C('GL_COLOR_TABLE_BIAS',0x80D7) +GL_COLOR_TABLE_BLUE_SIZE=_C('GL_COLOR_TABLE_BLUE_SIZE',0x80DC) +GL_COLOR_TABLE_FORMAT=_C('GL_COLOR_TABLE_FORMAT',0x80D8) +GL_COLOR_TABLE_GREEN_SIZE=_C('GL_COLOR_TABLE_GREEN_SIZE',0x80DB) +GL_COLOR_TABLE_INTENSITY_SIZE=_C('GL_COLOR_TABLE_INTENSITY_SIZE',0x80DF) +GL_COLOR_TABLE_LUMINANCE_SIZE=_C('GL_COLOR_TABLE_LUMINANCE_SIZE',0x80DE) +GL_COLOR_TABLE_RED_SIZE=_C('GL_COLOR_TABLE_RED_SIZE',0x80DA) +GL_COLOR_TABLE_SCALE=_C('GL_COLOR_TABLE_SCALE',0x80D6) +GL_COLOR_TABLE_WIDTH=_C('GL_COLOR_TABLE_WIDTH',0x80D9) +GL_CONSTANT_ALPHA=_C('GL_CONSTANT_ALPHA',0x8003) +GL_CONSTANT_BORDER=_C('GL_CONSTANT_BORDER',0x8151) +GL_CONSTANT_COLOR=_C('GL_CONSTANT_COLOR',0x8001) +GL_CONVOLUTION_1D=_C('GL_CONVOLUTION_1D',0x8010) +GL_CONVOLUTION_2D=_C('GL_CONVOLUTION_2D',0x8011) +GL_CONVOLUTION_BORDER_COLOR=_C('GL_CONVOLUTION_BORDER_COLOR',0x8154) +GL_CONVOLUTION_BORDER_MODE=_C('GL_CONVOLUTION_BORDER_MODE',0x8013) +GL_CONVOLUTION_FILTER_BIAS=_C('GL_CONVOLUTION_FILTER_BIAS',0x8015) +GL_CONVOLUTION_FILTER_SCALE=_C('GL_CONVOLUTION_FILTER_SCALE',0x8014) +GL_CONVOLUTION_FORMAT=_C('GL_CONVOLUTION_FORMAT',0x8017) +GL_CONVOLUTION_HEIGHT=_C('GL_CONVOLUTION_HEIGHT',0x8019) +GL_CONVOLUTION_WIDTH=_C('GL_CONVOLUTION_WIDTH',0x8018) +GL_FUNC_ADD=_C('GL_FUNC_ADD',0x8006) +GL_FUNC_REVERSE_SUBTRACT=_C('GL_FUNC_REVERSE_SUBTRACT',0x800B) +GL_FUNC_SUBTRACT=_C('GL_FUNC_SUBTRACT',0x800A) +GL_HISTOGRAM=_C('GL_HISTOGRAM',0x8024) +GL_HISTOGRAM_ALPHA_SIZE=_C('GL_HISTOGRAM_ALPHA_SIZE',0x802B) +GL_HISTOGRAM_BLUE_SIZE=_C('GL_HISTOGRAM_BLUE_SIZE',0x802A) +GL_HISTOGRAM_FORMAT=_C('GL_HISTOGRAM_FORMAT',0x8027) +GL_HISTOGRAM_GREEN_SIZE=_C('GL_HISTOGRAM_GREEN_SIZE',0x8029) +GL_HISTOGRAM_LUMINANCE_SIZE=_C('GL_HISTOGRAM_LUMINANCE_SIZE',0x802C) +GL_HISTOGRAM_RED_SIZE=_C('GL_HISTOGRAM_RED_SIZE',0x8028) +GL_HISTOGRAM_SINK=_C('GL_HISTOGRAM_SINK',0x802D) +GL_HISTOGRAM_WIDTH=_C('GL_HISTOGRAM_WIDTH',0x8026) +GL_MAX=_C('GL_MAX',0x8008) +GL_MAX_COLOR_MATRIX_STACK_DEPTH=_C('GL_MAX_COLOR_MATRIX_STACK_DEPTH',0x80B3) +GL_MAX_CONVOLUTION_HEIGHT=_C('GL_MAX_CONVOLUTION_HEIGHT',0x801B) +GL_MAX_CONVOLUTION_WIDTH=_C('GL_MAX_CONVOLUTION_WIDTH',0x801A) +GL_MIN=_C('GL_MIN',0x8007) +GL_MINMAX=_C('GL_MINMAX',0x802E) +GL_MINMAX_FORMAT=_C('GL_MINMAX_FORMAT',0x802F) +GL_MINMAX_SINK=_C('GL_MINMAX_SINK',0x8030) +GL_ONE_MINUS_CONSTANT_ALPHA=_C('GL_ONE_MINUS_CONSTANT_ALPHA',0x8004) +GL_ONE_MINUS_CONSTANT_COLOR=_C('GL_ONE_MINUS_CONSTANT_COLOR',0x8002) +GL_POST_COLOR_MATRIX_ALPHA_BIAS=_C('GL_POST_COLOR_MATRIX_ALPHA_BIAS',0x80BB) +GL_POST_COLOR_MATRIX_ALPHA_SCALE=_C('GL_POST_COLOR_MATRIX_ALPHA_SCALE',0x80B7) +GL_POST_COLOR_MATRIX_BLUE_BIAS=_C('GL_POST_COLOR_MATRIX_BLUE_BIAS',0x80BA) +GL_POST_COLOR_MATRIX_BLUE_SCALE=_C('GL_POST_COLOR_MATRIX_BLUE_SCALE',0x80B6) +GL_POST_COLOR_MATRIX_COLOR_TABLE=_C('GL_POST_COLOR_MATRIX_COLOR_TABLE',0x80D2) +GL_POST_COLOR_MATRIX_GREEN_BIAS=_C('GL_POST_COLOR_MATRIX_GREEN_BIAS',0x80B9) +GL_POST_COLOR_MATRIX_GREEN_SCALE=_C('GL_POST_COLOR_MATRIX_GREEN_SCALE',0x80B5) +GL_POST_COLOR_MATRIX_RED_BIAS=_C('GL_POST_COLOR_MATRIX_RED_BIAS',0x80B8) +GL_POST_COLOR_MATRIX_RED_SCALE=_C('GL_POST_COLOR_MATRIX_RED_SCALE',0x80B4) +GL_POST_CONVOLUTION_ALPHA_BIAS=_C('GL_POST_CONVOLUTION_ALPHA_BIAS',0x8023) +GL_POST_CONVOLUTION_ALPHA_SCALE=_C('GL_POST_CONVOLUTION_ALPHA_SCALE',0x801F) +GL_POST_CONVOLUTION_BLUE_BIAS=_C('GL_POST_CONVOLUTION_BLUE_BIAS',0x8022) +GL_POST_CONVOLUTION_BLUE_SCALE=_C('GL_POST_CONVOLUTION_BLUE_SCALE',0x801E) +GL_POST_CONVOLUTION_COLOR_TABLE=_C('GL_POST_CONVOLUTION_COLOR_TABLE',0x80D1) +GL_POST_CONVOLUTION_GREEN_BIAS=_C('GL_POST_CONVOLUTION_GREEN_BIAS',0x8021) +GL_POST_CONVOLUTION_GREEN_SCALE=_C('GL_POST_CONVOLUTION_GREEN_SCALE',0x801D) +GL_POST_CONVOLUTION_RED_BIAS=_C('GL_POST_CONVOLUTION_RED_BIAS',0x8020) +GL_POST_CONVOLUTION_RED_SCALE=_C('GL_POST_CONVOLUTION_RED_SCALE',0x801C) +GL_PROXY_COLOR_TABLE=_C('GL_PROXY_COLOR_TABLE',0x80D3) +GL_PROXY_HISTOGRAM=_C('GL_PROXY_HISTOGRAM',0x8025) +GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE=_C('GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE',0x80D5) +GL_PROXY_POST_CONVOLUTION_COLOR_TABLE=_C('GL_PROXY_POST_CONVOLUTION_COLOR_TABLE',0x80D4) +GL_REDUCE=_C('GL_REDUCE',0x8016) +GL_REPLICATE_BORDER=_C('GL_REPLICATE_BORDER',0x8153) +GL_SEPARABLE_2D=_C('GL_SEPARABLE_2D',0x8012) +GL_TABLE_TOO_LARGE=_C('GL_TABLE_TOO_LARGE',0x8031) +@_f +@_p.types(None,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat) +def glBlendColor(red,green,blue,alpha):pass +@_f +@_p.types(None,_cs.GLenum) +def glBlendEquation(mode):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizei,_cs.GLsizei,_cs.GLenum,_cs.GLenum,ctypes.c_void_p) +def glColorSubTable(target,start,count,format,type,data):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLsizei,_cs.GLenum,_cs.GLenum,ctypes.c_void_p) +def glColorTable(target,internalformat,width,format,type,table):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLfloatArray) +def glColorTableParameterfv(target,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLintArray) +def glColorTableParameteriv(target,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLsizei,_cs.GLenum,_cs.GLenum,ctypes.c_void_p) +def glConvolutionFilter1D(target,internalformat,width,format,type,image):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLsizei,_cs.GLsizei,_cs.GLenum,_cs.GLenum,ctypes.c_void_p) +def glConvolutionFilter2D(target,internalformat,width,height,format,type,image):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLfloat) +def glConvolutionParameterf(target,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLfloatArray) +def glConvolutionParameterfv(target,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLint) +def glConvolutionParameteri(target,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLintArray) +def glConvolutionParameteriv(target,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizei,_cs.GLint,_cs.GLint,_cs.GLsizei) +def glCopyColorSubTable(target,start,x,y,width):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLint,_cs.GLint,_cs.GLsizei) +def glCopyColorTable(target,internalformat,x,y,width):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLint,_cs.GLint,_cs.GLsizei) +def glCopyConvolutionFilter1D(target,internalformat,x,y,width):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLsizei) +def glCopyConvolutionFilter2D(target,internalformat,x,y,width,height):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLenum,ctypes.c_void_p) +def glGetColorTable(target,format,type,table):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLfloatArray) +def glGetColorTableParameterfv(target,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLintArray) +def glGetColorTableParameteriv(target,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLenum,ctypes.c_void_p) +def glGetConvolutionFilter(target,format,type,image):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLfloatArray) +def glGetConvolutionParameterfv(target,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLintArray) +def glGetConvolutionParameteriv(target,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLboolean,_cs.GLenum,_cs.GLenum,ctypes.c_void_p) +def glGetHistogram(target,reset,format,type,values):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLfloatArray) +def glGetHistogramParameterfv(target,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLintArray) +def glGetHistogramParameteriv(target,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLboolean,_cs.GLenum,_cs.GLenum,ctypes.c_void_p) +def glGetMinmax(target,reset,format,type,values):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLfloatArray) +def glGetMinmaxParameterfv(target,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLintArray) +def glGetMinmaxParameteriv(target,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLenum,ctypes.c_void_p,ctypes.c_void_p,ctypes.c_void_p) +def glGetSeparableFilter(target,format,type,row,column,span):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizei,_cs.GLenum,_cs.GLboolean) +def glHistogram(target,width,internalformat,sink):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLboolean) +def glMinmax(target,internalformat,sink):pass +@_f +@_p.types(None,_cs.GLenum) +def glResetHistogram(target):pass +@_f +@_p.types(None,_cs.GLenum) +def glResetMinmax(target):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLsizei,_cs.GLsizei,_cs.GLenum,_cs.GLenum,ctypes.c_void_p,ctypes.c_void_p) +def glSeparableFilter2D(target,internalformat,width,height,format,type,row,column):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/indirect_parameters.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/indirect_parameters.py new file mode 100644 index 00000000..0dc60183 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/indirect_parameters.py @@ -0,0 +1,21 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_indirect_parameters' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_indirect_parameters',error_checker=_errors._error_checker) +GL_PARAMETER_BUFFER_ARB=_C('GL_PARAMETER_BUFFER_ARB',0x80EE) +GL_PARAMETER_BUFFER_BINDING_ARB=_C('GL_PARAMETER_BUFFER_BINDING_ARB',0x80EF) +@_f +@_p.types(None,_cs.GLenum,ctypes.c_void_p,_cs.GLintptr,_cs.GLsizei,_cs.GLsizei) +def glMultiDrawArraysIndirectCountARB(mode,indirect,drawcount,maxdrawcount,stride):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,ctypes.c_void_p,_cs.GLintptr,_cs.GLsizei,_cs.GLsizei) +def glMultiDrawElementsIndirectCountARB(mode,type,indirect,drawcount,maxdrawcount,stride):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/instanced_arrays.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/instanced_arrays.py new file mode 100644 index 00000000..98dd995c --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/instanced_arrays.py @@ -0,0 +1,17 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_instanced_arrays' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_instanced_arrays',error_checker=_errors._error_checker) +GL_VERTEX_ATTRIB_ARRAY_DIVISOR_ARB=_C('GL_VERTEX_ATTRIB_ARRAY_DIVISOR_ARB',0x88FE) +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint) +def glVertexAttribDivisorARB(index,divisor):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/internalformat_query.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/internalformat_query.py new file mode 100644 index 00000000..0dc4bc8f --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/internalformat_query.py @@ -0,0 +1,17 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_internalformat_query' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_internalformat_query',error_checker=_errors._error_checker) +GL_NUM_SAMPLE_COUNTS=_C('GL_NUM_SAMPLE_COUNTS',0x9380) +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLenum,_cs.GLsizei,arrays.GLintArray) +def glGetInternalformativ(target,internalformat,pname,bufSize,params):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/internalformat_query2.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/internalformat_query2.py new file mode 100644 index 00000000..d475a9ef --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/internalformat_query2.py @@ -0,0 +1,150 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_internalformat_query2' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_internalformat_query2',error_checker=_errors._error_checker) +GL_AUTO_GENERATE_MIPMAP=_C('GL_AUTO_GENERATE_MIPMAP',0x8295) +GL_CAVEAT_SUPPORT=_C('GL_CAVEAT_SUPPORT',0x82B8) +GL_CLEAR_BUFFER=_C('GL_CLEAR_BUFFER',0x82B4) +GL_COLOR_COMPONENTS=_C('GL_COLOR_COMPONENTS',0x8283) +GL_COLOR_ENCODING=_C('GL_COLOR_ENCODING',0x8296) +GL_COLOR_RENDERABLE=_C('GL_COLOR_RENDERABLE',0x8286) +GL_COMPUTE_TEXTURE=_C('GL_COMPUTE_TEXTURE',0x82A0) +GL_DEPTH_COMPONENTS=_C('GL_DEPTH_COMPONENTS',0x8284) +GL_DEPTH_RENDERABLE=_C('GL_DEPTH_RENDERABLE',0x8287) +GL_FILTER=_C('GL_FILTER',0x829A) +GL_FRAGMENT_TEXTURE=_C('GL_FRAGMENT_TEXTURE',0x829F) +GL_FRAMEBUFFER_BLEND=_C('GL_FRAMEBUFFER_BLEND',0x828B) +GL_FRAMEBUFFER_RENDERABLE=_C('GL_FRAMEBUFFER_RENDERABLE',0x8289) +GL_FRAMEBUFFER_RENDERABLE_LAYERED=_C('GL_FRAMEBUFFER_RENDERABLE_LAYERED',0x828A) +GL_FULL_SUPPORT=_C('GL_FULL_SUPPORT',0x82B7) +GL_GEOMETRY_TEXTURE=_C('GL_GEOMETRY_TEXTURE',0x829E) +GL_GET_TEXTURE_IMAGE_FORMAT=_C('GL_GET_TEXTURE_IMAGE_FORMAT',0x8291) +GL_GET_TEXTURE_IMAGE_TYPE=_C('GL_GET_TEXTURE_IMAGE_TYPE',0x8292) +GL_IMAGE_CLASS_10_10_10_2=_C('GL_IMAGE_CLASS_10_10_10_2',0x82C3) +GL_IMAGE_CLASS_11_11_10=_C('GL_IMAGE_CLASS_11_11_10',0x82C2) +GL_IMAGE_CLASS_1_X_16=_C('GL_IMAGE_CLASS_1_X_16',0x82BE) +GL_IMAGE_CLASS_1_X_32=_C('GL_IMAGE_CLASS_1_X_32',0x82BB) +GL_IMAGE_CLASS_1_X_8=_C('GL_IMAGE_CLASS_1_X_8',0x82C1) +GL_IMAGE_CLASS_2_X_16=_C('GL_IMAGE_CLASS_2_X_16',0x82BD) +GL_IMAGE_CLASS_2_X_32=_C('GL_IMAGE_CLASS_2_X_32',0x82BA) +GL_IMAGE_CLASS_2_X_8=_C('GL_IMAGE_CLASS_2_X_8',0x82C0) +GL_IMAGE_CLASS_4_X_16=_C('GL_IMAGE_CLASS_4_X_16',0x82BC) +GL_IMAGE_CLASS_4_X_32=_C('GL_IMAGE_CLASS_4_X_32',0x82B9) +GL_IMAGE_CLASS_4_X_8=_C('GL_IMAGE_CLASS_4_X_8',0x82BF) +GL_IMAGE_COMPATIBILITY_CLASS=_C('GL_IMAGE_COMPATIBILITY_CLASS',0x82A8) +GL_IMAGE_FORMAT_COMPATIBILITY_TYPE=_C('GL_IMAGE_FORMAT_COMPATIBILITY_TYPE',0x90C7) +GL_IMAGE_PIXEL_FORMAT=_C('GL_IMAGE_PIXEL_FORMAT',0x82A9) +GL_IMAGE_PIXEL_TYPE=_C('GL_IMAGE_PIXEL_TYPE',0x82AA) +GL_IMAGE_TEXEL_SIZE=_C('GL_IMAGE_TEXEL_SIZE',0x82A7) +GL_INTERNALFORMAT_ALPHA_SIZE=_C('GL_INTERNALFORMAT_ALPHA_SIZE',0x8274) +GL_INTERNALFORMAT_ALPHA_TYPE=_C('GL_INTERNALFORMAT_ALPHA_TYPE',0x827B) +GL_INTERNALFORMAT_BLUE_SIZE=_C('GL_INTERNALFORMAT_BLUE_SIZE',0x8273) +GL_INTERNALFORMAT_BLUE_TYPE=_C('GL_INTERNALFORMAT_BLUE_TYPE',0x827A) +GL_INTERNALFORMAT_DEPTH_SIZE=_C('GL_INTERNALFORMAT_DEPTH_SIZE',0x8275) +GL_INTERNALFORMAT_DEPTH_TYPE=_C('GL_INTERNALFORMAT_DEPTH_TYPE',0x827C) +GL_INTERNALFORMAT_GREEN_SIZE=_C('GL_INTERNALFORMAT_GREEN_SIZE',0x8272) +GL_INTERNALFORMAT_GREEN_TYPE=_C('GL_INTERNALFORMAT_GREEN_TYPE',0x8279) +GL_INTERNALFORMAT_PREFERRED=_C('GL_INTERNALFORMAT_PREFERRED',0x8270) +GL_INTERNALFORMAT_RED_SIZE=_C('GL_INTERNALFORMAT_RED_SIZE',0x8271) +GL_INTERNALFORMAT_RED_TYPE=_C('GL_INTERNALFORMAT_RED_TYPE',0x8278) +GL_INTERNALFORMAT_SHARED_SIZE=_C('GL_INTERNALFORMAT_SHARED_SIZE',0x8277) +GL_INTERNALFORMAT_STENCIL_SIZE=_C('GL_INTERNALFORMAT_STENCIL_SIZE',0x8276) +GL_INTERNALFORMAT_STENCIL_TYPE=_C('GL_INTERNALFORMAT_STENCIL_TYPE',0x827D) +GL_INTERNALFORMAT_SUPPORTED=_C('GL_INTERNALFORMAT_SUPPORTED',0x826F) +GL_MANUAL_GENERATE_MIPMAP=_C('GL_MANUAL_GENERATE_MIPMAP',0x8294) +GL_MAX_COMBINED_DIMENSIONS=_C('GL_MAX_COMBINED_DIMENSIONS',0x8282) +GL_MAX_DEPTH=_C('GL_MAX_DEPTH',0x8280) +GL_MAX_HEIGHT=_C('GL_MAX_HEIGHT',0x827F) +GL_MAX_LAYERS=_C('GL_MAX_LAYERS',0x8281) +GL_MAX_WIDTH=_C('GL_MAX_WIDTH',0x827E) +GL_MIPMAP=_C('GL_MIPMAP',0x8293) +GL_NUM_SAMPLE_COUNTS=_C('GL_NUM_SAMPLE_COUNTS',0x9380) +GL_READ_PIXELS=_C('GL_READ_PIXELS',0x828C) +GL_READ_PIXELS_FORMAT=_C('GL_READ_PIXELS_FORMAT',0x828D) +GL_READ_PIXELS_TYPE=_C('GL_READ_PIXELS_TYPE',0x828E) +GL_RENDERBUFFER=_C('GL_RENDERBUFFER',0x8D41) +GL_SAMPLES=_C('GL_SAMPLES',0x80A9) +GL_SHADER_IMAGE_ATOMIC=_C('GL_SHADER_IMAGE_ATOMIC',0x82A6) +GL_SHADER_IMAGE_LOAD=_C('GL_SHADER_IMAGE_LOAD',0x82A4) +GL_SHADER_IMAGE_STORE=_C('GL_SHADER_IMAGE_STORE',0x82A5) +GL_SIMULTANEOUS_TEXTURE_AND_DEPTH_TEST=_C('GL_SIMULTANEOUS_TEXTURE_AND_DEPTH_TEST',0x82AC) +GL_SIMULTANEOUS_TEXTURE_AND_DEPTH_WRITE=_C('GL_SIMULTANEOUS_TEXTURE_AND_DEPTH_WRITE',0x82AE) +GL_SIMULTANEOUS_TEXTURE_AND_STENCIL_TEST=_C('GL_SIMULTANEOUS_TEXTURE_AND_STENCIL_TEST',0x82AD) +GL_SIMULTANEOUS_TEXTURE_AND_STENCIL_WRITE=_C('GL_SIMULTANEOUS_TEXTURE_AND_STENCIL_WRITE',0x82AF) +GL_SRGB_DECODE_ARB=_C('GL_SRGB_DECODE_ARB',0x8299) +GL_SRGB_READ=_C('GL_SRGB_READ',0x8297) +GL_SRGB_WRITE=_C('GL_SRGB_WRITE',0x8298) +GL_STENCIL_COMPONENTS=_C('GL_STENCIL_COMPONENTS',0x8285) +GL_STENCIL_RENDERABLE=_C('GL_STENCIL_RENDERABLE',0x8288) +GL_TESS_CONTROL_TEXTURE=_C('GL_TESS_CONTROL_TEXTURE',0x829C) +GL_TESS_EVALUATION_TEXTURE=_C('GL_TESS_EVALUATION_TEXTURE',0x829D) +GL_TEXTURE_1D=_C('GL_TEXTURE_1D',0x0DE0) +GL_TEXTURE_1D_ARRAY=_C('GL_TEXTURE_1D_ARRAY',0x8C18) +GL_TEXTURE_2D=_C('GL_TEXTURE_2D',0x0DE1) +GL_TEXTURE_2D_ARRAY=_C('GL_TEXTURE_2D_ARRAY',0x8C1A) +GL_TEXTURE_2D_MULTISAMPLE=_C('GL_TEXTURE_2D_MULTISAMPLE',0x9100) +GL_TEXTURE_2D_MULTISAMPLE_ARRAY=_C('GL_TEXTURE_2D_MULTISAMPLE_ARRAY',0x9102) +GL_TEXTURE_3D=_C('GL_TEXTURE_3D',0x806F) +GL_TEXTURE_BUFFER=_C('GL_TEXTURE_BUFFER',0x8C2A) +GL_TEXTURE_COMPRESSED=_C('GL_TEXTURE_COMPRESSED',0x86A1) +GL_TEXTURE_COMPRESSED_BLOCK_HEIGHT=_C('GL_TEXTURE_COMPRESSED_BLOCK_HEIGHT',0x82B2) +GL_TEXTURE_COMPRESSED_BLOCK_SIZE=_C('GL_TEXTURE_COMPRESSED_BLOCK_SIZE',0x82B3) +GL_TEXTURE_COMPRESSED_BLOCK_WIDTH=_C('GL_TEXTURE_COMPRESSED_BLOCK_WIDTH',0x82B1) +GL_TEXTURE_CUBE_MAP=_C('GL_TEXTURE_CUBE_MAP',0x8513) +GL_TEXTURE_CUBE_MAP_ARRAY=_C('GL_TEXTURE_CUBE_MAP_ARRAY',0x9009) +GL_TEXTURE_GATHER=_C('GL_TEXTURE_GATHER',0x82A2) +GL_TEXTURE_GATHER_SHADOW=_C('GL_TEXTURE_GATHER_SHADOW',0x82A3) +GL_TEXTURE_IMAGE_FORMAT=_C('GL_TEXTURE_IMAGE_FORMAT',0x828F) +GL_TEXTURE_IMAGE_TYPE=_C('GL_TEXTURE_IMAGE_TYPE',0x8290) +GL_TEXTURE_RECTANGLE=_C('GL_TEXTURE_RECTANGLE',0x84F5) +GL_TEXTURE_SHADOW=_C('GL_TEXTURE_SHADOW',0x82A1) +GL_TEXTURE_VIEW=_C('GL_TEXTURE_VIEW',0x82B5) +GL_VERTEX_TEXTURE=_C('GL_VERTEX_TEXTURE',0x829B) +GL_VIEW_CLASS_128_BITS=_C('GL_VIEW_CLASS_128_BITS',0x82C4) +GL_VIEW_CLASS_16_BITS=_C('GL_VIEW_CLASS_16_BITS',0x82CA) +GL_VIEW_CLASS_24_BITS=_C('GL_VIEW_CLASS_24_BITS',0x82C9) +GL_VIEW_CLASS_32_BITS=_C('GL_VIEW_CLASS_32_BITS',0x82C8) +GL_VIEW_CLASS_48_BITS=_C('GL_VIEW_CLASS_48_BITS',0x82C7) +GL_VIEW_CLASS_64_BITS=_C('GL_VIEW_CLASS_64_BITS',0x82C6) +GL_VIEW_CLASS_8_BITS=_C('GL_VIEW_CLASS_8_BITS',0x82CB) +GL_VIEW_CLASS_96_BITS=_C('GL_VIEW_CLASS_96_BITS',0x82C5) +GL_VIEW_CLASS_ASTC_10x10_RGBA=_C('GL_VIEW_CLASS_ASTC_10x10_RGBA',0x9393) +GL_VIEW_CLASS_ASTC_10x5_RGBA=_C('GL_VIEW_CLASS_ASTC_10x5_RGBA',0x9390) +GL_VIEW_CLASS_ASTC_10x6_RGBA=_C('GL_VIEW_CLASS_ASTC_10x6_RGBA',0x9391) +GL_VIEW_CLASS_ASTC_10x8_RGBA=_C('GL_VIEW_CLASS_ASTC_10x8_RGBA',0x9392) +GL_VIEW_CLASS_ASTC_12x10_RGBA=_C('GL_VIEW_CLASS_ASTC_12x10_RGBA',0x9394) +GL_VIEW_CLASS_ASTC_12x12_RGBA=_C('GL_VIEW_CLASS_ASTC_12x12_RGBA',0x9395) +GL_VIEW_CLASS_ASTC_4x4_RGBA=_C('GL_VIEW_CLASS_ASTC_4x4_RGBA',0x9388) +GL_VIEW_CLASS_ASTC_5x4_RGBA=_C('GL_VIEW_CLASS_ASTC_5x4_RGBA',0x9389) +GL_VIEW_CLASS_ASTC_5x5_RGBA=_C('GL_VIEW_CLASS_ASTC_5x5_RGBA',0x938A) +GL_VIEW_CLASS_ASTC_6x5_RGBA=_C('GL_VIEW_CLASS_ASTC_6x5_RGBA',0x938B) +GL_VIEW_CLASS_ASTC_6x6_RGBA=_C('GL_VIEW_CLASS_ASTC_6x6_RGBA',0x938C) +GL_VIEW_CLASS_ASTC_8x5_RGBA=_C('GL_VIEW_CLASS_ASTC_8x5_RGBA',0x938D) +GL_VIEW_CLASS_ASTC_8x6_RGBA=_C('GL_VIEW_CLASS_ASTC_8x6_RGBA',0x938E) +GL_VIEW_CLASS_ASTC_8x8_RGBA=_C('GL_VIEW_CLASS_ASTC_8x8_RGBA',0x938F) +GL_VIEW_CLASS_BPTC_FLOAT=_C('GL_VIEW_CLASS_BPTC_FLOAT',0x82D3) +GL_VIEW_CLASS_BPTC_UNORM=_C('GL_VIEW_CLASS_BPTC_UNORM',0x82D2) +GL_VIEW_CLASS_EAC_R11=_C('GL_VIEW_CLASS_EAC_R11',0x9383) +GL_VIEW_CLASS_EAC_RG11=_C('GL_VIEW_CLASS_EAC_RG11',0x9384) +GL_VIEW_CLASS_ETC2_EAC_RGBA=_C('GL_VIEW_CLASS_ETC2_EAC_RGBA',0x9387) +GL_VIEW_CLASS_ETC2_RGB=_C('GL_VIEW_CLASS_ETC2_RGB',0x9385) +GL_VIEW_CLASS_ETC2_RGBA=_C('GL_VIEW_CLASS_ETC2_RGBA',0x9386) +GL_VIEW_CLASS_RGTC1_RED=_C('GL_VIEW_CLASS_RGTC1_RED',0x82D0) +GL_VIEW_CLASS_RGTC2_RG=_C('GL_VIEW_CLASS_RGTC2_RG',0x82D1) +GL_VIEW_CLASS_S3TC_DXT1_RGB=_C('GL_VIEW_CLASS_S3TC_DXT1_RGB',0x82CC) +GL_VIEW_CLASS_S3TC_DXT1_RGBA=_C('GL_VIEW_CLASS_S3TC_DXT1_RGBA',0x82CD) +GL_VIEW_CLASS_S3TC_DXT3_RGBA=_C('GL_VIEW_CLASS_S3TC_DXT3_RGBA',0x82CE) +GL_VIEW_CLASS_S3TC_DXT5_RGBA=_C('GL_VIEW_CLASS_S3TC_DXT5_RGBA',0x82CF) +GL_VIEW_COMPATIBILITY_CLASS=_C('GL_VIEW_COMPATIBILITY_CLASS',0x82B6) +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLenum,_cs.GLsizei,arrays.GLint64Array) +def glGetInternalformati64v(target,internalformat,pname,bufSize,params):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/invalidate_subdata.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/invalidate_subdata.py new file mode 100644 index 00000000..bf2c134a --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/invalidate_subdata.py @@ -0,0 +1,32 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_invalidate_subdata' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_invalidate_subdata',error_checker=_errors._error_checker) + +@_f +@_p.types(None,_cs.GLuint) +def glInvalidateBufferData(buffer):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLintptr,_cs.GLsizeiptr) +def glInvalidateBufferSubData(buffer,offset,length):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizei,arrays.GLuintArray) +def glInvalidateFramebuffer(target,numAttachments,attachments):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizei,arrays.GLuintArray,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLsizei) +def glInvalidateSubFramebuffer(target,numAttachments,attachments,x,y,width,height):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint) +def glInvalidateTexImage(texture,level):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLsizei,_cs.GLsizei) +def glInvalidateTexSubImage(texture,level,xoffset,yoffset,zoffset,width,height,depth):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/map_buffer_alignment.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/map_buffer_alignment.py new file mode 100644 index 00000000..40cddc94 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/map_buffer_alignment.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_map_buffer_alignment' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_map_buffer_alignment',error_checker=_errors._error_checker) +GL_MIN_MAP_BUFFER_ALIGNMENT=_C('GL_MIN_MAP_BUFFER_ALIGNMENT',0x90BC) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/map_buffer_range.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/map_buffer_range.py new file mode 100644 index 00000000..f7a139e4 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/map_buffer_range.py @@ -0,0 +1,25 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_map_buffer_range' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_map_buffer_range',error_checker=_errors._error_checker) +GL_MAP_FLUSH_EXPLICIT_BIT=_C('GL_MAP_FLUSH_EXPLICIT_BIT',0x0010) +GL_MAP_INVALIDATE_BUFFER_BIT=_C('GL_MAP_INVALIDATE_BUFFER_BIT',0x0008) +GL_MAP_INVALIDATE_RANGE_BIT=_C('GL_MAP_INVALIDATE_RANGE_BIT',0x0004) +GL_MAP_READ_BIT=_C('GL_MAP_READ_BIT',0x0001) +GL_MAP_UNSYNCHRONIZED_BIT=_C('GL_MAP_UNSYNCHRONIZED_BIT',0x0020) +GL_MAP_WRITE_BIT=_C('GL_MAP_WRITE_BIT',0x0002) +@_f +@_p.types(None,_cs.GLenum,_cs.GLintptr,_cs.GLsizeiptr) +def glFlushMappedBufferRange(target,offset,length):pass +@_f +@_p.types(ctypes.c_void_p,_cs.GLenum,_cs.GLintptr,_cs.GLsizeiptr,_cs.GLbitfield) +def glMapBufferRange(target,offset,length,access):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/matrix_palette.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/matrix_palette.py new file mode 100644 index 00000000..dced5fb2 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/matrix_palette.py @@ -0,0 +1,38 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_matrix_palette' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_matrix_palette',error_checker=_errors._error_checker) +GL_CURRENT_MATRIX_INDEX_ARB=_C('GL_CURRENT_MATRIX_INDEX_ARB',0x8845) +GL_CURRENT_PALETTE_MATRIX_ARB=_C('GL_CURRENT_PALETTE_MATRIX_ARB',0x8843) +GL_MATRIX_INDEX_ARRAY_ARB=_C('GL_MATRIX_INDEX_ARRAY_ARB',0x8844) +GL_MATRIX_INDEX_ARRAY_POINTER_ARB=_C('GL_MATRIX_INDEX_ARRAY_POINTER_ARB',0x8849) +GL_MATRIX_INDEX_ARRAY_SIZE_ARB=_C('GL_MATRIX_INDEX_ARRAY_SIZE_ARB',0x8846) +GL_MATRIX_INDEX_ARRAY_STRIDE_ARB=_C('GL_MATRIX_INDEX_ARRAY_STRIDE_ARB',0x8848) +GL_MATRIX_INDEX_ARRAY_TYPE_ARB=_C('GL_MATRIX_INDEX_ARRAY_TYPE_ARB',0x8847) +GL_MATRIX_PALETTE_ARB=_C('GL_MATRIX_PALETTE_ARB',0x8840) +GL_MAX_MATRIX_PALETTE_STACK_DEPTH_ARB=_C('GL_MAX_MATRIX_PALETTE_STACK_DEPTH_ARB',0x8841) +GL_MAX_PALETTE_MATRICES_ARB=_C('GL_MAX_PALETTE_MATRICES_ARB',0x8842) +@_f +@_p.types(None,_cs.GLint) +def glCurrentPaletteMatrixARB(index):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLenum,_cs.GLsizei,ctypes.c_void_p) +def glMatrixIndexPointerARB(size,type,stride,pointer):pass +@_f +@_p.types(None,_cs.GLint,arrays.GLubyteArray) +def glMatrixIndexubvARB(size,indices):pass +@_f +@_p.types(None,_cs.GLint,arrays.GLuintArray) +def glMatrixIndexuivARB(size,indices):pass +@_f +@_p.types(None,_cs.GLint,arrays.GLushortArray) +def glMatrixIndexusvARB(size,indices):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/multi_bind.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/multi_bind.py new file mode 100644 index 00000000..a2a670fe --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/multi_bind.py @@ -0,0 +1,32 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_multi_bind' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_multi_bind',error_checker=_errors._error_checker) + +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,_cs.GLsizei,arrays.GLuintArray) +def glBindBuffersBase(target,first,count,buffers):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,_cs.GLsizei,arrays.GLuintArray,ctypes.POINTER(_cs.GLintptr),ctypes.POINTER(_cs.GLsizeiptr)) +def glBindBuffersRange(target,first,count,buffers,offsets,sizes):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizei,arrays.GLuintArray) +def glBindImageTextures(first,count,textures):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizei,arrays.GLuintArray) +def glBindSamplers(first,count,samplers):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizei,arrays.GLuintArray) +def glBindTextures(first,count,textures):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizei,arrays.GLuintArray,ctypes.POINTER(_cs.GLintptr),arrays.GLsizeiArray) +def glBindVertexBuffers(first,count,buffers,offsets,strides):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/multi_draw_indirect.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/multi_draw_indirect.py new file mode 100644 index 00000000..a596eaa8 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/multi_draw_indirect.py @@ -0,0 +1,20 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_multi_draw_indirect' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_multi_draw_indirect',error_checker=_errors._error_checker) + +@_f +@_p.types(None,_cs.GLenum,ctypes.c_void_p,_cs.GLsizei,_cs.GLsizei) +def glMultiDrawArraysIndirect(mode,indirect,drawcount,stride):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,ctypes.c_void_p,_cs.GLsizei,_cs.GLsizei) +def glMultiDrawElementsIndirect(mode,type,indirect,drawcount,stride):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/multisample.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/multisample.py new file mode 100644 index 00000000..88a59afe --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/multisample.py @@ -0,0 +1,25 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_multisample' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_multisample',error_checker=_errors._error_checker) +GL_MULTISAMPLE_ARB=_C('GL_MULTISAMPLE_ARB',0x809D) +GL_MULTISAMPLE_BIT_ARB=_C('GL_MULTISAMPLE_BIT_ARB',0x20000000) +GL_SAMPLES_ARB=_C('GL_SAMPLES_ARB',0x80A9) +GL_SAMPLE_ALPHA_TO_COVERAGE_ARB=_C('GL_SAMPLE_ALPHA_TO_COVERAGE_ARB',0x809E) +GL_SAMPLE_ALPHA_TO_ONE_ARB=_C('GL_SAMPLE_ALPHA_TO_ONE_ARB',0x809F) +GL_SAMPLE_BUFFERS_ARB=_C('GL_SAMPLE_BUFFERS_ARB',0x80A8) +GL_SAMPLE_COVERAGE_ARB=_C('GL_SAMPLE_COVERAGE_ARB',0x80A0) +GL_SAMPLE_COVERAGE_INVERT_ARB=_C('GL_SAMPLE_COVERAGE_INVERT_ARB',0x80AB) +GL_SAMPLE_COVERAGE_VALUE_ARB=_C('GL_SAMPLE_COVERAGE_VALUE_ARB',0x80AA) +@_f +@_p.types(None,_cs.GLfloat,_cs.GLboolean) +def glSampleCoverageARB(value,invert):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/multitexture.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/multitexture.py new file mode 100644 index 00000000..c5d4d9eb --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/multitexture.py @@ -0,0 +1,150 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_multitexture' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_multitexture',error_checker=_errors._error_checker) +GL_ACTIVE_TEXTURE_ARB=_C('GL_ACTIVE_TEXTURE_ARB',0x84E0) +GL_CLIENT_ACTIVE_TEXTURE_ARB=_C('GL_CLIENT_ACTIVE_TEXTURE_ARB',0x84E1) +GL_MAX_TEXTURE_UNITS_ARB=_C('GL_MAX_TEXTURE_UNITS_ARB',0x84E2) +GL_TEXTURE0_ARB=_C('GL_TEXTURE0_ARB',0x84C0) +GL_TEXTURE10_ARB=_C('GL_TEXTURE10_ARB',0x84CA) +GL_TEXTURE11_ARB=_C('GL_TEXTURE11_ARB',0x84CB) +GL_TEXTURE12_ARB=_C('GL_TEXTURE12_ARB',0x84CC) +GL_TEXTURE13_ARB=_C('GL_TEXTURE13_ARB',0x84CD) +GL_TEXTURE14_ARB=_C('GL_TEXTURE14_ARB',0x84CE) +GL_TEXTURE15_ARB=_C('GL_TEXTURE15_ARB',0x84CF) +GL_TEXTURE16_ARB=_C('GL_TEXTURE16_ARB',0x84D0) +GL_TEXTURE17_ARB=_C('GL_TEXTURE17_ARB',0x84D1) +GL_TEXTURE18_ARB=_C('GL_TEXTURE18_ARB',0x84D2) +GL_TEXTURE19_ARB=_C('GL_TEXTURE19_ARB',0x84D3) +GL_TEXTURE1_ARB=_C('GL_TEXTURE1_ARB',0x84C1) +GL_TEXTURE20_ARB=_C('GL_TEXTURE20_ARB',0x84D4) +GL_TEXTURE21_ARB=_C('GL_TEXTURE21_ARB',0x84D5) +GL_TEXTURE22_ARB=_C('GL_TEXTURE22_ARB',0x84D6) +GL_TEXTURE23_ARB=_C('GL_TEXTURE23_ARB',0x84D7) +GL_TEXTURE24_ARB=_C('GL_TEXTURE24_ARB',0x84D8) +GL_TEXTURE25_ARB=_C('GL_TEXTURE25_ARB',0x84D9) +GL_TEXTURE26_ARB=_C('GL_TEXTURE26_ARB',0x84DA) +GL_TEXTURE27_ARB=_C('GL_TEXTURE27_ARB',0x84DB) +GL_TEXTURE28_ARB=_C('GL_TEXTURE28_ARB',0x84DC) +GL_TEXTURE29_ARB=_C('GL_TEXTURE29_ARB',0x84DD) +GL_TEXTURE2_ARB=_C('GL_TEXTURE2_ARB',0x84C2) +GL_TEXTURE30_ARB=_C('GL_TEXTURE30_ARB',0x84DE) +GL_TEXTURE31_ARB=_C('GL_TEXTURE31_ARB',0x84DF) +GL_TEXTURE3_ARB=_C('GL_TEXTURE3_ARB',0x84C3) +GL_TEXTURE4_ARB=_C('GL_TEXTURE4_ARB',0x84C4) +GL_TEXTURE5_ARB=_C('GL_TEXTURE5_ARB',0x84C5) +GL_TEXTURE6_ARB=_C('GL_TEXTURE6_ARB',0x84C6) +GL_TEXTURE7_ARB=_C('GL_TEXTURE7_ARB',0x84C7) +GL_TEXTURE8_ARB=_C('GL_TEXTURE8_ARB',0x84C8) +GL_TEXTURE9_ARB=_C('GL_TEXTURE9_ARB',0x84C9) +@_f +@_p.types(None,_cs.GLenum) +def glActiveTextureARB(texture):pass +@_f +@_p.types(None,_cs.GLenum) +def glClientActiveTextureARB(texture):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLdouble) +def glMultiTexCoord1dARB(target,s):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLdoubleArray) +def glMultiTexCoord1dvARB(target,v):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLfloat) +def glMultiTexCoord1fARB(target,s):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLfloatArray) +def glMultiTexCoord1fvARB(target,v):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLint) +def glMultiTexCoord1iARB(target,s):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLintArray) +def glMultiTexCoord1ivARB(target,v):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLshort) +def glMultiTexCoord1sARB(target,s):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLshortArray) +def glMultiTexCoord1svARB(target,v):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLdouble,_cs.GLdouble) +def glMultiTexCoord2dARB(target,s,t):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLdoubleArray) +def glMultiTexCoord2dvARB(target,v):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLfloat,_cs.GLfloat) +def glMultiTexCoord2fARB(target,s,t):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLfloatArray) +def glMultiTexCoord2fvARB(target,v):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLint,_cs.GLint) +def glMultiTexCoord2iARB(target,s,t):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLintArray) +def glMultiTexCoord2ivARB(target,v):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLshort,_cs.GLshort) +def glMultiTexCoord2sARB(target,s,t):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLshortArray) +def glMultiTexCoord2svARB(target,v):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLdouble,_cs.GLdouble,_cs.GLdouble) +def glMultiTexCoord3dARB(target,s,t,r):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLdoubleArray) +def glMultiTexCoord3dvARB(target,v):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat) +def glMultiTexCoord3fARB(target,s,t,r):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLfloatArray) +def glMultiTexCoord3fvARB(target,v):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLint,_cs.GLint,_cs.GLint) +def glMultiTexCoord3iARB(target,s,t,r):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLintArray) +def glMultiTexCoord3ivARB(target,v):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLshort,_cs.GLshort,_cs.GLshort) +def glMultiTexCoord3sARB(target,s,t,r):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLshortArray) +def glMultiTexCoord3svARB(target,v):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLdouble,_cs.GLdouble,_cs.GLdouble,_cs.GLdouble) +def glMultiTexCoord4dARB(target,s,t,r,q):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLdoubleArray) +def glMultiTexCoord4dvARB(target,v):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat) +def glMultiTexCoord4fARB(target,s,t,r,q):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLfloatArray) +def glMultiTexCoord4fvARB(target,v):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint) +def glMultiTexCoord4iARB(target,s,t,r,q):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLintArray) +def glMultiTexCoord4ivARB(target,v):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLshort,_cs.GLshort,_cs.GLshort,_cs.GLshort) +def glMultiTexCoord4sARB(target,s,t,r,q):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLshortArray) +def glMultiTexCoord4svARB(target,v):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/occlusion_query.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/occlusion_query.py new file mode 100644 index 00000000..06cde561 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/occlusion_query.py @@ -0,0 +1,42 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_occlusion_query' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_occlusion_query',error_checker=_errors._error_checker) +GL_CURRENT_QUERY_ARB=_C('GL_CURRENT_QUERY_ARB',0x8865) +GL_QUERY_COUNTER_BITS_ARB=_C('GL_QUERY_COUNTER_BITS_ARB',0x8864) +GL_QUERY_RESULT_ARB=_C('GL_QUERY_RESULT_ARB',0x8866) +GL_QUERY_RESULT_AVAILABLE_ARB=_C('GL_QUERY_RESULT_AVAILABLE_ARB',0x8867) +GL_SAMPLES_PASSED_ARB=_C('GL_SAMPLES_PASSED_ARB',0x8914) +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint) +def glBeginQueryARB(target,id):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray) +def glDeleteQueriesARB(n,ids):pass +@_f +@_p.types(None,_cs.GLenum) +def glEndQueryARB(target):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray) +def glGenQueriesARB(n,ids):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLintArray) +def glGetQueryObjectivARB(id,pname,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLuintArray) +def glGetQueryObjectuivARB(id,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLintArray) +def glGetQueryivARB(target,pname,params):pass +@_f +@_p.types(_cs.GLboolean,_cs.GLuint) +def glIsQueryARB(id):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/occlusion_query2.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/occlusion_query2.py new file mode 100644 index 00000000..00fbcc9d --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/occlusion_query2.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_occlusion_query2' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_occlusion_query2',error_checker=_errors._error_checker) +GL_ANY_SAMPLES_PASSED=_C('GL_ANY_SAMPLES_PASSED',0x8C2F) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/parallel_shader_compile.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/parallel_shader_compile.py new file mode 100644 index 00000000..6e9e5ecd --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/parallel_shader_compile.py @@ -0,0 +1,18 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_parallel_shader_compile' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_parallel_shader_compile',error_checker=_errors._error_checker) +GL_COMPLETION_STATUS_ARB=_C('GL_COMPLETION_STATUS_ARB',0x91B1) +GL_MAX_SHADER_COMPILER_THREADS_ARB=_C('GL_MAX_SHADER_COMPILER_THREADS_ARB',0x91B0) +@_f +@_p.types(None,_cs.GLuint) +def glMaxShaderCompilerThreadsARB(count):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/pipeline_statistics_query.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/pipeline_statistics_query.py new file mode 100644 index 00000000..35ef34f2 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/pipeline_statistics_query.py @@ -0,0 +1,25 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_pipeline_statistics_query' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_pipeline_statistics_query',error_checker=_errors._error_checker) +GL_CLIPPING_INPUT_PRIMITIVES_ARB=_C('GL_CLIPPING_INPUT_PRIMITIVES_ARB',0x82F6) +GL_CLIPPING_OUTPUT_PRIMITIVES_ARB=_C('GL_CLIPPING_OUTPUT_PRIMITIVES_ARB',0x82F7) +GL_COMPUTE_SHADER_INVOCATIONS_ARB=_C('GL_COMPUTE_SHADER_INVOCATIONS_ARB',0x82F5) +GL_FRAGMENT_SHADER_INVOCATIONS_ARB=_C('GL_FRAGMENT_SHADER_INVOCATIONS_ARB',0x82F4) +GL_GEOMETRY_SHADER_INVOCATIONS=_C('GL_GEOMETRY_SHADER_INVOCATIONS',0x887F) +GL_GEOMETRY_SHADER_PRIMITIVES_EMITTED_ARB=_C('GL_GEOMETRY_SHADER_PRIMITIVES_EMITTED_ARB',0x82F3) +GL_PRIMITIVES_SUBMITTED_ARB=_C('GL_PRIMITIVES_SUBMITTED_ARB',0x82EF) +GL_TESS_CONTROL_SHADER_PATCHES_ARB=_C('GL_TESS_CONTROL_SHADER_PATCHES_ARB',0x82F1) +GL_TESS_EVALUATION_SHADER_INVOCATIONS_ARB=_C('GL_TESS_EVALUATION_SHADER_INVOCATIONS_ARB',0x82F2) +GL_VERTEX_SHADER_INVOCATIONS_ARB=_C('GL_VERTEX_SHADER_INVOCATIONS_ARB',0x82F0) +GL_VERTICES_SUBMITTED_ARB=_C('GL_VERTICES_SUBMITTED_ARB',0x82EE) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/pixel_buffer_object.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/pixel_buffer_object.py new file mode 100644 index 00000000..d9ea9b65 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/pixel_buffer_object.py @@ -0,0 +1,18 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_pixel_buffer_object' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_pixel_buffer_object',error_checker=_errors._error_checker) +GL_PIXEL_PACK_BUFFER_ARB=_C('GL_PIXEL_PACK_BUFFER_ARB',0x88EB) +GL_PIXEL_PACK_BUFFER_BINDING_ARB=_C('GL_PIXEL_PACK_BUFFER_BINDING_ARB',0x88ED) +GL_PIXEL_UNPACK_BUFFER_ARB=_C('GL_PIXEL_UNPACK_BUFFER_ARB',0x88EC) +GL_PIXEL_UNPACK_BUFFER_BINDING_ARB=_C('GL_PIXEL_UNPACK_BUFFER_BINDING_ARB',0x88EF) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/point_parameters.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/point_parameters.py new file mode 100644 index 00000000..cebf2a0c --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/point_parameters.py @@ -0,0 +1,23 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_point_parameters' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_point_parameters',error_checker=_errors._error_checker) +GL_POINT_DISTANCE_ATTENUATION_ARB=_C('GL_POINT_DISTANCE_ATTENUATION_ARB',0x8129) +GL_POINT_FADE_THRESHOLD_SIZE_ARB=_C('GL_POINT_FADE_THRESHOLD_SIZE_ARB',0x8128) +GL_POINT_SIZE_MAX_ARB=_C('GL_POINT_SIZE_MAX_ARB',0x8127) +GL_POINT_SIZE_MIN_ARB=_C('GL_POINT_SIZE_MIN_ARB',0x8126) +@_f +@_p.types(None,_cs.GLenum,_cs.GLfloat) +def glPointParameterfARB(pname,param):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLfloatArray) +def glPointParameterfvARB(pname,params):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/point_sprite.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/point_sprite.py new file mode 100644 index 00000000..d2789312 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/point_sprite.py @@ -0,0 +1,16 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_point_sprite' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_point_sprite',error_checker=_errors._error_checker) +GL_COORD_REPLACE_ARB=_C('GL_COORD_REPLACE_ARB',0x8862) +GL_POINT_SPRITE_ARB=_C('GL_POINT_SPRITE_ARB',0x8861) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/polygon_offset_clamp.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/polygon_offset_clamp.py new file mode 100644 index 00000000..a8475273 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/polygon_offset_clamp.py @@ -0,0 +1,17 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_polygon_offset_clamp' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_polygon_offset_clamp',error_checker=_errors._error_checker) +GL_POLYGON_OFFSET_CLAMP=_C('GL_POLYGON_OFFSET_CLAMP',0x8E1B) +@_f +@_p.types(None,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat) +def glPolygonOffsetClamp(factor,units,clamp):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/post_depth_coverage.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/post_depth_coverage.py new file mode 100644 index 00000000..41bab539 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/post_depth_coverage.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_post_depth_coverage' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_post_depth_coverage',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/program_interface_query.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/program_interface_query.py new file mode 100644 index 00000000..13a0e547 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/program_interface_query.py @@ -0,0 +1,81 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_program_interface_query' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_program_interface_query',error_checker=_errors._error_checker) +GL_ACTIVE_RESOURCES=_C('GL_ACTIVE_RESOURCES',0x92F5) +GL_ACTIVE_VARIABLES=_C('GL_ACTIVE_VARIABLES',0x9305) +GL_ARRAY_SIZE=_C('GL_ARRAY_SIZE',0x92FB) +GL_ARRAY_STRIDE=_C('GL_ARRAY_STRIDE',0x92FE) +GL_ATOMIC_COUNTER_BUFFER=_C('GL_ATOMIC_COUNTER_BUFFER',0x92C0) +GL_ATOMIC_COUNTER_BUFFER_INDEX=_C('GL_ATOMIC_COUNTER_BUFFER_INDEX',0x9301) +GL_BLOCK_INDEX=_C('GL_BLOCK_INDEX',0x92FD) +GL_BUFFER_BINDING=_C('GL_BUFFER_BINDING',0x9302) +GL_BUFFER_DATA_SIZE=_C('GL_BUFFER_DATA_SIZE',0x9303) +GL_BUFFER_VARIABLE=_C('GL_BUFFER_VARIABLE',0x92E5) +GL_COMPATIBLE_SUBROUTINES=_C('GL_COMPATIBLE_SUBROUTINES',0x8E4B) +GL_COMPUTE_SUBROUTINE=_C('GL_COMPUTE_SUBROUTINE',0x92ED) +GL_COMPUTE_SUBROUTINE_UNIFORM=_C('GL_COMPUTE_SUBROUTINE_UNIFORM',0x92F3) +GL_FRAGMENT_SUBROUTINE=_C('GL_FRAGMENT_SUBROUTINE',0x92EC) +GL_FRAGMENT_SUBROUTINE_UNIFORM=_C('GL_FRAGMENT_SUBROUTINE_UNIFORM',0x92F2) +GL_GEOMETRY_SUBROUTINE=_C('GL_GEOMETRY_SUBROUTINE',0x92EB) +GL_GEOMETRY_SUBROUTINE_UNIFORM=_C('GL_GEOMETRY_SUBROUTINE_UNIFORM',0x92F1) +GL_IS_PER_PATCH=_C('GL_IS_PER_PATCH',0x92E7) +GL_IS_ROW_MAJOR=_C('GL_IS_ROW_MAJOR',0x9300) +GL_LOCATION=_C('GL_LOCATION',0x930E) +GL_LOCATION_INDEX=_C('GL_LOCATION_INDEX',0x930F) +GL_MATRIX_STRIDE=_C('GL_MATRIX_STRIDE',0x92FF) +GL_MAX_NAME_LENGTH=_C('GL_MAX_NAME_LENGTH',0x92F6) +GL_MAX_NUM_ACTIVE_VARIABLES=_C('GL_MAX_NUM_ACTIVE_VARIABLES',0x92F7) +GL_MAX_NUM_COMPATIBLE_SUBROUTINES=_C('GL_MAX_NUM_COMPATIBLE_SUBROUTINES',0x92F8) +GL_NAME_LENGTH=_C('GL_NAME_LENGTH',0x92F9) +GL_NUM_ACTIVE_VARIABLES=_C('GL_NUM_ACTIVE_VARIABLES',0x9304) +GL_NUM_COMPATIBLE_SUBROUTINES=_C('GL_NUM_COMPATIBLE_SUBROUTINES',0x8E4A) +GL_OFFSET=_C('GL_OFFSET',0x92FC) +GL_PROGRAM_INPUT=_C('GL_PROGRAM_INPUT',0x92E3) +GL_PROGRAM_OUTPUT=_C('GL_PROGRAM_OUTPUT',0x92E4) +GL_REFERENCED_BY_COMPUTE_SHADER=_C('GL_REFERENCED_BY_COMPUTE_SHADER',0x930B) +GL_REFERENCED_BY_FRAGMENT_SHADER=_C('GL_REFERENCED_BY_FRAGMENT_SHADER',0x930A) +GL_REFERENCED_BY_GEOMETRY_SHADER=_C('GL_REFERENCED_BY_GEOMETRY_SHADER',0x9309) +GL_REFERENCED_BY_TESS_CONTROL_SHADER=_C('GL_REFERENCED_BY_TESS_CONTROL_SHADER',0x9307) +GL_REFERENCED_BY_TESS_EVALUATION_SHADER=_C('GL_REFERENCED_BY_TESS_EVALUATION_SHADER',0x9308) +GL_REFERENCED_BY_VERTEX_SHADER=_C('GL_REFERENCED_BY_VERTEX_SHADER',0x9306) +GL_SHADER_STORAGE_BLOCK=_C('GL_SHADER_STORAGE_BLOCK',0x92E6) +GL_TESS_CONTROL_SUBROUTINE=_C('GL_TESS_CONTROL_SUBROUTINE',0x92E9) +GL_TESS_CONTROL_SUBROUTINE_UNIFORM=_C('GL_TESS_CONTROL_SUBROUTINE_UNIFORM',0x92EF) +GL_TESS_EVALUATION_SUBROUTINE=_C('GL_TESS_EVALUATION_SUBROUTINE',0x92EA) +GL_TESS_EVALUATION_SUBROUTINE_UNIFORM=_C('GL_TESS_EVALUATION_SUBROUTINE_UNIFORM',0x92F0) +GL_TOP_LEVEL_ARRAY_SIZE=_C('GL_TOP_LEVEL_ARRAY_SIZE',0x930C) +GL_TOP_LEVEL_ARRAY_STRIDE=_C('GL_TOP_LEVEL_ARRAY_STRIDE',0x930D) +GL_TRANSFORM_FEEDBACK_VARYING=_C('GL_TRANSFORM_FEEDBACK_VARYING',0x92F4) +GL_TYPE=_C('GL_TYPE',0x92FA) +GL_UNIFORM=_C('GL_UNIFORM',0x92E1) +GL_UNIFORM_BLOCK=_C('GL_UNIFORM_BLOCK',0x92E2) +GL_VERTEX_SUBROUTINE=_C('GL_VERTEX_SUBROUTINE',0x92E8) +GL_VERTEX_SUBROUTINE_UNIFORM=_C('GL_VERTEX_SUBROUTINE_UNIFORM',0x92EE) +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLenum,arrays.GLintArray) +def glGetProgramInterfaceiv(program,programInterface,pname,params):pass +@_f +@_p.types(_cs.GLuint,_cs.GLuint,_cs.GLenum,arrays.GLcharArray) +def glGetProgramResourceIndex(program,programInterface,name):pass +@_f +@_p.types(_cs.GLint,_cs.GLuint,_cs.GLenum,arrays.GLcharArray) +def glGetProgramResourceLocation(program,programInterface,name):pass +@_f +@_p.types(_cs.GLint,_cs.GLuint,_cs.GLenum,arrays.GLcharArray) +def glGetProgramResourceLocationIndex(program,programInterface,name):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLuint,_cs.GLsizei,arrays.GLsizeiArray,arrays.GLcharArray) +def glGetProgramResourceName(program,programInterface,index,bufSize,length,name):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLuint,_cs.GLsizei,arrays.GLuintArray,_cs.GLsizei,arrays.GLsizeiArray,arrays.GLintArray) +def glGetProgramResourceiv(program,programInterface,index,propCount,props,bufSize,length,params):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/provoking_vertex.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/provoking_vertex.py new file mode 100644 index 00000000..33ebd819 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/provoking_vertex.py @@ -0,0 +1,20 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_provoking_vertex' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_provoking_vertex',error_checker=_errors._error_checker) +GL_FIRST_VERTEX_CONVENTION=_C('GL_FIRST_VERTEX_CONVENTION',0x8E4D) +GL_LAST_VERTEX_CONVENTION=_C('GL_LAST_VERTEX_CONVENTION',0x8E4E) +GL_PROVOKING_VERTEX=_C('GL_PROVOKING_VERTEX',0x8E4F) +GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION=_C('GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION',0x8E4C) +@_f +@_p.types(None,_cs.GLenum) +def glProvokingVertex(mode):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/query_buffer_object.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/query_buffer_object.py new file mode 100644 index 00000000..3405ded5 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/query_buffer_object.py @@ -0,0 +1,18 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_query_buffer_object' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_query_buffer_object',error_checker=_errors._error_checker) +GL_QUERY_BUFFER=_C('GL_QUERY_BUFFER',0x9192) +GL_QUERY_BUFFER_BARRIER_BIT=_C('GL_QUERY_BUFFER_BARRIER_BIT',0x00008000) +GL_QUERY_BUFFER_BINDING=_C('GL_QUERY_BUFFER_BINDING',0x9193) +GL_QUERY_RESULT_NO_WAIT=_C('GL_QUERY_RESULT_NO_WAIT',0x9194) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/robust_buffer_access_behavior.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/robust_buffer_access_behavior.py new file mode 100644 index 00000000..9a67e609 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/robust_buffer_access_behavior.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_robust_buffer_access_behavior' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_robust_buffer_access_behavior',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/robustness.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/robustness.py new file mode 100644 index 00000000..b240a50b --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/robustness.py @@ -0,0 +1,81 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_robustness' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_robustness',error_checker=_errors._error_checker) +GL_CONTEXT_FLAG_ROBUST_ACCESS_BIT_ARB=_C('GL_CONTEXT_FLAG_ROBUST_ACCESS_BIT_ARB',0x00000004) +GL_GUILTY_CONTEXT_RESET_ARB=_C('GL_GUILTY_CONTEXT_RESET_ARB',0x8253) +GL_INNOCENT_CONTEXT_RESET_ARB=_C('GL_INNOCENT_CONTEXT_RESET_ARB',0x8254) +GL_LOSE_CONTEXT_ON_RESET_ARB=_C('GL_LOSE_CONTEXT_ON_RESET_ARB',0x8252) +GL_NO_ERROR=_C('GL_NO_ERROR',0) +GL_NO_RESET_NOTIFICATION_ARB=_C('GL_NO_RESET_NOTIFICATION_ARB',0x8261) +GL_RESET_NOTIFICATION_STRATEGY_ARB=_C('GL_RESET_NOTIFICATION_STRATEGY_ARB',0x8256) +GL_UNKNOWN_CONTEXT_RESET_ARB=_C('GL_UNKNOWN_CONTEXT_RESET_ARB',0x8255) +@_f +@_p.types(_cs.GLenum,) +def glGetGraphicsResetStatusARB():pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLenum,_cs.GLsizei,ctypes.c_void_p) +def glGetnColorTableARB(target,format,type,bufSize,table):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLint,_cs.GLsizei,ctypes.c_void_p) +def glGetnCompressedTexImageARB(target,lod,bufSize,img):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLenum,_cs.GLsizei,ctypes.c_void_p) +def glGetnConvolutionFilterARB(target,format,type,bufSize,image):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLboolean,_cs.GLenum,_cs.GLenum,_cs.GLsizei,ctypes.c_void_p) +def glGetnHistogramARB(target,reset,format,type,bufSize,values):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLsizei,arrays.GLdoubleArray) +def glGetnMapdvARB(target,query,bufSize,v):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLsizei,arrays.GLfloatArray) +def glGetnMapfvARB(target,query,bufSize,v):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLsizei,arrays.GLintArray) +def glGetnMapivARB(target,query,bufSize,v):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLboolean,_cs.GLenum,_cs.GLenum,_cs.GLsizei,ctypes.c_void_p) +def glGetnMinmaxARB(target,reset,format,type,bufSize,values):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizei,arrays.GLfloatArray) +def glGetnPixelMapfvARB(map,bufSize,values):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizei,arrays.GLuintArray) +def glGetnPixelMapuivARB(map,bufSize,values):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizei,arrays.GLushortArray) +def glGetnPixelMapusvARB(map,bufSize,values):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLubyteArray) +def glGetnPolygonStippleARB(bufSize,pattern):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLenum,_cs.GLsizei,ctypes.c_void_p,_cs.GLsizei,ctypes.c_void_p,ctypes.c_void_p) +def glGetnSeparableFilterARB(target,format,type,rowBufSize,row,columnBufSize,column,span):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLint,_cs.GLenum,_cs.GLenum,_cs.GLsizei,ctypes.c_void_p) +def glGetnTexImageARB(target,level,format,type,bufSize,img):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLdoubleArray) +def glGetnUniformdvARB(program,location,bufSize,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLfloatArray) +def glGetnUniformfvARB(program,location,bufSize,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLintArray) +def glGetnUniformivARB(program,location,bufSize,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLuintArray) +def glGetnUniformuivARB(program,location,bufSize,params):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLsizei,_cs.GLenum,_cs.GLenum,_cs.GLsizei,ctypes.c_void_p) +def glReadnPixelsARB(x,y,width,height,format,type,bufSize,data):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/robustness_isolation.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/robustness_isolation.py new file mode 100644 index 00000000..1cc8d081 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/robustness_isolation.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_robustness_isolation' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_robustness_isolation',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/sample_locations.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/sample_locations.py new file mode 100644 index 00000000..4e589a95 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/sample_locations.py @@ -0,0 +1,30 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_sample_locations' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_sample_locations',error_checker=_errors._error_checker) +GL_FRAMEBUFFER_PROGRAMMABLE_SAMPLE_LOCATIONS_ARB=_C('GL_FRAMEBUFFER_PROGRAMMABLE_SAMPLE_LOCATIONS_ARB',0x9342) +GL_FRAMEBUFFER_SAMPLE_LOCATION_PIXEL_GRID_ARB=_C('GL_FRAMEBUFFER_SAMPLE_LOCATION_PIXEL_GRID_ARB',0x9343) +GL_PROGRAMMABLE_SAMPLE_LOCATION_ARB=_C('GL_PROGRAMMABLE_SAMPLE_LOCATION_ARB',0x9341) +GL_PROGRAMMABLE_SAMPLE_LOCATION_TABLE_SIZE_ARB=_C('GL_PROGRAMMABLE_SAMPLE_LOCATION_TABLE_SIZE_ARB',0x9340) +GL_SAMPLE_LOCATION_ARB=_C('GL_SAMPLE_LOCATION_ARB',0x8E50) +GL_SAMPLE_LOCATION_PIXEL_GRID_HEIGHT_ARB=_C('GL_SAMPLE_LOCATION_PIXEL_GRID_HEIGHT_ARB',0x933F) +GL_SAMPLE_LOCATION_PIXEL_GRID_WIDTH_ARB=_C('GL_SAMPLE_LOCATION_PIXEL_GRID_WIDTH_ARB',0x933E) +GL_SAMPLE_LOCATION_SUBPIXEL_BITS_ARB=_C('GL_SAMPLE_LOCATION_SUBPIXEL_BITS_ARB',0x933D) +@_f +@_p.types(None,) +def glEvaluateDepthValuesARB():pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,_cs.GLsizei,arrays.GLfloatArray) +def glFramebufferSampleLocationsfvARB(target,start,count,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLsizei,arrays.GLfloatArray) +def glNamedFramebufferSampleLocationsfvARB(framebuffer,start,count,v):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/sample_shading.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/sample_shading.py new file mode 100644 index 00000000..de9f293b --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/sample_shading.py @@ -0,0 +1,18 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_sample_shading' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_sample_shading',error_checker=_errors._error_checker) +GL_MIN_SAMPLE_SHADING_VALUE_ARB=_C('GL_MIN_SAMPLE_SHADING_VALUE_ARB',0x8C37) +GL_SAMPLE_SHADING_ARB=_C('GL_SAMPLE_SHADING_ARB',0x8C36) +@_f +@_p.types(None,_cs.GLfloat) +def glMinSampleShadingARB(value):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/sampler_objects.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/sampler_objects.py new file mode 100644 index 00000000..d3b02158 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/sampler_objects.py @@ -0,0 +1,56 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_sampler_objects' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_sampler_objects',error_checker=_errors._error_checker) +GL_SAMPLER_BINDING=_C('GL_SAMPLER_BINDING',0x8919) +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint) +def glBindSampler(unit,sampler):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray) +def glDeleteSamplers(count,samplers):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray) +def glGenSamplers(count,samplers):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLintArray) +def glGetSamplerParameterIiv(sampler,pname,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLuintArray) +def glGetSamplerParameterIuiv(sampler,pname,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLfloatArray) +def glGetSamplerParameterfv(sampler,pname,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLintArray) +def glGetSamplerParameteriv(sampler,pname,params):pass +@_f +@_p.types(_cs.GLboolean,_cs.GLuint) +def glIsSampler(sampler):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLintArray) +def glSamplerParameterIiv(sampler,pname,param):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLuintArray) +def glSamplerParameterIuiv(sampler,pname,param):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLfloat) +def glSamplerParameterf(sampler,pname,param):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLfloatArray) +def glSamplerParameterfv(sampler,pname,param):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLint) +def glSamplerParameteri(sampler,pname,param):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLintArray) +def glSamplerParameteriv(sampler,pname,param):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/seamless_cube_map.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/seamless_cube_map.py new file mode 100644 index 00000000..f0f2c4ff --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/seamless_cube_map.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_seamless_cube_map' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_seamless_cube_map',error_checker=_errors._error_checker) +GL_TEXTURE_CUBE_MAP_SEAMLESS=_C('GL_TEXTURE_CUBE_MAP_SEAMLESS',0x884F) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/seamless_cubemap_per_texture.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/seamless_cubemap_per_texture.py new file mode 100644 index 00000000..d2eeaf22 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/seamless_cubemap_per_texture.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_seamless_cubemap_per_texture' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_seamless_cubemap_per_texture',error_checker=_errors._error_checker) +GL_TEXTURE_CUBE_MAP_SEAMLESS=_C('GL_TEXTURE_CUBE_MAP_SEAMLESS',0x884F) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/separate_shader_objects.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/separate_shader_objects.py new file mode 100644 index 00000000..c2504495 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/separate_shader_objects.py @@ -0,0 +1,205 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_separate_shader_objects' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_separate_shader_objects',error_checker=_errors._error_checker) +GL_ACTIVE_PROGRAM=_C('GL_ACTIVE_PROGRAM',0x8259) +GL_ALL_SHADER_BITS=_C('GL_ALL_SHADER_BITS',0xFFFFFFFF) +GL_FRAGMENT_SHADER_BIT=_C('GL_FRAGMENT_SHADER_BIT',0x00000002) +GL_GEOMETRY_SHADER_BIT=_C('GL_GEOMETRY_SHADER_BIT',0x00000004) +GL_PROGRAM_PIPELINE_BINDING=_C('GL_PROGRAM_PIPELINE_BINDING',0x825A) +GL_PROGRAM_SEPARABLE=_C('GL_PROGRAM_SEPARABLE',0x8258) +GL_TESS_CONTROL_SHADER_BIT=_C('GL_TESS_CONTROL_SHADER_BIT',0x00000008) +GL_TESS_EVALUATION_SHADER_BIT=_C('GL_TESS_EVALUATION_SHADER_BIT',0x00000010) +GL_VERTEX_SHADER_BIT=_C('GL_VERTEX_SHADER_BIT',0x00000001) +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint) +def glActiveShaderProgram(pipeline,program):pass +@_f +@_p.types(None,_cs.GLuint) +def glBindProgramPipeline(pipeline):pass +@_f +@_p.types(_cs.GLuint,_cs.GLenum,_cs.GLsizei,ctypes.POINTER( ctypes.POINTER( _cs.GLchar ))) +def glCreateShaderProgramv(type,count,strings):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray) +def glDeleteProgramPipelines(n,pipelines):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray) +def glGenProgramPipelines(n,pipelines):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizei,arrays.GLsizeiArray,arrays.GLcharArray) +def glGetProgramPipelineInfoLog(pipeline,bufSize,length,infoLog):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLintArray) +def glGetProgramPipelineiv(pipeline,pname,params):pass +@_f +@_p.types(_cs.GLboolean,_cs.GLuint) +def glIsProgramPipeline(pipeline):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLint) +def glProgramParameteri(program,pname,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLdouble) +def glProgramUniform1d(program,location,v0):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLdoubleArray) +def glProgramUniform1dv(program,location,count,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLfloat) +def glProgramUniform1f(program,location,v0):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLfloatArray) +def glProgramUniform1fv(program,location,count,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLint) +def glProgramUniform1i(program,location,v0):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLintArray) +def glProgramUniform1iv(program,location,count,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLuint) +def glProgramUniform1ui(program,location,v0):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLuintArray) +def glProgramUniform1uiv(program,location,count,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLdouble,_cs.GLdouble) +def glProgramUniform2d(program,location,v0,v1):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLdoubleArray) +def glProgramUniform2dv(program,location,count,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLfloat,_cs.GLfloat) +def glProgramUniform2f(program,location,v0,v1):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLfloatArray) +def glProgramUniform2fv(program,location,count,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLint,_cs.GLint) +def glProgramUniform2i(program,location,v0,v1):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLintArray) +def glProgramUniform2iv(program,location,count,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLuint,_cs.GLuint) +def glProgramUniform2ui(program,location,v0,v1):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLuintArray) +def glProgramUniform2uiv(program,location,count,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLdouble,_cs.GLdouble,_cs.GLdouble) +def glProgramUniform3d(program,location,v0,v1,v2):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLdoubleArray) +def glProgramUniform3dv(program,location,count,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat) +def glProgramUniform3f(program,location,v0,v1,v2):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLfloatArray) +def glProgramUniform3fv(program,location,count,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint) +def glProgramUniform3i(program,location,v0,v1,v2):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLintArray) +def glProgramUniform3iv(program,location,count,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLuint,_cs.GLuint,_cs.GLuint) +def glProgramUniform3ui(program,location,v0,v1,v2):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLuintArray) +def glProgramUniform3uiv(program,location,count,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLdouble,_cs.GLdouble,_cs.GLdouble,_cs.GLdouble) +def glProgramUniform4d(program,location,v0,v1,v2,v3):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLdoubleArray) +def glProgramUniform4dv(program,location,count,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat) +def glProgramUniform4f(program,location,v0,v1,v2,v3):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLfloatArray) +def glProgramUniform4fv(program,location,count,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint) +def glProgramUniform4i(program,location,v0,v1,v2,v3):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLintArray) +def glProgramUniform4iv(program,location,count,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLuint,_cs.GLuint,_cs.GLuint,_cs.GLuint) +def glProgramUniform4ui(program,location,v0,v1,v2,v3):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLuintArray) +def glProgramUniform4uiv(program,location,count,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,_cs.GLboolean,arrays.GLdoubleArray) +def glProgramUniformMatrix2dv(program,location,count,transpose,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,_cs.GLboolean,arrays.GLfloatArray) +def glProgramUniformMatrix2fv(program,location,count,transpose,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,_cs.GLboolean,arrays.GLdoubleArray) +def glProgramUniformMatrix2x3dv(program,location,count,transpose,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,_cs.GLboolean,arrays.GLfloatArray) +def glProgramUniformMatrix2x3fv(program,location,count,transpose,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,_cs.GLboolean,arrays.GLdoubleArray) +def glProgramUniformMatrix2x4dv(program,location,count,transpose,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,_cs.GLboolean,arrays.GLfloatArray) +def glProgramUniformMatrix2x4fv(program,location,count,transpose,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,_cs.GLboolean,arrays.GLdoubleArray) +def glProgramUniformMatrix3dv(program,location,count,transpose,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,_cs.GLboolean,arrays.GLfloatArray) +def glProgramUniformMatrix3fv(program,location,count,transpose,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,_cs.GLboolean,arrays.GLdoubleArray) +def glProgramUniformMatrix3x2dv(program,location,count,transpose,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,_cs.GLboolean,arrays.GLfloatArray) +def glProgramUniformMatrix3x2fv(program,location,count,transpose,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,_cs.GLboolean,arrays.GLdoubleArray) +def glProgramUniformMatrix3x4dv(program,location,count,transpose,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,_cs.GLboolean,arrays.GLfloatArray) +def glProgramUniformMatrix3x4fv(program,location,count,transpose,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,_cs.GLboolean,arrays.GLdoubleArray) +def glProgramUniformMatrix4dv(program,location,count,transpose,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,_cs.GLboolean,arrays.GLfloatArray) +def glProgramUniformMatrix4fv(program,location,count,transpose,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,_cs.GLboolean,arrays.GLdoubleArray) +def glProgramUniformMatrix4x2dv(program,location,count,transpose,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,_cs.GLboolean,arrays.GLfloatArray) +def glProgramUniformMatrix4x2fv(program,location,count,transpose,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,_cs.GLboolean,arrays.GLdoubleArray) +def glProgramUniformMatrix4x3dv(program,location,count,transpose,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,_cs.GLboolean,arrays.GLfloatArray) +def glProgramUniformMatrix4x3fv(program,location,count,transpose,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLbitfield,_cs.GLuint) +def glUseProgramStages(pipeline,stages,program):pass +@_f +@_p.types(None,_cs.GLuint) +def glValidateProgramPipeline(pipeline):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/shader_atomic_counter_ops.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/shader_atomic_counter_ops.py new file mode 100644 index 00000000..275e7918 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/shader_atomic_counter_ops.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_shader_atomic_counter_ops' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_shader_atomic_counter_ops',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/shader_atomic_counters.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/shader_atomic_counters.py new file mode 100644 index 00000000..92704a20 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/shader_atomic_counters.py @@ -0,0 +1,45 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_shader_atomic_counters' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_shader_atomic_counters',error_checker=_errors._error_checker) +GL_ACTIVE_ATOMIC_COUNTER_BUFFERS=_C('GL_ACTIVE_ATOMIC_COUNTER_BUFFERS',0x92D9) +GL_ATOMIC_COUNTER_BUFFER=_C('GL_ATOMIC_COUNTER_BUFFER',0x92C0) +GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTERS=_C('GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTERS',0x92C5) +GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTER_INDICES=_C('GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTER_INDICES',0x92C6) +GL_ATOMIC_COUNTER_BUFFER_BINDING=_C('GL_ATOMIC_COUNTER_BUFFER_BINDING',0x92C1) +GL_ATOMIC_COUNTER_BUFFER_DATA_SIZE=_C('GL_ATOMIC_COUNTER_BUFFER_DATA_SIZE',0x92C4) +GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_FRAGMENT_SHADER=_C('GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_FRAGMENT_SHADER',0x92CB) +GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_GEOMETRY_SHADER=_C('GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_GEOMETRY_SHADER',0x92CA) +GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_CONTROL_SHADER=_C('GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_CONTROL_SHADER',0x92C8) +GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_EVALUATION_SHADER=_C('GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_EVALUATION_SHADER',0x92C9) +GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_VERTEX_SHADER=_C('GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_VERTEX_SHADER',0x92C7) +GL_ATOMIC_COUNTER_BUFFER_SIZE=_C('GL_ATOMIC_COUNTER_BUFFER_SIZE',0x92C3) +GL_ATOMIC_COUNTER_BUFFER_START=_C('GL_ATOMIC_COUNTER_BUFFER_START',0x92C2) +GL_MAX_ATOMIC_COUNTER_BUFFER_BINDINGS=_C('GL_MAX_ATOMIC_COUNTER_BUFFER_BINDINGS',0x92DC) +GL_MAX_ATOMIC_COUNTER_BUFFER_SIZE=_C('GL_MAX_ATOMIC_COUNTER_BUFFER_SIZE',0x92D8) +GL_MAX_COMBINED_ATOMIC_COUNTERS=_C('GL_MAX_COMBINED_ATOMIC_COUNTERS',0x92D7) +GL_MAX_COMBINED_ATOMIC_COUNTER_BUFFERS=_C('GL_MAX_COMBINED_ATOMIC_COUNTER_BUFFERS',0x92D1) +GL_MAX_FRAGMENT_ATOMIC_COUNTERS=_C('GL_MAX_FRAGMENT_ATOMIC_COUNTERS',0x92D6) +GL_MAX_FRAGMENT_ATOMIC_COUNTER_BUFFERS=_C('GL_MAX_FRAGMENT_ATOMIC_COUNTER_BUFFERS',0x92D0) +GL_MAX_GEOMETRY_ATOMIC_COUNTERS=_C('GL_MAX_GEOMETRY_ATOMIC_COUNTERS',0x92D5) +GL_MAX_GEOMETRY_ATOMIC_COUNTER_BUFFERS=_C('GL_MAX_GEOMETRY_ATOMIC_COUNTER_BUFFERS',0x92CF) +GL_MAX_TESS_CONTROL_ATOMIC_COUNTERS=_C('GL_MAX_TESS_CONTROL_ATOMIC_COUNTERS',0x92D3) +GL_MAX_TESS_CONTROL_ATOMIC_COUNTER_BUFFERS=_C('GL_MAX_TESS_CONTROL_ATOMIC_COUNTER_BUFFERS',0x92CD) +GL_MAX_TESS_EVALUATION_ATOMIC_COUNTERS=_C('GL_MAX_TESS_EVALUATION_ATOMIC_COUNTERS',0x92D4) +GL_MAX_TESS_EVALUATION_ATOMIC_COUNTER_BUFFERS=_C('GL_MAX_TESS_EVALUATION_ATOMIC_COUNTER_BUFFERS',0x92CE) +GL_MAX_VERTEX_ATOMIC_COUNTERS=_C('GL_MAX_VERTEX_ATOMIC_COUNTERS',0x92D2) +GL_MAX_VERTEX_ATOMIC_COUNTER_BUFFERS=_C('GL_MAX_VERTEX_ATOMIC_COUNTER_BUFFERS',0x92CC) +GL_UNIFORM_ATOMIC_COUNTER_BUFFER_INDEX=_C('GL_UNIFORM_ATOMIC_COUNTER_BUFFER_INDEX',0x92DA) +GL_UNSIGNED_INT_ATOMIC_COUNTER=_C('GL_UNSIGNED_INT_ATOMIC_COUNTER',0x92DB) +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLenum,arrays.GLintArray) +def glGetActiveAtomicCounterBufferiv(program,bufferIndex,pname,params):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/shader_ballot.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/shader_ballot.py new file mode 100644 index 00000000..4be2164d --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/shader_ballot.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_shader_ballot' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_shader_ballot',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/shader_bit_encoding.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/shader_bit_encoding.py new file mode 100644 index 00000000..0d5a770e --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/shader_bit_encoding.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_shader_bit_encoding' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_shader_bit_encoding',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/shader_clock.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/shader_clock.py new file mode 100644 index 00000000..dd42f1dd --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/shader_clock.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_shader_clock' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_shader_clock',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/shader_draw_parameters.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/shader_draw_parameters.py new file mode 100644 index 00000000..1e4a8550 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/shader_draw_parameters.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_shader_draw_parameters' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_shader_draw_parameters',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/shader_group_vote.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/shader_group_vote.py new file mode 100644 index 00000000..ee6e6ef4 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/shader_group_vote.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_shader_group_vote' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_shader_group_vote',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/shader_image_load_store.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/shader_image_load_store.py new file mode 100644 index 00000000..dd144391 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/shader_image_load_store.py @@ -0,0 +1,83 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_shader_image_load_store' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_shader_image_load_store',error_checker=_errors._error_checker) +GL_ALL_BARRIER_BITS=_C('GL_ALL_BARRIER_BITS',0xFFFFFFFF) +GL_ATOMIC_COUNTER_BARRIER_BIT=_C('GL_ATOMIC_COUNTER_BARRIER_BIT',0x00001000) +GL_BUFFER_UPDATE_BARRIER_BIT=_C('GL_BUFFER_UPDATE_BARRIER_BIT',0x00000200) +GL_COMMAND_BARRIER_BIT=_C('GL_COMMAND_BARRIER_BIT',0x00000040) +GL_ELEMENT_ARRAY_BARRIER_BIT=_C('GL_ELEMENT_ARRAY_BARRIER_BIT',0x00000002) +GL_FRAMEBUFFER_BARRIER_BIT=_C('GL_FRAMEBUFFER_BARRIER_BIT',0x00000400) +GL_IMAGE_1D=_C('GL_IMAGE_1D',0x904C) +GL_IMAGE_1D_ARRAY=_C('GL_IMAGE_1D_ARRAY',0x9052) +GL_IMAGE_2D=_C('GL_IMAGE_2D',0x904D) +GL_IMAGE_2D_ARRAY=_C('GL_IMAGE_2D_ARRAY',0x9053) +GL_IMAGE_2D_MULTISAMPLE=_C('GL_IMAGE_2D_MULTISAMPLE',0x9055) +GL_IMAGE_2D_MULTISAMPLE_ARRAY=_C('GL_IMAGE_2D_MULTISAMPLE_ARRAY',0x9056) +GL_IMAGE_2D_RECT=_C('GL_IMAGE_2D_RECT',0x904F) +GL_IMAGE_3D=_C('GL_IMAGE_3D',0x904E) +GL_IMAGE_BINDING_ACCESS=_C('GL_IMAGE_BINDING_ACCESS',0x8F3E) +GL_IMAGE_BINDING_FORMAT=_C('GL_IMAGE_BINDING_FORMAT',0x906E) +GL_IMAGE_BINDING_LAYER=_C('GL_IMAGE_BINDING_LAYER',0x8F3D) +GL_IMAGE_BINDING_LAYERED=_C('GL_IMAGE_BINDING_LAYERED',0x8F3C) +GL_IMAGE_BINDING_LEVEL=_C('GL_IMAGE_BINDING_LEVEL',0x8F3B) +GL_IMAGE_BINDING_NAME=_C('GL_IMAGE_BINDING_NAME',0x8F3A) +GL_IMAGE_BUFFER=_C('GL_IMAGE_BUFFER',0x9051) +GL_IMAGE_CUBE=_C('GL_IMAGE_CUBE',0x9050) +GL_IMAGE_CUBE_MAP_ARRAY=_C('GL_IMAGE_CUBE_MAP_ARRAY',0x9054) +GL_IMAGE_FORMAT_COMPATIBILITY_BY_CLASS=_C('GL_IMAGE_FORMAT_COMPATIBILITY_BY_CLASS',0x90C9) +GL_IMAGE_FORMAT_COMPATIBILITY_BY_SIZE=_C('GL_IMAGE_FORMAT_COMPATIBILITY_BY_SIZE',0x90C8) +GL_IMAGE_FORMAT_COMPATIBILITY_TYPE=_C('GL_IMAGE_FORMAT_COMPATIBILITY_TYPE',0x90C7) +GL_INT_IMAGE_1D=_C('GL_INT_IMAGE_1D',0x9057) +GL_INT_IMAGE_1D_ARRAY=_C('GL_INT_IMAGE_1D_ARRAY',0x905D) +GL_INT_IMAGE_2D=_C('GL_INT_IMAGE_2D',0x9058) +GL_INT_IMAGE_2D_ARRAY=_C('GL_INT_IMAGE_2D_ARRAY',0x905E) +GL_INT_IMAGE_2D_MULTISAMPLE=_C('GL_INT_IMAGE_2D_MULTISAMPLE',0x9060) +GL_INT_IMAGE_2D_MULTISAMPLE_ARRAY=_C('GL_INT_IMAGE_2D_MULTISAMPLE_ARRAY',0x9061) +GL_INT_IMAGE_2D_RECT=_C('GL_INT_IMAGE_2D_RECT',0x905A) +GL_INT_IMAGE_3D=_C('GL_INT_IMAGE_3D',0x9059) +GL_INT_IMAGE_BUFFER=_C('GL_INT_IMAGE_BUFFER',0x905C) +GL_INT_IMAGE_CUBE=_C('GL_INT_IMAGE_CUBE',0x905B) +GL_INT_IMAGE_CUBE_MAP_ARRAY=_C('GL_INT_IMAGE_CUBE_MAP_ARRAY',0x905F) +GL_MAX_COMBINED_IMAGE_UNIFORMS=_C('GL_MAX_COMBINED_IMAGE_UNIFORMS',0x90CF) +GL_MAX_COMBINED_IMAGE_UNITS_AND_FRAGMENT_OUTPUTS=_C('GL_MAX_COMBINED_IMAGE_UNITS_AND_FRAGMENT_OUTPUTS',0x8F39) +GL_MAX_FRAGMENT_IMAGE_UNIFORMS=_C('GL_MAX_FRAGMENT_IMAGE_UNIFORMS',0x90CE) +GL_MAX_GEOMETRY_IMAGE_UNIFORMS=_C('GL_MAX_GEOMETRY_IMAGE_UNIFORMS',0x90CD) +GL_MAX_IMAGE_SAMPLES=_C('GL_MAX_IMAGE_SAMPLES',0x906D) +GL_MAX_IMAGE_UNITS=_C('GL_MAX_IMAGE_UNITS',0x8F38) +GL_MAX_TESS_CONTROL_IMAGE_UNIFORMS=_C('GL_MAX_TESS_CONTROL_IMAGE_UNIFORMS',0x90CB) +GL_MAX_TESS_EVALUATION_IMAGE_UNIFORMS=_C('GL_MAX_TESS_EVALUATION_IMAGE_UNIFORMS',0x90CC) +GL_MAX_VERTEX_IMAGE_UNIFORMS=_C('GL_MAX_VERTEX_IMAGE_UNIFORMS',0x90CA) +GL_PIXEL_BUFFER_BARRIER_BIT=_C('GL_PIXEL_BUFFER_BARRIER_BIT',0x00000080) +GL_SHADER_IMAGE_ACCESS_BARRIER_BIT=_C('GL_SHADER_IMAGE_ACCESS_BARRIER_BIT',0x00000020) +GL_TEXTURE_FETCH_BARRIER_BIT=_C('GL_TEXTURE_FETCH_BARRIER_BIT',0x00000008) +GL_TEXTURE_UPDATE_BARRIER_BIT=_C('GL_TEXTURE_UPDATE_BARRIER_BIT',0x00000100) +GL_TRANSFORM_FEEDBACK_BARRIER_BIT=_C('GL_TRANSFORM_FEEDBACK_BARRIER_BIT',0x00000800) +GL_UNIFORM_BARRIER_BIT=_C('GL_UNIFORM_BARRIER_BIT',0x00000004) +GL_UNSIGNED_INT_IMAGE_1D=_C('GL_UNSIGNED_INT_IMAGE_1D',0x9062) +GL_UNSIGNED_INT_IMAGE_1D_ARRAY=_C('GL_UNSIGNED_INT_IMAGE_1D_ARRAY',0x9068) +GL_UNSIGNED_INT_IMAGE_2D=_C('GL_UNSIGNED_INT_IMAGE_2D',0x9063) +GL_UNSIGNED_INT_IMAGE_2D_ARRAY=_C('GL_UNSIGNED_INT_IMAGE_2D_ARRAY',0x9069) +GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE=_C('GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE',0x906B) +GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_ARRAY=_C('GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_ARRAY',0x906C) +GL_UNSIGNED_INT_IMAGE_2D_RECT=_C('GL_UNSIGNED_INT_IMAGE_2D_RECT',0x9065) +GL_UNSIGNED_INT_IMAGE_3D=_C('GL_UNSIGNED_INT_IMAGE_3D',0x9064) +GL_UNSIGNED_INT_IMAGE_BUFFER=_C('GL_UNSIGNED_INT_IMAGE_BUFFER',0x9067) +GL_UNSIGNED_INT_IMAGE_CUBE=_C('GL_UNSIGNED_INT_IMAGE_CUBE',0x9066) +GL_UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY=_C('GL_UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY',0x906A) +GL_VERTEX_ATTRIB_ARRAY_BARRIER_BIT=_C('GL_VERTEX_ATTRIB_ARRAY_BARRIER_BIT',0x00000001) +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLint,_cs.GLboolean,_cs.GLint,_cs.GLenum,_cs.GLenum) +def glBindImageTexture(unit,texture,level,layered,layer,access,format):pass +@_f +@_p.types(None,_cs.GLbitfield) +def glMemoryBarrier(barriers):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/shader_image_size.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/shader_image_size.py new file mode 100644 index 00000000..b74e062c --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/shader_image_size.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_shader_image_size' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_shader_image_size',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/shader_objects.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/shader_objects.py new file mode 100644 index 00000000..6cb9f097 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/shader_objects.py @@ -0,0 +1,164 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_shader_objects' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_shader_objects',error_checker=_errors._error_checker) +GL_BOOL_ARB=_C('GL_BOOL_ARB',0x8B56) +GL_BOOL_VEC2_ARB=_C('GL_BOOL_VEC2_ARB',0x8B57) +GL_BOOL_VEC3_ARB=_C('GL_BOOL_VEC3_ARB',0x8B58) +GL_BOOL_VEC4_ARB=_C('GL_BOOL_VEC4_ARB',0x8B59) +GL_FLOAT_MAT2_ARB=_C('GL_FLOAT_MAT2_ARB',0x8B5A) +GL_FLOAT_MAT3_ARB=_C('GL_FLOAT_MAT3_ARB',0x8B5B) +GL_FLOAT_MAT4_ARB=_C('GL_FLOAT_MAT4_ARB',0x8B5C) +GL_FLOAT_VEC2_ARB=_C('GL_FLOAT_VEC2_ARB',0x8B50) +GL_FLOAT_VEC3_ARB=_C('GL_FLOAT_VEC3_ARB',0x8B51) +GL_FLOAT_VEC4_ARB=_C('GL_FLOAT_VEC4_ARB',0x8B52) +GL_INT_VEC2_ARB=_C('GL_INT_VEC2_ARB',0x8B53) +GL_INT_VEC3_ARB=_C('GL_INT_VEC3_ARB',0x8B54) +GL_INT_VEC4_ARB=_C('GL_INT_VEC4_ARB',0x8B55) +GL_OBJECT_ACTIVE_UNIFORMS_ARB=_C('GL_OBJECT_ACTIVE_UNIFORMS_ARB',0x8B86) +GL_OBJECT_ACTIVE_UNIFORM_MAX_LENGTH_ARB=_C('GL_OBJECT_ACTIVE_UNIFORM_MAX_LENGTH_ARB',0x8B87) +GL_OBJECT_ATTACHED_OBJECTS_ARB=_C('GL_OBJECT_ATTACHED_OBJECTS_ARB',0x8B85) +GL_OBJECT_COMPILE_STATUS_ARB=_C('GL_OBJECT_COMPILE_STATUS_ARB',0x8B81) +GL_OBJECT_DELETE_STATUS_ARB=_C('GL_OBJECT_DELETE_STATUS_ARB',0x8B80) +GL_OBJECT_INFO_LOG_LENGTH_ARB=_C('GL_OBJECT_INFO_LOG_LENGTH_ARB',0x8B84) +GL_OBJECT_LINK_STATUS_ARB=_C('GL_OBJECT_LINK_STATUS_ARB',0x8B82) +GL_OBJECT_SHADER_SOURCE_LENGTH_ARB=_C('GL_OBJECT_SHADER_SOURCE_LENGTH_ARB',0x8B88) +GL_OBJECT_SUBTYPE_ARB=_C('GL_OBJECT_SUBTYPE_ARB',0x8B4F) +GL_OBJECT_TYPE_ARB=_C('GL_OBJECT_TYPE_ARB',0x8B4E) +GL_OBJECT_VALIDATE_STATUS_ARB=_C('GL_OBJECT_VALIDATE_STATUS_ARB',0x8B83) +GL_PROGRAM_OBJECT_ARB=_C('GL_PROGRAM_OBJECT_ARB',0x8B40) +GL_SAMPLER_1D_ARB=_C('GL_SAMPLER_1D_ARB',0x8B5D) +GL_SAMPLER_1D_SHADOW_ARB=_C('GL_SAMPLER_1D_SHADOW_ARB',0x8B61) +GL_SAMPLER_2D_ARB=_C('GL_SAMPLER_2D_ARB',0x8B5E) +GL_SAMPLER_2D_RECT_ARB=_C('GL_SAMPLER_2D_RECT_ARB',0x8B63) +GL_SAMPLER_2D_RECT_SHADOW_ARB=_C('GL_SAMPLER_2D_RECT_SHADOW_ARB',0x8B64) +GL_SAMPLER_2D_SHADOW_ARB=_C('GL_SAMPLER_2D_SHADOW_ARB',0x8B62) +GL_SAMPLER_3D_ARB=_C('GL_SAMPLER_3D_ARB',0x8B5F) +GL_SAMPLER_CUBE_ARB=_C('GL_SAMPLER_CUBE_ARB',0x8B60) +GL_SHADER_OBJECT_ARB=_C('GL_SHADER_OBJECT_ARB',0x8B48) +@_f +@_p.types(None,_cs.GLhandleARB,_cs.GLhandleARB) +def glAttachObjectARB(containerObj,obj):pass +@_f +@_p.types(None,_cs.GLhandleARB) +def glCompileShaderARB(shaderObj):pass +@_f +@_p.types(_cs.GLhandleARB,) +def glCreateProgramObjectARB():pass +@_f +@_p.types(_cs.GLhandleARB,_cs.GLenum) +def glCreateShaderObjectARB(shaderType):pass +@_f +@_p.types(None,_cs.GLhandleARB) +def glDeleteObjectARB(obj):pass +@_f +@_p.types(None,_cs.GLhandleARB,_cs.GLhandleARB) +def glDetachObjectARB(containerObj,attachedObj):pass +@_f +@_p.types(None,_cs.GLhandleARB,_cs.GLuint,_cs.GLsizei,arrays.GLsizeiArray,arrays.GLintArray,arrays.GLuintArray,arrays.GLcharARBArray) +def glGetActiveUniformARB(programObj,index,maxLength,length,size,type,name):pass +@_f +@_p.types(None,_cs.GLhandleARB,_cs.GLsizei,arrays.GLsizeiArray,arrays.GLuintArray) +def glGetAttachedObjectsARB(containerObj,maxCount,count,obj):pass +@_f +@_p.types(_cs.GLhandleARB,_cs.GLenum) +def glGetHandleARB(pname):pass +@_f +@_p.types(None,_cs.GLhandleARB,_cs.GLsizei,arrays.GLsizeiArray,arrays.GLcharARBArray) +def glGetInfoLogARB(obj,maxLength,length,infoLog):pass +@_f +@_p.types(None,_cs.GLhandleARB,_cs.GLenum,arrays.GLfloatArray) +def glGetObjectParameterfvARB(obj,pname,params):pass +@_f +@_p.types(None,_cs.GLhandleARB,_cs.GLenum,arrays.GLintArray) +def glGetObjectParameterivARB(obj,pname,params):pass +@_f +@_p.types(None,_cs.GLhandleARB,_cs.GLsizei,arrays.GLsizeiArray,arrays.GLcharARBArray) +def glGetShaderSourceARB(obj,maxLength,length,source):pass +@_f +@_p.types(_cs.GLint,_cs.GLhandleARB,arrays.GLcharARBArray) +def glGetUniformLocationARB(programObj,name):pass +@_f +@_p.types(None,_cs.GLhandleARB,_cs.GLint,arrays.GLfloatArray) +def glGetUniformfvARB(programObj,location,params):pass +@_f +@_p.types(None,_cs.GLhandleARB,_cs.GLint,arrays.GLintArray) +def glGetUniformivARB(programObj,location,params):pass +@_f +@_p.types(None,_cs.GLhandleARB) +def glLinkProgramARB(programObj):pass +@_f +@_p.types(None,_cs.GLhandleARB,_cs.GLsizei,ctypes.POINTER( ctypes.POINTER( _cs.GLchar )),arrays.GLintArray) +def glShaderSourceARB(shaderObj,count,string,length):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLfloat) +def glUniform1fARB(location,v0):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLsizei,arrays.GLfloatArray) +def glUniform1fvARB(location,count,value):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLint) +def glUniform1iARB(location,v0):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLsizei,arrays.GLintArray) +def glUniform1ivARB(location,count,value):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLfloat,_cs.GLfloat) +def glUniform2fARB(location,v0,v1):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLsizei,arrays.GLfloatArray) +def glUniform2fvARB(location,count,value):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLint,_cs.GLint) +def glUniform2iARB(location,v0,v1):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLsizei,arrays.GLintArray) +def glUniform2ivARB(location,count,value):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat) +def glUniform3fARB(location,v0,v1,v2):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLsizei,arrays.GLfloatArray) +def glUniform3fvARB(location,count,value):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint) +def glUniform3iARB(location,v0,v1,v2):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLsizei,arrays.GLintArray) +def glUniform3ivARB(location,count,value):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat) +def glUniform4fARB(location,v0,v1,v2,v3):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLsizei,arrays.GLfloatArray) +def glUniform4fvARB(location,count,value):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint) +def glUniform4iARB(location,v0,v1,v2,v3):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLsizei,arrays.GLintArray) +def glUniform4ivARB(location,count,value):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLsizei,_cs.GLboolean,arrays.GLfloatArray) +def glUniformMatrix2fvARB(location,count,transpose,value):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLsizei,_cs.GLboolean,arrays.GLfloatArray) +def glUniformMatrix3fvARB(location,count,transpose,value):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLsizei,_cs.GLboolean,arrays.GLfloatArray) +def glUniformMatrix4fvARB(location,count,transpose,value):pass +@_f +@_p.types(None,_cs.GLhandleARB) +def glUseProgramObjectARB(programObj):pass +@_f +@_p.types(None,_cs.GLhandleARB) +def glValidateProgramARB(programObj):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/shader_precision.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/shader_precision.py new file mode 100644 index 00000000..a801f130 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/shader_precision.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_shader_precision' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_shader_precision',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/shader_stencil_export.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/shader_stencil_export.py new file mode 100644 index 00000000..ba1e7f7c --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/shader_stencil_export.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_shader_stencil_export' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_shader_stencil_export',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/shader_storage_buffer_object.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/shader_storage_buffer_object.py new file mode 100644 index 00000000..926f3ff9 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/shader_storage_buffer_object.py @@ -0,0 +1,33 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_shader_storage_buffer_object' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_shader_storage_buffer_object',error_checker=_errors._error_checker) +GL_MAX_COMBINED_IMAGE_UNITS_AND_FRAGMENT_OUTPUTS=_C('GL_MAX_COMBINED_IMAGE_UNITS_AND_FRAGMENT_OUTPUTS',0x8F39) +GL_MAX_COMBINED_SHADER_OUTPUT_RESOURCES=_C('GL_MAX_COMBINED_SHADER_OUTPUT_RESOURCES',0x8F39) +GL_MAX_COMBINED_SHADER_STORAGE_BLOCKS=_C('GL_MAX_COMBINED_SHADER_STORAGE_BLOCKS',0x90DC) +GL_MAX_COMPUTE_SHADER_STORAGE_BLOCKS=_C('GL_MAX_COMPUTE_SHADER_STORAGE_BLOCKS',0x90DB) +GL_MAX_FRAGMENT_SHADER_STORAGE_BLOCKS=_C('GL_MAX_FRAGMENT_SHADER_STORAGE_BLOCKS',0x90DA) +GL_MAX_GEOMETRY_SHADER_STORAGE_BLOCKS=_C('GL_MAX_GEOMETRY_SHADER_STORAGE_BLOCKS',0x90D7) +GL_MAX_SHADER_STORAGE_BLOCK_SIZE=_C('GL_MAX_SHADER_STORAGE_BLOCK_SIZE',0x90DE) +GL_MAX_SHADER_STORAGE_BUFFER_BINDINGS=_C('GL_MAX_SHADER_STORAGE_BUFFER_BINDINGS',0x90DD) +GL_MAX_TESS_CONTROL_SHADER_STORAGE_BLOCKS=_C('GL_MAX_TESS_CONTROL_SHADER_STORAGE_BLOCKS',0x90D8) +GL_MAX_TESS_EVALUATION_SHADER_STORAGE_BLOCKS=_C('GL_MAX_TESS_EVALUATION_SHADER_STORAGE_BLOCKS',0x90D9) +GL_MAX_VERTEX_SHADER_STORAGE_BLOCKS=_C('GL_MAX_VERTEX_SHADER_STORAGE_BLOCKS',0x90D6) +GL_SHADER_STORAGE_BARRIER_BIT=_C('GL_SHADER_STORAGE_BARRIER_BIT',0x00002000) +GL_SHADER_STORAGE_BUFFER=_C('GL_SHADER_STORAGE_BUFFER',0x90D2) +GL_SHADER_STORAGE_BUFFER_BINDING=_C('GL_SHADER_STORAGE_BUFFER_BINDING',0x90D3) +GL_SHADER_STORAGE_BUFFER_OFFSET_ALIGNMENT=_C('GL_SHADER_STORAGE_BUFFER_OFFSET_ALIGNMENT',0x90DF) +GL_SHADER_STORAGE_BUFFER_SIZE=_C('GL_SHADER_STORAGE_BUFFER_SIZE',0x90D5) +GL_SHADER_STORAGE_BUFFER_START=_C('GL_SHADER_STORAGE_BUFFER_START',0x90D4) +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLuint) +def glShaderStorageBlockBinding(program,storageBlockIndex,storageBlockBinding):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/shader_subroutine.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/shader_subroutine.py new file mode 100644 index 00000000..088d77ce --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/shader_subroutine.py @@ -0,0 +1,48 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_shader_subroutine' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_shader_subroutine',error_checker=_errors._error_checker) +GL_ACTIVE_SUBROUTINES=_C('GL_ACTIVE_SUBROUTINES',0x8DE5) +GL_ACTIVE_SUBROUTINE_MAX_LENGTH=_C('GL_ACTIVE_SUBROUTINE_MAX_LENGTH',0x8E48) +GL_ACTIVE_SUBROUTINE_UNIFORMS=_C('GL_ACTIVE_SUBROUTINE_UNIFORMS',0x8DE6) +GL_ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS=_C('GL_ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS',0x8E47) +GL_ACTIVE_SUBROUTINE_UNIFORM_MAX_LENGTH=_C('GL_ACTIVE_SUBROUTINE_UNIFORM_MAX_LENGTH',0x8E49) +GL_COMPATIBLE_SUBROUTINES=_C('GL_COMPATIBLE_SUBROUTINES',0x8E4B) +GL_MAX_SUBROUTINES=_C('GL_MAX_SUBROUTINES',0x8DE7) +GL_MAX_SUBROUTINE_UNIFORM_LOCATIONS=_C('GL_MAX_SUBROUTINE_UNIFORM_LOCATIONS',0x8DE8) +GL_NUM_COMPATIBLE_SUBROUTINES=_C('GL_NUM_COMPATIBLE_SUBROUTINES',0x8E4A) +GL_UNIFORM_NAME_LENGTH=_C('GL_UNIFORM_NAME_LENGTH',0x8A39) +GL_UNIFORM_SIZE=_C('GL_UNIFORM_SIZE',0x8A38) +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLuint,_cs.GLsizei,arrays.GLsizeiArray,arrays.GLcharArray) +def glGetActiveSubroutineName(program,shadertype,index,bufsize,length,name):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLuint,_cs.GLsizei,arrays.GLsizeiArray,arrays.GLcharArray) +def glGetActiveSubroutineUniformName(program,shadertype,index,bufsize,length,name):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLuint,_cs.GLenum,arrays.GLintArray) +def glGetActiveSubroutineUniformiv(program,shadertype,index,pname,values):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLenum,arrays.GLintArray) +def glGetProgramStageiv(program,shadertype,pname,values):pass +@_f +@_p.types(_cs.GLuint,_cs.GLuint,_cs.GLenum,arrays.GLcharArray) +def glGetSubroutineIndex(program,shadertype,name):pass +@_f +@_p.types(_cs.GLint,_cs.GLuint,_cs.GLenum,arrays.GLcharArray) +def glGetSubroutineUniformLocation(program,shadertype,name):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLint,arrays.GLuintArray) +def glGetUniformSubroutineuiv(shadertype,location,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizei,arrays.GLuintArray) +def glUniformSubroutinesuiv(shadertype,count,indices):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/shader_texture_image_samples.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/shader_texture_image_samples.py new file mode 100644 index 00000000..69b34509 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/shader_texture_image_samples.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_shader_texture_image_samples' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_shader_texture_image_samples',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/shader_texture_lod.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/shader_texture_lod.py new file mode 100644 index 00000000..857fbf40 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/shader_texture_lod.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_shader_texture_lod' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_shader_texture_lod',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/shader_viewport_layer_array.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/shader_viewport_layer_array.py new file mode 100644 index 00000000..f9c0e165 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/shader_viewport_layer_array.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_shader_viewport_layer_array' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_shader_viewport_layer_array',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/shading_language_100.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/shading_language_100.py new file mode 100644 index 00000000..e7b31b75 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/shading_language_100.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_shading_language_100' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_shading_language_100',error_checker=_errors._error_checker) +GL_SHADING_LANGUAGE_VERSION_ARB=_C('GL_SHADING_LANGUAGE_VERSION_ARB',0x8B8C) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/shading_language_420pack.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/shading_language_420pack.py new file mode 100644 index 00000000..418fa058 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/shading_language_420pack.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_shading_language_420pack' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_shading_language_420pack',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/shading_language_include.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/shading_language_include.py new file mode 100644 index 00000000..13087b15 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/shading_language_include.py @@ -0,0 +1,34 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_shading_language_include' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_shading_language_include',error_checker=_errors._error_checker) +GL_NAMED_STRING_LENGTH_ARB=_C('GL_NAMED_STRING_LENGTH_ARB',0x8DE9) +GL_NAMED_STRING_TYPE_ARB=_C('GL_NAMED_STRING_TYPE_ARB',0x8DEA) +GL_SHADER_INCLUDE_ARB=_C('GL_SHADER_INCLUDE_ARB',0x8DAE) +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizei,ctypes.POINTER( ctypes.POINTER( _cs.GLchar )),arrays.GLintArray) +def glCompileShaderIncludeARB(shader,count,path,length):pass +@_f +@_p.types(None,_cs.GLint,arrays.GLcharArray) +def glDeleteNamedStringARB(namelen,name):pass +@_f +@_p.types(None,_cs.GLint,arrays.GLcharArray,_cs.GLsizei,arrays.GLintArray,arrays.GLcharArray) +def glGetNamedStringARB(namelen,name,bufSize,stringlen,string):pass +@_f +@_p.types(None,_cs.GLint,arrays.GLcharArray,_cs.GLenum,arrays.GLintArray) +def glGetNamedStringivARB(namelen,name,pname,params):pass +@_f +@_p.types(_cs.GLboolean,_cs.GLint,arrays.GLcharArray) +def glIsNamedStringARB(namelen,name):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLint,arrays.GLcharArray,_cs.GLint,arrays.GLcharArray) +def glNamedStringARB(type,namelen,name,stringlen,string):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/shading_language_packing.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/shading_language_packing.py new file mode 100644 index 00000000..0b7edd69 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/shading_language_packing.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_shading_language_packing' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_shading_language_packing',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/shadow.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/shadow.py new file mode 100644 index 00000000..bb69ad36 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/shadow.py @@ -0,0 +1,17 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_shadow' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_shadow',error_checker=_errors._error_checker) +GL_COMPARE_R_TO_TEXTURE_ARB=_C('GL_COMPARE_R_TO_TEXTURE_ARB',0x884E) +GL_TEXTURE_COMPARE_FUNC_ARB=_C('GL_TEXTURE_COMPARE_FUNC_ARB',0x884D) +GL_TEXTURE_COMPARE_MODE_ARB=_C('GL_TEXTURE_COMPARE_MODE_ARB',0x884C) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/shadow_ambient.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/shadow_ambient.py new file mode 100644 index 00000000..11282546 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/shadow_ambient.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_shadow_ambient' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_shadow_ambient',error_checker=_errors._error_checker) +GL_TEXTURE_COMPARE_FAIL_VALUE_ARB=_C('GL_TEXTURE_COMPARE_FAIL_VALUE_ARB',0x80BF) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/sparse_buffer.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/sparse_buffer.py new file mode 100644 index 00000000..05e37881 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/sparse_buffer.py @@ -0,0 +1,24 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_sparse_buffer' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_sparse_buffer',error_checker=_errors._error_checker) +GL_SPARSE_BUFFER_PAGE_SIZE_ARB=_C('GL_SPARSE_BUFFER_PAGE_SIZE_ARB',0x82F8) +GL_SPARSE_STORAGE_BIT_ARB=_C('GL_SPARSE_STORAGE_BIT_ARB',0x0400) +@_f +@_p.types(None,_cs.GLenum,_cs.GLintptr,_cs.GLsizeiptr,_cs.GLboolean) +def glBufferPageCommitmentARB(target,offset,size,commit):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLintptr,_cs.GLsizeiptr,_cs.GLboolean) +def glNamedBufferPageCommitmentARB(buffer,offset,size,commit):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLintptr,_cs.GLsizeiptr,_cs.GLboolean) +def glNamedBufferPageCommitmentEXT(buffer,offset,size,commit):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/sparse_texture.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/sparse_texture.py new file mode 100644 index 00000000..b3187b61 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/sparse_texture.py @@ -0,0 +1,27 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_sparse_texture' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_sparse_texture',error_checker=_errors._error_checker) +GL_MAX_SPARSE_3D_TEXTURE_SIZE_ARB=_C('GL_MAX_SPARSE_3D_TEXTURE_SIZE_ARB',0x9199) +GL_MAX_SPARSE_ARRAY_TEXTURE_LAYERS_ARB=_C('GL_MAX_SPARSE_ARRAY_TEXTURE_LAYERS_ARB',0x919A) +GL_MAX_SPARSE_TEXTURE_SIZE_ARB=_C('GL_MAX_SPARSE_TEXTURE_SIZE_ARB',0x9198) +GL_NUM_SPARSE_LEVELS_ARB=_C('GL_NUM_SPARSE_LEVELS_ARB',0x91AA) +GL_NUM_VIRTUAL_PAGE_SIZES_ARB=_C('GL_NUM_VIRTUAL_PAGE_SIZES_ARB',0x91A8) +GL_SPARSE_TEXTURE_FULL_ARRAY_CUBE_MIPMAPS_ARB=_C('GL_SPARSE_TEXTURE_FULL_ARRAY_CUBE_MIPMAPS_ARB',0x91A9) +GL_TEXTURE_SPARSE_ARB=_C('GL_TEXTURE_SPARSE_ARB',0x91A6) +GL_VIRTUAL_PAGE_SIZE_INDEX_ARB=_C('GL_VIRTUAL_PAGE_SIZE_INDEX_ARB',0x91A7) +GL_VIRTUAL_PAGE_SIZE_X_ARB=_C('GL_VIRTUAL_PAGE_SIZE_X_ARB',0x9195) +GL_VIRTUAL_PAGE_SIZE_Y_ARB=_C('GL_VIRTUAL_PAGE_SIZE_Y_ARB',0x9196) +GL_VIRTUAL_PAGE_SIZE_Z_ARB=_C('GL_VIRTUAL_PAGE_SIZE_Z_ARB',0x9197) +@_f +@_p.types(None,_cs.GLenum,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLsizei,_cs.GLsizei,_cs.GLboolean) +def glTexPageCommitmentARB(target,level,xoffset,yoffset,zoffset,width,height,depth,commit):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/sparse_texture2.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/sparse_texture2.py new file mode 100644 index 00000000..c76cd541 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/sparse_texture2.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_sparse_texture2' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_sparse_texture2',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/sparse_texture_clamp.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/sparse_texture_clamp.py new file mode 100644 index 00000000..1a892bf4 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/sparse_texture_clamp.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_sparse_texture_clamp' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_sparse_texture_clamp',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/spirv_extensions.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/spirv_extensions.py new file mode 100644 index 00000000..37ce6c24 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/spirv_extensions.py @@ -0,0 +1,16 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_spirv_extensions' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_spirv_extensions',error_checker=_errors._error_checker) +GL_NUM_SPIR_V_EXTENSIONS=_C('GL_NUM_SPIR_V_EXTENSIONS',0x9554) +GL_SPIR_V_EXTENSIONS=_C('GL_SPIR_V_EXTENSIONS',0x9553) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/stencil_texturing.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/stencil_texturing.py new file mode 100644 index 00000000..e01bd6f6 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/stencil_texturing.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_stencil_texturing' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_stencil_texturing',error_checker=_errors._error_checker) +GL_DEPTH_STENCIL_TEXTURE_MODE=_C('GL_DEPTH_STENCIL_TEXTURE_MODE',0x90EA) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/sync.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/sync.py new file mode 100644 index 00000000..6d00b9ec --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/sync.py @@ -0,0 +1,49 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_sync' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_sync',error_checker=_errors._error_checker) +GL_ALREADY_SIGNALED=_C('GL_ALREADY_SIGNALED',0x911A) +GL_CONDITION_SATISFIED=_C('GL_CONDITION_SATISFIED',0x911C) +GL_MAX_SERVER_WAIT_TIMEOUT=_C('GL_MAX_SERVER_WAIT_TIMEOUT',0x9111) +GL_OBJECT_TYPE=_C('GL_OBJECT_TYPE',0x9112) +GL_SIGNALED=_C('GL_SIGNALED',0x9119) +GL_SYNC_CONDITION=_C('GL_SYNC_CONDITION',0x9113) +GL_SYNC_FENCE=_C('GL_SYNC_FENCE',0x9116) +GL_SYNC_FLAGS=_C('GL_SYNC_FLAGS',0x9115) +GL_SYNC_FLUSH_COMMANDS_BIT=_C('GL_SYNC_FLUSH_COMMANDS_BIT',0x00000001) +GL_SYNC_GPU_COMMANDS_COMPLETE=_C('GL_SYNC_GPU_COMMANDS_COMPLETE',0x9117) +GL_SYNC_STATUS=_C('GL_SYNC_STATUS',0x9114) +GL_TIMEOUT_EXPIRED=_C('GL_TIMEOUT_EXPIRED',0x911B) +GL_TIMEOUT_IGNORED=_C('GL_TIMEOUT_IGNORED',0xFFFFFFFFFFFFFFFF) +GL_UNSIGNALED=_C('GL_UNSIGNALED',0x9118) +GL_WAIT_FAILED=_C('GL_WAIT_FAILED',0x911D) +@_f +@_p.types(_cs.GLenum,_cs.GLsync,_cs.GLbitfield,_cs.GLuint64) +def glClientWaitSync(sync,flags,timeout):pass +@_f +@_p.types(None,_cs.GLsync) +def glDeleteSync(sync):pass +@_f +@_p.types(_cs.GLsync,_cs.GLenum,_cs.GLbitfield) +def glFenceSync(condition,flags):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLint64Array) +def glGetInteger64v(pname,data):pass +@_f +@_p.types(None,_cs.GLsync,_cs.GLenum,_cs.GLsizei,arrays.GLsizeiArray,arrays.GLintArray) +def glGetSynciv(sync,pname,bufSize,length,values):pass +@_f +@_p.types(_cs.GLboolean,_cs.GLsync) +def glIsSync(sync):pass +@_f +@_p.types(None,_cs.GLsync,_cs.GLbitfield,_cs.GLuint64) +def glWaitSync(sync,flags,timeout):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/tessellation_shader.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/tessellation_shader.py new file mode 100644 index 00000000..1bbc48e7 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/tessellation_shader.py @@ -0,0 +1,56 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_tessellation_shader' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_tessellation_shader',error_checker=_errors._error_checker) +GL_CCW=_C('GL_CCW',0x0901) +GL_CW=_C('GL_CW',0x0900) +GL_EQUAL=_C('GL_EQUAL',0x0202) +GL_FRACTIONAL_EVEN=_C('GL_FRACTIONAL_EVEN',0x8E7C) +GL_FRACTIONAL_ODD=_C('GL_FRACTIONAL_ODD',0x8E7B) +GL_ISOLINES=_C('GL_ISOLINES',0x8E7A) +GL_MAX_COMBINED_TESS_CONTROL_UNIFORM_COMPONENTS=_C('GL_MAX_COMBINED_TESS_CONTROL_UNIFORM_COMPONENTS',0x8E1E) +GL_MAX_COMBINED_TESS_EVALUATION_UNIFORM_COMPONENTS=_C('GL_MAX_COMBINED_TESS_EVALUATION_UNIFORM_COMPONENTS',0x8E1F) +GL_MAX_PATCH_VERTICES=_C('GL_MAX_PATCH_VERTICES',0x8E7D) +GL_MAX_TESS_CONTROL_INPUT_COMPONENTS=_C('GL_MAX_TESS_CONTROL_INPUT_COMPONENTS',0x886C) +GL_MAX_TESS_CONTROL_OUTPUT_COMPONENTS=_C('GL_MAX_TESS_CONTROL_OUTPUT_COMPONENTS',0x8E83) +GL_MAX_TESS_CONTROL_TEXTURE_IMAGE_UNITS=_C('GL_MAX_TESS_CONTROL_TEXTURE_IMAGE_UNITS',0x8E81) +GL_MAX_TESS_CONTROL_TOTAL_OUTPUT_COMPONENTS=_C('GL_MAX_TESS_CONTROL_TOTAL_OUTPUT_COMPONENTS',0x8E85) +GL_MAX_TESS_CONTROL_UNIFORM_BLOCKS=_C('GL_MAX_TESS_CONTROL_UNIFORM_BLOCKS',0x8E89) +GL_MAX_TESS_CONTROL_UNIFORM_COMPONENTS=_C('GL_MAX_TESS_CONTROL_UNIFORM_COMPONENTS',0x8E7F) +GL_MAX_TESS_EVALUATION_INPUT_COMPONENTS=_C('GL_MAX_TESS_EVALUATION_INPUT_COMPONENTS',0x886D) +GL_MAX_TESS_EVALUATION_OUTPUT_COMPONENTS=_C('GL_MAX_TESS_EVALUATION_OUTPUT_COMPONENTS',0x8E86) +GL_MAX_TESS_EVALUATION_TEXTURE_IMAGE_UNITS=_C('GL_MAX_TESS_EVALUATION_TEXTURE_IMAGE_UNITS',0x8E82) +GL_MAX_TESS_EVALUATION_UNIFORM_BLOCKS=_C('GL_MAX_TESS_EVALUATION_UNIFORM_BLOCKS',0x8E8A) +GL_MAX_TESS_EVALUATION_UNIFORM_COMPONENTS=_C('GL_MAX_TESS_EVALUATION_UNIFORM_COMPONENTS',0x8E80) +GL_MAX_TESS_GEN_LEVEL=_C('GL_MAX_TESS_GEN_LEVEL',0x8E7E) +GL_MAX_TESS_PATCH_COMPONENTS=_C('GL_MAX_TESS_PATCH_COMPONENTS',0x8E84) +GL_PATCHES=_C('GL_PATCHES',0x000E) +GL_PATCH_DEFAULT_INNER_LEVEL=_C('GL_PATCH_DEFAULT_INNER_LEVEL',0x8E73) +GL_PATCH_DEFAULT_OUTER_LEVEL=_C('GL_PATCH_DEFAULT_OUTER_LEVEL',0x8E74) +GL_PATCH_VERTICES=_C('GL_PATCH_VERTICES',0x8E72) +GL_QUADS=_C('GL_QUADS',0x0007) +GL_TESS_CONTROL_OUTPUT_VERTICES=_C('GL_TESS_CONTROL_OUTPUT_VERTICES',0x8E75) +GL_TESS_CONTROL_SHADER=_C('GL_TESS_CONTROL_SHADER',0x8E88) +GL_TESS_EVALUATION_SHADER=_C('GL_TESS_EVALUATION_SHADER',0x8E87) +GL_TESS_GEN_MODE=_C('GL_TESS_GEN_MODE',0x8E76) +GL_TESS_GEN_POINT_MODE=_C('GL_TESS_GEN_POINT_MODE',0x8E79) +GL_TESS_GEN_SPACING=_C('GL_TESS_GEN_SPACING',0x8E77) +GL_TESS_GEN_VERTEX_ORDER=_C('GL_TESS_GEN_VERTEX_ORDER',0x8E78) +GL_TRIANGLES=_C('GL_TRIANGLES',0x0004) +GL_UNIFORM_BLOCK_REFERENCED_BY_TESS_CONTROL_SHADER=_C('GL_UNIFORM_BLOCK_REFERENCED_BY_TESS_CONTROL_SHADER',0x84F0) +GL_UNIFORM_BLOCK_REFERENCED_BY_TESS_EVALUATION_SHADER=_C('GL_UNIFORM_BLOCK_REFERENCED_BY_TESS_EVALUATION_SHADER',0x84F1) +@_f +@_p.types(None,_cs.GLenum,arrays.GLfloatArray) +def glPatchParameterfv(pname,values):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLint) +def glPatchParameteri(pname,value):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/texture_barrier.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/texture_barrier.py new file mode 100644 index 00000000..8afcf462 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/texture_barrier.py @@ -0,0 +1,17 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_texture_barrier' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_texture_barrier',error_checker=_errors._error_checker) + +@_f +@_p.types(None,) +def glTextureBarrier():pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/texture_border_clamp.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/texture_border_clamp.py new file mode 100644 index 00000000..df4afd31 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/texture_border_clamp.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_texture_border_clamp' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_texture_border_clamp',error_checker=_errors._error_checker) +GL_CLAMP_TO_BORDER_ARB=_C('GL_CLAMP_TO_BORDER_ARB',0x812D) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/texture_buffer_object.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/texture_buffer_object.py new file mode 100644 index 00000000..9881b3d9 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/texture_buffer_object.py @@ -0,0 +1,21 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_texture_buffer_object' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_texture_buffer_object',error_checker=_errors._error_checker) +GL_MAX_TEXTURE_BUFFER_SIZE_ARB=_C('GL_MAX_TEXTURE_BUFFER_SIZE_ARB',0x8C2B) +GL_TEXTURE_BINDING_BUFFER_ARB=_C('GL_TEXTURE_BINDING_BUFFER_ARB',0x8C2C) +GL_TEXTURE_BUFFER_ARB=_C('GL_TEXTURE_BUFFER_ARB',0x8C2A) +GL_TEXTURE_BUFFER_DATA_STORE_BINDING_ARB=_C('GL_TEXTURE_BUFFER_DATA_STORE_BINDING_ARB',0x8C2D) +GL_TEXTURE_BUFFER_FORMAT_ARB=_C('GL_TEXTURE_BUFFER_FORMAT_ARB',0x8C2E) +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLuint) +def glTexBufferARB(target,internalformat,buffer):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/texture_buffer_object_rgb32.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/texture_buffer_object_rgb32.py new file mode 100644 index 00000000..7501b7eb --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/texture_buffer_object_rgb32.py @@ -0,0 +1,17 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_texture_buffer_object_rgb32' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_texture_buffer_object_rgb32',error_checker=_errors._error_checker) +GL_RGB32F=_C('GL_RGB32F',0x8815) +GL_RGB32I=_C('GL_RGB32I',0x8D83) +GL_RGB32UI=_C('GL_RGB32UI',0x8D71) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/texture_buffer_range.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/texture_buffer_range.py new file mode 100644 index 00000000..28b5043e --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/texture_buffer_range.py @@ -0,0 +1,19 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_texture_buffer_range' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_texture_buffer_range',error_checker=_errors._error_checker) +GL_TEXTURE_BUFFER_OFFSET=_C('GL_TEXTURE_BUFFER_OFFSET',0x919D) +GL_TEXTURE_BUFFER_OFFSET_ALIGNMENT=_C('GL_TEXTURE_BUFFER_OFFSET_ALIGNMENT',0x919F) +GL_TEXTURE_BUFFER_SIZE=_C('GL_TEXTURE_BUFFER_SIZE',0x919E) +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLuint,_cs.GLintptr,_cs.GLsizeiptr) +def glTexBufferRange(target,internalformat,buffer,offset,size):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/texture_compression.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/texture_compression.py new file mode 100644 index 00000000..b29492ce --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/texture_compression.py @@ -0,0 +1,45 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_texture_compression' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_texture_compression',error_checker=_errors._error_checker) +GL_COMPRESSED_ALPHA_ARB=_C('GL_COMPRESSED_ALPHA_ARB',0x84E9) +GL_COMPRESSED_INTENSITY_ARB=_C('GL_COMPRESSED_INTENSITY_ARB',0x84EC) +GL_COMPRESSED_LUMINANCE_ALPHA_ARB=_C('GL_COMPRESSED_LUMINANCE_ALPHA_ARB',0x84EB) +GL_COMPRESSED_LUMINANCE_ARB=_C('GL_COMPRESSED_LUMINANCE_ARB',0x84EA) +GL_COMPRESSED_RGBA_ARB=_C('GL_COMPRESSED_RGBA_ARB',0x84EE) +GL_COMPRESSED_RGB_ARB=_C('GL_COMPRESSED_RGB_ARB',0x84ED) +GL_COMPRESSED_TEXTURE_FORMATS_ARB=_C('GL_COMPRESSED_TEXTURE_FORMATS_ARB',0x86A3) +GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB=_C('GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB',0x86A2) +GL_TEXTURE_COMPRESSED_ARB=_C('GL_TEXTURE_COMPRESSED_ARB',0x86A1) +GL_TEXTURE_COMPRESSED_IMAGE_SIZE_ARB=_C('GL_TEXTURE_COMPRESSED_IMAGE_SIZE_ARB',0x86A0) +GL_TEXTURE_COMPRESSION_HINT_ARB=_C('GL_TEXTURE_COMPRESSION_HINT_ARB',0x84EF) +@_f +@_p.types(None,_cs.GLenum,_cs.GLint,_cs.GLenum,_cs.GLsizei,_cs.GLint,_cs.GLsizei,ctypes.c_void_p) +def glCompressedTexImage1DARB(target,level,internalformat,width,border,imageSize,data):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLint,_cs.GLenum,_cs.GLsizei,_cs.GLsizei,_cs.GLint,_cs.GLsizei,ctypes.c_void_p) +def glCompressedTexImage2DARB(target,level,internalformat,width,height,border,imageSize,data):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLint,_cs.GLenum,_cs.GLsizei,_cs.GLsizei,_cs.GLsizei,_cs.GLint,_cs.GLsizei,ctypes.c_void_p) +def glCompressedTexImage3DARB(target,level,internalformat,width,height,depth,border,imageSize,data):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLenum,_cs.GLsizei,ctypes.c_void_p) +def glCompressedTexSubImage1DARB(target,level,xoffset,width,format,imageSize,data):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLsizei,_cs.GLenum,_cs.GLsizei,ctypes.c_void_p) +def glCompressedTexSubImage2DARB(target,level,xoffset,yoffset,width,height,format,imageSize,data):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLsizei,_cs.GLsizei,_cs.GLenum,_cs.GLsizei,ctypes.c_void_p) +def glCompressedTexSubImage3DARB(target,level,xoffset,yoffset,zoffset,width,height,depth,format,imageSize,data):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLint,ctypes.c_void_p) +def glGetCompressedTexImageARB(target,level,img):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/texture_compression_bptc.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/texture_compression_bptc.py new file mode 100644 index 00000000..51aa37d6 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/texture_compression_bptc.py @@ -0,0 +1,18 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_texture_compression_bptc' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_texture_compression_bptc',error_checker=_errors._error_checker) +GL_COMPRESSED_RGBA_BPTC_UNORM_ARB=_C('GL_COMPRESSED_RGBA_BPTC_UNORM_ARB',0x8E8C) +GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT_ARB=_C('GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT_ARB',0x8E8E) +GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT_ARB=_C('GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT_ARB',0x8E8F) +GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM_ARB=_C('GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM_ARB',0x8E8D) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/texture_compression_rgtc.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/texture_compression_rgtc.py new file mode 100644 index 00000000..4303aa9a --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/texture_compression_rgtc.py @@ -0,0 +1,18 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_texture_compression_rgtc' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_texture_compression_rgtc',error_checker=_errors._error_checker) +GL_COMPRESSED_RED_RGTC1=_C('GL_COMPRESSED_RED_RGTC1',0x8DBB) +GL_COMPRESSED_RG_RGTC2=_C('GL_COMPRESSED_RG_RGTC2',0x8DBD) +GL_COMPRESSED_SIGNED_RED_RGTC1=_C('GL_COMPRESSED_SIGNED_RED_RGTC1',0x8DBC) +GL_COMPRESSED_SIGNED_RG_RGTC2=_C('GL_COMPRESSED_SIGNED_RG_RGTC2',0x8DBE) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/texture_cube_map.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/texture_cube_map.py new file mode 100644 index 00000000..dcf0f9a2 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/texture_cube_map.py @@ -0,0 +1,26 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_texture_cube_map' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_texture_cube_map',error_checker=_errors._error_checker) +GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB=_C('GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB',0x851C) +GL_NORMAL_MAP_ARB=_C('GL_NORMAL_MAP_ARB',0x8511) +GL_PROXY_TEXTURE_CUBE_MAP_ARB=_C('GL_PROXY_TEXTURE_CUBE_MAP_ARB',0x851B) +GL_REFLECTION_MAP_ARB=_C('GL_REFLECTION_MAP_ARB',0x8512) +GL_TEXTURE_BINDING_CUBE_MAP_ARB=_C('GL_TEXTURE_BINDING_CUBE_MAP_ARB',0x8514) +GL_TEXTURE_CUBE_MAP_ARB=_C('GL_TEXTURE_CUBE_MAP_ARB',0x8513) +GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB=_C('GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB',0x8516) +GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB=_C('GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB',0x8518) +GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB=_C('GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB',0x851A) +GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB=_C('GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB',0x8515) +GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB=_C('GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB',0x8517) +GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB=_C('GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB',0x8519) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/texture_cube_map_array.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/texture_cube_map_array.py new file mode 100644 index 00000000..00be708a --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/texture_cube_map_array.py @@ -0,0 +1,21 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_texture_cube_map_array' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_texture_cube_map_array',error_checker=_errors._error_checker) +GL_INT_SAMPLER_CUBE_MAP_ARRAY_ARB=_C('GL_INT_SAMPLER_CUBE_MAP_ARRAY_ARB',0x900E) +GL_PROXY_TEXTURE_CUBE_MAP_ARRAY_ARB=_C('GL_PROXY_TEXTURE_CUBE_MAP_ARRAY_ARB',0x900B) +GL_SAMPLER_CUBE_MAP_ARRAY_ARB=_C('GL_SAMPLER_CUBE_MAP_ARRAY_ARB',0x900C) +GL_SAMPLER_CUBE_MAP_ARRAY_SHADOW_ARB=_C('GL_SAMPLER_CUBE_MAP_ARRAY_SHADOW_ARB',0x900D) +GL_TEXTURE_BINDING_CUBE_MAP_ARRAY_ARB=_C('GL_TEXTURE_BINDING_CUBE_MAP_ARRAY_ARB',0x900A) +GL_TEXTURE_CUBE_MAP_ARRAY_ARB=_C('GL_TEXTURE_CUBE_MAP_ARRAY_ARB',0x9009) +GL_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY_ARB=_C('GL_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY_ARB',0x900F) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/texture_env_add.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/texture_env_add.py new file mode 100644 index 00000000..ee986452 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/texture_env_add.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_texture_env_add' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_texture_env_add',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/texture_env_combine.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/texture_env_combine.py new file mode 100644 index 00000000..4ffddaba --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/texture_env_combine.py @@ -0,0 +1,36 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_texture_env_combine' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_texture_env_combine',error_checker=_errors._error_checker) +GL_ADD_SIGNED_ARB=_C('GL_ADD_SIGNED_ARB',0x8574) +GL_COMBINE_ALPHA_ARB=_C('GL_COMBINE_ALPHA_ARB',0x8572) +GL_COMBINE_ARB=_C('GL_COMBINE_ARB',0x8570) +GL_COMBINE_RGB_ARB=_C('GL_COMBINE_RGB_ARB',0x8571) +GL_CONSTANT_ARB=_C('GL_CONSTANT_ARB',0x8576) +GL_INTERPOLATE_ARB=_C('GL_INTERPOLATE_ARB',0x8575) +GL_OPERAND0_ALPHA_ARB=_C('GL_OPERAND0_ALPHA_ARB',0x8598) +GL_OPERAND0_RGB_ARB=_C('GL_OPERAND0_RGB_ARB',0x8590) +GL_OPERAND1_ALPHA_ARB=_C('GL_OPERAND1_ALPHA_ARB',0x8599) +GL_OPERAND1_RGB_ARB=_C('GL_OPERAND1_RGB_ARB',0x8591) +GL_OPERAND2_ALPHA_ARB=_C('GL_OPERAND2_ALPHA_ARB',0x859A) +GL_OPERAND2_RGB_ARB=_C('GL_OPERAND2_RGB_ARB',0x8592) +GL_PREVIOUS_ARB=_C('GL_PREVIOUS_ARB',0x8578) +GL_PRIMARY_COLOR_ARB=_C('GL_PRIMARY_COLOR_ARB',0x8577) +GL_RGB_SCALE_ARB=_C('GL_RGB_SCALE_ARB',0x8573) +GL_SOURCE0_ALPHA_ARB=_C('GL_SOURCE0_ALPHA_ARB',0x8588) +GL_SOURCE0_RGB_ARB=_C('GL_SOURCE0_RGB_ARB',0x8580) +GL_SOURCE1_ALPHA_ARB=_C('GL_SOURCE1_ALPHA_ARB',0x8589) +GL_SOURCE1_RGB_ARB=_C('GL_SOURCE1_RGB_ARB',0x8581) +GL_SOURCE2_ALPHA_ARB=_C('GL_SOURCE2_ALPHA_ARB',0x858A) +GL_SOURCE2_RGB_ARB=_C('GL_SOURCE2_RGB_ARB',0x8582) +GL_SUBTRACT_ARB=_C('GL_SUBTRACT_ARB',0x84E7) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/texture_env_crossbar.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/texture_env_crossbar.py new file mode 100644 index 00000000..ca832815 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/texture_env_crossbar.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_texture_env_crossbar' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_texture_env_crossbar',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/texture_env_dot3.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/texture_env_dot3.py new file mode 100644 index 00000000..8177c9d3 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/texture_env_dot3.py @@ -0,0 +1,16 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_texture_env_dot3' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_texture_env_dot3',error_checker=_errors._error_checker) +GL_DOT3_RGBA_ARB=_C('GL_DOT3_RGBA_ARB',0x86AF) +GL_DOT3_RGB_ARB=_C('GL_DOT3_RGB_ARB',0x86AE) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/texture_filter_anisotropic.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/texture_filter_anisotropic.py new file mode 100644 index 00000000..3b27c493 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/texture_filter_anisotropic.py @@ -0,0 +1,16 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_texture_filter_anisotropic' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_texture_filter_anisotropic',error_checker=_errors._error_checker) +GL_MAX_TEXTURE_MAX_ANISOTROPY=_C('GL_MAX_TEXTURE_MAX_ANISOTROPY',0x84FF) +GL_TEXTURE_MAX_ANISOTROPY=_C('GL_TEXTURE_MAX_ANISOTROPY',0x84FE) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/texture_filter_minmax.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/texture_filter_minmax.py new file mode 100644 index 00000000..62f1d06b --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/texture_filter_minmax.py @@ -0,0 +1,16 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_texture_filter_minmax' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_texture_filter_minmax',error_checker=_errors._error_checker) +GL_TEXTURE_REDUCTION_MODE_ARB=_C('GL_TEXTURE_REDUCTION_MODE_ARB',0x9366) +GL_WEIGHTED_AVERAGE_ARB=_C('GL_WEIGHTED_AVERAGE_ARB',0x9367) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/texture_float.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/texture_float.py new file mode 100644 index 00000000..505c967b --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/texture_float.py @@ -0,0 +1,34 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_texture_float' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_texture_float',error_checker=_errors._error_checker) +GL_ALPHA16F_ARB=_C('GL_ALPHA16F_ARB',0x881C) +GL_ALPHA32F_ARB=_C('GL_ALPHA32F_ARB',0x8816) +GL_INTENSITY16F_ARB=_C('GL_INTENSITY16F_ARB',0x881D) +GL_INTENSITY32F_ARB=_C('GL_INTENSITY32F_ARB',0x8817) +GL_LUMINANCE16F_ARB=_C('GL_LUMINANCE16F_ARB',0x881E) +GL_LUMINANCE32F_ARB=_C('GL_LUMINANCE32F_ARB',0x8818) +GL_LUMINANCE_ALPHA16F_ARB=_C('GL_LUMINANCE_ALPHA16F_ARB',0x881F) +GL_LUMINANCE_ALPHA32F_ARB=_C('GL_LUMINANCE_ALPHA32F_ARB',0x8819) +GL_RGB16F_ARB=_C('GL_RGB16F_ARB',0x881B) +GL_RGB32F_ARB=_C('GL_RGB32F_ARB',0x8815) +GL_RGBA16F_ARB=_C('GL_RGBA16F_ARB',0x881A) +GL_RGBA32F_ARB=_C('GL_RGBA32F_ARB',0x8814) +GL_TEXTURE_ALPHA_TYPE_ARB=_C('GL_TEXTURE_ALPHA_TYPE_ARB',0x8C13) +GL_TEXTURE_BLUE_TYPE_ARB=_C('GL_TEXTURE_BLUE_TYPE_ARB',0x8C12) +GL_TEXTURE_DEPTH_TYPE_ARB=_C('GL_TEXTURE_DEPTH_TYPE_ARB',0x8C16) +GL_TEXTURE_GREEN_TYPE_ARB=_C('GL_TEXTURE_GREEN_TYPE_ARB',0x8C11) +GL_TEXTURE_INTENSITY_TYPE_ARB=_C('GL_TEXTURE_INTENSITY_TYPE_ARB',0x8C15) +GL_TEXTURE_LUMINANCE_TYPE_ARB=_C('GL_TEXTURE_LUMINANCE_TYPE_ARB',0x8C14) +GL_TEXTURE_RED_TYPE_ARB=_C('GL_TEXTURE_RED_TYPE_ARB',0x8C10) +GL_UNSIGNED_NORMALIZED_ARB=_C('GL_UNSIGNED_NORMALIZED_ARB',0x8C17) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/texture_gather.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/texture_gather.py new file mode 100644 index 00000000..43a87135 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/texture_gather.py @@ -0,0 +1,17 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_texture_gather' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_texture_gather',error_checker=_errors._error_checker) +GL_MAX_PROGRAM_TEXTURE_GATHER_COMPONENTS_ARB=_C('GL_MAX_PROGRAM_TEXTURE_GATHER_COMPONENTS_ARB',0x8F9F) +GL_MAX_PROGRAM_TEXTURE_GATHER_OFFSET_ARB=_C('GL_MAX_PROGRAM_TEXTURE_GATHER_OFFSET_ARB',0x8E5F) +GL_MIN_PROGRAM_TEXTURE_GATHER_OFFSET_ARB=_C('GL_MIN_PROGRAM_TEXTURE_GATHER_OFFSET_ARB',0x8E5E) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/texture_mirror_clamp_to_edge.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/texture_mirror_clamp_to_edge.py new file mode 100644 index 00000000..b621d64f --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/texture_mirror_clamp_to_edge.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_texture_mirror_clamp_to_edge' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_texture_mirror_clamp_to_edge',error_checker=_errors._error_checker) +GL_MIRROR_CLAMP_TO_EDGE=_C('GL_MIRROR_CLAMP_TO_EDGE',0x8743) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/texture_mirrored_repeat.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/texture_mirrored_repeat.py new file mode 100644 index 00000000..6fafb945 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/texture_mirrored_repeat.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_texture_mirrored_repeat' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_texture_mirrored_repeat',error_checker=_errors._error_checker) +GL_MIRRORED_REPEAT_ARB=_C('GL_MIRRORED_REPEAT_ARB',0x8370) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/texture_multisample.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/texture_multisample.py new file mode 100644 index 00000000..fd23d6aa --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/texture_multisample.py @@ -0,0 +1,46 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_texture_multisample' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_texture_multisample',error_checker=_errors._error_checker) +GL_INT_SAMPLER_2D_MULTISAMPLE=_C('GL_INT_SAMPLER_2D_MULTISAMPLE',0x9109) +GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY=_C('GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY',0x910C) +GL_MAX_COLOR_TEXTURE_SAMPLES=_C('GL_MAX_COLOR_TEXTURE_SAMPLES',0x910E) +GL_MAX_DEPTH_TEXTURE_SAMPLES=_C('GL_MAX_DEPTH_TEXTURE_SAMPLES',0x910F) +GL_MAX_INTEGER_SAMPLES=_C('GL_MAX_INTEGER_SAMPLES',0x9110) +GL_MAX_SAMPLE_MASK_WORDS=_C('GL_MAX_SAMPLE_MASK_WORDS',0x8E59) +GL_PROXY_TEXTURE_2D_MULTISAMPLE=_C('GL_PROXY_TEXTURE_2D_MULTISAMPLE',0x9101) +GL_PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY=_C('GL_PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY',0x9103) +GL_SAMPLER_2D_MULTISAMPLE=_C('GL_SAMPLER_2D_MULTISAMPLE',0x9108) +GL_SAMPLER_2D_MULTISAMPLE_ARRAY=_C('GL_SAMPLER_2D_MULTISAMPLE_ARRAY',0x910B) +GL_SAMPLE_MASK=_C('GL_SAMPLE_MASK',0x8E51) +GL_SAMPLE_MASK_VALUE=_C('GL_SAMPLE_MASK_VALUE',0x8E52) +GL_SAMPLE_POSITION=_C('GL_SAMPLE_POSITION',0x8E50) +GL_TEXTURE_2D_MULTISAMPLE=_C('GL_TEXTURE_2D_MULTISAMPLE',0x9100) +GL_TEXTURE_2D_MULTISAMPLE_ARRAY=_C('GL_TEXTURE_2D_MULTISAMPLE_ARRAY',0x9102) +GL_TEXTURE_BINDING_2D_MULTISAMPLE=_C('GL_TEXTURE_BINDING_2D_MULTISAMPLE',0x9104) +GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY=_C('GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY',0x9105) +GL_TEXTURE_FIXED_SAMPLE_LOCATIONS=_C('GL_TEXTURE_FIXED_SAMPLE_LOCATIONS',0x9107) +GL_TEXTURE_SAMPLES=_C('GL_TEXTURE_SAMPLES',0x9106) +GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE=_C('GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE',0x910A) +GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY=_C('GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY',0x910D) +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,arrays.GLfloatArray) +def glGetMultisamplefv(pname,index,val):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLbitfield) +def glSampleMaski(maskNumber,mask):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizei,_cs.GLenum,_cs.GLsizei,_cs.GLsizei,_cs.GLboolean) +def glTexImage2DMultisample(target,samples,internalformat,width,height,fixedsamplelocations):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizei,_cs.GLenum,_cs.GLsizei,_cs.GLsizei,_cs.GLsizei,_cs.GLboolean) +def glTexImage3DMultisample(target,samples,internalformat,width,height,depth,fixedsamplelocations):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/texture_non_power_of_two.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/texture_non_power_of_two.py new file mode 100644 index 00000000..490efef2 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/texture_non_power_of_two.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_texture_non_power_of_two' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_texture_non_power_of_two',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/texture_query_levels.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/texture_query_levels.py new file mode 100644 index 00000000..b457472b --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/texture_query_levels.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_texture_query_levels' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_texture_query_levels',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/texture_query_lod.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/texture_query_lod.py new file mode 100644 index 00000000..ea8dcc15 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/texture_query_lod.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_texture_query_lod' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_texture_query_lod',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/texture_rectangle.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/texture_rectangle.py new file mode 100644 index 00000000..a819a1d9 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/texture_rectangle.py @@ -0,0 +1,18 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_texture_rectangle' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_texture_rectangle',error_checker=_errors._error_checker) +GL_MAX_RECTANGLE_TEXTURE_SIZE_ARB=_C('GL_MAX_RECTANGLE_TEXTURE_SIZE_ARB',0x84F8) +GL_PROXY_TEXTURE_RECTANGLE_ARB=_C('GL_PROXY_TEXTURE_RECTANGLE_ARB',0x84F7) +GL_TEXTURE_BINDING_RECTANGLE_ARB=_C('GL_TEXTURE_BINDING_RECTANGLE_ARB',0x84F6) +GL_TEXTURE_RECTANGLE_ARB=_C('GL_TEXTURE_RECTANGLE_ARB',0x84F5) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/texture_rg.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/texture_rg.py new file mode 100644 index 00000000..b22150d5 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/texture_rg.py @@ -0,0 +1,36 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_texture_rg' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_texture_rg',error_checker=_errors._error_checker) +GL_R16=_C('GL_R16',0x822A) +GL_R16F=_C('GL_R16F',0x822D) +GL_R16I=_C('GL_R16I',0x8233) +GL_R16UI=_C('GL_R16UI',0x8234) +GL_R32F=_C('GL_R32F',0x822E) +GL_R32I=_C('GL_R32I',0x8235) +GL_R32UI=_C('GL_R32UI',0x8236) +GL_R8=_C('GL_R8',0x8229) +GL_R8I=_C('GL_R8I',0x8231) +GL_R8UI=_C('GL_R8UI',0x8232) +GL_RG=_C('GL_RG',0x8227) +GL_RG16=_C('GL_RG16',0x822C) +GL_RG16F=_C('GL_RG16F',0x822F) +GL_RG16I=_C('GL_RG16I',0x8239) +GL_RG16UI=_C('GL_RG16UI',0x823A) +GL_RG32F=_C('GL_RG32F',0x8230) +GL_RG32I=_C('GL_RG32I',0x823B) +GL_RG32UI=_C('GL_RG32UI',0x823C) +GL_RG8=_C('GL_RG8',0x822B) +GL_RG8I=_C('GL_RG8I',0x8237) +GL_RG8UI=_C('GL_RG8UI',0x8238) +GL_RG_INTEGER=_C('GL_RG_INTEGER',0x8228) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/texture_rgb10_a2ui.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/texture_rgb10_a2ui.py new file mode 100644 index 00000000..ee13fc43 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/texture_rgb10_a2ui.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_texture_rgb10_a2ui' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_texture_rgb10_a2ui',error_checker=_errors._error_checker) +GL_RGB10_A2UI=_C('GL_RGB10_A2UI',0x906F) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/texture_stencil8.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/texture_stencil8.py new file mode 100644 index 00000000..a11b7ef5 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/texture_stencil8.py @@ -0,0 +1,16 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_texture_stencil8' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_texture_stencil8',error_checker=_errors._error_checker) +GL_STENCIL_INDEX=_C('GL_STENCIL_INDEX',0x1901) +GL_STENCIL_INDEX8=_C('GL_STENCIL_INDEX8',0x8D48) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/texture_storage.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/texture_storage.py new file mode 100644 index 00000000..0da2a2d5 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/texture_storage.py @@ -0,0 +1,23 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_texture_storage' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_texture_storage',error_checker=_errors._error_checker) +GL_TEXTURE_IMMUTABLE_FORMAT=_C('GL_TEXTURE_IMMUTABLE_FORMAT',0x912F) +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizei,_cs.GLenum,_cs.GLsizei) +def glTexStorage1D(target,levels,internalformat,width):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizei,_cs.GLenum,_cs.GLsizei,_cs.GLsizei) +def glTexStorage2D(target,levels,internalformat,width,height):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizei,_cs.GLenum,_cs.GLsizei,_cs.GLsizei,_cs.GLsizei) +def glTexStorage3D(target,levels,internalformat,width,height,depth):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/texture_storage_multisample.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/texture_storage_multisample.py new file mode 100644 index 00000000..e99b9bc0 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/texture_storage_multisample.py @@ -0,0 +1,20 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_texture_storage_multisample' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_texture_storage_multisample',error_checker=_errors._error_checker) + +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizei,_cs.GLenum,_cs.GLsizei,_cs.GLsizei,_cs.GLboolean) +def glTexStorage2DMultisample(target,samples,internalformat,width,height,fixedsamplelocations):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizei,_cs.GLenum,_cs.GLsizei,_cs.GLsizei,_cs.GLsizei,_cs.GLboolean) +def glTexStorage3DMultisample(target,samples,internalformat,width,height,depth,fixedsamplelocations):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/texture_swizzle.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/texture_swizzle.py new file mode 100644 index 00000000..06ec100d --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/texture_swizzle.py @@ -0,0 +1,19 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_texture_swizzle' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_texture_swizzle',error_checker=_errors._error_checker) +GL_TEXTURE_SWIZZLE_A=_C('GL_TEXTURE_SWIZZLE_A',0x8E45) +GL_TEXTURE_SWIZZLE_B=_C('GL_TEXTURE_SWIZZLE_B',0x8E44) +GL_TEXTURE_SWIZZLE_G=_C('GL_TEXTURE_SWIZZLE_G',0x8E43) +GL_TEXTURE_SWIZZLE_R=_C('GL_TEXTURE_SWIZZLE_R',0x8E42) +GL_TEXTURE_SWIZZLE_RGBA=_C('GL_TEXTURE_SWIZZLE_RGBA',0x8E46) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/texture_view.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/texture_view.py new file mode 100644 index 00000000..c225fa3e --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/texture_view.py @@ -0,0 +1,21 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_texture_view' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_texture_view',error_checker=_errors._error_checker) +GL_TEXTURE_IMMUTABLE_LEVELS=_C('GL_TEXTURE_IMMUTABLE_LEVELS',0x82DF) +GL_TEXTURE_VIEW_MIN_LAYER=_C('GL_TEXTURE_VIEW_MIN_LAYER',0x82DD) +GL_TEXTURE_VIEW_MIN_LEVEL=_C('GL_TEXTURE_VIEW_MIN_LEVEL',0x82DB) +GL_TEXTURE_VIEW_NUM_LAYERS=_C('GL_TEXTURE_VIEW_NUM_LAYERS',0x82DE) +GL_TEXTURE_VIEW_NUM_LEVELS=_C('GL_TEXTURE_VIEW_NUM_LEVELS',0x82DC) +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLuint,_cs.GLenum,_cs.GLuint,_cs.GLuint,_cs.GLuint,_cs.GLuint) +def glTextureView(texture,target,origtexture,internalformat,minlevel,numlevels,minlayer,numlayers):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/timer_query.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/timer_query.py new file mode 100644 index 00000000..85c93175 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/timer_query.py @@ -0,0 +1,24 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_timer_query' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_timer_query',error_checker=_errors._error_checker) +GL_TIMESTAMP=_C('GL_TIMESTAMP',0x8E28) +GL_TIME_ELAPSED=_C('GL_TIME_ELAPSED',0x88BF) +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLint64Array) +def glGetQueryObjecti64v(id,pname,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLuint64Array) +def glGetQueryObjectui64v(id,pname,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum) +def glQueryCounter(id,target):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/transform_feedback2.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/transform_feedback2.py new file mode 100644 index 00000000..48cdcc4d --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/transform_feedback2.py @@ -0,0 +1,38 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_transform_feedback2' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_transform_feedback2',error_checker=_errors._error_checker) +GL_TRANSFORM_FEEDBACK=_C('GL_TRANSFORM_FEEDBACK',0x8E22) +GL_TRANSFORM_FEEDBACK_BINDING=_C('GL_TRANSFORM_FEEDBACK_BINDING',0x8E25) +GL_TRANSFORM_FEEDBACK_BUFFER_ACTIVE=_C('GL_TRANSFORM_FEEDBACK_BUFFER_ACTIVE',0x8E24) +GL_TRANSFORM_FEEDBACK_BUFFER_PAUSED=_C('GL_TRANSFORM_FEEDBACK_BUFFER_PAUSED',0x8E23) +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint) +def glBindTransformFeedback(target,id):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray) +def glDeleteTransformFeedbacks(n,ids):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint) +def glDrawTransformFeedback(mode,id):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray) +def glGenTransformFeedbacks(n,ids):pass +@_f +@_p.types(_cs.GLboolean,_cs.GLuint) +def glIsTransformFeedback(id):pass +@_f +@_p.types(None,) +def glPauseTransformFeedback():pass +@_f +@_p.types(None,) +def glResumeTransformFeedback():pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/transform_feedback3.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/transform_feedback3.py new file mode 100644 index 00000000..5f810c8e --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/transform_feedback3.py @@ -0,0 +1,27 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_transform_feedback3' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_transform_feedback3',error_checker=_errors._error_checker) +GL_MAX_TRANSFORM_FEEDBACK_BUFFERS=_C('GL_MAX_TRANSFORM_FEEDBACK_BUFFERS',0x8E70) +GL_MAX_VERTEX_STREAMS=_C('GL_MAX_VERTEX_STREAMS',0x8E71) +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,_cs.GLuint) +def glBeginQueryIndexed(target,index,id):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,_cs.GLuint) +def glDrawTransformFeedbackStream(mode,id,stream):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint) +def glEndQueryIndexed(target,index):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,_cs.GLenum,arrays.GLintArray) +def glGetQueryIndexediv(target,index,pname,params):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/transform_feedback_instanced.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/transform_feedback_instanced.py new file mode 100644 index 00000000..0d674075 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/transform_feedback_instanced.py @@ -0,0 +1,20 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_transform_feedback_instanced' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_transform_feedback_instanced',error_checker=_errors._error_checker) + +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,_cs.GLsizei) +def glDrawTransformFeedbackInstanced(mode,id,instancecount):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,_cs.GLuint,_cs.GLsizei) +def glDrawTransformFeedbackStreamInstanced(mode,id,stream,instancecount):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/transform_feedback_overflow_query.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/transform_feedback_overflow_query.py new file mode 100644 index 00000000..4c611f0d --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/transform_feedback_overflow_query.py @@ -0,0 +1,16 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_transform_feedback_overflow_query' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_transform_feedback_overflow_query',error_checker=_errors._error_checker) +GL_TRANSFORM_FEEDBACK_OVERFLOW_ARB=_C('GL_TRANSFORM_FEEDBACK_OVERFLOW_ARB',0x82EC) +GL_TRANSFORM_FEEDBACK_STREAM_OVERFLOW_ARB=_C('GL_TRANSFORM_FEEDBACK_STREAM_OVERFLOW_ARB',0x82ED) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/transpose_matrix.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/transpose_matrix.py new file mode 100644 index 00000000..233cfc3a --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/transpose_matrix.py @@ -0,0 +1,29 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_transpose_matrix' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_transpose_matrix',error_checker=_errors._error_checker) +GL_TRANSPOSE_COLOR_MATRIX_ARB=_C('GL_TRANSPOSE_COLOR_MATRIX_ARB',0x84E6) +GL_TRANSPOSE_MODELVIEW_MATRIX_ARB=_C('GL_TRANSPOSE_MODELVIEW_MATRIX_ARB',0x84E3) +GL_TRANSPOSE_PROJECTION_MATRIX_ARB=_C('GL_TRANSPOSE_PROJECTION_MATRIX_ARB',0x84E4) +GL_TRANSPOSE_TEXTURE_MATRIX_ARB=_C('GL_TRANSPOSE_TEXTURE_MATRIX_ARB',0x84E5) +@_f +@_p.types(None,arrays.GLdoubleArray) +def glLoadTransposeMatrixdARB(m):pass +@_f +@_p.types(None,arrays.GLfloatArray) +def glLoadTransposeMatrixfARB(m):pass +@_f +@_p.types(None,arrays.GLdoubleArray) +def glMultTransposeMatrixdARB(m):pass +@_f +@_p.types(None,arrays.GLfloatArray) +def glMultTransposeMatrixfARB(m):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/uniform_buffer_object.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/uniform_buffer_object.py new file mode 100644 index 00000000..a60e738d --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/uniform_buffer_object.py @@ -0,0 +1,76 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_uniform_buffer_object' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_uniform_buffer_object',error_checker=_errors._error_checker) +GL_ACTIVE_UNIFORM_BLOCKS=_C('GL_ACTIVE_UNIFORM_BLOCKS',0x8A36) +GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH=_C('GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH',0x8A35) +GL_INVALID_INDEX=_C('GL_INVALID_INDEX',0xFFFFFFFF) +GL_MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS=_C('GL_MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS',0x8A33) +GL_MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS=_C('GL_MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS',0x8A32) +GL_MAX_COMBINED_UNIFORM_BLOCKS=_C('GL_MAX_COMBINED_UNIFORM_BLOCKS',0x8A2E) +GL_MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS=_C('GL_MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS',0x8A31) +GL_MAX_FRAGMENT_UNIFORM_BLOCKS=_C('GL_MAX_FRAGMENT_UNIFORM_BLOCKS',0x8A2D) +GL_MAX_GEOMETRY_UNIFORM_BLOCKS=_C('GL_MAX_GEOMETRY_UNIFORM_BLOCKS',0x8A2C) +GL_MAX_UNIFORM_BLOCK_SIZE=_C('GL_MAX_UNIFORM_BLOCK_SIZE',0x8A30) +GL_MAX_UNIFORM_BUFFER_BINDINGS=_C('GL_MAX_UNIFORM_BUFFER_BINDINGS',0x8A2F) +GL_MAX_VERTEX_UNIFORM_BLOCKS=_C('GL_MAX_VERTEX_UNIFORM_BLOCKS',0x8A2B) +GL_UNIFORM_ARRAY_STRIDE=_C('GL_UNIFORM_ARRAY_STRIDE',0x8A3C) +GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS=_C('GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS',0x8A42) +GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES=_C('GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES',0x8A43) +GL_UNIFORM_BLOCK_BINDING=_C('GL_UNIFORM_BLOCK_BINDING',0x8A3F) +GL_UNIFORM_BLOCK_DATA_SIZE=_C('GL_UNIFORM_BLOCK_DATA_SIZE',0x8A40) +GL_UNIFORM_BLOCK_INDEX=_C('GL_UNIFORM_BLOCK_INDEX',0x8A3A) +GL_UNIFORM_BLOCK_NAME_LENGTH=_C('GL_UNIFORM_BLOCK_NAME_LENGTH',0x8A41) +GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER=_C('GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER',0x8A46) +GL_UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER=_C('GL_UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER',0x8A45) +GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER=_C('GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER',0x8A44) +GL_UNIFORM_BUFFER=_C('GL_UNIFORM_BUFFER',0x8A11) +GL_UNIFORM_BUFFER_BINDING=_C('GL_UNIFORM_BUFFER_BINDING',0x8A28) +GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT=_C('GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT',0x8A34) +GL_UNIFORM_BUFFER_SIZE=_C('GL_UNIFORM_BUFFER_SIZE',0x8A2A) +GL_UNIFORM_BUFFER_START=_C('GL_UNIFORM_BUFFER_START',0x8A29) +GL_UNIFORM_IS_ROW_MAJOR=_C('GL_UNIFORM_IS_ROW_MAJOR',0x8A3E) +GL_UNIFORM_MATRIX_STRIDE=_C('GL_UNIFORM_MATRIX_STRIDE',0x8A3D) +GL_UNIFORM_NAME_LENGTH=_C('GL_UNIFORM_NAME_LENGTH',0x8A39) +GL_UNIFORM_OFFSET=_C('GL_UNIFORM_OFFSET',0x8A3B) +GL_UNIFORM_SIZE=_C('GL_UNIFORM_SIZE',0x8A38) +GL_UNIFORM_TYPE=_C('GL_UNIFORM_TYPE',0x8A37) +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,_cs.GLuint) +def glBindBufferBase(target,index,buffer):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,_cs.GLuint,_cs.GLintptr,_cs.GLsizeiptr) +def glBindBufferRange(target,index,buffer,offset,size):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLsizei,arrays.GLsizeiArray,arrays.GLcharArray) +def glGetActiveUniformBlockName(program,uniformBlockIndex,bufSize,length,uniformBlockName):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLenum,arrays.GLintArray) +def glGetActiveUniformBlockiv(program,uniformBlockIndex,pname,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLsizei,arrays.GLsizeiArray,arrays.GLcharArray) +def glGetActiveUniformName(program,uniformIndex,bufSize,length,uniformName):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizei,arrays.GLuintArray,_cs.GLenum,arrays.GLintArray) +def glGetActiveUniformsiv(program,uniformCount,uniformIndices,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,arrays.GLintArray) +def glGetIntegeri_v(target,index,data):pass +@_f +@_p.types(_cs.GLuint,_cs.GLuint,arrays.GLcharArray) +def glGetUniformBlockIndex(program,uniformBlockName):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizei,ctypes.POINTER( ctypes.POINTER( _cs.GLchar )),arrays.GLuintArray) +def glGetUniformIndices(program,uniformCount,uniformNames,uniformIndices):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLuint) +def glUniformBlockBinding(program,uniformBlockIndex,uniformBlockBinding):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/vertex_array_bgra.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/vertex_array_bgra.py new file mode 100644 index 00000000..2970897d --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/vertex_array_bgra.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_vertex_array_bgra' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_vertex_array_bgra',error_checker=_errors._error_checker) +GL_BGRA=_C('GL_BGRA',0x80E1) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/vertex_array_object.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/vertex_array_object.py new file mode 100644 index 00000000..7bae485d --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/vertex_array_object.py @@ -0,0 +1,26 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_vertex_array_object' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_vertex_array_object',error_checker=_errors._error_checker) +GL_VERTEX_ARRAY_BINDING=_C('GL_VERTEX_ARRAY_BINDING',0x85B5) +@_f +@_p.types(None,_cs.GLuint) +def glBindVertexArray(array):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray) +def glDeleteVertexArrays(n,arrays):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray) +def glGenVertexArrays(n,arrays):pass +@_f +@_p.types(_cs.GLboolean,_cs.GLuint) +def glIsVertexArray(array):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/vertex_attrib_64bit.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/vertex_attrib_64bit.py new file mode 100644 index 00000000..68ef2c40 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/vertex_attrib_64bit.py @@ -0,0 +1,56 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_vertex_attrib_64bit' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_vertex_attrib_64bit',error_checker=_errors._error_checker) +GL_DOUBLE_MAT2=_C('GL_DOUBLE_MAT2',0x8F46) +GL_DOUBLE_MAT2x3=_C('GL_DOUBLE_MAT2x3',0x8F49) +GL_DOUBLE_MAT2x4=_C('GL_DOUBLE_MAT2x4',0x8F4A) +GL_DOUBLE_MAT3=_C('GL_DOUBLE_MAT3',0x8F47) +GL_DOUBLE_MAT3x2=_C('GL_DOUBLE_MAT3x2',0x8F4B) +GL_DOUBLE_MAT3x4=_C('GL_DOUBLE_MAT3x4',0x8F4C) +GL_DOUBLE_MAT4=_C('GL_DOUBLE_MAT4',0x8F48) +GL_DOUBLE_MAT4x2=_C('GL_DOUBLE_MAT4x2',0x8F4D) +GL_DOUBLE_MAT4x3=_C('GL_DOUBLE_MAT4x3',0x8F4E) +GL_DOUBLE_VEC2=_C('GL_DOUBLE_VEC2',0x8FFC) +GL_DOUBLE_VEC3=_C('GL_DOUBLE_VEC3',0x8FFD) +GL_DOUBLE_VEC4=_C('GL_DOUBLE_VEC4',0x8FFE) +GL_RGB32I=_C('GL_RGB32I',0x8D83) +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLdoubleArray) +def glGetVertexAttribLdv(index,pname,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLdouble) +def glVertexAttribL1d(index,x):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLdoubleArray) +def glVertexAttribL1dv(index,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLdouble,_cs.GLdouble) +def glVertexAttribL2d(index,x,y):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLdoubleArray) +def glVertexAttribL2dv(index,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLdouble,_cs.GLdouble,_cs.GLdouble) +def glVertexAttribL3d(index,x,y,z):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLdoubleArray) +def glVertexAttribL3dv(index,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLdouble,_cs.GLdouble,_cs.GLdouble,_cs.GLdouble) +def glVertexAttribL4d(index,x,y,z,w):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLdoubleArray) +def glVertexAttribL4dv(index,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLenum,_cs.GLsizei,ctypes.c_void_p) +def glVertexAttribLPointer(index,size,type,stride,pointer):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/vertex_attrib_binding.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/vertex_attrib_binding.py new file mode 100644 index 00000000..0ab1cd8a --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/vertex_attrib_binding.py @@ -0,0 +1,38 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_vertex_attrib_binding' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_vertex_attrib_binding',error_checker=_errors._error_checker) +GL_MAX_VERTEX_ATTRIB_BINDINGS=_C('GL_MAX_VERTEX_ATTRIB_BINDINGS',0x82DA) +GL_MAX_VERTEX_ATTRIB_RELATIVE_OFFSET=_C('GL_MAX_VERTEX_ATTRIB_RELATIVE_OFFSET',0x82D9) +GL_VERTEX_ATTRIB_BINDING=_C('GL_VERTEX_ATTRIB_BINDING',0x82D4) +GL_VERTEX_ATTRIB_RELATIVE_OFFSET=_C('GL_VERTEX_ATTRIB_RELATIVE_OFFSET',0x82D5) +GL_VERTEX_BINDING_DIVISOR=_C('GL_VERTEX_BINDING_DIVISOR',0x82D6) +GL_VERTEX_BINDING_OFFSET=_C('GL_VERTEX_BINDING_OFFSET',0x82D7) +GL_VERTEX_BINDING_STRIDE=_C('GL_VERTEX_BINDING_STRIDE',0x82D8) +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLintptr,_cs.GLsizei) +def glBindVertexBuffer(bindingindex,buffer,offset,stride):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint) +def glVertexAttribBinding(attribindex,bindingindex):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLenum,_cs.GLboolean,_cs.GLuint) +def glVertexAttribFormat(attribindex,size,type,normalized,relativeoffset):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLenum,_cs.GLuint) +def glVertexAttribIFormat(attribindex,size,type,relativeoffset):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLenum,_cs.GLuint) +def glVertexAttribLFormat(attribindex,size,type,relativeoffset):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint) +def glVertexBindingDivisor(bindingindex,divisor):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/vertex_blend.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/vertex_blend.py new file mode 100644 index 00000000..2e9fac74 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/vertex_blend.py @@ -0,0 +1,85 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_vertex_blend' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_vertex_blend',error_checker=_errors._error_checker) +GL_ACTIVE_VERTEX_UNITS_ARB=_C('GL_ACTIVE_VERTEX_UNITS_ARB',0x86A5) +GL_CURRENT_WEIGHT_ARB=_C('GL_CURRENT_WEIGHT_ARB',0x86A8) +GL_MAX_VERTEX_UNITS_ARB=_C('GL_MAX_VERTEX_UNITS_ARB',0x86A4) +GL_MODELVIEW0_ARB=_C('GL_MODELVIEW0_ARB',0x1700) +GL_MODELVIEW10_ARB=_C('GL_MODELVIEW10_ARB',0x872A) +GL_MODELVIEW11_ARB=_C('GL_MODELVIEW11_ARB',0x872B) +GL_MODELVIEW12_ARB=_C('GL_MODELVIEW12_ARB',0x872C) +GL_MODELVIEW13_ARB=_C('GL_MODELVIEW13_ARB',0x872D) +GL_MODELVIEW14_ARB=_C('GL_MODELVIEW14_ARB',0x872E) +GL_MODELVIEW15_ARB=_C('GL_MODELVIEW15_ARB',0x872F) +GL_MODELVIEW16_ARB=_C('GL_MODELVIEW16_ARB',0x8730) +GL_MODELVIEW17_ARB=_C('GL_MODELVIEW17_ARB',0x8731) +GL_MODELVIEW18_ARB=_C('GL_MODELVIEW18_ARB',0x8732) +GL_MODELVIEW19_ARB=_C('GL_MODELVIEW19_ARB',0x8733) +GL_MODELVIEW1_ARB=_C('GL_MODELVIEW1_ARB',0x850A) +GL_MODELVIEW20_ARB=_C('GL_MODELVIEW20_ARB',0x8734) +GL_MODELVIEW21_ARB=_C('GL_MODELVIEW21_ARB',0x8735) +GL_MODELVIEW22_ARB=_C('GL_MODELVIEW22_ARB',0x8736) +GL_MODELVIEW23_ARB=_C('GL_MODELVIEW23_ARB',0x8737) +GL_MODELVIEW24_ARB=_C('GL_MODELVIEW24_ARB',0x8738) +GL_MODELVIEW25_ARB=_C('GL_MODELVIEW25_ARB',0x8739) +GL_MODELVIEW26_ARB=_C('GL_MODELVIEW26_ARB',0x873A) +GL_MODELVIEW27_ARB=_C('GL_MODELVIEW27_ARB',0x873B) +GL_MODELVIEW28_ARB=_C('GL_MODELVIEW28_ARB',0x873C) +GL_MODELVIEW29_ARB=_C('GL_MODELVIEW29_ARB',0x873D) +GL_MODELVIEW2_ARB=_C('GL_MODELVIEW2_ARB',0x8722) +GL_MODELVIEW30_ARB=_C('GL_MODELVIEW30_ARB',0x873E) +GL_MODELVIEW31_ARB=_C('GL_MODELVIEW31_ARB',0x873F) +GL_MODELVIEW3_ARB=_C('GL_MODELVIEW3_ARB',0x8723) +GL_MODELVIEW4_ARB=_C('GL_MODELVIEW4_ARB',0x8724) +GL_MODELVIEW5_ARB=_C('GL_MODELVIEW5_ARB',0x8725) +GL_MODELVIEW6_ARB=_C('GL_MODELVIEW6_ARB',0x8726) +GL_MODELVIEW7_ARB=_C('GL_MODELVIEW7_ARB',0x8727) +GL_MODELVIEW8_ARB=_C('GL_MODELVIEW8_ARB',0x8728) +GL_MODELVIEW9_ARB=_C('GL_MODELVIEW9_ARB',0x8729) +GL_VERTEX_BLEND_ARB=_C('GL_VERTEX_BLEND_ARB',0x86A7) +GL_WEIGHT_ARRAY_ARB=_C('GL_WEIGHT_ARRAY_ARB',0x86AD) +GL_WEIGHT_ARRAY_POINTER_ARB=_C('GL_WEIGHT_ARRAY_POINTER_ARB',0x86AC) +GL_WEIGHT_ARRAY_SIZE_ARB=_C('GL_WEIGHT_ARRAY_SIZE_ARB',0x86AB) +GL_WEIGHT_ARRAY_STRIDE_ARB=_C('GL_WEIGHT_ARRAY_STRIDE_ARB',0x86AA) +GL_WEIGHT_ARRAY_TYPE_ARB=_C('GL_WEIGHT_ARRAY_TYPE_ARB',0x86A9) +GL_WEIGHT_SUM_UNITY_ARB=_C('GL_WEIGHT_SUM_UNITY_ARB',0x86A6) +@_f +@_p.types(None,_cs.GLint) +def glVertexBlendARB(count):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLenum,_cs.GLsizei,ctypes.c_void_p) +def glWeightPointerARB(size,type,stride,pointer):pass +@_f +@_p.types(None,_cs.GLint,arrays.GLbyteArray) +def glWeightbvARB(size,weights):pass +@_f +@_p.types(None,_cs.GLint,arrays.GLdoubleArray) +def glWeightdvARB(size,weights):pass +@_f +@_p.types(None,_cs.GLint,arrays.GLfloatArray) +def glWeightfvARB(size,weights):pass +@_f +@_p.types(None,_cs.GLint,arrays.GLintArray) +def glWeightivARB(size,weights):pass +@_f +@_p.types(None,_cs.GLint,arrays.GLshortArray) +def glWeightsvARB(size,weights):pass +@_f +@_p.types(None,_cs.GLint,arrays.GLubyteArray) +def glWeightubvARB(size,weights):pass +@_f +@_p.types(None,_cs.GLint,arrays.GLuintArray) +def glWeightuivARB(size,weights):pass +@_f +@_p.types(None,_cs.GLint,arrays.GLushortArray) +def glWeightusvARB(size,weights):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/vertex_buffer_object.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/vertex_buffer_object.py new file mode 100644 index 00000000..aa61cac0 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/vertex_buffer_object.py @@ -0,0 +1,77 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_vertex_buffer_object' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_vertex_buffer_object',error_checker=_errors._error_checker) +GL_ARRAY_BUFFER_ARB=_C('GL_ARRAY_BUFFER_ARB',0x8892) +GL_ARRAY_BUFFER_BINDING_ARB=_C('GL_ARRAY_BUFFER_BINDING_ARB',0x8894) +GL_BUFFER_ACCESS_ARB=_C('GL_BUFFER_ACCESS_ARB',0x88BB) +GL_BUFFER_MAPPED_ARB=_C('GL_BUFFER_MAPPED_ARB',0x88BC) +GL_BUFFER_MAP_POINTER_ARB=_C('GL_BUFFER_MAP_POINTER_ARB',0x88BD) +GL_BUFFER_SIZE_ARB=_C('GL_BUFFER_SIZE_ARB',0x8764) +GL_BUFFER_USAGE_ARB=_C('GL_BUFFER_USAGE_ARB',0x8765) +GL_COLOR_ARRAY_BUFFER_BINDING_ARB=_C('GL_COLOR_ARRAY_BUFFER_BINDING_ARB',0x8898) +GL_DYNAMIC_COPY_ARB=_C('GL_DYNAMIC_COPY_ARB',0x88EA) +GL_DYNAMIC_DRAW_ARB=_C('GL_DYNAMIC_DRAW_ARB',0x88E8) +GL_DYNAMIC_READ_ARB=_C('GL_DYNAMIC_READ_ARB',0x88E9) +GL_EDGE_FLAG_ARRAY_BUFFER_BINDING_ARB=_C('GL_EDGE_FLAG_ARRAY_BUFFER_BINDING_ARB',0x889B) +GL_ELEMENT_ARRAY_BUFFER_ARB=_C('GL_ELEMENT_ARRAY_BUFFER_ARB',0x8893) +GL_ELEMENT_ARRAY_BUFFER_BINDING_ARB=_C('GL_ELEMENT_ARRAY_BUFFER_BINDING_ARB',0x8895) +GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING_ARB=_C('GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING_ARB',0x889D) +GL_INDEX_ARRAY_BUFFER_BINDING_ARB=_C('GL_INDEX_ARRAY_BUFFER_BINDING_ARB',0x8899) +GL_NORMAL_ARRAY_BUFFER_BINDING_ARB=_C('GL_NORMAL_ARRAY_BUFFER_BINDING_ARB',0x8897) +GL_READ_ONLY_ARB=_C('GL_READ_ONLY_ARB',0x88B8) +GL_READ_WRITE_ARB=_C('GL_READ_WRITE_ARB',0x88BA) +GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING_ARB=_C('GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING_ARB',0x889C) +GL_STATIC_COPY_ARB=_C('GL_STATIC_COPY_ARB',0x88E6) +GL_STATIC_DRAW_ARB=_C('GL_STATIC_DRAW_ARB',0x88E4) +GL_STATIC_READ_ARB=_C('GL_STATIC_READ_ARB',0x88E5) +GL_STREAM_COPY_ARB=_C('GL_STREAM_COPY_ARB',0x88E2) +GL_STREAM_DRAW_ARB=_C('GL_STREAM_DRAW_ARB',0x88E0) +GL_STREAM_READ_ARB=_C('GL_STREAM_READ_ARB',0x88E1) +GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING_ARB=_C('GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING_ARB',0x889A) +GL_VERTEX_ARRAY_BUFFER_BINDING_ARB=_C('GL_VERTEX_ARRAY_BUFFER_BINDING_ARB',0x8896) +GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING_ARB=_C('GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING_ARB',0x889F) +GL_WEIGHT_ARRAY_BUFFER_BINDING_ARB=_C('GL_WEIGHT_ARRAY_BUFFER_BINDING_ARB',0x889E) +GL_WRITE_ONLY_ARB=_C('GL_WRITE_ONLY_ARB',0x88B9) +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint) +def glBindBufferARB(target,buffer):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizeiptrARB,ctypes.c_void_p,_cs.GLenum) +def glBufferDataARB(target,size,data,usage):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLintptrARB,_cs.GLsizeiptrARB,ctypes.c_void_p) +def glBufferSubDataARB(target,offset,size,data):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray) +def glDeleteBuffersARB(n,buffers):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray) +def glGenBuffersARB(n,buffers):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLintArray) +def glGetBufferParameterivARB(target,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLvoidpArray) +def glGetBufferPointervARB(target,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLintptrARB,_cs.GLsizeiptrARB,ctypes.c_void_p) +def glGetBufferSubDataARB(target,offset,size,data):pass +@_f +@_p.types(_cs.GLboolean,_cs.GLuint) +def glIsBufferARB(buffer):pass +@_f +@_p.types(ctypes.c_void_p,_cs.GLenum,_cs.GLenum) +def glMapBufferARB(target,access):pass +@_f +@_p.types(_cs.GLboolean,_cs.GLenum) +def glUnmapBufferARB(target):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/vertex_program.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/vertex_program.py new file mode 100644 index 00000000..c97cc02b --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/vertex_program.py @@ -0,0 +1,278 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_vertex_program' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_vertex_program',error_checker=_errors._error_checker) +GL_COLOR_SUM_ARB=_C('GL_COLOR_SUM_ARB',0x8458) +GL_CURRENT_MATRIX_ARB=_C('GL_CURRENT_MATRIX_ARB',0x8641) +GL_CURRENT_MATRIX_STACK_DEPTH_ARB=_C('GL_CURRENT_MATRIX_STACK_DEPTH_ARB',0x8640) +GL_CURRENT_VERTEX_ATTRIB_ARB=_C('GL_CURRENT_VERTEX_ATTRIB_ARB',0x8626) +GL_MATRIX0_ARB=_C('GL_MATRIX0_ARB',0x88C0) +GL_MATRIX10_ARB=_C('GL_MATRIX10_ARB',0x88CA) +GL_MATRIX11_ARB=_C('GL_MATRIX11_ARB',0x88CB) +GL_MATRIX12_ARB=_C('GL_MATRIX12_ARB',0x88CC) +GL_MATRIX13_ARB=_C('GL_MATRIX13_ARB',0x88CD) +GL_MATRIX14_ARB=_C('GL_MATRIX14_ARB',0x88CE) +GL_MATRIX15_ARB=_C('GL_MATRIX15_ARB',0x88CF) +GL_MATRIX16_ARB=_C('GL_MATRIX16_ARB',0x88D0) +GL_MATRIX17_ARB=_C('GL_MATRIX17_ARB',0x88D1) +GL_MATRIX18_ARB=_C('GL_MATRIX18_ARB',0x88D2) +GL_MATRIX19_ARB=_C('GL_MATRIX19_ARB',0x88D3) +GL_MATRIX1_ARB=_C('GL_MATRIX1_ARB',0x88C1) +GL_MATRIX20_ARB=_C('GL_MATRIX20_ARB',0x88D4) +GL_MATRIX21_ARB=_C('GL_MATRIX21_ARB',0x88D5) +GL_MATRIX22_ARB=_C('GL_MATRIX22_ARB',0x88D6) +GL_MATRIX23_ARB=_C('GL_MATRIX23_ARB',0x88D7) +GL_MATRIX24_ARB=_C('GL_MATRIX24_ARB',0x88D8) +GL_MATRIX25_ARB=_C('GL_MATRIX25_ARB',0x88D9) +GL_MATRIX26_ARB=_C('GL_MATRIX26_ARB',0x88DA) +GL_MATRIX27_ARB=_C('GL_MATRIX27_ARB',0x88DB) +GL_MATRIX28_ARB=_C('GL_MATRIX28_ARB',0x88DC) +GL_MATRIX29_ARB=_C('GL_MATRIX29_ARB',0x88DD) +GL_MATRIX2_ARB=_C('GL_MATRIX2_ARB',0x88C2) +GL_MATRIX30_ARB=_C('GL_MATRIX30_ARB',0x88DE) +GL_MATRIX31_ARB=_C('GL_MATRIX31_ARB',0x88DF) +GL_MATRIX3_ARB=_C('GL_MATRIX3_ARB',0x88C3) +GL_MATRIX4_ARB=_C('GL_MATRIX4_ARB',0x88C4) +GL_MATRIX5_ARB=_C('GL_MATRIX5_ARB',0x88C5) +GL_MATRIX6_ARB=_C('GL_MATRIX6_ARB',0x88C6) +GL_MATRIX7_ARB=_C('GL_MATRIX7_ARB',0x88C7) +GL_MATRIX8_ARB=_C('GL_MATRIX8_ARB',0x88C8) +GL_MATRIX9_ARB=_C('GL_MATRIX9_ARB',0x88C9) +GL_MAX_PROGRAM_ADDRESS_REGISTERS_ARB=_C('GL_MAX_PROGRAM_ADDRESS_REGISTERS_ARB',0x88B1) +GL_MAX_PROGRAM_ATTRIBS_ARB=_C('GL_MAX_PROGRAM_ATTRIBS_ARB',0x88AD) +GL_MAX_PROGRAM_ENV_PARAMETERS_ARB=_C('GL_MAX_PROGRAM_ENV_PARAMETERS_ARB',0x88B5) +GL_MAX_PROGRAM_INSTRUCTIONS_ARB=_C('GL_MAX_PROGRAM_INSTRUCTIONS_ARB',0x88A1) +GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB=_C('GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB',0x88B4) +GL_MAX_PROGRAM_MATRICES_ARB=_C('GL_MAX_PROGRAM_MATRICES_ARB',0x862F) +GL_MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB=_C('GL_MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB',0x862E) +GL_MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB=_C('GL_MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB',0x88B3) +GL_MAX_PROGRAM_NATIVE_ATTRIBS_ARB=_C('GL_MAX_PROGRAM_NATIVE_ATTRIBS_ARB',0x88AF) +GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB=_C('GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB',0x88A3) +GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB=_C('GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB',0x88AB) +GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB=_C('GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB',0x88A7) +GL_MAX_PROGRAM_PARAMETERS_ARB=_C('GL_MAX_PROGRAM_PARAMETERS_ARB',0x88A9) +GL_MAX_PROGRAM_TEMPORARIES_ARB=_C('GL_MAX_PROGRAM_TEMPORARIES_ARB',0x88A5) +GL_MAX_VERTEX_ATTRIBS_ARB=_C('GL_MAX_VERTEX_ATTRIBS_ARB',0x8869) +GL_PROGRAM_ADDRESS_REGISTERS_ARB=_C('GL_PROGRAM_ADDRESS_REGISTERS_ARB',0x88B0) +GL_PROGRAM_ATTRIBS_ARB=_C('GL_PROGRAM_ATTRIBS_ARB',0x88AC) +GL_PROGRAM_BINDING_ARB=_C('GL_PROGRAM_BINDING_ARB',0x8677) +GL_PROGRAM_ERROR_POSITION_ARB=_C('GL_PROGRAM_ERROR_POSITION_ARB',0x864B) +GL_PROGRAM_ERROR_STRING_ARB=_C('GL_PROGRAM_ERROR_STRING_ARB',0x8874) +GL_PROGRAM_FORMAT_ARB=_C('GL_PROGRAM_FORMAT_ARB',0x8876) +GL_PROGRAM_FORMAT_ASCII_ARB=_C('GL_PROGRAM_FORMAT_ASCII_ARB',0x8875) +GL_PROGRAM_INSTRUCTIONS_ARB=_C('GL_PROGRAM_INSTRUCTIONS_ARB',0x88A0) +GL_PROGRAM_LENGTH_ARB=_C('GL_PROGRAM_LENGTH_ARB',0x8627) +GL_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB=_C('GL_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB',0x88B2) +GL_PROGRAM_NATIVE_ATTRIBS_ARB=_C('GL_PROGRAM_NATIVE_ATTRIBS_ARB',0x88AE) +GL_PROGRAM_NATIVE_INSTRUCTIONS_ARB=_C('GL_PROGRAM_NATIVE_INSTRUCTIONS_ARB',0x88A2) +GL_PROGRAM_NATIVE_PARAMETERS_ARB=_C('GL_PROGRAM_NATIVE_PARAMETERS_ARB',0x88AA) +GL_PROGRAM_NATIVE_TEMPORARIES_ARB=_C('GL_PROGRAM_NATIVE_TEMPORARIES_ARB',0x88A6) +GL_PROGRAM_PARAMETERS_ARB=_C('GL_PROGRAM_PARAMETERS_ARB',0x88A8) +GL_PROGRAM_STRING_ARB=_C('GL_PROGRAM_STRING_ARB',0x8628) +GL_PROGRAM_TEMPORARIES_ARB=_C('GL_PROGRAM_TEMPORARIES_ARB',0x88A4) +GL_PROGRAM_UNDER_NATIVE_LIMITS_ARB=_C('GL_PROGRAM_UNDER_NATIVE_LIMITS_ARB',0x88B6) +GL_TRANSPOSE_CURRENT_MATRIX_ARB=_C('GL_TRANSPOSE_CURRENT_MATRIX_ARB',0x88B7) +GL_VERTEX_ATTRIB_ARRAY_ENABLED_ARB=_C('GL_VERTEX_ATTRIB_ARRAY_ENABLED_ARB',0x8622) +GL_VERTEX_ATTRIB_ARRAY_NORMALIZED_ARB=_C('GL_VERTEX_ATTRIB_ARRAY_NORMALIZED_ARB',0x886A) +GL_VERTEX_ATTRIB_ARRAY_POINTER_ARB=_C('GL_VERTEX_ATTRIB_ARRAY_POINTER_ARB',0x8645) +GL_VERTEX_ATTRIB_ARRAY_SIZE_ARB=_C('GL_VERTEX_ATTRIB_ARRAY_SIZE_ARB',0x8623) +GL_VERTEX_ATTRIB_ARRAY_STRIDE_ARB=_C('GL_VERTEX_ATTRIB_ARRAY_STRIDE_ARB',0x8624) +GL_VERTEX_ATTRIB_ARRAY_TYPE_ARB=_C('GL_VERTEX_ATTRIB_ARRAY_TYPE_ARB',0x8625) +GL_VERTEX_PROGRAM_ARB=_C('GL_VERTEX_PROGRAM_ARB',0x8620) +GL_VERTEX_PROGRAM_POINT_SIZE_ARB=_C('GL_VERTEX_PROGRAM_POINT_SIZE_ARB',0x8642) +GL_VERTEX_PROGRAM_TWO_SIDE_ARB=_C('GL_VERTEX_PROGRAM_TWO_SIDE_ARB',0x8643) +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint) +def glBindProgramARB(target,program):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray) +def glDeleteProgramsARB(n,programs):pass +@_f +@_p.types(None,_cs.GLuint) +def glDisableVertexAttribArrayARB(index):pass +@_f +@_p.types(None,_cs.GLuint) +def glEnableVertexAttribArrayARB(index):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray) +def glGenProgramsARB(n,programs):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,arrays.GLdoubleArray) +def glGetProgramEnvParameterdvARB(target,index,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,arrays.GLfloatArray) +def glGetProgramEnvParameterfvARB(target,index,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,arrays.GLdoubleArray) +def glGetProgramLocalParameterdvARB(target,index,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,arrays.GLfloatArray) +def glGetProgramLocalParameterfvARB(target,index,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,ctypes.c_void_p) +def glGetProgramStringARB(target,pname,string):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLintArray) +def glGetProgramivARB(target,pname,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLvoidpArray) +def glGetVertexAttribPointervARB(index,pname,pointer):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLdoubleArray) +def glGetVertexAttribdvARB(index,pname,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLfloatArray) +def glGetVertexAttribfvARB(index,pname,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLintArray) +def glGetVertexAttribivARB(index,pname,params):pass +@_f +@_p.types(_cs.GLboolean,_cs.GLuint) +def glIsProgramARB(program):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,_cs.GLdouble,_cs.GLdouble,_cs.GLdouble,_cs.GLdouble) +def glProgramEnvParameter4dARB(target,index,x,y,z,w):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,arrays.GLdoubleArray) +def glProgramEnvParameter4dvARB(target,index,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat) +def glProgramEnvParameter4fARB(target,index,x,y,z,w):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,arrays.GLfloatArray) +def glProgramEnvParameter4fvARB(target,index,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,_cs.GLdouble,_cs.GLdouble,_cs.GLdouble,_cs.GLdouble) +def glProgramLocalParameter4dARB(target,index,x,y,z,w):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,arrays.GLdoubleArray) +def glProgramLocalParameter4dvARB(target,index,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat) +def glProgramLocalParameter4fARB(target,index,x,y,z,w):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,arrays.GLfloatArray) +def glProgramLocalParameter4fvARB(target,index,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLsizei,ctypes.c_void_p) +def glProgramStringARB(target,format,len,string):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLdouble) +def glVertexAttrib1dARB(index,x):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLdoubleArray) +def glVertexAttrib1dvARB(index,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLfloat) +def glVertexAttrib1fARB(index,x):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLfloatArray) +def glVertexAttrib1fvARB(index,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLshort) +def glVertexAttrib1sARB(index,x):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLshortArray) +def glVertexAttrib1svARB(index,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLdouble,_cs.GLdouble) +def glVertexAttrib2dARB(index,x,y):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLdoubleArray) +def glVertexAttrib2dvARB(index,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLfloat,_cs.GLfloat) +def glVertexAttrib2fARB(index,x,y):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLfloatArray) +def glVertexAttrib2fvARB(index,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLshort,_cs.GLshort) +def glVertexAttrib2sARB(index,x,y):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLshortArray) +def glVertexAttrib2svARB(index,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLdouble,_cs.GLdouble,_cs.GLdouble) +def glVertexAttrib3dARB(index,x,y,z):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLdoubleArray) +def glVertexAttrib3dvARB(index,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat) +def glVertexAttrib3fARB(index,x,y,z):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLfloatArray) +def glVertexAttrib3fvARB(index,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLshort,_cs.GLshort,_cs.GLshort) +def glVertexAttrib3sARB(index,x,y,z):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLshortArray) +def glVertexAttrib3svARB(index,v):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLbyteArray) +def glVertexAttrib4NbvARB(index,v):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLintArray) +def glVertexAttrib4NivARB(index,v):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLshortArray) +def glVertexAttrib4NsvARB(index,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLubyte,_cs.GLubyte,_cs.GLubyte,_cs.GLubyte) +def glVertexAttrib4NubARB(index,x,y,z,w):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLubyteArray) +def glVertexAttrib4NubvARB(index,v):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLuintArray) +def glVertexAttrib4NuivARB(index,v):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLushortArray) +def glVertexAttrib4NusvARB(index,v):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLbyteArray) +def glVertexAttrib4bvARB(index,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLdouble,_cs.GLdouble,_cs.GLdouble,_cs.GLdouble) +def glVertexAttrib4dARB(index,x,y,z,w):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLdoubleArray) +def glVertexAttrib4dvARB(index,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat) +def glVertexAttrib4fARB(index,x,y,z,w):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLfloatArray) +def glVertexAttrib4fvARB(index,v):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLintArray) +def glVertexAttrib4ivARB(index,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLshort,_cs.GLshort,_cs.GLshort,_cs.GLshort) +def glVertexAttrib4sARB(index,x,y,z,w):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLshortArray) +def glVertexAttrib4svARB(index,v):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLubyteArray) +def glVertexAttrib4ubvARB(index,v):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLuintArray) +def glVertexAttrib4uivARB(index,v):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLushortArray) +def glVertexAttrib4usvARB(index,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLenum,_cs.GLboolean,_cs.GLsizei,ctypes.c_void_p) +def glVertexAttribPointerARB(index,size,type,normalized,stride,pointer):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/vertex_shader.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/vertex_shader.py new file mode 100644 index 00000000..92a25ecc --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/vertex_shader.py @@ -0,0 +1,177 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_vertex_shader' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_vertex_shader',error_checker=_errors._error_checker) +GL_CURRENT_VERTEX_ATTRIB_ARB=_C('GL_CURRENT_VERTEX_ATTRIB_ARB',0x8626) +GL_FLOAT=_C('GL_FLOAT',0x1406) +GL_FLOAT_MAT2_ARB=_C('GL_FLOAT_MAT2_ARB',0x8B5A) +GL_FLOAT_MAT3_ARB=_C('GL_FLOAT_MAT3_ARB',0x8B5B) +GL_FLOAT_MAT4_ARB=_C('GL_FLOAT_MAT4_ARB',0x8B5C) +GL_FLOAT_VEC2_ARB=_C('GL_FLOAT_VEC2_ARB',0x8B50) +GL_FLOAT_VEC3_ARB=_C('GL_FLOAT_VEC3_ARB',0x8B51) +GL_FLOAT_VEC4_ARB=_C('GL_FLOAT_VEC4_ARB',0x8B52) +GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB=_C('GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB',0x8B4D) +GL_MAX_TEXTURE_COORDS_ARB=_C('GL_MAX_TEXTURE_COORDS_ARB',0x8871) +GL_MAX_TEXTURE_IMAGE_UNITS_ARB=_C('GL_MAX_TEXTURE_IMAGE_UNITS_ARB',0x8872) +GL_MAX_VARYING_FLOATS_ARB=_C('GL_MAX_VARYING_FLOATS_ARB',0x8B4B) +GL_MAX_VERTEX_ATTRIBS_ARB=_C('GL_MAX_VERTEX_ATTRIBS_ARB',0x8869) +GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB=_C('GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB',0x8B4C) +GL_MAX_VERTEX_UNIFORM_COMPONENTS_ARB=_C('GL_MAX_VERTEX_UNIFORM_COMPONENTS_ARB',0x8B4A) +GL_OBJECT_ACTIVE_ATTRIBUTES_ARB=_C('GL_OBJECT_ACTIVE_ATTRIBUTES_ARB',0x8B89) +GL_OBJECT_ACTIVE_ATTRIBUTE_MAX_LENGTH_ARB=_C('GL_OBJECT_ACTIVE_ATTRIBUTE_MAX_LENGTH_ARB',0x8B8A) +GL_VERTEX_ATTRIB_ARRAY_ENABLED_ARB=_C('GL_VERTEX_ATTRIB_ARRAY_ENABLED_ARB',0x8622) +GL_VERTEX_ATTRIB_ARRAY_NORMALIZED_ARB=_C('GL_VERTEX_ATTRIB_ARRAY_NORMALIZED_ARB',0x886A) +GL_VERTEX_ATTRIB_ARRAY_POINTER_ARB=_C('GL_VERTEX_ATTRIB_ARRAY_POINTER_ARB',0x8645) +GL_VERTEX_ATTRIB_ARRAY_SIZE_ARB=_C('GL_VERTEX_ATTRIB_ARRAY_SIZE_ARB',0x8623) +GL_VERTEX_ATTRIB_ARRAY_STRIDE_ARB=_C('GL_VERTEX_ATTRIB_ARRAY_STRIDE_ARB',0x8624) +GL_VERTEX_ATTRIB_ARRAY_TYPE_ARB=_C('GL_VERTEX_ATTRIB_ARRAY_TYPE_ARB',0x8625) +GL_VERTEX_PROGRAM_POINT_SIZE_ARB=_C('GL_VERTEX_PROGRAM_POINT_SIZE_ARB',0x8642) +GL_VERTEX_PROGRAM_TWO_SIDE_ARB=_C('GL_VERTEX_PROGRAM_TWO_SIDE_ARB',0x8643) +GL_VERTEX_SHADER_ARB=_C('GL_VERTEX_SHADER_ARB',0x8B31) +@_f +@_p.types(None,_cs.GLhandleARB,_cs.GLuint,arrays.GLcharARBArray) +def glBindAttribLocationARB(programObj,index,name):pass +@_f +@_p.types(None,_cs.GLuint) +def glDisableVertexAttribArrayARB(index):pass +@_f +@_p.types(None,_cs.GLuint) +def glEnableVertexAttribArrayARB(index):pass +@_f +@_p.types(None,_cs.GLhandleARB,_cs.GLuint,_cs.GLsizei,arrays.GLsizeiArray,arrays.GLintArray,arrays.GLuintArray,arrays.GLcharARBArray) +def glGetActiveAttribARB(programObj,index,maxLength,length,size,type,name):pass +@_f +@_p.types(_cs.GLint,_cs.GLhandleARB,arrays.GLcharARBArray) +def glGetAttribLocationARB(programObj,name):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLvoidpArray) +def glGetVertexAttribPointervARB(index,pname,pointer):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLdoubleArray) +def glGetVertexAttribdvARB(index,pname,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLfloatArray) +def glGetVertexAttribfvARB(index,pname,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLintArray) +def glGetVertexAttribivARB(index,pname,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLdouble) +def glVertexAttrib1dARB(index,x):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLdoubleArray) +def glVertexAttrib1dvARB(index,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLfloat) +def glVertexAttrib1fARB(index,x):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLfloatArray) +def glVertexAttrib1fvARB(index,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLshort) +def glVertexAttrib1sARB(index,x):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLshortArray) +def glVertexAttrib1svARB(index,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLdouble,_cs.GLdouble) +def glVertexAttrib2dARB(index,x,y):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLdoubleArray) +def glVertexAttrib2dvARB(index,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLfloat,_cs.GLfloat) +def glVertexAttrib2fARB(index,x,y):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLfloatArray) +def glVertexAttrib2fvARB(index,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLshort,_cs.GLshort) +def glVertexAttrib2sARB(index,x,y):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLshortArray) +def glVertexAttrib2svARB(index,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLdouble,_cs.GLdouble,_cs.GLdouble) +def glVertexAttrib3dARB(index,x,y,z):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLdoubleArray) +def glVertexAttrib3dvARB(index,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat) +def glVertexAttrib3fARB(index,x,y,z):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLfloatArray) +def glVertexAttrib3fvARB(index,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLshort,_cs.GLshort,_cs.GLshort) +def glVertexAttrib3sARB(index,x,y,z):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLshortArray) +def glVertexAttrib3svARB(index,v):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLbyteArray) +def glVertexAttrib4NbvARB(index,v):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLintArray) +def glVertexAttrib4NivARB(index,v):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLshortArray) +def glVertexAttrib4NsvARB(index,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLubyte,_cs.GLubyte,_cs.GLubyte,_cs.GLubyte) +def glVertexAttrib4NubARB(index,x,y,z,w):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLubyteArray) +def glVertexAttrib4NubvARB(index,v):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLuintArray) +def glVertexAttrib4NuivARB(index,v):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLushortArray) +def glVertexAttrib4NusvARB(index,v):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLbyteArray) +def glVertexAttrib4bvARB(index,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLdouble,_cs.GLdouble,_cs.GLdouble,_cs.GLdouble) +def glVertexAttrib4dARB(index,x,y,z,w):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLdoubleArray) +def glVertexAttrib4dvARB(index,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat) +def glVertexAttrib4fARB(index,x,y,z,w):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLfloatArray) +def glVertexAttrib4fvARB(index,v):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLintArray) +def glVertexAttrib4ivARB(index,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLshort,_cs.GLshort,_cs.GLshort,_cs.GLshort) +def glVertexAttrib4sARB(index,x,y,z,w):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLshortArray) +def glVertexAttrib4svARB(index,v):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLubyteArray) +def glVertexAttrib4ubvARB(index,v):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLuintArray) +def glVertexAttrib4uivARB(index,v):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLushortArray) +def glVertexAttrib4usvARB(index,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLenum,_cs.GLboolean,_cs.GLsizei,ctypes.c_void_p) +def glVertexAttribPointerARB(index,size,type,normalized,stride,pointer):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/vertex_type_10f_11f_11f_rev.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/vertex_type_10f_11f_11f_rev.py new file mode 100644 index 00000000..dcd393f2 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/vertex_type_10f_11f_11f_rev.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_vertex_type_10f_11f_11f_rev' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_vertex_type_10f_11f_11f_rev',error_checker=_errors._error_checker) +GL_UNSIGNED_INT_10F_11F_11F_REV=_C('GL_UNSIGNED_INT_10F_11F_11F_REV',0x8C3B) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/vertex_type_2_10_10_10_rev.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/vertex_type_2_10_10_10_rev.py new file mode 100644 index 00000000..9e1a0cda --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/vertex_type_2_10_10_10_rev.py @@ -0,0 +1,129 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_vertex_type_2_10_10_10_rev' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_vertex_type_2_10_10_10_rev',error_checker=_errors._error_checker) +GL_INT_2_10_10_10_REV=_C('GL_INT_2_10_10_10_REV',0x8D9F) +GL_UNSIGNED_INT_2_10_10_10_REV=_C('GL_UNSIGNED_INT_2_10_10_10_REV',0x8368) +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint) +def glColorP3ui(type,color):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLuintArray) +def glColorP3uiv(type,color):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint) +def glColorP4ui(type,color):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLuintArray) +def glColorP4uiv(type,color):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLuint) +def glMultiTexCoordP1ui(texture,type,coords):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLuintArray) +def glMultiTexCoordP1uiv(texture,type,coords):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLuint) +def glMultiTexCoordP2ui(texture,type,coords):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLuintArray) +def glMultiTexCoordP2uiv(texture,type,coords):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLuint) +def glMultiTexCoordP3ui(texture,type,coords):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLuintArray) +def glMultiTexCoordP3uiv(texture,type,coords):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLuint) +def glMultiTexCoordP4ui(texture,type,coords):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLuintArray) +def glMultiTexCoordP4uiv(texture,type,coords):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint) +def glNormalP3ui(type,coords):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLuintArray) +def glNormalP3uiv(type,coords):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint) +def glSecondaryColorP3ui(type,color):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLuintArray) +def glSecondaryColorP3uiv(type,color):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint) +def glTexCoordP1ui(type,coords):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLuintArray) +def glTexCoordP1uiv(type,coords):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint) +def glTexCoordP2ui(type,coords):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLuintArray) +def glTexCoordP2uiv(type,coords):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint) +def glTexCoordP3ui(type,coords):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLuintArray) +def glTexCoordP3uiv(type,coords):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint) +def glTexCoordP4ui(type,coords):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLuintArray) +def glTexCoordP4uiv(type,coords):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLboolean,_cs.GLuint) +def glVertexAttribP1ui(index,type,normalized,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLboolean,arrays.GLuintArray) +def glVertexAttribP1uiv(index,type,normalized,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLboolean,_cs.GLuint) +def glVertexAttribP2ui(index,type,normalized,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLboolean,arrays.GLuintArray) +def glVertexAttribP2uiv(index,type,normalized,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLboolean,_cs.GLuint) +def glVertexAttribP3ui(index,type,normalized,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLboolean,arrays.GLuintArray) +def glVertexAttribP3uiv(index,type,normalized,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLboolean,_cs.GLuint) +def glVertexAttribP4ui(index,type,normalized,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLboolean,arrays.GLuintArray) +def glVertexAttribP4uiv(index,type,normalized,value):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint) +def glVertexP2ui(type,value):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLuintArray) +def glVertexP2uiv(type,value):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint) +def glVertexP3ui(type,value):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLuintArray) +def glVertexP3uiv(type,value):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint) +def glVertexP4ui(type,value):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLuintArray) +def glVertexP4uiv(type,value):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/viewport_array.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/viewport_array.py new file mode 100644 index 00000000..1c59642b --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/viewport_array.py @@ -0,0 +1,56 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_viewport_array' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_viewport_array',error_checker=_errors._error_checker) +GL_DEPTH_RANGE=_C('GL_DEPTH_RANGE',0x0B70) +GL_FIRST_VERTEX_CONVENTION=_C('GL_FIRST_VERTEX_CONVENTION',0x8E4D) +GL_LAST_VERTEX_CONVENTION=_C('GL_LAST_VERTEX_CONVENTION',0x8E4E) +GL_LAYER_PROVOKING_VERTEX=_C('GL_LAYER_PROVOKING_VERTEX',0x825E) +GL_MAX_VIEWPORTS=_C('GL_MAX_VIEWPORTS',0x825B) +GL_PROVOKING_VERTEX=_C('GL_PROVOKING_VERTEX',0x8E4F) +GL_SCISSOR_BOX=_C('GL_SCISSOR_BOX',0x0C10) +GL_SCISSOR_TEST=_C('GL_SCISSOR_TEST',0x0C11) +GL_UNDEFINED_VERTEX=_C('GL_UNDEFINED_VERTEX',0x8260) +GL_VIEWPORT=_C('GL_VIEWPORT',0x0BA2) +GL_VIEWPORT_BOUNDS_RANGE=_C('GL_VIEWPORT_BOUNDS_RANGE',0x825D) +GL_VIEWPORT_INDEX_PROVOKING_VERTEX=_C('GL_VIEWPORT_INDEX_PROVOKING_VERTEX',0x825F) +GL_VIEWPORT_SUBPIXEL_BITS=_C('GL_VIEWPORT_SUBPIXEL_BITS',0x825C) +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizei,arrays.GLdoubleArray) +def glDepthRangeArrayv(first,count,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLdouble,_cs.GLdouble) +def glDepthRangeIndexed(index,n,f):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,arrays.GLdoubleArray) +def glGetDoublei_v(target,index,data):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,arrays.GLfloatArray) +def glGetFloati_v(target,index,data):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizei,arrays.GLintArray) +def glScissorArrayv(first,count,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLsizei) +def glScissorIndexed(index,left,bottom,width,height):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLintArray) +def glScissorIndexedv(index,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizei,arrays.GLfloatArray) +def glViewportArrayv(first,count,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat) +def glViewportIndexedf(index,x,y,w,h):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLfloatArray) +def glViewportIndexedfv(index,v):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/window_pos.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/window_pos.py new file mode 100644 index 00000000..cf173dcc --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARB/window_pos.py @@ -0,0 +1,62 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ARB_window_pos' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ARB_window_pos',error_checker=_errors._error_checker) + +@_f +@_p.types(None,_cs.GLdouble,_cs.GLdouble) +def glWindowPos2dARB(x,y):pass +@_f +@_p.types(None,arrays.GLdoubleArray) +def glWindowPos2dvARB(v):pass +@_f +@_p.types(None,_cs.GLfloat,_cs.GLfloat) +def glWindowPos2fARB(x,y):pass +@_f +@_p.types(None,arrays.GLfloatArray) +def glWindowPos2fvARB(v):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLint) +def glWindowPos2iARB(x,y):pass +@_f +@_p.types(None,arrays.GLintArray) +def glWindowPos2ivARB(v):pass +@_f +@_p.types(None,_cs.GLshort,_cs.GLshort) +def glWindowPos2sARB(x,y):pass +@_f +@_p.types(None,arrays.GLshortArray) +def glWindowPos2svARB(v):pass +@_f +@_p.types(None,_cs.GLdouble,_cs.GLdouble,_cs.GLdouble) +def glWindowPos3dARB(x,y,z):pass +@_f +@_p.types(None,arrays.GLdoubleArray) +def glWindowPos3dvARB(v):pass +@_f +@_p.types(None,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat) +def glWindowPos3fARB(x,y,z):pass +@_f +@_p.types(None,arrays.GLfloatArray) +def glWindowPos3fvARB(v):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLint,_cs.GLint) +def glWindowPos3iARB(x,y,z):pass +@_f +@_p.types(None,arrays.GLintArray) +def glWindowPos3ivARB(v):pass +@_f +@_p.types(None,_cs.GLshort,_cs.GLshort,_cs.GLshort) +def glWindowPos3sARB(x,y,z):pass +@_f +@_p.types(None,arrays.GLshortArray) +def glWindowPos3svARB(v):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARM/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARM/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARM/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARM/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARM/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..3f02fca6 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ARM/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ATI/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ATI/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ATI/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ATI/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ATI/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..59e58fb3 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ATI/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ATI/__pycache__/draw_buffers.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ATI/__pycache__/draw_buffers.cpython-312.pyc new file mode 100644 index 00000000..720935b3 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ATI/__pycache__/draw_buffers.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ATI/__pycache__/element_array.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ATI/__pycache__/element_array.cpython-312.pyc new file mode 100644 index 00000000..3e05d914 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ATI/__pycache__/element_array.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ATI/__pycache__/envmap_bumpmap.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ATI/__pycache__/envmap_bumpmap.cpython-312.pyc new file mode 100644 index 00000000..c7e60922 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ATI/__pycache__/envmap_bumpmap.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ATI/__pycache__/fragment_shader.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ATI/__pycache__/fragment_shader.cpython-312.pyc new file mode 100644 index 00000000..da7ea7cb Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ATI/__pycache__/fragment_shader.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ATI/__pycache__/map_object_buffer.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ATI/__pycache__/map_object_buffer.cpython-312.pyc new file mode 100644 index 00000000..f6aa5c84 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ATI/__pycache__/map_object_buffer.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ATI/__pycache__/meminfo.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ATI/__pycache__/meminfo.cpython-312.pyc new file mode 100644 index 00000000..ae343656 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ATI/__pycache__/meminfo.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ATI/__pycache__/pixel_format_float.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ATI/__pycache__/pixel_format_float.cpython-312.pyc new file mode 100644 index 00000000..6da87bfa Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ATI/__pycache__/pixel_format_float.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ATI/__pycache__/pn_triangles.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ATI/__pycache__/pn_triangles.cpython-312.pyc new file mode 100644 index 00000000..d79add1b Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ATI/__pycache__/pn_triangles.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ATI/__pycache__/separate_stencil.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ATI/__pycache__/separate_stencil.cpython-312.pyc new file mode 100644 index 00000000..ca94d2ce Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ATI/__pycache__/separate_stencil.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ATI/__pycache__/text_fragment_shader.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ATI/__pycache__/text_fragment_shader.cpython-312.pyc new file mode 100644 index 00000000..37fa8214 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ATI/__pycache__/text_fragment_shader.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ATI/__pycache__/texture_env_combine3.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ATI/__pycache__/texture_env_combine3.cpython-312.pyc new file mode 100644 index 00000000..e84ecf0e Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ATI/__pycache__/texture_env_combine3.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ATI/__pycache__/texture_float.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ATI/__pycache__/texture_float.cpython-312.pyc new file mode 100644 index 00000000..00c2b620 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ATI/__pycache__/texture_float.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ATI/__pycache__/texture_mirror_once.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ATI/__pycache__/texture_mirror_once.cpython-312.pyc new file mode 100644 index 00000000..56ef473c Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ATI/__pycache__/texture_mirror_once.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ATI/__pycache__/vertex_array_object.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ATI/__pycache__/vertex_array_object.cpython-312.pyc new file mode 100644 index 00000000..d4497590 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ATI/__pycache__/vertex_array_object.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ATI/__pycache__/vertex_attrib_array_object.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ATI/__pycache__/vertex_attrib_array_object.cpython-312.pyc new file mode 100644 index 00000000..4687c7f1 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ATI/__pycache__/vertex_attrib_array_object.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ATI/__pycache__/vertex_streams.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ATI/__pycache__/vertex_streams.cpython-312.pyc new file mode 100644 index 00000000..a437c21b Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ATI/__pycache__/vertex_streams.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ATI/draw_buffers.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ATI/draw_buffers.py new file mode 100644 index 00000000..d86998a4 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ATI/draw_buffers.py @@ -0,0 +1,33 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ATI_draw_buffers' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ATI_draw_buffers',error_checker=_errors._error_checker) +GL_DRAW_BUFFER0_ATI=_C('GL_DRAW_BUFFER0_ATI',0x8825) +GL_DRAW_BUFFER10_ATI=_C('GL_DRAW_BUFFER10_ATI',0x882F) +GL_DRAW_BUFFER11_ATI=_C('GL_DRAW_BUFFER11_ATI',0x8830) +GL_DRAW_BUFFER12_ATI=_C('GL_DRAW_BUFFER12_ATI',0x8831) +GL_DRAW_BUFFER13_ATI=_C('GL_DRAW_BUFFER13_ATI',0x8832) +GL_DRAW_BUFFER14_ATI=_C('GL_DRAW_BUFFER14_ATI',0x8833) +GL_DRAW_BUFFER15_ATI=_C('GL_DRAW_BUFFER15_ATI',0x8834) +GL_DRAW_BUFFER1_ATI=_C('GL_DRAW_BUFFER1_ATI',0x8826) +GL_DRAW_BUFFER2_ATI=_C('GL_DRAW_BUFFER2_ATI',0x8827) +GL_DRAW_BUFFER3_ATI=_C('GL_DRAW_BUFFER3_ATI',0x8828) +GL_DRAW_BUFFER4_ATI=_C('GL_DRAW_BUFFER4_ATI',0x8829) +GL_DRAW_BUFFER5_ATI=_C('GL_DRAW_BUFFER5_ATI',0x882A) +GL_DRAW_BUFFER6_ATI=_C('GL_DRAW_BUFFER6_ATI',0x882B) +GL_DRAW_BUFFER7_ATI=_C('GL_DRAW_BUFFER7_ATI',0x882C) +GL_DRAW_BUFFER8_ATI=_C('GL_DRAW_BUFFER8_ATI',0x882D) +GL_DRAW_BUFFER9_ATI=_C('GL_DRAW_BUFFER9_ATI',0x882E) +GL_MAX_DRAW_BUFFERS_ATI=_C('GL_MAX_DRAW_BUFFERS_ATI',0x8824) +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray) +def glDrawBuffersATI(n,bufs):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ATI/element_array.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ATI/element_array.py new file mode 100644 index 00000000..47cccd5f --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ATI/element_array.py @@ -0,0 +1,25 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ATI_element_array' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ATI_element_array',error_checker=_errors._error_checker) +GL_ELEMENT_ARRAY_ATI=_C('GL_ELEMENT_ARRAY_ATI',0x8768) +GL_ELEMENT_ARRAY_POINTER_ATI=_C('GL_ELEMENT_ARRAY_POINTER_ATI',0x876A) +GL_ELEMENT_ARRAY_TYPE_ATI=_C('GL_ELEMENT_ARRAY_TYPE_ATI',0x8769) +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizei) +def glDrawElementArrayATI(mode,count):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,_cs.GLuint,_cs.GLsizei) +def glDrawRangeElementArrayATI(mode,start,end,count):pass +@_f +@_p.types(None,_cs.GLenum,ctypes.c_void_p) +def glElementPointerATI(type,pointer):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ATI/envmap_bumpmap.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ATI/envmap_bumpmap.py new file mode 100644 index 00000000..04c2c0f3 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ATI/envmap_bumpmap.py @@ -0,0 +1,33 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ATI_envmap_bumpmap' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ATI_envmap_bumpmap',error_checker=_errors._error_checker) +GL_BUMP_ENVMAP_ATI=_C('GL_BUMP_ENVMAP_ATI',0x877B) +GL_BUMP_NUM_TEX_UNITS_ATI=_C('GL_BUMP_NUM_TEX_UNITS_ATI',0x8777) +GL_BUMP_ROT_MATRIX_ATI=_C('GL_BUMP_ROT_MATRIX_ATI',0x8775) +GL_BUMP_ROT_MATRIX_SIZE_ATI=_C('GL_BUMP_ROT_MATRIX_SIZE_ATI',0x8776) +GL_BUMP_TARGET_ATI=_C('GL_BUMP_TARGET_ATI',0x877C) +GL_BUMP_TEX_UNITS_ATI=_C('GL_BUMP_TEX_UNITS_ATI',0x8778) +GL_DU8DV8_ATI=_C('GL_DU8DV8_ATI',0x877A) +GL_DUDV_ATI=_C('GL_DUDV_ATI',0x8779) +@_f +@_p.types(None,_cs.GLenum,arrays.GLfloatArray) +def glGetTexBumpParameterfvATI(pname,param):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLintArray) +def glGetTexBumpParameterivATI(pname,param):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLfloatArray) +def glTexBumpParameterfvATI(pname,param):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLintArray) +def glTexBumpParameterivATI(pname,param):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ATI/fragment_shader.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ATI/fragment_shader.py new file mode 100644 index 00000000..5f301ca4 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ATI/fragment_shader.py @@ -0,0 +1,159 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ATI_fragment_shader' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ATI_fragment_shader',error_checker=_errors._error_checker) +GL_2X_BIT_ATI=_C('GL_2X_BIT_ATI',0x00000001) +GL_4X_BIT_ATI=_C('GL_4X_BIT_ATI',0x00000002) +GL_8X_BIT_ATI=_C('GL_8X_BIT_ATI',0x00000004) +GL_ADD_ATI=_C('GL_ADD_ATI',0x8963) +GL_BIAS_BIT_ATI=_C('GL_BIAS_BIT_ATI',0x00000008) +GL_BLUE_BIT_ATI=_C('GL_BLUE_BIT_ATI',0x00000004) +GL_CND0_ATI=_C('GL_CND0_ATI',0x896B) +GL_CND_ATI=_C('GL_CND_ATI',0x896A) +GL_COLOR_ALPHA_PAIRING_ATI=_C('GL_COLOR_ALPHA_PAIRING_ATI',0x8975) +GL_COMP_BIT_ATI=_C('GL_COMP_BIT_ATI',0x00000002) +GL_CON_0_ATI=_C('GL_CON_0_ATI',0x8941) +GL_CON_10_ATI=_C('GL_CON_10_ATI',0x894B) +GL_CON_11_ATI=_C('GL_CON_11_ATI',0x894C) +GL_CON_12_ATI=_C('GL_CON_12_ATI',0x894D) +GL_CON_13_ATI=_C('GL_CON_13_ATI',0x894E) +GL_CON_14_ATI=_C('GL_CON_14_ATI',0x894F) +GL_CON_15_ATI=_C('GL_CON_15_ATI',0x8950) +GL_CON_16_ATI=_C('GL_CON_16_ATI',0x8951) +GL_CON_17_ATI=_C('GL_CON_17_ATI',0x8952) +GL_CON_18_ATI=_C('GL_CON_18_ATI',0x8953) +GL_CON_19_ATI=_C('GL_CON_19_ATI',0x8954) +GL_CON_1_ATI=_C('GL_CON_1_ATI',0x8942) +GL_CON_20_ATI=_C('GL_CON_20_ATI',0x8955) +GL_CON_21_ATI=_C('GL_CON_21_ATI',0x8956) +GL_CON_22_ATI=_C('GL_CON_22_ATI',0x8957) +GL_CON_23_ATI=_C('GL_CON_23_ATI',0x8958) +GL_CON_24_ATI=_C('GL_CON_24_ATI',0x8959) +GL_CON_25_ATI=_C('GL_CON_25_ATI',0x895A) +GL_CON_26_ATI=_C('GL_CON_26_ATI',0x895B) +GL_CON_27_ATI=_C('GL_CON_27_ATI',0x895C) +GL_CON_28_ATI=_C('GL_CON_28_ATI',0x895D) +GL_CON_29_ATI=_C('GL_CON_29_ATI',0x895E) +GL_CON_2_ATI=_C('GL_CON_2_ATI',0x8943) +GL_CON_30_ATI=_C('GL_CON_30_ATI',0x895F) +GL_CON_31_ATI=_C('GL_CON_31_ATI',0x8960) +GL_CON_3_ATI=_C('GL_CON_3_ATI',0x8944) +GL_CON_4_ATI=_C('GL_CON_4_ATI',0x8945) +GL_CON_5_ATI=_C('GL_CON_5_ATI',0x8946) +GL_CON_6_ATI=_C('GL_CON_6_ATI',0x8947) +GL_CON_7_ATI=_C('GL_CON_7_ATI',0x8948) +GL_CON_8_ATI=_C('GL_CON_8_ATI',0x8949) +GL_CON_9_ATI=_C('GL_CON_9_ATI',0x894A) +GL_DOT2_ADD_ATI=_C('GL_DOT2_ADD_ATI',0x896C) +GL_DOT3_ATI=_C('GL_DOT3_ATI',0x8966) +GL_DOT4_ATI=_C('GL_DOT4_ATI',0x8967) +GL_EIGHTH_BIT_ATI=_C('GL_EIGHTH_BIT_ATI',0x00000020) +GL_FRAGMENT_SHADER_ATI=_C('GL_FRAGMENT_SHADER_ATI',0x8920) +GL_GREEN_BIT_ATI=_C('GL_GREEN_BIT_ATI',0x00000002) +GL_HALF_BIT_ATI=_C('GL_HALF_BIT_ATI',0x00000008) +GL_LERP_ATI=_C('GL_LERP_ATI',0x8969) +GL_MAD_ATI=_C('GL_MAD_ATI',0x8968) +GL_MOV_ATI=_C('GL_MOV_ATI',0x8961) +GL_MUL_ATI=_C('GL_MUL_ATI',0x8964) +GL_NEGATE_BIT_ATI=_C('GL_NEGATE_BIT_ATI',0x00000004) +GL_NUM_FRAGMENT_CONSTANTS_ATI=_C('GL_NUM_FRAGMENT_CONSTANTS_ATI',0x896F) +GL_NUM_FRAGMENT_REGISTERS_ATI=_C('GL_NUM_FRAGMENT_REGISTERS_ATI',0x896E) +GL_NUM_INPUT_INTERPOLATOR_COMPONENTS_ATI=_C('GL_NUM_INPUT_INTERPOLATOR_COMPONENTS_ATI',0x8973) +GL_NUM_INSTRUCTIONS_PER_PASS_ATI=_C('GL_NUM_INSTRUCTIONS_PER_PASS_ATI',0x8971) +GL_NUM_INSTRUCTIONS_TOTAL_ATI=_C('GL_NUM_INSTRUCTIONS_TOTAL_ATI',0x8972) +GL_NUM_LOOPBACK_COMPONENTS_ATI=_C('GL_NUM_LOOPBACK_COMPONENTS_ATI',0x8974) +GL_NUM_PASSES_ATI=_C('GL_NUM_PASSES_ATI',0x8970) +GL_QUARTER_BIT_ATI=_C('GL_QUARTER_BIT_ATI',0x00000010) +GL_RED_BIT_ATI=_C('GL_RED_BIT_ATI',0x00000001) +GL_REG_0_ATI=_C('GL_REG_0_ATI',0x8921) +GL_REG_10_ATI=_C('GL_REG_10_ATI',0x892B) +GL_REG_11_ATI=_C('GL_REG_11_ATI',0x892C) +GL_REG_12_ATI=_C('GL_REG_12_ATI',0x892D) +GL_REG_13_ATI=_C('GL_REG_13_ATI',0x892E) +GL_REG_14_ATI=_C('GL_REG_14_ATI',0x892F) +GL_REG_15_ATI=_C('GL_REG_15_ATI',0x8930) +GL_REG_16_ATI=_C('GL_REG_16_ATI',0x8931) +GL_REG_17_ATI=_C('GL_REG_17_ATI',0x8932) +GL_REG_18_ATI=_C('GL_REG_18_ATI',0x8933) +GL_REG_19_ATI=_C('GL_REG_19_ATI',0x8934) +GL_REG_1_ATI=_C('GL_REG_1_ATI',0x8922) +GL_REG_20_ATI=_C('GL_REG_20_ATI',0x8935) +GL_REG_21_ATI=_C('GL_REG_21_ATI',0x8936) +GL_REG_22_ATI=_C('GL_REG_22_ATI',0x8937) +GL_REG_23_ATI=_C('GL_REG_23_ATI',0x8938) +GL_REG_24_ATI=_C('GL_REG_24_ATI',0x8939) +GL_REG_25_ATI=_C('GL_REG_25_ATI',0x893A) +GL_REG_26_ATI=_C('GL_REG_26_ATI',0x893B) +GL_REG_27_ATI=_C('GL_REG_27_ATI',0x893C) +GL_REG_28_ATI=_C('GL_REG_28_ATI',0x893D) +GL_REG_29_ATI=_C('GL_REG_29_ATI',0x893E) +GL_REG_2_ATI=_C('GL_REG_2_ATI',0x8923) +GL_REG_30_ATI=_C('GL_REG_30_ATI',0x893F) +GL_REG_31_ATI=_C('GL_REG_31_ATI',0x8940) +GL_REG_3_ATI=_C('GL_REG_3_ATI',0x8924) +GL_REG_4_ATI=_C('GL_REG_4_ATI',0x8925) +GL_REG_5_ATI=_C('GL_REG_5_ATI',0x8926) +GL_REG_6_ATI=_C('GL_REG_6_ATI',0x8927) +GL_REG_7_ATI=_C('GL_REG_7_ATI',0x8928) +GL_REG_8_ATI=_C('GL_REG_8_ATI',0x8929) +GL_REG_9_ATI=_C('GL_REG_9_ATI',0x892A) +GL_SATURATE_BIT_ATI=_C('GL_SATURATE_BIT_ATI',0x00000040) +GL_SECONDARY_INTERPOLATOR_ATI=_C('GL_SECONDARY_INTERPOLATOR_ATI',0x896D) +GL_SUB_ATI=_C('GL_SUB_ATI',0x8965) +GL_SWIZZLE_STQ_ATI=_C('GL_SWIZZLE_STQ_ATI',0x8977) +GL_SWIZZLE_STQ_DQ_ATI=_C('GL_SWIZZLE_STQ_DQ_ATI',0x8979) +GL_SWIZZLE_STRQ_ATI=_C('GL_SWIZZLE_STRQ_ATI',0x897A) +GL_SWIZZLE_STRQ_DQ_ATI=_C('GL_SWIZZLE_STRQ_DQ_ATI',0x897B) +GL_SWIZZLE_STR_ATI=_C('GL_SWIZZLE_STR_ATI',0x8976) +GL_SWIZZLE_STR_DR_ATI=_C('GL_SWIZZLE_STR_DR_ATI',0x8978) +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,_cs.GLuint,_cs.GLuint,_cs.GLuint,_cs.GLuint) +def glAlphaFragmentOp1ATI(op,dst,dstMod,arg1,arg1Rep,arg1Mod):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,_cs.GLuint,_cs.GLuint,_cs.GLuint,_cs.GLuint,_cs.GLuint,_cs.GLuint,_cs.GLuint) +def glAlphaFragmentOp2ATI(op,dst,dstMod,arg1,arg1Rep,arg1Mod,arg2,arg2Rep,arg2Mod):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,_cs.GLuint,_cs.GLuint,_cs.GLuint,_cs.GLuint,_cs.GLuint,_cs.GLuint,_cs.GLuint,_cs.GLuint,_cs.GLuint,_cs.GLuint) +def glAlphaFragmentOp3ATI(op,dst,dstMod,arg1,arg1Rep,arg1Mod,arg2,arg2Rep,arg2Mod,arg3,arg3Rep,arg3Mod):pass +@_f +@_p.types(None,) +def glBeginFragmentShaderATI():pass +@_f +@_p.types(None,_cs.GLuint) +def glBindFragmentShaderATI(id):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,_cs.GLuint,_cs.GLuint,_cs.GLuint,_cs.GLuint,_cs.GLuint) +def glColorFragmentOp1ATI(op,dst,dstMask,dstMod,arg1,arg1Rep,arg1Mod):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,_cs.GLuint,_cs.GLuint,_cs.GLuint,_cs.GLuint,_cs.GLuint,_cs.GLuint,_cs.GLuint,_cs.GLuint) +def glColorFragmentOp2ATI(op,dst,dstMask,dstMod,arg1,arg1Rep,arg1Mod,arg2,arg2Rep,arg2Mod):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,_cs.GLuint,_cs.GLuint,_cs.GLuint,_cs.GLuint,_cs.GLuint,_cs.GLuint,_cs.GLuint,_cs.GLuint,_cs.GLuint,_cs.GLuint,_cs.GLuint) +def glColorFragmentOp3ATI(op,dst,dstMask,dstMod,arg1,arg1Rep,arg1Mod,arg2,arg2Rep,arg2Mod,arg3,arg3Rep,arg3Mod):pass +@_f +@_p.types(None,_cs.GLuint) +def glDeleteFragmentShaderATI(id):pass +@_f +@_p.types(None,) +def glEndFragmentShaderATI():pass +@_f +@_p.types(_cs.GLuint,_cs.GLuint) +def glGenFragmentShadersATI(range):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLenum) +def glPassTexCoordATI(dst,coord,swizzle):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLenum) +def glSampleMapATI(dst,interp,swizzle):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLfloatArray) +def glSetFragmentShaderConstantATI(dst,value):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ATI/map_object_buffer.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ATI/map_object_buffer.py new file mode 100644 index 00000000..666cd572 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ATI/map_object_buffer.py @@ -0,0 +1,20 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ATI_map_object_buffer' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ATI_map_object_buffer',error_checker=_errors._error_checker) + +@_f +@_p.types(ctypes.c_void_p,_cs.GLuint) +def glMapObjectBufferATI(buffer):pass +@_f +@_p.types(None,_cs.GLuint) +def glUnmapObjectBufferATI(buffer):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ATI/meminfo.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ATI/meminfo.py new file mode 100644 index 00000000..18cf13e3 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ATI/meminfo.py @@ -0,0 +1,17 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ATI_meminfo' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ATI_meminfo',error_checker=_errors._error_checker) +GL_RENDERBUFFER_FREE_MEMORY_ATI=_C('GL_RENDERBUFFER_FREE_MEMORY_ATI',0x87FD) +GL_TEXTURE_FREE_MEMORY_ATI=_C('GL_TEXTURE_FREE_MEMORY_ATI',0x87FC) +GL_VBO_FREE_MEMORY_ATI=_C('GL_VBO_FREE_MEMORY_ATI',0x87FB) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ATI/pixel_format_float.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ATI/pixel_format_float.py new file mode 100644 index 00000000..6cc9e1b0 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ATI/pixel_format_float.py @@ -0,0 +1,16 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ATI_pixel_format_float' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ATI_pixel_format_float',error_checker=_errors._error_checker) +GL_COLOR_CLEAR_UNCLAMPED_VALUE_ATI=_C('GL_COLOR_CLEAR_UNCLAMPED_VALUE_ATI',0x8835) +GL_RGBA_FLOAT_MODE_ATI=_C('GL_RGBA_FLOAT_MODE_ATI',0x8820) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ATI/pn_triangles.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ATI/pn_triangles.py new file mode 100644 index 00000000..542a22ee --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ATI/pn_triangles.py @@ -0,0 +1,28 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ATI_pn_triangles' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ATI_pn_triangles',error_checker=_errors._error_checker) +GL_MAX_PN_TRIANGLES_TESSELATION_LEVEL_ATI=_C('GL_MAX_PN_TRIANGLES_TESSELATION_LEVEL_ATI',0x87F1) +GL_PN_TRIANGLES_ATI=_C('GL_PN_TRIANGLES_ATI',0x87F0) +GL_PN_TRIANGLES_NORMAL_MODE_ATI=_C('GL_PN_TRIANGLES_NORMAL_MODE_ATI',0x87F3) +GL_PN_TRIANGLES_NORMAL_MODE_LINEAR_ATI=_C('GL_PN_TRIANGLES_NORMAL_MODE_LINEAR_ATI',0x87F7) +GL_PN_TRIANGLES_NORMAL_MODE_QUADRATIC_ATI=_C('GL_PN_TRIANGLES_NORMAL_MODE_QUADRATIC_ATI',0x87F8) +GL_PN_TRIANGLES_POINT_MODE_ATI=_C('GL_PN_TRIANGLES_POINT_MODE_ATI',0x87F2) +GL_PN_TRIANGLES_POINT_MODE_CUBIC_ATI=_C('GL_PN_TRIANGLES_POINT_MODE_CUBIC_ATI',0x87F6) +GL_PN_TRIANGLES_POINT_MODE_LINEAR_ATI=_C('GL_PN_TRIANGLES_POINT_MODE_LINEAR_ATI',0x87F5) +GL_PN_TRIANGLES_TESSELATION_LEVEL_ATI=_C('GL_PN_TRIANGLES_TESSELATION_LEVEL_ATI',0x87F4) +@_f +@_p.types(None,_cs.GLenum,_cs.GLfloat) +def glPNTrianglesfATI(pname,param):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLint) +def glPNTrianglesiATI(pname,param):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ATI/separate_stencil.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ATI/separate_stencil.py new file mode 100644 index 00000000..4a221a76 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ATI/separate_stencil.py @@ -0,0 +1,23 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ATI_separate_stencil' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ATI_separate_stencil',error_checker=_errors._error_checker) +GL_STENCIL_BACK_FAIL_ATI=_C('GL_STENCIL_BACK_FAIL_ATI',0x8801) +GL_STENCIL_BACK_FUNC_ATI=_C('GL_STENCIL_BACK_FUNC_ATI',0x8800) +GL_STENCIL_BACK_PASS_DEPTH_FAIL_ATI=_C('GL_STENCIL_BACK_PASS_DEPTH_FAIL_ATI',0x8802) +GL_STENCIL_BACK_PASS_DEPTH_PASS_ATI=_C('GL_STENCIL_BACK_PASS_DEPTH_PASS_ATI',0x8803) +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLint,_cs.GLuint) +def glStencilFuncSeparateATI(frontfunc,backfunc,ref,mask):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLenum,_cs.GLenum) +def glStencilOpSeparateATI(face,sfail,dpfail,dppass):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ATI/text_fragment_shader.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ATI/text_fragment_shader.py new file mode 100644 index 00000000..a9fd3793 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ATI/text_fragment_shader.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ATI_text_fragment_shader' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ATI_text_fragment_shader',error_checker=_errors._error_checker) +GL_TEXT_FRAGMENT_SHADER_ATI=_C('GL_TEXT_FRAGMENT_SHADER_ATI',0x8200) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ATI/texture_env_combine3.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ATI/texture_env_combine3.py new file mode 100644 index 00000000..6b02c125 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ATI/texture_env_combine3.py @@ -0,0 +1,17 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ATI_texture_env_combine3' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ATI_texture_env_combine3',error_checker=_errors._error_checker) +GL_MODULATE_ADD_ATI=_C('GL_MODULATE_ADD_ATI',0x8744) +GL_MODULATE_SIGNED_ADD_ATI=_C('GL_MODULATE_SIGNED_ADD_ATI',0x8745) +GL_MODULATE_SUBTRACT_ATI=_C('GL_MODULATE_SUBTRACT_ATI',0x8746) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ATI/texture_float.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ATI/texture_float.py new file mode 100644 index 00000000..bd18eb3d --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ATI/texture_float.py @@ -0,0 +1,26 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ATI_texture_float' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ATI_texture_float',error_checker=_errors._error_checker) +GL_ALPHA_FLOAT16_ATI=_C('GL_ALPHA_FLOAT16_ATI',0x881C) +GL_ALPHA_FLOAT32_ATI=_C('GL_ALPHA_FLOAT32_ATI',0x8816) +GL_INTENSITY_FLOAT16_ATI=_C('GL_INTENSITY_FLOAT16_ATI',0x881D) +GL_INTENSITY_FLOAT32_ATI=_C('GL_INTENSITY_FLOAT32_ATI',0x8817) +GL_LUMINANCE_ALPHA_FLOAT16_ATI=_C('GL_LUMINANCE_ALPHA_FLOAT16_ATI',0x881F) +GL_LUMINANCE_ALPHA_FLOAT32_ATI=_C('GL_LUMINANCE_ALPHA_FLOAT32_ATI',0x8819) +GL_LUMINANCE_FLOAT16_ATI=_C('GL_LUMINANCE_FLOAT16_ATI',0x881E) +GL_LUMINANCE_FLOAT32_ATI=_C('GL_LUMINANCE_FLOAT32_ATI',0x8818) +GL_RGBA_FLOAT16_ATI=_C('GL_RGBA_FLOAT16_ATI',0x881A) +GL_RGBA_FLOAT32_ATI=_C('GL_RGBA_FLOAT32_ATI',0x8814) +GL_RGB_FLOAT16_ATI=_C('GL_RGB_FLOAT16_ATI',0x881B) +GL_RGB_FLOAT32_ATI=_C('GL_RGB_FLOAT32_ATI',0x8815) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ATI/texture_mirror_once.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ATI/texture_mirror_once.py new file mode 100644 index 00000000..e8c9cdd4 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ATI/texture_mirror_once.py @@ -0,0 +1,16 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ATI_texture_mirror_once' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ATI_texture_mirror_once',error_checker=_errors._error_checker) +GL_MIRROR_CLAMP_ATI=_C('GL_MIRROR_CLAMP_ATI',0x8742) +GL_MIRROR_CLAMP_TO_EDGE_ATI=_C('GL_MIRROR_CLAMP_TO_EDGE_ATI',0x8743) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ATI/vertex_array_object.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ATI/vertex_array_object.py new file mode 100644 index 00000000..3838fa0b --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ATI/vertex_array_object.py @@ -0,0 +1,57 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ATI_vertex_array_object' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ATI_vertex_array_object',error_checker=_errors._error_checker) +GL_ARRAY_OBJECT_BUFFER_ATI=_C('GL_ARRAY_OBJECT_BUFFER_ATI',0x8766) +GL_ARRAY_OBJECT_OFFSET_ATI=_C('GL_ARRAY_OBJECT_OFFSET_ATI',0x8767) +GL_DISCARD_ATI=_C('GL_DISCARD_ATI',0x8763) +GL_DYNAMIC_ATI=_C('GL_DYNAMIC_ATI',0x8761) +GL_OBJECT_BUFFER_SIZE_ATI=_C('GL_OBJECT_BUFFER_SIZE_ATI',0x8764) +GL_OBJECT_BUFFER_USAGE_ATI=_C('GL_OBJECT_BUFFER_USAGE_ATI',0x8765) +GL_PRESERVE_ATI=_C('GL_PRESERVE_ATI',0x8762) +GL_STATIC_ATI=_C('GL_STATIC_ATI',0x8760) +@_f +@_p.types(None,_cs.GLenum,_cs.GLint,_cs.GLenum,_cs.GLsizei,_cs.GLuint,_cs.GLuint) +def glArrayObjectATI(array,size,type,stride,buffer,offset):pass +@_f +@_p.types(None,_cs.GLuint) +def glFreeObjectBufferATI(buffer):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLfloatArray) +def glGetArrayObjectfvATI(array,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLintArray) +def glGetArrayObjectivATI(array,pname,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLfloatArray) +def glGetObjectBufferfvATI(buffer,pname,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLintArray) +def glGetObjectBufferivATI(buffer,pname,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLfloatArray) +def glGetVariantArrayObjectfvATI(id,pname,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLintArray) +def glGetVariantArrayObjectivATI(id,pname,params):pass +@_f +@_p.types(_cs.GLboolean,_cs.GLuint) +def glIsObjectBufferATI(buffer):pass +@_f +@_p.types(_cs.GLuint,_cs.GLsizei,ctypes.c_void_p,_cs.GLenum) +def glNewObjectBufferATI(size,pointer,usage):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLsizei,ctypes.c_void_p,_cs.GLenum) +def glUpdateObjectBufferATI(buffer,offset,size,pointer,preserve):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLsizei,_cs.GLuint,_cs.GLuint) +def glVariantArrayObjectATI(id,type,stride,buffer,offset):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ATI/vertex_attrib_array_object.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ATI/vertex_attrib_array_object.py new file mode 100644 index 00000000..66717c64 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ATI/vertex_attrib_array_object.py @@ -0,0 +1,23 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ATI_vertex_attrib_array_object' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ATI_vertex_attrib_array_object',error_checker=_errors._error_checker) + +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLfloatArray) +def glGetVertexAttribArrayObjectfvATI(index,pname,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLintArray) +def glGetVertexAttribArrayObjectivATI(index,pname,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLenum,_cs.GLboolean,_cs.GLsizei,_cs.GLuint,_cs.GLuint) +def glVertexAttribArrayObjectATI(index,size,type,normalized,stride,buffer,offset):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ATI/vertex_streams.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ATI/vertex_streams.py new file mode 100644 index 00000000..04b8f44f --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/ATI/vertex_streams.py @@ -0,0 +1,158 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_ATI_vertex_streams' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_ATI_vertex_streams',error_checker=_errors._error_checker) +GL_MAX_VERTEX_STREAMS_ATI=_C('GL_MAX_VERTEX_STREAMS_ATI',0x876B) +GL_VERTEX_SOURCE_ATI=_C('GL_VERTEX_SOURCE_ATI',0x8774) +GL_VERTEX_STREAM0_ATI=_C('GL_VERTEX_STREAM0_ATI',0x876C) +GL_VERTEX_STREAM1_ATI=_C('GL_VERTEX_STREAM1_ATI',0x876D) +GL_VERTEX_STREAM2_ATI=_C('GL_VERTEX_STREAM2_ATI',0x876E) +GL_VERTEX_STREAM3_ATI=_C('GL_VERTEX_STREAM3_ATI',0x876F) +GL_VERTEX_STREAM4_ATI=_C('GL_VERTEX_STREAM4_ATI',0x8770) +GL_VERTEX_STREAM5_ATI=_C('GL_VERTEX_STREAM5_ATI',0x8771) +GL_VERTEX_STREAM6_ATI=_C('GL_VERTEX_STREAM6_ATI',0x8772) +GL_VERTEX_STREAM7_ATI=_C('GL_VERTEX_STREAM7_ATI',0x8773) +@_f +@_p.types(None,_cs.GLenum) +def glClientActiveVertexStreamATI(stream):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLbyte,_cs.GLbyte,_cs.GLbyte) +def glNormalStream3bATI(stream,nx,ny,nz):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLbyteArray) +def glNormalStream3bvATI(stream,coords):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLdouble,_cs.GLdouble,_cs.GLdouble) +def glNormalStream3dATI(stream,nx,ny,nz):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLdoubleArray) +def glNormalStream3dvATI(stream,coords):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat) +def glNormalStream3fATI(stream,nx,ny,nz):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLfloatArray) +def glNormalStream3fvATI(stream,coords):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLint,_cs.GLint,_cs.GLint) +def glNormalStream3iATI(stream,nx,ny,nz):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLintArray) +def glNormalStream3ivATI(stream,coords):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLshort,_cs.GLshort,_cs.GLshort) +def glNormalStream3sATI(stream,nx,ny,nz):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLshortArray) +def glNormalStream3svATI(stream,coords):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLfloat) +def glVertexBlendEnvfATI(pname,param):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLint) +def glVertexBlendEnviATI(pname,param):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLdouble) +def glVertexStream1dATI(stream,x):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLdoubleArray) +def glVertexStream1dvATI(stream,coords):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLfloat) +def glVertexStream1fATI(stream,x):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLfloatArray) +def glVertexStream1fvATI(stream,coords):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLint) +def glVertexStream1iATI(stream,x):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLintArray) +def glVertexStream1ivATI(stream,coords):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLshort) +def glVertexStream1sATI(stream,x):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLshortArray) +def glVertexStream1svATI(stream,coords):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLdouble,_cs.GLdouble) +def glVertexStream2dATI(stream,x,y):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLdoubleArray) +def glVertexStream2dvATI(stream,coords):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLfloat,_cs.GLfloat) +def glVertexStream2fATI(stream,x,y):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLfloatArray) +def glVertexStream2fvATI(stream,coords):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLint,_cs.GLint) +def glVertexStream2iATI(stream,x,y):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLintArray) +def glVertexStream2ivATI(stream,coords):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLshort,_cs.GLshort) +def glVertexStream2sATI(stream,x,y):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLshortArray) +def glVertexStream2svATI(stream,coords):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLdouble,_cs.GLdouble,_cs.GLdouble) +def glVertexStream3dATI(stream,x,y,z):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLdoubleArray) +def glVertexStream3dvATI(stream,coords):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat) +def glVertexStream3fATI(stream,x,y,z):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLfloatArray) +def glVertexStream3fvATI(stream,coords):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLint,_cs.GLint,_cs.GLint) +def glVertexStream3iATI(stream,x,y,z):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLintArray) +def glVertexStream3ivATI(stream,coords):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLshort,_cs.GLshort,_cs.GLshort) +def glVertexStream3sATI(stream,x,y,z):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLshortArray) +def glVertexStream3svATI(stream,coords):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLdouble,_cs.GLdouble,_cs.GLdouble,_cs.GLdouble) +def glVertexStream4dATI(stream,x,y,z,w):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLdoubleArray) +def glVertexStream4dvATI(stream,coords):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat) +def glVertexStream4fATI(stream,x,y,z,w):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLfloatArray) +def glVertexStream4fvATI(stream,coords):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint) +def glVertexStream4iATI(stream,x,y,z,w):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLintArray) +def glVertexStream4ivATI(stream,coords):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLshort,_cs.GLshort,_cs.GLshort,_cs.GLshort) +def glVertexStream4sATI(stream,x,y,z,w):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLshortArray) +def glVertexStream4svATI(stream,coords):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/DFX/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/DFX/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/DFX/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/DFX/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/DFX/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..3cd373a1 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/DFX/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/DFX/__pycache__/multisample.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/DFX/__pycache__/multisample.cpython-312.pyc new file mode 100644 index 00000000..33f021bc Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/DFX/__pycache__/multisample.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/DFX/__pycache__/tbuffer.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/DFX/__pycache__/tbuffer.cpython-312.pyc new file mode 100644 index 00000000..2ebbeeb2 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/DFX/__pycache__/tbuffer.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/DFX/__pycache__/texture_compression_FXT1.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/DFX/__pycache__/texture_compression_FXT1.cpython-312.pyc new file mode 100644 index 00000000..7ead71b6 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/DFX/__pycache__/texture_compression_FXT1.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/DFX/multisample.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/DFX/multisample.py new file mode 100644 index 00000000..c1bcbb4b --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/DFX/multisample.py @@ -0,0 +1,18 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_DFX_multisample' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_DFX_multisample',error_checker=_errors._error_checker) +GL_MULTISAMPLE_3DFX=_C('GL_MULTISAMPLE_3DFX',0x86B2) +GL_MULTISAMPLE_BIT_3DFX=_C('GL_MULTISAMPLE_BIT_3DFX',0x20000000) +GL_SAMPLES_3DFX=_C('GL_SAMPLES_3DFX',0x86B4) +GL_SAMPLE_BUFFERS_3DFX=_C('GL_SAMPLE_BUFFERS_3DFX',0x86B3) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/DFX/tbuffer.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/DFX/tbuffer.py new file mode 100644 index 00000000..b6085aca --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/DFX/tbuffer.py @@ -0,0 +1,17 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_DFX_tbuffer' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_DFX_tbuffer',error_checker=_errors._error_checker) + +@_f +@_p.types(None,_cs.GLuint) +def glTbufferMask3DFX(mask):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/DFX/texture_compression_FXT1.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/DFX/texture_compression_FXT1.py new file mode 100644 index 00000000..5ea8635a --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/DFX/texture_compression_FXT1.py @@ -0,0 +1,16 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_DFX_texture_compression_FXT1' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_DFX_texture_compression_FXT1',error_checker=_errors._error_checker) +GL_COMPRESSED_RGBA_FXT1_3DFX=_C('GL_COMPRESSED_RGBA_FXT1_3DFX',0x86B1) +GL_COMPRESSED_RGB_FXT1_3DFX=_C('GL_COMPRESSED_RGB_FXT1_3DFX',0x86B0) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/DMP/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/DMP/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/DMP/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/DMP/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/DMP/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..bc4f6b5f Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/DMP/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/EGL_image_storage.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/EGL_image_storage.py new file mode 100644 index 00000000..34933136 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/EGL_image_storage.py @@ -0,0 +1,20 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_EXT_EGL_image_storage' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_EXT_EGL_image_storage',error_checker=_errors._error_checker) + +@_f +@_p.types(None,_cs.GLenum,_cs.GLeglImageOES,arrays.GLintArray) +def glEGLImageTargetTexStorageEXT(target,image,attrib_list):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLeglImageOES,arrays.GLintArray) +def glEGLImageTargetTextureStorageEXT(texture,image,attrib_list):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/EGL_sync.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/EGL_sync.py new file mode 100644 index 00000000..b9e998ea --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/EGL_sync.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_EXT_EGL_sync' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_EXT_EGL_sync',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/GL_422_pixels.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/GL_422_pixels.py new file mode 100644 index 00000000..584f526f --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/GL_422_pixels.py @@ -0,0 +1,18 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_EXT_GL_422_pixels' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_EXT_GL_422_pixels',error_checker=_errors._error_checker) +GL_422_AVERAGE_EXT=_C('GL_422_AVERAGE_EXT',0x80CE) +GL_422_EXT=_C('GL_422_EXT',0x80CC) +GL_422_REV_AVERAGE_EXT=_C('GL_422_REV_AVERAGE_EXT',0x80CF) +GL_422_REV_EXT=_C('GL_422_REV_EXT',0x80CD) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/EGL_image_storage.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/EGL_image_storage.cpython-312.pyc new file mode 100644 index 00000000..a79efb37 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/EGL_image_storage.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/EGL_sync.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/EGL_sync.cpython-312.pyc new file mode 100644 index 00000000..cc6981b6 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/EGL_sync.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/GL_422_pixels.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/GL_422_pixels.cpython-312.pyc new file mode 100644 index 00000000..88c3a28b Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/GL_422_pixels.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..2d8751b0 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/abgr.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/abgr.cpython-312.pyc new file mode 100644 index 00000000..ff3cabbb Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/abgr.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/bgra.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/bgra.cpython-312.pyc new file mode 100644 index 00000000..8c59e156 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/bgra.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/bindable_uniform.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/bindable_uniform.cpython-312.pyc new file mode 100644 index 00000000..193d338b Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/bindable_uniform.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/blend_color.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/blend_color.cpython-312.pyc new file mode 100644 index 00000000..4db3092b Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/blend_color.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/blend_equation_separate.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/blend_equation_separate.cpython-312.pyc new file mode 100644 index 00000000..380cad3b Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/blend_equation_separate.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/blend_func_separate.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/blend_func_separate.cpython-312.pyc new file mode 100644 index 00000000..cb8ba55f Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/blend_func_separate.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/blend_logic_op.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/blend_logic_op.cpython-312.pyc new file mode 100644 index 00000000..f1c501df Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/blend_logic_op.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/blend_minmax.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/blend_minmax.cpython-312.pyc new file mode 100644 index 00000000..6cda762e Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/blend_minmax.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/blend_subtract.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/blend_subtract.cpython-312.pyc new file mode 100644 index 00000000..e09fce96 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/blend_subtract.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/clip_volume_hint.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/clip_volume_hint.cpython-312.pyc new file mode 100644 index 00000000..cc97c028 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/clip_volume_hint.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/cmyka.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/cmyka.cpython-312.pyc new file mode 100644 index 00000000..27d57d40 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/cmyka.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/color_subtable.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/color_subtable.cpython-312.pyc new file mode 100644 index 00000000..65288a2e Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/color_subtable.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/compiled_vertex_array.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/compiled_vertex_array.cpython-312.pyc new file mode 100644 index 00000000..cc8ad247 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/compiled_vertex_array.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/convolution.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/convolution.cpython-312.pyc new file mode 100644 index 00000000..b05a0c81 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/convolution.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/coordinate_frame.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/coordinate_frame.cpython-312.pyc new file mode 100644 index 00000000..3a08b772 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/coordinate_frame.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/copy_texture.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/copy_texture.cpython-312.pyc new file mode 100644 index 00000000..f8f6538d Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/copy_texture.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/cull_vertex.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/cull_vertex.cpython-312.pyc new file mode 100644 index 00000000..9f20d3ed Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/cull_vertex.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/debug_label.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/debug_label.cpython-312.pyc new file mode 100644 index 00000000..5f9c1592 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/debug_label.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/debug_marker.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/debug_marker.cpython-312.pyc new file mode 100644 index 00000000..2d77839e Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/debug_marker.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/depth_bounds_test.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/depth_bounds_test.cpython-312.pyc new file mode 100644 index 00000000..223856e4 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/depth_bounds_test.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/direct_state_access.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/direct_state_access.cpython-312.pyc new file mode 100644 index 00000000..f38fa382 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/direct_state_access.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/draw_buffers2.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/draw_buffers2.cpython-312.pyc new file mode 100644 index 00000000..e24532f7 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/draw_buffers2.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/draw_instanced.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/draw_instanced.cpython-312.pyc new file mode 100644 index 00000000..a6e2bf76 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/draw_instanced.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/draw_range_elements.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/draw_range_elements.cpython-312.pyc new file mode 100644 index 00000000..a016e521 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/draw_range_elements.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/external_buffer.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/external_buffer.cpython-312.pyc new file mode 100644 index 00000000..b7aead6d Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/external_buffer.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/fog_coord.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/fog_coord.cpython-312.pyc new file mode 100644 index 00000000..4034a5aa Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/fog_coord.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/framebuffer_blit.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/framebuffer_blit.cpython-312.pyc new file mode 100644 index 00000000..c3f41307 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/framebuffer_blit.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/framebuffer_multisample.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/framebuffer_multisample.cpython-312.pyc new file mode 100644 index 00000000..293471e4 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/framebuffer_multisample.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/framebuffer_multisample_blit_scaled.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/framebuffer_multisample_blit_scaled.cpython-312.pyc new file mode 100644 index 00000000..6f26e3a3 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/framebuffer_multisample_blit_scaled.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/framebuffer_object.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/framebuffer_object.cpython-312.pyc new file mode 100644 index 00000000..f81becf8 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/framebuffer_object.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/framebuffer_sRGB.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/framebuffer_sRGB.cpython-312.pyc new file mode 100644 index 00000000..5d50daa7 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/framebuffer_sRGB.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/geometry_shader4.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/geometry_shader4.cpython-312.pyc new file mode 100644 index 00000000..b0612f61 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/geometry_shader4.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/gpu_program_parameters.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/gpu_program_parameters.cpython-312.pyc new file mode 100644 index 00000000..66e7eb60 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/gpu_program_parameters.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/gpu_shader4.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/gpu_shader4.cpython-312.pyc new file mode 100644 index 00000000..aa7ba8d6 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/gpu_shader4.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/histogram.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/histogram.cpython-312.pyc new file mode 100644 index 00000000..733f3a4b Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/histogram.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/index_array_formats.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/index_array_formats.cpython-312.pyc new file mode 100644 index 00000000..d098b77b Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/index_array_formats.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/index_func.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/index_func.cpython-312.pyc new file mode 100644 index 00000000..b1628ab5 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/index_func.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/index_material.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/index_material.cpython-312.pyc new file mode 100644 index 00000000..791345e8 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/index_material.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/index_texture.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/index_texture.cpython-312.pyc new file mode 100644 index 00000000..96498e08 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/index_texture.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/light_texture.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/light_texture.cpython-312.pyc new file mode 100644 index 00000000..a8c38f1d Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/light_texture.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/memory_object.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/memory_object.cpython-312.pyc new file mode 100644 index 00000000..ec9207bb Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/memory_object.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/memory_object_fd.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/memory_object_fd.cpython-312.pyc new file mode 100644 index 00000000..5cd72d09 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/memory_object_fd.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/memory_object_win32.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/memory_object_win32.cpython-312.pyc new file mode 100644 index 00000000..6dedc4fc Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/memory_object_win32.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/misc_attribute.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/misc_attribute.cpython-312.pyc new file mode 100644 index 00000000..db91d8de Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/misc_attribute.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/multi_draw_arrays.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/multi_draw_arrays.cpython-312.pyc new file mode 100644 index 00000000..6bb0f02b Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/multi_draw_arrays.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/multisample.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/multisample.cpython-312.pyc new file mode 100644 index 00000000..cc9b2453 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/multisample.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/multiview_tessellation_geometry_shader.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/multiview_tessellation_geometry_shader.cpython-312.pyc new file mode 100644 index 00000000..89017fd9 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/multiview_tessellation_geometry_shader.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/multiview_texture_multisample.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/multiview_texture_multisample.cpython-312.pyc new file mode 100644 index 00000000..a3aa78f4 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/multiview_texture_multisample.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/multiview_timer_query.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/multiview_timer_query.cpython-312.pyc new file mode 100644 index 00000000..363c4b7a Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/multiview_timer_query.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/packed_depth_stencil.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/packed_depth_stencil.cpython-312.pyc new file mode 100644 index 00000000..7cfc95c9 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/packed_depth_stencil.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/packed_float.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/packed_float.cpython-312.pyc new file mode 100644 index 00000000..5bc107cf Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/packed_float.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/packed_pixels.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/packed_pixels.cpython-312.pyc new file mode 100644 index 00000000..2f6aa656 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/packed_pixels.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/paletted_texture.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/paletted_texture.cpython-312.pyc new file mode 100644 index 00000000..86e5baac Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/paletted_texture.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/pixel_buffer_object.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/pixel_buffer_object.cpython-312.pyc new file mode 100644 index 00000000..84b609dd Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/pixel_buffer_object.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/pixel_transform.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/pixel_transform.cpython-312.pyc new file mode 100644 index 00000000..dce640ce Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/pixel_transform.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/pixel_transform_color_table.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/pixel_transform_color_table.cpython-312.pyc new file mode 100644 index 00000000..12159787 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/pixel_transform_color_table.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/point_parameters.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/point_parameters.cpython-312.pyc new file mode 100644 index 00000000..28880f08 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/point_parameters.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/polygon_offset.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/polygon_offset.cpython-312.pyc new file mode 100644 index 00000000..1c0c189b Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/polygon_offset.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/polygon_offset_clamp.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/polygon_offset_clamp.cpython-312.pyc new file mode 100644 index 00000000..52708650 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/polygon_offset_clamp.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/post_depth_coverage.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/post_depth_coverage.cpython-312.pyc new file mode 100644 index 00000000..a40f1fe2 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/post_depth_coverage.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/provoking_vertex.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/provoking_vertex.cpython-312.pyc new file mode 100644 index 00000000..a4e6512a Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/provoking_vertex.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/raster_multisample.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/raster_multisample.cpython-312.pyc new file mode 100644 index 00000000..56777591 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/raster_multisample.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/rescale_normal.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/rescale_normal.cpython-312.pyc new file mode 100644 index 00000000..04a4137a Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/rescale_normal.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/secondary_color.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/secondary_color.cpython-312.pyc new file mode 100644 index 00000000..1254ef13 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/secondary_color.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/semaphore.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/semaphore.cpython-312.pyc new file mode 100644 index 00000000..69770439 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/semaphore.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/semaphore_fd.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/semaphore_fd.cpython-312.pyc new file mode 100644 index 00000000..3b82bece Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/semaphore_fd.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/semaphore_win32.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/semaphore_win32.cpython-312.pyc new file mode 100644 index 00000000..ef00fc5a Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/semaphore_win32.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/separate_shader_objects.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/separate_shader_objects.cpython-312.pyc new file mode 100644 index 00000000..a05685a5 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/separate_shader_objects.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/separate_specular_color.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/separate_specular_color.cpython-312.pyc new file mode 100644 index 00000000..784c78d2 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/separate_specular_color.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/shader_framebuffer_fetch.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/shader_framebuffer_fetch.cpython-312.pyc new file mode 100644 index 00000000..4b7f8aeb Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/shader_framebuffer_fetch.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/shader_framebuffer_fetch_non_coherent.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/shader_framebuffer_fetch_non_coherent.cpython-312.pyc new file mode 100644 index 00000000..527de5f4 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/shader_framebuffer_fetch_non_coherent.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/shader_image_load_formatted.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/shader_image_load_formatted.cpython-312.pyc new file mode 100644 index 00000000..68717589 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/shader_image_load_formatted.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/shader_image_load_store.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/shader_image_load_store.cpython-312.pyc new file mode 100644 index 00000000..41380012 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/shader_image_load_store.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/shader_integer_mix.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/shader_integer_mix.cpython-312.pyc new file mode 100644 index 00000000..a97674de Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/shader_integer_mix.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/shadow_funcs.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/shadow_funcs.cpython-312.pyc new file mode 100644 index 00000000..ba17fa51 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/shadow_funcs.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/shared_texture_palette.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/shared_texture_palette.cpython-312.pyc new file mode 100644 index 00000000..519925a3 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/shared_texture_palette.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/sparse_texture2.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/sparse_texture2.cpython-312.pyc new file mode 100644 index 00000000..254fb66a Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/sparse_texture2.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/stencil_clear_tag.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/stencil_clear_tag.cpython-312.pyc new file mode 100644 index 00000000..2bd0401b Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/stencil_clear_tag.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/stencil_two_side.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/stencil_two_side.cpython-312.pyc new file mode 100644 index 00000000..270014cc Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/stencil_two_side.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/stencil_wrap.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/stencil_wrap.cpython-312.pyc new file mode 100644 index 00000000..cd07e004 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/stencil_wrap.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/subtexture.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/subtexture.cpython-312.pyc new file mode 100644 index 00000000..7b8a1e47 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/subtexture.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/texture.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/texture.cpython-312.pyc new file mode 100644 index 00000000..ba122bd1 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/texture.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/texture3D.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/texture3D.cpython-312.pyc new file mode 100644 index 00000000..abf32fc8 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/texture3D.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/texture_array.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/texture_array.cpython-312.pyc new file mode 100644 index 00000000..25e97a7b Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/texture_array.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/texture_buffer_object.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/texture_buffer_object.cpython-312.pyc new file mode 100644 index 00000000..72f49960 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/texture_buffer_object.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/texture_compression_latc.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/texture_compression_latc.cpython-312.pyc new file mode 100644 index 00000000..66ca3edc Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/texture_compression_latc.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/texture_compression_rgtc.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/texture_compression_rgtc.cpython-312.pyc new file mode 100644 index 00000000..0b3ce6f6 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/texture_compression_rgtc.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/texture_compression_s3tc.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/texture_compression_s3tc.cpython-312.pyc new file mode 100644 index 00000000..3c281314 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/texture_compression_s3tc.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/texture_cube_map.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/texture_cube_map.cpython-312.pyc new file mode 100644 index 00000000..37d57fd0 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/texture_cube_map.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/texture_env_add.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/texture_env_add.cpython-312.pyc new file mode 100644 index 00000000..44f262a3 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/texture_env_add.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/texture_env_combine.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/texture_env_combine.cpython-312.pyc new file mode 100644 index 00000000..1375a468 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/texture_env_combine.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/texture_env_dot3.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/texture_env_dot3.cpython-312.pyc new file mode 100644 index 00000000..a50fcb82 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/texture_env_dot3.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/texture_filter_anisotropic.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/texture_filter_anisotropic.cpython-312.pyc new file mode 100644 index 00000000..8c6527c6 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/texture_filter_anisotropic.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/texture_filter_minmax.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/texture_filter_minmax.cpython-312.pyc new file mode 100644 index 00000000..41b832a8 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/texture_filter_minmax.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/texture_integer.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/texture_integer.cpython-312.pyc new file mode 100644 index 00000000..f90f695e Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/texture_integer.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/texture_lod_bias.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/texture_lod_bias.cpython-312.pyc new file mode 100644 index 00000000..11766390 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/texture_lod_bias.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/texture_mirror_clamp.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/texture_mirror_clamp.cpython-312.pyc new file mode 100644 index 00000000..bd96af05 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/texture_mirror_clamp.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/texture_object.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/texture_object.cpython-312.pyc new file mode 100644 index 00000000..be8284a1 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/texture_object.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/texture_perturb_normal.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/texture_perturb_normal.cpython-312.pyc new file mode 100644 index 00000000..21fd1efb Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/texture_perturb_normal.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/texture_sRGB.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/texture_sRGB.cpython-312.pyc new file mode 100644 index 00000000..1123b272 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/texture_sRGB.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/texture_sRGB_R8.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/texture_sRGB_R8.cpython-312.pyc new file mode 100644 index 00000000..d08a410b Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/texture_sRGB_R8.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/texture_sRGB_decode.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/texture_sRGB_decode.cpython-312.pyc new file mode 100644 index 00000000..1f142bf3 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/texture_sRGB_decode.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/texture_shadow_lod.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/texture_shadow_lod.cpython-312.pyc new file mode 100644 index 00000000..f1039810 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/texture_shadow_lod.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/texture_shared_exponent.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/texture_shared_exponent.cpython-312.pyc new file mode 100644 index 00000000..c898bbb4 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/texture_shared_exponent.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/texture_snorm.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/texture_snorm.cpython-312.pyc new file mode 100644 index 00000000..91eabdbd Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/texture_snorm.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/texture_swizzle.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/texture_swizzle.cpython-312.pyc new file mode 100644 index 00000000..9b02ecbd Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/texture_swizzle.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/timer_query.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/timer_query.cpython-312.pyc new file mode 100644 index 00000000..499efdc0 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/timer_query.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/transform_feedback.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/transform_feedback.cpython-312.pyc new file mode 100644 index 00000000..2243f81f Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/transform_feedback.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/vertex_array.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/vertex_array.cpython-312.pyc new file mode 100644 index 00000000..6199a3ec Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/vertex_array.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/vertex_array_bgra.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/vertex_array_bgra.cpython-312.pyc new file mode 100644 index 00000000..a9a0d8e6 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/vertex_array_bgra.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/vertex_attrib_64bit.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/vertex_attrib_64bit.cpython-312.pyc new file mode 100644 index 00000000..651cbda0 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/vertex_attrib_64bit.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/vertex_shader.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/vertex_shader.cpython-312.pyc new file mode 100644 index 00000000..8145132e Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/vertex_shader.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/vertex_weighting.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/vertex_weighting.cpython-312.pyc new file mode 100644 index 00000000..06635542 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/vertex_weighting.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/win32_keyed_mutex.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/win32_keyed_mutex.cpython-312.pyc new file mode 100644 index 00000000..414f801d Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/win32_keyed_mutex.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/window_rectangles.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/window_rectangles.cpython-312.pyc new file mode 100644 index 00000000..752cc264 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/window_rectangles.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/x11_sync_object.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/x11_sync_object.cpython-312.pyc new file mode 100644 index 00000000..7ea48c96 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/__pycache__/x11_sync_object.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/abgr.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/abgr.py new file mode 100644 index 00000000..4e3fcf75 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/abgr.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_EXT_abgr' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_EXT_abgr',error_checker=_errors._error_checker) +GL_ABGR_EXT=_C('GL_ABGR_EXT',0x8000) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/bgra.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/bgra.py new file mode 100644 index 00000000..895a29c2 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/bgra.py @@ -0,0 +1,16 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_EXT_bgra' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_EXT_bgra',error_checker=_errors._error_checker) +GL_BGRA_EXT=_C('GL_BGRA_EXT',0x80E1) +GL_BGR_EXT=_C('GL_BGR_EXT',0x80E0) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/bindable_uniform.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/bindable_uniform.py new file mode 100644 index 00000000..8a52026c --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/bindable_uniform.py @@ -0,0 +1,28 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_EXT_bindable_uniform' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_EXT_bindable_uniform',error_checker=_errors._error_checker) +GL_MAX_BINDABLE_UNIFORM_SIZE_EXT=_C('GL_MAX_BINDABLE_UNIFORM_SIZE_EXT',0x8DED) +GL_MAX_FRAGMENT_BINDABLE_UNIFORMS_EXT=_C('GL_MAX_FRAGMENT_BINDABLE_UNIFORMS_EXT',0x8DE3) +GL_MAX_GEOMETRY_BINDABLE_UNIFORMS_EXT=_C('GL_MAX_GEOMETRY_BINDABLE_UNIFORMS_EXT',0x8DE4) +GL_MAX_VERTEX_BINDABLE_UNIFORMS_EXT=_C('GL_MAX_VERTEX_BINDABLE_UNIFORMS_EXT',0x8DE2) +GL_UNIFORM_BUFFER_BINDING_EXT=_C('GL_UNIFORM_BUFFER_BINDING_EXT',0x8DEF) +GL_UNIFORM_BUFFER_EXT=_C('GL_UNIFORM_BUFFER_EXT',0x8DEE) +@_f +@_p.types(_cs.GLint,_cs.GLuint,_cs.GLint) +def glGetUniformBufferSizeEXT(program,location):pass +@_f +@_p.types(_cs.GLintptr,_cs.GLuint,_cs.GLint) +def glGetUniformOffsetEXT(program,location):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLuint) +def glUniformBufferEXT(program,location,buffer):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/blend_color.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/blend_color.py new file mode 100644 index 00000000..3f2c22f2 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/blend_color.py @@ -0,0 +1,21 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_EXT_blend_color' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_EXT_blend_color',error_checker=_errors._error_checker) +GL_BLEND_COLOR_EXT=_C('GL_BLEND_COLOR_EXT',0x8005) +GL_CONSTANT_ALPHA_EXT=_C('GL_CONSTANT_ALPHA_EXT',0x8003) +GL_CONSTANT_COLOR_EXT=_C('GL_CONSTANT_COLOR_EXT',0x8001) +GL_ONE_MINUS_CONSTANT_ALPHA_EXT=_C('GL_ONE_MINUS_CONSTANT_ALPHA_EXT',0x8004) +GL_ONE_MINUS_CONSTANT_COLOR_EXT=_C('GL_ONE_MINUS_CONSTANT_COLOR_EXT',0x8002) +@_f +@_p.types(None,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat) +def glBlendColorEXT(red,green,blue,alpha):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/blend_equation_separate.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/blend_equation_separate.py new file mode 100644 index 00000000..91bd10cc --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/blend_equation_separate.py @@ -0,0 +1,18 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_EXT_blend_equation_separate' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_EXT_blend_equation_separate',error_checker=_errors._error_checker) +GL_BLEND_EQUATION_ALPHA_EXT=_C('GL_BLEND_EQUATION_ALPHA_EXT',0x883D) +GL_BLEND_EQUATION_RGB_EXT=_C('GL_BLEND_EQUATION_RGB_EXT',0x8009) +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum) +def glBlendEquationSeparateEXT(modeRGB,modeAlpha):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/blend_func_separate.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/blend_func_separate.py new file mode 100644 index 00000000..39cbe72e --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/blend_func_separate.py @@ -0,0 +1,20 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_EXT_blend_func_separate' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_EXT_blend_func_separate',error_checker=_errors._error_checker) +GL_BLEND_DST_ALPHA_EXT=_C('GL_BLEND_DST_ALPHA_EXT',0x80CA) +GL_BLEND_DST_RGB_EXT=_C('GL_BLEND_DST_RGB_EXT',0x80C8) +GL_BLEND_SRC_ALPHA_EXT=_C('GL_BLEND_SRC_ALPHA_EXT',0x80CB) +GL_BLEND_SRC_RGB_EXT=_C('GL_BLEND_SRC_RGB_EXT',0x80C9) +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLenum,_cs.GLenum) +def glBlendFuncSeparateEXT(sfactorRGB,dfactorRGB,sfactorAlpha,dfactorAlpha):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/blend_logic_op.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/blend_logic_op.py new file mode 100644 index 00000000..084b3c98 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/blend_logic_op.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_EXT_blend_logic_op' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_EXT_blend_logic_op',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/blend_minmax.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/blend_minmax.py new file mode 100644 index 00000000..d03cdd7f --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/blend_minmax.py @@ -0,0 +1,20 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_EXT_blend_minmax' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_EXT_blend_minmax',error_checker=_errors._error_checker) +GL_BLEND_EQUATION_EXT=_C('GL_BLEND_EQUATION_EXT',0x8009) +GL_FUNC_ADD_EXT=_C('GL_FUNC_ADD_EXT',0x8006) +GL_MAX_EXT=_C('GL_MAX_EXT',0x8008) +GL_MIN_EXT=_C('GL_MIN_EXT',0x8007) +@_f +@_p.types(None,_cs.GLenum) +def glBlendEquationEXT(mode):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/blend_subtract.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/blend_subtract.py new file mode 100644 index 00000000..69b44b38 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/blend_subtract.py @@ -0,0 +1,16 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_EXT_blend_subtract' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_EXT_blend_subtract',error_checker=_errors._error_checker) +GL_FUNC_REVERSE_SUBTRACT_EXT=_C('GL_FUNC_REVERSE_SUBTRACT_EXT',0x800B) +GL_FUNC_SUBTRACT_EXT=_C('GL_FUNC_SUBTRACT_EXT',0x800A) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/clip_volume_hint.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/clip_volume_hint.py new file mode 100644 index 00000000..ae530879 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/clip_volume_hint.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_EXT_clip_volume_hint' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_EXT_clip_volume_hint',error_checker=_errors._error_checker) +GL_CLIP_VOLUME_CLIPPING_HINT_EXT=_C('GL_CLIP_VOLUME_CLIPPING_HINT_EXT',0x80F0) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/cmyka.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/cmyka.py new file mode 100644 index 00000000..26574442 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/cmyka.py @@ -0,0 +1,18 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_EXT_cmyka' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_EXT_cmyka',error_checker=_errors._error_checker) +GL_CMYKA_EXT=_C('GL_CMYKA_EXT',0x800D) +GL_CMYK_EXT=_C('GL_CMYK_EXT',0x800C) +GL_PACK_CMYK_HINT_EXT=_C('GL_PACK_CMYK_HINT_EXT',0x800E) +GL_UNPACK_CMYK_HINT_EXT=_C('GL_UNPACK_CMYK_HINT_EXT',0x800F) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/color_subtable.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/color_subtable.py new file mode 100644 index 00000000..a4431f60 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/color_subtable.py @@ -0,0 +1,20 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_EXT_color_subtable' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_EXT_color_subtable',error_checker=_errors._error_checker) + +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizei,_cs.GLsizei,_cs.GLenum,_cs.GLenum,ctypes.c_void_p) +def glColorSubTableEXT(target,start,count,format,type,data):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizei,_cs.GLint,_cs.GLint,_cs.GLsizei) +def glCopyColorSubTableEXT(target,start,x,y,width):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/compiled_vertex_array.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/compiled_vertex_array.py new file mode 100644 index 00000000..a74e539b --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/compiled_vertex_array.py @@ -0,0 +1,21 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_EXT_compiled_vertex_array' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_EXT_compiled_vertex_array',error_checker=_errors._error_checker) +GL_ARRAY_ELEMENT_LOCK_COUNT_EXT=_C('GL_ARRAY_ELEMENT_LOCK_COUNT_EXT',0x81A9) +GL_ARRAY_ELEMENT_LOCK_FIRST_EXT=_C('GL_ARRAY_ELEMENT_LOCK_FIRST_EXT',0x81A8) +@_f +@_p.types(None,_cs.GLint,_cs.GLsizei) +def glLockArraysEXT(first,count):pass +@_f +@_p.types(None,) +def glUnlockArraysEXT():pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/convolution.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/convolution.py new file mode 100644 index 00000000..af44101a --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/convolution.py @@ -0,0 +1,72 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_EXT_convolution' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_EXT_convolution',error_checker=_errors._error_checker) +GL_CONVOLUTION_1D_EXT=_C('GL_CONVOLUTION_1D_EXT',0x8010) +GL_CONVOLUTION_2D_EXT=_C('GL_CONVOLUTION_2D_EXT',0x8011) +GL_CONVOLUTION_BORDER_MODE_EXT=_C('GL_CONVOLUTION_BORDER_MODE_EXT',0x8013) +GL_CONVOLUTION_FILTER_BIAS_EXT=_C('GL_CONVOLUTION_FILTER_BIAS_EXT',0x8015) +GL_CONVOLUTION_FILTER_SCALE_EXT=_C('GL_CONVOLUTION_FILTER_SCALE_EXT',0x8014) +GL_CONVOLUTION_FORMAT_EXT=_C('GL_CONVOLUTION_FORMAT_EXT',0x8017) +GL_CONVOLUTION_HEIGHT_EXT=_C('GL_CONVOLUTION_HEIGHT_EXT',0x8019) +GL_CONVOLUTION_WIDTH_EXT=_C('GL_CONVOLUTION_WIDTH_EXT',0x8018) +GL_MAX_CONVOLUTION_HEIGHT_EXT=_C('GL_MAX_CONVOLUTION_HEIGHT_EXT',0x801B) +GL_MAX_CONVOLUTION_WIDTH_EXT=_C('GL_MAX_CONVOLUTION_WIDTH_EXT',0x801A) +GL_POST_CONVOLUTION_ALPHA_BIAS_EXT=_C('GL_POST_CONVOLUTION_ALPHA_BIAS_EXT',0x8023) +GL_POST_CONVOLUTION_ALPHA_SCALE_EXT=_C('GL_POST_CONVOLUTION_ALPHA_SCALE_EXT',0x801F) +GL_POST_CONVOLUTION_BLUE_BIAS_EXT=_C('GL_POST_CONVOLUTION_BLUE_BIAS_EXT',0x8022) +GL_POST_CONVOLUTION_BLUE_SCALE_EXT=_C('GL_POST_CONVOLUTION_BLUE_SCALE_EXT',0x801E) +GL_POST_CONVOLUTION_GREEN_BIAS_EXT=_C('GL_POST_CONVOLUTION_GREEN_BIAS_EXT',0x8021) +GL_POST_CONVOLUTION_GREEN_SCALE_EXT=_C('GL_POST_CONVOLUTION_GREEN_SCALE_EXT',0x801D) +GL_POST_CONVOLUTION_RED_BIAS_EXT=_C('GL_POST_CONVOLUTION_RED_BIAS_EXT',0x8020) +GL_POST_CONVOLUTION_RED_SCALE_EXT=_C('GL_POST_CONVOLUTION_RED_SCALE_EXT',0x801C) +GL_REDUCE_EXT=_C('GL_REDUCE_EXT',0x8016) +GL_SEPARABLE_2D_EXT=_C('GL_SEPARABLE_2D_EXT',0x8012) +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLsizei,_cs.GLenum,_cs.GLenum,ctypes.c_void_p) +def glConvolutionFilter1DEXT(target,internalformat,width,format,type,image):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLsizei,_cs.GLsizei,_cs.GLenum,_cs.GLenum,ctypes.c_void_p) +def glConvolutionFilter2DEXT(target,internalformat,width,height,format,type,image):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLfloat) +def glConvolutionParameterfEXT(target,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLfloatArray) +def glConvolutionParameterfvEXT(target,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLint) +def glConvolutionParameteriEXT(target,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLintArray) +def glConvolutionParameterivEXT(target,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLint,_cs.GLint,_cs.GLsizei) +def glCopyConvolutionFilter1DEXT(target,internalformat,x,y,width):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLsizei) +def glCopyConvolutionFilter2DEXT(target,internalformat,x,y,width,height):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLenum,ctypes.c_void_p) +def glGetConvolutionFilterEXT(target,format,type,image):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLfloatArray) +def glGetConvolutionParameterfvEXT(target,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLintArray) +def glGetConvolutionParameterivEXT(target,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLenum,ctypes.c_void_p,ctypes.c_void_p,ctypes.c_void_p) +def glGetSeparableFilterEXT(target,format,type,row,column,span):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLsizei,_cs.GLsizei,_cs.GLenum,_cs.GLenum,ctypes.c_void_p,ctypes.c_void_p) +def glSeparableFilter2DEXT(target,internalformat,width,height,format,type,row,column):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/coordinate_frame.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/coordinate_frame.py new file mode 100644 index 00000000..2f9d2824 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/coordinate_frame.py @@ -0,0 +1,93 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_EXT_coordinate_frame' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_EXT_coordinate_frame',error_checker=_errors._error_checker) +GL_BINORMAL_ARRAY_EXT=_C('GL_BINORMAL_ARRAY_EXT',0x843A) +GL_BINORMAL_ARRAY_POINTER_EXT=_C('GL_BINORMAL_ARRAY_POINTER_EXT',0x8443) +GL_BINORMAL_ARRAY_STRIDE_EXT=_C('GL_BINORMAL_ARRAY_STRIDE_EXT',0x8441) +GL_BINORMAL_ARRAY_TYPE_EXT=_C('GL_BINORMAL_ARRAY_TYPE_EXT',0x8440) +GL_CURRENT_BINORMAL_EXT=_C('GL_CURRENT_BINORMAL_EXT',0x843C) +GL_CURRENT_TANGENT_EXT=_C('GL_CURRENT_TANGENT_EXT',0x843B) +GL_MAP1_BINORMAL_EXT=_C('GL_MAP1_BINORMAL_EXT',0x8446) +GL_MAP1_TANGENT_EXT=_C('GL_MAP1_TANGENT_EXT',0x8444) +GL_MAP2_BINORMAL_EXT=_C('GL_MAP2_BINORMAL_EXT',0x8447) +GL_MAP2_TANGENT_EXT=_C('GL_MAP2_TANGENT_EXT',0x8445) +GL_TANGENT_ARRAY_EXT=_C('GL_TANGENT_ARRAY_EXT',0x8439) +GL_TANGENT_ARRAY_POINTER_EXT=_C('GL_TANGENT_ARRAY_POINTER_EXT',0x8442) +GL_TANGENT_ARRAY_STRIDE_EXT=_C('GL_TANGENT_ARRAY_STRIDE_EXT',0x843F) +GL_TANGENT_ARRAY_TYPE_EXT=_C('GL_TANGENT_ARRAY_TYPE_EXT',0x843E) +@_f +@_p.types(None,_cs.GLbyte,_cs.GLbyte,_cs.GLbyte) +def glBinormal3bEXT(bx,by,bz):pass +@_f +@_p.types(None,arrays.GLbyteArray) +def glBinormal3bvEXT(v):pass +@_f +@_p.types(None,_cs.GLdouble,_cs.GLdouble,_cs.GLdouble) +def glBinormal3dEXT(bx,by,bz):pass +@_f +@_p.types(None,arrays.GLdoubleArray) +def glBinormal3dvEXT(v):pass +@_f +@_p.types(None,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat) +def glBinormal3fEXT(bx,by,bz):pass +@_f +@_p.types(None,arrays.GLfloatArray) +def glBinormal3fvEXT(v):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLint,_cs.GLint) +def glBinormal3iEXT(bx,by,bz):pass +@_f +@_p.types(None,arrays.GLintArray) +def glBinormal3ivEXT(v):pass +@_f +@_p.types(None,_cs.GLshort,_cs.GLshort,_cs.GLshort) +def glBinormal3sEXT(bx,by,bz):pass +@_f +@_p.types(None,arrays.GLshortArray) +def glBinormal3svEXT(v):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizei,ctypes.c_void_p) +def glBinormalPointerEXT(type,stride,pointer):pass +@_f +@_p.types(None,_cs.GLbyte,_cs.GLbyte,_cs.GLbyte) +def glTangent3bEXT(tx,ty,tz):pass +@_f +@_p.types(None,arrays.GLbyteArray) +def glTangent3bvEXT(v):pass +@_f +@_p.types(None,_cs.GLdouble,_cs.GLdouble,_cs.GLdouble) +def glTangent3dEXT(tx,ty,tz):pass +@_f +@_p.types(None,arrays.GLdoubleArray) +def glTangent3dvEXT(v):pass +@_f +@_p.types(None,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat) +def glTangent3fEXT(tx,ty,tz):pass +@_f +@_p.types(None,arrays.GLfloatArray) +def glTangent3fvEXT(v):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLint,_cs.GLint) +def glTangent3iEXT(tx,ty,tz):pass +@_f +@_p.types(None,arrays.GLintArray) +def glTangent3ivEXT(v):pass +@_f +@_p.types(None,_cs.GLshort,_cs.GLshort,_cs.GLshort) +def glTangent3sEXT(tx,ty,tz):pass +@_f +@_p.types(None,arrays.GLshortArray) +def glTangent3svEXT(v):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizei,ctypes.c_void_p) +def glTangentPointerEXT(type,stride,pointer):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/copy_texture.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/copy_texture.py new file mode 100644 index 00000000..2cd8f89a --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/copy_texture.py @@ -0,0 +1,29 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_EXT_copy_texture' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_EXT_copy_texture',error_checker=_errors._error_checker) + +@_f +@_p.types(None,_cs.GLenum,_cs.GLint,_cs.GLenum,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLint) +def glCopyTexImage1DEXT(target,level,internalformat,x,y,width,border):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLint,_cs.GLenum,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLsizei,_cs.GLint) +def glCopyTexImage2DEXT(target,level,internalformat,x,y,width,height,border):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLsizei) +def glCopyTexSubImage1DEXT(target,level,xoffset,x,y,width):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLsizei) +def glCopyTexSubImage2DEXT(target,level,xoffset,yoffset,x,y,width,height):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLsizei) +def glCopyTexSubImage3DEXT(target,level,xoffset,yoffset,zoffset,x,y,width,height):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/cull_vertex.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/cull_vertex.py new file mode 100644 index 00000000..b2a4863e --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/cull_vertex.py @@ -0,0 +1,22 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_EXT_cull_vertex' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_EXT_cull_vertex',error_checker=_errors._error_checker) +GL_CULL_VERTEX_EXT=_C('GL_CULL_VERTEX_EXT',0x81AA) +GL_CULL_VERTEX_EYE_POSITION_EXT=_C('GL_CULL_VERTEX_EYE_POSITION_EXT',0x81AB) +GL_CULL_VERTEX_OBJECT_POSITION_EXT=_C('GL_CULL_VERTEX_OBJECT_POSITION_EXT',0x81AC) +@_f +@_p.types(None,_cs.GLenum,arrays.GLdoubleArray) +def glCullParameterdvEXT(pname,params):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLfloatArray) +def glCullParameterfvEXT(pname,params):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/debug_label.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/debug_label.py new file mode 100644 index 00000000..473d58e7 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/debug_label.py @@ -0,0 +1,27 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_EXT_debug_label' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_EXT_debug_label',error_checker=_errors._error_checker) +GL_BUFFER_OBJECT_EXT=_C('GL_BUFFER_OBJECT_EXT',0x9151) +GL_PROGRAM_OBJECT_EXT=_C('GL_PROGRAM_OBJECT_EXT',0x8B40) +GL_PROGRAM_PIPELINE_OBJECT_EXT=_C('GL_PROGRAM_PIPELINE_OBJECT_EXT',0x8A4F) +GL_QUERY_OBJECT_EXT=_C('GL_QUERY_OBJECT_EXT',0x9153) +GL_SAMPLER=_C('GL_SAMPLER',0x82E6) +GL_SHADER_OBJECT_EXT=_C('GL_SHADER_OBJECT_EXT',0x8B48) +GL_TRANSFORM_FEEDBACK=_C('GL_TRANSFORM_FEEDBACK',0x8E22) +GL_VERTEX_ARRAY_OBJECT_EXT=_C('GL_VERTEX_ARRAY_OBJECT_EXT',0x9154) +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,_cs.GLsizei,arrays.GLsizeiArray,arrays.GLcharArray) +def glGetObjectLabelEXT(type,object,bufSize,length,label):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,_cs.GLsizei,arrays.GLcharArray) +def glLabelObjectEXT(type,object,length,label):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/debug_marker.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/debug_marker.py new file mode 100644 index 00000000..7a1e62f9 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/debug_marker.py @@ -0,0 +1,23 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_EXT_debug_marker' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_EXT_debug_marker',error_checker=_errors._error_checker) + +@_f +@_p.types(None,_cs.GLsizei,arrays.GLcharArray) +def glInsertEventMarkerEXT(length,marker):pass +@_f +@_p.types(None,) +def glPopGroupMarkerEXT():pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLcharArray) +def glPushGroupMarkerEXT(length,marker):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/depth_bounds_test.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/depth_bounds_test.py new file mode 100644 index 00000000..66280506 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/depth_bounds_test.py @@ -0,0 +1,18 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_EXT_depth_bounds_test' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_EXT_depth_bounds_test',error_checker=_errors._error_checker) +GL_DEPTH_BOUNDS_EXT=_C('GL_DEPTH_BOUNDS_EXT',0x8891) +GL_DEPTH_BOUNDS_TEST_EXT=_C('GL_DEPTH_BOUNDS_TEST_EXT',0x8890) +@_f +@_p.types(None,_cs.GLclampd,_cs.GLclampd) +def glDepthBoundsEXT(zmin,zmax):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/direct_state_access.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/direct_state_access.py new file mode 100644 index 00000000..33476f8d --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/direct_state_access.py @@ -0,0 +1,781 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_EXT_direct_state_access' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_EXT_direct_state_access',error_checker=_errors._error_checker) +GL_PROGRAM_MATRIX_EXT=_C('GL_PROGRAM_MATRIX_EXT',0x8E2D) +GL_PROGRAM_MATRIX_STACK_DEPTH_EXT=_C('GL_PROGRAM_MATRIX_STACK_DEPTH_EXT',0x8E2F) +GL_TRANSPOSE_PROGRAM_MATRIX_EXT=_C('GL_TRANSPOSE_PROGRAM_MATRIX_EXT',0x8E2E) +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLuint) +def glBindMultiTextureEXT(texunit,target,texture):pass +@_f +@_p.types(_cs.GLenum,_cs.GLuint,_cs.GLenum) +def glCheckNamedFramebufferStatusEXT(framebuffer,target):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLenum,_cs.GLenum,ctypes.c_void_p) +def glClearNamedBufferDataEXT(buffer,internalformat,format,type,data):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLsizeiptr,_cs.GLsizeiptr,_cs.GLenum,_cs.GLenum,ctypes.c_void_p) +def glClearNamedBufferSubDataEXT(buffer,internalformat,offset,size,format,type,data):pass +@_f +@_p.types(None,_cs.GLbitfield) +def glClientAttribDefaultEXT(mask):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLint,_cs.GLenum,_cs.GLsizei,_cs.GLint,_cs.GLsizei,ctypes.c_void_p) +def glCompressedMultiTexImage1DEXT(texunit,target,level,internalformat,width,border,imageSize,bits):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLint,_cs.GLenum,_cs.GLsizei,_cs.GLsizei,_cs.GLint,_cs.GLsizei,ctypes.c_void_p) +def glCompressedMultiTexImage2DEXT(texunit,target,level,internalformat,width,height,border,imageSize,bits):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLint,_cs.GLenum,_cs.GLsizei,_cs.GLsizei,_cs.GLsizei,_cs.GLint,_cs.GLsizei,ctypes.c_void_p) +def glCompressedMultiTexImage3DEXT(texunit,target,level,internalformat,width,height,depth,border,imageSize,bits):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLenum,_cs.GLsizei,ctypes.c_void_p) +def glCompressedMultiTexSubImage1DEXT(texunit,target,level,xoffset,width,format,imageSize,bits):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLsizei,_cs.GLenum,_cs.GLsizei,ctypes.c_void_p) +def glCompressedMultiTexSubImage2DEXT(texunit,target,level,xoffset,yoffset,width,height,format,imageSize,bits):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLsizei,_cs.GLsizei,_cs.GLenum,_cs.GLsizei,ctypes.c_void_p) +def glCompressedMultiTexSubImage3DEXT(texunit,target,level,xoffset,yoffset,zoffset,width,height,depth,format,imageSize,bits):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLint,_cs.GLenum,_cs.GLsizei,_cs.GLint,_cs.GLsizei,ctypes.c_void_p) +def glCompressedTextureImage1DEXT(texture,target,level,internalformat,width,border,imageSize,bits):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLint,_cs.GLenum,_cs.GLsizei,_cs.GLsizei,_cs.GLint,_cs.GLsizei,ctypes.c_void_p) +def glCompressedTextureImage2DEXT(texture,target,level,internalformat,width,height,border,imageSize,bits):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLint,_cs.GLenum,_cs.GLsizei,_cs.GLsizei,_cs.GLsizei,_cs.GLint,_cs.GLsizei,ctypes.c_void_p) +def glCompressedTextureImage3DEXT(texture,target,level,internalformat,width,height,depth,border,imageSize,bits):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLenum,_cs.GLsizei,ctypes.c_void_p) +def glCompressedTextureSubImage1DEXT(texture,target,level,xoffset,width,format,imageSize,bits):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLsizei,_cs.GLenum,_cs.GLsizei,ctypes.c_void_p) +def glCompressedTextureSubImage2DEXT(texture,target,level,xoffset,yoffset,width,height,format,imageSize,bits):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLsizei,_cs.GLsizei,_cs.GLenum,_cs.GLsizei,ctypes.c_void_p) +def glCompressedTextureSubImage3DEXT(texture,target,level,xoffset,yoffset,zoffset,width,height,depth,format,imageSize,bits):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLint,_cs.GLenum,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLint) +def glCopyMultiTexImage1DEXT(texunit,target,level,internalformat,x,y,width,border):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLint,_cs.GLenum,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLsizei,_cs.GLint) +def glCopyMultiTexImage2DEXT(texunit,target,level,internalformat,x,y,width,height,border):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLsizei) +def glCopyMultiTexSubImage1DEXT(texunit,target,level,xoffset,x,y,width):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLsizei) +def glCopyMultiTexSubImage2DEXT(texunit,target,level,xoffset,yoffset,x,y,width,height):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLsizei) +def glCopyMultiTexSubImage3DEXT(texunit,target,level,xoffset,yoffset,zoffset,x,y,width,height):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLint,_cs.GLenum,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLint) +def glCopyTextureImage1DEXT(texture,target,level,internalformat,x,y,width,border):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLint,_cs.GLenum,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLsizei,_cs.GLint) +def glCopyTextureImage2DEXT(texture,target,level,internalformat,x,y,width,height,border):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLsizei) +def glCopyTextureSubImage1DEXT(texture,target,level,xoffset,x,y,width):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLsizei) +def glCopyTextureSubImage2DEXT(texture,target,level,xoffset,yoffset,x,y,width,height):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLsizei) +def glCopyTextureSubImage3DEXT(texture,target,level,xoffset,yoffset,zoffset,x,y,width,height):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint) +def glDisableClientStateIndexedEXT(array,index):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint) +def glDisableClientStateiEXT(array,index):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint) +def glDisableIndexedEXT(target,index):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint) +def glDisableVertexArrayAttribEXT(vaobj,index):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum) +def glDisableVertexArrayEXT(vaobj,array):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint) +def glEnableClientStateIndexedEXT(array,index):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint) +def glEnableClientStateiEXT(array,index):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint) +def glEnableIndexedEXT(target,index):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint) +def glEnableVertexArrayAttribEXT(vaobj,index):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum) +def glEnableVertexArrayEXT(vaobj,array):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLintptr,_cs.GLsizeiptr) +def glFlushMappedNamedBufferRangeEXT(buffer,offset,length):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum) +def glFramebufferDrawBufferEXT(framebuffer,mode):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizei,arrays.GLuintArray) +def glFramebufferDrawBuffersEXT(framebuffer,n,bufs):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum) +def glFramebufferReadBufferEXT(framebuffer,mode):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum) +def glGenerateMultiTexMipmapEXT(texunit,target):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum) +def glGenerateTextureMipmapEXT(texture,target):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,arrays.GLbooleanArray) +def glGetBooleanIndexedvEXT(target,index,data):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLint,ctypes.c_void_p) +def glGetCompressedMultiTexImageEXT(texunit,target,lod,img):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLint,ctypes.c_void_p) +def glGetCompressedTextureImageEXT(texture,target,lod,img):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,arrays.GLdoubleArray) +def glGetDoubleIndexedvEXT(target,index,data):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,arrays.GLdoubleArray) +def glGetDoublei_vEXT(pname,index,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,arrays.GLfloatArray) +def glGetFloatIndexedvEXT(target,index,data):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,arrays.GLfloatArray) +def glGetFloati_vEXT(pname,index,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLintArray) +def glGetFramebufferParameterivEXT(framebuffer,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,arrays.GLintArray) +def glGetIntegerIndexedvEXT(target,index,data):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLenum,arrays.GLfloatArray) +def glGetMultiTexEnvfvEXT(texunit,target,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLenum,arrays.GLintArray) +def glGetMultiTexEnvivEXT(texunit,target,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLenum,arrays.GLdoubleArray) +def glGetMultiTexGendvEXT(texunit,coord,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLenum,arrays.GLfloatArray) +def glGetMultiTexGenfvEXT(texunit,coord,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLenum,arrays.GLintArray) +def glGetMultiTexGenivEXT(texunit,coord,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLint,_cs.GLenum,_cs.GLenum,ctypes.c_void_p) +def glGetMultiTexImageEXT(texunit,target,level,format,type,pixels):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLint,_cs.GLenum,arrays.GLfloatArray) +def glGetMultiTexLevelParameterfvEXT(texunit,target,level,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLint,_cs.GLenum,arrays.GLintArray) +def glGetMultiTexLevelParameterivEXT(texunit,target,level,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLenum,arrays.GLintArray) +def glGetMultiTexParameterIivEXT(texunit,target,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLenum,arrays.GLuintArray) +def glGetMultiTexParameterIuivEXT(texunit,target,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLenum,arrays.GLfloatArray) +def glGetMultiTexParameterfvEXT(texunit,target,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLenum,arrays.GLintArray) +def glGetMultiTexParameterivEXT(texunit,target,pname,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLintArray) +def glGetNamedBufferParameterivEXT(buffer,pname,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLvoidpArray) +def glGetNamedBufferPointervEXT(buffer,pname,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLintptr,_cs.GLsizeiptr,ctypes.c_void_p) +def glGetNamedBufferSubDataEXT(buffer,offset,size,data):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLenum,arrays.GLintArray) +def glGetNamedFramebufferAttachmentParameterivEXT(framebuffer,attachment,pname,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLintArray) +def glGetNamedFramebufferParameterivEXT(framebuffer,pname,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLuint,arrays.GLintArray) +def glGetNamedProgramLocalParameterIivEXT(program,target,index,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLuint,arrays.GLuintArray) +def glGetNamedProgramLocalParameterIuivEXT(program,target,index,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLuint,arrays.GLdoubleArray) +def glGetNamedProgramLocalParameterdvEXT(program,target,index,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLuint,arrays.GLfloatArray) +def glGetNamedProgramLocalParameterfvEXT(program,target,index,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLenum,ctypes.c_void_p) +def glGetNamedProgramStringEXT(program,target,pname,string):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLenum,arrays.GLintArray) +def glGetNamedProgramivEXT(program,target,pname,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLintArray) +def glGetNamedRenderbufferParameterivEXT(renderbuffer,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,arrays.GLvoidpArray) +def glGetPointerIndexedvEXT(target,index,data):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,arrays.GLvoidpArray) +def glGetPointeri_vEXT(pname,index,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLint,_cs.GLenum,_cs.GLenum,ctypes.c_void_p) +def glGetTextureImageEXT(texture,target,level,format,type,pixels):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLint,_cs.GLenum,arrays.GLfloatArray) +def glGetTextureLevelParameterfvEXT(texture,target,level,pname,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLint,_cs.GLenum,arrays.GLintArray) +def glGetTextureLevelParameterivEXT(texture,target,level,pname,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLenum,arrays.GLintArray) +def glGetTextureParameterIivEXT(texture,target,pname,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLenum,arrays.GLuintArray) +def glGetTextureParameterIuivEXT(texture,target,pname,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLenum,arrays.GLfloatArray) +def glGetTextureParameterfvEXT(texture,target,pname,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLenum,arrays.GLintArray) +def glGetTextureParameterivEXT(texture,target,pname,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLenum,arrays.GLintArray) +def glGetVertexArrayIntegeri_vEXT(vaobj,index,pname,param):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLintArray) +def glGetVertexArrayIntegervEXT(vaobj,pname,param):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLenum,arrays.GLvoidpArray) +def glGetVertexArrayPointeri_vEXT(vaobj,index,pname,param):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLvoidpArray) +def glGetVertexArrayPointervEXT(vaobj,pname,param):pass +@_f +@_p.types(_cs.GLboolean,_cs.GLenum,_cs.GLuint) +def glIsEnabledIndexedEXT(target,index):pass +@_f +@_p.types(ctypes.c_void_p,_cs.GLuint,_cs.GLenum) +def glMapNamedBufferEXT(buffer,access):pass +@_f +@_p.types(ctypes.c_void_p,_cs.GLuint,_cs.GLintptr,_cs.GLsizeiptr,_cs.GLbitfield) +def glMapNamedBufferRangeEXT(buffer,offset,length,access):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLdouble,_cs.GLdouble,_cs.GLdouble,_cs.GLdouble,_cs.GLdouble,_cs.GLdouble) +def glMatrixFrustumEXT(mode,left,right,bottom,top,zNear,zFar):pass +@_f +@_p.types(None,_cs.GLenum) +def glMatrixLoadIdentityEXT(mode):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLdoubleArray) +def glMatrixLoadTransposedEXT(mode,m):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLfloatArray) +def glMatrixLoadTransposefEXT(mode,m):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLdoubleArray) +def glMatrixLoaddEXT(mode,m):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLfloatArray) +def glMatrixLoadfEXT(mode,m):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLdoubleArray) +def glMatrixMultTransposedEXT(mode,m):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLfloatArray) +def glMatrixMultTransposefEXT(mode,m):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLdoubleArray) +def glMatrixMultdEXT(mode,m):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLfloatArray) +def glMatrixMultfEXT(mode,m):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLdouble,_cs.GLdouble,_cs.GLdouble,_cs.GLdouble,_cs.GLdouble,_cs.GLdouble) +def glMatrixOrthoEXT(mode,left,right,bottom,top,zNear,zFar):pass +@_f +@_p.types(None,_cs.GLenum) +def glMatrixPopEXT(mode):pass +@_f +@_p.types(None,_cs.GLenum) +def glMatrixPushEXT(mode):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLdouble,_cs.GLdouble,_cs.GLdouble,_cs.GLdouble) +def glMatrixRotatedEXT(mode,angle,x,y,z):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat) +def glMatrixRotatefEXT(mode,angle,x,y,z):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLdouble,_cs.GLdouble,_cs.GLdouble) +def glMatrixScaledEXT(mode,x,y,z):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat) +def glMatrixScalefEXT(mode,x,y,z):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLdouble,_cs.GLdouble,_cs.GLdouble) +def glMatrixTranslatedEXT(mode,x,y,z):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat) +def glMatrixTranslatefEXT(mode,x,y,z):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLenum,_cs.GLuint) +def glMultiTexBufferEXT(texunit,target,internalformat,buffer):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLint,_cs.GLenum,_cs.GLsizei,ctypes.c_void_p) +def glMultiTexCoordPointerEXT(texunit,size,type,stride,pointer):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLenum,_cs.GLfloat) +def glMultiTexEnvfEXT(texunit,target,pname,param):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLenum,arrays.GLfloatArray) +def glMultiTexEnvfvEXT(texunit,target,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLenum,_cs.GLint) +def glMultiTexEnviEXT(texunit,target,pname,param):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLenum,arrays.GLintArray) +def glMultiTexEnvivEXT(texunit,target,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLenum,_cs.GLdouble) +def glMultiTexGendEXT(texunit,coord,pname,param):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLenum,arrays.GLdoubleArray) +def glMultiTexGendvEXT(texunit,coord,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLenum,_cs.GLfloat) +def glMultiTexGenfEXT(texunit,coord,pname,param):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLenum,arrays.GLfloatArray) +def glMultiTexGenfvEXT(texunit,coord,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLenum,_cs.GLint) +def glMultiTexGeniEXT(texunit,coord,pname,param):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLenum,arrays.GLintArray) +def glMultiTexGenivEXT(texunit,coord,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLint,_cs.GLenum,_cs.GLenum,ctypes.c_void_p) +def glMultiTexImage1DEXT(texunit,target,level,internalformat,width,border,format,type,pixels):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLsizei,_cs.GLint,_cs.GLenum,_cs.GLenum,ctypes.c_void_p) +def glMultiTexImage2DEXT(texunit,target,level,internalformat,width,height,border,format,type,pixels):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLsizei,_cs.GLsizei,_cs.GLint,_cs.GLenum,_cs.GLenum,ctypes.c_void_p) +def glMultiTexImage3DEXT(texunit,target,level,internalformat,width,height,depth,border,format,type,pixels):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLenum,arrays.GLintArray) +def glMultiTexParameterIivEXT(texunit,target,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLenum,arrays.GLuintArray) +def glMultiTexParameterIuivEXT(texunit,target,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLenum,_cs.GLfloat) +def glMultiTexParameterfEXT(texunit,target,pname,param):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLenum,arrays.GLfloatArray) +def glMultiTexParameterfvEXT(texunit,target,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLenum,_cs.GLint) +def glMultiTexParameteriEXT(texunit,target,pname,param):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLenum,arrays.GLintArray) +def glMultiTexParameterivEXT(texunit,target,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLuint) +def glMultiTexRenderbufferEXT(texunit,target,renderbuffer):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLenum,_cs.GLenum,ctypes.c_void_p) +def glMultiTexSubImage1DEXT(texunit,target,level,xoffset,width,format,type,pixels):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLsizei,_cs.GLenum,_cs.GLenum,ctypes.c_void_p) +def glMultiTexSubImage2DEXT(texunit,target,level,xoffset,yoffset,width,height,format,type,pixels):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLsizei,_cs.GLsizei,_cs.GLenum,_cs.GLenum,ctypes.c_void_p) +def glMultiTexSubImage3DEXT(texunit,target,level,xoffset,yoffset,zoffset,width,height,depth,format,type,pixels):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizeiptr,ctypes.c_void_p,_cs.GLenum) +def glNamedBufferDataEXT(buffer,size,data,usage):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizeiptr,ctypes.c_void_p,_cs.GLbitfield) +def glNamedBufferStorageEXT(buffer,size,data,flags):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLintptr,_cs.GLsizeiptr,ctypes.c_void_p) +def glNamedBufferSubDataEXT(buffer,offset,size,data):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLintptr,_cs.GLintptr,_cs.GLsizeiptr) +def glNamedCopyBufferSubDataEXT(readBuffer,writeBuffer,readOffset,writeOffset,size):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLint) +def glNamedFramebufferParameteriEXT(framebuffer,pname,param):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLenum,_cs.GLuint) +def glNamedFramebufferRenderbufferEXT(framebuffer,attachment,renderbuffertarget,renderbuffer):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLenum,_cs.GLuint,_cs.GLint) +def glNamedFramebufferTexture1DEXT(framebuffer,attachment,textarget,texture,level):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLenum,_cs.GLuint,_cs.GLint) +def glNamedFramebufferTexture2DEXT(framebuffer,attachment,textarget,texture,level):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLenum,_cs.GLuint,_cs.GLint,_cs.GLint) +def glNamedFramebufferTexture3DEXT(framebuffer,attachment,textarget,texture,level,zoffset):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLuint,_cs.GLint) +def glNamedFramebufferTextureEXT(framebuffer,attachment,texture,level):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLuint,_cs.GLint,_cs.GLenum) +def glNamedFramebufferTextureFaceEXT(framebuffer,attachment,texture,level,face):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLuint,_cs.GLint,_cs.GLint) +def glNamedFramebufferTextureLayerEXT(framebuffer,attachment,texture,level,layer):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLuint,_cs.GLdouble,_cs.GLdouble,_cs.GLdouble,_cs.GLdouble) +def glNamedProgramLocalParameter4dEXT(program,target,index,x,y,z,w):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLuint,arrays.GLdoubleArray) +def glNamedProgramLocalParameter4dvEXT(program,target,index,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLuint,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat) +def glNamedProgramLocalParameter4fEXT(program,target,index,x,y,z,w):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLuint,arrays.GLfloatArray) +def glNamedProgramLocalParameter4fvEXT(program,target,index,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLuint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint) +def glNamedProgramLocalParameterI4iEXT(program,target,index,x,y,z,w):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLuint,arrays.GLintArray) +def glNamedProgramLocalParameterI4ivEXT(program,target,index,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLuint,_cs.GLuint,_cs.GLuint,_cs.GLuint,_cs.GLuint) +def glNamedProgramLocalParameterI4uiEXT(program,target,index,x,y,z,w):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLuint,arrays.GLuintArray) +def glNamedProgramLocalParameterI4uivEXT(program,target,index,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLuint,_cs.GLsizei,arrays.GLfloatArray) +def glNamedProgramLocalParameters4fvEXT(program,target,index,count,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLuint,_cs.GLsizei,arrays.GLintArray) +def glNamedProgramLocalParametersI4ivEXT(program,target,index,count,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLuint,_cs.GLsizei,arrays.GLuintArray) +def glNamedProgramLocalParametersI4uivEXT(program,target,index,count,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLenum,_cs.GLsizei,ctypes.c_void_p) +def glNamedProgramStringEXT(program,target,format,len,string):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLsizei,_cs.GLsizei) +def glNamedRenderbufferStorageEXT(renderbuffer,internalformat,width,height):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizei,_cs.GLsizei,_cs.GLenum,_cs.GLsizei,_cs.GLsizei) +def glNamedRenderbufferStorageMultisampleCoverageEXT(renderbuffer,coverageSamples,colorSamples,internalformat,width,height):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizei,_cs.GLenum,_cs.GLsizei,_cs.GLsizei) +def glNamedRenderbufferStorageMultisampleEXT(renderbuffer,samples,internalformat,width,height):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLdouble) +def glProgramUniform1dEXT(program,location,x):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLdoubleArray) +def glProgramUniform1dvEXT(program,location,count,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLfloat) +def glProgramUniform1fEXT(program,location,v0):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLfloatArray) +def glProgramUniform1fvEXT(program,location,count,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLint) +def glProgramUniform1iEXT(program,location,v0):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLintArray) +def glProgramUniform1ivEXT(program,location,count,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLuint) +def glProgramUniform1uiEXT(program,location,v0):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLuintArray) +def glProgramUniform1uivEXT(program,location,count,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLdouble,_cs.GLdouble) +def glProgramUniform2dEXT(program,location,x,y):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLdoubleArray) +def glProgramUniform2dvEXT(program,location,count,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLfloat,_cs.GLfloat) +def glProgramUniform2fEXT(program,location,v0,v1):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLfloatArray) +def glProgramUniform2fvEXT(program,location,count,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLint,_cs.GLint) +def glProgramUniform2iEXT(program,location,v0,v1):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLintArray) +def glProgramUniform2ivEXT(program,location,count,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLuint,_cs.GLuint) +def glProgramUniform2uiEXT(program,location,v0,v1):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLuintArray) +def glProgramUniform2uivEXT(program,location,count,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLdouble,_cs.GLdouble,_cs.GLdouble) +def glProgramUniform3dEXT(program,location,x,y,z):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLdoubleArray) +def glProgramUniform3dvEXT(program,location,count,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat) +def glProgramUniform3fEXT(program,location,v0,v1,v2):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLfloatArray) +def glProgramUniform3fvEXT(program,location,count,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint) +def glProgramUniform3iEXT(program,location,v0,v1,v2):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLintArray) +def glProgramUniform3ivEXT(program,location,count,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLuint,_cs.GLuint,_cs.GLuint) +def glProgramUniform3uiEXT(program,location,v0,v1,v2):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLuintArray) +def glProgramUniform3uivEXT(program,location,count,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLdouble,_cs.GLdouble,_cs.GLdouble,_cs.GLdouble) +def glProgramUniform4dEXT(program,location,x,y,z,w):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLdoubleArray) +def glProgramUniform4dvEXT(program,location,count,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat) +def glProgramUniform4fEXT(program,location,v0,v1,v2,v3):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLfloatArray) +def glProgramUniform4fvEXT(program,location,count,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint) +def glProgramUniform4iEXT(program,location,v0,v1,v2,v3):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLintArray) +def glProgramUniform4ivEXT(program,location,count,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLuint,_cs.GLuint,_cs.GLuint,_cs.GLuint) +def glProgramUniform4uiEXT(program,location,v0,v1,v2,v3):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLuintArray) +def glProgramUniform4uivEXT(program,location,count,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,_cs.GLboolean,arrays.GLdoubleArray) +def glProgramUniformMatrix2dvEXT(program,location,count,transpose,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,_cs.GLboolean,arrays.GLfloatArray) +def glProgramUniformMatrix2fvEXT(program,location,count,transpose,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,_cs.GLboolean,arrays.GLdoubleArray) +def glProgramUniformMatrix2x3dvEXT(program,location,count,transpose,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,_cs.GLboolean,arrays.GLfloatArray) +def glProgramUniformMatrix2x3fvEXT(program,location,count,transpose,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,_cs.GLboolean,arrays.GLdoubleArray) +def glProgramUniformMatrix2x4dvEXT(program,location,count,transpose,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,_cs.GLboolean,arrays.GLfloatArray) +def glProgramUniformMatrix2x4fvEXT(program,location,count,transpose,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,_cs.GLboolean,arrays.GLdoubleArray) +def glProgramUniformMatrix3dvEXT(program,location,count,transpose,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,_cs.GLboolean,arrays.GLfloatArray) +def glProgramUniformMatrix3fvEXT(program,location,count,transpose,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,_cs.GLboolean,arrays.GLdoubleArray) +def glProgramUniformMatrix3x2dvEXT(program,location,count,transpose,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,_cs.GLboolean,arrays.GLfloatArray) +def glProgramUniformMatrix3x2fvEXT(program,location,count,transpose,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,_cs.GLboolean,arrays.GLdoubleArray) +def glProgramUniformMatrix3x4dvEXT(program,location,count,transpose,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,_cs.GLboolean,arrays.GLfloatArray) +def glProgramUniformMatrix3x4fvEXT(program,location,count,transpose,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,_cs.GLboolean,arrays.GLdoubleArray) +def glProgramUniformMatrix4dvEXT(program,location,count,transpose,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,_cs.GLboolean,arrays.GLfloatArray) +def glProgramUniformMatrix4fvEXT(program,location,count,transpose,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,_cs.GLboolean,arrays.GLdoubleArray) +def glProgramUniformMatrix4x2dvEXT(program,location,count,transpose,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,_cs.GLboolean,arrays.GLfloatArray) +def glProgramUniformMatrix4x2fvEXT(program,location,count,transpose,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,_cs.GLboolean,arrays.GLdoubleArray) +def glProgramUniformMatrix4x3dvEXT(program,location,count,transpose,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,_cs.GLboolean,arrays.GLfloatArray) +def glProgramUniformMatrix4x3fvEXT(program,location,count,transpose,value):pass +@_f +@_p.types(None,_cs.GLbitfield) +def glPushClientAttribDefaultEXT(mask):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLenum,_cs.GLuint) +def glTextureBufferEXT(texture,target,internalformat,buffer):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLenum,_cs.GLuint,_cs.GLintptr,_cs.GLsizeiptr) +def glTextureBufferRangeEXT(texture,target,internalformat,buffer,offset,size):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLint,_cs.GLenum,_cs.GLenum,ctypes.c_void_p) +def glTextureImage1DEXT(texture,target,level,internalformat,width,border,format,type,pixels):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLsizei,_cs.GLint,_cs.GLenum,_cs.GLenum,ctypes.c_void_p) +def glTextureImage2DEXT(texture,target,level,internalformat,width,height,border,format,type,pixels):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLsizei,_cs.GLsizei,_cs.GLint,_cs.GLenum,_cs.GLenum,ctypes.c_void_p) +def glTextureImage3DEXT(texture,target,level,internalformat,width,height,depth,border,format,type,pixels):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLsizei,_cs.GLsizei,_cs.GLboolean) +def glTexturePageCommitmentEXT(texture,level,xoffset,yoffset,zoffset,width,height,depth,commit):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLenum,arrays.GLintArray) +def glTextureParameterIivEXT(texture,target,pname,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLenum,arrays.GLuintArray) +def glTextureParameterIuivEXT(texture,target,pname,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLenum,_cs.GLfloat) +def glTextureParameterfEXT(texture,target,pname,param):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLenum,arrays.GLfloatArray) +def glTextureParameterfvEXT(texture,target,pname,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLenum,_cs.GLint) +def glTextureParameteriEXT(texture,target,pname,param):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLenum,arrays.GLintArray) +def glTextureParameterivEXT(texture,target,pname,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLuint) +def glTextureRenderbufferEXT(texture,target,renderbuffer):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLsizei,_cs.GLenum,_cs.GLsizei) +def glTextureStorage1DEXT(texture,target,levels,internalformat,width):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLsizei,_cs.GLenum,_cs.GLsizei,_cs.GLsizei) +def glTextureStorage2DEXT(texture,target,levels,internalformat,width,height):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLsizei,_cs.GLenum,_cs.GLsizei,_cs.GLsizei,_cs.GLboolean) +def glTextureStorage2DMultisampleEXT(texture,target,samples,internalformat,width,height,fixedsamplelocations):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLsizei,_cs.GLenum,_cs.GLsizei,_cs.GLsizei,_cs.GLsizei) +def glTextureStorage3DEXT(texture,target,levels,internalformat,width,height,depth):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLsizei,_cs.GLenum,_cs.GLsizei,_cs.GLsizei,_cs.GLsizei,_cs.GLboolean) +def glTextureStorage3DMultisampleEXT(texture,target,samples,internalformat,width,height,depth,fixedsamplelocations):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLenum,_cs.GLenum,ctypes.c_void_p) +def glTextureSubImage1DEXT(texture,target,level,xoffset,width,format,type,pixels):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLsizei,_cs.GLenum,_cs.GLenum,ctypes.c_void_p) +def glTextureSubImage2DEXT(texture,target,level,xoffset,yoffset,width,height,format,type,pixels):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLsizei,_cs.GLsizei,_cs.GLenum,_cs.GLenum,ctypes.c_void_p) +def glTextureSubImage3DEXT(texture,target,level,xoffset,yoffset,zoffset,width,height,depth,format,type,pixels):pass +@_f +@_p.types(_cs.GLboolean,_cs.GLuint) +def glUnmapNamedBufferEXT(buffer):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLuint,_cs.GLintptr,_cs.GLsizei) +def glVertexArrayBindVertexBufferEXT(vaobj,bindingindex,buffer,offset,stride):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLint,_cs.GLenum,_cs.GLsizei,_cs.GLintptr) +def glVertexArrayColorOffsetEXT(vaobj,buffer,size,type,stride,offset):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLsizei,_cs.GLintptr) +def glVertexArrayEdgeFlagOffsetEXT(vaobj,buffer,stride,offset):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLenum,_cs.GLsizei,_cs.GLintptr) +def glVertexArrayFogCoordOffsetEXT(vaobj,buffer,type,stride,offset):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLenum,_cs.GLsizei,_cs.GLintptr) +def glVertexArrayIndexOffsetEXT(vaobj,buffer,type,stride,offset):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLenum,_cs.GLint,_cs.GLenum,_cs.GLsizei,_cs.GLintptr) +def glVertexArrayMultiTexCoordOffsetEXT(vaobj,buffer,texunit,size,type,stride,offset):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLenum,_cs.GLsizei,_cs.GLintptr) +def glVertexArrayNormalOffsetEXT(vaobj,buffer,type,stride,offset):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLint,_cs.GLenum,_cs.GLsizei,_cs.GLintptr) +def glVertexArraySecondaryColorOffsetEXT(vaobj,buffer,size,type,stride,offset):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLint,_cs.GLenum,_cs.GLsizei,_cs.GLintptr) +def glVertexArrayTexCoordOffsetEXT(vaobj,buffer,size,type,stride,offset):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLuint) +def glVertexArrayVertexAttribBindingEXT(vaobj,attribindex,bindingindex):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLuint) +def glVertexArrayVertexAttribDivisorEXT(vaobj,index,divisor):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLint,_cs.GLenum,_cs.GLboolean,_cs.GLuint) +def glVertexArrayVertexAttribFormatEXT(vaobj,attribindex,size,type,normalized,relativeoffset):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLint,_cs.GLenum,_cs.GLuint) +def glVertexArrayVertexAttribIFormatEXT(vaobj,attribindex,size,type,relativeoffset):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLuint,_cs.GLint,_cs.GLenum,_cs.GLsizei,_cs.GLintptr) +def glVertexArrayVertexAttribIOffsetEXT(vaobj,buffer,index,size,type,stride,offset):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLint,_cs.GLenum,_cs.GLuint) +def glVertexArrayVertexAttribLFormatEXT(vaobj,attribindex,size,type,relativeoffset):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLuint,_cs.GLint,_cs.GLenum,_cs.GLsizei,_cs.GLintptr) +def glVertexArrayVertexAttribLOffsetEXT(vaobj,buffer,index,size,type,stride,offset):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLuint,_cs.GLint,_cs.GLenum,_cs.GLboolean,_cs.GLsizei,_cs.GLintptr) +def glVertexArrayVertexAttribOffsetEXT(vaobj,buffer,index,size,type,normalized,stride,offset):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLuint) +def glVertexArrayVertexBindingDivisorEXT(vaobj,bindingindex,divisor):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLint,_cs.GLenum,_cs.GLsizei,_cs.GLintptr) +def glVertexArrayVertexOffsetEXT(vaobj,buffer,size,type,stride,offset):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/draw_buffers2.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/draw_buffers2.py new file mode 100644 index 00000000..57cfeba3 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/draw_buffers2.py @@ -0,0 +1,32 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_EXT_draw_buffers2' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_EXT_draw_buffers2',error_checker=_errors._error_checker) + +@_f +@_p.types(None,_cs.GLuint,_cs.GLboolean,_cs.GLboolean,_cs.GLboolean,_cs.GLboolean) +def glColorMaskIndexedEXT(index,r,g,b,a):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint) +def glDisableIndexedEXT(target,index):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint) +def glEnableIndexedEXT(target,index):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,arrays.GLbooleanArray) +def glGetBooleanIndexedvEXT(target,index,data):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,arrays.GLintArray) +def glGetIntegerIndexedvEXT(target,index,data):pass +@_f +@_p.types(_cs.GLboolean,_cs.GLenum,_cs.GLuint) +def glIsEnabledIndexedEXT(target,index):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/draw_instanced.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/draw_instanced.py new file mode 100644 index 00000000..eef2d873 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/draw_instanced.py @@ -0,0 +1,20 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_EXT_draw_instanced' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_EXT_draw_instanced',error_checker=_errors._error_checker) + +@_f +@_p.types(None,_cs.GLenum,_cs.GLint,_cs.GLsizei,_cs.GLsizei) +def glDrawArraysInstancedEXT(mode,start,count,primcount):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizei,_cs.GLenum,ctypes.c_void_p,_cs.GLsizei) +def glDrawElementsInstancedEXT(mode,count,type,indices,primcount):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/draw_range_elements.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/draw_range_elements.py new file mode 100644 index 00000000..f7a2100a --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/draw_range_elements.py @@ -0,0 +1,18 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_EXT_draw_range_elements' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_EXT_draw_range_elements',error_checker=_errors._error_checker) +GL_MAX_ELEMENTS_INDICES_EXT=_C('GL_MAX_ELEMENTS_INDICES_EXT',0x80E9) +GL_MAX_ELEMENTS_VERTICES_EXT=_C('GL_MAX_ELEMENTS_VERTICES_EXT',0x80E8) +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,_cs.GLuint,_cs.GLsizei,_cs.GLenum,ctypes.c_void_p) +def glDrawRangeElementsEXT(mode,start,end,count,type,indices):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/external_buffer.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/external_buffer.py new file mode 100644 index 00000000..9fcc9c43 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/external_buffer.py @@ -0,0 +1,20 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_EXT_external_buffer' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_EXT_external_buffer',error_checker=_errors._error_checker) + +@_f +@_p.types(None,_cs.GLenum,_cs.GLintptr,_cs.GLsizeiptr,_cs.GLeglClientBufferEXT,_cs.GLbitfield) +def glBufferStorageExternalEXT(target,offset,size,clientBuffer,flags):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLintptr,_cs.GLsizeiptr,_cs.GLeglClientBufferEXT,_cs.GLbitfield) +def glNamedBufferStorageExternalEXT(buffer,offset,size,clientBuffer,flags):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/fog_coord.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/fog_coord.py new file mode 100644 index 00000000..27c9a720 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/fog_coord.py @@ -0,0 +1,36 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_EXT_fog_coord' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_EXT_fog_coord',error_checker=_errors._error_checker) +GL_CURRENT_FOG_COORDINATE_EXT=_C('GL_CURRENT_FOG_COORDINATE_EXT',0x8453) +GL_FOG_COORDINATE_ARRAY_EXT=_C('GL_FOG_COORDINATE_ARRAY_EXT',0x8457) +GL_FOG_COORDINATE_ARRAY_POINTER_EXT=_C('GL_FOG_COORDINATE_ARRAY_POINTER_EXT',0x8456) +GL_FOG_COORDINATE_ARRAY_STRIDE_EXT=_C('GL_FOG_COORDINATE_ARRAY_STRIDE_EXT',0x8455) +GL_FOG_COORDINATE_ARRAY_TYPE_EXT=_C('GL_FOG_COORDINATE_ARRAY_TYPE_EXT',0x8454) +GL_FOG_COORDINATE_EXT=_C('GL_FOG_COORDINATE_EXT',0x8451) +GL_FOG_COORDINATE_SOURCE_EXT=_C('GL_FOG_COORDINATE_SOURCE_EXT',0x8450) +GL_FRAGMENT_DEPTH_EXT=_C('GL_FRAGMENT_DEPTH_EXT',0x8452) +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizei,ctypes.c_void_p) +def glFogCoordPointerEXT(type,stride,pointer):pass +@_f +@_p.types(None,_cs.GLdouble) +def glFogCoorddEXT(coord):pass +@_f +@_p.types(None,arrays.GLdoubleArray) +def glFogCoorddvEXT(coord):pass +@_f +@_p.types(None,_cs.GLfloat) +def glFogCoordfEXT(coord):pass +@_f +@_p.types(None,arrays.GLfloatArray) +def glFogCoordfvEXT(coord):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/framebuffer_blit.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/framebuffer_blit.py new file mode 100644 index 00000000..f7866b3e --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/framebuffer_blit.py @@ -0,0 +1,20 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_EXT_framebuffer_blit' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_EXT_framebuffer_blit',error_checker=_errors._error_checker) +GL_DRAW_FRAMEBUFFER_BINDING_EXT=_C('GL_DRAW_FRAMEBUFFER_BINDING_EXT',0x8CA6) +GL_DRAW_FRAMEBUFFER_EXT=_C('GL_DRAW_FRAMEBUFFER_EXT',0x8CA9) +GL_READ_FRAMEBUFFER_BINDING_EXT=_C('GL_READ_FRAMEBUFFER_BINDING_EXT',0x8CAA) +GL_READ_FRAMEBUFFER_EXT=_C('GL_READ_FRAMEBUFFER_EXT',0x8CA8) +@_f +@_p.types(None,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLbitfield,_cs.GLenum) +def glBlitFramebufferEXT(srcX0,srcY0,srcX1,srcY1,dstX0,dstY0,dstX1,dstY1,mask,filter):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/framebuffer_multisample.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/framebuffer_multisample.py new file mode 100644 index 00000000..52953f0f --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/framebuffer_multisample.py @@ -0,0 +1,19 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_EXT_framebuffer_multisample' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_EXT_framebuffer_multisample',error_checker=_errors._error_checker) +GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_EXT=_C('GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_EXT',0x8D56) +GL_MAX_SAMPLES_EXT=_C('GL_MAX_SAMPLES_EXT',0x8D57) +GL_RENDERBUFFER_SAMPLES_EXT=_C('GL_RENDERBUFFER_SAMPLES_EXT',0x8CAB) +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizei,_cs.GLenum,_cs.GLsizei,_cs.GLsizei) +def glRenderbufferStorageMultisampleEXT(target,samples,internalformat,width,height):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/framebuffer_multisample_blit_scaled.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/framebuffer_multisample_blit_scaled.py new file mode 100644 index 00000000..9d1a260e --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/framebuffer_multisample_blit_scaled.py @@ -0,0 +1,16 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_EXT_framebuffer_multisample_blit_scaled' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_EXT_framebuffer_multisample_blit_scaled',error_checker=_errors._error_checker) +GL_SCALED_RESOLVE_FASTEST_EXT=_C('GL_SCALED_RESOLVE_FASTEST_EXT',0x90BA) +GL_SCALED_RESOLVE_NICEST_EXT=_C('GL_SCALED_RESOLVE_NICEST_EXT',0x90BB) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/framebuffer_object.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/framebuffer_object.py new file mode 100644 index 00000000..9b6edb28 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/framebuffer_object.py @@ -0,0 +1,115 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_EXT_framebuffer_object' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_EXT_framebuffer_object',error_checker=_errors._error_checker) +GL_COLOR_ATTACHMENT0_EXT=_C('GL_COLOR_ATTACHMENT0_EXT',0x8CE0) +GL_COLOR_ATTACHMENT10_EXT=_C('GL_COLOR_ATTACHMENT10_EXT',0x8CEA) +GL_COLOR_ATTACHMENT11_EXT=_C('GL_COLOR_ATTACHMENT11_EXT',0x8CEB) +GL_COLOR_ATTACHMENT12_EXT=_C('GL_COLOR_ATTACHMENT12_EXT',0x8CEC) +GL_COLOR_ATTACHMENT13_EXT=_C('GL_COLOR_ATTACHMENT13_EXT',0x8CED) +GL_COLOR_ATTACHMENT14_EXT=_C('GL_COLOR_ATTACHMENT14_EXT',0x8CEE) +GL_COLOR_ATTACHMENT15_EXT=_C('GL_COLOR_ATTACHMENT15_EXT',0x8CEF) +GL_COLOR_ATTACHMENT1_EXT=_C('GL_COLOR_ATTACHMENT1_EXT',0x8CE1) +GL_COLOR_ATTACHMENT2_EXT=_C('GL_COLOR_ATTACHMENT2_EXT',0x8CE2) +GL_COLOR_ATTACHMENT3_EXT=_C('GL_COLOR_ATTACHMENT3_EXT',0x8CE3) +GL_COLOR_ATTACHMENT4_EXT=_C('GL_COLOR_ATTACHMENT4_EXT',0x8CE4) +GL_COLOR_ATTACHMENT5_EXT=_C('GL_COLOR_ATTACHMENT5_EXT',0x8CE5) +GL_COLOR_ATTACHMENT6_EXT=_C('GL_COLOR_ATTACHMENT6_EXT',0x8CE6) +GL_COLOR_ATTACHMENT7_EXT=_C('GL_COLOR_ATTACHMENT7_EXT',0x8CE7) +GL_COLOR_ATTACHMENT8_EXT=_C('GL_COLOR_ATTACHMENT8_EXT',0x8CE8) +GL_COLOR_ATTACHMENT9_EXT=_C('GL_COLOR_ATTACHMENT9_EXT',0x8CE9) +GL_DEPTH_ATTACHMENT_EXT=_C('GL_DEPTH_ATTACHMENT_EXT',0x8D00) +GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT=_C('GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT',0x8CD1) +GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_EXT=_C('GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_EXT',0x8CD0) +GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_EXT=_C('GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_EXT',0x8CD4) +GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_EXT=_C('GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_EXT',0x8CD3) +GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_EXT=_C('GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_EXT',0x8CD2) +GL_FRAMEBUFFER_BINDING_EXT=_C('GL_FRAMEBUFFER_BINDING_EXT',0x8CA6) +GL_FRAMEBUFFER_COMPLETE_EXT=_C('GL_FRAMEBUFFER_COMPLETE_EXT',0x8CD5) +GL_FRAMEBUFFER_EXT=_C('GL_FRAMEBUFFER_EXT',0x8D40) +GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT=_C('GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT',0x8CD6) +GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT=_C('GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT',0x8CD9) +GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT=_C('GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT',0x8CDB) +GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT=_C('GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT',0x8CDA) +GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT=_C('GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT',0x8CD7) +GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT=_C('GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT',0x8CDC) +GL_FRAMEBUFFER_UNSUPPORTED_EXT=_C('GL_FRAMEBUFFER_UNSUPPORTED_EXT',0x8CDD) +GL_INVALID_FRAMEBUFFER_OPERATION_EXT=_C('GL_INVALID_FRAMEBUFFER_OPERATION_EXT',0x0506) +GL_MAX_COLOR_ATTACHMENTS_EXT=_C('GL_MAX_COLOR_ATTACHMENTS_EXT',0x8CDF) +GL_MAX_RENDERBUFFER_SIZE_EXT=_C('GL_MAX_RENDERBUFFER_SIZE_EXT',0x84E8) +GL_RENDERBUFFER_ALPHA_SIZE_EXT=_C('GL_RENDERBUFFER_ALPHA_SIZE_EXT',0x8D53) +GL_RENDERBUFFER_BINDING_EXT=_C('GL_RENDERBUFFER_BINDING_EXT',0x8CA7) +GL_RENDERBUFFER_BLUE_SIZE_EXT=_C('GL_RENDERBUFFER_BLUE_SIZE_EXT',0x8D52) +GL_RENDERBUFFER_DEPTH_SIZE_EXT=_C('GL_RENDERBUFFER_DEPTH_SIZE_EXT',0x8D54) +GL_RENDERBUFFER_EXT=_C('GL_RENDERBUFFER_EXT',0x8D41) +GL_RENDERBUFFER_GREEN_SIZE_EXT=_C('GL_RENDERBUFFER_GREEN_SIZE_EXT',0x8D51) +GL_RENDERBUFFER_HEIGHT_EXT=_C('GL_RENDERBUFFER_HEIGHT_EXT',0x8D43) +GL_RENDERBUFFER_INTERNAL_FORMAT_EXT=_C('GL_RENDERBUFFER_INTERNAL_FORMAT_EXT',0x8D44) +GL_RENDERBUFFER_RED_SIZE_EXT=_C('GL_RENDERBUFFER_RED_SIZE_EXT',0x8D50) +GL_RENDERBUFFER_STENCIL_SIZE_EXT=_C('GL_RENDERBUFFER_STENCIL_SIZE_EXT',0x8D55) +GL_RENDERBUFFER_WIDTH_EXT=_C('GL_RENDERBUFFER_WIDTH_EXT',0x8D42) +GL_STENCIL_ATTACHMENT_EXT=_C('GL_STENCIL_ATTACHMENT_EXT',0x8D20) +GL_STENCIL_INDEX16_EXT=_C('GL_STENCIL_INDEX16_EXT',0x8D49) +GL_STENCIL_INDEX1_EXT=_C('GL_STENCIL_INDEX1_EXT',0x8D46) +GL_STENCIL_INDEX4_EXT=_C('GL_STENCIL_INDEX4_EXT',0x8D47) +GL_STENCIL_INDEX8_EXT=_C('GL_STENCIL_INDEX8_EXT',0x8D48) +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint) +def glBindFramebufferEXT(target,framebuffer):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint) +def glBindRenderbufferEXT(target,renderbuffer):pass +@_f +@_p.types(_cs.GLenum,_cs.GLenum) +def glCheckFramebufferStatusEXT(target):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray) +def glDeleteFramebuffersEXT(n,framebuffers):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray) +def glDeleteRenderbuffersEXT(n,renderbuffers):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLenum,_cs.GLuint) +def glFramebufferRenderbufferEXT(target,attachment,renderbuffertarget,renderbuffer):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLenum,_cs.GLuint,_cs.GLint) +def glFramebufferTexture1DEXT(target,attachment,textarget,texture,level):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLenum,_cs.GLuint,_cs.GLint) +def glFramebufferTexture2DEXT(target,attachment,textarget,texture,level):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLenum,_cs.GLuint,_cs.GLint,_cs.GLint) +def glFramebufferTexture3DEXT(target,attachment,textarget,texture,level,zoffset):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray) +def glGenFramebuffersEXT(n,framebuffers):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray) +def glGenRenderbuffersEXT(n,renderbuffers):pass +@_f +@_p.types(None,_cs.GLenum) +def glGenerateMipmapEXT(target):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLenum,arrays.GLintArray) +def glGetFramebufferAttachmentParameterivEXT(target,attachment,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLintArray) +def glGetRenderbufferParameterivEXT(target,pname,params):pass +@_f +@_p.types(_cs.GLboolean,_cs.GLuint) +def glIsFramebufferEXT(framebuffer):pass +@_f +@_p.types(_cs.GLboolean,_cs.GLuint) +def glIsRenderbufferEXT(renderbuffer):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLsizei,_cs.GLsizei) +def glRenderbufferStorageEXT(target,internalformat,width,height):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/framebuffer_sRGB.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/framebuffer_sRGB.py new file mode 100644 index 00000000..85bd44dd --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/framebuffer_sRGB.py @@ -0,0 +1,16 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_EXT_framebuffer_sRGB' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_EXT_framebuffer_sRGB',error_checker=_errors._error_checker) +GL_FRAMEBUFFER_SRGB_CAPABLE_EXT=_C('GL_FRAMEBUFFER_SRGB_CAPABLE_EXT',0x8DBA) +GL_FRAMEBUFFER_SRGB_EXT=_C('GL_FRAMEBUFFER_SRGB_EXT',0x8DB9) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/geometry_shader4.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/geometry_shader4.py new file mode 100644 index 00000000..1f946fd9 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/geometry_shader4.py @@ -0,0 +1,36 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_EXT_geometry_shader4' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_EXT_geometry_shader4',error_checker=_errors._error_checker) +GL_FRAMEBUFFER_ATTACHMENT_LAYERED_EXT=_C('GL_FRAMEBUFFER_ATTACHMENT_LAYERED_EXT',0x8DA7) +GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER_EXT=_C('GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER_EXT',0x8CD4) +GL_FRAMEBUFFER_INCOMPLETE_LAYER_COUNT_EXT=_C('GL_FRAMEBUFFER_INCOMPLETE_LAYER_COUNT_EXT',0x8DA9) +GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS_EXT=_C('GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS_EXT',0x8DA8) +GL_GEOMETRY_INPUT_TYPE_EXT=_C('GL_GEOMETRY_INPUT_TYPE_EXT',0x8DDB) +GL_GEOMETRY_OUTPUT_TYPE_EXT=_C('GL_GEOMETRY_OUTPUT_TYPE_EXT',0x8DDC) +GL_GEOMETRY_SHADER_EXT=_C('GL_GEOMETRY_SHADER_EXT',0x8DD9) +GL_GEOMETRY_VERTICES_OUT_EXT=_C('GL_GEOMETRY_VERTICES_OUT_EXT',0x8DDA) +GL_LINES_ADJACENCY_EXT=_C('GL_LINES_ADJACENCY_EXT',0x000A) +GL_LINE_STRIP_ADJACENCY_EXT=_C('GL_LINE_STRIP_ADJACENCY_EXT',0x000B) +GL_MAX_GEOMETRY_OUTPUT_VERTICES_EXT=_C('GL_MAX_GEOMETRY_OUTPUT_VERTICES_EXT',0x8DE0) +GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_EXT=_C('GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_EXT',0x8C29) +GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS_EXT=_C('GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS_EXT',0x8DE1) +GL_MAX_GEOMETRY_UNIFORM_COMPONENTS_EXT=_C('GL_MAX_GEOMETRY_UNIFORM_COMPONENTS_EXT',0x8DDF) +GL_MAX_GEOMETRY_VARYING_COMPONENTS_EXT=_C('GL_MAX_GEOMETRY_VARYING_COMPONENTS_EXT',0x8DDD) +GL_MAX_VARYING_COMPONENTS_EXT=_C('GL_MAX_VARYING_COMPONENTS_EXT',0x8B4B) +GL_MAX_VERTEX_VARYING_COMPONENTS_EXT=_C('GL_MAX_VERTEX_VARYING_COMPONENTS_EXT',0x8DDE) +GL_PROGRAM_POINT_SIZE_EXT=_C('GL_PROGRAM_POINT_SIZE_EXT',0x8642) +GL_TRIANGLES_ADJACENCY_EXT=_C('GL_TRIANGLES_ADJACENCY_EXT',0x000C) +GL_TRIANGLE_STRIP_ADJACENCY_EXT=_C('GL_TRIANGLE_STRIP_ADJACENCY_EXT',0x000D) +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLint) +def glProgramParameteriEXT(program,pname,value):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/gpu_program_parameters.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/gpu_program_parameters.py new file mode 100644 index 00000000..4aa3cb82 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/gpu_program_parameters.py @@ -0,0 +1,20 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_EXT_gpu_program_parameters' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_EXT_gpu_program_parameters',error_checker=_errors._error_checker) + +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,_cs.GLsizei,arrays.GLfloatArray) +def glProgramEnvParameters4fvEXT(target,index,count,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,_cs.GLsizei,arrays.GLfloatArray) +def glProgramLocalParameters4fvEXT(target,index,count,params):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/gpu_shader4.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/gpu_shader4.py new file mode 100644 index 00000000..4cdf3ea5 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/gpu_shader4.py @@ -0,0 +1,74 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_EXT_gpu_shader4' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_EXT_gpu_shader4',error_checker=_errors._error_checker) +GL_INT_SAMPLER_1D_ARRAY_EXT=_C('GL_INT_SAMPLER_1D_ARRAY_EXT',0x8DCE) +GL_INT_SAMPLER_1D_EXT=_C('GL_INT_SAMPLER_1D_EXT',0x8DC9) +GL_INT_SAMPLER_2D_ARRAY_EXT=_C('GL_INT_SAMPLER_2D_ARRAY_EXT',0x8DCF) +GL_INT_SAMPLER_2D_EXT=_C('GL_INT_SAMPLER_2D_EXT',0x8DCA) +GL_INT_SAMPLER_2D_RECT_EXT=_C('GL_INT_SAMPLER_2D_RECT_EXT',0x8DCD) +GL_INT_SAMPLER_3D_EXT=_C('GL_INT_SAMPLER_3D_EXT',0x8DCB) +GL_INT_SAMPLER_BUFFER_EXT=_C('GL_INT_SAMPLER_BUFFER_EXT',0x8DD0) +GL_INT_SAMPLER_CUBE_EXT=_C('GL_INT_SAMPLER_CUBE_EXT',0x8DCC) +GL_MAX_PROGRAM_TEXEL_OFFSET_EXT=_C('GL_MAX_PROGRAM_TEXEL_OFFSET_EXT',0x8905) +GL_MIN_PROGRAM_TEXEL_OFFSET_EXT=_C('GL_MIN_PROGRAM_TEXEL_OFFSET_EXT',0x8904) +GL_SAMPLER_1D_ARRAY_EXT=_C('GL_SAMPLER_1D_ARRAY_EXT',0x8DC0) +GL_SAMPLER_1D_ARRAY_SHADOW_EXT=_C('GL_SAMPLER_1D_ARRAY_SHADOW_EXT',0x8DC3) +GL_SAMPLER_2D_ARRAY_EXT=_C('GL_SAMPLER_2D_ARRAY_EXT',0x8DC1) +GL_SAMPLER_2D_ARRAY_SHADOW_EXT=_C('GL_SAMPLER_2D_ARRAY_SHADOW_EXT',0x8DC4) +GL_SAMPLER_BUFFER_EXT=_C('GL_SAMPLER_BUFFER_EXT',0x8DC2) +GL_SAMPLER_CUBE_SHADOW_EXT=_C('GL_SAMPLER_CUBE_SHADOW_EXT',0x8DC5) +GL_UNSIGNED_INT_SAMPLER_1D_ARRAY_EXT=_C('GL_UNSIGNED_INT_SAMPLER_1D_ARRAY_EXT',0x8DD6) +GL_UNSIGNED_INT_SAMPLER_1D_EXT=_C('GL_UNSIGNED_INT_SAMPLER_1D_EXT',0x8DD1) +GL_UNSIGNED_INT_SAMPLER_2D_ARRAY_EXT=_C('GL_UNSIGNED_INT_SAMPLER_2D_ARRAY_EXT',0x8DD7) +GL_UNSIGNED_INT_SAMPLER_2D_EXT=_C('GL_UNSIGNED_INT_SAMPLER_2D_EXT',0x8DD2) +GL_UNSIGNED_INT_SAMPLER_2D_RECT_EXT=_C('GL_UNSIGNED_INT_SAMPLER_2D_RECT_EXT',0x8DD5) +GL_UNSIGNED_INT_SAMPLER_3D_EXT=_C('GL_UNSIGNED_INT_SAMPLER_3D_EXT',0x8DD3) +GL_UNSIGNED_INT_SAMPLER_BUFFER_EXT=_C('GL_UNSIGNED_INT_SAMPLER_BUFFER_EXT',0x8DD8) +GL_UNSIGNED_INT_SAMPLER_CUBE_EXT=_C('GL_UNSIGNED_INT_SAMPLER_CUBE_EXT',0x8DD4) +GL_UNSIGNED_INT_VEC2_EXT=_C('GL_UNSIGNED_INT_VEC2_EXT',0x8DC6) +GL_UNSIGNED_INT_VEC3_EXT=_C('GL_UNSIGNED_INT_VEC3_EXT',0x8DC7) +GL_UNSIGNED_INT_VEC4_EXT=_C('GL_UNSIGNED_INT_VEC4_EXT',0x8DC8) +GL_VERTEX_ATTRIB_ARRAY_INTEGER_EXT=_C('GL_VERTEX_ATTRIB_ARRAY_INTEGER_EXT',0x88FD) +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,arrays.GLcharArray) +def glBindFragDataLocationEXT(program,color,name):pass +@_f +@_p.types(_cs.GLint,_cs.GLuint,arrays.GLcharArray) +def glGetFragDataLocationEXT(program,name):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,arrays.GLuintArray) +def glGetUniformuivEXT(program,location,params):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLuint) +def glUniform1uiEXT(location,v0):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLsizei,arrays.GLuintArray) +def glUniform1uivEXT(location,count,value):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLuint,_cs.GLuint) +def glUniform2uiEXT(location,v0,v1):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLsizei,arrays.GLuintArray) +def glUniform2uivEXT(location,count,value):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLuint,_cs.GLuint,_cs.GLuint) +def glUniform3uiEXT(location,v0,v1,v2):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLsizei,arrays.GLuintArray) +def glUniform3uivEXT(location,count,value):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLuint,_cs.GLuint,_cs.GLuint,_cs.GLuint) +def glUniform4uiEXT(location,v0,v1,v2,v3):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLsizei,arrays.GLuintArray) +def glUniform4uivEXT(location,count,value):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/histogram.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/histogram.py new file mode 100644 index 00000000..77c4a7ca --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/histogram.py @@ -0,0 +1,57 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_EXT_histogram' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_EXT_histogram',error_checker=_errors._error_checker) +GL_HISTOGRAM_ALPHA_SIZE_EXT=_C('GL_HISTOGRAM_ALPHA_SIZE_EXT',0x802B) +GL_HISTOGRAM_BLUE_SIZE_EXT=_C('GL_HISTOGRAM_BLUE_SIZE_EXT',0x802A) +GL_HISTOGRAM_EXT=_C('GL_HISTOGRAM_EXT',0x8024) +GL_HISTOGRAM_FORMAT_EXT=_C('GL_HISTOGRAM_FORMAT_EXT',0x8027) +GL_HISTOGRAM_GREEN_SIZE_EXT=_C('GL_HISTOGRAM_GREEN_SIZE_EXT',0x8029) +GL_HISTOGRAM_LUMINANCE_SIZE_EXT=_C('GL_HISTOGRAM_LUMINANCE_SIZE_EXT',0x802C) +GL_HISTOGRAM_RED_SIZE_EXT=_C('GL_HISTOGRAM_RED_SIZE_EXT',0x8028) +GL_HISTOGRAM_SINK_EXT=_C('GL_HISTOGRAM_SINK_EXT',0x802D) +GL_HISTOGRAM_WIDTH_EXT=_C('GL_HISTOGRAM_WIDTH_EXT',0x8026) +GL_MINMAX_EXT=_C('GL_MINMAX_EXT',0x802E) +GL_MINMAX_FORMAT_EXT=_C('GL_MINMAX_FORMAT_EXT',0x802F) +GL_MINMAX_SINK_EXT=_C('GL_MINMAX_SINK_EXT',0x8030) +GL_PROXY_HISTOGRAM_EXT=_C('GL_PROXY_HISTOGRAM_EXT',0x8025) +GL_TABLE_TOO_LARGE_EXT=_C('GL_TABLE_TOO_LARGE_EXT',0x8031) +@_f +@_p.types(None,_cs.GLenum,_cs.GLboolean,_cs.GLenum,_cs.GLenum,ctypes.c_void_p) +def glGetHistogramEXT(target,reset,format,type,values):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLfloatArray) +def glGetHistogramParameterfvEXT(target,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLintArray) +def glGetHistogramParameterivEXT(target,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLboolean,_cs.GLenum,_cs.GLenum,ctypes.c_void_p) +def glGetMinmaxEXT(target,reset,format,type,values):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLfloatArray) +def glGetMinmaxParameterfvEXT(target,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLintArray) +def glGetMinmaxParameterivEXT(target,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizei,_cs.GLenum,_cs.GLboolean) +def glHistogramEXT(target,width,internalformat,sink):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLboolean) +def glMinmaxEXT(target,internalformat,sink):pass +@_f +@_p.types(None,_cs.GLenum) +def glResetHistogramEXT(target):pass +@_f +@_p.types(None,_cs.GLenum) +def glResetMinmaxEXT(target):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/index_array_formats.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/index_array_formats.py new file mode 100644 index 00000000..251121e1 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/index_array_formats.py @@ -0,0 +1,22 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_EXT_index_array_formats' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_EXT_index_array_formats',error_checker=_errors._error_checker) +GL_IUI_N3F_V2F_EXT=_C('GL_IUI_N3F_V2F_EXT',0x81AF) +GL_IUI_N3F_V3F_EXT=_C('GL_IUI_N3F_V3F_EXT',0x81B0) +GL_IUI_V2F_EXT=_C('GL_IUI_V2F_EXT',0x81AD) +GL_IUI_V3F_EXT=_C('GL_IUI_V3F_EXT',0x81AE) +GL_T2F_IUI_N3F_V2F_EXT=_C('GL_T2F_IUI_N3F_V2F_EXT',0x81B3) +GL_T2F_IUI_N3F_V3F_EXT=_C('GL_T2F_IUI_N3F_V3F_EXT',0x81B4) +GL_T2F_IUI_V2F_EXT=_C('GL_T2F_IUI_V2F_EXT',0x81B1) +GL_T2F_IUI_V3F_EXT=_C('GL_T2F_IUI_V3F_EXT',0x81B2) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/index_func.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/index_func.py new file mode 100644 index 00000000..db9b452a --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/index_func.py @@ -0,0 +1,19 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_EXT_index_func' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_EXT_index_func',error_checker=_errors._error_checker) +GL_INDEX_TEST_EXT=_C('GL_INDEX_TEST_EXT',0x81B5) +GL_INDEX_TEST_FUNC_EXT=_C('GL_INDEX_TEST_FUNC_EXT',0x81B6) +GL_INDEX_TEST_REF_EXT=_C('GL_INDEX_TEST_REF_EXT',0x81B7) +@_f +@_p.types(None,_cs.GLenum,_cs.GLclampf) +def glIndexFuncEXT(func,ref):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/index_material.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/index_material.py new file mode 100644 index 00000000..ce2858a7 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/index_material.py @@ -0,0 +1,19 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_EXT_index_material' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_EXT_index_material',error_checker=_errors._error_checker) +GL_INDEX_MATERIAL_EXT=_C('GL_INDEX_MATERIAL_EXT',0x81B8) +GL_INDEX_MATERIAL_FACE_EXT=_C('GL_INDEX_MATERIAL_FACE_EXT',0x81BA) +GL_INDEX_MATERIAL_PARAMETER_EXT=_C('GL_INDEX_MATERIAL_PARAMETER_EXT',0x81B9) +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum) +def glIndexMaterialEXT(face,mode):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/index_texture.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/index_texture.py new file mode 100644 index 00000000..9be6ba1f --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/index_texture.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_EXT_index_texture' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_EXT_index_texture',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/light_texture.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/light_texture.py new file mode 100644 index 00000000..dad9e8e2 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/light_texture.py @@ -0,0 +1,32 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_EXT_light_texture' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_EXT_light_texture',error_checker=_errors._error_checker) +GL_ATTENUATION_EXT=_C('GL_ATTENUATION_EXT',0x834D) +GL_FRAGMENT_COLOR_EXT=_C('GL_FRAGMENT_COLOR_EXT',0x834C) +GL_FRAGMENT_DEPTH_EXT=_C('GL_FRAGMENT_DEPTH_EXT',0x8452) +GL_FRAGMENT_MATERIAL_EXT=_C('GL_FRAGMENT_MATERIAL_EXT',0x8349) +GL_FRAGMENT_NORMAL_EXT=_C('GL_FRAGMENT_NORMAL_EXT',0x834A) +GL_SHADOW_ATTENUATION_EXT=_C('GL_SHADOW_ATTENUATION_EXT',0x834E) +GL_TEXTURE_APPLICATION_MODE_EXT=_C('GL_TEXTURE_APPLICATION_MODE_EXT',0x834F) +GL_TEXTURE_LIGHT_EXT=_C('GL_TEXTURE_LIGHT_EXT',0x8350) +GL_TEXTURE_MATERIAL_FACE_EXT=_C('GL_TEXTURE_MATERIAL_FACE_EXT',0x8351) +GL_TEXTURE_MATERIAL_PARAMETER_EXT=_C('GL_TEXTURE_MATERIAL_PARAMETER_EXT',0x8352) +@_f +@_p.types(None,_cs.GLenum) +def glApplyTextureEXT(mode):pass +@_f +@_p.types(None,_cs.GLenum) +def glTextureLightEXT(pname):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum) +def glTextureMaterialEXT(face,mode):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/memory_object.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/memory_object.py new file mode 100644 index 00000000..ab397063 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/memory_object.py @@ -0,0 +1,81 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_EXT_memory_object' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_EXT_memory_object',error_checker=_errors._error_checker) +GL_DEDICATED_MEMORY_OBJECT_EXT=_C('GL_DEDICATED_MEMORY_OBJECT_EXT',0x9581) +GL_DEVICE_UUID_EXT=_C('GL_DEVICE_UUID_EXT',0x9597) +GL_DRIVER_UUID_EXT=_C('GL_DRIVER_UUID_EXT',0x9598) +GL_LINEAR_TILING_EXT=_C('GL_LINEAR_TILING_EXT',0x9585) +GL_NUM_DEVICE_UUIDS_EXT=_C('GL_NUM_DEVICE_UUIDS_EXT',0x9596) +GL_NUM_TILING_TYPES_EXT=_C('GL_NUM_TILING_TYPES_EXT',0x9582) +GL_OPTIMAL_TILING_EXT=_C('GL_OPTIMAL_TILING_EXT',0x9584) +GL_PROTECTED_MEMORY_OBJECT_EXT=_C('GL_PROTECTED_MEMORY_OBJECT_EXT',0x959B) +GL_TEXTURE_TILING_EXT=_C('GL_TEXTURE_TILING_EXT',0x9580) +GL_TILING_TYPES_EXT=_C('GL_TILING_TYPES_EXT',0x9583) +GL_UUID_SIZE_EXT=_C('GL_UUID_SIZE_EXT',16) +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizeiptr,_cs.GLuint,_cs.GLuint64) +def glBufferStorageMemEXT(target,size,memory,offset):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray) +def glCreateMemoryObjectsEXT(n,memoryObjects):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray) +def glDeleteMemoryObjectsEXT(n,memoryObjects):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLintArray) +def glGetMemoryObjectParameterivEXT(memoryObject,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,arrays.GLubyteArray) +def glGetUnsignedBytei_vEXT(target,index,data):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLubyteArray) +def glGetUnsignedBytevEXT(pname,data):pass +@_f +@_p.types(_cs.GLboolean,_cs.GLuint) +def glIsMemoryObjectEXT(memoryObject):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLintArray) +def glMemoryObjectParameterivEXT(memoryObject,pname,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizeiptr,_cs.GLuint,_cs.GLuint64) +def glNamedBufferStorageMemEXT(buffer,size,memory,offset):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizei,_cs.GLenum,_cs.GLsizei,_cs.GLuint,_cs.GLuint64) +def glTexStorageMem1DEXT(target,levels,internalFormat,width,memory,offset):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizei,_cs.GLenum,_cs.GLsizei,_cs.GLsizei,_cs.GLuint,_cs.GLuint64) +def glTexStorageMem2DEXT(target,levels,internalFormat,width,height,memory,offset):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizei,_cs.GLenum,_cs.GLsizei,_cs.GLsizei,_cs.GLboolean,_cs.GLuint,_cs.GLuint64) +def glTexStorageMem2DMultisampleEXT(target,samples,internalFormat,width,height,fixedSampleLocations,memory,offset):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizei,_cs.GLenum,_cs.GLsizei,_cs.GLsizei,_cs.GLsizei,_cs.GLuint,_cs.GLuint64) +def glTexStorageMem3DEXT(target,levels,internalFormat,width,height,depth,memory,offset):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizei,_cs.GLenum,_cs.GLsizei,_cs.GLsizei,_cs.GLsizei,_cs.GLboolean,_cs.GLuint,_cs.GLuint64) +def glTexStorageMem3DMultisampleEXT(target,samples,internalFormat,width,height,depth,fixedSampleLocations,memory,offset):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizei,_cs.GLenum,_cs.GLsizei,_cs.GLuint,_cs.GLuint64) +def glTextureStorageMem1DEXT(texture,levels,internalFormat,width,memory,offset):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizei,_cs.GLenum,_cs.GLsizei,_cs.GLsizei,_cs.GLuint,_cs.GLuint64) +def glTextureStorageMem2DEXT(texture,levels,internalFormat,width,height,memory,offset):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizei,_cs.GLenum,_cs.GLsizei,_cs.GLsizei,_cs.GLboolean,_cs.GLuint,_cs.GLuint64) +def glTextureStorageMem2DMultisampleEXT(texture,samples,internalFormat,width,height,fixedSampleLocations,memory,offset):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizei,_cs.GLenum,_cs.GLsizei,_cs.GLsizei,_cs.GLsizei,_cs.GLuint,_cs.GLuint64) +def glTextureStorageMem3DEXT(texture,levels,internalFormat,width,height,depth,memory,offset):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizei,_cs.GLenum,_cs.GLsizei,_cs.GLsizei,_cs.GLsizei,_cs.GLboolean,_cs.GLuint,_cs.GLuint64) +def glTextureStorageMem3DMultisampleEXT(texture,samples,internalFormat,width,height,depth,fixedSampleLocations,memory,offset):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/memory_object_fd.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/memory_object_fd.py new file mode 100644 index 00000000..3e0643e7 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/memory_object_fd.py @@ -0,0 +1,17 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_EXT_memory_object_fd' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_EXT_memory_object_fd',error_checker=_errors._error_checker) +GL_HANDLE_TYPE_OPAQUE_FD_EXT=_C('GL_HANDLE_TYPE_OPAQUE_FD_EXT',0x9586) +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint64,_cs.GLenum,_cs.GLint) +def glImportMemoryFdEXT(memory,size,handleType,fd):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/memory_object_win32.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/memory_object_win32.py new file mode 100644 index 00000000..3d47f2d0 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/memory_object_win32.py @@ -0,0 +1,28 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_EXT_memory_object_win32' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_EXT_memory_object_win32',error_checker=_errors._error_checker) +GL_DEVICE_LUID_EXT=_C('GL_DEVICE_LUID_EXT',0x9599) +GL_DEVICE_NODE_MASK_EXT=_C('GL_DEVICE_NODE_MASK_EXT',0x959A) +GL_HANDLE_TYPE_D3D11_IMAGE_EXT=_C('GL_HANDLE_TYPE_D3D11_IMAGE_EXT',0x958B) +GL_HANDLE_TYPE_D3D11_IMAGE_KMT_EXT=_C('GL_HANDLE_TYPE_D3D11_IMAGE_KMT_EXT',0x958C) +GL_HANDLE_TYPE_D3D12_RESOURCE_EXT=_C('GL_HANDLE_TYPE_D3D12_RESOURCE_EXT',0x958A) +GL_HANDLE_TYPE_D3D12_TILEPOOL_EXT=_C('GL_HANDLE_TYPE_D3D12_TILEPOOL_EXT',0x9589) +GL_HANDLE_TYPE_OPAQUE_WIN32_EXT=_C('GL_HANDLE_TYPE_OPAQUE_WIN32_EXT',0x9587) +GL_HANDLE_TYPE_OPAQUE_WIN32_KMT_EXT=_C('GL_HANDLE_TYPE_OPAQUE_WIN32_KMT_EXT',0x9588) +GL_LUID_SIZE_EXT=_C('GL_LUID_SIZE_EXT',8) +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint64,_cs.GLenum,ctypes.c_void_p) +def glImportMemoryWin32HandleEXT(memory,size,handleType,handle):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint64,_cs.GLenum,ctypes.c_void_p) +def glImportMemoryWin32NameEXT(memory,size,handleType,name):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/misc_attribute.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/misc_attribute.py new file mode 100644 index 00000000..50dfa556 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/misc_attribute.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_EXT_misc_attribute' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_EXT_misc_attribute',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/multi_draw_arrays.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/multi_draw_arrays.py new file mode 100644 index 00000000..18ee5718 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/multi_draw_arrays.py @@ -0,0 +1,20 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_EXT_multi_draw_arrays' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_EXT_multi_draw_arrays',error_checker=_errors._error_checker) + +@_f +@_p.types(None,_cs.GLenum,arrays.GLintArray,arrays.GLsizeiArray,_cs.GLsizei) +def glMultiDrawArraysEXT(mode,first,count,primcount):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLsizeiArray,_cs.GLenum,arrays.GLvoidpArray,_cs.GLsizei) +def glMultiDrawElementsEXT(mode,count,type,indices,primcount):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/multisample.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/multisample.py new file mode 100644 index 00000000..646e677c --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/multisample.py @@ -0,0 +1,36 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_EXT_multisample' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_EXT_multisample',error_checker=_errors._error_checker) +GL_1PASS_EXT=_C('GL_1PASS_EXT',0x80A1) +GL_2PASS_0_EXT=_C('GL_2PASS_0_EXT',0x80A2) +GL_2PASS_1_EXT=_C('GL_2PASS_1_EXT',0x80A3) +GL_4PASS_0_EXT=_C('GL_4PASS_0_EXT',0x80A4) +GL_4PASS_1_EXT=_C('GL_4PASS_1_EXT',0x80A5) +GL_4PASS_2_EXT=_C('GL_4PASS_2_EXT',0x80A6) +GL_4PASS_3_EXT=_C('GL_4PASS_3_EXT',0x80A7) +GL_MULTISAMPLE_BIT_EXT=_C('GL_MULTISAMPLE_BIT_EXT',0x20000000) +GL_MULTISAMPLE_EXT=_C('GL_MULTISAMPLE_EXT',0x809D) +GL_SAMPLES_EXT=_C('GL_SAMPLES_EXT',0x80A9) +GL_SAMPLE_ALPHA_TO_MASK_EXT=_C('GL_SAMPLE_ALPHA_TO_MASK_EXT',0x809E) +GL_SAMPLE_ALPHA_TO_ONE_EXT=_C('GL_SAMPLE_ALPHA_TO_ONE_EXT',0x809F) +GL_SAMPLE_BUFFERS_EXT=_C('GL_SAMPLE_BUFFERS_EXT',0x80A8) +GL_SAMPLE_MASK_EXT=_C('GL_SAMPLE_MASK_EXT',0x80A0) +GL_SAMPLE_MASK_INVERT_EXT=_C('GL_SAMPLE_MASK_INVERT_EXT',0x80AB) +GL_SAMPLE_MASK_VALUE_EXT=_C('GL_SAMPLE_MASK_VALUE_EXT',0x80AA) +GL_SAMPLE_PATTERN_EXT=_C('GL_SAMPLE_PATTERN_EXT',0x80AC) +@_f +@_p.types(None,_cs.GLclampf,_cs.GLboolean) +def glSampleMaskEXT(value,invert):pass +@_f +@_p.types(None,_cs.GLenum) +def glSamplePatternEXT(pattern):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/multiview_tessellation_geometry_shader.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/multiview_tessellation_geometry_shader.py new file mode 100644 index 00000000..aa4d12db --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/multiview_tessellation_geometry_shader.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_EXT_multiview_tessellation_geometry_shader' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_EXT_multiview_tessellation_geometry_shader',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/multiview_texture_multisample.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/multiview_texture_multisample.py new file mode 100644 index 00000000..1d697fb7 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/multiview_texture_multisample.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_EXT_multiview_texture_multisample' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_EXT_multiview_texture_multisample',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/multiview_timer_query.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/multiview_timer_query.py new file mode 100644 index 00000000..71b8b1aa --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/multiview_timer_query.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_EXT_multiview_timer_query' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_EXT_multiview_timer_query',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/packed_depth_stencil.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/packed_depth_stencil.py new file mode 100644 index 00000000..37c6efc6 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/packed_depth_stencil.py @@ -0,0 +1,18 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_EXT_packed_depth_stencil' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_EXT_packed_depth_stencil',error_checker=_errors._error_checker) +GL_DEPTH24_STENCIL8_EXT=_C('GL_DEPTH24_STENCIL8_EXT',0x88F0) +GL_DEPTH_STENCIL_EXT=_C('GL_DEPTH_STENCIL_EXT',0x84F9) +GL_TEXTURE_STENCIL_SIZE_EXT=_C('GL_TEXTURE_STENCIL_SIZE_EXT',0x88F1) +GL_UNSIGNED_INT_24_8_EXT=_C('GL_UNSIGNED_INT_24_8_EXT',0x84FA) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/packed_float.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/packed_float.py new file mode 100644 index 00000000..22b88ac7 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/packed_float.py @@ -0,0 +1,17 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_EXT_packed_float' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_EXT_packed_float',error_checker=_errors._error_checker) +GL_R11F_G11F_B10F_EXT=_C('GL_R11F_G11F_B10F_EXT',0x8C3A) +GL_RGBA_SIGNED_COMPONENTS_EXT=_C('GL_RGBA_SIGNED_COMPONENTS_EXT',0x8C3C) +GL_UNSIGNED_INT_10F_11F_11F_REV_EXT=_C('GL_UNSIGNED_INT_10F_11F_11F_REV_EXT',0x8C3B) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/packed_pixels.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/packed_pixels.py new file mode 100644 index 00000000..45ec7340 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/packed_pixels.py @@ -0,0 +1,19 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_EXT_packed_pixels' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_EXT_packed_pixels',error_checker=_errors._error_checker) +GL_UNSIGNED_BYTE_3_3_2_EXT=_C('GL_UNSIGNED_BYTE_3_3_2_EXT',0x8032) +GL_UNSIGNED_INT_10_10_10_2_EXT=_C('GL_UNSIGNED_INT_10_10_10_2_EXT',0x8036) +GL_UNSIGNED_INT_8_8_8_8_EXT=_C('GL_UNSIGNED_INT_8_8_8_8_EXT',0x8035) +GL_UNSIGNED_SHORT_4_4_4_4_EXT=_C('GL_UNSIGNED_SHORT_4_4_4_4_EXT',0x8033) +GL_UNSIGNED_SHORT_5_5_5_1_EXT=_C('GL_UNSIGNED_SHORT_5_5_5_1_EXT',0x8034) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/paletted_texture.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/paletted_texture.py new file mode 100644 index 00000000..6b958a0f --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/paletted_texture.py @@ -0,0 +1,32 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_EXT_paletted_texture' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_EXT_paletted_texture',error_checker=_errors._error_checker) +GL_COLOR_INDEX12_EXT=_C('GL_COLOR_INDEX12_EXT',0x80E6) +GL_COLOR_INDEX16_EXT=_C('GL_COLOR_INDEX16_EXT',0x80E7) +GL_COLOR_INDEX1_EXT=_C('GL_COLOR_INDEX1_EXT',0x80E2) +GL_COLOR_INDEX2_EXT=_C('GL_COLOR_INDEX2_EXT',0x80E3) +GL_COLOR_INDEX4_EXT=_C('GL_COLOR_INDEX4_EXT',0x80E4) +GL_COLOR_INDEX8_EXT=_C('GL_COLOR_INDEX8_EXT',0x80E5) +GL_TEXTURE_INDEX_SIZE_EXT=_C('GL_TEXTURE_INDEX_SIZE_EXT',0x80ED) +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLsizei,_cs.GLenum,_cs.GLenum,ctypes.c_void_p) +def glColorTableEXT(target,internalFormat,width,format,type,table):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLenum,ctypes.c_void_p) +def glGetColorTableEXT(target,format,type,data):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLfloatArray) +def glGetColorTableParameterfvEXT(target,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLintArray) +def glGetColorTableParameterivEXT(target,pname,params):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/pixel_buffer_object.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/pixel_buffer_object.py new file mode 100644 index 00000000..0ad7c38a --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/pixel_buffer_object.py @@ -0,0 +1,18 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_EXT_pixel_buffer_object' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_EXT_pixel_buffer_object',error_checker=_errors._error_checker) +GL_PIXEL_PACK_BUFFER_BINDING_EXT=_C('GL_PIXEL_PACK_BUFFER_BINDING_EXT',0x88ED) +GL_PIXEL_PACK_BUFFER_EXT=_C('GL_PIXEL_PACK_BUFFER_EXT',0x88EB) +GL_PIXEL_UNPACK_BUFFER_BINDING_EXT=_C('GL_PIXEL_UNPACK_BUFFER_BINDING_EXT',0x88EF) +GL_PIXEL_UNPACK_BUFFER_EXT=_C('GL_PIXEL_UNPACK_BUFFER_EXT',0x88EC) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/pixel_transform.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/pixel_transform.py new file mode 100644 index 00000000..33d41e58 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/pixel_transform.py @@ -0,0 +1,40 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_EXT_pixel_transform' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_EXT_pixel_transform',error_checker=_errors._error_checker) +GL_AVERAGE_EXT=_C('GL_AVERAGE_EXT',0x8335) +GL_CUBIC_EXT=_C('GL_CUBIC_EXT',0x8334) +GL_MAX_PIXEL_TRANSFORM_2D_STACK_DEPTH_EXT=_C('GL_MAX_PIXEL_TRANSFORM_2D_STACK_DEPTH_EXT',0x8337) +GL_PIXEL_CUBIC_WEIGHT_EXT=_C('GL_PIXEL_CUBIC_WEIGHT_EXT',0x8333) +GL_PIXEL_MAG_FILTER_EXT=_C('GL_PIXEL_MAG_FILTER_EXT',0x8331) +GL_PIXEL_MIN_FILTER_EXT=_C('GL_PIXEL_MIN_FILTER_EXT',0x8332) +GL_PIXEL_TRANSFORM_2D_EXT=_C('GL_PIXEL_TRANSFORM_2D_EXT',0x8330) +GL_PIXEL_TRANSFORM_2D_MATRIX_EXT=_C('GL_PIXEL_TRANSFORM_2D_MATRIX_EXT',0x8338) +GL_PIXEL_TRANSFORM_2D_STACK_DEPTH_EXT=_C('GL_PIXEL_TRANSFORM_2D_STACK_DEPTH_EXT',0x8336) +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLfloatArray) +def glGetPixelTransformParameterfvEXT(target,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLintArray) +def glGetPixelTransformParameterivEXT(target,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLfloat) +def glPixelTransformParameterfEXT(target,pname,param):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLfloatArray) +def glPixelTransformParameterfvEXT(target,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLint) +def glPixelTransformParameteriEXT(target,pname,param):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLintArray) +def glPixelTransformParameterivEXT(target,pname,params):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/pixel_transform_color_table.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/pixel_transform_color_table.py new file mode 100644 index 00000000..ea22b7f8 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/pixel_transform_color_table.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_EXT_pixel_transform_color_table' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_EXT_pixel_transform_color_table',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/point_parameters.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/point_parameters.py new file mode 100644 index 00000000..fb47f3ce --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/point_parameters.py @@ -0,0 +1,23 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_EXT_point_parameters' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_EXT_point_parameters',error_checker=_errors._error_checker) +GL_DISTANCE_ATTENUATION_EXT=_C('GL_DISTANCE_ATTENUATION_EXT',0x8129) +GL_POINT_FADE_THRESHOLD_SIZE_EXT=_C('GL_POINT_FADE_THRESHOLD_SIZE_EXT',0x8128) +GL_POINT_SIZE_MAX_EXT=_C('GL_POINT_SIZE_MAX_EXT',0x8127) +GL_POINT_SIZE_MIN_EXT=_C('GL_POINT_SIZE_MIN_EXT',0x8126) +@_f +@_p.types(None,_cs.GLenum,_cs.GLfloat) +def glPointParameterfEXT(pname,param):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLfloatArray) +def glPointParameterfvEXT(pname,params):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/polygon_offset.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/polygon_offset.py new file mode 100644 index 00000000..dbbc70bf --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/polygon_offset.py @@ -0,0 +1,19 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_EXT_polygon_offset' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_EXT_polygon_offset',error_checker=_errors._error_checker) +GL_POLYGON_OFFSET_BIAS_EXT=_C('GL_POLYGON_OFFSET_BIAS_EXT',0x8039) +GL_POLYGON_OFFSET_EXT=_C('GL_POLYGON_OFFSET_EXT',0x8037) +GL_POLYGON_OFFSET_FACTOR_EXT=_C('GL_POLYGON_OFFSET_FACTOR_EXT',0x8038) +@_f +@_p.types(None,_cs.GLfloat,_cs.GLfloat) +def glPolygonOffsetEXT(factor,bias):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/polygon_offset_clamp.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/polygon_offset_clamp.py new file mode 100644 index 00000000..d145d418 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/polygon_offset_clamp.py @@ -0,0 +1,17 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_EXT_polygon_offset_clamp' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_EXT_polygon_offset_clamp',error_checker=_errors._error_checker) +GL_POLYGON_OFFSET_CLAMP_EXT=_C('GL_POLYGON_OFFSET_CLAMP_EXT',0x8E1B) +@_f +@_p.types(None,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat) +def glPolygonOffsetClampEXT(factor,units,clamp):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/post_depth_coverage.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/post_depth_coverage.py new file mode 100644 index 00000000..6d2ea318 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/post_depth_coverage.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_EXT_post_depth_coverage' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_EXT_post_depth_coverage',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/provoking_vertex.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/provoking_vertex.py new file mode 100644 index 00000000..ad3c3c93 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/provoking_vertex.py @@ -0,0 +1,20 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_EXT_provoking_vertex' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_EXT_provoking_vertex',error_checker=_errors._error_checker) +GL_FIRST_VERTEX_CONVENTION_EXT=_C('GL_FIRST_VERTEX_CONVENTION_EXT',0x8E4D) +GL_LAST_VERTEX_CONVENTION_EXT=_C('GL_LAST_VERTEX_CONVENTION_EXT',0x8E4E) +GL_PROVOKING_VERTEX_EXT=_C('GL_PROVOKING_VERTEX_EXT',0x8E4F) +GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION_EXT=_C('GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION_EXT',0x8E4C) +@_f +@_p.types(None,_cs.GLenum) +def glProvokingVertexEXT(mode):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/raster_multisample.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/raster_multisample.py new file mode 100644 index 00000000..9b37cf18 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/raster_multisample.py @@ -0,0 +1,22 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_EXT_raster_multisample' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_EXT_raster_multisample',error_checker=_errors._error_checker) +GL_EFFECTIVE_RASTER_SAMPLES_EXT=_C('GL_EFFECTIVE_RASTER_SAMPLES_EXT',0x932C) +GL_MAX_RASTER_SAMPLES_EXT=_C('GL_MAX_RASTER_SAMPLES_EXT',0x9329) +GL_MULTISAMPLE_RASTERIZATION_ALLOWED_EXT=_C('GL_MULTISAMPLE_RASTERIZATION_ALLOWED_EXT',0x932B) +GL_RASTER_FIXED_SAMPLE_LOCATIONS_EXT=_C('GL_RASTER_FIXED_SAMPLE_LOCATIONS_EXT',0x932A) +GL_RASTER_MULTISAMPLE_EXT=_C('GL_RASTER_MULTISAMPLE_EXT',0x9327) +GL_RASTER_SAMPLES_EXT=_C('GL_RASTER_SAMPLES_EXT',0x9328) +@_f +@_p.types(None,_cs.GLuint,_cs.GLboolean) +def glRasterSamplesEXT(samples,fixedsamplelocations):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/rescale_normal.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/rescale_normal.py new file mode 100644 index 00000000..3a83dd75 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/rescale_normal.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_EXT_rescale_normal' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_EXT_rescale_normal',error_checker=_errors._error_checker) +GL_RESCALE_NORMAL_EXT=_C('GL_RESCALE_NORMAL_EXT',0x803A) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/secondary_color.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/secondary_color.py new file mode 100644 index 00000000..1e6382bc --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/secondary_color.py @@ -0,0 +1,71 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_EXT_secondary_color' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_EXT_secondary_color',error_checker=_errors._error_checker) +GL_COLOR_SUM_EXT=_C('GL_COLOR_SUM_EXT',0x8458) +GL_CURRENT_SECONDARY_COLOR_EXT=_C('GL_CURRENT_SECONDARY_COLOR_EXT',0x8459) +GL_SECONDARY_COLOR_ARRAY_EXT=_C('GL_SECONDARY_COLOR_ARRAY_EXT',0x845E) +GL_SECONDARY_COLOR_ARRAY_POINTER_EXT=_C('GL_SECONDARY_COLOR_ARRAY_POINTER_EXT',0x845D) +GL_SECONDARY_COLOR_ARRAY_SIZE_EXT=_C('GL_SECONDARY_COLOR_ARRAY_SIZE_EXT',0x845A) +GL_SECONDARY_COLOR_ARRAY_STRIDE_EXT=_C('GL_SECONDARY_COLOR_ARRAY_STRIDE_EXT',0x845C) +GL_SECONDARY_COLOR_ARRAY_TYPE_EXT=_C('GL_SECONDARY_COLOR_ARRAY_TYPE_EXT',0x845B) +@_f +@_p.types(None,_cs.GLbyte,_cs.GLbyte,_cs.GLbyte) +def glSecondaryColor3bEXT(red,green,blue):pass +@_f +@_p.types(None,arrays.GLbyteArray) +def glSecondaryColor3bvEXT(v):pass +@_f +@_p.types(None,_cs.GLdouble,_cs.GLdouble,_cs.GLdouble) +def glSecondaryColor3dEXT(red,green,blue):pass +@_f +@_p.types(None,arrays.GLdoubleArray) +def glSecondaryColor3dvEXT(v):pass +@_f +@_p.types(None,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat) +def glSecondaryColor3fEXT(red,green,blue):pass +@_f +@_p.types(None,arrays.GLfloatArray) +def glSecondaryColor3fvEXT(v):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLint,_cs.GLint) +def glSecondaryColor3iEXT(red,green,blue):pass +@_f +@_p.types(None,arrays.GLintArray) +def glSecondaryColor3ivEXT(v):pass +@_f +@_p.types(None,_cs.GLshort,_cs.GLshort,_cs.GLshort) +def glSecondaryColor3sEXT(red,green,blue):pass +@_f +@_p.types(None,arrays.GLshortArray) +def glSecondaryColor3svEXT(v):pass +@_f +@_p.types(None,_cs.GLubyte,_cs.GLubyte,_cs.GLubyte) +def glSecondaryColor3ubEXT(red,green,blue):pass +@_f +@_p.types(None,arrays.GLubyteArray) +def glSecondaryColor3ubvEXT(v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLuint) +def glSecondaryColor3uiEXT(red,green,blue):pass +@_f +@_p.types(None,arrays.GLuintArray) +def glSecondaryColor3uivEXT(v):pass +@_f +@_p.types(None,_cs.GLushort,_cs.GLushort,_cs.GLushort) +def glSecondaryColor3usEXT(red,green,blue):pass +@_f +@_p.types(None,arrays.GLushortArray) +def glSecondaryColor3usvEXT(v):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLenum,_cs.GLsizei,ctypes.c_void_p) +def glSecondaryColorPointerEXT(size,type,stride,pointer):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/semaphore.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/semaphore.py new file mode 100644 index 00000000..ba8fd7a1 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/semaphore.py @@ -0,0 +1,53 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_EXT_semaphore' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_EXT_semaphore',error_checker=_errors._error_checker) +GL_DEVICE_UUID_EXT=_C('GL_DEVICE_UUID_EXT',0x9597) +GL_DRIVER_UUID_EXT=_C('GL_DRIVER_UUID_EXT',0x9598) +GL_LAYOUT_COLOR_ATTACHMENT_EXT=_C('GL_LAYOUT_COLOR_ATTACHMENT_EXT',0x958E) +GL_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_EXT=_C('GL_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_EXT',0x9531) +GL_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_EXT=_C('GL_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_EXT',0x9530) +GL_LAYOUT_DEPTH_STENCIL_ATTACHMENT_EXT=_C('GL_LAYOUT_DEPTH_STENCIL_ATTACHMENT_EXT',0x958F) +GL_LAYOUT_DEPTH_STENCIL_READ_ONLY_EXT=_C('GL_LAYOUT_DEPTH_STENCIL_READ_ONLY_EXT',0x9590) +GL_LAYOUT_GENERAL_EXT=_C('GL_LAYOUT_GENERAL_EXT',0x958D) +GL_LAYOUT_SHADER_READ_ONLY_EXT=_C('GL_LAYOUT_SHADER_READ_ONLY_EXT',0x9591) +GL_LAYOUT_TRANSFER_DST_EXT=_C('GL_LAYOUT_TRANSFER_DST_EXT',0x9593) +GL_LAYOUT_TRANSFER_SRC_EXT=_C('GL_LAYOUT_TRANSFER_SRC_EXT',0x9592) +GL_NUM_DEVICE_UUIDS_EXT=_C('GL_NUM_DEVICE_UUIDS_EXT',0x9596) +GL_UUID_SIZE_EXT=_C('GL_UUID_SIZE_EXT',16) +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray) +def glDeleteSemaphoresEXT(n,semaphores):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray) +def glGenSemaphoresEXT(n,semaphores):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLuint64Array) +def glGetSemaphoreParameterui64vEXT(semaphore,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,arrays.GLubyteArray) +def glGetUnsignedBytei_vEXT(target,index,data):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLubyteArray) +def glGetUnsignedBytevEXT(pname,data):pass +@_f +@_p.types(_cs.GLboolean,_cs.GLuint) +def glIsSemaphoreEXT(semaphore):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLuint64Array) +def glSemaphoreParameterui64vEXT(semaphore,pname,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,arrays.GLuintArray,_cs.GLuint,arrays.GLuintArray,arrays.GLuintArray) +def glSignalSemaphoreEXT(semaphore,numBufferBarriers,buffers,numTextureBarriers,textures,dstLayouts):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,arrays.GLuintArray,_cs.GLuint,arrays.GLuintArray,arrays.GLuintArray) +def glWaitSemaphoreEXT(semaphore,numBufferBarriers,buffers,numTextureBarriers,textures,srcLayouts):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/semaphore_fd.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/semaphore_fd.py new file mode 100644 index 00000000..ae18b0ac --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/semaphore_fd.py @@ -0,0 +1,17 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_EXT_semaphore_fd' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_EXT_semaphore_fd',error_checker=_errors._error_checker) +GL_HANDLE_TYPE_OPAQUE_FD_EXT=_C('GL_HANDLE_TYPE_OPAQUE_FD_EXT',0x9586) +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLint) +def glImportSemaphoreFdEXT(semaphore,handleType,fd):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/semaphore_win32.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/semaphore_win32.py new file mode 100644 index 00000000..51b34227 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/semaphore_win32.py @@ -0,0 +1,26 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_EXT_semaphore_win32' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_EXT_semaphore_win32',error_checker=_errors._error_checker) +GL_D3D12_FENCE_VALUE_EXT=_C('GL_D3D12_FENCE_VALUE_EXT',0x9595) +GL_DEVICE_LUID_EXT=_C('GL_DEVICE_LUID_EXT',0x9599) +GL_DEVICE_NODE_MASK_EXT=_C('GL_DEVICE_NODE_MASK_EXT',0x959A) +GL_HANDLE_TYPE_D3D12_FENCE_EXT=_C('GL_HANDLE_TYPE_D3D12_FENCE_EXT',0x9594) +GL_HANDLE_TYPE_OPAQUE_WIN32_EXT=_C('GL_HANDLE_TYPE_OPAQUE_WIN32_EXT',0x9587) +GL_HANDLE_TYPE_OPAQUE_WIN32_KMT_EXT=_C('GL_HANDLE_TYPE_OPAQUE_WIN32_KMT_EXT',0x9588) +GL_LUID_SIZE_EXT=_C('GL_LUID_SIZE_EXT',8) +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,ctypes.c_void_p) +def glImportSemaphoreWin32HandleEXT(semaphore,handleType,handle):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,ctypes.c_void_p) +def glImportSemaphoreWin32NameEXT(semaphore,handleType,name):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/separate_shader_objects.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/separate_shader_objects.py new file mode 100644 index 00000000..2262cc66 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/separate_shader_objects.py @@ -0,0 +1,164 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_EXT_separate_shader_objects' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_EXT_separate_shader_objects',error_checker=_errors._error_checker) +GL_ACTIVE_PROGRAM_EXT=_C('GL_ACTIVE_PROGRAM_EXT',0x8B8D) +GL_ACTIVE_PROGRAM_EXT=_C('GL_ACTIVE_PROGRAM_EXT',0x8B8D) +GL_ALL_SHADER_BITS_EXT=_C('GL_ALL_SHADER_BITS_EXT',0xFFFFFFFF) +GL_FRAGMENT_SHADER_BIT_EXT=_C('GL_FRAGMENT_SHADER_BIT_EXT',0x00000002) +GL_PROGRAM_PIPELINE_BINDING_EXT=_C('GL_PROGRAM_PIPELINE_BINDING_EXT',0x825A) +GL_PROGRAM_SEPARABLE_EXT=_C('GL_PROGRAM_SEPARABLE_EXT',0x8258) +GL_VERTEX_SHADER_BIT_EXT=_C('GL_VERTEX_SHADER_BIT_EXT',0x00000001) +@_f +@_p.types(None,_cs.GLuint) +def glActiveProgramEXT(program):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint) +def glActiveShaderProgramEXT(pipeline,program):pass +@_f +@_p.types(None,_cs.GLuint) +def glBindProgramPipelineEXT(pipeline):pass +@_f +@_p.types(_cs.GLuint,_cs.GLenum,arrays.GLcharArray) +def glCreateShaderProgramEXT(type,string):pass +@_f +@_p.types(_cs.GLuint,_cs.GLenum,_cs.GLsizei,ctypes.POINTER( ctypes.POINTER( _cs.GLchar ))) +def glCreateShaderProgramvEXT(type,count,strings):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray) +def glDeleteProgramPipelinesEXT(n,pipelines):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray) +def glGenProgramPipelinesEXT(n,pipelines):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizei,arrays.GLsizeiArray,arrays.GLcharArray) +def glGetProgramPipelineInfoLogEXT(pipeline,bufSize,length,infoLog):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLintArray) +def glGetProgramPipelineivEXT(pipeline,pname,params):pass +@_f +@_p.types(_cs.GLboolean,_cs.GLuint) +def glIsProgramPipelineEXT(pipeline):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLint) +def glProgramParameteriEXT(program,pname,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLfloat) +def glProgramUniform1fEXT(program,location,v0):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLfloatArray) +def glProgramUniform1fvEXT(program,location,count,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLint) +def glProgramUniform1iEXT(program,location,v0):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLintArray) +def glProgramUniform1ivEXT(program,location,count,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLuint) +def glProgramUniform1uiEXT(program,location,v0):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLuintArray) +def glProgramUniform1uivEXT(program,location,count,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLfloat,_cs.GLfloat) +def glProgramUniform2fEXT(program,location,v0,v1):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLfloatArray) +def glProgramUniform2fvEXT(program,location,count,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLint,_cs.GLint) +def glProgramUniform2iEXT(program,location,v0,v1):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLintArray) +def glProgramUniform2ivEXT(program,location,count,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLuint,_cs.GLuint) +def glProgramUniform2uiEXT(program,location,v0,v1):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLuintArray) +def glProgramUniform2uivEXT(program,location,count,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat) +def glProgramUniform3fEXT(program,location,v0,v1,v2):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLfloatArray) +def glProgramUniform3fvEXT(program,location,count,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint) +def glProgramUniform3iEXT(program,location,v0,v1,v2):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLintArray) +def glProgramUniform3ivEXT(program,location,count,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLuint,_cs.GLuint,_cs.GLuint) +def glProgramUniform3uiEXT(program,location,v0,v1,v2):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLuintArray) +def glProgramUniform3uivEXT(program,location,count,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat) +def glProgramUniform4fEXT(program,location,v0,v1,v2,v3):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLfloatArray) +def glProgramUniform4fvEXT(program,location,count,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint) +def glProgramUniform4iEXT(program,location,v0,v1,v2,v3):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLintArray) +def glProgramUniform4ivEXT(program,location,count,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLuint,_cs.GLuint,_cs.GLuint,_cs.GLuint) +def glProgramUniform4uiEXT(program,location,v0,v1,v2,v3):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLuintArray) +def glProgramUniform4uivEXT(program,location,count,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,_cs.GLboolean,arrays.GLfloatArray) +def glProgramUniformMatrix2fvEXT(program,location,count,transpose,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,_cs.GLboolean,arrays.GLfloatArray) +def glProgramUniformMatrix2x3fvEXT(program,location,count,transpose,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,_cs.GLboolean,arrays.GLfloatArray) +def glProgramUniformMatrix2x4fvEXT(program,location,count,transpose,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,_cs.GLboolean,arrays.GLfloatArray) +def glProgramUniformMatrix3fvEXT(program,location,count,transpose,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,_cs.GLboolean,arrays.GLfloatArray) +def glProgramUniformMatrix3x2fvEXT(program,location,count,transpose,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,_cs.GLboolean,arrays.GLfloatArray) +def glProgramUniformMatrix3x4fvEXT(program,location,count,transpose,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,_cs.GLboolean,arrays.GLfloatArray) +def glProgramUniformMatrix4fvEXT(program,location,count,transpose,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,_cs.GLboolean,arrays.GLfloatArray) +def glProgramUniformMatrix4fvEXT(program,location,count,transpose,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,_cs.GLboolean,arrays.GLfloatArray) +def glProgramUniformMatrix4x2fvEXT(program,location,count,transpose,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,_cs.GLboolean,arrays.GLfloatArray) +def glProgramUniformMatrix4x3fvEXT(program,location,count,transpose,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLbitfield,_cs.GLuint) +def glUseProgramStagesEXT(pipeline,stages,program):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint) +def glUseShaderProgramEXT(type,program):pass +@_f +@_p.types(None,_cs.GLuint) +def glValidateProgramPipelineEXT(pipeline):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/separate_specular_color.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/separate_specular_color.py new file mode 100644 index 00000000..5ae40f74 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/separate_specular_color.py @@ -0,0 +1,17 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_EXT_separate_specular_color' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_EXT_separate_specular_color',error_checker=_errors._error_checker) +GL_LIGHT_MODEL_COLOR_CONTROL_EXT=_C('GL_LIGHT_MODEL_COLOR_CONTROL_EXT',0x81F8) +GL_SEPARATE_SPECULAR_COLOR_EXT=_C('GL_SEPARATE_SPECULAR_COLOR_EXT',0x81FA) +GL_SINGLE_COLOR_EXT=_C('GL_SINGLE_COLOR_EXT',0x81F9) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/shader_framebuffer_fetch.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/shader_framebuffer_fetch.py new file mode 100644 index 00000000..25ac46ba --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/shader_framebuffer_fetch.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_EXT_shader_framebuffer_fetch' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_EXT_shader_framebuffer_fetch',error_checker=_errors._error_checker) +GL_FRAGMENT_SHADER_DISCARDS_SAMPLES_EXT=_C('GL_FRAGMENT_SHADER_DISCARDS_SAMPLES_EXT',0x8A52) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/shader_framebuffer_fetch_non_coherent.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/shader_framebuffer_fetch_non_coherent.py new file mode 100644 index 00000000..52431c23 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/shader_framebuffer_fetch_non_coherent.py @@ -0,0 +1,17 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_EXT_shader_framebuffer_fetch_non_coherent' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_EXT_shader_framebuffer_fetch_non_coherent',error_checker=_errors._error_checker) +GL_FRAGMENT_SHADER_DISCARDS_SAMPLES_EXT=_C('GL_FRAGMENT_SHADER_DISCARDS_SAMPLES_EXT',0x8A52) +@_f +@_p.types(None,) +def glFramebufferFetchBarrierEXT():pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/shader_image_load_formatted.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/shader_image_load_formatted.py new file mode 100644 index 00000000..4f7b7a64 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/shader_image_load_formatted.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_EXT_shader_image_load_formatted' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_EXT_shader_image_load_formatted',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/shader_image_load_store.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/shader_image_load_store.py new file mode 100644 index 00000000..1c7fff57 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/shader_image_load_store.py @@ -0,0 +1,74 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_EXT_shader_image_load_store' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_EXT_shader_image_load_store',error_checker=_errors._error_checker) +GL_ALL_BARRIER_BITS_EXT=_C('GL_ALL_BARRIER_BITS_EXT',0xFFFFFFFF) +GL_ATOMIC_COUNTER_BARRIER_BIT_EXT=_C('GL_ATOMIC_COUNTER_BARRIER_BIT_EXT',0x00001000) +GL_BUFFER_UPDATE_BARRIER_BIT_EXT=_C('GL_BUFFER_UPDATE_BARRIER_BIT_EXT',0x00000200) +GL_COMMAND_BARRIER_BIT_EXT=_C('GL_COMMAND_BARRIER_BIT_EXT',0x00000040) +GL_ELEMENT_ARRAY_BARRIER_BIT_EXT=_C('GL_ELEMENT_ARRAY_BARRIER_BIT_EXT',0x00000002) +GL_FRAMEBUFFER_BARRIER_BIT_EXT=_C('GL_FRAMEBUFFER_BARRIER_BIT_EXT',0x00000400) +GL_IMAGE_1D_ARRAY_EXT=_C('GL_IMAGE_1D_ARRAY_EXT',0x9052) +GL_IMAGE_1D_EXT=_C('GL_IMAGE_1D_EXT',0x904C) +GL_IMAGE_2D_ARRAY_EXT=_C('GL_IMAGE_2D_ARRAY_EXT',0x9053) +GL_IMAGE_2D_EXT=_C('GL_IMAGE_2D_EXT',0x904D) +GL_IMAGE_2D_MULTISAMPLE_ARRAY_EXT=_C('GL_IMAGE_2D_MULTISAMPLE_ARRAY_EXT',0x9056) +GL_IMAGE_2D_MULTISAMPLE_EXT=_C('GL_IMAGE_2D_MULTISAMPLE_EXT',0x9055) +GL_IMAGE_2D_RECT_EXT=_C('GL_IMAGE_2D_RECT_EXT',0x904F) +GL_IMAGE_3D_EXT=_C('GL_IMAGE_3D_EXT',0x904E) +GL_IMAGE_BINDING_ACCESS_EXT=_C('GL_IMAGE_BINDING_ACCESS_EXT',0x8F3E) +GL_IMAGE_BINDING_FORMAT_EXT=_C('GL_IMAGE_BINDING_FORMAT_EXT',0x906E) +GL_IMAGE_BINDING_LAYERED_EXT=_C('GL_IMAGE_BINDING_LAYERED_EXT',0x8F3C) +GL_IMAGE_BINDING_LAYER_EXT=_C('GL_IMAGE_BINDING_LAYER_EXT',0x8F3D) +GL_IMAGE_BINDING_LEVEL_EXT=_C('GL_IMAGE_BINDING_LEVEL_EXT',0x8F3B) +GL_IMAGE_BINDING_NAME_EXT=_C('GL_IMAGE_BINDING_NAME_EXT',0x8F3A) +GL_IMAGE_BUFFER_EXT=_C('GL_IMAGE_BUFFER_EXT',0x9051) +GL_IMAGE_CUBE_EXT=_C('GL_IMAGE_CUBE_EXT',0x9050) +GL_IMAGE_CUBE_MAP_ARRAY_EXT=_C('GL_IMAGE_CUBE_MAP_ARRAY_EXT',0x9054) +GL_INT_IMAGE_1D_ARRAY_EXT=_C('GL_INT_IMAGE_1D_ARRAY_EXT',0x905D) +GL_INT_IMAGE_1D_EXT=_C('GL_INT_IMAGE_1D_EXT',0x9057) +GL_INT_IMAGE_2D_ARRAY_EXT=_C('GL_INT_IMAGE_2D_ARRAY_EXT',0x905E) +GL_INT_IMAGE_2D_EXT=_C('GL_INT_IMAGE_2D_EXT',0x9058) +GL_INT_IMAGE_2D_MULTISAMPLE_ARRAY_EXT=_C('GL_INT_IMAGE_2D_MULTISAMPLE_ARRAY_EXT',0x9061) +GL_INT_IMAGE_2D_MULTISAMPLE_EXT=_C('GL_INT_IMAGE_2D_MULTISAMPLE_EXT',0x9060) +GL_INT_IMAGE_2D_RECT_EXT=_C('GL_INT_IMAGE_2D_RECT_EXT',0x905A) +GL_INT_IMAGE_3D_EXT=_C('GL_INT_IMAGE_3D_EXT',0x9059) +GL_INT_IMAGE_BUFFER_EXT=_C('GL_INT_IMAGE_BUFFER_EXT',0x905C) +GL_INT_IMAGE_CUBE_EXT=_C('GL_INT_IMAGE_CUBE_EXT',0x905B) +GL_INT_IMAGE_CUBE_MAP_ARRAY_EXT=_C('GL_INT_IMAGE_CUBE_MAP_ARRAY_EXT',0x905F) +GL_MAX_COMBINED_IMAGE_UNITS_AND_FRAGMENT_OUTPUTS_EXT=_C('GL_MAX_COMBINED_IMAGE_UNITS_AND_FRAGMENT_OUTPUTS_EXT',0x8F39) +GL_MAX_IMAGE_SAMPLES_EXT=_C('GL_MAX_IMAGE_SAMPLES_EXT',0x906D) +GL_MAX_IMAGE_UNITS_EXT=_C('GL_MAX_IMAGE_UNITS_EXT',0x8F38) +GL_PIXEL_BUFFER_BARRIER_BIT_EXT=_C('GL_PIXEL_BUFFER_BARRIER_BIT_EXT',0x00000080) +GL_SHADER_IMAGE_ACCESS_BARRIER_BIT_EXT=_C('GL_SHADER_IMAGE_ACCESS_BARRIER_BIT_EXT',0x00000020) +GL_TEXTURE_FETCH_BARRIER_BIT_EXT=_C('GL_TEXTURE_FETCH_BARRIER_BIT_EXT',0x00000008) +GL_TEXTURE_UPDATE_BARRIER_BIT_EXT=_C('GL_TEXTURE_UPDATE_BARRIER_BIT_EXT',0x00000100) +GL_TRANSFORM_FEEDBACK_BARRIER_BIT_EXT=_C('GL_TRANSFORM_FEEDBACK_BARRIER_BIT_EXT',0x00000800) +GL_UNIFORM_BARRIER_BIT_EXT=_C('GL_UNIFORM_BARRIER_BIT_EXT',0x00000004) +GL_UNSIGNED_INT_IMAGE_1D_ARRAY_EXT=_C('GL_UNSIGNED_INT_IMAGE_1D_ARRAY_EXT',0x9068) +GL_UNSIGNED_INT_IMAGE_1D_EXT=_C('GL_UNSIGNED_INT_IMAGE_1D_EXT',0x9062) +GL_UNSIGNED_INT_IMAGE_2D_ARRAY_EXT=_C('GL_UNSIGNED_INT_IMAGE_2D_ARRAY_EXT',0x9069) +GL_UNSIGNED_INT_IMAGE_2D_EXT=_C('GL_UNSIGNED_INT_IMAGE_2D_EXT',0x9063) +GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_ARRAY_EXT=_C('GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_ARRAY_EXT',0x906C) +GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_EXT=_C('GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_EXT',0x906B) +GL_UNSIGNED_INT_IMAGE_2D_RECT_EXT=_C('GL_UNSIGNED_INT_IMAGE_2D_RECT_EXT',0x9065) +GL_UNSIGNED_INT_IMAGE_3D_EXT=_C('GL_UNSIGNED_INT_IMAGE_3D_EXT',0x9064) +GL_UNSIGNED_INT_IMAGE_BUFFER_EXT=_C('GL_UNSIGNED_INT_IMAGE_BUFFER_EXT',0x9067) +GL_UNSIGNED_INT_IMAGE_CUBE_EXT=_C('GL_UNSIGNED_INT_IMAGE_CUBE_EXT',0x9066) +GL_UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY_EXT=_C('GL_UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY_EXT',0x906A) +GL_VERTEX_ATTRIB_ARRAY_BARRIER_BIT_EXT=_C('GL_VERTEX_ATTRIB_ARRAY_BARRIER_BIT_EXT',0x00000001) +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLint,_cs.GLboolean,_cs.GLint,_cs.GLenum,_cs.GLint) +def glBindImageTextureEXT(index,texture,level,layered,layer,access,format):pass +@_f +@_p.types(None,_cs.GLbitfield) +def glMemoryBarrierEXT(barriers):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/shader_integer_mix.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/shader_integer_mix.py new file mode 100644 index 00000000..9becb9a0 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/shader_integer_mix.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_EXT_shader_integer_mix' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_EXT_shader_integer_mix',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/shadow_funcs.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/shadow_funcs.py new file mode 100644 index 00000000..177873a8 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/shadow_funcs.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_EXT_shadow_funcs' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_EXT_shadow_funcs',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/shared_texture_palette.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/shared_texture_palette.py new file mode 100644 index 00000000..fdc6db18 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/shared_texture_palette.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_EXT_shared_texture_palette' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_EXT_shared_texture_palette',error_checker=_errors._error_checker) +GL_SHARED_TEXTURE_PALETTE_EXT=_C('GL_SHARED_TEXTURE_PALETTE_EXT',0x81FB) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/sparse_texture2.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/sparse_texture2.py new file mode 100644 index 00000000..11dd5295 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/sparse_texture2.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_EXT_sparse_texture2' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_EXT_sparse_texture2',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/stencil_clear_tag.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/stencil_clear_tag.py new file mode 100644 index 00000000..814f7912 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/stencil_clear_tag.py @@ -0,0 +1,18 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_EXT_stencil_clear_tag' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_EXT_stencil_clear_tag',error_checker=_errors._error_checker) +GL_STENCIL_CLEAR_TAG_VALUE_EXT=_C('GL_STENCIL_CLEAR_TAG_VALUE_EXT',0x88F3) +GL_STENCIL_TAG_BITS_EXT=_C('GL_STENCIL_TAG_BITS_EXT',0x88F2) +@_f +@_p.types(None,_cs.GLsizei,_cs.GLuint) +def glStencilClearTagEXT(stencilTagBits,stencilClearTag):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/stencil_two_side.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/stencil_two_side.py new file mode 100644 index 00000000..d5997e79 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/stencil_two_side.py @@ -0,0 +1,18 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_EXT_stencil_two_side' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_EXT_stencil_two_side',error_checker=_errors._error_checker) +GL_ACTIVE_STENCIL_FACE_EXT=_C('GL_ACTIVE_STENCIL_FACE_EXT',0x8911) +GL_STENCIL_TEST_TWO_SIDE_EXT=_C('GL_STENCIL_TEST_TWO_SIDE_EXT',0x8910) +@_f +@_p.types(None,_cs.GLenum) +def glActiveStencilFaceEXT(face):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/stencil_wrap.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/stencil_wrap.py new file mode 100644 index 00000000..ad4f0b8a --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/stencil_wrap.py @@ -0,0 +1,16 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_EXT_stencil_wrap' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_EXT_stencil_wrap',error_checker=_errors._error_checker) +GL_DECR_WRAP_EXT=_C('GL_DECR_WRAP_EXT',0x8508) +GL_INCR_WRAP_EXT=_C('GL_INCR_WRAP_EXT',0x8507) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/subtexture.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/subtexture.py new file mode 100644 index 00000000..07d1c4bd --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/subtexture.py @@ -0,0 +1,20 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_EXT_subtexture' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_EXT_subtexture',error_checker=_errors._error_checker) + +@_f +@_p.types(None,_cs.GLenum,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLenum,_cs.GLenum,ctypes.c_void_p) +def glTexSubImage1DEXT(target,level,xoffset,width,format,type,pixels):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLsizei,_cs.GLenum,_cs.GLenum,ctypes.c_void_p) +def glTexSubImage2DEXT(target,level,xoffset,yoffset,width,height,format,type,pixels):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/texture.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/texture.py new file mode 100644 index 00000000..ce96d81d --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/texture.py @@ -0,0 +1,57 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_EXT_texture' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_EXT_texture',error_checker=_errors._error_checker) +GL_ALPHA12_EXT=_C('GL_ALPHA12_EXT',0x803D) +GL_ALPHA16_EXT=_C('GL_ALPHA16_EXT',0x803E) +GL_ALPHA4_EXT=_C('GL_ALPHA4_EXT',0x803B) +GL_ALPHA8_EXT=_C('GL_ALPHA8_EXT',0x803C) +GL_INTENSITY12_EXT=_C('GL_INTENSITY12_EXT',0x804C) +GL_INTENSITY16_EXT=_C('GL_INTENSITY16_EXT',0x804D) +GL_INTENSITY4_EXT=_C('GL_INTENSITY4_EXT',0x804A) +GL_INTENSITY8_EXT=_C('GL_INTENSITY8_EXT',0x804B) +GL_INTENSITY_EXT=_C('GL_INTENSITY_EXT',0x8049) +GL_LUMINANCE12_ALPHA12_EXT=_C('GL_LUMINANCE12_ALPHA12_EXT',0x8047) +GL_LUMINANCE12_ALPHA4_EXT=_C('GL_LUMINANCE12_ALPHA4_EXT',0x8046) +GL_LUMINANCE12_EXT=_C('GL_LUMINANCE12_EXT',0x8041) +GL_LUMINANCE16_ALPHA16_EXT=_C('GL_LUMINANCE16_ALPHA16_EXT',0x8048) +GL_LUMINANCE16_EXT=_C('GL_LUMINANCE16_EXT',0x8042) +GL_LUMINANCE4_ALPHA4_EXT=_C('GL_LUMINANCE4_ALPHA4_EXT',0x8043) +GL_LUMINANCE4_EXT=_C('GL_LUMINANCE4_EXT',0x803F) +GL_LUMINANCE6_ALPHA2_EXT=_C('GL_LUMINANCE6_ALPHA2_EXT',0x8044) +GL_LUMINANCE8_ALPHA8_EXT=_C('GL_LUMINANCE8_ALPHA8_EXT',0x8045) +GL_LUMINANCE8_EXT=_C('GL_LUMINANCE8_EXT',0x8040) +GL_PROXY_TEXTURE_1D_EXT=_C('GL_PROXY_TEXTURE_1D_EXT',0x8063) +GL_PROXY_TEXTURE_2D_EXT=_C('GL_PROXY_TEXTURE_2D_EXT',0x8064) +GL_REPLACE_EXT=_C('GL_REPLACE_EXT',0x8062) +GL_RGB10_A2_EXT=_C('GL_RGB10_A2_EXT',0x8059) +GL_RGB10_EXT=_C('GL_RGB10_EXT',0x8052) +GL_RGB12_EXT=_C('GL_RGB12_EXT',0x8053) +GL_RGB16_EXT=_C('GL_RGB16_EXT',0x8054) +GL_RGB2_EXT=_C('GL_RGB2_EXT',0x804E) +GL_RGB4_EXT=_C('GL_RGB4_EXT',0x804F) +GL_RGB5_A1_EXT=_C('GL_RGB5_A1_EXT',0x8057) +GL_RGB5_EXT=_C('GL_RGB5_EXT',0x8050) +GL_RGB8_EXT=_C('GL_RGB8_EXT',0x8051) +GL_RGBA12_EXT=_C('GL_RGBA12_EXT',0x805A) +GL_RGBA16_EXT=_C('GL_RGBA16_EXT',0x805B) +GL_RGBA2_EXT=_C('GL_RGBA2_EXT',0x8055) +GL_RGBA4_EXT=_C('GL_RGBA4_EXT',0x8056) +GL_RGBA8_EXT=_C('GL_RGBA8_EXT',0x8058) +GL_TEXTURE_ALPHA_SIZE_EXT=_C('GL_TEXTURE_ALPHA_SIZE_EXT',0x805F) +GL_TEXTURE_BLUE_SIZE_EXT=_C('GL_TEXTURE_BLUE_SIZE_EXT',0x805E) +GL_TEXTURE_GREEN_SIZE_EXT=_C('GL_TEXTURE_GREEN_SIZE_EXT',0x805D) +GL_TEXTURE_INTENSITY_SIZE_EXT=_C('GL_TEXTURE_INTENSITY_SIZE_EXT',0x8061) +GL_TEXTURE_LUMINANCE_SIZE_EXT=_C('GL_TEXTURE_LUMINANCE_SIZE_EXT',0x8060) +GL_TEXTURE_RED_SIZE_EXT=_C('GL_TEXTURE_RED_SIZE_EXT',0x805C) +GL_TEXTURE_TOO_LARGE_EXT=_C('GL_TEXTURE_TOO_LARGE_EXT',0x8065) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/texture3D.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/texture3D.py new file mode 100644 index 00000000..eff90dfb --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/texture3D.py @@ -0,0 +1,28 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_EXT_texture3D' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_EXT_texture3D',error_checker=_errors._error_checker) +GL_MAX_3D_TEXTURE_SIZE_EXT=_C('GL_MAX_3D_TEXTURE_SIZE_EXT',0x8073) +GL_PACK_IMAGE_HEIGHT_EXT=_C('GL_PACK_IMAGE_HEIGHT_EXT',0x806C) +GL_PACK_SKIP_IMAGES_EXT=_C('GL_PACK_SKIP_IMAGES_EXT',0x806B) +GL_PROXY_TEXTURE_3D_EXT=_C('GL_PROXY_TEXTURE_3D_EXT',0x8070) +GL_TEXTURE_3D_EXT=_C('GL_TEXTURE_3D_EXT',0x806F) +GL_TEXTURE_DEPTH_EXT=_C('GL_TEXTURE_DEPTH_EXT',0x8071) +GL_TEXTURE_WRAP_R_EXT=_C('GL_TEXTURE_WRAP_R_EXT',0x8072) +GL_UNPACK_IMAGE_HEIGHT_EXT=_C('GL_UNPACK_IMAGE_HEIGHT_EXT',0x806E) +GL_UNPACK_SKIP_IMAGES_EXT=_C('GL_UNPACK_SKIP_IMAGES_EXT',0x806D) +@_f +@_p.types(None,_cs.GLenum,_cs.GLint,_cs.GLenum,_cs.GLsizei,_cs.GLsizei,_cs.GLsizei,_cs.GLint,_cs.GLenum,_cs.GLenum,ctypes.c_void_p) +def glTexImage3DEXT(target,level,internalformat,width,height,depth,border,format,type,pixels):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLsizei,_cs.GLsizei,_cs.GLenum,_cs.GLenum,ctypes.c_void_p) +def glTexSubImage3DEXT(target,level,xoffset,yoffset,zoffset,width,height,depth,format,type,pixels):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/texture_array.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/texture_array.py new file mode 100644 index 00000000..6cabeada --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/texture_array.py @@ -0,0 +1,25 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_EXT_texture_array' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_EXT_texture_array',error_checker=_errors._error_checker) +GL_COMPARE_REF_DEPTH_TO_TEXTURE_EXT=_C('GL_COMPARE_REF_DEPTH_TO_TEXTURE_EXT',0x884E) +GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER_EXT=_C('GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER_EXT',0x8CD4) +GL_MAX_ARRAY_TEXTURE_LAYERS_EXT=_C('GL_MAX_ARRAY_TEXTURE_LAYERS_EXT',0x88FF) +GL_PROXY_TEXTURE_1D_ARRAY_EXT=_C('GL_PROXY_TEXTURE_1D_ARRAY_EXT',0x8C19) +GL_PROXY_TEXTURE_2D_ARRAY_EXT=_C('GL_PROXY_TEXTURE_2D_ARRAY_EXT',0x8C1B) +GL_TEXTURE_1D_ARRAY_EXT=_C('GL_TEXTURE_1D_ARRAY_EXT',0x8C18) +GL_TEXTURE_2D_ARRAY_EXT=_C('GL_TEXTURE_2D_ARRAY_EXT',0x8C1A) +GL_TEXTURE_BINDING_1D_ARRAY_EXT=_C('GL_TEXTURE_BINDING_1D_ARRAY_EXT',0x8C1C) +GL_TEXTURE_BINDING_2D_ARRAY_EXT=_C('GL_TEXTURE_BINDING_2D_ARRAY_EXT',0x8C1D) +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLuint,_cs.GLint,_cs.GLint) +def glFramebufferTextureLayerEXT(target,attachment,texture,level,layer):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/texture_buffer_object.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/texture_buffer_object.py new file mode 100644 index 00000000..717182a9 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/texture_buffer_object.py @@ -0,0 +1,21 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_EXT_texture_buffer_object' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_EXT_texture_buffer_object',error_checker=_errors._error_checker) +GL_MAX_TEXTURE_BUFFER_SIZE_EXT=_C('GL_MAX_TEXTURE_BUFFER_SIZE_EXT',0x8C2B) +GL_TEXTURE_BINDING_BUFFER_EXT=_C('GL_TEXTURE_BINDING_BUFFER_EXT',0x8C2C) +GL_TEXTURE_BUFFER_DATA_STORE_BINDING_EXT=_C('GL_TEXTURE_BUFFER_DATA_STORE_BINDING_EXT',0x8C2D) +GL_TEXTURE_BUFFER_EXT=_C('GL_TEXTURE_BUFFER_EXT',0x8C2A) +GL_TEXTURE_BUFFER_FORMAT_EXT=_C('GL_TEXTURE_BUFFER_FORMAT_EXT',0x8C2E) +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLuint) +def glTexBufferEXT(target,internalformat,buffer):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/texture_compression_latc.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/texture_compression_latc.py new file mode 100644 index 00000000..f5b07ed1 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/texture_compression_latc.py @@ -0,0 +1,18 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_EXT_texture_compression_latc' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_EXT_texture_compression_latc',error_checker=_errors._error_checker) +GL_COMPRESSED_LUMINANCE_ALPHA_LATC2_EXT=_C('GL_COMPRESSED_LUMINANCE_ALPHA_LATC2_EXT',0x8C72) +GL_COMPRESSED_LUMINANCE_LATC1_EXT=_C('GL_COMPRESSED_LUMINANCE_LATC1_EXT',0x8C70) +GL_COMPRESSED_SIGNED_LUMINANCE_ALPHA_LATC2_EXT=_C('GL_COMPRESSED_SIGNED_LUMINANCE_ALPHA_LATC2_EXT',0x8C73) +GL_COMPRESSED_SIGNED_LUMINANCE_LATC1_EXT=_C('GL_COMPRESSED_SIGNED_LUMINANCE_LATC1_EXT',0x8C71) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/texture_compression_rgtc.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/texture_compression_rgtc.py new file mode 100644 index 00000000..8ecc7a8c --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/texture_compression_rgtc.py @@ -0,0 +1,18 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_EXT_texture_compression_rgtc' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_EXT_texture_compression_rgtc',error_checker=_errors._error_checker) +GL_COMPRESSED_RED_GREEN_RGTC2_EXT=_C('GL_COMPRESSED_RED_GREEN_RGTC2_EXT',0x8DBD) +GL_COMPRESSED_RED_RGTC1_EXT=_C('GL_COMPRESSED_RED_RGTC1_EXT',0x8DBB) +GL_COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT=_C('GL_COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT',0x8DBE) +GL_COMPRESSED_SIGNED_RED_RGTC1_EXT=_C('GL_COMPRESSED_SIGNED_RED_RGTC1_EXT',0x8DBC) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/texture_compression_s3tc.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/texture_compression_s3tc.py new file mode 100644 index 00000000..bcd978dd --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/texture_compression_s3tc.py @@ -0,0 +1,18 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_EXT_texture_compression_s3tc' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_EXT_texture_compression_s3tc',error_checker=_errors._error_checker) +GL_COMPRESSED_RGBA_S3TC_DXT1_EXT=_C('GL_COMPRESSED_RGBA_S3TC_DXT1_EXT',0x83F1) +GL_COMPRESSED_RGBA_S3TC_DXT3_EXT=_C('GL_COMPRESSED_RGBA_S3TC_DXT3_EXT',0x83F2) +GL_COMPRESSED_RGBA_S3TC_DXT5_EXT=_C('GL_COMPRESSED_RGBA_S3TC_DXT5_EXT',0x83F3) +GL_COMPRESSED_RGB_S3TC_DXT1_EXT=_C('GL_COMPRESSED_RGB_S3TC_DXT1_EXT',0x83F0) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/texture_cube_map.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/texture_cube_map.py new file mode 100644 index 00000000..468e2b36 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/texture_cube_map.py @@ -0,0 +1,26 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_EXT_texture_cube_map' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_EXT_texture_cube_map',error_checker=_errors._error_checker) +GL_MAX_CUBE_MAP_TEXTURE_SIZE_EXT=_C('GL_MAX_CUBE_MAP_TEXTURE_SIZE_EXT',0x851C) +GL_NORMAL_MAP_EXT=_C('GL_NORMAL_MAP_EXT',0x8511) +GL_PROXY_TEXTURE_CUBE_MAP_EXT=_C('GL_PROXY_TEXTURE_CUBE_MAP_EXT',0x851B) +GL_REFLECTION_MAP_EXT=_C('GL_REFLECTION_MAP_EXT',0x8512) +GL_TEXTURE_BINDING_CUBE_MAP_EXT=_C('GL_TEXTURE_BINDING_CUBE_MAP_EXT',0x8514) +GL_TEXTURE_CUBE_MAP_EXT=_C('GL_TEXTURE_CUBE_MAP_EXT',0x8513) +GL_TEXTURE_CUBE_MAP_NEGATIVE_X_EXT=_C('GL_TEXTURE_CUBE_MAP_NEGATIVE_X_EXT',0x8516) +GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_EXT=_C('GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_EXT',0x8518) +GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_EXT=_C('GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_EXT',0x851A) +GL_TEXTURE_CUBE_MAP_POSITIVE_X_EXT=_C('GL_TEXTURE_CUBE_MAP_POSITIVE_X_EXT',0x8515) +GL_TEXTURE_CUBE_MAP_POSITIVE_Y_EXT=_C('GL_TEXTURE_CUBE_MAP_POSITIVE_Y_EXT',0x8517) +GL_TEXTURE_CUBE_MAP_POSITIVE_Z_EXT=_C('GL_TEXTURE_CUBE_MAP_POSITIVE_Z_EXT',0x8519) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/texture_env_add.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/texture_env_add.py new file mode 100644 index 00000000..7e8c9d87 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/texture_env_add.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_EXT_texture_env_add' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_EXT_texture_env_add',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/texture_env_combine.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/texture_env_combine.py new file mode 100644 index 00000000..0296abe7 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/texture_env_combine.py @@ -0,0 +1,35 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_EXT_texture_env_combine' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_EXT_texture_env_combine',error_checker=_errors._error_checker) +GL_ADD_SIGNED_EXT=_C('GL_ADD_SIGNED_EXT',0x8574) +GL_COMBINE_ALPHA_EXT=_C('GL_COMBINE_ALPHA_EXT',0x8572) +GL_COMBINE_EXT=_C('GL_COMBINE_EXT',0x8570) +GL_COMBINE_RGB_EXT=_C('GL_COMBINE_RGB_EXT',0x8571) +GL_CONSTANT_EXT=_C('GL_CONSTANT_EXT',0x8576) +GL_INTERPOLATE_EXT=_C('GL_INTERPOLATE_EXT',0x8575) +GL_OPERAND0_ALPHA_EXT=_C('GL_OPERAND0_ALPHA_EXT',0x8598) +GL_OPERAND0_RGB_EXT=_C('GL_OPERAND0_RGB_EXT',0x8590) +GL_OPERAND1_ALPHA_EXT=_C('GL_OPERAND1_ALPHA_EXT',0x8599) +GL_OPERAND1_RGB_EXT=_C('GL_OPERAND1_RGB_EXT',0x8591) +GL_OPERAND2_ALPHA_EXT=_C('GL_OPERAND2_ALPHA_EXT',0x859A) +GL_OPERAND2_RGB_EXT=_C('GL_OPERAND2_RGB_EXT',0x8592) +GL_PREVIOUS_EXT=_C('GL_PREVIOUS_EXT',0x8578) +GL_PRIMARY_COLOR_EXT=_C('GL_PRIMARY_COLOR_EXT',0x8577) +GL_RGB_SCALE_EXT=_C('GL_RGB_SCALE_EXT',0x8573) +GL_SOURCE0_ALPHA_EXT=_C('GL_SOURCE0_ALPHA_EXT',0x8588) +GL_SOURCE0_RGB_EXT=_C('GL_SOURCE0_RGB_EXT',0x8580) +GL_SOURCE1_ALPHA_EXT=_C('GL_SOURCE1_ALPHA_EXT',0x8589) +GL_SOURCE1_RGB_EXT=_C('GL_SOURCE1_RGB_EXT',0x8581) +GL_SOURCE2_ALPHA_EXT=_C('GL_SOURCE2_ALPHA_EXT',0x858A) +GL_SOURCE2_RGB_EXT=_C('GL_SOURCE2_RGB_EXT',0x8582) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/texture_env_dot3.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/texture_env_dot3.py new file mode 100644 index 00000000..ead39b55 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/texture_env_dot3.py @@ -0,0 +1,16 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_EXT_texture_env_dot3' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_EXT_texture_env_dot3',error_checker=_errors._error_checker) +GL_DOT3_RGBA_EXT=_C('GL_DOT3_RGBA_EXT',0x8741) +GL_DOT3_RGB_EXT=_C('GL_DOT3_RGB_EXT',0x8740) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/texture_filter_anisotropic.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/texture_filter_anisotropic.py new file mode 100644 index 00000000..5ba520ac --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/texture_filter_anisotropic.py @@ -0,0 +1,16 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_EXT_texture_filter_anisotropic' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_EXT_texture_filter_anisotropic',error_checker=_errors._error_checker) +GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT=_C('GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT',0x84FF) +GL_TEXTURE_MAX_ANISOTROPY_EXT=_C('GL_TEXTURE_MAX_ANISOTROPY_EXT',0x84FE) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/texture_filter_minmax.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/texture_filter_minmax.py new file mode 100644 index 00000000..962dca15 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/texture_filter_minmax.py @@ -0,0 +1,16 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_EXT_texture_filter_minmax' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_EXT_texture_filter_minmax',error_checker=_errors._error_checker) +GL_TEXTURE_REDUCTION_MODE_EXT=_C('GL_TEXTURE_REDUCTION_MODE_EXT',0x9366) +GL_WEIGHTED_AVERAGE_EXT=_C('GL_WEIGHTED_AVERAGE_EXT',0x9367) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/texture_integer.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/texture_integer.py new file mode 100644 index 00000000..696badc0 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/texture_integer.py @@ -0,0 +1,78 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_EXT_texture_integer' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_EXT_texture_integer',error_checker=_errors._error_checker) +GL_ALPHA16I_EXT=_C('GL_ALPHA16I_EXT',0x8D8A) +GL_ALPHA16UI_EXT=_C('GL_ALPHA16UI_EXT',0x8D78) +GL_ALPHA32I_EXT=_C('GL_ALPHA32I_EXT',0x8D84) +GL_ALPHA32UI_EXT=_C('GL_ALPHA32UI_EXT',0x8D72) +GL_ALPHA8I_EXT=_C('GL_ALPHA8I_EXT',0x8D90) +GL_ALPHA8UI_EXT=_C('GL_ALPHA8UI_EXT',0x8D7E) +GL_ALPHA_INTEGER_EXT=_C('GL_ALPHA_INTEGER_EXT',0x8D97) +GL_BGRA_INTEGER_EXT=_C('GL_BGRA_INTEGER_EXT',0x8D9B) +GL_BGR_INTEGER_EXT=_C('GL_BGR_INTEGER_EXT',0x8D9A) +GL_BLUE_INTEGER_EXT=_C('GL_BLUE_INTEGER_EXT',0x8D96) +GL_GREEN_INTEGER_EXT=_C('GL_GREEN_INTEGER_EXT',0x8D95) +GL_INTENSITY16I_EXT=_C('GL_INTENSITY16I_EXT',0x8D8B) +GL_INTENSITY16UI_EXT=_C('GL_INTENSITY16UI_EXT',0x8D79) +GL_INTENSITY32I_EXT=_C('GL_INTENSITY32I_EXT',0x8D85) +GL_INTENSITY32UI_EXT=_C('GL_INTENSITY32UI_EXT',0x8D73) +GL_INTENSITY8I_EXT=_C('GL_INTENSITY8I_EXT',0x8D91) +GL_INTENSITY8UI_EXT=_C('GL_INTENSITY8UI_EXT',0x8D7F) +GL_LUMINANCE16I_EXT=_C('GL_LUMINANCE16I_EXT',0x8D8C) +GL_LUMINANCE16UI_EXT=_C('GL_LUMINANCE16UI_EXT',0x8D7A) +GL_LUMINANCE32I_EXT=_C('GL_LUMINANCE32I_EXT',0x8D86) +GL_LUMINANCE32UI_EXT=_C('GL_LUMINANCE32UI_EXT',0x8D74) +GL_LUMINANCE8I_EXT=_C('GL_LUMINANCE8I_EXT',0x8D92) +GL_LUMINANCE8UI_EXT=_C('GL_LUMINANCE8UI_EXT',0x8D80) +GL_LUMINANCE_ALPHA16I_EXT=_C('GL_LUMINANCE_ALPHA16I_EXT',0x8D8D) +GL_LUMINANCE_ALPHA16UI_EXT=_C('GL_LUMINANCE_ALPHA16UI_EXT',0x8D7B) +GL_LUMINANCE_ALPHA32I_EXT=_C('GL_LUMINANCE_ALPHA32I_EXT',0x8D87) +GL_LUMINANCE_ALPHA32UI_EXT=_C('GL_LUMINANCE_ALPHA32UI_EXT',0x8D75) +GL_LUMINANCE_ALPHA8I_EXT=_C('GL_LUMINANCE_ALPHA8I_EXT',0x8D93) +GL_LUMINANCE_ALPHA8UI_EXT=_C('GL_LUMINANCE_ALPHA8UI_EXT',0x8D81) +GL_LUMINANCE_ALPHA_INTEGER_EXT=_C('GL_LUMINANCE_ALPHA_INTEGER_EXT',0x8D9D) +GL_LUMINANCE_INTEGER_EXT=_C('GL_LUMINANCE_INTEGER_EXT',0x8D9C) +GL_RED_INTEGER_EXT=_C('GL_RED_INTEGER_EXT',0x8D94) +GL_RGB16I_EXT=_C('GL_RGB16I_EXT',0x8D89) +GL_RGB16UI_EXT=_C('GL_RGB16UI_EXT',0x8D77) +GL_RGB32I_EXT=_C('GL_RGB32I_EXT',0x8D83) +GL_RGB32UI_EXT=_C('GL_RGB32UI_EXT',0x8D71) +GL_RGB8I_EXT=_C('GL_RGB8I_EXT',0x8D8F) +GL_RGB8UI_EXT=_C('GL_RGB8UI_EXT',0x8D7D) +GL_RGBA16I_EXT=_C('GL_RGBA16I_EXT',0x8D88) +GL_RGBA16UI_EXT=_C('GL_RGBA16UI_EXT',0x8D76) +GL_RGBA32I_EXT=_C('GL_RGBA32I_EXT',0x8D82) +GL_RGBA32UI_EXT=_C('GL_RGBA32UI_EXT',0x8D70) +GL_RGBA8I_EXT=_C('GL_RGBA8I_EXT',0x8D8E) +GL_RGBA8UI_EXT=_C('GL_RGBA8UI_EXT',0x8D7C) +GL_RGBA_INTEGER_EXT=_C('GL_RGBA_INTEGER_EXT',0x8D99) +GL_RGBA_INTEGER_MODE_EXT=_C('GL_RGBA_INTEGER_MODE_EXT',0x8D9E) +GL_RGB_INTEGER_EXT=_C('GL_RGB_INTEGER_EXT',0x8D98) +@_f +@_p.types(None,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint) +def glClearColorIiEXT(red,green,blue,alpha):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLuint,_cs.GLuint) +def glClearColorIuiEXT(red,green,blue,alpha):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLintArray) +def glGetTexParameterIivEXT(target,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLuintArray) +def glGetTexParameterIuivEXT(target,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLintArray) +def glTexParameterIivEXT(target,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLuintArray) +def glTexParameterIuivEXT(target,pname,params):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/texture_lod_bias.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/texture_lod_bias.py new file mode 100644 index 00000000..f1b0053e --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/texture_lod_bias.py @@ -0,0 +1,17 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_EXT_texture_lod_bias' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_EXT_texture_lod_bias',error_checker=_errors._error_checker) +GL_MAX_TEXTURE_LOD_BIAS_EXT=_C('GL_MAX_TEXTURE_LOD_BIAS_EXT',0x84FD) +GL_TEXTURE_FILTER_CONTROL_EXT=_C('GL_TEXTURE_FILTER_CONTROL_EXT',0x8500) +GL_TEXTURE_LOD_BIAS_EXT=_C('GL_TEXTURE_LOD_BIAS_EXT',0x8501) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/texture_mirror_clamp.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/texture_mirror_clamp.py new file mode 100644 index 00000000..e770dfba --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/texture_mirror_clamp.py @@ -0,0 +1,17 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_EXT_texture_mirror_clamp' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_EXT_texture_mirror_clamp',error_checker=_errors._error_checker) +GL_MIRROR_CLAMP_EXT=_C('GL_MIRROR_CLAMP_EXT',0x8742) +GL_MIRROR_CLAMP_TO_BORDER_EXT=_C('GL_MIRROR_CLAMP_TO_BORDER_EXT',0x8912) +GL_MIRROR_CLAMP_TO_EDGE_EXT=_C('GL_MIRROR_CLAMP_TO_EDGE_EXT',0x8743) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/texture_object.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/texture_object.py new file mode 100644 index 00000000..6d372270 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/texture_object.py @@ -0,0 +1,36 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_EXT_texture_object' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_EXT_texture_object',error_checker=_errors._error_checker) +GL_TEXTURE_1D_BINDING_EXT=_C('GL_TEXTURE_1D_BINDING_EXT',0x8068) +GL_TEXTURE_2D_BINDING_EXT=_C('GL_TEXTURE_2D_BINDING_EXT',0x8069) +GL_TEXTURE_3D_BINDING_EXT=_C('GL_TEXTURE_3D_BINDING_EXT',0x806A) +GL_TEXTURE_PRIORITY_EXT=_C('GL_TEXTURE_PRIORITY_EXT',0x8066) +GL_TEXTURE_RESIDENT_EXT=_C('GL_TEXTURE_RESIDENT_EXT',0x8067) +@_f +@_p.types(_cs.GLboolean,_cs.GLsizei,arrays.GLuintArray,arrays.GLbooleanArray) +def glAreTexturesResidentEXT(n,textures,residences):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint) +def glBindTextureEXT(target,texture):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray) +def glDeleteTexturesEXT(n,textures):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray) +def glGenTexturesEXT(n,textures):pass +@_f +@_p.types(_cs.GLboolean,_cs.GLuint) +def glIsTextureEXT(texture):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray,arrays.GLclampfArray) +def glPrioritizeTexturesEXT(n,textures,priorities):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/texture_perturb_normal.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/texture_perturb_normal.py new file mode 100644 index 00000000..125f8de3 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/texture_perturb_normal.py @@ -0,0 +1,18 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_EXT_texture_perturb_normal' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_EXT_texture_perturb_normal',error_checker=_errors._error_checker) +GL_PERTURB_EXT=_C('GL_PERTURB_EXT',0x85AE) +GL_TEXTURE_NORMAL_EXT=_C('GL_TEXTURE_NORMAL_EXT',0x85AF) +@_f +@_p.types(None,_cs.GLenum) +def glTextureNormalEXT(mode):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/texture_sRGB.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/texture_sRGB.py new file mode 100644 index 00000000..b62bbffa --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/texture_sRGB.py @@ -0,0 +1,30 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_EXT_texture_sRGB' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_EXT_texture_sRGB',error_checker=_errors._error_checker) +GL_COMPRESSED_SLUMINANCE_ALPHA_EXT=_C('GL_COMPRESSED_SLUMINANCE_ALPHA_EXT',0x8C4B) +GL_COMPRESSED_SLUMINANCE_EXT=_C('GL_COMPRESSED_SLUMINANCE_EXT',0x8C4A) +GL_COMPRESSED_SRGB_ALPHA_EXT=_C('GL_COMPRESSED_SRGB_ALPHA_EXT',0x8C49) +GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT=_C('GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT',0x8C4D) +GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT=_C('GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT',0x8C4E) +GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT=_C('GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT',0x8C4F) +GL_COMPRESSED_SRGB_EXT=_C('GL_COMPRESSED_SRGB_EXT',0x8C48) +GL_COMPRESSED_SRGB_S3TC_DXT1_EXT=_C('GL_COMPRESSED_SRGB_S3TC_DXT1_EXT',0x8C4C) +GL_SLUMINANCE8_ALPHA8_EXT=_C('GL_SLUMINANCE8_ALPHA8_EXT',0x8C45) +GL_SLUMINANCE8_EXT=_C('GL_SLUMINANCE8_EXT',0x8C47) +GL_SLUMINANCE_ALPHA_EXT=_C('GL_SLUMINANCE_ALPHA_EXT',0x8C44) +GL_SLUMINANCE_EXT=_C('GL_SLUMINANCE_EXT',0x8C46) +GL_SRGB8_ALPHA8_EXT=_C('GL_SRGB8_ALPHA8_EXT',0x8C43) +GL_SRGB8_EXT=_C('GL_SRGB8_EXT',0x8C41) +GL_SRGB_ALPHA_EXT=_C('GL_SRGB_ALPHA_EXT',0x8C42) +GL_SRGB_EXT=_C('GL_SRGB_EXT',0x8C40) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/texture_sRGB_R8.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/texture_sRGB_R8.py new file mode 100644 index 00000000..b8dc4e3b --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/texture_sRGB_R8.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_EXT_texture_sRGB_R8' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_EXT_texture_sRGB_R8',error_checker=_errors._error_checker) +GL_SR8_EXT=_C('GL_SR8_EXT',0x8FBD) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/texture_sRGB_decode.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/texture_sRGB_decode.py new file mode 100644 index 00000000..6a5ba5f3 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/texture_sRGB_decode.py @@ -0,0 +1,17 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_EXT_texture_sRGB_decode' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_EXT_texture_sRGB_decode',error_checker=_errors._error_checker) +GL_DECODE_EXT=_C('GL_DECODE_EXT',0x8A49) +GL_SKIP_DECODE_EXT=_C('GL_SKIP_DECODE_EXT',0x8A4A) +GL_TEXTURE_SRGB_DECODE_EXT=_C('GL_TEXTURE_SRGB_DECODE_EXT',0x8A48) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/texture_shadow_lod.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/texture_shadow_lod.py new file mode 100644 index 00000000..30b6d1ab --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/texture_shadow_lod.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_EXT_texture_shadow_lod' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_EXT_texture_shadow_lod',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/texture_shared_exponent.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/texture_shared_exponent.py new file mode 100644 index 00000000..89b4bd70 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/texture_shared_exponent.py @@ -0,0 +1,17 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_EXT_texture_shared_exponent' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_EXT_texture_shared_exponent',error_checker=_errors._error_checker) +GL_RGB9_E5_EXT=_C('GL_RGB9_E5_EXT',0x8C3D) +GL_TEXTURE_SHARED_SIZE_EXT=_C('GL_TEXTURE_SHARED_SIZE_EXT',0x8C3F) +GL_UNSIGNED_INT_5_9_9_9_REV_EXT=_C('GL_UNSIGNED_INT_5_9_9_9_REV_EXT',0x8C3E) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/texture_snorm.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/texture_snorm.py new file mode 100644 index 00000000..57c3609a --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/texture_snorm.py @@ -0,0 +1,39 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_EXT_texture_snorm' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_EXT_texture_snorm',error_checker=_errors._error_checker) +GL_ALPHA16_SNORM=_C('GL_ALPHA16_SNORM',0x9018) +GL_ALPHA8_SNORM=_C('GL_ALPHA8_SNORM',0x9014) +GL_ALPHA_SNORM=_C('GL_ALPHA_SNORM',0x9010) +GL_INTENSITY16_SNORM=_C('GL_INTENSITY16_SNORM',0x901B) +GL_INTENSITY8_SNORM=_C('GL_INTENSITY8_SNORM',0x9017) +GL_INTENSITY_SNORM=_C('GL_INTENSITY_SNORM',0x9013) +GL_LUMINANCE16_ALPHA16_SNORM=_C('GL_LUMINANCE16_ALPHA16_SNORM',0x901A) +GL_LUMINANCE16_SNORM=_C('GL_LUMINANCE16_SNORM',0x9019) +GL_LUMINANCE8_ALPHA8_SNORM=_C('GL_LUMINANCE8_ALPHA8_SNORM',0x9016) +GL_LUMINANCE8_SNORM=_C('GL_LUMINANCE8_SNORM',0x9015) +GL_LUMINANCE_ALPHA_SNORM=_C('GL_LUMINANCE_ALPHA_SNORM',0x9012) +GL_LUMINANCE_SNORM=_C('GL_LUMINANCE_SNORM',0x9011) +GL_R16_SNORM=_C('GL_R16_SNORM',0x8F98) +GL_R8_SNORM=_C('GL_R8_SNORM',0x8F94) +GL_RED_SNORM=_C('GL_RED_SNORM',0x8F90) +GL_RG16_SNORM=_C('GL_RG16_SNORM',0x8F99) +GL_RG8_SNORM=_C('GL_RG8_SNORM',0x8F95) +GL_RGB16_SNORM=_C('GL_RGB16_SNORM',0x8F9A) +GL_RGB8_SNORM=_C('GL_RGB8_SNORM',0x8F96) +GL_RGBA16_SNORM=_C('GL_RGBA16_SNORM',0x8F9B) +GL_RGBA8_SNORM=_C('GL_RGBA8_SNORM',0x8F97) +GL_RGBA_SNORM=_C('GL_RGBA_SNORM',0x8F93) +GL_RGB_SNORM=_C('GL_RGB_SNORM',0x8F92) +GL_RG_SNORM=_C('GL_RG_SNORM',0x8F91) +GL_SIGNED_NORMALIZED=_C('GL_SIGNED_NORMALIZED',0x8F9C) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/texture_swizzle.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/texture_swizzle.py new file mode 100644 index 00000000..a5fec05a --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/texture_swizzle.py @@ -0,0 +1,19 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_EXT_texture_swizzle' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_EXT_texture_swizzle',error_checker=_errors._error_checker) +GL_TEXTURE_SWIZZLE_A_EXT=_C('GL_TEXTURE_SWIZZLE_A_EXT',0x8E45) +GL_TEXTURE_SWIZZLE_B_EXT=_C('GL_TEXTURE_SWIZZLE_B_EXT',0x8E44) +GL_TEXTURE_SWIZZLE_G_EXT=_C('GL_TEXTURE_SWIZZLE_G_EXT',0x8E43) +GL_TEXTURE_SWIZZLE_RGBA_EXT=_C('GL_TEXTURE_SWIZZLE_RGBA_EXT',0x8E46) +GL_TEXTURE_SWIZZLE_R_EXT=_C('GL_TEXTURE_SWIZZLE_R_EXT',0x8E42) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/timer_query.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/timer_query.py new file mode 100644 index 00000000..aaede3dc --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/timer_query.py @@ -0,0 +1,20 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_EXT_timer_query' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_EXT_timer_query',error_checker=_errors._error_checker) +GL_TIME_ELAPSED_EXT=_C('GL_TIME_ELAPSED_EXT',0x88BF) +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLint64Array) +def glGetQueryObjecti64vEXT(id,pname,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLuint64Array) +def glGetQueryObjectui64vEXT(id,pname,params):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/transform_feedback.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/transform_feedback.py new file mode 100644 index 00000000..adef8762 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/transform_feedback.py @@ -0,0 +1,49 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_EXT_transform_feedback' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_EXT_transform_feedback',error_checker=_errors._error_checker) +GL_INTERLEAVED_ATTRIBS_EXT=_C('GL_INTERLEAVED_ATTRIBS_EXT',0x8C8C) +GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS_EXT=_C('GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS_EXT',0x8C8A) +GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS_EXT=_C('GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS_EXT',0x8C8B) +GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS_EXT=_C('GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS_EXT',0x8C80) +GL_PRIMITIVES_GENERATED_EXT=_C('GL_PRIMITIVES_GENERATED_EXT',0x8C87) +GL_RASTERIZER_DISCARD_EXT=_C('GL_RASTERIZER_DISCARD_EXT',0x8C89) +GL_SEPARATE_ATTRIBS_EXT=_C('GL_SEPARATE_ATTRIBS_EXT',0x8C8D) +GL_TRANSFORM_FEEDBACK_BUFFER_BINDING_EXT=_C('GL_TRANSFORM_FEEDBACK_BUFFER_BINDING_EXT',0x8C8F) +GL_TRANSFORM_FEEDBACK_BUFFER_EXT=_C('GL_TRANSFORM_FEEDBACK_BUFFER_EXT',0x8C8E) +GL_TRANSFORM_FEEDBACK_BUFFER_MODE_EXT=_C('GL_TRANSFORM_FEEDBACK_BUFFER_MODE_EXT',0x8C7F) +GL_TRANSFORM_FEEDBACK_BUFFER_SIZE_EXT=_C('GL_TRANSFORM_FEEDBACK_BUFFER_SIZE_EXT',0x8C85) +GL_TRANSFORM_FEEDBACK_BUFFER_START_EXT=_C('GL_TRANSFORM_FEEDBACK_BUFFER_START_EXT',0x8C84) +GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN_EXT=_C('GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN_EXT',0x8C88) +GL_TRANSFORM_FEEDBACK_VARYINGS_EXT=_C('GL_TRANSFORM_FEEDBACK_VARYINGS_EXT',0x8C83) +GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH_EXT=_C('GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH_EXT',0x8C76) +@_f +@_p.types(None,_cs.GLenum) +def glBeginTransformFeedbackEXT(primitiveMode):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,_cs.GLuint) +def glBindBufferBaseEXT(target,index,buffer):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,_cs.GLuint,_cs.GLintptr) +def glBindBufferOffsetEXT(target,index,buffer,offset):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,_cs.GLuint,_cs.GLintptr,_cs.GLsizeiptr) +def glBindBufferRangeEXT(target,index,buffer,offset,size):pass +@_f +@_p.types(None,) +def glEndTransformFeedbackEXT():pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLsizei,arrays.GLsizeiArray,arrays.GLsizeiArray,arrays.GLuintArray,arrays.GLcharArray) +def glGetTransformFeedbackVaryingEXT(program,index,bufSize,length,size,type,name):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizei,ctypes.POINTER( ctypes.POINTER( _cs.GLchar )),_cs.GLenum) +def glTransformFeedbackVaryingsEXT(program,count,varyings,bufferMode):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/vertex_array.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/vertex_array.py new file mode 100644 index 00000000..1864bf81 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/vertex_array.py @@ -0,0 +1,72 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_EXT_vertex_array' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_EXT_vertex_array',error_checker=_errors._error_checker) +GL_COLOR_ARRAY_COUNT_EXT=_C('GL_COLOR_ARRAY_COUNT_EXT',0x8084) +GL_COLOR_ARRAY_EXT=_C('GL_COLOR_ARRAY_EXT',0x8076) +GL_COLOR_ARRAY_POINTER_EXT=_C('GL_COLOR_ARRAY_POINTER_EXT',0x8090) +GL_COLOR_ARRAY_SIZE_EXT=_C('GL_COLOR_ARRAY_SIZE_EXT',0x8081) +GL_COLOR_ARRAY_STRIDE_EXT=_C('GL_COLOR_ARRAY_STRIDE_EXT',0x8083) +GL_COLOR_ARRAY_TYPE_EXT=_C('GL_COLOR_ARRAY_TYPE_EXT',0x8082) +GL_EDGE_FLAG_ARRAY_COUNT_EXT=_C('GL_EDGE_FLAG_ARRAY_COUNT_EXT',0x808D) +GL_EDGE_FLAG_ARRAY_EXT=_C('GL_EDGE_FLAG_ARRAY_EXT',0x8079) +GL_EDGE_FLAG_ARRAY_POINTER_EXT=_C('GL_EDGE_FLAG_ARRAY_POINTER_EXT',0x8093) +GL_EDGE_FLAG_ARRAY_STRIDE_EXT=_C('GL_EDGE_FLAG_ARRAY_STRIDE_EXT',0x808C) +GL_INDEX_ARRAY_COUNT_EXT=_C('GL_INDEX_ARRAY_COUNT_EXT',0x8087) +GL_INDEX_ARRAY_EXT=_C('GL_INDEX_ARRAY_EXT',0x8077) +GL_INDEX_ARRAY_POINTER_EXT=_C('GL_INDEX_ARRAY_POINTER_EXT',0x8091) +GL_INDEX_ARRAY_STRIDE_EXT=_C('GL_INDEX_ARRAY_STRIDE_EXT',0x8086) +GL_INDEX_ARRAY_TYPE_EXT=_C('GL_INDEX_ARRAY_TYPE_EXT',0x8085) +GL_NORMAL_ARRAY_COUNT_EXT=_C('GL_NORMAL_ARRAY_COUNT_EXT',0x8080) +GL_NORMAL_ARRAY_EXT=_C('GL_NORMAL_ARRAY_EXT',0x8075) +GL_NORMAL_ARRAY_POINTER_EXT=_C('GL_NORMAL_ARRAY_POINTER_EXT',0x808F) +GL_NORMAL_ARRAY_STRIDE_EXT=_C('GL_NORMAL_ARRAY_STRIDE_EXT',0x807F) +GL_NORMAL_ARRAY_TYPE_EXT=_C('GL_NORMAL_ARRAY_TYPE_EXT',0x807E) +GL_TEXTURE_COORD_ARRAY_COUNT_EXT=_C('GL_TEXTURE_COORD_ARRAY_COUNT_EXT',0x808B) +GL_TEXTURE_COORD_ARRAY_EXT=_C('GL_TEXTURE_COORD_ARRAY_EXT',0x8078) +GL_TEXTURE_COORD_ARRAY_POINTER_EXT=_C('GL_TEXTURE_COORD_ARRAY_POINTER_EXT',0x8092) +GL_TEXTURE_COORD_ARRAY_SIZE_EXT=_C('GL_TEXTURE_COORD_ARRAY_SIZE_EXT',0x8088) +GL_TEXTURE_COORD_ARRAY_STRIDE_EXT=_C('GL_TEXTURE_COORD_ARRAY_STRIDE_EXT',0x808A) +GL_TEXTURE_COORD_ARRAY_TYPE_EXT=_C('GL_TEXTURE_COORD_ARRAY_TYPE_EXT',0x8089) +GL_VERTEX_ARRAY_COUNT_EXT=_C('GL_VERTEX_ARRAY_COUNT_EXT',0x807D) +GL_VERTEX_ARRAY_EXT=_C('GL_VERTEX_ARRAY_EXT',0x8074) +GL_VERTEX_ARRAY_POINTER_EXT=_C('GL_VERTEX_ARRAY_POINTER_EXT',0x808E) +GL_VERTEX_ARRAY_SIZE_EXT=_C('GL_VERTEX_ARRAY_SIZE_EXT',0x807A) +GL_VERTEX_ARRAY_STRIDE_EXT=_C('GL_VERTEX_ARRAY_STRIDE_EXT',0x807C) +GL_VERTEX_ARRAY_TYPE_EXT=_C('GL_VERTEX_ARRAY_TYPE_EXT',0x807B) +@_f +@_p.types(None,_cs.GLint) +def glArrayElementEXT(i):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLenum,_cs.GLsizei,_cs.GLsizei,ctypes.c_void_p) +def glColorPointerEXT(size,type,stride,count,pointer):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLint,_cs.GLsizei) +def glDrawArraysEXT(mode,first,count):pass +@_f +@_p.types(None,_cs.GLsizei,_cs.GLsizei,arrays.GLbooleanArray) +def glEdgeFlagPointerEXT(stride,count,pointer):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLvoidpArray) +def glGetPointervEXT(pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizei,_cs.GLsizei,ctypes.c_void_p) +def glIndexPointerEXT(type,stride,count,pointer):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizei,_cs.GLsizei,ctypes.c_void_p) +def glNormalPointerEXT(type,stride,count,pointer):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLenum,_cs.GLsizei,_cs.GLsizei,ctypes.c_void_p) +def glTexCoordPointerEXT(size,type,stride,count,pointer):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLenum,_cs.GLsizei,_cs.GLsizei,ctypes.c_void_p) +def glVertexPointerEXT(size,type,stride,count,pointer):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/vertex_array_bgra.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/vertex_array_bgra.py new file mode 100644 index 00000000..ef986a1c --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/vertex_array_bgra.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_EXT_vertex_array_bgra' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_EXT_vertex_array_bgra',error_checker=_errors._error_checker) +GL_BGRA=_C('GL_BGRA',0x80E1) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/vertex_attrib_64bit.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/vertex_attrib_64bit.py new file mode 100644 index 00000000..812b7dc4 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/vertex_attrib_64bit.py @@ -0,0 +1,56 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_EXT_vertex_attrib_64bit' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_EXT_vertex_attrib_64bit',error_checker=_errors._error_checker) +GL_DOUBLE=_C('GL_DOUBLE',0x140A) +GL_DOUBLE_MAT2_EXT=_C('GL_DOUBLE_MAT2_EXT',0x8F46) +GL_DOUBLE_MAT2x3_EXT=_C('GL_DOUBLE_MAT2x3_EXT',0x8F49) +GL_DOUBLE_MAT2x4_EXT=_C('GL_DOUBLE_MAT2x4_EXT',0x8F4A) +GL_DOUBLE_MAT3_EXT=_C('GL_DOUBLE_MAT3_EXT',0x8F47) +GL_DOUBLE_MAT3x2_EXT=_C('GL_DOUBLE_MAT3x2_EXT',0x8F4B) +GL_DOUBLE_MAT3x4_EXT=_C('GL_DOUBLE_MAT3x4_EXT',0x8F4C) +GL_DOUBLE_MAT4_EXT=_C('GL_DOUBLE_MAT4_EXT',0x8F48) +GL_DOUBLE_MAT4x2_EXT=_C('GL_DOUBLE_MAT4x2_EXT',0x8F4D) +GL_DOUBLE_MAT4x3_EXT=_C('GL_DOUBLE_MAT4x3_EXT',0x8F4E) +GL_DOUBLE_VEC2_EXT=_C('GL_DOUBLE_VEC2_EXT',0x8FFC) +GL_DOUBLE_VEC3_EXT=_C('GL_DOUBLE_VEC3_EXT',0x8FFD) +GL_DOUBLE_VEC4_EXT=_C('GL_DOUBLE_VEC4_EXT',0x8FFE) +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLdoubleArray) +def glGetVertexAttribLdvEXT(index,pname,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLdouble) +def glVertexAttribL1dEXT(index,x):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLdoubleArray) +def glVertexAttribL1dvEXT(index,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLdouble,_cs.GLdouble) +def glVertexAttribL2dEXT(index,x,y):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLdoubleArray) +def glVertexAttribL2dvEXT(index,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLdouble,_cs.GLdouble,_cs.GLdouble) +def glVertexAttribL3dEXT(index,x,y,z):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLdoubleArray) +def glVertexAttribL3dvEXT(index,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLdouble,_cs.GLdouble,_cs.GLdouble,_cs.GLdouble) +def glVertexAttribL4dEXT(index,x,y,z,w):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLdoubleArray) +def glVertexAttribL4dvEXT(index,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLenum,_cs.GLsizei,ctypes.c_void_p) +def glVertexAttribLPointerEXT(index,size,type,stride,pointer):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/vertex_shader.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/vertex_shader.py new file mode 100644 index 00000000..6c1ebfe2 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/vertex_shader.py @@ -0,0 +1,249 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_EXT_vertex_shader' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_EXT_vertex_shader',error_checker=_errors._error_checker) +GL_CURRENT_VERTEX_EXT=_C('GL_CURRENT_VERTEX_EXT',0x87E2) +GL_FULL_RANGE_EXT=_C('GL_FULL_RANGE_EXT',0x87E1) +GL_INVARIANT_DATATYPE_EXT=_C('GL_INVARIANT_DATATYPE_EXT',0x87EB) +GL_INVARIANT_EXT=_C('GL_INVARIANT_EXT',0x87C2) +GL_INVARIANT_VALUE_EXT=_C('GL_INVARIANT_VALUE_EXT',0x87EA) +GL_LOCAL_CONSTANT_DATATYPE_EXT=_C('GL_LOCAL_CONSTANT_DATATYPE_EXT',0x87ED) +GL_LOCAL_CONSTANT_EXT=_C('GL_LOCAL_CONSTANT_EXT',0x87C3) +GL_LOCAL_CONSTANT_VALUE_EXT=_C('GL_LOCAL_CONSTANT_VALUE_EXT',0x87EC) +GL_LOCAL_EXT=_C('GL_LOCAL_EXT',0x87C4) +GL_MATRIX_EXT=_C('GL_MATRIX_EXT',0x87C0) +GL_MAX_OPTIMIZED_VERTEX_SHADER_INSTRUCTIONS_EXT=_C('GL_MAX_OPTIMIZED_VERTEX_SHADER_INSTRUCTIONS_EXT',0x87CA) +GL_MAX_OPTIMIZED_VERTEX_SHADER_INVARIANTS_EXT=_C('GL_MAX_OPTIMIZED_VERTEX_SHADER_INVARIANTS_EXT',0x87CD) +GL_MAX_OPTIMIZED_VERTEX_SHADER_LOCALS_EXT=_C('GL_MAX_OPTIMIZED_VERTEX_SHADER_LOCALS_EXT',0x87CE) +GL_MAX_OPTIMIZED_VERTEX_SHADER_LOCAL_CONSTANTS_EXT=_C('GL_MAX_OPTIMIZED_VERTEX_SHADER_LOCAL_CONSTANTS_EXT',0x87CC) +GL_MAX_OPTIMIZED_VERTEX_SHADER_VARIANTS_EXT=_C('GL_MAX_OPTIMIZED_VERTEX_SHADER_VARIANTS_EXT',0x87CB) +GL_MAX_VERTEX_SHADER_INSTRUCTIONS_EXT=_C('GL_MAX_VERTEX_SHADER_INSTRUCTIONS_EXT',0x87C5) +GL_MAX_VERTEX_SHADER_INVARIANTS_EXT=_C('GL_MAX_VERTEX_SHADER_INVARIANTS_EXT',0x87C7) +GL_MAX_VERTEX_SHADER_LOCALS_EXT=_C('GL_MAX_VERTEX_SHADER_LOCALS_EXT',0x87C9) +GL_MAX_VERTEX_SHADER_LOCAL_CONSTANTS_EXT=_C('GL_MAX_VERTEX_SHADER_LOCAL_CONSTANTS_EXT',0x87C8) +GL_MAX_VERTEX_SHADER_VARIANTS_EXT=_C('GL_MAX_VERTEX_SHADER_VARIANTS_EXT',0x87C6) +GL_MVP_MATRIX_EXT=_C('GL_MVP_MATRIX_EXT',0x87E3) +GL_NEGATIVE_ONE_EXT=_C('GL_NEGATIVE_ONE_EXT',0x87DF) +GL_NEGATIVE_W_EXT=_C('GL_NEGATIVE_W_EXT',0x87DC) +GL_NEGATIVE_X_EXT=_C('GL_NEGATIVE_X_EXT',0x87D9) +GL_NEGATIVE_Y_EXT=_C('GL_NEGATIVE_Y_EXT',0x87DA) +GL_NEGATIVE_Z_EXT=_C('GL_NEGATIVE_Z_EXT',0x87DB) +GL_NORMALIZED_RANGE_EXT=_C('GL_NORMALIZED_RANGE_EXT',0x87E0) +GL_ONE_EXT=_C('GL_ONE_EXT',0x87DE) +GL_OP_ADD_EXT=_C('GL_OP_ADD_EXT',0x8787) +GL_OP_CLAMP_EXT=_C('GL_OP_CLAMP_EXT',0x878E) +GL_OP_CROSS_PRODUCT_EXT=_C('GL_OP_CROSS_PRODUCT_EXT',0x8797) +GL_OP_DOT3_EXT=_C('GL_OP_DOT3_EXT',0x8784) +GL_OP_DOT4_EXT=_C('GL_OP_DOT4_EXT',0x8785) +GL_OP_EXP_BASE_2_EXT=_C('GL_OP_EXP_BASE_2_EXT',0x8791) +GL_OP_FLOOR_EXT=_C('GL_OP_FLOOR_EXT',0x878F) +GL_OP_FRAC_EXT=_C('GL_OP_FRAC_EXT',0x8789) +GL_OP_INDEX_EXT=_C('GL_OP_INDEX_EXT',0x8782) +GL_OP_LOG_BASE_2_EXT=_C('GL_OP_LOG_BASE_2_EXT',0x8792) +GL_OP_MADD_EXT=_C('GL_OP_MADD_EXT',0x8788) +GL_OP_MAX_EXT=_C('GL_OP_MAX_EXT',0x878A) +GL_OP_MIN_EXT=_C('GL_OP_MIN_EXT',0x878B) +GL_OP_MOV_EXT=_C('GL_OP_MOV_EXT',0x8799) +GL_OP_MULTIPLY_MATRIX_EXT=_C('GL_OP_MULTIPLY_MATRIX_EXT',0x8798) +GL_OP_MUL_EXT=_C('GL_OP_MUL_EXT',0x8786) +GL_OP_NEGATE_EXT=_C('GL_OP_NEGATE_EXT',0x8783) +GL_OP_POWER_EXT=_C('GL_OP_POWER_EXT',0x8793) +GL_OP_RECIP_EXT=_C('GL_OP_RECIP_EXT',0x8794) +GL_OP_RECIP_SQRT_EXT=_C('GL_OP_RECIP_SQRT_EXT',0x8795) +GL_OP_ROUND_EXT=_C('GL_OP_ROUND_EXT',0x8790) +GL_OP_SET_GE_EXT=_C('GL_OP_SET_GE_EXT',0x878C) +GL_OP_SET_LT_EXT=_C('GL_OP_SET_LT_EXT',0x878D) +GL_OP_SUB_EXT=_C('GL_OP_SUB_EXT',0x8796) +GL_OUTPUT_COLOR0_EXT=_C('GL_OUTPUT_COLOR0_EXT',0x879B) +GL_OUTPUT_COLOR1_EXT=_C('GL_OUTPUT_COLOR1_EXT',0x879C) +GL_OUTPUT_FOG_EXT=_C('GL_OUTPUT_FOG_EXT',0x87BD) +GL_OUTPUT_TEXTURE_COORD0_EXT=_C('GL_OUTPUT_TEXTURE_COORD0_EXT',0x879D) +GL_OUTPUT_TEXTURE_COORD10_EXT=_C('GL_OUTPUT_TEXTURE_COORD10_EXT',0x87A7) +GL_OUTPUT_TEXTURE_COORD11_EXT=_C('GL_OUTPUT_TEXTURE_COORD11_EXT',0x87A8) +GL_OUTPUT_TEXTURE_COORD12_EXT=_C('GL_OUTPUT_TEXTURE_COORD12_EXT',0x87A9) +GL_OUTPUT_TEXTURE_COORD13_EXT=_C('GL_OUTPUT_TEXTURE_COORD13_EXT',0x87AA) +GL_OUTPUT_TEXTURE_COORD14_EXT=_C('GL_OUTPUT_TEXTURE_COORD14_EXT',0x87AB) +GL_OUTPUT_TEXTURE_COORD15_EXT=_C('GL_OUTPUT_TEXTURE_COORD15_EXT',0x87AC) +GL_OUTPUT_TEXTURE_COORD16_EXT=_C('GL_OUTPUT_TEXTURE_COORD16_EXT',0x87AD) +GL_OUTPUT_TEXTURE_COORD17_EXT=_C('GL_OUTPUT_TEXTURE_COORD17_EXT',0x87AE) +GL_OUTPUT_TEXTURE_COORD18_EXT=_C('GL_OUTPUT_TEXTURE_COORD18_EXT',0x87AF) +GL_OUTPUT_TEXTURE_COORD19_EXT=_C('GL_OUTPUT_TEXTURE_COORD19_EXT',0x87B0) +GL_OUTPUT_TEXTURE_COORD1_EXT=_C('GL_OUTPUT_TEXTURE_COORD1_EXT',0x879E) +GL_OUTPUT_TEXTURE_COORD20_EXT=_C('GL_OUTPUT_TEXTURE_COORD20_EXT',0x87B1) +GL_OUTPUT_TEXTURE_COORD21_EXT=_C('GL_OUTPUT_TEXTURE_COORD21_EXT',0x87B2) +GL_OUTPUT_TEXTURE_COORD22_EXT=_C('GL_OUTPUT_TEXTURE_COORD22_EXT',0x87B3) +GL_OUTPUT_TEXTURE_COORD23_EXT=_C('GL_OUTPUT_TEXTURE_COORD23_EXT',0x87B4) +GL_OUTPUT_TEXTURE_COORD24_EXT=_C('GL_OUTPUT_TEXTURE_COORD24_EXT',0x87B5) +GL_OUTPUT_TEXTURE_COORD25_EXT=_C('GL_OUTPUT_TEXTURE_COORD25_EXT',0x87B6) +GL_OUTPUT_TEXTURE_COORD26_EXT=_C('GL_OUTPUT_TEXTURE_COORD26_EXT',0x87B7) +GL_OUTPUT_TEXTURE_COORD27_EXT=_C('GL_OUTPUT_TEXTURE_COORD27_EXT',0x87B8) +GL_OUTPUT_TEXTURE_COORD28_EXT=_C('GL_OUTPUT_TEXTURE_COORD28_EXT',0x87B9) +GL_OUTPUT_TEXTURE_COORD29_EXT=_C('GL_OUTPUT_TEXTURE_COORD29_EXT',0x87BA) +GL_OUTPUT_TEXTURE_COORD2_EXT=_C('GL_OUTPUT_TEXTURE_COORD2_EXT',0x879F) +GL_OUTPUT_TEXTURE_COORD30_EXT=_C('GL_OUTPUT_TEXTURE_COORD30_EXT',0x87BB) +GL_OUTPUT_TEXTURE_COORD31_EXT=_C('GL_OUTPUT_TEXTURE_COORD31_EXT',0x87BC) +GL_OUTPUT_TEXTURE_COORD3_EXT=_C('GL_OUTPUT_TEXTURE_COORD3_EXT',0x87A0) +GL_OUTPUT_TEXTURE_COORD4_EXT=_C('GL_OUTPUT_TEXTURE_COORD4_EXT',0x87A1) +GL_OUTPUT_TEXTURE_COORD5_EXT=_C('GL_OUTPUT_TEXTURE_COORD5_EXT',0x87A2) +GL_OUTPUT_TEXTURE_COORD6_EXT=_C('GL_OUTPUT_TEXTURE_COORD6_EXT',0x87A3) +GL_OUTPUT_TEXTURE_COORD7_EXT=_C('GL_OUTPUT_TEXTURE_COORD7_EXT',0x87A4) +GL_OUTPUT_TEXTURE_COORD8_EXT=_C('GL_OUTPUT_TEXTURE_COORD8_EXT',0x87A5) +GL_OUTPUT_TEXTURE_COORD9_EXT=_C('GL_OUTPUT_TEXTURE_COORD9_EXT',0x87A6) +GL_OUTPUT_VERTEX_EXT=_C('GL_OUTPUT_VERTEX_EXT',0x879A) +GL_SCALAR_EXT=_C('GL_SCALAR_EXT',0x87BE) +GL_VARIANT_ARRAY_EXT=_C('GL_VARIANT_ARRAY_EXT',0x87E8) +GL_VARIANT_ARRAY_POINTER_EXT=_C('GL_VARIANT_ARRAY_POINTER_EXT',0x87E9) +GL_VARIANT_ARRAY_STRIDE_EXT=_C('GL_VARIANT_ARRAY_STRIDE_EXT',0x87E6) +GL_VARIANT_ARRAY_TYPE_EXT=_C('GL_VARIANT_ARRAY_TYPE_EXT',0x87E7) +GL_VARIANT_DATATYPE_EXT=_C('GL_VARIANT_DATATYPE_EXT',0x87E5) +GL_VARIANT_EXT=_C('GL_VARIANT_EXT',0x87C1) +GL_VARIANT_VALUE_EXT=_C('GL_VARIANT_VALUE_EXT',0x87E4) +GL_VECTOR_EXT=_C('GL_VECTOR_EXT',0x87BF) +GL_VERTEX_SHADER_BINDING_EXT=_C('GL_VERTEX_SHADER_BINDING_EXT',0x8781) +GL_VERTEX_SHADER_EXT=_C('GL_VERTEX_SHADER_EXT',0x8780) +GL_VERTEX_SHADER_INSTRUCTIONS_EXT=_C('GL_VERTEX_SHADER_INSTRUCTIONS_EXT',0x87CF) +GL_VERTEX_SHADER_INVARIANTS_EXT=_C('GL_VERTEX_SHADER_INVARIANTS_EXT',0x87D1) +GL_VERTEX_SHADER_LOCALS_EXT=_C('GL_VERTEX_SHADER_LOCALS_EXT',0x87D3) +GL_VERTEX_SHADER_LOCAL_CONSTANTS_EXT=_C('GL_VERTEX_SHADER_LOCAL_CONSTANTS_EXT',0x87D2) +GL_VERTEX_SHADER_OPTIMIZED_EXT=_C('GL_VERTEX_SHADER_OPTIMIZED_EXT',0x87D4) +GL_VERTEX_SHADER_VARIANTS_EXT=_C('GL_VERTEX_SHADER_VARIANTS_EXT',0x87D0) +GL_W_EXT=_C('GL_W_EXT',0x87D8) +GL_X_EXT=_C('GL_X_EXT',0x87D5) +GL_Y_EXT=_C('GL_Y_EXT',0x87D6) +GL_ZERO_EXT=_C('GL_ZERO_EXT',0x87DD) +GL_Z_EXT=_C('GL_Z_EXT',0x87D7) +@_f +@_p.types(None,) +def glBeginVertexShaderEXT():pass +@_f +@_p.types(_cs.GLuint,_cs.GLenum,_cs.GLenum) +def glBindLightParameterEXT(light,value):pass +@_f +@_p.types(_cs.GLuint,_cs.GLenum,_cs.GLenum) +def glBindMaterialParameterEXT(face,value):pass +@_f +@_p.types(_cs.GLuint,_cs.GLenum) +def glBindParameterEXT(value):pass +@_f +@_p.types(_cs.GLuint,_cs.GLenum,_cs.GLenum,_cs.GLenum) +def glBindTexGenParameterEXT(unit,coord,value):pass +@_f +@_p.types(_cs.GLuint,_cs.GLenum,_cs.GLenum) +def glBindTextureUnitParameterEXT(unit,value):pass +@_f +@_p.types(None,_cs.GLuint) +def glBindVertexShaderEXT(id):pass +@_f +@_p.types(None,_cs.GLuint) +def glDeleteVertexShaderEXT(id):pass +@_f +@_p.types(None,_cs.GLuint) +def glDisableVariantClientStateEXT(id):pass +@_f +@_p.types(None,_cs.GLuint) +def glEnableVariantClientStateEXT(id):pass +@_f +@_p.types(None,) +def glEndVertexShaderEXT():pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLuint) +def glExtractComponentEXT(res,src,num):pass +@_f +@_p.types(_cs.GLuint,_cs.GLenum,_cs.GLenum,_cs.GLenum,_cs.GLuint) +def glGenSymbolsEXT(datatype,storagetype,range,components):pass +@_f +@_p.types(_cs.GLuint,_cs.GLuint) +def glGenVertexShadersEXT(range):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLbooleanArray) +def glGetInvariantBooleanvEXT(id,value,data):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLfloatArray) +def glGetInvariantFloatvEXT(id,value,data):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLintArray) +def glGetInvariantIntegervEXT(id,value,data):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLbooleanArray) +def glGetLocalConstantBooleanvEXT(id,value,data):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLfloatArray) +def glGetLocalConstantFloatvEXT(id,value,data):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLintArray) +def glGetLocalConstantIntegervEXT(id,value,data):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLbooleanArray) +def glGetVariantBooleanvEXT(id,value,data):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLfloatArray) +def glGetVariantFloatvEXT(id,value,data):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLintArray) +def glGetVariantIntegervEXT(id,value,data):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLvoidpArray) +def glGetVariantPointervEXT(id,value,data):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLuint) +def glInsertComponentEXT(res,src,num):pass +@_f +@_p.types(_cs.GLboolean,_cs.GLuint,_cs.GLenum) +def glIsVariantEnabledEXT(id,cap):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,ctypes.c_void_p) +def glSetInvariantEXT(id,type,addr):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,ctypes.c_void_p) +def glSetLocalConstantEXT(id,type,addr):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,_cs.GLuint) +def glShaderOp1EXT(op,res,arg1):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,_cs.GLuint,_cs.GLuint) +def glShaderOp2EXT(op,res,arg1,arg2):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,_cs.GLuint,_cs.GLuint,_cs.GLuint) +def glShaderOp3EXT(op,res,arg1,arg2,arg3):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLenum,_cs.GLenum,_cs.GLenum,_cs.GLenum) +def glSwizzleEXT(res,in_,outX,outY,outZ,outW):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLuint,ctypes.c_void_p) +def glVariantPointerEXT(id,type,stride,addr):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLbyteArray) +def glVariantbvEXT(id,addr):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLdoubleArray) +def glVariantdvEXT(id,addr):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLfloatArray) +def glVariantfvEXT(id,addr):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLintArray) +def glVariantivEXT(id,addr):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLshortArray) +def glVariantsvEXT(id,addr):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLubyteArray) +def glVariantubvEXT(id,addr):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLuintArray) +def glVariantuivEXT(id,addr):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLushortArray) +def glVariantusvEXT(id,addr):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLenum,_cs.GLenum,_cs.GLenum,_cs.GLenum) +def glWriteMaskEXT(res,in_,outX,outY,outZ,outW):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/vertex_weighting.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/vertex_weighting.py new file mode 100644 index 00000000..18ab487f --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/vertex_weighting.py @@ -0,0 +1,35 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_EXT_vertex_weighting' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_EXT_vertex_weighting',error_checker=_errors._error_checker) +GL_CURRENT_VERTEX_WEIGHT_EXT=_C('GL_CURRENT_VERTEX_WEIGHT_EXT',0x850B) +GL_MODELVIEW0_EXT=_C('GL_MODELVIEW0_EXT',0x1700) +GL_MODELVIEW0_MATRIX_EXT=_C('GL_MODELVIEW0_MATRIX_EXT',0x0BA6) +GL_MODELVIEW0_STACK_DEPTH_EXT=_C('GL_MODELVIEW0_STACK_DEPTH_EXT',0x0BA3) +GL_MODELVIEW1_EXT=_C('GL_MODELVIEW1_EXT',0x850A) +GL_MODELVIEW1_MATRIX_EXT=_C('GL_MODELVIEW1_MATRIX_EXT',0x8506) +GL_MODELVIEW1_STACK_DEPTH_EXT=_C('GL_MODELVIEW1_STACK_DEPTH_EXT',0x8502) +GL_VERTEX_WEIGHTING_EXT=_C('GL_VERTEX_WEIGHTING_EXT',0x8509) +GL_VERTEX_WEIGHT_ARRAY_EXT=_C('GL_VERTEX_WEIGHT_ARRAY_EXT',0x850C) +GL_VERTEX_WEIGHT_ARRAY_POINTER_EXT=_C('GL_VERTEX_WEIGHT_ARRAY_POINTER_EXT',0x8510) +GL_VERTEX_WEIGHT_ARRAY_SIZE_EXT=_C('GL_VERTEX_WEIGHT_ARRAY_SIZE_EXT',0x850D) +GL_VERTEX_WEIGHT_ARRAY_STRIDE_EXT=_C('GL_VERTEX_WEIGHT_ARRAY_STRIDE_EXT',0x850F) +GL_VERTEX_WEIGHT_ARRAY_TYPE_EXT=_C('GL_VERTEX_WEIGHT_ARRAY_TYPE_EXT',0x850E) +@_f +@_p.types(None,_cs.GLint,_cs.GLenum,_cs.GLsizei,ctypes.c_void_p) +def glVertexWeightPointerEXT(size,type,stride,pointer):pass +@_f +@_p.types(None,_cs.GLfloat) +def glVertexWeightfEXT(weight):pass +@_f +@_p.types(None,arrays.GLfloatArray) +def glVertexWeightfvEXT(weight):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/win32_keyed_mutex.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/win32_keyed_mutex.py new file mode 100644 index 00000000..0c8845d1 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/win32_keyed_mutex.py @@ -0,0 +1,20 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_EXT_win32_keyed_mutex' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_EXT_win32_keyed_mutex',error_checker=_errors._error_checker) + +@_f +@_p.types(_cs.GLboolean,_cs.GLuint,_cs.GLuint64,_cs.GLuint) +def glAcquireKeyedMutexWin32EXT(memory,key,timeout):pass +@_f +@_p.types(_cs.GLboolean,_cs.GLuint,_cs.GLuint64) +def glReleaseKeyedMutexWin32EXT(memory,key):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/window_rectangles.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/window_rectangles.py new file mode 100644 index 00000000..c4265c14 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/window_rectangles.py @@ -0,0 +1,22 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_EXT_window_rectangles' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_EXT_window_rectangles',error_checker=_errors._error_checker) +GL_EXCLUSIVE_EXT=_C('GL_EXCLUSIVE_EXT',0x8F11) +GL_INCLUSIVE_EXT=_C('GL_INCLUSIVE_EXT',0x8F10) +GL_MAX_WINDOW_RECTANGLES_EXT=_C('GL_MAX_WINDOW_RECTANGLES_EXT',0x8F14) +GL_NUM_WINDOW_RECTANGLES_EXT=_C('GL_NUM_WINDOW_RECTANGLES_EXT',0x8F15) +GL_WINDOW_RECTANGLE_EXT=_C('GL_WINDOW_RECTANGLE_EXT',0x8F12) +GL_WINDOW_RECTANGLE_MODE_EXT=_C('GL_WINDOW_RECTANGLE_MODE_EXT',0x8F13) +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizei,arrays.GLintArray) +def glWindowRectanglesEXT(mode,count,box):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/x11_sync_object.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/x11_sync_object.py new file mode 100644 index 00000000..00be1c77 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/EXT/x11_sync_object.py @@ -0,0 +1,17 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_EXT_x11_sync_object' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_EXT_x11_sync_object',error_checker=_errors._error_checker) +GL_SYNC_X11_FENCE_EXT=_C('GL_SYNC_X11_FENCE_EXT',0x90E1) +@_f +@_p.types(_cs.GLsync,_cs.GLenum,_cs.GLintptr,_cs.GLbitfield) +def glImportSyncEXT(external_sync_type,external_sync,flags):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/FJ/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/FJ/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/FJ/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/FJ/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/FJ/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..1d4427f9 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/FJ/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/GREMEDY/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/GREMEDY/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/GREMEDY/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/GREMEDY/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/GREMEDY/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..2450cd41 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/GREMEDY/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/GREMEDY/__pycache__/frame_terminator.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/GREMEDY/__pycache__/frame_terminator.cpython-312.pyc new file mode 100644 index 00000000..5536011c Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/GREMEDY/__pycache__/frame_terminator.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/GREMEDY/__pycache__/string_marker.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/GREMEDY/__pycache__/string_marker.cpython-312.pyc new file mode 100644 index 00000000..a4d2de58 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/GREMEDY/__pycache__/string_marker.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/GREMEDY/frame_terminator.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/GREMEDY/frame_terminator.py new file mode 100644 index 00000000..e19231c2 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/GREMEDY/frame_terminator.py @@ -0,0 +1,17 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_GREMEDY_frame_terminator' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_GREMEDY_frame_terminator',error_checker=_errors._error_checker) + +@_f +@_p.types(None,) +def glFrameTerminatorGREMEDY():pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/GREMEDY/string_marker.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/GREMEDY/string_marker.py new file mode 100644 index 00000000..e4a53191 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/GREMEDY/string_marker.py @@ -0,0 +1,17 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_GREMEDY_string_marker' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_GREMEDY_string_marker',error_checker=_errors._error_checker) + +@_f +@_p.types(None,_cs.GLsizei,ctypes.c_void_p) +def glStringMarkerGREMEDY(len,string):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/HP/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/HP/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/HP/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/HP/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/HP/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..02365a7e Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/HP/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/HP/__pycache__/convolution_border_modes.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/HP/__pycache__/convolution_border_modes.cpython-312.pyc new file mode 100644 index 00000000..22170193 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/HP/__pycache__/convolution_border_modes.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/HP/__pycache__/image_transform.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/HP/__pycache__/image_transform.cpython-312.pyc new file mode 100644 index 00000000..76cc9964 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/HP/__pycache__/image_transform.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/HP/__pycache__/occlusion_test.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/HP/__pycache__/occlusion_test.cpython-312.pyc new file mode 100644 index 00000000..e9553a92 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/HP/__pycache__/occlusion_test.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/HP/__pycache__/texture_lighting.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/HP/__pycache__/texture_lighting.cpython-312.pyc new file mode 100644 index 00000000..6bdb97ff Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/HP/__pycache__/texture_lighting.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/HP/convolution_border_modes.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/HP/convolution_border_modes.py new file mode 100644 index 00000000..4bea4c6e --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/HP/convolution_border_modes.py @@ -0,0 +1,18 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_HP_convolution_border_modes' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_HP_convolution_border_modes',error_checker=_errors._error_checker) +GL_CONSTANT_BORDER_HP=_C('GL_CONSTANT_BORDER_HP',0x8151) +GL_CONVOLUTION_BORDER_COLOR_HP=_C('GL_CONVOLUTION_BORDER_COLOR_HP',0x8154) +GL_IGNORE_BORDER_HP=_C('GL_IGNORE_BORDER_HP',0x8150) +GL_REPLICATE_BORDER_HP=_C('GL_REPLICATE_BORDER_HP',0x8153) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/HP/image_transform.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/HP/image_transform.py new file mode 100644 index 00000000..10993cff --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/HP/image_transform.py @@ -0,0 +1,46 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_HP_image_transform' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_HP_image_transform',error_checker=_errors._error_checker) +GL_AVERAGE_HP=_C('GL_AVERAGE_HP',0x8160) +GL_CUBIC_HP=_C('GL_CUBIC_HP',0x815F) +GL_IMAGE_CUBIC_WEIGHT_HP=_C('GL_IMAGE_CUBIC_WEIGHT_HP',0x815E) +GL_IMAGE_MAG_FILTER_HP=_C('GL_IMAGE_MAG_FILTER_HP',0x815C) +GL_IMAGE_MIN_FILTER_HP=_C('GL_IMAGE_MIN_FILTER_HP',0x815D) +GL_IMAGE_ROTATE_ANGLE_HP=_C('GL_IMAGE_ROTATE_ANGLE_HP',0x8159) +GL_IMAGE_ROTATE_ORIGIN_X_HP=_C('GL_IMAGE_ROTATE_ORIGIN_X_HP',0x815A) +GL_IMAGE_ROTATE_ORIGIN_Y_HP=_C('GL_IMAGE_ROTATE_ORIGIN_Y_HP',0x815B) +GL_IMAGE_SCALE_X_HP=_C('GL_IMAGE_SCALE_X_HP',0x8155) +GL_IMAGE_SCALE_Y_HP=_C('GL_IMAGE_SCALE_Y_HP',0x8156) +GL_IMAGE_TRANSFORM_2D_HP=_C('GL_IMAGE_TRANSFORM_2D_HP',0x8161) +GL_IMAGE_TRANSLATE_X_HP=_C('GL_IMAGE_TRANSLATE_X_HP',0x8157) +GL_IMAGE_TRANSLATE_Y_HP=_C('GL_IMAGE_TRANSLATE_Y_HP',0x8158) +GL_POST_IMAGE_TRANSFORM_COLOR_TABLE_HP=_C('GL_POST_IMAGE_TRANSFORM_COLOR_TABLE_HP',0x8162) +GL_PROXY_POST_IMAGE_TRANSFORM_COLOR_TABLE_HP=_C('GL_PROXY_POST_IMAGE_TRANSFORM_COLOR_TABLE_HP',0x8163) +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLfloatArray) +def glGetImageTransformParameterfvHP(target,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLintArray) +def glGetImageTransformParameterivHP(target,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLfloat) +def glImageTransformParameterfHP(target,pname,param):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLfloatArray) +def glImageTransformParameterfvHP(target,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLint) +def glImageTransformParameteriHP(target,pname,param):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLintArray) +def glImageTransformParameterivHP(target,pname,params):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/HP/occlusion_test.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/HP/occlusion_test.py new file mode 100644 index 00000000..682ac9d3 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/HP/occlusion_test.py @@ -0,0 +1,16 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_HP_occlusion_test' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_HP_occlusion_test',error_checker=_errors._error_checker) +GL_OCCLUSION_TEST_HP=_C('GL_OCCLUSION_TEST_HP',0x8165) +GL_OCCLUSION_TEST_RESULT_HP=_C('GL_OCCLUSION_TEST_RESULT_HP',0x8166) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/HP/texture_lighting.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/HP/texture_lighting.py new file mode 100644 index 00000000..603cd0af --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/HP/texture_lighting.py @@ -0,0 +1,17 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_HP_texture_lighting' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_HP_texture_lighting',error_checker=_errors._error_checker) +GL_TEXTURE_LIGHTING_MODE_HP=_C('GL_TEXTURE_LIGHTING_MODE_HP',0x8167) +GL_TEXTURE_POST_SPECULAR_HP=_C('GL_TEXTURE_POST_SPECULAR_HP',0x8168) +GL_TEXTURE_PRE_SPECULAR_HP=_C('GL_TEXTURE_PRE_SPECULAR_HP',0x8169) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/IBM/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/IBM/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/IBM/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/IBM/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/IBM/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..ceaeab98 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/IBM/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/IBM/__pycache__/cull_vertex.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/IBM/__pycache__/cull_vertex.cpython-312.pyc new file mode 100644 index 00000000..bfa9eecd Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/IBM/__pycache__/cull_vertex.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/IBM/__pycache__/multimode_draw_arrays.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/IBM/__pycache__/multimode_draw_arrays.cpython-312.pyc new file mode 100644 index 00000000..eaff7316 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/IBM/__pycache__/multimode_draw_arrays.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/IBM/__pycache__/rasterpos_clip.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/IBM/__pycache__/rasterpos_clip.cpython-312.pyc new file mode 100644 index 00000000..f2cc6ecf Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/IBM/__pycache__/rasterpos_clip.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/IBM/__pycache__/static_data.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/IBM/__pycache__/static_data.cpython-312.pyc new file mode 100644 index 00000000..bdd4f059 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/IBM/__pycache__/static_data.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/IBM/__pycache__/texture_mirrored_repeat.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/IBM/__pycache__/texture_mirrored_repeat.cpython-312.pyc new file mode 100644 index 00000000..fbbe353c Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/IBM/__pycache__/texture_mirrored_repeat.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/IBM/__pycache__/vertex_array_lists.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/IBM/__pycache__/vertex_array_lists.cpython-312.pyc new file mode 100644 index 00000000..cc086d3f Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/IBM/__pycache__/vertex_array_lists.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/IBM/cull_vertex.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/IBM/cull_vertex.py new file mode 100644 index 00000000..2c92f9ab --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/IBM/cull_vertex.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_IBM_cull_vertex' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_IBM_cull_vertex',error_checker=_errors._error_checker) +GL_CULL_VERTEX_IBM=_C('GL_CULL_VERTEX_IBM',103050) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/IBM/multimode_draw_arrays.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/IBM/multimode_draw_arrays.py new file mode 100644 index 00000000..570bb3ff --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/IBM/multimode_draw_arrays.py @@ -0,0 +1,20 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_IBM_multimode_draw_arrays' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_IBM_multimode_draw_arrays',error_checker=_errors._error_checker) + +@_f +@_p.types(None,arrays.GLuintArray,arrays.GLintArray,arrays.GLsizeiArray,_cs.GLsizei,_cs.GLint) +def glMultiModeDrawArraysIBM(mode,first,count,primcount,modestride):pass +@_f +@_p.types(None,arrays.GLuintArray,arrays.GLsizeiArray,_cs.GLenum,arrays.GLvoidpArray,_cs.GLsizei,_cs.GLint) +def glMultiModeDrawElementsIBM(mode,count,type,indices,primcount,modestride):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/IBM/rasterpos_clip.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/IBM/rasterpos_clip.py new file mode 100644 index 00000000..520bcc49 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/IBM/rasterpos_clip.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_IBM_rasterpos_clip' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_IBM_rasterpos_clip',error_checker=_errors._error_checker) +GL_RASTER_POSITION_UNCLIPPED_IBM=_C('GL_RASTER_POSITION_UNCLIPPED_IBM',0x19262) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/IBM/static_data.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/IBM/static_data.py new file mode 100644 index 00000000..d7162d34 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/IBM/static_data.py @@ -0,0 +1,18 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_IBM_static_data' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_IBM_static_data',error_checker=_errors._error_checker) +GL_ALL_STATIC_DATA_IBM=_C('GL_ALL_STATIC_DATA_IBM',103060) +GL_STATIC_VERTEX_ARRAY_IBM=_C('GL_STATIC_VERTEX_ARRAY_IBM',103061) +@_f +@_p.types(None,_cs.GLenum) +def glFlushStaticDataIBM(target):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/IBM/texture_mirrored_repeat.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/IBM/texture_mirrored_repeat.py new file mode 100644 index 00000000..01370660 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/IBM/texture_mirrored_repeat.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_IBM_texture_mirrored_repeat' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_IBM_texture_mirrored_repeat',error_checker=_errors._error_checker) +GL_MIRRORED_REPEAT_IBM=_C('GL_MIRRORED_REPEAT_IBM',0x8370) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/IBM/vertex_array_lists.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/IBM/vertex_array_lists.py new file mode 100644 index 00000000..53d5e35e --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/IBM/vertex_array_lists.py @@ -0,0 +1,53 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_IBM_vertex_array_lists' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_IBM_vertex_array_lists',error_checker=_errors._error_checker) +GL_COLOR_ARRAY_LIST_IBM=_C('GL_COLOR_ARRAY_LIST_IBM',103072) +GL_COLOR_ARRAY_LIST_STRIDE_IBM=_C('GL_COLOR_ARRAY_LIST_STRIDE_IBM',103082) +GL_EDGE_FLAG_ARRAY_LIST_IBM=_C('GL_EDGE_FLAG_ARRAY_LIST_IBM',103075) +GL_EDGE_FLAG_ARRAY_LIST_STRIDE_IBM=_C('GL_EDGE_FLAG_ARRAY_LIST_STRIDE_IBM',103085) +GL_FOG_COORDINATE_ARRAY_LIST_IBM=_C('GL_FOG_COORDINATE_ARRAY_LIST_IBM',103076) +GL_FOG_COORDINATE_ARRAY_LIST_STRIDE_IBM=_C('GL_FOG_COORDINATE_ARRAY_LIST_STRIDE_IBM',103086) +GL_INDEX_ARRAY_LIST_IBM=_C('GL_INDEX_ARRAY_LIST_IBM',103073) +GL_INDEX_ARRAY_LIST_STRIDE_IBM=_C('GL_INDEX_ARRAY_LIST_STRIDE_IBM',103083) +GL_NORMAL_ARRAY_LIST_IBM=_C('GL_NORMAL_ARRAY_LIST_IBM',103071) +GL_NORMAL_ARRAY_LIST_STRIDE_IBM=_C('GL_NORMAL_ARRAY_LIST_STRIDE_IBM',103081) +GL_SECONDARY_COLOR_ARRAY_LIST_IBM=_C('GL_SECONDARY_COLOR_ARRAY_LIST_IBM',103077) +GL_SECONDARY_COLOR_ARRAY_LIST_STRIDE_IBM=_C('GL_SECONDARY_COLOR_ARRAY_LIST_STRIDE_IBM',103087) +GL_TEXTURE_COORD_ARRAY_LIST_IBM=_C('GL_TEXTURE_COORD_ARRAY_LIST_IBM',103074) +GL_TEXTURE_COORD_ARRAY_LIST_STRIDE_IBM=_C('GL_TEXTURE_COORD_ARRAY_LIST_STRIDE_IBM',103084) +GL_VERTEX_ARRAY_LIST_IBM=_C('GL_VERTEX_ARRAY_LIST_IBM',103070) +GL_VERTEX_ARRAY_LIST_STRIDE_IBM=_C('GL_VERTEX_ARRAY_LIST_STRIDE_IBM',103080) +@_f +@_p.types(None,_cs.GLint,_cs.GLenum,_cs.GLint,arrays.GLvoidpArray,_cs.GLint) +def glColorPointerListIBM(size,type,stride,pointer,ptrstride):pass +@_f +@_p.types(None,_cs.GLint,arrays.GLbooleanArray,_cs.GLint) +def glEdgeFlagPointerListIBM(stride,pointer,ptrstride):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLint,arrays.GLvoidpArray,_cs.GLint) +def glFogCoordPointerListIBM(type,stride,pointer,ptrstride):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLint,arrays.GLvoidpArray,_cs.GLint) +def glIndexPointerListIBM(type,stride,pointer,ptrstride):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLint,arrays.GLvoidpArray,_cs.GLint) +def glNormalPointerListIBM(type,stride,pointer,ptrstride):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLenum,_cs.GLint,arrays.GLvoidpArray,_cs.GLint) +def glSecondaryColorPointerListIBM(size,type,stride,pointer,ptrstride):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLenum,_cs.GLint,arrays.GLvoidpArray,_cs.GLint) +def glTexCoordPointerListIBM(size,type,stride,pointer,ptrstride):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLenum,_cs.GLint,arrays.GLvoidpArray,_cs.GLint) +def glVertexPointerListIBM(size,type,stride,pointer,ptrstride):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/IMG/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/IMG/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/IMG/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/IMG/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/IMG/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..04104f60 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/IMG/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/INGR/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/INGR/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/INGR/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/INGR/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/INGR/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..76e88c85 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/INGR/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/INGR/__pycache__/blend_func_separate.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/INGR/__pycache__/blend_func_separate.cpython-312.pyc new file mode 100644 index 00000000..355a54cd Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/INGR/__pycache__/blend_func_separate.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/INGR/__pycache__/color_clamp.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/INGR/__pycache__/color_clamp.cpython-312.pyc new file mode 100644 index 00000000..55cadc6b Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/INGR/__pycache__/color_clamp.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/INGR/__pycache__/interlace_read.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/INGR/__pycache__/interlace_read.cpython-312.pyc new file mode 100644 index 00000000..68fa0d83 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/INGR/__pycache__/interlace_read.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/INGR/blend_func_separate.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/INGR/blend_func_separate.py new file mode 100644 index 00000000..db537ee9 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/INGR/blend_func_separate.py @@ -0,0 +1,17 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_INGR_blend_func_separate' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_INGR_blend_func_separate',error_checker=_errors._error_checker) + +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLenum,_cs.GLenum) +def glBlendFuncSeparateINGR(sfactorRGB,dfactorRGB,sfactorAlpha,dfactorAlpha):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/INGR/color_clamp.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/INGR/color_clamp.py new file mode 100644 index 00000000..9acc6759 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/INGR/color_clamp.py @@ -0,0 +1,22 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_INGR_color_clamp' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_INGR_color_clamp',error_checker=_errors._error_checker) +GL_ALPHA_MAX_CLAMP_INGR=_C('GL_ALPHA_MAX_CLAMP_INGR',0x8567) +GL_ALPHA_MIN_CLAMP_INGR=_C('GL_ALPHA_MIN_CLAMP_INGR',0x8563) +GL_BLUE_MAX_CLAMP_INGR=_C('GL_BLUE_MAX_CLAMP_INGR',0x8566) +GL_BLUE_MIN_CLAMP_INGR=_C('GL_BLUE_MIN_CLAMP_INGR',0x8562) +GL_GREEN_MAX_CLAMP_INGR=_C('GL_GREEN_MAX_CLAMP_INGR',0x8565) +GL_GREEN_MIN_CLAMP_INGR=_C('GL_GREEN_MIN_CLAMP_INGR',0x8561) +GL_RED_MAX_CLAMP_INGR=_C('GL_RED_MAX_CLAMP_INGR',0x8564) +GL_RED_MIN_CLAMP_INGR=_C('GL_RED_MIN_CLAMP_INGR',0x8560) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/INGR/interlace_read.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/INGR/interlace_read.py new file mode 100644 index 00000000..d346fc92 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/INGR/interlace_read.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_INGR_interlace_read' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_INGR_interlace_read',error_checker=_errors._error_checker) +GL_INTERLACE_READ_INGR=_C('GL_INTERLACE_READ_INGR',0x8568) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/INTEL/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/INTEL/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/INTEL/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/INTEL/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/INTEL/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..45af2865 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/INTEL/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/INTEL/__pycache__/blackhole_render.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/INTEL/__pycache__/blackhole_render.cpython-312.pyc new file mode 100644 index 00000000..7ce383ca Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/INTEL/__pycache__/blackhole_render.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/INTEL/__pycache__/conservative_rasterization.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/INTEL/__pycache__/conservative_rasterization.cpython-312.pyc new file mode 100644 index 00000000..7a0d9edc Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/INTEL/__pycache__/conservative_rasterization.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/INTEL/__pycache__/fragment_shader_ordering.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/INTEL/__pycache__/fragment_shader_ordering.cpython-312.pyc new file mode 100644 index 00000000..430503a3 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/INTEL/__pycache__/fragment_shader_ordering.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/INTEL/__pycache__/framebuffer_CMAA.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/INTEL/__pycache__/framebuffer_CMAA.cpython-312.pyc new file mode 100644 index 00000000..eb107fe5 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/INTEL/__pycache__/framebuffer_CMAA.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/INTEL/__pycache__/map_texture.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/INTEL/__pycache__/map_texture.cpython-312.pyc new file mode 100644 index 00000000..3536d201 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/INTEL/__pycache__/map_texture.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/INTEL/__pycache__/parallel_arrays.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/INTEL/__pycache__/parallel_arrays.cpython-312.pyc new file mode 100644 index 00000000..ff4ccd04 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/INTEL/__pycache__/parallel_arrays.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/INTEL/__pycache__/performance_query.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/INTEL/__pycache__/performance_query.cpython-312.pyc new file mode 100644 index 00000000..7cecf4e0 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/INTEL/__pycache__/performance_query.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/INTEL/blackhole_render.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/INTEL/blackhole_render.py new file mode 100644 index 00000000..4635e1ba --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/INTEL/blackhole_render.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_INTEL_blackhole_render' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_INTEL_blackhole_render',error_checker=_errors._error_checker) +GL_BLACKHOLE_RENDER_INTEL=_C('GL_BLACKHOLE_RENDER_INTEL',0x83FC) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/INTEL/conservative_rasterization.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/INTEL/conservative_rasterization.py new file mode 100644 index 00000000..c8105674 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/INTEL/conservative_rasterization.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_INTEL_conservative_rasterization' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_INTEL_conservative_rasterization',error_checker=_errors._error_checker) +GL_CONSERVATIVE_RASTERIZATION_INTEL=_C('GL_CONSERVATIVE_RASTERIZATION_INTEL',0x83FE) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/INTEL/fragment_shader_ordering.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/INTEL/fragment_shader_ordering.py new file mode 100644 index 00000000..930c9f73 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/INTEL/fragment_shader_ordering.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_INTEL_fragment_shader_ordering' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_INTEL_fragment_shader_ordering',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/INTEL/framebuffer_CMAA.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/INTEL/framebuffer_CMAA.py new file mode 100644 index 00000000..b20adfa7 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/INTEL/framebuffer_CMAA.py @@ -0,0 +1,17 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_INTEL_framebuffer_CMAA' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_INTEL_framebuffer_CMAA',error_checker=_errors._error_checker) + +@_f +@_p.types(None,) +def glApplyFramebufferAttachmentCMAAINTEL():pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/INTEL/map_texture.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/INTEL/map_texture.py new file mode 100644 index 00000000..8b12ba2a --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/INTEL/map_texture.py @@ -0,0 +1,26 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_INTEL_map_texture' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_INTEL_map_texture',error_checker=_errors._error_checker) +GL_LAYOUT_DEFAULT_INTEL=_C('GL_LAYOUT_DEFAULT_INTEL',0) +GL_LAYOUT_LINEAR_CPU_CACHED_INTEL=_C('GL_LAYOUT_LINEAR_CPU_CACHED_INTEL',2) +GL_LAYOUT_LINEAR_INTEL=_C('GL_LAYOUT_LINEAR_INTEL',1) +GL_TEXTURE_MEMORY_LAYOUT_INTEL=_C('GL_TEXTURE_MEMORY_LAYOUT_INTEL',0x83FF) +@_f +@_p.types(ctypes.c_void_p,_cs.GLuint,_cs.GLint,_cs.GLbitfield,arrays.GLintArray,arrays.GLuintArray) +def glMapTexture2DINTEL(texture,level,access,stride,layout):pass +@_f +@_p.types(None,_cs.GLuint) +def glSyncTextureINTEL(texture):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint) +def glUnmapTexture2DINTEL(texture,level):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/INTEL/parallel_arrays.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/INTEL/parallel_arrays.py new file mode 100644 index 00000000..127246f3 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/INTEL/parallel_arrays.py @@ -0,0 +1,30 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_INTEL_parallel_arrays' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_INTEL_parallel_arrays',error_checker=_errors._error_checker) +GL_COLOR_ARRAY_PARALLEL_POINTERS_INTEL=_C('GL_COLOR_ARRAY_PARALLEL_POINTERS_INTEL',0x83F7) +GL_NORMAL_ARRAY_PARALLEL_POINTERS_INTEL=_C('GL_NORMAL_ARRAY_PARALLEL_POINTERS_INTEL',0x83F6) +GL_PARALLEL_ARRAYS_INTEL=_C('GL_PARALLEL_ARRAYS_INTEL',0x83F4) +GL_TEXTURE_COORD_ARRAY_PARALLEL_POINTERS_INTEL=_C('GL_TEXTURE_COORD_ARRAY_PARALLEL_POINTERS_INTEL',0x83F8) +GL_VERTEX_ARRAY_PARALLEL_POINTERS_INTEL=_C('GL_VERTEX_ARRAY_PARALLEL_POINTERS_INTEL',0x83F5) +@_f +@_p.types(None,_cs.GLint,_cs.GLenum,arrays.GLvoidpArray) +def glColorPointervINTEL(size,type,pointer):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLvoidpArray) +def glNormalPointervINTEL(type,pointer):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLenum,arrays.GLvoidpArray) +def glTexCoordPointervINTEL(size,type,pointer):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLenum,arrays.GLvoidpArray) +def glVertexPointervINTEL(size,type,pointer):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/INTEL/performance_query.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/INTEL/performance_query.py new file mode 100644 index 00000000..f36a801f --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/INTEL/performance_query.py @@ -0,0 +1,63 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_INTEL_performance_query' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_INTEL_performance_query',error_checker=_errors._error_checker) +GL_PERFQUERY_COUNTER_DATA_BOOL32_INTEL=_C('GL_PERFQUERY_COUNTER_DATA_BOOL32_INTEL',0x94FC) +GL_PERFQUERY_COUNTER_DATA_DOUBLE_INTEL=_C('GL_PERFQUERY_COUNTER_DATA_DOUBLE_INTEL',0x94FB) +GL_PERFQUERY_COUNTER_DATA_FLOAT_INTEL=_C('GL_PERFQUERY_COUNTER_DATA_FLOAT_INTEL',0x94FA) +GL_PERFQUERY_COUNTER_DATA_UINT32_INTEL=_C('GL_PERFQUERY_COUNTER_DATA_UINT32_INTEL',0x94F8) +GL_PERFQUERY_COUNTER_DATA_UINT64_INTEL=_C('GL_PERFQUERY_COUNTER_DATA_UINT64_INTEL',0x94F9) +GL_PERFQUERY_COUNTER_DESC_LENGTH_MAX_INTEL=_C('GL_PERFQUERY_COUNTER_DESC_LENGTH_MAX_INTEL',0x94FF) +GL_PERFQUERY_COUNTER_DURATION_NORM_INTEL=_C('GL_PERFQUERY_COUNTER_DURATION_NORM_INTEL',0x94F1) +GL_PERFQUERY_COUNTER_DURATION_RAW_INTEL=_C('GL_PERFQUERY_COUNTER_DURATION_RAW_INTEL',0x94F2) +GL_PERFQUERY_COUNTER_EVENT_INTEL=_C('GL_PERFQUERY_COUNTER_EVENT_INTEL',0x94F0) +GL_PERFQUERY_COUNTER_NAME_LENGTH_MAX_INTEL=_C('GL_PERFQUERY_COUNTER_NAME_LENGTH_MAX_INTEL',0x94FE) +GL_PERFQUERY_COUNTER_RAW_INTEL=_C('GL_PERFQUERY_COUNTER_RAW_INTEL',0x94F4) +GL_PERFQUERY_COUNTER_THROUGHPUT_INTEL=_C('GL_PERFQUERY_COUNTER_THROUGHPUT_INTEL',0x94F3) +GL_PERFQUERY_COUNTER_TIMESTAMP_INTEL=_C('GL_PERFQUERY_COUNTER_TIMESTAMP_INTEL',0x94F5) +GL_PERFQUERY_DONOT_FLUSH_INTEL=_C('GL_PERFQUERY_DONOT_FLUSH_INTEL',0x83F9) +GL_PERFQUERY_FLUSH_INTEL=_C('GL_PERFQUERY_FLUSH_INTEL',0x83FA) +GL_PERFQUERY_GLOBAL_CONTEXT_INTEL=_C('GL_PERFQUERY_GLOBAL_CONTEXT_INTEL',0x00000001) +GL_PERFQUERY_GPA_EXTENDED_COUNTERS_INTEL=_C('GL_PERFQUERY_GPA_EXTENDED_COUNTERS_INTEL',0x9500) +GL_PERFQUERY_QUERY_NAME_LENGTH_MAX_INTEL=_C('GL_PERFQUERY_QUERY_NAME_LENGTH_MAX_INTEL',0x94FD) +GL_PERFQUERY_SINGLE_CONTEXT_INTEL=_C('GL_PERFQUERY_SINGLE_CONTEXT_INTEL',0x00000000) +GL_PERFQUERY_WAIT_INTEL=_C('GL_PERFQUERY_WAIT_INTEL',0x83FB) +@_f +@_p.types(None,_cs.GLuint) +def glBeginPerfQueryINTEL(queryHandle):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLuintArray) +def glCreatePerfQueryINTEL(queryId,queryHandle):pass +@_f +@_p.types(None,_cs.GLuint) +def glDeletePerfQueryINTEL(queryHandle):pass +@_f +@_p.types(None,_cs.GLuint) +def glEndPerfQueryINTEL(queryHandle):pass +@_f +@_p.types(None,arrays.GLuintArray) +def glGetFirstPerfQueryIdINTEL(queryId):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLuintArray) +def glGetNextPerfQueryIdINTEL(queryId,nextQueryId):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLuint,arrays.GLcharArray,_cs.GLuint,arrays.GLcharArray,arrays.GLuintArray,arrays.GLuintArray,arrays.GLuintArray,arrays.GLuintArray,arrays.GLuint64Array) +def glGetPerfCounterInfoINTEL(queryId,counterId,counterNameLength,counterName,counterDescLength,counterDesc,counterOffset,counterDataSize,counterTypeEnum,counterDataTypeEnum,rawCounterMaxValue):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLsizei,ctypes.c_void_p,arrays.GLuintArray) +def glGetPerfQueryDataINTEL(queryHandle,flags,dataSize,data,bytesWritten):pass +@_f +@_p.types(None,arrays.GLcharArray,arrays.GLuintArray) +def glGetPerfQueryIdByNameINTEL(queryName,queryId):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,arrays.GLcharArray,arrays.GLuintArray,arrays.GLuintArray,arrays.GLuintArray,arrays.GLuintArray) +def glGetPerfQueryInfoINTEL(queryId,queryNameLength,queryName,dataSize,noCounters,noInstances,capsMask):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/KHR/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/KHR/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/KHR/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/KHR/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/KHR/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..295a4985 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/KHR/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/KHR/__pycache__/blend_equation_advanced.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/KHR/__pycache__/blend_equation_advanced.cpython-312.pyc new file mode 100644 index 00000000..c0bbd451 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/KHR/__pycache__/blend_equation_advanced.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/KHR/__pycache__/blend_equation_advanced_coherent.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/KHR/__pycache__/blend_equation_advanced_coherent.cpython-312.pyc new file mode 100644 index 00000000..4f27701d Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/KHR/__pycache__/blend_equation_advanced_coherent.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/KHR/__pycache__/context_flush_control.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/KHR/__pycache__/context_flush_control.cpython-312.pyc new file mode 100644 index 00000000..eaefc5a9 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/KHR/__pycache__/context_flush_control.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/KHR/__pycache__/debug.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/KHR/__pycache__/debug.cpython-312.pyc new file mode 100644 index 00000000..5fe77f41 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/KHR/__pycache__/debug.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/KHR/__pycache__/no_error.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/KHR/__pycache__/no_error.cpython-312.pyc new file mode 100644 index 00000000..599b2681 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/KHR/__pycache__/no_error.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/KHR/__pycache__/parallel_shader_compile.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/KHR/__pycache__/parallel_shader_compile.cpython-312.pyc new file mode 100644 index 00000000..c7fd9a15 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/KHR/__pycache__/parallel_shader_compile.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/KHR/__pycache__/robust_buffer_access_behavior.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/KHR/__pycache__/robust_buffer_access_behavior.cpython-312.pyc new file mode 100644 index 00000000..5984ab60 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/KHR/__pycache__/robust_buffer_access_behavior.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/KHR/__pycache__/robustness.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/KHR/__pycache__/robustness.cpython-312.pyc new file mode 100644 index 00000000..c7185ea4 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/KHR/__pycache__/robustness.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/KHR/__pycache__/shader_subgroup.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/KHR/__pycache__/shader_subgroup.cpython-312.pyc new file mode 100644 index 00000000..f0a815ca Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/KHR/__pycache__/shader_subgroup.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/KHR/__pycache__/texture_compression_astc_hdr.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/KHR/__pycache__/texture_compression_astc_hdr.cpython-312.pyc new file mode 100644 index 00000000..31ac1e24 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/KHR/__pycache__/texture_compression_astc_hdr.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/KHR/__pycache__/texture_compression_astc_ldr.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/KHR/__pycache__/texture_compression_astc_ldr.cpython-312.pyc new file mode 100644 index 00000000..b78955d9 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/KHR/__pycache__/texture_compression_astc_ldr.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/KHR/__pycache__/texture_compression_astc_sliced_3d.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/KHR/__pycache__/texture_compression_astc_sliced_3d.cpython-312.pyc new file mode 100644 index 00000000..5598ccc4 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/KHR/__pycache__/texture_compression_astc_sliced_3d.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/KHR/blend_equation_advanced.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/KHR/blend_equation_advanced.py new file mode 100644 index 00000000..8816fd85 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/KHR/blend_equation_advanced.py @@ -0,0 +1,31 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_KHR_blend_equation_advanced' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_KHR_blend_equation_advanced',error_checker=_errors._error_checker) +GL_COLORBURN_KHR=_C('GL_COLORBURN_KHR',0x929A) +GL_COLORDODGE_KHR=_C('GL_COLORDODGE_KHR',0x9299) +GL_DARKEN_KHR=_C('GL_DARKEN_KHR',0x9297) +GL_DIFFERENCE_KHR=_C('GL_DIFFERENCE_KHR',0x929E) +GL_EXCLUSION_KHR=_C('GL_EXCLUSION_KHR',0x92A0) +GL_HARDLIGHT_KHR=_C('GL_HARDLIGHT_KHR',0x929B) +GL_HSL_COLOR_KHR=_C('GL_HSL_COLOR_KHR',0x92AF) +GL_HSL_HUE_KHR=_C('GL_HSL_HUE_KHR',0x92AD) +GL_HSL_LUMINOSITY_KHR=_C('GL_HSL_LUMINOSITY_KHR',0x92B0) +GL_HSL_SATURATION_KHR=_C('GL_HSL_SATURATION_KHR',0x92AE) +GL_LIGHTEN_KHR=_C('GL_LIGHTEN_KHR',0x9298) +GL_MULTIPLY_KHR=_C('GL_MULTIPLY_KHR',0x9294) +GL_OVERLAY_KHR=_C('GL_OVERLAY_KHR',0x9296) +GL_SCREEN_KHR=_C('GL_SCREEN_KHR',0x9295) +GL_SOFTLIGHT_KHR=_C('GL_SOFTLIGHT_KHR',0x929C) +@_f +@_p.types(None,) +def glBlendBarrierKHR():pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/KHR/blend_equation_advanced_coherent.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/KHR/blend_equation_advanced_coherent.py new file mode 100644 index 00000000..30386296 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/KHR/blend_equation_advanced_coherent.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_KHR_blend_equation_advanced_coherent' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_KHR_blend_equation_advanced_coherent',error_checker=_errors._error_checker) +GL_BLEND_ADVANCED_COHERENT_KHR=_C('GL_BLEND_ADVANCED_COHERENT_KHR',0x9285) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/KHR/context_flush_control.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/KHR/context_flush_control.py new file mode 100644 index 00000000..3afcc413 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/KHR/context_flush_control.py @@ -0,0 +1,20 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_KHR_context_flush_control' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_KHR_context_flush_control',error_checker=_errors._error_checker) +GL_CONTEXT_RELEASE_BEHAVIOR=_C('GL_CONTEXT_RELEASE_BEHAVIOR',0x82FB) +GL_CONTEXT_RELEASE_BEHAVIOR_FLUSH=_C('GL_CONTEXT_RELEASE_BEHAVIOR_FLUSH',0x82FC) +GL_CONTEXT_RELEASE_BEHAVIOR_FLUSH_KHR=_C('GL_CONTEXT_RELEASE_BEHAVIOR_FLUSH_KHR',0x82FC) +GL_CONTEXT_RELEASE_BEHAVIOR_KHR=_C('GL_CONTEXT_RELEASE_BEHAVIOR_KHR',0x82FB) +GL_NONE=_C('GL_NONE',0) +GL_NONE=_C('GL_NONE',0) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/KHR/debug.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/KHR/debug.py new file mode 100644 index 00000000..04df7f41 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/KHR/debug.py @@ -0,0 +1,160 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_KHR_debug' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_KHR_debug',error_checker=_errors._error_checker) +GL_BUFFER=_C('GL_BUFFER',0x82E0) +GL_BUFFER_KHR=_C('GL_BUFFER_KHR',0x82E0) +GL_CONTEXT_FLAG_DEBUG_BIT=_C('GL_CONTEXT_FLAG_DEBUG_BIT',0x00000002) +GL_CONTEXT_FLAG_DEBUG_BIT_KHR=_C('GL_CONTEXT_FLAG_DEBUG_BIT_KHR',0x00000002) +GL_DEBUG_CALLBACK_FUNCTION=_C('GL_DEBUG_CALLBACK_FUNCTION',0x8244) +GL_DEBUG_CALLBACK_FUNCTION_KHR=_C('GL_DEBUG_CALLBACK_FUNCTION_KHR',0x8244) +GL_DEBUG_CALLBACK_USER_PARAM=_C('GL_DEBUG_CALLBACK_USER_PARAM',0x8245) +GL_DEBUG_CALLBACK_USER_PARAM_KHR=_C('GL_DEBUG_CALLBACK_USER_PARAM_KHR',0x8245) +GL_DEBUG_GROUP_STACK_DEPTH=_C('GL_DEBUG_GROUP_STACK_DEPTH',0x826D) +GL_DEBUG_GROUP_STACK_DEPTH_KHR=_C('GL_DEBUG_GROUP_STACK_DEPTH_KHR',0x826D) +GL_DEBUG_LOGGED_MESSAGES=_C('GL_DEBUG_LOGGED_MESSAGES',0x9145) +GL_DEBUG_LOGGED_MESSAGES_KHR=_C('GL_DEBUG_LOGGED_MESSAGES_KHR',0x9145) +GL_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH=_C('GL_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH',0x8243) +GL_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH_KHR=_C('GL_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH_KHR',0x8243) +GL_DEBUG_OUTPUT=_C('GL_DEBUG_OUTPUT',0x92E0) +GL_DEBUG_OUTPUT_KHR=_C('GL_DEBUG_OUTPUT_KHR',0x92E0) +GL_DEBUG_OUTPUT_SYNCHRONOUS=_C('GL_DEBUG_OUTPUT_SYNCHRONOUS',0x8242) +GL_DEBUG_OUTPUT_SYNCHRONOUS_KHR=_C('GL_DEBUG_OUTPUT_SYNCHRONOUS_KHR',0x8242) +GL_DEBUG_SEVERITY_HIGH=_C('GL_DEBUG_SEVERITY_HIGH',0x9146) +GL_DEBUG_SEVERITY_HIGH_KHR=_C('GL_DEBUG_SEVERITY_HIGH_KHR',0x9146) +GL_DEBUG_SEVERITY_LOW=_C('GL_DEBUG_SEVERITY_LOW',0x9148) +GL_DEBUG_SEVERITY_LOW_KHR=_C('GL_DEBUG_SEVERITY_LOW_KHR',0x9148) +GL_DEBUG_SEVERITY_MEDIUM=_C('GL_DEBUG_SEVERITY_MEDIUM',0x9147) +GL_DEBUG_SEVERITY_MEDIUM_KHR=_C('GL_DEBUG_SEVERITY_MEDIUM_KHR',0x9147) +GL_DEBUG_SEVERITY_NOTIFICATION=_C('GL_DEBUG_SEVERITY_NOTIFICATION',0x826B) +GL_DEBUG_SEVERITY_NOTIFICATION_KHR=_C('GL_DEBUG_SEVERITY_NOTIFICATION_KHR',0x826B) +GL_DEBUG_SOURCE_API=_C('GL_DEBUG_SOURCE_API',0x8246) +GL_DEBUG_SOURCE_API_KHR=_C('GL_DEBUG_SOURCE_API_KHR',0x8246) +GL_DEBUG_SOURCE_APPLICATION=_C('GL_DEBUG_SOURCE_APPLICATION',0x824A) +GL_DEBUG_SOURCE_APPLICATION_KHR=_C('GL_DEBUG_SOURCE_APPLICATION_KHR',0x824A) +GL_DEBUG_SOURCE_OTHER=_C('GL_DEBUG_SOURCE_OTHER',0x824B) +GL_DEBUG_SOURCE_OTHER_KHR=_C('GL_DEBUG_SOURCE_OTHER_KHR',0x824B) +GL_DEBUG_SOURCE_SHADER_COMPILER=_C('GL_DEBUG_SOURCE_SHADER_COMPILER',0x8248) +GL_DEBUG_SOURCE_SHADER_COMPILER_KHR=_C('GL_DEBUG_SOURCE_SHADER_COMPILER_KHR',0x8248) +GL_DEBUG_SOURCE_THIRD_PARTY=_C('GL_DEBUG_SOURCE_THIRD_PARTY',0x8249) +GL_DEBUG_SOURCE_THIRD_PARTY_KHR=_C('GL_DEBUG_SOURCE_THIRD_PARTY_KHR',0x8249) +GL_DEBUG_SOURCE_WINDOW_SYSTEM=_C('GL_DEBUG_SOURCE_WINDOW_SYSTEM',0x8247) +GL_DEBUG_SOURCE_WINDOW_SYSTEM_KHR=_C('GL_DEBUG_SOURCE_WINDOW_SYSTEM_KHR',0x8247) +GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR=_C('GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR',0x824D) +GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR_KHR=_C('GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR_KHR',0x824D) +GL_DEBUG_TYPE_ERROR=_C('GL_DEBUG_TYPE_ERROR',0x824C) +GL_DEBUG_TYPE_ERROR_KHR=_C('GL_DEBUG_TYPE_ERROR_KHR',0x824C) +GL_DEBUG_TYPE_MARKER=_C('GL_DEBUG_TYPE_MARKER',0x8268) +GL_DEBUG_TYPE_MARKER_KHR=_C('GL_DEBUG_TYPE_MARKER_KHR',0x8268) +GL_DEBUG_TYPE_OTHER=_C('GL_DEBUG_TYPE_OTHER',0x8251) +GL_DEBUG_TYPE_OTHER_KHR=_C('GL_DEBUG_TYPE_OTHER_KHR',0x8251) +GL_DEBUG_TYPE_PERFORMANCE=_C('GL_DEBUG_TYPE_PERFORMANCE',0x8250) +GL_DEBUG_TYPE_PERFORMANCE_KHR=_C('GL_DEBUG_TYPE_PERFORMANCE_KHR',0x8250) +GL_DEBUG_TYPE_POP_GROUP=_C('GL_DEBUG_TYPE_POP_GROUP',0x826A) +GL_DEBUG_TYPE_POP_GROUP_KHR=_C('GL_DEBUG_TYPE_POP_GROUP_KHR',0x826A) +GL_DEBUG_TYPE_PORTABILITY=_C('GL_DEBUG_TYPE_PORTABILITY',0x824F) +GL_DEBUG_TYPE_PORTABILITY_KHR=_C('GL_DEBUG_TYPE_PORTABILITY_KHR',0x824F) +GL_DEBUG_TYPE_PUSH_GROUP=_C('GL_DEBUG_TYPE_PUSH_GROUP',0x8269) +GL_DEBUG_TYPE_PUSH_GROUP_KHR=_C('GL_DEBUG_TYPE_PUSH_GROUP_KHR',0x8269) +GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR=_C('GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR',0x824E) +GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR_KHR=_C('GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR_KHR',0x824E) +GL_DISPLAY_LIST=_C('GL_DISPLAY_LIST',0x82E7) +GL_MAX_DEBUG_GROUP_STACK_DEPTH=_C('GL_MAX_DEBUG_GROUP_STACK_DEPTH',0x826C) +GL_MAX_DEBUG_GROUP_STACK_DEPTH_KHR=_C('GL_MAX_DEBUG_GROUP_STACK_DEPTH_KHR',0x826C) +GL_MAX_DEBUG_LOGGED_MESSAGES=_C('GL_MAX_DEBUG_LOGGED_MESSAGES',0x9144) +GL_MAX_DEBUG_LOGGED_MESSAGES_KHR=_C('GL_MAX_DEBUG_LOGGED_MESSAGES_KHR',0x9144) +GL_MAX_DEBUG_MESSAGE_LENGTH=_C('GL_MAX_DEBUG_MESSAGE_LENGTH',0x9143) +GL_MAX_DEBUG_MESSAGE_LENGTH_KHR=_C('GL_MAX_DEBUG_MESSAGE_LENGTH_KHR',0x9143) +GL_MAX_LABEL_LENGTH=_C('GL_MAX_LABEL_LENGTH',0x82E8) +GL_MAX_LABEL_LENGTH_KHR=_C('GL_MAX_LABEL_LENGTH_KHR',0x82E8) +GL_PROGRAM=_C('GL_PROGRAM',0x82E2) +GL_PROGRAM_KHR=_C('GL_PROGRAM_KHR',0x82E2) +GL_PROGRAM_PIPELINE=_C('GL_PROGRAM_PIPELINE',0x82E4) +GL_PROGRAM_PIPELINE_KHR=_C('GL_PROGRAM_PIPELINE_KHR',0x82E4) +GL_QUERY=_C('GL_QUERY',0x82E3) +GL_QUERY_KHR=_C('GL_QUERY_KHR',0x82E3) +GL_SAMPLER=_C('GL_SAMPLER',0x82E6) +GL_SAMPLER_KHR=_C('GL_SAMPLER_KHR',0x82E6) +GL_SHADER=_C('GL_SHADER',0x82E1) +GL_SHADER_KHR=_C('GL_SHADER_KHR',0x82E1) +GL_STACK_OVERFLOW=_C('GL_STACK_OVERFLOW',0x0503) +GL_STACK_OVERFLOW_KHR=_C('GL_STACK_OVERFLOW_KHR',0x0503) +GL_STACK_UNDERFLOW=_C('GL_STACK_UNDERFLOW',0x0504) +GL_STACK_UNDERFLOW_KHR=_C('GL_STACK_UNDERFLOW_KHR',0x0504) +GL_VERTEX_ARRAY=_C('GL_VERTEX_ARRAY',0x8074) +GL_VERTEX_ARRAY_KHR=_C('GL_VERTEX_ARRAY_KHR',0x8074) +@_f +@_p.types(None,_cs.GLDEBUGPROC,ctypes.c_void_p) +def glDebugMessageCallback(callback,userParam):pass +@_f +@_p.types(None,_cs.GLDEBUGPROCKHR,ctypes.c_void_p) +def glDebugMessageCallbackKHR(callback,userParam):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLenum,_cs.GLsizei,arrays.GLuintArray,_cs.GLboolean) +def glDebugMessageControl(source,type,severity,count,ids,enabled):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLenum,_cs.GLsizei,arrays.GLuintArray,_cs.GLboolean) +def glDebugMessageControlKHR(source,type,severity,count,ids,enabled):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLuint,_cs.GLenum,_cs.GLsizei,arrays.GLcharArray) +def glDebugMessageInsert(source,type,id,severity,length,buf):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLuint,_cs.GLenum,_cs.GLsizei,arrays.GLcharArray) +def glDebugMessageInsertKHR(source,type,id,severity,length,buf):pass +@_f +@_p.types(_cs.GLuint,_cs.GLuint,_cs.GLsizei,arrays.GLuintArray,arrays.GLuintArray,arrays.GLuintArray,arrays.GLuintArray,arrays.GLsizeiArray,arrays.GLcharArray) +def glGetDebugMessageLog(count,bufSize,sources,types,ids,severities,lengths,messageLog):pass +@_f +@_p.types(_cs.GLuint,_cs.GLuint,_cs.GLsizei,arrays.GLuintArray,arrays.GLuintArray,arrays.GLuintArray,arrays.GLuintArray,arrays.GLsizeiArray,arrays.GLcharArray) +def glGetDebugMessageLogKHR(count,bufSize,sources,types,ids,severities,lengths,messageLog):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,_cs.GLsizei,arrays.GLsizeiArray,arrays.GLcharArray) +def glGetObjectLabel(identifier,name,bufSize,length,label):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,_cs.GLsizei,arrays.GLsizeiArray,arrays.GLcharArray) +def glGetObjectLabelKHR(identifier,name,bufSize,length,label):pass +@_f +@_p.types(None,ctypes.c_void_p,_cs.GLsizei,arrays.GLsizeiArray,arrays.GLcharArray) +def glGetObjectPtrLabel(ptr,bufSize,length,label):pass +@_f +@_p.types(None,ctypes.c_void_p,_cs.GLsizei,arrays.GLsizeiArray,arrays.GLcharArray) +def glGetObjectPtrLabelKHR(ptr,bufSize,length,label):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLvoidpArray) +def glGetPointerv(pname,params):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLvoidpArray) +def glGetPointervKHR(pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,_cs.GLsizei,arrays.GLcharArray) +def glObjectLabel(identifier,name,length,label):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,_cs.GLsizei,arrays.GLcharArray) +def glObjectLabelKHR(identifier,name,length,label):pass +@_f +@_p.types(None,ctypes.c_void_p,_cs.GLsizei,arrays.GLcharArray) +def glObjectPtrLabel(ptr,length,label):pass +@_f +@_p.types(None,ctypes.c_void_p,_cs.GLsizei,arrays.GLcharArray) +def glObjectPtrLabelKHR(ptr,length,label):pass +@_f +@_p.types(None,) +def glPopDebugGroup():pass +@_f +@_p.types(None,) +def glPopDebugGroupKHR():pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,_cs.GLsizei,arrays.GLcharArray) +def glPushDebugGroup(source,id,length,message):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,_cs.GLsizei,arrays.GLcharArray) +def glPushDebugGroupKHR(source,id,length,message):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/KHR/no_error.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/KHR/no_error.py new file mode 100644 index 00000000..69f836f7 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/KHR/no_error.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_KHR_no_error' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_KHR_no_error',error_checker=_errors._error_checker) +GL_CONTEXT_FLAG_NO_ERROR_BIT_KHR=_C('GL_CONTEXT_FLAG_NO_ERROR_BIT_KHR',0x00000008) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/KHR/parallel_shader_compile.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/KHR/parallel_shader_compile.py new file mode 100644 index 00000000..4fd62ce4 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/KHR/parallel_shader_compile.py @@ -0,0 +1,18 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_KHR_parallel_shader_compile' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_KHR_parallel_shader_compile',error_checker=_errors._error_checker) +GL_COMPLETION_STATUS_KHR=_C('GL_COMPLETION_STATUS_KHR',0x91B1) +GL_MAX_SHADER_COMPILER_THREADS_KHR=_C('GL_MAX_SHADER_COMPILER_THREADS_KHR',0x91B0) +@_f +@_p.types(None,_cs.GLuint) +def glMaxShaderCompilerThreadsKHR(count):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/KHR/robust_buffer_access_behavior.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/KHR/robust_buffer_access_behavior.py new file mode 100644 index 00000000..65de5a94 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/KHR/robust_buffer_access_behavior.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_KHR_robust_buffer_access_behavior' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_KHR_robust_buffer_access_behavior',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/KHR/robustness.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/KHR/robustness.py new file mode 100644 index 00000000..9388f77b --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/KHR/robustness.py @@ -0,0 +1,61 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_KHR_robustness' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_KHR_robustness',error_checker=_errors._error_checker) +GL_CONTEXT_LOST=_C('GL_CONTEXT_LOST',0x0507) +GL_CONTEXT_LOST_KHR=_C('GL_CONTEXT_LOST_KHR',0x0507) +GL_CONTEXT_ROBUST_ACCESS=_C('GL_CONTEXT_ROBUST_ACCESS',0x90F3) +GL_CONTEXT_ROBUST_ACCESS_KHR=_C('GL_CONTEXT_ROBUST_ACCESS_KHR',0x90F3) +GL_GUILTY_CONTEXT_RESET=_C('GL_GUILTY_CONTEXT_RESET',0x8253) +GL_GUILTY_CONTEXT_RESET_KHR=_C('GL_GUILTY_CONTEXT_RESET_KHR',0x8253) +GL_INNOCENT_CONTEXT_RESET=_C('GL_INNOCENT_CONTEXT_RESET',0x8254) +GL_INNOCENT_CONTEXT_RESET_KHR=_C('GL_INNOCENT_CONTEXT_RESET_KHR',0x8254) +GL_LOSE_CONTEXT_ON_RESET=_C('GL_LOSE_CONTEXT_ON_RESET',0x8252) +GL_LOSE_CONTEXT_ON_RESET_KHR=_C('GL_LOSE_CONTEXT_ON_RESET_KHR',0x8252) +GL_NO_ERROR=_C('GL_NO_ERROR',0) +GL_NO_ERROR=_C('GL_NO_ERROR',0) +GL_NO_RESET_NOTIFICATION=_C('GL_NO_RESET_NOTIFICATION',0x8261) +GL_NO_RESET_NOTIFICATION_KHR=_C('GL_NO_RESET_NOTIFICATION_KHR',0x8261) +GL_RESET_NOTIFICATION_STRATEGY=_C('GL_RESET_NOTIFICATION_STRATEGY',0x8256) +GL_RESET_NOTIFICATION_STRATEGY_KHR=_C('GL_RESET_NOTIFICATION_STRATEGY_KHR',0x8256) +GL_UNKNOWN_CONTEXT_RESET=_C('GL_UNKNOWN_CONTEXT_RESET',0x8255) +GL_UNKNOWN_CONTEXT_RESET_KHR=_C('GL_UNKNOWN_CONTEXT_RESET_KHR',0x8255) +@_f +@_p.types(_cs.GLenum,) +def glGetGraphicsResetStatus():pass +@_f +@_p.types(_cs.GLenum,) +def glGetGraphicsResetStatusKHR():pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLfloatArray) +def glGetnUniformfv(program,location,bufSize,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLfloatArray) +def glGetnUniformfvKHR(program,location,bufSize,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLintArray) +def glGetnUniformiv(program,location,bufSize,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLintArray) +def glGetnUniformivKHR(program,location,bufSize,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLuintArray) +def glGetnUniformuiv(program,location,bufSize,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLuintArray) +def glGetnUniformuivKHR(program,location,bufSize,params):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLsizei,_cs.GLenum,_cs.GLenum,_cs.GLsizei,ctypes.c_void_p) +def glReadnPixels(x,y,width,height,format,type,bufSize,data):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLsizei,_cs.GLenum,_cs.GLenum,_cs.GLsizei,ctypes.c_void_p) +def glReadnPixelsKHR(x,y,width,height,format,type,bufSize,data):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/KHR/shader_subgroup.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/KHR/shader_subgroup.py new file mode 100644 index 00000000..adbfded4 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/KHR/shader_subgroup.py @@ -0,0 +1,26 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_KHR_shader_subgroup' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_KHR_shader_subgroup',error_checker=_errors._error_checker) +GL_SUBGROUP_FEATURE_ARITHMETIC_BIT_KHR=_C('GL_SUBGROUP_FEATURE_ARITHMETIC_BIT_KHR',0x00000004) +GL_SUBGROUP_FEATURE_BALLOT_BIT_KHR=_C('GL_SUBGROUP_FEATURE_BALLOT_BIT_KHR',0x00000008) +GL_SUBGROUP_FEATURE_BASIC_BIT_KHR=_C('GL_SUBGROUP_FEATURE_BASIC_BIT_KHR',0x00000001) +GL_SUBGROUP_FEATURE_CLUSTERED_BIT_KHR=_C('GL_SUBGROUP_FEATURE_CLUSTERED_BIT_KHR',0x00000040) +GL_SUBGROUP_FEATURE_QUAD_BIT_KHR=_C('GL_SUBGROUP_FEATURE_QUAD_BIT_KHR',0x00000080) +GL_SUBGROUP_FEATURE_SHUFFLE_BIT_KHR=_C('GL_SUBGROUP_FEATURE_SHUFFLE_BIT_KHR',0x00000010) +GL_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT_KHR=_C('GL_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT_KHR',0x00000020) +GL_SUBGROUP_FEATURE_VOTE_BIT_KHR=_C('GL_SUBGROUP_FEATURE_VOTE_BIT_KHR',0x00000002) +GL_SUBGROUP_QUAD_ALL_STAGES_KHR=_C('GL_SUBGROUP_QUAD_ALL_STAGES_KHR',0x9535) +GL_SUBGROUP_SIZE_KHR=_C('GL_SUBGROUP_SIZE_KHR',0x9532) +GL_SUBGROUP_SUPPORTED_FEATURES_KHR=_C('GL_SUBGROUP_SUPPORTED_FEATURES_KHR',0x9534) +GL_SUBGROUP_SUPPORTED_STAGES_KHR=_C('GL_SUBGROUP_SUPPORTED_STAGES_KHR',0x9533) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/KHR/texture_compression_astc_hdr.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/KHR/texture_compression_astc_hdr.py new file mode 100644 index 00000000..fa3de94c --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/KHR/texture_compression_astc_hdr.py @@ -0,0 +1,42 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_KHR_texture_compression_astc_hdr' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_KHR_texture_compression_astc_hdr',error_checker=_errors._error_checker) +GL_COMPRESSED_RGBA_ASTC_10x10_KHR=_C('GL_COMPRESSED_RGBA_ASTC_10x10_KHR',0x93BB) +GL_COMPRESSED_RGBA_ASTC_10x5_KHR=_C('GL_COMPRESSED_RGBA_ASTC_10x5_KHR',0x93B8) +GL_COMPRESSED_RGBA_ASTC_10x6_KHR=_C('GL_COMPRESSED_RGBA_ASTC_10x6_KHR',0x93B9) +GL_COMPRESSED_RGBA_ASTC_10x8_KHR=_C('GL_COMPRESSED_RGBA_ASTC_10x8_KHR',0x93BA) +GL_COMPRESSED_RGBA_ASTC_12x10_KHR=_C('GL_COMPRESSED_RGBA_ASTC_12x10_KHR',0x93BC) +GL_COMPRESSED_RGBA_ASTC_12x12_KHR=_C('GL_COMPRESSED_RGBA_ASTC_12x12_KHR',0x93BD) +GL_COMPRESSED_RGBA_ASTC_4x4_KHR=_C('GL_COMPRESSED_RGBA_ASTC_4x4_KHR',0x93B0) +GL_COMPRESSED_RGBA_ASTC_5x4_KHR=_C('GL_COMPRESSED_RGBA_ASTC_5x4_KHR',0x93B1) +GL_COMPRESSED_RGBA_ASTC_5x5_KHR=_C('GL_COMPRESSED_RGBA_ASTC_5x5_KHR',0x93B2) +GL_COMPRESSED_RGBA_ASTC_6x5_KHR=_C('GL_COMPRESSED_RGBA_ASTC_6x5_KHR',0x93B3) +GL_COMPRESSED_RGBA_ASTC_6x6_KHR=_C('GL_COMPRESSED_RGBA_ASTC_6x6_KHR',0x93B4) +GL_COMPRESSED_RGBA_ASTC_8x5_KHR=_C('GL_COMPRESSED_RGBA_ASTC_8x5_KHR',0x93B5) +GL_COMPRESSED_RGBA_ASTC_8x6_KHR=_C('GL_COMPRESSED_RGBA_ASTC_8x6_KHR',0x93B6) +GL_COMPRESSED_RGBA_ASTC_8x8_KHR=_C('GL_COMPRESSED_RGBA_ASTC_8x8_KHR',0x93B7) +GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR=_C('GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR',0x93DB) +GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR=_C('GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR',0x93D8) +GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR=_C('GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR',0x93D9) +GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR=_C('GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR',0x93DA) +GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR=_C('GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR',0x93DC) +GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR=_C('GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR',0x93DD) +GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR=_C('GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR',0x93D0) +GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR=_C('GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR',0x93D1) +GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR=_C('GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR',0x93D2) +GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR=_C('GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR',0x93D3) +GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR=_C('GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR',0x93D4) +GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR=_C('GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR',0x93D5) +GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR=_C('GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR',0x93D6) +GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR=_C('GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR',0x93D7) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/KHR/texture_compression_astc_ldr.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/KHR/texture_compression_astc_ldr.py new file mode 100644 index 00000000..8ca5852c --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/KHR/texture_compression_astc_ldr.py @@ -0,0 +1,42 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_KHR_texture_compression_astc_ldr' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_KHR_texture_compression_astc_ldr',error_checker=_errors._error_checker) +GL_COMPRESSED_RGBA_ASTC_10x10_KHR=_C('GL_COMPRESSED_RGBA_ASTC_10x10_KHR',0x93BB) +GL_COMPRESSED_RGBA_ASTC_10x5_KHR=_C('GL_COMPRESSED_RGBA_ASTC_10x5_KHR',0x93B8) +GL_COMPRESSED_RGBA_ASTC_10x6_KHR=_C('GL_COMPRESSED_RGBA_ASTC_10x6_KHR',0x93B9) +GL_COMPRESSED_RGBA_ASTC_10x8_KHR=_C('GL_COMPRESSED_RGBA_ASTC_10x8_KHR',0x93BA) +GL_COMPRESSED_RGBA_ASTC_12x10_KHR=_C('GL_COMPRESSED_RGBA_ASTC_12x10_KHR',0x93BC) +GL_COMPRESSED_RGBA_ASTC_12x12_KHR=_C('GL_COMPRESSED_RGBA_ASTC_12x12_KHR',0x93BD) +GL_COMPRESSED_RGBA_ASTC_4x4_KHR=_C('GL_COMPRESSED_RGBA_ASTC_4x4_KHR',0x93B0) +GL_COMPRESSED_RGBA_ASTC_5x4_KHR=_C('GL_COMPRESSED_RGBA_ASTC_5x4_KHR',0x93B1) +GL_COMPRESSED_RGBA_ASTC_5x5_KHR=_C('GL_COMPRESSED_RGBA_ASTC_5x5_KHR',0x93B2) +GL_COMPRESSED_RGBA_ASTC_6x5_KHR=_C('GL_COMPRESSED_RGBA_ASTC_6x5_KHR',0x93B3) +GL_COMPRESSED_RGBA_ASTC_6x6_KHR=_C('GL_COMPRESSED_RGBA_ASTC_6x6_KHR',0x93B4) +GL_COMPRESSED_RGBA_ASTC_8x5_KHR=_C('GL_COMPRESSED_RGBA_ASTC_8x5_KHR',0x93B5) +GL_COMPRESSED_RGBA_ASTC_8x6_KHR=_C('GL_COMPRESSED_RGBA_ASTC_8x6_KHR',0x93B6) +GL_COMPRESSED_RGBA_ASTC_8x8_KHR=_C('GL_COMPRESSED_RGBA_ASTC_8x8_KHR',0x93B7) +GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR=_C('GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR',0x93DB) +GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR=_C('GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR',0x93D8) +GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR=_C('GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR',0x93D9) +GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR=_C('GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR',0x93DA) +GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR=_C('GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR',0x93DC) +GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR=_C('GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR',0x93DD) +GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR=_C('GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR',0x93D0) +GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR=_C('GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR',0x93D1) +GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR=_C('GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR',0x93D2) +GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR=_C('GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR',0x93D3) +GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR=_C('GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR',0x93D4) +GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR=_C('GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR',0x93D5) +GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR=_C('GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR',0x93D6) +GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR=_C('GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR',0x93D7) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/KHR/texture_compression_astc_sliced_3d.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/KHR/texture_compression_astc_sliced_3d.py new file mode 100644 index 00000000..6522b1ed --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/KHR/texture_compression_astc_sliced_3d.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_KHR_texture_compression_astc_sliced_3d' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_KHR_texture_compression_astc_sliced_3d',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/MESA/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/MESA/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/MESA/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/MESA/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/MESA/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..c6e73aae Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/MESA/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/MESA/__pycache__/framebuffer_flip_y.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/MESA/__pycache__/framebuffer_flip_y.cpython-312.pyc new file mode 100644 index 00000000..c9661e31 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/MESA/__pycache__/framebuffer_flip_y.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/MESA/__pycache__/pack_invert.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/MESA/__pycache__/pack_invert.cpython-312.pyc new file mode 100644 index 00000000..b74df502 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/MESA/__pycache__/pack_invert.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/MESA/__pycache__/program_binary_formats.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/MESA/__pycache__/program_binary_formats.cpython-312.pyc new file mode 100644 index 00000000..97a425c2 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/MESA/__pycache__/program_binary_formats.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/MESA/__pycache__/resize_buffers.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/MESA/__pycache__/resize_buffers.cpython-312.pyc new file mode 100644 index 00000000..bd82ebe9 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/MESA/__pycache__/resize_buffers.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/MESA/__pycache__/shader_integer_functions.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/MESA/__pycache__/shader_integer_functions.cpython-312.pyc new file mode 100644 index 00000000..a4284368 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/MESA/__pycache__/shader_integer_functions.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/MESA/__pycache__/tile_raster_order.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/MESA/__pycache__/tile_raster_order.cpython-312.pyc new file mode 100644 index 00000000..b56c8957 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/MESA/__pycache__/tile_raster_order.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/MESA/__pycache__/window_pos.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/MESA/__pycache__/window_pos.cpython-312.pyc new file mode 100644 index 00000000..06d945bd Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/MESA/__pycache__/window_pos.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/MESA/__pycache__/ycbcr_texture.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/MESA/__pycache__/ycbcr_texture.cpython-312.pyc new file mode 100644 index 00000000..334aafcb Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/MESA/__pycache__/ycbcr_texture.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/MESA/framebuffer_flip_y.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/MESA/framebuffer_flip_y.py new file mode 100644 index 00000000..4e5555f3 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/MESA/framebuffer_flip_y.py @@ -0,0 +1,20 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_MESA_framebuffer_flip_y' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_MESA_framebuffer_flip_y',error_checker=_errors._error_checker) +GL_FRAMEBUFFER_FLIP_Y_MESA=_C('GL_FRAMEBUFFER_FLIP_Y_MESA',0x8BBB) +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLint) +def glFramebufferParameteriMESA(target,pname,param):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLintArray) +def glGetFramebufferParameterivMESA(target,pname,params):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/MESA/pack_invert.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/MESA/pack_invert.py new file mode 100644 index 00000000..8c1a571b --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/MESA/pack_invert.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_MESA_pack_invert' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_MESA_pack_invert',error_checker=_errors._error_checker) +GL_PACK_INVERT_MESA=_C('GL_PACK_INVERT_MESA',0x8758) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/MESA/program_binary_formats.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/MESA/program_binary_formats.py new file mode 100644 index 00000000..9d240e3c --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/MESA/program_binary_formats.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_MESA_program_binary_formats' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_MESA_program_binary_formats',error_checker=_errors._error_checker) +GL_PROGRAM_BINARY_FORMAT_MESA=_C('GL_PROGRAM_BINARY_FORMAT_MESA',0x875F) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/MESA/resize_buffers.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/MESA/resize_buffers.py new file mode 100644 index 00000000..f98d9bd2 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/MESA/resize_buffers.py @@ -0,0 +1,17 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_MESA_resize_buffers' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_MESA_resize_buffers',error_checker=_errors._error_checker) + +@_f +@_p.types(None,) +def glResizeBuffersMESA():pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/MESA/shader_integer_functions.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/MESA/shader_integer_functions.py new file mode 100644 index 00000000..9b2a8410 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/MESA/shader_integer_functions.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_MESA_shader_integer_functions' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_MESA_shader_integer_functions',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/MESA/tile_raster_order.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/MESA/tile_raster_order.py new file mode 100644 index 00000000..f451f16c --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/MESA/tile_raster_order.py @@ -0,0 +1,17 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_MESA_tile_raster_order' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_MESA_tile_raster_order',error_checker=_errors._error_checker) +GL_TILE_RASTER_ORDER_FIXED_MESA=_C('GL_TILE_RASTER_ORDER_FIXED_MESA',0x8BB8) +GL_TILE_RASTER_ORDER_INCREASING_X_MESA=_C('GL_TILE_RASTER_ORDER_INCREASING_X_MESA',0x8BB9) +GL_TILE_RASTER_ORDER_INCREASING_Y_MESA=_C('GL_TILE_RASTER_ORDER_INCREASING_Y_MESA',0x8BBA) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/MESA/window_pos.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/MESA/window_pos.py new file mode 100644 index 00000000..6157ba59 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/MESA/window_pos.py @@ -0,0 +1,86 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_MESA_window_pos' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_MESA_window_pos',error_checker=_errors._error_checker) + +@_f +@_p.types(None,_cs.GLdouble,_cs.GLdouble) +def glWindowPos2dMESA(x,y):pass +@_f +@_p.types(None,arrays.GLdoubleArray) +def glWindowPos2dvMESA(v):pass +@_f +@_p.types(None,_cs.GLfloat,_cs.GLfloat) +def glWindowPos2fMESA(x,y):pass +@_f +@_p.types(None,arrays.GLfloatArray) +def glWindowPos2fvMESA(v):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLint) +def glWindowPos2iMESA(x,y):pass +@_f +@_p.types(None,arrays.GLintArray) +def glWindowPos2ivMESA(v):pass +@_f +@_p.types(None,_cs.GLshort,_cs.GLshort) +def glWindowPos2sMESA(x,y):pass +@_f +@_p.types(None,arrays.GLshortArray) +def glWindowPos2svMESA(v):pass +@_f +@_p.types(None,_cs.GLdouble,_cs.GLdouble,_cs.GLdouble) +def glWindowPos3dMESA(x,y,z):pass +@_f +@_p.types(None,arrays.GLdoubleArray) +def glWindowPos3dvMESA(v):pass +@_f +@_p.types(None,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat) +def glWindowPos3fMESA(x,y,z):pass +@_f +@_p.types(None,arrays.GLfloatArray) +def glWindowPos3fvMESA(v):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLint,_cs.GLint) +def glWindowPos3iMESA(x,y,z):pass +@_f +@_p.types(None,arrays.GLintArray) +def glWindowPos3ivMESA(v):pass +@_f +@_p.types(None,_cs.GLshort,_cs.GLshort,_cs.GLshort) +def glWindowPos3sMESA(x,y,z):pass +@_f +@_p.types(None,arrays.GLshortArray) +def glWindowPos3svMESA(v):pass +@_f +@_p.types(None,_cs.GLdouble,_cs.GLdouble,_cs.GLdouble,_cs.GLdouble) +def glWindowPos4dMESA(x,y,z,w):pass +@_f +@_p.types(None,arrays.GLdoubleArray) +def glWindowPos4dvMESA(v):pass +@_f +@_p.types(None,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat) +def glWindowPos4fMESA(x,y,z,w):pass +@_f +@_p.types(None,arrays.GLfloatArray) +def glWindowPos4fvMESA(v):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint) +def glWindowPos4iMESA(x,y,z,w):pass +@_f +@_p.types(None,arrays.GLintArray) +def glWindowPos4ivMESA(v):pass +@_f +@_p.types(None,_cs.GLshort,_cs.GLshort,_cs.GLshort,_cs.GLshort) +def glWindowPos4sMESA(x,y,z,w):pass +@_f +@_p.types(None,arrays.GLshortArray) +def glWindowPos4svMESA(v):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/MESA/ycbcr_texture.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/MESA/ycbcr_texture.py new file mode 100644 index 00000000..03694be6 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/MESA/ycbcr_texture.py @@ -0,0 +1,17 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_MESA_ycbcr_texture' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_MESA_ycbcr_texture',error_checker=_errors._error_checker) +GL_UNSIGNED_SHORT_8_8_MESA=_C('GL_UNSIGNED_SHORT_8_8_MESA',0x85BA) +GL_UNSIGNED_SHORT_8_8_REV_MESA=_C('GL_UNSIGNED_SHORT_8_8_REV_MESA',0x85BB) +GL_YCBCR_MESA=_C('GL_YCBCR_MESA',0x8757) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/MESAX/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/MESAX/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/MESAX/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/MESAX/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/MESAX/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..d34a60e3 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/MESAX/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/MESAX/__pycache__/texture_stack.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/MESAX/__pycache__/texture_stack.cpython-312.pyc new file mode 100644 index 00000000..5520b95b Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/MESAX/__pycache__/texture_stack.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/MESAX/texture_stack.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/MESAX/texture_stack.py new file mode 100644 index 00000000..13e2366f --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/MESAX/texture_stack.py @@ -0,0 +1,20 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_MESAX_texture_stack' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_MESAX_texture_stack',error_checker=_errors._error_checker) +GL_PROXY_TEXTURE_1D_STACK_MESAX=_C('GL_PROXY_TEXTURE_1D_STACK_MESAX',0x875B) +GL_PROXY_TEXTURE_2D_STACK_MESAX=_C('GL_PROXY_TEXTURE_2D_STACK_MESAX',0x875C) +GL_TEXTURE_1D_STACK_BINDING_MESAX=_C('GL_TEXTURE_1D_STACK_BINDING_MESAX',0x875D) +GL_TEXTURE_1D_STACK_MESAX=_C('GL_TEXTURE_1D_STACK_MESAX',0x8759) +GL_TEXTURE_2D_STACK_BINDING_MESAX=_C('GL_TEXTURE_2D_STACK_BINDING_MESAX',0x875E) +GL_TEXTURE_2D_STACK_MESAX=_C('GL_TEXTURE_2D_STACK_MESAX',0x875A) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..68a033e7 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/alpha_to_coverage_dither_control.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/alpha_to_coverage_dither_control.cpython-312.pyc new file mode 100644 index 00000000..b0c1d0ba Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/alpha_to_coverage_dither_control.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/bindless_multi_draw_indirect.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/bindless_multi_draw_indirect.cpython-312.pyc new file mode 100644 index 00000000..d53dc52e Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/bindless_multi_draw_indirect.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/bindless_multi_draw_indirect_count.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/bindless_multi_draw_indirect_count.cpython-312.pyc new file mode 100644 index 00000000..e1861010 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/bindless_multi_draw_indirect_count.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/bindless_texture.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/bindless_texture.cpython-312.pyc new file mode 100644 index 00000000..b2681d05 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/bindless_texture.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/blend_equation_advanced.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/blend_equation_advanced.cpython-312.pyc new file mode 100644 index 00000000..1d5d0231 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/blend_equation_advanced.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/blend_equation_advanced_coherent.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/blend_equation_advanced_coherent.cpython-312.pyc new file mode 100644 index 00000000..1d26affd Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/blend_equation_advanced_coherent.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/blend_minmax_factor.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/blend_minmax_factor.cpython-312.pyc new file mode 100644 index 00000000..2eb26c08 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/blend_minmax_factor.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/blend_square.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/blend_square.cpython-312.pyc new file mode 100644 index 00000000..9c85f81e Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/blend_square.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/clip_space_w_scaling.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/clip_space_w_scaling.cpython-312.pyc new file mode 100644 index 00000000..50e93687 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/clip_space_w_scaling.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/command_list.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/command_list.cpython-312.pyc new file mode 100644 index 00000000..ee739119 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/command_list.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/compute_program5.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/compute_program5.cpython-312.pyc new file mode 100644 index 00000000..e44f15f0 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/compute_program5.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/compute_shader_derivatives.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/compute_shader_derivatives.cpython-312.pyc new file mode 100644 index 00000000..51b4e164 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/compute_shader_derivatives.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/conditional_render.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/conditional_render.cpython-312.pyc new file mode 100644 index 00000000..8c3151af Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/conditional_render.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/conservative_raster.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/conservative_raster.cpython-312.pyc new file mode 100644 index 00000000..5f64b130 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/conservative_raster.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/conservative_raster_dilate.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/conservative_raster_dilate.cpython-312.pyc new file mode 100644 index 00000000..30f6b1f3 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/conservative_raster_dilate.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/conservative_raster_pre_snap.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/conservative_raster_pre_snap.cpython-312.pyc new file mode 100644 index 00000000..150ff9dc Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/conservative_raster_pre_snap.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/conservative_raster_pre_snap_triangles.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/conservative_raster_pre_snap_triangles.cpython-312.pyc new file mode 100644 index 00000000..ea102fa4 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/conservative_raster_pre_snap_triangles.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/conservative_raster_underestimation.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/conservative_raster_underestimation.cpython-312.pyc new file mode 100644 index 00000000..6402e379 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/conservative_raster_underestimation.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/copy_depth_to_color.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/copy_depth_to_color.cpython-312.pyc new file mode 100644 index 00000000..b044b720 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/copy_depth_to_color.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/copy_image.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/copy_image.cpython-312.pyc new file mode 100644 index 00000000..c8d6742b Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/copy_image.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/deep_texture3D.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/deep_texture3D.cpython-312.pyc new file mode 100644 index 00000000..ec36623a Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/deep_texture3D.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/depth_buffer_float.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/depth_buffer_float.cpython-312.pyc new file mode 100644 index 00000000..c39c5663 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/depth_buffer_float.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/depth_clamp.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/depth_clamp.cpython-312.pyc new file mode 100644 index 00000000..431a2173 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/depth_clamp.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/draw_texture.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/draw_texture.cpython-312.pyc new file mode 100644 index 00000000..9625b5e6 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/draw_texture.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/draw_vulkan_image.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/draw_vulkan_image.cpython-312.pyc new file mode 100644 index 00000000..ed5e5dce Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/draw_vulkan_image.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/evaluators.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/evaluators.cpython-312.pyc new file mode 100644 index 00000000..856d65f5 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/evaluators.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/explicit_multisample.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/explicit_multisample.cpython-312.pyc new file mode 100644 index 00000000..3d60c56c Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/explicit_multisample.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/fence.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/fence.cpython-312.pyc new file mode 100644 index 00000000..2e2caee8 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/fence.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/fill_rectangle.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/fill_rectangle.cpython-312.pyc new file mode 100644 index 00000000..cba63c78 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/fill_rectangle.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/float_buffer.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/float_buffer.cpython-312.pyc new file mode 100644 index 00000000..6fdcd067 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/float_buffer.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/fog_distance.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/fog_distance.cpython-312.pyc new file mode 100644 index 00000000..3abc5de1 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/fog_distance.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/fragment_coverage_to_color.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/fragment_coverage_to_color.cpython-312.pyc new file mode 100644 index 00000000..042c9a3e Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/fragment_coverage_to_color.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/fragment_program.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/fragment_program.cpython-312.pyc new file mode 100644 index 00000000..88039bef Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/fragment_program.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/fragment_program2.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/fragment_program2.cpython-312.pyc new file mode 100644 index 00000000..b6b696ae Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/fragment_program2.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/fragment_program4.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/fragment_program4.cpython-312.pyc new file mode 100644 index 00000000..9087bde8 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/fragment_program4.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/fragment_program_option.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/fragment_program_option.cpython-312.pyc new file mode 100644 index 00000000..4668eb1d Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/fragment_program_option.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/fragment_shader_barycentric.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/fragment_shader_barycentric.cpython-312.pyc new file mode 100644 index 00000000..c08fcacf Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/fragment_shader_barycentric.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/fragment_shader_interlock.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/fragment_shader_interlock.cpython-312.pyc new file mode 100644 index 00000000..d350f92d Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/fragment_shader_interlock.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/framebuffer_mixed_samples.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/framebuffer_mixed_samples.cpython-312.pyc new file mode 100644 index 00000000..69437c05 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/framebuffer_mixed_samples.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/framebuffer_multisample_coverage.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/framebuffer_multisample_coverage.cpython-312.pyc new file mode 100644 index 00000000..50c8ca68 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/framebuffer_multisample_coverage.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/geometry_program4.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/geometry_program4.cpython-312.pyc new file mode 100644 index 00000000..c7157160 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/geometry_program4.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/geometry_shader4.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/geometry_shader4.cpython-312.pyc new file mode 100644 index 00000000..2256688b Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/geometry_shader4.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/geometry_shader_passthrough.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/geometry_shader_passthrough.cpython-312.pyc new file mode 100644 index 00000000..f0fbb33c Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/geometry_shader_passthrough.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/gpu_multicast.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/gpu_multicast.cpython-312.pyc new file mode 100644 index 00000000..eb24ee3c Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/gpu_multicast.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/gpu_program4.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/gpu_program4.cpython-312.pyc new file mode 100644 index 00000000..e4649e1a Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/gpu_program4.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/gpu_program5.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/gpu_program5.cpython-312.pyc new file mode 100644 index 00000000..c76bad76 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/gpu_program5.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/gpu_program5_mem_extended.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/gpu_program5_mem_extended.cpython-312.pyc new file mode 100644 index 00000000..a16e5e8d Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/gpu_program5_mem_extended.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/gpu_shader5.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/gpu_shader5.cpython-312.pyc new file mode 100644 index 00000000..fdc6458b Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/gpu_shader5.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/half_float.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/half_float.cpython-312.pyc new file mode 100644 index 00000000..f9018c55 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/half_float.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/internalformat_sample_query.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/internalformat_sample_query.cpython-312.pyc new file mode 100644 index 00000000..b3c6f38e Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/internalformat_sample_query.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/light_max_exponent.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/light_max_exponent.cpython-312.pyc new file mode 100644 index 00000000..0ab51b71 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/light_max_exponent.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/memory_attachment.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/memory_attachment.cpython-312.pyc new file mode 100644 index 00000000..4db14dd2 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/memory_attachment.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/mesh_shader.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/mesh_shader.cpython-312.pyc new file mode 100644 index 00000000..3883eb39 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/mesh_shader.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/multisample_coverage.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/multisample_coverage.cpython-312.pyc new file mode 100644 index 00000000..5efc8da6 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/multisample_coverage.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/multisample_filter_hint.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/multisample_filter_hint.cpython-312.pyc new file mode 100644 index 00000000..7556c8e8 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/multisample_filter_hint.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/occlusion_query.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/occlusion_query.cpython-312.pyc new file mode 100644 index 00000000..ab5f87d7 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/occlusion_query.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/packed_depth_stencil.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/packed_depth_stencil.cpython-312.pyc new file mode 100644 index 00000000..6659c6d6 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/packed_depth_stencil.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/parameter_buffer_object.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/parameter_buffer_object.cpython-312.pyc new file mode 100644 index 00000000..5e466a89 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/parameter_buffer_object.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/parameter_buffer_object2.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/parameter_buffer_object2.cpython-312.pyc new file mode 100644 index 00000000..d0574226 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/parameter_buffer_object2.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/path_rendering.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/path_rendering.cpython-312.pyc new file mode 100644 index 00000000..dbdc2157 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/path_rendering.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/path_rendering_shared_edge.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/path_rendering_shared_edge.cpython-312.pyc new file mode 100644 index 00000000..b9fa2343 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/path_rendering_shared_edge.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/pixel_data_range.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/pixel_data_range.cpython-312.pyc new file mode 100644 index 00000000..662397b6 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/pixel_data_range.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/point_sprite.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/point_sprite.cpython-312.pyc new file mode 100644 index 00000000..939cd353 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/point_sprite.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/present_video.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/present_video.cpython-312.pyc new file mode 100644 index 00000000..7503dc59 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/present_video.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/primitive_restart.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/primitive_restart.cpython-312.pyc new file mode 100644 index 00000000..e713b40d Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/primitive_restart.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/query_resource.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/query_resource.cpython-312.pyc new file mode 100644 index 00000000..0b77d99f Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/query_resource.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/query_resource_tag.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/query_resource_tag.cpython-312.pyc new file mode 100644 index 00000000..f6c53d81 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/query_resource_tag.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/register_combiners.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/register_combiners.cpython-312.pyc new file mode 100644 index 00000000..09acffff Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/register_combiners.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/register_combiners2.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/register_combiners2.cpython-312.pyc new file mode 100644 index 00000000..edbb7bb8 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/register_combiners2.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/representative_fragment_test.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/representative_fragment_test.cpython-312.pyc new file mode 100644 index 00000000..1e8f5981 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/representative_fragment_test.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/robustness_video_memory_purge.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/robustness_video_memory_purge.cpython-312.pyc new file mode 100644 index 00000000..4f8a87b9 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/robustness_video_memory_purge.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/sample_locations.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/sample_locations.cpython-312.pyc new file mode 100644 index 00000000..a0fe88c4 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/sample_locations.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/sample_mask_override_coverage.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/sample_mask_override_coverage.cpython-312.pyc new file mode 100644 index 00000000..ccce47ee Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/sample_mask_override_coverage.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/scissor_exclusive.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/scissor_exclusive.cpython-312.pyc new file mode 100644 index 00000000..17735aba Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/scissor_exclusive.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/shader_atomic_counters.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/shader_atomic_counters.cpython-312.pyc new file mode 100644 index 00000000..5087df9c Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/shader_atomic_counters.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/shader_atomic_float.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/shader_atomic_float.cpython-312.pyc new file mode 100644 index 00000000..9ecbe45f Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/shader_atomic_float.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/shader_atomic_float64.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/shader_atomic_float64.cpython-312.pyc new file mode 100644 index 00000000..1d0b7876 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/shader_atomic_float64.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/shader_atomic_fp16_vector.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/shader_atomic_fp16_vector.cpython-312.pyc new file mode 100644 index 00000000..2b6e8a8d Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/shader_atomic_fp16_vector.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/shader_atomic_int64.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/shader_atomic_int64.cpython-312.pyc new file mode 100644 index 00000000..67987bab Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/shader_atomic_int64.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/shader_buffer_load.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/shader_buffer_load.cpython-312.pyc new file mode 100644 index 00000000..77fee9b8 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/shader_buffer_load.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/shader_buffer_store.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/shader_buffer_store.cpython-312.pyc new file mode 100644 index 00000000..8e8f19b0 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/shader_buffer_store.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/shader_storage_buffer_object.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/shader_storage_buffer_object.cpython-312.pyc new file mode 100644 index 00000000..6814019b Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/shader_storage_buffer_object.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/shader_subgroup_partitioned.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/shader_subgroup_partitioned.cpython-312.pyc new file mode 100644 index 00000000..eee6031c Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/shader_subgroup_partitioned.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/shader_texture_footprint.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/shader_texture_footprint.cpython-312.pyc new file mode 100644 index 00000000..5e2677bb Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/shader_texture_footprint.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/shader_thread_group.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/shader_thread_group.cpython-312.pyc new file mode 100644 index 00000000..f75e46ea Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/shader_thread_group.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/shader_thread_shuffle.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/shader_thread_shuffle.cpython-312.pyc new file mode 100644 index 00000000..3bd5a484 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/shader_thread_shuffle.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/shading_rate_image.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/shading_rate_image.cpython-312.pyc new file mode 100644 index 00000000..5cd7fe1f Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/shading_rate_image.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/stereo_view_rendering.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/stereo_view_rendering.cpython-312.pyc new file mode 100644 index 00000000..d06e1944 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/stereo_view_rendering.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/tessellation_program5.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/tessellation_program5.cpython-312.pyc new file mode 100644 index 00000000..835194f2 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/tessellation_program5.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/texgen_emboss.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/texgen_emboss.cpython-312.pyc new file mode 100644 index 00000000..fd59a412 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/texgen_emboss.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/texgen_reflection.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/texgen_reflection.cpython-312.pyc new file mode 100644 index 00000000..919085b4 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/texgen_reflection.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/texture_barrier.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/texture_barrier.cpython-312.pyc new file mode 100644 index 00000000..4d89779d Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/texture_barrier.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/texture_compression_vtc.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/texture_compression_vtc.cpython-312.pyc new file mode 100644 index 00000000..31dc1e3b Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/texture_compression_vtc.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/texture_env_combine4.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/texture_env_combine4.cpython-312.pyc new file mode 100644 index 00000000..69cf9e40 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/texture_env_combine4.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/texture_expand_normal.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/texture_expand_normal.cpython-312.pyc new file mode 100644 index 00000000..bfe6e446 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/texture_expand_normal.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/texture_multisample.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/texture_multisample.cpython-312.pyc new file mode 100644 index 00000000..e50db95b Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/texture_multisample.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/texture_rectangle.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/texture_rectangle.cpython-312.pyc new file mode 100644 index 00000000..ca1a03d6 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/texture_rectangle.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/texture_rectangle_compressed.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/texture_rectangle_compressed.cpython-312.pyc new file mode 100644 index 00000000..3d0199c0 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/texture_rectangle_compressed.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/texture_shader.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/texture_shader.cpython-312.pyc new file mode 100644 index 00000000..7e422020 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/texture_shader.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/texture_shader2.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/texture_shader2.cpython-312.pyc new file mode 100644 index 00000000..d523992c Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/texture_shader2.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/texture_shader3.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/texture_shader3.cpython-312.pyc new file mode 100644 index 00000000..0c2de0e6 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/texture_shader3.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/transform_feedback.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/transform_feedback.cpython-312.pyc new file mode 100644 index 00000000..8cd0b790 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/transform_feedback.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/transform_feedback2.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/transform_feedback2.cpython-312.pyc new file mode 100644 index 00000000..7a88e5c0 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/transform_feedback2.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/uniform_buffer_unified_memory.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/uniform_buffer_unified_memory.cpython-312.pyc new file mode 100644 index 00000000..0a0e95ea Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/uniform_buffer_unified_memory.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/vdpau_interop.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/vdpau_interop.cpython-312.pyc new file mode 100644 index 00000000..16b75870 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/vdpau_interop.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/vdpau_interop2.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/vdpau_interop2.cpython-312.pyc new file mode 100644 index 00000000..4febc832 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/vdpau_interop2.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/vertex_array_range.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/vertex_array_range.cpython-312.pyc new file mode 100644 index 00000000..0a07480c Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/vertex_array_range.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/vertex_array_range2.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/vertex_array_range2.cpython-312.pyc new file mode 100644 index 00000000..b022ec55 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/vertex_array_range2.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/vertex_attrib_integer_64bit.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/vertex_attrib_integer_64bit.cpython-312.pyc new file mode 100644 index 00000000..9b1068a2 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/vertex_attrib_integer_64bit.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/vertex_buffer_unified_memory.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/vertex_buffer_unified_memory.cpython-312.pyc new file mode 100644 index 00000000..a293a092 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/vertex_buffer_unified_memory.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/vertex_program.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/vertex_program.cpython-312.pyc new file mode 100644 index 00000000..d41e6941 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/vertex_program.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/vertex_program1_1.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/vertex_program1_1.cpython-312.pyc new file mode 100644 index 00000000..0dc4b10d Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/vertex_program1_1.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/vertex_program2.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/vertex_program2.cpython-312.pyc new file mode 100644 index 00000000..9b016918 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/vertex_program2.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/vertex_program2_option.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/vertex_program2_option.cpython-312.pyc new file mode 100644 index 00000000..657ed6fd Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/vertex_program2_option.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/vertex_program3.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/vertex_program3.cpython-312.pyc new file mode 100644 index 00000000..98afc08a Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/vertex_program3.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/vertex_program4.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/vertex_program4.cpython-312.pyc new file mode 100644 index 00000000..a91e4e0d Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/vertex_program4.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/video_capture.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/video_capture.cpython-312.pyc new file mode 100644 index 00000000..b9385e37 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/video_capture.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/viewport_array2.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/viewport_array2.cpython-312.pyc new file mode 100644 index 00000000..d7c0c6b3 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/viewport_array2.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/viewport_swizzle.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/viewport_swizzle.cpython-312.pyc new file mode 100644 index 00000000..908eee24 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/__pycache__/viewport_swizzle.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/alpha_to_coverage_dither_control.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/alpha_to_coverage_dither_control.py new file mode 100644 index 00000000..bc727d8c --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/alpha_to_coverage_dither_control.py @@ -0,0 +1,20 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_NV_alpha_to_coverage_dither_control' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_NV_alpha_to_coverage_dither_control',error_checker=_errors._error_checker) +GL_ALPHA_TO_COVERAGE_DITHER_DEFAULT_NV=_C('GL_ALPHA_TO_COVERAGE_DITHER_DEFAULT_NV',0x934D) +GL_ALPHA_TO_COVERAGE_DITHER_DISABLE_NV=_C('GL_ALPHA_TO_COVERAGE_DITHER_DISABLE_NV',0x934F) +GL_ALPHA_TO_COVERAGE_DITHER_ENABLE_NV=_C('GL_ALPHA_TO_COVERAGE_DITHER_ENABLE_NV',0x934E) +GL_ALPHA_TO_COVERAGE_DITHER_MODE_NV=_C('GL_ALPHA_TO_COVERAGE_DITHER_MODE_NV',0x92BF) +@_f +@_p.types(None,_cs.GLenum) +def glAlphaToCoverageDitherControlNV(mode):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/bindless_multi_draw_indirect.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/bindless_multi_draw_indirect.py new file mode 100644 index 00000000..9d87375a --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/bindless_multi_draw_indirect.py @@ -0,0 +1,20 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_NV_bindless_multi_draw_indirect' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_NV_bindless_multi_draw_indirect',error_checker=_errors._error_checker) + +@_f +@_p.types(None,_cs.GLenum,ctypes.c_void_p,_cs.GLsizei,_cs.GLsizei,_cs.GLint) +def glMultiDrawArraysIndirectBindlessNV(mode,indirect,drawCount,stride,vertexBufferCount):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,ctypes.c_void_p,_cs.GLsizei,_cs.GLsizei,_cs.GLint) +def glMultiDrawElementsIndirectBindlessNV(mode,type,indirect,drawCount,stride,vertexBufferCount):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/bindless_multi_draw_indirect_count.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/bindless_multi_draw_indirect_count.py new file mode 100644 index 00000000..f5f8c64c --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/bindless_multi_draw_indirect_count.py @@ -0,0 +1,20 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_NV_bindless_multi_draw_indirect_count' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_NV_bindless_multi_draw_indirect_count',error_checker=_errors._error_checker) + +@_f +@_p.types(None,_cs.GLenum,ctypes.c_void_p,_cs.GLsizei,_cs.GLsizei,_cs.GLsizei,_cs.GLint) +def glMultiDrawArraysIndirectBindlessCountNV(mode,indirect,drawCount,maxDrawCount,stride,vertexBufferCount):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,ctypes.c_void_p,_cs.GLsizei,_cs.GLsizei,_cs.GLsizei,_cs.GLint) +def glMultiDrawElementsIndirectBindlessCountNV(mode,type,indirect,drawCount,maxDrawCount,stride,vertexBufferCount):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/bindless_texture.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/bindless_texture.py new file mode 100644 index 00000000..2b3b2271 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/bindless_texture.py @@ -0,0 +1,53 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_NV_bindless_texture' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_NV_bindless_texture',error_checker=_errors._error_checker) + +@_f +@_p.types(_cs.GLuint64,_cs.GLuint,_cs.GLint,_cs.GLboolean,_cs.GLint,_cs.GLenum) +def glGetImageHandleNV(texture,level,layered,layer,format):pass +@_f +@_p.types(_cs.GLuint64,_cs.GLuint) +def glGetTextureHandleNV(texture):pass +@_f +@_p.types(_cs.GLuint64,_cs.GLuint,_cs.GLuint) +def glGetTextureSamplerHandleNV(texture,sampler):pass +@_f +@_p.types(_cs.GLboolean,_cs.GLuint64) +def glIsImageHandleResidentNV(handle):pass +@_f +@_p.types(_cs.GLboolean,_cs.GLuint64) +def glIsTextureHandleResidentNV(handle):pass +@_f +@_p.types(None,_cs.GLuint64) +def glMakeImageHandleNonResidentNV(handle):pass +@_f +@_p.types(None,_cs.GLuint64,_cs.GLenum) +def glMakeImageHandleResidentNV(handle,access):pass +@_f +@_p.types(None,_cs.GLuint64) +def glMakeTextureHandleNonResidentNV(handle):pass +@_f +@_p.types(None,_cs.GLuint64) +def glMakeTextureHandleResidentNV(handle):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLuint64) +def glProgramUniformHandleui64NV(program,location,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLuint64Array) +def glProgramUniformHandleui64vNV(program,location,count,values):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLuint64) +def glUniformHandleui64NV(location,value):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLsizei,arrays.GLuint64Array) +def glUniformHandleui64vNV(location,count,value):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/blend_equation_advanced.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/blend_equation_advanced.py new file mode 100644 index 00000000..e5d79b19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/blend_equation_advanced.py @@ -0,0 +1,70 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_NV_blend_equation_advanced' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_NV_blend_equation_advanced',error_checker=_errors._error_checker) +GL_BLEND_OVERLAP_NV=_C('GL_BLEND_OVERLAP_NV',0x9281) +GL_BLEND_PREMULTIPLIED_SRC_NV=_C('GL_BLEND_PREMULTIPLIED_SRC_NV',0x9280) +GL_BLUE_NV=_C('GL_BLUE_NV',0x1905) +GL_COLORBURN_NV=_C('GL_COLORBURN_NV',0x929A) +GL_COLORDODGE_NV=_C('GL_COLORDODGE_NV',0x9299) +GL_CONJOINT_NV=_C('GL_CONJOINT_NV',0x9284) +GL_CONTRAST_NV=_C('GL_CONTRAST_NV',0x92A1) +GL_DARKEN_NV=_C('GL_DARKEN_NV',0x9297) +GL_DIFFERENCE_NV=_C('GL_DIFFERENCE_NV',0x929E) +GL_DISJOINT_NV=_C('GL_DISJOINT_NV',0x9283) +GL_DST_ATOP_NV=_C('GL_DST_ATOP_NV',0x928F) +GL_DST_IN_NV=_C('GL_DST_IN_NV',0x928B) +GL_DST_NV=_C('GL_DST_NV',0x9287) +GL_DST_OUT_NV=_C('GL_DST_OUT_NV',0x928D) +GL_DST_OVER_NV=_C('GL_DST_OVER_NV',0x9289) +GL_EXCLUSION_NV=_C('GL_EXCLUSION_NV',0x92A0) +GL_GREEN_NV=_C('GL_GREEN_NV',0x1904) +GL_HARDLIGHT_NV=_C('GL_HARDLIGHT_NV',0x929B) +GL_HARDMIX_NV=_C('GL_HARDMIX_NV',0x92A9) +GL_HSL_COLOR_NV=_C('GL_HSL_COLOR_NV',0x92AF) +GL_HSL_HUE_NV=_C('GL_HSL_HUE_NV',0x92AD) +GL_HSL_LUMINOSITY_NV=_C('GL_HSL_LUMINOSITY_NV',0x92B0) +GL_HSL_SATURATION_NV=_C('GL_HSL_SATURATION_NV',0x92AE) +GL_INVERT=_C('GL_INVERT',0x150A) +GL_INVERT_OVG_NV=_C('GL_INVERT_OVG_NV',0x92B4) +GL_INVERT_RGB_NV=_C('GL_INVERT_RGB_NV',0x92A3) +GL_LIGHTEN_NV=_C('GL_LIGHTEN_NV',0x9298) +GL_LINEARBURN_NV=_C('GL_LINEARBURN_NV',0x92A5) +GL_LINEARDODGE_NV=_C('GL_LINEARDODGE_NV',0x92A4) +GL_LINEARLIGHT_NV=_C('GL_LINEARLIGHT_NV',0x92A7) +GL_MINUS_CLAMPED_NV=_C('GL_MINUS_CLAMPED_NV',0x92B3) +GL_MINUS_NV=_C('GL_MINUS_NV',0x929F) +GL_MULTIPLY_NV=_C('GL_MULTIPLY_NV',0x9294) +GL_OVERLAY_NV=_C('GL_OVERLAY_NV',0x9296) +GL_PINLIGHT_NV=_C('GL_PINLIGHT_NV',0x92A8) +GL_PLUS_CLAMPED_ALPHA_NV=_C('GL_PLUS_CLAMPED_ALPHA_NV',0x92B2) +GL_PLUS_CLAMPED_NV=_C('GL_PLUS_CLAMPED_NV',0x92B1) +GL_PLUS_DARKER_NV=_C('GL_PLUS_DARKER_NV',0x9292) +GL_PLUS_NV=_C('GL_PLUS_NV',0x9291) +GL_RED_NV=_C('GL_RED_NV',0x1903) +GL_SCREEN_NV=_C('GL_SCREEN_NV',0x9295) +GL_SOFTLIGHT_NV=_C('GL_SOFTLIGHT_NV',0x929C) +GL_SRC_ATOP_NV=_C('GL_SRC_ATOP_NV',0x928E) +GL_SRC_IN_NV=_C('GL_SRC_IN_NV',0x928A) +GL_SRC_NV=_C('GL_SRC_NV',0x9286) +GL_SRC_OUT_NV=_C('GL_SRC_OUT_NV',0x928C) +GL_SRC_OVER_NV=_C('GL_SRC_OVER_NV',0x9288) +GL_UNCORRELATED_NV=_C('GL_UNCORRELATED_NV',0x9282) +GL_VIVIDLIGHT_NV=_C('GL_VIVIDLIGHT_NV',0x92A6) +GL_XOR_NV=_C('GL_XOR_NV',0x1506) +GL_ZERO=_C('GL_ZERO',0) +@_f +@_p.types(None,) +def glBlendBarrierNV():pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLint) +def glBlendParameteriNV(pname,value):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/blend_equation_advanced_coherent.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/blend_equation_advanced_coherent.py new file mode 100644 index 00000000..f926ea0b --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/blend_equation_advanced_coherent.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_NV_blend_equation_advanced_coherent' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_NV_blend_equation_advanced_coherent',error_checker=_errors._error_checker) +GL_BLEND_ADVANCED_COHERENT_NV=_C('GL_BLEND_ADVANCED_COHERENT_NV',0x9285) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/blend_minmax_factor.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/blend_minmax_factor.py new file mode 100644 index 00000000..9dd14f00 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/blend_minmax_factor.py @@ -0,0 +1,16 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_NV_blend_minmax_factor' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_NV_blend_minmax_factor',error_checker=_errors._error_checker) +GL_FACTOR_MAX_AMD=_C('GL_FACTOR_MAX_AMD',0x901D) +GL_FACTOR_MIN_AMD=_C('GL_FACTOR_MIN_AMD',0x901C) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/blend_square.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/blend_square.py new file mode 100644 index 00000000..6bd9dfb1 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/blend_square.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_NV_blend_square' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_NV_blend_square',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/clip_space_w_scaling.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/clip_space_w_scaling.py new file mode 100644 index 00000000..dc2a921e --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/clip_space_w_scaling.py @@ -0,0 +1,19 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_NV_clip_space_w_scaling' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_NV_clip_space_w_scaling',error_checker=_errors._error_checker) +GL_VIEWPORT_POSITION_W_SCALE_NV=_C('GL_VIEWPORT_POSITION_W_SCALE_NV',0x937C) +GL_VIEWPORT_POSITION_W_SCALE_X_COEFF_NV=_C('GL_VIEWPORT_POSITION_W_SCALE_X_COEFF_NV',0x937D) +GL_VIEWPORT_POSITION_W_SCALE_Y_COEFF_NV=_C('GL_VIEWPORT_POSITION_W_SCALE_Y_COEFF_NV',0x937E) +@_f +@_p.types(None,_cs.GLuint,_cs.GLfloat,_cs.GLfloat) +def glViewportPositionWScaleNV(index,xcoeff,ycoeff):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/command_list.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/command_list.py new file mode 100644 index 00000000..841ff7ac --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/command_list.py @@ -0,0 +1,83 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_NV_command_list' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_NV_command_list',error_checker=_errors._error_checker) +GL_ALPHA_REF_COMMAND_NV=_C('GL_ALPHA_REF_COMMAND_NV',0x000F) +GL_ATTRIBUTE_ADDRESS_COMMAND_NV=_C('GL_ATTRIBUTE_ADDRESS_COMMAND_NV',0x0009) +GL_BLEND_COLOR_COMMAND_NV=_C('GL_BLEND_COLOR_COMMAND_NV',0x000B) +GL_DRAW_ARRAYS_COMMAND_NV=_C('GL_DRAW_ARRAYS_COMMAND_NV',0x0003) +GL_DRAW_ARRAYS_INSTANCED_COMMAND_NV=_C('GL_DRAW_ARRAYS_INSTANCED_COMMAND_NV',0x0007) +GL_DRAW_ARRAYS_STRIP_COMMAND_NV=_C('GL_DRAW_ARRAYS_STRIP_COMMAND_NV',0x0005) +GL_DRAW_ELEMENTS_COMMAND_NV=_C('GL_DRAW_ELEMENTS_COMMAND_NV',0x0002) +GL_DRAW_ELEMENTS_INSTANCED_COMMAND_NV=_C('GL_DRAW_ELEMENTS_INSTANCED_COMMAND_NV',0x0006) +GL_DRAW_ELEMENTS_STRIP_COMMAND_NV=_C('GL_DRAW_ELEMENTS_STRIP_COMMAND_NV',0x0004) +GL_ELEMENT_ADDRESS_COMMAND_NV=_C('GL_ELEMENT_ADDRESS_COMMAND_NV',0x0008) +GL_FRONT_FACE_COMMAND_NV=_C('GL_FRONT_FACE_COMMAND_NV',0x0012) +GL_LINE_WIDTH_COMMAND_NV=_C('GL_LINE_WIDTH_COMMAND_NV',0x000D) +GL_NOP_COMMAND_NV=_C('GL_NOP_COMMAND_NV',0x0001) +GL_POLYGON_OFFSET_COMMAND_NV=_C('GL_POLYGON_OFFSET_COMMAND_NV',0x000E) +GL_SCISSOR_COMMAND_NV=_C('GL_SCISSOR_COMMAND_NV',0x0011) +GL_STENCIL_REF_COMMAND_NV=_C('GL_STENCIL_REF_COMMAND_NV',0x000C) +GL_TERMINATE_SEQUENCE_COMMAND_NV=_C('GL_TERMINATE_SEQUENCE_COMMAND_NV',0x0000) +GL_UNIFORM_ADDRESS_COMMAND_NV=_C('GL_UNIFORM_ADDRESS_COMMAND_NV',0x000A) +GL_VIEWPORT_COMMAND_NV=_C('GL_VIEWPORT_COMMAND_NV',0x0010) +@_f +@_p.types(None,_cs.GLuint) +def glCallCommandListNV(list):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint) +def glCommandListSegmentsNV(list,segments):pass +@_f +@_p.types(None,_cs.GLuint) +def glCompileCommandListNV(list):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray) +def glCreateCommandListsNV(n,lists):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray) +def glCreateStatesNV(n,states):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray) +def glDeleteCommandListsNV(n,lists):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray) +def glDeleteStatesNV(n,states):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLuint64Array,arrays.GLsizeiArray,_cs.GLuint) +def glDrawCommandsAddressNV(primitiveMode,indirects,sizes,count):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,ctypes.POINTER(_cs.GLintptr),arrays.GLsizeiArray,_cs.GLuint) +def glDrawCommandsNV(primitiveMode,buffer,indirects,sizes,count):pass +@_f +@_p.types(None,arrays.GLuint64Array,arrays.GLsizeiArray,arrays.GLuintArray,arrays.GLuintArray,_cs.GLuint) +def glDrawCommandsStatesAddressNV(indirects,sizes,states,fbos,count):pass +@_f +@_p.types(None,_cs.GLuint,ctypes.POINTER(_cs.GLintptr),arrays.GLsizeiArray,arrays.GLuintArray,arrays.GLuintArray,_cs.GLuint) +def glDrawCommandsStatesNV(buffer,indirects,sizes,states,fbos,count):pass +@_f +@_p.types(_cs.GLuint,_cs.GLenum,_cs.GLuint) +def glGetCommandHeaderNV(tokenID,size):pass +@_f +@_p.types(_cs.GLushort,_cs.GLenum) +def glGetStageIndexNV(shadertype):pass +@_f +@_p.types(_cs.GLboolean,_cs.GLuint) +def glIsCommandListNV(list):pass +@_f +@_p.types(_cs.GLboolean,_cs.GLuint) +def glIsStateNV(state):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,arrays.GLvoidpArray,arrays.GLsizeiArray,arrays.GLuintArray,arrays.GLuintArray,_cs.GLuint) +def glListDrawCommandsStatesClientNV(list,segment,indirects,sizes,states,fbos,count):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum) +def glStateCaptureNV(state,mode):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/compute_program5.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/compute_program5.py new file mode 100644 index 00000000..7451e15d --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/compute_program5.py @@ -0,0 +1,16 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_NV_compute_program5' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_NV_compute_program5',error_checker=_errors._error_checker) +GL_COMPUTE_PROGRAM_NV=_C('GL_COMPUTE_PROGRAM_NV',0x90FB) +GL_COMPUTE_PROGRAM_PARAMETER_BUFFER_NV=_C('GL_COMPUTE_PROGRAM_PARAMETER_BUFFER_NV',0x90FC) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/compute_shader_derivatives.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/compute_shader_derivatives.py new file mode 100644 index 00000000..39e67139 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/compute_shader_derivatives.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_NV_compute_shader_derivatives' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_NV_compute_shader_derivatives',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/conditional_render.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/conditional_render.py new file mode 100644 index 00000000..eb052750 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/conditional_render.py @@ -0,0 +1,23 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_NV_conditional_render' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_NV_conditional_render',error_checker=_errors._error_checker) +GL_QUERY_BY_REGION_NO_WAIT_NV=_C('GL_QUERY_BY_REGION_NO_WAIT_NV',0x8E16) +GL_QUERY_BY_REGION_WAIT_NV=_C('GL_QUERY_BY_REGION_WAIT_NV',0x8E15) +GL_QUERY_NO_WAIT_NV=_C('GL_QUERY_NO_WAIT_NV',0x8E14) +GL_QUERY_WAIT_NV=_C('GL_QUERY_WAIT_NV',0x8E13) +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum) +def glBeginConditionalRenderNV(id,mode):pass +@_f +@_p.types(None,) +def glEndConditionalRenderNV():pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/conservative_raster.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/conservative_raster.py new file mode 100644 index 00000000..c6cb36b6 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/conservative_raster.py @@ -0,0 +1,20 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_NV_conservative_raster' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_NV_conservative_raster',error_checker=_errors._error_checker) +GL_CONSERVATIVE_RASTERIZATION_NV=_C('GL_CONSERVATIVE_RASTERIZATION_NV',0x9346) +GL_MAX_SUBPIXEL_PRECISION_BIAS_BITS_NV=_C('GL_MAX_SUBPIXEL_PRECISION_BIAS_BITS_NV',0x9349) +GL_SUBPIXEL_PRECISION_BIAS_X_BITS_NV=_C('GL_SUBPIXEL_PRECISION_BIAS_X_BITS_NV',0x9347) +GL_SUBPIXEL_PRECISION_BIAS_Y_BITS_NV=_C('GL_SUBPIXEL_PRECISION_BIAS_Y_BITS_NV',0x9348) +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint) +def glSubpixelPrecisionBiasNV(xbits,ybits):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/conservative_raster_dilate.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/conservative_raster_dilate.py new file mode 100644 index 00000000..e54babb7 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/conservative_raster_dilate.py @@ -0,0 +1,19 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_NV_conservative_raster_dilate' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_NV_conservative_raster_dilate',error_checker=_errors._error_checker) +GL_CONSERVATIVE_RASTER_DILATE_GRANULARITY_NV=_C('GL_CONSERVATIVE_RASTER_DILATE_GRANULARITY_NV',0x937B) +GL_CONSERVATIVE_RASTER_DILATE_NV=_C('GL_CONSERVATIVE_RASTER_DILATE_NV',0x9379) +GL_CONSERVATIVE_RASTER_DILATE_RANGE_NV=_C('GL_CONSERVATIVE_RASTER_DILATE_RANGE_NV',0x937A) +@_f +@_p.types(None,_cs.GLenum,_cs.GLfloat) +def glConservativeRasterParameterfNV(pname,value):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/conservative_raster_pre_snap.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/conservative_raster_pre_snap.py new file mode 100644 index 00000000..78589001 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/conservative_raster_pre_snap.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_NV_conservative_raster_pre_snap' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_NV_conservative_raster_pre_snap',error_checker=_errors._error_checker) +GL_CONSERVATIVE_RASTER_MODE_PRE_SNAP_NV=_C('GL_CONSERVATIVE_RASTER_MODE_PRE_SNAP_NV',0x9550) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/conservative_raster_pre_snap_triangles.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/conservative_raster_pre_snap_triangles.py new file mode 100644 index 00000000..428452e5 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/conservative_raster_pre_snap_triangles.py @@ -0,0 +1,20 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_NV_conservative_raster_pre_snap_triangles' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_NV_conservative_raster_pre_snap_triangles',error_checker=_errors._error_checker) +GL_CONSERVATIVE_RASTER_MODE_NV=_C('GL_CONSERVATIVE_RASTER_MODE_NV',0x954D) +GL_CONSERVATIVE_RASTER_MODE_NV=_C('GL_CONSERVATIVE_RASTER_MODE_NV',0x954D) +GL_CONSERVATIVE_RASTER_MODE_POST_SNAP_NV=_C('GL_CONSERVATIVE_RASTER_MODE_POST_SNAP_NV',0x954E) +GL_CONSERVATIVE_RASTER_MODE_PRE_SNAP_TRIANGLES_NV=_C('GL_CONSERVATIVE_RASTER_MODE_PRE_SNAP_TRIANGLES_NV',0x954F) +@_f +@_p.types(None,_cs.GLenum,_cs.GLint) +def glConservativeRasterParameteriNV(pname,param):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/conservative_raster_underestimation.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/conservative_raster_underestimation.py new file mode 100644 index 00000000..b795c50e --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/conservative_raster_underestimation.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_NV_conservative_raster_underestimation' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_NV_conservative_raster_underestimation',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/copy_depth_to_color.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/copy_depth_to_color.py new file mode 100644 index 00000000..29a59965 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/copy_depth_to_color.py @@ -0,0 +1,16 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_NV_copy_depth_to_color' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_NV_copy_depth_to_color',error_checker=_errors._error_checker) +GL_DEPTH_STENCIL_TO_BGRA_NV=_C('GL_DEPTH_STENCIL_TO_BGRA_NV',0x886F) +GL_DEPTH_STENCIL_TO_RGBA_NV=_C('GL_DEPTH_STENCIL_TO_RGBA_NV',0x886E) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/copy_image.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/copy_image.py new file mode 100644 index 00000000..71c4cb90 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/copy_image.py @@ -0,0 +1,17 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_NV_copy_image' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_NV_copy_image',error_checker=_errors._error_checker) + +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLuint,_cs.GLenum,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLsizei,_cs.GLsizei) +def glCopyImageSubDataNV(srcName,srcTarget,srcLevel,srcX,srcY,srcZ,dstName,dstTarget,dstLevel,dstX,dstY,dstZ,width,height,depth):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/deep_texture3D.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/deep_texture3D.py new file mode 100644 index 00000000..13ea4f72 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/deep_texture3D.py @@ -0,0 +1,16 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_NV_deep_texture3D' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_NV_deep_texture3D',error_checker=_errors._error_checker) +GL_MAX_DEEP_3D_TEXTURE_DEPTH_NV=_C('GL_MAX_DEEP_3D_TEXTURE_DEPTH_NV',0x90D1) +GL_MAX_DEEP_3D_TEXTURE_WIDTH_HEIGHT_NV=_C('GL_MAX_DEEP_3D_TEXTURE_WIDTH_HEIGHT_NV',0x90D0) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/depth_buffer_float.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/depth_buffer_float.py new file mode 100644 index 00000000..baa1c543 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/depth_buffer_float.py @@ -0,0 +1,26 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_NV_depth_buffer_float' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_NV_depth_buffer_float',error_checker=_errors._error_checker) +GL_DEPTH32F_STENCIL8_NV=_C('GL_DEPTH32F_STENCIL8_NV',0x8DAC) +GL_DEPTH_BUFFER_FLOAT_MODE_NV=_C('GL_DEPTH_BUFFER_FLOAT_MODE_NV',0x8DAF) +GL_DEPTH_COMPONENT32F_NV=_C('GL_DEPTH_COMPONENT32F_NV',0x8DAB) +GL_FLOAT_32_UNSIGNED_INT_24_8_REV_NV=_C('GL_FLOAT_32_UNSIGNED_INT_24_8_REV_NV',0x8DAD) +@_f +@_p.types(None,_cs.GLdouble) +def glClearDepthdNV(depth):pass +@_f +@_p.types(None,_cs.GLdouble,_cs.GLdouble) +def glDepthBoundsdNV(zmin,zmax):pass +@_f +@_p.types(None,_cs.GLdouble,_cs.GLdouble) +def glDepthRangedNV(zNear,zFar):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/depth_clamp.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/depth_clamp.py new file mode 100644 index 00000000..03e147ff --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/depth_clamp.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_NV_depth_clamp' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_NV_depth_clamp',error_checker=_errors._error_checker) +GL_DEPTH_CLAMP_NV=_C('GL_DEPTH_CLAMP_NV',0x864F) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/draw_texture.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/draw_texture.py new file mode 100644 index 00000000..fc22a160 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/draw_texture.py @@ -0,0 +1,17 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_NV_draw_texture' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_NV_draw_texture',error_checker=_errors._error_checker) + +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat) +def glDrawTextureNV(texture,sampler,x0,y0,x1,y1,z,s0,t0,s1,t1):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/draw_vulkan_image.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/draw_vulkan_image.py new file mode 100644 index 00000000..5687e3fe --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/draw_vulkan_image.py @@ -0,0 +1,29 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_NV_draw_vulkan_image' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_NV_draw_vulkan_image',error_checker=_errors._error_checker) + +@_f +@_p.types(None,_cs.GLuint64,_cs.GLuint,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat) +def glDrawVkImageNV(vkImage,sampler,x0,y0,x1,y1,z,s0,t0,s1,t1):pass +@_f +@_p.types(_cs.GLVULKANPROCNV,arrays.GLcharArray) +def glGetVkProcAddrNV(name):pass +@_f +@_p.types(None,_cs.GLuint64) +def glSignalVkFenceNV(vkFence):pass +@_f +@_p.types(None,_cs.GLuint64) +def glSignalVkSemaphoreNV(vkSemaphore):pass +@_f +@_p.types(None,_cs.GLuint64) +def glWaitVkSemaphoreNV(vkSemaphore):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/evaluators.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/evaluators.py new file mode 100644 index 00000000..50474838 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/evaluators.py @@ -0,0 +1,64 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_NV_evaluators' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_NV_evaluators',error_checker=_errors._error_checker) +GL_EVAL_2D_NV=_C('GL_EVAL_2D_NV',0x86C0) +GL_EVAL_FRACTIONAL_TESSELLATION_NV=_C('GL_EVAL_FRACTIONAL_TESSELLATION_NV',0x86C5) +GL_EVAL_TRIANGULAR_2D_NV=_C('GL_EVAL_TRIANGULAR_2D_NV',0x86C1) +GL_EVAL_VERTEX_ATTRIB0_NV=_C('GL_EVAL_VERTEX_ATTRIB0_NV',0x86C6) +GL_EVAL_VERTEX_ATTRIB10_NV=_C('GL_EVAL_VERTEX_ATTRIB10_NV',0x86D0) +GL_EVAL_VERTEX_ATTRIB11_NV=_C('GL_EVAL_VERTEX_ATTRIB11_NV',0x86D1) +GL_EVAL_VERTEX_ATTRIB12_NV=_C('GL_EVAL_VERTEX_ATTRIB12_NV',0x86D2) +GL_EVAL_VERTEX_ATTRIB13_NV=_C('GL_EVAL_VERTEX_ATTRIB13_NV',0x86D3) +GL_EVAL_VERTEX_ATTRIB14_NV=_C('GL_EVAL_VERTEX_ATTRIB14_NV',0x86D4) +GL_EVAL_VERTEX_ATTRIB15_NV=_C('GL_EVAL_VERTEX_ATTRIB15_NV',0x86D5) +GL_EVAL_VERTEX_ATTRIB1_NV=_C('GL_EVAL_VERTEX_ATTRIB1_NV',0x86C7) +GL_EVAL_VERTEX_ATTRIB2_NV=_C('GL_EVAL_VERTEX_ATTRIB2_NV',0x86C8) +GL_EVAL_VERTEX_ATTRIB3_NV=_C('GL_EVAL_VERTEX_ATTRIB3_NV',0x86C9) +GL_EVAL_VERTEX_ATTRIB4_NV=_C('GL_EVAL_VERTEX_ATTRIB4_NV',0x86CA) +GL_EVAL_VERTEX_ATTRIB5_NV=_C('GL_EVAL_VERTEX_ATTRIB5_NV',0x86CB) +GL_EVAL_VERTEX_ATTRIB6_NV=_C('GL_EVAL_VERTEX_ATTRIB6_NV',0x86CC) +GL_EVAL_VERTEX_ATTRIB7_NV=_C('GL_EVAL_VERTEX_ATTRIB7_NV',0x86CD) +GL_EVAL_VERTEX_ATTRIB8_NV=_C('GL_EVAL_VERTEX_ATTRIB8_NV',0x86CE) +GL_EVAL_VERTEX_ATTRIB9_NV=_C('GL_EVAL_VERTEX_ATTRIB9_NV',0x86CF) +GL_MAP_ATTRIB_U_ORDER_NV=_C('GL_MAP_ATTRIB_U_ORDER_NV',0x86C3) +GL_MAP_ATTRIB_V_ORDER_NV=_C('GL_MAP_ATTRIB_V_ORDER_NV',0x86C4) +GL_MAP_TESSELLATION_NV=_C('GL_MAP_TESSELLATION_NV',0x86C2) +GL_MAX_MAP_TESSELLATION_NV=_C('GL_MAX_MAP_TESSELLATION_NV',0x86D6) +GL_MAX_RATIONAL_EVAL_ORDER_NV=_C('GL_MAX_RATIONAL_EVAL_ORDER_NV',0x86D7) +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum) +def glEvalMapsNV(target,mode):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,_cs.GLenum,arrays.GLfloatArray) +def glGetMapAttribParameterfvNV(target,index,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,_cs.GLenum,arrays.GLintArray) +def glGetMapAttribParameterivNV(target,index,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,_cs.GLenum,_cs.GLsizei,_cs.GLsizei,_cs.GLboolean,ctypes.c_void_p) +def glGetMapControlPointsNV(target,index,type,ustride,vstride,packed,points):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLfloatArray) +def glGetMapParameterfvNV(target,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLintArray) +def glGetMapParameterivNV(target,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,_cs.GLenum,_cs.GLsizei,_cs.GLsizei,_cs.GLint,_cs.GLint,_cs.GLboolean,ctypes.c_void_p) +def glMapControlPointsNV(target,index,type,ustride,vstride,uorder,vorder,packed,points):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLfloatArray) +def glMapParameterfvNV(target,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLintArray) +def glMapParameterivNV(target,pname,params):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/explicit_multisample.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/explicit_multisample.py new file mode 100644 index 00000000..96ffb890 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/explicit_multisample.py @@ -0,0 +1,32 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_NV_explicit_multisample' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_NV_explicit_multisample',error_checker=_errors._error_checker) +GL_INT_SAMPLER_RENDERBUFFER_NV=_C('GL_INT_SAMPLER_RENDERBUFFER_NV',0x8E57) +GL_MAX_SAMPLE_MASK_WORDS_NV=_C('GL_MAX_SAMPLE_MASK_WORDS_NV',0x8E59) +GL_SAMPLER_RENDERBUFFER_NV=_C('GL_SAMPLER_RENDERBUFFER_NV',0x8E56) +GL_SAMPLE_MASK_NV=_C('GL_SAMPLE_MASK_NV',0x8E51) +GL_SAMPLE_MASK_VALUE_NV=_C('GL_SAMPLE_MASK_VALUE_NV',0x8E52) +GL_SAMPLE_POSITION_NV=_C('GL_SAMPLE_POSITION_NV',0x8E50) +GL_TEXTURE_BINDING_RENDERBUFFER_NV=_C('GL_TEXTURE_BINDING_RENDERBUFFER_NV',0x8E53) +GL_TEXTURE_RENDERBUFFER_DATA_STORE_BINDING_NV=_C('GL_TEXTURE_RENDERBUFFER_DATA_STORE_BINDING_NV',0x8E54) +GL_TEXTURE_RENDERBUFFER_NV=_C('GL_TEXTURE_RENDERBUFFER_NV',0x8E55) +GL_UNSIGNED_INT_SAMPLER_RENDERBUFFER_NV=_C('GL_UNSIGNED_INT_SAMPLER_RENDERBUFFER_NV',0x8E58) +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,arrays.GLfloatArray) +def glGetMultisamplefvNV(pname,index,val):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLbitfield) +def glSampleMaskIndexedNV(index,mask):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint) +def glTexRenderbufferNV(target,renderbuffer):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/fence.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/fence.py new file mode 100644 index 00000000..601dc369 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/fence.py @@ -0,0 +1,37 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_NV_fence' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_NV_fence',error_checker=_errors._error_checker) +GL_ALL_COMPLETED_NV=_C('GL_ALL_COMPLETED_NV',0x84F2) +GL_FENCE_CONDITION_NV=_C('GL_FENCE_CONDITION_NV',0x84F4) +GL_FENCE_STATUS_NV=_C('GL_FENCE_STATUS_NV',0x84F3) +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray) +def glDeleteFencesNV(n,fences):pass +@_f +@_p.types(None,_cs.GLuint) +def glFinishFenceNV(fence):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray) +def glGenFencesNV(n,fences):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLintArray) +def glGetFenceivNV(fence,pname,params):pass +@_f +@_p.types(_cs.GLboolean,_cs.GLuint) +def glIsFenceNV(fence):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum) +def glSetFenceNV(fence,condition):pass +@_f +@_p.types(_cs.GLboolean,_cs.GLuint) +def glTestFenceNV(fence):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/fill_rectangle.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/fill_rectangle.py new file mode 100644 index 00000000..b4c64f9e --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/fill_rectangle.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_NV_fill_rectangle' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_NV_fill_rectangle',error_checker=_errors._error_checker) +GL_FILL_RECTANGLE_NV=_C('GL_FILL_RECTANGLE_NV',0x933C) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/float_buffer.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/float_buffer.py new file mode 100644 index 00000000..abbeb7c3 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/float_buffer.py @@ -0,0 +1,29 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_NV_float_buffer' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_NV_float_buffer',error_checker=_errors._error_checker) +GL_FLOAT_CLEAR_COLOR_VALUE_NV=_C('GL_FLOAT_CLEAR_COLOR_VALUE_NV',0x888D) +GL_FLOAT_R16_NV=_C('GL_FLOAT_R16_NV',0x8884) +GL_FLOAT_R32_NV=_C('GL_FLOAT_R32_NV',0x8885) +GL_FLOAT_RG16_NV=_C('GL_FLOAT_RG16_NV',0x8886) +GL_FLOAT_RG32_NV=_C('GL_FLOAT_RG32_NV',0x8887) +GL_FLOAT_RGB16_NV=_C('GL_FLOAT_RGB16_NV',0x8888) +GL_FLOAT_RGB32_NV=_C('GL_FLOAT_RGB32_NV',0x8889) +GL_FLOAT_RGBA16_NV=_C('GL_FLOAT_RGBA16_NV',0x888A) +GL_FLOAT_RGBA32_NV=_C('GL_FLOAT_RGBA32_NV',0x888B) +GL_FLOAT_RGBA_MODE_NV=_C('GL_FLOAT_RGBA_MODE_NV',0x888E) +GL_FLOAT_RGBA_NV=_C('GL_FLOAT_RGBA_NV',0x8883) +GL_FLOAT_RGB_NV=_C('GL_FLOAT_RGB_NV',0x8882) +GL_FLOAT_RG_NV=_C('GL_FLOAT_RG_NV',0x8881) +GL_FLOAT_R_NV=_C('GL_FLOAT_R_NV',0x8880) +GL_TEXTURE_FLOAT_COMPONENTS_NV=_C('GL_TEXTURE_FLOAT_COMPONENTS_NV',0x888C) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/fog_distance.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/fog_distance.py new file mode 100644 index 00000000..32e1c264 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/fog_distance.py @@ -0,0 +1,18 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_NV_fog_distance' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_NV_fog_distance',error_checker=_errors._error_checker) +GL_EYE_PLANE=_C('GL_EYE_PLANE',0x2502) +GL_EYE_PLANE_ABSOLUTE_NV=_C('GL_EYE_PLANE_ABSOLUTE_NV',0x855C) +GL_EYE_RADIAL_NV=_C('GL_EYE_RADIAL_NV',0x855B) +GL_FOG_DISTANCE_MODE_NV=_C('GL_FOG_DISTANCE_MODE_NV',0x855A) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/fragment_coverage_to_color.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/fragment_coverage_to_color.py new file mode 100644 index 00000000..03c0fd60 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/fragment_coverage_to_color.py @@ -0,0 +1,18 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_NV_fragment_coverage_to_color' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_NV_fragment_coverage_to_color',error_checker=_errors._error_checker) +GL_FRAGMENT_COVERAGE_COLOR_NV=_C('GL_FRAGMENT_COVERAGE_COLOR_NV',0x92DE) +GL_FRAGMENT_COVERAGE_TO_COLOR_NV=_C('GL_FRAGMENT_COVERAGE_TO_COLOR_NV',0x92DD) +@_f +@_p.types(None,_cs.GLuint) +def glFragmentCoverageColorNV(color):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/fragment_program.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/fragment_program.py new file mode 100644 index 00000000..2c3ab369 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/fragment_program.py @@ -0,0 +1,37 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_NV_fragment_program' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_NV_fragment_program',error_checker=_errors._error_checker) +GL_FRAGMENT_PROGRAM_BINDING_NV=_C('GL_FRAGMENT_PROGRAM_BINDING_NV',0x8873) +GL_FRAGMENT_PROGRAM_NV=_C('GL_FRAGMENT_PROGRAM_NV',0x8870) +GL_MAX_FRAGMENT_PROGRAM_LOCAL_PARAMETERS_NV=_C('GL_MAX_FRAGMENT_PROGRAM_LOCAL_PARAMETERS_NV',0x8868) +GL_MAX_TEXTURE_COORDS_NV=_C('GL_MAX_TEXTURE_COORDS_NV',0x8871) +GL_MAX_TEXTURE_IMAGE_UNITS_NV=_C('GL_MAX_TEXTURE_IMAGE_UNITS_NV',0x8872) +GL_PROGRAM_ERROR_STRING_NV=_C('GL_PROGRAM_ERROR_STRING_NV',0x8874) +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizei,arrays.GLubyteArray,arrays.GLdoubleArray) +def glGetProgramNamedParameterdvNV(id,len,name,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizei,arrays.GLubyteArray,arrays.GLfloatArray) +def glGetProgramNamedParameterfvNV(id,len,name,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizei,arrays.GLubyteArray,_cs.GLdouble,_cs.GLdouble,_cs.GLdouble,_cs.GLdouble) +def glProgramNamedParameter4dNV(id,len,name,x,y,z,w):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizei,arrays.GLubyteArray,arrays.GLdoubleArray) +def glProgramNamedParameter4dvNV(id,len,name,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizei,arrays.GLubyteArray,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat) +def glProgramNamedParameter4fNV(id,len,name,x,y,z,w):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizei,arrays.GLubyteArray,arrays.GLfloatArray) +def glProgramNamedParameter4fvNV(id,len,name,v):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/fragment_program2.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/fragment_program2.py new file mode 100644 index 00000000..3f7e82c1 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/fragment_program2.py @@ -0,0 +1,19 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_NV_fragment_program2' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_NV_fragment_program2',error_checker=_errors._error_checker) +GL_MAX_PROGRAM_CALL_DEPTH_NV=_C('GL_MAX_PROGRAM_CALL_DEPTH_NV',0x88F5) +GL_MAX_PROGRAM_EXEC_INSTRUCTIONS_NV=_C('GL_MAX_PROGRAM_EXEC_INSTRUCTIONS_NV',0x88F4) +GL_MAX_PROGRAM_IF_DEPTH_NV=_C('GL_MAX_PROGRAM_IF_DEPTH_NV',0x88F6) +GL_MAX_PROGRAM_LOOP_COUNT_NV=_C('GL_MAX_PROGRAM_LOOP_COUNT_NV',0x88F8) +GL_MAX_PROGRAM_LOOP_DEPTH_NV=_C('GL_MAX_PROGRAM_LOOP_DEPTH_NV',0x88F7) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/fragment_program4.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/fragment_program4.py new file mode 100644 index 00000000..c9be16c9 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/fragment_program4.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_NV_fragment_program4' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_NV_fragment_program4',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/fragment_program_option.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/fragment_program_option.py new file mode 100644 index 00000000..88879e4c --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/fragment_program_option.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_NV_fragment_program_option' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_NV_fragment_program_option',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/fragment_shader_barycentric.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/fragment_shader_barycentric.py new file mode 100644 index 00000000..0517ff15 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/fragment_shader_barycentric.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_NV_fragment_shader_barycentric' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_NV_fragment_shader_barycentric',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/fragment_shader_interlock.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/fragment_shader_interlock.py new file mode 100644 index 00000000..61756c7c --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/fragment_shader_interlock.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_NV_fragment_shader_interlock' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_NV_fragment_shader_interlock',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/framebuffer_mixed_samples.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/framebuffer_mixed_samples.py new file mode 100644 index 00000000..8a31f299 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/framebuffer_mixed_samples.py @@ -0,0 +1,39 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_NV_framebuffer_mixed_samples' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_NV_framebuffer_mixed_samples',error_checker=_errors._error_checker) +GL_COLOR_SAMPLES_NV=_C('GL_COLOR_SAMPLES_NV',0x8E20) +GL_COVERAGE_MODULATION_NV=_C('GL_COVERAGE_MODULATION_NV',0x9332) +GL_COVERAGE_MODULATION_TABLE_NV=_C('GL_COVERAGE_MODULATION_TABLE_NV',0x9331) +GL_COVERAGE_MODULATION_TABLE_SIZE_NV=_C('GL_COVERAGE_MODULATION_TABLE_SIZE_NV',0x9333) +GL_DEPTH_SAMPLES_NV=_C('GL_DEPTH_SAMPLES_NV',0x932D) +GL_EFFECTIVE_RASTER_SAMPLES_EXT=_C('GL_EFFECTIVE_RASTER_SAMPLES_EXT',0x932C) +GL_MAX_RASTER_SAMPLES_EXT=_C('GL_MAX_RASTER_SAMPLES_EXT',0x9329) +GL_MIXED_DEPTH_SAMPLES_SUPPORTED_NV=_C('GL_MIXED_DEPTH_SAMPLES_SUPPORTED_NV',0x932F) +GL_MIXED_STENCIL_SAMPLES_SUPPORTED_NV=_C('GL_MIXED_STENCIL_SAMPLES_SUPPORTED_NV',0x9330) +GL_MULTISAMPLE_RASTERIZATION_ALLOWED_EXT=_C('GL_MULTISAMPLE_RASTERIZATION_ALLOWED_EXT',0x932B) +GL_RASTER_FIXED_SAMPLE_LOCATIONS_EXT=_C('GL_RASTER_FIXED_SAMPLE_LOCATIONS_EXT',0x932A) +GL_RASTER_MULTISAMPLE_EXT=_C('GL_RASTER_MULTISAMPLE_EXT',0x9327) +GL_RASTER_SAMPLES_EXT=_C('GL_RASTER_SAMPLES_EXT',0x9328) +GL_STENCIL_SAMPLES_NV=_C('GL_STENCIL_SAMPLES_NV',0x932E) +@_f +@_p.types(None,_cs.GLenum) +def glCoverageModulationNV(components):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLfloatArray) +def glCoverageModulationTableNV(n,v):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLfloatArray) +def glGetCoverageModulationTableNV(bufsize,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLboolean) +def glRasterSamplesEXT(samples,fixedsamplelocations):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/framebuffer_multisample_coverage.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/framebuffer_multisample_coverage.py new file mode 100644 index 00000000..fa238971 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/framebuffer_multisample_coverage.py @@ -0,0 +1,20 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_NV_framebuffer_multisample_coverage' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_NV_framebuffer_multisample_coverage',error_checker=_errors._error_checker) +GL_MAX_MULTISAMPLE_COVERAGE_MODES_NV=_C('GL_MAX_MULTISAMPLE_COVERAGE_MODES_NV',0x8E11) +GL_MULTISAMPLE_COVERAGE_MODES_NV=_C('GL_MULTISAMPLE_COVERAGE_MODES_NV',0x8E12) +GL_RENDERBUFFER_COLOR_SAMPLES_NV=_C('GL_RENDERBUFFER_COLOR_SAMPLES_NV',0x8E10) +GL_RENDERBUFFER_COVERAGE_SAMPLES_NV=_C('GL_RENDERBUFFER_COVERAGE_SAMPLES_NV',0x8CAB) +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizei,_cs.GLsizei,_cs.GLenum,_cs.GLsizei,_cs.GLsizei) +def glRenderbufferStorageMultisampleCoverageNV(target,coverageSamples,colorSamples,internalformat,width,height):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/geometry_program4.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/geometry_program4.py new file mode 100644 index 00000000..50b55426 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/geometry_program4.py @@ -0,0 +1,41 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_NV_geometry_program4' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_NV_geometry_program4',error_checker=_errors._error_checker) +GL_FRAMEBUFFER_ATTACHMENT_LAYERED_EXT=_C('GL_FRAMEBUFFER_ATTACHMENT_LAYERED_EXT',0x8DA7) +GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER_EXT=_C('GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER_EXT',0x8CD4) +GL_FRAMEBUFFER_INCOMPLETE_LAYER_COUNT_EXT=_C('GL_FRAMEBUFFER_INCOMPLETE_LAYER_COUNT_EXT',0x8DA9) +GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS_EXT=_C('GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS_EXT',0x8DA8) +GL_GEOMETRY_INPUT_TYPE_EXT=_C('GL_GEOMETRY_INPUT_TYPE_EXT',0x8DDB) +GL_GEOMETRY_OUTPUT_TYPE_EXT=_C('GL_GEOMETRY_OUTPUT_TYPE_EXT',0x8DDC) +GL_GEOMETRY_PROGRAM_NV=_C('GL_GEOMETRY_PROGRAM_NV',0x8C26) +GL_GEOMETRY_VERTICES_OUT_EXT=_C('GL_GEOMETRY_VERTICES_OUT_EXT',0x8DDA) +GL_LINES_ADJACENCY_EXT=_C('GL_LINES_ADJACENCY_EXT',0x000A) +GL_LINE_STRIP_ADJACENCY_EXT=_C('GL_LINE_STRIP_ADJACENCY_EXT',0x000B) +GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_EXT=_C('GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_EXT',0x8C29) +GL_MAX_PROGRAM_OUTPUT_VERTICES_NV=_C('GL_MAX_PROGRAM_OUTPUT_VERTICES_NV',0x8C27) +GL_MAX_PROGRAM_TOTAL_OUTPUT_COMPONENTS_NV=_C('GL_MAX_PROGRAM_TOTAL_OUTPUT_COMPONENTS_NV',0x8C28) +GL_PROGRAM_POINT_SIZE_EXT=_C('GL_PROGRAM_POINT_SIZE_EXT',0x8642) +GL_TRIANGLES_ADJACENCY_EXT=_C('GL_TRIANGLES_ADJACENCY_EXT',0x000C) +GL_TRIANGLE_STRIP_ADJACENCY_EXT=_C('GL_TRIANGLE_STRIP_ADJACENCY_EXT',0x000D) +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLuint,_cs.GLint) +def glFramebufferTextureEXT(target,attachment,texture,level):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLuint,_cs.GLint,_cs.GLenum) +def glFramebufferTextureFaceEXT(target,attachment,texture,level,face):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLuint,_cs.GLint,_cs.GLint) +def glFramebufferTextureLayerEXT(target,attachment,texture,level,layer):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLint) +def glProgramVertexLimitNV(target,limit):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/geometry_shader4.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/geometry_shader4.py new file mode 100644 index 00000000..9a75d7b5 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/geometry_shader4.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_NV_geometry_shader4' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_NV_geometry_shader4',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/geometry_shader_passthrough.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/geometry_shader_passthrough.py new file mode 100644 index 00000000..5cca3c06 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/geometry_shader_passthrough.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_NV_geometry_shader_passthrough' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_NV_geometry_shader_passthrough',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/gpu_multicast.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/gpu_multicast.py new file mode 100644 index 00000000..da3d7872 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/gpu_multicast.py @@ -0,0 +1,54 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_NV_gpu_multicast' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_NV_gpu_multicast',error_checker=_errors._error_checker) +GL_MULTICAST_GPUS_NV=_C('GL_MULTICAST_GPUS_NV',0x92BA) +GL_MULTICAST_PROGRAMMABLE_SAMPLE_LOCATION_NV=_C('GL_MULTICAST_PROGRAMMABLE_SAMPLE_LOCATION_NV',0x9549) +GL_PER_GPU_STORAGE_BIT_NV=_C('GL_PER_GPU_STORAGE_BIT_NV',0x0800) +GL_PER_GPU_STORAGE_NV=_C('GL_PER_GPU_STORAGE_NV',0x9548) +GL_RENDER_GPU_MASK_NV=_C('GL_RENDER_GPU_MASK_NV',0x9558) +@_f +@_p.types(None,) +def glMulticastBarrierNV():pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLbitfield,_cs.GLenum) +def glMulticastBlitFramebufferNV(srcGpu,dstGpu,srcX0,srcY0,srcX1,srcY1,dstX0,dstY0,dstX1,dstY1,mask,filter):pass +@_f +@_p.types(None,_cs.GLbitfield,_cs.GLuint,_cs.GLintptr,_cs.GLsizeiptr,ctypes.c_void_p) +def glMulticastBufferSubDataNV(gpuMask,buffer,offset,size,data):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLbitfield,_cs.GLuint,_cs.GLuint,_cs.GLintptr,_cs.GLintptr,_cs.GLsizeiptr) +def glMulticastCopyBufferSubDataNV(readGpu,writeGpuMask,readBuffer,writeBuffer,readOffset,writeOffset,size):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLbitfield,_cs.GLuint,_cs.GLenum,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLuint,_cs.GLenum,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLsizei,_cs.GLsizei) +def glMulticastCopyImageSubDataNV(srcGpu,dstGpuMask,srcName,srcTarget,srcLevel,srcX,srcY,srcZ,dstName,dstTarget,dstLevel,dstX,dstY,dstZ,srcWidth,srcHeight,srcDepth):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLuint,_cs.GLsizei,arrays.GLfloatArray) +def glMulticastFramebufferSampleLocationsfvNV(gpu,framebuffer,start,count,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLenum,arrays.GLint64Array) +def glMulticastGetQueryObjecti64vNV(gpu,id,pname,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLenum,arrays.GLintArray) +def glMulticastGetQueryObjectivNV(gpu,id,pname,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLenum,arrays.GLuint64Array) +def glMulticastGetQueryObjectui64vNV(gpu,id,pname,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLenum,arrays.GLuintArray) +def glMulticastGetQueryObjectuivNV(gpu,id,pname,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLbitfield) +def glMulticastWaitSyncNV(signalGpu,waitGpuMask):pass +@_f +@_p.types(None,_cs.GLbitfield) +def glRenderGpuMaskNV(mask):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/gpu_program4.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/gpu_program4.py new file mode 100644 index 00000000..dc71ee99 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/gpu_program4.py @@ -0,0 +1,69 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_NV_gpu_program4' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_NV_gpu_program4',error_checker=_errors._error_checker) +GL_MAX_PROGRAM_ATTRIB_COMPONENTS_NV=_C('GL_MAX_PROGRAM_ATTRIB_COMPONENTS_NV',0x8908) +GL_MAX_PROGRAM_GENERIC_ATTRIBS_NV=_C('GL_MAX_PROGRAM_GENERIC_ATTRIBS_NV',0x8DA5) +GL_MAX_PROGRAM_GENERIC_RESULTS_NV=_C('GL_MAX_PROGRAM_GENERIC_RESULTS_NV',0x8DA6) +GL_MAX_PROGRAM_RESULT_COMPONENTS_NV=_C('GL_MAX_PROGRAM_RESULT_COMPONENTS_NV',0x8909) +GL_MAX_PROGRAM_TEXEL_OFFSET_NV=_C('GL_MAX_PROGRAM_TEXEL_OFFSET_NV',0x8905) +GL_MIN_PROGRAM_TEXEL_OFFSET_NV=_C('GL_MIN_PROGRAM_TEXEL_OFFSET_NV',0x8904) +GL_PROGRAM_ATTRIB_COMPONENTS_NV=_C('GL_PROGRAM_ATTRIB_COMPONENTS_NV',0x8906) +GL_PROGRAM_RESULT_COMPONENTS_NV=_C('GL_PROGRAM_RESULT_COMPONENTS_NV',0x8907) +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,arrays.GLintArray) +def glGetProgramEnvParameterIivNV(target,index,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,arrays.GLuintArray) +def glGetProgramEnvParameterIuivNV(target,index,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,arrays.GLintArray) +def glGetProgramLocalParameterIivNV(target,index,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,arrays.GLuintArray) +def glGetProgramLocalParameterIuivNV(target,index,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint) +def glProgramEnvParameterI4iNV(target,index,x,y,z,w):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,arrays.GLintArray) +def glProgramEnvParameterI4ivNV(target,index,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,_cs.GLuint,_cs.GLuint,_cs.GLuint,_cs.GLuint) +def glProgramEnvParameterI4uiNV(target,index,x,y,z,w):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,arrays.GLuintArray) +def glProgramEnvParameterI4uivNV(target,index,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,_cs.GLsizei,arrays.GLintArray) +def glProgramEnvParametersI4ivNV(target,index,count,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,_cs.GLsizei,arrays.GLuintArray) +def glProgramEnvParametersI4uivNV(target,index,count,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint) +def glProgramLocalParameterI4iNV(target,index,x,y,z,w):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,arrays.GLintArray) +def glProgramLocalParameterI4ivNV(target,index,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,_cs.GLuint,_cs.GLuint,_cs.GLuint,_cs.GLuint) +def glProgramLocalParameterI4uiNV(target,index,x,y,z,w):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,arrays.GLuintArray) +def glProgramLocalParameterI4uivNV(target,index,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,_cs.GLsizei,arrays.GLintArray) +def glProgramLocalParametersI4ivNV(target,index,count,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,_cs.GLsizei,arrays.GLuintArray) +def glProgramLocalParametersI4uivNV(target,index,count,params):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/gpu_program5.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/gpu_program5.py new file mode 100644 index 00000000..6cc095f0 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/gpu_program5.py @@ -0,0 +1,27 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_NV_gpu_program5' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_NV_gpu_program5',error_checker=_errors._error_checker) +GL_FRAGMENT_PROGRAM_INTERPOLATION_OFFSET_BITS_NV=_C('GL_FRAGMENT_PROGRAM_INTERPOLATION_OFFSET_BITS_NV',0x8E5D) +GL_MAX_FRAGMENT_INTERPOLATION_OFFSET_NV=_C('GL_MAX_FRAGMENT_INTERPOLATION_OFFSET_NV',0x8E5C) +GL_MAX_GEOMETRY_PROGRAM_INVOCATIONS_NV=_C('GL_MAX_GEOMETRY_PROGRAM_INVOCATIONS_NV',0x8E5A) +GL_MAX_PROGRAM_SUBROUTINE_NUM_NV=_C('GL_MAX_PROGRAM_SUBROUTINE_NUM_NV',0x8F45) +GL_MAX_PROGRAM_SUBROUTINE_PARAMETERS_NV=_C('GL_MAX_PROGRAM_SUBROUTINE_PARAMETERS_NV',0x8F44) +GL_MAX_PROGRAM_TEXTURE_GATHER_OFFSET_NV=_C('GL_MAX_PROGRAM_TEXTURE_GATHER_OFFSET_NV',0x8E5F) +GL_MIN_FRAGMENT_INTERPOLATION_OFFSET_NV=_C('GL_MIN_FRAGMENT_INTERPOLATION_OFFSET_NV',0x8E5B) +GL_MIN_PROGRAM_TEXTURE_GATHER_OFFSET_NV=_C('GL_MIN_PROGRAM_TEXTURE_GATHER_OFFSET_NV',0x8E5E) +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,arrays.GLuintArray) +def glGetProgramSubroutineParameteruivNV(target,index,param):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizei,arrays.GLuintArray) +def glProgramSubroutineParametersuivNV(target,count,params):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/gpu_program5_mem_extended.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/gpu_program5_mem_extended.py new file mode 100644 index 00000000..d239d0ca --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/gpu_program5_mem_extended.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_NV_gpu_program5_mem_extended' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_NV_gpu_program5_mem_extended',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/gpu_shader5.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/gpu_shader5.py new file mode 100644 index 00000000..81cfc7de --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/gpu_shader5.py @@ -0,0 +1,141 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_NV_gpu_shader5' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_NV_gpu_shader5',error_checker=_errors._error_checker) +GL_FLOAT16_NV=_C('GL_FLOAT16_NV',0x8FF8) +GL_FLOAT16_VEC2_NV=_C('GL_FLOAT16_VEC2_NV',0x8FF9) +GL_FLOAT16_VEC3_NV=_C('GL_FLOAT16_VEC3_NV',0x8FFA) +GL_FLOAT16_VEC4_NV=_C('GL_FLOAT16_VEC4_NV',0x8FFB) +GL_INT16_NV=_C('GL_INT16_NV',0x8FE4) +GL_INT16_VEC2_NV=_C('GL_INT16_VEC2_NV',0x8FE5) +GL_INT16_VEC3_NV=_C('GL_INT16_VEC3_NV',0x8FE6) +GL_INT16_VEC4_NV=_C('GL_INT16_VEC4_NV',0x8FE7) +GL_INT64_NV=_C('GL_INT64_NV',0x140E) +GL_INT64_VEC2_NV=_C('GL_INT64_VEC2_NV',0x8FE9) +GL_INT64_VEC3_NV=_C('GL_INT64_VEC3_NV',0x8FEA) +GL_INT64_VEC4_NV=_C('GL_INT64_VEC4_NV',0x8FEB) +GL_INT8_NV=_C('GL_INT8_NV',0x8FE0) +GL_INT8_VEC2_NV=_C('GL_INT8_VEC2_NV',0x8FE1) +GL_INT8_VEC3_NV=_C('GL_INT8_VEC3_NV',0x8FE2) +GL_INT8_VEC4_NV=_C('GL_INT8_VEC4_NV',0x8FE3) +GL_PATCHES=_C('GL_PATCHES',0x000E) +GL_UNSIGNED_INT16_NV=_C('GL_UNSIGNED_INT16_NV',0x8FF0) +GL_UNSIGNED_INT16_VEC2_NV=_C('GL_UNSIGNED_INT16_VEC2_NV',0x8FF1) +GL_UNSIGNED_INT16_VEC3_NV=_C('GL_UNSIGNED_INT16_VEC3_NV',0x8FF2) +GL_UNSIGNED_INT16_VEC4_NV=_C('GL_UNSIGNED_INT16_VEC4_NV',0x8FF3) +GL_UNSIGNED_INT64_NV=_C('GL_UNSIGNED_INT64_NV',0x140F) +GL_UNSIGNED_INT64_VEC2_NV=_C('GL_UNSIGNED_INT64_VEC2_NV',0x8FF5) +GL_UNSIGNED_INT64_VEC3_NV=_C('GL_UNSIGNED_INT64_VEC3_NV',0x8FF6) +GL_UNSIGNED_INT64_VEC4_NV=_C('GL_UNSIGNED_INT64_VEC4_NV',0x8FF7) +GL_UNSIGNED_INT8_NV=_C('GL_UNSIGNED_INT8_NV',0x8FEC) +GL_UNSIGNED_INT8_VEC2_NV=_C('GL_UNSIGNED_INT8_VEC2_NV',0x8FED) +GL_UNSIGNED_INT8_VEC3_NV=_C('GL_UNSIGNED_INT8_VEC3_NV',0x8FEE) +GL_UNSIGNED_INT8_VEC4_NV=_C('GL_UNSIGNED_INT8_VEC4_NV',0x8FEF) +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,arrays.GLint64Array) +def glGetUniformi64vNV(program,location,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLint64EXT) +def glProgramUniform1i64NV(program,location,x):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLint64Array) +def glProgramUniform1i64vNV(program,location,count,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLuint64EXT) +def glProgramUniform1ui64NV(program,location,x):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLuint64Array) +def glProgramUniform1ui64vNV(program,location,count,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLint64EXT,_cs.GLint64EXT) +def glProgramUniform2i64NV(program,location,x,y):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLint64Array) +def glProgramUniform2i64vNV(program,location,count,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLuint64EXT,_cs.GLuint64EXT) +def glProgramUniform2ui64NV(program,location,x,y):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLuint64Array) +def glProgramUniform2ui64vNV(program,location,count,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLint64EXT,_cs.GLint64EXT,_cs.GLint64EXT) +def glProgramUniform3i64NV(program,location,x,y,z):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLint64Array) +def glProgramUniform3i64vNV(program,location,count,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLuint64EXT,_cs.GLuint64EXT,_cs.GLuint64EXT) +def glProgramUniform3ui64NV(program,location,x,y,z):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLuint64Array) +def glProgramUniform3ui64vNV(program,location,count,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLint64EXT,_cs.GLint64EXT,_cs.GLint64EXT,_cs.GLint64EXT) +def glProgramUniform4i64NV(program,location,x,y,z,w):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLint64Array) +def glProgramUniform4i64vNV(program,location,count,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLuint64EXT,_cs.GLuint64EXT,_cs.GLuint64EXT,_cs.GLuint64EXT) +def glProgramUniform4ui64NV(program,location,x,y,z,w):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLuint64Array) +def glProgramUniform4ui64vNV(program,location,count,value):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLint64EXT) +def glUniform1i64NV(location,x):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLsizei,arrays.GLint64Array) +def glUniform1i64vNV(location,count,value):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLuint64EXT) +def glUniform1ui64NV(location,x):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLsizei,arrays.GLuint64Array) +def glUniform1ui64vNV(location,count,value):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLint64EXT,_cs.GLint64EXT) +def glUniform2i64NV(location,x,y):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLsizei,arrays.GLint64Array) +def glUniform2i64vNV(location,count,value):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLuint64EXT,_cs.GLuint64EXT) +def glUniform2ui64NV(location,x,y):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLsizei,arrays.GLuint64Array) +def glUniform2ui64vNV(location,count,value):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLint64EXT,_cs.GLint64EXT,_cs.GLint64EXT) +def glUniform3i64NV(location,x,y,z):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLsizei,arrays.GLint64Array) +def glUniform3i64vNV(location,count,value):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLuint64EXT,_cs.GLuint64EXT,_cs.GLuint64EXT) +def glUniform3ui64NV(location,x,y,z):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLsizei,arrays.GLuint64Array) +def glUniform3ui64vNV(location,count,value):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLint64EXT,_cs.GLint64EXT,_cs.GLint64EXT,_cs.GLint64EXT) +def glUniform4i64NV(location,x,y,z,w):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLsizei,arrays.GLint64Array) +def glUniform4i64vNV(location,count,value):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLuint64EXT,_cs.GLuint64EXT,_cs.GLuint64EXT,_cs.GLuint64EXT) +def glUniform4ui64NV(location,x,y,z,w):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLsizei,arrays.GLuint64Array) +def glUniform4ui64vNV(location,count,value):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/half_float.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/half_float.py new file mode 100644 index 00000000..cbee664d --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/half_float.py @@ -0,0 +1,152 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_NV_half_float' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_NV_half_float',error_checker=_errors._error_checker) +GL_HALF_FLOAT_NV=_C('GL_HALF_FLOAT_NV',0x140B) +@_f +@_p.types(None,_cs.GLhalfNV,_cs.GLhalfNV,_cs.GLhalfNV) +def glColor3hNV(red,green,blue):pass +@_f +@_p.types(None,arrays.GLushortArray) +def glColor3hvNV(v):pass +@_f +@_p.types(None,_cs.GLhalfNV,_cs.GLhalfNV,_cs.GLhalfNV,_cs.GLhalfNV) +def glColor4hNV(red,green,blue,alpha):pass +@_f +@_p.types(None,arrays.GLushortArray) +def glColor4hvNV(v):pass +@_f +@_p.types(None,_cs.GLhalfNV) +def glFogCoordhNV(fog):pass +@_f +@_p.types(None,arrays.GLushortArray) +def glFogCoordhvNV(fog):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLhalfNV) +def glMultiTexCoord1hNV(target,s):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLushortArray) +def glMultiTexCoord1hvNV(target,v):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLhalfNV,_cs.GLhalfNV) +def glMultiTexCoord2hNV(target,s,t):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLushortArray) +def glMultiTexCoord2hvNV(target,v):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLhalfNV,_cs.GLhalfNV,_cs.GLhalfNV) +def glMultiTexCoord3hNV(target,s,t,r):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLushortArray) +def glMultiTexCoord3hvNV(target,v):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLhalfNV,_cs.GLhalfNV,_cs.GLhalfNV,_cs.GLhalfNV) +def glMultiTexCoord4hNV(target,s,t,r,q):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLushortArray) +def glMultiTexCoord4hvNV(target,v):pass +@_f +@_p.types(None,_cs.GLhalfNV,_cs.GLhalfNV,_cs.GLhalfNV) +def glNormal3hNV(nx,ny,nz):pass +@_f +@_p.types(None,arrays.GLushortArray) +def glNormal3hvNV(v):pass +@_f +@_p.types(None,_cs.GLhalfNV,_cs.GLhalfNV,_cs.GLhalfNV) +def glSecondaryColor3hNV(red,green,blue):pass +@_f +@_p.types(None,arrays.GLushortArray) +def glSecondaryColor3hvNV(v):pass +@_f +@_p.types(None,_cs.GLhalfNV) +def glTexCoord1hNV(s):pass +@_f +@_p.types(None,arrays.GLushortArray) +def glTexCoord1hvNV(v):pass +@_f +@_p.types(None,_cs.GLhalfNV,_cs.GLhalfNV) +def glTexCoord2hNV(s,t):pass +@_f +@_p.types(None,arrays.GLushortArray) +def glTexCoord2hvNV(v):pass +@_f +@_p.types(None,_cs.GLhalfNV,_cs.GLhalfNV,_cs.GLhalfNV) +def glTexCoord3hNV(s,t,r):pass +@_f +@_p.types(None,arrays.GLushortArray) +def glTexCoord3hvNV(v):pass +@_f +@_p.types(None,_cs.GLhalfNV,_cs.GLhalfNV,_cs.GLhalfNV,_cs.GLhalfNV) +def glTexCoord4hNV(s,t,r,q):pass +@_f +@_p.types(None,arrays.GLushortArray) +def glTexCoord4hvNV(v):pass +@_f +@_p.types(None,_cs.GLhalfNV,_cs.GLhalfNV) +def glVertex2hNV(x,y):pass +@_f +@_p.types(None,arrays.GLushortArray) +def glVertex2hvNV(v):pass +@_f +@_p.types(None,_cs.GLhalfNV,_cs.GLhalfNV,_cs.GLhalfNV) +def glVertex3hNV(x,y,z):pass +@_f +@_p.types(None,arrays.GLushortArray) +def glVertex3hvNV(v):pass +@_f +@_p.types(None,_cs.GLhalfNV,_cs.GLhalfNV,_cs.GLhalfNV,_cs.GLhalfNV) +def glVertex4hNV(x,y,z,w):pass +@_f +@_p.types(None,arrays.GLushortArray) +def glVertex4hvNV(v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLhalfNV) +def glVertexAttrib1hNV(index,x):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLushortArray) +def glVertexAttrib1hvNV(index,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLhalfNV,_cs.GLhalfNV) +def glVertexAttrib2hNV(index,x,y):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLushortArray) +def glVertexAttrib2hvNV(index,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLhalfNV,_cs.GLhalfNV,_cs.GLhalfNV) +def glVertexAttrib3hNV(index,x,y,z):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLushortArray) +def glVertexAttrib3hvNV(index,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLhalfNV,_cs.GLhalfNV,_cs.GLhalfNV,_cs.GLhalfNV) +def glVertexAttrib4hNV(index,x,y,z,w):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLushortArray) +def glVertexAttrib4hvNV(index,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizei,arrays.GLushortArray) +def glVertexAttribs1hvNV(index,n,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizei,arrays.GLushortArray) +def glVertexAttribs2hvNV(index,n,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizei,arrays.GLushortArray) +def glVertexAttribs3hvNV(index,n,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizei,arrays.GLushortArray) +def glVertexAttribs4hvNV(index,n,v):pass +@_f +@_p.types(None,_cs.GLhalfNV) +def glVertexWeighthNV(weight):pass +@_f +@_p.types(None,arrays.GLushortArray) +def glVertexWeighthvNV(weight):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/internalformat_sample_query.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/internalformat_sample_query.py new file mode 100644 index 00000000..534b1122 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/internalformat_sample_query.py @@ -0,0 +1,23 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_NV_internalformat_sample_query' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_NV_internalformat_sample_query',error_checker=_errors._error_checker) +GL_CONFORMANT_NV=_C('GL_CONFORMANT_NV',0x9374) +GL_MULTISAMPLES_NV=_C('GL_MULTISAMPLES_NV',0x9371) +GL_RENDERBUFFER=_C('GL_RENDERBUFFER',0x8D41) +GL_SUPERSAMPLE_SCALE_X_NV=_C('GL_SUPERSAMPLE_SCALE_X_NV',0x9372) +GL_SUPERSAMPLE_SCALE_Y_NV=_C('GL_SUPERSAMPLE_SCALE_Y_NV',0x9373) +GL_TEXTURE_2D_MULTISAMPLE=_C('GL_TEXTURE_2D_MULTISAMPLE',0x9100) +GL_TEXTURE_2D_MULTISAMPLE_ARRAY=_C('GL_TEXTURE_2D_MULTISAMPLE_ARRAY',0x9102) +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLsizei,_cs.GLenum,_cs.GLsizei,arrays.GLintArray) +def glGetInternalformatSampleivNV(target,internalformat,samples,pname,bufSize,params):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/light_max_exponent.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/light_max_exponent.py new file mode 100644 index 00000000..0660d69b --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/light_max_exponent.py @@ -0,0 +1,16 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_NV_light_max_exponent' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_NV_light_max_exponent',error_checker=_errors._error_checker) +GL_MAX_SHININESS_NV=_C('GL_MAX_SHININESS_NV',0x8504) +GL_MAX_SPOT_EXPONENT_NV=_C('GL_MAX_SPOT_EXPONENT_NV',0x8505) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/memory_attachment.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/memory_attachment.py new file mode 100644 index 00000000..8685b05b --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/memory_attachment.py @@ -0,0 +1,41 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_NV_memory_attachment' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_NV_memory_attachment',error_checker=_errors._error_checker) +GL_ATTACHED_MEMORY_OBJECT_NV=_C('GL_ATTACHED_MEMORY_OBJECT_NV',0x95A4) +GL_ATTACHED_MEMORY_OFFSET_NV=_C('GL_ATTACHED_MEMORY_OFFSET_NV',0x95A5) +GL_DETACHED_BUFFERS_NV=_C('GL_DETACHED_BUFFERS_NV',0x95AB) +GL_DETACHED_MEMORY_INCARNATION_NV=_C('GL_DETACHED_MEMORY_INCARNATION_NV',0x95A9) +GL_DETACHED_TEXTURES_NV=_C('GL_DETACHED_TEXTURES_NV',0x95AA) +GL_MAX_DETACHED_BUFFERS_NV=_C('GL_MAX_DETACHED_BUFFERS_NV',0x95AD) +GL_MAX_DETACHED_TEXTURES_NV=_C('GL_MAX_DETACHED_TEXTURES_NV',0x95AC) +GL_MEMORY_ATTACHABLE_ALIGNMENT_NV=_C('GL_MEMORY_ATTACHABLE_ALIGNMENT_NV',0x95A6) +GL_MEMORY_ATTACHABLE_NV=_C('GL_MEMORY_ATTACHABLE_NV',0x95A8) +GL_MEMORY_ATTACHABLE_SIZE_NV=_C('GL_MEMORY_ATTACHABLE_SIZE_NV',0x95A7) +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,_cs.GLuint64) +def glBufferAttachMemoryNV(target,memory,offset):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLint,_cs.GLsizei,arrays.GLuintArray) +def glGetMemoryObjectDetachedResourcesuivNV(memory,pname,first,count,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLuint64) +def glNamedBufferAttachMemoryNV(buffer,memory,offset):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum) +def glResetMemoryObjectParameterNV(memory,pname):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,_cs.GLuint64) +def glTexAttachMemoryNV(target,memory,offset):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLuint64) +def glTextureAttachMemoryNV(texture,memory,offset):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/mesh_shader.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/mesh_shader.py new file mode 100644 index 00000000..040753eb --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/mesh_shader.py @@ -0,0 +1,73 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_NV_mesh_shader' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_NV_mesh_shader',error_checker=_errors._error_checker) +GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_MESH_SHADER_NV=_C('GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_MESH_SHADER_NV',0x959E) +GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TASK_SHADER_NV=_C('GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TASK_SHADER_NV',0x959F) +GL_MAX_COMBINED_MESH_UNIFORM_COMPONENTS_NV=_C('GL_MAX_COMBINED_MESH_UNIFORM_COMPONENTS_NV',0x8E67) +GL_MAX_COMBINED_TASK_UNIFORM_COMPONENTS_NV=_C('GL_MAX_COMBINED_TASK_UNIFORM_COMPONENTS_NV',0x8E6F) +GL_MAX_DRAW_MESH_TASKS_COUNT_NV=_C('GL_MAX_DRAW_MESH_TASKS_COUNT_NV',0x953D) +GL_MAX_MESH_ATOMIC_COUNTERS_NV=_C('GL_MAX_MESH_ATOMIC_COUNTERS_NV',0x8E65) +GL_MAX_MESH_ATOMIC_COUNTER_BUFFERS_NV=_C('GL_MAX_MESH_ATOMIC_COUNTER_BUFFERS_NV',0x8E64) +GL_MAX_MESH_IMAGE_UNIFORMS_NV=_C('GL_MAX_MESH_IMAGE_UNIFORMS_NV',0x8E62) +GL_MAX_MESH_OUTPUT_PRIMITIVES_NV=_C('GL_MAX_MESH_OUTPUT_PRIMITIVES_NV',0x9539) +GL_MAX_MESH_OUTPUT_VERTICES_NV=_C('GL_MAX_MESH_OUTPUT_VERTICES_NV',0x9538) +GL_MAX_MESH_SHADER_STORAGE_BLOCKS_NV=_C('GL_MAX_MESH_SHADER_STORAGE_BLOCKS_NV',0x8E66) +GL_MAX_MESH_TEXTURE_IMAGE_UNITS_NV=_C('GL_MAX_MESH_TEXTURE_IMAGE_UNITS_NV',0x8E61) +GL_MAX_MESH_TOTAL_MEMORY_SIZE_NV=_C('GL_MAX_MESH_TOTAL_MEMORY_SIZE_NV',0x9536) +GL_MAX_MESH_UNIFORM_BLOCKS_NV=_C('GL_MAX_MESH_UNIFORM_BLOCKS_NV',0x8E60) +GL_MAX_MESH_UNIFORM_COMPONENTS_NV=_C('GL_MAX_MESH_UNIFORM_COMPONENTS_NV',0x8E63) +GL_MAX_MESH_VIEWS_NV=_C('GL_MAX_MESH_VIEWS_NV',0x9557) +GL_MAX_MESH_WORK_GROUP_INVOCATIONS_NV=_C('GL_MAX_MESH_WORK_GROUP_INVOCATIONS_NV',0x95A2) +GL_MAX_MESH_WORK_GROUP_SIZE_NV=_C('GL_MAX_MESH_WORK_GROUP_SIZE_NV',0x953B) +GL_MAX_TASK_ATOMIC_COUNTERS_NV=_C('GL_MAX_TASK_ATOMIC_COUNTERS_NV',0x8E6D) +GL_MAX_TASK_ATOMIC_COUNTER_BUFFERS_NV=_C('GL_MAX_TASK_ATOMIC_COUNTER_BUFFERS_NV',0x8E6C) +GL_MAX_TASK_IMAGE_UNIFORMS_NV=_C('GL_MAX_TASK_IMAGE_UNIFORMS_NV',0x8E6A) +GL_MAX_TASK_OUTPUT_COUNT_NV=_C('GL_MAX_TASK_OUTPUT_COUNT_NV',0x953A) +GL_MAX_TASK_SHADER_STORAGE_BLOCKS_NV=_C('GL_MAX_TASK_SHADER_STORAGE_BLOCKS_NV',0x8E6E) +GL_MAX_TASK_TEXTURE_IMAGE_UNITS_NV=_C('GL_MAX_TASK_TEXTURE_IMAGE_UNITS_NV',0x8E69) +GL_MAX_TASK_TOTAL_MEMORY_SIZE_NV=_C('GL_MAX_TASK_TOTAL_MEMORY_SIZE_NV',0x9537) +GL_MAX_TASK_UNIFORM_BLOCKS_NV=_C('GL_MAX_TASK_UNIFORM_BLOCKS_NV',0x8E68) +GL_MAX_TASK_UNIFORM_COMPONENTS_NV=_C('GL_MAX_TASK_UNIFORM_COMPONENTS_NV',0x8E6B) +GL_MAX_TASK_WORK_GROUP_INVOCATIONS_NV=_C('GL_MAX_TASK_WORK_GROUP_INVOCATIONS_NV',0x95A3) +GL_MAX_TASK_WORK_GROUP_SIZE_NV=_C('GL_MAX_TASK_WORK_GROUP_SIZE_NV',0x953C) +GL_MESH_OUTPUT_PER_PRIMITIVE_GRANULARITY_NV=_C('GL_MESH_OUTPUT_PER_PRIMITIVE_GRANULARITY_NV',0x9543) +GL_MESH_OUTPUT_PER_VERTEX_GRANULARITY_NV=_C('GL_MESH_OUTPUT_PER_VERTEX_GRANULARITY_NV',0x92DF) +GL_MESH_OUTPUT_TYPE_NV=_C('GL_MESH_OUTPUT_TYPE_NV',0x957B) +GL_MESH_PRIMITIVES_OUT_NV=_C('GL_MESH_PRIMITIVES_OUT_NV',0x957A) +GL_MESH_SHADER_BIT_NV=_C('GL_MESH_SHADER_BIT_NV',0x00000040) +GL_MESH_SHADER_NV=_C('GL_MESH_SHADER_NV',0x9559) +GL_MESH_SUBROUTINE_NV=_C('GL_MESH_SUBROUTINE_NV',0x957C) +GL_MESH_SUBROUTINE_UNIFORM_NV=_C('GL_MESH_SUBROUTINE_UNIFORM_NV',0x957E) +GL_MESH_VERTICES_OUT_NV=_C('GL_MESH_VERTICES_OUT_NV',0x9579) +GL_MESH_WORK_GROUP_SIZE_NV=_C('GL_MESH_WORK_GROUP_SIZE_NV',0x953E) +GL_REFERENCED_BY_MESH_SHADER_NV=_C('GL_REFERENCED_BY_MESH_SHADER_NV',0x95A0) +GL_REFERENCED_BY_TASK_SHADER_NV=_C('GL_REFERENCED_BY_TASK_SHADER_NV',0x95A1) +GL_TASK_SHADER_BIT_NV=_C('GL_TASK_SHADER_BIT_NV',0x00000080) +GL_TASK_SHADER_NV=_C('GL_TASK_SHADER_NV',0x955A) +GL_TASK_SUBROUTINE_NV=_C('GL_TASK_SUBROUTINE_NV',0x957D) +GL_TASK_SUBROUTINE_UNIFORM_NV=_C('GL_TASK_SUBROUTINE_UNIFORM_NV',0x957F) +GL_TASK_WORK_GROUP_SIZE_NV=_C('GL_TASK_WORK_GROUP_SIZE_NV',0x953F) +GL_UNIFORM_BLOCK_REFERENCED_BY_MESH_SHADER_NV=_C('GL_UNIFORM_BLOCK_REFERENCED_BY_MESH_SHADER_NV',0x959C) +GL_UNIFORM_BLOCK_REFERENCED_BY_TASK_SHADER_NV=_C('GL_UNIFORM_BLOCK_REFERENCED_BY_TASK_SHADER_NV',0x959D) +@_f +@_p.types(None,_cs.GLintptr) +def glDrawMeshTasksIndirectNV(indirect):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint) +def glDrawMeshTasksNV(first,count):pass +@_f +@_p.types(None,_cs.GLintptr,_cs.GLintptr,_cs.GLsizei,_cs.GLsizei) +def glMultiDrawMeshTasksIndirectCountNV(indirect,drawcount,maxdrawcount,stride):pass +@_f +@_p.types(None,_cs.GLintptr,_cs.GLsizei,_cs.GLsizei) +def glMultiDrawMeshTasksIndirectNV(indirect,drawcount,stride):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/multisample_coverage.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/multisample_coverage.py new file mode 100644 index 00000000..7a07eef2 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/multisample_coverage.py @@ -0,0 +1,16 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_NV_multisample_coverage' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_NV_multisample_coverage',error_checker=_errors._error_checker) +GL_COLOR_SAMPLES_NV=_C('GL_COLOR_SAMPLES_NV',0x8E20) +GL_SAMPLES_ARB=_C('GL_SAMPLES_ARB',0x80A9) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/multisample_filter_hint.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/multisample_filter_hint.py new file mode 100644 index 00000000..5f211eca --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/multisample_filter_hint.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_NV_multisample_filter_hint' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_NV_multisample_filter_hint',error_checker=_errors._error_checker) +GL_MULTISAMPLE_FILTER_HINT_NV=_C('GL_MULTISAMPLE_FILTER_HINT_NV',0x8534) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/occlusion_query.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/occlusion_query.py new file mode 100644 index 00000000..2c03ebe5 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/occlusion_query.py @@ -0,0 +1,38 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_NV_occlusion_query' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_NV_occlusion_query',error_checker=_errors._error_checker) +GL_CURRENT_OCCLUSION_QUERY_ID_NV=_C('GL_CURRENT_OCCLUSION_QUERY_ID_NV',0x8865) +GL_PIXEL_COUNTER_BITS_NV=_C('GL_PIXEL_COUNTER_BITS_NV',0x8864) +GL_PIXEL_COUNT_AVAILABLE_NV=_C('GL_PIXEL_COUNT_AVAILABLE_NV',0x8867) +GL_PIXEL_COUNT_NV=_C('GL_PIXEL_COUNT_NV',0x8866) +@_f +@_p.types(None,_cs.GLuint) +def glBeginOcclusionQueryNV(id):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray) +def glDeleteOcclusionQueriesNV(n,ids):pass +@_f +@_p.types(None,) +def glEndOcclusionQueryNV():pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray) +def glGenOcclusionQueriesNV(n,ids):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLintArray) +def glGetOcclusionQueryivNV(id,pname,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLuintArray) +def glGetOcclusionQueryuivNV(id,pname,params):pass +@_f +@_p.types(_cs.GLboolean,_cs.GLuint) +def glIsOcclusionQueryNV(id):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/packed_depth_stencil.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/packed_depth_stencil.py new file mode 100644 index 00000000..7fd1aafa --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/packed_depth_stencil.py @@ -0,0 +1,16 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_NV_packed_depth_stencil' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_NV_packed_depth_stencil',error_checker=_errors._error_checker) +GL_DEPTH_STENCIL_NV=_C('GL_DEPTH_STENCIL_NV',0x84F9) +GL_UNSIGNED_INT_24_8_NV=_C('GL_UNSIGNED_INT_24_8_NV',0x84FA) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/parameter_buffer_object.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/parameter_buffer_object.py new file mode 100644 index 00000000..d16a9c1c --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/parameter_buffer_object.py @@ -0,0 +1,27 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_NV_parameter_buffer_object' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_NV_parameter_buffer_object',error_checker=_errors._error_checker) +GL_FRAGMENT_PROGRAM_PARAMETER_BUFFER_NV=_C('GL_FRAGMENT_PROGRAM_PARAMETER_BUFFER_NV',0x8DA4) +GL_GEOMETRY_PROGRAM_PARAMETER_BUFFER_NV=_C('GL_GEOMETRY_PROGRAM_PARAMETER_BUFFER_NV',0x8DA3) +GL_MAX_PROGRAM_PARAMETER_BUFFER_BINDINGS_NV=_C('GL_MAX_PROGRAM_PARAMETER_BUFFER_BINDINGS_NV',0x8DA0) +GL_MAX_PROGRAM_PARAMETER_BUFFER_SIZE_NV=_C('GL_MAX_PROGRAM_PARAMETER_BUFFER_SIZE_NV',0x8DA1) +GL_VERTEX_PROGRAM_PARAMETER_BUFFER_NV=_C('GL_VERTEX_PROGRAM_PARAMETER_BUFFER_NV',0x8DA2) +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,_cs.GLuint,_cs.GLsizei,arrays.GLintArray) +def glProgramBufferParametersIivNV(target,bindingIndex,wordIndex,count,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,_cs.GLuint,_cs.GLsizei,arrays.GLuintArray) +def glProgramBufferParametersIuivNV(target,bindingIndex,wordIndex,count,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,_cs.GLuint,_cs.GLsizei,arrays.GLfloatArray) +def glProgramBufferParametersfvNV(target,bindingIndex,wordIndex,count,params):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/parameter_buffer_object2.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/parameter_buffer_object2.py new file mode 100644 index 00000000..197458c6 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/parameter_buffer_object2.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_NV_parameter_buffer_object2' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_NV_parameter_buffer_object2',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/path_rendering.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/path_rendering.py new file mode 100644 index 00000000..b9b03d27 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/path_rendering.py @@ -0,0 +1,426 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_NV_path_rendering' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_NV_path_rendering',error_checker=_errors._error_checker) +GL_2_BYTES_NV=_C('GL_2_BYTES_NV',0x1407) +GL_3_BYTES_NV=_C('GL_3_BYTES_NV',0x1408) +GL_4_BYTES_NV=_C('GL_4_BYTES_NV',0x1409) +GL_ACCUM_ADJACENT_PAIRS_NV=_C('GL_ACCUM_ADJACENT_PAIRS_NV',0x90AD) +GL_ADJACENT_PAIRS_NV=_C('GL_ADJACENT_PAIRS_NV',0x90AE) +GL_AFFINE_2D_NV=_C('GL_AFFINE_2D_NV',0x9092) +GL_AFFINE_3D_NV=_C('GL_AFFINE_3D_NV',0x9094) +GL_ARC_TO_NV=_C('GL_ARC_TO_NV',0xFE) +GL_BEVEL_NV=_C('GL_BEVEL_NV',0x90A6) +GL_BOLD_BIT_NV=_C('GL_BOLD_BIT_NV',0x01) +GL_BOUNDING_BOX_NV=_C('GL_BOUNDING_BOX_NV',0x908D) +GL_BOUNDING_BOX_OF_BOUNDING_BOXES_NV=_C('GL_BOUNDING_BOX_OF_BOUNDING_BOXES_NV',0x909C) +GL_CIRCULAR_CCW_ARC_TO_NV=_C('GL_CIRCULAR_CCW_ARC_TO_NV',0xF8) +GL_CIRCULAR_CW_ARC_TO_NV=_C('GL_CIRCULAR_CW_ARC_TO_NV',0xFA) +GL_CIRCULAR_TANGENT_ARC_TO_NV=_C('GL_CIRCULAR_TANGENT_ARC_TO_NV',0xFC) +GL_CLOSE_PATH_NV=_C('GL_CLOSE_PATH_NV',0x00) +GL_CONIC_CURVE_TO_NV=_C('GL_CONIC_CURVE_TO_NV',0x1A) +GL_CONSTANT_NV=_C('GL_CONSTANT_NV',0x8576) +GL_CONVEX_HULL_NV=_C('GL_CONVEX_HULL_NV',0x908B) +GL_COUNT_DOWN_NV=_C('GL_COUNT_DOWN_NV',0x9089) +GL_COUNT_UP_NV=_C('GL_COUNT_UP_NV',0x9088) +GL_CUBIC_CURVE_TO_NV=_C('GL_CUBIC_CURVE_TO_NV',0x0C) +GL_DUP_FIRST_CUBIC_CURVE_TO_NV=_C('GL_DUP_FIRST_CUBIC_CURVE_TO_NV',0xF2) +GL_DUP_LAST_CUBIC_CURVE_TO_NV=_C('GL_DUP_LAST_CUBIC_CURVE_TO_NV',0xF4) +GL_EYE_LINEAR_NV=_C('GL_EYE_LINEAR_NV',0x2400) +GL_FILE_NAME_NV=_C('GL_FILE_NAME_NV',0x9074) +GL_FIRST_TO_REST_NV=_C('GL_FIRST_TO_REST_NV',0x90AF) +GL_FONT_ASCENDER_BIT_NV=_C('GL_FONT_ASCENDER_BIT_NV',0x00200000) +GL_FONT_DESCENDER_BIT_NV=_C('GL_FONT_DESCENDER_BIT_NV',0x00400000) +GL_FONT_GLYPHS_AVAILABLE_NV=_C('GL_FONT_GLYPHS_AVAILABLE_NV',0x9368) +GL_FONT_HAS_KERNING_BIT_NV=_C('GL_FONT_HAS_KERNING_BIT_NV',0x10000000) +GL_FONT_HEIGHT_BIT_NV=_C('GL_FONT_HEIGHT_BIT_NV',0x00800000) +GL_FONT_MAX_ADVANCE_HEIGHT_BIT_NV=_C('GL_FONT_MAX_ADVANCE_HEIGHT_BIT_NV',0x02000000) +GL_FONT_MAX_ADVANCE_WIDTH_BIT_NV=_C('GL_FONT_MAX_ADVANCE_WIDTH_BIT_NV',0x01000000) +GL_FONT_NUM_GLYPH_INDICES_BIT_NV=_C('GL_FONT_NUM_GLYPH_INDICES_BIT_NV',0x20000000) +GL_FONT_TARGET_UNAVAILABLE_NV=_C('GL_FONT_TARGET_UNAVAILABLE_NV',0x9369) +GL_FONT_UNAVAILABLE_NV=_C('GL_FONT_UNAVAILABLE_NV',0x936A) +GL_FONT_UNDERLINE_POSITION_BIT_NV=_C('GL_FONT_UNDERLINE_POSITION_BIT_NV',0x04000000) +GL_FONT_UNDERLINE_THICKNESS_BIT_NV=_C('GL_FONT_UNDERLINE_THICKNESS_BIT_NV',0x08000000) +GL_FONT_UNINTELLIGIBLE_NV=_C('GL_FONT_UNINTELLIGIBLE_NV',0x936B) +GL_FONT_UNITS_PER_EM_BIT_NV=_C('GL_FONT_UNITS_PER_EM_BIT_NV',0x00100000) +GL_FONT_X_MAX_BOUNDS_BIT_NV=_C('GL_FONT_X_MAX_BOUNDS_BIT_NV',0x00040000) +GL_FONT_X_MIN_BOUNDS_BIT_NV=_C('GL_FONT_X_MIN_BOUNDS_BIT_NV',0x00010000) +GL_FONT_Y_MAX_BOUNDS_BIT_NV=_C('GL_FONT_Y_MAX_BOUNDS_BIT_NV',0x00080000) +GL_FONT_Y_MIN_BOUNDS_BIT_NV=_C('GL_FONT_Y_MIN_BOUNDS_BIT_NV',0x00020000) +GL_FRAGMENT_INPUT_NV=_C('GL_FRAGMENT_INPUT_NV',0x936D) +GL_GLYPH_HAS_KERNING_BIT_NV=_C('GL_GLYPH_HAS_KERNING_BIT_NV',0x100) +GL_GLYPH_HEIGHT_BIT_NV=_C('GL_GLYPH_HEIGHT_BIT_NV',0x02) +GL_GLYPH_HORIZONTAL_BEARING_ADVANCE_BIT_NV=_C('GL_GLYPH_HORIZONTAL_BEARING_ADVANCE_BIT_NV',0x10) +GL_GLYPH_HORIZONTAL_BEARING_X_BIT_NV=_C('GL_GLYPH_HORIZONTAL_BEARING_X_BIT_NV',0x04) +GL_GLYPH_HORIZONTAL_BEARING_Y_BIT_NV=_C('GL_GLYPH_HORIZONTAL_BEARING_Y_BIT_NV',0x08) +GL_GLYPH_VERTICAL_BEARING_ADVANCE_BIT_NV=_C('GL_GLYPH_VERTICAL_BEARING_ADVANCE_BIT_NV',0x80) +GL_GLYPH_VERTICAL_BEARING_X_BIT_NV=_C('GL_GLYPH_VERTICAL_BEARING_X_BIT_NV',0x20) +GL_GLYPH_VERTICAL_BEARING_Y_BIT_NV=_C('GL_GLYPH_VERTICAL_BEARING_Y_BIT_NV',0x40) +GL_GLYPH_WIDTH_BIT_NV=_C('GL_GLYPH_WIDTH_BIT_NV',0x01) +GL_HORIZONTAL_LINE_TO_NV=_C('GL_HORIZONTAL_LINE_TO_NV',0x06) +GL_ITALIC_BIT_NV=_C('GL_ITALIC_BIT_NV',0x02) +GL_LARGE_CCW_ARC_TO_NV=_C('GL_LARGE_CCW_ARC_TO_NV',0x16) +GL_LARGE_CW_ARC_TO_NV=_C('GL_LARGE_CW_ARC_TO_NV',0x18) +GL_LINE_TO_NV=_C('GL_LINE_TO_NV',0x04) +GL_MITER_REVERT_NV=_C('GL_MITER_REVERT_NV',0x90A7) +GL_MITER_TRUNCATE_NV=_C('GL_MITER_TRUNCATE_NV',0x90A8) +GL_MOVE_TO_CONTINUES_NV=_C('GL_MOVE_TO_CONTINUES_NV',0x90B6) +GL_MOVE_TO_NV=_C('GL_MOVE_TO_NV',0x02) +GL_MOVE_TO_RESETS_NV=_C('GL_MOVE_TO_RESETS_NV',0x90B5) +GL_OBJECT_LINEAR_NV=_C('GL_OBJECT_LINEAR_NV',0x2401) +GL_PATH_CLIENT_LENGTH_NV=_C('GL_PATH_CLIENT_LENGTH_NV',0x907F) +GL_PATH_COMMAND_COUNT_NV=_C('GL_PATH_COMMAND_COUNT_NV',0x909D) +GL_PATH_COMPUTED_LENGTH_NV=_C('GL_PATH_COMPUTED_LENGTH_NV',0x90A0) +GL_PATH_COORD_COUNT_NV=_C('GL_PATH_COORD_COUNT_NV',0x909E) +GL_PATH_COVER_DEPTH_FUNC_NV=_C('GL_PATH_COVER_DEPTH_FUNC_NV',0x90BF) +GL_PATH_DASH_ARRAY_COUNT_NV=_C('GL_PATH_DASH_ARRAY_COUNT_NV',0x909F) +GL_PATH_DASH_CAPS_NV=_C('GL_PATH_DASH_CAPS_NV',0x907B) +GL_PATH_DASH_OFFSET_NV=_C('GL_PATH_DASH_OFFSET_NV',0x907E) +GL_PATH_DASH_OFFSET_RESET_NV=_C('GL_PATH_DASH_OFFSET_RESET_NV',0x90B4) +GL_PATH_END_CAPS_NV=_C('GL_PATH_END_CAPS_NV',0x9076) +GL_PATH_ERROR_POSITION_NV=_C('GL_PATH_ERROR_POSITION_NV',0x90AB) +GL_PATH_FILL_BOUNDING_BOX_NV=_C('GL_PATH_FILL_BOUNDING_BOX_NV',0x90A1) +GL_PATH_FILL_COVER_MODE_NV=_C('GL_PATH_FILL_COVER_MODE_NV',0x9082) +GL_PATH_FILL_MASK_NV=_C('GL_PATH_FILL_MASK_NV',0x9081) +GL_PATH_FILL_MODE_NV=_C('GL_PATH_FILL_MODE_NV',0x9080) +GL_PATH_FOG_GEN_MODE_NV=_C('GL_PATH_FOG_GEN_MODE_NV',0x90AC) +GL_PATH_FORMAT_PS_NV=_C('GL_PATH_FORMAT_PS_NV',0x9071) +GL_PATH_FORMAT_SVG_NV=_C('GL_PATH_FORMAT_SVG_NV',0x9070) +GL_PATH_GEN_COEFF_NV=_C('GL_PATH_GEN_COEFF_NV',0x90B1) +GL_PATH_GEN_COLOR_FORMAT_NV=_C('GL_PATH_GEN_COLOR_FORMAT_NV',0x90B2) +GL_PATH_GEN_COMPONENTS_NV=_C('GL_PATH_GEN_COMPONENTS_NV',0x90B3) +GL_PATH_GEN_MODE_NV=_C('GL_PATH_GEN_MODE_NV',0x90B0) +GL_PATH_INITIAL_DASH_CAP_NV=_C('GL_PATH_INITIAL_DASH_CAP_NV',0x907C) +GL_PATH_INITIAL_END_CAP_NV=_C('GL_PATH_INITIAL_END_CAP_NV',0x9077) +GL_PATH_JOIN_STYLE_NV=_C('GL_PATH_JOIN_STYLE_NV',0x9079) +GL_PATH_MAX_MODELVIEW_STACK_DEPTH_NV=_C('GL_PATH_MAX_MODELVIEW_STACK_DEPTH_NV',0x0D36) +GL_PATH_MAX_PROJECTION_STACK_DEPTH_NV=_C('GL_PATH_MAX_PROJECTION_STACK_DEPTH_NV',0x0D38) +GL_PATH_MITER_LIMIT_NV=_C('GL_PATH_MITER_LIMIT_NV',0x907A) +GL_PATH_MODELVIEW_MATRIX_NV=_C('GL_PATH_MODELVIEW_MATRIX_NV',0x0BA6) +GL_PATH_MODELVIEW_NV=_C('GL_PATH_MODELVIEW_NV',0x1700) +GL_PATH_MODELVIEW_STACK_DEPTH_NV=_C('GL_PATH_MODELVIEW_STACK_DEPTH_NV',0x0BA3) +GL_PATH_OBJECT_BOUNDING_BOX_NV=_C('GL_PATH_OBJECT_BOUNDING_BOX_NV',0x908A) +GL_PATH_PROJECTION_MATRIX_NV=_C('GL_PATH_PROJECTION_MATRIX_NV',0x0BA7) +GL_PATH_PROJECTION_NV=_C('GL_PATH_PROJECTION_NV',0x1701) +GL_PATH_PROJECTION_STACK_DEPTH_NV=_C('GL_PATH_PROJECTION_STACK_DEPTH_NV',0x0BA4) +GL_PATH_STENCIL_DEPTH_OFFSET_FACTOR_NV=_C('GL_PATH_STENCIL_DEPTH_OFFSET_FACTOR_NV',0x90BD) +GL_PATH_STENCIL_DEPTH_OFFSET_UNITS_NV=_C('GL_PATH_STENCIL_DEPTH_OFFSET_UNITS_NV',0x90BE) +GL_PATH_STENCIL_FUNC_NV=_C('GL_PATH_STENCIL_FUNC_NV',0x90B7) +GL_PATH_STENCIL_REF_NV=_C('GL_PATH_STENCIL_REF_NV',0x90B8) +GL_PATH_STENCIL_VALUE_MASK_NV=_C('GL_PATH_STENCIL_VALUE_MASK_NV',0x90B9) +GL_PATH_STROKE_BOUNDING_BOX_NV=_C('GL_PATH_STROKE_BOUNDING_BOX_NV',0x90A2) +GL_PATH_STROKE_COVER_MODE_NV=_C('GL_PATH_STROKE_COVER_MODE_NV',0x9083) +GL_PATH_STROKE_MASK_NV=_C('GL_PATH_STROKE_MASK_NV',0x9084) +GL_PATH_STROKE_WIDTH_NV=_C('GL_PATH_STROKE_WIDTH_NV',0x9075) +GL_PATH_TERMINAL_DASH_CAP_NV=_C('GL_PATH_TERMINAL_DASH_CAP_NV',0x907D) +GL_PATH_TERMINAL_END_CAP_NV=_C('GL_PATH_TERMINAL_END_CAP_NV',0x9078) +GL_PATH_TRANSPOSE_MODELVIEW_MATRIX_NV=_C('GL_PATH_TRANSPOSE_MODELVIEW_MATRIX_NV',0x84E3) +GL_PATH_TRANSPOSE_PROJECTION_MATRIX_NV=_C('GL_PATH_TRANSPOSE_PROJECTION_MATRIX_NV',0x84E4) +GL_PRIMARY_COLOR=_C('GL_PRIMARY_COLOR',0x8577) +GL_PRIMARY_COLOR_NV=_C('GL_PRIMARY_COLOR_NV',0x852C) +GL_QUADRATIC_CURVE_TO_NV=_C('GL_QUADRATIC_CURVE_TO_NV',0x0A) +GL_RECT_NV=_C('GL_RECT_NV',0xF6) +GL_RELATIVE_ARC_TO_NV=_C('GL_RELATIVE_ARC_TO_NV',0xFF) +GL_RELATIVE_CONIC_CURVE_TO_NV=_C('GL_RELATIVE_CONIC_CURVE_TO_NV',0x1B) +GL_RELATIVE_CUBIC_CURVE_TO_NV=_C('GL_RELATIVE_CUBIC_CURVE_TO_NV',0x0D) +GL_RELATIVE_HORIZONTAL_LINE_TO_NV=_C('GL_RELATIVE_HORIZONTAL_LINE_TO_NV',0x07) +GL_RELATIVE_LARGE_CCW_ARC_TO_NV=_C('GL_RELATIVE_LARGE_CCW_ARC_TO_NV',0x17) +GL_RELATIVE_LARGE_CW_ARC_TO_NV=_C('GL_RELATIVE_LARGE_CW_ARC_TO_NV',0x19) +GL_RELATIVE_LINE_TO_NV=_C('GL_RELATIVE_LINE_TO_NV',0x05) +GL_RELATIVE_MOVE_TO_NV=_C('GL_RELATIVE_MOVE_TO_NV',0x03) +GL_RELATIVE_QUADRATIC_CURVE_TO_NV=_C('GL_RELATIVE_QUADRATIC_CURVE_TO_NV',0x0B) +GL_RELATIVE_RECT_NV=_C('GL_RELATIVE_RECT_NV',0xF7) +GL_RELATIVE_ROUNDED_RECT2_NV=_C('GL_RELATIVE_ROUNDED_RECT2_NV',0xEB) +GL_RELATIVE_ROUNDED_RECT4_NV=_C('GL_RELATIVE_ROUNDED_RECT4_NV',0xED) +GL_RELATIVE_ROUNDED_RECT8_NV=_C('GL_RELATIVE_ROUNDED_RECT8_NV',0xEF) +GL_RELATIVE_ROUNDED_RECT_NV=_C('GL_RELATIVE_ROUNDED_RECT_NV',0xE9) +GL_RELATIVE_SMALL_CCW_ARC_TO_NV=_C('GL_RELATIVE_SMALL_CCW_ARC_TO_NV',0x13) +GL_RELATIVE_SMALL_CW_ARC_TO_NV=_C('GL_RELATIVE_SMALL_CW_ARC_TO_NV',0x15) +GL_RELATIVE_SMOOTH_CUBIC_CURVE_TO_NV=_C('GL_RELATIVE_SMOOTH_CUBIC_CURVE_TO_NV',0x11) +GL_RELATIVE_SMOOTH_QUADRATIC_CURVE_TO_NV=_C('GL_RELATIVE_SMOOTH_QUADRATIC_CURVE_TO_NV',0x0F) +GL_RELATIVE_VERTICAL_LINE_TO_NV=_C('GL_RELATIVE_VERTICAL_LINE_TO_NV',0x09) +GL_RESTART_PATH_NV=_C('GL_RESTART_PATH_NV',0xF0) +GL_ROUNDED_RECT2_NV=_C('GL_ROUNDED_RECT2_NV',0xEA) +GL_ROUNDED_RECT4_NV=_C('GL_ROUNDED_RECT4_NV',0xEC) +GL_ROUNDED_RECT8_NV=_C('GL_ROUNDED_RECT8_NV',0xEE) +GL_ROUNDED_RECT_NV=_C('GL_ROUNDED_RECT_NV',0xE8) +GL_ROUND_NV=_C('GL_ROUND_NV',0x90A4) +GL_SECONDARY_COLOR_NV=_C('GL_SECONDARY_COLOR_NV',0x852D) +GL_SKIP_MISSING_GLYPH_NV=_C('GL_SKIP_MISSING_GLYPH_NV',0x90A9) +GL_SMALL_CCW_ARC_TO_NV=_C('GL_SMALL_CCW_ARC_TO_NV',0x12) +GL_SMALL_CW_ARC_TO_NV=_C('GL_SMALL_CW_ARC_TO_NV',0x14) +GL_SMOOTH_CUBIC_CURVE_TO_NV=_C('GL_SMOOTH_CUBIC_CURVE_TO_NV',0x10) +GL_SMOOTH_QUADRATIC_CURVE_TO_NV=_C('GL_SMOOTH_QUADRATIC_CURVE_TO_NV',0x0E) +GL_SQUARE_NV=_C('GL_SQUARE_NV',0x90A3) +GL_STANDARD_FONT_FORMAT_NV=_C('GL_STANDARD_FONT_FORMAT_NV',0x936C) +GL_STANDARD_FONT_NAME_NV=_C('GL_STANDARD_FONT_NAME_NV',0x9072) +GL_SYSTEM_FONT_NAME_NV=_C('GL_SYSTEM_FONT_NAME_NV',0x9073) +GL_TRANSLATE_2D_NV=_C('GL_TRANSLATE_2D_NV',0x9090) +GL_TRANSLATE_3D_NV=_C('GL_TRANSLATE_3D_NV',0x9091) +GL_TRANSLATE_X_NV=_C('GL_TRANSLATE_X_NV',0x908E) +GL_TRANSLATE_Y_NV=_C('GL_TRANSLATE_Y_NV',0x908F) +GL_TRANSPOSE_AFFINE_2D_NV=_C('GL_TRANSPOSE_AFFINE_2D_NV',0x9096) +GL_TRANSPOSE_AFFINE_3D_NV=_C('GL_TRANSPOSE_AFFINE_3D_NV',0x9098) +GL_TRIANGULAR_NV=_C('GL_TRIANGULAR_NV',0x90A5) +GL_USE_MISSING_GLYPH_NV=_C('GL_USE_MISSING_GLYPH_NV',0x90AA) +GL_UTF16_NV=_C('GL_UTF16_NV',0x909B) +GL_UTF8_NV=_C('GL_UTF8_NV',0x909A) +GL_VERTICAL_LINE_TO_NV=_C('GL_VERTICAL_LINE_TO_NV',0x08) +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint) +def glCopyPathNV(resultPath,srcPath):pass +@_f +@_p.types(None,_cs.GLsizei,_cs.GLenum,ctypes.c_void_p,_cs.GLuint,_cs.GLenum,_cs.GLenum,arrays.GLfloatArray) +def glCoverFillPathInstancedNV(numPaths,pathNameType,paths,pathBase,coverMode,transformType,transformValues):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum) +def glCoverFillPathNV(path,coverMode):pass +@_f +@_p.types(None,_cs.GLsizei,_cs.GLenum,ctypes.c_void_p,_cs.GLuint,_cs.GLenum,_cs.GLenum,arrays.GLfloatArray) +def glCoverStrokePathInstancedNV(numPaths,pathNameType,paths,pathBase,coverMode,transformType,transformValues):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum) +def glCoverStrokePathNV(path,coverMode):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizei) +def glDeletePathsNV(path,range):pass +@_f +@_p.types(_cs.GLuint,_cs.GLsizei) +def glGenPathsNV(range):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLfloatArray) +def glGetPathColorGenfvNV(color,pname,value):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLintArray) +def glGetPathColorGenivNV(color,pname,value):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLubyteArray) +def glGetPathCommandsNV(path,commands):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLfloatArray) +def glGetPathCoordsNV(path,coords):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLfloatArray) +def glGetPathDashArrayNV(path,dashArray):pass +@_f +@_p.types(_cs.GLfloat,_cs.GLuint,_cs.GLsizei,_cs.GLsizei) +def glGetPathLengthNV(path,startSegment,numSegments):pass +@_f +@_p.types(None,_cs.GLbitfield,_cs.GLuint,_cs.GLsizei,_cs.GLsizei,arrays.GLfloatArray) +def glGetPathMetricRangeNV(metricQueryMask,firstPathName,numPaths,stride,metrics):pass +@_f +@_p.types(None,_cs.GLbitfield,_cs.GLsizei,_cs.GLenum,ctypes.c_void_p,_cs.GLuint,_cs.GLsizei,arrays.GLfloatArray) +def glGetPathMetricsNV(metricQueryMask,numPaths,pathNameType,paths,pathBase,stride,metrics):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLfloatArray) +def glGetPathParameterfvNV(path,pname,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLintArray) +def glGetPathParameterivNV(path,pname,value):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizei,_cs.GLenum,ctypes.c_void_p,_cs.GLuint,_cs.GLfloat,_cs.GLfloat,_cs.GLenum,arrays.GLfloatArray) +def glGetPathSpacingNV(pathListMode,numPaths,pathNameType,paths,pathBase,advanceScale,kerningScale,transformType,returnedSpacing):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLfloatArray) +def glGetPathTexGenfvNV(texCoordSet,pname,value):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLintArray) +def glGetPathTexGenivNV(texCoordSet,pname,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLuint,_cs.GLsizei,arrays.GLuintArray,_cs.GLsizei,arrays.GLsizeiArray,arrays.GLfloatArray) +def glGetProgramResourcefvNV(program,programInterface,index,propCount,props,bufSize,length,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLuint,_cs.GLfloat) +def glInterpolatePathsNV(resultPath,pathA,pathB,weight):pass +@_f +@_p.types(_cs.GLboolean,_cs.GLuint) +def glIsPathNV(path):pass +@_f +@_p.types(_cs.GLboolean,_cs.GLuint,_cs.GLuint,_cs.GLfloat,_cs.GLfloat) +def glIsPointInFillPathNV(path,mask,x,y):pass +@_f +@_p.types(_cs.GLboolean,_cs.GLuint,_cs.GLfloat,_cs.GLfloat) +def glIsPointInStrokePathNV(path,x,y):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLdouble,_cs.GLdouble,_cs.GLdouble,_cs.GLdouble,_cs.GLdouble,_cs.GLdouble) +def glMatrixFrustumEXT(mode,left,right,bottom,top,zNear,zFar):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLfloatArray) +def glMatrixLoad3x2fNV(matrixMode,m):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLfloatArray) +def glMatrixLoad3x3fNV(matrixMode,m):pass +@_f +@_p.types(None,_cs.GLenum) +def glMatrixLoadIdentityEXT(mode):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLfloatArray) +def glMatrixLoadTranspose3x3fNV(matrixMode,m):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLdoubleArray) +def glMatrixLoadTransposedEXT(mode,m):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLfloatArray) +def glMatrixLoadTransposefEXT(mode,m):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLdoubleArray) +def glMatrixLoaddEXT(mode,m):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLfloatArray) +def glMatrixLoadfEXT(mode,m):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLfloatArray) +def glMatrixMult3x2fNV(matrixMode,m):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLfloatArray) +def glMatrixMult3x3fNV(matrixMode,m):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLfloatArray) +def glMatrixMultTranspose3x3fNV(matrixMode,m):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLdoubleArray) +def glMatrixMultTransposedEXT(mode,m):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLfloatArray) +def glMatrixMultTransposefEXT(mode,m):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLdoubleArray) +def glMatrixMultdEXT(mode,m):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLfloatArray) +def glMatrixMultfEXT(mode,m):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLdouble,_cs.GLdouble,_cs.GLdouble,_cs.GLdouble,_cs.GLdouble,_cs.GLdouble) +def glMatrixOrthoEXT(mode,left,right,bottom,top,zNear,zFar):pass +@_f +@_p.types(None,_cs.GLenum) +def glMatrixPopEXT(mode):pass +@_f +@_p.types(None,_cs.GLenum) +def glMatrixPushEXT(mode):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLdouble,_cs.GLdouble,_cs.GLdouble,_cs.GLdouble) +def glMatrixRotatedEXT(mode,angle,x,y,z):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat) +def glMatrixRotatefEXT(mode,angle,x,y,z):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLdouble,_cs.GLdouble,_cs.GLdouble) +def glMatrixScaledEXT(mode,x,y,z):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat) +def glMatrixScalefEXT(mode,x,y,z):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLdouble,_cs.GLdouble,_cs.GLdouble) +def glMatrixTranslatedEXT(mode,x,y,z):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat) +def glMatrixTranslatefEXT(mode,x,y,z):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLenum,arrays.GLfloatArray) +def glPathColorGenNV(color,genMode,colorFormat,coeffs):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizei,arrays.GLubyteArray,_cs.GLsizei,_cs.GLenum,ctypes.c_void_p) +def glPathCommandsNV(path,numCommands,commands,numCoords,coordType,coords):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizei,_cs.GLenum,ctypes.c_void_p) +def glPathCoordsNV(path,numCoords,coordType,coords):pass +@_f +@_p.types(None,_cs.GLenum) +def glPathCoverDepthFuncNV(func):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizei,arrays.GLfloatArray) +def glPathDashArrayNV(path,dashCount,dashArray):pass +@_f +@_p.types(None,_cs.GLenum) +def glPathFogGenNV(genMode):pass +@_f +@_p.types(_cs.GLenum,_cs.GLuint,_cs.GLenum,ctypes.c_void_p,_cs.GLbitfield,_cs.GLuint,_cs.GLsizei,_cs.GLuint,_cs.GLfloat) +def glPathGlyphIndexArrayNV(firstPathName,fontTarget,fontName,fontStyle,firstGlyphIndex,numGlyphs,pathParameterTemplate,emScale):pass +@_f +@_p.types(_cs.GLenum,_cs.GLenum,ctypes.c_void_p,_cs.GLbitfield,_cs.GLuint,_cs.GLfloat,_cs.GLuint) +def glPathGlyphIndexRangeNV(fontTarget,fontName,fontStyle,pathParameterTemplate,emScale,baseAndCount):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,ctypes.c_void_p,_cs.GLbitfield,_cs.GLuint,_cs.GLsizei,_cs.GLenum,_cs.GLuint,_cs.GLfloat) +def glPathGlyphRangeNV(firstPathName,fontTarget,fontName,fontStyle,firstGlyph,numGlyphs,handleMissingGlyphs,pathParameterTemplate,emScale):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,ctypes.c_void_p,_cs.GLbitfield,_cs.GLsizei,_cs.GLenum,ctypes.c_void_p,_cs.GLenum,_cs.GLuint,_cs.GLfloat) +def glPathGlyphsNV(firstPathName,fontTarget,fontName,fontStyle,numGlyphs,type,charcodes,handleMissingGlyphs,pathParameterTemplate,emScale):pass +@_f +@_p.types(_cs.GLenum,_cs.GLuint,_cs.GLenum,_cs.GLsizeiptr,ctypes.c_void_p,_cs.GLsizei,_cs.GLuint,_cs.GLsizei,_cs.GLuint,_cs.GLfloat) +def glPathMemoryGlyphIndexArrayNV(firstPathName,fontTarget,fontSize,fontData,faceIndex,firstGlyphIndex,numGlyphs,pathParameterTemplate,emScale):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLfloat) +def glPathParameterfNV(path,pname,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLfloatArray) +def glPathParameterfvNV(path,pname,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLint) +def glPathParameteriNV(path,pname,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLintArray) +def glPathParameterivNV(path,pname,value):pass +@_f +@_p.types(None,_cs.GLfloat,_cs.GLfloat) +def glPathStencilDepthOffsetNV(factor,units):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLint,_cs.GLuint) +def glPathStencilFuncNV(func,ref,mask):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLsizei,ctypes.c_void_p) +def glPathStringNV(path,format,length,pathString):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizei,_cs.GLsizei,_cs.GLsizei,arrays.GLubyteArray,_cs.GLsizei,_cs.GLenum,ctypes.c_void_p) +def glPathSubCommandsNV(path,commandStart,commandsToDelete,numCommands,commands,numCoords,coordType,coords):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizei,_cs.GLsizei,_cs.GLenum,ctypes.c_void_p) +def glPathSubCoordsNV(path,coordStart,numCoords,coordType,coords):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLint,arrays.GLfloatArray) +def glPathTexGenNV(texCoordSet,genMode,components,coeffs):pass +@_f +@_p.types(_cs.GLboolean,_cs.GLuint,_cs.GLsizei,_cs.GLsizei,_cs.GLfloat,arrays.GLfloatArray,arrays.GLfloatArray,arrays.GLfloatArray,arrays.GLfloatArray) +def glPointAlongPathNV(path,startSegment,numSegments,distance,x,y,tangentX,tangentY):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLenum,_cs.GLint,arrays.GLfloatArray) +def glProgramPathFragmentInputGenNV(program,location,genMode,components,coeffs):pass +@_f +@_p.types(None,_cs.GLsizei,_cs.GLenum,ctypes.c_void_p,_cs.GLuint,_cs.GLenum,_cs.GLuint,_cs.GLenum,arrays.GLfloatArray) +def glStencilFillPathInstancedNV(numPaths,pathNameType,paths,pathBase,fillMode,mask,transformType,transformValues):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLuint) +def glStencilFillPathNV(path,fillMode,mask):pass +@_f +@_p.types(None,_cs.GLsizei,_cs.GLenum,ctypes.c_void_p,_cs.GLuint,_cs.GLint,_cs.GLuint,_cs.GLenum,arrays.GLfloatArray) +def glStencilStrokePathInstancedNV(numPaths,pathNameType,paths,pathBase,reference,mask,transformType,transformValues):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLuint) +def glStencilStrokePathNV(path,reference,mask):pass +@_f +@_p.types(None,_cs.GLsizei,_cs.GLenum,ctypes.c_void_p,_cs.GLuint,_cs.GLenum,_cs.GLuint,_cs.GLenum,_cs.GLenum,arrays.GLfloatArray) +def glStencilThenCoverFillPathInstancedNV(numPaths,pathNameType,paths,pathBase,fillMode,mask,coverMode,transformType,transformValues):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLuint,_cs.GLenum) +def glStencilThenCoverFillPathNV(path,fillMode,mask,coverMode):pass +@_f +@_p.types(None,_cs.GLsizei,_cs.GLenum,ctypes.c_void_p,_cs.GLuint,_cs.GLint,_cs.GLuint,_cs.GLenum,_cs.GLenum,arrays.GLfloatArray) +def glStencilThenCoverStrokePathInstancedNV(numPaths,pathNameType,paths,pathBase,reference,mask,coverMode,transformType,transformValues):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLuint,_cs.GLenum) +def glStencilThenCoverStrokePathNV(path,reference,mask,coverMode):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLenum,arrays.GLfloatArray) +def glTransformPathNV(resultPath,srcPath,transformType,transformValues):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizei,arrays.GLuintArray,arrays.GLfloatArray) +def glWeightPathsNV(resultPath,numPaths,paths,weights):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/path_rendering_shared_edge.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/path_rendering_shared_edge.py new file mode 100644 index 00000000..8477aed2 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/path_rendering_shared_edge.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_NV_path_rendering_shared_edge' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_NV_path_rendering_shared_edge',error_checker=_errors._error_checker) +GL_SHARED_EDGE_NV=_C('GL_SHARED_EDGE_NV',0xC0) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/pixel_data_range.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/pixel_data_range.py new file mode 100644 index 00000000..10bbe698 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/pixel_data_range.py @@ -0,0 +1,25 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_NV_pixel_data_range' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_NV_pixel_data_range',error_checker=_errors._error_checker) +GL_READ_PIXEL_DATA_RANGE_LENGTH_NV=_C('GL_READ_PIXEL_DATA_RANGE_LENGTH_NV',0x887B) +GL_READ_PIXEL_DATA_RANGE_NV=_C('GL_READ_PIXEL_DATA_RANGE_NV',0x8879) +GL_READ_PIXEL_DATA_RANGE_POINTER_NV=_C('GL_READ_PIXEL_DATA_RANGE_POINTER_NV',0x887D) +GL_WRITE_PIXEL_DATA_RANGE_LENGTH_NV=_C('GL_WRITE_PIXEL_DATA_RANGE_LENGTH_NV',0x887A) +GL_WRITE_PIXEL_DATA_RANGE_NV=_C('GL_WRITE_PIXEL_DATA_RANGE_NV',0x8878) +GL_WRITE_PIXEL_DATA_RANGE_POINTER_NV=_C('GL_WRITE_PIXEL_DATA_RANGE_POINTER_NV',0x887C) +@_f +@_p.types(None,_cs.GLenum) +def glFlushPixelDataRangeNV(target):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizei,ctypes.c_void_p) +def glPixelDataRangeNV(target,length,pointer):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/point_sprite.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/point_sprite.py new file mode 100644 index 00000000..d5a14bd9 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/point_sprite.py @@ -0,0 +1,22 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_NV_point_sprite' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_NV_point_sprite',error_checker=_errors._error_checker) +GL_COORD_REPLACE_NV=_C('GL_COORD_REPLACE_NV',0x8862) +GL_POINT_SPRITE_NV=_C('GL_POINT_SPRITE_NV',0x8861) +GL_POINT_SPRITE_R_MODE_NV=_C('GL_POINT_SPRITE_R_MODE_NV',0x8863) +@_f +@_p.types(None,_cs.GLenum,_cs.GLint) +def glPointParameteriNV(pname,param):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLintArray) +def glPointParameterivNV(pname,params):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/present_video.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/present_video.py new file mode 100644 index 00000000..0f5357f6 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/present_video.py @@ -0,0 +1,37 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_NV_present_video' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_NV_present_video',error_checker=_errors._error_checker) +GL_CURRENT_TIME_NV=_C('GL_CURRENT_TIME_NV',0x8E28) +GL_FIELDS_NV=_C('GL_FIELDS_NV',0x8E27) +GL_FRAME_NV=_C('GL_FRAME_NV',0x8E26) +GL_NUM_FILL_STREAMS_NV=_C('GL_NUM_FILL_STREAMS_NV',0x8E29) +GL_PRESENT_DURATION_NV=_C('GL_PRESENT_DURATION_NV',0x8E2B) +GL_PRESENT_TIME_NV=_C('GL_PRESENT_TIME_NV',0x8E2A) +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLint64Array) +def glGetVideoi64vNV(video_slot,pname,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLintArray) +def glGetVideoivNV(video_slot,pname,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLuint64Array) +def glGetVideoui64vNV(video_slot,pname,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLuintArray) +def glGetVideouivNV(video_slot,pname,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint64EXT,_cs.GLuint,_cs.GLuint,_cs.GLenum,_cs.GLenum,_cs.GLuint,_cs.GLenum,_cs.GLuint,_cs.GLenum,_cs.GLuint,_cs.GLenum,_cs.GLuint) +def glPresentFrameDualFillNV(video_slot,minPresentTime,beginPresentTimeId,presentDurationId,type,target0,fill0,target1,fill1,target2,fill2,target3,fill3):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint64EXT,_cs.GLuint,_cs.GLuint,_cs.GLenum,_cs.GLenum,_cs.GLuint,_cs.GLuint,_cs.GLenum,_cs.GLuint,_cs.GLuint) +def glPresentFrameKeyedNV(video_slot,minPresentTime,beginPresentTimeId,presentDurationId,type,target0,fill0,key0,target1,fill1,key1):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/primitive_restart.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/primitive_restart.py new file mode 100644 index 00000000..472b47d2 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/primitive_restart.py @@ -0,0 +1,21 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_NV_primitive_restart' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_NV_primitive_restart',error_checker=_errors._error_checker) +GL_PRIMITIVE_RESTART_INDEX_NV=_C('GL_PRIMITIVE_RESTART_INDEX_NV',0x8559) +GL_PRIMITIVE_RESTART_NV=_C('GL_PRIMITIVE_RESTART_NV',0x8558) +@_f +@_p.types(None,_cs.GLuint) +def glPrimitiveRestartIndexNV(index):pass +@_f +@_p.types(None,) +def glPrimitiveRestartNV():pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/query_resource.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/query_resource.py new file mode 100644 index 00000000..fb97908e --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/query_resource.py @@ -0,0 +1,22 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_NV_query_resource' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_NV_query_resource',error_checker=_errors._error_checker) +GL_QUERY_RESOURCE_BUFFEROBJECT_NV=_C('GL_QUERY_RESOURCE_BUFFEROBJECT_NV',0x9547) +GL_QUERY_RESOURCE_MEMTYPE_VIDMEM_NV=_C('GL_QUERY_RESOURCE_MEMTYPE_VIDMEM_NV',0x9542) +GL_QUERY_RESOURCE_RENDERBUFFER_NV=_C('GL_QUERY_RESOURCE_RENDERBUFFER_NV',0x9546) +GL_QUERY_RESOURCE_SYS_RESERVED_NV=_C('GL_QUERY_RESOURCE_SYS_RESERVED_NV',0x9544) +GL_QUERY_RESOURCE_TEXTURE_NV=_C('GL_QUERY_RESOURCE_TEXTURE_NV',0x9545) +GL_QUERY_RESOURCE_TYPE_VIDMEM_ALLOC_NV=_C('GL_QUERY_RESOURCE_TYPE_VIDMEM_ALLOC_NV',0x9540) +@_f +@_p.types(_cs.GLint,_cs.GLenum,_cs.GLint,_cs.GLuint,arrays.GLintArray) +def glQueryResourceNV(queryType,tagId,bufSize,buffer):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/query_resource_tag.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/query_resource_tag.py new file mode 100644 index 00000000..72cbccbf --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/query_resource_tag.py @@ -0,0 +1,23 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_NV_query_resource_tag' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_NV_query_resource_tag',error_checker=_errors._error_checker) + +@_f +@_p.types(None,_cs.GLsizei,arrays.GLintArray) +def glDeleteQueryResourceTagNV(n,tagIds):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLintArray) +def glGenQueryResourceTagNV(n,tagIds):pass +@_f +@_p.types(None,_cs.GLint,arrays.GLcharArray) +def glQueryResourceTagNV(tagId,tagString):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/register_combiners.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/register_combiners.py new file mode 100644 index 00000000..bb1e2e45 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/register_combiners.py @@ -0,0 +1,108 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_NV_register_combiners' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_NV_register_combiners',error_checker=_errors._error_checker) +GL_BIAS_BY_NEGATIVE_ONE_HALF_NV=_C('GL_BIAS_BY_NEGATIVE_ONE_HALF_NV',0x8541) +GL_COLOR_SUM_CLAMP_NV=_C('GL_COLOR_SUM_CLAMP_NV',0x854F) +GL_COMBINER0_NV=_C('GL_COMBINER0_NV',0x8550) +GL_COMBINER1_NV=_C('GL_COMBINER1_NV',0x8551) +GL_COMBINER2_NV=_C('GL_COMBINER2_NV',0x8552) +GL_COMBINER3_NV=_C('GL_COMBINER3_NV',0x8553) +GL_COMBINER4_NV=_C('GL_COMBINER4_NV',0x8554) +GL_COMBINER5_NV=_C('GL_COMBINER5_NV',0x8555) +GL_COMBINER6_NV=_C('GL_COMBINER6_NV',0x8556) +GL_COMBINER7_NV=_C('GL_COMBINER7_NV',0x8557) +GL_COMBINER_AB_DOT_PRODUCT_NV=_C('GL_COMBINER_AB_DOT_PRODUCT_NV',0x8545) +GL_COMBINER_AB_OUTPUT_NV=_C('GL_COMBINER_AB_OUTPUT_NV',0x854A) +GL_COMBINER_BIAS_NV=_C('GL_COMBINER_BIAS_NV',0x8549) +GL_COMBINER_CD_DOT_PRODUCT_NV=_C('GL_COMBINER_CD_DOT_PRODUCT_NV',0x8546) +GL_COMBINER_CD_OUTPUT_NV=_C('GL_COMBINER_CD_OUTPUT_NV',0x854B) +GL_COMBINER_COMPONENT_USAGE_NV=_C('GL_COMBINER_COMPONENT_USAGE_NV',0x8544) +GL_COMBINER_INPUT_NV=_C('GL_COMBINER_INPUT_NV',0x8542) +GL_COMBINER_MAPPING_NV=_C('GL_COMBINER_MAPPING_NV',0x8543) +GL_COMBINER_MUX_SUM_NV=_C('GL_COMBINER_MUX_SUM_NV',0x8547) +GL_COMBINER_SCALE_NV=_C('GL_COMBINER_SCALE_NV',0x8548) +GL_COMBINER_SUM_OUTPUT_NV=_C('GL_COMBINER_SUM_OUTPUT_NV',0x854C) +GL_CONSTANT_COLOR0_NV=_C('GL_CONSTANT_COLOR0_NV',0x852A) +GL_CONSTANT_COLOR1_NV=_C('GL_CONSTANT_COLOR1_NV',0x852B) +GL_DISCARD_NV=_C('GL_DISCARD_NV',0x8530) +GL_EXPAND_NEGATE_NV=_C('GL_EXPAND_NEGATE_NV',0x8539) +GL_EXPAND_NORMAL_NV=_C('GL_EXPAND_NORMAL_NV',0x8538) +GL_E_TIMES_F_NV=_C('GL_E_TIMES_F_NV',0x8531) +GL_FOG=_C('GL_FOG',0x0B60) +GL_HALF_BIAS_NEGATE_NV=_C('GL_HALF_BIAS_NEGATE_NV',0x853B) +GL_HALF_BIAS_NORMAL_NV=_C('GL_HALF_BIAS_NORMAL_NV',0x853A) +GL_MAX_GENERAL_COMBINERS_NV=_C('GL_MAX_GENERAL_COMBINERS_NV',0x854D) +GL_NONE=_C('GL_NONE',0) +GL_NUM_GENERAL_COMBINERS_NV=_C('GL_NUM_GENERAL_COMBINERS_NV',0x854E) +GL_PRIMARY_COLOR_NV=_C('GL_PRIMARY_COLOR_NV',0x852C) +GL_REGISTER_COMBINERS_NV=_C('GL_REGISTER_COMBINERS_NV',0x8522) +GL_SCALE_BY_FOUR_NV=_C('GL_SCALE_BY_FOUR_NV',0x853F) +GL_SCALE_BY_ONE_HALF_NV=_C('GL_SCALE_BY_ONE_HALF_NV',0x8540) +GL_SCALE_BY_TWO_NV=_C('GL_SCALE_BY_TWO_NV',0x853E) +GL_SECONDARY_COLOR_NV=_C('GL_SECONDARY_COLOR_NV',0x852D) +GL_SIGNED_IDENTITY_NV=_C('GL_SIGNED_IDENTITY_NV',0x853C) +GL_SIGNED_NEGATE_NV=_C('GL_SIGNED_NEGATE_NV',0x853D) +GL_SPARE0_NV=_C('GL_SPARE0_NV',0x852E) +GL_SPARE0_PLUS_SECONDARY_COLOR_NV=_C('GL_SPARE0_PLUS_SECONDARY_COLOR_NV',0x8532) +GL_SPARE1_NV=_C('GL_SPARE1_NV',0x852F) +GL_TEXTURE0_ARB=_C('GL_TEXTURE0_ARB',0x84C0) +GL_TEXTURE1_ARB=_C('GL_TEXTURE1_ARB',0x84C1) +GL_UNSIGNED_IDENTITY_NV=_C('GL_UNSIGNED_IDENTITY_NV',0x8536) +GL_UNSIGNED_INVERT_NV=_C('GL_UNSIGNED_INVERT_NV',0x8537) +GL_VARIABLE_A_NV=_C('GL_VARIABLE_A_NV',0x8523) +GL_VARIABLE_B_NV=_C('GL_VARIABLE_B_NV',0x8524) +GL_VARIABLE_C_NV=_C('GL_VARIABLE_C_NV',0x8525) +GL_VARIABLE_D_NV=_C('GL_VARIABLE_D_NV',0x8526) +GL_VARIABLE_E_NV=_C('GL_VARIABLE_E_NV',0x8527) +GL_VARIABLE_F_NV=_C('GL_VARIABLE_F_NV',0x8528) +GL_VARIABLE_G_NV=_C('GL_VARIABLE_G_NV',0x8529) +GL_ZERO=_C('GL_ZERO',0) +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLenum,_cs.GLenum,_cs.GLenum,_cs.GLenum) +def glCombinerInputNV(stage,portion,variable,input,mapping,componentUsage):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLenum,_cs.GLenum,_cs.GLenum,_cs.GLenum,_cs.GLenum,_cs.GLboolean,_cs.GLboolean,_cs.GLboolean) +def glCombinerOutputNV(stage,portion,abOutput,cdOutput,sumOutput,scale,bias,abDotProduct,cdDotProduct,muxSum):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLfloat) +def glCombinerParameterfNV(pname,param):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLfloatArray) +def glCombinerParameterfvNV(pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLint) +def glCombinerParameteriNV(pname,param):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLintArray) +def glCombinerParameterivNV(pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLenum,_cs.GLenum) +def glFinalCombinerInputNV(variable,input,mapping,componentUsage):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLenum,_cs.GLenum,arrays.GLfloatArray) +def glGetCombinerInputParameterfvNV(stage,portion,variable,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLenum,_cs.GLenum,arrays.GLintArray) +def glGetCombinerInputParameterivNV(stage,portion,variable,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLenum,arrays.GLfloatArray) +def glGetCombinerOutputParameterfvNV(stage,portion,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLenum,arrays.GLintArray) +def glGetCombinerOutputParameterivNV(stage,portion,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLfloatArray) +def glGetFinalCombinerInputParameterfvNV(variable,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLintArray) +def glGetFinalCombinerInputParameterivNV(variable,pname,params):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/register_combiners2.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/register_combiners2.py new file mode 100644 index 00000000..f4b1a6e1 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/register_combiners2.py @@ -0,0 +1,20 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_NV_register_combiners2' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_NV_register_combiners2',error_checker=_errors._error_checker) +GL_PER_STAGE_CONSTANTS_NV=_C('GL_PER_STAGE_CONSTANTS_NV',0x8535) +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLfloatArray) +def glCombinerStageParameterfvNV(stage,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLfloatArray) +def glGetCombinerStageParameterfvNV(stage,pname,params):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/representative_fragment_test.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/representative_fragment_test.py new file mode 100644 index 00000000..f94011b4 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/representative_fragment_test.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_NV_representative_fragment_test' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_NV_representative_fragment_test',error_checker=_errors._error_checker) +GL_REPRESENTATIVE_FRAGMENT_TEST_NV=_C('GL_REPRESENTATIVE_FRAGMENT_TEST_NV',0x937F) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/robustness_video_memory_purge.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/robustness_video_memory_purge.py new file mode 100644 index 00000000..d19209a1 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/robustness_video_memory_purge.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_NV_robustness_video_memory_purge' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_NV_robustness_video_memory_purge',error_checker=_errors._error_checker) +GL_PURGED_CONTEXT_RESET_NV=_C('GL_PURGED_CONTEXT_RESET_NV',0x92BB) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/sample_locations.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/sample_locations.py new file mode 100644 index 00000000..d429b594 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/sample_locations.py @@ -0,0 +1,30 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_NV_sample_locations' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_NV_sample_locations',error_checker=_errors._error_checker) +GL_FRAMEBUFFER_PROGRAMMABLE_SAMPLE_LOCATIONS_NV=_C('GL_FRAMEBUFFER_PROGRAMMABLE_SAMPLE_LOCATIONS_NV',0x9342) +GL_FRAMEBUFFER_SAMPLE_LOCATION_PIXEL_GRID_NV=_C('GL_FRAMEBUFFER_SAMPLE_LOCATION_PIXEL_GRID_NV',0x9343) +GL_PROGRAMMABLE_SAMPLE_LOCATION_NV=_C('GL_PROGRAMMABLE_SAMPLE_LOCATION_NV',0x9341) +GL_PROGRAMMABLE_SAMPLE_LOCATION_TABLE_SIZE_NV=_C('GL_PROGRAMMABLE_SAMPLE_LOCATION_TABLE_SIZE_NV',0x9340) +GL_SAMPLE_LOCATION_NV=_C('GL_SAMPLE_LOCATION_NV',0x8E50) +GL_SAMPLE_LOCATION_PIXEL_GRID_HEIGHT_NV=_C('GL_SAMPLE_LOCATION_PIXEL_GRID_HEIGHT_NV',0x933F) +GL_SAMPLE_LOCATION_PIXEL_GRID_WIDTH_NV=_C('GL_SAMPLE_LOCATION_PIXEL_GRID_WIDTH_NV',0x933E) +GL_SAMPLE_LOCATION_SUBPIXEL_BITS_NV=_C('GL_SAMPLE_LOCATION_SUBPIXEL_BITS_NV',0x933D) +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,_cs.GLsizei,arrays.GLfloatArray) +def glFramebufferSampleLocationsfvNV(target,start,count,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLsizei,arrays.GLfloatArray) +def glNamedFramebufferSampleLocationsfvNV(framebuffer,start,count,v):pass +@_f +@_p.types(None,) +def glResolveDepthValuesNV():pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/sample_mask_override_coverage.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/sample_mask_override_coverage.py new file mode 100644 index 00000000..9e6d6765 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/sample_mask_override_coverage.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_NV_sample_mask_override_coverage' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_NV_sample_mask_override_coverage',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/scissor_exclusive.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/scissor_exclusive.py new file mode 100644 index 00000000..171be1c1 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/scissor_exclusive.py @@ -0,0 +1,21 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_NV_scissor_exclusive' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_NV_scissor_exclusive',error_checker=_errors._error_checker) +GL_SCISSOR_BOX_EXCLUSIVE_NV=_C('GL_SCISSOR_BOX_EXCLUSIVE_NV',0x9556) +GL_SCISSOR_TEST_EXCLUSIVE_NV=_C('GL_SCISSOR_TEST_EXCLUSIVE_NV',0x9555) +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizei,arrays.GLintArray) +def glScissorExclusiveArrayvNV(first,count,v):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLsizei) +def glScissorExclusiveNV(x,y,width,height):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/shader_atomic_counters.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/shader_atomic_counters.py new file mode 100644 index 00000000..2720f0b8 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/shader_atomic_counters.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_NV_shader_atomic_counters' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_NV_shader_atomic_counters',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/shader_atomic_float.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/shader_atomic_float.py new file mode 100644 index 00000000..2cb0fcc6 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/shader_atomic_float.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_NV_shader_atomic_float' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_NV_shader_atomic_float',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/shader_atomic_float64.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/shader_atomic_float64.py new file mode 100644 index 00000000..18e25d8a --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/shader_atomic_float64.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_NV_shader_atomic_float64' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_NV_shader_atomic_float64',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/shader_atomic_fp16_vector.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/shader_atomic_fp16_vector.py new file mode 100644 index 00000000..739f0b40 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/shader_atomic_fp16_vector.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_NV_shader_atomic_fp16_vector' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_NV_shader_atomic_fp16_vector',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/shader_atomic_int64.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/shader_atomic_int64.py new file mode 100644 index 00000000..0eaa85e4 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/shader_atomic_int64.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_NV_shader_atomic_int64' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_NV_shader_atomic_int64',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/shader_buffer_load.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/shader_buffer_load.py new file mode 100644 index 00000000..b5314ebb --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/shader_buffer_load.py @@ -0,0 +1,58 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_NV_shader_buffer_load' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_NV_shader_buffer_load',error_checker=_errors._error_checker) +GL_BUFFER_GPU_ADDRESS_NV=_C('GL_BUFFER_GPU_ADDRESS_NV',0x8F1D) +GL_GPU_ADDRESS_NV=_C('GL_GPU_ADDRESS_NV',0x8F34) +GL_MAX_SHADER_BUFFER_ADDRESS_NV=_C('GL_MAX_SHADER_BUFFER_ADDRESS_NV',0x8F35) +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLuint64Array) +def glGetBufferParameterui64vNV(target,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLuint64Array) +def glGetIntegerui64vNV(value,result):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLuint64Array) +def glGetNamedBufferParameterui64vNV(buffer,pname,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,arrays.GLuint64Array) +def glGetUniformui64vNV(program,location,params):pass +@_f +@_p.types(_cs.GLboolean,_cs.GLenum) +def glIsBufferResidentNV(target):pass +@_f +@_p.types(_cs.GLboolean,_cs.GLuint) +def glIsNamedBufferResidentNV(buffer):pass +@_f +@_p.types(None,_cs.GLenum) +def glMakeBufferNonResidentNV(target):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum) +def glMakeBufferResidentNV(target,access):pass +@_f +@_p.types(None,_cs.GLuint) +def glMakeNamedBufferNonResidentNV(buffer):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum) +def glMakeNamedBufferResidentNV(buffer,access):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLuint64EXT) +def glProgramUniformui64NV(program,location,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLuint64Array) +def glProgramUniformui64vNV(program,location,count,value):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLuint64EXT) +def glUniformui64NV(location,value):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLsizei,arrays.GLuint64Array) +def glUniformui64vNV(location,count,value):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/shader_buffer_store.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/shader_buffer_store.py new file mode 100644 index 00000000..a466cb0d --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/shader_buffer_store.py @@ -0,0 +1,17 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_NV_shader_buffer_store' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_NV_shader_buffer_store',error_checker=_errors._error_checker) +GL_READ_WRITE=_C('GL_READ_WRITE',0x88BA) +GL_SHADER_GLOBAL_ACCESS_BARRIER_BIT_NV=_C('GL_SHADER_GLOBAL_ACCESS_BARRIER_BIT_NV',0x00000010) +GL_WRITE_ONLY=_C('GL_WRITE_ONLY',0x88B9) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/shader_storage_buffer_object.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/shader_storage_buffer_object.py new file mode 100644 index 00000000..923f1532 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/shader_storage_buffer_object.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_NV_shader_storage_buffer_object' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_NV_shader_storage_buffer_object',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/shader_subgroup_partitioned.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/shader_subgroup_partitioned.py new file mode 100644 index 00000000..00c225fd --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/shader_subgroup_partitioned.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_NV_shader_subgroup_partitioned' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_NV_shader_subgroup_partitioned',error_checker=_errors._error_checker) +GL_SUBGROUP_FEATURE_PARTITIONED_BIT_NV=_C('GL_SUBGROUP_FEATURE_PARTITIONED_BIT_NV',0x00000100) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/shader_texture_footprint.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/shader_texture_footprint.py new file mode 100644 index 00000000..5dfbe936 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/shader_texture_footprint.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_NV_shader_texture_footprint' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_NV_shader_texture_footprint',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/shader_thread_group.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/shader_thread_group.py new file mode 100644 index 00000000..3c122ad7 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/shader_thread_group.py @@ -0,0 +1,17 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_NV_shader_thread_group' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_NV_shader_thread_group',error_checker=_errors._error_checker) +GL_SM_COUNT_NV=_C('GL_SM_COUNT_NV',0x933B) +GL_WARPS_PER_SM_NV=_C('GL_WARPS_PER_SM_NV',0x933A) +GL_WARP_SIZE_NV=_C('GL_WARP_SIZE_NV',0x9339) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/shader_thread_shuffle.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/shader_thread_shuffle.py new file mode 100644 index 00000000..fe252cb2 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/shader_thread_shuffle.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_NV_shader_thread_shuffle' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_NV_shader_thread_shuffle',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/shading_rate_image.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/shading_rate_image.py new file mode 100644 index 00000000..3fed3ec6 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/shading_rate_image.py @@ -0,0 +1,58 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_NV_shading_rate_image' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_NV_shading_rate_image',error_checker=_errors._error_checker) +GL_MAX_COARSE_FRAGMENT_SAMPLES_NV=_C('GL_MAX_COARSE_FRAGMENT_SAMPLES_NV',0x955F) +GL_SHADING_RATE_16_INVOCATIONS_PER_PIXEL_NV=_C('GL_SHADING_RATE_16_INVOCATIONS_PER_PIXEL_NV',0x956F) +GL_SHADING_RATE_1_INVOCATION_PER_1X2_PIXELS_NV=_C('GL_SHADING_RATE_1_INVOCATION_PER_1X2_PIXELS_NV',0x9566) +GL_SHADING_RATE_1_INVOCATION_PER_2X1_PIXELS_NV=_C('GL_SHADING_RATE_1_INVOCATION_PER_2X1_PIXELS_NV',0x9567) +GL_SHADING_RATE_1_INVOCATION_PER_2X2_PIXELS_NV=_C('GL_SHADING_RATE_1_INVOCATION_PER_2X2_PIXELS_NV',0x9568) +GL_SHADING_RATE_1_INVOCATION_PER_2X4_PIXELS_NV=_C('GL_SHADING_RATE_1_INVOCATION_PER_2X4_PIXELS_NV',0x9569) +GL_SHADING_RATE_1_INVOCATION_PER_4X2_PIXELS_NV=_C('GL_SHADING_RATE_1_INVOCATION_PER_4X2_PIXELS_NV',0x956A) +GL_SHADING_RATE_1_INVOCATION_PER_4X4_PIXELS_NV=_C('GL_SHADING_RATE_1_INVOCATION_PER_4X4_PIXELS_NV',0x956B) +GL_SHADING_RATE_1_INVOCATION_PER_PIXEL_NV=_C('GL_SHADING_RATE_1_INVOCATION_PER_PIXEL_NV',0x9565) +GL_SHADING_RATE_2_INVOCATIONS_PER_PIXEL_NV=_C('GL_SHADING_RATE_2_INVOCATIONS_PER_PIXEL_NV',0x956C) +GL_SHADING_RATE_4_INVOCATIONS_PER_PIXEL_NV=_C('GL_SHADING_RATE_4_INVOCATIONS_PER_PIXEL_NV',0x956D) +GL_SHADING_RATE_8_INVOCATIONS_PER_PIXEL_NV=_C('GL_SHADING_RATE_8_INVOCATIONS_PER_PIXEL_NV',0x956E) +GL_SHADING_RATE_IMAGE_BINDING_NV=_C('GL_SHADING_RATE_IMAGE_BINDING_NV',0x955B) +GL_SHADING_RATE_IMAGE_NV=_C('GL_SHADING_RATE_IMAGE_NV',0x9563) +GL_SHADING_RATE_IMAGE_PALETTE_SIZE_NV=_C('GL_SHADING_RATE_IMAGE_PALETTE_SIZE_NV',0x955E) +GL_SHADING_RATE_IMAGE_TEXEL_HEIGHT_NV=_C('GL_SHADING_RATE_IMAGE_TEXEL_HEIGHT_NV',0x955D) +GL_SHADING_RATE_IMAGE_TEXEL_WIDTH_NV=_C('GL_SHADING_RATE_IMAGE_TEXEL_WIDTH_NV',0x955C) +GL_SHADING_RATE_NO_INVOCATIONS_NV=_C('GL_SHADING_RATE_NO_INVOCATIONS_NV',0x9564) +GL_SHADING_RATE_SAMPLE_ORDER_DEFAULT_NV=_C('GL_SHADING_RATE_SAMPLE_ORDER_DEFAULT_NV',0x95AE) +GL_SHADING_RATE_SAMPLE_ORDER_PIXEL_MAJOR_NV=_C('GL_SHADING_RATE_SAMPLE_ORDER_PIXEL_MAJOR_NV',0x95AF) +GL_SHADING_RATE_SAMPLE_ORDER_SAMPLE_MAJOR_NV=_C('GL_SHADING_RATE_SAMPLE_ORDER_SAMPLE_MAJOR_NV',0x95B0) +@_f +@_p.types(None,_cs.GLuint) +def glBindShadingRateImageNV(texture):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,arrays.GLuintArray) +def glGetShadingRateImagePaletteNV(viewport,entry,rate):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,_cs.GLuint,arrays.GLintArray) +def glGetShadingRateSampleLocationivNV(rate,samples,index,location):pass +@_f +@_p.types(None,_cs.GLboolean) +def glShadingRateImageBarrierNV(synchronize):pass +@_f +@_p.types(None,_cs.GLboolean) +def glShadingRateImageBarrierNV(synchronize):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLsizei,arrays.GLuintArray) +def glShadingRateImagePaletteNV(viewport,first,count,rates):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,arrays.GLintArray) +def glShadingRateSampleOrderCustomNV(rate,samples,locations):pass +@_f +@_p.types(None,_cs.GLenum) +def glShadingRateSampleOrderNV(order):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/stereo_view_rendering.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/stereo_view_rendering.py new file mode 100644 index 00000000..95d69c29 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/stereo_view_rendering.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_NV_stereo_view_rendering' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_NV_stereo_view_rendering',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/tessellation_program5.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/tessellation_program5.py new file mode 100644 index 00000000..9086a590 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/tessellation_program5.py @@ -0,0 +1,19 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_NV_tessellation_program5' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_NV_tessellation_program5',error_checker=_errors._error_checker) +GL_MAX_PROGRAM_PATCH_ATTRIBS_NV=_C('GL_MAX_PROGRAM_PATCH_ATTRIBS_NV',0x86D8) +GL_TESS_CONTROL_PROGRAM_NV=_C('GL_TESS_CONTROL_PROGRAM_NV',0x891E) +GL_TESS_CONTROL_PROGRAM_PARAMETER_BUFFER_NV=_C('GL_TESS_CONTROL_PROGRAM_PARAMETER_BUFFER_NV',0x8C74) +GL_TESS_EVALUATION_PROGRAM_NV=_C('GL_TESS_EVALUATION_PROGRAM_NV',0x891F) +GL_TESS_EVALUATION_PROGRAM_PARAMETER_BUFFER_NV=_C('GL_TESS_EVALUATION_PROGRAM_PARAMETER_BUFFER_NV',0x8C75) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/texgen_emboss.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/texgen_emboss.py new file mode 100644 index 00000000..f24b5d93 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/texgen_emboss.py @@ -0,0 +1,17 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_NV_texgen_emboss' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_NV_texgen_emboss',error_checker=_errors._error_checker) +GL_EMBOSS_CONSTANT_NV=_C('GL_EMBOSS_CONSTANT_NV',0x855E) +GL_EMBOSS_LIGHT_NV=_C('GL_EMBOSS_LIGHT_NV',0x855D) +GL_EMBOSS_MAP_NV=_C('GL_EMBOSS_MAP_NV',0x855F) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/texgen_reflection.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/texgen_reflection.py new file mode 100644 index 00000000..499ae7a6 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/texgen_reflection.py @@ -0,0 +1,16 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_NV_texgen_reflection' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_NV_texgen_reflection',error_checker=_errors._error_checker) +GL_NORMAL_MAP_NV=_C('GL_NORMAL_MAP_NV',0x8511) +GL_REFLECTION_MAP_NV=_C('GL_REFLECTION_MAP_NV',0x8512) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/texture_barrier.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/texture_barrier.py new file mode 100644 index 00000000..38fa04bc --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/texture_barrier.py @@ -0,0 +1,17 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_NV_texture_barrier' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_NV_texture_barrier',error_checker=_errors._error_checker) + +@_f +@_p.types(None,) +def glTextureBarrierNV():pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/texture_compression_vtc.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/texture_compression_vtc.py new file mode 100644 index 00000000..005dd758 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/texture_compression_vtc.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_NV_texture_compression_vtc' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_NV_texture_compression_vtc',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/texture_env_combine4.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/texture_env_combine4.py new file mode 100644 index 00000000..d5e17370 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/texture_env_combine4.py @@ -0,0 +1,19 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_NV_texture_env_combine4' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_NV_texture_env_combine4',error_checker=_errors._error_checker) +GL_COMBINE4_NV=_C('GL_COMBINE4_NV',0x8503) +GL_OPERAND3_ALPHA_NV=_C('GL_OPERAND3_ALPHA_NV',0x859B) +GL_OPERAND3_RGB_NV=_C('GL_OPERAND3_RGB_NV',0x8593) +GL_SOURCE3_ALPHA_NV=_C('GL_SOURCE3_ALPHA_NV',0x858B) +GL_SOURCE3_RGB_NV=_C('GL_SOURCE3_RGB_NV',0x8583) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/texture_expand_normal.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/texture_expand_normal.py new file mode 100644 index 00000000..491ab1e3 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/texture_expand_normal.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_NV_texture_expand_normal' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_NV_texture_expand_normal',error_checker=_errors._error_checker) +GL_TEXTURE_UNSIGNED_REMAP_MODE_NV=_C('GL_TEXTURE_UNSIGNED_REMAP_MODE_NV',0x888F) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/texture_multisample.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/texture_multisample.py new file mode 100644 index 00000000..0c3f5f9d --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/texture_multisample.py @@ -0,0 +1,33 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_NV_texture_multisample' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_NV_texture_multisample',error_checker=_errors._error_checker) +GL_TEXTURE_COLOR_SAMPLES_NV=_C('GL_TEXTURE_COLOR_SAMPLES_NV',0x9046) +GL_TEXTURE_COVERAGE_SAMPLES_NV=_C('GL_TEXTURE_COVERAGE_SAMPLES_NV',0x9045) +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizei,_cs.GLsizei,_cs.GLint,_cs.GLsizei,_cs.GLsizei,_cs.GLboolean) +def glTexImage2DMultisampleCoverageNV(target,coverageSamples,colorSamples,internalFormat,width,height,fixedSampleLocations):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizei,_cs.GLsizei,_cs.GLint,_cs.GLsizei,_cs.GLsizei,_cs.GLsizei,_cs.GLboolean) +def glTexImage3DMultisampleCoverageNV(target,coverageSamples,colorSamples,internalFormat,width,height,depth,fixedSampleLocations):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLsizei,_cs.GLsizei,_cs.GLint,_cs.GLsizei,_cs.GLsizei,_cs.GLboolean) +def glTextureImage2DMultisampleCoverageNV(texture,target,coverageSamples,colorSamples,internalFormat,width,height,fixedSampleLocations):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLsizei,_cs.GLint,_cs.GLsizei,_cs.GLsizei,_cs.GLboolean) +def glTextureImage2DMultisampleNV(texture,target,samples,internalFormat,width,height,fixedSampleLocations):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLsizei,_cs.GLsizei,_cs.GLint,_cs.GLsizei,_cs.GLsizei,_cs.GLsizei,_cs.GLboolean) +def glTextureImage3DMultisampleCoverageNV(texture,target,coverageSamples,colorSamples,internalFormat,width,height,depth,fixedSampleLocations):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLsizei,_cs.GLint,_cs.GLsizei,_cs.GLsizei,_cs.GLsizei,_cs.GLboolean) +def glTextureImage3DMultisampleNV(texture,target,samples,internalFormat,width,height,depth,fixedSampleLocations):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/texture_rectangle.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/texture_rectangle.py new file mode 100644 index 00000000..06ada3b3 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/texture_rectangle.py @@ -0,0 +1,18 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_NV_texture_rectangle' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_NV_texture_rectangle',error_checker=_errors._error_checker) +GL_MAX_RECTANGLE_TEXTURE_SIZE_NV=_C('GL_MAX_RECTANGLE_TEXTURE_SIZE_NV',0x84F8) +GL_PROXY_TEXTURE_RECTANGLE_NV=_C('GL_PROXY_TEXTURE_RECTANGLE_NV',0x84F7) +GL_TEXTURE_BINDING_RECTANGLE_NV=_C('GL_TEXTURE_BINDING_RECTANGLE_NV',0x84F6) +GL_TEXTURE_RECTANGLE_NV=_C('GL_TEXTURE_RECTANGLE_NV',0x84F5) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/texture_rectangle_compressed.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/texture_rectangle_compressed.py new file mode 100644 index 00000000..d56a8723 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/texture_rectangle_compressed.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_NV_texture_rectangle_compressed' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_NV_texture_rectangle_compressed',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/texture_shader.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/texture_shader.py new file mode 100644 index 00000000..57aec8ea --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/texture_shader.py @@ -0,0 +1,87 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_NV_texture_shader' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_NV_texture_shader',error_checker=_errors._error_checker) +GL_CONST_EYE_NV=_C('GL_CONST_EYE_NV',0x86E5) +GL_CULL_FRAGMENT_NV=_C('GL_CULL_FRAGMENT_NV',0x86E7) +GL_CULL_MODES_NV=_C('GL_CULL_MODES_NV',0x86E0) +GL_DEPENDENT_AR_TEXTURE_2D_NV=_C('GL_DEPENDENT_AR_TEXTURE_2D_NV',0x86E9) +GL_DEPENDENT_GB_TEXTURE_2D_NV=_C('GL_DEPENDENT_GB_TEXTURE_2D_NV',0x86EA) +GL_DOT_PRODUCT_CONST_EYE_REFLECT_CUBE_MAP_NV=_C('GL_DOT_PRODUCT_CONST_EYE_REFLECT_CUBE_MAP_NV',0x86F3) +GL_DOT_PRODUCT_DEPTH_REPLACE_NV=_C('GL_DOT_PRODUCT_DEPTH_REPLACE_NV',0x86ED) +GL_DOT_PRODUCT_DIFFUSE_CUBE_MAP_NV=_C('GL_DOT_PRODUCT_DIFFUSE_CUBE_MAP_NV',0x86F1) +GL_DOT_PRODUCT_NV=_C('GL_DOT_PRODUCT_NV',0x86EC) +GL_DOT_PRODUCT_REFLECT_CUBE_MAP_NV=_C('GL_DOT_PRODUCT_REFLECT_CUBE_MAP_NV',0x86F2) +GL_DOT_PRODUCT_TEXTURE_2D_NV=_C('GL_DOT_PRODUCT_TEXTURE_2D_NV',0x86EE) +GL_DOT_PRODUCT_TEXTURE_CUBE_MAP_NV=_C('GL_DOT_PRODUCT_TEXTURE_CUBE_MAP_NV',0x86F0) +GL_DOT_PRODUCT_TEXTURE_RECTANGLE_NV=_C('GL_DOT_PRODUCT_TEXTURE_RECTANGLE_NV',0x864E) +GL_DSDT8_MAG8_INTENSITY8_NV=_C('GL_DSDT8_MAG8_INTENSITY8_NV',0x870B) +GL_DSDT8_MAG8_NV=_C('GL_DSDT8_MAG8_NV',0x870A) +GL_DSDT8_NV=_C('GL_DSDT8_NV',0x8709) +GL_DSDT_MAG_INTENSITY_NV=_C('GL_DSDT_MAG_INTENSITY_NV',0x86DC) +GL_DSDT_MAG_NV=_C('GL_DSDT_MAG_NV',0x86F6) +GL_DSDT_MAG_VIB_NV=_C('GL_DSDT_MAG_VIB_NV',0x86F7) +GL_DSDT_NV=_C('GL_DSDT_NV',0x86F5) +GL_DS_BIAS_NV=_C('GL_DS_BIAS_NV',0x8716) +GL_DS_SCALE_NV=_C('GL_DS_SCALE_NV',0x8710) +GL_DT_BIAS_NV=_C('GL_DT_BIAS_NV',0x8717) +GL_DT_SCALE_NV=_C('GL_DT_SCALE_NV',0x8711) +GL_HILO16_NV=_C('GL_HILO16_NV',0x86F8) +GL_HILO_NV=_C('GL_HILO_NV',0x86F4) +GL_HI_BIAS_NV=_C('GL_HI_BIAS_NV',0x8714) +GL_HI_SCALE_NV=_C('GL_HI_SCALE_NV',0x870E) +GL_LO_BIAS_NV=_C('GL_LO_BIAS_NV',0x8715) +GL_LO_SCALE_NV=_C('GL_LO_SCALE_NV',0x870F) +GL_MAGNITUDE_BIAS_NV=_C('GL_MAGNITUDE_BIAS_NV',0x8718) +GL_MAGNITUDE_SCALE_NV=_C('GL_MAGNITUDE_SCALE_NV',0x8712) +GL_OFFSET_TEXTURE_2D_BIAS_NV=_C('GL_OFFSET_TEXTURE_2D_BIAS_NV',0x86E3) +GL_OFFSET_TEXTURE_2D_MATRIX_NV=_C('GL_OFFSET_TEXTURE_2D_MATRIX_NV',0x86E1) +GL_OFFSET_TEXTURE_2D_NV=_C('GL_OFFSET_TEXTURE_2D_NV',0x86E8) +GL_OFFSET_TEXTURE_2D_SCALE_NV=_C('GL_OFFSET_TEXTURE_2D_SCALE_NV',0x86E2) +GL_OFFSET_TEXTURE_BIAS_NV=_C('GL_OFFSET_TEXTURE_BIAS_NV',0x86E3) +GL_OFFSET_TEXTURE_MATRIX_NV=_C('GL_OFFSET_TEXTURE_MATRIX_NV',0x86E1) +GL_OFFSET_TEXTURE_RECTANGLE_NV=_C('GL_OFFSET_TEXTURE_RECTANGLE_NV',0x864C) +GL_OFFSET_TEXTURE_RECTANGLE_SCALE_NV=_C('GL_OFFSET_TEXTURE_RECTANGLE_SCALE_NV',0x864D) +GL_OFFSET_TEXTURE_SCALE_NV=_C('GL_OFFSET_TEXTURE_SCALE_NV',0x86E2) +GL_PASS_THROUGH_NV=_C('GL_PASS_THROUGH_NV',0x86E6) +GL_PREVIOUS_TEXTURE_INPUT_NV=_C('GL_PREVIOUS_TEXTURE_INPUT_NV',0x86E4) +GL_RGBA_UNSIGNED_DOT_PRODUCT_MAPPING_NV=_C('GL_RGBA_UNSIGNED_DOT_PRODUCT_MAPPING_NV',0x86D9) +GL_SHADER_CONSISTENT_NV=_C('GL_SHADER_CONSISTENT_NV',0x86DD) +GL_SHADER_OPERATION_NV=_C('GL_SHADER_OPERATION_NV',0x86DF) +GL_SIGNED_ALPHA8_NV=_C('GL_SIGNED_ALPHA8_NV',0x8706) +GL_SIGNED_ALPHA_NV=_C('GL_SIGNED_ALPHA_NV',0x8705) +GL_SIGNED_HILO16_NV=_C('GL_SIGNED_HILO16_NV',0x86FA) +GL_SIGNED_HILO_NV=_C('GL_SIGNED_HILO_NV',0x86F9) +GL_SIGNED_INTENSITY8_NV=_C('GL_SIGNED_INTENSITY8_NV',0x8708) +GL_SIGNED_INTENSITY_NV=_C('GL_SIGNED_INTENSITY_NV',0x8707) +GL_SIGNED_LUMINANCE8_ALPHA8_NV=_C('GL_SIGNED_LUMINANCE8_ALPHA8_NV',0x8704) +GL_SIGNED_LUMINANCE8_NV=_C('GL_SIGNED_LUMINANCE8_NV',0x8702) +GL_SIGNED_LUMINANCE_ALPHA_NV=_C('GL_SIGNED_LUMINANCE_ALPHA_NV',0x8703) +GL_SIGNED_LUMINANCE_NV=_C('GL_SIGNED_LUMINANCE_NV',0x8701) +GL_SIGNED_RGB8_NV=_C('GL_SIGNED_RGB8_NV',0x86FF) +GL_SIGNED_RGB8_UNSIGNED_ALPHA8_NV=_C('GL_SIGNED_RGB8_UNSIGNED_ALPHA8_NV',0x870D) +GL_SIGNED_RGBA8_NV=_C('GL_SIGNED_RGBA8_NV',0x86FC) +GL_SIGNED_RGBA_NV=_C('GL_SIGNED_RGBA_NV',0x86FB) +GL_SIGNED_RGB_NV=_C('GL_SIGNED_RGB_NV',0x86FE) +GL_SIGNED_RGB_UNSIGNED_ALPHA_NV=_C('GL_SIGNED_RGB_UNSIGNED_ALPHA_NV',0x870C) +GL_TEXTURE_BORDER_VALUES_NV=_C('GL_TEXTURE_BORDER_VALUES_NV',0x871A) +GL_TEXTURE_DS_SIZE_NV=_C('GL_TEXTURE_DS_SIZE_NV',0x871D) +GL_TEXTURE_DT_SIZE_NV=_C('GL_TEXTURE_DT_SIZE_NV',0x871E) +GL_TEXTURE_HI_SIZE_NV=_C('GL_TEXTURE_HI_SIZE_NV',0x871B) +GL_TEXTURE_LO_SIZE_NV=_C('GL_TEXTURE_LO_SIZE_NV',0x871C) +GL_TEXTURE_MAG_SIZE_NV=_C('GL_TEXTURE_MAG_SIZE_NV',0x871F) +GL_TEXTURE_SHADER_NV=_C('GL_TEXTURE_SHADER_NV',0x86DE) +GL_UNSIGNED_INT_8_8_S8_S8_REV_NV=_C('GL_UNSIGNED_INT_8_8_S8_S8_REV_NV',0x86DB) +GL_UNSIGNED_INT_S8_S8_8_8_NV=_C('GL_UNSIGNED_INT_S8_S8_8_8_NV',0x86DA) +GL_VIBRANCE_BIAS_NV=_C('GL_VIBRANCE_BIAS_NV',0x8719) +GL_VIBRANCE_SCALE_NV=_C('GL_VIBRANCE_SCALE_NV',0x8713) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/texture_shader2.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/texture_shader2.py new file mode 100644 index 00000000..2b22158a --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/texture_shader2.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_NV_texture_shader2' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_NV_texture_shader2',error_checker=_errors._error_checker) +GL_DOT_PRODUCT_TEXTURE_3D_NV=_C('GL_DOT_PRODUCT_TEXTURE_3D_NV',0x86EF) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/texture_shader3.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/texture_shader3.py new file mode 100644 index 00000000..ee51fb70 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/texture_shader3.py @@ -0,0 +1,31 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_NV_texture_shader3' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_NV_texture_shader3',error_checker=_errors._error_checker) +GL_DEPENDENT_HILO_TEXTURE_2D_NV=_C('GL_DEPENDENT_HILO_TEXTURE_2D_NV',0x8858) +GL_DEPENDENT_RGB_TEXTURE_3D_NV=_C('GL_DEPENDENT_RGB_TEXTURE_3D_NV',0x8859) +GL_DEPENDENT_RGB_TEXTURE_CUBE_MAP_NV=_C('GL_DEPENDENT_RGB_TEXTURE_CUBE_MAP_NV',0x885A) +GL_DOT_PRODUCT_AFFINE_DEPTH_REPLACE_NV=_C('GL_DOT_PRODUCT_AFFINE_DEPTH_REPLACE_NV',0x885D) +GL_DOT_PRODUCT_PASS_THROUGH_NV=_C('GL_DOT_PRODUCT_PASS_THROUGH_NV',0x885B) +GL_DOT_PRODUCT_TEXTURE_1D_NV=_C('GL_DOT_PRODUCT_TEXTURE_1D_NV',0x885C) +GL_FORCE_BLUE_TO_ONE_NV=_C('GL_FORCE_BLUE_TO_ONE_NV',0x8860) +GL_HILO8_NV=_C('GL_HILO8_NV',0x885E) +GL_OFFSET_HILO_PROJECTIVE_TEXTURE_2D_NV=_C('GL_OFFSET_HILO_PROJECTIVE_TEXTURE_2D_NV',0x8856) +GL_OFFSET_HILO_PROJECTIVE_TEXTURE_RECTANGLE_NV=_C('GL_OFFSET_HILO_PROJECTIVE_TEXTURE_RECTANGLE_NV',0x8857) +GL_OFFSET_HILO_TEXTURE_2D_NV=_C('GL_OFFSET_HILO_TEXTURE_2D_NV',0x8854) +GL_OFFSET_HILO_TEXTURE_RECTANGLE_NV=_C('GL_OFFSET_HILO_TEXTURE_RECTANGLE_NV',0x8855) +GL_OFFSET_PROJECTIVE_TEXTURE_2D_NV=_C('GL_OFFSET_PROJECTIVE_TEXTURE_2D_NV',0x8850) +GL_OFFSET_PROJECTIVE_TEXTURE_2D_SCALE_NV=_C('GL_OFFSET_PROJECTIVE_TEXTURE_2D_SCALE_NV',0x8851) +GL_OFFSET_PROJECTIVE_TEXTURE_RECTANGLE_NV=_C('GL_OFFSET_PROJECTIVE_TEXTURE_RECTANGLE_NV',0x8852) +GL_OFFSET_PROJECTIVE_TEXTURE_RECTANGLE_SCALE_NV=_C('GL_OFFSET_PROJECTIVE_TEXTURE_RECTANGLE_SCALE_NV',0x8853) +GL_SIGNED_HILO8_NV=_C('GL_SIGNED_HILO8_NV',0x885F) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/transform_feedback.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/transform_feedback.py new file mode 100644 index 00000000..dca63ab8 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/transform_feedback.py @@ -0,0 +1,80 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_NV_transform_feedback' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_NV_transform_feedback',error_checker=_errors._error_checker) +GL_ACTIVE_VARYINGS_NV=_C('GL_ACTIVE_VARYINGS_NV',0x8C81) +GL_ACTIVE_VARYING_MAX_LENGTH_NV=_C('GL_ACTIVE_VARYING_MAX_LENGTH_NV',0x8C82) +GL_BACK_PRIMARY_COLOR_NV=_C('GL_BACK_PRIMARY_COLOR_NV',0x8C77) +GL_BACK_SECONDARY_COLOR_NV=_C('GL_BACK_SECONDARY_COLOR_NV',0x8C78) +GL_CLIP_DISTANCE_NV=_C('GL_CLIP_DISTANCE_NV',0x8C7A) +GL_GENERIC_ATTRIB_NV=_C('GL_GENERIC_ATTRIB_NV',0x8C7D) +GL_INTERLEAVED_ATTRIBS_NV=_C('GL_INTERLEAVED_ATTRIBS_NV',0x8C8C) +GL_LAYER_NV=_C('GL_LAYER_NV',0x8DAA) +GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS_NV=_C('GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS_NV',0x8C8A) +GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS_NV=_C('GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS_NV',0x8C8B) +GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS_NV=_C('GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS_NV',0x8C80) +GL_NEXT_BUFFER_NV=_C('GL_NEXT_BUFFER_NV',-2) +GL_PRIMITIVES_GENERATED_NV=_C('GL_PRIMITIVES_GENERATED_NV',0x8C87) +GL_PRIMITIVE_ID_NV=_C('GL_PRIMITIVE_ID_NV',0x8C7C) +GL_RASTERIZER_DISCARD_NV=_C('GL_RASTERIZER_DISCARD_NV',0x8C89) +GL_SEPARATE_ATTRIBS_NV=_C('GL_SEPARATE_ATTRIBS_NV',0x8C8D) +GL_SKIP_COMPONENTS1_NV=_C('GL_SKIP_COMPONENTS1_NV',-6) +GL_SKIP_COMPONENTS2_NV=_C('GL_SKIP_COMPONENTS2_NV',-5) +GL_SKIP_COMPONENTS3_NV=_C('GL_SKIP_COMPONENTS3_NV',-4) +GL_SKIP_COMPONENTS4_NV=_C('GL_SKIP_COMPONENTS4_NV',-3) +GL_TEXTURE_COORD_NV=_C('GL_TEXTURE_COORD_NV',0x8C79) +GL_TRANSFORM_FEEDBACK_ATTRIBS_NV=_C('GL_TRANSFORM_FEEDBACK_ATTRIBS_NV',0x8C7E) +GL_TRANSFORM_FEEDBACK_BUFFER_BINDING_NV=_C('GL_TRANSFORM_FEEDBACK_BUFFER_BINDING_NV',0x8C8F) +GL_TRANSFORM_FEEDBACK_BUFFER_MODE_NV=_C('GL_TRANSFORM_FEEDBACK_BUFFER_MODE_NV',0x8C7F) +GL_TRANSFORM_FEEDBACK_BUFFER_NV=_C('GL_TRANSFORM_FEEDBACK_BUFFER_NV',0x8C8E) +GL_TRANSFORM_FEEDBACK_BUFFER_SIZE_NV=_C('GL_TRANSFORM_FEEDBACK_BUFFER_SIZE_NV',0x8C85) +GL_TRANSFORM_FEEDBACK_BUFFER_START_NV=_C('GL_TRANSFORM_FEEDBACK_BUFFER_START_NV',0x8C84) +GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN_NV=_C('GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN_NV',0x8C88) +GL_TRANSFORM_FEEDBACK_RECORD_NV=_C('GL_TRANSFORM_FEEDBACK_RECORD_NV',0x8C86) +GL_TRANSFORM_FEEDBACK_VARYINGS_NV=_C('GL_TRANSFORM_FEEDBACK_VARYINGS_NV',0x8C83) +GL_VERTEX_ID_NV=_C('GL_VERTEX_ID_NV',0x8C7B) +@_f +@_p.types(None,_cs.GLuint,arrays.GLcharArray) +def glActiveVaryingNV(program,name):pass +@_f +@_p.types(None,_cs.GLenum) +def glBeginTransformFeedbackNV(primitiveMode):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,_cs.GLuint) +def glBindBufferBaseNV(target,index,buffer):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,_cs.GLuint,_cs.GLintptr) +def glBindBufferOffsetNV(target,index,buffer,offset):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,_cs.GLuint,_cs.GLintptr,_cs.GLsizeiptr) +def glBindBufferRangeNV(target,index,buffer,offset,size):pass +@_f +@_p.types(None,) +def glEndTransformFeedbackNV():pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLsizei,arrays.GLsizeiArray,arrays.GLsizeiArray,arrays.GLuintArray,arrays.GLcharArray) +def glGetActiveVaryingNV(program,index,bufSize,length,size,type,name):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,arrays.GLintArray) +def glGetTransformFeedbackVaryingNV(program,index,location):pass +@_f +@_p.types(_cs.GLint,_cs.GLuint,arrays.GLcharArray) +def glGetVaryingLocationNV(program,name):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLintArray,_cs.GLenum) +def glTransformFeedbackAttribsNV(count,attribs,bufferMode):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLintArray,_cs.GLsizei,arrays.GLintArray,_cs.GLenum) +def glTransformFeedbackStreamAttribsNV(count,attribs,nbuffers,bufstreams,bufferMode):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizei,arrays.GLintArray,_cs.GLenum) +def glTransformFeedbackVaryingsNV(program,count,locations,bufferMode):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/transform_feedback2.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/transform_feedback2.py new file mode 100644 index 00000000..33a787df --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/transform_feedback2.py @@ -0,0 +1,38 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_NV_transform_feedback2' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_NV_transform_feedback2',error_checker=_errors._error_checker) +GL_TRANSFORM_FEEDBACK_BINDING_NV=_C('GL_TRANSFORM_FEEDBACK_BINDING_NV',0x8E25) +GL_TRANSFORM_FEEDBACK_BUFFER_ACTIVE_NV=_C('GL_TRANSFORM_FEEDBACK_BUFFER_ACTIVE_NV',0x8E24) +GL_TRANSFORM_FEEDBACK_BUFFER_PAUSED_NV=_C('GL_TRANSFORM_FEEDBACK_BUFFER_PAUSED_NV',0x8E23) +GL_TRANSFORM_FEEDBACK_NV=_C('GL_TRANSFORM_FEEDBACK_NV',0x8E22) +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint) +def glBindTransformFeedbackNV(target,id):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray) +def glDeleteTransformFeedbacksNV(n,ids):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint) +def glDrawTransformFeedbackNV(mode,id):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray) +def glGenTransformFeedbacksNV(n,ids):pass +@_f +@_p.types(_cs.GLboolean,_cs.GLuint) +def glIsTransformFeedbackNV(id):pass +@_f +@_p.types(None,) +def glPauseTransformFeedbackNV():pass +@_f +@_p.types(None,) +def glResumeTransformFeedbackNV():pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/uniform_buffer_unified_memory.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/uniform_buffer_unified_memory.py new file mode 100644 index 00000000..acac183b --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/uniform_buffer_unified_memory.py @@ -0,0 +1,17 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_NV_uniform_buffer_unified_memory' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_NV_uniform_buffer_unified_memory',error_checker=_errors._error_checker) +GL_UNIFORM_BUFFER_ADDRESS_NV=_C('GL_UNIFORM_BUFFER_ADDRESS_NV',0x936F) +GL_UNIFORM_BUFFER_LENGTH_NV=_C('GL_UNIFORM_BUFFER_LENGTH_NV',0x9370) +GL_UNIFORM_BUFFER_UNIFIED_NV=_C('GL_UNIFORM_BUFFER_UNIFIED_NV',0x936E) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/vdpau_interop.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/vdpau_interop.py new file mode 100644 index 00000000..e16b4ca2 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/vdpau_interop.py @@ -0,0 +1,47 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_NV_vdpau_interop' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_NV_vdpau_interop',error_checker=_errors._error_checker) +GL_SURFACE_MAPPED_NV=_C('GL_SURFACE_MAPPED_NV',0x8700) +GL_SURFACE_REGISTERED_NV=_C('GL_SURFACE_REGISTERED_NV',0x86FD) +GL_SURFACE_STATE_NV=_C('GL_SURFACE_STATE_NV',0x86EB) +GL_WRITE_DISCARD_NV=_C('GL_WRITE_DISCARD_NV',0x88BE) +@_f +@_p.types(None,) +def glVDPAUFiniNV():pass +@_f +@_p.types(None,_cs.GLvdpauSurfaceNV,_cs.GLenum,_cs.GLsizei,arrays.GLsizeiArray,arrays.GLintArray) +def glVDPAUGetSurfaceivNV(surface,pname,bufSize,length,values):pass +@_f +@_p.types(None,ctypes.c_void_p,ctypes.c_void_p) +def glVDPAUInitNV(vdpDevice,getProcAddress):pass +@_f +@_p.types(_cs.GLboolean,_cs.GLvdpauSurfaceNV) +def glVDPAUIsSurfaceNV(surface):pass +@_f +@_p.types(None,_cs.GLsizei,ctypes.POINTER(_cs.GLvdpauSurfaceNV)) +def glVDPAUMapSurfacesNV(numSurfaces,surfaces):pass +@_f +@_p.types(_cs.GLvdpauSurfaceNV,ctypes.c_void_p,_cs.GLenum,_cs.GLsizei,arrays.GLuintArray) +def glVDPAURegisterOutputSurfaceNV(vdpSurface,target,numTextureNames,textureNames):pass +@_f +@_p.types(_cs.GLvdpauSurfaceNV,ctypes.c_void_p,_cs.GLenum,_cs.GLsizei,arrays.GLuintArray) +def glVDPAURegisterVideoSurfaceNV(vdpSurface,target,numTextureNames,textureNames):pass +@_f +@_p.types(None,_cs.GLvdpauSurfaceNV,_cs.GLenum) +def glVDPAUSurfaceAccessNV(surface,access):pass +@_f +@_p.types(None,_cs.GLsizei,ctypes.POINTER(_cs.GLvdpauSurfaceNV)) +def glVDPAUUnmapSurfacesNV(numSurface,surfaces):pass +@_f +@_p.types(None,_cs.GLvdpauSurfaceNV) +def glVDPAUUnregisterSurfaceNV(surface):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/vdpau_interop2.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/vdpau_interop2.py new file mode 100644 index 00000000..d27a8d30 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/vdpau_interop2.py @@ -0,0 +1,17 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_NV_vdpau_interop2' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_NV_vdpau_interop2',error_checker=_errors._error_checker) + +@_f +@_p.types(_cs.GLvdpauSurfaceNV,ctypes.c_void_p,_cs.GLenum,_cs.GLsizei,arrays.GLuintArray,_cs.GLboolean) +def glVDPAURegisterVideoSurfaceWithPictureStructureNV(vdpSurface,target,numTextureNames,textureNames,isFrameStructure):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/vertex_array_range.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/vertex_array_range.py new file mode 100644 index 00000000..f8a8a175 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/vertex_array_range.py @@ -0,0 +1,24 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_NV_vertex_array_range' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_NV_vertex_array_range',error_checker=_errors._error_checker) +GL_MAX_VERTEX_ARRAY_RANGE_ELEMENT_NV=_C('GL_MAX_VERTEX_ARRAY_RANGE_ELEMENT_NV',0x8520) +GL_VERTEX_ARRAY_RANGE_LENGTH_NV=_C('GL_VERTEX_ARRAY_RANGE_LENGTH_NV',0x851E) +GL_VERTEX_ARRAY_RANGE_NV=_C('GL_VERTEX_ARRAY_RANGE_NV',0x851D) +GL_VERTEX_ARRAY_RANGE_POINTER_NV=_C('GL_VERTEX_ARRAY_RANGE_POINTER_NV',0x8521) +GL_VERTEX_ARRAY_RANGE_VALID_NV=_C('GL_VERTEX_ARRAY_RANGE_VALID_NV',0x851F) +@_f +@_p.types(None,) +def glFlushVertexArrayRangeNV():pass +@_f +@_p.types(None,_cs.GLsizei,ctypes.c_void_p) +def glVertexArrayRangeNV(length,pointer):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/vertex_array_range2.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/vertex_array_range2.py new file mode 100644 index 00000000..34895c49 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/vertex_array_range2.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_NV_vertex_array_range2' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_NV_vertex_array_range2',error_checker=_errors._error_checker) +GL_VERTEX_ARRAY_RANGE_WITHOUT_FLUSH_NV=_C('GL_VERTEX_ARRAY_RANGE_WITHOUT_FLUSH_NV',0x8533) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/vertex_attrib_integer_64bit.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/vertex_attrib_integer_64bit.py new file mode 100644 index 00000000..7bbe885b --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/vertex_attrib_integer_64bit.py @@ -0,0 +1,72 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_NV_vertex_attrib_integer_64bit' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_NV_vertex_attrib_integer_64bit',error_checker=_errors._error_checker) +GL_INT64_NV=_C('GL_INT64_NV',0x140E) +GL_UNSIGNED_INT64_NV=_C('GL_UNSIGNED_INT64_NV',0x140F) +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLint64Array) +def glGetVertexAttribLi64vNV(index,pname,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLuint64Array) +def glGetVertexAttribLui64vNV(index,pname,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint64EXT) +def glVertexAttribL1i64NV(index,x):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLint64Array) +def glVertexAttribL1i64vNV(index,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint64EXT) +def glVertexAttribL1ui64NV(index,x):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLuint64Array) +def glVertexAttribL1ui64vNV(index,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint64EXT,_cs.GLint64EXT) +def glVertexAttribL2i64NV(index,x,y):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLint64Array) +def glVertexAttribL2i64vNV(index,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint64EXT,_cs.GLuint64EXT) +def glVertexAttribL2ui64NV(index,x,y):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLuint64Array) +def glVertexAttribL2ui64vNV(index,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint64EXT,_cs.GLint64EXT,_cs.GLint64EXT) +def glVertexAttribL3i64NV(index,x,y,z):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLint64Array) +def glVertexAttribL3i64vNV(index,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint64EXT,_cs.GLuint64EXT,_cs.GLuint64EXT) +def glVertexAttribL3ui64NV(index,x,y,z):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLuint64Array) +def glVertexAttribL3ui64vNV(index,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint64EXT,_cs.GLint64EXT,_cs.GLint64EXT,_cs.GLint64EXT) +def glVertexAttribL4i64NV(index,x,y,z,w):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLint64Array) +def glVertexAttribL4i64vNV(index,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint64EXT,_cs.GLuint64EXT,_cs.GLuint64EXT,_cs.GLuint64EXT) +def glVertexAttribL4ui64NV(index,x,y,z,w):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLuint64Array) +def glVertexAttribL4ui64vNV(index,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLenum,_cs.GLsizei) +def glVertexAttribLFormatNV(index,size,type,stride):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/vertex_buffer_unified_memory.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/vertex_buffer_unified_memory.py new file mode 100644 index 00000000..04db5899 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/vertex_buffer_unified_memory.py @@ -0,0 +1,74 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_NV_vertex_buffer_unified_memory' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_NV_vertex_buffer_unified_memory',error_checker=_errors._error_checker) +GL_COLOR_ARRAY_ADDRESS_NV=_C('GL_COLOR_ARRAY_ADDRESS_NV',0x8F23) +GL_COLOR_ARRAY_LENGTH_NV=_C('GL_COLOR_ARRAY_LENGTH_NV',0x8F2D) +GL_DRAW_INDIRECT_ADDRESS_NV=_C('GL_DRAW_INDIRECT_ADDRESS_NV',0x8F41) +GL_DRAW_INDIRECT_LENGTH_NV=_C('GL_DRAW_INDIRECT_LENGTH_NV',0x8F42) +GL_DRAW_INDIRECT_UNIFIED_NV=_C('GL_DRAW_INDIRECT_UNIFIED_NV',0x8F40) +GL_EDGE_FLAG_ARRAY_ADDRESS_NV=_C('GL_EDGE_FLAG_ARRAY_ADDRESS_NV',0x8F26) +GL_EDGE_FLAG_ARRAY_LENGTH_NV=_C('GL_EDGE_FLAG_ARRAY_LENGTH_NV',0x8F30) +GL_ELEMENT_ARRAY_ADDRESS_NV=_C('GL_ELEMENT_ARRAY_ADDRESS_NV',0x8F29) +GL_ELEMENT_ARRAY_LENGTH_NV=_C('GL_ELEMENT_ARRAY_LENGTH_NV',0x8F33) +GL_ELEMENT_ARRAY_UNIFIED_NV=_C('GL_ELEMENT_ARRAY_UNIFIED_NV',0x8F1F) +GL_FOG_COORD_ARRAY_ADDRESS_NV=_C('GL_FOG_COORD_ARRAY_ADDRESS_NV',0x8F28) +GL_FOG_COORD_ARRAY_LENGTH_NV=_C('GL_FOG_COORD_ARRAY_LENGTH_NV',0x8F32) +GL_INDEX_ARRAY_ADDRESS_NV=_C('GL_INDEX_ARRAY_ADDRESS_NV',0x8F24) +GL_INDEX_ARRAY_LENGTH_NV=_C('GL_INDEX_ARRAY_LENGTH_NV',0x8F2E) +GL_NORMAL_ARRAY_ADDRESS_NV=_C('GL_NORMAL_ARRAY_ADDRESS_NV',0x8F22) +GL_NORMAL_ARRAY_LENGTH_NV=_C('GL_NORMAL_ARRAY_LENGTH_NV',0x8F2C) +GL_SECONDARY_COLOR_ARRAY_ADDRESS_NV=_C('GL_SECONDARY_COLOR_ARRAY_ADDRESS_NV',0x8F27) +GL_SECONDARY_COLOR_ARRAY_LENGTH_NV=_C('GL_SECONDARY_COLOR_ARRAY_LENGTH_NV',0x8F31) +GL_TEXTURE_COORD_ARRAY_ADDRESS_NV=_C('GL_TEXTURE_COORD_ARRAY_ADDRESS_NV',0x8F25) +GL_TEXTURE_COORD_ARRAY_LENGTH_NV=_C('GL_TEXTURE_COORD_ARRAY_LENGTH_NV',0x8F2F) +GL_VERTEX_ARRAY_ADDRESS_NV=_C('GL_VERTEX_ARRAY_ADDRESS_NV',0x8F21) +GL_VERTEX_ARRAY_LENGTH_NV=_C('GL_VERTEX_ARRAY_LENGTH_NV',0x8F2B) +GL_VERTEX_ATTRIB_ARRAY_ADDRESS_NV=_C('GL_VERTEX_ATTRIB_ARRAY_ADDRESS_NV',0x8F20) +GL_VERTEX_ATTRIB_ARRAY_LENGTH_NV=_C('GL_VERTEX_ATTRIB_ARRAY_LENGTH_NV',0x8F2A) +GL_VERTEX_ATTRIB_ARRAY_UNIFIED_NV=_C('GL_VERTEX_ATTRIB_ARRAY_UNIFIED_NV',0x8F1E) +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,_cs.GLuint64EXT,_cs.GLsizeiptr) +def glBufferAddressRangeNV(pname,index,address,length):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLenum,_cs.GLsizei) +def glColorFormatNV(size,type,stride):pass +@_f +@_p.types(None,_cs.GLsizei) +def glEdgeFlagFormatNV(stride):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizei) +def glFogCoordFormatNV(type,stride):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,arrays.GLuint64Array) +def glGetIntegerui64i_vNV(value,index,result):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizei) +def glIndexFormatNV(type,stride):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizei) +def glNormalFormatNV(type,stride):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLenum,_cs.GLsizei) +def glSecondaryColorFormatNV(size,type,stride):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLenum,_cs.GLsizei) +def glTexCoordFormatNV(size,type,stride):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLenum,_cs.GLboolean,_cs.GLsizei) +def glVertexAttribFormatNV(index,size,type,normalized,stride):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLenum,_cs.GLsizei) +def glVertexAttribIFormatNV(index,size,type,stride):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLenum,_cs.GLsizei) +def glVertexFormatNV(size,type,stride):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/vertex_program.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/vertex_program.py new file mode 100644 index 00000000..3ddbb93b --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/vertex_program.py @@ -0,0 +1,288 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_NV_vertex_program' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_NV_vertex_program',error_checker=_errors._error_checker) +GL_ATTRIB_ARRAY_POINTER_NV=_C('GL_ATTRIB_ARRAY_POINTER_NV',0x8645) +GL_ATTRIB_ARRAY_SIZE_NV=_C('GL_ATTRIB_ARRAY_SIZE_NV',0x8623) +GL_ATTRIB_ARRAY_STRIDE_NV=_C('GL_ATTRIB_ARRAY_STRIDE_NV',0x8624) +GL_ATTRIB_ARRAY_TYPE_NV=_C('GL_ATTRIB_ARRAY_TYPE_NV',0x8625) +GL_CURRENT_ATTRIB_NV=_C('GL_CURRENT_ATTRIB_NV',0x8626) +GL_CURRENT_MATRIX_NV=_C('GL_CURRENT_MATRIX_NV',0x8641) +GL_CURRENT_MATRIX_STACK_DEPTH_NV=_C('GL_CURRENT_MATRIX_STACK_DEPTH_NV',0x8640) +GL_IDENTITY_NV=_C('GL_IDENTITY_NV',0x862A) +GL_INVERSE_NV=_C('GL_INVERSE_NV',0x862B) +GL_INVERSE_TRANSPOSE_NV=_C('GL_INVERSE_TRANSPOSE_NV',0x862D) +GL_MAP1_VERTEX_ATTRIB0_4_NV=_C('GL_MAP1_VERTEX_ATTRIB0_4_NV',0x8660) +GL_MAP1_VERTEX_ATTRIB10_4_NV=_C('GL_MAP1_VERTEX_ATTRIB10_4_NV',0x866A) +GL_MAP1_VERTEX_ATTRIB11_4_NV=_C('GL_MAP1_VERTEX_ATTRIB11_4_NV',0x866B) +GL_MAP1_VERTEX_ATTRIB12_4_NV=_C('GL_MAP1_VERTEX_ATTRIB12_4_NV',0x866C) +GL_MAP1_VERTEX_ATTRIB13_4_NV=_C('GL_MAP1_VERTEX_ATTRIB13_4_NV',0x866D) +GL_MAP1_VERTEX_ATTRIB14_4_NV=_C('GL_MAP1_VERTEX_ATTRIB14_4_NV',0x866E) +GL_MAP1_VERTEX_ATTRIB15_4_NV=_C('GL_MAP1_VERTEX_ATTRIB15_4_NV',0x866F) +GL_MAP1_VERTEX_ATTRIB1_4_NV=_C('GL_MAP1_VERTEX_ATTRIB1_4_NV',0x8661) +GL_MAP1_VERTEX_ATTRIB2_4_NV=_C('GL_MAP1_VERTEX_ATTRIB2_4_NV',0x8662) +GL_MAP1_VERTEX_ATTRIB3_4_NV=_C('GL_MAP1_VERTEX_ATTRIB3_4_NV',0x8663) +GL_MAP1_VERTEX_ATTRIB4_4_NV=_C('GL_MAP1_VERTEX_ATTRIB4_4_NV',0x8664) +GL_MAP1_VERTEX_ATTRIB5_4_NV=_C('GL_MAP1_VERTEX_ATTRIB5_4_NV',0x8665) +GL_MAP1_VERTEX_ATTRIB6_4_NV=_C('GL_MAP1_VERTEX_ATTRIB6_4_NV',0x8666) +GL_MAP1_VERTEX_ATTRIB7_4_NV=_C('GL_MAP1_VERTEX_ATTRIB7_4_NV',0x8667) +GL_MAP1_VERTEX_ATTRIB8_4_NV=_C('GL_MAP1_VERTEX_ATTRIB8_4_NV',0x8668) +GL_MAP1_VERTEX_ATTRIB9_4_NV=_C('GL_MAP1_VERTEX_ATTRIB9_4_NV',0x8669) +GL_MAP2_VERTEX_ATTRIB0_4_NV=_C('GL_MAP2_VERTEX_ATTRIB0_4_NV',0x8670) +GL_MAP2_VERTEX_ATTRIB10_4_NV=_C('GL_MAP2_VERTEX_ATTRIB10_4_NV',0x867A) +GL_MAP2_VERTEX_ATTRIB11_4_NV=_C('GL_MAP2_VERTEX_ATTRIB11_4_NV',0x867B) +GL_MAP2_VERTEX_ATTRIB12_4_NV=_C('GL_MAP2_VERTEX_ATTRIB12_4_NV',0x867C) +GL_MAP2_VERTEX_ATTRIB13_4_NV=_C('GL_MAP2_VERTEX_ATTRIB13_4_NV',0x867D) +GL_MAP2_VERTEX_ATTRIB14_4_NV=_C('GL_MAP2_VERTEX_ATTRIB14_4_NV',0x867E) +GL_MAP2_VERTEX_ATTRIB15_4_NV=_C('GL_MAP2_VERTEX_ATTRIB15_4_NV',0x867F) +GL_MAP2_VERTEX_ATTRIB1_4_NV=_C('GL_MAP2_VERTEX_ATTRIB1_4_NV',0x8671) +GL_MAP2_VERTEX_ATTRIB2_4_NV=_C('GL_MAP2_VERTEX_ATTRIB2_4_NV',0x8672) +GL_MAP2_VERTEX_ATTRIB3_4_NV=_C('GL_MAP2_VERTEX_ATTRIB3_4_NV',0x8673) +GL_MAP2_VERTEX_ATTRIB4_4_NV=_C('GL_MAP2_VERTEX_ATTRIB4_4_NV',0x8674) +GL_MAP2_VERTEX_ATTRIB5_4_NV=_C('GL_MAP2_VERTEX_ATTRIB5_4_NV',0x8675) +GL_MAP2_VERTEX_ATTRIB6_4_NV=_C('GL_MAP2_VERTEX_ATTRIB6_4_NV',0x8676) +GL_MAP2_VERTEX_ATTRIB7_4_NV=_C('GL_MAP2_VERTEX_ATTRIB7_4_NV',0x8677) +GL_MAP2_VERTEX_ATTRIB8_4_NV=_C('GL_MAP2_VERTEX_ATTRIB8_4_NV',0x8678) +GL_MAP2_VERTEX_ATTRIB9_4_NV=_C('GL_MAP2_VERTEX_ATTRIB9_4_NV',0x8679) +GL_MATRIX0_NV=_C('GL_MATRIX0_NV',0x8630) +GL_MATRIX1_NV=_C('GL_MATRIX1_NV',0x8631) +GL_MATRIX2_NV=_C('GL_MATRIX2_NV',0x8632) +GL_MATRIX3_NV=_C('GL_MATRIX3_NV',0x8633) +GL_MATRIX4_NV=_C('GL_MATRIX4_NV',0x8634) +GL_MATRIX5_NV=_C('GL_MATRIX5_NV',0x8635) +GL_MATRIX6_NV=_C('GL_MATRIX6_NV',0x8636) +GL_MATRIX7_NV=_C('GL_MATRIX7_NV',0x8637) +GL_MAX_TRACK_MATRICES_NV=_C('GL_MAX_TRACK_MATRICES_NV',0x862F) +GL_MAX_TRACK_MATRIX_STACK_DEPTH_NV=_C('GL_MAX_TRACK_MATRIX_STACK_DEPTH_NV',0x862E) +GL_MODELVIEW_PROJECTION_NV=_C('GL_MODELVIEW_PROJECTION_NV',0x8629) +GL_PROGRAM_ERROR_POSITION_NV=_C('GL_PROGRAM_ERROR_POSITION_NV',0x864B) +GL_PROGRAM_LENGTH_NV=_C('GL_PROGRAM_LENGTH_NV',0x8627) +GL_PROGRAM_PARAMETER_NV=_C('GL_PROGRAM_PARAMETER_NV',0x8644) +GL_PROGRAM_RESIDENT_NV=_C('GL_PROGRAM_RESIDENT_NV',0x8647) +GL_PROGRAM_STRING_NV=_C('GL_PROGRAM_STRING_NV',0x8628) +GL_PROGRAM_TARGET_NV=_C('GL_PROGRAM_TARGET_NV',0x8646) +GL_TRACK_MATRIX_NV=_C('GL_TRACK_MATRIX_NV',0x8648) +GL_TRACK_MATRIX_TRANSFORM_NV=_C('GL_TRACK_MATRIX_TRANSFORM_NV',0x8649) +GL_TRANSPOSE_NV=_C('GL_TRANSPOSE_NV',0x862C) +GL_VERTEX_ATTRIB_ARRAY0_NV=_C('GL_VERTEX_ATTRIB_ARRAY0_NV',0x8650) +GL_VERTEX_ATTRIB_ARRAY10_NV=_C('GL_VERTEX_ATTRIB_ARRAY10_NV',0x865A) +GL_VERTEX_ATTRIB_ARRAY11_NV=_C('GL_VERTEX_ATTRIB_ARRAY11_NV',0x865B) +GL_VERTEX_ATTRIB_ARRAY12_NV=_C('GL_VERTEX_ATTRIB_ARRAY12_NV',0x865C) +GL_VERTEX_ATTRIB_ARRAY13_NV=_C('GL_VERTEX_ATTRIB_ARRAY13_NV',0x865D) +GL_VERTEX_ATTRIB_ARRAY14_NV=_C('GL_VERTEX_ATTRIB_ARRAY14_NV',0x865E) +GL_VERTEX_ATTRIB_ARRAY15_NV=_C('GL_VERTEX_ATTRIB_ARRAY15_NV',0x865F) +GL_VERTEX_ATTRIB_ARRAY1_NV=_C('GL_VERTEX_ATTRIB_ARRAY1_NV',0x8651) +GL_VERTEX_ATTRIB_ARRAY2_NV=_C('GL_VERTEX_ATTRIB_ARRAY2_NV',0x8652) +GL_VERTEX_ATTRIB_ARRAY3_NV=_C('GL_VERTEX_ATTRIB_ARRAY3_NV',0x8653) +GL_VERTEX_ATTRIB_ARRAY4_NV=_C('GL_VERTEX_ATTRIB_ARRAY4_NV',0x8654) +GL_VERTEX_ATTRIB_ARRAY5_NV=_C('GL_VERTEX_ATTRIB_ARRAY5_NV',0x8655) +GL_VERTEX_ATTRIB_ARRAY6_NV=_C('GL_VERTEX_ATTRIB_ARRAY6_NV',0x8656) +GL_VERTEX_ATTRIB_ARRAY7_NV=_C('GL_VERTEX_ATTRIB_ARRAY7_NV',0x8657) +GL_VERTEX_ATTRIB_ARRAY8_NV=_C('GL_VERTEX_ATTRIB_ARRAY8_NV',0x8658) +GL_VERTEX_ATTRIB_ARRAY9_NV=_C('GL_VERTEX_ATTRIB_ARRAY9_NV',0x8659) +GL_VERTEX_PROGRAM_BINDING_NV=_C('GL_VERTEX_PROGRAM_BINDING_NV',0x864A) +GL_VERTEX_PROGRAM_NV=_C('GL_VERTEX_PROGRAM_NV',0x8620) +GL_VERTEX_PROGRAM_POINT_SIZE_NV=_C('GL_VERTEX_PROGRAM_POINT_SIZE_NV',0x8642) +GL_VERTEX_PROGRAM_TWO_SIDE_NV=_C('GL_VERTEX_PROGRAM_TWO_SIDE_NV',0x8643) +GL_VERTEX_STATE_PROGRAM_NV=_C('GL_VERTEX_STATE_PROGRAM_NV',0x8621) +@_f +@_p.types(_cs.GLboolean,_cs.GLsizei,arrays.GLuintArray,arrays.GLbooleanArray) +def glAreProgramsResidentNV(n,programs,residences):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint) +def glBindProgramNV(target,id):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray) +def glDeleteProgramsNV(n,programs):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,arrays.GLfloatArray) +def glExecuteProgramNV(target,id,params):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray) +def glGenProgramsNV(n,programs):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,_cs.GLenum,arrays.GLdoubleArray) +def glGetProgramParameterdvNV(target,index,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,_cs.GLenum,arrays.GLfloatArray) +def glGetProgramParameterfvNV(target,index,pname,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLubyteArray) +def glGetProgramStringNV(id,pname,program):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLintArray) +def glGetProgramivNV(id,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,_cs.GLenum,arrays.GLintArray) +def glGetTrackMatrixivNV(target,address,pname,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLvoidpArray) +def glGetVertexAttribPointervNV(index,pname,pointer):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLdoubleArray) +def glGetVertexAttribdvNV(index,pname,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLfloatArray) +def glGetVertexAttribfvNV(index,pname,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLintArray) +def glGetVertexAttribivNV(index,pname,params):pass +@_f +@_p.types(_cs.GLboolean,_cs.GLuint) +def glIsProgramNV(id):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,_cs.GLsizei,arrays.GLubyteArray) +def glLoadProgramNV(target,id,len,program):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,_cs.GLdouble,_cs.GLdouble,_cs.GLdouble,_cs.GLdouble) +def glProgramParameter4dNV(target,index,x,y,z,w):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,arrays.GLdoubleArray) +def glProgramParameter4dvNV(target,index,v):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat) +def glProgramParameter4fNV(target,index,x,y,z,w):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,arrays.GLfloatArray) +def glProgramParameter4fvNV(target,index,v):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,_cs.GLsizei,arrays.GLdoubleArray) +def glProgramParameters4dvNV(target,index,count,v):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,_cs.GLsizei,arrays.GLfloatArray) +def glProgramParameters4fvNV(target,index,count,v):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray) +def glRequestResidentProgramsNV(n,programs):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,_cs.GLenum,_cs.GLenum) +def glTrackMatrixNV(target,address,matrix,transform):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLdouble) +def glVertexAttrib1dNV(index,x):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLdoubleArray) +def glVertexAttrib1dvNV(index,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLfloat) +def glVertexAttrib1fNV(index,x):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLfloatArray) +def glVertexAttrib1fvNV(index,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLshort) +def glVertexAttrib1sNV(index,x):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLshortArray) +def glVertexAttrib1svNV(index,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLdouble,_cs.GLdouble) +def glVertexAttrib2dNV(index,x,y):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLdoubleArray) +def glVertexAttrib2dvNV(index,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLfloat,_cs.GLfloat) +def glVertexAttrib2fNV(index,x,y):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLfloatArray) +def glVertexAttrib2fvNV(index,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLshort,_cs.GLshort) +def glVertexAttrib2sNV(index,x,y):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLshortArray) +def glVertexAttrib2svNV(index,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLdouble,_cs.GLdouble,_cs.GLdouble) +def glVertexAttrib3dNV(index,x,y,z):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLdoubleArray) +def glVertexAttrib3dvNV(index,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat) +def glVertexAttrib3fNV(index,x,y,z):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLfloatArray) +def glVertexAttrib3fvNV(index,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLshort,_cs.GLshort,_cs.GLshort) +def glVertexAttrib3sNV(index,x,y,z):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLshortArray) +def glVertexAttrib3svNV(index,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLdouble,_cs.GLdouble,_cs.GLdouble,_cs.GLdouble) +def glVertexAttrib4dNV(index,x,y,z,w):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLdoubleArray) +def glVertexAttrib4dvNV(index,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat) +def glVertexAttrib4fNV(index,x,y,z,w):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLfloatArray) +def glVertexAttrib4fvNV(index,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLshort,_cs.GLshort,_cs.GLshort,_cs.GLshort) +def glVertexAttrib4sNV(index,x,y,z,w):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLshortArray) +def glVertexAttrib4svNV(index,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLubyte,_cs.GLubyte,_cs.GLubyte,_cs.GLubyte) +def glVertexAttrib4ubNV(index,x,y,z,w):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLubyteArray) +def glVertexAttrib4ubvNV(index,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLenum,_cs.GLsizei,ctypes.c_void_p) +def glVertexAttribPointerNV(index,fsize,type,stride,pointer):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizei,arrays.GLdoubleArray) +def glVertexAttribs1dvNV(index,count,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizei,arrays.GLfloatArray) +def glVertexAttribs1fvNV(index,count,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizei,arrays.GLshortArray) +def glVertexAttribs1svNV(index,count,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizei,arrays.GLdoubleArray) +def glVertexAttribs2dvNV(index,count,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizei,arrays.GLfloatArray) +def glVertexAttribs2fvNV(index,count,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizei,arrays.GLshortArray) +def glVertexAttribs2svNV(index,count,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizei,arrays.GLdoubleArray) +def glVertexAttribs3dvNV(index,count,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizei,arrays.GLfloatArray) +def glVertexAttribs3fvNV(index,count,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizei,arrays.GLshortArray) +def glVertexAttribs3svNV(index,count,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizei,arrays.GLdoubleArray) +def glVertexAttribs4dvNV(index,count,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizei,arrays.GLfloatArray) +def glVertexAttribs4fvNV(index,count,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizei,arrays.GLshortArray) +def glVertexAttribs4svNV(index,count,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizei,arrays.GLubyteArray) +def glVertexAttribs4ubvNV(index,count,v):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/vertex_program1_1.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/vertex_program1_1.py new file mode 100644 index 00000000..d6429a09 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/vertex_program1_1.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_NV_vertex_program1_1' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_NV_vertex_program1_1',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/vertex_program2.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/vertex_program2.py new file mode 100644 index 00000000..62a80da5 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/vertex_program2.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_NV_vertex_program2' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_NV_vertex_program2',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/vertex_program2_option.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/vertex_program2_option.py new file mode 100644 index 00000000..6578ee9a --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/vertex_program2_option.py @@ -0,0 +1,16 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_NV_vertex_program2_option' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_NV_vertex_program2_option',error_checker=_errors._error_checker) +GL_MAX_PROGRAM_CALL_DEPTH_NV=_C('GL_MAX_PROGRAM_CALL_DEPTH_NV',0x88F5) +GL_MAX_PROGRAM_EXEC_INSTRUCTIONS_NV=_C('GL_MAX_PROGRAM_EXEC_INSTRUCTIONS_NV',0x88F4) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/vertex_program3.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/vertex_program3.py new file mode 100644 index 00000000..71d6561c --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/vertex_program3.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_NV_vertex_program3' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_NV_vertex_program3',error_checker=_errors._error_checker) +GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB=_C('GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB',0x8B4C) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/vertex_program4.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/vertex_program4.py new file mode 100644 index 00000000..bcc6b606 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/vertex_program4.py @@ -0,0 +1,83 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_NV_vertex_program4' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_NV_vertex_program4',error_checker=_errors._error_checker) +GL_VERTEX_ATTRIB_ARRAY_INTEGER_NV=_C('GL_VERTEX_ATTRIB_ARRAY_INTEGER_NV',0x88FD) +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLintArray) +def glGetVertexAttribIivEXT(index,pname,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLuintArray) +def glGetVertexAttribIuivEXT(index,pname,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint) +def glVertexAttribI1iEXT(index,x):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLintArray) +def glVertexAttribI1ivEXT(index,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint) +def glVertexAttribI1uiEXT(index,x):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLuintArray) +def glVertexAttribI1uivEXT(index,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLint) +def glVertexAttribI2iEXT(index,x,y):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLintArray) +def glVertexAttribI2ivEXT(index,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLuint) +def glVertexAttribI2uiEXT(index,x,y):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLuintArray) +def glVertexAttribI2uivEXT(index,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLint,_cs.GLint) +def glVertexAttribI3iEXT(index,x,y,z):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLintArray) +def glVertexAttribI3ivEXT(index,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLuint,_cs.GLuint) +def glVertexAttribI3uiEXT(index,x,y,z):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLuintArray) +def glVertexAttribI3uivEXT(index,v):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLbyteArray) +def glVertexAttribI4bvEXT(index,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint) +def glVertexAttribI4iEXT(index,x,y,z,w):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLintArray) +def glVertexAttribI4ivEXT(index,v):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLshortArray) +def glVertexAttribI4svEXT(index,v):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLubyteArray) +def glVertexAttribI4ubvEXT(index,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLuint,_cs.GLuint,_cs.GLuint) +def glVertexAttribI4uiEXT(index,x,y,z,w):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLuintArray) +def glVertexAttribI4uivEXT(index,v):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLushortArray) +def glVertexAttribI4usvEXT(index,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLenum,_cs.GLsizei,ctypes.c_void_p) +def glVertexAttribIPointerEXT(index,size,type,stride,pointer):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/video_capture.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/video_capture.py new file mode 100644 index 00000000..2737343d --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/video_capture.py @@ -0,0 +1,78 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_NV_video_capture' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_NV_video_capture',error_checker=_errors._error_checker) +GL_FAILURE_NV=_C('GL_FAILURE_NV',0x9030) +GL_FIELD_LOWER_NV=_C('GL_FIELD_LOWER_NV',0x9023) +GL_FIELD_UPPER_NV=_C('GL_FIELD_UPPER_NV',0x9022) +GL_LAST_VIDEO_CAPTURE_STATUS_NV=_C('GL_LAST_VIDEO_CAPTURE_STATUS_NV',0x9027) +GL_NEXT_VIDEO_CAPTURE_BUFFER_STATUS_NV=_C('GL_NEXT_VIDEO_CAPTURE_BUFFER_STATUS_NV',0x9025) +GL_NUM_VIDEO_CAPTURE_STREAMS_NV=_C('GL_NUM_VIDEO_CAPTURE_STREAMS_NV',0x9024) +GL_PARTIAL_SUCCESS_NV=_C('GL_PARTIAL_SUCCESS_NV',0x902E) +GL_SUCCESS_NV=_C('GL_SUCCESS_NV',0x902F) +GL_VIDEO_BUFFER_BINDING_NV=_C('GL_VIDEO_BUFFER_BINDING_NV',0x9021) +GL_VIDEO_BUFFER_INTERNAL_FORMAT_NV=_C('GL_VIDEO_BUFFER_INTERNAL_FORMAT_NV',0x902D) +GL_VIDEO_BUFFER_NV=_C('GL_VIDEO_BUFFER_NV',0x9020) +GL_VIDEO_BUFFER_PITCH_NV=_C('GL_VIDEO_BUFFER_PITCH_NV',0x9028) +GL_VIDEO_CAPTURE_FIELD_LOWER_HEIGHT_NV=_C('GL_VIDEO_CAPTURE_FIELD_LOWER_HEIGHT_NV',0x903B) +GL_VIDEO_CAPTURE_FIELD_UPPER_HEIGHT_NV=_C('GL_VIDEO_CAPTURE_FIELD_UPPER_HEIGHT_NV',0x903A) +GL_VIDEO_CAPTURE_FRAME_HEIGHT_NV=_C('GL_VIDEO_CAPTURE_FRAME_HEIGHT_NV',0x9039) +GL_VIDEO_CAPTURE_FRAME_WIDTH_NV=_C('GL_VIDEO_CAPTURE_FRAME_WIDTH_NV',0x9038) +GL_VIDEO_CAPTURE_SURFACE_ORIGIN_NV=_C('GL_VIDEO_CAPTURE_SURFACE_ORIGIN_NV',0x903C) +GL_VIDEO_CAPTURE_TO_422_SUPPORTED_NV=_C('GL_VIDEO_CAPTURE_TO_422_SUPPORTED_NV',0x9026) +GL_VIDEO_COLOR_CONVERSION_MATRIX_NV=_C('GL_VIDEO_COLOR_CONVERSION_MATRIX_NV',0x9029) +GL_VIDEO_COLOR_CONVERSION_MAX_NV=_C('GL_VIDEO_COLOR_CONVERSION_MAX_NV',0x902A) +GL_VIDEO_COLOR_CONVERSION_MIN_NV=_C('GL_VIDEO_COLOR_CONVERSION_MIN_NV',0x902B) +GL_VIDEO_COLOR_CONVERSION_OFFSET_NV=_C('GL_VIDEO_COLOR_CONVERSION_OFFSET_NV',0x902C) +GL_YCBAYCR8A_4224_NV=_C('GL_YCBAYCR8A_4224_NV',0x9032) +GL_YCBYCR8_422_NV=_C('GL_YCBYCR8_422_NV',0x9031) +GL_Z4Y12Z4CB12Z4A12Z4Y12Z4CR12Z4A12_4224_NV=_C('GL_Z4Y12Z4CB12Z4A12Z4Y12Z4CR12Z4A12_4224_NV',0x9036) +GL_Z4Y12Z4CB12Z4CR12_444_NV=_C('GL_Z4Y12Z4CB12Z4CR12_444_NV',0x9037) +GL_Z4Y12Z4CB12Z4Y12Z4CR12_422_NV=_C('GL_Z4Y12Z4CB12Z4Y12Z4CR12_422_NV',0x9035) +GL_Z6Y10Z6CB10Z6A10Z6Y10Z6CR10Z6A10_4224_NV=_C('GL_Z6Y10Z6CB10Z6A10Z6Y10Z6CR10Z6A10_4224_NV',0x9034) +GL_Z6Y10Z6CB10Z6Y10Z6CR10_422_NV=_C('GL_Z6Y10Z6CB10Z6Y10Z6CR10_422_NV',0x9033) +@_f +@_p.types(None,_cs.GLuint) +def glBeginVideoCaptureNV(video_capture_slot):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLenum,_cs.GLintptrARB) +def glBindVideoCaptureStreamBufferNV(video_capture_slot,stream,frame_region,offset):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLenum,_cs.GLenum,_cs.GLuint) +def glBindVideoCaptureStreamTextureNV(video_capture_slot,stream,frame_region,target,texture):pass +@_f +@_p.types(None,_cs.GLuint) +def glEndVideoCaptureNV(video_capture_slot):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLenum,arrays.GLdoubleArray) +def glGetVideoCaptureStreamdvNV(video_capture_slot,stream,pname,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLenum,arrays.GLfloatArray) +def glGetVideoCaptureStreamfvNV(video_capture_slot,stream,pname,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLenum,arrays.GLintArray) +def glGetVideoCaptureStreamivNV(video_capture_slot,stream,pname,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLintArray) +def glGetVideoCaptureivNV(video_capture_slot,pname,params):pass +@_f +@_p.types(_cs.GLenum,_cs.GLuint,arrays.GLuintArray,arrays.GLuint64Array) +def glVideoCaptureNV(video_capture_slot,sequence_num,capture_time):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLenum,arrays.GLdoubleArray) +def glVideoCaptureStreamParameterdvNV(video_capture_slot,stream,pname,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLenum,arrays.GLfloatArray) +def glVideoCaptureStreamParameterfvNV(video_capture_slot,stream,pname,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLenum,arrays.GLintArray) +def glVideoCaptureStreamParameterivNV(video_capture_slot,stream,pname,params):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/viewport_array2.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/viewport_array2.py new file mode 100644 index 00000000..b40e3c8d --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/viewport_array2.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_NV_viewport_array2' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_NV_viewport_array2',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/viewport_swizzle.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/viewport_swizzle.py new file mode 100644 index 00000000..a8e66730 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NV/viewport_swizzle.py @@ -0,0 +1,28 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_NV_viewport_swizzle' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_NV_viewport_swizzle',error_checker=_errors._error_checker) +GL_VIEWPORT_SWIZZLE_NEGATIVE_W_NV=_C('GL_VIEWPORT_SWIZZLE_NEGATIVE_W_NV',0x9357) +GL_VIEWPORT_SWIZZLE_NEGATIVE_X_NV=_C('GL_VIEWPORT_SWIZZLE_NEGATIVE_X_NV',0x9351) +GL_VIEWPORT_SWIZZLE_NEGATIVE_Y_NV=_C('GL_VIEWPORT_SWIZZLE_NEGATIVE_Y_NV',0x9353) +GL_VIEWPORT_SWIZZLE_NEGATIVE_Z_NV=_C('GL_VIEWPORT_SWIZZLE_NEGATIVE_Z_NV',0x9355) +GL_VIEWPORT_SWIZZLE_POSITIVE_W_NV=_C('GL_VIEWPORT_SWIZZLE_POSITIVE_W_NV',0x9356) +GL_VIEWPORT_SWIZZLE_POSITIVE_X_NV=_C('GL_VIEWPORT_SWIZZLE_POSITIVE_X_NV',0x9350) +GL_VIEWPORT_SWIZZLE_POSITIVE_Y_NV=_C('GL_VIEWPORT_SWIZZLE_POSITIVE_Y_NV',0x9352) +GL_VIEWPORT_SWIZZLE_POSITIVE_Z_NV=_C('GL_VIEWPORT_SWIZZLE_POSITIVE_Z_NV',0x9354) +GL_VIEWPORT_SWIZZLE_W_NV=_C('GL_VIEWPORT_SWIZZLE_W_NV',0x935B) +GL_VIEWPORT_SWIZZLE_X_NV=_C('GL_VIEWPORT_SWIZZLE_X_NV',0x9358) +GL_VIEWPORT_SWIZZLE_Y_NV=_C('GL_VIEWPORT_SWIZZLE_Y_NV',0x9359) +GL_VIEWPORT_SWIZZLE_Z_NV=_C('GL_VIEWPORT_SWIZZLE_Z_NV',0x935A) +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLenum,_cs.GLenum,_cs.GLenum) +def glViewportSwizzleNV(index,swizzlex,swizzley,swizzlez,swizzlew):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NVX/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NVX/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NVX/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NVX/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NVX/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..a871aa6a Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NVX/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NVX/__pycache__/blend_equation_advanced_multi_draw_buffers.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NVX/__pycache__/blend_equation_advanced_multi_draw_buffers.cpython-312.pyc new file mode 100644 index 00000000..b2aed333 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NVX/__pycache__/blend_equation_advanced_multi_draw_buffers.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NVX/__pycache__/conditional_render.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NVX/__pycache__/conditional_render.cpython-312.pyc new file mode 100644 index 00000000..f43fc107 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NVX/__pycache__/conditional_render.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NVX/__pycache__/gpu_memory_info.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NVX/__pycache__/gpu_memory_info.cpython-312.pyc new file mode 100644 index 00000000..a41dc85a Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NVX/__pycache__/gpu_memory_info.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NVX/__pycache__/gpu_multicast2.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NVX/__pycache__/gpu_multicast2.cpython-312.pyc new file mode 100644 index 00000000..91b154c9 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NVX/__pycache__/gpu_multicast2.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NVX/__pycache__/linked_gpu_multicast.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NVX/__pycache__/linked_gpu_multicast.cpython-312.pyc new file mode 100644 index 00000000..fea71f4c Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NVX/__pycache__/linked_gpu_multicast.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NVX/__pycache__/progress_fence.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NVX/__pycache__/progress_fence.cpython-312.pyc new file mode 100644 index 00000000..27abb5b1 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NVX/__pycache__/progress_fence.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NVX/blend_equation_advanced_multi_draw_buffers.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NVX/blend_equation_advanced_multi_draw_buffers.py new file mode 100644 index 00000000..8ade3cbc --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NVX/blend_equation_advanced_multi_draw_buffers.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_NVX_blend_equation_advanced_multi_draw_buffers' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_NVX_blend_equation_advanced_multi_draw_buffers',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NVX/conditional_render.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NVX/conditional_render.py new file mode 100644 index 00000000..d1a995e5 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NVX/conditional_render.py @@ -0,0 +1,20 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_NVX_conditional_render' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_NVX_conditional_render',error_checker=_errors._error_checker) + +@_f +@_p.types(None,_cs.GLuint) +def glBeginConditionalRenderNVX(id):pass +@_f +@_p.types(None,) +def glEndConditionalRenderNVX():pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NVX/gpu_memory_info.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NVX/gpu_memory_info.py new file mode 100644 index 00000000..6df49adb --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NVX/gpu_memory_info.py @@ -0,0 +1,19 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_NVX_gpu_memory_info' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_NVX_gpu_memory_info',error_checker=_errors._error_checker) +GL_GPU_MEMORY_INFO_CURRENT_AVAILABLE_VIDMEM_NVX=_C('GL_GPU_MEMORY_INFO_CURRENT_AVAILABLE_VIDMEM_NVX',0x9049) +GL_GPU_MEMORY_INFO_DEDICATED_VIDMEM_NVX=_C('GL_GPU_MEMORY_INFO_DEDICATED_VIDMEM_NVX',0x9047) +GL_GPU_MEMORY_INFO_EVICTED_MEMORY_NVX=_C('GL_GPU_MEMORY_INFO_EVICTED_MEMORY_NVX',0x904B) +GL_GPU_MEMORY_INFO_EVICTION_COUNT_NVX=_C('GL_GPU_MEMORY_INFO_EVICTION_COUNT_NVX',0x904A) +GL_GPU_MEMORY_INFO_TOTAL_AVAILABLE_MEMORY_NVX=_C('GL_GPU_MEMORY_INFO_TOTAL_AVAILABLE_MEMORY_NVX',0x9048) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NVX/gpu_multicast2.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NVX/gpu_multicast2.py new file mode 100644 index 00000000..15260381 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NVX/gpu_multicast2.py @@ -0,0 +1,32 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_NVX_gpu_multicast2' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_NVX_gpu_multicast2',error_checker=_errors._error_checker) +GL_UPLOAD_GPU_MASK_NVX=_C('GL_UPLOAD_GPU_MASK_NVX',0x954A) +@_f +@_p.types(_cs.GLuint,_cs.GLsizei,arrays.GLuintArray,arrays.GLuint64Array,_cs.GLuint,_cs.GLbitfield,_cs.GLuint,_cs.GLuint,_cs.GLintptr,_cs.GLintptr,_cs.GLsizeiptr,_cs.GLsizei,arrays.GLuintArray,arrays.GLuint64Array) +def glAsyncCopyBufferSubDataNVX(waitSemaphoreCount,waitSemaphoreArray,fenceValueArray,readGpu,writeGpuMask,readBuffer,writeBuffer,readOffset,writeOffset,size,signalSemaphoreCount,signalSemaphoreArray,signalValueArray):pass +@_f +@_p.types(_cs.GLuint,_cs.GLsizei,arrays.GLuintArray,arrays.GLuint64Array,_cs.GLuint,_cs.GLbitfield,_cs.GLuint,_cs.GLenum,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLuint,_cs.GLenum,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLsizei,_cs.GLsizei,_cs.GLsizei,arrays.GLuintArray,arrays.GLuint64Array) +def glAsyncCopyImageSubDataNVX(waitSemaphoreCount,waitSemaphoreArray,waitValueArray,srcGpu,dstGpuMask,srcName,srcTarget,srcLevel,srcX,srcY,srcZ,dstName,dstTarget,dstLevel,dstX,dstY,dstZ,srcWidth,srcHeight,srcDepth,signalSemaphoreCount,signalSemaphoreArray,signalValueArray):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLsizei,arrays.GLintArray) +def glMulticastScissorArrayvNVX(gpu,first,count,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLsizei,arrays.GLfloatArray) +def glMulticastViewportArrayvNVX(gpu,first,count,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLfloat,_cs.GLfloat) +def glMulticastViewportPositionWScaleNVX(gpu,index,xcoeff,ycoeff):pass +@_f +@_p.types(None,_cs.GLbitfield) +def glUploadGpuMaskNVX(mask):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NVX/linked_gpu_multicast.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NVX/linked_gpu_multicast.py new file mode 100644 index 00000000..dd48fcc1 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NVX/linked_gpu_multicast.py @@ -0,0 +1,24 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_NVX_linked_gpu_multicast' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_NVX_linked_gpu_multicast',error_checker=_errors._error_checker) +GL_LGPU_SEPARATE_STORAGE_BIT_NVX=_C('GL_LGPU_SEPARATE_STORAGE_BIT_NVX',0x0800) +GL_MAX_LGPU_GPUS_NVX=_C('GL_MAX_LGPU_GPUS_NVX',0x92BA) +@_f +@_p.types(None,_cs.GLuint,_cs.GLbitfield,_cs.GLuint,_cs.GLenum,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLuint,_cs.GLenum,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLsizei,_cs.GLsizei) +def glLGPUCopyImageSubDataNVX(sourceGpu,destinationGpuMask,srcName,srcTarget,srcLevel,srcX,srxY,srcZ,dstName,dstTarget,dstLevel,dstX,dstY,dstZ,width,height,depth):pass +@_f +@_p.types(None,) +def glLGPUInterlockNVX():pass +@_f +@_p.types(None,_cs.GLbitfield,_cs.GLuint,_cs.GLintptr,_cs.GLsizeiptr,ctypes.c_void_p) +def glLGPUNamedBufferSubDataNVX(gpuMask,buffer,offset,size,data):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NVX/progress_fence.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NVX/progress_fence.py new file mode 100644 index 00000000..df09c0a0 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/NVX/progress_fence.py @@ -0,0 +1,26 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_NVX_progress_fence' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_NVX_progress_fence',error_checker=_errors._error_checker) + +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray,arrays.GLuint64Array) +def glClientWaitSemaphoreui64NVX(fenceObjectCount,semaphoreArray,fenceValueArray):pass +@_f +@_p.types(_cs.GLuint,) +def glCreateProgressFenceNVX():pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizei,arrays.GLuintArray,arrays.GLuint64Array) +def glSignalSemaphoreui64NVX(signalGpu,fenceObjectCount,semaphoreArray,fenceValueArray):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizei,arrays.GLuintArray,arrays.GLuint64Array) +def glWaitSemaphoreui64NVX(waitGpu,fenceObjectCount,semaphoreArray,fenceValueArray):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/OES/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/OES/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/OES/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/OES/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/OES/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..4cb56fa1 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/OES/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/OES/__pycache__/byte_coordinates.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/OES/__pycache__/byte_coordinates.cpython-312.pyc new file mode 100644 index 00000000..fed5912b Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/OES/__pycache__/byte_coordinates.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/OES/__pycache__/compressed_paletted_texture.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/OES/__pycache__/compressed_paletted_texture.cpython-312.pyc new file mode 100644 index 00000000..ba7ad9ea Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/OES/__pycache__/compressed_paletted_texture.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/OES/__pycache__/fixed_point.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/OES/__pycache__/fixed_point.cpython-312.pyc new file mode 100644 index 00000000..87ae6a60 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/OES/__pycache__/fixed_point.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/OES/__pycache__/query_matrix.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/OES/__pycache__/query_matrix.cpython-312.pyc new file mode 100644 index 00000000..ce12f13e Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/OES/__pycache__/query_matrix.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/OES/__pycache__/read_format.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/OES/__pycache__/read_format.cpython-312.pyc new file mode 100644 index 00000000..448b06c0 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/OES/__pycache__/read_format.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/OES/__pycache__/single_precision.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/OES/__pycache__/single_precision.cpython-312.pyc new file mode 100644 index 00000000..5a0d36b4 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/OES/__pycache__/single_precision.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/OES/byte_coordinates.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/OES/byte_coordinates.py new file mode 100644 index 00000000..c294c347 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/OES/byte_coordinates.py @@ -0,0 +1,80 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_OES_byte_coordinates' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_OES_byte_coordinates',error_checker=_errors._error_checker) +GL_BYTE=_C('GL_BYTE',0x1400) +@_f +@_p.types(None,_cs.GLenum,_cs.GLbyte) +def glMultiTexCoord1bOES(texture,s):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLbyteArray) +def glMultiTexCoord1bvOES(texture,coords):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLbyte,_cs.GLbyte) +def glMultiTexCoord2bOES(texture,s,t):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLbyteArray) +def glMultiTexCoord2bvOES(texture,coords):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLbyte,_cs.GLbyte,_cs.GLbyte) +def glMultiTexCoord3bOES(texture,s,t,r):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLbyteArray) +def glMultiTexCoord3bvOES(texture,coords):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLbyte,_cs.GLbyte,_cs.GLbyte,_cs.GLbyte) +def glMultiTexCoord4bOES(texture,s,t,r,q):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLbyteArray) +def glMultiTexCoord4bvOES(texture,coords):pass +@_f +@_p.types(None,_cs.GLbyte) +def glTexCoord1bOES(s):pass +@_f +@_p.types(None,arrays.GLbyteArray) +def glTexCoord1bvOES(coords):pass +@_f +@_p.types(None,_cs.GLbyte,_cs.GLbyte) +def glTexCoord2bOES(s,t):pass +@_f +@_p.types(None,arrays.GLbyteArray) +def glTexCoord2bvOES(coords):pass +@_f +@_p.types(None,_cs.GLbyte,_cs.GLbyte,_cs.GLbyte) +def glTexCoord3bOES(s,t,r):pass +@_f +@_p.types(None,arrays.GLbyteArray) +def glTexCoord3bvOES(coords):pass +@_f +@_p.types(None,_cs.GLbyte,_cs.GLbyte,_cs.GLbyte,_cs.GLbyte) +def glTexCoord4bOES(s,t,r,q):pass +@_f +@_p.types(None,arrays.GLbyteArray) +def glTexCoord4bvOES(coords):pass +@_f +@_p.types(None,_cs.GLbyte,_cs.GLbyte) +def glVertex2bOES(x,y):pass +@_f +@_p.types(None,arrays.GLbyteArray) +def glVertex2bvOES(coords):pass +@_f +@_p.types(None,_cs.GLbyte,_cs.GLbyte,_cs.GLbyte) +def glVertex3bOES(x,y,z):pass +@_f +@_p.types(None,arrays.GLbyteArray) +def glVertex3bvOES(coords):pass +@_f +@_p.types(None,_cs.GLbyte,_cs.GLbyte,_cs.GLbyte,_cs.GLbyte) +def glVertex4bOES(x,y,z,w):pass +@_f +@_p.types(None,arrays.GLbyteArray) +def glVertex4bvOES(coords):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/OES/compressed_paletted_texture.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/OES/compressed_paletted_texture.py new file mode 100644 index 00000000..5af09681 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/OES/compressed_paletted_texture.py @@ -0,0 +1,24 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_OES_compressed_paletted_texture' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_OES_compressed_paletted_texture',error_checker=_errors._error_checker) +GL_PALETTE4_R5_G6_B5_OES=_C('GL_PALETTE4_R5_G6_B5_OES',0x8B92) +GL_PALETTE4_RGB5_A1_OES=_C('GL_PALETTE4_RGB5_A1_OES',0x8B94) +GL_PALETTE4_RGB8_OES=_C('GL_PALETTE4_RGB8_OES',0x8B90) +GL_PALETTE4_RGBA4_OES=_C('GL_PALETTE4_RGBA4_OES',0x8B93) +GL_PALETTE4_RGBA8_OES=_C('GL_PALETTE4_RGBA8_OES',0x8B91) +GL_PALETTE8_R5_G6_B5_OES=_C('GL_PALETTE8_R5_G6_B5_OES',0x8B97) +GL_PALETTE8_RGB5_A1_OES=_C('GL_PALETTE8_RGB5_A1_OES',0x8B99) +GL_PALETTE8_RGB8_OES=_C('GL_PALETTE8_RGB8_OES',0x8B95) +GL_PALETTE8_RGBA4_OES=_C('GL_PALETTE8_RGBA4_OES',0x8B98) +GL_PALETTE8_RGBA8_OES=_C('GL_PALETTE8_RGBA8_OES',0x8B96) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/OES/fixed_point.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/OES/fixed_point.py new file mode 100644 index 00000000..c308271f --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/OES/fixed_point.py @@ -0,0 +1,335 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_OES_fixed_point' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_OES_fixed_point',error_checker=_errors._error_checker) +GL_FIXED_OES=_C('GL_FIXED_OES',0x140C) +@_f +@_p.types(None,_cs.GLenum,_cs.GLfixed) +def glAccumxOES(op,value):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLfixed) +def glAlphaFuncxOES(func,ref):pass +@_f +@_p.types(None,_cs.GLsizei,_cs.GLsizei,_cs.GLfixed,_cs.GLfixed,_cs.GLfixed,_cs.GLfixed,arrays.GLubyteArray) +def glBitmapxOES(width,height,xorig,yorig,xmove,ymove,bitmap):pass +@_f +@_p.types(None,_cs.GLfixed,_cs.GLfixed,_cs.GLfixed,_cs.GLfixed) +def glBlendColorxOES(red,green,blue,alpha):pass +@_f +@_p.types(None,_cs.GLfixed,_cs.GLfixed,_cs.GLfixed,_cs.GLfixed) +def glClearAccumxOES(red,green,blue,alpha):pass +@_f +@_p.types(None,_cs.GLfixed,_cs.GLfixed,_cs.GLfixed,_cs.GLfixed) +def glClearColorxOES(red,green,blue,alpha):pass +@_f +@_p.types(None,_cs.GLfixed) +def glClearDepthxOES(depth):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLfixedArray) +def glClipPlanexOES(plane,equation):pass +@_f +@_p.types(None,_cs.GLfixed,_cs.GLfixed,_cs.GLfixed) +def glColor3xOES(red,green,blue):pass +@_f +@_p.types(None,arrays.GLfixedArray) +def glColor3xvOES(components):pass +@_f +@_p.types(None,_cs.GLfixed,_cs.GLfixed,_cs.GLfixed,_cs.GLfixed) +def glColor4xOES(red,green,blue,alpha):pass +@_f +@_p.types(None,arrays.GLfixedArray) +def glColor4xvOES(components):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLfixed) +def glConvolutionParameterxOES(target,pname,param):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLfixedArray) +def glConvolutionParameterxvOES(target,pname,params):pass +@_f +@_p.types(None,_cs.GLfixed,_cs.GLfixed) +def glDepthRangexOES(n,f):pass +@_f +@_p.types(None,_cs.GLfixed) +def glEvalCoord1xOES(u):pass +@_f +@_p.types(None,arrays.GLfixedArray) +def glEvalCoord1xvOES(coords):pass +@_f +@_p.types(None,_cs.GLfixed,_cs.GLfixed) +def glEvalCoord2xOES(u,v):pass +@_f +@_p.types(None,arrays.GLfixedArray) +def glEvalCoord2xvOES(coords):pass +@_f +@_p.types(None,_cs.GLsizei,_cs.GLenum,arrays.GLfixedArray) +def glFeedbackBufferxOES(n,type,buffer):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLfixed) +def glFogxOES(pname,param):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLfixedArray) +def glFogxvOES(pname,param):pass +@_f +@_p.types(None,_cs.GLfixed,_cs.GLfixed,_cs.GLfixed,_cs.GLfixed,_cs.GLfixed,_cs.GLfixed) +def glFrustumxOES(l,r,b,t,n,f):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLfixedArray) +def glGetClipPlanexOES(plane,equation):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLfixedArray) +def glGetConvolutionParameterxvOES(target,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLfixedArray) +def glGetFixedvOES(pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLfixedArray) +def glGetHistogramParameterxvOES(target,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLfixedArray) +def glGetLightxOES(light,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLfixedArray) +def glGetLightxvOES(light,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLfixedArray) +def glGetMapxvOES(target,query,v):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLfixed) +def glGetMaterialxOES(face,pname,param):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLfixedArray) +def glGetMaterialxvOES(face,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLint,arrays.GLfixedArray) +def glGetPixelMapxv(map,size,values):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLfixedArray) +def glGetTexEnvxvOES(target,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLfixedArray) +def glGetTexGenxvOES(coord,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLint,_cs.GLenum,arrays.GLfixedArray) +def glGetTexLevelParameterxvOES(target,level,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLfixedArray) +def glGetTexParameterxvOES(target,pname,params):pass +@_f +@_p.types(None,_cs.GLfixed) +def glIndexxOES(component):pass +@_f +@_p.types(None,arrays.GLfixedArray) +def glIndexxvOES(component):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLfixed) +def glLightModelxOES(pname,param):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLfixedArray) +def glLightModelxvOES(pname,param):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLfixed) +def glLightxOES(light,pname,param):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLfixedArray) +def glLightxvOES(light,pname,params):pass +@_f +@_p.types(None,_cs.GLfixed) +def glLineWidthxOES(width):pass +@_f +@_p.types(None,arrays.GLfixedArray) +def glLoadMatrixxOES(m):pass +@_f +@_p.types(None,arrays.GLfixedArray) +def glLoadTransposeMatrixxOES(m):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLfixed,_cs.GLfixed,_cs.GLint,_cs.GLint,_cs.GLfixed) +def glMap1xOES(target,u1,u2,stride,order,points):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLfixed,_cs.GLfixed,_cs.GLint,_cs.GLint,_cs.GLfixed,_cs.GLfixed,_cs.GLint,_cs.GLint,_cs.GLfixed) +def glMap2xOES(target,u1,u2,ustride,uorder,v1,v2,vstride,vorder,points):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLfixed,_cs.GLfixed) +def glMapGrid1xOES(n,u1,u2):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLfixed,_cs.GLfixed,_cs.GLfixed,_cs.GLfixed) +def glMapGrid2xOES(n,u1,u2,v1,v2):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLfixed) +def glMaterialxOES(face,pname,param):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLfixedArray) +def glMaterialxvOES(face,pname,param):pass +@_f +@_p.types(None,arrays.GLfixedArray) +def glMultMatrixxOES(m):pass +@_f +@_p.types(None,arrays.GLfixedArray) +def glMultTransposeMatrixxOES(m):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLfixed) +def glMultiTexCoord1xOES(texture,s):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLfixedArray) +def glMultiTexCoord1xvOES(texture,coords):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLfixed,_cs.GLfixed) +def glMultiTexCoord2xOES(texture,s,t):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLfixedArray) +def glMultiTexCoord2xvOES(texture,coords):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLfixed,_cs.GLfixed,_cs.GLfixed) +def glMultiTexCoord3xOES(texture,s,t,r):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLfixedArray) +def glMultiTexCoord3xvOES(texture,coords):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLfixed,_cs.GLfixed,_cs.GLfixed,_cs.GLfixed) +def glMultiTexCoord4xOES(texture,s,t,r,q):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLfixedArray) +def glMultiTexCoord4xvOES(texture,coords):pass +@_f +@_p.types(None,_cs.GLfixed,_cs.GLfixed,_cs.GLfixed) +def glNormal3xOES(nx,ny,nz):pass +@_f +@_p.types(None,arrays.GLfixedArray) +def glNormal3xvOES(coords):pass +@_f +@_p.types(None,_cs.GLfixed,_cs.GLfixed,_cs.GLfixed,_cs.GLfixed,_cs.GLfixed,_cs.GLfixed) +def glOrthoxOES(l,r,b,t,n,f):pass +@_f +@_p.types(None,_cs.GLfixed) +def glPassThroughxOES(token):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLint,arrays.GLfixedArray) +def glPixelMapx(map,size,values):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLfixed) +def glPixelStorex(pname,param):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLfixed) +def glPixelTransferxOES(pname,param):pass +@_f +@_p.types(None,_cs.GLfixed,_cs.GLfixed) +def glPixelZoomxOES(xfactor,yfactor):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLfixed) +def glPointParameterxOES(pname,param):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLfixedArray) +def glPointParameterxvOES(pname,params):pass +@_f +@_p.types(None,_cs.GLfixed) +def glPointSizexOES(size):pass +@_f +@_p.types(None,_cs.GLfixed,_cs.GLfixed) +def glPolygonOffsetxOES(factor,units):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray,arrays.GLfixedArray) +def glPrioritizeTexturesxOES(n,textures,priorities):pass +@_f +@_p.types(None,_cs.GLfixed,_cs.GLfixed) +def glRasterPos2xOES(x,y):pass +@_f +@_p.types(None,arrays.GLfixedArray) +def glRasterPos2xvOES(coords):pass +@_f +@_p.types(None,_cs.GLfixed,_cs.GLfixed,_cs.GLfixed) +def glRasterPos3xOES(x,y,z):pass +@_f +@_p.types(None,arrays.GLfixedArray) +def glRasterPos3xvOES(coords):pass +@_f +@_p.types(None,_cs.GLfixed,_cs.GLfixed,_cs.GLfixed,_cs.GLfixed) +def glRasterPos4xOES(x,y,z,w):pass +@_f +@_p.types(None,arrays.GLfixedArray) +def glRasterPos4xvOES(coords):pass +@_f +@_p.types(None,_cs.GLfixed,_cs.GLfixed,_cs.GLfixed,_cs.GLfixed) +def glRectxOES(x1,y1,x2,y2):pass +@_f +@_p.types(None,arrays.GLfixedArray,arrays.GLfixedArray) +def glRectxvOES(v1,v2):pass +@_f +@_p.types(None,_cs.GLfixed,_cs.GLfixed,_cs.GLfixed,_cs.GLfixed) +def glRotatexOES(angle,x,y,z):pass +@_f +@_p.types(None,_cs.GLclampx,_cs.GLboolean) +def glSampleCoveragexOES(value,invert):pass +@_f +@_p.types(None,_cs.GLfixed,_cs.GLfixed,_cs.GLfixed) +def glScalexOES(x,y,z):pass +@_f +@_p.types(None,_cs.GLfixed) +def glTexCoord1xOES(s):pass +@_f +@_p.types(None,arrays.GLfixedArray) +def glTexCoord1xvOES(coords):pass +@_f +@_p.types(None,_cs.GLfixed,_cs.GLfixed) +def glTexCoord2xOES(s,t):pass +@_f +@_p.types(None,arrays.GLfixedArray) +def glTexCoord2xvOES(coords):pass +@_f +@_p.types(None,_cs.GLfixed,_cs.GLfixed,_cs.GLfixed) +def glTexCoord3xOES(s,t,r):pass +@_f +@_p.types(None,arrays.GLfixedArray) +def glTexCoord3xvOES(coords):pass +@_f +@_p.types(None,_cs.GLfixed,_cs.GLfixed,_cs.GLfixed,_cs.GLfixed) +def glTexCoord4xOES(s,t,r,q):pass +@_f +@_p.types(None,arrays.GLfixedArray) +def glTexCoord4xvOES(coords):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLfixed) +def glTexEnvxOES(target,pname,param):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLfixedArray) +def glTexEnvxvOES(target,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLfixed) +def glTexGenxOES(coord,pname,param):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLfixedArray) +def glTexGenxvOES(coord,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLfixed) +def glTexParameterxOES(target,pname,param):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLfixedArray) +def glTexParameterxvOES(target,pname,params):pass +@_f +@_p.types(None,_cs.GLfixed,_cs.GLfixed,_cs.GLfixed) +def glTranslatexOES(x,y,z):pass +@_f +@_p.types(None,_cs.GLfixed) +def glVertex2xOES(x):pass +@_f +@_p.types(None,arrays.GLfixedArray) +def glVertex2xvOES(coords):pass +@_f +@_p.types(None,_cs.GLfixed,_cs.GLfixed) +def glVertex3xOES(x,y):pass +@_f +@_p.types(None,arrays.GLfixedArray) +def glVertex3xvOES(coords):pass +@_f +@_p.types(None,_cs.GLfixed,_cs.GLfixed,_cs.GLfixed) +def glVertex4xOES(x,y,z):pass +@_f +@_p.types(None,arrays.GLfixedArray) +def glVertex4xvOES(coords):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/OES/query_matrix.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/OES/query_matrix.py new file mode 100644 index 00000000..362b9240 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/OES/query_matrix.py @@ -0,0 +1,17 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_OES_query_matrix' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_OES_query_matrix',error_checker=_errors._error_checker) + +@_f +@_p.types(_cs.GLbitfield,arrays.GLfixedArray,arrays.GLintArray) +def glQueryMatrixxOES(mantissa,exponent):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/OES/read_format.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/OES/read_format.py new file mode 100644 index 00000000..fa588d10 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/OES/read_format.py @@ -0,0 +1,16 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_OES_read_format' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_OES_read_format',error_checker=_errors._error_checker) +GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES=_C('GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES',0x8B9B) +GL_IMPLEMENTATION_COLOR_READ_TYPE_OES=_C('GL_IMPLEMENTATION_COLOR_READ_TYPE_OES',0x8B9A) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/OES/single_precision.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/OES/single_precision.py new file mode 100644 index 00000000..64f328d7 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/OES/single_precision.py @@ -0,0 +1,32 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_OES_single_precision' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_OES_single_precision',error_checker=_errors._error_checker) + +@_f +@_p.types(None,_cs.GLclampf) +def glClearDepthfOES(depth):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLfloatArray) +def glClipPlanefOES(plane,equation):pass +@_f +@_p.types(None,_cs.GLclampf,_cs.GLclampf) +def glDepthRangefOES(n,f):pass +@_f +@_p.types(None,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat) +def glFrustumfOES(l,r,b,t,n,f):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLfloatArray) +def glGetClipPlanefOES(plane,equation):pass +@_f +@_p.types(None,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat) +def glOrthofOES(l,r,b,t,n,f):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/OML/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/OML/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/OML/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/OML/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/OML/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..7fa8ad62 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/OML/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/OML/__pycache__/interlace.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/OML/__pycache__/interlace.cpython-312.pyc new file mode 100644 index 00000000..3b4eb4d9 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/OML/__pycache__/interlace.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/OML/__pycache__/resample.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/OML/__pycache__/resample.cpython-312.pyc new file mode 100644 index 00000000..00804e7e Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/OML/__pycache__/resample.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/OML/__pycache__/subsample.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/OML/__pycache__/subsample.cpython-312.pyc new file mode 100644 index 00000000..675ae448 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/OML/__pycache__/subsample.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/OML/interlace.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/OML/interlace.py new file mode 100644 index 00000000..61acb9d9 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/OML/interlace.py @@ -0,0 +1,16 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_OML_interlace' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_OML_interlace',error_checker=_errors._error_checker) +GL_INTERLACE_OML=_C('GL_INTERLACE_OML',0x8980) +GL_INTERLACE_READ_OML=_C('GL_INTERLACE_READ_OML',0x8981) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/OML/resample.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/OML/resample.py new file mode 100644 index 00000000..1b8a1fcc --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/OML/resample.py @@ -0,0 +1,20 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_OML_resample' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_OML_resample',error_checker=_errors._error_checker) +GL_PACK_RESAMPLE_OML=_C('GL_PACK_RESAMPLE_OML',0x8984) +GL_RESAMPLE_AVERAGE_OML=_C('GL_RESAMPLE_AVERAGE_OML',0x8988) +GL_RESAMPLE_DECIMATE_OML=_C('GL_RESAMPLE_DECIMATE_OML',0x8989) +GL_RESAMPLE_REPLICATE_OML=_C('GL_RESAMPLE_REPLICATE_OML',0x8986) +GL_RESAMPLE_ZERO_FILL_OML=_C('GL_RESAMPLE_ZERO_FILL_OML',0x8987) +GL_UNPACK_RESAMPLE_OML=_C('GL_UNPACK_RESAMPLE_OML',0x8985) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/OML/subsample.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/OML/subsample.py new file mode 100644 index 00000000..0105ec40 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/OML/subsample.py @@ -0,0 +1,16 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_OML_subsample' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_OML_subsample',error_checker=_errors._error_checker) +GL_FORMAT_SUBSAMPLE_244_244_OML=_C('GL_FORMAT_SUBSAMPLE_244_244_OML',0x8983) +GL_FORMAT_SUBSAMPLE_24_24_OML=_C('GL_FORMAT_SUBSAMPLE_24_24_OML',0x8982) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/OVR/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/OVR/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/OVR/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/OVR/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/OVR/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..153d2d89 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/OVR/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/OVR/__pycache__/multiview.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/OVR/__pycache__/multiview.cpython-312.pyc new file mode 100644 index 00000000..4badba2e Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/OVR/__pycache__/multiview.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/OVR/__pycache__/multiview2.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/OVR/__pycache__/multiview2.cpython-312.pyc new file mode 100644 index 00000000..c23233fc Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/OVR/__pycache__/multiview2.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/OVR/multiview.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/OVR/multiview.py new file mode 100644 index 00000000..3a6e0079 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/OVR/multiview.py @@ -0,0 +1,20 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_OVR_multiview' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_OVR_multiview',error_checker=_errors._error_checker) +GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_BASE_VIEW_INDEX_OVR=_C('GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_BASE_VIEW_INDEX_OVR',0x9632) +GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_NUM_VIEWS_OVR=_C('GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_NUM_VIEWS_OVR',0x9630) +GL_FRAMEBUFFER_INCOMPLETE_VIEW_TARGETS_OVR=_C('GL_FRAMEBUFFER_INCOMPLETE_VIEW_TARGETS_OVR',0x9633) +GL_MAX_VIEWS_OVR=_C('GL_MAX_VIEWS_OVR',0x9631) +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLuint,_cs.GLint,_cs.GLint,_cs.GLsizei) +def glFramebufferTextureMultiviewOVR(target,attachment,texture,level,baseViewIndex,numViews):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/OVR/multiview2.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/OVR/multiview2.py new file mode 100644 index 00000000..11458bc6 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/OVR/multiview2.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_OVR_multiview2' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_OVR_multiview2',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/PGI/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/PGI/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/PGI/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/PGI/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/PGI/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..5bd36369 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/PGI/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/PGI/__pycache__/misc_hints.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/PGI/__pycache__/misc_hints.cpython-312.pyc new file mode 100644 index 00000000..f0025879 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/PGI/__pycache__/misc_hints.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/PGI/__pycache__/vertex_hints.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/PGI/__pycache__/vertex_hints.cpython-312.pyc new file mode 100644 index 00000000..1545d060 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/PGI/__pycache__/vertex_hints.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/PGI/misc_hints.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/PGI/misc_hints.py new file mode 100644 index 00000000..d534ea2c --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/PGI/misc_hints.py @@ -0,0 +1,36 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_PGI_misc_hints' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_PGI_misc_hints',error_checker=_errors._error_checker) +GL_ALLOW_DRAW_FRG_HINT_PGI=_C('GL_ALLOW_DRAW_FRG_HINT_PGI',0x1A210) +GL_ALLOW_DRAW_MEM_HINT_PGI=_C('GL_ALLOW_DRAW_MEM_HINT_PGI',0x1A211) +GL_ALLOW_DRAW_OBJ_HINT_PGI=_C('GL_ALLOW_DRAW_OBJ_HINT_PGI',0x1A20E) +GL_ALLOW_DRAW_WIN_HINT_PGI=_C('GL_ALLOW_DRAW_WIN_HINT_PGI',0x1A20F) +GL_ALWAYS_FAST_HINT_PGI=_C('GL_ALWAYS_FAST_HINT_PGI',0x1A20C) +GL_ALWAYS_SOFT_HINT_PGI=_C('GL_ALWAYS_SOFT_HINT_PGI',0x1A20D) +GL_BACK_NORMALS_HINT_PGI=_C('GL_BACK_NORMALS_HINT_PGI',0x1A223) +GL_CLIP_FAR_HINT_PGI=_C('GL_CLIP_FAR_HINT_PGI',0x1A221) +GL_CLIP_NEAR_HINT_PGI=_C('GL_CLIP_NEAR_HINT_PGI',0x1A220) +GL_CONSERVE_MEMORY_HINT_PGI=_C('GL_CONSERVE_MEMORY_HINT_PGI',0x1A1FD) +GL_FULL_STIPPLE_HINT_PGI=_C('GL_FULL_STIPPLE_HINT_PGI',0x1A219) +GL_NATIVE_GRAPHICS_BEGIN_HINT_PGI=_C('GL_NATIVE_GRAPHICS_BEGIN_HINT_PGI',0x1A203) +GL_NATIVE_GRAPHICS_END_HINT_PGI=_C('GL_NATIVE_GRAPHICS_END_HINT_PGI',0x1A204) +GL_NATIVE_GRAPHICS_HANDLE_PGI=_C('GL_NATIVE_GRAPHICS_HANDLE_PGI',0x1A202) +GL_PREFER_DOUBLEBUFFER_HINT_PGI=_C('GL_PREFER_DOUBLEBUFFER_HINT_PGI',0x1A1F8) +GL_RECLAIM_MEMORY_HINT_PGI=_C('GL_RECLAIM_MEMORY_HINT_PGI',0x1A1FE) +GL_STRICT_DEPTHFUNC_HINT_PGI=_C('GL_STRICT_DEPTHFUNC_HINT_PGI',0x1A216) +GL_STRICT_LIGHTING_HINT_PGI=_C('GL_STRICT_LIGHTING_HINT_PGI',0x1A217) +GL_STRICT_SCISSOR_HINT_PGI=_C('GL_STRICT_SCISSOR_HINT_PGI',0x1A218) +GL_WIDE_LINE_HINT_PGI=_C('GL_WIDE_LINE_HINT_PGI',0x1A222) +@_f +@_p.types(None,_cs.GLenum,_cs.GLint) +def glHintPGI(target,mode):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/PGI/vertex_hints.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/PGI/vertex_hints.py new file mode 100644 index 00000000..46c3f641 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/PGI/vertex_hints.py @@ -0,0 +1,36 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_PGI_vertex_hints' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_PGI_vertex_hints',error_checker=_errors._error_checker) +GL_COLOR3_BIT_PGI=_C('GL_COLOR3_BIT_PGI',0x00010000) +GL_COLOR4_BIT_PGI=_C('GL_COLOR4_BIT_PGI',0x00020000) +GL_EDGEFLAG_BIT_PGI=_C('GL_EDGEFLAG_BIT_PGI',0x00040000) +GL_INDEX_BIT_PGI=_C('GL_INDEX_BIT_PGI',0x00080000) +GL_MATERIAL_SIDE_HINT_PGI=_C('GL_MATERIAL_SIDE_HINT_PGI',0x1A22C) +GL_MAT_AMBIENT_AND_DIFFUSE_BIT_PGI=_C('GL_MAT_AMBIENT_AND_DIFFUSE_BIT_PGI',0x00200000) +GL_MAT_AMBIENT_BIT_PGI=_C('GL_MAT_AMBIENT_BIT_PGI',0x00100000) +GL_MAT_COLOR_INDEXES_BIT_PGI=_C('GL_MAT_COLOR_INDEXES_BIT_PGI',0x01000000) +GL_MAT_DIFFUSE_BIT_PGI=_C('GL_MAT_DIFFUSE_BIT_PGI',0x00400000) +GL_MAT_EMISSION_BIT_PGI=_C('GL_MAT_EMISSION_BIT_PGI',0x00800000) +GL_MAT_SHININESS_BIT_PGI=_C('GL_MAT_SHININESS_BIT_PGI',0x02000000) +GL_MAT_SPECULAR_BIT_PGI=_C('GL_MAT_SPECULAR_BIT_PGI',0x04000000) +GL_MAX_VERTEX_HINT_PGI=_C('GL_MAX_VERTEX_HINT_PGI',0x1A22D) +GL_NORMAL_BIT_PGI=_C('GL_NORMAL_BIT_PGI',0x08000000) +GL_TEXCOORD1_BIT_PGI=_C('GL_TEXCOORD1_BIT_PGI',0x10000000) +GL_TEXCOORD2_BIT_PGI=_C('GL_TEXCOORD2_BIT_PGI',0x20000000) +GL_TEXCOORD3_BIT_PGI=_C('GL_TEXCOORD3_BIT_PGI',0x40000000) +GL_TEXCOORD4_BIT_PGI=_C('GL_TEXCOORD4_BIT_PGI',0x80000000) +GL_VERTEX23_BIT_PGI=_C('GL_VERTEX23_BIT_PGI',0x00000004) +GL_VERTEX4_BIT_PGI=_C('GL_VERTEX4_BIT_PGI',0x00000008) +GL_VERTEX_CONSISTENT_HINT_PGI=_C('GL_VERTEX_CONSISTENT_HINT_PGI',0x1A22B) +GL_VERTEX_DATA_HINT_PGI=_C('GL_VERTEX_DATA_HINT_PGI',0x1A22A) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/QCOM/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/QCOM/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/QCOM/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/QCOM/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/QCOM/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..6f6f0955 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/QCOM/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/REND/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/REND/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/REND/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/REND/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/REND/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..0ba3cdfd Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/REND/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/REND/__pycache__/screen_coordinates.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/REND/__pycache__/screen_coordinates.cpython-312.pyc new file mode 100644 index 00000000..50f76c2c Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/REND/__pycache__/screen_coordinates.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/REND/screen_coordinates.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/REND/screen_coordinates.py new file mode 100644 index 00000000..e118d8df --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/REND/screen_coordinates.py @@ -0,0 +1,16 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_REND_screen_coordinates' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_REND_screen_coordinates',error_checker=_errors._error_checker) +GL_INVERTED_SCREEN_W_REND=_C('GL_INVERTED_SCREEN_W_REND',0x8491) +GL_SCREEN_COORDINATES_REND=_C('GL_SCREEN_COORDINATES_REND',0x8490) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/S3/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/S3/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/S3/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/S3/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/S3/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..914b0daa Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/S3/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/S3/__pycache__/s3tc.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/S3/__pycache__/s3tc.cpython-312.pyc new file mode 100644 index 00000000..2fd62db4 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/S3/__pycache__/s3tc.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/S3/s3tc.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/S3/s3tc.py new file mode 100644 index 00000000..ddab3d8d --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/S3/s3tc.py @@ -0,0 +1,20 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_S3_s3tc' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_S3_s3tc',error_checker=_errors._error_checker) +GL_RGB4_S3TC=_C('GL_RGB4_S3TC',0x83A1) +GL_RGBA4_DXT5_S3TC=_C('GL_RGBA4_DXT5_S3TC',0x83A5) +GL_RGBA4_S3TC=_C('GL_RGBA4_S3TC',0x83A3) +GL_RGBA_DXT5_S3TC=_C('GL_RGBA_DXT5_S3TC',0x83A4) +GL_RGBA_S3TC=_C('GL_RGBA_S3TC',0x83A2) +GL_RGB_S3TC=_C('GL_RGB_S3TC',0x83A0) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGI/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGI/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGI/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGI/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGI/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..faa98a7c Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGI/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGI/__pycache__/color_matrix.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGI/__pycache__/color_matrix.cpython-312.pyc new file mode 100644 index 00000000..f9ad90d1 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGI/__pycache__/color_matrix.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGI/__pycache__/color_table.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGI/__pycache__/color_table.cpython-312.pyc new file mode 100644 index 00000000..70326688 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGI/__pycache__/color_table.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGI/__pycache__/texture_color_table.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGI/__pycache__/texture_color_table.cpython-312.pyc new file mode 100644 index 00000000..60c74623 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGI/__pycache__/texture_color_table.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGI/color_matrix.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGI/color_matrix.py new file mode 100644 index 00000000..5e754564 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGI/color_matrix.py @@ -0,0 +1,25 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_SGI_color_matrix' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_SGI_color_matrix',error_checker=_errors._error_checker) +GL_COLOR_MATRIX_SGI=_C('GL_COLOR_MATRIX_SGI',0x80B1) +GL_COLOR_MATRIX_STACK_DEPTH_SGI=_C('GL_COLOR_MATRIX_STACK_DEPTH_SGI',0x80B2) +GL_MAX_COLOR_MATRIX_STACK_DEPTH_SGI=_C('GL_MAX_COLOR_MATRIX_STACK_DEPTH_SGI',0x80B3) +GL_POST_COLOR_MATRIX_ALPHA_BIAS_SGI=_C('GL_POST_COLOR_MATRIX_ALPHA_BIAS_SGI',0x80BB) +GL_POST_COLOR_MATRIX_ALPHA_SCALE_SGI=_C('GL_POST_COLOR_MATRIX_ALPHA_SCALE_SGI',0x80B7) +GL_POST_COLOR_MATRIX_BLUE_BIAS_SGI=_C('GL_POST_COLOR_MATRIX_BLUE_BIAS_SGI',0x80BA) +GL_POST_COLOR_MATRIX_BLUE_SCALE_SGI=_C('GL_POST_COLOR_MATRIX_BLUE_SCALE_SGI',0x80B6) +GL_POST_COLOR_MATRIX_GREEN_BIAS_SGI=_C('GL_POST_COLOR_MATRIX_GREEN_BIAS_SGI',0x80B9) +GL_POST_COLOR_MATRIX_GREEN_SCALE_SGI=_C('GL_POST_COLOR_MATRIX_GREEN_SCALE_SGI',0x80B5) +GL_POST_COLOR_MATRIX_RED_BIAS_SGI=_C('GL_POST_COLOR_MATRIX_RED_BIAS_SGI',0x80B8) +GL_POST_COLOR_MATRIX_RED_SCALE_SGI=_C('GL_POST_COLOR_MATRIX_RED_SCALE_SGI',0x80B4) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGI/color_table.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGI/color_table.py new file mode 100644 index 00000000..da84f239 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGI/color_table.py @@ -0,0 +1,50 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_SGI_color_table' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_SGI_color_table',error_checker=_errors._error_checker) +GL_COLOR_TABLE_ALPHA_SIZE_SGI=_C('GL_COLOR_TABLE_ALPHA_SIZE_SGI',0x80DD) +GL_COLOR_TABLE_BIAS_SGI=_C('GL_COLOR_TABLE_BIAS_SGI',0x80D7) +GL_COLOR_TABLE_BLUE_SIZE_SGI=_C('GL_COLOR_TABLE_BLUE_SIZE_SGI',0x80DC) +GL_COLOR_TABLE_FORMAT_SGI=_C('GL_COLOR_TABLE_FORMAT_SGI',0x80D8) +GL_COLOR_TABLE_GREEN_SIZE_SGI=_C('GL_COLOR_TABLE_GREEN_SIZE_SGI',0x80DB) +GL_COLOR_TABLE_INTENSITY_SIZE_SGI=_C('GL_COLOR_TABLE_INTENSITY_SIZE_SGI',0x80DF) +GL_COLOR_TABLE_LUMINANCE_SIZE_SGI=_C('GL_COLOR_TABLE_LUMINANCE_SIZE_SGI',0x80DE) +GL_COLOR_TABLE_RED_SIZE_SGI=_C('GL_COLOR_TABLE_RED_SIZE_SGI',0x80DA) +GL_COLOR_TABLE_SCALE_SGI=_C('GL_COLOR_TABLE_SCALE_SGI',0x80D6) +GL_COLOR_TABLE_SGI=_C('GL_COLOR_TABLE_SGI',0x80D0) +GL_COLOR_TABLE_WIDTH_SGI=_C('GL_COLOR_TABLE_WIDTH_SGI',0x80D9) +GL_POST_COLOR_MATRIX_COLOR_TABLE_SGI=_C('GL_POST_COLOR_MATRIX_COLOR_TABLE_SGI',0x80D2) +GL_POST_CONVOLUTION_COLOR_TABLE_SGI=_C('GL_POST_CONVOLUTION_COLOR_TABLE_SGI',0x80D1) +GL_PROXY_COLOR_TABLE_SGI=_C('GL_PROXY_COLOR_TABLE_SGI',0x80D3) +GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE_SGI=_C('GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE_SGI',0x80D5) +GL_PROXY_POST_CONVOLUTION_COLOR_TABLE_SGI=_C('GL_PROXY_POST_CONVOLUTION_COLOR_TABLE_SGI',0x80D4) +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLfloatArray) +def glColorTableParameterfvSGI(target,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLintArray) +def glColorTableParameterivSGI(target,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLsizei,_cs.GLenum,_cs.GLenum,ctypes.c_void_p) +def glColorTableSGI(target,internalformat,width,format,type,table):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLint,_cs.GLint,_cs.GLsizei) +def glCopyColorTableSGI(target,internalformat,x,y,width):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLfloatArray) +def glGetColorTableParameterfvSGI(target,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLintArray) +def glGetColorTableParameterivSGI(target,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLenum,ctypes.c_void_p) +def glGetColorTableSGI(target,format,type,table):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGI/texture_color_table.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGI/texture_color_table.py new file mode 100644 index 00000000..eedba4a7 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGI/texture_color_table.py @@ -0,0 +1,16 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_SGI_texture_color_table' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_SGI_texture_color_table',error_checker=_errors._error_checker) +GL_PROXY_TEXTURE_COLOR_TABLE_SGI=_C('GL_PROXY_TEXTURE_COLOR_TABLE_SGI',0x80BD) +GL_TEXTURE_COLOR_TABLE_SGI=_C('GL_TEXTURE_COLOR_TABLE_SGI',0x80BC) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIS/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIS/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIS/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIS/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIS/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..db8260a2 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIS/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIS/__pycache__/detail_texture.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIS/__pycache__/detail_texture.cpython-312.pyc new file mode 100644 index 00000000..46348df2 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIS/__pycache__/detail_texture.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIS/__pycache__/fog_function.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIS/__pycache__/fog_function.cpython-312.pyc new file mode 100644 index 00000000..9fd2503f Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIS/__pycache__/fog_function.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIS/__pycache__/generate_mipmap.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIS/__pycache__/generate_mipmap.cpython-312.pyc new file mode 100644 index 00000000..b0f6221b Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIS/__pycache__/generate_mipmap.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIS/__pycache__/multisample.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIS/__pycache__/multisample.cpython-312.pyc new file mode 100644 index 00000000..e201a32d Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIS/__pycache__/multisample.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIS/__pycache__/pixel_texture.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIS/__pycache__/pixel_texture.cpython-312.pyc new file mode 100644 index 00000000..20aa9245 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIS/__pycache__/pixel_texture.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIS/__pycache__/point_line_texgen.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIS/__pycache__/point_line_texgen.cpython-312.pyc new file mode 100644 index 00000000..ee1b4eba Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIS/__pycache__/point_line_texgen.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIS/__pycache__/point_parameters.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIS/__pycache__/point_parameters.cpython-312.pyc new file mode 100644 index 00000000..c3703ad3 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIS/__pycache__/point_parameters.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIS/__pycache__/sharpen_texture.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIS/__pycache__/sharpen_texture.cpython-312.pyc new file mode 100644 index 00000000..a5c047c8 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIS/__pycache__/sharpen_texture.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIS/__pycache__/texture4D.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIS/__pycache__/texture4D.cpython-312.pyc new file mode 100644 index 00000000..36405888 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIS/__pycache__/texture4D.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIS/__pycache__/texture_border_clamp.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIS/__pycache__/texture_border_clamp.cpython-312.pyc new file mode 100644 index 00000000..4c8c65ba Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIS/__pycache__/texture_border_clamp.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIS/__pycache__/texture_color_mask.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIS/__pycache__/texture_color_mask.cpython-312.pyc new file mode 100644 index 00000000..6f11e33f Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIS/__pycache__/texture_color_mask.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIS/__pycache__/texture_edge_clamp.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIS/__pycache__/texture_edge_clamp.cpython-312.pyc new file mode 100644 index 00000000..ae76e807 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIS/__pycache__/texture_edge_clamp.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIS/__pycache__/texture_filter4.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIS/__pycache__/texture_filter4.cpython-312.pyc new file mode 100644 index 00000000..21ca9c41 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIS/__pycache__/texture_filter4.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIS/__pycache__/texture_lod.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIS/__pycache__/texture_lod.cpython-312.pyc new file mode 100644 index 00000000..7b8d0a16 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIS/__pycache__/texture_lod.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIS/__pycache__/texture_select.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIS/__pycache__/texture_select.cpython-312.pyc new file mode 100644 index 00000000..93dd6d8b Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIS/__pycache__/texture_select.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIS/detail_texture.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIS/detail_texture.py new file mode 100644 index 00000000..66c25aec --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIS/detail_texture.py @@ -0,0 +1,27 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_SGIS_detail_texture' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_SGIS_detail_texture',error_checker=_errors._error_checker) +GL_DETAIL_TEXTURE_2D_BINDING_SGIS=_C('GL_DETAIL_TEXTURE_2D_BINDING_SGIS',0x8096) +GL_DETAIL_TEXTURE_2D_SGIS=_C('GL_DETAIL_TEXTURE_2D_SGIS',0x8095) +GL_DETAIL_TEXTURE_FUNC_POINTS_SGIS=_C('GL_DETAIL_TEXTURE_FUNC_POINTS_SGIS',0x809C) +GL_DETAIL_TEXTURE_LEVEL_SGIS=_C('GL_DETAIL_TEXTURE_LEVEL_SGIS',0x809A) +GL_DETAIL_TEXTURE_MODE_SGIS=_C('GL_DETAIL_TEXTURE_MODE_SGIS',0x809B) +GL_LINEAR_DETAIL_ALPHA_SGIS=_C('GL_LINEAR_DETAIL_ALPHA_SGIS',0x8098) +GL_LINEAR_DETAIL_COLOR_SGIS=_C('GL_LINEAR_DETAIL_COLOR_SGIS',0x8099) +GL_LINEAR_DETAIL_SGIS=_C('GL_LINEAR_DETAIL_SGIS',0x8097) +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizei,arrays.GLfloatArray) +def glDetailTexFuncSGIS(target,n,points):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLfloatArray) +def glGetDetailTexFuncSGIS(target,points):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIS/fog_function.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIS/fog_function.py new file mode 100644 index 00000000..d8c6708c --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIS/fog_function.py @@ -0,0 +1,22 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_SGIS_fog_function' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_SGIS_fog_function',error_checker=_errors._error_checker) +GL_FOG_FUNC_POINTS_SGIS=_C('GL_FOG_FUNC_POINTS_SGIS',0x812B) +GL_FOG_FUNC_SGIS=_C('GL_FOG_FUNC_SGIS',0x812A) +GL_MAX_FOG_FUNC_POINTS_SGIS=_C('GL_MAX_FOG_FUNC_POINTS_SGIS',0x812C) +@_f +@_p.types(None,_cs.GLsizei,arrays.GLfloatArray) +def glFogFuncSGIS(n,points):pass +@_f +@_p.types(None,arrays.GLfloatArray) +def glGetFogFuncSGIS(points):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIS/generate_mipmap.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIS/generate_mipmap.py new file mode 100644 index 00000000..3615c959 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIS/generate_mipmap.py @@ -0,0 +1,16 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_SGIS_generate_mipmap' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_SGIS_generate_mipmap',error_checker=_errors._error_checker) +GL_GENERATE_MIPMAP_HINT_SGIS=_C('GL_GENERATE_MIPMAP_HINT_SGIS',0x8192) +GL_GENERATE_MIPMAP_SGIS=_C('GL_GENERATE_MIPMAP_SGIS',0x8191) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIS/multisample.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIS/multisample.py new file mode 100644 index 00000000..4443c2c8 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIS/multisample.py @@ -0,0 +1,35 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_SGIS_multisample' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_SGIS_multisample',error_checker=_errors._error_checker) +GL_1PASS_SGIS=_C('GL_1PASS_SGIS',0x80A1) +GL_2PASS_0_SGIS=_C('GL_2PASS_0_SGIS',0x80A2) +GL_2PASS_1_SGIS=_C('GL_2PASS_1_SGIS',0x80A3) +GL_4PASS_0_SGIS=_C('GL_4PASS_0_SGIS',0x80A4) +GL_4PASS_1_SGIS=_C('GL_4PASS_1_SGIS',0x80A5) +GL_4PASS_2_SGIS=_C('GL_4PASS_2_SGIS',0x80A6) +GL_4PASS_3_SGIS=_C('GL_4PASS_3_SGIS',0x80A7) +GL_MULTISAMPLE_SGIS=_C('GL_MULTISAMPLE_SGIS',0x809D) +GL_SAMPLES_SGIS=_C('GL_SAMPLES_SGIS',0x80A9) +GL_SAMPLE_ALPHA_TO_MASK_SGIS=_C('GL_SAMPLE_ALPHA_TO_MASK_SGIS',0x809E) +GL_SAMPLE_ALPHA_TO_ONE_SGIS=_C('GL_SAMPLE_ALPHA_TO_ONE_SGIS',0x809F) +GL_SAMPLE_BUFFERS_SGIS=_C('GL_SAMPLE_BUFFERS_SGIS',0x80A8) +GL_SAMPLE_MASK_INVERT_SGIS=_C('GL_SAMPLE_MASK_INVERT_SGIS',0x80AB) +GL_SAMPLE_MASK_SGIS=_C('GL_SAMPLE_MASK_SGIS',0x80A0) +GL_SAMPLE_MASK_VALUE_SGIS=_C('GL_SAMPLE_MASK_VALUE_SGIS',0x80AA) +GL_SAMPLE_PATTERN_SGIS=_C('GL_SAMPLE_PATTERN_SGIS',0x80AC) +@_f +@_p.types(None,_cs.GLclampf,_cs.GLboolean) +def glSampleMaskSGIS(value,invert):pass +@_f +@_p.types(None,_cs.GLenum) +def glSamplePatternSGIS(pattern):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIS/pixel_texture.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIS/pixel_texture.py new file mode 100644 index 00000000..79a4871f --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIS/pixel_texture.py @@ -0,0 +1,35 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_SGIS_pixel_texture' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_SGIS_pixel_texture',error_checker=_errors._error_checker) +GL_PIXEL_FRAGMENT_ALPHA_SOURCE_SGIS=_C('GL_PIXEL_FRAGMENT_ALPHA_SOURCE_SGIS',0x8355) +GL_PIXEL_FRAGMENT_RGB_SOURCE_SGIS=_C('GL_PIXEL_FRAGMENT_RGB_SOURCE_SGIS',0x8354) +GL_PIXEL_GROUP_COLOR_SGIS=_C('GL_PIXEL_GROUP_COLOR_SGIS',0x8356) +GL_PIXEL_TEXTURE_SGIS=_C('GL_PIXEL_TEXTURE_SGIS',0x8353) +@_f +@_p.types(None,_cs.GLenum,arrays.GLfloatArray) +def glGetPixelTexGenParameterfvSGIS(pname,params):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLintArray) +def glGetPixelTexGenParameterivSGIS(pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLfloat) +def glPixelTexGenParameterfSGIS(pname,param):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLfloatArray) +def glPixelTexGenParameterfvSGIS(pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLint) +def glPixelTexGenParameteriSGIS(pname,param):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLintArray) +def glPixelTexGenParameterivSGIS(pname,params):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIS/point_line_texgen.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIS/point_line_texgen.py new file mode 100644 index 00000000..92f000fb --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIS/point_line_texgen.py @@ -0,0 +1,22 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_SGIS_point_line_texgen' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_SGIS_point_line_texgen',error_checker=_errors._error_checker) +GL_EYE_DISTANCE_TO_LINE_SGIS=_C('GL_EYE_DISTANCE_TO_LINE_SGIS',0x81F2) +GL_EYE_DISTANCE_TO_POINT_SGIS=_C('GL_EYE_DISTANCE_TO_POINT_SGIS',0x81F0) +GL_EYE_LINE_SGIS=_C('GL_EYE_LINE_SGIS',0x81F6) +GL_EYE_POINT_SGIS=_C('GL_EYE_POINT_SGIS',0x81F4) +GL_OBJECT_DISTANCE_TO_LINE_SGIS=_C('GL_OBJECT_DISTANCE_TO_LINE_SGIS',0x81F3) +GL_OBJECT_DISTANCE_TO_POINT_SGIS=_C('GL_OBJECT_DISTANCE_TO_POINT_SGIS',0x81F1) +GL_OBJECT_LINE_SGIS=_C('GL_OBJECT_LINE_SGIS',0x81F7) +GL_OBJECT_POINT_SGIS=_C('GL_OBJECT_POINT_SGIS',0x81F5) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIS/point_parameters.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIS/point_parameters.py new file mode 100644 index 00000000..724d6edb --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIS/point_parameters.py @@ -0,0 +1,23 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_SGIS_point_parameters' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_SGIS_point_parameters',error_checker=_errors._error_checker) +GL_DISTANCE_ATTENUATION_SGIS=_C('GL_DISTANCE_ATTENUATION_SGIS',0x8129) +GL_POINT_FADE_THRESHOLD_SIZE_SGIS=_C('GL_POINT_FADE_THRESHOLD_SIZE_SGIS',0x8128) +GL_POINT_SIZE_MAX_SGIS=_C('GL_POINT_SIZE_MAX_SGIS',0x8127) +GL_POINT_SIZE_MIN_SGIS=_C('GL_POINT_SIZE_MIN_SGIS',0x8126) +@_f +@_p.types(None,_cs.GLenum,_cs.GLfloat) +def glPointParameterfSGIS(pname,param):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLfloatArray) +def glPointParameterfvSGIS(pname,params):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIS/sharpen_texture.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIS/sharpen_texture.py new file mode 100644 index 00000000..3bd6354b --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIS/sharpen_texture.py @@ -0,0 +1,23 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_SGIS_sharpen_texture' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_SGIS_sharpen_texture',error_checker=_errors._error_checker) +GL_LINEAR_SHARPEN_ALPHA_SGIS=_C('GL_LINEAR_SHARPEN_ALPHA_SGIS',0x80AE) +GL_LINEAR_SHARPEN_COLOR_SGIS=_C('GL_LINEAR_SHARPEN_COLOR_SGIS',0x80AF) +GL_LINEAR_SHARPEN_SGIS=_C('GL_LINEAR_SHARPEN_SGIS',0x80AD) +GL_SHARPEN_TEXTURE_FUNC_POINTS_SGIS=_C('GL_SHARPEN_TEXTURE_FUNC_POINTS_SGIS',0x80B0) +@_f +@_p.types(None,_cs.GLenum,arrays.GLfloatArray) +def glGetSharpenTexFuncSGIS(target,points):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizei,arrays.GLfloatArray) +def glSharpenTexFuncSGIS(target,n,points):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIS/texture4D.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIS/texture4D.py new file mode 100644 index 00000000..22c33b38 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIS/texture4D.py @@ -0,0 +1,29 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_SGIS_texture4D' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_SGIS_texture4D',error_checker=_errors._error_checker) +GL_MAX_4D_TEXTURE_SIZE_SGIS=_C('GL_MAX_4D_TEXTURE_SIZE_SGIS',0x8138) +GL_PACK_IMAGE_DEPTH_SGIS=_C('GL_PACK_IMAGE_DEPTH_SGIS',0x8131) +GL_PACK_SKIP_VOLUMES_SGIS=_C('GL_PACK_SKIP_VOLUMES_SGIS',0x8130) +GL_PROXY_TEXTURE_4D_SGIS=_C('GL_PROXY_TEXTURE_4D_SGIS',0x8135) +GL_TEXTURE_4DSIZE_SGIS=_C('GL_TEXTURE_4DSIZE_SGIS',0x8136) +GL_TEXTURE_4D_BINDING_SGIS=_C('GL_TEXTURE_4D_BINDING_SGIS',0x814F) +GL_TEXTURE_4D_SGIS=_C('GL_TEXTURE_4D_SGIS',0x8134) +GL_TEXTURE_WRAP_Q_SGIS=_C('GL_TEXTURE_WRAP_Q_SGIS',0x8137) +GL_UNPACK_IMAGE_DEPTH_SGIS=_C('GL_UNPACK_IMAGE_DEPTH_SGIS',0x8133) +GL_UNPACK_SKIP_VOLUMES_SGIS=_C('GL_UNPACK_SKIP_VOLUMES_SGIS',0x8132) +@_f +@_p.types(None,_cs.GLenum,_cs.GLint,_cs.GLenum,_cs.GLsizei,_cs.GLsizei,_cs.GLsizei,_cs.GLsizei,_cs.GLint,_cs.GLenum,_cs.GLenum,ctypes.c_void_p) +def glTexImage4DSGIS(target,level,internalformat,width,height,depth,size4d,border,format,type,pixels):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLsizei,_cs.GLsizei,_cs.GLsizei,_cs.GLenum,_cs.GLenum,ctypes.c_void_p) +def glTexSubImage4DSGIS(target,level,xoffset,yoffset,zoffset,woffset,width,height,depth,size4d,format,type,pixels):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIS/texture_border_clamp.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIS/texture_border_clamp.py new file mode 100644 index 00000000..f55884f9 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIS/texture_border_clamp.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_SGIS_texture_border_clamp' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_SGIS_texture_border_clamp',error_checker=_errors._error_checker) +GL_CLAMP_TO_BORDER_SGIS=_C('GL_CLAMP_TO_BORDER_SGIS',0x812D) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIS/texture_color_mask.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIS/texture_color_mask.py new file mode 100644 index 00000000..af637d22 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIS/texture_color_mask.py @@ -0,0 +1,17 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_SGIS_texture_color_mask' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_SGIS_texture_color_mask',error_checker=_errors._error_checker) +GL_TEXTURE_COLOR_WRITEMASK_SGIS=_C('GL_TEXTURE_COLOR_WRITEMASK_SGIS',0x81EF) +@_f +@_p.types(None,_cs.GLboolean,_cs.GLboolean,_cs.GLboolean,_cs.GLboolean) +def glTextureColorMaskSGIS(red,green,blue,alpha):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIS/texture_edge_clamp.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIS/texture_edge_clamp.py new file mode 100644 index 00000000..126c9d2a --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIS/texture_edge_clamp.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_SGIS_texture_edge_clamp' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_SGIS_texture_edge_clamp',error_checker=_errors._error_checker) +GL_CLAMP_TO_EDGE_SGIS=_C('GL_CLAMP_TO_EDGE_SGIS',0x812F) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIS/texture_filter4.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIS/texture_filter4.py new file mode 100644 index 00000000..fa735bad --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIS/texture_filter4.py @@ -0,0 +1,21 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_SGIS_texture_filter4' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_SGIS_texture_filter4',error_checker=_errors._error_checker) +GL_FILTER4_SGIS=_C('GL_FILTER4_SGIS',0x8146) +GL_TEXTURE_FILTER4_SIZE_SGIS=_C('GL_TEXTURE_FILTER4_SIZE_SGIS',0x8147) +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLfloatArray) +def glGetTexFilterFuncSGIS(target,filter,weights):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLsizei,arrays.GLfloatArray) +def glTexFilterFuncSGIS(target,filter,n,weights):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIS/texture_lod.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIS/texture_lod.py new file mode 100644 index 00000000..aafa77f6 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIS/texture_lod.py @@ -0,0 +1,18 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_SGIS_texture_lod' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_SGIS_texture_lod',error_checker=_errors._error_checker) +GL_TEXTURE_BASE_LEVEL_SGIS=_C('GL_TEXTURE_BASE_LEVEL_SGIS',0x813C) +GL_TEXTURE_MAX_LEVEL_SGIS=_C('GL_TEXTURE_MAX_LEVEL_SGIS',0x813D) +GL_TEXTURE_MAX_LOD_SGIS=_C('GL_TEXTURE_MAX_LOD_SGIS',0x813B) +GL_TEXTURE_MIN_LOD_SGIS=_C('GL_TEXTURE_MIN_LOD_SGIS',0x813A) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIS/texture_select.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIS/texture_select.py new file mode 100644 index 00000000..349d66a2 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIS/texture_select.py @@ -0,0 +1,36 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_SGIS_texture_select' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_SGIS_texture_select',error_checker=_errors._error_checker) +GL_DUAL_ALPHA12_SGIS=_C('GL_DUAL_ALPHA12_SGIS',0x8112) +GL_DUAL_ALPHA16_SGIS=_C('GL_DUAL_ALPHA16_SGIS',0x8113) +GL_DUAL_ALPHA4_SGIS=_C('GL_DUAL_ALPHA4_SGIS',0x8110) +GL_DUAL_ALPHA8_SGIS=_C('GL_DUAL_ALPHA8_SGIS',0x8111) +GL_DUAL_INTENSITY12_SGIS=_C('GL_DUAL_INTENSITY12_SGIS',0x811A) +GL_DUAL_INTENSITY16_SGIS=_C('GL_DUAL_INTENSITY16_SGIS',0x811B) +GL_DUAL_INTENSITY4_SGIS=_C('GL_DUAL_INTENSITY4_SGIS',0x8118) +GL_DUAL_INTENSITY8_SGIS=_C('GL_DUAL_INTENSITY8_SGIS',0x8119) +GL_DUAL_LUMINANCE12_SGIS=_C('GL_DUAL_LUMINANCE12_SGIS',0x8116) +GL_DUAL_LUMINANCE16_SGIS=_C('GL_DUAL_LUMINANCE16_SGIS',0x8117) +GL_DUAL_LUMINANCE4_SGIS=_C('GL_DUAL_LUMINANCE4_SGIS',0x8114) +GL_DUAL_LUMINANCE8_SGIS=_C('GL_DUAL_LUMINANCE8_SGIS',0x8115) +GL_DUAL_LUMINANCE_ALPHA4_SGIS=_C('GL_DUAL_LUMINANCE_ALPHA4_SGIS',0x811C) +GL_DUAL_LUMINANCE_ALPHA8_SGIS=_C('GL_DUAL_LUMINANCE_ALPHA8_SGIS',0x811D) +GL_DUAL_TEXTURE_SELECT_SGIS=_C('GL_DUAL_TEXTURE_SELECT_SGIS',0x8124) +GL_QUAD_ALPHA4_SGIS=_C('GL_QUAD_ALPHA4_SGIS',0x811E) +GL_QUAD_ALPHA8_SGIS=_C('GL_QUAD_ALPHA8_SGIS',0x811F) +GL_QUAD_INTENSITY4_SGIS=_C('GL_QUAD_INTENSITY4_SGIS',0x8122) +GL_QUAD_INTENSITY8_SGIS=_C('GL_QUAD_INTENSITY8_SGIS',0x8123) +GL_QUAD_LUMINANCE4_SGIS=_C('GL_QUAD_LUMINANCE4_SGIS',0x8120) +GL_QUAD_LUMINANCE8_SGIS=_C('GL_QUAD_LUMINANCE8_SGIS',0x8121) +GL_QUAD_TEXTURE_SELECT_SGIS=_C('GL_QUAD_TEXTURE_SELECT_SGIS',0x8125) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..5bd319bd Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/__pycache__/async_.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/__pycache__/async_.cpython-312.pyc new file mode 100644 index 00000000..d9de3c1f Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/__pycache__/async_.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/__pycache__/async_histogram.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/__pycache__/async_histogram.cpython-312.pyc new file mode 100644 index 00000000..1700271d Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/__pycache__/async_histogram.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/__pycache__/async_pixel.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/__pycache__/async_pixel.cpython-312.pyc new file mode 100644 index 00000000..94f91ac7 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/__pycache__/async_pixel.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/__pycache__/blend_alpha_minmax.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/__pycache__/blend_alpha_minmax.cpython-312.pyc new file mode 100644 index 00000000..ad758c16 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/__pycache__/blend_alpha_minmax.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/__pycache__/calligraphic_fragment.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/__pycache__/calligraphic_fragment.cpython-312.pyc new file mode 100644 index 00000000..96ba5d14 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/__pycache__/calligraphic_fragment.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/__pycache__/clipmap.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/__pycache__/clipmap.cpython-312.pyc new file mode 100644 index 00000000..9239bf5b Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/__pycache__/clipmap.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/__pycache__/convolution_accuracy.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/__pycache__/convolution_accuracy.cpython-312.pyc new file mode 100644 index 00000000..83ef0955 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/__pycache__/convolution_accuracy.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/__pycache__/depth_pass_instrument.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/__pycache__/depth_pass_instrument.cpython-312.pyc new file mode 100644 index 00000000..c0a10611 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/__pycache__/depth_pass_instrument.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/__pycache__/depth_texture.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/__pycache__/depth_texture.cpython-312.pyc new file mode 100644 index 00000000..4d8fd556 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/__pycache__/depth_texture.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/__pycache__/flush_raster.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/__pycache__/flush_raster.cpython-312.pyc new file mode 100644 index 00000000..731760f4 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/__pycache__/flush_raster.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/__pycache__/fog_offset.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/__pycache__/fog_offset.cpython-312.pyc new file mode 100644 index 00000000..b76b7101 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/__pycache__/fog_offset.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/__pycache__/fragment_lighting.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/__pycache__/fragment_lighting.cpython-312.pyc new file mode 100644 index 00000000..a8f82a0b Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/__pycache__/fragment_lighting.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/__pycache__/framezoom.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/__pycache__/framezoom.cpython-312.pyc new file mode 100644 index 00000000..ecc5d14a Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/__pycache__/framezoom.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/__pycache__/igloo_interface.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/__pycache__/igloo_interface.cpython-312.pyc new file mode 100644 index 00000000..23ae2fca Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/__pycache__/igloo_interface.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/__pycache__/instruments.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/__pycache__/instruments.cpython-312.pyc new file mode 100644 index 00000000..753b3d40 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/__pycache__/instruments.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/__pycache__/interlace.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/__pycache__/interlace.cpython-312.pyc new file mode 100644 index 00000000..2e0c75d4 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/__pycache__/interlace.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/__pycache__/ir_instrument1.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/__pycache__/ir_instrument1.cpython-312.pyc new file mode 100644 index 00000000..44fffd31 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/__pycache__/ir_instrument1.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/__pycache__/list_priority.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/__pycache__/list_priority.cpython-312.pyc new file mode 100644 index 00000000..02a6c3fe Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/__pycache__/list_priority.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/__pycache__/pixel_texture.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/__pycache__/pixel_texture.cpython-312.pyc new file mode 100644 index 00000000..ae22f10b Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/__pycache__/pixel_texture.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/__pycache__/pixel_tiles.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/__pycache__/pixel_tiles.cpython-312.pyc new file mode 100644 index 00000000..0a8d3a7c Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/__pycache__/pixel_tiles.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/__pycache__/polynomial_ffd.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/__pycache__/polynomial_ffd.cpython-312.pyc new file mode 100644 index 00000000..e489eda8 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/__pycache__/polynomial_ffd.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/__pycache__/reference_plane.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/__pycache__/reference_plane.cpython-312.pyc new file mode 100644 index 00000000..8b538aba Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/__pycache__/reference_plane.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/__pycache__/resample.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/__pycache__/resample.cpython-312.pyc new file mode 100644 index 00000000..7dfe1cc3 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/__pycache__/resample.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/__pycache__/scalebias_hint.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/__pycache__/scalebias_hint.cpython-312.pyc new file mode 100644 index 00000000..559b2ad0 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/__pycache__/scalebias_hint.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/__pycache__/shadow.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/__pycache__/shadow.cpython-312.pyc new file mode 100644 index 00000000..f5e3a8d4 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/__pycache__/shadow.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/__pycache__/shadow_ambient.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/__pycache__/shadow_ambient.cpython-312.pyc new file mode 100644 index 00000000..73de4bf2 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/__pycache__/shadow_ambient.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/__pycache__/sprite.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/__pycache__/sprite.cpython-312.pyc new file mode 100644 index 00000000..74144c41 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/__pycache__/sprite.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/__pycache__/subsample.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/__pycache__/subsample.cpython-312.pyc new file mode 100644 index 00000000..79b052e0 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/__pycache__/subsample.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/__pycache__/tag_sample_buffer.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/__pycache__/tag_sample_buffer.cpython-312.pyc new file mode 100644 index 00000000..7df67595 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/__pycache__/tag_sample_buffer.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/__pycache__/texture_add_env.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/__pycache__/texture_add_env.cpython-312.pyc new file mode 100644 index 00000000..1884ca72 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/__pycache__/texture_add_env.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/__pycache__/texture_coordinate_clamp.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/__pycache__/texture_coordinate_clamp.cpython-312.pyc new file mode 100644 index 00000000..67337431 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/__pycache__/texture_coordinate_clamp.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/__pycache__/texture_lod_bias.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/__pycache__/texture_lod_bias.cpython-312.pyc new file mode 100644 index 00000000..6d51bf43 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/__pycache__/texture_lod_bias.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/__pycache__/texture_multi_buffer.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/__pycache__/texture_multi_buffer.cpython-312.pyc new file mode 100644 index 00000000..3134f473 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/__pycache__/texture_multi_buffer.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/__pycache__/texture_scale_bias.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/__pycache__/texture_scale_bias.cpython-312.pyc new file mode 100644 index 00000000..0d0c4c8f Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/__pycache__/texture_scale_bias.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/__pycache__/vertex_preclip.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/__pycache__/vertex_preclip.cpython-312.pyc new file mode 100644 index 00000000..2a599fcb Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/__pycache__/vertex_preclip.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/__pycache__/ycrcb.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/__pycache__/ycrcb.cpython-312.pyc new file mode 100644 index 00000000..f3300ebc Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/__pycache__/ycrcb.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/__pycache__/ycrcb_subsample.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/__pycache__/ycrcb_subsample.cpython-312.pyc new file mode 100644 index 00000000..a77fcbef Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/__pycache__/ycrcb_subsample.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/__pycache__/ycrcba.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/__pycache__/ycrcba.cpython-312.pyc new file mode 100644 index 00000000..414243dd Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/__pycache__/ycrcba.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/async_.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/async_.py new file mode 100644 index 00000000..70dae12e --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/async_.py @@ -0,0 +1,32 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_SGIX_async_' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_SGIX_async_',error_checker=_errors._error_checker) +GL_ASYNC_MARKER_SGIX=_C('GL_ASYNC_MARKER_SGIX',0x8329) +@_f +@_p.types(None,_cs.GLuint) +def glAsyncMarkerSGIX(marker):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizei) +def glDeleteAsyncMarkersSGIX(marker,range):pass +@_f +@_p.types(_cs.GLint,arrays.GLuintArray) +def glFinishAsyncSGIX(markerp):pass +@_f +@_p.types(_cs.GLuint,_cs.GLsizei) +def glGenAsyncMarkersSGIX(range):pass +@_f +@_p.types(_cs.GLboolean,_cs.GLuint) +def glIsAsyncMarkerSGIX(marker):pass +@_f +@_p.types(_cs.GLint,arrays.GLuintArray) +def glPollAsyncSGIX(markerp):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/async_histogram.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/async_histogram.py new file mode 100644 index 00000000..26067dd5 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/async_histogram.py @@ -0,0 +1,16 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_SGIX_async_histogram' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_SGIX_async_histogram',error_checker=_errors._error_checker) +GL_ASYNC_HISTOGRAM_SGIX=_C('GL_ASYNC_HISTOGRAM_SGIX',0x832C) +GL_MAX_ASYNC_HISTOGRAM_SGIX=_C('GL_MAX_ASYNC_HISTOGRAM_SGIX',0x832D) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/async_pixel.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/async_pixel.py new file mode 100644 index 00000000..730fd859 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/async_pixel.py @@ -0,0 +1,20 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_SGIX_async_pixel' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_SGIX_async_pixel',error_checker=_errors._error_checker) +GL_ASYNC_DRAW_PIXELS_SGIX=_C('GL_ASYNC_DRAW_PIXELS_SGIX',0x835D) +GL_ASYNC_READ_PIXELS_SGIX=_C('GL_ASYNC_READ_PIXELS_SGIX',0x835E) +GL_ASYNC_TEX_IMAGE_SGIX=_C('GL_ASYNC_TEX_IMAGE_SGIX',0x835C) +GL_MAX_ASYNC_DRAW_PIXELS_SGIX=_C('GL_MAX_ASYNC_DRAW_PIXELS_SGIX',0x8360) +GL_MAX_ASYNC_READ_PIXELS_SGIX=_C('GL_MAX_ASYNC_READ_PIXELS_SGIX',0x8361) +GL_MAX_ASYNC_TEX_IMAGE_SGIX=_C('GL_MAX_ASYNC_TEX_IMAGE_SGIX',0x835F) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/blend_alpha_minmax.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/blend_alpha_minmax.py new file mode 100644 index 00000000..03ebb3d9 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/blend_alpha_minmax.py @@ -0,0 +1,16 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_SGIX_blend_alpha_minmax' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_SGIX_blend_alpha_minmax',error_checker=_errors._error_checker) +GL_ALPHA_MAX_SGIX=_C('GL_ALPHA_MAX_SGIX',0x8321) +GL_ALPHA_MIN_SGIX=_C('GL_ALPHA_MIN_SGIX',0x8320) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/calligraphic_fragment.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/calligraphic_fragment.py new file mode 100644 index 00000000..025a3970 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/calligraphic_fragment.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_SGIX_calligraphic_fragment' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_SGIX_calligraphic_fragment',error_checker=_errors._error_checker) +GL_CALLIGRAPHIC_FRAGMENT_SGIX=_C('GL_CALLIGRAPHIC_FRAGMENT_SGIX',0x8183) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/clipmap.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/clipmap.py new file mode 100644 index 00000000..93dfe195 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/clipmap.py @@ -0,0 +1,26 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_SGIX_clipmap' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_SGIX_clipmap',error_checker=_errors._error_checker) +GL_LINEAR_CLIPMAP_LINEAR_SGIX=_C('GL_LINEAR_CLIPMAP_LINEAR_SGIX',0x8170) +GL_LINEAR_CLIPMAP_NEAREST_SGIX=_C('GL_LINEAR_CLIPMAP_NEAREST_SGIX',0x844F) +GL_MAX_CLIPMAP_DEPTH_SGIX=_C('GL_MAX_CLIPMAP_DEPTH_SGIX',0x8177) +GL_MAX_CLIPMAP_VIRTUAL_DEPTH_SGIX=_C('GL_MAX_CLIPMAP_VIRTUAL_DEPTH_SGIX',0x8178) +GL_NEAREST_CLIPMAP_LINEAR_SGIX=_C('GL_NEAREST_CLIPMAP_LINEAR_SGIX',0x844E) +GL_NEAREST_CLIPMAP_NEAREST_SGIX=_C('GL_NEAREST_CLIPMAP_NEAREST_SGIX',0x844D) +GL_TEXTURE_CLIPMAP_CENTER_SGIX=_C('GL_TEXTURE_CLIPMAP_CENTER_SGIX',0x8171) +GL_TEXTURE_CLIPMAP_DEPTH_SGIX=_C('GL_TEXTURE_CLIPMAP_DEPTH_SGIX',0x8176) +GL_TEXTURE_CLIPMAP_FRAME_SGIX=_C('GL_TEXTURE_CLIPMAP_FRAME_SGIX',0x8172) +GL_TEXTURE_CLIPMAP_LOD_OFFSET_SGIX=_C('GL_TEXTURE_CLIPMAP_LOD_OFFSET_SGIX',0x8175) +GL_TEXTURE_CLIPMAP_OFFSET_SGIX=_C('GL_TEXTURE_CLIPMAP_OFFSET_SGIX',0x8173) +GL_TEXTURE_CLIPMAP_VIRTUAL_DEPTH_SGIX=_C('GL_TEXTURE_CLIPMAP_VIRTUAL_DEPTH_SGIX',0x8174) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/convolution_accuracy.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/convolution_accuracy.py new file mode 100644 index 00000000..2b5d56d6 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/convolution_accuracy.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_SGIX_convolution_accuracy' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_SGIX_convolution_accuracy',error_checker=_errors._error_checker) +GL_CONVOLUTION_HINT_SGIX=_C('GL_CONVOLUTION_HINT_SGIX',0x8316) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/depth_pass_instrument.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/depth_pass_instrument.py new file mode 100644 index 00000000..aa688e4f --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/depth_pass_instrument.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_SGIX_depth_pass_instrument' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_SGIX_depth_pass_instrument',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/depth_texture.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/depth_texture.py new file mode 100644 index 00000000..8be34d4d --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/depth_texture.py @@ -0,0 +1,17 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_SGIX_depth_texture' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_SGIX_depth_texture',error_checker=_errors._error_checker) +GL_DEPTH_COMPONENT16_SGIX=_C('GL_DEPTH_COMPONENT16_SGIX',0x81A5) +GL_DEPTH_COMPONENT24_SGIX=_C('GL_DEPTH_COMPONENT24_SGIX',0x81A6) +GL_DEPTH_COMPONENT32_SGIX=_C('GL_DEPTH_COMPONENT32_SGIX',0x81A7) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/flush_raster.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/flush_raster.py new file mode 100644 index 00000000..5dc8ac64 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/flush_raster.py @@ -0,0 +1,17 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_SGIX_flush_raster' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_SGIX_flush_raster',error_checker=_errors._error_checker) + +@_f +@_p.types(None,) +def glFlushRasterSGIX():pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/fog_offset.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/fog_offset.py new file mode 100644 index 00000000..ae163d61 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/fog_offset.py @@ -0,0 +1,16 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_SGIX_fog_offset' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_SGIX_fog_offset',error_checker=_errors._error_checker) +GL_FOG_OFFSET_SGIX=_C('GL_FOG_OFFSET_SGIX',0x8198) +GL_FOG_OFFSET_VALUE_SGIX=_C('GL_FOG_OFFSET_VALUE_SGIX',0x8199) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/fragment_lighting.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/fragment_lighting.py new file mode 100644 index 00000000..1f65f092 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/fragment_lighting.py @@ -0,0 +1,87 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_SGIX_fragment_lighting' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_SGIX_fragment_lighting',error_checker=_errors._error_checker) +GL_CURRENT_RASTER_NORMAL_SGIX=_C('GL_CURRENT_RASTER_NORMAL_SGIX',0x8406) +GL_FRAGMENT_COLOR_MATERIAL_FACE_SGIX=_C('GL_FRAGMENT_COLOR_MATERIAL_FACE_SGIX',0x8402) +GL_FRAGMENT_COLOR_MATERIAL_PARAMETER_SGIX=_C('GL_FRAGMENT_COLOR_MATERIAL_PARAMETER_SGIX',0x8403) +GL_FRAGMENT_COLOR_MATERIAL_SGIX=_C('GL_FRAGMENT_COLOR_MATERIAL_SGIX',0x8401) +GL_FRAGMENT_LIGHT0_SGIX=_C('GL_FRAGMENT_LIGHT0_SGIX',0x840C) +GL_FRAGMENT_LIGHT1_SGIX=_C('GL_FRAGMENT_LIGHT1_SGIX',0x840D) +GL_FRAGMENT_LIGHT2_SGIX=_C('GL_FRAGMENT_LIGHT2_SGIX',0x840E) +GL_FRAGMENT_LIGHT3_SGIX=_C('GL_FRAGMENT_LIGHT3_SGIX',0x840F) +GL_FRAGMENT_LIGHT4_SGIX=_C('GL_FRAGMENT_LIGHT4_SGIX',0x8410) +GL_FRAGMENT_LIGHT5_SGIX=_C('GL_FRAGMENT_LIGHT5_SGIX',0x8411) +GL_FRAGMENT_LIGHT6_SGIX=_C('GL_FRAGMENT_LIGHT6_SGIX',0x8412) +GL_FRAGMENT_LIGHT7_SGIX=_C('GL_FRAGMENT_LIGHT7_SGIX',0x8413) +GL_FRAGMENT_LIGHTING_SGIX=_C('GL_FRAGMENT_LIGHTING_SGIX',0x8400) +GL_FRAGMENT_LIGHT_MODEL_AMBIENT_SGIX=_C('GL_FRAGMENT_LIGHT_MODEL_AMBIENT_SGIX',0x840A) +GL_FRAGMENT_LIGHT_MODEL_LOCAL_VIEWER_SGIX=_C('GL_FRAGMENT_LIGHT_MODEL_LOCAL_VIEWER_SGIX',0x8408) +GL_FRAGMENT_LIGHT_MODEL_NORMAL_INTERPOLATION_SGIX=_C('GL_FRAGMENT_LIGHT_MODEL_NORMAL_INTERPOLATION_SGIX',0x840B) +GL_FRAGMENT_LIGHT_MODEL_TWO_SIDE_SGIX=_C('GL_FRAGMENT_LIGHT_MODEL_TWO_SIDE_SGIX',0x8409) +GL_LIGHT_ENV_MODE_SGIX=_C('GL_LIGHT_ENV_MODE_SGIX',0x8407) +GL_MAX_ACTIVE_LIGHTS_SGIX=_C('GL_MAX_ACTIVE_LIGHTS_SGIX',0x8405) +GL_MAX_FRAGMENT_LIGHTS_SGIX=_C('GL_MAX_FRAGMENT_LIGHTS_SGIX',0x8404) +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum) +def glFragmentColorMaterialSGIX(face,mode):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLfloat) +def glFragmentLightModelfSGIX(pname,param):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLfloatArray) +def glFragmentLightModelfvSGIX(pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLint) +def glFragmentLightModeliSGIX(pname,param):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLintArray) +def glFragmentLightModelivSGIX(pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLfloat) +def glFragmentLightfSGIX(light,pname,param):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLfloatArray) +def glFragmentLightfvSGIX(light,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLint) +def glFragmentLightiSGIX(light,pname,param):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLintArray) +def glFragmentLightivSGIX(light,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLfloat) +def glFragmentMaterialfSGIX(face,pname,param):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLfloatArray) +def glFragmentMaterialfvSGIX(face,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLint) +def glFragmentMaterialiSGIX(face,pname,param):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLintArray) +def glFragmentMaterialivSGIX(face,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLfloatArray) +def glGetFragmentLightfvSGIX(light,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLintArray) +def glGetFragmentLightivSGIX(light,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLfloatArray) +def glGetFragmentMaterialfvSGIX(face,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLintArray) +def glGetFragmentMaterialivSGIX(face,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLint) +def glLightEnviSGIX(pname,param):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/framezoom.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/framezoom.py new file mode 100644 index 00000000..19ede11b --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/framezoom.py @@ -0,0 +1,19 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_SGIX_framezoom' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_SGIX_framezoom',error_checker=_errors._error_checker) +GL_FRAMEZOOM_FACTOR_SGIX=_C('GL_FRAMEZOOM_FACTOR_SGIX',0x818C) +GL_FRAMEZOOM_SGIX=_C('GL_FRAMEZOOM_SGIX',0x818B) +GL_MAX_FRAMEZOOM_FACTOR_SGIX=_C('GL_MAX_FRAMEZOOM_FACTOR_SGIX',0x818D) +@_f +@_p.types(None,_cs.GLint) +def glFrameZoomSGIX(factor):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/igloo_interface.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/igloo_interface.py new file mode 100644 index 00000000..71ea62ba --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/igloo_interface.py @@ -0,0 +1,17 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_SGIX_igloo_interface' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_SGIX_igloo_interface',error_checker=_errors._error_checker) + +@_f +@_p.types(None,_cs.GLenum,ctypes.c_void_p) +def glIglooInterfaceSGIX(pname,params):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/instruments.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/instruments.py new file mode 100644 index 00000000..97eff001 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/instruments.py @@ -0,0 +1,33 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_SGIX_instruments' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_SGIX_instruments',error_checker=_errors._error_checker) +GL_INSTRUMENT_BUFFER_POINTER_SGIX=_C('GL_INSTRUMENT_BUFFER_POINTER_SGIX',0x8180) +GL_INSTRUMENT_MEASUREMENTS_SGIX=_C('GL_INSTRUMENT_MEASUREMENTS_SGIX',0x8181) +@_f +@_p.types(_cs.GLint,) +def glGetInstrumentsSGIX():pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLintArray) +def glInstrumentsBufferSGIX(size,buffer):pass +@_f +@_p.types(_cs.GLint,arrays.GLintArray) +def glPollInstrumentsSGIX(marker_p):pass +@_f +@_p.types(None,_cs.GLint) +def glReadInstrumentsSGIX(marker):pass +@_f +@_p.types(None,) +def glStartInstrumentsSGIX():pass +@_f +@_p.types(None,_cs.GLint) +def glStopInstrumentsSGIX(marker):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/interlace.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/interlace.py new file mode 100644 index 00000000..1661c1e0 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/interlace.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_SGIX_interlace' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_SGIX_interlace',error_checker=_errors._error_checker) +GL_INTERLACE_SGIX=_C('GL_INTERLACE_SGIX',0x8094) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/ir_instrument1.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/ir_instrument1.py new file mode 100644 index 00000000..86db9db9 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/ir_instrument1.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_SGIX_ir_instrument1' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_SGIX_ir_instrument1',error_checker=_errors._error_checker) +GL_IR_INSTRUMENT1_SGIX=_C('GL_IR_INSTRUMENT1_SGIX',0x817F) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/list_priority.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/list_priority.py new file mode 100644 index 00000000..3e09a3d0 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/list_priority.py @@ -0,0 +1,32 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_SGIX_list_priority' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_SGIX_list_priority',error_checker=_errors._error_checker) +GL_LIST_PRIORITY_SGIX=_C('GL_LIST_PRIORITY_SGIX',0x8182) +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLfloatArray) +def glGetListParameterfvSGIX(list,pname,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLintArray) +def glGetListParameterivSGIX(list,pname,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLfloat) +def glListParameterfSGIX(list,pname,param):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLfloatArray) +def glListParameterfvSGIX(list,pname,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLint) +def glListParameteriSGIX(list,pname,param):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLintArray) +def glListParameterivSGIX(list,pname,params):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/pixel_texture.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/pixel_texture.py new file mode 100644 index 00000000..59456c59 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/pixel_texture.py @@ -0,0 +1,18 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_SGIX_pixel_texture' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_SGIX_pixel_texture',error_checker=_errors._error_checker) +GL_PIXEL_TEX_GEN_MODE_SGIX=_C('GL_PIXEL_TEX_GEN_MODE_SGIX',0x832B) +GL_PIXEL_TEX_GEN_SGIX=_C('GL_PIXEL_TEX_GEN_SGIX',0x8139) +@_f +@_p.types(None,_cs.GLenum) +def glPixelTexGenSGIX(mode):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/pixel_tiles.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/pixel_tiles.py new file mode 100644 index 00000000..68feb3e8 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/pixel_tiles.py @@ -0,0 +1,22 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_SGIX_pixel_tiles' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_SGIX_pixel_tiles',error_checker=_errors._error_checker) +GL_PIXEL_TILE_BEST_ALIGNMENT_SGIX=_C('GL_PIXEL_TILE_BEST_ALIGNMENT_SGIX',0x813E) +GL_PIXEL_TILE_CACHE_INCREMENT_SGIX=_C('GL_PIXEL_TILE_CACHE_INCREMENT_SGIX',0x813F) +GL_PIXEL_TILE_CACHE_SIZE_SGIX=_C('GL_PIXEL_TILE_CACHE_SIZE_SGIX',0x8145) +GL_PIXEL_TILE_GRID_DEPTH_SGIX=_C('GL_PIXEL_TILE_GRID_DEPTH_SGIX',0x8144) +GL_PIXEL_TILE_GRID_HEIGHT_SGIX=_C('GL_PIXEL_TILE_GRID_HEIGHT_SGIX',0x8143) +GL_PIXEL_TILE_GRID_WIDTH_SGIX=_C('GL_PIXEL_TILE_GRID_WIDTH_SGIX',0x8142) +GL_PIXEL_TILE_HEIGHT_SGIX=_C('GL_PIXEL_TILE_HEIGHT_SGIX',0x8141) +GL_PIXEL_TILE_WIDTH_SGIX=_C('GL_PIXEL_TILE_WIDTH_SGIX',0x8140) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/polynomial_ffd.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/polynomial_ffd.py new file mode 100644 index 00000000..eff96efa --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/polynomial_ffd.py @@ -0,0 +1,31 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_SGIX_polynomial_ffd' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_SGIX_polynomial_ffd',error_checker=_errors._error_checker) +GL_DEFORMATIONS_MASK_SGIX=_C('GL_DEFORMATIONS_MASK_SGIX',0x8196) +GL_GEOMETRY_DEFORMATION_BIT_SGIX=_C('GL_GEOMETRY_DEFORMATION_BIT_SGIX',0x00000002) +GL_GEOMETRY_DEFORMATION_SGIX=_C('GL_GEOMETRY_DEFORMATION_SGIX',0x8194) +GL_MAX_DEFORMATION_ORDER_SGIX=_C('GL_MAX_DEFORMATION_ORDER_SGIX',0x8197) +GL_TEXTURE_DEFORMATION_BIT_SGIX=_C('GL_TEXTURE_DEFORMATION_BIT_SGIX',0x00000001) +GL_TEXTURE_DEFORMATION_SGIX=_C('GL_TEXTURE_DEFORMATION_SGIX',0x8195) +@_f +@_p.types(None,_cs.GLbitfield) +def glDeformSGIX(mask):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLdouble,_cs.GLdouble,_cs.GLint,_cs.GLint,_cs.GLdouble,_cs.GLdouble,_cs.GLint,_cs.GLint,_cs.GLdouble,_cs.GLdouble,_cs.GLint,_cs.GLint,arrays.GLdoubleArray) +def glDeformationMap3dSGIX(target,u1,u2,ustride,uorder,v1,v2,vstride,vorder,w1,w2,wstride,worder,points):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLfloat,_cs.GLfloat,_cs.GLint,_cs.GLint,_cs.GLfloat,_cs.GLfloat,_cs.GLint,_cs.GLint,_cs.GLfloat,_cs.GLfloat,_cs.GLint,_cs.GLint,arrays.GLfloatArray) +def glDeformationMap3fSGIX(target,u1,u2,ustride,uorder,v1,v2,vstride,vorder,w1,w2,wstride,worder,points):pass +@_f +@_p.types(None,_cs.GLbitfield) +def glLoadIdentityDeformationMapSGIX(mask):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/reference_plane.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/reference_plane.py new file mode 100644 index 00000000..c5deede2 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/reference_plane.py @@ -0,0 +1,18 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_SGIX_reference_plane' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_SGIX_reference_plane',error_checker=_errors._error_checker) +GL_REFERENCE_PLANE_EQUATION_SGIX=_C('GL_REFERENCE_PLANE_EQUATION_SGIX',0x817E) +GL_REFERENCE_PLANE_SGIX=_C('GL_REFERENCE_PLANE_SGIX',0x817D) +@_f +@_p.types(None,arrays.GLdoubleArray) +def glReferencePlaneSGIX(equation):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/resample.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/resample.py new file mode 100644 index 00000000..5a29fa36 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/resample.py @@ -0,0 +1,19 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_SGIX_resample' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_SGIX_resample',error_checker=_errors._error_checker) +GL_PACK_RESAMPLE_SGIX=_C('GL_PACK_RESAMPLE_SGIX',0x842E) +GL_RESAMPLE_DECIMATE_SGIX=_C('GL_RESAMPLE_DECIMATE_SGIX',0x8430) +GL_RESAMPLE_REPLICATE_SGIX=_C('GL_RESAMPLE_REPLICATE_SGIX',0x8433) +GL_RESAMPLE_ZERO_FILL_SGIX=_C('GL_RESAMPLE_ZERO_FILL_SGIX',0x8434) +GL_UNPACK_RESAMPLE_SGIX=_C('GL_UNPACK_RESAMPLE_SGIX',0x842F) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/scalebias_hint.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/scalebias_hint.py new file mode 100644 index 00000000..47ae97cb --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/scalebias_hint.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_SGIX_scalebias_hint' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_SGIX_scalebias_hint',error_checker=_errors._error_checker) +GL_SCALEBIAS_HINT_SGIX=_C('GL_SCALEBIAS_HINT_SGIX',0x8322) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/shadow.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/shadow.py new file mode 100644 index 00000000..0ec2a8a3 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/shadow.py @@ -0,0 +1,18 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_SGIX_shadow' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_SGIX_shadow',error_checker=_errors._error_checker) +GL_TEXTURE_COMPARE_OPERATOR_SGIX=_C('GL_TEXTURE_COMPARE_OPERATOR_SGIX',0x819B) +GL_TEXTURE_COMPARE_SGIX=_C('GL_TEXTURE_COMPARE_SGIX',0x819A) +GL_TEXTURE_GEQUAL_R_SGIX=_C('GL_TEXTURE_GEQUAL_R_SGIX',0x819D) +GL_TEXTURE_LEQUAL_R_SGIX=_C('GL_TEXTURE_LEQUAL_R_SGIX',0x819C) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/shadow_ambient.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/shadow_ambient.py new file mode 100644 index 00000000..b0019377 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/shadow_ambient.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_SGIX_shadow_ambient' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_SGIX_shadow_ambient',error_checker=_errors._error_checker) +GL_SHADOW_AMBIENT_SGIX=_C('GL_SHADOW_AMBIENT_SGIX',0x80BF) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/sprite.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/sprite.py new file mode 100644 index 00000000..3fae45ff --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/sprite.py @@ -0,0 +1,32 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_SGIX_sprite' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_SGIX_sprite',error_checker=_errors._error_checker) +GL_SPRITE_AXIAL_SGIX=_C('GL_SPRITE_AXIAL_SGIX',0x814C) +GL_SPRITE_AXIS_SGIX=_C('GL_SPRITE_AXIS_SGIX',0x814A) +GL_SPRITE_EYE_ALIGNED_SGIX=_C('GL_SPRITE_EYE_ALIGNED_SGIX',0x814E) +GL_SPRITE_MODE_SGIX=_C('GL_SPRITE_MODE_SGIX',0x8149) +GL_SPRITE_OBJECT_ALIGNED_SGIX=_C('GL_SPRITE_OBJECT_ALIGNED_SGIX',0x814D) +GL_SPRITE_SGIX=_C('GL_SPRITE_SGIX',0x8148) +GL_SPRITE_TRANSLATION_SGIX=_C('GL_SPRITE_TRANSLATION_SGIX',0x814B) +@_f +@_p.types(None,_cs.GLenum,_cs.GLfloat) +def glSpriteParameterfSGIX(pname,param):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLfloatArray) +def glSpriteParameterfvSGIX(pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLint) +def glSpriteParameteriSGIX(pname,param):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLintArray) +def glSpriteParameterivSGIX(pname,params):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/subsample.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/subsample.py new file mode 100644 index 00000000..a0e47686 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/subsample.py @@ -0,0 +1,19 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_SGIX_subsample' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_SGIX_subsample',error_checker=_errors._error_checker) +GL_PACK_SUBSAMPLE_RATE_SGIX=_C('GL_PACK_SUBSAMPLE_RATE_SGIX',0x85A0) +GL_PIXEL_SUBSAMPLE_2424_SGIX=_C('GL_PIXEL_SUBSAMPLE_2424_SGIX',0x85A3) +GL_PIXEL_SUBSAMPLE_4242_SGIX=_C('GL_PIXEL_SUBSAMPLE_4242_SGIX',0x85A4) +GL_PIXEL_SUBSAMPLE_4444_SGIX=_C('GL_PIXEL_SUBSAMPLE_4444_SGIX',0x85A2) +GL_UNPACK_SUBSAMPLE_RATE_SGIX=_C('GL_UNPACK_SUBSAMPLE_RATE_SGIX',0x85A1) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/tag_sample_buffer.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/tag_sample_buffer.py new file mode 100644 index 00000000..7c55f837 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/tag_sample_buffer.py @@ -0,0 +1,17 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_SGIX_tag_sample_buffer' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_SGIX_tag_sample_buffer',error_checker=_errors._error_checker) + +@_f +@_p.types(None,) +def glTagSampleBufferSGIX():pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/texture_add_env.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/texture_add_env.py new file mode 100644 index 00000000..2d553138 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/texture_add_env.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_SGIX_texture_add_env' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_SGIX_texture_add_env',error_checker=_errors._error_checker) +GL_TEXTURE_ENV_BIAS_SGIX=_C('GL_TEXTURE_ENV_BIAS_SGIX',0x80BE) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/texture_coordinate_clamp.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/texture_coordinate_clamp.py new file mode 100644 index 00000000..3b4ee582 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/texture_coordinate_clamp.py @@ -0,0 +1,17 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_SGIX_texture_coordinate_clamp' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_SGIX_texture_coordinate_clamp',error_checker=_errors._error_checker) +GL_TEXTURE_MAX_CLAMP_R_SGIX=_C('GL_TEXTURE_MAX_CLAMP_R_SGIX',0x836B) +GL_TEXTURE_MAX_CLAMP_S_SGIX=_C('GL_TEXTURE_MAX_CLAMP_S_SGIX',0x8369) +GL_TEXTURE_MAX_CLAMP_T_SGIX=_C('GL_TEXTURE_MAX_CLAMP_T_SGIX',0x836A) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/texture_lod_bias.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/texture_lod_bias.py new file mode 100644 index 00000000..a1fcd1ef --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/texture_lod_bias.py @@ -0,0 +1,17 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_SGIX_texture_lod_bias' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_SGIX_texture_lod_bias',error_checker=_errors._error_checker) +GL_TEXTURE_LOD_BIAS_R_SGIX=_C('GL_TEXTURE_LOD_BIAS_R_SGIX',0x8190) +GL_TEXTURE_LOD_BIAS_S_SGIX=_C('GL_TEXTURE_LOD_BIAS_S_SGIX',0x818E) +GL_TEXTURE_LOD_BIAS_T_SGIX=_C('GL_TEXTURE_LOD_BIAS_T_SGIX',0x818F) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/texture_multi_buffer.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/texture_multi_buffer.py new file mode 100644 index 00000000..072af4dd --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/texture_multi_buffer.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_SGIX_texture_multi_buffer' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_SGIX_texture_multi_buffer',error_checker=_errors._error_checker) +GL_TEXTURE_MULTI_BUFFER_HINT_SGIX=_C('GL_TEXTURE_MULTI_BUFFER_HINT_SGIX',0x812E) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/texture_scale_bias.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/texture_scale_bias.py new file mode 100644 index 00000000..e917597e --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/texture_scale_bias.py @@ -0,0 +1,18 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_SGIX_texture_scale_bias' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_SGIX_texture_scale_bias',error_checker=_errors._error_checker) +GL_POST_TEXTURE_FILTER_BIAS_RANGE_SGIX=_C('GL_POST_TEXTURE_FILTER_BIAS_RANGE_SGIX',0x817B) +GL_POST_TEXTURE_FILTER_BIAS_SGIX=_C('GL_POST_TEXTURE_FILTER_BIAS_SGIX',0x8179) +GL_POST_TEXTURE_FILTER_SCALE_RANGE_SGIX=_C('GL_POST_TEXTURE_FILTER_SCALE_RANGE_SGIX',0x817C) +GL_POST_TEXTURE_FILTER_SCALE_SGIX=_C('GL_POST_TEXTURE_FILTER_SCALE_SGIX',0x817A) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/vertex_preclip.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/vertex_preclip.py new file mode 100644 index 00000000..9aee43d0 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/vertex_preclip.py @@ -0,0 +1,16 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_SGIX_vertex_preclip' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_SGIX_vertex_preclip',error_checker=_errors._error_checker) +GL_VERTEX_PRECLIP_HINT_SGIX=_C('GL_VERTEX_PRECLIP_HINT_SGIX',0x83EF) +GL_VERTEX_PRECLIP_SGIX=_C('GL_VERTEX_PRECLIP_SGIX',0x83EE) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/ycrcb.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/ycrcb.py new file mode 100644 index 00000000..d007a0f6 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/ycrcb.py @@ -0,0 +1,16 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_SGIX_ycrcb' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_SGIX_ycrcb',error_checker=_errors._error_checker) +GL_YCRCB_422_SGIX=_C('GL_YCRCB_422_SGIX',0x81BB) +GL_YCRCB_444_SGIX=_C('GL_YCRCB_444_SGIX',0x81BC) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/ycrcb_subsample.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/ycrcb_subsample.py new file mode 100644 index 00000000..e210762d --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/ycrcb_subsample.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_SGIX_ycrcb_subsample' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_SGIX_ycrcb_subsample',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/ycrcba.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/ycrcba.py new file mode 100644 index 00000000..46884eb2 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SGIX/ycrcba.py @@ -0,0 +1,16 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_SGIX_ycrcba' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_SGIX_ycrcba',error_checker=_errors._error_checker) +GL_YCRCBA_SGIX=_C('GL_YCRCBA_SGIX',0x8319) +GL_YCRCB_SGIX=_C('GL_YCRCB_SGIX',0x8318) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SUN/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SUN/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SUN/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SUN/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SUN/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..84f3e63c Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SUN/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SUN/__pycache__/convolution_border_modes.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SUN/__pycache__/convolution_border_modes.cpython-312.pyc new file mode 100644 index 00000000..e93f8d7e Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SUN/__pycache__/convolution_border_modes.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SUN/__pycache__/global_alpha.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SUN/__pycache__/global_alpha.cpython-312.pyc new file mode 100644 index 00000000..68d287b1 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SUN/__pycache__/global_alpha.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SUN/__pycache__/mesh_array.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SUN/__pycache__/mesh_array.cpython-312.pyc new file mode 100644 index 00000000..48eca1ba Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SUN/__pycache__/mesh_array.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SUN/__pycache__/slice_accum.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SUN/__pycache__/slice_accum.cpython-312.pyc new file mode 100644 index 00000000..2055461b Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SUN/__pycache__/slice_accum.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SUN/__pycache__/triangle_list.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SUN/__pycache__/triangle_list.cpython-312.pyc new file mode 100644 index 00000000..f20f9046 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SUN/__pycache__/triangle_list.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SUN/__pycache__/vertex.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SUN/__pycache__/vertex.cpython-312.pyc new file mode 100644 index 00000000..38cb5a3e Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SUN/__pycache__/vertex.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SUN/convolution_border_modes.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SUN/convolution_border_modes.py new file mode 100644 index 00000000..673078c4 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SUN/convolution_border_modes.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_SUN_convolution_border_modes' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_SUN_convolution_border_modes',error_checker=_errors._error_checker) +GL_WRAP_BORDER_SUN=_C('GL_WRAP_BORDER_SUN',0x81D4) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SUN/global_alpha.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SUN/global_alpha.py new file mode 100644 index 00000000..3e90ebf5 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SUN/global_alpha.py @@ -0,0 +1,39 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_SUN_global_alpha' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_SUN_global_alpha',error_checker=_errors._error_checker) +GL_GLOBAL_ALPHA_FACTOR_SUN=_C('GL_GLOBAL_ALPHA_FACTOR_SUN',0x81DA) +GL_GLOBAL_ALPHA_SUN=_C('GL_GLOBAL_ALPHA_SUN',0x81D9) +@_f +@_p.types(None,_cs.GLbyte) +def glGlobalAlphaFactorbSUN(factor):pass +@_f +@_p.types(None,_cs.GLdouble) +def glGlobalAlphaFactordSUN(factor):pass +@_f +@_p.types(None,_cs.GLfloat) +def glGlobalAlphaFactorfSUN(factor):pass +@_f +@_p.types(None,_cs.GLint) +def glGlobalAlphaFactoriSUN(factor):pass +@_f +@_p.types(None,_cs.GLshort) +def glGlobalAlphaFactorsSUN(factor):pass +@_f +@_p.types(None,_cs.GLubyte) +def glGlobalAlphaFactorubSUN(factor):pass +@_f +@_p.types(None,_cs.GLuint) +def glGlobalAlphaFactoruiSUN(factor):pass +@_f +@_p.types(None,_cs.GLushort) +def glGlobalAlphaFactorusSUN(factor):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SUN/mesh_array.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SUN/mesh_array.py new file mode 100644 index 00000000..d37b8508 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SUN/mesh_array.py @@ -0,0 +1,18 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_SUN_mesh_array' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_SUN_mesh_array',error_checker=_errors._error_checker) +GL_QUAD_MESH_SUN=_C('GL_QUAD_MESH_SUN',0x8614) +GL_TRIANGLE_MESH_SUN=_C('GL_TRIANGLE_MESH_SUN',0x8615) +@_f +@_p.types(None,_cs.GLenum,_cs.GLint,_cs.GLsizei,_cs.GLsizei) +def glDrawMeshArraysSUN(mode,first,count,width):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SUN/slice_accum.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SUN/slice_accum.py new file mode 100644 index 00000000..81c38efa --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SUN/slice_accum.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_SUN_slice_accum' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_SUN_slice_accum',error_checker=_errors._error_checker) +GL_SLICE_ACCUM_SUN=_C('GL_SLICE_ACCUM_SUN',0x85CC) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SUN/triangle_list.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SUN/triangle_list.py new file mode 100644 index 00000000..a0732cf7 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SUN/triangle_list.py @@ -0,0 +1,51 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_SUN_triangle_list' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_SUN_triangle_list',error_checker=_errors._error_checker) +GL_R1UI_C3F_V3F_SUN=_C('GL_R1UI_C3F_V3F_SUN',0x85C6) +GL_R1UI_C4F_N3F_V3F_SUN=_C('GL_R1UI_C4F_N3F_V3F_SUN',0x85C8) +GL_R1UI_C4UB_V3F_SUN=_C('GL_R1UI_C4UB_V3F_SUN',0x85C5) +GL_R1UI_N3F_V3F_SUN=_C('GL_R1UI_N3F_V3F_SUN',0x85C7) +GL_R1UI_T2F_C4F_N3F_V3F_SUN=_C('GL_R1UI_T2F_C4F_N3F_V3F_SUN',0x85CB) +GL_R1UI_T2F_N3F_V3F_SUN=_C('GL_R1UI_T2F_N3F_V3F_SUN',0x85CA) +GL_R1UI_T2F_V3F_SUN=_C('GL_R1UI_T2F_V3F_SUN',0x85C9) +GL_R1UI_V3F_SUN=_C('GL_R1UI_V3F_SUN',0x85C4) +GL_REPLACEMENT_CODE_ARRAY_POINTER_SUN=_C('GL_REPLACEMENT_CODE_ARRAY_POINTER_SUN',0x85C3) +GL_REPLACEMENT_CODE_ARRAY_STRIDE_SUN=_C('GL_REPLACEMENT_CODE_ARRAY_STRIDE_SUN',0x85C2) +GL_REPLACEMENT_CODE_ARRAY_SUN=_C('GL_REPLACEMENT_CODE_ARRAY_SUN',0x85C0) +GL_REPLACEMENT_CODE_ARRAY_TYPE_SUN=_C('GL_REPLACEMENT_CODE_ARRAY_TYPE_SUN',0x85C1) +GL_REPLACEMENT_CODE_SUN=_C('GL_REPLACEMENT_CODE_SUN',0x81D8) +GL_REPLACE_MIDDLE_SUN=_C('GL_REPLACE_MIDDLE_SUN',0x0002) +GL_REPLACE_OLDEST_SUN=_C('GL_REPLACE_OLDEST_SUN',0x0003) +GL_RESTART_SUN=_C('GL_RESTART_SUN',0x0001) +GL_TRIANGLE_LIST_SUN=_C('GL_TRIANGLE_LIST_SUN',0x81D7) +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizei,arrays.GLvoidpArray) +def glReplacementCodePointerSUN(type,stride,pointer):pass +@_f +@_p.types(None,_cs.GLubyte) +def glReplacementCodeubSUN(code):pass +@_f +@_p.types(None,arrays.GLubyteArray) +def glReplacementCodeubvSUN(code):pass +@_f +@_p.types(None,_cs.GLuint) +def glReplacementCodeuiSUN(code):pass +@_f +@_p.types(None,arrays.GLuintArray) +def glReplacementCodeuivSUN(code):pass +@_f +@_p.types(None,_cs.GLushort) +def glReplacementCodeusSUN(code):pass +@_f +@_p.types(None,arrays.GLushortArray) +def glReplacementCodeusvSUN(code):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SUN/vertex.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SUN/vertex.py new file mode 100644 index 00000000..97c1eddc --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SUN/vertex.py @@ -0,0 +1,134 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_SUN_vertex' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_SUN_vertex',error_checker=_errors._error_checker) + +@_f +@_p.types(None,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat) +def glColor3fVertex3fSUN(r,g,b,x,y,z):pass +@_f +@_p.types(None,arrays.GLfloatArray,arrays.GLfloatArray) +def glColor3fVertex3fvSUN(c,v):pass +@_f +@_p.types(None,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat) +def glColor4fNormal3fVertex3fSUN(r,g,b,a,nx,ny,nz,x,y,z):pass +@_f +@_p.types(None,arrays.GLfloatArray,arrays.GLfloatArray,arrays.GLfloatArray) +def glColor4fNormal3fVertex3fvSUN(c,n,v):pass +@_f +@_p.types(None,_cs.GLubyte,_cs.GLubyte,_cs.GLubyte,_cs.GLubyte,_cs.GLfloat,_cs.GLfloat) +def glColor4ubVertex2fSUN(r,g,b,a,x,y):pass +@_f +@_p.types(None,arrays.GLubyteArray,arrays.GLfloatArray) +def glColor4ubVertex2fvSUN(c,v):pass +@_f +@_p.types(None,_cs.GLubyte,_cs.GLubyte,_cs.GLubyte,_cs.GLubyte,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat) +def glColor4ubVertex3fSUN(r,g,b,a,x,y,z):pass +@_f +@_p.types(None,arrays.GLubyteArray,arrays.GLfloatArray) +def glColor4ubVertex3fvSUN(c,v):pass +@_f +@_p.types(None,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat) +def glNormal3fVertex3fSUN(nx,ny,nz,x,y,z):pass +@_f +@_p.types(None,arrays.GLfloatArray,arrays.GLfloatArray) +def glNormal3fVertex3fvSUN(n,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat) +def glReplacementCodeuiColor3fVertex3fSUN(rc,r,g,b,x,y,z):pass +@_f +@_p.types(None,arrays.GLuintArray,arrays.GLfloatArray,arrays.GLfloatArray) +def glReplacementCodeuiColor3fVertex3fvSUN(rc,c,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat) +def glReplacementCodeuiColor4fNormal3fVertex3fSUN(rc,r,g,b,a,nx,ny,nz,x,y,z):pass +@_f +@_p.types(None,arrays.GLuintArray,arrays.GLfloatArray,arrays.GLfloatArray,arrays.GLfloatArray) +def glReplacementCodeuiColor4fNormal3fVertex3fvSUN(rc,c,n,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLubyte,_cs.GLubyte,_cs.GLubyte,_cs.GLubyte,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat) +def glReplacementCodeuiColor4ubVertex3fSUN(rc,r,g,b,a,x,y,z):pass +@_f +@_p.types(None,arrays.GLuintArray,arrays.GLubyteArray,arrays.GLfloatArray) +def glReplacementCodeuiColor4ubVertex3fvSUN(rc,c,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat) +def glReplacementCodeuiNormal3fVertex3fSUN(rc,nx,ny,nz,x,y,z):pass +@_f +@_p.types(None,arrays.GLuintArray,arrays.GLfloatArray,arrays.GLfloatArray) +def glReplacementCodeuiNormal3fVertex3fvSUN(rc,n,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat) +def glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN(rc,s,t,r,g,b,a,nx,ny,nz,x,y,z):pass +@_f +@_p.types(None,arrays.GLuintArray,arrays.GLfloatArray,arrays.GLfloatArray,arrays.GLfloatArray,arrays.GLfloatArray) +def glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(rc,tc,c,n,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat) +def glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN(rc,s,t,nx,ny,nz,x,y,z):pass +@_f +@_p.types(None,arrays.GLuintArray,arrays.GLfloatArray,arrays.GLfloatArray,arrays.GLfloatArray) +def glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(rc,tc,n,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat) +def glReplacementCodeuiTexCoord2fVertex3fSUN(rc,s,t,x,y,z):pass +@_f +@_p.types(None,arrays.GLuintArray,arrays.GLfloatArray,arrays.GLfloatArray) +def glReplacementCodeuiTexCoord2fVertex3fvSUN(rc,tc,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat) +def glReplacementCodeuiVertex3fSUN(rc,x,y,z):pass +@_f +@_p.types(None,arrays.GLuintArray,arrays.GLfloatArray) +def glReplacementCodeuiVertex3fvSUN(rc,v):pass +@_f +@_p.types(None,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat) +def glTexCoord2fColor3fVertex3fSUN(s,t,r,g,b,x,y,z):pass +@_f +@_p.types(None,arrays.GLfloatArray,arrays.GLfloatArray,arrays.GLfloatArray) +def glTexCoord2fColor3fVertex3fvSUN(tc,c,v):pass +@_f +@_p.types(None,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat) +def glTexCoord2fColor4fNormal3fVertex3fSUN(s,t,r,g,b,a,nx,ny,nz,x,y,z):pass +@_f +@_p.types(None,arrays.GLfloatArray,arrays.GLfloatArray,arrays.GLfloatArray,arrays.GLfloatArray) +def glTexCoord2fColor4fNormal3fVertex3fvSUN(tc,c,n,v):pass +@_f +@_p.types(None,_cs.GLfloat,_cs.GLfloat,_cs.GLubyte,_cs.GLubyte,_cs.GLubyte,_cs.GLubyte,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat) +def glTexCoord2fColor4ubVertex3fSUN(s,t,r,g,b,a,x,y,z):pass +@_f +@_p.types(None,arrays.GLfloatArray,arrays.GLubyteArray,arrays.GLfloatArray) +def glTexCoord2fColor4ubVertex3fvSUN(tc,c,v):pass +@_f +@_p.types(None,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat) +def glTexCoord2fNormal3fVertex3fSUN(s,t,nx,ny,nz,x,y,z):pass +@_f +@_p.types(None,arrays.GLfloatArray,arrays.GLfloatArray,arrays.GLfloatArray) +def glTexCoord2fNormal3fVertex3fvSUN(tc,n,v):pass +@_f +@_p.types(None,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat) +def glTexCoord2fVertex3fSUN(s,t,x,y,z):pass +@_f +@_p.types(None,arrays.GLfloatArray,arrays.GLfloatArray) +def glTexCoord2fVertex3fvSUN(tc,v):pass +@_f +@_p.types(None,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat) +def glTexCoord4fColor4fNormal3fVertex4fSUN(s,t,p,q,r,g,b,a,nx,ny,nz,x,y,z,w):pass +@_f +@_p.types(None,arrays.GLfloatArray,arrays.GLfloatArray,arrays.GLfloatArray,arrays.GLfloatArray) +def glTexCoord4fColor4fNormal3fVertex4fvSUN(tc,c,n,v):pass +@_f +@_p.types(None,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat) +def glTexCoord4fVertex4fSUN(s,t,p,q,x,y,z,w):pass +@_f +@_p.types(None,arrays.GLfloatArray,arrays.GLfloatArray) +def glTexCoord4fVertex4fvSUN(tc,v):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SUNX/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SUNX/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SUNX/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SUNX/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SUNX/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..e4aafc78 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SUNX/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SUNX/__pycache__/constant_data.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SUNX/__pycache__/constant_data.cpython-312.pyc new file mode 100644 index 00000000..eb81d072 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SUNX/__pycache__/constant_data.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SUNX/constant_data.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SUNX/constant_data.py new file mode 100644 index 00000000..91bc209c --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/SUNX/constant_data.py @@ -0,0 +1,18 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_SUNX_constant_data' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_SUNX_constant_data',error_checker=_errors._error_checker) +GL_TEXTURE_CONSTANT_DATA_SUNX=_C('GL_TEXTURE_CONSTANT_DATA_SUNX',0x81D6) +GL_UNPACK_CONSTANT_DATA_SUNX=_C('GL_UNPACK_CONSTANT_DATA_SUNX',0x81D5) +@_f +@_p.types(None,) +def glFinishTextureSUNX():pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/VERSION/GL_1_0.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/VERSION/GL_1_0.py new file mode 100644 index 00000000..38bfd050 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/VERSION/GL_1_0.py @@ -0,0 +1,1355 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_VERSION_GL_1_0' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_VERSION_GL_1_0',error_checker=_errors._error_checker) +GL_2D=_C('GL_2D',0x0600) +GL_2_BYTES=_C('GL_2_BYTES',0x1407) +GL_3D=_C('GL_3D',0x0601) +GL_3D_COLOR=_C('GL_3D_COLOR',0x0602) +GL_3D_COLOR_TEXTURE=_C('GL_3D_COLOR_TEXTURE',0x0603) +GL_3_BYTES=_C('GL_3_BYTES',0x1408) +GL_4D_COLOR_TEXTURE=_C('GL_4D_COLOR_TEXTURE',0x0604) +GL_4_BYTES=_C('GL_4_BYTES',0x1409) +GL_ACCUM=_C('GL_ACCUM',0x0100) +GL_ACCUM_ALPHA_BITS=_C('GL_ACCUM_ALPHA_BITS',0x0D5B) +GL_ACCUM_BLUE_BITS=_C('GL_ACCUM_BLUE_BITS',0x0D5A) +GL_ACCUM_BUFFER_BIT=_C('GL_ACCUM_BUFFER_BIT',0x00000200) +GL_ACCUM_CLEAR_VALUE=_C('GL_ACCUM_CLEAR_VALUE',0x0B80) +GL_ACCUM_GREEN_BITS=_C('GL_ACCUM_GREEN_BITS',0x0D59) +GL_ACCUM_RED_BITS=_C('GL_ACCUM_RED_BITS',0x0D58) +GL_ADD=_C('GL_ADD',0x0104) +GL_ALL_ATTRIB_BITS=_C('GL_ALL_ATTRIB_BITS',0xFFFFFFFF) +GL_ALPHA=_C('GL_ALPHA',0x1906) +GL_ALPHA_BIAS=_C('GL_ALPHA_BIAS',0x0D1D) +GL_ALPHA_BITS=_C('GL_ALPHA_BITS',0x0D55) +GL_ALPHA_SCALE=_C('GL_ALPHA_SCALE',0x0D1C) +GL_ALPHA_TEST=_C('GL_ALPHA_TEST',0x0BC0) +GL_ALPHA_TEST_FUNC=_C('GL_ALPHA_TEST_FUNC',0x0BC1) +GL_ALPHA_TEST_REF=_C('GL_ALPHA_TEST_REF',0x0BC2) +GL_ALWAYS=_C('GL_ALWAYS',0x0207) +GL_AMBIENT=_C('GL_AMBIENT',0x1200) +GL_AMBIENT_AND_DIFFUSE=_C('GL_AMBIENT_AND_DIFFUSE',0x1602) +GL_AND=_C('GL_AND',0x1501) +GL_AND_INVERTED=_C('GL_AND_INVERTED',0x1504) +GL_AND_REVERSE=_C('GL_AND_REVERSE',0x1502) +GL_ATTRIB_STACK_DEPTH=_C('GL_ATTRIB_STACK_DEPTH',0x0BB0) +GL_AUTO_NORMAL=_C('GL_AUTO_NORMAL',0x0D80) +GL_AUX0=_C('GL_AUX0',0x0409) +GL_AUX1=_C('GL_AUX1',0x040A) +GL_AUX2=_C('GL_AUX2',0x040B) +GL_AUX3=_C('GL_AUX3',0x040C) +GL_AUX_BUFFERS=_C('GL_AUX_BUFFERS',0x0C00) +GL_BACK=_C('GL_BACK',0x0405) +GL_BACK_LEFT=_C('GL_BACK_LEFT',0x0402) +GL_BACK_RIGHT=_C('GL_BACK_RIGHT',0x0403) +GL_BITMAP=_C('GL_BITMAP',0x1A00) +GL_BITMAP_TOKEN=_C('GL_BITMAP_TOKEN',0x0704) +GL_BLEND=_C('GL_BLEND',0x0BE2) +GL_BLEND_DST=_C('GL_BLEND_DST',0x0BE0) +GL_BLEND_SRC=_C('GL_BLEND_SRC',0x0BE1) +GL_BLUE=_C('GL_BLUE',0x1905) +GL_BLUE_BIAS=_C('GL_BLUE_BIAS',0x0D1B) +GL_BLUE_BITS=_C('GL_BLUE_BITS',0x0D54) +GL_BLUE_SCALE=_C('GL_BLUE_SCALE',0x0D1A) +GL_BYTE=_C('GL_BYTE',0x1400) +GL_CCW=_C('GL_CCW',0x0901) +GL_CLAMP=_C('GL_CLAMP',0x2900) +GL_CLEAR=_C('GL_CLEAR',0x1500) +GL_CLIP_PLANE0=_C('GL_CLIP_PLANE0',0x3000) +GL_CLIP_PLANE1=_C('GL_CLIP_PLANE1',0x3001) +GL_CLIP_PLANE2=_C('GL_CLIP_PLANE2',0x3002) +GL_CLIP_PLANE3=_C('GL_CLIP_PLANE3',0x3003) +GL_CLIP_PLANE4=_C('GL_CLIP_PLANE4',0x3004) +GL_CLIP_PLANE5=_C('GL_CLIP_PLANE5',0x3005) +GL_COEFF=_C('GL_COEFF',0x0A00) +GL_COLOR=_C('GL_COLOR',0x1800) +GL_COLOR_BUFFER_BIT=_C('GL_COLOR_BUFFER_BIT',0x00004000) +GL_COLOR_CLEAR_VALUE=_C('GL_COLOR_CLEAR_VALUE',0x0C22) +GL_COLOR_INDEX=_C('GL_COLOR_INDEX',0x1900) +GL_COLOR_INDEXES=_C('GL_COLOR_INDEXES',0x1603) +GL_COLOR_MATERIAL=_C('GL_COLOR_MATERIAL',0x0B57) +GL_COLOR_MATERIAL_FACE=_C('GL_COLOR_MATERIAL_FACE',0x0B55) +GL_COLOR_MATERIAL_PARAMETER=_C('GL_COLOR_MATERIAL_PARAMETER',0x0B56) +GL_COLOR_WRITEMASK=_C('GL_COLOR_WRITEMASK',0x0C23) +GL_COMPILE=_C('GL_COMPILE',0x1300) +GL_COMPILE_AND_EXECUTE=_C('GL_COMPILE_AND_EXECUTE',0x1301) +GL_CONSTANT_ATTENUATION=_C('GL_CONSTANT_ATTENUATION',0x1207) +GL_COPY=_C('GL_COPY',0x1503) +GL_COPY_INVERTED=_C('GL_COPY_INVERTED',0x150C) +GL_COPY_PIXEL_TOKEN=_C('GL_COPY_PIXEL_TOKEN',0x0706) +GL_CULL_FACE=_C('GL_CULL_FACE',0x0B44) +GL_CULL_FACE_MODE=_C('GL_CULL_FACE_MODE',0x0B45) +GL_CURRENT_BIT=_C('GL_CURRENT_BIT',0x00000001) +GL_CURRENT_COLOR=_C('GL_CURRENT_COLOR',0x0B00) +GL_CURRENT_INDEX=_C('GL_CURRENT_INDEX',0x0B01) +GL_CURRENT_NORMAL=_C('GL_CURRENT_NORMAL',0x0B02) +GL_CURRENT_RASTER_COLOR=_C('GL_CURRENT_RASTER_COLOR',0x0B04) +GL_CURRENT_RASTER_DISTANCE=_C('GL_CURRENT_RASTER_DISTANCE',0x0B09) +GL_CURRENT_RASTER_INDEX=_C('GL_CURRENT_RASTER_INDEX',0x0B05) +GL_CURRENT_RASTER_POSITION=_C('GL_CURRENT_RASTER_POSITION',0x0B07) +GL_CURRENT_RASTER_POSITION_VALID=_C('GL_CURRENT_RASTER_POSITION_VALID',0x0B08) +GL_CURRENT_RASTER_TEXTURE_COORDS=_C('GL_CURRENT_RASTER_TEXTURE_COORDS',0x0B06) +GL_CURRENT_TEXTURE_COORDS=_C('GL_CURRENT_TEXTURE_COORDS',0x0B03) +GL_CW=_C('GL_CW',0x0900) +GL_DECAL=_C('GL_DECAL',0x2101) +GL_DECR=_C('GL_DECR',0x1E03) +GL_DEPTH=_C('GL_DEPTH',0x1801) +GL_DEPTH_BIAS=_C('GL_DEPTH_BIAS',0x0D1F) +GL_DEPTH_BITS=_C('GL_DEPTH_BITS',0x0D56) +GL_DEPTH_BUFFER_BIT=_C('GL_DEPTH_BUFFER_BIT',0x00000100) +GL_DEPTH_CLEAR_VALUE=_C('GL_DEPTH_CLEAR_VALUE',0x0B73) +GL_DEPTH_COMPONENT=_C('GL_DEPTH_COMPONENT',0x1902) +GL_DEPTH_FUNC=_C('GL_DEPTH_FUNC',0x0B74) +GL_DEPTH_RANGE=_C('GL_DEPTH_RANGE',0x0B70) +GL_DEPTH_SCALE=_C('GL_DEPTH_SCALE',0x0D1E) +GL_DEPTH_TEST=_C('GL_DEPTH_TEST',0x0B71) +GL_DEPTH_WRITEMASK=_C('GL_DEPTH_WRITEMASK',0x0B72) +GL_DIFFUSE=_C('GL_DIFFUSE',0x1201) +GL_DITHER=_C('GL_DITHER',0x0BD0) +GL_DOMAIN=_C('GL_DOMAIN',0x0A02) +GL_DONT_CARE=_C('GL_DONT_CARE',0x1100) +GL_DOUBLEBUFFER=_C('GL_DOUBLEBUFFER',0x0C32) +GL_DRAW_BUFFER=_C('GL_DRAW_BUFFER',0x0C01) +GL_DRAW_PIXEL_TOKEN=_C('GL_DRAW_PIXEL_TOKEN',0x0705) +GL_DST_ALPHA=_C('GL_DST_ALPHA',0x0304) +GL_DST_COLOR=_C('GL_DST_COLOR',0x0306) +GL_EDGE_FLAG=_C('GL_EDGE_FLAG',0x0B43) +GL_EMISSION=_C('GL_EMISSION',0x1600) +GL_ENABLE_BIT=_C('GL_ENABLE_BIT',0x00002000) +GL_EQUAL=_C('GL_EQUAL',0x0202) +GL_EQUIV=_C('GL_EQUIV',0x1509) +GL_EVAL_BIT=_C('GL_EVAL_BIT',0x00010000) +GL_EXP=_C('GL_EXP',0x0800) +GL_EXP2=_C('GL_EXP2',0x0801) +GL_EXTENSIONS=_C('GL_EXTENSIONS',0x1F03) +GL_EYE_LINEAR=_C('GL_EYE_LINEAR',0x2400) +GL_EYE_PLANE=_C('GL_EYE_PLANE',0x2502) +GL_FALSE=_C('GL_FALSE',0) +GL_FASTEST=_C('GL_FASTEST',0x1101) +GL_FEEDBACK=_C('GL_FEEDBACK',0x1C01) +GL_FILL=_C('GL_FILL',0x1B02) +GL_FLAT=_C('GL_FLAT',0x1D00) +GL_FLOAT=_C('GL_FLOAT',0x1406) +GL_FOG=_C('GL_FOG',0x0B60) +GL_FOG_BIT=_C('GL_FOG_BIT',0x00000080) +GL_FOG_COLOR=_C('GL_FOG_COLOR',0x0B66) +GL_FOG_DENSITY=_C('GL_FOG_DENSITY',0x0B62) +GL_FOG_END=_C('GL_FOG_END',0x0B64) +GL_FOG_HINT=_C('GL_FOG_HINT',0x0C54) +GL_FOG_INDEX=_C('GL_FOG_INDEX',0x0B61) +GL_FOG_MODE=_C('GL_FOG_MODE',0x0B65) +GL_FOG_START=_C('GL_FOG_START',0x0B63) +GL_FRONT=_C('GL_FRONT',0x0404) +GL_FRONT_AND_BACK=_C('GL_FRONT_AND_BACK',0x0408) +GL_FRONT_FACE=_C('GL_FRONT_FACE',0x0B46) +GL_FRONT_LEFT=_C('GL_FRONT_LEFT',0x0400) +GL_FRONT_RIGHT=_C('GL_FRONT_RIGHT',0x0401) +GL_GEQUAL=_C('GL_GEQUAL',0x0206) +GL_GREATER=_C('GL_GREATER',0x0204) +GL_GREEN=_C('GL_GREEN',0x1904) +GL_GREEN_BIAS=_C('GL_GREEN_BIAS',0x0D19) +GL_GREEN_BITS=_C('GL_GREEN_BITS',0x0D53) +GL_GREEN_SCALE=_C('GL_GREEN_SCALE',0x0D18) +GL_HINT_BIT=_C('GL_HINT_BIT',0x00008000) +GL_INCR=_C('GL_INCR',0x1E02) +GL_INDEX_BITS=_C('GL_INDEX_BITS',0x0D51) +GL_INDEX_CLEAR_VALUE=_C('GL_INDEX_CLEAR_VALUE',0x0C20) +GL_INDEX_MODE=_C('GL_INDEX_MODE',0x0C30) +GL_INDEX_OFFSET=_C('GL_INDEX_OFFSET',0x0D13) +GL_INDEX_SHIFT=_C('GL_INDEX_SHIFT',0x0D12) +GL_INDEX_WRITEMASK=_C('GL_INDEX_WRITEMASK',0x0C21) +GL_INT=_C('GL_INT',0x1404) +GL_INVALID_ENUM=_C('GL_INVALID_ENUM',0x0500) +GL_INVALID_OPERATION=_C('GL_INVALID_OPERATION',0x0502) +GL_INVALID_VALUE=_C('GL_INVALID_VALUE',0x0501) +GL_INVERT=_C('GL_INVERT',0x150A) +GL_KEEP=_C('GL_KEEP',0x1E00) +GL_LEFT=_C('GL_LEFT',0x0406) +GL_LEQUAL=_C('GL_LEQUAL',0x0203) +GL_LESS=_C('GL_LESS',0x0201) +GL_LIGHT0=_C('GL_LIGHT0',0x4000) +GL_LIGHT1=_C('GL_LIGHT1',0x4001) +GL_LIGHT2=_C('GL_LIGHT2',0x4002) +GL_LIGHT3=_C('GL_LIGHT3',0x4003) +GL_LIGHT4=_C('GL_LIGHT4',0x4004) +GL_LIGHT5=_C('GL_LIGHT5',0x4005) +GL_LIGHT6=_C('GL_LIGHT6',0x4006) +GL_LIGHT7=_C('GL_LIGHT7',0x4007) +GL_LIGHTING=_C('GL_LIGHTING',0x0B50) +GL_LIGHTING_BIT=_C('GL_LIGHTING_BIT',0x00000040) +GL_LIGHT_MODEL_AMBIENT=_C('GL_LIGHT_MODEL_AMBIENT',0x0B53) +GL_LIGHT_MODEL_LOCAL_VIEWER=_C('GL_LIGHT_MODEL_LOCAL_VIEWER',0x0B51) +GL_LIGHT_MODEL_TWO_SIDE=_C('GL_LIGHT_MODEL_TWO_SIDE',0x0B52) +GL_LINE=_C('GL_LINE',0x1B01) +GL_LINEAR=_C('GL_LINEAR',0x2601) +GL_LINEAR_ATTENUATION=_C('GL_LINEAR_ATTENUATION',0x1208) +GL_LINEAR_MIPMAP_LINEAR=_C('GL_LINEAR_MIPMAP_LINEAR',0x2703) +GL_LINEAR_MIPMAP_NEAREST=_C('GL_LINEAR_MIPMAP_NEAREST',0x2701) +GL_LINES=_C('GL_LINES',0x0001) +GL_LINE_BIT=_C('GL_LINE_BIT',0x00000004) +GL_LINE_LOOP=_C('GL_LINE_LOOP',0x0002) +GL_LINE_RESET_TOKEN=_C('GL_LINE_RESET_TOKEN',0x0707) +GL_LINE_SMOOTH=_C('GL_LINE_SMOOTH',0x0B20) +GL_LINE_SMOOTH_HINT=_C('GL_LINE_SMOOTH_HINT',0x0C52) +GL_LINE_STIPPLE=_C('GL_LINE_STIPPLE',0x0B24) +GL_LINE_STIPPLE_PATTERN=_C('GL_LINE_STIPPLE_PATTERN',0x0B25) +GL_LINE_STIPPLE_REPEAT=_C('GL_LINE_STIPPLE_REPEAT',0x0B26) +GL_LINE_STRIP=_C('GL_LINE_STRIP',0x0003) +GL_LINE_TOKEN=_C('GL_LINE_TOKEN',0x0702) +GL_LINE_WIDTH=_C('GL_LINE_WIDTH',0x0B21) +GL_LINE_WIDTH_GRANULARITY=_C('GL_LINE_WIDTH_GRANULARITY',0x0B23) +GL_LINE_WIDTH_RANGE=_C('GL_LINE_WIDTH_RANGE',0x0B22) +GL_LIST_BASE=_C('GL_LIST_BASE',0x0B32) +GL_LIST_BIT=_C('GL_LIST_BIT',0x00020000) +GL_LIST_INDEX=_C('GL_LIST_INDEX',0x0B33) +GL_LIST_MODE=_C('GL_LIST_MODE',0x0B30) +GL_LOAD=_C('GL_LOAD',0x0101) +GL_LOGIC_OP=_C('GL_LOGIC_OP',0x0BF1) +GL_LOGIC_OP_MODE=_C('GL_LOGIC_OP_MODE',0x0BF0) +GL_LUMINANCE=_C('GL_LUMINANCE',0x1909) +GL_LUMINANCE_ALPHA=_C('GL_LUMINANCE_ALPHA',0x190A) +GL_MAP1_COLOR_4=_C('GL_MAP1_COLOR_4',0x0D90) +GL_MAP1_GRID_DOMAIN=_C('GL_MAP1_GRID_DOMAIN',0x0DD0) +GL_MAP1_GRID_SEGMENTS=_C('GL_MAP1_GRID_SEGMENTS',0x0DD1) +GL_MAP1_INDEX=_C('GL_MAP1_INDEX',0x0D91) +GL_MAP1_NORMAL=_C('GL_MAP1_NORMAL',0x0D92) +GL_MAP1_TEXTURE_COORD_1=_C('GL_MAP1_TEXTURE_COORD_1',0x0D93) +GL_MAP1_TEXTURE_COORD_2=_C('GL_MAP1_TEXTURE_COORD_2',0x0D94) +GL_MAP1_TEXTURE_COORD_3=_C('GL_MAP1_TEXTURE_COORD_3',0x0D95) +GL_MAP1_TEXTURE_COORD_4=_C('GL_MAP1_TEXTURE_COORD_4',0x0D96) +GL_MAP1_VERTEX_3=_C('GL_MAP1_VERTEX_3',0x0D97) +GL_MAP1_VERTEX_4=_C('GL_MAP1_VERTEX_4',0x0D98) +GL_MAP2_COLOR_4=_C('GL_MAP2_COLOR_4',0x0DB0) +GL_MAP2_GRID_DOMAIN=_C('GL_MAP2_GRID_DOMAIN',0x0DD2) +GL_MAP2_GRID_SEGMENTS=_C('GL_MAP2_GRID_SEGMENTS',0x0DD3) +GL_MAP2_INDEX=_C('GL_MAP2_INDEX',0x0DB1) +GL_MAP2_NORMAL=_C('GL_MAP2_NORMAL',0x0DB2) +GL_MAP2_TEXTURE_COORD_1=_C('GL_MAP2_TEXTURE_COORD_1',0x0DB3) +GL_MAP2_TEXTURE_COORD_2=_C('GL_MAP2_TEXTURE_COORD_2',0x0DB4) +GL_MAP2_TEXTURE_COORD_3=_C('GL_MAP2_TEXTURE_COORD_3',0x0DB5) +GL_MAP2_TEXTURE_COORD_4=_C('GL_MAP2_TEXTURE_COORD_4',0x0DB6) +GL_MAP2_VERTEX_3=_C('GL_MAP2_VERTEX_3',0x0DB7) +GL_MAP2_VERTEX_4=_C('GL_MAP2_VERTEX_4',0x0DB8) +GL_MAP_COLOR=_C('GL_MAP_COLOR',0x0D10) +GL_MAP_STENCIL=_C('GL_MAP_STENCIL',0x0D11) +GL_MATRIX_MODE=_C('GL_MATRIX_MODE',0x0BA0) +GL_MAX_ATTRIB_STACK_DEPTH=_C('GL_MAX_ATTRIB_STACK_DEPTH',0x0D35) +GL_MAX_CLIP_PLANES=_C('GL_MAX_CLIP_PLANES',0x0D32) +GL_MAX_EVAL_ORDER=_C('GL_MAX_EVAL_ORDER',0x0D30) +GL_MAX_LIGHTS=_C('GL_MAX_LIGHTS',0x0D31) +GL_MAX_LIST_NESTING=_C('GL_MAX_LIST_NESTING',0x0B31) +GL_MAX_MODELVIEW_STACK_DEPTH=_C('GL_MAX_MODELVIEW_STACK_DEPTH',0x0D36) +GL_MAX_NAME_STACK_DEPTH=_C('GL_MAX_NAME_STACK_DEPTH',0x0D37) +GL_MAX_PIXEL_MAP_TABLE=_C('GL_MAX_PIXEL_MAP_TABLE',0x0D34) +GL_MAX_PROJECTION_STACK_DEPTH=_C('GL_MAX_PROJECTION_STACK_DEPTH',0x0D38) +GL_MAX_TEXTURE_SIZE=_C('GL_MAX_TEXTURE_SIZE',0x0D33) +GL_MAX_TEXTURE_STACK_DEPTH=_C('GL_MAX_TEXTURE_STACK_DEPTH',0x0D39) +GL_MAX_VIEWPORT_DIMS=_C('GL_MAX_VIEWPORT_DIMS',0x0D3A) +GL_MODELVIEW=_C('GL_MODELVIEW',0x1700) +GL_MODELVIEW_MATRIX=_C('GL_MODELVIEW_MATRIX',0x0BA6) +GL_MODELVIEW_STACK_DEPTH=_C('GL_MODELVIEW_STACK_DEPTH',0x0BA3) +GL_MODULATE=_C('GL_MODULATE',0x2100) +GL_MULT=_C('GL_MULT',0x0103) +GL_NAME_STACK_DEPTH=_C('GL_NAME_STACK_DEPTH',0x0D70) +GL_NAND=_C('GL_NAND',0x150E) +GL_NEAREST=_C('GL_NEAREST',0x2600) +GL_NEAREST_MIPMAP_LINEAR=_C('GL_NEAREST_MIPMAP_LINEAR',0x2702) +GL_NEAREST_MIPMAP_NEAREST=_C('GL_NEAREST_MIPMAP_NEAREST',0x2700) +GL_NEVER=_C('GL_NEVER',0x0200) +GL_NICEST=_C('GL_NICEST',0x1102) +GL_NONE=_C('GL_NONE',0) +GL_NOOP=_C('GL_NOOP',0x1505) +GL_NOR=_C('GL_NOR',0x1508) +GL_NORMALIZE=_C('GL_NORMALIZE',0x0BA1) +GL_NOTEQUAL=_C('GL_NOTEQUAL',0x0205) +GL_NO_ERROR=_C('GL_NO_ERROR',0) +GL_OBJECT_LINEAR=_C('GL_OBJECT_LINEAR',0x2401) +GL_OBJECT_PLANE=_C('GL_OBJECT_PLANE',0x2501) +GL_ONE=_C('GL_ONE',1) +GL_ONE_MINUS_DST_ALPHA=_C('GL_ONE_MINUS_DST_ALPHA',0x0305) +GL_ONE_MINUS_DST_COLOR=_C('GL_ONE_MINUS_DST_COLOR',0x0307) +GL_ONE_MINUS_SRC_ALPHA=_C('GL_ONE_MINUS_SRC_ALPHA',0x0303) +GL_ONE_MINUS_SRC_COLOR=_C('GL_ONE_MINUS_SRC_COLOR',0x0301) +GL_OR=_C('GL_OR',0x1507) +GL_ORDER=_C('GL_ORDER',0x0A01) +GL_OR_INVERTED=_C('GL_OR_INVERTED',0x150D) +GL_OR_REVERSE=_C('GL_OR_REVERSE',0x150B) +GL_OUT_OF_MEMORY=_C('GL_OUT_OF_MEMORY',0x0505) +GL_PACK_ALIGNMENT=_C('GL_PACK_ALIGNMENT',0x0D05) +GL_PACK_LSB_FIRST=_C('GL_PACK_LSB_FIRST',0x0D01) +GL_PACK_ROW_LENGTH=_C('GL_PACK_ROW_LENGTH',0x0D02) +GL_PACK_SKIP_PIXELS=_C('GL_PACK_SKIP_PIXELS',0x0D04) +GL_PACK_SKIP_ROWS=_C('GL_PACK_SKIP_ROWS',0x0D03) +GL_PACK_SWAP_BYTES=_C('GL_PACK_SWAP_BYTES',0x0D00) +GL_PASS_THROUGH_TOKEN=_C('GL_PASS_THROUGH_TOKEN',0x0700) +GL_PERSPECTIVE_CORRECTION_HINT=_C('GL_PERSPECTIVE_CORRECTION_HINT',0x0C50) +GL_PIXEL_MAP_A_TO_A=_C('GL_PIXEL_MAP_A_TO_A',0x0C79) +GL_PIXEL_MAP_A_TO_A_SIZE=_C('GL_PIXEL_MAP_A_TO_A_SIZE',0x0CB9) +GL_PIXEL_MAP_B_TO_B=_C('GL_PIXEL_MAP_B_TO_B',0x0C78) +GL_PIXEL_MAP_B_TO_B_SIZE=_C('GL_PIXEL_MAP_B_TO_B_SIZE',0x0CB8) +GL_PIXEL_MAP_G_TO_G=_C('GL_PIXEL_MAP_G_TO_G',0x0C77) +GL_PIXEL_MAP_G_TO_G_SIZE=_C('GL_PIXEL_MAP_G_TO_G_SIZE',0x0CB7) +GL_PIXEL_MAP_I_TO_A=_C('GL_PIXEL_MAP_I_TO_A',0x0C75) +GL_PIXEL_MAP_I_TO_A_SIZE=_C('GL_PIXEL_MAP_I_TO_A_SIZE',0x0CB5) +GL_PIXEL_MAP_I_TO_B=_C('GL_PIXEL_MAP_I_TO_B',0x0C74) +GL_PIXEL_MAP_I_TO_B_SIZE=_C('GL_PIXEL_MAP_I_TO_B_SIZE',0x0CB4) +GL_PIXEL_MAP_I_TO_G=_C('GL_PIXEL_MAP_I_TO_G',0x0C73) +GL_PIXEL_MAP_I_TO_G_SIZE=_C('GL_PIXEL_MAP_I_TO_G_SIZE',0x0CB3) +GL_PIXEL_MAP_I_TO_I=_C('GL_PIXEL_MAP_I_TO_I',0x0C70) +GL_PIXEL_MAP_I_TO_I_SIZE=_C('GL_PIXEL_MAP_I_TO_I_SIZE',0x0CB0) +GL_PIXEL_MAP_I_TO_R=_C('GL_PIXEL_MAP_I_TO_R',0x0C72) +GL_PIXEL_MAP_I_TO_R_SIZE=_C('GL_PIXEL_MAP_I_TO_R_SIZE',0x0CB2) +GL_PIXEL_MAP_R_TO_R=_C('GL_PIXEL_MAP_R_TO_R',0x0C76) +GL_PIXEL_MAP_R_TO_R_SIZE=_C('GL_PIXEL_MAP_R_TO_R_SIZE',0x0CB6) +GL_PIXEL_MAP_S_TO_S=_C('GL_PIXEL_MAP_S_TO_S',0x0C71) +GL_PIXEL_MAP_S_TO_S_SIZE=_C('GL_PIXEL_MAP_S_TO_S_SIZE',0x0CB1) +GL_PIXEL_MODE_BIT=_C('GL_PIXEL_MODE_BIT',0x00000020) +GL_POINT=_C('GL_POINT',0x1B00) +GL_POINTS=_C('GL_POINTS',0x0000) +GL_POINT_BIT=_C('GL_POINT_BIT',0x00000002) +GL_POINT_SIZE=_C('GL_POINT_SIZE',0x0B11) +GL_POINT_SIZE_GRANULARITY=_C('GL_POINT_SIZE_GRANULARITY',0x0B13) +GL_POINT_SIZE_RANGE=_C('GL_POINT_SIZE_RANGE',0x0B12) +GL_POINT_SMOOTH=_C('GL_POINT_SMOOTH',0x0B10) +GL_POINT_SMOOTH_HINT=_C('GL_POINT_SMOOTH_HINT',0x0C51) +GL_POINT_TOKEN=_C('GL_POINT_TOKEN',0x0701) +GL_POLYGON=_C('GL_POLYGON',0x0009) +GL_POLYGON_BIT=_C('GL_POLYGON_BIT',0x00000008) +GL_POLYGON_MODE=_C('GL_POLYGON_MODE',0x0B40) +GL_POLYGON_SMOOTH=_C('GL_POLYGON_SMOOTH',0x0B41) +GL_POLYGON_SMOOTH_HINT=_C('GL_POLYGON_SMOOTH_HINT',0x0C53) +GL_POLYGON_STIPPLE=_C('GL_POLYGON_STIPPLE',0x0B42) +GL_POLYGON_STIPPLE_BIT=_C('GL_POLYGON_STIPPLE_BIT',0x00000010) +GL_POLYGON_TOKEN=_C('GL_POLYGON_TOKEN',0x0703) +GL_POSITION=_C('GL_POSITION',0x1203) +GL_PROJECTION=_C('GL_PROJECTION',0x1701) +GL_PROJECTION_MATRIX=_C('GL_PROJECTION_MATRIX',0x0BA7) +GL_PROJECTION_STACK_DEPTH=_C('GL_PROJECTION_STACK_DEPTH',0x0BA4) +GL_Q=_C('GL_Q',0x2003) +GL_QUADRATIC_ATTENUATION=_C('GL_QUADRATIC_ATTENUATION',0x1209) +GL_QUADS=_C('GL_QUADS',0x0007) +GL_QUAD_STRIP=_C('GL_QUAD_STRIP',0x0008) +GL_R=_C('GL_R',0x2002) +GL_READ_BUFFER=_C('GL_READ_BUFFER',0x0C02) +GL_RED=_C('GL_RED',0x1903) +GL_RED_BIAS=_C('GL_RED_BIAS',0x0D15) +GL_RED_BITS=_C('GL_RED_BITS',0x0D52) +GL_RED_SCALE=_C('GL_RED_SCALE',0x0D14) +GL_RENDER=_C('GL_RENDER',0x1C00) +GL_RENDERER=_C('GL_RENDERER',0x1F01) +GL_RENDER_MODE=_C('GL_RENDER_MODE',0x0C40) +GL_REPEAT=_C('GL_REPEAT',0x2901) +GL_REPLACE=_C('GL_REPLACE',0x1E01) +GL_RETURN=_C('GL_RETURN',0x0102) +GL_RGB=_C('GL_RGB',0x1907) +GL_RGBA=_C('GL_RGBA',0x1908) +GL_RGBA_MODE=_C('GL_RGBA_MODE',0x0C31) +GL_RIGHT=_C('GL_RIGHT',0x0407) +GL_S=_C('GL_S',0x2000) +GL_SCISSOR_BIT=_C('GL_SCISSOR_BIT',0x00080000) +GL_SCISSOR_BOX=_C('GL_SCISSOR_BOX',0x0C10) +GL_SCISSOR_TEST=_C('GL_SCISSOR_TEST',0x0C11) +GL_SELECT=_C('GL_SELECT',0x1C02) +GL_SET=_C('GL_SET',0x150F) +GL_SHADE_MODEL=_C('GL_SHADE_MODEL',0x0B54) +GL_SHININESS=_C('GL_SHININESS',0x1601) +GL_SHORT=_C('GL_SHORT',0x1402) +GL_SMOOTH=_C('GL_SMOOTH',0x1D01) +GL_SPECULAR=_C('GL_SPECULAR',0x1202) +GL_SPHERE_MAP=_C('GL_SPHERE_MAP',0x2402) +GL_SPOT_CUTOFF=_C('GL_SPOT_CUTOFF',0x1206) +GL_SPOT_DIRECTION=_C('GL_SPOT_DIRECTION',0x1204) +GL_SPOT_EXPONENT=_C('GL_SPOT_EXPONENT',0x1205) +GL_SRC_ALPHA=_C('GL_SRC_ALPHA',0x0302) +GL_SRC_ALPHA_SATURATE=_C('GL_SRC_ALPHA_SATURATE',0x0308) +GL_SRC_COLOR=_C('GL_SRC_COLOR',0x0300) +GL_STACK_OVERFLOW=_C('GL_STACK_OVERFLOW',0x0503) +GL_STACK_UNDERFLOW=_C('GL_STACK_UNDERFLOW',0x0504) +GL_STENCIL=_C('GL_STENCIL',0x1802) +GL_STENCIL_BITS=_C('GL_STENCIL_BITS',0x0D57) +GL_STENCIL_BUFFER_BIT=_C('GL_STENCIL_BUFFER_BIT',0x00000400) +GL_STENCIL_CLEAR_VALUE=_C('GL_STENCIL_CLEAR_VALUE',0x0B91) +GL_STENCIL_FAIL=_C('GL_STENCIL_FAIL',0x0B94) +GL_STENCIL_FUNC=_C('GL_STENCIL_FUNC',0x0B92) +GL_STENCIL_INDEX=_C('GL_STENCIL_INDEX',0x1901) +GL_STENCIL_PASS_DEPTH_FAIL=_C('GL_STENCIL_PASS_DEPTH_FAIL',0x0B95) +GL_STENCIL_PASS_DEPTH_PASS=_C('GL_STENCIL_PASS_DEPTH_PASS',0x0B96) +GL_STENCIL_REF=_C('GL_STENCIL_REF',0x0B97) +GL_STENCIL_TEST=_C('GL_STENCIL_TEST',0x0B90) +GL_STENCIL_VALUE_MASK=_C('GL_STENCIL_VALUE_MASK',0x0B93) +GL_STENCIL_WRITEMASK=_C('GL_STENCIL_WRITEMASK',0x0B98) +GL_STEREO=_C('GL_STEREO',0x0C33) +GL_SUBPIXEL_BITS=_C('GL_SUBPIXEL_BITS',0x0D50) +GL_T=_C('GL_T',0x2001) +GL_TEXTURE=_C('GL_TEXTURE',0x1702) +GL_TEXTURE_1D=_C('GL_TEXTURE_1D',0x0DE0) +GL_TEXTURE_2D=_C('GL_TEXTURE_2D',0x0DE1) +GL_TEXTURE_BIT=_C('GL_TEXTURE_BIT',0x00040000) +GL_TEXTURE_BORDER=_C('GL_TEXTURE_BORDER',0x1005) +GL_TEXTURE_BORDER_COLOR=_C('GL_TEXTURE_BORDER_COLOR',0x1004) +GL_TEXTURE_COMPONENTS=_C('GL_TEXTURE_COMPONENTS',0x1003) +GL_TEXTURE_ENV=_C('GL_TEXTURE_ENV',0x2300) +GL_TEXTURE_ENV_COLOR=_C('GL_TEXTURE_ENV_COLOR',0x2201) +GL_TEXTURE_ENV_MODE=_C('GL_TEXTURE_ENV_MODE',0x2200) +GL_TEXTURE_GEN_MODE=_C('GL_TEXTURE_GEN_MODE',0x2500) +GL_TEXTURE_GEN_Q=_C('GL_TEXTURE_GEN_Q',0x0C63) +GL_TEXTURE_GEN_R=_C('GL_TEXTURE_GEN_R',0x0C62) +GL_TEXTURE_GEN_S=_C('GL_TEXTURE_GEN_S',0x0C60) +GL_TEXTURE_GEN_T=_C('GL_TEXTURE_GEN_T',0x0C61) +GL_TEXTURE_HEIGHT=_C('GL_TEXTURE_HEIGHT',0x1001) +GL_TEXTURE_MAG_FILTER=_C('GL_TEXTURE_MAG_FILTER',0x2800) +GL_TEXTURE_MATRIX=_C('GL_TEXTURE_MATRIX',0x0BA8) +GL_TEXTURE_MIN_FILTER=_C('GL_TEXTURE_MIN_FILTER',0x2801) +GL_TEXTURE_STACK_DEPTH=_C('GL_TEXTURE_STACK_DEPTH',0x0BA5) +GL_TEXTURE_WIDTH=_C('GL_TEXTURE_WIDTH',0x1000) +GL_TEXTURE_WRAP_S=_C('GL_TEXTURE_WRAP_S',0x2802) +GL_TEXTURE_WRAP_T=_C('GL_TEXTURE_WRAP_T',0x2803) +GL_TRANSFORM_BIT=_C('GL_TRANSFORM_BIT',0x00001000) +GL_TRIANGLES=_C('GL_TRIANGLES',0x0004) +GL_TRIANGLE_FAN=_C('GL_TRIANGLE_FAN',0x0006) +GL_TRIANGLE_STRIP=_C('GL_TRIANGLE_STRIP',0x0005) +GL_TRUE=_C('GL_TRUE',1) +GL_UNPACK_ALIGNMENT=_C('GL_UNPACK_ALIGNMENT',0x0CF5) +GL_UNPACK_LSB_FIRST=_C('GL_UNPACK_LSB_FIRST',0x0CF1) +GL_UNPACK_ROW_LENGTH=_C('GL_UNPACK_ROW_LENGTH',0x0CF2) +GL_UNPACK_SKIP_PIXELS=_C('GL_UNPACK_SKIP_PIXELS',0x0CF4) +GL_UNPACK_SKIP_ROWS=_C('GL_UNPACK_SKIP_ROWS',0x0CF3) +GL_UNPACK_SWAP_BYTES=_C('GL_UNPACK_SWAP_BYTES',0x0CF0) +GL_UNSIGNED_BYTE=_C('GL_UNSIGNED_BYTE',0x1401) +GL_UNSIGNED_INT=_C('GL_UNSIGNED_INT',0x1405) +GL_UNSIGNED_SHORT=_C('GL_UNSIGNED_SHORT',0x1403) +GL_VENDOR=_C('GL_VENDOR',0x1F00) +GL_VERSION=_C('GL_VERSION',0x1F02) +GL_VIEWPORT=_C('GL_VIEWPORT',0x0BA2) +GL_VIEWPORT_BIT=_C('GL_VIEWPORT_BIT',0x00000800) +GL_XOR=_C('GL_XOR',0x1506) +GL_ZERO=_C('GL_ZERO',0) +GL_ZOOM_X=_C('GL_ZOOM_X',0x0D16) +GL_ZOOM_Y=_C('GL_ZOOM_Y',0x0D17) +@_f +@_p.types(None,_cs.GLenum,_cs.GLfloat) +def glAccum(op,value):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLfloat) +def glAlphaFunc(func,ref):pass +@_f +@_p.types(None,_cs.GLenum) +def glBegin(mode):pass +@_f +@_p.types(None,_cs.GLsizei,_cs.GLsizei,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,arrays.GLubyteArray) +def glBitmap(width,height,xorig,yorig,xmove,ymove,bitmap):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum) +def glBlendFunc(sfactor,dfactor):pass +@_f +@_p.types(None,_cs.GLuint) +def glCallList(list):pass +@_f +@_p.types(None,_cs.GLsizei,_cs.GLenum,ctypes.c_void_p) +def glCallLists(n,type,lists):pass +@_f +@_p.types(None,_cs.GLbitfield) +def glClear(mask):pass +@_f +@_p.types(None,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat) +def glClearAccum(red,green,blue,alpha):pass +@_f +@_p.types(None,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat) +def glClearColor(red,green,blue,alpha):pass +@_f +@_p.types(None,_cs.GLdouble) +def glClearDepth(depth):pass +@_f +@_p.types(None,_cs.GLfloat) +def glClearIndex(c):pass +@_f +@_p.types(None,_cs.GLint) +def glClearStencil(s):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLdoubleArray) +def glClipPlane(plane,equation):pass +@_f +@_p.types(None,_cs.GLbyte,_cs.GLbyte,_cs.GLbyte) +def glColor3b(red,green,blue):pass +@_f +@_p.types(None,arrays.GLbyteArray) +def glColor3bv(v):pass +@_f +@_p.types(None,_cs.GLdouble,_cs.GLdouble,_cs.GLdouble) +def glColor3d(red,green,blue):pass +@_f +@_p.types(None,arrays.GLdoubleArray) +def glColor3dv(v):pass +@_f +@_p.types(None,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat) +def glColor3f(red,green,blue):pass +@_f +@_p.types(None,arrays.GLfloatArray) +def glColor3fv(v):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLint,_cs.GLint) +def glColor3i(red,green,blue):pass +@_f +@_p.types(None,arrays.GLintArray) +def glColor3iv(v):pass +@_f +@_p.types(None,_cs.GLshort,_cs.GLshort,_cs.GLshort) +def glColor3s(red,green,blue):pass +@_f +@_p.types(None,arrays.GLshortArray) +def glColor3sv(v):pass +@_f +@_p.types(None,_cs.GLubyte,_cs.GLubyte,_cs.GLubyte) +def glColor3ub(red,green,blue):pass +@_f +@_p.types(None,arrays.GLubyteArray) +def glColor3ubv(v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLuint) +def glColor3ui(red,green,blue):pass +@_f +@_p.types(None,arrays.GLuintArray) +def glColor3uiv(v):pass +@_f +@_p.types(None,_cs.GLushort,_cs.GLushort,_cs.GLushort) +def glColor3us(red,green,blue):pass +@_f +@_p.types(None,arrays.GLushortArray) +def glColor3usv(v):pass +@_f +@_p.types(None,_cs.GLbyte,_cs.GLbyte,_cs.GLbyte,_cs.GLbyte) +def glColor4b(red,green,blue,alpha):pass +@_f +@_p.types(None,arrays.GLbyteArray) +def glColor4bv(v):pass +@_f +@_p.types(None,_cs.GLdouble,_cs.GLdouble,_cs.GLdouble,_cs.GLdouble) +def glColor4d(red,green,blue,alpha):pass +@_f +@_p.types(None,arrays.GLdoubleArray) +def glColor4dv(v):pass +@_f +@_p.types(None,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat) +def glColor4f(red,green,blue,alpha):pass +@_f +@_p.types(None,arrays.GLfloatArray) +def glColor4fv(v):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint) +def glColor4i(red,green,blue,alpha):pass +@_f +@_p.types(None,arrays.GLintArray) +def glColor4iv(v):pass +@_f +@_p.types(None,_cs.GLshort,_cs.GLshort,_cs.GLshort,_cs.GLshort) +def glColor4s(red,green,blue,alpha):pass +@_f +@_p.types(None,arrays.GLshortArray) +def glColor4sv(v):pass +@_f +@_p.types(None,_cs.GLubyte,_cs.GLubyte,_cs.GLubyte,_cs.GLubyte) +def glColor4ub(red,green,blue,alpha):pass +@_f +@_p.types(None,arrays.GLubyteArray) +def glColor4ubv(v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLuint,_cs.GLuint) +def glColor4ui(red,green,blue,alpha):pass +@_f +@_p.types(None,arrays.GLuintArray) +def glColor4uiv(v):pass +@_f +@_p.types(None,_cs.GLushort,_cs.GLushort,_cs.GLushort,_cs.GLushort) +def glColor4us(red,green,blue,alpha):pass +@_f +@_p.types(None,arrays.GLushortArray) +def glColor4usv(v):pass +@_f +@_p.types(None,_cs.GLboolean,_cs.GLboolean,_cs.GLboolean,_cs.GLboolean) +def glColorMask(red,green,blue,alpha):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum) +def glColorMaterial(face,mode):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLsizei,_cs.GLenum) +def glCopyPixels(x,y,width,height,type):pass +@_f +@_p.types(None,_cs.GLenum) +def glCullFace(mode):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizei) +def glDeleteLists(list,range):pass +@_f +@_p.types(None,_cs.GLenum) +def glDepthFunc(func):pass +@_f +@_p.types(None,_cs.GLboolean) +def glDepthMask(flag):pass +@_f +@_p.types(None,_cs.GLdouble,_cs.GLdouble) +def glDepthRange(n,f):pass +@_f +@_p.types(None,_cs.GLenum) +def glDisable(cap):pass +@_f +@_p.types(None,_cs.GLenum) +def glDrawBuffer(buf):pass +@_f +@_p.types(None,_cs.GLsizei,_cs.GLsizei,_cs.GLenum,_cs.GLenum,ctypes.c_void_p) +def glDrawPixels(width,height,format,type,pixels):pass +@_f +@_p.types(None,_cs.GLboolean) +def glEdgeFlag(flag):pass +@_f +@_p.types(None,arrays.GLbooleanArray) +def glEdgeFlagv(flag):pass +@_f +@_p.types(None,_cs.GLenum) +def glEnable(cap):pass +@_f +@_p.types(None,) +def glEnd():pass +@_f +@_p.types(None,) +def glEndList():pass +@_f +@_p.types(None,_cs.GLdouble) +def glEvalCoord1d(u):pass +@_f +@_p.types(None,arrays.GLdoubleArray) +def glEvalCoord1dv(u):pass +@_f +@_p.types(None,_cs.GLfloat) +def glEvalCoord1f(u):pass +@_f +@_p.types(None,arrays.GLfloatArray) +def glEvalCoord1fv(u):pass +@_f +@_p.types(None,_cs.GLdouble,_cs.GLdouble) +def glEvalCoord2d(u,v):pass +@_f +@_p.types(None,arrays.GLdoubleArray) +def glEvalCoord2dv(u):pass +@_f +@_p.types(None,_cs.GLfloat,_cs.GLfloat) +def glEvalCoord2f(u,v):pass +@_f +@_p.types(None,arrays.GLfloatArray) +def glEvalCoord2fv(u):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLint,_cs.GLint) +def glEvalMesh1(mode,i1,i2):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint) +def glEvalMesh2(mode,i1,i2,j1,j2):pass +@_f +@_p.types(None,_cs.GLint) +def glEvalPoint1(i):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLint) +def glEvalPoint2(i,j):pass +@_f +@_p.types(None,_cs.GLsizei,_cs.GLenum,arrays.GLfloatArray) +def glFeedbackBuffer(size,type,buffer):pass +@_f +@_p.types(None,) +def glFinish():pass +@_f +@_p.types(None,) +def glFlush():pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLfloat) +def glFogf(pname,param):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLfloatArray) +def glFogfv(pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLint) +def glFogi(pname,param):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLintArray) +def glFogiv(pname,params):pass +@_f +@_p.types(None,_cs.GLenum) +def glFrontFace(mode):pass +@_f +@_p.types(None,_cs.GLdouble,_cs.GLdouble,_cs.GLdouble,_cs.GLdouble,_cs.GLdouble,_cs.GLdouble) +def glFrustum(left,right,bottom,top,zNear,zFar):pass +@_f +@_p.types(_cs.GLuint,_cs.GLsizei) +def glGenLists(range):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLbooleanArray) +def glGetBooleanv(pname,data):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLdoubleArray) +def glGetClipPlane(plane,equation):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLdoubleArray) +def glGetDoublev(pname,data):pass +@_f +@_p.types(_cs.GLenum,) +def glGetError():pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLfloatArray) +def glGetFloatv(pname,data):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLintArray) +def glGetIntegerv(pname,data):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLfloatArray) +def glGetLightfv(light,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLintArray) +def glGetLightiv(light,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLdoubleArray) +def glGetMapdv(target,query,v):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLfloatArray) +def glGetMapfv(target,query,v):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLintArray) +def glGetMapiv(target,query,v):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLfloatArray) +def glGetMaterialfv(face,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLintArray) +def glGetMaterialiv(face,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLfloatArray) +def glGetPixelMapfv(map,values):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLuintArray) +def glGetPixelMapuiv(map,values):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLushortArray) +def glGetPixelMapusv(map,values):pass +@_f +@_p.types(None,arrays.GLubyteArray) +def glGetPolygonStipple(mask):pass +@_f +@_p.types(arrays.GLubyteArray,_cs.GLenum) +def glGetString(name):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLfloatArray) +def glGetTexEnvfv(target,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLintArray) +def glGetTexEnviv(target,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLdoubleArray) +def glGetTexGendv(coord,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLfloatArray) +def glGetTexGenfv(coord,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLintArray) +def glGetTexGeniv(coord,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLint,_cs.GLenum,_cs.GLenum,ctypes.c_void_p) +def glGetTexImage(target,level,format,type,pixels):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLint,_cs.GLenum,arrays.GLfloatArray) +def glGetTexLevelParameterfv(target,level,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLint,_cs.GLenum,arrays.GLintArray) +def glGetTexLevelParameteriv(target,level,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLfloatArray) +def glGetTexParameterfv(target,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLintArray) +def glGetTexParameteriv(target,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum) +def glHint(target,mode):pass +@_f +@_p.types(None,_cs.GLuint) +def glIndexMask(mask):pass +@_f +@_p.types(None,_cs.GLdouble) +def glIndexd(c):pass +@_f +@_p.types(None,arrays.GLdoubleArray) +def glIndexdv(c):pass +@_f +@_p.types(None,_cs.GLfloat) +def glIndexf(c):pass +@_f +@_p.types(None,arrays.GLfloatArray) +def glIndexfv(c):pass +@_f +@_p.types(None,_cs.GLint) +def glIndexi(c):pass +@_f +@_p.types(None,arrays.GLintArray) +def glIndexiv(c):pass +@_f +@_p.types(None,_cs.GLshort) +def glIndexs(c):pass +@_f +@_p.types(None,arrays.GLshortArray) +def glIndexsv(c):pass +@_f +@_p.types(None,) +def glInitNames():pass +@_f +@_p.types(_cs.GLboolean,_cs.GLenum) +def glIsEnabled(cap):pass +@_f +@_p.types(_cs.GLboolean,_cs.GLuint) +def glIsList(list):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLfloat) +def glLightModelf(pname,param):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLfloatArray) +def glLightModelfv(pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLint) +def glLightModeli(pname,param):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLintArray) +def glLightModeliv(pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLfloat) +def glLightf(light,pname,param):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLfloatArray) +def glLightfv(light,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLint) +def glLighti(light,pname,param):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLintArray) +def glLightiv(light,pname,params):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLushort) +def glLineStipple(factor,pattern):pass +@_f +@_p.types(None,_cs.GLfloat) +def glLineWidth(width):pass +@_f +@_p.types(None,_cs.GLuint) +def glListBase(base):pass +@_f +@_p.types(None,) +def glLoadIdentity():pass +@_f +@_p.types(None,arrays.GLdoubleArray) +def glLoadMatrixd(m):pass +@_f +@_p.types(None,arrays.GLfloatArray) +def glLoadMatrixf(m):pass +@_f +@_p.types(None,_cs.GLuint) +def glLoadName(name):pass +@_f +@_p.types(None,_cs.GLenum) +def glLogicOp(opcode):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLdouble,_cs.GLdouble,_cs.GLint,_cs.GLint,arrays.GLdoubleArray) +def glMap1d(target,u1,u2,stride,order,points):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLfloat,_cs.GLfloat,_cs.GLint,_cs.GLint,arrays.GLfloatArray) +def glMap1f(target,u1,u2,stride,order,points):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLdouble,_cs.GLdouble,_cs.GLint,_cs.GLint,_cs.GLdouble,_cs.GLdouble,_cs.GLint,_cs.GLint,arrays.GLdoubleArray) +def glMap2d(target,u1,u2,ustride,uorder,v1,v2,vstride,vorder,points):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLfloat,_cs.GLfloat,_cs.GLint,_cs.GLint,_cs.GLfloat,_cs.GLfloat,_cs.GLint,_cs.GLint,arrays.GLfloatArray) +def glMap2f(target,u1,u2,ustride,uorder,v1,v2,vstride,vorder,points):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLdouble,_cs.GLdouble) +def glMapGrid1d(un,u1,u2):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLfloat,_cs.GLfloat) +def glMapGrid1f(un,u1,u2):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLdouble,_cs.GLdouble,_cs.GLint,_cs.GLdouble,_cs.GLdouble) +def glMapGrid2d(un,u1,u2,vn,v1,v2):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLfloat,_cs.GLfloat,_cs.GLint,_cs.GLfloat,_cs.GLfloat) +def glMapGrid2f(un,u1,u2,vn,v1,v2):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLfloat) +def glMaterialf(face,pname,param):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLfloatArray) +def glMaterialfv(face,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLint) +def glMateriali(face,pname,param):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLintArray) +def glMaterialiv(face,pname,params):pass +@_f +@_p.types(None,_cs.GLenum) +def glMatrixMode(mode):pass +@_f +@_p.types(None,arrays.GLdoubleArray) +def glMultMatrixd(m):pass +@_f +@_p.types(None,arrays.GLfloatArray) +def glMultMatrixf(m):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum) +def glNewList(list,mode):pass +@_f +@_p.types(None,_cs.GLbyte,_cs.GLbyte,_cs.GLbyte) +def glNormal3b(nx,ny,nz):pass +@_f +@_p.types(None,arrays.GLbyteArray) +def glNormal3bv(v):pass +@_f +@_p.types(None,_cs.GLdouble,_cs.GLdouble,_cs.GLdouble) +def glNormal3d(nx,ny,nz):pass +@_f +@_p.types(None,arrays.GLdoubleArray) +def glNormal3dv(v):pass +@_f +@_p.types(None,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat) +def glNormal3f(nx,ny,nz):pass +@_f +@_p.types(None,arrays.GLfloatArray) +def glNormal3fv(v):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLint,_cs.GLint) +def glNormal3i(nx,ny,nz):pass +@_f +@_p.types(None,arrays.GLintArray) +def glNormal3iv(v):pass +@_f +@_p.types(None,_cs.GLshort,_cs.GLshort,_cs.GLshort) +def glNormal3s(nx,ny,nz):pass +@_f +@_p.types(None,arrays.GLshortArray) +def glNormal3sv(v):pass +@_f +@_p.types(None,_cs.GLdouble,_cs.GLdouble,_cs.GLdouble,_cs.GLdouble,_cs.GLdouble,_cs.GLdouble) +def glOrtho(left,right,bottom,top,zNear,zFar):pass +@_f +@_p.types(None,_cs.GLfloat) +def glPassThrough(token):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizei,arrays.GLfloatArray) +def glPixelMapfv(map,mapsize,values):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizei,arrays.GLuintArray) +def glPixelMapuiv(map,mapsize,values):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizei,arrays.GLushortArray) +def glPixelMapusv(map,mapsize,values):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLfloat) +def glPixelStoref(pname,param):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLint) +def glPixelStorei(pname,param):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLfloat) +def glPixelTransferf(pname,param):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLint) +def glPixelTransferi(pname,param):pass +@_f +@_p.types(None,_cs.GLfloat,_cs.GLfloat) +def glPixelZoom(xfactor,yfactor):pass +@_f +@_p.types(None,_cs.GLfloat) +def glPointSize(size):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum) +def glPolygonMode(face,mode):pass +@_f +@_p.types(None,arrays.GLubyteArray) +def glPolygonStipple(mask):pass +@_f +@_p.types(None,) +def glPopAttrib():pass +@_f +@_p.types(None,) +def glPopMatrix():pass +@_f +@_p.types(None,) +def glPopName():pass +@_f +@_p.types(None,_cs.GLbitfield) +def glPushAttrib(mask):pass +@_f +@_p.types(None,) +def glPushMatrix():pass +@_f +@_p.types(None,_cs.GLuint) +def glPushName(name):pass +@_f +@_p.types(None,_cs.GLdouble,_cs.GLdouble) +def glRasterPos2d(x,y):pass +@_f +@_p.types(None,arrays.GLdoubleArray) +def glRasterPos2dv(v):pass +@_f +@_p.types(None,_cs.GLfloat,_cs.GLfloat) +def glRasterPos2f(x,y):pass +@_f +@_p.types(None,arrays.GLfloatArray) +def glRasterPos2fv(v):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLint) +def glRasterPos2i(x,y):pass +@_f +@_p.types(None,arrays.GLintArray) +def glRasterPos2iv(v):pass +@_f +@_p.types(None,_cs.GLshort,_cs.GLshort) +def glRasterPos2s(x,y):pass +@_f +@_p.types(None,arrays.GLshortArray) +def glRasterPos2sv(v):pass +@_f +@_p.types(None,_cs.GLdouble,_cs.GLdouble,_cs.GLdouble) +def glRasterPos3d(x,y,z):pass +@_f +@_p.types(None,arrays.GLdoubleArray) +def glRasterPos3dv(v):pass +@_f +@_p.types(None,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat) +def glRasterPos3f(x,y,z):pass +@_f +@_p.types(None,arrays.GLfloatArray) +def glRasterPos3fv(v):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLint,_cs.GLint) +def glRasterPos3i(x,y,z):pass +@_f +@_p.types(None,arrays.GLintArray) +def glRasterPos3iv(v):pass +@_f +@_p.types(None,_cs.GLshort,_cs.GLshort,_cs.GLshort) +def glRasterPos3s(x,y,z):pass +@_f +@_p.types(None,arrays.GLshortArray) +def glRasterPos3sv(v):pass +@_f +@_p.types(None,_cs.GLdouble,_cs.GLdouble,_cs.GLdouble,_cs.GLdouble) +def glRasterPos4d(x,y,z,w):pass +@_f +@_p.types(None,arrays.GLdoubleArray) +def glRasterPos4dv(v):pass +@_f +@_p.types(None,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat) +def glRasterPos4f(x,y,z,w):pass +@_f +@_p.types(None,arrays.GLfloatArray) +def glRasterPos4fv(v):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint) +def glRasterPos4i(x,y,z,w):pass +@_f +@_p.types(None,arrays.GLintArray) +def glRasterPos4iv(v):pass +@_f +@_p.types(None,_cs.GLshort,_cs.GLshort,_cs.GLshort,_cs.GLshort) +def glRasterPos4s(x,y,z,w):pass +@_f +@_p.types(None,arrays.GLshortArray) +def glRasterPos4sv(v):pass +@_f +@_p.types(None,_cs.GLenum) +def glReadBuffer(src):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLsizei,_cs.GLenum,_cs.GLenum,ctypes.c_void_p) +def glReadPixels(x,y,width,height,format,type,pixels):pass +@_f +@_p.types(None,_cs.GLdouble,_cs.GLdouble,_cs.GLdouble,_cs.GLdouble) +def glRectd(x1,y1,x2,y2):pass +@_f +@_p.types(None,arrays.GLdoubleArray,arrays.GLdoubleArray) +def glRectdv(v1,v2):pass +@_f +@_p.types(None,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat) +def glRectf(x1,y1,x2,y2):pass +@_f +@_p.types(None,arrays.GLfloatArray,arrays.GLfloatArray) +def glRectfv(v1,v2):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint) +def glRecti(x1,y1,x2,y2):pass +@_f +@_p.types(None,arrays.GLintArray,arrays.GLintArray) +def glRectiv(v1,v2):pass +@_f +@_p.types(None,_cs.GLshort,_cs.GLshort,_cs.GLshort,_cs.GLshort) +def glRects(x1,y1,x2,y2):pass +@_f +@_p.types(None,arrays.GLshortArray,arrays.GLshortArray) +def glRectsv(v1,v2):pass +@_f +@_p.types(_cs.GLint,_cs.GLenum) +def glRenderMode(mode):pass +@_f +@_p.types(None,_cs.GLdouble,_cs.GLdouble,_cs.GLdouble,_cs.GLdouble) +def glRotated(angle,x,y,z):pass +@_f +@_p.types(None,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat) +def glRotatef(angle,x,y,z):pass +@_f +@_p.types(None,_cs.GLdouble,_cs.GLdouble,_cs.GLdouble) +def glScaled(x,y,z):pass +@_f +@_p.types(None,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat) +def glScalef(x,y,z):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLsizei) +def glScissor(x,y,width,height):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray) +def glSelectBuffer(size,buffer):pass +@_f +@_p.types(None,_cs.GLenum) +def glShadeModel(mode):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLint,_cs.GLuint) +def glStencilFunc(func,ref,mask):pass +@_f +@_p.types(None,_cs.GLuint) +def glStencilMask(mask):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLenum) +def glStencilOp(fail,zfail,zpass):pass +@_f +@_p.types(None,_cs.GLdouble) +def glTexCoord1d(s):pass +@_f +@_p.types(None,arrays.GLdoubleArray) +def glTexCoord1dv(v):pass +@_f +@_p.types(None,_cs.GLfloat) +def glTexCoord1f(s):pass +@_f +@_p.types(None,arrays.GLfloatArray) +def glTexCoord1fv(v):pass +@_f +@_p.types(None,_cs.GLint) +def glTexCoord1i(s):pass +@_f +@_p.types(None,arrays.GLintArray) +def glTexCoord1iv(v):pass +@_f +@_p.types(None,_cs.GLshort) +def glTexCoord1s(s):pass +@_f +@_p.types(None,arrays.GLshortArray) +def glTexCoord1sv(v):pass +@_f +@_p.types(None,_cs.GLdouble,_cs.GLdouble) +def glTexCoord2d(s,t):pass +@_f +@_p.types(None,arrays.GLdoubleArray) +def glTexCoord2dv(v):pass +@_f +@_p.types(None,_cs.GLfloat,_cs.GLfloat) +def glTexCoord2f(s,t):pass +@_f +@_p.types(None,arrays.GLfloatArray) +def glTexCoord2fv(v):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLint) +def glTexCoord2i(s,t):pass +@_f +@_p.types(None,arrays.GLintArray) +def glTexCoord2iv(v):pass +@_f +@_p.types(None,_cs.GLshort,_cs.GLshort) +def glTexCoord2s(s,t):pass +@_f +@_p.types(None,arrays.GLshortArray) +def glTexCoord2sv(v):pass +@_f +@_p.types(None,_cs.GLdouble,_cs.GLdouble,_cs.GLdouble) +def glTexCoord3d(s,t,r):pass +@_f +@_p.types(None,arrays.GLdoubleArray) +def glTexCoord3dv(v):pass +@_f +@_p.types(None,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat) +def glTexCoord3f(s,t,r):pass +@_f +@_p.types(None,arrays.GLfloatArray) +def glTexCoord3fv(v):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLint,_cs.GLint) +def glTexCoord3i(s,t,r):pass +@_f +@_p.types(None,arrays.GLintArray) +def glTexCoord3iv(v):pass +@_f +@_p.types(None,_cs.GLshort,_cs.GLshort,_cs.GLshort) +def glTexCoord3s(s,t,r):pass +@_f +@_p.types(None,arrays.GLshortArray) +def glTexCoord3sv(v):pass +@_f +@_p.types(None,_cs.GLdouble,_cs.GLdouble,_cs.GLdouble,_cs.GLdouble) +def glTexCoord4d(s,t,r,q):pass +@_f +@_p.types(None,arrays.GLdoubleArray) +def glTexCoord4dv(v):pass +@_f +@_p.types(None,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat) +def glTexCoord4f(s,t,r,q):pass +@_f +@_p.types(None,arrays.GLfloatArray) +def glTexCoord4fv(v):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint) +def glTexCoord4i(s,t,r,q):pass +@_f +@_p.types(None,arrays.GLintArray) +def glTexCoord4iv(v):pass +@_f +@_p.types(None,_cs.GLshort,_cs.GLshort,_cs.GLshort,_cs.GLshort) +def glTexCoord4s(s,t,r,q):pass +@_f +@_p.types(None,arrays.GLshortArray) +def glTexCoord4sv(v):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLfloat) +def glTexEnvf(target,pname,param):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLfloatArray) +def glTexEnvfv(target,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLint) +def glTexEnvi(target,pname,param):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLintArray) +def glTexEnviv(target,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLdouble) +def glTexGend(coord,pname,param):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLdoubleArray) +def glTexGendv(coord,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLfloat) +def glTexGenf(coord,pname,param):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLfloatArray) +def glTexGenfv(coord,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLint) +def glTexGeni(coord,pname,param):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLintArray) +def glTexGeniv(coord,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLint,_cs.GLenum,_cs.GLenum,ctypes.c_void_p) +def glTexImage1D(target,level,internalformat,width,border,format,type,pixels):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLsizei,_cs.GLint,_cs.GLenum,_cs.GLenum,ctypes.c_void_p) +def glTexImage2D(target,level,internalformat,width,height,border,format,type,pixels):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLfloat) +def glTexParameterf(target,pname,param):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLfloatArray) +def glTexParameterfv(target,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLint) +def glTexParameteri(target,pname,param):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLintArray) +def glTexParameteriv(target,pname,params):pass +@_f +@_p.types(None,_cs.GLdouble,_cs.GLdouble,_cs.GLdouble) +def glTranslated(x,y,z):pass +@_f +@_p.types(None,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat) +def glTranslatef(x,y,z):pass +@_f +@_p.types(None,_cs.GLdouble,_cs.GLdouble) +def glVertex2d(x,y):pass +@_f +@_p.types(None,arrays.GLdoubleArray) +def glVertex2dv(v):pass +@_f +@_p.types(None,_cs.GLfloat,_cs.GLfloat) +def glVertex2f(x,y):pass +@_f +@_p.types(None,arrays.GLfloatArray) +def glVertex2fv(v):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLint) +def glVertex2i(x,y):pass +@_f +@_p.types(None,arrays.GLintArray) +def glVertex2iv(v):pass +@_f +@_p.types(None,_cs.GLshort,_cs.GLshort) +def glVertex2s(x,y):pass +@_f +@_p.types(None,arrays.GLshortArray) +def glVertex2sv(v):pass +@_f +@_p.types(None,_cs.GLdouble,_cs.GLdouble,_cs.GLdouble) +def glVertex3d(x,y,z):pass +@_f +@_p.types(None,arrays.GLdoubleArray) +def glVertex3dv(v):pass +@_f +@_p.types(None,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat) +def glVertex3f(x,y,z):pass +@_f +@_p.types(None,arrays.GLfloatArray) +def glVertex3fv(v):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLint,_cs.GLint) +def glVertex3i(x,y,z):pass +@_f +@_p.types(None,arrays.GLintArray) +def glVertex3iv(v):pass +@_f +@_p.types(None,_cs.GLshort,_cs.GLshort,_cs.GLshort) +def glVertex3s(x,y,z):pass +@_f +@_p.types(None,arrays.GLshortArray) +def glVertex3sv(v):pass +@_f +@_p.types(None,_cs.GLdouble,_cs.GLdouble,_cs.GLdouble,_cs.GLdouble) +def glVertex4d(x,y,z,w):pass +@_f +@_p.types(None,arrays.GLdoubleArray) +def glVertex4dv(v):pass +@_f +@_p.types(None,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat) +def glVertex4f(x,y,z,w):pass +@_f +@_p.types(None,arrays.GLfloatArray) +def glVertex4fv(v):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint) +def glVertex4i(x,y,z,w):pass +@_f +@_p.types(None,arrays.GLintArray) +def glVertex4iv(v):pass +@_f +@_p.types(None,_cs.GLshort,_cs.GLshort,_cs.GLshort,_cs.GLshort) +def glVertex4s(x,y,z,w):pass +@_f +@_p.types(None,arrays.GLshortArray) +def glVertex4sv(v):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLsizei) +def glViewport(x,y,width,height):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/VERSION/GL_1_1.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/VERSION/GL_1_1.py new file mode 100644 index 00000000..a14250ed --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/VERSION/GL_1_1.py @@ -0,0 +1,208 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C +# Spec mixes constants from 1.0 and 1.1 +from OpenGL.raw.GL.VERSION.GL_1_0 import * +import ctypes +_EXTENSION_NAME = 'GL_VERSION_GL_1_1' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_VERSION_GL_1_1',error_checker=_errors._error_checker) +GL_ALPHA12=_C('GL_ALPHA12',0x803D) +GL_ALPHA16=_C('GL_ALPHA16',0x803E) +GL_ALPHA4=_C('GL_ALPHA4',0x803B) +GL_ALPHA8=_C('GL_ALPHA8',0x803C) +GL_C3F_V3F=_C('GL_C3F_V3F',0x2A24) +GL_C4F_N3F_V3F=_C('GL_C4F_N3F_V3F',0x2A26) +GL_C4UB_V2F=_C('GL_C4UB_V2F',0x2A22) +GL_C4UB_V3F=_C('GL_C4UB_V3F',0x2A23) +GL_CLIENT_ALL_ATTRIB_BITS=_C('GL_CLIENT_ALL_ATTRIB_BITS',0xFFFFFFFF) +GL_CLIENT_ATTRIB_STACK_DEPTH=_C('GL_CLIENT_ATTRIB_STACK_DEPTH',0x0BB1) +GL_CLIENT_PIXEL_STORE_BIT=_C('GL_CLIENT_PIXEL_STORE_BIT',0x00000001) +GL_CLIENT_VERTEX_ARRAY_BIT=_C('GL_CLIENT_VERTEX_ARRAY_BIT',0x00000002) +GL_COLOR_ARRAY=_C('GL_COLOR_ARRAY',0x8076) +GL_COLOR_ARRAY_POINTER=_C('GL_COLOR_ARRAY_POINTER',0x8090) +GL_COLOR_ARRAY_SIZE=_C('GL_COLOR_ARRAY_SIZE',0x8081) +GL_COLOR_ARRAY_STRIDE=_C('GL_COLOR_ARRAY_STRIDE',0x8083) +GL_COLOR_ARRAY_TYPE=_C('GL_COLOR_ARRAY_TYPE',0x8082) +GL_COLOR_LOGIC_OP=_C('GL_COLOR_LOGIC_OP',0x0BF2) +GL_DOUBLE=_C('GL_DOUBLE',0x140A) +GL_EDGE_FLAG_ARRAY=_C('GL_EDGE_FLAG_ARRAY',0x8079) +GL_EDGE_FLAG_ARRAY_POINTER=_C('GL_EDGE_FLAG_ARRAY_POINTER',0x8093) +GL_EDGE_FLAG_ARRAY_STRIDE=_C('GL_EDGE_FLAG_ARRAY_STRIDE',0x808C) +GL_FEEDBACK_BUFFER_POINTER=_C('GL_FEEDBACK_BUFFER_POINTER',0x0DF0) +GL_FEEDBACK_BUFFER_SIZE=_C('GL_FEEDBACK_BUFFER_SIZE',0x0DF1) +GL_FEEDBACK_BUFFER_TYPE=_C('GL_FEEDBACK_BUFFER_TYPE',0x0DF2) +GL_INDEX_ARRAY=_C('GL_INDEX_ARRAY',0x8077) +GL_INDEX_ARRAY_POINTER=_C('GL_INDEX_ARRAY_POINTER',0x8091) +GL_INDEX_ARRAY_STRIDE=_C('GL_INDEX_ARRAY_STRIDE',0x8086) +GL_INDEX_ARRAY_TYPE=_C('GL_INDEX_ARRAY_TYPE',0x8085) +GL_INDEX_LOGIC_OP=_C('GL_INDEX_LOGIC_OP',0x0BF1) +GL_INTENSITY=_C('GL_INTENSITY',0x8049) +GL_INTENSITY12=_C('GL_INTENSITY12',0x804C) +GL_INTENSITY16=_C('GL_INTENSITY16',0x804D) +GL_INTENSITY4=_C('GL_INTENSITY4',0x804A) +GL_INTENSITY8=_C('GL_INTENSITY8',0x804B) +GL_LUMINANCE12=_C('GL_LUMINANCE12',0x8041) +GL_LUMINANCE12_ALPHA12=_C('GL_LUMINANCE12_ALPHA12',0x8047) +GL_LUMINANCE12_ALPHA4=_C('GL_LUMINANCE12_ALPHA4',0x8046) +GL_LUMINANCE16=_C('GL_LUMINANCE16',0x8042) +GL_LUMINANCE16_ALPHA16=_C('GL_LUMINANCE16_ALPHA16',0x8048) +GL_LUMINANCE4=_C('GL_LUMINANCE4',0x803F) +GL_LUMINANCE4_ALPHA4=_C('GL_LUMINANCE4_ALPHA4',0x8043) +GL_LUMINANCE6_ALPHA2=_C('GL_LUMINANCE6_ALPHA2',0x8044) +GL_LUMINANCE8=_C('GL_LUMINANCE8',0x8040) +GL_LUMINANCE8_ALPHA8=_C('GL_LUMINANCE8_ALPHA8',0x8045) +GL_MAX_CLIENT_ATTRIB_STACK_DEPTH=_C('GL_MAX_CLIENT_ATTRIB_STACK_DEPTH',0x0D3B) +GL_N3F_V3F=_C('GL_N3F_V3F',0x2A25) +GL_NORMAL_ARRAY=_C('GL_NORMAL_ARRAY',0x8075) +GL_NORMAL_ARRAY_POINTER=_C('GL_NORMAL_ARRAY_POINTER',0x808F) +GL_NORMAL_ARRAY_STRIDE=_C('GL_NORMAL_ARRAY_STRIDE',0x807F) +GL_NORMAL_ARRAY_TYPE=_C('GL_NORMAL_ARRAY_TYPE',0x807E) +GL_POLYGON_OFFSET_FACTOR=_C('GL_POLYGON_OFFSET_FACTOR',0x8038) +GL_POLYGON_OFFSET_FILL=_C('GL_POLYGON_OFFSET_FILL',0x8037) +GL_POLYGON_OFFSET_LINE=_C('GL_POLYGON_OFFSET_LINE',0x2A02) +GL_POLYGON_OFFSET_POINT=_C('GL_POLYGON_OFFSET_POINT',0x2A01) +GL_POLYGON_OFFSET_UNITS=_C('GL_POLYGON_OFFSET_UNITS',0x2A00) +GL_PROXY_TEXTURE_1D=_C('GL_PROXY_TEXTURE_1D',0x8063) +GL_PROXY_TEXTURE_2D=_C('GL_PROXY_TEXTURE_2D',0x8064) +GL_R3_G3_B2=_C('GL_R3_G3_B2',0x2A10) +GL_RGB10=_C('GL_RGB10',0x8052) +GL_RGB10_A2=_C('GL_RGB10_A2',0x8059) +GL_RGB12=_C('GL_RGB12',0x8053) +GL_RGB16=_C('GL_RGB16',0x8054) +GL_RGB4=_C('GL_RGB4',0x804F) +GL_RGB5=_C('GL_RGB5',0x8050) +GL_RGB5_A1=_C('GL_RGB5_A1',0x8057) +GL_RGB8=_C('GL_RGB8',0x8051) +GL_RGBA12=_C('GL_RGBA12',0x805A) +GL_RGBA16=_C('GL_RGBA16',0x805B) +GL_RGBA2=_C('GL_RGBA2',0x8055) +GL_RGBA4=_C('GL_RGBA4',0x8056) +GL_RGBA8=_C('GL_RGBA8',0x8058) +GL_SELECTION_BUFFER_POINTER=_C('GL_SELECTION_BUFFER_POINTER',0x0DF3) +GL_SELECTION_BUFFER_SIZE=_C('GL_SELECTION_BUFFER_SIZE',0x0DF4) +GL_T2F_C3F_V3F=_C('GL_T2F_C3F_V3F',0x2A2A) +GL_T2F_C4F_N3F_V3F=_C('GL_T2F_C4F_N3F_V3F',0x2A2C) +GL_T2F_C4UB_V3F=_C('GL_T2F_C4UB_V3F',0x2A29) +GL_T2F_N3F_V3F=_C('GL_T2F_N3F_V3F',0x2A2B) +GL_T2F_V3F=_C('GL_T2F_V3F',0x2A27) +GL_T4F_C4F_N3F_V4F=_C('GL_T4F_C4F_N3F_V4F',0x2A2D) +GL_T4F_V4F=_C('GL_T4F_V4F',0x2A28) +GL_TEXTURE_ALPHA_SIZE=_C('GL_TEXTURE_ALPHA_SIZE',0x805F) +GL_TEXTURE_BINDING_1D=_C('GL_TEXTURE_BINDING_1D',0x8068) +GL_TEXTURE_BINDING_2D=_C('GL_TEXTURE_BINDING_2D',0x8069) +GL_TEXTURE_BLUE_SIZE=_C('GL_TEXTURE_BLUE_SIZE',0x805E) +GL_TEXTURE_COORD_ARRAY=_C('GL_TEXTURE_COORD_ARRAY',0x8078) +GL_TEXTURE_COORD_ARRAY_POINTER=_C('GL_TEXTURE_COORD_ARRAY_POINTER',0x8092) +GL_TEXTURE_COORD_ARRAY_SIZE=_C('GL_TEXTURE_COORD_ARRAY_SIZE',0x8088) +GL_TEXTURE_COORD_ARRAY_STRIDE=_C('GL_TEXTURE_COORD_ARRAY_STRIDE',0x808A) +GL_TEXTURE_COORD_ARRAY_TYPE=_C('GL_TEXTURE_COORD_ARRAY_TYPE',0x8089) +GL_TEXTURE_GREEN_SIZE=_C('GL_TEXTURE_GREEN_SIZE',0x805D) +GL_TEXTURE_INTENSITY_SIZE=_C('GL_TEXTURE_INTENSITY_SIZE',0x8061) +GL_TEXTURE_INTERNAL_FORMAT=_C('GL_TEXTURE_INTERNAL_FORMAT',0x1003) +GL_TEXTURE_LUMINANCE_SIZE=_C('GL_TEXTURE_LUMINANCE_SIZE',0x8060) +GL_TEXTURE_PRIORITY=_C('GL_TEXTURE_PRIORITY',0x8066) +GL_TEXTURE_RED_SIZE=_C('GL_TEXTURE_RED_SIZE',0x805C) +GL_TEXTURE_RESIDENT=_C('GL_TEXTURE_RESIDENT',0x8067) +GL_V2F=_C('GL_V2F',0x2A20) +GL_V3F=_C('GL_V3F',0x2A21) +GL_VERTEX_ARRAY=_C('GL_VERTEX_ARRAY',0x8074) +GL_VERTEX_ARRAY_POINTER=_C('GL_VERTEX_ARRAY_POINTER',0x808E) +GL_VERTEX_ARRAY_SIZE=_C('GL_VERTEX_ARRAY_SIZE',0x807A) +GL_VERTEX_ARRAY_STRIDE=_C('GL_VERTEX_ARRAY_STRIDE',0x807C) +GL_VERTEX_ARRAY_TYPE=_C('GL_VERTEX_ARRAY_TYPE',0x807B) +@_f +@_p.types(_cs.GLboolean,_cs.GLsizei,arrays.GLuintArray,arrays.GLbooleanArray) +def glAreTexturesResident(n,textures,residences):pass +@_f +@_p.types(None,_cs.GLint) +def glArrayElement(i):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint) +def glBindTexture(target,texture):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLenum,_cs.GLsizei,ctypes.c_void_p) +def glColorPointer(size,type,stride,pointer):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLint,_cs.GLenum,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLint) +def glCopyTexImage1D(target,level,internalformat,x,y,width,border):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLint,_cs.GLenum,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLsizei,_cs.GLint) +def glCopyTexImage2D(target,level,internalformat,x,y,width,height,border):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLsizei) +def glCopyTexSubImage1D(target,level,xoffset,x,y,width):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLsizei) +def glCopyTexSubImage2D(target,level,xoffset,yoffset,x,y,width,height):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray) +def glDeleteTextures(n,textures):pass +@_f +@_p.types(None,_cs.GLenum) +def glDisableClientState(array):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLint,_cs.GLsizei) +def glDrawArrays(mode,first,count):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizei,_cs.GLenum,ctypes.c_void_p) +def glDrawElements(mode,count,type,indices):pass +@_f +@_p.types(None,_cs.GLsizei,ctypes.c_void_p) +def glEdgeFlagPointer(stride,pointer):pass +@_f +@_p.types(None,_cs.GLenum) +def glEnableClientState(array):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray) +def glGenTextures(n,textures):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLvoidpArray) +def glGetPointerv(pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizei,ctypes.c_void_p) +def glIndexPointer(type,stride,pointer):pass +@_f +@_p.types(None,_cs.GLubyte) +def glIndexub(c):pass +@_f +@_p.types(None,arrays.GLubyteArray) +def glIndexubv(c):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizei,ctypes.c_void_p) +def glInterleavedArrays(format,stride,pointer):pass +@_f +@_p.types(_cs.GLboolean,_cs.GLuint) +def glIsTexture(texture):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizei,ctypes.c_void_p) +def glNormalPointer(type,stride,pointer):pass +@_f +@_p.types(None,_cs.GLfloat,_cs.GLfloat) +def glPolygonOffset(factor,units):pass +@_f +@_p.types(None,) +def glPopClientAttrib():pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray,arrays.GLfloatArray) +def glPrioritizeTextures(n,textures,priorities):pass +@_f +@_p.types(None,_cs.GLbitfield) +def glPushClientAttrib(mask):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLenum,_cs.GLsizei,ctypes.c_void_p) +def glTexCoordPointer(size,type,stride,pointer):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLenum,_cs.GLenum,ctypes.c_void_p) +def glTexSubImage1D(target,level,xoffset,width,format,type,pixels):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLsizei,_cs.GLenum,_cs.GLenum,ctypes.c_void_p) +def glTexSubImage2D(target,level,xoffset,yoffset,width,height,format,type,pixels):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLenum,_cs.GLsizei,ctypes.c_void_p) +def glVertexPointer(size,type,stride,pointer):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/VERSION/GL_1_2.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/VERSION/GL_1_2.py new file mode 100644 index 00000000..1b85c285 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/VERSION/GL_1_2.py @@ -0,0 +1,66 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_VERSION_GL_1_2' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_VERSION_GL_1_2',error_checker=_errors._error_checker) +GL_ALIASED_LINE_WIDTH_RANGE=_C('GL_ALIASED_LINE_WIDTH_RANGE',0x846E) +GL_ALIASED_POINT_SIZE_RANGE=_C('GL_ALIASED_POINT_SIZE_RANGE',0x846D) +GL_BGR=_C('GL_BGR',0x80E0) +GL_BGRA=_C('GL_BGRA',0x80E1) +GL_CLAMP_TO_EDGE=_C('GL_CLAMP_TO_EDGE',0x812F) +GL_LIGHT_MODEL_COLOR_CONTROL=_C('GL_LIGHT_MODEL_COLOR_CONTROL',0x81F8) +GL_MAX_3D_TEXTURE_SIZE=_C('GL_MAX_3D_TEXTURE_SIZE',0x8073) +GL_MAX_ELEMENTS_INDICES=_C('GL_MAX_ELEMENTS_INDICES',0x80E9) +GL_MAX_ELEMENTS_VERTICES=_C('GL_MAX_ELEMENTS_VERTICES',0x80E8) +GL_PACK_IMAGE_HEIGHT=_C('GL_PACK_IMAGE_HEIGHT',0x806C) +GL_PACK_SKIP_IMAGES=_C('GL_PACK_SKIP_IMAGES',0x806B) +GL_PROXY_TEXTURE_3D=_C('GL_PROXY_TEXTURE_3D',0x8070) +GL_RESCALE_NORMAL=_C('GL_RESCALE_NORMAL',0x803A) +GL_SEPARATE_SPECULAR_COLOR=_C('GL_SEPARATE_SPECULAR_COLOR',0x81FA) +GL_SINGLE_COLOR=_C('GL_SINGLE_COLOR',0x81F9) +GL_SMOOTH_LINE_WIDTH_GRANULARITY=_C('GL_SMOOTH_LINE_WIDTH_GRANULARITY',0x0B23) +GL_SMOOTH_LINE_WIDTH_RANGE=_C('GL_SMOOTH_LINE_WIDTH_RANGE',0x0B22) +GL_SMOOTH_POINT_SIZE_GRANULARITY=_C('GL_SMOOTH_POINT_SIZE_GRANULARITY',0x0B13) +GL_SMOOTH_POINT_SIZE_RANGE=_C('GL_SMOOTH_POINT_SIZE_RANGE',0x0B12) +GL_TEXTURE_3D=_C('GL_TEXTURE_3D',0x806F) +GL_TEXTURE_BASE_LEVEL=_C('GL_TEXTURE_BASE_LEVEL',0x813C) +GL_TEXTURE_BINDING_3D=_C('GL_TEXTURE_BINDING_3D',0x806A) +GL_TEXTURE_DEPTH=_C('GL_TEXTURE_DEPTH',0x8071) +GL_TEXTURE_MAX_LEVEL=_C('GL_TEXTURE_MAX_LEVEL',0x813D) +GL_TEXTURE_MAX_LOD=_C('GL_TEXTURE_MAX_LOD',0x813B) +GL_TEXTURE_MIN_LOD=_C('GL_TEXTURE_MIN_LOD',0x813A) +GL_TEXTURE_WRAP_R=_C('GL_TEXTURE_WRAP_R',0x8072) +GL_UNPACK_IMAGE_HEIGHT=_C('GL_UNPACK_IMAGE_HEIGHT',0x806E) +GL_UNPACK_SKIP_IMAGES=_C('GL_UNPACK_SKIP_IMAGES',0x806D) +GL_UNSIGNED_BYTE_2_3_3_REV=_C('GL_UNSIGNED_BYTE_2_3_3_REV',0x8362) +GL_UNSIGNED_BYTE_3_3_2=_C('GL_UNSIGNED_BYTE_3_3_2',0x8032) +GL_UNSIGNED_INT_10_10_10_2=_C('GL_UNSIGNED_INT_10_10_10_2',0x8036) +GL_UNSIGNED_INT_2_10_10_10_REV=_C('GL_UNSIGNED_INT_2_10_10_10_REV',0x8368) +GL_UNSIGNED_INT_8_8_8_8=_C('GL_UNSIGNED_INT_8_8_8_8',0x8035) +GL_UNSIGNED_INT_8_8_8_8_REV=_C('GL_UNSIGNED_INT_8_8_8_8_REV',0x8367) +GL_UNSIGNED_SHORT_1_5_5_5_REV=_C('GL_UNSIGNED_SHORT_1_5_5_5_REV',0x8366) +GL_UNSIGNED_SHORT_4_4_4_4=_C('GL_UNSIGNED_SHORT_4_4_4_4',0x8033) +GL_UNSIGNED_SHORT_4_4_4_4_REV=_C('GL_UNSIGNED_SHORT_4_4_4_4_REV',0x8365) +GL_UNSIGNED_SHORT_5_5_5_1=_C('GL_UNSIGNED_SHORT_5_5_5_1',0x8034) +GL_UNSIGNED_SHORT_5_6_5=_C('GL_UNSIGNED_SHORT_5_6_5',0x8363) +GL_UNSIGNED_SHORT_5_6_5_REV=_C('GL_UNSIGNED_SHORT_5_6_5_REV',0x8364) +@_f +@_p.types(None,_cs.GLenum,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLsizei) +def glCopyTexSubImage3D(target,level,xoffset,yoffset,zoffset,x,y,width,height):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,_cs.GLuint,_cs.GLsizei,_cs.GLenum,ctypes.c_void_p) +def glDrawRangeElements(mode,start,end,count,type,indices):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLsizei,_cs.GLsizei,_cs.GLint,_cs.GLenum,_cs.GLenum,ctypes.c_void_p) +def glTexImage3D(target,level,internalformat,width,height,depth,border,format,type,pixels):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLsizei,_cs.GLsizei,_cs.GLenum,_cs.GLenum,ctypes.c_void_p) +def glTexSubImage3D(target,level,xoffset,yoffset,zoffset,width,height,depth,format,type,pixels):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/VERSION/GL_1_3.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/VERSION/GL_1_3.py new file mode 100644 index 00000000..f7d72485 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/VERSION/GL_1_3.py @@ -0,0 +1,247 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_VERSION_GL_1_3' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_VERSION_GL_1_3',error_checker=_errors._error_checker) +GL_ACTIVE_TEXTURE=_C('GL_ACTIVE_TEXTURE',0x84E0) +GL_ADD_SIGNED=_C('GL_ADD_SIGNED',0x8574) +GL_CLAMP_TO_BORDER=_C('GL_CLAMP_TO_BORDER',0x812D) +GL_CLIENT_ACTIVE_TEXTURE=_C('GL_CLIENT_ACTIVE_TEXTURE',0x84E1) +GL_COMBINE=_C('GL_COMBINE',0x8570) +GL_COMBINE_ALPHA=_C('GL_COMBINE_ALPHA',0x8572) +GL_COMBINE_RGB=_C('GL_COMBINE_RGB',0x8571) +GL_COMPRESSED_ALPHA=_C('GL_COMPRESSED_ALPHA',0x84E9) +GL_COMPRESSED_INTENSITY=_C('GL_COMPRESSED_INTENSITY',0x84EC) +GL_COMPRESSED_LUMINANCE=_C('GL_COMPRESSED_LUMINANCE',0x84EA) +GL_COMPRESSED_LUMINANCE_ALPHA=_C('GL_COMPRESSED_LUMINANCE_ALPHA',0x84EB) +GL_COMPRESSED_RGB=_C('GL_COMPRESSED_RGB',0x84ED) +GL_COMPRESSED_RGBA=_C('GL_COMPRESSED_RGBA',0x84EE) +GL_COMPRESSED_TEXTURE_FORMATS=_C('GL_COMPRESSED_TEXTURE_FORMATS',0x86A3) +GL_CONSTANT=_C('GL_CONSTANT',0x8576) +GL_DOT3_RGB=_C('GL_DOT3_RGB',0x86AE) +GL_DOT3_RGBA=_C('GL_DOT3_RGBA',0x86AF) +GL_INTERPOLATE=_C('GL_INTERPOLATE',0x8575) +GL_MAX_CUBE_MAP_TEXTURE_SIZE=_C('GL_MAX_CUBE_MAP_TEXTURE_SIZE',0x851C) +GL_MAX_TEXTURE_UNITS=_C('GL_MAX_TEXTURE_UNITS',0x84E2) +GL_MULTISAMPLE=_C('GL_MULTISAMPLE',0x809D) +GL_MULTISAMPLE_BIT=_C('GL_MULTISAMPLE_BIT',0x20000000) +GL_NORMAL_MAP=_C('GL_NORMAL_MAP',0x8511) +GL_NUM_COMPRESSED_TEXTURE_FORMATS=_C('GL_NUM_COMPRESSED_TEXTURE_FORMATS',0x86A2) +GL_OPERAND0_ALPHA=_C('GL_OPERAND0_ALPHA',0x8598) +GL_OPERAND0_RGB=_C('GL_OPERAND0_RGB',0x8590) +GL_OPERAND1_ALPHA=_C('GL_OPERAND1_ALPHA',0x8599) +GL_OPERAND1_RGB=_C('GL_OPERAND1_RGB',0x8591) +GL_OPERAND2_ALPHA=_C('GL_OPERAND2_ALPHA',0x859A) +GL_OPERAND2_RGB=_C('GL_OPERAND2_RGB',0x8592) +GL_PREVIOUS=_C('GL_PREVIOUS',0x8578) +GL_PRIMARY_COLOR=_C('GL_PRIMARY_COLOR',0x8577) +GL_PROXY_TEXTURE_CUBE_MAP=_C('GL_PROXY_TEXTURE_CUBE_MAP',0x851B) +GL_REFLECTION_MAP=_C('GL_REFLECTION_MAP',0x8512) +GL_RGB_SCALE=_C('GL_RGB_SCALE',0x8573) +GL_SAMPLES=_C('GL_SAMPLES',0x80A9) +GL_SAMPLE_ALPHA_TO_COVERAGE=_C('GL_SAMPLE_ALPHA_TO_COVERAGE',0x809E) +GL_SAMPLE_ALPHA_TO_ONE=_C('GL_SAMPLE_ALPHA_TO_ONE',0x809F) +GL_SAMPLE_BUFFERS=_C('GL_SAMPLE_BUFFERS',0x80A8) +GL_SAMPLE_COVERAGE=_C('GL_SAMPLE_COVERAGE',0x80A0) +GL_SAMPLE_COVERAGE_INVERT=_C('GL_SAMPLE_COVERAGE_INVERT',0x80AB) +GL_SAMPLE_COVERAGE_VALUE=_C('GL_SAMPLE_COVERAGE_VALUE',0x80AA) +GL_SOURCE0_ALPHA=_C('GL_SOURCE0_ALPHA',0x8588) +GL_SOURCE0_RGB=_C('GL_SOURCE0_RGB',0x8580) +GL_SOURCE1_ALPHA=_C('GL_SOURCE1_ALPHA',0x8589) +GL_SOURCE1_RGB=_C('GL_SOURCE1_RGB',0x8581) +GL_SOURCE2_ALPHA=_C('GL_SOURCE2_ALPHA',0x858A) +GL_SOURCE2_RGB=_C('GL_SOURCE2_RGB',0x8582) +GL_SUBTRACT=_C('GL_SUBTRACT',0x84E7) +GL_TEXTURE0=_C('GL_TEXTURE0',0x84C0) +GL_TEXTURE1=_C('GL_TEXTURE1',0x84C1) +GL_TEXTURE10=_C('GL_TEXTURE10',0x84CA) +GL_TEXTURE11=_C('GL_TEXTURE11',0x84CB) +GL_TEXTURE12=_C('GL_TEXTURE12',0x84CC) +GL_TEXTURE13=_C('GL_TEXTURE13',0x84CD) +GL_TEXTURE14=_C('GL_TEXTURE14',0x84CE) +GL_TEXTURE15=_C('GL_TEXTURE15',0x84CF) +GL_TEXTURE16=_C('GL_TEXTURE16',0x84D0) +GL_TEXTURE17=_C('GL_TEXTURE17',0x84D1) +GL_TEXTURE18=_C('GL_TEXTURE18',0x84D2) +GL_TEXTURE19=_C('GL_TEXTURE19',0x84D3) +GL_TEXTURE2=_C('GL_TEXTURE2',0x84C2) +GL_TEXTURE20=_C('GL_TEXTURE20',0x84D4) +GL_TEXTURE21=_C('GL_TEXTURE21',0x84D5) +GL_TEXTURE22=_C('GL_TEXTURE22',0x84D6) +GL_TEXTURE23=_C('GL_TEXTURE23',0x84D7) +GL_TEXTURE24=_C('GL_TEXTURE24',0x84D8) +GL_TEXTURE25=_C('GL_TEXTURE25',0x84D9) +GL_TEXTURE26=_C('GL_TEXTURE26',0x84DA) +GL_TEXTURE27=_C('GL_TEXTURE27',0x84DB) +GL_TEXTURE28=_C('GL_TEXTURE28',0x84DC) +GL_TEXTURE29=_C('GL_TEXTURE29',0x84DD) +GL_TEXTURE3=_C('GL_TEXTURE3',0x84C3) +GL_TEXTURE30=_C('GL_TEXTURE30',0x84DE) +GL_TEXTURE31=_C('GL_TEXTURE31',0x84DF) +GL_TEXTURE4=_C('GL_TEXTURE4',0x84C4) +GL_TEXTURE5=_C('GL_TEXTURE5',0x84C5) +GL_TEXTURE6=_C('GL_TEXTURE6',0x84C6) +GL_TEXTURE7=_C('GL_TEXTURE7',0x84C7) +GL_TEXTURE8=_C('GL_TEXTURE8',0x84C8) +GL_TEXTURE9=_C('GL_TEXTURE9',0x84C9) +GL_TEXTURE_BINDING_CUBE_MAP=_C('GL_TEXTURE_BINDING_CUBE_MAP',0x8514) +GL_TEXTURE_COMPRESSED=_C('GL_TEXTURE_COMPRESSED',0x86A1) +GL_TEXTURE_COMPRESSED_IMAGE_SIZE=_C('GL_TEXTURE_COMPRESSED_IMAGE_SIZE',0x86A0) +GL_TEXTURE_COMPRESSION_HINT=_C('GL_TEXTURE_COMPRESSION_HINT',0x84EF) +GL_TEXTURE_CUBE_MAP=_C('GL_TEXTURE_CUBE_MAP',0x8513) +GL_TEXTURE_CUBE_MAP_NEGATIVE_X=_C('GL_TEXTURE_CUBE_MAP_NEGATIVE_X',0x8516) +GL_TEXTURE_CUBE_MAP_NEGATIVE_Y=_C('GL_TEXTURE_CUBE_MAP_NEGATIVE_Y',0x8518) +GL_TEXTURE_CUBE_MAP_NEGATIVE_Z=_C('GL_TEXTURE_CUBE_MAP_NEGATIVE_Z',0x851A) +GL_TEXTURE_CUBE_MAP_POSITIVE_X=_C('GL_TEXTURE_CUBE_MAP_POSITIVE_X',0x8515) +GL_TEXTURE_CUBE_MAP_POSITIVE_Y=_C('GL_TEXTURE_CUBE_MAP_POSITIVE_Y',0x8517) +GL_TEXTURE_CUBE_MAP_POSITIVE_Z=_C('GL_TEXTURE_CUBE_MAP_POSITIVE_Z',0x8519) +GL_TRANSPOSE_COLOR_MATRIX=_C('GL_TRANSPOSE_COLOR_MATRIX',0x84E6) +GL_TRANSPOSE_MODELVIEW_MATRIX=_C('GL_TRANSPOSE_MODELVIEW_MATRIX',0x84E3) +GL_TRANSPOSE_PROJECTION_MATRIX=_C('GL_TRANSPOSE_PROJECTION_MATRIX',0x84E4) +GL_TRANSPOSE_TEXTURE_MATRIX=_C('GL_TRANSPOSE_TEXTURE_MATRIX',0x84E5) +@_f +@_p.types(None,_cs.GLenum) +def glActiveTexture(texture):pass +@_f +@_p.types(None,_cs.GLenum) +def glClientActiveTexture(texture):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLint,_cs.GLenum,_cs.GLsizei,_cs.GLint,_cs.GLsizei,ctypes.c_void_p) +def glCompressedTexImage1D(target,level,internalformat,width,border,imageSize,data):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLint,_cs.GLenum,_cs.GLsizei,_cs.GLsizei,_cs.GLint,_cs.GLsizei,ctypes.c_void_p) +def glCompressedTexImage2D(target,level,internalformat,width,height,border,imageSize,data):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLint,_cs.GLenum,_cs.GLsizei,_cs.GLsizei,_cs.GLsizei,_cs.GLint,_cs.GLsizei,ctypes.c_void_p) +def glCompressedTexImage3D(target,level,internalformat,width,height,depth,border,imageSize,data):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLenum,_cs.GLsizei,ctypes.c_void_p) +def glCompressedTexSubImage1D(target,level,xoffset,width,format,imageSize,data):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLsizei,_cs.GLenum,_cs.GLsizei,ctypes.c_void_p) +def glCompressedTexSubImage2D(target,level,xoffset,yoffset,width,height,format,imageSize,data):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLsizei,_cs.GLsizei,_cs.GLenum,_cs.GLsizei,ctypes.c_void_p) +def glCompressedTexSubImage3D(target,level,xoffset,yoffset,zoffset,width,height,depth,format,imageSize,data):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLint,ctypes.c_void_p) +def glGetCompressedTexImage(target,level,img):pass +@_f +@_p.types(None,arrays.GLdoubleArray) +def glLoadTransposeMatrixd(m):pass +@_f +@_p.types(None,arrays.GLfloatArray) +def glLoadTransposeMatrixf(m):pass +@_f +@_p.types(None,arrays.GLdoubleArray) +def glMultTransposeMatrixd(m):pass +@_f +@_p.types(None,arrays.GLfloatArray) +def glMultTransposeMatrixf(m):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLdouble) +def glMultiTexCoord1d(target,s):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLdoubleArray) +def glMultiTexCoord1dv(target,v):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLfloat) +def glMultiTexCoord1f(target,s):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLfloatArray) +def glMultiTexCoord1fv(target,v):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLint) +def glMultiTexCoord1i(target,s):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLintArray) +def glMultiTexCoord1iv(target,v):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLshort) +def glMultiTexCoord1s(target,s):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLshortArray) +def glMultiTexCoord1sv(target,v):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLdouble,_cs.GLdouble) +def glMultiTexCoord2d(target,s,t):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLdoubleArray) +def glMultiTexCoord2dv(target,v):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLfloat,_cs.GLfloat) +def glMultiTexCoord2f(target,s,t):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLfloatArray) +def glMultiTexCoord2fv(target,v):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLint,_cs.GLint) +def glMultiTexCoord2i(target,s,t):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLintArray) +def glMultiTexCoord2iv(target,v):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLshort,_cs.GLshort) +def glMultiTexCoord2s(target,s,t):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLshortArray) +def glMultiTexCoord2sv(target,v):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLdouble,_cs.GLdouble,_cs.GLdouble) +def glMultiTexCoord3d(target,s,t,r):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLdoubleArray) +def glMultiTexCoord3dv(target,v):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat) +def glMultiTexCoord3f(target,s,t,r):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLfloatArray) +def glMultiTexCoord3fv(target,v):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLint,_cs.GLint,_cs.GLint) +def glMultiTexCoord3i(target,s,t,r):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLintArray) +def glMultiTexCoord3iv(target,v):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLshort,_cs.GLshort,_cs.GLshort) +def glMultiTexCoord3s(target,s,t,r):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLshortArray) +def glMultiTexCoord3sv(target,v):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLdouble,_cs.GLdouble,_cs.GLdouble,_cs.GLdouble) +def glMultiTexCoord4d(target,s,t,r,q):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLdoubleArray) +def glMultiTexCoord4dv(target,v):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat) +def glMultiTexCoord4f(target,s,t,r,q):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLfloatArray) +def glMultiTexCoord4fv(target,v):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint) +def glMultiTexCoord4i(target,s,t,r,q):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLintArray) +def glMultiTexCoord4iv(target,v):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLshort,_cs.GLshort,_cs.GLshort,_cs.GLshort) +def glMultiTexCoord4s(target,s,t,r,q):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLshortArray) +def glMultiTexCoord4sv(target,v):pass +@_f +@_p.types(None,_cs.GLfloat,_cs.GLboolean) +def glSampleCoverage(value,invert):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/VERSION/GL_1_4.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/VERSION/GL_1_4.py new file mode 100644 index 00000000..a949a6d8 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/VERSION/GL_1_4.py @@ -0,0 +1,204 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_VERSION_GL_1_4' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_VERSION_GL_1_4',error_checker=_errors._error_checker) +GL_BLEND_COLOR=_C('GL_BLEND_COLOR',0x8005) +GL_BLEND_DST_ALPHA=_C('GL_BLEND_DST_ALPHA',0x80CA) +GL_BLEND_DST_RGB=_C('GL_BLEND_DST_RGB',0x80C8) +GL_BLEND_EQUATION=_C('GL_BLEND_EQUATION',0x8009) +GL_BLEND_SRC_ALPHA=_C('GL_BLEND_SRC_ALPHA',0x80CB) +GL_BLEND_SRC_RGB=_C('GL_BLEND_SRC_RGB',0x80C9) +GL_COLOR_SUM=_C('GL_COLOR_SUM',0x8458) +GL_COMPARE_R_TO_TEXTURE=_C('GL_COMPARE_R_TO_TEXTURE',0x884E) +GL_CONSTANT_ALPHA=_C('GL_CONSTANT_ALPHA',0x8003) +GL_CONSTANT_COLOR=_C('GL_CONSTANT_COLOR',0x8001) +GL_CURRENT_FOG_COORDINATE=_C('GL_CURRENT_FOG_COORDINATE',0x8453) +GL_CURRENT_SECONDARY_COLOR=_C('GL_CURRENT_SECONDARY_COLOR',0x8459) +GL_DECR_WRAP=_C('GL_DECR_WRAP',0x8508) +GL_DEPTH_COMPONENT16=_C('GL_DEPTH_COMPONENT16',0x81A5) +GL_DEPTH_COMPONENT24=_C('GL_DEPTH_COMPONENT24',0x81A6) +GL_DEPTH_COMPONENT32=_C('GL_DEPTH_COMPONENT32',0x81A7) +GL_DEPTH_TEXTURE_MODE=_C('GL_DEPTH_TEXTURE_MODE',0x884B) +GL_FOG_COORDINATE=_C('GL_FOG_COORDINATE',0x8451) +GL_FOG_COORDINATE_ARRAY=_C('GL_FOG_COORDINATE_ARRAY',0x8457) +GL_FOG_COORDINATE_ARRAY_POINTER=_C('GL_FOG_COORDINATE_ARRAY_POINTER',0x8456) +GL_FOG_COORDINATE_ARRAY_STRIDE=_C('GL_FOG_COORDINATE_ARRAY_STRIDE',0x8455) +GL_FOG_COORDINATE_ARRAY_TYPE=_C('GL_FOG_COORDINATE_ARRAY_TYPE',0x8454) +GL_FOG_COORDINATE_SOURCE=_C('GL_FOG_COORDINATE_SOURCE',0x8450) +GL_FRAGMENT_DEPTH=_C('GL_FRAGMENT_DEPTH',0x8452) +GL_FUNC_ADD=_C('GL_FUNC_ADD',0x8006) +GL_FUNC_REVERSE_SUBTRACT=_C('GL_FUNC_REVERSE_SUBTRACT',0x800B) +GL_FUNC_SUBTRACT=_C('GL_FUNC_SUBTRACT',0x800A) +GL_GENERATE_MIPMAP=_C('GL_GENERATE_MIPMAP',0x8191) +GL_GENERATE_MIPMAP_HINT=_C('GL_GENERATE_MIPMAP_HINT',0x8192) +GL_INCR_WRAP=_C('GL_INCR_WRAP',0x8507) +GL_MAX=_C('GL_MAX',0x8008) +GL_MAX_TEXTURE_LOD_BIAS=_C('GL_MAX_TEXTURE_LOD_BIAS',0x84FD) +GL_MIN=_C('GL_MIN',0x8007) +GL_MIRRORED_REPEAT=_C('GL_MIRRORED_REPEAT',0x8370) +GL_ONE_MINUS_CONSTANT_ALPHA=_C('GL_ONE_MINUS_CONSTANT_ALPHA',0x8004) +GL_ONE_MINUS_CONSTANT_COLOR=_C('GL_ONE_MINUS_CONSTANT_COLOR',0x8002) +GL_POINT_DISTANCE_ATTENUATION=_C('GL_POINT_DISTANCE_ATTENUATION',0x8129) +GL_POINT_FADE_THRESHOLD_SIZE=_C('GL_POINT_FADE_THRESHOLD_SIZE',0x8128) +GL_POINT_SIZE_MAX=_C('GL_POINT_SIZE_MAX',0x8127) +GL_POINT_SIZE_MIN=_C('GL_POINT_SIZE_MIN',0x8126) +GL_SECONDARY_COLOR_ARRAY=_C('GL_SECONDARY_COLOR_ARRAY',0x845E) +GL_SECONDARY_COLOR_ARRAY_POINTER=_C('GL_SECONDARY_COLOR_ARRAY_POINTER',0x845D) +GL_SECONDARY_COLOR_ARRAY_SIZE=_C('GL_SECONDARY_COLOR_ARRAY_SIZE',0x845A) +GL_SECONDARY_COLOR_ARRAY_STRIDE=_C('GL_SECONDARY_COLOR_ARRAY_STRIDE',0x845C) +GL_SECONDARY_COLOR_ARRAY_TYPE=_C('GL_SECONDARY_COLOR_ARRAY_TYPE',0x845B) +GL_TEXTURE_COMPARE_FUNC=_C('GL_TEXTURE_COMPARE_FUNC',0x884D) +GL_TEXTURE_COMPARE_MODE=_C('GL_TEXTURE_COMPARE_MODE',0x884C) +GL_TEXTURE_DEPTH_SIZE=_C('GL_TEXTURE_DEPTH_SIZE',0x884A) +GL_TEXTURE_FILTER_CONTROL=_C('GL_TEXTURE_FILTER_CONTROL',0x8500) +GL_TEXTURE_LOD_BIAS=_C('GL_TEXTURE_LOD_BIAS',0x8501) +@_f +@_p.types(None,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat) +def glBlendColor(red,green,blue,alpha):pass +@_f +@_p.types(None,_cs.GLenum) +def glBlendEquation(mode):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLenum,_cs.GLenum) +def glBlendFuncSeparate(sfactorRGB,dfactorRGB,sfactorAlpha,dfactorAlpha):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizei,ctypes.c_void_p) +def glFogCoordPointer(type,stride,pointer):pass +@_f +@_p.types(None,_cs.GLdouble) +def glFogCoordd(coord):pass +@_f +@_p.types(None,arrays.GLdoubleArray) +def glFogCoorddv(coord):pass +@_f +@_p.types(None,_cs.GLfloat) +def glFogCoordf(coord):pass +@_f +@_p.types(None,arrays.GLfloatArray) +def glFogCoordfv(coord):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLintArray,arrays.GLsizeiArray,_cs.GLsizei) +def glMultiDrawArrays(mode,first,count,drawcount):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLsizeiArray,_cs.GLenum,arrays.GLvoidpArray,_cs.GLsizei) +def glMultiDrawElements(mode,count,type,indices,drawcount):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLfloat) +def glPointParameterf(pname,param):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLfloatArray) +def glPointParameterfv(pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLint) +def glPointParameteri(pname,param):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLintArray) +def glPointParameteriv(pname,params):pass +@_f +@_p.types(None,_cs.GLbyte,_cs.GLbyte,_cs.GLbyte) +def glSecondaryColor3b(red,green,blue):pass +@_f +@_p.types(None,arrays.GLbyteArray) +def glSecondaryColor3bv(v):pass +@_f +@_p.types(None,_cs.GLdouble,_cs.GLdouble,_cs.GLdouble) +def glSecondaryColor3d(red,green,blue):pass +@_f +@_p.types(None,arrays.GLdoubleArray) +def glSecondaryColor3dv(v):pass +@_f +@_p.types(None,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat) +def glSecondaryColor3f(red,green,blue):pass +@_f +@_p.types(None,arrays.GLfloatArray) +def glSecondaryColor3fv(v):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLint,_cs.GLint) +def glSecondaryColor3i(red,green,blue):pass +@_f +@_p.types(None,arrays.GLintArray) +def glSecondaryColor3iv(v):pass +@_f +@_p.types(None,_cs.GLshort,_cs.GLshort,_cs.GLshort) +def glSecondaryColor3s(red,green,blue):pass +@_f +@_p.types(None,arrays.GLshortArray) +def glSecondaryColor3sv(v):pass +@_f +@_p.types(None,_cs.GLubyte,_cs.GLubyte,_cs.GLubyte) +def glSecondaryColor3ub(red,green,blue):pass +@_f +@_p.types(None,arrays.GLubyteArray) +def glSecondaryColor3ubv(v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLuint) +def glSecondaryColor3ui(red,green,blue):pass +@_f +@_p.types(None,arrays.GLuintArray) +def glSecondaryColor3uiv(v):pass +@_f +@_p.types(None,_cs.GLushort,_cs.GLushort,_cs.GLushort) +def glSecondaryColor3us(red,green,blue):pass +@_f +@_p.types(None,arrays.GLushortArray) +def glSecondaryColor3usv(v):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLenum,_cs.GLsizei,ctypes.c_void_p) +def glSecondaryColorPointer(size,type,stride,pointer):pass +@_f +@_p.types(None,_cs.GLdouble,_cs.GLdouble) +def glWindowPos2d(x,y):pass +@_f +@_p.types(None,arrays.GLdoubleArray) +def glWindowPos2dv(v):pass +@_f +@_p.types(None,_cs.GLfloat,_cs.GLfloat) +def glWindowPos2f(x,y):pass +@_f +@_p.types(None,arrays.GLfloatArray) +def glWindowPos2fv(v):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLint) +def glWindowPos2i(x,y):pass +@_f +@_p.types(None,arrays.GLintArray) +def glWindowPos2iv(v):pass +@_f +@_p.types(None,_cs.GLshort,_cs.GLshort) +def glWindowPos2s(x,y):pass +@_f +@_p.types(None,arrays.GLshortArray) +def glWindowPos2sv(v):pass +@_f +@_p.types(None,_cs.GLdouble,_cs.GLdouble,_cs.GLdouble) +def glWindowPos3d(x,y,z):pass +@_f +@_p.types(None,arrays.GLdoubleArray) +def glWindowPos3dv(v):pass +@_f +@_p.types(None,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat) +def glWindowPos3f(x,y,z):pass +@_f +@_p.types(None,arrays.GLfloatArray) +def glWindowPos3fv(v):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLint,_cs.GLint) +def glWindowPos3i(x,y,z):pass +@_f +@_p.types(None,arrays.GLintArray) +def glWindowPos3iv(v):pass +@_f +@_p.types(None,_cs.GLshort,_cs.GLshort,_cs.GLshort) +def glWindowPos3s(x,y,z):pass +@_f +@_p.types(None,arrays.GLshortArray) +def glWindowPos3sv(v):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/VERSION/GL_1_5.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/VERSION/GL_1_5.py new file mode 100644 index 00000000..cf8d8c16 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/VERSION/GL_1_5.py @@ -0,0 +1,120 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_VERSION_GL_1_5' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_VERSION_GL_1_5',error_checker=_errors._error_checker) +GL_ARRAY_BUFFER=_C('GL_ARRAY_BUFFER',0x8892) +GL_ARRAY_BUFFER_BINDING=_C('GL_ARRAY_BUFFER_BINDING',0x8894) +GL_BUFFER_ACCESS=_C('GL_BUFFER_ACCESS',0x88BB) +GL_BUFFER_MAPPED=_C('GL_BUFFER_MAPPED',0x88BC) +GL_BUFFER_MAP_POINTER=_C('GL_BUFFER_MAP_POINTER',0x88BD) +GL_BUFFER_SIZE=_C('GL_BUFFER_SIZE',0x8764) +GL_BUFFER_USAGE=_C('GL_BUFFER_USAGE',0x8765) +GL_COLOR_ARRAY_BUFFER_BINDING=_C('GL_COLOR_ARRAY_BUFFER_BINDING',0x8898) +GL_CURRENT_FOG_COORD=_C('GL_CURRENT_FOG_COORD',0x8453) +GL_CURRENT_QUERY=_C('GL_CURRENT_QUERY',0x8865) +GL_DYNAMIC_COPY=_C('GL_DYNAMIC_COPY',0x88EA) +GL_DYNAMIC_DRAW=_C('GL_DYNAMIC_DRAW',0x88E8) +GL_DYNAMIC_READ=_C('GL_DYNAMIC_READ',0x88E9) +GL_EDGE_FLAG_ARRAY_BUFFER_BINDING=_C('GL_EDGE_FLAG_ARRAY_BUFFER_BINDING',0x889B) +GL_ELEMENT_ARRAY_BUFFER=_C('GL_ELEMENT_ARRAY_BUFFER',0x8893) +GL_ELEMENT_ARRAY_BUFFER_BINDING=_C('GL_ELEMENT_ARRAY_BUFFER_BINDING',0x8895) +GL_FOG_COORD=_C('GL_FOG_COORD',0x8451) +GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING=_C('GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING',0x889D) +GL_FOG_COORD_ARRAY=_C('GL_FOG_COORD_ARRAY',0x8457) +GL_FOG_COORD_ARRAY_BUFFER_BINDING=_C('GL_FOG_COORD_ARRAY_BUFFER_BINDING',0x889D) +GL_FOG_COORD_ARRAY_POINTER=_C('GL_FOG_COORD_ARRAY_POINTER',0x8456) +GL_FOG_COORD_ARRAY_STRIDE=_C('GL_FOG_COORD_ARRAY_STRIDE',0x8455) +GL_FOG_COORD_ARRAY_TYPE=_C('GL_FOG_COORD_ARRAY_TYPE',0x8454) +GL_FOG_COORD_SRC=_C('GL_FOG_COORD_SRC',0x8450) +GL_INDEX_ARRAY_BUFFER_BINDING=_C('GL_INDEX_ARRAY_BUFFER_BINDING',0x8899) +GL_NORMAL_ARRAY_BUFFER_BINDING=_C('GL_NORMAL_ARRAY_BUFFER_BINDING',0x8897) +GL_QUERY_COUNTER_BITS=_C('GL_QUERY_COUNTER_BITS',0x8864) +GL_QUERY_RESULT=_C('GL_QUERY_RESULT',0x8866) +GL_QUERY_RESULT_AVAILABLE=_C('GL_QUERY_RESULT_AVAILABLE',0x8867) +GL_READ_ONLY=_C('GL_READ_ONLY',0x88B8) +GL_READ_WRITE=_C('GL_READ_WRITE',0x88BA) +GL_SAMPLES_PASSED=_C('GL_SAMPLES_PASSED',0x8914) +GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING=_C('GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING',0x889C) +GL_SRC0_ALPHA=_C('GL_SRC0_ALPHA',0x8588) +GL_SRC0_RGB=_C('GL_SRC0_RGB',0x8580) +GL_SRC1_ALPHA=_C('GL_SRC1_ALPHA',0x8589) +GL_SRC1_RGB=_C('GL_SRC1_RGB',0x8581) +GL_SRC2_ALPHA=_C('GL_SRC2_ALPHA',0x858A) +GL_SRC2_RGB=_C('GL_SRC2_RGB',0x8582) +GL_STATIC_COPY=_C('GL_STATIC_COPY',0x88E6) +GL_STATIC_DRAW=_C('GL_STATIC_DRAW',0x88E4) +GL_STATIC_READ=_C('GL_STATIC_READ',0x88E5) +GL_STREAM_COPY=_C('GL_STREAM_COPY',0x88E2) +GL_STREAM_DRAW=_C('GL_STREAM_DRAW',0x88E0) +GL_STREAM_READ=_C('GL_STREAM_READ',0x88E1) +GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING=_C('GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING',0x889A) +GL_VERTEX_ARRAY_BUFFER_BINDING=_C('GL_VERTEX_ARRAY_BUFFER_BINDING',0x8896) +GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING=_C('GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING',0x889F) +GL_WEIGHT_ARRAY_BUFFER_BINDING=_C('GL_WEIGHT_ARRAY_BUFFER_BINDING',0x889E) +GL_WRITE_ONLY=_C('GL_WRITE_ONLY',0x88B9) +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint) +def glBeginQuery(target,id):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint) +def glBindBuffer(target,buffer):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizeiptr,ctypes.c_void_p,_cs.GLenum) +def glBufferData(target,size,data,usage):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLintptr,_cs.GLsizeiptr,ctypes.c_void_p) +def glBufferSubData(target,offset,size,data):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray) +def glDeleteBuffers(n,buffers):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray) +def glDeleteQueries(n,ids):pass +@_f +@_p.types(None,_cs.GLenum) +def glEndQuery(target):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray) +def glGenBuffers(n,buffers):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray) +def glGenQueries(n,ids):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLintArray) +def glGetBufferParameteriv(target,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLvoidpArray) +def glGetBufferPointerv(target,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLintptr,_cs.GLsizeiptr,ctypes.c_void_p) +def glGetBufferSubData(target,offset,size,data):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLintArray) +def glGetQueryObjectiv(id,pname,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLuintArray) +def glGetQueryObjectuiv(id,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLintArray) +def glGetQueryiv(target,pname,params):pass +@_f +@_p.types(_cs.GLboolean,_cs.GLuint) +def glIsBuffer(buffer):pass +@_f +@_p.types(_cs.GLboolean,_cs.GLuint) +def glIsQuery(id):pass +@_f +@_p.types(ctypes.c_void_p,_cs.GLenum,_cs.GLenum) +def glMapBuffer(target,access):pass +@_f +@_p.types(_cs.GLboolean,_cs.GLenum) +def glUnmapBuffer(target):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/VERSION/GL_2_0.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/VERSION/GL_2_0.py new file mode 100644 index 00000000..6f786b75 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/VERSION/GL_2_0.py @@ -0,0 +1,376 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_VERSION_GL_2_0' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_VERSION_GL_2_0',error_checker=_errors._error_checker) +GL_ACTIVE_ATTRIBUTES=_C('GL_ACTIVE_ATTRIBUTES',0x8B89) +GL_ACTIVE_ATTRIBUTE_MAX_LENGTH=_C('GL_ACTIVE_ATTRIBUTE_MAX_LENGTH',0x8B8A) +GL_ACTIVE_UNIFORMS=_C('GL_ACTIVE_UNIFORMS',0x8B86) +GL_ACTIVE_UNIFORM_MAX_LENGTH=_C('GL_ACTIVE_UNIFORM_MAX_LENGTH',0x8B87) +GL_ATTACHED_SHADERS=_C('GL_ATTACHED_SHADERS',0x8B85) +GL_BLEND_EQUATION_ALPHA=_C('GL_BLEND_EQUATION_ALPHA',0x883D) +GL_BLEND_EQUATION_RGB=_C('GL_BLEND_EQUATION_RGB',0x8009) +GL_BOOL=_C('GL_BOOL',0x8B56) +GL_BOOL_VEC2=_C('GL_BOOL_VEC2',0x8B57) +GL_BOOL_VEC3=_C('GL_BOOL_VEC3',0x8B58) +GL_BOOL_VEC4=_C('GL_BOOL_VEC4',0x8B59) +GL_COMPILE_STATUS=_C('GL_COMPILE_STATUS',0x8B81) +GL_COORD_REPLACE=_C('GL_COORD_REPLACE',0x8862) +GL_CURRENT_PROGRAM=_C('GL_CURRENT_PROGRAM',0x8B8D) +GL_CURRENT_VERTEX_ATTRIB=_C('GL_CURRENT_VERTEX_ATTRIB',0x8626) +GL_DELETE_STATUS=_C('GL_DELETE_STATUS',0x8B80) +GL_DRAW_BUFFER0=_C('GL_DRAW_BUFFER0',0x8825) +GL_DRAW_BUFFER1=_C('GL_DRAW_BUFFER1',0x8826) +GL_DRAW_BUFFER10=_C('GL_DRAW_BUFFER10',0x882F) +GL_DRAW_BUFFER11=_C('GL_DRAW_BUFFER11',0x8830) +GL_DRAW_BUFFER12=_C('GL_DRAW_BUFFER12',0x8831) +GL_DRAW_BUFFER13=_C('GL_DRAW_BUFFER13',0x8832) +GL_DRAW_BUFFER14=_C('GL_DRAW_BUFFER14',0x8833) +GL_DRAW_BUFFER15=_C('GL_DRAW_BUFFER15',0x8834) +GL_DRAW_BUFFER2=_C('GL_DRAW_BUFFER2',0x8827) +GL_DRAW_BUFFER3=_C('GL_DRAW_BUFFER3',0x8828) +GL_DRAW_BUFFER4=_C('GL_DRAW_BUFFER4',0x8829) +GL_DRAW_BUFFER5=_C('GL_DRAW_BUFFER5',0x882A) +GL_DRAW_BUFFER6=_C('GL_DRAW_BUFFER6',0x882B) +GL_DRAW_BUFFER7=_C('GL_DRAW_BUFFER7',0x882C) +GL_DRAW_BUFFER8=_C('GL_DRAW_BUFFER8',0x882D) +GL_DRAW_BUFFER9=_C('GL_DRAW_BUFFER9',0x882E) +GL_FLOAT_MAT2=_C('GL_FLOAT_MAT2',0x8B5A) +GL_FLOAT_MAT3=_C('GL_FLOAT_MAT3',0x8B5B) +GL_FLOAT_MAT4=_C('GL_FLOAT_MAT4',0x8B5C) +GL_FLOAT_VEC2=_C('GL_FLOAT_VEC2',0x8B50) +GL_FLOAT_VEC3=_C('GL_FLOAT_VEC3',0x8B51) +GL_FLOAT_VEC4=_C('GL_FLOAT_VEC4',0x8B52) +GL_FRAGMENT_SHADER=_C('GL_FRAGMENT_SHADER',0x8B30) +GL_FRAGMENT_SHADER_DERIVATIVE_HINT=_C('GL_FRAGMENT_SHADER_DERIVATIVE_HINT',0x8B8B) +GL_INFO_LOG_LENGTH=_C('GL_INFO_LOG_LENGTH',0x8B84) +GL_INT_VEC2=_C('GL_INT_VEC2',0x8B53) +GL_INT_VEC3=_C('GL_INT_VEC3',0x8B54) +GL_INT_VEC4=_C('GL_INT_VEC4',0x8B55) +GL_LINK_STATUS=_C('GL_LINK_STATUS',0x8B82) +GL_LOWER_LEFT=_C('GL_LOWER_LEFT',0x8CA1) +GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS=_C('GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS',0x8B4D) +GL_MAX_DRAW_BUFFERS=_C('GL_MAX_DRAW_BUFFERS',0x8824) +GL_MAX_FRAGMENT_UNIFORM_COMPONENTS=_C('GL_MAX_FRAGMENT_UNIFORM_COMPONENTS',0x8B49) +GL_MAX_TEXTURE_COORDS=_C('GL_MAX_TEXTURE_COORDS',0x8871) +GL_MAX_TEXTURE_IMAGE_UNITS=_C('GL_MAX_TEXTURE_IMAGE_UNITS',0x8872) +GL_MAX_VARYING_FLOATS=_C('GL_MAX_VARYING_FLOATS',0x8B4B) +GL_MAX_VERTEX_ATTRIBS=_C('GL_MAX_VERTEX_ATTRIBS',0x8869) +GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS=_C('GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS',0x8B4C) +GL_MAX_VERTEX_UNIFORM_COMPONENTS=_C('GL_MAX_VERTEX_UNIFORM_COMPONENTS',0x8B4A) +GL_POINT_SPRITE=_C('GL_POINT_SPRITE',0x8861) +GL_POINT_SPRITE_COORD_ORIGIN=_C('GL_POINT_SPRITE_COORD_ORIGIN',0x8CA0) +GL_SAMPLER_1D=_C('GL_SAMPLER_1D',0x8B5D) +GL_SAMPLER_1D_SHADOW=_C('GL_SAMPLER_1D_SHADOW',0x8B61) +GL_SAMPLER_2D=_C('GL_SAMPLER_2D',0x8B5E) +GL_SAMPLER_2D_SHADOW=_C('GL_SAMPLER_2D_SHADOW',0x8B62) +GL_SAMPLER_3D=_C('GL_SAMPLER_3D',0x8B5F) +GL_SAMPLER_CUBE=_C('GL_SAMPLER_CUBE',0x8B60) +GL_SHADER_SOURCE_LENGTH=_C('GL_SHADER_SOURCE_LENGTH',0x8B88) +GL_SHADER_TYPE=_C('GL_SHADER_TYPE',0x8B4F) +GL_SHADING_LANGUAGE_VERSION=_C('GL_SHADING_LANGUAGE_VERSION',0x8B8C) +GL_STENCIL_BACK_FAIL=_C('GL_STENCIL_BACK_FAIL',0x8801) +GL_STENCIL_BACK_FUNC=_C('GL_STENCIL_BACK_FUNC',0x8800) +GL_STENCIL_BACK_PASS_DEPTH_FAIL=_C('GL_STENCIL_BACK_PASS_DEPTH_FAIL',0x8802) +GL_STENCIL_BACK_PASS_DEPTH_PASS=_C('GL_STENCIL_BACK_PASS_DEPTH_PASS',0x8803) +GL_STENCIL_BACK_REF=_C('GL_STENCIL_BACK_REF',0x8CA3) +GL_STENCIL_BACK_VALUE_MASK=_C('GL_STENCIL_BACK_VALUE_MASK',0x8CA4) +GL_STENCIL_BACK_WRITEMASK=_C('GL_STENCIL_BACK_WRITEMASK',0x8CA5) +GL_UPPER_LEFT=_C('GL_UPPER_LEFT',0x8CA2) +GL_VALIDATE_STATUS=_C('GL_VALIDATE_STATUS',0x8B83) +GL_VERTEX_ATTRIB_ARRAY_ENABLED=_C('GL_VERTEX_ATTRIB_ARRAY_ENABLED',0x8622) +GL_VERTEX_ATTRIB_ARRAY_NORMALIZED=_C('GL_VERTEX_ATTRIB_ARRAY_NORMALIZED',0x886A) +GL_VERTEX_ATTRIB_ARRAY_POINTER=_C('GL_VERTEX_ATTRIB_ARRAY_POINTER',0x8645) +GL_VERTEX_ATTRIB_ARRAY_SIZE=_C('GL_VERTEX_ATTRIB_ARRAY_SIZE',0x8623) +GL_VERTEX_ATTRIB_ARRAY_STRIDE=_C('GL_VERTEX_ATTRIB_ARRAY_STRIDE',0x8624) +GL_VERTEX_ATTRIB_ARRAY_TYPE=_C('GL_VERTEX_ATTRIB_ARRAY_TYPE',0x8625) +GL_VERTEX_PROGRAM_POINT_SIZE=_C('GL_VERTEX_PROGRAM_POINT_SIZE',0x8642) +GL_VERTEX_PROGRAM_TWO_SIDE=_C('GL_VERTEX_PROGRAM_TWO_SIDE',0x8643) +GL_VERTEX_SHADER=_C('GL_VERTEX_SHADER',0x8B31) +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint) +def glAttachShader(program,shader):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,arrays.GLcharArray) +def glBindAttribLocation(program,index,name):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum) +def glBlendEquationSeparate(modeRGB,modeAlpha):pass +@_f +@_p.types(None,_cs.GLuint) +def glCompileShader(shader):pass +@_f +@_p.types(_cs.GLuint,) +def glCreateProgram():pass +@_f +@_p.types(_cs.GLuint,_cs.GLenum) +def glCreateShader(type):pass +@_f +@_p.types(None,_cs.GLuint) +def glDeleteProgram(program):pass +@_f +@_p.types(None,_cs.GLuint) +def glDeleteShader(shader):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint) +def glDetachShader(program,shader):pass +@_f +@_p.types(None,_cs.GLuint) +def glDisableVertexAttribArray(index):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray) +def glDrawBuffers(n,bufs):pass +@_f +@_p.types(None,_cs.GLuint) +def glEnableVertexAttribArray(index):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLsizei,arrays.GLsizeiArray,arrays.GLintArray,arrays.GLuintArray,arrays.GLcharArray) +def glGetActiveAttrib(program,index,bufSize,length,size,type,name):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLsizei,arrays.GLsizeiArray,arrays.GLintArray,arrays.GLuintArray,arrays.GLcharArray) +def glGetActiveUniform(program,index,bufSize,length,size,type,name):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizei,arrays.GLsizeiArray,arrays.GLuintArray) +def glGetAttachedShaders(program,maxCount,count,shaders):pass +@_f +@_p.types(_cs.GLint,_cs.GLuint,arrays.GLcharArray) +def glGetAttribLocation(program,name):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizei,arrays.GLsizeiArray,arrays.GLcharArray) +def glGetProgramInfoLog(program,bufSize,length,infoLog):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLintArray) +def glGetProgramiv(program,pname,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizei,arrays.GLsizeiArray,arrays.GLcharArray) +def glGetShaderInfoLog(shader,bufSize,length,infoLog):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizei,arrays.GLsizeiArray,arrays.GLcharArray) +def glGetShaderSource(shader,bufSize,length,source):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLintArray) +def glGetShaderiv(shader,pname,params):pass +@_f +@_p.types(_cs.GLint,_cs.GLuint,arrays.GLcharArray) +def glGetUniformLocation(program,name):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,arrays.GLfloatArray) +def glGetUniformfv(program,location,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,arrays.GLintArray) +def glGetUniformiv(program,location,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLvoidpArray) +def glGetVertexAttribPointerv(index,pname,pointer):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLdoubleArray) +def glGetVertexAttribdv(index,pname,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLfloatArray) +def glGetVertexAttribfv(index,pname,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLintArray) +def glGetVertexAttribiv(index,pname,params):pass +@_f +@_p.types(_cs.GLboolean,_cs.GLuint) +def glIsProgram(program):pass +@_f +@_p.types(_cs.GLboolean,_cs.GLuint) +def glIsShader(shader):pass +@_f +@_p.types(None,_cs.GLuint) +def glLinkProgram(program):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizei,ctypes.POINTER( ctypes.POINTER( _cs.GLchar )),arrays.GLintArray) +def glShaderSource(shader,count,string,length):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLint,_cs.GLuint) +def glStencilFuncSeparate(face,func,ref,mask):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint) +def glStencilMaskSeparate(face,mask):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLenum,_cs.GLenum) +def glStencilOpSeparate(face,sfail,dpfail,dppass):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLfloat) +def glUniform1f(location,v0):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLsizei,arrays.GLfloatArray) +def glUniform1fv(location,count,value):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLint) +def glUniform1i(location,v0):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLsizei,arrays.GLintArray) +def glUniform1iv(location,count,value):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLfloat,_cs.GLfloat) +def glUniform2f(location,v0,v1):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLsizei,arrays.GLfloatArray) +def glUniform2fv(location,count,value):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLint,_cs.GLint) +def glUniform2i(location,v0,v1):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLsizei,arrays.GLintArray) +def glUniform2iv(location,count,value):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat) +def glUniform3f(location,v0,v1,v2):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLsizei,arrays.GLfloatArray) +def glUniform3fv(location,count,value):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint) +def glUniform3i(location,v0,v1,v2):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLsizei,arrays.GLintArray) +def glUniform3iv(location,count,value):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat) +def glUniform4f(location,v0,v1,v2,v3):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLsizei,arrays.GLfloatArray) +def glUniform4fv(location,count,value):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint) +def glUniform4i(location,v0,v1,v2,v3):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLsizei,arrays.GLintArray) +def glUniform4iv(location,count,value):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLsizei,_cs.GLboolean,arrays.GLfloatArray) +def glUniformMatrix2fv(location,count,transpose,value):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLsizei,_cs.GLboolean,arrays.GLfloatArray) +def glUniformMatrix3fv(location,count,transpose,value):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLsizei,_cs.GLboolean,arrays.GLfloatArray) +def glUniformMatrix4fv(location,count,transpose,value):pass +@_f +@_p.types(None,_cs.GLuint) +def glUseProgram(program):pass +@_f +@_p.types(None,_cs.GLuint) +def glValidateProgram(program):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLdouble) +def glVertexAttrib1d(index,x):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLdoubleArray) +def glVertexAttrib1dv(index,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLfloat) +def glVertexAttrib1f(index,x):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLfloatArray) +def glVertexAttrib1fv(index,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLshort) +def glVertexAttrib1s(index,x):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLshortArray) +def glVertexAttrib1sv(index,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLdouble,_cs.GLdouble) +def glVertexAttrib2d(index,x,y):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLdoubleArray) +def glVertexAttrib2dv(index,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLfloat,_cs.GLfloat) +def glVertexAttrib2f(index,x,y):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLfloatArray) +def glVertexAttrib2fv(index,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLshort,_cs.GLshort) +def glVertexAttrib2s(index,x,y):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLshortArray) +def glVertexAttrib2sv(index,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLdouble,_cs.GLdouble,_cs.GLdouble) +def glVertexAttrib3d(index,x,y,z):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLdoubleArray) +def glVertexAttrib3dv(index,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat) +def glVertexAttrib3f(index,x,y,z):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLfloatArray) +def glVertexAttrib3fv(index,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLshort,_cs.GLshort,_cs.GLshort) +def glVertexAttrib3s(index,x,y,z):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLshortArray) +def glVertexAttrib3sv(index,v):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLbyteArray) +def glVertexAttrib4Nbv(index,v):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLintArray) +def glVertexAttrib4Niv(index,v):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLshortArray) +def glVertexAttrib4Nsv(index,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLubyte,_cs.GLubyte,_cs.GLubyte,_cs.GLubyte) +def glVertexAttrib4Nub(index,x,y,z,w):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLubyteArray) +def glVertexAttrib4Nubv(index,v):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLuintArray) +def glVertexAttrib4Nuiv(index,v):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLushortArray) +def glVertexAttrib4Nusv(index,v):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLbyteArray) +def glVertexAttrib4bv(index,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLdouble,_cs.GLdouble,_cs.GLdouble,_cs.GLdouble) +def glVertexAttrib4d(index,x,y,z,w):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLdoubleArray) +def glVertexAttrib4dv(index,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat) +def glVertexAttrib4f(index,x,y,z,w):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLfloatArray) +def glVertexAttrib4fv(index,v):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLintArray) +def glVertexAttrib4iv(index,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLshort,_cs.GLshort,_cs.GLshort,_cs.GLshort) +def glVertexAttrib4s(index,x,y,z,w):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLshortArray) +def glVertexAttrib4sv(index,v):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLubyteArray) +def glVertexAttrib4ubv(index,v):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLuintArray) +def glVertexAttrib4uiv(index,v):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLushortArray) +def glVertexAttrib4usv(index,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLenum,_cs.GLboolean,_cs.GLsizei,ctypes.c_void_p) +def glVertexAttribPointer(index,size,type,normalized,stride,pointer):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/VERSION/GL_2_1.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/VERSION/GL_2_1.py new file mode 100644 index 00000000..5aa5a179 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/VERSION/GL_2_1.py @@ -0,0 +1,54 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_VERSION_GL_2_1' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_VERSION_GL_2_1',error_checker=_errors._error_checker) +GL_COMPRESSED_SLUMINANCE=_C('GL_COMPRESSED_SLUMINANCE',0x8C4A) +GL_COMPRESSED_SLUMINANCE_ALPHA=_C('GL_COMPRESSED_SLUMINANCE_ALPHA',0x8C4B) +GL_COMPRESSED_SRGB=_C('GL_COMPRESSED_SRGB',0x8C48) +GL_COMPRESSED_SRGB_ALPHA=_C('GL_COMPRESSED_SRGB_ALPHA',0x8C49) +GL_CURRENT_RASTER_SECONDARY_COLOR=_C('GL_CURRENT_RASTER_SECONDARY_COLOR',0x845F) +GL_FLOAT_MAT2x3=_C('GL_FLOAT_MAT2x3',0x8B65) +GL_FLOAT_MAT2x4=_C('GL_FLOAT_MAT2x4',0x8B66) +GL_FLOAT_MAT3x2=_C('GL_FLOAT_MAT3x2',0x8B67) +GL_FLOAT_MAT3x4=_C('GL_FLOAT_MAT3x4',0x8B68) +GL_FLOAT_MAT4x2=_C('GL_FLOAT_MAT4x2',0x8B69) +GL_FLOAT_MAT4x3=_C('GL_FLOAT_MAT4x3',0x8B6A) +GL_PIXEL_PACK_BUFFER=_C('GL_PIXEL_PACK_BUFFER',0x88EB) +GL_PIXEL_PACK_BUFFER_BINDING=_C('GL_PIXEL_PACK_BUFFER_BINDING',0x88ED) +GL_PIXEL_UNPACK_BUFFER=_C('GL_PIXEL_UNPACK_BUFFER',0x88EC) +GL_PIXEL_UNPACK_BUFFER_BINDING=_C('GL_PIXEL_UNPACK_BUFFER_BINDING',0x88EF) +GL_SLUMINANCE=_C('GL_SLUMINANCE',0x8C46) +GL_SLUMINANCE8=_C('GL_SLUMINANCE8',0x8C47) +GL_SLUMINANCE8_ALPHA8=_C('GL_SLUMINANCE8_ALPHA8',0x8C45) +GL_SLUMINANCE_ALPHA=_C('GL_SLUMINANCE_ALPHA',0x8C44) +GL_SRGB=_C('GL_SRGB',0x8C40) +GL_SRGB8=_C('GL_SRGB8',0x8C41) +GL_SRGB8_ALPHA8=_C('GL_SRGB8_ALPHA8',0x8C43) +GL_SRGB_ALPHA=_C('GL_SRGB_ALPHA',0x8C42) +@_f +@_p.types(None,_cs.GLint,_cs.GLsizei,_cs.GLboolean,arrays.GLfloatArray) +def glUniformMatrix2x3fv(location,count,transpose,value):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLsizei,_cs.GLboolean,arrays.GLfloatArray) +def glUniformMatrix2x4fv(location,count,transpose,value):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLsizei,_cs.GLboolean,arrays.GLfloatArray) +def glUniformMatrix3x2fv(location,count,transpose,value):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLsizei,_cs.GLboolean,arrays.GLfloatArray) +def glUniformMatrix3x4fv(location,count,transpose,value):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLsizei,_cs.GLboolean,arrays.GLfloatArray) +def glUniformMatrix4x2fv(location,count,transpose,value):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLsizei,_cs.GLboolean,arrays.GLfloatArray) +def glUniformMatrix4x3fv(location,count,transpose,value):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/VERSION/GL_3_0.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/VERSION/GL_3_0.py new file mode 100644 index 00000000..fc5487a4 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/VERSION/GL_3_0.py @@ -0,0 +1,502 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_VERSION_GL_3_0' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_VERSION_GL_3_0',error_checker=_errors._error_checker) +GL_ALPHA_INTEGER=_C('GL_ALPHA_INTEGER',0x8D97) +GL_BGRA_INTEGER=_C('GL_BGRA_INTEGER',0x8D9B) +GL_BGR_INTEGER=_C('GL_BGR_INTEGER',0x8D9A) +GL_BLUE_INTEGER=_C('GL_BLUE_INTEGER',0x8D96) +GL_BUFFER_ACCESS_FLAGS=_C('GL_BUFFER_ACCESS_FLAGS',0x911F) +GL_BUFFER_MAP_LENGTH=_C('GL_BUFFER_MAP_LENGTH',0x9120) +GL_BUFFER_MAP_OFFSET=_C('GL_BUFFER_MAP_OFFSET',0x9121) +GL_CLAMP_FRAGMENT_COLOR=_C('GL_CLAMP_FRAGMENT_COLOR',0x891B) +GL_CLAMP_READ_COLOR=_C('GL_CLAMP_READ_COLOR',0x891C) +GL_CLAMP_VERTEX_COLOR=_C('GL_CLAMP_VERTEX_COLOR',0x891A) +GL_CLIP_DISTANCE0=_C('GL_CLIP_DISTANCE0',0x3000) +GL_CLIP_DISTANCE1=_C('GL_CLIP_DISTANCE1',0x3001) +GL_CLIP_DISTANCE2=_C('GL_CLIP_DISTANCE2',0x3002) +GL_CLIP_DISTANCE3=_C('GL_CLIP_DISTANCE3',0x3003) +GL_CLIP_DISTANCE4=_C('GL_CLIP_DISTANCE4',0x3004) +GL_CLIP_DISTANCE5=_C('GL_CLIP_DISTANCE5',0x3005) +GL_CLIP_DISTANCE6=_C('GL_CLIP_DISTANCE6',0x3006) +GL_CLIP_DISTANCE7=_C('GL_CLIP_DISTANCE7',0x3007) +GL_COLOR_ATTACHMENT0=_C('GL_COLOR_ATTACHMENT0',0x8CE0) +GL_COLOR_ATTACHMENT1=_C('GL_COLOR_ATTACHMENT1',0x8CE1) +GL_COLOR_ATTACHMENT10=_C('GL_COLOR_ATTACHMENT10',0x8CEA) +GL_COLOR_ATTACHMENT11=_C('GL_COLOR_ATTACHMENT11',0x8CEB) +GL_COLOR_ATTACHMENT12=_C('GL_COLOR_ATTACHMENT12',0x8CEC) +GL_COLOR_ATTACHMENT13=_C('GL_COLOR_ATTACHMENT13',0x8CED) +GL_COLOR_ATTACHMENT14=_C('GL_COLOR_ATTACHMENT14',0x8CEE) +GL_COLOR_ATTACHMENT15=_C('GL_COLOR_ATTACHMENT15',0x8CEF) +GL_COLOR_ATTACHMENT16=_C('GL_COLOR_ATTACHMENT16',0x8CF0) +GL_COLOR_ATTACHMENT17=_C('GL_COLOR_ATTACHMENT17',0x8CF1) +GL_COLOR_ATTACHMENT18=_C('GL_COLOR_ATTACHMENT18',0x8CF2) +GL_COLOR_ATTACHMENT19=_C('GL_COLOR_ATTACHMENT19',0x8CF3) +GL_COLOR_ATTACHMENT2=_C('GL_COLOR_ATTACHMENT2',0x8CE2) +GL_COLOR_ATTACHMENT20=_C('GL_COLOR_ATTACHMENT20',0x8CF4) +GL_COLOR_ATTACHMENT21=_C('GL_COLOR_ATTACHMENT21',0x8CF5) +GL_COLOR_ATTACHMENT22=_C('GL_COLOR_ATTACHMENT22',0x8CF6) +GL_COLOR_ATTACHMENT23=_C('GL_COLOR_ATTACHMENT23',0x8CF7) +GL_COLOR_ATTACHMENT24=_C('GL_COLOR_ATTACHMENT24',0x8CF8) +GL_COLOR_ATTACHMENT25=_C('GL_COLOR_ATTACHMENT25',0x8CF9) +GL_COLOR_ATTACHMENT26=_C('GL_COLOR_ATTACHMENT26',0x8CFA) +GL_COLOR_ATTACHMENT27=_C('GL_COLOR_ATTACHMENT27',0x8CFB) +GL_COLOR_ATTACHMENT28=_C('GL_COLOR_ATTACHMENT28',0x8CFC) +GL_COLOR_ATTACHMENT29=_C('GL_COLOR_ATTACHMENT29',0x8CFD) +GL_COLOR_ATTACHMENT3=_C('GL_COLOR_ATTACHMENT3',0x8CE3) +GL_COLOR_ATTACHMENT30=_C('GL_COLOR_ATTACHMENT30',0x8CFE) +GL_COLOR_ATTACHMENT31=_C('GL_COLOR_ATTACHMENT31',0x8CFF) +GL_COLOR_ATTACHMENT4=_C('GL_COLOR_ATTACHMENT4',0x8CE4) +GL_COLOR_ATTACHMENT5=_C('GL_COLOR_ATTACHMENT5',0x8CE5) +GL_COLOR_ATTACHMENT6=_C('GL_COLOR_ATTACHMENT6',0x8CE6) +GL_COLOR_ATTACHMENT7=_C('GL_COLOR_ATTACHMENT7',0x8CE7) +GL_COLOR_ATTACHMENT8=_C('GL_COLOR_ATTACHMENT8',0x8CE8) +GL_COLOR_ATTACHMENT9=_C('GL_COLOR_ATTACHMENT9',0x8CE9) +GL_COMPARE_REF_TO_TEXTURE=_C('GL_COMPARE_REF_TO_TEXTURE',0x884E) +GL_COMPRESSED_RED=_C('GL_COMPRESSED_RED',0x8225) +GL_COMPRESSED_RED_RGTC1=_C('GL_COMPRESSED_RED_RGTC1',0x8DBB) +GL_COMPRESSED_RG=_C('GL_COMPRESSED_RG',0x8226) +GL_COMPRESSED_RG_RGTC2=_C('GL_COMPRESSED_RG_RGTC2',0x8DBD) +GL_COMPRESSED_SIGNED_RED_RGTC1=_C('GL_COMPRESSED_SIGNED_RED_RGTC1',0x8DBC) +GL_COMPRESSED_SIGNED_RG_RGTC2=_C('GL_COMPRESSED_SIGNED_RG_RGTC2',0x8DBE) +GL_CONTEXT_FLAGS=_C('GL_CONTEXT_FLAGS',0x821E) +GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT=_C('GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT',0x00000001) +GL_DEPTH24_STENCIL8=_C('GL_DEPTH24_STENCIL8',0x88F0) +GL_DEPTH32F_STENCIL8=_C('GL_DEPTH32F_STENCIL8',0x8CAD) +GL_DEPTH_ATTACHMENT=_C('GL_DEPTH_ATTACHMENT',0x8D00) +GL_DEPTH_COMPONENT32F=_C('GL_DEPTH_COMPONENT32F',0x8CAC) +GL_DEPTH_STENCIL=_C('GL_DEPTH_STENCIL',0x84F9) +GL_DEPTH_STENCIL_ATTACHMENT=_C('GL_DEPTH_STENCIL_ATTACHMENT',0x821A) +GL_DRAW_FRAMEBUFFER=_C('GL_DRAW_FRAMEBUFFER',0x8CA9) +GL_DRAW_FRAMEBUFFER_BINDING=_C('GL_DRAW_FRAMEBUFFER_BINDING',0x8CA6) +GL_FIXED_ONLY=_C('GL_FIXED_ONLY',0x891D) +GL_FLOAT_32_UNSIGNED_INT_24_8_REV=_C('GL_FLOAT_32_UNSIGNED_INT_24_8_REV',0x8DAD) +GL_FRAMEBUFFER=_C('GL_FRAMEBUFFER',0x8D40) +GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE=_C('GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE',0x8215) +GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE=_C('GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE',0x8214) +GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING=_C('GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING',0x8210) +GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE=_C('GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE',0x8211) +GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE=_C('GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE',0x8216) +GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE=_C('GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE',0x8213) +GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME=_C('GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME',0x8CD1) +GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE=_C('GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE',0x8CD0) +GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE=_C('GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE',0x8212) +GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE=_C('GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE',0x8217) +GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE=_C('GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE',0x8CD3) +GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER=_C('GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER',0x8CD4) +GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL=_C('GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL',0x8CD2) +GL_FRAMEBUFFER_BINDING=_C('GL_FRAMEBUFFER_BINDING',0x8CA6) +GL_FRAMEBUFFER_COMPLETE=_C('GL_FRAMEBUFFER_COMPLETE',0x8CD5) +GL_FRAMEBUFFER_DEFAULT=_C('GL_FRAMEBUFFER_DEFAULT',0x8218) +GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT=_C('GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT',0x8CD6) +GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER=_C('GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER',0x8CDB) +GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT=_C('GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT',0x8CD7) +GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE=_C('GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE',0x8D56) +GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER=_C('GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER',0x8CDC) +GL_FRAMEBUFFER_SRGB=_C('GL_FRAMEBUFFER_SRGB',0x8DB9) +GL_FRAMEBUFFER_UNDEFINED=_C('GL_FRAMEBUFFER_UNDEFINED',0x8219) +GL_FRAMEBUFFER_UNSUPPORTED=_C('GL_FRAMEBUFFER_UNSUPPORTED',0x8CDD) +GL_GREEN_INTEGER=_C('GL_GREEN_INTEGER',0x8D95) +GL_HALF_FLOAT=_C('GL_HALF_FLOAT',0x140B) +GL_INDEX=_C('GL_INDEX',0x8222) +GL_INTERLEAVED_ATTRIBS=_C('GL_INTERLEAVED_ATTRIBS',0x8C8C) +GL_INT_SAMPLER_1D=_C('GL_INT_SAMPLER_1D',0x8DC9) +GL_INT_SAMPLER_1D_ARRAY=_C('GL_INT_SAMPLER_1D_ARRAY',0x8DCE) +GL_INT_SAMPLER_2D=_C('GL_INT_SAMPLER_2D',0x8DCA) +GL_INT_SAMPLER_2D_ARRAY=_C('GL_INT_SAMPLER_2D_ARRAY',0x8DCF) +GL_INT_SAMPLER_3D=_C('GL_INT_SAMPLER_3D',0x8DCB) +GL_INT_SAMPLER_CUBE=_C('GL_INT_SAMPLER_CUBE',0x8DCC) +GL_INVALID_FRAMEBUFFER_OPERATION=_C('GL_INVALID_FRAMEBUFFER_OPERATION',0x0506) +GL_MAJOR_VERSION=_C('GL_MAJOR_VERSION',0x821B) +GL_MAP_FLUSH_EXPLICIT_BIT=_C('GL_MAP_FLUSH_EXPLICIT_BIT',0x0010) +GL_MAP_INVALIDATE_BUFFER_BIT=_C('GL_MAP_INVALIDATE_BUFFER_BIT',0x0008) +GL_MAP_INVALIDATE_RANGE_BIT=_C('GL_MAP_INVALIDATE_RANGE_BIT',0x0004) +GL_MAP_READ_BIT=_C('GL_MAP_READ_BIT',0x0001) +GL_MAP_UNSYNCHRONIZED_BIT=_C('GL_MAP_UNSYNCHRONIZED_BIT',0x0020) +GL_MAP_WRITE_BIT=_C('GL_MAP_WRITE_BIT',0x0002) +GL_MAX_ARRAY_TEXTURE_LAYERS=_C('GL_MAX_ARRAY_TEXTURE_LAYERS',0x88FF) +GL_MAX_CLIP_DISTANCES=_C('GL_MAX_CLIP_DISTANCES',0x0D32) +GL_MAX_COLOR_ATTACHMENTS=_C('GL_MAX_COLOR_ATTACHMENTS',0x8CDF) +GL_MAX_PROGRAM_TEXEL_OFFSET=_C('GL_MAX_PROGRAM_TEXEL_OFFSET',0x8905) +GL_MAX_RENDERBUFFER_SIZE=_C('GL_MAX_RENDERBUFFER_SIZE',0x84E8) +GL_MAX_SAMPLES=_C('GL_MAX_SAMPLES',0x8D57) +GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS=_C('GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS',0x8C8A) +GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS=_C('GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS',0x8C8B) +GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS=_C('GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS',0x8C80) +GL_MAX_VARYING_COMPONENTS=_C('GL_MAX_VARYING_COMPONENTS',0x8B4B) +GL_MINOR_VERSION=_C('GL_MINOR_VERSION',0x821C) +GL_MIN_PROGRAM_TEXEL_OFFSET=_C('GL_MIN_PROGRAM_TEXEL_OFFSET',0x8904) +GL_NUM_EXTENSIONS=_C('GL_NUM_EXTENSIONS',0x821D) +GL_PRIMITIVES_GENERATED=_C('GL_PRIMITIVES_GENERATED',0x8C87) +GL_PROXY_TEXTURE_1D_ARRAY=_C('GL_PROXY_TEXTURE_1D_ARRAY',0x8C19) +GL_PROXY_TEXTURE_2D_ARRAY=_C('GL_PROXY_TEXTURE_2D_ARRAY',0x8C1B) +GL_QUERY_BY_REGION_NO_WAIT=_C('GL_QUERY_BY_REGION_NO_WAIT',0x8E16) +GL_QUERY_BY_REGION_WAIT=_C('GL_QUERY_BY_REGION_WAIT',0x8E15) +GL_QUERY_NO_WAIT=_C('GL_QUERY_NO_WAIT',0x8E14) +GL_QUERY_WAIT=_C('GL_QUERY_WAIT',0x8E13) +GL_R11F_G11F_B10F=_C('GL_R11F_G11F_B10F',0x8C3A) +GL_R16=_C('GL_R16',0x822A) +GL_R16F=_C('GL_R16F',0x822D) +GL_R16I=_C('GL_R16I',0x8233) +GL_R16UI=_C('GL_R16UI',0x8234) +GL_R32F=_C('GL_R32F',0x822E) +GL_R32I=_C('GL_R32I',0x8235) +GL_R32UI=_C('GL_R32UI',0x8236) +GL_R8=_C('GL_R8',0x8229) +GL_R8I=_C('GL_R8I',0x8231) +GL_R8UI=_C('GL_R8UI',0x8232) +GL_RASTERIZER_DISCARD=_C('GL_RASTERIZER_DISCARD',0x8C89) +GL_READ_FRAMEBUFFER=_C('GL_READ_FRAMEBUFFER',0x8CA8) +GL_READ_FRAMEBUFFER_BINDING=_C('GL_READ_FRAMEBUFFER_BINDING',0x8CAA) +GL_RED_INTEGER=_C('GL_RED_INTEGER',0x8D94) +GL_RENDERBUFFER=_C('GL_RENDERBUFFER',0x8D41) +GL_RENDERBUFFER_ALPHA_SIZE=_C('GL_RENDERBUFFER_ALPHA_SIZE',0x8D53) +GL_RENDERBUFFER_BINDING=_C('GL_RENDERBUFFER_BINDING',0x8CA7) +GL_RENDERBUFFER_BLUE_SIZE=_C('GL_RENDERBUFFER_BLUE_SIZE',0x8D52) +GL_RENDERBUFFER_DEPTH_SIZE=_C('GL_RENDERBUFFER_DEPTH_SIZE',0x8D54) +GL_RENDERBUFFER_GREEN_SIZE=_C('GL_RENDERBUFFER_GREEN_SIZE',0x8D51) +GL_RENDERBUFFER_HEIGHT=_C('GL_RENDERBUFFER_HEIGHT',0x8D43) +GL_RENDERBUFFER_INTERNAL_FORMAT=_C('GL_RENDERBUFFER_INTERNAL_FORMAT',0x8D44) +GL_RENDERBUFFER_RED_SIZE=_C('GL_RENDERBUFFER_RED_SIZE',0x8D50) +GL_RENDERBUFFER_SAMPLES=_C('GL_RENDERBUFFER_SAMPLES',0x8CAB) +GL_RENDERBUFFER_STENCIL_SIZE=_C('GL_RENDERBUFFER_STENCIL_SIZE',0x8D55) +GL_RENDERBUFFER_WIDTH=_C('GL_RENDERBUFFER_WIDTH',0x8D42) +GL_RG=_C('GL_RG',0x8227) +GL_RG16=_C('GL_RG16',0x822C) +GL_RG16F=_C('GL_RG16F',0x822F) +GL_RG16I=_C('GL_RG16I',0x8239) +GL_RG16UI=_C('GL_RG16UI',0x823A) +GL_RG32F=_C('GL_RG32F',0x8230) +GL_RG32I=_C('GL_RG32I',0x823B) +GL_RG32UI=_C('GL_RG32UI',0x823C) +GL_RG8=_C('GL_RG8',0x822B) +GL_RG8I=_C('GL_RG8I',0x8237) +GL_RG8UI=_C('GL_RG8UI',0x8238) +GL_RGB16F=_C('GL_RGB16F',0x881B) +GL_RGB16I=_C('GL_RGB16I',0x8D89) +GL_RGB16UI=_C('GL_RGB16UI',0x8D77) +GL_RGB32F=_C('GL_RGB32F',0x8815) +GL_RGB32I=_C('GL_RGB32I',0x8D83) +GL_RGB32UI=_C('GL_RGB32UI',0x8D71) +GL_RGB8I=_C('GL_RGB8I',0x8D8F) +GL_RGB8UI=_C('GL_RGB8UI',0x8D7D) +GL_RGB9_E5=_C('GL_RGB9_E5',0x8C3D) +GL_RGBA16F=_C('GL_RGBA16F',0x881A) +GL_RGBA16I=_C('GL_RGBA16I',0x8D88) +GL_RGBA16UI=_C('GL_RGBA16UI',0x8D76) +GL_RGBA32F=_C('GL_RGBA32F',0x8814) +GL_RGBA32I=_C('GL_RGBA32I',0x8D82) +GL_RGBA32UI=_C('GL_RGBA32UI',0x8D70) +GL_RGBA8I=_C('GL_RGBA8I',0x8D8E) +GL_RGBA8UI=_C('GL_RGBA8UI',0x8D7C) +GL_RGBA_INTEGER=_C('GL_RGBA_INTEGER',0x8D99) +GL_RGB_INTEGER=_C('GL_RGB_INTEGER',0x8D98) +GL_RG_INTEGER=_C('GL_RG_INTEGER',0x8228) +GL_SAMPLER_1D_ARRAY=_C('GL_SAMPLER_1D_ARRAY',0x8DC0) +GL_SAMPLER_1D_ARRAY_SHADOW=_C('GL_SAMPLER_1D_ARRAY_SHADOW',0x8DC3) +GL_SAMPLER_2D_ARRAY=_C('GL_SAMPLER_2D_ARRAY',0x8DC1) +GL_SAMPLER_2D_ARRAY_SHADOW=_C('GL_SAMPLER_2D_ARRAY_SHADOW',0x8DC4) +GL_SAMPLER_CUBE_SHADOW=_C('GL_SAMPLER_CUBE_SHADOW',0x8DC5) +GL_SEPARATE_ATTRIBS=_C('GL_SEPARATE_ATTRIBS',0x8C8D) +GL_STENCIL_ATTACHMENT=_C('GL_STENCIL_ATTACHMENT',0x8D20) +GL_STENCIL_INDEX1=_C('GL_STENCIL_INDEX1',0x8D46) +GL_STENCIL_INDEX16=_C('GL_STENCIL_INDEX16',0x8D49) +GL_STENCIL_INDEX4=_C('GL_STENCIL_INDEX4',0x8D47) +GL_STENCIL_INDEX8=_C('GL_STENCIL_INDEX8',0x8D48) +GL_TEXTURE_1D_ARRAY=_C('GL_TEXTURE_1D_ARRAY',0x8C18) +GL_TEXTURE_2D_ARRAY=_C('GL_TEXTURE_2D_ARRAY',0x8C1A) +GL_TEXTURE_ALPHA_TYPE=_C('GL_TEXTURE_ALPHA_TYPE',0x8C13) +GL_TEXTURE_BINDING_1D_ARRAY=_C('GL_TEXTURE_BINDING_1D_ARRAY',0x8C1C) +GL_TEXTURE_BINDING_2D_ARRAY=_C('GL_TEXTURE_BINDING_2D_ARRAY',0x8C1D) +GL_TEXTURE_BLUE_TYPE=_C('GL_TEXTURE_BLUE_TYPE',0x8C12) +GL_TEXTURE_DEPTH_TYPE=_C('GL_TEXTURE_DEPTH_TYPE',0x8C16) +GL_TEXTURE_GREEN_TYPE=_C('GL_TEXTURE_GREEN_TYPE',0x8C11) +GL_TEXTURE_INTENSITY_TYPE=_C('GL_TEXTURE_INTENSITY_TYPE',0x8C15) +GL_TEXTURE_LUMINANCE_TYPE=_C('GL_TEXTURE_LUMINANCE_TYPE',0x8C14) +GL_TEXTURE_RED_TYPE=_C('GL_TEXTURE_RED_TYPE',0x8C10) +GL_TEXTURE_SHARED_SIZE=_C('GL_TEXTURE_SHARED_SIZE',0x8C3F) +GL_TEXTURE_STENCIL_SIZE=_C('GL_TEXTURE_STENCIL_SIZE',0x88F1) +GL_TRANSFORM_FEEDBACK_BUFFER=_C('GL_TRANSFORM_FEEDBACK_BUFFER',0x8C8E) +GL_TRANSFORM_FEEDBACK_BUFFER_BINDING=_C('GL_TRANSFORM_FEEDBACK_BUFFER_BINDING',0x8C8F) +GL_TRANSFORM_FEEDBACK_BUFFER_MODE=_C('GL_TRANSFORM_FEEDBACK_BUFFER_MODE',0x8C7F) +GL_TRANSFORM_FEEDBACK_BUFFER_SIZE=_C('GL_TRANSFORM_FEEDBACK_BUFFER_SIZE',0x8C85) +GL_TRANSFORM_FEEDBACK_BUFFER_START=_C('GL_TRANSFORM_FEEDBACK_BUFFER_START',0x8C84) +GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN=_C('GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN',0x8C88) +GL_TRANSFORM_FEEDBACK_VARYINGS=_C('GL_TRANSFORM_FEEDBACK_VARYINGS',0x8C83) +GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH=_C('GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH',0x8C76) +GL_UNSIGNED_INT_10F_11F_11F_REV=_C('GL_UNSIGNED_INT_10F_11F_11F_REV',0x8C3B) +GL_UNSIGNED_INT_24_8=_C('GL_UNSIGNED_INT_24_8',0x84FA) +GL_UNSIGNED_INT_5_9_9_9_REV=_C('GL_UNSIGNED_INT_5_9_9_9_REV',0x8C3E) +GL_UNSIGNED_INT_SAMPLER_1D=_C('GL_UNSIGNED_INT_SAMPLER_1D',0x8DD1) +GL_UNSIGNED_INT_SAMPLER_1D_ARRAY=_C('GL_UNSIGNED_INT_SAMPLER_1D_ARRAY',0x8DD6) +GL_UNSIGNED_INT_SAMPLER_2D=_C('GL_UNSIGNED_INT_SAMPLER_2D',0x8DD2) +GL_UNSIGNED_INT_SAMPLER_2D_ARRAY=_C('GL_UNSIGNED_INT_SAMPLER_2D_ARRAY',0x8DD7) +GL_UNSIGNED_INT_SAMPLER_3D=_C('GL_UNSIGNED_INT_SAMPLER_3D',0x8DD3) +GL_UNSIGNED_INT_SAMPLER_CUBE=_C('GL_UNSIGNED_INT_SAMPLER_CUBE',0x8DD4) +GL_UNSIGNED_INT_VEC2=_C('GL_UNSIGNED_INT_VEC2',0x8DC6) +GL_UNSIGNED_INT_VEC3=_C('GL_UNSIGNED_INT_VEC3',0x8DC7) +GL_UNSIGNED_INT_VEC4=_C('GL_UNSIGNED_INT_VEC4',0x8DC8) +GL_UNSIGNED_NORMALIZED=_C('GL_UNSIGNED_NORMALIZED',0x8C17) +GL_VERTEX_ARRAY_BINDING=_C('GL_VERTEX_ARRAY_BINDING',0x85B5) +GL_VERTEX_ATTRIB_ARRAY_INTEGER=_C('GL_VERTEX_ATTRIB_ARRAY_INTEGER',0x88FD) +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum) +def glBeginConditionalRender(id,mode):pass +@_f +@_p.types(None,_cs.GLenum) +def glBeginTransformFeedback(primitiveMode):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,_cs.GLuint) +def glBindBufferBase(target,index,buffer):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,_cs.GLuint,_cs.GLintptr,_cs.GLsizeiptr) +def glBindBufferRange(target,index,buffer,offset,size):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,arrays.GLcharArray) +def glBindFragDataLocation(program,color,name):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint) +def glBindFramebuffer(target,framebuffer):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint) +def glBindRenderbuffer(target,renderbuffer):pass +@_f +@_p.types(None,_cs.GLuint) +def glBindVertexArray(array):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLbitfield,_cs.GLenum) +def glBlitFramebuffer(srcX0,srcY0,srcX1,srcY1,dstX0,dstY0,dstX1,dstY1,mask,filter):pass +@_f +@_p.types(_cs.GLenum,_cs.GLenum) +def glCheckFramebufferStatus(target):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum) +def glClampColor(target,clamp):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLint,_cs.GLfloat,_cs.GLint) +def glClearBufferfi(buffer,drawbuffer,depth,stencil):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLint,arrays.GLfloatArray) +def glClearBufferfv(buffer,drawbuffer,value):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLint,arrays.GLintArray) +def glClearBufferiv(buffer,drawbuffer,value):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLint,arrays.GLuintArray) +def glClearBufferuiv(buffer,drawbuffer,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLboolean,_cs.GLboolean,_cs.GLboolean,_cs.GLboolean) +def glColorMaski(index,r,g,b,a):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray) +def glDeleteFramebuffers(n,framebuffers):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray) +def glDeleteRenderbuffers(n,renderbuffers):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray) +def glDeleteVertexArrays(n,arrays):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint) +def glDisablei(target,index):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint) +def glEnablei(target,index):pass +@_f +@_p.types(None,) +def glEndConditionalRender():pass +@_f +@_p.types(None,) +def glEndTransformFeedback():pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLintptr,_cs.GLsizeiptr) +def glFlushMappedBufferRange(target,offset,length):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLenum,_cs.GLuint) +def glFramebufferRenderbuffer(target,attachment,renderbuffertarget,renderbuffer):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLenum,_cs.GLuint,_cs.GLint) +def glFramebufferTexture1D(target,attachment,textarget,texture,level):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLenum,_cs.GLuint,_cs.GLint) +def glFramebufferTexture2D(target,attachment,textarget,texture,level):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLenum,_cs.GLuint,_cs.GLint,_cs.GLint) +def glFramebufferTexture3D(target,attachment,textarget,texture,level,zoffset):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLuint,_cs.GLint,_cs.GLint) +def glFramebufferTextureLayer(target,attachment,texture,level,layer):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray) +def glGenFramebuffers(n,framebuffers):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray) +def glGenRenderbuffers(n,renderbuffers):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray) +def glGenVertexArrays(n,arrays):pass +@_f +@_p.types(None,_cs.GLenum) +def glGenerateMipmap(target):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,arrays.GLbooleanArray) +def glGetBooleani_v(target,index,data):pass +@_f +@_p.types(_cs.GLint,_cs.GLuint,arrays.GLcharArray) +def glGetFragDataLocation(program,name):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLenum,arrays.GLintArray) +def glGetFramebufferAttachmentParameteriv(target,attachment,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,arrays.GLintArray) +def glGetIntegeri_v(target,index,data):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLintArray) +def glGetRenderbufferParameteriv(target,pname,params):pass +@_f +@_p.types(arrays.GLubyteArray,_cs.GLenum,_cs.GLuint) +def glGetStringi(name,index):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLintArray) +def glGetTexParameterIiv(target,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLuintArray) +def glGetTexParameterIuiv(target,pname,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLsizei,arrays.GLsizeiArray,arrays.GLsizeiArray,arrays.GLuintArray,arrays.GLcharArray) +def glGetTransformFeedbackVarying(program,index,bufSize,length,size,type,name):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,arrays.GLuintArray) +def glGetUniformuiv(program,location,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLintArray) +def glGetVertexAttribIiv(index,pname,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLuintArray) +def glGetVertexAttribIuiv(index,pname,params):pass +@_f +@_p.types(_cs.GLboolean,_cs.GLenum,_cs.GLuint) +def glIsEnabledi(target,index):pass +@_f +@_p.types(_cs.GLboolean,_cs.GLuint) +def glIsFramebuffer(framebuffer):pass +@_f +@_p.types(_cs.GLboolean,_cs.GLuint) +def glIsRenderbuffer(renderbuffer):pass +@_f +@_p.types(_cs.GLboolean,_cs.GLuint) +def glIsVertexArray(array):pass +@_f +@_p.types(ctypes.c_void_p,_cs.GLenum,_cs.GLintptr,_cs.GLsizeiptr,_cs.GLbitfield) +def glMapBufferRange(target,offset,length,access):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLsizei,_cs.GLsizei) +def glRenderbufferStorage(target,internalformat,width,height):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizei,_cs.GLenum,_cs.GLsizei,_cs.GLsizei) +def glRenderbufferStorageMultisample(target,samples,internalformat,width,height):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLintArray) +def glTexParameterIiv(target,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLuintArray) +def glTexParameterIuiv(target,pname,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizei,ctypes.POINTER( ctypes.POINTER( _cs.GLchar )),_cs.GLenum) +def glTransformFeedbackVaryings(program,count,varyings,bufferMode):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLuint) +def glUniform1ui(location,v0):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLsizei,arrays.GLuintArray) +def glUniform1uiv(location,count,value):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLuint,_cs.GLuint) +def glUniform2ui(location,v0,v1):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLsizei,arrays.GLuintArray) +def glUniform2uiv(location,count,value):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLuint,_cs.GLuint,_cs.GLuint) +def glUniform3ui(location,v0,v1,v2):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLsizei,arrays.GLuintArray) +def glUniform3uiv(location,count,value):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLuint,_cs.GLuint,_cs.GLuint,_cs.GLuint) +def glUniform4ui(location,v0,v1,v2,v3):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLsizei,arrays.GLuintArray) +def glUniform4uiv(location,count,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint) +def glVertexAttribI1i(index,x):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLintArray) +def glVertexAttribI1iv(index,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint) +def glVertexAttribI1ui(index,x):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLuintArray) +def glVertexAttribI1uiv(index,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLint) +def glVertexAttribI2i(index,x,y):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLintArray) +def glVertexAttribI2iv(index,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLuint) +def glVertexAttribI2ui(index,x,y):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLuintArray) +def glVertexAttribI2uiv(index,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLint,_cs.GLint) +def glVertexAttribI3i(index,x,y,z):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLintArray) +def glVertexAttribI3iv(index,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLuint,_cs.GLuint) +def glVertexAttribI3ui(index,x,y,z):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLuintArray) +def glVertexAttribI3uiv(index,v):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLbyteArray) +def glVertexAttribI4bv(index,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint) +def glVertexAttribI4i(index,x,y,z,w):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLintArray) +def glVertexAttribI4iv(index,v):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLshortArray) +def glVertexAttribI4sv(index,v):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLubyteArray) +def glVertexAttribI4ubv(index,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLuint,_cs.GLuint,_cs.GLuint) +def glVertexAttribI4ui(index,x,y,z,w):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLuintArray) +def glVertexAttribI4uiv(index,v):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLushortArray) +def glVertexAttribI4usv(index,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLenum,_cs.GLsizei,ctypes.c_void_p) +def glVertexAttribIPointer(index,size,type,stride,pointer):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/VERSION/GL_3_1.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/VERSION/GL_3_1.py new file mode 100644 index 00000000..1166259a --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/VERSION/GL_3_1.py @@ -0,0 +1,119 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_VERSION_GL_3_1' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_VERSION_GL_3_1',error_checker=_errors._error_checker) +GL_ACTIVE_UNIFORM_BLOCKS=_C('GL_ACTIVE_UNIFORM_BLOCKS',0x8A36) +GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH=_C('GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH',0x8A35) +GL_COPY_READ_BUFFER=_C('GL_COPY_READ_BUFFER',0x8F36) +GL_COPY_WRITE_BUFFER=_C('GL_COPY_WRITE_BUFFER',0x8F37) +GL_INT_SAMPLER_2D_RECT=_C('GL_INT_SAMPLER_2D_RECT',0x8DCD) +GL_INT_SAMPLER_BUFFER=_C('GL_INT_SAMPLER_BUFFER',0x8DD0) +GL_INVALID_INDEX=_C('GL_INVALID_INDEX',0xFFFFFFFF) +GL_MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS=_C('GL_MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS',0x8A33) +GL_MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS=_C('GL_MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS',0x8A32) +GL_MAX_COMBINED_UNIFORM_BLOCKS=_C('GL_MAX_COMBINED_UNIFORM_BLOCKS',0x8A2E) +GL_MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS=_C('GL_MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS',0x8A31) +GL_MAX_FRAGMENT_UNIFORM_BLOCKS=_C('GL_MAX_FRAGMENT_UNIFORM_BLOCKS',0x8A2D) +GL_MAX_GEOMETRY_UNIFORM_BLOCKS=_C('GL_MAX_GEOMETRY_UNIFORM_BLOCKS',0x8A2C) +GL_MAX_RECTANGLE_TEXTURE_SIZE=_C('GL_MAX_RECTANGLE_TEXTURE_SIZE',0x84F8) +GL_MAX_TEXTURE_BUFFER_SIZE=_C('GL_MAX_TEXTURE_BUFFER_SIZE',0x8C2B) +GL_MAX_UNIFORM_BLOCK_SIZE=_C('GL_MAX_UNIFORM_BLOCK_SIZE',0x8A30) +GL_MAX_UNIFORM_BUFFER_BINDINGS=_C('GL_MAX_UNIFORM_BUFFER_BINDINGS',0x8A2F) +GL_MAX_VERTEX_UNIFORM_BLOCKS=_C('GL_MAX_VERTEX_UNIFORM_BLOCKS',0x8A2B) +GL_PRIMITIVE_RESTART=_C('GL_PRIMITIVE_RESTART',0x8F9D) +GL_PRIMITIVE_RESTART_INDEX=_C('GL_PRIMITIVE_RESTART_INDEX',0x8F9E) +GL_PROXY_TEXTURE_RECTANGLE=_C('GL_PROXY_TEXTURE_RECTANGLE',0x84F7) +GL_R16_SNORM=_C('GL_R16_SNORM',0x8F98) +GL_R8_SNORM=_C('GL_R8_SNORM',0x8F94) +GL_RG16_SNORM=_C('GL_RG16_SNORM',0x8F99) +GL_RG8_SNORM=_C('GL_RG8_SNORM',0x8F95) +GL_RGB16_SNORM=_C('GL_RGB16_SNORM',0x8F9A) +GL_RGB8_SNORM=_C('GL_RGB8_SNORM',0x8F96) +GL_RGBA16_SNORM=_C('GL_RGBA16_SNORM',0x8F9B) +GL_RGBA8_SNORM=_C('GL_RGBA8_SNORM',0x8F97) +GL_SAMPLER_2D_RECT=_C('GL_SAMPLER_2D_RECT',0x8B63) +GL_SAMPLER_2D_RECT_SHADOW=_C('GL_SAMPLER_2D_RECT_SHADOW',0x8B64) +GL_SAMPLER_BUFFER=_C('GL_SAMPLER_BUFFER',0x8DC2) +GL_SIGNED_NORMALIZED=_C('GL_SIGNED_NORMALIZED',0x8F9C) +GL_TEXTURE_BINDING_BUFFER=_C('GL_TEXTURE_BINDING_BUFFER',0x8C2C) +GL_TEXTURE_BINDING_RECTANGLE=_C('GL_TEXTURE_BINDING_RECTANGLE',0x84F6) +GL_TEXTURE_BUFFER=_C('GL_TEXTURE_BUFFER',0x8C2A) +GL_TEXTURE_BUFFER_DATA_STORE_BINDING=_C('GL_TEXTURE_BUFFER_DATA_STORE_BINDING',0x8C2D) +GL_TEXTURE_RECTANGLE=_C('GL_TEXTURE_RECTANGLE',0x84F5) +GL_UNIFORM_ARRAY_STRIDE=_C('GL_UNIFORM_ARRAY_STRIDE',0x8A3C) +GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS=_C('GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS',0x8A42) +GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES=_C('GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES',0x8A43) +GL_UNIFORM_BLOCK_BINDING=_C('GL_UNIFORM_BLOCK_BINDING',0x8A3F) +GL_UNIFORM_BLOCK_DATA_SIZE=_C('GL_UNIFORM_BLOCK_DATA_SIZE',0x8A40) +GL_UNIFORM_BLOCK_INDEX=_C('GL_UNIFORM_BLOCK_INDEX',0x8A3A) +GL_UNIFORM_BLOCK_NAME_LENGTH=_C('GL_UNIFORM_BLOCK_NAME_LENGTH',0x8A41) +GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER=_C('GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER',0x8A46) +GL_UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER=_C('GL_UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER',0x8A45) +GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER=_C('GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER',0x8A44) +GL_UNIFORM_BUFFER=_C('GL_UNIFORM_BUFFER',0x8A11) +GL_UNIFORM_BUFFER_BINDING=_C('GL_UNIFORM_BUFFER_BINDING',0x8A28) +GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT=_C('GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT',0x8A34) +GL_UNIFORM_BUFFER_SIZE=_C('GL_UNIFORM_BUFFER_SIZE',0x8A2A) +GL_UNIFORM_BUFFER_START=_C('GL_UNIFORM_BUFFER_START',0x8A29) +GL_UNIFORM_IS_ROW_MAJOR=_C('GL_UNIFORM_IS_ROW_MAJOR',0x8A3E) +GL_UNIFORM_MATRIX_STRIDE=_C('GL_UNIFORM_MATRIX_STRIDE',0x8A3D) +GL_UNIFORM_NAME_LENGTH=_C('GL_UNIFORM_NAME_LENGTH',0x8A39) +GL_UNIFORM_OFFSET=_C('GL_UNIFORM_OFFSET',0x8A3B) +GL_UNIFORM_SIZE=_C('GL_UNIFORM_SIZE',0x8A38) +GL_UNIFORM_TYPE=_C('GL_UNIFORM_TYPE',0x8A37) +GL_UNSIGNED_INT_SAMPLER_2D_RECT=_C('GL_UNSIGNED_INT_SAMPLER_2D_RECT',0x8DD5) +GL_UNSIGNED_INT_SAMPLER_BUFFER=_C('GL_UNSIGNED_INT_SAMPLER_BUFFER',0x8DD8) +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,_cs.GLuint) +def glBindBufferBase(target,index,buffer):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,_cs.GLuint,_cs.GLintptr,_cs.GLsizeiptr) +def glBindBufferRange(target,index,buffer,offset,size):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLintptr,_cs.GLintptr,_cs.GLsizeiptr) +def glCopyBufferSubData(readTarget,writeTarget,readOffset,writeOffset,size):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLint,_cs.GLsizei,_cs.GLsizei) +def glDrawArraysInstanced(mode,first,count,instancecount):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizei,_cs.GLenum,ctypes.c_void_p,_cs.GLsizei) +def glDrawElementsInstanced(mode,count,type,indices,instancecount):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLsizei,arrays.GLsizeiArray,arrays.GLcharArray) +def glGetActiveUniformBlockName(program,uniformBlockIndex,bufSize,length,uniformBlockName):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLenum,arrays.GLintArray) +def glGetActiveUniformBlockiv(program,uniformBlockIndex,pname,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLsizei,arrays.GLsizeiArray,arrays.GLcharArray) +def glGetActiveUniformName(program,uniformIndex,bufSize,length,uniformName):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizei,arrays.GLuintArray,_cs.GLenum,arrays.GLintArray) +def glGetActiveUniformsiv(program,uniformCount,uniformIndices,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,arrays.GLintArray) +def glGetIntegeri_v(target,index,data):pass +@_f +@_p.types(_cs.GLuint,_cs.GLuint,arrays.GLcharArray) +def glGetUniformBlockIndex(program,uniformBlockName):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizei,ctypes.POINTER( ctypes.POINTER( _cs.GLchar )),arrays.GLuintArray) +def glGetUniformIndices(program,uniformCount,uniformNames,uniformIndices):pass +@_f +@_p.types(None,_cs.GLuint) +def glPrimitiveRestartIndex(index):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLuint) +def glTexBuffer(target,internalformat,buffer):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLuint) +def glUniformBlockBinding(program,uniformBlockIndex,uniformBlockBinding):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/VERSION/GL_3_2.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/VERSION/GL_3_2.py new file mode 100644 index 00000000..aeb0adfc --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/VERSION/GL_3_2.py @@ -0,0 +1,134 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_VERSION_GL_3_2' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_VERSION_GL_3_2',error_checker=_errors._error_checker) +GL_ALREADY_SIGNALED=_C('GL_ALREADY_SIGNALED',0x911A) +GL_CONDITION_SATISFIED=_C('GL_CONDITION_SATISFIED',0x911C) +GL_CONTEXT_COMPATIBILITY_PROFILE_BIT=_C('GL_CONTEXT_COMPATIBILITY_PROFILE_BIT',0x00000002) +GL_CONTEXT_CORE_PROFILE_BIT=_C('GL_CONTEXT_CORE_PROFILE_BIT',0x00000001) +GL_CONTEXT_PROFILE_MASK=_C('GL_CONTEXT_PROFILE_MASK',0x9126) +GL_DEPTH_CLAMP=_C('GL_DEPTH_CLAMP',0x864F) +GL_FIRST_VERTEX_CONVENTION=_C('GL_FIRST_VERTEX_CONVENTION',0x8E4D) +GL_FRAMEBUFFER_ATTACHMENT_LAYERED=_C('GL_FRAMEBUFFER_ATTACHMENT_LAYERED',0x8DA7) +GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS=_C('GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS',0x8DA8) +GL_GEOMETRY_INPUT_TYPE=_C('GL_GEOMETRY_INPUT_TYPE',0x8917) +GL_GEOMETRY_OUTPUT_TYPE=_C('GL_GEOMETRY_OUTPUT_TYPE',0x8918) +GL_GEOMETRY_SHADER=_C('GL_GEOMETRY_SHADER',0x8DD9) +GL_GEOMETRY_VERTICES_OUT=_C('GL_GEOMETRY_VERTICES_OUT',0x8916) +GL_INT_SAMPLER_2D_MULTISAMPLE=_C('GL_INT_SAMPLER_2D_MULTISAMPLE',0x9109) +GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY=_C('GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY',0x910C) +GL_LAST_VERTEX_CONVENTION=_C('GL_LAST_VERTEX_CONVENTION',0x8E4E) +GL_LINES_ADJACENCY=_C('GL_LINES_ADJACENCY',0x000A) +GL_LINE_STRIP_ADJACENCY=_C('GL_LINE_STRIP_ADJACENCY',0x000B) +GL_MAX_COLOR_TEXTURE_SAMPLES=_C('GL_MAX_COLOR_TEXTURE_SAMPLES',0x910E) +GL_MAX_DEPTH_TEXTURE_SAMPLES=_C('GL_MAX_DEPTH_TEXTURE_SAMPLES',0x910F) +GL_MAX_FRAGMENT_INPUT_COMPONENTS=_C('GL_MAX_FRAGMENT_INPUT_COMPONENTS',0x9125) +GL_MAX_GEOMETRY_INPUT_COMPONENTS=_C('GL_MAX_GEOMETRY_INPUT_COMPONENTS',0x9123) +GL_MAX_GEOMETRY_OUTPUT_COMPONENTS=_C('GL_MAX_GEOMETRY_OUTPUT_COMPONENTS',0x9124) +GL_MAX_GEOMETRY_OUTPUT_VERTICES=_C('GL_MAX_GEOMETRY_OUTPUT_VERTICES',0x8DE0) +GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS=_C('GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS',0x8C29) +GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS=_C('GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS',0x8DE1) +GL_MAX_GEOMETRY_UNIFORM_COMPONENTS=_C('GL_MAX_GEOMETRY_UNIFORM_COMPONENTS',0x8DDF) +GL_MAX_INTEGER_SAMPLES=_C('GL_MAX_INTEGER_SAMPLES',0x9110) +GL_MAX_SAMPLE_MASK_WORDS=_C('GL_MAX_SAMPLE_MASK_WORDS',0x8E59) +GL_MAX_SERVER_WAIT_TIMEOUT=_C('GL_MAX_SERVER_WAIT_TIMEOUT',0x9111) +GL_MAX_VERTEX_OUTPUT_COMPONENTS=_C('GL_MAX_VERTEX_OUTPUT_COMPONENTS',0x9122) +GL_OBJECT_TYPE=_C('GL_OBJECT_TYPE',0x9112) +GL_PROGRAM_POINT_SIZE=_C('GL_PROGRAM_POINT_SIZE',0x8642) +GL_PROVOKING_VERTEX=_C('GL_PROVOKING_VERTEX',0x8E4F) +GL_PROXY_TEXTURE_2D_MULTISAMPLE=_C('GL_PROXY_TEXTURE_2D_MULTISAMPLE',0x9101) +GL_PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY=_C('GL_PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY',0x9103) +GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION=_C('GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION',0x8E4C) +GL_SAMPLER_2D_MULTISAMPLE=_C('GL_SAMPLER_2D_MULTISAMPLE',0x9108) +GL_SAMPLER_2D_MULTISAMPLE_ARRAY=_C('GL_SAMPLER_2D_MULTISAMPLE_ARRAY',0x910B) +GL_SAMPLE_MASK=_C('GL_SAMPLE_MASK',0x8E51) +GL_SAMPLE_MASK_VALUE=_C('GL_SAMPLE_MASK_VALUE',0x8E52) +GL_SAMPLE_POSITION=_C('GL_SAMPLE_POSITION',0x8E50) +GL_SIGNALED=_C('GL_SIGNALED',0x9119) +GL_SYNC_CONDITION=_C('GL_SYNC_CONDITION',0x9113) +GL_SYNC_FENCE=_C('GL_SYNC_FENCE',0x9116) +GL_SYNC_FLAGS=_C('GL_SYNC_FLAGS',0x9115) +GL_SYNC_FLUSH_COMMANDS_BIT=_C('GL_SYNC_FLUSH_COMMANDS_BIT',0x00000001) +GL_SYNC_GPU_COMMANDS_COMPLETE=_C('GL_SYNC_GPU_COMMANDS_COMPLETE',0x9117) +GL_SYNC_STATUS=_C('GL_SYNC_STATUS',0x9114) +GL_TEXTURE_2D_MULTISAMPLE=_C('GL_TEXTURE_2D_MULTISAMPLE',0x9100) +GL_TEXTURE_2D_MULTISAMPLE_ARRAY=_C('GL_TEXTURE_2D_MULTISAMPLE_ARRAY',0x9102) +GL_TEXTURE_BINDING_2D_MULTISAMPLE=_C('GL_TEXTURE_BINDING_2D_MULTISAMPLE',0x9104) +GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY=_C('GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY',0x9105) +GL_TEXTURE_CUBE_MAP_SEAMLESS=_C('GL_TEXTURE_CUBE_MAP_SEAMLESS',0x884F) +GL_TEXTURE_FIXED_SAMPLE_LOCATIONS=_C('GL_TEXTURE_FIXED_SAMPLE_LOCATIONS',0x9107) +GL_TEXTURE_SAMPLES=_C('GL_TEXTURE_SAMPLES',0x9106) +GL_TIMEOUT_EXPIRED=_C('GL_TIMEOUT_EXPIRED',0x911B) +GL_TIMEOUT_IGNORED=_C('GL_TIMEOUT_IGNORED',0xFFFFFFFFFFFFFFFF) +GL_TRIANGLES_ADJACENCY=_C('GL_TRIANGLES_ADJACENCY',0x000C) +GL_TRIANGLE_STRIP_ADJACENCY=_C('GL_TRIANGLE_STRIP_ADJACENCY',0x000D) +GL_UNSIGNALED=_C('GL_UNSIGNALED',0x9118) +GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE=_C('GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE',0x910A) +GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY=_C('GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY',0x910D) +GL_WAIT_FAILED=_C('GL_WAIT_FAILED',0x911D) +@_f +@_p.types(_cs.GLenum,_cs.GLsync,_cs.GLbitfield,_cs.GLuint64) +def glClientWaitSync(sync,flags,timeout):pass +@_f +@_p.types(None,_cs.GLsync) +def glDeleteSync(sync):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizei,_cs.GLenum,ctypes.c_void_p,_cs.GLint) +def glDrawElementsBaseVertex(mode,count,type,indices,basevertex):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizei,_cs.GLenum,ctypes.c_void_p,_cs.GLsizei,_cs.GLint) +def glDrawElementsInstancedBaseVertex(mode,count,type,indices,instancecount,basevertex):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,_cs.GLuint,_cs.GLsizei,_cs.GLenum,ctypes.c_void_p,_cs.GLint) +def glDrawRangeElementsBaseVertex(mode,start,end,count,type,indices,basevertex):pass +@_f +@_p.types(_cs.GLsync,_cs.GLenum,_cs.GLbitfield) +def glFenceSync(condition,flags):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLuint,_cs.GLint) +def glFramebufferTexture(target,attachment,texture,level):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLint64Array) +def glGetBufferParameteri64v(target,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,arrays.GLint64Array) +def glGetInteger64i_v(target,index,data):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLint64Array) +def glGetInteger64v(pname,data):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,arrays.GLfloatArray) +def glGetMultisamplefv(pname,index,val):pass +@_f +@_p.types(None,_cs.GLsync,_cs.GLenum,_cs.GLsizei,arrays.GLsizeiArray,arrays.GLintArray) +def glGetSynciv(sync,pname,bufSize,length,values):pass +@_f +@_p.types(_cs.GLboolean,_cs.GLsync) +def glIsSync(sync):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLsizeiArray,_cs.GLenum,arrays.GLvoidpArray,_cs.GLsizei,arrays.GLintArray) +def glMultiDrawElementsBaseVertex(mode,count,type,indices,drawcount,basevertex):pass +@_f +@_p.types(None,_cs.GLenum) +def glProvokingVertex(mode):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLbitfield) +def glSampleMaski(maskNumber,mask):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizei,_cs.GLenum,_cs.GLsizei,_cs.GLsizei,_cs.GLboolean) +def glTexImage2DMultisample(target,samples,internalformat,width,height,fixedsamplelocations):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizei,_cs.GLenum,_cs.GLsizei,_cs.GLsizei,_cs.GLsizei,_cs.GLboolean) +def glTexImage3DMultisample(target,samples,internalformat,width,height,depth,fixedsamplelocations):pass +@_f +@_p.types(None,_cs.GLsync,_cs.GLbitfield,_cs.GLuint64) +def glWaitSync(sync,flags,timeout):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/VERSION/GL_3_3.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/VERSION/GL_3_3.py new file mode 100644 index 00000000..1b7029bd --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/VERSION/GL_3_3.py @@ -0,0 +1,203 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_VERSION_GL_3_3' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_VERSION_GL_3_3',error_checker=_errors._error_checker) +GL_ANY_SAMPLES_PASSED=_C('GL_ANY_SAMPLES_PASSED',0x8C2F) +GL_INT_2_10_10_10_REV=_C('GL_INT_2_10_10_10_REV',0x8D9F) +GL_MAX_DUAL_SOURCE_DRAW_BUFFERS=_C('GL_MAX_DUAL_SOURCE_DRAW_BUFFERS',0x88FC) +GL_ONE_MINUS_SRC1_ALPHA=_C('GL_ONE_MINUS_SRC1_ALPHA',0x88FB) +GL_ONE_MINUS_SRC1_COLOR=_C('GL_ONE_MINUS_SRC1_COLOR',0x88FA) +GL_RGB10_A2UI=_C('GL_RGB10_A2UI',0x906F) +GL_SAMPLER_BINDING=_C('GL_SAMPLER_BINDING',0x8919) +GL_SRC1_COLOR=_C('GL_SRC1_COLOR',0x88F9) +GL_TEXTURE_SWIZZLE_A=_C('GL_TEXTURE_SWIZZLE_A',0x8E45) +GL_TEXTURE_SWIZZLE_B=_C('GL_TEXTURE_SWIZZLE_B',0x8E44) +GL_TEXTURE_SWIZZLE_G=_C('GL_TEXTURE_SWIZZLE_G',0x8E43) +GL_TEXTURE_SWIZZLE_R=_C('GL_TEXTURE_SWIZZLE_R',0x8E42) +GL_TEXTURE_SWIZZLE_RGBA=_C('GL_TEXTURE_SWIZZLE_RGBA',0x8E46) +GL_TIMESTAMP=_C('GL_TIMESTAMP',0x8E28) +GL_TIME_ELAPSED=_C('GL_TIME_ELAPSED',0x88BF) +GL_VERTEX_ATTRIB_ARRAY_DIVISOR=_C('GL_VERTEX_ATTRIB_ARRAY_DIVISOR',0x88FE) +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLuint,arrays.GLcharArray) +def glBindFragDataLocationIndexed(program,colorNumber,index,name):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint) +def glBindSampler(unit,sampler):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint) +def glColorP3ui(type,color):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLuintArray) +def glColorP3uiv(type,color):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint) +def glColorP4ui(type,color):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLuintArray) +def glColorP4uiv(type,color):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray) +def glDeleteSamplers(count,samplers):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray) +def glGenSamplers(count,samplers):pass +@_f +@_p.types(_cs.GLint,_cs.GLuint,arrays.GLcharArray) +def glGetFragDataIndex(program,name):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLint64Array) +def glGetQueryObjecti64v(id,pname,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLuint64Array) +def glGetQueryObjectui64v(id,pname,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLintArray) +def glGetSamplerParameterIiv(sampler,pname,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLuintArray) +def glGetSamplerParameterIuiv(sampler,pname,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLfloatArray) +def glGetSamplerParameterfv(sampler,pname,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLintArray) +def glGetSamplerParameteriv(sampler,pname,params):pass +@_f +@_p.types(_cs.GLboolean,_cs.GLuint) +def glIsSampler(sampler):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLuint) +def glMultiTexCoordP1ui(texture,type,coords):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLuintArray) +def glMultiTexCoordP1uiv(texture,type,coords):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLuint) +def glMultiTexCoordP2ui(texture,type,coords):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLuintArray) +def glMultiTexCoordP2uiv(texture,type,coords):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLuint) +def glMultiTexCoordP3ui(texture,type,coords):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLuintArray) +def glMultiTexCoordP3uiv(texture,type,coords):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLuint) +def glMultiTexCoordP4ui(texture,type,coords):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLuintArray) +def glMultiTexCoordP4uiv(texture,type,coords):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint) +def glNormalP3ui(type,coords):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLuintArray) +def glNormalP3uiv(type,coords):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum) +def glQueryCounter(id,target):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLintArray) +def glSamplerParameterIiv(sampler,pname,param):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLuintArray) +def glSamplerParameterIuiv(sampler,pname,param):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLfloat) +def glSamplerParameterf(sampler,pname,param):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLfloatArray) +def glSamplerParameterfv(sampler,pname,param):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLint) +def glSamplerParameteri(sampler,pname,param):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLintArray) +def glSamplerParameteriv(sampler,pname,param):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint) +def glSecondaryColorP3ui(type,color):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLuintArray) +def glSecondaryColorP3uiv(type,color):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint) +def glTexCoordP1ui(type,coords):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLuintArray) +def glTexCoordP1uiv(type,coords):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint) +def glTexCoordP2ui(type,coords):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLuintArray) +def glTexCoordP2uiv(type,coords):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint) +def glTexCoordP3ui(type,coords):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLuintArray) +def glTexCoordP3uiv(type,coords):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint) +def glTexCoordP4ui(type,coords):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLuintArray) +def glTexCoordP4uiv(type,coords):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint) +def glVertexAttribDivisor(index,divisor):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLboolean,_cs.GLuint) +def glVertexAttribP1ui(index,type,normalized,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLboolean,arrays.GLuintArray) +def glVertexAttribP1uiv(index,type,normalized,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLboolean,_cs.GLuint) +def glVertexAttribP2ui(index,type,normalized,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLboolean,arrays.GLuintArray) +def glVertexAttribP2uiv(index,type,normalized,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLboolean,_cs.GLuint) +def glVertexAttribP3ui(index,type,normalized,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLboolean,arrays.GLuintArray) +def glVertexAttribP3uiv(index,type,normalized,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLboolean,_cs.GLuint) +def glVertexAttribP4ui(index,type,normalized,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLboolean,arrays.GLuintArray) +def glVertexAttribP4uiv(index,type,normalized,value):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint) +def glVertexP2ui(type,value):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLuintArray) +def glVertexP2uiv(type,value):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint) +def glVertexP3ui(type,value):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLuintArray) +def glVertexP3uiv(type,value):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint) +def glVertexP4ui(type,value):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLuintArray) +def glVertexP4uiv(type,value):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/VERSION/GL_4_0.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/VERSION/GL_4_0.py new file mode 100644 index 00000000..8b4d815d --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/VERSION/GL_4_0.py @@ -0,0 +1,230 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_VERSION_GL_4_0' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_VERSION_GL_4_0',error_checker=_errors._error_checker) +GL_ACTIVE_SUBROUTINES=_C('GL_ACTIVE_SUBROUTINES',0x8DE5) +GL_ACTIVE_SUBROUTINE_MAX_LENGTH=_C('GL_ACTIVE_SUBROUTINE_MAX_LENGTH',0x8E48) +GL_ACTIVE_SUBROUTINE_UNIFORMS=_C('GL_ACTIVE_SUBROUTINE_UNIFORMS',0x8DE6) +GL_ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS=_C('GL_ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS',0x8E47) +GL_ACTIVE_SUBROUTINE_UNIFORM_MAX_LENGTH=_C('GL_ACTIVE_SUBROUTINE_UNIFORM_MAX_LENGTH',0x8E49) +GL_COMPATIBLE_SUBROUTINES=_C('GL_COMPATIBLE_SUBROUTINES',0x8E4B) +GL_DOUBLE_MAT2=_C('GL_DOUBLE_MAT2',0x8F46) +GL_DOUBLE_MAT2x3=_C('GL_DOUBLE_MAT2x3',0x8F49) +GL_DOUBLE_MAT2x4=_C('GL_DOUBLE_MAT2x4',0x8F4A) +GL_DOUBLE_MAT3=_C('GL_DOUBLE_MAT3',0x8F47) +GL_DOUBLE_MAT3x2=_C('GL_DOUBLE_MAT3x2',0x8F4B) +GL_DOUBLE_MAT3x4=_C('GL_DOUBLE_MAT3x4',0x8F4C) +GL_DOUBLE_MAT4=_C('GL_DOUBLE_MAT4',0x8F48) +GL_DOUBLE_MAT4x2=_C('GL_DOUBLE_MAT4x2',0x8F4D) +GL_DOUBLE_MAT4x3=_C('GL_DOUBLE_MAT4x3',0x8F4E) +GL_DOUBLE_VEC2=_C('GL_DOUBLE_VEC2',0x8FFC) +GL_DOUBLE_VEC3=_C('GL_DOUBLE_VEC3',0x8FFD) +GL_DOUBLE_VEC4=_C('GL_DOUBLE_VEC4',0x8FFE) +GL_DRAW_INDIRECT_BUFFER=_C('GL_DRAW_INDIRECT_BUFFER',0x8F3F) +GL_DRAW_INDIRECT_BUFFER_BINDING=_C('GL_DRAW_INDIRECT_BUFFER_BINDING',0x8F43) +GL_FRACTIONAL_EVEN=_C('GL_FRACTIONAL_EVEN',0x8E7C) +GL_FRACTIONAL_ODD=_C('GL_FRACTIONAL_ODD',0x8E7B) +GL_FRAGMENT_INTERPOLATION_OFFSET_BITS=_C('GL_FRAGMENT_INTERPOLATION_OFFSET_BITS',0x8E5D) +GL_GEOMETRY_SHADER_INVOCATIONS=_C('GL_GEOMETRY_SHADER_INVOCATIONS',0x887F) +GL_INT_SAMPLER_CUBE_MAP_ARRAY=_C('GL_INT_SAMPLER_CUBE_MAP_ARRAY',0x900E) +GL_ISOLINES=_C('GL_ISOLINES',0x8E7A) +GL_MAX_COMBINED_TESS_CONTROL_UNIFORM_COMPONENTS=_C('GL_MAX_COMBINED_TESS_CONTROL_UNIFORM_COMPONENTS',0x8E1E) +GL_MAX_COMBINED_TESS_EVALUATION_UNIFORM_COMPONENTS=_C('GL_MAX_COMBINED_TESS_EVALUATION_UNIFORM_COMPONENTS',0x8E1F) +GL_MAX_FRAGMENT_INTERPOLATION_OFFSET=_C('GL_MAX_FRAGMENT_INTERPOLATION_OFFSET',0x8E5C) +GL_MAX_GEOMETRY_SHADER_INVOCATIONS=_C('GL_MAX_GEOMETRY_SHADER_INVOCATIONS',0x8E5A) +GL_MAX_PATCH_VERTICES=_C('GL_MAX_PATCH_VERTICES',0x8E7D) +GL_MAX_PROGRAM_TEXTURE_GATHER_OFFSET=_C('GL_MAX_PROGRAM_TEXTURE_GATHER_OFFSET',0x8E5F) +GL_MAX_SUBROUTINES=_C('GL_MAX_SUBROUTINES',0x8DE7) +GL_MAX_SUBROUTINE_UNIFORM_LOCATIONS=_C('GL_MAX_SUBROUTINE_UNIFORM_LOCATIONS',0x8DE8) +GL_MAX_TESS_CONTROL_INPUT_COMPONENTS=_C('GL_MAX_TESS_CONTROL_INPUT_COMPONENTS',0x886C) +GL_MAX_TESS_CONTROL_OUTPUT_COMPONENTS=_C('GL_MAX_TESS_CONTROL_OUTPUT_COMPONENTS',0x8E83) +GL_MAX_TESS_CONTROL_TEXTURE_IMAGE_UNITS=_C('GL_MAX_TESS_CONTROL_TEXTURE_IMAGE_UNITS',0x8E81) +GL_MAX_TESS_CONTROL_TOTAL_OUTPUT_COMPONENTS=_C('GL_MAX_TESS_CONTROL_TOTAL_OUTPUT_COMPONENTS',0x8E85) +GL_MAX_TESS_CONTROL_UNIFORM_BLOCKS=_C('GL_MAX_TESS_CONTROL_UNIFORM_BLOCKS',0x8E89) +GL_MAX_TESS_CONTROL_UNIFORM_COMPONENTS=_C('GL_MAX_TESS_CONTROL_UNIFORM_COMPONENTS',0x8E7F) +GL_MAX_TESS_EVALUATION_INPUT_COMPONENTS=_C('GL_MAX_TESS_EVALUATION_INPUT_COMPONENTS',0x886D) +GL_MAX_TESS_EVALUATION_OUTPUT_COMPONENTS=_C('GL_MAX_TESS_EVALUATION_OUTPUT_COMPONENTS',0x8E86) +GL_MAX_TESS_EVALUATION_TEXTURE_IMAGE_UNITS=_C('GL_MAX_TESS_EVALUATION_TEXTURE_IMAGE_UNITS',0x8E82) +GL_MAX_TESS_EVALUATION_UNIFORM_BLOCKS=_C('GL_MAX_TESS_EVALUATION_UNIFORM_BLOCKS',0x8E8A) +GL_MAX_TESS_EVALUATION_UNIFORM_COMPONENTS=_C('GL_MAX_TESS_EVALUATION_UNIFORM_COMPONENTS',0x8E80) +GL_MAX_TESS_GEN_LEVEL=_C('GL_MAX_TESS_GEN_LEVEL',0x8E7E) +GL_MAX_TESS_PATCH_COMPONENTS=_C('GL_MAX_TESS_PATCH_COMPONENTS',0x8E84) +GL_MAX_TRANSFORM_FEEDBACK_BUFFERS=_C('GL_MAX_TRANSFORM_FEEDBACK_BUFFERS',0x8E70) +GL_MAX_VERTEX_STREAMS=_C('GL_MAX_VERTEX_STREAMS',0x8E71) +GL_MAX_VERTEX_STREAMS=_C('GL_MAX_VERTEX_STREAMS',0x8E71) +GL_MIN_FRAGMENT_INTERPOLATION_OFFSET=_C('GL_MIN_FRAGMENT_INTERPOLATION_OFFSET',0x8E5B) +GL_MIN_PROGRAM_TEXTURE_GATHER_OFFSET=_C('GL_MIN_PROGRAM_TEXTURE_GATHER_OFFSET',0x8E5E) +GL_MIN_SAMPLE_SHADING_VALUE=_C('GL_MIN_SAMPLE_SHADING_VALUE',0x8C37) +GL_NUM_COMPATIBLE_SUBROUTINES=_C('GL_NUM_COMPATIBLE_SUBROUTINES',0x8E4A) +GL_PATCHES=_C('GL_PATCHES',0x000E) +GL_PATCH_DEFAULT_INNER_LEVEL=_C('GL_PATCH_DEFAULT_INNER_LEVEL',0x8E73) +GL_PATCH_DEFAULT_OUTER_LEVEL=_C('GL_PATCH_DEFAULT_OUTER_LEVEL',0x8E74) +GL_PATCH_VERTICES=_C('GL_PATCH_VERTICES',0x8E72) +GL_PROXY_TEXTURE_CUBE_MAP_ARRAY=_C('GL_PROXY_TEXTURE_CUBE_MAP_ARRAY',0x900B) +GL_QUADS=_C('GL_QUADS',0x0007) +GL_SAMPLER_CUBE_MAP_ARRAY=_C('GL_SAMPLER_CUBE_MAP_ARRAY',0x900C) +GL_SAMPLER_CUBE_MAP_ARRAY_SHADOW=_C('GL_SAMPLER_CUBE_MAP_ARRAY_SHADOW',0x900D) +GL_SAMPLE_SHADING=_C('GL_SAMPLE_SHADING',0x8C36) +GL_TESS_CONTROL_OUTPUT_VERTICES=_C('GL_TESS_CONTROL_OUTPUT_VERTICES',0x8E75) +GL_TESS_CONTROL_SHADER=_C('GL_TESS_CONTROL_SHADER',0x8E88) +GL_TESS_EVALUATION_SHADER=_C('GL_TESS_EVALUATION_SHADER',0x8E87) +GL_TESS_GEN_MODE=_C('GL_TESS_GEN_MODE',0x8E76) +GL_TESS_GEN_POINT_MODE=_C('GL_TESS_GEN_POINT_MODE',0x8E79) +GL_TESS_GEN_SPACING=_C('GL_TESS_GEN_SPACING',0x8E77) +GL_TESS_GEN_VERTEX_ORDER=_C('GL_TESS_GEN_VERTEX_ORDER',0x8E78) +GL_TEXTURE_BINDING_CUBE_MAP_ARRAY=_C('GL_TEXTURE_BINDING_CUBE_MAP_ARRAY',0x900A) +GL_TEXTURE_CUBE_MAP_ARRAY=_C('GL_TEXTURE_CUBE_MAP_ARRAY',0x9009) +GL_TRANSFORM_FEEDBACK=_C('GL_TRANSFORM_FEEDBACK',0x8E22) +GL_TRANSFORM_FEEDBACK_BINDING=_C('GL_TRANSFORM_FEEDBACK_BINDING',0x8E25) +GL_TRANSFORM_FEEDBACK_BUFFER_ACTIVE=_C('GL_TRANSFORM_FEEDBACK_BUFFER_ACTIVE',0x8E24) +GL_TRANSFORM_FEEDBACK_BUFFER_PAUSED=_C('GL_TRANSFORM_FEEDBACK_BUFFER_PAUSED',0x8E23) +GL_UNIFORM_BLOCK_REFERENCED_BY_TESS_CONTROL_SHADER=_C('GL_UNIFORM_BLOCK_REFERENCED_BY_TESS_CONTROL_SHADER',0x84F0) +GL_UNIFORM_BLOCK_REFERENCED_BY_TESS_EVALUATION_SHADER=_C('GL_UNIFORM_BLOCK_REFERENCED_BY_TESS_EVALUATION_SHADER',0x84F1) +GL_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY=_C('GL_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY',0x900F) +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,_cs.GLuint) +def glBeginQueryIndexed(target,index,id):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint) +def glBindTransformFeedback(target,id):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLenum) +def glBlendEquationSeparatei(buf,modeRGB,modeAlpha):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum) +def glBlendEquationi(buf,mode):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLenum,_cs.GLenum,_cs.GLenum) +def glBlendFuncSeparatei(buf,srcRGB,dstRGB,srcAlpha,dstAlpha):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLenum) +def glBlendFunci(buf,src,dst):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray) +def glDeleteTransformFeedbacks(n,ids):pass +@_f +@_p.types(None,_cs.GLenum,ctypes.c_void_p) +def glDrawArraysIndirect(mode,indirect):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,ctypes.c_void_p) +def glDrawElementsIndirect(mode,type,indirect):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint) +def glDrawTransformFeedback(mode,id):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,_cs.GLuint) +def glDrawTransformFeedbackStream(mode,id,stream):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint) +def glEndQueryIndexed(target,index):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray) +def glGenTransformFeedbacks(n,ids):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLuint,_cs.GLsizei,arrays.GLsizeiArray,arrays.GLcharArray) +def glGetActiveSubroutineName(program,shadertype,index,bufsize,length,name):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLuint,_cs.GLsizei,arrays.GLsizeiArray,arrays.GLcharArray) +def glGetActiveSubroutineUniformName(program,shadertype,index,bufsize,length,name):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLuint,_cs.GLenum,arrays.GLintArray) +def glGetActiveSubroutineUniformiv(program,shadertype,index,pname,values):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLenum,arrays.GLintArray) +def glGetProgramStageiv(program,shadertype,pname,values):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,_cs.GLenum,arrays.GLintArray) +def glGetQueryIndexediv(target,index,pname,params):pass +@_f +@_p.types(_cs.GLuint,_cs.GLuint,_cs.GLenum,arrays.GLcharArray) +def glGetSubroutineIndex(program,shadertype,name):pass +@_f +@_p.types(_cs.GLint,_cs.GLuint,_cs.GLenum,arrays.GLcharArray) +def glGetSubroutineUniformLocation(program,shadertype,name):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLint,arrays.GLuintArray) +def glGetUniformSubroutineuiv(shadertype,location,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,arrays.GLdoubleArray) +def glGetUniformdv(program,location,params):pass +@_f +@_p.types(_cs.GLboolean,_cs.GLuint) +def glIsTransformFeedback(id):pass +@_f +@_p.types(None,_cs.GLfloat) +def glMinSampleShading(value):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLfloatArray) +def glPatchParameterfv(pname,values):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLint) +def glPatchParameteri(pname,value):pass +@_f +@_p.types(None,) +def glPauseTransformFeedback():pass +@_f +@_p.types(None,) +def glResumeTransformFeedback():pass +@_f +@_p.types(None,_cs.GLint,_cs.GLdouble) +def glUniform1d(location,x):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLsizei,arrays.GLdoubleArray) +def glUniform1dv(location,count,value):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLdouble,_cs.GLdouble) +def glUniform2d(location,x,y):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLsizei,arrays.GLdoubleArray) +def glUniform2dv(location,count,value):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLdouble,_cs.GLdouble,_cs.GLdouble) +def glUniform3d(location,x,y,z):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLsizei,arrays.GLdoubleArray) +def glUniform3dv(location,count,value):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLdouble,_cs.GLdouble,_cs.GLdouble,_cs.GLdouble) +def glUniform4d(location,x,y,z,w):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLsizei,arrays.GLdoubleArray) +def glUniform4dv(location,count,value):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLsizei,_cs.GLboolean,arrays.GLdoubleArray) +def glUniformMatrix2dv(location,count,transpose,value):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLsizei,_cs.GLboolean,arrays.GLdoubleArray) +def glUniformMatrix2x3dv(location,count,transpose,value):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLsizei,_cs.GLboolean,arrays.GLdoubleArray) +def glUniformMatrix2x4dv(location,count,transpose,value):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLsizei,_cs.GLboolean,arrays.GLdoubleArray) +def glUniformMatrix3dv(location,count,transpose,value):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLsizei,_cs.GLboolean,arrays.GLdoubleArray) +def glUniformMatrix3x2dv(location,count,transpose,value):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLsizei,_cs.GLboolean,arrays.GLdoubleArray) +def glUniformMatrix3x4dv(location,count,transpose,value):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLsizei,_cs.GLboolean,arrays.GLdoubleArray) +def glUniformMatrix4dv(location,count,transpose,value):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLsizei,_cs.GLboolean,arrays.GLdoubleArray) +def glUniformMatrix4x2dv(location,count,transpose,value):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLsizei,_cs.GLboolean,arrays.GLdoubleArray) +def glUniformMatrix4x3dv(location,count,transpose,value):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizei,arrays.GLuintArray) +def glUniformSubroutinesuiv(shadertype,count,indices):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/VERSION/GL_4_1.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/VERSION/GL_4_1.py new file mode 100644 index 00000000..808b2c75 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/VERSION/GL_4_1.py @@ -0,0 +1,315 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_VERSION_GL_4_1' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_VERSION_GL_4_1',error_checker=_errors._error_checker) +GL_ACTIVE_PROGRAM=_C('GL_ACTIVE_PROGRAM',0x8259) +GL_ALL_SHADER_BITS=_C('GL_ALL_SHADER_BITS',0xFFFFFFFF) +GL_FIXED=_C('GL_FIXED',0x140C) +GL_FRAGMENT_SHADER_BIT=_C('GL_FRAGMENT_SHADER_BIT',0x00000002) +GL_GEOMETRY_SHADER_BIT=_C('GL_GEOMETRY_SHADER_BIT',0x00000004) +GL_HIGH_FLOAT=_C('GL_HIGH_FLOAT',0x8DF2) +GL_HIGH_INT=_C('GL_HIGH_INT',0x8DF5) +GL_IMPLEMENTATION_COLOR_READ_FORMAT=_C('GL_IMPLEMENTATION_COLOR_READ_FORMAT',0x8B9B) +GL_IMPLEMENTATION_COLOR_READ_TYPE=_C('GL_IMPLEMENTATION_COLOR_READ_TYPE',0x8B9A) +GL_LAYER_PROVOKING_VERTEX=_C('GL_LAYER_PROVOKING_VERTEX',0x825E) +GL_LOW_FLOAT=_C('GL_LOW_FLOAT',0x8DF0) +GL_LOW_INT=_C('GL_LOW_INT',0x8DF3) +GL_MAX_FRAGMENT_UNIFORM_VECTORS=_C('GL_MAX_FRAGMENT_UNIFORM_VECTORS',0x8DFD) +GL_MAX_VARYING_VECTORS=_C('GL_MAX_VARYING_VECTORS',0x8DFC) +GL_MAX_VERTEX_UNIFORM_VECTORS=_C('GL_MAX_VERTEX_UNIFORM_VECTORS',0x8DFB) +GL_MAX_VIEWPORTS=_C('GL_MAX_VIEWPORTS',0x825B) +GL_MEDIUM_FLOAT=_C('GL_MEDIUM_FLOAT',0x8DF1) +GL_MEDIUM_INT=_C('GL_MEDIUM_INT',0x8DF4) +GL_NUM_PROGRAM_BINARY_FORMATS=_C('GL_NUM_PROGRAM_BINARY_FORMATS',0x87FE) +GL_NUM_SHADER_BINARY_FORMATS=_C('GL_NUM_SHADER_BINARY_FORMATS',0x8DF9) +GL_PROGRAM_BINARY_FORMATS=_C('GL_PROGRAM_BINARY_FORMATS',0x87FF) +GL_PROGRAM_BINARY_LENGTH=_C('GL_PROGRAM_BINARY_LENGTH',0x8741) +GL_PROGRAM_BINARY_RETRIEVABLE_HINT=_C('GL_PROGRAM_BINARY_RETRIEVABLE_HINT',0x8257) +GL_PROGRAM_PIPELINE_BINDING=_C('GL_PROGRAM_PIPELINE_BINDING',0x825A) +GL_PROGRAM_SEPARABLE=_C('GL_PROGRAM_SEPARABLE',0x8258) +GL_RGB565=_C('GL_RGB565',0x8D62) +GL_SHADER_BINARY_FORMATS=_C('GL_SHADER_BINARY_FORMATS',0x8DF8) +GL_SHADER_COMPILER=_C('GL_SHADER_COMPILER',0x8DFA) +GL_TESS_CONTROL_SHADER_BIT=_C('GL_TESS_CONTROL_SHADER_BIT',0x00000008) +GL_TESS_EVALUATION_SHADER_BIT=_C('GL_TESS_EVALUATION_SHADER_BIT',0x00000010) +GL_UNDEFINED_VERTEX=_C('GL_UNDEFINED_VERTEX',0x8260) +GL_VERTEX_SHADER_BIT=_C('GL_VERTEX_SHADER_BIT',0x00000001) +GL_VIEWPORT_BOUNDS_RANGE=_C('GL_VIEWPORT_BOUNDS_RANGE',0x825D) +GL_VIEWPORT_INDEX_PROVOKING_VERTEX=_C('GL_VIEWPORT_INDEX_PROVOKING_VERTEX',0x825F) +GL_VIEWPORT_SUBPIXEL_BITS=_C('GL_VIEWPORT_SUBPIXEL_BITS',0x825C) +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint) +def glActiveShaderProgram(pipeline,program):pass +@_f +@_p.types(None,_cs.GLuint) +def glBindProgramPipeline(pipeline):pass +@_f +@_p.types(None,_cs.GLfloat) +def glClearDepthf(d):pass +@_f +@_p.types(_cs.GLuint,_cs.GLenum,_cs.GLsizei,ctypes.POINTER( ctypes.POINTER( _cs.GLchar ))) +def glCreateShaderProgramv(type,count,strings):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray) +def glDeleteProgramPipelines(n,pipelines):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizei,arrays.GLdoubleArray) +def glDepthRangeArrayv(first,count,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLdouble,_cs.GLdouble) +def glDepthRangeIndexed(index,n,f):pass +@_f +@_p.types(None,_cs.GLfloat,_cs.GLfloat) +def glDepthRangef(n,f):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray) +def glGenProgramPipelines(n,pipelines):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,arrays.GLdoubleArray) +def glGetDoublei_v(target,index,data):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,arrays.GLfloatArray) +def glGetFloati_v(target,index,data):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizei,arrays.GLsizeiArray,arrays.GLuintArray,ctypes.c_void_p) +def glGetProgramBinary(program,bufSize,length,binaryFormat,binary):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizei,arrays.GLsizeiArray,arrays.GLcharArray) +def glGetProgramPipelineInfoLog(pipeline,bufSize,length,infoLog):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLintArray) +def glGetProgramPipelineiv(pipeline,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLintArray,arrays.GLintArray) +def glGetShaderPrecisionFormat(shadertype,precisiontype,range,precision):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLdoubleArray) +def glGetVertexAttribLdv(index,pname,params):pass +@_f +@_p.types(_cs.GLboolean,_cs.GLuint) +def glIsProgramPipeline(pipeline):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,ctypes.c_void_p,_cs.GLsizei) +def glProgramBinary(program,binaryFormat,binary,length):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLint) +def glProgramParameteri(program,pname,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLint) +def glProgramParameteri(program,pname,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLdouble) +def glProgramUniform1d(program,location,v0):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLdoubleArray) +def glProgramUniform1dv(program,location,count,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLfloat) +def glProgramUniform1f(program,location,v0):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLfloatArray) +def glProgramUniform1fv(program,location,count,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLint) +def glProgramUniform1i(program,location,v0):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLintArray) +def glProgramUniform1iv(program,location,count,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLuint) +def glProgramUniform1ui(program,location,v0):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLuintArray) +def glProgramUniform1uiv(program,location,count,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLdouble,_cs.GLdouble) +def glProgramUniform2d(program,location,v0,v1):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLdoubleArray) +def glProgramUniform2dv(program,location,count,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLfloat,_cs.GLfloat) +def glProgramUniform2f(program,location,v0,v1):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLfloatArray) +def glProgramUniform2fv(program,location,count,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLint,_cs.GLint) +def glProgramUniform2i(program,location,v0,v1):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLintArray) +def glProgramUniform2iv(program,location,count,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLuint,_cs.GLuint) +def glProgramUniform2ui(program,location,v0,v1):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLuintArray) +def glProgramUniform2uiv(program,location,count,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLdouble,_cs.GLdouble,_cs.GLdouble) +def glProgramUniform3d(program,location,v0,v1,v2):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLdoubleArray) +def glProgramUniform3dv(program,location,count,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat) +def glProgramUniform3f(program,location,v0,v1,v2):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLfloatArray) +def glProgramUniform3fv(program,location,count,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint) +def glProgramUniform3i(program,location,v0,v1,v2):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLintArray) +def glProgramUniform3iv(program,location,count,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLuint,_cs.GLuint,_cs.GLuint) +def glProgramUniform3ui(program,location,v0,v1,v2):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLuintArray) +def glProgramUniform3uiv(program,location,count,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLdouble,_cs.GLdouble,_cs.GLdouble,_cs.GLdouble) +def glProgramUniform4d(program,location,v0,v1,v2,v3):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLdoubleArray) +def glProgramUniform4dv(program,location,count,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat) +def glProgramUniform4f(program,location,v0,v1,v2,v3):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLfloatArray) +def glProgramUniform4fv(program,location,count,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint) +def glProgramUniform4i(program,location,v0,v1,v2,v3):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLintArray) +def glProgramUniform4iv(program,location,count,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLuint,_cs.GLuint,_cs.GLuint,_cs.GLuint) +def glProgramUniform4ui(program,location,v0,v1,v2,v3):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLuintArray) +def glProgramUniform4uiv(program,location,count,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,_cs.GLboolean,arrays.GLdoubleArray) +def glProgramUniformMatrix2dv(program,location,count,transpose,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,_cs.GLboolean,arrays.GLfloatArray) +def glProgramUniformMatrix2fv(program,location,count,transpose,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,_cs.GLboolean,arrays.GLdoubleArray) +def glProgramUniformMatrix2x3dv(program,location,count,transpose,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,_cs.GLboolean,arrays.GLfloatArray) +def glProgramUniformMatrix2x3fv(program,location,count,transpose,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,_cs.GLboolean,arrays.GLdoubleArray) +def glProgramUniformMatrix2x4dv(program,location,count,transpose,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,_cs.GLboolean,arrays.GLfloatArray) +def glProgramUniformMatrix2x4fv(program,location,count,transpose,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,_cs.GLboolean,arrays.GLdoubleArray) +def glProgramUniformMatrix3dv(program,location,count,transpose,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,_cs.GLboolean,arrays.GLfloatArray) +def glProgramUniformMatrix3fv(program,location,count,transpose,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,_cs.GLboolean,arrays.GLdoubleArray) +def glProgramUniformMatrix3x2dv(program,location,count,transpose,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,_cs.GLboolean,arrays.GLfloatArray) +def glProgramUniformMatrix3x2fv(program,location,count,transpose,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,_cs.GLboolean,arrays.GLdoubleArray) +def glProgramUniformMatrix3x4dv(program,location,count,transpose,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,_cs.GLboolean,arrays.GLfloatArray) +def glProgramUniformMatrix3x4fv(program,location,count,transpose,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,_cs.GLboolean,arrays.GLdoubleArray) +def glProgramUniformMatrix4dv(program,location,count,transpose,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,_cs.GLboolean,arrays.GLfloatArray) +def glProgramUniformMatrix4fv(program,location,count,transpose,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,_cs.GLboolean,arrays.GLdoubleArray) +def glProgramUniformMatrix4x2dv(program,location,count,transpose,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,_cs.GLboolean,arrays.GLfloatArray) +def glProgramUniformMatrix4x2fv(program,location,count,transpose,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,_cs.GLboolean,arrays.GLdoubleArray) +def glProgramUniformMatrix4x3dv(program,location,count,transpose,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,_cs.GLboolean,arrays.GLfloatArray) +def glProgramUniformMatrix4x3fv(program,location,count,transpose,value):pass +@_f +@_p.types(None,) +def glReleaseShaderCompiler():pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizei,arrays.GLintArray) +def glScissorArrayv(first,count,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLsizei) +def glScissorIndexed(index,left,bottom,width,height):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLintArray) +def glScissorIndexedv(index,v):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray,_cs.GLenum,ctypes.c_void_p,_cs.GLsizei) +def glShaderBinary(count,shaders,binaryformat,binary,length):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLbitfield,_cs.GLuint) +def glUseProgramStages(pipeline,stages,program):pass +@_f +@_p.types(None,_cs.GLuint) +def glValidateProgramPipeline(pipeline):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLdouble) +def glVertexAttribL1d(index,x):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLdoubleArray) +def glVertexAttribL1dv(index,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLdouble,_cs.GLdouble) +def glVertexAttribL2d(index,x,y):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLdoubleArray) +def glVertexAttribL2dv(index,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLdouble,_cs.GLdouble,_cs.GLdouble) +def glVertexAttribL3d(index,x,y,z):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLdoubleArray) +def glVertexAttribL3dv(index,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLdouble,_cs.GLdouble,_cs.GLdouble,_cs.GLdouble) +def glVertexAttribL4d(index,x,y,z,w):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLdoubleArray) +def glVertexAttribL4dv(index,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLenum,_cs.GLsizei,ctypes.c_void_p) +def glVertexAttribLPointer(index,size,type,stride,pointer):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizei,arrays.GLfloatArray) +def glViewportArrayv(first,count,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat) +def glViewportIndexedf(index,x,y,w,h):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLfloatArray) +def glViewportIndexedfv(index,v):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/VERSION/GL_4_2.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/VERSION/GL_4_2.py new file mode 100644 index 00000000..09783f25 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/VERSION/GL_4_2.py @@ -0,0 +1,161 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_VERSION_GL_4_2' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_VERSION_GL_4_2',error_checker=_errors._error_checker) +GL_ACTIVE_ATOMIC_COUNTER_BUFFERS=_C('GL_ACTIVE_ATOMIC_COUNTER_BUFFERS',0x92D9) +GL_ALL_BARRIER_BITS=_C('GL_ALL_BARRIER_BITS',0xFFFFFFFF) +GL_ATOMIC_COUNTER_BARRIER_BIT=_C('GL_ATOMIC_COUNTER_BARRIER_BIT',0x00001000) +GL_ATOMIC_COUNTER_BUFFER=_C('GL_ATOMIC_COUNTER_BUFFER',0x92C0) +GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTERS=_C('GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTERS',0x92C5) +GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTER_INDICES=_C('GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTER_INDICES',0x92C6) +GL_ATOMIC_COUNTER_BUFFER_BINDING=_C('GL_ATOMIC_COUNTER_BUFFER_BINDING',0x92C1) +GL_ATOMIC_COUNTER_BUFFER_DATA_SIZE=_C('GL_ATOMIC_COUNTER_BUFFER_DATA_SIZE',0x92C4) +GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_FRAGMENT_SHADER=_C('GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_FRAGMENT_SHADER',0x92CB) +GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_GEOMETRY_SHADER=_C('GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_GEOMETRY_SHADER',0x92CA) +GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_CONTROL_SHADER=_C('GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_CONTROL_SHADER',0x92C8) +GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_EVALUATION_SHADER=_C('GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_EVALUATION_SHADER',0x92C9) +GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_VERTEX_SHADER=_C('GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_VERTEX_SHADER',0x92C7) +GL_ATOMIC_COUNTER_BUFFER_SIZE=_C('GL_ATOMIC_COUNTER_BUFFER_SIZE',0x92C3) +GL_ATOMIC_COUNTER_BUFFER_START=_C('GL_ATOMIC_COUNTER_BUFFER_START',0x92C2) +GL_BUFFER_UPDATE_BARRIER_BIT=_C('GL_BUFFER_UPDATE_BARRIER_BIT',0x00000200) +GL_COMMAND_BARRIER_BIT=_C('GL_COMMAND_BARRIER_BIT',0x00000040) +GL_COMPRESSED_RGBA_BPTC_UNORM=_C('GL_COMPRESSED_RGBA_BPTC_UNORM',0x8E8C) +GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT=_C('GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT',0x8E8E) +GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT=_C('GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT',0x8E8F) +GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM=_C('GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM',0x8E8D) +GL_COPY_READ_BUFFER_BINDING=_C('GL_COPY_READ_BUFFER_BINDING',0x8F36) +GL_COPY_WRITE_BUFFER_BINDING=_C('GL_COPY_WRITE_BUFFER_BINDING',0x8F37) +GL_ELEMENT_ARRAY_BARRIER_BIT=_C('GL_ELEMENT_ARRAY_BARRIER_BIT',0x00000002) +GL_FRAMEBUFFER_BARRIER_BIT=_C('GL_FRAMEBUFFER_BARRIER_BIT',0x00000400) +GL_IMAGE_1D=_C('GL_IMAGE_1D',0x904C) +GL_IMAGE_1D_ARRAY=_C('GL_IMAGE_1D_ARRAY',0x9052) +GL_IMAGE_2D=_C('GL_IMAGE_2D',0x904D) +GL_IMAGE_2D_ARRAY=_C('GL_IMAGE_2D_ARRAY',0x9053) +GL_IMAGE_2D_MULTISAMPLE=_C('GL_IMAGE_2D_MULTISAMPLE',0x9055) +GL_IMAGE_2D_MULTISAMPLE_ARRAY=_C('GL_IMAGE_2D_MULTISAMPLE_ARRAY',0x9056) +GL_IMAGE_2D_RECT=_C('GL_IMAGE_2D_RECT',0x904F) +GL_IMAGE_3D=_C('GL_IMAGE_3D',0x904E) +GL_IMAGE_BINDING_ACCESS=_C('GL_IMAGE_BINDING_ACCESS',0x8F3E) +GL_IMAGE_BINDING_FORMAT=_C('GL_IMAGE_BINDING_FORMAT',0x906E) +GL_IMAGE_BINDING_LAYER=_C('GL_IMAGE_BINDING_LAYER',0x8F3D) +GL_IMAGE_BINDING_LAYERED=_C('GL_IMAGE_BINDING_LAYERED',0x8F3C) +GL_IMAGE_BINDING_LEVEL=_C('GL_IMAGE_BINDING_LEVEL',0x8F3B) +GL_IMAGE_BINDING_NAME=_C('GL_IMAGE_BINDING_NAME',0x8F3A) +GL_IMAGE_BUFFER=_C('GL_IMAGE_BUFFER',0x9051) +GL_IMAGE_CUBE=_C('GL_IMAGE_CUBE',0x9050) +GL_IMAGE_CUBE_MAP_ARRAY=_C('GL_IMAGE_CUBE_MAP_ARRAY',0x9054) +GL_IMAGE_FORMAT_COMPATIBILITY_BY_CLASS=_C('GL_IMAGE_FORMAT_COMPATIBILITY_BY_CLASS',0x90C9) +GL_IMAGE_FORMAT_COMPATIBILITY_BY_SIZE=_C('GL_IMAGE_FORMAT_COMPATIBILITY_BY_SIZE',0x90C8) +GL_IMAGE_FORMAT_COMPATIBILITY_TYPE=_C('GL_IMAGE_FORMAT_COMPATIBILITY_TYPE',0x90C7) +GL_INT_IMAGE_1D=_C('GL_INT_IMAGE_1D',0x9057) +GL_INT_IMAGE_1D_ARRAY=_C('GL_INT_IMAGE_1D_ARRAY',0x905D) +GL_INT_IMAGE_2D=_C('GL_INT_IMAGE_2D',0x9058) +GL_INT_IMAGE_2D_ARRAY=_C('GL_INT_IMAGE_2D_ARRAY',0x905E) +GL_INT_IMAGE_2D_MULTISAMPLE=_C('GL_INT_IMAGE_2D_MULTISAMPLE',0x9060) +GL_INT_IMAGE_2D_MULTISAMPLE_ARRAY=_C('GL_INT_IMAGE_2D_MULTISAMPLE_ARRAY',0x9061) +GL_INT_IMAGE_2D_RECT=_C('GL_INT_IMAGE_2D_RECT',0x905A) +GL_INT_IMAGE_3D=_C('GL_INT_IMAGE_3D',0x9059) +GL_INT_IMAGE_BUFFER=_C('GL_INT_IMAGE_BUFFER',0x905C) +GL_INT_IMAGE_CUBE=_C('GL_INT_IMAGE_CUBE',0x905B) +GL_INT_IMAGE_CUBE_MAP_ARRAY=_C('GL_INT_IMAGE_CUBE_MAP_ARRAY',0x905F) +GL_MAX_ATOMIC_COUNTER_BUFFER_BINDINGS=_C('GL_MAX_ATOMIC_COUNTER_BUFFER_BINDINGS',0x92DC) +GL_MAX_ATOMIC_COUNTER_BUFFER_SIZE=_C('GL_MAX_ATOMIC_COUNTER_BUFFER_SIZE',0x92D8) +GL_MAX_COMBINED_ATOMIC_COUNTERS=_C('GL_MAX_COMBINED_ATOMIC_COUNTERS',0x92D7) +GL_MAX_COMBINED_ATOMIC_COUNTER_BUFFERS=_C('GL_MAX_COMBINED_ATOMIC_COUNTER_BUFFERS',0x92D1) +GL_MAX_COMBINED_IMAGE_UNIFORMS=_C('GL_MAX_COMBINED_IMAGE_UNIFORMS',0x90CF) +GL_MAX_COMBINED_IMAGE_UNITS_AND_FRAGMENT_OUTPUTS=_C('GL_MAX_COMBINED_IMAGE_UNITS_AND_FRAGMENT_OUTPUTS',0x8F39) +GL_MAX_FRAGMENT_ATOMIC_COUNTERS=_C('GL_MAX_FRAGMENT_ATOMIC_COUNTERS',0x92D6) +GL_MAX_FRAGMENT_ATOMIC_COUNTER_BUFFERS=_C('GL_MAX_FRAGMENT_ATOMIC_COUNTER_BUFFERS',0x92D0) +GL_MAX_FRAGMENT_IMAGE_UNIFORMS=_C('GL_MAX_FRAGMENT_IMAGE_UNIFORMS',0x90CE) +GL_MAX_GEOMETRY_ATOMIC_COUNTERS=_C('GL_MAX_GEOMETRY_ATOMIC_COUNTERS',0x92D5) +GL_MAX_GEOMETRY_ATOMIC_COUNTER_BUFFERS=_C('GL_MAX_GEOMETRY_ATOMIC_COUNTER_BUFFERS',0x92CF) +GL_MAX_GEOMETRY_IMAGE_UNIFORMS=_C('GL_MAX_GEOMETRY_IMAGE_UNIFORMS',0x90CD) +GL_MAX_IMAGE_SAMPLES=_C('GL_MAX_IMAGE_SAMPLES',0x906D) +GL_MAX_IMAGE_UNITS=_C('GL_MAX_IMAGE_UNITS',0x8F38) +GL_MAX_TESS_CONTROL_ATOMIC_COUNTERS=_C('GL_MAX_TESS_CONTROL_ATOMIC_COUNTERS',0x92D3) +GL_MAX_TESS_CONTROL_ATOMIC_COUNTER_BUFFERS=_C('GL_MAX_TESS_CONTROL_ATOMIC_COUNTER_BUFFERS',0x92CD) +GL_MAX_TESS_CONTROL_IMAGE_UNIFORMS=_C('GL_MAX_TESS_CONTROL_IMAGE_UNIFORMS',0x90CB) +GL_MAX_TESS_EVALUATION_ATOMIC_COUNTERS=_C('GL_MAX_TESS_EVALUATION_ATOMIC_COUNTERS',0x92D4) +GL_MAX_TESS_EVALUATION_ATOMIC_COUNTER_BUFFERS=_C('GL_MAX_TESS_EVALUATION_ATOMIC_COUNTER_BUFFERS',0x92CE) +GL_MAX_TESS_EVALUATION_IMAGE_UNIFORMS=_C('GL_MAX_TESS_EVALUATION_IMAGE_UNIFORMS',0x90CC) +GL_MAX_VERTEX_ATOMIC_COUNTERS=_C('GL_MAX_VERTEX_ATOMIC_COUNTERS',0x92D2) +GL_MAX_VERTEX_ATOMIC_COUNTER_BUFFERS=_C('GL_MAX_VERTEX_ATOMIC_COUNTER_BUFFERS',0x92CC) +GL_MAX_VERTEX_IMAGE_UNIFORMS=_C('GL_MAX_VERTEX_IMAGE_UNIFORMS',0x90CA) +GL_MIN_MAP_BUFFER_ALIGNMENT=_C('GL_MIN_MAP_BUFFER_ALIGNMENT',0x90BC) +GL_NUM_SAMPLE_COUNTS=_C('GL_NUM_SAMPLE_COUNTS',0x9380) +GL_PACK_COMPRESSED_BLOCK_DEPTH=_C('GL_PACK_COMPRESSED_BLOCK_DEPTH',0x912D) +GL_PACK_COMPRESSED_BLOCK_HEIGHT=_C('GL_PACK_COMPRESSED_BLOCK_HEIGHT',0x912C) +GL_PACK_COMPRESSED_BLOCK_SIZE=_C('GL_PACK_COMPRESSED_BLOCK_SIZE',0x912E) +GL_PACK_COMPRESSED_BLOCK_WIDTH=_C('GL_PACK_COMPRESSED_BLOCK_WIDTH',0x912B) +GL_PIXEL_BUFFER_BARRIER_BIT=_C('GL_PIXEL_BUFFER_BARRIER_BIT',0x00000080) +GL_SHADER_IMAGE_ACCESS_BARRIER_BIT=_C('GL_SHADER_IMAGE_ACCESS_BARRIER_BIT',0x00000020) +GL_TEXTURE_FETCH_BARRIER_BIT=_C('GL_TEXTURE_FETCH_BARRIER_BIT',0x00000008) +GL_TEXTURE_IMMUTABLE_FORMAT=_C('GL_TEXTURE_IMMUTABLE_FORMAT',0x912F) +GL_TEXTURE_UPDATE_BARRIER_BIT=_C('GL_TEXTURE_UPDATE_BARRIER_BIT',0x00000100) +GL_TRANSFORM_FEEDBACK_ACTIVE=_C('GL_TRANSFORM_FEEDBACK_ACTIVE',0x8E24) +GL_TRANSFORM_FEEDBACK_BARRIER_BIT=_C('GL_TRANSFORM_FEEDBACK_BARRIER_BIT',0x00000800) +GL_TRANSFORM_FEEDBACK_PAUSED=_C('GL_TRANSFORM_FEEDBACK_PAUSED',0x8E23) +GL_UNIFORM_ATOMIC_COUNTER_BUFFER_INDEX=_C('GL_UNIFORM_ATOMIC_COUNTER_BUFFER_INDEX',0x92DA) +GL_UNIFORM_BARRIER_BIT=_C('GL_UNIFORM_BARRIER_BIT',0x00000004) +GL_UNPACK_COMPRESSED_BLOCK_DEPTH=_C('GL_UNPACK_COMPRESSED_BLOCK_DEPTH',0x9129) +GL_UNPACK_COMPRESSED_BLOCK_HEIGHT=_C('GL_UNPACK_COMPRESSED_BLOCK_HEIGHT',0x9128) +GL_UNPACK_COMPRESSED_BLOCK_SIZE=_C('GL_UNPACK_COMPRESSED_BLOCK_SIZE',0x912A) +GL_UNPACK_COMPRESSED_BLOCK_WIDTH=_C('GL_UNPACK_COMPRESSED_BLOCK_WIDTH',0x9127) +GL_UNSIGNED_INT_ATOMIC_COUNTER=_C('GL_UNSIGNED_INT_ATOMIC_COUNTER',0x92DB) +GL_UNSIGNED_INT_IMAGE_1D=_C('GL_UNSIGNED_INT_IMAGE_1D',0x9062) +GL_UNSIGNED_INT_IMAGE_1D_ARRAY=_C('GL_UNSIGNED_INT_IMAGE_1D_ARRAY',0x9068) +GL_UNSIGNED_INT_IMAGE_2D=_C('GL_UNSIGNED_INT_IMAGE_2D',0x9063) +GL_UNSIGNED_INT_IMAGE_2D_ARRAY=_C('GL_UNSIGNED_INT_IMAGE_2D_ARRAY',0x9069) +GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE=_C('GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE',0x906B) +GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_ARRAY=_C('GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_ARRAY',0x906C) +GL_UNSIGNED_INT_IMAGE_2D_RECT=_C('GL_UNSIGNED_INT_IMAGE_2D_RECT',0x9065) +GL_UNSIGNED_INT_IMAGE_3D=_C('GL_UNSIGNED_INT_IMAGE_3D',0x9064) +GL_UNSIGNED_INT_IMAGE_BUFFER=_C('GL_UNSIGNED_INT_IMAGE_BUFFER',0x9067) +GL_UNSIGNED_INT_IMAGE_CUBE=_C('GL_UNSIGNED_INT_IMAGE_CUBE',0x9066) +GL_UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY=_C('GL_UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY',0x906A) +GL_VERTEX_ATTRIB_ARRAY_BARRIER_BIT=_C('GL_VERTEX_ATTRIB_ARRAY_BARRIER_BIT',0x00000001) +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLint,_cs.GLboolean,_cs.GLint,_cs.GLenum,_cs.GLenum) +def glBindImageTexture(unit,texture,level,layered,layer,access,format):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLint,_cs.GLsizei,_cs.GLsizei,_cs.GLuint) +def glDrawArraysInstancedBaseInstance(mode,first,count,instancecount,baseinstance):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizei,_cs.GLenum,ctypes.c_void_p,_cs.GLsizei,_cs.GLuint) +def glDrawElementsInstancedBaseInstance(mode,count,type,indices,instancecount,baseinstance):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizei,_cs.GLenum,ctypes.c_void_p,_cs.GLsizei,_cs.GLint,_cs.GLuint) +def glDrawElementsInstancedBaseVertexBaseInstance(mode,count,type,indices,instancecount,basevertex,baseinstance):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,_cs.GLsizei) +def glDrawTransformFeedbackInstanced(mode,id,instancecount):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,_cs.GLuint,_cs.GLsizei) +def glDrawTransformFeedbackStreamInstanced(mode,id,stream,instancecount):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLenum,arrays.GLintArray) +def glGetActiveAtomicCounterBufferiv(program,bufferIndex,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLenum,_cs.GLsizei,arrays.GLintArray) +def glGetInternalformativ(target,internalformat,pname,bufSize,params):pass +@_f +@_p.types(None,_cs.GLbitfield) +def glMemoryBarrier(barriers):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizei,_cs.GLenum,_cs.GLsizei) +def glTexStorage1D(target,levels,internalformat,width):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizei,_cs.GLenum,_cs.GLsizei,_cs.GLsizei) +def glTexStorage2D(target,levels,internalformat,width,height):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizei,_cs.GLenum,_cs.GLsizei,_cs.GLsizei,_cs.GLsizei) +def glTexStorage3D(target,levels,internalformat,width,height,depth):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/VERSION/GL_4_3.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/VERSION/GL_4_3.py new file mode 100644 index 00000000..ad98a98b --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/VERSION/GL_4_3.py @@ -0,0 +1,407 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_VERSION_GL_4_3' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_VERSION_GL_4_3',error_checker=_errors._error_checker) +GL_ACTIVE_RESOURCES=_C('GL_ACTIVE_RESOURCES',0x92F5) +GL_ACTIVE_VARIABLES=_C('GL_ACTIVE_VARIABLES',0x9305) +GL_ANY_SAMPLES_PASSED_CONSERVATIVE=_C('GL_ANY_SAMPLES_PASSED_CONSERVATIVE',0x8D6A) +GL_ARRAY_SIZE=_C('GL_ARRAY_SIZE',0x92FB) +GL_ARRAY_STRIDE=_C('GL_ARRAY_STRIDE',0x92FE) +GL_ATOMIC_COUNTER_BUFFER_INDEX=_C('GL_ATOMIC_COUNTER_BUFFER_INDEX',0x9301) +GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_COMPUTE_SHADER=_C('GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_COMPUTE_SHADER',0x90ED) +GL_AUTO_GENERATE_MIPMAP=_C('GL_AUTO_GENERATE_MIPMAP',0x8295) +GL_BLOCK_INDEX=_C('GL_BLOCK_INDEX',0x92FD) +GL_BUFFER=_C('GL_BUFFER',0x82E0) +GL_BUFFER_BINDING=_C('GL_BUFFER_BINDING',0x9302) +GL_BUFFER_DATA_SIZE=_C('GL_BUFFER_DATA_SIZE',0x9303) +GL_BUFFER_VARIABLE=_C('GL_BUFFER_VARIABLE',0x92E5) +GL_CAVEAT_SUPPORT=_C('GL_CAVEAT_SUPPORT',0x82B8) +GL_CLEAR_BUFFER=_C('GL_CLEAR_BUFFER',0x82B4) +GL_COLOR_COMPONENTS=_C('GL_COLOR_COMPONENTS',0x8283) +GL_COLOR_ENCODING=_C('GL_COLOR_ENCODING',0x8296) +GL_COLOR_RENDERABLE=_C('GL_COLOR_RENDERABLE',0x8286) +GL_COMPRESSED_R11_EAC=_C('GL_COMPRESSED_R11_EAC',0x9270) +GL_COMPRESSED_RG11_EAC=_C('GL_COMPRESSED_RG11_EAC',0x9272) +GL_COMPRESSED_RGB8_ETC2=_C('GL_COMPRESSED_RGB8_ETC2',0x9274) +GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2=_C('GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2',0x9276) +GL_COMPRESSED_RGBA8_ETC2_EAC=_C('GL_COMPRESSED_RGBA8_ETC2_EAC',0x9278) +GL_COMPRESSED_SIGNED_R11_EAC=_C('GL_COMPRESSED_SIGNED_R11_EAC',0x9271) +GL_COMPRESSED_SIGNED_RG11_EAC=_C('GL_COMPRESSED_SIGNED_RG11_EAC',0x9273) +GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC=_C('GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC',0x9279) +GL_COMPRESSED_SRGB8_ETC2=_C('GL_COMPRESSED_SRGB8_ETC2',0x9275) +GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2=_C('GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2',0x9277) +GL_COMPUTE_SHADER=_C('GL_COMPUTE_SHADER',0x91B9) +GL_COMPUTE_SHADER_BIT=_C('GL_COMPUTE_SHADER_BIT',0x00000020) +GL_COMPUTE_SUBROUTINE=_C('GL_COMPUTE_SUBROUTINE',0x92ED) +GL_COMPUTE_SUBROUTINE_UNIFORM=_C('GL_COMPUTE_SUBROUTINE_UNIFORM',0x92F3) +GL_COMPUTE_TEXTURE=_C('GL_COMPUTE_TEXTURE',0x82A0) +GL_COMPUTE_WORK_GROUP_SIZE=_C('GL_COMPUTE_WORK_GROUP_SIZE',0x8267) +GL_CONTEXT_FLAG_DEBUG_BIT=_C('GL_CONTEXT_FLAG_DEBUG_BIT',0x00000002) +GL_DEBUG_CALLBACK_FUNCTION=_C('GL_DEBUG_CALLBACK_FUNCTION',0x8244) +GL_DEBUG_CALLBACK_USER_PARAM=_C('GL_DEBUG_CALLBACK_USER_PARAM',0x8245) +GL_DEBUG_GROUP_STACK_DEPTH=_C('GL_DEBUG_GROUP_STACK_DEPTH',0x826D) +GL_DEBUG_LOGGED_MESSAGES=_C('GL_DEBUG_LOGGED_MESSAGES',0x9145) +GL_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH=_C('GL_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH',0x8243) +GL_DEBUG_OUTPUT=_C('GL_DEBUG_OUTPUT',0x92E0) +GL_DEBUG_OUTPUT_SYNCHRONOUS=_C('GL_DEBUG_OUTPUT_SYNCHRONOUS',0x8242) +GL_DEBUG_SEVERITY_HIGH=_C('GL_DEBUG_SEVERITY_HIGH',0x9146) +GL_DEBUG_SEVERITY_LOW=_C('GL_DEBUG_SEVERITY_LOW',0x9148) +GL_DEBUG_SEVERITY_MEDIUM=_C('GL_DEBUG_SEVERITY_MEDIUM',0x9147) +GL_DEBUG_SEVERITY_NOTIFICATION=_C('GL_DEBUG_SEVERITY_NOTIFICATION',0x826B) +GL_DEBUG_SOURCE_API=_C('GL_DEBUG_SOURCE_API',0x8246) +GL_DEBUG_SOURCE_APPLICATION=_C('GL_DEBUG_SOURCE_APPLICATION',0x824A) +GL_DEBUG_SOURCE_OTHER=_C('GL_DEBUG_SOURCE_OTHER',0x824B) +GL_DEBUG_SOURCE_SHADER_COMPILER=_C('GL_DEBUG_SOURCE_SHADER_COMPILER',0x8248) +GL_DEBUG_SOURCE_THIRD_PARTY=_C('GL_DEBUG_SOURCE_THIRD_PARTY',0x8249) +GL_DEBUG_SOURCE_WINDOW_SYSTEM=_C('GL_DEBUG_SOURCE_WINDOW_SYSTEM',0x8247) +GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR=_C('GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR',0x824D) +GL_DEBUG_TYPE_ERROR=_C('GL_DEBUG_TYPE_ERROR',0x824C) +GL_DEBUG_TYPE_MARKER=_C('GL_DEBUG_TYPE_MARKER',0x8268) +GL_DEBUG_TYPE_OTHER=_C('GL_DEBUG_TYPE_OTHER',0x8251) +GL_DEBUG_TYPE_PERFORMANCE=_C('GL_DEBUG_TYPE_PERFORMANCE',0x8250) +GL_DEBUG_TYPE_POP_GROUP=_C('GL_DEBUG_TYPE_POP_GROUP',0x826A) +GL_DEBUG_TYPE_PORTABILITY=_C('GL_DEBUG_TYPE_PORTABILITY',0x824F) +GL_DEBUG_TYPE_PUSH_GROUP=_C('GL_DEBUG_TYPE_PUSH_GROUP',0x8269) +GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR=_C('GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR',0x824E) +GL_DEPTH_COMPONENTS=_C('GL_DEPTH_COMPONENTS',0x8284) +GL_DEPTH_RENDERABLE=_C('GL_DEPTH_RENDERABLE',0x8287) +GL_DEPTH_STENCIL_TEXTURE_MODE=_C('GL_DEPTH_STENCIL_TEXTURE_MODE',0x90EA) +GL_DISPATCH_INDIRECT_BUFFER=_C('GL_DISPATCH_INDIRECT_BUFFER',0x90EE) +GL_DISPATCH_INDIRECT_BUFFER_BINDING=_C('GL_DISPATCH_INDIRECT_BUFFER_BINDING',0x90EF) +GL_DISPLAY_LIST=_C('GL_DISPLAY_LIST',0x82E7) +GL_FILTER=_C('GL_FILTER',0x829A) +GL_FRAGMENT_SUBROUTINE=_C('GL_FRAGMENT_SUBROUTINE',0x92EC) +GL_FRAGMENT_SUBROUTINE_UNIFORM=_C('GL_FRAGMENT_SUBROUTINE_UNIFORM',0x92F2) +GL_FRAGMENT_TEXTURE=_C('GL_FRAGMENT_TEXTURE',0x829F) +GL_FRAMEBUFFER_BLEND=_C('GL_FRAMEBUFFER_BLEND',0x828B) +GL_FRAMEBUFFER_DEFAULT_FIXED_SAMPLE_LOCATIONS=_C('GL_FRAMEBUFFER_DEFAULT_FIXED_SAMPLE_LOCATIONS',0x9314) +GL_FRAMEBUFFER_DEFAULT_HEIGHT=_C('GL_FRAMEBUFFER_DEFAULT_HEIGHT',0x9311) +GL_FRAMEBUFFER_DEFAULT_LAYERS=_C('GL_FRAMEBUFFER_DEFAULT_LAYERS',0x9312) +GL_FRAMEBUFFER_DEFAULT_SAMPLES=_C('GL_FRAMEBUFFER_DEFAULT_SAMPLES',0x9313) +GL_FRAMEBUFFER_DEFAULT_WIDTH=_C('GL_FRAMEBUFFER_DEFAULT_WIDTH',0x9310) +GL_FRAMEBUFFER_RENDERABLE=_C('GL_FRAMEBUFFER_RENDERABLE',0x8289) +GL_FRAMEBUFFER_RENDERABLE_LAYERED=_C('GL_FRAMEBUFFER_RENDERABLE_LAYERED',0x828A) +GL_FULL_SUPPORT=_C('GL_FULL_SUPPORT',0x82B7) +GL_GEOMETRY_SUBROUTINE=_C('GL_GEOMETRY_SUBROUTINE',0x92EB) +GL_GEOMETRY_SUBROUTINE_UNIFORM=_C('GL_GEOMETRY_SUBROUTINE_UNIFORM',0x92F1) +GL_GEOMETRY_TEXTURE=_C('GL_GEOMETRY_TEXTURE',0x829E) +GL_GET_TEXTURE_IMAGE_FORMAT=_C('GL_GET_TEXTURE_IMAGE_FORMAT',0x8291) +GL_GET_TEXTURE_IMAGE_TYPE=_C('GL_GET_TEXTURE_IMAGE_TYPE',0x8292) +GL_IMAGE_CLASS_10_10_10_2=_C('GL_IMAGE_CLASS_10_10_10_2',0x82C3) +GL_IMAGE_CLASS_11_11_10=_C('GL_IMAGE_CLASS_11_11_10',0x82C2) +GL_IMAGE_CLASS_1_X_16=_C('GL_IMAGE_CLASS_1_X_16',0x82BE) +GL_IMAGE_CLASS_1_X_32=_C('GL_IMAGE_CLASS_1_X_32',0x82BB) +GL_IMAGE_CLASS_1_X_8=_C('GL_IMAGE_CLASS_1_X_8',0x82C1) +GL_IMAGE_CLASS_2_X_16=_C('GL_IMAGE_CLASS_2_X_16',0x82BD) +GL_IMAGE_CLASS_2_X_32=_C('GL_IMAGE_CLASS_2_X_32',0x82BA) +GL_IMAGE_CLASS_2_X_8=_C('GL_IMAGE_CLASS_2_X_8',0x82C0) +GL_IMAGE_CLASS_4_X_16=_C('GL_IMAGE_CLASS_4_X_16',0x82BC) +GL_IMAGE_CLASS_4_X_32=_C('GL_IMAGE_CLASS_4_X_32',0x82B9) +GL_IMAGE_CLASS_4_X_8=_C('GL_IMAGE_CLASS_4_X_8',0x82BF) +GL_IMAGE_COMPATIBILITY_CLASS=_C('GL_IMAGE_COMPATIBILITY_CLASS',0x82A8) +GL_IMAGE_PIXEL_FORMAT=_C('GL_IMAGE_PIXEL_FORMAT',0x82A9) +GL_IMAGE_PIXEL_TYPE=_C('GL_IMAGE_PIXEL_TYPE',0x82AA) +GL_IMAGE_TEXEL_SIZE=_C('GL_IMAGE_TEXEL_SIZE',0x82A7) +GL_INTERNALFORMAT_ALPHA_SIZE=_C('GL_INTERNALFORMAT_ALPHA_SIZE',0x8274) +GL_INTERNALFORMAT_ALPHA_TYPE=_C('GL_INTERNALFORMAT_ALPHA_TYPE',0x827B) +GL_INTERNALFORMAT_BLUE_SIZE=_C('GL_INTERNALFORMAT_BLUE_SIZE',0x8273) +GL_INTERNALFORMAT_BLUE_TYPE=_C('GL_INTERNALFORMAT_BLUE_TYPE',0x827A) +GL_INTERNALFORMAT_DEPTH_SIZE=_C('GL_INTERNALFORMAT_DEPTH_SIZE',0x8275) +GL_INTERNALFORMAT_DEPTH_TYPE=_C('GL_INTERNALFORMAT_DEPTH_TYPE',0x827C) +GL_INTERNALFORMAT_GREEN_SIZE=_C('GL_INTERNALFORMAT_GREEN_SIZE',0x8272) +GL_INTERNALFORMAT_GREEN_TYPE=_C('GL_INTERNALFORMAT_GREEN_TYPE',0x8279) +GL_INTERNALFORMAT_PREFERRED=_C('GL_INTERNALFORMAT_PREFERRED',0x8270) +GL_INTERNALFORMAT_RED_SIZE=_C('GL_INTERNALFORMAT_RED_SIZE',0x8271) +GL_INTERNALFORMAT_RED_TYPE=_C('GL_INTERNALFORMAT_RED_TYPE',0x8278) +GL_INTERNALFORMAT_SHARED_SIZE=_C('GL_INTERNALFORMAT_SHARED_SIZE',0x8277) +GL_INTERNALFORMAT_STENCIL_SIZE=_C('GL_INTERNALFORMAT_STENCIL_SIZE',0x8276) +GL_INTERNALFORMAT_STENCIL_TYPE=_C('GL_INTERNALFORMAT_STENCIL_TYPE',0x827D) +GL_INTERNALFORMAT_SUPPORTED=_C('GL_INTERNALFORMAT_SUPPORTED',0x826F) +GL_IS_PER_PATCH=_C('GL_IS_PER_PATCH',0x92E7) +GL_IS_ROW_MAJOR=_C('GL_IS_ROW_MAJOR',0x9300) +GL_LOCATION=_C('GL_LOCATION',0x930E) +GL_LOCATION_INDEX=_C('GL_LOCATION_INDEX',0x930F) +GL_MANUAL_GENERATE_MIPMAP=_C('GL_MANUAL_GENERATE_MIPMAP',0x8294) +GL_MATRIX_STRIDE=_C('GL_MATRIX_STRIDE',0x92FF) +GL_MAX_COMBINED_COMPUTE_UNIFORM_COMPONENTS=_C('GL_MAX_COMBINED_COMPUTE_UNIFORM_COMPONENTS',0x8266) +GL_MAX_COMBINED_DIMENSIONS=_C('GL_MAX_COMBINED_DIMENSIONS',0x8282) +GL_MAX_COMBINED_SHADER_OUTPUT_RESOURCES=_C('GL_MAX_COMBINED_SHADER_OUTPUT_RESOURCES',0x8F39) +GL_MAX_COMBINED_SHADER_STORAGE_BLOCKS=_C('GL_MAX_COMBINED_SHADER_STORAGE_BLOCKS',0x90DC) +GL_MAX_COMPUTE_ATOMIC_COUNTERS=_C('GL_MAX_COMPUTE_ATOMIC_COUNTERS',0x8265) +GL_MAX_COMPUTE_ATOMIC_COUNTER_BUFFERS=_C('GL_MAX_COMPUTE_ATOMIC_COUNTER_BUFFERS',0x8264) +GL_MAX_COMPUTE_IMAGE_UNIFORMS=_C('GL_MAX_COMPUTE_IMAGE_UNIFORMS',0x91BD) +GL_MAX_COMPUTE_SHADER_STORAGE_BLOCKS=_C('GL_MAX_COMPUTE_SHADER_STORAGE_BLOCKS',0x90DB) +GL_MAX_COMPUTE_SHARED_MEMORY_SIZE=_C('GL_MAX_COMPUTE_SHARED_MEMORY_SIZE',0x8262) +GL_MAX_COMPUTE_TEXTURE_IMAGE_UNITS=_C('GL_MAX_COMPUTE_TEXTURE_IMAGE_UNITS',0x91BC) +GL_MAX_COMPUTE_UNIFORM_BLOCKS=_C('GL_MAX_COMPUTE_UNIFORM_BLOCKS',0x91BB) +GL_MAX_COMPUTE_UNIFORM_COMPONENTS=_C('GL_MAX_COMPUTE_UNIFORM_COMPONENTS',0x8263) +GL_MAX_COMPUTE_WORK_GROUP_COUNT=_C('GL_MAX_COMPUTE_WORK_GROUP_COUNT',0x91BE) +GL_MAX_COMPUTE_WORK_GROUP_INVOCATIONS=_C('GL_MAX_COMPUTE_WORK_GROUP_INVOCATIONS',0x90EB) +GL_MAX_COMPUTE_WORK_GROUP_SIZE=_C('GL_MAX_COMPUTE_WORK_GROUP_SIZE',0x91BF) +GL_MAX_DEBUG_GROUP_STACK_DEPTH=_C('GL_MAX_DEBUG_GROUP_STACK_DEPTH',0x826C) +GL_MAX_DEBUG_LOGGED_MESSAGES=_C('GL_MAX_DEBUG_LOGGED_MESSAGES',0x9144) +GL_MAX_DEBUG_MESSAGE_LENGTH=_C('GL_MAX_DEBUG_MESSAGE_LENGTH',0x9143) +GL_MAX_DEPTH=_C('GL_MAX_DEPTH',0x8280) +GL_MAX_ELEMENT_INDEX=_C('GL_MAX_ELEMENT_INDEX',0x8D6B) +GL_MAX_FRAGMENT_SHADER_STORAGE_BLOCKS=_C('GL_MAX_FRAGMENT_SHADER_STORAGE_BLOCKS',0x90DA) +GL_MAX_FRAMEBUFFER_HEIGHT=_C('GL_MAX_FRAMEBUFFER_HEIGHT',0x9316) +GL_MAX_FRAMEBUFFER_LAYERS=_C('GL_MAX_FRAMEBUFFER_LAYERS',0x9317) +GL_MAX_FRAMEBUFFER_SAMPLES=_C('GL_MAX_FRAMEBUFFER_SAMPLES',0x9318) +GL_MAX_FRAMEBUFFER_WIDTH=_C('GL_MAX_FRAMEBUFFER_WIDTH',0x9315) +GL_MAX_GEOMETRY_SHADER_STORAGE_BLOCKS=_C('GL_MAX_GEOMETRY_SHADER_STORAGE_BLOCKS',0x90D7) +GL_MAX_HEIGHT=_C('GL_MAX_HEIGHT',0x827F) +GL_MAX_LABEL_LENGTH=_C('GL_MAX_LABEL_LENGTH',0x82E8) +GL_MAX_LAYERS=_C('GL_MAX_LAYERS',0x8281) +GL_MAX_NAME_LENGTH=_C('GL_MAX_NAME_LENGTH',0x92F6) +GL_MAX_NUM_ACTIVE_VARIABLES=_C('GL_MAX_NUM_ACTIVE_VARIABLES',0x92F7) +GL_MAX_NUM_COMPATIBLE_SUBROUTINES=_C('GL_MAX_NUM_COMPATIBLE_SUBROUTINES',0x92F8) +GL_MAX_SHADER_STORAGE_BLOCK_SIZE=_C('GL_MAX_SHADER_STORAGE_BLOCK_SIZE',0x90DE) +GL_MAX_SHADER_STORAGE_BUFFER_BINDINGS=_C('GL_MAX_SHADER_STORAGE_BUFFER_BINDINGS',0x90DD) +GL_MAX_TESS_CONTROL_SHADER_STORAGE_BLOCKS=_C('GL_MAX_TESS_CONTROL_SHADER_STORAGE_BLOCKS',0x90D8) +GL_MAX_TESS_EVALUATION_SHADER_STORAGE_BLOCKS=_C('GL_MAX_TESS_EVALUATION_SHADER_STORAGE_BLOCKS',0x90D9) +GL_MAX_UNIFORM_LOCATIONS=_C('GL_MAX_UNIFORM_LOCATIONS',0x826E) +GL_MAX_VERTEX_ATTRIB_BINDINGS=_C('GL_MAX_VERTEX_ATTRIB_BINDINGS',0x82DA) +GL_MAX_VERTEX_ATTRIB_RELATIVE_OFFSET=_C('GL_MAX_VERTEX_ATTRIB_RELATIVE_OFFSET',0x82D9) +GL_MAX_VERTEX_SHADER_STORAGE_BLOCKS=_C('GL_MAX_VERTEX_SHADER_STORAGE_BLOCKS',0x90D6) +GL_MAX_WIDTH=_C('GL_MAX_WIDTH',0x827E) +GL_MIPMAP=_C('GL_MIPMAP',0x8293) +GL_NAME_LENGTH=_C('GL_NAME_LENGTH',0x92F9) +GL_NUM_ACTIVE_VARIABLES=_C('GL_NUM_ACTIVE_VARIABLES',0x9304) +GL_NUM_SHADING_LANGUAGE_VERSIONS=_C('GL_NUM_SHADING_LANGUAGE_VERSIONS',0x82E9) +GL_OFFSET=_C('GL_OFFSET',0x92FC) +GL_PRIMITIVE_RESTART_FIXED_INDEX=_C('GL_PRIMITIVE_RESTART_FIXED_INDEX',0x8D69) +GL_PROGRAM=_C('GL_PROGRAM',0x82E2) +GL_PROGRAM_INPUT=_C('GL_PROGRAM_INPUT',0x92E3) +GL_PROGRAM_OUTPUT=_C('GL_PROGRAM_OUTPUT',0x92E4) +GL_PROGRAM_PIPELINE=_C('GL_PROGRAM_PIPELINE',0x82E4) +GL_QUERY=_C('GL_QUERY',0x82E3) +GL_READ_PIXELS=_C('GL_READ_PIXELS',0x828C) +GL_READ_PIXELS_FORMAT=_C('GL_READ_PIXELS_FORMAT',0x828D) +GL_READ_PIXELS_TYPE=_C('GL_READ_PIXELS_TYPE',0x828E) +GL_REFERENCED_BY_COMPUTE_SHADER=_C('GL_REFERENCED_BY_COMPUTE_SHADER',0x930B) +GL_REFERENCED_BY_FRAGMENT_SHADER=_C('GL_REFERENCED_BY_FRAGMENT_SHADER',0x930A) +GL_REFERENCED_BY_GEOMETRY_SHADER=_C('GL_REFERENCED_BY_GEOMETRY_SHADER',0x9309) +GL_REFERENCED_BY_TESS_CONTROL_SHADER=_C('GL_REFERENCED_BY_TESS_CONTROL_SHADER',0x9307) +GL_REFERENCED_BY_TESS_EVALUATION_SHADER=_C('GL_REFERENCED_BY_TESS_EVALUATION_SHADER',0x9308) +GL_REFERENCED_BY_VERTEX_SHADER=_C('GL_REFERENCED_BY_VERTEX_SHADER',0x9306) +GL_SAMPLER=_C('GL_SAMPLER',0x82E6) +GL_SHADER=_C('GL_SHADER',0x82E1) +GL_SHADER_IMAGE_ATOMIC=_C('GL_SHADER_IMAGE_ATOMIC',0x82A6) +GL_SHADER_IMAGE_LOAD=_C('GL_SHADER_IMAGE_LOAD',0x82A4) +GL_SHADER_IMAGE_STORE=_C('GL_SHADER_IMAGE_STORE',0x82A5) +GL_SHADER_STORAGE_BARRIER_BIT=_C('GL_SHADER_STORAGE_BARRIER_BIT',0x00002000) +GL_SHADER_STORAGE_BLOCK=_C('GL_SHADER_STORAGE_BLOCK',0x92E6) +GL_SHADER_STORAGE_BUFFER=_C('GL_SHADER_STORAGE_BUFFER',0x90D2) +GL_SHADER_STORAGE_BUFFER_BINDING=_C('GL_SHADER_STORAGE_BUFFER_BINDING',0x90D3) +GL_SHADER_STORAGE_BUFFER_OFFSET_ALIGNMENT=_C('GL_SHADER_STORAGE_BUFFER_OFFSET_ALIGNMENT',0x90DF) +GL_SHADER_STORAGE_BUFFER_SIZE=_C('GL_SHADER_STORAGE_BUFFER_SIZE',0x90D5) +GL_SHADER_STORAGE_BUFFER_START=_C('GL_SHADER_STORAGE_BUFFER_START',0x90D4) +GL_SIMULTANEOUS_TEXTURE_AND_DEPTH_TEST=_C('GL_SIMULTANEOUS_TEXTURE_AND_DEPTH_TEST',0x82AC) +GL_SIMULTANEOUS_TEXTURE_AND_DEPTH_WRITE=_C('GL_SIMULTANEOUS_TEXTURE_AND_DEPTH_WRITE',0x82AE) +GL_SIMULTANEOUS_TEXTURE_AND_STENCIL_TEST=_C('GL_SIMULTANEOUS_TEXTURE_AND_STENCIL_TEST',0x82AD) +GL_SIMULTANEOUS_TEXTURE_AND_STENCIL_WRITE=_C('GL_SIMULTANEOUS_TEXTURE_AND_STENCIL_WRITE',0x82AF) +GL_SRGB_READ=_C('GL_SRGB_READ',0x8297) +GL_SRGB_WRITE=_C('GL_SRGB_WRITE',0x8298) +GL_STACK_OVERFLOW=_C('GL_STACK_OVERFLOW',0x0503) +GL_STACK_UNDERFLOW=_C('GL_STACK_UNDERFLOW',0x0504) +GL_STENCIL_COMPONENTS=_C('GL_STENCIL_COMPONENTS',0x8285) +GL_STENCIL_RENDERABLE=_C('GL_STENCIL_RENDERABLE',0x8288) +GL_TESS_CONTROL_SUBROUTINE=_C('GL_TESS_CONTROL_SUBROUTINE',0x92E9) +GL_TESS_CONTROL_SUBROUTINE_UNIFORM=_C('GL_TESS_CONTROL_SUBROUTINE_UNIFORM',0x92EF) +GL_TESS_CONTROL_TEXTURE=_C('GL_TESS_CONTROL_TEXTURE',0x829C) +GL_TESS_EVALUATION_SUBROUTINE=_C('GL_TESS_EVALUATION_SUBROUTINE',0x92EA) +GL_TESS_EVALUATION_SUBROUTINE_UNIFORM=_C('GL_TESS_EVALUATION_SUBROUTINE_UNIFORM',0x92F0) +GL_TESS_EVALUATION_TEXTURE=_C('GL_TESS_EVALUATION_TEXTURE',0x829D) +GL_TEXTURE_BUFFER_OFFSET=_C('GL_TEXTURE_BUFFER_OFFSET',0x919D) +GL_TEXTURE_BUFFER_OFFSET_ALIGNMENT=_C('GL_TEXTURE_BUFFER_OFFSET_ALIGNMENT',0x919F) +GL_TEXTURE_BUFFER_SIZE=_C('GL_TEXTURE_BUFFER_SIZE',0x919E) +GL_TEXTURE_COMPRESSED_BLOCK_HEIGHT=_C('GL_TEXTURE_COMPRESSED_BLOCK_HEIGHT',0x82B2) +GL_TEXTURE_COMPRESSED_BLOCK_SIZE=_C('GL_TEXTURE_COMPRESSED_BLOCK_SIZE',0x82B3) +GL_TEXTURE_COMPRESSED_BLOCK_WIDTH=_C('GL_TEXTURE_COMPRESSED_BLOCK_WIDTH',0x82B1) +GL_TEXTURE_GATHER=_C('GL_TEXTURE_GATHER',0x82A2) +GL_TEXTURE_GATHER_SHADOW=_C('GL_TEXTURE_GATHER_SHADOW',0x82A3) +GL_TEXTURE_IMAGE_FORMAT=_C('GL_TEXTURE_IMAGE_FORMAT',0x828F) +GL_TEXTURE_IMAGE_TYPE=_C('GL_TEXTURE_IMAGE_TYPE',0x8290) +GL_TEXTURE_IMMUTABLE_LEVELS=_C('GL_TEXTURE_IMMUTABLE_LEVELS',0x82DF) +GL_TEXTURE_SHADOW=_C('GL_TEXTURE_SHADOW',0x82A1) +GL_TEXTURE_VIEW=_C('GL_TEXTURE_VIEW',0x82B5) +GL_TEXTURE_VIEW_MIN_LAYER=_C('GL_TEXTURE_VIEW_MIN_LAYER',0x82DD) +GL_TEXTURE_VIEW_MIN_LEVEL=_C('GL_TEXTURE_VIEW_MIN_LEVEL',0x82DB) +GL_TEXTURE_VIEW_NUM_LAYERS=_C('GL_TEXTURE_VIEW_NUM_LAYERS',0x82DE) +GL_TEXTURE_VIEW_NUM_LEVELS=_C('GL_TEXTURE_VIEW_NUM_LEVELS',0x82DC) +GL_TOP_LEVEL_ARRAY_SIZE=_C('GL_TOP_LEVEL_ARRAY_SIZE',0x930C) +GL_TOP_LEVEL_ARRAY_STRIDE=_C('GL_TOP_LEVEL_ARRAY_STRIDE',0x930D) +GL_TRANSFORM_FEEDBACK_VARYING=_C('GL_TRANSFORM_FEEDBACK_VARYING',0x92F4) +GL_TYPE=_C('GL_TYPE',0x92FA) +GL_UNIFORM=_C('GL_UNIFORM',0x92E1) +GL_UNIFORM_BLOCK=_C('GL_UNIFORM_BLOCK',0x92E2) +GL_UNIFORM_BLOCK_REFERENCED_BY_COMPUTE_SHADER=_C('GL_UNIFORM_BLOCK_REFERENCED_BY_COMPUTE_SHADER',0x90EC) +GL_VERTEX_ARRAY=_C('GL_VERTEX_ARRAY',0x8074) +GL_VERTEX_ATTRIB_ARRAY_LONG=_C('GL_VERTEX_ATTRIB_ARRAY_LONG',0x874E) +GL_VERTEX_ATTRIB_BINDING=_C('GL_VERTEX_ATTRIB_BINDING',0x82D4) +GL_VERTEX_ATTRIB_RELATIVE_OFFSET=_C('GL_VERTEX_ATTRIB_RELATIVE_OFFSET',0x82D5) +GL_VERTEX_BINDING_BUFFER=_C('GL_VERTEX_BINDING_BUFFER',0x8F4F) +GL_VERTEX_BINDING_DIVISOR=_C('GL_VERTEX_BINDING_DIVISOR',0x82D6) +GL_VERTEX_BINDING_OFFSET=_C('GL_VERTEX_BINDING_OFFSET',0x82D7) +GL_VERTEX_BINDING_STRIDE=_C('GL_VERTEX_BINDING_STRIDE',0x82D8) +GL_VERTEX_SUBROUTINE=_C('GL_VERTEX_SUBROUTINE',0x92E8) +GL_VERTEX_SUBROUTINE_UNIFORM=_C('GL_VERTEX_SUBROUTINE_UNIFORM',0x92EE) +GL_VERTEX_TEXTURE=_C('GL_VERTEX_TEXTURE',0x829B) +GL_VIEW_CLASS_128_BITS=_C('GL_VIEW_CLASS_128_BITS',0x82C4) +GL_VIEW_CLASS_16_BITS=_C('GL_VIEW_CLASS_16_BITS',0x82CA) +GL_VIEW_CLASS_24_BITS=_C('GL_VIEW_CLASS_24_BITS',0x82C9) +GL_VIEW_CLASS_32_BITS=_C('GL_VIEW_CLASS_32_BITS',0x82C8) +GL_VIEW_CLASS_48_BITS=_C('GL_VIEW_CLASS_48_BITS',0x82C7) +GL_VIEW_CLASS_64_BITS=_C('GL_VIEW_CLASS_64_BITS',0x82C6) +GL_VIEW_CLASS_8_BITS=_C('GL_VIEW_CLASS_8_BITS',0x82CB) +GL_VIEW_CLASS_96_BITS=_C('GL_VIEW_CLASS_96_BITS',0x82C5) +GL_VIEW_CLASS_BPTC_FLOAT=_C('GL_VIEW_CLASS_BPTC_FLOAT',0x82D3) +GL_VIEW_CLASS_BPTC_UNORM=_C('GL_VIEW_CLASS_BPTC_UNORM',0x82D2) +GL_VIEW_CLASS_RGTC1_RED=_C('GL_VIEW_CLASS_RGTC1_RED',0x82D0) +GL_VIEW_CLASS_RGTC2_RG=_C('GL_VIEW_CLASS_RGTC2_RG',0x82D1) +GL_VIEW_CLASS_S3TC_DXT1_RGB=_C('GL_VIEW_CLASS_S3TC_DXT1_RGB',0x82CC) +GL_VIEW_CLASS_S3TC_DXT1_RGBA=_C('GL_VIEW_CLASS_S3TC_DXT1_RGBA',0x82CD) +GL_VIEW_CLASS_S3TC_DXT3_RGBA=_C('GL_VIEW_CLASS_S3TC_DXT3_RGBA',0x82CE) +GL_VIEW_CLASS_S3TC_DXT5_RGBA=_C('GL_VIEW_CLASS_S3TC_DXT5_RGBA',0x82CF) +GL_VIEW_COMPATIBILITY_CLASS=_C('GL_VIEW_COMPATIBILITY_CLASS',0x82B6) +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLintptr,_cs.GLsizei) +def glBindVertexBuffer(bindingindex,buffer,offset,stride):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLenum,_cs.GLenum,ctypes.c_void_p) +def glClearBufferData(target,internalformat,format,type,data):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLintptr,_cs.GLsizeiptr,_cs.GLenum,_cs.GLenum,ctypes.c_void_p) +def glClearBufferSubData(target,internalformat,offset,size,format,type,data):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLuint,_cs.GLenum,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLsizei,_cs.GLsizei) +def glCopyImageSubData(srcName,srcTarget,srcLevel,srcX,srcY,srcZ,dstName,dstTarget,dstLevel,dstX,dstY,dstZ,srcWidth,srcHeight,srcDepth):pass +@_f +@_p.types(None,_cs.GLDEBUGPROC,ctypes.c_void_p) +def glDebugMessageCallback(callback,userParam):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLenum,_cs.GLsizei,arrays.GLuintArray,_cs.GLboolean) +def glDebugMessageControl(source,type,severity,count,ids,enabled):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLuint,_cs.GLenum,_cs.GLsizei,arrays.GLcharArray) +def glDebugMessageInsert(source,type,id,severity,length,buf):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLuint) +def glDispatchCompute(num_groups_x,num_groups_y,num_groups_z):pass +@_f +@_p.types(None,_cs.GLintptr) +def glDispatchComputeIndirect(indirect):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLint) +def glFramebufferParameteri(target,pname,param):pass +@_f +@_p.types(_cs.GLuint,_cs.GLuint,_cs.GLsizei,arrays.GLuintArray,arrays.GLuintArray,arrays.GLuintArray,arrays.GLuintArray,arrays.GLsizeiArray,arrays.GLcharArray) +def glGetDebugMessageLog(count,bufSize,sources,types,ids,severities,lengths,messageLog):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLintArray) +def glGetFramebufferParameteriv(target,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLenum,_cs.GLsizei,arrays.GLint64Array) +def glGetInternalformati64v(target,internalformat,pname,bufSize,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,_cs.GLsizei,arrays.GLsizeiArray,arrays.GLcharArray) +def glGetObjectLabel(identifier,name,bufSize,length,label):pass +@_f +@_p.types(None,ctypes.c_void_p,_cs.GLsizei,arrays.GLsizeiArray,arrays.GLcharArray) +def glGetObjectPtrLabel(ptr,bufSize,length,label):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLvoidpArray) +def glGetPointerv(pname,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLenum,arrays.GLintArray) +def glGetProgramInterfaceiv(program,programInterface,pname,params):pass +@_f +@_p.types(_cs.GLuint,_cs.GLuint,_cs.GLenum,arrays.GLcharArray) +def glGetProgramResourceIndex(program,programInterface,name):pass +@_f +@_p.types(_cs.GLint,_cs.GLuint,_cs.GLenum,arrays.GLcharArray) +def glGetProgramResourceLocation(program,programInterface,name):pass +@_f +@_p.types(_cs.GLint,_cs.GLuint,_cs.GLenum,arrays.GLcharArray) +def glGetProgramResourceLocationIndex(program,programInterface,name):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLuint,_cs.GLsizei,arrays.GLsizeiArray,arrays.GLcharArray) +def glGetProgramResourceName(program,programInterface,index,bufSize,length,name):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLuint,_cs.GLsizei,arrays.GLuintArray,_cs.GLsizei,arrays.GLsizeiArray,arrays.GLintArray) +def glGetProgramResourceiv(program,programInterface,index,propCount,props,bufSize,length,params):pass +@_f +@_p.types(None,_cs.GLuint) +def glInvalidateBufferData(buffer):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLintptr,_cs.GLsizeiptr) +def glInvalidateBufferSubData(buffer,offset,length):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizei,arrays.GLuintArray) +def glInvalidateFramebuffer(target,numAttachments,attachments):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizei,arrays.GLuintArray,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLsizei) +def glInvalidateSubFramebuffer(target,numAttachments,attachments,x,y,width,height):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint) +def glInvalidateTexImage(texture,level):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLsizei,_cs.GLsizei) +def glInvalidateTexSubImage(texture,level,xoffset,yoffset,zoffset,width,height,depth):pass +@_f +@_p.types(None,_cs.GLenum,ctypes.c_void_p,_cs.GLsizei,_cs.GLsizei) +def glMultiDrawArraysIndirect(mode,indirect,drawcount,stride):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,ctypes.c_void_p,_cs.GLsizei,_cs.GLsizei) +def glMultiDrawElementsIndirect(mode,type,indirect,drawcount,stride):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,_cs.GLsizei,arrays.GLcharArray) +def glObjectLabel(identifier,name,length,label):pass +@_f +@_p.types(None,ctypes.c_void_p,_cs.GLsizei,arrays.GLcharArray) +def glObjectPtrLabel(ptr,length,label):pass +@_f +@_p.types(None,) +def glPopDebugGroup():pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,_cs.GLsizei,arrays.GLcharArray) +def glPushDebugGroup(source,id,length,message):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLuint) +def glShaderStorageBlockBinding(program,storageBlockIndex,storageBlockBinding):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLuint,_cs.GLintptr,_cs.GLsizeiptr) +def glTexBufferRange(target,internalformat,buffer,offset,size):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizei,_cs.GLenum,_cs.GLsizei,_cs.GLsizei,_cs.GLboolean) +def glTexStorage2DMultisample(target,samples,internalformat,width,height,fixedsamplelocations):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizei,_cs.GLenum,_cs.GLsizei,_cs.GLsizei,_cs.GLsizei,_cs.GLboolean) +def glTexStorage3DMultisample(target,samples,internalformat,width,height,depth,fixedsamplelocations):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLuint,_cs.GLenum,_cs.GLuint,_cs.GLuint,_cs.GLuint,_cs.GLuint) +def glTextureView(texture,target,origtexture,internalformat,minlevel,numlevels,minlayer,numlayers):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint) +def glVertexAttribBinding(attribindex,bindingindex):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLenum,_cs.GLboolean,_cs.GLuint) +def glVertexAttribFormat(attribindex,size,type,normalized,relativeoffset):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLenum,_cs.GLuint) +def glVertexAttribIFormat(attribindex,size,type,relativeoffset):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLenum,_cs.GLuint) +def glVertexAttribLFormat(attribindex,size,type,relativeoffset):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint) +def glVertexBindingDivisor(bindingindex,divisor):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/VERSION/GL_4_4.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/VERSION/GL_4_4.py new file mode 100644 index 00000000..cda8ee4c --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/VERSION/GL_4_4.py @@ -0,0 +1,65 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_VERSION_GL_4_4' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_VERSION_GL_4_4',error_checker=_errors._error_checker) +GL_BUFFER_IMMUTABLE_STORAGE=_C('GL_BUFFER_IMMUTABLE_STORAGE',0x821F) +GL_BUFFER_STORAGE_FLAGS=_C('GL_BUFFER_STORAGE_FLAGS',0x8220) +GL_CLEAR_TEXTURE=_C('GL_CLEAR_TEXTURE',0x9365) +GL_CLIENT_MAPPED_BUFFER_BARRIER_BIT=_C('GL_CLIENT_MAPPED_BUFFER_BARRIER_BIT',0x00004000) +GL_CLIENT_STORAGE_BIT=_C('GL_CLIENT_STORAGE_BIT',0x0200) +GL_DYNAMIC_STORAGE_BIT=_C('GL_DYNAMIC_STORAGE_BIT',0x0100) +GL_LOCATION_COMPONENT=_C('GL_LOCATION_COMPONENT',0x934A) +GL_MAP_COHERENT_BIT=_C('GL_MAP_COHERENT_BIT',0x0080) +GL_MAP_PERSISTENT_BIT=_C('GL_MAP_PERSISTENT_BIT',0x0040) +GL_MAP_READ_BIT=_C('GL_MAP_READ_BIT',0x0001) +GL_MAP_WRITE_BIT=_C('GL_MAP_WRITE_BIT',0x0002) +GL_MAX_VERTEX_ATTRIB_STRIDE=_C('GL_MAX_VERTEX_ATTRIB_STRIDE',0x82E5) +GL_MIRROR_CLAMP_TO_EDGE=_C('GL_MIRROR_CLAMP_TO_EDGE',0x8743) +GL_PRIMITIVE_RESTART_FOR_PATCHES_SUPPORTED=_C('GL_PRIMITIVE_RESTART_FOR_PATCHES_SUPPORTED',0x8221) +GL_QUERY_BUFFER=_C('GL_QUERY_BUFFER',0x9192) +GL_QUERY_BUFFER_BARRIER_BIT=_C('GL_QUERY_BUFFER_BARRIER_BIT',0x00008000) +GL_QUERY_BUFFER_BINDING=_C('GL_QUERY_BUFFER_BINDING',0x9193) +GL_QUERY_RESULT_NO_WAIT=_C('GL_QUERY_RESULT_NO_WAIT',0x9194) +GL_STENCIL_INDEX=_C('GL_STENCIL_INDEX',0x1901) +GL_STENCIL_INDEX8=_C('GL_STENCIL_INDEX8',0x8D48) +GL_TEXTURE_BUFFER_BINDING=_C('GL_TEXTURE_BUFFER_BINDING',0x8C2A) +GL_TRANSFORM_FEEDBACK_BUFFER=_C('GL_TRANSFORM_FEEDBACK_BUFFER',0x8C8E) +GL_TRANSFORM_FEEDBACK_BUFFER_INDEX=_C('GL_TRANSFORM_FEEDBACK_BUFFER_INDEX',0x934B) +GL_TRANSFORM_FEEDBACK_BUFFER_STRIDE=_C('GL_TRANSFORM_FEEDBACK_BUFFER_STRIDE',0x934C) +GL_UNSIGNED_INT_10F_11F_11F_REV=_C('GL_UNSIGNED_INT_10F_11F_11F_REV',0x8C3B) +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,_cs.GLsizei,arrays.GLuintArray) +def glBindBuffersBase(target,first,count,buffers):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,_cs.GLsizei,arrays.GLuintArray,ctypes.POINTER(_cs.GLintptr),ctypes.POINTER(_cs.GLsizeiptr)) +def glBindBuffersRange(target,first,count,buffers,offsets,sizes):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizei,arrays.GLuintArray) +def glBindImageTextures(first,count,textures):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizei,arrays.GLuintArray) +def glBindSamplers(first,count,samplers):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizei,arrays.GLuintArray) +def glBindTextures(first,count,textures):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizei,arrays.GLuintArray,ctypes.POINTER(_cs.GLintptr),arrays.GLsizeiArray) +def glBindVertexBuffers(first,count,buffers,offsets,strides):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizeiptr,ctypes.c_void_p,_cs.GLbitfield) +def glBufferStorage(target,size,data,flags):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLenum,_cs.GLenum,ctypes.c_void_p) +def glClearTexImage(texture,level,format,type,data):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLsizei,_cs.GLsizei,_cs.GLenum,_cs.GLenum,ctypes.c_void_p) +def glClearTexSubImage(texture,level,xoffset,yoffset,zoffset,width,height,depth,format,type,data):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/VERSION/GL_4_5.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/VERSION/GL_4_5.py new file mode 100644 index 00000000..e85ceb32 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/VERSION/GL_4_5.py @@ -0,0 +1,418 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_VERSION_GL_4_5' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_VERSION_GL_4_5',error_checker=_errors._error_checker) +GL_BACK=_C('GL_BACK',0x0405) +GL_CLIP_DEPTH_MODE=_C('GL_CLIP_DEPTH_MODE',0x935D) +GL_CLIP_ORIGIN=_C('GL_CLIP_ORIGIN',0x935C) +GL_CONTEXT_FLAG_ROBUST_ACCESS_BIT=_C('GL_CONTEXT_FLAG_ROBUST_ACCESS_BIT',0x00000004) +GL_CONTEXT_LOST=_C('GL_CONTEXT_LOST',0x0507) +GL_CONTEXT_LOST=_C('GL_CONTEXT_LOST',0x0507) +GL_CONTEXT_RELEASE_BEHAVIOR=_C('GL_CONTEXT_RELEASE_BEHAVIOR',0x82FB) +GL_CONTEXT_RELEASE_BEHAVIOR_FLUSH=_C('GL_CONTEXT_RELEASE_BEHAVIOR_FLUSH',0x82FC) +GL_GUILTY_CONTEXT_RESET=_C('GL_GUILTY_CONTEXT_RESET',0x8253) +GL_INNOCENT_CONTEXT_RESET=_C('GL_INNOCENT_CONTEXT_RESET',0x8254) +GL_LOSE_CONTEXT_ON_RESET=_C('GL_LOSE_CONTEXT_ON_RESET',0x8252) +GL_LOWER_LEFT=_C('GL_LOWER_LEFT',0x8CA1) +GL_MAX_COMBINED_CLIP_AND_CULL_DISTANCES=_C('GL_MAX_COMBINED_CLIP_AND_CULL_DISTANCES',0x82FA) +GL_MAX_CULL_DISTANCES=_C('GL_MAX_CULL_DISTANCES',0x82F9) +GL_NEGATIVE_ONE_TO_ONE=_C('GL_NEGATIVE_ONE_TO_ONE',0x935E) +GL_NONE=_C('GL_NONE',0) +GL_NO_ERROR=_C('GL_NO_ERROR',0) +GL_NO_RESET_NOTIFICATION=_C('GL_NO_RESET_NOTIFICATION',0x8261) +GL_QUERY_BY_REGION_NO_WAIT_INVERTED=_C('GL_QUERY_BY_REGION_NO_WAIT_INVERTED',0x8E1A) +GL_QUERY_BY_REGION_WAIT_INVERTED=_C('GL_QUERY_BY_REGION_WAIT_INVERTED',0x8E19) +GL_QUERY_NO_WAIT_INVERTED=_C('GL_QUERY_NO_WAIT_INVERTED',0x8E18) +GL_QUERY_TARGET=_C('GL_QUERY_TARGET',0x82EA) +GL_QUERY_WAIT_INVERTED=_C('GL_QUERY_WAIT_INVERTED',0x8E17) +GL_RESET_NOTIFICATION_STRATEGY=_C('GL_RESET_NOTIFICATION_STRATEGY',0x8256) +GL_TEXTURE_BINDING_1D=_C('GL_TEXTURE_BINDING_1D',0x8068) +GL_TEXTURE_BINDING_1D_ARRAY=_C('GL_TEXTURE_BINDING_1D_ARRAY',0x8C1C) +GL_TEXTURE_BINDING_2D=_C('GL_TEXTURE_BINDING_2D',0x8069) +GL_TEXTURE_BINDING_2D_ARRAY=_C('GL_TEXTURE_BINDING_2D_ARRAY',0x8C1D) +GL_TEXTURE_BINDING_2D_MULTISAMPLE=_C('GL_TEXTURE_BINDING_2D_MULTISAMPLE',0x9104) +GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY=_C('GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY',0x9105) +GL_TEXTURE_BINDING_3D=_C('GL_TEXTURE_BINDING_3D',0x806A) +GL_TEXTURE_BINDING_BUFFER=_C('GL_TEXTURE_BINDING_BUFFER',0x8C2C) +GL_TEXTURE_BINDING_CUBE_MAP=_C('GL_TEXTURE_BINDING_CUBE_MAP',0x8514) +GL_TEXTURE_BINDING_CUBE_MAP_ARRAY=_C('GL_TEXTURE_BINDING_CUBE_MAP_ARRAY',0x900A) +GL_TEXTURE_BINDING_RECTANGLE=_C('GL_TEXTURE_BINDING_RECTANGLE',0x84F6) +GL_TEXTURE_TARGET=_C('GL_TEXTURE_TARGET',0x1006) +GL_UNKNOWN_CONTEXT_RESET=_C('GL_UNKNOWN_CONTEXT_RESET',0x8255) +GL_UPPER_LEFT=_C('GL_UPPER_LEFT',0x8CA2) +GL_ZERO_TO_ONE=_C('GL_ZERO_TO_ONE',0x935F) +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint) +def glBindTextureUnit(unit,texture):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLbitfield,_cs.GLenum) +def glBlitNamedFramebuffer(readFramebuffer,drawFramebuffer,srcX0,srcY0,srcX1,srcY1,dstX0,dstY0,dstX1,dstY1,mask,filter):pass +@_f +@_p.types(_cs.GLenum,_cs.GLuint,_cs.GLenum) +def glCheckNamedFramebufferStatus(framebuffer,target):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLenum,_cs.GLenum,ctypes.c_void_p) +def glClearNamedBufferData(buffer,internalformat,format,type,data):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLintptr,_cs.GLsizeiptr,_cs.GLenum,_cs.GLenum,ctypes.c_void_p) +def glClearNamedBufferSubData(buffer,internalformat,offset,size,format,type,data):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLint,_cs.GLfloat,_cs.GLint) +def glClearNamedFramebufferfi(framebuffer,buffer,drawbuffer,depth,stencil):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLint,arrays.GLfloatArray) +def glClearNamedFramebufferfv(framebuffer,buffer,drawbuffer,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLint,arrays.GLintArray) +def glClearNamedFramebufferiv(framebuffer,buffer,drawbuffer,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLint,arrays.GLuintArray) +def glClearNamedFramebufferuiv(framebuffer,buffer,drawbuffer,value):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum) +def glClipControl(origin,depth):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLenum,_cs.GLsizei,ctypes.c_void_p) +def glCompressedTextureSubImage1D(texture,level,xoffset,width,format,imageSize,data):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLsizei,_cs.GLenum,_cs.GLsizei,ctypes.c_void_p) +def glCompressedTextureSubImage2D(texture,level,xoffset,yoffset,width,height,format,imageSize,data):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLsizei,_cs.GLsizei,_cs.GLenum,_cs.GLsizei,ctypes.c_void_p) +def glCompressedTextureSubImage3D(texture,level,xoffset,yoffset,zoffset,width,height,depth,format,imageSize,data):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLintptr,_cs.GLintptr,_cs.GLsizeiptr) +def glCopyNamedBufferSubData(readBuffer,writeBuffer,readOffset,writeOffset,size):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLsizei) +def glCopyTextureSubImage1D(texture,level,xoffset,x,y,width):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLsizei) +def glCopyTextureSubImage2D(texture,level,xoffset,yoffset,x,y,width,height):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLsizei) +def glCopyTextureSubImage3D(texture,level,xoffset,yoffset,zoffset,x,y,width,height):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray) +def glCreateBuffers(n,buffers):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray) +def glCreateFramebuffers(n,framebuffers):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray) +def glCreateProgramPipelines(n,pipelines):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizei,arrays.GLuintArray) +def glCreateQueries(target,n,ids):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray) +def glCreateRenderbuffers(n,renderbuffers):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray) +def glCreateSamplers(n,samplers):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizei,arrays.GLuintArray) +def glCreateTextures(target,n,textures):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray) +def glCreateTransformFeedbacks(n,ids):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray) +def glCreateVertexArrays(n,arrays):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint) +def glDisableVertexArrayAttrib(vaobj,index):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint) +def glEnableVertexArrayAttrib(vaobj,index):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLintptr,_cs.GLsizeiptr) +def glFlushMappedNamedBufferRange(buffer,offset,length):pass +@_f +@_p.types(None,_cs.GLuint) +def glGenerateTextureMipmap(texture):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,ctypes.c_void_p) +def glGetCompressedTextureImage(texture,level,bufSize,pixels):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLsizei,_cs.GLsizei,_cs.GLsizei,ctypes.c_void_p) +def glGetCompressedTextureSubImage(texture,level,xoffset,yoffset,zoffset,width,height,depth,bufSize,pixels):pass +@_f +@_p.types(_cs.GLenum,) +def glGetGraphicsResetStatus():pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLint64Array) +def glGetNamedBufferParameteri64v(buffer,pname,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLintArray) +def glGetNamedBufferParameteriv(buffer,pname,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLvoidpArray) +def glGetNamedBufferPointerv(buffer,pname,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLintptr,_cs.GLsizeiptr,ctypes.c_void_p) +def glGetNamedBufferSubData(buffer,offset,size,data):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLenum,arrays.GLintArray) +def glGetNamedFramebufferAttachmentParameteriv(framebuffer,attachment,pname,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLintArray) +def glGetNamedFramebufferParameteriv(framebuffer,pname,param):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLintArray) +def glGetNamedRenderbufferParameteriv(renderbuffer,pname,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLenum,_cs.GLintptr) +def glGetQueryBufferObjecti64v(id,buffer,pname,offset):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLenum,_cs.GLintptr) +def glGetQueryBufferObjectiv(id,buffer,pname,offset):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLenum,_cs.GLintptr) +def glGetQueryBufferObjectui64v(id,buffer,pname,offset):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLenum,_cs.GLintptr) +def glGetQueryBufferObjectuiv(id,buffer,pname,offset):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLenum,_cs.GLenum,_cs.GLsizei,ctypes.c_void_p) +def glGetTextureImage(texture,level,format,type,bufSize,pixels):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLenum,arrays.GLfloatArray) +def glGetTextureLevelParameterfv(texture,level,pname,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLenum,arrays.GLintArray) +def glGetTextureLevelParameteriv(texture,level,pname,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLintArray) +def glGetTextureParameterIiv(texture,pname,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLuintArray) +def glGetTextureParameterIuiv(texture,pname,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLfloatArray) +def glGetTextureParameterfv(texture,pname,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLintArray) +def glGetTextureParameteriv(texture,pname,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLsizei,_cs.GLsizei,_cs.GLenum,_cs.GLenum,_cs.GLsizei,ctypes.c_void_p) +def glGetTextureSubImage(texture,level,xoffset,yoffset,zoffset,width,height,depth,format,type,bufSize,pixels):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLuint,arrays.GLint64Array) +def glGetTransformFeedbacki64_v(xfb,pname,index,param):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLuint,arrays.GLintArray) +def glGetTransformFeedbacki_v(xfb,pname,index,param):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLintArray) +def glGetTransformFeedbackiv(xfb,pname,param):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLenum,arrays.GLint64Array) +def glGetVertexArrayIndexed64iv(vaobj,index,pname,param):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLenum,arrays.GLintArray) +def glGetVertexArrayIndexediv(vaobj,index,pname,param):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLintArray) +def glGetVertexArrayiv(vaobj,pname,param):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLenum,_cs.GLsizei,ctypes.c_void_p) +def glGetnColorTable(target,format,type,bufSize,table):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLint,_cs.GLsizei,ctypes.c_void_p) +def glGetnCompressedTexImage(target,lod,bufSize,pixels):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLenum,_cs.GLsizei,ctypes.c_void_p) +def glGetnConvolutionFilter(target,format,type,bufSize,image):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLboolean,_cs.GLenum,_cs.GLenum,_cs.GLsizei,ctypes.c_void_p) +def glGetnHistogram(target,reset,format,type,bufSize,values):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLsizei,arrays.GLdoubleArray) +def glGetnMapdv(target,query,bufSize,v):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLsizei,arrays.GLfloatArray) +def glGetnMapfv(target,query,bufSize,v):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLsizei,arrays.GLintArray) +def glGetnMapiv(target,query,bufSize,v):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLboolean,_cs.GLenum,_cs.GLenum,_cs.GLsizei,ctypes.c_void_p) +def glGetnMinmax(target,reset,format,type,bufSize,values):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizei,arrays.GLfloatArray) +def glGetnPixelMapfv(map,bufSize,values):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizei,arrays.GLuintArray) +def glGetnPixelMapuiv(map,bufSize,values):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizei,arrays.GLushortArray) +def glGetnPixelMapusv(map,bufSize,values):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLubyteArray) +def glGetnPolygonStipple(bufSize,pattern):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLenum,_cs.GLsizei,ctypes.c_void_p,_cs.GLsizei,ctypes.c_void_p,ctypes.c_void_p) +def glGetnSeparableFilter(target,format,type,rowBufSize,row,columnBufSize,column,span):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLint,_cs.GLenum,_cs.GLenum,_cs.GLsizei,ctypes.c_void_p) +def glGetnTexImage(target,level,format,type,bufSize,pixels):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLdoubleArray) +def glGetnUniformdv(program,location,bufSize,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLfloatArray) +def glGetnUniformfv(program,location,bufSize,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLintArray) +def glGetnUniformiv(program,location,bufSize,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLuintArray) +def glGetnUniformuiv(program,location,bufSize,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizei,arrays.GLuintArray) +def glInvalidateNamedFramebufferData(framebuffer,numAttachments,attachments):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizei,arrays.GLuintArray,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLsizei) +def glInvalidateNamedFramebufferSubData(framebuffer,numAttachments,attachments,x,y,width,height):pass +@_f +@_p.types(ctypes.c_void_p,_cs.GLuint,_cs.GLenum) +def glMapNamedBuffer(buffer,access):pass +@_f +@_p.types(ctypes.c_void_p,_cs.GLuint,_cs.GLintptr,_cs.GLsizeiptr,_cs.GLbitfield) +def glMapNamedBufferRange(buffer,offset,length,access):pass +@_f +@_p.types(None,_cs.GLbitfield) +def glMemoryBarrierByRegion(barriers):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizeiptr,ctypes.c_void_p,_cs.GLenum) +def glNamedBufferData(buffer,size,data,usage):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizeiptr,ctypes.c_void_p,_cs.GLbitfield) +def glNamedBufferStorage(buffer,size,data,flags):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLintptr,_cs.GLsizeiptr,ctypes.c_void_p) +def glNamedBufferSubData(buffer,offset,size,data):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum) +def glNamedFramebufferDrawBuffer(framebuffer,buf):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizei,arrays.GLuintArray) +def glNamedFramebufferDrawBuffers(framebuffer,n,bufs):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLint) +def glNamedFramebufferParameteri(framebuffer,pname,param):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum) +def glNamedFramebufferReadBuffer(framebuffer,src):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLenum,_cs.GLuint) +def glNamedFramebufferRenderbuffer(framebuffer,attachment,renderbuffertarget,renderbuffer):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLuint,_cs.GLint) +def glNamedFramebufferTexture(framebuffer,attachment,texture,level):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLuint,_cs.GLint,_cs.GLint) +def glNamedFramebufferTextureLayer(framebuffer,attachment,texture,level,layer):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLsizei,_cs.GLsizei) +def glNamedRenderbufferStorage(renderbuffer,internalformat,width,height):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizei,_cs.GLenum,_cs.GLsizei,_cs.GLsizei) +def glNamedRenderbufferStorageMultisample(renderbuffer,samples,internalformat,width,height):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLsizei,_cs.GLenum,_cs.GLenum,_cs.GLsizei,ctypes.c_void_p) +def glReadnPixels(x,y,width,height,format,type,bufSize,data):pass +@_f +@_p.types(None,) +def glTextureBarrier():pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLuint) +def glTextureBuffer(texture,internalformat,buffer):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLuint,_cs.GLintptr,_cs.GLsizeiptr) +def glTextureBufferRange(texture,internalformat,buffer,offset,size):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLintArray) +def glTextureParameterIiv(texture,pname,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLuintArray) +def glTextureParameterIuiv(texture,pname,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLfloat) +def glTextureParameterf(texture,pname,param):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLfloatArray) +def glTextureParameterfv(texture,pname,param):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLint) +def glTextureParameteri(texture,pname,param):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLintArray) +def glTextureParameteriv(texture,pname,param):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizei,_cs.GLenum,_cs.GLsizei) +def glTextureStorage1D(texture,levels,internalformat,width):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizei,_cs.GLenum,_cs.GLsizei,_cs.GLsizei) +def glTextureStorage2D(texture,levels,internalformat,width,height):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizei,_cs.GLenum,_cs.GLsizei,_cs.GLsizei,_cs.GLboolean) +def glTextureStorage2DMultisample(texture,samples,internalformat,width,height,fixedsamplelocations):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizei,_cs.GLenum,_cs.GLsizei,_cs.GLsizei,_cs.GLsizei) +def glTextureStorage3D(texture,levels,internalformat,width,height,depth):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizei,_cs.GLenum,_cs.GLsizei,_cs.GLsizei,_cs.GLsizei,_cs.GLboolean) +def glTextureStorage3DMultisample(texture,samples,internalformat,width,height,depth,fixedsamplelocations):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLenum,_cs.GLenum,ctypes.c_void_p) +def glTextureSubImage1D(texture,level,xoffset,width,format,type,pixels):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLsizei,_cs.GLenum,_cs.GLenum,ctypes.c_void_p) +def glTextureSubImage2D(texture,level,xoffset,yoffset,width,height,format,type,pixels):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLsizei,_cs.GLsizei,_cs.GLenum,_cs.GLenum,ctypes.c_void_p) +def glTextureSubImage3D(texture,level,xoffset,yoffset,zoffset,width,height,depth,format,type,pixels):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLuint) +def glTransformFeedbackBufferBase(xfb,index,buffer):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLuint,_cs.GLintptr,_cs.GLsizeiptr) +def glTransformFeedbackBufferRange(xfb,index,buffer,offset,size):pass +@_f +@_p.types(_cs.GLboolean,_cs.GLuint) +def glUnmapNamedBuffer(buffer):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLuint) +def glVertexArrayAttribBinding(vaobj,attribindex,bindingindex):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLint,_cs.GLenum,_cs.GLboolean,_cs.GLuint) +def glVertexArrayAttribFormat(vaobj,attribindex,size,type,normalized,relativeoffset):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLint,_cs.GLenum,_cs.GLuint) +def glVertexArrayAttribIFormat(vaobj,attribindex,size,type,relativeoffset):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLint,_cs.GLenum,_cs.GLuint) +def glVertexArrayAttribLFormat(vaobj,attribindex,size,type,relativeoffset):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLuint) +def glVertexArrayBindingDivisor(vaobj,bindingindex,divisor):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint) +def glVertexArrayElementBuffer(vaobj,buffer):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLuint,_cs.GLintptr,_cs.GLsizei) +def glVertexArrayVertexBuffer(vaobj,bindingindex,buffer,offset,stride):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLsizei,arrays.GLuintArray,ctypes.POINTER(_cs.GLintptr),arrays.GLsizeiArray) +def glVertexArrayVertexBuffers(vaobj,first,count,buffers,offsets,strides):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/VERSION/GL_4_6.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/VERSION/GL_4_6.py new file mode 100644 index 00000000..2729fae5 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/VERSION/GL_4_6.py @@ -0,0 +1,51 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_VERSION_GL_4_6' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_VERSION_GL_4_6',error_checker=_errors._error_checker) +GL_CLIPPING_INPUT_PRIMITIVES=_C('GL_CLIPPING_INPUT_PRIMITIVES',0x82F6) +GL_CLIPPING_OUTPUT_PRIMITIVES=_C('GL_CLIPPING_OUTPUT_PRIMITIVES',0x82F7) +GL_COMPUTE_SHADER_INVOCATIONS=_C('GL_COMPUTE_SHADER_INVOCATIONS',0x82F5) +GL_CONTEXT_FLAG_NO_ERROR_BIT=_C('GL_CONTEXT_FLAG_NO_ERROR_BIT',0x00000008) +GL_CONTEXT_RELEASE_BEHAVIOR=_C('GL_CONTEXT_RELEASE_BEHAVIOR',0x82FB) +GL_CONTEXT_RELEASE_BEHAVIOR_FLUSH=_C('GL_CONTEXT_RELEASE_BEHAVIOR_FLUSH',0x82FC) +GL_FRAGMENT_SHADER_INVOCATIONS=_C('GL_FRAGMENT_SHADER_INVOCATIONS',0x82F4) +GL_GEOMETRY_SHADER_INVOCATIONS=_C('GL_GEOMETRY_SHADER_INVOCATIONS',0x887F) +GL_GEOMETRY_SHADER_PRIMITIVES_EMITTED=_C('GL_GEOMETRY_SHADER_PRIMITIVES_EMITTED',0x82F3) +GL_MAX_TEXTURE_MAX_ANISOTROPY=_C('GL_MAX_TEXTURE_MAX_ANISOTROPY',0x84FF) +GL_NONE=_C('GL_NONE',0) +GL_NUM_SPIR_V_EXTENSIONS=_C('GL_NUM_SPIR_V_EXTENSIONS',0x9554) +GL_PARAMETER_BUFFER=_C('GL_PARAMETER_BUFFER',0x80EE) +GL_PARAMETER_BUFFER_BINDING=_C('GL_PARAMETER_BUFFER_BINDING',0x80EF) +GL_POLYGON_OFFSET_CLAMP=_C('GL_POLYGON_OFFSET_CLAMP',0x8E1B) +GL_PRIMITIVES_SUBMITTED=_C('GL_PRIMITIVES_SUBMITTED',0x82EF) +GL_SHADER_BINARY_FORMAT_SPIR_V=_C('GL_SHADER_BINARY_FORMAT_SPIR_V',0x9551) +GL_SPIR_V_BINARY=_C('GL_SPIR_V_BINARY',0x9552) +GL_SPIR_V_EXTENSIONS=_C('GL_SPIR_V_EXTENSIONS',0x9553) +GL_TESS_CONTROL_SHADER_PATCHES=_C('GL_TESS_CONTROL_SHADER_PATCHES',0x82F1) +GL_TESS_EVALUATION_SHADER_INVOCATIONS=_C('GL_TESS_EVALUATION_SHADER_INVOCATIONS',0x82F2) +GL_TEXTURE_MAX_ANISOTROPY=_C('GL_TEXTURE_MAX_ANISOTROPY',0x84FE) +GL_TRANSFORM_FEEDBACK_OVERFLOW=_C('GL_TRANSFORM_FEEDBACK_OVERFLOW',0x82EC) +GL_TRANSFORM_FEEDBACK_STREAM_OVERFLOW=_C('GL_TRANSFORM_FEEDBACK_STREAM_OVERFLOW',0x82ED) +GL_VERTEX_SHADER_INVOCATIONS=_C('GL_VERTEX_SHADER_INVOCATIONS',0x82F0) +GL_VERTICES_SUBMITTED=_C('GL_VERTICES_SUBMITTED',0x82EE) +@_f +@_p.types(None,_cs.GLenum,ctypes.c_void_p,_cs.GLintptr,_cs.GLsizei,_cs.GLsizei) +def glMultiDrawArraysIndirectCount(mode,indirect,drawcount,maxdrawcount,stride):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,ctypes.c_void_p,_cs.GLintptr,_cs.GLsizei,_cs.GLsizei) +def glMultiDrawElementsIndirectCount(mode,type,indirect,drawcount,maxdrawcount,stride):pass +@_f +@_p.types(None,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat) +def glPolygonOffsetClamp(factor,units,clamp):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLcharArray,_cs.GLuint,arrays.GLuintArray,arrays.GLuintArray) +def glSpecializeShader(shader,pEntryPoint,numSpecializationConstants,pConstantIndex,pConstantValue):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/VERSION/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/VERSION/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/VERSION/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/VERSION/__pycache__/GL_1_0.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/VERSION/__pycache__/GL_1_0.cpython-312.pyc new file mode 100644 index 00000000..3f6552d5 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/VERSION/__pycache__/GL_1_0.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/VERSION/__pycache__/GL_1_1.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/VERSION/__pycache__/GL_1_1.cpython-312.pyc new file mode 100644 index 00000000..38838aa5 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/VERSION/__pycache__/GL_1_1.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/VERSION/__pycache__/GL_1_2.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/VERSION/__pycache__/GL_1_2.cpython-312.pyc new file mode 100644 index 00000000..1206b0b8 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/VERSION/__pycache__/GL_1_2.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/VERSION/__pycache__/GL_1_3.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/VERSION/__pycache__/GL_1_3.cpython-312.pyc new file mode 100644 index 00000000..b8a4a182 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/VERSION/__pycache__/GL_1_3.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/VERSION/__pycache__/GL_1_4.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/VERSION/__pycache__/GL_1_4.cpython-312.pyc new file mode 100644 index 00000000..31ebaa6d Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/VERSION/__pycache__/GL_1_4.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/VERSION/__pycache__/GL_1_5.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/VERSION/__pycache__/GL_1_5.cpython-312.pyc new file mode 100644 index 00000000..7ddd964a Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/VERSION/__pycache__/GL_1_5.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/VERSION/__pycache__/GL_2_0.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/VERSION/__pycache__/GL_2_0.cpython-312.pyc new file mode 100644 index 00000000..38447b6d Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/VERSION/__pycache__/GL_2_0.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/VERSION/__pycache__/GL_2_1.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/VERSION/__pycache__/GL_2_1.cpython-312.pyc new file mode 100644 index 00000000..37b95cba Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/VERSION/__pycache__/GL_2_1.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/VERSION/__pycache__/GL_3_0.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/VERSION/__pycache__/GL_3_0.cpython-312.pyc new file mode 100644 index 00000000..83d9093b Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/VERSION/__pycache__/GL_3_0.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/VERSION/__pycache__/GL_3_1.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/VERSION/__pycache__/GL_3_1.cpython-312.pyc new file mode 100644 index 00000000..2fab316a Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/VERSION/__pycache__/GL_3_1.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/VERSION/__pycache__/GL_3_2.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/VERSION/__pycache__/GL_3_2.cpython-312.pyc new file mode 100644 index 00000000..696e10da Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/VERSION/__pycache__/GL_3_2.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/VERSION/__pycache__/GL_3_3.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/VERSION/__pycache__/GL_3_3.cpython-312.pyc new file mode 100644 index 00000000..5027c9f0 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/VERSION/__pycache__/GL_3_3.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/VERSION/__pycache__/GL_4_0.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/VERSION/__pycache__/GL_4_0.cpython-312.pyc new file mode 100644 index 00000000..7c0c47a7 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/VERSION/__pycache__/GL_4_0.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/VERSION/__pycache__/GL_4_1.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/VERSION/__pycache__/GL_4_1.cpython-312.pyc new file mode 100644 index 00000000..8835fb6d Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/VERSION/__pycache__/GL_4_1.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/VERSION/__pycache__/GL_4_2.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/VERSION/__pycache__/GL_4_2.cpython-312.pyc new file mode 100644 index 00000000..16c43206 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/VERSION/__pycache__/GL_4_2.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/VERSION/__pycache__/GL_4_3.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/VERSION/__pycache__/GL_4_3.cpython-312.pyc new file mode 100644 index 00000000..8588b11e Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/VERSION/__pycache__/GL_4_3.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/VERSION/__pycache__/GL_4_4.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/VERSION/__pycache__/GL_4_4.cpython-312.pyc new file mode 100644 index 00000000..8d5c5769 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/VERSION/__pycache__/GL_4_4.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/VERSION/__pycache__/GL_4_5.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/VERSION/__pycache__/GL_4_5.cpython-312.pyc new file mode 100644 index 00000000..d2496646 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/VERSION/__pycache__/GL_4_5.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/VERSION/__pycache__/GL_4_6.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/VERSION/__pycache__/GL_4_6.cpython-312.pyc new file mode 100644 index 00000000..d862170b Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/VERSION/__pycache__/GL_4_6.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/VERSION/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/VERSION/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..512c9a8b Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/VERSION/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/VIV/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/VIV/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/VIV/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/VIV/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/VIV/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..834d17a6 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/VIV/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/WIN/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/WIN/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/WIN/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/WIN/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/WIN/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..24af0ff2 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/WIN/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/WIN/__pycache__/phong_shading.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/WIN/__pycache__/phong_shading.cpython-312.pyc new file mode 100644 index 00000000..0e2192ac Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/WIN/__pycache__/phong_shading.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/WIN/__pycache__/specular_fog.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/WIN/__pycache__/specular_fog.cpython-312.pyc new file mode 100644 index 00000000..7d3af8fa Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/WIN/__pycache__/specular_fog.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/WIN/phong_shading.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/WIN/phong_shading.py new file mode 100644 index 00000000..d8f49968 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/WIN/phong_shading.py @@ -0,0 +1,16 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_WIN_phong_shading' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_WIN_phong_shading',error_checker=_errors._error_checker) +GL_PHONG_HINT_WIN=_C('GL_PHONG_HINT_WIN',0x80EB) +GL_PHONG_WIN=_C('GL_PHONG_WIN',0x80EA) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/WIN/specular_fog.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/WIN/specular_fog.py new file mode 100644 index 00000000..804cb34e --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/WIN/specular_fog.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GL import _types as _cs +# End users want this... +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GL_WIN_specular_fog' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GL,'GL_WIN_specular_fog',error_checker=_errors._error_checker) +GL_FOG_SPECULAR_TEXTURE_WIN=_C('GL_FOG_SPECULAR_TEXTURE_WIN',0x80EC) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/__init__.py new file mode 100644 index 00000000..a27c7d4e --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/__init__.py @@ -0,0 +1 @@ +"""Raw (C-style) API for OpenGL.GL""" diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..2c423073 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/__pycache__/_errors.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/__pycache__/_errors.cpython-312.pyc new file mode 100644 index 00000000..047b9081 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/__pycache__/_errors.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/__pycache__/_glgets.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/__pycache__/_glgets.cpython-312.pyc new file mode 100644 index 00000000..85bc012a Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/__pycache__/_glgets.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/__pycache__/_lookupint.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/__pycache__/_lookupint.cpython-312.pyc new file mode 100644 index 00000000..1c84aea6 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/__pycache__/_lookupint.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/__pycache__/_types.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/__pycache__/_types.cpython-312.pyc new file mode 100644 index 00000000..d415b94b Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/__pycache__/_types.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/_errors.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/_errors.py new file mode 100644 index 00000000..d67e9e11 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/_errors.py @@ -0,0 +1,6 @@ +from OpenGL.platform import PLATFORM as _p +from OpenGL.error import _ErrorChecker +if _ErrorChecker: + _error_checker = _ErrorChecker( _p, _p.GL.glGetError ) +else: + _error_checker = None diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/_glgets.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/_glgets.py new file mode 100644 index 00000000..f7bcc317 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/_glgets.py @@ -0,0 +1,2290 @@ +"""glGet* auto-generation of output arrays (DO NOT EDIT, AUTOGENERATED)""" +try: + from OpenGL.raw.GL._lookupint import LookupInt as _L +except ImportError: + def _L(*args): + raise RuntimeError( "Need to define a lookupint for this api" ) +_glget_size_mapping = _m = {} +# _m[0x8892] = TODO # GL_ARRAY_BUFFER +# _m[0x92C0] = TODO # GL_ATOMIC_COUNTER_BUFFER +# _m[0x8777] = TODO # GL_BUMP_NUM_TEX_UNITS_ATI +# _m[0x8775] = TODO # GL_BUMP_ROT_MATRIX_ATI +# _m[0x8776] = TODO # GL_BUMP_ROT_MATRIX_SIZE_ATI +# _m[0x8778] = TODO # GL_BUMP_TEX_UNITS_ATI +# _m[0x0A00] = TODO # GL_COEFF +# _m[0x8576] = TODO # GL_CONSTANT +# _m[0x8095] = TODO # GL_DETAIL_TEXTURE_2D_SGIS +# _m[0x809C] = TODO # GL_DETAIL_TEXTURE_FUNC_POINTS_SGIS +# _m[0x809A] = TODO # GL_DETAIL_TEXTURE_LEVEL_SGIS +# _m[0x809B] = TODO # GL_DETAIL_TEXTURE_MODE_SGIS +# _m[0x9599] = TODO # GL_DEVICE_LUID_EXT +# _m[0x959A] = TODO # GL_DEVICE_NODE_MASK_EXT +# _m[0x9597] = TODO # GL_DEVICE_UUID_EXT +# _m[0x90EE] = TODO # GL_DISPATCH_INDIRECT_BUFFER +# _m[0x0A02] = TODO # GL_DOMAIN +# _m[0x8F3F] = TODO # GL_DRAW_INDIRECT_BUFFER +# _m[0x9598] = TODO # GL_DRIVER_UUID_EXT +# _m[0x8124] = TODO # GL_DUAL_TEXTURE_SELECT_SGIS +# _m[0x8893] = TODO # GL_ELEMENT_ARRAY_BUFFER +# _m[0x86C0] = TODO # GL_EVAL_2D_NV +# _m[0x86C1] = TODO # GL_EVAL_TRIANGULAR_2D_NV +# _m[0x2400] = TODO # GL_EYE_LINEAR +# _m[0x8210] = TODO # GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING_EXT +# _m[0x8211] = TODO # GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE_EXT +# _m[0x8DA7] = TODO # GL_FRAMEBUFFER_ATTACHMENT_LAYERED_ARB +# _m[0x8DA7] = TODO # GL_FRAMEBUFFER_ATTACHMENT_LAYERED_EXT +# _m[0x8DA7] = TODO # GL_FRAMEBUFFER_ATTACHMENT_LAYERED_OES +# _m[0x8CD1] = TODO # GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT +# _m[0x8CD1] = TODO # GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_OES +# _m[0x8CD0] = TODO # GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_EXT +# _m[0x8CD0] = TODO # GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_OES +# _m[0x8CD4] = TODO # GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_EXT +# _m[0x8CD4] = TODO # GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_OES +# _m[0x8CD3] = TODO # GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_EXT +# _m[0x8CD3] = TODO # GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_OES +# _m[0x8CD4] = TODO # GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER_EXT +# _m[0x8CD2] = TODO # GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_EXT +# _m[0x8CD2] = TODO # GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_OES +# _m[0x8191] = TODO # GL_GENERATE_MIPMAP_SGIS +# _m[0x8917] = TODO # GL_GEOMETRY_INPUT_TYPE +# _m[0x8918] = TODO # GL_GEOMETRY_OUTPUT_TYPE +# _m[0x8916] = TODO # GL_GEOMETRY_VERTICES_OUT +# _m[0x815E] = TODO # GL_IMAGE_CUBIC_WEIGHT_HP +# _m[0x815C] = TODO # GL_IMAGE_MAG_FILTER_HP +# _m[0x815D] = TODO # GL_IMAGE_MIN_FILTER_HP +# _m[0x8159] = TODO # GL_IMAGE_ROTATE_ANGLE_HP +# _m[0x815A] = TODO # GL_IMAGE_ROTATE_ORIGIN_X_HP +# _m[0x815B] = TODO # GL_IMAGE_ROTATE_ORIGIN_Y_HP +# _m[0x8155] = TODO # GL_IMAGE_SCALE_X_HP +# _m[0x8156] = TODO # GL_IMAGE_SCALE_Y_HP +# _m[0x8157] = TODO # GL_IMAGE_TRANSLATE_X_HP +# _m[0x8158] = TODO # GL_IMAGE_TRANSLATE_Y_HP +# _m[0x8182] = TODO # GL_LIST_PRIORITY_SGIX +# _m[0] = TODO # GL_NONE +# _m[0x9596] = TODO # GL_NUM_DEVICE_UUIDS_EXT +# _m[0x2401] = TODO # GL_OBJECT_LINEAR +# _m[0x0A01] = TODO # GL_ORDER +# _m[0x85A0] = TODO # GL_PACK_SUBSAMPLE_RATE_SGIX +# _m[0x80EE] = TODO # GL_PARAMETER_BUFFER +# _m[0x908A] = TODO # GL_PATH_OBJECT_BOUNDING_BOX_NV +# _m[0x88EB] = TODO # GL_PIXEL_PACK_BUFFER +# _m[0x88EC] = TODO # GL_PIXEL_UNPACK_BUFFER +# _m[0x8063] = TODO # GL_PROXY_TEXTURE_1D +# _m[0x8C19] = TODO # GL_PROXY_TEXTURE_1D_ARRAY +# _m[0x8C19] = TODO # GL_PROXY_TEXTURE_1D_ARRAY_EXT +# _m[0x8063] = TODO # GL_PROXY_TEXTURE_1D_EXT +# _m[0x8064] = TODO # GL_PROXY_TEXTURE_2D +# _m[0x8C1B] = TODO # GL_PROXY_TEXTURE_2D_ARRAY +# _m[0x8C1B] = TODO # GL_PROXY_TEXTURE_2D_ARRAY_EXT +# _m[0x8064] = TODO # GL_PROXY_TEXTURE_2D_EXT +# _m[0x9101] = TODO # GL_PROXY_TEXTURE_2D_MULTISAMPLE +# _m[0x9103] = TODO # GL_PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY +# _m[0x8070] = TODO # GL_PROXY_TEXTURE_3D +# _m[0x8070] = TODO # GL_PROXY_TEXTURE_3D_EXT +# _m[0x8135] = TODO # GL_PROXY_TEXTURE_4D_SGIS +# _m[0x851B] = TODO # GL_PROXY_TEXTURE_CUBE_MAP +# _m[0x851B] = TODO # GL_PROXY_TEXTURE_CUBE_MAP_ARB +# _m[0x900B] = TODO # GL_PROXY_TEXTURE_CUBE_MAP_ARRAY +# _m[0x900B] = TODO # GL_PROXY_TEXTURE_CUBE_MAP_ARRAY_ARB +# _m[0x851B] = TODO # GL_PROXY_TEXTURE_CUBE_MAP_EXT +# _m[0x84F7] = TODO # GL_PROXY_TEXTURE_RECTANGLE +# _m[0x84F7] = TODO # GL_PROXY_TEXTURE_RECTANGLE_ARB +# _m[0x84F7] = TODO # GL_PROXY_TEXTURE_RECTANGLE_NV +# _m[0x8125] = TODO # GL_QUAD_TEXTURE_SELECT_SGIS +# _m[0x9192] = TODO # GL_QUERY_BUFFER +# _m[0x8D53] = TODO # GL_RENDERBUFFER_ALPHA_SIZE_EXT +# _m[0x8D53] = TODO # GL_RENDERBUFFER_ALPHA_SIZE_OES +# _m[0x8D52] = TODO # GL_RENDERBUFFER_BLUE_SIZE_EXT +# _m[0x8D52] = TODO # GL_RENDERBUFFER_BLUE_SIZE_OES +# _m[0x8D54] = TODO # GL_RENDERBUFFER_DEPTH_SIZE_EXT +# _m[0x8D54] = TODO # GL_RENDERBUFFER_DEPTH_SIZE_OES +# _m[0x8D51] = TODO # GL_RENDERBUFFER_GREEN_SIZE_EXT +# _m[0x8D51] = TODO # GL_RENDERBUFFER_GREEN_SIZE_OES +# _m[0x8D43] = TODO # GL_RENDERBUFFER_HEIGHT_EXT +# _m[0x8D43] = TODO # GL_RENDERBUFFER_HEIGHT_OES +# _m[0x8D44] = TODO # GL_RENDERBUFFER_INTERNAL_FORMAT_EXT +# _m[0x8D44] = TODO # GL_RENDERBUFFER_INTERNAL_FORMAT_OES +# _m[0x8D50] = TODO # GL_RENDERBUFFER_RED_SIZE_EXT +# _m[0x8D50] = TODO # GL_RENDERBUFFER_RED_SIZE_OES +# _m[0x8CAB] = TODO # GL_RENDERBUFFER_SAMPLES_ANGLE +# _m[0x8CAB] = TODO # GL_RENDERBUFFER_SAMPLES_APPLE +# _m[0x8CAB] = TODO # GL_RENDERBUFFER_SAMPLES_EXT +# _m[0x8CAB] = TODO # GL_RENDERBUFFER_SAMPLES_NV +# _m[0x8D55] = TODO # GL_RENDERBUFFER_STENCIL_SIZE_EXT +# _m[0x8D55] = TODO # GL_RENDERBUFFER_STENCIL_SIZE_OES +# _m[0x8D42] = TODO # GL_RENDERBUFFER_WIDTH_EXT +# _m[0x8D42] = TODO # GL_RENDERBUFFER_WIDTH_OES +# _m[0x80BF] = TODO # GL_SHADOW_AMBIENT_SGIX +# _m[0x81FB] = TODO # GL_SHARED_TEXTURE_PALETTE_EXT +# _m[0x80B0] = TODO # GL_SHARPEN_TEXTURE_FUNC_POINTS_SGIS +# _m[0x9100] = TODO # GL_TEXTURE_2D_MULTISAMPLE +# _m[0x9102] = TODO # GL_TEXTURE_2D_MULTISAMPLE_ARRAY +# _m[0x8136] = TODO # GL_TEXTURE_4DSIZE_SGIS +# _m[0x8175] = TODO # GL_TEXTURE_CLIPMAP_LOD_OFFSET_SGIX +# _m[0x1003] = TODO # GL_TEXTURE_COMPONENTS +# _m[0x9009] = TODO # GL_TEXTURE_CUBE_MAP_ARRAY_ARB +# _m[0x9009] = TODO # GL_TEXTURE_CUBE_MAP_ARRAY_EXT +# _m[0x9009] = TODO # GL_TEXTURE_CUBE_MAP_ARRAY_OES +# _m[0x8516] = TODO # GL_TEXTURE_CUBE_MAP_NEGATIVE_X +# _m[0x8518] = TODO # GL_TEXTURE_CUBE_MAP_NEGATIVE_Y +# _m[0x851A] = TODO # GL_TEXTURE_CUBE_MAP_NEGATIVE_Z +# _m[0x8515] = TODO # GL_TEXTURE_CUBE_MAP_POSITIVE_X +# _m[0x8517] = TODO # GL_TEXTURE_CUBE_MAP_POSITIVE_Y +# _m[0x8519] = TODO # GL_TEXTURE_CUBE_MAP_POSITIVE_Z +# _m[0x8147] = TODO # GL_TEXTURE_FILTER4_SIZE_SGIS +# _m[0x819D] = TODO # GL_TEXTURE_GEQUAL_R_SGIX +# _m[0x819C] = TODO # GL_TEXTURE_LEQUAL_R_SGIX +# _m[0x84FE] = TODO # GL_TEXTURE_MAX_ANISOTROPY +# _m[0x8C8E] = TODO # GL_TRANSFORM_FEEDBACK_BUFFER +# _m[0x8A11] = TODO # GL_UNIFORM_BUFFER +# _m[0x85A1] = TODO # GL_UNPACK_SUBSAMPLE_RATE_SGIX +_m[0x0D5B] = (1,) # GL_ACCUM_ALPHA_BITS +_m[0x0D5A] = (1,) # GL_ACCUM_BLUE_BITS +_m[0x0B80] = (4,) # GL_ACCUM_CLEAR_VALUE +_m[0x0D59] = (1,) # GL_ACCUM_GREEN_BITS +_m[0x0D58] = (1,) # GL_ACCUM_RED_BITS +_m[0x92D9] = (1,) # GL_ACTIVE_ATOMIC_COUNTER_BUFFERS +_m[0x8B89] = (1,) # GL_ACTIVE_ATTRIBUTES +_m[0x8B8A] = (1,) # GL_ACTIVE_ATTRIBUTE_MAX_LENGTH +_m[0x8259] = (1,) # GL_ACTIVE_PROGRAM +_m[0x92F5] = (1,) # GL_ACTIVE_RESOURCES +_m[0x8911] = (1,) # GL_ACTIVE_STENCIL_FACE_EXT +_m[0x8DE5] = (1,) # GL_ACTIVE_SUBROUTINES +_m[0x8E48] = (1,) # GL_ACTIVE_SUBROUTINE_MAX_LENGTH +_m[0x8DE6] = (1,) # GL_ACTIVE_SUBROUTINE_UNIFORMS +_m[0x8E47] = (1,) # GL_ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS +_m[0x8E49] = (1,) # GL_ACTIVE_SUBROUTINE_UNIFORM_MAX_LENGTH +_m[0x84E0] = (1,) # GL_ACTIVE_TEXTURE +_m[0x84E0] = (1,) # GL_ACTIVE_TEXTURE_ARB +_m[0x8B86] = (1,) # GL_ACTIVE_UNIFORMS +_m[0x8A36] = (1,) # GL_ACTIVE_UNIFORM_BLOCKS +_m[0x8A35] = (1,) # GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH +_m[0x8B87] = (1,) # GL_ACTIVE_UNIFORM_MAX_LENGTH +_m[0x9305] = (1,) # GL_ACTIVE_VARIABLES +_m[0x86A5] = (1,) # GL_ACTIVE_VERTEX_UNITS_ARB +_m[0x846E] = (2,) # GL_ALIASED_LINE_WIDTH_RANGE +_m[0x846D] = (2,) # GL_ALIASED_POINT_SIZE_RANGE +_m[0x0D1D] = (1,) # GL_ALPHA_BIAS +_m[0x0D55] = (1,) # GL_ALPHA_BITS +_m[0x8567] = (1,) # GL_ALPHA_MAX_CLAMP_INGR +_m[0x8563] = (1,) # GL_ALPHA_MIN_CLAMP_INGR +_m[0x0D1C] = (1,) # GL_ALPHA_SCALE +_m[0x0BC0] = (1,) # GL_ALPHA_TEST +_m[0x0BC1] = (1,) # GL_ALPHA_TEST_FUNC +_m[0x0BC1] = (1,) # GL_ALPHA_TEST_FUNC_QCOM +_m[0x0BC0] = (1,) # GL_ALPHA_TEST_QCOM +_m[0x0BC2] = (1,) # GL_ALPHA_TEST_REF +_m[0x0BC2] = (1,) # GL_ALPHA_TEST_REF_QCOM +_m[0x92BF] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_alpha_to_coverage_dither_control.txt # GL_ALPHA_TO_COVERAGE_DITHER_MODE_NV +_m[0x1200] = (4,) # GL_AMBIENT +_m[0x1602] = (4,) # GL_AMBIENT_AND_DIFFUSE +_m[0x8C2F] = (1,) # GL_ANY_SAMPLES_PASSED +_m[0x8D6A] = (1,) # GL_ANY_SAMPLES_PASSED_CONSERVATIVE +_m[0x8894] = (1,) # GL_ARRAY_BUFFER_BINDING +_m[0x8894] = (1,) # GL_ARRAY_BUFFER_BINDING_ARB +_m[0x81A9] = (1,) # GL_ARRAY_ELEMENT_LOCK_COUNT_EXT +_m[0x81A8] = (1,) # GL_ARRAY_ELEMENT_LOCK_FIRST_EXT +_m[0x8766] = (1,) # GL_ARRAY_OBJECT_BUFFER_ATI +_m[0x8767] = (1,) # GL_ARRAY_OBJECT_OFFSET_ATI +_m[0x92FB] = (1,) # GL_ARRAY_SIZE +_m[0x92FE] = (1,) # GL_ARRAY_STRIDE +_m[0x835D] = (1,) # GL_ASYNC_DRAW_PIXELS_SGIX +_m[0x832C] = (1,) # GL_ASYNC_HISTOGRAM_SGIX +_m[0x8329] = (1,) # GL_ASYNC_MARKER_SGIX +_m[0x835E] = (1,) # GL_ASYNC_READ_PIXELS_SGIX +_m[0x835C] = (1,) # GL_ASYNC_TEX_IMAGE_SGIX +_m[0x92C5] = (1,) # GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTERS +_m[0x92C6] = (1,)#TODO Is actually GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTERS # GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTER_INDICES +_m[0x92C1] = (1,) # GL_ATOMIC_COUNTER_BUFFER_BINDING +_m[0x92C4] = (1,)#TODO Is actually GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTERS # GL_ATOMIC_COUNTER_BUFFER_DATA_SIZE +_m[0x9301] = (1,) # GL_ATOMIC_COUNTER_BUFFER_INDEX +_m[0x90ED] = (1,)#TODO Is actually GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTERS # GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_COMPUTE_SHADER +_m[0x92CB] = (1,)#TODO Is actually GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTERS # GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_FRAGMENT_SHADER +_m[0x92CA] = (1,)#TODO Is actually GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTERS # GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_GEOMETRY_SHADER +_m[0x959E] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_MESH_SHADER_NV +_m[0x959F] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TASK_SHADER_NV +_m[0x92C8] = (1,)#TODO Is actually GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTERS # GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_CONTROL_SHADER +_m[0x92C9] = (1,)#TODO Is actually GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTERS # GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_EVALUATION_SHADER +_m[0x92C7] = (1,)#TODO Is actually GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTERS # GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_VERTEX_SHADER +_m[0x92C3] = (1,)#TODO Is actually GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTERS # GL_ATOMIC_COUNTER_BUFFER_SIZE +_m[0x92C2] = (1,)#TODO Is actually GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTERS # GL_ATOMIC_COUNTER_BUFFER_START +_m[0x8B85] = (1,) # GL_ATTACHED_SHADERS +_m[0x8645] = (1,) # GL_ATTRIB_ARRAY_POINTER_NV +_m[0x8623] = (1,) # GL_ATTRIB_ARRAY_SIZE_NV +_m[0x8624] = (1,) # GL_ATTRIB_ARRAY_STRIDE_NV +_m[0x8625] = (1,) # GL_ATTRIB_ARRAY_TYPE_NV +_m[0x0BB0] = (1,) # GL_ATTRIB_STACK_DEPTH +_m[0x8295] = (1,) # GL_AUTO_GENERATE_MIPMAP +_m[0x0D80] = (1,) # GL_AUTO_NORMAL +_m[0x0C00] = (1,) # GL_AUX_BUFFERS +_m[0x843A] = (1,) # GL_BINORMAL_ARRAY_EXT +_m[0x8443] = (1,) # GL_BINORMAL_ARRAY_POINTER_EXT +_m[0x8441] = (1,) # GL_BINORMAL_ARRAY_STRIDE_EXT +_m[0x8440] = (1,) # GL_BINORMAL_ARRAY_TYPE_EXT +_m[0x0BE2] = (1,) # GL_BLEND +_m[0x9285] = (1,) # GL_BLEND_ADVANCED_COHERENT_KHR +_m[0x9285] = (1,) # GL_BLEND_ADVANCED_COHERENT_NV +_m[0x8005] = (4,) # GL_BLEND_COLOR +_m[0x8005] = (4,) # GL_BLEND_COLOR_EXT +_m[0x0BE0] = (1,) # GL_BLEND_DST +_m[0x80CA] = (1,) # GL_BLEND_DST_ALPHA +_m[0x80CA] = (1,) # GL_BLEND_DST_ALPHA_EXT +_m[0x80C8] = (1,) # GL_BLEND_DST_RGB +_m[0x80C8] = (1,) # GL_BLEND_DST_RGB_EXT +_m[0x8009] = (1,) # GL_BLEND_EQUATION +_m[0x883D] = (1,) # GL_BLEND_EQUATION_ALPHA +_m[0x883D] = (1,) # GL_BLEND_EQUATION_ALPHA_EXT +_m[0x8009] = (1,) # GL_BLEND_EQUATION_EXT +_m[0x8009] = (1,) # GL_BLEND_EQUATION_RGB +_m[0x9281] = (3,) # GL_BLEND_OVERLAP_NV +_m[0x9280] = (1,) # GL_BLEND_PREMULTIPLIED_SRC_NV +_m[0x0BE1] = (1,) # GL_BLEND_SRC +_m[0x80CB] = (1,) # GL_BLEND_SRC_ALPHA +_m[0x80CB] = (1,) # GL_BLEND_SRC_ALPHA_EXT +_m[0x80C9] = (1,) # GL_BLEND_SRC_RGB +_m[0x80C9] = (1,) # GL_BLEND_SRC_RGB_EXT +_m[0x92FD] = (1,) # GL_BLOCK_INDEX +_m[0x0D1B] = (1,) # GL_BLUE_BIAS +_m[0x0D54] = (1,) # GL_BLUE_BITS +_m[0x8566] = (1,) # GL_BLUE_MAX_CLAMP_INGR +_m[0x8562] = (1,) # GL_BLUE_MIN_CLAMP_INGR +_m[0x0D1A] = (1,) # GL_BLUE_SCALE +_m[0x88BB] = (1,) # GL_BUFFER_ACCESS +_m[0x88BB] = (1,) # GL_BUFFER_ACCESS_ARB +_m[0x911F] = (1,) # GL_BUFFER_ACCESS_FLAGS +_m[0x9302] = (1,) # GL_BUFFER_BINDING +_m[0x9303] = (1,) # GL_BUFFER_DATA_SIZE +_m[0x8F1D] = (1,) # GL_BUFFER_GPU_ADDRESS_NV +_m[0x821F] = (1,) # GL_BUFFER_IMMUTABLE_STORAGE +_m[0x88BC] = (1,) # GL_BUFFER_MAPPED +_m[0x88BC] = (1,) # GL_BUFFER_MAPPED_ARB +_m[0x9120] = (1,) # GL_BUFFER_MAP_LENGTH +_m[0x9121] = (1,) # GL_BUFFER_MAP_OFFSET +_m[0x88BD] = (1,) # GL_BUFFER_MAP_POINTER +_m[0x88BD] = (1,) # GL_BUFFER_MAP_POINTER_ARB +_m[0x8764] = (1,) # GL_BUFFER_SIZE +_m[0x8764] = (1,) # GL_BUFFER_SIZE_ARB +_m[0x8220] = (1,) # GL_BUFFER_STORAGE_FLAGS +_m[0x8765] = (1,) # GL_BUFFER_USAGE +_m[0x8765] = (1,) # GL_BUFFER_USAGE_ARB +_m[0x877C] = (1,) # GL_BUMP_TARGET_ATI +_m[0x8183] = (1,) # GL_CALLIGRAPHIC_FRAGMENT_SGIX +_m[0x891B] = (1,) # GL_CLAMP_FRAGMENT_COLOR +_m[0x891B] = (1,) # GL_CLAMP_FRAGMENT_COLOR_ARB +_m[0x891C] = (1,) # GL_CLAMP_READ_COLOR +_m[0x891C] = (1,) # GL_CLAMP_READ_COLOR_ARB +_m[0x891A] = (1,) # GL_CLAMP_VERTEX_COLOR +_m[0x891A] = (1,) # GL_CLAMP_VERTEX_COLOR_ARB +_m[0x82B4] = (1,) # GL_CLEAR_BUFFER +_m[0x84E1] = (1,) # GL_CLIENT_ACTIVE_TEXTURE +_m[0x84E1] = (1,) # GL_CLIENT_ACTIVE_TEXTURE_ARB +_m[0x0BB1] = (1,) # GL_CLIENT_ATTRIB_STACK_DEPTH +_m[0x935D] = (2,) # GL_CLIP_DEPTH_MODE +_m[0x3000] = (1,) # GL_CLIP_DISTANCE0 +_m[0x3001] = (1,) # GL_CLIP_DISTANCE1 +_m[0x3002] = (1,) # GL_CLIP_DISTANCE2 +_m[0x3003] = (1,) # GL_CLIP_DISTANCE3 +_m[0x3004] = (1,) # GL_CLIP_DISTANCE4 +_m[0x3005] = (1,) # GL_CLIP_DISTANCE5 +_m[0x3006] = (1,) # GL_CLIP_DISTANCE6 +_m[0x3007] = (1,) # GL_CLIP_DISTANCE7 +_m[0x935C] = (2,) # GL_CLIP_ORIGIN +_m[0x3000] = (1,) # GL_CLIP_PLANE0 +_m[0x3001] = (1,) # GL_CLIP_PLANE1 +_m[0x3002] = (1,) # GL_CLIP_PLANE2 +_m[0x3003] = (1,) # GL_CLIP_PLANE3 +_m[0x3004] = (1,) # GL_CLIP_PLANE4 +_m[0x3005] = (1,) # GL_CLIP_PLANE5 +_m[0x80F0] = (1,) # GL_CLIP_VOLUME_CLIPPING_HINT_EXT +_m[0x8975] = (1,) # GL_COLOR_ALPHA_PAIRING_ATI +_m[0x8076] = (1,) # GL_COLOR_ARRAY +_m[0x8898] = (1,) # GL_COLOR_ARRAY_BUFFER_BINDING +_m[0x8898] = (1,) # GL_COLOR_ARRAY_BUFFER_BINDING_ARB +_m[0x8084] = (1,) # GL_COLOR_ARRAY_COUNT_EXT +_m[0x8076] = (1,) # GL_COLOR_ARRAY_EXT +_m[0x8F2D] = (1,) # GL_COLOR_ARRAY_LENGTH_NV +_m[0x83F7] = (1,) # GL_COLOR_ARRAY_PARALLEL_POINTERS_INTEL +_m[0x8090] = (1,) # GL_COLOR_ARRAY_POINTER +_m[0x8081] = (1,) # GL_COLOR_ARRAY_SIZE +_m[0x8081] = (1,) # GL_COLOR_ARRAY_SIZE_EXT +_m[0x8083] = (1,) # GL_COLOR_ARRAY_STRIDE +_m[0x8083] = (1,) # GL_COLOR_ARRAY_STRIDE_EXT +_m[0x8082] = (1,) # GL_COLOR_ARRAY_TYPE +_m[0x8082] = (1,) # GL_COLOR_ARRAY_TYPE_EXT +_m[0x8835] = (4,) # GL_COLOR_CLEAR_UNCLAMPED_VALUE_ATI +_m[0x0C22] = (4,) # GL_COLOR_CLEAR_VALUE +_m[0x8283] = (1,) # GL_COLOR_COMPONENTS +_m[0x8296] = (1,) # GL_COLOR_ENCODING +_m[0x8A0F] = (1,) # GL_COLOR_FLOAT_APPLE +_m[0x1603] = (3,) # GL_COLOR_INDEXES +_m[0x0BF2] = (1,) # GL_COLOR_LOGIC_OP +_m[0x0B57] = (1,) # GL_COLOR_MATERIAL +_m[0x0B55] = (1,) # GL_COLOR_MATERIAL_FACE +_m[0x0B56] = (1,) # GL_COLOR_MATERIAL_PARAMETER +_m[0x80B1] = (4,4) # GL_COLOR_MATRIX +_m[0x80B1] = (4,4) # GL_COLOR_MATRIX_SGI +_m[0x80B2] = (1,) # GL_COLOR_MATRIX_STACK_DEPTH +_m[0x80B2] = (1,) # GL_COLOR_MATRIX_STACK_DEPTH_SGI +_m[0x8286] = (1,) # GL_COLOR_RENDERABLE +_m[0x8E20] = (1,) # GL_COLOR_SAMPLES_NV +_m[0x8458] = (1,) # GL_COLOR_SUM +_m[0x8458] = (1,) # GL_COLOR_SUM_ARB +_m[0x854F] = (1,) # GL_COLOR_SUM_CLAMP_NV +_m[0x8458] = (1,) # GL_COLOR_SUM_EXT +_m[0x80D0] = (1,) # GL_COLOR_TABLE +_m[0x80DD] = (1,) # GL_COLOR_TABLE_ALPHA_SIZE +_m[0x80DD] = (1,) # GL_COLOR_TABLE_ALPHA_SIZE_SGI +_m[0x80D7] = (4,) # GL_COLOR_TABLE_BIAS +_m[0x80D7] = (4,) # GL_COLOR_TABLE_BIAS_SGI +_m[0x80DC] = (1,) # GL_COLOR_TABLE_BLUE_SIZE +_m[0x80DC] = (1,) # GL_COLOR_TABLE_BLUE_SIZE_SGI +_m[0x80D8] = (1,) # GL_COLOR_TABLE_FORMAT +_m[0x80D8] = (1,) # GL_COLOR_TABLE_FORMAT_SGI +_m[0x80DB] = (1,) # GL_COLOR_TABLE_GREEN_SIZE +_m[0x80DB] = (1,) # GL_COLOR_TABLE_GREEN_SIZE_SGI +_m[0x80DF] = (1,) # GL_COLOR_TABLE_INTENSITY_SIZE +_m[0x80DF] = (1,) # GL_COLOR_TABLE_INTENSITY_SIZE_SGI +_m[0x80DE] = (1,) # GL_COLOR_TABLE_LUMINANCE_SIZE +_m[0x80DE] = (1,) # GL_COLOR_TABLE_LUMINANCE_SIZE_SGI +_m[0x80DA] = (1,) # GL_COLOR_TABLE_RED_SIZE +_m[0x80DA] = (1,) # GL_COLOR_TABLE_RED_SIZE_SGI +_m[0x80D6] = (4,) # GL_COLOR_TABLE_SCALE +_m[0x80D6] = (4,) # GL_COLOR_TABLE_SCALE_SGI +_m[0x80D0] = (1,) # GL_COLOR_TABLE_SGI +_m[0x80D9] = (1,) # GL_COLOR_TABLE_WIDTH +_m[0x80D9] = (1,) # GL_COLOR_TABLE_WIDTH_SGI +_m[0x0C23] = (4,) # GL_COLOR_WRITEMASK +_m[0x8545] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/register_combiners.txt # GL_COMBINER_AB_DOT_PRODUCT_NV +_m[0x854A] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/register_combiners.txt # GL_COMBINER_AB_OUTPUT_NV +_m[0x8549] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/register_combiners.txt # GL_COMBINER_BIAS_NV +_m[0x8546] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/register_combiners.txt # GL_COMBINER_CD_DOT_PRODUCT_NV +_m[0x854B] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/register_combiners.txt # GL_COMBINER_CD_OUTPUT_NV +_m[0x8544] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/register_combiners.txt # GL_COMBINER_COMPONENT_USAGE_NV +_m[0x8542] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/register_combiners.txt # GL_COMBINER_INPUT_NV +_m[0x8543] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/register_combiners.txt # GL_COMBINER_MAPPING_NV +_m[0x8547] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/register_combiners.txt # GL_COMBINER_MUX_SUM_NV +_m[0x8548] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/register_combiners.txt # GL_COMBINER_SCALE_NV +_m[0x854C] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/register_combiners.txt # GL_COMBINER_SUM_OUTPUT_NV +_m[0x8572] = (1,) # GL_COMBINE_ALPHA +_m[0x8571] = (1,) # GL_COMBINE_RGB +_m[0x8E4B] = (1,) # GL_COMPATIBLE_SUBROUTINES +_m[0x8B81] = (1,) # GL_COMPILE_STATUS +_m[0x86A3] = (_L(0x86A2),) # GL_COMPRESSED_TEXTURE_FORMATS +_m[0x86A3] = (_L(0x86A2),) # GL_COMPRESSED_TEXTURE_FORMATS_ARB +_m[0x90FB] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/compute_program5.txt # GL_COMPUTE_PROGRAM_NV +_m[0x91B9] = (1,) # GL_COMPUTE_SHADER +_m[0x82A0] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_COMPUTE_TEXTURE +_m[0x8267] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/compute_shader.txt # GL_COMPUTE_WORK_GROUP_SIZE +_m[0x9374] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_internalformat_sample_query.txt # GL_CONFORMANT_NV +_m[0x937B] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_conservative_raster_dilate.txt # GL_CONSERVATIVE_RASTER_DILATE_GRANULARITY_NV +_m[0x9379] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_conservative_raster_dilate.txt # GL_CONSERVATIVE_RASTER_DILATE_NV +_m[0x937A] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_conservative_raster_dilate.txt # GL_CONSERVATIVE_RASTER_DILATE_RANGE_NV +_m[0x954D] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_conservative_raster_pre_snap_triangles.txt # GL_CONSERVATIVE_RASTER_MODE_NV +_m[0x1207] = (1,) # GL_CONSTANT_ATTENUATION +_m[0x852A] = (4,) # GL_CONSTANT_COLOR0_NV +_m[0x852B] = (4,) # GL_CONSTANT_COLOR1_NV +_m[0x86E5] = (3,) # GL_CONST_EYE_NV +_m[0x821E] = (1,) # GL_CONTEXT_FLAGS +_m[0x00000002] = (1,) # GL_CONTEXT_FLAG_DEBUG_BIT +_m[0x00000004] = (1,) # GL_CONTEXT_FLAG_ROBUST_ACCESS_BIT_ARB +_m[0x9126] = (1,) # GL_CONTEXT_PROFILE_MASK +_m[0x90F3] = (1,)#TODO Review http://www.opengl.org/registry/specs//KHR/robustness.txt # GL_CONTEXT_ROBUST_ACCESS +_m[0x8010] = (1,) # GL_CONVOLUTION_1D +_m[0x8010] = (1,) # GL_CONVOLUTION_1D_EXT +_m[0x8011] = (1,) # GL_CONVOLUTION_2D +_m[0x8011] = (1,) # GL_CONVOLUTION_2D_EXT +_m[0x8154] = (4,) # GL_CONVOLUTION_BORDER_COLOR +_m[0x8013] = (1,) # GL_CONVOLUTION_BORDER_MODE +_m[0x8013] = (1,) # GL_CONVOLUTION_BORDER_MODE_EXT +_m[0x8015] = (4,) # GL_CONVOLUTION_FILTER_BIAS +_m[0x8015] = (4,) # GL_CONVOLUTION_FILTER_BIAS_EXT +_m[0x8014] = (4,) # GL_CONVOLUTION_FILTER_SCALE +_m[0x8014] = (4,) # GL_CONVOLUTION_FILTER_SCALE_EXT +_m[0x8017] = (1,) # GL_CONVOLUTION_FORMAT +_m[0x8019] = (1,) # GL_CONVOLUTION_HEIGHT +_m[0x8316] = (1,) # GL_CONVOLUTION_HINT_SGIX +_m[0x8018] = (1,) # GL_CONVOLUTION_WIDTH +_m[0x8862] = (1,) # GL_COORD_REPLACE +_m[0x8F36] = (1,) # GL_COPY_READ_BUFFER +_m[0x8F37] = (1,) # GL_COPY_WRITE_BUFFER +_m[0x9332] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_framebuffer_mixed_samples.txt # GL_COVERAGE_MODULATION_NV +_m[0x9333] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_framebuffer_mixed_samples.txt # GL_COVERAGE_MODULATION_TABLE_SIZE_NV +_m[0x8ED4] = (1,) # GL_COVERAGE_SAMPLES_NV +_m[0x0B44] = (1,) # GL_CULL_FACE +_m[0x0B45] = (1,) # GL_CULL_FACE_MODE +_m[0x86E0] = (4,) # GL_CULL_MODES_NV +_m[0x81AA] = (1,) # GL_CULL_VERTEX_EXT +_m[0x81AB] = (1,) # GL_CULL_VERTEX_EYE_POSITION_EXT +_m[103050] = (1,)#TODO Review http://www.opengl.org/registry/specs//IBM/cull_vertex.txt # GL_CULL_VERTEX_IBM +_m[0x81AC] = (1,) # GL_CULL_VERTEX_OBJECT_POSITION_EXT +_m[0x8626] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/vertex_program.txt # GL_CURRENT_ATTRIB_NV +_m[0x843C] = (1,) # GL_CURRENT_BINORMAL_EXT +_m[0x0B00] = (4,) # GL_CURRENT_COLOR +_m[0x8453] = (1,) # GL_CURRENT_FOG_COORD +_m[0x8453] = (1,) # GL_CURRENT_FOG_COORDINATE +_m[0x8453] = (1,) # GL_CURRENT_FOG_COORDINATE_EXT +_m[0x0B01] = (1,) # GL_CURRENT_INDEX +_m[0x8641] = (4, 4) # GL_CURRENT_MATRIX_ARB +_m[0x8845] = (1,) # GL_CURRENT_MATRIX_INDEX_ARB +_m[0x8641] = (4, 4) # GL_CURRENT_MATRIX_NV +_m[0x8640] = (1,) # GL_CURRENT_MATRIX_STACK_DEPTH_ARB +_m[0x8640] = (1,) # GL_CURRENT_MATRIX_STACK_DEPTH_NV +_m[0x0B02] = (3,) # GL_CURRENT_NORMAL +_m[0x8865] = (1,) # GL_CURRENT_OCCLUSION_QUERY_ID_NV +_m[0x8843] = (1,) # GL_CURRENT_PALETTE_MATRIX_ARB +_m[0x8843] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/OES/OES_matrix_palette.txt # GL_CURRENT_PALETTE_MATRIX_OES +_m[0x8B8D] = (1,) # GL_CURRENT_PROGRAM +_m[0x8865] = (1,) # GL_CURRENT_QUERY +_m[0x0B04] = (4,) # GL_CURRENT_RASTER_COLOR +_m[0x0B09] = (1,) # GL_CURRENT_RASTER_DISTANCE +_m[0x0B05] = (1,) # GL_CURRENT_RASTER_INDEX +_m[0x8406] = (1,) # GL_CURRENT_RASTER_NORMAL_SGIX +_m[0x0B07] = (4,) # GL_CURRENT_RASTER_POSITION +_m[0x0B08] = (1,) # GL_CURRENT_RASTER_POSITION_VALID +_m[0x0B06] = (4,) # GL_CURRENT_RASTER_TEXTURE_COORDS +_m[0x8459] = (4,) # GL_CURRENT_SECONDARY_COLOR +_m[0x8459] = (1,) # GL_CURRENT_SECONDARY_COLOR_EXT +_m[0x843B] = (1,) # GL_CURRENT_TANGENT_EXT +_m[0x0B03] = (4,) # GL_CURRENT_TEXTURE_COORDS +_m[0x8E28] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/present_video.txt # GL_CURRENT_TIME_NV +_m[0x8626] = (4,) # GL_CURRENT_VERTEX_ATTRIB +_m[0x850B] = (1,) # GL_CURRENT_VERTEX_WEIGHT_EXT +_m[0x86A8] = (1,) # GL_CURRENT_WEIGHT_ARB +_m[0x8244] = (1,) # GL_DEBUG_CALLBACK_FUNCTION +_m[0x8245] = (1,) # GL_DEBUG_CALLBACK_USER_PARAM +_m[0x826D] = (1,) # GL_DEBUG_GROUP_STACK_DEPTH +_m[0x9145] = (1,) # GL_DEBUG_LOGGED_MESSAGES +_m[0x9145] = (1,) # GL_DEBUG_LOGGED_MESSAGES_AMD +_m[0x9145] = (1,) # GL_DEBUG_LOGGED_MESSAGES_ARB +_m[0x8243] = (1,) # GL_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH +_m[0x8243] = (1,) # GL_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH_ARB +_m[0x92E0] = (1,) # GL_DEBUG_OUTPUT +_m[0x8242] = (1,) # GL_DEBUG_OUTPUT_SYNCHRONOUS +_m[0x8196] = (1,) # GL_DEFORMATIONS_MASK_SGIX +_m[0x8B80] = (1,) # GL_DELETE_STATUS +_m[0x0D1F] = (1,) # GL_DEPTH_BIAS +_m[0x0D56] = (1,) # GL_DEPTH_BITS +_m[0x8891] = (1,) # GL_DEPTH_BOUNDS_EXT +_m[0x8890] = (1,) # GL_DEPTH_BOUNDS_TEST_EXT +_m[0x8DAF] = (1,) # GL_DEPTH_BUFFER_FLOAT_MODE_NV +_m[0x864F] = (1,) # GL_DEPTH_CLAMP +_m[0x901F] = (1,) # GL_DEPTH_CLAMP_FAR_AMD +_m[0x901E] = (1,) # GL_DEPTH_CLAMP_NEAR_AMD +_m[0x864F] = (1,) # GL_DEPTH_CLAMP_NV +_m[0x0B73] = (1,) # GL_DEPTH_CLEAR_VALUE +_m[0x8284] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_DEPTH_COMPONENTS +_m[0x0B74] = (1,) # GL_DEPTH_FUNC +_m[0x8311] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/SGIX/SGIX_depth_pass_instrument.txt # GL_DEPTH_PASS_INSTRUMENT_COUNTERS_SGIX +_m[0x8312] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/SGIX/SGIX_depth_pass_instrument.txt # GL_DEPTH_PASS_INSTRUMENT_MAX_SGIX +_m[0x0B70] = (2,) # GL_DEPTH_RANGE +_m[0x8287] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_DEPTH_RENDERABLE +_m[0x932D] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_framebuffer_mixed_samples.txt # GL_DEPTH_SAMPLES_NV +_m[0x0D1E] = (1,) # GL_DEPTH_SCALE +_m[0x90EA] = (1,) # GL_DEPTH_STENCIL_TEXTURE_MODE +_m[0x0B71] = (1,) # GL_DEPTH_TEST +_m[0x884B] = (1,) # GL_DEPTH_TEXTURE_MODE +_m[0x0B72] = (1,) # GL_DEPTH_WRITEMASK +_m[0x95AB] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_memory_attachment.txt # GL_DETACHED_BUFFERS_NV +_m[0x95A9] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_memory_attachment.txt # GL_DETACHED_MEMORY_INCARNATION_NV +_m[0x95AA] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_memory_attachment.txt # GL_DETACHED_TEXTURES_NV +_m[0x8096] = (1,) # GL_DETAIL_TEXTURE_2D_BINDING_SGIS +_m[0x1201] = (4,) # GL_DIFFUSE +_m[0x90EF] = (1,) # GL_DISPATCH_INDIRECT_BUFFER_BINDING +_m[0x8129] = (3,) # GL_DISTANCE_ATTENUATION_SGIS +_m[0x0BD0] = (1,) # GL_DITHER +_m[0x0C32] = (1,) # GL_DOUBLEBUFFER +_m[0x913E] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/IMG/IMG_framebuffer_downsample.txt # GL_DOWNSAMPLE_SCALES_IMG +_m[0x0C01] = (1,) # GL_DRAW_BUFFER +_m[0x8825] = (1,) # GL_DRAW_BUFFER0 +_m[0x8825] = (1,) # GL_DRAW_BUFFER0_ARB +_m[0x8825] = (1,) # GL_DRAW_BUFFER0_ATI +_m[0x8826] = (1,) # GL_DRAW_BUFFER1 +_m[0x882F] = (1,) # GL_DRAW_BUFFER10 +_m[0x882F] = (1,) # GL_DRAW_BUFFER10_ARB +_m[0x882F] = (1,) # GL_DRAW_BUFFER10_ATI +_m[0x8830] = (1,) # GL_DRAW_BUFFER11 +_m[0x8830] = (1,) # GL_DRAW_BUFFER11_ARB +_m[0x8830] = (1,) # GL_DRAW_BUFFER11_ATI +_m[0x8831] = (1,) # GL_DRAW_BUFFER12 +_m[0x8831] = (1,) # GL_DRAW_BUFFER12_ARB +_m[0x8831] = (1,) # GL_DRAW_BUFFER12_ATI +_m[0x8832] = (1,) # GL_DRAW_BUFFER13 +_m[0x8832] = (1,) # GL_DRAW_BUFFER13_ARB +_m[0x8832] = (1,) # GL_DRAW_BUFFER13_ATI +_m[0x8833] = (1,) # GL_DRAW_BUFFER14 +_m[0x8833] = (1,) # GL_DRAW_BUFFER14_ARB +_m[0x8833] = (1,) # GL_DRAW_BUFFER14_ATI +_m[0x8834] = (1,) # GL_DRAW_BUFFER15 +_m[0x8834] = (1,) # GL_DRAW_BUFFER15_ARB +_m[0x8834] = (1,) # GL_DRAW_BUFFER15_ATI +_m[0x8826] = (1,) # GL_DRAW_BUFFER1_ARB +_m[0x8826] = (1,) # GL_DRAW_BUFFER1_ATI +_m[0x8827] = (1,) # GL_DRAW_BUFFER2 +_m[0x8827] = (1,) # GL_DRAW_BUFFER2_ARB +_m[0x8827] = (1,) # GL_DRAW_BUFFER2_ATI +_m[0x8828] = (1,) # GL_DRAW_BUFFER3 +_m[0x8828] = (1,) # GL_DRAW_BUFFER3_ARB +_m[0x8828] = (1,) # GL_DRAW_BUFFER3_ATI +_m[0x8829] = (1,) # GL_DRAW_BUFFER4 +_m[0x8829] = (1,) # GL_DRAW_BUFFER4_ARB +_m[0x8829] = (1,) # GL_DRAW_BUFFER4_ATI +_m[0x882A] = (1,) # GL_DRAW_BUFFER5 +_m[0x882A] = (1,) # GL_DRAW_BUFFER5_ARB +_m[0x882A] = (1,) # GL_DRAW_BUFFER5_ATI +_m[0x882B] = (1,) # GL_DRAW_BUFFER6 +_m[0x882B] = (1,) # GL_DRAW_BUFFER6_ARB +_m[0x882B] = (1,) # GL_DRAW_BUFFER6_ATI +_m[0x882C] = (1,) # GL_DRAW_BUFFER7 +_m[0x882C] = (1,) # GL_DRAW_BUFFER7_ARB +_m[0x882C] = (1,) # GL_DRAW_BUFFER7_ATI +_m[0x882D] = (1,) # GL_DRAW_BUFFER8 +_m[0x882D] = (1,) # GL_DRAW_BUFFER8_ARB +_m[0x882D] = (1,) # GL_DRAW_BUFFER8_ATI +_m[0x882E] = (1,) # GL_DRAW_BUFFER9 +_m[0x882E] = (1,) # GL_DRAW_BUFFER9_ARB +_m[0x882E] = (1,) # GL_DRAW_BUFFER9_ATI +_m[0x0C01] = (1,) # GL_DRAW_BUFFER_EXT +_m[0x8CA9] = (1,) # GL_DRAW_FRAMEBUFFER +_m[0x8CA6] = (1,) # GL_DRAW_FRAMEBUFFER_BINDING +_m[0x8F43] = (1,) # GL_DRAW_INDIRECT_BUFFER_BINDING +_m[0x8716] = (1,) # GL_DS_BIAS_NV +_m[0x8710] = (1,) # GL_DS_SCALE_NV +_m[0x8717] = (1,) # GL_DT_BIAS_NV +_m[0x8711] = (1,) # GL_DT_SCALE_NV +_m[0x0B43] = (1,) # GL_EDGE_FLAG +_m[0x8079] = (1,) # GL_EDGE_FLAG_ARRAY +_m[0x889B] = (1,) # GL_EDGE_FLAG_ARRAY_BUFFER_BINDING +_m[0x889B] = (1,) # GL_EDGE_FLAG_ARRAY_BUFFER_BINDING_ARB +_m[0x808D] = (1,) # GL_EDGE_FLAG_ARRAY_COUNT_EXT +_m[0x8079] = (1,) # GL_EDGE_FLAG_ARRAY_EXT +_m[0x8F30] = (1,) # GL_EDGE_FLAG_ARRAY_LENGTH_NV +_m[0x8093] = (1,) # GL_EDGE_FLAG_ARRAY_POINTER +_m[0x808C] = (1,) # GL_EDGE_FLAG_ARRAY_STRIDE +_m[0x808C] = (1,) # GL_EDGE_FLAG_ARRAY_STRIDE_EXT +_m[0x932C] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_framebuffer_mixed_samples.txt # GL_EFFECTIVE_RASTER_SAMPLES_EXT +_m[0x8895] = (1,) # GL_ELEMENT_ARRAY_BUFFER_BINDING +_m[0x8895] = (1,) # GL_ELEMENT_ARRAY_BUFFER_BINDING_ARB +_m[0x8F33] = (1,) # GL_ELEMENT_ARRAY_LENGTH_NV +_m[0x8A0E] = (1,)#TODO Review http://www.opengl.org/registry/specs//APPLE/element_array.txt # GL_ELEMENT_ARRAY_POINTER_APPLE +_m[0x8A0D] = (1,) # GL_ELEMENT_ARRAY_TYPE_APPLE +_m[0x8769] = (1,) # GL_ELEMENT_ARRAY_TYPE_ATI +_m[0x1600] = (4,) # GL_EMISSION +_m[0x86C5] = (1,) # GL_EVAL_FRACTIONAL_TESSELLATION_NV +_m[0x86C6] = (1,) # GL_EVAL_VERTEX_ATTRIB0_NV +_m[0x86D0] = (1,) # GL_EVAL_VERTEX_ATTRIB10_NV +_m[0x86D1] = (1,) # GL_EVAL_VERTEX_ATTRIB11_NV +_m[0x86D2] = (1,) # GL_EVAL_VERTEX_ATTRIB12_NV +_m[0x86D3] = (1,) # GL_EVAL_VERTEX_ATTRIB13_NV +_m[0x86D4] = (1,) # GL_EVAL_VERTEX_ATTRIB14_NV +_m[0x86D5] = (1,) # GL_EVAL_VERTEX_ATTRIB15_NV +_m[0x86C7] = (1,) # GL_EVAL_VERTEX_ATTRIB1_NV +_m[0x86C8] = (1,) # GL_EVAL_VERTEX_ATTRIB2_NV +_m[0x86C9] = (1,) # GL_EVAL_VERTEX_ATTRIB3_NV +_m[0x86CA] = (1,) # GL_EVAL_VERTEX_ATTRIB4_NV +_m[0x86CB] = (1,) # GL_EVAL_VERTEX_ATTRIB5_NV +_m[0x86CC] = (1,) # GL_EVAL_VERTEX_ATTRIB6_NV +_m[0x86CD] = (1,) # GL_EVAL_VERTEX_ATTRIB7_NV +_m[0x86CE] = (1,) # GL_EVAL_VERTEX_ATTRIB8_NV +_m[0x86CF] = (1,) # GL_EVAL_VERTEX_ATTRIB9_NV +_m[0x1F03] = (1,) # GL_EXTENSIONS +_m[0x81F6] = (7,) # GL_EYE_LINE_SGIS +_m[0x2502] = (4,) # GL_EYE_PLANE +_m[0x81F4] = (4,) # GL_EYE_POINT_SGIS +_m[0x0DF0] = (1,) # GL_FEEDBACK_BUFFER_POINTER +_m[0x0DF1] = (1,) # GL_FEEDBACK_BUFFER_SIZE +_m[0x0DF2] = (1,) # GL_FEEDBACK_BUFFER_TYPE +_m[0x84F4] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/fence.txt # GL_FENCE_CONDITION_NV +_m[0x84F3] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/fence.txt # GL_FENCE_STATUS_NV +_m[0x8F65] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/ARM/ARM_shader_framebuffer_fetch.txt # GL_FETCH_PER_SAMPLE_ARM +_m[0x1B02] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_polygon_mode.txt # GL_FILL_NV +_m[0x829A] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_FILTER +_m[0x888D] = (4,) # GL_FLOAT_CLEAR_COLOR_VALUE_NV +_m[0x888E] = (1,) # GL_FLOAT_RGBA_MODE_NV +_m[0x0B60] = (1,) # GL_FOG +_m[0x0B66] = (4,) # GL_FOG_COLOR +_m[0x889D] = (1,) # GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING_ARB +_m[0x8456] = (1,)#TODO Review http://www.opengl.org/registry/specs//EXT/fog_coord.txt # GL_FOG_COORDINATE_ARRAY_POINTER_EXT +_m[0x8455] = (1,) # GL_FOG_COORDINATE_ARRAY_STRIDE_EXT +_m[0x8454] = (1,) # GL_FOG_COORDINATE_ARRAY_TYPE_EXT +_m[0x8457] = (1,) # GL_FOG_COORD_ARRAY +_m[0x889D] = (1,) # GL_FOG_COORD_ARRAY_BUFFER_BINDING +_m[0x8F32] = (1,) # GL_FOG_COORD_ARRAY_LENGTH_NV +_m[0x8455] = (1,) # GL_FOG_COORD_ARRAY_STRIDE +_m[0x8454] = (1,) # GL_FOG_COORD_ARRAY_TYPE +_m[0x8450] = (1,) # GL_FOG_COORD_SRC +_m[0x0B62] = (1,) # GL_FOG_DENSITY +_m[0x855A] = (1,) # GL_FOG_DISTANCE_MODE_NV +_m[0x0B64] = (1,) # GL_FOG_END +_m[0x812B] = (1,) # GL_FOG_FUNC_POINTS_SGIS +_m[0x0C54] = (1,) # GL_FOG_HINT +_m[0x0B61] = (1,) # GL_FOG_INDEX +_m[0x0B65] = (1,) # GL_FOG_MODE +_m[0x8198] = (1,) # GL_FOG_OFFSET_SGIX +_m[0x8199] = (4,) # GL_FOG_OFFSET_VALUE_SGIX +_m[0x0B63] = (1,) # GL_FOG_START +_m[0x8402] = (1,) # GL_FRAGMENT_COLOR_MATERIAL_FACE_SGIX +_m[0x8403] = (1,) # GL_FRAGMENT_COLOR_MATERIAL_PARAMETER_SGIX +_m[0x8401] = (1,) # GL_FRAGMENT_COLOR_MATERIAL_SGIX +_m[0x92DE] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_fragment_coverage_to_color.txt # GL_FRAGMENT_COVERAGE_COLOR_NV +_m[0x8E5D] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/gpu_shader5.txt # GL_FRAGMENT_INTERPOLATION_OFFSET_BITS +_m[0x840C] = (1,) # GL_FRAGMENT_LIGHT0_SGIX +_m[0x8400] = (1,) # GL_FRAGMENT_LIGHTING_SGIX +_m[0x840A] = (4,) # GL_FRAGMENT_LIGHT_MODEL_AMBIENT_SGIX +_m[0x8408] = (1,) # GL_FRAGMENT_LIGHT_MODEL_LOCAL_VIEWER_SGIX +_m[0x840B] = (1,) # GL_FRAGMENT_LIGHT_MODEL_NORMAL_INTERPOLATION_SGIX +_m[0x8409] = (1,) # GL_FRAGMENT_LIGHT_MODEL_TWO_SIDE_SGIX +_m[0x8804] = (1,) # GL_FRAGMENT_PROGRAM_ARB +_m[0x8873] = (1,) # GL_FRAGMENT_PROGRAM_BINDING_NV +_m[0x8E5D] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/gpu_program5.txt # GL_FRAGMENT_PROGRAM_INTERPOLATION_OFFSET_BITS_NV +_m[0x8870] = (1,) # GL_FRAGMENT_PROGRAM_NV +_m[0x8DA4] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/parameter_buffer_object.txt # GL_FRAGMENT_PROGRAM_PARAMETER_BUFFER_NV +_m[0x8B30] = (1,) # GL_FRAGMENT_SHADER +_m[0x8920] = (1,) # GL_FRAGMENT_SHADER_ATI +_m[0x8B8B] = (1,) # GL_FRAGMENT_SHADER_DERIVATIVE_HINT +_m[0x8B8B] = (1,) # GL_FRAGMENT_SHADER_DERIVATIVE_HINT_ARB +_m[0x8A52] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/EXT/EXT_shader_framebuffer_fetch.txt # GL_FRAGMENT_SHADER_DISCARDS_SAMPLES_EXT +_m[0x8F66] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/ARM/ARM_shader_framebuffer_fetch.txt # GL_FRAGMENT_SHADER_FRAMEBUFFER_FETCH_MRT_ARM +_m[0x829F] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_FRAGMENT_TEXTURE +_m[0x8215] = (1,) # GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE +_m[0x8214] = (1,) # GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE +_m[0x8210] = (1,) # GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING +_m[0x8211] = (1,) # GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE +_m[0x8216] = (1,) # GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE +_m[0x8213] = (1,) # GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE +_m[0x8DA7] = (1,) # GL_FRAMEBUFFER_ATTACHMENT_LAYERED +_m[0x8CD1] = (1,) # GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME +_m[0x8CD0] = (1,) # GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE +_m[0x8212] = (1,) # GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE +_m[0x8217] = (1,) # GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE +_m[0x9632] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/OVR/OVR_multiview.txt # GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_BASE_VIEW_INDEX_OVR +_m[0x8CD3] = (1,) # GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE +_m[0x8CD4] = (1,) # GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER +_m[0x8CD2] = (1,) # GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL +_m[0x9630] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/OVR/OVR_multiview.txt # GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_NUM_VIEWS_OVR +_m[0x8D6C] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/EXT/EXT_multisampled_render_to_texture.txt # GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_SAMPLES_EXT +_m[0x913F] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/IMG/IMG_framebuffer_downsample.txt # GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_SCALE_IMG +_m[0x8CA6] = (1,) # GL_FRAMEBUFFER_BINDING_EXT +_m[0x8CA6] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/OES/OES_framebuffer_object.txt # GL_FRAMEBUFFER_BINDING_OES +_m[0x828B] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_FRAMEBUFFER_BLEND +_m[0x9314] = (1,) # GL_FRAMEBUFFER_DEFAULT_FIXED_SAMPLE_LOCATIONS +_m[0x9311] = (1,) # GL_FRAMEBUFFER_DEFAULT_HEIGHT +_m[0x9312] = (1,) # GL_FRAMEBUFFER_DEFAULT_LAYERS +_m[0x9313] = (1,) # GL_FRAMEBUFFER_DEFAULT_SAMPLES +_m[0x9310] = (1,) # GL_FRAMEBUFFER_DEFAULT_WIDTH +_m[0x96A2] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/QCOM/QCOM_shader_framebuffer_fetch_noncoherent.txt # GL_FRAMEBUFFER_FETCH_NONCOHERENT_QCOM +_m[0x8289] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_FRAMEBUFFER_RENDERABLE +_m[0x828A] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_FRAMEBUFFER_RENDERABLE_LAYERED +_m[0x8DB9] = (1,) # GL_FRAMEBUFFER_SRGB +_m[0x8DBA] = (1,) # GL_FRAMEBUFFER_SRGB_CAPABLE_EXT +_m[0x8DB9] = (1,) # GL_FRAMEBUFFER_SRGB_EXT +_m[0x818C] = (1,) # GL_FRAMEZOOM_FACTOR_SGIX +_m[0x818B] = (1,) # GL_FRAMEZOOM_SGIX +_m[0x0B46] = (1,) # GL_FRONT_FACE +_m[0x8191] = (1,) # GL_GENERATE_MIPMAP +_m[0x8192] = (1,) # GL_GENERATE_MIPMAP_HINT +_m[0x8192] = (1,) # GL_GENERATE_MIPMAP_HINT_SGIS +_m[0x8DDB] = (1,) # GL_GEOMETRY_INPUT_TYPE_ARB +_m[0x8DDB] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/geometry_program4.txt # GL_GEOMETRY_INPUT_TYPE_EXT +_m[0x8917] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/EXT/EXT_geometry_shader.txt # GL_GEOMETRY_LINKED_INPUT_TYPE_EXT +_m[0x8917] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/OES/OES_geometry_shader.txt # GL_GEOMETRY_LINKED_INPUT_TYPE_OES +_m[0x8918] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/EXT/EXT_geometry_shader.txt # GL_GEOMETRY_LINKED_OUTPUT_TYPE_EXT +_m[0x8918] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/OES/OES_geometry_shader.txt # GL_GEOMETRY_LINKED_OUTPUT_TYPE_OES +_m[0x8916] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/EXT/EXT_geometry_shader.txt # GL_GEOMETRY_LINKED_VERTICES_OUT_EXT +_m[0x8916] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/OES/OES_geometry_shader.txt # GL_GEOMETRY_LINKED_VERTICES_OUT_OES +_m[0x8DDC] = (1,) # GL_GEOMETRY_OUTPUT_TYPE_ARB +_m[0x8DDC] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/geometry_program4.txt # GL_GEOMETRY_OUTPUT_TYPE_EXT +_m[0x8C26] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/geometry_program4.txt # GL_GEOMETRY_PROGRAM_NV +_m[0x8DA3] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/parameter_buffer_object.txt # GL_GEOMETRY_PROGRAM_PARAMETER_BUFFER_NV +_m[0x8DD9] = (1,) # GL_GEOMETRY_SHADER +_m[0x887F] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/gpu_shader5.txt # GL_GEOMETRY_SHADER_INVOCATIONS +_m[0x829E] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_GEOMETRY_TEXTURE +_m[0x8DDA] = (1,) # GL_GEOMETRY_VERTICES_OUT_ARB +_m[0x8DDA] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/geometry_program4.txt # GL_GEOMETRY_VERTICES_OUT_EXT +_m[0x8291] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_GET_TEXTURE_IMAGE_FORMAT +_m[0x8292] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_GET_TEXTURE_IMAGE_TYPE +_m[0x81DA] = (1,) # GL_GLOBAL_ALPHA_FACTOR_SUN +_m[0x8FBB] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/EXT/EXT_disjoint_timer_query.txt # GL_GPU_DISJOINT_EXT +_m[0x9049] = (1,) # GL_GPU_MEMORY_INFO_CURRENT_AVAILABLE_VIDMEM_NVX +_m[0x9047] = (1,) # GL_GPU_MEMORY_INFO_DEDICATED_VIDMEM_NVX +_m[0x904B] = (1,) # GL_GPU_MEMORY_INFO_EVICTED_MEMORY_NVX +_m[0x904A] = (1,) # GL_GPU_MEMORY_INFO_EVICTION_COUNT_NVX +_m[0x9048] = (1,) # GL_GPU_MEMORY_INFO_TOTAL_AVAILABLE_MEMORY_NVX +_m[0x0D19] = (1,) # GL_GREEN_BIAS +_m[0x0D53] = (1,) # GL_GREEN_BITS +_m[0x8565] = (1,) # GL_GREEN_MAX_CLAMP_INGR +_m[0x8561] = (1,) # GL_GREEN_MIN_CLAMP_INGR +_m[0x0D18] = (1,) # GL_GREEN_SCALE +_m[0x8024] = (1,) # GL_HISTOGRAM +_m[0x802B] = (1,) # GL_HISTOGRAM_ALPHA_SIZE +_m[0x802B] = (1,) # GL_HISTOGRAM_ALPHA_SIZE_EXT +_m[0x802A] = (1,) # GL_HISTOGRAM_BLUE_SIZE +_m[0x802A] = (1,) # GL_HISTOGRAM_BLUE_SIZE_EXT +_m[0x8024] = (1,) # GL_HISTOGRAM_EXT +_m[0x8027] = (1,) # GL_HISTOGRAM_FORMAT +_m[0x8027] = (1,) # GL_HISTOGRAM_FORMAT_EXT +_m[0x8029] = (1,) # GL_HISTOGRAM_GREEN_SIZE +_m[0x8029] = (1,) # GL_HISTOGRAM_GREEN_SIZE_EXT +_m[0x802C] = (1,) # GL_HISTOGRAM_LUMINANCE_SIZE +_m[0x802C] = (1,) # GL_HISTOGRAM_LUMINANCE_SIZE_EXT +_m[0x8028] = (1,) # GL_HISTOGRAM_RED_SIZE +_m[0x8028] = (1,) # GL_HISTOGRAM_RED_SIZE_EXT +_m[0x802D] = (1,) # GL_HISTOGRAM_SINK +_m[0x802D] = (1,) # GL_HISTOGRAM_SINK_EXT +_m[0x8026] = (1,) # GL_HISTOGRAM_WIDTH +_m[0x8026] = (1,) # GL_HISTOGRAM_WIDTH_EXT +_m[0x8714] = (1,) # GL_HI_BIAS_NV +_m[0x870E] = (1,) # GL_HI_SCALE_NV +_m[0x82A8] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_IMAGE_COMPATIBILITY_CLASS +_m[0x90C7] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_IMAGE_FORMAT_COMPATIBILITY_TYPE +_m[0x82A9] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_IMAGE_PIXEL_FORMAT +_m[0x82AA] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_IMAGE_PIXEL_TYPE +_m[0x82A7] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_IMAGE_TEXEL_SIZE +_m[0x8B9B] = (1,) # GL_IMPLEMENTATION_COLOR_READ_FORMAT +_m[0x8B9A] = (1,) # GL_IMPLEMENTATION_COLOR_READ_TYPE +_m[0x8077] = (1,) # GL_INDEX_ARRAY +_m[0x8899] = (1,) # GL_INDEX_ARRAY_BUFFER_BINDING +_m[0x8899] = (1,) # GL_INDEX_ARRAY_BUFFER_BINDING_ARB +_m[0x8087] = (1,) # GL_INDEX_ARRAY_COUNT_EXT +_m[0x8077] = (1,) # GL_INDEX_ARRAY_EXT +_m[0x8F2E] = (1,) # GL_INDEX_ARRAY_LENGTH_NV +_m[0x8091] = (1,) # GL_INDEX_ARRAY_POINTER +_m[0x8086] = (1,) # GL_INDEX_ARRAY_STRIDE +_m[0x8086] = (1,) # GL_INDEX_ARRAY_STRIDE_EXT +_m[0x8085] = (1,) # GL_INDEX_ARRAY_TYPE +_m[0x8085] = (1,) # GL_INDEX_ARRAY_TYPE_EXT +_m[0x0D51] = (1,) # GL_INDEX_BITS +_m[0x0C20] = (1,) # GL_INDEX_CLEAR_VALUE +_m[0x0BF1] = (1,) # GL_INDEX_LOGIC_OP +_m[0x0C30] = (1,) # GL_INDEX_MODE +_m[0x0D13] = (1,) # GL_INDEX_OFFSET +_m[0x0D12] = (1,) # GL_INDEX_SHIFT +_m[0x0C21] = (1,) # GL_INDEX_WRITEMASK +_m[0x8B84] = (1,) # GL_INFO_LOG_LENGTH +_m[0x8181] = (1,) # GL_INSTRUMENT_MEASUREMENTS_SGIX +_m[0x8980] = (1,) # GL_INTERLACE_OML +_m[0x8568] = (1,) # GL_INTERLACE_READ_INGR +_m[0x8981] = (1,) # GL_INTERLACE_READ_OML +_m[0x8094] = (1,) # GL_INTERLACE_SGIX +_m[0x8274] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_INTERNALFORMAT_ALPHA_SIZE +_m[0x827B] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_INTERNALFORMAT_ALPHA_TYPE +_m[0x8273] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_INTERNALFORMAT_BLUE_SIZE +_m[0x827A] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_INTERNALFORMAT_BLUE_TYPE +_m[0x8275] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_INTERNALFORMAT_DEPTH_SIZE +_m[0x827C] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_INTERNALFORMAT_DEPTH_TYPE +_m[0x8272] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_INTERNALFORMAT_GREEN_SIZE +_m[0x8279] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_INTERNALFORMAT_GREEN_TYPE +_m[0x8270] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_INTERNALFORMAT_PREFERRED +_m[0x8271] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_INTERNALFORMAT_RED_SIZE +_m[0x8278] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_INTERNALFORMAT_RED_TYPE +_m[0x8277] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_INTERNALFORMAT_SHARED_SIZE +_m[0x8276] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_INTERNALFORMAT_STENCIL_SIZE +_m[0x827D] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_INTERNALFORMAT_STENCIL_TYPE +_m[0x826F] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_INTERNALFORMAT_SUPPORTED +_m[0x817F] = (1,) # GL_IR_INSTRUMENT1_SGIX +_m[0x92E7] = (1,) # GL_IS_PER_PATCH +_m[0x9300] = (1,) # GL_IS_ROW_MAJOR +_m[0x825E] = (1,) # GL_LAYER_PROVOKING_VERTEX +_m[0x4000] = (1,) # GL_LIGHT0 +_m[0x4001] = (1,) # GL_LIGHT1 +_m[0x4002] = (1,) # GL_LIGHT2 +_m[0x4003] = (1,) # GL_LIGHT3 +_m[0x4004] = (1,) # GL_LIGHT4 +_m[0x4005] = (1,) # GL_LIGHT5 +_m[0x4006] = (1,) # GL_LIGHT6 +_m[0x4007] = (1,) # GL_LIGHT7 +_m[0x0B50] = (1,) # GL_LIGHTING +_m[0x8407] = (1,) # GL_LIGHT_ENV_MODE_SGIX +_m[0x0B53] = (4,) # GL_LIGHT_MODEL_AMBIENT +_m[0x81F8] = (1,) # GL_LIGHT_MODEL_COLOR_CONTROL +_m[0x81F8] = (1,) # GL_LIGHT_MODEL_COLOR_CONTROL_EXT +_m[0x0B51] = (1,) # GL_LIGHT_MODEL_LOCAL_VIEWER +_m[0x0B52] = (1,) # GL_LIGHT_MODEL_TWO_SIDE +_m[0x1208] = (1,) # GL_LINEAR_ATTENUATION +_m[0x1B01] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_polygon_mode.txt # GL_LINE_NV +_m[0x0B20] = (1,) # GL_LINE_SMOOTH +_m[0x0C52] = (1,) # GL_LINE_SMOOTH_HINT +_m[0x0B24] = (1,) # GL_LINE_STIPPLE +_m[0x0B25] = (1,) # GL_LINE_STIPPLE_PATTERN +_m[0x0B26] = (1,) # GL_LINE_STIPPLE_REPEAT +_m[0x0B21] = (1,) # GL_LINE_WIDTH +_m[0x0B23] = (1,) # GL_LINE_WIDTH_GRANULARITY +_m[0x0B22] = (2,) # GL_LINE_WIDTH_RANGE +_m[0x8B82] = (1,) # GL_LINK_STATUS +_m[0x0B32] = (1,) # GL_LIST_BASE +_m[0x0B33] = (1,) # GL_LIST_INDEX +_m[0x0B30] = (1,) # GL_LIST_MODE +_m[0x930E] = (1,) # GL_LOCATION +_m[0x930F] = (1,) # GL_LOCATION_INDEX +_m[0x0BF1] = (1,) # GL_LOGIC_OP +_m[0x0BF0] = (1,) # GL_LOGIC_OP_MODE +_m[0x8252] = (1,)#TODO Review http://www.opengl.org/registry/specs//KHR/robustness.txt # GL_LOSE_CONTEXT_ON_RESET +_m[0x8252] = (1,) # GL_LOSE_CONTEXT_ON_RESET_ARB +_m[0x8715] = (1,) # GL_LO_BIAS_NV +_m[0x870F] = (1,) # GL_LO_SCALE_NV +_m[0x8718] = (1,) # GL_MAGNITUDE_BIAS_NV +_m[0x8712] = (1,) # GL_MAGNITUDE_SCALE_NV +_m[0x821B] = (1,) # GL_MAJOR_VERSION +_m[0x8294] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_MANUAL_GENERATE_MIPMAP +_m[0x0D90] = (1,) # GL_MAP1_COLOR_4 +_m[0x0DD0] = (2,) # GL_MAP1_GRID_DOMAIN +_m[0x0DD1] = (1,) # GL_MAP1_GRID_SEGMENTS +_m[0x0D91] = (1,) # GL_MAP1_INDEX +_m[0x0D92] = (1,) # GL_MAP1_NORMAL +_m[0x0D93] = (1,) # GL_MAP1_TEXTURE_COORD_1 +_m[0x0D94] = (1,) # GL_MAP1_TEXTURE_COORD_2 +_m[0x0D95] = (1,) # GL_MAP1_TEXTURE_COORD_3 +_m[0x0D96] = (1,) # GL_MAP1_TEXTURE_COORD_4 +_m[0x0D97] = (1,) # GL_MAP1_VERTEX_3 +_m[0x0D98] = (1,) # GL_MAP1_VERTEX_4 +_m[0x8660] = (4,) # GL_MAP1_VERTEX_ATTRIB0_4_NV +_m[0x866A] = (4,) # GL_MAP1_VERTEX_ATTRIB10_4_NV +_m[0x866B] = (4,) # GL_MAP1_VERTEX_ATTRIB11_4_NV +_m[0x866C] = (4,) # GL_MAP1_VERTEX_ATTRIB12_4_NV +_m[0x866D] = (4,) # GL_MAP1_VERTEX_ATTRIB13_4_NV +_m[0x866E] = (4,) # GL_MAP1_VERTEX_ATTRIB14_4_NV +_m[0x866F] = (4,) # GL_MAP1_VERTEX_ATTRIB15_4_NV +_m[0x8661] = (4,) # GL_MAP1_VERTEX_ATTRIB1_4_NV +_m[0x8662] = (4,) # GL_MAP1_VERTEX_ATTRIB2_4_NV +_m[0x8663] = (4,) # GL_MAP1_VERTEX_ATTRIB3_4_NV +_m[0x8664] = (4,) # GL_MAP1_VERTEX_ATTRIB4_4_NV +_m[0x8665] = (4,) # GL_MAP1_VERTEX_ATTRIB5_4_NV +_m[0x8666] = (4,) # GL_MAP1_VERTEX_ATTRIB6_4_NV +_m[0x8667] = (4,) # GL_MAP1_VERTEX_ATTRIB7_4_NV +_m[0x8668] = (4,) # GL_MAP1_VERTEX_ATTRIB8_4_NV +_m[0x8669] = (4,) # GL_MAP1_VERTEX_ATTRIB9_4_NV +_m[0x0DB0] = (1,) # GL_MAP2_COLOR_4 +_m[0x0DD2] = (4,) # GL_MAP2_GRID_DOMAIN +_m[0x0DD3] = (2,) # GL_MAP2_GRID_SEGMENTS +_m[0x0DB1] = (1,) # GL_MAP2_INDEX +_m[0x0DB2] = (1,) # GL_MAP2_NORMAL +_m[0x0DB3] = (1,) # GL_MAP2_TEXTURE_COORD_1 +_m[0x0DB4] = (1,) # GL_MAP2_TEXTURE_COORD_2 +_m[0x0DB5] = (1,) # GL_MAP2_TEXTURE_COORD_3 +_m[0x0DB6] = (1,) # GL_MAP2_TEXTURE_COORD_4 +_m[0x0DB7] = (1,) # GL_MAP2_VERTEX_3 +_m[0x0DB8] = (1,) # GL_MAP2_VERTEX_4 +_m[0x8670] = (4,) # GL_MAP2_VERTEX_ATTRIB0_4_NV +_m[0x867A] = (4,) # GL_MAP2_VERTEX_ATTRIB10_4_NV +_m[0x867B] = (4,) # GL_MAP2_VERTEX_ATTRIB11_4_NV +_m[0x867C] = (4,) # GL_MAP2_VERTEX_ATTRIB12_4_NV +_m[0x867D] = (4,) # GL_MAP2_VERTEX_ATTRIB13_4_NV +_m[0x867E] = (4,) # GL_MAP2_VERTEX_ATTRIB14_4_NV +_m[0x867F] = (4,) # GL_MAP2_VERTEX_ATTRIB15_4_NV +_m[0x8671] = (4,) # GL_MAP2_VERTEX_ATTRIB1_4_NV +_m[0x8672] = (4,) # GL_MAP2_VERTEX_ATTRIB2_4_NV +_m[0x8673] = (4,) # GL_MAP2_VERTEX_ATTRIB3_4_NV +_m[0x8674] = (4,) # GL_MAP2_VERTEX_ATTRIB4_4_NV +_m[0x8675] = (4,) # GL_MAP2_VERTEX_ATTRIB5_4_NV +_m[0x8676] = (4,) # GL_MAP2_VERTEX_ATTRIB6_4_NV +_m[0x8677] = (4,) # GL_MAP2_VERTEX_ATTRIB7_4_NV +_m[0x8678] = (4,) # GL_MAP2_VERTEX_ATTRIB8_4_NV +_m[0x8679] = (4,) # GL_MAP2_VERTEX_ATTRIB9_4_NV +_m[0x86C3] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/evaluators.txt # GL_MAP_ATTRIB_U_ORDER_NV +_m[0x86C4] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/evaluators.txt # GL_MAP_ATTRIB_V_ORDER_NV +_m[0x0D10] = (1,) # GL_MAP_COLOR +_m[0x0D11] = (1,) # GL_MAP_STENCIL +_m[0x8844] = (1,) # GL_MATRIX_INDEX_ARRAY_ARB +_m[0x8B9E] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/OES/OES_matrix_palette.txt # GL_MATRIX_INDEX_ARRAY_BUFFER_BINDING_OES +_m[0x8849] = (1,) # GL_MATRIX_INDEX_ARRAY_POINTER_ARB +_m[0x8849] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/OES/OES_matrix_palette.txt # GL_MATRIX_INDEX_ARRAY_POINTER_OES +_m[0x8846] = (1,) # GL_MATRIX_INDEX_ARRAY_SIZE_ARB +_m[0x8846] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/OES/OES_matrix_palette.txt # GL_MATRIX_INDEX_ARRAY_SIZE_OES +_m[0x8848] = (1,) # GL_MATRIX_INDEX_ARRAY_STRIDE_ARB +_m[0x8848] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/OES/OES_matrix_palette.txt # GL_MATRIX_INDEX_ARRAY_STRIDE_OES +_m[0x8847] = (1,) # GL_MATRIX_INDEX_ARRAY_TYPE_ARB +_m[0x8847] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/OES/OES_matrix_palette.txt # GL_MATRIX_INDEX_ARRAY_TYPE_OES +_m[0x0BA0] = (1,) # GL_MATRIX_MODE +_m[0x8840] = (1,) # GL_MATRIX_PALETTE_ARB +_m[0x92FF] = (1,) # GL_MATRIX_STRIDE +_m[0x8073] = (1,) # GL_MAX_3D_TEXTURE_SIZE +_m[0x8073] = (1,) # GL_MAX_3D_TEXTURE_SIZE_EXT +_m[0x8138] = (1,) # GL_MAX_4D_TEXTURE_SIZE_SGIS +_m[0x8405] = (1,) # GL_MAX_ACTIVE_LIGHTS_SGIX +_m[0x88FF] = (1,) # GL_MAX_ARRAY_TEXTURE_LAYERS +_m[0x88FF] = (1,) # GL_MAX_ARRAY_TEXTURE_LAYERS_EXT +_m[0x8360] = (1,) # GL_MAX_ASYNC_DRAW_PIXELS_SGIX +_m[0x832D] = (1,) # GL_MAX_ASYNC_HISTOGRAM_SGIX +_m[0x8361] = (1,) # GL_MAX_ASYNC_READ_PIXELS_SGIX +_m[0x835F] = (1,) # GL_MAX_ASYNC_TEX_IMAGE_SGIX +_m[0x92DC] = (1,) # GL_MAX_ATOMIC_COUNTER_BUFFER_BINDINGS +_m[0x92D8] = (1,) # GL_MAX_ATOMIC_COUNTER_BUFFER_SIZE +_m[0x0D35] = (1,) # GL_MAX_ATTRIB_STACK_DEPTH +_m[0x8DED] = (1,) # GL_MAX_BINDABLE_UNIFORM_SIZE_EXT +_m[0x0D3B] = (1,) # GL_MAX_CLIENT_ATTRIB_STACK_DEPTH +_m[0x8177] = (1,) # GL_MAX_CLIPMAP_DEPTH_SGIX +_m[0x8178] = (1,) # GL_MAX_CLIPMAP_VIRTUAL_DEPTH_SGIX +_m[0x0D32] = (1,) # GL_MAX_CLIP_DISTANCES +_m[0x0D32] = (1,) # GL_MAX_CLIP_PLANES +_m[0x955F] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_shading_rate_image.txt # GL_MAX_COARSE_FRAGMENT_SAMPLES_NV +_m[0x8CDF] = (1,) # GL_MAX_COLOR_ATTACHMENTS +_m[0x8CDF] = (1,) # GL_MAX_COLOR_ATTACHMENTS_EXT +_m[0x91B3] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/AMD/AMD_framebuffer_multisample_advanced.txt # GL_MAX_COLOR_FRAMEBUFFER_SAMPLES_AMD +_m[0x91B4] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/AMD/AMD_framebuffer_multisample_advanced.txt # GL_MAX_COLOR_FRAMEBUFFER_STORAGE_SAMPLES_AMD +_m[0x80B3] = (1,) # GL_MAX_COLOR_MATRIX_STACK_DEPTH +_m[0x80B3] = (1,) # GL_MAX_COLOR_MATRIX_STACK_DEPTH_SGI +_m[0x910E] = (1,) # GL_MAX_COLOR_TEXTURE_SAMPLES +_m[0x92D7] = (1,) # GL_MAX_COMBINED_ATOMIC_COUNTERS +_m[0x92D1] = (1,) # GL_MAX_COMBINED_ATOMIC_COUNTER_BUFFERS +_m[0x82FA] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/cull_distance.txt # GL_MAX_COMBINED_CLIP_AND_CULL_DISTANCES +_m[0x8266] = (1,) # GL_MAX_COMBINED_COMPUTE_UNIFORM_COMPONENTS +_m[0x8282] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_MAX_COMBINED_DIMENSIONS +_m[0x8A33] = (1,) # GL_MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS +_m[0x8A32] = (1,) # GL_MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS +_m[0x90CF] = (1,) # GL_MAX_COMBINED_IMAGE_UNIFORMS +_m[0x8F39] = (1,) # GL_MAX_COMBINED_IMAGE_UNITS_AND_FRAGMENT_OUTPUTS +_m[0x8F39] = (1,) # GL_MAX_COMBINED_IMAGE_UNITS_AND_FRAGMENT_OUTPUTS_EXT +_m[0x8E67] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_MAX_COMBINED_MESH_UNIFORM_COMPONENTS_NV +_m[0x90DC] = (1,) # GL_MAX_COMBINED_SHADER_STORAGE_BLOCKS +_m[0x8E6F] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_MAX_COMBINED_TASK_UNIFORM_COMPONENTS_NV +_m[0x8E1E] = (1,) # GL_MAX_COMBINED_TESS_CONTROL_UNIFORM_COMPONENTS +_m[0x8E1F] = (1,) # GL_MAX_COMBINED_TESS_EVALUATION_UNIFORM_COMPONENTS +_m[0x8B4D] = (1,) # GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS +_m[0x8B4D] = (1,) # GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB +_m[0x8A2E] = (1,) # GL_MAX_COMBINED_UNIFORM_BLOCKS +_m[0x8A31] = (1,) # GL_MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS +_m[0x8265] = (1,) # GL_MAX_COMPUTE_ATOMIC_COUNTERS +_m[0x8264] = (1,) # GL_MAX_COMPUTE_ATOMIC_COUNTER_BUFFERS +_m[0x91BD] = (1,) # GL_MAX_COMPUTE_IMAGE_UNIFORMS +_m[0x90DB] = (1,) # GL_MAX_COMPUTE_SHADER_STORAGE_BLOCKS +_m[0x8262] = (1,) # GL_MAX_COMPUTE_SHARED_MEMORY_SIZE +_m[0x91BC] = (1,) # GL_MAX_COMPUTE_TEXTURE_IMAGE_UNITS +_m[0x91BB] = (1,) # GL_MAX_COMPUTE_UNIFORM_BLOCKS +_m[0x8263] = (1,) # GL_MAX_COMPUTE_UNIFORM_COMPONENTS +_m[0x9344] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/compute_variable_group_size.txt # GL_MAX_COMPUTE_VARIABLE_GROUP_INVOCATIONS_ARB +_m[0x9345] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/compute_variable_group_size.txt # GL_MAX_COMPUTE_VARIABLE_GROUP_SIZE_ARB +_m[0x91BE] = (3,) # GL_MAX_COMPUTE_WORK_GROUP_COUNT +_m[0x90EB] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/compute_shader.txt # GL_MAX_COMPUTE_WORK_GROUP_INVOCATIONS +_m[0x91BF] = (3,) # GL_MAX_COMPUTE_WORK_GROUP_SIZE +_m[0x801B] = (1,) # GL_MAX_CONVOLUTION_HEIGHT +_m[0x801A] = (1,) # GL_MAX_CONVOLUTION_WIDTH +_m[0x851C] = (1,) # GL_MAX_CUBE_MAP_TEXTURE_SIZE +_m[0x851C] = (1,) # GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB +_m[0x82F9] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/cull_distance.txt # GL_MAX_CULL_DISTANCES +_m[0x826C] = (1,) # GL_MAX_DEBUG_GROUP_STACK_DEPTH +_m[0x9144] = (1,) # GL_MAX_DEBUG_LOGGED_MESSAGES +_m[0x9144] = (1,) # GL_MAX_DEBUG_LOGGED_MESSAGES_AMD +_m[0x9144] = (1,) # GL_MAX_DEBUG_LOGGED_MESSAGES_ARB +_m[0x9143] = (1,) # GL_MAX_DEBUG_MESSAGE_LENGTH +_m[0x9143] = (1,) # GL_MAX_DEBUG_MESSAGE_LENGTH_AMD +_m[0x9143] = (1,) # GL_MAX_DEBUG_MESSAGE_LENGTH_ARB +_m[0x90D1] = (1,) # GL_MAX_DEEP_3D_TEXTURE_DEPTH_NV +_m[0x90D0] = (2,) # GL_MAX_DEEP_3D_TEXTURE_WIDTH_HEIGHT_NV +_m[0x8280] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_MAX_DEPTH +_m[0x91B5] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/AMD/AMD_framebuffer_multisample_advanced.txt # GL_MAX_DEPTH_STENCIL_FRAMEBUFFER_SAMPLES_AMD +_m[0x910F] = (1,) # GL_MAX_DEPTH_TEXTURE_SAMPLES +_m[0x8824] = (1,) # GL_MAX_DRAW_BUFFERS +_m[0x8824] = (1,) # GL_MAX_DRAW_BUFFERS_ARB +_m[0x8824] = (1,) # GL_MAX_DRAW_BUFFERS_ATI +_m[0x953D] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_MAX_DRAW_MESH_TASKS_COUNT_NV +_m[0x88FC] = (1,) # GL_MAX_DUAL_SOURCE_DRAW_BUFFERS +_m[0x80E9] = (1,) # GL_MAX_ELEMENTS_INDICES +_m[0x80E8] = (1,) # GL_MAX_ELEMENTS_VERTICES +_m[0x8D6B] = (1,) # GL_MAX_ELEMENT_INDEX +_m[0x0D30] = (1,) # GL_MAX_EVAL_ORDER +_m[0x812C] = (1,) # GL_MAX_FOG_FUNC_POINTS_SGIS +_m[0x92D6] = (1,) # GL_MAX_FRAGMENT_ATOMIC_COUNTERS +_m[0x92D0] = (1,) # GL_MAX_FRAGMENT_ATOMIC_COUNTER_BUFFERS +_m[0x8DE3] = (1,) # GL_MAX_FRAGMENT_BINDABLE_UNIFORMS_EXT +_m[0x90CE] = (1,) # GL_MAX_FRAGMENT_IMAGE_UNIFORMS +_m[0x9125] = (1,) # GL_MAX_FRAGMENT_INPUT_COMPONENTS +_m[0x8E5C] = (1,) # GL_MAX_FRAGMENT_INTERPOLATION_OFFSET +_m[0x8E5C] = (1,) # GL_MAX_FRAGMENT_INTERPOLATION_OFFSET_NV +_m[0x8404] = (1,) # GL_MAX_FRAGMENT_LIGHTS_SGIX +_m[0x8868] = (1,) # GL_MAX_FRAGMENT_PROGRAM_LOCAL_PARAMETERS_NV +_m[0x90DA] = (1,) # GL_MAX_FRAGMENT_SHADER_STORAGE_BLOCKS +_m[0x8A2D] = (1,) # GL_MAX_FRAGMENT_UNIFORM_BLOCKS +_m[0x8B49] = (1,) # GL_MAX_FRAGMENT_UNIFORM_COMPONENTS +_m[0x8B49] = (1,) # GL_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB +_m[0x8DFD] = (1,) # GL_MAX_FRAGMENT_UNIFORM_VECTORS +_m[0x9316] = (1,) # GL_MAX_FRAMEBUFFER_HEIGHT +_m[0x9317] = (1,) # GL_MAX_FRAMEBUFFER_LAYERS +_m[0x9318] = (1,) # GL_MAX_FRAMEBUFFER_SAMPLES +_m[0x9315] = (1,) # GL_MAX_FRAMEBUFFER_WIDTH +_m[0x818D] = (1,) # GL_MAX_FRAMEZOOM_FACTOR_SGIX +_m[0x854D] = (1,) # GL_MAX_GENERAL_COMBINERS_NV +_m[0x92D5] = (1,) # GL_MAX_GEOMETRY_ATOMIC_COUNTERS +_m[0x92CF] = (1,) # GL_MAX_GEOMETRY_ATOMIC_COUNTER_BUFFERS +_m[0x8DE4] = (1,) # GL_MAX_GEOMETRY_BINDABLE_UNIFORMS_EXT +_m[0x90CD] = (1,) # GL_MAX_GEOMETRY_IMAGE_UNIFORMS +_m[0x9123] = (1,) # GL_MAX_GEOMETRY_INPUT_COMPONENTS +_m[0x9124] = (1,) # GL_MAX_GEOMETRY_OUTPUT_COMPONENTS +_m[0x8DE0] = (1,) # GL_MAX_GEOMETRY_OUTPUT_VERTICES +_m[0x8DE0] = (1,) # GL_MAX_GEOMETRY_OUTPUT_VERTICES_ARB +_m[0x8DE0] = (1,) # GL_MAX_GEOMETRY_OUTPUT_VERTICES_EXT +_m[0x8E5A] = (1,) # GL_MAX_GEOMETRY_PROGRAM_INVOCATIONS_NV +_m[0x8E5A] = (1,) # GL_MAX_GEOMETRY_SHADER_INVOCATIONS +_m[0x90D7] = (1,) # GL_MAX_GEOMETRY_SHADER_STORAGE_BLOCKS +_m[0x8C29] = (1,) # GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS +_m[0x8C29] = (1,) # GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_ARB +_m[0x8C29] = (1,) # GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_EXT +_m[0x8DE1] = (1,) # GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS +_m[0x8DE1] = (1,) # GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS_ARB +_m[0x8DE1] = (1,) # GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS_EXT +_m[0x8A2C] = (1,) # GL_MAX_GEOMETRY_UNIFORM_BLOCKS +_m[0x8DDF] = (1,) # GL_MAX_GEOMETRY_UNIFORM_COMPONENTS +_m[0x8DDF] = (1,) # GL_MAX_GEOMETRY_UNIFORM_COMPONENTS_ARB +_m[0x8DDF] = (1,) # GL_MAX_GEOMETRY_UNIFORM_COMPONENTS_EXT +_m[0x8DDD] = (1,) # GL_MAX_GEOMETRY_VARYING_COMPONENTS_ARB +_m[0x8DDD] = (1,) # GL_MAX_GEOMETRY_VARYING_COMPONENTS_EXT +_m[0x827F] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_MAX_HEIGHT +_m[0x906D] = (1,) # GL_MAX_IMAGE_SAMPLES +_m[0x906D] = (1,) # GL_MAX_IMAGE_SAMPLES_EXT +_m[0x8F38] = (1,) # GL_MAX_IMAGE_UNITS +_m[0x8F38] = (1,) # GL_MAX_IMAGE_UNITS_EXT +_m[0x9110] = (1,) # GL_MAX_INTEGER_SAMPLES +_m[0x82E8] = (1,) # GL_MAX_LABEL_LENGTH +_m[0x8281] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_MAX_LAYERS +_m[0x92BA] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NVX/NVX_linked_gpu_multicast.txt # GL_MAX_LGPU_GPUS_NVX +_m[0x0D31] = (1,) # GL_MAX_LIGHTS +_m[0x0B31] = (1,) # GL_MAX_LIST_NESTING +_m[0x86D6] = (1,) # GL_MAX_MAP_TESSELLATION_NV +_m[0x8841] = (1,) # GL_MAX_MATRIX_PALETTE_STACK_DEPTH_ARB +_m[0x8E65] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_MAX_MESH_ATOMIC_COUNTERS_NV +_m[0x8E64] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_MAX_MESH_ATOMIC_COUNTER_BUFFERS_NV +_m[0x8E62] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_MAX_MESH_IMAGE_UNIFORMS_NV +_m[0x9539] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_MAX_MESH_OUTPUT_PRIMITIVES_NV +_m[0x9538] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_MAX_MESH_OUTPUT_VERTICES_NV +_m[0x8E66] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_MAX_MESH_SHADER_STORAGE_BLOCKS_NV +_m[0x8E61] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_MAX_MESH_TEXTURE_IMAGE_UNITS_NV +_m[0x9536] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_MAX_MESH_TOTAL_MEMORY_SIZE_NV +_m[0x8E60] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_MAX_MESH_UNIFORM_BLOCKS_NV +_m[0x8E63] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_MAX_MESH_UNIFORM_COMPONENTS_NV +_m[0x9557] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_MAX_MESH_VIEWS_NV +_m[0x95A2] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_MAX_MESH_WORK_GROUP_INVOCATIONS_NV +_m[0x953B] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_MAX_MESH_WORK_GROUP_SIZE_NV +_m[0x0D36] = (1,) # GL_MAX_MODELVIEW_STACK_DEPTH +_m[0x8E11] = (1,) # GL_MAX_MULTISAMPLE_COVERAGE_MODES_NV +_m[0x92F6] = (1,) # GL_MAX_NAME_LENGTH +_m[0x0D37] = (1,) # GL_MAX_NAME_STACK_DEPTH +_m[0x92F7] = (1,) # GL_MAX_NUM_ACTIVE_VARIABLES +_m[0x92F8] = (1,) # GL_MAX_NUM_COMPATIBLE_SUBROUTINES +_m[0x87CA] = (1,) # GL_MAX_OPTIMIZED_VERTEX_SHADER_INSTRUCTIONS_EXT +_m[0x87CE] = (1,) # GL_MAX_OPTIMIZED_VERTEX_SHADER_LOCALS_EXT +_m[0x87CC] = (1,) # GL_MAX_OPTIMIZED_VERTEX_SHADER_LOCAL_CONSTANTS_EXT +_m[0x87CB] = (1,) # GL_MAX_OPTIMIZED_VERTEX_SHADER_VARIANTS_EXT +_m[0x8842] = (1,) # GL_MAX_PALETTE_MATRICES_ARB +_m[0x8842] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/OES/OES_matrix_palette.txt # GL_MAX_PALETTE_MATRICES_OES +_m[0x8E7D] = (1,) # GL_MAX_PATCH_VERTICES +_m[0x0D34] = (1,) # GL_MAX_PIXEL_MAP_TABLE +_m[0x8337] = (1,) # GL_MAX_PIXEL_TRANSFORM_2D_STACK_DEPTH_EXT +_m[0x87F1] = (1,) # GL_MAX_PN_TRIANGLES_TESSELATION_LEVEL_ATI +_m[0x88B1] = (1,) # GL_MAX_PROGRAM_ADDRESS_REGISTERS_ARB +_m[0x880B] = (1,) # GL_MAX_PROGRAM_ALU_INSTRUCTIONS_ARB +_m[0x88AD] = (1,) # GL_MAX_PROGRAM_ATTRIBS_ARB +_m[0x8908] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/gpu_program4.txt # GL_MAX_PROGRAM_ATTRIB_COMPONENTS_NV +_m[0x88F5] = (1,) # GL_MAX_PROGRAM_CALL_DEPTH_NV +_m[0x88B5] = (1,) # GL_MAX_PROGRAM_ENV_PARAMETERS_ARB +_m[0x88F4] = (1,) # GL_MAX_PROGRAM_EXEC_INSTRUCTIONS_NV +_m[0x8DA5] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/gpu_program4.txt # GL_MAX_PROGRAM_GENERIC_ATTRIBS_NV +_m[0x8DA6] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/gpu_program4.txt # GL_MAX_PROGRAM_GENERIC_RESULTS_NV +_m[0x88F6] = (1,) # GL_MAX_PROGRAM_IF_DEPTH_NV +_m[0x88A1] = (1,) # GL_MAX_PROGRAM_INSTRUCTIONS_ARB +_m[0x88B4] = (1,) # GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB +_m[0x88F8] = (1,) # GL_MAX_PROGRAM_LOOP_COUNT_NV +_m[0x88F7] = (1,) # GL_MAX_PROGRAM_LOOP_DEPTH_NV +_m[0x862F] = (1,) # GL_MAX_PROGRAM_MATRICES_ARB +_m[0x862E] = (1,) # GL_MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB +_m[0x88B3] = (1,) # GL_MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB +_m[0x880E] = (1,) # GL_MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB +_m[0x88AF] = (1,) # GL_MAX_PROGRAM_NATIVE_ATTRIBS_ARB +_m[0x88A3] = (1,) # GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB +_m[0x88AB] = (1,) # GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB +_m[0x88A7] = (1,) # GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB +_m[0x8810] = (1,) # GL_MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB +_m[0x880F] = (1,) # GL_MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB +_m[0x8C27] = (1,) # GL_MAX_PROGRAM_OUTPUT_VERTICES_NV +_m[0x88A9] = (1,) # GL_MAX_PROGRAM_PARAMETERS_ARB +_m[0x8DA0] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/parameter_buffer_object.txt # GL_MAX_PROGRAM_PARAMETER_BUFFER_BINDINGS_NV +_m[0x8DA1] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/parameter_buffer_object.txt # GL_MAX_PROGRAM_PARAMETER_BUFFER_SIZE_NV +_m[0x86D8] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/tessellation_program5.txt # GL_MAX_PROGRAM_PATCH_ATTRIBS_NV +_m[0x8909] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/gpu_program4.txt # GL_MAX_PROGRAM_RESULT_COMPONENTS_NV +_m[0x88A5] = (1,) # GL_MAX_PROGRAM_TEMPORARIES_ARB +_m[0x8905] = (1,) # GL_MAX_PROGRAM_TEXEL_OFFSET +_m[0x8F9F] = (1,) # GL_MAX_PROGRAM_TEXTURE_GATHER_COMPONENTS_ARB +_m[0x8E5F] = (1,) # GL_MAX_PROGRAM_TEXTURE_GATHER_OFFSET_ARB +_m[0x8E5F] = (1,) # GL_MAX_PROGRAM_TEXTURE_GATHER_OFFSET_NV +_m[0x880D] = (1,) # GL_MAX_PROGRAM_TEX_INDIRECTIONS_ARB +_m[0x880C] = (1,) # GL_MAX_PROGRAM_TEX_INSTRUCTIONS_ARB +_m[0x8C28] = (1,) # GL_MAX_PROGRAM_TOTAL_OUTPUT_COMPONENTS_NV +_m[0x0D38] = (1,) # GL_MAX_PROJECTION_STACK_DEPTH +_m[0x9329] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_framebuffer_mixed_samples.txt # GL_MAX_RASTER_SAMPLES_EXT +_m[0x86D7] = (1,) # GL_MAX_RATIONAL_EVAL_ORDER_NV +_m[0x84F8] = (1,) # GL_MAX_RECTANGLE_TEXTURE_SIZE +_m[0x84F8] = (1,) # GL_MAX_RECTANGLE_TEXTURE_SIZE_ARB +_m[0x84F8] = (1,) # GL_MAX_RECTANGLE_TEXTURE_SIZE_NV +_m[0x84E8] = (1,) # GL_MAX_RENDERBUFFER_SIZE +_m[0x84E8] = (1,) # GL_MAX_RENDERBUFFER_SIZE_EXT +_m[0x8D57] = (1,) # GL_MAX_SAMPLES +_m[0x8D57] = (1,) # GL_MAX_SAMPLES_EXT +_m[0x9135] = (1,) # GL_MAX_SAMPLES_IMG +_m[0x8E59] = (1,) # GL_MAX_SAMPLE_MASK_WORDS +_m[0x8E59] = (1,) # GL_MAX_SAMPLE_MASK_WORDS_NV +_m[0x9111] = (1,) # GL_MAX_SERVER_WAIT_TIMEOUT +_m[0x9650] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/EXT/EXT_shader_pixel_local_storage2.txt # GL_MAX_SHADER_COMBINED_LOCAL_STORAGE_FAST_SIZE_EXT +_m[0x9651] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/EXT/EXT_shader_pixel_local_storage2.txt # GL_MAX_SHADER_COMBINED_LOCAL_STORAGE_SIZE_EXT +_m[0x91B0] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/ARB/ARB_parallel_shader_compile.txt # GL_MAX_SHADER_COMPILER_THREADS_ARB +_m[0x91B0] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/KHR/KHR_parallel_shader_compile.txt # GL_MAX_SHADER_COMPILER_THREADS_KHR +_m[0x8F63] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/EXT/EXT_shader_pixel_local_storage.txt # GL_MAX_SHADER_PIXEL_LOCAL_STORAGE_FAST_SIZE_EXT +_m[0x8F67] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/EXT/EXT_shader_pixel_local_storage.txt # GL_MAX_SHADER_PIXEL_LOCAL_STORAGE_SIZE_EXT +_m[0x90DE] = (1,) # GL_MAX_SHADER_STORAGE_BLOCK_SIZE +_m[0x90DD] = (1,) # GL_MAX_SHADER_STORAGE_BUFFER_BINDINGS +_m[0x8FA1] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/QCOM/QCOM_texture_foveated_subsampled_layout.txt # GL_MAX_SHADER_SUBSAMPLED_IMAGE_UNITS_QCOM +_m[0x8504] = (1,) # GL_MAX_SHININESS_NV +_m[0x9199] = (1,)#TODO Review http://www.opengl.org/registry/specs//AMD/sparse_texture.txt # GL_MAX_SPARSE_3D_TEXTURE_SIZE_AMD +_m[0x9199] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/sparse_texture.txt # GL_MAX_SPARSE_3D_TEXTURE_SIZE_ARB +_m[0x9199] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/EXT/EXT_sparse_texture.txt # GL_MAX_SPARSE_3D_TEXTURE_SIZE_EXT +_m[0x919A] = (1,) # GL_MAX_SPARSE_ARRAY_TEXTURE_LAYERS +_m[0x9198] = (1,)#TODO Review http://www.opengl.org/registry/specs//AMD/sparse_texture.txt # GL_MAX_SPARSE_TEXTURE_SIZE_AMD +_m[0x9198] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/sparse_texture.txt # GL_MAX_SPARSE_TEXTURE_SIZE_ARB +_m[0x9198] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/EXT/EXT_sparse_texture.txt # GL_MAX_SPARSE_TEXTURE_SIZE_EXT +_m[0x8505] = (1,) # GL_MAX_SPOT_EXPONENT_NV +_m[0x9349] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_conservative_raster.txt # GL_MAX_SUBPIXEL_PRECISION_BIAS_BITS_NV +_m[0x8DE7] = (1,) # GL_MAX_SUBROUTINES +_m[0x8DE8] = (1,) # GL_MAX_SUBROUTINE_UNIFORM_LOCATIONS +_m[0x8E6D] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_MAX_TASK_ATOMIC_COUNTERS_NV +_m[0x8E6C] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_MAX_TASK_ATOMIC_COUNTER_BUFFERS_NV +_m[0x8E6A] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_MAX_TASK_IMAGE_UNIFORMS_NV +_m[0x953A] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_MAX_TASK_OUTPUT_COUNT_NV +_m[0x8E6E] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_MAX_TASK_SHADER_STORAGE_BLOCKS_NV +_m[0x8E69] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_MAX_TASK_TEXTURE_IMAGE_UNITS_NV +_m[0x9537] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_MAX_TASK_TOTAL_MEMORY_SIZE_NV +_m[0x8E68] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_MAX_TASK_UNIFORM_BLOCKS_NV +_m[0x8E6B] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_MAX_TASK_UNIFORM_COMPONENTS_NV +_m[0x95A3] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_MAX_TASK_WORK_GROUP_INVOCATIONS_NV +_m[0x953C] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_MAX_TASK_WORK_GROUP_SIZE_NV +_m[0x92D3] = (1,) # GL_MAX_TESS_CONTROL_ATOMIC_COUNTERS +_m[0x92CD] = (1,) # GL_MAX_TESS_CONTROL_ATOMIC_COUNTER_BUFFERS +_m[0x90CB] = (1,) # GL_MAX_TESS_CONTROL_IMAGE_UNIFORMS +_m[0x886C] = (1,) # GL_MAX_TESS_CONTROL_INPUT_COMPONENTS +_m[0x8E83] = (1,) # GL_MAX_TESS_CONTROL_OUTPUT_COMPONENTS +_m[0x90D8] = (1,) # GL_MAX_TESS_CONTROL_SHADER_STORAGE_BLOCKS +_m[0x8E81] = (1,) # GL_MAX_TESS_CONTROL_TEXTURE_IMAGE_UNITS +_m[0x8E85] = (1,) # GL_MAX_TESS_CONTROL_TOTAL_OUTPUT_COMPONENTS +_m[0x8E89] = (1,) # GL_MAX_TESS_CONTROL_UNIFORM_BLOCKS +_m[0x8E7F] = (1,) # GL_MAX_TESS_CONTROL_UNIFORM_COMPONENTS +_m[0x92D4] = (1,) # GL_MAX_TESS_EVALUATION_ATOMIC_COUNTERS +_m[0x92CE] = (1,) # GL_MAX_TESS_EVALUATION_ATOMIC_COUNTER_BUFFERS +_m[0x90CC] = (1,) # GL_MAX_TESS_EVALUATION_IMAGE_UNIFORMS +_m[0x886D] = (1,) # GL_MAX_TESS_EVALUATION_INPUT_COMPONENTS +_m[0x8E86] = (1,) # GL_MAX_TESS_EVALUATION_OUTPUT_COMPONENTS +_m[0x90D9] = (1,) # GL_MAX_TESS_EVALUATION_SHADER_STORAGE_BLOCKS +_m[0x8E82] = (1,) # GL_MAX_TESS_EVALUATION_TEXTURE_IMAGE_UNITS +_m[0x8E8A] = (1,) # GL_MAX_TESS_EVALUATION_UNIFORM_BLOCKS +_m[0x8E80] = (1,) # GL_MAX_TESS_EVALUATION_UNIFORM_COMPONENTS +_m[0x8E7E] = (1,) # GL_MAX_TESS_GEN_LEVEL +_m[0x8E84] = (1,) # GL_MAX_TESS_PATCH_COMPONENTS +_m[0x8C2B] = (1,) # GL_MAX_TEXTURE_BUFFER_SIZE +_m[0x8C2B] = (1,) # GL_MAX_TEXTURE_BUFFER_SIZE_ARB +_m[0x8C2B] = (1,) # GL_MAX_TEXTURE_BUFFER_SIZE_EXT +_m[0x8871] = (1,) # GL_MAX_TEXTURE_COORDS +_m[0x8871] = (1,) # GL_MAX_TEXTURE_COORDS_ARB +_m[0x8871] = (1,) # GL_MAX_TEXTURE_COORDS_NV +_m[0x8872] = (1,) # GL_MAX_TEXTURE_IMAGE_UNITS +_m[0x8872] = (1,) # GL_MAX_TEXTURE_IMAGE_UNITS_ARB +_m[0x8872] = (1,) # GL_MAX_TEXTURE_IMAGE_UNITS_NV +_m[0x84FD] = (1,) # GL_MAX_TEXTURE_LOD_BIAS +_m[0x84FD] = (1,) # GL_MAX_TEXTURE_LOD_BIAS_EXT +_m[0x84FF] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/ARB/ARB_texture_filter_anisotropic.txt # GL_MAX_TEXTURE_MAX_ANISOTROPY +_m[0x84FF] = (1,) # GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT +_m[0x0D33] = (1,) # GL_MAX_TEXTURE_SIZE +_m[0x0D39] = (1,) # GL_MAX_TEXTURE_STACK_DEPTH +_m[0x84E2] = (1,) # GL_MAX_TEXTURE_UNITS +_m[0x84E2] = (1,) # GL_MAX_TEXTURE_UNITS_ARB +_m[0x862F] = (1,) # GL_MAX_TRACK_MATRICES_NV +_m[0x862E] = (1,) # GL_MAX_TRACK_MATRIX_STACK_DEPTH_NV +_m[0x8E70] = (1,) # GL_MAX_TRANSFORM_FEEDBACK_BUFFERS +_m[0x8C8A] = (1,) # GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS +_m[0x8C8B] = (1,) # GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS +_m[0x8C80] = (1,) # GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS +_m[0x8A30] = (1,) # GL_MAX_UNIFORM_BLOCK_SIZE +_m[0x8A2F] = (1,) # GL_MAX_UNIFORM_BUFFER_BINDINGS +_m[0x826E] = (1,) # GL_MAX_UNIFORM_LOCATIONS +_m[0x8B4B] = (1,) # GL_MAX_VARYING_COMPONENTS +_m[0x8B4B] = (1,) # GL_MAX_VARYING_COMPONENTS_EXT +_m[0x8B4B] = (1,) # GL_MAX_VARYING_FLOATS +_m[0x8B4B] = (1,) # GL_MAX_VARYING_FLOATS_ARB +_m[0x8DFC] = (1,) # GL_MAX_VARYING_VECTORS +_m[0x8520] = (1,) # GL_MAX_VERTEX_ARRAY_RANGE_ELEMENT_NV +_m[0x92D2] = (1,) # GL_MAX_VERTEX_ATOMIC_COUNTERS +_m[0x92CC] = (1,) # GL_MAX_VERTEX_ATOMIC_COUNTER_BUFFERS +_m[0x8869] = (1,) # GL_MAX_VERTEX_ATTRIBS +_m[0x8869] = (1,) # GL_MAX_VERTEX_ATTRIBS_ARB +_m[0x82DA] = (1,) # GL_MAX_VERTEX_ATTRIB_BINDINGS +_m[0x82D9] = (1,) # GL_MAX_VERTEX_ATTRIB_RELATIVE_OFFSET +_m[0x8DE2] = (1,) # GL_MAX_VERTEX_BINDABLE_UNIFORMS_EXT +_m[0x90CA] = (1,) # GL_MAX_VERTEX_IMAGE_UNIFORMS +_m[0x9122] = (1,) # GL_MAX_VERTEX_OUTPUT_COMPONENTS +_m[0x87C5] = (1,) # GL_MAX_VERTEX_SHADER_INSTRUCTIONS_EXT +_m[0x87C7] = (1,) # GL_MAX_VERTEX_SHADER_INVARIANTS_EXT +_m[0x87C9] = (1,) # GL_MAX_VERTEX_SHADER_LOCALS_EXT +_m[0x87C8] = (1,) # GL_MAX_VERTEX_SHADER_LOCAL_CONSTANTS_EXT +_m[0x90D6] = (1,) # GL_MAX_VERTEX_SHADER_STORAGE_BLOCKS +_m[0x87C6] = (1,) # GL_MAX_VERTEX_SHADER_VARIANTS_EXT +_m[0x8E71] = (1,) # GL_MAX_VERTEX_STREAMS +_m[0x876B] = (1,) # GL_MAX_VERTEX_STREAMS_ATI +_m[0x8B4C] = (1,) # GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS +_m[0x8B4C] = (1,) # GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB +_m[0x8A2B] = (1,) # GL_MAX_VERTEX_UNIFORM_BLOCKS +_m[0x8B4A] = (1,) # GL_MAX_VERTEX_UNIFORM_COMPONENTS +_m[0x8B4A] = (1,) # GL_MAX_VERTEX_UNIFORM_COMPONENTS_ARB +_m[0x8DFB] = (1,) # GL_MAX_VERTEX_UNIFORM_VECTORS +_m[0x86A4] = (1,) # GL_MAX_VERTEX_UNITS_ARB +_m[0x86A4] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/OES/OES_matrix_palette.txt # GL_MAX_VERTEX_UNITS_OES +_m[0x8DDE] = (1,) # GL_MAX_VERTEX_VARYING_COMPONENTS_ARB +_m[0x8DDE] = (1,) # GL_MAX_VERTEX_VARYING_COMPONENTS_EXT +_m[0x825B] = (1,) # GL_MAX_VIEWPORTS +_m[0x0D3A] = (2,) # GL_MAX_VIEWPORT_DIMS +_m[0x9631] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/OVR/OVR_multiview.txt # GL_MAX_VIEWS_OVR +_m[0x827E] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_MAX_WIDTH +_m[0x8F14] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/EXT/EXT_window_rectangles.txt # GL_MAX_WINDOW_RECTANGLES_EXT +_m[0x9543] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_MESH_OUTPUT_PER_PRIMITIVE_GRANULARITY_NV +_m[0x92DF] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_MESH_OUTPUT_PER_VERTEX_GRANULARITY_NV +_m[0x957B] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_MESH_OUTPUT_TYPE_NV +_m[0x957A] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_MESH_PRIMITIVES_OUT_NV +_m[0x9579] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_MESH_VERTICES_OUT_NV +_m[0x953E] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_MESH_WORK_GROUP_SIZE_NV +_m[0x802E] = (1,) # GL_MINMAX +_m[0x802E] = (1,) # GL_MINMAX_EXT +_m[0x802F] = (1,) # GL_MINMAX_FORMAT +_m[0x802F] = (1,) # GL_MINMAX_FORMAT_EXT +_m[0x8030] = (1,) # GL_MINMAX_SINK +_m[0x8030] = (1,) # GL_MINMAX_SINK_EXT +_m[0x821C] = (1,) # GL_MINOR_VERSION +_m[0x8E5B] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/gpu_shader5.txt # GL_MIN_FRAGMENT_INTERPOLATION_OFFSET +_m[0x8E5B] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/gpu_program5.txt # GL_MIN_FRAGMENT_INTERPOLATION_OFFSET_NV +_m[0x90BC] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/map_buffer_alignment.txt # GL_MIN_MAP_BUFFER_ALIGNMENT +_m[0x8904] = (1,) # GL_MIN_PROGRAM_TEXEL_OFFSET +_m[0x8E5E] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/texture_gather.txt # GL_MIN_PROGRAM_TEXTURE_GATHER_OFFSET_ARB +_m[0x8E5E] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/gpu_program5.txt # GL_MIN_PROGRAM_TEXTURE_GATHER_OFFSET_NV +_m[0x8C37] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/sample_shading.txt # GL_MIN_SAMPLE_SHADING_VALUE_ARB +_m[0x8C37] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/OES/OES_sample_shading.txt # GL_MIN_SAMPLE_SHADING_VALUE_OES +_m[0x919B] = (1,)#TODO Review http://www.opengl.org/registry/specs//AMD/sparse_texture.txt # GL_MIN_SPARSE_LEVEL_AMD +_m[0x8293] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_MIPMAP +_m[0x932F] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_framebuffer_mixed_samples.txt # GL_MIXED_DEPTH_SAMPLES_SUPPORTED_NV +_m[0x9330] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_framebuffer_mixed_samples.txt # GL_MIXED_STENCIL_SAMPLES_SUPPORTED_NV +_m[0x0BA6] = (4,4) # GL_MODELVIEW0_MATRIX_EXT +_m[0x0BA3] = (1,) # GL_MODELVIEW0_STACK_DEPTH_EXT +_m[0x872A] = (4,4) # GL_MODELVIEW10_ARB +_m[0x872B] = (4,4) # GL_MODELVIEW11_ARB +_m[0x872C] = (4,4) # GL_MODELVIEW12_ARB +_m[0x872D] = (4,4) # GL_MODELVIEW13_ARB +_m[0x872E] = (4,4) # GL_MODELVIEW14_ARB +_m[0x872F] = (4,4) # GL_MODELVIEW15_ARB +_m[0x8730] = (4,4) # GL_MODELVIEW16_ARB +_m[0x8731] = (4,4) # GL_MODELVIEW17_ARB +_m[0x8732] = (4,4) # GL_MODELVIEW18_ARB +_m[0x8733] = (4,4) # GL_MODELVIEW19_ARB +_m[0x850A] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/vertex_blend.txt # GL_MODELVIEW1_ARB +_m[0x8506] = (4,4) # GL_MODELVIEW1_MATRIX_EXT +_m[0x8502] = (1,) # GL_MODELVIEW1_STACK_DEPTH_EXT +_m[0x8734] = (4,4) # GL_MODELVIEW20_ARB +_m[0x8735] = (4,4) # GL_MODELVIEW21_ARB +_m[0x8736] = (4,4) # GL_MODELVIEW22_ARB +_m[0x8737] = (4,4) # GL_MODELVIEW23_ARB +_m[0x8738] = (4,4) # GL_MODELVIEW24_ARB +_m[0x8739] = (4,4) # GL_MODELVIEW25_ARB +_m[0x873A] = (4,4) # GL_MODELVIEW26_ARB +_m[0x873B] = (4,4) # GL_MODELVIEW27_ARB +_m[0x873C] = (4,4) # GL_MODELVIEW28_ARB +_m[0x873D] = (4,4) # GL_MODELVIEW29_ARB +_m[0x8722] = (4,4) # GL_MODELVIEW2_ARB +_m[0x873E] = (4,4) # GL_MODELVIEW30_ARB +_m[0x873F] = (4,4) # GL_MODELVIEW31_ARB +_m[0x8723] = (4,4) # GL_MODELVIEW3_ARB +_m[0x8724] = (4,4) # GL_MODELVIEW4_ARB +_m[0x8725] = (4,4) # GL_MODELVIEW5_ARB +_m[0x8726] = (4,4) # GL_MODELVIEW6_ARB +_m[0x8727] = (4,4) # GL_MODELVIEW7_ARB +_m[0x8728] = (4,4) # GL_MODELVIEW8_ARB +_m[0x8729] = (4,4) # GL_MODELVIEW9_ARB +_m[0x0BA6] = (4, 4) # GL_MODELVIEW_MATRIX +_m[0x898D] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/OES/OES_matrix_get.txt # GL_MODELVIEW_MATRIX_FLOAT_AS_INT_BITS_OES +_m[0x0BA3] = (1,) # GL_MODELVIEW_STACK_DEPTH +_m[0x92BA] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_gpu_multicast.txt # GL_MULTICAST_GPUS_NV +_m[0x9549] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_gpu_multicast.txt # GL_MULTICAST_PROGRAMMABLE_SAMPLE_LOCATION_NV +_m[0x809D] = (1,) # GL_MULTISAMPLE +_m[0x9371] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_internalformat_sample_query.txt # GL_MULTISAMPLES_NV +_m[0x86B2] = (1,) # GL_MULTISAMPLE_3DFX +_m[0x809D] = (1,) # GL_MULTISAMPLE_ARB +_m[0x8E12] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/framebuffer_multisample_coverage.txt # GL_MULTISAMPLE_COVERAGE_MODES_NV +_m[0x809D] = (1,) # GL_MULTISAMPLE_EXT +_m[0x8534] = (1,) # GL_MULTISAMPLE_FILTER_HINT_NV +_m[0x9382] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/ARB/ARB_ES3_2_compatibility.txt # GL_MULTISAMPLE_LINE_WIDTH_GRANULARITY_ARB +_m[0x9381] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/ARB/ARB_ES3_2_compatibility.txt # GL_MULTISAMPLE_LINE_WIDTH_RANGE_ARB +_m[0x932B] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_framebuffer_mixed_samples.txt # GL_MULTISAMPLE_RASTERIZATION_ALLOWED_EXT +_m[0x809D] = (1,) # GL_MULTISAMPLE_SGIS +_m[0x8DE9] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/shading_language_include.txt # GL_NAMED_STRING_LENGTH_ARB +_m[0x8DEA] = (1,) # GL_NAMED_STRING_TYPE_ARB +_m[0x92F9] = (1,) # GL_NAME_LENGTH +_m[0x0D70] = (1,) # GL_NAME_STACK_DEPTH +_m[0x9025] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/video_capture.txt # GL_NEXT_VIDEO_CAPTURE_BUFFER_STATUS_NV +_m[0x0BA1] = (1,) # GL_NORMALIZE +_m[0x8075] = (1,) # GL_NORMAL_ARRAY +_m[0x8897] = (1,) # GL_NORMAL_ARRAY_BUFFER_BINDING +_m[0x8897] = (1,) # GL_NORMAL_ARRAY_BUFFER_BINDING_ARB +_m[0x8080] = (1,) # GL_NORMAL_ARRAY_COUNT_EXT +_m[0x8075] = (1,) # GL_NORMAL_ARRAY_EXT +_m[0x8F2C] = (1,) # GL_NORMAL_ARRAY_LENGTH_NV +_m[0x83F6] = (1,)#TODO Review http://www.opengl.org/registry/specs//INTEL/parallel_arrays.txt # GL_NORMAL_ARRAY_PARALLEL_POINTERS_INTEL +_m[0x808F] = (1,) # GL_NORMAL_ARRAY_POINTER +_m[0x807F] = (1,) # GL_NORMAL_ARRAY_STRIDE +_m[0x807F] = (1,) # GL_NORMAL_ARRAY_STRIDE_EXT +_m[0x807E] = (1,) # GL_NORMAL_ARRAY_TYPE +_m[0x807E] = (1,) # GL_NORMAL_ARRAY_TYPE_EXT +_m[0x8261] = (1,)#TODO Review http://www.opengl.org/registry/specs//KHR/robustness.txt # GL_NO_RESET_NOTIFICATION +_m[0x8261] = (1,) # GL_NO_RESET_NOTIFICATION_ARB +_m[0x9304] = (1,) # GL_NUM_ACTIVE_VARIABLES +_m[0x8E4A] = (1,) # GL_NUM_COMPATIBLE_SUBROUTINES +_m[0x86A2] = (1,) # GL_NUM_COMPRESSED_TEXTURE_FORMATS +_m[0x86A2] = (1,) # GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB +_m[0x913D] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/IMG/IMG_framebuffer_downsample.txt # GL_NUM_DOWNSAMPLE_SCALES_IMG +_m[0x821D] = (1,) # GL_NUM_EXTENSIONS +_m[0x8E29] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/present_video.txt # GL_NUM_FILL_STREAMS_NV +_m[0x896F] = (1,) # GL_NUM_FRAGMENT_CONSTANTS_ATI +_m[0x896E] = (1,) # GL_NUM_FRAGMENT_REGISTERS_ATI +_m[0x854E] = (1,) # GL_NUM_GENERAL_COMBINERS_NV +_m[0x8973] = (1,) # GL_NUM_INPUT_INTERPOLATOR_COMPONENTS_ATI +_m[0x8971] = (1,) # GL_NUM_INSTRUCTIONS_PER_PASS_ATI +_m[0x8972] = (1,) # GL_NUM_INSTRUCTIONS_TOTAL_ATI +_m[0x8974] = (1,) # GL_NUM_LOOPBACK_COMPONENTS_ATI +_m[0x8970] = (1,) # GL_NUM_PASSES_ATI +_m[0x87FE] = (1,) # GL_NUM_PROGRAM_BINARY_FORMATS +_m[0x9380] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query.txt # GL_NUM_SAMPLE_COUNTS +_m[0x8DF9] = (1,) # GL_NUM_SHADER_BINARY_FORMATS +_m[0x91AA] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/sparse_texture.txt # GL_NUM_SPARSE_LEVELS_ARB +_m[0x91AA] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/EXT/EXT_sparse_texture.txt # GL_NUM_SPARSE_LEVELS_EXT +_m[0x9554] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/ARB/ARB_spirv_extensions.txt # GL_NUM_SPIR_V_EXTENSIONS +_m[0x91B6] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/AMD/AMD_framebuffer_multisample_advanced.txt # GL_NUM_SUPPORTED_MULTISAMPLE_MODES_AMD +_m[0x9024] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/video_capture.txt # GL_NUM_VIDEO_CAPTURE_STREAMS_NV +_m[0x8F15] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/EXT/EXT_window_rectangles.txt # GL_NUM_WINDOW_RECTANGLES_EXT +_m[0x8B86] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/shader_objects.txt # GL_OBJECT_ACTIVE_UNIFORMS_ARB +_m[0x8B87] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/shader_objects.txt # GL_OBJECT_ACTIVE_UNIFORM_MAX_LENGTH_ARB +_m[0x8B85] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/shader_objects.txt # GL_OBJECT_ATTACHED_OBJECTS_ARB +_m[0x8764] = (1,) # GL_OBJECT_BUFFER_SIZE_ATI +_m[0x8765] = (4,) # GL_OBJECT_BUFFER_USAGE_ATI +_m[0x8B81] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/shader_objects.txt # GL_OBJECT_COMPILE_STATUS_ARB +_m[0x8B80] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/shader_objects.txt # GL_OBJECT_DELETE_STATUS_ARB +_m[0x8B84] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/shader_objects.txt # GL_OBJECT_INFO_LOG_LENGTH_ARB +_m[0x81F7] = (7,) # GL_OBJECT_LINE_SGIS +_m[0x8B82] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/shader_objects.txt # GL_OBJECT_LINK_STATUS_ARB +_m[0x2501] = (4,) # GL_OBJECT_PLANE +_m[0x81F5] = (4,) # GL_OBJECT_POINT_SGIS +_m[0x8B88] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/shader_objects.txt # GL_OBJECT_SHADER_SOURCE_LENGTH_ARB +_m[0x8B4F] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/shader_objects.txt # GL_OBJECT_SUBTYPE_ARB +_m[0x9112] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/sync.txt # GL_OBJECT_TYPE +_m[0x8B4E] = (1,) # GL_OBJECT_TYPE_ARB +_m[0x8B83] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/shader_objects.txt # GL_OBJECT_VALIDATE_STATUS_ARB +_m[0x8165] = (1,) # GL_OCCLUSION_TEST_HP +_m[0x8166] = (1,) # GL_OCCLUSION_TEST_RESULT_HP +_m[0x92FC] = (1,) # GL_OFFSET +_m[0x86E3] = (1,) # GL_OFFSET_TEXTURE_BIAS_NV +_m[0x86E1] = (4,) # GL_OFFSET_TEXTURE_MATRIX_NV +_m[0x86E2] = (1,) # GL_OFFSET_TEXTURE_SCALE_NV +_m[0x8598] = (1,) # GL_OPERAND0_ALPHA +_m[0x8590] = (1,) # GL_OPERAND0_RGB +_m[0x8599] = (1,) # GL_OPERAND1_ALPHA +_m[0x8591] = (1,) # GL_OPERAND1_RGB +_m[0x859A] = (1,) # GL_OPERAND2_ALPHA +_m[0x8592] = (1,) # GL_OPERAND2_RGB +_m[0x859B] = (1,) # GL_OPERAND3_ALPHA_NV +_m[0x8593] = (1,) # GL_OPERAND3_RGB_NV +_m[0x0D05] = (1,) # GL_PACK_ALIGNMENT +_m[0x800E] = (1,) # GL_PACK_CMYK_HINT_EXT +_m[0x912D] = (1,) # GL_PACK_COMPRESSED_BLOCK_DEPTH +_m[0x912C] = (1,) # GL_PACK_COMPRESSED_BLOCK_HEIGHT +_m[0x912E] = (1,) # GL_PACK_COMPRESSED_BLOCK_SIZE +_m[0x912B] = (1,) # GL_PACK_COMPRESSED_BLOCK_WIDTH +_m[0x8131] = (1,) # GL_PACK_IMAGE_DEPTH_SGIS +_m[0x806C] = (1,) # GL_PACK_IMAGE_HEIGHT +_m[0x806C] = (1,) # GL_PACK_IMAGE_HEIGHT_EXT +_m[0x8758] = (1,) # GL_PACK_INVERT_MESA +_m[0x0D01] = (1,) # GL_PACK_LSB_FIRST +_m[0x8984] = (1,) # GL_PACK_RESAMPLE_OML +_m[0x842E] = (1,) # GL_PACK_RESAMPLE_SGIX +_m[0x93A4] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/ANGLE/ANGLE_pack_reverse_row_order.txt # GL_PACK_REVERSE_ROW_ORDER_ANGLE +_m[0x8A15] = (1,) # GL_PACK_ROW_BYTES_APPLE +_m[0x0D02] = (1,) # GL_PACK_ROW_LENGTH +_m[0x806B] = (1,) # GL_PACK_SKIP_IMAGES +_m[0x806B] = (1,) # GL_PACK_SKIP_IMAGES_EXT +_m[0x0D04] = (1,) # GL_PACK_SKIP_PIXELS +_m[0x0D03] = (1,) # GL_PACK_SKIP_ROWS +_m[0x8130] = (1,) # GL_PACK_SKIP_VOLUMES_SGIS +_m[0x0D00] = (1,) # GL_PACK_SWAP_BYTES +_m[0x83F4] = (1,) # GL_PARALLEL_ARRAYS_INTEL +_m[0x80EF] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/indirect_parameters.txt # GL_PARAMETER_BUFFER_BINDING_ARB +_m[0x8E73] = (1,) # GL_PATCH_DEFAULT_INNER_LEVEL +_m[0x8E74] = (1,) # GL_PATCH_DEFAULT_OUTER_LEVEL +_m[0x8E72] = (1,) # GL_PATCH_VERTICES +_m[0x909D] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/path_rendering.txt # GL_PATH_COMMAND_COUNT_NV +_m[0x90A0] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/path_rendering.txt # GL_PATH_COMPUTED_LENGTH_NV +_m[0x909E] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/path_rendering.txt # GL_PATH_COORD_COUNT_NV +_m[0x90BF] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/path_rendering.txt # GL_PATH_COVER_DEPTH_FUNC_NV +_m[0x909F] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/path_rendering.txt # GL_PATH_DASH_ARRAY_COUNT_NV +_m[0x90AB] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/path_rendering.txt # GL_PATH_ERROR_POSITION_NV +_m[0x90A1] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/path_rendering.txt # GL_PATH_FILL_BOUNDING_BOX_NV +_m[0x90AC] = (1,) # GL_PATH_FOG_GEN_MODE_NV +_m[0x90B1] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/path_rendering.txt # GL_PATH_GEN_COEFF_NV +_m[0x90B2] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/path_rendering.txt # GL_PATH_GEN_COLOR_FORMAT_NV +_m[0x90B3] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/path_rendering.txt # GL_PATH_GEN_COMPONENTS_NV +_m[0x90B0] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/path_rendering.txt # GL_PATH_GEN_MODE_NV +_m[0x90BD] = (1,) # GL_PATH_STENCIL_DEPTH_OFFSET_FACTOR_NV +_m[0x90BE] = (1,) # GL_PATH_STENCIL_DEPTH_OFFSET_UNITS_NV +_m[0x90B7] = (1,) # GL_PATH_STENCIL_FUNC_NV +_m[0x90B8] = (1,) # GL_PATH_STENCIL_REF_NV +_m[0x90B9] = (1,) # GL_PATH_STENCIL_VALUE_MASK_NV +_m[0x90A2] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/path_rendering.txt # GL_PATH_STROKE_BOUNDING_BOX_NV +_m[0x8BC6] = (1,)#TODO Review http://www.opengl.org/registry/specs//AMD/performance_monitor.txt # GL_PERFMON_RESULT_AMD +_m[0x8BC4] = (1,)#TODO Review http://www.opengl.org/registry/specs//AMD/performance_monitor.txt # GL_PERFMON_RESULT_AVAILABLE_AMD +_m[0x8BC5] = (1,)#TODO Review http://www.opengl.org/registry/specs//AMD/performance_monitor.txt # GL_PERFMON_RESULT_SIZE_AMD +_m[0x94FF] = (1,)#TODO Review http://www.opengl.org/registry/specs//INTEL/performance_query.txt # GL_PERFQUERY_COUNTER_DESC_LENGTH_MAX_INTEL +_m[0x94FE] = (1,)#TODO Review http://www.opengl.org/registry/specs//INTEL/performance_query.txt # GL_PERFQUERY_COUNTER_NAME_LENGTH_MAX_INTEL +_m[0x9500] = (1,)#TODO Review http://www.opengl.org/registry/specs//INTEL/performance_query.txt # GL_PERFQUERY_GPA_EXTENDED_COUNTERS_INTEL +_m[0x94FD] = (1,)#TODO Review http://www.opengl.org/registry/specs//INTEL/performance_query.txt # GL_PERFQUERY_QUERY_NAME_LENGTH_MAX_INTEL +_m[0x0C50] = (1,) # GL_PERSPECTIVE_CORRECTION_HINT +_m[0x8535] = (1,) # GL_PER_STAGE_CONSTANTS_NV +_m[0x91AE] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/AMD/AMD_framebuffer_sample_positions.txt # GL_PIXELS_PER_SAMPLE_PATTERN_X_AMD +_m[0x91AF] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/AMD/AMD_framebuffer_sample_positions.txt # GL_PIXELS_PER_SAMPLE_PATTERN_Y_AMD +_m[0x8864] = (1,) # GL_PIXEL_COUNTER_BITS_NV +_m[0x8867] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/occlusion_query.txt # GL_PIXEL_COUNT_AVAILABLE_NV +_m[0x8866] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/occlusion_query.txt # GL_PIXEL_COUNT_NV +_m[0x8355] = (1,) # GL_PIXEL_FRAGMENT_ALPHA_SOURCE_SGIS +_m[0x8354] = (1,) # GL_PIXEL_FRAGMENT_RGB_SOURCE_SGIS +_m[0x8356] = (1,) # GL_PIXEL_GROUP_COLOR_SGIS +_m[0x0C79] = (_L(0xCB9),) # GL_PIXEL_MAP_A_TO_A +_m[0x0CB9] = (1,) # GL_PIXEL_MAP_A_TO_A_SIZE +_m[0x0C78] = (_L(0xCB8),) # GL_PIXEL_MAP_B_TO_B +_m[0x0CB8] = (1,) # GL_PIXEL_MAP_B_TO_B_SIZE +_m[0x0C77] = (_L(0xCB7),) # GL_PIXEL_MAP_G_TO_G +_m[0x0CB7] = (1,) # GL_PIXEL_MAP_G_TO_G_SIZE +_m[0x0C75] = (_L(0xCB5),) # GL_PIXEL_MAP_I_TO_A +_m[0x0CB5] = (1,) # GL_PIXEL_MAP_I_TO_A_SIZE +_m[0x0C74] = (_L(0xCB4),) # GL_PIXEL_MAP_I_TO_B +_m[0x0CB4] = (1,) # GL_PIXEL_MAP_I_TO_B_SIZE +_m[0x0C73] = (_L(0xCB3),) # GL_PIXEL_MAP_I_TO_G +_m[0x0CB3] = (1,) # GL_PIXEL_MAP_I_TO_G_SIZE +_m[0x0C70] = (_L(0xCB0),) # GL_PIXEL_MAP_I_TO_I +_m[0x0CB0] = (1,) # GL_PIXEL_MAP_I_TO_I_SIZE +_m[0x0C72] = (_L(0xCB2),) # GL_PIXEL_MAP_I_TO_R +_m[0x0CB2] = (1,) # GL_PIXEL_MAP_I_TO_R_SIZE +_m[0x0C76] = (_L(0xCB6),) # GL_PIXEL_MAP_R_TO_R +_m[0x0CB6] = (1,) # GL_PIXEL_MAP_R_TO_R_SIZE +_m[0x0C71] = (_L(0xCB1),) # GL_PIXEL_MAP_S_TO_S +_m[0x0CB1] = (1,) # GL_PIXEL_MAP_S_TO_S_SIZE +_m[0x88ED] = (1,) # GL_PIXEL_PACK_BUFFER_BINDING +_m[0x88ED] = (1,) # GL_PIXEL_PACK_BUFFER_BINDING_ARB +_m[0x88ED] = (1,) # GL_PIXEL_PACK_BUFFER_BINDING_EXT +_m[0x8353] = (1,) # GL_PIXEL_TEXTURE_SGIS +_m[0x832B] = (1,) # GL_PIXEL_TEX_GEN_MODE_SGIX +_m[0x8139] = (1,) # GL_PIXEL_TEX_GEN_SGIX +_m[0x813E] = (1,) # GL_PIXEL_TILE_BEST_ALIGNMENT_SGIX +_m[0x813F] = (1,) # GL_PIXEL_TILE_CACHE_INCREMENT_SGIX +_m[0x8145] = (1,) # GL_PIXEL_TILE_CACHE_SIZE_SGIX +_m[0x8144] = (1,) # GL_PIXEL_TILE_GRID_DEPTH_SGIX +_m[0x8143] = (1,) # GL_PIXEL_TILE_GRID_HEIGHT_SGIX +_m[0x8142] = (1,) # GL_PIXEL_TILE_GRID_WIDTH_SGIX +_m[0x8141] = (1,) # GL_PIXEL_TILE_HEIGHT_SGIX +_m[0x8140] = (1,) # GL_PIXEL_TILE_WIDTH_SGIX +_m[0x8338] = (1,)#TODO Review http://www.opengl.org/registry/specs//EXT/pixel_transform.txt # GL_PIXEL_TRANSFORM_2D_MATRIX_EXT +_m[0x8336] = (1,) # GL_PIXEL_TRANSFORM_2D_STACK_DEPTH_EXT +_m[0x88EF] = (1,) # GL_PIXEL_UNPACK_BUFFER_BINDING +_m[0x88EF] = (1,) # GL_PIXEL_UNPACK_BUFFER_BINDING_ARB +_m[0x88EF] = (1,) # GL_PIXEL_UNPACK_BUFFER_BINDING_EXT +_m[0x87F3] = (1,) # GL_PN_TRIANGLES_NORMAL_MODE_ATI +_m[0x87F2] = (1,) # GL_PN_TRIANGLES_POINT_MODE_ATI +_m[0x87F4] = (1,) # GL_PN_TRIANGLES_TESSELATION_LEVEL_ATI +_m[0x8129] = (3,) # GL_POINT_DISTANCE_ATTENUATION +_m[0x8129] = (3,) # GL_POINT_DISTANCE_ATTENUATION_ARB +_m[0x8128] = (1,) # GL_POINT_FADE_THRESHOLD_SIZE +_m[0x8128] = (1,) # GL_POINT_FADE_THRESHOLD_SIZE_ARB +_m[0x8128] = (1,) # GL_POINT_FADE_THRESHOLD_SIZE_SGIS +_m[0x1B00] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_polygon_mode.txt # GL_POINT_NV +_m[0x0B11] = (1,) # GL_POINT_SIZE +_m[0x8B9F] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/OES/OES_point_size_array.txt # GL_POINT_SIZE_ARRAY_BUFFER_BINDING_OES +_m[0x898C] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/OES/OES_point_size_array.txt # GL_POINT_SIZE_ARRAY_POINTER_OES +_m[0x898B] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/OES/OES_point_size_array.txt # GL_POINT_SIZE_ARRAY_STRIDE_OES +_m[0x898A] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/OES/OES_point_size_array.txt # GL_POINT_SIZE_ARRAY_TYPE_OES +_m[0x0B13] = (1,) # GL_POINT_SIZE_GRANULARITY +_m[0x8127] = (1,) # GL_POINT_SIZE_MAX +_m[0x8127] = (1,) # GL_POINT_SIZE_MAX_ARB +_m[0x8127] = (1,) # GL_POINT_SIZE_MAX_SGIS +_m[0x8126] = (1,) # GL_POINT_SIZE_MIN +_m[0x8126] = (1,) # GL_POINT_SIZE_MIN_ARB +_m[0x8126] = (1,) # GL_POINT_SIZE_MIN_SGIS +_m[0x0B12] = (2,) # GL_POINT_SIZE_RANGE +_m[0x0B10] = (1,) # GL_POINT_SMOOTH +_m[0x0C51] = (1,) # GL_POINT_SMOOTH_HINT +_m[0x8861] = (1,) # GL_POINT_SPRITE +_m[0x8861] = (1,) # GL_POINT_SPRITE_ARB +_m[0x8CA0] = (1,) # GL_POINT_SPRITE_COORD_ORIGIN +_m[0x8861] = (1,) # GL_POINT_SPRITE_NV +_m[0x8863] = (1,) # GL_POINT_SPRITE_R_MODE_NV +_m[0x0B40] = (2,) # GL_POLYGON_MODE +_m[0x8039] = (1,) # GL_POLYGON_OFFSET_BIAS_EXT +_m[0x8E1B] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/ARB/ARB_polygon_offset_clamp.txt # GL_POLYGON_OFFSET_CLAMP +_m[0x8E1B] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/EXT/EXT_polygon_offset_clamp.txt # GL_POLYGON_OFFSET_CLAMP_EXT +_m[0x8037] = (1,) # GL_POLYGON_OFFSET_EXT +_m[0x8038] = (1,) # GL_POLYGON_OFFSET_FACTOR +_m[0x8038] = (1,) # GL_POLYGON_OFFSET_FACTOR_EXT +_m[0x8037] = (1,) # GL_POLYGON_OFFSET_FILL +_m[0x2A02] = (1,) # GL_POLYGON_OFFSET_LINE +_m[0x2A01] = (1,) # GL_POLYGON_OFFSET_POINT +_m[0x2A00] = (1,) # GL_POLYGON_OFFSET_UNITS +_m[0x0B41] = (1,) # GL_POLYGON_SMOOTH +_m[0x0C53] = (1,) # GL_POLYGON_SMOOTH_HINT +_m[0x0B42] = (1,) # GL_POLYGON_STIPPLE +_m[0x1203] = (4,) # GL_POSITION +_m[0x80BB] = (1,) # GL_POST_COLOR_MATRIX_ALPHA_BIAS +_m[0x80BB] = (1,) # GL_POST_COLOR_MATRIX_ALPHA_BIAS_SGI +_m[0x80B7] = (1,) # GL_POST_COLOR_MATRIX_ALPHA_SCALE +_m[0x80B7] = (1,) # GL_POST_COLOR_MATRIX_ALPHA_SCALE_SGI +_m[0x80BA] = (1,) # GL_POST_COLOR_MATRIX_BLUE_BIAS +_m[0x80BA] = (1,) # GL_POST_COLOR_MATRIX_BLUE_BIAS_SGI +_m[0x80B6] = (1,) # GL_POST_COLOR_MATRIX_BLUE_SCALE +_m[0x80B6] = (1,) # GL_POST_COLOR_MATRIX_BLUE_SCALE_SGI +_m[0x80D2] = (1,) # GL_POST_COLOR_MATRIX_COLOR_TABLE +_m[0x80D2] = (1,) # GL_POST_COLOR_MATRIX_COLOR_TABLE_SGI +_m[0x80B9] = (1,) # GL_POST_COLOR_MATRIX_GREEN_BIAS +_m[0x80B9] = (1,) # GL_POST_COLOR_MATRIX_GREEN_BIAS_SGI +_m[0x80B5] = (1,) # GL_POST_COLOR_MATRIX_GREEN_SCALE +_m[0x80B5] = (1,) # GL_POST_COLOR_MATRIX_GREEN_SCALE_SGI +_m[0x80B8] = (1,) # GL_POST_COLOR_MATRIX_RED_BIAS +_m[0x80B8] = (1,) # GL_POST_COLOR_MATRIX_RED_BIAS_SGI +_m[0x80B4] = (1,) # GL_POST_COLOR_MATRIX_RED_SCALE +_m[0x80B4] = (1,) # GL_POST_COLOR_MATRIX_RED_SCALE_SGI +_m[0x8023] = (1,) # GL_POST_CONVOLUTION_ALPHA_BIAS +_m[0x8023] = (1,) # GL_POST_CONVOLUTION_ALPHA_BIAS_EXT +_m[0x801F] = (1,) # GL_POST_CONVOLUTION_ALPHA_SCALE +_m[0x801F] = (1,) # GL_POST_CONVOLUTION_ALPHA_SCALE_EXT +_m[0x8022] = (1,) # GL_POST_CONVOLUTION_BLUE_BIAS +_m[0x8022] = (1,) # GL_POST_CONVOLUTION_BLUE_BIAS_EXT +_m[0x801E] = (1,) # GL_POST_CONVOLUTION_BLUE_SCALE +_m[0x801E] = (1,) # GL_POST_CONVOLUTION_BLUE_SCALE_EXT +_m[0x80D1] = (1,) # GL_POST_CONVOLUTION_COLOR_TABLE +_m[0x80D1] = (1,) # GL_POST_CONVOLUTION_COLOR_TABLE_SGI +_m[0x8021] = (1,) # GL_POST_CONVOLUTION_GREEN_BIAS +_m[0x8021] = (1,) # GL_POST_CONVOLUTION_GREEN_BIAS_EXT +_m[0x801D] = (1,) # GL_POST_CONVOLUTION_GREEN_SCALE +_m[0x801D] = (1,) # GL_POST_CONVOLUTION_GREEN_SCALE_EXT +_m[0x8020] = (1,) # GL_POST_CONVOLUTION_RED_BIAS +_m[0x8020] = (1,) # GL_POST_CONVOLUTION_RED_BIAS_EXT +_m[0x801C] = (1,) # GL_POST_CONVOLUTION_RED_SCALE +_m[0x801C] = (1,) # GL_POST_CONVOLUTION_RED_SCALE_EXT +_m[0x817B] = (1,) # GL_POST_TEXTURE_FILTER_BIAS_RANGE_SGIX +_m[0x8179] = (1,) # GL_POST_TEXTURE_FILTER_BIAS_SGIX +_m[0x817C] = (1,) # GL_POST_TEXTURE_FILTER_SCALE_RANGE_SGIX +_m[0x817A] = (1,) # GL_POST_TEXTURE_FILTER_SCALE_SGIX +_m[0x86E4] = (1,) # GL_PREVIOUS_TEXTURE_INPUT_NV +_m[0x92BE] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/ARB/ARB_ES3_2_compatibility.txt # GL_PRIMITIVE_BOUNDING_BOX_ARB +_m[0x92BE] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/EXT/EXT_primitive_bounding_box.txt # GL_PRIMITIVE_BOUNDING_BOX_EXT +_m[0x92BE] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/OES/OES_primitive_bounding_box.txt # GL_PRIMITIVE_BOUNDING_BOX_OES +_m[0x8F9D] = (1,) # GL_PRIMITIVE_RESTART +_m[0x8D69] = (1,) # GL_PRIMITIVE_RESTART_FIXED_INDEX +_m[0x8221] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/EXT/EXT_tessellation_shader.txt # GL_PRIMITIVE_RESTART_FOR_PATCHES_SUPPORTED +_m[0x8F9E] = (1,) # GL_PRIMITIVE_RESTART_INDEX +_m[0x8559] = (1,) # GL_PRIMITIVE_RESTART_INDEX_NV +_m[0x8558] = (1,) # GL_PRIMITIVE_RESTART_NV +_m[0x9341] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/ARB/ARB_sample_locations.txt # GL_PROGRAMMABLE_SAMPLE_LOCATION_ARB +_m[0x9341] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_sample_locations.txt # GL_PROGRAMMABLE_SAMPLE_LOCATION_NV +_m[0x9340] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/ARB/ARB_sample_locations.txt # GL_PROGRAMMABLE_SAMPLE_LOCATION_TABLE_SIZE_ARB +_m[0x9340] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_sample_locations.txt # GL_PROGRAMMABLE_SAMPLE_LOCATION_TABLE_SIZE_NV +_m[0x88B0] = (1,) # GL_PROGRAM_ADDRESS_REGISTERS_ARB +_m[0x8805] = (1,) # GL_PROGRAM_ALU_INSTRUCTIONS_ARB +_m[0x88AC] = (1,) # GL_PROGRAM_ATTRIBS_ARB +_m[0x8906] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/gpu_program4.txt # GL_PROGRAM_ATTRIB_COMPONENTS_NV +_m[0x87FF] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/get_program_binary.txt # GL_PROGRAM_BINARY_FORMATS +_m[0x8741] = (1,) # GL_PROGRAM_BINARY_LENGTH +_m[0x8677] = (1,) # GL_PROGRAM_BINDING_ARB +_m[0x864B] = (1,) # GL_PROGRAM_ERROR_POSITION_ARB +_m[0x864B] = (1,) # GL_PROGRAM_ERROR_POSITION_NV +_m[0x8874] = (1,) # GL_PROGRAM_ERROR_STRING_ARB +_m[0x8876] = (1,) # GL_PROGRAM_FORMAT_ARB +_m[0x88A0] = (1,) # GL_PROGRAM_INSTRUCTIONS_ARB +_m[0x8627] = (1,) # GL_PROGRAM_LENGTH_ARB +_m[0x8627] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/vertex_program.txt # GL_PROGRAM_LENGTH_NV +_m[0x8E2D] = (1,)#TODO Review http://www.opengl.org/registry/specs//EXT/direct_state_access.txt # GL_PROGRAM_MATRIX_EXT +_m[0x8E2F] = (1,)#TODO Review http://www.opengl.org/registry/specs//EXT/direct_state_access.txt # GL_PROGRAM_MATRIX_STACK_DEPTH_EXT +_m[0x88B2] = (1,) # GL_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB +_m[0x8808] = (1,) # GL_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB +_m[0x88AE] = (1,) # GL_PROGRAM_NATIVE_ATTRIBS_ARB +_m[0x88A2] = (1,) # GL_PROGRAM_NATIVE_INSTRUCTIONS_ARB +_m[0x88AA] = (1,) # GL_PROGRAM_NATIVE_PARAMETERS_ARB +_m[0x88A6] = (1,) # GL_PROGRAM_NATIVE_TEMPORARIES_ARB +_m[0x880A] = (1,) # GL_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB +_m[0x8809] = (1,) # GL_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB +_m[0x8B40] = (1,) # GL_PROGRAM_OBJECT_ARB +_m[0x88A8] = (1,) # GL_PROGRAM_PARAMETERS_ARB +_m[0x8644] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/vertex_program.txt # GL_PROGRAM_PARAMETER_NV +_m[0x825A] = (1,) # GL_PROGRAM_PIPELINE_BINDING +_m[0x8642] = (1,) # GL_PROGRAM_POINT_SIZE +_m[0x8642] = (1,) # GL_PROGRAM_POINT_SIZE_ARB +_m[0x8642] = (1,) # GL_PROGRAM_POINT_SIZE_EXT +_m[0x8647] = (1,) # GL_PROGRAM_RESIDENT_NV +_m[0x8907] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/gpu_program4.txt # GL_PROGRAM_RESULT_COMPONENTS_NV +_m[0x8628] = (1,) # GL_PROGRAM_STRING_ARB +_m[0x8628] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/vertex_program.txt # GL_PROGRAM_STRING_NV +_m[0x8646] = (1,) # GL_PROGRAM_TARGET_NV +_m[0x88A4] = (1,) # GL_PROGRAM_TEMPORARIES_ARB +_m[0x8807] = (1,) # GL_PROGRAM_TEX_INDIRECTIONS_ARB +_m[0x8806] = (1,) # GL_PROGRAM_TEX_INSTRUCTIONS_ARB +_m[0x88B6] = (1,) # GL_PROGRAM_UNDER_NATIVE_LIMITS_ARB +_m[0x0BA7] = (4, 4) # GL_PROJECTION_MATRIX +_m[0x898E] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/OES/OES_matrix_get.txt # GL_PROJECTION_MATRIX_FLOAT_AS_INT_BITS_OES +_m[0x0BA4] = (1,) # GL_PROJECTION_STACK_DEPTH +_m[0x8E4F] = (1,) # GL_PROVOKING_VERTEX +_m[0x8E4F] = (1,) # GL_PROVOKING_VERTEX_EXT +_m[0x1209] = (1,) # GL_QUADRATIC_ATTENUATION +_m[0x8E4C] = (1,) # GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION +_m[0x8E4C] = (1,) # GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION_EXT +_m[0x9193] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/query_buffer_object.txt # GL_QUERY_BUFFER_BINDING +_m[0x9193] = (1,) # GL_QUERY_BUFFER_BINDING_AMD +_m[0x8864] = (1,) # GL_QUERY_COUNTER_BITS +_m[0x8864] = (1,) # GL_QUERY_COUNTER_BITS_ARB +_m[0x8866] = (1,) # GL_QUERY_RESULT +_m[0x8867] = (1,) # GL_QUERY_RESULT_AVAILABLE +_m[0x9194] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/query_buffer_object.txt # GL_QUERY_RESULT_NO_WAIT +_m[0x82EA] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/direct_state_access.txt # GL_QUERY_TARGET +_m[0x8C89] = (1,) # GL_RASTERIZER_DISCARD +_m[0x932A] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_framebuffer_mixed_samples.txt # GL_RASTER_FIXED_SAMPLE_LOCATIONS_EXT +_m[0x19262] = (1,) # GL_RASTER_POSITION_UNCLIPPED_IBM +_m[0x9328] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_framebuffer_mixed_samples.txt # GL_RASTER_SAMPLES_EXT +_m[0x0C02] = (1,) # GL_READ_BUFFER +_m[0x0C02] = (1,) # GL_READ_BUFFER_EXT +_m[0x0C02] = (1,) # GL_READ_BUFFER_NV +_m[0x8CA8] = (1,) # GL_READ_FRAMEBUFFER +_m[0x8CAA] = (1,) # GL_READ_FRAMEBUFFER_BINDING +_m[0x828C] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_READ_PIXELS +_m[0x828D] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_READ_PIXELS_FORMAT +_m[0x828E] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_READ_PIXELS_TYPE +_m[0x887B] = (1,) # GL_READ_PIXEL_DATA_RANGE_LENGTH_NV +_m[0x887D] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/pixel_data_range.txt # GL_READ_PIXEL_DATA_RANGE_POINTER_NV +_m[0x0D15] = (1,) # GL_RED_BIAS +_m[0x0D52] = (1,) # GL_RED_BITS +_m[0x8564] = (1,) # GL_RED_MAX_CLAMP_INGR +_m[0x8560] = (1,) # GL_RED_MIN_CLAMP_INGR +_m[0x0D14] = (1,) # GL_RED_SCALE +_m[0x930B] = (1,) # GL_REFERENCED_BY_COMPUTE_SHADER +_m[0x930A] = (1,) # GL_REFERENCED_BY_FRAGMENT_SHADER +_m[0x9309] = (1,) # GL_REFERENCED_BY_GEOMETRY_SHADER +_m[0x9307] = (1,) # GL_REFERENCED_BY_TESS_CONTROL_SHADER +_m[0x9308] = (1,) # GL_REFERENCED_BY_TESS_EVALUATION_SHADER +_m[0x9306] = (1,) # GL_REFERENCED_BY_VERTEX_SHADER +_m[0x817E] = (4,) # GL_REFERENCE_PLANE_EQUATION_SGIX +_m[0x817D] = (1,) # GL_REFERENCE_PLANE_SGIX +_m[0x8522] = (1,) # GL_REGISTER_COMBINERS_NV +_m[0x8D53] = (1,) # GL_RENDERBUFFER_ALPHA_SIZE +_m[0x8CA7] = (1,) # GL_RENDERBUFFER_BINDING +_m[0x8CA7] = (1,) # GL_RENDERBUFFER_BINDING_EXT +_m[0x8D52] = (1,) # GL_RENDERBUFFER_BLUE_SIZE +_m[0x8E10] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/framebuffer_multisample_coverage.txt # GL_RENDERBUFFER_COLOR_SAMPLES_NV +_m[0x8CAB] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/framebuffer_multisample_coverage.txt # GL_RENDERBUFFER_COVERAGE_SAMPLES_NV +_m[0x8D54] = (1,) # GL_RENDERBUFFER_DEPTH_SIZE +_m[0x87FD] = (1,) # GL_RENDERBUFFER_FREE_MEMORY_ATI +_m[0x8D51] = (1,) # GL_RENDERBUFFER_GREEN_SIZE +_m[0x8D43] = (1,) # GL_RENDERBUFFER_HEIGHT +_m[0x8D44] = (1,) # GL_RENDERBUFFER_INTERNAL_FORMAT +_m[0x8D50] = (1,) # GL_RENDERBUFFER_RED_SIZE +_m[0x8CAB] = (1,) # GL_RENDERBUFFER_SAMPLES +_m[0x9133] = (1,) # GL_RENDERBUFFER_SAMPLES_IMG +_m[0x8D55] = (1,) # GL_RENDERBUFFER_STENCIL_SIZE +_m[0x91B2] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/AMD/AMD_framebuffer_multisample_advanced.txt # GL_RENDERBUFFER_STORAGE_SAMPLES_AMD +_m[0x8D42] = (1,) # GL_RENDERBUFFER_WIDTH +_m[0x1F01] = (1,) # GL_RENDERER +_m[0x9558] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_gpu_multicast.txt # GL_RENDER_GPU_MASK_NV +_m[0x0C40] = (1,) # GL_RENDER_MODE +_m[0x85C2] = (1,) # GL_REPLACEMENT_CODE_ARRAY_STRIDE_SUN +_m[0x85C1] = (1,) # GL_REPLACEMENT_CODE_ARRAY_TYPE_SUN +_m[0x81D8] = (1,) # GL_REPLACEMENT_CODE_SUN +_m[0x937F] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_representative_fragment_test.txt # GL_REPRESENTATIVE_FRAGMENT_TEST_NV +_m[0x803A] = (1,) # GL_RESCALE_NORMAL +_m[0x803A] = (1,) # GL_RESCALE_NORMAL_EXT +_m[0x8256] = (1,)#TODO Review http://www.opengl.org/registry/specs//KHR/robustness.txt # GL_RESET_NOTIFICATION_STRATEGY +_m[0x8256] = (1,) # GL_RESET_NOTIFICATION_STRATEGY_ARB +_m[0x8820] = (1,) # GL_RGBA_FLOAT_MODE_ARB +_m[0x8820] = (1,) # GL_RGBA_FLOAT_MODE_ATI +_m[0x8D9E] = (1,) # GL_RGBA_INTEGER_MODE_EXT +_m[0x0C31] = (1,) # GL_RGBA_MODE +_m[0x8C3C] = (1,) # GL_RGBA_SIGNED_COMPONENTS_EXT +_m[0x86D9] = (1,) # GL_RGBA_UNSIGNED_DOT_PRODUCT_MAPPING_NV +_m[0x8573] = (1,) # GL_RGB_SCALE +_m[0x8919] = (1,) # GL_SAMPLER_BINDING +_m[0x80A9] = (1,) # GL_SAMPLES +_m[0x86B4] = (1,) # GL_SAMPLES_3DFX +_m[0x80A9] = (1,) # GL_SAMPLES_ARB +_m[0x80A9] = (1,) # GL_SAMPLES_SGIS +_m[0x809E] = (1,) # GL_SAMPLE_ALPHA_TO_COVERAGE +_m[0x809E] = (1,) # GL_SAMPLE_ALPHA_TO_COVERAGE_ARB +_m[0x809E] = (1,) # GL_SAMPLE_ALPHA_TO_MASK_EXT +_m[0x809E] = (1,) # GL_SAMPLE_ALPHA_TO_MASK_SGIS +_m[0x809F] = (1,) # GL_SAMPLE_ALPHA_TO_ONE +_m[0x809F] = (1,) # GL_SAMPLE_ALPHA_TO_ONE_ARB +_m[0x809F] = (1,) # GL_SAMPLE_ALPHA_TO_ONE_EXT +_m[0x809F] = (1,) # GL_SAMPLE_ALPHA_TO_ONE_SGIS +_m[0x80A8] = (1,) # GL_SAMPLE_BUFFERS +_m[0x86B3] = (1,) # GL_SAMPLE_BUFFERS_3DFX +_m[0x80A8] = (1,) # GL_SAMPLE_BUFFERS_ARB +_m[0x80A8] = (1,) # GL_SAMPLE_BUFFERS_SGIS +_m[0x80A0] = (1,) # GL_SAMPLE_COVERAGE +_m[0x80A0] = (1,) # GL_SAMPLE_COVERAGE_ARB +_m[0x80AB] = (1,) # GL_SAMPLE_COVERAGE_INVERT +_m[0x80AB] = (1,) # GL_SAMPLE_COVERAGE_INVERT_ARB +_m[0x80AA] = (1,) # GL_SAMPLE_COVERAGE_VALUE +_m[0x80AA] = (1,) # GL_SAMPLE_COVERAGE_VALUE_ARB +_m[0x8E50] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/ARB/ARB_sample_locations.txt # GL_SAMPLE_LOCATION_ARB +_m[0x8E50] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_sample_locations.txt # GL_SAMPLE_LOCATION_NV +_m[0x933F] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/ARB/ARB_sample_locations.txt # GL_SAMPLE_LOCATION_PIXEL_GRID_HEIGHT_ARB +_m[0x933F] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_sample_locations.txt # GL_SAMPLE_LOCATION_PIXEL_GRID_HEIGHT_NV +_m[0x933E] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/ARB/ARB_sample_locations.txt # GL_SAMPLE_LOCATION_PIXEL_GRID_WIDTH_ARB +_m[0x933E] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_sample_locations.txt # GL_SAMPLE_LOCATION_PIXEL_GRID_WIDTH_NV +_m[0x933D] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/ARB/ARB_sample_locations.txt # GL_SAMPLE_LOCATION_SUBPIXEL_BITS_ARB +_m[0x933D] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_sample_locations.txt # GL_SAMPLE_LOCATION_SUBPIXEL_BITS_NV +_m[0x8E51] = (1,) # GL_SAMPLE_MASK +_m[0x80A0] = (1,) # GL_SAMPLE_MASK_EXT +_m[0x80AB] = (1,) # GL_SAMPLE_MASK_INVERT_SGIS +_m[0x8E51] = (1,) # GL_SAMPLE_MASK_NV +_m[0x80A0] = (1,) # GL_SAMPLE_MASK_SGIS +_m[0x8E52] = (1,) # GL_SAMPLE_MASK_VALUE +_m[0x80AA] = (1,) # GL_SAMPLE_MASK_VALUE_SGIS +_m[0x80AC] = (1,) # GL_SAMPLE_PATTERN_EXT +_m[0x80AC] = (1,) # GL_SAMPLE_PATTERN_SGIS +_m[0x8E50] = (2,) # GL_SAMPLE_POSITION +_m[0x8C36] = (1,) # GL_SAMPLE_SHADING_ARB +_m[0x8C36] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/OES/OES_sample_shading.txt # GL_SAMPLE_SHADING_OES +_m[0x0C10] = (4,) # GL_SCISSOR_BOX +_m[0x9556] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_scissor_exclusive.txt # GL_SCISSOR_BOX_EXCLUSIVE_NV +_m[0x0C11] = (1,) # GL_SCISSOR_TEST +_m[0x9555] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_scissor_exclusive.txt # GL_SCISSOR_TEST_EXCLUSIVE_NV +_m[0x845E] = (1,) # GL_SECONDARY_COLOR_ARRAY +_m[0x889C] = (1,) # GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING +_m[0x889C] = (1,) # GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING_ARB +_m[0x8F31] = (1,) # GL_SECONDARY_COLOR_ARRAY_LENGTH_NV +_m[0x845D] = (1,)#TODO Review http://www.opengl.org/registry/specs//EXT/secondary_color.txt # GL_SECONDARY_COLOR_ARRAY_POINTER_EXT +_m[0x845A] = (1,) # GL_SECONDARY_COLOR_ARRAY_SIZE +_m[0x845A] = (1,) # GL_SECONDARY_COLOR_ARRAY_SIZE_EXT +_m[0x845C] = (1,) # GL_SECONDARY_COLOR_ARRAY_STRIDE +_m[0x845C] = (1,) # GL_SECONDARY_COLOR_ARRAY_STRIDE_EXT +_m[0x845B] = (1,) # GL_SECONDARY_COLOR_ARRAY_TYPE +_m[0x845B] = (1,) # GL_SECONDARY_COLOR_ARRAY_TYPE_EXT +_m[0x0DF3] = (1,) # GL_SELECTION_BUFFER_POINTER +_m[0x0DF4] = (1,) # GL_SELECTION_BUFFER_SIZE +_m[0x8012] = (1,) # GL_SEPARABLE_2D +_m[0x8012] = (1,) # GL_SEPARABLE_2D_EXT +_m[0x8DF8] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/ES2_compatibility.txt # GL_SHADER_BINARY_FORMATS +_m[0x8DFA] = (1,) # GL_SHADER_COMPILER +_m[0x82A6] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_SHADER_IMAGE_ATOMIC +_m[0x82A4] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_SHADER_IMAGE_LOAD +_m[0x82A5] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_SHADER_IMAGE_STORE +_m[0x86DF] = (1,) # GL_SHADER_OPERATION_NV +_m[0x8F64] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/EXT/EXT_shader_pixel_local_storage.txt # GL_SHADER_PIXEL_LOCAL_STORAGE_EXT +_m[0x8B88] = (1,) # GL_SHADER_SOURCE_LENGTH +_m[0x90D2] = (1,) # GL_SHADER_STORAGE_BUFFER +_m[0x90D3] = (1,) # GL_SHADER_STORAGE_BUFFER_BINDING +_m[0x90DF] = (1,) # GL_SHADER_STORAGE_BUFFER_OFFSET_ALIGNMENT +_m[0x90D5] = (1,) # GL_SHADER_STORAGE_BUFFER_SIZE +_m[0x90D4] = (1,) # GL_SHADER_STORAGE_BUFFER_START +_m[0x8B4F] = (1,) # GL_SHADER_TYPE +_m[0x0B54] = (1,) # GL_SHADE_MODEL +_m[0x8B8C] = (1,) # GL_SHADING_LANGUAGE_VERSION +_m[0x955B] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_shading_rate_image.txt # GL_SHADING_RATE_IMAGE_BINDING_NV +_m[0x9563] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_shading_rate_image.txt # GL_SHADING_RATE_IMAGE_NV +_m[0x955E] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_shading_rate_image.txt # GL_SHADING_RATE_IMAGE_PALETTE_SIZE_NV +_m[0x955D] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_shading_rate_image.txt # GL_SHADING_RATE_IMAGE_TEXEL_HEIGHT_NV +_m[0x955C] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_shading_rate_image.txt # GL_SHADING_RATE_IMAGE_TEXEL_WIDTH_NV +_m[0x1601] = (1,) # GL_SHININESS +_m[0x82AC] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_SIMULTANEOUS_TEXTURE_AND_DEPTH_TEST +_m[0x82AE] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_SIMULTANEOUS_TEXTURE_AND_DEPTH_WRITE +_m[0x82AD] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_SIMULTANEOUS_TEXTURE_AND_STENCIL_TEST +_m[0x82AF] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_SIMULTANEOUS_TEXTURE_AND_STENCIL_WRITE +_m[0x0B23] = (1,) # GL_SMOOTH_LINE_WIDTH_GRANULARITY +_m[0x0B22] = (2,) # GL_SMOOTH_LINE_WIDTH_RANGE +_m[0x0B13] = (1,) # GL_SMOOTH_POINT_SIZE_GRANULARITY +_m[0x0B12] = (2,) # GL_SMOOTH_POINT_SIZE_RANGE +_m[0x933B] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/shader_thread_group.txt # GL_SM_COUNT_NV +_m[0x858B] = (1,) # GL_SOURCE3_ALPHA_NV +_m[0x8583] = (1,) # GL_SOURCE3_RGB_NV +_m[0x82F8] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/sparse_buffer.txt # GL_SPARSE_BUFFER_PAGE_SIZE_ARB +_m[0x91A9] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/sparse_texture.txt # GL_SPARSE_TEXTURE_FULL_ARRAY_CUBE_MIPMAPS_ARB +_m[0x91A9] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/EXT/EXT_sparse_texture.txt # GL_SPARSE_TEXTURE_FULL_ARRAY_CUBE_MIPMAPS_EXT +_m[0x1202] = (4,) # GL_SPECULAR +_m[0x9552] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/ARB/ARB_gl_spirv.txt # GL_SPIR_V_BINARY_ARB +_m[0x1206] = (1,) # GL_SPOT_CUTOFF +_m[0x1204] = (3,) # GL_SPOT_DIRECTION +_m[0x1205] = (1,) # GL_SPOT_EXPONENT +_m[0x814A] = (3,) # GL_SPRITE_AXIS_SGIX +_m[0x8149] = (1,) # GL_SPRITE_MODE_SGIX +_m[0x8148] = (1,) # GL_SPRITE_SGIX +_m[0x814B] = (3,) # GL_SPRITE_TRANSLATION_SGIX +_m[0x8588] = (1,) # GL_SRC0_ALPHA +_m[0x8580] = (1,) # GL_SRC0_RGB +_m[0x8589] = (1,) # GL_SRC1_ALPHA +_m[0x8581] = (1,) # GL_SRC1_RGB +_m[0x858A] = (1,) # GL_SRC2_ALPHA +_m[0x8582] = (1,) # GL_SRC2_RGB +_m[0x8299] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_SRGB_DECODE_ARB +_m[0x8297] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_SRGB_READ +_m[0x8298] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_SRGB_WRITE +_m[0x8801] = (1,) # GL_STENCIL_BACK_FAIL +_m[0x8801] = (1,) # GL_STENCIL_BACK_FAIL_ATI +_m[0x8800] = (1,) # GL_STENCIL_BACK_FUNC +_m[0x8800] = (1,) # GL_STENCIL_BACK_FUNC_ATI +_m[0x874D] = (1,) # GL_STENCIL_BACK_OP_VALUE_AMD +_m[0x8802] = (1,) # GL_STENCIL_BACK_PASS_DEPTH_FAIL +_m[0x8802] = (1,) # GL_STENCIL_BACK_PASS_DEPTH_FAIL_ATI +_m[0x8803] = (1,) # GL_STENCIL_BACK_PASS_DEPTH_PASS +_m[0x8803] = (1,) # GL_STENCIL_BACK_PASS_DEPTH_PASS_ATI +_m[0x8CA3] = (1,) # GL_STENCIL_BACK_REF +_m[0x8CA4] = (1,) # GL_STENCIL_BACK_VALUE_MASK +_m[0x8CA5] = (1,) # GL_STENCIL_BACK_WRITEMASK +_m[0x0D57] = (1,) # GL_STENCIL_BITS +_m[0x88F3] = (1,) # GL_STENCIL_CLEAR_TAG_VALUE_EXT +_m[0x0B91] = (1,) # GL_STENCIL_CLEAR_VALUE +_m[0x8285] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_STENCIL_COMPONENTS +_m[0x0B94] = (1,) # GL_STENCIL_FAIL +_m[0x0B92] = (1,) # GL_STENCIL_FUNC +_m[0x874C] = (1,) # GL_STENCIL_OP_VALUE_AMD +_m[0x0B95] = (1,) # GL_STENCIL_PASS_DEPTH_FAIL +_m[0x0B96] = (1,) # GL_STENCIL_PASS_DEPTH_PASS +_m[0x0B97] = (1,) # GL_STENCIL_REF +_m[0x8288] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_STENCIL_RENDERABLE +_m[0x932E] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_framebuffer_mixed_samples.txt # GL_STENCIL_SAMPLES_NV +_m[0x88F2] = (1,) # GL_STENCIL_TAG_BITS_EXT +_m[0x0B90] = (1,) # GL_STENCIL_TEST +_m[0x8910] = (1,) # GL_STENCIL_TEST_TWO_SIDE_EXT +_m[0x0B93] = (1,) # GL_STENCIL_VALUE_MASK +_m[0x0B98] = (1,) # GL_STENCIL_WRITEMASK +_m[0x0C33] = (1,) # GL_STEREO +_m[0x00000004] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/KHR/KHR_shader_subgroup.txt # GL_SUBGROUP_FEATURE_ARITHMETIC_BIT_KHR +_m[0x00000008] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/KHR/KHR_shader_subgroup.txt # GL_SUBGROUP_FEATURE_BALLOT_BIT_KHR +_m[0x00000001] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/KHR/KHR_shader_subgroup.txt # GL_SUBGROUP_FEATURE_BASIC_BIT_KHR +_m[0x00000040] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/KHR/KHR_shader_subgroup.txt # GL_SUBGROUP_FEATURE_CLUSTERED_BIT_KHR +_m[0x00000100] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_shader_subgroup_partitioned.txt # GL_SUBGROUP_FEATURE_PARTITIONED_BIT_NV +_m[0x00000080] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/KHR/KHR_shader_subgroup.txt # GL_SUBGROUP_FEATURE_QUAD_BIT_KHR +_m[0x00000010] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/KHR/KHR_shader_subgroup.txt # GL_SUBGROUP_FEATURE_SHUFFLE_BIT_KHR +_m[0x00000020] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/KHR/KHR_shader_subgroup.txt # GL_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT_KHR +_m[0x00000002] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/KHR/KHR_shader_subgroup.txt # GL_SUBGROUP_FEATURE_VOTE_BIT_KHR +_m[0x9535] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/KHR/KHR_shader_subgroup.txt # GL_SUBGROUP_QUAD_ALL_STAGES_KHR +_m[0x9532] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/KHR/KHR_shader_subgroup.txt # GL_SUBGROUP_SIZE_KHR +_m[0x9534] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/KHR/KHR_shader_subgroup.txt # GL_SUBGROUP_SUPPORTED_FEATURES_KHR +_m[0x9533] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/KHR/KHR_shader_subgroup.txt # GL_SUBGROUP_SUPPORTED_STAGES_KHR +_m[0x0D50] = (1,) # GL_SUBPIXEL_BITS +_m[0x9347] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_conservative_raster.txt # GL_SUBPIXEL_PRECISION_BIAS_X_BITS_NV +_m[0x9348] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_conservative_raster.txt # GL_SUBPIXEL_PRECISION_BIAS_Y_BITS_NV +_m[0x883F] = (1,)#TODO Review http://www.opengl.org/registry/specs//AMD/sample_positions.txt # GL_SUBSAMPLE_DISTANCE_AMD +_m[0x9372] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_internalformat_sample_query.txt # GL_SUPERSAMPLE_SCALE_X_NV +_m[0x9373] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_internalformat_sample_query.txt # GL_SUPERSAMPLE_SCALE_Y_NV +_m[0x91B7] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/AMD/AMD_framebuffer_multisample_advanced.txt # GL_SUPPORTED_MULTISAMPLE_MODES_AMD +_m[0x9113] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/sync.txt # GL_SYNC_CONDITION +_m[0x9115] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/sync.txt # GL_SYNC_FLAGS +_m[0x9114] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/sync.txt # GL_SYNC_STATUS +_m[0x8439] = (1,) # GL_TANGENT_ARRAY_EXT +_m[0x8442] = (1,) # GL_TANGENT_ARRAY_POINTER_EXT +_m[0x843F] = (1,) # GL_TANGENT_ARRAY_STRIDE_EXT +_m[0x843E] = (1,) # GL_TANGENT_ARRAY_TYPE_EXT +_m[0x953F] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_TASK_WORK_GROUP_SIZE_NV +_m[0x9004] = (1,) # GL_TESSELLATION_MODE_AMD +_m[0x8E75] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/tessellation_shader.txt # GL_TESS_CONTROL_OUTPUT_VERTICES +_m[0x891E] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/tessellation_program5.txt # GL_TESS_CONTROL_PROGRAM_NV +_m[0x8E88] = (1,) # GL_TESS_CONTROL_SHADER +_m[0x829C] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_TESS_CONTROL_TEXTURE +_m[0x891F] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/tessellation_program5.txt # GL_TESS_EVALUATION_PROGRAM_NV +_m[0x8E87] = (1,) # GL_TESS_EVALUATION_SHADER +_m[0x829D] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_TESS_EVALUATION_TEXTURE +_m[0x8E76] = (1,) # GL_TESS_GEN_MODE +_m[0x8E79] = (1,) # GL_TESS_GEN_POINT_MODE +_m[0x8E77] = (1,) # GL_TESS_GEN_SPACING +_m[0x8E78] = (1,) # GL_TESS_GEN_VERTEX_ORDER +_m[0x0DE0] = (1,) # GL_TEXTURE_1D +_m[0x8C18] = (1,) # GL_TEXTURE_1D_ARRAY +_m[0x8068] = (1,) # GL_TEXTURE_1D_BINDING_EXT +_m[0x875D] = (1,) # GL_TEXTURE_1D_STACK_BINDING_MESAX +_m[0x8759] = (1,) # GL_TEXTURE_1D_STACK_MESAX +_m[0x0DE1] = (1,) # GL_TEXTURE_2D +_m[0x8C1A] = (1,) # GL_TEXTURE_2D_ARRAY +_m[0x8069] = (1,) # GL_TEXTURE_2D_BINDING_EXT +_m[0x875E] = (1,) # GL_TEXTURE_2D_STACK_BINDING_MESAX +_m[0x875A] = (1,) # GL_TEXTURE_2D_STACK_MESAX +_m[0x806F] = (1,) # GL_TEXTURE_3D +_m[0x806A] = (1,) # GL_TEXTURE_3D_BINDING_EXT +_m[0x806F] = (1,) # GL_TEXTURE_3D_EXT +_m[0x806F] = (1,) # GL_TEXTURE_3D_OES +_m[0x814F] = (1,) # GL_TEXTURE_4D_BINDING_SGIS +_m[0x8134] = (1,) # GL_TEXTURE_4D_SGIS +_m[0x805F] = (1,) # GL_TEXTURE_ALPHA_SIZE +_m[0x8C13] = (1,) # GL_TEXTURE_ALPHA_TYPE +_m[0x834F] = (1,) # GL_TEXTURE_APPLICATION_MODE_EXT +_m[0x813C] = (1,) # GL_TEXTURE_BASE_LEVEL +_m[0x813C] = (1,) # GL_TEXTURE_BASE_LEVEL_SGIS +_m[0x8068] = (1,) # GL_TEXTURE_BINDING_1D +_m[0x8C1C] = (1,) # GL_TEXTURE_BINDING_1D_ARRAY +_m[0x8C1C] = (1,) # GL_TEXTURE_BINDING_1D_ARRAY_EXT +_m[0x8069] = (1,) # GL_TEXTURE_BINDING_2D +_m[0x8C1D] = (1,) # GL_TEXTURE_BINDING_2D_ARRAY +_m[0x8C1D] = (1,) # GL_TEXTURE_BINDING_2D_ARRAY_EXT +_m[0x9104] = (1,) # GL_TEXTURE_BINDING_2D_MULTISAMPLE +_m[0x9105] = (1,) # GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY +_m[0x806A] = (1,) # GL_TEXTURE_BINDING_3D +_m[0x8C2C] = (1,) # GL_TEXTURE_BINDING_BUFFER +_m[0x8C2C] = (1,) # GL_TEXTURE_BINDING_BUFFER_ARB +_m[0x8C2C] = (1,) # GL_TEXTURE_BINDING_BUFFER_EXT +_m[0x8514] = (1,) # GL_TEXTURE_BINDING_CUBE_MAP +_m[0x8514] = (1,) # GL_TEXTURE_BINDING_CUBE_MAP_ARB +_m[0x900A] = (1,) # GL_TEXTURE_BINDING_CUBE_MAP_ARRAY +_m[0x900A] = (1,) # GL_TEXTURE_BINDING_CUBE_MAP_ARRAY_ARB +_m[0x8D67] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/OES/OES_EGL_image_external.txt # GL_TEXTURE_BINDING_EXTERNAL_OES +_m[0x84F6] = (1,) # GL_TEXTURE_BINDING_RECTANGLE +_m[0x84F6] = (1,) # GL_TEXTURE_BINDING_RECTANGLE_ARB +_m[0x84F6] = (1,) # GL_TEXTURE_BINDING_RECTANGLE_NV +_m[0x8E53] = (1,) # GL_TEXTURE_BINDING_RENDERBUFFER_NV +_m[0x805E] = (1,) # GL_TEXTURE_BLUE_SIZE +_m[0x8C12] = (1,) # GL_TEXTURE_BLUE_TYPE +_m[0x1005] = (1,) # GL_TEXTURE_BORDER +_m[0x1004] = (4,) # GL_TEXTURE_BORDER_COLOR +_m[0x1004] = (4,) # GL_TEXTURE_BORDER_COLOR_NV +_m[0x8C2A] = (1,) # GL_TEXTURE_BUFFER +_m[0x8C2A] = (1,) # GL_TEXTURE_BUFFER_ARB +_m[0x8C2A] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/EXT/EXT_texture_buffer.txt # GL_TEXTURE_BUFFER_BINDING_EXT +_m[0x8C2A] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/OES/OES_texture_buffer.txt # GL_TEXTURE_BUFFER_BINDING_OES +_m[0x8C2D] = (1,) # GL_TEXTURE_BUFFER_DATA_STORE_BINDING +_m[0x8C2D] = (1,) # GL_TEXTURE_BUFFER_DATA_STORE_BINDING_ARB +_m[0x8C2D] = (1,) # GL_TEXTURE_BUFFER_DATA_STORE_BINDING_EXT +_m[0x8C2A] = (1,) # GL_TEXTURE_BUFFER_EXT +_m[0x8C2E] = (1,) # GL_TEXTURE_BUFFER_FORMAT_ARB +_m[0x8C2E] = (1,) # GL_TEXTURE_BUFFER_FORMAT_EXT +_m[0x919D] = (1,) # GL_TEXTURE_BUFFER_OFFSET +_m[0x919F] = (1,) # GL_TEXTURE_BUFFER_OFFSET_ALIGNMENT +_m[0x919E] = (1,) # GL_TEXTURE_BUFFER_SIZE +_m[0x8171] = (2,) # GL_TEXTURE_CLIPMAP_CENTER_SGIX +_m[0x8176] = (1,) # GL_TEXTURE_CLIPMAP_DEPTH_SGIX +_m[0x8172] = (1,) # GL_TEXTURE_CLIPMAP_FRAME_SGIX +_m[0x8173] = (2,) # GL_TEXTURE_CLIPMAP_OFFSET_SGIX +_m[0x8174] = (3,) # GL_TEXTURE_CLIPMAP_VIRTUAL_DEPTH_SGIX +_m[0x9046] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/texture_multisample.txt # GL_TEXTURE_COLOR_SAMPLES_NV +_m[0x80BC] = (1,) # GL_TEXTURE_COLOR_TABLE_SGI +_m[0x81EF] = (4,) # GL_TEXTURE_COLOR_WRITEMASK_SGIS +_m[0x80BF] = (1,) # GL_TEXTURE_COMPARE_FAIL_VALUE_ARB +_m[0x884D] = (1,) # GL_TEXTURE_COMPARE_FUNC +_m[0x884C] = (1,) # GL_TEXTURE_COMPARE_MODE +_m[0x819B] = (1,) # GL_TEXTURE_COMPARE_OPERATOR_SGIX +_m[0x819A] = (1,) # GL_TEXTURE_COMPARE_SGIX +_m[0x86A1] = (1,) # GL_TEXTURE_COMPRESSED +_m[0x82B2] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_TEXTURE_COMPRESSED_BLOCK_HEIGHT +_m[0x82B3] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_TEXTURE_COMPRESSED_BLOCK_SIZE +_m[0x82B1] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_TEXTURE_COMPRESSED_BLOCK_WIDTH +_m[0x86A0] = (1,) # GL_TEXTURE_COMPRESSED_IMAGE_SIZE +_m[0x84EF] = (1,) # GL_TEXTURE_COMPRESSION_HINT +_m[0x84EF] = (1,) # GL_TEXTURE_COMPRESSION_HINT_ARB +_m[0x8078] = (1,) # GL_TEXTURE_COORD_ARRAY +_m[0x889A] = (1,) # GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING +_m[0x889A] = (1,) # GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING_ARB +_m[0x808B] = (1,) # GL_TEXTURE_COORD_ARRAY_COUNT_EXT +_m[0x8078] = (1,) # GL_TEXTURE_COORD_ARRAY_EXT +_m[0x83F8] = (1,)#TODO Review http://www.opengl.org/registry/specs//INTEL/parallel_arrays.txt # GL_TEXTURE_COORD_ARRAY_PARALLEL_POINTERS_INTEL +_m[0x8092] = (1,) # GL_TEXTURE_COORD_ARRAY_POINTER +_m[0x8088] = (1,) # GL_TEXTURE_COORD_ARRAY_SIZE +_m[0x8088] = (1,) # GL_TEXTURE_COORD_ARRAY_SIZE_EXT +_m[0x808A] = (1,) # GL_TEXTURE_COORD_ARRAY_STRIDE +_m[0x808A] = (1,) # GL_TEXTURE_COORD_ARRAY_STRIDE_EXT +_m[0x8089] = (1,) # GL_TEXTURE_COORD_ARRAY_TYPE +_m[0x8089] = (1,) # GL_TEXTURE_COORD_ARRAY_TYPE_EXT +_m[0x9045] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/texture_multisample.txt # GL_TEXTURE_COVERAGE_SAMPLES_NV +_m[0x8B9D] = (4,) # GL_TEXTURE_CROP_RECT_OES +_m[0x8513] = (1,) # GL_TEXTURE_CUBE_MAP +_m[0x8513] = (1,) # GL_TEXTURE_CUBE_MAP_ARB +_m[0x9009] = (1,) # GL_TEXTURE_CUBE_MAP_ARRAY +_m[0x884F] = (1,) # GL_TEXTURE_CUBE_MAP_SEAMLESS +_m[0x8071] = (1,) # GL_TEXTURE_DEPTH +_m[0x8071] = (1,) # GL_TEXTURE_DEPTH_EXT +_m[0x884A] = (1,) # GL_TEXTURE_DEPTH_SIZE +_m[0x8C16] = (1,) # GL_TEXTURE_DEPTH_TYPE +_m[0x871D] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/texture_shader.txt # GL_TEXTURE_DS_SIZE_NV +_m[0x871E] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/texture_shader.txt # GL_TEXTURE_DT_SIZE_NV +_m[0x2201] = (4,) # GL_TEXTURE_ENV_COLOR +_m[0x2200] = (1,) # GL_TEXTURE_ENV_MODE +_m[0x9107] = (1,) # GL_TEXTURE_FIXED_SAMPLE_LOCATIONS +_m[0x888C] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/float_buffer.txt # GL_TEXTURE_FLOAT_COMPONENTS_NV +_m[0x8BFD] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/QCOM/QCOM_texture_foveated.txt # GL_TEXTURE_FOVEATED_FEATURE_QUERY_QCOM +_m[0x8BFE] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/QCOM/QCOM_texture_foveated.txt # GL_TEXTURE_FOVEATED_NUM_FOCAL_POINTS_QUERY_QCOM +_m[0x87FC] = (1,) # GL_TEXTURE_FREE_MEMORY_ATI +_m[0x82A2] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_TEXTURE_GATHER +_m[0x82A3] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_TEXTURE_GATHER_SHADOW +_m[0x2500] = (1,) # GL_TEXTURE_GEN_MODE +_m[0x0C63] = (1,) # GL_TEXTURE_GEN_Q +_m[0x0C62] = (1,) # GL_TEXTURE_GEN_R +_m[0x0C60] = (1,) # GL_TEXTURE_GEN_S +_m[0x8D60] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/OES/OES_texture_cube_map.txt # GL_TEXTURE_GEN_STR_OES +_m[0x0C61] = (1,) # GL_TEXTURE_GEN_T +_m[0x805D] = (1,) # GL_TEXTURE_GREEN_SIZE +_m[0x8C11] = (1,) # GL_TEXTURE_GREEN_TYPE +_m[0x1001] = (1,) # GL_TEXTURE_HEIGHT +_m[0x871B] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/texture_shader.txt # GL_TEXTURE_HI_SIZE_NV +_m[0x828F] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_TEXTURE_IMAGE_FORMAT +_m[0x8290] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_TEXTURE_IMAGE_TYPE +_m[0x912F] = (1,) # GL_TEXTURE_IMMUTABLE_FORMAT +_m[0x82DF] = (1,) # GL_TEXTURE_IMMUTABLE_LEVELS +_m[0x80ED] = (1,) # GL_TEXTURE_INDEX_SIZE_EXT +_m[0x8061] = (1,) # GL_TEXTURE_INTENSITY_SIZE +_m[0x8C15] = (1,) # GL_TEXTURE_INTENSITY_TYPE +_m[0x1003] = (1,) # GL_TEXTURE_INTERNAL_FORMAT +_m[0x8350] = (1,) # GL_TEXTURE_LIGHT_EXT +_m[0x8501] = (1,) # GL_TEXTURE_LOD_BIAS +_m[0x8190] = (1,) # GL_TEXTURE_LOD_BIAS_R_SGIX +_m[0x818E] = (1,) # GL_TEXTURE_LOD_BIAS_S_SGIX +_m[0x818F] = (1,) # GL_TEXTURE_LOD_BIAS_T_SGIX +_m[0x871C] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/texture_shader.txt # GL_TEXTURE_LO_SIZE_NV +_m[0x8060] = (1,) # GL_TEXTURE_LUMINANCE_SIZE +_m[0x8C14] = (1,) # GL_TEXTURE_LUMINANCE_TYPE +_m[0x2800] = (1,) # GL_TEXTURE_MAG_FILTER +_m[0x871F] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/texture_shader.txt # GL_TEXTURE_MAG_SIZE_NV +_m[0x8351] = (1,) # GL_TEXTURE_MATERIAL_FACE_EXT +_m[0x8352] = (1,) # GL_TEXTURE_MATERIAL_PARAMETER_EXT +_m[0x0BA8] = (4, 4) # GL_TEXTURE_MATRIX +_m[0x898F] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/OES/OES_matrix_get.txt # GL_TEXTURE_MATRIX_FLOAT_AS_INT_BITS_OES +_m[0x84FE] = (1,) # GL_TEXTURE_MAX_ANISOTROPY_EXT +_m[0x836B] = (1,) # GL_TEXTURE_MAX_CLAMP_R_SGIX +_m[0x8369] = (1,) # GL_TEXTURE_MAX_CLAMP_S_SGIX +_m[0x836A] = (1,) # GL_TEXTURE_MAX_CLAMP_T_SGIX +_m[0x813D] = (1,) # GL_TEXTURE_MAX_LEVEL +_m[0x813D] = (1,) # GL_TEXTURE_MAX_LEVEL_SGIS +_m[0x813B] = (1,) # GL_TEXTURE_MAX_LOD +_m[0x813B] = (1,) # GL_TEXTURE_MAX_LOD_SGIS +_m[0x2801] = (1,) # GL_TEXTURE_MIN_FILTER +_m[0x813A] = (1,) # GL_TEXTURE_MIN_LOD +_m[0x813A] = (1,) # GL_TEXTURE_MIN_LOD_SGIS +_m[0x8066] = (1,) # GL_TEXTURE_PRIORITY +_m[0x85B8] = (1,) # GL_TEXTURE_RANGE_POINTER_APPLE +_m[0x84F5] = (1,) # GL_TEXTURE_RECTANGLE +_m[0x84F5] = (1,) # GL_TEXTURE_RECTANGLE_ARB +_m[0x84F5] = (1,) # GL_TEXTURE_RECTANGLE_NV +_m[0x805C] = (1,) # GL_TEXTURE_RED_SIZE +_m[0x8C10] = (1,) # GL_TEXTURE_RED_TYPE +_m[0x8E54] = (1,) # GL_TEXTURE_RENDERBUFFER_DATA_STORE_BINDING_NV +_m[0x8067] = (1,) # GL_TEXTURE_RESIDENT +_m[0x9106] = (1,) # GL_TEXTURE_SAMPLES +_m[0x9136] = (1,) # GL_TEXTURE_SAMPLES_IMG +_m[0x86DE] = (1,) # GL_TEXTURE_SHADER_NV +_m[0x82A1] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_TEXTURE_SHADOW +_m[0x8C3F] = (1,)#TODO Review http://www.opengl.org/registry/specs//EXT/texture_shared_exponent.txt # GL_TEXTURE_SHARED_SIZE_EXT +_m[0x8A48] = (1,) # GL_TEXTURE_SRGB_DECODE_EXT +_m[0x0BA5] = (1,) # GL_TEXTURE_STACK_DEPTH +_m[0x88F1] = (1,) # GL_TEXTURE_STENCIL_SIZE +_m[0x85BC] = (1,) # GL_TEXTURE_STORAGE_HINT_APPLE +_m[0x8E45] = (1,) # GL_TEXTURE_SWIZZLE_A +_m[0x8E44] = (1,) # GL_TEXTURE_SWIZZLE_B +_m[0x8E43] = (1,) # GL_TEXTURE_SWIZZLE_G +_m[0x8E42] = (1,) # GL_TEXTURE_SWIZZLE_R +_m[0x8E46] = (4,) # GL_TEXTURE_SWIZZLE_RGBA +_m[0x1006] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/direct_state_access.txt # GL_TEXTURE_TARGET +_m[0x888F] = (1,) # GL_TEXTURE_UNSIGNED_REMAP_MODE_NV +_m[0x82B5] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_TEXTURE_VIEW +_m[0x82DD] = (1,) # GL_TEXTURE_VIEW_MIN_LAYER +_m[0x82DB] = (1,) # GL_TEXTURE_VIEW_MIN_LEVEL +_m[0x82DE] = (1,) # GL_TEXTURE_VIEW_NUM_LAYERS +_m[0x82DC] = (1,) # GL_TEXTURE_VIEW_NUM_LEVELS +_m[0x1000] = (1,) # GL_TEXTURE_WIDTH +_m[0x8137] = (1,) # GL_TEXTURE_WRAP_Q_SGIS +_m[0x8072] = (1,) # GL_TEXTURE_WRAP_R +_m[0x8072] = (1,) # GL_TEXTURE_WRAP_R_EXT +_m[0x2802] = (1,) # GL_TEXTURE_WRAP_S +_m[0x2803] = (1,) # GL_TEXTURE_WRAP_T +_m[0x8200] = (1,) # GL_TEXT_FRAGMENT_SHADER_ATI +_m[0x8E28] = (1,) # GL_TIMESTAMP +_m[0x930C] = (1,) # GL_TOP_LEVEL_ARRAY_SIZE +_m[0x930D] = (1,) # GL_TOP_LEVEL_ARRAY_STRIDE +_m[0x8648] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/vertex_program.txt # GL_TRACK_MATRIX_NV +_m[0x8649] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/vertex_program.txt # GL_TRACK_MATRIX_TRANSFORM_NV +_m[0x8E25] = (1,) # GL_TRANSFORM_FEEDBACK_BINDING +_m[0x8E25] = (1,) # GL_TRANSFORM_FEEDBACK_BINDING_NV +_m[0x8E24] = (1,) # GL_TRANSFORM_FEEDBACK_BUFFER_ACTIVE +_m[0x8E24] = (1,) # GL_TRANSFORM_FEEDBACK_BUFFER_ACTIVE_NV +_m[0x8C8F] = (1,) # GL_TRANSFORM_FEEDBACK_BUFFER_BINDING +_m[0x8C7F] = (1,) # GL_TRANSFORM_FEEDBACK_BUFFER_MODE +_m[0x8C7F] = (1,)#TODO Review http://www.opengl.org/registry/specs//EXT/transform_feedback.txt # GL_TRANSFORM_FEEDBACK_BUFFER_MODE_EXT +_m[0x8C7F] = (1,) # GL_TRANSFORM_FEEDBACK_BUFFER_MODE_NV +_m[0x8E23] = (1,) # GL_TRANSFORM_FEEDBACK_BUFFER_PAUSED +_m[0x8E23] = (1,) # GL_TRANSFORM_FEEDBACK_BUFFER_PAUSED_NV +_m[0x8C85] = (1,) # GL_TRANSFORM_FEEDBACK_BUFFER_SIZE +_m[0x8C84] = (1,) # GL_TRANSFORM_FEEDBACK_BUFFER_START +_m[0x8C83] = (1,) # GL_TRANSFORM_FEEDBACK_VARYINGS +_m[0x8C83] = (1,)#TODO Review http://www.opengl.org/registry/specs//EXT/transform_feedback.txt # GL_TRANSFORM_FEEDBACK_VARYINGS_EXT +_m[0x8C76] = (1,) # GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH +_m[0x8C76] = (1,)#TODO Review http://www.opengl.org/registry/specs//EXT/transform_feedback.txt # GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH_EXT +_m[0x84E6] = (4,4) # GL_TRANSPOSE_COLOR_MATRIX +_m[0x84E6] = (4,4) # GL_TRANSPOSE_COLOR_MATRIX_ARB +_m[0x88B7] = (4, 4) # GL_TRANSPOSE_CURRENT_MATRIX_ARB +_m[0x84E3] = (4,4) # GL_TRANSPOSE_MODELVIEW_MATRIX +_m[0x84E3] = (4,4) # GL_TRANSPOSE_MODELVIEW_MATRIX_ARB +_m[0x8E2E] = (1,)#TODO Review http://www.opengl.org/registry/specs//EXT/direct_state_access.txt # GL_TRANSPOSE_PROGRAM_MATRIX_EXT +_m[0x84E4] = (4,4) # GL_TRANSPOSE_PROJECTION_MATRIX +_m[0x84E4] = (4,4) # GL_TRANSPOSE_PROJECTION_MATRIX_ARB +_m[0x84E5] = (4,4) # GL_TRANSPOSE_TEXTURE_MATRIX +_m[0x84E5] = (4,4) # GL_TRANSPOSE_TEXTURE_MATRIX_ARB +_m[0x92FA] = (1,) # GL_TYPE +_m[0x8A3C] = (1,) # GL_UNIFORM_ARRAY_STRIDE +_m[0x92DA] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/shader_atomic_counters.txt # GL_UNIFORM_ATOMIC_COUNTER_BUFFER_INDEX +_m[0x8A42] = (1,) # GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS +_m[0x8A43] = (1,) # GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES +_m[0x8A3F] = (1,) # GL_UNIFORM_BLOCK_BINDING +_m[0x8A40] = (1,) # GL_UNIFORM_BLOCK_DATA_SIZE +_m[0x8A3A] = (1,) # GL_UNIFORM_BLOCK_INDEX +_m[0x8A41] = (1,) # GL_UNIFORM_BLOCK_NAME_LENGTH +_m[0x90EC] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/compute_shader.txt # GL_UNIFORM_BLOCK_REFERENCED_BY_COMPUTE_SHADER +_m[0x8A46] = (1,) # GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER +_m[0x8A45] = (1,) # GL_UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER +_m[0x959C] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_UNIFORM_BLOCK_REFERENCED_BY_MESH_SHADER_NV +_m[0x959D] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_UNIFORM_BLOCK_REFERENCED_BY_TASK_SHADER_NV +_m[0x84F0] = (1,) # GL_UNIFORM_BLOCK_REFERENCED_BY_TESS_CONTROL_SHADER +_m[0x84F1] = (1,) # GL_UNIFORM_BLOCK_REFERENCED_BY_TESS_EVALUATION_SHADER +_m[0x8A44] = (1,) # GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER +_m[0x8A28] = (1,) # GL_UNIFORM_BUFFER_BINDING +_m[0x8DEF] = (1,) # GL_UNIFORM_BUFFER_BINDING_EXT +_m[0x8A34] = (1,) # GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT +_m[0x8A2A] = (1,) # GL_UNIFORM_BUFFER_SIZE +_m[0x8A29] = (1,) # GL_UNIFORM_BUFFER_START +_m[0x8A3E] = (1,) # GL_UNIFORM_IS_ROW_MAJOR +_m[0x8A3D] = (1,) # GL_UNIFORM_MATRIX_STRIDE +_m[0x8A39] = (1,) # GL_UNIFORM_NAME_LENGTH +_m[0x8A3B] = (1,) # GL_UNIFORM_OFFSET +_m[0x8A38] = (1,) # GL_UNIFORM_SIZE +_m[0x8A37] = (1,) # GL_UNIFORM_TYPE +_m[0x0CF5] = (1,) # GL_UNPACK_ALIGNMENT +_m[0x85B2] = (1,) # GL_UNPACK_CLIENT_STORAGE_APPLE +_m[0x800F] = (1,) # GL_UNPACK_CMYK_HINT_EXT +_m[0x9129] = (1,) # GL_UNPACK_COMPRESSED_BLOCK_DEPTH +_m[0x9128] = (1,) # GL_UNPACK_COMPRESSED_BLOCK_HEIGHT +_m[0x912A] = (1,) # GL_UNPACK_COMPRESSED_BLOCK_SIZE +_m[0x9127] = (1,) # GL_UNPACK_COMPRESSED_BLOCK_WIDTH +_m[0x8133] = (1,) # GL_UNPACK_IMAGE_DEPTH_SGIS +_m[0x806E] = (1,) # GL_UNPACK_IMAGE_HEIGHT +_m[0x806E] = (1,) # GL_UNPACK_IMAGE_HEIGHT_EXT +_m[0x0CF1] = (1,) # GL_UNPACK_LSB_FIRST +_m[0x8985] = (1,) # GL_UNPACK_RESAMPLE_OML +_m[0x842F] = (1,) # GL_UNPACK_RESAMPLE_SGIX +_m[0x8A16] = (1,) # GL_UNPACK_ROW_BYTES_APPLE +_m[0x0CF2] = (1,) # GL_UNPACK_ROW_LENGTH +_m[0x806D] = (1,) # GL_UNPACK_SKIP_IMAGES +_m[0x806D] = (1,) # GL_UNPACK_SKIP_IMAGES_EXT +_m[0x0CF4] = (1,) # GL_UNPACK_SKIP_PIXELS +_m[0x0CF3] = (1,) # GL_UNPACK_SKIP_ROWS +_m[0x8132] = (1,) # GL_UNPACK_SKIP_VOLUMES_SGIS +_m[0x0CF0] = (1,) # GL_UNPACK_SWAP_BYTES +_m[0x954A] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NVX/NVX_gpu_multicast2.txt # GL_UPLOAD_GPU_MASK_NVX +_m[0x8B83] = (1,) # GL_VALIDATE_STATUS +_m[0x87E9] = (1,)#TODO Review http://www.opengl.org/registry/specs//EXT/vertex_shader.txt # GL_VARIANT_ARRAY_POINTER_EXT +_m[0x87E7] = (1,) # GL_VARIANT_ARRAY_TYPE_EXT +_m[0x87FB] = (1,) # GL_VBO_FREE_MEMORY_ATI +_m[0x1F00] = (1,) # GL_VENDOR +_m[0x1F02] = (1,) # GL_VERSION +_m[0x8074] = (1,) # GL_VERTEX_ARRAY +_m[0x85B5] = (1,) # GL_VERTEX_ARRAY_BINDING +_m[0x85B5] = (1,) # GL_VERTEX_ARRAY_BINDING_APPLE +_m[0x8896] = (1,) # GL_VERTEX_ARRAY_BUFFER_BINDING +_m[0x8896] = (1,) # GL_VERTEX_ARRAY_BUFFER_BINDING_ARB +_m[0x807D] = (1,) # GL_VERTEX_ARRAY_COUNT_EXT +_m[0x8074] = (1,) # GL_VERTEX_ARRAY_EXT +_m[0x8F2B] = (1,) # GL_VERTEX_ARRAY_LENGTH_NV +_m[0x83F5] = (1,)#TODO Review http://www.opengl.org/registry/specs//INTEL/parallel_arrays.txt # GL_VERTEX_ARRAY_PARALLEL_POINTERS_INTEL +_m[0x808E] = (1,) # GL_VERTEX_ARRAY_POINTER +_m[0x851E] = (1,) # GL_VERTEX_ARRAY_RANGE_LENGTH_APPLE +_m[0x851E] = (1,) # GL_VERTEX_ARRAY_RANGE_LENGTH_NV +_m[0x851D] = (1,) # GL_VERTEX_ARRAY_RANGE_NV +_m[0x8521] = (1,) # GL_VERTEX_ARRAY_RANGE_POINTER_NV +_m[0x851F] = (1,) # GL_VERTEX_ARRAY_RANGE_VALID_NV +_m[0x807A] = (1,) # GL_VERTEX_ARRAY_SIZE +_m[0x807A] = (1,) # GL_VERTEX_ARRAY_SIZE_EXT +_m[0x807C] = (1,) # GL_VERTEX_ARRAY_STRIDE +_m[0x807C] = (1,) # GL_VERTEX_ARRAY_STRIDE_EXT +_m[0x807B] = (1,) # GL_VERTEX_ARRAY_TYPE +_m[0x807B] = (1,) # GL_VERTEX_ARRAY_TYPE_EXT +_m[0x8650] = (1,) # GL_VERTEX_ATTRIB_ARRAY0_NV +_m[0x865A] = (1,) # GL_VERTEX_ATTRIB_ARRAY10_NV +_m[0x865B] = (1,) # GL_VERTEX_ATTRIB_ARRAY11_NV +_m[0x865C] = (1,) # GL_VERTEX_ATTRIB_ARRAY12_NV +_m[0x865D] = (1,) # GL_VERTEX_ATTRIB_ARRAY13_NV +_m[0x865E] = (1,) # GL_VERTEX_ATTRIB_ARRAY14_NV +_m[0x865F] = (1,) # GL_VERTEX_ATTRIB_ARRAY15_NV +_m[0x8651] = (1,) # GL_VERTEX_ATTRIB_ARRAY1_NV +_m[0x8652] = (1,) # GL_VERTEX_ATTRIB_ARRAY2_NV +_m[0x8653] = (1,) # GL_VERTEX_ATTRIB_ARRAY3_NV +_m[0x8654] = (1,) # GL_VERTEX_ATTRIB_ARRAY4_NV +_m[0x8655] = (1,) # GL_VERTEX_ATTRIB_ARRAY5_NV +_m[0x8656] = (1,) # GL_VERTEX_ATTRIB_ARRAY6_NV +_m[0x8657] = (1,) # GL_VERTEX_ATTRIB_ARRAY7_NV +_m[0x8658] = (1,) # GL_VERTEX_ATTRIB_ARRAY8_NV +_m[0x8659] = (1,) # GL_VERTEX_ATTRIB_ARRAY9_NV +_m[0x889F] = (1,) # GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING +_m[0x889F] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/vertex_buffer_object.txt # GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING_ARB +_m[0x88FE] = (1,) # GL_VERTEX_ATTRIB_ARRAY_DIVISOR +_m[0x8622] = (1,) # GL_VERTEX_ATTRIB_ARRAY_ENABLED +_m[0x88FD] = (1,) # GL_VERTEX_ATTRIB_ARRAY_INTEGER +_m[0x874E] = (1,) # GL_VERTEX_ATTRIB_ARRAY_LONG +_m[0x886A] = (1,) # GL_VERTEX_ATTRIB_ARRAY_NORMALIZED +_m[0x8645] = (1,) # GL_VERTEX_ATTRIB_ARRAY_POINTER +_m[0x8623] = (1,) # GL_VERTEX_ATTRIB_ARRAY_SIZE +_m[0x8624] = (1,) # GL_VERTEX_ATTRIB_ARRAY_STRIDE +_m[0x8625] = (1,) # GL_VERTEX_ATTRIB_ARRAY_TYPE +_m[0x82D4] = (1,) # GL_VERTEX_ATTRIB_BINDING +_m[0x82D5] = (1,) # GL_VERTEX_ATTRIB_RELATIVE_OFFSET +_m[0x82D6] = (1,) # GL_VERTEX_BINDING_DIVISOR +_m[0x82D7] = (1,) # GL_VERTEX_BINDING_OFFSET +_m[0x82D8] = (1,) # GL_VERTEX_BINDING_STRIDE +_m[0x86A7] = (1,) # GL_VERTEX_BLEND_ARB +_m[0x83EF] = (1,) # GL_VERTEX_PRECLIP_HINT_SGIX +_m[0x83EE] = (1,) # GL_VERTEX_PRECLIP_SGIX +_m[0x8620] = (1,) # GL_VERTEX_PROGRAM_ARB +_m[0x864A] = (1,) # GL_VERTEX_PROGRAM_BINDING_NV +_m[0x8620] = (1,) # GL_VERTEX_PROGRAM_NV +_m[0x8DA2] = (1,) # GL_VERTEX_PROGRAM_PARAMETER_BUFFER_NV +_m[0x8642] = (1,) # GL_VERTEX_PROGRAM_POINT_SIZE +_m[0x8642] = (1,) # GL_VERTEX_PROGRAM_POINT_SIZE_ARB +_m[0x8642] = (1,) # GL_VERTEX_PROGRAM_POINT_SIZE_NV +_m[0x8643] = (1,) # GL_VERTEX_PROGRAM_TWO_SIDE +_m[0x8643] = (1,) # GL_VERTEX_PROGRAM_TWO_SIDE_ARB +_m[0x8643] = (1,) # GL_VERTEX_PROGRAM_TWO_SIDE_NV +_m[0x8B31] = (1,) # GL_VERTEX_SHADER +_m[0x8781] = (1,) # GL_VERTEX_SHADER_BINDING_EXT +_m[0x8780] = (1,) # GL_VERTEX_SHADER_EXT +_m[0x87CF] = (1,) # GL_VERTEX_SHADER_INSTRUCTIONS_EXT +_m[0x87D1] = (1,) # GL_VERTEX_SHADER_INVARIANTS_EXT +_m[0x87D3] = (1,) # GL_VERTEX_SHADER_LOCALS_EXT +_m[0x87D2] = (1,) # GL_VERTEX_SHADER_LOCAL_CONSTANTS_EXT +_m[0x87D4] = (1,) # GL_VERTEX_SHADER_OPTIMIZED_EXT +_m[0x87D0] = (1,) # GL_VERTEX_SHADER_VARIANTS_EXT +_m[0x829B] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_VERTEX_TEXTURE +_m[0x850C] = (1,) # GL_VERTEX_WEIGHT_ARRAY_EXT +_m[0x8510] = (1,) # GL_VERTEX_WEIGHT_ARRAY_POINTER_EXT +_m[0x850D] = (1,) # GL_VERTEX_WEIGHT_ARRAY_SIZE_EXT +_m[0x850F] = (1,) # GL_VERTEX_WEIGHT_ARRAY_STRIDE_EXT +_m[0x850E] = (1,) # GL_VERTEX_WEIGHT_ARRAY_TYPE_EXT +_m[0x8719] = (1,) # GL_VIBRANCE_BIAS_NV +_m[0x8713] = (1,) # GL_VIBRANCE_SCALE_NV +_m[0x9021] = (1,) # GL_VIDEO_BUFFER_BINDING_NV +_m[0x0BA2] = (4,) # GL_VIEWPORT +_m[0x825D] = (2,) # GL_VIEWPORT_BOUNDS_RANGE +_m[0x825F] = (1,) # GL_VIEWPORT_INDEX_PROVOKING_VERTEX +_m[0x937D] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_clip_space_w_scaling.txt # GL_VIEWPORT_POSITION_W_SCALE_X_COEFF_NV +_m[0x937E] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_clip_space_w_scaling.txt # GL_VIEWPORT_POSITION_W_SCALE_Y_COEFF_NV +_m[0x825C] = (1,) # GL_VIEWPORT_SUBPIXEL_BITS +_m[0x935B] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_viewport_swizzle.txt # GL_VIEWPORT_SWIZZLE_W_NV +_m[0x9358] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_viewport_swizzle.txt # GL_VIEWPORT_SWIZZLE_X_NV +_m[0x9359] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_viewport_swizzle.txt # GL_VIEWPORT_SWIZZLE_Y_NV +_m[0x935A] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_viewport_swizzle.txt # GL_VIEWPORT_SWIZZLE_Z_NV +_m[0x82B6] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_VIEW_COMPATIBILITY_CLASS +_m[0x933A] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/shader_thread_group.txt # GL_WARPS_PER_SM_NV +_m[0x9339] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/shader_thread_group.txt # GL_WARP_SIZE_NV +_m[0x86AD] = (1,) # GL_WEIGHT_ARRAY_ARB +_m[0x889E] = (1,) # GL_WEIGHT_ARRAY_BUFFER_BINDING +_m[0x889E] = (1,) # GL_WEIGHT_ARRAY_BUFFER_BINDING_ARB +_m[0x86AC] = (1,) # GL_WEIGHT_ARRAY_POINTER_ARB +_m[0x86AC] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/OES/OES_matrix_palette.txt # GL_WEIGHT_ARRAY_POINTER_OES +_m[0x86AB] = (1,) # GL_WEIGHT_ARRAY_SIZE_ARB +_m[0x86AB] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/OES/OES_matrix_palette.txt # GL_WEIGHT_ARRAY_SIZE_OES +_m[0x86AA] = (1,) # GL_WEIGHT_ARRAY_STRIDE_ARB +_m[0x86AA] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/OES/OES_matrix_palette.txt # GL_WEIGHT_ARRAY_STRIDE_OES +_m[0x86A9] = (1,) # GL_WEIGHT_ARRAY_TYPE_ARB +_m[0x86A9] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/OES/OES_matrix_palette.txt # GL_WEIGHT_ARRAY_TYPE_OES +_m[0x86A6] = (1,) # GL_WEIGHT_SUM_UNITY_ARB +_m[0x8F12] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/EXT/EXT_window_rectangles.txt # GL_WINDOW_RECTANGLE_EXT +_m[0x8F13] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/EXT/EXT_window_rectangles.txt # GL_WINDOW_RECTANGLE_MODE_EXT +_m[0x887A] = (1,) # GL_WRITE_PIXEL_DATA_RANGE_LENGTH_NV +_m[0x887C] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/pixel_data_range.txt # GL_WRITE_PIXEL_DATA_RANGE_POINTER_NV +_m[0x0D16] = (1,) # GL_ZOOM_X +_m[0x0D17] = (1,) # GL_ZOOM_Y diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/_lookupint.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/_lookupint.py new file mode 100644 index 00000000..2df4d817 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/_lookupint.py @@ -0,0 +1,28 @@ +"""Integer values looked up via glGetIntegerv( constant )""" +import ctypes +_get = None +_get_float = None + +class LookupInt( object ): + def __init__( self, lookup, format=ctypes.c_int, calculation=None ): + self.lookup = lookup + self.format = format + self.calculation = calculation + def __int__( self ): + global _get + if _get is None: + from OpenGL.GL import glGetIntegerv + _get = glGetIntegerv + output = self.format() + _get( self.lookup, output ) + if self.calculation: + return self.calculation( output.value ) + return output.value + __long__ = __int__ + def __eq__( self, other ): + return int(self) == other + def __cmp__( self, other ): + return cmp( int(self), other ) + def __str__(self): + return str(int(self)) + __repr__ = __str__ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GL/_types.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/_types.py new file mode 100644 index 00000000..ed4a0796 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GL/_types.py @@ -0,0 +1,173 @@ +"""OpenGL-wide constant types (not OpenGL.GL-specific) + +These are basically the fundamental data-types that OpenGL +uses (note, doesn't include the OpenGL-ES types!) +""" +import ctypes +from OpenGL.constant import Constant +from OpenGL._bytes import bytes,unicode,as_8_bit, long +assert unicode +assert as_8_bit +from OpenGL._opaque import opaque_pointer_cls as _opaque_pointer_cls + +sizeof = ctypes.sizeof +GL_FALSE = Constant( 'GL_FALSE', 0x0 ) +GL_TRUE = Constant( 'GL_TRUE', 0x1 ) +GL_BYTE = Constant( 'GL_BYTE', 0x1400 ) +GL_UNSIGNED_BYTE = Constant( 'GL_UNSIGNED_BYTE', 0x1401 ) +GL_SHORT = Constant( 'GL_SHORT', 0x1402 ) +GL_UNSIGNED_SHORT = Constant( 'GL_UNSIGNED_SHORT', 0x1403 ) +GL_INT = Constant( 'GL_INT', 0x1404 ) +GL_UNSIGNED_INT = Constant( 'GL_UNSIGNED_INT', 0x1405 ) +GL_UNSIGNED_INT64 = Constant( 'GL_UNSIGNED_INT64_AMD', 0x8BC2 ) +GL_FLOAT = Constant( 'GL_FLOAT', 0x1406 ) +GL_DOUBLE = Constant( 'GL_DOUBLE', 0x140a ) +GL_CHAR = bytes +GL_HALF_FLOAT = Constant( 'GL_HALF_FLOAT_ARB',0x140B) +GL_HALF_NV = Constant( 'GL_HALF_NV', 0x1401 ) +GL_FIXED=Constant('GL_FIXED',0x140C) +GL_VOID_P = object() + +def _get_ctypes_version(): + return [int(i) for i in ctypes.__version__.split('.')[:3]] +ctypes_version = _get_ctypes_version() + +# Basic OpenGL data-types as ctypes declarations... +def _defineType( name, baseType, convertFunc = long ): + from OpenGL import _configflags + do_wrapping = ( + _configflags.ALLOW_NUMPY_SCALARS or # explicitly require + (( # or we are using Python 2.5.x ctypes which doesn't support uint type numpy scalars + ctypes_version < [1,1,0] + and baseType in (ctypes.c_uint,ctypes.c_uint64,ctypes.c_ulong,ctypes.c_ushort) + ) or + ( # or we are using Python 2.5.x (x < 2) ctypes which doesn't support any numpy int scalars + ctypes_version < [1,0,2] + and baseType in (ctypes.c_int,ctypes.c_int64,ctypes.c_long,ctypes.c_short) + )) + ) + if do_wrapping: + original = baseType.from_param + if not getattr( original, 'from_param_numpy_scalar', False ): + def from_param( x, typeCode=None ): + try: + return original( x ) + except TypeError as err: + try: + return original( convertFunc(x) ) + except TypeError: + raise err + from_param = staticmethod( from_param ) + setattr( baseType, 'from_param', from_param ) + baseType.from_param_numpy_scalar = True + return baseType + else: + return baseType + +GLvoid = None +GLboolean = _defineType( 'GLboolean', ctypes.c_ubyte, bool ) +GLenum = _defineType( 'GLenum', ctypes.c_uint ) + +GLfloat = _defineType( 'GLfloat', ctypes.c_float, float ) +GLfloat_2 = GLfloat * 2 +GLfloat_3 = GLfloat * 3 +GLfloat_4 = GLfloat * 4 +GLdouble = _defineType( 'GLdouble', ctypes.c_double, float ) +GLdouble_2 = GLdouble * 2 +GLdouble_3 = GLdouble * 3 +GLdouble_4 = GLdouble * 4 + +GLbyte = ctypes.c_byte +GLshort = _defineType( 'GLshort', ctypes.c_short, int ) +GLint = _defineType( 'GLint', ctypes.c_int, int ) +GLuint = _defineType( 'GLuint', ctypes.c_uint, long ) +GLfixed = _defineType('GLfixed', ctypes.c_int32, int ) +GLclampx = _defineType('GLclampx', ctypes.c_int32, int ) + +# This is explicitly called out as equivalent to a uint +GLsizei = _defineType( 'GLsizei', ctypes.c_uint, long ) +# Signed 2's complement binary integer with sizeof( void * ) +GLintptr = _defineType( 'GLintptr', ctypes.c_ssize_t, int ) +# Unsigned size-of-x +GLsizeiptr = _defineType( 'GLsizeiptr', ctypes.c_size_t, int ) + +GLubyte = ctypes.c_ubyte +GLubyte_3 = GLubyte * 3 +GLushort = _defineType( 'GLushort', ctypes.c_ushort, int ) +GLulong = _defineType( 'GLulong', ctypes.c_ulong, int ) +GLhandleARB = _defineType( 'GLhandleARB', ctypes.c_uint, long ) +GLhandle = _defineType( 'GLhandle', ctypes.c_uint, long ) + +GLchar = GLcharARB = ctypes.c_char + +GLbitfield = _defineType( 'GLbitfield', ctypes.c_uint, long ) + +GLclampd = _defineType( 'GLclampd', ctypes.c_double, float ) +GLclampf = _defineType( 'GLclampf', ctypes.c_float, float ) + +GLuint64 = GLuint64EXT = _defineType('GLuint64', ctypes.c_uint64, long ) +GLint64 = GLint64EXT = _defineType('GLint64', ctypes.c_int64, long ) + +# ptrdiff_t, actually... +GLsizeiptrARB = GLsizeiptr +GLvdpauSurfaceNV = GLintptrARB = GLintptr +size_t = ctypes.c_size_t +int32_t = ctypes.c_int32 +int64_t = ctypes.c_int64 + +void = None + +# this is *wrong*, half is a *float* type, but ctypes doesn't have 16-bit float support +GLhalfNV = GLhalfARB = ctypes.c_ushort + +# GL.ARB.sync extension, GLsync is an opaque pointer to a struct +# in the extensions header, basically just a "token" that can be +# passed to the various operations... +GLsync = _opaque_pointer_cls( 'GLsync' ) +GLvoidp = ctypes.c_void_p + +ARRAY_TYPE_TO_CONSTANT = [ + ('GLclampd', GL_DOUBLE), + ('GLclampf', GL_FLOAT), + ('GLfloat', GL_FLOAT), + ('GLdouble', GL_DOUBLE), + ('GLbyte', GL_BYTE), + ('GLshort', GL_SHORT), + ('GLint', GL_INT), + ('GLubyte', GL_UNSIGNED_BYTE), + ('GLushort', GL_UNSIGNED_SHORT), + ('GLuint', GL_UNSIGNED_INT), + ('GLenum', GL_UNSIGNED_INT), +] + +from OpenGL.platform import PLATFORM as _p + +GLDEBUGPROCARB = GLDEBUGPROCKHR = GLDEBUGPROC = _p.DEFAULT_FUNCTION_TYPE( + void, + GLenum, # source, + GLenum, #type, + GLuint, # id + GLenum, # severity + GLsizei, # length + ctypes.c_char_p, # message + GLvoidp, # userParam +) + +class _cl_context( ctypes.Structure ): + """Placeholder/empty structure for _cl_context""" +class _cl_event( ctypes.Structure ): + """Placeholder/empty structure for _cl_event""" + +GLDEBUGPROCAMD = _p.DEFAULT_FUNCTION_TYPE( + void, + GLuint,# id, + GLenum,# category, + GLenum,# severity, + GLsizei,# length, + ctypes.c_char_p,# message, + GLvoidp,# userParam +) + +GLeglImageOES = GLvoidp +c_int = ctypes.c_int + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLE/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLE/__init__.py new file mode 100644 index 00000000..c308ff8c --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLE/__init__.py @@ -0,0 +1,298 @@ +# -*- coding: iso-8859-1 -*- +"""Raw (C-style) API for OpenGL.GLE + +Automatically generated by the generateraw script, do not edit! +""" +from OpenGL.raw.GLE.constants import * + +from ctypes import * +from OpenGL import platform, arrays +from OpenGL.constant import Constant +from OpenGL.raw.GL import _types as GL_types +GLvoid = GL_types.GLvoid + + + + +gleDouble = c_double +gleAffine = gleDouble * 3 * 2 + + +# /usr/include/GL/gle.h 136 +gleExtrusion = platform.createBaseFunction( + 'gleExtrusion', dll=platform.PLATFORM.GLE, resultType=None, + argTypes=[c_int,arrays.GLdoubleArray,arrays.GLdoubleArray,arrays.GLdoubleArray,c_int,arrays.GLdoubleArray,arrays.GLfloatArray], + doc='gleExtrusion( c_int(ncp), arrays.GLdoubleArray(contour), arrays.GLdoubleArray(cont_normal), arrays.GLdoubleArray(up), c_int(npoints), arrays.GLdoubleArray(point_array), arrays.GLfloatArray(color_array) ) -> None', + argNames=('ncp', 'contour', 'cont_normal', 'up', 'npoints', 'point_array', 'color_array'), +) + + +# /usr/include/GL/gle.h 110 +gleGetJoinStyle = platform.createBaseFunction( + 'gleGetJoinStyle', dll=platform.PLATFORM.GLE, resultType=c_int, + argTypes=[], + doc='gleGetJoinStyle( ) -> c_int', + argNames=(), +) + + +# /usr/include/GL/gle.h 114 +gleGetNumSides = platform.createBaseFunction( + 'gleGetNumSides', dll=platform.PLATFORM.GLE, resultType=c_int, + argTypes=[], + doc='gleGetNumSides( ) -> c_int', + argNames=(), +) + + +# /usr/include/GL/gle.h 195 +gleHelicoid = platform.createBaseFunction( + 'gleHelicoid', dll=platform.PLATFORM.GLE, resultType=None, + argTypes=[gleDouble,gleDouble,gleDouble,gleDouble,gleDouble,arrays.GLdoubleArray,arrays.GLdoubleArray,gleDouble,gleDouble], + doc='gleHelicoid( gleDouble(rToroid), gleDouble(startRadius), gleDouble(drdTheta), gleDouble(startZ), gleDouble(dzdTheta), arrays.GLdoubleArray(startXform), arrays.GLdoubleArray(dXformdTheta), gleDouble(startTheta), gleDouble(sweepTheta) ) -> None', + argNames=('rToroid', 'startRadius', 'drdTheta', 'startZ', 'dzdTheta', 'startXform', 'dXformdTheta', 'startTheta', 'sweepTheta'), +) + + +# /usr/include/GL/gle.h 184 +gleLathe = platform.createBaseFunction( + 'gleLathe', dll=platform.PLATFORM.GLE, resultType=None, + argTypes=[c_int,arrays.GLdoubleArray,arrays.GLdoubleArray,arrays.GLdoubleArray,gleDouble,gleDouble,gleDouble,gleDouble,arrays.GLdoubleArray,arrays.GLdoubleArray,gleDouble,gleDouble], + doc='gleLathe( c_int(ncp), arrays.GLdoubleArray(contour), arrays.GLdoubleArray(cont_normal), arrays.GLdoubleArray(up), gleDouble(startRadius), gleDouble(drdTheta), gleDouble(startZ), gleDouble(dzdTheta), arrays.GLdoubleArray(startXform), arrays.GLdoubleArray(dXformdTheta), gleDouble(startTheta), gleDouble(sweepTheta) ) -> None', + argNames=('ncp', 'contour', 'cont_normal', 'up', 'startRadius', 'drdTheta', 'startZ', 'dzdTheta', 'startXform', 'dXformdTheta', 'startTheta', 'sweepTheta'), +) + + +# /usr/include/GL/gle.h 127 +glePolyCone = platform.createBaseFunction( + 'glePolyCone', dll=platform.PLATFORM.GLE, resultType=None, + argTypes=[c_int,arrays.GLdoubleArray,arrays.GLfloatArray,arrays.GLdoubleArray], + doc='glePolyCone( c_int(npoints), arrays.GLdoubleArray(point_array), arrays.GLfloatArray(color_array), arrays.GLdoubleArray(radius_array) ) -> None', + argNames=('npoints', 'point_array', 'color_array', 'radius_array'), +) + + +# /usr/include/GL/gle.h 121 +glePolyCylinder = platform.createBaseFunction( + 'glePolyCylinder', dll=platform.PLATFORM.GLE, resultType=None, + argTypes=[c_int,arrays.GLdoubleArray,arrays.GLfloatArray,gleDouble], + doc='glePolyCylinder( c_int(npoints), arrays.GLdoubleArray(point_array), arrays.GLfloatArray(color_array), gleDouble(radius) ) -> None', + argNames=('npoints', 'point_array', 'color_array', 'radius'), +) + + +# /usr/include/GL/gle.h 215 +gleScrew = platform.createBaseFunction( + 'gleScrew', dll=platform.PLATFORM.GLE, resultType=None, + argTypes=[c_int,arrays.GLdoubleArray,arrays.GLdoubleArray,arrays.GLdoubleArray,gleDouble,gleDouble,gleDouble], + doc='gleScrew( c_int(ncp), arrays.GLdoubleArray(contour), arrays.GLdoubleArray(cont_normal), arrays.GLdoubleArray(up), gleDouble(startz), gleDouble(endz), gleDouble(twist) ) -> None', + argNames=('ncp', 'contour', 'cont_normal', 'up', 'startz', 'endz', 'twist'), +) + +# /usr/include/GL/gle.h 111 +gleSetJoinStyle = platform.createBaseFunction( + 'gleSetJoinStyle', dll=platform.PLATFORM.GLE, resultType=None, + argTypes=[c_int], + doc='gleSetJoinStyle( c_int(style) ) -> None', + argNames=('style',), +) + + +# /usr/include/GL/gle.h 115 +gleSetNumSides = platform.createBaseFunction( + 'gleSetNumSides', dll=platform.PLATFORM.GLE, resultType=None, + argTypes=[c_int], + doc='gleSetNumSides( c_int(slices) ) -> None', + argNames=('slices',), +) + + +# /usr/include/GL/gle.h 170 +gleSpiral = platform.createBaseFunction( + 'gleSpiral', dll=platform.PLATFORM.GLE, resultType=None, + argTypes=[c_int,arrays.GLdoubleArray,arrays.GLdoubleArray,arrays.GLdoubleArray,gleDouble,gleDouble,gleDouble,gleDouble,arrays.GLdoubleArray,arrays.GLdoubleArray,gleDouble,gleDouble], + doc='gleSpiral( c_int(ncp), arrays.GLdoubleArray(contour), arrays.GLdoubleArray(cont_normal), arrays.GLdoubleArray(up), gleDouble(startRadius), gleDouble(drdTheta), gleDouble(startZ), gleDouble(dzdTheta), arrays.GLdoubleArray(startXform), arrays.GLdoubleArray(dXformdTheta), gleDouble(startTheta), gleDouble(sweepTheta) ) -> None', + argNames=('ncp', 'contour', 'cont_normal', 'up', 'startRadius', 'drdTheta', 'startZ', 'dzdTheta', 'startXform', 'dXformdTheta', 'startTheta', 'sweepTheta'), +) + + +# /usr/include/GL/gle.h 156 +gleSuperExtrusion = platform.createBaseFunction( + 'gleSuperExtrusion', dll=platform.PLATFORM.GLE, resultType=None, + argTypes=[c_int,arrays.GLdoubleArray,arrays.GLdoubleArray,arrays.GLdoubleArray,c_int,arrays.GLdoubleArray,arrays.GLfloatArray,arrays.GLdoubleArray], + doc='gleSuperExtrusion( c_int(ncp), arrays.GLdoubleArray(contour), arrays.GLdoubleArray(cont_normal), arrays.GLdoubleArray(up), c_int(npoints), arrays.GLdoubleArray(point_array), arrays.GLfloatArray(color_array), arrays.GLdoubleArray(xform_array) ) -> None', + argNames=('ncp', 'contour', 'cont_normal', 'up', 'npoints', 'point_array', 'color_array', 'xform_array'), +) + + +# /usr/include/GL/gle.h 217 +gleTextureMode = platform.createBaseFunction( + 'gleTextureMode', dll=platform.PLATFORM.GLE, resultType=None, + argTypes=[c_int], + doc='gleTextureMode( c_int(mode) ) -> None', + argNames=('mode',), +) + + +# /usr/include/GL/gle.h 206 +gleToroid = platform.createBaseFunction( + 'gleToroid', dll=platform.PLATFORM.GLE, resultType=None, + argTypes=[gleDouble,gleDouble,gleDouble,gleDouble,gleDouble,arrays.GLdoubleArray,arrays.GLdoubleArray,gleDouble,gleDouble], + doc='gleToroid( gleDouble(rToroid), gleDouble(startRadius), gleDouble(drdTheta), gleDouble(startZ), gleDouble(dzdTheta), arrays.GLdoubleArray(startXform), arrays.GLdoubleArray(dXformdTheta), gleDouble(startTheta), gleDouble(sweepTheta) ) -> None', + argNames=('rToroid', 'startRadius', 'drdTheta', 'startZ', 'dzdTheta', 'startXform', 'dXformdTheta', 'startTheta', 'sweepTheta'), +) + + +# /usr/include/GL/gle.h 146 +gleTwistExtrusion = platform.createBaseFunction( + 'gleTwistExtrusion', dll=platform.PLATFORM.GLE, resultType=None, + argTypes=[c_int,arrays.GLdoubleArray,arrays.GLdoubleArray,arrays.GLdoubleArray,c_int,arrays.GLdoubleArray,arrays.GLfloatArray,arrays.GLdoubleArray], + doc='gleTwistExtrusion( c_int(ncp), arrays.GLdoubleArray(contour), arrays.GLdoubleArray(cont_normal), arrays.GLdoubleArray(up), c_int(npoints), arrays.GLdoubleArray(point_array), arrays.GLfloatArray(color_array), arrays.GLdoubleArray(twist_array) ) -> None', + argNames=('ncp', 'contour', 'cont_normal', 'up', 'npoints', 'point_array', 'color_array', 'twist_array'), +) + + +# /usr/include/GL/gle.h 221 +rot_about_axis = platform.createBaseFunction( + 'rot_about_axis', dll=platform.PLATFORM.GLE, resultType=None, + argTypes=[gleDouble,arrays.GLdoubleArray], + doc='rot_about_axis( gleDouble(angle), arrays.GLdoubleArray(axis) ) -> None', + argNames=('angle', 'axis'), +) + + +# /usr/include/GL/gle.h 220 +rot_axis = platform.createBaseFunction( + 'rot_axis', dll=platform.PLATFORM.GLE, resultType=None, + argTypes=[gleDouble,arrays.GLdoubleArray], + doc='rot_axis( gleDouble(omega), arrays.GLdoubleArray(axis) ) -> None', + argNames=('omega', 'axis'), +) + + +# /usr/include/GL/gle.h 222 +rot_omega = platform.createBaseFunction( + 'rot_omega', dll=platform.PLATFORM.GLE, resultType=None, + argTypes=[arrays.GLdoubleArray], + doc='rot_omega( arrays.GLdoubleArray(axis) ) -> None', + argNames=('axis',), +) + + +# /usr/include/GL/gle.h 223 +rot_prince = platform.createBaseFunction( + 'rot_prince', dll=platform.PLATFORM.GLE, resultType=None, + argTypes=[gleDouble,c_char], + doc='rot_prince( gleDouble(omega), c_char(axis) ) -> None', + argNames=('omega', 'axis'), +) + + +# /usr/include/GL/gle.h 225 +urot_about_axis = platform.createBaseFunction( + 'urot_about_axis', dll=platform.PLATFORM.GLE, resultType=None, + argTypes=[arrays.GLdoubleArray,gleDouble,arrays.GLdoubleArray], + doc='urot_about_axis( arrays.GLdoubleArray(m), gleDouble(angle), arrays.GLdoubleArray(axis) ) -> None', + argNames=('m', 'angle', 'axis'), +) + + +# /usr/include/GL/gle.h 224 +urot_axis = platform.createBaseFunction( + 'urot_axis', dll=platform.PLATFORM.GLE, resultType=None, + argTypes=[arrays.GLdoubleArray,gleDouble,arrays.GLdoubleArray], + doc='urot_axis( arrays.GLdoubleArray(m), gleDouble(omega), arrays.GLdoubleArray(axis) ) -> None', + argNames=('m', 'omega', 'axis'), +) + + +# /usr/include/GL/gle.h 226 +urot_omega = platform.createBaseFunction( + 'urot_omega', dll=platform.PLATFORM.GLE, resultType=None, + argTypes=[arrays.GLdoubleArray,arrays.GLdoubleArray], + doc='urot_omega( arrays.GLdoubleArray(m), arrays.GLdoubleArray(axis) ) -> None', + argNames=('m', 'axis'), +) + + +# /usr/include/GL/gle.h 227 +urot_prince = platform.createBaseFunction( + 'urot_prince', dll=platform.PLATFORM.GLE, resultType=None, + argTypes=[arrays.GLdoubleArray,gleDouble,c_char], + doc='urot_prince( arrays.GLdoubleArray(m), gleDouble(omega), c_char(axis) ) -> None', + argNames=('m', 'omega', 'axis'), +) + + +# /usr/include/GL/gle.h 232 +uview_direction = platform.createBaseFunction( + 'uview_direction', dll=platform.PLATFORM.GLE, resultType=None, + argTypes=[arrays.GLdoubleArray,arrays.GLdoubleArray,arrays.GLdoubleArray], + doc='uview_direction( arrays.GLdoubleArray(m), arrays.GLdoubleArray(v21), arrays.GLdoubleArray(up) ) -> None', + argNames=('m', 'v21', 'up'), +) + + +# /usr/include/GL/gle.h 237 +uviewpoint = platform.createBaseFunction( + 'uviewpoint', dll=platform.PLATFORM.GLE, resultType=None, + argTypes=[arrays.GLdoubleArray,arrays.GLdoubleArray,arrays.GLdoubleArray,arrays.GLdoubleArray], + doc='uviewpoint( arrays.GLdoubleArray(m), arrays.GLdoubleArray(v1), arrays.GLdoubleArray(v2), arrays.GLdoubleArray(up) ) -> None', + argNames=('m', 'v1', 'v2', 'up'), +) + +__all__ = [ + 'GLE_TEXTURE_ENABLE', + 'GLE_TEXTURE_NORMAL_CYL', + 'GLE_TEXTURE_NORMAL_FLAT', + 'GLE_TEXTURE_NORMAL_MODEL_CYL', + 'GLE_TEXTURE_NORMAL_MODEL_FLAT', + 'GLE_TEXTURE_NORMAL_MODEL_SPH', + 'GLE_TEXTURE_NORMAL_SPH', + 'GLE_TEXTURE_STYLE_MASK', + 'GLE_TEXTURE_VERTEX_CYL', + 'GLE_TEXTURE_VERTEX_FLAT', + 'GLE_TEXTURE_VERTEX_MODEL_CYL', + 'GLE_TEXTURE_VERTEX_MODEL_FLAT', + 'GLE_TEXTURE_VERTEX_MODEL_SPH', + 'GLE_TEXTURE_VERTEX_SPH', + 'TUBE_CONTOUR_CLOSED', + 'TUBE_JN_ANGLE', + 'TUBE_JN_CAP', + 'TUBE_JN_CUT', + 'TUBE_JN_MASK', + 'TUBE_JN_RAW', + 'TUBE_JN_ROUND', + 'TUBE_NORM_EDGE', + 'TUBE_NORM_FACET', + 'TUBE_NORM_MASK', + 'TUBE_NORM_PATH_EDGE', + '__GLE_DOUBLE', + 'gleAffine', + 'gleDouble', + 'gleExtrusion', + 'gleGetJoinStyle', + 'gleGetNumSides', + 'gleHelicoid', + 'gleLathe', + 'glePolyCone', + 'glePolyCylinder', + 'gleScrew', + 'gleSetJoinStyle', + 'gleSetNumSides', + 'gleSpiral', + 'gleSuperExtrusion', + 'gleTextureMode', + 'gleToroid', + 'gleTwistExtrusion', + 'rot_about_axis', + 'rot_axis', + 'rot_omega', + 'rot_prince', + 'urot_about_axis', + 'urot_axis', + 'urot_omega', + 'urot_prince', + 'uview_direction', + 'uviewpoint' +] diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLE/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLE/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..f4abb19c Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLE/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLE/__pycache__/annotations.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLE/__pycache__/annotations.cpython-312.pyc new file mode 100644 index 00000000..c0524e64 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLE/__pycache__/annotations.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLE/__pycache__/constants.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLE/__pycache__/constants.cpython-312.pyc new file mode 100644 index 00000000..015b6c75 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLE/__pycache__/constants.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLE/annotations.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLE/annotations.py new file mode 100644 index 00000000..ff8b53b9 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLE/annotations.py @@ -0,0 +1,353 @@ +"""Array-size annotations for OpenGL.raw.GLE + +Automatically generated by the generateraw script, do not edit! +""" +from OpenGL.raw import GLE as raw + +from ctypes import * +from OpenGL import platform, arrays +from OpenGL.constant import Constant +from OpenGL.raw.GL import _types as GL_types +GLvoid = GL_types.GLvoid +STRING = c_char_p + + +gleExtrusion = arrays.setInputArraySizeType( + arrays.setInputArraySizeType( + arrays.setInputArraySizeType( + arrays.setInputArraySizeType( + arrays.setInputArraySizeType( + raw.gleExtrusion, + None, # XXX Could not determine size of argument contour for gleExtrusion arrays.GLdoubleArray + arrays.GLdoubleArray, + 'contour', + ), + None, # XXX Could not determine size of argument cont_normal for gleExtrusion arrays.GLdoubleArray + arrays.GLdoubleArray, + 'cont_normal', + ), + None, # XXX Could not determine size of argument up for gleExtrusion arrays.GLdoubleArray + arrays.GLdoubleArray, + 'up', + ), + None, # XXX Could not determine size of argument point_array for gleExtrusion arrays.GLdoubleArray + arrays.GLdoubleArray, + 'point_array', + ), + None, # XXX Could not determine size of argument color_array for gleExtrusion arrays.GLfloatArray + arrays.GLfloatArray, + 'color_array', +) + +gleHelicoid = arrays.setInputArraySizeType( + arrays.setInputArraySizeType( + raw.gleHelicoid, + None, # XXX Could not determine size of argument startXform for gleHelicoid arrays.GLdoubleArray + arrays.GLdoubleArray, + 'startXform', + ), + None, # XXX Could not determine size of argument dXformdTheta for gleHelicoid arrays.GLdoubleArray + arrays.GLdoubleArray, + 'dXformdTheta', +) + +gleLathe = arrays.setInputArraySizeType( + arrays.setInputArraySizeType( + arrays.setInputArraySizeType( + arrays.setInputArraySizeType( + arrays.setInputArraySizeType( + raw.gleLathe, + None, # XXX Could not determine size of argument contour for gleLathe arrays.GLdoubleArray + arrays.GLdoubleArray, + 'contour', + ), + None, # XXX Could not determine size of argument cont_normal for gleLathe arrays.GLdoubleArray + arrays.GLdoubleArray, + 'cont_normal', + ), + None, # XXX Could not determine size of argument up for gleLathe arrays.GLdoubleArray + arrays.GLdoubleArray, + 'up', + ), + None, # XXX Could not determine size of argument startXform for gleLathe arrays.GLdoubleArray + arrays.GLdoubleArray, + 'startXform', + ), + None, # XXX Could not determine size of argument dXformdTheta for gleLathe arrays.GLdoubleArray + arrays.GLdoubleArray, + 'dXformdTheta', +) + +glePolyCone = arrays.setInputArraySizeType( + arrays.setInputArraySizeType( + arrays.setInputArraySizeType( + raw.glePolyCone, + None, # XXX Could not determine size of argument point_array for glePolyCone arrays.GLdoubleArray + arrays.GLdoubleArray, + 'point_array', + ), + None, # XXX Could not determine size of argument color_array for glePolyCone arrays.GLfloatArray + arrays.GLfloatArray, + 'color_array', + ), + None, # XXX Could not determine size of argument radius_array for glePolyCone arrays.GLdoubleArray + arrays.GLdoubleArray, + 'radius_array', +) + +glePolyCylinder = arrays.setInputArraySizeType( + arrays.setInputArraySizeType( + raw.glePolyCylinder, + None, # XXX Could not determine size of argument point_array for glePolyCylinder arrays.GLdoubleArray + arrays.GLdoubleArray, + 'point_array', + ), + None, # XXX Could not determine size of argument color_array for glePolyCylinder arrays.GLfloatArray + arrays.GLfloatArray, + 'color_array', +) + +gleScrew = arrays.setInputArraySizeType( + arrays.setInputArraySizeType( + arrays.setInputArraySizeType( + raw.gleScrew, + None, # XXX Could not determine size of argument contour for gleScrew arrays.GLdoubleArray + arrays.GLdoubleArray, + 'contour', + ), + None, # XXX Could not determine size of argument cont_normal for gleScrew arrays.GLdoubleArray + arrays.GLdoubleArray, + 'cont_normal', + ), + None, # XXX Could not determine size of argument up for gleScrew arrays.GLdoubleArray + arrays.GLdoubleArray, + 'up', +) + +gleSpiral = arrays.setInputArraySizeType( + arrays.setInputArraySizeType( + arrays.setInputArraySizeType( + arrays.setInputArraySizeType( + arrays.setInputArraySizeType( + raw.gleSpiral, + None, # XXX Could not determine size of argument contour for gleSpiral arrays.GLdoubleArray + arrays.GLdoubleArray, + 'contour', + ), + None, # XXX Could not determine size of argument cont_normal for gleSpiral arrays.GLdoubleArray + arrays.GLdoubleArray, + 'cont_normal', + ), + None, # XXX Could not determine size of argument up for gleSpiral arrays.GLdoubleArray + arrays.GLdoubleArray, + 'up', + ), + None, # XXX Could not determine size of argument startXform for gleSpiral arrays.GLdoubleArray + arrays.GLdoubleArray, + 'startXform', + ), + None, # XXX Could not determine size of argument dXformdTheta for gleSpiral arrays.GLdoubleArray + arrays.GLdoubleArray, + 'dXformdTheta', +) + +gleSuperExtrusion = arrays.setInputArraySizeType( + arrays.setInputArraySizeType( + arrays.setInputArraySizeType( + arrays.setInputArraySizeType( + arrays.setInputArraySizeType( + arrays.setInputArraySizeType( + raw.gleSuperExtrusion, + None, # XXX Could not determine size of argument contour for gleSuperExtrusion arrays.GLdoubleArray + arrays.GLdoubleArray, + 'contour', + ), + None, # XXX Could not determine size of argument cont_normal for gleSuperExtrusion arrays.GLdoubleArray + arrays.GLdoubleArray, + 'cont_normal', + ), + None, # XXX Could not determine size of argument up for gleSuperExtrusion arrays.GLdoubleArray + arrays.GLdoubleArray, + 'up', + ), + None, # XXX Could not determine size of argument point_array for gleSuperExtrusion arrays.GLdoubleArray + arrays.GLdoubleArray, + 'point_array', + ), + None, # XXX Could not determine size of argument color_array for gleSuperExtrusion arrays.GLfloatArray + arrays.GLfloatArray, + 'color_array', + ), + None, # XXX Could not determine size of argument xform_array for gleSuperExtrusion arrays.GLdoubleArray + arrays.GLdoubleArray, + 'xform_array', +) + +gleToroid = arrays.setInputArraySizeType( + arrays.setInputArraySizeType( + raw.gleToroid, + None, # XXX Could not determine size of argument startXform for gleToroid arrays.GLdoubleArray + arrays.GLdoubleArray, + 'startXform', + ), + None, # XXX Could not determine size of argument dXformdTheta for gleToroid arrays.GLdoubleArray + arrays.GLdoubleArray, + 'dXformdTheta', +) + +gleTwistExtrusion = arrays.setInputArraySizeType( + arrays.setInputArraySizeType( + arrays.setInputArraySizeType( + arrays.setInputArraySizeType( + arrays.setInputArraySizeType( + arrays.setInputArraySizeType( + raw.gleTwistExtrusion, + None, # XXX Could not determine size of argument contour for gleTwistExtrusion arrays.GLdoubleArray + arrays.GLdoubleArray, + 'contour', + ), + None, # XXX Could not determine size of argument cont_normal for gleTwistExtrusion arrays.GLdoubleArray + arrays.GLdoubleArray, + 'cont_normal', + ), + None, # XXX Could not determine size of argument up for gleTwistExtrusion arrays.GLdoubleArray + arrays.GLdoubleArray, + 'up', + ), + None, # XXX Could not determine size of argument point_array for gleTwistExtrusion arrays.GLdoubleArray + arrays.GLdoubleArray, + 'point_array', + ), + None, # XXX Could not determine size of argument color_array for gleTwistExtrusion arrays.GLfloatArray + arrays.GLfloatArray, + 'color_array', + ), + None, # XXX Could not determine size of argument twist_array for gleTwistExtrusion arrays.GLdoubleArray + arrays.GLdoubleArray, + 'twist_array', +) + +rot_about_axis = arrays.setInputArraySizeType( + raw.rot_about_axis, + None, # XXX Could not determine size of argument axis for rot_about_axis arrays.GLdoubleArray + arrays.GLdoubleArray, + 'axis', +) + +rot_axis = arrays.setInputArraySizeType( + raw.rot_axis, + None, # XXX Could not determine size of argument axis for rot_axis arrays.GLdoubleArray + arrays.GLdoubleArray, + 'axis', +) + +rot_omega = arrays.setInputArraySizeType( + raw.rot_omega, + None, # XXX Could not determine size of argument axis for rot_omega arrays.GLdoubleArray + arrays.GLdoubleArray, + 'axis', +) + +urot_about_axis = arrays.setInputArraySizeType( + arrays.setInputArraySizeType( + raw.urot_about_axis, + None, # XXX Could not determine size of argument m for urot_about_axis arrays.GLdoubleArray + arrays.GLdoubleArray, + 'm', + ), + None, # XXX Could not determine size of argument axis for urot_about_axis arrays.GLdoubleArray + arrays.GLdoubleArray, + 'axis', +) + +urot_axis = arrays.setInputArraySizeType( + arrays.setInputArraySizeType( + raw.urot_axis, + None, # XXX Could not determine size of argument m for urot_axis arrays.GLdoubleArray + arrays.GLdoubleArray, + 'm', + ), + None, # XXX Could not determine size of argument axis for urot_axis arrays.GLdoubleArray + arrays.GLdoubleArray, + 'axis', +) + +urot_omega = arrays.setInputArraySizeType( + arrays.setInputArraySizeType( + raw.urot_omega, + None, # XXX Could not determine size of argument m for urot_omega arrays.GLdoubleArray + arrays.GLdoubleArray, + 'm', + ), + None, # XXX Could not determine size of argument axis for urot_omega arrays.GLdoubleArray + arrays.GLdoubleArray, + 'axis', +) + +urot_prince = arrays.setInputArraySizeType( + raw.urot_prince, + None, # XXX Could not determine size of argument m for urot_prince arrays.GLdoubleArray + arrays.GLdoubleArray, + 'm', +) + +uview_direction = arrays.setInputArraySizeType( + arrays.setInputArraySizeType( + arrays.setInputArraySizeType( + raw.uview_direction, + None, # XXX Could not determine size of argument m for uview_direction arrays.GLdoubleArray + arrays.GLdoubleArray, + 'm', + ), + None, # XXX Could not determine size of argument v21 for uview_direction arrays.GLdoubleArray + arrays.GLdoubleArray, + 'v21', + ), + None, # XXX Could not determine size of argument up for uview_direction arrays.GLdoubleArray + arrays.GLdoubleArray, + 'up', +) + +uviewpoint = arrays.setInputArraySizeType( + arrays.setInputArraySizeType( + arrays.setInputArraySizeType( + arrays.setInputArraySizeType( + raw.uviewpoint, + None, # XXX Could not determine size of argument m for uviewpoint arrays.GLdoubleArray + arrays.GLdoubleArray, + 'm', + ), + None, # XXX Could not determine size of argument v1 for uviewpoint arrays.GLdoubleArray + arrays.GLdoubleArray, + 'v1', + ), + None, # XXX Could not determine size of argument v2 for uviewpoint arrays.GLdoubleArray + arrays.GLdoubleArray, + 'v2', + ), + None, # XXX Could not determine size of argument up for uviewpoint arrays.GLdoubleArray + arrays.GLdoubleArray, + 'up', +) + +__all__ = [ + 'gleExtrusion', + 'gleHelicoid', + 'gleLathe', + 'glePolyCone', + 'glePolyCylinder', + 'gleScrew', + 'gleSpiral', + 'gleSuperExtrusion', + 'gleToroid', + 'gleTwistExtrusion', + 'rot_about_axis', + 'rot_axis', + 'rot_omega', + 'urot_about_axis', + 'urot_axis', + 'urot_omega', + 'urot_prince', + 'uview_direction', + 'uviewpoint' +] diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLE/constants.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLE/constants.py new file mode 100644 index 00000000..489fbd54 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLE/constants.py @@ -0,0 +1,67 @@ +"""Constants for OpenGL.GLE + +Automatically generated by the generateraw script, do not edit! +""" + +from ctypes import * +from OpenGL import platform, arrays +from OpenGL.constant import Constant +from OpenGL.raw.GL import _types as GL_types +GLvoid = GL_types.GLvoid + + + +GLE_TEXTURE_ENABLE = Constant( 'GLE_TEXTURE_ENABLE', 65536) +GLE_TEXTURE_NORMAL_CYL = Constant( 'GLE_TEXTURE_NORMAL_CYL', 4) +GLE_TEXTURE_NORMAL_FLAT = Constant( 'GLE_TEXTURE_NORMAL_FLAT', 2) +GLE_TEXTURE_NORMAL_MODEL_CYL = Constant( 'GLE_TEXTURE_NORMAL_MODEL_CYL', 10) +GLE_TEXTURE_NORMAL_MODEL_FLAT = Constant( 'GLE_TEXTURE_NORMAL_MODEL_FLAT', 8) +GLE_TEXTURE_NORMAL_MODEL_SPH = Constant( 'GLE_TEXTURE_NORMAL_MODEL_SPH', 12) +GLE_TEXTURE_NORMAL_SPH = Constant( 'GLE_TEXTURE_NORMAL_SPH', 6) +GLE_TEXTURE_STYLE_MASK = Constant( 'GLE_TEXTURE_STYLE_MASK', 255) +GLE_TEXTURE_VERTEX_CYL = Constant( 'GLE_TEXTURE_VERTEX_CYL', 3) +GLE_TEXTURE_VERTEX_FLAT = Constant( 'GLE_TEXTURE_VERTEX_FLAT', 1) +GLE_TEXTURE_VERTEX_MODEL_CYL = Constant( 'GLE_TEXTURE_VERTEX_MODEL_CYL', 9) +GLE_TEXTURE_VERTEX_MODEL_FLAT = Constant( 'GLE_TEXTURE_VERTEX_MODEL_FLAT', 7) +GLE_TEXTURE_VERTEX_MODEL_SPH = Constant( 'GLE_TEXTURE_VERTEX_MODEL_SPH', 11) +GLE_TEXTURE_VERTEX_SPH = Constant( 'GLE_TEXTURE_VERTEX_SPH', 5) +TUBE_CONTOUR_CLOSED = Constant( 'TUBE_CONTOUR_CLOSED', 4096) +TUBE_JN_ANGLE = Constant( 'TUBE_JN_ANGLE', 2) +TUBE_JN_CAP = Constant( 'TUBE_JN_CAP', 16) +TUBE_JN_CUT = Constant( 'TUBE_JN_CUT', 3) +TUBE_JN_MASK = Constant( 'TUBE_JN_MASK', 15) +TUBE_JN_RAW = Constant( 'TUBE_JN_RAW', 1) +TUBE_JN_ROUND = Constant( 'TUBE_JN_ROUND', 4) +TUBE_NORM_EDGE = Constant( 'TUBE_NORM_EDGE', 512) +TUBE_NORM_FACET = Constant( 'TUBE_NORM_FACET', 256) +TUBE_NORM_MASK = Constant( 'TUBE_NORM_MASK', 3840) +TUBE_NORM_PATH_EDGE = Constant( 'TUBE_NORM_PATH_EDGE', 1024) +__GLE_DOUBLE = Constant( '__GLE_DOUBLE', 1) +__all__ = [ + 'GLE_TEXTURE_ENABLE', + 'GLE_TEXTURE_NORMAL_CYL', + 'GLE_TEXTURE_NORMAL_FLAT', + 'GLE_TEXTURE_NORMAL_MODEL_CYL', + 'GLE_TEXTURE_NORMAL_MODEL_FLAT', + 'GLE_TEXTURE_NORMAL_MODEL_SPH', + 'GLE_TEXTURE_NORMAL_SPH', + 'GLE_TEXTURE_STYLE_MASK', + 'GLE_TEXTURE_VERTEX_CYL', + 'GLE_TEXTURE_VERTEX_FLAT', + 'GLE_TEXTURE_VERTEX_MODEL_CYL', + 'GLE_TEXTURE_VERTEX_MODEL_FLAT', + 'GLE_TEXTURE_VERTEX_MODEL_SPH', + 'GLE_TEXTURE_VERTEX_SPH', + 'TUBE_CONTOUR_CLOSED', + 'TUBE_JN_ANGLE', + 'TUBE_JN_CAP', + 'TUBE_JN_CUT', + 'TUBE_JN_MASK', + 'TUBE_JN_RAW', + 'TUBE_JN_ROUND', + 'TUBE_NORM_EDGE', + 'TUBE_NORM_FACET', + 'TUBE_NORM_MASK', + 'TUBE_NORM_PATH_EDGE', + '__GLE_DOUBLE' +] diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/AMD/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/AMD/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/AMD/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/AMD/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/AMD/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..80b535c8 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/AMD/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/AMD/__pycache__/compressed_3DC_texture.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/AMD/__pycache__/compressed_3DC_texture.cpython-312.pyc new file mode 100644 index 00000000..9d202571 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/AMD/__pycache__/compressed_3DC_texture.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/AMD/__pycache__/compressed_ATC_texture.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/AMD/__pycache__/compressed_ATC_texture.cpython-312.pyc new file mode 100644 index 00000000..aaadebab Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/AMD/__pycache__/compressed_ATC_texture.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/AMD/compressed_3DC_texture.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/AMD/compressed_3DC_texture.py new file mode 100644 index 00000000..6e085ee6 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/AMD/compressed_3DC_texture.py @@ -0,0 +1,16 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES1 import _types as _cs +# End users want this... +from OpenGL.raw.GLES1._types import * +from OpenGL.raw.GLES1 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES1_AMD_compressed_3DC_texture' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES1,'GLES1_AMD_compressed_3DC_texture',error_checker=_errors._error_checker) +GL_3DC_XY_AMD=_C('GL_3DC_XY_AMD',0x87FA) +GL_3DC_X_AMD=_C('GL_3DC_X_AMD',0x87F9) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/AMD/compressed_ATC_texture.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/AMD/compressed_ATC_texture.py new file mode 100644 index 00000000..d593b2a1 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/AMD/compressed_ATC_texture.py @@ -0,0 +1,17 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES1 import _types as _cs +# End users want this... +from OpenGL.raw.GLES1._types import * +from OpenGL.raw.GLES1 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES1_AMD_compressed_ATC_texture' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES1,'GLES1_AMD_compressed_ATC_texture',error_checker=_errors._error_checker) +GL_ATC_RGBA_EXPLICIT_ALPHA_AMD=_C('GL_ATC_RGBA_EXPLICIT_ALPHA_AMD',0x8C93) +GL_ATC_RGBA_INTERPOLATED_ALPHA_AMD=_C('GL_ATC_RGBA_INTERPOLATED_ALPHA_AMD',0x87EE) +GL_ATC_RGB_AMD=_C('GL_ATC_RGB_AMD',0x8C92) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/APPLE/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/APPLE/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/APPLE/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/APPLE/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/APPLE/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..8e5ce75e Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/APPLE/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/APPLE/__pycache__/copy_texture_levels.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/APPLE/__pycache__/copy_texture_levels.cpython-312.pyc new file mode 100644 index 00000000..2a9142d3 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/APPLE/__pycache__/copy_texture_levels.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/APPLE/__pycache__/framebuffer_multisample.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/APPLE/__pycache__/framebuffer_multisample.cpython-312.pyc new file mode 100644 index 00000000..1ecb3718 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/APPLE/__pycache__/framebuffer_multisample.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/APPLE/__pycache__/sync.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/APPLE/__pycache__/sync.cpython-312.pyc new file mode 100644 index 00000000..40ea35f1 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/APPLE/__pycache__/sync.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/APPLE/__pycache__/texture_2D_limited_npot.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/APPLE/__pycache__/texture_2D_limited_npot.cpython-312.pyc new file mode 100644 index 00000000..1a8d1d26 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/APPLE/__pycache__/texture_2D_limited_npot.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/APPLE/__pycache__/texture_format_BGRA8888.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/APPLE/__pycache__/texture_format_BGRA8888.cpython-312.pyc new file mode 100644 index 00000000..ec08655e Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/APPLE/__pycache__/texture_format_BGRA8888.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/APPLE/__pycache__/texture_max_level.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/APPLE/__pycache__/texture_max_level.cpython-312.pyc new file mode 100644 index 00000000..724fe57b Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/APPLE/__pycache__/texture_max_level.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/APPLE/copy_texture_levels.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/APPLE/copy_texture_levels.py new file mode 100644 index 00000000..44036e5d --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/APPLE/copy_texture_levels.py @@ -0,0 +1,17 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES1 import _types as _cs +# End users want this... +from OpenGL.raw.GLES1._types import * +from OpenGL.raw.GLES1 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES1_APPLE_copy_texture_levels' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES1,'GLES1_APPLE_copy_texture_levels',error_checker=_errors._error_checker) + +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLint,_cs.GLsizei) +def glCopyTextureLevelsAPPLE(destinationTexture,sourceTexture,sourceBaseLevel,sourceLevelCount):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/APPLE/framebuffer_multisample.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/APPLE/framebuffer_multisample.py new file mode 100644 index 00000000..e7bd29e0 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/APPLE/framebuffer_multisample.py @@ -0,0 +1,26 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES1 import _types as _cs +# End users want this... +from OpenGL.raw.GLES1._types import * +from OpenGL.raw.GLES1 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES1_APPLE_framebuffer_multisample' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES1,'GLES1_APPLE_framebuffer_multisample',error_checker=_errors._error_checker) +GL_DRAW_FRAMEBUFFER_APPLE=_C('GL_DRAW_FRAMEBUFFER_APPLE',0x8CA9) +GL_DRAW_FRAMEBUFFER_BINDING_APPLE=_C('GL_DRAW_FRAMEBUFFER_BINDING_APPLE',0x8CA6) +GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_APPLE=_C('GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_APPLE',0x8D56) +GL_MAX_SAMPLES_APPLE=_C('GL_MAX_SAMPLES_APPLE',0x8D57) +GL_READ_FRAMEBUFFER_APPLE=_C('GL_READ_FRAMEBUFFER_APPLE',0x8CA8) +GL_READ_FRAMEBUFFER_BINDING_APPLE=_C('GL_READ_FRAMEBUFFER_BINDING_APPLE',0x8CAA) +GL_RENDERBUFFER_SAMPLES_APPLE=_C('GL_RENDERBUFFER_SAMPLES_APPLE',0x8CAB) +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizei,_cs.GLenum,_cs.GLsizei,_cs.GLsizei) +def glRenderbufferStorageMultisampleAPPLE(target,samples,internalformat,width,height):pass +@_f +@_p.types(None,) +def glResolveMultisampleFramebufferAPPLE():pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/APPLE/sync.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/APPLE/sync.py new file mode 100644 index 00000000..b02e6229 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/APPLE/sync.py @@ -0,0 +1,50 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES1 import _types as _cs +# End users want this... +from OpenGL.raw.GLES1._types import * +from OpenGL.raw.GLES1 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES1_APPLE_sync' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES1,'GLES1_APPLE_sync',error_checker=_errors._error_checker) +GL_ALREADY_SIGNALED_APPLE=_C('GL_ALREADY_SIGNALED_APPLE',0x911A) +GL_CONDITION_SATISFIED_APPLE=_C('GL_CONDITION_SATISFIED_APPLE',0x911C) +GL_MAX_SERVER_WAIT_TIMEOUT_APPLE=_C('GL_MAX_SERVER_WAIT_TIMEOUT_APPLE',0x9111) +GL_OBJECT_TYPE_APPLE=_C('GL_OBJECT_TYPE_APPLE',0x9112) +GL_SIGNALED_APPLE=_C('GL_SIGNALED_APPLE',0x9119) +GL_SYNC_CONDITION_APPLE=_C('GL_SYNC_CONDITION_APPLE',0x9113) +GL_SYNC_FENCE_APPLE=_C('GL_SYNC_FENCE_APPLE',0x9116) +GL_SYNC_FLAGS_APPLE=_C('GL_SYNC_FLAGS_APPLE',0x9115) +GL_SYNC_FLUSH_COMMANDS_BIT_APPLE=_C('GL_SYNC_FLUSH_COMMANDS_BIT_APPLE',0x00000001) +GL_SYNC_GPU_COMMANDS_COMPLETE_APPLE=_C('GL_SYNC_GPU_COMMANDS_COMPLETE_APPLE',0x9117) +GL_SYNC_OBJECT_APPLE=_C('GL_SYNC_OBJECT_APPLE',0x8A53) +GL_SYNC_STATUS_APPLE=_C('GL_SYNC_STATUS_APPLE',0x9114) +GL_TIMEOUT_EXPIRED_APPLE=_C('GL_TIMEOUT_EXPIRED_APPLE',0x911B) +GL_TIMEOUT_IGNORED_APPLE=_C('GL_TIMEOUT_IGNORED_APPLE',0xFFFFFFFFFFFFFFFF) +GL_UNSIGNALED_APPLE=_C('GL_UNSIGNALED_APPLE',0x9118) +GL_WAIT_FAILED_APPLE=_C('GL_WAIT_FAILED_APPLE',0x911D) +@_f +@_p.types(_cs.GLenum,_cs.GLsync,_cs.GLbitfield,_cs.GLuint64) +def glClientWaitSyncAPPLE(sync,flags,timeout):pass +@_f +@_p.types(None,_cs.GLsync) +def glDeleteSyncAPPLE(sync):pass +@_f +@_p.types(_cs.GLsync,_cs.GLenum,_cs.GLbitfield) +def glFenceSyncAPPLE(condition,flags):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLint64Array) +def glGetInteger64vAPPLE(pname,params):pass +@_f +@_p.types(None,_cs.GLsync,_cs.GLenum,_cs.GLsizei,arrays.GLsizeiArray,arrays.GLintArray) +def glGetSyncivAPPLE(sync,pname,bufSize,length,values):pass +@_f +@_p.types(_cs.GLboolean,_cs.GLsync) +def glIsSyncAPPLE(sync):pass +@_f +@_p.types(None,_cs.GLsync,_cs.GLbitfield,_cs.GLuint64) +def glWaitSyncAPPLE(sync,flags,timeout):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/APPLE/texture_2D_limited_npot.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/APPLE/texture_2D_limited_npot.py new file mode 100644 index 00000000..36df8e7d --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/APPLE/texture_2D_limited_npot.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES1 import _types as _cs +# End users want this... +from OpenGL.raw.GLES1._types import * +from OpenGL.raw.GLES1 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES1_APPLE_texture_2D_limited_npot' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES1,'GLES1_APPLE_texture_2D_limited_npot',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/APPLE/texture_format_BGRA8888.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/APPLE/texture_format_BGRA8888.py new file mode 100644 index 00000000..a9f35734 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/APPLE/texture_format_BGRA8888.py @@ -0,0 +1,16 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES1 import _types as _cs +# End users want this... +from OpenGL.raw.GLES1._types import * +from OpenGL.raw.GLES1 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES1_APPLE_texture_format_BGRA8888' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES1,'GLES1_APPLE_texture_format_BGRA8888',error_checker=_errors._error_checker) +GL_BGRA8_EXT=_C('GL_BGRA8_EXT',0x93A1) +GL_BGRA_EXT=_C('GL_BGRA_EXT',0x80E1) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/APPLE/texture_max_level.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/APPLE/texture_max_level.py new file mode 100644 index 00000000..0d7ccbe9 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/APPLE/texture_max_level.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES1 import _types as _cs +# End users want this... +from OpenGL.raw.GLES1._types import * +from OpenGL.raw.GLES1 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES1_APPLE_texture_max_level' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES1,'GLES1_APPLE_texture_max_level',error_checker=_errors._error_checker) +GL_TEXTURE_MAX_LEVEL_APPLE=_C('GL_TEXTURE_MAX_LEVEL_APPLE',0x813D) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/ARM/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/ARM/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/ARM/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/ARM/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/ARM/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..9d355e30 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/ARM/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/ARM/__pycache__/rgba8.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/ARM/__pycache__/rgba8.cpython-312.pyc new file mode 100644 index 00000000..fbf8148b Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/ARM/__pycache__/rgba8.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/ARM/rgba8.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/ARM/rgba8.py new file mode 100644 index 00000000..d38bea45 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/ARM/rgba8.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES1 import _types as _cs +# End users want this... +from OpenGL.raw.GLES1._types import * +from OpenGL.raw.GLES1 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES1_ARM_rgba8' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES1,'GLES1_ARM_rgba8',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/EXT/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/EXT/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/EXT/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/EXT/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/EXT/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..3a9fad1b Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/EXT/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/EXT/__pycache__/blend_minmax.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/EXT/__pycache__/blend_minmax.cpython-312.pyc new file mode 100644 index 00000000..6983a37b Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/EXT/__pycache__/blend_minmax.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/EXT/__pycache__/debug_marker.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/EXT/__pycache__/debug_marker.cpython-312.pyc new file mode 100644 index 00000000..307d1d9a Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/EXT/__pycache__/debug_marker.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/EXT/__pycache__/discard_framebuffer.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/EXT/__pycache__/discard_framebuffer.cpython-312.pyc new file mode 100644 index 00000000..6613a446 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/EXT/__pycache__/discard_framebuffer.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/EXT/__pycache__/map_buffer_range.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/EXT/__pycache__/map_buffer_range.cpython-312.pyc new file mode 100644 index 00000000..b04361b5 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/EXT/__pycache__/map_buffer_range.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/EXT/__pycache__/multi_draw_arrays.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/EXT/__pycache__/multi_draw_arrays.cpython-312.pyc new file mode 100644 index 00000000..497ac142 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/EXT/__pycache__/multi_draw_arrays.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/EXT/__pycache__/multisampled_render_to_texture.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/EXT/__pycache__/multisampled_render_to_texture.cpython-312.pyc new file mode 100644 index 00000000..cd6d1c92 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/EXT/__pycache__/multisampled_render_to_texture.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/EXT/__pycache__/read_format_bgra.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/EXT/__pycache__/read_format_bgra.cpython-312.pyc new file mode 100644 index 00000000..0c489924 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/EXT/__pycache__/read_format_bgra.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/EXT/__pycache__/robustness.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/EXT/__pycache__/robustness.cpython-312.pyc new file mode 100644 index 00000000..33d68587 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/EXT/__pycache__/robustness.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/EXT/__pycache__/sRGB.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/EXT/__pycache__/sRGB.cpython-312.pyc new file mode 100644 index 00000000..72a94d4b Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/EXT/__pycache__/sRGB.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/EXT/__pycache__/texture_compression_dxt1.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/EXT/__pycache__/texture_compression_dxt1.cpython-312.pyc new file mode 100644 index 00000000..742290d7 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/EXT/__pycache__/texture_compression_dxt1.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/EXT/__pycache__/texture_filter_anisotropic.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/EXT/__pycache__/texture_filter_anisotropic.cpython-312.pyc new file mode 100644 index 00000000..754d93b5 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/EXT/__pycache__/texture_filter_anisotropic.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/EXT/__pycache__/texture_format_BGRA8888.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/EXT/__pycache__/texture_format_BGRA8888.cpython-312.pyc new file mode 100644 index 00000000..2e62bd10 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/EXT/__pycache__/texture_format_BGRA8888.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/EXT/__pycache__/texture_lod_bias.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/EXT/__pycache__/texture_lod_bias.cpython-312.pyc new file mode 100644 index 00000000..71813575 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/EXT/__pycache__/texture_lod_bias.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/EXT/__pycache__/texture_storage.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/EXT/__pycache__/texture_storage.cpython-312.pyc new file mode 100644 index 00000000..bed48e6f Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/EXT/__pycache__/texture_storage.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/EXT/blend_minmax.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/EXT/blend_minmax.py new file mode 100644 index 00000000..3c4108fe --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/EXT/blend_minmax.py @@ -0,0 +1,20 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES1 import _types as _cs +# End users want this... +from OpenGL.raw.GLES1._types import * +from OpenGL.raw.GLES1 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES1_EXT_blend_minmax' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES1,'GLES1_EXT_blend_minmax',error_checker=_errors._error_checker) +GL_BLEND_EQUATION_EXT=_C('GL_BLEND_EQUATION_EXT',0x8009) +GL_FUNC_ADD_EXT=_C('GL_FUNC_ADD_EXT',0x8006) +GL_MAX_EXT=_C('GL_MAX_EXT',0x8008) +GL_MIN_EXT=_C('GL_MIN_EXT',0x8007) +@_f +@_p.types(None,_cs.GLenum) +def glBlendEquationEXT(mode):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/EXT/debug_marker.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/EXT/debug_marker.py new file mode 100644 index 00000000..cf1505ff --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/EXT/debug_marker.py @@ -0,0 +1,23 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES1 import _types as _cs +# End users want this... +from OpenGL.raw.GLES1._types import * +from OpenGL.raw.GLES1 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES1_EXT_debug_marker' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES1,'GLES1_EXT_debug_marker',error_checker=_errors._error_checker) + +@_f +@_p.types(None,_cs.GLsizei,arrays.GLcharArray) +def glInsertEventMarkerEXT(length,marker):pass +@_f +@_p.types(None,) +def glPopGroupMarkerEXT():pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLcharArray) +def glPushGroupMarkerEXT(length,marker):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/EXT/discard_framebuffer.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/EXT/discard_framebuffer.py new file mode 100644 index 00000000..5fbda36f --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/EXT/discard_framebuffer.py @@ -0,0 +1,19 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES1 import _types as _cs +# End users want this... +from OpenGL.raw.GLES1._types import * +from OpenGL.raw.GLES1 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES1_EXT_discard_framebuffer' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES1,'GLES1_EXT_discard_framebuffer',error_checker=_errors._error_checker) +GL_COLOR_EXT=_C('GL_COLOR_EXT',0x1800) +GL_DEPTH_EXT=_C('GL_DEPTH_EXT',0x1801) +GL_STENCIL_EXT=_C('GL_STENCIL_EXT',0x1802) +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizei,arrays.GLuintArray) +def glDiscardFramebufferEXT(target,numAttachments,attachments):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/EXT/map_buffer_range.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/EXT/map_buffer_range.py new file mode 100644 index 00000000..89b1c38d --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/EXT/map_buffer_range.py @@ -0,0 +1,25 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES1 import _types as _cs +# End users want this... +from OpenGL.raw.GLES1._types import * +from OpenGL.raw.GLES1 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES1_EXT_map_buffer_range' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES1,'GLES1_EXT_map_buffer_range',error_checker=_errors._error_checker) +GL_MAP_FLUSH_EXPLICIT_BIT_EXT=_C('GL_MAP_FLUSH_EXPLICIT_BIT_EXT',0x0010) +GL_MAP_INVALIDATE_BUFFER_BIT_EXT=_C('GL_MAP_INVALIDATE_BUFFER_BIT_EXT',0x0008) +GL_MAP_INVALIDATE_RANGE_BIT_EXT=_C('GL_MAP_INVALIDATE_RANGE_BIT_EXT',0x0004) +GL_MAP_READ_BIT_EXT=_C('GL_MAP_READ_BIT_EXT',0x0001) +GL_MAP_UNSYNCHRONIZED_BIT_EXT=_C('GL_MAP_UNSYNCHRONIZED_BIT_EXT',0x0020) +GL_MAP_WRITE_BIT_EXT=_C('GL_MAP_WRITE_BIT_EXT',0x0002) +@_f +@_p.types(None,_cs.GLenum,_cs.GLintptr,_cs.GLsizeiptr) +def glFlushMappedBufferRangeEXT(target,offset,length):pass +@_f +@_p.types(ctypes.c_void_p,_cs.GLenum,_cs.GLintptr,_cs.GLsizeiptr,_cs.GLbitfield) +def glMapBufferRangeEXT(target,offset,length,access):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/EXT/multi_draw_arrays.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/EXT/multi_draw_arrays.py new file mode 100644 index 00000000..cf9eaf99 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/EXT/multi_draw_arrays.py @@ -0,0 +1,20 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES1 import _types as _cs +# End users want this... +from OpenGL.raw.GLES1._types import * +from OpenGL.raw.GLES1 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES1_EXT_multi_draw_arrays' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES1,'GLES1_EXT_multi_draw_arrays',error_checker=_errors._error_checker) + +@_f +@_p.types(None,_cs.GLenum,arrays.GLintArray,arrays.GLsizeiArray,_cs.GLsizei) +def glMultiDrawArraysEXT(mode,first,count,primcount):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLsizeiArray,_cs.GLenum,arrays.GLvoidpArray,_cs.GLsizei) +def glMultiDrawElementsEXT(mode,count,type,indices,primcount):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/EXT/multisampled_render_to_texture.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/EXT/multisampled_render_to_texture.py new file mode 100644 index 00000000..c179cc00 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/EXT/multisampled_render_to_texture.py @@ -0,0 +1,23 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES1 import _types as _cs +# End users want this... +from OpenGL.raw.GLES1._types import * +from OpenGL.raw.GLES1 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES1_EXT_multisampled_render_to_texture' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES1,'GLES1_EXT_multisampled_render_to_texture',error_checker=_errors._error_checker) +GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_SAMPLES_EXT=_C('GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_SAMPLES_EXT',0x8D6C) +GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_EXT=_C('GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_EXT',0x8D56) +GL_MAX_SAMPLES_EXT=_C('GL_MAX_SAMPLES_EXT',0x8D57) +GL_RENDERBUFFER_SAMPLES_EXT=_C('GL_RENDERBUFFER_SAMPLES_EXT',0x8CAB) +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLenum,_cs.GLuint,_cs.GLint,_cs.GLsizei) +def glFramebufferTexture2DMultisampleEXT(target,attachment,textarget,texture,level,samples):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizei,_cs.GLenum,_cs.GLsizei,_cs.GLsizei) +def glRenderbufferStorageMultisampleEXT(target,samples,internalformat,width,height):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/EXT/read_format_bgra.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/EXT/read_format_bgra.py new file mode 100644 index 00000000..b351023b --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/EXT/read_format_bgra.py @@ -0,0 +1,17 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES1 import _types as _cs +# End users want this... +from OpenGL.raw.GLES1._types import * +from OpenGL.raw.GLES1 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES1_EXT_read_format_bgra' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES1,'GLES1_EXT_read_format_bgra',error_checker=_errors._error_checker) +GL_BGRA_EXT=_C('GL_BGRA_EXT',0x80E1) +GL_UNSIGNED_SHORT_1_5_5_5_REV_EXT=_C('GL_UNSIGNED_SHORT_1_5_5_5_REV_EXT',0x8366) +GL_UNSIGNED_SHORT_4_4_4_4_REV_EXT=_C('GL_UNSIGNED_SHORT_4_4_4_4_REV_EXT',0x8365) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/EXT/robustness.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/EXT/robustness.py new file mode 100644 index 00000000..e87913ba --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/EXT/robustness.py @@ -0,0 +1,33 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES1 import _types as _cs +# End users want this... +from OpenGL.raw.GLES1._types import * +from OpenGL.raw.GLES1 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES1_EXT_robustness' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES1,'GLES1_EXT_robustness',error_checker=_errors._error_checker) +GL_CONTEXT_ROBUST_ACCESS_EXT=_C('GL_CONTEXT_ROBUST_ACCESS_EXT',0x90F3) +GL_GUILTY_CONTEXT_RESET_EXT=_C('GL_GUILTY_CONTEXT_RESET_EXT',0x8253) +GL_INNOCENT_CONTEXT_RESET_EXT=_C('GL_INNOCENT_CONTEXT_RESET_EXT',0x8254) +GL_LOSE_CONTEXT_ON_RESET_EXT=_C('GL_LOSE_CONTEXT_ON_RESET_EXT',0x8252) +GL_NO_ERROR=_C('GL_NO_ERROR',0) +GL_NO_RESET_NOTIFICATION_EXT=_C('GL_NO_RESET_NOTIFICATION_EXT',0x8261) +GL_RESET_NOTIFICATION_STRATEGY_EXT=_C('GL_RESET_NOTIFICATION_STRATEGY_EXT',0x8256) +GL_UNKNOWN_CONTEXT_RESET_EXT=_C('GL_UNKNOWN_CONTEXT_RESET_EXT',0x8255) +@_f +@_p.types(_cs.GLenum,) +def glGetGraphicsResetStatusEXT():pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLfloatArray) +def glGetnUniformfvEXT(program,location,bufSize,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLintArray) +def glGetnUniformivEXT(program,location,bufSize,params):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLsizei,_cs.GLenum,_cs.GLenum,_cs.GLsizei,ctypes.c_void_p) +def glReadnPixelsEXT(x,y,width,height,format,type,bufSize,data):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/EXT/sRGB.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/EXT/sRGB.py new file mode 100644 index 00000000..374ea616 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/EXT/sRGB.py @@ -0,0 +1,18 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES1 import _types as _cs +# End users want this... +from OpenGL.raw.GLES1._types import * +from OpenGL.raw.GLES1 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES1_EXT_sRGB' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES1,'GLES1_EXT_sRGB',error_checker=_errors._error_checker) +GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING_EXT=_C('GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING_EXT',0x8210) +GL_SRGB8_ALPHA8_EXT=_C('GL_SRGB8_ALPHA8_EXT',0x8C43) +GL_SRGB_ALPHA_EXT=_C('GL_SRGB_ALPHA_EXT',0x8C42) +GL_SRGB_EXT=_C('GL_SRGB_EXT',0x8C40) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/EXT/texture_compression_dxt1.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/EXT/texture_compression_dxt1.py new file mode 100644 index 00000000..27203f3a --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/EXT/texture_compression_dxt1.py @@ -0,0 +1,16 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES1 import _types as _cs +# End users want this... +from OpenGL.raw.GLES1._types import * +from OpenGL.raw.GLES1 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES1_EXT_texture_compression_dxt1' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES1,'GLES1_EXT_texture_compression_dxt1',error_checker=_errors._error_checker) +GL_COMPRESSED_RGBA_S3TC_DXT1_EXT=_C('GL_COMPRESSED_RGBA_S3TC_DXT1_EXT',0x83F1) +GL_COMPRESSED_RGB_S3TC_DXT1_EXT=_C('GL_COMPRESSED_RGB_S3TC_DXT1_EXT',0x83F0) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/EXT/texture_filter_anisotropic.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/EXT/texture_filter_anisotropic.py new file mode 100644 index 00000000..22fce5b1 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/EXT/texture_filter_anisotropic.py @@ -0,0 +1,16 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES1 import _types as _cs +# End users want this... +from OpenGL.raw.GLES1._types import * +from OpenGL.raw.GLES1 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES1_EXT_texture_filter_anisotropic' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES1,'GLES1_EXT_texture_filter_anisotropic',error_checker=_errors._error_checker) +GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT=_C('GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT',0x84FF) +GL_TEXTURE_MAX_ANISOTROPY_EXT=_C('GL_TEXTURE_MAX_ANISOTROPY_EXT',0x84FE) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/EXT/texture_format_BGRA8888.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/EXT/texture_format_BGRA8888.py new file mode 100644 index 00000000..6b83c288 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/EXT/texture_format_BGRA8888.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES1 import _types as _cs +# End users want this... +from OpenGL.raw.GLES1._types import * +from OpenGL.raw.GLES1 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES1_EXT_texture_format_BGRA8888' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES1,'GLES1_EXT_texture_format_BGRA8888',error_checker=_errors._error_checker) +GL_BGRA_EXT=_C('GL_BGRA_EXT',0x80E1) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/EXT/texture_lod_bias.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/EXT/texture_lod_bias.py new file mode 100644 index 00000000..b8ef0c74 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/EXT/texture_lod_bias.py @@ -0,0 +1,17 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES1 import _types as _cs +# End users want this... +from OpenGL.raw.GLES1._types import * +from OpenGL.raw.GLES1 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES1_EXT_texture_lod_bias' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES1,'GLES1_EXT_texture_lod_bias',error_checker=_errors._error_checker) +GL_MAX_TEXTURE_LOD_BIAS_EXT=_C('GL_MAX_TEXTURE_LOD_BIAS_EXT',0x84FD) +GL_TEXTURE_FILTER_CONTROL_EXT=_C('GL_TEXTURE_FILTER_CONTROL_EXT',0x8500) +GL_TEXTURE_LOD_BIAS_EXT=_C('GL_TEXTURE_LOD_BIAS_EXT',0x8501) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/EXT/texture_storage.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/EXT/texture_storage.py new file mode 100644 index 00000000..b539e683 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/EXT/texture_storage.py @@ -0,0 +1,54 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES1 import _types as _cs +# End users want this... +from OpenGL.raw.GLES1._types import * +from OpenGL.raw.GLES1 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES1_EXT_texture_storage' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES1,'GLES1_EXT_texture_storage',error_checker=_errors._error_checker) +GL_ALPHA16F_EXT=_C('GL_ALPHA16F_EXT',0x881C) +GL_ALPHA32F_EXT=_C('GL_ALPHA32F_EXT',0x8816) +GL_ALPHA8_EXT=_C('GL_ALPHA8_EXT',0x803C) +GL_BGRA8_EXT=_C('GL_BGRA8_EXT',0x93A1) +GL_LUMINANCE16F_EXT=_C('GL_LUMINANCE16F_EXT',0x881E) +GL_LUMINANCE32F_EXT=_C('GL_LUMINANCE32F_EXT',0x8818) +GL_LUMINANCE8_ALPHA8_EXT=_C('GL_LUMINANCE8_ALPHA8_EXT',0x8045) +GL_LUMINANCE8_EXT=_C('GL_LUMINANCE8_EXT',0x8040) +GL_LUMINANCE_ALPHA16F_EXT=_C('GL_LUMINANCE_ALPHA16F_EXT',0x881F) +GL_LUMINANCE_ALPHA32F_EXT=_C('GL_LUMINANCE_ALPHA32F_EXT',0x8819) +GL_R16F_EXT=_C('GL_R16F_EXT',0x822D) +GL_R32F_EXT=_C('GL_R32F_EXT',0x822E) +GL_R8_EXT=_C('GL_R8_EXT',0x8229) +GL_RG16F_EXT=_C('GL_RG16F_EXT',0x822F) +GL_RG32F_EXT=_C('GL_RG32F_EXT',0x8230) +GL_RG8_EXT=_C('GL_RG8_EXT',0x822B) +GL_RGB10_A2_EXT=_C('GL_RGB10_A2_EXT',0x8059) +GL_RGB10_EXT=_C('GL_RGB10_EXT',0x8052) +GL_RGB16F_EXT=_C('GL_RGB16F_EXT',0x881B) +GL_RGB32F_EXT=_C('GL_RGB32F_EXT',0x8815) +GL_RGBA16F_EXT=_C('GL_RGBA16F_EXT',0x881A) +GL_RGBA32F_EXT=_C('GL_RGBA32F_EXT',0x8814) +GL_TEXTURE_IMMUTABLE_FORMAT_EXT=_C('GL_TEXTURE_IMMUTABLE_FORMAT_EXT',0x912F) +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizei,_cs.GLenum,_cs.GLsizei) +def glTexStorage1DEXT(target,levels,internalformat,width):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizei,_cs.GLenum,_cs.GLsizei,_cs.GLsizei) +def glTexStorage2DEXT(target,levels,internalformat,width,height):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizei,_cs.GLenum,_cs.GLsizei,_cs.GLsizei,_cs.GLsizei) +def glTexStorage3DEXT(target,levels,internalformat,width,height,depth):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLsizei,_cs.GLenum,_cs.GLsizei) +def glTextureStorage1DEXT(texture,target,levels,internalformat,width):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLsizei,_cs.GLenum,_cs.GLsizei,_cs.GLsizei) +def glTextureStorage2DEXT(texture,target,levels,internalformat,width,height):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLsizei,_cs.GLenum,_cs.GLsizei,_cs.GLsizei,_cs.GLsizei) +def glTextureStorage3DEXT(texture,target,levels,internalformat,width,height,depth):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/IMG/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/IMG/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/IMG/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/IMG/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/IMG/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..8e5d0934 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/IMG/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/IMG/__pycache__/multisampled_render_to_texture.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/IMG/__pycache__/multisampled_render_to_texture.cpython-312.pyc new file mode 100644 index 00000000..f97eccd9 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/IMG/__pycache__/multisampled_render_to_texture.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/IMG/__pycache__/read_format.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/IMG/__pycache__/read_format.cpython-312.pyc new file mode 100644 index 00000000..cf23d61a Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/IMG/__pycache__/read_format.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/IMG/__pycache__/texture_compression_pvrtc.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/IMG/__pycache__/texture_compression_pvrtc.cpython-312.pyc new file mode 100644 index 00000000..234812b8 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/IMG/__pycache__/texture_compression_pvrtc.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/IMG/__pycache__/texture_env_enhanced_fixed_function.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/IMG/__pycache__/texture_env_enhanced_fixed_function.cpython-312.pyc new file mode 100644 index 00000000..41eafcf3 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/IMG/__pycache__/texture_env_enhanced_fixed_function.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/IMG/__pycache__/user_clip_plane.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/IMG/__pycache__/user_clip_plane.cpython-312.pyc new file mode 100644 index 00000000..0ec244a1 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/IMG/__pycache__/user_clip_plane.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/IMG/multisampled_render_to_texture.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/IMG/multisampled_render_to_texture.py new file mode 100644 index 00000000..2d4686e0 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/IMG/multisampled_render_to_texture.py @@ -0,0 +1,23 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES1 import _types as _cs +# End users want this... +from OpenGL.raw.GLES1._types import * +from OpenGL.raw.GLES1 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES1_IMG_multisampled_render_to_texture' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES1,'GLES1_IMG_multisampled_render_to_texture',error_checker=_errors._error_checker) +GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_IMG=_C('GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_IMG',0x9134) +GL_MAX_SAMPLES_IMG=_C('GL_MAX_SAMPLES_IMG',0x9135) +GL_RENDERBUFFER_SAMPLES_IMG=_C('GL_RENDERBUFFER_SAMPLES_IMG',0x9133) +GL_TEXTURE_SAMPLES_IMG=_C('GL_TEXTURE_SAMPLES_IMG',0x9136) +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLenum,_cs.GLuint,_cs.GLint,_cs.GLsizei) +def glFramebufferTexture2DMultisampleIMG(target,attachment,textarget,texture,level,samples):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizei,_cs.GLenum,_cs.GLsizei,_cs.GLsizei) +def glRenderbufferStorageMultisampleIMG(target,samples,internalformat,width,height):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/IMG/read_format.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/IMG/read_format.py new file mode 100644 index 00000000..d7380895 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/IMG/read_format.py @@ -0,0 +1,16 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES1 import _types as _cs +# End users want this... +from OpenGL.raw.GLES1._types import * +from OpenGL.raw.GLES1 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES1_IMG_read_format' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES1,'GLES1_IMG_read_format',error_checker=_errors._error_checker) +GL_BGRA_IMG=_C('GL_BGRA_IMG',0x80E1) +GL_UNSIGNED_SHORT_4_4_4_4_REV_IMG=_C('GL_UNSIGNED_SHORT_4_4_4_4_REV_IMG',0x8365) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/IMG/texture_compression_pvrtc.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/IMG/texture_compression_pvrtc.py new file mode 100644 index 00000000..0c24171d --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/IMG/texture_compression_pvrtc.py @@ -0,0 +1,18 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES1 import _types as _cs +# End users want this... +from OpenGL.raw.GLES1._types import * +from OpenGL.raw.GLES1 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES1_IMG_texture_compression_pvrtc' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES1,'GLES1_IMG_texture_compression_pvrtc',error_checker=_errors._error_checker) +GL_COMPRESSED_RGBA_PVRTC_2BPPV1_IMG=_C('GL_COMPRESSED_RGBA_PVRTC_2BPPV1_IMG',0x8C03) +GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG=_C('GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG',0x8C02) +GL_COMPRESSED_RGB_PVRTC_2BPPV1_IMG=_C('GL_COMPRESSED_RGB_PVRTC_2BPPV1_IMG',0x8C01) +GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG=_C('GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG',0x8C00) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/IMG/texture_env_enhanced_fixed_function.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/IMG/texture_env_enhanced_fixed_function.py new file mode 100644 index 00000000..2653d243 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/IMG/texture_env_enhanced_fixed_function.py @@ -0,0 +1,21 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES1 import _types as _cs +# End users want this... +from OpenGL.raw.GLES1._types import * +from OpenGL.raw.GLES1 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES1_IMG_texture_env_enhanced_fixed_function' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES1,'GLES1_IMG_texture_env_enhanced_fixed_function',error_checker=_errors._error_checker) +GL_ADD_BLEND_IMG=_C('GL_ADD_BLEND_IMG',0x8C09) +GL_DOT3_RGBA_IMG=_C('GL_DOT3_RGBA_IMG',0x86AF) +GL_FACTOR_ALPHA_MODULATE_IMG=_C('GL_FACTOR_ALPHA_MODULATE_IMG',0x8C07) +GL_FRAGMENT_ALPHA_MODULATE_IMG=_C('GL_FRAGMENT_ALPHA_MODULATE_IMG',0x8C08) +GL_MODULATE_COLOR_IMG=_C('GL_MODULATE_COLOR_IMG',0x8C04) +GL_RECIP_ADD_SIGNED_ALPHA_IMG=_C('GL_RECIP_ADD_SIGNED_ALPHA_IMG',0x8C05) +GL_TEXTURE_ALPHA_MODULATE_IMG=_C('GL_TEXTURE_ALPHA_MODULATE_IMG',0x8C06) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/IMG/user_clip_plane.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/IMG/user_clip_plane.py new file mode 100644 index 00000000..6da50b97 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/IMG/user_clip_plane.py @@ -0,0 +1,26 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES1 import _types as _cs +# End users want this... +from OpenGL.raw.GLES1._types import * +from OpenGL.raw.GLES1 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES1_IMG_user_clip_plane' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES1,'GLES1_IMG_user_clip_plane',error_checker=_errors._error_checker) +GL_CLIP_PLANE0_IMG=_C('GL_CLIP_PLANE0_IMG',0x3000) +GL_CLIP_PLANE1_IMG=_C('GL_CLIP_PLANE1_IMG',0x3001) +GL_CLIP_PLANE2_IMG=_C('GL_CLIP_PLANE2_IMG',0x3002) +GL_CLIP_PLANE3_IMG=_C('GL_CLIP_PLANE3_IMG',0x3003) +GL_CLIP_PLANE4_IMG=_C('GL_CLIP_PLANE4_IMG',0x3004) +GL_CLIP_PLANE5_IMG=_C('GL_CLIP_PLANE5_IMG',0x3005) +GL_MAX_CLIP_PLANES_IMG=_C('GL_MAX_CLIP_PLANES_IMG',0x0D32) +@_f +@_p.types(None,_cs.GLenum,arrays.GLfloatArray) +def glClipPlanefIMG(p,eqn):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLfixedArray) +def glClipPlanexIMG(p,eqn):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/KHR/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/KHR/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/KHR/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/KHR/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/KHR/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..67048a0d Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/KHR/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/KHR/__pycache__/debug.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/KHR/__pycache__/debug.cpython-312.pyc new file mode 100644 index 00000000..814d2d31 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/KHR/__pycache__/debug.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/KHR/debug.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/KHR/debug.py new file mode 100644 index 00000000..970e8e8e --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/KHR/debug.py @@ -0,0 +1,160 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES1 import _types as _cs +# End users want this... +from OpenGL.raw.GLES1._types import * +from OpenGL.raw.GLES1 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES1_KHR_debug' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES1,'GLES1_KHR_debug',error_checker=_errors._error_checker) +GL_BUFFER=_C('GL_BUFFER',0x82E0) +GL_BUFFER_KHR=_C('GL_BUFFER_KHR',0x82E0) +GL_CONTEXT_FLAG_DEBUG_BIT=_C('GL_CONTEXT_FLAG_DEBUG_BIT',0x00000002) +GL_CONTEXT_FLAG_DEBUG_BIT_KHR=_C('GL_CONTEXT_FLAG_DEBUG_BIT_KHR',0x00000002) +GL_DEBUG_CALLBACK_FUNCTION=_C('GL_DEBUG_CALLBACK_FUNCTION',0x8244) +GL_DEBUG_CALLBACK_FUNCTION_KHR=_C('GL_DEBUG_CALLBACK_FUNCTION_KHR',0x8244) +GL_DEBUG_CALLBACK_USER_PARAM=_C('GL_DEBUG_CALLBACK_USER_PARAM',0x8245) +GL_DEBUG_CALLBACK_USER_PARAM_KHR=_C('GL_DEBUG_CALLBACK_USER_PARAM_KHR',0x8245) +GL_DEBUG_GROUP_STACK_DEPTH=_C('GL_DEBUG_GROUP_STACK_DEPTH',0x826D) +GL_DEBUG_GROUP_STACK_DEPTH_KHR=_C('GL_DEBUG_GROUP_STACK_DEPTH_KHR',0x826D) +GL_DEBUG_LOGGED_MESSAGES=_C('GL_DEBUG_LOGGED_MESSAGES',0x9145) +GL_DEBUG_LOGGED_MESSAGES_KHR=_C('GL_DEBUG_LOGGED_MESSAGES_KHR',0x9145) +GL_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH=_C('GL_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH',0x8243) +GL_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH_KHR=_C('GL_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH_KHR',0x8243) +GL_DEBUG_OUTPUT=_C('GL_DEBUG_OUTPUT',0x92E0) +GL_DEBUG_OUTPUT_KHR=_C('GL_DEBUG_OUTPUT_KHR',0x92E0) +GL_DEBUG_OUTPUT_SYNCHRONOUS=_C('GL_DEBUG_OUTPUT_SYNCHRONOUS',0x8242) +GL_DEBUG_OUTPUT_SYNCHRONOUS_KHR=_C('GL_DEBUG_OUTPUT_SYNCHRONOUS_KHR',0x8242) +GL_DEBUG_SEVERITY_HIGH=_C('GL_DEBUG_SEVERITY_HIGH',0x9146) +GL_DEBUG_SEVERITY_HIGH_KHR=_C('GL_DEBUG_SEVERITY_HIGH_KHR',0x9146) +GL_DEBUG_SEVERITY_LOW=_C('GL_DEBUG_SEVERITY_LOW',0x9148) +GL_DEBUG_SEVERITY_LOW_KHR=_C('GL_DEBUG_SEVERITY_LOW_KHR',0x9148) +GL_DEBUG_SEVERITY_MEDIUM=_C('GL_DEBUG_SEVERITY_MEDIUM',0x9147) +GL_DEBUG_SEVERITY_MEDIUM_KHR=_C('GL_DEBUG_SEVERITY_MEDIUM_KHR',0x9147) +GL_DEBUG_SEVERITY_NOTIFICATION=_C('GL_DEBUG_SEVERITY_NOTIFICATION',0x826B) +GL_DEBUG_SEVERITY_NOTIFICATION_KHR=_C('GL_DEBUG_SEVERITY_NOTIFICATION_KHR',0x826B) +GL_DEBUG_SOURCE_API=_C('GL_DEBUG_SOURCE_API',0x8246) +GL_DEBUG_SOURCE_API_KHR=_C('GL_DEBUG_SOURCE_API_KHR',0x8246) +GL_DEBUG_SOURCE_APPLICATION=_C('GL_DEBUG_SOURCE_APPLICATION',0x824A) +GL_DEBUG_SOURCE_APPLICATION_KHR=_C('GL_DEBUG_SOURCE_APPLICATION_KHR',0x824A) +GL_DEBUG_SOURCE_OTHER=_C('GL_DEBUG_SOURCE_OTHER',0x824B) +GL_DEBUG_SOURCE_OTHER_KHR=_C('GL_DEBUG_SOURCE_OTHER_KHR',0x824B) +GL_DEBUG_SOURCE_SHADER_COMPILER=_C('GL_DEBUG_SOURCE_SHADER_COMPILER',0x8248) +GL_DEBUG_SOURCE_SHADER_COMPILER_KHR=_C('GL_DEBUG_SOURCE_SHADER_COMPILER_KHR',0x8248) +GL_DEBUG_SOURCE_THIRD_PARTY=_C('GL_DEBUG_SOURCE_THIRD_PARTY',0x8249) +GL_DEBUG_SOURCE_THIRD_PARTY_KHR=_C('GL_DEBUG_SOURCE_THIRD_PARTY_KHR',0x8249) +GL_DEBUG_SOURCE_WINDOW_SYSTEM=_C('GL_DEBUG_SOURCE_WINDOW_SYSTEM',0x8247) +GL_DEBUG_SOURCE_WINDOW_SYSTEM_KHR=_C('GL_DEBUG_SOURCE_WINDOW_SYSTEM_KHR',0x8247) +GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR=_C('GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR',0x824D) +GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR_KHR=_C('GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR_KHR',0x824D) +GL_DEBUG_TYPE_ERROR=_C('GL_DEBUG_TYPE_ERROR',0x824C) +GL_DEBUG_TYPE_ERROR_KHR=_C('GL_DEBUG_TYPE_ERROR_KHR',0x824C) +GL_DEBUG_TYPE_MARKER=_C('GL_DEBUG_TYPE_MARKER',0x8268) +GL_DEBUG_TYPE_MARKER_KHR=_C('GL_DEBUG_TYPE_MARKER_KHR',0x8268) +GL_DEBUG_TYPE_OTHER=_C('GL_DEBUG_TYPE_OTHER',0x8251) +GL_DEBUG_TYPE_OTHER_KHR=_C('GL_DEBUG_TYPE_OTHER_KHR',0x8251) +GL_DEBUG_TYPE_PERFORMANCE=_C('GL_DEBUG_TYPE_PERFORMANCE',0x8250) +GL_DEBUG_TYPE_PERFORMANCE_KHR=_C('GL_DEBUG_TYPE_PERFORMANCE_KHR',0x8250) +GL_DEBUG_TYPE_POP_GROUP=_C('GL_DEBUG_TYPE_POP_GROUP',0x826A) +GL_DEBUG_TYPE_POP_GROUP_KHR=_C('GL_DEBUG_TYPE_POP_GROUP_KHR',0x826A) +GL_DEBUG_TYPE_PORTABILITY=_C('GL_DEBUG_TYPE_PORTABILITY',0x824F) +GL_DEBUG_TYPE_PORTABILITY_KHR=_C('GL_DEBUG_TYPE_PORTABILITY_KHR',0x824F) +GL_DEBUG_TYPE_PUSH_GROUP=_C('GL_DEBUG_TYPE_PUSH_GROUP',0x8269) +GL_DEBUG_TYPE_PUSH_GROUP_KHR=_C('GL_DEBUG_TYPE_PUSH_GROUP_KHR',0x8269) +GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR=_C('GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR',0x824E) +GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR_KHR=_C('GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR_KHR',0x824E) +GL_DISPLAY_LIST=_C('GL_DISPLAY_LIST',0x82E7) +GL_MAX_DEBUG_GROUP_STACK_DEPTH=_C('GL_MAX_DEBUG_GROUP_STACK_DEPTH',0x826C) +GL_MAX_DEBUG_GROUP_STACK_DEPTH_KHR=_C('GL_MAX_DEBUG_GROUP_STACK_DEPTH_KHR',0x826C) +GL_MAX_DEBUG_LOGGED_MESSAGES=_C('GL_MAX_DEBUG_LOGGED_MESSAGES',0x9144) +GL_MAX_DEBUG_LOGGED_MESSAGES_KHR=_C('GL_MAX_DEBUG_LOGGED_MESSAGES_KHR',0x9144) +GL_MAX_DEBUG_MESSAGE_LENGTH=_C('GL_MAX_DEBUG_MESSAGE_LENGTH',0x9143) +GL_MAX_DEBUG_MESSAGE_LENGTH_KHR=_C('GL_MAX_DEBUG_MESSAGE_LENGTH_KHR',0x9143) +GL_MAX_LABEL_LENGTH=_C('GL_MAX_LABEL_LENGTH',0x82E8) +GL_MAX_LABEL_LENGTH_KHR=_C('GL_MAX_LABEL_LENGTH_KHR',0x82E8) +GL_PROGRAM=_C('GL_PROGRAM',0x82E2) +GL_PROGRAM_KHR=_C('GL_PROGRAM_KHR',0x82E2) +GL_PROGRAM_PIPELINE=_C('GL_PROGRAM_PIPELINE',0x82E4) +GL_PROGRAM_PIPELINE_KHR=_C('GL_PROGRAM_PIPELINE_KHR',0x82E4) +GL_QUERY=_C('GL_QUERY',0x82E3) +GL_QUERY_KHR=_C('GL_QUERY_KHR',0x82E3) +GL_SAMPLER=_C('GL_SAMPLER',0x82E6) +GL_SAMPLER_KHR=_C('GL_SAMPLER_KHR',0x82E6) +GL_SHADER=_C('GL_SHADER',0x82E1) +GL_SHADER_KHR=_C('GL_SHADER_KHR',0x82E1) +GL_STACK_OVERFLOW=_C('GL_STACK_OVERFLOW',0x0503) +GL_STACK_OVERFLOW_KHR=_C('GL_STACK_OVERFLOW_KHR',0x0503) +GL_STACK_UNDERFLOW=_C('GL_STACK_UNDERFLOW',0x0504) +GL_STACK_UNDERFLOW_KHR=_C('GL_STACK_UNDERFLOW_KHR',0x0504) +GL_VERTEX_ARRAY=_C('GL_VERTEX_ARRAY',0x8074) +GL_VERTEX_ARRAY_KHR=_C('GL_VERTEX_ARRAY_KHR',0x8074) +@_f +@_p.types(None,_cs.GLDEBUGPROC,ctypes.c_void_p) +def glDebugMessageCallback(callback,userParam):pass +@_f +@_p.types(None,_cs.GLDEBUGPROCKHR,ctypes.c_void_p) +def glDebugMessageCallbackKHR(callback,userParam):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLenum,_cs.GLsizei,arrays.GLuintArray,_cs.GLboolean) +def glDebugMessageControl(source,type,severity,count,ids,enabled):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLenum,_cs.GLsizei,arrays.GLuintArray,_cs.GLboolean) +def glDebugMessageControlKHR(source,type,severity,count,ids,enabled):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLuint,_cs.GLenum,_cs.GLsizei,arrays.GLcharArray) +def glDebugMessageInsert(source,type,id,severity,length,buf):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLuint,_cs.GLenum,_cs.GLsizei,arrays.GLcharArray) +def glDebugMessageInsertKHR(source,type,id,severity,length,buf):pass +@_f +@_p.types(_cs.GLuint,_cs.GLuint,_cs.GLsizei,arrays.GLuintArray,arrays.GLuintArray,arrays.GLuintArray,arrays.GLuintArray,arrays.GLsizeiArray,arrays.GLcharArray) +def glGetDebugMessageLog(count,bufSize,sources,types,ids,severities,lengths,messageLog):pass +@_f +@_p.types(_cs.GLuint,_cs.GLuint,_cs.GLsizei,arrays.GLuintArray,arrays.GLuintArray,arrays.GLuintArray,arrays.GLuintArray,arrays.GLsizeiArray,arrays.GLcharArray) +def glGetDebugMessageLogKHR(count,bufSize,sources,types,ids,severities,lengths,messageLog):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,_cs.GLsizei,arrays.GLsizeiArray,arrays.GLcharArray) +def glGetObjectLabel(identifier,name,bufSize,length,label):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,_cs.GLsizei,arrays.GLsizeiArray,arrays.GLcharArray) +def glGetObjectLabelKHR(identifier,name,bufSize,length,label):pass +@_f +@_p.types(None,ctypes.c_void_p,_cs.GLsizei,arrays.GLsizeiArray,arrays.GLcharArray) +def glGetObjectPtrLabel(ptr,bufSize,length,label):pass +@_f +@_p.types(None,ctypes.c_void_p,_cs.GLsizei,arrays.GLsizeiArray,arrays.GLcharArray) +def glGetObjectPtrLabelKHR(ptr,bufSize,length,label):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLvoidpArray) +def glGetPointerv(pname,params):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLvoidpArray) +def glGetPointervKHR(pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,_cs.GLsizei,arrays.GLcharArray) +def glObjectLabel(identifier,name,length,label):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,_cs.GLsizei,arrays.GLcharArray) +def glObjectLabelKHR(identifier,name,length,label):pass +@_f +@_p.types(None,ctypes.c_void_p,_cs.GLsizei,arrays.GLcharArray) +def glObjectPtrLabel(ptr,length,label):pass +@_f +@_p.types(None,ctypes.c_void_p,_cs.GLsizei,arrays.GLcharArray) +def glObjectPtrLabelKHR(ptr,length,label):pass +@_f +@_p.types(None,) +def glPopDebugGroup():pass +@_f +@_p.types(None,) +def glPopDebugGroupKHR():pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,_cs.GLsizei,arrays.GLcharArray) +def glPushDebugGroup(source,id,length,message):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,_cs.GLsizei,arrays.GLcharArray) +def glPushDebugGroupKHR(source,id,length,message):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/NV/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/NV/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/NV/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/NV/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/NV/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..ad3767aa Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/NV/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/NV/__pycache__/fence.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/NV/__pycache__/fence.cpython-312.pyc new file mode 100644 index 00000000..18d6b612 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/NV/__pycache__/fence.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/NV/fence.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/NV/fence.py new file mode 100644 index 00000000..873fa197 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/NV/fence.py @@ -0,0 +1,37 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES1 import _types as _cs +# End users want this... +from OpenGL.raw.GLES1._types import * +from OpenGL.raw.GLES1 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES1_NV_fence' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES1,'GLES1_NV_fence',error_checker=_errors._error_checker) +GL_ALL_COMPLETED_NV=_C('GL_ALL_COMPLETED_NV',0x84F2) +GL_FENCE_CONDITION_NV=_C('GL_FENCE_CONDITION_NV',0x84F4) +GL_FENCE_STATUS_NV=_C('GL_FENCE_STATUS_NV',0x84F3) +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray) +def glDeleteFencesNV(n,fences):pass +@_f +@_p.types(None,_cs.GLuint) +def glFinishFenceNV(fence):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray) +def glGenFencesNV(n,fences):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLintArray) +def glGetFenceivNV(fence,pname,params):pass +@_f +@_p.types(_cs.GLboolean,_cs.GLuint) +def glIsFenceNV(fence):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum) +def glSetFenceNV(fence,condition):pass +@_f +@_p.types(_cs.GLboolean,_cs.GLuint) +def glTestFenceNV(fence):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/EGL_image.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/EGL_image.py new file mode 100644 index 00000000..0c7c197a --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/EGL_image.py @@ -0,0 +1,20 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES1 import _types as _cs +# End users want this... +from OpenGL.raw.GLES1._types import * +from OpenGL.raw.GLES1 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES1_OES_EGL_image' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES1,'GLES1_OES_EGL_image',error_checker=_errors._error_checker) + +@_f +@_p.types(None,_cs.GLenum,_cs.GLeglImageOES) +def glEGLImageTargetRenderbufferStorageOES(target,image):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLeglImageOES) +def glEGLImageTargetTexture2DOES(target,image):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/EGL_image_external.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/EGL_image_external.py new file mode 100644 index 00000000..7476a403 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/EGL_image_external.py @@ -0,0 +1,18 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES1 import _types as _cs +# End users want this... +from OpenGL.raw.GLES1._types import * +from OpenGL.raw.GLES1 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES1_OES_EGL_image_external' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES1,'GLES1_OES_EGL_image_external',error_checker=_errors._error_checker) +GL_REQUIRED_TEXTURE_IMAGE_UNITS_OES=_C('GL_REQUIRED_TEXTURE_IMAGE_UNITS_OES',0x8D68) +GL_SAMPLER_EXTERNAL_OES=_C('GL_SAMPLER_EXTERNAL_OES',0x8D66) +GL_TEXTURE_BINDING_EXTERNAL_OES=_C('GL_TEXTURE_BINDING_EXTERNAL_OES',0x8D67) +GL_TEXTURE_EXTERNAL_OES=_C('GL_TEXTURE_EXTERNAL_OES',0x8D65) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/__pycache__/EGL_image.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/__pycache__/EGL_image.cpython-312.pyc new file mode 100644 index 00000000..ea8eb40d Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/__pycache__/EGL_image.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/__pycache__/EGL_image_external.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/__pycache__/EGL_image_external.cpython-312.pyc new file mode 100644 index 00000000..affc3c9e Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/__pycache__/EGL_image_external.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..9cfa95a1 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/__pycache__/blend_equation_separate.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/__pycache__/blend_equation_separate.cpython-312.pyc new file mode 100644 index 00000000..9285b2fb Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/__pycache__/blend_equation_separate.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/__pycache__/blend_func_separate.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/__pycache__/blend_func_separate.cpython-312.pyc new file mode 100644 index 00000000..027800ec Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/__pycache__/blend_func_separate.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/__pycache__/blend_subtract.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/__pycache__/blend_subtract.cpython-312.pyc new file mode 100644 index 00000000..1904400b Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/__pycache__/blend_subtract.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/__pycache__/byte_coordinates.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/__pycache__/byte_coordinates.cpython-312.pyc new file mode 100644 index 00000000..6094dc37 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/__pycache__/byte_coordinates.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/__pycache__/compressed_ETC1_RGB8_sub_texture.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/__pycache__/compressed_ETC1_RGB8_sub_texture.cpython-312.pyc new file mode 100644 index 00000000..868ebe43 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/__pycache__/compressed_ETC1_RGB8_sub_texture.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/__pycache__/compressed_ETC1_RGB8_texture.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/__pycache__/compressed_ETC1_RGB8_texture.cpython-312.pyc new file mode 100644 index 00000000..f6c89b34 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/__pycache__/compressed_ETC1_RGB8_texture.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/__pycache__/compressed_paletted_texture.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/__pycache__/compressed_paletted_texture.cpython-312.pyc new file mode 100644 index 00000000..e2805088 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/__pycache__/compressed_paletted_texture.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/__pycache__/depth24.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/__pycache__/depth24.cpython-312.pyc new file mode 100644 index 00000000..648a2eb5 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/__pycache__/depth24.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/__pycache__/depth32.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/__pycache__/depth32.cpython-312.pyc new file mode 100644 index 00000000..7d2ba9da Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/__pycache__/depth32.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/__pycache__/draw_texture.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/__pycache__/draw_texture.cpython-312.pyc new file mode 100644 index 00000000..500bc18c Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/__pycache__/draw_texture.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/__pycache__/element_index_uint.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/__pycache__/element_index_uint.cpython-312.pyc new file mode 100644 index 00000000..c16fa42b Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/__pycache__/element_index_uint.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/__pycache__/extended_matrix_palette.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/__pycache__/extended_matrix_palette.cpython-312.pyc new file mode 100644 index 00000000..c0aaeb48 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/__pycache__/extended_matrix_palette.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/__pycache__/fbo_render_mipmap.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/__pycache__/fbo_render_mipmap.cpython-312.pyc new file mode 100644 index 00000000..8de1b006 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/__pycache__/fbo_render_mipmap.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/__pycache__/fixed_point.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/__pycache__/fixed_point.cpython-312.pyc new file mode 100644 index 00000000..e07e9e04 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/__pycache__/fixed_point.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/__pycache__/framebuffer_object.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/__pycache__/framebuffer_object.cpython-312.pyc new file mode 100644 index 00000000..2428eb42 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/__pycache__/framebuffer_object.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/__pycache__/mapbuffer.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/__pycache__/mapbuffer.cpython-312.pyc new file mode 100644 index 00000000..52a46518 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/__pycache__/mapbuffer.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/__pycache__/matrix_get.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/__pycache__/matrix_get.cpython-312.pyc new file mode 100644 index 00000000..c57bee90 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/__pycache__/matrix_get.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/__pycache__/matrix_palette.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/__pycache__/matrix_palette.cpython-312.pyc new file mode 100644 index 00000000..4e855343 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/__pycache__/matrix_palette.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/__pycache__/packed_depth_stencil.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/__pycache__/packed_depth_stencil.cpython-312.pyc new file mode 100644 index 00000000..6c002b76 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/__pycache__/packed_depth_stencil.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/__pycache__/point_size_array.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/__pycache__/point_size_array.cpython-312.pyc new file mode 100644 index 00000000..9800382a Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/__pycache__/point_size_array.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/__pycache__/point_sprite.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/__pycache__/point_sprite.cpython-312.pyc new file mode 100644 index 00000000..fe1906be Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/__pycache__/point_sprite.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/__pycache__/query_matrix.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/__pycache__/query_matrix.cpython-312.pyc new file mode 100644 index 00000000..3309a3fc Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/__pycache__/query_matrix.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/__pycache__/read_format.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/__pycache__/read_format.cpython-312.pyc new file mode 100644 index 00000000..8e4a4c9f Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/__pycache__/read_format.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/__pycache__/required_internalformat.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/__pycache__/required_internalformat.cpython-312.pyc new file mode 100644 index 00000000..ca808023 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/__pycache__/required_internalformat.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/__pycache__/rgb8_rgba8.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/__pycache__/rgb8_rgba8.cpython-312.pyc new file mode 100644 index 00000000..1daa8ae5 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/__pycache__/rgb8_rgba8.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/__pycache__/single_precision.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/__pycache__/single_precision.cpython-312.pyc new file mode 100644 index 00000000..0de3a2ce Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/__pycache__/single_precision.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/__pycache__/stencil1.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/__pycache__/stencil1.cpython-312.pyc new file mode 100644 index 00000000..01a7cea1 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/__pycache__/stencil1.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/__pycache__/stencil4.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/__pycache__/stencil4.cpython-312.pyc new file mode 100644 index 00000000..19bbf409 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/__pycache__/stencil4.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/__pycache__/stencil8.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/__pycache__/stencil8.cpython-312.pyc new file mode 100644 index 00000000..e9983c07 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/__pycache__/stencil8.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/__pycache__/stencil_wrap.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/__pycache__/stencil_wrap.cpython-312.pyc new file mode 100644 index 00000000..20fc0e3b Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/__pycache__/stencil_wrap.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/__pycache__/surfaceless_context.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/__pycache__/surfaceless_context.cpython-312.pyc new file mode 100644 index 00000000..2cb768a0 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/__pycache__/surfaceless_context.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/__pycache__/texture_cube_map.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/__pycache__/texture_cube_map.cpython-312.pyc new file mode 100644 index 00000000..b3b58bf2 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/__pycache__/texture_cube_map.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/__pycache__/texture_env_crossbar.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/__pycache__/texture_env_crossbar.cpython-312.pyc new file mode 100644 index 00000000..9157b9a3 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/__pycache__/texture_env_crossbar.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/__pycache__/texture_mirrored_repeat.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/__pycache__/texture_mirrored_repeat.cpython-312.pyc new file mode 100644 index 00000000..dfecf8c1 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/__pycache__/texture_mirrored_repeat.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/__pycache__/texture_npot.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/__pycache__/texture_npot.cpython-312.pyc new file mode 100644 index 00000000..f11f9c5a Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/__pycache__/texture_npot.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/__pycache__/vertex_array_object.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/__pycache__/vertex_array_object.cpython-312.pyc new file mode 100644 index 00000000..0ac6a464 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/__pycache__/vertex_array_object.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/blend_equation_separate.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/blend_equation_separate.py new file mode 100644 index 00000000..2da896e8 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/blend_equation_separate.py @@ -0,0 +1,18 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES1 import _types as _cs +# End users want this... +from OpenGL.raw.GLES1._types import * +from OpenGL.raw.GLES1 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES1_OES_blend_equation_separate' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES1,'GLES1_OES_blend_equation_separate',error_checker=_errors._error_checker) +GL_BLEND_EQUATION_ALPHA_OES=_C('GL_BLEND_EQUATION_ALPHA_OES',0x883D) +GL_BLEND_EQUATION_RGB_OES=_C('GL_BLEND_EQUATION_RGB_OES',0x8009) +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum) +def glBlendEquationSeparateOES(modeRGB,modeAlpha):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/blend_func_separate.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/blend_func_separate.py new file mode 100644 index 00000000..75c1df43 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/blend_func_separate.py @@ -0,0 +1,20 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES1 import _types as _cs +# End users want this... +from OpenGL.raw.GLES1._types import * +from OpenGL.raw.GLES1 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES1_OES_blend_func_separate' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES1,'GLES1_OES_blend_func_separate',error_checker=_errors._error_checker) +GL_BLEND_DST_ALPHA_OES=_C('GL_BLEND_DST_ALPHA_OES',0x80CA) +GL_BLEND_DST_RGB_OES=_C('GL_BLEND_DST_RGB_OES',0x80C8) +GL_BLEND_SRC_ALPHA_OES=_C('GL_BLEND_SRC_ALPHA_OES',0x80CB) +GL_BLEND_SRC_RGB_OES=_C('GL_BLEND_SRC_RGB_OES',0x80C9) +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLenum,_cs.GLenum) +def glBlendFuncSeparateOES(srcRGB,dstRGB,srcAlpha,dstAlpha):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/blend_subtract.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/blend_subtract.py new file mode 100644 index 00000000..343a6d1a --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/blend_subtract.py @@ -0,0 +1,20 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES1 import _types as _cs +# End users want this... +from OpenGL.raw.GLES1._types import * +from OpenGL.raw.GLES1 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES1_OES_blend_subtract' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES1,'GLES1_OES_blend_subtract',error_checker=_errors._error_checker) +GL_BLEND_EQUATION_OES=_C('GL_BLEND_EQUATION_OES',0x8009) +GL_FUNC_ADD_OES=_C('GL_FUNC_ADD_OES',0x8006) +GL_FUNC_REVERSE_SUBTRACT_OES=_C('GL_FUNC_REVERSE_SUBTRACT_OES',0x800B) +GL_FUNC_SUBTRACT_OES=_C('GL_FUNC_SUBTRACT_OES',0x800A) +@_f +@_p.types(None,_cs.GLenum) +def glBlendEquationOES(mode):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/byte_coordinates.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/byte_coordinates.py new file mode 100644 index 00000000..baf75fa5 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/byte_coordinates.py @@ -0,0 +1,80 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES1 import _types as _cs +# End users want this... +from OpenGL.raw.GLES1._types import * +from OpenGL.raw.GLES1 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES1_OES_byte_coordinates' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES1,'GLES1_OES_byte_coordinates',error_checker=_errors._error_checker) +GL_BYTE=_C('GL_BYTE',0x1400) +@_f +@_p.types(None,_cs.GLenum,_cs.GLbyte) +def glMultiTexCoord1bOES(texture,s):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLbyteArray) +def glMultiTexCoord1bvOES(texture,coords):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLbyte,_cs.GLbyte) +def glMultiTexCoord2bOES(texture,s,t):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLbyteArray) +def glMultiTexCoord2bvOES(texture,coords):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLbyte,_cs.GLbyte,_cs.GLbyte) +def glMultiTexCoord3bOES(texture,s,t,r):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLbyteArray) +def glMultiTexCoord3bvOES(texture,coords):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLbyte,_cs.GLbyte,_cs.GLbyte,_cs.GLbyte) +def glMultiTexCoord4bOES(texture,s,t,r,q):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLbyteArray) +def glMultiTexCoord4bvOES(texture,coords):pass +@_f +@_p.types(None,_cs.GLbyte) +def glTexCoord1bOES(s):pass +@_f +@_p.types(None,arrays.GLbyteArray) +def glTexCoord1bvOES(coords):pass +@_f +@_p.types(None,_cs.GLbyte,_cs.GLbyte) +def glTexCoord2bOES(s,t):pass +@_f +@_p.types(None,arrays.GLbyteArray) +def glTexCoord2bvOES(coords):pass +@_f +@_p.types(None,_cs.GLbyte,_cs.GLbyte,_cs.GLbyte) +def glTexCoord3bOES(s,t,r):pass +@_f +@_p.types(None,arrays.GLbyteArray) +def glTexCoord3bvOES(coords):pass +@_f +@_p.types(None,_cs.GLbyte,_cs.GLbyte,_cs.GLbyte,_cs.GLbyte) +def glTexCoord4bOES(s,t,r,q):pass +@_f +@_p.types(None,arrays.GLbyteArray) +def glTexCoord4bvOES(coords):pass +@_f +@_p.types(None,_cs.GLbyte,_cs.GLbyte) +def glVertex2bOES(x,y):pass +@_f +@_p.types(None,arrays.GLbyteArray) +def glVertex2bvOES(coords):pass +@_f +@_p.types(None,_cs.GLbyte,_cs.GLbyte,_cs.GLbyte) +def glVertex3bOES(x,y,z):pass +@_f +@_p.types(None,arrays.GLbyteArray) +def glVertex3bvOES(coords):pass +@_f +@_p.types(None,_cs.GLbyte,_cs.GLbyte,_cs.GLbyte,_cs.GLbyte) +def glVertex4bOES(x,y,z,w):pass +@_f +@_p.types(None,arrays.GLbyteArray) +def glVertex4bvOES(coords):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/compressed_ETC1_RGB8_sub_texture.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/compressed_ETC1_RGB8_sub_texture.py new file mode 100644 index 00000000..acb9f8c8 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/compressed_ETC1_RGB8_sub_texture.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES1 import _types as _cs +# End users want this... +from OpenGL.raw.GLES1._types import * +from OpenGL.raw.GLES1 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES1_OES_compressed_ETC1_RGB8_sub_texture' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES1,'GLES1_OES_compressed_ETC1_RGB8_sub_texture',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/compressed_ETC1_RGB8_texture.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/compressed_ETC1_RGB8_texture.py new file mode 100644 index 00000000..d6e29670 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/compressed_ETC1_RGB8_texture.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES1 import _types as _cs +# End users want this... +from OpenGL.raw.GLES1._types import * +from OpenGL.raw.GLES1 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES1_OES_compressed_ETC1_RGB8_texture' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES1,'GLES1_OES_compressed_ETC1_RGB8_texture',error_checker=_errors._error_checker) +GL_ETC1_RGB8_OES=_C('GL_ETC1_RGB8_OES',0x8D64) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/compressed_paletted_texture.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/compressed_paletted_texture.py new file mode 100644 index 00000000..25951c27 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/compressed_paletted_texture.py @@ -0,0 +1,24 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES1 import _types as _cs +# End users want this... +from OpenGL.raw.GLES1._types import * +from OpenGL.raw.GLES1 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES1_OES_compressed_paletted_texture' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES1,'GLES1_OES_compressed_paletted_texture',error_checker=_errors._error_checker) +GL_PALETTE4_R5_G6_B5_OES=_C('GL_PALETTE4_R5_G6_B5_OES',0x8B92) +GL_PALETTE4_RGB5_A1_OES=_C('GL_PALETTE4_RGB5_A1_OES',0x8B94) +GL_PALETTE4_RGB8_OES=_C('GL_PALETTE4_RGB8_OES',0x8B90) +GL_PALETTE4_RGBA4_OES=_C('GL_PALETTE4_RGBA4_OES',0x8B93) +GL_PALETTE4_RGBA8_OES=_C('GL_PALETTE4_RGBA8_OES',0x8B91) +GL_PALETTE8_R5_G6_B5_OES=_C('GL_PALETTE8_R5_G6_B5_OES',0x8B97) +GL_PALETTE8_RGB5_A1_OES=_C('GL_PALETTE8_RGB5_A1_OES',0x8B99) +GL_PALETTE8_RGB8_OES=_C('GL_PALETTE8_RGB8_OES',0x8B95) +GL_PALETTE8_RGBA4_OES=_C('GL_PALETTE8_RGBA4_OES',0x8B98) +GL_PALETTE8_RGBA8_OES=_C('GL_PALETTE8_RGBA8_OES',0x8B96) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/depth24.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/depth24.py new file mode 100644 index 00000000..e784696d --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/depth24.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES1 import _types as _cs +# End users want this... +from OpenGL.raw.GLES1._types import * +from OpenGL.raw.GLES1 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES1_OES_depth24' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES1,'GLES1_OES_depth24',error_checker=_errors._error_checker) +GL_DEPTH_COMPONENT24_OES=_C('GL_DEPTH_COMPONENT24_OES',0x81A6) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/depth32.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/depth32.py new file mode 100644 index 00000000..b3b288a6 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/depth32.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES1 import _types as _cs +# End users want this... +from OpenGL.raw.GLES1._types import * +from OpenGL.raw.GLES1 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES1_OES_depth32' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES1,'GLES1_OES_depth32',error_checker=_errors._error_checker) +GL_DEPTH_COMPONENT32_OES=_C('GL_DEPTH_COMPONENT32_OES',0x81A7) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/draw_texture.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/draw_texture.py new file mode 100644 index 00000000..d58a90ea --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/draw_texture.py @@ -0,0 +1,38 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES1 import _types as _cs +# End users want this... +from OpenGL.raw.GLES1._types import * +from OpenGL.raw.GLES1 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES1_OES_draw_texture' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES1,'GLES1_OES_draw_texture',error_checker=_errors._error_checker) +GL_TEXTURE_CROP_RECT_OES=_C('GL_TEXTURE_CROP_RECT_OES',0x8B9D) +@_f +@_p.types(None,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat) +def glDrawTexfOES(x,y,z,width,height):pass +@_f +@_p.types(None,arrays.GLfloatArray) +def glDrawTexfvOES(coords):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint) +def glDrawTexiOES(x,y,z,width,height):pass +@_f +@_p.types(None,arrays.GLintArray) +def glDrawTexivOES(coords):pass +@_f +@_p.types(None,_cs.GLshort,_cs.GLshort,_cs.GLshort,_cs.GLshort,_cs.GLshort) +def glDrawTexsOES(x,y,z,width,height):pass +@_f +@_p.types(None,arrays.GLshortArray) +def glDrawTexsvOES(coords):pass +@_f +@_p.types(None,_cs.GLfixed,_cs.GLfixed,_cs.GLfixed,_cs.GLfixed,_cs.GLfixed) +def glDrawTexxOES(x,y,z,width,height):pass +@_f +@_p.types(None,arrays.GLfixedArray) +def glDrawTexxvOES(coords):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/element_index_uint.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/element_index_uint.py new file mode 100644 index 00000000..d47f655c --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/element_index_uint.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES1 import _types as _cs +# End users want this... +from OpenGL.raw.GLES1._types import * +from OpenGL.raw.GLES1 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES1_OES_element_index_uint' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES1,'GLES1_OES_element_index_uint',error_checker=_errors._error_checker) +GL_UNSIGNED_INT=_C('GL_UNSIGNED_INT',0x1405) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/extended_matrix_palette.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/extended_matrix_palette.py new file mode 100644 index 00000000..a63febb8 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/extended_matrix_palette.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES1 import _types as _cs +# End users want this... +from OpenGL.raw.GLES1._types import * +from OpenGL.raw.GLES1 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES1_OES_extended_matrix_palette' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES1,'GLES1_OES_extended_matrix_palette',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/fbo_render_mipmap.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/fbo_render_mipmap.py new file mode 100644 index 00000000..308e6a57 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/fbo_render_mipmap.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES1 import _types as _cs +# End users want this... +from OpenGL.raw.GLES1._types import * +from OpenGL.raw.GLES1 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES1_OES_fbo_render_mipmap' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES1,'GLES1_OES_fbo_render_mipmap',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/fixed_point.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/fixed_point.py new file mode 100644 index 00000000..232285c1 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/fixed_point.py @@ -0,0 +1,335 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES1 import _types as _cs +# End users want this... +from OpenGL.raw.GLES1._types import * +from OpenGL.raw.GLES1 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES1_OES_fixed_point' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES1,'GLES1_OES_fixed_point',error_checker=_errors._error_checker) +GL_FIXED_OES=_C('GL_FIXED_OES',0x140C) +@_f +@_p.types(None,_cs.GLenum,_cs.GLfixed) +def glAccumxOES(op,value):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLfixed) +def glAlphaFuncxOES(func,ref):pass +@_f +@_p.types(None,_cs.GLsizei,_cs.GLsizei,_cs.GLfixed,_cs.GLfixed,_cs.GLfixed,_cs.GLfixed,arrays.GLubyteArray) +def glBitmapxOES(width,height,xorig,yorig,xmove,ymove,bitmap):pass +@_f +@_p.types(None,_cs.GLfixed,_cs.GLfixed,_cs.GLfixed,_cs.GLfixed) +def glBlendColorxOES(red,green,blue,alpha):pass +@_f +@_p.types(None,_cs.GLfixed,_cs.GLfixed,_cs.GLfixed,_cs.GLfixed) +def glClearAccumxOES(red,green,blue,alpha):pass +@_f +@_p.types(None,_cs.GLfixed,_cs.GLfixed,_cs.GLfixed,_cs.GLfixed) +def glClearColorxOES(red,green,blue,alpha):pass +@_f +@_p.types(None,_cs.GLfixed) +def glClearDepthxOES(depth):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLfixedArray) +def glClipPlanexOES(plane,equation):pass +@_f +@_p.types(None,_cs.GLfixed,_cs.GLfixed,_cs.GLfixed) +def glColor3xOES(red,green,blue):pass +@_f +@_p.types(None,arrays.GLfixedArray) +def glColor3xvOES(components):pass +@_f +@_p.types(None,_cs.GLfixed,_cs.GLfixed,_cs.GLfixed,_cs.GLfixed) +def glColor4xOES(red,green,blue,alpha):pass +@_f +@_p.types(None,arrays.GLfixedArray) +def glColor4xvOES(components):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLfixed) +def glConvolutionParameterxOES(target,pname,param):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLfixedArray) +def glConvolutionParameterxvOES(target,pname,params):pass +@_f +@_p.types(None,_cs.GLfixed,_cs.GLfixed) +def glDepthRangexOES(n,f):pass +@_f +@_p.types(None,_cs.GLfixed) +def glEvalCoord1xOES(u):pass +@_f +@_p.types(None,arrays.GLfixedArray) +def glEvalCoord1xvOES(coords):pass +@_f +@_p.types(None,_cs.GLfixed,_cs.GLfixed) +def glEvalCoord2xOES(u,v):pass +@_f +@_p.types(None,arrays.GLfixedArray) +def glEvalCoord2xvOES(coords):pass +@_f +@_p.types(None,_cs.GLsizei,_cs.GLenum,arrays.GLfixedArray) +def glFeedbackBufferxOES(n,type,buffer):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLfixed) +def glFogxOES(pname,param):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLfixedArray) +def glFogxvOES(pname,param):pass +@_f +@_p.types(None,_cs.GLfixed,_cs.GLfixed,_cs.GLfixed,_cs.GLfixed,_cs.GLfixed,_cs.GLfixed) +def glFrustumxOES(l,r,b,t,n,f):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLfixedArray) +def glGetClipPlanexOES(plane,equation):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLfixedArray) +def glGetConvolutionParameterxvOES(target,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLfixedArray) +def glGetFixedvOES(pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLfixedArray) +def glGetHistogramParameterxvOES(target,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLfixedArray) +def glGetLightxOES(light,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLfixedArray) +def glGetLightxvOES(light,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLfixedArray) +def glGetMapxvOES(target,query,v):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLfixed) +def glGetMaterialxOES(face,pname,param):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLfixedArray) +def glGetMaterialxvOES(face,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLint,arrays.GLfixedArray) +def glGetPixelMapxv(map,size,values):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLfixedArray) +def glGetTexEnvxvOES(target,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLfixedArray) +def glGetTexGenxvOES(coord,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLint,_cs.GLenum,arrays.GLfixedArray) +def glGetTexLevelParameterxvOES(target,level,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLfixedArray) +def glGetTexParameterxvOES(target,pname,params):pass +@_f +@_p.types(None,_cs.GLfixed) +def glIndexxOES(component):pass +@_f +@_p.types(None,arrays.GLfixedArray) +def glIndexxvOES(component):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLfixed) +def glLightModelxOES(pname,param):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLfixedArray) +def glLightModelxvOES(pname,param):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLfixed) +def glLightxOES(light,pname,param):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLfixedArray) +def glLightxvOES(light,pname,params):pass +@_f +@_p.types(None,_cs.GLfixed) +def glLineWidthxOES(width):pass +@_f +@_p.types(None,arrays.GLfixedArray) +def glLoadMatrixxOES(m):pass +@_f +@_p.types(None,arrays.GLfixedArray) +def glLoadTransposeMatrixxOES(m):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLfixed,_cs.GLfixed,_cs.GLint,_cs.GLint,_cs.GLfixed) +def glMap1xOES(target,u1,u2,stride,order,points):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLfixed,_cs.GLfixed,_cs.GLint,_cs.GLint,_cs.GLfixed,_cs.GLfixed,_cs.GLint,_cs.GLint,_cs.GLfixed) +def glMap2xOES(target,u1,u2,ustride,uorder,v1,v2,vstride,vorder,points):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLfixed,_cs.GLfixed) +def glMapGrid1xOES(n,u1,u2):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLfixed,_cs.GLfixed,_cs.GLfixed,_cs.GLfixed) +def glMapGrid2xOES(n,u1,u2,v1,v2):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLfixed) +def glMaterialxOES(face,pname,param):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLfixedArray) +def glMaterialxvOES(face,pname,param):pass +@_f +@_p.types(None,arrays.GLfixedArray) +def glMultMatrixxOES(m):pass +@_f +@_p.types(None,arrays.GLfixedArray) +def glMultTransposeMatrixxOES(m):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLfixed) +def glMultiTexCoord1xOES(texture,s):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLfixedArray) +def glMultiTexCoord1xvOES(texture,coords):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLfixed,_cs.GLfixed) +def glMultiTexCoord2xOES(texture,s,t):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLfixedArray) +def glMultiTexCoord2xvOES(texture,coords):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLfixed,_cs.GLfixed,_cs.GLfixed) +def glMultiTexCoord3xOES(texture,s,t,r):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLfixedArray) +def glMultiTexCoord3xvOES(texture,coords):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLfixed,_cs.GLfixed,_cs.GLfixed,_cs.GLfixed) +def glMultiTexCoord4xOES(texture,s,t,r,q):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLfixedArray) +def glMultiTexCoord4xvOES(texture,coords):pass +@_f +@_p.types(None,_cs.GLfixed,_cs.GLfixed,_cs.GLfixed) +def glNormal3xOES(nx,ny,nz):pass +@_f +@_p.types(None,arrays.GLfixedArray) +def glNormal3xvOES(coords):pass +@_f +@_p.types(None,_cs.GLfixed,_cs.GLfixed,_cs.GLfixed,_cs.GLfixed,_cs.GLfixed,_cs.GLfixed) +def glOrthoxOES(l,r,b,t,n,f):pass +@_f +@_p.types(None,_cs.GLfixed) +def glPassThroughxOES(token):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLint,arrays.GLfixedArray) +def glPixelMapx(map,size,values):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLfixed) +def glPixelStorex(pname,param):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLfixed) +def glPixelTransferxOES(pname,param):pass +@_f +@_p.types(None,_cs.GLfixed,_cs.GLfixed) +def glPixelZoomxOES(xfactor,yfactor):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLfixed) +def glPointParameterxOES(pname,param):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLfixedArray) +def glPointParameterxvOES(pname,params):pass +@_f +@_p.types(None,_cs.GLfixed) +def glPointSizexOES(size):pass +@_f +@_p.types(None,_cs.GLfixed,_cs.GLfixed) +def glPolygonOffsetxOES(factor,units):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray,arrays.GLfixedArray) +def glPrioritizeTexturesxOES(n,textures,priorities):pass +@_f +@_p.types(None,_cs.GLfixed,_cs.GLfixed) +def glRasterPos2xOES(x,y):pass +@_f +@_p.types(None,arrays.GLfixedArray) +def glRasterPos2xvOES(coords):pass +@_f +@_p.types(None,_cs.GLfixed,_cs.GLfixed,_cs.GLfixed) +def glRasterPos3xOES(x,y,z):pass +@_f +@_p.types(None,arrays.GLfixedArray) +def glRasterPos3xvOES(coords):pass +@_f +@_p.types(None,_cs.GLfixed,_cs.GLfixed,_cs.GLfixed,_cs.GLfixed) +def glRasterPos4xOES(x,y,z,w):pass +@_f +@_p.types(None,arrays.GLfixedArray) +def glRasterPos4xvOES(coords):pass +@_f +@_p.types(None,_cs.GLfixed,_cs.GLfixed,_cs.GLfixed,_cs.GLfixed) +def glRectxOES(x1,y1,x2,y2):pass +@_f +@_p.types(None,arrays.GLfixedArray,arrays.GLfixedArray) +def glRectxvOES(v1,v2):pass +@_f +@_p.types(None,_cs.GLfixed,_cs.GLfixed,_cs.GLfixed,_cs.GLfixed) +def glRotatexOES(angle,x,y,z):pass +@_f +@_p.types(None,_cs.GLclampx,_cs.GLboolean) +def glSampleCoveragexOES(value,invert):pass +@_f +@_p.types(None,_cs.GLfixed,_cs.GLfixed,_cs.GLfixed) +def glScalexOES(x,y,z):pass +@_f +@_p.types(None,_cs.GLfixed) +def glTexCoord1xOES(s):pass +@_f +@_p.types(None,arrays.GLfixedArray) +def glTexCoord1xvOES(coords):pass +@_f +@_p.types(None,_cs.GLfixed,_cs.GLfixed) +def glTexCoord2xOES(s,t):pass +@_f +@_p.types(None,arrays.GLfixedArray) +def glTexCoord2xvOES(coords):pass +@_f +@_p.types(None,_cs.GLfixed,_cs.GLfixed,_cs.GLfixed) +def glTexCoord3xOES(s,t,r):pass +@_f +@_p.types(None,arrays.GLfixedArray) +def glTexCoord3xvOES(coords):pass +@_f +@_p.types(None,_cs.GLfixed,_cs.GLfixed,_cs.GLfixed,_cs.GLfixed) +def glTexCoord4xOES(s,t,r,q):pass +@_f +@_p.types(None,arrays.GLfixedArray) +def glTexCoord4xvOES(coords):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLfixed) +def glTexEnvxOES(target,pname,param):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLfixedArray) +def glTexEnvxvOES(target,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLfixed) +def glTexGenxOES(coord,pname,param):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLfixedArray) +def glTexGenxvOES(coord,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLfixed) +def glTexParameterxOES(target,pname,param):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLfixedArray) +def glTexParameterxvOES(target,pname,params):pass +@_f +@_p.types(None,_cs.GLfixed,_cs.GLfixed,_cs.GLfixed) +def glTranslatexOES(x,y,z):pass +@_f +@_p.types(None,_cs.GLfixed) +def glVertex2xOES(x):pass +@_f +@_p.types(None,arrays.GLfixedArray) +def glVertex2xvOES(coords):pass +@_f +@_p.types(None,_cs.GLfixed,_cs.GLfixed) +def glVertex3xOES(x,y):pass +@_f +@_p.types(None,arrays.GLfixedArray) +def glVertex3xvOES(coords):pass +@_f +@_p.types(None,_cs.GLfixed,_cs.GLfixed,_cs.GLfixed) +def glVertex4xOES(x,y,z):pass +@_f +@_p.types(None,arrays.GLfixedArray) +def glVertex4xvOES(coords):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/framebuffer_object.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/framebuffer_object.py new file mode 100644 index 00000000..87f25d8a --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/framebuffer_object.py @@ -0,0 +1,91 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES1 import _types as _cs +# End users want this... +from OpenGL.raw.GLES1._types import * +from OpenGL.raw.GLES1 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES1_OES_framebuffer_object' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES1,'GLES1_OES_framebuffer_object',error_checker=_errors._error_checker) +GL_COLOR_ATTACHMENT0_OES=_C('GL_COLOR_ATTACHMENT0_OES',0x8CE0) +GL_DEPTH_ATTACHMENT_OES=_C('GL_DEPTH_ATTACHMENT_OES',0x8D00) +GL_DEPTH_COMPONENT16_OES=_C('GL_DEPTH_COMPONENT16_OES',0x81A5) +GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_OES=_C('GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_OES',0x8CD1) +GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_OES=_C('GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_OES',0x8CD0) +GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_OES=_C('GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_OES',0x8CD3) +GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_OES=_C('GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_OES',0x8CD2) +GL_FRAMEBUFFER_BINDING_OES=_C('GL_FRAMEBUFFER_BINDING_OES',0x8CA6) +GL_FRAMEBUFFER_COMPLETE_OES=_C('GL_FRAMEBUFFER_COMPLETE_OES',0x8CD5) +GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_OES=_C('GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_OES',0x8CD6) +GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_OES=_C('GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_OES',0x8CD9) +GL_FRAMEBUFFER_INCOMPLETE_FORMATS_OES=_C('GL_FRAMEBUFFER_INCOMPLETE_FORMATS_OES',0x8CDA) +GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_OES=_C('GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_OES',0x8CD7) +GL_FRAMEBUFFER_OES=_C('GL_FRAMEBUFFER_OES',0x8D40) +GL_FRAMEBUFFER_UNSUPPORTED_OES=_C('GL_FRAMEBUFFER_UNSUPPORTED_OES',0x8CDD) +GL_INVALID_FRAMEBUFFER_OPERATION_OES=_C('GL_INVALID_FRAMEBUFFER_OPERATION_OES',0x0506) +GL_MAX_RENDERBUFFER_SIZE_OES=_C('GL_MAX_RENDERBUFFER_SIZE_OES',0x84E8) +GL_NONE_OES=_C('GL_NONE_OES',0) +GL_RENDERBUFFER_ALPHA_SIZE_OES=_C('GL_RENDERBUFFER_ALPHA_SIZE_OES',0x8D53) +GL_RENDERBUFFER_BINDING_OES=_C('GL_RENDERBUFFER_BINDING_OES',0x8CA7) +GL_RENDERBUFFER_BLUE_SIZE_OES=_C('GL_RENDERBUFFER_BLUE_SIZE_OES',0x8D52) +GL_RENDERBUFFER_DEPTH_SIZE_OES=_C('GL_RENDERBUFFER_DEPTH_SIZE_OES',0x8D54) +GL_RENDERBUFFER_GREEN_SIZE_OES=_C('GL_RENDERBUFFER_GREEN_SIZE_OES',0x8D51) +GL_RENDERBUFFER_HEIGHT_OES=_C('GL_RENDERBUFFER_HEIGHT_OES',0x8D43) +GL_RENDERBUFFER_INTERNAL_FORMAT_OES=_C('GL_RENDERBUFFER_INTERNAL_FORMAT_OES',0x8D44) +GL_RENDERBUFFER_OES=_C('GL_RENDERBUFFER_OES',0x8D41) +GL_RENDERBUFFER_RED_SIZE_OES=_C('GL_RENDERBUFFER_RED_SIZE_OES',0x8D50) +GL_RENDERBUFFER_STENCIL_SIZE_OES=_C('GL_RENDERBUFFER_STENCIL_SIZE_OES',0x8D55) +GL_RENDERBUFFER_WIDTH_OES=_C('GL_RENDERBUFFER_WIDTH_OES',0x8D42) +GL_RGB565_OES=_C('GL_RGB565_OES',0x8D62) +GL_RGB5_A1_OES=_C('GL_RGB5_A1_OES',0x8057) +GL_RGBA4_OES=_C('GL_RGBA4_OES',0x8056) +GL_STENCIL_ATTACHMENT_OES=_C('GL_STENCIL_ATTACHMENT_OES',0x8D20) +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint) +def glBindFramebufferOES(target,framebuffer):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint) +def glBindRenderbufferOES(target,renderbuffer):pass +@_f +@_p.types(_cs.GLenum,_cs.GLenum) +def glCheckFramebufferStatusOES(target):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray) +def glDeleteFramebuffersOES(n,framebuffers):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray) +def glDeleteRenderbuffersOES(n,renderbuffers):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLenum,_cs.GLuint) +def glFramebufferRenderbufferOES(target,attachment,renderbuffertarget,renderbuffer):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLenum,_cs.GLuint,_cs.GLint) +def glFramebufferTexture2DOES(target,attachment,textarget,texture,level):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray) +def glGenFramebuffersOES(n,framebuffers):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray) +def glGenRenderbuffersOES(n,renderbuffers):pass +@_f +@_p.types(None,_cs.GLenum) +def glGenerateMipmapOES(target):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLenum,arrays.GLintArray) +def glGetFramebufferAttachmentParameterivOES(target,attachment,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLintArray) +def glGetRenderbufferParameterivOES(target,pname,params):pass +@_f +@_p.types(_cs.GLboolean,_cs.GLuint) +def glIsFramebufferOES(framebuffer):pass +@_f +@_p.types(_cs.GLboolean,_cs.GLuint) +def glIsRenderbufferOES(renderbuffer):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLsizei,_cs.GLsizei) +def glRenderbufferStorageOES(target,internalformat,width,height):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/mapbuffer.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/mapbuffer.py new file mode 100644 index 00000000..b1420fe0 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/mapbuffer.py @@ -0,0 +1,26 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES1 import _types as _cs +# End users want this... +from OpenGL.raw.GLES1._types import * +from OpenGL.raw.GLES1 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES1_OES_mapbuffer' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES1,'GLES1_OES_mapbuffer',error_checker=_errors._error_checker) +GL_BUFFER_ACCESS_OES=_C('GL_BUFFER_ACCESS_OES',0x88BB) +GL_BUFFER_MAPPED_OES=_C('GL_BUFFER_MAPPED_OES',0x88BC) +GL_BUFFER_MAP_POINTER_OES=_C('GL_BUFFER_MAP_POINTER_OES',0x88BD) +GL_WRITE_ONLY_OES=_C('GL_WRITE_ONLY_OES',0x88B9) +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLvoidpArray) +def glGetBufferPointervOES(target,pname,params):pass +@_f +@_p.types(ctypes.c_void_p,_cs.GLenum,_cs.GLenum) +def glMapBufferOES(target,access):pass +@_f +@_p.types(_cs.GLboolean,_cs.GLenum) +def glUnmapBufferOES(target):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/matrix_get.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/matrix_get.py new file mode 100644 index 00000000..bcded10c --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/matrix_get.py @@ -0,0 +1,17 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES1 import _types as _cs +# End users want this... +from OpenGL.raw.GLES1._types import * +from OpenGL.raw.GLES1 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES1_OES_matrix_get' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES1,'GLES1_OES_matrix_get',error_checker=_errors._error_checker) +GL_MODELVIEW_MATRIX_FLOAT_AS_INT_BITS_OES=_C('GL_MODELVIEW_MATRIX_FLOAT_AS_INT_BITS_OES',0x898D) +GL_PROJECTION_MATRIX_FLOAT_AS_INT_BITS_OES=_C('GL_PROJECTION_MATRIX_FLOAT_AS_INT_BITS_OES',0x898E) +GL_TEXTURE_MATRIX_FLOAT_AS_INT_BITS_OES=_C('GL_TEXTURE_MATRIX_FLOAT_AS_INT_BITS_OES',0x898F) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/matrix_palette.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/matrix_palette.py new file mode 100644 index 00000000..9a9939bc --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/matrix_palette.py @@ -0,0 +1,41 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES1 import _types as _cs +# End users want this... +from OpenGL.raw.GLES1._types import * +from OpenGL.raw.GLES1 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES1_OES_matrix_palette' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES1,'GLES1_OES_matrix_palette',error_checker=_errors._error_checker) +GL_CURRENT_PALETTE_MATRIX_OES=_C('GL_CURRENT_PALETTE_MATRIX_OES',0x8843) +GL_MATRIX_INDEX_ARRAY_BUFFER_BINDING_OES=_C('GL_MATRIX_INDEX_ARRAY_BUFFER_BINDING_OES',0x8B9E) +GL_MATRIX_INDEX_ARRAY_OES=_C('GL_MATRIX_INDEX_ARRAY_OES',0x8844) +GL_MATRIX_INDEX_ARRAY_POINTER_OES=_C('GL_MATRIX_INDEX_ARRAY_POINTER_OES',0x8849) +GL_MATRIX_INDEX_ARRAY_SIZE_OES=_C('GL_MATRIX_INDEX_ARRAY_SIZE_OES',0x8846) +GL_MATRIX_INDEX_ARRAY_STRIDE_OES=_C('GL_MATRIX_INDEX_ARRAY_STRIDE_OES',0x8848) +GL_MATRIX_INDEX_ARRAY_TYPE_OES=_C('GL_MATRIX_INDEX_ARRAY_TYPE_OES',0x8847) +GL_MATRIX_PALETTE_OES=_C('GL_MATRIX_PALETTE_OES',0x8840) +GL_MAX_PALETTE_MATRICES_OES=_C('GL_MAX_PALETTE_MATRICES_OES',0x8842) +GL_MAX_VERTEX_UNITS_OES=_C('GL_MAX_VERTEX_UNITS_OES',0x86A4) +GL_WEIGHT_ARRAY_BUFFER_BINDING_OES=_C('GL_WEIGHT_ARRAY_BUFFER_BINDING_OES',0x889E) +GL_WEIGHT_ARRAY_OES=_C('GL_WEIGHT_ARRAY_OES',0x86AD) +GL_WEIGHT_ARRAY_POINTER_OES=_C('GL_WEIGHT_ARRAY_POINTER_OES',0x86AC) +GL_WEIGHT_ARRAY_SIZE_OES=_C('GL_WEIGHT_ARRAY_SIZE_OES',0x86AB) +GL_WEIGHT_ARRAY_STRIDE_OES=_C('GL_WEIGHT_ARRAY_STRIDE_OES',0x86AA) +GL_WEIGHT_ARRAY_TYPE_OES=_C('GL_WEIGHT_ARRAY_TYPE_OES',0x86A9) +@_f +@_p.types(None,_cs.GLuint) +def glCurrentPaletteMatrixOES(matrixpaletteindex):pass +@_f +@_p.types(None,) +def glLoadPaletteFromModelViewMatrixOES():pass +@_f +@_p.types(None,_cs.GLint,_cs.GLenum,_cs.GLsizei,ctypes.c_void_p) +def glMatrixIndexPointerOES(size,type,stride,pointer):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLenum,_cs.GLsizei,ctypes.c_void_p) +def glWeightPointerOES(size,type,stride,pointer):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/packed_depth_stencil.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/packed_depth_stencil.py new file mode 100644 index 00000000..aea7dd27 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/packed_depth_stencil.py @@ -0,0 +1,17 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES1 import _types as _cs +# End users want this... +from OpenGL.raw.GLES1._types import * +from OpenGL.raw.GLES1 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES1_OES_packed_depth_stencil' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES1,'GLES1_OES_packed_depth_stencil',error_checker=_errors._error_checker) +GL_DEPTH24_STENCIL8_OES=_C('GL_DEPTH24_STENCIL8_OES',0x88F0) +GL_DEPTH_STENCIL_OES=_C('GL_DEPTH_STENCIL_OES',0x84F9) +GL_UNSIGNED_INT_24_8_OES=_C('GL_UNSIGNED_INT_24_8_OES',0x84FA) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/point_size_array.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/point_size_array.py new file mode 100644 index 00000000..9d745603 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/point_size_array.py @@ -0,0 +1,21 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES1 import _types as _cs +# End users want this... +from OpenGL.raw.GLES1._types import * +from OpenGL.raw.GLES1 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES1_OES_point_size_array' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES1,'GLES1_OES_point_size_array',error_checker=_errors._error_checker) +GL_POINT_SIZE_ARRAY_BUFFER_BINDING_OES=_C('GL_POINT_SIZE_ARRAY_BUFFER_BINDING_OES',0x8B9F) +GL_POINT_SIZE_ARRAY_OES=_C('GL_POINT_SIZE_ARRAY_OES',0x8B9C) +GL_POINT_SIZE_ARRAY_POINTER_OES=_C('GL_POINT_SIZE_ARRAY_POINTER_OES',0x898C) +GL_POINT_SIZE_ARRAY_STRIDE_OES=_C('GL_POINT_SIZE_ARRAY_STRIDE_OES',0x898B) +GL_POINT_SIZE_ARRAY_TYPE_OES=_C('GL_POINT_SIZE_ARRAY_TYPE_OES',0x898A) +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizei,ctypes.c_void_p) +def glPointSizePointerOES(type,stride,pointer):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/point_sprite.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/point_sprite.py new file mode 100644 index 00000000..8b5303e6 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/point_sprite.py @@ -0,0 +1,16 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES1 import _types as _cs +# End users want this... +from OpenGL.raw.GLES1._types import * +from OpenGL.raw.GLES1 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES1_OES_point_sprite' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES1,'GLES1_OES_point_sprite',error_checker=_errors._error_checker) +GL_COORD_REPLACE_OES=_C('GL_COORD_REPLACE_OES',0x8862) +GL_POINT_SPRITE_OES=_C('GL_POINT_SPRITE_OES',0x8861) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/query_matrix.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/query_matrix.py new file mode 100644 index 00000000..b24d787a --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/query_matrix.py @@ -0,0 +1,17 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES1 import _types as _cs +# End users want this... +from OpenGL.raw.GLES1._types import * +from OpenGL.raw.GLES1 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES1_OES_query_matrix' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES1,'GLES1_OES_query_matrix',error_checker=_errors._error_checker) + +@_f +@_p.types(_cs.GLbitfield,arrays.GLfixedArray,arrays.GLintArray) +def glQueryMatrixxOES(mantissa,exponent):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/read_format.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/read_format.py new file mode 100644 index 00000000..305f2182 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/read_format.py @@ -0,0 +1,16 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES1 import _types as _cs +# End users want this... +from OpenGL.raw.GLES1._types import * +from OpenGL.raw.GLES1 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES1_OES_read_format' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES1,'GLES1_OES_read_format',error_checker=_errors._error_checker) +GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES=_C('GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES',0x8B9B) +GL_IMPLEMENTATION_COLOR_READ_TYPE_OES=_C('GL_IMPLEMENTATION_COLOR_READ_TYPE_OES',0x8B9A) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/required_internalformat.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/required_internalformat.py new file mode 100644 index 00000000..26494bca --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/required_internalformat.py @@ -0,0 +1,29 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES1 import _types as _cs +# End users want this... +from OpenGL.raw.GLES1._types import * +from OpenGL.raw.GLES1 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES1_OES_required_internalformat' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES1,'GLES1_OES_required_internalformat',error_checker=_errors._error_checker) +GL_ALPHA8_OES=_C('GL_ALPHA8_OES',0x803C) +GL_DEPTH24_STENCIL8_OES=_C('GL_DEPTH24_STENCIL8_OES',0x88F0) +GL_DEPTH_COMPONENT16_OES=_C('GL_DEPTH_COMPONENT16_OES',0x81A5) +GL_DEPTH_COMPONENT24_OES=_C('GL_DEPTH_COMPONENT24_OES',0x81A6) +GL_DEPTH_COMPONENT32_OES=_C('GL_DEPTH_COMPONENT32_OES',0x81A7) +GL_LUMINANCE4_ALPHA4_OES=_C('GL_LUMINANCE4_ALPHA4_OES',0x8043) +GL_LUMINANCE8_ALPHA8_OES=_C('GL_LUMINANCE8_ALPHA8_OES',0x8045) +GL_LUMINANCE8_OES=_C('GL_LUMINANCE8_OES',0x8040) +GL_RGB10_A2_EXT=_C('GL_RGB10_A2_EXT',0x8059) +GL_RGB10_EXT=_C('GL_RGB10_EXT',0x8052) +GL_RGB565_OES=_C('GL_RGB565_OES',0x8D62) +GL_RGB5_A1_OES=_C('GL_RGB5_A1_OES',0x8057) +GL_RGB8_OES=_C('GL_RGB8_OES',0x8051) +GL_RGBA4_OES=_C('GL_RGBA4_OES',0x8056) +GL_RGBA8_OES=_C('GL_RGBA8_OES',0x8058) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/rgb8_rgba8.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/rgb8_rgba8.py new file mode 100644 index 00000000..04af3536 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/rgb8_rgba8.py @@ -0,0 +1,16 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES1 import _types as _cs +# End users want this... +from OpenGL.raw.GLES1._types import * +from OpenGL.raw.GLES1 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES1_OES_rgb8_rgba8' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES1,'GLES1_OES_rgb8_rgba8',error_checker=_errors._error_checker) +GL_RGB8_OES=_C('GL_RGB8_OES',0x8051) +GL_RGBA8_OES=_C('GL_RGBA8_OES',0x8058) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/single_precision.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/single_precision.py new file mode 100644 index 00000000..94618811 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/single_precision.py @@ -0,0 +1,32 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES1 import _types as _cs +# End users want this... +from OpenGL.raw.GLES1._types import * +from OpenGL.raw.GLES1 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES1_OES_single_precision' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES1,'GLES1_OES_single_precision',error_checker=_errors._error_checker) + +@_f +@_p.types(None,_cs.GLclampf) +def glClearDepthfOES(depth):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLfloatArray) +def glClipPlanefOES(plane,equation):pass +@_f +@_p.types(None,_cs.GLclampf,_cs.GLclampf) +def glDepthRangefOES(n,f):pass +@_f +@_p.types(None,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat) +def glFrustumfOES(l,r,b,t,n,f):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLfloatArray) +def glGetClipPlanefOES(plane,equation):pass +@_f +@_p.types(None,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat) +def glOrthofOES(l,r,b,t,n,f):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/stencil1.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/stencil1.py new file mode 100644 index 00000000..7fc9c363 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/stencil1.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES1 import _types as _cs +# End users want this... +from OpenGL.raw.GLES1._types import * +from OpenGL.raw.GLES1 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES1_OES_stencil1' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES1,'GLES1_OES_stencil1',error_checker=_errors._error_checker) +GL_STENCIL_INDEX1_OES=_C('GL_STENCIL_INDEX1_OES',0x8D46) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/stencil4.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/stencil4.py new file mode 100644 index 00000000..50aad987 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/stencil4.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES1 import _types as _cs +# End users want this... +from OpenGL.raw.GLES1._types import * +from OpenGL.raw.GLES1 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES1_OES_stencil4' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES1,'GLES1_OES_stencil4',error_checker=_errors._error_checker) +GL_STENCIL_INDEX4_OES=_C('GL_STENCIL_INDEX4_OES',0x8D47) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/stencil8.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/stencil8.py new file mode 100644 index 00000000..dc490a85 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/stencil8.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES1 import _types as _cs +# End users want this... +from OpenGL.raw.GLES1._types import * +from OpenGL.raw.GLES1 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES1_OES_stencil8' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES1,'GLES1_OES_stencil8',error_checker=_errors._error_checker) +GL_STENCIL_INDEX8_OES=_C('GL_STENCIL_INDEX8_OES',0x8D48) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/stencil_wrap.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/stencil_wrap.py new file mode 100644 index 00000000..74acabaf --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/stencil_wrap.py @@ -0,0 +1,16 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES1 import _types as _cs +# End users want this... +from OpenGL.raw.GLES1._types import * +from OpenGL.raw.GLES1 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES1_OES_stencil_wrap' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES1,'GLES1_OES_stencil_wrap',error_checker=_errors._error_checker) +GL_DECR_WRAP_OES=_C('GL_DECR_WRAP_OES',0x8508) +GL_INCR_WRAP_OES=_C('GL_INCR_WRAP_OES',0x8507) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/surfaceless_context.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/surfaceless_context.py new file mode 100644 index 00000000..60082411 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/surfaceless_context.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES1 import _types as _cs +# End users want this... +from OpenGL.raw.GLES1._types import * +from OpenGL.raw.GLES1 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES1_OES_surfaceless_context' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES1,'GLES1_OES_surfaceless_context',error_checker=_errors._error_checker) +GL_FRAMEBUFFER_UNDEFINED_OES=_C('GL_FRAMEBUFFER_UNDEFINED_OES',0x8219) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/texture_cube_map.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/texture_cube_map.py new file mode 100644 index 00000000..46502160 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/texture_cube_map.py @@ -0,0 +1,53 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES1 import _types as _cs +# End users want this... +from OpenGL.raw.GLES1._types import * +from OpenGL.raw.GLES1 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES1_OES_texture_cube_map' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES1,'GLES1_OES_texture_cube_map',error_checker=_errors._error_checker) +GL_MAX_CUBE_MAP_TEXTURE_SIZE_OES=_C('GL_MAX_CUBE_MAP_TEXTURE_SIZE_OES',0x851C) +GL_NORMAL_MAP_OES=_C('GL_NORMAL_MAP_OES',0x8511) +GL_REFLECTION_MAP_OES=_C('GL_REFLECTION_MAP_OES',0x8512) +GL_TEXTURE_BINDING_CUBE_MAP_OES=_C('GL_TEXTURE_BINDING_CUBE_MAP_OES',0x8514) +GL_TEXTURE_CUBE_MAP_NEGATIVE_X_OES=_C('GL_TEXTURE_CUBE_MAP_NEGATIVE_X_OES',0x8516) +GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_OES=_C('GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_OES',0x8518) +GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_OES=_C('GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_OES',0x851A) +GL_TEXTURE_CUBE_MAP_OES=_C('GL_TEXTURE_CUBE_MAP_OES',0x8513) +GL_TEXTURE_CUBE_MAP_POSITIVE_X_OES=_C('GL_TEXTURE_CUBE_MAP_POSITIVE_X_OES',0x8515) +GL_TEXTURE_CUBE_MAP_POSITIVE_Y_OES=_C('GL_TEXTURE_CUBE_MAP_POSITIVE_Y_OES',0x8517) +GL_TEXTURE_CUBE_MAP_POSITIVE_Z_OES=_C('GL_TEXTURE_CUBE_MAP_POSITIVE_Z_OES',0x8519) +GL_TEXTURE_GEN_MODE_OES=_C('GL_TEXTURE_GEN_MODE_OES',0x2500) +GL_TEXTURE_GEN_STR_OES=_C('GL_TEXTURE_GEN_STR_OES',0x8D60) +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLfloatArray) +def glGetTexGenfvOES(coord,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLintArray) +def glGetTexGenivOES(coord,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLfixedArray) +def glGetTexGenxvOES(coord,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLfloat) +def glTexGenfOES(coord,pname,param):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLfloatArray) +def glTexGenfvOES(coord,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLint) +def glTexGeniOES(coord,pname,param):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLintArray) +def glTexGenivOES(coord,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLfixed) +def glTexGenxOES(coord,pname,param):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLfixedArray) +def glTexGenxvOES(coord,pname,params):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/texture_env_crossbar.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/texture_env_crossbar.py new file mode 100644 index 00000000..5c0c8ebc --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/texture_env_crossbar.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES1 import _types as _cs +# End users want this... +from OpenGL.raw.GLES1._types import * +from OpenGL.raw.GLES1 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES1_OES_texture_env_crossbar' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES1,'GLES1_OES_texture_env_crossbar',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/texture_mirrored_repeat.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/texture_mirrored_repeat.py new file mode 100644 index 00000000..ba8f49ed --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/texture_mirrored_repeat.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES1 import _types as _cs +# End users want this... +from OpenGL.raw.GLES1._types import * +from OpenGL.raw.GLES1 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES1_OES_texture_mirrored_repeat' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES1,'GLES1_OES_texture_mirrored_repeat',error_checker=_errors._error_checker) +GL_MIRRORED_REPEAT_OES=_C('GL_MIRRORED_REPEAT_OES',0x8370) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/texture_npot.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/texture_npot.py new file mode 100644 index 00000000..9f151564 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/texture_npot.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES1 import _types as _cs +# End users want this... +from OpenGL.raw.GLES1._types import * +from OpenGL.raw.GLES1 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES1_OES_texture_npot' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES1,'GLES1_OES_texture_npot',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/vertex_array_object.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/vertex_array_object.py new file mode 100644 index 00000000..33945bda --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/OES/vertex_array_object.py @@ -0,0 +1,26 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES1 import _types as _cs +# End users want this... +from OpenGL.raw.GLES1._types import * +from OpenGL.raw.GLES1 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES1_OES_vertex_array_object' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES1,'GLES1_OES_vertex_array_object',error_checker=_errors._error_checker) +GL_VERTEX_ARRAY_BINDING_OES=_C('GL_VERTEX_ARRAY_BINDING_OES',0x85B5) +@_f +@_p.types(None,_cs.GLuint) +def glBindVertexArrayOES(array):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray) +def glDeleteVertexArraysOES(n,arrays):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray) +def glGenVertexArraysOES(n,arrays):pass +@_f +@_p.types(_cs.GLboolean,_cs.GLuint) +def glIsVertexArrayOES(array):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/QCOM/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/QCOM/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/QCOM/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/QCOM/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/QCOM/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..0d733a73 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/QCOM/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/QCOM/__pycache__/driver_control.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/QCOM/__pycache__/driver_control.cpython-312.pyc new file mode 100644 index 00000000..577e9713 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/QCOM/__pycache__/driver_control.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/QCOM/__pycache__/extended_get.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/QCOM/__pycache__/extended_get.cpython-312.pyc new file mode 100644 index 00000000..a2fd573c Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/QCOM/__pycache__/extended_get.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/QCOM/__pycache__/extended_get2.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/QCOM/__pycache__/extended_get2.cpython-312.pyc new file mode 100644 index 00000000..24f26bc7 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/QCOM/__pycache__/extended_get2.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/QCOM/__pycache__/perfmon_global_mode.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/QCOM/__pycache__/perfmon_global_mode.cpython-312.pyc new file mode 100644 index 00000000..40ce1ac9 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/QCOM/__pycache__/perfmon_global_mode.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/QCOM/__pycache__/tiled_rendering.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/QCOM/__pycache__/tiled_rendering.cpython-312.pyc new file mode 100644 index 00000000..adef63a1 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/QCOM/__pycache__/tiled_rendering.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/QCOM/__pycache__/writeonly_rendering.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/QCOM/__pycache__/writeonly_rendering.cpython-312.pyc new file mode 100644 index 00000000..c227ff7e Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/QCOM/__pycache__/writeonly_rendering.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/QCOM/driver_control.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/QCOM/driver_control.py new file mode 100644 index 00000000..665d7be3 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/QCOM/driver_control.py @@ -0,0 +1,26 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES1 import _types as _cs +# End users want this... +from OpenGL.raw.GLES1._types import * +from OpenGL.raw.GLES1 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES1_QCOM_driver_control' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES1,'GLES1_QCOM_driver_control',error_checker=_errors._error_checker) + +@_f +@_p.types(None,_cs.GLuint) +def glDisableDriverControlQCOM(driverControl):pass +@_f +@_p.types(None,_cs.GLuint) +def glEnableDriverControlQCOM(driverControl):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizei,arrays.GLsizeiArray,arrays.GLcharArray) +def glGetDriverControlStringQCOM(driverControl,bufSize,length,driverControlString):pass +@_f +@_p.types(None,arrays.GLintArray,_cs.GLsizei,arrays.GLuintArray) +def glGetDriverControlsQCOM(num,size,driverControls):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/QCOM/extended_get.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/QCOM/extended_get.py new file mode 100644 index 00000000..a8cbb72c --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/QCOM/extended_get.py @@ -0,0 +1,48 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES1 import _types as _cs +# End users want this... +from OpenGL.raw.GLES1._types import * +from OpenGL.raw.GLES1 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES1_QCOM_extended_get' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES1,'GLES1_QCOM_extended_get',error_checker=_errors._error_checker) +GL_STATE_RESTORE=_C('GL_STATE_RESTORE',0x8BDC) +GL_TEXTURE_DEPTH_QCOM=_C('GL_TEXTURE_DEPTH_QCOM',0x8BD4) +GL_TEXTURE_FORMAT_QCOM=_C('GL_TEXTURE_FORMAT_QCOM',0x8BD6) +GL_TEXTURE_HEIGHT_QCOM=_C('GL_TEXTURE_HEIGHT_QCOM',0x8BD3) +GL_TEXTURE_IMAGE_VALID_QCOM=_C('GL_TEXTURE_IMAGE_VALID_QCOM',0x8BD8) +GL_TEXTURE_INTERNAL_FORMAT_QCOM=_C('GL_TEXTURE_INTERNAL_FORMAT_QCOM',0x8BD5) +GL_TEXTURE_NUM_LEVELS_QCOM=_C('GL_TEXTURE_NUM_LEVELS_QCOM',0x8BD9) +GL_TEXTURE_OBJECT_VALID_QCOM=_C('GL_TEXTURE_OBJECT_VALID_QCOM',0x8BDB) +GL_TEXTURE_TARGET_QCOM=_C('GL_TEXTURE_TARGET_QCOM',0x8BDA) +GL_TEXTURE_TYPE_QCOM=_C('GL_TEXTURE_TYPE_QCOM',0x8BD7) +GL_TEXTURE_WIDTH_QCOM=_C('GL_TEXTURE_WIDTH_QCOM',0x8BD2) +@_f +@_p.types(None,_cs.GLenum,arrays.GLvoidpArray) +def glExtGetBufferPointervQCOM(target,params):pass +@_f +@_p.types(None,arrays.GLuintArray,_cs.GLint,arrays.GLintArray) +def glExtGetBuffersQCOM(buffers,maxBuffers,numBuffers):pass +@_f +@_p.types(None,arrays.GLuintArray,_cs.GLint,arrays.GLintArray) +def glExtGetFramebuffersQCOM(framebuffers,maxFramebuffers,numFramebuffers):pass +@_f +@_p.types(None,arrays.GLuintArray,_cs.GLint,arrays.GLintArray) +def glExtGetRenderbuffersQCOM(renderbuffers,maxRenderbuffers,numRenderbuffers):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLint,_cs.GLenum,arrays.GLintArray) +def glExtGetTexLevelParameterivQCOM(texture,face,level,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLsizei,_cs.GLsizei,_cs.GLenum,_cs.GLenum,ctypes.c_void_p) +def glExtGetTexSubImageQCOM(target,level,xoffset,yoffset,zoffset,width,height,depth,format,type,texels):pass +@_f +@_p.types(None,arrays.GLuintArray,_cs.GLint,arrays.GLintArray) +def glExtGetTexturesQCOM(textures,maxTextures,numTextures):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLint) +def glExtTexObjectStateOverrideiQCOM(target,pname,param):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/QCOM/extended_get2.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/QCOM/extended_get2.py new file mode 100644 index 00000000..edf8c9cf --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/QCOM/extended_get2.py @@ -0,0 +1,26 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES1 import _types as _cs +# End users want this... +from OpenGL.raw.GLES1._types import * +from OpenGL.raw.GLES1 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES1_QCOM_extended_get2' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES1,'GLES1_QCOM_extended_get2',error_checker=_errors._error_checker) + +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLcharArray,arrays.GLintArray) +def glExtGetProgramBinarySourceQCOM(program,shadertype,source,length):pass +@_f +@_p.types(None,arrays.GLuintArray,_cs.GLint,arrays.GLintArray) +def glExtGetProgramsQCOM(programs,maxPrograms,numPrograms):pass +@_f +@_p.types(None,arrays.GLuintArray,_cs.GLint,arrays.GLintArray) +def glExtGetShadersQCOM(shaders,maxShaders,numShaders):pass +@_f +@_p.types(_cs.GLboolean,_cs.GLuint) +def glExtIsProgramBinaryQCOM(program):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/QCOM/perfmon_global_mode.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/QCOM/perfmon_global_mode.py new file mode 100644 index 00000000..179b72c5 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/QCOM/perfmon_global_mode.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES1 import _types as _cs +# End users want this... +from OpenGL.raw.GLES1._types import * +from OpenGL.raw.GLES1 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES1_QCOM_perfmon_global_mode' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES1,'GLES1_QCOM_perfmon_global_mode',error_checker=_errors._error_checker) +GL_PERFMON_GLOBAL_MODE_QCOM=_C('GL_PERFMON_GLOBAL_MODE_QCOM',0x8FA0) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/QCOM/tiled_rendering.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/QCOM/tiled_rendering.py new file mode 100644 index 00000000..bb40306c --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/QCOM/tiled_rendering.py @@ -0,0 +1,51 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES1 import _types as _cs +# End users want this... +from OpenGL.raw.GLES1._types import * +from OpenGL.raw.GLES1 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES1_QCOM_tiled_rendering' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES1,'GLES1_QCOM_tiled_rendering',error_checker=_errors._error_checker) +GL_COLOR_BUFFER_BIT0_QCOM=_C('GL_COLOR_BUFFER_BIT0_QCOM',0x00000001) +GL_COLOR_BUFFER_BIT1_QCOM=_C('GL_COLOR_BUFFER_BIT1_QCOM',0x00000002) +GL_COLOR_BUFFER_BIT2_QCOM=_C('GL_COLOR_BUFFER_BIT2_QCOM',0x00000004) +GL_COLOR_BUFFER_BIT3_QCOM=_C('GL_COLOR_BUFFER_BIT3_QCOM',0x00000008) +GL_COLOR_BUFFER_BIT4_QCOM=_C('GL_COLOR_BUFFER_BIT4_QCOM',0x00000010) +GL_COLOR_BUFFER_BIT5_QCOM=_C('GL_COLOR_BUFFER_BIT5_QCOM',0x00000020) +GL_COLOR_BUFFER_BIT6_QCOM=_C('GL_COLOR_BUFFER_BIT6_QCOM',0x00000040) +GL_COLOR_BUFFER_BIT7_QCOM=_C('GL_COLOR_BUFFER_BIT7_QCOM',0x00000080) +GL_DEPTH_BUFFER_BIT0_QCOM=_C('GL_DEPTH_BUFFER_BIT0_QCOM',0x00000100) +GL_DEPTH_BUFFER_BIT1_QCOM=_C('GL_DEPTH_BUFFER_BIT1_QCOM',0x00000200) +GL_DEPTH_BUFFER_BIT2_QCOM=_C('GL_DEPTH_BUFFER_BIT2_QCOM',0x00000400) +GL_DEPTH_BUFFER_BIT3_QCOM=_C('GL_DEPTH_BUFFER_BIT3_QCOM',0x00000800) +GL_DEPTH_BUFFER_BIT4_QCOM=_C('GL_DEPTH_BUFFER_BIT4_QCOM',0x00001000) +GL_DEPTH_BUFFER_BIT5_QCOM=_C('GL_DEPTH_BUFFER_BIT5_QCOM',0x00002000) +GL_DEPTH_BUFFER_BIT6_QCOM=_C('GL_DEPTH_BUFFER_BIT6_QCOM',0x00004000) +GL_DEPTH_BUFFER_BIT7_QCOM=_C('GL_DEPTH_BUFFER_BIT7_QCOM',0x00008000) +GL_MULTISAMPLE_BUFFER_BIT0_QCOM=_C('GL_MULTISAMPLE_BUFFER_BIT0_QCOM',0x01000000) +GL_MULTISAMPLE_BUFFER_BIT1_QCOM=_C('GL_MULTISAMPLE_BUFFER_BIT1_QCOM',0x02000000) +GL_MULTISAMPLE_BUFFER_BIT2_QCOM=_C('GL_MULTISAMPLE_BUFFER_BIT2_QCOM',0x04000000) +GL_MULTISAMPLE_BUFFER_BIT3_QCOM=_C('GL_MULTISAMPLE_BUFFER_BIT3_QCOM',0x08000000) +GL_MULTISAMPLE_BUFFER_BIT4_QCOM=_C('GL_MULTISAMPLE_BUFFER_BIT4_QCOM',0x10000000) +GL_MULTISAMPLE_BUFFER_BIT5_QCOM=_C('GL_MULTISAMPLE_BUFFER_BIT5_QCOM',0x20000000) +GL_MULTISAMPLE_BUFFER_BIT6_QCOM=_C('GL_MULTISAMPLE_BUFFER_BIT6_QCOM',0x40000000) +GL_MULTISAMPLE_BUFFER_BIT7_QCOM=_C('GL_MULTISAMPLE_BUFFER_BIT7_QCOM',0x80000000) +GL_STENCIL_BUFFER_BIT0_QCOM=_C('GL_STENCIL_BUFFER_BIT0_QCOM',0x00010000) +GL_STENCIL_BUFFER_BIT1_QCOM=_C('GL_STENCIL_BUFFER_BIT1_QCOM',0x00020000) +GL_STENCIL_BUFFER_BIT2_QCOM=_C('GL_STENCIL_BUFFER_BIT2_QCOM',0x00040000) +GL_STENCIL_BUFFER_BIT3_QCOM=_C('GL_STENCIL_BUFFER_BIT3_QCOM',0x00080000) +GL_STENCIL_BUFFER_BIT4_QCOM=_C('GL_STENCIL_BUFFER_BIT4_QCOM',0x00100000) +GL_STENCIL_BUFFER_BIT5_QCOM=_C('GL_STENCIL_BUFFER_BIT5_QCOM',0x00200000) +GL_STENCIL_BUFFER_BIT6_QCOM=_C('GL_STENCIL_BUFFER_BIT6_QCOM',0x00400000) +GL_STENCIL_BUFFER_BIT7_QCOM=_C('GL_STENCIL_BUFFER_BIT7_QCOM',0x00800000) +@_f +@_p.types(None,_cs.GLbitfield) +def glEndTilingQCOM(preserveMask):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLuint,_cs.GLuint,_cs.GLbitfield) +def glStartTilingQCOM(x,y,width,height,preserveMask):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/QCOM/writeonly_rendering.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/QCOM/writeonly_rendering.py new file mode 100644 index 00000000..05a10be7 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/QCOM/writeonly_rendering.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES1 import _types as _cs +# End users want this... +from OpenGL.raw.GLES1._types import * +from OpenGL.raw.GLES1 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES1_QCOM_writeonly_rendering' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES1,'GLES1_QCOM_writeonly_rendering',error_checker=_errors._error_checker) +GL_WRITEONLY_RENDERING_QCOM=_C('GL_WRITEONLY_RENDERING_QCOM',0x8823) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/VERSION/GLES1_1_0.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/VERSION/GLES1_1_0.py new file mode 100644 index 00000000..55191f6f --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/VERSION/GLES1_1_0.py @@ -0,0 +1,778 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES1 import _types as _cs +# End users want this... +from OpenGL.raw.GLES1._types import * +from OpenGL.raw.GLES1 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES1_VERSION_GLES1_1_0' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES1,'GLES1_VERSION_GLES1_1_0',error_checker=_errors._error_checker) +GL_ACTIVE_TEXTURE=_C('GL_ACTIVE_TEXTURE',0x84E0) +GL_ADD=_C('GL_ADD',0x0104) +GL_ADD_SIGNED=_C('GL_ADD_SIGNED',0x8574) +GL_ALIASED_LINE_WIDTH_RANGE=_C('GL_ALIASED_LINE_WIDTH_RANGE',0x846E) +GL_ALIASED_POINT_SIZE_RANGE=_C('GL_ALIASED_POINT_SIZE_RANGE',0x846D) +GL_ALPHA=_C('GL_ALPHA',0x1906) +GL_ALPHA_BITS=_C('GL_ALPHA_BITS',0x0D55) +GL_ALPHA_SCALE=_C('GL_ALPHA_SCALE',0x0D1C) +GL_ALPHA_TEST=_C('GL_ALPHA_TEST',0x0BC0) +GL_ALPHA_TEST_FUNC=_C('GL_ALPHA_TEST_FUNC',0x0BC1) +GL_ALPHA_TEST_REF=_C('GL_ALPHA_TEST_REF',0x0BC2) +GL_ALWAYS=_C('GL_ALWAYS',0x0207) +GL_AMBIENT=_C('GL_AMBIENT',0x1200) +GL_AMBIENT_AND_DIFFUSE=_C('GL_AMBIENT_AND_DIFFUSE',0x1602) +GL_AND=_C('GL_AND',0x1501) +GL_AND_INVERTED=_C('GL_AND_INVERTED',0x1504) +GL_AND_REVERSE=_C('GL_AND_REVERSE',0x1502) +GL_ARRAY_BUFFER=_C('GL_ARRAY_BUFFER',0x8892) +GL_ARRAY_BUFFER_BINDING=_C('GL_ARRAY_BUFFER_BINDING',0x8894) +GL_BACK=_C('GL_BACK',0x0405) +GL_BLEND=_C('GL_BLEND',0x0BE2) +GL_BLEND_DST=_C('GL_BLEND_DST',0x0BE0) +GL_BLEND_SRC=_C('GL_BLEND_SRC',0x0BE1) +GL_BLUE_BITS=_C('GL_BLUE_BITS',0x0D54) +GL_BUFFER_SIZE=_C('GL_BUFFER_SIZE',0x8764) +GL_BUFFER_USAGE=_C('GL_BUFFER_USAGE',0x8765) +GL_BYTE=_C('GL_BYTE',0x1400) +GL_CCW=_C('GL_CCW',0x0901) +GL_CLAMP_TO_EDGE=_C('GL_CLAMP_TO_EDGE',0x812F) +GL_CLEAR=_C('GL_CLEAR',0x1500) +GL_CLIENT_ACTIVE_TEXTURE=_C('GL_CLIENT_ACTIVE_TEXTURE',0x84E1) +GL_CLIP_PLANE0=_C('GL_CLIP_PLANE0',0x3000) +GL_CLIP_PLANE1=_C('GL_CLIP_PLANE1',0x3001) +GL_CLIP_PLANE2=_C('GL_CLIP_PLANE2',0x3002) +GL_CLIP_PLANE3=_C('GL_CLIP_PLANE3',0x3003) +GL_CLIP_PLANE4=_C('GL_CLIP_PLANE4',0x3004) +GL_CLIP_PLANE5=_C('GL_CLIP_PLANE5',0x3005) +GL_COLOR_ARRAY=_C('GL_COLOR_ARRAY',0x8076) +GL_COLOR_ARRAY_BUFFER_BINDING=_C('GL_COLOR_ARRAY_BUFFER_BINDING',0x8898) +GL_COLOR_ARRAY_POINTER=_C('GL_COLOR_ARRAY_POINTER',0x8090) +GL_COLOR_ARRAY_SIZE=_C('GL_COLOR_ARRAY_SIZE',0x8081) +GL_COLOR_ARRAY_STRIDE=_C('GL_COLOR_ARRAY_STRIDE',0x8083) +GL_COLOR_ARRAY_TYPE=_C('GL_COLOR_ARRAY_TYPE',0x8082) +GL_COLOR_BUFFER_BIT=_C('GL_COLOR_BUFFER_BIT',0x00004000) +GL_COLOR_CLEAR_VALUE=_C('GL_COLOR_CLEAR_VALUE',0x0C22) +GL_COLOR_LOGIC_OP=_C('GL_COLOR_LOGIC_OP',0x0BF2) +GL_COLOR_MATERIAL=_C('GL_COLOR_MATERIAL',0x0B57) +GL_COLOR_WRITEMASK=_C('GL_COLOR_WRITEMASK',0x0C23) +GL_COMBINE=_C('GL_COMBINE',0x8570) +GL_COMBINE_ALPHA=_C('GL_COMBINE_ALPHA',0x8572) +GL_COMBINE_RGB=_C('GL_COMBINE_RGB',0x8571) +GL_COMPRESSED_TEXTURE_FORMATS=_C('GL_COMPRESSED_TEXTURE_FORMATS',0x86A3) +GL_CONSTANT=_C('GL_CONSTANT',0x8576) +GL_CONSTANT_ATTENUATION=_C('GL_CONSTANT_ATTENUATION',0x1207) +GL_COPY=_C('GL_COPY',0x1503) +GL_COPY_INVERTED=_C('GL_COPY_INVERTED',0x150C) +GL_CULL_FACE=_C('GL_CULL_FACE',0x0B44) +GL_CULL_FACE_MODE=_C('GL_CULL_FACE_MODE',0x0B45) +GL_CURRENT_COLOR=_C('GL_CURRENT_COLOR',0x0B00) +GL_CURRENT_NORMAL=_C('GL_CURRENT_NORMAL',0x0B02) +GL_CURRENT_TEXTURE_COORDS=_C('GL_CURRENT_TEXTURE_COORDS',0x0B03) +GL_CW=_C('GL_CW',0x0900) +GL_DECAL=_C('GL_DECAL',0x2101) +GL_DECR=_C('GL_DECR',0x1E03) +GL_DEPTH_BITS=_C('GL_DEPTH_BITS',0x0D56) +GL_DEPTH_BUFFER_BIT=_C('GL_DEPTH_BUFFER_BIT',0x00000100) +GL_DEPTH_CLEAR_VALUE=_C('GL_DEPTH_CLEAR_VALUE',0x0B73) +GL_DEPTH_FUNC=_C('GL_DEPTH_FUNC',0x0B74) +GL_DEPTH_RANGE=_C('GL_DEPTH_RANGE',0x0B70) +GL_DEPTH_TEST=_C('GL_DEPTH_TEST',0x0B71) +GL_DEPTH_WRITEMASK=_C('GL_DEPTH_WRITEMASK',0x0B72) +GL_DIFFUSE=_C('GL_DIFFUSE',0x1201) +GL_DITHER=_C('GL_DITHER',0x0BD0) +GL_DONT_CARE=_C('GL_DONT_CARE',0x1100) +GL_DOT3_RGB=_C('GL_DOT3_RGB',0x86AE) +GL_DOT3_RGBA=_C('GL_DOT3_RGBA',0x86AF) +GL_DST_ALPHA=_C('GL_DST_ALPHA',0x0304) +GL_DST_COLOR=_C('GL_DST_COLOR',0x0306) +GL_DYNAMIC_DRAW=_C('GL_DYNAMIC_DRAW',0x88E8) +GL_ELEMENT_ARRAY_BUFFER=_C('GL_ELEMENT_ARRAY_BUFFER',0x8893) +GL_ELEMENT_ARRAY_BUFFER_BINDING=_C('GL_ELEMENT_ARRAY_BUFFER_BINDING',0x8895) +GL_EMISSION=_C('GL_EMISSION',0x1600) +GL_EQUAL=_C('GL_EQUAL',0x0202) +GL_EQUIV=_C('GL_EQUIV',0x1509) +GL_EXP=_C('GL_EXP',0x0800) +GL_EXP2=_C('GL_EXP2',0x0801) +GL_EXTENSIONS=_C('GL_EXTENSIONS',0x1F03) +GL_FALSE=_C('GL_FALSE',0) +GL_FASTEST=_C('GL_FASTEST',0x1101) +GL_FIXED=_C('GL_FIXED',0x140C) +GL_FLAT=_C('GL_FLAT',0x1D00) +GL_FLOAT=_C('GL_FLOAT',0x1406) +GL_FOG=_C('GL_FOG',0x0B60) +GL_FOG_COLOR=_C('GL_FOG_COLOR',0x0B66) +GL_FOG_DENSITY=_C('GL_FOG_DENSITY',0x0B62) +GL_FOG_END=_C('GL_FOG_END',0x0B64) +GL_FOG_HINT=_C('GL_FOG_HINT',0x0C54) +GL_FOG_MODE=_C('GL_FOG_MODE',0x0B65) +GL_FOG_START=_C('GL_FOG_START',0x0B63) +GL_FRONT=_C('GL_FRONT',0x0404) +GL_FRONT_AND_BACK=_C('GL_FRONT_AND_BACK',0x0408) +GL_FRONT_FACE=_C('GL_FRONT_FACE',0x0B46) +GL_GENERATE_MIPMAP=_C('GL_GENERATE_MIPMAP',0x8191) +GL_GENERATE_MIPMAP_HINT=_C('GL_GENERATE_MIPMAP_HINT',0x8192) +GL_GEQUAL=_C('GL_GEQUAL',0x0206) +GL_GREATER=_C('GL_GREATER',0x0204) +GL_GREEN_BITS=_C('GL_GREEN_BITS',0x0D53) +GL_INCR=_C('GL_INCR',0x1E02) +GL_INTERPOLATE=_C('GL_INTERPOLATE',0x8575) +GL_INVALID_ENUM=_C('GL_INVALID_ENUM',0x0500) +GL_INVALID_OPERATION=_C('GL_INVALID_OPERATION',0x0502) +GL_INVALID_VALUE=_C('GL_INVALID_VALUE',0x0501) +GL_INVERT=_C('GL_INVERT',0x150A) +GL_KEEP=_C('GL_KEEP',0x1E00) +GL_LEQUAL=_C('GL_LEQUAL',0x0203) +GL_LESS=_C('GL_LESS',0x0201) +GL_LIGHT0=_C('GL_LIGHT0',0x4000) +GL_LIGHT1=_C('GL_LIGHT1',0x4001) +GL_LIGHT2=_C('GL_LIGHT2',0x4002) +GL_LIGHT3=_C('GL_LIGHT3',0x4003) +GL_LIGHT4=_C('GL_LIGHT4',0x4004) +GL_LIGHT5=_C('GL_LIGHT5',0x4005) +GL_LIGHT6=_C('GL_LIGHT6',0x4006) +GL_LIGHT7=_C('GL_LIGHT7',0x4007) +GL_LIGHTING=_C('GL_LIGHTING',0x0B50) +GL_LIGHT_MODEL_AMBIENT=_C('GL_LIGHT_MODEL_AMBIENT',0x0B53) +GL_LIGHT_MODEL_TWO_SIDE=_C('GL_LIGHT_MODEL_TWO_SIDE',0x0B52) +GL_LINEAR=_C('GL_LINEAR',0x2601) +GL_LINEAR_ATTENUATION=_C('GL_LINEAR_ATTENUATION',0x1208) +GL_LINEAR_MIPMAP_LINEAR=_C('GL_LINEAR_MIPMAP_LINEAR',0x2703) +GL_LINEAR_MIPMAP_NEAREST=_C('GL_LINEAR_MIPMAP_NEAREST',0x2701) +GL_LINES=_C('GL_LINES',0x0001) +GL_LINE_LOOP=_C('GL_LINE_LOOP',0x0002) +GL_LINE_SMOOTH=_C('GL_LINE_SMOOTH',0x0B20) +GL_LINE_SMOOTH_HINT=_C('GL_LINE_SMOOTH_HINT',0x0C52) +GL_LINE_STRIP=_C('GL_LINE_STRIP',0x0003) +GL_LINE_WIDTH=_C('GL_LINE_WIDTH',0x0B21) +GL_LOGIC_OP_MODE=_C('GL_LOGIC_OP_MODE',0x0BF0) +GL_LUMINANCE=_C('GL_LUMINANCE',0x1909) +GL_LUMINANCE_ALPHA=_C('GL_LUMINANCE_ALPHA',0x190A) +GL_MATRIX_MODE=_C('GL_MATRIX_MODE',0x0BA0) +GL_MAX_CLIP_PLANES=_C('GL_MAX_CLIP_PLANES',0x0D32) +GL_MAX_LIGHTS=_C('GL_MAX_LIGHTS',0x0D31) +GL_MAX_MODELVIEW_STACK_DEPTH=_C('GL_MAX_MODELVIEW_STACK_DEPTH',0x0D36) +GL_MAX_PROJECTION_STACK_DEPTH=_C('GL_MAX_PROJECTION_STACK_DEPTH',0x0D38) +GL_MAX_TEXTURE_SIZE=_C('GL_MAX_TEXTURE_SIZE',0x0D33) +GL_MAX_TEXTURE_STACK_DEPTH=_C('GL_MAX_TEXTURE_STACK_DEPTH',0x0D39) +GL_MAX_TEXTURE_UNITS=_C('GL_MAX_TEXTURE_UNITS',0x84E2) +GL_MAX_VIEWPORT_DIMS=_C('GL_MAX_VIEWPORT_DIMS',0x0D3A) +GL_MODELVIEW=_C('GL_MODELVIEW',0x1700) +GL_MODELVIEW_MATRIX=_C('GL_MODELVIEW_MATRIX',0x0BA6) +GL_MODELVIEW_STACK_DEPTH=_C('GL_MODELVIEW_STACK_DEPTH',0x0BA3) +GL_MODULATE=_C('GL_MODULATE',0x2100) +GL_MULTISAMPLE=_C('GL_MULTISAMPLE',0x809D) +GL_NAND=_C('GL_NAND',0x150E) +GL_NEAREST=_C('GL_NEAREST',0x2600) +GL_NEAREST_MIPMAP_LINEAR=_C('GL_NEAREST_MIPMAP_LINEAR',0x2702) +GL_NEAREST_MIPMAP_NEAREST=_C('GL_NEAREST_MIPMAP_NEAREST',0x2700) +GL_NEVER=_C('GL_NEVER',0x0200) +GL_NICEST=_C('GL_NICEST',0x1102) +GL_NOOP=_C('GL_NOOP',0x1505) +GL_NOR=_C('GL_NOR',0x1508) +GL_NORMALIZE=_C('GL_NORMALIZE',0x0BA1) +GL_NORMAL_ARRAY=_C('GL_NORMAL_ARRAY',0x8075) +GL_NORMAL_ARRAY_BUFFER_BINDING=_C('GL_NORMAL_ARRAY_BUFFER_BINDING',0x8897) +GL_NORMAL_ARRAY_POINTER=_C('GL_NORMAL_ARRAY_POINTER',0x808F) +GL_NORMAL_ARRAY_STRIDE=_C('GL_NORMAL_ARRAY_STRIDE',0x807F) +GL_NORMAL_ARRAY_TYPE=_C('GL_NORMAL_ARRAY_TYPE',0x807E) +GL_NOTEQUAL=_C('GL_NOTEQUAL',0x0205) +GL_NO_ERROR=_C('GL_NO_ERROR',0) +GL_NUM_COMPRESSED_TEXTURE_FORMATS=_C('GL_NUM_COMPRESSED_TEXTURE_FORMATS',0x86A2) +GL_ONE=_C('GL_ONE',1) +GL_ONE_MINUS_DST_ALPHA=_C('GL_ONE_MINUS_DST_ALPHA',0x0305) +GL_ONE_MINUS_DST_COLOR=_C('GL_ONE_MINUS_DST_COLOR',0x0307) +GL_ONE_MINUS_SRC_ALPHA=_C('GL_ONE_MINUS_SRC_ALPHA',0x0303) +GL_ONE_MINUS_SRC_COLOR=_C('GL_ONE_MINUS_SRC_COLOR',0x0301) +GL_OPERAND0_ALPHA=_C('GL_OPERAND0_ALPHA',0x8598) +GL_OPERAND0_RGB=_C('GL_OPERAND0_RGB',0x8590) +GL_OPERAND1_ALPHA=_C('GL_OPERAND1_ALPHA',0x8599) +GL_OPERAND1_RGB=_C('GL_OPERAND1_RGB',0x8591) +GL_OPERAND2_ALPHA=_C('GL_OPERAND2_ALPHA',0x859A) +GL_OPERAND2_RGB=_C('GL_OPERAND2_RGB',0x8592) +GL_OR=_C('GL_OR',0x1507) +GL_OR_INVERTED=_C('GL_OR_INVERTED',0x150D) +GL_OR_REVERSE=_C('GL_OR_REVERSE',0x150B) +GL_OUT_OF_MEMORY=_C('GL_OUT_OF_MEMORY',0x0505) +GL_PACK_ALIGNMENT=_C('GL_PACK_ALIGNMENT',0x0D05) +GL_PERSPECTIVE_CORRECTION_HINT=_C('GL_PERSPECTIVE_CORRECTION_HINT',0x0C50) +GL_POINTS=_C('GL_POINTS',0x0000) +GL_POINT_DISTANCE_ATTENUATION=_C('GL_POINT_DISTANCE_ATTENUATION',0x8129) +GL_POINT_FADE_THRESHOLD_SIZE=_C('GL_POINT_FADE_THRESHOLD_SIZE',0x8128) +GL_POINT_SIZE=_C('GL_POINT_SIZE',0x0B11) +GL_POINT_SIZE_MAX=_C('GL_POINT_SIZE_MAX',0x8127) +GL_POINT_SIZE_MIN=_C('GL_POINT_SIZE_MIN',0x8126) +GL_POINT_SMOOTH=_C('GL_POINT_SMOOTH',0x0B10) +GL_POINT_SMOOTH_HINT=_C('GL_POINT_SMOOTH_HINT',0x0C51) +GL_POLYGON_OFFSET_FACTOR=_C('GL_POLYGON_OFFSET_FACTOR',0x8038) +GL_POLYGON_OFFSET_FILL=_C('GL_POLYGON_OFFSET_FILL',0x8037) +GL_POLYGON_OFFSET_UNITS=_C('GL_POLYGON_OFFSET_UNITS',0x2A00) +GL_POSITION=_C('GL_POSITION',0x1203) +GL_PREVIOUS=_C('GL_PREVIOUS',0x8578) +GL_PRIMARY_COLOR=_C('GL_PRIMARY_COLOR',0x8577) +GL_PROJECTION=_C('GL_PROJECTION',0x1701) +GL_PROJECTION_MATRIX=_C('GL_PROJECTION_MATRIX',0x0BA7) +GL_PROJECTION_STACK_DEPTH=_C('GL_PROJECTION_STACK_DEPTH',0x0BA4) +GL_QUADRATIC_ATTENUATION=_C('GL_QUADRATIC_ATTENUATION',0x1209) +GL_RED_BITS=_C('GL_RED_BITS',0x0D52) +GL_RENDERER=_C('GL_RENDERER',0x1F01) +GL_REPEAT=_C('GL_REPEAT',0x2901) +GL_REPLACE=_C('GL_REPLACE',0x1E01) +GL_RESCALE_NORMAL=_C('GL_RESCALE_NORMAL',0x803A) +GL_RGB=_C('GL_RGB',0x1907) +GL_RGBA=_C('GL_RGBA',0x1908) +GL_RGB_SCALE=_C('GL_RGB_SCALE',0x8573) +GL_SAMPLES=_C('GL_SAMPLES',0x80A9) +GL_SAMPLE_ALPHA_TO_COVERAGE=_C('GL_SAMPLE_ALPHA_TO_COVERAGE',0x809E) +GL_SAMPLE_ALPHA_TO_ONE=_C('GL_SAMPLE_ALPHA_TO_ONE',0x809F) +GL_SAMPLE_BUFFERS=_C('GL_SAMPLE_BUFFERS',0x80A8) +GL_SAMPLE_COVERAGE=_C('GL_SAMPLE_COVERAGE',0x80A0) +GL_SAMPLE_COVERAGE_INVERT=_C('GL_SAMPLE_COVERAGE_INVERT',0x80AB) +GL_SAMPLE_COVERAGE_VALUE=_C('GL_SAMPLE_COVERAGE_VALUE',0x80AA) +GL_SCISSOR_BOX=_C('GL_SCISSOR_BOX',0x0C10) +GL_SCISSOR_TEST=_C('GL_SCISSOR_TEST',0x0C11) +GL_SET=_C('GL_SET',0x150F) +GL_SHADE_MODEL=_C('GL_SHADE_MODEL',0x0B54) +GL_SHININESS=_C('GL_SHININESS',0x1601) +GL_SHORT=_C('GL_SHORT',0x1402) +GL_SMOOTH=_C('GL_SMOOTH',0x1D01) +GL_SMOOTH_LINE_WIDTH_RANGE=_C('GL_SMOOTH_LINE_WIDTH_RANGE',0x0B22) +GL_SMOOTH_POINT_SIZE_RANGE=_C('GL_SMOOTH_POINT_SIZE_RANGE',0x0B12) +GL_SPECULAR=_C('GL_SPECULAR',0x1202) +GL_SPOT_CUTOFF=_C('GL_SPOT_CUTOFF',0x1206) +GL_SPOT_DIRECTION=_C('GL_SPOT_DIRECTION',0x1204) +GL_SPOT_EXPONENT=_C('GL_SPOT_EXPONENT',0x1205) +GL_SRC0_ALPHA=_C('GL_SRC0_ALPHA',0x8588) +GL_SRC0_RGB=_C('GL_SRC0_RGB',0x8580) +GL_SRC1_ALPHA=_C('GL_SRC1_ALPHA',0x8589) +GL_SRC1_RGB=_C('GL_SRC1_RGB',0x8581) +GL_SRC2_ALPHA=_C('GL_SRC2_ALPHA',0x858A) +GL_SRC2_RGB=_C('GL_SRC2_RGB',0x8582) +GL_SRC_ALPHA=_C('GL_SRC_ALPHA',0x0302) +GL_SRC_ALPHA_SATURATE=_C('GL_SRC_ALPHA_SATURATE',0x0308) +GL_SRC_COLOR=_C('GL_SRC_COLOR',0x0300) +GL_STACK_OVERFLOW=_C('GL_STACK_OVERFLOW',0x0503) +GL_STACK_UNDERFLOW=_C('GL_STACK_UNDERFLOW',0x0504) +GL_STATIC_DRAW=_C('GL_STATIC_DRAW',0x88E4) +GL_STENCIL_BITS=_C('GL_STENCIL_BITS',0x0D57) +GL_STENCIL_BUFFER_BIT=_C('GL_STENCIL_BUFFER_BIT',0x00000400) +GL_STENCIL_CLEAR_VALUE=_C('GL_STENCIL_CLEAR_VALUE',0x0B91) +GL_STENCIL_FAIL=_C('GL_STENCIL_FAIL',0x0B94) +GL_STENCIL_FUNC=_C('GL_STENCIL_FUNC',0x0B92) +GL_STENCIL_PASS_DEPTH_FAIL=_C('GL_STENCIL_PASS_DEPTH_FAIL',0x0B95) +GL_STENCIL_PASS_DEPTH_PASS=_C('GL_STENCIL_PASS_DEPTH_PASS',0x0B96) +GL_STENCIL_REF=_C('GL_STENCIL_REF',0x0B97) +GL_STENCIL_TEST=_C('GL_STENCIL_TEST',0x0B90) +GL_STENCIL_VALUE_MASK=_C('GL_STENCIL_VALUE_MASK',0x0B93) +GL_STENCIL_WRITEMASK=_C('GL_STENCIL_WRITEMASK',0x0B98) +GL_SUBPIXEL_BITS=_C('GL_SUBPIXEL_BITS',0x0D50) +GL_SUBTRACT=_C('GL_SUBTRACT',0x84E7) +GL_TEXTURE=_C('GL_TEXTURE',0x1702) +GL_TEXTURE0=_C('GL_TEXTURE0',0x84C0) +GL_TEXTURE1=_C('GL_TEXTURE1',0x84C1) +GL_TEXTURE10=_C('GL_TEXTURE10',0x84CA) +GL_TEXTURE11=_C('GL_TEXTURE11',0x84CB) +GL_TEXTURE12=_C('GL_TEXTURE12',0x84CC) +GL_TEXTURE13=_C('GL_TEXTURE13',0x84CD) +GL_TEXTURE14=_C('GL_TEXTURE14',0x84CE) +GL_TEXTURE15=_C('GL_TEXTURE15',0x84CF) +GL_TEXTURE16=_C('GL_TEXTURE16',0x84D0) +GL_TEXTURE17=_C('GL_TEXTURE17',0x84D1) +GL_TEXTURE18=_C('GL_TEXTURE18',0x84D2) +GL_TEXTURE19=_C('GL_TEXTURE19',0x84D3) +GL_TEXTURE2=_C('GL_TEXTURE2',0x84C2) +GL_TEXTURE20=_C('GL_TEXTURE20',0x84D4) +GL_TEXTURE21=_C('GL_TEXTURE21',0x84D5) +GL_TEXTURE22=_C('GL_TEXTURE22',0x84D6) +GL_TEXTURE23=_C('GL_TEXTURE23',0x84D7) +GL_TEXTURE24=_C('GL_TEXTURE24',0x84D8) +GL_TEXTURE25=_C('GL_TEXTURE25',0x84D9) +GL_TEXTURE26=_C('GL_TEXTURE26',0x84DA) +GL_TEXTURE27=_C('GL_TEXTURE27',0x84DB) +GL_TEXTURE28=_C('GL_TEXTURE28',0x84DC) +GL_TEXTURE29=_C('GL_TEXTURE29',0x84DD) +GL_TEXTURE3=_C('GL_TEXTURE3',0x84C3) +GL_TEXTURE30=_C('GL_TEXTURE30',0x84DE) +GL_TEXTURE31=_C('GL_TEXTURE31',0x84DF) +GL_TEXTURE4=_C('GL_TEXTURE4',0x84C4) +GL_TEXTURE5=_C('GL_TEXTURE5',0x84C5) +GL_TEXTURE6=_C('GL_TEXTURE6',0x84C6) +GL_TEXTURE7=_C('GL_TEXTURE7',0x84C7) +GL_TEXTURE8=_C('GL_TEXTURE8',0x84C8) +GL_TEXTURE9=_C('GL_TEXTURE9',0x84C9) +GL_TEXTURE_2D=_C('GL_TEXTURE_2D',0x0DE1) +GL_TEXTURE_BINDING_2D=_C('GL_TEXTURE_BINDING_2D',0x8069) +GL_TEXTURE_COORD_ARRAY=_C('GL_TEXTURE_COORD_ARRAY',0x8078) +GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING=_C('GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING',0x889A) +GL_TEXTURE_COORD_ARRAY_POINTER=_C('GL_TEXTURE_COORD_ARRAY_POINTER',0x8092) +GL_TEXTURE_COORD_ARRAY_SIZE=_C('GL_TEXTURE_COORD_ARRAY_SIZE',0x8088) +GL_TEXTURE_COORD_ARRAY_STRIDE=_C('GL_TEXTURE_COORD_ARRAY_STRIDE',0x808A) +GL_TEXTURE_COORD_ARRAY_TYPE=_C('GL_TEXTURE_COORD_ARRAY_TYPE',0x8089) +GL_TEXTURE_ENV=_C('GL_TEXTURE_ENV',0x2300) +GL_TEXTURE_ENV_COLOR=_C('GL_TEXTURE_ENV_COLOR',0x2201) +GL_TEXTURE_ENV_MODE=_C('GL_TEXTURE_ENV_MODE',0x2200) +GL_TEXTURE_MAG_FILTER=_C('GL_TEXTURE_MAG_FILTER',0x2800) +GL_TEXTURE_MATRIX=_C('GL_TEXTURE_MATRIX',0x0BA8) +GL_TEXTURE_MIN_FILTER=_C('GL_TEXTURE_MIN_FILTER',0x2801) +GL_TEXTURE_STACK_DEPTH=_C('GL_TEXTURE_STACK_DEPTH',0x0BA5) +GL_TEXTURE_WRAP_S=_C('GL_TEXTURE_WRAP_S',0x2802) +GL_TEXTURE_WRAP_T=_C('GL_TEXTURE_WRAP_T',0x2803) +GL_TRIANGLES=_C('GL_TRIANGLES',0x0004) +GL_TRIANGLE_FAN=_C('GL_TRIANGLE_FAN',0x0006) +GL_TRIANGLE_STRIP=_C('GL_TRIANGLE_STRIP',0x0005) +GL_TRUE=_C('GL_TRUE',1) +GL_UNPACK_ALIGNMENT=_C('GL_UNPACK_ALIGNMENT',0x0CF5) +GL_UNSIGNED_BYTE=_C('GL_UNSIGNED_BYTE',0x1401) +GL_UNSIGNED_SHORT=_C('GL_UNSIGNED_SHORT',0x1403) +GL_UNSIGNED_SHORT_4_4_4_4=_C('GL_UNSIGNED_SHORT_4_4_4_4',0x8033) +GL_UNSIGNED_SHORT_5_5_5_1=_C('GL_UNSIGNED_SHORT_5_5_5_1',0x8034) +GL_UNSIGNED_SHORT_5_6_5=_C('GL_UNSIGNED_SHORT_5_6_5',0x8363) +GL_VENDOR=_C('GL_VENDOR',0x1F00) +GL_VERSION=_C('GL_VERSION',0x1F02) +GL_VERSION_ES_CL_1_0=_C('GL_VERSION_ES_CL_1_0',1) +GL_VERSION_ES_CL_1_1=_C('GL_VERSION_ES_CL_1_1',1) +GL_VERSION_ES_CM_1_1=_C('GL_VERSION_ES_CM_1_1',1) +GL_VERTEX_ARRAY=_C('GL_VERTEX_ARRAY',0x8074) +GL_VERTEX_ARRAY_BUFFER_BINDING=_C('GL_VERTEX_ARRAY_BUFFER_BINDING',0x8896) +GL_VERTEX_ARRAY_POINTER=_C('GL_VERTEX_ARRAY_POINTER',0x808E) +GL_VERTEX_ARRAY_SIZE=_C('GL_VERTEX_ARRAY_SIZE',0x807A) +GL_VERTEX_ARRAY_STRIDE=_C('GL_VERTEX_ARRAY_STRIDE',0x807C) +GL_VERTEX_ARRAY_TYPE=_C('GL_VERTEX_ARRAY_TYPE',0x807B) +GL_VIEWPORT=_C('GL_VIEWPORT',0x0BA2) +GL_XOR=_C('GL_XOR',0x1506) +GL_ZERO=_C('GL_ZERO',0) +@_f +@_p.types(None,_cs.GLenum) +def glActiveTexture(texture):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLfloat) +def glAlphaFunc(func,ref):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLfixed) +def glAlphaFuncx(func,ref):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint) +def glBindBuffer(target,buffer):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint) +def glBindTexture(target,texture):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum) +def glBlendFunc(sfactor,dfactor):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizeiptr,ctypes.c_void_p,_cs.GLenum) +def glBufferData(target,size,data,usage):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLintptr,_cs.GLsizeiptr,ctypes.c_void_p) +def glBufferSubData(target,offset,size,data):pass +@_f +@_p.types(None,_cs.GLbitfield) +def glClear(mask):pass +@_f +@_p.types(None,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat) +def glClearColor(red,green,blue,alpha):pass +@_f +@_p.types(None,_cs.GLfixed,_cs.GLfixed,_cs.GLfixed,_cs.GLfixed) +def glClearColorx(red,green,blue,alpha):pass +@_f +@_p.types(None,_cs.GLfloat) +def glClearDepthf(d):pass +@_f +@_p.types(None,_cs.GLfixed) +def glClearDepthx(depth):pass +@_f +@_p.types(None,_cs.GLint) +def glClearStencil(s):pass +@_f +@_p.types(None,_cs.GLenum) +def glClientActiveTexture(texture):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLfloatArray) +def glClipPlanef(p,eqn):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLfixedArray) +def glClipPlanex(plane,equation):pass +@_f +@_p.types(None,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat) +def glColor4f(red,green,blue,alpha):pass +@_f +@_p.types(None,_cs.GLubyte,_cs.GLubyte,_cs.GLubyte,_cs.GLubyte) +def glColor4ub(red,green,blue,alpha):pass +@_f +@_p.types(None,_cs.GLfixed,_cs.GLfixed,_cs.GLfixed,_cs.GLfixed) +def glColor4x(red,green,blue,alpha):pass +@_f +@_p.types(None,_cs.GLboolean,_cs.GLboolean,_cs.GLboolean,_cs.GLboolean) +def glColorMask(red,green,blue,alpha):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLenum,_cs.GLsizei,ctypes.c_void_p) +def glColorPointer(size,type,stride,pointer):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLint,_cs.GLenum,_cs.GLsizei,_cs.GLsizei,_cs.GLint,_cs.GLsizei,ctypes.c_void_p) +def glCompressedTexImage2D(target,level,internalformat,width,height,border,imageSize,data):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLsizei,_cs.GLenum,_cs.GLsizei,ctypes.c_void_p) +def glCompressedTexSubImage2D(target,level,xoffset,yoffset,width,height,format,imageSize,data):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLint,_cs.GLenum,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLsizei,_cs.GLint) +def glCopyTexImage2D(target,level,internalformat,x,y,width,height,border):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLsizei) +def glCopyTexSubImage2D(target,level,xoffset,yoffset,x,y,width,height):pass +@_f +@_p.types(None,_cs.GLenum) +def glCullFace(mode):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray) +def glDeleteBuffers(n,buffers):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray) +def glDeleteTextures(n,textures):pass +@_f +@_p.types(None,_cs.GLenum) +def glDepthFunc(func):pass +@_f +@_p.types(None,_cs.GLboolean) +def glDepthMask(flag):pass +@_f +@_p.types(None,_cs.GLfloat,_cs.GLfloat) +def glDepthRangef(n,f):pass +@_f +@_p.types(None,_cs.GLfixed,_cs.GLfixed) +def glDepthRangex(n,f):pass +@_f +@_p.types(None,_cs.GLenum) +def glDisable(cap):pass +@_f +@_p.types(None,_cs.GLenum) +def glDisableClientState(array):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLint,_cs.GLsizei) +def glDrawArrays(mode,first,count):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizei,_cs.GLenum,ctypes.c_void_p) +def glDrawElements(mode,count,type,indices):pass +@_f +@_p.types(None,_cs.GLenum) +def glEnable(cap):pass +@_f +@_p.types(None,_cs.GLenum) +def glEnableClientState(array):pass +@_f +@_p.types(None,) +def glFinish():pass +@_f +@_p.types(None,) +def glFlush():pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLfloat) +def glFogf(pname,param):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLfloatArray) +def glFogfv(pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLfixed) +def glFogx(pname,param):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLfixedArray) +def glFogxv(pname,param):pass +@_f +@_p.types(None,_cs.GLenum) +def glFrontFace(mode):pass +@_f +@_p.types(None,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat) +def glFrustumf(l,r,b,t,n,f):pass +@_f +@_p.types(None,_cs.GLfixed,_cs.GLfixed,_cs.GLfixed,_cs.GLfixed,_cs.GLfixed,_cs.GLfixed) +def glFrustumx(l,r,b,t,n,f):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray) +def glGenBuffers(n,buffers):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray) +def glGenTextures(n,textures):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLbooleanArray) +def glGetBooleanv(pname,data):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLintArray) +def glGetBufferParameteriv(target,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLfloatArray) +def glGetClipPlanef(plane,equation):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLfixedArray) +def glGetClipPlanex(plane,equation):pass +@_f +@_p.types(_cs.GLenum,) +def glGetError():pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLfixedArray) +def glGetFixedv(pname,params):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLfloatArray) +def glGetFloatv(pname,data):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLintArray) +def glGetIntegerv(pname,data):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLfloatArray) +def glGetLightfv(light,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLfixedArray) +def glGetLightxv(light,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLfloatArray) +def glGetMaterialfv(face,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLfixedArray) +def glGetMaterialxv(face,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLvoidpArray) +def glGetPointerv(pname,params):pass +@_f +@_p.types(arrays.GLubyteArray,_cs.GLenum) +def glGetString(name):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLfloatArray) +def glGetTexEnvfv(target,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLintArray) +def glGetTexEnviv(target,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLfixedArray) +def glGetTexEnvxv(target,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLfloatArray) +def glGetTexParameterfv(target,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLintArray) +def glGetTexParameteriv(target,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLfixedArray) +def glGetTexParameterxv(target,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum) +def glHint(target,mode):pass +@_f +@_p.types(_cs.GLboolean,_cs.GLuint) +def glIsBuffer(buffer):pass +@_f +@_p.types(_cs.GLboolean,_cs.GLenum) +def glIsEnabled(cap):pass +@_f +@_p.types(_cs.GLboolean,_cs.GLuint) +def glIsTexture(texture):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLfloat) +def glLightModelf(pname,param):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLfloatArray) +def glLightModelfv(pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLfixed) +def glLightModelx(pname,param):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLfixedArray) +def glLightModelxv(pname,param):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLfloat) +def glLightf(light,pname,param):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLfloatArray) +def glLightfv(light,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLfixed) +def glLightx(light,pname,param):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLfixedArray) +def glLightxv(light,pname,params):pass +@_f +@_p.types(None,_cs.GLfloat) +def glLineWidth(width):pass +@_f +@_p.types(None,_cs.GLfixed) +def glLineWidthx(width):pass +@_f +@_p.types(None,) +def glLoadIdentity():pass +@_f +@_p.types(None,arrays.GLfloatArray) +def glLoadMatrixf(m):pass +@_f +@_p.types(None,arrays.GLfixedArray) +def glLoadMatrixx(m):pass +@_f +@_p.types(None,_cs.GLenum) +def glLogicOp(opcode):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLfloat) +def glMaterialf(face,pname,param):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLfloatArray) +def glMaterialfv(face,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLfixed) +def glMaterialx(face,pname,param):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLfixedArray) +def glMaterialxv(face,pname,param):pass +@_f +@_p.types(None,_cs.GLenum) +def glMatrixMode(mode):pass +@_f +@_p.types(None,arrays.GLfloatArray) +def glMultMatrixf(m):pass +@_f +@_p.types(None,arrays.GLfixedArray) +def glMultMatrixx(m):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat) +def glMultiTexCoord4f(target,s,t,r,q):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLfixed,_cs.GLfixed,_cs.GLfixed,_cs.GLfixed) +def glMultiTexCoord4x(texture,s,t,r,q):pass +@_f +@_p.types(None,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat) +def glNormal3f(nx,ny,nz):pass +@_f +@_p.types(None,_cs.GLfixed,_cs.GLfixed,_cs.GLfixed) +def glNormal3x(nx,ny,nz):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizei,ctypes.c_void_p) +def glNormalPointer(type,stride,pointer):pass +@_f +@_p.types(None,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat) +def glOrthof(l,r,b,t,n,f):pass +@_f +@_p.types(None,_cs.GLfixed,_cs.GLfixed,_cs.GLfixed,_cs.GLfixed,_cs.GLfixed,_cs.GLfixed) +def glOrthox(l,r,b,t,n,f):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLint) +def glPixelStorei(pname,param):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLfloat) +def glPointParameterf(pname,param):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLfloatArray) +def glPointParameterfv(pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLfixed) +def glPointParameterx(pname,param):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLfixedArray) +def glPointParameterxv(pname,params):pass +@_f +@_p.types(None,_cs.GLfloat) +def glPointSize(size):pass +@_f +@_p.types(None,_cs.GLfixed) +def glPointSizex(size):pass +@_f +@_p.types(None,_cs.GLfloat,_cs.GLfloat) +def glPolygonOffset(factor,units):pass +@_f +@_p.types(None,_cs.GLfixed,_cs.GLfixed) +def glPolygonOffsetx(factor,units):pass +@_f +@_p.types(None,) +def glPopMatrix():pass +@_f +@_p.types(None,) +def glPushMatrix():pass +@_f +@_p.types(None,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLsizei,_cs.GLenum,_cs.GLenum,ctypes.c_void_p) +def glReadPixels(x,y,width,height,format,type,pixels):pass +@_f +@_p.types(None,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat) +def glRotatef(angle,x,y,z):pass +@_f +@_p.types(None,_cs.GLfixed,_cs.GLfixed,_cs.GLfixed,_cs.GLfixed) +def glRotatex(angle,x,y,z):pass +@_f +@_p.types(None,_cs.GLfloat,_cs.GLboolean) +def glSampleCoverage(value,invert):pass +@_f +@_p.types(None,_cs.GLclampx,_cs.GLboolean) +def glSampleCoveragex(value,invert):pass +@_f +@_p.types(None,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat) +def glScalef(x,y,z):pass +@_f +@_p.types(None,_cs.GLfixed,_cs.GLfixed,_cs.GLfixed) +def glScalex(x,y,z):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLsizei) +def glScissor(x,y,width,height):pass +@_f +@_p.types(None,_cs.GLenum) +def glShadeModel(mode):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLint,_cs.GLuint) +def glStencilFunc(func,ref,mask):pass +@_f +@_p.types(None,_cs.GLuint) +def glStencilMask(mask):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLenum) +def glStencilOp(fail,zfail,zpass):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLenum,_cs.GLsizei,ctypes.c_void_p) +def glTexCoordPointer(size,type,stride,pointer):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLfloat) +def glTexEnvf(target,pname,param):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLfloatArray) +def glTexEnvfv(target,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLint) +def glTexEnvi(target,pname,param):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLintArray) +def glTexEnviv(target,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLfixed) +def glTexEnvx(target,pname,param):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLfixedArray) +def glTexEnvxv(target,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLsizei,_cs.GLint,_cs.GLenum,_cs.GLenum,ctypes.c_void_p) +def glTexImage2D(target,level,internalformat,width,height,border,format,type,pixels):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLfloat) +def glTexParameterf(target,pname,param):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLfloatArray) +def glTexParameterfv(target,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLint) +def glTexParameteri(target,pname,param):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLintArray) +def glTexParameteriv(target,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLfixed) +def glTexParameterx(target,pname,param):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLfixedArray) +def glTexParameterxv(target,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLsizei,_cs.GLenum,_cs.GLenum,ctypes.c_void_p) +def glTexSubImage2D(target,level,xoffset,yoffset,width,height,format,type,pixels):pass +@_f +@_p.types(None,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat) +def glTranslatef(x,y,z):pass +@_f +@_p.types(None,_cs.GLfixed,_cs.GLfixed,_cs.GLfixed) +def glTranslatex(x,y,z):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLenum,_cs.GLsizei,ctypes.c_void_p) +def glVertexPointer(size,type,stride,pointer):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLsizei) +def glViewport(x,y,width,height):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/VERSION/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/VERSION/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/VERSION/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/VERSION/__pycache__/GLES1_1_0.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/VERSION/__pycache__/GLES1_1_0.cpython-312.pyc new file mode 100644 index 00000000..ff1f44b9 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/VERSION/__pycache__/GLES1_1_0.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/VERSION/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/VERSION/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..db0bc000 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/VERSION/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..fa475157 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/__pycache__/_errors.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/__pycache__/_errors.cpython-312.pyc new file mode 100644 index 00000000..65f8e517 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/__pycache__/_errors.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/__pycache__/_glgets.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/__pycache__/_glgets.cpython-312.pyc new file mode 100644 index 00000000..970fbed6 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/__pycache__/_glgets.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/__pycache__/_types.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/__pycache__/_types.cpython-312.pyc new file mode 100644 index 00000000..0afebaab Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/__pycache__/_types.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/_errors.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/_errors.py new file mode 100644 index 00000000..290bcb3e --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/_errors.py @@ -0,0 +1,6 @@ +from OpenGL.platform import PLATFORM as _p +from OpenGL.error import _ErrorChecker +if _p.GLES1 and _p.GLES1.glGetError and _ErrorChecker: + _error_checker = _ErrorChecker( _p, _p.GLES1.glGetError ) +else: + _error_checker = None diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/_glgets.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/_glgets.py new file mode 100644 index 00000000..f7bcc317 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/_glgets.py @@ -0,0 +1,2290 @@ +"""glGet* auto-generation of output arrays (DO NOT EDIT, AUTOGENERATED)""" +try: + from OpenGL.raw.GL._lookupint import LookupInt as _L +except ImportError: + def _L(*args): + raise RuntimeError( "Need to define a lookupint for this api" ) +_glget_size_mapping = _m = {} +# _m[0x8892] = TODO # GL_ARRAY_BUFFER +# _m[0x92C0] = TODO # GL_ATOMIC_COUNTER_BUFFER +# _m[0x8777] = TODO # GL_BUMP_NUM_TEX_UNITS_ATI +# _m[0x8775] = TODO # GL_BUMP_ROT_MATRIX_ATI +# _m[0x8776] = TODO # GL_BUMP_ROT_MATRIX_SIZE_ATI +# _m[0x8778] = TODO # GL_BUMP_TEX_UNITS_ATI +# _m[0x0A00] = TODO # GL_COEFF +# _m[0x8576] = TODO # GL_CONSTANT +# _m[0x8095] = TODO # GL_DETAIL_TEXTURE_2D_SGIS +# _m[0x809C] = TODO # GL_DETAIL_TEXTURE_FUNC_POINTS_SGIS +# _m[0x809A] = TODO # GL_DETAIL_TEXTURE_LEVEL_SGIS +# _m[0x809B] = TODO # GL_DETAIL_TEXTURE_MODE_SGIS +# _m[0x9599] = TODO # GL_DEVICE_LUID_EXT +# _m[0x959A] = TODO # GL_DEVICE_NODE_MASK_EXT +# _m[0x9597] = TODO # GL_DEVICE_UUID_EXT +# _m[0x90EE] = TODO # GL_DISPATCH_INDIRECT_BUFFER +# _m[0x0A02] = TODO # GL_DOMAIN +# _m[0x8F3F] = TODO # GL_DRAW_INDIRECT_BUFFER +# _m[0x9598] = TODO # GL_DRIVER_UUID_EXT +# _m[0x8124] = TODO # GL_DUAL_TEXTURE_SELECT_SGIS +# _m[0x8893] = TODO # GL_ELEMENT_ARRAY_BUFFER +# _m[0x86C0] = TODO # GL_EVAL_2D_NV +# _m[0x86C1] = TODO # GL_EVAL_TRIANGULAR_2D_NV +# _m[0x2400] = TODO # GL_EYE_LINEAR +# _m[0x8210] = TODO # GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING_EXT +# _m[0x8211] = TODO # GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE_EXT +# _m[0x8DA7] = TODO # GL_FRAMEBUFFER_ATTACHMENT_LAYERED_ARB +# _m[0x8DA7] = TODO # GL_FRAMEBUFFER_ATTACHMENT_LAYERED_EXT +# _m[0x8DA7] = TODO # GL_FRAMEBUFFER_ATTACHMENT_LAYERED_OES +# _m[0x8CD1] = TODO # GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT +# _m[0x8CD1] = TODO # GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_OES +# _m[0x8CD0] = TODO # GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_EXT +# _m[0x8CD0] = TODO # GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_OES +# _m[0x8CD4] = TODO # GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_EXT +# _m[0x8CD4] = TODO # GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_OES +# _m[0x8CD3] = TODO # GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_EXT +# _m[0x8CD3] = TODO # GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_OES +# _m[0x8CD4] = TODO # GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER_EXT +# _m[0x8CD2] = TODO # GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_EXT +# _m[0x8CD2] = TODO # GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_OES +# _m[0x8191] = TODO # GL_GENERATE_MIPMAP_SGIS +# _m[0x8917] = TODO # GL_GEOMETRY_INPUT_TYPE +# _m[0x8918] = TODO # GL_GEOMETRY_OUTPUT_TYPE +# _m[0x8916] = TODO # GL_GEOMETRY_VERTICES_OUT +# _m[0x815E] = TODO # GL_IMAGE_CUBIC_WEIGHT_HP +# _m[0x815C] = TODO # GL_IMAGE_MAG_FILTER_HP +# _m[0x815D] = TODO # GL_IMAGE_MIN_FILTER_HP +# _m[0x8159] = TODO # GL_IMAGE_ROTATE_ANGLE_HP +# _m[0x815A] = TODO # GL_IMAGE_ROTATE_ORIGIN_X_HP +# _m[0x815B] = TODO # GL_IMAGE_ROTATE_ORIGIN_Y_HP +# _m[0x8155] = TODO # GL_IMAGE_SCALE_X_HP +# _m[0x8156] = TODO # GL_IMAGE_SCALE_Y_HP +# _m[0x8157] = TODO # GL_IMAGE_TRANSLATE_X_HP +# _m[0x8158] = TODO # GL_IMAGE_TRANSLATE_Y_HP +# _m[0x8182] = TODO # GL_LIST_PRIORITY_SGIX +# _m[0] = TODO # GL_NONE +# _m[0x9596] = TODO # GL_NUM_DEVICE_UUIDS_EXT +# _m[0x2401] = TODO # GL_OBJECT_LINEAR +# _m[0x0A01] = TODO # GL_ORDER +# _m[0x85A0] = TODO # GL_PACK_SUBSAMPLE_RATE_SGIX +# _m[0x80EE] = TODO # GL_PARAMETER_BUFFER +# _m[0x908A] = TODO # GL_PATH_OBJECT_BOUNDING_BOX_NV +# _m[0x88EB] = TODO # GL_PIXEL_PACK_BUFFER +# _m[0x88EC] = TODO # GL_PIXEL_UNPACK_BUFFER +# _m[0x8063] = TODO # GL_PROXY_TEXTURE_1D +# _m[0x8C19] = TODO # GL_PROXY_TEXTURE_1D_ARRAY +# _m[0x8C19] = TODO # GL_PROXY_TEXTURE_1D_ARRAY_EXT +# _m[0x8063] = TODO # GL_PROXY_TEXTURE_1D_EXT +# _m[0x8064] = TODO # GL_PROXY_TEXTURE_2D +# _m[0x8C1B] = TODO # GL_PROXY_TEXTURE_2D_ARRAY +# _m[0x8C1B] = TODO # GL_PROXY_TEXTURE_2D_ARRAY_EXT +# _m[0x8064] = TODO # GL_PROXY_TEXTURE_2D_EXT +# _m[0x9101] = TODO # GL_PROXY_TEXTURE_2D_MULTISAMPLE +# _m[0x9103] = TODO # GL_PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY +# _m[0x8070] = TODO # GL_PROXY_TEXTURE_3D +# _m[0x8070] = TODO # GL_PROXY_TEXTURE_3D_EXT +# _m[0x8135] = TODO # GL_PROXY_TEXTURE_4D_SGIS +# _m[0x851B] = TODO # GL_PROXY_TEXTURE_CUBE_MAP +# _m[0x851B] = TODO # GL_PROXY_TEXTURE_CUBE_MAP_ARB +# _m[0x900B] = TODO # GL_PROXY_TEXTURE_CUBE_MAP_ARRAY +# _m[0x900B] = TODO # GL_PROXY_TEXTURE_CUBE_MAP_ARRAY_ARB +# _m[0x851B] = TODO # GL_PROXY_TEXTURE_CUBE_MAP_EXT +# _m[0x84F7] = TODO # GL_PROXY_TEXTURE_RECTANGLE +# _m[0x84F7] = TODO # GL_PROXY_TEXTURE_RECTANGLE_ARB +# _m[0x84F7] = TODO # GL_PROXY_TEXTURE_RECTANGLE_NV +# _m[0x8125] = TODO # GL_QUAD_TEXTURE_SELECT_SGIS +# _m[0x9192] = TODO # GL_QUERY_BUFFER +# _m[0x8D53] = TODO # GL_RENDERBUFFER_ALPHA_SIZE_EXT +# _m[0x8D53] = TODO # GL_RENDERBUFFER_ALPHA_SIZE_OES +# _m[0x8D52] = TODO # GL_RENDERBUFFER_BLUE_SIZE_EXT +# _m[0x8D52] = TODO # GL_RENDERBUFFER_BLUE_SIZE_OES +# _m[0x8D54] = TODO # GL_RENDERBUFFER_DEPTH_SIZE_EXT +# _m[0x8D54] = TODO # GL_RENDERBUFFER_DEPTH_SIZE_OES +# _m[0x8D51] = TODO # GL_RENDERBUFFER_GREEN_SIZE_EXT +# _m[0x8D51] = TODO # GL_RENDERBUFFER_GREEN_SIZE_OES +# _m[0x8D43] = TODO # GL_RENDERBUFFER_HEIGHT_EXT +# _m[0x8D43] = TODO # GL_RENDERBUFFER_HEIGHT_OES +# _m[0x8D44] = TODO # GL_RENDERBUFFER_INTERNAL_FORMAT_EXT +# _m[0x8D44] = TODO # GL_RENDERBUFFER_INTERNAL_FORMAT_OES +# _m[0x8D50] = TODO # GL_RENDERBUFFER_RED_SIZE_EXT +# _m[0x8D50] = TODO # GL_RENDERBUFFER_RED_SIZE_OES +# _m[0x8CAB] = TODO # GL_RENDERBUFFER_SAMPLES_ANGLE +# _m[0x8CAB] = TODO # GL_RENDERBUFFER_SAMPLES_APPLE +# _m[0x8CAB] = TODO # GL_RENDERBUFFER_SAMPLES_EXT +# _m[0x8CAB] = TODO # GL_RENDERBUFFER_SAMPLES_NV +# _m[0x8D55] = TODO # GL_RENDERBUFFER_STENCIL_SIZE_EXT +# _m[0x8D55] = TODO # GL_RENDERBUFFER_STENCIL_SIZE_OES +# _m[0x8D42] = TODO # GL_RENDERBUFFER_WIDTH_EXT +# _m[0x8D42] = TODO # GL_RENDERBUFFER_WIDTH_OES +# _m[0x80BF] = TODO # GL_SHADOW_AMBIENT_SGIX +# _m[0x81FB] = TODO # GL_SHARED_TEXTURE_PALETTE_EXT +# _m[0x80B0] = TODO # GL_SHARPEN_TEXTURE_FUNC_POINTS_SGIS +# _m[0x9100] = TODO # GL_TEXTURE_2D_MULTISAMPLE +# _m[0x9102] = TODO # GL_TEXTURE_2D_MULTISAMPLE_ARRAY +# _m[0x8136] = TODO # GL_TEXTURE_4DSIZE_SGIS +# _m[0x8175] = TODO # GL_TEXTURE_CLIPMAP_LOD_OFFSET_SGIX +# _m[0x1003] = TODO # GL_TEXTURE_COMPONENTS +# _m[0x9009] = TODO # GL_TEXTURE_CUBE_MAP_ARRAY_ARB +# _m[0x9009] = TODO # GL_TEXTURE_CUBE_MAP_ARRAY_EXT +# _m[0x9009] = TODO # GL_TEXTURE_CUBE_MAP_ARRAY_OES +# _m[0x8516] = TODO # GL_TEXTURE_CUBE_MAP_NEGATIVE_X +# _m[0x8518] = TODO # GL_TEXTURE_CUBE_MAP_NEGATIVE_Y +# _m[0x851A] = TODO # GL_TEXTURE_CUBE_MAP_NEGATIVE_Z +# _m[0x8515] = TODO # GL_TEXTURE_CUBE_MAP_POSITIVE_X +# _m[0x8517] = TODO # GL_TEXTURE_CUBE_MAP_POSITIVE_Y +# _m[0x8519] = TODO # GL_TEXTURE_CUBE_MAP_POSITIVE_Z +# _m[0x8147] = TODO # GL_TEXTURE_FILTER4_SIZE_SGIS +# _m[0x819D] = TODO # GL_TEXTURE_GEQUAL_R_SGIX +# _m[0x819C] = TODO # GL_TEXTURE_LEQUAL_R_SGIX +# _m[0x84FE] = TODO # GL_TEXTURE_MAX_ANISOTROPY +# _m[0x8C8E] = TODO # GL_TRANSFORM_FEEDBACK_BUFFER +# _m[0x8A11] = TODO # GL_UNIFORM_BUFFER +# _m[0x85A1] = TODO # GL_UNPACK_SUBSAMPLE_RATE_SGIX +_m[0x0D5B] = (1,) # GL_ACCUM_ALPHA_BITS +_m[0x0D5A] = (1,) # GL_ACCUM_BLUE_BITS +_m[0x0B80] = (4,) # GL_ACCUM_CLEAR_VALUE +_m[0x0D59] = (1,) # GL_ACCUM_GREEN_BITS +_m[0x0D58] = (1,) # GL_ACCUM_RED_BITS +_m[0x92D9] = (1,) # GL_ACTIVE_ATOMIC_COUNTER_BUFFERS +_m[0x8B89] = (1,) # GL_ACTIVE_ATTRIBUTES +_m[0x8B8A] = (1,) # GL_ACTIVE_ATTRIBUTE_MAX_LENGTH +_m[0x8259] = (1,) # GL_ACTIVE_PROGRAM +_m[0x92F5] = (1,) # GL_ACTIVE_RESOURCES +_m[0x8911] = (1,) # GL_ACTIVE_STENCIL_FACE_EXT +_m[0x8DE5] = (1,) # GL_ACTIVE_SUBROUTINES +_m[0x8E48] = (1,) # GL_ACTIVE_SUBROUTINE_MAX_LENGTH +_m[0x8DE6] = (1,) # GL_ACTIVE_SUBROUTINE_UNIFORMS +_m[0x8E47] = (1,) # GL_ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS +_m[0x8E49] = (1,) # GL_ACTIVE_SUBROUTINE_UNIFORM_MAX_LENGTH +_m[0x84E0] = (1,) # GL_ACTIVE_TEXTURE +_m[0x84E0] = (1,) # GL_ACTIVE_TEXTURE_ARB +_m[0x8B86] = (1,) # GL_ACTIVE_UNIFORMS +_m[0x8A36] = (1,) # GL_ACTIVE_UNIFORM_BLOCKS +_m[0x8A35] = (1,) # GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH +_m[0x8B87] = (1,) # GL_ACTIVE_UNIFORM_MAX_LENGTH +_m[0x9305] = (1,) # GL_ACTIVE_VARIABLES +_m[0x86A5] = (1,) # GL_ACTIVE_VERTEX_UNITS_ARB +_m[0x846E] = (2,) # GL_ALIASED_LINE_WIDTH_RANGE +_m[0x846D] = (2,) # GL_ALIASED_POINT_SIZE_RANGE +_m[0x0D1D] = (1,) # GL_ALPHA_BIAS +_m[0x0D55] = (1,) # GL_ALPHA_BITS +_m[0x8567] = (1,) # GL_ALPHA_MAX_CLAMP_INGR +_m[0x8563] = (1,) # GL_ALPHA_MIN_CLAMP_INGR +_m[0x0D1C] = (1,) # GL_ALPHA_SCALE +_m[0x0BC0] = (1,) # GL_ALPHA_TEST +_m[0x0BC1] = (1,) # GL_ALPHA_TEST_FUNC +_m[0x0BC1] = (1,) # GL_ALPHA_TEST_FUNC_QCOM +_m[0x0BC0] = (1,) # GL_ALPHA_TEST_QCOM +_m[0x0BC2] = (1,) # GL_ALPHA_TEST_REF +_m[0x0BC2] = (1,) # GL_ALPHA_TEST_REF_QCOM +_m[0x92BF] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_alpha_to_coverage_dither_control.txt # GL_ALPHA_TO_COVERAGE_DITHER_MODE_NV +_m[0x1200] = (4,) # GL_AMBIENT +_m[0x1602] = (4,) # GL_AMBIENT_AND_DIFFUSE +_m[0x8C2F] = (1,) # GL_ANY_SAMPLES_PASSED +_m[0x8D6A] = (1,) # GL_ANY_SAMPLES_PASSED_CONSERVATIVE +_m[0x8894] = (1,) # GL_ARRAY_BUFFER_BINDING +_m[0x8894] = (1,) # GL_ARRAY_BUFFER_BINDING_ARB +_m[0x81A9] = (1,) # GL_ARRAY_ELEMENT_LOCK_COUNT_EXT +_m[0x81A8] = (1,) # GL_ARRAY_ELEMENT_LOCK_FIRST_EXT +_m[0x8766] = (1,) # GL_ARRAY_OBJECT_BUFFER_ATI +_m[0x8767] = (1,) # GL_ARRAY_OBJECT_OFFSET_ATI +_m[0x92FB] = (1,) # GL_ARRAY_SIZE +_m[0x92FE] = (1,) # GL_ARRAY_STRIDE +_m[0x835D] = (1,) # GL_ASYNC_DRAW_PIXELS_SGIX +_m[0x832C] = (1,) # GL_ASYNC_HISTOGRAM_SGIX +_m[0x8329] = (1,) # GL_ASYNC_MARKER_SGIX +_m[0x835E] = (1,) # GL_ASYNC_READ_PIXELS_SGIX +_m[0x835C] = (1,) # GL_ASYNC_TEX_IMAGE_SGIX +_m[0x92C5] = (1,) # GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTERS +_m[0x92C6] = (1,)#TODO Is actually GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTERS # GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTER_INDICES +_m[0x92C1] = (1,) # GL_ATOMIC_COUNTER_BUFFER_BINDING +_m[0x92C4] = (1,)#TODO Is actually GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTERS # GL_ATOMIC_COUNTER_BUFFER_DATA_SIZE +_m[0x9301] = (1,) # GL_ATOMIC_COUNTER_BUFFER_INDEX +_m[0x90ED] = (1,)#TODO Is actually GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTERS # GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_COMPUTE_SHADER +_m[0x92CB] = (1,)#TODO Is actually GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTERS # GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_FRAGMENT_SHADER +_m[0x92CA] = (1,)#TODO Is actually GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTERS # GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_GEOMETRY_SHADER +_m[0x959E] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_MESH_SHADER_NV +_m[0x959F] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TASK_SHADER_NV +_m[0x92C8] = (1,)#TODO Is actually GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTERS # GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_CONTROL_SHADER +_m[0x92C9] = (1,)#TODO Is actually GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTERS # GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_EVALUATION_SHADER +_m[0x92C7] = (1,)#TODO Is actually GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTERS # GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_VERTEX_SHADER +_m[0x92C3] = (1,)#TODO Is actually GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTERS # GL_ATOMIC_COUNTER_BUFFER_SIZE +_m[0x92C2] = (1,)#TODO Is actually GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTERS # GL_ATOMIC_COUNTER_BUFFER_START +_m[0x8B85] = (1,) # GL_ATTACHED_SHADERS +_m[0x8645] = (1,) # GL_ATTRIB_ARRAY_POINTER_NV +_m[0x8623] = (1,) # GL_ATTRIB_ARRAY_SIZE_NV +_m[0x8624] = (1,) # GL_ATTRIB_ARRAY_STRIDE_NV +_m[0x8625] = (1,) # GL_ATTRIB_ARRAY_TYPE_NV +_m[0x0BB0] = (1,) # GL_ATTRIB_STACK_DEPTH +_m[0x8295] = (1,) # GL_AUTO_GENERATE_MIPMAP +_m[0x0D80] = (1,) # GL_AUTO_NORMAL +_m[0x0C00] = (1,) # GL_AUX_BUFFERS +_m[0x843A] = (1,) # GL_BINORMAL_ARRAY_EXT +_m[0x8443] = (1,) # GL_BINORMAL_ARRAY_POINTER_EXT +_m[0x8441] = (1,) # GL_BINORMAL_ARRAY_STRIDE_EXT +_m[0x8440] = (1,) # GL_BINORMAL_ARRAY_TYPE_EXT +_m[0x0BE2] = (1,) # GL_BLEND +_m[0x9285] = (1,) # GL_BLEND_ADVANCED_COHERENT_KHR +_m[0x9285] = (1,) # GL_BLEND_ADVANCED_COHERENT_NV +_m[0x8005] = (4,) # GL_BLEND_COLOR +_m[0x8005] = (4,) # GL_BLEND_COLOR_EXT +_m[0x0BE0] = (1,) # GL_BLEND_DST +_m[0x80CA] = (1,) # GL_BLEND_DST_ALPHA +_m[0x80CA] = (1,) # GL_BLEND_DST_ALPHA_EXT +_m[0x80C8] = (1,) # GL_BLEND_DST_RGB +_m[0x80C8] = (1,) # GL_BLEND_DST_RGB_EXT +_m[0x8009] = (1,) # GL_BLEND_EQUATION +_m[0x883D] = (1,) # GL_BLEND_EQUATION_ALPHA +_m[0x883D] = (1,) # GL_BLEND_EQUATION_ALPHA_EXT +_m[0x8009] = (1,) # GL_BLEND_EQUATION_EXT +_m[0x8009] = (1,) # GL_BLEND_EQUATION_RGB +_m[0x9281] = (3,) # GL_BLEND_OVERLAP_NV +_m[0x9280] = (1,) # GL_BLEND_PREMULTIPLIED_SRC_NV +_m[0x0BE1] = (1,) # GL_BLEND_SRC +_m[0x80CB] = (1,) # GL_BLEND_SRC_ALPHA +_m[0x80CB] = (1,) # GL_BLEND_SRC_ALPHA_EXT +_m[0x80C9] = (1,) # GL_BLEND_SRC_RGB +_m[0x80C9] = (1,) # GL_BLEND_SRC_RGB_EXT +_m[0x92FD] = (1,) # GL_BLOCK_INDEX +_m[0x0D1B] = (1,) # GL_BLUE_BIAS +_m[0x0D54] = (1,) # GL_BLUE_BITS +_m[0x8566] = (1,) # GL_BLUE_MAX_CLAMP_INGR +_m[0x8562] = (1,) # GL_BLUE_MIN_CLAMP_INGR +_m[0x0D1A] = (1,) # GL_BLUE_SCALE +_m[0x88BB] = (1,) # GL_BUFFER_ACCESS +_m[0x88BB] = (1,) # GL_BUFFER_ACCESS_ARB +_m[0x911F] = (1,) # GL_BUFFER_ACCESS_FLAGS +_m[0x9302] = (1,) # GL_BUFFER_BINDING +_m[0x9303] = (1,) # GL_BUFFER_DATA_SIZE +_m[0x8F1D] = (1,) # GL_BUFFER_GPU_ADDRESS_NV +_m[0x821F] = (1,) # GL_BUFFER_IMMUTABLE_STORAGE +_m[0x88BC] = (1,) # GL_BUFFER_MAPPED +_m[0x88BC] = (1,) # GL_BUFFER_MAPPED_ARB +_m[0x9120] = (1,) # GL_BUFFER_MAP_LENGTH +_m[0x9121] = (1,) # GL_BUFFER_MAP_OFFSET +_m[0x88BD] = (1,) # GL_BUFFER_MAP_POINTER +_m[0x88BD] = (1,) # GL_BUFFER_MAP_POINTER_ARB +_m[0x8764] = (1,) # GL_BUFFER_SIZE +_m[0x8764] = (1,) # GL_BUFFER_SIZE_ARB +_m[0x8220] = (1,) # GL_BUFFER_STORAGE_FLAGS +_m[0x8765] = (1,) # GL_BUFFER_USAGE +_m[0x8765] = (1,) # GL_BUFFER_USAGE_ARB +_m[0x877C] = (1,) # GL_BUMP_TARGET_ATI +_m[0x8183] = (1,) # GL_CALLIGRAPHIC_FRAGMENT_SGIX +_m[0x891B] = (1,) # GL_CLAMP_FRAGMENT_COLOR +_m[0x891B] = (1,) # GL_CLAMP_FRAGMENT_COLOR_ARB +_m[0x891C] = (1,) # GL_CLAMP_READ_COLOR +_m[0x891C] = (1,) # GL_CLAMP_READ_COLOR_ARB +_m[0x891A] = (1,) # GL_CLAMP_VERTEX_COLOR +_m[0x891A] = (1,) # GL_CLAMP_VERTEX_COLOR_ARB +_m[0x82B4] = (1,) # GL_CLEAR_BUFFER +_m[0x84E1] = (1,) # GL_CLIENT_ACTIVE_TEXTURE +_m[0x84E1] = (1,) # GL_CLIENT_ACTIVE_TEXTURE_ARB +_m[0x0BB1] = (1,) # GL_CLIENT_ATTRIB_STACK_DEPTH +_m[0x935D] = (2,) # GL_CLIP_DEPTH_MODE +_m[0x3000] = (1,) # GL_CLIP_DISTANCE0 +_m[0x3001] = (1,) # GL_CLIP_DISTANCE1 +_m[0x3002] = (1,) # GL_CLIP_DISTANCE2 +_m[0x3003] = (1,) # GL_CLIP_DISTANCE3 +_m[0x3004] = (1,) # GL_CLIP_DISTANCE4 +_m[0x3005] = (1,) # GL_CLIP_DISTANCE5 +_m[0x3006] = (1,) # GL_CLIP_DISTANCE6 +_m[0x3007] = (1,) # GL_CLIP_DISTANCE7 +_m[0x935C] = (2,) # GL_CLIP_ORIGIN +_m[0x3000] = (1,) # GL_CLIP_PLANE0 +_m[0x3001] = (1,) # GL_CLIP_PLANE1 +_m[0x3002] = (1,) # GL_CLIP_PLANE2 +_m[0x3003] = (1,) # GL_CLIP_PLANE3 +_m[0x3004] = (1,) # GL_CLIP_PLANE4 +_m[0x3005] = (1,) # GL_CLIP_PLANE5 +_m[0x80F0] = (1,) # GL_CLIP_VOLUME_CLIPPING_HINT_EXT +_m[0x8975] = (1,) # GL_COLOR_ALPHA_PAIRING_ATI +_m[0x8076] = (1,) # GL_COLOR_ARRAY +_m[0x8898] = (1,) # GL_COLOR_ARRAY_BUFFER_BINDING +_m[0x8898] = (1,) # GL_COLOR_ARRAY_BUFFER_BINDING_ARB +_m[0x8084] = (1,) # GL_COLOR_ARRAY_COUNT_EXT +_m[0x8076] = (1,) # GL_COLOR_ARRAY_EXT +_m[0x8F2D] = (1,) # GL_COLOR_ARRAY_LENGTH_NV +_m[0x83F7] = (1,) # GL_COLOR_ARRAY_PARALLEL_POINTERS_INTEL +_m[0x8090] = (1,) # GL_COLOR_ARRAY_POINTER +_m[0x8081] = (1,) # GL_COLOR_ARRAY_SIZE +_m[0x8081] = (1,) # GL_COLOR_ARRAY_SIZE_EXT +_m[0x8083] = (1,) # GL_COLOR_ARRAY_STRIDE +_m[0x8083] = (1,) # GL_COLOR_ARRAY_STRIDE_EXT +_m[0x8082] = (1,) # GL_COLOR_ARRAY_TYPE +_m[0x8082] = (1,) # GL_COLOR_ARRAY_TYPE_EXT +_m[0x8835] = (4,) # GL_COLOR_CLEAR_UNCLAMPED_VALUE_ATI +_m[0x0C22] = (4,) # GL_COLOR_CLEAR_VALUE +_m[0x8283] = (1,) # GL_COLOR_COMPONENTS +_m[0x8296] = (1,) # GL_COLOR_ENCODING +_m[0x8A0F] = (1,) # GL_COLOR_FLOAT_APPLE +_m[0x1603] = (3,) # GL_COLOR_INDEXES +_m[0x0BF2] = (1,) # GL_COLOR_LOGIC_OP +_m[0x0B57] = (1,) # GL_COLOR_MATERIAL +_m[0x0B55] = (1,) # GL_COLOR_MATERIAL_FACE +_m[0x0B56] = (1,) # GL_COLOR_MATERIAL_PARAMETER +_m[0x80B1] = (4,4) # GL_COLOR_MATRIX +_m[0x80B1] = (4,4) # GL_COLOR_MATRIX_SGI +_m[0x80B2] = (1,) # GL_COLOR_MATRIX_STACK_DEPTH +_m[0x80B2] = (1,) # GL_COLOR_MATRIX_STACK_DEPTH_SGI +_m[0x8286] = (1,) # GL_COLOR_RENDERABLE +_m[0x8E20] = (1,) # GL_COLOR_SAMPLES_NV +_m[0x8458] = (1,) # GL_COLOR_SUM +_m[0x8458] = (1,) # GL_COLOR_SUM_ARB +_m[0x854F] = (1,) # GL_COLOR_SUM_CLAMP_NV +_m[0x8458] = (1,) # GL_COLOR_SUM_EXT +_m[0x80D0] = (1,) # GL_COLOR_TABLE +_m[0x80DD] = (1,) # GL_COLOR_TABLE_ALPHA_SIZE +_m[0x80DD] = (1,) # GL_COLOR_TABLE_ALPHA_SIZE_SGI +_m[0x80D7] = (4,) # GL_COLOR_TABLE_BIAS +_m[0x80D7] = (4,) # GL_COLOR_TABLE_BIAS_SGI +_m[0x80DC] = (1,) # GL_COLOR_TABLE_BLUE_SIZE +_m[0x80DC] = (1,) # GL_COLOR_TABLE_BLUE_SIZE_SGI +_m[0x80D8] = (1,) # GL_COLOR_TABLE_FORMAT +_m[0x80D8] = (1,) # GL_COLOR_TABLE_FORMAT_SGI +_m[0x80DB] = (1,) # GL_COLOR_TABLE_GREEN_SIZE +_m[0x80DB] = (1,) # GL_COLOR_TABLE_GREEN_SIZE_SGI +_m[0x80DF] = (1,) # GL_COLOR_TABLE_INTENSITY_SIZE +_m[0x80DF] = (1,) # GL_COLOR_TABLE_INTENSITY_SIZE_SGI +_m[0x80DE] = (1,) # GL_COLOR_TABLE_LUMINANCE_SIZE +_m[0x80DE] = (1,) # GL_COLOR_TABLE_LUMINANCE_SIZE_SGI +_m[0x80DA] = (1,) # GL_COLOR_TABLE_RED_SIZE +_m[0x80DA] = (1,) # GL_COLOR_TABLE_RED_SIZE_SGI +_m[0x80D6] = (4,) # GL_COLOR_TABLE_SCALE +_m[0x80D6] = (4,) # GL_COLOR_TABLE_SCALE_SGI +_m[0x80D0] = (1,) # GL_COLOR_TABLE_SGI +_m[0x80D9] = (1,) # GL_COLOR_TABLE_WIDTH +_m[0x80D9] = (1,) # GL_COLOR_TABLE_WIDTH_SGI +_m[0x0C23] = (4,) # GL_COLOR_WRITEMASK +_m[0x8545] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/register_combiners.txt # GL_COMBINER_AB_DOT_PRODUCT_NV +_m[0x854A] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/register_combiners.txt # GL_COMBINER_AB_OUTPUT_NV +_m[0x8549] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/register_combiners.txt # GL_COMBINER_BIAS_NV +_m[0x8546] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/register_combiners.txt # GL_COMBINER_CD_DOT_PRODUCT_NV +_m[0x854B] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/register_combiners.txt # GL_COMBINER_CD_OUTPUT_NV +_m[0x8544] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/register_combiners.txt # GL_COMBINER_COMPONENT_USAGE_NV +_m[0x8542] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/register_combiners.txt # GL_COMBINER_INPUT_NV +_m[0x8543] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/register_combiners.txt # GL_COMBINER_MAPPING_NV +_m[0x8547] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/register_combiners.txt # GL_COMBINER_MUX_SUM_NV +_m[0x8548] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/register_combiners.txt # GL_COMBINER_SCALE_NV +_m[0x854C] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/register_combiners.txt # GL_COMBINER_SUM_OUTPUT_NV +_m[0x8572] = (1,) # GL_COMBINE_ALPHA +_m[0x8571] = (1,) # GL_COMBINE_RGB +_m[0x8E4B] = (1,) # GL_COMPATIBLE_SUBROUTINES +_m[0x8B81] = (1,) # GL_COMPILE_STATUS +_m[0x86A3] = (_L(0x86A2),) # GL_COMPRESSED_TEXTURE_FORMATS +_m[0x86A3] = (_L(0x86A2),) # GL_COMPRESSED_TEXTURE_FORMATS_ARB +_m[0x90FB] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/compute_program5.txt # GL_COMPUTE_PROGRAM_NV +_m[0x91B9] = (1,) # GL_COMPUTE_SHADER +_m[0x82A0] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_COMPUTE_TEXTURE +_m[0x8267] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/compute_shader.txt # GL_COMPUTE_WORK_GROUP_SIZE +_m[0x9374] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_internalformat_sample_query.txt # GL_CONFORMANT_NV +_m[0x937B] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_conservative_raster_dilate.txt # GL_CONSERVATIVE_RASTER_DILATE_GRANULARITY_NV +_m[0x9379] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_conservative_raster_dilate.txt # GL_CONSERVATIVE_RASTER_DILATE_NV +_m[0x937A] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_conservative_raster_dilate.txt # GL_CONSERVATIVE_RASTER_DILATE_RANGE_NV +_m[0x954D] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_conservative_raster_pre_snap_triangles.txt # GL_CONSERVATIVE_RASTER_MODE_NV +_m[0x1207] = (1,) # GL_CONSTANT_ATTENUATION +_m[0x852A] = (4,) # GL_CONSTANT_COLOR0_NV +_m[0x852B] = (4,) # GL_CONSTANT_COLOR1_NV +_m[0x86E5] = (3,) # GL_CONST_EYE_NV +_m[0x821E] = (1,) # GL_CONTEXT_FLAGS +_m[0x00000002] = (1,) # GL_CONTEXT_FLAG_DEBUG_BIT +_m[0x00000004] = (1,) # GL_CONTEXT_FLAG_ROBUST_ACCESS_BIT_ARB +_m[0x9126] = (1,) # GL_CONTEXT_PROFILE_MASK +_m[0x90F3] = (1,)#TODO Review http://www.opengl.org/registry/specs//KHR/robustness.txt # GL_CONTEXT_ROBUST_ACCESS +_m[0x8010] = (1,) # GL_CONVOLUTION_1D +_m[0x8010] = (1,) # GL_CONVOLUTION_1D_EXT +_m[0x8011] = (1,) # GL_CONVOLUTION_2D +_m[0x8011] = (1,) # GL_CONVOLUTION_2D_EXT +_m[0x8154] = (4,) # GL_CONVOLUTION_BORDER_COLOR +_m[0x8013] = (1,) # GL_CONVOLUTION_BORDER_MODE +_m[0x8013] = (1,) # GL_CONVOLUTION_BORDER_MODE_EXT +_m[0x8015] = (4,) # GL_CONVOLUTION_FILTER_BIAS +_m[0x8015] = (4,) # GL_CONVOLUTION_FILTER_BIAS_EXT +_m[0x8014] = (4,) # GL_CONVOLUTION_FILTER_SCALE +_m[0x8014] = (4,) # GL_CONVOLUTION_FILTER_SCALE_EXT +_m[0x8017] = (1,) # GL_CONVOLUTION_FORMAT +_m[0x8019] = (1,) # GL_CONVOLUTION_HEIGHT +_m[0x8316] = (1,) # GL_CONVOLUTION_HINT_SGIX +_m[0x8018] = (1,) # GL_CONVOLUTION_WIDTH +_m[0x8862] = (1,) # GL_COORD_REPLACE +_m[0x8F36] = (1,) # GL_COPY_READ_BUFFER +_m[0x8F37] = (1,) # GL_COPY_WRITE_BUFFER +_m[0x9332] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_framebuffer_mixed_samples.txt # GL_COVERAGE_MODULATION_NV +_m[0x9333] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_framebuffer_mixed_samples.txt # GL_COVERAGE_MODULATION_TABLE_SIZE_NV +_m[0x8ED4] = (1,) # GL_COVERAGE_SAMPLES_NV +_m[0x0B44] = (1,) # GL_CULL_FACE +_m[0x0B45] = (1,) # GL_CULL_FACE_MODE +_m[0x86E0] = (4,) # GL_CULL_MODES_NV +_m[0x81AA] = (1,) # GL_CULL_VERTEX_EXT +_m[0x81AB] = (1,) # GL_CULL_VERTEX_EYE_POSITION_EXT +_m[103050] = (1,)#TODO Review http://www.opengl.org/registry/specs//IBM/cull_vertex.txt # GL_CULL_VERTEX_IBM +_m[0x81AC] = (1,) # GL_CULL_VERTEX_OBJECT_POSITION_EXT +_m[0x8626] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/vertex_program.txt # GL_CURRENT_ATTRIB_NV +_m[0x843C] = (1,) # GL_CURRENT_BINORMAL_EXT +_m[0x0B00] = (4,) # GL_CURRENT_COLOR +_m[0x8453] = (1,) # GL_CURRENT_FOG_COORD +_m[0x8453] = (1,) # GL_CURRENT_FOG_COORDINATE +_m[0x8453] = (1,) # GL_CURRENT_FOG_COORDINATE_EXT +_m[0x0B01] = (1,) # GL_CURRENT_INDEX +_m[0x8641] = (4, 4) # GL_CURRENT_MATRIX_ARB +_m[0x8845] = (1,) # GL_CURRENT_MATRIX_INDEX_ARB +_m[0x8641] = (4, 4) # GL_CURRENT_MATRIX_NV +_m[0x8640] = (1,) # GL_CURRENT_MATRIX_STACK_DEPTH_ARB +_m[0x8640] = (1,) # GL_CURRENT_MATRIX_STACK_DEPTH_NV +_m[0x0B02] = (3,) # GL_CURRENT_NORMAL +_m[0x8865] = (1,) # GL_CURRENT_OCCLUSION_QUERY_ID_NV +_m[0x8843] = (1,) # GL_CURRENT_PALETTE_MATRIX_ARB +_m[0x8843] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/OES/OES_matrix_palette.txt # GL_CURRENT_PALETTE_MATRIX_OES +_m[0x8B8D] = (1,) # GL_CURRENT_PROGRAM +_m[0x8865] = (1,) # GL_CURRENT_QUERY +_m[0x0B04] = (4,) # GL_CURRENT_RASTER_COLOR +_m[0x0B09] = (1,) # GL_CURRENT_RASTER_DISTANCE +_m[0x0B05] = (1,) # GL_CURRENT_RASTER_INDEX +_m[0x8406] = (1,) # GL_CURRENT_RASTER_NORMAL_SGIX +_m[0x0B07] = (4,) # GL_CURRENT_RASTER_POSITION +_m[0x0B08] = (1,) # GL_CURRENT_RASTER_POSITION_VALID +_m[0x0B06] = (4,) # GL_CURRENT_RASTER_TEXTURE_COORDS +_m[0x8459] = (4,) # GL_CURRENT_SECONDARY_COLOR +_m[0x8459] = (1,) # GL_CURRENT_SECONDARY_COLOR_EXT +_m[0x843B] = (1,) # GL_CURRENT_TANGENT_EXT +_m[0x0B03] = (4,) # GL_CURRENT_TEXTURE_COORDS +_m[0x8E28] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/present_video.txt # GL_CURRENT_TIME_NV +_m[0x8626] = (4,) # GL_CURRENT_VERTEX_ATTRIB +_m[0x850B] = (1,) # GL_CURRENT_VERTEX_WEIGHT_EXT +_m[0x86A8] = (1,) # GL_CURRENT_WEIGHT_ARB +_m[0x8244] = (1,) # GL_DEBUG_CALLBACK_FUNCTION +_m[0x8245] = (1,) # GL_DEBUG_CALLBACK_USER_PARAM +_m[0x826D] = (1,) # GL_DEBUG_GROUP_STACK_DEPTH +_m[0x9145] = (1,) # GL_DEBUG_LOGGED_MESSAGES +_m[0x9145] = (1,) # GL_DEBUG_LOGGED_MESSAGES_AMD +_m[0x9145] = (1,) # GL_DEBUG_LOGGED_MESSAGES_ARB +_m[0x8243] = (1,) # GL_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH +_m[0x8243] = (1,) # GL_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH_ARB +_m[0x92E0] = (1,) # GL_DEBUG_OUTPUT +_m[0x8242] = (1,) # GL_DEBUG_OUTPUT_SYNCHRONOUS +_m[0x8196] = (1,) # GL_DEFORMATIONS_MASK_SGIX +_m[0x8B80] = (1,) # GL_DELETE_STATUS +_m[0x0D1F] = (1,) # GL_DEPTH_BIAS +_m[0x0D56] = (1,) # GL_DEPTH_BITS +_m[0x8891] = (1,) # GL_DEPTH_BOUNDS_EXT +_m[0x8890] = (1,) # GL_DEPTH_BOUNDS_TEST_EXT +_m[0x8DAF] = (1,) # GL_DEPTH_BUFFER_FLOAT_MODE_NV +_m[0x864F] = (1,) # GL_DEPTH_CLAMP +_m[0x901F] = (1,) # GL_DEPTH_CLAMP_FAR_AMD +_m[0x901E] = (1,) # GL_DEPTH_CLAMP_NEAR_AMD +_m[0x864F] = (1,) # GL_DEPTH_CLAMP_NV +_m[0x0B73] = (1,) # GL_DEPTH_CLEAR_VALUE +_m[0x8284] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_DEPTH_COMPONENTS +_m[0x0B74] = (1,) # GL_DEPTH_FUNC +_m[0x8311] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/SGIX/SGIX_depth_pass_instrument.txt # GL_DEPTH_PASS_INSTRUMENT_COUNTERS_SGIX +_m[0x8312] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/SGIX/SGIX_depth_pass_instrument.txt # GL_DEPTH_PASS_INSTRUMENT_MAX_SGIX +_m[0x0B70] = (2,) # GL_DEPTH_RANGE +_m[0x8287] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_DEPTH_RENDERABLE +_m[0x932D] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_framebuffer_mixed_samples.txt # GL_DEPTH_SAMPLES_NV +_m[0x0D1E] = (1,) # GL_DEPTH_SCALE +_m[0x90EA] = (1,) # GL_DEPTH_STENCIL_TEXTURE_MODE +_m[0x0B71] = (1,) # GL_DEPTH_TEST +_m[0x884B] = (1,) # GL_DEPTH_TEXTURE_MODE +_m[0x0B72] = (1,) # GL_DEPTH_WRITEMASK +_m[0x95AB] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_memory_attachment.txt # GL_DETACHED_BUFFERS_NV +_m[0x95A9] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_memory_attachment.txt # GL_DETACHED_MEMORY_INCARNATION_NV +_m[0x95AA] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_memory_attachment.txt # GL_DETACHED_TEXTURES_NV +_m[0x8096] = (1,) # GL_DETAIL_TEXTURE_2D_BINDING_SGIS +_m[0x1201] = (4,) # GL_DIFFUSE +_m[0x90EF] = (1,) # GL_DISPATCH_INDIRECT_BUFFER_BINDING +_m[0x8129] = (3,) # GL_DISTANCE_ATTENUATION_SGIS +_m[0x0BD0] = (1,) # GL_DITHER +_m[0x0C32] = (1,) # GL_DOUBLEBUFFER +_m[0x913E] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/IMG/IMG_framebuffer_downsample.txt # GL_DOWNSAMPLE_SCALES_IMG +_m[0x0C01] = (1,) # GL_DRAW_BUFFER +_m[0x8825] = (1,) # GL_DRAW_BUFFER0 +_m[0x8825] = (1,) # GL_DRAW_BUFFER0_ARB +_m[0x8825] = (1,) # GL_DRAW_BUFFER0_ATI +_m[0x8826] = (1,) # GL_DRAW_BUFFER1 +_m[0x882F] = (1,) # GL_DRAW_BUFFER10 +_m[0x882F] = (1,) # GL_DRAW_BUFFER10_ARB +_m[0x882F] = (1,) # GL_DRAW_BUFFER10_ATI +_m[0x8830] = (1,) # GL_DRAW_BUFFER11 +_m[0x8830] = (1,) # GL_DRAW_BUFFER11_ARB +_m[0x8830] = (1,) # GL_DRAW_BUFFER11_ATI +_m[0x8831] = (1,) # GL_DRAW_BUFFER12 +_m[0x8831] = (1,) # GL_DRAW_BUFFER12_ARB +_m[0x8831] = (1,) # GL_DRAW_BUFFER12_ATI +_m[0x8832] = (1,) # GL_DRAW_BUFFER13 +_m[0x8832] = (1,) # GL_DRAW_BUFFER13_ARB +_m[0x8832] = (1,) # GL_DRAW_BUFFER13_ATI +_m[0x8833] = (1,) # GL_DRAW_BUFFER14 +_m[0x8833] = (1,) # GL_DRAW_BUFFER14_ARB +_m[0x8833] = (1,) # GL_DRAW_BUFFER14_ATI +_m[0x8834] = (1,) # GL_DRAW_BUFFER15 +_m[0x8834] = (1,) # GL_DRAW_BUFFER15_ARB +_m[0x8834] = (1,) # GL_DRAW_BUFFER15_ATI +_m[0x8826] = (1,) # GL_DRAW_BUFFER1_ARB +_m[0x8826] = (1,) # GL_DRAW_BUFFER1_ATI +_m[0x8827] = (1,) # GL_DRAW_BUFFER2 +_m[0x8827] = (1,) # GL_DRAW_BUFFER2_ARB +_m[0x8827] = (1,) # GL_DRAW_BUFFER2_ATI +_m[0x8828] = (1,) # GL_DRAW_BUFFER3 +_m[0x8828] = (1,) # GL_DRAW_BUFFER3_ARB +_m[0x8828] = (1,) # GL_DRAW_BUFFER3_ATI +_m[0x8829] = (1,) # GL_DRAW_BUFFER4 +_m[0x8829] = (1,) # GL_DRAW_BUFFER4_ARB +_m[0x8829] = (1,) # GL_DRAW_BUFFER4_ATI +_m[0x882A] = (1,) # GL_DRAW_BUFFER5 +_m[0x882A] = (1,) # GL_DRAW_BUFFER5_ARB +_m[0x882A] = (1,) # GL_DRAW_BUFFER5_ATI +_m[0x882B] = (1,) # GL_DRAW_BUFFER6 +_m[0x882B] = (1,) # GL_DRAW_BUFFER6_ARB +_m[0x882B] = (1,) # GL_DRAW_BUFFER6_ATI +_m[0x882C] = (1,) # GL_DRAW_BUFFER7 +_m[0x882C] = (1,) # GL_DRAW_BUFFER7_ARB +_m[0x882C] = (1,) # GL_DRAW_BUFFER7_ATI +_m[0x882D] = (1,) # GL_DRAW_BUFFER8 +_m[0x882D] = (1,) # GL_DRAW_BUFFER8_ARB +_m[0x882D] = (1,) # GL_DRAW_BUFFER8_ATI +_m[0x882E] = (1,) # GL_DRAW_BUFFER9 +_m[0x882E] = (1,) # GL_DRAW_BUFFER9_ARB +_m[0x882E] = (1,) # GL_DRAW_BUFFER9_ATI +_m[0x0C01] = (1,) # GL_DRAW_BUFFER_EXT +_m[0x8CA9] = (1,) # GL_DRAW_FRAMEBUFFER +_m[0x8CA6] = (1,) # GL_DRAW_FRAMEBUFFER_BINDING +_m[0x8F43] = (1,) # GL_DRAW_INDIRECT_BUFFER_BINDING +_m[0x8716] = (1,) # GL_DS_BIAS_NV +_m[0x8710] = (1,) # GL_DS_SCALE_NV +_m[0x8717] = (1,) # GL_DT_BIAS_NV +_m[0x8711] = (1,) # GL_DT_SCALE_NV +_m[0x0B43] = (1,) # GL_EDGE_FLAG +_m[0x8079] = (1,) # GL_EDGE_FLAG_ARRAY +_m[0x889B] = (1,) # GL_EDGE_FLAG_ARRAY_BUFFER_BINDING +_m[0x889B] = (1,) # GL_EDGE_FLAG_ARRAY_BUFFER_BINDING_ARB +_m[0x808D] = (1,) # GL_EDGE_FLAG_ARRAY_COUNT_EXT +_m[0x8079] = (1,) # GL_EDGE_FLAG_ARRAY_EXT +_m[0x8F30] = (1,) # GL_EDGE_FLAG_ARRAY_LENGTH_NV +_m[0x8093] = (1,) # GL_EDGE_FLAG_ARRAY_POINTER +_m[0x808C] = (1,) # GL_EDGE_FLAG_ARRAY_STRIDE +_m[0x808C] = (1,) # GL_EDGE_FLAG_ARRAY_STRIDE_EXT +_m[0x932C] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_framebuffer_mixed_samples.txt # GL_EFFECTIVE_RASTER_SAMPLES_EXT +_m[0x8895] = (1,) # GL_ELEMENT_ARRAY_BUFFER_BINDING +_m[0x8895] = (1,) # GL_ELEMENT_ARRAY_BUFFER_BINDING_ARB +_m[0x8F33] = (1,) # GL_ELEMENT_ARRAY_LENGTH_NV +_m[0x8A0E] = (1,)#TODO Review http://www.opengl.org/registry/specs//APPLE/element_array.txt # GL_ELEMENT_ARRAY_POINTER_APPLE +_m[0x8A0D] = (1,) # GL_ELEMENT_ARRAY_TYPE_APPLE +_m[0x8769] = (1,) # GL_ELEMENT_ARRAY_TYPE_ATI +_m[0x1600] = (4,) # GL_EMISSION +_m[0x86C5] = (1,) # GL_EVAL_FRACTIONAL_TESSELLATION_NV +_m[0x86C6] = (1,) # GL_EVAL_VERTEX_ATTRIB0_NV +_m[0x86D0] = (1,) # GL_EVAL_VERTEX_ATTRIB10_NV +_m[0x86D1] = (1,) # GL_EVAL_VERTEX_ATTRIB11_NV +_m[0x86D2] = (1,) # GL_EVAL_VERTEX_ATTRIB12_NV +_m[0x86D3] = (1,) # GL_EVAL_VERTEX_ATTRIB13_NV +_m[0x86D4] = (1,) # GL_EVAL_VERTEX_ATTRIB14_NV +_m[0x86D5] = (1,) # GL_EVAL_VERTEX_ATTRIB15_NV +_m[0x86C7] = (1,) # GL_EVAL_VERTEX_ATTRIB1_NV +_m[0x86C8] = (1,) # GL_EVAL_VERTEX_ATTRIB2_NV +_m[0x86C9] = (1,) # GL_EVAL_VERTEX_ATTRIB3_NV +_m[0x86CA] = (1,) # GL_EVAL_VERTEX_ATTRIB4_NV +_m[0x86CB] = (1,) # GL_EVAL_VERTEX_ATTRIB5_NV +_m[0x86CC] = (1,) # GL_EVAL_VERTEX_ATTRIB6_NV +_m[0x86CD] = (1,) # GL_EVAL_VERTEX_ATTRIB7_NV +_m[0x86CE] = (1,) # GL_EVAL_VERTEX_ATTRIB8_NV +_m[0x86CF] = (1,) # GL_EVAL_VERTEX_ATTRIB9_NV +_m[0x1F03] = (1,) # GL_EXTENSIONS +_m[0x81F6] = (7,) # GL_EYE_LINE_SGIS +_m[0x2502] = (4,) # GL_EYE_PLANE +_m[0x81F4] = (4,) # GL_EYE_POINT_SGIS +_m[0x0DF0] = (1,) # GL_FEEDBACK_BUFFER_POINTER +_m[0x0DF1] = (1,) # GL_FEEDBACK_BUFFER_SIZE +_m[0x0DF2] = (1,) # GL_FEEDBACK_BUFFER_TYPE +_m[0x84F4] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/fence.txt # GL_FENCE_CONDITION_NV +_m[0x84F3] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/fence.txt # GL_FENCE_STATUS_NV +_m[0x8F65] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/ARM/ARM_shader_framebuffer_fetch.txt # GL_FETCH_PER_SAMPLE_ARM +_m[0x1B02] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_polygon_mode.txt # GL_FILL_NV +_m[0x829A] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_FILTER +_m[0x888D] = (4,) # GL_FLOAT_CLEAR_COLOR_VALUE_NV +_m[0x888E] = (1,) # GL_FLOAT_RGBA_MODE_NV +_m[0x0B60] = (1,) # GL_FOG +_m[0x0B66] = (4,) # GL_FOG_COLOR +_m[0x889D] = (1,) # GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING_ARB +_m[0x8456] = (1,)#TODO Review http://www.opengl.org/registry/specs//EXT/fog_coord.txt # GL_FOG_COORDINATE_ARRAY_POINTER_EXT +_m[0x8455] = (1,) # GL_FOG_COORDINATE_ARRAY_STRIDE_EXT +_m[0x8454] = (1,) # GL_FOG_COORDINATE_ARRAY_TYPE_EXT +_m[0x8457] = (1,) # GL_FOG_COORD_ARRAY +_m[0x889D] = (1,) # GL_FOG_COORD_ARRAY_BUFFER_BINDING +_m[0x8F32] = (1,) # GL_FOG_COORD_ARRAY_LENGTH_NV +_m[0x8455] = (1,) # GL_FOG_COORD_ARRAY_STRIDE +_m[0x8454] = (1,) # GL_FOG_COORD_ARRAY_TYPE +_m[0x8450] = (1,) # GL_FOG_COORD_SRC +_m[0x0B62] = (1,) # GL_FOG_DENSITY +_m[0x855A] = (1,) # GL_FOG_DISTANCE_MODE_NV +_m[0x0B64] = (1,) # GL_FOG_END +_m[0x812B] = (1,) # GL_FOG_FUNC_POINTS_SGIS +_m[0x0C54] = (1,) # GL_FOG_HINT +_m[0x0B61] = (1,) # GL_FOG_INDEX +_m[0x0B65] = (1,) # GL_FOG_MODE +_m[0x8198] = (1,) # GL_FOG_OFFSET_SGIX +_m[0x8199] = (4,) # GL_FOG_OFFSET_VALUE_SGIX +_m[0x0B63] = (1,) # GL_FOG_START +_m[0x8402] = (1,) # GL_FRAGMENT_COLOR_MATERIAL_FACE_SGIX +_m[0x8403] = (1,) # GL_FRAGMENT_COLOR_MATERIAL_PARAMETER_SGIX +_m[0x8401] = (1,) # GL_FRAGMENT_COLOR_MATERIAL_SGIX +_m[0x92DE] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_fragment_coverage_to_color.txt # GL_FRAGMENT_COVERAGE_COLOR_NV +_m[0x8E5D] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/gpu_shader5.txt # GL_FRAGMENT_INTERPOLATION_OFFSET_BITS +_m[0x840C] = (1,) # GL_FRAGMENT_LIGHT0_SGIX +_m[0x8400] = (1,) # GL_FRAGMENT_LIGHTING_SGIX +_m[0x840A] = (4,) # GL_FRAGMENT_LIGHT_MODEL_AMBIENT_SGIX +_m[0x8408] = (1,) # GL_FRAGMENT_LIGHT_MODEL_LOCAL_VIEWER_SGIX +_m[0x840B] = (1,) # GL_FRAGMENT_LIGHT_MODEL_NORMAL_INTERPOLATION_SGIX +_m[0x8409] = (1,) # GL_FRAGMENT_LIGHT_MODEL_TWO_SIDE_SGIX +_m[0x8804] = (1,) # GL_FRAGMENT_PROGRAM_ARB +_m[0x8873] = (1,) # GL_FRAGMENT_PROGRAM_BINDING_NV +_m[0x8E5D] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/gpu_program5.txt # GL_FRAGMENT_PROGRAM_INTERPOLATION_OFFSET_BITS_NV +_m[0x8870] = (1,) # GL_FRAGMENT_PROGRAM_NV +_m[0x8DA4] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/parameter_buffer_object.txt # GL_FRAGMENT_PROGRAM_PARAMETER_BUFFER_NV +_m[0x8B30] = (1,) # GL_FRAGMENT_SHADER +_m[0x8920] = (1,) # GL_FRAGMENT_SHADER_ATI +_m[0x8B8B] = (1,) # GL_FRAGMENT_SHADER_DERIVATIVE_HINT +_m[0x8B8B] = (1,) # GL_FRAGMENT_SHADER_DERIVATIVE_HINT_ARB +_m[0x8A52] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/EXT/EXT_shader_framebuffer_fetch.txt # GL_FRAGMENT_SHADER_DISCARDS_SAMPLES_EXT +_m[0x8F66] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/ARM/ARM_shader_framebuffer_fetch.txt # GL_FRAGMENT_SHADER_FRAMEBUFFER_FETCH_MRT_ARM +_m[0x829F] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_FRAGMENT_TEXTURE +_m[0x8215] = (1,) # GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE +_m[0x8214] = (1,) # GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE +_m[0x8210] = (1,) # GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING +_m[0x8211] = (1,) # GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE +_m[0x8216] = (1,) # GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE +_m[0x8213] = (1,) # GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE +_m[0x8DA7] = (1,) # GL_FRAMEBUFFER_ATTACHMENT_LAYERED +_m[0x8CD1] = (1,) # GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME +_m[0x8CD0] = (1,) # GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE +_m[0x8212] = (1,) # GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE +_m[0x8217] = (1,) # GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE +_m[0x9632] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/OVR/OVR_multiview.txt # GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_BASE_VIEW_INDEX_OVR +_m[0x8CD3] = (1,) # GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE +_m[0x8CD4] = (1,) # GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER +_m[0x8CD2] = (1,) # GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL +_m[0x9630] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/OVR/OVR_multiview.txt # GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_NUM_VIEWS_OVR +_m[0x8D6C] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/EXT/EXT_multisampled_render_to_texture.txt # GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_SAMPLES_EXT +_m[0x913F] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/IMG/IMG_framebuffer_downsample.txt # GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_SCALE_IMG +_m[0x8CA6] = (1,) # GL_FRAMEBUFFER_BINDING_EXT +_m[0x8CA6] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/OES/OES_framebuffer_object.txt # GL_FRAMEBUFFER_BINDING_OES +_m[0x828B] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_FRAMEBUFFER_BLEND +_m[0x9314] = (1,) # GL_FRAMEBUFFER_DEFAULT_FIXED_SAMPLE_LOCATIONS +_m[0x9311] = (1,) # GL_FRAMEBUFFER_DEFAULT_HEIGHT +_m[0x9312] = (1,) # GL_FRAMEBUFFER_DEFAULT_LAYERS +_m[0x9313] = (1,) # GL_FRAMEBUFFER_DEFAULT_SAMPLES +_m[0x9310] = (1,) # GL_FRAMEBUFFER_DEFAULT_WIDTH +_m[0x96A2] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/QCOM/QCOM_shader_framebuffer_fetch_noncoherent.txt # GL_FRAMEBUFFER_FETCH_NONCOHERENT_QCOM +_m[0x8289] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_FRAMEBUFFER_RENDERABLE +_m[0x828A] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_FRAMEBUFFER_RENDERABLE_LAYERED +_m[0x8DB9] = (1,) # GL_FRAMEBUFFER_SRGB +_m[0x8DBA] = (1,) # GL_FRAMEBUFFER_SRGB_CAPABLE_EXT +_m[0x8DB9] = (1,) # GL_FRAMEBUFFER_SRGB_EXT +_m[0x818C] = (1,) # GL_FRAMEZOOM_FACTOR_SGIX +_m[0x818B] = (1,) # GL_FRAMEZOOM_SGIX +_m[0x0B46] = (1,) # GL_FRONT_FACE +_m[0x8191] = (1,) # GL_GENERATE_MIPMAP +_m[0x8192] = (1,) # GL_GENERATE_MIPMAP_HINT +_m[0x8192] = (1,) # GL_GENERATE_MIPMAP_HINT_SGIS +_m[0x8DDB] = (1,) # GL_GEOMETRY_INPUT_TYPE_ARB +_m[0x8DDB] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/geometry_program4.txt # GL_GEOMETRY_INPUT_TYPE_EXT +_m[0x8917] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/EXT/EXT_geometry_shader.txt # GL_GEOMETRY_LINKED_INPUT_TYPE_EXT +_m[0x8917] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/OES/OES_geometry_shader.txt # GL_GEOMETRY_LINKED_INPUT_TYPE_OES +_m[0x8918] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/EXT/EXT_geometry_shader.txt # GL_GEOMETRY_LINKED_OUTPUT_TYPE_EXT +_m[0x8918] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/OES/OES_geometry_shader.txt # GL_GEOMETRY_LINKED_OUTPUT_TYPE_OES +_m[0x8916] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/EXT/EXT_geometry_shader.txt # GL_GEOMETRY_LINKED_VERTICES_OUT_EXT +_m[0x8916] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/OES/OES_geometry_shader.txt # GL_GEOMETRY_LINKED_VERTICES_OUT_OES +_m[0x8DDC] = (1,) # GL_GEOMETRY_OUTPUT_TYPE_ARB +_m[0x8DDC] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/geometry_program4.txt # GL_GEOMETRY_OUTPUT_TYPE_EXT +_m[0x8C26] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/geometry_program4.txt # GL_GEOMETRY_PROGRAM_NV +_m[0x8DA3] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/parameter_buffer_object.txt # GL_GEOMETRY_PROGRAM_PARAMETER_BUFFER_NV +_m[0x8DD9] = (1,) # GL_GEOMETRY_SHADER +_m[0x887F] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/gpu_shader5.txt # GL_GEOMETRY_SHADER_INVOCATIONS +_m[0x829E] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_GEOMETRY_TEXTURE +_m[0x8DDA] = (1,) # GL_GEOMETRY_VERTICES_OUT_ARB +_m[0x8DDA] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/geometry_program4.txt # GL_GEOMETRY_VERTICES_OUT_EXT +_m[0x8291] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_GET_TEXTURE_IMAGE_FORMAT +_m[0x8292] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_GET_TEXTURE_IMAGE_TYPE +_m[0x81DA] = (1,) # GL_GLOBAL_ALPHA_FACTOR_SUN +_m[0x8FBB] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/EXT/EXT_disjoint_timer_query.txt # GL_GPU_DISJOINT_EXT +_m[0x9049] = (1,) # GL_GPU_MEMORY_INFO_CURRENT_AVAILABLE_VIDMEM_NVX +_m[0x9047] = (1,) # GL_GPU_MEMORY_INFO_DEDICATED_VIDMEM_NVX +_m[0x904B] = (1,) # GL_GPU_MEMORY_INFO_EVICTED_MEMORY_NVX +_m[0x904A] = (1,) # GL_GPU_MEMORY_INFO_EVICTION_COUNT_NVX +_m[0x9048] = (1,) # GL_GPU_MEMORY_INFO_TOTAL_AVAILABLE_MEMORY_NVX +_m[0x0D19] = (1,) # GL_GREEN_BIAS +_m[0x0D53] = (1,) # GL_GREEN_BITS +_m[0x8565] = (1,) # GL_GREEN_MAX_CLAMP_INGR +_m[0x8561] = (1,) # GL_GREEN_MIN_CLAMP_INGR +_m[0x0D18] = (1,) # GL_GREEN_SCALE +_m[0x8024] = (1,) # GL_HISTOGRAM +_m[0x802B] = (1,) # GL_HISTOGRAM_ALPHA_SIZE +_m[0x802B] = (1,) # GL_HISTOGRAM_ALPHA_SIZE_EXT +_m[0x802A] = (1,) # GL_HISTOGRAM_BLUE_SIZE +_m[0x802A] = (1,) # GL_HISTOGRAM_BLUE_SIZE_EXT +_m[0x8024] = (1,) # GL_HISTOGRAM_EXT +_m[0x8027] = (1,) # GL_HISTOGRAM_FORMAT +_m[0x8027] = (1,) # GL_HISTOGRAM_FORMAT_EXT +_m[0x8029] = (1,) # GL_HISTOGRAM_GREEN_SIZE +_m[0x8029] = (1,) # GL_HISTOGRAM_GREEN_SIZE_EXT +_m[0x802C] = (1,) # GL_HISTOGRAM_LUMINANCE_SIZE +_m[0x802C] = (1,) # GL_HISTOGRAM_LUMINANCE_SIZE_EXT +_m[0x8028] = (1,) # GL_HISTOGRAM_RED_SIZE +_m[0x8028] = (1,) # GL_HISTOGRAM_RED_SIZE_EXT +_m[0x802D] = (1,) # GL_HISTOGRAM_SINK +_m[0x802D] = (1,) # GL_HISTOGRAM_SINK_EXT +_m[0x8026] = (1,) # GL_HISTOGRAM_WIDTH +_m[0x8026] = (1,) # GL_HISTOGRAM_WIDTH_EXT +_m[0x8714] = (1,) # GL_HI_BIAS_NV +_m[0x870E] = (1,) # GL_HI_SCALE_NV +_m[0x82A8] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_IMAGE_COMPATIBILITY_CLASS +_m[0x90C7] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_IMAGE_FORMAT_COMPATIBILITY_TYPE +_m[0x82A9] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_IMAGE_PIXEL_FORMAT +_m[0x82AA] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_IMAGE_PIXEL_TYPE +_m[0x82A7] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_IMAGE_TEXEL_SIZE +_m[0x8B9B] = (1,) # GL_IMPLEMENTATION_COLOR_READ_FORMAT +_m[0x8B9A] = (1,) # GL_IMPLEMENTATION_COLOR_READ_TYPE +_m[0x8077] = (1,) # GL_INDEX_ARRAY +_m[0x8899] = (1,) # GL_INDEX_ARRAY_BUFFER_BINDING +_m[0x8899] = (1,) # GL_INDEX_ARRAY_BUFFER_BINDING_ARB +_m[0x8087] = (1,) # GL_INDEX_ARRAY_COUNT_EXT +_m[0x8077] = (1,) # GL_INDEX_ARRAY_EXT +_m[0x8F2E] = (1,) # GL_INDEX_ARRAY_LENGTH_NV +_m[0x8091] = (1,) # GL_INDEX_ARRAY_POINTER +_m[0x8086] = (1,) # GL_INDEX_ARRAY_STRIDE +_m[0x8086] = (1,) # GL_INDEX_ARRAY_STRIDE_EXT +_m[0x8085] = (1,) # GL_INDEX_ARRAY_TYPE +_m[0x8085] = (1,) # GL_INDEX_ARRAY_TYPE_EXT +_m[0x0D51] = (1,) # GL_INDEX_BITS +_m[0x0C20] = (1,) # GL_INDEX_CLEAR_VALUE +_m[0x0BF1] = (1,) # GL_INDEX_LOGIC_OP +_m[0x0C30] = (1,) # GL_INDEX_MODE +_m[0x0D13] = (1,) # GL_INDEX_OFFSET +_m[0x0D12] = (1,) # GL_INDEX_SHIFT +_m[0x0C21] = (1,) # GL_INDEX_WRITEMASK +_m[0x8B84] = (1,) # GL_INFO_LOG_LENGTH +_m[0x8181] = (1,) # GL_INSTRUMENT_MEASUREMENTS_SGIX +_m[0x8980] = (1,) # GL_INTERLACE_OML +_m[0x8568] = (1,) # GL_INTERLACE_READ_INGR +_m[0x8981] = (1,) # GL_INTERLACE_READ_OML +_m[0x8094] = (1,) # GL_INTERLACE_SGIX +_m[0x8274] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_INTERNALFORMAT_ALPHA_SIZE +_m[0x827B] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_INTERNALFORMAT_ALPHA_TYPE +_m[0x8273] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_INTERNALFORMAT_BLUE_SIZE +_m[0x827A] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_INTERNALFORMAT_BLUE_TYPE +_m[0x8275] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_INTERNALFORMAT_DEPTH_SIZE +_m[0x827C] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_INTERNALFORMAT_DEPTH_TYPE +_m[0x8272] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_INTERNALFORMAT_GREEN_SIZE +_m[0x8279] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_INTERNALFORMAT_GREEN_TYPE +_m[0x8270] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_INTERNALFORMAT_PREFERRED +_m[0x8271] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_INTERNALFORMAT_RED_SIZE +_m[0x8278] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_INTERNALFORMAT_RED_TYPE +_m[0x8277] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_INTERNALFORMAT_SHARED_SIZE +_m[0x8276] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_INTERNALFORMAT_STENCIL_SIZE +_m[0x827D] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_INTERNALFORMAT_STENCIL_TYPE +_m[0x826F] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_INTERNALFORMAT_SUPPORTED +_m[0x817F] = (1,) # GL_IR_INSTRUMENT1_SGIX +_m[0x92E7] = (1,) # GL_IS_PER_PATCH +_m[0x9300] = (1,) # GL_IS_ROW_MAJOR +_m[0x825E] = (1,) # GL_LAYER_PROVOKING_VERTEX +_m[0x4000] = (1,) # GL_LIGHT0 +_m[0x4001] = (1,) # GL_LIGHT1 +_m[0x4002] = (1,) # GL_LIGHT2 +_m[0x4003] = (1,) # GL_LIGHT3 +_m[0x4004] = (1,) # GL_LIGHT4 +_m[0x4005] = (1,) # GL_LIGHT5 +_m[0x4006] = (1,) # GL_LIGHT6 +_m[0x4007] = (1,) # GL_LIGHT7 +_m[0x0B50] = (1,) # GL_LIGHTING +_m[0x8407] = (1,) # GL_LIGHT_ENV_MODE_SGIX +_m[0x0B53] = (4,) # GL_LIGHT_MODEL_AMBIENT +_m[0x81F8] = (1,) # GL_LIGHT_MODEL_COLOR_CONTROL +_m[0x81F8] = (1,) # GL_LIGHT_MODEL_COLOR_CONTROL_EXT +_m[0x0B51] = (1,) # GL_LIGHT_MODEL_LOCAL_VIEWER +_m[0x0B52] = (1,) # GL_LIGHT_MODEL_TWO_SIDE +_m[0x1208] = (1,) # GL_LINEAR_ATTENUATION +_m[0x1B01] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_polygon_mode.txt # GL_LINE_NV +_m[0x0B20] = (1,) # GL_LINE_SMOOTH +_m[0x0C52] = (1,) # GL_LINE_SMOOTH_HINT +_m[0x0B24] = (1,) # GL_LINE_STIPPLE +_m[0x0B25] = (1,) # GL_LINE_STIPPLE_PATTERN +_m[0x0B26] = (1,) # GL_LINE_STIPPLE_REPEAT +_m[0x0B21] = (1,) # GL_LINE_WIDTH +_m[0x0B23] = (1,) # GL_LINE_WIDTH_GRANULARITY +_m[0x0B22] = (2,) # GL_LINE_WIDTH_RANGE +_m[0x8B82] = (1,) # GL_LINK_STATUS +_m[0x0B32] = (1,) # GL_LIST_BASE +_m[0x0B33] = (1,) # GL_LIST_INDEX +_m[0x0B30] = (1,) # GL_LIST_MODE +_m[0x930E] = (1,) # GL_LOCATION +_m[0x930F] = (1,) # GL_LOCATION_INDEX +_m[0x0BF1] = (1,) # GL_LOGIC_OP +_m[0x0BF0] = (1,) # GL_LOGIC_OP_MODE +_m[0x8252] = (1,)#TODO Review http://www.opengl.org/registry/specs//KHR/robustness.txt # GL_LOSE_CONTEXT_ON_RESET +_m[0x8252] = (1,) # GL_LOSE_CONTEXT_ON_RESET_ARB +_m[0x8715] = (1,) # GL_LO_BIAS_NV +_m[0x870F] = (1,) # GL_LO_SCALE_NV +_m[0x8718] = (1,) # GL_MAGNITUDE_BIAS_NV +_m[0x8712] = (1,) # GL_MAGNITUDE_SCALE_NV +_m[0x821B] = (1,) # GL_MAJOR_VERSION +_m[0x8294] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_MANUAL_GENERATE_MIPMAP +_m[0x0D90] = (1,) # GL_MAP1_COLOR_4 +_m[0x0DD0] = (2,) # GL_MAP1_GRID_DOMAIN +_m[0x0DD1] = (1,) # GL_MAP1_GRID_SEGMENTS +_m[0x0D91] = (1,) # GL_MAP1_INDEX +_m[0x0D92] = (1,) # GL_MAP1_NORMAL +_m[0x0D93] = (1,) # GL_MAP1_TEXTURE_COORD_1 +_m[0x0D94] = (1,) # GL_MAP1_TEXTURE_COORD_2 +_m[0x0D95] = (1,) # GL_MAP1_TEXTURE_COORD_3 +_m[0x0D96] = (1,) # GL_MAP1_TEXTURE_COORD_4 +_m[0x0D97] = (1,) # GL_MAP1_VERTEX_3 +_m[0x0D98] = (1,) # GL_MAP1_VERTEX_4 +_m[0x8660] = (4,) # GL_MAP1_VERTEX_ATTRIB0_4_NV +_m[0x866A] = (4,) # GL_MAP1_VERTEX_ATTRIB10_4_NV +_m[0x866B] = (4,) # GL_MAP1_VERTEX_ATTRIB11_4_NV +_m[0x866C] = (4,) # GL_MAP1_VERTEX_ATTRIB12_4_NV +_m[0x866D] = (4,) # GL_MAP1_VERTEX_ATTRIB13_4_NV +_m[0x866E] = (4,) # GL_MAP1_VERTEX_ATTRIB14_4_NV +_m[0x866F] = (4,) # GL_MAP1_VERTEX_ATTRIB15_4_NV +_m[0x8661] = (4,) # GL_MAP1_VERTEX_ATTRIB1_4_NV +_m[0x8662] = (4,) # GL_MAP1_VERTEX_ATTRIB2_4_NV +_m[0x8663] = (4,) # GL_MAP1_VERTEX_ATTRIB3_4_NV +_m[0x8664] = (4,) # GL_MAP1_VERTEX_ATTRIB4_4_NV +_m[0x8665] = (4,) # GL_MAP1_VERTEX_ATTRIB5_4_NV +_m[0x8666] = (4,) # GL_MAP1_VERTEX_ATTRIB6_4_NV +_m[0x8667] = (4,) # GL_MAP1_VERTEX_ATTRIB7_4_NV +_m[0x8668] = (4,) # GL_MAP1_VERTEX_ATTRIB8_4_NV +_m[0x8669] = (4,) # GL_MAP1_VERTEX_ATTRIB9_4_NV +_m[0x0DB0] = (1,) # GL_MAP2_COLOR_4 +_m[0x0DD2] = (4,) # GL_MAP2_GRID_DOMAIN +_m[0x0DD3] = (2,) # GL_MAP2_GRID_SEGMENTS +_m[0x0DB1] = (1,) # GL_MAP2_INDEX +_m[0x0DB2] = (1,) # GL_MAP2_NORMAL +_m[0x0DB3] = (1,) # GL_MAP2_TEXTURE_COORD_1 +_m[0x0DB4] = (1,) # GL_MAP2_TEXTURE_COORD_2 +_m[0x0DB5] = (1,) # GL_MAP2_TEXTURE_COORD_3 +_m[0x0DB6] = (1,) # GL_MAP2_TEXTURE_COORD_4 +_m[0x0DB7] = (1,) # GL_MAP2_VERTEX_3 +_m[0x0DB8] = (1,) # GL_MAP2_VERTEX_4 +_m[0x8670] = (4,) # GL_MAP2_VERTEX_ATTRIB0_4_NV +_m[0x867A] = (4,) # GL_MAP2_VERTEX_ATTRIB10_4_NV +_m[0x867B] = (4,) # GL_MAP2_VERTEX_ATTRIB11_4_NV +_m[0x867C] = (4,) # GL_MAP2_VERTEX_ATTRIB12_4_NV +_m[0x867D] = (4,) # GL_MAP2_VERTEX_ATTRIB13_4_NV +_m[0x867E] = (4,) # GL_MAP2_VERTEX_ATTRIB14_4_NV +_m[0x867F] = (4,) # GL_MAP2_VERTEX_ATTRIB15_4_NV +_m[0x8671] = (4,) # GL_MAP2_VERTEX_ATTRIB1_4_NV +_m[0x8672] = (4,) # GL_MAP2_VERTEX_ATTRIB2_4_NV +_m[0x8673] = (4,) # GL_MAP2_VERTEX_ATTRIB3_4_NV +_m[0x8674] = (4,) # GL_MAP2_VERTEX_ATTRIB4_4_NV +_m[0x8675] = (4,) # GL_MAP2_VERTEX_ATTRIB5_4_NV +_m[0x8676] = (4,) # GL_MAP2_VERTEX_ATTRIB6_4_NV +_m[0x8677] = (4,) # GL_MAP2_VERTEX_ATTRIB7_4_NV +_m[0x8678] = (4,) # GL_MAP2_VERTEX_ATTRIB8_4_NV +_m[0x8679] = (4,) # GL_MAP2_VERTEX_ATTRIB9_4_NV +_m[0x86C3] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/evaluators.txt # GL_MAP_ATTRIB_U_ORDER_NV +_m[0x86C4] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/evaluators.txt # GL_MAP_ATTRIB_V_ORDER_NV +_m[0x0D10] = (1,) # GL_MAP_COLOR +_m[0x0D11] = (1,) # GL_MAP_STENCIL +_m[0x8844] = (1,) # GL_MATRIX_INDEX_ARRAY_ARB +_m[0x8B9E] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/OES/OES_matrix_palette.txt # GL_MATRIX_INDEX_ARRAY_BUFFER_BINDING_OES +_m[0x8849] = (1,) # GL_MATRIX_INDEX_ARRAY_POINTER_ARB +_m[0x8849] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/OES/OES_matrix_palette.txt # GL_MATRIX_INDEX_ARRAY_POINTER_OES +_m[0x8846] = (1,) # GL_MATRIX_INDEX_ARRAY_SIZE_ARB +_m[0x8846] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/OES/OES_matrix_palette.txt # GL_MATRIX_INDEX_ARRAY_SIZE_OES +_m[0x8848] = (1,) # GL_MATRIX_INDEX_ARRAY_STRIDE_ARB +_m[0x8848] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/OES/OES_matrix_palette.txt # GL_MATRIX_INDEX_ARRAY_STRIDE_OES +_m[0x8847] = (1,) # GL_MATRIX_INDEX_ARRAY_TYPE_ARB +_m[0x8847] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/OES/OES_matrix_palette.txt # GL_MATRIX_INDEX_ARRAY_TYPE_OES +_m[0x0BA0] = (1,) # GL_MATRIX_MODE +_m[0x8840] = (1,) # GL_MATRIX_PALETTE_ARB +_m[0x92FF] = (1,) # GL_MATRIX_STRIDE +_m[0x8073] = (1,) # GL_MAX_3D_TEXTURE_SIZE +_m[0x8073] = (1,) # GL_MAX_3D_TEXTURE_SIZE_EXT +_m[0x8138] = (1,) # GL_MAX_4D_TEXTURE_SIZE_SGIS +_m[0x8405] = (1,) # GL_MAX_ACTIVE_LIGHTS_SGIX +_m[0x88FF] = (1,) # GL_MAX_ARRAY_TEXTURE_LAYERS +_m[0x88FF] = (1,) # GL_MAX_ARRAY_TEXTURE_LAYERS_EXT +_m[0x8360] = (1,) # GL_MAX_ASYNC_DRAW_PIXELS_SGIX +_m[0x832D] = (1,) # GL_MAX_ASYNC_HISTOGRAM_SGIX +_m[0x8361] = (1,) # GL_MAX_ASYNC_READ_PIXELS_SGIX +_m[0x835F] = (1,) # GL_MAX_ASYNC_TEX_IMAGE_SGIX +_m[0x92DC] = (1,) # GL_MAX_ATOMIC_COUNTER_BUFFER_BINDINGS +_m[0x92D8] = (1,) # GL_MAX_ATOMIC_COUNTER_BUFFER_SIZE +_m[0x0D35] = (1,) # GL_MAX_ATTRIB_STACK_DEPTH +_m[0x8DED] = (1,) # GL_MAX_BINDABLE_UNIFORM_SIZE_EXT +_m[0x0D3B] = (1,) # GL_MAX_CLIENT_ATTRIB_STACK_DEPTH +_m[0x8177] = (1,) # GL_MAX_CLIPMAP_DEPTH_SGIX +_m[0x8178] = (1,) # GL_MAX_CLIPMAP_VIRTUAL_DEPTH_SGIX +_m[0x0D32] = (1,) # GL_MAX_CLIP_DISTANCES +_m[0x0D32] = (1,) # GL_MAX_CLIP_PLANES +_m[0x955F] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_shading_rate_image.txt # GL_MAX_COARSE_FRAGMENT_SAMPLES_NV +_m[0x8CDF] = (1,) # GL_MAX_COLOR_ATTACHMENTS +_m[0x8CDF] = (1,) # GL_MAX_COLOR_ATTACHMENTS_EXT +_m[0x91B3] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/AMD/AMD_framebuffer_multisample_advanced.txt # GL_MAX_COLOR_FRAMEBUFFER_SAMPLES_AMD +_m[0x91B4] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/AMD/AMD_framebuffer_multisample_advanced.txt # GL_MAX_COLOR_FRAMEBUFFER_STORAGE_SAMPLES_AMD +_m[0x80B3] = (1,) # GL_MAX_COLOR_MATRIX_STACK_DEPTH +_m[0x80B3] = (1,) # GL_MAX_COLOR_MATRIX_STACK_DEPTH_SGI +_m[0x910E] = (1,) # GL_MAX_COLOR_TEXTURE_SAMPLES +_m[0x92D7] = (1,) # GL_MAX_COMBINED_ATOMIC_COUNTERS +_m[0x92D1] = (1,) # GL_MAX_COMBINED_ATOMIC_COUNTER_BUFFERS +_m[0x82FA] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/cull_distance.txt # GL_MAX_COMBINED_CLIP_AND_CULL_DISTANCES +_m[0x8266] = (1,) # GL_MAX_COMBINED_COMPUTE_UNIFORM_COMPONENTS +_m[0x8282] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_MAX_COMBINED_DIMENSIONS +_m[0x8A33] = (1,) # GL_MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS +_m[0x8A32] = (1,) # GL_MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS +_m[0x90CF] = (1,) # GL_MAX_COMBINED_IMAGE_UNIFORMS +_m[0x8F39] = (1,) # GL_MAX_COMBINED_IMAGE_UNITS_AND_FRAGMENT_OUTPUTS +_m[0x8F39] = (1,) # GL_MAX_COMBINED_IMAGE_UNITS_AND_FRAGMENT_OUTPUTS_EXT +_m[0x8E67] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_MAX_COMBINED_MESH_UNIFORM_COMPONENTS_NV +_m[0x90DC] = (1,) # GL_MAX_COMBINED_SHADER_STORAGE_BLOCKS +_m[0x8E6F] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_MAX_COMBINED_TASK_UNIFORM_COMPONENTS_NV +_m[0x8E1E] = (1,) # GL_MAX_COMBINED_TESS_CONTROL_UNIFORM_COMPONENTS +_m[0x8E1F] = (1,) # GL_MAX_COMBINED_TESS_EVALUATION_UNIFORM_COMPONENTS +_m[0x8B4D] = (1,) # GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS +_m[0x8B4D] = (1,) # GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB +_m[0x8A2E] = (1,) # GL_MAX_COMBINED_UNIFORM_BLOCKS +_m[0x8A31] = (1,) # GL_MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS +_m[0x8265] = (1,) # GL_MAX_COMPUTE_ATOMIC_COUNTERS +_m[0x8264] = (1,) # GL_MAX_COMPUTE_ATOMIC_COUNTER_BUFFERS +_m[0x91BD] = (1,) # GL_MAX_COMPUTE_IMAGE_UNIFORMS +_m[0x90DB] = (1,) # GL_MAX_COMPUTE_SHADER_STORAGE_BLOCKS +_m[0x8262] = (1,) # GL_MAX_COMPUTE_SHARED_MEMORY_SIZE +_m[0x91BC] = (1,) # GL_MAX_COMPUTE_TEXTURE_IMAGE_UNITS +_m[0x91BB] = (1,) # GL_MAX_COMPUTE_UNIFORM_BLOCKS +_m[0x8263] = (1,) # GL_MAX_COMPUTE_UNIFORM_COMPONENTS +_m[0x9344] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/compute_variable_group_size.txt # GL_MAX_COMPUTE_VARIABLE_GROUP_INVOCATIONS_ARB +_m[0x9345] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/compute_variable_group_size.txt # GL_MAX_COMPUTE_VARIABLE_GROUP_SIZE_ARB +_m[0x91BE] = (3,) # GL_MAX_COMPUTE_WORK_GROUP_COUNT +_m[0x90EB] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/compute_shader.txt # GL_MAX_COMPUTE_WORK_GROUP_INVOCATIONS +_m[0x91BF] = (3,) # GL_MAX_COMPUTE_WORK_GROUP_SIZE +_m[0x801B] = (1,) # GL_MAX_CONVOLUTION_HEIGHT +_m[0x801A] = (1,) # GL_MAX_CONVOLUTION_WIDTH +_m[0x851C] = (1,) # GL_MAX_CUBE_MAP_TEXTURE_SIZE +_m[0x851C] = (1,) # GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB +_m[0x82F9] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/cull_distance.txt # GL_MAX_CULL_DISTANCES +_m[0x826C] = (1,) # GL_MAX_DEBUG_GROUP_STACK_DEPTH +_m[0x9144] = (1,) # GL_MAX_DEBUG_LOGGED_MESSAGES +_m[0x9144] = (1,) # GL_MAX_DEBUG_LOGGED_MESSAGES_AMD +_m[0x9144] = (1,) # GL_MAX_DEBUG_LOGGED_MESSAGES_ARB +_m[0x9143] = (1,) # GL_MAX_DEBUG_MESSAGE_LENGTH +_m[0x9143] = (1,) # GL_MAX_DEBUG_MESSAGE_LENGTH_AMD +_m[0x9143] = (1,) # GL_MAX_DEBUG_MESSAGE_LENGTH_ARB +_m[0x90D1] = (1,) # GL_MAX_DEEP_3D_TEXTURE_DEPTH_NV +_m[0x90D0] = (2,) # GL_MAX_DEEP_3D_TEXTURE_WIDTH_HEIGHT_NV +_m[0x8280] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_MAX_DEPTH +_m[0x91B5] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/AMD/AMD_framebuffer_multisample_advanced.txt # GL_MAX_DEPTH_STENCIL_FRAMEBUFFER_SAMPLES_AMD +_m[0x910F] = (1,) # GL_MAX_DEPTH_TEXTURE_SAMPLES +_m[0x8824] = (1,) # GL_MAX_DRAW_BUFFERS +_m[0x8824] = (1,) # GL_MAX_DRAW_BUFFERS_ARB +_m[0x8824] = (1,) # GL_MAX_DRAW_BUFFERS_ATI +_m[0x953D] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_MAX_DRAW_MESH_TASKS_COUNT_NV +_m[0x88FC] = (1,) # GL_MAX_DUAL_SOURCE_DRAW_BUFFERS +_m[0x80E9] = (1,) # GL_MAX_ELEMENTS_INDICES +_m[0x80E8] = (1,) # GL_MAX_ELEMENTS_VERTICES +_m[0x8D6B] = (1,) # GL_MAX_ELEMENT_INDEX +_m[0x0D30] = (1,) # GL_MAX_EVAL_ORDER +_m[0x812C] = (1,) # GL_MAX_FOG_FUNC_POINTS_SGIS +_m[0x92D6] = (1,) # GL_MAX_FRAGMENT_ATOMIC_COUNTERS +_m[0x92D0] = (1,) # GL_MAX_FRAGMENT_ATOMIC_COUNTER_BUFFERS +_m[0x8DE3] = (1,) # GL_MAX_FRAGMENT_BINDABLE_UNIFORMS_EXT +_m[0x90CE] = (1,) # GL_MAX_FRAGMENT_IMAGE_UNIFORMS +_m[0x9125] = (1,) # GL_MAX_FRAGMENT_INPUT_COMPONENTS +_m[0x8E5C] = (1,) # GL_MAX_FRAGMENT_INTERPOLATION_OFFSET +_m[0x8E5C] = (1,) # GL_MAX_FRAGMENT_INTERPOLATION_OFFSET_NV +_m[0x8404] = (1,) # GL_MAX_FRAGMENT_LIGHTS_SGIX +_m[0x8868] = (1,) # GL_MAX_FRAGMENT_PROGRAM_LOCAL_PARAMETERS_NV +_m[0x90DA] = (1,) # GL_MAX_FRAGMENT_SHADER_STORAGE_BLOCKS +_m[0x8A2D] = (1,) # GL_MAX_FRAGMENT_UNIFORM_BLOCKS +_m[0x8B49] = (1,) # GL_MAX_FRAGMENT_UNIFORM_COMPONENTS +_m[0x8B49] = (1,) # GL_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB +_m[0x8DFD] = (1,) # GL_MAX_FRAGMENT_UNIFORM_VECTORS +_m[0x9316] = (1,) # GL_MAX_FRAMEBUFFER_HEIGHT +_m[0x9317] = (1,) # GL_MAX_FRAMEBUFFER_LAYERS +_m[0x9318] = (1,) # GL_MAX_FRAMEBUFFER_SAMPLES +_m[0x9315] = (1,) # GL_MAX_FRAMEBUFFER_WIDTH +_m[0x818D] = (1,) # GL_MAX_FRAMEZOOM_FACTOR_SGIX +_m[0x854D] = (1,) # GL_MAX_GENERAL_COMBINERS_NV +_m[0x92D5] = (1,) # GL_MAX_GEOMETRY_ATOMIC_COUNTERS +_m[0x92CF] = (1,) # GL_MAX_GEOMETRY_ATOMIC_COUNTER_BUFFERS +_m[0x8DE4] = (1,) # GL_MAX_GEOMETRY_BINDABLE_UNIFORMS_EXT +_m[0x90CD] = (1,) # GL_MAX_GEOMETRY_IMAGE_UNIFORMS +_m[0x9123] = (1,) # GL_MAX_GEOMETRY_INPUT_COMPONENTS +_m[0x9124] = (1,) # GL_MAX_GEOMETRY_OUTPUT_COMPONENTS +_m[0x8DE0] = (1,) # GL_MAX_GEOMETRY_OUTPUT_VERTICES +_m[0x8DE0] = (1,) # GL_MAX_GEOMETRY_OUTPUT_VERTICES_ARB +_m[0x8DE0] = (1,) # GL_MAX_GEOMETRY_OUTPUT_VERTICES_EXT +_m[0x8E5A] = (1,) # GL_MAX_GEOMETRY_PROGRAM_INVOCATIONS_NV +_m[0x8E5A] = (1,) # GL_MAX_GEOMETRY_SHADER_INVOCATIONS +_m[0x90D7] = (1,) # GL_MAX_GEOMETRY_SHADER_STORAGE_BLOCKS +_m[0x8C29] = (1,) # GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS +_m[0x8C29] = (1,) # GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_ARB +_m[0x8C29] = (1,) # GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_EXT +_m[0x8DE1] = (1,) # GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS +_m[0x8DE1] = (1,) # GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS_ARB +_m[0x8DE1] = (1,) # GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS_EXT +_m[0x8A2C] = (1,) # GL_MAX_GEOMETRY_UNIFORM_BLOCKS +_m[0x8DDF] = (1,) # GL_MAX_GEOMETRY_UNIFORM_COMPONENTS +_m[0x8DDF] = (1,) # GL_MAX_GEOMETRY_UNIFORM_COMPONENTS_ARB +_m[0x8DDF] = (1,) # GL_MAX_GEOMETRY_UNIFORM_COMPONENTS_EXT +_m[0x8DDD] = (1,) # GL_MAX_GEOMETRY_VARYING_COMPONENTS_ARB +_m[0x8DDD] = (1,) # GL_MAX_GEOMETRY_VARYING_COMPONENTS_EXT +_m[0x827F] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_MAX_HEIGHT +_m[0x906D] = (1,) # GL_MAX_IMAGE_SAMPLES +_m[0x906D] = (1,) # GL_MAX_IMAGE_SAMPLES_EXT +_m[0x8F38] = (1,) # GL_MAX_IMAGE_UNITS +_m[0x8F38] = (1,) # GL_MAX_IMAGE_UNITS_EXT +_m[0x9110] = (1,) # GL_MAX_INTEGER_SAMPLES +_m[0x82E8] = (1,) # GL_MAX_LABEL_LENGTH +_m[0x8281] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_MAX_LAYERS +_m[0x92BA] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NVX/NVX_linked_gpu_multicast.txt # GL_MAX_LGPU_GPUS_NVX +_m[0x0D31] = (1,) # GL_MAX_LIGHTS +_m[0x0B31] = (1,) # GL_MAX_LIST_NESTING +_m[0x86D6] = (1,) # GL_MAX_MAP_TESSELLATION_NV +_m[0x8841] = (1,) # GL_MAX_MATRIX_PALETTE_STACK_DEPTH_ARB +_m[0x8E65] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_MAX_MESH_ATOMIC_COUNTERS_NV +_m[0x8E64] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_MAX_MESH_ATOMIC_COUNTER_BUFFERS_NV +_m[0x8E62] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_MAX_MESH_IMAGE_UNIFORMS_NV +_m[0x9539] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_MAX_MESH_OUTPUT_PRIMITIVES_NV +_m[0x9538] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_MAX_MESH_OUTPUT_VERTICES_NV +_m[0x8E66] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_MAX_MESH_SHADER_STORAGE_BLOCKS_NV +_m[0x8E61] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_MAX_MESH_TEXTURE_IMAGE_UNITS_NV +_m[0x9536] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_MAX_MESH_TOTAL_MEMORY_SIZE_NV +_m[0x8E60] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_MAX_MESH_UNIFORM_BLOCKS_NV +_m[0x8E63] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_MAX_MESH_UNIFORM_COMPONENTS_NV +_m[0x9557] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_MAX_MESH_VIEWS_NV +_m[0x95A2] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_MAX_MESH_WORK_GROUP_INVOCATIONS_NV +_m[0x953B] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_MAX_MESH_WORK_GROUP_SIZE_NV +_m[0x0D36] = (1,) # GL_MAX_MODELVIEW_STACK_DEPTH +_m[0x8E11] = (1,) # GL_MAX_MULTISAMPLE_COVERAGE_MODES_NV +_m[0x92F6] = (1,) # GL_MAX_NAME_LENGTH +_m[0x0D37] = (1,) # GL_MAX_NAME_STACK_DEPTH +_m[0x92F7] = (1,) # GL_MAX_NUM_ACTIVE_VARIABLES +_m[0x92F8] = (1,) # GL_MAX_NUM_COMPATIBLE_SUBROUTINES +_m[0x87CA] = (1,) # GL_MAX_OPTIMIZED_VERTEX_SHADER_INSTRUCTIONS_EXT +_m[0x87CE] = (1,) # GL_MAX_OPTIMIZED_VERTEX_SHADER_LOCALS_EXT +_m[0x87CC] = (1,) # GL_MAX_OPTIMIZED_VERTEX_SHADER_LOCAL_CONSTANTS_EXT +_m[0x87CB] = (1,) # GL_MAX_OPTIMIZED_VERTEX_SHADER_VARIANTS_EXT +_m[0x8842] = (1,) # GL_MAX_PALETTE_MATRICES_ARB +_m[0x8842] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/OES/OES_matrix_palette.txt # GL_MAX_PALETTE_MATRICES_OES +_m[0x8E7D] = (1,) # GL_MAX_PATCH_VERTICES +_m[0x0D34] = (1,) # GL_MAX_PIXEL_MAP_TABLE +_m[0x8337] = (1,) # GL_MAX_PIXEL_TRANSFORM_2D_STACK_DEPTH_EXT +_m[0x87F1] = (1,) # GL_MAX_PN_TRIANGLES_TESSELATION_LEVEL_ATI +_m[0x88B1] = (1,) # GL_MAX_PROGRAM_ADDRESS_REGISTERS_ARB +_m[0x880B] = (1,) # GL_MAX_PROGRAM_ALU_INSTRUCTIONS_ARB +_m[0x88AD] = (1,) # GL_MAX_PROGRAM_ATTRIBS_ARB +_m[0x8908] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/gpu_program4.txt # GL_MAX_PROGRAM_ATTRIB_COMPONENTS_NV +_m[0x88F5] = (1,) # GL_MAX_PROGRAM_CALL_DEPTH_NV +_m[0x88B5] = (1,) # GL_MAX_PROGRAM_ENV_PARAMETERS_ARB +_m[0x88F4] = (1,) # GL_MAX_PROGRAM_EXEC_INSTRUCTIONS_NV +_m[0x8DA5] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/gpu_program4.txt # GL_MAX_PROGRAM_GENERIC_ATTRIBS_NV +_m[0x8DA6] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/gpu_program4.txt # GL_MAX_PROGRAM_GENERIC_RESULTS_NV +_m[0x88F6] = (1,) # GL_MAX_PROGRAM_IF_DEPTH_NV +_m[0x88A1] = (1,) # GL_MAX_PROGRAM_INSTRUCTIONS_ARB +_m[0x88B4] = (1,) # GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB +_m[0x88F8] = (1,) # GL_MAX_PROGRAM_LOOP_COUNT_NV +_m[0x88F7] = (1,) # GL_MAX_PROGRAM_LOOP_DEPTH_NV +_m[0x862F] = (1,) # GL_MAX_PROGRAM_MATRICES_ARB +_m[0x862E] = (1,) # GL_MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB +_m[0x88B3] = (1,) # GL_MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB +_m[0x880E] = (1,) # GL_MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB +_m[0x88AF] = (1,) # GL_MAX_PROGRAM_NATIVE_ATTRIBS_ARB +_m[0x88A3] = (1,) # GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB +_m[0x88AB] = (1,) # GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB +_m[0x88A7] = (1,) # GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB +_m[0x8810] = (1,) # GL_MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB +_m[0x880F] = (1,) # GL_MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB +_m[0x8C27] = (1,) # GL_MAX_PROGRAM_OUTPUT_VERTICES_NV +_m[0x88A9] = (1,) # GL_MAX_PROGRAM_PARAMETERS_ARB +_m[0x8DA0] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/parameter_buffer_object.txt # GL_MAX_PROGRAM_PARAMETER_BUFFER_BINDINGS_NV +_m[0x8DA1] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/parameter_buffer_object.txt # GL_MAX_PROGRAM_PARAMETER_BUFFER_SIZE_NV +_m[0x86D8] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/tessellation_program5.txt # GL_MAX_PROGRAM_PATCH_ATTRIBS_NV +_m[0x8909] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/gpu_program4.txt # GL_MAX_PROGRAM_RESULT_COMPONENTS_NV +_m[0x88A5] = (1,) # GL_MAX_PROGRAM_TEMPORARIES_ARB +_m[0x8905] = (1,) # GL_MAX_PROGRAM_TEXEL_OFFSET +_m[0x8F9F] = (1,) # GL_MAX_PROGRAM_TEXTURE_GATHER_COMPONENTS_ARB +_m[0x8E5F] = (1,) # GL_MAX_PROGRAM_TEXTURE_GATHER_OFFSET_ARB +_m[0x8E5F] = (1,) # GL_MAX_PROGRAM_TEXTURE_GATHER_OFFSET_NV +_m[0x880D] = (1,) # GL_MAX_PROGRAM_TEX_INDIRECTIONS_ARB +_m[0x880C] = (1,) # GL_MAX_PROGRAM_TEX_INSTRUCTIONS_ARB +_m[0x8C28] = (1,) # GL_MAX_PROGRAM_TOTAL_OUTPUT_COMPONENTS_NV +_m[0x0D38] = (1,) # GL_MAX_PROJECTION_STACK_DEPTH +_m[0x9329] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_framebuffer_mixed_samples.txt # GL_MAX_RASTER_SAMPLES_EXT +_m[0x86D7] = (1,) # GL_MAX_RATIONAL_EVAL_ORDER_NV +_m[0x84F8] = (1,) # GL_MAX_RECTANGLE_TEXTURE_SIZE +_m[0x84F8] = (1,) # GL_MAX_RECTANGLE_TEXTURE_SIZE_ARB +_m[0x84F8] = (1,) # GL_MAX_RECTANGLE_TEXTURE_SIZE_NV +_m[0x84E8] = (1,) # GL_MAX_RENDERBUFFER_SIZE +_m[0x84E8] = (1,) # GL_MAX_RENDERBUFFER_SIZE_EXT +_m[0x8D57] = (1,) # GL_MAX_SAMPLES +_m[0x8D57] = (1,) # GL_MAX_SAMPLES_EXT +_m[0x9135] = (1,) # GL_MAX_SAMPLES_IMG +_m[0x8E59] = (1,) # GL_MAX_SAMPLE_MASK_WORDS +_m[0x8E59] = (1,) # GL_MAX_SAMPLE_MASK_WORDS_NV +_m[0x9111] = (1,) # GL_MAX_SERVER_WAIT_TIMEOUT +_m[0x9650] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/EXT/EXT_shader_pixel_local_storage2.txt # GL_MAX_SHADER_COMBINED_LOCAL_STORAGE_FAST_SIZE_EXT +_m[0x9651] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/EXT/EXT_shader_pixel_local_storage2.txt # GL_MAX_SHADER_COMBINED_LOCAL_STORAGE_SIZE_EXT +_m[0x91B0] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/ARB/ARB_parallel_shader_compile.txt # GL_MAX_SHADER_COMPILER_THREADS_ARB +_m[0x91B0] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/KHR/KHR_parallel_shader_compile.txt # GL_MAX_SHADER_COMPILER_THREADS_KHR +_m[0x8F63] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/EXT/EXT_shader_pixel_local_storage.txt # GL_MAX_SHADER_PIXEL_LOCAL_STORAGE_FAST_SIZE_EXT +_m[0x8F67] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/EXT/EXT_shader_pixel_local_storage.txt # GL_MAX_SHADER_PIXEL_LOCAL_STORAGE_SIZE_EXT +_m[0x90DE] = (1,) # GL_MAX_SHADER_STORAGE_BLOCK_SIZE +_m[0x90DD] = (1,) # GL_MAX_SHADER_STORAGE_BUFFER_BINDINGS +_m[0x8FA1] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/QCOM/QCOM_texture_foveated_subsampled_layout.txt # GL_MAX_SHADER_SUBSAMPLED_IMAGE_UNITS_QCOM +_m[0x8504] = (1,) # GL_MAX_SHININESS_NV +_m[0x9199] = (1,)#TODO Review http://www.opengl.org/registry/specs//AMD/sparse_texture.txt # GL_MAX_SPARSE_3D_TEXTURE_SIZE_AMD +_m[0x9199] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/sparse_texture.txt # GL_MAX_SPARSE_3D_TEXTURE_SIZE_ARB +_m[0x9199] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/EXT/EXT_sparse_texture.txt # GL_MAX_SPARSE_3D_TEXTURE_SIZE_EXT +_m[0x919A] = (1,) # GL_MAX_SPARSE_ARRAY_TEXTURE_LAYERS +_m[0x9198] = (1,)#TODO Review http://www.opengl.org/registry/specs//AMD/sparse_texture.txt # GL_MAX_SPARSE_TEXTURE_SIZE_AMD +_m[0x9198] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/sparse_texture.txt # GL_MAX_SPARSE_TEXTURE_SIZE_ARB +_m[0x9198] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/EXT/EXT_sparse_texture.txt # GL_MAX_SPARSE_TEXTURE_SIZE_EXT +_m[0x8505] = (1,) # GL_MAX_SPOT_EXPONENT_NV +_m[0x9349] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_conservative_raster.txt # GL_MAX_SUBPIXEL_PRECISION_BIAS_BITS_NV +_m[0x8DE7] = (1,) # GL_MAX_SUBROUTINES +_m[0x8DE8] = (1,) # GL_MAX_SUBROUTINE_UNIFORM_LOCATIONS +_m[0x8E6D] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_MAX_TASK_ATOMIC_COUNTERS_NV +_m[0x8E6C] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_MAX_TASK_ATOMIC_COUNTER_BUFFERS_NV +_m[0x8E6A] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_MAX_TASK_IMAGE_UNIFORMS_NV +_m[0x953A] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_MAX_TASK_OUTPUT_COUNT_NV +_m[0x8E6E] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_MAX_TASK_SHADER_STORAGE_BLOCKS_NV +_m[0x8E69] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_MAX_TASK_TEXTURE_IMAGE_UNITS_NV +_m[0x9537] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_MAX_TASK_TOTAL_MEMORY_SIZE_NV +_m[0x8E68] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_MAX_TASK_UNIFORM_BLOCKS_NV +_m[0x8E6B] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_MAX_TASK_UNIFORM_COMPONENTS_NV +_m[0x95A3] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_MAX_TASK_WORK_GROUP_INVOCATIONS_NV +_m[0x953C] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_MAX_TASK_WORK_GROUP_SIZE_NV +_m[0x92D3] = (1,) # GL_MAX_TESS_CONTROL_ATOMIC_COUNTERS +_m[0x92CD] = (1,) # GL_MAX_TESS_CONTROL_ATOMIC_COUNTER_BUFFERS +_m[0x90CB] = (1,) # GL_MAX_TESS_CONTROL_IMAGE_UNIFORMS +_m[0x886C] = (1,) # GL_MAX_TESS_CONTROL_INPUT_COMPONENTS +_m[0x8E83] = (1,) # GL_MAX_TESS_CONTROL_OUTPUT_COMPONENTS +_m[0x90D8] = (1,) # GL_MAX_TESS_CONTROL_SHADER_STORAGE_BLOCKS +_m[0x8E81] = (1,) # GL_MAX_TESS_CONTROL_TEXTURE_IMAGE_UNITS +_m[0x8E85] = (1,) # GL_MAX_TESS_CONTROL_TOTAL_OUTPUT_COMPONENTS +_m[0x8E89] = (1,) # GL_MAX_TESS_CONTROL_UNIFORM_BLOCKS +_m[0x8E7F] = (1,) # GL_MAX_TESS_CONTROL_UNIFORM_COMPONENTS +_m[0x92D4] = (1,) # GL_MAX_TESS_EVALUATION_ATOMIC_COUNTERS +_m[0x92CE] = (1,) # GL_MAX_TESS_EVALUATION_ATOMIC_COUNTER_BUFFERS +_m[0x90CC] = (1,) # GL_MAX_TESS_EVALUATION_IMAGE_UNIFORMS +_m[0x886D] = (1,) # GL_MAX_TESS_EVALUATION_INPUT_COMPONENTS +_m[0x8E86] = (1,) # GL_MAX_TESS_EVALUATION_OUTPUT_COMPONENTS +_m[0x90D9] = (1,) # GL_MAX_TESS_EVALUATION_SHADER_STORAGE_BLOCKS +_m[0x8E82] = (1,) # GL_MAX_TESS_EVALUATION_TEXTURE_IMAGE_UNITS +_m[0x8E8A] = (1,) # GL_MAX_TESS_EVALUATION_UNIFORM_BLOCKS +_m[0x8E80] = (1,) # GL_MAX_TESS_EVALUATION_UNIFORM_COMPONENTS +_m[0x8E7E] = (1,) # GL_MAX_TESS_GEN_LEVEL +_m[0x8E84] = (1,) # GL_MAX_TESS_PATCH_COMPONENTS +_m[0x8C2B] = (1,) # GL_MAX_TEXTURE_BUFFER_SIZE +_m[0x8C2B] = (1,) # GL_MAX_TEXTURE_BUFFER_SIZE_ARB +_m[0x8C2B] = (1,) # GL_MAX_TEXTURE_BUFFER_SIZE_EXT +_m[0x8871] = (1,) # GL_MAX_TEXTURE_COORDS +_m[0x8871] = (1,) # GL_MAX_TEXTURE_COORDS_ARB +_m[0x8871] = (1,) # GL_MAX_TEXTURE_COORDS_NV +_m[0x8872] = (1,) # GL_MAX_TEXTURE_IMAGE_UNITS +_m[0x8872] = (1,) # GL_MAX_TEXTURE_IMAGE_UNITS_ARB +_m[0x8872] = (1,) # GL_MAX_TEXTURE_IMAGE_UNITS_NV +_m[0x84FD] = (1,) # GL_MAX_TEXTURE_LOD_BIAS +_m[0x84FD] = (1,) # GL_MAX_TEXTURE_LOD_BIAS_EXT +_m[0x84FF] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/ARB/ARB_texture_filter_anisotropic.txt # GL_MAX_TEXTURE_MAX_ANISOTROPY +_m[0x84FF] = (1,) # GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT +_m[0x0D33] = (1,) # GL_MAX_TEXTURE_SIZE +_m[0x0D39] = (1,) # GL_MAX_TEXTURE_STACK_DEPTH +_m[0x84E2] = (1,) # GL_MAX_TEXTURE_UNITS +_m[0x84E2] = (1,) # GL_MAX_TEXTURE_UNITS_ARB +_m[0x862F] = (1,) # GL_MAX_TRACK_MATRICES_NV +_m[0x862E] = (1,) # GL_MAX_TRACK_MATRIX_STACK_DEPTH_NV +_m[0x8E70] = (1,) # GL_MAX_TRANSFORM_FEEDBACK_BUFFERS +_m[0x8C8A] = (1,) # GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS +_m[0x8C8B] = (1,) # GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS +_m[0x8C80] = (1,) # GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS +_m[0x8A30] = (1,) # GL_MAX_UNIFORM_BLOCK_SIZE +_m[0x8A2F] = (1,) # GL_MAX_UNIFORM_BUFFER_BINDINGS +_m[0x826E] = (1,) # GL_MAX_UNIFORM_LOCATIONS +_m[0x8B4B] = (1,) # GL_MAX_VARYING_COMPONENTS +_m[0x8B4B] = (1,) # GL_MAX_VARYING_COMPONENTS_EXT +_m[0x8B4B] = (1,) # GL_MAX_VARYING_FLOATS +_m[0x8B4B] = (1,) # GL_MAX_VARYING_FLOATS_ARB +_m[0x8DFC] = (1,) # GL_MAX_VARYING_VECTORS +_m[0x8520] = (1,) # GL_MAX_VERTEX_ARRAY_RANGE_ELEMENT_NV +_m[0x92D2] = (1,) # GL_MAX_VERTEX_ATOMIC_COUNTERS +_m[0x92CC] = (1,) # GL_MAX_VERTEX_ATOMIC_COUNTER_BUFFERS +_m[0x8869] = (1,) # GL_MAX_VERTEX_ATTRIBS +_m[0x8869] = (1,) # GL_MAX_VERTEX_ATTRIBS_ARB +_m[0x82DA] = (1,) # GL_MAX_VERTEX_ATTRIB_BINDINGS +_m[0x82D9] = (1,) # GL_MAX_VERTEX_ATTRIB_RELATIVE_OFFSET +_m[0x8DE2] = (1,) # GL_MAX_VERTEX_BINDABLE_UNIFORMS_EXT +_m[0x90CA] = (1,) # GL_MAX_VERTEX_IMAGE_UNIFORMS +_m[0x9122] = (1,) # GL_MAX_VERTEX_OUTPUT_COMPONENTS +_m[0x87C5] = (1,) # GL_MAX_VERTEX_SHADER_INSTRUCTIONS_EXT +_m[0x87C7] = (1,) # GL_MAX_VERTEX_SHADER_INVARIANTS_EXT +_m[0x87C9] = (1,) # GL_MAX_VERTEX_SHADER_LOCALS_EXT +_m[0x87C8] = (1,) # GL_MAX_VERTEX_SHADER_LOCAL_CONSTANTS_EXT +_m[0x90D6] = (1,) # GL_MAX_VERTEX_SHADER_STORAGE_BLOCKS +_m[0x87C6] = (1,) # GL_MAX_VERTEX_SHADER_VARIANTS_EXT +_m[0x8E71] = (1,) # GL_MAX_VERTEX_STREAMS +_m[0x876B] = (1,) # GL_MAX_VERTEX_STREAMS_ATI +_m[0x8B4C] = (1,) # GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS +_m[0x8B4C] = (1,) # GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB +_m[0x8A2B] = (1,) # GL_MAX_VERTEX_UNIFORM_BLOCKS +_m[0x8B4A] = (1,) # GL_MAX_VERTEX_UNIFORM_COMPONENTS +_m[0x8B4A] = (1,) # GL_MAX_VERTEX_UNIFORM_COMPONENTS_ARB +_m[0x8DFB] = (1,) # GL_MAX_VERTEX_UNIFORM_VECTORS +_m[0x86A4] = (1,) # GL_MAX_VERTEX_UNITS_ARB +_m[0x86A4] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/OES/OES_matrix_palette.txt # GL_MAX_VERTEX_UNITS_OES +_m[0x8DDE] = (1,) # GL_MAX_VERTEX_VARYING_COMPONENTS_ARB +_m[0x8DDE] = (1,) # GL_MAX_VERTEX_VARYING_COMPONENTS_EXT +_m[0x825B] = (1,) # GL_MAX_VIEWPORTS +_m[0x0D3A] = (2,) # GL_MAX_VIEWPORT_DIMS +_m[0x9631] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/OVR/OVR_multiview.txt # GL_MAX_VIEWS_OVR +_m[0x827E] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_MAX_WIDTH +_m[0x8F14] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/EXT/EXT_window_rectangles.txt # GL_MAX_WINDOW_RECTANGLES_EXT +_m[0x9543] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_MESH_OUTPUT_PER_PRIMITIVE_GRANULARITY_NV +_m[0x92DF] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_MESH_OUTPUT_PER_VERTEX_GRANULARITY_NV +_m[0x957B] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_MESH_OUTPUT_TYPE_NV +_m[0x957A] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_MESH_PRIMITIVES_OUT_NV +_m[0x9579] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_MESH_VERTICES_OUT_NV +_m[0x953E] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_MESH_WORK_GROUP_SIZE_NV +_m[0x802E] = (1,) # GL_MINMAX +_m[0x802E] = (1,) # GL_MINMAX_EXT +_m[0x802F] = (1,) # GL_MINMAX_FORMAT +_m[0x802F] = (1,) # GL_MINMAX_FORMAT_EXT +_m[0x8030] = (1,) # GL_MINMAX_SINK +_m[0x8030] = (1,) # GL_MINMAX_SINK_EXT +_m[0x821C] = (1,) # GL_MINOR_VERSION +_m[0x8E5B] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/gpu_shader5.txt # GL_MIN_FRAGMENT_INTERPOLATION_OFFSET +_m[0x8E5B] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/gpu_program5.txt # GL_MIN_FRAGMENT_INTERPOLATION_OFFSET_NV +_m[0x90BC] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/map_buffer_alignment.txt # GL_MIN_MAP_BUFFER_ALIGNMENT +_m[0x8904] = (1,) # GL_MIN_PROGRAM_TEXEL_OFFSET +_m[0x8E5E] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/texture_gather.txt # GL_MIN_PROGRAM_TEXTURE_GATHER_OFFSET_ARB +_m[0x8E5E] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/gpu_program5.txt # GL_MIN_PROGRAM_TEXTURE_GATHER_OFFSET_NV +_m[0x8C37] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/sample_shading.txt # GL_MIN_SAMPLE_SHADING_VALUE_ARB +_m[0x8C37] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/OES/OES_sample_shading.txt # GL_MIN_SAMPLE_SHADING_VALUE_OES +_m[0x919B] = (1,)#TODO Review http://www.opengl.org/registry/specs//AMD/sparse_texture.txt # GL_MIN_SPARSE_LEVEL_AMD +_m[0x8293] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_MIPMAP +_m[0x932F] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_framebuffer_mixed_samples.txt # GL_MIXED_DEPTH_SAMPLES_SUPPORTED_NV +_m[0x9330] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_framebuffer_mixed_samples.txt # GL_MIXED_STENCIL_SAMPLES_SUPPORTED_NV +_m[0x0BA6] = (4,4) # GL_MODELVIEW0_MATRIX_EXT +_m[0x0BA3] = (1,) # GL_MODELVIEW0_STACK_DEPTH_EXT +_m[0x872A] = (4,4) # GL_MODELVIEW10_ARB +_m[0x872B] = (4,4) # GL_MODELVIEW11_ARB +_m[0x872C] = (4,4) # GL_MODELVIEW12_ARB +_m[0x872D] = (4,4) # GL_MODELVIEW13_ARB +_m[0x872E] = (4,4) # GL_MODELVIEW14_ARB +_m[0x872F] = (4,4) # GL_MODELVIEW15_ARB +_m[0x8730] = (4,4) # GL_MODELVIEW16_ARB +_m[0x8731] = (4,4) # GL_MODELVIEW17_ARB +_m[0x8732] = (4,4) # GL_MODELVIEW18_ARB +_m[0x8733] = (4,4) # GL_MODELVIEW19_ARB +_m[0x850A] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/vertex_blend.txt # GL_MODELVIEW1_ARB +_m[0x8506] = (4,4) # GL_MODELVIEW1_MATRIX_EXT +_m[0x8502] = (1,) # GL_MODELVIEW1_STACK_DEPTH_EXT +_m[0x8734] = (4,4) # GL_MODELVIEW20_ARB +_m[0x8735] = (4,4) # GL_MODELVIEW21_ARB +_m[0x8736] = (4,4) # GL_MODELVIEW22_ARB +_m[0x8737] = (4,4) # GL_MODELVIEW23_ARB +_m[0x8738] = (4,4) # GL_MODELVIEW24_ARB +_m[0x8739] = (4,4) # GL_MODELVIEW25_ARB +_m[0x873A] = (4,4) # GL_MODELVIEW26_ARB +_m[0x873B] = (4,4) # GL_MODELVIEW27_ARB +_m[0x873C] = (4,4) # GL_MODELVIEW28_ARB +_m[0x873D] = (4,4) # GL_MODELVIEW29_ARB +_m[0x8722] = (4,4) # GL_MODELVIEW2_ARB +_m[0x873E] = (4,4) # GL_MODELVIEW30_ARB +_m[0x873F] = (4,4) # GL_MODELVIEW31_ARB +_m[0x8723] = (4,4) # GL_MODELVIEW3_ARB +_m[0x8724] = (4,4) # GL_MODELVIEW4_ARB +_m[0x8725] = (4,4) # GL_MODELVIEW5_ARB +_m[0x8726] = (4,4) # GL_MODELVIEW6_ARB +_m[0x8727] = (4,4) # GL_MODELVIEW7_ARB +_m[0x8728] = (4,4) # GL_MODELVIEW8_ARB +_m[0x8729] = (4,4) # GL_MODELVIEW9_ARB +_m[0x0BA6] = (4, 4) # GL_MODELVIEW_MATRIX +_m[0x898D] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/OES/OES_matrix_get.txt # GL_MODELVIEW_MATRIX_FLOAT_AS_INT_BITS_OES +_m[0x0BA3] = (1,) # GL_MODELVIEW_STACK_DEPTH +_m[0x92BA] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_gpu_multicast.txt # GL_MULTICAST_GPUS_NV +_m[0x9549] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_gpu_multicast.txt # GL_MULTICAST_PROGRAMMABLE_SAMPLE_LOCATION_NV +_m[0x809D] = (1,) # GL_MULTISAMPLE +_m[0x9371] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_internalformat_sample_query.txt # GL_MULTISAMPLES_NV +_m[0x86B2] = (1,) # GL_MULTISAMPLE_3DFX +_m[0x809D] = (1,) # GL_MULTISAMPLE_ARB +_m[0x8E12] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/framebuffer_multisample_coverage.txt # GL_MULTISAMPLE_COVERAGE_MODES_NV +_m[0x809D] = (1,) # GL_MULTISAMPLE_EXT +_m[0x8534] = (1,) # GL_MULTISAMPLE_FILTER_HINT_NV +_m[0x9382] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/ARB/ARB_ES3_2_compatibility.txt # GL_MULTISAMPLE_LINE_WIDTH_GRANULARITY_ARB +_m[0x9381] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/ARB/ARB_ES3_2_compatibility.txt # GL_MULTISAMPLE_LINE_WIDTH_RANGE_ARB +_m[0x932B] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_framebuffer_mixed_samples.txt # GL_MULTISAMPLE_RASTERIZATION_ALLOWED_EXT +_m[0x809D] = (1,) # GL_MULTISAMPLE_SGIS +_m[0x8DE9] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/shading_language_include.txt # GL_NAMED_STRING_LENGTH_ARB +_m[0x8DEA] = (1,) # GL_NAMED_STRING_TYPE_ARB +_m[0x92F9] = (1,) # GL_NAME_LENGTH +_m[0x0D70] = (1,) # GL_NAME_STACK_DEPTH +_m[0x9025] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/video_capture.txt # GL_NEXT_VIDEO_CAPTURE_BUFFER_STATUS_NV +_m[0x0BA1] = (1,) # GL_NORMALIZE +_m[0x8075] = (1,) # GL_NORMAL_ARRAY +_m[0x8897] = (1,) # GL_NORMAL_ARRAY_BUFFER_BINDING +_m[0x8897] = (1,) # GL_NORMAL_ARRAY_BUFFER_BINDING_ARB +_m[0x8080] = (1,) # GL_NORMAL_ARRAY_COUNT_EXT +_m[0x8075] = (1,) # GL_NORMAL_ARRAY_EXT +_m[0x8F2C] = (1,) # GL_NORMAL_ARRAY_LENGTH_NV +_m[0x83F6] = (1,)#TODO Review http://www.opengl.org/registry/specs//INTEL/parallel_arrays.txt # GL_NORMAL_ARRAY_PARALLEL_POINTERS_INTEL +_m[0x808F] = (1,) # GL_NORMAL_ARRAY_POINTER +_m[0x807F] = (1,) # GL_NORMAL_ARRAY_STRIDE +_m[0x807F] = (1,) # GL_NORMAL_ARRAY_STRIDE_EXT +_m[0x807E] = (1,) # GL_NORMAL_ARRAY_TYPE +_m[0x807E] = (1,) # GL_NORMAL_ARRAY_TYPE_EXT +_m[0x8261] = (1,)#TODO Review http://www.opengl.org/registry/specs//KHR/robustness.txt # GL_NO_RESET_NOTIFICATION +_m[0x8261] = (1,) # GL_NO_RESET_NOTIFICATION_ARB +_m[0x9304] = (1,) # GL_NUM_ACTIVE_VARIABLES +_m[0x8E4A] = (1,) # GL_NUM_COMPATIBLE_SUBROUTINES +_m[0x86A2] = (1,) # GL_NUM_COMPRESSED_TEXTURE_FORMATS +_m[0x86A2] = (1,) # GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB +_m[0x913D] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/IMG/IMG_framebuffer_downsample.txt # GL_NUM_DOWNSAMPLE_SCALES_IMG +_m[0x821D] = (1,) # GL_NUM_EXTENSIONS +_m[0x8E29] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/present_video.txt # GL_NUM_FILL_STREAMS_NV +_m[0x896F] = (1,) # GL_NUM_FRAGMENT_CONSTANTS_ATI +_m[0x896E] = (1,) # GL_NUM_FRAGMENT_REGISTERS_ATI +_m[0x854E] = (1,) # GL_NUM_GENERAL_COMBINERS_NV +_m[0x8973] = (1,) # GL_NUM_INPUT_INTERPOLATOR_COMPONENTS_ATI +_m[0x8971] = (1,) # GL_NUM_INSTRUCTIONS_PER_PASS_ATI +_m[0x8972] = (1,) # GL_NUM_INSTRUCTIONS_TOTAL_ATI +_m[0x8974] = (1,) # GL_NUM_LOOPBACK_COMPONENTS_ATI +_m[0x8970] = (1,) # GL_NUM_PASSES_ATI +_m[0x87FE] = (1,) # GL_NUM_PROGRAM_BINARY_FORMATS +_m[0x9380] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query.txt # GL_NUM_SAMPLE_COUNTS +_m[0x8DF9] = (1,) # GL_NUM_SHADER_BINARY_FORMATS +_m[0x91AA] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/sparse_texture.txt # GL_NUM_SPARSE_LEVELS_ARB +_m[0x91AA] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/EXT/EXT_sparse_texture.txt # GL_NUM_SPARSE_LEVELS_EXT +_m[0x9554] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/ARB/ARB_spirv_extensions.txt # GL_NUM_SPIR_V_EXTENSIONS +_m[0x91B6] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/AMD/AMD_framebuffer_multisample_advanced.txt # GL_NUM_SUPPORTED_MULTISAMPLE_MODES_AMD +_m[0x9024] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/video_capture.txt # GL_NUM_VIDEO_CAPTURE_STREAMS_NV +_m[0x8F15] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/EXT/EXT_window_rectangles.txt # GL_NUM_WINDOW_RECTANGLES_EXT +_m[0x8B86] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/shader_objects.txt # GL_OBJECT_ACTIVE_UNIFORMS_ARB +_m[0x8B87] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/shader_objects.txt # GL_OBJECT_ACTIVE_UNIFORM_MAX_LENGTH_ARB +_m[0x8B85] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/shader_objects.txt # GL_OBJECT_ATTACHED_OBJECTS_ARB +_m[0x8764] = (1,) # GL_OBJECT_BUFFER_SIZE_ATI +_m[0x8765] = (4,) # GL_OBJECT_BUFFER_USAGE_ATI +_m[0x8B81] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/shader_objects.txt # GL_OBJECT_COMPILE_STATUS_ARB +_m[0x8B80] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/shader_objects.txt # GL_OBJECT_DELETE_STATUS_ARB +_m[0x8B84] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/shader_objects.txt # GL_OBJECT_INFO_LOG_LENGTH_ARB +_m[0x81F7] = (7,) # GL_OBJECT_LINE_SGIS +_m[0x8B82] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/shader_objects.txt # GL_OBJECT_LINK_STATUS_ARB +_m[0x2501] = (4,) # GL_OBJECT_PLANE +_m[0x81F5] = (4,) # GL_OBJECT_POINT_SGIS +_m[0x8B88] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/shader_objects.txt # GL_OBJECT_SHADER_SOURCE_LENGTH_ARB +_m[0x8B4F] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/shader_objects.txt # GL_OBJECT_SUBTYPE_ARB +_m[0x9112] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/sync.txt # GL_OBJECT_TYPE +_m[0x8B4E] = (1,) # GL_OBJECT_TYPE_ARB +_m[0x8B83] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/shader_objects.txt # GL_OBJECT_VALIDATE_STATUS_ARB +_m[0x8165] = (1,) # GL_OCCLUSION_TEST_HP +_m[0x8166] = (1,) # GL_OCCLUSION_TEST_RESULT_HP +_m[0x92FC] = (1,) # GL_OFFSET +_m[0x86E3] = (1,) # GL_OFFSET_TEXTURE_BIAS_NV +_m[0x86E1] = (4,) # GL_OFFSET_TEXTURE_MATRIX_NV +_m[0x86E2] = (1,) # GL_OFFSET_TEXTURE_SCALE_NV +_m[0x8598] = (1,) # GL_OPERAND0_ALPHA +_m[0x8590] = (1,) # GL_OPERAND0_RGB +_m[0x8599] = (1,) # GL_OPERAND1_ALPHA +_m[0x8591] = (1,) # GL_OPERAND1_RGB +_m[0x859A] = (1,) # GL_OPERAND2_ALPHA +_m[0x8592] = (1,) # GL_OPERAND2_RGB +_m[0x859B] = (1,) # GL_OPERAND3_ALPHA_NV +_m[0x8593] = (1,) # GL_OPERAND3_RGB_NV +_m[0x0D05] = (1,) # GL_PACK_ALIGNMENT +_m[0x800E] = (1,) # GL_PACK_CMYK_HINT_EXT +_m[0x912D] = (1,) # GL_PACK_COMPRESSED_BLOCK_DEPTH +_m[0x912C] = (1,) # GL_PACK_COMPRESSED_BLOCK_HEIGHT +_m[0x912E] = (1,) # GL_PACK_COMPRESSED_BLOCK_SIZE +_m[0x912B] = (1,) # GL_PACK_COMPRESSED_BLOCK_WIDTH +_m[0x8131] = (1,) # GL_PACK_IMAGE_DEPTH_SGIS +_m[0x806C] = (1,) # GL_PACK_IMAGE_HEIGHT +_m[0x806C] = (1,) # GL_PACK_IMAGE_HEIGHT_EXT +_m[0x8758] = (1,) # GL_PACK_INVERT_MESA +_m[0x0D01] = (1,) # GL_PACK_LSB_FIRST +_m[0x8984] = (1,) # GL_PACK_RESAMPLE_OML +_m[0x842E] = (1,) # GL_PACK_RESAMPLE_SGIX +_m[0x93A4] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/ANGLE/ANGLE_pack_reverse_row_order.txt # GL_PACK_REVERSE_ROW_ORDER_ANGLE +_m[0x8A15] = (1,) # GL_PACK_ROW_BYTES_APPLE +_m[0x0D02] = (1,) # GL_PACK_ROW_LENGTH +_m[0x806B] = (1,) # GL_PACK_SKIP_IMAGES +_m[0x806B] = (1,) # GL_PACK_SKIP_IMAGES_EXT +_m[0x0D04] = (1,) # GL_PACK_SKIP_PIXELS +_m[0x0D03] = (1,) # GL_PACK_SKIP_ROWS +_m[0x8130] = (1,) # GL_PACK_SKIP_VOLUMES_SGIS +_m[0x0D00] = (1,) # GL_PACK_SWAP_BYTES +_m[0x83F4] = (1,) # GL_PARALLEL_ARRAYS_INTEL +_m[0x80EF] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/indirect_parameters.txt # GL_PARAMETER_BUFFER_BINDING_ARB +_m[0x8E73] = (1,) # GL_PATCH_DEFAULT_INNER_LEVEL +_m[0x8E74] = (1,) # GL_PATCH_DEFAULT_OUTER_LEVEL +_m[0x8E72] = (1,) # GL_PATCH_VERTICES +_m[0x909D] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/path_rendering.txt # GL_PATH_COMMAND_COUNT_NV +_m[0x90A0] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/path_rendering.txt # GL_PATH_COMPUTED_LENGTH_NV +_m[0x909E] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/path_rendering.txt # GL_PATH_COORD_COUNT_NV +_m[0x90BF] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/path_rendering.txt # GL_PATH_COVER_DEPTH_FUNC_NV +_m[0x909F] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/path_rendering.txt # GL_PATH_DASH_ARRAY_COUNT_NV +_m[0x90AB] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/path_rendering.txt # GL_PATH_ERROR_POSITION_NV +_m[0x90A1] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/path_rendering.txt # GL_PATH_FILL_BOUNDING_BOX_NV +_m[0x90AC] = (1,) # GL_PATH_FOG_GEN_MODE_NV +_m[0x90B1] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/path_rendering.txt # GL_PATH_GEN_COEFF_NV +_m[0x90B2] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/path_rendering.txt # GL_PATH_GEN_COLOR_FORMAT_NV +_m[0x90B3] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/path_rendering.txt # GL_PATH_GEN_COMPONENTS_NV +_m[0x90B0] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/path_rendering.txt # GL_PATH_GEN_MODE_NV +_m[0x90BD] = (1,) # GL_PATH_STENCIL_DEPTH_OFFSET_FACTOR_NV +_m[0x90BE] = (1,) # GL_PATH_STENCIL_DEPTH_OFFSET_UNITS_NV +_m[0x90B7] = (1,) # GL_PATH_STENCIL_FUNC_NV +_m[0x90B8] = (1,) # GL_PATH_STENCIL_REF_NV +_m[0x90B9] = (1,) # GL_PATH_STENCIL_VALUE_MASK_NV +_m[0x90A2] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/path_rendering.txt # GL_PATH_STROKE_BOUNDING_BOX_NV +_m[0x8BC6] = (1,)#TODO Review http://www.opengl.org/registry/specs//AMD/performance_monitor.txt # GL_PERFMON_RESULT_AMD +_m[0x8BC4] = (1,)#TODO Review http://www.opengl.org/registry/specs//AMD/performance_monitor.txt # GL_PERFMON_RESULT_AVAILABLE_AMD +_m[0x8BC5] = (1,)#TODO Review http://www.opengl.org/registry/specs//AMD/performance_monitor.txt # GL_PERFMON_RESULT_SIZE_AMD +_m[0x94FF] = (1,)#TODO Review http://www.opengl.org/registry/specs//INTEL/performance_query.txt # GL_PERFQUERY_COUNTER_DESC_LENGTH_MAX_INTEL +_m[0x94FE] = (1,)#TODO Review http://www.opengl.org/registry/specs//INTEL/performance_query.txt # GL_PERFQUERY_COUNTER_NAME_LENGTH_MAX_INTEL +_m[0x9500] = (1,)#TODO Review http://www.opengl.org/registry/specs//INTEL/performance_query.txt # GL_PERFQUERY_GPA_EXTENDED_COUNTERS_INTEL +_m[0x94FD] = (1,)#TODO Review http://www.opengl.org/registry/specs//INTEL/performance_query.txt # GL_PERFQUERY_QUERY_NAME_LENGTH_MAX_INTEL +_m[0x0C50] = (1,) # GL_PERSPECTIVE_CORRECTION_HINT +_m[0x8535] = (1,) # GL_PER_STAGE_CONSTANTS_NV +_m[0x91AE] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/AMD/AMD_framebuffer_sample_positions.txt # GL_PIXELS_PER_SAMPLE_PATTERN_X_AMD +_m[0x91AF] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/AMD/AMD_framebuffer_sample_positions.txt # GL_PIXELS_PER_SAMPLE_PATTERN_Y_AMD +_m[0x8864] = (1,) # GL_PIXEL_COUNTER_BITS_NV +_m[0x8867] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/occlusion_query.txt # GL_PIXEL_COUNT_AVAILABLE_NV +_m[0x8866] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/occlusion_query.txt # GL_PIXEL_COUNT_NV +_m[0x8355] = (1,) # GL_PIXEL_FRAGMENT_ALPHA_SOURCE_SGIS +_m[0x8354] = (1,) # GL_PIXEL_FRAGMENT_RGB_SOURCE_SGIS +_m[0x8356] = (1,) # GL_PIXEL_GROUP_COLOR_SGIS +_m[0x0C79] = (_L(0xCB9),) # GL_PIXEL_MAP_A_TO_A +_m[0x0CB9] = (1,) # GL_PIXEL_MAP_A_TO_A_SIZE +_m[0x0C78] = (_L(0xCB8),) # GL_PIXEL_MAP_B_TO_B +_m[0x0CB8] = (1,) # GL_PIXEL_MAP_B_TO_B_SIZE +_m[0x0C77] = (_L(0xCB7),) # GL_PIXEL_MAP_G_TO_G +_m[0x0CB7] = (1,) # GL_PIXEL_MAP_G_TO_G_SIZE +_m[0x0C75] = (_L(0xCB5),) # GL_PIXEL_MAP_I_TO_A +_m[0x0CB5] = (1,) # GL_PIXEL_MAP_I_TO_A_SIZE +_m[0x0C74] = (_L(0xCB4),) # GL_PIXEL_MAP_I_TO_B +_m[0x0CB4] = (1,) # GL_PIXEL_MAP_I_TO_B_SIZE +_m[0x0C73] = (_L(0xCB3),) # GL_PIXEL_MAP_I_TO_G +_m[0x0CB3] = (1,) # GL_PIXEL_MAP_I_TO_G_SIZE +_m[0x0C70] = (_L(0xCB0),) # GL_PIXEL_MAP_I_TO_I +_m[0x0CB0] = (1,) # GL_PIXEL_MAP_I_TO_I_SIZE +_m[0x0C72] = (_L(0xCB2),) # GL_PIXEL_MAP_I_TO_R +_m[0x0CB2] = (1,) # GL_PIXEL_MAP_I_TO_R_SIZE +_m[0x0C76] = (_L(0xCB6),) # GL_PIXEL_MAP_R_TO_R +_m[0x0CB6] = (1,) # GL_PIXEL_MAP_R_TO_R_SIZE +_m[0x0C71] = (_L(0xCB1),) # GL_PIXEL_MAP_S_TO_S +_m[0x0CB1] = (1,) # GL_PIXEL_MAP_S_TO_S_SIZE +_m[0x88ED] = (1,) # GL_PIXEL_PACK_BUFFER_BINDING +_m[0x88ED] = (1,) # GL_PIXEL_PACK_BUFFER_BINDING_ARB +_m[0x88ED] = (1,) # GL_PIXEL_PACK_BUFFER_BINDING_EXT +_m[0x8353] = (1,) # GL_PIXEL_TEXTURE_SGIS +_m[0x832B] = (1,) # GL_PIXEL_TEX_GEN_MODE_SGIX +_m[0x8139] = (1,) # GL_PIXEL_TEX_GEN_SGIX +_m[0x813E] = (1,) # GL_PIXEL_TILE_BEST_ALIGNMENT_SGIX +_m[0x813F] = (1,) # GL_PIXEL_TILE_CACHE_INCREMENT_SGIX +_m[0x8145] = (1,) # GL_PIXEL_TILE_CACHE_SIZE_SGIX +_m[0x8144] = (1,) # GL_PIXEL_TILE_GRID_DEPTH_SGIX +_m[0x8143] = (1,) # GL_PIXEL_TILE_GRID_HEIGHT_SGIX +_m[0x8142] = (1,) # GL_PIXEL_TILE_GRID_WIDTH_SGIX +_m[0x8141] = (1,) # GL_PIXEL_TILE_HEIGHT_SGIX +_m[0x8140] = (1,) # GL_PIXEL_TILE_WIDTH_SGIX +_m[0x8338] = (1,)#TODO Review http://www.opengl.org/registry/specs//EXT/pixel_transform.txt # GL_PIXEL_TRANSFORM_2D_MATRIX_EXT +_m[0x8336] = (1,) # GL_PIXEL_TRANSFORM_2D_STACK_DEPTH_EXT +_m[0x88EF] = (1,) # GL_PIXEL_UNPACK_BUFFER_BINDING +_m[0x88EF] = (1,) # GL_PIXEL_UNPACK_BUFFER_BINDING_ARB +_m[0x88EF] = (1,) # GL_PIXEL_UNPACK_BUFFER_BINDING_EXT +_m[0x87F3] = (1,) # GL_PN_TRIANGLES_NORMAL_MODE_ATI +_m[0x87F2] = (1,) # GL_PN_TRIANGLES_POINT_MODE_ATI +_m[0x87F4] = (1,) # GL_PN_TRIANGLES_TESSELATION_LEVEL_ATI +_m[0x8129] = (3,) # GL_POINT_DISTANCE_ATTENUATION +_m[0x8129] = (3,) # GL_POINT_DISTANCE_ATTENUATION_ARB +_m[0x8128] = (1,) # GL_POINT_FADE_THRESHOLD_SIZE +_m[0x8128] = (1,) # GL_POINT_FADE_THRESHOLD_SIZE_ARB +_m[0x8128] = (1,) # GL_POINT_FADE_THRESHOLD_SIZE_SGIS +_m[0x1B00] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_polygon_mode.txt # GL_POINT_NV +_m[0x0B11] = (1,) # GL_POINT_SIZE +_m[0x8B9F] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/OES/OES_point_size_array.txt # GL_POINT_SIZE_ARRAY_BUFFER_BINDING_OES +_m[0x898C] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/OES/OES_point_size_array.txt # GL_POINT_SIZE_ARRAY_POINTER_OES +_m[0x898B] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/OES/OES_point_size_array.txt # GL_POINT_SIZE_ARRAY_STRIDE_OES +_m[0x898A] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/OES/OES_point_size_array.txt # GL_POINT_SIZE_ARRAY_TYPE_OES +_m[0x0B13] = (1,) # GL_POINT_SIZE_GRANULARITY +_m[0x8127] = (1,) # GL_POINT_SIZE_MAX +_m[0x8127] = (1,) # GL_POINT_SIZE_MAX_ARB +_m[0x8127] = (1,) # GL_POINT_SIZE_MAX_SGIS +_m[0x8126] = (1,) # GL_POINT_SIZE_MIN +_m[0x8126] = (1,) # GL_POINT_SIZE_MIN_ARB +_m[0x8126] = (1,) # GL_POINT_SIZE_MIN_SGIS +_m[0x0B12] = (2,) # GL_POINT_SIZE_RANGE +_m[0x0B10] = (1,) # GL_POINT_SMOOTH +_m[0x0C51] = (1,) # GL_POINT_SMOOTH_HINT +_m[0x8861] = (1,) # GL_POINT_SPRITE +_m[0x8861] = (1,) # GL_POINT_SPRITE_ARB +_m[0x8CA0] = (1,) # GL_POINT_SPRITE_COORD_ORIGIN +_m[0x8861] = (1,) # GL_POINT_SPRITE_NV +_m[0x8863] = (1,) # GL_POINT_SPRITE_R_MODE_NV +_m[0x0B40] = (2,) # GL_POLYGON_MODE +_m[0x8039] = (1,) # GL_POLYGON_OFFSET_BIAS_EXT +_m[0x8E1B] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/ARB/ARB_polygon_offset_clamp.txt # GL_POLYGON_OFFSET_CLAMP +_m[0x8E1B] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/EXT/EXT_polygon_offset_clamp.txt # GL_POLYGON_OFFSET_CLAMP_EXT +_m[0x8037] = (1,) # GL_POLYGON_OFFSET_EXT +_m[0x8038] = (1,) # GL_POLYGON_OFFSET_FACTOR +_m[0x8038] = (1,) # GL_POLYGON_OFFSET_FACTOR_EXT +_m[0x8037] = (1,) # GL_POLYGON_OFFSET_FILL +_m[0x2A02] = (1,) # GL_POLYGON_OFFSET_LINE +_m[0x2A01] = (1,) # GL_POLYGON_OFFSET_POINT +_m[0x2A00] = (1,) # GL_POLYGON_OFFSET_UNITS +_m[0x0B41] = (1,) # GL_POLYGON_SMOOTH +_m[0x0C53] = (1,) # GL_POLYGON_SMOOTH_HINT +_m[0x0B42] = (1,) # GL_POLYGON_STIPPLE +_m[0x1203] = (4,) # GL_POSITION +_m[0x80BB] = (1,) # GL_POST_COLOR_MATRIX_ALPHA_BIAS +_m[0x80BB] = (1,) # GL_POST_COLOR_MATRIX_ALPHA_BIAS_SGI +_m[0x80B7] = (1,) # GL_POST_COLOR_MATRIX_ALPHA_SCALE +_m[0x80B7] = (1,) # GL_POST_COLOR_MATRIX_ALPHA_SCALE_SGI +_m[0x80BA] = (1,) # GL_POST_COLOR_MATRIX_BLUE_BIAS +_m[0x80BA] = (1,) # GL_POST_COLOR_MATRIX_BLUE_BIAS_SGI +_m[0x80B6] = (1,) # GL_POST_COLOR_MATRIX_BLUE_SCALE +_m[0x80B6] = (1,) # GL_POST_COLOR_MATRIX_BLUE_SCALE_SGI +_m[0x80D2] = (1,) # GL_POST_COLOR_MATRIX_COLOR_TABLE +_m[0x80D2] = (1,) # GL_POST_COLOR_MATRIX_COLOR_TABLE_SGI +_m[0x80B9] = (1,) # GL_POST_COLOR_MATRIX_GREEN_BIAS +_m[0x80B9] = (1,) # GL_POST_COLOR_MATRIX_GREEN_BIAS_SGI +_m[0x80B5] = (1,) # GL_POST_COLOR_MATRIX_GREEN_SCALE +_m[0x80B5] = (1,) # GL_POST_COLOR_MATRIX_GREEN_SCALE_SGI +_m[0x80B8] = (1,) # GL_POST_COLOR_MATRIX_RED_BIAS +_m[0x80B8] = (1,) # GL_POST_COLOR_MATRIX_RED_BIAS_SGI +_m[0x80B4] = (1,) # GL_POST_COLOR_MATRIX_RED_SCALE +_m[0x80B4] = (1,) # GL_POST_COLOR_MATRIX_RED_SCALE_SGI +_m[0x8023] = (1,) # GL_POST_CONVOLUTION_ALPHA_BIAS +_m[0x8023] = (1,) # GL_POST_CONVOLUTION_ALPHA_BIAS_EXT +_m[0x801F] = (1,) # GL_POST_CONVOLUTION_ALPHA_SCALE +_m[0x801F] = (1,) # GL_POST_CONVOLUTION_ALPHA_SCALE_EXT +_m[0x8022] = (1,) # GL_POST_CONVOLUTION_BLUE_BIAS +_m[0x8022] = (1,) # GL_POST_CONVOLUTION_BLUE_BIAS_EXT +_m[0x801E] = (1,) # GL_POST_CONVOLUTION_BLUE_SCALE +_m[0x801E] = (1,) # GL_POST_CONVOLUTION_BLUE_SCALE_EXT +_m[0x80D1] = (1,) # GL_POST_CONVOLUTION_COLOR_TABLE +_m[0x80D1] = (1,) # GL_POST_CONVOLUTION_COLOR_TABLE_SGI +_m[0x8021] = (1,) # GL_POST_CONVOLUTION_GREEN_BIAS +_m[0x8021] = (1,) # GL_POST_CONVOLUTION_GREEN_BIAS_EXT +_m[0x801D] = (1,) # GL_POST_CONVOLUTION_GREEN_SCALE +_m[0x801D] = (1,) # GL_POST_CONVOLUTION_GREEN_SCALE_EXT +_m[0x8020] = (1,) # GL_POST_CONVOLUTION_RED_BIAS +_m[0x8020] = (1,) # GL_POST_CONVOLUTION_RED_BIAS_EXT +_m[0x801C] = (1,) # GL_POST_CONVOLUTION_RED_SCALE +_m[0x801C] = (1,) # GL_POST_CONVOLUTION_RED_SCALE_EXT +_m[0x817B] = (1,) # GL_POST_TEXTURE_FILTER_BIAS_RANGE_SGIX +_m[0x8179] = (1,) # GL_POST_TEXTURE_FILTER_BIAS_SGIX +_m[0x817C] = (1,) # GL_POST_TEXTURE_FILTER_SCALE_RANGE_SGIX +_m[0x817A] = (1,) # GL_POST_TEXTURE_FILTER_SCALE_SGIX +_m[0x86E4] = (1,) # GL_PREVIOUS_TEXTURE_INPUT_NV +_m[0x92BE] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/ARB/ARB_ES3_2_compatibility.txt # GL_PRIMITIVE_BOUNDING_BOX_ARB +_m[0x92BE] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/EXT/EXT_primitive_bounding_box.txt # GL_PRIMITIVE_BOUNDING_BOX_EXT +_m[0x92BE] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/OES/OES_primitive_bounding_box.txt # GL_PRIMITIVE_BOUNDING_BOX_OES +_m[0x8F9D] = (1,) # GL_PRIMITIVE_RESTART +_m[0x8D69] = (1,) # GL_PRIMITIVE_RESTART_FIXED_INDEX +_m[0x8221] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/EXT/EXT_tessellation_shader.txt # GL_PRIMITIVE_RESTART_FOR_PATCHES_SUPPORTED +_m[0x8F9E] = (1,) # GL_PRIMITIVE_RESTART_INDEX +_m[0x8559] = (1,) # GL_PRIMITIVE_RESTART_INDEX_NV +_m[0x8558] = (1,) # GL_PRIMITIVE_RESTART_NV +_m[0x9341] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/ARB/ARB_sample_locations.txt # GL_PROGRAMMABLE_SAMPLE_LOCATION_ARB +_m[0x9341] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_sample_locations.txt # GL_PROGRAMMABLE_SAMPLE_LOCATION_NV +_m[0x9340] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/ARB/ARB_sample_locations.txt # GL_PROGRAMMABLE_SAMPLE_LOCATION_TABLE_SIZE_ARB +_m[0x9340] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_sample_locations.txt # GL_PROGRAMMABLE_SAMPLE_LOCATION_TABLE_SIZE_NV +_m[0x88B0] = (1,) # GL_PROGRAM_ADDRESS_REGISTERS_ARB +_m[0x8805] = (1,) # GL_PROGRAM_ALU_INSTRUCTIONS_ARB +_m[0x88AC] = (1,) # GL_PROGRAM_ATTRIBS_ARB +_m[0x8906] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/gpu_program4.txt # GL_PROGRAM_ATTRIB_COMPONENTS_NV +_m[0x87FF] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/get_program_binary.txt # GL_PROGRAM_BINARY_FORMATS +_m[0x8741] = (1,) # GL_PROGRAM_BINARY_LENGTH +_m[0x8677] = (1,) # GL_PROGRAM_BINDING_ARB +_m[0x864B] = (1,) # GL_PROGRAM_ERROR_POSITION_ARB +_m[0x864B] = (1,) # GL_PROGRAM_ERROR_POSITION_NV +_m[0x8874] = (1,) # GL_PROGRAM_ERROR_STRING_ARB +_m[0x8876] = (1,) # GL_PROGRAM_FORMAT_ARB +_m[0x88A0] = (1,) # GL_PROGRAM_INSTRUCTIONS_ARB +_m[0x8627] = (1,) # GL_PROGRAM_LENGTH_ARB +_m[0x8627] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/vertex_program.txt # GL_PROGRAM_LENGTH_NV +_m[0x8E2D] = (1,)#TODO Review http://www.opengl.org/registry/specs//EXT/direct_state_access.txt # GL_PROGRAM_MATRIX_EXT +_m[0x8E2F] = (1,)#TODO Review http://www.opengl.org/registry/specs//EXT/direct_state_access.txt # GL_PROGRAM_MATRIX_STACK_DEPTH_EXT +_m[0x88B2] = (1,) # GL_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB +_m[0x8808] = (1,) # GL_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB +_m[0x88AE] = (1,) # GL_PROGRAM_NATIVE_ATTRIBS_ARB +_m[0x88A2] = (1,) # GL_PROGRAM_NATIVE_INSTRUCTIONS_ARB +_m[0x88AA] = (1,) # GL_PROGRAM_NATIVE_PARAMETERS_ARB +_m[0x88A6] = (1,) # GL_PROGRAM_NATIVE_TEMPORARIES_ARB +_m[0x880A] = (1,) # GL_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB +_m[0x8809] = (1,) # GL_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB +_m[0x8B40] = (1,) # GL_PROGRAM_OBJECT_ARB +_m[0x88A8] = (1,) # GL_PROGRAM_PARAMETERS_ARB +_m[0x8644] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/vertex_program.txt # GL_PROGRAM_PARAMETER_NV +_m[0x825A] = (1,) # GL_PROGRAM_PIPELINE_BINDING +_m[0x8642] = (1,) # GL_PROGRAM_POINT_SIZE +_m[0x8642] = (1,) # GL_PROGRAM_POINT_SIZE_ARB +_m[0x8642] = (1,) # GL_PROGRAM_POINT_SIZE_EXT +_m[0x8647] = (1,) # GL_PROGRAM_RESIDENT_NV +_m[0x8907] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/gpu_program4.txt # GL_PROGRAM_RESULT_COMPONENTS_NV +_m[0x8628] = (1,) # GL_PROGRAM_STRING_ARB +_m[0x8628] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/vertex_program.txt # GL_PROGRAM_STRING_NV +_m[0x8646] = (1,) # GL_PROGRAM_TARGET_NV +_m[0x88A4] = (1,) # GL_PROGRAM_TEMPORARIES_ARB +_m[0x8807] = (1,) # GL_PROGRAM_TEX_INDIRECTIONS_ARB +_m[0x8806] = (1,) # GL_PROGRAM_TEX_INSTRUCTIONS_ARB +_m[0x88B6] = (1,) # GL_PROGRAM_UNDER_NATIVE_LIMITS_ARB +_m[0x0BA7] = (4, 4) # GL_PROJECTION_MATRIX +_m[0x898E] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/OES/OES_matrix_get.txt # GL_PROJECTION_MATRIX_FLOAT_AS_INT_BITS_OES +_m[0x0BA4] = (1,) # GL_PROJECTION_STACK_DEPTH +_m[0x8E4F] = (1,) # GL_PROVOKING_VERTEX +_m[0x8E4F] = (1,) # GL_PROVOKING_VERTEX_EXT +_m[0x1209] = (1,) # GL_QUADRATIC_ATTENUATION +_m[0x8E4C] = (1,) # GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION +_m[0x8E4C] = (1,) # GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION_EXT +_m[0x9193] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/query_buffer_object.txt # GL_QUERY_BUFFER_BINDING +_m[0x9193] = (1,) # GL_QUERY_BUFFER_BINDING_AMD +_m[0x8864] = (1,) # GL_QUERY_COUNTER_BITS +_m[0x8864] = (1,) # GL_QUERY_COUNTER_BITS_ARB +_m[0x8866] = (1,) # GL_QUERY_RESULT +_m[0x8867] = (1,) # GL_QUERY_RESULT_AVAILABLE +_m[0x9194] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/query_buffer_object.txt # GL_QUERY_RESULT_NO_WAIT +_m[0x82EA] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/direct_state_access.txt # GL_QUERY_TARGET +_m[0x8C89] = (1,) # GL_RASTERIZER_DISCARD +_m[0x932A] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_framebuffer_mixed_samples.txt # GL_RASTER_FIXED_SAMPLE_LOCATIONS_EXT +_m[0x19262] = (1,) # GL_RASTER_POSITION_UNCLIPPED_IBM +_m[0x9328] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_framebuffer_mixed_samples.txt # GL_RASTER_SAMPLES_EXT +_m[0x0C02] = (1,) # GL_READ_BUFFER +_m[0x0C02] = (1,) # GL_READ_BUFFER_EXT +_m[0x0C02] = (1,) # GL_READ_BUFFER_NV +_m[0x8CA8] = (1,) # GL_READ_FRAMEBUFFER +_m[0x8CAA] = (1,) # GL_READ_FRAMEBUFFER_BINDING +_m[0x828C] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_READ_PIXELS +_m[0x828D] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_READ_PIXELS_FORMAT +_m[0x828E] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_READ_PIXELS_TYPE +_m[0x887B] = (1,) # GL_READ_PIXEL_DATA_RANGE_LENGTH_NV +_m[0x887D] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/pixel_data_range.txt # GL_READ_PIXEL_DATA_RANGE_POINTER_NV +_m[0x0D15] = (1,) # GL_RED_BIAS +_m[0x0D52] = (1,) # GL_RED_BITS +_m[0x8564] = (1,) # GL_RED_MAX_CLAMP_INGR +_m[0x8560] = (1,) # GL_RED_MIN_CLAMP_INGR +_m[0x0D14] = (1,) # GL_RED_SCALE +_m[0x930B] = (1,) # GL_REFERENCED_BY_COMPUTE_SHADER +_m[0x930A] = (1,) # GL_REFERENCED_BY_FRAGMENT_SHADER +_m[0x9309] = (1,) # GL_REFERENCED_BY_GEOMETRY_SHADER +_m[0x9307] = (1,) # GL_REFERENCED_BY_TESS_CONTROL_SHADER +_m[0x9308] = (1,) # GL_REFERENCED_BY_TESS_EVALUATION_SHADER +_m[0x9306] = (1,) # GL_REFERENCED_BY_VERTEX_SHADER +_m[0x817E] = (4,) # GL_REFERENCE_PLANE_EQUATION_SGIX +_m[0x817D] = (1,) # GL_REFERENCE_PLANE_SGIX +_m[0x8522] = (1,) # GL_REGISTER_COMBINERS_NV +_m[0x8D53] = (1,) # GL_RENDERBUFFER_ALPHA_SIZE +_m[0x8CA7] = (1,) # GL_RENDERBUFFER_BINDING +_m[0x8CA7] = (1,) # GL_RENDERBUFFER_BINDING_EXT +_m[0x8D52] = (1,) # GL_RENDERBUFFER_BLUE_SIZE +_m[0x8E10] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/framebuffer_multisample_coverage.txt # GL_RENDERBUFFER_COLOR_SAMPLES_NV +_m[0x8CAB] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/framebuffer_multisample_coverage.txt # GL_RENDERBUFFER_COVERAGE_SAMPLES_NV +_m[0x8D54] = (1,) # GL_RENDERBUFFER_DEPTH_SIZE +_m[0x87FD] = (1,) # GL_RENDERBUFFER_FREE_MEMORY_ATI +_m[0x8D51] = (1,) # GL_RENDERBUFFER_GREEN_SIZE +_m[0x8D43] = (1,) # GL_RENDERBUFFER_HEIGHT +_m[0x8D44] = (1,) # GL_RENDERBUFFER_INTERNAL_FORMAT +_m[0x8D50] = (1,) # GL_RENDERBUFFER_RED_SIZE +_m[0x8CAB] = (1,) # GL_RENDERBUFFER_SAMPLES +_m[0x9133] = (1,) # GL_RENDERBUFFER_SAMPLES_IMG +_m[0x8D55] = (1,) # GL_RENDERBUFFER_STENCIL_SIZE +_m[0x91B2] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/AMD/AMD_framebuffer_multisample_advanced.txt # GL_RENDERBUFFER_STORAGE_SAMPLES_AMD +_m[0x8D42] = (1,) # GL_RENDERBUFFER_WIDTH +_m[0x1F01] = (1,) # GL_RENDERER +_m[0x9558] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_gpu_multicast.txt # GL_RENDER_GPU_MASK_NV +_m[0x0C40] = (1,) # GL_RENDER_MODE +_m[0x85C2] = (1,) # GL_REPLACEMENT_CODE_ARRAY_STRIDE_SUN +_m[0x85C1] = (1,) # GL_REPLACEMENT_CODE_ARRAY_TYPE_SUN +_m[0x81D8] = (1,) # GL_REPLACEMENT_CODE_SUN +_m[0x937F] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_representative_fragment_test.txt # GL_REPRESENTATIVE_FRAGMENT_TEST_NV +_m[0x803A] = (1,) # GL_RESCALE_NORMAL +_m[0x803A] = (1,) # GL_RESCALE_NORMAL_EXT +_m[0x8256] = (1,)#TODO Review http://www.opengl.org/registry/specs//KHR/robustness.txt # GL_RESET_NOTIFICATION_STRATEGY +_m[0x8256] = (1,) # GL_RESET_NOTIFICATION_STRATEGY_ARB +_m[0x8820] = (1,) # GL_RGBA_FLOAT_MODE_ARB +_m[0x8820] = (1,) # GL_RGBA_FLOAT_MODE_ATI +_m[0x8D9E] = (1,) # GL_RGBA_INTEGER_MODE_EXT +_m[0x0C31] = (1,) # GL_RGBA_MODE +_m[0x8C3C] = (1,) # GL_RGBA_SIGNED_COMPONENTS_EXT +_m[0x86D9] = (1,) # GL_RGBA_UNSIGNED_DOT_PRODUCT_MAPPING_NV +_m[0x8573] = (1,) # GL_RGB_SCALE +_m[0x8919] = (1,) # GL_SAMPLER_BINDING +_m[0x80A9] = (1,) # GL_SAMPLES +_m[0x86B4] = (1,) # GL_SAMPLES_3DFX +_m[0x80A9] = (1,) # GL_SAMPLES_ARB +_m[0x80A9] = (1,) # GL_SAMPLES_SGIS +_m[0x809E] = (1,) # GL_SAMPLE_ALPHA_TO_COVERAGE +_m[0x809E] = (1,) # GL_SAMPLE_ALPHA_TO_COVERAGE_ARB +_m[0x809E] = (1,) # GL_SAMPLE_ALPHA_TO_MASK_EXT +_m[0x809E] = (1,) # GL_SAMPLE_ALPHA_TO_MASK_SGIS +_m[0x809F] = (1,) # GL_SAMPLE_ALPHA_TO_ONE +_m[0x809F] = (1,) # GL_SAMPLE_ALPHA_TO_ONE_ARB +_m[0x809F] = (1,) # GL_SAMPLE_ALPHA_TO_ONE_EXT +_m[0x809F] = (1,) # GL_SAMPLE_ALPHA_TO_ONE_SGIS +_m[0x80A8] = (1,) # GL_SAMPLE_BUFFERS +_m[0x86B3] = (1,) # GL_SAMPLE_BUFFERS_3DFX +_m[0x80A8] = (1,) # GL_SAMPLE_BUFFERS_ARB +_m[0x80A8] = (1,) # GL_SAMPLE_BUFFERS_SGIS +_m[0x80A0] = (1,) # GL_SAMPLE_COVERAGE +_m[0x80A0] = (1,) # GL_SAMPLE_COVERAGE_ARB +_m[0x80AB] = (1,) # GL_SAMPLE_COVERAGE_INVERT +_m[0x80AB] = (1,) # GL_SAMPLE_COVERAGE_INVERT_ARB +_m[0x80AA] = (1,) # GL_SAMPLE_COVERAGE_VALUE +_m[0x80AA] = (1,) # GL_SAMPLE_COVERAGE_VALUE_ARB +_m[0x8E50] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/ARB/ARB_sample_locations.txt # GL_SAMPLE_LOCATION_ARB +_m[0x8E50] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_sample_locations.txt # GL_SAMPLE_LOCATION_NV +_m[0x933F] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/ARB/ARB_sample_locations.txt # GL_SAMPLE_LOCATION_PIXEL_GRID_HEIGHT_ARB +_m[0x933F] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_sample_locations.txt # GL_SAMPLE_LOCATION_PIXEL_GRID_HEIGHT_NV +_m[0x933E] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/ARB/ARB_sample_locations.txt # GL_SAMPLE_LOCATION_PIXEL_GRID_WIDTH_ARB +_m[0x933E] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_sample_locations.txt # GL_SAMPLE_LOCATION_PIXEL_GRID_WIDTH_NV +_m[0x933D] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/ARB/ARB_sample_locations.txt # GL_SAMPLE_LOCATION_SUBPIXEL_BITS_ARB +_m[0x933D] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_sample_locations.txt # GL_SAMPLE_LOCATION_SUBPIXEL_BITS_NV +_m[0x8E51] = (1,) # GL_SAMPLE_MASK +_m[0x80A0] = (1,) # GL_SAMPLE_MASK_EXT +_m[0x80AB] = (1,) # GL_SAMPLE_MASK_INVERT_SGIS +_m[0x8E51] = (1,) # GL_SAMPLE_MASK_NV +_m[0x80A0] = (1,) # GL_SAMPLE_MASK_SGIS +_m[0x8E52] = (1,) # GL_SAMPLE_MASK_VALUE +_m[0x80AA] = (1,) # GL_SAMPLE_MASK_VALUE_SGIS +_m[0x80AC] = (1,) # GL_SAMPLE_PATTERN_EXT +_m[0x80AC] = (1,) # GL_SAMPLE_PATTERN_SGIS +_m[0x8E50] = (2,) # GL_SAMPLE_POSITION +_m[0x8C36] = (1,) # GL_SAMPLE_SHADING_ARB +_m[0x8C36] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/OES/OES_sample_shading.txt # GL_SAMPLE_SHADING_OES +_m[0x0C10] = (4,) # GL_SCISSOR_BOX +_m[0x9556] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_scissor_exclusive.txt # GL_SCISSOR_BOX_EXCLUSIVE_NV +_m[0x0C11] = (1,) # GL_SCISSOR_TEST +_m[0x9555] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_scissor_exclusive.txt # GL_SCISSOR_TEST_EXCLUSIVE_NV +_m[0x845E] = (1,) # GL_SECONDARY_COLOR_ARRAY +_m[0x889C] = (1,) # GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING +_m[0x889C] = (1,) # GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING_ARB +_m[0x8F31] = (1,) # GL_SECONDARY_COLOR_ARRAY_LENGTH_NV +_m[0x845D] = (1,)#TODO Review http://www.opengl.org/registry/specs//EXT/secondary_color.txt # GL_SECONDARY_COLOR_ARRAY_POINTER_EXT +_m[0x845A] = (1,) # GL_SECONDARY_COLOR_ARRAY_SIZE +_m[0x845A] = (1,) # GL_SECONDARY_COLOR_ARRAY_SIZE_EXT +_m[0x845C] = (1,) # GL_SECONDARY_COLOR_ARRAY_STRIDE +_m[0x845C] = (1,) # GL_SECONDARY_COLOR_ARRAY_STRIDE_EXT +_m[0x845B] = (1,) # GL_SECONDARY_COLOR_ARRAY_TYPE +_m[0x845B] = (1,) # GL_SECONDARY_COLOR_ARRAY_TYPE_EXT +_m[0x0DF3] = (1,) # GL_SELECTION_BUFFER_POINTER +_m[0x0DF4] = (1,) # GL_SELECTION_BUFFER_SIZE +_m[0x8012] = (1,) # GL_SEPARABLE_2D +_m[0x8012] = (1,) # GL_SEPARABLE_2D_EXT +_m[0x8DF8] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/ES2_compatibility.txt # GL_SHADER_BINARY_FORMATS +_m[0x8DFA] = (1,) # GL_SHADER_COMPILER +_m[0x82A6] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_SHADER_IMAGE_ATOMIC +_m[0x82A4] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_SHADER_IMAGE_LOAD +_m[0x82A5] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_SHADER_IMAGE_STORE +_m[0x86DF] = (1,) # GL_SHADER_OPERATION_NV +_m[0x8F64] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/EXT/EXT_shader_pixel_local_storage.txt # GL_SHADER_PIXEL_LOCAL_STORAGE_EXT +_m[0x8B88] = (1,) # GL_SHADER_SOURCE_LENGTH +_m[0x90D2] = (1,) # GL_SHADER_STORAGE_BUFFER +_m[0x90D3] = (1,) # GL_SHADER_STORAGE_BUFFER_BINDING +_m[0x90DF] = (1,) # GL_SHADER_STORAGE_BUFFER_OFFSET_ALIGNMENT +_m[0x90D5] = (1,) # GL_SHADER_STORAGE_BUFFER_SIZE +_m[0x90D4] = (1,) # GL_SHADER_STORAGE_BUFFER_START +_m[0x8B4F] = (1,) # GL_SHADER_TYPE +_m[0x0B54] = (1,) # GL_SHADE_MODEL +_m[0x8B8C] = (1,) # GL_SHADING_LANGUAGE_VERSION +_m[0x955B] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_shading_rate_image.txt # GL_SHADING_RATE_IMAGE_BINDING_NV +_m[0x9563] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_shading_rate_image.txt # GL_SHADING_RATE_IMAGE_NV +_m[0x955E] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_shading_rate_image.txt # GL_SHADING_RATE_IMAGE_PALETTE_SIZE_NV +_m[0x955D] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_shading_rate_image.txt # GL_SHADING_RATE_IMAGE_TEXEL_HEIGHT_NV +_m[0x955C] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_shading_rate_image.txt # GL_SHADING_RATE_IMAGE_TEXEL_WIDTH_NV +_m[0x1601] = (1,) # GL_SHININESS +_m[0x82AC] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_SIMULTANEOUS_TEXTURE_AND_DEPTH_TEST +_m[0x82AE] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_SIMULTANEOUS_TEXTURE_AND_DEPTH_WRITE +_m[0x82AD] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_SIMULTANEOUS_TEXTURE_AND_STENCIL_TEST +_m[0x82AF] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_SIMULTANEOUS_TEXTURE_AND_STENCIL_WRITE +_m[0x0B23] = (1,) # GL_SMOOTH_LINE_WIDTH_GRANULARITY +_m[0x0B22] = (2,) # GL_SMOOTH_LINE_WIDTH_RANGE +_m[0x0B13] = (1,) # GL_SMOOTH_POINT_SIZE_GRANULARITY +_m[0x0B12] = (2,) # GL_SMOOTH_POINT_SIZE_RANGE +_m[0x933B] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/shader_thread_group.txt # GL_SM_COUNT_NV +_m[0x858B] = (1,) # GL_SOURCE3_ALPHA_NV +_m[0x8583] = (1,) # GL_SOURCE3_RGB_NV +_m[0x82F8] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/sparse_buffer.txt # GL_SPARSE_BUFFER_PAGE_SIZE_ARB +_m[0x91A9] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/sparse_texture.txt # GL_SPARSE_TEXTURE_FULL_ARRAY_CUBE_MIPMAPS_ARB +_m[0x91A9] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/EXT/EXT_sparse_texture.txt # GL_SPARSE_TEXTURE_FULL_ARRAY_CUBE_MIPMAPS_EXT +_m[0x1202] = (4,) # GL_SPECULAR +_m[0x9552] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/ARB/ARB_gl_spirv.txt # GL_SPIR_V_BINARY_ARB +_m[0x1206] = (1,) # GL_SPOT_CUTOFF +_m[0x1204] = (3,) # GL_SPOT_DIRECTION +_m[0x1205] = (1,) # GL_SPOT_EXPONENT +_m[0x814A] = (3,) # GL_SPRITE_AXIS_SGIX +_m[0x8149] = (1,) # GL_SPRITE_MODE_SGIX +_m[0x8148] = (1,) # GL_SPRITE_SGIX +_m[0x814B] = (3,) # GL_SPRITE_TRANSLATION_SGIX +_m[0x8588] = (1,) # GL_SRC0_ALPHA +_m[0x8580] = (1,) # GL_SRC0_RGB +_m[0x8589] = (1,) # GL_SRC1_ALPHA +_m[0x8581] = (1,) # GL_SRC1_RGB +_m[0x858A] = (1,) # GL_SRC2_ALPHA +_m[0x8582] = (1,) # GL_SRC2_RGB +_m[0x8299] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_SRGB_DECODE_ARB +_m[0x8297] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_SRGB_READ +_m[0x8298] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_SRGB_WRITE +_m[0x8801] = (1,) # GL_STENCIL_BACK_FAIL +_m[0x8801] = (1,) # GL_STENCIL_BACK_FAIL_ATI +_m[0x8800] = (1,) # GL_STENCIL_BACK_FUNC +_m[0x8800] = (1,) # GL_STENCIL_BACK_FUNC_ATI +_m[0x874D] = (1,) # GL_STENCIL_BACK_OP_VALUE_AMD +_m[0x8802] = (1,) # GL_STENCIL_BACK_PASS_DEPTH_FAIL +_m[0x8802] = (1,) # GL_STENCIL_BACK_PASS_DEPTH_FAIL_ATI +_m[0x8803] = (1,) # GL_STENCIL_BACK_PASS_DEPTH_PASS +_m[0x8803] = (1,) # GL_STENCIL_BACK_PASS_DEPTH_PASS_ATI +_m[0x8CA3] = (1,) # GL_STENCIL_BACK_REF +_m[0x8CA4] = (1,) # GL_STENCIL_BACK_VALUE_MASK +_m[0x8CA5] = (1,) # GL_STENCIL_BACK_WRITEMASK +_m[0x0D57] = (1,) # GL_STENCIL_BITS +_m[0x88F3] = (1,) # GL_STENCIL_CLEAR_TAG_VALUE_EXT +_m[0x0B91] = (1,) # GL_STENCIL_CLEAR_VALUE +_m[0x8285] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_STENCIL_COMPONENTS +_m[0x0B94] = (1,) # GL_STENCIL_FAIL +_m[0x0B92] = (1,) # GL_STENCIL_FUNC +_m[0x874C] = (1,) # GL_STENCIL_OP_VALUE_AMD +_m[0x0B95] = (1,) # GL_STENCIL_PASS_DEPTH_FAIL +_m[0x0B96] = (1,) # GL_STENCIL_PASS_DEPTH_PASS +_m[0x0B97] = (1,) # GL_STENCIL_REF +_m[0x8288] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_STENCIL_RENDERABLE +_m[0x932E] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_framebuffer_mixed_samples.txt # GL_STENCIL_SAMPLES_NV +_m[0x88F2] = (1,) # GL_STENCIL_TAG_BITS_EXT +_m[0x0B90] = (1,) # GL_STENCIL_TEST +_m[0x8910] = (1,) # GL_STENCIL_TEST_TWO_SIDE_EXT +_m[0x0B93] = (1,) # GL_STENCIL_VALUE_MASK +_m[0x0B98] = (1,) # GL_STENCIL_WRITEMASK +_m[0x0C33] = (1,) # GL_STEREO +_m[0x00000004] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/KHR/KHR_shader_subgroup.txt # GL_SUBGROUP_FEATURE_ARITHMETIC_BIT_KHR +_m[0x00000008] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/KHR/KHR_shader_subgroup.txt # GL_SUBGROUP_FEATURE_BALLOT_BIT_KHR +_m[0x00000001] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/KHR/KHR_shader_subgroup.txt # GL_SUBGROUP_FEATURE_BASIC_BIT_KHR +_m[0x00000040] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/KHR/KHR_shader_subgroup.txt # GL_SUBGROUP_FEATURE_CLUSTERED_BIT_KHR +_m[0x00000100] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_shader_subgroup_partitioned.txt # GL_SUBGROUP_FEATURE_PARTITIONED_BIT_NV +_m[0x00000080] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/KHR/KHR_shader_subgroup.txt # GL_SUBGROUP_FEATURE_QUAD_BIT_KHR +_m[0x00000010] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/KHR/KHR_shader_subgroup.txt # GL_SUBGROUP_FEATURE_SHUFFLE_BIT_KHR +_m[0x00000020] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/KHR/KHR_shader_subgroup.txt # GL_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT_KHR +_m[0x00000002] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/KHR/KHR_shader_subgroup.txt # GL_SUBGROUP_FEATURE_VOTE_BIT_KHR +_m[0x9535] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/KHR/KHR_shader_subgroup.txt # GL_SUBGROUP_QUAD_ALL_STAGES_KHR +_m[0x9532] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/KHR/KHR_shader_subgroup.txt # GL_SUBGROUP_SIZE_KHR +_m[0x9534] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/KHR/KHR_shader_subgroup.txt # GL_SUBGROUP_SUPPORTED_FEATURES_KHR +_m[0x9533] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/KHR/KHR_shader_subgroup.txt # GL_SUBGROUP_SUPPORTED_STAGES_KHR +_m[0x0D50] = (1,) # GL_SUBPIXEL_BITS +_m[0x9347] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_conservative_raster.txt # GL_SUBPIXEL_PRECISION_BIAS_X_BITS_NV +_m[0x9348] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_conservative_raster.txt # GL_SUBPIXEL_PRECISION_BIAS_Y_BITS_NV +_m[0x883F] = (1,)#TODO Review http://www.opengl.org/registry/specs//AMD/sample_positions.txt # GL_SUBSAMPLE_DISTANCE_AMD +_m[0x9372] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_internalformat_sample_query.txt # GL_SUPERSAMPLE_SCALE_X_NV +_m[0x9373] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_internalformat_sample_query.txt # GL_SUPERSAMPLE_SCALE_Y_NV +_m[0x91B7] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/AMD/AMD_framebuffer_multisample_advanced.txt # GL_SUPPORTED_MULTISAMPLE_MODES_AMD +_m[0x9113] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/sync.txt # GL_SYNC_CONDITION +_m[0x9115] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/sync.txt # GL_SYNC_FLAGS +_m[0x9114] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/sync.txt # GL_SYNC_STATUS +_m[0x8439] = (1,) # GL_TANGENT_ARRAY_EXT +_m[0x8442] = (1,) # GL_TANGENT_ARRAY_POINTER_EXT +_m[0x843F] = (1,) # GL_TANGENT_ARRAY_STRIDE_EXT +_m[0x843E] = (1,) # GL_TANGENT_ARRAY_TYPE_EXT +_m[0x953F] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_TASK_WORK_GROUP_SIZE_NV +_m[0x9004] = (1,) # GL_TESSELLATION_MODE_AMD +_m[0x8E75] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/tessellation_shader.txt # GL_TESS_CONTROL_OUTPUT_VERTICES +_m[0x891E] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/tessellation_program5.txt # GL_TESS_CONTROL_PROGRAM_NV +_m[0x8E88] = (1,) # GL_TESS_CONTROL_SHADER +_m[0x829C] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_TESS_CONTROL_TEXTURE +_m[0x891F] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/tessellation_program5.txt # GL_TESS_EVALUATION_PROGRAM_NV +_m[0x8E87] = (1,) # GL_TESS_EVALUATION_SHADER +_m[0x829D] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_TESS_EVALUATION_TEXTURE +_m[0x8E76] = (1,) # GL_TESS_GEN_MODE +_m[0x8E79] = (1,) # GL_TESS_GEN_POINT_MODE +_m[0x8E77] = (1,) # GL_TESS_GEN_SPACING +_m[0x8E78] = (1,) # GL_TESS_GEN_VERTEX_ORDER +_m[0x0DE0] = (1,) # GL_TEXTURE_1D +_m[0x8C18] = (1,) # GL_TEXTURE_1D_ARRAY +_m[0x8068] = (1,) # GL_TEXTURE_1D_BINDING_EXT +_m[0x875D] = (1,) # GL_TEXTURE_1D_STACK_BINDING_MESAX +_m[0x8759] = (1,) # GL_TEXTURE_1D_STACK_MESAX +_m[0x0DE1] = (1,) # GL_TEXTURE_2D +_m[0x8C1A] = (1,) # GL_TEXTURE_2D_ARRAY +_m[0x8069] = (1,) # GL_TEXTURE_2D_BINDING_EXT +_m[0x875E] = (1,) # GL_TEXTURE_2D_STACK_BINDING_MESAX +_m[0x875A] = (1,) # GL_TEXTURE_2D_STACK_MESAX +_m[0x806F] = (1,) # GL_TEXTURE_3D +_m[0x806A] = (1,) # GL_TEXTURE_3D_BINDING_EXT +_m[0x806F] = (1,) # GL_TEXTURE_3D_EXT +_m[0x806F] = (1,) # GL_TEXTURE_3D_OES +_m[0x814F] = (1,) # GL_TEXTURE_4D_BINDING_SGIS +_m[0x8134] = (1,) # GL_TEXTURE_4D_SGIS +_m[0x805F] = (1,) # GL_TEXTURE_ALPHA_SIZE +_m[0x8C13] = (1,) # GL_TEXTURE_ALPHA_TYPE +_m[0x834F] = (1,) # GL_TEXTURE_APPLICATION_MODE_EXT +_m[0x813C] = (1,) # GL_TEXTURE_BASE_LEVEL +_m[0x813C] = (1,) # GL_TEXTURE_BASE_LEVEL_SGIS +_m[0x8068] = (1,) # GL_TEXTURE_BINDING_1D +_m[0x8C1C] = (1,) # GL_TEXTURE_BINDING_1D_ARRAY +_m[0x8C1C] = (1,) # GL_TEXTURE_BINDING_1D_ARRAY_EXT +_m[0x8069] = (1,) # GL_TEXTURE_BINDING_2D +_m[0x8C1D] = (1,) # GL_TEXTURE_BINDING_2D_ARRAY +_m[0x8C1D] = (1,) # GL_TEXTURE_BINDING_2D_ARRAY_EXT +_m[0x9104] = (1,) # GL_TEXTURE_BINDING_2D_MULTISAMPLE +_m[0x9105] = (1,) # GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY +_m[0x806A] = (1,) # GL_TEXTURE_BINDING_3D +_m[0x8C2C] = (1,) # GL_TEXTURE_BINDING_BUFFER +_m[0x8C2C] = (1,) # GL_TEXTURE_BINDING_BUFFER_ARB +_m[0x8C2C] = (1,) # GL_TEXTURE_BINDING_BUFFER_EXT +_m[0x8514] = (1,) # GL_TEXTURE_BINDING_CUBE_MAP +_m[0x8514] = (1,) # GL_TEXTURE_BINDING_CUBE_MAP_ARB +_m[0x900A] = (1,) # GL_TEXTURE_BINDING_CUBE_MAP_ARRAY +_m[0x900A] = (1,) # GL_TEXTURE_BINDING_CUBE_MAP_ARRAY_ARB +_m[0x8D67] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/OES/OES_EGL_image_external.txt # GL_TEXTURE_BINDING_EXTERNAL_OES +_m[0x84F6] = (1,) # GL_TEXTURE_BINDING_RECTANGLE +_m[0x84F6] = (1,) # GL_TEXTURE_BINDING_RECTANGLE_ARB +_m[0x84F6] = (1,) # GL_TEXTURE_BINDING_RECTANGLE_NV +_m[0x8E53] = (1,) # GL_TEXTURE_BINDING_RENDERBUFFER_NV +_m[0x805E] = (1,) # GL_TEXTURE_BLUE_SIZE +_m[0x8C12] = (1,) # GL_TEXTURE_BLUE_TYPE +_m[0x1005] = (1,) # GL_TEXTURE_BORDER +_m[0x1004] = (4,) # GL_TEXTURE_BORDER_COLOR +_m[0x1004] = (4,) # GL_TEXTURE_BORDER_COLOR_NV +_m[0x8C2A] = (1,) # GL_TEXTURE_BUFFER +_m[0x8C2A] = (1,) # GL_TEXTURE_BUFFER_ARB +_m[0x8C2A] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/EXT/EXT_texture_buffer.txt # GL_TEXTURE_BUFFER_BINDING_EXT +_m[0x8C2A] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/OES/OES_texture_buffer.txt # GL_TEXTURE_BUFFER_BINDING_OES +_m[0x8C2D] = (1,) # GL_TEXTURE_BUFFER_DATA_STORE_BINDING +_m[0x8C2D] = (1,) # GL_TEXTURE_BUFFER_DATA_STORE_BINDING_ARB +_m[0x8C2D] = (1,) # GL_TEXTURE_BUFFER_DATA_STORE_BINDING_EXT +_m[0x8C2A] = (1,) # GL_TEXTURE_BUFFER_EXT +_m[0x8C2E] = (1,) # GL_TEXTURE_BUFFER_FORMAT_ARB +_m[0x8C2E] = (1,) # GL_TEXTURE_BUFFER_FORMAT_EXT +_m[0x919D] = (1,) # GL_TEXTURE_BUFFER_OFFSET +_m[0x919F] = (1,) # GL_TEXTURE_BUFFER_OFFSET_ALIGNMENT +_m[0x919E] = (1,) # GL_TEXTURE_BUFFER_SIZE +_m[0x8171] = (2,) # GL_TEXTURE_CLIPMAP_CENTER_SGIX +_m[0x8176] = (1,) # GL_TEXTURE_CLIPMAP_DEPTH_SGIX +_m[0x8172] = (1,) # GL_TEXTURE_CLIPMAP_FRAME_SGIX +_m[0x8173] = (2,) # GL_TEXTURE_CLIPMAP_OFFSET_SGIX +_m[0x8174] = (3,) # GL_TEXTURE_CLIPMAP_VIRTUAL_DEPTH_SGIX +_m[0x9046] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/texture_multisample.txt # GL_TEXTURE_COLOR_SAMPLES_NV +_m[0x80BC] = (1,) # GL_TEXTURE_COLOR_TABLE_SGI +_m[0x81EF] = (4,) # GL_TEXTURE_COLOR_WRITEMASK_SGIS +_m[0x80BF] = (1,) # GL_TEXTURE_COMPARE_FAIL_VALUE_ARB +_m[0x884D] = (1,) # GL_TEXTURE_COMPARE_FUNC +_m[0x884C] = (1,) # GL_TEXTURE_COMPARE_MODE +_m[0x819B] = (1,) # GL_TEXTURE_COMPARE_OPERATOR_SGIX +_m[0x819A] = (1,) # GL_TEXTURE_COMPARE_SGIX +_m[0x86A1] = (1,) # GL_TEXTURE_COMPRESSED +_m[0x82B2] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_TEXTURE_COMPRESSED_BLOCK_HEIGHT +_m[0x82B3] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_TEXTURE_COMPRESSED_BLOCK_SIZE +_m[0x82B1] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_TEXTURE_COMPRESSED_BLOCK_WIDTH +_m[0x86A0] = (1,) # GL_TEXTURE_COMPRESSED_IMAGE_SIZE +_m[0x84EF] = (1,) # GL_TEXTURE_COMPRESSION_HINT +_m[0x84EF] = (1,) # GL_TEXTURE_COMPRESSION_HINT_ARB +_m[0x8078] = (1,) # GL_TEXTURE_COORD_ARRAY +_m[0x889A] = (1,) # GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING +_m[0x889A] = (1,) # GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING_ARB +_m[0x808B] = (1,) # GL_TEXTURE_COORD_ARRAY_COUNT_EXT +_m[0x8078] = (1,) # GL_TEXTURE_COORD_ARRAY_EXT +_m[0x83F8] = (1,)#TODO Review http://www.opengl.org/registry/specs//INTEL/parallel_arrays.txt # GL_TEXTURE_COORD_ARRAY_PARALLEL_POINTERS_INTEL +_m[0x8092] = (1,) # GL_TEXTURE_COORD_ARRAY_POINTER +_m[0x8088] = (1,) # GL_TEXTURE_COORD_ARRAY_SIZE +_m[0x8088] = (1,) # GL_TEXTURE_COORD_ARRAY_SIZE_EXT +_m[0x808A] = (1,) # GL_TEXTURE_COORD_ARRAY_STRIDE +_m[0x808A] = (1,) # GL_TEXTURE_COORD_ARRAY_STRIDE_EXT +_m[0x8089] = (1,) # GL_TEXTURE_COORD_ARRAY_TYPE +_m[0x8089] = (1,) # GL_TEXTURE_COORD_ARRAY_TYPE_EXT +_m[0x9045] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/texture_multisample.txt # GL_TEXTURE_COVERAGE_SAMPLES_NV +_m[0x8B9D] = (4,) # GL_TEXTURE_CROP_RECT_OES +_m[0x8513] = (1,) # GL_TEXTURE_CUBE_MAP +_m[0x8513] = (1,) # GL_TEXTURE_CUBE_MAP_ARB +_m[0x9009] = (1,) # GL_TEXTURE_CUBE_MAP_ARRAY +_m[0x884F] = (1,) # GL_TEXTURE_CUBE_MAP_SEAMLESS +_m[0x8071] = (1,) # GL_TEXTURE_DEPTH +_m[0x8071] = (1,) # GL_TEXTURE_DEPTH_EXT +_m[0x884A] = (1,) # GL_TEXTURE_DEPTH_SIZE +_m[0x8C16] = (1,) # GL_TEXTURE_DEPTH_TYPE +_m[0x871D] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/texture_shader.txt # GL_TEXTURE_DS_SIZE_NV +_m[0x871E] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/texture_shader.txt # GL_TEXTURE_DT_SIZE_NV +_m[0x2201] = (4,) # GL_TEXTURE_ENV_COLOR +_m[0x2200] = (1,) # GL_TEXTURE_ENV_MODE +_m[0x9107] = (1,) # GL_TEXTURE_FIXED_SAMPLE_LOCATIONS +_m[0x888C] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/float_buffer.txt # GL_TEXTURE_FLOAT_COMPONENTS_NV +_m[0x8BFD] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/QCOM/QCOM_texture_foveated.txt # GL_TEXTURE_FOVEATED_FEATURE_QUERY_QCOM +_m[0x8BFE] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/QCOM/QCOM_texture_foveated.txt # GL_TEXTURE_FOVEATED_NUM_FOCAL_POINTS_QUERY_QCOM +_m[0x87FC] = (1,) # GL_TEXTURE_FREE_MEMORY_ATI +_m[0x82A2] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_TEXTURE_GATHER +_m[0x82A3] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_TEXTURE_GATHER_SHADOW +_m[0x2500] = (1,) # GL_TEXTURE_GEN_MODE +_m[0x0C63] = (1,) # GL_TEXTURE_GEN_Q +_m[0x0C62] = (1,) # GL_TEXTURE_GEN_R +_m[0x0C60] = (1,) # GL_TEXTURE_GEN_S +_m[0x8D60] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/OES/OES_texture_cube_map.txt # GL_TEXTURE_GEN_STR_OES +_m[0x0C61] = (1,) # GL_TEXTURE_GEN_T +_m[0x805D] = (1,) # GL_TEXTURE_GREEN_SIZE +_m[0x8C11] = (1,) # GL_TEXTURE_GREEN_TYPE +_m[0x1001] = (1,) # GL_TEXTURE_HEIGHT +_m[0x871B] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/texture_shader.txt # GL_TEXTURE_HI_SIZE_NV +_m[0x828F] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_TEXTURE_IMAGE_FORMAT +_m[0x8290] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_TEXTURE_IMAGE_TYPE +_m[0x912F] = (1,) # GL_TEXTURE_IMMUTABLE_FORMAT +_m[0x82DF] = (1,) # GL_TEXTURE_IMMUTABLE_LEVELS +_m[0x80ED] = (1,) # GL_TEXTURE_INDEX_SIZE_EXT +_m[0x8061] = (1,) # GL_TEXTURE_INTENSITY_SIZE +_m[0x8C15] = (1,) # GL_TEXTURE_INTENSITY_TYPE +_m[0x1003] = (1,) # GL_TEXTURE_INTERNAL_FORMAT +_m[0x8350] = (1,) # GL_TEXTURE_LIGHT_EXT +_m[0x8501] = (1,) # GL_TEXTURE_LOD_BIAS +_m[0x8190] = (1,) # GL_TEXTURE_LOD_BIAS_R_SGIX +_m[0x818E] = (1,) # GL_TEXTURE_LOD_BIAS_S_SGIX +_m[0x818F] = (1,) # GL_TEXTURE_LOD_BIAS_T_SGIX +_m[0x871C] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/texture_shader.txt # GL_TEXTURE_LO_SIZE_NV +_m[0x8060] = (1,) # GL_TEXTURE_LUMINANCE_SIZE +_m[0x8C14] = (1,) # GL_TEXTURE_LUMINANCE_TYPE +_m[0x2800] = (1,) # GL_TEXTURE_MAG_FILTER +_m[0x871F] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/texture_shader.txt # GL_TEXTURE_MAG_SIZE_NV +_m[0x8351] = (1,) # GL_TEXTURE_MATERIAL_FACE_EXT +_m[0x8352] = (1,) # GL_TEXTURE_MATERIAL_PARAMETER_EXT +_m[0x0BA8] = (4, 4) # GL_TEXTURE_MATRIX +_m[0x898F] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/OES/OES_matrix_get.txt # GL_TEXTURE_MATRIX_FLOAT_AS_INT_BITS_OES +_m[0x84FE] = (1,) # GL_TEXTURE_MAX_ANISOTROPY_EXT +_m[0x836B] = (1,) # GL_TEXTURE_MAX_CLAMP_R_SGIX +_m[0x8369] = (1,) # GL_TEXTURE_MAX_CLAMP_S_SGIX +_m[0x836A] = (1,) # GL_TEXTURE_MAX_CLAMP_T_SGIX +_m[0x813D] = (1,) # GL_TEXTURE_MAX_LEVEL +_m[0x813D] = (1,) # GL_TEXTURE_MAX_LEVEL_SGIS +_m[0x813B] = (1,) # GL_TEXTURE_MAX_LOD +_m[0x813B] = (1,) # GL_TEXTURE_MAX_LOD_SGIS +_m[0x2801] = (1,) # GL_TEXTURE_MIN_FILTER +_m[0x813A] = (1,) # GL_TEXTURE_MIN_LOD +_m[0x813A] = (1,) # GL_TEXTURE_MIN_LOD_SGIS +_m[0x8066] = (1,) # GL_TEXTURE_PRIORITY +_m[0x85B8] = (1,) # GL_TEXTURE_RANGE_POINTER_APPLE +_m[0x84F5] = (1,) # GL_TEXTURE_RECTANGLE +_m[0x84F5] = (1,) # GL_TEXTURE_RECTANGLE_ARB +_m[0x84F5] = (1,) # GL_TEXTURE_RECTANGLE_NV +_m[0x805C] = (1,) # GL_TEXTURE_RED_SIZE +_m[0x8C10] = (1,) # GL_TEXTURE_RED_TYPE +_m[0x8E54] = (1,) # GL_TEXTURE_RENDERBUFFER_DATA_STORE_BINDING_NV +_m[0x8067] = (1,) # GL_TEXTURE_RESIDENT +_m[0x9106] = (1,) # GL_TEXTURE_SAMPLES +_m[0x9136] = (1,) # GL_TEXTURE_SAMPLES_IMG +_m[0x86DE] = (1,) # GL_TEXTURE_SHADER_NV +_m[0x82A1] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_TEXTURE_SHADOW +_m[0x8C3F] = (1,)#TODO Review http://www.opengl.org/registry/specs//EXT/texture_shared_exponent.txt # GL_TEXTURE_SHARED_SIZE_EXT +_m[0x8A48] = (1,) # GL_TEXTURE_SRGB_DECODE_EXT +_m[0x0BA5] = (1,) # GL_TEXTURE_STACK_DEPTH +_m[0x88F1] = (1,) # GL_TEXTURE_STENCIL_SIZE +_m[0x85BC] = (1,) # GL_TEXTURE_STORAGE_HINT_APPLE +_m[0x8E45] = (1,) # GL_TEXTURE_SWIZZLE_A +_m[0x8E44] = (1,) # GL_TEXTURE_SWIZZLE_B +_m[0x8E43] = (1,) # GL_TEXTURE_SWIZZLE_G +_m[0x8E42] = (1,) # GL_TEXTURE_SWIZZLE_R +_m[0x8E46] = (4,) # GL_TEXTURE_SWIZZLE_RGBA +_m[0x1006] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/direct_state_access.txt # GL_TEXTURE_TARGET +_m[0x888F] = (1,) # GL_TEXTURE_UNSIGNED_REMAP_MODE_NV +_m[0x82B5] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_TEXTURE_VIEW +_m[0x82DD] = (1,) # GL_TEXTURE_VIEW_MIN_LAYER +_m[0x82DB] = (1,) # GL_TEXTURE_VIEW_MIN_LEVEL +_m[0x82DE] = (1,) # GL_TEXTURE_VIEW_NUM_LAYERS +_m[0x82DC] = (1,) # GL_TEXTURE_VIEW_NUM_LEVELS +_m[0x1000] = (1,) # GL_TEXTURE_WIDTH +_m[0x8137] = (1,) # GL_TEXTURE_WRAP_Q_SGIS +_m[0x8072] = (1,) # GL_TEXTURE_WRAP_R +_m[0x8072] = (1,) # GL_TEXTURE_WRAP_R_EXT +_m[0x2802] = (1,) # GL_TEXTURE_WRAP_S +_m[0x2803] = (1,) # GL_TEXTURE_WRAP_T +_m[0x8200] = (1,) # GL_TEXT_FRAGMENT_SHADER_ATI +_m[0x8E28] = (1,) # GL_TIMESTAMP +_m[0x930C] = (1,) # GL_TOP_LEVEL_ARRAY_SIZE +_m[0x930D] = (1,) # GL_TOP_LEVEL_ARRAY_STRIDE +_m[0x8648] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/vertex_program.txt # GL_TRACK_MATRIX_NV +_m[0x8649] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/vertex_program.txt # GL_TRACK_MATRIX_TRANSFORM_NV +_m[0x8E25] = (1,) # GL_TRANSFORM_FEEDBACK_BINDING +_m[0x8E25] = (1,) # GL_TRANSFORM_FEEDBACK_BINDING_NV +_m[0x8E24] = (1,) # GL_TRANSFORM_FEEDBACK_BUFFER_ACTIVE +_m[0x8E24] = (1,) # GL_TRANSFORM_FEEDBACK_BUFFER_ACTIVE_NV +_m[0x8C8F] = (1,) # GL_TRANSFORM_FEEDBACK_BUFFER_BINDING +_m[0x8C7F] = (1,) # GL_TRANSFORM_FEEDBACK_BUFFER_MODE +_m[0x8C7F] = (1,)#TODO Review http://www.opengl.org/registry/specs//EXT/transform_feedback.txt # GL_TRANSFORM_FEEDBACK_BUFFER_MODE_EXT +_m[0x8C7F] = (1,) # GL_TRANSFORM_FEEDBACK_BUFFER_MODE_NV +_m[0x8E23] = (1,) # GL_TRANSFORM_FEEDBACK_BUFFER_PAUSED +_m[0x8E23] = (1,) # GL_TRANSFORM_FEEDBACK_BUFFER_PAUSED_NV +_m[0x8C85] = (1,) # GL_TRANSFORM_FEEDBACK_BUFFER_SIZE +_m[0x8C84] = (1,) # GL_TRANSFORM_FEEDBACK_BUFFER_START +_m[0x8C83] = (1,) # GL_TRANSFORM_FEEDBACK_VARYINGS +_m[0x8C83] = (1,)#TODO Review http://www.opengl.org/registry/specs//EXT/transform_feedback.txt # GL_TRANSFORM_FEEDBACK_VARYINGS_EXT +_m[0x8C76] = (1,) # GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH +_m[0x8C76] = (1,)#TODO Review http://www.opengl.org/registry/specs//EXT/transform_feedback.txt # GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH_EXT +_m[0x84E6] = (4,4) # GL_TRANSPOSE_COLOR_MATRIX +_m[0x84E6] = (4,4) # GL_TRANSPOSE_COLOR_MATRIX_ARB +_m[0x88B7] = (4, 4) # GL_TRANSPOSE_CURRENT_MATRIX_ARB +_m[0x84E3] = (4,4) # GL_TRANSPOSE_MODELVIEW_MATRIX +_m[0x84E3] = (4,4) # GL_TRANSPOSE_MODELVIEW_MATRIX_ARB +_m[0x8E2E] = (1,)#TODO Review http://www.opengl.org/registry/specs//EXT/direct_state_access.txt # GL_TRANSPOSE_PROGRAM_MATRIX_EXT +_m[0x84E4] = (4,4) # GL_TRANSPOSE_PROJECTION_MATRIX +_m[0x84E4] = (4,4) # GL_TRANSPOSE_PROJECTION_MATRIX_ARB +_m[0x84E5] = (4,4) # GL_TRANSPOSE_TEXTURE_MATRIX +_m[0x84E5] = (4,4) # GL_TRANSPOSE_TEXTURE_MATRIX_ARB +_m[0x92FA] = (1,) # GL_TYPE +_m[0x8A3C] = (1,) # GL_UNIFORM_ARRAY_STRIDE +_m[0x92DA] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/shader_atomic_counters.txt # GL_UNIFORM_ATOMIC_COUNTER_BUFFER_INDEX +_m[0x8A42] = (1,) # GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS +_m[0x8A43] = (1,) # GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES +_m[0x8A3F] = (1,) # GL_UNIFORM_BLOCK_BINDING +_m[0x8A40] = (1,) # GL_UNIFORM_BLOCK_DATA_SIZE +_m[0x8A3A] = (1,) # GL_UNIFORM_BLOCK_INDEX +_m[0x8A41] = (1,) # GL_UNIFORM_BLOCK_NAME_LENGTH +_m[0x90EC] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/compute_shader.txt # GL_UNIFORM_BLOCK_REFERENCED_BY_COMPUTE_SHADER +_m[0x8A46] = (1,) # GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER +_m[0x8A45] = (1,) # GL_UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER +_m[0x959C] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_UNIFORM_BLOCK_REFERENCED_BY_MESH_SHADER_NV +_m[0x959D] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_UNIFORM_BLOCK_REFERENCED_BY_TASK_SHADER_NV +_m[0x84F0] = (1,) # GL_UNIFORM_BLOCK_REFERENCED_BY_TESS_CONTROL_SHADER +_m[0x84F1] = (1,) # GL_UNIFORM_BLOCK_REFERENCED_BY_TESS_EVALUATION_SHADER +_m[0x8A44] = (1,) # GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER +_m[0x8A28] = (1,) # GL_UNIFORM_BUFFER_BINDING +_m[0x8DEF] = (1,) # GL_UNIFORM_BUFFER_BINDING_EXT +_m[0x8A34] = (1,) # GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT +_m[0x8A2A] = (1,) # GL_UNIFORM_BUFFER_SIZE +_m[0x8A29] = (1,) # GL_UNIFORM_BUFFER_START +_m[0x8A3E] = (1,) # GL_UNIFORM_IS_ROW_MAJOR +_m[0x8A3D] = (1,) # GL_UNIFORM_MATRIX_STRIDE +_m[0x8A39] = (1,) # GL_UNIFORM_NAME_LENGTH +_m[0x8A3B] = (1,) # GL_UNIFORM_OFFSET +_m[0x8A38] = (1,) # GL_UNIFORM_SIZE +_m[0x8A37] = (1,) # GL_UNIFORM_TYPE +_m[0x0CF5] = (1,) # GL_UNPACK_ALIGNMENT +_m[0x85B2] = (1,) # GL_UNPACK_CLIENT_STORAGE_APPLE +_m[0x800F] = (1,) # GL_UNPACK_CMYK_HINT_EXT +_m[0x9129] = (1,) # GL_UNPACK_COMPRESSED_BLOCK_DEPTH +_m[0x9128] = (1,) # GL_UNPACK_COMPRESSED_BLOCK_HEIGHT +_m[0x912A] = (1,) # GL_UNPACK_COMPRESSED_BLOCK_SIZE +_m[0x9127] = (1,) # GL_UNPACK_COMPRESSED_BLOCK_WIDTH +_m[0x8133] = (1,) # GL_UNPACK_IMAGE_DEPTH_SGIS +_m[0x806E] = (1,) # GL_UNPACK_IMAGE_HEIGHT +_m[0x806E] = (1,) # GL_UNPACK_IMAGE_HEIGHT_EXT +_m[0x0CF1] = (1,) # GL_UNPACK_LSB_FIRST +_m[0x8985] = (1,) # GL_UNPACK_RESAMPLE_OML +_m[0x842F] = (1,) # GL_UNPACK_RESAMPLE_SGIX +_m[0x8A16] = (1,) # GL_UNPACK_ROW_BYTES_APPLE +_m[0x0CF2] = (1,) # GL_UNPACK_ROW_LENGTH +_m[0x806D] = (1,) # GL_UNPACK_SKIP_IMAGES +_m[0x806D] = (1,) # GL_UNPACK_SKIP_IMAGES_EXT +_m[0x0CF4] = (1,) # GL_UNPACK_SKIP_PIXELS +_m[0x0CF3] = (1,) # GL_UNPACK_SKIP_ROWS +_m[0x8132] = (1,) # GL_UNPACK_SKIP_VOLUMES_SGIS +_m[0x0CF0] = (1,) # GL_UNPACK_SWAP_BYTES +_m[0x954A] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NVX/NVX_gpu_multicast2.txt # GL_UPLOAD_GPU_MASK_NVX +_m[0x8B83] = (1,) # GL_VALIDATE_STATUS +_m[0x87E9] = (1,)#TODO Review http://www.opengl.org/registry/specs//EXT/vertex_shader.txt # GL_VARIANT_ARRAY_POINTER_EXT +_m[0x87E7] = (1,) # GL_VARIANT_ARRAY_TYPE_EXT +_m[0x87FB] = (1,) # GL_VBO_FREE_MEMORY_ATI +_m[0x1F00] = (1,) # GL_VENDOR +_m[0x1F02] = (1,) # GL_VERSION +_m[0x8074] = (1,) # GL_VERTEX_ARRAY +_m[0x85B5] = (1,) # GL_VERTEX_ARRAY_BINDING +_m[0x85B5] = (1,) # GL_VERTEX_ARRAY_BINDING_APPLE +_m[0x8896] = (1,) # GL_VERTEX_ARRAY_BUFFER_BINDING +_m[0x8896] = (1,) # GL_VERTEX_ARRAY_BUFFER_BINDING_ARB +_m[0x807D] = (1,) # GL_VERTEX_ARRAY_COUNT_EXT +_m[0x8074] = (1,) # GL_VERTEX_ARRAY_EXT +_m[0x8F2B] = (1,) # GL_VERTEX_ARRAY_LENGTH_NV +_m[0x83F5] = (1,)#TODO Review http://www.opengl.org/registry/specs//INTEL/parallel_arrays.txt # GL_VERTEX_ARRAY_PARALLEL_POINTERS_INTEL +_m[0x808E] = (1,) # GL_VERTEX_ARRAY_POINTER +_m[0x851E] = (1,) # GL_VERTEX_ARRAY_RANGE_LENGTH_APPLE +_m[0x851E] = (1,) # GL_VERTEX_ARRAY_RANGE_LENGTH_NV +_m[0x851D] = (1,) # GL_VERTEX_ARRAY_RANGE_NV +_m[0x8521] = (1,) # GL_VERTEX_ARRAY_RANGE_POINTER_NV +_m[0x851F] = (1,) # GL_VERTEX_ARRAY_RANGE_VALID_NV +_m[0x807A] = (1,) # GL_VERTEX_ARRAY_SIZE +_m[0x807A] = (1,) # GL_VERTEX_ARRAY_SIZE_EXT +_m[0x807C] = (1,) # GL_VERTEX_ARRAY_STRIDE +_m[0x807C] = (1,) # GL_VERTEX_ARRAY_STRIDE_EXT +_m[0x807B] = (1,) # GL_VERTEX_ARRAY_TYPE +_m[0x807B] = (1,) # GL_VERTEX_ARRAY_TYPE_EXT +_m[0x8650] = (1,) # GL_VERTEX_ATTRIB_ARRAY0_NV +_m[0x865A] = (1,) # GL_VERTEX_ATTRIB_ARRAY10_NV +_m[0x865B] = (1,) # GL_VERTEX_ATTRIB_ARRAY11_NV +_m[0x865C] = (1,) # GL_VERTEX_ATTRIB_ARRAY12_NV +_m[0x865D] = (1,) # GL_VERTEX_ATTRIB_ARRAY13_NV +_m[0x865E] = (1,) # GL_VERTEX_ATTRIB_ARRAY14_NV +_m[0x865F] = (1,) # GL_VERTEX_ATTRIB_ARRAY15_NV +_m[0x8651] = (1,) # GL_VERTEX_ATTRIB_ARRAY1_NV +_m[0x8652] = (1,) # GL_VERTEX_ATTRIB_ARRAY2_NV +_m[0x8653] = (1,) # GL_VERTEX_ATTRIB_ARRAY3_NV +_m[0x8654] = (1,) # GL_VERTEX_ATTRIB_ARRAY4_NV +_m[0x8655] = (1,) # GL_VERTEX_ATTRIB_ARRAY5_NV +_m[0x8656] = (1,) # GL_VERTEX_ATTRIB_ARRAY6_NV +_m[0x8657] = (1,) # GL_VERTEX_ATTRIB_ARRAY7_NV +_m[0x8658] = (1,) # GL_VERTEX_ATTRIB_ARRAY8_NV +_m[0x8659] = (1,) # GL_VERTEX_ATTRIB_ARRAY9_NV +_m[0x889F] = (1,) # GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING +_m[0x889F] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/vertex_buffer_object.txt # GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING_ARB +_m[0x88FE] = (1,) # GL_VERTEX_ATTRIB_ARRAY_DIVISOR +_m[0x8622] = (1,) # GL_VERTEX_ATTRIB_ARRAY_ENABLED +_m[0x88FD] = (1,) # GL_VERTEX_ATTRIB_ARRAY_INTEGER +_m[0x874E] = (1,) # GL_VERTEX_ATTRIB_ARRAY_LONG +_m[0x886A] = (1,) # GL_VERTEX_ATTRIB_ARRAY_NORMALIZED +_m[0x8645] = (1,) # GL_VERTEX_ATTRIB_ARRAY_POINTER +_m[0x8623] = (1,) # GL_VERTEX_ATTRIB_ARRAY_SIZE +_m[0x8624] = (1,) # GL_VERTEX_ATTRIB_ARRAY_STRIDE +_m[0x8625] = (1,) # GL_VERTEX_ATTRIB_ARRAY_TYPE +_m[0x82D4] = (1,) # GL_VERTEX_ATTRIB_BINDING +_m[0x82D5] = (1,) # GL_VERTEX_ATTRIB_RELATIVE_OFFSET +_m[0x82D6] = (1,) # GL_VERTEX_BINDING_DIVISOR +_m[0x82D7] = (1,) # GL_VERTEX_BINDING_OFFSET +_m[0x82D8] = (1,) # GL_VERTEX_BINDING_STRIDE +_m[0x86A7] = (1,) # GL_VERTEX_BLEND_ARB +_m[0x83EF] = (1,) # GL_VERTEX_PRECLIP_HINT_SGIX +_m[0x83EE] = (1,) # GL_VERTEX_PRECLIP_SGIX +_m[0x8620] = (1,) # GL_VERTEX_PROGRAM_ARB +_m[0x864A] = (1,) # GL_VERTEX_PROGRAM_BINDING_NV +_m[0x8620] = (1,) # GL_VERTEX_PROGRAM_NV +_m[0x8DA2] = (1,) # GL_VERTEX_PROGRAM_PARAMETER_BUFFER_NV +_m[0x8642] = (1,) # GL_VERTEX_PROGRAM_POINT_SIZE +_m[0x8642] = (1,) # GL_VERTEX_PROGRAM_POINT_SIZE_ARB +_m[0x8642] = (1,) # GL_VERTEX_PROGRAM_POINT_SIZE_NV +_m[0x8643] = (1,) # GL_VERTEX_PROGRAM_TWO_SIDE +_m[0x8643] = (1,) # GL_VERTEX_PROGRAM_TWO_SIDE_ARB +_m[0x8643] = (1,) # GL_VERTEX_PROGRAM_TWO_SIDE_NV +_m[0x8B31] = (1,) # GL_VERTEX_SHADER +_m[0x8781] = (1,) # GL_VERTEX_SHADER_BINDING_EXT +_m[0x8780] = (1,) # GL_VERTEX_SHADER_EXT +_m[0x87CF] = (1,) # GL_VERTEX_SHADER_INSTRUCTIONS_EXT +_m[0x87D1] = (1,) # GL_VERTEX_SHADER_INVARIANTS_EXT +_m[0x87D3] = (1,) # GL_VERTEX_SHADER_LOCALS_EXT +_m[0x87D2] = (1,) # GL_VERTEX_SHADER_LOCAL_CONSTANTS_EXT +_m[0x87D4] = (1,) # GL_VERTEX_SHADER_OPTIMIZED_EXT +_m[0x87D0] = (1,) # GL_VERTEX_SHADER_VARIANTS_EXT +_m[0x829B] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_VERTEX_TEXTURE +_m[0x850C] = (1,) # GL_VERTEX_WEIGHT_ARRAY_EXT +_m[0x8510] = (1,) # GL_VERTEX_WEIGHT_ARRAY_POINTER_EXT +_m[0x850D] = (1,) # GL_VERTEX_WEIGHT_ARRAY_SIZE_EXT +_m[0x850F] = (1,) # GL_VERTEX_WEIGHT_ARRAY_STRIDE_EXT +_m[0x850E] = (1,) # GL_VERTEX_WEIGHT_ARRAY_TYPE_EXT +_m[0x8719] = (1,) # GL_VIBRANCE_BIAS_NV +_m[0x8713] = (1,) # GL_VIBRANCE_SCALE_NV +_m[0x9021] = (1,) # GL_VIDEO_BUFFER_BINDING_NV +_m[0x0BA2] = (4,) # GL_VIEWPORT +_m[0x825D] = (2,) # GL_VIEWPORT_BOUNDS_RANGE +_m[0x825F] = (1,) # GL_VIEWPORT_INDEX_PROVOKING_VERTEX +_m[0x937D] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_clip_space_w_scaling.txt # GL_VIEWPORT_POSITION_W_SCALE_X_COEFF_NV +_m[0x937E] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_clip_space_w_scaling.txt # GL_VIEWPORT_POSITION_W_SCALE_Y_COEFF_NV +_m[0x825C] = (1,) # GL_VIEWPORT_SUBPIXEL_BITS +_m[0x935B] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_viewport_swizzle.txt # GL_VIEWPORT_SWIZZLE_W_NV +_m[0x9358] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_viewport_swizzle.txt # GL_VIEWPORT_SWIZZLE_X_NV +_m[0x9359] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_viewport_swizzle.txt # GL_VIEWPORT_SWIZZLE_Y_NV +_m[0x935A] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_viewport_swizzle.txt # GL_VIEWPORT_SWIZZLE_Z_NV +_m[0x82B6] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_VIEW_COMPATIBILITY_CLASS +_m[0x933A] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/shader_thread_group.txt # GL_WARPS_PER_SM_NV +_m[0x9339] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/shader_thread_group.txt # GL_WARP_SIZE_NV +_m[0x86AD] = (1,) # GL_WEIGHT_ARRAY_ARB +_m[0x889E] = (1,) # GL_WEIGHT_ARRAY_BUFFER_BINDING +_m[0x889E] = (1,) # GL_WEIGHT_ARRAY_BUFFER_BINDING_ARB +_m[0x86AC] = (1,) # GL_WEIGHT_ARRAY_POINTER_ARB +_m[0x86AC] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/OES/OES_matrix_palette.txt # GL_WEIGHT_ARRAY_POINTER_OES +_m[0x86AB] = (1,) # GL_WEIGHT_ARRAY_SIZE_ARB +_m[0x86AB] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/OES/OES_matrix_palette.txt # GL_WEIGHT_ARRAY_SIZE_OES +_m[0x86AA] = (1,) # GL_WEIGHT_ARRAY_STRIDE_ARB +_m[0x86AA] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/OES/OES_matrix_palette.txt # GL_WEIGHT_ARRAY_STRIDE_OES +_m[0x86A9] = (1,) # GL_WEIGHT_ARRAY_TYPE_ARB +_m[0x86A9] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/OES/OES_matrix_palette.txt # GL_WEIGHT_ARRAY_TYPE_OES +_m[0x86A6] = (1,) # GL_WEIGHT_SUM_UNITY_ARB +_m[0x8F12] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/EXT/EXT_window_rectangles.txt # GL_WINDOW_RECTANGLE_EXT +_m[0x8F13] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/EXT/EXT_window_rectangles.txt # GL_WINDOW_RECTANGLE_MODE_EXT +_m[0x887A] = (1,) # GL_WRITE_PIXEL_DATA_RANGE_LENGTH_NV +_m[0x887C] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/pixel_data_range.txt # GL_WRITE_PIXEL_DATA_RANGE_POINTER_NV +_m[0x0D16] = (1,) # GL_ZOOM_X +_m[0x0D17] = (1,) # GL_ZOOM_Y diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/_types.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/_types.py new file mode 100644 index 00000000..5d214609 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES1/_types.py @@ -0,0 +1,4 @@ +from OpenGL.raw.GL._types import * +from OpenGL.raw.GL import _types as _base +GLfixed = _base._defineType('GLfixed', ctypes.c_int32, int ) +GLclampx = _base._defineType('GLclampx', ctypes.c_int32, int ) diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/AMD/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/AMD/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/AMD/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/AMD/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/AMD/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..b4f08c83 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/AMD/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/AMD/__pycache__/compressed_3DC_texture.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/AMD/__pycache__/compressed_3DC_texture.cpython-312.pyc new file mode 100644 index 00000000..5f8ce37f Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/AMD/__pycache__/compressed_3DC_texture.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/AMD/__pycache__/compressed_ATC_texture.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/AMD/__pycache__/compressed_ATC_texture.cpython-312.pyc new file mode 100644 index 00000000..10c10360 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/AMD/__pycache__/compressed_ATC_texture.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/AMD/__pycache__/framebuffer_multisample_advanced.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/AMD/__pycache__/framebuffer_multisample_advanced.cpython-312.pyc new file mode 100644 index 00000000..ee26b468 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/AMD/__pycache__/framebuffer_multisample_advanced.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/AMD/__pycache__/performance_monitor.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/AMD/__pycache__/performance_monitor.cpython-312.pyc new file mode 100644 index 00000000..69a437a2 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/AMD/__pycache__/performance_monitor.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/AMD/__pycache__/program_binary_Z400.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/AMD/__pycache__/program_binary_Z400.cpython-312.pyc new file mode 100644 index 00000000..ab46e966 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/AMD/__pycache__/program_binary_Z400.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/AMD/compressed_3DC_texture.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/AMD/compressed_3DC_texture.py new file mode 100644 index 00000000..0ad28979 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/AMD/compressed_3DC_texture.py @@ -0,0 +1,16 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_AMD_compressed_3DC_texture' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_AMD_compressed_3DC_texture',error_checker=_errors._error_checker) +GL_3DC_XY_AMD=_C('GL_3DC_XY_AMD',0x87FA) +GL_3DC_X_AMD=_C('GL_3DC_X_AMD',0x87F9) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/AMD/compressed_ATC_texture.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/AMD/compressed_ATC_texture.py new file mode 100644 index 00000000..0241c28e --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/AMD/compressed_ATC_texture.py @@ -0,0 +1,17 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_AMD_compressed_ATC_texture' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_AMD_compressed_ATC_texture',error_checker=_errors._error_checker) +GL_ATC_RGBA_EXPLICIT_ALPHA_AMD=_C('GL_ATC_RGBA_EXPLICIT_ALPHA_AMD',0x8C93) +GL_ATC_RGBA_INTERPOLATED_ALPHA_AMD=_C('GL_ATC_RGBA_INTERPOLATED_ALPHA_AMD',0x87EE) +GL_ATC_RGB_AMD=_C('GL_ATC_RGB_AMD',0x8C92) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/AMD/framebuffer_multisample_advanced.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/AMD/framebuffer_multisample_advanced.py new file mode 100644 index 00000000..8c6c3e22 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/AMD/framebuffer_multisample_advanced.py @@ -0,0 +1,25 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_AMD_framebuffer_multisample_advanced' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_AMD_framebuffer_multisample_advanced',error_checker=_errors._error_checker) +GL_MAX_COLOR_FRAMEBUFFER_SAMPLES_AMD=_C('GL_MAX_COLOR_FRAMEBUFFER_SAMPLES_AMD',0x91B3) +GL_MAX_COLOR_FRAMEBUFFER_STORAGE_SAMPLES_AMD=_C('GL_MAX_COLOR_FRAMEBUFFER_STORAGE_SAMPLES_AMD',0x91B4) +GL_MAX_DEPTH_STENCIL_FRAMEBUFFER_SAMPLES_AMD=_C('GL_MAX_DEPTH_STENCIL_FRAMEBUFFER_SAMPLES_AMD',0x91B5) +GL_NUM_SUPPORTED_MULTISAMPLE_MODES_AMD=_C('GL_NUM_SUPPORTED_MULTISAMPLE_MODES_AMD',0x91B6) +GL_RENDERBUFFER_STORAGE_SAMPLES_AMD=_C('GL_RENDERBUFFER_STORAGE_SAMPLES_AMD',0x91B2) +GL_SUPPORTED_MULTISAMPLE_MODES_AMD=_C('GL_SUPPORTED_MULTISAMPLE_MODES_AMD',0x91B7) +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizei,_cs.GLsizei,_cs.GLenum,_cs.GLsizei,_cs.GLsizei) +def glNamedRenderbufferStorageMultisampleAdvancedAMD(renderbuffer,samples,storageSamples,internalformat,width,height):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizei,_cs.GLsizei,_cs.GLenum,_cs.GLsizei,_cs.GLsizei) +def glRenderbufferStorageMultisampleAdvancedAMD(target,samples,storageSamples,internalformat,width,height):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/AMD/performance_monitor.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/AMD/performance_monitor.py new file mode 100644 index 00000000..4b5cb0ec --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/AMD/performance_monitor.py @@ -0,0 +1,53 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_AMD_performance_monitor' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_AMD_performance_monitor',error_checker=_errors._error_checker) +GL_COUNTER_RANGE_AMD=_C('GL_COUNTER_RANGE_AMD',0x8BC1) +GL_COUNTER_TYPE_AMD=_C('GL_COUNTER_TYPE_AMD',0x8BC0) +GL_PERCENTAGE_AMD=_C('GL_PERCENTAGE_AMD',0x8BC3) +GL_PERFMON_RESULT_AMD=_C('GL_PERFMON_RESULT_AMD',0x8BC6) +GL_PERFMON_RESULT_AVAILABLE_AMD=_C('GL_PERFMON_RESULT_AVAILABLE_AMD',0x8BC4) +GL_PERFMON_RESULT_SIZE_AMD=_C('GL_PERFMON_RESULT_SIZE_AMD',0x8BC5) +GL_UNSIGNED_INT64_AMD=_C('GL_UNSIGNED_INT64_AMD',0x8BC2) +@_f +@_p.types(None,_cs.GLuint) +def glBeginPerfMonitorAMD(monitor):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray) +def glDeletePerfMonitorsAMD(n,monitors):pass +@_f +@_p.types(None,_cs.GLuint) +def glEndPerfMonitorAMD(monitor):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray) +def glGenPerfMonitorsAMD(n,monitors):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLsizei,arrays.GLuintArray,arrays.GLintArray) +def glGetPerfMonitorCounterDataAMD(monitor,pname,dataSize,data,bytesWritten):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLenum,ctypes.c_void_p) +def glGetPerfMonitorCounterInfoAMD(group,counter,pname,data):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLsizei,arrays.GLsizeiArray,arrays.GLcharArray) +def glGetPerfMonitorCounterStringAMD(group,counter,bufSize,length,counterString):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLintArray,arrays.GLintArray,_cs.GLsizei,arrays.GLuintArray) +def glGetPerfMonitorCountersAMD(group,numCounters,maxActiveCounters,counterSize,counters):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizei,arrays.GLsizeiArray,arrays.GLcharArray) +def glGetPerfMonitorGroupStringAMD(group,bufSize,length,groupString):pass +@_f +@_p.types(None,arrays.GLintArray,_cs.GLsizei,arrays.GLuintArray) +def glGetPerfMonitorGroupsAMD(numGroups,groupsSize,groups):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLboolean,_cs.GLuint,_cs.GLint,arrays.GLuintArray) +def glSelectPerfMonitorCountersAMD(monitor,enable,group,numCounters,counterList):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/AMD/program_binary_Z400.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/AMD/program_binary_Z400.py new file mode 100644 index 00000000..1afcf2a7 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/AMD/program_binary_Z400.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_AMD_program_binary_Z400' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_AMD_program_binary_Z400',error_checker=_errors._error_checker) +GL_Z400_BINARY_AMD=_C('GL_Z400_BINARY_AMD',0x8740) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/ANDROID/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/ANDROID/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/ANDROID/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/ANDROID/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/ANDROID/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..b4716b47 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/ANDROID/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/ANDROID/__pycache__/extension_pack_es31a.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/ANDROID/__pycache__/extension_pack_es31a.cpython-312.pyc new file mode 100644 index 00000000..64060093 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/ANDROID/__pycache__/extension_pack_es31a.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/ANDROID/extension_pack_es31a.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/ANDROID/extension_pack_es31a.py new file mode 100644 index 00000000..8ba8e9c1 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/ANDROID/extension_pack_es31a.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_ANDROID_extension_pack_es31a' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_ANDROID_extension_pack_es31a',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/ANGLE/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/ANGLE/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/ANGLE/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/ANGLE/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/ANGLE/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..e22c48cd Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/ANGLE/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/ANGLE/__pycache__/depth_texture.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/ANGLE/__pycache__/depth_texture.cpython-312.pyc new file mode 100644 index 00000000..c5e54391 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/ANGLE/__pycache__/depth_texture.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/ANGLE/__pycache__/framebuffer_blit.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/ANGLE/__pycache__/framebuffer_blit.cpython-312.pyc new file mode 100644 index 00000000..495d6da4 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/ANGLE/__pycache__/framebuffer_blit.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/ANGLE/__pycache__/framebuffer_multisample.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/ANGLE/__pycache__/framebuffer_multisample.cpython-312.pyc new file mode 100644 index 00000000..19a17301 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/ANGLE/__pycache__/framebuffer_multisample.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/ANGLE/__pycache__/instanced_arrays.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/ANGLE/__pycache__/instanced_arrays.cpython-312.pyc new file mode 100644 index 00000000..315a21f5 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/ANGLE/__pycache__/instanced_arrays.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/ANGLE/__pycache__/pack_reverse_row_order.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/ANGLE/__pycache__/pack_reverse_row_order.cpython-312.pyc new file mode 100644 index 00000000..7c35541b Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/ANGLE/__pycache__/pack_reverse_row_order.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/ANGLE/__pycache__/program_binary.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/ANGLE/__pycache__/program_binary.cpython-312.pyc new file mode 100644 index 00000000..bdf480ea Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/ANGLE/__pycache__/program_binary.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/ANGLE/__pycache__/texture_compression_dxt3.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/ANGLE/__pycache__/texture_compression_dxt3.cpython-312.pyc new file mode 100644 index 00000000..8d14c49f Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/ANGLE/__pycache__/texture_compression_dxt3.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/ANGLE/__pycache__/texture_compression_dxt5.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/ANGLE/__pycache__/texture_compression_dxt5.cpython-312.pyc new file mode 100644 index 00000000..7e49654a Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/ANGLE/__pycache__/texture_compression_dxt5.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/ANGLE/__pycache__/texture_usage.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/ANGLE/__pycache__/texture_usage.cpython-312.pyc new file mode 100644 index 00000000..d1338e03 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/ANGLE/__pycache__/texture_usage.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/ANGLE/__pycache__/translated_shader_source.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/ANGLE/__pycache__/translated_shader_source.cpython-312.pyc new file mode 100644 index 00000000..d87990d3 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/ANGLE/__pycache__/translated_shader_source.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/ANGLE/depth_texture.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/ANGLE/depth_texture.py new file mode 100644 index 00000000..7741137b --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/ANGLE/depth_texture.py @@ -0,0 +1,22 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_ANGLE_depth_texture' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_ANGLE_depth_texture',error_checker=_errors._error_checker) +GL_DEPTH24_STENCIL8_OES=_C('GL_DEPTH24_STENCIL8_OES',0x88F0) +GL_DEPTH_COMPONENT=_C('GL_DEPTH_COMPONENT',0x1902) +GL_DEPTH_COMPONENT16=_C('GL_DEPTH_COMPONENT16',0x81A5) +GL_DEPTH_COMPONENT32_OES=_C('GL_DEPTH_COMPONENT32_OES',0x81A7) +GL_DEPTH_STENCIL_OES=_C('GL_DEPTH_STENCIL_OES',0x84F9) +GL_UNSIGNED_INT=_C('GL_UNSIGNED_INT',0x1405) +GL_UNSIGNED_INT_24_8_OES=_C('GL_UNSIGNED_INT_24_8_OES',0x84FA) +GL_UNSIGNED_SHORT=_C('GL_UNSIGNED_SHORT',0x1403) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/ANGLE/framebuffer_blit.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/ANGLE/framebuffer_blit.py new file mode 100644 index 00000000..dc9f75fc --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/ANGLE/framebuffer_blit.py @@ -0,0 +1,20 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_ANGLE_framebuffer_blit' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_ANGLE_framebuffer_blit',error_checker=_errors._error_checker) +GL_DRAW_FRAMEBUFFER_ANGLE=_C('GL_DRAW_FRAMEBUFFER_ANGLE',0x8CA9) +GL_DRAW_FRAMEBUFFER_BINDING_ANGLE=_C('GL_DRAW_FRAMEBUFFER_BINDING_ANGLE',0x8CA6) +GL_READ_FRAMEBUFFER_ANGLE=_C('GL_READ_FRAMEBUFFER_ANGLE',0x8CA8) +GL_READ_FRAMEBUFFER_BINDING_ANGLE=_C('GL_READ_FRAMEBUFFER_BINDING_ANGLE',0x8CAA) +@_f +@_p.types(None,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLbitfield,_cs.GLenum) +def glBlitFramebufferANGLE(srcX0,srcY0,srcX1,srcY1,dstX0,dstY0,dstX1,dstY1,mask,filter):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/ANGLE/framebuffer_multisample.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/ANGLE/framebuffer_multisample.py new file mode 100644 index 00000000..e822db29 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/ANGLE/framebuffer_multisample.py @@ -0,0 +1,19 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_ANGLE_framebuffer_multisample' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_ANGLE_framebuffer_multisample',error_checker=_errors._error_checker) +GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_ANGLE=_C('GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_ANGLE',0x8D56) +GL_MAX_SAMPLES_ANGLE=_C('GL_MAX_SAMPLES_ANGLE',0x8D57) +GL_RENDERBUFFER_SAMPLES_ANGLE=_C('GL_RENDERBUFFER_SAMPLES_ANGLE',0x8CAB) +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizei,_cs.GLenum,_cs.GLsizei,_cs.GLsizei) +def glRenderbufferStorageMultisampleANGLE(target,samples,internalformat,width,height):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/ANGLE/instanced_arrays.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/ANGLE/instanced_arrays.py new file mode 100644 index 00000000..a0ac5ad3 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/ANGLE/instanced_arrays.py @@ -0,0 +1,23 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_ANGLE_instanced_arrays' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_ANGLE_instanced_arrays',error_checker=_errors._error_checker) +GL_VERTEX_ATTRIB_ARRAY_DIVISOR_ANGLE=_C('GL_VERTEX_ATTRIB_ARRAY_DIVISOR_ANGLE',0x88FE) +@_f +@_p.types(None,_cs.GLenum,_cs.GLint,_cs.GLsizei,_cs.GLsizei) +def glDrawArraysInstancedANGLE(mode,first,count,primcount):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizei,_cs.GLenum,ctypes.c_void_p,_cs.GLsizei) +def glDrawElementsInstancedANGLE(mode,count,type,indices,primcount):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint) +def glVertexAttribDivisorANGLE(index,divisor):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/ANGLE/pack_reverse_row_order.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/ANGLE/pack_reverse_row_order.py new file mode 100644 index 00000000..041b7b4e --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/ANGLE/pack_reverse_row_order.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_ANGLE_pack_reverse_row_order' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_ANGLE_pack_reverse_row_order',error_checker=_errors._error_checker) +GL_PACK_REVERSE_ROW_ORDER_ANGLE=_C('GL_PACK_REVERSE_ROW_ORDER_ANGLE',0x93A4) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/ANGLE/program_binary.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/ANGLE/program_binary.py new file mode 100644 index 00000000..b19a39a7 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/ANGLE/program_binary.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_ANGLE_program_binary' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_ANGLE_program_binary',error_checker=_errors._error_checker) +GL_PROGRAM_BINARY_ANGLE=_C('GL_PROGRAM_BINARY_ANGLE',0x93A6) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/ANGLE/texture_compression_dxt3.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/ANGLE/texture_compression_dxt3.py new file mode 100644 index 00000000..73b56ede --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/ANGLE/texture_compression_dxt3.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_ANGLE_texture_compression_dxt3' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_ANGLE_texture_compression_dxt3',error_checker=_errors._error_checker) +GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE=_C('GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE',0x83F2) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/ANGLE/texture_compression_dxt5.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/ANGLE/texture_compression_dxt5.py new file mode 100644 index 00000000..b225e5b6 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/ANGLE/texture_compression_dxt5.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_ANGLE_texture_compression_dxt5' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_ANGLE_texture_compression_dxt5',error_checker=_errors._error_checker) +GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE=_C('GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE',0x83F3) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/ANGLE/texture_usage.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/ANGLE/texture_usage.py new file mode 100644 index 00000000..88ef32b4 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/ANGLE/texture_usage.py @@ -0,0 +1,16 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_ANGLE_texture_usage' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_ANGLE_texture_usage',error_checker=_errors._error_checker) +GL_FRAMEBUFFER_ATTACHMENT_ANGLE=_C('GL_FRAMEBUFFER_ATTACHMENT_ANGLE',0x93A3) +GL_TEXTURE_USAGE_ANGLE=_C('GL_TEXTURE_USAGE_ANGLE',0x93A2) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/ANGLE/translated_shader_source.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/ANGLE/translated_shader_source.py new file mode 100644 index 00000000..6fc11385 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/ANGLE/translated_shader_source.py @@ -0,0 +1,17 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_ANGLE_translated_shader_source' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_ANGLE_translated_shader_source',error_checker=_errors._error_checker) +GL_TRANSLATED_SHADER_SOURCE_LENGTH_ANGLE=_C('GL_TRANSLATED_SHADER_SOURCE_LENGTH_ANGLE',0x93A0) +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizei,arrays.GLsizeiArray,arrays.GLcharArray) +def glGetTranslatedShaderSourceANGLE(shader,bufsize,length,source):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/APPLE/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/APPLE/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/APPLE/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/APPLE/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/APPLE/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..3a70d185 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/APPLE/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/APPLE/__pycache__/clip_distance.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/APPLE/__pycache__/clip_distance.cpython-312.pyc new file mode 100644 index 00000000..d7b40912 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/APPLE/__pycache__/clip_distance.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/APPLE/__pycache__/color_buffer_packed_float.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/APPLE/__pycache__/color_buffer_packed_float.cpython-312.pyc new file mode 100644 index 00000000..ac11c642 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/APPLE/__pycache__/color_buffer_packed_float.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/APPLE/__pycache__/copy_texture_levels.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/APPLE/__pycache__/copy_texture_levels.cpython-312.pyc new file mode 100644 index 00000000..2014eee9 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/APPLE/__pycache__/copy_texture_levels.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/APPLE/__pycache__/framebuffer_multisample.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/APPLE/__pycache__/framebuffer_multisample.cpython-312.pyc new file mode 100644 index 00000000..f203b09b Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/APPLE/__pycache__/framebuffer_multisample.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/APPLE/__pycache__/rgb_422.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/APPLE/__pycache__/rgb_422.cpython-312.pyc new file mode 100644 index 00000000..2bca6f0f Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/APPLE/__pycache__/rgb_422.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/APPLE/__pycache__/sync.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/APPLE/__pycache__/sync.cpython-312.pyc new file mode 100644 index 00000000..fac84d74 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/APPLE/__pycache__/sync.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/APPLE/__pycache__/texture_format_BGRA8888.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/APPLE/__pycache__/texture_format_BGRA8888.cpython-312.pyc new file mode 100644 index 00000000..068a1772 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/APPLE/__pycache__/texture_format_BGRA8888.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/APPLE/__pycache__/texture_max_level.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/APPLE/__pycache__/texture_max_level.cpython-312.pyc new file mode 100644 index 00000000..b39e9793 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/APPLE/__pycache__/texture_max_level.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/APPLE/__pycache__/texture_packed_float.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/APPLE/__pycache__/texture_packed_float.cpython-312.pyc new file mode 100644 index 00000000..b16bba22 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/APPLE/__pycache__/texture_packed_float.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/APPLE/clip_distance.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/APPLE/clip_distance.py new file mode 100644 index 00000000..23d088e4 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/APPLE/clip_distance.py @@ -0,0 +1,23 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_APPLE_clip_distance' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_APPLE_clip_distance',error_checker=_errors._error_checker) +GL_CLIP_DISTANCE0_APPLE=_C('GL_CLIP_DISTANCE0_APPLE',0x3000) +GL_CLIP_DISTANCE1_APPLE=_C('GL_CLIP_DISTANCE1_APPLE',0x3001) +GL_CLIP_DISTANCE2_APPLE=_C('GL_CLIP_DISTANCE2_APPLE',0x3002) +GL_CLIP_DISTANCE3_APPLE=_C('GL_CLIP_DISTANCE3_APPLE',0x3003) +GL_CLIP_DISTANCE4_APPLE=_C('GL_CLIP_DISTANCE4_APPLE',0x3004) +GL_CLIP_DISTANCE5_APPLE=_C('GL_CLIP_DISTANCE5_APPLE',0x3005) +GL_CLIP_DISTANCE6_APPLE=_C('GL_CLIP_DISTANCE6_APPLE',0x3006) +GL_CLIP_DISTANCE7_APPLE=_C('GL_CLIP_DISTANCE7_APPLE',0x3007) +GL_MAX_CLIP_DISTANCES_APPLE=_C('GL_MAX_CLIP_DISTANCES_APPLE',0x0D32) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/APPLE/color_buffer_packed_float.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/APPLE/color_buffer_packed_float.py new file mode 100644 index 00000000..7fb4b494 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/APPLE/color_buffer_packed_float.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_APPLE_color_buffer_packed_float' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_APPLE_color_buffer_packed_float',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/APPLE/copy_texture_levels.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/APPLE/copy_texture_levels.py new file mode 100644 index 00000000..aef1f8f6 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/APPLE/copy_texture_levels.py @@ -0,0 +1,17 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_APPLE_copy_texture_levels' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_APPLE_copy_texture_levels',error_checker=_errors._error_checker) + +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLint,_cs.GLsizei) +def glCopyTextureLevelsAPPLE(destinationTexture,sourceTexture,sourceBaseLevel,sourceLevelCount):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/APPLE/framebuffer_multisample.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/APPLE/framebuffer_multisample.py new file mode 100644 index 00000000..b1d0505a --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/APPLE/framebuffer_multisample.py @@ -0,0 +1,26 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_APPLE_framebuffer_multisample' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_APPLE_framebuffer_multisample',error_checker=_errors._error_checker) +GL_DRAW_FRAMEBUFFER_APPLE=_C('GL_DRAW_FRAMEBUFFER_APPLE',0x8CA9) +GL_DRAW_FRAMEBUFFER_BINDING_APPLE=_C('GL_DRAW_FRAMEBUFFER_BINDING_APPLE',0x8CA6) +GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_APPLE=_C('GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_APPLE',0x8D56) +GL_MAX_SAMPLES_APPLE=_C('GL_MAX_SAMPLES_APPLE',0x8D57) +GL_READ_FRAMEBUFFER_APPLE=_C('GL_READ_FRAMEBUFFER_APPLE',0x8CA8) +GL_READ_FRAMEBUFFER_BINDING_APPLE=_C('GL_READ_FRAMEBUFFER_BINDING_APPLE',0x8CAA) +GL_RENDERBUFFER_SAMPLES_APPLE=_C('GL_RENDERBUFFER_SAMPLES_APPLE',0x8CAB) +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizei,_cs.GLenum,_cs.GLsizei,_cs.GLsizei) +def glRenderbufferStorageMultisampleAPPLE(target,samples,internalformat,width,height):pass +@_f +@_p.types(None,) +def glResolveMultisampleFramebufferAPPLE():pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/APPLE/rgb_422.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/APPLE/rgb_422.py new file mode 100644 index 00000000..451d794e --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/APPLE/rgb_422.py @@ -0,0 +1,18 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_APPLE_rgb_422' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_APPLE_rgb_422',error_checker=_errors._error_checker) +GL_RGB_422_APPLE=_C('GL_RGB_422_APPLE',0x8A1F) +GL_RGB_RAW_422_APPLE=_C('GL_RGB_RAW_422_APPLE',0x8A51) +GL_UNSIGNED_SHORT_8_8_APPLE=_C('GL_UNSIGNED_SHORT_8_8_APPLE',0x85BA) +GL_UNSIGNED_SHORT_8_8_REV_APPLE=_C('GL_UNSIGNED_SHORT_8_8_REV_APPLE',0x85BB) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/APPLE/sync.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/APPLE/sync.py new file mode 100644 index 00000000..2ff732d6 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/APPLE/sync.py @@ -0,0 +1,50 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_APPLE_sync' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_APPLE_sync',error_checker=_errors._error_checker) +GL_ALREADY_SIGNALED_APPLE=_C('GL_ALREADY_SIGNALED_APPLE',0x911A) +GL_CONDITION_SATISFIED_APPLE=_C('GL_CONDITION_SATISFIED_APPLE',0x911C) +GL_MAX_SERVER_WAIT_TIMEOUT_APPLE=_C('GL_MAX_SERVER_WAIT_TIMEOUT_APPLE',0x9111) +GL_OBJECT_TYPE_APPLE=_C('GL_OBJECT_TYPE_APPLE',0x9112) +GL_SIGNALED_APPLE=_C('GL_SIGNALED_APPLE',0x9119) +GL_SYNC_CONDITION_APPLE=_C('GL_SYNC_CONDITION_APPLE',0x9113) +GL_SYNC_FENCE_APPLE=_C('GL_SYNC_FENCE_APPLE',0x9116) +GL_SYNC_FLAGS_APPLE=_C('GL_SYNC_FLAGS_APPLE',0x9115) +GL_SYNC_FLUSH_COMMANDS_BIT_APPLE=_C('GL_SYNC_FLUSH_COMMANDS_BIT_APPLE',0x00000001) +GL_SYNC_GPU_COMMANDS_COMPLETE_APPLE=_C('GL_SYNC_GPU_COMMANDS_COMPLETE_APPLE',0x9117) +GL_SYNC_OBJECT_APPLE=_C('GL_SYNC_OBJECT_APPLE',0x8A53) +GL_SYNC_STATUS_APPLE=_C('GL_SYNC_STATUS_APPLE',0x9114) +GL_TIMEOUT_EXPIRED_APPLE=_C('GL_TIMEOUT_EXPIRED_APPLE',0x911B) +GL_TIMEOUT_IGNORED_APPLE=_C('GL_TIMEOUT_IGNORED_APPLE',0xFFFFFFFFFFFFFFFF) +GL_UNSIGNALED_APPLE=_C('GL_UNSIGNALED_APPLE',0x9118) +GL_WAIT_FAILED_APPLE=_C('GL_WAIT_FAILED_APPLE',0x911D) +@_f +@_p.types(_cs.GLenum,_cs.GLsync,_cs.GLbitfield,_cs.GLuint64) +def glClientWaitSyncAPPLE(sync,flags,timeout):pass +@_f +@_p.types(None,_cs.GLsync) +def glDeleteSyncAPPLE(sync):pass +@_f +@_p.types(_cs.GLsync,_cs.GLenum,_cs.GLbitfield) +def glFenceSyncAPPLE(condition,flags):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLint64Array) +def glGetInteger64vAPPLE(pname,params):pass +@_f +@_p.types(None,_cs.GLsync,_cs.GLenum,_cs.GLsizei,arrays.GLsizeiArray,arrays.GLintArray) +def glGetSyncivAPPLE(sync,pname,bufSize,length,values):pass +@_f +@_p.types(_cs.GLboolean,_cs.GLsync) +def glIsSyncAPPLE(sync):pass +@_f +@_p.types(None,_cs.GLsync,_cs.GLbitfield,_cs.GLuint64) +def glWaitSyncAPPLE(sync,flags,timeout):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/APPLE/texture_format_BGRA8888.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/APPLE/texture_format_BGRA8888.py new file mode 100644 index 00000000..49abb319 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/APPLE/texture_format_BGRA8888.py @@ -0,0 +1,16 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_APPLE_texture_format_BGRA8888' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_APPLE_texture_format_BGRA8888',error_checker=_errors._error_checker) +GL_BGRA8_EXT=_C('GL_BGRA8_EXT',0x93A1) +GL_BGRA_EXT=_C('GL_BGRA_EXT',0x80E1) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/APPLE/texture_max_level.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/APPLE/texture_max_level.py new file mode 100644 index 00000000..7fbd8a41 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/APPLE/texture_max_level.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_APPLE_texture_max_level' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_APPLE_texture_max_level',error_checker=_errors._error_checker) +GL_TEXTURE_MAX_LEVEL_APPLE=_C('GL_TEXTURE_MAX_LEVEL_APPLE',0x813D) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/APPLE/texture_packed_float.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/APPLE/texture_packed_float.py new file mode 100644 index 00000000..50335bcd --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/APPLE/texture_packed_float.py @@ -0,0 +1,18 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_APPLE_texture_packed_float' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_APPLE_texture_packed_float',error_checker=_errors._error_checker) +GL_R11F_G11F_B10F_APPLE=_C('GL_R11F_G11F_B10F_APPLE',0x8C3A) +GL_RGB9_E5_APPLE=_C('GL_RGB9_E5_APPLE',0x8C3D) +GL_UNSIGNED_INT_10F_11F_11F_REV_APPLE=_C('GL_UNSIGNED_INT_10F_11F_11F_REV_APPLE',0x8C3B) +GL_UNSIGNED_INT_5_9_9_9_REV_APPLE=_C('GL_UNSIGNED_INT_5_9_9_9_REV_APPLE',0x8C3E) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/ARM/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/ARM/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/ARM/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/ARM/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/ARM/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..d3fd1c55 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/ARM/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/ARM/__pycache__/mali_program_binary.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/ARM/__pycache__/mali_program_binary.cpython-312.pyc new file mode 100644 index 00000000..f49f77ba Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/ARM/__pycache__/mali_program_binary.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/ARM/__pycache__/mali_shader_binary.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/ARM/__pycache__/mali_shader_binary.cpython-312.pyc new file mode 100644 index 00000000..cdbb4dbc Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/ARM/__pycache__/mali_shader_binary.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/ARM/__pycache__/rgba8.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/ARM/__pycache__/rgba8.cpython-312.pyc new file mode 100644 index 00000000..98e18468 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/ARM/__pycache__/rgba8.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/ARM/__pycache__/shader_framebuffer_fetch.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/ARM/__pycache__/shader_framebuffer_fetch.cpython-312.pyc new file mode 100644 index 00000000..e9e19c99 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/ARM/__pycache__/shader_framebuffer_fetch.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/ARM/__pycache__/shader_framebuffer_fetch_depth_stencil.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/ARM/__pycache__/shader_framebuffer_fetch_depth_stencil.cpython-312.pyc new file mode 100644 index 00000000..4b9fd29a Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/ARM/__pycache__/shader_framebuffer_fetch_depth_stencil.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/ARM/mali_program_binary.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/ARM/mali_program_binary.py new file mode 100644 index 00000000..a16a81aa --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/ARM/mali_program_binary.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_ARM_mali_program_binary' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_ARM_mali_program_binary',error_checker=_errors._error_checker) +GL_MALI_PROGRAM_BINARY_ARM=_C('GL_MALI_PROGRAM_BINARY_ARM',0x8F61) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/ARM/mali_shader_binary.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/ARM/mali_shader_binary.py new file mode 100644 index 00000000..762b2b8d --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/ARM/mali_shader_binary.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_ARM_mali_shader_binary' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_ARM_mali_shader_binary',error_checker=_errors._error_checker) +GL_MALI_SHADER_BINARY_ARM=_C('GL_MALI_SHADER_BINARY_ARM',0x8F60) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/ARM/rgba8.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/ARM/rgba8.py new file mode 100644 index 00000000..b2e32d89 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/ARM/rgba8.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_ARM_rgba8' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_ARM_rgba8',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/ARM/shader_framebuffer_fetch.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/ARM/shader_framebuffer_fetch.py new file mode 100644 index 00000000..92560656 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/ARM/shader_framebuffer_fetch.py @@ -0,0 +1,16 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_ARM_shader_framebuffer_fetch' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_ARM_shader_framebuffer_fetch',error_checker=_errors._error_checker) +GL_FETCH_PER_SAMPLE_ARM=_C('GL_FETCH_PER_SAMPLE_ARM',0x8F65) +GL_FRAGMENT_SHADER_FRAMEBUFFER_FETCH_MRT_ARM=_C('GL_FRAGMENT_SHADER_FRAMEBUFFER_FETCH_MRT_ARM',0x8F66) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/ARM/shader_framebuffer_fetch_depth_stencil.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/ARM/shader_framebuffer_fetch_depth_stencil.py new file mode 100644 index 00000000..7328d0c2 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/ARM/shader_framebuffer_fetch_depth_stencil.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_ARM_shader_framebuffer_fetch_depth_stencil' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_ARM_shader_framebuffer_fetch_depth_stencil',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/DMP/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/DMP/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/DMP/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/DMP/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/DMP/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..22f950dc Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/DMP/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/DMP/__pycache__/program_binary.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/DMP/__pycache__/program_binary.cpython-312.pyc new file mode 100644 index 00000000..5073c882 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/DMP/__pycache__/program_binary.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/DMP/__pycache__/shader_binary.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/DMP/__pycache__/shader_binary.cpython-312.pyc new file mode 100644 index 00000000..cfcd8341 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/DMP/__pycache__/shader_binary.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/DMP/program_binary.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/DMP/program_binary.py new file mode 100644 index 00000000..0b25e609 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/DMP/program_binary.py @@ -0,0 +1,17 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_DMP_program_binary' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_DMP_program_binary',error_checker=_errors._error_checker) +GL_DMP_PROGRAM_BINARY_DMP=_C('GL_DMP_PROGRAM_BINARY_DMP',0x9253) +GL_SMAPHS30_PROGRAM_BINARY_DMP=_C('GL_SMAPHS30_PROGRAM_BINARY_DMP',0x9251) +GL_SMAPHS_PROGRAM_BINARY_DMP=_C('GL_SMAPHS_PROGRAM_BINARY_DMP',0x9252) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/DMP/shader_binary.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/DMP/shader_binary.py new file mode 100644 index 00000000..e905da9c --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/DMP/shader_binary.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_DMP_shader_binary' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_DMP_shader_binary',error_checker=_errors._error_checker) +GL_SHADER_BINARY_DMP=_C('GL_SHADER_BINARY_DMP',0x9250) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/ES/VERSION_3_2.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/ES/VERSION_3_2.py new file mode 100644 index 00000000..3239279e --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/ES/VERSION_3_2.py @@ -0,0 +1,358 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_ES_VERSION_3_2' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_ES_VERSION_3_2',error_checker=_errors._error_checker) +GL_BUFFER=_C('GL_BUFFER',0x82E0) +GL_CCW=_C('GL_CCW',0x0901) +GL_CLAMP_TO_BORDER=_C('GL_CLAMP_TO_BORDER',0x812D) +GL_COLORBURN=_C('GL_COLORBURN',0x929A) +GL_COLORDODGE=_C('GL_COLORDODGE',0x9299) +GL_COMPRESSED_RGBA_ASTC_10x10=_C('GL_COMPRESSED_RGBA_ASTC_10x10',0x93BB) +GL_COMPRESSED_RGBA_ASTC_10x5=_C('GL_COMPRESSED_RGBA_ASTC_10x5',0x93B8) +GL_COMPRESSED_RGBA_ASTC_10x6=_C('GL_COMPRESSED_RGBA_ASTC_10x6',0x93B9) +GL_COMPRESSED_RGBA_ASTC_10x8=_C('GL_COMPRESSED_RGBA_ASTC_10x8',0x93BA) +GL_COMPRESSED_RGBA_ASTC_12x10=_C('GL_COMPRESSED_RGBA_ASTC_12x10',0x93BC) +GL_COMPRESSED_RGBA_ASTC_12x12=_C('GL_COMPRESSED_RGBA_ASTC_12x12',0x93BD) +GL_COMPRESSED_RGBA_ASTC_4x4=_C('GL_COMPRESSED_RGBA_ASTC_4x4',0x93B0) +GL_COMPRESSED_RGBA_ASTC_5x4=_C('GL_COMPRESSED_RGBA_ASTC_5x4',0x93B1) +GL_COMPRESSED_RGBA_ASTC_5x5=_C('GL_COMPRESSED_RGBA_ASTC_5x5',0x93B2) +GL_COMPRESSED_RGBA_ASTC_6x5=_C('GL_COMPRESSED_RGBA_ASTC_6x5',0x93B3) +GL_COMPRESSED_RGBA_ASTC_6x6=_C('GL_COMPRESSED_RGBA_ASTC_6x6',0x93B4) +GL_COMPRESSED_RGBA_ASTC_8x5=_C('GL_COMPRESSED_RGBA_ASTC_8x5',0x93B5) +GL_COMPRESSED_RGBA_ASTC_8x6=_C('GL_COMPRESSED_RGBA_ASTC_8x6',0x93B6) +GL_COMPRESSED_RGBA_ASTC_8x8=_C('GL_COMPRESSED_RGBA_ASTC_8x8',0x93B7) +GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10=_C('GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10',0x93DB) +GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5=_C('GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5',0x93D8) +GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6=_C('GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6',0x93D9) +GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8=_C('GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8',0x93DA) +GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10=_C('GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10',0x93DC) +GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12=_C('GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12',0x93DD) +GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4=_C('GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4',0x93D0) +GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4=_C('GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4',0x93D1) +GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5=_C('GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5',0x93D2) +GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5=_C('GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5',0x93D3) +GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6=_C('GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6',0x93D4) +GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5=_C('GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5',0x93D5) +GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6=_C('GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6',0x93D6) +GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8=_C('GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8',0x93D7) +GL_CONTEXT_FLAGS=_C('GL_CONTEXT_FLAGS',0x821E) +GL_CONTEXT_FLAG_DEBUG_BIT=_C('GL_CONTEXT_FLAG_DEBUG_BIT',0x00000002) +GL_CONTEXT_FLAG_ROBUST_ACCESS_BIT=_C('GL_CONTEXT_FLAG_ROBUST_ACCESS_BIT',0x00000004) +GL_CONTEXT_LOST=_C('GL_CONTEXT_LOST',0x0507) +GL_CW=_C('GL_CW',0x0900) +GL_DARKEN=_C('GL_DARKEN',0x9297) +GL_DEBUG_CALLBACK_FUNCTION=_C('GL_DEBUG_CALLBACK_FUNCTION',0x8244) +GL_DEBUG_CALLBACK_USER_PARAM=_C('GL_DEBUG_CALLBACK_USER_PARAM',0x8245) +GL_DEBUG_GROUP_STACK_DEPTH=_C('GL_DEBUG_GROUP_STACK_DEPTH',0x826D) +GL_DEBUG_LOGGED_MESSAGES=_C('GL_DEBUG_LOGGED_MESSAGES',0x9145) +GL_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH=_C('GL_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH',0x8243) +GL_DEBUG_OUTPUT=_C('GL_DEBUG_OUTPUT',0x92E0) +GL_DEBUG_OUTPUT_SYNCHRONOUS=_C('GL_DEBUG_OUTPUT_SYNCHRONOUS',0x8242) +GL_DEBUG_SEVERITY_HIGH=_C('GL_DEBUG_SEVERITY_HIGH',0x9146) +GL_DEBUG_SEVERITY_LOW=_C('GL_DEBUG_SEVERITY_LOW',0x9148) +GL_DEBUG_SEVERITY_MEDIUM=_C('GL_DEBUG_SEVERITY_MEDIUM',0x9147) +GL_DEBUG_SEVERITY_NOTIFICATION=_C('GL_DEBUG_SEVERITY_NOTIFICATION',0x826B) +GL_DEBUG_SOURCE_API=_C('GL_DEBUG_SOURCE_API',0x8246) +GL_DEBUG_SOURCE_APPLICATION=_C('GL_DEBUG_SOURCE_APPLICATION',0x824A) +GL_DEBUG_SOURCE_OTHER=_C('GL_DEBUG_SOURCE_OTHER',0x824B) +GL_DEBUG_SOURCE_SHADER_COMPILER=_C('GL_DEBUG_SOURCE_SHADER_COMPILER',0x8248) +GL_DEBUG_SOURCE_THIRD_PARTY=_C('GL_DEBUG_SOURCE_THIRD_PARTY',0x8249) +GL_DEBUG_SOURCE_WINDOW_SYSTEM=_C('GL_DEBUG_SOURCE_WINDOW_SYSTEM',0x8247) +GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR=_C('GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR',0x824D) +GL_DEBUG_TYPE_ERROR=_C('GL_DEBUG_TYPE_ERROR',0x824C) +GL_DEBUG_TYPE_MARKER=_C('GL_DEBUG_TYPE_MARKER',0x8268) +GL_DEBUG_TYPE_OTHER=_C('GL_DEBUG_TYPE_OTHER',0x8251) +GL_DEBUG_TYPE_PERFORMANCE=_C('GL_DEBUG_TYPE_PERFORMANCE',0x8250) +GL_DEBUG_TYPE_POP_GROUP=_C('GL_DEBUG_TYPE_POP_GROUP',0x826A) +GL_DEBUG_TYPE_PORTABILITY=_C('GL_DEBUG_TYPE_PORTABILITY',0x824F) +GL_DEBUG_TYPE_PUSH_GROUP=_C('GL_DEBUG_TYPE_PUSH_GROUP',0x8269) +GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR=_C('GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR',0x824E) +GL_DIFFERENCE=_C('GL_DIFFERENCE',0x929E) +GL_EQUAL=_C('GL_EQUAL',0x0202) +GL_EXCLUSION=_C('GL_EXCLUSION',0x92A0) +GL_FIRST_VERTEX_CONVENTION=_C('GL_FIRST_VERTEX_CONVENTION',0x8E4D) +GL_FRACTIONAL_EVEN=_C('GL_FRACTIONAL_EVEN',0x8E7C) +GL_FRACTIONAL_ODD=_C('GL_FRACTIONAL_ODD',0x8E7B) +GL_FRAGMENT_INTERPOLATION_OFFSET_BITS=_C('GL_FRAGMENT_INTERPOLATION_OFFSET_BITS',0x8E5D) +GL_FRAMEBUFFER_ATTACHMENT_LAYERED=_C('GL_FRAMEBUFFER_ATTACHMENT_LAYERED',0x8DA7) +GL_FRAMEBUFFER_DEFAULT_LAYERS=_C('GL_FRAMEBUFFER_DEFAULT_LAYERS',0x9312) +GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS=_C('GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS',0x8DA8) +GL_GEOMETRY_INPUT_TYPE=_C('GL_GEOMETRY_INPUT_TYPE',0x8917) +GL_GEOMETRY_OUTPUT_TYPE=_C('GL_GEOMETRY_OUTPUT_TYPE',0x8918) +GL_GEOMETRY_SHADER=_C('GL_GEOMETRY_SHADER',0x8DD9) +GL_GEOMETRY_SHADER_BIT=_C('GL_GEOMETRY_SHADER_BIT',0x00000004) +GL_GEOMETRY_SHADER_INVOCATIONS=_C('GL_GEOMETRY_SHADER_INVOCATIONS',0x887F) +GL_GEOMETRY_VERTICES_OUT=_C('GL_GEOMETRY_VERTICES_OUT',0x8916) +GL_GUILTY_CONTEXT_RESET=_C('GL_GUILTY_CONTEXT_RESET',0x8253) +GL_HARDLIGHT=_C('GL_HARDLIGHT',0x929B) +GL_HSL_COLOR=_C('GL_HSL_COLOR',0x92AF) +GL_HSL_HUE=_C('GL_HSL_HUE',0x92AD) +GL_HSL_LUMINOSITY=_C('GL_HSL_LUMINOSITY',0x92B0) +GL_HSL_SATURATION=_C('GL_HSL_SATURATION',0x92AE) +GL_IMAGE_BUFFER=_C('GL_IMAGE_BUFFER',0x9051) +GL_IMAGE_CUBE_MAP_ARRAY=_C('GL_IMAGE_CUBE_MAP_ARRAY',0x9054) +GL_INNOCENT_CONTEXT_RESET=_C('GL_INNOCENT_CONTEXT_RESET',0x8254) +GL_INT_IMAGE_BUFFER=_C('GL_INT_IMAGE_BUFFER',0x905C) +GL_INT_IMAGE_CUBE_MAP_ARRAY=_C('GL_INT_IMAGE_CUBE_MAP_ARRAY',0x905F) +GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY=_C('GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY',0x910C) +GL_INT_SAMPLER_BUFFER=_C('GL_INT_SAMPLER_BUFFER',0x8DD0) +GL_INT_SAMPLER_CUBE_MAP_ARRAY=_C('GL_INT_SAMPLER_CUBE_MAP_ARRAY',0x900E) +GL_ISOLINES=_C('GL_ISOLINES',0x8E7A) +GL_IS_PER_PATCH=_C('GL_IS_PER_PATCH',0x92E7) +GL_LAST_VERTEX_CONVENTION=_C('GL_LAST_VERTEX_CONVENTION',0x8E4E) +GL_LAYER_PROVOKING_VERTEX=_C('GL_LAYER_PROVOKING_VERTEX',0x825E) +GL_LIGHTEN=_C('GL_LIGHTEN',0x9298) +GL_LINES_ADJACENCY=_C('GL_LINES_ADJACENCY',0x000A) +GL_LINE_STRIP_ADJACENCY=_C('GL_LINE_STRIP_ADJACENCY',0x000B) +GL_LOSE_CONTEXT_ON_RESET=_C('GL_LOSE_CONTEXT_ON_RESET',0x8252) +GL_MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS=_C('GL_MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS',0x8A32) +GL_MAX_COMBINED_TESS_CONTROL_UNIFORM_COMPONENTS=_C('GL_MAX_COMBINED_TESS_CONTROL_UNIFORM_COMPONENTS',0x8E1E) +GL_MAX_COMBINED_TESS_EVALUATION_UNIFORM_COMPONENTS=_C('GL_MAX_COMBINED_TESS_EVALUATION_UNIFORM_COMPONENTS',0x8E1F) +GL_MAX_DEBUG_GROUP_STACK_DEPTH=_C('GL_MAX_DEBUG_GROUP_STACK_DEPTH',0x826C) +GL_MAX_DEBUG_LOGGED_MESSAGES=_C('GL_MAX_DEBUG_LOGGED_MESSAGES',0x9144) +GL_MAX_DEBUG_MESSAGE_LENGTH=_C('GL_MAX_DEBUG_MESSAGE_LENGTH',0x9143) +GL_MAX_FRAGMENT_INTERPOLATION_OFFSET=_C('GL_MAX_FRAGMENT_INTERPOLATION_OFFSET',0x8E5C) +GL_MAX_FRAMEBUFFER_LAYERS=_C('GL_MAX_FRAMEBUFFER_LAYERS',0x9317) +GL_MAX_GEOMETRY_ATOMIC_COUNTERS=_C('GL_MAX_GEOMETRY_ATOMIC_COUNTERS',0x92D5) +GL_MAX_GEOMETRY_ATOMIC_COUNTER_BUFFERS=_C('GL_MAX_GEOMETRY_ATOMIC_COUNTER_BUFFERS',0x92CF) +GL_MAX_GEOMETRY_IMAGE_UNIFORMS=_C('GL_MAX_GEOMETRY_IMAGE_UNIFORMS',0x90CD) +GL_MAX_GEOMETRY_INPUT_COMPONENTS=_C('GL_MAX_GEOMETRY_INPUT_COMPONENTS',0x9123) +GL_MAX_GEOMETRY_OUTPUT_COMPONENTS=_C('GL_MAX_GEOMETRY_OUTPUT_COMPONENTS',0x9124) +GL_MAX_GEOMETRY_OUTPUT_VERTICES=_C('GL_MAX_GEOMETRY_OUTPUT_VERTICES',0x8DE0) +GL_MAX_GEOMETRY_SHADER_INVOCATIONS=_C('GL_MAX_GEOMETRY_SHADER_INVOCATIONS',0x8E5A) +GL_MAX_GEOMETRY_SHADER_STORAGE_BLOCKS=_C('GL_MAX_GEOMETRY_SHADER_STORAGE_BLOCKS',0x90D7) +GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS=_C('GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS',0x8C29) +GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS=_C('GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS',0x8DE1) +GL_MAX_GEOMETRY_UNIFORM_BLOCKS=_C('GL_MAX_GEOMETRY_UNIFORM_BLOCKS',0x8A2C) +GL_MAX_GEOMETRY_UNIFORM_COMPONENTS=_C('GL_MAX_GEOMETRY_UNIFORM_COMPONENTS',0x8DDF) +GL_MAX_LABEL_LENGTH=_C('GL_MAX_LABEL_LENGTH',0x82E8) +GL_MAX_PATCH_VERTICES=_C('GL_MAX_PATCH_VERTICES',0x8E7D) +GL_MAX_TESS_CONTROL_ATOMIC_COUNTERS=_C('GL_MAX_TESS_CONTROL_ATOMIC_COUNTERS',0x92D3) +GL_MAX_TESS_CONTROL_ATOMIC_COUNTER_BUFFERS=_C('GL_MAX_TESS_CONTROL_ATOMIC_COUNTER_BUFFERS',0x92CD) +GL_MAX_TESS_CONTROL_IMAGE_UNIFORMS=_C('GL_MAX_TESS_CONTROL_IMAGE_UNIFORMS',0x90CB) +GL_MAX_TESS_CONTROL_INPUT_COMPONENTS=_C('GL_MAX_TESS_CONTROL_INPUT_COMPONENTS',0x886C) +GL_MAX_TESS_CONTROL_OUTPUT_COMPONENTS=_C('GL_MAX_TESS_CONTROL_OUTPUT_COMPONENTS',0x8E83) +GL_MAX_TESS_CONTROL_SHADER_STORAGE_BLOCKS=_C('GL_MAX_TESS_CONTROL_SHADER_STORAGE_BLOCKS',0x90D8) +GL_MAX_TESS_CONTROL_TEXTURE_IMAGE_UNITS=_C('GL_MAX_TESS_CONTROL_TEXTURE_IMAGE_UNITS',0x8E81) +GL_MAX_TESS_CONTROL_TOTAL_OUTPUT_COMPONENTS=_C('GL_MAX_TESS_CONTROL_TOTAL_OUTPUT_COMPONENTS',0x8E85) +GL_MAX_TESS_CONTROL_UNIFORM_BLOCKS=_C('GL_MAX_TESS_CONTROL_UNIFORM_BLOCKS',0x8E89) +GL_MAX_TESS_CONTROL_UNIFORM_COMPONENTS=_C('GL_MAX_TESS_CONTROL_UNIFORM_COMPONENTS',0x8E7F) +GL_MAX_TESS_EVALUATION_ATOMIC_COUNTERS=_C('GL_MAX_TESS_EVALUATION_ATOMIC_COUNTERS',0x92D4) +GL_MAX_TESS_EVALUATION_ATOMIC_COUNTER_BUFFERS=_C('GL_MAX_TESS_EVALUATION_ATOMIC_COUNTER_BUFFERS',0x92CE) +GL_MAX_TESS_EVALUATION_IMAGE_UNIFORMS=_C('GL_MAX_TESS_EVALUATION_IMAGE_UNIFORMS',0x90CC) +GL_MAX_TESS_EVALUATION_INPUT_COMPONENTS=_C('GL_MAX_TESS_EVALUATION_INPUT_COMPONENTS',0x886D) +GL_MAX_TESS_EVALUATION_OUTPUT_COMPONENTS=_C('GL_MAX_TESS_EVALUATION_OUTPUT_COMPONENTS',0x8E86) +GL_MAX_TESS_EVALUATION_SHADER_STORAGE_BLOCKS=_C('GL_MAX_TESS_EVALUATION_SHADER_STORAGE_BLOCKS',0x90D9) +GL_MAX_TESS_EVALUATION_TEXTURE_IMAGE_UNITS=_C('GL_MAX_TESS_EVALUATION_TEXTURE_IMAGE_UNITS',0x8E82) +GL_MAX_TESS_EVALUATION_UNIFORM_BLOCKS=_C('GL_MAX_TESS_EVALUATION_UNIFORM_BLOCKS',0x8E8A) +GL_MAX_TESS_EVALUATION_UNIFORM_COMPONENTS=_C('GL_MAX_TESS_EVALUATION_UNIFORM_COMPONENTS',0x8E80) +GL_MAX_TESS_GEN_LEVEL=_C('GL_MAX_TESS_GEN_LEVEL',0x8E7E) +GL_MAX_TESS_PATCH_COMPONENTS=_C('GL_MAX_TESS_PATCH_COMPONENTS',0x8E84) +GL_MAX_TEXTURE_BUFFER_SIZE=_C('GL_MAX_TEXTURE_BUFFER_SIZE',0x8C2B) +GL_MIN_FRAGMENT_INTERPOLATION_OFFSET=_C('GL_MIN_FRAGMENT_INTERPOLATION_OFFSET',0x8E5B) +GL_MIN_SAMPLE_SHADING_VALUE=_C('GL_MIN_SAMPLE_SHADING_VALUE',0x8C37) +GL_MULTIPLY=_C('GL_MULTIPLY',0x9294) +GL_MULTISAMPLE_LINE_WIDTH_GRANULARITY=_C('GL_MULTISAMPLE_LINE_WIDTH_GRANULARITY',0x9382) +GL_MULTISAMPLE_LINE_WIDTH_RANGE=_C('GL_MULTISAMPLE_LINE_WIDTH_RANGE',0x9381) +GL_NO_ERROR=_C('GL_NO_ERROR',0) +GL_NO_RESET_NOTIFICATION=_C('GL_NO_RESET_NOTIFICATION',0x8261) +GL_OVERLAY=_C('GL_OVERLAY',0x9296) +GL_PATCHES=_C('GL_PATCHES',0x000E) +GL_PATCH_VERTICES=_C('GL_PATCH_VERTICES',0x8E72) +GL_PRIMITIVES_GENERATED=_C('GL_PRIMITIVES_GENERATED',0x8C87) +GL_PRIMITIVE_BOUNDING_BOX=_C('GL_PRIMITIVE_BOUNDING_BOX',0x92BE) +GL_PRIMITIVE_RESTART_FOR_PATCHES_SUPPORTED=_C('GL_PRIMITIVE_RESTART_FOR_PATCHES_SUPPORTED',0x8221) +GL_PROGRAM=_C('GL_PROGRAM',0x82E2) +GL_PROGRAM_PIPELINE=_C('GL_PROGRAM_PIPELINE',0x82E4) +GL_QUADS=_C('GL_QUADS',0x0007) +GL_QUERY=_C('GL_QUERY',0x82E3) +GL_REFERENCED_BY_GEOMETRY_SHADER=_C('GL_REFERENCED_BY_GEOMETRY_SHADER',0x9309) +GL_REFERENCED_BY_TESS_CONTROL_SHADER=_C('GL_REFERENCED_BY_TESS_CONTROL_SHADER',0x9307) +GL_REFERENCED_BY_TESS_EVALUATION_SHADER=_C('GL_REFERENCED_BY_TESS_EVALUATION_SHADER',0x9308) +GL_RESET_NOTIFICATION_STRATEGY=_C('GL_RESET_NOTIFICATION_STRATEGY',0x8256) +GL_SAMPLER=_C('GL_SAMPLER',0x82E6) +GL_SAMPLER_2D_MULTISAMPLE_ARRAY=_C('GL_SAMPLER_2D_MULTISAMPLE_ARRAY',0x910B) +GL_SAMPLER_BUFFER=_C('GL_SAMPLER_BUFFER',0x8DC2) +GL_SAMPLER_CUBE_MAP_ARRAY=_C('GL_SAMPLER_CUBE_MAP_ARRAY',0x900C) +GL_SAMPLER_CUBE_MAP_ARRAY_SHADOW=_C('GL_SAMPLER_CUBE_MAP_ARRAY_SHADOW',0x900D) +GL_SAMPLE_SHADING=_C('GL_SAMPLE_SHADING',0x8C36) +GL_SCREEN=_C('GL_SCREEN',0x9295) +GL_SHADER=_C('GL_SHADER',0x82E1) +GL_SOFTLIGHT=_C('GL_SOFTLIGHT',0x929C) +GL_STACK_OVERFLOW=_C('GL_STACK_OVERFLOW',0x0503) +GL_STACK_UNDERFLOW=_C('GL_STACK_UNDERFLOW',0x0504) +GL_STENCIL_INDEX=_C('GL_STENCIL_INDEX',0x1901) +GL_STENCIL_INDEX8=_C('GL_STENCIL_INDEX8',0x8D48) +GL_TESS_CONTROL_OUTPUT_VERTICES=_C('GL_TESS_CONTROL_OUTPUT_VERTICES',0x8E75) +GL_TESS_CONTROL_SHADER=_C('GL_TESS_CONTROL_SHADER',0x8E88) +GL_TESS_CONTROL_SHADER_BIT=_C('GL_TESS_CONTROL_SHADER_BIT',0x00000008) +GL_TESS_EVALUATION_SHADER=_C('GL_TESS_EVALUATION_SHADER',0x8E87) +GL_TESS_EVALUATION_SHADER_BIT=_C('GL_TESS_EVALUATION_SHADER_BIT',0x00000010) +GL_TESS_GEN_MODE=_C('GL_TESS_GEN_MODE',0x8E76) +GL_TESS_GEN_POINT_MODE=_C('GL_TESS_GEN_POINT_MODE',0x8E79) +GL_TESS_GEN_SPACING=_C('GL_TESS_GEN_SPACING',0x8E77) +GL_TESS_GEN_VERTEX_ORDER=_C('GL_TESS_GEN_VERTEX_ORDER',0x8E78) +GL_TEXTURE_2D_MULTISAMPLE_ARRAY=_C('GL_TEXTURE_2D_MULTISAMPLE_ARRAY',0x9102) +GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY=_C('GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY',0x9105) +GL_TEXTURE_BINDING_BUFFER=_C('GL_TEXTURE_BINDING_BUFFER',0x8C2C) +GL_TEXTURE_BINDING_CUBE_MAP_ARRAY=_C('GL_TEXTURE_BINDING_CUBE_MAP_ARRAY',0x900A) +GL_TEXTURE_BORDER_COLOR=_C('GL_TEXTURE_BORDER_COLOR',0x1004) +GL_TEXTURE_BUFFER=_C('GL_TEXTURE_BUFFER',0x8C2A) +GL_TEXTURE_BUFFER_BINDING=_C('GL_TEXTURE_BUFFER_BINDING',0x8C2A) +GL_TEXTURE_BUFFER_DATA_STORE_BINDING=_C('GL_TEXTURE_BUFFER_DATA_STORE_BINDING',0x8C2D) +GL_TEXTURE_BUFFER_OFFSET=_C('GL_TEXTURE_BUFFER_OFFSET',0x919D) +GL_TEXTURE_BUFFER_OFFSET_ALIGNMENT=_C('GL_TEXTURE_BUFFER_OFFSET_ALIGNMENT',0x919F) +GL_TEXTURE_BUFFER_SIZE=_C('GL_TEXTURE_BUFFER_SIZE',0x919E) +GL_TEXTURE_CUBE_MAP_ARRAY=_C('GL_TEXTURE_CUBE_MAP_ARRAY',0x9009) +GL_TRIANGLES=_C('GL_TRIANGLES',0x0004) +GL_TRIANGLES_ADJACENCY=_C('GL_TRIANGLES_ADJACENCY',0x000C) +GL_TRIANGLE_STRIP_ADJACENCY=_C('GL_TRIANGLE_STRIP_ADJACENCY',0x000D) +GL_UNDEFINED_VERTEX=_C('GL_UNDEFINED_VERTEX',0x8260) +GL_UNKNOWN_CONTEXT_RESET=_C('GL_UNKNOWN_CONTEXT_RESET',0x8255) +GL_UNSIGNED_INT_IMAGE_BUFFER=_C('GL_UNSIGNED_INT_IMAGE_BUFFER',0x9067) +GL_UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY=_C('GL_UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY',0x906A) +GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY=_C('GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY',0x910D) +GL_UNSIGNED_INT_SAMPLER_BUFFER=_C('GL_UNSIGNED_INT_SAMPLER_BUFFER',0x8DD8) +GL_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY=_C('GL_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY',0x900F) +GL_VERTEX_ARRAY=_C('GL_VERTEX_ARRAY',0x8074) +@_f +@_p.types(None,) +def glBlendBarrier():pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLenum) +def glBlendEquationSeparatei(buf,modeRGB,modeAlpha):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum) +def glBlendEquationi(buf,mode):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLenum,_cs.GLenum,_cs.GLenum) +def glBlendFuncSeparatei(buf,srcRGB,dstRGB,srcAlpha,dstAlpha):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLenum) +def glBlendFunci(buf,src,dst):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLboolean,_cs.GLboolean,_cs.GLboolean,_cs.GLboolean) +def glColorMaski(index,r,g,b,a):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLuint,_cs.GLenum,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLsizei,_cs.GLsizei) +def glCopyImageSubData(srcName,srcTarget,srcLevel,srcX,srcY,srcZ,dstName,dstTarget,dstLevel,dstX,dstY,dstZ,srcWidth,srcHeight,srcDepth):pass +@_f +@_p.types(None,_cs.GLDEBUGPROC,ctypes.c_void_p) +def glDebugMessageCallback(callback,userParam):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLenum,_cs.GLsizei,arrays.GLuintArray,_cs.GLboolean) +def glDebugMessageControl(source,type,severity,count,ids,enabled):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLuint,_cs.GLenum,_cs.GLsizei,arrays.GLcharArray) +def glDebugMessageInsert(source,type,id,severity,length,buf):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint) +def glDisablei(target,index):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizei,_cs.GLenum,ctypes.c_void_p,_cs.GLint) +def glDrawElementsBaseVertex(mode,count,type,indices,basevertex):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizei,_cs.GLenum,ctypes.c_void_p,_cs.GLsizei,_cs.GLint) +def glDrawElementsInstancedBaseVertex(mode,count,type,indices,instancecount,basevertex):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,_cs.GLuint,_cs.GLsizei,_cs.GLenum,ctypes.c_void_p,_cs.GLint) +def glDrawRangeElementsBaseVertex(mode,start,end,count,type,indices,basevertex):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint) +def glEnablei(target,index):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLuint,_cs.GLint) +def glFramebufferTexture(target,attachment,texture,level):pass +@_f +@_p.types(_cs.GLuint,_cs.GLuint,_cs.GLsizei,arrays.GLuintArray,arrays.GLuintArray,arrays.GLuintArray,arrays.GLuintArray,arrays.GLsizeiArray,arrays.GLcharArray) +def glGetDebugMessageLog(count,bufSize,sources,types,ids,severities,lengths,messageLog):pass +@_f +@_p.types(_cs.GLenum,) +def glGetGraphicsResetStatus():pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,_cs.GLsizei,arrays.GLsizeiArray,arrays.GLcharArray) +def glGetObjectLabel(identifier,name,bufSize,length,label):pass +@_f +@_p.types(None,ctypes.c_void_p,_cs.GLsizei,arrays.GLsizeiArray,arrays.GLcharArray) +def glGetObjectPtrLabel(ptr,bufSize,length,label):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLvoidpArray) +def glGetPointerv(pname,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLintArray) +def glGetSamplerParameterIiv(sampler,pname,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLuintArray) +def glGetSamplerParameterIuiv(sampler,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLintArray) +def glGetTexParameterIiv(target,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLuintArray) +def glGetTexParameterIuiv(target,pname,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLfloatArray) +def glGetnUniformfv(program,location,bufSize,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLintArray) +def glGetnUniformiv(program,location,bufSize,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLuintArray) +def glGetnUniformuiv(program,location,bufSize,params):pass +@_f +@_p.types(_cs.GLboolean,_cs.GLenum,_cs.GLuint) +def glIsEnabledi(target,index):pass +@_f +@_p.types(None,_cs.GLfloat) +def glMinSampleShading(value):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,_cs.GLsizei,arrays.GLcharArray) +def glObjectLabel(identifier,name,length,label):pass +@_f +@_p.types(None,ctypes.c_void_p,_cs.GLsizei,arrays.GLcharArray) +def glObjectPtrLabel(ptr,length,label):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLint) +def glPatchParameteri(pname,value):pass +@_f +@_p.types(None,) +def glPopDebugGroup():pass +@_f +@_p.types(None,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat) +def glPrimitiveBoundingBox(minX,minY,minZ,minW,maxX,maxY,maxZ,maxW):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,_cs.GLsizei,arrays.GLcharArray) +def glPushDebugGroup(source,id,length,message):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLsizei,_cs.GLenum,_cs.GLenum,_cs.GLsizei,ctypes.c_void_p) +def glReadnPixels(x,y,width,height,format,type,bufSize,data):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLintArray) +def glSamplerParameterIiv(sampler,pname,param):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLuintArray) +def glSamplerParameterIuiv(sampler,pname,param):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLuint) +def glTexBuffer(target,internalformat,buffer):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLuint,_cs.GLintptr,_cs.GLsizeiptr) +def glTexBufferRange(target,internalformat,buffer,offset,size):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLintArray) +def glTexParameterIiv(target,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLuintArray) +def glTexParameterIuiv(target,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizei,_cs.GLenum,_cs.GLsizei,_cs.GLsizei,_cs.GLsizei,_cs.GLboolean) +def glTexStorage3DMultisample(target,samples,internalformat,width,height,depth,fixedsamplelocations):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/ES/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/ES/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/ES/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/ES/__pycache__/VERSION_3_2.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/ES/__pycache__/VERSION_3_2.cpython-312.pyc new file mode 100644 index 00000000..21a7fa86 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/ES/__pycache__/VERSION_3_2.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/ES/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/ES/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..d4a47dac Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/ES/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/EGL_image_array.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/EGL_image_array.py new file mode 100644 index 00000000..312d872b --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/EGL_image_array.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_EXT_EGL_image_array' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_EXT_EGL_image_array',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/EGL_image_storage.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/EGL_image_storage.py new file mode 100644 index 00000000..9cff04a3 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/EGL_image_storage.py @@ -0,0 +1,20 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_EXT_EGL_image_storage' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_EXT_EGL_image_storage',error_checker=_errors._error_checker) + +@_f +@_p.types(None,_cs.GLenum,_cs.GLeglImageOES,arrays.GLintArray) +def glEGLImageTargetTexStorageEXT(target,image,attrib_list):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLeglImageOES,arrays.GLintArray) +def glEGLImageTargetTextureStorageEXT(texture,image,attrib_list):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/YUV_target.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/YUV_target.py new file mode 100644 index 00000000..3df30e13 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/YUV_target.py @@ -0,0 +1,18 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_EXT_YUV_target' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_EXT_YUV_target',error_checker=_errors._error_checker) +GL_REQUIRED_TEXTURE_IMAGE_UNITS_OES=_C('GL_REQUIRED_TEXTURE_IMAGE_UNITS_OES',0x8D68) +GL_SAMPLER_EXTERNAL_2D_Y2Y_EXT=_C('GL_SAMPLER_EXTERNAL_2D_Y2Y_EXT',0x8BE7) +GL_TEXTURE_BINDING_EXTERNAL_OES=_C('GL_TEXTURE_BINDING_EXTERNAL_OES',0x8D67) +GL_TEXTURE_EXTERNAL_OES=_C('GL_TEXTURE_EXTERNAL_OES',0x8D65) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/EGL_image_array.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/EGL_image_array.cpython-312.pyc new file mode 100644 index 00000000..b24b1e3a Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/EGL_image_array.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/EGL_image_storage.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/EGL_image_storage.cpython-312.pyc new file mode 100644 index 00000000..78d11c9d Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/EGL_image_storage.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/YUV_target.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/YUV_target.cpython-312.pyc new file mode 100644 index 00000000..4e5ec5b7 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/YUV_target.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..c91b9cb9 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/base_instance.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/base_instance.cpython-312.pyc new file mode 100644 index 00000000..f67cc337 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/base_instance.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/blend_func_extended.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/blend_func_extended.cpython-312.pyc new file mode 100644 index 00000000..5c80cc92 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/blend_func_extended.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/blend_minmax.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/blend_minmax.cpython-312.pyc new file mode 100644 index 00000000..e499df0f Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/blend_minmax.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/buffer_storage.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/buffer_storage.cpython-312.pyc new file mode 100644 index 00000000..e014bc05 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/buffer_storage.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/clear_texture.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/clear_texture.cpython-312.pyc new file mode 100644 index 00000000..4c464912 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/clear_texture.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/clip_control.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/clip_control.cpython-312.pyc new file mode 100644 index 00000000..9305c734 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/clip_control.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/clip_cull_distance.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/clip_cull_distance.cpython-312.pyc new file mode 100644 index 00000000..224f8262 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/clip_cull_distance.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/color_buffer_float.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/color_buffer_float.cpython-312.pyc new file mode 100644 index 00000000..b0e41b33 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/color_buffer_float.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/color_buffer_half_float.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/color_buffer_half_float.cpython-312.pyc new file mode 100644 index 00000000..554d1930 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/color_buffer_half_float.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/conservative_depth.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/conservative_depth.cpython-312.pyc new file mode 100644 index 00000000..99851752 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/conservative_depth.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/copy_image.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/copy_image.cpython-312.pyc new file mode 100644 index 00000000..d6da7806 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/copy_image.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/debug_label.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/debug_label.cpython-312.pyc new file mode 100644 index 00000000..7ef14822 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/debug_label.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/debug_marker.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/debug_marker.cpython-312.pyc new file mode 100644 index 00000000..1efb2207 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/debug_marker.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/depth_clamp.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/depth_clamp.cpython-312.pyc new file mode 100644 index 00000000..0f70de6a Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/depth_clamp.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/discard_framebuffer.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/discard_framebuffer.cpython-312.pyc new file mode 100644 index 00000000..2c078bf3 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/discard_framebuffer.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/disjoint_timer_query.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/disjoint_timer_query.cpython-312.pyc new file mode 100644 index 00000000..1d795b10 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/disjoint_timer_query.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/draw_buffers.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/draw_buffers.cpython-312.pyc new file mode 100644 index 00000000..6a2d8c53 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/draw_buffers.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/draw_buffers_indexed.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/draw_buffers_indexed.cpython-312.pyc new file mode 100644 index 00000000..ef595c3f Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/draw_buffers_indexed.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/draw_elements_base_vertex.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/draw_elements_base_vertex.cpython-312.pyc new file mode 100644 index 00000000..00fe0595 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/draw_elements_base_vertex.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/draw_instanced.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/draw_instanced.cpython-312.pyc new file mode 100644 index 00000000..3a7fe7b2 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/draw_instanced.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/draw_transform_feedback.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/draw_transform_feedback.cpython-312.pyc new file mode 100644 index 00000000..8e65f029 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/draw_transform_feedback.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/external_buffer.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/external_buffer.cpython-312.pyc new file mode 100644 index 00000000..f59bfb5a Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/external_buffer.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/float_blend.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/float_blend.cpython-312.pyc new file mode 100644 index 00000000..4848ccdb Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/float_blend.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/geometry_point_size.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/geometry_point_size.cpython-312.pyc new file mode 100644 index 00000000..855fc08c Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/geometry_point_size.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/geometry_shader.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/geometry_shader.cpython-312.pyc new file mode 100644 index 00000000..f83fc847 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/geometry_shader.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/gpu_shader5.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/gpu_shader5.cpython-312.pyc new file mode 100644 index 00000000..4cff1965 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/gpu_shader5.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/instanced_arrays.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/instanced_arrays.cpython-312.pyc new file mode 100644 index 00000000..5e29ba81 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/instanced_arrays.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/map_buffer_range.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/map_buffer_range.cpython-312.pyc new file mode 100644 index 00000000..c206148e Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/map_buffer_range.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/memory_object.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/memory_object.cpython-312.pyc new file mode 100644 index 00000000..fa2dda4a Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/memory_object.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/memory_object_fd.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/memory_object_fd.cpython-312.pyc new file mode 100644 index 00000000..8e004e90 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/memory_object_fd.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/memory_object_win32.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/memory_object_win32.cpython-312.pyc new file mode 100644 index 00000000..430f9aae Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/memory_object_win32.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/multi_draw_arrays.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/multi_draw_arrays.cpython-312.pyc new file mode 100644 index 00000000..1765b34d Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/multi_draw_arrays.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/multi_draw_indirect.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/multi_draw_indirect.cpython-312.pyc new file mode 100644 index 00000000..f87abd32 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/multi_draw_indirect.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/multisampled_compatibility.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/multisampled_compatibility.cpython-312.pyc new file mode 100644 index 00000000..f97daf53 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/multisampled_compatibility.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/multisampled_render_to_texture.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/multisampled_render_to_texture.cpython-312.pyc new file mode 100644 index 00000000..428ecd54 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/multisampled_render_to_texture.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/multiview_draw_buffers.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/multiview_draw_buffers.cpython-312.pyc new file mode 100644 index 00000000..56266510 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/multiview_draw_buffers.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/multiview_tessellation_geometry_shader.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/multiview_tessellation_geometry_shader.cpython-312.pyc new file mode 100644 index 00000000..dff38fb3 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/multiview_tessellation_geometry_shader.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/multiview_texture_multisample.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/multiview_texture_multisample.cpython-312.pyc new file mode 100644 index 00000000..fb7e6454 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/multiview_texture_multisample.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/multiview_timer_query.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/multiview_timer_query.cpython-312.pyc new file mode 100644 index 00000000..7e7cb48f Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/multiview_timer_query.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/occlusion_query_boolean.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/occlusion_query_boolean.cpython-312.pyc new file mode 100644 index 00000000..0aa8873a Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/occlusion_query_boolean.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/polygon_offset_clamp.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/polygon_offset_clamp.cpython-312.pyc new file mode 100644 index 00000000..1082db55 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/polygon_offset_clamp.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/post_depth_coverage.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/post_depth_coverage.cpython-312.pyc new file mode 100644 index 00000000..7a8b97cc Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/post_depth_coverage.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/primitive_bounding_box.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/primitive_bounding_box.cpython-312.pyc new file mode 100644 index 00000000..71140c7a Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/primitive_bounding_box.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/protected_textures.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/protected_textures.cpython-312.pyc new file mode 100644 index 00000000..44fa568f Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/protected_textures.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/pvrtc_sRGB.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/pvrtc_sRGB.cpython-312.pyc new file mode 100644 index 00000000..81dfd36a Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/pvrtc_sRGB.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/raster_multisample.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/raster_multisample.cpython-312.pyc new file mode 100644 index 00000000..eae60c47 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/raster_multisample.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/read_format_bgra.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/read_format_bgra.cpython-312.pyc new file mode 100644 index 00000000..da4be3d8 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/read_format_bgra.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/render_snorm.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/render_snorm.cpython-312.pyc new file mode 100644 index 00000000..c14d062f Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/render_snorm.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/robustness.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/robustness.cpython-312.pyc new file mode 100644 index 00000000..8c11f0d4 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/robustness.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/sRGB.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/sRGB.cpython-312.pyc new file mode 100644 index 00000000..e791e939 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/sRGB.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/sRGB_write_control.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/sRGB_write_control.cpython-312.pyc new file mode 100644 index 00000000..17291ad0 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/sRGB_write_control.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/semaphore.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/semaphore.cpython-312.pyc new file mode 100644 index 00000000..603c5838 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/semaphore.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/semaphore_fd.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/semaphore_fd.cpython-312.pyc new file mode 100644 index 00000000..d74bb55f Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/semaphore_fd.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/semaphore_win32.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/semaphore_win32.cpython-312.pyc new file mode 100644 index 00000000..9effa4d2 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/semaphore_win32.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/separate_shader_objects.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/separate_shader_objects.cpython-312.pyc new file mode 100644 index 00000000..96913d15 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/separate_shader_objects.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/shader_framebuffer_fetch.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/shader_framebuffer_fetch.cpython-312.pyc new file mode 100644 index 00000000..5edd237d Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/shader_framebuffer_fetch.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/shader_framebuffer_fetch_non_coherent.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/shader_framebuffer_fetch_non_coherent.cpython-312.pyc new file mode 100644 index 00000000..0caec370 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/shader_framebuffer_fetch_non_coherent.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/shader_group_vote.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/shader_group_vote.cpython-312.pyc new file mode 100644 index 00000000..dff38ae5 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/shader_group_vote.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/shader_implicit_conversions.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/shader_implicit_conversions.cpython-312.pyc new file mode 100644 index 00000000..703f7fc5 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/shader_implicit_conversions.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/shader_integer_mix.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/shader_integer_mix.cpython-312.pyc new file mode 100644 index 00000000..442e0fac Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/shader_integer_mix.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/shader_io_blocks.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/shader_io_blocks.cpython-312.pyc new file mode 100644 index 00000000..651ec027 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/shader_io_blocks.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/shader_non_constant_global_initializers.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/shader_non_constant_global_initializers.cpython-312.pyc new file mode 100644 index 00000000..d64f9404 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/shader_non_constant_global_initializers.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/shader_pixel_local_storage.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/shader_pixel_local_storage.cpython-312.pyc new file mode 100644 index 00000000..d7bbc648 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/shader_pixel_local_storage.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/shader_pixel_local_storage2.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/shader_pixel_local_storage2.cpython-312.pyc new file mode 100644 index 00000000..dfd8855f Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/shader_pixel_local_storage2.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/shader_texture_lod.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/shader_texture_lod.cpython-312.pyc new file mode 100644 index 00000000..f078218d Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/shader_texture_lod.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/shadow_samplers.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/shadow_samplers.cpython-312.pyc new file mode 100644 index 00000000..9a982cb7 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/shadow_samplers.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/sparse_texture.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/sparse_texture.cpython-312.pyc new file mode 100644 index 00000000..388cf5cf Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/sparse_texture.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/sparse_texture2.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/sparse_texture2.cpython-312.pyc new file mode 100644 index 00000000..b24c789b Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/sparse_texture2.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/tessellation_point_size.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/tessellation_point_size.cpython-312.pyc new file mode 100644 index 00000000..81df02d0 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/tessellation_point_size.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/tessellation_shader.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/tessellation_shader.cpython-312.pyc new file mode 100644 index 00000000..cbb0e499 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/tessellation_shader.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/texture_border_clamp.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/texture_border_clamp.cpython-312.pyc new file mode 100644 index 00000000..58a292e3 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/texture_border_clamp.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/texture_buffer.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/texture_buffer.cpython-312.pyc new file mode 100644 index 00000000..8201e33e Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/texture_buffer.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/texture_compression_astc_decode_mode.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/texture_compression_astc_decode_mode.cpython-312.pyc new file mode 100644 index 00000000..28bd1fb4 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/texture_compression_astc_decode_mode.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/texture_compression_bptc.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/texture_compression_bptc.cpython-312.pyc new file mode 100644 index 00000000..24117ce8 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/texture_compression_bptc.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/texture_compression_dxt1.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/texture_compression_dxt1.cpython-312.pyc new file mode 100644 index 00000000..883591f4 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/texture_compression_dxt1.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/texture_compression_rgtc.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/texture_compression_rgtc.cpython-312.pyc new file mode 100644 index 00000000..9caafb6f Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/texture_compression_rgtc.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/texture_compression_s3tc.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/texture_compression_s3tc.cpython-312.pyc new file mode 100644 index 00000000..baeaff8a Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/texture_compression_s3tc.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/texture_compression_s3tc_srgb.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/texture_compression_s3tc_srgb.cpython-312.pyc new file mode 100644 index 00000000..c700a926 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/texture_compression_s3tc_srgb.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/texture_cube_map_array.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/texture_cube_map_array.cpython-312.pyc new file mode 100644 index 00000000..149e3c29 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/texture_cube_map_array.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/texture_filter_anisotropic.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/texture_filter_anisotropic.cpython-312.pyc new file mode 100644 index 00000000..9424bb08 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/texture_filter_anisotropic.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/texture_filter_minmax.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/texture_filter_minmax.cpython-312.pyc new file mode 100644 index 00000000..95632fd5 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/texture_filter_minmax.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/texture_format_BGRA8888.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/texture_format_BGRA8888.cpython-312.pyc new file mode 100644 index 00000000..afa873ff Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/texture_format_BGRA8888.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/texture_format_sRGB_override.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/texture_format_sRGB_override.cpython-312.pyc new file mode 100644 index 00000000..01fa0128 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/texture_format_sRGB_override.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/texture_mirror_clamp_to_edge.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/texture_mirror_clamp_to_edge.cpython-312.pyc new file mode 100644 index 00000000..41a18b70 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/texture_mirror_clamp_to_edge.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/texture_norm16.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/texture_norm16.cpython-312.pyc new file mode 100644 index 00000000..4886c1b9 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/texture_norm16.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/texture_query_lod.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/texture_query_lod.cpython-312.pyc new file mode 100644 index 00000000..1727bae2 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/texture_query_lod.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/texture_rg.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/texture_rg.cpython-312.pyc new file mode 100644 index 00000000..9fe6b4e0 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/texture_rg.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/texture_sRGB_R8.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/texture_sRGB_R8.cpython-312.pyc new file mode 100644 index 00000000..e50020cb Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/texture_sRGB_R8.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/texture_sRGB_RG8.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/texture_sRGB_RG8.cpython-312.pyc new file mode 100644 index 00000000..2b163faf Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/texture_sRGB_RG8.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/texture_sRGB_decode.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/texture_sRGB_decode.cpython-312.pyc new file mode 100644 index 00000000..7a1cbbb8 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/texture_sRGB_decode.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/texture_shadow_lod.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/texture_shadow_lod.cpython-312.pyc new file mode 100644 index 00000000..6a80fa88 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/texture_shadow_lod.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/texture_storage.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/texture_storage.cpython-312.pyc new file mode 100644 index 00000000..1b1a4d6f Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/texture_storage.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/texture_type_2_10_10_10_REV.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/texture_type_2_10_10_10_REV.cpython-312.pyc new file mode 100644 index 00000000..b6c30cf5 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/texture_type_2_10_10_10_REV.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/texture_view.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/texture_view.cpython-312.pyc new file mode 100644 index 00000000..29db8d06 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/texture_view.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/unpack_subimage.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/unpack_subimage.cpython-312.pyc new file mode 100644 index 00000000..e815d2bd Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/unpack_subimage.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/win32_keyed_mutex.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/win32_keyed_mutex.cpython-312.pyc new file mode 100644 index 00000000..1ddddffe Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/win32_keyed_mutex.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/window_rectangles.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/window_rectangles.cpython-312.pyc new file mode 100644 index 00000000..1df7cbb2 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/__pycache__/window_rectangles.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/base_instance.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/base_instance.py new file mode 100644 index 00000000..af0b2a30 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/base_instance.py @@ -0,0 +1,23 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_EXT_base_instance' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_EXT_base_instance',error_checker=_errors._error_checker) + +@_f +@_p.types(None,_cs.GLenum,_cs.GLint,_cs.GLsizei,_cs.GLsizei,_cs.GLuint) +def glDrawArraysInstancedBaseInstanceEXT(mode,first,count,instancecount,baseinstance):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizei,_cs.GLenum,ctypes.c_void_p,_cs.GLsizei,_cs.GLuint) +def glDrawElementsInstancedBaseInstanceEXT(mode,count,type,indices,instancecount,baseinstance):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizei,_cs.GLenum,ctypes.c_void_p,_cs.GLsizei,_cs.GLint,_cs.GLuint) +def glDrawElementsInstancedBaseVertexBaseInstanceEXT(mode,count,type,indices,instancecount,basevertex,baseinstance):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/blend_func_extended.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/blend_func_extended.py new file mode 100644 index 00000000..2150c087 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/blend_func_extended.py @@ -0,0 +1,32 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_EXT_blend_func_extended' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_EXT_blend_func_extended',error_checker=_errors._error_checker) +GL_LOCATION_INDEX_EXT=_C('GL_LOCATION_INDEX_EXT',0x930F) +GL_MAX_DUAL_SOURCE_DRAW_BUFFERS_EXT=_C('GL_MAX_DUAL_SOURCE_DRAW_BUFFERS_EXT',0x88FC) +GL_ONE_MINUS_SRC1_ALPHA_EXT=_C('GL_ONE_MINUS_SRC1_ALPHA_EXT',0x88FB) +GL_ONE_MINUS_SRC1_COLOR_EXT=_C('GL_ONE_MINUS_SRC1_COLOR_EXT',0x88FA) +GL_SRC1_ALPHA_EXT=_C('GL_SRC1_ALPHA_EXT',0x8589) +GL_SRC1_COLOR_EXT=_C('GL_SRC1_COLOR_EXT',0x88F9) +GL_SRC_ALPHA_SATURATE_EXT=_C('GL_SRC_ALPHA_SATURATE_EXT',0x0308) +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,arrays.GLcharArray) +def glBindFragDataLocationEXT(program,color,name):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLuint,arrays.GLcharArray) +def glBindFragDataLocationIndexedEXT(program,colorNumber,index,name):pass +@_f +@_p.types(_cs.GLint,_cs.GLuint,arrays.GLcharArray) +def glGetFragDataIndexEXT(program,name):pass +@_f +@_p.types(_cs.GLint,_cs.GLuint,_cs.GLenum,arrays.GLcharArray) +def glGetProgramResourceLocationIndexEXT(program,programInterface,name):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/blend_minmax.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/blend_minmax.py new file mode 100644 index 00000000..fc230c46 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/blend_minmax.py @@ -0,0 +1,20 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_EXT_blend_minmax' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_EXT_blend_minmax',error_checker=_errors._error_checker) +GL_BLEND_EQUATION_EXT=_C('GL_BLEND_EQUATION_EXT',0x8009) +GL_FUNC_ADD_EXT=_C('GL_FUNC_ADD_EXT',0x8006) +GL_MAX_EXT=_C('GL_MAX_EXT',0x8008) +GL_MIN_EXT=_C('GL_MIN_EXT',0x8007) +@_f +@_p.types(None,_cs.GLenum) +def glBlendEquationEXT(mode):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/buffer_storage.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/buffer_storage.py new file mode 100644 index 00000000..81599fda --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/buffer_storage.py @@ -0,0 +1,25 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_EXT_buffer_storage' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_EXT_buffer_storage',error_checker=_errors._error_checker) +GL_BUFFER_IMMUTABLE_STORAGE_EXT=_C('GL_BUFFER_IMMUTABLE_STORAGE_EXT',0x821F) +GL_BUFFER_STORAGE_FLAGS_EXT=_C('GL_BUFFER_STORAGE_FLAGS_EXT',0x8220) +GL_CLIENT_MAPPED_BUFFER_BARRIER_BIT_EXT=_C('GL_CLIENT_MAPPED_BUFFER_BARRIER_BIT_EXT',0x00004000) +GL_CLIENT_STORAGE_BIT_EXT=_C('GL_CLIENT_STORAGE_BIT_EXT',0x0200) +GL_DYNAMIC_STORAGE_BIT_EXT=_C('GL_DYNAMIC_STORAGE_BIT_EXT',0x0100) +GL_MAP_COHERENT_BIT_EXT=_C('GL_MAP_COHERENT_BIT_EXT',0x0080) +GL_MAP_PERSISTENT_BIT_EXT=_C('GL_MAP_PERSISTENT_BIT_EXT',0x0040) +GL_MAP_READ_BIT=_C('GL_MAP_READ_BIT',0x0001) +GL_MAP_WRITE_BIT=_C('GL_MAP_WRITE_BIT',0x0002) +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizeiptr,ctypes.c_void_p,_cs.GLbitfield) +def glBufferStorageEXT(target,size,data,flags):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/clear_texture.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/clear_texture.py new file mode 100644 index 00000000..bd031570 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/clear_texture.py @@ -0,0 +1,20 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_EXT_clear_texture' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_EXT_clear_texture',error_checker=_errors._error_checker) + +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLenum,_cs.GLenum,ctypes.c_void_p) +def glClearTexImageEXT(texture,level,format,type,data):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLsizei,_cs.GLsizei,_cs.GLenum,_cs.GLenum,ctypes.c_void_p) +def glClearTexSubImageEXT(texture,level,xoffset,yoffset,zoffset,width,height,depth,format,type,data):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/clip_control.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/clip_control.py new file mode 100644 index 00000000..d2b905f5 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/clip_control.py @@ -0,0 +1,22 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_EXT_clip_control' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_EXT_clip_control',error_checker=_errors._error_checker) +GL_CLIP_DEPTH_MODE_EXT=_C('GL_CLIP_DEPTH_MODE_EXT',0x935D) +GL_CLIP_ORIGIN_EXT=_C('GL_CLIP_ORIGIN_EXT',0x935C) +GL_LOWER_LEFT_EXT=_C('GL_LOWER_LEFT_EXT',0x8CA1) +GL_NEGATIVE_ONE_TO_ONE_EXT=_C('GL_NEGATIVE_ONE_TO_ONE_EXT',0x935E) +GL_UPPER_LEFT_EXT=_C('GL_UPPER_LEFT_EXT',0x8CA2) +GL_ZERO_TO_ONE_EXT=_C('GL_ZERO_TO_ONE_EXT',0x935F) +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum) +def glClipControlEXT(origin,depth):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/clip_cull_distance.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/clip_cull_distance.py new file mode 100644 index 00000000..0e8964ae --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/clip_cull_distance.py @@ -0,0 +1,25 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_EXT_clip_cull_distance' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_EXT_clip_cull_distance',error_checker=_errors._error_checker) +GL_CLIP_DISTANCE0_EXT=_C('GL_CLIP_DISTANCE0_EXT',0x3000) +GL_CLIP_DISTANCE1_EXT=_C('GL_CLIP_DISTANCE1_EXT',0x3001) +GL_CLIP_DISTANCE2_EXT=_C('GL_CLIP_DISTANCE2_EXT',0x3002) +GL_CLIP_DISTANCE3_EXT=_C('GL_CLIP_DISTANCE3_EXT',0x3003) +GL_CLIP_DISTANCE4_EXT=_C('GL_CLIP_DISTANCE4_EXT',0x3004) +GL_CLIP_DISTANCE5_EXT=_C('GL_CLIP_DISTANCE5_EXT',0x3005) +GL_CLIP_DISTANCE6_EXT=_C('GL_CLIP_DISTANCE6_EXT',0x3006) +GL_CLIP_DISTANCE7_EXT=_C('GL_CLIP_DISTANCE7_EXT',0x3007) +GL_MAX_CLIP_DISTANCES_EXT=_C('GL_MAX_CLIP_DISTANCES_EXT',0x0D32) +GL_MAX_COMBINED_CLIP_AND_CULL_DISTANCES_EXT=_C('GL_MAX_COMBINED_CLIP_AND_CULL_DISTANCES_EXT',0x82FA) +GL_MAX_CULL_DISTANCES_EXT=_C('GL_MAX_CULL_DISTANCES_EXT',0x82F9) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/color_buffer_float.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/color_buffer_float.py new file mode 100644 index 00000000..c63a0672 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/color_buffer_float.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_EXT_color_buffer_float' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_EXT_color_buffer_float',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/color_buffer_half_float.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/color_buffer_half_float.py new file mode 100644 index 00000000..02832c55 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/color_buffer_half_float.py @@ -0,0 +1,20 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_EXT_color_buffer_half_float' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_EXT_color_buffer_half_float',error_checker=_errors._error_checker) +GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE_EXT=_C('GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE_EXT',0x8211) +GL_R16F_EXT=_C('GL_R16F_EXT',0x822D) +GL_RG16F_EXT=_C('GL_RG16F_EXT',0x822F) +GL_RGB16F_EXT=_C('GL_RGB16F_EXT',0x881B) +GL_RGBA16F_EXT=_C('GL_RGBA16F_EXT',0x881A) +GL_UNSIGNED_NORMALIZED_EXT=_C('GL_UNSIGNED_NORMALIZED_EXT',0x8C17) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/conservative_depth.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/conservative_depth.py new file mode 100644 index 00000000..9808c8ee --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/conservative_depth.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_EXT_conservative_depth' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_EXT_conservative_depth',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/copy_image.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/copy_image.py new file mode 100644 index 00000000..d8f1e8c3 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/copy_image.py @@ -0,0 +1,17 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_EXT_copy_image' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_EXT_copy_image',error_checker=_errors._error_checker) + +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLuint,_cs.GLenum,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLsizei,_cs.GLsizei) +def glCopyImageSubDataEXT(srcName,srcTarget,srcLevel,srcX,srcY,srcZ,dstName,dstTarget,dstLevel,dstX,dstY,dstZ,srcWidth,srcHeight,srcDepth):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/debug_label.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/debug_label.py new file mode 100644 index 00000000..ddd2165e --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/debug_label.py @@ -0,0 +1,27 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_EXT_debug_label' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_EXT_debug_label',error_checker=_errors._error_checker) +GL_BUFFER_OBJECT_EXT=_C('GL_BUFFER_OBJECT_EXT',0x9151) +GL_PROGRAM_OBJECT_EXT=_C('GL_PROGRAM_OBJECT_EXT',0x8B40) +GL_PROGRAM_PIPELINE_OBJECT_EXT=_C('GL_PROGRAM_PIPELINE_OBJECT_EXT',0x8A4F) +GL_QUERY_OBJECT_EXT=_C('GL_QUERY_OBJECT_EXT',0x9153) +GL_SAMPLER=_C('GL_SAMPLER',0x82E6) +GL_SHADER_OBJECT_EXT=_C('GL_SHADER_OBJECT_EXT',0x8B48) +GL_TRANSFORM_FEEDBACK=_C('GL_TRANSFORM_FEEDBACK',0x8E22) +GL_VERTEX_ARRAY_OBJECT_EXT=_C('GL_VERTEX_ARRAY_OBJECT_EXT',0x9154) +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,_cs.GLsizei,arrays.GLsizeiArray,arrays.GLcharArray) +def glGetObjectLabelEXT(type,object,bufSize,length,label):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,_cs.GLsizei,arrays.GLcharArray) +def glLabelObjectEXT(type,object,length,label):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/debug_marker.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/debug_marker.py new file mode 100644 index 00000000..85fb6b07 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/debug_marker.py @@ -0,0 +1,23 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_EXT_debug_marker' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_EXT_debug_marker',error_checker=_errors._error_checker) + +@_f +@_p.types(None,_cs.GLsizei,arrays.GLcharArray) +def glInsertEventMarkerEXT(length,marker):pass +@_f +@_p.types(None,) +def glPopGroupMarkerEXT():pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLcharArray) +def glPushGroupMarkerEXT(length,marker):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/depth_clamp.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/depth_clamp.py new file mode 100644 index 00000000..8d59a256 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/depth_clamp.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_EXT_depth_clamp' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_EXT_depth_clamp',error_checker=_errors._error_checker) +GL_DEPTH_CLAMP_EXT=_C('GL_DEPTH_CLAMP_EXT',0x864F) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/discard_framebuffer.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/discard_framebuffer.py new file mode 100644 index 00000000..7695e262 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/discard_framebuffer.py @@ -0,0 +1,19 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_EXT_discard_framebuffer' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_EXT_discard_framebuffer',error_checker=_errors._error_checker) +GL_COLOR_EXT=_C('GL_COLOR_EXT',0x1800) +GL_DEPTH_EXT=_C('GL_DEPTH_EXT',0x1801) +GL_STENCIL_EXT=_C('GL_STENCIL_EXT',0x1802) +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizei,arrays.GLuintArray) +def glDiscardFramebufferEXT(target,numAttachments,attachments):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/disjoint_timer_query.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/disjoint_timer_query.py new file mode 100644 index 00000000..079cbc12 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/disjoint_timer_query.py @@ -0,0 +1,53 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_EXT_disjoint_timer_query' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_EXT_disjoint_timer_query',error_checker=_errors._error_checker) +GL_CURRENT_QUERY_EXT=_C('GL_CURRENT_QUERY_EXT',0x8865) +GL_GPU_DISJOINT_EXT=_C('GL_GPU_DISJOINT_EXT',0x8FBB) +GL_QUERY_COUNTER_BITS_EXT=_C('GL_QUERY_COUNTER_BITS_EXT',0x8864) +GL_QUERY_RESULT_AVAILABLE_EXT=_C('GL_QUERY_RESULT_AVAILABLE_EXT',0x8867) +GL_QUERY_RESULT_EXT=_C('GL_QUERY_RESULT_EXT',0x8866) +GL_TIMESTAMP_EXT=_C('GL_TIMESTAMP_EXT',0x8E28) +GL_TIME_ELAPSED_EXT=_C('GL_TIME_ELAPSED_EXT',0x88BF) +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint) +def glBeginQueryEXT(target,id):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray) +def glDeleteQueriesEXT(n,ids):pass +@_f +@_p.types(None,_cs.GLenum) +def glEndQueryEXT(target):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray) +def glGenQueriesEXT(n,ids):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLint64Array) +def glGetQueryObjecti64vEXT(id,pname,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLintArray) +def glGetQueryObjectivEXT(id,pname,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLuint64Array) +def glGetQueryObjectui64vEXT(id,pname,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLuintArray) +def glGetQueryObjectuivEXT(id,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLintArray) +def glGetQueryivEXT(target,pname,params):pass +@_f +@_p.types(_cs.GLboolean,_cs.GLuint) +def glIsQueryEXT(id):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum) +def glQueryCounterEXT(id,target):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/draw_buffers.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/draw_buffers.py new file mode 100644 index 00000000..f65db182 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/draw_buffers.py @@ -0,0 +1,50 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_EXT_draw_buffers' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_EXT_draw_buffers',error_checker=_errors._error_checker) +GL_COLOR_ATTACHMENT0_EXT=_C('GL_COLOR_ATTACHMENT0_EXT',0x8CE0) +GL_COLOR_ATTACHMENT10_EXT=_C('GL_COLOR_ATTACHMENT10_EXT',0x8CEA) +GL_COLOR_ATTACHMENT11_EXT=_C('GL_COLOR_ATTACHMENT11_EXT',0x8CEB) +GL_COLOR_ATTACHMENT12_EXT=_C('GL_COLOR_ATTACHMENT12_EXT',0x8CEC) +GL_COLOR_ATTACHMENT13_EXT=_C('GL_COLOR_ATTACHMENT13_EXT',0x8CED) +GL_COLOR_ATTACHMENT14_EXT=_C('GL_COLOR_ATTACHMENT14_EXT',0x8CEE) +GL_COLOR_ATTACHMENT15_EXT=_C('GL_COLOR_ATTACHMENT15_EXT',0x8CEF) +GL_COLOR_ATTACHMENT1_EXT=_C('GL_COLOR_ATTACHMENT1_EXT',0x8CE1) +GL_COLOR_ATTACHMENT2_EXT=_C('GL_COLOR_ATTACHMENT2_EXT',0x8CE2) +GL_COLOR_ATTACHMENT3_EXT=_C('GL_COLOR_ATTACHMENT3_EXT',0x8CE3) +GL_COLOR_ATTACHMENT4_EXT=_C('GL_COLOR_ATTACHMENT4_EXT',0x8CE4) +GL_COLOR_ATTACHMENT5_EXT=_C('GL_COLOR_ATTACHMENT5_EXT',0x8CE5) +GL_COLOR_ATTACHMENT6_EXT=_C('GL_COLOR_ATTACHMENT6_EXT',0x8CE6) +GL_COLOR_ATTACHMENT7_EXT=_C('GL_COLOR_ATTACHMENT7_EXT',0x8CE7) +GL_COLOR_ATTACHMENT8_EXT=_C('GL_COLOR_ATTACHMENT8_EXT',0x8CE8) +GL_COLOR_ATTACHMENT9_EXT=_C('GL_COLOR_ATTACHMENT9_EXT',0x8CE9) +GL_DRAW_BUFFER0_EXT=_C('GL_DRAW_BUFFER0_EXT',0x8825) +GL_DRAW_BUFFER10_EXT=_C('GL_DRAW_BUFFER10_EXT',0x882F) +GL_DRAW_BUFFER11_EXT=_C('GL_DRAW_BUFFER11_EXT',0x8830) +GL_DRAW_BUFFER12_EXT=_C('GL_DRAW_BUFFER12_EXT',0x8831) +GL_DRAW_BUFFER13_EXT=_C('GL_DRAW_BUFFER13_EXT',0x8832) +GL_DRAW_BUFFER14_EXT=_C('GL_DRAW_BUFFER14_EXT',0x8833) +GL_DRAW_BUFFER15_EXT=_C('GL_DRAW_BUFFER15_EXT',0x8834) +GL_DRAW_BUFFER1_EXT=_C('GL_DRAW_BUFFER1_EXT',0x8826) +GL_DRAW_BUFFER2_EXT=_C('GL_DRAW_BUFFER2_EXT',0x8827) +GL_DRAW_BUFFER3_EXT=_C('GL_DRAW_BUFFER3_EXT',0x8828) +GL_DRAW_BUFFER4_EXT=_C('GL_DRAW_BUFFER4_EXT',0x8829) +GL_DRAW_BUFFER5_EXT=_C('GL_DRAW_BUFFER5_EXT',0x882A) +GL_DRAW_BUFFER6_EXT=_C('GL_DRAW_BUFFER6_EXT',0x882B) +GL_DRAW_BUFFER7_EXT=_C('GL_DRAW_BUFFER7_EXT',0x882C) +GL_DRAW_BUFFER8_EXT=_C('GL_DRAW_BUFFER8_EXT',0x882D) +GL_DRAW_BUFFER9_EXT=_C('GL_DRAW_BUFFER9_EXT',0x882E) +GL_MAX_COLOR_ATTACHMENTS_EXT=_C('GL_MAX_COLOR_ATTACHMENTS_EXT',0x8CDF) +GL_MAX_DRAW_BUFFERS_EXT=_C('GL_MAX_DRAW_BUFFERS_EXT',0x8824) +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray) +def glDrawBuffersEXT(n,bufs):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/draw_buffers_indexed.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/draw_buffers_indexed.py new file mode 100644 index 00000000..cd761e88 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/draw_buffers_indexed.py @@ -0,0 +1,65 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_EXT_draw_buffers_indexed' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_EXT_draw_buffers_indexed',error_checker=_errors._error_checker) +GL_BLEND=_C('GL_BLEND',0x0BE2) +GL_BLEND_DST_ALPHA=_C('GL_BLEND_DST_ALPHA',0x80CA) +GL_BLEND_DST_RGB=_C('GL_BLEND_DST_RGB',0x80C8) +GL_BLEND_EQUATION_ALPHA=_C('GL_BLEND_EQUATION_ALPHA',0x883D) +GL_BLEND_EQUATION_RGB=_C('GL_BLEND_EQUATION_RGB',0x8009) +GL_BLEND_SRC_ALPHA=_C('GL_BLEND_SRC_ALPHA',0x80CB) +GL_BLEND_SRC_RGB=_C('GL_BLEND_SRC_RGB',0x80C9) +GL_COLOR_WRITEMASK=_C('GL_COLOR_WRITEMASK',0x0C23) +GL_CONSTANT_ALPHA=_C('GL_CONSTANT_ALPHA',0x8003) +GL_CONSTANT_COLOR=_C('GL_CONSTANT_COLOR',0x8001) +GL_DST_ALPHA=_C('GL_DST_ALPHA',0x0304) +GL_DST_COLOR=_C('GL_DST_COLOR',0x0306) +GL_FUNC_ADD=_C('GL_FUNC_ADD',0x8006) +GL_FUNC_REVERSE_SUBTRACT=_C('GL_FUNC_REVERSE_SUBTRACT',0x800B) +GL_FUNC_SUBTRACT=_C('GL_FUNC_SUBTRACT',0x800A) +GL_MAX=_C('GL_MAX',0x8008) +GL_MIN=_C('GL_MIN',0x8007) +GL_ONE=_C('GL_ONE',1) +GL_ONE_MINUS_CONSTANT_ALPHA=_C('GL_ONE_MINUS_CONSTANT_ALPHA',0x8004) +GL_ONE_MINUS_CONSTANT_COLOR=_C('GL_ONE_MINUS_CONSTANT_COLOR',0x8002) +GL_ONE_MINUS_DST_ALPHA=_C('GL_ONE_MINUS_DST_ALPHA',0x0305) +GL_ONE_MINUS_DST_COLOR=_C('GL_ONE_MINUS_DST_COLOR',0x0307) +GL_ONE_MINUS_SRC_ALPHA=_C('GL_ONE_MINUS_SRC_ALPHA',0x0303) +GL_ONE_MINUS_SRC_COLOR=_C('GL_ONE_MINUS_SRC_COLOR',0x0301) +GL_SRC_ALPHA=_C('GL_SRC_ALPHA',0x0302) +GL_SRC_ALPHA_SATURATE=_C('GL_SRC_ALPHA_SATURATE',0x0308) +GL_SRC_COLOR=_C('GL_SRC_COLOR',0x0300) +GL_ZERO=_C('GL_ZERO',0) +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLenum) +def glBlendEquationSeparateiEXT(buf,modeRGB,modeAlpha):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum) +def glBlendEquationiEXT(buf,mode):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLenum,_cs.GLenum,_cs.GLenum) +def glBlendFuncSeparateiEXT(buf,srcRGB,dstRGB,srcAlpha,dstAlpha):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLenum) +def glBlendFunciEXT(buf,src,dst):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLboolean,_cs.GLboolean,_cs.GLboolean,_cs.GLboolean) +def glColorMaskiEXT(index,r,g,b,a):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint) +def glDisableiEXT(target,index):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint) +def glEnableiEXT(target,index):pass +@_f +@_p.types(_cs.GLboolean,_cs.GLenum,_cs.GLuint) +def glIsEnablediEXT(target,index):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/draw_elements_base_vertex.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/draw_elements_base_vertex.py new file mode 100644 index 00000000..21c59793 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/draw_elements_base_vertex.py @@ -0,0 +1,26 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_EXT_draw_elements_base_vertex' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_EXT_draw_elements_base_vertex',error_checker=_errors._error_checker) + +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizei,_cs.GLenum,ctypes.c_void_p,_cs.GLint) +def glDrawElementsBaseVertexEXT(mode,count,type,indices,basevertex):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizei,_cs.GLenum,ctypes.c_void_p,_cs.GLsizei,_cs.GLint) +def glDrawElementsInstancedBaseVertexEXT(mode,count,type,indices,instancecount,basevertex):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,_cs.GLuint,_cs.GLsizei,_cs.GLenum,ctypes.c_void_p,_cs.GLint) +def glDrawRangeElementsBaseVertexEXT(mode,start,end,count,type,indices,basevertex):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLsizeiArray,_cs.GLenum,arrays.GLvoidpArray,_cs.GLsizei,arrays.GLintArray) +def glMultiDrawElementsBaseVertexEXT(mode,count,type,indices,primcount,basevertex):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/draw_instanced.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/draw_instanced.py new file mode 100644 index 00000000..3e29a403 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/draw_instanced.py @@ -0,0 +1,20 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_EXT_draw_instanced' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_EXT_draw_instanced',error_checker=_errors._error_checker) + +@_f +@_p.types(None,_cs.GLenum,_cs.GLint,_cs.GLsizei,_cs.GLsizei) +def glDrawArraysInstancedEXT(mode,start,count,primcount):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizei,_cs.GLenum,ctypes.c_void_p,_cs.GLsizei) +def glDrawElementsInstancedEXT(mode,count,type,indices,primcount):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/draw_transform_feedback.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/draw_transform_feedback.py new file mode 100644 index 00000000..774b17ae --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/draw_transform_feedback.py @@ -0,0 +1,20 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_EXT_draw_transform_feedback' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_EXT_draw_transform_feedback',error_checker=_errors._error_checker) + +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint) +def glDrawTransformFeedbackEXT(mode,id):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,_cs.GLsizei) +def glDrawTransformFeedbackInstancedEXT(mode,id,instancecount):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/external_buffer.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/external_buffer.py new file mode 100644 index 00000000..2a61648d --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/external_buffer.py @@ -0,0 +1,20 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_EXT_external_buffer' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_EXT_external_buffer',error_checker=_errors._error_checker) + +@_f +@_p.types(None,_cs.GLenum,_cs.GLintptr,_cs.GLsizeiptr,_cs.GLeglClientBufferEXT,_cs.GLbitfield) +def glBufferStorageExternalEXT(target,offset,size,clientBuffer,flags):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLintptr,_cs.GLsizeiptr,_cs.GLeglClientBufferEXT,_cs.GLbitfield) +def glNamedBufferStorageExternalEXT(buffer,offset,size,clientBuffer,flags):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/float_blend.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/float_blend.py new file mode 100644 index 00000000..3b11a17d --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/float_blend.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_EXT_float_blend' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_EXT_float_blend',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/geometry_point_size.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/geometry_point_size.py new file mode 100644 index 00000000..0e10c1ce --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/geometry_point_size.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_EXT_geometry_point_size' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_EXT_geometry_point_size',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/geometry_shader.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/geometry_shader.py new file mode 100644 index 00000000..3bbc2a10 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/geometry_shader.py @@ -0,0 +1,49 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_EXT_geometry_shader' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_EXT_geometry_shader',error_checker=_errors._error_checker) +GL_FIRST_VERTEX_CONVENTION_EXT=_C('GL_FIRST_VERTEX_CONVENTION_EXT',0x8E4D) +GL_FRAMEBUFFER_ATTACHMENT_LAYERED_EXT=_C('GL_FRAMEBUFFER_ATTACHMENT_LAYERED_EXT',0x8DA7) +GL_FRAMEBUFFER_DEFAULT_LAYERS_EXT=_C('GL_FRAMEBUFFER_DEFAULT_LAYERS_EXT',0x9312) +GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS_EXT=_C('GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS_EXT',0x8DA8) +GL_GEOMETRY_LINKED_INPUT_TYPE_EXT=_C('GL_GEOMETRY_LINKED_INPUT_TYPE_EXT',0x8917) +GL_GEOMETRY_LINKED_OUTPUT_TYPE_EXT=_C('GL_GEOMETRY_LINKED_OUTPUT_TYPE_EXT',0x8918) +GL_GEOMETRY_LINKED_VERTICES_OUT_EXT=_C('GL_GEOMETRY_LINKED_VERTICES_OUT_EXT',0x8916) +GL_GEOMETRY_SHADER_BIT_EXT=_C('GL_GEOMETRY_SHADER_BIT_EXT',0x00000004) +GL_GEOMETRY_SHADER_EXT=_C('GL_GEOMETRY_SHADER_EXT',0x8DD9) +GL_GEOMETRY_SHADER_INVOCATIONS_EXT=_C('GL_GEOMETRY_SHADER_INVOCATIONS_EXT',0x887F) +GL_LAST_VERTEX_CONVENTION_EXT=_C('GL_LAST_VERTEX_CONVENTION_EXT',0x8E4E) +GL_LAYER_PROVOKING_VERTEX_EXT=_C('GL_LAYER_PROVOKING_VERTEX_EXT',0x825E) +GL_LINES_ADJACENCY_EXT=_C('GL_LINES_ADJACENCY_EXT',0x000A) +GL_LINE_STRIP_ADJACENCY_EXT=_C('GL_LINE_STRIP_ADJACENCY_EXT',0x000B) +GL_MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS_EXT=_C('GL_MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS_EXT',0x8A32) +GL_MAX_FRAMEBUFFER_LAYERS_EXT=_C('GL_MAX_FRAMEBUFFER_LAYERS_EXT',0x9317) +GL_MAX_GEOMETRY_ATOMIC_COUNTERS_EXT=_C('GL_MAX_GEOMETRY_ATOMIC_COUNTERS_EXT',0x92D5) +GL_MAX_GEOMETRY_ATOMIC_COUNTER_BUFFERS_EXT=_C('GL_MAX_GEOMETRY_ATOMIC_COUNTER_BUFFERS_EXT',0x92CF) +GL_MAX_GEOMETRY_IMAGE_UNIFORMS_EXT=_C('GL_MAX_GEOMETRY_IMAGE_UNIFORMS_EXT',0x90CD) +GL_MAX_GEOMETRY_INPUT_COMPONENTS_EXT=_C('GL_MAX_GEOMETRY_INPUT_COMPONENTS_EXT',0x9123) +GL_MAX_GEOMETRY_OUTPUT_COMPONENTS_EXT=_C('GL_MAX_GEOMETRY_OUTPUT_COMPONENTS_EXT',0x9124) +GL_MAX_GEOMETRY_OUTPUT_VERTICES_EXT=_C('GL_MAX_GEOMETRY_OUTPUT_VERTICES_EXT',0x8DE0) +GL_MAX_GEOMETRY_SHADER_INVOCATIONS_EXT=_C('GL_MAX_GEOMETRY_SHADER_INVOCATIONS_EXT',0x8E5A) +GL_MAX_GEOMETRY_SHADER_STORAGE_BLOCKS_EXT=_C('GL_MAX_GEOMETRY_SHADER_STORAGE_BLOCKS_EXT',0x90D7) +GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_EXT=_C('GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_EXT',0x8C29) +GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS_EXT=_C('GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS_EXT',0x8DE1) +GL_MAX_GEOMETRY_UNIFORM_BLOCKS_EXT=_C('GL_MAX_GEOMETRY_UNIFORM_BLOCKS_EXT',0x8A2C) +GL_MAX_GEOMETRY_UNIFORM_COMPONENTS_EXT=_C('GL_MAX_GEOMETRY_UNIFORM_COMPONENTS_EXT',0x8DDF) +GL_PRIMITIVES_GENERATED_EXT=_C('GL_PRIMITIVES_GENERATED_EXT',0x8C87) +GL_REFERENCED_BY_GEOMETRY_SHADER_EXT=_C('GL_REFERENCED_BY_GEOMETRY_SHADER_EXT',0x9309) +GL_TRIANGLES_ADJACENCY_EXT=_C('GL_TRIANGLES_ADJACENCY_EXT',0x000C) +GL_TRIANGLE_STRIP_ADJACENCY_EXT=_C('GL_TRIANGLE_STRIP_ADJACENCY_EXT',0x000D) +GL_UNDEFINED_VERTEX_EXT=_C('GL_UNDEFINED_VERTEX_EXT',0x8260) +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLuint,_cs.GLint) +def glFramebufferTextureEXT(target,attachment,texture,level):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/gpu_shader5.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/gpu_shader5.py new file mode 100644 index 00000000..24d57e9c --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/gpu_shader5.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_EXT_gpu_shader5' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_EXT_gpu_shader5',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/instanced_arrays.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/instanced_arrays.py new file mode 100644 index 00000000..45cbf155 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/instanced_arrays.py @@ -0,0 +1,23 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_EXT_instanced_arrays' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_EXT_instanced_arrays',error_checker=_errors._error_checker) +GL_VERTEX_ATTRIB_ARRAY_DIVISOR_EXT=_C('GL_VERTEX_ATTRIB_ARRAY_DIVISOR_EXT',0x88FE) +@_f +@_p.types(None,_cs.GLenum,_cs.GLint,_cs.GLsizei,_cs.GLsizei) +def glDrawArraysInstancedEXT(mode,start,count,primcount):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizei,_cs.GLenum,ctypes.c_void_p,_cs.GLsizei) +def glDrawElementsInstancedEXT(mode,count,type,indices,primcount):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint) +def glVertexAttribDivisorEXT(index,divisor):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/map_buffer_range.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/map_buffer_range.py new file mode 100644 index 00000000..f4173242 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/map_buffer_range.py @@ -0,0 +1,25 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_EXT_map_buffer_range' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_EXT_map_buffer_range',error_checker=_errors._error_checker) +GL_MAP_FLUSH_EXPLICIT_BIT_EXT=_C('GL_MAP_FLUSH_EXPLICIT_BIT_EXT',0x0010) +GL_MAP_INVALIDATE_BUFFER_BIT_EXT=_C('GL_MAP_INVALIDATE_BUFFER_BIT_EXT',0x0008) +GL_MAP_INVALIDATE_RANGE_BIT_EXT=_C('GL_MAP_INVALIDATE_RANGE_BIT_EXT',0x0004) +GL_MAP_READ_BIT_EXT=_C('GL_MAP_READ_BIT_EXT',0x0001) +GL_MAP_UNSYNCHRONIZED_BIT_EXT=_C('GL_MAP_UNSYNCHRONIZED_BIT_EXT',0x0020) +GL_MAP_WRITE_BIT_EXT=_C('GL_MAP_WRITE_BIT_EXT',0x0002) +@_f +@_p.types(None,_cs.GLenum,_cs.GLintptr,_cs.GLsizeiptr) +def glFlushMappedBufferRangeEXT(target,offset,length):pass +@_f +@_p.types(ctypes.c_void_p,_cs.GLenum,_cs.GLintptr,_cs.GLsizeiptr,_cs.GLbitfield) +def glMapBufferRangeEXT(target,offset,length,access):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/memory_object.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/memory_object.py new file mode 100644 index 00000000..be53df3e --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/memory_object.py @@ -0,0 +1,81 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_EXT_memory_object' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_EXT_memory_object',error_checker=_errors._error_checker) +GL_DEDICATED_MEMORY_OBJECT_EXT=_C('GL_DEDICATED_MEMORY_OBJECT_EXT',0x9581) +GL_DEVICE_UUID_EXT=_C('GL_DEVICE_UUID_EXT',0x9597) +GL_DRIVER_UUID_EXT=_C('GL_DRIVER_UUID_EXT',0x9598) +GL_LINEAR_TILING_EXT=_C('GL_LINEAR_TILING_EXT',0x9585) +GL_NUM_DEVICE_UUIDS_EXT=_C('GL_NUM_DEVICE_UUIDS_EXT',0x9596) +GL_NUM_TILING_TYPES_EXT=_C('GL_NUM_TILING_TYPES_EXT',0x9582) +GL_OPTIMAL_TILING_EXT=_C('GL_OPTIMAL_TILING_EXT',0x9584) +GL_PROTECTED_MEMORY_OBJECT_EXT=_C('GL_PROTECTED_MEMORY_OBJECT_EXT',0x959B) +GL_TEXTURE_TILING_EXT=_C('GL_TEXTURE_TILING_EXT',0x9580) +GL_TILING_TYPES_EXT=_C('GL_TILING_TYPES_EXT',0x9583) +GL_UUID_SIZE_EXT=_C('GL_UUID_SIZE_EXT',16) +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizeiptr,_cs.GLuint,_cs.GLuint64) +def glBufferStorageMemEXT(target,size,memory,offset):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray) +def glCreateMemoryObjectsEXT(n,memoryObjects):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray) +def glDeleteMemoryObjectsEXT(n,memoryObjects):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLintArray) +def glGetMemoryObjectParameterivEXT(memoryObject,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,arrays.GLubyteArray) +def glGetUnsignedBytei_vEXT(target,index,data):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLubyteArray) +def glGetUnsignedBytevEXT(pname,data):pass +@_f +@_p.types(_cs.GLboolean,_cs.GLuint) +def glIsMemoryObjectEXT(memoryObject):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLintArray) +def glMemoryObjectParameterivEXT(memoryObject,pname,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizeiptr,_cs.GLuint,_cs.GLuint64) +def glNamedBufferStorageMemEXT(buffer,size,memory,offset):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizei,_cs.GLenum,_cs.GLsizei,_cs.GLuint,_cs.GLuint64) +def glTexStorageMem1DEXT(target,levels,internalFormat,width,memory,offset):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizei,_cs.GLenum,_cs.GLsizei,_cs.GLsizei,_cs.GLuint,_cs.GLuint64) +def glTexStorageMem2DEXT(target,levels,internalFormat,width,height,memory,offset):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizei,_cs.GLenum,_cs.GLsizei,_cs.GLsizei,_cs.GLboolean,_cs.GLuint,_cs.GLuint64) +def glTexStorageMem2DMultisampleEXT(target,samples,internalFormat,width,height,fixedSampleLocations,memory,offset):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizei,_cs.GLenum,_cs.GLsizei,_cs.GLsizei,_cs.GLsizei,_cs.GLuint,_cs.GLuint64) +def glTexStorageMem3DEXT(target,levels,internalFormat,width,height,depth,memory,offset):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizei,_cs.GLenum,_cs.GLsizei,_cs.GLsizei,_cs.GLsizei,_cs.GLboolean,_cs.GLuint,_cs.GLuint64) +def glTexStorageMem3DMultisampleEXT(target,samples,internalFormat,width,height,depth,fixedSampleLocations,memory,offset):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizei,_cs.GLenum,_cs.GLsizei,_cs.GLuint,_cs.GLuint64) +def glTextureStorageMem1DEXT(texture,levels,internalFormat,width,memory,offset):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizei,_cs.GLenum,_cs.GLsizei,_cs.GLsizei,_cs.GLuint,_cs.GLuint64) +def glTextureStorageMem2DEXT(texture,levels,internalFormat,width,height,memory,offset):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizei,_cs.GLenum,_cs.GLsizei,_cs.GLsizei,_cs.GLboolean,_cs.GLuint,_cs.GLuint64) +def glTextureStorageMem2DMultisampleEXT(texture,samples,internalFormat,width,height,fixedSampleLocations,memory,offset):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizei,_cs.GLenum,_cs.GLsizei,_cs.GLsizei,_cs.GLsizei,_cs.GLuint,_cs.GLuint64) +def glTextureStorageMem3DEXT(texture,levels,internalFormat,width,height,depth,memory,offset):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizei,_cs.GLenum,_cs.GLsizei,_cs.GLsizei,_cs.GLsizei,_cs.GLboolean,_cs.GLuint,_cs.GLuint64) +def glTextureStorageMem3DMultisampleEXT(texture,samples,internalFormat,width,height,depth,fixedSampleLocations,memory,offset):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/memory_object_fd.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/memory_object_fd.py new file mode 100644 index 00000000..ef715903 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/memory_object_fd.py @@ -0,0 +1,17 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_EXT_memory_object_fd' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_EXT_memory_object_fd',error_checker=_errors._error_checker) +GL_HANDLE_TYPE_OPAQUE_FD_EXT=_C('GL_HANDLE_TYPE_OPAQUE_FD_EXT',0x9586) +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint64,_cs.GLenum,_cs.GLint) +def glImportMemoryFdEXT(memory,size,handleType,fd):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/memory_object_win32.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/memory_object_win32.py new file mode 100644 index 00000000..4e2a85d7 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/memory_object_win32.py @@ -0,0 +1,28 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_EXT_memory_object_win32' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_EXT_memory_object_win32',error_checker=_errors._error_checker) +GL_DEVICE_LUID_EXT=_C('GL_DEVICE_LUID_EXT',0x9599) +GL_DEVICE_NODE_MASK_EXT=_C('GL_DEVICE_NODE_MASK_EXT',0x959A) +GL_HANDLE_TYPE_D3D11_IMAGE_EXT=_C('GL_HANDLE_TYPE_D3D11_IMAGE_EXT',0x958B) +GL_HANDLE_TYPE_D3D11_IMAGE_KMT_EXT=_C('GL_HANDLE_TYPE_D3D11_IMAGE_KMT_EXT',0x958C) +GL_HANDLE_TYPE_D3D12_RESOURCE_EXT=_C('GL_HANDLE_TYPE_D3D12_RESOURCE_EXT',0x958A) +GL_HANDLE_TYPE_D3D12_TILEPOOL_EXT=_C('GL_HANDLE_TYPE_D3D12_TILEPOOL_EXT',0x9589) +GL_HANDLE_TYPE_OPAQUE_WIN32_EXT=_C('GL_HANDLE_TYPE_OPAQUE_WIN32_EXT',0x9587) +GL_HANDLE_TYPE_OPAQUE_WIN32_KMT_EXT=_C('GL_HANDLE_TYPE_OPAQUE_WIN32_KMT_EXT',0x9588) +GL_LUID_SIZE_EXT=_C('GL_LUID_SIZE_EXT',8) +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint64,_cs.GLenum,ctypes.c_void_p) +def glImportMemoryWin32HandleEXT(memory,size,handleType,handle):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint64,_cs.GLenum,ctypes.c_void_p) +def glImportMemoryWin32NameEXT(memory,size,handleType,name):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/multi_draw_arrays.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/multi_draw_arrays.py new file mode 100644 index 00000000..df7d6f4e --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/multi_draw_arrays.py @@ -0,0 +1,20 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_EXT_multi_draw_arrays' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_EXT_multi_draw_arrays',error_checker=_errors._error_checker) + +@_f +@_p.types(None,_cs.GLenum,arrays.GLintArray,arrays.GLsizeiArray,_cs.GLsizei) +def glMultiDrawArraysEXT(mode,first,count,primcount):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLsizeiArray,_cs.GLenum,arrays.GLvoidpArray,_cs.GLsizei) +def glMultiDrawElementsEXT(mode,count,type,indices,primcount):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/multi_draw_indirect.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/multi_draw_indirect.py new file mode 100644 index 00000000..c1916255 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/multi_draw_indirect.py @@ -0,0 +1,20 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_EXT_multi_draw_indirect' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_EXT_multi_draw_indirect',error_checker=_errors._error_checker) + +@_f +@_p.types(None,_cs.GLenum,ctypes.c_void_p,_cs.GLsizei,_cs.GLsizei) +def glMultiDrawArraysIndirectEXT(mode,indirect,drawcount,stride):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,ctypes.c_void_p,_cs.GLsizei,_cs.GLsizei) +def glMultiDrawElementsIndirectEXT(mode,type,indirect,drawcount,stride):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/multisampled_compatibility.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/multisampled_compatibility.py new file mode 100644 index 00000000..da20ecc4 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/multisampled_compatibility.py @@ -0,0 +1,16 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_EXT_multisampled_compatibility' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_EXT_multisampled_compatibility',error_checker=_errors._error_checker) +GL_MULTISAMPLE_EXT=_C('GL_MULTISAMPLE_EXT',0x809D) +GL_SAMPLE_ALPHA_TO_ONE_EXT=_C('GL_SAMPLE_ALPHA_TO_ONE_EXT',0x809F) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/multisampled_render_to_texture.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/multisampled_render_to_texture.py new file mode 100644 index 00000000..d29b347a --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/multisampled_render_to_texture.py @@ -0,0 +1,23 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_EXT_multisampled_render_to_texture' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_EXT_multisampled_render_to_texture',error_checker=_errors._error_checker) +GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_SAMPLES_EXT=_C('GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_SAMPLES_EXT',0x8D6C) +GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_EXT=_C('GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_EXT',0x8D56) +GL_MAX_SAMPLES_EXT=_C('GL_MAX_SAMPLES_EXT',0x8D57) +GL_RENDERBUFFER_SAMPLES_EXT=_C('GL_RENDERBUFFER_SAMPLES_EXT',0x8CAB) +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLenum,_cs.GLuint,_cs.GLint,_cs.GLsizei) +def glFramebufferTexture2DMultisampleEXT(target,attachment,textarget,texture,level,samples):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizei,_cs.GLenum,_cs.GLsizei,_cs.GLsizei) +def glRenderbufferStorageMultisampleEXT(target,samples,internalformat,width,height):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/multiview_draw_buffers.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/multiview_draw_buffers.py new file mode 100644 index 00000000..938a8ef4 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/multiview_draw_buffers.py @@ -0,0 +1,27 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_EXT_multiview_draw_buffers' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_EXT_multiview_draw_buffers',error_checker=_errors._error_checker) +GL_COLOR_ATTACHMENT_EXT=_C('GL_COLOR_ATTACHMENT_EXT',0x90F0) +GL_DRAW_BUFFER_EXT=_C('GL_DRAW_BUFFER_EXT',0x0C01) +GL_MAX_MULTIVIEW_BUFFERS_EXT=_C('GL_MAX_MULTIVIEW_BUFFERS_EXT',0x90F2) +GL_MULTIVIEW_EXT=_C('GL_MULTIVIEW_EXT',0x90F1) +GL_READ_BUFFER_EXT=_C('GL_READ_BUFFER_EXT',0x0C02) +@_f +@_p.types(None,_cs.GLint,arrays.GLuintArray,arrays.GLintArray) +def glDrawBuffersIndexedEXT(n,location,indices):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,arrays.GLintArray) +def glGetIntegeri_vEXT(target,index,data):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLint) +def glReadBufferIndexedEXT(src,index):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/multiview_tessellation_geometry_shader.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/multiview_tessellation_geometry_shader.py new file mode 100644 index 00000000..d97ecc7a --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/multiview_tessellation_geometry_shader.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_EXT_multiview_tessellation_geometry_shader' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_EXT_multiview_tessellation_geometry_shader',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/multiview_texture_multisample.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/multiview_texture_multisample.py new file mode 100644 index 00000000..d3674e8f --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/multiview_texture_multisample.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_EXT_multiview_texture_multisample' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_EXT_multiview_texture_multisample',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/multiview_timer_query.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/multiview_timer_query.py new file mode 100644 index 00000000..3f93dad7 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/multiview_timer_query.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_EXT_multiview_timer_query' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_EXT_multiview_timer_query',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/occlusion_query_boolean.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/occlusion_query_boolean.py new file mode 100644 index 00000000..522c7e42 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/occlusion_query_boolean.py @@ -0,0 +1,39 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_EXT_occlusion_query_boolean' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_EXT_occlusion_query_boolean',error_checker=_errors._error_checker) +GL_ANY_SAMPLES_PASSED_CONSERVATIVE_EXT=_C('GL_ANY_SAMPLES_PASSED_CONSERVATIVE_EXT',0x8D6A) +GL_ANY_SAMPLES_PASSED_EXT=_C('GL_ANY_SAMPLES_PASSED_EXT',0x8C2F) +GL_CURRENT_QUERY_EXT=_C('GL_CURRENT_QUERY_EXT',0x8865) +GL_QUERY_RESULT_AVAILABLE_EXT=_C('GL_QUERY_RESULT_AVAILABLE_EXT',0x8867) +GL_QUERY_RESULT_EXT=_C('GL_QUERY_RESULT_EXT',0x8866) +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint) +def glBeginQueryEXT(target,id):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray) +def glDeleteQueriesEXT(n,ids):pass +@_f +@_p.types(None,_cs.GLenum) +def glEndQueryEXT(target):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray) +def glGenQueriesEXT(n,ids):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLuintArray) +def glGetQueryObjectuivEXT(id,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLintArray) +def glGetQueryivEXT(target,pname,params):pass +@_f +@_p.types(_cs.GLboolean,_cs.GLuint) +def glIsQueryEXT(id):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/polygon_offset_clamp.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/polygon_offset_clamp.py new file mode 100644 index 00000000..6832e3b6 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/polygon_offset_clamp.py @@ -0,0 +1,17 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_EXT_polygon_offset_clamp' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_EXT_polygon_offset_clamp',error_checker=_errors._error_checker) +GL_POLYGON_OFFSET_CLAMP_EXT=_C('GL_POLYGON_OFFSET_CLAMP_EXT',0x8E1B) +@_f +@_p.types(None,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat) +def glPolygonOffsetClampEXT(factor,units,clamp):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/post_depth_coverage.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/post_depth_coverage.py new file mode 100644 index 00000000..ddce1fce --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/post_depth_coverage.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_EXT_post_depth_coverage' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_EXT_post_depth_coverage',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/primitive_bounding_box.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/primitive_bounding_box.py new file mode 100644 index 00000000..4597d13f --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/primitive_bounding_box.py @@ -0,0 +1,17 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_EXT_primitive_bounding_box' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_EXT_primitive_bounding_box',error_checker=_errors._error_checker) +GL_PRIMITIVE_BOUNDING_BOX_EXT=_C('GL_PRIMITIVE_BOUNDING_BOX_EXT',0x92BE) +@_f +@_p.types(None,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat) +def glPrimitiveBoundingBoxEXT(minX,minY,minZ,minW,maxX,maxY,maxZ,maxW):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/protected_textures.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/protected_textures.py new file mode 100644 index 00000000..0aea9260 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/protected_textures.py @@ -0,0 +1,16 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_EXT_protected_textures' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_EXT_protected_textures',error_checker=_errors._error_checker) +GL_CONTEXT_FLAG_PROTECTED_CONTENT_BIT_EXT=_C('GL_CONTEXT_FLAG_PROTECTED_CONTENT_BIT_EXT',0x00000010) +GL_TEXTURE_PROTECTED_EXT=_C('GL_TEXTURE_PROTECTED_EXT',0x8BFA) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/pvrtc_sRGB.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/pvrtc_sRGB.py new file mode 100644 index 00000000..ed07db77 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/pvrtc_sRGB.py @@ -0,0 +1,20 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_EXT_pvrtc_sRGB' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_EXT_pvrtc_sRGB',error_checker=_errors._error_checker) +GL_COMPRESSED_SRGB_ALPHA_PVRTC_2BPPV1_EXT=_C('GL_COMPRESSED_SRGB_ALPHA_PVRTC_2BPPV1_EXT',0x8A56) +GL_COMPRESSED_SRGB_ALPHA_PVRTC_2BPPV2_IMG=_C('GL_COMPRESSED_SRGB_ALPHA_PVRTC_2BPPV2_IMG',0x93F0) +GL_COMPRESSED_SRGB_ALPHA_PVRTC_4BPPV1_EXT=_C('GL_COMPRESSED_SRGB_ALPHA_PVRTC_4BPPV1_EXT',0x8A57) +GL_COMPRESSED_SRGB_ALPHA_PVRTC_4BPPV2_IMG=_C('GL_COMPRESSED_SRGB_ALPHA_PVRTC_4BPPV2_IMG',0x93F1) +GL_COMPRESSED_SRGB_PVRTC_2BPPV1_EXT=_C('GL_COMPRESSED_SRGB_PVRTC_2BPPV1_EXT',0x8A54) +GL_COMPRESSED_SRGB_PVRTC_4BPPV1_EXT=_C('GL_COMPRESSED_SRGB_PVRTC_4BPPV1_EXT',0x8A55) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/raster_multisample.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/raster_multisample.py new file mode 100644 index 00000000..f2201766 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/raster_multisample.py @@ -0,0 +1,22 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_EXT_raster_multisample' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_EXT_raster_multisample',error_checker=_errors._error_checker) +GL_EFFECTIVE_RASTER_SAMPLES_EXT=_C('GL_EFFECTIVE_RASTER_SAMPLES_EXT',0x932C) +GL_MAX_RASTER_SAMPLES_EXT=_C('GL_MAX_RASTER_SAMPLES_EXT',0x9329) +GL_MULTISAMPLE_RASTERIZATION_ALLOWED_EXT=_C('GL_MULTISAMPLE_RASTERIZATION_ALLOWED_EXT',0x932B) +GL_RASTER_FIXED_SAMPLE_LOCATIONS_EXT=_C('GL_RASTER_FIXED_SAMPLE_LOCATIONS_EXT',0x932A) +GL_RASTER_MULTISAMPLE_EXT=_C('GL_RASTER_MULTISAMPLE_EXT',0x9327) +GL_RASTER_SAMPLES_EXT=_C('GL_RASTER_SAMPLES_EXT',0x9328) +@_f +@_p.types(None,_cs.GLuint,_cs.GLboolean) +def glRasterSamplesEXT(samples,fixedsamplelocations):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/read_format_bgra.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/read_format_bgra.py new file mode 100644 index 00000000..c0d013d3 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/read_format_bgra.py @@ -0,0 +1,17 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_EXT_read_format_bgra' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_EXT_read_format_bgra',error_checker=_errors._error_checker) +GL_BGRA_EXT=_C('GL_BGRA_EXT',0x80E1) +GL_UNSIGNED_SHORT_1_5_5_5_REV_EXT=_C('GL_UNSIGNED_SHORT_1_5_5_5_REV_EXT',0x8366) +GL_UNSIGNED_SHORT_4_4_4_4_REV_EXT=_C('GL_UNSIGNED_SHORT_4_4_4_4_REV_EXT',0x8365) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/render_snorm.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/render_snorm.py new file mode 100644 index 00000000..c4f40995 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/render_snorm.py @@ -0,0 +1,22 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_EXT_render_snorm' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_EXT_render_snorm',error_checker=_errors._error_checker) +GL_BYTE=_C('GL_BYTE',0x1400) +GL_R16_SNORM_EXT=_C('GL_R16_SNORM_EXT',0x8F98) +GL_R8_SNORM=_C('GL_R8_SNORM',0x8F94) +GL_RG16_SNORM_EXT=_C('GL_RG16_SNORM_EXT',0x8F99) +GL_RG8_SNORM=_C('GL_RG8_SNORM',0x8F95) +GL_RGBA16_SNORM_EXT=_C('GL_RGBA16_SNORM_EXT',0x8F9B) +GL_RGBA8_SNORM=_C('GL_RGBA8_SNORM',0x8F97) +GL_SHORT=_C('GL_SHORT',0x1402) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/robustness.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/robustness.py new file mode 100644 index 00000000..eb91c6da --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/robustness.py @@ -0,0 +1,33 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_EXT_robustness' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_EXT_robustness',error_checker=_errors._error_checker) +GL_CONTEXT_ROBUST_ACCESS_EXT=_C('GL_CONTEXT_ROBUST_ACCESS_EXT',0x90F3) +GL_GUILTY_CONTEXT_RESET_EXT=_C('GL_GUILTY_CONTEXT_RESET_EXT',0x8253) +GL_INNOCENT_CONTEXT_RESET_EXT=_C('GL_INNOCENT_CONTEXT_RESET_EXT',0x8254) +GL_LOSE_CONTEXT_ON_RESET_EXT=_C('GL_LOSE_CONTEXT_ON_RESET_EXT',0x8252) +GL_NO_ERROR=_C('GL_NO_ERROR',0) +GL_NO_RESET_NOTIFICATION_EXT=_C('GL_NO_RESET_NOTIFICATION_EXT',0x8261) +GL_RESET_NOTIFICATION_STRATEGY_EXT=_C('GL_RESET_NOTIFICATION_STRATEGY_EXT',0x8256) +GL_UNKNOWN_CONTEXT_RESET_EXT=_C('GL_UNKNOWN_CONTEXT_RESET_EXT',0x8255) +@_f +@_p.types(_cs.GLenum,) +def glGetGraphicsResetStatusEXT():pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLfloatArray) +def glGetnUniformfvEXT(program,location,bufSize,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLintArray) +def glGetnUniformivEXT(program,location,bufSize,params):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLsizei,_cs.GLenum,_cs.GLenum,_cs.GLsizei,ctypes.c_void_p) +def glReadnPixelsEXT(x,y,width,height,format,type,bufSize,data):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/sRGB.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/sRGB.py new file mode 100644 index 00000000..d691287a --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/sRGB.py @@ -0,0 +1,18 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_EXT_sRGB' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_EXT_sRGB',error_checker=_errors._error_checker) +GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING_EXT=_C('GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING_EXT',0x8210) +GL_SRGB8_ALPHA8_EXT=_C('GL_SRGB8_ALPHA8_EXT',0x8C43) +GL_SRGB_ALPHA_EXT=_C('GL_SRGB_ALPHA_EXT',0x8C42) +GL_SRGB_EXT=_C('GL_SRGB_EXT',0x8C40) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/sRGB_write_control.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/sRGB_write_control.py new file mode 100644 index 00000000..ebfca4fa --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/sRGB_write_control.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_EXT_sRGB_write_control' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_EXT_sRGB_write_control',error_checker=_errors._error_checker) +GL_FRAMEBUFFER_SRGB_EXT=_C('GL_FRAMEBUFFER_SRGB_EXT',0x8DB9) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/semaphore.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/semaphore.py new file mode 100644 index 00000000..40fac64c --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/semaphore.py @@ -0,0 +1,53 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_EXT_semaphore' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_EXT_semaphore',error_checker=_errors._error_checker) +GL_DEVICE_UUID_EXT=_C('GL_DEVICE_UUID_EXT',0x9597) +GL_DRIVER_UUID_EXT=_C('GL_DRIVER_UUID_EXT',0x9598) +GL_LAYOUT_COLOR_ATTACHMENT_EXT=_C('GL_LAYOUT_COLOR_ATTACHMENT_EXT',0x958E) +GL_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_EXT=_C('GL_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_EXT',0x9531) +GL_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_EXT=_C('GL_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_EXT',0x9530) +GL_LAYOUT_DEPTH_STENCIL_ATTACHMENT_EXT=_C('GL_LAYOUT_DEPTH_STENCIL_ATTACHMENT_EXT',0x958F) +GL_LAYOUT_DEPTH_STENCIL_READ_ONLY_EXT=_C('GL_LAYOUT_DEPTH_STENCIL_READ_ONLY_EXT',0x9590) +GL_LAYOUT_GENERAL_EXT=_C('GL_LAYOUT_GENERAL_EXT',0x958D) +GL_LAYOUT_SHADER_READ_ONLY_EXT=_C('GL_LAYOUT_SHADER_READ_ONLY_EXT',0x9591) +GL_LAYOUT_TRANSFER_DST_EXT=_C('GL_LAYOUT_TRANSFER_DST_EXT',0x9593) +GL_LAYOUT_TRANSFER_SRC_EXT=_C('GL_LAYOUT_TRANSFER_SRC_EXT',0x9592) +GL_NUM_DEVICE_UUIDS_EXT=_C('GL_NUM_DEVICE_UUIDS_EXT',0x9596) +GL_UUID_SIZE_EXT=_C('GL_UUID_SIZE_EXT',16) +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray) +def glDeleteSemaphoresEXT(n,semaphores):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray) +def glGenSemaphoresEXT(n,semaphores):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLuint64Array) +def glGetSemaphoreParameterui64vEXT(semaphore,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,arrays.GLubyteArray) +def glGetUnsignedBytei_vEXT(target,index,data):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLubyteArray) +def glGetUnsignedBytevEXT(pname,data):pass +@_f +@_p.types(_cs.GLboolean,_cs.GLuint) +def glIsSemaphoreEXT(semaphore):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLuint64Array) +def glSemaphoreParameterui64vEXT(semaphore,pname,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,arrays.GLuintArray,_cs.GLuint,arrays.GLuintArray,arrays.GLuintArray) +def glSignalSemaphoreEXT(semaphore,numBufferBarriers,buffers,numTextureBarriers,textures,dstLayouts):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,arrays.GLuintArray,_cs.GLuint,arrays.GLuintArray,arrays.GLuintArray) +def glWaitSemaphoreEXT(semaphore,numBufferBarriers,buffers,numTextureBarriers,textures,srcLayouts):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/semaphore_fd.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/semaphore_fd.py new file mode 100644 index 00000000..3f48c917 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/semaphore_fd.py @@ -0,0 +1,17 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_EXT_semaphore_fd' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_EXT_semaphore_fd',error_checker=_errors._error_checker) +GL_HANDLE_TYPE_OPAQUE_FD_EXT=_C('GL_HANDLE_TYPE_OPAQUE_FD_EXT',0x9586) +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLint) +def glImportSemaphoreFdEXT(semaphore,handleType,fd):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/semaphore_win32.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/semaphore_win32.py new file mode 100644 index 00000000..98180176 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/semaphore_win32.py @@ -0,0 +1,26 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_EXT_semaphore_win32' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_EXT_semaphore_win32',error_checker=_errors._error_checker) +GL_D3D12_FENCE_VALUE_EXT=_C('GL_D3D12_FENCE_VALUE_EXT',0x9595) +GL_DEVICE_LUID_EXT=_C('GL_DEVICE_LUID_EXT',0x9599) +GL_DEVICE_NODE_MASK_EXT=_C('GL_DEVICE_NODE_MASK_EXT',0x959A) +GL_HANDLE_TYPE_D3D12_FENCE_EXT=_C('GL_HANDLE_TYPE_D3D12_FENCE_EXT',0x9594) +GL_HANDLE_TYPE_OPAQUE_WIN32_EXT=_C('GL_HANDLE_TYPE_OPAQUE_WIN32_EXT',0x9587) +GL_HANDLE_TYPE_OPAQUE_WIN32_KMT_EXT=_C('GL_HANDLE_TYPE_OPAQUE_WIN32_KMT_EXT',0x9588) +GL_LUID_SIZE_EXT=_C('GL_LUID_SIZE_EXT',8) +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,ctypes.c_void_p) +def glImportSemaphoreWin32HandleEXT(semaphore,handleType,handle):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,ctypes.c_void_p) +def glImportSemaphoreWin32NameEXT(semaphore,handleType,name):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/separate_shader_objects.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/separate_shader_objects.py new file mode 100644 index 00000000..1817fbf9 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/separate_shader_objects.py @@ -0,0 +1,164 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_EXT_separate_shader_objects' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_EXT_separate_shader_objects',error_checker=_errors._error_checker) +GL_ACTIVE_PROGRAM_EXT=_C('GL_ACTIVE_PROGRAM_EXT',0x8B8D) +GL_ACTIVE_PROGRAM_EXT=_C('GL_ACTIVE_PROGRAM_EXT',0x8B8D) +GL_ALL_SHADER_BITS_EXT=_C('GL_ALL_SHADER_BITS_EXT',0xFFFFFFFF) +GL_FRAGMENT_SHADER_BIT_EXT=_C('GL_FRAGMENT_SHADER_BIT_EXT',0x00000002) +GL_PROGRAM_PIPELINE_BINDING_EXT=_C('GL_PROGRAM_PIPELINE_BINDING_EXT',0x825A) +GL_PROGRAM_SEPARABLE_EXT=_C('GL_PROGRAM_SEPARABLE_EXT',0x8258) +GL_VERTEX_SHADER_BIT_EXT=_C('GL_VERTEX_SHADER_BIT_EXT',0x00000001) +@_f +@_p.types(None,_cs.GLuint) +def glActiveProgramEXT(program):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint) +def glActiveShaderProgramEXT(pipeline,program):pass +@_f +@_p.types(None,_cs.GLuint) +def glBindProgramPipelineEXT(pipeline):pass +@_f +@_p.types(_cs.GLuint,_cs.GLenum,arrays.GLcharArray) +def glCreateShaderProgramEXT(type,string):pass +@_f +@_p.types(_cs.GLuint,_cs.GLenum,_cs.GLsizei,ctypes.POINTER( ctypes.POINTER( _cs.GLchar ))) +def glCreateShaderProgramvEXT(type,count,strings):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray) +def glDeleteProgramPipelinesEXT(n,pipelines):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray) +def glGenProgramPipelinesEXT(n,pipelines):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizei,arrays.GLsizeiArray,arrays.GLcharArray) +def glGetProgramPipelineInfoLogEXT(pipeline,bufSize,length,infoLog):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLintArray) +def glGetProgramPipelineivEXT(pipeline,pname,params):pass +@_f +@_p.types(_cs.GLboolean,_cs.GLuint) +def glIsProgramPipelineEXT(pipeline):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLint) +def glProgramParameteriEXT(program,pname,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLfloat) +def glProgramUniform1fEXT(program,location,v0):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLfloatArray) +def glProgramUniform1fvEXT(program,location,count,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLint) +def glProgramUniform1iEXT(program,location,v0):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLintArray) +def glProgramUniform1ivEXT(program,location,count,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLuint) +def glProgramUniform1uiEXT(program,location,v0):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLuintArray) +def glProgramUniform1uivEXT(program,location,count,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLfloat,_cs.GLfloat) +def glProgramUniform2fEXT(program,location,v0,v1):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLfloatArray) +def glProgramUniform2fvEXT(program,location,count,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLint,_cs.GLint) +def glProgramUniform2iEXT(program,location,v0,v1):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLintArray) +def glProgramUniform2ivEXT(program,location,count,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLuint,_cs.GLuint) +def glProgramUniform2uiEXT(program,location,v0,v1):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLuintArray) +def glProgramUniform2uivEXT(program,location,count,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat) +def glProgramUniform3fEXT(program,location,v0,v1,v2):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLfloatArray) +def glProgramUniform3fvEXT(program,location,count,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint) +def glProgramUniform3iEXT(program,location,v0,v1,v2):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLintArray) +def glProgramUniform3ivEXT(program,location,count,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLuint,_cs.GLuint,_cs.GLuint) +def glProgramUniform3uiEXT(program,location,v0,v1,v2):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLuintArray) +def glProgramUniform3uivEXT(program,location,count,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat) +def glProgramUniform4fEXT(program,location,v0,v1,v2,v3):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLfloatArray) +def glProgramUniform4fvEXT(program,location,count,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint) +def glProgramUniform4iEXT(program,location,v0,v1,v2,v3):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLintArray) +def glProgramUniform4ivEXT(program,location,count,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLuint,_cs.GLuint,_cs.GLuint,_cs.GLuint) +def glProgramUniform4uiEXT(program,location,v0,v1,v2,v3):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLuintArray) +def glProgramUniform4uivEXT(program,location,count,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,_cs.GLboolean,arrays.GLfloatArray) +def glProgramUniformMatrix2fvEXT(program,location,count,transpose,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,_cs.GLboolean,arrays.GLfloatArray) +def glProgramUniformMatrix2x3fvEXT(program,location,count,transpose,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,_cs.GLboolean,arrays.GLfloatArray) +def glProgramUniformMatrix2x4fvEXT(program,location,count,transpose,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,_cs.GLboolean,arrays.GLfloatArray) +def glProgramUniformMatrix3fvEXT(program,location,count,transpose,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,_cs.GLboolean,arrays.GLfloatArray) +def glProgramUniformMatrix3x2fvEXT(program,location,count,transpose,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,_cs.GLboolean,arrays.GLfloatArray) +def glProgramUniformMatrix3x4fvEXT(program,location,count,transpose,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,_cs.GLboolean,arrays.GLfloatArray) +def glProgramUniformMatrix4fvEXT(program,location,count,transpose,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,_cs.GLboolean,arrays.GLfloatArray) +def glProgramUniformMatrix4fvEXT(program,location,count,transpose,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,_cs.GLboolean,arrays.GLfloatArray) +def glProgramUniformMatrix4x2fvEXT(program,location,count,transpose,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,_cs.GLboolean,arrays.GLfloatArray) +def glProgramUniformMatrix4x3fvEXT(program,location,count,transpose,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLbitfield,_cs.GLuint) +def glUseProgramStagesEXT(pipeline,stages,program):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint) +def glUseShaderProgramEXT(type,program):pass +@_f +@_p.types(None,_cs.GLuint) +def glValidateProgramPipelineEXT(pipeline):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/shader_framebuffer_fetch.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/shader_framebuffer_fetch.py new file mode 100644 index 00000000..de990008 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/shader_framebuffer_fetch.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_EXT_shader_framebuffer_fetch' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_EXT_shader_framebuffer_fetch',error_checker=_errors._error_checker) +GL_FRAGMENT_SHADER_DISCARDS_SAMPLES_EXT=_C('GL_FRAGMENT_SHADER_DISCARDS_SAMPLES_EXT',0x8A52) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/shader_framebuffer_fetch_non_coherent.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/shader_framebuffer_fetch_non_coherent.py new file mode 100644 index 00000000..950afeb7 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/shader_framebuffer_fetch_non_coherent.py @@ -0,0 +1,17 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_EXT_shader_framebuffer_fetch_non_coherent' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_EXT_shader_framebuffer_fetch_non_coherent',error_checker=_errors._error_checker) +GL_FRAGMENT_SHADER_DISCARDS_SAMPLES_EXT=_C('GL_FRAGMENT_SHADER_DISCARDS_SAMPLES_EXT',0x8A52) +@_f +@_p.types(None,) +def glFramebufferFetchBarrierEXT():pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/shader_group_vote.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/shader_group_vote.py new file mode 100644 index 00000000..7a9c9d81 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/shader_group_vote.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_EXT_shader_group_vote' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_EXT_shader_group_vote',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/shader_implicit_conversions.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/shader_implicit_conversions.py new file mode 100644 index 00000000..5f32d257 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/shader_implicit_conversions.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_EXT_shader_implicit_conversions' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_EXT_shader_implicit_conversions',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/shader_integer_mix.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/shader_integer_mix.py new file mode 100644 index 00000000..6304e71f --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/shader_integer_mix.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_EXT_shader_integer_mix' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_EXT_shader_integer_mix',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/shader_io_blocks.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/shader_io_blocks.py new file mode 100644 index 00000000..84090b6d --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/shader_io_blocks.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_EXT_shader_io_blocks' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_EXT_shader_io_blocks',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/shader_non_constant_global_initializers.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/shader_non_constant_global_initializers.py new file mode 100644 index 00000000..769c4e6a --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/shader_non_constant_global_initializers.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_EXT_shader_non_constant_global_initializers' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_EXT_shader_non_constant_global_initializers',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/shader_pixel_local_storage.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/shader_pixel_local_storage.py new file mode 100644 index 00000000..5b929e58 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/shader_pixel_local_storage.py @@ -0,0 +1,17 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_EXT_shader_pixel_local_storage' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_EXT_shader_pixel_local_storage',error_checker=_errors._error_checker) +GL_MAX_SHADER_PIXEL_LOCAL_STORAGE_FAST_SIZE_EXT=_C('GL_MAX_SHADER_PIXEL_LOCAL_STORAGE_FAST_SIZE_EXT',0x8F63) +GL_MAX_SHADER_PIXEL_LOCAL_STORAGE_SIZE_EXT=_C('GL_MAX_SHADER_PIXEL_LOCAL_STORAGE_SIZE_EXT',0x8F67) +GL_SHADER_PIXEL_LOCAL_STORAGE_EXT=_C('GL_SHADER_PIXEL_LOCAL_STORAGE_EXT',0x8F64) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/shader_pixel_local_storage2.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/shader_pixel_local_storage2.py new file mode 100644 index 00000000..656aa0b5 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/shader_pixel_local_storage2.py @@ -0,0 +1,25 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_EXT_shader_pixel_local_storage2' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_EXT_shader_pixel_local_storage2',error_checker=_errors._error_checker) +GL_FRAMEBUFFER_INCOMPLETE_INSUFFICIENT_SHADER_COMBINED_LOCAL_STORAGE_EXT=_C('GL_FRAMEBUFFER_INCOMPLETE_INSUFFICIENT_SHADER_COMBINED_LOCAL_STORAGE_EXT',0x9652) +GL_MAX_SHADER_COMBINED_LOCAL_STORAGE_FAST_SIZE_EXT=_C('GL_MAX_SHADER_COMBINED_LOCAL_STORAGE_FAST_SIZE_EXT',0x9650) +GL_MAX_SHADER_COMBINED_LOCAL_STORAGE_SIZE_EXT=_C('GL_MAX_SHADER_COMBINED_LOCAL_STORAGE_SIZE_EXT',0x9651) +@_f +@_p.types(None,_cs.GLsizei,_cs.GLsizei,arrays.GLuintArray) +def glClearPixelLocalStorageuiEXT(offset,n,values):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizei) +def glFramebufferPixelLocalStorageSizeEXT(target,size):pass +@_f +@_p.types(_cs.GLsizei,_cs.GLuint) +def glGetFramebufferPixelLocalStorageSizeEXT(target):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/shader_texture_lod.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/shader_texture_lod.py new file mode 100644 index 00000000..8bedf61f --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/shader_texture_lod.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_EXT_shader_texture_lod' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_EXT_shader_texture_lod',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/shadow_samplers.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/shadow_samplers.py new file mode 100644 index 00000000..71e33d66 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/shadow_samplers.py @@ -0,0 +1,18 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_EXT_shadow_samplers' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_EXT_shadow_samplers',error_checker=_errors._error_checker) +GL_COMPARE_REF_TO_TEXTURE_EXT=_C('GL_COMPARE_REF_TO_TEXTURE_EXT',0x884E) +GL_SAMPLER_2D_SHADOW_EXT=_C('GL_SAMPLER_2D_SHADOW_EXT',0x8B62) +GL_TEXTURE_COMPARE_FUNC_EXT=_C('GL_TEXTURE_COMPARE_FUNC_EXT',0x884D) +GL_TEXTURE_COMPARE_MODE_EXT=_C('GL_TEXTURE_COMPARE_MODE_EXT',0x884C) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/sparse_texture.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/sparse_texture.py new file mode 100644 index 00000000..7926acc6 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/sparse_texture.py @@ -0,0 +1,32 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_EXT_sparse_texture' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_EXT_sparse_texture',error_checker=_errors._error_checker) +GL_MAX_SPARSE_3D_TEXTURE_SIZE_EXT=_C('GL_MAX_SPARSE_3D_TEXTURE_SIZE_EXT',0x9199) +GL_MAX_SPARSE_ARRAY_TEXTURE_LAYERS_EXT=_C('GL_MAX_SPARSE_ARRAY_TEXTURE_LAYERS_EXT',0x919A) +GL_MAX_SPARSE_TEXTURE_SIZE_EXT=_C('GL_MAX_SPARSE_TEXTURE_SIZE_EXT',0x9198) +GL_NUM_SPARSE_LEVELS_EXT=_C('GL_NUM_SPARSE_LEVELS_EXT',0x91AA) +GL_NUM_VIRTUAL_PAGE_SIZES_EXT=_C('GL_NUM_VIRTUAL_PAGE_SIZES_EXT',0x91A8) +GL_SPARSE_TEXTURE_FULL_ARRAY_CUBE_MIPMAPS_EXT=_C('GL_SPARSE_TEXTURE_FULL_ARRAY_CUBE_MIPMAPS_EXT',0x91A9) +GL_TEXTURE_2D=_C('GL_TEXTURE_2D',0x0DE1) +GL_TEXTURE_2D_ARRAY=_C('GL_TEXTURE_2D_ARRAY',0x8C1A) +GL_TEXTURE_3D=_C('GL_TEXTURE_3D',0x806F) +GL_TEXTURE_CUBE_MAP=_C('GL_TEXTURE_CUBE_MAP',0x8513) +GL_TEXTURE_CUBE_MAP_ARRAY_OES=_C('GL_TEXTURE_CUBE_MAP_ARRAY_OES',0x9009) +GL_TEXTURE_SPARSE_EXT=_C('GL_TEXTURE_SPARSE_EXT',0x91A6) +GL_VIRTUAL_PAGE_SIZE_INDEX_EXT=_C('GL_VIRTUAL_PAGE_SIZE_INDEX_EXT',0x91A7) +GL_VIRTUAL_PAGE_SIZE_X_EXT=_C('GL_VIRTUAL_PAGE_SIZE_X_EXT',0x9195) +GL_VIRTUAL_PAGE_SIZE_Y_EXT=_C('GL_VIRTUAL_PAGE_SIZE_Y_EXT',0x9196) +GL_VIRTUAL_PAGE_SIZE_Z_EXT=_C('GL_VIRTUAL_PAGE_SIZE_Z_EXT',0x9197) +@_f +@_p.types(None,_cs.GLenum,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLsizei,_cs.GLsizei,_cs.GLboolean) +def glTexPageCommitmentEXT(target,level,xoffset,yoffset,zoffset,width,height,depth,commit):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/sparse_texture2.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/sparse_texture2.py new file mode 100644 index 00000000..ba851153 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/sparse_texture2.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_EXT_sparse_texture2' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_EXT_sparse_texture2',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/tessellation_point_size.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/tessellation_point_size.py new file mode 100644 index 00000000..737357e9 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/tessellation_point_size.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_EXT_tessellation_point_size' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_EXT_tessellation_point_size',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/tessellation_shader.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/tessellation_shader.py new file mode 100644 index 00000000..04755270 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/tessellation_shader.py @@ -0,0 +1,63 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_EXT_tessellation_shader' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_EXT_tessellation_shader',error_checker=_errors._error_checker) +GL_CCW=_C('GL_CCW',0x0901) +GL_CW=_C('GL_CW',0x0900) +GL_EQUAL=_C('GL_EQUAL',0x0202) +GL_FRACTIONAL_EVEN_EXT=_C('GL_FRACTIONAL_EVEN_EXT',0x8E7C) +GL_FRACTIONAL_ODD_EXT=_C('GL_FRACTIONAL_ODD_EXT',0x8E7B) +GL_ISOLINES_EXT=_C('GL_ISOLINES_EXT',0x8E7A) +GL_IS_PER_PATCH_EXT=_C('GL_IS_PER_PATCH_EXT',0x92E7) +GL_MAX_COMBINED_TESS_CONTROL_UNIFORM_COMPONENTS_EXT=_C('GL_MAX_COMBINED_TESS_CONTROL_UNIFORM_COMPONENTS_EXT',0x8E1E) +GL_MAX_COMBINED_TESS_EVALUATION_UNIFORM_COMPONENTS_EXT=_C('GL_MAX_COMBINED_TESS_EVALUATION_UNIFORM_COMPONENTS_EXT',0x8E1F) +GL_MAX_PATCH_VERTICES_EXT=_C('GL_MAX_PATCH_VERTICES_EXT',0x8E7D) +GL_MAX_TESS_CONTROL_ATOMIC_COUNTERS_EXT=_C('GL_MAX_TESS_CONTROL_ATOMIC_COUNTERS_EXT',0x92D3) +GL_MAX_TESS_CONTROL_ATOMIC_COUNTER_BUFFERS_EXT=_C('GL_MAX_TESS_CONTROL_ATOMIC_COUNTER_BUFFERS_EXT',0x92CD) +GL_MAX_TESS_CONTROL_IMAGE_UNIFORMS_EXT=_C('GL_MAX_TESS_CONTROL_IMAGE_UNIFORMS_EXT',0x90CB) +GL_MAX_TESS_CONTROL_INPUT_COMPONENTS_EXT=_C('GL_MAX_TESS_CONTROL_INPUT_COMPONENTS_EXT',0x886C) +GL_MAX_TESS_CONTROL_OUTPUT_COMPONENTS_EXT=_C('GL_MAX_TESS_CONTROL_OUTPUT_COMPONENTS_EXT',0x8E83) +GL_MAX_TESS_CONTROL_SHADER_STORAGE_BLOCKS_EXT=_C('GL_MAX_TESS_CONTROL_SHADER_STORAGE_BLOCKS_EXT',0x90D8) +GL_MAX_TESS_CONTROL_TEXTURE_IMAGE_UNITS_EXT=_C('GL_MAX_TESS_CONTROL_TEXTURE_IMAGE_UNITS_EXT',0x8E81) +GL_MAX_TESS_CONTROL_TOTAL_OUTPUT_COMPONENTS_EXT=_C('GL_MAX_TESS_CONTROL_TOTAL_OUTPUT_COMPONENTS_EXT',0x8E85) +GL_MAX_TESS_CONTROL_UNIFORM_BLOCKS_EXT=_C('GL_MAX_TESS_CONTROL_UNIFORM_BLOCKS_EXT',0x8E89) +GL_MAX_TESS_CONTROL_UNIFORM_COMPONENTS_EXT=_C('GL_MAX_TESS_CONTROL_UNIFORM_COMPONENTS_EXT',0x8E7F) +GL_MAX_TESS_EVALUATION_ATOMIC_COUNTERS_EXT=_C('GL_MAX_TESS_EVALUATION_ATOMIC_COUNTERS_EXT',0x92D4) +GL_MAX_TESS_EVALUATION_ATOMIC_COUNTER_BUFFERS_EXT=_C('GL_MAX_TESS_EVALUATION_ATOMIC_COUNTER_BUFFERS_EXT',0x92CE) +GL_MAX_TESS_EVALUATION_IMAGE_UNIFORMS_EXT=_C('GL_MAX_TESS_EVALUATION_IMAGE_UNIFORMS_EXT',0x90CC) +GL_MAX_TESS_EVALUATION_INPUT_COMPONENTS_EXT=_C('GL_MAX_TESS_EVALUATION_INPUT_COMPONENTS_EXT',0x886D) +GL_MAX_TESS_EVALUATION_OUTPUT_COMPONENTS_EXT=_C('GL_MAX_TESS_EVALUATION_OUTPUT_COMPONENTS_EXT',0x8E86) +GL_MAX_TESS_EVALUATION_SHADER_STORAGE_BLOCKS_EXT=_C('GL_MAX_TESS_EVALUATION_SHADER_STORAGE_BLOCKS_EXT',0x90D9) +GL_MAX_TESS_EVALUATION_TEXTURE_IMAGE_UNITS_EXT=_C('GL_MAX_TESS_EVALUATION_TEXTURE_IMAGE_UNITS_EXT',0x8E82) +GL_MAX_TESS_EVALUATION_UNIFORM_BLOCKS_EXT=_C('GL_MAX_TESS_EVALUATION_UNIFORM_BLOCKS_EXT',0x8E8A) +GL_MAX_TESS_EVALUATION_UNIFORM_COMPONENTS_EXT=_C('GL_MAX_TESS_EVALUATION_UNIFORM_COMPONENTS_EXT',0x8E80) +GL_MAX_TESS_GEN_LEVEL_EXT=_C('GL_MAX_TESS_GEN_LEVEL_EXT',0x8E7E) +GL_MAX_TESS_PATCH_COMPONENTS_EXT=_C('GL_MAX_TESS_PATCH_COMPONENTS_EXT',0x8E84) +GL_PATCHES_EXT=_C('GL_PATCHES_EXT',0x000E) +GL_PATCH_VERTICES_EXT=_C('GL_PATCH_VERTICES_EXT',0x8E72) +GL_PRIMITIVE_RESTART_FOR_PATCHES_SUPPORTED=_C('GL_PRIMITIVE_RESTART_FOR_PATCHES_SUPPORTED',0x8221) +GL_QUADS_EXT=_C('GL_QUADS_EXT',0x0007) +GL_REFERENCED_BY_TESS_CONTROL_SHADER_EXT=_C('GL_REFERENCED_BY_TESS_CONTROL_SHADER_EXT',0x9307) +GL_REFERENCED_BY_TESS_EVALUATION_SHADER_EXT=_C('GL_REFERENCED_BY_TESS_EVALUATION_SHADER_EXT',0x9308) +GL_TESS_CONTROL_OUTPUT_VERTICES_EXT=_C('GL_TESS_CONTROL_OUTPUT_VERTICES_EXT',0x8E75) +GL_TESS_CONTROL_SHADER_BIT_EXT=_C('GL_TESS_CONTROL_SHADER_BIT_EXT',0x00000008) +GL_TESS_CONTROL_SHADER_EXT=_C('GL_TESS_CONTROL_SHADER_EXT',0x8E88) +GL_TESS_EVALUATION_SHADER_BIT_EXT=_C('GL_TESS_EVALUATION_SHADER_BIT_EXT',0x00000010) +GL_TESS_EVALUATION_SHADER_EXT=_C('GL_TESS_EVALUATION_SHADER_EXT',0x8E87) +GL_TESS_GEN_MODE_EXT=_C('GL_TESS_GEN_MODE_EXT',0x8E76) +GL_TESS_GEN_POINT_MODE_EXT=_C('GL_TESS_GEN_POINT_MODE_EXT',0x8E79) +GL_TESS_GEN_SPACING_EXT=_C('GL_TESS_GEN_SPACING_EXT',0x8E77) +GL_TESS_GEN_VERTEX_ORDER_EXT=_C('GL_TESS_GEN_VERTEX_ORDER_EXT',0x8E78) +GL_TRIANGLES=_C('GL_TRIANGLES',0x0004) +@_f +@_p.types(None,_cs.GLenum,_cs.GLint) +def glPatchParameteriEXT(pname,value):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/texture_border_clamp.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/texture_border_clamp.py new file mode 100644 index 00000000..4d5221e4 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/texture_border_clamp.py @@ -0,0 +1,39 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_EXT_texture_border_clamp' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_EXT_texture_border_clamp',error_checker=_errors._error_checker) +GL_CLAMP_TO_BORDER_EXT=_C('GL_CLAMP_TO_BORDER_EXT',0x812D) +GL_TEXTURE_BORDER_COLOR_EXT=_C('GL_TEXTURE_BORDER_COLOR_EXT',0x1004) +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLintArray) +def glGetSamplerParameterIivEXT(sampler,pname,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLuintArray) +def glGetSamplerParameterIuivEXT(sampler,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLintArray) +def glGetTexParameterIivEXT(target,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLuintArray) +def glGetTexParameterIuivEXT(target,pname,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLintArray) +def glSamplerParameterIivEXT(sampler,pname,param):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLuintArray) +def glSamplerParameterIuivEXT(sampler,pname,param):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLintArray) +def glTexParameterIivEXT(target,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLuintArray) +def glTexParameterIuivEXT(target,pname,params):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/texture_buffer.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/texture_buffer.py new file mode 100644 index 00000000..a7264ecd --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/texture_buffer.py @@ -0,0 +1,33 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_EXT_texture_buffer' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_EXT_texture_buffer',error_checker=_errors._error_checker) +GL_IMAGE_BUFFER_EXT=_C('GL_IMAGE_BUFFER_EXT',0x9051) +GL_INT_IMAGE_BUFFER_EXT=_C('GL_INT_IMAGE_BUFFER_EXT',0x905C) +GL_INT_SAMPLER_BUFFER_EXT=_C('GL_INT_SAMPLER_BUFFER_EXT',0x8DD0) +GL_MAX_TEXTURE_BUFFER_SIZE_EXT=_C('GL_MAX_TEXTURE_BUFFER_SIZE_EXT',0x8C2B) +GL_SAMPLER_BUFFER_EXT=_C('GL_SAMPLER_BUFFER_EXT',0x8DC2) +GL_TEXTURE_BINDING_BUFFER_EXT=_C('GL_TEXTURE_BINDING_BUFFER_EXT',0x8C2C) +GL_TEXTURE_BUFFER_BINDING_EXT=_C('GL_TEXTURE_BUFFER_BINDING_EXT',0x8C2A) +GL_TEXTURE_BUFFER_DATA_STORE_BINDING_EXT=_C('GL_TEXTURE_BUFFER_DATA_STORE_BINDING_EXT',0x8C2D) +GL_TEXTURE_BUFFER_EXT=_C('GL_TEXTURE_BUFFER_EXT',0x8C2A) +GL_TEXTURE_BUFFER_OFFSET_ALIGNMENT_EXT=_C('GL_TEXTURE_BUFFER_OFFSET_ALIGNMENT_EXT',0x919F) +GL_TEXTURE_BUFFER_OFFSET_EXT=_C('GL_TEXTURE_BUFFER_OFFSET_EXT',0x919D) +GL_TEXTURE_BUFFER_SIZE_EXT=_C('GL_TEXTURE_BUFFER_SIZE_EXT',0x919E) +GL_UNSIGNED_INT_IMAGE_BUFFER_EXT=_C('GL_UNSIGNED_INT_IMAGE_BUFFER_EXT',0x9067) +GL_UNSIGNED_INT_SAMPLER_BUFFER_EXT=_C('GL_UNSIGNED_INT_SAMPLER_BUFFER_EXT',0x8DD8) +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLuint) +def glTexBufferEXT(target,internalformat,buffer):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLuint,_cs.GLintptr,_cs.GLsizeiptr) +def glTexBufferRangeEXT(target,internalformat,buffer,offset,size):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/texture_compression_astc_decode_mode.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/texture_compression_astc_decode_mode.py new file mode 100644 index 00000000..3350c489 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/texture_compression_astc_decode_mode.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_EXT_texture_compression_astc_decode_mode' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_EXT_texture_compression_astc_decode_mode',error_checker=_errors._error_checker) +GL_TEXTURE_ASTC_DECODE_PRECISION_EXT=_C('GL_TEXTURE_ASTC_DECODE_PRECISION_EXT',0x8F69) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/texture_compression_bptc.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/texture_compression_bptc.py new file mode 100644 index 00000000..678e3d08 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/texture_compression_bptc.py @@ -0,0 +1,18 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_EXT_texture_compression_bptc' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_EXT_texture_compression_bptc',error_checker=_errors._error_checker) +GL_COMPRESSED_RGBA_BPTC_UNORM_EXT=_C('GL_COMPRESSED_RGBA_BPTC_UNORM_EXT',0x8E8C) +GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT_EXT=_C('GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT_EXT',0x8E8E) +GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT_EXT=_C('GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT_EXT',0x8E8F) +GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM_EXT=_C('GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM_EXT',0x8E8D) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/texture_compression_dxt1.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/texture_compression_dxt1.py new file mode 100644 index 00000000..32d62e39 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/texture_compression_dxt1.py @@ -0,0 +1,16 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_EXT_texture_compression_dxt1' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_EXT_texture_compression_dxt1',error_checker=_errors._error_checker) +GL_COMPRESSED_RGBA_S3TC_DXT1_EXT=_C('GL_COMPRESSED_RGBA_S3TC_DXT1_EXT',0x83F1) +GL_COMPRESSED_RGB_S3TC_DXT1_EXT=_C('GL_COMPRESSED_RGB_S3TC_DXT1_EXT',0x83F0) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/texture_compression_rgtc.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/texture_compression_rgtc.py new file mode 100644 index 00000000..ae8b6fda --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/texture_compression_rgtc.py @@ -0,0 +1,18 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_EXT_texture_compression_rgtc' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_EXT_texture_compression_rgtc',error_checker=_errors._error_checker) +GL_COMPRESSED_RED_GREEN_RGTC2_EXT=_C('GL_COMPRESSED_RED_GREEN_RGTC2_EXT',0x8DBD) +GL_COMPRESSED_RED_RGTC1_EXT=_C('GL_COMPRESSED_RED_RGTC1_EXT',0x8DBB) +GL_COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT=_C('GL_COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT',0x8DBE) +GL_COMPRESSED_SIGNED_RED_RGTC1_EXT=_C('GL_COMPRESSED_SIGNED_RED_RGTC1_EXT',0x8DBC) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/texture_compression_s3tc.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/texture_compression_s3tc.py new file mode 100644 index 00000000..577f9ef9 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/texture_compression_s3tc.py @@ -0,0 +1,18 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_EXT_texture_compression_s3tc' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_EXT_texture_compression_s3tc',error_checker=_errors._error_checker) +GL_COMPRESSED_RGBA_S3TC_DXT1_EXT=_C('GL_COMPRESSED_RGBA_S3TC_DXT1_EXT',0x83F1) +GL_COMPRESSED_RGBA_S3TC_DXT3_EXT=_C('GL_COMPRESSED_RGBA_S3TC_DXT3_EXT',0x83F2) +GL_COMPRESSED_RGBA_S3TC_DXT5_EXT=_C('GL_COMPRESSED_RGBA_S3TC_DXT5_EXT',0x83F3) +GL_COMPRESSED_RGB_S3TC_DXT1_EXT=_C('GL_COMPRESSED_RGB_S3TC_DXT1_EXT',0x83F0) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/texture_compression_s3tc_srgb.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/texture_compression_s3tc_srgb.py new file mode 100644 index 00000000..0a6e9559 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/texture_compression_s3tc_srgb.py @@ -0,0 +1,18 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_EXT_texture_compression_s3tc_srgb' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_EXT_texture_compression_s3tc_srgb',error_checker=_errors._error_checker) +GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT=_C('GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT',0x8C4D) +GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT=_C('GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT',0x8C4E) +GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT=_C('GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT',0x8C4F) +GL_COMPRESSED_SRGB_S3TC_DXT1_EXT=_C('GL_COMPRESSED_SRGB_S3TC_DXT1_EXT',0x8C4C) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/texture_cube_map_array.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/texture_cube_map_array.py new file mode 100644 index 00000000..46e6c8b3 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/texture_cube_map_array.py @@ -0,0 +1,23 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_EXT_texture_cube_map_array' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_EXT_texture_cube_map_array',error_checker=_errors._error_checker) +GL_IMAGE_CUBE_MAP_ARRAY_EXT=_C('GL_IMAGE_CUBE_MAP_ARRAY_EXT',0x9054) +GL_INT_IMAGE_CUBE_MAP_ARRAY_EXT=_C('GL_INT_IMAGE_CUBE_MAP_ARRAY_EXT',0x905F) +GL_INT_SAMPLER_CUBE_MAP_ARRAY_EXT=_C('GL_INT_SAMPLER_CUBE_MAP_ARRAY_EXT',0x900E) +GL_SAMPLER_CUBE_MAP_ARRAY_EXT=_C('GL_SAMPLER_CUBE_MAP_ARRAY_EXT',0x900C) +GL_SAMPLER_CUBE_MAP_ARRAY_SHADOW_EXT=_C('GL_SAMPLER_CUBE_MAP_ARRAY_SHADOW_EXT',0x900D) +GL_TEXTURE_BINDING_CUBE_MAP_ARRAY_EXT=_C('GL_TEXTURE_BINDING_CUBE_MAP_ARRAY_EXT',0x900A) +GL_TEXTURE_CUBE_MAP_ARRAY_EXT=_C('GL_TEXTURE_CUBE_MAP_ARRAY_EXT',0x9009) +GL_UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY_EXT=_C('GL_UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY_EXT',0x906A) +GL_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY_EXT=_C('GL_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY_EXT',0x900F) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/texture_filter_anisotropic.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/texture_filter_anisotropic.py new file mode 100644 index 00000000..b7f61bf4 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/texture_filter_anisotropic.py @@ -0,0 +1,16 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_EXT_texture_filter_anisotropic' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_EXT_texture_filter_anisotropic',error_checker=_errors._error_checker) +GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT=_C('GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT',0x84FF) +GL_TEXTURE_MAX_ANISOTROPY_EXT=_C('GL_TEXTURE_MAX_ANISOTROPY_EXT',0x84FE) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/texture_filter_minmax.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/texture_filter_minmax.py new file mode 100644 index 00000000..b7aad3f9 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/texture_filter_minmax.py @@ -0,0 +1,16 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_EXT_texture_filter_minmax' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_EXT_texture_filter_minmax',error_checker=_errors._error_checker) +GL_TEXTURE_REDUCTION_MODE_EXT=_C('GL_TEXTURE_REDUCTION_MODE_EXT',0x9366) +GL_WEIGHTED_AVERAGE_EXT=_C('GL_WEIGHTED_AVERAGE_EXT',0x9367) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/texture_format_BGRA8888.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/texture_format_BGRA8888.py new file mode 100644 index 00000000..b69e9916 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/texture_format_BGRA8888.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_EXT_texture_format_BGRA8888' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_EXT_texture_format_BGRA8888',error_checker=_errors._error_checker) +GL_BGRA_EXT=_C('GL_BGRA_EXT',0x80E1) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/texture_format_sRGB_override.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/texture_format_sRGB_override.py new file mode 100644 index 00000000..0b408c44 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/texture_format_sRGB_override.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_EXT_texture_format_sRGB_override' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_EXT_texture_format_sRGB_override',error_checker=_errors._error_checker) +GL_TEXTURE_FORMAT_SRGB_OVERRIDE_EXT=_C('GL_TEXTURE_FORMAT_SRGB_OVERRIDE_EXT',0x8FBF) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/texture_mirror_clamp_to_edge.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/texture_mirror_clamp_to_edge.py new file mode 100644 index 00000000..e7630528 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/texture_mirror_clamp_to_edge.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_EXT_texture_mirror_clamp_to_edge' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_EXT_texture_mirror_clamp_to_edge',error_checker=_errors._error_checker) +GL_MIRROR_CLAMP_TO_EDGE_EXT=_C('GL_MIRROR_CLAMP_TO_EDGE_EXT',0x8743) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/texture_norm16.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/texture_norm16.py new file mode 100644 index 00000000..b011cf96 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/texture_norm16.py @@ -0,0 +1,22 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_EXT_texture_norm16' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_EXT_texture_norm16',error_checker=_errors._error_checker) +GL_R16_EXT=_C('GL_R16_EXT',0x822A) +GL_R16_SNORM_EXT=_C('GL_R16_SNORM_EXT',0x8F98) +GL_RG16_EXT=_C('GL_RG16_EXT',0x822C) +GL_RG16_SNORM_EXT=_C('GL_RG16_SNORM_EXT',0x8F99) +GL_RGB16_EXT=_C('GL_RGB16_EXT',0x8054) +GL_RGB16_SNORM_EXT=_C('GL_RGB16_SNORM_EXT',0x8F9A) +GL_RGBA16_EXT=_C('GL_RGBA16_EXT',0x805B) +GL_RGBA16_SNORM_EXT=_C('GL_RGBA16_SNORM_EXT',0x8F9B) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/texture_query_lod.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/texture_query_lod.py new file mode 100644 index 00000000..8c0ce838 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/texture_query_lod.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_EXT_texture_query_lod' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_EXT_texture_query_lod',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/texture_rg.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/texture_rg.py new file mode 100644 index 00000000..07937066 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/texture_rg.py @@ -0,0 +1,18 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_EXT_texture_rg' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_EXT_texture_rg',error_checker=_errors._error_checker) +GL_R8_EXT=_C('GL_R8_EXT',0x8229) +GL_RED_EXT=_C('GL_RED_EXT',0x1903) +GL_RG8_EXT=_C('GL_RG8_EXT',0x822B) +GL_RG_EXT=_C('GL_RG_EXT',0x8227) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/texture_sRGB_R8.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/texture_sRGB_R8.py new file mode 100644 index 00000000..a53950e9 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/texture_sRGB_R8.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_EXT_texture_sRGB_R8' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_EXT_texture_sRGB_R8',error_checker=_errors._error_checker) +GL_SR8_EXT=_C('GL_SR8_EXT',0x8FBD) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/texture_sRGB_RG8.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/texture_sRGB_RG8.py new file mode 100644 index 00000000..b3e86e45 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/texture_sRGB_RG8.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_EXT_texture_sRGB_RG8' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_EXT_texture_sRGB_RG8',error_checker=_errors._error_checker) +GL_SRG8_EXT=_C('GL_SRG8_EXT',0x8FBE) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/texture_sRGB_decode.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/texture_sRGB_decode.py new file mode 100644 index 00000000..090cbd3e --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/texture_sRGB_decode.py @@ -0,0 +1,17 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_EXT_texture_sRGB_decode' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_EXT_texture_sRGB_decode',error_checker=_errors._error_checker) +GL_DECODE_EXT=_C('GL_DECODE_EXT',0x8A49) +GL_SKIP_DECODE_EXT=_C('GL_SKIP_DECODE_EXT',0x8A4A) +GL_TEXTURE_SRGB_DECODE_EXT=_C('GL_TEXTURE_SRGB_DECODE_EXT',0x8A48) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/texture_shadow_lod.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/texture_shadow_lod.py new file mode 100644 index 00000000..3d853376 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/texture_shadow_lod.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_EXT_texture_shadow_lod' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_EXT_texture_shadow_lod',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/texture_storage.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/texture_storage.py new file mode 100644 index 00000000..75d1de81 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/texture_storage.py @@ -0,0 +1,54 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_EXT_texture_storage' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_EXT_texture_storage',error_checker=_errors._error_checker) +GL_ALPHA16F_EXT=_C('GL_ALPHA16F_EXT',0x881C) +GL_ALPHA32F_EXT=_C('GL_ALPHA32F_EXT',0x8816) +GL_ALPHA8_EXT=_C('GL_ALPHA8_EXT',0x803C) +GL_BGRA8_EXT=_C('GL_BGRA8_EXT',0x93A1) +GL_LUMINANCE16F_EXT=_C('GL_LUMINANCE16F_EXT',0x881E) +GL_LUMINANCE32F_EXT=_C('GL_LUMINANCE32F_EXT',0x8818) +GL_LUMINANCE8_ALPHA8_EXT=_C('GL_LUMINANCE8_ALPHA8_EXT',0x8045) +GL_LUMINANCE8_EXT=_C('GL_LUMINANCE8_EXT',0x8040) +GL_LUMINANCE_ALPHA16F_EXT=_C('GL_LUMINANCE_ALPHA16F_EXT',0x881F) +GL_LUMINANCE_ALPHA32F_EXT=_C('GL_LUMINANCE_ALPHA32F_EXT',0x8819) +GL_R16F_EXT=_C('GL_R16F_EXT',0x822D) +GL_R32F_EXT=_C('GL_R32F_EXT',0x822E) +GL_R8_EXT=_C('GL_R8_EXT',0x8229) +GL_RG16F_EXT=_C('GL_RG16F_EXT',0x822F) +GL_RG32F_EXT=_C('GL_RG32F_EXT',0x8230) +GL_RG8_EXT=_C('GL_RG8_EXT',0x822B) +GL_RGB10_A2_EXT=_C('GL_RGB10_A2_EXT',0x8059) +GL_RGB10_EXT=_C('GL_RGB10_EXT',0x8052) +GL_RGB16F_EXT=_C('GL_RGB16F_EXT',0x881B) +GL_RGB32F_EXT=_C('GL_RGB32F_EXT',0x8815) +GL_RGBA16F_EXT=_C('GL_RGBA16F_EXT',0x881A) +GL_RGBA32F_EXT=_C('GL_RGBA32F_EXT',0x8814) +GL_TEXTURE_IMMUTABLE_FORMAT_EXT=_C('GL_TEXTURE_IMMUTABLE_FORMAT_EXT',0x912F) +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizei,_cs.GLenum,_cs.GLsizei) +def glTexStorage1DEXT(target,levels,internalformat,width):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizei,_cs.GLenum,_cs.GLsizei,_cs.GLsizei) +def glTexStorage2DEXT(target,levels,internalformat,width,height):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizei,_cs.GLenum,_cs.GLsizei,_cs.GLsizei,_cs.GLsizei) +def glTexStorage3DEXT(target,levels,internalformat,width,height,depth):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLsizei,_cs.GLenum,_cs.GLsizei) +def glTextureStorage1DEXT(texture,target,levels,internalformat,width):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLsizei,_cs.GLenum,_cs.GLsizei,_cs.GLsizei) +def glTextureStorage2DEXT(texture,target,levels,internalformat,width,height):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLsizei,_cs.GLenum,_cs.GLsizei,_cs.GLsizei,_cs.GLsizei) +def glTextureStorage3DEXT(texture,target,levels,internalformat,width,height,depth):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/texture_type_2_10_10_10_REV.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/texture_type_2_10_10_10_REV.py new file mode 100644 index 00000000..8a54baff --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/texture_type_2_10_10_10_REV.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_EXT_texture_type_2_10_10_10_REV' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_EXT_texture_type_2_10_10_10_REV',error_checker=_errors._error_checker) +GL_UNSIGNED_INT_2_10_10_10_REV_EXT=_C('GL_UNSIGNED_INT_2_10_10_10_REV_EXT',0x8368) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/texture_view.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/texture_view.py new file mode 100644 index 00000000..7bde60e1 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/texture_view.py @@ -0,0 +1,21 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_EXT_texture_view' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_EXT_texture_view',error_checker=_errors._error_checker) +GL_TEXTURE_IMMUTABLE_LEVELS=_C('GL_TEXTURE_IMMUTABLE_LEVELS',0x82DF) +GL_TEXTURE_VIEW_MIN_LAYER_EXT=_C('GL_TEXTURE_VIEW_MIN_LAYER_EXT',0x82DD) +GL_TEXTURE_VIEW_MIN_LEVEL_EXT=_C('GL_TEXTURE_VIEW_MIN_LEVEL_EXT',0x82DB) +GL_TEXTURE_VIEW_NUM_LAYERS_EXT=_C('GL_TEXTURE_VIEW_NUM_LAYERS_EXT',0x82DE) +GL_TEXTURE_VIEW_NUM_LEVELS_EXT=_C('GL_TEXTURE_VIEW_NUM_LEVELS_EXT',0x82DC) +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLuint,_cs.GLenum,_cs.GLuint,_cs.GLuint,_cs.GLuint,_cs.GLuint) +def glTextureViewEXT(texture,target,origtexture,internalformat,minlevel,numlevels,minlayer,numlayers):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/unpack_subimage.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/unpack_subimage.py new file mode 100644 index 00000000..3e7b129a --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/unpack_subimage.py @@ -0,0 +1,17 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_EXT_unpack_subimage' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_EXT_unpack_subimage',error_checker=_errors._error_checker) +GL_UNPACK_ROW_LENGTH_EXT=_C('GL_UNPACK_ROW_LENGTH_EXT',0x0CF2) +GL_UNPACK_SKIP_PIXELS_EXT=_C('GL_UNPACK_SKIP_PIXELS_EXT',0x0CF4) +GL_UNPACK_SKIP_ROWS_EXT=_C('GL_UNPACK_SKIP_ROWS_EXT',0x0CF3) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/win32_keyed_mutex.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/win32_keyed_mutex.py new file mode 100644 index 00000000..cd8170cc --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/win32_keyed_mutex.py @@ -0,0 +1,20 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_EXT_win32_keyed_mutex' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_EXT_win32_keyed_mutex',error_checker=_errors._error_checker) + +@_f +@_p.types(_cs.GLboolean,_cs.GLuint,_cs.GLuint64,_cs.GLuint) +def glAcquireKeyedMutexWin32EXT(memory,key,timeout):pass +@_f +@_p.types(_cs.GLboolean,_cs.GLuint,_cs.GLuint64) +def glReleaseKeyedMutexWin32EXT(memory,key):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/window_rectangles.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/window_rectangles.py new file mode 100644 index 00000000..e562617d --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/EXT/window_rectangles.py @@ -0,0 +1,22 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_EXT_window_rectangles' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_EXT_window_rectangles',error_checker=_errors._error_checker) +GL_EXCLUSIVE_EXT=_C('GL_EXCLUSIVE_EXT',0x8F11) +GL_INCLUSIVE_EXT=_C('GL_INCLUSIVE_EXT',0x8F10) +GL_MAX_WINDOW_RECTANGLES_EXT=_C('GL_MAX_WINDOW_RECTANGLES_EXT',0x8F14) +GL_NUM_WINDOW_RECTANGLES_EXT=_C('GL_NUM_WINDOW_RECTANGLES_EXT',0x8F15) +GL_WINDOW_RECTANGLE_EXT=_C('GL_WINDOW_RECTANGLE_EXT',0x8F12) +GL_WINDOW_RECTANGLE_MODE_EXT=_C('GL_WINDOW_RECTANGLE_MODE_EXT',0x8F13) +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizei,arrays.GLintArray) +def glWindowRectanglesEXT(mode,count,box):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/FJ/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/FJ/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/FJ/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/FJ/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/FJ/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..c3990618 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/FJ/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/FJ/__pycache__/shader_binary_GCCSO.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/FJ/__pycache__/shader_binary_GCCSO.cpython-312.pyc new file mode 100644 index 00000000..11d5af31 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/FJ/__pycache__/shader_binary_GCCSO.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/FJ/shader_binary_GCCSO.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/FJ/shader_binary_GCCSO.py new file mode 100644 index 00000000..8bc7d7a0 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/FJ/shader_binary_GCCSO.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_FJ_shader_binary_GCCSO' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_FJ_shader_binary_GCCSO',error_checker=_errors._error_checker) +GL_GCCSO_SHADER_BINARY_FJ=_C('GL_GCCSO_SHADER_BINARY_FJ',0x9260) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/IMG/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/IMG/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/IMG/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/IMG/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/IMG/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..261e2d6b Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/IMG/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/IMG/__pycache__/bindless_texture.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/IMG/__pycache__/bindless_texture.cpython-312.pyc new file mode 100644 index 00000000..f2df4f69 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/IMG/__pycache__/bindless_texture.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/IMG/__pycache__/framebuffer_downsample.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/IMG/__pycache__/framebuffer_downsample.cpython-312.pyc new file mode 100644 index 00000000..94a75b7a Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/IMG/__pycache__/framebuffer_downsample.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/IMG/__pycache__/multisampled_render_to_texture.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/IMG/__pycache__/multisampled_render_to_texture.cpython-312.pyc new file mode 100644 index 00000000..11a62ba2 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/IMG/__pycache__/multisampled_render_to_texture.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/IMG/__pycache__/program_binary.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/IMG/__pycache__/program_binary.cpython-312.pyc new file mode 100644 index 00000000..77aabcec Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/IMG/__pycache__/program_binary.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/IMG/__pycache__/read_format.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/IMG/__pycache__/read_format.cpython-312.pyc new file mode 100644 index 00000000..a9a13718 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/IMG/__pycache__/read_format.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/IMG/__pycache__/shader_binary.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/IMG/__pycache__/shader_binary.cpython-312.pyc new file mode 100644 index 00000000..8b5bbfc5 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/IMG/__pycache__/shader_binary.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/IMG/__pycache__/texture_compression_pvrtc.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/IMG/__pycache__/texture_compression_pvrtc.cpython-312.pyc new file mode 100644 index 00000000..a5ac5fff Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/IMG/__pycache__/texture_compression_pvrtc.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/IMG/__pycache__/texture_compression_pvrtc2.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/IMG/__pycache__/texture_compression_pvrtc2.cpython-312.pyc new file mode 100644 index 00000000..9c6963ec Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/IMG/__pycache__/texture_compression_pvrtc2.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/IMG/__pycache__/texture_filter_cubic.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/IMG/__pycache__/texture_filter_cubic.cpython-312.pyc new file mode 100644 index 00000000..b380b251 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/IMG/__pycache__/texture_filter_cubic.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/IMG/bindless_texture.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/IMG/bindless_texture.py new file mode 100644 index 00000000..a5f2291d --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/IMG/bindless_texture.py @@ -0,0 +1,32 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_IMG_bindless_texture' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_IMG_bindless_texture',error_checker=_errors._error_checker) + +@_f +@_p.types(_cs.GLuint64,_cs.GLuint) +def glGetTextureHandleIMG(texture):pass +@_f +@_p.types(_cs.GLuint64,_cs.GLuint,_cs.GLuint) +def glGetTextureSamplerHandleIMG(texture,sampler):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLuint64) +def glProgramUniformHandleui64IMG(program,location,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLuint64Array) +def glProgramUniformHandleui64vIMG(program,location,count,values):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLuint64) +def glUniformHandleui64IMG(location,value):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLsizei,arrays.GLuint64Array) +def glUniformHandleui64vIMG(location,count,value):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/IMG/framebuffer_downsample.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/IMG/framebuffer_downsample.py new file mode 100644 index 00000000..7a44b58d --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/IMG/framebuffer_downsample.py @@ -0,0 +1,23 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_IMG_framebuffer_downsample' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_IMG_framebuffer_downsample',error_checker=_errors._error_checker) +GL_DOWNSAMPLE_SCALES_IMG=_C('GL_DOWNSAMPLE_SCALES_IMG',0x913E) +GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_SCALE_IMG=_C('GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_SCALE_IMG',0x913F) +GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_AND_DOWNSAMPLE_IMG=_C('GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_AND_DOWNSAMPLE_IMG',0x913C) +GL_NUM_DOWNSAMPLE_SCALES_IMG=_C('GL_NUM_DOWNSAMPLE_SCALES_IMG',0x913D) +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLenum,_cs.GLuint,_cs.GLint,_cs.GLint,_cs.GLint) +def glFramebufferTexture2DDownsampleIMG(target,attachment,textarget,texture,level,xscale,yscale):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLuint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint) +def glFramebufferTextureLayerDownsampleIMG(target,attachment,texture,level,layer,xscale,yscale):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/IMG/multisampled_render_to_texture.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/IMG/multisampled_render_to_texture.py new file mode 100644 index 00000000..dea6ebf6 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/IMG/multisampled_render_to_texture.py @@ -0,0 +1,23 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_IMG_multisampled_render_to_texture' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_IMG_multisampled_render_to_texture',error_checker=_errors._error_checker) +GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_IMG=_C('GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_IMG',0x9134) +GL_MAX_SAMPLES_IMG=_C('GL_MAX_SAMPLES_IMG',0x9135) +GL_RENDERBUFFER_SAMPLES_IMG=_C('GL_RENDERBUFFER_SAMPLES_IMG',0x9133) +GL_TEXTURE_SAMPLES_IMG=_C('GL_TEXTURE_SAMPLES_IMG',0x9136) +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLenum,_cs.GLuint,_cs.GLint,_cs.GLsizei) +def glFramebufferTexture2DMultisampleIMG(target,attachment,textarget,texture,level,samples):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizei,_cs.GLenum,_cs.GLsizei,_cs.GLsizei) +def glRenderbufferStorageMultisampleIMG(target,samples,internalformat,width,height):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/IMG/program_binary.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/IMG/program_binary.py new file mode 100644 index 00000000..592bc7b6 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/IMG/program_binary.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_IMG_program_binary' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_IMG_program_binary',error_checker=_errors._error_checker) +GL_SGX_PROGRAM_BINARY_IMG=_C('GL_SGX_PROGRAM_BINARY_IMG',0x9130) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/IMG/read_format.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/IMG/read_format.py new file mode 100644 index 00000000..df060905 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/IMG/read_format.py @@ -0,0 +1,16 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_IMG_read_format' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_IMG_read_format',error_checker=_errors._error_checker) +GL_BGRA_IMG=_C('GL_BGRA_IMG',0x80E1) +GL_UNSIGNED_SHORT_4_4_4_4_REV_IMG=_C('GL_UNSIGNED_SHORT_4_4_4_4_REV_IMG',0x8365) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/IMG/shader_binary.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/IMG/shader_binary.py new file mode 100644 index 00000000..e6de8a7e --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/IMG/shader_binary.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_IMG_shader_binary' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_IMG_shader_binary',error_checker=_errors._error_checker) +GL_SGX_BINARY_IMG=_C('GL_SGX_BINARY_IMG',0x8C0A) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/IMG/texture_compression_pvrtc.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/IMG/texture_compression_pvrtc.py new file mode 100644 index 00000000..c23de6ba --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/IMG/texture_compression_pvrtc.py @@ -0,0 +1,18 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_IMG_texture_compression_pvrtc' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_IMG_texture_compression_pvrtc',error_checker=_errors._error_checker) +GL_COMPRESSED_RGBA_PVRTC_2BPPV1_IMG=_C('GL_COMPRESSED_RGBA_PVRTC_2BPPV1_IMG',0x8C03) +GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG=_C('GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG',0x8C02) +GL_COMPRESSED_RGB_PVRTC_2BPPV1_IMG=_C('GL_COMPRESSED_RGB_PVRTC_2BPPV1_IMG',0x8C01) +GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG=_C('GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG',0x8C00) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/IMG/texture_compression_pvrtc2.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/IMG/texture_compression_pvrtc2.py new file mode 100644 index 00000000..822cc7b7 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/IMG/texture_compression_pvrtc2.py @@ -0,0 +1,16 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_IMG_texture_compression_pvrtc2' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_IMG_texture_compression_pvrtc2',error_checker=_errors._error_checker) +GL_COMPRESSED_RGBA_PVRTC_2BPPV2_IMG=_C('GL_COMPRESSED_RGBA_PVRTC_2BPPV2_IMG',0x9137) +GL_COMPRESSED_RGBA_PVRTC_4BPPV2_IMG=_C('GL_COMPRESSED_RGBA_PVRTC_4BPPV2_IMG',0x9138) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/IMG/texture_filter_cubic.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/IMG/texture_filter_cubic.py new file mode 100644 index 00000000..9e19044d --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/IMG/texture_filter_cubic.py @@ -0,0 +1,17 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_IMG_texture_filter_cubic' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_IMG_texture_filter_cubic',error_checker=_errors._error_checker) +GL_CUBIC_IMG=_C('GL_CUBIC_IMG',0x9139) +GL_CUBIC_MIPMAP_LINEAR_IMG=_C('GL_CUBIC_MIPMAP_LINEAR_IMG',0x913B) +GL_CUBIC_MIPMAP_NEAREST_IMG=_C('GL_CUBIC_MIPMAP_NEAREST_IMG',0x913A) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/INTEL/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/INTEL/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/INTEL/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/INTEL/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/INTEL/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..e4f6acab Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/INTEL/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/INTEL/__pycache__/blackhole_render.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/INTEL/__pycache__/blackhole_render.cpython-312.pyc new file mode 100644 index 00000000..7a56d726 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/INTEL/__pycache__/blackhole_render.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/INTEL/__pycache__/conservative_rasterization.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/INTEL/__pycache__/conservative_rasterization.cpython-312.pyc new file mode 100644 index 00000000..5f2d4b3b Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/INTEL/__pycache__/conservative_rasterization.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/INTEL/__pycache__/framebuffer_CMAA.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/INTEL/__pycache__/framebuffer_CMAA.cpython-312.pyc new file mode 100644 index 00000000..31a77481 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/INTEL/__pycache__/framebuffer_CMAA.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/INTEL/__pycache__/performance_query.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/INTEL/__pycache__/performance_query.cpython-312.pyc new file mode 100644 index 00000000..8746212d Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/INTEL/__pycache__/performance_query.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/INTEL/blackhole_render.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/INTEL/blackhole_render.py new file mode 100644 index 00000000..26282a1e --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/INTEL/blackhole_render.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_INTEL_blackhole_render' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_INTEL_blackhole_render',error_checker=_errors._error_checker) +GL_BLACKHOLE_RENDER_INTEL=_C('GL_BLACKHOLE_RENDER_INTEL',0x83FC) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/INTEL/conservative_rasterization.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/INTEL/conservative_rasterization.py new file mode 100644 index 00000000..62d1554e --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/INTEL/conservative_rasterization.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_INTEL_conservative_rasterization' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_INTEL_conservative_rasterization',error_checker=_errors._error_checker) +GL_CONSERVATIVE_RASTERIZATION_INTEL=_C('GL_CONSERVATIVE_RASTERIZATION_INTEL',0x83FE) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/INTEL/framebuffer_CMAA.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/INTEL/framebuffer_CMAA.py new file mode 100644 index 00000000..4125c363 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/INTEL/framebuffer_CMAA.py @@ -0,0 +1,17 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_INTEL_framebuffer_CMAA' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_INTEL_framebuffer_CMAA',error_checker=_errors._error_checker) + +@_f +@_p.types(None,) +def glApplyFramebufferAttachmentCMAAINTEL():pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/INTEL/performance_query.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/INTEL/performance_query.py new file mode 100644 index 00000000..41f65304 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/INTEL/performance_query.py @@ -0,0 +1,63 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_INTEL_performance_query' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_INTEL_performance_query',error_checker=_errors._error_checker) +GL_PERFQUERY_COUNTER_DATA_BOOL32_INTEL=_C('GL_PERFQUERY_COUNTER_DATA_BOOL32_INTEL',0x94FC) +GL_PERFQUERY_COUNTER_DATA_DOUBLE_INTEL=_C('GL_PERFQUERY_COUNTER_DATA_DOUBLE_INTEL',0x94FB) +GL_PERFQUERY_COUNTER_DATA_FLOAT_INTEL=_C('GL_PERFQUERY_COUNTER_DATA_FLOAT_INTEL',0x94FA) +GL_PERFQUERY_COUNTER_DATA_UINT32_INTEL=_C('GL_PERFQUERY_COUNTER_DATA_UINT32_INTEL',0x94F8) +GL_PERFQUERY_COUNTER_DATA_UINT64_INTEL=_C('GL_PERFQUERY_COUNTER_DATA_UINT64_INTEL',0x94F9) +GL_PERFQUERY_COUNTER_DESC_LENGTH_MAX_INTEL=_C('GL_PERFQUERY_COUNTER_DESC_LENGTH_MAX_INTEL',0x94FF) +GL_PERFQUERY_COUNTER_DURATION_NORM_INTEL=_C('GL_PERFQUERY_COUNTER_DURATION_NORM_INTEL',0x94F1) +GL_PERFQUERY_COUNTER_DURATION_RAW_INTEL=_C('GL_PERFQUERY_COUNTER_DURATION_RAW_INTEL',0x94F2) +GL_PERFQUERY_COUNTER_EVENT_INTEL=_C('GL_PERFQUERY_COUNTER_EVENT_INTEL',0x94F0) +GL_PERFQUERY_COUNTER_NAME_LENGTH_MAX_INTEL=_C('GL_PERFQUERY_COUNTER_NAME_LENGTH_MAX_INTEL',0x94FE) +GL_PERFQUERY_COUNTER_RAW_INTEL=_C('GL_PERFQUERY_COUNTER_RAW_INTEL',0x94F4) +GL_PERFQUERY_COUNTER_THROUGHPUT_INTEL=_C('GL_PERFQUERY_COUNTER_THROUGHPUT_INTEL',0x94F3) +GL_PERFQUERY_COUNTER_TIMESTAMP_INTEL=_C('GL_PERFQUERY_COUNTER_TIMESTAMP_INTEL',0x94F5) +GL_PERFQUERY_DONOT_FLUSH_INTEL=_C('GL_PERFQUERY_DONOT_FLUSH_INTEL',0x83F9) +GL_PERFQUERY_FLUSH_INTEL=_C('GL_PERFQUERY_FLUSH_INTEL',0x83FA) +GL_PERFQUERY_GLOBAL_CONTEXT_INTEL=_C('GL_PERFQUERY_GLOBAL_CONTEXT_INTEL',0x00000001) +GL_PERFQUERY_GPA_EXTENDED_COUNTERS_INTEL=_C('GL_PERFQUERY_GPA_EXTENDED_COUNTERS_INTEL',0x9500) +GL_PERFQUERY_QUERY_NAME_LENGTH_MAX_INTEL=_C('GL_PERFQUERY_QUERY_NAME_LENGTH_MAX_INTEL',0x94FD) +GL_PERFQUERY_SINGLE_CONTEXT_INTEL=_C('GL_PERFQUERY_SINGLE_CONTEXT_INTEL',0x00000000) +GL_PERFQUERY_WAIT_INTEL=_C('GL_PERFQUERY_WAIT_INTEL',0x83FB) +@_f +@_p.types(None,_cs.GLuint) +def glBeginPerfQueryINTEL(queryHandle):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLuintArray) +def glCreatePerfQueryINTEL(queryId,queryHandle):pass +@_f +@_p.types(None,_cs.GLuint) +def glDeletePerfQueryINTEL(queryHandle):pass +@_f +@_p.types(None,_cs.GLuint) +def glEndPerfQueryINTEL(queryHandle):pass +@_f +@_p.types(None,arrays.GLuintArray) +def glGetFirstPerfQueryIdINTEL(queryId):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLuintArray) +def glGetNextPerfQueryIdINTEL(queryId,nextQueryId):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLuint,arrays.GLcharArray,_cs.GLuint,arrays.GLcharArray,arrays.GLuintArray,arrays.GLuintArray,arrays.GLuintArray,arrays.GLuintArray,arrays.GLuint64Array) +def glGetPerfCounterInfoINTEL(queryId,counterId,counterNameLength,counterName,counterDescLength,counterDesc,counterOffset,counterDataSize,counterTypeEnum,counterDataTypeEnum,rawCounterMaxValue):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLsizei,ctypes.c_void_p,arrays.GLuintArray) +def glGetPerfQueryDataINTEL(queryHandle,flags,dataSize,data,bytesWritten):pass +@_f +@_p.types(None,arrays.GLcharArray,arrays.GLuintArray) +def glGetPerfQueryIdByNameINTEL(queryName,queryId):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,arrays.GLcharArray,arrays.GLuintArray,arrays.GLuintArray,arrays.GLuintArray,arrays.GLuintArray) +def glGetPerfQueryInfoINTEL(queryId,queryNameLength,queryName,dataSize,noCounters,noInstances,capsMask):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/KHR/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/KHR/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/KHR/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/KHR/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/KHR/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..44bf3b1a Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/KHR/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/KHR/__pycache__/blend_equation_advanced.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/KHR/__pycache__/blend_equation_advanced.cpython-312.pyc new file mode 100644 index 00000000..0d77ed7f Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/KHR/__pycache__/blend_equation_advanced.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/KHR/__pycache__/blend_equation_advanced_coherent.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/KHR/__pycache__/blend_equation_advanced_coherent.cpython-312.pyc new file mode 100644 index 00000000..acda2a4b Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/KHR/__pycache__/blend_equation_advanced_coherent.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/KHR/__pycache__/context_flush_control.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/KHR/__pycache__/context_flush_control.cpython-312.pyc new file mode 100644 index 00000000..148037e7 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/KHR/__pycache__/context_flush_control.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/KHR/__pycache__/debug.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/KHR/__pycache__/debug.cpython-312.pyc new file mode 100644 index 00000000..d231fd75 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/KHR/__pycache__/debug.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/KHR/__pycache__/no_error.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/KHR/__pycache__/no_error.cpython-312.pyc new file mode 100644 index 00000000..693d6855 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/KHR/__pycache__/no_error.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/KHR/__pycache__/parallel_shader_compile.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/KHR/__pycache__/parallel_shader_compile.cpython-312.pyc new file mode 100644 index 00000000..417ae536 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/KHR/__pycache__/parallel_shader_compile.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/KHR/__pycache__/robust_buffer_access_behavior.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/KHR/__pycache__/robust_buffer_access_behavior.cpython-312.pyc new file mode 100644 index 00000000..439ca6fa Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/KHR/__pycache__/robust_buffer_access_behavior.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/KHR/__pycache__/robustness.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/KHR/__pycache__/robustness.cpython-312.pyc new file mode 100644 index 00000000..d66134f4 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/KHR/__pycache__/robustness.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/KHR/__pycache__/shader_subgroup.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/KHR/__pycache__/shader_subgroup.cpython-312.pyc new file mode 100644 index 00000000..4a03839f Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/KHR/__pycache__/shader_subgroup.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/KHR/__pycache__/texture_compression_astc_hdr.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/KHR/__pycache__/texture_compression_astc_hdr.cpython-312.pyc new file mode 100644 index 00000000..9500e317 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/KHR/__pycache__/texture_compression_astc_hdr.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/KHR/__pycache__/texture_compression_astc_ldr.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/KHR/__pycache__/texture_compression_astc_ldr.cpython-312.pyc new file mode 100644 index 00000000..0c756fc9 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/KHR/__pycache__/texture_compression_astc_ldr.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/KHR/__pycache__/texture_compression_astc_sliced_3d.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/KHR/__pycache__/texture_compression_astc_sliced_3d.cpython-312.pyc new file mode 100644 index 00000000..d36c3dd6 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/KHR/__pycache__/texture_compression_astc_sliced_3d.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/KHR/blend_equation_advanced.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/KHR/blend_equation_advanced.py new file mode 100644 index 00000000..dec453a9 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/KHR/blend_equation_advanced.py @@ -0,0 +1,31 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_KHR_blend_equation_advanced' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_KHR_blend_equation_advanced',error_checker=_errors._error_checker) +GL_COLORBURN_KHR=_C('GL_COLORBURN_KHR',0x929A) +GL_COLORDODGE_KHR=_C('GL_COLORDODGE_KHR',0x9299) +GL_DARKEN_KHR=_C('GL_DARKEN_KHR',0x9297) +GL_DIFFERENCE_KHR=_C('GL_DIFFERENCE_KHR',0x929E) +GL_EXCLUSION_KHR=_C('GL_EXCLUSION_KHR',0x92A0) +GL_HARDLIGHT_KHR=_C('GL_HARDLIGHT_KHR',0x929B) +GL_HSL_COLOR_KHR=_C('GL_HSL_COLOR_KHR',0x92AF) +GL_HSL_HUE_KHR=_C('GL_HSL_HUE_KHR',0x92AD) +GL_HSL_LUMINOSITY_KHR=_C('GL_HSL_LUMINOSITY_KHR',0x92B0) +GL_HSL_SATURATION_KHR=_C('GL_HSL_SATURATION_KHR',0x92AE) +GL_LIGHTEN_KHR=_C('GL_LIGHTEN_KHR',0x9298) +GL_MULTIPLY_KHR=_C('GL_MULTIPLY_KHR',0x9294) +GL_OVERLAY_KHR=_C('GL_OVERLAY_KHR',0x9296) +GL_SCREEN_KHR=_C('GL_SCREEN_KHR',0x9295) +GL_SOFTLIGHT_KHR=_C('GL_SOFTLIGHT_KHR',0x929C) +@_f +@_p.types(None,) +def glBlendBarrierKHR():pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/KHR/blend_equation_advanced_coherent.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/KHR/blend_equation_advanced_coherent.py new file mode 100644 index 00000000..2cc325cc --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/KHR/blend_equation_advanced_coherent.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_KHR_blend_equation_advanced_coherent' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_KHR_blend_equation_advanced_coherent',error_checker=_errors._error_checker) +GL_BLEND_ADVANCED_COHERENT_KHR=_C('GL_BLEND_ADVANCED_COHERENT_KHR',0x9285) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/KHR/context_flush_control.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/KHR/context_flush_control.py new file mode 100644 index 00000000..84329bd5 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/KHR/context_flush_control.py @@ -0,0 +1,20 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_KHR_context_flush_control' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_KHR_context_flush_control',error_checker=_errors._error_checker) +GL_CONTEXT_RELEASE_BEHAVIOR=_C('GL_CONTEXT_RELEASE_BEHAVIOR',0x82FB) +GL_CONTEXT_RELEASE_BEHAVIOR_FLUSH=_C('GL_CONTEXT_RELEASE_BEHAVIOR_FLUSH',0x82FC) +GL_CONTEXT_RELEASE_BEHAVIOR_FLUSH_KHR=_C('GL_CONTEXT_RELEASE_BEHAVIOR_FLUSH_KHR',0x82FC) +GL_CONTEXT_RELEASE_BEHAVIOR_KHR=_C('GL_CONTEXT_RELEASE_BEHAVIOR_KHR',0x82FB) +GL_NONE=_C('GL_NONE',0) +GL_NONE=_C('GL_NONE',0) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/KHR/debug.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/KHR/debug.py new file mode 100644 index 00000000..de35c389 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/KHR/debug.py @@ -0,0 +1,160 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_KHR_debug' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_KHR_debug',error_checker=_errors._error_checker) +GL_BUFFER=_C('GL_BUFFER',0x82E0) +GL_BUFFER_KHR=_C('GL_BUFFER_KHR',0x82E0) +GL_CONTEXT_FLAG_DEBUG_BIT=_C('GL_CONTEXT_FLAG_DEBUG_BIT',0x00000002) +GL_CONTEXT_FLAG_DEBUG_BIT_KHR=_C('GL_CONTEXT_FLAG_DEBUG_BIT_KHR',0x00000002) +GL_DEBUG_CALLBACK_FUNCTION=_C('GL_DEBUG_CALLBACK_FUNCTION',0x8244) +GL_DEBUG_CALLBACK_FUNCTION_KHR=_C('GL_DEBUG_CALLBACK_FUNCTION_KHR',0x8244) +GL_DEBUG_CALLBACK_USER_PARAM=_C('GL_DEBUG_CALLBACK_USER_PARAM',0x8245) +GL_DEBUG_CALLBACK_USER_PARAM_KHR=_C('GL_DEBUG_CALLBACK_USER_PARAM_KHR',0x8245) +GL_DEBUG_GROUP_STACK_DEPTH=_C('GL_DEBUG_GROUP_STACK_DEPTH',0x826D) +GL_DEBUG_GROUP_STACK_DEPTH_KHR=_C('GL_DEBUG_GROUP_STACK_DEPTH_KHR',0x826D) +GL_DEBUG_LOGGED_MESSAGES=_C('GL_DEBUG_LOGGED_MESSAGES',0x9145) +GL_DEBUG_LOGGED_MESSAGES_KHR=_C('GL_DEBUG_LOGGED_MESSAGES_KHR',0x9145) +GL_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH=_C('GL_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH',0x8243) +GL_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH_KHR=_C('GL_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH_KHR',0x8243) +GL_DEBUG_OUTPUT=_C('GL_DEBUG_OUTPUT',0x92E0) +GL_DEBUG_OUTPUT_KHR=_C('GL_DEBUG_OUTPUT_KHR',0x92E0) +GL_DEBUG_OUTPUT_SYNCHRONOUS=_C('GL_DEBUG_OUTPUT_SYNCHRONOUS',0x8242) +GL_DEBUG_OUTPUT_SYNCHRONOUS_KHR=_C('GL_DEBUG_OUTPUT_SYNCHRONOUS_KHR',0x8242) +GL_DEBUG_SEVERITY_HIGH=_C('GL_DEBUG_SEVERITY_HIGH',0x9146) +GL_DEBUG_SEVERITY_HIGH_KHR=_C('GL_DEBUG_SEVERITY_HIGH_KHR',0x9146) +GL_DEBUG_SEVERITY_LOW=_C('GL_DEBUG_SEVERITY_LOW',0x9148) +GL_DEBUG_SEVERITY_LOW_KHR=_C('GL_DEBUG_SEVERITY_LOW_KHR',0x9148) +GL_DEBUG_SEVERITY_MEDIUM=_C('GL_DEBUG_SEVERITY_MEDIUM',0x9147) +GL_DEBUG_SEVERITY_MEDIUM_KHR=_C('GL_DEBUG_SEVERITY_MEDIUM_KHR',0x9147) +GL_DEBUG_SEVERITY_NOTIFICATION=_C('GL_DEBUG_SEVERITY_NOTIFICATION',0x826B) +GL_DEBUG_SEVERITY_NOTIFICATION_KHR=_C('GL_DEBUG_SEVERITY_NOTIFICATION_KHR',0x826B) +GL_DEBUG_SOURCE_API=_C('GL_DEBUG_SOURCE_API',0x8246) +GL_DEBUG_SOURCE_API_KHR=_C('GL_DEBUG_SOURCE_API_KHR',0x8246) +GL_DEBUG_SOURCE_APPLICATION=_C('GL_DEBUG_SOURCE_APPLICATION',0x824A) +GL_DEBUG_SOURCE_APPLICATION_KHR=_C('GL_DEBUG_SOURCE_APPLICATION_KHR',0x824A) +GL_DEBUG_SOURCE_OTHER=_C('GL_DEBUG_SOURCE_OTHER',0x824B) +GL_DEBUG_SOURCE_OTHER_KHR=_C('GL_DEBUG_SOURCE_OTHER_KHR',0x824B) +GL_DEBUG_SOURCE_SHADER_COMPILER=_C('GL_DEBUG_SOURCE_SHADER_COMPILER',0x8248) +GL_DEBUG_SOURCE_SHADER_COMPILER_KHR=_C('GL_DEBUG_SOURCE_SHADER_COMPILER_KHR',0x8248) +GL_DEBUG_SOURCE_THIRD_PARTY=_C('GL_DEBUG_SOURCE_THIRD_PARTY',0x8249) +GL_DEBUG_SOURCE_THIRD_PARTY_KHR=_C('GL_DEBUG_SOURCE_THIRD_PARTY_KHR',0x8249) +GL_DEBUG_SOURCE_WINDOW_SYSTEM=_C('GL_DEBUG_SOURCE_WINDOW_SYSTEM',0x8247) +GL_DEBUG_SOURCE_WINDOW_SYSTEM_KHR=_C('GL_DEBUG_SOURCE_WINDOW_SYSTEM_KHR',0x8247) +GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR=_C('GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR',0x824D) +GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR_KHR=_C('GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR_KHR',0x824D) +GL_DEBUG_TYPE_ERROR=_C('GL_DEBUG_TYPE_ERROR',0x824C) +GL_DEBUG_TYPE_ERROR_KHR=_C('GL_DEBUG_TYPE_ERROR_KHR',0x824C) +GL_DEBUG_TYPE_MARKER=_C('GL_DEBUG_TYPE_MARKER',0x8268) +GL_DEBUG_TYPE_MARKER_KHR=_C('GL_DEBUG_TYPE_MARKER_KHR',0x8268) +GL_DEBUG_TYPE_OTHER=_C('GL_DEBUG_TYPE_OTHER',0x8251) +GL_DEBUG_TYPE_OTHER_KHR=_C('GL_DEBUG_TYPE_OTHER_KHR',0x8251) +GL_DEBUG_TYPE_PERFORMANCE=_C('GL_DEBUG_TYPE_PERFORMANCE',0x8250) +GL_DEBUG_TYPE_PERFORMANCE_KHR=_C('GL_DEBUG_TYPE_PERFORMANCE_KHR',0x8250) +GL_DEBUG_TYPE_POP_GROUP=_C('GL_DEBUG_TYPE_POP_GROUP',0x826A) +GL_DEBUG_TYPE_POP_GROUP_KHR=_C('GL_DEBUG_TYPE_POP_GROUP_KHR',0x826A) +GL_DEBUG_TYPE_PORTABILITY=_C('GL_DEBUG_TYPE_PORTABILITY',0x824F) +GL_DEBUG_TYPE_PORTABILITY_KHR=_C('GL_DEBUG_TYPE_PORTABILITY_KHR',0x824F) +GL_DEBUG_TYPE_PUSH_GROUP=_C('GL_DEBUG_TYPE_PUSH_GROUP',0x8269) +GL_DEBUG_TYPE_PUSH_GROUP_KHR=_C('GL_DEBUG_TYPE_PUSH_GROUP_KHR',0x8269) +GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR=_C('GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR',0x824E) +GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR_KHR=_C('GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR_KHR',0x824E) +GL_DISPLAY_LIST=_C('GL_DISPLAY_LIST',0x82E7) +GL_MAX_DEBUG_GROUP_STACK_DEPTH=_C('GL_MAX_DEBUG_GROUP_STACK_DEPTH',0x826C) +GL_MAX_DEBUG_GROUP_STACK_DEPTH_KHR=_C('GL_MAX_DEBUG_GROUP_STACK_DEPTH_KHR',0x826C) +GL_MAX_DEBUG_LOGGED_MESSAGES=_C('GL_MAX_DEBUG_LOGGED_MESSAGES',0x9144) +GL_MAX_DEBUG_LOGGED_MESSAGES_KHR=_C('GL_MAX_DEBUG_LOGGED_MESSAGES_KHR',0x9144) +GL_MAX_DEBUG_MESSAGE_LENGTH=_C('GL_MAX_DEBUG_MESSAGE_LENGTH',0x9143) +GL_MAX_DEBUG_MESSAGE_LENGTH_KHR=_C('GL_MAX_DEBUG_MESSAGE_LENGTH_KHR',0x9143) +GL_MAX_LABEL_LENGTH=_C('GL_MAX_LABEL_LENGTH',0x82E8) +GL_MAX_LABEL_LENGTH_KHR=_C('GL_MAX_LABEL_LENGTH_KHR',0x82E8) +GL_PROGRAM=_C('GL_PROGRAM',0x82E2) +GL_PROGRAM_KHR=_C('GL_PROGRAM_KHR',0x82E2) +GL_PROGRAM_PIPELINE=_C('GL_PROGRAM_PIPELINE',0x82E4) +GL_PROGRAM_PIPELINE_KHR=_C('GL_PROGRAM_PIPELINE_KHR',0x82E4) +GL_QUERY=_C('GL_QUERY',0x82E3) +GL_QUERY_KHR=_C('GL_QUERY_KHR',0x82E3) +GL_SAMPLER=_C('GL_SAMPLER',0x82E6) +GL_SAMPLER_KHR=_C('GL_SAMPLER_KHR',0x82E6) +GL_SHADER=_C('GL_SHADER',0x82E1) +GL_SHADER_KHR=_C('GL_SHADER_KHR',0x82E1) +GL_STACK_OVERFLOW=_C('GL_STACK_OVERFLOW',0x0503) +GL_STACK_OVERFLOW_KHR=_C('GL_STACK_OVERFLOW_KHR',0x0503) +GL_STACK_UNDERFLOW=_C('GL_STACK_UNDERFLOW',0x0504) +GL_STACK_UNDERFLOW_KHR=_C('GL_STACK_UNDERFLOW_KHR',0x0504) +GL_VERTEX_ARRAY=_C('GL_VERTEX_ARRAY',0x8074) +GL_VERTEX_ARRAY_KHR=_C('GL_VERTEX_ARRAY_KHR',0x8074) +@_f +@_p.types(None,_cs.GLDEBUGPROC,ctypes.c_void_p) +def glDebugMessageCallback(callback,userParam):pass +@_f +@_p.types(None,_cs.GLDEBUGPROCKHR,ctypes.c_void_p) +def glDebugMessageCallbackKHR(callback,userParam):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLenum,_cs.GLsizei,arrays.GLuintArray,_cs.GLboolean) +def glDebugMessageControl(source,type,severity,count,ids,enabled):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLenum,_cs.GLsizei,arrays.GLuintArray,_cs.GLboolean) +def glDebugMessageControlKHR(source,type,severity,count,ids,enabled):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLuint,_cs.GLenum,_cs.GLsizei,arrays.GLcharArray) +def glDebugMessageInsert(source,type,id,severity,length,buf):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLuint,_cs.GLenum,_cs.GLsizei,arrays.GLcharArray) +def glDebugMessageInsertKHR(source,type,id,severity,length,buf):pass +@_f +@_p.types(_cs.GLuint,_cs.GLuint,_cs.GLsizei,arrays.GLuintArray,arrays.GLuintArray,arrays.GLuintArray,arrays.GLuintArray,arrays.GLsizeiArray,arrays.GLcharArray) +def glGetDebugMessageLog(count,bufSize,sources,types,ids,severities,lengths,messageLog):pass +@_f +@_p.types(_cs.GLuint,_cs.GLuint,_cs.GLsizei,arrays.GLuintArray,arrays.GLuintArray,arrays.GLuintArray,arrays.GLuintArray,arrays.GLsizeiArray,arrays.GLcharArray) +def glGetDebugMessageLogKHR(count,bufSize,sources,types,ids,severities,lengths,messageLog):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,_cs.GLsizei,arrays.GLsizeiArray,arrays.GLcharArray) +def glGetObjectLabel(identifier,name,bufSize,length,label):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,_cs.GLsizei,arrays.GLsizeiArray,arrays.GLcharArray) +def glGetObjectLabelKHR(identifier,name,bufSize,length,label):pass +@_f +@_p.types(None,ctypes.c_void_p,_cs.GLsizei,arrays.GLsizeiArray,arrays.GLcharArray) +def glGetObjectPtrLabel(ptr,bufSize,length,label):pass +@_f +@_p.types(None,ctypes.c_void_p,_cs.GLsizei,arrays.GLsizeiArray,arrays.GLcharArray) +def glGetObjectPtrLabelKHR(ptr,bufSize,length,label):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLvoidpArray) +def glGetPointerv(pname,params):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLvoidpArray) +def glGetPointervKHR(pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,_cs.GLsizei,arrays.GLcharArray) +def glObjectLabel(identifier,name,length,label):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,_cs.GLsizei,arrays.GLcharArray) +def glObjectLabelKHR(identifier,name,length,label):pass +@_f +@_p.types(None,ctypes.c_void_p,_cs.GLsizei,arrays.GLcharArray) +def glObjectPtrLabel(ptr,length,label):pass +@_f +@_p.types(None,ctypes.c_void_p,_cs.GLsizei,arrays.GLcharArray) +def glObjectPtrLabelKHR(ptr,length,label):pass +@_f +@_p.types(None,) +def glPopDebugGroup():pass +@_f +@_p.types(None,) +def glPopDebugGroupKHR():pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,_cs.GLsizei,arrays.GLcharArray) +def glPushDebugGroup(source,id,length,message):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,_cs.GLsizei,arrays.GLcharArray) +def glPushDebugGroupKHR(source,id,length,message):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/KHR/no_error.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/KHR/no_error.py new file mode 100644 index 00000000..0c5c3406 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/KHR/no_error.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_KHR_no_error' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_KHR_no_error',error_checker=_errors._error_checker) +GL_CONTEXT_FLAG_NO_ERROR_BIT_KHR=_C('GL_CONTEXT_FLAG_NO_ERROR_BIT_KHR',0x00000008) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/KHR/parallel_shader_compile.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/KHR/parallel_shader_compile.py new file mode 100644 index 00000000..f5df4fc9 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/KHR/parallel_shader_compile.py @@ -0,0 +1,18 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_KHR_parallel_shader_compile' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_KHR_parallel_shader_compile',error_checker=_errors._error_checker) +GL_COMPLETION_STATUS_KHR=_C('GL_COMPLETION_STATUS_KHR',0x91B1) +GL_MAX_SHADER_COMPILER_THREADS_KHR=_C('GL_MAX_SHADER_COMPILER_THREADS_KHR',0x91B0) +@_f +@_p.types(None,_cs.GLuint) +def glMaxShaderCompilerThreadsKHR(count):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/KHR/robust_buffer_access_behavior.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/KHR/robust_buffer_access_behavior.py new file mode 100644 index 00000000..e20df329 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/KHR/robust_buffer_access_behavior.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_KHR_robust_buffer_access_behavior' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_KHR_robust_buffer_access_behavior',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/KHR/robustness.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/KHR/robustness.py new file mode 100644 index 00000000..707c79ac --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/KHR/robustness.py @@ -0,0 +1,61 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_KHR_robustness' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_KHR_robustness',error_checker=_errors._error_checker) +GL_CONTEXT_LOST=_C('GL_CONTEXT_LOST',0x0507) +GL_CONTEXT_LOST_KHR=_C('GL_CONTEXT_LOST_KHR',0x0507) +GL_CONTEXT_ROBUST_ACCESS=_C('GL_CONTEXT_ROBUST_ACCESS',0x90F3) +GL_CONTEXT_ROBUST_ACCESS_KHR=_C('GL_CONTEXT_ROBUST_ACCESS_KHR',0x90F3) +GL_GUILTY_CONTEXT_RESET=_C('GL_GUILTY_CONTEXT_RESET',0x8253) +GL_GUILTY_CONTEXT_RESET_KHR=_C('GL_GUILTY_CONTEXT_RESET_KHR',0x8253) +GL_INNOCENT_CONTEXT_RESET=_C('GL_INNOCENT_CONTEXT_RESET',0x8254) +GL_INNOCENT_CONTEXT_RESET_KHR=_C('GL_INNOCENT_CONTEXT_RESET_KHR',0x8254) +GL_LOSE_CONTEXT_ON_RESET=_C('GL_LOSE_CONTEXT_ON_RESET',0x8252) +GL_LOSE_CONTEXT_ON_RESET_KHR=_C('GL_LOSE_CONTEXT_ON_RESET_KHR',0x8252) +GL_NO_ERROR=_C('GL_NO_ERROR',0) +GL_NO_ERROR=_C('GL_NO_ERROR',0) +GL_NO_RESET_NOTIFICATION=_C('GL_NO_RESET_NOTIFICATION',0x8261) +GL_NO_RESET_NOTIFICATION_KHR=_C('GL_NO_RESET_NOTIFICATION_KHR',0x8261) +GL_RESET_NOTIFICATION_STRATEGY=_C('GL_RESET_NOTIFICATION_STRATEGY',0x8256) +GL_RESET_NOTIFICATION_STRATEGY_KHR=_C('GL_RESET_NOTIFICATION_STRATEGY_KHR',0x8256) +GL_UNKNOWN_CONTEXT_RESET=_C('GL_UNKNOWN_CONTEXT_RESET',0x8255) +GL_UNKNOWN_CONTEXT_RESET_KHR=_C('GL_UNKNOWN_CONTEXT_RESET_KHR',0x8255) +@_f +@_p.types(_cs.GLenum,) +def glGetGraphicsResetStatus():pass +@_f +@_p.types(_cs.GLenum,) +def glGetGraphicsResetStatusKHR():pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLfloatArray) +def glGetnUniformfv(program,location,bufSize,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLfloatArray) +def glGetnUniformfvKHR(program,location,bufSize,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLintArray) +def glGetnUniformiv(program,location,bufSize,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLintArray) +def glGetnUniformivKHR(program,location,bufSize,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLuintArray) +def glGetnUniformuiv(program,location,bufSize,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLuintArray) +def glGetnUniformuivKHR(program,location,bufSize,params):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLsizei,_cs.GLenum,_cs.GLenum,_cs.GLsizei,ctypes.c_void_p) +def glReadnPixels(x,y,width,height,format,type,bufSize,data):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLsizei,_cs.GLenum,_cs.GLenum,_cs.GLsizei,ctypes.c_void_p) +def glReadnPixelsKHR(x,y,width,height,format,type,bufSize,data):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/KHR/shader_subgroup.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/KHR/shader_subgroup.py new file mode 100644 index 00000000..af7204c0 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/KHR/shader_subgroup.py @@ -0,0 +1,26 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_KHR_shader_subgroup' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_KHR_shader_subgroup',error_checker=_errors._error_checker) +GL_SUBGROUP_FEATURE_ARITHMETIC_BIT_KHR=_C('GL_SUBGROUP_FEATURE_ARITHMETIC_BIT_KHR',0x00000004) +GL_SUBGROUP_FEATURE_BALLOT_BIT_KHR=_C('GL_SUBGROUP_FEATURE_BALLOT_BIT_KHR',0x00000008) +GL_SUBGROUP_FEATURE_BASIC_BIT_KHR=_C('GL_SUBGROUP_FEATURE_BASIC_BIT_KHR',0x00000001) +GL_SUBGROUP_FEATURE_CLUSTERED_BIT_KHR=_C('GL_SUBGROUP_FEATURE_CLUSTERED_BIT_KHR',0x00000040) +GL_SUBGROUP_FEATURE_QUAD_BIT_KHR=_C('GL_SUBGROUP_FEATURE_QUAD_BIT_KHR',0x00000080) +GL_SUBGROUP_FEATURE_SHUFFLE_BIT_KHR=_C('GL_SUBGROUP_FEATURE_SHUFFLE_BIT_KHR',0x00000010) +GL_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT_KHR=_C('GL_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT_KHR',0x00000020) +GL_SUBGROUP_FEATURE_VOTE_BIT_KHR=_C('GL_SUBGROUP_FEATURE_VOTE_BIT_KHR',0x00000002) +GL_SUBGROUP_QUAD_ALL_STAGES_KHR=_C('GL_SUBGROUP_QUAD_ALL_STAGES_KHR',0x9535) +GL_SUBGROUP_SIZE_KHR=_C('GL_SUBGROUP_SIZE_KHR',0x9532) +GL_SUBGROUP_SUPPORTED_FEATURES_KHR=_C('GL_SUBGROUP_SUPPORTED_FEATURES_KHR',0x9534) +GL_SUBGROUP_SUPPORTED_STAGES_KHR=_C('GL_SUBGROUP_SUPPORTED_STAGES_KHR',0x9533) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/KHR/texture_compression_astc_hdr.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/KHR/texture_compression_astc_hdr.py new file mode 100644 index 00000000..45d0c836 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/KHR/texture_compression_astc_hdr.py @@ -0,0 +1,42 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_KHR_texture_compression_astc_hdr' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_KHR_texture_compression_astc_hdr',error_checker=_errors._error_checker) +GL_COMPRESSED_RGBA_ASTC_10x10_KHR=_C('GL_COMPRESSED_RGBA_ASTC_10x10_KHR',0x93BB) +GL_COMPRESSED_RGBA_ASTC_10x5_KHR=_C('GL_COMPRESSED_RGBA_ASTC_10x5_KHR',0x93B8) +GL_COMPRESSED_RGBA_ASTC_10x6_KHR=_C('GL_COMPRESSED_RGBA_ASTC_10x6_KHR',0x93B9) +GL_COMPRESSED_RGBA_ASTC_10x8_KHR=_C('GL_COMPRESSED_RGBA_ASTC_10x8_KHR',0x93BA) +GL_COMPRESSED_RGBA_ASTC_12x10_KHR=_C('GL_COMPRESSED_RGBA_ASTC_12x10_KHR',0x93BC) +GL_COMPRESSED_RGBA_ASTC_12x12_KHR=_C('GL_COMPRESSED_RGBA_ASTC_12x12_KHR',0x93BD) +GL_COMPRESSED_RGBA_ASTC_4x4_KHR=_C('GL_COMPRESSED_RGBA_ASTC_4x4_KHR',0x93B0) +GL_COMPRESSED_RGBA_ASTC_5x4_KHR=_C('GL_COMPRESSED_RGBA_ASTC_5x4_KHR',0x93B1) +GL_COMPRESSED_RGBA_ASTC_5x5_KHR=_C('GL_COMPRESSED_RGBA_ASTC_5x5_KHR',0x93B2) +GL_COMPRESSED_RGBA_ASTC_6x5_KHR=_C('GL_COMPRESSED_RGBA_ASTC_6x5_KHR',0x93B3) +GL_COMPRESSED_RGBA_ASTC_6x6_KHR=_C('GL_COMPRESSED_RGBA_ASTC_6x6_KHR',0x93B4) +GL_COMPRESSED_RGBA_ASTC_8x5_KHR=_C('GL_COMPRESSED_RGBA_ASTC_8x5_KHR',0x93B5) +GL_COMPRESSED_RGBA_ASTC_8x6_KHR=_C('GL_COMPRESSED_RGBA_ASTC_8x6_KHR',0x93B6) +GL_COMPRESSED_RGBA_ASTC_8x8_KHR=_C('GL_COMPRESSED_RGBA_ASTC_8x8_KHR',0x93B7) +GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR=_C('GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR',0x93DB) +GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR=_C('GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR',0x93D8) +GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR=_C('GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR',0x93D9) +GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR=_C('GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR',0x93DA) +GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR=_C('GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR',0x93DC) +GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR=_C('GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR',0x93DD) +GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR=_C('GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR',0x93D0) +GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR=_C('GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR',0x93D1) +GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR=_C('GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR',0x93D2) +GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR=_C('GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR',0x93D3) +GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR=_C('GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR',0x93D4) +GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR=_C('GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR',0x93D5) +GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR=_C('GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR',0x93D6) +GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR=_C('GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR',0x93D7) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/KHR/texture_compression_astc_ldr.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/KHR/texture_compression_astc_ldr.py new file mode 100644 index 00000000..cc61074c --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/KHR/texture_compression_astc_ldr.py @@ -0,0 +1,42 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_KHR_texture_compression_astc_ldr' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_KHR_texture_compression_astc_ldr',error_checker=_errors._error_checker) +GL_COMPRESSED_RGBA_ASTC_10x10_KHR=_C('GL_COMPRESSED_RGBA_ASTC_10x10_KHR',0x93BB) +GL_COMPRESSED_RGBA_ASTC_10x5_KHR=_C('GL_COMPRESSED_RGBA_ASTC_10x5_KHR',0x93B8) +GL_COMPRESSED_RGBA_ASTC_10x6_KHR=_C('GL_COMPRESSED_RGBA_ASTC_10x6_KHR',0x93B9) +GL_COMPRESSED_RGBA_ASTC_10x8_KHR=_C('GL_COMPRESSED_RGBA_ASTC_10x8_KHR',0x93BA) +GL_COMPRESSED_RGBA_ASTC_12x10_KHR=_C('GL_COMPRESSED_RGBA_ASTC_12x10_KHR',0x93BC) +GL_COMPRESSED_RGBA_ASTC_12x12_KHR=_C('GL_COMPRESSED_RGBA_ASTC_12x12_KHR',0x93BD) +GL_COMPRESSED_RGBA_ASTC_4x4_KHR=_C('GL_COMPRESSED_RGBA_ASTC_4x4_KHR',0x93B0) +GL_COMPRESSED_RGBA_ASTC_5x4_KHR=_C('GL_COMPRESSED_RGBA_ASTC_5x4_KHR',0x93B1) +GL_COMPRESSED_RGBA_ASTC_5x5_KHR=_C('GL_COMPRESSED_RGBA_ASTC_5x5_KHR',0x93B2) +GL_COMPRESSED_RGBA_ASTC_6x5_KHR=_C('GL_COMPRESSED_RGBA_ASTC_6x5_KHR',0x93B3) +GL_COMPRESSED_RGBA_ASTC_6x6_KHR=_C('GL_COMPRESSED_RGBA_ASTC_6x6_KHR',0x93B4) +GL_COMPRESSED_RGBA_ASTC_8x5_KHR=_C('GL_COMPRESSED_RGBA_ASTC_8x5_KHR',0x93B5) +GL_COMPRESSED_RGBA_ASTC_8x6_KHR=_C('GL_COMPRESSED_RGBA_ASTC_8x6_KHR',0x93B6) +GL_COMPRESSED_RGBA_ASTC_8x8_KHR=_C('GL_COMPRESSED_RGBA_ASTC_8x8_KHR',0x93B7) +GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR=_C('GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR',0x93DB) +GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR=_C('GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR',0x93D8) +GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR=_C('GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR',0x93D9) +GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR=_C('GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR',0x93DA) +GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR=_C('GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR',0x93DC) +GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR=_C('GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR',0x93DD) +GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR=_C('GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR',0x93D0) +GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR=_C('GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR',0x93D1) +GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR=_C('GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR',0x93D2) +GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR=_C('GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR',0x93D3) +GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR=_C('GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR',0x93D4) +GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR=_C('GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR',0x93D5) +GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR=_C('GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR',0x93D6) +GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR=_C('GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR',0x93D7) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/KHR/texture_compression_astc_sliced_3d.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/KHR/texture_compression_astc_sliced_3d.py new file mode 100644 index 00000000..494e1d5f --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/KHR/texture_compression_astc_sliced_3d.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_KHR_texture_compression_astc_sliced_3d' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_KHR_texture_compression_astc_sliced_3d',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/MESA/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/MESA/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/MESA/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/MESA/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/MESA/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..3d22dbc1 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/MESA/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/MESA/__pycache__/framebuffer_flip_y.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/MESA/__pycache__/framebuffer_flip_y.cpython-312.pyc new file mode 100644 index 00000000..d24da519 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/MESA/__pycache__/framebuffer_flip_y.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/MESA/__pycache__/program_binary_formats.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/MESA/__pycache__/program_binary_formats.cpython-312.pyc new file mode 100644 index 00000000..a988d4ad Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/MESA/__pycache__/program_binary_formats.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/MESA/__pycache__/shader_integer_functions.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/MESA/__pycache__/shader_integer_functions.cpython-312.pyc new file mode 100644 index 00000000..b1275691 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/MESA/__pycache__/shader_integer_functions.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/MESA/framebuffer_flip_y.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/MESA/framebuffer_flip_y.py new file mode 100644 index 00000000..69309f3f --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/MESA/framebuffer_flip_y.py @@ -0,0 +1,20 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_MESA_framebuffer_flip_y' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_MESA_framebuffer_flip_y',error_checker=_errors._error_checker) +GL_FRAMEBUFFER_FLIP_Y_MESA=_C('GL_FRAMEBUFFER_FLIP_Y_MESA',0x8BBB) +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLint) +def glFramebufferParameteriMESA(target,pname,param):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLintArray) +def glGetFramebufferParameterivMESA(target,pname,params):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/MESA/program_binary_formats.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/MESA/program_binary_formats.py new file mode 100644 index 00000000..3dd99680 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/MESA/program_binary_formats.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_MESA_program_binary_formats' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_MESA_program_binary_formats',error_checker=_errors._error_checker) +GL_PROGRAM_BINARY_FORMAT_MESA=_C('GL_PROGRAM_BINARY_FORMAT_MESA',0x875F) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/MESA/shader_integer_functions.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/MESA/shader_integer_functions.py new file mode 100644 index 00000000..34160c01 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/MESA/shader_integer_functions.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_MESA_shader_integer_functions' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_MESA_shader_integer_functions',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..9e26ad24 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/bindless_texture.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/bindless_texture.cpython-312.pyc new file mode 100644 index 00000000..91c716af Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/bindless_texture.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/blend_equation_advanced.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/blend_equation_advanced.cpython-312.pyc new file mode 100644 index 00000000..7633a4e7 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/blend_equation_advanced.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/blend_equation_advanced_coherent.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/blend_equation_advanced_coherent.cpython-312.pyc new file mode 100644 index 00000000..e7ff4483 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/blend_equation_advanced_coherent.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/blend_minmax_factor.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/blend_minmax_factor.cpython-312.pyc new file mode 100644 index 00000000..c4545351 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/blend_minmax_factor.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/clip_space_w_scaling.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/clip_space_w_scaling.cpython-312.pyc new file mode 100644 index 00000000..9d4e8d54 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/clip_space_w_scaling.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/compute_shader_derivatives.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/compute_shader_derivatives.cpython-312.pyc new file mode 100644 index 00000000..7b4af979 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/compute_shader_derivatives.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/conditional_render.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/conditional_render.cpython-312.pyc new file mode 100644 index 00000000..9c991f23 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/conditional_render.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/conservative_raster.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/conservative_raster.cpython-312.pyc new file mode 100644 index 00000000..3f0c49c2 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/conservative_raster.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/conservative_raster_pre_snap.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/conservative_raster_pre_snap.cpython-312.pyc new file mode 100644 index 00000000..db5fcd33 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/conservative_raster_pre_snap.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/conservative_raster_pre_snap_triangles.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/conservative_raster_pre_snap_triangles.cpython-312.pyc new file mode 100644 index 00000000..896ea5fd Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/conservative_raster_pre_snap_triangles.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/copy_buffer.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/copy_buffer.cpython-312.pyc new file mode 100644 index 00000000..044b2c89 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/copy_buffer.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/coverage_sample.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/coverage_sample.cpython-312.pyc new file mode 100644 index 00000000..c734caa7 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/coverage_sample.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/depth_nonlinear.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/depth_nonlinear.cpython-312.pyc new file mode 100644 index 00000000..e844bc5b Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/depth_nonlinear.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/draw_buffers.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/draw_buffers.cpython-312.pyc new file mode 100644 index 00000000..23793cb1 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/draw_buffers.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/draw_instanced.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/draw_instanced.cpython-312.pyc new file mode 100644 index 00000000..f1be147d Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/draw_instanced.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/draw_vulkan_image.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/draw_vulkan_image.cpython-312.pyc new file mode 100644 index 00000000..54958af7 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/draw_vulkan_image.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/explicit_attrib_location.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/explicit_attrib_location.cpython-312.pyc new file mode 100644 index 00000000..8f639641 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/explicit_attrib_location.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/fbo_color_attachments.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/fbo_color_attachments.cpython-312.pyc new file mode 100644 index 00000000..f9a21928 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/fbo_color_attachments.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/fence.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/fence.cpython-312.pyc new file mode 100644 index 00000000..31998188 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/fence.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/fill_rectangle.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/fill_rectangle.cpython-312.pyc new file mode 100644 index 00000000..7d7f26bb Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/fill_rectangle.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/fragment_coverage_to_color.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/fragment_coverage_to_color.cpython-312.pyc new file mode 100644 index 00000000..215453cc Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/fragment_coverage_to_color.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/fragment_shader_barycentric.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/fragment_shader_barycentric.cpython-312.pyc new file mode 100644 index 00000000..5d69af7f Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/fragment_shader_barycentric.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/fragment_shader_interlock.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/fragment_shader_interlock.cpython-312.pyc new file mode 100644 index 00000000..174c168e Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/fragment_shader_interlock.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/framebuffer_blit.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/framebuffer_blit.cpython-312.pyc new file mode 100644 index 00000000..2231e1ce Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/framebuffer_blit.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/framebuffer_mixed_samples.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/framebuffer_mixed_samples.cpython-312.pyc new file mode 100644 index 00000000..2d477130 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/framebuffer_mixed_samples.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/framebuffer_multisample.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/framebuffer_multisample.cpython-312.pyc new file mode 100644 index 00000000..57aebacf Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/framebuffer_multisample.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/generate_mipmap_sRGB.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/generate_mipmap_sRGB.cpython-312.pyc new file mode 100644 index 00000000..f720c0b5 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/generate_mipmap_sRGB.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/geometry_shader_passthrough.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/geometry_shader_passthrough.cpython-312.pyc new file mode 100644 index 00000000..483f9fcb Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/geometry_shader_passthrough.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/gpu_shader5.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/gpu_shader5.cpython-312.pyc new file mode 100644 index 00000000..5a90e4df Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/gpu_shader5.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/image_formats.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/image_formats.cpython-312.pyc new file mode 100644 index 00000000..4387e853 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/image_formats.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/instanced_arrays.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/instanced_arrays.cpython-312.pyc new file mode 100644 index 00000000..365b4f71 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/instanced_arrays.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/internalformat_sample_query.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/internalformat_sample_query.cpython-312.pyc new file mode 100644 index 00000000..caeb1e53 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/internalformat_sample_query.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/memory_attachment.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/memory_attachment.cpython-312.pyc new file mode 100644 index 00000000..020092c1 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/memory_attachment.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/mesh_shader.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/mesh_shader.cpython-312.pyc new file mode 100644 index 00000000..97899b04 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/mesh_shader.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/non_square_matrices.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/non_square_matrices.cpython-312.pyc new file mode 100644 index 00000000..e2358999 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/non_square_matrices.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/path_rendering.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/path_rendering.cpython-312.pyc new file mode 100644 index 00000000..7367b547 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/path_rendering.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/path_rendering_shared_edge.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/path_rendering_shared_edge.cpython-312.pyc new file mode 100644 index 00000000..f7cdd916 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/path_rendering_shared_edge.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/pixel_buffer_object.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/pixel_buffer_object.cpython-312.pyc new file mode 100644 index 00000000..d8bd10ef Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/pixel_buffer_object.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/polygon_mode.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/polygon_mode.cpython-312.pyc new file mode 100644 index 00000000..58d238e4 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/polygon_mode.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/read_buffer.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/read_buffer.cpython-312.pyc new file mode 100644 index 00000000..afe16b81 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/read_buffer.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/read_buffer_front.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/read_buffer_front.cpython-312.pyc new file mode 100644 index 00000000..2499beba Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/read_buffer_front.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/read_depth.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/read_depth.cpython-312.pyc new file mode 100644 index 00000000..2ffdbbbe Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/read_depth.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/read_depth_stencil.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/read_depth_stencil.cpython-312.pyc new file mode 100644 index 00000000..11b4a024 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/read_depth_stencil.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/read_stencil.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/read_stencil.cpython-312.pyc new file mode 100644 index 00000000..69e7cc2f Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/read_stencil.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/representative_fragment_test.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/representative_fragment_test.cpython-312.pyc new file mode 100644 index 00000000..026e5932 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/representative_fragment_test.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/sRGB_formats.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/sRGB_formats.cpython-312.pyc new file mode 100644 index 00000000..5b80535a Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/sRGB_formats.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/sample_locations.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/sample_locations.cpython-312.pyc new file mode 100644 index 00000000..e2b251a5 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/sample_locations.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/sample_mask_override_coverage.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/sample_mask_override_coverage.cpython-312.pyc new file mode 100644 index 00000000..ccc22dbf Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/sample_mask_override_coverage.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/scissor_exclusive.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/scissor_exclusive.cpython-312.pyc new file mode 100644 index 00000000..ba43037f Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/scissor_exclusive.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/shader_atomic_fp16_vector.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/shader_atomic_fp16_vector.cpython-312.pyc new file mode 100644 index 00000000..0711f08e Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/shader_atomic_fp16_vector.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/shader_noperspective_interpolation.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/shader_noperspective_interpolation.cpython-312.pyc new file mode 100644 index 00000000..b9e1d3ad Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/shader_noperspective_interpolation.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/shader_subgroup_partitioned.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/shader_subgroup_partitioned.cpython-312.pyc new file mode 100644 index 00000000..1332eabd Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/shader_subgroup_partitioned.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/shader_texture_footprint.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/shader_texture_footprint.cpython-312.pyc new file mode 100644 index 00000000..2afc9bb6 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/shader_texture_footprint.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/shading_rate_image.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/shading_rate_image.cpython-312.pyc new file mode 100644 index 00000000..bb6bf4db Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/shading_rate_image.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/shadow_samplers_array.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/shadow_samplers_array.cpython-312.pyc new file mode 100644 index 00000000..1512490c Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/shadow_samplers_array.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/shadow_samplers_cube.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/shadow_samplers_cube.cpython-312.pyc new file mode 100644 index 00000000..d60bb681 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/shadow_samplers_cube.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/stereo_view_rendering.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/stereo_view_rendering.cpython-312.pyc new file mode 100644 index 00000000..629b4166 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/stereo_view_rendering.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/texture_border_clamp.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/texture_border_clamp.cpython-312.pyc new file mode 100644 index 00000000..70dcb29a Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/texture_border_clamp.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/texture_compression_s3tc_update.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/texture_compression_s3tc_update.cpython-312.pyc new file mode 100644 index 00000000..29bcf661 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/texture_compression_s3tc_update.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/texture_npot_2D_mipmap.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/texture_npot_2D_mipmap.cpython-312.pyc new file mode 100644 index 00000000..4a06cfdd Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/texture_npot_2D_mipmap.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/viewport_array.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/viewport_array.cpython-312.pyc new file mode 100644 index 00000000..eff08d09 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/viewport_array.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/viewport_array2.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/viewport_array2.cpython-312.pyc new file mode 100644 index 00000000..d50e779e Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/viewport_array2.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/viewport_swizzle.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/viewport_swizzle.cpython-312.pyc new file mode 100644 index 00000000..7246bd37 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/__pycache__/viewport_swizzle.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/bindless_texture.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/bindless_texture.py new file mode 100644 index 00000000..c965920e --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/bindless_texture.py @@ -0,0 +1,53 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_NV_bindless_texture' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_NV_bindless_texture',error_checker=_errors._error_checker) + +@_f +@_p.types(_cs.GLuint64,_cs.GLuint,_cs.GLint,_cs.GLboolean,_cs.GLint,_cs.GLenum) +def glGetImageHandleNV(texture,level,layered,layer,format):pass +@_f +@_p.types(_cs.GLuint64,_cs.GLuint) +def glGetTextureHandleNV(texture):pass +@_f +@_p.types(_cs.GLuint64,_cs.GLuint,_cs.GLuint) +def glGetTextureSamplerHandleNV(texture,sampler):pass +@_f +@_p.types(_cs.GLboolean,_cs.GLuint64) +def glIsImageHandleResidentNV(handle):pass +@_f +@_p.types(_cs.GLboolean,_cs.GLuint64) +def glIsTextureHandleResidentNV(handle):pass +@_f +@_p.types(None,_cs.GLuint64) +def glMakeImageHandleNonResidentNV(handle):pass +@_f +@_p.types(None,_cs.GLuint64,_cs.GLenum) +def glMakeImageHandleResidentNV(handle,access):pass +@_f +@_p.types(None,_cs.GLuint64) +def glMakeTextureHandleNonResidentNV(handle):pass +@_f +@_p.types(None,_cs.GLuint64) +def glMakeTextureHandleResidentNV(handle):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLuint64) +def glProgramUniformHandleui64NV(program,location,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLuint64Array) +def glProgramUniformHandleui64vNV(program,location,count,values):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLuint64) +def glUniformHandleui64NV(location,value):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLsizei,arrays.GLuint64Array) +def glUniformHandleui64vNV(location,count,value):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/blend_equation_advanced.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/blend_equation_advanced.py new file mode 100644 index 00000000..4716da38 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/blend_equation_advanced.py @@ -0,0 +1,70 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_NV_blend_equation_advanced' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_NV_blend_equation_advanced',error_checker=_errors._error_checker) +GL_BLEND_OVERLAP_NV=_C('GL_BLEND_OVERLAP_NV',0x9281) +GL_BLEND_PREMULTIPLIED_SRC_NV=_C('GL_BLEND_PREMULTIPLIED_SRC_NV',0x9280) +GL_BLUE_NV=_C('GL_BLUE_NV',0x1905) +GL_COLORBURN_NV=_C('GL_COLORBURN_NV',0x929A) +GL_COLORDODGE_NV=_C('GL_COLORDODGE_NV',0x9299) +GL_CONJOINT_NV=_C('GL_CONJOINT_NV',0x9284) +GL_CONTRAST_NV=_C('GL_CONTRAST_NV',0x92A1) +GL_DARKEN_NV=_C('GL_DARKEN_NV',0x9297) +GL_DIFFERENCE_NV=_C('GL_DIFFERENCE_NV',0x929E) +GL_DISJOINT_NV=_C('GL_DISJOINT_NV',0x9283) +GL_DST_ATOP_NV=_C('GL_DST_ATOP_NV',0x928F) +GL_DST_IN_NV=_C('GL_DST_IN_NV',0x928B) +GL_DST_NV=_C('GL_DST_NV',0x9287) +GL_DST_OUT_NV=_C('GL_DST_OUT_NV',0x928D) +GL_DST_OVER_NV=_C('GL_DST_OVER_NV',0x9289) +GL_EXCLUSION_NV=_C('GL_EXCLUSION_NV',0x92A0) +GL_GREEN_NV=_C('GL_GREEN_NV',0x1904) +GL_HARDLIGHT_NV=_C('GL_HARDLIGHT_NV',0x929B) +GL_HARDMIX_NV=_C('GL_HARDMIX_NV',0x92A9) +GL_HSL_COLOR_NV=_C('GL_HSL_COLOR_NV',0x92AF) +GL_HSL_HUE_NV=_C('GL_HSL_HUE_NV',0x92AD) +GL_HSL_LUMINOSITY_NV=_C('GL_HSL_LUMINOSITY_NV',0x92B0) +GL_HSL_SATURATION_NV=_C('GL_HSL_SATURATION_NV',0x92AE) +GL_INVERT=_C('GL_INVERT',0x150A) +GL_INVERT_OVG_NV=_C('GL_INVERT_OVG_NV',0x92B4) +GL_INVERT_RGB_NV=_C('GL_INVERT_RGB_NV',0x92A3) +GL_LIGHTEN_NV=_C('GL_LIGHTEN_NV',0x9298) +GL_LINEARBURN_NV=_C('GL_LINEARBURN_NV',0x92A5) +GL_LINEARDODGE_NV=_C('GL_LINEARDODGE_NV',0x92A4) +GL_LINEARLIGHT_NV=_C('GL_LINEARLIGHT_NV',0x92A7) +GL_MINUS_CLAMPED_NV=_C('GL_MINUS_CLAMPED_NV',0x92B3) +GL_MINUS_NV=_C('GL_MINUS_NV',0x929F) +GL_MULTIPLY_NV=_C('GL_MULTIPLY_NV',0x9294) +GL_OVERLAY_NV=_C('GL_OVERLAY_NV',0x9296) +GL_PINLIGHT_NV=_C('GL_PINLIGHT_NV',0x92A8) +GL_PLUS_CLAMPED_ALPHA_NV=_C('GL_PLUS_CLAMPED_ALPHA_NV',0x92B2) +GL_PLUS_CLAMPED_NV=_C('GL_PLUS_CLAMPED_NV',0x92B1) +GL_PLUS_DARKER_NV=_C('GL_PLUS_DARKER_NV',0x9292) +GL_PLUS_NV=_C('GL_PLUS_NV',0x9291) +GL_RED_NV=_C('GL_RED_NV',0x1903) +GL_SCREEN_NV=_C('GL_SCREEN_NV',0x9295) +GL_SOFTLIGHT_NV=_C('GL_SOFTLIGHT_NV',0x929C) +GL_SRC_ATOP_NV=_C('GL_SRC_ATOP_NV',0x928E) +GL_SRC_IN_NV=_C('GL_SRC_IN_NV',0x928A) +GL_SRC_NV=_C('GL_SRC_NV',0x9286) +GL_SRC_OUT_NV=_C('GL_SRC_OUT_NV',0x928C) +GL_SRC_OVER_NV=_C('GL_SRC_OVER_NV',0x9288) +GL_UNCORRELATED_NV=_C('GL_UNCORRELATED_NV',0x9282) +GL_VIVIDLIGHT_NV=_C('GL_VIVIDLIGHT_NV',0x92A6) +GL_XOR_NV=_C('GL_XOR_NV',0x1506) +GL_ZERO=_C('GL_ZERO',0) +@_f +@_p.types(None,) +def glBlendBarrierNV():pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLint) +def glBlendParameteriNV(pname,value):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/blend_equation_advanced_coherent.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/blend_equation_advanced_coherent.py new file mode 100644 index 00000000..e9218e82 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/blend_equation_advanced_coherent.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_NV_blend_equation_advanced_coherent' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_NV_blend_equation_advanced_coherent',error_checker=_errors._error_checker) +GL_BLEND_ADVANCED_COHERENT_NV=_C('GL_BLEND_ADVANCED_COHERENT_NV',0x9285) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/blend_minmax_factor.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/blend_minmax_factor.py new file mode 100644 index 00000000..22ad99bb --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/blend_minmax_factor.py @@ -0,0 +1,16 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_NV_blend_minmax_factor' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_NV_blend_minmax_factor',error_checker=_errors._error_checker) +GL_FACTOR_MAX_AMD=_C('GL_FACTOR_MAX_AMD',0x901D) +GL_FACTOR_MIN_AMD=_C('GL_FACTOR_MIN_AMD',0x901C) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/clip_space_w_scaling.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/clip_space_w_scaling.py new file mode 100644 index 00000000..b8004a28 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/clip_space_w_scaling.py @@ -0,0 +1,19 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_NV_clip_space_w_scaling' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_NV_clip_space_w_scaling',error_checker=_errors._error_checker) +GL_VIEWPORT_POSITION_W_SCALE_NV=_C('GL_VIEWPORT_POSITION_W_SCALE_NV',0x937C) +GL_VIEWPORT_POSITION_W_SCALE_X_COEFF_NV=_C('GL_VIEWPORT_POSITION_W_SCALE_X_COEFF_NV',0x937D) +GL_VIEWPORT_POSITION_W_SCALE_Y_COEFF_NV=_C('GL_VIEWPORT_POSITION_W_SCALE_Y_COEFF_NV',0x937E) +@_f +@_p.types(None,_cs.GLuint,_cs.GLfloat,_cs.GLfloat) +def glViewportPositionWScaleNV(index,xcoeff,ycoeff):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/compute_shader_derivatives.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/compute_shader_derivatives.py new file mode 100644 index 00000000..85cea397 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/compute_shader_derivatives.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_NV_compute_shader_derivatives' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_NV_compute_shader_derivatives',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/conditional_render.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/conditional_render.py new file mode 100644 index 00000000..7304f9b5 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/conditional_render.py @@ -0,0 +1,23 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_NV_conditional_render' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_NV_conditional_render',error_checker=_errors._error_checker) +GL_QUERY_BY_REGION_NO_WAIT_NV=_C('GL_QUERY_BY_REGION_NO_WAIT_NV',0x8E16) +GL_QUERY_BY_REGION_WAIT_NV=_C('GL_QUERY_BY_REGION_WAIT_NV',0x8E15) +GL_QUERY_NO_WAIT_NV=_C('GL_QUERY_NO_WAIT_NV',0x8E14) +GL_QUERY_WAIT_NV=_C('GL_QUERY_WAIT_NV',0x8E13) +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum) +def glBeginConditionalRenderNV(id,mode):pass +@_f +@_p.types(None,) +def glEndConditionalRenderNV():pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/conservative_raster.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/conservative_raster.py new file mode 100644 index 00000000..8f650fb6 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/conservative_raster.py @@ -0,0 +1,20 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_NV_conservative_raster' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_NV_conservative_raster',error_checker=_errors._error_checker) +GL_CONSERVATIVE_RASTERIZATION_NV=_C('GL_CONSERVATIVE_RASTERIZATION_NV',0x9346) +GL_MAX_SUBPIXEL_PRECISION_BIAS_BITS_NV=_C('GL_MAX_SUBPIXEL_PRECISION_BIAS_BITS_NV',0x9349) +GL_SUBPIXEL_PRECISION_BIAS_X_BITS_NV=_C('GL_SUBPIXEL_PRECISION_BIAS_X_BITS_NV',0x9347) +GL_SUBPIXEL_PRECISION_BIAS_Y_BITS_NV=_C('GL_SUBPIXEL_PRECISION_BIAS_Y_BITS_NV',0x9348) +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint) +def glSubpixelPrecisionBiasNV(xbits,ybits):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/conservative_raster_pre_snap.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/conservative_raster_pre_snap.py new file mode 100644 index 00000000..7ea4a87f --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/conservative_raster_pre_snap.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_NV_conservative_raster_pre_snap' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_NV_conservative_raster_pre_snap',error_checker=_errors._error_checker) +GL_CONSERVATIVE_RASTER_MODE_PRE_SNAP_NV=_C('GL_CONSERVATIVE_RASTER_MODE_PRE_SNAP_NV',0x9550) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/conservative_raster_pre_snap_triangles.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/conservative_raster_pre_snap_triangles.py new file mode 100644 index 00000000..86228828 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/conservative_raster_pre_snap_triangles.py @@ -0,0 +1,20 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_NV_conservative_raster_pre_snap_triangles' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_NV_conservative_raster_pre_snap_triangles',error_checker=_errors._error_checker) +GL_CONSERVATIVE_RASTER_MODE_NV=_C('GL_CONSERVATIVE_RASTER_MODE_NV',0x954D) +GL_CONSERVATIVE_RASTER_MODE_NV=_C('GL_CONSERVATIVE_RASTER_MODE_NV',0x954D) +GL_CONSERVATIVE_RASTER_MODE_POST_SNAP_NV=_C('GL_CONSERVATIVE_RASTER_MODE_POST_SNAP_NV',0x954E) +GL_CONSERVATIVE_RASTER_MODE_PRE_SNAP_TRIANGLES_NV=_C('GL_CONSERVATIVE_RASTER_MODE_PRE_SNAP_TRIANGLES_NV',0x954F) +@_f +@_p.types(None,_cs.GLenum,_cs.GLint) +def glConservativeRasterParameteriNV(pname,param):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/copy_buffer.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/copy_buffer.py new file mode 100644 index 00000000..4aab1642 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/copy_buffer.py @@ -0,0 +1,18 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_NV_copy_buffer' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_NV_copy_buffer',error_checker=_errors._error_checker) +GL_COPY_READ_BUFFER_NV=_C('GL_COPY_READ_BUFFER_NV',0x8F36) +GL_COPY_WRITE_BUFFER_NV=_C('GL_COPY_WRITE_BUFFER_NV',0x8F37) +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLintptr,_cs.GLintptr,_cs.GLsizeiptr) +def glCopyBufferSubDataNV(readTarget,writeTarget,readOffset,writeOffset,size):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/coverage_sample.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/coverage_sample.py new file mode 100644 index 00000000..14cb7417 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/coverage_sample.py @@ -0,0 +1,28 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_NV_coverage_sample' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_NV_coverage_sample',error_checker=_errors._error_checker) +GL_COVERAGE_ALL_FRAGMENTS_NV=_C('GL_COVERAGE_ALL_FRAGMENTS_NV',0x8ED5) +GL_COVERAGE_ATTACHMENT_NV=_C('GL_COVERAGE_ATTACHMENT_NV',0x8ED2) +GL_COVERAGE_AUTOMATIC_NV=_C('GL_COVERAGE_AUTOMATIC_NV',0x8ED7) +GL_COVERAGE_BUFFERS_NV=_C('GL_COVERAGE_BUFFERS_NV',0x8ED3) +GL_COVERAGE_BUFFER_BIT_NV=_C('GL_COVERAGE_BUFFER_BIT_NV',0x00008000) +GL_COVERAGE_COMPONENT4_NV=_C('GL_COVERAGE_COMPONENT4_NV',0x8ED1) +GL_COVERAGE_COMPONENT_NV=_C('GL_COVERAGE_COMPONENT_NV',0x8ED0) +GL_COVERAGE_EDGE_FRAGMENTS_NV=_C('GL_COVERAGE_EDGE_FRAGMENTS_NV',0x8ED6) +GL_COVERAGE_SAMPLES_NV=_C('GL_COVERAGE_SAMPLES_NV',0x8ED4) +@_f +@_p.types(None,_cs.GLboolean) +def glCoverageMaskNV(mask):pass +@_f +@_p.types(None,_cs.GLenum) +def glCoverageOperationNV(operation):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/depth_nonlinear.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/depth_nonlinear.py new file mode 100644 index 00000000..e02a32e5 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/depth_nonlinear.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_NV_depth_nonlinear' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_NV_depth_nonlinear',error_checker=_errors._error_checker) +GL_DEPTH_COMPONENT16_NONLINEAR_NV=_C('GL_DEPTH_COMPONENT16_NONLINEAR_NV',0x8E2C) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/draw_buffers.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/draw_buffers.py new file mode 100644 index 00000000..6e6b30bf --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/draw_buffers.py @@ -0,0 +1,49 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_NV_draw_buffers' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_NV_draw_buffers',error_checker=_errors._error_checker) +GL_COLOR_ATTACHMENT0_NV=_C('GL_COLOR_ATTACHMENT0_NV',0x8CE0) +GL_COLOR_ATTACHMENT10_NV=_C('GL_COLOR_ATTACHMENT10_NV',0x8CEA) +GL_COLOR_ATTACHMENT11_NV=_C('GL_COLOR_ATTACHMENT11_NV',0x8CEB) +GL_COLOR_ATTACHMENT12_NV=_C('GL_COLOR_ATTACHMENT12_NV',0x8CEC) +GL_COLOR_ATTACHMENT13_NV=_C('GL_COLOR_ATTACHMENT13_NV',0x8CED) +GL_COLOR_ATTACHMENT14_NV=_C('GL_COLOR_ATTACHMENT14_NV',0x8CEE) +GL_COLOR_ATTACHMENT15_NV=_C('GL_COLOR_ATTACHMENT15_NV',0x8CEF) +GL_COLOR_ATTACHMENT1_NV=_C('GL_COLOR_ATTACHMENT1_NV',0x8CE1) +GL_COLOR_ATTACHMENT2_NV=_C('GL_COLOR_ATTACHMENT2_NV',0x8CE2) +GL_COLOR_ATTACHMENT3_NV=_C('GL_COLOR_ATTACHMENT3_NV',0x8CE3) +GL_COLOR_ATTACHMENT4_NV=_C('GL_COLOR_ATTACHMENT4_NV',0x8CE4) +GL_COLOR_ATTACHMENT5_NV=_C('GL_COLOR_ATTACHMENT5_NV',0x8CE5) +GL_COLOR_ATTACHMENT6_NV=_C('GL_COLOR_ATTACHMENT6_NV',0x8CE6) +GL_COLOR_ATTACHMENT7_NV=_C('GL_COLOR_ATTACHMENT7_NV',0x8CE7) +GL_COLOR_ATTACHMENT8_NV=_C('GL_COLOR_ATTACHMENT8_NV',0x8CE8) +GL_COLOR_ATTACHMENT9_NV=_C('GL_COLOR_ATTACHMENT9_NV',0x8CE9) +GL_DRAW_BUFFER0_NV=_C('GL_DRAW_BUFFER0_NV',0x8825) +GL_DRAW_BUFFER10_NV=_C('GL_DRAW_BUFFER10_NV',0x882F) +GL_DRAW_BUFFER11_NV=_C('GL_DRAW_BUFFER11_NV',0x8830) +GL_DRAW_BUFFER12_NV=_C('GL_DRAW_BUFFER12_NV',0x8831) +GL_DRAW_BUFFER13_NV=_C('GL_DRAW_BUFFER13_NV',0x8832) +GL_DRAW_BUFFER14_NV=_C('GL_DRAW_BUFFER14_NV',0x8833) +GL_DRAW_BUFFER15_NV=_C('GL_DRAW_BUFFER15_NV',0x8834) +GL_DRAW_BUFFER1_NV=_C('GL_DRAW_BUFFER1_NV',0x8826) +GL_DRAW_BUFFER2_NV=_C('GL_DRAW_BUFFER2_NV',0x8827) +GL_DRAW_BUFFER3_NV=_C('GL_DRAW_BUFFER3_NV',0x8828) +GL_DRAW_BUFFER4_NV=_C('GL_DRAW_BUFFER4_NV',0x8829) +GL_DRAW_BUFFER5_NV=_C('GL_DRAW_BUFFER5_NV',0x882A) +GL_DRAW_BUFFER6_NV=_C('GL_DRAW_BUFFER6_NV',0x882B) +GL_DRAW_BUFFER7_NV=_C('GL_DRAW_BUFFER7_NV',0x882C) +GL_DRAW_BUFFER8_NV=_C('GL_DRAW_BUFFER8_NV',0x882D) +GL_DRAW_BUFFER9_NV=_C('GL_DRAW_BUFFER9_NV',0x882E) +GL_MAX_DRAW_BUFFERS_NV=_C('GL_MAX_DRAW_BUFFERS_NV',0x8824) +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray) +def glDrawBuffersNV(n,bufs):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/draw_instanced.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/draw_instanced.py new file mode 100644 index 00000000..95fa3b54 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/draw_instanced.py @@ -0,0 +1,20 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_NV_draw_instanced' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_NV_draw_instanced',error_checker=_errors._error_checker) + +@_f +@_p.types(None,_cs.GLenum,_cs.GLint,_cs.GLsizei,_cs.GLsizei) +def glDrawArraysInstancedNV(mode,first,count,primcount):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizei,_cs.GLenum,ctypes.c_void_p,_cs.GLsizei) +def glDrawElementsInstancedNV(mode,count,type,indices,primcount):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/draw_vulkan_image.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/draw_vulkan_image.py new file mode 100644 index 00000000..22466456 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/draw_vulkan_image.py @@ -0,0 +1,29 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_NV_draw_vulkan_image' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_NV_draw_vulkan_image',error_checker=_errors._error_checker) + +@_f +@_p.types(None,_cs.GLuint64,_cs.GLuint,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat) +def glDrawVkImageNV(vkImage,sampler,x0,y0,x1,y1,z,s0,t0,s1,t1):pass +@_f +@_p.types(_cs.GLVULKANPROCNV,arrays.GLcharArray) +def glGetVkProcAddrNV(name):pass +@_f +@_p.types(None,_cs.GLuint64) +def glSignalVkFenceNV(vkFence):pass +@_f +@_p.types(None,_cs.GLuint64) +def glSignalVkSemaphoreNV(vkSemaphore):pass +@_f +@_p.types(None,_cs.GLuint64) +def glWaitVkSemaphoreNV(vkSemaphore):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/explicit_attrib_location.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/explicit_attrib_location.py new file mode 100644 index 00000000..cf096cdc --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/explicit_attrib_location.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_NV_explicit_attrib_location' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_NV_explicit_attrib_location',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/fbo_color_attachments.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/fbo_color_attachments.py new file mode 100644 index 00000000..4759066a --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/fbo_color_attachments.py @@ -0,0 +1,31 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_NV_fbo_color_attachments' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_NV_fbo_color_attachments',error_checker=_errors._error_checker) +GL_COLOR_ATTACHMENT0_NV=_C('GL_COLOR_ATTACHMENT0_NV',0x8CE0) +GL_COLOR_ATTACHMENT10_NV=_C('GL_COLOR_ATTACHMENT10_NV',0x8CEA) +GL_COLOR_ATTACHMENT11_NV=_C('GL_COLOR_ATTACHMENT11_NV',0x8CEB) +GL_COLOR_ATTACHMENT12_NV=_C('GL_COLOR_ATTACHMENT12_NV',0x8CEC) +GL_COLOR_ATTACHMENT13_NV=_C('GL_COLOR_ATTACHMENT13_NV',0x8CED) +GL_COLOR_ATTACHMENT14_NV=_C('GL_COLOR_ATTACHMENT14_NV',0x8CEE) +GL_COLOR_ATTACHMENT15_NV=_C('GL_COLOR_ATTACHMENT15_NV',0x8CEF) +GL_COLOR_ATTACHMENT1_NV=_C('GL_COLOR_ATTACHMENT1_NV',0x8CE1) +GL_COLOR_ATTACHMENT2_NV=_C('GL_COLOR_ATTACHMENT2_NV',0x8CE2) +GL_COLOR_ATTACHMENT3_NV=_C('GL_COLOR_ATTACHMENT3_NV',0x8CE3) +GL_COLOR_ATTACHMENT4_NV=_C('GL_COLOR_ATTACHMENT4_NV',0x8CE4) +GL_COLOR_ATTACHMENT5_NV=_C('GL_COLOR_ATTACHMENT5_NV',0x8CE5) +GL_COLOR_ATTACHMENT6_NV=_C('GL_COLOR_ATTACHMENT6_NV',0x8CE6) +GL_COLOR_ATTACHMENT7_NV=_C('GL_COLOR_ATTACHMENT7_NV',0x8CE7) +GL_COLOR_ATTACHMENT8_NV=_C('GL_COLOR_ATTACHMENT8_NV',0x8CE8) +GL_COLOR_ATTACHMENT9_NV=_C('GL_COLOR_ATTACHMENT9_NV',0x8CE9) +GL_MAX_COLOR_ATTACHMENTS_NV=_C('GL_MAX_COLOR_ATTACHMENTS_NV',0x8CDF) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/fence.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/fence.py new file mode 100644 index 00000000..83fa2932 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/fence.py @@ -0,0 +1,37 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_NV_fence' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_NV_fence',error_checker=_errors._error_checker) +GL_ALL_COMPLETED_NV=_C('GL_ALL_COMPLETED_NV',0x84F2) +GL_FENCE_CONDITION_NV=_C('GL_FENCE_CONDITION_NV',0x84F4) +GL_FENCE_STATUS_NV=_C('GL_FENCE_STATUS_NV',0x84F3) +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray) +def glDeleteFencesNV(n,fences):pass +@_f +@_p.types(None,_cs.GLuint) +def glFinishFenceNV(fence):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray) +def glGenFencesNV(n,fences):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLintArray) +def glGetFenceivNV(fence,pname,params):pass +@_f +@_p.types(_cs.GLboolean,_cs.GLuint) +def glIsFenceNV(fence):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum) +def glSetFenceNV(fence,condition):pass +@_f +@_p.types(_cs.GLboolean,_cs.GLuint) +def glTestFenceNV(fence):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/fill_rectangle.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/fill_rectangle.py new file mode 100644 index 00000000..6f8d0dca --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/fill_rectangle.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_NV_fill_rectangle' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_NV_fill_rectangle',error_checker=_errors._error_checker) +GL_FILL_RECTANGLE_NV=_C('GL_FILL_RECTANGLE_NV',0x933C) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/fragment_coverage_to_color.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/fragment_coverage_to_color.py new file mode 100644 index 00000000..cf2f4672 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/fragment_coverage_to_color.py @@ -0,0 +1,18 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_NV_fragment_coverage_to_color' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_NV_fragment_coverage_to_color',error_checker=_errors._error_checker) +GL_FRAGMENT_COVERAGE_COLOR_NV=_C('GL_FRAGMENT_COVERAGE_COLOR_NV',0x92DE) +GL_FRAGMENT_COVERAGE_TO_COLOR_NV=_C('GL_FRAGMENT_COVERAGE_TO_COLOR_NV',0x92DD) +@_f +@_p.types(None,_cs.GLuint) +def glFragmentCoverageColorNV(color):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/fragment_shader_barycentric.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/fragment_shader_barycentric.py new file mode 100644 index 00000000..636727ab --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/fragment_shader_barycentric.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_NV_fragment_shader_barycentric' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_NV_fragment_shader_barycentric',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/fragment_shader_interlock.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/fragment_shader_interlock.py new file mode 100644 index 00000000..deec7717 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/fragment_shader_interlock.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_NV_fragment_shader_interlock' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_NV_fragment_shader_interlock',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/framebuffer_blit.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/framebuffer_blit.py new file mode 100644 index 00000000..14b33a7e --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/framebuffer_blit.py @@ -0,0 +1,20 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_NV_framebuffer_blit' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_NV_framebuffer_blit',error_checker=_errors._error_checker) +GL_DRAW_FRAMEBUFFER_BINDING_NV=_C('GL_DRAW_FRAMEBUFFER_BINDING_NV',0x8CA6) +GL_DRAW_FRAMEBUFFER_NV=_C('GL_DRAW_FRAMEBUFFER_NV',0x8CA9) +GL_READ_FRAMEBUFFER_BINDING_NV=_C('GL_READ_FRAMEBUFFER_BINDING_NV',0x8CAA) +GL_READ_FRAMEBUFFER_NV=_C('GL_READ_FRAMEBUFFER_NV',0x8CA8) +@_f +@_p.types(None,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLbitfield,_cs.GLenum) +def glBlitFramebufferNV(srcX0,srcY0,srcX1,srcY1,dstX0,dstY0,dstX1,dstY1,mask,filter):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/framebuffer_mixed_samples.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/framebuffer_mixed_samples.py new file mode 100644 index 00000000..14df8099 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/framebuffer_mixed_samples.py @@ -0,0 +1,39 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_NV_framebuffer_mixed_samples' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_NV_framebuffer_mixed_samples',error_checker=_errors._error_checker) +GL_COLOR_SAMPLES_NV=_C('GL_COLOR_SAMPLES_NV',0x8E20) +GL_COVERAGE_MODULATION_NV=_C('GL_COVERAGE_MODULATION_NV',0x9332) +GL_COVERAGE_MODULATION_TABLE_NV=_C('GL_COVERAGE_MODULATION_TABLE_NV',0x9331) +GL_COVERAGE_MODULATION_TABLE_SIZE_NV=_C('GL_COVERAGE_MODULATION_TABLE_SIZE_NV',0x9333) +GL_DEPTH_SAMPLES_NV=_C('GL_DEPTH_SAMPLES_NV',0x932D) +GL_EFFECTIVE_RASTER_SAMPLES_EXT=_C('GL_EFFECTIVE_RASTER_SAMPLES_EXT',0x932C) +GL_MAX_RASTER_SAMPLES_EXT=_C('GL_MAX_RASTER_SAMPLES_EXT',0x9329) +GL_MIXED_DEPTH_SAMPLES_SUPPORTED_NV=_C('GL_MIXED_DEPTH_SAMPLES_SUPPORTED_NV',0x932F) +GL_MIXED_STENCIL_SAMPLES_SUPPORTED_NV=_C('GL_MIXED_STENCIL_SAMPLES_SUPPORTED_NV',0x9330) +GL_MULTISAMPLE_RASTERIZATION_ALLOWED_EXT=_C('GL_MULTISAMPLE_RASTERIZATION_ALLOWED_EXT',0x932B) +GL_RASTER_FIXED_SAMPLE_LOCATIONS_EXT=_C('GL_RASTER_FIXED_SAMPLE_LOCATIONS_EXT',0x932A) +GL_RASTER_MULTISAMPLE_EXT=_C('GL_RASTER_MULTISAMPLE_EXT',0x9327) +GL_RASTER_SAMPLES_EXT=_C('GL_RASTER_SAMPLES_EXT',0x9328) +GL_STENCIL_SAMPLES_NV=_C('GL_STENCIL_SAMPLES_NV',0x932E) +@_f +@_p.types(None,_cs.GLenum) +def glCoverageModulationNV(components):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLfloatArray) +def glCoverageModulationTableNV(n,v):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLfloatArray) +def glGetCoverageModulationTableNV(bufsize,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLboolean) +def glRasterSamplesEXT(samples,fixedsamplelocations):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/framebuffer_multisample.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/framebuffer_multisample.py new file mode 100644 index 00000000..58caaefe --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/framebuffer_multisample.py @@ -0,0 +1,19 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_NV_framebuffer_multisample' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_NV_framebuffer_multisample',error_checker=_errors._error_checker) +GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_NV=_C('GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_NV',0x8D56) +GL_MAX_SAMPLES_NV=_C('GL_MAX_SAMPLES_NV',0x8D57) +GL_RENDERBUFFER_SAMPLES_NV=_C('GL_RENDERBUFFER_SAMPLES_NV',0x8CAB) +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizei,_cs.GLenum,_cs.GLsizei,_cs.GLsizei) +def glRenderbufferStorageMultisampleNV(target,samples,internalformat,width,height):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/generate_mipmap_sRGB.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/generate_mipmap_sRGB.py new file mode 100644 index 00000000..4e0a2616 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/generate_mipmap_sRGB.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_NV_generate_mipmap_sRGB' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_NV_generate_mipmap_sRGB',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/geometry_shader_passthrough.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/geometry_shader_passthrough.py new file mode 100644 index 00000000..d4033958 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/geometry_shader_passthrough.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_NV_geometry_shader_passthrough' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_NV_geometry_shader_passthrough',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/gpu_shader5.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/gpu_shader5.py new file mode 100644 index 00000000..f9034a76 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/gpu_shader5.py @@ -0,0 +1,141 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_NV_gpu_shader5' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_NV_gpu_shader5',error_checker=_errors._error_checker) +GL_FLOAT16_NV=_C('GL_FLOAT16_NV',0x8FF8) +GL_FLOAT16_VEC2_NV=_C('GL_FLOAT16_VEC2_NV',0x8FF9) +GL_FLOAT16_VEC3_NV=_C('GL_FLOAT16_VEC3_NV',0x8FFA) +GL_FLOAT16_VEC4_NV=_C('GL_FLOAT16_VEC4_NV',0x8FFB) +GL_INT16_NV=_C('GL_INT16_NV',0x8FE4) +GL_INT16_VEC2_NV=_C('GL_INT16_VEC2_NV',0x8FE5) +GL_INT16_VEC3_NV=_C('GL_INT16_VEC3_NV',0x8FE6) +GL_INT16_VEC4_NV=_C('GL_INT16_VEC4_NV',0x8FE7) +GL_INT64_NV=_C('GL_INT64_NV',0x140E) +GL_INT64_VEC2_NV=_C('GL_INT64_VEC2_NV',0x8FE9) +GL_INT64_VEC3_NV=_C('GL_INT64_VEC3_NV',0x8FEA) +GL_INT64_VEC4_NV=_C('GL_INT64_VEC4_NV',0x8FEB) +GL_INT8_NV=_C('GL_INT8_NV',0x8FE0) +GL_INT8_VEC2_NV=_C('GL_INT8_VEC2_NV',0x8FE1) +GL_INT8_VEC3_NV=_C('GL_INT8_VEC3_NV',0x8FE2) +GL_INT8_VEC4_NV=_C('GL_INT8_VEC4_NV',0x8FE3) +GL_PATCHES=_C('GL_PATCHES',0x000E) +GL_UNSIGNED_INT16_NV=_C('GL_UNSIGNED_INT16_NV',0x8FF0) +GL_UNSIGNED_INT16_VEC2_NV=_C('GL_UNSIGNED_INT16_VEC2_NV',0x8FF1) +GL_UNSIGNED_INT16_VEC3_NV=_C('GL_UNSIGNED_INT16_VEC3_NV',0x8FF2) +GL_UNSIGNED_INT16_VEC4_NV=_C('GL_UNSIGNED_INT16_VEC4_NV',0x8FF3) +GL_UNSIGNED_INT64_NV=_C('GL_UNSIGNED_INT64_NV',0x140F) +GL_UNSIGNED_INT64_VEC2_NV=_C('GL_UNSIGNED_INT64_VEC2_NV',0x8FF5) +GL_UNSIGNED_INT64_VEC3_NV=_C('GL_UNSIGNED_INT64_VEC3_NV',0x8FF6) +GL_UNSIGNED_INT64_VEC4_NV=_C('GL_UNSIGNED_INT64_VEC4_NV',0x8FF7) +GL_UNSIGNED_INT8_NV=_C('GL_UNSIGNED_INT8_NV',0x8FEC) +GL_UNSIGNED_INT8_VEC2_NV=_C('GL_UNSIGNED_INT8_VEC2_NV',0x8FED) +GL_UNSIGNED_INT8_VEC3_NV=_C('GL_UNSIGNED_INT8_VEC3_NV',0x8FEE) +GL_UNSIGNED_INT8_VEC4_NV=_C('GL_UNSIGNED_INT8_VEC4_NV',0x8FEF) +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,arrays.GLint64Array) +def glGetUniformi64vNV(program,location,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLint64EXT) +def glProgramUniform1i64NV(program,location,x):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLint64Array) +def glProgramUniform1i64vNV(program,location,count,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLuint64EXT) +def glProgramUniform1ui64NV(program,location,x):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLuint64Array) +def glProgramUniform1ui64vNV(program,location,count,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLint64EXT,_cs.GLint64EXT) +def glProgramUniform2i64NV(program,location,x,y):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLint64Array) +def glProgramUniform2i64vNV(program,location,count,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLuint64EXT,_cs.GLuint64EXT) +def glProgramUniform2ui64NV(program,location,x,y):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLuint64Array) +def glProgramUniform2ui64vNV(program,location,count,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLint64EXT,_cs.GLint64EXT,_cs.GLint64EXT) +def glProgramUniform3i64NV(program,location,x,y,z):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLint64Array) +def glProgramUniform3i64vNV(program,location,count,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLuint64EXT,_cs.GLuint64EXT,_cs.GLuint64EXT) +def glProgramUniform3ui64NV(program,location,x,y,z):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLuint64Array) +def glProgramUniform3ui64vNV(program,location,count,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLint64EXT,_cs.GLint64EXT,_cs.GLint64EXT,_cs.GLint64EXT) +def glProgramUniform4i64NV(program,location,x,y,z,w):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLint64Array) +def glProgramUniform4i64vNV(program,location,count,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLuint64EXT,_cs.GLuint64EXT,_cs.GLuint64EXT,_cs.GLuint64EXT) +def glProgramUniform4ui64NV(program,location,x,y,z,w):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLuint64Array) +def glProgramUniform4ui64vNV(program,location,count,value):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLint64EXT) +def glUniform1i64NV(location,x):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLsizei,arrays.GLint64Array) +def glUniform1i64vNV(location,count,value):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLuint64EXT) +def glUniform1ui64NV(location,x):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLsizei,arrays.GLuint64Array) +def glUniform1ui64vNV(location,count,value):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLint64EXT,_cs.GLint64EXT) +def glUniform2i64NV(location,x,y):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLsizei,arrays.GLint64Array) +def glUniform2i64vNV(location,count,value):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLuint64EXT,_cs.GLuint64EXT) +def glUniform2ui64NV(location,x,y):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLsizei,arrays.GLuint64Array) +def glUniform2ui64vNV(location,count,value):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLint64EXT,_cs.GLint64EXT,_cs.GLint64EXT) +def glUniform3i64NV(location,x,y,z):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLsizei,arrays.GLint64Array) +def glUniform3i64vNV(location,count,value):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLuint64EXT,_cs.GLuint64EXT,_cs.GLuint64EXT) +def glUniform3ui64NV(location,x,y,z):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLsizei,arrays.GLuint64Array) +def glUniform3ui64vNV(location,count,value):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLint64EXT,_cs.GLint64EXT,_cs.GLint64EXT,_cs.GLint64EXT) +def glUniform4i64NV(location,x,y,z,w):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLsizei,arrays.GLint64Array) +def glUniform4i64vNV(location,count,value):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLuint64EXT,_cs.GLuint64EXT,_cs.GLuint64EXT,_cs.GLuint64EXT) +def glUniform4ui64NV(location,x,y,z,w):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLsizei,arrays.GLuint64Array) +def glUniform4ui64vNV(location,count,value):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/image_formats.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/image_formats.py new file mode 100644 index 00000000..46fe8277 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/image_formats.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_NV_image_formats' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_NV_image_formats',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/instanced_arrays.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/instanced_arrays.py new file mode 100644 index 00000000..bc438828 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/instanced_arrays.py @@ -0,0 +1,17 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_NV_instanced_arrays' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_NV_instanced_arrays',error_checker=_errors._error_checker) +GL_VERTEX_ATTRIB_ARRAY_DIVISOR_NV=_C('GL_VERTEX_ATTRIB_ARRAY_DIVISOR_NV',0x88FE) +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint) +def glVertexAttribDivisorNV(index,divisor):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/internalformat_sample_query.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/internalformat_sample_query.py new file mode 100644 index 00000000..13c7b9c2 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/internalformat_sample_query.py @@ -0,0 +1,23 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_NV_internalformat_sample_query' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_NV_internalformat_sample_query',error_checker=_errors._error_checker) +GL_CONFORMANT_NV=_C('GL_CONFORMANT_NV',0x9374) +GL_MULTISAMPLES_NV=_C('GL_MULTISAMPLES_NV',0x9371) +GL_RENDERBUFFER=_C('GL_RENDERBUFFER',0x8D41) +GL_SUPERSAMPLE_SCALE_X_NV=_C('GL_SUPERSAMPLE_SCALE_X_NV',0x9372) +GL_SUPERSAMPLE_SCALE_Y_NV=_C('GL_SUPERSAMPLE_SCALE_Y_NV',0x9373) +GL_TEXTURE_2D_MULTISAMPLE=_C('GL_TEXTURE_2D_MULTISAMPLE',0x9100) +GL_TEXTURE_2D_MULTISAMPLE_ARRAY=_C('GL_TEXTURE_2D_MULTISAMPLE_ARRAY',0x9102) +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLsizei,_cs.GLenum,_cs.GLsizei,arrays.GLintArray) +def glGetInternalformatSampleivNV(target,internalformat,samples,pname,bufSize,params):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/memory_attachment.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/memory_attachment.py new file mode 100644 index 00000000..d3c63bb4 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/memory_attachment.py @@ -0,0 +1,41 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_NV_memory_attachment' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_NV_memory_attachment',error_checker=_errors._error_checker) +GL_ATTACHED_MEMORY_OBJECT_NV=_C('GL_ATTACHED_MEMORY_OBJECT_NV',0x95A4) +GL_ATTACHED_MEMORY_OFFSET_NV=_C('GL_ATTACHED_MEMORY_OFFSET_NV',0x95A5) +GL_DETACHED_BUFFERS_NV=_C('GL_DETACHED_BUFFERS_NV',0x95AB) +GL_DETACHED_MEMORY_INCARNATION_NV=_C('GL_DETACHED_MEMORY_INCARNATION_NV',0x95A9) +GL_DETACHED_TEXTURES_NV=_C('GL_DETACHED_TEXTURES_NV',0x95AA) +GL_MAX_DETACHED_BUFFERS_NV=_C('GL_MAX_DETACHED_BUFFERS_NV',0x95AD) +GL_MAX_DETACHED_TEXTURES_NV=_C('GL_MAX_DETACHED_TEXTURES_NV',0x95AC) +GL_MEMORY_ATTACHABLE_ALIGNMENT_NV=_C('GL_MEMORY_ATTACHABLE_ALIGNMENT_NV',0x95A6) +GL_MEMORY_ATTACHABLE_NV=_C('GL_MEMORY_ATTACHABLE_NV',0x95A8) +GL_MEMORY_ATTACHABLE_SIZE_NV=_C('GL_MEMORY_ATTACHABLE_SIZE_NV',0x95A7) +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,_cs.GLuint64) +def glBufferAttachMemoryNV(target,memory,offset):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLint,_cs.GLsizei,arrays.GLuintArray) +def glGetMemoryObjectDetachedResourcesuivNV(memory,pname,first,count,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLuint64) +def glNamedBufferAttachMemoryNV(buffer,memory,offset):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum) +def glResetMemoryObjectParameterNV(memory,pname):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,_cs.GLuint64) +def glTexAttachMemoryNV(target,memory,offset):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLuint64) +def glTextureAttachMemoryNV(texture,memory,offset):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/mesh_shader.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/mesh_shader.py new file mode 100644 index 00000000..32e1c999 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/mesh_shader.py @@ -0,0 +1,73 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_NV_mesh_shader' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_NV_mesh_shader',error_checker=_errors._error_checker) +GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_MESH_SHADER_NV=_C('GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_MESH_SHADER_NV',0x959E) +GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TASK_SHADER_NV=_C('GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TASK_SHADER_NV',0x959F) +GL_MAX_COMBINED_MESH_UNIFORM_COMPONENTS_NV=_C('GL_MAX_COMBINED_MESH_UNIFORM_COMPONENTS_NV',0x8E67) +GL_MAX_COMBINED_TASK_UNIFORM_COMPONENTS_NV=_C('GL_MAX_COMBINED_TASK_UNIFORM_COMPONENTS_NV',0x8E6F) +GL_MAX_DRAW_MESH_TASKS_COUNT_NV=_C('GL_MAX_DRAW_MESH_TASKS_COUNT_NV',0x953D) +GL_MAX_MESH_ATOMIC_COUNTERS_NV=_C('GL_MAX_MESH_ATOMIC_COUNTERS_NV',0x8E65) +GL_MAX_MESH_ATOMIC_COUNTER_BUFFERS_NV=_C('GL_MAX_MESH_ATOMIC_COUNTER_BUFFERS_NV',0x8E64) +GL_MAX_MESH_IMAGE_UNIFORMS_NV=_C('GL_MAX_MESH_IMAGE_UNIFORMS_NV',0x8E62) +GL_MAX_MESH_OUTPUT_PRIMITIVES_NV=_C('GL_MAX_MESH_OUTPUT_PRIMITIVES_NV',0x9539) +GL_MAX_MESH_OUTPUT_VERTICES_NV=_C('GL_MAX_MESH_OUTPUT_VERTICES_NV',0x9538) +GL_MAX_MESH_SHADER_STORAGE_BLOCKS_NV=_C('GL_MAX_MESH_SHADER_STORAGE_BLOCKS_NV',0x8E66) +GL_MAX_MESH_TEXTURE_IMAGE_UNITS_NV=_C('GL_MAX_MESH_TEXTURE_IMAGE_UNITS_NV',0x8E61) +GL_MAX_MESH_TOTAL_MEMORY_SIZE_NV=_C('GL_MAX_MESH_TOTAL_MEMORY_SIZE_NV',0x9536) +GL_MAX_MESH_UNIFORM_BLOCKS_NV=_C('GL_MAX_MESH_UNIFORM_BLOCKS_NV',0x8E60) +GL_MAX_MESH_UNIFORM_COMPONENTS_NV=_C('GL_MAX_MESH_UNIFORM_COMPONENTS_NV',0x8E63) +GL_MAX_MESH_VIEWS_NV=_C('GL_MAX_MESH_VIEWS_NV',0x9557) +GL_MAX_MESH_WORK_GROUP_INVOCATIONS_NV=_C('GL_MAX_MESH_WORK_GROUP_INVOCATIONS_NV',0x95A2) +GL_MAX_MESH_WORK_GROUP_SIZE_NV=_C('GL_MAX_MESH_WORK_GROUP_SIZE_NV',0x953B) +GL_MAX_TASK_ATOMIC_COUNTERS_NV=_C('GL_MAX_TASK_ATOMIC_COUNTERS_NV',0x8E6D) +GL_MAX_TASK_ATOMIC_COUNTER_BUFFERS_NV=_C('GL_MAX_TASK_ATOMIC_COUNTER_BUFFERS_NV',0x8E6C) +GL_MAX_TASK_IMAGE_UNIFORMS_NV=_C('GL_MAX_TASK_IMAGE_UNIFORMS_NV',0x8E6A) +GL_MAX_TASK_OUTPUT_COUNT_NV=_C('GL_MAX_TASK_OUTPUT_COUNT_NV',0x953A) +GL_MAX_TASK_SHADER_STORAGE_BLOCKS_NV=_C('GL_MAX_TASK_SHADER_STORAGE_BLOCKS_NV',0x8E6E) +GL_MAX_TASK_TEXTURE_IMAGE_UNITS_NV=_C('GL_MAX_TASK_TEXTURE_IMAGE_UNITS_NV',0x8E69) +GL_MAX_TASK_TOTAL_MEMORY_SIZE_NV=_C('GL_MAX_TASK_TOTAL_MEMORY_SIZE_NV',0x9537) +GL_MAX_TASK_UNIFORM_BLOCKS_NV=_C('GL_MAX_TASK_UNIFORM_BLOCKS_NV',0x8E68) +GL_MAX_TASK_UNIFORM_COMPONENTS_NV=_C('GL_MAX_TASK_UNIFORM_COMPONENTS_NV',0x8E6B) +GL_MAX_TASK_WORK_GROUP_INVOCATIONS_NV=_C('GL_MAX_TASK_WORK_GROUP_INVOCATIONS_NV',0x95A3) +GL_MAX_TASK_WORK_GROUP_SIZE_NV=_C('GL_MAX_TASK_WORK_GROUP_SIZE_NV',0x953C) +GL_MESH_OUTPUT_PER_PRIMITIVE_GRANULARITY_NV=_C('GL_MESH_OUTPUT_PER_PRIMITIVE_GRANULARITY_NV',0x9543) +GL_MESH_OUTPUT_PER_VERTEX_GRANULARITY_NV=_C('GL_MESH_OUTPUT_PER_VERTEX_GRANULARITY_NV',0x92DF) +GL_MESH_OUTPUT_TYPE_NV=_C('GL_MESH_OUTPUT_TYPE_NV',0x957B) +GL_MESH_PRIMITIVES_OUT_NV=_C('GL_MESH_PRIMITIVES_OUT_NV',0x957A) +GL_MESH_SHADER_BIT_NV=_C('GL_MESH_SHADER_BIT_NV',0x00000040) +GL_MESH_SHADER_NV=_C('GL_MESH_SHADER_NV',0x9559) +GL_MESH_SUBROUTINE_NV=_C('GL_MESH_SUBROUTINE_NV',0x957C) +GL_MESH_SUBROUTINE_UNIFORM_NV=_C('GL_MESH_SUBROUTINE_UNIFORM_NV',0x957E) +GL_MESH_VERTICES_OUT_NV=_C('GL_MESH_VERTICES_OUT_NV',0x9579) +GL_MESH_WORK_GROUP_SIZE_NV=_C('GL_MESH_WORK_GROUP_SIZE_NV',0x953E) +GL_REFERENCED_BY_MESH_SHADER_NV=_C('GL_REFERENCED_BY_MESH_SHADER_NV',0x95A0) +GL_REFERENCED_BY_TASK_SHADER_NV=_C('GL_REFERENCED_BY_TASK_SHADER_NV',0x95A1) +GL_TASK_SHADER_BIT_NV=_C('GL_TASK_SHADER_BIT_NV',0x00000080) +GL_TASK_SHADER_NV=_C('GL_TASK_SHADER_NV',0x955A) +GL_TASK_SUBROUTINE_NV=_C('GL_TASK_SUBROUTINE_NV',0x957D) +GL_TASK_SUBROUTINE_UNIFORM_NV=_C('GL_TASK_SUBROUTINE_UNIFORM_NV',0x957F) +GL_TASK_WORK_GROUP_SIZE_NV=_C('GL_TASK_WORK_GROUP_SIZE_NV',0x953F) +GL_UNIFORM_BLOCK_REFERENCED_BY_MESH_SHADER_NV=_C('GL_UNIFORM_BLOCK_REFERENCED_BY_MESH_SHADER_NV',0x959C) +GL_UNIFORM_BLOCK_REFERENCED_BY_TASK_SHADER_NV=_C('GL_UNIFORM_BLOCK_REFERENCED_BY_TASK_SHADER_NV',0x959D) +@_f +@_p.types(None,_cs.GLintptr) +def glDrawMeshTasksIndirectNV(indirect):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint) +def glDrawMeshTasksNV(first,count):pass +@_f +@_p.types(None,_cs.GLintptr,_cs.GLintptr,_cs.GLsizei,_cs.GLsizei) +def glMultiDrawMeshTasksIndirectCountNV(indirect,drawcount,maxdrawcount,stride):pass +@_f +@_p.types(None,_cs.GLintptr,_cs.GLsizei,_cs.GLsizei) +def glMultiDrawMeshTasksIndirectNV(indirect,drawcount,stride):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/non_square_matrices.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/non_square_matrices.py new file mode 100644 index 00000000..4803d900 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/non_square_matrices.py @@ -0,0 +1,37 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_NV_non_square_matrices' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_NV_non_square_matrices',error_checker=_errors._error_checker) +GL_FLOAT_MAT2x3_NV=_C('GL_FLOAT_MAT2x3_NV',0x8B65) +GL_FLOAT_MAT2x4_NV=_C('GL_FLOAT_MAT2x4_NV',0x8B66) +GL_FLOAT_MAT3x2_NV=_C('GL_FLOAT_MAT3x2_NV',0x8B67) +GL_FLOAT_MAT3x4_NV=_C('GL_FLOAT_MAT3x4_NV',0x8B68) +GL_FLOAT_MAT4x2_NV=_C('GL_FLOAT_MAT4x2_NV',0x8B69) +GL_FLOAT_MAT4x3_NV=_C('GL_FLOAT_MAT4x3_NV',0x8B6A) +@_f +@_p.types(None,_cs.GLint,_cs.GLsizei,_cs.GLboolean,arrays.GLfloatArray) +def glUniformMatrix2x3fvNV(location,count,transpose,value):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLsizei,_cs.GLboolean,arrays.GLfloatArray) +def glUniformMatrix2x4fvNV(location,count,transpose,value):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLsizei,_cs.GLboolean,arrays.GLfloatArray) +def glUniformMatrix3x2fvNV(location,count,transpose,value):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLsizei,_cs.GLboolean,arrays.GLfloatArray) +def glUniformMatrix3x4fvNV(location,count,transpose,value):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLsizei,_cs.GLboolean,arrays.GLfloatArray) +def glUniformMatrix4x2fvNV(location,count,transpose,value):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLsizei,_cs.GLboolean,arrays.GLfloatArray) +def glUniformMatrix4x3fvNV(location,count,transpose,value):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/path_rendering.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/path_rendering.py new file mode 100644 index 00000000..7b842bee --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/path_rendering.py @@ -0,0 +1,426 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_NV_path_rendering' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_NV_path_rendering',error_checker=_errors._error_checker) +GL_2_BYTES_NV=_C('GL_2_BYTES_NV',0x1407) +GL_3_BYTES_NV=_C('GL_3_BYTES_NV',0x1408) +GL_4_BYTES_NV=_C('GL_4_BYTES_NV',0x1409) +GL_ACCUM_ADJACENT_PAIRS_NV=_C('GL_ACCUM_ADJACENT_PAIRS_NV',0x90AD) +GL_ADJACENT_PAIRS_NV=_C('GL_ADJACENT_PAIRS_NV',0x90AE) +GL_AFFINE_2D_NV=_C('GL_AFFINE_2D_NV',0x9092) +GL_AFFINE_3D_NV=_C('GL_AFFINE_3D_NV',0x9094) +GL_ARC_TO_NV=_C('GL_ARC_TO_NV',0xFE) +GL_BEVEL_NV=_C('GL_BEVEL_NV',0x90A6) +GL_BOLD_BIT_NV=_C('GL_BOLD_BIT_NV',0x01) +GL_BOUNDING_BOX_NV=_C('GL_BOUNDING_BOX_NV',0x908D) +GL_BOUNDING_BOX_OF_BOUNDING_BOXES_NV=_C('GL_BOUNDING_BOX_OF_BOUNDING_BOXES_NV',0x909C) +GL_CIRCULAR_CCW_ARC_TO_NV=_C('GL_CIRCULAR_CCW_ARC_TO_NV',0xF8) +GL_CIRCULAR_CW_ARC_TO_NV=_C('GL_CIRCULAR_CW_ARC_TO_NV',0xFA) +GL_CIRCULAR_TANGENT_ARC_TO_NV=_C('GL_CIRCULAR_TANGENT_ARC_TO_NV',0xFC) +GL_CLOSE_PATH_NV=_C('GL_CLOSE_PATH_NV',0x00) +GL_CONIC_CURVE_TO_NV=_C('GL_CONIC_CURVE_TO_NV',0x1A) +GL_CONSTANT_NV=_C('GL_CONSTANT_NV',0x8576) +GL_CONVEX_HULL_NV=_C('GL_CONVEX_HULL_NV',0x908B) +GL_COUNT_DOWN_NV=_C('GL_COUNT_DOWN_NV',0x9089) +GL_COUNT_UP_NV=_C('GL_COUNT_UP_NV',0x9088) +GL_CUBIC_CURVE_TO_NV=_C('GL_CUBIC_CURVE_TO_NV',0x0C) +GL_DUP_FIRST_CUBIC_CURVE_TO_NV=_C('GL_DUP_FIRST_CUBIC_CURVE_TO_NV',0xF2) +GL_DUP_LAST_CUBIC_CURVE_TO_NV=_C('GL_DUP_LAST_CUBIC_CURVE_TO_NV',0xF4) +GL_EYE_LINEAR_NV=_C('GL_EYE_LINEAR_NV',0x2400) +GL_FILE_NAME_NV=_C('GL_FILE_NAME_NV',0x9074) +GL_FIRST_TO_REST_NV=_C('GL_FIRST_TO_REST_NV',0x90AF) +GL_FONT_ASCENDER_BIT_NV=_C('GL_FONT_ASCENDER_BIT_NV',0x00200000) +GL_FONT_DESCENDER_BIT_NV=_C('GL_FONT_DESCENDER_BIT_NV',0x00400000) +GL_FONT_GLYPHS_AVAILABLE_NV=_C('GL_FONT_GLYPHS_AVAILABLE_NV',0x9368) +GL_FONT_HAS_KERNING_BIT_NV=_C('GL_FONT_HAS_KERNING_BIT_NV',0x10000000) +GL_FONT_HEIGHT_BIT_NV=_C('GL_FONT_HEIGHT_BIT_NV',0x00800000) +GL_FONT_MAX_ADVANCE_HEIGHT_BIT_NV=_C('GL_FONT_MAX_ADVANCE_HEIGHT_BIT_NV',0x02000000) +GL_FONT_MAX_ADVANCE_WIDTH_BIT_NV=_C('GL_FONT_MAX_ADVANCE_WIDTH_BIT_NV',0x01000000) +GL_FONT_NUM_GLYPH_INDICES_BIT_NV=_C('GL_FONT_NUM_GLYPH_INDICES_BIT_NV',0x20000000) +GL_FONT_TARGET_UNAVAILABLE_NV=_C('GL_FONT_TARGET_UNAVAILABLE_NV',0x9369) +GL_FONT_UNAVAILABLE_NV=_C('GL_FONT_UNAVAILABLE_NV',0x936A) +GL_FONT_UNDERLINE_POSITION_BIT_NV=_C('GL_FONT_UNDERLINE_POSITION_BIT_NV',0x04000000) +GL_FONT_UNDERLINE_THICKNESS_BIT_NV=_C('GL_FONT_UNDERLINE_THICKNESS_BIT_NV',0x08000000) +GL_FONT_UNINTELLIGIBLE_NV=_C('GL_FONT_UNINTELLIGIBLE_NV',0x936B) +GL_FONT_UNITS_PER_EM_BIT_NV=_C('GL_FONT_UNITS_PER_EM_BIT_NV',0x00100000) +GL_FONT_X_MAX_BOUNDS_BIT_NV=_C('GL_FONT_X_MAX_BOUNDS_BIT_NV',0x00040000) +GL_FONT_X_MIN_BOUNDS_BIT_NV=_C('GL_FONT_X_MIN_BOUNDS_BIT_NV',0x00010000) +GL_FONT_Y_MAX_BOUNDS_BIT_NV=_C('GL_FONT_Y_MAX_BOUNDS_BIT_NV',0x00080000) +GL_FONT_Y_MIN_BOUNDS_BIT_NV=_C('GL_FONT_Y_MIN_BOUNDS_BIT_NV',0x00020000) +GL_FRAGMENT_INPUT_NV=_C('GL_FRAGMENT_INPUT_NV',0x936D) +GL_GLYPH_HAS_KERNING_BIT_NV=_C('GL_GLYPH_HAS_KERNING_BIT_NV',0x100) +GL_GLYPH_HEIGHT_BIT_NV=_C('GL_GLYPH_HEIGHT_BIT_NV',0x02) +GL_GLYPH_HORIZONTAL_BEARING_ADVANCE_BIT_NV=_C('GL_GLYPH_HORIZONTAL_BEARING_ADVANCE_BIT_NV',0x10) +GL_GLYPH_HORIZONTAL_BEARING_X_BIT_NV=_C('GL_GLYPH_HORIZONTAL_BEARING_X_BIT_NV',0x04) +GL_GLYPH_HORIZONTAL_BEARING_Y_BIT_NV=_C('GL_GLYPH_HORIZONTAL_BEARING_Y_BIT_NV',0x08) +GL_GLYPH_VERTICAL_BEARING_ADVANCE_BIT_NV=_C('GL_GLYPH_VERTICAL_BEARING_ADVANCE_BIT_NV',0x80) +GL_GLYPH_VERTICAL_BEARING_X_BIT_NV=_C('GL_GLYPH_VERTICAL_BEARING_X_BIT_NV',0x20) +GL_GLYPH_VERTICAL_BEARING_Y_BIT_NV=_C('GL_GLYPH_VERTICAL_BEARING_Y_BIT_NV',0x40) +GL_GLYPH_WIDTH_BIT_NV=_C('GL_GLYPH_WIDTH_BIT_NV',0x01) +GL_HORIZONTAL_LINE_TO_NV=_C('GL_HORIZONTAL_LINE_TO_NV',0x06) +GL_ITALIC_BIT_NV=_C('GL_ITALIC_BIT_NV',0x02) +GL_LARGE_CCW_ARC_TO_NV=_C('GL_LARGE_CCW_ARC_TO_NV',0x16) +GL_LARGE_CW_ARC_TO_NV=_C('GL_LARGE_CW_ARC_TO_NV',0x18) +GL_LINE_TO_NV=_C('GL_LINE_TO_NV',0x04) +GL_MITER_REVERT_NV=_C('GL_MITER_REVERT_NV',0x90A7) +GL_MITER_TRUNCATE_NV=_C('GL_MITER_TRUNCATE_NV',0x90A8) +GL_MOVE_TO_CONTINUES_NV=_C('GL_MOVE_TO_CONTINUES_NV',0x90B6) +GL_MOVE_TO_NV=_C('GL_MOVE_TO_NV',0x02) +GL_MOVE_TO_RESETS_NV=_C('GL_MOVE_TO_RESETS_NV',0x90B5) +GL_OBJECT_LINEAR_NV=_C('GL_OBJECT_LINEAR_NV',0x2401) +GL_PATH_CLIENT_LENGTH_NV=_C('GL_PATH_CLIENT_LENGTH_NV',0x907F) +GL_PATH_COMMAND_COUNT_NV=_C('GL_PATH_COMMAND_COUNT_NV',0x909D) +GL_PATH_COMPUTED_LENGTH_NV=_C('GL_PATH_COMPUTED_LENGTH_NV',0x90A0) +GL_PATH_COORD_COUNT_NV=_C('GL_PATH_COORD_COUNT_NV',0x909E) +GL_PATH_COVER_DEPTH_FUNC_NV=_C('GL_PATH_COVER_DEPTH_FUNC_NV',0x90BF) +GL_PATH_DASH_ARRAY_COUNT_NV=_C('GL_PATH_DASH_ARRAY_COUNT_NV',0x909F) +GL_PATH_DASH_CAPS_NV=_C('GL_PATH_DASH_CAPS_NV',0x907B) +GL_PATH_DASH_OFFSET_NV=_C('GL_PATH_DASH_OFFSET_NV',0x907E) +GL_PATH_DASH_OFFSET_RESET_NV=_C('GL_PATH_DASH_OFFSET_RESET_NV',0x90B4) +GL_PATH_END_CAPS_NV=_C('GL_PATH_END_CAPS_NV',0x9076) +GL_PATH_ERROR_POSITION_NV=_C('GL_PATH_ERROR_POSITION_NV',0x90AB) +GL_PATH_FILL_BOUNDING_BOX_NV=_C('GL_PATH_FILL_BOUNDING_BOX_NV',0x90A1) +GL_PATH_FILL_COVER_MODE_NV=_C('GL_PATH_FILL_COVER_MODE_NV',0x9082) +GL_PATH_FILL_MASK_NV=_C('GL_PATH_FILL_MASK_NV',0x9081) +GL_PATH_FILL_MODE_NV=_C('GL_PATH_FILL_MODE_NV',0x9080) +GL_PATH_FOG_GEN_MODE_NV=_C('GL_PATH_FOG_GEN_MODE_NV',0x90AC) +GL_PATH_FORMAT_PS_NV=_C('GL_PATH_FORMAT_PS_NV',0x9071) +GL_PATH_FORMAT_SVG_NV=_C('GL_PATH_FORMAT_SVG_NV',0x9070) +GL_PATH_GEN_COEFF_NV=_C('GL_PATH_GEN_COEFF_NV',0x90B1) +GL_PATH_GEN_COLOR_FORMAT_NV=_C('GL_PATH_GEN_COLOR_FORMAT_NV',0x90B2) +GL_PATH_GEN_COMPONENTS_NV=_C('GL_PATH_GEN_COMPONENTS_NV',0x90B3) +GL_PATH_GEN_MODE_NV=_C('GL_PATH_GEN_MODE_NV',0x90B0) +GL_PATH_INITIAL_DASH_CAP_NV=_C('GL_PATH_INITIAL_DASH_CAP_NV',0x907C) +GL_PATH_INITIAL_END_CAP_NV=_C('GL_PATH_INITIAL_END_CAP_NV',0x9077) +GL_PATH_JOIN_STYLE_NV=_C('GL_PATH_JOIN_STYLE_NV',0x9079) +GL_PATH_MAX_MODELVIEW_STACK_DEPTH_NV=_C('GL_PATH_MAX_MODELVIEW_STACK_DEPTH_NV',0x0D36) +GL_PATH_MAX_PROJECTION_STACK_DEPTH_NV=_C('GL_PATH_MAX_PROJECTION_STACK_DEPTH_NV',0x0D38) +GL_PATH_MITER_LIMIT_NV=_C('GL_PATH_MITER_LIMIT_NV',0x907A) +GL_PATH_MODELVIEW_MATRIX_NV=_C('GL_PATH_MODELVIEW_MATRIX_NV',0x0BA6) +GL_PATH_MODELVIEW_NV=_C('GL_PATH_MODELVIEW_NV',0x1700) +GL_PATH_MODELVIEW_STACK_DEPTH_NV=_C('GL_PATH_MODELVIEW_STACK_DEPTH_NV',0x0BA3) +GL_PATH_OBJECT_BOUNDING_BOX_NV=_C('GL_PATH_OBJECT_BOUNDING_BOX_NV',0x908A) +GL_PATH_PROJECTION_MATRIX_NV=_C('GL_PATH_PROJECTION_MATRIX_NV',0x0BA7) +GL_PATH_PROJECTION_NV=_C('GL_PATH_PROJECTION_NV',0x1701) +GL_PATH_PROJECTION_STACK_DEPTH_NV=_C('GL_PATH_PROJECTION_STACK_DEPTH_NV',0x0BA4) +GL_PATH_STENCIL_DEPTH_OFFSET_FACTOR_NV=_C('GL_PATH_STENCIL_DEPTH_OFFSET_FACTOR_NV',0x90BD) +GL_PATH_STENCIL_DEPTH_OFFSET_UNITS_NV=_C('GL_PATH_STENCIL_DEPTH_OFFSET_UNITS_NV',0x90BE) +GL_PATH_STENCIL_FUNC_NV=_C('GL_PATH_STENCIL_FUNC_NV',0x90B7) +GL_PATH_STENCIL_REF_NV=_C('GL_PATH_STENCIL_REF_NV',0x90B8) +GL_PATH_STENCIL_VALUE_MASK_NV=_C('GL_PATH_STENCIL_VALUE_MASK_NV',0x90B9) +GL_PATH_STROKE_BOUNDING_BOX_NV=_C('GL_PATH_STROKE_BOUNDING_BOX_NV',0x90A2) +GL_PATH_STROKE_COVER_MODE_NV=_C('GL_PATH_STROKE_COVER_MODE_NV',0x9083) +GL_PATH_STROKE_MASK_NV=_C('GL_PATH_STROKE_MASK_NV',0x9084) +GL_PATH_STROKE_WIDTH_NV=_C('GL_PATH_STROKE_WIDTH_NV',0x9075) +GL_PATH_TERMINAL_DASH_CAP_NV=_C('GL_PATH_TERMINAL_DASH_CAP_NV',0x907D) +GL_PATH_TERMINAL_END_CAP_NV=_C('GL_PATH_TERMINAL_END_CAP_NV',0x9078) +GL_PATH_TRANSPOSE_MODELVIEW_MATRIX_NV=_C('GL_PATH_TRANSPOSE_MODELVIEW_MATRIX_NV',0x84E3) +GL_PATH_TRANSPOSE_PROJECTION_MATRIX_NV=_C('GL_PATH_TRANSPOSE_PROJECTION_MATRIX_NV',0x84E4) +GL_PRIMARY_COLOR=_C('GL_PRIMARY_COLOR',0x8577) +GL_PRIMARY_COLOR_NV=_C('GL_PRIMARY_COLOR_NV',0x852C) +GL_QUADRATIC_CURVE_TO_NV=_C('GL_QUADRATIC_CURVE_TO_NV',0x0A) +GL_RECT_NV=_C('GL_RECT_NV',0xF6) +GL_RELATIVE_ARC_TO_NV=_C('GL_RELATIVE_ARC_TO_NV',0xFF) +GL_RELATIVE_CONIC_CURVE_TO_NV=_C('GL_RELATIVE_CONIC_CURVE_TO_NV',0x1B) +GL_RELATIVE_CUBIC_CURVE_TO_NV=_C('GL_RELATIVE_CUBIC_CURVE_TO_NV',0x0D) +GL_RELATIVE_HORIZONTAL_LINE_TO_NV=_C('GL_RELATIVE_HORIZONTAL_LINE_TO_NV',0x07) +GL_RELATIVE_LARGE_CCW_ARC_TO_NV=_C('GL_RELATIVE_LARGE_CCW_ARC_TO_NV',0x17) +GL_RELATIVE_LARGE_CW_ARC_TO_NV=_C('GL_RELATIVE_LARGE_CW_ARC_TO_NV',0x19) +GL_RELATIVE_LINE_TO_NV=_C('GL_RELATIVE_LINE_TO_NV',0x05) +GL_RELATIVE_MOVE_TO_NV=_C('GL_RELATIVE_MOVE_TO_NV',0x03) +GL_RELATIVE_QUADRATIC_CURVE_TO_NV=_C('GL_RELATIVE_QUADRATIC_CURVE_TO_NV',0x0B) +GL_RELATIVE_RECT_NV=_C('GL_RELATIVE_RECT_NV',0xF7) +GL_RELATIVE_ROUNDED_RECT2_NV=_C('GL_RELATIVE_ROUNDED_RECT2_NV',0xEB) +GL_RELATIVE_ROUNDED_RECT4_NV=_C('GL_RELATIVE_ROUNDED_RECT4_NV',0xED) +GL_RELATIVE_ROUNDED_RECT8_NV=_C('GL_RELATIVE_ROUNDED_RECT8_NV',0xEF) +GL_RELATIVE_ROUNDED_RECT_NV=_C('GL_RELATIVE_ROUNDED_RECT_NV',0xE9) +GL_RELATIVE_SMALL_CCW_ARC_TO_NV=_C('GL_RELATIVE_SMALL_CCW_ARC_TO_NV',0x13) +GL_RELATIVE_SMALL_CW_ARC_TO_NV=_C('GL_RELATIVE_SMALL_CW_ARC_TO_NV',0x15) +GL_RELATIVE_SMOOTH_CUBIC_CURVE_TO_NV=_C('GL_RELATIVE_SMOOTH_CUBIC_CURVE_TO_NV',0x11) +GL_RELATIVE_SMOOTH_QUADRATIC_CURVE_TO_NV=_C('GL_RELATIVE_SMOOTH_QUADRATIC_CURVE_TO_NV',0x0F) +GL_RELATIVE_VERTICAL_LINE_TO_NV=_C('GL_RELATIVE_VERTICAL_LINE_TO_NV',0x09) +GL_RESTART_PATH_NV=_C('GL_RESTART_PATH_NV',0xF0) +GL_ROUNDED_RECT2_NV=_C('GL_ROUNDED_RECT2_NV',0xEA) +GL_ROUNDED_RECT4_NV=_C('GL_ROUNDED_RECT4_NV',0xEC) +GL_ROUNDED_RECT8_NV=_C('GL_ROUNDED_RECT8_NV',0xEE) +GL_ROUNDED_RECT_NV=_C('GL_ROUNDED_RECT_NV',0xE8) +GL_ROUND_NV=_C('GL_ROUND_NV',0x90A4) +GL_SECONDARY_COLOR_NV=_C('GL_SECONDARY_COLOR_NV',0x852D) +GL_SKIP_MISSING_GLYPH_NV=_C('GL_SKIP_MISSING_GLYPH_NV',0x90A9) +GL_SMALL_CCW_ARC_TO_NV=_C('GL_SMALL_CCW_ARC_TO_NV',0x12) +GL_SMALL_CW_ARC_TO_NV=_C('GL_SMALL_CW_ARC_TO_NV',0x14) +GL_SMOOTH_CUBIC_CURVE_TO_NV=_C('GL_SMOOTH_CUBIC_CURVE_TO_NV',0x10) +GL_SMOOTH_QUADRATIC_CURVE_TO_NV=_C('GL_SMOOTH_QUADRATIC_CURVE_TO_NV',0x0E) +GL_SQUARE_NV=_C('GL_SQUARE_NV',0x90A3) +GL_STANDARD_FONT_FORMAT_NV=_C('GL_STANDARD_FONT_FORMAT_NV',0x936C) +GL_STANDARD_FONT_NAME_NV=_C('GL_STANDARD_FONT_NAME_NV',0x9072) +GL_SYSTEM_FONT_NAME_NV=_C('GL_SYSTEM_FONT_NAME_NV',0x9073) +GL_TRANSLATE_2D_NV=_C('GL_TRANSLATE_2D_NV',0x9090) +GL_TRANSLATE_3D_NV=_C('GL_TRANSLATE_3D_NV',0x9091) +GL_TRANSLATE_X_NV=_C('GL_TRANSLATE_X_NV',0x908E) +GL_TRANSLATE_Y_NV=_C('GL_TRANSLATE_Y_NV',0x908F) +GL_TRANSPOSE_AFFINE_2D_NV=_C('GL_TRANSPOSE_AFFINE_2D_NV',0x9096) +GL_TRANSPOSE_AFFINE_3D_NV=_C('GL_TRANSPOSE_AFFINE_3D_NV',0x9098) +GL_TRIANGULAR_NV=_C('GL_TRIANGULAR_NV',0x90A5) +GL_USE_MISSING_GLYPH_NV=_C('GL_USE_MISSING_GLYPH_NV',0x90AA) +GL_UTF16_NV=_C('GL_UTF16_NV',0x909B) +GL_UTF8_NV=_C('GL_UTF8_NV',0x909A) +GL_VERTICAL_LINE_TO_NV=_C('GL_VERTICAL_LINE_TO_NV',0x08) +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint) +def glCopyPathNV(resultPath,srcPath):pass +@_f +@_p.types(None,_cs.GLsizei,_cs.GLenum,ctypes.c_void_p,_cs.GLuint,_cs.GLenum,_cs.GLenum,arrays.GLfloatArray) +def glCoverFillPathInstancedNV(numPaths,pathNameType,paths,pathBase,coverMode,transformType,transformValues):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum) +def glCoverFillPathNV(path,coverMode):pass +@_f +@_p.types(None,_cs.GLsizei,_cs.GLenum,ctypes.c_void_p,_cs.GLuint,_cs.GLenum,_cs.GLenum,arrays.GLfloatArray) +def glCoverStrokePathInstancedNV(numPaths,pathNameType,paths,pathBase,coverMode,transformType,transformValues):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum) +def glCoverStrokePathNV(path,coverMode):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizei) +def glDeletePathsNV(path,range):pass +@_f +@_p.types(_cs.GLuint,_cs.GLsizei) +def glGenPathsNV(range):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLfloatArray) +def glGetPathColorGenfvNV(color,pname,value):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLintArray) +def glGetPathColorGenivNV(color,pname,value):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLubyteArray) +def glGetPathCommandsNV(path,commands):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLfloatArray) +def glGetPathCoordsNV(path,coords):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLfloatArray) +def glGetPathDashArrayNV(path,dashArray):pass +@_f +@_p.types(_cs.GLfloat,_cs.GLuint,_cs.GLsizei,_cs.GLsizei) +def glGetPathLengthNV(path,startSegment,numSegments):pass +@_f +@_p.types(None,_cs.GLbitfield,_cs.GLuint,_cs.GLsizei,_cs.GLsizei,arrays.GLfloatArray) +def glGetPathMetricRangeNV(metricQueryMask,firstPathName,numPaths,stride,metrics):pass +@_f +@_p.types(None,_cs.GLbitfield,_cs.GLsizei,_cs.GLenum,ctypes.c_void_p,_cs.GLuint,_cs.GLsizei,arrays.GLfloatArray) +def glGetPathMetricsNV(metricQueryMask,numPaths,pathNameType,paths,pathBase,stride,metrics):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLfloatArray) +def glGetPathParameterfvNV(path,pname,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLintArray) +def glGetPathParameterivNV(path,pname,value):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizei,_cs.GLenum,ctypes.c_void_p,_cs.GLuint,_cs.GLfloat,_cs.GLfloat,_cs.GLenum,arrays.GLfloatArray) +def glGetPathSpacingNV(pathListMode,numPaths,pathNameType,paths,pathBase,advanceScale,kerningScale,transformType,returnedSpacing):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLfloatArray) +def glGetPathTexGenfvNV(texCoordSet,pname,value):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLintArray) +def glGetPathTexGenivNV(texCoordSet,pname,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLuint,_cs.GLsizei,arrays.GLuintArray,_cs.GLsizei,arrays.GLsizeiArray,arrays.GLfloatArray) +def glGetProgramResourcefvNV(program,programInterface,index,propCount,props,bufSize,length,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLuint,_cs.GLfloat) +def glInterpolatePathsNV(resultPath,pathA,pathB,weight):pass +@_f +@_p.types(_cs.GLboolean,_cs.GLuint) +def glIsPathNV(path):pass +@_f +@_p.types(_cs.GLboolean,_cs.GLuint,_cs.GLuint,_cs.GLfloat,_cs.GLfloat) +def glIsPointInFillPathNV(path,mask,x,y):pass +@_f +@_p.types(_cs.GLboolean,_cs.GLuint,_cs.GLfloat,_cs.GLfloat) +def glIsPointInStrokePathNV(path,x,y):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLdouble,_cs.GLdouble,_cs.GLdouble,_cs.GLdouble,_cs.GLdouble,_cs.GLdouble) +def glMatrixFrustumEXT(mode,left,right,bottom,top,zNear,zFar):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLfloatArray) +def glMatrixLoad3x2fNV(matrixMode,m):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLfloatArray) +def glMatrixLoad3x3fNV(matrixMode,m):pass +@_f +@_p.types(None,_cs.GLenum) +def glMatrixLoadIdentityEXT(mode):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLfloatArray) +def glMatrixLoadTranspose3x3fNV(matrixMode,m):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLdoubleArray) +def glMatrixLoadTransposedEXT(mode,m):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLfloatArray) +def glMatrixLoadTransposefEXT(mode,m):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLdoubleArray) +def glMatrixLoaddEXT(mode,m):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLfloatArray) +def glMatrixLoadfEXT(mode,m):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLfloatArray) +def glMatrixMult3x2fNV(matrixMode,m):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLfloatArray) +def glMatrixMult3x3fNV(matrixMode,m):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLfloatArray) +def glMatrixMultTranspose3x3fNV(matrixMode,m):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLdoubleArray) +def glMatrixMultTransposedEXT(mode,m):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLfloatArray) +def glMatrixMultTransposefEXT(mode,m):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLdoubleArray) +def glMatrixMultdEXT(mode,m):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLfloatArray) +def glMatrixMultfEXT(mode,m):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLdouble,_cs.GLdouble,_cs.GLdouble,_cs.GLdouble,_cs.GLdouble,_cs.GLdouble) +def glMatrixOrthoEXT(mode,left,right,bottom,top,zNear,zFar):pass +@_f +@_p.types(None,_cs.GLenum) +def glMatrixPopEXT(mode):pass +@_f +@_p.types(None,_cs.GLenum) +def glMatrixPushEXT(mode):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLdouble,_cs.GLdouble,_cs.GLdouble,_cs.GLdouble) +def glMatrixRotatedEXT(mode,angle,x,y,z):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat) +def glMatrixRotatefEXT(mode,angle,x,y,z):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLdouble,_cs.GLdouble,_cs.GLdouble) +def glMatrixScaledEXT(mode,x,y,z):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat) +def glMatrixScalefEXT(mode,x,y,z):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLdouble,_cs.GLdouble,_cs.GLdouble) +def glMatrixTranslatedEXT(mode,x,y,z):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat) +def glMatrixTranslatefEXT(mode,x,y,z):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLenum,arrays.GLfloatArray) +def glPathColorGenNV(color,genMode,colorFormat,coeffs):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizei,arrays.GLubyteArray,_cs.GLsizei,_cs.GLenum,ctypes.c_void_p) +def glPathCommandsNV(path,numCommands,commands,numCoords,coordType,coords):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizei,_cs.GLenum,ctypes.c_void_p) +def glPathCoordsNV(path,numCoords,coordType,coords):pass +@_f +@_p.types(None,_cs.GLenum) +def glPathCoverDepthFuncNV(func):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizei,arrays.GLfloatArray) +def glPathDashArrayNV(path,dashCount,dashArray):pass +@_f +@_p.types(None,_cs.GLenum) +def glPathFogGenNV(genMode):pass +@_f +@_p.types(_cs.GLenum,_cs.GLuint,_cs.GLenum,ctypes.c_void_p,_cs.GLbitfield,_cs.GLuint,_cs.GLsizei,_cs.GLuint,_cs.GLfloat) +def glPathGlyphIndexArrayNV(firstPathName,fontTarget,fontName,fontStyle,firstGlyphIndex,numGlyphs,pathParameterTemplate,emScale):pass +@_f +@_p.types(_cs.GLenum,_cs.GLenum,ctypes.c_void_p,_cs.GLbitfield,_cs.GLuint,_cs.GLfloat,_cs.GLuint) +def glPathGlyphIndexRangeNV(fontTarget,fontName,fontStyle,pathParameterTemplate,emScale,baseAndCount):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,ctypes.c_void_p,_cs.GLbitfield,_cs.GLuint,_cs.GLsizei,_cs.GLenum,_cs.GLuint,_cs.GLfloat) +def glPathGlyphRangeNV(firstPathName,fontTarget,fontName,fontStyle,firstGlyph,numGlyphs,handleMissingGlyphs,pathParameterTemplate,emScale):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,ctypes.c_void_p,_cs.GLbitfield,_cs.GLsizei,_cs.GLenum,ctypes.c_void_p,_cs.GLenum,_cs.GLuint,_cs.GLfloat) +def glPathGlyphsNV(firstPathName,fontTarget,fontName,fontStyle,numGlyphs,type,charcodes,handleMissingGlyphs,pathParameterTemplate,emScale):pass +@_f +@_p.types(_cs.GLenum,_cs.GLuint,_cs.GLenum,_cs.GLsizeiptr,ctypes.c_void_p,_cs.GLsizei,_cs.GLuint,_cs.GLsizei,_cs.GLuint,_cs.GLfloat) +def glPathMemoryGlyphIndexArrayNV(firstPathName,fontTarget,fontSize,fontData,faceIndex,firstGlyphIndex,numGlyphs,pathParameterTemplate,emScale):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLfloat) +def glPathParameterfNV(path,pname,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLfloatArray) +def glPathParameterfvNV(path,pname,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLint) +def glPathParameteriNV(path,pname,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLintArray) +def glPathParameterivNV(path,pname,value):pass +@_f +@_p.types(None,_cs.GLfloat,_cs.GLfloat) +def glPathStencilDepthOffsetNV(factor,units):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLint,_cs.GLuint) +def glPathStencilFuncNV(func,ref,mask):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLsizei,ctypes.c_void_p) +def glPathStringNV(path,format,length,pathString):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizei,_cs.GLsizei,_cs.GLsizei,arrays.GLubyteArray,_cs.GLsizei,_cs.GLenum,ctypes.c_void_p) +def glPathSubCommandsNV(path,commandStart,commandsToDelete,numCommands,commands,numCoords,coordType,coords):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizei,_cs.GLsizei,_cs.GLenum,ctypes.c_void_p) +def glPathSubCoordsNV(path,coordStart,numCoords,coordType,coords):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLint,arrays.GLfloatArray) +def glPathTexGenNV(texCoordSet,genMode,components,coeffs):pass +@_f +@_p.types(_cs.GLboolean,_cs.GLuint,_cs.GLsizei,_cs.GLsizei,_cs.GLfloat,arrays.GLfloatArray,arrays.GLfloatArray,arrays.GLfloatArray,arrays.GLfloatArray) +def glPointAlongPathNV(path,startSegment,numSegments,distance,x,y,tangentX,tangentY):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLenum,_cs.GLint,arrays.GLfloatArray) +def glProgramPathFragmentInputGenNV(program,location,genMode,components,coeffs):pass +@_f +@_p.types(None,_cs.GLsizei,_cs.GLenum,ctypes.c_void_p,_cs.GLuint,_cs.GLenum,_cs.GLuint,_cs.GLenum,arrays.GLfloatArray) +def glStencilFillPathInstancedNV(numPaths,pathNameType,paths,pathBase,fillMode,mask,transformType,transformValues):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLuint) +def glStencilFillPathNV(path,fillMode,mask):pass +@_f +@_p.types(None,_cs.GLsizei,_cs.GLenum,ctypes.c_void_p,_cs.GLuint,_cs.GLint,_cs.GLuint,_cs.GLenum,arrays.GLfloatArray) +def glStencilStrokePathInstancedNV(numPaths,pathNameType,paths,pathBase,reference,mask,transformType,transformValues):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLuint) +def glStencilStrokePathNV(path,reference,mask):pass +@_f +@_p.types(None,_cs.GLsizei,_cs.GLenum,ctypes.c_void_p,_cs.GLuint,_cs.GLenum,_cs.GLuint,_cs.GLenum,_cs.GLenum,arrays.GLfloatArray) +def glStencilThenCoverFillPathInstancedNV(numPaths,pathNameType,paths,pathBase,fillMode,mask,coverMode,transformType,transformValues):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLuint,_cs.GLenum) +def glStencilThenCoverFillPathNV(path,fillMode,mask,coverMode):pass +@_f +@_p.types(None,_cs.GLsizei,_cs.GLenum,ctypes.c_void_p,_cs.GLuint,_cs.GLint,_cs.GLuint,_cs.GLenum,_cs.GLenum,arrays.GLfloatArray) +def glStencilThenCoverStrokePathInstancedNV(numPaths,pathNameType,paths,pathBase,reference,mask,coverMode,transformType,transformValues):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLuint,_cs.GLenum) +def glStencilThenCoverStrokePathNV(path,reference,mask,coverMode):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLenum,arrays.GLfloatArray) +def glTransformPathNV(resultPath,srcPath,transformType,transformValues):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizei,arrays.GLuintArray,arrays.GLfloatArray) +def glWeightPathsNV(resultPath,numPaths,paths,weights):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/path_rendering_shared_edge.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/path_rendering_shared_edge.py new file mode 100644 index 00000000..5c9c246e --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/path_rendering_shared_edge.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_NV_path_rendering_shared_edge' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_NV_path_rendering_shared_edge',error_checker=_errors._error_checker) +GL_SHARED_EDGE_NV=_C('GL_SHARED_EDGE_NV',0xC0) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/pixel_buffer_object.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/pixel_buffer_object.py new file mode 100644 index 00000000..c379323f --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/pixel_buffer_object.py @@ -0,0 +1,18 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_NV_pixel_buffer_object' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_NV_pixel_buffer_object',error_checker=_errors._error_checker) +GL_PIXEL_PACK_BUFFER_BINDING_NV=_C('GL_PIXEL_PACK_BUFFER_BINDING_NV',0x88ED) +GL_PIXEL_PACK_BUFFER_NV=_C('GL_PIXEL_PACK_BUFFER_NV',0x88EB) +GL_PIXEL_UNPACK_BUFFER_BINDING_NV=_C('GL_PIXEL_UNPACK_BUFFER_BINDING_NV',0x88EF) +GL_PIXEL_UNPACK_BUFFER_NV=_C('GL_PIXEL_UNPACK_BUFFER_NV',0x88EC) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/polygon_mode.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/polygon_mode.py new file mode 100644 index 00000000..5397e3c3 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/polygon_mode.py @@ -0,0 +1,22 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_NV_polygon_mode' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_NV_polygon_mode',error_checker=_errors._error_checker) +GL_FILL_NV=_C('GL_FILL_NV',0x1B02) +GL_LINE_NV=_C('GL_LINE_NV',0x1B01) +GL_POINT_NV=_C('GL_POINT_NV',0x1B00) +GL_POLYGON_MODE_NV=_C('GL_POLYGON_MODE_NV',0x0B40) +GL_POLYGON_OFFSET_LINE_NV=_C('GL_POLYGON_OFFSET_LINE_NV',0x2A02) +GL_POLYGON_OFFSET_POINT_NV=_C('GL_POLYGON_OFFSET_POINT_NV',0x2A01) +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum) +def glPolygonModeNV(face,mode):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/read_buffer.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/read_buffer.py new file mode 100644 index 00000000..63834991 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/read_buffer.py @@ -0,0 +1,17 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_NV_read_buffer' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_NV_read_buffer',error_checker=_errors._error_checker) +GL_READ_BUFFER_NV=_C('GL_READ_BUFFER_NV',0x0C02) +@_f +@_p.types(None,_cs.GLenum) +def glReadBufferNV(mode):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/read_buffer_front.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/read_buffer_front.py new file mode 100644 index 00000000..cd9d498c --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/read_buffer_front.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_NV_read_buffer_front' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_NV_read_buffer_front',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/read_depth.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/read_depth.py new file mode 100644 index 00000000..30d3920e --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/read_depth.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_NV_read_depth' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_NV_read_depth',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/read_depth_stencil.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/read_depth_stencil.py new file mode 100644 index 00000000..d6ca7d3f --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/read_depth_stencil.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_NV_read_depth_stencil' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_NV_read_depth_stencil',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/read_stencil.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/read_stencil.py new file mode 100644 index 00000000..40391132 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/read_stencil.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_NV_read_stencil' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_NV_read_stencil',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/representative_fragment_test.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/representative_fragment_test.py new file mode 100644 index 00000000..1e9ec5a2 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/representative_fragment_test.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_NV_representative_fragment_test' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_NV_representative_fragment_test',error_checker=_errors._error_checker) +GL_REPRESENTATIVE_FRAGMENT_TEST_NV=_C('GL_REPRESENTATIVE_FRAGMENT_TEST_NV',0x937F) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/sRGB_formats.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/sRGB_formats.py new file mode 100644 index 00000000..df0ee3bd --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/sRGB_formats.py @@ -0,0 +1,24 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_NV_sRGB_formats' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_NV_sRGB_formats',error_checker=_errors._error_checker) +GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_NV=_C('GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_NV',0x8C4D) +GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_NV=_C('GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_NV',0x8C4E) +GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_NV=_C('GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_NV',0x8C4F) +GL_COMPRESSED_SRGB_S3TC_DXT1_NV=_C('GL_COMPRESSED_SRGB_S3TC_DXT1_NV',0x8C4C) +GL_ETC1_SRGB8_NV=_C('GL_ETC1_SRGB8_NV',0x88EE) +GL_SLUMINANCE8_ALPHA8_NV=_C('GL_SLUMINANCE8_ALPHA8_NV',0x8C45) +GL_SLUMINANCE8_NV=_C('GL_SLUMINANCE8_NV',0x8C47) +GL_SLUMINANCE_ALPHA_NV=_C('GL_SLUMINANCE_ALPHA_NV',0x8C44) +GL_SLUMINANCE_NV=_C('GL_SLUMINANCE_NV',0x8C46) +GL_SRGB8_NV=_C('GL_SRGB8_NV',0x8C41) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/sample_locations.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/sample_locations.py new file mode 100644 index 00000000..6a24195c --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/sample_locations.py @@ -0,0 +1,30 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_NV_sample_locations' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_NV_sample_locations',error_checker=_errors._error_checker) +GL_FRAMEBUFFER_PROGRAMMABLE_SAMPLE_LOCATIONS_NV=_C('GL_FRAMEBUFFER_PROGRAMMABLE_SAMPLE_LOCATIONS_NV',0x9342) +GL_FRAMEBUFFER_SAMPLE_LOCATION_PIXEL_GRID_NV=_C('GL_FRAMEBUFFER_SAMPLE_LOCATION_PIXEL_GRID_NV',0x9343) +GL_PROGRAMMABLE_SAMPLE_LOCATION_NV=_C('GL_PROGRAMMABLE_SAMPLE_LOCATION_NV',0x9341) +GL_PROGRAMMABLE_SAMPLE_LOCATION_TABLE_SIZE_NV=_C('GL_PROGRAMMABLE_SAMPLE_LOCATION_TABLE_SIZE_NV',0x9340) +GL_SAMPLE_LOCATION_NV=_C('GL_SAMPLE_LOCATION_NV',0x8E50) +GL_SAMPLE_LOCATION_PIXEL_GRID_HEIGHT_NV=_C('GL_SAMPLE_LOCATION_PIXEL_GRID_HEIGHT_NV',0x933F) +GL_SAMPLE_LOCATION_PIXEL_GRID_WIDTH_NV=_C('GL_SAMPLE_LOCATION_PIXEL_GRID_WIDTH_NV',0x933E) +GL_SAMPLE_LOCATION_SUBPIXEL_BITS_NV=_C('GL_SAMPLE_LOCATION_SUBPIXEL_BITS_NV',0x933D) +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,_cs.GLsizei,arrays.GLfloatArray) +def glFramebufferSampleLocationsfvNV(target,start,count,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLsizei,arrays.GLfloatArray) +def glNamedFramebufferSampleLocationsfvNV(framebuffer,start,count,v):pass +@_f +@_p.types(None,) +def glResolveDepthValuesNV():pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/sample_mask_override_coverage.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/sample_mask_override_coverage.py new file mode 100644 index 00000000..ac22a90d --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/sample_mask_override_coverage.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_NV_sample_mask_override_coverage' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_NV_sample_mask_override_coverage',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/scissor_exclusive.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/scissor_exclusive.py new file mode 100644 index 00000000..63fff69c --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/scissor_exclusive.py @@ -0,0 +1,21 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_NV_scissor_exclusive' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_NV_scissor_exclusive',error_checker=_errors._error_checker) +GL_SCISSOR_BOX_EXCLUSIVE_NV=_C('GL_SCISSOR_BOX_EXCLUSIVE_NV',0x9556) +GL_SCISSOR_TEST_EXCLUSIVE_NV=_C('GL_SCISSOR_TEST_EXCLUSIVE_NV',0x9555) +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizei,arrays.GLintArray) +def glScissorExclusiveArrayvNV(first,count,v):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLsizei) +def glScissorExclusiveNV(x,y,width,height):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/shader_atomic_fp16_vector.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/shader_atomic_fp16_vector.py new file mode 100644 index 00000000..1899906e --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/shader_atomic_fp16_vector.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_NV_shader_atomic_fp16_vector' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_NV_shader_atomic_fp16_vector',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/shader_noperspective_interpolation.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/shader_noperspective_interpolation.py new file mode 100644 index 00000000..5559e8c6 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/shader_noperspective_interpolation.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_NV_shader_noperspective_interpolation' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_NV_shader_noperspective_interpolation',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/shader_subgroup_partitioned.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/shader_subgroup_partitioned.py new file mode 100644 index 00000000..99b2e720 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/shader_subgroup_partitioned.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_NV_shader_subgroup_partitioned' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_NV_shader_subgroup_partitioned',error_checker=_errors._error_checker) +GL_SUBGROUP_FEATURE_PARTITIONED_BIT_NV=_C('GL_SUBGROUP_FEATURE_PARTITIONED_BIT_NV',0x00000100) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/shader_texture_footprint.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/shader_texture_footprint.py new file mode 100644 index 00000000..6daf36d0 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/shader_texture_footprint.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_NV_shader_texture_footprint' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_NV_shader_texture_footprint',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/shading_rate_image.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/shading_rate_image.py new file mode 100644 index 00000000..bf0b6f16 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/shading_rate_image.py @@ -0,0 +1,58 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_NV_shading_rate_image' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_NV_shading_rate_image',error_checker=_errors._error_checker) +GL_MAX_COARSE_FRAGMENT_SAMPLES_NV=_C('GL_MAX_COARSE_FRAGMENT_SAMPLES_NV',0x955F) +GL_SHADING_RATE_16_INVOCATIONS_PER_PIXEL_NV=_C('GL_SHADING_RATE_16_INVOCATIONS_PER_PIXEL_NV',0x956F) +GL_SHADING_RATE_1_INVOCATION_PER_1X2_PIXELS_NV=_C('GL_SHADING_RATE_1_INVOCATION_PER_1X2_PIXELS_NV',0x9566) +GL_SHADING_RATE_1_INVOCATION_PER_2X1_PIXELS_NV=_C('GL_SHADING_RATE_1_INVOCATION_PER_2X1_PIXELS_NV',0x9567) +GL_SHADING_RATE_1_INVOCATION_PER_2X2_PIXELS_NV=_C('GL_SHADING_RATE_1_INVOCATION_PER_2X2_PIXELS_NV',0x9568) +GL_SHADING_RATE_1_INVOCATION_PER_2X4_PIXELS_NV=_C('GL_SHADING_RATE_1_INVOCATION_PER_2X4_PIXELS_NV',0x9569) +GL_SHADING_RATE_1_INVOCATION_PER_4X2_PIXELS_NV=_C('GL_SHADING_RATE_1_INVOCATION_PER_4X2_PIXELS_NV',0x956A) +GL_SHADING_RATE_1_INVOCATION_PER_4X4_PIXELS_NV=_C('GL_SHADING_RATE_1_INVOCATION_PER_4X4_PIXELS_NV',0x956B) +GL_SHADING_RATE_1_INVOCATION_PER_PIXEL_NV=_C('GL_SHADING_RATE_1_INVOCATION_PER_PIXEL_NV',0x9565) +GL_SHADING_RATE_2_INVOCATIONS_PER_PIXEL_NV=_C('GL_SHADING_RATE_2_INVOCATIONS_PER_PIXEL_NV',0x956C) +GL_SHADING_RATE_4_INVOCATIONS_PER_PIXEL_NV=_C('GL_SHADING_RATE_4_INVOCATIONS_PER_PIXEL_NV',0x956D) +GL_SHADING_RATE_8_INVOCATIONS_PER_PIXEL_NV=_C('GL_SHADING_RATE_8_INVOCATIONS_PER_PIXEL_NV',0x956E) +GL_SHADING_RATE_IMAGE_BINDING_NV=_C('GL_SHADING_RATE_IMAGE_BINDING_NV',0x955B) +GL_SHADING_RATE_IMAGE_NV=_C('GL_SHADING_RATE_IMAGE_NV',0x9563) +GL_SHADING_RATE_IMAGE_PALETTE_SIZE_NV=_C('GL_SHADING_RATE_IMAGE_PALETTE_SIZE_NV',0x955E) +GL_SHADING_RATE_IMAGE_TEXEL_HEIGHT_NV=_C('GL_SHADING_RATE_IMAGE_TEXEL_HEIGHT_NV',0x955D) +GL_SHADING_RATE_IMAGE_TEXEL_WIDTH_NV=_C('GL_SHADING_RATE_IMAGE_TEXEL_WIDTH_NV',0x955C) +GL_SHADING_RATE_NO_INVOCATIONS_NV=_C('GL_SHADING_RATE_NO_INVOCATIONS_NV',0x9564) +GL_SHADING_RATE_SAMPLE_ORDER_DEFAULT_NV=_C('GL_SHADING_RATE_SAMPLE_ORDER_DEFAULT_NV',0x95AE) +GL_SHADING_RATE_SAMPLE_ORDER_PIXEL_MAJOR_NV=_C('GL_SHADING_RATE_SAMPLE_ORDER_PIXEL_MAJOR_NV',0x95AF) +GL_SHADING_RATE_SAMPLE_ORDER_SAMPLE_MAJOR_NV=_C('GL_SHADING_RATE_SAMPLE_ORDER_SAMPLE_MAJOR_NV',0x95B0) +@_f +@_p.types(None,_cs.GLuint) +def glBindShadingRateImageNV(texture):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,arrays.GLuintArray) +def glGetShadingRateImagePaletteNV(viewport,entry,rate):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,_cs.GLuint,arrays.GLintArray) +def glGetShadingRateSampleLocationivNV(rate,samples,index,location):pass +@_f +@_p.types(None,_cs.GLboolean) +def glShadingRateImageBarrierNV(synchronize):pass +@_f +@_p.types(None,_cs.GLboolean) +def glShadingRateImageBarrierNV(synchronize):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLsizei,arrays.GLuintArray) +def glShadingRateImagePaletteNV(viewport,first,count,rates):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,arrays.GLintArray) +def glShadingRateSampleOrderCustomNV(rate,samples,locations):pass +@_f +@_p.types(None,_cs.GLenum) +def glShadingRateSampleOrderNV(order):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/shadow_samplers_array.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/shadow_samplers_array.py new file mode 100644 index 00000000..f3d56f13 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/shadow_samplers_array.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_NV_shadow_samplers_array' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_NV_shadow_samplers_array',error_checker=_errors._error_checker) +GL_SAMPLER_2D_ARRAY_SHADOW_NV=_C('GL_SAMPLER_2D_ARRAY_SHADOW_NV',0x8DC4) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/shadow_samplers_cube.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/shadow_samplers_cube.py new file mode 100644 index 00000000..d86829ea --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/shadow_samplers_cube.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_NV_shadow_samplers_cube' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_NV_shadow_samplers_cube',error_checker=_errors._error_checker) +GL_SAMPLER_CUBE_SHADOW_NV=_C('GL_SAMPLER_CUBE_SHADOW_NV',0x8DC5) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/stereo_view_rendering.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/stereo_view_rendering.py new file mode 100644 index 00000000..d19e2a55 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/stereo_view_rendering.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_NV_stereo_view_rendering' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_NV_stereo_view_rendering',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/texture_border_clamp.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/texture_border_clamp.py new file mode 100644 index 00000000..3f3c5029 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/texture_border_clamp.py @@ -0,0 +1,16 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_NV_texture_border_clamp' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_NV_texture_border_clamp',error_checker=_errors._error_checker) +GL_CLAMP_TO_BORDER_NV=_C('GL_CLAMP_TO_BORDER_NV',0x812D) +GL_TEXTURE_BORDER_COLOR_NV=_C('GL_TEXTURE_BORDER_COLOR_NV',0x1004) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/texture_compression_s3tc_update.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/texture_compression_s3tc_update.py new file mode 100644 index 00000000..e90dd590 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/texture_compression_s3tc_update.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_NV_texture_compression_s3tc_update' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_NV_texture_compression_s3tc_update',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/texture_npot_2D_mipmap.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/texture_npot_2D_mipmap.py new file mode 100644 index 00000000..93921bb4 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/texture_npot_2D_mipmap.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_NV_texture_npot_2D_mipmap' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_NV_texture_npot_2D_mipmap',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/viewport_array.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/viewport_array.py new file mode 100644 index 00000000..f29fbda5 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/viewport_array.py @@ -0,0 +1,57 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_NV_viewport_array' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_NV_viewport_array',error_checker=_errors._error_checker) +GL_DEPTH_RANGE=_C('GL_DEPTH_RANGE',0x0B70) +GL_MAX_VIEWPORTS_NV=_C('GL_MAX_VIEWPORTS_NV',0x825B) +GL_SCISSOR_BOX=_C('GL_SCISSOR_BOX',0x0C10) +GL_SCISSOR_TEST=_C('GL_SCISSOR_TEST',0x0C11) +GL_VIEWPORT=_C('GL_VIEWPORT',0x0BA2) +GL_VIEWPORT_BOUNDS_RANGE_NV=_C('GL_VIEWPORT_BOUNDS_RANGE_NV',0x825D) +GL_VIEWPORT_INDEX_PROVOKING_VERTEX_NV=_C('GL_VIEWPORT_INDEX_PROVOKING_VERTEX_NV',0x825F) +GL_VIEWPORT_SUBPIXEL_BITS_NV=_C('GL_VIEWPORT_SUBPIXEL_BITS_NV',0x825C) +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizei,arrays.GLfloatArray) +def glDepthRangeArrayfvNV(first,count,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLfloat,_cs.GLfloat) +def glDepthRangeIndexedfNV(index,n,f):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint) +def glDisableiNV(target,index):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint) +def glEnableiNV(target,index):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,arrays.GLfloatArray) +def glGetFloati_vNV(target,index,data):pass +@_f +@_p.types(_cs.GLboolean,_cs.GLenum,_cs.GLuint) +def glIsEnablediNV(target,index):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizei,arrays.GLintArray) +def glScissorArrayvNV(first,count,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLsizei) +def glScissorIndexedNV(index,left,bottom,width,height):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLintArray) +def glScissorIndexedvNV(index,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizei,arrays.GLfloatArray) +def glViewportArrayvNV(first,count,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat) +def glViewportIndexedfNV(index,x,y,w,h):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLfloatArray) +def glViewportIndexedfvNV(index,v):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/viewport_array2.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/viewport_array2.py new file mode 100644 index 00000000..3ec4aecf --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/viewport_array2.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_NV_viewport_array2' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_NV_viewport_array2',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/viewport_swizzle.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/viewport_swizzle.py new file mode 100644 index 00000000..c74fa876 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NV/viewport_swizzle.py @@ -0,0 +1,28 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_NV_viewport_swizzle' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_NV_viewport_swizzle',error_checker=_errors._error_checker) +GL_VIEWPORT_SWIZZLE_NEGATIVE_W_NV=_C('GL_VIEWPORT_SWIZZLE_NEGATIVE_W_NV',0x9357) +GL_VIEWPORT_SWIZZLE_NEGATIVE_X_NV=_C('GL_VIEWPORT_SWIZZLE_NEGATIVE_X_NV',0x9351) +GL_VIEWPORT_SWIZZLE_NEGATIVE_Y_NV=_C('GL_VIEWPORT_SWIZZLE_NEGATIVE_Y_NV',0x9353) +GL_VIEWPORT_SWIZZLE_NEGATIVE_Z_NV=_C('GL_VIEWPORT_SWIZZLE_NEGATIVE_Z_NV',0x9355) +GL_VIEWPORT_SWIZZLE_POSITIVE_W_NV=_C('GL_VIEWPORT_SWIZZLE_POSITIVE_W_NV',0x9356) +GL_VIEWPORT_SWIZZLE_POSITIVE_X_NV=_C('GL_VIEWPORT_SWIZZLE_POSITIVE_X_NV',0x9350) +GL_VIEWPORT_SWIZZLE_POSITIVE_Y_NV=_C('GL_VIEWPORT_SWIZZLE_POSITIVE_Y_NV',0x9352) +GL_VIEWPORT_SWIZZLE_POSITIVE_Z_NV=_C('GL_VIEWPORT_SWIZZLE_POSITIVE_Z_NV',0x9354) +GL_VIEWPORT_SWIZZLE_W_NV=_C('GL_VIEWPORT_SWIZZLE_W_NV',0x935B) +GL_VIEWPORT_SWIZZLE_X_NV=_C('GL_VIEWPORT_SWIZZLE_X_NV',0x9358) +GL_VIEWPORT_SWIZZLE_Y_NV=_C('GL_VIEWPORT_SWIZZLE_Y_NV',0x9359) +GL_VIEWPORT_SWIZZLE_Z_NV=_C('GL_VIEWPORT_SWIZZLE_Z_NV',0x935A) +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLenum,_cs.GLenum,_cs.GLenum) +def glViewportSwizzleNV(index,swizzlex,swizzley,swizzlez,swizzlew):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NVX/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NVX/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NVX/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NVX/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NVX/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..d52711bd Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NVX/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NVX/__pycache__/blend_equation_advanced_multi_draw_buffers.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NVX/__pycache__/blend_equation_advanced_multi_draw_buffers.cpython-312.pyc new file mode 100644 index 00000000..17c5da13 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NVX/__pycache__/blend_equation_advanced_multi_draw_buffers.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NVX/blend_equation_advanced_multi_draw_buffers.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NVX/blend_equation_advanced_multi_draw_buffers.py new file mode 100644 index 00000000..20c189f5 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/NVX/blend_equation_advanced_multi_draw_buffers.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_NVX_blend_equation_advanced_multi_draw_buffers' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_NVX_blend_equation_advanced_multi_draw_buffers',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/EGL_image.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/EGL_image.py new file mode 100644 index 00000000..96f4f087 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/EGL_image.py @@ -0,0 +1,20 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_OES_EGL_image' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_OES_EGL_image',error_checker=_errors._error_checker) + +@_f +@_p.types(None,_cs.GLenum,_cs.GLeglImageOES) +def glEGLImageTargetRenderbufferStorageOES(target,image):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLeglImageOES) +def glEGLImageTargetTexture2DOES(target,image):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/EGL_image_external.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/EGL_image_external.py new file mode 100644 index 00000000..dba6410a --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/EGL_image_external.py @@ -0,0 +1,18 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_OES_EGL_image_external' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_OES_EGL_image_external',error_checker=_errors._error_checker) +GL_REQUIRED_TEXTURE_IMAGE_UNITS_OES=_C('GL_REQUIRED_TEXTURE_IMAGE_UNITS_OES',0x8D68) +GL_SAMPLER_EXTERNAL_OES=_C('GL_SAMPLER_EXTERNAL_OES',0x8D66) +GL_TEXTURE_BINDING_EXTERNAL_OES=_C('GL_TEXTURE_BINDING_EXTERNAL_OES',0x8D67) +GL_TEXTURE_EXTERNAL_OES=_C('GL_TEXTURE_EXTERNAL_OES',0x8D65) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/EGL_image_external_essl3.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/EGL_image_external_essl3.py new file mode 100644 index 00000000..f058b957 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/EGL_image_external_essl3.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_OES_EGL_image_external_essl3' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_OES_EGL_image_external_essl3',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/EGL_image.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/EGL_image.cpython-312.pyc new file mode 100644 index 00000000..4c638c1f Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/EGL_image.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/EGL_image_external.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/EGL_image_external.cpython-312.pyc new file mode 100644 index 00000000..56a8b29b Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/EGL_image_external.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/EGL_image_external_essl3.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/EGL_image_external_essl3.cpython-312.pyc new file mode 100644 index 00000000..c8ef28ff Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/EGL_image_external_essl3.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..205249fc Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/compressed_ETC1_RGB8_sub_texture.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/compressed_ETC1_RGB8_sub_texture.cpython-312.pyc new file mode 100644 index 00000000..abf04e45 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/compressed_ETC1_RGB8_sub_texture.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/compressed_ETC1_RGB8_texture.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/compressed_ETC1_RGB8_texture.cpython-312.pyc new file mode 100644 index 00000000..4b40dfc5 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/compressed_ETC1_RGB8_texture.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/compressed_paletted_texture.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/compressed_paletted_texture.cpython-312.pyc new file mode 100644 index 00000000..4f729a95 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/compressed_paletted_texture.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/copy_image.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/copy_image.cpython-312.pyc new file mode 100644 index 00000000..f76e71db Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/copy_image.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/depth24.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/depth24.cpython-312.pyc new file mode 100644 index 00000000..6cdca800 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/depth24.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/depth32.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/depth32.cpython-312.pyc new file mode 100644 index 00000000..d143b96e Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/depth32.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/depth_texture.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/depth_texture.cpython-312.pyc new file mode 100644 index 00000000..71dd189c Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/depth_texture.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/draw_buffers_indexed.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/draw_buffers_indexed.cpython-312.pyc new file mode 100644 index 00000000..994183fe Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/draw_buffers_indexed.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/draw_elements_base_vertex.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/draw_elements_base_vertex.cpython-312.pyc new file mode 100644 index 00000000..d1e036b0 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/draw_elements_base_vertex.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/element_index_uint.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/element_index_uint.cpython-312.pyc new file mode 100644 index 00000000..c5540a98 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/element_index_uint.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/fbo_render_mipmap.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/fbo_render_mipmap.cpython-312.pyc new file mode 100644 index 00000000..6b9bb8b6 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/fbo_render_mipmap.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/fragment_precision_high.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/fragment_precision_high.cpython-312.pyc new file mode 100644 index 00000000..103cc3d8 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/fragment_precision_high.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/geometry_point_size.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/geometry_point_size.cpython-312.pyc new file mode 100644 index 00000000..0dd7b167 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/geometry_point_size.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/geometry_shader.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/geometry_shader.cpython-312.pyc new file mode 100644 index 00000000..94ced15f Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/geometry_shader.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/get_program_binary.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/get_program_binary.cpython-312.pyc new file mode 100644 index 00000000..b509532b Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/get_program_binary.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/gpu_shader5.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/gpu_shader5.cpython-312.pyc new file mode 100644 index 00000000..7df4c002 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/gpu_shader5.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/mapbuffer.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/mapbuffer.cpython-312.pyc new file mode 100644 index 00000000..a4e9a852 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/mapbuffer.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/packed_depth_stencil.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/packed_depth_stencil.cpython-312.pyc new file mode 100644 index 00000000..ac9fb421 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/packed_depth_stencil.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/primitive_bounding_box.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/primitive_bounding_box.cpython-312.pyc new file mode 100644 index 00000000..2b11fc70 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/primitive_bounding_box.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/required_internalformat.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/required_internalformat.cpython-312.pyc new file mode 100644 index 00000000..fb230898 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/required_internalformat.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/rgb8_rgba8.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/rgb8_rgba8.cpython-312.pyc new file mode 100644 index 00000000..78f54436 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/rgb8_rgba8.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/sample_shading.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/sample_shading.cpython-312.pyc new file mode 100644 index 00000000..992b7f63 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/sample_shading.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/sample_variables.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/sample_variables.cpython-312.pyc new file mode 100644 index 00000000..0f060ccd Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/sample_variables.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/shader_image_atomic.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/shader_image_atomic.cpython-312.pyc new file mode 100644 index 00000000..1661e03c Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/shader_image_atomic.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/shader_io_blocks.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/shader_io_blocks.cpython-312.pyc new file mode 100644 index 00000000..39c32b40 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/shader_io_blocks.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/shader_multisample_interpolation.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/shader_multisample_interpolation.cpython-312.pyc new file mode 100644 index 00000000..0d457011 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/shader_multisample_interpolation.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/standard_derivatives.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/standard_derivatives.cpython-312.pyc new file mode 100644 index 00000000..7016184a Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/standard_derivatives.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/stencil1.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/stencil1.cpython-312.pyc new file mode 100644 index 00000000..42cb8152 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/stencil1.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/stencil4.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/stencil4.cpython-312.pyc new file mode 100644 index 00000000..fffdb4bb Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/stencil4.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/surfaceless_context.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/surfaceless_context.cpython-312.pyc new file mode 100644 index 00000000..acbfb3fb Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/surfaceless_context.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/tessellation_point_size.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/tessellation_point_size.cpython-312.pyc new file mode 100644 index 00000000..71ba7285 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/tessellation_point_size.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/tessellation_shader.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/tessellation_shader.cpython-312.pyc new file mode 100644 index 00000000..06a35979 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/tessellation_shader.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/texture_3D.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/texture_3D.cpython-312.pyc new file mode 100644 index 00000000..1058074c Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/texture_3D.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/texture_border_clamp.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/texture_border_clamp.cpython-312.pyc new file mode 100644 index 00000000..cd888cd7 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/texture_border_clamp.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/texture_buffer.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/texture_buffer.cpython-312.pyc new file mode 100644 index 00000000..61d3c9bb Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/texture_buffer.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/texture_compression_astc.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/texture_compression_astc.cpython-312.pyc new file mode 100644 index 00000000..6493beef Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/texture_compression_astc.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/texture_cube_map_array.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/texture_cube_map_array.cpython-312.pyc new file mode 100644 index 00000000..72958969 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/texture_cube_map_array.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/texture_float.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/texture_float.cpython-312.pyc new file mode 100644 index 00000000..1377fa1d Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/texture_float.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/texture_float_linear.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/texture_float_linear.cpython-312.pyc new file mode 100644 index 00000000..797fe08d Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/texture_float_linear.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/texture_half_float.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/texture_half_float.cpython-312.pyc new file mode 100644 index 00000000..55b55a4c Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/texture_half_float.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/texture_half_float_linear.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/texture_half_float_linear.cpython-312.pyc new file mode 100644 index 00000000..9ea63d9b Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/texture_half_float_linear.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/texture_npot.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/texture_npot.cpython-312.pyc new file mode 100644 index 00000000..ea00b15b Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/texture_npot.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/texture_stencil8.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/texture_stencil8.cpython-312.pyc new file mode 100644 index 00000000..23af8546 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/texture_stencil8.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/texture_storage_multisample_2d_array.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/texture_storage_multisample_2d_array.cpython-312.pyc new file mode 100644 index 00000000..d65f9149 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/texture_storage_multisample_2d_array.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/texture_view.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/texture_view.cpython-312.pyc new file mode 100644 index 00000000..717f61e4 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/texture_view.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/vertex_array_object.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/vertex_array_object.cpython-312.pyc new file mode 100644 index 00000000..aa488ded Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/vertex_array_object.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/vertex_half_float.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/vertex_half_float.cpython-312.pyc new file mode 100644 index 00000000..a6cad09f Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/vertex_half_float.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/vertex_type_10_10_10_2.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/vertex_type_10_10_10_2.cpython-312.pyc new file mode 100644 index 00000000..298de966 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/vertex_type_10_10_10_2.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/viewport_array.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/viewport_array.cpython-312.pyc new file mode 100644 index 00000000..eff5c0c1 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/__pycache__/viewport_array.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/compressed_ETC1_RGB8_sub_texture.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/compressed_ETC1_RGB8_sub_texture.py new file mode 100644 index 00000000..296af82d --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/compressed_ETC1_RGB8_sub_texture.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_OES_compressed_ETC1_RGB8_sub_texture' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_OES_compressed_ETC1_RGB8_sub_texture',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/compressed_ETC1_RGB8_texture.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/compressed_ETC1_RGB8_texture.py new file mode 100644 index 00000000..cd27a31f --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/compressed_ETC1_RGB8_texture.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_OES_compressed_ETC1_RGB8_texture' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_OES_compressed_ETC1_RGB8_texture',error_checker=_errors._error_checker) +GL_ETC1_RGB8_OES=_C('GL_ETC1_RGB8_OES',0x8D64) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/compressed_paletted_texture.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/compressed_paletted_texture.py new file mode 100644 index 00000000..dae31402 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/compressed_paletted_texture.py @@ -0,0 +1,24 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_OES_compressed_paletted_texture' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_OES_compressed_paletted_texture',error_checker=_errors._error_checker) +GL_PALETTE4_R5_G6_B5_OES=_C('GL_PALETTE4_R5_G6_B5_OES',0x8B92) +GL_PALETTE4_RGB5_A1_OES=_C('GL_PALETTE4_RGB5_A1_OES',0x8B94) +GL_PALETTE4_RGB8_OES=_C('GL_PALETTE4_RGB8_OES',0x8B90) +GL_PALETTE4_RGBA4_OES=_C('GL_PALETTE4_RGBA4_OES',0x8B93) +GL_PALETTE4_RGBA8_OES=_C('GL_PALETTE4_RGBA8_OES',0x8B91) +GL_PALETTE8_R5_G6_B5_OES=_C('GL_PALETTE8_R5_G6_B5_OES',0x8B97) +GL_PALETTE8_RGB5_A1_OES=_C('GL_PALETTE8_RGB5_A1_OES',0x8B99) +GL_PALETTE8_RGB8_OES=_C('GL_PALETTE8_RGB8_OES',0x8B95) +GL_PALETTE8_RGBA4_OES=_C('GL_PALETTE8_RGBA4_OES',0x8B98) +GL_PALETTE8_RGBA8_OES=_C('GL_PALETTE8_RGBA8_OES',0x8B96) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/copy_image.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/copy_image.py new file mode 100644 index 00000000..02c043f3 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/copy_image.py @@ -0,0 +1,17 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_OES_copy_image' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_OES_copy_image',error_checker=_errors._error_checker) + +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLuint,_cs.GLenum,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLsizei,_cs.GLsizei) +def glCopyImageSubDataOES(srcName,srcTarget,srcLevel,srcX,srcY,srcZ,dstName,dstTarget,dstLevel,dstX,dstY,dstZ,srcWidth,srcHeight,srcDepth):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/depth24.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/depth24.py new file mode 100644 index 00000000..fe7b4fe2 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/depth24.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_OES_depth24' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_OES_depth24',error_checker=_errors._error_checker) +GL_DEPTH_COMPONENT24_OES=_C('GL_DEPTH_COMPONENT24_OES',0x81A6) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/depth32.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/depth32.py new file mode 100644 index 00000000..e063fc16 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/depth32.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_OES_depth32' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_OES_depth32',error_checker=_errors._error_checker) +GL_DEPTH_COMPONENT32_OES=_C('GL_DEPTH_COMPONENT32_OES',0x81A7) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/depth_texture.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/depth_texture.py new file mode 100644 index 00000000..7a74d301 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/depth_texture.py @@ -0,0 +1,17 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_OES_depth_texture' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_OES_depth_texture',error_checker=_errors._error_checker) +GL_DEPTH_COMPONENT=_C('GL_DEPTH_COMPONENT',0x1902) +GL_UNSIGNED_INT=_C('GL_UNSIGNED_INT',0x1405) +GL_UNSIGNED_SHORT=_C('GL_UNSIGNED_SHORT',0x1403) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/draw_buffers_indexed.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/draw_buffers_indexed.py new file mode 100644 index 00000000..3ef7e6f2 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/draw_buffers_indexed.py @@ -0,0 +1,65 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_OES_draw_buffers_indexed' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_OES_draw_buffers_indexed',error_checker=_errors._error_checker) +GL_BLEND=_C('GL_BLEND',0x0BE2) +GL_BLEND_DST_ALPHA=_C('GL_BLEND_DST_ALPHA',0x80CA) +GL_BLEND_DST_RGB=_C('GL_BLEND_DST_RGB',0x80C8) +GL_BLEND_EQUATION_ALPHA=_C('GL_BLEND_EQUATION_ALPHA',0x883D) +GL_BLEND_EQUATION_RGB=_C('GL_BLEND_EQUATION_RGB',0x8009) +GL_BLEND_SRC_ALPHA=_C('GL_BLEND_SRC_ALPHA',0x80CB) +GL_BLEND_SRC_RGB=_C('GL_BLEND_SRC_RGB',0x80C9) +GL_COLOR_WRITEMASK=_C('GL_COLOR_WRITEMASK',0x0C23) +GL_CONSTANT_ALPHA=_C('GL_CONSTANT_ALPHA',0x8003) +GL_CONSTANT_COLOR=_C('GL_CONSTANT_COLOR',0x8001) +GL_DST_ALPHA=_C('GL_DST_ALPHA',0x0304) +GL_DST_COLOR=_C('GL_DST_COLOR',0x0306) +GL_FUNC_ADD=_C('GL_FUNC_ADD',0x8006) +GL_FUNC_REVERSE_SUBTRACT=_C('GL_FUNC_REVERSE_SUBTRACT',0x800B) +GL_FUNC_SUBTRACT=_C('GL_FUNC_SUBTRACT',0x800A) +GL_MAX=_C('GL_MAX',0x8008) +GL_MIN=_C('GL_MIN',0x8007) +GL_ONE=_C('GL_ONE',1) +GL_ONE_MINUS_CONSTANT_ALPHA=_C('GL_ONE_MINUS_CONSTANT_ALPHA',0x8004) +GL_ONE_MINUS_CONSTANT_COLOR=_C('GL_ONE_MINUS_CONSTANT_COLOR',0x8002) +GL_ONE_MINUS_DST_ALPHA=_C('GL_ONE_MINUS_DST_ALPHA',0x0305) +GL_ONE_MINUS_DST_COLOR=_C('GL_ONE_MINUS_DST_COLOR',0x0307) +GL_ONE_MINUS_SRC_ALPHA=_C('GL_ONE_MINUS_SRC_ALPHA',0x0303) +GL_ONE_MINUS_SRC_COLOR=_C('GL_ONE_MINUS_SRC_COLOR',0x0301) +GL_SRC_ALPHA=_C('GL_SRC_ALPHA',0x0302) +GL_SRC_ALPHA_SATURATE=_C('GL_SRC_ALPHA_SATURATE',0x0308) +GL_SRC_COLOR=_C('GL_SRC_COLOR',0x0300) +GL_ZERO=_C('GL_ZERO',0) +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLenum) +def glBlendEquationSeparateiOES(buf,modeRGB,modeAlpha):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum) +def glBlendEquationiOES(buf,mode):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLenum,_cs.GLenum,_cs.GLenum) +def glBlendFuncSeparateiOES(buf,srcRGB,dstRGB,srcAlpha,dstAlpha):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLenum) +def glBlendFunciOES(buf,src,dst):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLboolean,_cs.GLboolean,_cs.GLboolean,_cs.GLboolean) +def glColorMaskiOES(index,r,g,b,a):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint) +def glDisableiOES(target,index):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint) +def glEnableiOES(target,index):pass +@_f +@_p.types(_cs.GLboolean,_cs.GLenum,_cs.GLuint) +def glIsEnablediOES(target,index):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/draw_elements_base_vertex.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/draw_elements_base_vertex.py new file mode 100644 index 00000000..c377de07 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/draw_elements_base_vertex.py @@ -0,0 +1,26 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_OES_draw_elements_base_vertex' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_OES_draw_elements_base_vertex',error_checker=_errors._error_checker) + +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizei,_cs.GLenum,ctypes.c_void_p,_cs.GLint) +def glDrawElementsBaseVertexOES(mode,count,type,indices,basevertex):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizei,_cs.GLenum,ctypes.c_void_p,_cs.GLsizei,_cs.GLint) +def glDrawElementsInstancedBaseVertexOES(mode,count,type,indices,instancecount,basevertex):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,_cs.GLuint,_cs.GLsizei,_cs.GLenum,ctypes.c_void_p,_cs.GLint) +def glDrawRangeElementsBaseVertexOES(mode,start,end,count,type,indices,basevertex):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLsizeiArray,_cs.GLenum,arrays.GLvoidpArray,_cs.GLsizei,arrays.GLintArray) +def glMultiDrawElementsBaseVertexEXT(mode,count,type,indices,primcount,basevertex):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/element_index_uint.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/element_index_uint.py new file mode 100644 index 00000000..295598ac --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/element_index_uint.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_OES_element_index_uint' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_OES_element_index_uint',error_checker=_errors._error_checker) +GL_UNSIGNED_INT=_C('GL_UNSIGNED_INT',0x1405) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/fbo_render_mipmap.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/fbo_render_mipmap.py new file mode 100644 index 00000000..b7ca8dc1 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/fbo_render_mipmap.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_OES_fbo_render_mipmap' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_OES_fbo_render_mipmap',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/fragment_precision_high.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/fragment_precision_high.py new file mode 100644 index 00000000..ea484ccc --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/fragment_precision_high.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_OES_fragment_precision_high' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_OES_fragment_precision_high',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/geometry_point_size.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/geometry_point_size.py new file mode 100644 index 00000000..7e60d330 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/geometry_point_size.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_OES_geometry_point_size' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_OES_geometry_point_size',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/geometry_shader.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/geometry_shader.py new file mode 100644 index 00000000..d368c1a1 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/geometry_shader.py @@ -0,0 +1,49 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_OES_geometry_shader' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_OES_geometry_shader',error_checker=_errors._error_checker) +GL_FIRST_VERTEX_CONVENTION_OES=_C('GL_FIRST_VERTEX_CONVENTION_OES',0x8E4D) +GL_FRAMEBUFFER_ATTACHMENT_LAYERED_OES=_C('GL_FRAMEBUFFER_ATTACHMENT_LAYERED_OES',0x8DA7) +GL_FRAMEBUFFER_DEFAULT_LAYERS_OES=_C('GL_FRAMEBUFFER_DEFAULT_LAYERS_OES',0x9312) +GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS_OES=_C('GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS_OES',0x8DA8) +GL_GEOMETRY_LINKED_INPUT_TYPE_OES=_C('GL_GEOMETRY_LINKED_INPUT_TYPE_OES',0x8917) +GL_GEOMETRY_LINKED_OUTPUT_TYPE_OES=_C('GL_GEOMETRY_LINKED_OUTPUT_TYPE_OES',0x8918) +GL_GEOMETRY_LINKED_VERTICES_OUT_OES=_C('GL_GEOMETRY_LINKED_VERTICES_OUT_OES',0x8916) +GL_GEOMETRY_SHADER_BIT_OES=_C('GL_GEOMETRY_SHADER_BIT_OES',0x00000004) +GL_GEOMETRY_SHADER_INVOCATIONS_OES=_C('GL_GEOMETRY_SHADER_INVOCATIONS_OES',0x887F) +GL_GEOMETRY_SHADER_OES=_C('GL_GEOMETRY_SHADER_OES',0x8DD9) +GL_LAST_VERTEX_CONVENTION_OES=_C('GL_LAST_VERTEX_CONVENTION_OES',0x8E4E) +GL_LAYER_PROVOKING_VERTEX_OES=_C('GL_LAYER_PROVOKING_VERTEX_OES',0x825E) +GL_LINES_ADJACENCY_OES=_C('GL_LINES_ADJACENCY_OES',0x000A) +GL_LINE_STRIP_ADJACENCY_OES=_C('GL_LINE_STRIP_ADJACENCY_OES',0x000B) +GL_MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS_OES=_C('GL_MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS_OES',0x8A32) +GL_MAX_FRAMEBUFFER_LAYERS_OES=_C('GL_MAX_FRAMEBUFFER_LAYERS_OES',0x9317) +GL_MAX_GEOMETRY_ATOMIC_COUNTERS_OES=_C('GL_MAX_GEOMETRY_ATOMIC_COUNTERS_OES',0x92D5) +GL_MAX_GEOMETRY_ATOMIC_COUNTER_BUFFERS_OES=_C('GL_MAX_GEOMETRY_ATOMIC_COUNTER_BUFFERS_OES',0x92CF) +GL_MAX_GEOMETRY_IMAGE_UNIFORMS_OES=_C('GL_MAX_GEOMETRY_IMAGE_UNIFORMS_OES',0x90CD) +GL_MAX_GEOMETRY_INPUT_COMPONENTS_OES=_C('GL_MAX_GEOMETRY_INPUT_COMPONENTS_OES',0x9123) +GL_MAX_GEOMETRY_OUTPUT_COMPONENTS_OES=_C('GL_MAX_GEOMETRY_OUTPUT_COMPONENTS_OES',0x9124) +GL_MAX_GEOMETRY_OUTPUT_VERTICES_OES=_C('GL_MAX_GEOMETRY_OUTPUT_VERTICES_OES',0x8DE0) +GL_MAX_GEOMETRY_SHADER_INVOCATIONS_OES=_C('GL_MAX_GEOMETRY_SHADER_INVOCATIONS_OES',0x8E5A) +GL_MAX_GEOMETRY_SHADER_STORAGE_BLOCKS_OES=_C('GL_MAX_GEOMETRY_SHADER_STORAGE_BLOCKS_OES',0x90D7) +GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_OES=_C('GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_OES',0x8C29) +GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS_OES=_C('GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS_OES',0x8DE1) +GL_MAX_GEOMETRY_UNIFORM_BLOCKS_OES=_C('GL_MAX_GEOMETRY_UNIFORM_BLOCKS_OES',0x8A2C) +GL_MAX_GEOMETRY_UNIFORM_COMPONENTS_OES=_C('GL_MAX_GEOMETRY_UNIFORM_COMPONENTS_OES',0x8DDF) +GL_PRIMITIVES_GENERATED_OES=_C('GL_PRIMITIVES_GENERATED_OES',0x8C87) +GL_REFERENCED_BY_GEOMETRY_SHADER_OES=_C('GL_REFERENCED_BY_GEOMETRY_SHADER_OES',0x9309) +GL_TRIANGLES_ADJACENCY_OES=_C('GL_TRIANGLES_ADJACENCY_OES',0x000C) +GL_TRIANGLE_STRIP_ADJACENCY_OES=_C('GL_TRIANGLE_STRIP_ADJACENCY_OES',0x000D) +GL_UNDEFINED_VERTEX_OES=_C('GL_UNDEFINED_VERTEX_OES',0x8260) +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLuint,_cs.GLint) +def glFramebufferTextureOES(target,attachment,texture,level):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/get_program_binary.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/get_program_binary.py new file mode 100644 index 00000000..398d2319 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/get_program_binary.py @@ -0,0 +1,22 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_OES_get_program_binary' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_OES_get_program_binary',error_checker=_errors._error_checker) +GL_NUM_PROGRAM_BINARY_FORMATS_OES=_C('GL_NUM_PROGRAM_BINARY_FORMATS_OES',0x87FE) +GL_PROGRAM_BINARY_FORMATS_OES=_C('GL_PROGRAM_BINARY_FORMATS_OES',0x87FF) +GL_PROGRAM_BINARY_LENGTH_OES=_C('GL_PROGRAM_BINARY_LENGTH_OES',0x8741) +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizei,arrays.GLsizeiArray,arrays.GLuintArray,ctypes.c_void_p) +def glGetProgramBinaryOES(program,bufSize,length,binaryFormat,binary):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,ctypes.c_void_p,_cs.GLint) +def glProgramBinaryOES(program,binaryFormat,binary,length):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/gpu_shader5.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/gpu_shader5.py new file mode 100644 index 00000000..aab75d26 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/gpu_shader5.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_OES_gpu_shader5' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_OES_gpu_shader5',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/mapbuffer.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/mapbuffer.py new file mode 100644 index 00000000..e5e98215 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/mapbuffer.py @@ -0,0 +1,26 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_OES_mapbuffer' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_OES_mapbuffer',error_checker=_errors._error_checker) +GL_BUFFER_ACCESS_OES=_C('GL_BUFFER_ACCESS_OES',0x88BB) +GL_BUFFER_MAPPED_OES=_C('GL_BUFFER_MAPPED_OES',0x88BC) +GL_BUFFER_MAP_POINTER_OES=_C('GL_BUFFER_MAP_POINTER_OES',0x88BD) +GL_WRITE_ONLY_OES=_C('GL_WRITE_ONLY_OES',0x88B9) +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLvoidpArray) +def glGetBufferPointervOES(target,pname,params):pass +@_f +@_p.types(ctypes.c_void_p,_cs.GLenum,_cs.GLenum) +def glMapBufferOES(target,access):pass +@_f +@_p.types(_cs.GLboolean,_cs.GLenum) +def glUnmapBufferOES(target):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/packed_depth_stencil.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/packed_depth_stencil.py new file mode 100644 index 00000000..fffe42d5 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/packed_depth_stencil.py @@ -0,0 +1,17 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_OES_packed_depth_stencil' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_OES_packed_depth_stencil',error_checker=_errors._error_checker) +GL_DEPTH24_STENCIL8_OES=_C('GL_DEPTH24_STENCIL8_OES',0x88F0) +GL_DEPTH_STENCIL_OES=_C('GL_DEPTH_STENCIL_OES',0x84F9) +GL_UNSIGNED_INT_24_8_OES=_C('GL_UNSIGNED_INT_24_8_OES',0x84FA) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/primitive_bounding_box.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/primitive_bounding_box.py new file mode 100644 index 00000000..bb3b7b1e --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/primitive_bounding_box.py @@ -0,0 +1,17 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_OES_primitive_bounding_box' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_OES_primitive_bounding_box',error_checker=_errors._error_checker) +GL_PRIMITIVE_BOUNDING_BOX_OES=_C('GL_PRIMITIVE_BOUNDING_BOX_OES',0x92BE) +@_f +@_p.types(None,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat) +def glPrimitiveBoundingBoxOES(minX,minY,minZ,minW,maxX,maxY,maxZ,maxW):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/required_internalformat.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/required_internalformat.py new file mode 100644 index 00000000..2538586c --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/required_internalformat.py @@ -0,0 +1,29 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_OES_required_internalformat' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_OES_required_internalformat',error_checker=_errors._error_checker) +GL_ALPHA8_OES=_C('GL_ALPHA8_OES',0x803C) +GL_DEPTH24_STENCIL8_OES=_C('GL_DEPTH24_STENCIL8_OES',0x88F0) +GL_DEPTH_COMPONENT16_OES=_C('GL_DEPTH_COMPONENT16_OES',0x81A5) +GL_DEPTH_COMPONENT24_OES=_C('GL_DEPTH_COMPONENT24_OES',0x81A6) +GL_DEPTH_COMPONENT32_OES=_C('GL_DEPTH_COMPONENT32_OES',0x81A7) +GL_LUMINANCE4_ALPHA4_OES=_C('GL_LUMINANCE4_ALPHA4_OES',0x8043) +GL_LUMINANCE8_ALPHA8_OES=_C('GL_LUMINANCE8_ALPHA8_OES',0x8045) +GL_LUMINANCE8_OES=_C('GL_LUMINANCE8_OES',0x8040) +GL_RGB10_A2_EXT=_C('GL_RGB10_A2_EXT',0x8059) +GL_RGB10_EXT=_C('GL_RGB10_EXT',0x8052) +GL_RGB565_OES=_C('GL_RGB565_OES',0x8D62) +GL_RGB5_A1_OES=_C('GL_RGB5_A1_OES',0x8057) +GL_RGB8_OES=_C('GL_RGB8_OES',0x8051) +GL_RGBA4_OES=_C('GL_RGBA4_OES',0x8056) +GL_RGBA8_OES=_C('GL_RGBA8_OES',0x8058) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/rgb8_rgba8.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/rgb8_rgba8.py new file mode 100644 index 00000000..bbb462af --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/rgb8_rgba8.py @@ -0,0 +1,16 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_OES_rgb8_rgba8' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_OES_rgb8_rgba8',error_checker=_errors._error_checker) +GL_RGB8_OES=_C('GL_RGB8_OES',0x8051) +GL_RGBA8_OES=_C('GL_RGBA8_OES',0x8058) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/sample_shading.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/sample_shading.py new file mode 100644 index 00000000..fbd7fb2c --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/sample_shading.py @@ -0,0 +1,18 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_OES_sample_shading' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_OES_sample_shading',error_checker=_errors._error_checker) +GL_MIN_SAMPLE_SHADING_VALUE_OES=_C('GL_MIN_SAMPLE_SHADING_VALUE_OES',0x8C37) +GL_SAMPLE_SHADING_OES=_C('GL_SAMPLE_SHADING_OES',0x8C36) +@_f +@_p.types(None,_cs.GLfloat) +def glMinSampleShadingOES(value):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/sample_variables.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/sample_variables.py new file mode 100644 index 00000000..8f6e4407 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/sample_variables.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_OES_sample_variables' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_OES_sample_variables',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/shader_image_atomic.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/shader_image_atomic.py new file mode 100644 index 00000000..534fc27f --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/shader_image_atomic.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_OES_shader_image_atomic' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_OES_shader_image_atomic',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/shader_io_blocks.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/shader_io_blocks.py new file mode 100644 index 00000000..28d203e9 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/shader_io_blocks.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_OES_shader_io_blocks' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_OES_shader_io_blocks',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/shader_multisample_interpolation.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/shader_multisample_interpolation.py new file mode 100644 index 00000000..59589288 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/shader_multisample_interpolation.py @@ -0,0 +1,17 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_OES_shader_multisample_interpolation' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_OES_shader_multisample_interpolation',error_checker=_errors._error_checker) +GL_FRAGMENT_INTERPOLATION_OFFSET_BITS_OES=_C('GL_FRAGMENT_INTERPOLATION_OFFSET_BITS_OES',0x8E5D) +GL_MAX_FRAGMENT_INTERPOLATION_OFFSET_OES=_C('GL_MAX_FRAGMENT_INTERPOLATION_OFFSET_OES',0x8E5C) +GL_MIN_FRAGMENT_INTERPOLATION_OFFSET_OES=_C('GL_MIN_FRAGMENT_INTERPOLATION_OFFSET_OES',0x8E5B) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/standard_derivatives.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/standard_derivatives.py new file mode 100644 index 00000000..7ab2b9fa --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/standard_derivatives.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_OES_standard_derivatives' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_OES_standard_derivatives',error_checker=_errors._error_checker) +GL_FRAGMENT_SHADER_DERIVATIVE_HINT_OES=_C('GL_FRAGMENT_SHADER_DERIVATIVE_HINT_OES',0x8B8B) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/stencil1.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/stencil1.py new file mode 100644 index 00000000..b9d3d24e --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/stencil1.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_OES_stencil1' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_OES_stencil1',error_checker=_errors._error_checker) +GL_STENCIL_INDEX1_OES=_C('GL_STENCIL_INDEX1_OES',0x8D46) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/stencil4.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/stencil4.py new file mode 100644 index 00000000..e6aa04da --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/stencil4.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_OES_stencil4' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_OES_stencil4',error_checker=_errors._error_checker) +GL_STENCIL_INDEX4_OES=_C('GL_STENCIL_INDEX4_OES',0x8D47) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/surfaceless_context.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/surfaceless_context.py new file mode 100644 index 00000000..63451121 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/surfaceless_context.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_OES_surfaceless_context' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_OES_surfaceless_context',error_checker=_errors._error_checker) +GL_FRAMEBUFFER_UNDEFINED_OES=_C('GL_FRAMEBUFFER_UNDEFINED_OES',0x8219) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/tessellation_point_size.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/tessellation_point_size.py new file mode 100644 index 00000000..b0a5f2c0 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/tessellation_point_size.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_OES_tessellation_point_size' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_OES_tessellation_point_size',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/tessellation_shader.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/tessellation_shader.py new file mode 100644 index 00000000..f08cbf49 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/tessellation_shader.py @@ -0,0 +1,63 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_OES_tessellation_shader' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_OES_tessellation_shader',error_checker=_errors._error_checker) +GL_CCW=_C('GL_CCW',0x0901) +GL_CW=_C('GL_CW',0x0900) +GL_EQUAL=_C('GL_EQUAL',0x0202) +GL_FRACTIONAL_EVEN_OES=_C('GL_FRACTIONAL_EVEN_OES',0x8E7C) +GL_FRACTIONAL_ODD_OES=_C('GL_FRACTIONAL_ODD_OES',0x8E7B) +GL_ISOLINES_OES=_C('GL_ISOLINES_OES',0x8E7A) +GL_IS_PER_PATCH_OES=_C('GL_IS_PER_PATCH_OES',0x92E7) +GL_MAX_COMBINED_TESS_CONTROL_UNIFORM_COMPONENTS_OES=_C('GL_MAX_COMBINED_TESS_CONTROL_UNIFORM_COMPONENTS_OES',0x8E1E) +GL_MAX_COMBINED_TESS_EVALUATION_UNIFORM_COMPONENTS_OES=_C('GL_MAX_COMBINED_TESS_EVALUATION_UNIFORM_COMPONENTS_OES',0x8E1F) +GL_MAX_PATCH_VERTICES_OES=_C('GL_MAX_PATCH_VERTICES_OES',0x8E7D) +GL_MAX_TESS_CONTROL_ATOMIC_COUNTERS_OES=_C('GL_MAX_TESS_CONTROL_ATOMIC_COUNTERS_OES',0x92D3) +GL_MAX_TESS_CONTROL_ATOMIC_COUNTER_BUFFERS_OES=_C('GL_MAX_TESS_CONTROL_ATOMIC_COUNTER_BUFFERS_OES',0x92CD) +GL_MAX_TESS_CONTROL_IMAGE_UNIFORMS_OES=_C('GL_MAX_TESS_CONTROL_IMAGE_UNIFORMS_OES',0x90CB) +GL_MAX_TESS_CONTROL_INPUT_COMPONENTS_OES=_C('GL_MAX_TESS_CONTROL_INPUT_COMPONENTS_OES',0x886C) +GL_MAX_TESS_CONTROL_OUTPUT_COMPONENTS_OES=_C('GL_MAX_TESS_CONTROL_OUTPUT_COMPONENTS_OES',0x8E83) +GL_MAX_TESS_CONTROL_SHADER_STORAGE_BLOCKS_OES=_C('GL_MAX_TESS_CONTROL_SHADER_STORAGE_BLOCKS_OES',0x90D8) +GL_MAX_TESS_CONTROL_TEXTURE_IMAGE_UNITS_OES=_C('GL_MAX_TESS_CONTROL_TEXTURE_IMAGE_UNITS_OES',0x8E81) +GL_MAX_TESS_CONTROL_TOTAL_OUTPUT_COMPONENTS_OES=_C('GL_MAX_TESS_CONTROL_TOTAL_OUTPUT_COMPONENTS_OES',0x8E85) +GL_MAX_TESS_CONTROL_UNIFORM_BLOCKS_OES=_C('GL_MAX_TESS_CONTROL_UNIFORM_BLOCKS_OES',0x8E89) +GL_MAX_TESS_CONTROL_UNIFORM_COMPONENTS_OES=_C('GL_MAX_TESS_CONTROL_UNIFORM_COMPONENTS_OES',0x8E7F) +GL_MAX_TESS_EVALUATION_ATOMIC_COUNTERS_OES=_C('GL_MAX_TESS_EVALUATION_ATOMIC_COUNTERS_OES',0x92D4) +GL_MAX_TESS_EVALUATION_ATOMIC_COUNTER_BUFFERS_OES=_C('GL_MAX_TESS_EVALUATION_ATOMIC_COUNTER_BUFFERS_OES',0x92CE) +GL_MAX_TESS_EVALUATION_IMAGE_UNIFORMS_OES=_C('GL_MAX_TESS_EVALUATION_IMAGE_UNIFORMS_OES',0x90CC) +GL_MAX_TESS_EVALUATION_INPUT_COMPONENTS_OES=_C('GL_MAX_TESS_EVALUATION_INPUT_COMPONENTS_OES',0x886D) +GL_MAX_TESS_EVALUATION_OUTPUT_COMPONENTS_OES=_C('GL_MAX_TESS_EVALUATION_OUTPUT_COMPONENTS_OES',0x8E86) +GL_MAX_TESS_EVALUATION_SHADER_STORAGE_BLOCKS_OES=_C('GL_MAX_TESS_EVALUATION_SHADER_STORAGE_BLOCKS_OES',0x90D9) +GL_MAX_TESS_EVALUATION_TEXTURE_IMAGE_UNITS_OES=_C('GL_MAX_TESS_EVALUATION_TEXTURE_IMAGE_UNITS_OES',0x8E82) +GL_MAX_TESS_EVALUATION_UNIFORM_BLOCKS_OES=_C('GL_MAX_TESS_EVALUATION_UNIFORM_BLOCKS_OES',0x8E8A) +GL_MAX_TESS_EVALUATION_UNIFORM_COMPONENTS_OES=_C('GL_MAX_TESS_EVALUATION_UNIFORM_COMPONENTS_OES',0x8E80) +GL_MAX_TESS_GEN_LEVEL_OES=_C('GL_MAX_TESS_GEN_LEVEL_OES',0x8E7E) +GL_MAX_TESS_PATCH_COMPONENTS_OES=_C('GL_MAX_TESS_PATCH_COMPONENTS_OES',0x8E84) +GL_PATCHES_OES=_C('GL_PATCHES_OES',0x000E) +GL_PATCH_VERTICES_OES=_C('GL_PATCH_VERTICES_OES',0x8E72) +GL_PRIMITIVE_RESTART_FOR_PATCHES_SUPPORTED_OES=_C('GL_PRIMITIVE_RESTART_FOR_PATCHES_SUPPORTED_OES',0x8221) +GL_QUADS_OES=_C('GL_QUADS_OES',0x0007) +GL_REFERENCED_BY_TESS_CONTROL_SHADER_OES=_C('GL_REFERENCED_BY_TESS_CONTROL_SHADER_OES',0x9307) +GL_REFERENCED_BY_TESS_EVALUATION_SHADER_OES=_C('GL_REFERENCED_BY_TESS_EVALUATION_SHADER_OES',0x9308) +GL_TESS_CONTROL_OUTPUT_VERTICES_OES=_C('GL_TESS_CONTROL_OUTPUT_VERTICES_OES',0x8E75) +GL_TESS_CONTROL_SHADER_BIT_OES=_C('GL_TESS_CONTROL_SHADER_BIT_OES',0x00000008) +GL_TESS_CONTROL_SHADER_OES=_C('GL_TESS_CONTROL_SHADER_OES',0x8E88) +GL_TESS_EVALUATION_SHADER_BIT_OES=_C('GL_TESS_EVALUATION_SHADER_BIT_OES',0x00000010) +GL_TESS_EVALUATION_SHADER_OES=_C('GL_TESS_EVALUATION_SHADER_OES',0x8E87) +GL_TESS_GEN_MODE_OES=_C('GL_TESS_GEN_MODE_OES',0x8E76) +GL_TESS_GEN_POINT_MODE_OES=_C('GL_TESS_GEN_POINT_MODE_OES',0x8E79) +GL_TESS_GEN_SPACING_OES=_C('GL_TESS_GEN_SPACING_OES',0x8E77) +GL_TESS_GEN_VERTEX_ORDER_OES=_C('GL_TESS_GEN_VERTEX_ORDER_OES',0x8E78) +GL_TRIANGLES=_C('GL_TRIANGLES',0x0004) +@_f +@_p.types(None,_cs.GLenum,_cs.GLint) +def glPatchParameteriOES(pname,value):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/texture_3D.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/texture_3D.py new file mode 100644 index 00000000..725f08d8 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/texture_3D.py @@ -0,0 +1,37 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_OES_texture_3D' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_OES_texture_3D',error_checker=_errors._error_checker) +GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_OES=_C('GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_OES',0x8CD4) +GL_MAX_3D_TEXTURE_SIZE_OES=_C('GL_MAX_3D_TEXTURE_SIZE_OES',0x8073) +GL_SAMPLER_3D_OES=_C('GL_SAMPLER_3D_OES',0x8B5F) +GL_TEXTURE_3D_OES=_C('GL_TEXTURE_3D_OES',0x806F) +GL_TEXTURE_BINDING_3D_OES=_C('GL_TEXTURE_BINDING_3D_OES',0x806A) +GL_TEXTURE_WRAP_R_OES=_C('GL_TEXTURE_WRAP_R_OES',0x8072) +@_f +@_p.types(None,_cs.GLenum,_cs.GLint,_cs.GLenum,_cs.GLsizei,_cs.GLsizei,_cs.GLsizei,_cs.GLint,_cs.GLsizei,ctypes.c_void_p) +def glCompressedTexImage3DOES(target,level,internalformat,width,height,depth,border,imageSize,data):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLsizei,_cs.GLsizei,_cs.GLenum,_cs.GLsizei,ctypes.c_void_p) +def glCompressedTexSubImage3DOES(target,level,xoffset,yoffset,zoffset,width,height,depth,format,imageSize,data):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLsizei) +def glCopyTexSubImage3DOES(target,level,xoffset,yoffset,zoffset,x,y,width,height):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLenum,_cs.GLuint,_cs.GLint,_cs.GLint) +def glFramebufferTexture3DOES(target,attachment,textarget,texture,level,zoffset):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLint,_cs.GLenum,_cs.GLsizei,_cs.GLsizei,_cs.GLsizei,_cs.GLint,_cs.GLenum,_cs.GLenum,ctypes.c_void_p) +def glTexImage3DOES(target,level,internalformat,width,height,depth,border,format,type,pixels):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLsizei,_cs.GLsizei,_cs.GLenum,_cs.GLenum,ctypes.c_void_p) +def glTexSubImage3DOES(target,level,xoffset,yoffset,zoffset,width,height,depth,format,type,pixels):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/texture_border_clamp.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/texture_border_clamp.py new file mode 100644 index 00000000..81d583a9 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/texture_border_clamp.py @@ -0,0 +1,39 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_OES_texture_border_clamp' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_OES_texture_border_clamp',error_checker=_errors._error_checker) +GL_CLAMP_TO_BORDER_OES=_C('GL_CLAMP_TO_BORDER_OES',0x812D) +GL_TEXTURE_BORDER_COLOR_OES=_C('GL_TEXTURE_BORDER_COLOR_OES',0x1004) +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLintArray) +def glGetSamplerParameterIivOES(sampler,pname,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLuintArray) +def glGetSamplerParameterIuivOES(sampler,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLintArray) +def glGetTexParameterIivOES(target,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLuintArray) +def glGetTexParameterIuivOES(target,pname,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLintArray) +def glSamplerParameterIivOES(sampler,pname,param):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLuintArray) +def glSamplerParameterIuivOES(sampler,pname,param):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLintArray) +def glTexParameterIivOES(target,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLuintArray) +def glTexParameterIuivOES(target,pname,params):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/texture_buffer.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/texture_buffer.py new file mode 100644 index 00000000..b7958587 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/texture_buffer.py @@ -0,0 +1,33 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_OES_texture_buffer' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_OES_texture_buffer',error_checker=_errors._error_checker) +GL_IMAGE_BUFFER_OES=_C('GL_IMAGE_BUFFER_OES',0x9051) +GL_INT_IMAGE_BUFFER_OES=_C('GL_INT_IMAGE_BUFFER_OES',0x905C) +GL_INT_SAMPLER_BUFFER_OES=_C('GL_INT_SAMPLER_BUFFER_OES',0x8DD0) +GL_MAX_TEXTURE_BUFFER_SIZE_OES=_C('GL_MAX_TEXTURE_BUFFER_SIZE_OES',0x8C2B) +GL_SAMPLER_BUFFER_OES=_C('GL_SAMPLER_BUFFER_OES',0x8DC2) +GL_TEXTURE_BINDING_BUFFER_OES=_C('GL_TEXTURE_BINDING_BUFFER_OES',0x8C2C) +GL_TEXTURE_BUFFER_BINDING_OES=_C('GL_TEXTURE_BUFFER_BINDING_OES',0x8C2A) +GL_TEXTURE_BUFFER_DATA_STORE_BINDING_OES=_C('GL_TEXTURE_BUFFER_DATA_STORE_BINDING_OES',0x8C2D) +GL_TEXTURE_BUFFER_OES=_C('GL_TEXTURE_BUFFER_OES',0x8C2A) +GL_TEXTURE_BUFFER_OFFSET_ALIGNMENT_OES=_C('GL_TEXTURE_BUFFER_OFFSET_ALIGNMENT_OES',0x919F) +GL_TEXTURE_BUFFER_OFFSET_OES=_C('GL_TEXTURE_BUFFER_OFFSET_OES',0x919D) +GL_TEXTURE_BUFFER_SIZE_OES=_C('GL_TEXTURE_BUFFER_SIZE_OES',0x919E) +GL_UNSIGNED_INT_IMAGE_BUFFER_OES=_C('GL_UNSIGNED_INT_IMAGE_BUFFER_OES',0x9067) +GL_UNSIGNED_INT_SAMPLER_BUFFER_OES=_C('GL_UNSIGNED_INT_SAMPLER_BUFFER_OES',0x8DD8) +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLuint) +def glTexBufferOES(target,internalformat,buffer):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLuint,_cs.GLintptr,_cs.GLsizeiptr) +def glTexBufferRangeOES(target,internalformat,buffer,offset,size):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/texture_compression_astc.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/texture_compression_astc.py new file mode 100644 index 00000000..c1d4c436 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/texture_compression_astc.py @@ -0,0 +1,62 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_OES_texture_compression_astc' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_OES_texture_compression_astc',error_checker=_errors._error_checker) +GL_COMPRESSED_RGBA_ASTC_10x10_KHR=_C('GL_COMPRESSED_RGBA_ASTC_10x10_KHR',0x93BB) +GL_COMPRESSED_RGBA_ASTC_10x5_KHR=_C('GL_COMPRESSED_RGBA_ASTC_10x5_KHR',0x93B8) +GL_COMPRESSED_RGBA_ASTC_10x6_KHR=_C('GL_COMPRESSED_RGBA_ASTC_10x6_KHR',0x93B9) +GL_COMPRESSED_RGBA_ASTC_10x8_KHR=_C('GL_COMPRESSED_RGBA_ASTC_10x8_KHR',0x93BA) +GL_COMPRESSED_RGBA_ASTC_12x10_KHR=_C('GL_COMPRESSED_RGBA_ASTC_12x10_KHR',0x93BC) +GL_COMPRESSED_RGBA_ASTC_12x12_KHR=_C('GL_COMPRESSED_RGBA_ASTC_12x12_KHR',0x93BD) +GL_COMPRESSED_RGBA_ASTC_3x3x3_OES=_C('GL_COMPRESSED_RGBA_ASTC_3x3x3_OES',0x93C0) +GL_COMPRESSED_RGBA_ASTC_4x3x3_OES=_C('GL_COMPRESSED_RGBA_ASTC_4x3x3_OES',0x93C1) +GL_COMPRESSED_RGBA_ASTC_4x4_KHR=_C('GL_COMPRESSED_RGBA_ASTC_4x4_KHR',0x93B0) +GL_COMPRESSED_RGBA_ASTC_4x4x3_OES=_C('GL_COMPRESSED_RGBA_ASTC_4x4x3_OES',0x93C2) +GL_COMPRESSED_RGBA_ASTC_4x4x4_OES=_C('GL_COMPRESSED_RGBA_ASTC_4x4x4_OES',0x93C3) +GL_COMPRESSED_RGBA_ASTC_5x4_KHR=_C('GL_COMPRESSED_RGBA_ASTC_5x4_KHR',0x93B1) +GL_COMPRESSED_RGBA_ASTC_5x4x4_OES=_C('GL_COMPRESSED_RGBA_ASTC_5x4x4_OES',0x93C4) +GL_COMPRESSED_RGBA_ASTC_5x5_KHR=_C('GL_COMPRESSED_RGBA_ASTC_5x5_KHR',0x93B2) +GL_COMPRESSED_RGBA_ASTC_5x5x4_OES=_C('GL_COMPRESSED_RGBA_ASTC_5x5x4_OES',0x93C5) +GL_COMPRESSED_RGBA_ASTC_5x5x5_OES=_C('GL_COMPRESSED_RGBA_ASTC_5x5x5_OES',0x93C6) +GL_COMPRESSED_RGBA_ASTC_6x5_KHR=_C('GL_COMPRESSED_RGBA_ASTC_6x5_KHR',0x93B3) +GL_COMPRESSED_RGBA_ASTC_6x5x5_OES=_C('GL_COMPRESSED_RGBA_ASTC_6x5x5_OES',0x93C7) +GL_COMPRESSED_RGBA_ASTC_6x6_KHR=_C('GL_COMPRESSED_RGBA_ASTC_6x6_KHR',0x93B4) +GL_COMPRESSED_RGBA_ASTC_6x6x5_OES=_C('GL_COMPRESSED_RGBA_ASTC_6x6x5_OES',0x93C8) +GL_COMPRESSED_RGBA_ASTC_6x6x6_OES=_C('GL_COMPRESSED_RGBA_ASTC_6x6x6_OES',0x93C9) +GL_COMPRESSED_RGBA_ASTC_8x5_KHR=_C('GL_COMPRESSED_RGBA_ASTC_8x5_KHR',0x93B5) +GL_COMPRESSED_RGBA_ASTC_8x6_KHR=_C('GL_COMPRESSED_RGBA_ASTC_8x6_KHR',0x93B6) +GL_COMPRESSED_RGBA_ASTC_8x8_KHR=_C('GL_COMPRESSED_RGBA_ASTC_8x8_KHR',0x93B7) +GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR=_C('GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR',0x93DB) +GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR=_C('GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR',0x93D8) +GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR=_C('GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR',0x93D9) +GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR=_C('GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR',0x93DA) +GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR=_C('GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR',0x93DC) +GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR=_C('GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR',0x93DD) +GL_COMPRESSED_SRGB8_ALPHA8_ASTC_3x3x3_OES=_C('GL_COMPRESSED_SRGB8_ALPHA8_ASTC_3x3x3_OES',0x93E0) +GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x3x3_OES=_C('GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x3x3_OES',0x93E1) +GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR=_C('GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR',0x93D0) +GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4x3_OES=_C('GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4x3_OES',0x93E2) +GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4x4_OES=_C('GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4x4_OES',0x93E3) +GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR=_C('GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR',0x93D1) +GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4x4_OES=_C('GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4x4_OES',0x93E4) +GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR=_C('GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR',0x93D2) +GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5x4_OES=_C('GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5x4_OES',0x93E5) +GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5x5_OES=_C('GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5x5_OES',0x93E6) +GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR=_C('GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR',0x93D3) +GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5x5_OES=_C('GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5x5_OES',0x93E7) +GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR=_C('GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR',0x93D4) +GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6x5_OES=_C('GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6x5_OES',0x93E8) +GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6x6_OES=_C('GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6x6_OES',0x93E9) +GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR=_C('GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR',0x93D5) +GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR=_C('GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR',0x93D6) +GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR=_C('GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR',0x93D7) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/texture_cube_map_array.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/texture_cube_map_array.py new file mode 100644 index 00000000..aee2af9a --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/texture_cube_map_array.py @@ -0,0 +1,23 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_OES_texture_cube_map_array' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_OES_texture_cube_map_array',error_checker=_errors._error_checker) +GL_IMAGE_CUBE_MAP_ARRAY_OES=_C('GL_IMAGE_CUBE_MAP_ARRAY_OES',0x9054) +GL_INT_IMAGE_CUBE_MAP_ARRAY_OES=_C('GL_INT_IMAGE_CUBE_MAP_ARRAY_OES',0x905F) +GL_INT_SAMPLER_CUBE_MAP_ARRAY_OES=_C('GL_INT_SAMPLER_CUBE_MAP_ARRAY_OES',0x900E) +GL_SAMPLER_CUBE_MAP_ARRAY_OES=_C('GL_SAMPLER_CUBE_MAP_ARRAY_OES',0x900C) +GL_SAMPLER_CUBE_MAP_ARRAY_SHADOW_OES=_C('GL_SAMPLER_CUBE_MAP_ARRAY_SHADOW_OES',0x900D) +GL_TEXTURE_BINDING_CUBE_MAP_ARRAY_OES=_C('GL_TEXTURE_BINDING_CUBE_MAP_ARRAY_OES',0x900A) +GL_TEXTURE_CUBE_MAP_ARRAY_OES=_C('GL_TEXTURE_CUBE_MAP_ARRAY_OES',0x9009) +GL_UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY_OES=_C('GL_UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY_OES',0x906A) +GL_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY_OES=_C('GL_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY_OES',0x900F) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/texture_float.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/texture_float.py new file mode 100644 index 00000000..6e8228db --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/texture_float.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_OES_texture_float' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_OES_texture_float',error_checker=_errors._error_checker) +GL_FLOAT=_C('GL_FLOAT',0x1406) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/texture_float_linear.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/texture_float_linear.py new file mode 100644 index 00000000..82597092 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/texture_float_linear.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_OES_texture_float_linear' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_OES_texture_float_linear',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/texture_half_float.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/texture_half_float.py new file mode 100644 index 00000000..2d45b482 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/texture_half_float.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_OES_texture_half_float' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_OES_texture_half_float',error_checker=_errors._error_checker) +GL_HALF_FLOAT_OES=_C('GL_HALF_FLOAT_OES',0x8D61) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/texture_half_float_linear.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/texture_half_float_linear.py new file mode 100644 index 00000000..16e04d71 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/texture_half_float_linear.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_OES_texture_half_float_linear' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_OES_texture_half_float_linear',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/texture_npot.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/texture_npot.py new file mode 100644 index 00000000..0b65bb3f --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/texture_npot.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_OES_texture_npot' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_OES_texture_npot',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/texture_stencil8.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/texture_stencil8.py new file mode 100644 index 00000000..607eeac2 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/texture_stencil8.py @@ -0,0 +1,16 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_OES_texture_stencil8' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_OES_texture_stencil8',error_checker=_errors._error_checker) +GL_STENCIL_INDEX8_OES=_C('GL_STENCIL_INDEX8_OES',0x8D48) +GL_STENCIL_INDEX_OES=_C('GL_STENCIL_INDEX_OES',0x1901) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/texture_storage_multisample_2d_array.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/texture_storage_multisample_2d_array.py new file mode 100644 index 00000000..856025f6 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/texture_storage_multisample_2d_array.py @@ -0,0 +1,21 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_OES_texture_storage_multisample_2d_array' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_OES_texture_storage_multisample_2d_array',error_checker=_errors._error_checker) +GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY_OES=_C('GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY_OES',0x910C) +GL_SAMPLER_2D_MULTISAMPLE_ARRAY_OES=_C('GL_SAMPLER_2D_MULTISAMPLE_ARRAY_OES',0x910B) +GL_TEXTURE_2D_MULTISAMPLE_ARRAY_OES=_C('GL_TEXTURE_2D_MULTISAMPLE_ARRAY_OES',0x9102) +GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY_OES=_C('GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY_OES',0x9105) +GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY_OES=_C('GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY_OES',0x910D) +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizei,_cs.GLenum,_cs.GLsizei,_cs.GLsizei,_cs.GLsizei,_cs.GLboolean) +def glTexStorage3DMultisampleOES(target,samples,internalformat,width,height,depth,fixedsamplelocations):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/texture_view.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/texture_view.py new file mode 100644 index 00000000..a3379caf --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/texture_view.py @@ -0,0 +1,21 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_OES_texture_view' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_OES_texture_view',error_checker=_errors._error_checker) +GL_TEXTURE_IMMUTABLE_LEVELS=_C('GL_TEXTURE_IMMUTABLE_LEVELS',0x82DF) +GL_TEXTURE_VIEW_MIN_LAYER_OES=_C('GL_TEXTURE_VIEW_MIN_LAYER_OES',0x82DD) +GL_TEXTURE_VIEW_MIN_LEVEL_OES=_C('GL_TEXTURE_VIEW_MIN_LEVEL_OES',0x82DB) +GL_TEXTURE_VIEW_NUM_LAYERS_OES=_C('GL_TEXTURE_VIEW_NUM_LAYERS_OES',0x82DE) +GL_TEXTURE_VIEW_NUM_LEVELS_OES=_C('GL_TEXTURE_VIEW_NUM_LEVELS_OES',0x82DC) +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLuint,_cs.GLenum,_cs.GLuint,_cs.GLuint,_cs.GLuint,_cs.GLuint) +def glTextureViewOES(texture,target,origtexture,internalformat,minlevel,numlevels,minlayer,numlayers):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/vertex_array_object.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/vertex_array_object.py new file mode 100644 index 00000000..7af849cd --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/vertex_array_object.py @@ -0,0 +1,26 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_OES_vertex_array_object' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_OES_vertex_array_object',error_checker=_errors._error_checker) +GL_VERTEX_ARRAY_BINDING_OES=_C('GL_VERTEX_ARRAY_BINDING_OES',0x85B5) +@_f +@_p.types(None,_cs.GLuint) +def glBindVertexArrayOES(array):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray) +def glDeleteVertexArraysOES(n,arrays):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray) +def glGenVertexArraysOES(n,arrays):pass +@_f +@_p.types(_cs.GLboolean,_cs.GLuint) +def glIsVertexArrayOES(array):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/vertex_half_float.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/vertex_half_float.py new file mode 100644 index 00000000..1b38721a --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/vertex_half_float.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_OES_vertex_half_float' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_OES_vertex_half_float',error_checker=_errors._error_checker) +GL_HALF_FLOAT_OES=_C('GL_HALF_FLOAT_OES',0x8D61) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/vertex_type_10_10_10_2.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/vertex_type_10_10_10_2.py new file mode 100644 index 00000000..64766d18 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/vertex_type_10_10_10_2.py @@ -0,0 +1,16 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_OES_vertex_type_10_10_10_2' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_OES_vertex_type_10_10_10_2',error_checker=_errors._error_checker) +GL_INT_10_10_10_2_OES=_C('GL_INT_10_10_10_2_OES',0x8DF7) +GL_UNSIGNED_INT_10_10_10_2_OES=_C('GL_UNSIGNED_INT_10_10_10_2_OES',0x8DF6) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/viewport_array.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/viewport_array.py new file mode 100644 index 00000000..cf105740 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OES/viewport_array.py @@ -0,0 +1,57 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_OES_viewport_array' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_OES_viewport_array',error_checker=_errors._error_checker) +GL_DEPTH_RANGE=_C('GL_DEPTH_RANGE',0x0B70) +GL_MAX_VIEWPORTS_OES=_C('GL_MAX_VIEWPORTS_OES',0x825B) +GL_SCISSOR_BOX=_C('GL_SCISSOR_BOX',0x0C10) +GL_SCISSOR_TEST=_C('GL_SCISSOR_TEST',0x0C11) +GL_VIEWPORT=_C('GL_VIEWPORT',0x0BA2) +GL_VIEWPORT_BOUNDS_RANGE_OES=_C('GL_VIEWPORT_BOUNDS_RANGE_OES',0x825D) +GL_VIEWPORT_INDEX_PROVOKING_VERTEX_OES=_C('GL_VIEWPORT_INDEX_PROVOKING_VERTEX_OES',0x825F) +GL_VIEWPORT_SUBPIXEL_BITS_OES=_C('GL_VIEWPORT_SUBPIXEL_BITS_OES',0x825C) +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizei,arrays.GLfloatArray) +def glDepthRangeArrayfvOES(first,count,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLfloat,_cs.GLfloat) +def glDepthRangeIndexedfOES(index,n,f):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint) +def glDisableiOES(target,index):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint) +def glEnableiOES(target,index):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,arrays.GLfloatArray) +def glGetFloati_vOES(target,index,data):pass +@_f +@_p.types(_cs.GLboolean,_cs.GLenum,_cs.GLuint) +def glIsEnablediOES(target,index):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizei,arrays.GLintArray) +def glScissorArrayvOES(first,count,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLsizei) +def glScissorIndexedOES(index,left,bottom,width,height):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLintArray) +def glScissorIndexedvOES(index,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizei,arrays.GLfloatArray) +def glViewportArrayvOES(first,count,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat) +def glViewportIndexedfOES(index,x,y,w,h):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLfloatArray) +def glViewportIndexedfvOES(index,v):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OVR/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OVR/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OVR/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OVR/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OVR/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..e6bf644e Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OVR/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OVR/__pycache__/multiview.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OVR/__pycache__/multiview.cpython-312.pyc new file mode 100644 index 00000000..2238ea8c Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OVR/__pycache__/multiview.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OVR/__pycache__/multiview2.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OVR/__pycache__/multiview2.cpython-312.pyc new file mode 100644 index 00000000..a79e5863 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OVR/__pycache__/multiview2.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OVR/__pycache__/multiview_multisampled_render_to_texture.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OVR/__pycache__/multiview_multisampled_render_to_texture.cpython-312.pyc new file mode 100644 index 00000000..367ffc41 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OVR/__pycache__/multiview_multisampled_render_to_texture.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OVR/multiview.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OVR/multiview.py new file mode 100644 index 00000000..0f6cf338 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OVR/multiview.py @@ -0,0 +1,20 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_OVR_multiview' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_OVR_multiview',error_checker=_errors._error_checker) +GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_BASE_VIEW_INDEX_OVR=_C('GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_BASE_VIEW_INDEX_OVR',0x9632) +GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_NUM_VIEWS_OVR=_C('GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_NUM_VIEWS_OVR',0x9630) +GL_FRAMEBUFFER_INCOMPLETE_VIEW_TARGETS_OVR=_C('GL_FRAMEBUFFER_INCOMPLETE_VIEW_TARGETS_OVR',0x9633) +GL_MAX_VIEWS_OVR=_C('GL_MAX_VIEWS_OVR',0x9631) +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLuint,_cs.GLint,_cs.GLint,_cs.GLsizei) +def glFramebufferTextureMultiviewOVR(target,attachment,texture,level,baseViewIndex,numViews):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OVR/multiview2.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OVR/multiview2.py new file mode 100644 index 00000000..6b7bc651 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OVR/multiview2.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_OVR_multiview2' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_OVR_multiview2',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OVR/multiview_multisampled_render_to_texture.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OVR/multiview_multisampled_render_to_texture.py new file mode 100644 index 00000000..d345decc --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/OVR/multiview_multisampled_render_to_texture.py @@ -0,0 +1,17 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_OVR_multiview_multisampled_render_to_texture' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_OVR_multiview_multisampled_render_to_texture',error_checker=_errors._error_checker) + +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLuint,_cs.GLint,_cs.GLsizei,_cs.GLint,_cs.GLsizei) +def glFramebufferTextureMultisampleMultiviewOVR(target,attachment,texture,level,samples,baseViewIndex,numViews):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/QCOM/YUV_texture_gather.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/QCOM/YUV_texture_gather.py new file mode 100644 index 00000000..75f3ffc0 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/QCOM/YUV_texture_gather.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_QCOM_YUV_texture_gather' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_QCOM_YUV_texture_gather',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/QCOM/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/QCOM/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/QCOM/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/QCOM/__pycache__/YUV_texture_gather.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/QCOM/__pycache__/YUV_texture_gather.cpython-312.pyc new file mode 100644 index 00000000..239c1d37 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/QCOM/__pycache__/YUV_texture_gather.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/QCOM/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/QCOM/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..f3d9c50d Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/QCOM/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/QCOM/__pycache__/alpha_test.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/QCOM/__pycache__/alpha_test.cpython-312.pyc new file mode 100644 index 00000000..32206eaf Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/QCOM/__pycache__/alpha_test.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/QCOM/__pycache__/binning_control.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/QCOM/__pycache__/binning_control.cpython-312.pyc new file mode 100644 index 00000000..7c500d8c Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/QCOM/__pycache__/binning_control.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/QCOM/__pycache__/driver_control.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/QCOM/__pycache__/driver_control.cpython-312.pyc new file mode 100644 index 00000000..f0418995 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/QCOM/__pycache__/driver_control.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/QCOM/__pycache__/extended_get.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/QCOM/__pycache__/extended_get.cpython-312.pyc new file mode 100644 index 00000000..98330d00 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/QCOM/__pycache__/extended_get.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/QCOM/__pycache__/extended_get2.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/QCOM/__pycache__/extended_get2.cpython-312.pyc new file mode 100644 index 00000000..d692c826 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/QCOM/__pycache__/extended_get2.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/QCOM/__pycache__/framebuffer_foveated.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/QCOM/__pycache__/framebuffer_foveated.cpython-312.pyc new file mode 100644 index 00000000..28b3b576 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/QCOM/__pycache__/framebuffer_foveated.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/QCOM/__pycache__/perfmon_global_mode.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/QCOM/__pycache__/perfmon_global_mode.cpython-312.pyc new file mode 100644 index 00000000..ed68c73a Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/QCOM/__pycache__/perfmon_global_mode.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/QCOM/__pycache__/shader_framebuffer_fetch_noncoherent.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/QCOM/__pycache__/shader_framebuffer_fetch_noncoherent.cpython-312.pyc new file mode 100644 index 00000000..f8fe6307 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/QCOM/__pycache__/shader_framebuffer_fetch_noncoherent.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/QCOM/__pycache__/shader_framebuffer_fetch_rate.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/QCOM/__pycache__/shader_framebuffer_fetch_rate.cpython-312.pyc new file mode 100644 index 00000000..0a87212d Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/QCOM/__pycache__/shader_framebuffer_fetch_rate.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/QCOM/__pycache__/texture_foveated.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/QCOM/__pycache__/texture_foveated.cpython-312.pyc new file mode 100644 index 00000000..c5f520d5 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/QCOM/__pycache__/texture_foveated.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/QCOM/__pycache__/texture_foveated_subsampled_layout.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/QCOM/__pycache__/texture_foveated_subsampled_layout.cpython-312.pyc new file mode 100644 index 00000000..eb70764e Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/QCOM/__pycache__/texture_foveated_subsampled_layout.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/QCOM/__pycache__/tiled_rendering.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/QCOM/__pycache__/tiled_rendering.cpython-312.pyc new file mode 100644 index 00000000..50794ce8 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/QCOM/__pycache__/tiled_rendering.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/QCOM/__pycache__/writeonly_rendering.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/QCOM/__pycache__/writeonly_rendering.cpython-312.pyc new file mode 100644 index 00000000..bbf5978b Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/QCOM/__pycache__/writeonly_rendering.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/QCOM/alpha_test.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/QCOM/alpha_test.py new file mode 100644 index 00000000..6d1bf8fa --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/QCOM/alpha_test.py @@ -0,0 +1,19 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_QCOM_alpha_test' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_QCOM_alpha_test',error_checker=_errors._error_checker) +GL_ALPHA_TEST_FUNC_QCOM=_C('GL_ALPHA_TEST_FUNC_QCOM',0x0BC1) +GL_ALPHA_TEST_QCOM=_C('GL_ALPHA_TEST_QCOM',0x0BC0) +GL_ALPHA_TEST_REF_QCOM=_C('GL_ALPHA_TEST_REF_QCOM',0x0BC2) +@_f +@_p.types(None,_cs.GLenum,_cs.GLclampf) +def glAlphaFuncQCOM(func,ref):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/QCOM/binning_control.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/QCOM/binning_control.py new file mode 100644 index 00000000..6340ea77 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/QCOM/binning_control.py @@ -0,0 +1,18 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_QCOM_binning_control' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_QCOM_binning_control',error_checker=_errors._error_checker) +GL_BINNING_CONTROL_HINT_QCOM=_C('GL_BINNING_CONTROL_HINT_QCOM',0x8FB0) +GL_CPU_OPTIMIZED_QCOM=_C('GL_CPU_OPTIMIZED_QCOM',0x8FB1) +GL_GPU_OPTIMIZED_QCOM=_C('GL_GPU_OPTIMIZED_QCOM',0x8FB2) +GL_RENDER_DIRECT_TO_FRAMEBUFFER_QCOM=_C('GL_RENDER_DIRECT_TO_FRAMEBUFFER_QCOM',0x8FB3) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/QCOM/driver_control.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/QCOM/driver_control.py new file mode 100644 index 00000000..419a10aa --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/QCOM/driver_control.py @@ -0,0 +1,26 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_QCOM_driver_control' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_QCOM_driver_control',error_checker=_errors._error_checker) + +@_f +@_p.types(None,_cs.GLuint) +def glDisableDriverControlQCOM(driverControl):pass +@_f +@_p.types(None,_cs.GLuint) +def glEnableDriverControlQCOM(driverControl):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizei,arrays.GLsizeiArray,arrays.GLcharArray) +def glGetDriverControlStringQCOM(driverControl,bufSize,length,driverControlString):pass +@_f +@_p.types(None,arrays.GLintArray,_cs.GLsizei,arrays.GLuintArray) +def glGetDriverControlsQCOM(num,size,driverControls):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/QCOM/extended_get.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/QCOM/extended_get.py new file mode 100644 index 00000000..52e2332f --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/QCOM/extended_get.py @@ -0,0 +1,48 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_QCOM_extended_get' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_QCOM_extended_get',error_checker=_errors._error_checker) +GL_STATE_RESTORE=_C('GL_STATE_RESTORE',0x8BDC) +GL_TEXTURE_DEPTH_QCOM=_C('GL_TEXTURE_DEPTH_QCOM',0x8BD4) +GL_TEXTURE_FORMAT_QCOM=_C('GL_TEXTURE_FORMAT_QCOM',0x8BD6) +GL_TEXTURE_HEIGHT_QCOM=_C('GL_TEXTURE_HEIGHT_QCOM',0x8BD3) +GL_TEXTURE_IMAGE_VALID_QCOM=_C('GL_TEXTURE_IMAGE_VALID_QCOM',0x8BD8) +GL_TEXTURE_INTERNAL_FORMAT_QCOM=_C('GL_TEXTURE_INTERNAL_FORMAT_QCOM',0x8BD5) +GL_TEXTURE_NUM_LEVELS_QCOM=_C('GL_TEXTURE_NUM_LEVELS_QCOM',0x8BD9) +GL_TEXTURE_OBJECT_VALID_QCOM=_C('GL_TEXTURE_OBJECT_VALID_QCOM',0x8BDB) +GL_TEXTURE_TARGET_QCOM=_C('GL_TEXTURE_TARGET_QCOM',0x8BDA) +GL_TEXTURE_TYPE_QCOM=_C('GL_TEXTURE_TYPE_QCOM',0x8BD7) +GL_TEXTURE_WIDTH_QCOM=_C('GL_TEXTURE_WIDTH_QCOM',0x8BD2) +@_f +@_p.types(None,_cs.GLenum,arrays.GLvoidpArray) +def glExtGetBufferPointervQCOM(target,params):pass +@_f +@_p.types(None,arrays.GLuintArray,_cs.GLint,arrays.GLintArray) +def glExtGetBuffersQCOM(buffers,maxBuffers,numBuffers):pass +@_f +@_p.types(None,arrays.GLuintArray,_cs.GLint,arrays.GLintArray) +def glExtGetFramebuffersQCOM(framebuffers,maxFramebuffers,numFramebuffers):pass +@_f +@_p.types(None,arrays.GLuintArray,_cs.GLint,arrays.GLintArray) +def glExtGetRenderbuffersQCOM(renderbuffers,maxRenderbuffers,numRenderbuffers):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLint,_cs.GLenum,arrays.GLintArray) +def glExtGetTexLevelParameterivQCOM(texture,face,level,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLsizei,_cs.GLsizei,_cs.GLenum,_cs.GLenum,ctypes.c_void_p) +def glExtGetTexSubImageQCOM(target,level,xoffset,yoffset,zoffset,width,height,depth,format,type,texels):pass +@_f +@_p.types(None,arrays.GLuintArray,_cs.GLint,arrays.GLintArray) +def glExtGetTexturesQCOM(textures,maxTextures,numTextures):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLint) +def glExtTexObjectStateOverrideiQCOM(target,pname,param):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/QCOM/extended_get2.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/QCOM/extended_get2.py new file mode 100644 index 00000000..0903b6bd --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/QCOM/extended_get2.py @@ -0,0 +1,26 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_QCOM_extended_get2' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_QCOM_extended_get2',error_checker=_errors._error_checker) + +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLcharArray,arrays.GLintArray) +def glExtGetProgramBinarySourceQCOM(program,shadertype,source,length):pass +@_f +@_p.types(None,arrays.GLuintArray,_cs.GLint,arrays.GLintArray) +def glExtGetProgramsQCOM(programs,maxPrograms,numPrograms):pass +@_f +@_p.types(None,arrays.GLuintArray,_cs.GLint,arrays.GLintArray) +def glExtGetShadersQCOM(shaders,maxShaders,numShaders):pass +@_f +@_p.types(_cs.GLboolean,_cs.GLuint) +def glExtIsProgramBinaryQCOM(program):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/QCOM/framebuffer_foveated.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/QCOM/framebuffer_foveated.py new file mode 100644 index 00000000..5db96732 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/QCOM/framebuffer_foveated.py @@ -0,0 +1,21 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_QCOM_framebuffer_foveated' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_QCOM_framebuffer_foveated',error_checker=_errors._error_checker) +GL_FOVEATION_ENABLE_BIT_QCOM=_C('GL_FOVEATION_ENABLE_BIT_QCOM',0x00000001) +GL_FOVEATION_SCALED_BIN_METHOD_BIT_QCOM=_C('GL_FOVEATION_SCALED_BIN_METHOD_BIT_QCOM',0x00000002) +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLuint,_cs.GLuint,arrays.GLuintArray) +def glFramebufferFoveationConfigQCOM(framebuffer,numLayers,focalPointsPerLayer,requestedFeatures,providedFeatures):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLuint,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat) +def glFramebufferFoveationParametersQCOM(framebuffer,layer,focalPoint,focalX,focalY,gainX,gainY,foveaArea):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/QCOM/perfmon_global_mode.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/QCOM/perfmon_global_mode.py new file mode 100644 index 00000000..ec6a8ffe --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/QCOM/perfmon_global_mode.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_QCOM_perfmon_global_mode' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_QCOM_perfmon_global_mode',error_checker=_errors._error_checker) +GL_PERFMON_GLOBAL_MODE_QCOM=_C('GL_PERFMON_GLOBAL_MODE_QCOM',0x8FA0) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/QCOM/shader_framebuffer_fetch_noncoherent.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/QCOM/shader_framebuffer_fetch_noncoherent.py new file mode 100644 index 00000000..a4aceddf --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/QCOM/shader_framebuffer_fetch_noncoherent.py @@ -0,0 +1,17 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_QCOM_shader_framebuffer_fetch_noncoherent' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_QCOM_shader_framebuffer_fetch_noncoherent',error_checker=_errors._error_checker) +GL_FRAMEBUFFER_FETCH_NONCOHERENT_QCOM=_C('GL_FRAMEBUFFER_FETCH_NONCOHERENT_QCOM',0x96A2) +@_f +@_p.types(None,) +def glFramebufferFetchBarrierQCOM():pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/QCOM/shader_framebuffer_fetch_rate.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/QCOM/shader_framebuffer_fetch_rate.py new file mode 100644 index 00000000..e1f53015 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/QCOM/shader_framebuffer_fetch_rate.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_QCOM_shader_framebuffer_fetch_rate' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_QCOM_shader_framebuffer_fetch_rate',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/QCOM/texture_foveated.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/QCOM/texture_foveated.py new file mode 100644 index 00000000..3a487e49 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/QCOM/texture_foveated.py @@ -0,0 +1,23 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_QCOM_texture_foveated' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_QCOM_texture_foveated',error_checker=_errors._error_checker) +GL_FOVEATION_ENABLE_BIT_QCOM=_C('GL_FOVEATION_ENABLE_BIT_QCOM',0x00000001) +GL_FOVEATION_SCALED_BIN_METHOD_BIT_QCOM=_C('GL_FOVEATION_SCALED_BIN_METHOD_BIT_QCOM',0x00000002) +GL_FRAMEBUFFER_INCOMPLETE_FOVEATION_QCOM=_C('GL_FRAMEBUFFER_INCOMPLETE_FOVEATION_QCOM',0x8BFF) +GL_TEXTURE_FOVEATED_FEATURE_BITS_QCOM=_C('GL_TEXTURE_FOVEATED_FEATURE_BITS_QCOM',0x8BFB) +GL_TEXTURE_FOVEATED_FEATURE_QUERY_QCOM=_C('GL_TEXTURE_FOVEATED_FEATURE_QUERY_QCOM',0x8BFD) +GL_TEXTURE_FOVEATED_MIN_PIXEL_DENSITY_QCOM=_C('GL_TEXTURE_FOVEATED_MIN_PIXEL_DENSITY_QCOM',0x8BFC) +GL_TEXTURE_FOVEATED_NUM_FOCAL_POINTS_QUERY_QCOM=_C('GL_TEXTURE_FOVEATED_NUM_FOCAL_POINTS_QUERY_QCOM',0x8BFE) +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLuint,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat) +def glTextureFoveationParametersQCOM(texture,layer,focalPoint,focalX,focalY,gainX,gainY,foveaArea):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/QCOM/texture_foveated_subsampled_layout.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/QCOM/texture_foveated_subsampled_layout.py new file mode 100644 index 00000000..b2afa675 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/QCOM/texture_foveated_subsampled_layout.py @@ -0,0 +1,16 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_QCOM_texture_foveated_subsampled_layout' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_QCOM_texture_foveated_subsampled_layout',error_checker=_errors._error_checker) +GL_FOVEATION_SUBSAMPLED_LAYOUT_METHOD_BIT_QCOM=_C('GL_FOVEATION_SUBSAMPLED_LAYOUT_METHOD_BIT_QCOM',0x00000004) +GL_MAX_SHADER_SUBSAMPLED_IMAGE_UNITS_QCOM=_C('GL_MAX_SHADER_SUBSAMPLED_IMAGE_UNITS_QCOM',0x8FA1) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/QCOM/tiled_rendering.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/QCOM/tiled_rendering.py new file mode 100644 index 00000000..1301ca1f --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/QCOM/tiled_rendering.py @@ -0,0 +1,51 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_QCOM_tiled_rendering' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_QCOM_tiled_rendering',error_checker=_errors._error_checker) +GL_COLOR_BUFFER_BIT0_QCOM=_C('GL_COLOR_BUFFER_BIT0_QCOM',0x00000001) +GL_COLOR_BUFFER_BIT1_QCOM=_C('GL_COLOR_BUFFER_BIT1_QCOM',0x00000002) +GL_COLOR_BUFFER_BIT2_QCOM=_C('GL_COLOR_BUFFER_BIT2_QCOM',0x00000004) +GL_COLOR_BUFFER_BIT3_QCOM=_C('GL_COLOR_BUFFER_BIT3_QCOM',0x00000008) +GL_COLOR_BUFFER_BIT4_QCOM=_C('GL_COLOR_BUFFER_BIT4_QCOM',0x00000010) +GL_COLOR_BUFFER_BIT5_QCOM=_C('GL_COLOR_BUFFER_BIT5_QCOM',0x00000020) +GL_COLOR_BUFFER_BIT6_QCOM=_C('GL_COLOR_BUFFER_BIT6_QCOM',0x00000040) +GL_COLOR_BUFFER_BIT7_QCOM=_C('GL_COLOR_BUFFER_BIT7_QCOM',0x00000080) +GL_DEPTH_BUFFER_BIT0_QCOM=_C('GL_DEPTH_BUFFER_BIT0_QCOM',0x00000100) +GL_DEPTH_BUFFER_BIT1_QCOM=_C('GL_DEPTH_BUFFER_BIT1_QCOM',0x00000200) +GL_DEPTH_BUFFER_BIT2_QCOM=_C('GL_DEPTH_BUFFER_BIT2_QCOM',0x00000400) +GL_DEPTH_BUFFER_BIT3_QCOM=_C('GL_DEPTH_BUFFER_BIT3_QCOM',0x00000800) +GL_DEPTH_BUFFER_BIT4_QCOM=_C('GL_DEPTH_BUFFER_BIT4_QCOM',0x00001000) +GL_DEPTH_BUFFER_BIT5_QCOM=_C('GL_DEPTH_BUFFER_BIT5_QCOM',0x00002000) +GL_DEPTH_BUFFER_BIT6_QCOM=_C('GL_DEPTH_BUFFER_BIT6_QCOM',0x00004000) +GL_DEPTH_BUFFER_BIT7_QCOM=_C('GL_DEPTH_BUFFER_BIT7_QCOM',0x00008000) +GL_MULTISAMPLE_BUFFER_BIT0_QCOM=_C('GL_MULTISAMPLE_BUFFER_BIT0_QCOM',0x01000000) +GL_MULTISAMPLE_BUFFER_BIT1_QCOM=_C('GL_MULTISAMPLE_BUFFER_BIT1_QCOM',0x02000000) +GL_MULTISAMPLE_BUFFER_BIT2_QCOM=_C('GL_MULTISAMPLE_BUFFER_BIT2_QCOM',0x04000000) +GL_MULTISAMPLE_BUFFER_BIT3_QCOM=_C('GL_MULTISAMPLE_BUFFER_BIT3_QCOM',0x08000000) +GL_MULTISAMPLE_BUFFER_BIT4_QCOM=_C('GL_MULTISAMPLE_BUFFER_BIT4_QCOM',0x10000000) +GL_MULTISAMPLE_BUFFER_BIT5_QCOM=_C('GL_MULTISAMPLE_BUFFER_BIT5_QCOM',0x20000000) +GL_MULTISAMPLE_BUFFER_BIT6_QCOM=_C('GL_MULTISAMPLE_BUFFER_BIT6_QCOM',0x40000000) +GL_MULTISAMPLE_BUFFER_BIT7_QCOM=_C('GL_MULTISAMPLE_BUFFER_BIT7_QCOM',0x80000000) +GL_STENCIL_BUFFER_BIT0_QCOM=_C('GL_STENCIL_BUFFER_BIT0_QCOM',0x00010000) +GL_STENCIL_BUFFER_BIT1_QCOM=_C('GL_STENCIL_BUFFER_BIT1_QCOM',0x00020000) +GL_STENCIL_BUFFER_BIT2_QCOM=_C('GL_STENCIL_BUFFER_BIT2_QCOM',0x00040000) +GL_STENCIL_BUFFER_BIT3_QCOM=_C('GL_STENCIL_BUFFER_BIT3_QCOM',0x00080000) +GL_STENCIL_BUFFER_BIT4_QCOM=_C('GL_STENCIL_BUFFER_BIT4_QCOM',0x00100000) +GL_STENCIL_BUFFER_BIT5_QCOM=_C('GL_STENCIL_BUFFER_BIT5_QCOM',0x00200000) +GL_STENCIL_BUFFER_BIT6_QCOM=_C('GL_STENCIL_BUFFER_BIT6_QCOM',0x00400000) +GL_STENCIL_BUFFER_BIT7_QCOM=_C('GL_STENCIL_BUFFER_BIT7_QCOM',0x00800000) +@_f +@_p.types(None,_cs.GLbitfield) +def glEndTilingQCOM(preserveMask):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLuint,_cs.GLuint,_cs.GLbitfield) +def glStartTilingQCOM(x,y,width,height,preserveMask):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/QCOM/writeonly_rendering.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/QCOM/writeonly_rendering.py new file mode 100644 index 00000000..880e3d04 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/QCOM/writeonly_rendering.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_QCOM_writeonly_rendering' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_QCOM_writeonly_rendering',error_checker=_errors._error_checker) +GL_WRITEONLY_RENDERING_QCOM=_C('GL_WRITEONLY_RENDERING_QCOM',0x8823) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/VERSION/GLES2_2_0.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/VERSION/GLES2_2_0.py new file mode 100644 index 00000000..a06f8f89 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/VERSION/GLES2_2_0.py @@ -0,0 +1,740 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_VERSION_GLES2_2_0' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_VERSION_GLES2_2_0',error_checker=_errors._error_checker) +GL_ACTIVE_ATTRIBUTES=_C('GL_ACTIVE_ATTRIBUTES',0x8B89) +GL_ACTIVE_ATTRIBUTE_MAX_LENGTH=_C('GL_ACTIVE_ATTRIBUTE_MAX_LENGTH',0x8B8A) +GL_ACTIVE_TEXTURE=_C('GL_ACTIVE_TEXTURE',0x84E0) +GL_ACTIVE_UNIFORMS=_C('GL_ACTIVE_UNIFORMS',0x8B86) +GL_ACTIVE_UNIFORM_MAX_LENGTH=_C('GL_ACTIVE_UNIFORM_MAX_LENGTH',0x8B87) +GL_ALIASED_LINE_WIDTH_RANGE=_C('GL_ALIASED_LINE_WIDTH_RANGE',0x846E) +GL_ALIASED_POINT_SIZE_RANGE=_C('GL_ALIASED_POINT_SIZE_RANGE',0x846D) +GL_ALPHA=_C('GL_ALPHA',0x1906) +GL_ALPHA_BITS=_C('GL_ALPHA_BITS',0x0D55) +GL_ALWAYS=_C('GL_ALWAYS',0x0207) +GL_ARRAY_BUFFER=_C('GL_ARRAY_BUFFER',0x8892) +GL_ARRAY_BUFFER_BINDING=_C('GL_ARRAY_BUFFER_BINDING',0x8894) +GL_ATTACHED_SHADERS=_C('GL_ATTACHED_SHADERS',0x8B85) +GL_BACK=_C('GL_BACK',0x0405) +GL_BLEND=_C('GL_BLEND',0x0BE2) +GL_BLEND_COLOR=_C('GL_BLEND_COLOR',0x8005) +GL_BLEND_DST_ALPHA=_C('GL_BLEND_DST_ALPHA',0x80CA) +GL_BLEND_DST_RGB=_C('GL_BLEND_DST_RGB',0x80C8) +GL_BLEND_EQUATION=_C('GL_BLEND_EQUATION',0x8009) +GL_BLEND_EQUATION_ALPHA=_C('GL_BLEND_EQUATION_ALPHA',0x883D) +GL_BLEND_EQUATION_RGB=_C('GL_BLEND_EQUATION_RGB',0x8009) +GL_BLEND_SRC_ALPHA=_C('GL_BLEND_SRC_ALPHA',0x80CB) +GL_BLEND_SRC_RGB=_C('GL_BLEND_SRC_RGB',0x80C9) +GL_BLUE_BITS=_C('GL_BLUE_BITS',0x0D54) +GL_BOOL=_C('GL_BOOL',0x8B56) +GL_BOOL_VEC2=_C('GL_BOOL_VEC2',0x8B57) +GL_BOOL_VEC3=_C('GL_BOOL_VEC3',0x8B58) +GL_BOOL_VEC4=_C('GL_BOOL_VEC4',0x8B59) +GL_BUFFER_SIZE=_C('GL_BUFFER_SIZE',0x8764) +GL_BUFFER_USAGE=_C('GL_BUFFER_USAGE',0x8765) +GL_BYTE=_C('GL_BYTE',0x1400) +GL_CCW=_C('GL_CCW',0x0901) +GL_CLAMP_TO_EDGE=_C('GL_CLAMP_TO_EDGE',0x812F) +GL_COLOR_ATTACHMENT0=_C('GL_COLOR_ATTACHMENT0',0x8CE0) +GL_COLOR_BUFFER_BIT=_C('GL_COLOR_BUFFER_BIT',0x00004000) +GL_COLOR_CLEAR_VALUE=_C('GL_COLOR_CLEAR_VALUE',0x0C22) +GL_COLOR_WRITEMASK=_C('GL_COLOR_WRITEMASK',0x0C23) +GL_COMPILE_STATUS=_C('GL_COMPILE_STATUS',0x8B81) +GL_COMPRESSED_TEXTURE_FORMATS=_C('GL_COMPRESSED_TEXTURE_FORMATS',0x86A3) +GL_CONSTANT_ALPHA=_C('GL_CONSTANT_ALPHA',0x8003) +GL_CONSTANT_COLOR=_C('GL_CONSTANT_COLOR',0x8001) +GL_CULL_FACE=_C('GL_CULL_FACE',0x0B44) +GL_CULL_FACE_MODE=_C('GL_CULL_FACE_MODE',0x0B45) +GL_CURRENT_PROGRAM=_C('GL_CURRENT_PROGRAM',0x8B8D) +GL_CURRENT_VERTEX_ATTRIB=_C('GL_CURRENT_VERTEX_ATTRIB',0x8626) +GL_CW=_C('GL_CW',0x0900) +GL_DECR=_C('GL_DECR',0x1E03) +GL_DECR_WRAP=_C('GL_DECR_WRAP',0x8508) +GL_DELETE_STATUS=_C('GL_DELETE_STATUS',0x8B80) +GL_DEPTH_ATTACHMENT=_C('GL_DEPTH_ATTACHMENT',0x8D00) +GL_DEPTH_BITS=_C('GL_DEPTH_BITS',0x0D56) +GL_DEPTH_BUFFER_BIT=_C('GL_DEPTH_BUFFER_BIT',0x00000100) +GL_DEPTH_CLEAR_VALUE=_C('GL_DEPTH_CLEAR_VALUE',0x0B73) +GL_DEPTH_COMPONENT=_C('GL_DEPTH_COMPONENT',0x1902) +GL_DEPTH_COMPONENT16=_C('GL_DEPTH_COMPONENT16',0x81A5) +GL_DEPTH_FUNC=_C('GL_DEPTH_FUNC',0x0B74) +GL_DEPTH_RANGE=_C('GL_DEPTH_RANGE',0x0B70) +GL_DEPTH_TEST=_C('GL_DEPTH_TEST',0x0B71) +GL_DEPTH_WRITEMASK=_C('GL_DEPTH_WRITEMASK',0x0B72) +GL_DITHER=_C('GL_DITHER',0x0BD0) +GL_DONT_CARE=_C('GL_DONT_CARE',0x1100) +GL_DST_ALPHA=_C('GL_DST_ALPHA',0x0304) +GL_DST_COLOR=_C('GL_DST_COLOR',0x0306) +GL_DYNAMIC_DRAW=_C('GL_DYNAMIC_DRAW',0x88E8) +GL_ELEMENT_ARRAY_BUFFER=_C('GL_ELEMENT_ARRAY_BUFFER',0x8893) +GL_ELEMENT_ARRAY_BUFFER_BINDING=_C('GL_ELEMENT_ARRAY_BUFFER_BINDING',0x8895) +GL_EQUAL=_C('GL_EQUAL',0x0202) +GL_EXTENSIONS=_C('GL_EXTENSIONS',0x1F03) +GL_FALSE=_C('GL_FALSE',0) +GL_FASTEST=_C('GL_FASTEST',0x1101) +GL_FIXED=_C('GL_FIXED',0x140C) +GL_FLOAT=_C('GL_FLOAT',0x1406) +GL_FLOAT_MAT2=_C('GL_FLOAT_MAT2',0x8B5A) +GL_FLOAT_MAT3=_C('GL_FLOAT_MAT3',0x8B5B) +GL_FLOAT_MAT4=_C('GL_FLOAT_MAT4',0x8B5C) +GL_FLOAT_VEC2=_C('GL_FLOAT_VEC2',0x8B50) +GL_FLOAT_VEC3=_C('GL_FLOAT_VEC3',0x8B51) +GL_FLOAT_VEC4=_C('GL_FLOAT_VEC4',0x8B52) +GL_FRAGMENT_SHADER=_C('GL_FRAGMENT_SHADER',0x8B30) +GL_FRAMEBUFFER=_C('GL_FRAMEBUFFER',0x8D40) +GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME=_C('GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME',0x8CD1) +GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE=_C('GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE',0x8CD0) +GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE=_C('GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE',0x8CD3) +GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL=_C('GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL',0x8CD2) +GL_FRAMEBUFFER_BINDING=_C('GL_FRAMEBUFFER_BINDING',0x8CA6) +GL_FRAMEBUFFER_COMPLETE=_C('GL_FRAMEBUFFER_COMPLETE',0x8CD5) +GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT=_C('GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT',0x8CD6) +GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS=_C('GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS',0x8CD9) +GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT=_C('GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT',0x8CD7) +GL_FRAMEBUFFER_UNSUPPORTED=_C('GL_FRAMEBUFFER_UNSUPPORTED',0x8CDD) +GL_FRONT=_C('GL_FRONT',0x0404) +GL_FRONT_AND_BACK=_C('GL_FRONT_AND_BACK',0x0408) +GL_FRONT_FACE=_C('GL_FRONT_FACE',0x0B46) +GL_FUNC_ADD=_C('GL_FUNC_ADD',0x8006) +GL_FUNC_REVERSE_SUBTRACT=_C('GL_FUNC_REVERSE_SUBTRACT',0x800B) +GL_FUNC_SUBTRACT=_C('GL_FUNC_SUBTRACT',0x800A) +GL_GENERATE_MIPMAP_HINT=_C('GL_GENERATE_MIPMAP_HINT',0x8192) +GL_GEQUAL=_C('GL_GEQUAL',0x0206) +GL_GREATER=_C('GL_GREATER',0x0204) +GL_GREEN_BITS=_C('GL_GREEN_BITS',0x0D53) +GL_HIGH_FLOAT=_C('GL_HIGH_FLOAT',0x8DF2) +GL_HIGH_INT=_C('GL_HIGH_INT',0x8DF5) +GL_IMPLEMENTATION_COLOR_READ_FORMAT=_C('GL_IMPLEMENTATION_COLOR_READ_FORMAT',0x8B9B) +GL_IMPLEMENTATION_COLOR_READ_TYPE=_C('GL_IMPLEMENTATION_COLOR_READ_TYPE',0x8B9A) +GL_INCR=_C('GL_INCR',0x1E02) +GL_INCR_WRAP=_C('GL_INCR_WRAP',0x8507) +GL_INFO_LOG_LENGTH=_C('GL_INFO_LOG_LENGTH',0x8B84) +GL_INT=_C('GL_INT',0x1404) +GL_INT_VEC2=_C('GL_INT_VEC2',0x8B53) +GL_INT_VEC3=_C('GL_INT_VEC3',0x8B54) +GL_INT_VEC4=_C('GL_INT_VEC4',0x8B55) +GL_INVALID_ENUM=_C('GL_INVALID_ENUM',0x0500) +GL_INVALID_FRAMEBUFFER_OPERATION=_C('GL_INVALID_FRAMEBUFFER_OPERATION',0x0506) +GL_INVALID_OPERATION=_C('GL_INVALID_OPERATION',0x0502) +GL_INVALID_VALUE=_C('GL_INVALID_VALUE',0x0501) +GL_INVERT=_C('GL_INVERT',0x150A) +GL_KEEP=_C('GL_KEEP',0x1E00) +GL_LEQUAL=_C('GL_LEQUAL',0x0203) +GL_LESS=_C('GL_LESS',0x0201) +GL_LINEAR=_C('GL_LINEAR',0x2601) +GL_LINEAR_MIPMAP_LINEAR=_C('GL_LINEAR_MIPMAP_LINEAR',0x2703) +GL_LINEAR_MIPMAP_NEAREST=_C('GL_LINEAR_MIPMAP_NEAREST',0x2701) +GL_LINES=_C('GL_LINES',0x0001) +GL_LINE_LOOP=_C('GL_LINE_LOOP',0x0002) +GL_LINE_STRIP=_C('GL_LINE_STRIP',0x0003) +GL_LINE_WIDTH=_C('GL_LINE_WIDTH',0x0B21) +GL_LINK_STATUS=_C('GL_LINK_STATUS',0x8B82) +GL_LOW_FLOAT=_C('GL_LOW_FLOAT',0x8DF0) +GL_LOW_INT=_C('GL_LOW_INT',0x8DF3) +GL_LUMINANCE=_C('GL_LUMINANCE',0x1909) +GL_LUMINANCE_ALPHA=_C('GL_LUMINANCE_ALPHA',0x190A) +GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS=_C('GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS',0x8B4D) +GL_MAX_CUBE_MAP_TEXTURE_SIZE=_C('GL_MAX_CUBE_MAP_TEXTURE_SIZE',0x851C) +GL_MAX_FRAGMENT_UNIFORM_VECTORS=_C('GL_MAX_FRAGMENT_UNIFORM_VECTORS',0x8DFD) +GL_MAX_RENDERBUFFER_SIZE=_C('GL_MAX_RENDERBUFFER_SIZE',0x84E8) +GL_MAX_TEXTURE_IMAGE_UNITS=_C('GL_MAX_TEXTURE_IMAGE_UNITS',0x8872) +GL_MAX_TEXTURE_SIZE=_C('GL_MAX_TEXTURE_SIZE',0x0D33) +GL_MAX_VARYING_VECTORS=_C('GL_MAX_VARYING_VECTORS',0x8DFC) +GL_MAX_VERTEX_ATTRIBS=_C('GL_MAX_VERTEX_ATTRIBS',0x8869) +GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS=_C('GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS',0x8B4C) +GL_MAX_VERTEX_UNIFORM_VECTORS=_C('GL_MAX_VERTEX_UNIFORM_VECTORS',0x8DFB) +GL_MAX_VIEWPORT_DIMS=_C('GL_MAX_VIEWPORT_DIMS',0x0D3A) +GL_MEDIUM_FLOAT=_C('GL_MEDIUM_FLOAT',0x8DF1) +GL_MEDIUM_INT=_C('GL_MEDIUM_INT',0x8DF4) +GL_MIRRORED_REPEAT=_C('GL_MIRRORED_REPEAT',0x8370) +GL_NEAREST=_C('GL_NEAREST',0x2600) +GL_NEAREST_MIPMAP_LINEAR=_C('GL_NEAREST_MIPMAP_LINEAR',0x2702) +GL_NEAREST_MIPMAP_NEAREST=_C('GL_NEAREST_MIPMAP_NEAREST',0x2700) +GL_NEVER=_C('GL_NEVER',0x0200) +GL_NICEST=_C('GL_NICEST',0x1102) +GL_NONE=_C('GL_NONE',0) +GL_NOTEQUAL=_C('GL_NOTEQUAL',0x0205) +GL_NO_ERROR=_C('GL_NO_ERROR',0) +GL_NUM_COMPRESSED_TEXTURE_FORMATS=_C('GL_NUM_COMPRESSED_TEXTURE_FORMATS',0x86A2) +GL_NUM_SHADER_BINARY_FORMATS=_C('GL_NUM_SHADER_BINARY_FORMATS',0x8DF9) +GL_ONE=_C('GL_ONE',1) +GL_ONE_MINUS_CONSTANT_ALPHA=_C('GL_ONE_MINUS_CONSTANT_ALPHA',0x8004) +GL_ONE_MINUS_CONSTANT_COLOR=_C('GL_ONE_MINUS_CONSTANT_COLOR',0x8002) +GL_ONE_MINUS_DST_ALPHA=_C('GL_ONE_MINUS_DST_ALPHA',0x0305) +GL_ONE_MINUS_DST_COLOR=_C('GL_ONE_MINUS_DST_COLOR',0x0307) +GL_ONE_MINUS_SRC_ALPHA=_C('GL_ONE_MINUS_SRC_ALPHA',0x0303) +GL_ONE_MINUS_SRC_COLOR=_C('GL_ONE_MINUS_SRC_COLOR',0x0301) +GL_OUT_OF_MEMORY=_C('GL_OUT_OF_MEMORY',0x0505) +GL_PACK_ALIGNMENT=_C('GL_PACK_ALIGNMENT',0x0D05) +GL_POINTS=_C('GL_POINTS',0x0000) +GL_POLYGON_OFFSET_FACTOR=_C('GL_POLYGON_OFFSET_FACTOR',0x8038) +GL_POLYGON_OFFSET_FILL=_C('GL_POLYGON_OFFSET_FILL',0x8037) +GL_POLYGON_OFFSET_UNITS=_C('GL_POLYGON_OFFSET_UNITS',0x2A00) +GL_RED_BITS=_C('GL_RED_BITS',0x0D52) +GL_RENDERBUFFER=_C('GL_RENDERBUFFER',0x8D41) +GL_RENDERBUFFER_ALPHA_SIZE=_C('GL_RENDERBUFFER_ALPHA_SIZE',0x8D53) +GL_RENDERBUFFER_BINDING=_C('GL_RENDERBUFFER_BINDING',0x8CA7) +GL_RENDERBUFFER_BLUE_SIZE=_C('GL_RENDERBUFFER_BLUE_SIZE',0x8D52) +GL_RENDERBUFFER_DEPTH_SIZE=_C('GL_RENDERBUFFER_DEPTH_SIZE',0x8D54) +GL_RENDERBUFFER_GREEN_SIZE=_C('GL_RENDERBUFFER_GREEN_SIZE',0x8D51) +GL_RENDERBUFFER_HEIGHT=_C('GL_RENDERBUFFER_HEIGHT',0x8D43) +GL_RENDERBUFFER_INTERNAL_FORMAT=_C('GL_RENDERBUFFER_INTERNAL_FORMAT',0x8D44) +GL_RENDERBUFFER_RED_SIZE=_C('GL_RENDERBUFFER_RED_SIZE',0x8D50) +GL_RENDERBUFFER_STENCIL_SIZE=_C('GL_RENDERBUFFER_STENCIL_SIZE',0x8D55) +GL_RENDERBUFFER_WIDTH=_C('GL_RENDERBUFFER_WIDTH',0x8D42) +GL_RENDERER=_C('GL_RENDERER',0x1F01) +GL_REPEAT=_C('GL_REPEAT',0x2901) +GL_REPLACE=_C('GL_REPLACE',0x1E01) +GL_RGB=_C('GL_RGB',0x1907) +GL_RGB565=_C('GL_RGB565',0x8D62) +GL_RGB5_A1=_C('GL_RGB5_A1',0x8057) +GL_RGBA=_C('GL_RGBA',0x1908) +GL_RGBA4=_C('GL_RGBA4',0x8056) +GL_SAMPLER_2D=_C('GL_SAMPLER_2D',0x8B5E) +GL_SAMPLER_CUBE=_C('GL_SAMPLER_CUBE',0x8B60) +GL_SAMPLES=_C('GL_SAMPLES',0x80A9) +GL_SAMPLE_ALPHA_TO_COVERAGE=_C('GL_SAMPLE_ALPHA_TO_COVERAGE',0x809E) +GL_SAMPLE_BUFFERS=_C('GL_SAMPLE_BUFFERS',0x80A8) +GL_SAMPLE_COVERAGE=_C('GL_SAMPLE_COVERAGE',0x80A0) +GL_SAMPLE_COVERAGE_INVERT=_C('GL_SAMPLE_COVERAGE_INVERT',0x80AB) +GL_SAMPLE_COVERAGE_VALUE=_C('GL_SAMPLE_COVERAGE_VALUE',0x80AA) +GL_SCISSOR_BOX=_C('GL_SCISSOR_BOX',0x0C10) +GL_SCISSOR_TEST=_C('GL_SCISSOR_TEST',0x0C11) +GL_SHADER_BINARY_FORMATS=_C('GL_SHADER_BINARY_FORMATS',0x8DF8) +GL_SHADER_COMPILER=_C('GL_SHADER_COMPILER',0x8DFA) +GL_SHADER_SOURCE_LENGTH=_C('GL_SHADER_SOURCE_LENGTH',0x8B88) +GL_SHADER_TYPE=_C('GL_SHADER_TYPE',0x8B4F) +GL_SHADING_LANGUAGE_VERSION=_C('GL_SHADING_LANGUAGE_VERSION',0x8B8C) +GL_SHORT=_C('GL_SHORT',0x1402) +GL_SRC_ALPHA=_C('GL_SRC_ALPHA',0x0302) +GL_SRC_ALPHA_SATURATE=_C('GL_SRC_ALPHA_SATURATE',0x0308) +GL_SRC_COLOR=_C('GL_SRC_COLOR',0x0300) +GL_STATIC_DRAW=_C('GL_STATIC_DRAW',0x88E4) +GL_STENCIL_ATTACHMENT=_C('GL_STENCIL_ATTACHMENT',0x8D20) +GL_STENCIL_BACK_FAIL=_C('GL_STENCIL_BACK_FAIL',0x8801) +GL_STENCIL_BACK_FUNC=_C('GL_STENCIL_BACK_FUNC',0x8800) +GL_STENCIL_BACK_PASS_DEPTH_FAIL=_C('GL_STENCIL_BACK_PASS_DEPTH_FAIL',0x8802) +GL_STENCIL_BACK_PASS_DEPTH_PASS=_C('GL_STENCIL_BACK_PASS_DEPTH_PASS',0x8803) +GL_STENCIL_BACK_REF=_C('GL_STENCIL_BACK_REF',0x8CA3) +GL_STENCIL_BACK_VALUE_MASK=_C('GL_STENCIL_BACK_VALUE_MASK',0x8CA4) +GL_STENCIL_BACK_WRITEMASK=_C('GL_STENCIL_BACK_WRITEMASK',0x8CA5) +GL_STENCIL_BITS=_C('GL_STENCIL_BITS',0x0D57) +GL_STENCIL_BUFFER_BIT=_C('GL_STENCIL_BUFFER_BIT',0x00000400) +GL_STENCIL_CLEAR_VALUE=_C('GL_STENCIL_CLEAR_VALUE',0x0B91) +GL_STENCIL_FAIL=_C('GL_STENCIL_FAIL',0x0B94) +GL_STENCIL_FUNC=_C('GL_STENCIL_FUNC',0x0B92) +GL_STENCIL_INDEX8=_C('GL_STENCIL_INDEX8',0x8D48) +GL_STENCIL_PASS_DEPTH_FAIL=_C('GL_STENCIL_PASS_DEPTH_FAIL',0x0B95) +GL_STENCIL_PASS_DEPTH_PASS=_C('GL_STENCIL_PASS_DEPTH_PASS',0x0B96) +GL_STENCIL_REF=_C('GL_STENCIL_REF',0x0B97) +GL_STENCIL_TEST=_C('GL_STENCIL_TEST',0x0B90) +GL_STENCIL_VALUE_MASK=_C('GL_STENCIL_VALUE_MASK',0x0B93) +GL_STENCIL_WRITEMASK=_C('GL_STENCIL_WRITEMASK',0x0B98) +GL_STREAM_DRAW=_C('GL_STREAM_DRAW',0x88E0) +GL_SUBPIXEL_BITS=_C('GL_SUBPIXEL_BITS',0x0D50) +GL_TEXTURE=_C('GL_TEXTURE',0x1702) +GL_TEXTURE0=_C('GL_TEXTURE0',0x84C0) +GL_TEXTURE1=_C('GL_TEXTURE1',0x84C1) +GL_TEXTURE10=_C('GL_TEXTURE10',0x84CA) +GL_TEXTURE11=_C('GL_TEXTURE11',0x84CB) +GL_TEXTURE12=_C('GL_TEXTURE12',0x84CC) +GL_TEXTURE13=_C('GL_TEXTURE13',0x84CD) +GL_TEXTURE14=_C('GL_TEXTURE14',0x84CE) +GL_TEXTURE15=_C('GL_TEXTURE15',0x84CF) +GL_TEXTURE16=_C('GL_TEXTURE16',0x84D0) +GL_TEXTURE17=_C('GL_TEXTURE17',0x84D1) +GL_TEXTURE18=_C('GL_TEXTURE18',0x84D2) +GL_TEXTURE19=_C('GL_TEXTURE19',0x84D3) +GL_TEXTURE2=_C('GL_TEXTURE2',0x84C2) +GL_TEXTURE20=_C('GL_TEXTURE20',0x84D4) +GL_TEXTURE21=_C('GL_TEXTURE21',0x84D5) +GL_TEXTURE22=_C('GL_TEXTURE22',0x84D6) +GL_TEXTURE23=_C('GL_TEXTURE23',0x84D7) +GL_TEXTURE24=_C('GL_TEXTURE24',0x84D8) +GL_TEXTURE25=_C('GL_TEXTURE25',0x84D9) +GL_TEXTURE26=_C('GL_TEXTURE26',0x84DA) +GL_TEXTURE27=_C('GL_TEXTURE27',0x84DB) +GL_TEXTURE28=_C('GL_TEXTURE28',0x84DC) +GL_TEXTURE29=_C('GL_TEXTURE29',0x84DD) +GL_TEXTURE3=_C('GL_TEXTURE3',0x84C3) +GL_TEXTURE30=_C('GL_TEXTURE30',0x84DE) +GL_TEXTURE31=_C('GL_TEXTURE31',0x84DF) +GL_TEXTURE4=_C('GL_TEXTURE4',0x84C4) +GL_TEXTURE5=_C('GL_TEXTURE5',0x84C5) +GL_TEXTURE6=_C('GL_TEXTURE6',0x84C6) +GL_TEXTURE7=_C('GL_TEXTURE7',0x84C7) +GL_TEXTURE8=_C('GL_TEXTURE8',0x84C8) +GL_TEXTURE9=_C('GL_TEXTURE9',0x84C9) +GL_TEXTURE_2D=_C('GL_TEXTURE_2D',0x0DE1) +GL_TEXTURE_BINDING_2D=_C('GL_TEXTURE_BINDING_2D',0x8069) +GL_TEXTURE_BINDING_CUBE_MAP=_C('GL_TEXTURE_BINDING_CUBE_MAP',0x8514) +GL_TEXTURE_CUBE_MAP=_C('GL_TEXTURE_CUBE_MAP',0x8513) +GL_TEXTURE_CUBE_MAP_NEGATIVE_X=_C('GL_TEXTURE_CUBE_MAP_NEGATIVE_X',0x8516) +GL_TEXTURE_CUBE_MAP_NEGATIVE_Y=_C('GL_TEXTURE_CUBE_MAP_NEGATIVE_Y',0x8518) +GL_TEXTURE_CUBE_MAP_NEGATIVE_Z=_C('GL_TEXTURE_CUBE_MAP_NEGATIVE_Z',0x851A) +GL_TEXTURE_CUBE_MAP_POSITIVE_X=_C('GL_TEXTURE_CUBE_MAP_POSITIVE_X',0x8515) +GL_TEXTURE_CUBE_MAP_POSITIVE_Y=_C('GL_TEXTURE_CUBE_MAP_POSITIVE_Y',0x8517) +GL_TEXTURE_CUBE_MAP_POSITIVE_Z=_C('GL_TEXTURE_CUBE_MAP_POSITIVE_Z',0x8519) +GL_TEXTURE_MAG_FILTER=_C('GL_TEXTURE_MAG_FILTER',0x2800) +GL_TEXTURE_MIN_FILTER=_C('GL_TEXTURE_MIN_FILTER',0x2801) +GL_TEXTURE_WRAP_S=_C('GL_TEXTURE_WRAP_S',0x2802) +GL_TEXTURE_WRAP_T=_C('GL_TEXTURE_WRAP_T',0x2803) +GL_TRIANGLES=_C('GL_TRIANGLES',0x0004) +GL_TRIANGLE_FAN=_C('GL_TRIANGLE_FAN',0x0006) +GL_TRIANGLE_STRIP=_C('GL_TRIANGLE_STRIP',0x0005) +GL_TRUE=_C('GL_TRUE',1) +GL_UNPACK_ALIGNMENT=_C('GL_UNPACK_ALIGNMENT',0x0CF5) +GL_UNSIGNED_BYTE=_C('GL_UNSIGNED_BYTE',0x1401) +GL_UNSIGNED_INT=_C('GL_UNSIGNED_INT',0x1405) +GL_UNSIGNED_SHORT=_C('GL_UNSIGNED_SHORT',0x1403) +GL_UNSIGNED_SHORT_4_4_4_4=_C('GL_UNSIGNED_SHORT_4_4_4_4',0x8033) +GL_UNSIGNED_SHORT_5_5_5_1=_C('GL_UNSIGNED_SHORT_5_5_5_1',0x8034) +GL_UNSIGNED_SHORT_5_6_5=_C('GL_UNSIGNED_SHORT_5_6_5',0x8363) +GL_VALIDATE_STATUS=_C('GL_VALIDATE_STATUS',0x8B83) +GL_VENDOR=_C('GL_VENDOR',0x1F00) +GL_VERSION=_C('GL_VERSION',0x1F02) +GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING=_C('GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING',0x889F) +GL_VERTEX_ATTRIB_ARRAY_ENABLED=_C('GL_VERTEX_ATTRIB_ARRAY_ENABLED',0x8622) +GL_VERTEX_ATTRIB_ARRAY_NORMALIZED=_C('GL_VERTEX_ATTRIB_ARRAY_NORMALIZED',0x886A) +GL_VERTEX_ATTRIB_ARRAY_POINTER=_C('GL_VERTEX_ATTRIB_ARRAY_POINTER',0x8645) +GL_VERTEX_ATTRIB_ARRAY_SIZE=_C('GL_VERTEX_ATTRIB_ARRAY_SIZE',0x8623) +GL_VERTEX_ATTRIB_ARRAY_STRIDE=_C('GL_VERTEX_ATTRIB_ARRAY_STRIDE',0x8624) +GL_VERTEX_ATTRIB_ARRAY_TYPE=_C('GL_VERTEX_ATTRIB_ARRAY_TYPE',0x8625) +GL_VERTEX_SHADER=_C('GL_VERTEX_SHADER',0x8B31) +GL_VIEWPORT=_C('GL_VIEWPORT',0x0BA2) +GL_ZERO=_C('GL_ZERO',0) +@_f +@_p.types(None,_cs.GLenum) +def glActiveTexture(texture):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint) +def glAttachShader(program,shader):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,arrays.GLcharArray) +def glBindAttribLocation(program,index,name):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint) +def glBindBuffer(target,buffer):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint) +def glBindFramebuffer(target,framebuffer):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint) +def glBindRenderbuffer(target,renderbuffer):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint) +def glBindTexture(target,texture):pass +@_f +@_p.types(None,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat) +def glBlendColor(red,green,blue,alpha):pass +@_f +@_p.types(None,_cs.GLenum) +def glBlendEquation(mode):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum) +def glBlendEquationSeparate(modeRGB,modeAlpha):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum) +def glBlendFunc(sfactor,dfactor):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLenum,_cs.GLenum) +def glBlendFuncSeparate(sfactorRGB,dfactorRGB,sfactorAlpha,dfactorAlpha):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizeiptr,ctypes.c_void_p,_cs.GLenum) +def glBufferData(target,size,data,usage):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLintptr,_cs.GLsizeiptr,ctypes.c_void_p) +def glBufferSubData(target,offset,size,data):pass +@_f +@_p.types(_cs.GLenum,_cs.GLenum) +def glCheckFramebufferStatus(target):pass +@_f +@_p.types(None,_cs.GLbitfield) +def glClear(mask):pass +@_f +@_p.types(None,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat) +def glClearColor(red,green,blue,alpha):pass +@_f +@_p.types(None,_cs.GLfloat) +def glClearDepthf(d):pass +@_f +@_p.types(None,_cs.GLint) +def glClearStencil(s):pass +@_f +@_p.types(None,_cs.GLboolean,_cs.GLboolean,_cs.GLboolean,_cs.GLboolean) +def glColorMask(red,green,blue,alpha):pass +@_f +@_p.types(None,_cs.GLuint) +def glCompileShader(shader):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLint,_cs.GLenum,_cs.GLsizei,_cs.GLsizei,_cs.GLint,_cs.GLsizei,ctypes.c_void_p) +def glCompressedTexImage2D(target,level,internalformat,width,height,border,imageSize,data):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLsizei,_cs.GLenum,_cs.GLsizei,ctypes.c_void_p) +def glCompressedTexSubImage2D(target,level,xoffset,yoffset,width,height,format,imageSize,data):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLint,_cs.GLenum,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLsizei,_cs.GLint) +def glCopyTexImage2D(target,level,internalformat,x,y,width,height,border):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLsizei) +def glCopyTexSubImage2D(target,level,xoffset,yoffset,x,y,width,height):pass +@_f +@_p.types(_cs.GLuint,) +def glCreateProgram():pass +@_f +@_p.types(_cs.GLuint,_cs.GLenum) +def glCreateShader(type):pass +@_f +@_p.types(None,_cs.GLenum) +def glCullFace(mode):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray) +def glDeleteBuffers(n,buffers):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray) +def glDeleteFramebuffers(n,framebuffers):pass +@_f +@_p.types(None,_cs.GLuint) +def glDeleteProgram(program):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray) +def glDeleteRenderbuffers(n,renderbuffers):pass +@_f +@_p.types(None,_cs.GLuint) +def glDeleteShader(shader):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray) +def glDeleteTextures(n,textures):pass +@_f +@_p.types(None,_cs.GLenum) +def glDepthFunc(func):pass +@_f +@_p.types(None,_cs.GLboolean) +def glDepthMask(flag):pass +@_f +@_p.types(None,_cs.GLfloat,_cs.GLfloat) +def glDepthRangef(n,f):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint) +def glDetachShader(program,shader):pass +@_f +@_p.types(None,_cs.GLenum) +def glDisable(cap):pass +@_f +@_p.types(None,_cs.GLuint) +def glDisableVertexAttribArray(index):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLint,_cs.GLsizei) +def glDrawArrays(mode,first,count):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizei,_cs.GLenum,ctypes.c_void_p) +def glDrawElements(mode,count,type,indices):pass +@_f +@_p.types(None,_cs.GLenum) +def glEnable(cap):pass +@_f +@_p.types(None,_cs.GLuint) +def glEnableVertexAttribArray(index):pass +@_f +@_p.types(None,) +def glFinish():pass +@_f +@_p.types(None,) +def glFlush():pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLenum,_cs.GLuint) +def glFramebufferRenderbuffer(target,attachment,renderbuffertarget,renderbuffer):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLenum,_cs.GLuint,_cs.GLint) +def glFramebufferTexture2D(target,attachment,textarget,texture,level):pass +@_f +@_p.types(None,_cs.GLenum) +def glFrontFace(mode):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray) +def glGenBuffers(n,buffers):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray) +def glGenFramebuffers(n,framebuffers):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray) +def glGenRenderbuffers(n,renderbuffers):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray) +def glGenTextures(n,textures):pass +@_f +@_p.types(None,_cs.GLenum) +def glGenerateMipmap(target):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLsizei,arrays.GLsizeiArray,arrays.GLintArray,arrays.GLuintArray,arrays.GLcharArray) +def glGetActiveAttrib(program,index,bufSize,length,size,type,name):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLsizei,arrays.GLsizeiArray,arrays.GLintArray,arrays.GLuintArray,arrays.GLcharArray) +def glGetActiveUniform(program,index,bufSize,length,size,type,name):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizei,arrays.GLsizeiArray,arrays.GLuintArray) +def glGetAttachedShaders(program,maxCount,count,shaders):pass +@_f +@_p.types(_cs.GLint,_cs.GLuint,arrays.GLcharArray) +def glGetAttribLocation(program,name):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLbooleanArray) +def glGetBooleanv(pname,data):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLintArray) +def glGetBufferParameteriv(target,pname,params):pass +@_f +@_p.types(_cs.GLenum,) +def glGetError():pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLfloatArray) +def glGetFloatv(pname,data):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLenum,arrays.GLintArray) +def glGetFramebufferAttachmentParameteriv(target,attachment,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLintArray) +def glGetIntegerv(pname,data):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizei,arrays.GLsizeiArray,arrays.GLcharArray) +def glGetProgramInfoLog(program,bufSize,length,infoLog):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLintArray) +def glGetProgramiv(program,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLintArray) +def glGetRenderbufferParameteriv(target,pname,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizei,arrays.GLsizeiArray,arrays.GLcharArray) +def glGetShaderInfoLog(shader,bufSize,length,infoLog):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLintArray,arrays.GLintArray) +def glGetShaderPrecisionFormat(shadertype,precisiontype,range,precision):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizei,arrays.GLsizeiArray,arrays.GLcharArray) +def glGetShaderSource(shader,bufSize,length,source):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLintArray) +def glGetShaderiv(shader,pname,params):pass +@_f +@_p.types(arrays.GLubyteArray,_cs.GLenum) +def glGetString(name):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLfloatArray) +def glGetTexParameterfv(target,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLintArray) +def glGetTexParameteriv(target,pname,params):pass +@_f +@_p.types(_cs.GLint,_cs.GLuint,arrays.GLcharArray) +def glGetUniformLocation(program,name):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,arrays.GLfloatArray) +def glGetUniformfv(program,location,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,arrays.GLintArray) +def glGetUniformiv(program,location,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLvoidpArray) +def glGetVertexAttribPointerv(index,pname,pointer):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLfloatArray) +def glGetVertexAttribfv(index,pname,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLintArray) +def glGetVertexAttribiv(index,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum) +def glHint(target,mode):pass +@_f +@_p.types(_cs.GLboolean,_cs.GLuint) +def glIsBuffer(buffer):pass +@_f +@_p.types(_cs.GLboolean,_cs.GLenum) +def glIsEnabled(cap):pass +@_f +@_p.types(_cs.GLboolean,_cs.GLuint) +def glIsFramebuffer(framebuffer):pass +@_f +@_p.types(_cs.GLboolean,_cs.GLuint) +def glIsProgram(program):pass +@_f +@_p.types(_cs.GLboolean,_cs.GLuint) +def glIsRenderbuffer(renderbuffer):pass +@_f +@_p.types(_cs.GLboolean,_cs.GLuint) +def glIsShader(shader):pass +@_f +@_p.types(_cs.GLboolean,_cs.GLuint) +def glIsTexture(texture):pass +@_f +@_p.types(None,_cs.GLfloat) +def glLineWidth(width):pass +@_f +@_p.types(None,_cs.GLuint) +def glLinkProgram(program):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLint) +def glPixelStorei(pname,param):pass +@_f +@_p.types(None,_cs.GLfloat,_cs.GLfloat) +def glPolygonOffset(factor,units):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLsizei,_cs.GLenum,_cs.GLenum,ctypes.c_void_p) +def glReadPixels(x,y,width,height,format,type,pixels):pass +@_f +@_p.types(None,) +def glReleaseShaderCompiler():pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLsizei,_cs.GLsizei) +def glRenderbufferStorage(target,internalformat,width,height):pass +@_f +@_p.types(None,_cs.GLfloat,_cs.GLboolean) +def glSampleCoverage(value,invert):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLsizei) +def glScissor(x,y,width,height):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray,_cs.GLenum,ctypes.c_void_p,_cs.GLsizei) +def glShaderBinary(count,shaders,binaryformat,binary,length):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizei,ctypes.POINTER( ctypes.POINTER( _cs.GLchar )),arrays.GLintArray) +def glShaderSource(shader,count,string,length):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLint,_cs.GLuint) +def glStencilFunc(func,ref,mask):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLint,_cs.GLuint) +def glStencilFuncSeparate(face,func,ref,mask):pass +@_f +@_p.types(None,_cs.GLuint) +def glStencilMask(mask):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint) +def glStencilMaskSeparate(face,mask):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLenum) +def glStencilOp(fail,zfail,zpass):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLenum,_cs.GLenum) +def glStencilOpSeparate(face,sfail,dpfail,dppass):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLsizei,_cs.GLint,_cs.GLenum,_cs.GLenum,ctypes.c_void_p) +def glTexImage2D(target,level,internalformat,width,height,border,format,type,pixels):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLfloat) +def glTexParameterf(target,pname,param):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLfloatArray) +def glTexParameterfv(target,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLint) +def glTexParameteri(target,pname,param):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLintArray) +def glTexParameteriv(target,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLsizei,_cs.GLenum,_cs.GLenum,ctypes.c_void_p) +def glTexSubImage2D(target,level,xoffset,yoffset,width,height,format,type,pixels):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLfloat) +def glUniform1f(location,v0):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLsizei,arrays.GLfloatArray) +def glUniform1fv(location,count,value):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLint) +def glUniform1i(location,v0):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLsizei,arrays.GLintArray) +def glUniform1iv(location,count,value):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLfloat,_cs.GLfloat) +def glUniform2f(location,v0,v1):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLsizei,arrays.GLfloatArray) +def glUniform2fv(location,count,value):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLint,_cs.GLint) +def glUniform2i(location,v0,v1):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLsizei,arrays.GLintArray) +def glUniform2iv(location,count,value):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat) +def glUniform3f(location,v0,v1,v2):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLsizei,arrays.GLfloatArray) +def glUniform3fv(location,count,value):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint) +def glUniform3i(location,v0,v1,v2):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLsizei,arrays.GLintArray) +def glUniform3iv(location,count,value):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat) +def glUniform4f(location,v0,v1,v2,v3):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLsizei,arrays.GLfloatArray) +def glUniform4fv(location,count,value):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint) +def glUniform4i(location,v0,v1,v2,v3):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLsizei,arrays.GLintArray) +def glUniform4iv(location,count,value):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLsizei,_cs.GLboolean,arrays.GLfloatArray) +def glUniformMatrix2fv(location,count,transpose,value):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLsizei,_cs.GLboolean,arrays.GLfloatArray) +def glUniformMatrix3fv(location,count,transpose,value):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLsizei,_cs.GLboolean,arrays.GLfloatArray) +def glUniformMatrix4fv(location,count,transpose,value):pass +@_f +@_p.types(None,_cs.GLuint) +def glUseProgram(program):pass +@_f +@_p.types(None,_cs.GLuint) +def glValidateProgram(program):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLfloat) +def glVertexAttrib1f(index,x):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLfloatArray) +def glVertexAttrib1fv(index,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLfloat,_cs.GLfloat) +def glVertexAttrib2f(index,x,y):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLfloatArray) +def glVertexAttrib2fv(index,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat) +def glVertexAttrib3f(index,x,y,z):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLfloatArray) +def glVertexAttrib3fv(index,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat) +def glVertexAttrib4f(index,x,y,z,w):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLfloatArray) +def glVertexAttrib4fv(index,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLenum,_cs.GLboolean,_cs.GLsizei,ctypes.c_void_p) +def glVertexAttribPointer(index,size,type,normalized,stride,pointer):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLsizei) +def glViewport(x,y,width,height):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/VERSION/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/VERSION/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/VERSION/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/VERSION/__pycache__/GLES2_2_0.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/VERSION/__pycache__/GLES2_2_0.cpython-312.pyc new file mode 100644 index 00000000..a13021de Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/VERSION/__pycache__/GLES2_2_0.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/VERSION/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/VERSION/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..777a15d0 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/VERSION/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/VIV/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/VIV/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/VIV/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/VIV/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/VIV/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..d1db2d56 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/VIV/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/VIV/__pycache__/shader_binary.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/VIV/__pycache__/shader_binary.cpython-312.pyc new file mode 100644 index 00000000..efb2d5d4 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/VIV/__pycache__/shader_binary.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/VIV/shader_binary.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/VIV/shader_binary.py new file mode 100644 index 00000000..a51abbe1 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/VIV/shader_binary.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES2 import _types as _cs +# End users want this... +from OpenGL.raw.GLES2._types import * +from OpenGL.raw.GLES2 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES2_VIV_shader_binary' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES2,'GLES2_VIV_shader_binary',error_checker=_errors._error_checker) +GL_SHADER_BINARY_VIV=_C('GL_SHADER_BINARY_VIV',0x8FC4) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..70721153 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/__pycache__/_errors.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/__pycache__/_errors.cpython-312.pyc new file mode 100644 index 00000000..3a76abe4 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/__pycache__/_errors.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/__pycache__/_glgets.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/__pycache__/_glgets.cpython-312.pyc new file mode 100644 index 00000000..acd1c033 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/__pycache__/_glgets.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/__pycache__/_types.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/__pycache__/_types.cpython-312.pyc new file mode 100644 index 00000000..3c1ebf96 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/__pycache__/_types.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/_errors.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/_errors.py new file mode 100644 index 00000000..2a606210 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/_errors.py @@ -0,0 +1,7 @@ +from OpenGL.platform import PLATFORM as _p +from OpenGL.error import _ErrorChecker +if _ErrorChecker: + _error_checker = _ErrorChecker( _p, _p.GLES2.glGetError ) +else: + _error_checker = None + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/_glgets.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/_glgets.py new file mode 100644 index 00000000..f7bcc317 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/_glgets.py @@ -0,0 +1,2290 @@ +"""glGet* auto-generation of output arrays (DO NOT EDIT, AUTOGENERATED)""" +try: + from OpenGL.raw.GL._lookupint import LookupInt as _L +except ImportError: + def _L(*args): + raise RuntimeError( "Need to define a lookupint for this api" ) +_glget_size_mapping = _m = {} +# _m[0x8892] = TODO # GL_ARRAY_BUFFER +# _m[0x92C0] = TODO # GL_ATOMIC_COUNTER_BUFFER +# _m[0x8777] = TODO # GL_BUMP_NUM_TEX_UNITS_ATI +# _m[0x8775] = TODO # GL_BUMP_ROT_MATRIX_ATI +# _m[0x8776] = TODO # GL_BUMP_ROT_MATRIX_SIZE_ATI +# _m[0x8778] = TODO # GL_BUMP_TEX_UNITS_ATI +# _m[0x0A00] = TODO # GL_COEFF +# _m[0x8576] = TODO # GL_CONSTANT +# _m[0x8095] = TODO # GL_DETAIL_TEXTURE_2D_SGIS +# _m[0x809C] = TODO # GL_DETAIL_TEXTURE_FUNC_POINTS_SGIS +# _m[0x809A] = TODO # GL_DETAIL_TEXTURE_LEVEL_SGIS +# _m[0x809B] = TODO # GL_DETAIL_TEXTURE_MODE_SGIS +# _m[0x9599] = TODO # GL_DEVICE_LUID_EXT +# _m[0x959A] = TODO # GL_DEVICE_NODE_MASK_EXT +# _m[0x9597] = TODO # GL_DEVICE_UUID_EXT +# _m[0x90EE] = TODO # GL_DISPATCH_INDIRECT_BUFFER +# _m[0x0A02] = TODO # GL_DOMAIN +# _m[0x8F3F] = TODO # GL_DRAW_INDIRECT_BUFFER +# _m[0x9598] = TODO # GL_DRIVER_UUID_EXT +# _m[0x8124] = TODO # GL_DUAL_TEXTURE_SELECT_SGIS +# _m[0x8893] = TODO # GL_ELEMENT_ARRAY_BUFFER +# _m[0x86C0] = TODO # GL_EVAL_2D_NV +# _m[0x86C1] = TODO # GL_EVAL_TRIANGULAR_2D_NV +# _m[0x2400] = TODO # GL_EYE_LINEAR +# _m[0x8210] = TODO # GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING_EXT +# _m[0x8211] = TODO # GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE_EXT +# _m[0x8DA7] = TODO # GL_FRAMEBUFFER_ATTACHMENT_LAYERED_ARB +# _m[0x8DA7] = TODO # GL_FRAMEBUFFER_ATTACHMENT_LAYERED_EXT +# _m[0x8DA7] = TODO # GL_FRAMEBUFFER_ATTACHMENT_LAYERED_OES +# _m[0x8CD1] = TODO # GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT +# _m[0x8CD1] = TODO # GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_OES +# _m[0x8CD0] = TODO # GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_EXT +# _m[0x8CD0] = TODO # GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_OES +# _m[0x8CD4] = TODO # GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_EXT +# _m[0x8CD4] = TODO # GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_OES +# _m[0x8CD3] = TODO # GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_EXT +# _m[0x8CD3] = TODO # GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_OES +# _m[0x8CD4] = TODO # GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER_EXT +# _m[0x8CD2] = TODO # GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_EXT +# _m[0x8CD2] = TODO # GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_OES +# _m[0x8191] = TODO # GL_GENERATE_MIPMAP_SGIS +# _m[0x8917] = TODO # GL_GEOMETRY_INPUT_TYPE +# _m[0x8918] = TODO # GL_GEOMETRY_OUTPUT_TYPE +# _m[0x8916] = TODO # GL_GEOMETRY_VERTICES_OUT +# _m[0x815E] = TODO # GL_IMAGE_CUBIC_WEIGHT_HP +# _m[0x815C] = TODO # GL_IMAGE_MAG_FILTER_HP +# _m[0x815D] = TODO # GL_IMAGE_MIN_FILTER_HP +# _m[0x8159] = TODO # GL_IMAGE_ROTATE_ANGLE_HP +# _m[0x815A] = TODO # GL_IMAGE_ROTATE_ORIGIN_X_HP +# _m[0x815B] = TODO # GL_IMAGE_ROTATE_ORIGIN_Y_HP +# _m[0x8155] = TODO # GL_IMAGE_SCALE_X_HP +# _m[0x8156] = TODO # GL_IMAGE_SCALE_Y_HP +# _m[0x8157] = TODO # GL_IMAGE_TRANSLATE_X_HP +# _m[0x8158] = TODO # GL_IMAGE_TRANSLATE_Y_HP +# _m[0x8182] = TODO # GL_LIST_PRIORITY_SGIX +# _m[0] = TODO # GL_NONE +# _m[0x9596] = TODO # GL_NUM_DEVICE_UUIDS_EXT +# _m[0x2401] = TODO # GL_OBJECT_LINEAR +# _m[0x0A01] = TODO # GL_ORDER +# _m[0x85A0] = TODO # GL_PACK_SUBSAMPLE_RATE_SGIX +# _m[0x80EE] = TODO # GL_PARAMETER_BUFFER +# _m[0x908A] = TODO # GL_PATH_OBJECT_BOUNDING_BOX_NV +# _m[0x88EB] = TODO # GL_PIXEL_PACK_BUFFER +# _m[0x88EC] = TODO # GL_PIXEL_UNPACK_BUFFER +# _m[0x8063] = TODO # GL_PROXY_TEXTURE_1D +# _m[0x8C19] = TODO # GL_PROXY_TEXTURE_1D_ARRAY +# _m[0x8C19] = TODO # GL_PROXY_TEXTURE_1D_ARRAY_EXT +# _m[0x8063] = TODO # GL_PROXY_TEXTURE_1D_EXT +# _m[0x8064] = TODO # GL_PROXY_TEXTURE_2D +# _m[0x8C1B] = TODO # GL_PROXY_TEXTURE_2D_ARRAY +# _m[0x8C1B] = TODO # GL_PROXY_TEXTURE_2D_ARRAY_EXT +# _m[0x8064] = TODO # GL_PROXY_TEXTURE_2D_EXT +# _m[0x9101] = TODO # GL_PROXY_TEXTURE_2D_MULTISAMPLE +# _m[0x9103] = TODO # GL_PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY +# _m[0x8070] = TODO # GL_PROXY_TEXTURE_3D +# _m[0x8070] = TODO # GL_PROXY_TEXTURE_3D_EXT +# _m[0x8135] = TODO # GL_PROXY_TEXTURE_4D_SGIS +# _m[0x851B] = TODO # GL_PROXY_TEXTURE_CUBE_MAP +# _m[0x851B] = TODO # GL_PROXY_TEXTURE_CUBE_MAP_ARB +# _m[0x900B] = TODO # GL_PROXY_TEXTURE_CUBE_MAP_ARRAY +# _m[0x900B] = TODO # GL_PROXY_TEXTURE_CUBE_MAP_ARRAY_ARB +# _m[0x851B] = TODO # GL_PROXY_TEXTURE_CUBE_MAP_EXT +# _m[0x84F7] = TODO # GL_PROXY_TEXTURE_RECTANGLE +# _m[0x84F7] = TODO # GL_PROXY_TEXTURE_RECTANGLE_ARB +# _m[0x84F7] = TODO # GL_PROXY_TEXTURE_RECTANGLE_NV +# _m[0x8125] = TODO # GL_QUAD_TEXTURE_SELECT_SGIS +# _m[0x9192] = TODO # GL_QUERY_BUFFER +# _m[0x8D53] = TODO # GL_RENDERBUFFER_ALPHA_SIZE_EXT +# _m[0x8D53] = TODO # GL_RENDERBUFFER_ALPHA_SIZE_OES +# _m[0x8D52] = TODO # GL_RENDERBUFFER_BLUE_SIZE_EXT +# _m[0x8D52] = TODO # GL_RENDERBUFFER_BLUE_SIZE_OES +# _m[0x8D54] = TODO # GL_RENDERBUFFER_DEPTH_SIZE_EXT +# _m[0x8D54] = TODO # GL_RENDERBUFFER_DEPTH_SIZE_OES +# _m[0x8D51] = TODO # GL_RENDERBUFFER_GREEN_SIZE_EXT +# _m[0x8D51] = TODO # GL_RENDERBUFFER_GREEN_SIZE_OES +# _m[0x8D43] = TODO # GL_RENDERBUFFER_HEIGHT_EXT +# _m[0x8D43] = TODO # GL_RENDERBUFFER_HEIGHT_OES +# _m[0x8D44] = TODO # GL_RENDERBUFFER_INTERNAL_FORMAT_EXT +# _m[0x8D44] = TODO # GL_RENDERBUFFER_INTERNAL_FORMAT_OES +# _m[0x8D50] = TODO # GL_RENDERBUFFER_RED_SIZE_EXT +# _m[0x8D50] = TODO # GL_RENDERBUFFER_RED_SIZE_OES +# _m[0x8CAB] = TODO # GL_RENDERBUFFER_SAMPLES_ANGLE +# _m[0x8CAB] = TODO # GL_RENDERBUFFER_SAMPLES_APPLE +# _m[0x8CAB] = TODO # GL_RENDERBUFFER_SAMPLES_EXT +# _m[0x8CAB] = TODO # GL_RENDERBUFFER_SAMPLES_NV +# _m[0x8D55] = TODO # GL_RENDERBUFFER_STENCIL_SIZE_EXT +# _m[0x8D55] = TODO # GL_RENDERBUFFER_STENCIL_SIZE_OES +# _m[0x8D42] = TODO # GL_RENDERBUFFER_WIDTH_EXT +# _m[0x8D42] = TODO # GL_RENDERBUFFER_WIDTH_OES +# _m[0x80BF] = TODO # GL_SHADOW_AMBIENT_SGIX +# _m[0x81FB] = TODO # GL_SHARED_TEXTURE_PALETTE_EXT +# _m[0x80B0] = TODO # GL_SHARPEN_TEXTURE_FUNC_POINTS_SGIS +# _m[0x9100] = TODO # GL_TEXTURE_2D_MULTISAMPLE +# _m[0x9102] = TODO # GL_TEXTURE_2D_MULTISAMPLE_ARRAY +# _m[0x8136] = TODO # GL_TEXTURE_4DSIZE_SGIS +# _m[0x8175] = TODO # GL_TEXTURE_CLIPMAP_LOD_OFFSET_SGIX +# _m[0x1003] = TODO # GL_TEXTURE_COMPONENTS +# _m[0x9009] = TODO # GL_TEXTURE_CUBE_MAP_ARRAY_ARB +# _m[0x9009] = TODO # GL_TEXTURE_CUBE_MAP_ARRAY_EXT +# _m[0x9009] = TODO # GL_TEXTURE_CUBE_MAP_ARRAY_OES +# _m[0x8516] = TODO # GL_TEXTURE_CUBE_MAP_NEGATIVE_X +# _m[0x8518] = TODO # GL_TEXTURE_CUBE_MAP_NEGATIVE_Y +# _m[0x851A] = TODO # GL_TEXTURE_CUBE_MAP_NEGATIVE_Z +# _m[0x8515] = TODO # GL_TEXTURE_CUBE_MAP_POSITIVE_X +# _m[0x8517] = TODO # GL_TEXTURE_CUBE_MAP_POSITIVE_Y +# _m[0x8519] = TODO # GL_TEXTURE_CUBE_MAP_POSITIVE_Z +# _m[0x8147] = TODO # GL_TEXTURE_FILTER4_SIZE_SGIS +# _m[0x819D] = TODO # GL_TEXTURE_GEQUAL_R_SGIX +# _m[0x819C] = TODO # GL_TEXTURE_LEQUAL_R_SGIX +# _m[0x84FE] = TODO # GL_TEXTURE_MAX_ANISOTROPY +# _m[0x8C8E] = TODO # GL_TRANSFORM_FEEDBACK_BUFFER +# _m[0x8A11] = TODO # GL_UNIFORM_BUFFER +# _m[0x85A1] = TODO # GL_UNPACK_SUBSAMPLE_RATE_SGIX +_m[0x0D5B] = (1,) # GL_ACCUM_ALPHA_BITS +_m[0x0D5A] = (1,) # GL_ACCUM_BLUE_BITS +_m[0x0B80] = (4,) # GL_ACCUM_CLEAR_VALUE +_m[0x0D59] = (1,) # GL_ACCUM_GREEN_BITS +_m[0x0D58] = (1,) # GL_ACCUM_RED_BITS +_m[0x92D9] = (1,) # GL_ACTIVE_ATOMIC_COUNTER_BUFFERS +_m[0x8B89] = (1,) # GL_ACTIVE_ATTRIBUTES +_m[0x8B8A] = (1,) # GL_ACTIVE_ATTRIBUTE_MAX_LENGTH +_m[0x8259] = (1,) # GL_ACTIVE_PROGRAM +_m[0x92F5] = (1,) # GL_ACTIVE_RESOURCES +_m[0x8911] = (1,) # GL_ACTIVE_STENCIL_FACE_EXT +_m[0x8DE5] = (1,) # GL_ACTIVE_SUBROUTINES +_m[0x8E48] = (1,) # GL_ACTIVE_SUBROUTINE_MAX_LENGTH +_m[0x8DE6] = (1,) # GL_ACTIVE_SUBROUTINE_UNIFORMS +_m[0x8E47] = (1,) # GL_ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS +_m[0x8E49] = (1,) # GL_ACTIVE_SUBROUTINE_UNIFORM_MAX_LENGTH +_m[0x84E0] = (1,) # GL_ACTIVE_TEXTURE +_m[0x84E0] = (1,) # GL_ACTIVE_TEXTURE_ARB +_m[0x8B86] = (1,) # GL_ACTIVE_UNIFORMS +_m[0x8A36] = (1,) # GL_ACTIVE_UNIFORM_BLOCKS +_m[0x8A35] = (1,) # GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH +_m[0x8B87] = (1,) # GL_ACTIVE_UNIFORM_MAX_LENGTH +_m[0x9305] = (1,) # GL_ACTIVE_VARIABLES +_m[0x86A5] = (1,) # GL_ACTIVE_VERTEX_UNITS_ARB +_m[0x846E] = (2,) # GL_ALIASED_LINE_WIDTH_RANGE +_m[0x846D] = (2,) # GL_ALIASED_POINT_SIZE_RANGE +_m[0x0D1D] = (1,) # GL_ALPHA_BIAS +_m[0x0D55] = (1,) # GL_ALPHA_BITS +_m[0x8567] = (1,) # GL_ALPHA_MAX_CLAMP_INGR +_m[0x8563] = (1,) # GL_ALPHA_MIN_CLAMP_INGR +_m[0x0D1C] = (1,) # GL_ALPHA_SCALE +_m[0x0BC0] = (1,) # GL_ALPHA_TEST +_m[0x0BC1] = (1,) # GL_ALPHA_TEST_FUNC +_m[0x0BC1] = (1,) # GL_ALPHA_TEST_FUNC_QCOM +_m[0x0BC0] = (1,) # GL_ALPHA_TEST_QCOM +_m[0x0BC2] = (1,) # GL_ALPHA_TEST_REF +_m[0x0BC2] = (1,) # GL_ALPHA_TEST_REF_QCOM +_m[0x92BF] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_alpha_to_coverage_dither_control.txt # GL_ALPHA_TO_COVERAGE_DITHER_MODE_NV +_m[0x1200] = (4,) # GL_AMBIENT +_m[0x1602] = (4,) # GL_AMBIENT_AND_DIFFUSE +_m[0x8C2F] = (1,) # GL_ANY_SAMPLES_PASSED +_m[0x8D6A] = (1,) # GL_ANY_SAMPLES_PASSED_CONSERVATIVE +_m[0x8894] = (1,) # GL_ARRAY_BUFFER_BINDING +_m[0x8894] = (1,) # GL_ARRAY_BUFFER_BINDING_ARB +_m[0x81A9] = (1,) # GL_ARRAY_ELEMENT_LOCK_COUNT_EXT +_m[0x81A8] = (1,) # GL_ARRAY_ELEMENT_LOCK_FIRST_EXT +_m[0x8766] = (1,) # GL_ARRAY_OBJECT_BUFFER_ATI +_m[0x8767] = (1,) # GL_ARRAY_OBJECT_OFFSET_ATI +_m[0x92FB] = (1,) # GL_ARRAY_SIZE +_m[0x92FE] = (1,) # GL_ARRAY_STRIDE +_m[0x835D] = (1,) # GL_ASYNC_DRAW_PIXELS_SGIX +_m[0x832C] = (1,) # GL_ASYNC_HISTOGRAM_SGIX +_m[0x8329] = (1,) # GL_ASYNC_MARKER_SGIX +_m[0x835E] = (1,) # GL_ASYNC_READ_PIXELS_SGIX +_m[0x835C] = (1,) # GL_ASYNC_TEX_IMAGE_SGIX +_m[0x92C5] = (1,) # GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTERS +_m[0x92C6] = (1,)#TODO Is actually GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTERS # GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTER_INDICES +_m[0x92C1] = (1,) # GL_ATOMIC_COUNTER_BUFFER_BINDING +_m[0x92C4] = (1,)#TODO Is actually GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTERS # GL_ATOMIC_COUNTER_BUFFER_DATA_SIZE +_m[0x9301] = (1,) # GL_ATOMIC_COUNTER_BUFFER_INDEX +_m[0x90ED] = (1,)#TODO Is actually GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTERS # GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_COMPUTE_SHADER +_m[0x92CB] = (1,)#TODO Is actually GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTERS # GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_FRAGMENT_SHADER +_m[0x92CA] = (1,)#TODO Is actually GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTERS # GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_GEOMETRY_SHADER +_m[0x959E] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_MESH_SHADER_NV +_m[0x959F] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TASK_SHADER_NV +_m[0x92C8] = (1,)#TODO Is actually GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTERS # GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_CONTROL_SHADER +_m[0x92C9] = (1,)#TODO Is actually GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTERS # GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_EVALUATION_SHADER +_m[0x92C7] = (1,)#TODO Is actually GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTERS # GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_VERTEX_SHADER +_m[0x92C3] = (1,)#TODO Is actually GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTERS # GL_ATOMIC_COUNTER_BUFFER_SIZE +_m[0x92C2] = (1,)#TODO Is actually GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTERS # GL_ATOMIC_COUNTER_BUFFER_START +_m[0x8B85] = (1,) # GL_ATTACHED_SHADERS +_m[0x8645] = (1,) # GL_ATTRIB_ARRAY_POINTER_NV +_m[0x8623] = (1,) # GL_ATTRIB_ARRAY_SIZE_NV +_m[0x8624] = (1,) # GL_ATTRIB_ARRAY_STRIDE_NV +_m[0x8625] = (1,) # GL_ATTRIB_ARRAY_TYPE_NV +_m[0x0BB0] = (1,) # GL_ATTRIB_STACK_DEPTH +_m[0x8295] = (1,) # GL_AUTO_GENERATE_MIPMAP +_m[0x0D80] = (1,) # GL_AUTO_NORMAL +_m[0x0C00] = (1,) # GL_AUX_BUFFERS +_m[0x843A] = (1,) # GL_BINORMAL_ARRAY_EXT +_m[0x8443] = (1,) # GL_BINORMAL_ARRAY_POINTER_EXT +_m[0x8441] = (1,) # GL_BINORMAL_ARRAY_STRIDE_EXT +_m[0x8440] = (1,) # GL_BINORMAL_ARRAY_TYPE_EXT +_m[0x0BE2] = (1,) # GL_BLEND +_m[0x9285] = (1,) # GL_BLEND_ADVANCED_COHERENT_KHR +_m[0x9285] = (1,) # GL_BLEND_ADVANCED_COHERENT_NV +_m[0x8005] = (4,) # GL_BLEND_COLOR +_m[0x8005] = (4,) # GL_BLEND_COLOR_EXT +_m[0x0BE0] = (1,) # GL_BLEND_DST +_m[0x80CA] = (1,) # GL_BLEND_DST_ALPHA +_m[0x80CA] = (1,) # GL_BLEND_DST_ALPHA_EXT +_m[0x80C8] = (1,) # GL_BLEND_DST_RGB +_m[0x80C8] = (1,) # GL_BLEND_DST_RGB_EXT +_m[0x8009] = (1,) # GL_BLEND_EQUATION +_m[0x883D] = (1,) # GL_BLEND_EQUATION_ALPHA +_m[0x883D] = (1,) # GL_BLEND_EQUATION_ALPHA_EXT +_m[0x8009] = (1,) # GL_BLEND_EQUATION_EXT +_m[0x8009] = (1,) # GL_BLEND_EQUATION_RGB +_m[0x9281] = (3,) # GL_BLEND_OVERLAP_NV +_m[0x9280] = (1,) # GL_BLEND_PREMULTIPLIED_SRC_NV +_m[0x0BE1] = (1,) # GL_BLEND_SRC +_m[0x80CB] = (1,) # GL_BLEND_SRC_ALPHA +_m[0x80CB] = (1,) # GL_BLEND_SRC_ALPHA_EXT +_m[0x80C9] = (1,) # GL_BLEND_SRC_RGB +_m[0x80C9] = (1,) # GL_BLEND_SRC_RGB_EXT +_m[0x92FD] = (1,) # GL_BLOCK_INDEX +_m[0x0D1B] = (1,) # GL_BLUE_BIAS +_m[0x0D54] = (1,) # GL_BLUE_BITS +_m[0x8566] = (1,) # GL_BLUE_MAX_CLAMP_INGR +_m[0x8562] = (1,) # GL_BLUE_MIN_CLAMP_INGR +_m[0x0D1A] = (1,) # GL_BLUE_SCALE +_m[0x88BB] = (1,) # GL_BUFFER_ACCESS +_m[0x88BB] = (1,) # GL_BUFFER_ACCESS_ARB +_m[0x911F] = (1,) # GL_BUFFER_ACCESS_FLAGS +_m[0x9302] = (1,) # GL_BUFFER_BINDING +_m[0x9303] = (1,) # GL_BUFFER_DATA_SIZE +_m[0x8F1D] = (1,) # GL_BUFFER_GPU_ADDRESS_NV +_m[0x821F] = (1,) # GL_BUFFER_IMMUTABLE_STORAGE +_m[0x88BC] = (1,) # GL_BUFFER_MAPPED +_m[0x88BC] = (1,) # GL_BUFFER_MAPPED_ARB +_m[0x9120] = (1,) # GL_BUFFER_MAP_LENGTH +_m[0x9121] = (1,) # GL_BUFFER_MAP_OFFSET +_m[0x88BD] = (1,) # GL_BUFFER_MAP_POINTER +_m[0x88BD] = (1,) # GL_BUFFER_MAP_POINTER_ARB +_m[0x8764] = (1,) # GL_BUFFER_SIZE +_m[0x8764] = (1,) # GL_BUFFER_SIZE_ARB +_m[0x8220] = (1,) # GL_BUFFER_STORAGE_FLAGS +_m[0x8765] = (1,) # GL_BUFFER_USAGE +_m[0x8765] = (1,) # GL_BUFFER_USAGE_ARB +_m[0x877C] = (1,) # GL_BUMP_TARGET_ATI +_m[0x8183] = (1,) # GL_CALLIGRAPHIC_FRAGMENT_SGIX +_m[0x891B] = (1,) # GL_CLAMP_FRAGMENT_COLOR +_m[0x891B] = (1,) # GL_CLAMP_FRAGMENT_COLOR_ARB +_m[0x891C] = (1,) # GL_CLAMP_READ_COLOR +_m[0x891C] = (1,) # GL_CLAMP_READ_COLOR_ARB +_m[0x891A] = (1,) # GL_CLAMP_VERTEX_COLOR +_m[0x891A] = (1,) # GL_CLAMP_VERTEX_COLOR_ARB +_m[0x82B4] = (1,) # GL_CLEAR_BUFFER +_m[0x84E1] = (1,) # GL_CLIENT_ACTIVE_TEXTURE +_m[0x84E1] = (1,) # GL_CLIENT_ACTIVE_TEXTURE_ARB +_m[0x0BB1] = (1,) # GL_CLIENT_ATTRIB_STACK_DEPTH +_m[0x935D] = (2,) # GL_CLIP_DEPTH_MODE +_m[0x3000] = (1,) # GL_CLIP_DISTANCE0 +_m[0x3001] = (1,) # GL_CLIP_DISTANCE1 +_m[0x3002] = (1,) # GL_CLIP_DISTANCE2 +_m[0x3003] = (1,) # GL_CLIP_DISTANCE3 +_m[0x3004] = (1,) # GL_CLIP_DISTANCE4 +_m[0x3005] = (1,) # GL_CLIP_DISTANCE5 +_m[0x3006] = (1,) # GL_CLIP_DISTANCE6 +_m[0x3007] = (1,) # GL_CLIP_DISTANCE7 +_m[0x935C] = (2,) # GL_CLIP_ORIGIN +_m[0x3000] = (1,) # GL_CLIP_PLANE0 +_m[0x3001] = (1,) # GL_CLIP_PLANE1 +_m[0x3002] = (1,) # GL_CLIP_PLANE2 +_m[0x3003] = (1,) # GL_CLIP_PLANE3 +_m[0x3004] = (1,) # GL_CLIP_PLANE4 +_m[0x3005] = (1,) # GL_CLIP_PLANE5 +_m[0x80F0] = (1,) # GL_CLIP_VOLUME_CLIPPING_HINT_EXT +_m[0x8975] = (1,) # GL_COLOR_ALPHA_PAIRING_ATI +_m[0x8076] = (1,) # GL_COLOR_ARRAY +_m[0x8898] = (1,) # GL_COLOR_ARRAY_BUFFER_BINDING +_m[0x8898] = (1,) # GL_COLOR_ARRAY_BUFFER_BINDING_ARB +_m[0x8084] = (1,) # GL_COLOR_ARRAY_COUNT_EXT +_m[0x8076] = (1,) # GL_COLOR_ARRAY_EXT +_m[0x8F2D] = (1,) # GL_COLOR_ARRAY_LENGTH_NV +_m[0x83F7] = (1,) # GL_COLOR_ARRAY_PARALLEL_POINTERS_INTEL +_m[0x8090] = (1,) # GL_COLOR_ARRAY_POINTER +_m[0x8081] = (1,) # GL_COLOR_ARRAY_SIZE +_m[0x8081] = (1,) # GL_COLOR_ARRAY_SIZE_EXT +_m[0x8083] = (1,) # GL_COLOR_ARRAY_STRIDE +_m[0x8083] = (1,) # GL_COLOR_ARRAY_STRIDE_EXT +_m[0x8082] = (1,) # GL_COLOR_ARRAY_TYPE +_m[0x8082] = (1,) # GL_COLOR_ARRAY_TYPE_EXT +_m[0x8835] = (4,) # GL_COLOR_CLEAR_UNCLAMPED_VALUE_ATI +_m[0x0C22] = (4,) # GL_COLOR_CLEAR_VALUE +_m[0x8283] = (1,) # GL_COLOR_COMPONENTS +_m[0x8296] = (1,) # GL_COLOR_ENCODING +_m[0x8A0F] = (1,) # GL_COLOR_FLOAT_APPLE +_m[0x1603] = (3,) # GL_COLOR_INDEXES +_m[0x0BF2] = (1,) # GL_COLOR_LOGIC_OP +_m[0x0B57] = (1,) # GL_COLOR_MATERIAL +_m[0x0B55] = (1,) # GL_COLOR_MATERIAL_FACE +_m[0x0B56] = (1,) # GL_COLOR_MATERIAL_PARAMETER +_m[0x80B1] = (4,4) # GL_COLOR_MATRIX +_m[0x80B1] = (4,4) # GL_COLOR_MATRIX_SGI +_m[0x80B2] = (1,) # GL_COLOR_MATRIX_STACK_DEPTH +_m[0x80B2] = (1,) # GL_COLOR_MATRIX_STACK_DEPTH_SGI +_m[0x8286] = (1,) # GL_COLOR_RENDERABLE +_m[0x8E20] = (1,) # GL_COLOR_SAMPLES_NV +_m[0x8458] = (1,) # GL_COLOR_SUM +_m[0x8458] = (1,) # GL_COLOR_SUM_ARB +_m[0x854F] = (1,) # GL_COLOR_SUM_CLAMP_NV +_m[0x8458] = (1,) # GL_COLOR_SUM_EXT +_m[0x80D0] = (1,) # GL_COLOR_TABLE +_m[0x80DD] = (1,) # GL_COLOR_TABLE_ALPHA_SIZE +_m[0x80DD] = (1,) # GL_COLOR_TABLE_ALPHA_SIZE_SGI +_m[0x80D7] = (4,) # GL_COLOR_TABLE_BIAS +_m[0x80D7] = (4,) # GL_COLOR_TABLE_BIAS_SGI +_m[0x80DC] = (1,) # GL_COLOR_TABLE_BLUE_SIZE +_m[0x80DC] = (1,) # GL_COLOR_TABLE_BLUE_SIZE_SGI +_m[0x80D8] = (1,) # GL_COLOR_TABLE_FORMAT +_m[0x80D8] = (1,) # GL_COLOR_TABLE_FORMAT_SGI +_m[0x80DB] = (1,) # GL_COLOR_TABLE_GREEN_SIZE +_m[0x80DB] = (1,) # GL_COLOR_TABLE_GREEN_SIZE_SGI +_m[0x80DF] = (1,) # GL_COLOR_TABLE_INTENSITY_SIZE +_m[0x80DF] = (1,) # GL_COLOR_TABLE_INTENSITY_SIZE_SGI +_m[0x80DE] = (1,) # GL_COLOR_TABLE_LUMINANCE_SIZE +_m[0x80DE] = (1,) # GL_COLOR_TABLE_LUMINANCE_SIZE_SGI +_m[0x80DA] = (1,) # GL_COLOR_TABLE_RED_SIZE +_m[0x80DA] = (1,) # GL_COLOR_TABLE_RED_SIZE_SGI +_m[0x80D6] = (4,) # GL_COLOR_TABLE_SCALE +_m[0x80D6] = (4,) # GL_COLOR_TABLE_SCALE_SGI +_m[0x80D0] = (1,) # GL_COLOR_TABLE_SGI +_m[0x80D9] = (1,) # GL_COLOR_TABLE_WIDTH +_m[0x80D9] = (1,) # GL_COLOR_TABLE_WIDTH_SGI +_m[0x0C23] = (4,) # GL_COLOR_WRITEMASK +_m[0x8545] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/register_combiners.txt # GL_COMBINER_AB_DOT_PRODUCT_NV +_m[0x854A] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/register_combiners.txt # GL_COMBINER_AB_OUTPUT_NV +_m[0x8549] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/register_combiners.txt # GL_COMBINER_BIAS_NV +_m[0x8546] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/register_combiners.txt # GL_COMBINER_CD_DOT_PRODUCT_NV +_m[0x854B] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/register_combiners.txt # GL_COMBINER_CD_OUTPUT_NV +_m[0x8544] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/register_combiners.txt # GL_COMBINER_COMPONENT_USAGE_NV +_m[0x8542] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/register_combiners.txt # GL_COMBINER_INPUT_NV +_m[0x8543] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/register_combiners.txt # GL_COMBINER_MAPPING_NV +_m[0x8547] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/register_combiners.txt # GL_COMBINER_MUX_SUM_NV +_m[0x8548] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/register_combiners.txt # GL_COMBINER_SCALE_NV +_m[0x854C] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/register_combiners.txt # GL_COMBINER_SUM_OUTPUT_NV +_m[0x8572] = (1,) # GL_COMBINE_ALPHA +_m[0x8571] = (1,) # GL_COMBINE_RGB +_m[0x8E4B] = (1,) # GL_COMPATIBLE_SUBROUTINES +_m[0x8B81] = (1,) # GL_COMPILE_STATUS +_m[0x86A3] = (_L(0x86A2),) # GL_COMPRESSED_TEXTURE_FORMATS +_m[0x86A3] = (_L(0x86A2),) # GL_COMPRESSED_TEXTURE_FORMATS_ARB +_m[0x90FB] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/compute_program5.txt # GL_COMPUTE_PROGRAM_NV +_m[0x91B9] = (1,) # GL_COMPUTE_SHADER +_m[0x82A0] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_COMPUTE_TEXTURE +_m[0x8267] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/compute_shader.txt # GL_COMPUTE_WORK_GROUP_SIZE +_m[0x9374] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_internalformat_sample_query.txt # GL_CONFORMANT_NV +_m[0x937B] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_conservative_raster_dilate.txt # GL_CONSERVATIVE_RASTER_DILATE_GRANULARITY_NV +_m[0x9379] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_conservative_raster_dilate.txt # GL_CONSERVATIVE_RASTER_DILATE_NV +_m[0x937A] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_conservative_raster_dilate.txt # GL_CONSERVATIVE_RASTER_DILATE_RANGE_NV +_m[0x954D] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_conservative_raster_pre_snap_triangles.txt # GL_CONSERVATIVE_RASTER_MODE_NV +_m[0x1207] = (1,) # GL_CONSTANT_ATTENUATION +_m[0x852A] = (4,) # GL_CONSTANT_COLOR0_NV +_m[0x852B] = (4,) # GL_CONSTANT_COLOR1_NV +_m[0x86E5] = (3,) # GL_CONST_EYE_NV +_m[0x821E] = (1,) # GL_CONTEXT_FLAGS +_m[0x00000002] = (1,) # GL_CONTEXT_FLAG_DEBUG_BIT +_m[0x00000004] = (1,) # GL_CONTEXT_FLAG_ROBUST_ACCESS_BIT_ARB +_m[0x9126] = (1,) # GL_CONTEXT_PROFILE_MASK +_m[0x90F3] = (1,)#TODO Review http://www.opengl.org/registry/specs//KHR/robustness.txt # GL_CONTEXT_ROBUST_ACCESS +_m[0x8010] = (1,) # GL_CONVOLUTION_1D +_m[0x8010] = (1,) # GL_CONVOLUTION_1D_EXT +_m[0x8011] = (1,) # GL_CONVOLUTION_2D +_m[0x8011] = (1,) # GL_CONVOLUTION_2D_EXT +_m[0x8154] = (4,) # GL_CONVOLUTION_BORDER_COLOR +_m[0x8013] = (1,) # GL_CONVOLUTION_BORDER_MODE +_m[0x8013] = (1,) # GL_CONVOLUTION_BORDER_MODE_EXT +_m[0x8015] = (4,) # GL_CONVOLUTION_FILTER_BIAS +_m[0x8015] = (4,) # GL_CONVOLUTION_FILTER_BIAS_EXT +_m[0x8014] = (4,) # GL_CONVOLUTION_FILTER_SCALE +_m[0x8014] = (4,) # GL_CONVOLUTION_FILTER_SCALE_EXT +_m[0x8017] = (1,) # GL_CONVOLUTION_FORMAT +_m[0x8019] = (1,) # GL_CONVOLUTION_HEIGHT +_m[0x8316] = (1,) # GL_CONVOLUTION_HINT_SGIX +_m[0x8018] = (1,) # GL_CONVOLUTION_WIDTH +_m[0x8862] = (1,) # GL_COORD_REPLACE +_m[0x8F36] = (1,) # GL_COPY_READ_BUFFER +_m[0x8F37] = (1,) # GL_COPY_WRITE_BUFFER +_m[0x9332] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_framebuffer_mixed_samples.txt # GL_COVERAGE_MODULATION_NV +_m[0x9333] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_framebuffer_mixed_samples.txt # GL_COVERAGE_MODULATION_TABLE_SIZE_NV +_m[0x8ED4] = (1,) # GL_COVERAGE_SAMPLES_NV +_m[0x0B44] = (1,) # GL_CULL_FACE +_m[0x0B45] = (1,) # GL_CULL_FACE_MODE +_m[0x86E0] = (4,) # GL_CULL_MODES_NV +_m[0x81AA] = (1,) # GL_CULL_VERTEX_EXT +_m[0x81AB] = (1,) # GL_CULL_VERTEX_EYE_POSITION_EXT +_m[103050] = (1,)#TODO Review http://www.opengl.org/registry/specs//IBM/cull_vertex.txt # GL_CULL_VERTEX_IBM +_m[0x81AC] = (1,) # GL_CULL_VERTEX_OBJECT_POSITION_EXT +_m[0x8626] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/vertex_program.txt # GL_CURRENT_ATTRIB_NV +_m[0x843C] = (1,) # GL_CURRENT_BINORMAL_EXT +_m[0x0B00] = (4,) # GL_CURRENT_COLOR +_m[0x8453] = (1,) # GL_CURRENT_FOG_COORD +_m[0x8453] = (1,) # GL_CURRENT_FOG_COORDINATE +_m[0x8453] = (1,) # GL_CURRENT_FOG_COORDINATE_EXT +_m[0x0B01] = (1,) # GL_CURRENT_INDEX +_m[0x8641] = (4, 4) # GL_CURRENT_MATRIX_ARB +_m[0x8845] = (1,) # GL_CURRENT_MATRIX_INDEX_ARB +_m[0x8641] = (4, 4) # GL_CURRENT_MATRIX_NV +_m[0x8640] = (1,) # GL_CURRENT_MATRIX_STACK_DEPTH_ARB +_m[0x8640] = (1,) # GL_CURRENT_MATRIX_STACK_DEPTH_NV +_m[0x0B02] = (3,) # GL_CURRENT_NORMAL +_m[0x8865] = (1,) # GL_CURRENT_OCCLUSION_QUERY_ID_NV +_m[0x8843] = (1,) # GL_CURRENT_PALETTE_MATRIX_ARB +_m[0x8843] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/OES/OES_matrix_palette.txt # GL_CURRENT_PALETTE_MATRIX_OES +_m[0x8B8D] = (1,) # GL_CURRENT_PROGRAM +_m[0x8865] = (1,) # GL_CURRENT_QUERY +_m[0x0B04] = (4,) # GL_CURRENT_RASTER_COLOR +_m[0x0B09] = (1,) # GL_CURRENT_RASTER_DISTANCE +_m[0x0B05] = (1,) # GL_CURRENT_RASTER_INDEX +_m[0x8406] = (1,) # GL_CURRENT_RASTER_NORMAL_SGIX +_m[0x0B07] = (4,) # GL_CURRENT_RASTER_POSITION +_m[0x0B08] = (1,) # GL_CURRENT_RASTER_POSITION_VALID +_m[0x0B06] = (4,) # GL_CURRENT_RASTER_TEXTURE_COORDS +_m[0x8459] = (4,) # GL_CURRENT_SECONDARY_COLOR +_m[0x8459] = (1,) # GL_CURRENT_SECONDARY_COLOR_EXT +_m[0x843B] = (1,) # GL_CURRENT_TANGENT_EXT +_m[0x0B03] = (4,) # GL_CURRENT_TEXTURE_COORDS +_m[0x8E28] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/present_video.txt # GL_CURRENT_TIME_NV +_m[0x8626] = (4,) # GL_CURRENT_VERTEX_ATTRIB +_m[0x850B] = (1,) # GL_CURRENT_VERTEX_WEIGHT_EXT +_m[0x86A8] = (1,) # GL_CURRENT_WEIGHT_ARB +_m[0x8244] = (1,) # GL_DEBUG_CALLBACK_FUNCTION +_m[0x8245] = (1,) # GL_DEBUG_CALLBACK_USER_PARAM +_m[0x826D] = (1,) # GL_DEBUG_GROUP_STACK_DEPTH +_m[0x9145] = (1,) # GL_DEBUG_LOGGED_MESSAGES +_m[0x9145] = (1,) # GL_DEBUG_LOGGED_MESSAGES_AMD +_m[0x9145] = (1,) # GL_DEBUG_LOGGED_MESSAGES_ARB +_m[0x8243] = (1,) # GL_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH +_m[0x8243] = (1,) # GL_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH_ARB +_m[0x92E0] = (1,) # GL_DEBUG_OUTPUT +_m[0x8242] = (1,) # GL_DEBUG_OUTPUT_SYNCHRONOUS +_m[0x8196] = (1,) # GL_DEFORMATIONS_MASK_SGIX +_m[0x8B80] = (1,) # GL_DELETE_STATUS +_m[0x0D1F] = (1,) # GL_DEPTH_BIAS +_m[0x0D56] = (1,) # GL_DEPTH_BITS +_m[0x8891] = (1,) # GL_DEPTH_BOUNDS_EXT +_m[0x8890] = (1,) # GL_DEPTH_BOUNDS_TEST_EXT +_m[0x8DAF] = (1,) # GL_DEPTH_BUFFER_FLOAT_MODE_NV +_m[0x864F] = (1,) # GL_DEPTH_CLAMP +_m[0x901F] = (1,) # GL_DEPTH_CLAMP_FAR_AMD +_m[0x901E] = (1,) # GL_DEPTH_CLAMP_NEAR_AMD +_m[0x864F] = (1,) # GL_DEPTH_CLAMP_NV +_m[0x0B73] = (1,) # GL_DEPTH_CLEAR_VALUE +_m[0x8284] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_DEPTH_COMPONENTS +_m[0x0B74] = (1,) # GL_DEPTH_FUNC +_m[0x8311] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/SGIX/SGIX_depth_pass_instrument.txt # GL_DEPTH_PASS_INSTRUMENT_COUNTERS_SGIX +_m[0x8312] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/SGIX/SGIX_depth_pass_instrument.txt # GL_DEPTH_PASS_INSTRUMENT_MAX_SGIX +_m[0x0B70] = (2,) # GL_DEPTH_RANGE +_m[0x8287] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_DEPTH_RENDERABLE +_m[0x932D] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_framebuffer_mixed_samples.txt # GL_DEPTH_SAMPLES_NV +_m[0x0D1E] = (1,) # GL_DEPTH_SCALE +_m[0x90EA] = (1,) # GL_DEPTH_STENCIL_TEXTURE_MODE +_m[0x0B71] = (1,) # GL_DEPTH_TEST +_m[0x884B] = (1,) # GL_DEPTH_TEXTURE_MODE +_m[0x0B72] = (1,) # GL_DEPTH_WRITEMASK +_m[0x95AB] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_memory_attachment.txt # GL_DETACHED_BUFFERS_NV +_m[0x95A9] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_memory_attachment.txt # GL_DETACHED_MEMORY_INCARNATION_NV +_m[0x95AA] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_memory_attachment.txt # GL_DETACHED_TEXTURES_NV +_m[0x8096] = (1,) # GL_DETAIL_TEXTURE_2D_BINDING_SGIS +_m[0x1201] = (4,) # GL_DIFFUSE +_m[0x90EF] = (1,) # GL_DISPATCH_INDIRECT_BUFFER_BINDING +_m[0x8129] = (3,) # GL_DISTANCE_ATTENUATION_SGIS +_m[0x0BD0] = (1,) # GL_DITHER +_m[0x0C32] = (1,) # GL_DOUBLEBUFFER +_m[0x913E] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/IMG/IMG_framebuffer_downsample.txt # GL_DOWNSAMPLE_SCALES_IMG +_m[0x0C01] = (1,) # GL_DRAW_BUFFER +_m[0x8825] = (1,) # GL_DRAW_BUFFER0 +_m[0x8825] = (1,) # GL_DRAW_BUFFER0_ARB +_m[0x8825] = (1,) # GL_DRAW_BUFFER0_ATI +_m[0x8826] = (1,) # GL_DRAW_BUFFER1 +_m[0x882F] = (1,) # GL_DRAW_BUFFER10 +_m[0x882F] = (1,) # GL_DRAW_BUFFER10_ARB +_m[0x882F] = (1,) # GL_DRAW_BUFFER10_ATI +_m[0x8830] = (1,) # GL_DRAW_BUFFER11 +_m[0x8830] = (1,) # GL_DRAW_BUFFER11_ARB +_m[0x8830] = (1,) # GL_DRAW_BUFFER11_ATI +_m[0x8831] = (1,) # GL_DRAW_BUFFER12 +_m[0x8831] = (1,) # GL_DRAW_BUFFER12_ARB +_m[0x8831] = (1,) # GL_DRAW_BUFFER12_ATI +_m[0x8832] = (1,) # GL_DRAW_BUFFER13 +_m[0x8832] = (1,) # GL_DRAW_BUFFER13_ARB +_m[0x8832] = (1,) # GL_DRAW_BUFFER13_ATI +_m[0x8833] = (1,) # GL_DRAW_BUFFER14 +_m[0x8833] = (1,) # GL_DRAW_BUFFER14_ARB +_m[0x8833] = (1,) # GL_DRAW_BUFFER14_ATI +_m[0x8834] = (1,) # GL_DRAW_BUFFER15 +_m[0x8834] = (1,) # GL_DRAW_BUFFER15_ARB +_m[0x8834] = (1,) # GL_DRAW_BUFFER15_ATI +_m[0x8826] = (1,) # GL_DRAW_BUFFER1_ARB +_m[0x8826] = (1,) # GL_DRAW_BUFFER1_ATI +_m[0x8827] = (1,) # GL_DRAW_BUFFER2 +_m[0x8827] = (1,) # GL_DRAW_BUFFER2_ARB +_m[0x8827] = (1,) # GL_DRAW_BUFFER2_ATI +_m[0x8828] = (1,) # GL_DRAW_BUFFER3 +_m[0x8828] = (1,) # GL_DRAW_BUFFER3_ARB +_m[0x8828] = (1,) # GL_DRAW_BUFFER3_ATI +_m[0x8829] = (1,) # GL_DRAW_BUFFER4 +_m[0x8829] = (1,) # GL_DRAW_BUFFER4_ARB +_m[0x8829] = (1,) # GL_DRAW_BUFFER4_ATI +_m[0x882A] = (1,) # GL_DRAW_BUFFER5 +_m[0x882A] = (1,) # GL_DRAW_BUFFER5_ARB +_m[0x882A] = (1,) # GL_DRAW_BUFFER5_ATI +_m[0x882B] = (1,) # GL_DRAW_BUFFER6 +_m[0x882B] = (1,) # GL_DRAW_BUFFER6_ARB +_m[0x882B] = (1,) # GL_DRAW_BUFFER6_ATI +_m[0x882C] = (1,) # GL_DRAW_BUFFER7 +_m[0x882C] = (1,) # GL_DRAW_BUFFER7_ARB +_m[0x882C] = (1,) # GL_DRAW_BUFFER7_ATI +_m[0x882D] = (1,) # GL_DRAW_BUFFER8 +_m[0x882D] = (1,) # GL_DRAW_BUFFER8_ARB +_m[0x882D] = (1,) # GL_DRAW_BUFFER8_ATI +_m[0x882E] = (1,) # GL_DRAW_BUFFER9 +_m[0x882E] = (1,) # GL_DRAW_BUFFER9_ARB +_m[0x882E] = (1,) # GL_DRAW_BUFFER9_ATI +_m[0x0C01] = (1,) # GL_DRAW_BUFFER_EXT +_m[0x8CA9] = (1,) # GL_DRAW_FRAMEBUFFER +_m[0x8CA6] = (1,) # GL_DRAW_FRAMEBUFFER_BINDING +_m[0x8F43] = (1,) # GL_DRAW_INDIRECT_BUFFER_BINDING +_m[0x8716] = (1,) # GL_DS_BIAS_NV +_m[0x8710] = (1,) # GL_DS_SCALE_NV +_m[0x8717] = (1,) # GL_DT_BIAS_NV +_m[0x8711] = (1,) # GL_DT_SCALE_NV +_m[0x0B43] = (1,) # GL_EDGE_FLAG +_m[0x8079] = (1,) # GL_EDGE_FLAG_ARRAY +_m[0x889B] = (1,) # GL_EDGE_FLAG_ARRAY_BUFFER_BINDING +_m[0x889B] = (1,) # GL_EDGE_FLAG_ARRAY_BUFFER_BINDING_ARB +_m[0x808D] = (1,) # GL_EDGE_FLAG_ARRAY_COUNT_EXT +_m[0x8079] = (1,) # GL_EDGE_FLAG_ARRAY_EXT +_m[0x8F30] = (1,) # GL_EDGE_FLAG_ARRAY_LENGTH_NV +_m[0x8093] = (1,) # GL_EDGE_FLAG_ARRAY_POINTER +_m[0x808C] = (1,) # GL_EDGE_FLAG_ARRAY_STRIDE +_m[0x808C] = (1,) # GL_EDGE_FLAG_ARRAY_STRIDE_EXT +_m[0x932C] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_framebuffer_mixed_samples.txt # GL_EFFECTIVE_RASTER_SAMPLES_EXT +_m[0x8895] = (1,) # GL_ELEMENT_ARRAY_BUFFER_BINDING +_m[0x8895] = (1,) # GL_ELEMENT_ARRAY_BUFFER_BINDING_ARB +_m[0x8F33] = (1,) # GL_ELEMENT_ARRAY_LENGTH_NV +_m[0x8A0E] = (1,)#TODO Review http://www.opengl.org/registry/specs//APPLE/element_array.txt # GL_ELEMENT_ARRAY_POINTER_APPLE +_m[0x8A0D] = (1,) # GL_ELEMENT_ARRAY_TYPE_APPLE +_m[0x8769] = (1,) # GL_ELEMENT_ARRAY_TYPE_ATI +_m[0x1600] = (4,) # GL_EMISSION +_m[0x86C5] = (1,) # GL_EVAL_FRACTIONAL_TESSELLATION_NV +_m[0x86C6] = (1,) # GL_EVAL_VERTEX_ATTRIB0_NV +_m[0x86D0] = (1,) # GL_EVAL_VERTEX_ATTRIB10_NV +_m[0x86D1] = (1,) # GL_EVAL_VERTEX_ATTRIB11_NV +_m[0x86D2] = (1,) # GL_EVAL_VERTEX_ATTRIB12_NV +_m[0x86D3] = (1,) # GL_EVAL_VERTEX_ATTRIB13_NV +_m[0x86D4] = (1,) # GL_EVAL_VERTEX_ATTRIB14_NV +_m[0x86D5] = (1,) # GL_EVAL_VERTEX_ATTRIB15_NV +_m[0x86C7] = (1,) # GL_EVAL_VERTEX_ATTRIB1_NV +_m[0x86C8] = (1,) # GL_EVAL_VERTEX_ATTRIB2_NV +_m[0x86C9] = (1,) # GL_EVAL_VERTEX_ATTRIB3_NV +_m[0x86CA] = (1,) # GL_EVAL_VERTEX_ATTRIB4_NV +_m[0x86CB] = (1,) # GL_EVAL_VERTEX_ATTRIB5_NV +_m[0x86CC] = (1,) # GL_EVAL_VERTEX_ATTRIB6_NV +_m[0x86CD] = (1,) # GL_EVAL_VERTEX_ATTRIB7_NV +_m[0x86CE] = (1,) # GL_EVAL_VERTEX_ATTRIB8_NV +_m[0x86CF] = (1,) # GL_EVAL_VERTEX_ATTRIB9_NV +_m[0x1F03] = (1,) # GL_EXTENSIONS +_m[0x81F6] = (7,) # GL_EYE_LINE_SGIS +_m[0x2502] = (4,) # GL_EYE_PLANE +_m[0x81F4] = (4,) # GL_EYE_POINT_SGIS +_m[0x0DF0] = (1,) # GL_FEEDBACK_BUFFER_POINTER +_m[0x0DF1] = (1,) # GL_FEEDBACK_BUFFER_SIZE +_m[0x0DF2] = (1,) # GL_FEEDBACK_BUFFER_TYPE +_m[0x84F4] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/fence.txt # GL_FENCE_CONDITION_NV +_m[0x84F3] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/fence.txt # GL_FENCE_STATUS_NV +_m[0x8F65] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/ARM/ARM_shader_framebuffer_fetch.txt # GL_FETCH_PER_SAMPLE_ARM +_m[0x1B02] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_polygon_mode.txt # GL_FILL_NV +_m[0x829A] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_FILTER +_m[0x888D] = (4,) # GL_FLOAT_CLEAR_COLOR_VALUE_NV +_m[0x888E] = (1,) # GL_FLOAT_RGBA_MODE_NV +_m[0x0B60] = (1,) # GL_FOG +_m[0x0B66] = (4,) # GL_FOG_COLOR +_m[0x889D] = (1,) # GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING_ARB +_m[0x8456] = (1,)#TODO Review http://www.opengl.org/registry/specs//EXT/fog_coord.txt # GL_FOG_COORDINATE_ARRAY_POINTER_EXT +_m[0x8455] = (1,) # GL_FOG_COORDINATE_ARRAY_STRIDE_EXT +_m[0x8454] = (1,) # GL_FOG_COORDINATE_ARRAY_TYPE_EXT +_m[0x8457] = (1,) # GL_FOG_COORD_ARRAY +_m[0x889D] = (1,) # GL_FOG_COORD_ARRAY_BUFFER_BINDING +_m[0x8F32] = (1,) # GL_FOG_COORD_ARRAY_LENGTH_NV +_m[0x8455] = (1,) # GL_FOG_COORD_ARRAY_STRIDE +_m[0x8454] = (1,) # GL_FOG_COORD_ARRAY_TYPE +_m[0x8450] = (1,) # GL_FOG_COORD_SRC +_m[0x0B62] = (1,) # GL_FOG_DENSITY +_m[0x855A] = (1,) # GL_FOG_DISTANCE_MODE_NV +_m[0x0B64] = (1,) # GL_FOG_END +_m[0x812B] = (1,) # GL_FOG_FUNC_POINTS_SGIS +_m[0x0C54] = (1,) # GL_FOG_HINT +_m[0x0B61] = (1,) # GL_FOG_INDEX +_m[0x0B65] = (1,) # GL_FOG_MODE +_m[0x8198] = (1,) # GL_FOG_OFFSET_SGIX +_m[0x8199] = (4,) # GL_FOG_OFFSET_VALUE_SGIX +_m[0x0B63] = (1,) # GL_FOG_START +_m[0x8402] = (1,) # GL_FRAGMENT_COLOR_MATERIAL_FACE_SGIX +_m[0x8403] = (1,) # GL_FRAGMENT_COLOR_MATERIAL_PARAMETER_SGIX +_m[0x8401] = (1,) # GL_FRAGMENT_COLOR_MATERIAL_SGIX +_m[0x92DE] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_fragment_coverage_to_color.txt # GL_FRAGMENT_COVERAGE_COLOR_NV +_m[0x8E5D] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/gpu_shader5.txt # GL_FRAGMENT_INTERPOLATION_OFFSET_BITS +_m[0x840C] = (1,) # GL_FRAGMENT_LIGHT0_SGIX +_m[0x8400] = (1,) # GL_FRAGMENT_LIGHTING_SGIX +_m[0x840A] = (4,) # GL_FRAGMENT_LIGHT_MODEL_AMBIENT_SGIX +_m[0x8408] = (1,) # GL_FRAGMENT_LIGHT_MODEL_LOCAL_VIEWER_SGIX +_m[0x840B] = (1,) # GL_FRAGMENT_LIGHT_MODEL_NORMAL_INTERPOLATION_SGIX +_m[0x8409] = (1,) # GL_FRAGMENT_LIGHT_MODEL_TWO_SIDE_SGIX +_m[0x8804] = (1,) # GL_FRAGMENT_PROGRAM_ARB +_m[0x8873] = (1,) # GL_FRAGMENT_PROGRAM_BINDING_NV +_m[0x8E5D] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/gpu_program5.txt # GL_FRAGMENT_PROGRAM_INTERPOLATION_OFFSET_BITS_NV +_m[0x8870] = (1,) # GL_FRAGMENT_PROGRAM_NV +_m[0x8DA4] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/parameter_buffer_object.txt # GL_FRAGMENT_PROGRAM_PARAMETER_BUFFER_NV +_m[0x8B30] = (1,) # GL_FRAGMENT_SHADER +_m[0x8920] = (1,) # GL_FRAGMENT_SHADER_ATI +_m[0x8B8B] = (1,) # GL_FRAGMENT_SHADER_DERIVATIVE_HINT +_m[0x8B8B] = (1,) # GL_FRAGMENT_SHADER_DERIVATIVE_HINT_ARB +_m[0x8A52] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/EXT/EXT_shader_framebuffer_fetch.txt # GL_FRAGMENT_SHADER_DISCARDS_SAMPLES_EXT +_m[0x8F66] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/ARM/ARM_shader_framebuffer_fetch.txt # GL_FRAGMENT_SHADER_FRAMEBUFFER_FETCH_MRT_ARM +_m[0x829F] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_FRAGMENT_TEXTURE +_m[0x8215] = (1,) # GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE +_m[0x8214] = (1,) # GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE +_m[0x8210] = (1,) # GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING +_m[0x8211] = (1,) # GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE +_m[0x8216] = (1,) # GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE +_m[0x8213] = (1,) # GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE +_m[0x8DA7] = (1,) # GL_FRAMEBUFFER_ATTACHMENT_LAYERED +_m[0x8CD1] = (1,) # GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME +_m[0x8CD0] = (1,) # GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE +_m[0x8212] = (1,) # GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE +_m[0x8217] = (1,) # GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE +_m[0x9632] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/OVR/OVR_multiview.txt # GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_BASE_VIEW_INDEX_OVR +_m[0x8CD3] = (1,) # GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE +_m[0x8CD4] = (1,) # GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER +_m[0x8CD2] = (1,) # GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL +_m[0x9630] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/OVR/OVR_multiview.txt # GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_NUM_VIEWS_OVR +_m[0x8D6C] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/EXT/EXT_multisampled_render_to_texture.txt # GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_SAMPLES_EXT +_m[0x913F] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/IMG/IMG_framebuffer_downsample.txt # GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_SCALE_IMG +_m[0x8CA6] = (1,) # GL_FRAMEBUFFER_BINDING_EXT +_m[0x8CA6] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/OES/OES_framebuffer_object.txt # GL_FRAMEBUFFER_BINDING_OES +_m[0x828B] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_FRAMEBUFFER_BLEND +_m[0x9314] = (1,) # GL_FRAMEBUFFER_DEFAULT_FIXED_SAMPLE_LOCATIONS +_m[0x9311] = (1,) # GL_FRAMEBUFFER_DEFAULT_HEIGHT +_m[0x9312] = (1,) # GL_FRAMEBUFFER_DEFAULT_LAYERS +_m[0x9313] = (1,) # GL_FRAMEBUFFER_DEFAULT_SAMPLES +_m[0x9310] = (1,) # GL_FRAMEBUFFER_DEFAULT_WIDTH +_m[0x96A2] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/QCOM/QCOM_shader_framebuffer_fetch_noncoherent.txt # GL_FRAMEBUFFER_FETCH_NONCOHERENT_QCOM +_m[0x8289] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_FRAMEBUFFER_RENDERABLE +_m[0x828A] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_FRAMEBUFFER_RENDERABLE_LAYERED +_m[0x8DB9] = (1,) # GL_FRAMEBUFFER_SRGB +_m[0x8DBA] = (1,) # GL_FRAMEBUFFER_SRGB_CAPABLE_EXT +_m[0x8DB9] = (1,) # GL_FRAMEBUFFER_SRGB_EXT +_m[0x818C] = (1,) # GL_FRAMEZOOM_FACTOR_SGIX +_m[0x818B] = (1,) # GL_FRAMEZOOM_SGIX +_m[0x0B46] = (1,) # GL_FRONT_FACE +_m[0x8191] = (1,) # GL_GENERATE_MIPMAP +_m[0x8192] = (1,) # GL_GENERATE_MIPMAP_HINT +_m[0x8192] = (1,) # GL_GENERATE_MIPMAP_HINT_SGIS +_m[0x8DDB] = (1,) # GL_GEOMETRY_INPUT_TYPE_ARB +_m[0x8DDB] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/geometry_program4.txt # GL_GEOMETRY_INPUT_TYPE_EXT +_m[0x8917] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/EXT/EXT_geometry_shader.txt # GL_GEOMETRY_LINKED_INPUT_TYPE_EXT +_m[0x8917] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/OES/OES_geometry_shader.txt # GL_GEOMETRY_LINKED_INPUT_TYPE_OES +_m[0x8918] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/EXT/EXT_geometry_shader.txt # GL_GEOMETRY_LINKED_OUTPUT_TYPE_EXT +_m[0x8918] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/OES/OES_geometry_shader.txt # GL_GEOMETRY_LINKED_OUTPUT_TYPE_OES +_m[0x8916] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/EXT/EXT_geometry_shader.txt # GL_GEOMETRY_LINKED_VERTICES_OUT_EXT +_m[0x8916] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/OES/OES_geometry_shader.txt # GL_GEOMETRY_LINKED_VERTICES_OUT_OES +_m[0x8DDC] = (1,) # GL_GEOMETRY_OUTPUT_TYPE_ARB +_m[0x8DDC] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/geometry_program4.txt # GL_GEOMETRY_OUTPUT_TYPE_EXT +_m[0x8C26] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/geometry_program4.txt # GL_GEOMETRY_PROGRAM_NV +_m[0x8DA3] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/parameter_buffer_object.txt # GL_GEOMETRY_PROGRAM_PARAMETER_BUFFER_NV +_m[0x8DD9] = (1,) # GL_GEOMETRY_SHADER +_m[0x887F] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/gpu_shader5.txt # GL_GEOMETRY_SHADER_INVOCATIONS +_m[0x829E] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_GEOMETRY_TEXTURE +_m[0x8DDA] = (1,) # GL_GEOMETRY_VERTICES_OUT_ARB +_m[0x8DDA] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/geometry_program4.txt # GL_GEOMETRY_VERTICES_OUT_EXT +_m[0x8291] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_GET_TEXTURE_IMAGE_FORMAT +_m[0x8292] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_GET_TEXTURE_IMAGE_TYPE +_m[0x81DA] = (1,) # GL_GLOBAL_ALPHA_FACTOR_SUN +_m[0x8FBB] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/EXT/EXT_disjoint_timer_query.txt # GL_GPU_DISJOINT_EXT +_m[0x9049] = (1,) # GL_GPU_MEMORY_INFO_CURRENT_AVAILABLE_VIDMEM_NVX +_m[0x9047] = (1,) # GL_GPU_MEMORY_INFO_DEDICATED_VIDMEM_NVX +_m[0x904B] = (1,) # GL_GPU_MEMORY_INFO_EVICTED_MEMORY_NVX +_m[0x904A] = (1,) # GL_GPU_MEMORY_INFO_EVICTION_COUNT_NVX +_m[0x9048] = (1,) # GL_GPU_MEMORY_INFO_TOTAL_AVAILABLE_MEMORY_NVX +_m[0x0D19] = (1,) # GL_GREEN_BIAS +_m[0x0D53] = (1,) # GL_GREEN_BITS +_m[0x8565] = (1,) # GL_GREEN_MAX_CLAMP_INGR +_m[0x8561] = (1,) # GL_GREEN_MIN_CLAMP_INGR +_m[0x0D18] = (1,) # GL_GREEN_SCALE +_m[0x8024] = (1,) # GL_HISTOGRAM +_m[0x802B] = (1,) # GL_HISTOGRAM_ALPHA_SIZE +_m[0x802B] = (1,) # GL_HISTOGRAM_ALPHA_SIZE_EXT +_m[0x802A] = (1,) # GL_HISTOGRAM_BLUE_SIZE +_m[0x802A] = (1,) # GL_HISTOGRAM_BLUE_SIZE_EXT +_m[0x8024] = (1,) # GL_HISTOGRAM_EXT +_m[0x8027] = (1,) # GL_HISTOGRAM_FORMAT +_m[0x8027] = (1,) # GL_HISTOGRAM_FORMAT_EXT +_m[0x8029] = (1,) # GL_HISTOGRAM_GREEN_SIZE +_m[0x8029] = (1,) # GL_HISTOGRAM_GREEN_SIZE_EXT +_m[0x802C] = (1,) # GL_HISTOGRAM_LUMINANCE_SIZE +_m[0x802C] = (1,) # GL_HISTOGRAM_LUMINANCE_SIZE_EXT +_m[0x8028] = (1,) # GL_HISTOGRAM_RED_SIZE +_m[0x8028] = (1,) # GL_HISTOGRAM_RED_SIZE_EXT +_m[0x802D] = (1,) # GL_HISTOGRAM_SINK +_m[0x802D] = (1,) # GL_HISTOGRAM_SINK_EXT +_m[0x8026] = (1,) # GL_HISTOGRAM_WIDTH +_m[0x8026] = (1,) # GL_HISTOGRAM_WIDTH_EXT +_m[0x8714] = (1,) # GL_HI_BIAS_NV +_m[0x870E] = (1,) # GL_HI_SCALE_NV +_m[0x82A8] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_IMAGE_COMPATIBILITY_CLASS +_m[0x90C7] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_IMAGE_FORMAT_COMPATIBILITY_TYPE +_m[0x82A9] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_IMAGE_PIXEL_FORMAT +_m[0x82AA] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_IMAGE_PIXEL_TYPE +_m[0x82A7] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_IMAGE_TEXEL_SIZE +_m[0x8B9B] = (1,) # GL_IMPLEMENTATION_COLOR_READ_FORMAT +_m[0x8B9A] = (1,) # GL_IMPLEMENTATION_COLOR_READ_TYPE +_m[0x8077] = (1,) # GL_INDEX_ARRAY +_m[0x8899] = (1,) # GL_INDEX_ARRAY_BUFFER_BINDING +_m[0x8899] = (1,) # GL_INDEX_ARRAY_BUFFER_BINDING_ARB +_m[0x8087] = (1,) # GL_INDEX_ARRAY_COUNT_EXT +_m[0x8077] = (1,) # GL_INDEX_ARRAY_EXT +_m[0x8F2E] = (1,) # GL_INDEX_ARRAY_LENGTH_NV +_m[0x8091] = (1,) # GL_INDEX_ARRAY_POINTER +_m[0x8086] = (1,) # GL_INDEX_ARRAY_STRIDE +_m[0x8086] = (1,) # GL_INDEX_ARRAY_STRIDE_EXT +_m[0x8085] = (1,) # GL_INDEX_ARRAY_TYPE +_m[0x8085] = (1,) # GL_INDEX_ARRAY_TYPE_EXT +_m[0x0D51] = (1,) # GL_INDEX_BITS +_m[0x0C20] = (1,) # GL_INDEX_CLEAR_VALUE +_m[0x0BF1] = (1,) # GL_INDEX_LOGIC_OP +_m[0x0C30] = (1,) # GL_INDEX_MODE +_m[0x0D13] = (1,) # GL_INDEX_OFFSET +_m[0x0D12] = (1,) # GL_INDEX_SHIFT +_m[0x0C21] = (1,) # GL_INDEX_WRITEMASK +_m[0x8B84] = (1,) # GL_INFO_LOG_LENGTH +_m[0x8181] = (1,) # GL_INSTRUMENT_MEASUREMENTS_SGIX +_m[0x8980] = (1,) # GL_INTERLACE_OML +_m[0x8568] = (1,) # GL_INTERLACE_READ_INGR +_m[0x8981] = (1,) # GL_INTERLACE_READ_OML +_m[0x8094] = (1,) # GL_INTERLACE_SGIX +_m[0x8274] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_INTERNALFORMAT_ALPHA_SIZE +_m[0x827B] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_INTERNALFORMAT_ALPHA_TYPE +_m[0x8273] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_INTERNALFORMAT_BLUE_SIZE +_m[0x827A] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_INTERNALFORMAT_BLUE_TYPE +_m[0x8275] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_INTERNALFORMAT_DEPTH_SIZE +_m[0x827C] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_INTERNALFORMAT_DEPTH_TYPE +_m[0x8272] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_INTERNALFORMAT_GREEN_SIZE +_m[0x8279] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_INTERNALFORMAT_GREEN_TYPE +_m[0x8270] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_INTERNALFORMAT_PREFERRED +_m[0x8271] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_INTERNALFORMAT_RED_SIZE +_m[0x8278] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_INTERNALFORMAT_RED_TYPE +_m[0x8277] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_INTERNALFORMAT_SHARED_SIZE +_m[0x8276] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_INTERNALFORMAT_STENCIL_SIZE +_m[0x827D] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_INTERNALFORMAT_STENCIL_TYPE +_m[0x826F] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_INTERNALFORMAT_SUPPORTED +_m[0x817F] = (1,) # GL_IR_INSTRUMENT1_SGIX +_m[0x92E7] = (1,) # GL_IS_PER_PATCH +_m[0x9300] = (1,) # GL_IS_ROW_MAJOR +_m[0x825E] = (1,) # GL_LAYER_PROVOKING_VERTEX +_m[0x4000] = (1,) # GL_LIGHT0 +_m[0x4001] = (1,) # GL_LIGHT1 +_m[0x4002] = (1,) # GL_LIGHT2 +_m[0x4003] = (1,) # GL_LIGHT3 +_m[0x4004] = (1,) # GL_LIGHT4 +_m[0x4005] = (1,) # GL_LIGHT5 +_m[0x4006] = (1,) # GL_LIGHT6 +_m[0x4007] = (1,) # GL_LIGHT7 +_m[0x0B50] = (1,) # GL_LIGHTING +_m[0x8407] = (1,) # GL_LIGHT_ENV_MODE_SGIX +_m[0x0B53] = (4,) # GL_LIGHT_MODEL_AMBIENT +_m[0x81F8] = (1,) # GL_LIGHT_MODEL_COLOR_CONTROL +_m[0x81F8] = (1,) # GL_LIGHT_MODEL_COLOR_CONTROL_EXT +_m[0x0B51] = (1,) # GL_LIGHT_MODEL_LOCAL_VIEWER +_m[0x0B52] = (1,) # GL_LIGHT_MODEL_TWO_SIDE +_m[0x1208] = (1,) # GL_LINEAR_ATTENUATION +_m[0x1B01] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_polygon_mode.txt # GL_LINE_NV +_m[0x0B20] = (1,) # GL_LINE_SMOOTH +_m[0x0C52] = (1,) # GL_LINE_SMOOTH_HINT +_m[0x0B24] = (1,) # GL_LINE_STIPPLE +_m[0x0B25] = (1,) # GL_LINE_STIPPLE_PATTERN +_m[0x0B26] = (1,) # GL_LINE_STIPPLE_REPEAT +_m[0x0B21] = (1,) # GL_LINE_WIDTH +_m[0x0B23] = (1,) # GL_LINE_WIDTH_GRANULARITY +_m[0x0B22] = (2,) # GL_LINE_WIDTH_RANGE +_m[0x8B82] = (1,) # GL_LINK_STATUS +_m[0x0B32] = (1,) # GL_LIST_BASE +_m[0x0B33] = (1,) # GL_LIST_INDEX +_m[0x0B30] = (1,) # GL_LIST_MODE +_m[0x930E] = (1,) # GL_LOCATION +_m[0x930F] = (1,) # GL_LOCATION_INDEX +_m[0x0BF1] = (1,) # GL_LOGIC_OP +_m[0x0BF0] = (1,) # GL_LOGIC_OP_MODE +_m[0x8252] = (1,)#TODO Review http://www.opengl.org/registry/specs//KHR/robustness.txt # GL_LOSE_CONTEXT_ON_RESET +_m[0x8252] = (1,) # GL_LOSE_CONTEXT_ON_RESET_ARB +_m[0x8715] = (1,) # GL_LO_BIAS_NV +_m[0x870F] = (1,) # GL_LO_SCALE_NV +_m[0x8718] = (1,) # GL_MAGNITUDE_BIAS_NV +_m[0x8712] = (1,) # GL_MAGNITUDE_SCALE_NV +_m[0x821B] = (1,) # GL_MAJOR_VERSION +_m[0x8294] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_MANUAL_GENERATE_MIPMAP +_m[0x0D90] = (1,) # GL_MAP1_COLOR_4 +_m[0x0DD0] = (2,) # GL_MAP1_GRID_DOMAIN +_m[0x0DD1] = (1,) # GL_MAP1_GRID_SEGMENTS +_m[0x0D91] = (1,) # GL_MAP1_INDEX +_m[0x0D92] = (1,) # GL_MAP1_NORMAL +_m[0x0D93] = (1,) # GL_MAP1_TEXTURE_COORD_1 +_m[0x0D94] = (1,) # GL_MAP1_TEXTURE_COORD_2 +_m[0x0D95] = (1,) # GL_MAP1_TEXTURE_COORD_3 +_m[0x0D96] = (1,) # GL_MAP1_TEXTURE_COORD_4 +_m[0x0D97] = (1,) # GL_MAP1_VERTEX_3 +_m[0x0D98] = (1,) # GL_MAP1_VERTEX_4 +_m[0x8660] = (4,) # GL_MAP1_VERTEX_ATTRIB0_4_NV +_m[0x866A] = (4,) # GL_MAP1_VERTEX_ATTRIB10_4_NV +_m[0x866B] = (4,) # GL_MAP1_VERTEX_ATTRIB11_4_NV +_m[0x866C] = (4,) # GL_MAP1_VERTEX_ATTRIB12_4_NV +_m[0x866D] = (4,) # GL_MAP1_VERTEX_ATTRIB13_4_NV +_m[0x866E] = (4,) # GL_MAP1_VERTEX_ATTRIB14_4_NV +_m[0x866F] = (4,) # GL_MAP1_VERTEX_ATTRIB15_4_NV +_m[0x8661] = (4,) # GL_MAP1_VERTEX_ATTRIB1_4_NV +_m[0x8662] = (4,) # GL_MAP1_VERTEX_ATTRIB2_4_NV +_m[0x8663] = (4,) # GL_MAP1_VERTEX_ATTRIB3_4_NV +_m[0x8664] = (4,) # GL_MAP1_VERTEX_ATTRIB4_4_NV +_m[0x8665] = (4,) # GL_MAP1_VERTEX_ATTRIB5_4_NV +_m[0x8666] = (4,) # GL_MAP1_VERTEX_ATTRIB6_4_NV +_m[0x8667] = (4,) # GL_MAP1_VERTEX_ATTRIB7_4_NV +_m[0x8668] = (4,) # GL_MAP1_VERTEX_ATTRIB8_4_NV +_m[0x8669] = (4,) # GL_MAP1_VERTEX_ATTRIB9_4_NV +_m[0x0DB0] = (1,) # GL_MAP2_COLOR_4 +_m[0x0DD2] = (4,) # GL_MAP2_GRID_DOMAIN +_m[0x0DD3] = (2,) # GL_MAP2_GRID_SEGMENTS +_m[0x0DB1] = (1,) # GL_MAP2_INDEX +_m[0x0DB2] = (1,) # GL_MAP2_NORMAL +_m[0x0DB3] = (1,) # GL_MAP2_TEXTURE_COORD_1 +_m[0x0DB4] = (1,) # GL_MAP2_TEXTURE_COORD_2 +_m[0x0DB5] = (1,) # GL_MAP2_TEXTURE_COORD_3 +_m[0x0DB6] = (1,) # GL_MAP2_TEXTURE_COORD_4 +_m[0x0DB7] = (1,) # GL_MAP2_VERTEX_3 +_m[0x0DB8] = (1,) # GL_MAP2_VERTEX_4 +_m[0x8670] = (4,) # GL_MAP2_VERTEX_ATTRIB0_4_NV +_m[0x867A] = (4,) # GL_MAP2_VERTEX_ATTRIB10_4_NV +_m[0x867B] = (4,) # GL_MAP2_VERTEX_ATTRIB11_4_NV +_m[0x867C] = (4,) # GL_MAP2_VERTEX_ATTRIB12_4_NV +_m[0x867D] = (4,) # GL_MAP2_VERTEX_ATTRIB13_4_NV +_m[0x867E] = (4,) # GL_MAP2_VERTEX_ATTRIB14_4_NV +_m[0x867F] = (4,) # GL_MAP2_VERTEX_ATTRIB15_4_NV +_m[0x8671] = (4,) # GL_MAP2_VERTEX_ATTRIB1_4_NV +_m[0x8672] = (4,) # GL_MAP2_VERTEX_ATTRIB2_4_NV +_m[0x8673] = (4,) # GL_MAP2_VERTEX_ATTRIB3_4_NV +_m[0x8674] = (4,) # GL_MAP2_VERTEX_ATTRIB4_4_NV +_m[0x8675] = (4,) # GL_MAP2_VERTEX_ATTRIB5_4_NV +_m[0x8676] = (4,) # GL_MAP2_VERTEX_ATTRIB6_4_NV +_m[0x8677] = (4,) # GL_MAP2_VERTEX_ATTRIB7_4_NV +_m[0x8678] = (4,) # GL_MAP2_VERTEX_ATTRIB8_4_NV +_m[0x8679] = (4,) # GL_MAP2_VERTEX_ATTRIB9_4_NV +_m[0x86C3] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/evaluators.txt # GL_MAP_ATTRIB_U_ORDER_NV +_m[0x86C4] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/evaluators.txt # GL_MAP_ATTRIB_V_ORDER_NV +_m[0x0D10] = (1,) # GL_MAP_COLOR +_m[0x0D11] = (1,) # GL_MAP_STENCIL +_m[0x8844] = (1,) # GL_MATRIX_INDEX_ARRAY_ARB +_m[0x8B9E] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/OES/OES_matrix_palette.txt # GL_MATRIX_INDEX_ARRAY_BUFFER_BINDING_OES +_m[0x8849] = (1,) # GL_MATRIX_INDEX_ARRAY_POINTER_ARB +_m[0x8849] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/OES/OES_matrix_palette.txt # GL_MATRIX_INDEX_ARRAY_POINTER_OES +_m[0x8846] = (1,) # GL_MATRIX_INDEX_ARRAY_SIZE_ARB +_m[0x8846] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/OES/OES_matrix_palette.txt # GL_MATRIX_INDEX_ARRAY_SIZE_OES +_m[0x8848] = (1,) # GL_MATRIX_INDEX_ARRAY_STRIDE_ARB +_m[0x8848] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/OES/OES_matrix_palette.txt # GL_MATRIX_INDEX_ARRAY_STRIDE_OES +_m[0x8847] = (1,) # GL_MATRIX_INDEX_ARRAY_TYPE_ARB +_m[0x8847] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/OES/OES_matrix_palette.txt # GL_MATRIX_INDEX_ARRAY_TYPE_OES +_m[0x0BA0] = (1,) # GL_MATRIX_MODE +_m[0x8840] = (1,) # GL_MATRIX_PALETTE_ARB +_m[0x92FF] = (1,) # GL_MATRIX_STRIDE +_m[0x8073] = (1,) # GL_MAX_3D_TEXTURE_SIZE +_m[0x8073] = (1,) # GL_MAX_3D_TEXTURE_SIZE_EXT +_m[0x8138] = (1,) # GL_MAX_4D_TEXTURE_SIZE_SGIS +_m[0x8405] = (1,) # GL_MAX_ACTIVE_LIGHTS_SGIX +_m[0x88FF] = (1,) # GL_MAX_ARRAY_TEXTURE_LAYERS +_m[0x88FF] = (1,) # GL_MAX_ARRAY_TEXTURE_LAYERS_EXT +_m[0x8360] = (1,) # GL_MAX_ASYNC_DRAW_PIXELS_SGIX +_m[0x832D] = (1,) # GL_MAX_ASYNC_HISTOGRAM_SGIX +_m[0x8361] = (1,) # GL_MAX_ASYNC_READ_PIXELS_SGIX +_m[0x835F] = (1,) # GL_MAX_ASYNC_TEX_IMAGE_SGIX +_m[0x92DC] = (1,) # GL_MAX_ATOMIC_COUNTER_BUFFER_BINDINGS +_m[0x92D8] = (1,) # GL_MAX_ATOMIC_COUNTER_BUFFER_SIZE +_m[0x0D35] = (1,) # GL_MAX_ATTRIB_STACK_DEPTH +_m[0x8DED] = (1,) # GL_MAX_BINDABLE_UNIFORM_SIZE_EXT +_m[0x0D3B] = (1,) # GL_MAX_CLIENT_ATTRIB_STACK_DEPTH +_m[0x8177] = (1,) # GL_MAX_CLIPMAP_DEPTH_SGIX +_m[0x8178] = (1,) # GL_MAX_CLIPMAP_VIRTUAL_DEPTH_SGIX +_m[0x0D32] = (1,) # GL_MAX_CLIP_DISTANCES +_m[0x0D32] = (1,) # GL_MAX_CLIP_PLANES +_m[0x955F] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_shading_rate_image.txt # GL_MAX_COARSE_FRAGMENT_SAMPLES_NV +_m[0x8CDF] = (1,) # GL_MAX_COLOR_ATTACHMENTS +_m[0x8CDF] = (1,) # GL_MAX_COLOR_ATTACHMENTS_EXT +_m[0x91B3] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/AMD/AMD_framebuffer_multisample_advanced.txt # GL_MAX_COLOR_FRAMEBUFFER_SAMPLES_AMD +_m[0x91B4] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/AMD/AMD_framebuffer_multisample_advanced.txt # GL_MAX_COLOR_FRAMEBUFFER_STORAGE_SAMPLES_AMD +_m[0x80B3] = (1,) # GL_MAX_COLOR_MATRIX_STACK_DEPTH +_m[0x80B3] = (1,) # GL_MAX_COLOR_MATRIX_STACK_DEPTH_SGI +_m[0x910E] = (1,) # GL_MAX_COLOR_TEXTURE_SAMPLES +_m[0x92D7] = (1,) # GL_MAX_COMBINED_ATOMIC_COUNTERS +_m[0x92D1] = (1,) # GL_MAX_COMBINED_ATOMIC_COUNTER_BUFFERS +_m[0x82FA] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/cull_distance.txt # GL_MAX_COMBINED_CLIP_AND_CULL_DISTANCES +_m[0x8266] = (1,) # GL_MAX_COMBINED_COMPUTE_UNIFORM_COMPONENTS +_m[0x8282] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_MAX_COMBINED_DIMENSIONS +_m[0x8A33] = (1,) # GL_MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS +_m[0x8A32] = (1,) # GL_MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS +_m[0x90CF] = (1,) # GL_MAX_COMBINED_IMAGE_UNIFORMS +_m[0x8F39] = (1,) # GL_MAX_COMBINED_IMAGE_UNITS_AND_FRAGMENT_OUTPUTS +_m[0x8F39] = (1,) # GL_MAX_COMBINED_IMAGE_UNITS_AND_FRAGMENT_OUTPUTS_EXT +_m[0x8E67] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_MAX_COMBINED_MESH_UNIFORM_COMPONENTS_NV +_m[0x90DC] = (1,) # GL_MAX_COMBINED_SHADER_STORAGE_BLOCKS +_m[0x8E6F] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_MAX_COMBINED_TASK_UNIFORM_COMPONENTS_NV +_m[0x8E1E] = (1,) # GL_MAX_COMBINED_TESS_CONTROL_UNIFORM_COMPONENTS +_m[0x8E1F] = (1,) # GL_MAX_COMBINED_TESS_EVALUATION_UNIFORM_COMPONENTS +_m[0x8B4D] = (1,) # GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS +_m[0x8B4D] = (1,) # GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB +_m[0x8A2E] = (1,) # GL_MAX_COMBINED_UNIFORM_BLOCKS +_m[0x8A31] = (1,) # GL_MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS +_m[0x8265] = (1,) # GL_MAX_COMPUTE_ATOMIC_COUNTERS +_m[0x8264] = (1,) # GL_MAX_COMPUTE_ATOMIC_COUNTER_BUFFERS +_m[0x91BD] = (1,) # GL_MAX_COMPUTE_IMAGE_UNIFORMS +_m[0x90DB] = (1,) # GL_MAX_COMPUTE_SHADER_STORAGE_BLOCKS +_m[0x8262] = (1,) # GL_MAX_COMPUTE_SHARED_MEMORY_SIZE +_m[0x91BC] = (1,) # GL_MAX_COMPUTE_TEXTURE_IMAGE_UNITS +_m[0x91BB] = (1,) # GL_MAX_COMPUTE_UNIFORM_BLOCKS +_m[0x8263] = (1,) # GL_MAX_COMPUTE_UNIFORM_COMPONENTS +_m[0x9344] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/compute_variable_group_size.txt # GL_MAX_COMPUTE_VARIABLE_GROUP_INVOCATIONS_ARB +_m[0x9345] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/compute_variable_group_size.txt # GL_MAX_COMPUTE_VARIABLE_GROUP_SIZE_ARB +_m[0x91BE] = (3,) # GL_MAX_COMPUTE_WORK_GROUP_COUNT +_m[0x90EB] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/compute_shader.txt # GL_MAX_COMPUTE_WORK_GROUP_INVOCATIONS +_m[0x91BF] = (3,) # GL_MAX_COMPUTE_WORK_GROUP_SIZE +_m[0x801B] = (1,) # GL_MAX_CONVOLUTION_HEIGHT +_m[0x801A] = (1,) # GL_MAX_CONVOLUTION_WIDTH +_m[0x851C] = (1,) # GL_MAX_CUBE_MAP_TEXTURE_SIZE +_m[0x851C] = (1,) # GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB +_m[0x82F9] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/cull_distance.txt # GL_MAX_CULL_DISTANCES +_m[0x826C] = (1,) # GL_MAX_DEBUG_GROUP_STACK_DEPTH +_m[0x9144] = (1,) # GL_MAX_DEBUG_LOGGED_MESSAGES +_m[0x9144] = (1,) # GL_MAX_DEBUG_LOGGED_MESSAGES_AMD +_m[0x9144] = (1,) # GL_MAX_DEBUG_LOGGED_MESSAGES_ARB +_m[0x9143] = (1,) # GL_MAX_DEBUG_MESSAGE_LENGTH +_m[0x9143] = (1,) # GL_MAX_DEBUG_MESSAGE_LENGTH_AMD +_m[0x9143] = (1,) # GL_MAX_DEBUG_MESSAGE_LENGTH_ARB +_m[0x90D1] = (1,) # GL_MAX_DEEP_3D_TEXTURE_DEPTH_NV +_m[0x90D0] = (2,) # GL_MAX_DEEP_3D_TEXTURE_WIDTH_HEIGHT_NV +_m[0x8280] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_MAX_DEPTH +_m[0x91B5] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/AMD/AMD_framebuffer_multisample_advanced.txt # GL_MAX_DEPTH_STENCIL_FRAMEBUFFER_SAMPLES_AMD +_m[0x910F] = (1,) # GL_MAX_DEPTH_TEXTURE_SAMPLES +_m[0x8824] = (1,) # GL_MAX_DRAW_BUFFERS +_m[0x8824] = (1,) # GL_MAX_DRAW_BUFFERS_ARB +_m[0x8824] = (1,) # GL_MAX_DRAW_BUFFERS_ATI +_m[0x953D] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_MAX_DRAW_MESH_TASKS_COUNT_NV +_m[0x88FC] = (1,) # GL_MAX_DUAL_SOURCE_DRAW_BUFFERS +_m[0x80E9] = (1,) # GL_MAX_ELEMENTS_INDICES +_m[0x80E8] = (1,) # GL_MAX_ELEMENTS_VERTICES +_m[0x8D6B] = (1,) # GL_MAX_ELEMENT_INDEX +_m[0x0D30] = (1,) # GL_MAX_EVAL_ORDER +_m[0x812C] = (1,) # GL_MAX_FOG_FUNC_POINTS_SGIS +_m[0x92D6] = (1,) # GL_MAX_FRAGMENT_ATOMIC_COUNTERS +_m[0x92D0] = (1,) # GL_MAX_FRAGMENT_ATOMIC_COUNTER_BUFFERS +_m[0x8DE3] = (1,) # GL_MAX_FRAGMENT_BINDABLE_UNIFORMS_EXT +_m[0x90CE] = (1,) # GL_MAX_FRAGMENT_IMAGE_UNIFORMS +_m[0x9125] = (1,) # GL_MAX_FRAGMENT_INPUT_COMPONENTS +_m[0x8E5C] = (1,) # GL_MAX_FRAGMENT_INTERPOLATION_OFFSET +_m[0x8E5C] = (1,) # GL_MAX_FRAGMENT_INTERPOLATION_OFFSET_NV +_m[0x8404] = (1,) # GL_MAX_FRAGMENT_LIGHTS_SGIX +_m[0x8868] = (1,) # GL_MAX_FRAGMENT_PROGRAM_LOCAL_PARAMETERS_NV +_m[0x90DA] = (1,) # GL_MAX_FRAGMENT_SHADER_STORAGE_BLOCKS +_m[0x8A2D] = (1,) # GL_MAX_FRAGMENT_UNIFORM_BLOCKS +_m[0x8B49] = (1,) # GL_MAX_FRAGMENT_UNIFORM_COMPONENTS +_m[0x8B49] = (1,) # GL_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB +_m[0x8DFD] = (1,) # GL_MAX_FRAGMENT_UNIFORM_VECTORS +_m[0x9316] = (1,) # GL_MAX_FRAMEBUFFER_HEIGHT +_m[0x9317] = (1,) # GL_MAX_FRAMEBUFFER_LAYERS +_m[0x9318] = (1,) # GL_MAX_FRAMEBUFFER_SAMPLES +_m[0x9315] = (1,) # GL_MAX_FRAMEBUFFER_WIDTH +_m[0x818D] = (1,) # GL_MAX_FRAMEZOOM_FACTOR_SGIX +_m[0x854D] = (1,) # GL_MAX_GENERAL_COMBINERS_NV +_m[0x92D5] = (1,) # GL_MAX_GEOMETRY_ATOMIC_COUNTERS +_m[0x92CF] = (1,) # GL_MAX_GEOMETRY_ATOMIC_COUNTER_BUFFERS +_m[0x8DE4] = (1,) # GL_MAX_GEOMETRY_BINDABLE_UNIFORMS_EXT +_m[0x90CD] = (1,) # GL_MAX_GEOMETRY_IMAGE_UNIFORMS +_m[0x9123] = (1,) # GL_MAX_GEOMETRY_INPUT_COMPONENTS +_m[0x9124] = (1,) # GL_MAX_GEOMETRY_OUTPUT_COMPONENTS +_m[0x8DE0] = (1,) # GL_MAX_GEOMETRY_OUTPUT_VERTICES +_m[0x8DE0] = (1,) # GL_MAX_GEOMETRY_OUTPUT_VERTICES_ARB +_m[0x8DE0] = (1,) # GL_MAX_GEOMETRY_OUTPUT_VERTICES_EXT +_m[0x8E5A] = (1,) # GL_MAX_GEOMETRY_PROGRAM_INVOCATIONS_NV +_m[0x8E5A] = (1,) # GL_MAX_GEOMETRY_SHADER_INVOCATIONS +_m[0x90D7] = (1,) # GL_MAX_GEOMETRY_SHADER_STORAGE_BLOCKS +_m[0x8C29] = (1,) # GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS +_m[0x8C29] = (1,) # GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_ARB +_m[0x8C29] = (1,) # GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_EXT +_m[0x8DE1] = (1,) # GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS +_m[0x8DE1] = (1,) # GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS_ARB +_m[0x8DE1] = (1,) # GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS_EXT +_m[0x8A2C] = (1,) # GL_MAX_GEOMETRY_UNIFORM_BLOCKS +_m[0x8DDF] = (1,) # GL_MAX_GEOMETRY_UNIFORM_COMPONENTS +_m[0x8DDF] = (1,) # GL_MAX_GEOMETRY_UNIFORM_COMPONENTS_ARB +_m[0x8DDF] = (1,) # GL_MAX_GEOMETRY_UNIFORM_COMPONENTS_EXT +_m[0x8DDD] = (1,) # GL_MAX_GEOMETRY_VARYING_COMPONENTS_ARB +_m[0x8DDD] = (1,) # GL_MAX_GEOMETRY_VARYING_COMPONENTS_EXT +_m[0x827F] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_MAX_HEIGHT +_m[0x906D] = (1,) # GL_MAX_IMAGE_SAMPLES +_m[0x906D] = (1,) # GL_MAX_IMAGE_SAMPLES_EXT +_m[0x8F38] = (1,) # GL_MAX_IMAGE_UNITS +_m[0x8F38] = (1,) # GL_MAX_IMAGE_UNITS_EXT +_m[0x9110] = (1,) # GL_MAX_INTEGER_SAMPLES +_m[0x82E8] = (1,) # GL_MAX_LABEL_LENGTH +_m[0x8281] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_MAX_LAYERS +_m[0x92BA] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NVX/NVX_linked_gpu_multicast.txt # GL_MAX_LGPU_GPUS_NVX +_m[0x0D31] = (1,) # GL_MAX_LIGHTS +_m[0x0B31] = (1,) # GL_MAX_LIST_NESTING +_m[0x86D6] = (1,) # GL_MAX_MAP_TESSELLATION_NV +_m[0x8841] = (1,) # GL_MAX_MATRIX_PALETTE_STACK_DEPTH_ARB +_m[0x8E65] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_MAX_MESH_ATOMIC_COUNTERS_NV +_m[0x8E64] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_MAX_MESH_ATOMIC_COUNTER_BUFFERS_NV +_m[0x8E62] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_MAX_MESH_IMAGE_UNIFORMS_NV +_m[0x9539] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_MAX_MESH_OUTPUT_PRIMITIVES_NV +_m[0x9538] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_MAX_MESH_OUTPUT_VERTICES_NV +_m[0x8E66] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_MAX_MESH_SHADER_STORAGE_BLOCKS_NV +_m[0x8E61] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_MAX_MESH_TEXTURE_IMAGE_UNITS_NV +_m[0x9536] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_MAX_MESH_TOTAL_MEMORY_SIZE_NV +_m[0x8E60] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_MAX_MESH_UNIFORM_BLOCKS_NV +_m[0x8E63] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_MAX_MESH_UNIFORM_COMPONENTS_NV +_m[0x9557] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_MAX_MESH_VIEWS_NV +_m[0x95A2] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_MAX_MESH_WORK_GROUP_INVOCATIONS_NV +_m[0x953B] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_MAX_MESH_WORK_GROUP_SIZE_NV +_m[0x0D36] = (1,) # GL_MAX_MODELVIEW_STACK_DEPTH +_m[0x8E11] = (1,) # GL_MAX_MULTISAMPLE_COVERAGE_MODES_NV +_m[0x92F6] = (1,) # GL_MAX_NAME_LENGTH +_m[0x0D37] = (1,) # GL_MAX_NAME_STACK_DEPTH +_m[0x92F7] = (1,) # GL_MAX_NUM_ACTIVE_VARIABLES +_m[0x92F8] = (1,) # GL_MAX_NUM_COMPATIBLE_SUBROUTINES +_m[0x87CA] = (1,) # GL_MAX_OPTIMIZED_VERTEX_SHADER_INSTRUCTIONS_EXT +_m[0x87CE] = (1,) # GL_MAX_OPTIMIZED_VERTEX_SHADER_LOCALS_EXT +_m[0x87CC] = (1,) # GL_MAX_OPTIMIZED_VERTEX_SHADER_LOCAL_CONSTANTS_EXT +_m[0x87CB] = (1,) # GL_MAX_OPTIMIZED_VERTEX_SHADER_VARIANTS_EXT +_m[0x8842] = (1,) # GL_MAX_PALETTE_MATRICES_ARB +_m[0x8842] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/OES/OES_matrix_palette.txt # GL_MAX_PALETTE_MATRICES_OES +_m[0x8E7D] = (1,) # GL_MAX_PATCH_VERTICES +_m[0x0D34] = (1,) # GL_MAX_PIXEL_MAP_TABLE +_m[0x8337] = (1,) # GL_MAX_PIXEL_TRANSFORM_2D_STACK_DEPTH_EXT +_m[0x87F1] = (1,) # GL_MAX_PN_TRIANGLES_TESSELATION_LEVEL_ATI +_m[0x88B1] = (1,) # GL_MAX_PROGRAM_ADDRESS_REGISTERS_ARB +_m[0x880B] = (1,) # GL_MAX_PROGRAM_ALU_INSTRUCTIONS_ARB +_m[0x88AD] = (1,) # GL_MAX_PROGRAM_ATTRIBS_ARB +_m[0x8908] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/gpu_program4.txt # GL_MAX_PROGRAM_ATTRIB_COMPONENTS_NV +_m[0x88F5] = (1,) # GL_MAX_PROGRAM_CALL_DEPTH_NV +_m[0x88B5] = (1,) # GL_MAX_PROGRAM_ENV_PARAMETERS_ARB +_m[0x88F4] = (1,) # GL_MAX_PROGRAM_EXEC_INSTRUCTIONS_NV +_m[0x8DA5] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/gpu_program4.txt # GL_MAX_PROGRAM_GENERIC_ATTRIBS_NV +_m[0x8DA6] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/gpu_program4.txt # GL_MAX_PROGRAM_GENERIC_RESULTS_NV +_m[0x88F6] = (1,) # GL_MAX_PROGRAM_IF_DEPTH_NV +_m[0x88A1] = (1,) # GL_MAX_PROGRAM_INSTRUCTIONS_ARB +_m[0x88B4] = (1,) # GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB +_m[0x88F8] = (1,) # GL_MAX_PROGRAM_LOOP_COUNT_NV +_m[0x88F7] = (1,) # GL_MAX_PROGRAM_LOOP_DEPTH_NV +_m[0x862F] = (1,) # GL_MAX_PROGRAM_MATRICES_ARB +_m[0x862E] = (1,) # GL_MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB +_m[0x88B3] = (1,) # GL_MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB +_m[0x880E] = (1,) # GL_MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB +_m[0x88AF] = (1,) # GL_MAX_PROGRAM_NATIVE_ATTRIBS_ARB +_m[0x88A3] = (1,) # GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB +_m[0x88AB] = (1,) # GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB +_m[0x88A7] = (1,) # GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB +_m[0x8810] = (1,) # GL_MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB +_m[0x880F] = (1,) # GL_MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB +_m[0x8C27] = (1,) # GL_MAX_PROGRAM_OUTPUT_VERTICES_NV +_m[0x88A9] = (1,) # GL_MAX_PROGRAM_PARAMETERS_ARB +_m[0x8DA0] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/parameter_buffer_object.txt # GL_MAX_PROGRAM_PARAMETER_BUFFER_BINDINGS_NV +_m[0x8DA1] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/parameter_buffer_object.txt # GL_MAX_PROGRAM_PARAMETER_BUFFER_SIZE_NV +_m[0x86D8] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/tessellation_program5.txt # GL_MAX_PROGRAM_PATCH_ATTRIBS_NV +_m[0x8909] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/gpu_program4.txt # GL_MAX_PROGRAM_RESULT_COMPONENTS_NV +_m[0x88A5] = (1,) # GL_MAX_PROGRAM_TEMPORARIES_ARB +_m[0x8905] = (1,) # GL_MAX_PROGRAM_TEXEL_OFFSET +_m[0x8F9F] = (1,) # GL_MAX_PROGRAM_TEXTURE_GATHER_COMPONENTS_ARB +_m[0x8E5F] = (1,) # GL_MAX_PROGRAM_TEXTURE_GATHER_OFFSET_ARB +_m[0x8E5F] = (1,) # GL_MAX_PROGRAM_TEXTURE_GATHER_OFFSET_NV +_m[0x880D] = (1,) # GL_MAX_PROGRAM_TEX_INDIRECTIONS_ARB +_m[0x880C] = (1,) # GL_MAX_PROGRAM_TEX_INSTRUCTIONS_ARB +_m[0x8C28] = (1,) # GL_MAX_PROGRAM_TOTAL_OUTPUT_COMPONENTS_NV +_m[0x0D38] = (1,) # GL_MAX_PROJECTION_STACK_DEPTH +_m[0x9329] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_framebuffer_mixed_samples.txt # GL_MAX_RASTER_SAMPLES_EXT +_m[0x86D7] = (1,) # GL_MAX_RATIONAL_EVAL_ORDER_NV +_m[0x84F8] = (1,) # GL_MAX_RECTANGLE_TEXTURE_SIZE +_m[0x84F8] = (1,) # GL_MAX_RECTANGLE_TEXTURE_SIZE_ARB +_m[0x84F8] = (1,) # GL_MAX_RECTANGLE_TEXTURE_SIZE_NV +_m[0x84E8] = (1,) # GL_MAX_RENDERBUFFER_SIZE +_m[0x84E8] = (1,) # GL_MAX_RENDERBUFFER_SIZE_EXT +_m[0x8D57] = (1,) # GL_MAX_SAMPLES +_m[0x8D57] = (1,) # GL_MAX_SAMPLES_EXT +_m[0x9135] = (1,) # GL_MAX_SAMPLES_IMG +_m[0x8E59] = (1,) # GL_MAX_SAMPLE_MASK_WORDS +_m[0x8E59] = (1,) # GL_MAX_SAMPLE_MASK_WORDS_NV +_m[0x9111] = (1,) # GL_MAX_SERVER_WAIT_TIMEOUT +_m[0x9650] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/EXT/EXT_shader_pixel_local_storage2.txt # GL_MAX_SHADER_COMBINED_LOCAL_STORAGE_FAST_SIZE_EXT +_m[0x9651] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/EXT/EXT_shader_pixel_local_storage2.txt # GL_MAX_SHADER_COMBINED_LOCAL_STORAGE_SIZE_EXT +_m[0x91B0] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/ARB/ARB_parallel_shader_compile.txt # GL_MAX_SHADER_COMPILER_THREADS_ARB +_m[0x91B0] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/KHR/KHR_parallel_shader_compile.txt # GL_MAX_SHADER_COMPILER_THREADS_KHR +_m[0x8F63] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/EXT/EXT_shader_pixel_local_storage.txt # GL_MAX_SHADER_PIXEL_LOCAL_STORAGE_FAST_SIZE_EXT +_m[0x8F67] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/EXT/EXT_shader_pixel_local_storage.txt # GL_MAX_SHADER_PIXEL_LOCAL_STORAGE_SIZE_EXT +_m[0x90DE] = (1,) # GL_MAX_SHADER_STORAGE_BLOCK_SIZE +_m[0x90DD] = (1,) # GL_MAX_SHADER_STORAGE_BUFFER_BINDINGS +_m[0x8FA1] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/QCOM/QCOM_texture_foveated_subsampled_layout.txt # GL_MAX_SHADER_SUBSAMPLED_IMAGE_UNITS_QCOM +_m[0x8504] = (1,) # GL_MAX_SHININESS_NV +_m[0x9199] = (1,)#TODO Review http://www.opengl.org/registry/specs//AMD/sparse_texture.txt # GL_MAX_SPARSE_3D_TEXTURE_SIZE_AMD +_m[0x9199] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/sparse_texture.txt # GL_MAX_SPARSE_3D_TEXTURE_SIZE_ARB +_m[0x9199] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/EXT/EXT_sparse_texture.txt # GL_MAX_SPARSE_3D_TEXTURE_SIZE_EXT +_m[0x919A] = (1,) # GL_MAX_SPARSE_ARRAY_TEXTURE_LAYERS +_m[0x9198] = (1,)#TODO Review http://www.opengl.org/registry/specs//AMD/sparse_texture.txt # GL_MAX_SPARSE_TEXTURE_SIZE_AMD +_m[0x9198] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/sparse_texture.txt # GL_MAX_SPARSE_TEXTURE_SIZE_ARB +_m[0x9198] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/EXT/EXT_sparse_texture.txt # GL_MAX_SPARSE_TEXTURE_SIZE_EXT +_m[0x8505] = (1,) # GL_MAX_SPOT_EXPONENT_NV +_m[0x9349] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_conservative_raster.txt # GL_MAX_SUBPIXEL_PRECISION_BIAS_BITS_NV +_m[0x8DE7] = (1,) # GL_MAX_SUBROUTINES +_m[0x8DE8] = (1,) # GL_MAX_SUBROUTINE_UNIFORM_LOCATIONS +_m[0x8E6D] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_MAX_TASK_ATOMIC_COUNTERS_NV +_m[0x8E6C] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_MAX_TASK_ATOMIC_COUNTER_BUFFERS_NV +_m[0x8E6A] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_MAX_TASK_IMAGE_UNIFORMS_NV +_m[0x953A] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_MAX_TASK_OUTPUT_COUNT_NV +_m[0x8E6E] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_MAX_TASK_SHADER_STORAGE_BLOCKS_NV +_m[0x8E69] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_MAX_TASK_TEXTURE_IMAGE_UNITS_NV +_m[0x9537] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_MAX_TASK_TOTAL_MEMORY_SIZE_NV +_m[0x8E68] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_MAX_TASK_UNIFORM_BLOCKS_NV +_m[0x8E6B] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_MAX_TASK_UNIFORM_COMPONENTS_NV +_m[0x95A3] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_MAX_TASK_WORK_GROUP_INVOCATIONS_NV +_m[0x953C] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_MAX_TASK_WORK_GROUP_SIZE_NV +_m[0x92D3] = (1,) # GL_MAX_TESS_CONTROL_ATOMIC_COUNTERS +_m[0x92CD] = (1,) # GL_MAX_TESS_CONTROL_ATOMIC_COUNTER_BUFFERS +_m[0x90CB] = (1,) # GL_MAX_TESS_CONTROL_IMAGE_UNIFORMS +_m[0x886C] = (1,) # GL_MAX_TESS_CONTROL_INPUT_COMPONENTS +_m[0x8E83] = (1,) # GL_MAX_TESS_CONTROL_OUTPUT_COMPONENTS +_m[0x90D8] = (1,) # GL_MAX_TESS_CONTROL_SHADER_STORAGE_BLOCKS +_m[0x8E81] = (1,) # GL_MAX_TESS_CONTROL_TEXTURE_IMAGE_UNITS +_m[0x8E85] = (1,) # GL_MAX_TESS_CONTROL_TOTAL_OUTPUT_COMPONENTS +_m[0x8E89] = (1,) # GL_MAX_TESS_CONTROL_UNIFORM_BLOCKS +_m[0x8E7F] = (1,) # GL_MAX_TESS_CONTROL_UNIFORM_COMPONENTS +_m[0x92D4] = (1,) # GL_MAX_TESS_EVALUATION_ATOMIC_COUNTERS +_m[0x92CE] = (1,) # GL_MAX_TESS_EVALUATION_ATOMIC_COUNTER_BUFFERS +_m[0x90CC] = (1,) # GL_MAX_TESS_EVALUATION_IMAGE_UNIFORMS +_m[0x886D] = (1,) # GL_MAX_TESS_EVALUATION_INPUT_COMPONENTS +_m[0x8E86] = (1,) # GL_MAX_TESS_EVALUATION_OUTPUT_COMPONENTS +_m[0x90D9] = (1,) # GL_MAX_TESS_EVALUATION_SHADER_STORAGE_BLOCKS +_m[0x8E82] = (1,) # GL_MAX_TESS_EVALUATION_TEXTURE_IMAGE_UNITS +_m[0x8E8A] = (1,) # GL_MAX_TESS_EVALUATION_UNIFORM_BLOCKS +_m[0x8E80] = (1,) # GL_MAX_TESS_EVALUATION_UNIFORM_COMPONENTS +_m[0x8E7E] = (1,) # GL_MAX_TESS_GEN_LEVEL +_m[0x8E84] = (1,) # GL_MAX_TESS_PATCH_COMPONENTS +_m[0x8C2B] = (1,) # GL_MAX_TEXTURE_BUFFER_SIZE +_m[0x8C2B] = (1,) # GL_MAX_TEXTURE_BUFFER_SIZE_ARB +_m[0x8C2B] = (1,) # GL_MAX_TEXTURE_BUFFER_SIZE_EXT +_m[0x8871] = (1,) # GL_MAX_TEXTURE_COORDS +_m[0x8871] = (1,) # GL_MAX_TEXTURE_COORDS_ARB +_m[0x8871] = (1,) # GL_MAX_TEXTURE_COORDS_NV +_m[0x8872] = (1,) # GL_MAX_TEXTURE_IMAGE_UNITS +_m[0x8872] = (1,) # GL_MAX_TEXTURE_IMAGE_UNITS_ARB +_m[0x8872] = (1,) # GL_MAX_TEXTURE_IMAGE_UNITS_NV +_m[0x84FD] = (1,) # GL_MAX_TEXTURE_LOD_BIAS +_m[0x84FD] = (1,) # GL_MAX_TEXTURE_LOD_BIAS_EXT +_m[0x84FF] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/ARB/ARB_texture_filter_anisotropic.txt # GL_MAX_TEXTURE_MAX_ANISOTROPY +_m[0x84FF] = (1,) # GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT +_m[0x0D33] = (1,) # GL_MAX_TEXTURE_SIZE +_m[0x0D39] = (1,) # GL_MAX_TEXTURE_STACK_DEPTH +_m[0x84E2] = (1,) # GL_MAX_TEXTURE_UNITS +_m[0x84E2] = (1,) # GL_MAX_TEXTURE_UNITS_ARB +_m[0x862F] = (1,) # GL_MAX_TRACK_MATRICES_NV +_m[0x862E] = (1,) # GL_MAX_TRACK_MATRIX_STACK_DEPTH_NV +_m[0x8E70] = (1,) # GL_MAX_TRANSFORM_FEEDBACK_BUFFERS +_m[0x8C8A] = (1,) # GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS +_m[0x8C8B] = (1,) # GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS +_m[0x8C80] = (1,) # GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS +_m[0x8A30] = (1,) # GL_MAX_UNIFORM_BLOCK_SIZE +_m[0x8A2F] = (1,) # GL_MAX_UNIFORM_BUFFER_BINDINGS +_m[0x826E] = (1,) # GL_MAX_UNIFORM_LOCATIONS +_m[0x8B4B] = (1,) # GL_MAX_VARYING_COMPONENTS +_m[0x8B4B] = (1,) # GL_MAX_VARYING_COMPONENTS_EXT +_m[0x8B4B] = (1,) # GL_MAX_VARYING_FLOATS +_m[0x8B4B] = (1,) # GL_MAX_VARYING_FLOATS_ARB +_m[0x8DFC] = (1,) # GL_MAX_VARYING_VECTORS +_m[0x8520] = (1,) # GL_MAX_VERTEX_ARRAY_RANGE_ELEMENT_NV +_m[0x92D2] = (1,) # GL_MAX_VERTEX_ATOMIC_COUNTERS +_m[0x92CC] = (1,) # GL_MAX_VERTEX_ATOMIC_COUNTER_BUFFERS +_m[0x8869] = (1,) # GL_MAX_VERTEX_ATTRIBS +_m[0x8869] = (1,) # GL_MAX_VERTEX_ATTRIBS_ARB +_m[0x82DA] = (1,) # GL_MAX_VERTEX_ATTRIB_BINDINGS +_m[0x82D9] = (1,) # GL_MAX_VERTEX_ATTRIB_RELATIVE_OFFSET +_m[0x8DE2] = (1,) # GL_MAX_VERTEX_BINDABLE_UNIFORMS_EXT +_m[0x90CA] = (1,) # GL_MAX_VERTEX_IMAGE_UNIFORMS +_m[0x9122] = (1,) # GL_MAX_VERTEX_OUTPUT_COMPONENTS +_m[0x87C5] = (1,) # GL_MAX_VERTEX_SHADER_INSTRUCTIONS_EXT +_m[0x87C7] = (1,) # GL_MAX_VERTEX_SHADER_INVARIANTS_EXT +_m[0x87C9] = (1,) # GL_MAX_VERTEX_SHADER_LOCALS_EXT +_m[0x87C8] = (1,) # GL_MAX_VERTEX_SHADER_LOCAL_CONSTANTS_EXT +_m[0x90D6] = (1,) # GL_MAX_VERTEX_SHADER_STORAGE_BLOCKS +_m[0x87C6] = (1,) # GL_MAX_VERTEX_SHADER_VARIANTS_EXT +_m[0x8E71] = (1,) # GL_MAX_VERTEX_STREAMS +_m[0x876B] = (1,) # GL_MAX_VERTEX_STREAMS_ATI +_m[0x8B4C] = (1,) # GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS +_m[0x8B4C] = (1,) # GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB +_m[0x8A2B] = (1,) # GL_MAX_VERTEX_UNIFORM_BLOCKS +_m[0x8B4A] = (1,) # GL_MAX_VERTEX_UNIFORM_COMPONENTS +_m[0x8B4A] = (1,) # GL_MAX_VERTEX_UNIFORM_COMPONENTS_ARB +_m[0x8DFB] = (1,) # GL_MAX_VERTEX_UNIFORM_VECTORS +_m[0x86A4] = (1,) # GL_MAX_VERTEX_UNITS_ARB +_m[0x86A4] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/OES/OES_matrix_palette.txt # GL_MAX_VERTEX_UNITS_OES +_m[0x8DDE] = (1,) # GL_MAX_VERTEX_VARYING_COMPONENTS_ARB +_m[0x8DDE] = (1,) # GL_MAX_VERTEX_VARYING_COMPONENTS_EXT +_m[0x825B] = (1,) # GL_MAX_VIEWPORTS +_m[0x0D3A] = (2,) # GL_MAX_VIEWPORT_DIMS +_m[0x9631] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/OVR/OVR_multiview.txt # GL_MAX_VIEWS_OVR +_m[0x827E] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_MAX_WIDTH +_m[0x8F14] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/EXT/EXT_window_rectangles.txt # GL_MAX_WINDOW_RECTANGLES_EXT +_m[0x9543] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_MESH_OUTPUT_PER_PRIMITIVE_GRANULARITY_NV +_m[0x92DF] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_MESH_OUTPUT_PER_VERTEX_GRANULARITY_NV +_m[0x957B] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_MESH_OUTPUT_TYPE_NV +_m[0x957A] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_MESH_PRIMITIVES_OUT_NV +_m[0x9579] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_MESH_VERTICES_OUT_NV +_m[0x953E] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_MESH_WORK_GROUP_SIZE_NV +_m[0x802E] = (1,) # GL_MINMAX +_m[0x802E] = (1,) # GL_MINMAX_EXT +_m[0x802F] = (1,) # GL_MINMAX_FORMAT +_m[0x802F] = (1,) # GL_MINMAX_FORMAT_EXT +_m[0x8030] = (1,) # GL_MINMAX_SINK +_m[0x8030] = (1,) # GL_MINMAX_SINK_EXT +_m[0x821C] = (1,) # GL_MINOR_VERSION +_m[0x8E5B] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/gpu_shader5.txt # GL_MIN_FRAGMENT_INTERPOLATION_OFFSET +_m[0x8E5B] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/gpu_program5.txt # GL_MIN_FRAGMENT_INTERPOLATION_OFFSET_NV +_m[0x90BC] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/map_buffer_alignment.txt # GL_MIN_MAP_BUFFER_ALIGNMENT +_m[0x8904] = (1,) # GL_MIN_PROGRAM_TEXEL_OFFSET +_m[0x8E5E] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/texture_gather.txt # GL_MIN_PROGRAM_TEXTURE_GATHER_OFFSET_ARB +_m[0x8E5E] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/gpu_program5.txt # GL_MIN_PROGRAM_TEXTURE_GATHER_OFFSET_NV +_m[0x8C37] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/sample_shading.txt # GL_MIN_SAMPLE_SHADING_VALUE_ARB +_m[0x8C37] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/OES/OES_sample_shading.txt # GL_MIN_SAMPLE_SHADING_VALUE_OES +_m[0x919B] = (1,)#TODO Review http://www.opengl.org/registry/specs//AMD/sparse_texture.txt # GL_MIN_SPARSE_LEVEL_AMD +_m[0x8293] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_MIPMAP +_m[0x932F] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_framebuffer_mixed_samples.txt # GL_MIXED_DEPTH_SAMPLES_SUPPORTED_NV +_m[0x9330] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_framebuffer_mixed_samples.txt # GL_MIXED_STENCIL_SAMPLES_SUPPORTED_NV +_m[0x0BA6] = (4,4) # GL_MODELVIEW0_MATRIX_EXT +_m[0x0BA3] = (1,) # GL_MODELVIEW0_STACK_DEPTH_EXT +_m[0x872A] = (4,4) # GL_MODELVIEW10_ARB +_m[0x872B] = (4,4) # GL_MODELVIEW11_ARB +_m[0x872C] = (4,4) # GL_MODELVIEW12_ARB +_m[0x872D] = (4,4) # GL_MODELVIEW13_ARB +_m[0x872E] = (4,4) # GL_MODELVIEW14_ARB +_m[0x872F] = (4,4) # GL_MODELVIEW15_ARB +_m[0x8730] = (4,4) # GL_MODELVIEW16_ARB +_m[0x8731] = (4,4) # GL_MODELVIEW17_ARB +_m[0x8732] = (4,4) # GL_MODELVIEW18_ARB +_m[0x8733] = (4,4) # GL_MODELVIEW19_ARB +_m[0x850A] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/vertex_blend.txt # GL_MODELVIEW1_ARB +_m[0x8506] = (4,4) # GL_MODELVIEW1_MATRIX_EXT +_m[0x8502] = (1,) # GL_MODELVIEW1_STACK_DEPTH_EXT +_m[0x8734] = (4,4) # GL_MODELVIEW20_ARB +_m[0x8735] = (4,4) # GL_MODELVIEW21_ARB +_m[0x8736] = (4,4) # GL_MODELVIEW22_ARB +_m[0x8737] = (4,4) # GL_MODELVIEW23_ARB +_m[0x8738] = (4,4) # GL_MODELVIEW24_ARB +_m[0x8739] = (4,4) # GL_MODELVIEW25_ARB +_m[0x873A] = (4,4) # GL_MODELVIEW26_ARB +_m[0x873B] = (4,4) # GL_MODELVIEW27_ARB +_m[0x873C] = (4,4) # GL_MODELVIEW28_ARB +_m[0x873D] = (4,4) # GL_MODELVIEW29_ARB +_m[0x8722] = (4,4) # GL_MODELVIEW2_ARB +_m[0x873E] = (4,4) # GL_MODELVIEW30_ARB +_m[0x873F] = (4,4) # GL_MODELVIEW31_ARB +_m[0x8723] = (4,4) # GL_MODELVIEW3_ARB +_m[0x8724] = (4,4) # GL_MODELVIEW4_ARB +_m[0x8725] = (4,4) # GL_MODELVIEW5_ARB +_m[0x8726] = (4,4) # GL_MODELVIEW6_ARB +_m[0x8727] = (4,4) # GL_MODELVIEW7_ARB +_m[0x8728] = (4,4) # GL_MODELVIEW8_ARB +_m[0x8729] = (4,4) # GL_MODELVIEW9_ARB +_m[0x0BA6] = (4, 4) # GL_MODELVIEW_MATRIX +_m[0x898D] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/OES/OES_matrix_get.txt # GL_MODELVIEW_MATRIX_FLOAT_AS_INT_BITS_OES +_m[0x0BA3] = (1,) # GL_MODELVIEW_STACK_DEPTH +_m[0x92BA] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_gpu_multicast.txt # GL_MULTICAST_GPUS_NV +_m[0x9549] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_gpu_multicast.txt # GL_MULTICAST_PROGRAMMABLE_SAMPLE_LOCATION_NV +_m[0x809D] = (1,) # GL_MULTISAMPLE +_m[0x9371] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_internalformat_sample_query.txt # GL_MULTISAMPLES_NV +_m[0x86B2] = (1,) # GL_MULTISAMPLE_3DFX +_m[0x809D] = (1,) # GL_MULTISAMPLE_ARB +_m[0x8E12] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/framebuffer_multisample_coverage.txt # GL_MULTISAMPLE_COVERAGE_MODES_NV +_m[0x809D] = (1,) # GL_MULTISAMPLE_EXT +_m[0x8534] = (1,) # GL_MULTISAMPLE_FILTER_HINT_NV +_m[0x9382] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/ARB/ARB_ES3_2_compatibility.txt # GL_MULTISAMPLE_LINE_WIDTH_GRANULARITY_ARB +_m[0x9381] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/ARB/ARB_ES3_2_compatibility.txt # GL_MULTISAMPLE_LINE_WIDTH_RANGE_ARB +_m[0x932B] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_framebuffer_mixed_samples.txt # GL_MULTISAMPLE_RASTERIZATION_ALLOWED_EXT +_m[0x809D] = (1,) # GL_MULTISAMPLE_SGIS +_m[0x8DE9] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/shading_language_include.txt # GL_NAMED_STRING_LENGTH_ARB +_m[0x8DEA] = (1,) # GL_NAMED_STRING_TYPE_ARB +_m[0x92F9] = (1,) # GL_NAME_LENGTH +_m[0x0D70] = (1,) # GL_NAME_STACK_DEPTH +_m[0x9025] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/video_capture.txt # GL_NEXT_VIDEO_CAPTURE_BUFFER_STATUS_NV +_m[0x0BA1] = (1,) # GL_NORMALIZE +_m[0x8075] = (1,) # GL_NORMAL_ARRAY +_m[0x8897] = (1,) # GL_NORMAL_ARRAY_BUFFER_BINDING +_m[0x8897] = (1,) # GL_NORMAL_ARRAY_BUFFER_BINDING_ARB +_m[0x8080] = (1,) # GL_NORMAL_ARRAY_COUNT_EXT +_m[0x8075] = (1,) # GL_NORMAL_ARRAY_EXT +_m[0x8F2C] = (1,) # GL_NORMAL_ARRAY_LENGTH_NV +_m[0x83F6] = (1,)#TODO Review http://www.opengl.org/registry/specs//INTEL/parallel_arrays.txt # GL_NORMAL_ARRAY_PARALLEL_POINTERS_INTEL +_m[0x808F] = (1,) # GL_NORMAL_ARRAY_POINTER +_m[0x807F] = (1,) # GL_NORMAL_ARRAY_STRIDE +_m[0x807F] = (1,) # GL_NORMAL_ARRAY_STRIDE_EXT +_m[0x807E] = (1,) # GL_NORMAL_ARRAY_TYPE +_m[0x807E] = (1,) # GL_NORMAL_ARRAY_TYPE_EXT +_m[0x8261] = (1,)#TODO Review http://www.opengl.org/registry/specs//KHR/robustness.txt # GL_NO_RESET_NOTIFICATION +_m[0x8261] = (1,) # GL_NO_RESET_NOTIFICATION_ARB +_m[0x9304] = (1,) # GL_NUM_ACTIVE_VARIABLES +_m[0x8E4A] = (1,) # GL_NUM_COMPATIBLE_SUBROUTINES +_m[0x86A2] = (1,) # GL_NUM_COMPRESSED_TEXTURE_FORMATS +_m[0x86A2] = (1,) # GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB +_m[0x913D] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/IMG/IMG_framebuffer_downsample.txt # GL_NUM_DOWNSAMPLE_SCALES_IMG +_m[0x821D] = (1,) # GL_NUM_EXTENSIONS +_m[0x8E29] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/present_video.txt # GL_NUM_FILL_STREAMS_NV +_m[0x896F] = (1,) # GL_NUM_FRAGMENT_CONSTANTS_ATI +_m[0x896E] = (1,) # GL_NUM_FRAGMENT_REGISTERS_ATI +_m[0x854E] = (1,) # GL_NUM_GENERAL_COMBINERS_NV +_m[0x8973] = (1,) # GL_NUM_INPUT_INTERPOLATOR_COMPONENTS_ATI +_m[0x8971] = (1,) # GL_NUM_INSTRUCTIONS_PER_PASS_ATI +_m[0x8972] = (1,) # GL_NUM_INSTRUCTIONS_TOTAL_ATI +_m[0x8974] = (1,) # GL_NUM_LOOPBACK_COMPONENTS_ATI +_m[0x8970] = (1,) # GL_NUM_PASSES_ATI +_m[0x87FE] = (1,) # GL_NUM_PROGRAM_BINARY_FORMATS +_m[0x9380] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query.txt # GL_NUM_SAMPLE_COUNTS +_m[0x8DF9] = (1,) # GL_NUM_SHADER_BINARY_FORMATS +_m[0x91AA] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/sparse_texture.txt # GL_NUM_SPARSE_LEVELS_ARB +_m[0x91AA] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/EXT/EXT_sparse_texture.txt # GL_NUM_SPARSE_LEVELS_EXT +_m[0x9554] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/ARB/ARB_spirv_extensions.txt # GL_NUM_SPIR_V_EXTENSIONS +_m[0x91B6] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/AMD/AMD_framebuffer_multisample_advanced.txt # GL_NUM_SUPPORTED_MULTISAMPLE_MODES_AMD +_m[0x9024] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/video_capture.txt # GL_NUM_VIDEO_CAPTURE_STREAMS_NV +_m[0x8F15] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/EXT/EXT_window_rectangles.txt # GL_NUM_WINDOW_RECTANGLES_EXT +_m[0x8B86] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/shader_objects.txt # GL_OBJECT_ACTIVE_UNIFORMS_ARB +_m[0x8B87] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/shader_objects.txt # GL_OBJECT_ACTIVE_UNIFORM_MAX_LENGTH_ARB +_m[0x8B85] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/shader_objects.txt # GL_OBJECT_ATTACHED_OBJECTS_ARB +_m[0x8764] = (1,) # GL_OBJECT_BUFFER_SIZE_ATI +_m[0x8765] = (4,) # GL_OBJECT_BUFFER_USAGE_ATI +_m[0x8B81] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/shader_objects.txt # GL_OBJECT_COMPILE_STATUS_ARB +_m[0x8B80] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/shader_objects.txt # GL_OBJECT_DELETE_STATUS_ARB +_m[0x8B84] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/shader_objects.txt # GL_OBJECT_INFO_LOG_LENGTH_ARB +_m[0x81F7] = (7,) # GL_OBJECT_LINE_SGIS +_m[0x8B82] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/shader_objects.txt # GL_OBJECT_LINK_STATUS_ARB +_m[0x2501] = (4,) # GL_OBJECT_PLANE +_m[0x81F5] = (4,) # GL_OBJECT_POINT_SGIS +_m[0x8B88] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/shader_objects.txt # GL_OBJECT_SHADER_SOURCE_LENGTH_ARB +_m[0x8B4F] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/shader_objects.txt # GL_OBJECT_SUBTYPE_ARB +_m[0x9112] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/sync.txt # GL_OBJECT_TYPE +_m[0x8B4E] = (1,) # GL_OBJECT_TYPE_ARB +_m[0x8B83] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/shader_objects.txt # GL_OBJECT_VALIDATE_STATUS_ARB +_m[0x8165] = (1,) # GL_OCCLUSION_TEST_HP +_m[0x8166] = (1,) # GL_OCCLUSION_TEST_RESULT_HP +_m[0x92FC] = (1,) # GL_OFFSET +_m[0x86E3] = (1,) # GL_OFFSET_TEXTURE_BIAS_NV +_m[0x86E1] = (4,) # GL_OFFSET_TEXTURE_MATRIX_NV +_m[0x86E2] = (1,) # GL_OFFSET_TEXTURE_SCALE_NV +_m[0x8598] = (1,) # GL_OPERAND0_ALPHA +_m[0x8590] = (1,) # GL_OPERAND0_RGB +_m[0x8599] = (1,) # GL_OPERAND1_ALPHA +_m[0x8591] = (1,) # GL_OPERAND1_RGB +_m[0x859A] = (1,) # GL_OPERAND2_ALPHA +_m[0x8592] = (1,) # GL_OPERAND2_RGB +_m[0x859B] = (1,) # GL_OPERAND3_ALPHA_NV +_m[0x8593] = (1,) # GL_OPERAND3_RGB_NV +_m[0x0D05] = (1,) # GL_PACK_ALIGNMENT +_m[0x800E] = (1,) # GL_PACK_CMYK_HINT_EXT +_m[0x912D] = (1,) # GL_PACK_COMPRESSED_BLOCK_DEPTH +_m[0x912C] = (1,) # GL_PACK_COMPRESSED_BLOCK_HEIGHT +_m[0x912E] = (1,) # GL_PACK_COMPRESSED_BLOCK_SIZE +_m[0x912B] = (1,) # GL_PACK_COMPRESSED_BLOCK_WIDTH +_m[0x8131] = (1,) # GL_PACK_IMAGE_DEPTH_SGIS +_m[0x806C] = (1,) # GL_PACK_IMAGE_HEIGHT +_m[0x806C] = (1,) # GL_PACK_IMAGE_HEIGHT_EXT +_m[0x8758] = (1,) # GL_PACK_INVERT_MESA +_m[0x0D01] = (1,) # GL_PACK_LSB_FIRST +_m[0x8984] = (1,) # GL_PACK_RESAMPLE_OML +_m[0x842E] = (1,) # GL_PACK_RESAMPLE_SGIX +_m[0x93A4] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/ANGLE/ANGLE_pack_reverse_row_order.txt # GL_PACK_REVERSE_ROW_ORDER_ANGLE +_m[0x8A15] = (1,) # GL_PACK_ROW_BYTES_APPLE +_m[0x0D02] = (1,) # GL_PACK_ROW_LENGTH +_m[0x806B] = (1,) # GL_PACK_SKIP_IMAGES +_m[0x806B] = (1,) # GL_PACK_SKIP_IMAGES_EXT +_m[0x0D04] = (1,) # GL_PACK_SKIP_PIXELS +_m[0x0D03] = (1,) # GL_PACK_SKIP_ROWS +_m[0x8130] = (1,) # GL_PACK_SKIP_VOLUMES_SGIS +_m[0x0D00] = (1,) # GL_PACK_SWAP_BYTES +_m[0x83F4] = (1,) # GL_PARALLEL_ARRAYS_INTEL +_m[0x80EF] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/indirect_parameters.txt # GL_PARAMETER_BUFFER_BINDING_ARB +_m[0x8E73] = (1,) # GL_PATCH_DEFAULT_INNER_LEVEL +_m[0x8E74] = (1,) # GL_PATCH_DEFAULT_OUTER_LEVEL +_m[0x8E72] = (1,) # GL_PATCH_VERTICES +_m[0x909D] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/path_rendering.txt # GL_PATH_COMMAND_COUNT_NV +_m[0x90A0] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/path_rendering.txt # GL_PATH_COMPUTED_LENGTH_NV +_m[0x909E] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/path_rendering.txt # GL_PATH_COORD_COUNT_NV +_m[0x90BF] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/path_rendering.txt # GL_PATH_COVER_DEPTH_FUNC_NV +_m[0x909F] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/path_rendering.txt # GL_PATH_DASH_ARRAY_COUNT_NV +_m[0x90AB] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/path_rendering.txt # GL_PATH_ERROR_POSITION_NV +_m[0x90A1] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/path_rendering.txt # GL_PATH_FILL_BOUNDING_BOX_NV +_m[0x90AC] = (1,) # GL_PATH_FOG_GEN_MODE_NV +_m[0x90B1] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/path_rendering.txt # GL_PATH_GEN_COEFF_NV +_m[0x90B2] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/path_rendering.txt # GL_PATH_GEN_COLOR_FORMAT_NV +_m[0x90B3] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/path_rendering.txt # GL_PATH_GEN_COMPONENTS_NV +_m[0x90B0] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/path_rendering.txt # GL_PATH_GEN_MODE_NV +_m[0x90BD] = (1,) # GL_PATH_STENCIL_DEPTH_OFFSET_FACTOR_NV +_m[0x90BE] = (1,) # GL_PATH_STENCIL_DEPTH_OFFSET_UNITS_NV +_m[0x90B7] = (1,) # GL_PATH_STENCIL_FUNC_NV +_m[0x90B8] = (1,) # GL_PATH_STENCIL_REF_NV +_m[0x90B9] = (1,) # GL_PATH_STENCIL_VALUE_MASK_NV +_m[0x90A2] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/path_rendering.txt # GL_PATH_STROKE_BOUNDING_BOX_NV +_m[0x8BC6] = (1,)#TODO Review http://www.opengl.org/registry/specs//AMD/performance_monitor.txt # GL_PERFMON_RESULT_AMD +_m[0x8BC4] = (1,)#TODO Review http://www.opengl.org/registry/specs//AMD/performance_monitor.txt # GL_PERFMON_RESULT_AVAILABLE_AMD +_m[0x8BC5] = (1,)#TODO Review http://www.opengl.org/registry/specs//AMD/performance_monitor.txt # GL_PERFMON_RESULT_SIZE_AMD +_m[0x94FF] = (1,)#TODO Review http://www.opengl.org/registry/specs//INTEL/performance_query.txt # GL_PERFQUERY_COUNTER_DESC_LENGTH_MAX_INTEL +_m[0x94FE] = (1,)#TODO Review http://www.opengl.org/registry/specs//INTEL/performance_query.txt # GL_PERFQUERY_COUNTER_NAME_LENGTH_MAX_INTEL +_m[0x9500] = (1,)#TODO Review http://www.opengl.org/registry/specs//INTEL/performance_query.txt # GL_PERFQUERY_GPA_EXTENDED_COUNTERS_INTEL +_m[0x94FD] = (1,)#TODO Review http://www.opengl.org/registry/specs//INTEL/performance_query.txt # GL_PERFQUERY_QUERY_NAME_LENGTH_MAX_INTEL +_m[0x0C50] = (1,) # GL_PERSPECTIVE_CORRECTION_HINT +_m[0x8535] = (1,) # GL_PER_STAGE_CONSTANTS_NV +_m[0x91AE] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/AMD/AMD_framebuffer_sample_positions.txt # GL_PIXELS_PER_SAMPLE_PATTERN_X_AMD +_m[0x91AF] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/AMD/AMD_framebuffer_sample_positions.txt # GL_PIXELS_PER_SAMPLE_PATTERN_Y_AMD +_m[0x8864] = (1,) # GL_PIXEL_COUNTER_BITS_NV +_m[0x8867] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/occlusion_query.txt # GL_PIXEL_COUNT_AVAILABLE_NV +_m[0x8866] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/occlusion_query.txt # GL_PIXEL_COUNT_NV +_m[0x8355] = (1,) # GL_PIXEL_FRAGMENT_ALPHA_SOURCE_SGIS +_m[0x8354] = (1,) # GL_PIXEL_FRAGMENT_RGB_SOURCE_SGIS +_m[0x8356] = (1,) # GL_PIXEL_GROUP_COLOR_SGIS +_m[0x0C79] = (_L(0xCB9),) # GL_PIXEL_MAP_A_TO_A +_m[0x0CB9] = (1,) # GL_PIXEL_MAP_A_TO_A_SIZE +_m[0x0C78] = (_L(0xCB8),) # GL_PIXEL_MAP_B_TO_B +_m[0x0CB8] = (1,) # GL_PIXEL_MAP_B_TO_B_SIZE +_m[0x0C77] = (_L(0xCB7),) # GL_PIXEL_MAP_G_TO_G +_m[0x0CB7] = (1,) # GL_PIXEL_MAP_G_TO_G_SIZE +_m[0x0C75] = (_L(0xCB5),) # GL_PIXEL_MAP_I_TO_A +_m[0x0CB5] = (1,) # GL_PIXEL_MAP_I_TO_A_SIZE +_m[0x0C74] = (_L(0xCB4),) # GL_PIXEL_MAP_I_TO_B +_m[0x0CB4] = (1,) # GL_PIXEL_MAP_I_TO_B_SIZE +_m[0x0C73] = (_L(0xCB3),) # GL_PIXEL_MAP_I_TO_G +_m[0x0CB3] = (1,) # GL_PIXEL_MAP_I_TO_G_SIZE +_m[0x0C70] = (_L(0xCB0),) # GL_PIXEL_MAP_I_TO_I +_m[0x0CB0] = (1,) # GL_PIXEL_MAP_I_TO_I_SIZE +_m[0x0C72] = (_L(0xCB2),) # GL_PIXEL_MAP_I_TO_R +_m[0x0CB2] = (1,) # GL_PIXEL_MAP_I_TO_R_SIZE +_m[0x0C76] = (_L(0xCB6),) # GL_PIXEL_MAP_R_TO_R +_m[0x0CB6] = (1,) # GL_PIXEL_MAP_R_TO_R_SIZE +_m[0x0C71] = (_L(0xCB1),) # GL_PIXEL_MAP_S_TO_S +_m[0x0CB1] = (1,) # GL_PIXEL_MAP_S_TO_S_SIZE +_m[0x88ED] = (1,) # GL_PIXEL_PACK_BUFFER_BINDING +_m[0x88ED] = (1,) # GL_PIXEL_PACK_BUFFER_BINDING_ARB +_m[0x88ED] = (1,) # GL_PIXEL_PACK_BUFFER_BINDING_EXT +_m[0x8353] = (1,) # GL_PIXEL_TEXTURE_SGIS +_m[0x832B] = (1,) # GL_PIXEL_TEX_GEN_MODE_SGIX +_m[0x8139] = (1,) # GL_PIXEL_TEX_GEN_SGIX +_m[0x813E] = (1,) # GL_PIXEL_TILE_BEST_ALIGNMENT_SGIX +_m[0x813F] = (1,) # GL_PIXEL_TILE_CACHE_INCREMENT_SGIX +_m[0x8145] = (1,) # GL_PIXEL_TILE_CACHE_SIZE_SGIX +_m[0x8144] = (1,) # GL_PIXEL_TILE_GRID_DEPTH_SGIX +_m[0x8143] = (1,) # GL_PIXEL_TILE_GRID_HEIGHT_SGIX +_m[0x8142] = (1,) # GL_PIXEL_TILE_GRID_WIDTH_SGIX +_m[0x8141] = (1,) # GL_PIXEL_TILE_HEIGHT_SGIX +_m[0x8140] = (1,) # GL_PIXEL_TILE_WIDTH_SGIX +_m[0x8338] = (1,)#TODO Review http://www.opengl.org/registry/specs//EXT/pixel_transform.txt # GL_PIXEL_TRANSFORM_2D_MATRIX_EXT +_m[0x8336] = (1,) # GL_PIXEL_TRANSFORM_2D_STACK_DEPTH_EXT +_m[0x88EF] = (1,) # GL_PIXEL_UNPACK_BUFFER_BINDING +_m[0x88EF] = (1,) # GL_PIXEL_UNPACK_BUFFER_BINDING_ARB +_m[0x88EF] = (1,) # GL_PIXEL_UNPACK_BUFFER_BINDING_EXT +_m[0x87F3] = (1,) # GL_PN_TRIANGLES_NORMAL_MODE_ATI +_m[0x87F2] = (1,) # GL_PN_TRIANGLES_POINT_MODE_ATI +_m[0x87F4] = (1,) # GL_PN_TRIANGLES_TESSELATION_LEVEL_ATI +_m[0x8129] = (3,) # GL_POINT_DISTANCE_ATTENUATION +_m[0x8129] = (3,) # GL_POINT_DISTANCE_ATTENUATION_ARB +_m[0x8128] = (1,) # GL_POINT_FADE_THRESHOLD_SIZE +_m[0x8128] = (1,) # GL_POINT_FADE_THRESHOLD_SIZE_ARB +_m[0x8128] = (1,) # GL_POINT_FADE_THRESHOLD_SIZE_SGIS +_m[0x1B00] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_polygon_mode.txt # GL_POINT_NV +_m[0x0B11] = (1,) # GL_POINT_SIZE +_m[0x8B9F] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/OES/OES_point_size_array.txt # GL_POINT_SIZE_ARRAY_BUFFER_BINDING_OES +_m[0x898C] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/OES/OES_point_size_array.txt # GL_POINT_SIZE_ARRAY_POINTER_OES +_m[0x898B] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/OES/OES_point_size_array.txt # GL_POINT_SIZE_ARRAY_STRIDE_OES +_m[0x898A] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/OES/OES_point_size_array.txt # GL_POINT_SIZE_ARRAY_TYPE_OES +_m[0x0B13] = (1,) # GL_POINT_SIZE_GRANULARITY +_m[0x8127] = (1,) # GL_POINT_SIZE_MAX +_m[0x8127] = (1,) # GL_POINT_SIZE_MAX_ARB +_m[0x8127] = (1,) # GL_POINT_SIZE_MAX_SGIS +_m[0x8126] = (1,) # GL_POINT_SIZE_MIN +_m[0x8126] = (1,) # GL_POINT_SIZE_MIN_ARB +_m[0x8126] = (1,) # GL_POINT_SIZE_MIN_SGIS +_m[0x0B12] = (2,) # GL_POINT_SIZE_RANGE +_m[0x0B10] = (1,) # GL_POINT_SMOOTH +_m[0x0C51] = (1,) # GL_POINT_SMOOTH_HINT +_m[0x8861] = (1,) # GL_POINT_SPRITE +_m[0x8861] = (1,) # GL_POINT_SPRITE_ARB +_m[0x8CA0] = (1,) # GL_POINT_SPRITE_COORD_ORIGIN +_m[0x8861] = (1,) # GL_POINT_SPRITE_NV +_m[0x8863] = (1,) # GL_POINT_SPRITE_R_MODE_NV +_m[0x0B40] = (2,) # GL_POLYGON_MODE +_m[0x8039] = (1,) # GL_POLYGON_OFFSET_BIAS_EXT +_m[0x8E1B] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/ARB/ARB_polygon_offset_clamp.txt # GL_POLYGON_OFFSET_CLAMP +_m[0x8E1B] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/EXT/EXT_polygon_offset_clamp.txt # GL_POLYGON_OFFSET_CLAMP_EXT +_m[0x8037] = (1,) # GL_POLYGON_OFFSET_EXT +_m[0x8038] = (1,) # GL_POLYGON_OFFSET_FACTOR +_m[0x8038] = (1,) # GL_POLYGON_OFFSET_FACTOR_EXT +_m[0x8037] = (1,) # GL_POLYGON_OFFSET_FILL +_m[0x2A02] = (1,) # GL_POLYGON_OFFSET_LINE +_m[0x2A01] = (1,) # GL_POLYGON_OFFSET_POINT +_m[0x2A00] = (1,) # GL_POLYGON_OFFSET_UNITS +_m[0x0B41] = (1,) # GL_POLYGON_SMOOTH +_m[0x0C53] = (1,) # GL_POLYGON_SMOOTH_HINT +_m[0x0B42] = (1,) # GL_POLYGON_STIPPLE +_m[0x1203] = (4,) # GL_POSITION +_m[0x80BB] = (1,) # GL_POST_COLOR_MATRIX_ALPHA_BIAS +_m[0x80BB] = (1,) # GL_POST_COLOR_MATRIX_ALPHA_BIAS_SGI +_m[0x80B7] = (1,) # GL_POST_COLOR_MATRIX_ALPHA_SCALE +_m[0x80B7] = (1,) # GL_POST_COLOR_MATRIX_ALPHA_SCALE_SGI +_m[0x80BA] = (1,) # GL_POST_COLOR_MATRIX_BLUE_BIAS +_m[0x80BA] = (1,) # GL_POST_COLOR_MATRIX_BLUE_BIAS_SGI +_m[0x80B6] = (1,) # GL_POST_COLOR_MATRIX_BLUE_SCALE +_m[0x80B6] = (1,) # GL_POST_COLOR_MATRIX_BLUE_SCALE_SGI +_m[0x80D2] = (1,) # GL_POST_COLOR_MATRIX_COLOR_TABLE +_m[0x80D2] = (1,) # GL_POST_COLOR_MATRIX_COLOR_TABLE_SGI +_m[0x80B9] = (1,) # GL_POST_COLOR_MATRIX_GREEN_BIAS +_m[0x80B9] = (1,) # GL_POST_COLOR_MATRIX_GREEN_BIAS_SGI +_m[0x80B5] = (1,) # GL_POST_COLOR_MATRIX_GREEN_SCALE +_m[0x80B5] = (1,) # GL_POST_COLOR_MATRIX_GREEN_SCALE_SGI +_m[0x80B8] = (1,) # GL_POST_COLOR_MATRIX_RED_BIAS +_m[0x80B8] = (1,) # GL_POST_COLOR_MATRIX_RED_BIAS_SGI +_m[0x80B4] = (1,) # GL_POST_COLOR_MATRIX_RED_SCALE +_m[0x80B4] = (1,) # GL_POST_COLOR_MATRIX_RED_SCALE_SGI +_m[0x8023] = (1,) # GL_POST_CONVOLUTION_ALPHA_BIAS +_m[0x8023] = (1,) # GL_POST_CONVOLUTION_ALPHA_BIAS_EXT +_m[0x801F] = (1,) # GL_POST_CONVOLUTION_ALPHA_SCALE +_m[0x801F] = (1,) # GL_POST_CONVOLUTION_ALPHA_SCALE_EXT +_m[0x8022] = (1,) # GL_POST_CONVOLUTION_BLUE_BIAS +_m[0x8022] = (1,) # GL_POST_CONVOLUTION_BLUE_BIAS_EXT +_m[0x801E] = (1,) # GL_POST_CONVOLUTION_BLUE_SCALE +_m[0x801E] = (1,) # GL_POST_CONVOLUTION_BLUE_SCALE_EXT +_m[0x80D1] = (1,) # GL_POST_CONVOLUTION_COLOR_TABLE +_m[0x80D1] = (1,) # GL_POST_CONVOLUTION_COLOR_TABLE_SGI +_m[0x8021] = (1,) # GL_POST_CONVOLUTION_GREEN_BIAS +_m[0x8021] = (1,) # GL_POST_CONVOLUTION_GREEN_BIAS_EXT +_m[0x801D] = (1,) # GL_POST_CONVOLUTION_GREEN_SCALE +_m[0x801D] = (1,) # GL_POST_CONVOLUTION_GREEN_SCALE_EXT +_m[0x8020] = (1,) # GL_POST_CONVOLUTION_RED_BIAS +_m[0x8020] = (1,) # GL_POST_CONVOLUTION_RED_BIAS_EXT +_m[0x801C] = (1,) # GL_POST_CONVOLUTION_RED_SCALE +_m[0x801C] = (1,) # GL_POST_CONVOLUTION_RED_SCALE_EXT +_m[0x817B] = (1,) # GL_POST_TEXTURE_FILTER_BIAS_RANGE_SGIX +_m[0x8179] = (1,) # GL_POST_TEXTURE_FILTER_BIAS_SGIX +_m[0x817C] = (1,) # GL_POST_TEXTURE_FILTER_SCALE_RANGE_SGIX +_m[0x817A] = (1,) # GL_POST_TEXTURE_FILTER_SCALE_SGIX +_m[0x86E4] = (1,) # GL_PREVIOUS_TEXTURE_INPUT_NV +_m[0x92BE] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/ARB/ARB_ES3_2_compatibility.txt # GL_PRIMITIVE_BOUNDING_BOX_ARB +_m[0x92BE] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/EXT/EXT_primitive_bounding_box.txt # GL_PRIMITIVE_BOUNDING_BOX_EXT +_m[0x92BE] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/OES/OES_primitive_bounding_box.txt # GL_PRIMITIVE_BOUNDING_BOX_OES +_m[0x8F9D] = (1,) # GL_PRIMITIVE_RESTART +_m[0x8D69] = (1,) # GL_PRIMITIVE_RESTART_FIXED_INDEX +_m[0x8221] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/EXT/EXT_tessellation_shader.txt # GL_PRIMITIVE_RESTART_FOR_PATCHES_SUPPORTED +_m[0x8F9E] = (1,) # GL_PRIMITIVE_RESTART_INDEX +_m[0x8559] = (1,) # GL_PRIMITIVE_RESTART_INDEX_NV +_m[0x8558] = (1,) # GL_PRIMITIVE_RESTART_NV +_m[0x9341] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/ARB/ARB_sample_locations.txt # GL_PROGRAMMABLE_SAMPLE_LOCATION_ARB +_m[0x9341] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_sample_locations.txt # GL_PROGRAMMABLE_SAMPLE_LOCATION_NV +_m[0x9340] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/ARB/ARB_sample_locations.txt # GL_PROGRAMMABLE_SAMPLE_LOCATION_TABLE_SIZE_ARB +_m[0x9340] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_sample_locations.txt # GL_PROGRAMMABLE_SAMPLE_LOCATION_TABLE_SIZE_NV +_m[0x88B0] = (1,) # GL_PROGRAM_ADDRESS_REGISTERS_ARB +_m[0x8805] = (1,) # GL_PROGRAM_ALU_INSTRUCTIONS_ARB +_m[0x88AC] = (1,) # GL_PROGRAM_ATTRIBS_ARB +_m[0x8906] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/gpu_program4.txt # GL_PROGRAM_ATTRIB_COMPONENTS_NV +_m[0x87FF] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/get_program_binary.txt # GL_PROGRAM_BINARY_FORMATS +_m[0x8741] = (1,) # GL_PROGRAM_BINARY_LENGTH +_m[0x8677] = (1,) # GL_PROGRAM_BINDING_ARB +_m[0x864B] = (1,) # GL_PROGRAM_ERROR_POSITION_ARB +_m[0x864B] = (1,) # GL_PROGRAM_ERROR_POSITION_NV +_m[0x8874] = (1,) # GL_PROGRAM_ERROR_STRING_ARB +_m[0x8876] = (1,) # GL_PROGRAM_FORMAT_ARB +_m[0x88A0] = (1,) # GL_PROGRAM_INSTRUCTIONS_ARB +_m[0x8627] = (1,) # GL_PROGRAM_LENGTH_ARB +_m[0x8627] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/vertex_program.txt # GL_PROGRAM_LENGTH_NV +_m[0x8E2D] = (1,)#TODO Review http://www.opengl.org/registry/specs//EXT/direct_state_access.txt # GL_PROGRAM_MATRIX_EXT +_m[0x8E2F] = (1,)#TODO Review http://www.opengl.org/registry/specs//EXT/direct_state_access.txt # GL_PROGRAM_MATRIX_STACK_DEPTH_EXT +_m[0x88B2] = (1,) # GL_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB +_m[0x8808] = (1,) # GL_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB +_m[0x88AE] = (1,) # GL_PROGRAM_NATIVE_ATTRIBS_ARB +_m[0x88A2] = (1,) # GL_PROGRAM_NATIVE_INSTRUCTIONS_ARB +_m[0x88AA] = (1,) # GL_PROGRAM_NATIVE_PARAMETERS_ARB +_m[0x88A6] = (1,) # GL_PROGRAM_NATIVE_TEMPORARIES_ARB +_m[0x880A] = (1,) # GL_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB +_m[0x8809] = (1,) # GL_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB +_m[0x8B40] = (1,) # GL_PROGRAM_OBJECT_ARB +_m[0x88A8] = (1,) # GL_PROGRAM_PARAMETERS_ARB +_m[0x8644] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/vertex_program.txt # GL_PROGRAM_PARAMETER_NV +_m[0x825A] = (1,) # GL_PROGRAM_PIPELINE_BINDING +_m[0x8642] = (1,) # GL_PROGRAM_POINT_SIZE +_m[0x8642] = (1,) # GL_PROGRAM_POINT_SIZE_ARB +_m[0x8642] = (1,) # GL_PROGRAM_POINT_SIZE_EXT +_m[0x8647] = (1,) # GL_PROGRAM_RESIDENT_NV +_m[0x8907] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/gpu_program4.txt # GL_PROGRAM_RESULT_COMPONENTS_NV +_m[0x8628] = (1,) # GL_PROGRAM_STRING_ARB +_m[0x8628] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/vertex_program.txt # GL_PROGRAM_STRING_NV +_m[0x8646] = (1,) # GL_PROGRAM_TARGET_NV +_m[0x88A4] = (1,) # GL_PROGRAM_TEMPORARIES_ARB +_m[0x8807] = (1,) # GL_PROGRAM_TEX_INDIRECTIONS_ARB +_m[0x8806] = (1,) # GL_PROGRAM_TEX_INSTRUCTIONS_ARB +_m[0x88B6] = (1,) # GL_PROGRAM_UNDER_NATIVE_LIMITS_ARB +_m[0x0BA7] = (4, 4) # GL_PROJECTION_MATRIX +_m[0x898E] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/OES/OES_matrix_get.txt # GL_PROJECTION_MATRIX_FLOAT_AS_INT_BITS_OES +_m[0x0BA4] = (1,) # GL_PROJECTION_STACK_DEPTH +_m[0x8E4F] = (1,) # GL_PROVOKING_VERTEX +_m[0x8E4F] = (1,) # GL_PROVOKING_VERTEX_EXT +_m[0x1209] = (1,) # GL_QUADRATIC_ATTENUATION +_m[0x8E4C] = (1,) # GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION +_m[0x8E4C] = (1,) # GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION_EXT +_m[0x9193] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/query_buffer_object.txt # GL_QUERY_BUFFER_BINDING +_m[0x9193] = (1,) # GL_QUERY_BUFFER_BINDING_AMD +_m[0x8864] = (1,) # GL_QUERY_COUNTER_BITS +_m[0x8864] = (1,) # GL_QUERY_COUNTER_BITS_ARB +_m[0x8866] = (1,) # GL_QUERY_RESULT +_m[0x8867] = (1,) # GL_QUERY_RESULT_AVAILABLE +_m[0x9194] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/query_buffer_object.txt # GL_QUERY_RESULT_NO_WAIT +_m[0x82EA] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/direct_state_access.txt # GL_QUERY_TARGET +_m[0x8C89] = (1,) # GL_RASTERIZER_DISCARD +_m[0x932A] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_framebuffer_mixed_samples.txt # GL_RASTER_FIXED_SAMPLE_LOCATIONS_EXT +_m[0x19262] = (1,) # GL_RASTER_POSITION_UNCLIPPED_IBM +_m[0x9328] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_framebuffer_mixed_samples.txt # GL_RASTER_SAMPLES_EXT +_m[0x0C02] = (1,) # GL_READ_BUFFER +_m[0x0C02] = (1,) # GL_READ_BUFFER_EXT +_m[0x0C02] = (1,) # GL_READ_BUFFER_NV +_m[0x8CA8] = (1,) # GL_READ_FRAMEBUFFER +_m[0x8CAA] = (1,) # GL_READ_FRAMEBUFFER_BINDING +_m[0x828C] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_READ_PIXELS +_m[0x828D] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_READ_PIXELS_FORMAT +_m[0x828E] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_READ_PIXELS_TYPE +_m[0x887B] = (1,) # GL_READ_PIXEL_DATA_RANGE_LENGTH_NV +_m[0x887D] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/pixel_data_range.txt # GL_READ_PIXEL_DATA_RANGE_POINTER_NV +_m[0x0D15] = (1,) # GL_RED_BIAS +_m[0x0D52] = (1,) # GL_RED_BITS +_m[0x8564] = (1,) # GL_RED_MAX_CLAMP_INGR +_m[0x8560] = (1,) # GL_RED_MIN_CLAMP_INGR +_m[0x0D14] = (1,) # GL_RED_SCALE +_m[0x930B] = (1,) # GL_REFERENCED_BY_COMPUTE_SHADER +_m[0x930A] = (1,) # GL_REFERENCED_BY_FRAGMENT_SHADER +_m[0x9309] = (1,) # GL_REFERENCED_BY_GEOMETRY_SHADER +_m[0x9307] = (1,) # GL_REFERENCED_BY_TESS_CONTROL_SHADER +_m[0x9308] = (1,) # GL_REFERENCED_BY_TESS_EVALUATION_SHADER +_m[0x9306] = (1,) # GL_REFERENCED_BY_VERTEX_SHADER +_m[0x817E] = (4,) # GL_REFERENCE_PLANE_EQUATION_SGIX +_m[0x817D] = (1,) # GL_REFERENCE_PLANE_SGIX +_m[0x8522] = (1,) # GL_REGISTER_COMBINERS_NV +_m[0x8D53] = (1,) # GL_RENDERBUFFER_ALPHA_SIZE +_m[0x8CA7] = (1,) # GL_RENDERBUFFER_BINDING +_m[0x8CA7] = (1,) # GL_RENDERBUFFER_BINDING_EXT +_m[0x8D52] = (1,) # GL_RENDERBUFFER_BLUE_SIZE +_m[0x8E10] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/framebuffer_multisample_coverage.txt # GL_RENDERBUFFER_COLOR_SAMPLES_NV +_m[0x8CAB] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/framebuffer_multisample_coverage.txt # GL_RENDERBUFFER_COVERAGE_SAMPLES_NV +_m[0x8D54] = (1,) # GL_RENDERBUFFER_DEPTH_SIZE +_m[0x87FD] = (1,) # GL_RENDERBUFFER_FREE_MEMORY_ATI +_m[0x8D51] = (1,) # GL_RENDERBUFFER_GREEN_SIZE +_m[0x8D43] = (1,) # GL_RENDERBUFFER_HEIGHT +_m[0x8D44] = (1,) # GL_RENDERBUFFER_INTERNAL_FORMAT +_m[0x8D50] = (1,) # GL_RENDERBUFFER_RED_SIZE +_m[0x8CAB] = (1,) # GL_RENDERBUFFER_SAMPLES +_m[0x9133] = (1,) # GL_RENDERBUFFER_SAMPLES_IMG +_m[0x8D55] = (1,) # GL_RENDERBUFFER_STENCIL_SIZE +_m[0x91B2] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/AMD/AMD_framebuffer_multisample_advanced.txt # GL_RENDERBUFFER_STORAGE_SAMPLES_AMD +_m[0x8D42] = (1,) # GL_RENDERBUFFER_WIDTH +_m[0x1F01] = (1,) # GL_RENDERER +_m[0x9558] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_gpu_multicast.txt # GL_RENDER_GPU_MASK_NV +_m[0x0C40] = (1,) # GL_RENDER_MODE +_m[0x85C2] = (1,) # GL_REPLACEMENT_CODE_ARRAY_STRIDE_SUN +_m[0x85C1] = (1,) # GL_REPLACEMENT_CODE_ARRAY_TYPE_SUN +_m[0x81D8] = (1,) # GL_REPLACEMENT_CODE_SUN +_m[0x937F] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_representative_fragment_test.txt # GL_REPRESENTATIVE_FRAGMENT_TEST_NV +_m[0x803A] = (1,) # GL_RESCALE_NORMAL +_m[0x803A] = (1,) # GL_RESCALE_NORMAL_EXT +_m[0x8256] = (1,)#TODO Review http://www.opengl.org/registry/specs//KHR/robustness.txt # GL_RESET_NOTIFICATION_STRATEGY +_m[0x8256] = (1,) # GL_RESET_NOTIFICATION_STRATEGY_ARB +_m[0x8820] = (1,) # GL_RGBA_FLOAT_MODE_ARB +_m[0x8820] = (1,) # GL_RGBA_FLOAT_MODE_ATI +_m[0x8D9E] = (1,) # GL_RGBA_INTEGER_MODE_EXT +_m[0x0C31] = (1,) # GL_RGBA_MODE +_m[0x8C3C] = (1,) # GL_RGBA_SIGNED_COMPONENTS_EXT +_m[0x86D9] = (1,) # GL_RGBA_UNSIGNED_DOT_PRODUCT_MAPPING_NV +_m[0x8573] = (1,) # GL_RGB_SCALE +_m[0x8919] = (1,) # GL_SAMPLER_BINDING +_m[0x80A9] = (1,) # GL_SAMPLES +_m[0x86B4] = (1,) # GL_SAMPLES_3DFX +_m[0x80A9] = (1,) # GL_SAMPLES_ARB +_m[0x80A9] = (1,) # GL_SAMPLES_SGIS +_m[0x809E] = (1,) # GL_SAMPLE_ALPHA_TO_COVERAGE +_m[0x809E] = (1,) # GL_SAMPLE_ALPHA_TO_COVERAGE_ARB +_m[0x809E] = (1,) # GL_SAMPLE_ALPHA_TO_MASK_EXT +_m[0x809E] = (1,) # GL_SAMPLE_ALPHA_TO_MASK_SGIS +_m[0x809F] = (1,) # GL_SAMPLE_ALPHA_TO_ONE +_m[0x809F] = (1,) # GL_SAMPLE_ALPHA_TO_ONE_ARB +_m[0x809F] = (1,) # GL_SAMPLE_ALPHA_TO_ONE_EXT +_m[0x809F] = (1,) # GL_SAMPLE_ALPHA_TO_ONE_SGIS +_m[0x80A8] = (1,) # GL_SAMPLE_BUFFERS +_m[0x86B3] = (1,) # GL_SAMPLE_BUFFERS_3DFX +_m[0x80A8] = (1,) # GL_SAMPLE_BUFFERS_ARB +_m[0x80A8] = (1,) # GL_SAMPLE_BUFFERS_SGIS +_m[0x80A0] = (1,) # GL_SAMPLE_COVERAGE +_m[0x80A0] = (1,) # GL_SAMPLE_COVERAGE_ARB +_m[0x80AB] = (1,) # GL_SAMPLE_COVERAGE_INVERT +_m[0x80AB] = (1,) # GL_SAMPLE_COVERAGE_INVERT_ARB +_m[0x80AA] = (1,) # GL_SAMPLE_COVERAGE_VALUE +_m[0x80AA] = (1,) # GL_SAMPLE_COVERAGE_VALUE_ARB +_m[0x8E50] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/ARB/ARB_sample_locations.txt # GL_SAMPLE_LOCATION_ARB +_m[0x8E50] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_sample_locations.txt # GL_SAMPLE_LOCATION_NV +_m[0x933F] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/ARB/ARB_sample_locations.txt # GL_SAMPLE_LOCATION_PIXEL_GRID_HEIGHT_ARB +_m[0x933F] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_sample_locations.txt # GL_SAMPLE_LOCATION_PIXEL_GRID_HEIGHT_NV +_m[0x933E] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/ARB/ARB_sample_locations.txt # GL_SAMPLE_LOCATION_PIXEL_GRID_WIDTH_ARB +_m[0x933E] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_sample_locations.txt # GL_SAMPLE_LOCATION_PIXEL_GRID_WIDTH_NV +_m[0x933D] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/ARB/ARB_sample_locations.txt # GL_SAMPLE_LOCATION_SUBPIXEL_BITS_ARB +_m[0x933D] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_sample_locations.txt # GL_SAMPLE_LOCATION_SUBPIXEL_BITS_NV +_m[0x8E51] = (1,) # GL_SAMPLE_MASK +_m[0x80A0] = (1,) # GL_SAMPLE_MASK_EXT +_m[0x80AB] = (1,) # GL_SAMPLE_MASK_INVERT_SGIS +_m[0x8E51] = (1,) # GL_SAMPLE_MASK_NV +_m[0x80A0] = (1,) # GL_SAMPLE_MASK_SGIS +_m[0x8E52] = (1,) # GL_SAMPLE_MASK_VALUE +_m[0x80AA] = (1,) # GL_SAMPLE_MASK_VALUE_SGIS +_m[0x80AC] = (1,) # GL_SAMPLE_PATTERN_EXT +_m[0x80AC] = (1,) # GL_SAMPLE_PATTERN_SGIS +_m[0x8E50] = (2,) # GL_SAMPLE_POSITION +_m[0x8C36] = (1,) # GL_SAMPLE_SHADING_ARB +_m[0x8C36] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/OES/OES_sample_shading.txt # GL_SAMPLE_SHADING_OES +_m[0x0C10] = (4,) # GL_SCISSOR_BOX +_m[0x9556] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_scissor_exclusive.txt # GL_SCISSOR_BOX_EXCLUSIVE_NV +_m[0x0C11] = (1,) # GL_SCISSOR_TEST +_m[0x9555] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_scissor_exclusive.txt # GL_SCISSOR_TEST_EXCLUSIVE_NV +_m[0x845E] = (1,) # GL_SECONDARY_COLOR_ARRAY +_m[0x889C] = (1,) # GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING +_m[0x889C] = (1,) # GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING_ARB +_m[0x8F31] = (1,) # GL_SECONDARY_COLOR_ARRAY_LENGTH_NV +_m[0x845D] = (1,)#TODO Review http://www.opengl.org/registry/specs//EXT/secondary_color.txt # GL_SECONDARY_COLOR_ARRAY_POINTER_EXT +_m[0x845A] = (1,) # GL_SECONDARY_COLOR_ARRAY_SIZE +_m[0x845A] = (1,) # GL_SECONDARY_COLOR_ARRAY_SIZE_EXT +_m[0x845C] = (1,) # GL_SECONDARY_COLOR_ARRAY_STRIDE +_m[0x845C] = (1,) # GL_SECONDARY_COLOR_ARRAY_STRIDE_EXT +_m[0x845B] = (1,) # GL_SECONDARY_COLOR_ARRAY_TYPE +_m[0x845B] = (1,) # GL_SECONDARY_COLOR_ARRAY_TYPE_EXT +_m[0x0DF3] = (1,) # GL_SELECTION_BUFFER_POINTER +_m[0x0DF4] = (1,) # GL_SELECTION_BUFFER_SIZE +_m[0x8012] = (1,) # GL_SEPARABLE_2D +_m[0x8012] = (1,) # GL_SEPARABLE_2D_EXT +_m[0x8DF8] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/ES2_compatibility.txt # GL_SHADER_BINARY_FORMATS +_m[0x8DFA] = (1,) # GL_SHADER_COMPILER +_m[0x82A6] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_SHADER_IMAGE_ATOMIC +_m[0x82A4] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_SHADER_IMAGE_LOAD +_m[0x82A5] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_SHADER_IMAGE_STORE +_m[0x86DF] = (1,) # GL_SHADER_OPERATION_NV +_m[0x8F64] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/EXT/EXT_shader_pixel_local_storage.txt # GL_SHADER_PIXEL_LOCAL_STORAGE_EXT +_m[0x8B88] = (1,) # GL_SHADER_SOURCE_LENGTH +_m[0x90D2] = (1,) # GL_SHADER_STORAGE_BUFFER +_m[0x90D3] = (1,) # GL_SHADER_STORAGE_BUFFER_BINDING +_m[0x90DF] = (1,) # GL_SHADER_STORAGE_BUFFER_OFFSET_ALIGNMENT +_m[0x90D5] = (1,) # GL_SHADER_STORAGE_BUFFER_SIZE +_m[0x90D4] = (1,) # GL_SHADER_STORAGE_BUFFER_START +_m[0x8B4F] = (1,) # GL_SHADER_TYPE +_m[0x0B54] = (1,) # GL_SHADE_MODEL +_m[0x8B8C] = (1,) # GL_SHADING_LANGUAGE_VERSION +_m[0x955B] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_shading_rate_image.txt # GL_SHADING_RATE_IMAGE_BINDING_NV +_m[0x9563] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_shading_rate_image.txt # GL_SHADING_RATE_IMAGE_NV +_m[0x955E] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_shading_rate_image.txt # GL_SHADING_RATE_IMAGE_PALETTE_SIZE_NV +_m[0x955D] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_shading_rate_image.txt # GL_SHADING_RATE_IMAGE_TEXEL_HEIGHT_NV +_m[0x955C] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_shading_rate_image.txt # GL_SHADING_RATE_IMAGE_TEXEL_WIDTH_NV +_m[0x1601] = (1,) # GL_SHININESS +_m[0x82AC] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_SIMULTANEOUS_TEXTURE_AND_DEPTH_TEST +_m[0x82AE] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_SIMULTANEOUS_TEXTURE_AND_DEPTH_WRITE +_m[0x82AD] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_SIMULTANEOUS_TEXTURE_AND_STENCIL_TEST +_m[0x82AF] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_SIMULTANEOUS_TEXTURE_AND_STENCIL_WRITE +_m[0x0B23] = (1,) # GL_SMOOTH_LINE_WIDTH_GRANULARITY +_m[0x0B22] = (2,) # GL_SMOOTH_LINE_WIDTH_RANGE +_m[0x0B13] = (1,) # GL_SMOOTH_POINT_SIZE_GRANULARITY +_m[0x0B12] = (2,) # GL_SMOOTH_POINT_SIZE_RANGE +_m[0x933B] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/shader_thread_group.txt # GL_SM_COUNT_NV +_m[0x858B] = (1,) # GL_SOURCE3_ALPHA_NV +_m[0x8583] = (1,) # GL_SOURCE3_RGB_NV +_m[0x82F8] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/sparse_buffer.txt # GL_SPARSE_BUFFER_PAGE_SIZE_ARB +_m[0x91A9] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/sparse_texture.txt # GL_SPARSE_TEXTURE_FULL_ARRAY_CUBE_MIPMAPS_ARB +_m[0x91A9] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/EXT/EXT_sparse_texture.txt # GL_SPARSE_TEXTURE_FULL_ARRAY_CUBE_MIPMAPS_EXT +_m[0x1202] = (4,) # GL_SPECULAR +_m[0x9552] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/ARB/ARB_gl_spirv.txt # GL_SPIR_V_BINARY_ARB +_m[0x1206] = (1,) # GL_SPOT_CUTOFF +_m[0x1204] = (3,) # GL_SPOT_DIRECTION +_m[0x1205] = (1,) # GL_SPOT_EXPONENT +_m[0x814A] = (3,) # GL_SPRITE_AXIS_SGIX +_m[0x8149] = (1,) # GL_SPRITE_MODE_SGIX +_m[0x8148] = (1,) # GL_SPRITE_SGIX +_m[0x814B] = (3,) # GL_SPRITE_TRANSLATION_SGIX +_m[0x8588] = (1,) # GL_SRC0_ALPHA +_m[0x8580] = (1,) # GL_SRC0_RGB +_m[0x8589] = (1,) # GL_SRC1_ALPHA +_m[0x8581] = (1,) # GL_SRC1_RGB +_m[0x858A] = (1,) # GL_SRC2_ALPHA +_m[0x8582] = (1,) # GL_SRC2_RGB +_m[0x8299] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_SRGB_DECODE_ARB +_m[0x8297] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_SRGB_READ +_m[0x8298] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_SRGB_WRITE +_m[0x8801] = (1,) # GL_STENCIL_BACK_FAIL +_m[0x8801] = (1,) # GL_STENCIL_BACK_FAIL_ATI +_m[0x8800] = (1,) # GL_STENCIL_BACK_FUNC +_m[0x8800] = (1,) # GL_STENCIL_BACK_FUNC_ATI +_m[0x874D] = (1,) # GL_STENCIL_BACK_OP_VALUE_AMD +_m[0x8802] = (1,) # GL_STENCIL_BACK_PASS_DEPTH_FAIL +_m[0x8802] = (1,) # GL_STENCIL_BACK_PASS_DEPTH_FAIL_ATI +_m[0x8803] = (1,) # GL_STENCIL_BACK_PASS_DEPTH_PASS +_m[0x8803] = (1,) # GL_STENCIL_BACK_PASS_DEPTH_PASS_ATI +_m[0x8CA3] = (1,) # GL_STENCIL_BACK_REF +_m[0x8CA4] = (1,) # GL_STENCIL_BACK_VALUE_MASK +_m[0x8CA5] = (1,) # GL_STENCIL_BACK_WRITEMASK +_m[0x0D57] = (1,) # GL_STENCIL_BITS +_m[0x88F3] = (1,) # GL_STENCIL_CLEAR_TAG_VALUE_EXT +_m[0x0B91] = (1,) # GL_STENCIL_CLEAR_VALUE +_m[0x8285] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_STENCIL_COMPONENTS +_m[0x0B94] = (1,) # GL_STENCIL_FAIL +_m[0x0B92] = (1,) # GL_STENCIL_FUNC +_m[0x874C] = (1,) # GL_STENCIL_OP_VALUE_AMD +_m[0x0B95] = (1,) # GL_STENCIL_PASS_DEPTH_FAIL +_m[0x0B96] = (1,) # GL_STENCIL_PASS_DEPTH_PASS +_m[0x0B97] = (1,) # GL_STENCIL_REF +_m[0x8288] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_STENCIL_RENDERABLE +_m[0x932E] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_framebuffer_mixed_samples.txt # GL_STENCIL_SAMPLES_NV +_m[0x88F2] = (1,) # GL_STENCIL_TAG_BITS_EXT +_m[0x0B90] = (1,) # GL_STENCIL_TEST +_m[0x8910] = (1,) # GL_STENCIL_TEST_TWO_SIDE_EXT +_m[0x0B93] = (1,) # GL_STENCIL_VALUE_MASK +_m[0x0B98] = (1,) # GL_STENCIL_WRITEMASK +_m[0x0C33] = (1,) # GL_STEREO +_m[0x00000004] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/KHR/KHR_shader_subgroup.txt # GL_SUBGROUP_FEATURE_ARITHMETIC_BIT_KHR +_m[0x00000008] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/KHR/KHR_shader_subgroup.txt # GL_SUBGROUP_FEATURE_BALLOT_BIT_KHR +_m[0x00000001] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/KHR/KHR_shader_subgroup.txt # GL_SUBGROUP_FEATURE_BASIC_BIT_KHR +_m[0x00000040] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/KHR/KHR_shader_subgroup.txt # GL_SUBGROUP_FEATURE_CLUSTERED_BIT_KHR +_m[0x00000100] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_shader_subgroup_partitioned.txt # GL_SUBGROUP_FEATURE_PARTITIONED_BIT_NV +_m[0x00000080] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/KHR/KHR_shader_subgroup.txt # GL_SUBGROUP_FEATURE_QUAD_BIT_KHR +_m[0x00000010] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/KHR/KHR_shader_subgroup.txt # GL_SUBGROUP_FEATURE_SHUFFLE_BIT_KHR +_m[0x00000020] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/KHR/KHR_shader_subgroup.txt # GL_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT_KHR +_m[0x00000002] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/KHR/KHR_shader_subgroup.txt # GL_SUBGROUP_FEATURE_VOTE_BIT_KHR +_m[0x9535] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/KHR/KHR_shader_subgroup.txt # GL_SUBGROUP_QUAD_ALL_STAGES_KHR +_m[0x9532] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/KHR/KHR_shader_subgroup.txt # GL_SUBGROUP_SIZE_KHR +_m[0x9534] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/KHR/KHR_shader_subgroup.txt # GL_SUBGROUP_SUPPORTED_FEATURES_KHR +_m[0x9533] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/KHR/KHR_shader_subgroup.txt # GL_SUBGROUP_SUPPORTED_STAGES_KHR +_m[0x0D50] = (1,) # GL_SUBPIXEL_BITS +_m[0x9347] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_conservative_raster.txt # GL_SUBPIXEL_PRECISION_BIAS_X_BITS_NV +_m[0x9348] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_conservative_raster.txt # GL_SUBPIXEL_PRECISION_BIAS_Y_BITS_NV +_m[0x883F] = (1,)#TODO Review http://www.opengl.org/registry/specs//AMD/sample_positions.txt # GL_SUBSAMPLE_DISTANCE_AMD +_m[0x9372] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_internalformat_sample_query.txt # GL_SUPERSAMPLE_SCALE_X_NV +_m[0x9373] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_internalformat_sample_query.txt # GL_SUPERSAMPLE_SCALE_Y_NV +_m[0x91B7] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/AMD/AMD_framebuffer_multisample_advanced.txt # GL_SUPPORTED_MULTISAMPLE_MODES_AMD +_m[0x9113] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/sync.txt # GL_SYNC_CONDITION +_m[0x9115] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/sync.txt # GL_SYNC_FLAGS +_m[0x9114] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/sync.txt # GL_SYNC_STATUS +_m[0x8439] = (1,) # GL_TANGENT_ARRAY_EXT +_m[0x8442] = (1,) # GL_TANGENT_ARRAY_POINTER_EXT +_m[0x843F] = (1,) # GL_TANGENT_ARRAY_STRIDE_EXT +_m[0x843E] = (1,) # GL_TANGENT_ARRAY_TYPE_EXT +_m[0x953F] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_TASK_WORK_GROUP_SIZE_NV +_m[0x9004] = (1,) # GL_TESSELLATION_MODE_AMD +_m[0x8E75] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/tessellation_shader.txt # GL_TESS_CONTROL_OUTPUT_VERTICES +_m[0x891E] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/tessellation_program5.txt # GL_TESS_CONTROL_PROGRAM_NV +_m[0x8E88] = (1,) # GL_TESS_CONTROL_SHADER +_m[0x829C] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_TESS_CONTROL_TEXTURE +_m[0x891F] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/tessellation_program5.txt # GL_TESS_EVALUATION_PROGRAM_NV +_m[0x8E87] = (1,) # GL_TESS_EVALUATION_SHADER +_m[0x829D] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_TESS_EVALUATION_TEXTURE +_m[0x8E76] = (1,) # GL_TESS_GEN_MODE +_m[0x8E79] = (1,) # GL_TESS_GEN_POINT_MODE +_m[0x8E77] = (1,) # GL_TESS_GEN_SPACING +_m[0x8E78] = (1,) # GL_TESS_GEN_VERTEX_ORDER +_m[0x0DE0] = (1,) # GL_TEXTURE_1D +_m[0x8C18] = (1,) # GL_TEXTURE_1D_ARRAY +_m[0x8068] = (1,) # GL_TEXTURE_1D_BINDING_EXT +_m[0x875D] = (1,) # GL_TEXTURE_1D_STACK_BINDING_MESAX +_m[0x8759] = (1,) # GL_TEXTURE_1D_STACK_MESAX +_m[0x0DE1] = (1,) # GL_TEXTURE_2D +_m[0x8C1A] = (1,) # GL_TEXTURE_2D_ARRAY +_m[0x8069] = (1,) # GL_TEXTURE_2D_BINDING_EXT +_m[0x875E] = (1,) # GL_TEXTURE_2D_STACK_BINDING_MESAX +_m[0x875A] = (1,) # GL_TEXTURE_2D_STACK_MESAX +_m[0x806F] = (1,) # GL_TEXTURE_3D +_m[0x806A] = (1,) # GL_TEXTURE_3D_BINDING_EXT +_m[0x806F] = (1,) # GL_TEXTURE_3D_EXT +_m[0x806F] = (1,) # GL_TEXTURE_3D_OES +_m[0x814F] = (1,) # GL_TEXTURE_4D_BINDING_SGIS +_m[0x8134] = (1,) # GL_TEXTURE_4D_SGIS +_m[0x805F] = (1,) # GL_TEXTURE_ALPHA_SIZE +_m[0x8C13] = (1,) # GL_TEXTURE_ALPHA_TYPE +_m[0x834F] = (1,) # GL_TEXTURE_APPLICATION_MODE_EXT +_m[0x813C] = (1,) # GL_TEXTURE_BASE_LEVEL +_m[0x813C] = (1,) # GL_TEXTURE_BASE_LEVEL_SGIS +_m[0x8068] = (1,) # GL_TEXTURE_BINDING_1D +_m[0x8C1C] = (1,) # GL_TEXTURE_BINDING_1D_ARRAY +_m[0x8C1C] = (1,) # GL_TEXTURE_BINDING_1D_ARRAY_EXT +_m[0x8069] = (1,) # GL_TEXTURE_BINDING_2D +_m[0x8C1D] = (1,) # GL_TEXTURE_BINDING_2D_ARRAY +_m[0x8C1D] = (1,) # GL_TEXTURE_BINDING_2D_ARRAY_EXT +_m[0x9104] = (1,) # GL_TEXTURE_BINDING_2D_MULTISAMPLE +_m[0x9105] = (1,) # GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY +_m[0x806A] = (1,) # GL_TEXTURE_BINDING_3D +_m[0x8C2C] = (1,) # GL_TEXTURE_BINDING_BUFFER +_m[0x8C2C] = (1,) # GL_TEXTURE_BINDING_BUFFER_ARB +_m[0x8C2C] = (1,) # GL_TEXTURE_BINDING_BUFFER_EXT +_m[0x8514] = (1,) # GL_TEXTURE_BINDING_CUBE_MAP +_m[0x8514] = (1,) # GL_TEXTURE_BINDING_CUBE_MAP_ARB +_m[0x900A] = (1,) # GL_TEXTURE_BINDING_CUBE_MAP_ARRAY +_m[0x900A] = (1,) # GL_TEXTURE_BINDING_CUBE_MAP_ARRAY_ARB +_m[0x8D67] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/OES/OES_EGL_image_external.txt # GL_TEXTURE_BINDING_EXTERNAL_OES +_m[0x84F6] = (1,) # GL_TEXTURE_BINDING_RECTANGLE +_m[0x84F6] = (1,) # GL_TEXTURE_BINDING_RECTANGLE_ARB +_m[0x84F6] = (1,) # GL_TEXTURE_BINDING_RECTANGLE_NV +_m[0x8E53] = (1,) # GL_TEXTURE_BINDING_RENDERBUFFER_NV +_m[0x805E] = (1,) # GL_TEXTURE_BLUE_SIZE +_m[0x8C12] = (1,) # GL_TEXTURE_BLUE_TYPE +_m[0x1005] = (1,) # GL_TEXTURE_BORDER +_m[0x1004] = (4,) # GL_TEXTURE_BORDER_COLOR +_m[0x1004] = (4,) # GL_TEXTURE_BORDER_COLOR_NV +_m[0x8C2A] = (1,) # GL_TEXTURE_BUFFER +_m[0x8C2A] = (1,) # GL_TEXTURE_BUFFER_ARB +_m[0x8C2A] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/EXT/EXT_texture_buffer.txt # GL_TEXTURE_BUFFER_BINDING_EXT +_m[0x8C2A] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/OES/OES_texture_buffer.txt # GL_TEXTURE_BUFFER_BINDING_OES +_m[0x8C2D] = (1,) # GL_TEXTURE_BUFFER_DATA_STORE_BINDING +_m[0x8C2D] = (1,) # GL_TEXTURE_BUFFER_DATA_STORE_BINDING_ARB +_m[0x8C2D] = (1,) # GL_TEXTURE_BUFFER_DATA_STORE_BINDING_EXT +_m[0x8C2A] = (1,) # GL_TEXTURE_BUFFER_EXT +_m[0x8C2E] = (1,) # GL_TEXTURE_BUFFER_FORMAT_ARB +_m[0x8C2E] = (1,) # GL_TEXTURE_BUFFER_FORMAT_EXT +_m[0x919D] = (1,) # GL_TEXTURE_BUFFER_OFFSET +_m[0x919F] = (1,) # GL_TEXTURE_BUFFER_OFFSET_ALIGNMENT +_m[0x919E] = (1,) # GL_TEXTURE_BUFFER_SIZE +_m[0x8171] = (2,) # GL_TEXTURE_CLIPMAP_CENTER_SGIX +_m[0x8176] = (1,) # GL_TEXTURE_CLIPMAP_DEPTH_SGIX +_m[0x8172] = (1,) # GL_TEXTURE_CLIPMAP_FRAME_SGIX +_m[0x8173] = (2,) # GL_TEXTURE_CLIPMAP_OFFSET_SGIX +_m[0x8174] = (3,) # GL_TEXTURE_CLIPMAP_VIRTUAL_DEPTH_SGIX +_m[0x9046] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/texture_multisample.txt # GL_TEXTURE_COLOR_SAMPLES_NV +_m[0x80BC] = (1,) # GL_TEXTURE_COLOR_TABLE_SGI +_m[0x81EF] = (4,) # GL_TEXTURE_COLOR_WRITEMASK_SGIS +_m[0x80BF] = (1,) # GL_TEXTURE_COMPARE_FAIL_VALUE_ARB +_m[0x884D] = (1,) # GL_TEXTURE_COMPARE_FUNC +_m[0x884C] = (1,) # GL_TEXTURE_COMPARE_MODE +_m[0x819B] = (1,) # GL_TEXTURE_COMPARE_OPERATOR_SGIX +_m[0x819A] = (1,) # GL_TEXTURE_COMPARE_SGIX +_m[0x86A1] = (1,) # GL_TEXTURE_COMPRESSED +_m[0x82B2] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_TEXTURE_COMPRESSED_BLOCK_HEIGHT +_m[0x82B3] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_TEXTURE_COMPRESSED_BLOCK_SIZE +_m[0x82B1] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_TEXTURE_COMPRESSED_BLOCK_WIDTH +_m[0x86A0] = (1,) # GL_TEXTURE_COMPRESSED_IMAGE_SIZE +_m[0x84EF] = (1,) # GL_TEXTURE_COMPRESSION_HINT +_m[0x84EF] = (1,) # GL_TEXTURE_COMPRESSION_HINT_ARB +_m[0x8078] = (1,) # GL_TEXTURE_COORD_ARRAY +_m[0x889A] = (1,) # GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING +_m[0x889A] = (1,) # GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING_ARB +_m[0x808B] = (1,) # GL_TEXTURE_COORD_ARRAY_COUNT_EXT +_m[0x8078] = (1,) # GL_TEXTURE_COORD_ARRAY_EXT +_m[0x83F8] = (1,)#TODO Review http://www.opengl.org/registry/specs//INTEL/parallel_arrays.txt # GL_TEXTURE_COORD_ARRAY_PARALLEL_POINTERS_INTEL +_m[0x8092] = (1,) # GL_TEXTURE_COORD_ARRAY_POINTER +_m[0x8088] = (1,) # GL_TEXTURE_COORD_ARRAY_SIZE +_m[0x8088] = (1,) # GL_TEXTURE_COORD_ARRAY_SIZE_EXT +_m[0x808A] = (1,) # GL_TEXTURE_COORD_ARRAY_STRIDE +_m[0x808A] = (1,) # GL_TEXTURE_COORD_ARRAY_STRIDE_EXT +_m[0x8089] = (1,) # GL_TEXTURE_COORD_ARRAY_TYPE +_m[0x8089] = (1,) # GL_TEXTURE_COORD_ARRAY_TYPE_EXT +_m[0x9045] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/texture_multisample.txt # GL_TEXTURE_COVERAGE_SAMPLES_NV +_m[0x8B9D] = (4,) # GL_TEXTURE_CROP_RECT_OES +_m[0x8513] = (1,) # GL_TEXTURE_CUBE_MAP +_m[0x8513] = (1,) # GL_TEXTURE_CUBE_MAP_ARB +_m[0x9009] = (1,) # GL_TEXTURE_CUBE_MAP_ARRAY +_m[0x884F] = (1,) # GL_TEXTURE_CUBE_MAP_SEAMLESS +_m[0x8071] = (1,) # GL_TEXTURE_DEPTH +_m[0x8071] = (1,) # GL_TEXTURE_DEPTH_EXT +_m[0x884A] = (1,) # GL_TEXTURE_DEPTH_SIZE +_m[0x8C16] = (1,) # GL_TEXTURE_DEPTH_TYPE +_m[0x871D] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/texture_shader.txt # GL_TEXTURE_DS_SIZE_NV +_m[0x871E] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/texture_shader.txt # GL_TEXTURE_DT_SIZE_NV +_m[0x2201] = (4,) # GL_TEXTURE_ENV_COLOR +_m[0x2200] = (1,) # GL_TEXTURE_ENV_MODE +_m[0x9107] = (1,) # GL_TEXTURE_FIXED_SAMPLE_LOCATIONS +_m[0x888C] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/float_buffer.txt # GL_TEXTURE_FLOAT_COMPONENTS_NV +_m[0x8BFD] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/QCOM/QCOM_texture_foveated.txt # GL_TEXTURE_FOVEATED_FEATURE_QUERY_QCOM +_m[0x8BFE] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/QCOM/QCOM_texture_foveated.txt # GL_TEXTURE_FOVEATED_NUM_FOCAL_POINTS_QUERY_QCOM +_m[0x87FC] = (1,) # GL_TEXTURE_FREE_MEMORY_ATI +_m[0x82A2] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_TEXTURE_GATHER +_m[0x82A3] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_TEXTURE_GATHER_SHADOW +_m[0x2500] = (1,) # GL_TEXTURE_GEN_MODE +_m[0x0C63] = (1,) # GL_TEXTURE_GEN_Q +_m[0x0C62] = (1,) # GL_TEXTURE_GEN_R +_m[0x0C60] = (1,) # GL_TEXTURE_GEN_S +_m[0x8D60] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/OES/OES_texture_cube_map.txt # GL_TEXTURE_GEN_STR_OES +_m[0x0C61] = (1,) # GL_TEXTURE_GEN_T +_m[0x805D] = (1,) # GL_TEXTURE_GREEN_SIZE +_m[0x8C11] = (1,) # GL_TEXTURE_GREEN_TYPE +_m[0x1001] = (1,) # GL_TEXTURE_HEIGHT +_m[0x871B] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/texture_shader.txt # GL_TEXTURE_HI_SIZE_NV +_m[0x828F] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_TEXTURE_IMAGE_FORMAT +_m[0x8290] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_TEXTURE_IMAGE_TYPE +_m[0x912F] = (1,) # GL_TEXTURE_IMMUTABLE_FORMAT +_m[0x82DF] = (1,) # GL_TEXTURE_IMMUTABLE_LEVELS +_m[0x80ED] = (1,) # GL_TEXTURE_INDEX_SIZE_EXT +_m[0x8061] = (1,) # GL_TEXTURE_INTENSITY_SIZE +_m[0x8C15] = (1,) # GL_TEXTURE_INTENSITY_TYPE +_m[0x1003] = (1,) # GL_TEXTURE_INTERNAL_FORMAT +_m[0x8350] = (1,) # GL_TEXTURE_LIGHT_EXT +_m[0x8501] = (1,) # GL_TEXTURE_LOD_BIAS +_m[0x8190] = (1,) # GL_TEXTURE_LOD_BIAS_R_SGIX +_m[0x818E] = (1,) # GL_TEXTURE_LOD_BIAS_S_SGIX +_m[0x818F] = (1,) # GL_TEXTURE_LOD_BIAS_T_SGIX +_m[0x871C] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/texture_shader.txt # GL_TEXTURE_LO_SIZE_NV +_m[0x8060] = (1,) # GL_TEXTURE_LUMINANCE_SIZE +_m[0x8C14] = (1,) # GL_TEXTURE_LUMINANCE_TYPE +_m[0x2800] = (1,) # GL_TEXTURE_MAG_FILTER +_m[0x871F] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/texture_shader.txt # GL_TEXTURE_MAG_SIZE_NV +_m[0x8351] = (1,) # GL_TEXTURE_MATERIAL_FACE_EXT +_m[0x8352] = (1,) # GL_TEXTURE_MATERIAL_PARAMETER_EXT +_m[0x0BA8] = (4, 4) # GL_TEXTURE_MATRIX +_m[0x898F] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/OES/OES_matrix_get.txt # GL_TEXTURE_MATRIX_FLOAT_AS_INT_BITS_OES +_m[0x84FE] = (1,) # GL_TEXTURE_MAX_ANISOTROPY_EXT +_m[0x836B] = (1,) # GL_TEXTURE_MAX_CLAMP_R_SGIX +_m[0x8369] = (1,) # GL_TEXTURE_MAX_CLAMP_S_SGIX +_m[0x836A] = (1,) # GL_TEXTURE_MAX_CLAMP_T_SGIX +_m[0x813D] = (1,) # GL_TEXTURE_MAX_LEVEL +_m[0x813D] = (1,) # GL_TEXTURE_MAX_LEVEL_SGIS +_m[0x813B] = (1,) # GL_TEXTURE_MAX_LOD +_m[0x813B] = (1,) # GL_TEXTURE_MAX_LOD_SGIS +_m[0x2801] = (1,) # GL_TEXTURE_MIN_FILTER +_m[0x813A] = (1,) # GL_TEXTURE_MIN_LOD +_m[0x813A] = (1,) # GL_TEXTURE_MIN_LOD_SGIS +_m[0x8066] = (1,) # GL_TEXTURE_PRIORITY +_m[0x85B8] = (1,) # GL_TEXTURE_RANGE_POINTER_APPLE +_m[0x84F5] = (1,) # GL_TEXTURE_RECTANGLE +_m[0x84F5] = (1,) # GL_TEXTURE_RECTANGLE_ARB +_m[0x84F5] = (1,) # GL_TEXTURE_RECTANGLE_NV +_m[0x805C] = (1,) # GL_TEXTURE_RED_SIZE +_m[0x8C10] = (1,) # GL_TEXTURE_RED_TYPE +_m[0x8E54] = (1,) # GL_TEXTURE_RENDERBUFFER_DATA_STORE_BINDING_NV +_m[0x8067] = (1,) # GL_TEXTURE_RESIDENT +_m[0x9106] = (1,) # GL_TEXTURE_SAMPLES +_m[0x9136] = (1,) # GL_TEXTURE_SAMPLES_IMG +_m[0x86DE] = (1,) # GL_TEXTURE_SHADER_NV +_m[0x82A1] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_TEXTURE_SHADOW +_m[0x8C3F] = (1,)#TODO Review http://www.opengl.org/registry/specs//EXT/texture_shared_exponent.txt # GL_TEXTURE_SHARED_SIZE_EXT +_m[0x8A48] = (1,) # GL_TEXTURE_SRGB_DECODE_EXT +_m[0x0BA5] = (1,) # GL_TEXTURE_STACK_DEPTH +_m[0x88F1] = (1,) # GL_TEXTURE_STENCIL_SIZE +_m[0x85BC] = (1,) # GL_TEXTURE_STORAGE_HINT_APPLE +_m[0x8E45] = (1,) # GL_TEXTURE_SWIZZLE_A +_m[0x8E44] = (1,) # GL_TEXTURE_SWIZZLE_B +_m[0x8E43] = (1,) # GL_TEXTURE_SWIZZLE_G +_m[0x8E42] = (1,) # GL_TEXTURE_SWIZZLE_R +_m[0x8E46] = (4,) # GL_TEXTURE_SWIZZLE_RGBA +_m[0x1006] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/direct_state_access.txt # GL_TEXTURE_TARGET +_m[0x888F] = (1,) # GL_TEXTURE_UNSIGNED_REMAP_MODE_NV +_m[0x82B5] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_TEXTURE_VIEW +_m[0x82DD] = (1,) # GL_TEXTURE_VIEW_MIN_LAYER +_m[0x82DB] = (1,) # GL_TEXTURE_VIEW_MIN_LEVEL +_m[0x82DE] = (1,) # GL_TEXTURE_VIEW_NUM_LAYERS +_m[0x82DC] = (1,) # GL_TEXTURE_VIEW_NUM_LEVELS +_m[0x1000] = (1,) # GL_TEXTURE_WIDTH +_m[0x8137] = (1,) # GL_TEXTURE_WRAP_Q_SGIS +_m[0x8072] = (1,) # GL_TEXTURE_WRAP_R +_m[0x8072] = (1,) # GL_TEXTURE_WRAP_R_EXT +_m[0x2802] = (1,) # GL_TEXTURE_WRAP_S +_m[0x2803] = (1,) # GL_TEXTURE_WRAP_T +_m[0x8200] = (1,) # GL_TEXT_FRAGMENT_SHADER_ATI +_m[0x8E28] = (1,) # GL_TIMESTAMP +_m[0x930C] = (1,) # GL_TOP_LEVEL_ARRAY_SIZE +_m[0x930D] = (1,) # GL_TOP_LEVEL_ARRAY_STRIDE +_m[0x8648] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/vertex_program.txt # GL_TRACK_MATRIX_NV +_m[0x8649] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/vertex_program.txt # GL_TRACK_MATRIX_TRANSFORM_NV +_m[0x8E25] = (1,) # GL_TRANSFORM_FEEDBACK_BINDING +_m[0x8E25] = (1,) # GL_TRANSFORM_FEEDBACK_BINDING_NV +_m[0x8E24] = (1,) # GL_TRANSFORM_FEEDBACK_BUFFER_ACTIVE +_m[0x8E24] = (1,) # GL_TRANSFORM_FEEDBACK_BUFFER_ACTIVE_NV +_m[0x8C8F] = (1,) # GL_TRANSFORM_FEEDBACK_BUFFER_BINDING +_m[0x8C7F] = (1,) # GL_TRANSFORM_FEEDBACK_BUFFER_MODE +_m[0x8C7F] = (1,)#TODO Review http://www.opengl.org/registry/specs//EXT/transform_feedback.txt # GL_TRANSFORM_FEEDBACK_BUFFER_MODE_EXT +_m[0x8C7F] = (1,) # GL_TRANSFORM_FEEDBACK_BUFFER_MODE_NV +_m[0x8E23] = (1,) # GL_TRANSFORM_FEEDBACK_BUFFER_PAUSED +_m[0x8E23] = (1,) # GL_TRANSFORM_FEEDBACK_BUFFER_PAUSED_NV +_m[0x8C85] = (1,) # GL_TRANSFORM_FEEDBACK_BUFFER_SIZE +_m[0x8C84] = (1,) # GL_TRANSFORM_FEEDBACK_BUFFER_START +_m[0x8C83] = (1,) # GL_TRANSFORM_FEEDBACK_VARYINGS +_m[0x8C83] = (1,)#TODO Review http://www.opengl.org/registry/specs//EXT/transform_feedback.txt # GL_TRANSFORM_FEEDBACK_VARYINGS_EXT +_m[0x8C76] = (1,) # GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH +_m[0x8C76] = (1,)#TODO Review http://www.opengl.org/registry/specs//EXT/transform_feedback.txt # GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH_EXT +_m[0x84E6] = (4,4) # GL_TRANSPOSE_COLOR_MATRIX +_m[0x84E6] = (4,4) # GL_TRANSPOSE_COLOR_MATRIX_ARB +_m[0x88B7] = (4, 4) # GL_TRANSPOSE_CURRENT_MATRIX_ARB +_m[0x84E3] = (4,4) # GL_TRANSPOSE_MODELVIEW_MATRIX +_m[0x84E3] = (4,4) # GL_TRANSPOSE_MODELVIEW_MATRIX_ARB +_m[0x8E2E] = (1,)#TODO Review http://www.opengl.org/registry/specs//EXT/direct_state_access.txt # GL_TRANSPOSE_PROGRAM_MATRIX_EXT +_m[0x84E4] = (4,4) # GL_TRANSPOSE_PROJECTION_MATRIX +_m[0x84E4] = (4,4) # GL_TRANSPOSE_PROJECTION_MATRIX_ARB +_m[0x84E5] = (4,4) # GL_TRANSPOSE_TEXTURE_MATRIX +_m[0x84E5] = (4,4) # GL_TRANSPOSE_TEXTURE_MATRIX_ARB +_m[0x92FA] = (1,) # GL_TYPE +_m[0x8A3C] = (1,) # GL_UNIFORM_ARRAY_STRIDE +_m[0x92DA] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/shader_atomic_counters.txt # GL_UNIFORM_ATOMIC_COUNTER_BUFFER_INDEX +_m[0x8A42] = (1,) # GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS +_m[0x8A43] = (1,) # GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES +_m[0x8A3F] = (1,) # GL_UNIFORM_BLOCK_BINDING +_m[0x8A40] = (1,) # GL_UNIFORM_BLOCK_DATA_SIZE +_m[0x8A3A] = (1,) # GL_UNIFORM_BLOCK_INDEX +_m[0x8A41] = (1,) # GL_UNIFORM_BLOCK_NAME_LENGTH +_m[0x90EC] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/compute_shader.txt # GL_UNIFORM_BLOCK_REFERENCED_BY_COMPUTE_SHADER +_m[0x8A46] = (1,) # GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER +_m[0x8A45] = (1,) # GL_UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER +_m[0x959C] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_UNIFORM_BLOCK_REFERENCED_BY_MESH_SHADER_NV +_m[0x959D] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_UNIFORM_BLOCK_REFERENCED_BY_TASK_SHADER_NV +_m[0x84F0] = (1,) # GL_UNIFORM_BLOCK_REFERENCED_BY_TESS_CONTROL_SHADER +_m[0x84F1] = (1,) # GL_UNIFORM_BLOCK_REFERENCED_BY_TESS_EVALUATION_SHADER +_m[0x8A44] = (1,) # GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER +_m[0x8A28] = (1,) # GL_UNIFORM_BUFFER_BINDING +_m[0x8DEF] = (1,) # GL_UNIFORM_BUFFER_BINDING_EXT +_m[0x8A34] = (1,) # GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT +_m[0x8A2A] = (1,) # GL_UNIFORM_BUFFER_SIZE +_m[0x8A29] = (1,) # GL_UNIFORM_BUFFER_START +_m[0x8A3E] = (1,) # GL_UNIFORM_IS_ROW_MAJOR +_m[0x8A3D] = (1,) # GL_UNIFORM_MATRIX_STRIDE +_m[0x8A39] = (1,) # GL_UNIFORM_NAME_LENGTH +_m[0x8A3B] = (1,) # GL_UNIFORM_OFFSET +_m[0x8A38] = (1,) # GL_UNIFORM_SIZE +_m[0x8A37] = (1,) # GL_UNIFORM_TYPE +_m[0x0CF5] = (1,) # GL_UNPACK_ALIGNMENT +_m[0x85B2] = (1,) # GL_UNPACK_CLIENT_STORAGE_APPLE +_m[0x800F] = (1,) # GL_UNPACK_CMYK_HINT_EXT +_m[0x9129] = (1,) # GL_UNPACK_COMPRESSED_BLOCK_DEPTH +_m[0x9128] = (1,) # GL_UNPACK_COMPRESSED_BLOCK_HEIGHT +_m[0x912A] = (1,) # GL_UNPACK_COMPRESSED_BLOCK_SIZE +_m[0x9127] = (1,) # GL_UNPACK_COMPRESSED_BLOCK_WIDTH +_m[0x8133] = (1,) # GL_UNPACK_IMAGE_DEPTH_SGIS +_m[0x806E] = (1,) # GL_UNPACK_IMAGE_HEIGHT +_m[0x806E] = (1,) # GL_UNPACK_IMAGE_HEIGHT_EXT +_m[0x0CF1] = (1,) # GL_UNPACK_LSB_FIRST +_m[0x8985] = (1,) # GL_UNPACK_RESAMPLE_OML +_m[0x842F] = (1,) # GL_UNPACK_RESAMPLE_SGIX +_m[0x8A16] = (1,) # GL_UNPACK_ROW_BYTES_APPLE +_m[0x0CF2] = (1,) # GL_UNPACK_ROW_LENGTH +_m[0x806D] = (1,) # GL_UNPACK_SKIP_IMAGES +_m[0x806D] = (1,) # GL_UNPACK_SKIP_IMAGES_EXT +_m[0x0CF4] = (1,) # GL_UNPACK_SKIP_PIXELS +_m[0x0CF3] = (1,) # GL_UNPACK_SKIP_ROWS +_m[0x8132] = (1,) # GL_UNPACK_SKIP_VOLUMES_SGIS +_m[0x0CF0] = (1,) # GL_UNPACK_SWAP_BYTES +_m[0x954A] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NVX/NVX_gpu_multicast2.txt # GL_UPLOAD_GPU_MASK_NVX +_m[0x8B83] = (1,) # GL_VALIDATE_STATUS +_m[0x87E9] = (1,)#TODO Review http://www.opengl.org/registry/specs//EXT/vertex_shader.txt # GL_VARIANT_ARRAY_POINTER_EXT +_m[0x87E7] = (1,) # GL_VARIANT_ARRAY_TYPE_EXT +_m[0x87FB] = (1,) # GL_VBO_FREE_MEMORY_ATI +_m[0x1F00] = (1,) # GL_VENDOR +_m[0x1F02] = (1,) # GL_VERSION +_m[0x8074] = (1,) # GL_VERTEX_ARRAY +_m[0x85B5] = (1,) # GL_VERTEX_ARRAY_BINDING +_m[0x85B5] = (1,) # GL_VERTEX_ARRAY_BINDING_APPLE +_m[0x8896] = (1,) # GL_VERTEX_ARRAY_BUFFER_BINDING +_m[0x8896] = (1,) # GL_VERTEX_ARRAY_BUFFER_BINDING_ARB +_m[0x807D] = (1,) # GL_VERTEX_ARRAY_COUNT_EXT +_m[0x8074] = (1,) # GL_VERTEX_ARRAY_EXT +_m[0x8F2B] = (1,) # GL_VERTEX_ARRAY_LENGTH_NV +_m[0x83F5] = (1,)#TODO Review http://www.opengl.org/registry/specs//INTEL/parallel_arrays.txt # GL_VERTEX_ARRAY_PARALLEL_POINTERS_INTEL +_m[0x808E] = (1,) # GL_VERTEX_ARRAY_POINTER +_m[0x851E] = (1,) # GL_VERTEX_ARRAY_RANGE_LENGTH_APPLE +_m[0x851E] = (1,) # GL_VERTEX_ARRAY_RANGE_LENGTH_NV +_m[0x851D] = (1,) # GL_VERTEX_ARRAY_RANGE_NV +_m[0x8521] = (1,) # GL_VERTEX_ARRAY_RANGE_POINTER_NV +_m[0x851F] = (1,) # GL_VERTEX_ARRAY_RANGE_VALID_NV +_m[0x807A] = (1,) # GL_VERTEX_ARRAY_SIZE +_m[0x807A] = (1,) # GL_VERTEX_ARRAY_SIZE_EXT +_m[0x807C] = (1,) # GL_VERTEX_ARRAY_STRIDE +_m[0x807C] = (1,) # GL_VERTEX_ARRAY_STRIDE_EXT +_m[0x807B] = (1,) # GL_VERTEX_ARRAY_TYPE +_m[0x807B] = (1,) # GL_VERTEX_ARRAY_TYPE_EXT +_m[0x8650] = (1,) # GL_VERTEX_ATTRIB_ARRAY0_NV +_m[0x865A] = (1,) # GL_VERTEX_ATTRIB_ARRAY10_NV +_m[0x865B] = (1,) # GL_VERTEX_ATTRIB_ARRAY11_NV +_m[0x865C] = (1,) # GL_VERTEX_ATTRIB_ARRAY12_NV +_m[0x865D] = (1,) # GL_VERTEX_ATTRIB_ARRAY13_NV +_m[0x865E] = (1,) # GL_VERTEX_ATTRIB_ARRAY14_NV +_m[0x865F] = (1,) # GL_VERTEX_ATTRIB_ARRAY15_NV +_m[0x8651] = (1,) # GL_VERTEX_ATTRIB_ARRAY1_NV +_m[0x8652] = (1,) # GL_VERTEX_ATTRIB_ARRAY2_NV +_m[0x8653] = (1,) # GL_VERTEX_ATTRIB_ARRAY3_NV +_m[0x8654] = (1,) # GL_VERTEX_ATTRIB_ARRAY4_NV +_m[0x8655] = (1,) # GL_VERTEX_ATTRIB_ARRAY5_NV +_m[0x8656] = (1,) # GL_VERTEX_ATTRIB_ARRAY6_NV +_m[0x8657] = (1,) # GL_VERTEX_ATTRIB_ARRAY7_NV +_m[0x8658] = (1,) # GL_VERTEX_ATTRIB_ARRAY8_NV +_m[0x8659] = (1,) # GL_VERTEX_ATTRIB_ARRAY9_NV +_m[0x889F] = (1,) # GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING +_m[0x889F] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/vertex_buffer_object.txt # GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING_ARB +_m[0x88FE] = (1,) # GL_VERTEX_ATTRIB_ARRAY_DIVISOR +_m[0x8622] = (1,) # GL_VERTEX_ATTRIB_ARRAY_ENABLED +_m[0x88FD] = (1,) # GL_VERTEX_ATTRIB_ARRAY_INTEGER +_m[0x874E] = (1,) # GL_VERTEX_ATTRIB_ARRAY_LONG +_m[0x886A] = (1,) # GL_VERTEX_ATTRIB_ARRAY_NORMALIZED +_m[0x8645] = (1,) # GL_VERTEX_ATTRIB_ARRAY_POINTER +_m[0x8623] = (1,) # GL_VERTEX_ATTRIB_ARRAY_SIZE +_m[0x8624] = (1,) # GL_VERTEX_ATTRIB_ARRAY_STRIDE +_m[0x8625] = (1,) # GL_VERTEX_ATTRIB_ARRAY_TYPE +_m[0x82D4] = (1,) # GL_VERTEX_ATTRIB_BINDING +_m[0x82D5] = (1,) # GL_VERTEX_ATTRIB_RELATIVE_OFFSET +_m[0x82D6] = (1,) # GL_VERTEX_BINDING_DIVISOR +_m[0x82D7] = (1,) # GL_VERTEX_BINDING_OFFSET +_m[0x82D8] = (1,) # GL_VERTEX_BINDING_STRIDE +_m[0x86A7] = (1,) # GL_VERTEX_BLEND_ARB +_m[0x83EF] = (1,) # GL_VERTEX_PRECLIP_HINT_SGIX +_m[0x83EE] = (1,) # GL_VERTEX_PRECLIP_SGIX +_m[0x8620] = (1,) # GL_VERTEX_PROGRAM_ARB +_m[0x864A] = (1,) # GL_VERTEX_PROGRAM_BINDING_NV +_m[0x8620] = (1,) # GL_VERTEX_PROGRAM_NV +_m[0x8DA2] = (1,) # GL_VERTEX_PROGRAM_PARAMETER_BUFFER_NV +_m[0x8642] = (1,) # GL_VERTEX_PROGRAM_POINT_SIZE +_m[0x8642] = (1,) # GL_VERTEX_PROGRAM_POINT_SIZE_ARB +_m[0x8642] = (1,) # GL_VERTEX_PROGRAM_POINT_SIZE_NV +_m[0x8643] = (1,) # GL_VERTEX_PROGRAM_TWO_SIDE +_m[0x8643] = (1,) # GL_VERTEX_PROGRAM_TWO_SIDE_ARB +_m[0x8643] = (1,) # GL_VERTEX_PROGRAM_TWO_SIDE_NV +_m[0x8B31] = (1,) # GL_VERTEX_SHADER +_m[0x8781] = (1,) # GL_VERTEX_SHADER_BINDING_EXT +_m[0x8780] = (1,) # GL_VERTEX_SHADER_EXT +_m[0x87CF] = (1,) # GL_VERTEX_SHADER_INSTRUCTIONS_EXT +_m[0x87D1] = (1,) # GL_VERTEX_SHADER_INVARIANTS_EXT +_m[0x87D3] = (1,) # GL_VERTEX_SHADER_LOCALS_EXT +_m[0x87D2] = (1,) # GL_VERTEX_SHADER_LOCAL_CONSTANTS_EXT +_m[0x87D4] = (1,) # GL_VERTEX_SHADER_OPTIMIZED_EXT +_m[0x87D0] = (1,) # GL_VERTEX_SHADER_VARIANTS_EXT +_m[0x829B] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_VERTEX_TEXTURE +_m[0x850C] = (1,) # GL_VERTEX_WEIGHT_ARRAY_EXT +_m[0x8510] = (1,) # GL_VERTEX_WEIGHT_ARRAY_POINTER_EXT +_m[0x850D] = (1,) # GL_VERTEX_WEIGHT_ARRAY_SIZE_EXT +_m[0x850F] = (1,) # GL_VERTEX_WEIGHT_ARRAY_STRIDE_EXT +_m[0x850E] = (1,) # GL_VERTEX_WEIGHT_ARRAY_TYPE_EXT +_m[0x8719] = (1,) # GL_VIBRANCE_BIAS_NV +_m[0x8713] = (1,) # GL_VIBRANCE_SCALE_NV +_m[0x9021] = (1,) # GL_VIDEO_BUFFER_BINDING_NV +_m[0x0BA2] = (4,) # GL_VIEWPORT +_m[0x825D] = (2,) # GL_VIEWPORT_BOUNDS_RANGE +_m[0x825F] = (1,) # GL_VIEWPORT_INDEX_PROVOKING_VERTEX +_m[0x937D] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_clip_space_w_scaling.txt # GL_VIEWPORT_POSITION_W_SCALE_X_COEFF_NV +_m[0x937E] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_clip_space_w_scaling.txt # GL_VIEWPORT_POSITION_W_SCALE_Y_COEFF_NV +_m[0x825C] = (1,) # GL_VIEWPORT_SUBPIXEL_BITS +_m[0x935B] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_viewport_swizzle.txt # GL_VIEWPORT_SWIZZLE_W_NV +_m[0x9358] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_viewport_swizzle.txt # GL_VIEWPORT_SWIZZLE_X_NV +_m[0x9359] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_viewport_swizzle.txt # GL_VIEWPORT_SWIZZLE_Y_NV +_m[0x935A] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_viewport_swizzle.txt # GL_VIEWPORT_SWIZZLE_Z_NV +_m[0x82B6] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_VIEW_COMPATIBILITY_CLASS +_m[0x933A] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/shader_thread_group.txt # GL_WARPS_PER_SM_NV +_m[0x9339] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/shader_thread_group.txt # GL_WARP_SIZE_NV +_m[0x86AD] = (1,) # GL_WEIGHT_ARRAY_ARB +_m[0x889E] = (1,) # GL_WEIGHT_ARRAY_BUFFER_BINDING +_m[0x889E] = (1,) # GL_WEIGHT_ARRAY_BUFFER_BINDING_ARB +_m[0x86AC] = (1,) # GL_WEIGHT_ARRAY_POINTER_ARB +_m[0x86AC] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/OES/OES_matrix_palette.txt # GL_WEIGHT_ARRAY_POINTER_OES +_m[0x86AB] = (1,) # GL_WEIGHT_ARRAY_SIZE_ARB +_m[0x86AB] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/OES/OES_matrix_palette.txt # GL_WEIGHT_ARRAY_SIZE_OES +_m[0x86AA] = (1,) # GL_WEIGHT_ARRAY_STRIDE_ARB +_m[0x86AA] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/OES/OES_matrix_palette.txt # GL_WEIGHT_ARRAY_STRIDE_OES +_m[0x86A9] = (1,) # GL_WEIGHT_ARRAY_TYPE_ARB +_m[0x86A9] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/OES/OES_matrix_palette.txt # GL_WEIGHT_ARRAY_TYPE_OES +_m[0x86A6] = (1,) # GL_WEIGHT_SUM_UNITY_ARB +_m[0x8F12] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/EXT/EXT_window_rectangles.txt # GL_WINDOW_RECTANGLE_EXT +_m[0x8F13] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/EXT/EXT_window_rectangles.txt # GL_WINDOW_RECTANGLE_MODE_EXT +_m[0x887A] = (1,) # GL_WRITE_PIXEL_DATA_RANGE_LENGTH_NV +_m[0x887C] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/pixel_data_range.txt # GL_WRITE_PIXEL_DATA_RANGE_POINTER_NV +_m[0x0D16] = (1,) # GL_ZOOM_X +_m[0x0D17] = (1,) # GL_ZOOM_Y diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/_types.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/_types.py new file mode 100644 index 00000000..983d9a91 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES2/_types.py @@ -0,0 +1,5 @@ +from OpenGL.raw.GLES1._types import * + +from OpenGL.platform import PLATFORM as _p +from OpenGL.error import _ErrorChecker +_error_checker = _ErrorChecker( _p, _p.GLES2.glGetError ) diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES3/VERSION/GLES3_3_0.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES3/VERSION/GLES3_3_0.py new file mode 100644 index 00000000..2bd92773 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES3/VERSION/GLES3_3_0.py @@ -0,0 +1,646 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES3 import _types as _cs +# End users want this... +from OpenGL.raw.GLES3._types import * +from OpenGL.raw.GLES3 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES3_VERSION_GLES3_3_0' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES3,'GLES3_VERSION_GLES3_3_0',error_checker=_errors._error_checker) +GL_ACTIVE_UNIFORM_BLOCKS=_C('GL_ACTIVE_UNIFORM_BLOCKS',0x8A36) +GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH=_C('GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH',0x8A35) +GL_ALREADY_SIGNALED=_C('GL_ALREADY_SIGNALED',0x911A) +GL_ANY_SAMPLES_PASSED=_C('GL_ANY_SAMPLES_PASSED',0x8C2F) +GL_ANY_SAMPLES_PASSED_CONSERVATIVE=_C('GL_ANY_SAMPLES_PASSED_CONSERVATIVE',0x8D6A) +GL_BLUE=_C('GL_BLUE',0x1905) +GL_BUFFER_ACCESS_FLAGS=_C('GL_BUFFER_ACCESS_FLAGS',0x911F) +GL_BUFFER_MAPPED=_C('GL_BUFFER_MAPPED',0x88BC) +GL_BUFFER_MAP_LENGTH=_C('GL_BUFFER_MAP_LENGTH',0x9120) +GL_BUFFER_MAP_OFFSET=_C('GL_BUFFER_MAP_OFFSET',0x9121) +GL_BUFFER_MAP_POINTER=_C('GL_BUFFER_MAP_POINTER',0x88BD) +GL_COLOR=_C('GL_COLOR',0x1800) +GL_COLOR_ATTACHMENT1=_C('GL_COLOR_ATTACHMENT1',0x8CE1) +GL_COLOR_ATTACHMENT10=_C('GL_COLOR_ATTACHMENT10',0x8CEA) +GL_COLOR_ATTACHMENT11=_C('GL_COLOR_ATTACHMENT11',0x8CEB) +GL_COLOR_ATTACHMENT12=_C('GL_COLOR_ATTACHMENT12',0x8CEC) +GL_COLOR_ATTACHMENT13=_C('GL_COLOR_ATTACHMENT13',0x8CED) +GL_COLOR_ATTACHMENT14=_C('GL_COLOR_ATTACHMENT14',0x8CEE) +GL_COLOR_ATTACHMENT15=_C('GL_COLOR_ATTACHMENT15',0x8CEF) +GL_COLOR_ATTACHMENT16=_C('GL_COLOR_ATTACHMENT16',0x8CF0) +GL_COLOR_ATTACHMENT17=_C('GL_COLOR_ATTACHMENT17',0x8CF1) +GL_COLOR_ATTACHMENT18=_C('GL_COLOR_ATTACHMENT18',0x8CF2) +GL_COLOR_ATTACHMENT19=_C('GL_COLOR_ATTACHMENT19',0x8CF3) +GL_COLOR_ATTACHMENT2=_C('GL_COLOR_ATTACHMENT2',0x8CE2) +GL_COLOR_ATTACHMENT20=_C('GL_COLOR_ATTACHMENT20',0x8CF4) +GL_COLOR_ATTACHMENT21=_C('GL_COLOR_ATTACHMENT21',0x8CF5) +GL_COLOR_ATTACHMENT22=_C('GL_COLOR_ATTACHMENT22',0x8CF6) +GL_COLOR_ATTACHMENT23=_C('GL_COLOR_ATTACHMENT23',0x8CF7) +GL_COLOR_ATTACHMENT24=_C('GL_COLOR_ATTACHMENT24',0x8CF8) +GL_COLOR_ATTACHMENT25=_C('GL_COLOR_ATTACHMENT25',0x8CF9) +GL_COLOR_ATTACHMENT26=_C('GL_COLOR_ATTACHMENT26',0x8CFA) +GL_COLOR_ATTACHMENT27=_C('GL_COLOR_ATTACHMENT27',0x8CFB) +GL_COLOR_ATTACHMENT28=_C('GL_COLOR_ATTACHMENT28',0x8CFC) +GL_COLOR_ATTACHMENT29=_C('GL_COLOR_ATTACHMENT29',0x8CFD) +GL_COLOR_ATTACHMENT3=_C('GL_COLOR_ATTACHMENT3',0x8CE3) +GL_COLOR_ATTACHMENT30=_C('GL_COLOR_ATTACHMENT30',0x8CFE) +GL_COLOR_ATTACHMENT31=_C('GL_COLOR_ATTACHMENT31',0x8CFF) +GL_COLOR_ATTACHMENT4=_C('GL_COLOR_ATTACHMENT4',0x8CE4) +GL_COLOR_ATTACHMENT5=_C('GL_COLOR_ATTACHMENT5',0x8CE5) +GL_COLOR_ATTACHMENT6=_C('GL_COLOR_ATTACHMENT6',0x8CE6) +GL_COLOR_ATTACHMENT7=_C('GL_COLOR_ATTACHMENT7',0x8CE7) +GL_COLOR_ATTACHMENT8=_C('GL_COLOR_ATTACHMENT8',0x8CE8) +GL_COLOR_ATTACHMENT9=_C('GL_COLOR_ATTACHMENT9',0x8CE9) +GL_COMPARE_REF_TO_TEXTURE=_C('GL_COMPARE_REF_TO_TEXTURE',0x884E) +GL_COMPRESSED_R11_EAC=_C('GL_COMPRESSED_R11_EAC',0x9270) +GL_COMPRESSED_RG11_EAC=_C('GL_COMPRESSED_RG11_EAC',0x9272) +GL_COMPRESSED_RGB8_ETC2=_C('GL_COMPRESSED_RGB8_ETC2',0x9274) +GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2=_C('GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2',0x9276) +GL_COMPRESSED_RGBA8_ETC2_EAC=_C('GL_COMPRESSED_RGBA8_ETC2_EAC',0x9278) +GL_COMPRESSED_SIGNED_R11_EAC=_C('GL_COMPRESSED_SIGNED_R11_EAC',0x9271) +GL_COMPRESSED_SIGNED_RG11_EAC=_C('GL_COMPRESSED_SIGNED_RG11_EAC',0x9273) +GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC=_C('GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC',0x9279) +GL_COMPRESSED_SRGB8_ETC2=_C('GL_COMPRESSED_SRGB8_ETC2',0x9275) +GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2=_C('GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2',0x9277) +GL_CONDITION_SATISFIED=_C('GL_CONDITION_SATISFIED',0x911C) +GL_COPY_READ_BUFFER=_C('GL_COPY_READ_BUFFER',0x8F36) +GL_COPY_READ_BUFFER_BINDING=_C('GL_COPY_READ_BUFFER_BINDING',0x8F36) +GL_COPY_WRITE_BUFFER=_C('GL_COPY_WRITE_BUFFER',0x8F37) +GL_COPY_WRITE_BUFFER_BINDING=_C('GL_COPY_WRITE_BUFFER_BINDING',0x8F37) +GL_CURRENT_QUERY=_C('GL_CURRENT_QUERY',0x8865) +GL_DEPTH=_C('GL_DEPTH',0x1801) +GL_DEPTH24_STENCIL8=_C('GL_DEPTH24_STENCIL8',0x88F0) +GL_DEPTH32F_STENCIL8=_C('GL_DEPTH32F_STENCIL8',0x8CAD) +GL_DEPTH_COMPONENT24=_C('GL_DEPTH_COMPONENT24',0x81A6) +GL_DEPTH_COMPONENT32F=_C('GL_DEPTH_COMPONENT32F',0x8CAC) +GL_DEPTH_STENCIL=_C('GL_DEPTH_STENCIL',0x84F9) +GL_DEPTH_STENCIL_ATTACHMENT=_C('GL_DEPTH_STENCIL_ATTACHMENT',0x821A) +GL_DRAW_BUFFER0=_C('GL_DRAW_BUFFER0',0x8825) +GL_DRAW_BUFFER1=_C('GL_DRAW_BUFFER1',0x8826) +GL_DRAW_BUFFER10=_C('GL_DRAW_BUFFER10',0x882F) +GL_DRAW_BUFFER11=_C('GL_DRAW_BUFFER11',0x8830) +GL_DRAW_BUFFER12=_C('GL_DRAW_BUFFER12',0x8831) +GL_DRAW_BUFFER13=_C('GL_DRAW_BUFFER13',0x8832) +GL_DRAW_BUFFER14=_C('GL_DRAW_BUFFER14',0x8833) +GL_DRAW_BUFFER15=_C('GL_DRAW_BUFFER15',0x8834) +GL_DRAW_BUFFER2=_C('GL_DRAW_BUFFER2',0x8827) +GL_DRAW_BUFFER3=_C('GL_DRAW_BUFFER3',0x8828) +GL_DRAW_BUFFER4=_C('GL_DRAW_BUFFER4',0x8829) +GL_DRAW_BUFFER5=_C('GL_DRAW_BUFFER5',0x882A) +GL_DRAW_BUFFER6=_C('GL_DRAW_BUFFER6',0x882B) +GL_DRAW_BUFFER7=_C('GL_DRAW_BUFFER7',0x882C) +GL_DRAW_BUFFER8=_C('GL_DRAW_BUFFER8',0x882D) +GL_DRAW_BUFFER9=_C('GL_DRAW_BUFFER9',0x882E) +GL_DRAW_FRAMEBUFFER=_C('GL_DRAW_FRAMEBUFFER',0x8CA9) +GL_DRAW_FRAMEBUFFER_BINDING=_C('GL_DRAW_FRAMEBUFFER_BINDING',0x8CA6) +GL_DYNAMIC_COPY=_C('GL_DYNAMIC_COPY',0x88EA) +GL_DYNAMIC_READ=_C('GL_DYNAMIC_READ',0x88E9) +GL_FLOAT_32_UNSIGNED_INT_24_8_REV=_C('GL_FLOAT_32_UNSIGNED_INT_24_8_REV',0x8DAD) +GL_FLOAT_MAT2x3=_C('GL_FLOAT_MAT2x3',0x8B65) +GL_FLOAT_MAT2x4=_C('GL_FLOAT_MAT2x4',0x8B66) +GL_FLOAT_MAT3x2=_C('GL_FLOAT_MAT3x2',0x8B67) +GL_FLOAT_MAT3x4=_C('GL_FLOAT_MAT3x4',0x8B68) +GL_FLOAT_MAT4x2=_C('GL_FLOAT_MAT4x2',0x8B69) +GL_FLOAT_MAT4x3=_C('GL_FLOAT_MAT4x3',0x8B6A) +GL_FRAGMENT_SHADER_DERIVATIVE_HINT=_C('GL_FRAGMENT_SHADER_DERIVATIVE_HINT',0x8B8B) +GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE=_C('GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE',0x8215) +GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE=_C('GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE',0x8214) +GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING=_C('GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING',0x8210) +GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE=_C('GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE',0x8211) +GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE=_C('GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE',0x8216) +GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE=_C('GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE',0x8213) +GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE=_C('GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE',0x8212) +GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE=_C('GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE',0x8217) +GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER=_C('GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER',0x8CD4) +GL_FRAMEBUFFER_DEFAULT=_C('GL_FRAMEBUFFER_DEFAULT',0x8218) +GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE=_C('GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE',0x8D56) +GL_FRAMEBUFFER_UNDEFINED=_C('GL_FRAMEBUFFER_UNDEFINED',0x8219) +GL_GREEN=_C('GL_GREEN',0x1904) +GL_HALF_FLOAT=_C('GL_HALF_FLOAT',0x140B) +GL_INTERLEAVED_ATTRIBS=_C('GL_INTERLEAVED_ATTRIBS',0x8C8C) +GL_INT_2_10_10_10_REV=_C('GL_INT_2_10_10_10_REV',0x8D9F) +GL_INT_SAMPLER_2D=_C('GL_INT_SAMPLER_2D',0x8DCA) +GL_INT_SAMPLER_2D_ARRAY=_C('GL_INT_SAMPLER_2D_ARRAY',0x8DCF) +GL_INT_SAMPLER_3D=_C('GL_INT_SAMPLER_3D',0x8DCB) +GL_INT_SAMPLER_CUBE=_C('GL_INT_SAMPLER_CUBE',0x8DCC) +GL_INVALID_INDEX=_C('GL_INVALID_INDEX',0xFFFFFFFF) +GL_MAJOR_VERSION=_C('GL_MAJOR_VERSION',0x821B) +GL_MAP_FLUSH_EXPLICIT_BIT=_C('GL_MAP_FLUSH_EXPLICIT_BIT',0x0010) +GL_MAP_INVALIDATE_BUFFER_BIT=_C('GL_MAP_INVALIDATE_BUFFER_BIT',0x0008) +GL_MAP_INVALIDATE_RANGE_BIT=_C('GL_MAP_INVALIDATE_RANGE_BIT',0x0004) +GL_MAP_READ_BIT=_C('GL_MAP_READ_BIT',0x0001) +GL_MAP_UNSYNCHRONIZED_BIT=_C('GL_MAP_UNSYNCHRONIZED_BIT',0x0020) +GL_MAP_WRITE_BIT=_C('GL_MAP_WRITE_BIT',0x0002) +GL_MAX=_C('GL_MAX',0x8008) +GL_MAX_3D_TEXTURE_SIZE=_C('GL_MAX_3D_TEXTURE_SIZE',0x8073) +GL_MAX_ARRAY_TEXTURE_LAYERS=_C('GL_MAX_ARRAY_TEXTURE_LAYERS',0x88FF) +GL_MAX_COLOR_ATTACHMENTS=_C('GL_MAX_COLOR_ATTACHMENTS',0x8CDF) +GL_MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS=_C('GL_MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS',0x8A33) +GL_MAX_COMBINED_UNIFORM_BLOCKS=_C('GL_MAX_COMBINED_UNIFORM_BLOCKS',0x8A2E) +GL_MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS=_C('GL_MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS',0x8A31) +GL_MAX_DRAW_BUFFERS=_C('GL_MAX_DRAW_BUFFERS',0x8824) +GL_MAX_ELEMENTS_INDICES=_C('GL_MAX_ELEMENTS_INDICES',0x80E9) +GL_MAX_ELEMENTS_VERTICES=_C('GL_MAX_ELEMENTS_VERTICES',0x80E8) +GL_MAX_ELEMENT_INDEX=_C('GL_MAX_ELEMENT_INDEX',0x8D6B) +GL_MAX_FRAGMENT_INPUT_COMPONENTS=_C('GL_MAX_FRAGMENT_INPUT_COMPONENTS',0x9125) +GL_MAX_FRAGMENT_UNIFORM_BLOCKS=_C('GL_MAX_FRAGMENT_UNIFORM_BLOCKS',0x8A2D) +GL_MAX_FRAGMENT_UNIFORM_COMPONENTS=_C('GL_MAX_FRAGMENT_UNIFORM_COMPONENTS',0x8B49) +GL_MAX_PROGRAM_TEXEL_OFFSET=_C('GL_MAX_PROGRAM_TEXEL_OFFSET',0x8905) +GL_MAX_SAMPLES=_C('GL_MAX_SAMPLES',0x8D57) +GL_MAX_SERVER_WAIT_TIMEOUT=_C('GL_MAX_SERVER_WAIT_TIMEOUT',0x9111) +GL_MAX_TEXTURE_LOD_BIAS=_C('GL_MAX_TEXTURE_LOD_BIAS',0x84FD) +GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS=_C('GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS',0x8C8A) +GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS=_C('GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS',0x8C8B) +GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS=_C('GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS',0x8C80) +GL_MAX_UNIFORM_BLOCK_SIZE=_C('GL_MAX_UNIFORM_BLOCK_SIZE',0x8A30) +GL_MAX_UNIFORM_BUFFER_BINDINGS=_C('GL_MAX_UNIFORM_BUFFER_BINDINGS',0x8A2F) +GL_MAX_VARYING_COMPONENTS=_C('GL_MAX_VARYING_COMPONENTS',0x8B4B) +GL_MAX_VERTEX_OUTPUT_COMPONENTS=_C('GL_MAX_VERTEX_OUTPUT_COMPONENTS',0x9122) +GL_MAX_VERTEX_UNIFORM_BLOCKS=_C('GL_MAX_VERTEX_UNIFORM_BLOCKS',0x8A2B) +GL_MAX_VERTEX_UNIFORM_COMPONENTS=_C('GL_MAX_VERTEX_UNIFORM_COMPONENTS',0x8B4A) +GL_MIN=_C('GL_MIN',0x8007) +GL_MINOR_VERSION=_C('GL_MINOR_VERSION',0x821C) +GL_MIN_PROGRAM_TEXEL_OFFSET=_C('GL_MIN_PROGRAM_TEXEL_OFFSET',0x8904) +GL_NUM_EXTENSIONS=_C('GL_NUM_EXTENSIONS',0x821D) +GL_NUM_PROGRAM_BINARY_FORMATS=_C('GL_NUM_PROGRAM_BINARY_FORMATS',0x87FE) +GL_NUM_SAMPLE_COUNTS=_C('GL_NUM_SAMPLE_COUNTS',0x9380) +GL_OBJECT_TYPE=_C('GL_OBJECT_TYPE',0x9112) +GL_PACK_ROW_LENGTH=_C('GL_PACK_ROW_LENGTH',0x0D02) +GL_PACK_SKIP_PIXELS=_C('GL_PACK_SKIP_PIXELS',0x0D04) +GL_PACK_SKIP_ROWS=_C('GL_PACK_SKIP_ROWS',0x0D03) +GL_PIXEL_PACK_BUFFER=_C('GL_PIXEL_PACK_BUFFER',0x88EB) +GL_PIXEL_PACK_BUFFER_BINDING=_C('GL_PIXEL_PACK_BUFFER_BINDING',0x88ED) +GL_PIXEL_UNPACK_BUFFER=_C('GL_PIXEL_UNPACK_BUFFER',0x88EC) +GL_PIXEL_UNPACK_BUFFER_BINDING=_C('GL_PIXEL_UNPACK_BUFFER_BINDING',0x88EF) +GL_PRIMITIVE_RESTART_FIXED_INDEX=_C('GL_PRIMITIVE_RESTART_FIXED_INDEX',0x8D69) +GL_PROGRAM_BINARY_FORMATS=_C('GL_PROGRAM_BINARY_FORMATS',0x87FF) +GL_PROGRAM_BINARY_LENGTH=_C('GL_PROGRAM_BINARY_LENGTH',0x8741) +GL_PROGRAM_BINARY_RETRIEVABLE_HINT=_C('GL_PROGRAM_BINARY_RETRIEVABLE_HINT',0x8257) +GL_QUERY_RESULT=_C('GL_QUERY_RESULT',0x8866) +GL_QUERY_RESULT_AVAILABLE=_C('GL_QUERY_RESULT_AVAILABLE',0x8867) +GL_R11F_G11F_B10F=_C('GL_R11F_G11F_B10F',0x8C3A) +GL_R16F=_C('GL_R16F',0x822D) +GL_R16I=_C('GL_R16I',0x8233) +GL_R16UI=_C('GL_R16UI',0x8234) +GL_R32F=_C('GL_R32F',0x822E) +GL_R32I=_C('GL_R32I',0x8235) +GL_R32UI=_C('GL_R32UI',0x8236) +GL_R8=_C('GL_R8',0x8229) +GL_R8I=_C('GL_R8I',0x8231) +GL_R8UI=_C('GL_R8UI',0x8232) +GL_R8_SNORM=_C('GL_R8_SNORM',0x8F94) +GL_RASTERIZER_DISCARD=_C('GL_RASTERIZER_DISCARD',0x8C89) +GL_READ_BUFFER=_C('GL_READ_BUFFER',0x0C02) +GL_READ_FRAMEBUFFER=_C('GL_READ_FRAMEBUFFER',0x8CA8) +GL_READ_FRAMEBUFFER_BINDING=_C('GL_READ_FRAMEBUFFER_BINDING',0x8CAA) +GL_RED=_C('GL_RED',0x1903) +GL_RED_INTEGER=_C('GL_RED_INTEGER',0x8D94) +GL_RENDERBUFFER_SAMPLES=_C('GL_RENDERBUFFER_SAMPLES',0x8CAB) +GL_RG=_C('GL_RG',0x8227) +GL_RG16F=_C('GL_RG16F',0x822F) +GL_RG16I=_C('GL_RG16I',0x8239) +GL_RG16UI=_C('GL_RG16UI',0x823A) +GL_RG32F=_C('GL_RG32F',0x8230) +GL_RG32I=_C('GL_RG32I',0x823B) +GL_RG32UI=_C('GL_RG32UI',0x823C) +GL_RG8=_C('GL_RG8',0x822B) +GL_RG8I=_C('GL_RG8I',0x8237) +GL_RG8UI=_C('GL_RG8UI',0x8238) +GL_RG8_SNORM=_C('GL_RG8_SNORM',0x8F95) +GL_RGB10_A2=_C('GL_RGB10_A2',0x8059) +GL_RGB10_A2UI=_C('GL_RGB10_A2UI',0x906F) +GL_RGB16F=_C('GL_RGB16F',0x881B) +GL_RGB16I=_C('GL_RGB16I',0x8D89) +GL_RGB16UI=_C('GL_RGB16UI',0x8D77) +GL_RGB32F=_C('GL_RGB32F',0x8815) +GL_RGB32I=_C('GL_RGB32I',0x8D83) +GL_RGB32UI=_C('GL_RGB32UI',0x8D71) +GL_RGB8=_C('GL_RGB8',0x8051) +GL_RGB8I=_C('GL_RGB8I',0x8D8F) +GL_RGB8UI=_C('GL_RGB8UI',0x8D7D) +GL_RGB8_SNORM=_C('GL_RGB8_SNORM',0x8F96) +GL_RGB9_E5=_C('GL_RGB9_E5',0x8C3D) +GL_RGBA16F=_C('GL_RGBA16F',0x881A) +GL_RGBA16I=_C('GL_RGBA16I',0x8D88) +GL_RGBA16UI=_C('GL_RGBA16UI',0x8D76) +GL_RGBA32F=_C('GL_RGBA32F',0x8814) +GL_RGBA32I=_C('GL_RGBA32I',0x8D82) +GL_RGBA32UI=_C('GL_RGBA32UI',0x8D70) +GL_RGBA8=_C('GL_RGBA8',0x8058) +GL_RGBA8I=_C('GL_RGBA8I',0x8D8E) +GL_RGBA8UI=_C('GL_RGBA8UI',0x8D7C) +GL_RGBA8_SNORM=_C('GL_RGBA8_SNORM',0x8F97) +GL_RGBA_INTEGER=_C('GL_RGBA_INTEGER',0x8D99) +GL_RGB_INTEGER=_C('GL_RGB_INTEGER',0x8D98) +GL_RG_INTEGER=_C('GL_RG_INTEGER',0x8228) +GL_SAMPLER_2D_ARRAY=_C('GL_SAMPLER_2D_ARRAY',0x8DC1) +GL_SAMPLER_2D_ARRAY_SHADOW=_C('GL_SAMPLER_2D_ARRAY_SHADOW',0x8DC4) +GL_SAMPLER_2D_SHADOW=_C('GL_SAMPLER_2D_SHADOW',0x8B62) +GL_SAMPLER_3D=_C('GL_SAMPLER_3D',0x8B5F) +GL_SAMPLER_BINDING=_C('GL_SAMPLER_BINDING',0x8919) +GL_SAMPLER_CUBE_SHADOW=_C('GL_SAMPLER_CUBE_SHADOW',0x8DC5) +GL_SEPARATE_ATTRIBS=_C('GL_SEPARATE_ATTRIBS',0x8C8D) +GL_SIGNALED=_C('GL_SIGNALED',0x9119) +GL_SIGNED_NORMALIZED=_C('GL_SIGNED_NORMALIZED',0x8F9C) +GL_SRGB=_C('GL_SRGB',0x8C40) +GL_SRGB8=_C('GL_SRGB8',0x8C41) +GL_SRGB8_ALPHA8=_C('GL_SRGB8_ALPHA8',0x8C43) +GL_STATIC_COPY=_C('GL_STATIC_COPY',0x88E6) +GL_STATIC_READ=_C('GL_STATIC_READ',0x88E5) +GL_STENCIL=_C('GL_STENCIL',0x1802) +GL_STREAM_COPY=_C('GL_STREAM_COPY',0x88E2) +GL_STREAM_READ=_C('GL_STREAM_READ',0x88E1) +GL_SYNC_CONDITION=_C('GL_SYNC_CONDITION',0x9113) +GL_SYNC_FENCE=_C('GL_SYNC_FENCE',0x9116) +GL_SYNC_FLAGS=_C('GL_SYNC_FLAGS',0x9115) +GL_SYNC_FLUSH_COMMANDS_BIT=_C('GL_SYNC_FLUSH_COMMANDS_BIT',0x00000001) +GL_SYNC_GPU_COMMANDS_COMPLETE=_C('GL_SYNC_GPU_COMMANDS_COMPLETE',0x9117) +GL_SYNC_STATUS=_C('GL_SYNC_STATUS',0x9114) +GL_TEXTURE_2D_ARRAY=_C('GL_TEXTURE_2D_ARRAY',0x8C1A) +GL_TEXTURE_3D=_C('GL_TEXTURE_3D',0x806F) +GL_TEXTURE_BASE_LEVEL=_C('GL_TEXTURE_BASE_LEVEL',0x813C) +GL_TEXTURE_BINDING_2D_ARRAY=_C('GL_TEXTURE_BINDING_2D_ARRAY',0x8C1D) +GL_TEXTURE_BINDING_3D=_C('GL_TEXTURE_BINDING_3D',0x806A) +GL_TEXTURE_COMPARE_FUNC=_C('GL_TEXTURE_COMPARE_FUNC',0x884D) +GL_TEXTURE_COMPARE_MODE=_C('GL_TEXTURE_COMPARE_MODE',0x884C) +GL_TEXTURE_IMMUTABLE_FORMAT=_C('GL_TEXTURE_IMMUTABLE_FORMAT',0x912F) +GL_TEXTURE_IMMUTABLE_LEVELS=_C('GL_TEXTURE_IMMUTABLE_LEVELS',0x82DF) +GL_TEXTURE_MAX_LEVEL=_C('GL_TEXTURE_MAX_LEVEL',0x813D) +GL_TEXTURE_MAX_LOD=_C('GL_TEXTURE_MAX_LOD',0x813B) +GL_TEXTURE_MIN_LOD=_C('GL_TEXTURE_MIN_LOD',0x813A) +GL_TEXTURE_SWIZZLE_A=_C('GL_TEXTURE_SWIZZLE_A',0x8E45) +GL_TEXTURE_SWIZZLE_B=_C('GL_TEXTURE_SWIZZLE_B',0x8E44) +GL_TEXTURE_SWIZZLE_G=_C('GL_TEXTURE_SWIZZLE_G',0x8E43) +GL_TEXTURE_SWIZZLE_R=_C('GL_TEXTURE_SWIZZLE_R',0x8E42) +GL_TEXTURE_WRAP_R=_C('GL_TEXTURE_WRAP_R',0x8072) +GL_TIMEOUT_EXPIRED=_C('GL_TIMEOUT_EXPIRED',0x911B) +GL_TIMEOUT_IGNORED=_C('GL_TIMEOUT_IGNORED',0xFFFFFFFFFFFFFFFF) +GL_TRANSFORM_FEEDBACK=_C('GL_TRANSFORM_FEEDBACK',0x8E22) +GL_TRANSFORM_FEEDBACK_ACTIVE=_C('GL_TRANSFORM_FEEDBACK_ACTIVE',0x8E24) +GL_TRANSFORM_FEEDBACK_BINDING=_C('GL_TRANSFORM_FEEDBACK_BINDING',0x8E25) +GL_TRANSFORM_FEEDBACK_BUFFER=_C('GL_TRANSFORM_FEEDBACK_BUFFER',0x8C8E) +GL_TRANSFORM_FEEDBACK_BUFFER_BINDING=_C('GL_TRANSFORM_FEEDBACK_BUFFER_BINDING',0x8C8F) +GL_TRANSFORM_FEEDBACK_BUFFER_MODE=_C('GL_TRANSFORM_FEEDBACK_BUFFER_MODE',0x8C7F) +GL_TRANSFORM_FEEDBACK_BUFFER_SIZE=_C('GL_TRANSFORM_FEEDBACK_BUFFER_SIZE',0x8C85) +GL_TRANSFORM_FEEDBACK_BUFFER_START=_C('GL_TRANSFORM_FEEDBACK_BUFFER_START',0x8C84) +GL_TRANSFORM_FEEDBACK_PAUSED=_C('GL_TRANSFORM_FEEDBACK_PAUSED',0x8E23) +GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN=_C('GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN',0x8C88) +GL_TRANSFORM_FEEDBACK_VARYINGS=_C('GL_TRANSFORM_FEEDBACK_VARYINGS',0x8C83) +GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH=_C('GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH',0x8C76) +GL_UNIFORM_ARRAY_STRIDE=_C('GL_UNIFORM_ARRAY_STRIDE',0x8A3C) +GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS=_C('GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS',0x8A42) +GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES=_C('GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES',0x8A43) +GL_UNIFORM_BLOCK_BINDING=_C('GL_UNIFORM_BLOCK_BINDING',0x8A3F) +GL_UNIFORM_BLOCK_DATA_SIZE=_C('GL_UNIFORM_BLOCK_DATA_SIZE',0x8A40) +GL_UNIFORM_BLOCK_INDEX=_C('GL_UNIFORM_BLOCK_INDEX',0x8A3A) +GL_UNIFORM_BLOCK_NAME_LENGTH=_C('GL_UNIFORM_BLOCK_NAME_LENGTH',0x8A41) +GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER=_C('GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER',0x8A46) +GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER=_C('GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER',0x8A44) +GL_UNIFORM_BUFFER=_C('GL_UNIFORM_BUFFER',0x8A11) +GL_UNIFORM_BUFFER_BINDING=_C('GL_UNIFORM_BUFFER_BINDING',0x8A28) +GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT=_C('GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT',0x8A34) +GL_UNIFORM_BUFFER_SIZE=_C('GL_UNIFORM_BUFFER_SIZE',0x8A2A) +GL_UNIFORM_BUFFER_START=_C('GL_UNIFORM_BUFFER_START',0x8A29) +GL_UNIFORM_IS_ROW_MAJOR=_C('GL_UNIFORM_IS_ROW_MAJOR',0x8A3E) +GL_UNIFORM_MATRIX_STRIDE=_C('GL_UNIFORM_MATRIX_STRIDE',0x8A3D) +GL_UNIFORM_NAME_LENGTH=_C('GL_UNIFORM_NAME_LENGTH',0x8A39) +GL_UNIFORM_OFFSET=_C('GL_UNIFORM_OFFSET',0x8A3B) +GL_UNIFORM_SIZE=_C('GL_UNIFORM_SIZE',0x8A38) +GL_UNIFORM_TYPE=_C('GL_UNIFORM_TYPE',0x8A37) +GL_UNPACK_IMAGE_HEIGHT=_C('GL_UNPACK_IMAGE_HEIGHT',0x806E) +GL_UNPACK_ROW_LENGTH=_C('GL_UNPACK_ROW_LENGTH',0x0CF2) +GL_UNPACK_SKIP_IMAGES=_C('GL_UNPACK_SKIP_IMAGES',0x806D) +GL_UNPACK_SKIP_PIXELS=_C('GL_UNPACK_SKIP_PIXELS',0x0CF4) +GL_UNPACK_SKIP_ROWS=_C('GL_UNPACK_SKIP_ROWS',0x0CF3) +GL_UNSIGNALED=_C('GL_UNSIGNALED',0x9118) +GL_UNSIGNED_INT_10F_11F_11F_REV=_C('GL_UNSIGNED_INT_10F_11F_11F_REV',0x8C3B) +GL_UNSIGNED_INT_24_8=_C('GL_UNSIGNED_INT_24_8',0x84FA) +GL_UNSIGNED_INT_2_10_10_10_REV=_C('GL_UNSIGNED_INT_2_10_10_10_REV',0x8368) +GL_UNSIGNED_INT_5_9_9_9_REV=_C('GL_UNSIGNED_INT_5_9_9_9_REV',0x8C3E) +GL_UNSIGNED_INT_SAMPLER_2D=_C('GL_UNSIGNED_INT_SAMPLER_2D',0x8DD2) +GL_UNSIGNED_INT_SAMPLER_2D_ARRAY=_C('GL_UNSIGNED_INT_SAMPLER_2D_ARRAY',0x8DD7) +GL_UNSIGNED_INT_SAMPLER_3D=_C('GL_UNSIGNED_INT_SAMPLER_3D',0x8DD3) +GL_UNSIGNED_INT_SAMPLER_CUBE=_C('GL_UNSIGNED_INT_SAMPLER_CUBE',0x8DD4) +GL_UNSIGNED_INT_VEC2=_C('GL_UNSIGNED_INT_VEC2',0x8DC6) +GL_UNSIGNED_INT_VEC3=_C('GL_UNSIGNED_INT_VEC3',0x8DC7) +GL_UNSIGNED_INT_VEC4=_C('GL_UNSIGNED_INT_VEC4',0x8DC8) +GL_UNSIGNED_NORMALIZED=_C('GL_UNSIGNED_NORMALIZED',0x8C17) +GL_VERTEX_ARRAY_BINDING=_C('GL_VERTEX_ARRAY_BINDING',0x85B5) +GL_VERTEX_ATTRIB_ARRAY_DIVISOR=_C('GL_VERTEX_ATTRIB_ARRAY_DIVISOR',0x88FE) +GL_VERTEX_ATTRIB_ARRAY_INTEGER=_C('GL_VERTEX_ATTRIB_ARRAY_INTEGER',0x88FD) +GL_WAIT_FAILED=_C('GL_WAIT_FAILED',0x911D) +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint) +def glBeginQuery(target,id):pass +@_f +@_p.types(None,_cs.GLenum) +def glBeginTransformFeedback(primitiveMode):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,_cs.GLuint) +def glBindBufferBase(target,index,buffer):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,_cs.GLuint,_cs.GLintptr,_cs.GLsizeiptr) +def glBindBufferRange(target,index,buffer,offset,size):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint) +def glBindSampler(unit,sampler):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint) +def glBindTransformFeedback(target,id):pass +@_f +@_p.types(None,_cs.GLuint) +def glBindVertexArray(array):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLbitfield,_cs.GLenum) +def glBlitFramebuffer(srcX0,srcY0,srcX1,srcY1,dstX0,dstY0,dstX1,dstY1,mask,filter):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLint,_cs.GLfloat,_cs.GLint) +def glClearBufferfi(buffer,drawbuffer,depth,stencil):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLint,arrays.GLfloatArray) +def glClearBufferfv(buffer,drawbuffer,value):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLint,arrays.GLintArray) +def glClearBufferiv(buffer,drawbuffer,value):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLint,arrays.GLuintArray) +def glClearBufferuiv(buffer,drawbuffer,value):pass +@_f +@_p.types(_cs.GLenum,_cs.GLsync,_cs.GLbitfield,_cs.GLuint64) +def glClientWaitSync(sync,flags,timeout):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLint,_cs.GLenum,_cs.GLsizei,_cs.GLsizei,_cs.GLsizei,_cs.GLint,_cs.GLsizei,ctypes.c_void_p) +def glCompressedTexImage3D(target,level,internalformat,width,height,depth,border,imageSize,data):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLsizei,_cs.GLsizei,_cs.GLenum,_cs.GLsizei,ctypes.c_void_p) +def glCompressedTexSubImage3D(target,level,xoffset,yoffset,zoffset,width,height,depth,format,imageSize,data):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLintptr,_cs.GLintptr,_cs.GLsizeiptr) +def glCopyBufferSubData(readTarget,writeTarget,readOffset,writeOffset,size):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLsizei) +def glCopyTexSubImage3D(target,level,xoffset,yoffset,zoffset,x,y,width,height):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray) +def glDeleteQueries(n,ids):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray) +def glDeleteSamplers(count,samplers):pass +@_f +@_p.types(None,_cs.GLsync) +def glDeleteSync(sync):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray) +def glDeleteTransformFeedbacks(n,ids):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray) +def glDeleteVertexArrays(n,arrays):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLint,_cs.GLsizei,_cs.GLsizei) +def glDrawArraysInstanced(mode,first,count,instancecount):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray) +def glDrawBuffers(n,bufs):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizei,_cs.GLenum,ctypes.c_void_p,_cs.GLsizei) +def glDrawElementsInstanced(mode,count,type,indices,instancecount):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,_cs.GLuint,_cs.GLsizei,_cs.GLenum,ctypes.c_void_p) +def glDrawRangeElements(mode,start,end,count,type,indices):pass +@_f +@_p.types(None,_cs.GLenum) +def glEndQuery(target):pass +@_f +@_p.types(None,) +def glEndTransformFeedback():pass +@_f +@_p.types(_cs.GLsync,_cs.GLenum,_cs.GLbitfield) +def glFenceSync(condition,flags):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLintptr,_cs.GLsizeiptr) +def glFlushMappedBufferRange(target,offset,length):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLuint,_cs.GLint,_cs.GLint) +def glFramebufferTextureLayer(target,attachment,texture,level,layer):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray) +def glGenQueries(n,ids):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray) +def glGenSamplers(count,samplers):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray) +def glGenTransformFeedbacks(n,ids):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray) +def glGenVertexArrays(n,arrays):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLsizei,arrays.GLsizeiArray,arrays.GLcharArray) +def glGetActiveUniformBlockName(program,uniformBlockIndex,bufSize,length,uniformBlockName):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLenum,arrays.GLintArray) +def glGetActiveUniformBlockiv(program,uniformBlockIndex,pname,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizei,arrays.GLuintArray,_cs.GLenum,arrays.GLintArray) +def glGetActiveUniformsiv(program,uniformCount,uniformIndices,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLint64Array) +def glGetBufferParameteri64v(target,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLvoidpArray) +def glGetBufferPointerv(target,pname,params):pass +@_f +@_p.types(_cs.GLint,_cs.GLuint,arrays.GLcharArray) +def glGetFragDataLocation(program,name):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,arrays.GLint64Array) +def glGetInteger64i_v(target,index,data):pass +@_f +@_p.types(None,_cs.GLenum,arrays.GLint64Array) +def glGetInteger64v(pname,data):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,arrays.GLintArray) +def glGetIntegeri_v(target,index,data):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLenum,_cs.GLsizei,arrays.GLintArray) +def glGetInternalformativ(target,internalformat,pname,bufSize,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizei,arrays.GLsizeiArray,arrays.GLuintArray,ctypes.c_void_p) +def glGetProgramBinary(program,bufSize,length,binaryFormat,binary):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLuintArray) +def glGetQueryObjectuiv(id,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLintArray) +def glGetQueryiv(target,pname,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLfloatArray) +def glGetSamplerParameterfv(sampler,pname,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLintArray) +def glGetSamplerParameteriv(sampler,pname,params):pass +@_f +@_p.types(arrays.GLubyteArray,_cs.GLenum,_cs.GLuint) +def glGetStringi(name,index):pass +@_f +@_p.types(None,_cs.GLsync,_cs.GLenum,_cs.GLsizei,arrays.GLsizeiArray,arrays.GLintArray) +def glGetSynciv(sync,pname,bufSize,length,values):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLsizei,arrays.GLsizeiArray,arrays.GLsizeiArray,arrays.GLuintArray,arrays.GLcharArray) +def glGetTransformFeedbackVarying(program,index,bufSize,length,size,type,name):pass +@_f +@_p.types(_cs.GLuint,_cs.GLuint,arrays.GLcharArray) +def glGetUniformBlockIndex(program,uniformBlockName):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizei,ctypes.POINTER( ctypes.POINTER( _cs.GLchar )),arrays.GLuintArray) +def glGetUniformIndices(program,uniformCount,uniformNames,uniformIndices):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,arrays.GLuintArray) +def glGetUniformuiv(program,location,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLintArray) +def glGetVertexAttribIiv(index,pname,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLuintArray) +def glGetVertexAttribIuiv(index,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizei,arrays.GLuintArray) +def glInvalidateFramebuffer(target,numAttachments,attachments):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizei,arrays.GLuintArray,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLsizei) +def glInvalidateSubFramebuffer(target,numAttachments,attachments,x,y,width,height):pass +@_f +@_p.types(_cs.GLboolean,_cs.GLuint) +def glIsQuery(id):pass +@_f +@_p.types(_cs.GLboolean,_cs.GLuint) +def glIsSampler(sampler):pass +@_f +@_p.types(_cs.GLboolean,_cs.GLsync) +def glIsSync(sync):pass +@_f +@_p.types(_cs.GLboolean,_cs.GLuint) +def glIsTransformFeedback(id):pass +@_f +@_p.types(_cs.GLboolean,_cs.GLuint) +def glIsVertexArray(array):pass +@_f +@_p.types(ctypes.c_void_p,_cs.GLenum,_cs.GLintptr,_cs.GLsizeiptr,_cs.GLbitfield) +def glMapBufferRange(target,offset,length,access):pass +@_f +@_p.types(None,) +def glPauseTransformFeedback():pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,ctypes.c_void_p,_cs.GLsizei) +def glProgramBinary(program,binaryFormat,binary,length):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLint) +def glProgramParameteri(program,pname,value):pass +@_f +@_p.types(None,_cs.GLenum) +def glReadBuffer(src):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizei,_cs.GLenum,_cs.GLsizei,_cs.GLsizei) +def glRenderbufferStorageMultisample(target,samples,internalformat,width,height):pass +@_f +@_p.types(None,) +def glResumeTransformFeedback():pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLfloat) +def glSamplerParameterf(sampler,pname,param):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLfloatArray) +def glSamplerParameterfv(sampler,pname,param):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLint) +def glSamplerParameteri(sampler,pname,param):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLintArray) +def glSamplerParameteriv(sampler,pname,param):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLsizei,_cs.GLsizei,_cs.GLint,_cs.GLenum,_cs.GLenum,ctypes.c_void_p) +def glTexImage3D(target,level,internalformat,width,height,depth,border,format,type,pixels):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizei,_cs.GLenum,_cs.GLsizei,_cs.GLsizei) +def glTexStorage2D(target,levels,internalformat,width,height):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizei,_cs.GLenum,_cs.GLsizei,_cs.GLsizei,_cs.GLsizei) +def glTexStorage3D(target,levels,internalformat,width,height,depth):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLsizei,_cs.GLsizei,_cs.GLenum,_cs.GLenum,ctypes.c_void_p) +def glTexSubImage3D(target,level,xoffset,yoffset,zoffset,width,height,depth,format,type,pixels):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizei,ctypes.POINTER( ctypes.POINTER( _cs.GLchar )),_cs.GLenum) +def glTransformFeedbackVaryings(program,count,varyings,bufferMode):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLuint) +def glUniform1ui(location,v0):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLsizei,arrays.GLuintArray) +def glUniform1uiv(location,count,value):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLuint,_cs.GLuint) +def glUniform2ui(location,v0,v1):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLsizei,arrays.GLuintArray) +def glUniform2uiv(location,count,value):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLuint,_cs.GLuint,_cs.GLuint) +def glUniform3ui(location,v0,v1,v2):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLsizei,arrays.GLuintArray) +def glUniform3uiv(location,count,value):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLuint,_cs.GLuint,_cs.GLuint,_cs.GLuint) +def glUniform4ui(location,v0,v1,v2,v3):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLsizei,arrays.GLuintArray) +def glUniform4uiv(location,count,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLuint) +def glUniformBlockBinding(program,uniformBlockIndex,uniformBlockBinding):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLsizei,_cs.GLboolean,arrays.GLfloatArray) +def glUniformMatrix2x3fv(location,count,transpose,value):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLsizei,_cs.GLboolean,arrays.GLfloatArray) +def glUniformMatrix2x4fv(location,count,transpose,value):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLsizei,_cs.GLboolean,arrays.GLfloatArray) +def glUniformMatrix3x2fv(location,count,transpose,value):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLsizei,_cs.GLboolean,arrays.GLfloatArray) +def glUniformMatrix3x4fv(location,count,transpose,value):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLsizei,_cs.GLboolean,arrays.GLfloatArray) +def glUniformMatrix4x2fv(location,count,transpose,value):pass +@_f +@_p.types(None,_cs.GLint,_cs.GLsizei,_cs.GLboolean,arrays.GLfloatArray) +def glUniformMatrix4x3fv(location,count,transpose,value):pass +@_f +@_p.types(_cs.GLboolean,_cs.GLenum) +def glUnmapBuffer(target):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint) +def glVertexAttribDivisor(index,divisor):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint) +def glVertexAttribI4i(index,x,y,z,w):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLintArray) +def glVertexAttribI4iv(index,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLuint,_cs.GLuint,_cs.GLuint) +def glVertexAttribI4ui(index,x,y,z,w):pass +@_f +@_p.types(None,_cs.GLuint,arrays.GLuintArray) +def glVertexAttribI4uiv(index,v):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLenum,_cs.GLsizei,ctypes.c_void_p) +def glVertexAttribIPointer(index,size,type,stride,pointer):pass +@_f +@_p.types(None,_cs.GLsync,_cs.GLbitfield,_cs.GLuint64) +def glWaitSync(sync,flags,timeout):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES3/VERSION/GLES3_3_1.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES3/VERSION/GLES3_3_1.py new file mode 100644 index 00000000..aae759ef --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES3/VERSION/GLES3_3_1.py @@ -0,0 +1,394 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLES3 import _types as _cs +# End users want this... +from OpenGL.raw.GLES3._types import * +from OpenGL.raw.GLES3 import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLES3_VERSION_GLES3_3_1' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLES3,'GLES3_VERSION_GLES3_3_1',error_checker=_errors._error_checker) +GL_ACTIVE_ATOMIC_COUNTER_BUFFERS=_C('GL_ACTIVE_ATOMIC_COUNTER_BUFFERS',0x92D9) +GL_ACTIVE_PROGRAM=_C('GL_ACTIVE_PROGRAM',0x8259) +GL_ACTIVE_RESOURCES=_C('GL_ACTIVE_RESOURCES',0x92F5) +GL_ACTIVE_VARIABLES=_C('GL_ACTIVE_VARIABLES',0x9305) +GL_ALL_BARRIER_BITS=_C('GL_ALL_BARRIER_BITS',0xFFFFFFFF) +GL_ALL_SHADER_BITS=_C('GL_ALL_SHADER_BITS',0xFFFFFFFF) +GL_ARRAY_SIZE=_C('GL_ARRAY_SIZE',0x92FB) +GL_ARRAY_STRIDE=_C('GL_ARRAY_STRIDE',0x92FE) +GL_ATOMIC_COUNTER_BARRIER_BIT=_C('GL_ATOMIC_COUNTER_BARRIER_BIT',0x00001000) +GL_ATOMIC_COUNTER_BUFFER=_C('GL_ATOMIC_COUNTER_BUFFER',0x92C0) +GL_ATOMIC_COUNTER_BUFFER=_C('GL_ATOMIC_COUNTER_BUFFER',0x92C0) +GL_ATOMIC_COUNTER_BUFFER_BINDING=_C('GL_ATOMIC_COUNTER_BUFFER_BINDING',0x92C1) +GL_ATOMIC_COUNTER_BUFFER_INDEX=_C('GL_ATOMIC_COUNTER_BUFFER_INDEX',0x9301) +GL_ATOMIC_COUNTER_BUFFER_SIZE=_C('GL_ATOMIC_COUNTER_BUFFER_SIZE',0x92C3) +GL_ATOMIC_COUNTER_BUFFER_START=_C('GL_ATOMIC_COUNTER_BUFFER_START',0x92C2) +GL_BLOCK_INDEX=_C('GL_BLOCK_INDEX',0x92FD) +GL_BUFFER_BINDING=_C('GL_BUFFER_BINDING',0x9302) +GL_BUFFER_DATA_SIZE=_C('GL_BUFFER_DATA_SIZE',0x9303) +GL_BUFFER_UPDATE_BARRIER_BIT=_C('GL_BUFFER_UPDATE_BARRIER_BIT',0x00000200) +GL_BUFFER_VARIABLE=_C('GL_BUFFER_VARIABLE',0x92E5) +GL_COMMAND_BARRIER_BIT=_C('GL_COMMAND_BARRIER_BIT',0x00000040) +GL_COMPUTE_SHADER=_C('GL_COMPUTE_SHADER',0x91B9) +GL_COMPUTE_SHADER_BIT=_C('GL_COMPUTE_SHADER_BIT',0x00000020) +GL_COMPUTE_WORK_GROUP_SIZE=_C('GL_COMPUTE_WORK_GROUP_SIZE',0x8267) +GL_DEPTH_STENCIL_TEXTURE_MODE=_C('GL_DEPTH_STENCIL_TEXTURE_MODE',0x90EA) +GL_DISPATCH_INDIRECT_BUFFER=_C('GL_DISPATCH_INDIRECT_BUFFER',0x90EE) +GL_DISPATCH_INDIRECT_BUFFER_BINDING=_C('GL_DISPATCH_INDIRECT_BUFFER_BINDING',0x90EF) +GL_DRAW_INDIRECT_BUFFER=_C('GL_DRAW_INDIRECT_BUFFER',0x8F3F) +GL_DRAW_INDIRECT_BUFFER_BINDING=_C('GL_DRAW_INDIRECT_BUFFER_BINDING',0x8F43) +GL_ELEMENT_ARRAY_BARRIER_BIT=_C('GL_ELEMENT_ARRAY_BARRIER_BIT',0x00000002) +GL_FRAGMENT_SHADER_BIT=_C('GL_FRAGMENT_SHADER_BIT',0x00000002) +GL_FRAMEBUFFER_BARRIER_BIT=_C('GL_FRAMEBUFFER_BARRIER_BIT',0x00000400) +GL_FRAMEBUFFER_DEFAULT_FIXED_SAMPLE_LOCATIONS=_C('GL_FRAMEBUFFER_DEFAULT_FIXED_SAMPLE_LOCATIONS',0x9314) +GL_FRAMEBUFFER_DEFAULT_HEIGHT=_C('GL_FRAMEBUFFER_DEFAULT_HEIGHT',0x9311) +GL_FRAMEBUFFER_DEFAULT_SAMPLES=_C('GL_FRAMEBUFFER_DEFAULT_SAMPLES',0x9313) +GL_FRAMEBUFFER_DEFAULT_WIDTH=_C('GL_FRAMEBUFFER_DEFAULT_WIDTH',0x9310) +GL_IMAGE_2D=_C('GL_IMAGE_2D',0x904D) +GL_IMAGE_2D_ARRAY=_C('GL_IMAGE_2D_ARRAY',0x9053) +GL_IMAGE_3D=_C('GL_IMAGE_3D',0x904E) +GL_IMAGE_BINDING_ACCESS=_C('GL_IMAGE_BINDING_ACCESS',0x8F3E) +GL_IMAGE_BINDING_FORMAT=_C('GL_IMAGE_BINDING_FORMAT',0x906E) +GL_IMAGE_BINDING_LAYER=_C('GL_IMAGE_BINDING_LAYER',0x8F3D) +GL_IMAGE_BINDING_LAYERED=_C('GL_IMAGE_BINDING_LAYERED',0x8F3C) +GL_IMAGE_BINDING_LEVEL=_C('GL_IMAGE_BINDING_LEVEL',0x8F3B) +GL_IMAGE_BINDING_NAME=_C('GL_IMAGE_BINDING_NAME',0x8F3A) +GL_IMAGE_CUBE=_C('GL_IMAGE_CUBE',0x9050) +GL_IMAGE_FORMAT_COMPATIBILITY_BY_CLASS=_C('GL_IMAGE_FORMAT_COMPATIBILITY_BY_CLASS',0x90C9) +GL_IMAGE_FORMAT_COMPATIBILITY_BY_SIZE=_C('GL_IMAGE_FORMAT_COMPATIBILITY_BY_SIZE',0x90C8) +GL_IMAGE_FORMAT_COMPATIBILITY_TYPE=_C('GL_IMAGE_FORMAT_COMPATIBILITY_TYPE',0x90C7) +GL_INT_IMAGE_2D=_C('GL_INT_IMAGE_2D',0x9058) +GL_INT_IMAGE_2D_ARRAY=_C('GL_INT_IMAGE_2D_ARRAY',0x905E) +GL_INT_IMAGE_3D=_C('GL_INT_IMAGE_3D',0x9059) +GL_INT_IMAGE_CUBE=_C('GL_INT_IMAGE_CUBE',0x905B) +GL_INT_SAMPLER_2D_MULTISAMPLE=_C('GL_INT_SAMPLER_2D_MULTISAMPLE',0x9109) +GL_IS_ROW_MAJOR=_C('GL_IS_ROW_MAJOR',0x9300) +GL_LOCATION=_C('GL_LOCATION',0x930E) +GL_MATRIX_STRIDE=_C('GL_MATRIX_STRIDE',0x92FF) +GL_MAX_ATOMIC_COUNTER_BUFFER_BINDINGS=_C('GL_MAX_ATOMIC_COUNTER_BUFFER_BINDINGS',0x92DC) +GL_MAX_ATOMIC_COUNTER_BUFFER_SIZE=_C('GL_MAX_ATOMIC_COUNTER_BUFFER_SIZE',0x92D8) +GL_MAX_COLOR_TEXTURE_SAMPLES=_C('GL_MAX_COLOR_TEXTURE_SAMPLES',0x910E) +GL_MAX_COMBINED_ATOMIC_COUNTERS=_C('GL_MAX_COMBINED_ATOMIC_COUNTERS',0x92D7) +GL_MAX_COMBINED_ATOMIC_COUNTER_BUFFERS=_C('GL_MAX_COMBINED_ATOMIC_COUNTER_BUFFERS',0x92D1) +GL_MAX_COMBINED_COMPUTE_UNIFORM_COMPONENTS=_C('GL_MAX_COMBINED_COMPUTE_UNIFORM_COMPONENTS',0x8266) +GL_MAX_COMBINED_IMAGE_UNIFORMS=_C('GL_MAX_COMBINED_IMAGE_UNIFORMS',0x90CF) +GL_MAX_COMBINED_SHADER_OUTPUT_RESOURCES=_C('GL_MAX_COMBINED_SHADER_OUTPUT_RESOURCES',0x8F39) +GL_MAX_COMBINED_SHADER_STORAGE_BLOCKS=_C('GL_MAX_COMBINED_SHADER_STORAGE_BLOCKS',0x90DC) +GL_MAX_COMPUTE_ATOMIC_COUNTERS=_C('GL_MAX_COMPUTE_ATOMIC_COUNTERS',0x8265) +GL_MAX_COMPUTE_ATOMIC_COUNTERS=_C('GL_MAX_COMPUTE_ATOMIC_COUNTERS',0x8265) +GL_MAX_COMPUTE_ATOMIC_COUNTER_BUFFERS=_C('GL_MAX_COMPUTE_ATOMIC_COUNTER_BUFFERS',0x8264) +GL_MAX_COMPUTE_ATOMIC_COUNTER_BUFFERS=_C('GL_MAX_COMPUTE_ATOMIC_COUNTER_BUFFERS',0x8264) +GL_MAX_COMPUTE_IMAGE_UNIFORMS=_C('GL_MAX_COMPUTE_IMAGE_UNIFORMS',0x91BD) +GL_MAX_COMPUTE_IMAGE_UNIFORMS=_C('GL_MAX_COMPUTE_IMAGE_UNIFORMS',0x91BD) +GL_MAX_COMPUTE_SHADER_STORAGE_BLOCKS=_C('GL_MAX_COMPUTE_SHADER_STORAGE_BLOCKS',0x90DB) +GL_MAX_COMPUTE_SHARED_MEMORY_SIZE=_C('GL_MAX_COMPUTE_SHARED_MEMORY_SIZE',0x8262) +GL_MAX_COMPUTE_TEXTURE_IMAGE_UNITS=_C('GL_MAX_COMPUTE_TEXTURE_IMAGE_UNITS',0x91BC) +GL_MAX_COMPUTE_UNIFORM_BLOCKS=_C('GL_MAX_COMPUTE_UNIFORM_BLOCKS',0x91BB) +GL_MAX_COMPUTE_UNIFORM_COMPONENTS=_C('GL_MAX_COMPUTE_UNIFORM_COMPONENTS',0x8263) +GL_MAX_COMPUTE_WORK_GROUP_COUNT=_C('GL_MAX_COMPUTE_WORK_GROUP_COUNT',0x91BE) +GL_MAX_COMPUTE_WORK_GROUP_INVOCATIONS=_C('GL_MAX_COMPUTE_WORK_GROUP_INVOCATIONS',0x90EB) +GL_MAX_COMPUTE_WORK_GROUP_SIZE=_C('GL_MAX_COMPUTE_WORK_GROUP_SIZE',0x91BF) +GL_MAX_DEPTH_TEXTURE_SAMPLES=_C('GL_MAX_DEPTH_TEXTURE_SAMPLES',0x910F) +GL_MAX_FRAGMENT_ATOMIC_COUNTERS=_C('GL_MAX_FRAGMENT_ATOMIC_COUNTERS',0x92D6) +GL_MAX_FRAGMENT_ATOMIC_COUNTER_BUFFERS=_C('GL_MAX_FRAGMENT_ATOMIC_COUNTER_BUFFERS',0x92D0) +GL_MAX_FRAGMENT_IMAGE_UNIFORMS=_C('GL_MAX_FRAGMENT_IMAGE_UNIFORMS',0x90CE) +GL_MAX_FRAGMENT_SHADER_STORAGE_BLOCKS=_C('GL_MAX_FRAGMENT_SHADER_STORAGE_BLOCKS',0x90DA) +GL_MAX_FRAMEBUFFER_HEIGHT=_C('GL_MAX_FRAMEBUFFER_HEIGHT',0x9316) +GL_MAX_FRAMEBUFFER_SAMPLES=_C('GL_MAX_FRAMEBUFFER_SAMPLES',0x9318) +GL_MAX_FRAMEBUFFER_WIDTH=_C('GL_MAX_FRAMEBUFFER_WIDTH',0x9315) +GL_MAX_IMAGE_UNITS=_C('GL_MAX_IMAGE_UNITS',0x8F38) +GL_MAX_INTEGER_SAMPLES=_C('GL_MAX_INTEGER_SAMPLES',0x9110) +GL_MAX_NAME_LENGTH=_C('GL_MAX_NAME_LENGTH',0x92F6) +GL_MAX_NUM_ACTIVE_VARIABLES=_C('GL_MAX_NUM_ACTIVE_VARIABLES',0x92F7) +GL_MAX_PROGRAM_TEXTURE_GATHER_OFFSET=_C('GL_MAX_PROGRAM_TEXTURE_GATHER_OFFSET',0x8E5F) +GL_MAX_SAMPLE_MASK_WORDS=_C('GL_MAX_SAMPLE_MASK_WORDS',0x8E59) +GL_MAX_SHADER_STORAGE_BLOCK_SIZE=_C('GL_MAX_SHADER_STORAGE_BLOCK_SIZE',0x90DE) +GL_MAX_SHADER_STORAGE_BUFFER_BINDINGS=_C('GL_MAX_SHADER_STORAGE_BUFFER_BINDINGS',0x90DD) +GL_MAX_UNIFORM_LOCATIONS=_C('GL_MAX_UNIFORM_LOCATIONS',0x826E) +GL_MAX_VERTEX_ATOMIC_COUNTERS=_C('GL_MAX_VERTEX_ATOMIC_COUNTERS',0x92D2) +GL_MAX_VERTEX_ATOMIC_COUNTER_BUFFERS=_C('GL_MAX_VERTEX_ATOMIC_COUNTER_BUFFERS',0x92CC) +GL_MAX_VERTEX_ATTRIB_BINDINGS=_C('GL_MAX_VERTEX_ATTRIB_BINDINGS',0x82DA) +GL_MAX_VERTEX_ATTRIB_RELATIVE_OFFSET=_C('GL_MAX_VERTEX_ATTRIB_RELATIVE_OFFSET',0x82D9) +GL_MAX_VERTEX_ATTRIB_STRIDE=_C('GL_MAX_VERTEX_ATTRIB_STRIDE',0x82E5) +GL_MAX_VERTEX_IMAGE_UNIFORMS=_C('GL_MAX_VERTEX_IMAGE_UNIFORMS',0x90CA) +GL_MAX_VERTEX_SHADER_STORAGE_BLOCKS=_C('GL_MAX_VERTEX_SHADER_STORAGE_BLOCKS',0x90D6) +GL_MIN_PROGRAM_TEXTURE_GATHER_OFFSET=_C('GL_MIN_PROGRAM_TEXTURE_GATHER_OFFSET',0x8E5E) +GL_NAME_LENGTH=_C('GL_NAME_LENGTH',0x92F9) +GL_NUM_ACTIVE_VARIABLES=_C('GL_NUM_ACTIVE_VARIABLES',0x9304) +GL_OFFSET=_C('GL_OFFSET',0x92FC) +GL_PIXEL_BUFFER_BARRIER_BIT=_C('GL_PIXEL_BUFFER_BARRIER_BIT',0x00000080) +GL_PROGRAM_INPUT=_C('GL_PROGRAM_INPUT',0x92E3) +GL_PROGRAM_OUTPUT=_C('GL_PROGRAM_OUTPUT',0x92E4) +GL_PROGRAM_PIPELINE_BINDING=_C('GL_PROGRAM_PIPELINE_BINDING',0x825A) +GL_PROGRAM_SEPARABLE=_C('GL_PROGRAM_SEPARABLE',0x8258) +GL_READ_ONLY=_C('GL_READ_ONLY',0x88B8) +GL_READ_WRITE=_C('GL_READ_WRITE',0x88BA) +GL_REFERENCED_BY_COMPUTE_SHADER=_C('GL_REFERENCED_BY_COMPUTE_SHADER',0x930B) +GL_REFERENCED_BY_FRAGMENT_SHADER=_C('GL_REFERENCED_BY_FRAGMENT_SHADER',0x930A) +GL_REFERENCED_BY_VERTEX_SHADER=_C('GL_REFERENCED_BY_VERTEX_SHADER',0x9306) +GL_SAMPLER_2D_MULTISAMPLE=_C('GL_SAMPLER_2D_MULTISAMPLE',0x9108) +GL_SAMPLE_MASK=_C('GL_SAMPLE_MASK',0x8E51) +GL_SAMPLE_MASK_VALUE=_C('GL_SAMPLE_MASK_VALUE',0x8E52) +GL_SAMPLE_POSITION=_C('GL_SAMPLE_POSITION',0x8E50) +GL_SHADER_IMAGE_ACCESS_BARRIER_BIT=_C('GL_SHADER_IMAGE_ACCESS_BARRIER_BIT',0x00000020) +GL_SHADER_STORAGE_BARRIER_BIT=_C('GL_SHADER_STORAGE_BARRIER_BIT',0x00002000) +GL_SHADER_STORAGE_BLOCK=_C('GL_SHADER_STORAGE_BLOCK',0x92E6) +GL_SHADER_STORAGE_BUFFER=_C('GL_SHADER_STORAGE_BUFFER',0x90D2) +GL_SHADER_STORAGE_BUFFER_BINDING=_C('GL_SHADER_STORAGE_BUFFER_BINDING',0x90D3) +GL_SHADER_STORAGE_BUFFER_OFFSET_ALIGNMENT=_C('GL_SHADER_STORAGE_BUFFER_OFFSET_ALIGNMENT',0x90DF) +GL_SHADER_STORAGE_BUFFER_SIZE=_C('GL_SHADER_STORAGE_BUFFER_SIZE',0x90D5) +GL_SHADER_STORAGE_BUFFER_START=_C('GL_SHADER_STORAGE_BUFFER_START',0x90D4) +GL_STENCIL_INDEX=_C('GL_STENCIL_INDEX',0x1901) +GL_TEXTURE_2D_MULTISAMPLE=_C('GL_TEXTURE_2D_MULTISAMPLE',0x9100) +GL_TEXTURE_ALPHA_SIZE=_C('GL_TEXTURE_ALPHA_SIZE',0x805F) +GL_TEXTURE_ALPHA_TYPE=_C('GL_TEXTURE_ALPHA_TYPE',0x8C13) +GL_TEXTURE_BINDING_2D_MULTISAMPLE=_C('GL_TEXTURE_BINDING_2D_MULTISAMPLE',0x9104) +GL_TEXTURE_BLUE_SIZE=_C('GL_TEXTURE_BLUE_SIZE',0x805E) +GL_TEXTURE_BLUE_TYPE=_C('GL_TEXTURE_BLUE_TYPE',0x8C12) +GL_TEXTURE_COMPRESSED=_C('GL_TEXTURE_COMPRESSED',0x86A1) +GL_TEXTURE_DEPTH=_C('GL_TEXTURE_DEPTH',0x8071) +GL_TEXTURE_DEPTH_SIZE=_C('GL_TEXTURE_DEPTH_SIZE',0x884A) +GL_TEXTURE_DEPTH_TYPE=_C('GL_TEXTURE_DEPTH_TYPE',0x8C16) +GL_TEXTURE_FETCH_BARRIER_BIT=_C('GL_TEXTURE_FETCH_BARRIER_BIT',0x00000008) +GL_TEXTURE_FIXED_SAMPLE_LOCATIONS=_C('GL_TEXTURE_FIXED_SAMPLE_LOCATIONS',0x9107) +GL_TEXTURE_GREEN_SIZE=_C('GL_TEXTURE_GREEN_SIZE',0x805D) +GL_TEXTURE_GREEN_TYPE=_C('GL_TEXTURE_GREEN_TYPE',0x8C11) +GL_TEXTURE_HEIGHT=_C('GL_TEXTURE_HEIGHT',0x1001) +GL_TEXTURE_INTERNAL_FORMAT=_C('GL_TEXTURE_INTERNAL_FORMAT',0x1003) +GL_TEXTURE_RED_SIZE=_C('GL_TEXTURE_RED_SIZE',0x805C) +GL_TEXTURE_RED_TYPE=_C('GL_TEXTURE_RED_TYPE',0x8C10) +GL_TEXTURE_SAMPLES=_C('GL_TEXTURE_SAMPLES',0x9106) +GL_TEXTURE_SHARED_SIZE=_C('GL_TEXTURE_SHARED_SIZE',0x8C3F) +GL_TEXTURE_STENCIL_SIZE=_C('GL_TEXTURE_STENCIL_SIZE',0x88F1) +GL_TEXTURE_UPDATE_BARRIER_BIT=_C('GL_TEXTURE_UPDATE_BARRIER_BIT',0x00000100) +GL_TEXTURE_WIDTH=_C('GL_TEXTURE_WIDTH',0x1000) +GL_TOP_LEVEL_ARRAY_SIZE=_C('GL_TOP_LEVEL_ARRAY_SIZE',0x930C) +GL_TOP_LEVEL_ARRAY_STRIDE=_C('GL_TOP_LEVEL_ARRAY_STRIDE',0x930D) +GL_TRANSFORM_FEEDBACK_BARRIER_BIT=_C('GL_TRANSFORM_FEEDBACK_BARRIER_BIT',0x00000800) +GL_TRANSFORM_FEEDBACK_VARYING=_C('GL_TRANSFORM_FEEDBACK_VARYING',0x92F4) +GL_TYPE=_C('GL_TYPE',0x92FA) +GL_UNIFORM=_C('GL_UNIFORM',0x92E1) +GL_UNIFORM_BARRIER_BIT=_C('GL_UNIFORM_BARRIER_BIT',0x00000004) +GL_UNIFORM_BLOCK=_C('GL_UNIFORM_BLOCK',0x92E2) +GL_UNSIGNED_INT_ATOMIC_COUNTER=_C('GL_UNSIGNED_INT_ATOMIC_COUNTER',0x92DB) +GL_UNSIGNED_INT_IMAGE_2D=_C('GL_UNSIGNED_INT_IMAGE_2D',0x9063) +GL_UNSIGNED_INT_IMAGE_2D_ARRAY=_C('GL_UNSIGNED_INT_IMAGE_2D_ARRAY',0x9069) +GL_UNSIGNED_INT_IMAGE_3D=_C('GL_UNSIGNED_INT_IMAGE_3D',0x9064) +GL_UNSIGNED_INT_IMAGE_CUBE=_C('GL_UNSIGNED_INT_IMAGE_CUBE',0x9066) +GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE=_C('GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE',0x910A) +GL_VERTEX_ATTRIB_ARRAY_BARRIER_BIT=_C('GL_VERTEX_ATTRIB_ARRAY_BARRIER_BIT',0x00000001) +GL_VERTEX_ATTRIB_BINDING=_C('GL_VERTEX_ATTRIB_BINDING',0x82D4) +GL_VERTEX_ATTRIB_RELATIVE_OFFSET=_C('GL_VERTEX_ATTRIB_RELATIVE_OFFSET',0x82D5) +GL_VERTEX_BINDING_BUFFER=_C('GL_VERTEX_BINDING_BUFFER',0x8F4F) +GL_VERTEX_BINDING_DIVISOR=_C('GL_VERTEX_BINDING_DIVISOR',0x82D6) +GL_VERTEX_BINDING_OFFSET=_C('GL_VERTEX_BINDING_OFFSET',0x82D7) +GL_VERTEX_BINDING_STRIDE=_C('GL_VERTEX_BINDING_STRIDE',0x82D8) +GL_VERTEX_SHADER_BIT=_C('GL_VERTEX_SHADER_BIT',0x00000001) +GL_WRITE_ONLY=_C('GL_WRITE_ONLY',0x88B9) +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint) +def glActiveShaderProgram(pipeline,program):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLint,_cs.GLboolean,_cs.GLint,_cs.GLenum,_cs.GLenum) +def glBindImageTexture(unit,texture,level,layered,layer,access,format):pass +@_f +@_p.types(None,_cs.GLuint) +def glBindProgramPipeline(pipeline):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLintptr,_cs.GLsizei) +def glBindVertexBuffer(bindingindex,buffer,offset,stride):pass +@_f +@_p.types(_cs.GLuint,_cs.GLenum,_cs.GLsizei,ctypes.POINTER( ctypes.POINTER( _cs.GLchar ))) +def glCreateShaderProgramv(type,count,strings):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray) +def glDeleteProgramPipelines(n,pipelines):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint,_cs.GLuint) +def glDispatchCompute(num_groups_x,num_groups_y,num_groups_z):pass +@_f +@_p.types(None,_cs.GLintptr) +def glDispatchComputeIndirect(indirect):pass +@_f +@_p.types(None,_cs.GLenum,ctypes.c_void_p) +def glDrawArraysIndirect(mode,indirect):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,ctypes.c_void_p) +def glDrawElementsIndirect(mode,type,indirect):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,_cs.GLint) +def glFramebufferParameteri(target,pname,param):pass +@_f +@_p.types(None,_cs.GLsizei,arrays.GLuintArray) +def glGenProgramPipelines(n,pipelines):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,arrays.GLbooleanArray) +def glGetBooleani_v(target,index,data):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLenum,arrays.GLintArray) +def glGetFramebufferParameteriv(target,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLuint,arrays.GLfloatArray) +def glGetMultisamplefv(pname,index,val):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLenum,arrays.GLintArray) +def glGetProgramInterfaceiv(program,programInterface,pname,params):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLsizei,arrays.GLsizeiArray,arrays.GLcharArray) +def glGetProgramPipelineInfoLog(pipeline,bufSize,length,infoLog):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,arrays.GLintArray) +def glGetProgramPipelineiv(pipeline,pname,params):pass +@_f +@_p.types(_cs.GLuint,_cs.GLuint,_cs.GLenum,arrays.GLcharArray) +def glGetProgramResourceIndex(program,programInterface,name):pass +@_f +@_p.types(_cs.GLint,_cs.GLuint,_cs.GLenum,arrays.GLcharArray) +def glGetProgramResourceLocation(program,programInterface,name):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLuint,_cs.GLsizei,arrays.GLsizeiArray,arrays.GLcharArray) +def glGetProgramResourceName(program,programInterface,index,bufSize,length,name):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLenum,_cs.GLuint,_cs.GLsizei,arrays.GLuintArray,_cs.GLsizei,arrays.GLsizeiArray,arrays.GLintArray) +def glGetProgramResourceiv(program,programInterface,index,propCount,props,bufSize,length,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLint,_cs.GLenum,arrays.GLfloatArray) +def glGetTexLevelParameterfv(target,level,pname,params):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLint,_cs.GLenum,arrays.GLintArray) +def glGetTexLevelParameteriv(target,level,pname,params):pass +@_f +@_p.types(_cs.GLboolean,_cs.GLuint) +def glIsProgramPipeline(pipeline):pass +@_f +@_p.types(None,_cs.GLbitfield) +def glMemoryBarrier(barriers):pass +@_f +@_p.types(None,_cs.GLbitfield) +def glMemoryBarrierByRegion(barriers):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLfloat) +def glProgramUniform1f(program,location,v0):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLfloatArray) +def glProgramUniform1fv(program,location,count,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLint) +def glProgramUniform1i(program,location,v0):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLintArray) +def glProgramUniform1iv(program,location,count,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLuint) +def glProgramUniform1ui(program,location,v0):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLuintArray) +def glProgramUniform1uiv(program,location,count,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLfloat,_cs.GLfloat) +def glProgramUniform2f(program,location,v0,v1):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLfloatArray) +def glProgramUniform2fv(program,location,count,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLint,_cs.GLint) +def glProgramUniform2i(program,location,v0,v1):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLintArray) +def glProgramUniform2iv(program,location,count,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLuint,_cs.GLuint) +def glProgramUniform2ui(program,location,v0,v1):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLuintArray) +def glProgramUniform2uiv(program,location,count,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat) +def glProgramUniform3f(program,location,v0,v1,v2):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLfloatArray) +def glProgramUniform3fv(program,location,count,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint) +def glProgramUniform3i(program,location,v0,v1,v2):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLintArray) +def glProgramUniform3iv(program,location,count,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLuint,_cs.GLuint,_cs.GLuint) +def glProgramUniform3ui(program,location,v0,v1,v2):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLuintArray) +def glProgramUniform3uiv(program,location,count,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat) +def glProgramUniform4f(program,location,v0,v1,v2,v3):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLfloatArray) +def glProgramUniform4fv(program,location,count,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint) +def glProgramUniform4i(program,location,v0,v1,v2,v3):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLintArray) +def glProgramUniform4iv(program,location,count,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLuint,_cs.GLuint,_cs.GLuint,_cs.GLuint) +def glProgramUniform4ui(program,location,v0,v1,v2,v3):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,arrays.GLuintArray) +def glProgramUniform4uiv(program,location,count,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,_cs.GLboolean,arrays.GLfloatArray) +def glProgramUniformMatrix2fv(program,location,count,transpose,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,_cs.GLboolean,arrays.GLfloatArray) +def glProgramUniformMatrix2x3fv(program,location,count,transpose,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,_cs.GLboolean,arrays.GLfloatArray) +def glProgramUniformMatrix2x4fv(program,location,count,transpose,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,_cs.GLboolean,arrays.GLfloatArray) +def glProgramUniformMatrix3fv(program,location,count,transpose,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,_cs.GLboolean,arrays.GLfloatArray) +def glProgramUniformMatrix3x2fv(program,location,count,transpose,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,_cs.GLboolean,arrays.GLfloatArray) +def glProgramUniformMatrix3x4fv(program,location,count,transpose,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,_cs.GLboolean,arrays.GLfloatArray) +def glProgramUniformMatrix4fv(program,location,count,transpose,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,_cs.GLboolean,arrays.GLfloatArray) +def glProgramUniformMatrix4x2fv(program,location,count,transpose,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLsizei,_cs.GLboolean,arrays.GLfloatArray) +def glProgramUniformMatrix4x3fv(program,location,count,transpose,value):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLbitfield) +def glSampleMaski(maskNumber,mask):pass +@_f +@_p.types(None,_cs.GLenum,_cs.GLsizei,_cs.GLenum,_cs.GLsizei,_cs.GLsizei,_cs.GLboolean) +def glTexStorage2DMultisample(target,samples,internalformat,width,height,fixedsamplelocations):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLbitfield,_cs.GLuint) +def glUseProgramStages(pipeline,stages,program):pass +@_f +@_p.types(None,_cs.GLuint) +def glValidateProgramPipeline(pipeline):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint) +def glVertexAttribBinding(attribindex,bindingindex):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLenum,_cs.GLboolean,_cs.GLuint) +def glVertexAttribFormat(attribindex,size,type,normalized,relativeoffset):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLint,_cs.GLenum,_cs.GLuint) +def glVertexAttribIFormat(attribindex,size,type,relativeoffset):pass +@_f +@_p.types(None,_cs.GLuint,_cs.GLuint) +def glVertexBindingDivisor(bindingindex,divisor):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES3/VERSION/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES3/VERSION/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES3/VERSION/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES3/VERSION/__pycache__/GLES3_3_0.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES3/VERSION/__pycache__/GLES3_3_0.cpython-312.pyc new file mode 100644 index 00000000..54d5ba89 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES3/VERSION/__pycache__/GLES3_3_0.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES3/VERSION/__pycache__/GLES3_3_1.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES3/VERSION/__pycache__/GLES3_3_1.cpython-312.pyc new file mode 100644 index 00000000..bb27c823 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES3/VERSION/__pycache__/GLES3_3_1.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES3/VERSION/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES3/VERSION/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..5f8955e2 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES3/VERSION/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES3/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES3/__init__.py new file mode 100644 index 00000000..adf79a78 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES3/__init__.py @@ -0,0 +1,2 @@ +from OpenGL.raw.GLES3._types import * +from OpenGL.GLES3.VERSION.GLES3_3_0 import * diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES3/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES3/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..a4f7b5e0 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES3/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES3/__pycache__/_errors.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES3/__pycache__/_errors.cpython-312.pyc new file mode 100644 index 00000000..b87dbb23 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES3/__pycache__/_errors.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES3/__pycache__/_glgets.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES3/__pycache__/_glgets.cpython-312.pyc new file mode 100644 index 00000000..bcb6c016 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES3/__pycache__/_glgets.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES3/__pycache__/_types.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES3/__pycache__/_types.cpython-312.pyc new file mode 100644 index 00000000..daaf6e34 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES3/__pycache__/_types.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES3/_errors.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES3/_errors.py new file mode 100644 index 00000000..0a43af5b --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES3/_errors.py @@ -0,0 +1,7 @@ +from OpenGL.platform import PLATFORM as _p +from OpenGL.error import _ErrorChecker +if _ErrorChecker: + _error_checker = _ErrorChecker( _p, getattr(_p.GLES3,'glGetError',None) ) +else: + _error_checker = None + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES3/_glgets.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES3/_glgets.py new file mode 100644 index 00000000..f7bcc317 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES3/_glgets.py @@ -0,0 +1,2290 @@ +"""glGet* auto-generation of output arrays (DO NOT EDIT, AUTOGENERATED)""" +try: + from OpenGL.raw.GL._lookupint import LookupInt as _L +except ImportError: + def _L(*args): + raise RuntimeError( "Need to define a lookupint for this api" ) +_glget_size_mapping = _m = {} +# _m[0x8892] = TODO # GL_ARRAY_BUFFER +# _m[0x92C0] = TODO # GL_ATOMIC_COUNTER_BUFFER +# _m[0x8777] = TODO # GL_BUMP_NUM_TEX_UNITS_ATI +# _m[0x8775] = TODO # GL_BUMP_ROT_MATRIX_ATI +# _m[0x8776] = TODO # GL_BUMP_ROT_MATRIX_SIZE_ATI +# _m[0x8778] = TODO # GL_BUMP_TEX_UNITS_ATI +# _m[0x0A00] = TODO # GL_COEFF +# _m[0x8576] = TODO # GL_CONSTANT +# _m[0x8095] = TODO # GL_DETAIL_TEXTURE_2D_SGIS +# _m[0x809C] = TODO # GL_DETAIL_TEXTURE_FUNC_POINTS_SGIS +# _m[0x809A] = TODO # GL_DETAIL_TEXTURE_LEVEL_SGIS +# _m[0x809B] = TODO # GL_DETAIL_TEXTURE_MODE_SGIS +# _m[0x9599] = TODO # GL_DEVICE_LUID_EXT +# _m[0x959A] = TODO # GL_DEVICE_NODE_MASK_EXT +# _m[0x9597] = TODO # GL_DEVICE_UUID_EXT +# _m[0x90EE] = TODO # GL_DISPATCH_INDIRECT_BUFFER +# _m[0x0A02] = TODO # GL_DOMAIN +# _m[0x8F3F] = TODO # GL_DRAW_INDIRECT_BUFFER +# _m[0x9598] = TODO # GL_DRIVER_UUID_EXT +# _m[0x8124] = TODO # GL_DUAL_TEXTURE_SELECT_SGIS +# _m[0x8893] = TODO # GL_ELEMENT_ARRAY_BUFFER +# _m[0x86C0] = TODO # GL_EVAL_2D_NV +# _m[0x86C1] = TODO # GL_EVAL_TRIANGULAR_2D_NV +# _m[0x2400] = TODO # GL_EYE_LINEAR +# _m[0x8210] = TODO # GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING_EXT +# _m[0x8211] = TODO # GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE_EXT +# _m[0x8DA7] = TODO # GL_FRAMEBUFFER_ATTACHMENT_LAYERED_ARB +# _m[0x8DA7] = TODO # GL_FRAMEBUFFER_ATTACHMENT_LAYERED_EXT +# _m[0x8DA7] = TODO # GL_FRAMEBUFFER_ATTACHMENT_LAYERED_OES +# _m[0x8CD1] = TODO # GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT +# _m[0x8CD1] = TODO # GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_OES +# _m[0x8CD0] = TODO # GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_EXT +# _m[0x8CD0] = TODO # GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_OES +# _m[0x8CD4] = TODO # GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_EXT +# _m[0x8CD4] = TODO # GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_OES +# _m[0x8CD3] = TODO # GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_EXT +# _m[0x8CD3] = TODO # GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_OES +# _m[0x8CD4] = TODO # GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER_EXT +# _m[0x8CD2] = TODO # GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_EXT +# _m[0x8CD2] = TODO # GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_OES +# _m[0x8191] = TODO # GL_GENERATE_MIPMAP_SGIS +# _m[0x8917] = TODO # GL_GEOMETRY_INPUT_TYPE +# _m[0x8918] = TODO # GL_GEOMETRY_OUTPUT_TYPE +# _m[0x8916] = TODO # GL_GEOMETRY_VERTICES_OUT +# _m[0x815E] = TODO # GL_IMAGE_CUBIC_WEIGHT_HP +# _m[0x815C] = TODO # GL_IMAGE_MAG_FILTER_HP +# _m[0x815D] = TODO # GL_IMAGE_MIN_FILTER_HP +# _m[0x8159] = TODO # GL_IMAGE_ROTATE_ANGLE_HP +# _m[0x815A] = TODO # GL_IMAGE_ROTATE_ORIGIN_X_HP +# _m[0x815B] = TODO # GL_IMAGE_ROTATE_ORIGIN_Y_HP +# _m[0x8155] = TODO # GL_IMAGE_SCALE_X_HP +# _m[0x8156] = TODO # GL_IMAGE_SCALE_Y_HP +# _m[0x8157] = TODO # GL_IMAGE_TRANSLATE_X_HP +# _m[0x8158] = TODO # GL_IMAGE_TRANSLATE_Y_HP +# _m[0x8182] = TODO # GL_LIST_PRIORITY_SGIX +# _m[0] = TODO # GL_NONE +# _m[0x9596] = TODO # GL_NUM_DEVICE_UUIDS_EXT +# _m[0x2401] = TODO # GL_OBJECT_LINEAR +# _m[0x0A01] = TODO # GL_ORDER +# _m[0x85A0] = TODO # GL_PACK_SUBSAMPLE_RATE_SGIX +# _m[0x80EE] = TODO # GL_PARAMETER_BUFFER +# _m[0x908A] = TODO # GL_PATH_OBJECT_BOUNDING_BOX_NV +# _m[0x88EB] = TODO # GL_PIXEL_PACK_BUFFER +# _m[0x88EC] = TODO # GL_PIXEL_UNPACK_BUFFER +# _m[0x8063] = TODO # GL_PROXY_TEXTURE_1D +# _m[0x8C19] = TODO # GL_PROXY_TEXTURE_1D_ARRAY +# _m[0x8C19] = TODO # GL_PROXY_TEXTURE_1D_ARRAY_EXT +# _m[0x8063] = TODO # GL_PROXY_TEXTURE_1D_EXT +# _m[0x8064] = TODO # GL_PROXY_TEXTURE_2D +# _m[0x8C1B] = TODO # GL_PROXY_TEXTURE_2D_ARRAY +# _m[0x8C1B] = TODO # GL_PROXY_TEXTURE_2D_ARRAY_EXT +# _m[0x8064] = TODO # GL_PROXY_TEXTURE_2D_EXT +# _m[0x9101] = TODO # GL_PROXY_TEXTURE_2D_MULTISAMPLE +# _m[0x9103] = TODO # GL_PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY +# _m[0x8070] = TODO # GL_PROXY_TEXTURE_3D +# _m[0x8070] = TODO # GL_PROXY_TEXTURE_3D_EXT +# _m[0x8135] = TODO # GL_PROXY_TEXTURE_4D_SGIS +# _m[0x851B] = TODO # GL_PROXY_TEXTURE_CUBE_MAP +# _m[0x851B] = TODO # GL_PROXY_TEXTURE_CUBE_MAP_ARB +# _m[0x900B] = TODO # GL_PROXY_TEXTURE_CUBE_MAP_ARRAY +# _m[0x900B] = TODO # GL_PROXY_TEXTURE_CUBE_MAP_ARRAY_ARB +# _m[0x851B] = TODO # GL_PROXY_TEXTURE_CUBE_MAP_EXT +# _m[0x84F7] = TODO # GL_PROXY_TEXTURE_RECTANGLE +# _m[0x84F7] = TODO # GL_PROXY_TEXTURE_RECTANGLE_ARB +# _m[0x84F7] = TODO # GL_PROXY_TEXTURE_RECTANGLE_NV +# _m[0x8125] = TODO # GL_QUAD_TEXTURE_SELECT_SGIS +# _m[0x9192] = TODO # GL_QUERY_BUFFER +# _m[0x8D53] = TODO # GL_RENDERBUFFER_ALPHA_SIZE_EXT +# _m[0x8D53] = TODO # GL_RENDERBUFFER_ALPHA_SIZE_OES +# _m[0x8D52] = TODO # GL_RENDERBUFFER_BLUE_SIZE_EXT +# _m[0x8D52] = TODO # GL_RENDERBUFFER_BLUE_SIZE_OES +# _m[0x8D54] = TODO # GL_RENDERBUFFER_DEPTH_SIZE_EXT +# _m[0x8D54] = TODO # GL_RENDERBUFFER_DEPTH_SIZE_OES +# _m[0x8D51] = TODO # GL_RENDERBUFFER_GREEN_SIZE_EXT +# _m[0x8D51] = TODO # GL_RENDERBUFFER_GREEN_SIZE_OES +# _m[0x8D43] = TODO # GL_RENDERBUFFER_HEIGHT_EXT +# _m[0x8D43] = TODO # GL_RENDERBUFFER_HEIGHT_OES +# _m[0x8D44] = TODO # GL_RENDERBUFFER_INTERNAL_FORMAT_EXT +# _m[0x8D44] = TODO # GL_RENDERBUFFER_INTERNAL_FORMAT_OES +# _m[0x8D50] = TODO # GL_RENDERBUFFER_RED_SIZE_EXT +# _m[0x8D50] = TODO # GL_RENDERBUFFER_RED_SIZE_OES +# _m[0x8CAB] = TODO # GL_RENDERBUFFER_SAMPLES_ANGLE +# _m[0x8CAB] = TODO # GL_RENDERBUFFER_SAMPLES_APPLE +# _m[0x8CAB] = TODO # GL_RENDERBUFFER_SAMPLES_EXT +# _m[0x8CAB] = TODO # GL_RENDERBUFFER_SAMPLES_NV +# _m[0x8D55] = TODO # GL_RENDERBUFFER_STENCIL_SIZE_EXT +# _m[0x8D55] = TODO # GL_RENDERBUFFER_STENCIL_SIZE_OES +# _m[0x8D42] = TODO # GL_RENDERBUFFER_WIDTH_EXT +# _m[0x8D42] = TODO # GL_RENDERBUFFER_WIDTH_OES +# _m[0x80BF] = TODO # GL_SHADOW_AMBIENT_SGIX +# _m[0x81FB] = TODO # GL_SHARED_TEXTURE_PALETTE_EXT +# _m[0x80B0] = TODO # GL_SHARPEN_TEXTURE_FUNC_POINTS_SGIS +# _m[0x9100] = TODO # GL_TEXTURE_2D_MULTISAMPLE +# _m[0x9102] = TODO # GL_TEXTURE_2D_MULTISAMPLE_ARRAY +# _m[0x8136] = TODO # GL_TEXTURE_4DSIZE_SGIS +# _m[0x8175] = TODO # GL_TEXTURE_CLIPMAP_LOD_OFFSET_SGIX +# _m[0x1003] = TODO # GL_TEXTURE_COMPONENTS +# _m[0x9009] = TODO # GL_TEXTURE_CUBE_MAP_ARRAY_ARB +# _m[0x9009] = TODO # GL_TEXTURE_CUBE_MAP_ARRAY_EXT +# _m[0x9009] = TODO # GL_TEXTURE_CUBE_MAP_ARRAY_OES +# _m[0x8516] = TODO # GL_TEXTURE_CUBE_MAP_NEGATIVE_X +# _m[0x8518] = TODO # GL_TEXTURE_CUBE_MAP_NEGATIVE_Y +# _m[0x851A] = TODO # GL_TEXTURE_CUBE_MAP_NEGATIVE_Z +# _m[0x8515] = TODO # GL_TEXTURE_CUBE_MAP_POSITIVE_X +# _m[0x8517] = TODO # GL_TEXTURE_CUBE_MAP_POSITIVE_Y +# _m[0x8519] = TODO # GL_TEXTURE_CUBE_MAP_POSITIVE_Z +# _m[0x8147] = TODO # GL_TEXTURE_FILTER4_SIZE_SGIS +# _m[0x819D] = TODO # GL_TEXTURE_GEQUAL_R_SGIX +# _m[0x819C] = TODO # GL_TEXTURE_LEQUAL_R_SGIX +# _m[0x84FE] = TODO # GL_TEXTURE_MAX_ANISOTROPY +# _m[0x8C8E] = TODO # GL_TRANSFORM_FEEDBACK_BUFFER +# _m[0x8A11] = TODO # GL_UNIFORM_BUFFER +# _m[0x85A1] = TODO # GL_UNPACK_SUBSAMPLE_RATE_SGIX +_m[0x0D5B] = (1,) # GL_ACCUM_ALPHA_BITS +_m[0x0D5A] = (1,) # GL_ACCUM_BLUE_BITS +_m[0x0B80] = (4,) # GL_ACCUM_CLEAR_VALUE +_m[0x0D59] = (1,) # GL_ACCUM_GREEN_BITS +_m[0x0D58] = (1,) # GL_ACCUM_RED_BITS +_m[0x92D9] = (1,) # GL_ACTIVE_ATOMIC_COUNTER_BUFFERS +_m[0x8B89] = (1,) # GL_ACTIVE_ATTRIBUTES +_m[0x8B8A] = (1,) # GL_ACTIVE_ATTRIBUTE_MAX_LENGTH +_m[0x8259] = (1,) # GL_ACTIVE_PROGRAM +_m[0x92F5] = (1,) # GL_ACTIVE_RESOURCES +_m[0x8911] = (1,) # GL_ACTIVE_STENCIL_FACE_EXT +_m[0x8DE5] = (1,) # GL_ACTIVE_SUBROUTINES +_m[0x8E48] = (1,) # GL_ACTIVE_SUBROUTINE_MAX_LENGTH +_m[0x8DE6] = (1,) # GL_ACTIVE_SUBROUTINE_UNIFORMS +_m[0x8E47] = (1,) # GL_ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS +_m[0x8E49] = (1,) # GL_ACTIVE_SUBROUTINE_UNIFORM_MAX_LENGTH +_m[0x84E0] = (1,) # GL_ACTIVE_TEXTURE +_m[0x84E0] = (1,) # GL_ACTIVE_TEXTURE_ARB +_m[0x8B86] = (1,) # GL_ACTIVE_UNIFORMS +_m[0x8A36] = (1,) # GL_ACTIVE_UNIFORM_BLOCKS +_m[0x8A35] = (1,) # GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH +_m[0x8B87] = (1,) # GL_ACTIVE_UNIFORM_MAX_LENGTH +_m[0x9305] = (1,) # GL_ACTIVE_VARIABLES +_m[0x86A5] = (1,) # GL_ACTIVE_VERTEX_UNITS_ARB +_m[0x846E] = (2,) # GL_ALIASED_LINE_WIDTH_RANGE +_m[0x846D] = (2,) # GL_ALIASED_POINT_SIZE_RANGE +_m[0x0D1D] = (1,) # GL_ALPHA_BIAS +_m[0x0D55] = (1,) # GL_ALPHA_BITS +_m[0x8567] = (1,) # GL_ALPHA_MAX_CLAMP_INGR +_m[0x8563] = (1,) # GL_ALPHA_MIN_CLAMP_INGR +_m[0x0D1C] = (1,) # GL_ALPHA_SCALE +_m[0x0BC0] = (1,) # GL_ALPHA_TEST +_m[0x0BC1] = (1,) # GL_ALPHA_TEST_FUNC +_m[0x0BC1] = (1,) # GL_ALPHA_TEST_FUNC_QCOM +_m[0x0BC0] = (1,) # GL_ALPHA_TEST_QCOM +_m[0x0BC2] = (1,) # GL_ALPHA_TEST_REF +_m[0x0BC2] = (1,) # GL_ALPHA_TEST_REF_QCOM +_m[0x92BF] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_alpha_to_coverage_dither_control.txt # GL_ALPHA_TO_COVERAGE_DITHER_MODE_NV +_m[0x1200] = (4,) # GL_AMBIENT +_m[0x1602] = (4,) # GL_AMBIENT_AND_DIFFUSE +_m[0x8C2F] = (1,) # GL_ANY_SAMPLES_PASSED +_m[0x8D6A] = (1,) # GL_ANY_SAMPLES_PASSED_CONSERVATIVE +_m[0x8894] = (1,) # GL_ARRAY_BUFFER_BINDING +_m[0x8894] = (1,) # GL_ARRAY_BUFFER_BINDING_ARB +_m[0x81A9] = (1,) # GL_ARRAY_ELEMENT_LOCK_COUNT_EXT +_m[0x81A8] = (1,) # GL_ARRAY_ELEMENT_LOCK_FIRST_EXT +_m[0x8766] = (1,) # GL_ARRAY_OBJECT_BUFFER_ATI +_m[0x8767] = (1,) # GL_ARRAY_OBJECT_OFFSET_ATI +_m[0x92FB] = (1,) # GL_ARRAY_SIZE +_m[0x92FE] = (1,) # GL_ARRAY_STRIDE +_m[0x835D] = (1,) # GL_ASYNC_DRAW_PIXELS_SGIX +_m[0x832C] = (1,) # GL_ASYNC_HISTOGRAM_SGIX +_m[0x8329] = (1,) # GL_ASYNC_MARKER_SGIX +_m[0x835E] = (1,) # GL_ASYNC_READ_PIXELS_SGIX +_m[0x835C] = (1,) # GL_ASYNC_TEX_IMAGE_SGIX +_m[0x92C5] = (1,) # GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTERS +_m[0x92C6] = (1,)#TODO Is actually GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTERS # GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTER_INDICES +_m[0x92C1] = (1,) # GL_ATOMIC_COUNTER_BUFFER_BINDING +_m[0x92C4] = (1,)#TODO Is actually GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTERS # GL_ATOMIC_COUNTER_BUFFER_DATA_SIZE +_m[0x9301] = (1,) # GL_ATOMIC_COUNTER_BUFFER_INDEX +_m[0x90ED] = (1,)#TODO Is actually GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTERS # GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_COMPUTE_SHADER +_m[0x92CB] = (1,)#TODO Is actually GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTERS # GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_FRAGMENT_SHADER +_m[0x92CA] = (1,)#TODO Is actually GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTERS # GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_GEOMETRY_SHADER +_m[0x959E] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_MESH_SHADER_NV +_m[0x959F] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TASK_SHADER_NV +_m[0x92C8] = (1,)#TODO Is actually GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTERS # GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_CONTROL_SHADER +_m[0x92C9] = (1,)#TODO Is actually GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTERS # GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_EVALUATION_SHADER +_m[0x92C7] = (1,)#TODO Is actually GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTERS # GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_VERTEX_SHADER +_m[0x92C3] = (1,)#TODO Is actually GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTERS # GL_ATOMIC_COUNTER_BUFFER_SIZE +_m[0x92C2] = (1,)#TODO Is actually GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTERS # GL_ATOMIC_COUNTER_BUFFER_START +_m[0x8B85] = (1,) # GL_ATTACHED_SHADERS +_m[0x8645] = (1,) # GL_ATTRIB_ARRAY_POINTER_NV +_m[0x8623] = (1,) # GL_ATTRIB_ARRAY_SIZE_NV +_m[0x8624] = (1,) # GL_ATTRIB_ARRAY_STRIDE_NV +_m[0x8625] = (1,) # GL_ATTRIB_ARRAY_TYPE_NV +_m[0x0BB0] = (1,) # GL_ATTRIB_STACK_DEPTH +_m[0x8295] = (1,) # GL_AUTO_GENERATE_MIPMAP +_m[0x0D80] = (1,) # GL_AUTO_NORMAL +_m[0x0C00] = (1,) # GL_AUX_BUFFERS +_m[0x843A] = (1,) # GL_BINORMAL_ARRAY_EXT +_m[0x8443] = (1,) # GL_BINORMAL_ARRAY_POINTER_EXT +_m[0x8441] = (1,) # GL_BINORMAL_ARRAY_STRIDE_EXT +_m[0x8440] = (1,) # GL_BINORMAL_ARRAY_TYPE_EXT +_m[0x0BE2] = (1,) # GL_BLEND +_m[0x9285] = (1,) # GL_BLEND_ADVANCED_COHERENT_KHR +_m[0x9285] = (1,) # GL_BLEND_ADVANCED_COHERENT_NV +_m[0x8005] = (4,) # GL_BLEND_COLOR +_m[0x8005] = (4,) # GL_BLEND_COLOR_EXT +_m[0x0BE0] = (1,) # GL_BLEND_DST +_m[0x80CA] = (1,) # GL_BLEND_DST_ALPHA +_m[0x80CA] = (1,) # GL_BLEND_DST_ALPHA_EXT +_m[0x80C8] = (1,) # GL_BLEND_DST_RGB +_m[0x80C8] = (1,) # GL_BLEND_DST_RGB_EXT +_m[0x8009] = (1,) # GL_BLEND_EQUATION +_m[0x883D] = (1,) # GL_BLEND_EQUATION_ALPHA +_m[0x883D] = (1,) # GL_BLEND_EQUATION_ALPHA_EXT +_m[0x8009] = (1,) # GL_BLEND_EQUATION_EXT +_m[0x8009] = (1,) # GL_BLEND_EQUATION_RGB +_m[0x9281] = (3,) # GL_BLEND_OVERLAP_NV +_m[0x9280] = (1,) # GL_BLEND_PREMULTIPLIED_SRC_NV +_m[0x0BE1] = (1,) # GL_BLEND_SRC +_m[0x80CB] = (1,) # GL_BLEND_SRC_ALPHA +_m[0x80CB] = (1,) # GL_BLEND_SRC_ALPHA_EXT +_m[0x80C9] = (1,) # GL_BLEND_SRC_RGB +_m[0x80C9] = (1,) # GL_BLEND_SRC_RGB_EXT +_m[0x92FD] = (1,) # GL_BLOCK_INDEX +_m[0x0D1B] = (1,) # GL_BLUE_BIAS +_m[0x0D54] = (1,) # GL_BLUE_BITS +_m[0x8566] = (1,) # GL_BLUE_MAX_CLAMP_INGR +_m[0x8562] = (1,) # GL_BLUE_MIN_CLAMP_INGR +_m[0x0D1A] = (1,) # GL_BLUE_SCALE +_m[0x88BB] = (1,) # GL_BUFFER_ACCESS +_m[0x88BB] = (1,) # GL_BUFFER_ACCESS_ARB +_m[0x911F] = (1,) # GL_BUFFER_ACCESS_FLAGS +_m[0x9302] = (1,) # GL_BUFFER_BINDING +_m[0x9303] = (1,) # GL_BUFFER_DATA_SIZE +_m[0x8F1D] = (1,) # GL_BUFFER_GPU_ADDRESS_NV +_m[0x821F] = (1,) # GL_BUFFER_IMMUTABLE_STORAGE +_m[0x88BC] = (1,) # GL_BUFFER_MAPPED +_m[0x88BC] = (1,) # GL_BUFFER_MAPPED_ARB +_m[0x9120] = (1,) # GL_BUFFER_MAP_LENGTH +_m[0x9121] = (1,) # GL_BUFFER_MAP_OFFSET +_m[0x88BD] = (1,) # GL_BUFFER_MAP_POINTER +_m[0x88BD] = (1,) # GL_BUFFER_MAP_POINTER_ARB +_m[0x8764] = (1,) # GL_BUFFER_SIZE +_m[0x8764] = (1,) # GL_BUFFER_SIZE_ARB +_m[0x8220] = (1,) # GL_BUFFER_STORAGE_FLAGS +_m[0x8765] = (1,) # GL_BUFFER_USAGE +_m[0x8765] = (1,) # GL_BUFFER_USAGE_ARB +_m[0x877C] = (1,) # GL_BUMP_TARGET_ATI +_m[0x8183] = (1,) # GL_CALLIGRAPHIC_FRAGMENT_SGIX +_m[0x891B] = (1,) # GL_CLAMP_FRAGMENT_COLOR +_m[0x891B] = (1,) # GL_CLAMP_FRAGMENT_COLOR_ARB +_m[0x891C] = (1,) # GL_CLAMP_READ_COLOR +_m[0x891C] = (1,) # GL_CLAMP_READ_COLOR_ARB +_m[0x891A] = (1,) # GL_CLAMP_VERTEX_COLOR +_m[0x891A] = (1,) # GL_CLAMP_VERTEX_COLOR_ARB +_m[0x82B4] = (1,) # GL_CLEAR_BUFFER +_m[0x84E1] = (1,) # GL_CLIENT_ACTIVE_TEXTURE +_m[0x84E1] = (1,) # GL_CLIENT_ACTIVE_TEXTURE_ARB +_m[0x0BB1] = (1,) # GL_CLIENT_ATTRIB_STACK_DEPTH +_m[0x935D] = (2,) # GL_CLIP_DEPTH_MODE +_m[0x3000] = (1,) # GL_CLIP_DISTANCE0 +_m[0x3001] = (1,) # GL_CLIP_DISTANCE1 +_m[0x3002] = (1,) # GL_CLIP_DISTANCE2 +_m[0x3003] = (1,) # GL_CLIP_DISTANCE3 +_m[0x3004] = (1,) # GL_CLIP_DISTANCE4 +_m[0x3005] = (1,) # GL_CLIP_DISTANCE5 +_m[0x3006] = (1,) # GL_CLIP_DISTANCE6 +_m[0x3007] = (1,) # GL_CLIP_DISTANCE7 +_m[0x935C] = (2,) # GL_CLIP_ORIGIN +_m[0x3000] = (1,) # GL_CLIP_PLANE0 +_m[0x3001] = (1,) # GL_CLIP_PLANE1 +_m[0x3002] = (1,) # GL_CLIP_PLANE2 +_m[0x3003] = (1,) # GL_CLIP_PLANE3 +_m[0x3004] = (1,) # GL_CLIP_PLANE4 +_m[0x3005] = (1,) # GL_CLIP_PLANE5 +_m[0x80F0] = (1,) # GL_CLIP_VOLUME_CLIPPING_HINT_EXT +_m[0x8975] = (1,) # GL_COLOR_ALPHA_PAIRING_ATI +_m[0x8076] = (1,) # GL_COLOR_ARRAY +_m[0x8898] = (1,) # GL_COLOR_ARRAY_BUFFER_BINDING +_m[0x8898] = (1,) # GL_COLOR_ARRAY_BUFFER_BINDING_ARB +_m[0x8084] = (1,) # GL_COLOR_ARRAY_COUNT_EXT +_m[0x8076] = (1,) # GL_COLOR_ARRAY_EXT +_m[0x8F2D] = (1,) # GL_COLOR_ARRAY_LENGTH_NV +_m[0x83F7] = (1,) # GL_COLOR_ARRAY_PARALLEL_POINTERS_INTEL +_m[0x8090] = (1,) # GL_COLOR_ARRAY_POINTER +_m[0x8081] = (1,) # GL_COLOR_ARRAY_SIZE +_m[0x8081] = (1,) # GL_COLOR_ARRAY_SIZE_EXT +_m[0x8083] = (1,) # GL_COLOR_ARRAY_STRIDE +_m[0x8083] = (1,) # GL_COLOR_ARRAY_STRIDE_EXT +_m[0x8082] = (1,) # GL_COLOR_ARRAY_TYPE +_m[0x8082] = (1,) # GL_COLOR_ARRAY_TYPE_EXT +_m[0x8835] = (4,) # GL_COLOR_CLEAR_UNCLAMPED_VALUE_ATI +_m[0x0C22] = (4,) # GL_COLOR_CLEAR_VALUE +_m[0x8283] = (1,) # GL_COLOR_COMPONENTS +_m[0x8296] = (1,) # GL_COLOR_ENCODING +_m[0x8A0F] = (1,) # GL_COLOR_FLOAT_APPLE +_m[0x1603] = (3,) # GL_COLOR_INDEXES +_m[0x0BF2] = (1,) # GL_COLOR_LOGIC_OP +_m[0x0B57] = (1,) # GL_COLOR_MATERIAL +_m[0x0B55] = (1,) # GL_COLOR_MATERIAL_FACE +_m[0x0B56] = (1,) # GL_COLOR_MATERIAL_PARAMETER +_m[0x80B1] = (4,4) # GL_COLOR_MATRIX +_m[0x80B1] = (4,4) # GL_COLOR_MATRIX_SGI +_m[0x80B2] = (1,) # GL_COLOR_MATRIX_STACK_DEPTH +_m[0x80B2] = (1,) # GL_COLOR_MATRIX_STACK_DEPTH_SGI +_m[0x8286] = (1,) # GL_COLOR_RENDERABLE +_m[0x8E20] = (1,) # GL_COLOR_SAMPLES_NV +_m[0x8458] = (1,) # GL_COLOR_SUM +_m[0x8458] = (1,) # GL_COLOR_SUM_ARB +_m[0x854F] = (1,) # GL_COLOR_SUM_CLAMP_NV +_m[0x8458] = (1,) # GL_COLOR_SUM_EXT +_m[0x80D0] = (1,) # GL_COLOR_TABLE +_m[0x80DD] = (1,) # GL_COLOR_TABLE_ALPHA_SIZE +_m[0x80DD] = (1,) # GL_COLOR_TABLE_ALPHA_SIZE_SGI +_m[0x80D7] = (4,) # GL_COLOR_TABLE_BIAS +_m[0x80D7] = (4,) # GL_COLOR_TABLE_BIAS_SGI +_m[0x80DC] = (1,) # GL_COLOR_TABLE_BLUE_SIZE +_m[0x80DC] = (1,) # GL_COLOR_TABLE_BLUE_SIZE_SGI +_m[0x80D8] = (1,) # GL_COLOR_TABLE_FORMAT +_m[0x80D8] = (1,) # GL_COLOR_TABLE_FORMAT_SGI +_m[0x80DB] = (1,) # GL_COLOR_TABLE_GREEN_SIZE +_m[0x80DB] = (1,) # GL_COLOR_TABLE_GREEN_SIZE_SGI +_m[0x80DF] = (1,) # GL_COLOR_TABLE_INTENSITY_SIZE +_m[0x80DF] = (1,) # GL_COLOR_TABLE_INTENSITY_SIZE_SGI +_m[0x80DE] = (1,) # GL_COLOR_TABLE_LUMINANCE_SIZE +_m[0x80DE] = (1,) # GL_COLOR_TABLE_LUMINANCE_SIZE_SGI +_m[0x80DA] = (1,) # GL_COLOR_TABLE_RED_SIZE +_m[0x80DA] = (1,) # GL_COLOR_TABLE_RED_SIZE_SGI +_m[0x80D6] = (4,) # GL_COLOR_TABLE_SCALE +_m[0x80D6] = (4,) # GL_COLOR_TABLE_SCALE_SGI +_m[0x80D0] = (1,) # GL_COLOR_TABLE_SGI +_m[0x80D9] = (1,) # GL_COLOR_TABLE_WIDTH +_m[0x80D9] = (1,) # GL_COLOR_TABLE_WIDTH_SGI +_m[0x0C23] = (4,) # GL_COLOR_WRITEMASK +_m[0x8545] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/register_combiners.txt # GL_COMBINER_AB_DOT_PRODUCT_NV +_m[0x854A] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/register_combiners.txt # GL_COMBINER_AB_OUTPUT_NV +_m[0x8549] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/register_combiners.txt # GL_COMBINER_BIAS_NV +_m[0x8546] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/register_combiners.txt # GL_COMBINER_CD_DOT_PRODUCT_NV +_m[0x854B] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/register_combiners.txt # GL_COMBINER_CD_OUTPUT_NV +_m[0x8544] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/register_combiners.txt # GL_COMBINER_COMPONENT_USAGE_NV +_m[0x8542] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/register_combiners.txt # GL_COMBINER_INPUT_NV +_m[0x8543] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/register_combiners.txt # GL_COMBINER_MAPPING_NV +_m[0x8547] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/register_combiners.txt # GL_COMBINER_MUX_SUM_NV +_m[0x8548] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/register_combiners.txt # GL_COMBINER_SCALE_NV +_m[0x854C] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/register_combiners.txt # GL_COMBINER_SUM_OUTPUT_NV +_m[0x8572] = (1,) # GL_COMBINE_ALPHA +_m[0x8571] = (1,) # GL_COMBINE_RGB +_m[0x8E4B] = (1,) # GL_COMPATIBLE_SUBROUTINES +_m[0x8B81] = (1,) # GL_COMPILE_STATUS +_m[0x86A3] = (_L(0x86A2),) # GL_COMPRESSED_TEXTURE_FORMATS +_m[0x86A3] = (_L(0x86A2),) # GL_COMPRESSED_TEXTURE_FORMATS_ARB +_m[0x90FB] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/compute_program5.txt # GL_COMPUTE_PROGRAM_NV +_m[0x91B9] = (1,) # GL_COMPUTE_SHADER +_m[0x82A0] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_COMPUTE_TEXTURE +_m[0x8267] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/compute_shader.txt # GL_COMPUTE_WORK_GROUP_SIZE +_m[0x9374] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_internalformat_sample_query.txt # GL_CONFORMANT_NV +_m[0x937B] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_conservative_raster_dilate.txt # GL_CONSERVATIVE_RASTER_DILATE_GRANULARITY_NV +_m[0x9379] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_conservative_raster_dilate.txt # GL_CONSERVATIVE_RASTER_DILATE_NV +_m[0x937A] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_conservative_raster_dilate.txt # GL_CONSERVATIVE_RASTER_DILATE_RANGE_NV +_m[0x954D] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_conservative_raster_pre_snap_triangles.txt # GL_CONSERVATIVE_RASTER_MODE_NV +_m[0x1207] = (1,) # GL_CONSTANT_ATTENUATION +_m[0x852A] = (4,) # GL_CONSTANT_COLOR0_NV +_m[0x852B] = (4,) # GL_CONSTANT_COLOR1_NV +_m[0x86E5] = (3,) # GL_CONST_EYE_NV +_m[0x821E] = (1,) # GL_CONTEXT_FLAGS +_m[0x00000002] = (1,) # GL_CONTEXT_FLAG_DEBUG_BIT +_m[0x00000004] = (1,) # GL_CONTEXT_FLAG_ROBUST_ACCESS_BIT_ARB +_m[0x9126] = (1,) # GL_CONTEXT_PROFILE_MASK +_m[0x90F3] = (1,)#TODO Review http://www.opengl.org/registry/specs//KHR/robustness.txt # GL_CONTEXT_ROBUST_ACCESS +_m[0x8010] = (1,) # GL_CONVOLUTION_1D +_m[0x8010] = (1,) # GL_CONVOLUTION_1D_EXT +_m[0x8011] = (1,) # GL_CONVOLUTION_2D +_m[0x8011] = (1,) # GL_CONVOLUTION_2D_EXT +_m[0x8154] = (4,) # GL_CONVOLUTION_BORDER_COLOR +_m[0x8013] = (1,) # GL_CONVOLUTION_BORDER_MODE +_m[0x8013] = (1,) # GL_CONVOLUTION_BORDER_MODE_EXT +_m[0x8015] = (4,) # GL_CONVOLUTION_FILTER_BIAS +_m[0x8015] = (4,) # GL_CONVOLUTION_FILTER_BIAS_EXT +_m[0x8014] = (4,) # GL_CONVOLUTION_FILTER_SCALE +_m[0x8014] = (4,) # GL_CONVOLUTION_FILTER_SCALE_EXT +_m[0x8017] = (1,) # GL_CONVOLUTION_FORMAT +_m[0x8019] = (1,) # GL_CONVOLUTION_HEIGHT +_m[0x8316] = (1,) # GL_CONVOLUTION_HINT_SGIX +_m[0x8018] = (1,) # GL_CONVOLUTION_WIDTH +_m[0x8862] = (1,) # GL_COORD_REPLACE +_m[0x8F36] = (1,) # GL_COPY_READ_BUFFER +_m[0x8F37] = (1,) # GL_COPY_WRITE_BUFFER +_m[0x9332] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_framebuffer_mixed_samples.txt # GL_COVERAGE_MODULATION_NV +_m[0x9333] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_framebuffer_mixed_samples.txt # GL_COVERAGE_MODULATION_TABLE_SIZE_NV +_m[0x8ED4] = (1,) # GL_COVERAGE_SAMPLES_NV +_m[0x0B44] = (1,) # GL_CULL_FACE +_m[0x0B45] = (1,) # GL_CULL_FACE_MODE +_m[0x86E0] = (4,) # GL_CULL_MODES_NV +_m[0x81AA] = (1,) # GL_CULL_VERTEX_EXT +_m[0x81AB] = (1,) # GL_CULL_VERTEX_EYE_POSITION_EXT +_m[103050] = (1,)#TODO Review http://www.opengl.org/registry/specs//IBM/cull_vertex.txt # GL_CULL_VERTEX_IBM +_m[0x81AC] = (1,) # GL_CULL_VERTEX_OBJECT_POSITION_EXT +_m[0x8626] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/vertex_program.txt # GL_CURRENT_ATTRIB_NV +_m[0x843C] = (1,) # GL_CURRENT_BINORMAL_EXT +_m[0x0B00] = (4,) # GL_CURRENT_COLOR +_m[0x8453] = (1,) # GL_CURRENT_FOG_COORD +_m[0x8453] = (1,) # GL_CURRENT_FOG_COORDINATE +_m[0x8453] = (1,) # GL_CURRENT_FOG_COORDINATE_EXT +_m[0x0B01] = (1,) # GL_CURRENT_INDEX +_m[0x8641] = (4, 4) # GL_CURRENT_MATRIX_ARB +_m[0x8845] = (1,) # GL_CURRENT_MATRIX_INDEX_ARB +_m[0x8641] = (4, 4) # GL_CURRENT_MATRIX_NV +_m[0x8640] = (1,) # GL_CURRENT_MATRIX_STACK_DEPTH_ARB +_m[0x8640] = (1,) # GL_CURRENT_MATRIX_STACK_DEPTH_NV +_m[0x0B02] = (3,) # GL_CURRENT_NORMAL +_m[0x8865] = (1,) # GL_CURRENT_OCCLUSION_QUERY_ID_NV +_m[0x8843] = (1,) # GL_CURRENT_PALETTE_MATRIX_ARB +_m[0x8843] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/OES/OES_matrix_palette.txt # GL_CURRENT_PALETTE_MATRIX_OES +_m[0x8B8D] = (1,) # GL_CURRENT_PROGRAM +_m[0x8865] = (1,) # GL_CURRENT_QUERY +_m[0x0B04] = (4,) # GL_CURRENT_RASTER_COLOR +_m[0x0B09] = (1,) # GL_CURRENT_RASTER_DISTANCE +_m[0x0B05] = (1,) # GL_CURRENT_RASTER_INDEX +_m[0x8406] = (1,) # GL_CURRENT_RASTER_NORMAL_SGIX +_m[0x0B07] = (4,) # GL_CURRENT_RASTER_POSITION +_m[0x0B08] = (1,) # GL_CURRENT_RASTER_POSITION_VALID +_m[0x0B06] = (4,) # GL_CURRENT_RASTER_TEXTURE_COORDS +_m[0x8459] = (4,) # GL_CURRENT_SECONDARY_COLOR +_m[0x8459] = (1,) # GL_CURRENT_SECONDARY_COLOR_EXT +_m[0x843B] = (1,) # GL_CURRENT_TANGENT_EXT +_m[0x0B03] = (4,) # GL_CURRENT_TEXTURE_COORDS +_m[0x8E28] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/present_video.txt # GL_CURRENT_TIME_NV +_m[0x8626] = (4,) # GL_CURRENT_VERTEX_ATTRIB +_m[0x850B] = (1,) # GL_CURRENT_VERTEX_WEIGHT_EXT +_m[0x86A8] = (1,) # GL_CURRENT_WEIGHT_ARB +_m[0x8244] = (1,) # GL_DEBUG_CALLBACK_FUNCTION +_m[0x8245] = (1,) # GL_DEBUG_CALLBACK_USER_PARAM +_m[0x826D] = (1,) # GL_DEBUG_GROUP_STACK_DEPTH +_m[0x9145] = (1,) # GL_DEBUG_LOGGED_MESSAGES +_m[0x9145] = (1,) # GL_DEBUG_LOGGED_MESSAGES_AMD +_m[0x9145] = (1,) # GL_DEBUG_LOGGED_MESSAGES_ARB +_m[0x8243] = (1,) # GL_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH +_m[0x8243] = (1,) # GL_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH_ARB +_m[0x92E0] = (1,) # GL_DEBUG_OUTPUT +_m[0x8242] = (1,) # GL_DEBUG_OUTPUT_SYNCHRONOUS +_m[0x8196] = (1,) # GL_DEFORMATIONS_MASK_SGIX +_m[0x8B80] = (1,) # GL_DELETE_STATUS +_m[0x0D1F] = (1,) # GL_DEPTH_BIAS +_m[0x0D56] = (1,) # GL_DEPTH_BITS +_m[0x8891] = (1,) # GL_DEPTH_BOUNDS_EXT +_m[0x8890] = (1,) # GL_DEPTH_BOUNDS_TEST_EXT +_m[0x8DAF] = (1,) # GL_DEPTH_BUFFER_FLOAT_MODE_NV +_m[0x864F] = (1,) # GL_DEPTH_CLAMP +_m[0x901F] = (1,) # GL_DEPTH_CLAMP_FAR_AMD +_m[0x901E] = (1,) # GL_DEPTH_CLAMP_NEAR_AMD +_m[0x864F] = (1,) # GL_DEPTH_CLAMP_NV +_m[0x0B73] = (1,) # GL_DEPTH_CLEAR_VALUE +_m[0x8284] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_DEPTH_COMPONENTS +_m[0x0B74] = (1,) # GL_DEPTH_FUNC +_m[0x8311] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/SGIX/SGIX_depth_pass_instrument.txt # GL_DEPTH_PASS_INSTRUMENT_COUNTERS_SGIX +_m[0x8312] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/SGIX/SGIX_depth_pass_instrument.txt # GL_DEPTH_PASS_INSTRUMENT_MAX_SGIX +_m[0x0B70] = (2,) # GL_DEPTH_RANGE +_m[0x8287] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_DEPTH_RENDERABLE +_m[0x932D] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_framebuffer_mixed_samples.txt # GL_DEPTH_SAMPLES_NV +_m[0x0D1E] = (1,) # GL_DEPTH_SCALE +_m[0x90EA] = (1,) # GL_DEPTH_STENCIL_TEXTURE_MODE +_m[0x0B71] = (1,) # GL_DEPTH_TEST +_m[0x884B] = (1,) # GL_DEPTH_TEXTURE_MODE +_m[0x0B72] = (1,) # GL_DEPTH_WRITEMASK +_m[0x95AB] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_memory_attachment.txt # GL_DETACHED_BUFFERS_NV +_m[0x95A9] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_memory_attachment.txt # GL_DETACHED_MEMORY_INCARNATION_NV +_m[0x95AA] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_memory_attachment.txt # GL_DETACHED_TEXTURES_NV +_m[0x8096] = (1,) # GL_DETAIL_TEXTURE_2D_BINDING_SGIS +_m[0x1201] = (4,) # GL_DIFFUSE +_m[0x90EF] = (1,) # GL_DISPATCH_INDIRECT_BUFFER_BINDING +_m[0x8129] = (3,) # GL_DISTANCE_ATTENUATION_SGIS +_m[0x0BD0] = (1,) # GL_DITHER +_m[0x0C32] = (1,) # GL_DOUBLEBUFFER +_m[0x913E] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/IMG/IMG_framebuffer_downsample.txt # GL_DOWNSAMPLE_SCALES_IMG +_m[0x0C01] = (1,) # GL_DRAW_BUFFER +_m[0x8825] = (1,) # GL_DRAW_BUFFER0 +_m[0x8825] = (1,) # GL_DRAW_BUFFER0_ARB +_m[0x8825] = (1,) # GL_DRAW_BUFFER0_ATI +_m[0x8826] = (1,) # GL_DRAW_BUFFER1 +_m[0x882F] = (1,) # GL_DRAW_BUFFER10 +_m[0x882F] = (1,) # GL_DRAW_BUFFER10_ARB +_m[0x882F] = (1,) # GL_DRAW_BUFFER10_ATI +_m[0x8830] = (1,) # GL_DRAW_BUFFER11 +_m[0x8830] = (1,) # GL_DRAW_BUFFER11_ARB +_m[0x8830] = (1,) # GL_DRAW_BUFFER11_ATI +_m[0x8831] = (1,) # GL_DRAW_BUFFER12 +_m[0x8831] = (1,) # GL_DRAW_BUFFER12_ARB +_m[0x8831] = (1,) # GL_DRAW_BUFFER12_ATI +_m[0x8832] = (1,) # GL_DRAW_BUFFER13 +_m[0x8832] = (1,) # GL_DRAW_BUFFER13_ARB +_m[0x8832] = (1,) # GL_DRAW_BUFFER13_ATI +_m[0x8833] = (1,) # GL_DRAW_BUFFER14 +_m[0x8833] = (1,) # GL_DRAW_BUFFER14_ARB +_m[0x8833] = (1,) # GL_DRAW_BUFFER14_ATI +_m[0x8834] = (1,) # GL_DRAW_BUFFER15 +_m[0x8834] = (1,) # GL_DRAW_BUFFER15_ARB +_m[0x8834] = (1,) # GL_DRAW_BUFFER15_ATI +_m[0x8826] = (1,) # GL_DRAW_BUFFER1_ARB +_m[0x8826] = (1,) # GL_DRAW_BUFFER1_ATI +_m[0x8827] = (1,) # GL_DRAW_BUFFER2 +_m[0x8827] = (1,) # GL_DRAW_BUFFER2_ARB +_m[0x8827] = (1,) # GL_DRAW_BUFFER2_ATI +_m[0x8828] = (1,) # GL_DRAW_BUFFER3 +_m[0x8828] = (1,) # GL_DRAW_BUFFER3_ARB +_m[0x8828] = (1,) # GL_DRAW_BUFFER3_ATI +_m[0x8829] = (1,) # GL_DRAW_BUFFER4 +_m[0x8829] = (1,) # GL_DRAW_BUFFER4_ARB +_m[0x8829] = (1,) # GL_DRAW_BUFFER4_ATI +_m[0x882A] = (1,) # GL_DRAW_BUFFER5 +_m[0x882A] = (1,) # GL_DRAW_BUFFER5_ARB +_m[0x882A] = (1,) # GL_DRAW_BUFFER5_ATI +_m[0x882B] = (1,) # GL_DRAW_BUFFER6 +_m[0x882B] = (1,) # GL_DRAW_BUFFER6_ARB +_m[0x882B] = (1,) # GL_DRAW_BUFFER6_ATI +_m[0x882C] = (1,) # GL_DRAW_BUFFER7 +_m[0x882C] = (1,) # GL_DRAW_BUFFER7_ARB +_m[0x882C] = (1,) # GL_DRAW_BUFFER7_ATI +_m[0x882D] = (1,) # GL_DRAW_BUFFER8 +_m[0x882D] = (1,) # GL_DRAW_BUFFER8_ARB +_m[0x882D] = (1,) # GL_DRAW_BUFFER8_ATI +_m[0x882E] = (1,) # GL_DRAW_BUFFER9 +_m[0x882E] = (1,) # GL_DRAW_BUFFER9_ARB +_m[0x882E] = (1,) # GL_DRAW_BUFFER9_ATI +_m[0x0C01] = (1,) # GL_DRAW_BUFFER_EXT +_m[0x8CA9] = (1,) # GL_DRAW_FRAMEBUFFER +_m[0x8CA6] = (1,) # GL_DRAW_FRAMEBUFFER_BINDING +_m[0x8F43] = (1,) # GL_DRAW_INDIRECT_BUFFER_BINDING +_m[0x8716] = (1,) # GL_DS_BIAS_NV +_m[0x8710] = (1,) # GL_DS_SCALE_NV +_m[0x8717] = (1,) # GL_DT_BIAS_NV +_m[0x8711] = (1,) # GL_DT_SCALE_NV +_m[0x0B43] = (1,) # GL_EDGE_FLAG +_m[0x8079] = (1,) # GL_EDGE_FLAG_ARRAY +_m[0x889B] = (1,) # GL_EDGE_FLAG_ARRAY_BUFFER_BINDING +_m[0x889B] = (1,) # GL_EDGE_FLAG_ARRAY_BUFFER_BINDING_ARB +_m[0x808D] = (1,) # GL_EDGE_FLAG_ARRAY_COUNT_EXT +_m[0x8079] = (1,) # GL_EDGE_FLAG_ARRAY_EXT +_m[0x8F30] = (1,) # GL_EDGE_FLAG_ARRAY_LENGTH_NV +_m[0x8093] = (1,) # GL_EDGE_FLAG_ARRAY_POINTER +_m[0x808C] = (1,) # GL_EDGE_FLAG_ARRAY_STRIDE +_m[0x808C] = (1,) # GL_EDGE_FLAG_ARRAY_STRIDE_EXT +_m[0x932C] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_framebuffer_mixed_samples.txt # GL_EFFECTIVE_RASTER_SAMPLES_EXT +_m[0x8895] = (1,) # GL_ELEMENT_ARRAY_BUFFER_BINDING +_m[0x8895] = (1,) # GL_ELEMENT_ARRAY_BUFFER_BINDING_ARB +_m[0x8F33] = (1,) # GL_ELEMENT_ARRAY_LENGTH_NV +_m[0x8A0E] = (1,)#TODO Review http://www.opengl.org/registry/specs//APPLE/element_array.txt # GL_ELEMENT_ARRAY_POINTER_APPLE +_m[0x8A0D] = (1,) # GL_ELEMENT_ARRAY_TYPE_APPLE +_m[0x8769] = (1,) # GL_ELEMENT_ARRAY_TYPE_ATI +_m[0x1600] = (4,) # GL_EMISSION +_m[0x86C5] = (1,) # GL_EVAL_FRACTIONAL_TESSELLATION_NV +_m[0x86C6] = (1,) # GL_EVAL_VERTEX_ATTRIB0_NV +_m[0x86D0] = (1,) # GL_EVAL_VERTEX_ATTRIB10_NV +_m[0x86D1] = (1,) # GL_EVAL_VERTEX_ATTRIB11_NV +_m[0x86D2] = (1,) # GL_EVAL_VERTEX_ATTRIB12_NV +_m[0x86D3] = (1,) # GL_EVAL_VERTEX_ATTRIB13_NV +_m[0x86D4] = (1,) # GL_EVAL_VERTEX_ATTRIB14_NV +_m[0x86D5] = (1,) # GL_EVAL_VERTEX_ATTRIB15_NV +_m[0x86C7] = (1,) # GL_EVAL_VERTEX_ATTRIB1_NV +_m[0x86C8] = (1,) # GL_EVAL_VERTEX_ATTRIB2_NV +_m[0x86C9] = (1,) # GL_EVAL_VERTEX_ATTRIB3_NV +_m[0x86CA] = (1,) # GL_EVAL_VERTEX_ATTRIB4_NV +_m[0x86CB] = (1,) # GL_EVAL_VERTEX_ATTRIB5_NV +_m[0x86CC] = (1,) # GL_EVAL_VERTEX_ATTRIB6_NV +_m[0x86CD] = (1,) # GL_EVAL_VERTEX_ATTRIB7_NV +_m[0x86CE] = (1,) # GL_EVAL_VERTEX_ATTRIB8_NV +_m[0x86CF] = (1,) # GL_EVAL_VERTEX_ATTRIB9_NV +_m[0x1F03] = (1,) # GL_EXTENSIONS +_m[0x81F6] = (7,) # GL_EYE_LINE_SGIS +_m[0x2502] = (4,) # GL_EYE_PLANE +_m[0x81F4] = (4,) # GL_EYE_POINT_SGIS +_m[0x0DF0] = (1,) # GL_FEEDBACK_BUFFER_POINTER +_m[0x0DF1] = (1,) # GL_FEEDBACK_BUFFER_SIZE +_m[0x0DF2] = (1,) # GL_FEEDBACK_BUFFER_TYPE +_m[0x84F4] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/fence.txt # GL_FENCE_CONDITION_NV +_m[0x84F3] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/fence.txt # GL_FENCE_STATUS_NV +_m[0x8F65] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/ARM/ARM_shader_framebuffer_fetch.txt # GL_FETCH_PER_SAMPLE_ARM +_m[0x1B02] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_polygon_mode.txt # GL_FILL_NV +_m[0x829A] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_FILTER +_m[0x888D] = (4,) # GL_FLOAT_CLEAR_COLOR_VALUE_NV +_m[0x888E] = (1,) # GL_FLOAT_RGBA_MODE_NV +_m[0x0B60] = (1,) # GL_FOG +_m[0x0B66] = (4,) # GL_FOG_COLOR +_m[0x889D] = (1,) # GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING_ARB +_m[0x8456] = (1,)#TODO Review http://www.opengl.org/registry/specs//EXT/fog_coord.txt # GL_FOG_COORDINATE_ARRAY_POINTER_EXT +_m[0x8455] = (1,) # GL_FOG_COORDINATE_ARRAY_STRIDE_EXT +_m[0x8454] = (1,) # GL_FOG_COORDINATE_ARRAY_TYPE_EXT +_m[0x8457] = (1,) # GL_FOG_COORD_ARRAY +_m[0x889D] = (1,) # GL_FOG_COORD_ARRAY_BUFFER_BINDING +_m[0x8F32] = (1,) # GL_FOG_COORD_ARRAY_LENGTH_NV +_m[0x8455] = (1,) # GL_FOG_COORD_ARRAY_STRIDE +_m[0x8454] = (1,) # GL_FOG_COORD_ARRAY_TYPE +_m[0x8450] = (1,) # GL_FOG_COORD_SRC +_m[0x0B62] = (1,) # GL_FOG_DENSITY +_m[0x855A] = (1,) # GL_FOG_DISTANCE_MODE_NV +_m[0x0B64] = (1,) # GL_FOG_END +_m[0x812B] = (1,) # GL_FOG_FUNC_POINTS_SGIS +_m[0x0C54] = (1,) # GL_FOG_HINT +_m[0x0B61] = (1,) # GL_FOG_INDEX +_m[0x0B65] = (1,) # GL_FOG_MODE +_m[0x8198] = (1,) # GL_FOG_OFFSET_SGIX +_m[0x8199] = (4,) # GL_FOG_OFFSET_VALUE_SGIX +_m[0x0B63] = (1,) # GL_FOG_START +_m[0x8402] = (1,) # GL_FRAGMENT_COLOR_MATERIAL_FACE_SGIX +_m[0x8403] = (1,) # GL_FRAGMENT_COLOR_MATERIAL_PARAMETER_SGIX +_m[0x8401] = (1,) # GL_FRAGMENT_COLOR_MATERIAL_SGIX +_m[0x92DE] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_fragment_coverage_to_color.txt # GL_FRAGMENT_COVERAGE_COLOR_NV +_m[0x8E5D] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/gpu_shader5.txt # GL_FRAGMENT_INTERPOLATION_OFFSET_BITS +_m[0x840C] = (1,) # GL_FRAGMENT_LIGHT0_SGIX +_m[0x8400] = (1,) # GL_FRAGMENT_LIGHTING_SGIX +_m[0x840A] = (4,) # GL_FRAGMENT_LIGHT_MODEL_AMBIENT_SGIX +_m[0x8408] = (1,) # GL_FRAGMENT_LIGHT_MODEL_LOCAL_VIEWER_SGIX +_m[0x840B] = (1,) # GL_FRAGMENT_LIGHT_MODEL_NORMAL_INTERPOLATION_SGIX +_m[0x8409] = (1,) # GL_FRAGMENT_LIGHT_MODEL_TWO_SIDE_SGIX +_m[0x8804] = (1,) # GL_FRAGMENT_PROGRAM_ARB +_m[0x8873] = (1,) # GL_FRAGMENT_PROGRAM_BINDING_NV +_m[0x8E5D] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/gpu_program5.txt # GL_FRAGMENT_PROGRAM_INTERPOLATION_OFFSET_BITS_NV +_m[0x8870] = (1,) # GL_FRAGMENT_PROGRAM_NV +_m[0x8DA4] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/parameter_buffer_object.txt # GL_FRAGMENT_PROGRAM_PARAMETER_BUFFER_NV +_m[0x8B30] = (1,) # GL_FRAGMENT_SHADER +_m[0x8920] = (1,) # GL_FRAGMENT_SHADER_ATI +_m[0x8B8B] = (1,) # GL_FRAGMENT_SHADER_DERIVATIVE_HINT +_m[0x8B8B] = (1,) # GL_FRAGMENT_SHADER_DERIVATIVE_HINT_ARB +_m[0x8A52] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/EXT/EXT_shader_framebuffer_fetch.txt # GL_FRAGMENT_SHADER_DISCARDS_SAMPLES_EXT +_m[0x8F66] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/ARM/ARM_shader_framebuffer_fetch.txt # GL_FRAGMENT_SHADER_FRAMEBUFFER_FETCH_MRT_ARM +_m[0x829F] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_FRAGMENT_TEXTURE +_m[0x8215] = (1,) # GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE +_m[0x8214] = (1,) # GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE +_m[0x8210] = (1,) # GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING +_m[0x8211] = (1,) # GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE +_m[0x8216] = (1,) # GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE +_m[0x8213] = (1,) # GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE +_m[0x8DA7] = (1,) # GL_FRAMEBUFFER_ATTACHMENT_LAYERED +_m[0x8CD1] = (1,) # GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME +_m[0x8CD0] = (1,) # GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE +_m[0x8212] = (1,) # GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE +_m[0x8217] = (1,) # GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE +_m[0x9632] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/OVR/OVR_multiview.txt # GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_BASE_VIEW_INDEX_OVR +_m[0x8CD3] = (1,) # GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE +_m[0x8CD4] = (1,) # GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER +_m[0x8CD2] = (1,) # GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL +_m[0x9630] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/OVR/OVR_multiview.txt # GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_NUM_VIEWS_OVR +_m[0x8D6C] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/EXT/EXT_multisampled_render_to_texture.txt # GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_SAMPLES_EXT +_m[0x913F] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/IMG/IMG_framebuffer_downsample.txt # GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_SCALE_IMG +_m[0x8CA6] = (1,) # GL_FRAMEBUFFER_BINDING_EXT +_m[0x8CA6] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/OES/OES_framebuffer_object.txt # GL_FRAMEBUFFER_BINDING_OES +_m[0x828B] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_FRAMEBUFFER_BLEND +_m[0x9314] = (1,) # GL_FRAMEBUFFER_DEFAULT_FIXED_SAMPLE_LOCATIONS +_m[0x9311] = (1,) # GL_FRAMEBUFFER_DEFAULT_HEIGHT +_m[0x9312] = (1,) # GL_FRAMEBUFFER_DEFAULT_LAYERS +_m[0x9313] = (1,) # GL_FRAMEBUFFER_DEFAULT_SAMPLES +_m[0x9310] = (1,) # GL_FRAMEBUFFER_DEFAULT_WIDTH +_m[0x96A2] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/QCOM/QCOM_shader_framebuffer_fetch_noncoherent.txt # GL_FRAMEBUFFER_FETCH_NONCOHERENT_QCOM +_m[0x8289] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_FRAMEBUFFER_RENDERABLE +_m[0x828A] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_FRAMEBUFFER_RENDERABLE_LAYERED +_m[0x8DB9] = (1,) # GL_FRAMEBUFFER_SRGB +_m[0x8DBA] = (1,) # GL_FRAMEBUFFER_SRGB_CAPABLE_EXT +_m[0x8DB9] = (1,) # GL_FRAMEBUFFER_SRGB_EXT +_m[0x818C] = (1,) # GL_FRAMEZOOM_FACTOR_SGIX +_m[0x818B] = (1,) # GL_FRAMEZOOM_SGIX +_m[0x0B46] = (1,) # GL_FRONT_FACE +_m[0x8191] = (1,) # GL_GENERATE_MIPMAP +_m[0x8192] = (1,) # GL_GENERATE_MIPMAP_HINT +_m[0x8192] = (1,) # GL_GENERATE_MIPMAP_HINT_SGIS +_m[0x8DDB] = (1,) # GL_GEOMETRY_INPUT_TYPE_ARB +_m[0x8DDB] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/geometry_program4.txt # GL_GEOMETRY_INPUT_TYPE_EXT +_m[0x8917] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/EXT/EXT_geometry_shader.txt # GL_GEOMETRY_LINKED_INPUT_TYPE_EXT +_m[0x8917] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/OES/OES_geometry_shader.txt # GL_GEOMETRY_LINKED_INPUT_TYPE_OES +_m[0x8918] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/EXT/EXT_geometry_shader.txt # GL_GEOMETRY_LINKED_OUTPUT_TYPE_EXT +_m[0x8918] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/OES/OES_geometry_shader.txt # GL_GEOMETRY_LINKED_OUTPUT_TYPE_OES +_m[0x8916] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/EXT/EXT_geometry_shader.txt # GL_GEOMETRY_LINKED_VERTICES_OUT_EXT +_m[0x8916] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/OES/OES_geometry_shader.txt # GL_GEOMETRY_LINKED_VERTICES_OUT_OES +_m[0x8DDC] = (1,) # GL_GEOMETRY_OUTPUT_TYPE_ARB +_m[0x8DDC] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/geometry_program4.txt # GL_GEOMETRY_OUTPUT_TYPE_EXT +_m[0x8C26] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/geometry_program4.txt # GL_GEOMETRY_PROGRAM_NV +_m[0x8DA3] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/parameter_buffer_object.txt # GL_GEOMETRY_PROGRAM_PARAMETER_BUFFER_NV +_m[0x8DD9] = (1,) # GL_GEOMETRY_SHADER +_m[0x887F] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/gpu_shader5.txt # GL_GEOMETRY_SHADER_INVOCATIONS +_m[0x829E] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_GEOMETRY_TEXTURE +_m[0x8DDA] = (1,) # GL_GEOMETRY_VERTICES_OUT_ARB +_m[0x8DDA] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/geometry_program4.txt # GL_GEOMETRY_VERTICES_OUT_EXT +_m[0x8291] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_GET_TEXTURE_IMAGE_FORMAT +_m[0x8292] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_GET_TEXTURE_IMAGE_TYPE +_m[0x81DA] = (1,) # GL_GLOBAL_ALPHA_FACTOR_SUN +_m[0x8FBB] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/EXT/EXT_disjoint_timer_query.txt # GL_GPU_DISJOINT_EXT +_m[0x9049] = (1,) # GL_GPU_MEMORY_INFO_CURRENT_AVAILABLE_VIDMEM_NVX +_m[0x9047] = (1,) # GL_GPU_MEMORY_INFO_DEDICATED_VIDMEM_NVX +_m[0x904B] = (1,) # GL_GPU_MEMORY_INFO_EVICTED_MEMORY_NVX +_m[0x904A] = (1,) # GL_GPU_MEMORY_INFO_EVICTION_COUNT_NVX +_m[0x9048] = (1,) # GL_GPU_MEMORY_INFO_TOTAL_AVAILABLE_MEMORY_NVX +_m[0x0D19] = (1,) # GL_GREEN_BIAS +_m[0x0D53] = (1,) # GL_GREEN_BITS +_m[0x8565] = (1,) # GL_GREEN_MAX_CLAMP_INGR +_m[0x8561] = (1,) # GL_GREEN_MIN_CLAMP_INGR +_m[0x0D18] = (1,) # GL_GREEN_SCALE +_m[0x8024] = (1,) # GL_HISTOGRAM +_m[0x802B] = (1,) # GL_HISTOGRAM_ALPHA_SIZE +_m[0x802B] = (1,) # GL_HISTOGRAM_ALPHA_SIZE_EXT +_m[0x802A] = (1,) # GL_HISTOGRAM_BLUE_SIZE +_m[0x802A] = (1,) # GL_HISTOGRAM_BLUE_SIZE_EXT +_m[0x8024] = (1,) # GL_HISTOGRAM_EXT +_m[0x8027] = (1,) # GL_HISTOGRAM_FORMAT +_m[0x8027] = (1,) # GL_HISTOGRAM_FORMAT_EXT +_m[0x8029] = (1,) # GL_HISTOGRAM_GREEN_SIZE +_m[0x8029] = (1,) # GL_HISTOGRAM_GREEN_SIZE_EXT +_m[0x802C] = (1,) # GL_HISTOGRAM_LUMINANCE_SIZE +_m[0x802C] = (1,) # GL_HISTOGRAM_LUMINANCE_SIZE_EXT +_m[0x8028] = (1,) # GL_HISTOGRAM_RED_SIZE +_m[0x8028] = (1,) # GL_HISTOGRAM_RED_SIZE_EXT +_m[0x802D] = (1,) # GL_HISTOGRAM_SINK +_m[0x802D] = (1,) # GL_HISTOGRAM_SINK_EXT +_m[0x8026] = (1,) # GL_HISTOGRAM_WIDTH +_m[0x8026] = (1,) # GL_HISTOGRAM_WIDTH_EXT +_m[0x8714] = (1,) # GL_HI_BIAS_NV +_m[0x870E] = (1,) # GL_HI_SCALE_NV +_m[0x82A8] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_IMAGE_COMPATIBILITY_CLASS +_m[0x90C7] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_IMAGE_FORMAT_COMPATIBILITY_TYPE +_m[0x82A9] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_IMAGE_PIXEL_FORMAT +_m[0x82AA] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_IMAGE_PIXEL_TYPE +_m[0x82A7] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_IMAGE_TEXEL_SIZE +_m[0x8B9B] = (1,) # GL_IMPLEMENTATION_COLOR_READ_FORMAT +_m[0x8B9A] = (1,) # GL_IMPLEMENTATION_COLOR_READ_TYPE +_m[0x8077] = (1,) # GL_INDEX_ARRAY +_m[0x8899] = (1,) # GL_INDEX_ARRAY_BUFFER_BINDING +_m[0x8899] = (1,) # GL_INDEX_ARRAY_BUFFER_BINDING_ARB +_m[0x8087] = (1,) # GL_INDEX_ARRAY_COUNT_EXT +_m[0x8077] = (1,) # GL_INDEX_ARRAY_EXT +_m[0x8F2E] = (1,) # GL_INDEX_ARRAY_LENGTH_NV +_m[0x8091] = (1,) # GL_INDEX_ARRAY_POINTER +_m[0x8086] = (1,) # GL_INDEX_ARRAY_STRIDE +_m[0x8086] = (1,) # GL_INDEX_ARRAY_STRIDE_EXT +_m[0x8085] = (1,) # GL_INDEX_ARRAY_TYPE +_m[0x8085] = (1,) # GL_INDEX_ARRAY_TYPE_EXT +_m[0x0D51] = (1,) # GL_INDEX_BITS +_m[0x0C20] = (1,) # GL_INDEX_CLEAR_VALUE +_m[0x0BF1] = (1,) # GL_INDEX_LOGIC_OP +_m[0x0C30] = (1,) # GL_INDEX_MODE +_m[0x0D13] = (1,) # GL_INDEX_OFFSET +_m[0x0D12] = (1,) # GL_INDEX_SHIFT +_m[0x0C21] = (1,) # GL_INDEX_WRITEMASK +_m[0x8B84] = (1,) # GL_INFO_LOG_LENGTH +_m[0x8181] = (1,) # GL_INSTRUMENT_MEASUREMENTS_SGIX +_m[0x8980] = (1,) # GL_INTERLACE_OML +_m[0x8568] = (1,) # GL_INTERLACE_READ_INGR +_m[0x8981] = (1,) # GL_INTERLACE_READ_OML +_m[0x8094] = (1,) # GL_INTERLACE_SGIX +_m[0x8274] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_INTERNALFORMAT_ALPHA_SIZE +_m[0x827B] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_INTERNALFORMAT_ALPHA_TYPE +_m[0x8273] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_INTERNALFORMAT_BLUE_SIZE +_m[0x827A] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_INTERNALFORMAT_BLUE_TYPE +_m[0x8275] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_INTERNALFORMAT_DEPTH_SIZE +_m[0x827C] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_INTERNALFORMAT_DEPTH_TYPE +_m[0x8272] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_INTERNALFORMAT_GREEN_SIZE +_m[0x8279] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_INTERNALFORMAT_GREEN_TYPE +_m[0x8270] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_INTERNALFORMAT_PREFERRED +_m[0x8271] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_INTERNALFORMAT_RED_SIZE +_m[0x8278] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_INTERNALFORMAT_RED_TYPE +_m[0x8277] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_INTERNALFORMAT_SHARED_SIZE +_m[0x8276] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_INTERNALFORMAT_STENCIL_SIZE +_m[0x827D] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_INTERNALFORMAT_STENCIL_TYPE +_m[0x826F] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_INTERNALFORMAT_SUPPORTED +_m[0x817F] = (1,) # GL_IR_INSTRUMENT1_SGIX +_m[0x92E7] = (1,) # GL_IS_PER_PATCH +_m[0x9300] = (1,) # GL_IS_ROW_MAJOR +_m[0x825E] = (1,) # GL_LAYER_PROVOKING_VERTEX +_m[0x4000] = (1,) # GL_LIGHT0 +_m[0x4001] = (1,) # GL_LIGHT1 +_m[0x4002] = (1,) # GL_LIGHT2 +_m[0x4003] = (1,) # GL_LIGHT3 +_m[0x4004] = (1,) # GL_LIGHT4 +_m[0x4005] = (1,) # GL_LIGHT5 +_m[0x4006] = (1,) # GL_LIGHT6 +_m[0x4007] = (1,) # GL_LIGHT7 +_m[0x0B50] = (1,) # GL_LIGHTING +_m[0x8407] = (1,) # GL_LIGHT_ENV_MODE_SGIX +_m[0x0B53] = (4,) # GL_LIGHT_MODEL_AMBIENT +_m[0x81F8] = (1,) # GL_LIGHT_MODEL_COLOR_CONTROL +_m[0x81F8] = (1,) # GL_LIGHT_MODEL_COLOR_CONTROL_EXT +_m[0x0B51] = (1,) # GL_LIGHT_MODEL_LOCAL_VIEWER +_m[0x0B52] = (1,) # GL_LIGHT_MODEL_TWO_SIDE +_m[0x1208] = (1,) # GL_LINEAR_ATTENUATION +_m[0x1B01] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_polygon_mode.txt # GL_LINE_NV +_m[0x0B20] = (1,) # GL_LINE_SMOOTH +_m[0x0C52] = (1,) # GL_LINE_SMOOTH_HINT +_m[0x0B24] = (1,) # GL_LINE_STIPPLE +_m[0x0B25] = (1,) # GL_LINE_STIPPLE_PATTERN +_m[0x0B26] = (1,) # GL_LINE_STIPPLE_REPEAT +_m[0x0B21] = (1,) # GL_LINE_WIDTH +_m[0x0B23] = (1,) # GL_LINE_WIDTH_GRANULARITY +_m[0x0B22] = (2,) # GL_LINE_WIDTH_RANGE +_m[0x8B82] = (1,) # GL_LINK_STATUS +_m[0x0B32] = (1,) # GL_LIST_BASE +_m[0x0B33] = (1,) # GL_LIST_INDEX +_m[0x0B30] = (1,) # GL_LIST_MODE +_m[0x930E] = (1,) # GL_LOCATION +_m[0x930F] = (1,) # GL_LOCATION_INDEX +_m[0x0BF1] = (1,) # GL_LOGIC_OP +_m[0x0BF0] = (1,) # GL_LOGIC_OP_MODE +_m[0x8252] = (1,)#TODO Review http://www.opengl.org/registry/specs//KHR/robustness.txt # GL_LOSE_CONTEXT_ON_RESET +_m[0x8252] = (1,) # GL_LOSE_CONTEXT_ON_RESET_ARB +_m[0x8715] = (1,) # GL_LO_BIAS_NV +_m[0x870F] = (1,) # GL_LO_SCALE_NV +_m[0x8718] = (1,) # GL_MAGNITUDE_BIAS_NV +_m[0x8712] = (1,) # GL_MAGNITUDE_SCALE_NV +_m[0x821B] = (1,) # GL_MAJOR_VERSION +_m[0x8294] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_MANUAL_GENERATE_MIPMAP +_m[0x0D90] = (1,) # GL_MAP1_COLOR_4 +_m[0x0DD0] = (2,) # GL_MAP1_GRID_DOMAIN +_m[0x0DD1] = (1,) # GL_MAP1_GRID_SEGMENTS +_m[0x0D91] = (1,) # GL_MAP1_INDEX +_m[0x0D92] = (1,) # GL_MAP1_NORMAL +_m[0x0D93] = (1,) # GL_MAP1_TEXTURE_COORD_1 +_m[0x0D94] = (1,) # GL_MAP1_TEXTURE_COORD_2 +_m[0x0D95] = (1,) # GL_MAP1_TEXTURE_COORD_3 +_m[0x0D96] = (1,) # GL_MAP1_TEXTURE_COORD_4 +_m[0x0D97] = (1,) # GL_MAP1_VERTEX_3 +_m[0x0D98] = (1,) # GL_MAP1_VERTEX_4 +_m[0x8660] = (4,) # GL_MAP1_VERTEX_ATTRIB0_4_NV +_m[0x866A] = (4,) # GL_MAP1_VERTEX_ATTRIB10_4_NV +_m[0x866B] = (4,) # GL_MAP1_VERTEX_ATTRIB11_4_NV +_m[0x866C] = (4,) # GL_MAP1_VERTEX_ATTRIB12_4_NV +_m[0x866D] = (4,) # GL_MAP1_VERTEX_ATTRIB13_4_NV +_m[0x866E] = (4,) # GL_MAP1_VERTEX_ATTRIB14_4_NV +_m[0x866F] = (4,) # GL_MAP1_VERTEX_ATTRIB15_4_NV +_m[0x8661] = (4,) # GL_MAP1_VERTEX_ATTRIB1_4_NV +_m[0x8662] = (4,) # GL_MAP1_VERTEX_ATTRIB2_4_NV +_m[0x8663] = (4,) # GL_MAP1_VERTEX_ATTRIB3_4_NV +_m[0x8664] = (4,) # GL_MAP1_VERTEX_ATTRIB4_4_NV +_m[0x8665] = (4,) # GL_MAP1_VERTEX_ATTRIB5_4_NV +_m[0x8666] = (4,) # GL_MAP1_VERTEX_ATTRIB6_4_NV +_m[0x8667] = (4,) # GL_MAP1_VERTEX_ATTRIB7_4_NV +_m[0x8668] = (4,) # GL_MAP1_VERTEX_ATTRIB8_4_NV +_m[0x8669] = (4,) # GL_MAP1_VERTEX_ATTRIB9_4_NV +_m[0x0DB0] = (1,) # GL_MAP2_COLOR_4 +_m[0x0DD2] = (4,) # GL_MAP2_GRID_DOMAIN +_m[0x0DD3] = (2,) # GL_MAP2_GRID_SEGMENTS +_m[0x0DB1] = (1,) # GL_MAP2_INDEX +_m[0x0DB2] = (1,) # GL_MAP2_NORMAL +_m[0x0DB3] = (1,) # GL_MAP2_TEXTURE_COORD_1 +_m[0x0DB4] = (1,) # GL_MAP2_TEXTURE_COORD_2 +_m[0x0DB5] = (1,) # GL_MAP2_TEXTURE_COORD_3 +_m[0x0DB6] = (1,) # GL_MAP2_TEXTURE_COORD_4 +_m[0x0DB7] = (1,) # GL_MAP2_VERTEX_3 +_m[0x0DB8] = (1,) # GL_MAP2_VERTEX_4 +_m[0x8670] = (4,) # GL_MAP2_VERTEX_ATTRIB0_4_NV +_m[0x867A] = (4,) # GL_MAP2_VERTEX_ATTRIB10_4_NV +_m[0x867B] = (4,) # GL_MAP2_VERTEX_ATTRIB11_4_NV +_m[0x867C] = (4,) # GL_MAP2_VERTEX_ATTRIB12_4_NV +_m[0x867D] = (4,) # GL_MAP2_VERTEX_ATTRIB13_4_NV +_m[0x867E] = (4,) # GL_MAP2_VERTEX_ATTRIB14_4_NV +_m[0x867F] = (4,) # GL_MAP2_VERTEX_ATTRIB15_4_NV +_m[0x8671] = (4,) # GL_MAP2_VERTEX_ATTRIB1_4_NV +_m[0x8672] = (4,) # GL_MAP2_VERTEX_ATTRIB2_4_NV +_m[0x8673] = (4,) # GL_MAP2_VERTEX_ATTRIB3_4_NV +_m[0x8674] = (4,) # GL_MAP2_VERTEX_ATTRIB4_4_NV +_m[0x8675] = (4,) # GL_MAP2_VERTEX_ATTRIB5_4_NV +_m[0x8676] = (4,) # GL_MAP2_VERTEX_ATTRIB6_4_NV +_m[0x8677] = (4,) # GL_MAP2_VERTEX_ATTRIB7_4_NV +_m[0x8678] = (4,) # GL_MAP2_VERTEX_ATTRIB8_4_NV +_m[0x8679] = (4,) # GL_MAP2_VERTEX_ATTRIB9_4_NV +_m[0x86C3] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/evaluators.txt # GL_MAP_ATTRIB_U_ORDER_NV +_m[0x86C4] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/evaluators.txt # GL_MAP_ATTRIB_V_ORDER_NV +_m[0x0D10] = (1,) # GL_MAP_COLOR +_m[0x0D11] = (1,) # GL_MAP_STENCIL +_m[0x8844] = (1,) # GL_MATRIX_INDEX_ARRAY_ARB +_m[0x8B9E] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/OES/OES_matrix_palette.txt # GL_MATRIX_INDEX_ARRAY_BUFFER_BINDING_OES +_m[0x8849] = (1,) # GL_MATRIX_INDEX_ARRAY_POINTER_ARB +_m[0x8849] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/OES/OES_matrix_palette.txt # GL_MATRIX_INDEX_ARRAY_POINTER_OES +_m[0x8846] = (1,) # GL_MATRIX_INDEX_ARRAY_SIZE_ARB +_m[0x8846] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/OES/OES_matrix_palette.txt # GL_MATRIX_INDEX_ARRAY_SIZE_OES +_m[0x8848] = (1,) # GL_MATRIX_INDEX_ARRAY_STRIDE_ARB +_m[0x8848] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/OES/OES_matrix_palette.txt # GL_MATRIX_INDEX_ARRAY_STRIDE_OES +_m[0x8847] = (1,) # GL_MATRIX_INDEX_ARRAY_TYPE_ARB +_m[0x8847] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/OES/OES_matrix_palette.txt # GL_MATRIX_INDEX_ARRAY_TYPE_OES +_m[0x0BA0] = (1,) # GL_MATRIX_MODE +_m[0x8840] = (1,) # GL_MATRIX_PALETTE_ARB +_m[0x92FF] = (1,) # GL_MATRIX_STRIDE +_m[0x8073] = (1,) # GL_MAX_3D_TEXTURE_SIZE +_m[0x8073] = (1,) # GL_MAX_3D_TEXTURE_SIZE_EXT +_m[0x8138] = (1,) # GL_MAX_4D_TEXTURE_SIZE_SGIS +_m[0x8405] = (1,) # GL_MAX_ACTIVE_LIGHTS_SGIX +_m[0x88FF] = (1,) # GL_MAX_ARRAY_TEXTURE_LAYERS +_m[0x88FF] = (1,) # GL_MAX_ARRAY_TEXTURE_LAYERS_EXT +_m[0x8360] = (1,) # GL_MAX_ASYNC_DRAW_PIXELS_SGIX +_m[0x832D] = (1,) # GL_MAX_ASYNC_HISTOGRAM_SGIX +_m[0x8361] = (1,) # GL_MAX_ASYNC_READ_PIXELS_SGIX +_m[0x835F] = (1,) # GL_MAX_ASYNC_TEX_IMAGE_SGIX +_m[0x92DC] = (1,) # GL_MAX_ATOMIC_COUNTER_BUFFER_BINDINGS +_m[0x92D8] = (1,) # GL_MAX_ATOMIC_COUNTER_BUFFER_SIZE +_m[0x0D35] = (1,) # GL_MAX_ATTRIB_STACK_DEPTH +_m[0x8DED] = (1,) # GL_MAX_BINDABLE_UNIFORM_SIZE_EXT +_m[0x0D3B] = (1,) # GL_MAX_CLIENT_ATTRIB_STACK_DEPTH +_m[0x8177] = (1,) # GL_MAX_CLIPMAP_DEPTH_SGIX +_m[0x8178] = (1,) # GL_MAX_CLIPMAP_VIRTUAL_DEPTH_SGIX +_m[0x0D32] = (1,) # GL_MAX_CLIP_DISTANCES +_m[0x0D32] = (1,) # GL_MAX_CLIP_PLANES +_m[0x955F] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_shading_rate_image.txt # GL_MAX_COARSE_FRAGMENT_SAMPLES_NV +_m[0x8CDF] = (1,) # GL_MAX_COLOR_ATTACHMENTS +_m[0x8CDF] = (1,) # GL_MAX_COLOR_ATTACHMENTS_EXT +_m[0x91B3] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/AMD/AMD_framebuffer_multisample_advanced.txt # GL_MAX_COLOR_FRAMEBUFFER_SAMPLES_AMD +_m[0x91B4] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/AMD/AMD_framebuffer_multisample_advanced.txt # GL_MAX_COLOR_FRAMEBUFFER_STORAGE_SAMPLES_AMD +_m[0x80B3] = (1,) # GL_MAX_COLOR_MATRIX_STACK_DEPTH +_m[0x80B3] = (1,) # GL_MAX_COLOR_MATRIX_STACK_DEPTH_SGI +_m[0x910E] = (1,) # GL_MAX_COLOR_TEXTURE_SAMPLES +_m[0x92D7] = (1,) # GL_MAX_COMBINED_ATOMIC_COUNTERS +_m[0x92D1] = (1,) # GL_MAX_COMBINED_ATOMIC_COUNTER_BUFFERS +_m[0x82FA] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/cull_distance.txt # GL_MAX_COMBINED_CLIP_AND_CULL_DISTANCES +_m[0x8266] = (1,) # GL_MAX_COMBINED_COMPUTE_UNIFORM_COMPONENTS +_m[0x8282] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_MAX_COMBINED_DIMENSIONS +_m[0x8A33] = (1,) # GL_MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS +_m[0x8A32] = (1,) # GL_MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS +_m[0x90CF] = (1,) # GL_MAX_COMBINED_IMAGE_UNIFORMS +_m[0x8F39] = (1,) # GL_MAX_COMBINED_IMAGE_UNITS_AND_FRAGMENT_OUTPUTS +_m[0x8F39] = (1,) # GL_MAX_COMBINED_IMAGE_UNITS_AND_FRAGMENT_OUTPUTS_EXT +_m[0x8E67] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_MAX_COMBINED_MESH_UNIFORM_COMPONENTS_NV +_m[0x90DC] = (1,) # GL_MAX_COMBINED_SHADER_STORAGE_BLOCKS +_m[0x8E6F] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_MAX_COMBINED_TASK_UNIFORM_COMPONENTS_NV +_m[0x8E1E] = (1,) # GL_MAX_COMBINED_TESS_CONTROL_UNIFORM_COMPONENTS +_m[0x8E1F] = (1,) # GL_MAX_COMBINED_TESS_EVALUATION_UNIFORM_COMPONENTS +_m[0x8B4D] = (1,) # GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS +_m[0x8B4D] = (1,) # GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB +_m[0x8A2E] = (1,) # GL_MAX_COMBINED_UNIFORM_BLOCKS +_m[0x8A31] = (1,) # GL_MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS +_m[0x8265] = (1,) # GL_MAX_COMPUTE_ATOMIC_COUNTERS +_m[0x8264] = (1,) # GL_MAX_COMPUTE_ATOMIC_COUNTER_BUFFERS +_m[0x91BD] = (1,) # GL_MAX_COMPUTE_IMAGE_UNIFORMS +_m[0x90DB] = (1,) # GL_MAX_COMPUTE_SHADER_STORAGE_BLOCKS +_m[0x8262] = (1,) # GL_MAX_COMPUTE_SHARED_MEMORY_SIZE +_m[0x91BC] = (1,) # GL_MAX_COMPUTE_TEXTURE_IMAGE_UNITS +_m[0x91BB] = (1,) # GL_MAX_COMPUTE_UNIFORM_BLOCKS +_m[0x8263] = (1,) # GL_MAX_COMPUTE_UNIFORM_COMPONENTS +_m[0x9344] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/compute_variable_group_size.txt # GL_MAX_COMPUTE_VARIABLE_GROUP_INVOCATIONS_ARB +_m[0x9345] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/compute_variable_group_size.txt # GL_MAX_COMPUTE_VARIABLE_GROUP_SIZE_ARB +_m[0x91BE] = (3,) # GL_MAX_COMPUTE_WORK_GROUP_COUNT +_m[0x90EB] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/compute_shader.txt # GL_MAX_COMPUTE_WORK_GROUP_INVOCATIONS +_m[0x91BF] = (3,) # GL_MAX_COMPUTE_WORK_GROUP_SIZE +_m[0x801B] = (1,) # GL_MAX_CONVOLUTION_HEIGHT +_m[0x801A] = (1,) # GL_MAX_CONVOLUTION_WIDTH +_m[0x851C] = (1,) # GL_MAX_CUBE_MAP_TEXTURE_SIZE +_m[0x851C] = (1,) # GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB +_m[0x82F9] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/cull_distance.txt # GL_MAX_CULL_DISTANCES +_m[0x826C] = (1,) # GL_MAX_DEBUG_GROUP_STACK_DEPTH +_m[0x9144] = (1,) # GL_MAX_DEBUG_LOGGED_MESSAGES +_m[0x9144] = (1,) # GL_MAX_DEBUG_LOGGED_MESSAGES_AMD +_m[0x9144] = (1,) # GL_MAX_DEBUG_LOGGED_MESSAGES_ARB +_m[0x9143] = (1,) # GL_MAX_DEBUG_MESSAGE_LENGTH +_m[0x9143] = (1,) # GL_MAX_DEBUG_MESSAGE_LENGTH_AMD +_m[0x9143] = (1,) # GL_MAX_DEBUG_MESSAGE_LENGTH_ARB +_m[0x90D1] = (1,) # GL_MAX_DEEP_3D_TEXTURE_DEPTH_NV +_m[0x90D0] = (2,) # GL_MAX_DEEP_3D_TEXTURE_WIDTH_HEIGHT_NV +_m[0x8280] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_MAX_DEPTH +_m[0x91B5] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/AMD/AMD_framebuffer_multisample_advanced.txt # GL_MAX_DEPTH_STENCIL_FRAMEBUFFER_SAMPLES_AMD +_m[0x910F] = (1,) # GL_MAX_DEPTH_TEXTURE_SAMPLES +_m[0x8824] = (1,) # GL_MAX_DRAW_BUFFERS +_m[0x8824] = (1,) # GL_MAX_DRAW_BUFFERS_ARB +_m[0x8824] = (1,) # GL_MAX_DRAW_BUFFERS_ATI +_m[0x953D] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_MAX_DRAW_MESH_TASKS_COUNT_NV +_m[0x88FC] = (1,) # GL_MAX_DUAL_SOURCE_DRAW_BUFFERS +_m[0x80E9] = (1,) # GL_MAX_ELEMENTS_INDICES +_m[0x80E8] = (1,) # GL_MAX_ELEMENTS_VERTICES +_m[0x8D6B] = (1,) # GL_MAX_ELEMENT_INDEX +_m[0x0D30] = (1,) # GL_MAX_EVAL_ORDER +_m[0x812C] = (1,) # GL_MAX_FOG_FUNC_POINTS_SGIS +_m[0x92D6] = (1,) # GL_MAX_FRAGMENT_ATOMIC_COUNTERS +_m[0x92D0] = (1,) # GL_MAX_FRAGMENT_ATOMIC_COUNTER_BUFFERS +_m[0x8DE3] = (1,) # GL_MAX_FRAGMENT_BINDABLE_UNIFORMS_EXT +_m[0x90CE] = (1,) # GL_MAX_FRAGMENT_IMAGE_UNIFORMS +_m[0x9125] = (1,) # GL_MAX_FRAGMENT_INPUT_COMPONENTS +_m[0x8E5C] = (1,) # GL_MAX_FRAGMENT_INTERPOLATION_OFFSET +_m[0x8E5C] = (1,) # GL_MAX_FRAGMENT_INTERPOLATION_OFFSET_NV +_m[0x8404] = (1,) # GL_MAX_FRAGMENT_LIGHTS_SGIX +_m[0x8868] = (1,) # GL_MAX_FRAGMENT_PROGRAM_LOCAL_PARAMETERS_NV +_m[0x90DA] = (1,) # GL_MAX_FRAGMENT_SHADER_STORAGE_BLOCKS +_m[0x8A2D] = (1,) # GL_MAX_FRAGMENT_UNIFORM_BLOCKS +_m[0x8B49] = (1,) # GL_MAX_FRAGMENT_UNIFORM_COMPONENTS +_m[0x8B49] = (1,) # GL_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB +_m[0x8DFD] = (1,) # GL_MAX_FRAGMENT_UNIFORM_VECTORS +_m[0x9316] = (1,) # GL_MAX_FRAMEBUFFER_HEIGHT +_m[0x9317] = (1,) # GL_MAX_FRAMEBUFFER_LAYERS +_m[0x9318] = (1,) # GL_MAX_FRAMEBUFFER_SAMPLES +_m[0x9315] = (1,) # GL_MAX_FRAMEBUFFER_WIDTH +_m[0x818D] = (1,) # GL_MAX_FRAMEZOOM_FACTOR_SGIX +_m[0x854D] = (1,) # GL_MAX_GENERAL_COMBINERS_NV +_m[0x92D5] = (1,) # GL_MAX_GEOMETRY_ATOMIC_COUNTERS +_m[0x92CF] = (1,) # GL_MAX_GEOMETRY_ATOMIC_COUNTER_BUFFERS +_m[0x8DE4] = (1,) # GL_MAX_GEOMETRY_BINDABLE_UNIFORMS_EXT +_m[0x90CD] = (1,) # GL_MAX_GEOMETRY_IMAGE_UNIFORMS +_m[0x9123] = (1,) # GL_MAX_GEOMETRY_INPUT_COMPONENTS +_m[0x9124] = (1,) # GL_MAX_GEOMETRY_OUTPUT_COMPONENTS +_m[0x8DE0] = (1,) # GL_MAX_GEOMETRY_OUTPUT_VERTICES +_m[0x8DE0] = (1,) # GL_MAX_GEOMETRY_OUTPUT_VERTICES_ARB +_m[0x8DE0] = (1,) # GL_MAX_GEOMETRY_OUTPUT_VERTICES_EXT +_m[0x8E5A] = (1,) # GL_MAX_GEOMETRY_PROGRAM_INVOCATIONS_NV +_m[0x8E5A] = (1,) # GL_MAX_GEOMETRY_SHADER_INVOCATIONS +_m[0x90D7] = (1,) # GL_MAX_GEOMETRY_SHADER_STORAGE_BLOCKS +_m[0x8C29] = (1,) # GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS +_m[0x8C29] = (1,) # GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_ARB +_m[0x8C29] = (1,) # GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_EXT +_m[0x8DE1] = (1,) # GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS +_m[0x8DE1] = (1,) # GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS_ARB +_m[0x8DE1] = (1,) # GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS_EXT +_m[0x8A2C] = (1,) # GL_MAX_GEOMETRY_UNIFORM_BLOCKS +_m[0x8DDF] = (1,) # GL_MAX_GEOMETRY_UNIFORM_COMPONENTS +_m[0x8DDF] = (1,) # GL_MAX_GEOMETRY_UNIFORM_COMPONENTS_ARB +_m[0x8DDF] = (1,) # GL_MAX_GEOMETRY_UNIFORM_COMPONENTS_EXT +_m[0x8DDD] = (1,) # GL_MAX_GEOMETRY_VARYING_COMPONENTS_ARB +_m[0x8DDD] = (1,) # GL_MAX_GEOMETRY_VARYING_COMPONENTS_EXT +_m[0x827F] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_MAX_HEIGHT +_m[0x906D] = (1,) # GL_MAX_IMAGE_SAMPLES +_m[0x906D] = (1,) # GL_MAX_IMAGE_SAMPLES_EXT +_m[0x8F38] = (1,) # GL_MAX_IMAGE_UNITS +_m[0x8F38] = (1,) # GL_MAX_IMAGE_UNITS_EXT +_m[0x9110] = (1,) # GL_MAX_INTEGER_SAMPLES +_m[0x82E8] = (1,) # GL_MAX_LABEL_LENGTH +_m[0x8281] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_MAX_LAYERS +_m[0x92BA] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NVX/NVX_linked_gpu_multicast.txt # GL_MAX_LGPU_GPUS_NVX +_m[0x0D31] = (1,) # GL_MAX_LIGHTS +_m[0x0B31] = (1,) # GL_MAX_LIST_NESTING +_m[0x86D6] = (1,) # GL_MAX_MAP_TESSELLATION_NV +_m[0x8841] = (1,) # GL_MAX_MATRIX_PALETTE_STACK_DEPTH_ARB +_m[0x8E65] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_MAX_MESH_ATOMIC_COUNTERS_NV +_m[0x8E64] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_MAX_MESH_ATOMIC_COUNTER_BUFFERS_NV +_m[0x8E62] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_MAX_MESH_IMAGE_UNIFORMS_NV +_m[0x9539] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_MAX_MESH_OUTPUT_PRIMITIVES_NV +_m[0x9538] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_MAX_MESH_OUTPUT_VERTICES_NV +_m[0x8E66] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_MAX_MESH_SHADER_STORAGE_BLOCKS_NV +_m[0x8E61] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_MAX_MESH_TEXTURE_IMAGE_UNITS_NV +_m[0x9536] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_MAX_MESH_TOTAL_MEMORY_SIZE_NV +_m[0x8E60] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_MAX_MESH_UNIFORM_BLOCKS_NV +_m[0x8E63] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_MAX_MESH_UNIFORM_COMPONENTS_NV +_m[0x9557] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_MAX_MESH_VIEWS_NV +_m[0x95A2] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_MAX_MESH_WORK_GROUP_INVOCATIONS_NV +_m[0x953B] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_MAX_MESH_WORK_GROUP_SIZE_NV +_m[0x0D36] = (1,) # GL_MAX_MODELVIEW_STACK_DEPTH +_m[0x8E11] = (1,) # GL_MAX_MULTISAMPLE_COVERAGE_MODES_NV +_m[0x92F6] = (1,) # GL_MAX_NAME_LENGTH +_m[0x0D37] = (1,) # GL_MAX_NAME_STACK_DEPTH +_m[0x92F7] = (1,) # GL_MAX_NUM_ACTIVE_VARIABLES +_m[0x92F8] = (1,) # GL_MAX_NUM_COMPATIBLE_SUBROUTINES +_m[0x87CA] = (1,) # GL_MAX_OPTIMIZED_VERTEX_SHADER_INSTRUCTIONS_EXT +_m[0x87CE] = (1,) # GL_MAX_OPTIMIZED_VERTEX_SHADER_LOCALS_EXT +_m[0x87CC] = (1,) # GL_MAX_OPTIMIZED_VERTEX_SHADER_LOCAL_CONSTANTS_EXT +_m[0x87CB] = (1,) # GL_MAX_OPTIMIZED_VERTEX_SHADER_VARIANTS_EXT +_m[0x8842] = (1,) # GL_MAX_PALETTE_MATRICES_ARB +_m[0x8842] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/OES/OES_matrix_palette.txt # GL_MAX_PALETTE_MATRICES_OES +_m[0x8E7D] = (1,) # GL_MAX_PATCH_VERTICES +_m[0x0D34] = (1,) # GL_MAX_PIXEL_MAP_TABLE +_m[0x8337] = (1,) # GL_MAX_PIXEL_TRANSFORM_2D_STACK_DEPTH_EXT +_m[0x87F1] = (1,) # GL_MAX_PN_TRIANGLES_TESSELATION_LEVEL_ATI +_m[0x88B1] = (1,) # GL_MAX_PROGRAM_ADDRESS_REGISTERS_ARB +_m[0x880B] = (1,) # GL_MAX_PROGRAM_ALU_INSTRUCTIONS_ARB +_m[0x88AD] = (1,) # GL_MAX_PROGRAM_ATTRIBS_ARB +_m[0x8908] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/gpu_program4.txt # GL_MAX_PROGRAM_ATTRIB_COMPONENTS_NV +_m[0x88F5] = (1,) # GL_MAX_PROGRAM_CALL_DEPTH_NV +_m[0x88B5] = (1,) # GL_MAX_PROGRAM_ENV_PARAMETERS_ARB +_m[0x88F4] = (1,) # GL_MAX_PROGRAM_EXEC_INSTRUCTIONS_NV +_m[0x8DA5] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/gpu_program4.txt # GL_MAX_PROGRAM_GENERIC_ATTRIBS_NV +_m[0x8DA6] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/gpu_program4.txt # GL_MAX_PROGRAM_GENERIC_RESULTS_NV +_m[0x88F6] = (1,) # GL_MAX_PROGRAM_IF_DEPTH_NV +_m[0x88A1] = (1,) # GL_MAX_PROGRAM_INSTRUCTIONS_ARB +_m[0x88B4] = (1,) # GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB +_m[0x88F8] = (1,) # GL_MAX_PROGRAM_LOOP_COUNT_NV +_m[0x88F7] = (1,) # GL_MAX_PROGRAM_LOOP_DEPTH_NV +_m[0x862F] = (1,) # GL_MAX_PROGRAM_MATRICES_ARB +_m[0x862E] = (1,) # GL_MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB +_m[0x88B3] = (1,) # GL_MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB +_m[0x880E] = (1,) # GL_MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB +_m[0x88AF] = (1,) # GL_MAX_PROGRAM_NATIVE_ATTRIBS_ARB +_m[0x88A3] = (1,) # GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB +_m[0x88AB] = (1,) # GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB +_m[0x88A7] = (1,) # GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB +_m[0x8810] = (1,) # GL_MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB +_m[0x880F] = (1,) # GL_MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB +_m[0x8C27] = (1,) # GL_MAX_PROGRAM_OUTPUT_VERTICES_NV +_m[0x88A9] = (1,) # GL_MAX_PROGRAM_PARAMETERS_ARB +_m[0x8DA0] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/parameter_buffer_object.txt # GL_MAX_PROGRAM_PARAMETER_BUFFER_BINDINGS_NV +_m[0x8DA1] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/parameter_buffer_object.txt # GL_MAX_PROGRAM_PARAMETER_BUFFER_SIZE_NV +_m[0x86D8] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/tessellation_program5.txt # GL_MAX_PROGRAM_PATCH_ATTRIBS_NV +_m[0x8909] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/gpu_program4.txt # GL_MAX_PROGRAM_RESULT_COMPONENTS_NV +_m[0x88A5] = (1,) # GL_MAX_PROGRAM_TEMPORARIES_ARB +_m[0x8905] = (1,) # GL_MAX_PROGRAM_TEXEL_OFFSET +_m[0x8F9F] = (1,) # GL_MAX_PROGRAM_TEXTURE_GATHER_COMPONENTS_ARB +_m[0x8E5F] = (1,) # GL_MAX_PROGRAM_TEXTURE_GATHER_OFFSET_ARB +_m[0x8E5F] = (1,) # GL_MAX_PROGRAM_TEXTURE_GATHER_OFFSET_NV +_m[0x880D] = (1,) # GL_MAX_PROGRAM_TEX_INDIRECTIONS_ARB +_m[0x880C] = (1,) # GL_MAX_PROGRAM_TEX_INSTRUCTIONS_ARB +_m[0x8C28] = (1,) # GL_MAX_PROGRAM_TOTAL_OUTPUT_COMPONENTS_NV +_m[0x0D38] = (1,) # GL_MAX_PROJECTION_STACK_DEPTH +_m[0x9329] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_framebuffer_mixed_samples.txt # GL_MAX_RASTER_SAMPLES_EXT +_m[0x86D7] = (1,) # GL_MAX_RATIONAL_EVAL_ORDER_NV +_m[0x84F8] = (1,) # GL_MAX_RECTANGLE_TEXTURE_SIZE +_m[0x84F8] = (1,) # GL_MAX_RECTANGLE_TEXTURE_SIZE_ARB +_m[0x84F8] = (1,) # GL_MAX_RECTANGLE_TEXTURE_SIZE_NV +_m[0x84E8] = (1,) # GL_MAX_RENDERBUFFER_SIZE +_m[0x84E8] = (1,) # GL_MAX_RENDERBUFFER_SIZE_EXT +_m[0x8D57] = (1,) # GL_MAX_SAMPLES +_m[0x8D57] = (1,) # GL_MAX_SAMPLES_EXT +_m[0x9135] = (1,) # GL_MAX_SAMPLES_IMG +_m[0x8E59] = (1,) # GL_MAX_SAMPLE_MASK_WORDS +_m[0x8E59] = (1,) # GL_MAX_SAMPLE_MASK_WORDS_NV +_m[0x9111] = (1,) # GL_MAX_SERVER_WAIT_TIMEOUT +_m[0x9650] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/EXT/EXT_shader_pixel_local_storage2.txt # GL_MAX_SHADER_COMBINED_LOCAL_STORAGE_FAST_SIZE_EXT +_m[0x9651] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/EXT/EXT_shader_pixel_local_storage2.txt # GL_MAX_SHADER_COMBINED_LOCAL_STORAGE_SIZE_EXT +_m[0x91B0] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/ARB/ARB_parallel_shader_compile.txt # GL_MAX_SHADER_COMPILER_THREADS_ARB +_m[0x91B0] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/KHR/KHR_parallel_shader_compile.txt # GL_MAX_SHADER_COMPILER_THREADS_KHR +_m[0x8F63] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/EXT/EXT_shader_pixel_local_storage.txt # GL_MAX_SHADER_PIXEL_LOCAL_STORAGE_FAST_SIZE_EXT +_m[0x8F67] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/EXT/EXT_shader_pixel_local_storage.txt # GL_MAX_SHADER_PIXEL_LOCAL_STORAGE_SIZE_EXT +_m[0x90DE] = (1,) # GL_MAX_SHADER_STORAGE_BLOCK_SIZE +_m[0x90DD] = (1,) # GL_MAX_SHADER_STORAGE_BUFFER_BINDINGS +_m[0x8FA1] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/QCOM/QCOM_texture_foveated_subsampled_layout.txt # GL_MAX_SHADER_SUBSAMPLED_IMAGE_UNITS_QCOM +_m[0x8504] = (1,) # GL_MAX_SHININESS_NV +_m[0x9199] = (1,)#TODO Review http://www.opengl.org/registry/specs//AMD/sparse_texture.txt # GL_MAX_SPARSE_3D_TEXTURE_SIZE_AMD +_m[0x9199] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/sparse_texture.txt # GL_MAX_SPARSE_3D_TEXTURE_SIZE_ARB +_m[0x9199] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/EXT/EXT_sparse_texture.txt # GL_MAX_SPARSE_3D_TEXTURE_SIZE_EXT +_m[0x919A] = (1,) # GL_MAX_SPARSE_ARRAY_TEXTURE_LAYERS +_m[0x9198] = (1,)#TODO Review http://www.opengl.org/registry/specs//AMD/sparse_texture.txt # GL_MAX_SPARSE_TEXTURE_SIZE_AMD +_m[0x9198] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/sparse_texture.txt # GL_MAX_SPARSE_TEXTURE_SIZE_ARB +_m[0x9198] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/EXT/EXT_sparse_texture.txt # GL_MAX_SPARSE_TEXTURE_SIZE_EXT +_m[0x8505] = (1,) # GL_MAX_SPOT_EXPONENT_NV +_m[0x9349] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_conservative_raster.txt # GL_MAX_SUBPIXEL_PRECISION_BIAS_BITS_NV +_m[0x8DE7] = (1,) # GL_MAX_SUBROUTINES +_m[0x8DE8] = (1,) # GL_MAX_SUBROUTINE_UNIFORM_LOCATIONS +_m[0x8E6D] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_MAX_TASK_ATOMIC_COUNTERS_NV +_m[0x8E6C] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_MAX_TASK_ATOMIC_COUNTER_BUFFERS_NV +_m[0x8E6A] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_MAX_TASK_IMAGE_UNIFORMS_NV +_m[0x953A] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_MAX_TASK_OUTPUT_COUNT_NV +_m[0x8E6E] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_MAX_TASK_SHADER_STORAGE_BLOCKS_NV +_m[0x8E69] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_MAX_TASK_TEXTURE_IMAGE_UNITS_NV +_m[0x9537] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_MAX_TASK_TOTAL_MEMORY_SIZE_NV +_m[0x8E68] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_MAX_TASK_UNIFORM_BLOCKS_NV +_m[0x8E6B] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_MAX_TASK_UNIFORM_COMPONENTS_NV +_m[0x95A3] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_MAX_TASK_WORK_GROUP_INVOCATIONS_NV +_m[0x953C] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_MAX_TASK_WORK_GROUP_SIZE_NV +_m[0x92D3] = (1,) # GL_MAX_TESS_CONTROL_ATOMIC_COUNTERS +_m[0x92CD] = (1,) # GL_MAX_TESS_CONTROL_ATOMIC_COUNTER_BUFFERS +_m[0x90CB] = (1,) # GL_MAX_TESS_CONTROL_IMAGE_UNIFORMS +_m[0x886C] = (1,) # GL_MAX_TESS_CONTROL_INPUT_COMPONENTS +_m[0x8E83] = (1,) # GL_MAX_TESS_CONTROL_OUTPUT_COMPONENTS +_m[0x90D8] = (1,) # GL_MAX_TESS_CONTROL_SHADER_STORAGE_BLOCKS +_m[0x8E81] = (1,) # GL_MAX_TESS_CONTROL_TEXTURE_IMAGE_UNITS +_m[0x8E85] = (1,) # GL_MAX_TESS_CONTROL_TOTAL_OUTPUT_COMPONENTS +_m[0x8E89] = (1,) # GL_MAX_TESS_CONTROL_UNIFORM_BLOCKS +_m[0x8E7F] = (1,) # GL_MAX_TESS_CONTROL_UNIFORM_COMPONENTS +_m[0x92D4] = (1,) # GL_MAX_TESS_EVALUATION_ATOMIC_COUNTERS +_m[0x92CE] = (1,) # GL_MAX_TESS_EVALUATION_ATOMIC_COUNTER_BUFFERS +_m[0x90CC] = (1,) # GL_MAX_TESS_EVALUATION_IMAGE_UNIFORMS +_m[0x886D] = (1,) # GL_MAX_TESS_EVALUATION_INPUT_COMPONENTS +_m[0x8E86] = (1,) # GL_MAX_TESS_EVALUATION_OUTPUT_COMPONENTS +_m[0x90D9] = (1,) # GL_MAX_TESS_EVALUATION_SHADER_STORAGE_BLOCKS +_m[0x8E82] = (1,) # GL_MAX_TESS_EVALUATION_TEXTURE_IMAGE_UNITS +_m[0x8E8A] = (1,) # GL_MAX_TESS_EVALUATION_UNIFORM_BLOCKS +_m[0x8E80] = (1,) # GL_MAX_TESS_EVALUATION_UNIFORM_COMPONENTS +_m[0x8E7E] = (1,) # GL_MAX_TESS_GEN_LEVEL +_m[0x8E84] = (1,) # GL_MAX_TESS_PATCH_COMPONENTS +_m[0x8C2B] = (1,) # GL_MAX_TEXTURE_BUFFER_SIZE +_m[0x8C2B] = (1,) # GL_MAX_TEXTURE_BUFFER_SIZE_ARB +_m[0x8C2B] = (1,) # GL_MAX_TEXTURE_BUFFER_SIZE_EXT +_m[0x8871] = (1,) # GL_MAX_TEXTURE_COORDS +_m[0x8871] = (1,) # GL_MAX_TEXTURE_COORDS_ARB +_m[0x8871] = (1,) # GL_MAX_TEXTURE_COORDS_NV +_m[0x8872] = (1,) # GL_MAX_TEXTURE_IMAGE_UNITS +_m[0x8872] = (1,) # GL_MAX_TEXTURE_IMAGE_UNITS_ARB +_m[0x8872] = (1,) # GL_MAX_TEXTURE_IMAGE_UNITS_NV +_m[0x84FD] = (1,) # GL_MAX_TEXTURE_LOD_BIAS +_m[0x84FD] = (1,) # GL_MAX_TEXTURE_LOD_BIAS_EXT +_m[0x84FF] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/ARB/ARB_texture_filter_anisotropic.txt # GL_MAX_TEXTURE_MAX_ANISOTROPY +_m[0x84FF] = (1,) # GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT +_m[0x0D33] = (1,) # GL_MAX_TEXTURE_SIZE +_m[0x0D39] = (1,) # GL_MAX_TEXTURE_STACK_DEPTH +_m[0x84E2] = (1,) # GL_MAX_TEXTURE_UNITS +_m[0x84E2] = (1,) # GL_MAX_TEXTURE_UNITS_ARB +_m[0x862F] = (1,) # GL_MAX_TRACK_MATRICES_NV +_m[0x862E] = (1,) # GL_MAX_TRACK_MATRIX_STACK_DEPTH_NV +_m[0x8E70] = (1,) # GL_MAX_TRANSFORM_FEEDBACK_BUFFERS +_m[0x8C8A] = (1,) # GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS +_m[0x8C8B] = (1,) # GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS +_m[0x8C80] = (1,) # GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS +_m[0x8A30] = (1,) # GL_MAX_UNIFORM_BLOCK_SIZE +_m[0x8A2F] = (1,) # GL_MAX_UNIFORM_BUFFER_BINDINGS +_m[0x826E] = (1,) # GL_MAX_UNIFORM_LOCATIONS +_m[0x8B4B] = (1,) # GL_MAX_VARYING_COMPONENTS +_m[0x8B4B] = (1,) # GL_MAX_VARYING_COMPONENTS_EXT +_m[0x8B4B] = (1,) # GL_MAX_VARYING_FLOATS +_m[0x8B4B] = (1,) # GL_MAX_VARYING_FLOATS_ARB +_m[0x8DFC] = (1,) # GL_MAX_VARYING_VECTORS +_m[0x8520] = (1,) # GL_MAX_VERTEX_ARRAY_RANGE_ELEMENT_NV +_m[0x92D2] = (1,) # GL_MAX_VERTEX_ATOMIC_COUNTERS +_m[0x92CC] = (1,) # GL_MAX_VERTEX_ATOMIC_COUNTER_BUFFERS +_m[0x8869] = (1,) # GL_MAX_VERTEX_ATTRIBS +_m[0x8869] = (1,) # GL_MAX_VERTEX_ATTRIBS_ARB +_m[0x82DA] = (1,) # GL_MAX_VERTEX_ATTRIB_BINDINGS +_m[0x82D9] = (1,) # GL_MAX_VERTEX_ATTRIB_RELATIVE_OFFSET +_m[0x8DE2] = (1,) # GL_MAX_VERTEX_BINDABLE_UNIFORMS_EXT +_m[0x90CA] = (1,) # GL_MAX_VERTEX_IMAGE_UNIFORMS +_m[0x9122] = (1,) # GL_MAX_VERTEX_OUTPUT_COMPONENTS +_m[0x87C5] = (1,) # GL_MAX_VERTEX_SHADER_INSTRUCTIONS_EXT +_m[0x87C7] = (1,) # GL_MAX_VERTEX_SHADER_INVARIANTS_EXT +_m[0x87C9] = (1,) # GL_MAX_VERTEX_SHADER_LOCALS_EXT +_m[0x87C8] = (1,) # GL_MAX_VERTEX_SHADER_LOCAL_CONSTANTS_EXT +_m[0x90D6] = (1,) # GL_MAX_VERTEX_SHADER_STORAGE_BLOCKS +_m[0x87C6] = (1,) # GL_MAX_VERTEX_SHADER_VARIANTS_EXT +_m[0x8E71] = (1,) # GL_MAX_VERTEX_STREAMS +_m[0x876B] = (1,) # GL_MAX_VERTEX_STREAMS_ATI +_m[0x8B4C] = (1,) # GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS +_m[0x8B4C] = (1,) # GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB +_m[0x8A2B] = (1,) # GL_MAX_VERTEX_UNIFORM_BLOCKS +_m[0x8B4A] = (1,) # GL_MAX_VERTEX_UNIFORM_COMPONENTS +_m[0x8B4A] = (1,) # GL_MAX_VERTEX_UNIFORM_COMPONENTS_ARB +_m[0x8DFB] = (1,) # GL_MAX_VERTEX_UNIFORM_VECTORS +_m[0x86A4] = (1,) # GL_MAX_VERTEX_UNITS_ARB +_m[0x86A4] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/OES/OES_matrix_palette.txt # GL_MAX_VERTEX_UNITS_OES +_m[0x8DDE] = (1,) # GL_MAX_VERTEX_VARYING_COMPONENTS_ARB +_m[0x8DDE] = (1,) # GL_MAX_VERTEX_VARYING_COMPONENTS_EXT +_m[0x825B] = (1,) # GL_MAX_VIEWPORTS +_m[0x0D3A] = (2,) # GL_MAX_VIEWPORT_DIMS +_m[0x9631] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/OVR/OVR_multiview.txt # GL_MAX_VIEWS_OVR +_m[0x827E] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_MAX_WIDTH +_m[0x8F14] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/EXT/EXT_window_rectangles.txt # GL_MAX_WINDOW_RECTANGLES_EXT +_m[0x9543] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_MESH_OUTPUT_PER_PRIMITIVE_GRANULARITY_NV +_m[0x92DF] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_MESH_OUTPUT_PER_VERTEX_GRANULARITY_NV +_m[0x957B] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_MESH_OUTPUT_TYPE_NV +_m[0x957A] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_MESH_PRIMITIVES_OUT_NV +_m[0x9579] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_MESH_VERTICES_OUT_NV +_m[0x953E] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_MESH_WORK_GROUP_SIZE_NV +_m[0x802E] = (1,) # GL_MINMAX +_m[0x802E] = (1,) # GL_MINMAX_EXT +_m[0x802F] = (1,) # GL_MINMAX_FORMAT +_m[0x802F] = (1,) # GL_MINMAX_FORMAT_EXT +_m[0x8030] = (1,) # GL_MINMAX_SINK +_m[0x8030] = (1,) # GL_MINMAX_SINK_EXT +_m[0x821C] = (1,) # GL_MINOR_VERSION +_m[0x8E5B] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/gpu_shader5.txt # GL_MIN_FRAGMENT_INTERPOLATION_OFFSET +_m[0x8E5B] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/gpu_program5.txt # GL_MIN_FRAGMENT_INTERPOLATION_OFFSET_NV +_m[0x90BC] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/map_buffer_alignment.txt # GL_MIN_MAP_BUFFER_ALIGNMENT +_m[0x8904] = (1,) # GL_MIN_PROGRAM_TEXEL_OFFSET +_m[0x8E5E] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/texture_gather.txt # GL_MIN_PROGRAM_TEXTURE_GATHER_OFFSET_ARB +_m[0x8E5E] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/gpu_program5.txt # GL_MIN_PROGRAM_TEXTURE_GATHER_OFFSET_NV +_m[0x8C37] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/sample_shading.txt # GL_MIN_SAMPLE_SHADING_VALUE_ARB +_m[0x8C37] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/OES/OES_sample_shading.txt # GL_MIN_SAMPLE_SHADING_VALUE_OES +_m[0x919B] = (1,)#TODO Review http://www.opengl.org/registry/specs//AMD/sparse_texture.txt # GL_MIN_SPARSE_LEVEL_AMD +_m[0x8293] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_MIPMAP +_m[0x932F] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_framebuffer_mixed_samples.txt # GL_MIXED_DEPTH_SAMPLES_SUPPORTED_NV +_m[0x9330] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_framebuffer_mixed_samples.txt # GL_MIXED_STENCIL_SAMPLES_SUPPORTED_NV +_m[0x0BA6] = (4,4) # GL_MODELVIEW0_MATRIX_EXT +_m[0x0BA3] = (1,) # GL_MODELVIEW0_STACK_DEPTH_EXT +_m[0x872A] = (4,4) # GL_MODELVIEW10_ARB +_m[0x872B] = (4,4) # GL_MODELVIEW11_ARB +_m[0x872C] = (4,4) # GL_MODELVIEW12_ARB +_m[0x872D] = (4,4) # GL_MODELVIEW13_ARB +_m[0x872E] = (4,4) # GL_MODELVIEW14_ARB +_m[0x872F] = (4,4) # GL_MODELVIEW15_ARB +_m[0x8730] = (4,4) # GL_MODELVIEW16_ARB +_m[0x8731] = (4,4) # GL_MODELVIEW17_ARB +_m[0x8732] = (4,4) # GL_MODELVIEW18_ARB +_m[0x8733] = (4,4) # GL_MODELVIEW19_ARB +_m[0x850A] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/vertex_blend.txt # GL_MODELVIEW1_ARB +_m[0x8506] = (4,4) # GL_MODELVIEW1_MATRIX_EXT +_m[0x8502] = (1,) # GL_MODELVIEW1_STACK_DEPTH_EXT +_m[0x8734] = (4,4) # GL_MODELVIEW20_ARB +_m[0x8735] = (4,4) # GL_MODELVIEW21_ARB +_m[0x8736] = (4,4) # GL_MODELVIEW22_ARB +_m[0x8737] = (4,4) # GL_MODELVIEW23_ARB +_m[0x8738] = (4,4) # GL_MODELVIEW24_ARB +_m[0x8739] = (4,4) # GL_MODELVIEW25_ARB +_m[0x873A] = (4,4) # GL_MODELVIEW26_ARB +_m[0x873B] = (4,4) # GL_MODELVIEW27_ARB +_m[0x873C] = (4,4) # GL_MODELVIEW28_ARB +_m[0x873D] = (4,4) # GL_MODELVIEW29_ARB +_m[0x8722] = (4,4) # GL_MODELVIEW2_ARB +_m[0x873E] = (4,4) # GL_MODELVIEW30_ARB +_m[0x873F] = (4,4) # GL_MODELVIEW31_ARB +_m[0x8723] = (4,4) # GL_MODELVIEW3_ARB +_m[0x8724] = (4,4) # GL_MODELVIEW4_ARB +_m[0x8725] = (4,4) # GL_MODELVIEW5_ARB +_m[0x8726] = (4,4) # GL_MODELVIEW6_ARB +_m[0x8727] = (4,4) # GL_MODELVIEW7_ARB +_m[0x8728] = (4,4) # GL_MODELVIEW8_ARB +_m[0x8729] = (4,4) # GL_MODELVIEW9_ARB +_m[0x0BA6] = (4, 4) # GL_MODELVIEW_MATRIX +_m[0x898D] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/OES/OES_matrix_get.txt # GL_MODELVIEW_MATRIX_FLOAT_AS_INT_BITS_OES +_m[0x0BA3] = (1,) # GL_MODELVIEW_STACK_DEPTH +_m[0x92BA] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_gpu_multicast.txt # GL_MULTICAST_GPUS_NV +_m[0x9549] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_gpu_multicast.txt # GL_MULTICAST_PROGRAMMABLE_SAMPLE_LOCATION_NV +_m[0x809D] = (1,) # GL_MULTISAMPLE +_m[0x9371] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_internalformat_sample_query.txt # GL_MULTISAMPLES_NV +_m[0x86B2] = (1,) # GL_MULTISAMPLE_3DFX +_m[0x809D] = (1,) # GL_MULTISAMPLE_ARB +_m[0x8E12] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/framebuffer_multisample_coverage.txt # GL_MULTISAMPLE_COVERAGE_MODES_NV +_m[0x809D] = (1,) # GL_MULTISAMPLE_EXT +_m[0x8534] = (1,) # GL_MULTISAMPLE_FILTER_HINT_NV +_m[0x9382] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/ARB/ARB_ES3_2_compatibility.txt # GL_MULTISAMPLE_LINE_WIDTH_GRANULARITY_ARB +_m[0x9381] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/ARB/ARB_ES3_2_compatibility.txt # GL_MULTISAMPLE_LINE_WIDTH_RANGE_ARB +_m[0x932B] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_framebuffer_mixed_samples.txt # GL_MULTISAMPLE_RASTERIZATION_ALLOWED_EXT +_m[0x809D] = (1,) # GL_MULTISAMPLE_SGIS +_m[0x8DE9] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/shading_language_include.txt # GL_NAMED_STRING_LENGTH_ARB +_m[0x8DEA] = (1,) # GL_NAMED_STRING_TYPE_ARB +_m[0x92F9] = (1,) # GL_NAME_LENGTH +_m[0x0D70] = (1,) # GL_NAME_STACK_DEPTH +_m[0x9025] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/video_capture.txt # GL_NEXT_VIDEO_CAPTURE_BUFFER_STATUS_NV +_m[0x0BA1] = (1,) # GL_NORMALIZE +_m[0x8075] = (1,) # GL_NORMAL_ARRAY +_m[0x8897] = (1,) # GL_NORMAL_ARRAY_BUFFER_BINDING +_m[0x8897] = (1,) # GL_NORMAL_ARRAY_BUFFER_BINDING_ARB +_m[0x8080] = (1,) # GL_NORMAL_ARRAY_COUNT_EXT +_m[0x8075] = (1,) # GL_NORMAL_ARRAY_EXT +_m[0x8F2C] = (1,) # GL_NORMAL_ARRAY_LENGTH_NV +_m[0x83F6] = (1,)#TODO Review http://www.opengl.org/registry/specs//INTEL/parallel_arrays.txt # GL_NORMAL_ARRAY_PARALLEL_POINTERS_INTEL +_m[0x808F] = (1,) # GL_NORMAL_ARRAY_POINTER +_m[0x807F] = (1,) # GL_NORMAL_ARRAY_STRIDE +_m[0x807F] = (1,) # GL_NORMAL_ARRAY_STRIDE_EXT +_m[0x807E] = (1,) # GL_NORMAL_ARRAY_TYPE +_m[0x807E] = (1,) # GL_NORMAL_ARRAY_TYPE_EXT +_m[0x8261] = (1,)#TODO Review http://www.opengl.org/registry/specs//KHR/robustness.txt # GL_NO_RESET_NOTIFICATION +_m[0x8261] = (1,) # GL_NO_RESET_NOTIFICATION_ARB +_m[0x9304] = (1,) # GL_NUM_ACTIVE_VARIABLES +_m[0x8E4A] = (1,) # GL_NUM_COMPATIBLE_SUBROUTINES +_m[0x86A2] = (1,) # GL_NUM_COMPRESSED_TEXTURE_FORMATS +_m[0x86A2] = (1,) # GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB +_m[0x913D] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/IMG/IMG_framebuffer_downsample.txt # GL_NUM_DOWNSAMPLE_SCALES_IMG +_m[0x821D] = (1,) # GL_NUM_EXTENSIONS +_m[0x8E29] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/present_video.txt # GL_NUM_FILL_STREAMS_NV +_m[0x896F] = (1,) # GL_NUM_FRAGMENT_CONSTANTS_ATI +_m[0x896E] = (1,) # GL_NUM_FRAGMENT_REGISTERS_ATI +_m[0x854E] = (1,) # GL_NUM_GENERAL_COMBINERS_NV +_m[0x8973] = (1,) # GL_NUM_INPUT_INTERPOLATOR_COMPONENTS_ATI +_m[0x8971] = (1,) # GL_NUM_INSTRUCTIONS_PER_PASS_ATI +_m[0x8972] = (1,) # GL_NUM_INSTRUCTIONS_TOTAL_ATI +_m[0x8974] = (1,) # GL_NUM_LOOPBACK_COMPONENTS_ATI +_m[0x8970] = (1,) # GL_NUM_PASSES_ATI +_m[0x87FE] = (1,) # GL_NUM_PROGRAM_BINARY_FORMATS +_m[0x9380] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query.txt # GL_NUM_SAMPLE_COUNTS +_m[0x8DF9] = (1,) # GL_NUM_SHADER_BINARY_FORMATS +_m[0x91AA] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/sparse_texture.txt # GL_NUM_SPARSE_LEVELS_ARB +_m[0x91AA] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/EXT/EXT_sparse_texture.txt # GL_NUM_SPARSE_LEVELS_EXT +_m[0x9554] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/ARB/ARB_spirv_extensions.txt # GL_NUM_SPIR_V_EXTENSIONS +_m[0x91B6] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/AMD/AMD_framebuffer_multisample_advanced.txt # GL_NUM_SUPPORTED_MULTISAMPLE_MODES_AMD +_m[0x9024] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/video_capture.txt # GL_NUM_VIDEO_CAPTURE_STREAMS_NV +_m[0x8F15] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/EXT/EXT_window_rectangles.txt # GL_NUM_WINDOW_RECTANGLES_EXT +_m[0x8B86] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/shader_objects.txt # GL_OBJECT_ACTIVE_UNIFORMS_ARB +_m[0x8B87] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/shader_objects.txt # GL_OBJECT_ACTIVE_UNIFORM_MAX_LENGTH_ARB +_m[0x8B85] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/shader_objects.txt # GL_OBJECT_ATTACHED_OBJECTS_ARB +_m[0x8764] = (1,) # GL_OBJECT_BUFFER_SIZE_ATI +_m[0x8765] = (4,) # GL_OBJECT_BUFFER_USAGE_ATI +_m[0x8B81] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/shader_objects.txt # GL_OBJECT_COMPILE_STATUS_ARB +_m[0x8B80] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/shader_objects.txt # GL_OBJECT_DELETE_STATUS_ARB +_m[0x8B84] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/shader_objects.txt # GL_OBJECT_INFO_LOG_LENGTH_ARB +_m[0x81F7] = (7,) # GL_OBJECT_LINE_SGIS +_m[0x8B82] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/shader_objects.txt # GL_OBJECT_LINK_STATUS_ARB +_m[0x2501] = (4,) # GL_OBJECT_PLANE +_m[0x81F5] = (4,) # GL_OBJECT_POINT_SGIS +_m[0x8B88] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/shader_objects.txt # GL_OBJECT_SHADER_SOURCE_LENGTH_ARB +_m[0x8B4F] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/shader_objects.txt # GL_OBJECT_SUBTYPE_ARB +_m[0x9112] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/sync.txt # GL_OBJECT_TYPE +_m[0x8B4E] = (1,) # GL_OBJECT_TYPE_ARB +_m[0x8B83] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/shader_objects.txt # GL_OBJECT_VALIDATE_STATUS_ARB +_m[0x8165] = (1,) # GL_OCCLUSION_TEST_HP +_m[0x8166] = (1,) # GL_OCCLUSION_TEST_RESULT_HP +_m[0x92FC] = (1,) # GL_OFFSET +_m[0x86E3] = (1,) # GL_OFFSET_TEXTURE_BIAS_NV +_m[0x86E1] = (4,) # GL_OFFSET_TEXTURE_MATRIX_NV +_m[0x86E2] = (1,) # GL_OFFSET_TEXTURE_SCALE_NV +_m[0x8598] = (1,) # GL_OPERAND0_ALPHA +_m[0x8590] = (1,) # GL_OPERAND0_RGB +_m[0x8599] = (1,) # GL_OPERAND1_ALPHA +_m[0x8591] = (1,) # GL_OPERAND1_RGB +_m[0x859A] = (1,) # GL_OPERAND2_ALPHA +_m[0x8592] = (1,) # GL_OPERAND2_RGB +_m[0x859B] = (1,) # GL_OPERAND3_ALPHA_NV +_m[0x8593] = (1,) # GL_OPERAND3_RGB_NV +_m[0x0D05] = (1,) # GL_PACK_ALIGNMENT +_m[0x800E] = (1,) # GL_PACK_CMYK_HINT_EXT +_m[0x912D] = (1,) # GL_PACK_COMPRESSED_BLOCK_DEPTH +_m[0x912C] = (1,) # GL_PACK_COMPRESSED_BLOCK_HEIGHT +_m[0x912E] = (1,) # GL_PACK_COMPRESSED_BLOCK_SIZE +_m[0x912B] = (1,) # GL_PACK_COMPRESSED_BLOCK_WIDTH +_m[0x8131] = (1,) # GL_PACK_IMAGE_DEPTH_SGIS +_m[0x806C] = (1,) # GL_PACK_IMAGE_HEIGHT +_m[0x806C] = (1,) # GL_PACK_IMAGE_HEIGHT_EXT +_m[0x8758] = (1,) # GL_PACK_INVERT_MESA +_m[0x0D01] = (1,) # GL_PACK_LSB_FIRST +_m[0x8984] = (1,) # GL_PACK_RESAMPLE_OML +_m[0x842E] = (1,) # GL_PACK_RESAMPLE_SGIX +_m[0x93A4] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/ANGLE/ANGLE_pack_reverse_row_order.txt # GL_PACK_REVERSE_ROW_ORDER_ANGLE +_m[0x8A15] = (1,) # GL_PACK_ROW_BYTES_APPLE +_m[0x0D02] = (1,) # GL_PACK_ROW_LENGTH +_m[0x806B] = (1,) # GL_PACK_SKIP_IMAGES +_m[0x806B] = (1,) # GL_PACK_SKIP_IMAGES_EXT +_m[0x0D04] = (1,) # GL_PACK_SKIP_PIXELS +_m[0x0D03] = (1,) # GL_PACK_SKIP_ROWS +_m[0x8130] = (1,) # GL_PACK_SKIP_VOLUMES_SGIS +_m[0x0D00] = (1,) # GL_PACK_SWAP_BYTES +_m[0x83F4] = (1,) # GL_PARALLEL_ARRAYS_INTEL +_m[0x80EF] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/indirect_parameters.txt # GL_PARAMETER_BUFFER_BINDING_ARB +_m[0x8E73] = (1,) # GL_PATCH_DEFAULT_INNER_LEVEL +_m[0x8E74] = (1,) # GL_PATCH_DEFAULT_OUTER_LEVEL +_m[0x8E72] = (1,) # GL_PATCH_VERTICES +_m[0x909D] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/path_rendering.txt # GL_PATH_COMMAND_COUNT_NV +_m[0x90A0] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/path_rendering.txt # GL_PATH_COMPUTED_LENGTH_NV +_m[0x909E] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/path_rendering.txt # GL_PATH_COORD_COUNT_NV +_m[0x90BF] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/path_rendering.txt # GL_PATH_COVER_DEPTH_FUNC_NV +_m[0x909F] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/path_rendering.txt # GL_PATH_DASH_ARRAY_COUNT_NV +_m[0x90AB] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/path_rendering.txt # GL_PATH_ERROR_POSITION_NV +_m[0x90A1] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/path_rendering.txt # GL_PATH_FILL_BOUNDING_BOX_NV +_m[0x90AC] = (1,) # GL_PATH_FOG_GEN_MODE_NV +_m[0x90B1] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/path_rendering.txt # GL_PATH_GEN_COEFF_NV +_m[0x90B2] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/path_rendering.txt # GL_PATH_GEN_COLOR_FORMAT_NV +_m[0x90B3] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/path_rendering.txt # GL_PATH_GEN_COMPONENTS_NV +_m[0x90B0] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/path_rendering.txt # GL_PATH_GEN_MODE_NV +_m[0x90BD] = (1,) # GL_PATH_STENCIL_DEPTH_OFFSET_FACTOR_NV +_m[0x90BE] = (1,) # GL_PATH_STENCIL_DEPTH_OFFSET_UNITS_NV +_m[0x90B7] = (1,) # GL_PATH_STENCIL_FUNC_NV +_m[0x90B8] = (1,) # GL_PATH_STENCIL_REF_NV +_m[0x90B9] = (1,) # GL_PATH_STENCIL_VALUE_MASK_NV +_m[0x90A2] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/path_rendering.txt # GL_PATH_STROKE_BOUNDING_BOX_NV +_m[0x8BC6] = (1,)#TODO Review http://www.opengl.org/registry/specs//AMD/performance_monitor.txt # GL_PERFMON_RESULT_AMD +_m[0x8BC4] = (1,)#TODO Review http://www.opengl.org/registry/specs//AMD/performance_monitor.txt # GL_PERFMON_RESULT_AVAILABLE_AMD +_m[0x8BC5] = (1,)#TODO Review http://www.opengl.org/registry/specs//AMD/performance_monitor.txt # GL_PERFMON_RESULT_SIZE_AMD +_m[0x94FF] = (1,)#TODO Review http://www.opengl.org/registry/specs//INTEL/performance_query.txt # GL_PERFQUERY_COUNTER_DESC_LENGTH_MAX_INTEL +_m[0x94FE] = (1,)#TODO Review http://www.opengl.org/registry/specs//INTEL/performance_query.txt # GL_PERFQUERY_COUNTER_NAME_LENGTH_MAX_INTEL +_m[0x9500] = (1,)#TODO Review http://www.opengl.org/registry/specs//INTEL/performance_query.txt # GL_PERFQUERY_GPA_EXTENDED_COUNTERS_INTEL +_m[0x94FD] = (1,)#TODO Review http://www.opengl.org/registry/specs//INTEL/performance_query.txt # GL_PERFQUERY_QUERY_NAME_LENGTH_MAX_INTEL +_m[0x0C50] = (1,) # GL_PERSPECTIVE_CORRECTION_HINT +_m[0x8535] = (1,) # GL_PER_STAGE_CONSTANTS_NV +_m[0x91AE] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/AMD/AMD_framebuffer_sample_positions.txt # GL_PIXELS_PER_SAMPLE_PATTERN_X_AMD +_m[0x91AF] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/AMD/AMD_framebuffer_sample_positions.txt # GL_PIXELS_PER_SAMPLE_PATTERN_Y_AMD +_m[0x8864] = (1,) # GL_PIXEL_COUNTER_BITS_NV +_m[0x8867] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/occlusion_query.txt # GL_PIXEL_COUNT_AVAILABLE_NV +_m[0x8866] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/occlusion_query.txt # GL_PIXEL_COUNT_NV +_m[0x8355] = (1,) # GL_PIXEL_FRAGMENT_ALPHA_SOURCE_SGIS +_m[0x8354] = (1,) # GL_PIXEL_FRAGMENT_RGB_SOURCE_SGIS +_m[0x8356] = (1,) # GL_PIXEL_GROUP_COLOR_SGIS +_m[0x0C79] = (_L(0xCB9),) # GL_PIXEL_MAP_A_TO_A +_m[0x0CB9] = (1,) # GL_PIXEL_MAP_A_TO_A_SIZE +_m[0x0C78] = (_L(0xCB8),) # GL_PIXEL_MAP_B_TO_B +_m[0x0CB8] = (1,) # GL_PIXEL_MAP_B_TO_B_SIZE +_m[0x0C77] = (_L(0xCB7),) # GL_PIXEL_MAP_G_TO_G +_m[0x0CB7] = (1,) # GL_PIXEL_MAP_G_TO_G_SIZE +_m[0x0C75] = (_L(0xCB5),) # GL_PIXEL_MAP_I_TO_A +_m[0x0CB5] = (1,) # GL_PIXEL_MAP_I_TO_A_SIZE +_m[0x0C74] = (_L(0xCB4),) # GL_PIXEL_MAP_I_TO_B +_m[0x0CB4] = (1,) # GL_PIXEL_MAP_I_TO_B_SIZE +_m[0x0C73] = (_L(0xCB3),) # GL_PIXEL_MAP_I_TO_G +_m[0x0CB3] = (1,) # GL_PIXEL_MAP_I_TO_G_SIZE +_m[0x0C70] = (_L(0xCB0),) # GL_PIXEL_MAP_I_TO_I +_m[0x0CB0] = (1,) # GL_PIXEL_MAP_I_TO_I_SIZE +_m[0x0C72] = (_L(0xCB2),) # GL_PIXEL_MAP_I_TO_R +_m[0x0CB2] = (1,) # GL_PIXEL_MAP_I_TO_R_SIZE +_m[0x0C76] = (_L(0xCB6),) # GL_PIXEL_MAP_R_TO_R +_m[0x0CB6] = (1,) # GL_PIXEL_MAP_R_TO_R_SIZE +_m[0x0C71] = (_L(0xCB1),) # GL_PIXEL_MAP_S_TO_S +_m[0x0CB1] = (1,) # GL_PIXEL_MAP_S_TO_S_SIZE +_m[0x88ED] = (1,) # GL_PIXEL_PACK_BUFFER_BINDING +_m[0x88ED] = (1,) # GL_PIXEL_PACK_BUFFER_BINDING_ARB +_m[0x88ED] = (1,) # GL_PIXEL_PACK_BUFFER_BINDING_EXT +_m[0x8353] = (1,) # GL_PIXEL_TEXTURE_SGIS +_m[0x832B] = (1,) # GL_PIXEL_TEX_GEN_MODE_SGIX +_m[0x8139] = (1,) # GL_PIXEL_TEX_GEN_SGIX +_m[0x813E] = (1,) # GL_PIXEL_TILE_BEST_ALIGNMENT_SGIX +_m[0x813F] = (1,) # GL_PIXEL_TILE_CACHE_INCREMENT_SGIX +_m[0x8145] = (1,) # GL_PIXEL_TILE_CACHE_SIZE_SGIX +_m[0x8144] = (1,) # GL_PIXEL_TILE_GRID_DEPTH_SGIX +_m[0x8143] = (1,) # GL_PIXEL_TILE_GRID_HEIGHT_SGIX +_m[0x8142] = (1,) # GL_PIXEL_TILE_GRID_WIDTH_SGIX +_m[0x8141] = (1,) # GL_PIXEL_TILE_HEIGHT_SGIX +_m[0x8140] = (1,) # GL_PIXEL_TILE_WIDTH_SGIX +_m[0x8338] = (1,)#TODO Review http://www.opengl.org/registry/specs//EXT/pixel_transform.txt # GL_PIXEL_TRANSFORM_2D_MATRIX_EXT +_m[0x8336] = (1,) # GL_PIXEL_TRANSFORM_2D_STACK_DEPTH_EXT +_m[0x88EF] = (1,) # GL_PIXEL_UNPACK_BUFFER_BINDING +_m[0x88EF] = (1,) # GL_PIXEL_UNPACK_BUFFER_BINDING_ARB +_m[0x88EF] = (1,) # GL_PIXEL_UNPACK_BUFFER_BINDING_EXT +_m[0x87F3] = (1,) # GL_PN_TRIANGLES_NORMAL_MODE_ATI +_m[0x87F2] = (1,) # GL_PN_TRIANGLES_POINT_MODE_ATI +_m[0x87F4] = (1,) # GL_PN_TRIANGLES_TESSELATION_LEVEL_ATI +_m[0x8129] = (3,) # GL_POINT_DISTANCE_ATTENUATION +_m[0x8129] = (3,) # GL_POINT_DISTANCE_ATTENUATION_ARB +_m[0x8128] = (1,) # GL_POINT_FADE_THRESHOLD_SIZE +_m[0x8128] = (1,) # GL_POINT_FADE_THRESHOLD_SIZE_ARB +_m[0x8128] = (1,) # GL_POINT_FADE_THRESHOLD_SIZE_SGIS +_m[0x1B00] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_polygon_mode.txt # GL_POINT_NV +_m[0x0B11] = (1,) # GL_POINT_SIZE +_m[0x8B9F] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/OES/OES_point_size_array.txt # GL_POINT_SIZE_ARRAY_BUFFER_BINDING_OES +_m[0x898C] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/OES/OES_point_size_array.txt # GL_POINT_SIZE_ARRAY_POINTER_OES +_m[0x898B] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/OES/OES_point_size_array.txt # GL_POINT_SIZE_ARRAY_STRIDE_OES +_m[0x898A] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/OES/OES_point_size_array.txt # GL_POINT_SIZE_ARRAY_TYPE_OES +_m[0x0B13] = (1,) # GL_POINT_SIZE_GRANULARITY +_m[0x8127] = (1,) # GL_POINT_SIZE_MAX +_m[0x8127] = (1,) # GL_POINT_SIZE_MAX_ARB +_m[0x8127] = (1,) # GL_POINT_SIZE_MAX_SGIS +_m[0x8126] = (1,) # GL_POINT_SIZE_MIN +_m[0x8126] = (1,) # GL_POINT_SIZE_MIN_ARB +_m[0x8126] = (1,) # GL_POINT_SIZE_MIN_SGIS +_m[0x0B12] = (2,) # GL_POINT_SIZE_RANGE +_m[0x0B10] = (1,) # GL_POINT_SMOOTH +_m[0x0C51] = (1,) # GL_POINT_SMOOTH_HINT +_m[0x8861] = (1,) # GL_POINT_SPRITE +_m[0x8861] = (1,) # GL_POINT_SPRITE_ARB +_m[0x8CA0] = (1,) # GL_POINT_SPRITE_COORD_ORIGIN +_m[0x8861] = (1,) # GL_POINT_SPRITE_NV +_m[0x8863] = (1,) # GL_POINT_SPRITE_R_MODE_NV +_m[0x0B40] = (2,) # GL_POLYGON_MODE +_m[0x8039] = (1,) # GL_POLYGON_OFFSET_BIAS_EXT +_m[0x8E1B] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/ARB/ARB_polygon_offset_clamp.txt # GL_POLYGON_OFFSET_CLAMP +_m[0x8E1B] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/EXT/EXT_polygon_offset_clamp.txt # GL_POLYGON_OFFSET_CLAMP_EXT +_m[0x8037] = (1,) # GL_POLYGON_OFFSET_EXT +_m[0x8038] = (1,) # GL_POLYGON_OFFSET_FACTOR +_m[0x8038] = (1,) # GL_POLYGON_OFFSET_FACTOR_EXT +_m[0x8037] = (1,) # GL_POLYGON_OFFSET_FILL +_m[0x2A02] = (1,) # GL_POLYGON_OFFSET_LINE +_m[0x2A01] = (1,) # GL_POLYGON_OFFSET_POINT +_m[0x2A00] = (1,) # GL_POLYGON_OFFSET_UNITS +_m[0x0B41] = (1,) # GL_POLYGON_SMOOTH +_m[0x0C53] = (1,) # GL_POLYGON_SMOOTH_HINT +_m[0x0B42] = (1,) # GL_POLYGON_STIPPLE +_m[0x1203] = (4,) # GL_POSITION +_m[0x80BB] = (1,) # GL_POST_COLOR_MATRIX_ALPHA_BIAS +_m[0x80BB] = (1,) # GL_POST_COLOR_MATRIX_ALPHA_BIAS_SGI +_m[0x80B7] = (1,) # GL_POST_COLOR_MATRIX_ALPHA_SCALE +_m[0x80B7] = (1,) # GL_POST_COLOR_MATRIX_ALPHA_SCALE_SGI +_m[0x80BA] = (1,) # GL_POST_COLOR_MATRIX_BLUE_BIAS +_m[0x80BA] = (1,) # GL_POST_COLOR_MATRIX_BLUE_BIAS_SGI +_m[0x80B6] = (1,) # GL_POST_COLOR_MATRIX_BLUE_SCALE +_m[0x80B6] = (1,) # GL_POST_COLOR_MATRIX_BLUE_SCALE_SGI +_m[0x80D2] = (1,) # GL_POST_COLOR_MATRIX_COLOR_TABLE +_m[0x80D2] = (1,) # GL_POST_COLOR_MATRIX_COLOR_TABLE_SGI +_m[0x80B9] = (1,) # GL_POST_COLOR_MATRIX_GREEN_BIAS +_m[0x80B9] = (1,) # GL_POST_COLOR_MATRIX_GREEN_BIAS_SGI +_m[0x80B5] = (1,) # GL_POST_COLOR_MATRIX_GREEN_SCALE +_m[0x80B5] = (1,) # GL_POST_COLOR_MATRIX_GREEN_SCALE_SGI +_m[0x80B8] = (1,) # GL_POST_COLOR_MATRIX_RED_BIAS +_m[0x80B8] = (1,) # GL_POST_COLOR_MATRIX_RED_BIAS_SGI +_m[0x80B4] = (1,) # GL_POST_COLOR_MATRIX_RED_SCALE +_m[0x80B4] = (1,) # GL_POST_COLOR_MATRIX_RED_SCALE_SGI +_m[0x8023] = (1,) # GL_POST_CONVOLUTION_ALPHA_BIAS +_m[0x8023] = (1,) # GL_POST_CONVOLUTION_ALPHA_BIAS_EXT +_m[0x801F] = (1,) # GL_POST_CONVOLUTION_ALPHA_SCALE +_m[0x801F] = (1,) # GL_POST_CONVOLUTION_ALPHA_SCALE_EXT +_m[0x8022] = (1,) # GL_POST_CONVOLUTION_BLUE_BIAS +_m[0x8022] = (1,) # GL_POST_CONVOLUTION_BLUE_BIAS_EXT +_m[0x801E] = (1,) # GL_POST_CONVOLUTION_BLUE_SCALE +_m[0x801E] = (1,) # GL_POST_CONVOLUTION_BLUE_SCALE_EXT +_m[0x80D1] = (1,) # GL_POST_CONVOLUTION_COLOR_TABLE +_m[0x80D1] = (1,) # GL_POST_CONVOLUTION_COLOR_TABLE_SGI +_m[0x8021] = (1,) # GL_POST_CONVOLUTION_GREEN_BIAS +_m[0x8021] = (1,) # GL_POST_CONVOLUTION_GREEN_BIAS_EXT +_m[0x801D] = (1,) # GL_POST_CONVOLUTION_GREEN_SCALE +_m[0x801D] = (1,) # GL_POST_CONVOLUTION_GREEN_SCALE_EXT +_m[0x8020] = (1,) # GL_POST_CONVOLUTION_RED_BIAS +_m[0x8020] = (1,) # GL_POST_CONVOLUTION_RED_BIAS_EXT +_m[0x801C] = (1,) # GL_POST_CONVOLUTION_RED_SCALE +_m[0x801C] = (1,) # GL_POST_CONVOLUTION_RED_SCALE_EXT +_m[0x817B] = (1,) # GL_POST_TEXTURE_FILTER_BIAS_RANGE_SGIX +_m[0x8179] = (1,) # GL_POST_TEXTURE_FILTER_BIAS_SGIX +_m[0x817C] = (1,) # GL_POST_TEXTURE_FILTER_SCALE_RANGE_SGIX +_m[0x817A] = (1,) # GL_POST_TEXTURE_FILTER_SCALE_SGIX +_m[0x86E4] = (1,) # GL_PREVIOUS_TEXTURE_INPUT_NV +_m[0x92BE] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/ARB/ARB_ES3_2_compatibility.txt # GL_PRIMITIVE_BOUNDING_BOX_ARB +_m[0x92BE] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/EXT/EXT_primitive_bounding_box.txt # GL_PRIMITIVE_BOUNDING_BOX_EXT +_m[0x92BE] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/OES/OES_primitive_bounding_box.txt # GL_PRIMITIVE_BOUNDING_BOX_OES +_m[0x8F9D] = (1,) # GL_PRIMITIVE_RESTART +_m[0x8D69] = (1,) # GL_PRIMITIVE_RESTART_FIXED_INDEX +_m[0x8221] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/EXT/EXT_tessellation_shader.txt # GL_PRIMITIVE_RESTART_FOR_PATCHES_SUPPORTED +_m[0x8F9E] = (1,) # GL_PRIMITIVE_RESTART_INDEX +_m[0x8559] = (1,) # GL_PRIMITIVE_RESTART_INDEX_NV +_m[0x8558] = (1,) # GL_PRIMITIVE_RESTART_NV +_m[0x9341] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/ARB/ARB_sample_locations.txt # GL_PROGRAMMABLE_SAMPLE_LOCATION_ARB +_m[0x9341] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_sample_locations.txt # GL_PROGRAMMABLE_SAMPLE_LOCATION_NV +_m[0x9340] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/ARB/ARB_sample_locations.txt # GL_PROGRAMMABLE_SAMPLE_LOCATION_TABLE_SIZE_ARB +_m[0x9340] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_sample_locations.txt # GL_PROGRAMMABLE_SAMPLE_LOCATION_TABLE_SIZE_NV +_m[0x88B0] = (1,) # GL_PROGRAM_ADDRESS_REGISTERS_ARB +_m[0x8805] = (1,) # GL_PROGRAM_ALU_INSTRUCTIONS_ARB +_m[0x88AC] = (1,) # GL_PROGRAM_ATTRIBS_ARB +_m[0x8906] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/gpu_program4.txt # GL_PROGRAM_ATTRIB_COMPONENTS_NV +_m[0x87FF] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/get_program_binary.txt # GL_PROGRAM_BINARY_FORMATS +_m[0x8741] = (1,) # GL_PROGRAM_BINARY_LENGTH +_m[0x8677] = (1,) # GL_PROGRAM_BINDING_ARB +_m[0x864B] = (1,) # GL_PROGRAM_ERROR_POSITION_ARB +_m[0x864B] = (1,) # GL_PROGRAM_ERROR_POSITION_NV +_m[0x8874] = (1,) # GL_PROGRAM_ERROR_STRING_ARB +_m[0x8876] = (1,) # GL_PROGRAM_FORMAT_ARB +_m[0x88A0] = (1,) # GL_PROGRAM_INSTRUCTIONS_ARB +_m[0x8627] = (1,) # GL_PROGRAM_LENGTH_ARB +_m[0x8627] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/vertex_program.txt # GL_PROGRAM_LENGTH_NV +_m[0x8E2D] = (1,)#TODO Review http://www.opengl.org/registry/specs//EXT/direct_state_access.txt # GL_PROGRAM_MATRIX_EXT +_m[0x8E2F] = (1,)#TODO Review http://www.opengl.org/registry/specs//EXT/direct_state_access.txt # GL_PROGRAM_MATRIX_STACK_DEPTH_EXT +_m[0x88B2] = (1,) # GL_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB +_m[0x8808] = (1,) # GL_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB +_m[0x88AE] = (1,) # GL_PROGRAM_NATIVE_ATTRIBS_ARB +_m[0x88A2] = (1,) # GL_PROGRAM_NATIVE_INSTRUCTIONS_ARB +_m[0x88AA] = (1,) # GL_PROGRAM_NATIVE_PARAMETERS_ARB +_m[0x88A6] = (1,) # GL_PROGRAM_NATIVE_TEMPORARIES_ARB +_m[0x880A] = (1,) # GL_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB +_m[0x8809] = (1,) # GL_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB +_m[0x8B40] = (1,) # GL_PROGRAM_OBJECT_ARB +_m[0x88A8] = (1,) # GL_PROGRAM_PARAMETERS_ARB +_m[0x8644] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/vertex_program.txt # GL_PROGRAM_PARAMETER_NV +_m[0x825A] = (1,) # GL_PROGRAM_PIPELINE_BINDING +_m[0x8642] = (1,) # GL_PROGRAM_POINT_SIZE +_m[0x8642] = (1,) # GL_PROGRAM_POINT_SIZE_ARB +_m[0x8642] = (1,) # GL_PROGRAM_POINT_SIZE_EXT +_m[0x8647] = (1,) # GL_PROGRAM_RESIDENT_NV +_m[0x8907] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/gpu_program4.txt # GL_PROGRAM_RESULT_COMPONENTS_NV +_m[0x8628] = (1,) # GL_PROGRAM_STRING_ARB +_m[0x8628] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/vertex_program.txt # GL_PROGRAM_STRING_NV +_m[0x8646] = (1,) # GL_PROGRAM_TARGET_NV +_m[0x88A4] = (1,) # GL_PROGRAM_TEMPORARIES_ARB +_m[0x8807] = (1,) # GL_PROGRAM_TEX_INDIRECTIONS_ARB +_m[0x8806] = (1,) # GL_PROGRAM_TEX_INSTRUCTIONS_ARB +_m[0x88B6] = (1,) # GL_PROGRAM_UNDER_NATIVE_LIMITS_ARB +_m[0x0BA7] = (4, 4) # GL_PROJECTION_MATRIX +_m[0x898E] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/OES/OES_matrix_get.txt # GL_PROJECTION_MATRIX_FLOAT_AS_INT_BITS_OES +_m[0x0BA4] = (1,) # GL_PROJECTION_STACK_DEPTH +_m[0x8E4F] = (1,) # GL_PROVOKING_VERTEX +_m[0x8E4F] = (1,) # GL_PROVOKING_VERTEX_EXT +_m[0x1209] = (1,) # GL_QUADRATIC_ATTENUATION +_m[0x8E4C] = (1,) # GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION +_m[0x8E4C] = (1,) # GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION_EXT +_m[0x9193] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/query_buffer_object.txt # GL_QUERY_BUFFER_BINDING +_m[0x9193] = (1,) # GL_QUERY_BUFFER_BINDING_AMD +_m[0x8864] = (1,) # GL_QUERY_COUNTER_BITS +_m[0x8864] = (1,) # GL_QUERY_COUNTER_BITS_ARB +_m[0x8866] = (1,) # GL_QUERY_RESULT +_m[0x8867] = (1,) # GL_QUERY_RESULT_AVAILABLE +_m[0x9194] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/query_buffer_object.txt # GL_QUERY_RESULT_NO_WAIT +_m[0x82EA] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/direct_state_access.txt # GL_QUERY_TARGET +_m[0x8C89] = (1,) # GL_RASTERIZER_DISCARD +_m[0x932A] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_framebuffer_mixed_samples.txt # GL_RASTER_FIXED_SAMPLE_LOCATIONS_EXT +_m[0x19262] = (1,) # GL_RASTER_POSITION_UNCLIPPED_IBM +_m[0x9328] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_framebuffer_mixed_samples.txt # GL_RASTER_SAMPLES_EXT +_m[0x0C02] = (1,) # GL_READ_BUFFER +_m[0x0C02] = (1,) # GL_READ_BUFFER_EXT +_m[0x0C02] = (1,) # GL_READ_BUFFER_NV +_m[0x8CA8] = (1,) # GL_READ_FRAMEBUFFER +_m[0x8CAA] = (1,) # GL_READ_FRAMEBUFFER_BINDING +_m[0x828C] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_READ_PIXELS +_m[0x828D] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_READ_PIXELS_FORMAT +_m[0x828E] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_READ_PIXELS_TYPE +_m[0x887B] = (1,) # GL_READ_PIXEL_DATA_RANGE_LENGTH_NV +_m[0x887D] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/pixel_data_range.txt # GL_READ_PIXEL_DATA_RANGE_POINTER_NV +_m[0x0D15] = (1,) # GL_RED_BIAS +_m[0x0D52] = (1,) # GL_RED_BITS +_m[0x8564] = (1,) # GL_RED_MAX_CLAMP_INGR +_m[0x8560] = (1,) # GL_RED_MIN_CLAMP_INGR +_m[0x0D14] = (1,) # GL_RED_SCALE +_m[0x930B] = (1,) # GL_REFERENCED_BY_COMPUTE_SHADER +_m[0x930A] = (1,) # GL_REFERENCED_BY_FRAGMENT_SHADER +_m[0x9309] = (1,) # GL_REFERENCED_BY_GEOMETRY_SHADER +_m[0x9307] = (1,) # GL_REFERENCED_BY_TESS_CONTROL_SHADER +_m[0x9308] = (1,) # GL_REFERENCED_BY_TESS_EVALUATION_SHADER +_m[0x9306] = (1,) # GL_REFERENCED_BY_VERTEX_SHADER +_m[0x817E] = (4,) # GL_REFERENCE_PLANE_EQUATION_SGIX +_m[0x817D] = (1,) # GL_REFERENCE_PLANE_SGIX +_m[0x8522] = (1,) # GL_REGISTER_COMBINERS_NV +_m[0x8D53] = (1,) # GL_RENDERBUFFER_ALPHA_SIZE +_m[0x8CA7] = (1,) # GL_RENDERBUFFER_BINDING +_m[0x8CA7] = (1,) # GL_RENDERBUFFER_BINDING_EXT +_m[0x8D52] = (1,) # GL_RENDERBUFFER_BLUE_SIZE +_m[0x8E10] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/framebuffer_multisample_coverage.txt # GL_RENDERBUFFER_COLOR_SAMPLES_NV +_m[0x8CAB] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/framebuffer_multisample_coverage.txt # GL_RENDERBUFFER_COVERAGE_SAMPLES_NV +_m[0x8D54] = (1,) # GL_RENDERBUFFER_DEPTH_SIZE +_m[0x87FD] = (1,) # GL_RENDERBUFFER_FREE_MEMORY_ATI +_m[0x8D51] = (1,) # GL_RENDERBUFFER_GREEN_SIZE +_m[0x8D43] = (1,) # GL_RENDERBUFFER_HEIGHT +_m[0x8D44] = (1,) # GL_RENDERBUFFER_INTERNAL_FORMAT +_m[0x8D50] = (1,) # GL_RENDERBUFFER_RED_SIZE +_m[0x8CAB] = (1,) # GL_RENDERBUFFER_SAMPLES +_m[0x9133] = (1,) # GL_RENDERBUFFER_SAMPLES_IMG +_m[0x8D55] = (1,) # GL_RENDERBUFFER_STENCIL_SIZE +_m[0x91B2] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/AMD/AMD_framebuffer_multisample_advanced.txt # GL_RENDERBUFFER_STORAGE_SAMPLES_AMD +_m[0x8D42] = (1,) # GL_RENDERBUFFER_WIDTH +_m[0x1F01] = (1,) # GL_RENDERER +_m[0x9558] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_gpu_multicast.txt # GL_RENDER_GPU_MASK_NV +_m[0x0C40] = (1,) # GL_RENDER_MODE +_m[0x85C2] = (1,) # GL_REPLACEMENT_CODE_ARRAY_STRIDE_SUN +_m[0x85C1] = (1,) # GL_REPLACEMENT_CODE_ARRAY_TYPE_SUN +_m[0x81D8] = (1,) # GL_REPLACEMENT_CODE_SUN +_m[0x937F] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_representative_fragment_test.txt # GL_REPRESENTATIVE_FRAGMENT_TEST_NV +_m[0x803A] = (1,) # GL_RESCALE_NORMAL +_m[0x803A] = (1,) # GL_RESCALE_NORMAL_EXT +_m[0x8256] = (1,)#TODO Review http://www.opengl.org/registry/specs//KHR/robustness.txt # GL_RESET_NOTIFICATION_STRATEGY +_m[0x8256] = (1,) # GL_RESET_NOTIFICATION_STRATEGY_ARB +_m[0x8820] = (1,) # GL_RGBA_FLOAT_MODE_ARB +_m[0x8820] = (1,) # GL_RGBA_FLOAT_MODE_ATI +_m[0x8D9E] = (1,) # GL_RGBA_INTEGER_MODE_EXT +_m[0x0C31] = (1,) # GL_RGBA_MODE +_m[0x8C3C] = (1,) # GL_RGBA_SIGNED_COMPONENTS_EXT +_m[0x86D9] = (1,) # GL_RGBA_UNSIGNED_DOT_PRODUCT_MAPPING_NV +_m[0x8573] = (1,) # GL_RGB_SCALE +_m[0x8919] = (1,) # GL_SAMPLER_BINDING +_m[0x80A9] = (1,) # GL_SAMPLES +_m[0x86B4] = (1,) # GL_SAMPLES_3DFX +_m[0x80A9] = (1,) # GL_SAMPLES_ARB +_m[0x80A9] = (1,) # GL_SAMPLES_SGIS +_m[0x809E] = (1,) # GL_SAMPLE_ALPHA_TO_COVERAGE +_m[0x809E] = (1,) # GL_SAMPLE_ALPHA_TO_COVERAGE_ARB +_m[0x809E] = (1,) # GL_SAMPLE_ALPHA_TO_MASK_EXT +_m[0x809E] = (1,) # GL_SAMPLE_ALPHA_TO_MASK_SGIS +_m[0x809F] = (1,) # GL_SAMPLE_ALPHA_TO_ONE +_m[0x809F] = (1,) # GL_SAMPLE_ALPHA_TO_ONE_ARB +_m[0x809F] = (1,) # GL_SAMPLE_ALPHA_TO_ONE_EXT +_m[0x809F] = (1,) # GL_SAMPLE_ALPHA_TO_ONE_SGIS +_m[0x80A8] = (1,) # GL_SAMPLE_BUFFERS +_m[0x86B3] = (1,) # GL_SAMPLE_BUFFERS_3DFX +_m[0x80A8] = (1,) # GL_SAMPLE_BUFFERS_ARB +_m[0x80A8] = (1,) # GL_SAMPLE_BUFFERS_SGIS +_m[0x80A0] = (1,) # GL_SAMPLE_COVERAGE +_m[0x80A0] = (1,) # GL_SAMPLE_COVERAGE_ARB +_m[0x80AB] = (1,) # GL_SAMPLE_COVERAGE_INVERT +_m[0x80AB] = (1,) # GL_SAMPLE_COVERAGE_INVERT_ARB +_m[0x80AA] = (1,) # GL_SAMPLE_COVERAGE_VALUE +_m[0x80AA] = (1,) # GL_SAMPLE_COVERAGE_VALUE_ARB +_m[0x8E50] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/ARB/ARB_sample_locations.txt # GL_SAMPLE_LOCATION_ARB +_m[0x8E50] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_sample_locations.txt # GL_SAMPLE_LOCATION_NV +_m[0x933F] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/ARB/ARB_sample_locations.txt # GL_SAMPLE_LOCATION_PIXEL_GRID_HEIGHT_ARB +_m[0x933F] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_sample_locations.txt # GL_SAMPLE_LOCATION_PIXEL_GRID_HEIGHT_NV +_m[0x933E] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/ARB/ARB_sample_locations.txt # GL_SAMPLE_LOCATION_PIXEL_GRID_WIDTH_ARB +_m[0x933E] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_sample_locations.txt # GL_SAMPLE_LOCATION_PIXEL_GRID_WIDTH_NV +_m[0x933D] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/ARB/ARB_sample_locations.txt # GL_SAMPLE_LOCATION_SUBPIXEL_BITS_ARB +_m[0x933D] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_sample_locations.txt # GL_SAMPLE_LOCATION_SUBPIXEL_BITS_NV +_m[0x8E51] = (1,) # GL_SAMPLE_MASK +_m[0x80A0] = (1,) # GL_SAMPLE_MASK_EXT +_m[0x80AB] = (1,) # GL_SAMPLE_MASK_INVERT_SGIS +_m[0x8E51] = (1,) # GL_SAMPLE_MASK_NV +_m[0x80A0] = (1,) # GL_SAMPLE_MASK_SGIS +_m[0x8E52] = (1,) # GL_SAMPLE_MASK_VALUE +_m[0x80AA] = (1,) # GL_SAMPLE_MASK_VALUE_SGIS +_m[0x80AC] = (1,) # GL_SAMPLE_PATTERN_EXT +_m[0x80AC] = (1,) # GL_SAMPLE_PATTERN_SGIS +_m[0x8E50] = (2,) # GL_SAMPLE_POSITION +_m[0x8C36] = (1,) # GL_SAMPLE_SHADING_ARB +_m[0x8C36] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/OES/OES_sample_shading.txt # GL_SAMPLE_SHADING_OES +_m[0x0C10] = (4,) # GL_SCISSOR_BOX +_m[0x9556] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_scissor_exclusive.txt # GL_SCISSOR_BOX_EXCLUSIVE_NV +_m[0x0C11] = (1,) # GL_SCISSOR_TEST +_m[0x9555] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_scissor_exclusive.txt # GL_SCISSOR_TEST_EXCLUSIVE_NV +_m[0x845E] = (1,) # GL_SECONDARY_COLOR_ARRAY +_m[0x889C] = (1,) # GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING +_m[0x889C] = (1,) # GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING_ARB +_m[0x8F31] = (1,) # GL_SECONDARY_COLOR_ARRAY_LENGTH_NV +_m[0x845D] = (1,)#TODO Review http://www.opengl.org/registry/specs//EXT/secondary_color.txt # GL_SECONDARY_COLOR_ARRAY_POINTER_EXT +_m[0x845A] = (1,) # GL_SECONDARY_COLOR_ARRAY_SIZE +_m[0x845A] = (1,) # GL_SECONDARY_COLOR_ARRAY_SIZE_EXT +_m[0x845C] = (1,) # GL_SECONDARY_COLOR_ARRAY_STRIDE +_m[0x845C] = (1,) # GL_SECONDARY_COLOR_ARRAY_STRIDE_EXT +_m[0x845B] = (1,) # GL_SECONDARY_COLOR_ARRAY_TYPE +_m[0x845B] = (1,) # GL_SECONDARY_COLOR_ARRAY_TYPE_EXT +_m[0x0DF3] = (1,) # GL_SELECTION_BUFFER_POINTER +_m[0x0DF4] = (1,) # GL_SELECTION_BUFFER_SIZE +_m[0x8012] = (1,) # GL_SEPARABLE_2D +_m[0x8012] = (1,) # GL_SEPARABLE_2D_EXT +_m[0x8DF8] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/ES2_compatibility.txt # GL_SHADER_BINARY_FORMATS +_m[0x8DFA] = (1,) # GL_SHADER_COMPILER +_m[0x82A6] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_SHADER_IMAGE_ATOMIC +_m[0x82A4] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_SHADER_IMAGE_LOAD +_m[0x82A5] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_SHADER_IMAGE_STORE +_m[0x86DF] = (1,) # GL_SHADER_OPERATION_NV +_m[0x8F64] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/EXT/EXT_shader_pixel_local_storage.txt # GL_SHADER_PIXEL_LOCAL_STORAGE_EXT +_m[0x8B88] = (1,) # GL_SHADER_SOURCE_LENGTH +_m[0x90D2] = (1,) # GL_SHADER_STORAGE_BUFFER +_m[0x90D3] = (1,) # GL_SHADER_STORAGE_BUFFER_BINDING +_m[0x90DF] = (1,) # GL_SHADER_STORAGE_BUFFER_OFFSET_ALIGNMENT +_m[0x90D5] = (1,) # GL_SHADER_STORAGE_BUFFER_SIZE +_m[0x90D4] = (1,) # GL_SHADER_STORAGE_BUFFER_START +_m[0x8B4F] = (1,) # GL_SHADER_TYPE +_m[0x0B54] = (1,) # GL_SHADE_MODEL +_m[0x8B8C] = (1,) # GL_SHADING_LANGUAGE_VERSION +_m[0x955B] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_shading_rate_image.txt # GL_SHADING_RATE_IMAGE_BINDING_NV +_m[0x9563] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_shading_rate_image.txt # GL_SHADING_RATE_IMAGE_NV +_m[0x955E] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_shading_rate_image.txt # GL_SHADING_RATE_IMAGE_PALETTE_SIZE_NV +_m[0x955D] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_shading_rate_image.txt # GL_SHADING_RATE_IMAGE_TEXEL_HEIGHT_NV +_m[0x955C] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_shading_rate_image.txt # GL_SHADING_RATE_IMAGE_TEXEL_WIDTH_NV +_m[0x1601] = (1,) # GL_SHININESS +_m[0x82AC] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_SIMULTANEOUS_TEXTURE_AND_DEPTH_TEST +_m[0x82AE] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_SIMULTANEOUS_TEXTURE_AND_DEPTH_WRITE +_m[0x82AD] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_SIMULTANEOUS_TEXTURE_AND_STENCIL_TEST +_m[0x82AF] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_SIMULTANEOUS_TEXTURE_AND_STENCIL_WRITE +_m[0x0B23] = (1,) # GL_SMOOTH_LINE_WIDTH_GRANULARITY +_m[0x0B22] = (2,) # GL_SMOOTH_LINE_WIDTH_RANGE +_m[0x0B13] = (1,) # GL_SMOOTH_POINT_SIZE_GRANULARITY +_m[0x0B12] = (2,) # GL_SMOOTH_POINT_SIZE_RANGE +_m[0x933B] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/shader_thread_group.txt # GL_SM_COUNT_NV +_m[0x858B] = (1,) # GL_SOURCE3_ALPHA_NV +_m[0x8583] = (1,) # GL_SOURCE3_RGB_NV +_m[0x82F8] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/sparse_buffer.txt # GL_SPARSE_BUFFER_PAGE_SIZE_ARB +_m[0x91A9] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/sparse_texture.txt # GL_SPARSE_TEXTURE_FULL_ARRAY_CUBE_MIPMAPS_ARB +_m[0x91A9] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/EXT/EXT_sparse_texture.txt # GL_SPARSE_TEXTURE_FULL_ARRAY_CUBE_MIPMAPS_EXT +_m[0x1202] = (4,) # GL_SPECULAR +_m[0x9552] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/ARB/ARB_gl_spirv.txt # GL_SPIR_V_BINARY_ARB +_m[0x1206] = (1,) # GL_SPOT_CUTOFF +_m[0x1204] = (3,) # GL_SPOT_DIRECTION +_m[0x1205] = (1,) # GL_SPOT_EXPONENT +_m[0x814A] = (3,) # GL_SPRITE_AXIS_SGIX +_m[0x8149] = (1,) # GL_SPRITE_MODE_SGIX +_m[0x8148] = (1,) # GL_SPRITE_SGIX +_m[0x814B] = (3,) # GL_SPRITE_TRANSLATION_SGIX +_m[0x8588] = (1,) # GL_SRC0_ALPHA +_m[0x8580] = (1,) # GL_SRC0_RGB +_m[0x8589] = (1,) # GL_SRC1_ALPHA +_m[0x8581] = (1,) # GL_SRC1_RGB +_m[0x858A] = (1,) # GL_SRC2_ALPHA +_m[0x8582] = (1,) # GL_SRC2_RGB +_m[0x8299] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_SRGB_DECODE_ARB +_m[0x8297] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_SRGB_READ +_m[0x8298] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_SRGB_WRITE +_m[0x8801] = (1,) # GL_STENCIL_BACK_FAIL +_m[0x8801] = (1,) # GL_STENCIL_BACK_FAIL_ATI +_m[0x8800] = (1,) # GL_STENCIL_BACK_FUNC +_m[0x8800] = (1,) # GL_STENCIL_BACK_FUNC_ATI +_m[0x874D] = (1,) # GL_STENCIL_BACK_OP_VALUE_AMD +_m[0x8802] = (1,) # GL_STENCIL_BACK_PASS_DEPTH_FAIL +_m[0x8802] = (1,) # GL_STENCIL_BACK_PASS_DEPTH_FAIL_ATI +_m[0x8803] = (1,) # GL_STENCIL_BACK_PASS_DEPTH_PASS +_m[0x8803] = (1,) # GL_STENCIL_BACK_PASS_DEPTH_PASS_ATI +_m[0x8CA3] = (1,) # GL_STENCIL_BACK_REF +_m[0x8CA4] = (1,) # GL_STENCIL_BACK_VALUE_MASK +_m[0x8CA5] = (1,) # GL_STENCIL_BACK_WRITEMASK +_m[0x0D57] = (1,) # GL_STENCIL_BITS +_m[0x88F3] = (1,) # GL_STENCIL_CLEAR_TAG_VALUE_EXT +_m[0x0B91] = (1,) # GL_STENCIL_CLEAR_VALUE +_m[0x8285] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_STENCIL_COMPONENTS +_m[0x0B94] = (1,) # GL_STENCIL_FAIL +_m[0x0B92] = (1,) # GL_STENCIL_FUNC +_m[0x874C] = (1,) # GL_STENCIL_OP_VALUE_AMD +_m[0x0B95] = (1,) # GL_STENCIL_PASS_DEPTH_FAIL +_m[0x0B96] = (1,) # GL_STENCIL_PASS_DEPTH_PASS +_m[0x0B97] = (1,) # GL_STENCIL_REF +_m[0x8288] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_STENCIL_RENDERABLE +_m[0x932E] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_framebuffer_mixed_samples.txt # GL_STENCIL_SAMPLES_NV +_m[0x88F2] = (1,) # GL_STENCIL_TAG_BITS_EXT +_m[0x0B90] = (1,) # GL_STENCIL_TEST +_m[0x8910] = (1,) # GL_STENCIL_TEST_TWO_SIDE_EXT +_m[0x0B93] = (1,) # GL_STENCIL_VALUE_MASK +_m[0x0B98] = (1,) # GL_STENCIL_WRITEMASK +_m[0x0C33] = (1,) # GL_STEREO +_m[0x00000004] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/KHR/KHR_shader_subgroup.txt # GL_SUBGROUP_FEATURE_ARITHMETIC_BIT_KHR +_m[0x00000008] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/KHR/KHR_shader_subgroup.txt # GL_SUBGROUP_FEATURE_BALLOT_BIT_KHR +_m[0x00000001] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/KHR/KHR_shader_subgroup.txt # GL_SUBGROUP_FEATURE_BASIC_BIT_KHR +_m[0x00000040] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/KHR/KHR_shader_subgroup.txt # GL_SUBGROUP_FEATURE_CLUSTERED_BIT_KHR +_m[0x00000100] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_shader_subgroup_partitioned.txt # GL_SUBGROUP_FEATURE_PARTITIONED_BIT_NV +_m[0x00000080] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/KHR/KHR_shader_subgroup.txt # GL_SUBGROUP_FEATURE_QUAD_BIT_KHR +_m[0x00000010] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/KHR/KHR_shader_subgroup.txt # GL_SUBGROUP_FEATURE_SHUFFLE_BIT_KHR +_m[0x00000020] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/KHR/KHR_shader_subgroup.txt # GL_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT_KHR +_m[0x00000002] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/KHR/KHR_shader_subgroup.txt # GL_SUBGROUP_FEATURE_VOTE_BIT_KHR +_m[0x9535] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/KHR/KHR_shader_subgroup.txt # GL_SUBGROUP_QUAD_ALL_STAGES_KHR +_m[0x9532] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/KHR/KHR_shader_subgroup.txt # GL_SUBGROUP_SIZE_KHR +_m[0x9534] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/KHR/KHR_shader_subgroup.txt # GL_SUBGROUP_SUPPORTED_FEATURES_KHR +_m[0x9533] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/KHR/KHR_shader_subgroup.txt # GL_SUBGROUP_SUPPORTED_STAGES_KHR +_m[0x0D50] = (1,) # GL_SUBPIXEL_BITS +_m[0x9347] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_conservative_raster.txt # GL_SUBPIXEL_PRECISION_BIAS_X_BITS_NV +_m[0x9348] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_conservative_raster.txt # GL_SUBPIXEL_PRECISION_BIAS_Y_BITS_NV +_m[0x883F] = (1,)#TODO Review http://www.opengl.org/registry/specs//AMD/sample_positions.txt # GL_SUBSAMPLE_DISTANCE_AMD +_m[0x9372] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_internalformat_sample_query.txt # GL_SUPERSAMPLE_SCALE_X_NV +_m[0x9373] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_internalformat_sample_query.txt # GL_SUPERSAMPLE_SCALE_Y_NV +_m[0x91B7] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/AMD/AMD_framebuffer_multisample_advanced.txt # GL_SUPPORTED_MULTISAMPLE_MODES_AMD +_m[0x9113] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/sync.txt # GL_SYNC_CONDITION +_m[0x9115] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/sync.txt # GL_SYNC_FLAGS +_m[0x9114] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/sync.txt # GL_SYNC_STATUS +_m[0x8439] = (1,) # GL_TANGENT_ARRAY_EXT +_m[0x8442] = (1,) # GL_TANGENT_ARRAY_POINTER_EXT +_m[0x843F] = (1,) # GL_TANGENT_ARRAY_STRIDE_EXT +_m[0x843E] = (1,) # GL_TANGENT_ARRAY_TYPE_EXT +_m[0x953F] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_TASK_WORK_GROUP_SIZE_NV +_m[0x9004] = (1,) # GL_TESSELLATION_MODE_AMD +_m[0x8E75] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/tessellation_shader.txt # GL_TESS_CONTROL_OUTPUT_VERTICES +_m[0x891E] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/tessellation_program5.txt # GL_TESS_CONTROL_PROGRAM_NV +_m[0x8E88] = (1,) # GL_TESS_CONTROL_SHADER +_m[0x829C] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_TESS_CONTROL_TEXTURE +_m[0x891F] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/tessellation_program5.txt # GL_TESS_EVALUATION_PROGRAM_NV +_m[0x8E87] = (1,) # GL_TESS_EVALUATION_SHADER +_m[0x829D] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_TESS_EVALUATION_TEXTURE +_m[0x8E76] = (1,) # GL_TESS_GEN_MODE +_m[0x8E79] = (1,) # GL_TESS_GEN_POINT_MODE +_m[0x8E77] = (1,) # GL_TESS_GEN_SPACING +_m[0x8E78] = (1,) # GL_TESS_GEN_VERTEX_ORDER +_m[0x0DE0] = (1,) # GL_TEXTURE_1D +_m[0x8C18] = (1,) # GL_TEXTURE_1D_ARRAY +_m[0x8068] = (1,) # GL_TEXTURE_1D_BINDING_EXT +_m[0x875D] = (1,) # GL_TEXTURE_1D_STACK_BINDING_MESAX +_m[0x8759] = (1,) # GL_TEXTURE_1D_STACK_MESAX +_m[0x0DE1] = (1,) # GL_TEXTURE_2D +_m[0x8C1A] = (1,) # GL_TEXTURE_2D_ARRAY +_m[0x8069] = (1,) # GL_TEXTURE_2D_BINDING_EXT +_m[0x875E] = (1,) # GL_TEXTURE_2D_STACK_BINDING_MESAX +_m[0x875A] = (1,) # GL_TEXTURE_2D_STACK_MESAX +_m[0x806F] = (1,) # GL_TEXTURE_3D +_m[0x806A] = (1,) # GL_TEXTURE_3D_BINDING_EXT +_m[0x806F] = (1,) # GL_TEXTURE_3D_EXT +_m[0x806F] = (1,) # GL_TEXTURE_3D_OES +_m[0x814F] = (1,) # GL_TEXTURE_4D_BINDING_SGIS +_m[0x8134] = (1,) # GL_TEXTURE_4D_SGIS +_m[0x805F] = (1,) # GL_TEXTURE_ALPHA_SIZE +_m[0x8C13] = (1,) # GL_TEXTURE_ALPHA_TYPE +_m[0x834F] = (1,) # GL_TEXTURE_APPLICATION_MODE_EXT +_m[0x813C] = (1,) # GL_TEXTURE_BASE_LEVEL +_m[0x813C] = (1,) # GL_TEXTURE_BASE_LEVEL_SGIS +_m[0x8068] = (1,) # GL_TEXTURE_BINDING_1D +_m[0x8C1C] = (1,) # GL_TEXTURE_BINDING_1D_ARRAY +_m[0x8C1C] = (1,) # GL_TEXTURE_BINDING_1D_ARRAY_EXT +_m[0x8069] = (1,) # GL_TEXTURE_BINDING_2D +_m[0x8C1D] = (1,) # GL_TEXTURE_BINDING_2D_ARRAY +_m[0x8C1D] = (1,) # GL_TEXTURE_BINDING_2D_ARRAY_EXT +_m[0x9104] = (1,) # GL_TEXTURE_BINDING_2D_MULTISAMPLE +_m[0x9105] = (1,) # GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY +_m[0x806A] = (1,) # GL_TEXTURE_BINDING_3D +_m[0x8C2C] = (1,) # GL_TEXTURE_BINDING_BUFFER +_m[0x8C2C] = (1,) # GL_TEXTURE_BINDING_BUFFER_ARB +_m[0x8C2C] = (1,) # GL_TEXTURE_BINDING_BUFFER_EXT +_m[0x8514] = (1,) # GL_TEXTURE_BINDING_CUBE_MAP +_m[0x8514] = (1,) # GL_TEXTURE_BINDING_CUBE_MAP_ARB +_m[0x900A] = (1,) # GL_TEXTURE_BINDING_CUBE_MAP_ARRAY +_m[0x900A] = (1,) # GL_TEXTURE_BINDING_CUBE_MAP_ARRAY_ARB +_m[0x8D67] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/OES/OES_EGL_image_external.txt # GL_TEXTURE_BINDING_EXTERNAL_OES +_m[0x84F6] = (1,) # GL_TEXTURE_BINDING_RECTANGLE +_m[0x84F6] = (1,) # GL_TEXTURE_BINDING_RECTANGLE_ARB +_m[0x84F6] = (1,) # GL_TEXTURE_BINDING_RECTANGLE_NV +_m[0x8E53] = (1,) # GL_TEXTURE_BINDING_RENDERBUFFER_NV +_m[0x805E] = (1,) # GL_TEXTURE_BLUE_SIZE +_m[0x8C12] = (1,) # GL_TEXTURE_BLUE_TYPE +_m[0x1005] = (1,) # GL_TEXTURE_BORDER +_m[0x1004] = (4,) # GL_TEXTURE_BORDER_COLOR +_m[0x1004] = (4,) # GL_TEXTURE_BORDER_COLOR_NV +_m[0x8C2A] = (1,) # GL_TEXTURE_BUFFER +_m[0x8C2A] = (1,) # GL_TEXTURE_BUFFER_ARB +_m[0x8C2A] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/EXT/EXT_texture_buffer.txt # GL_TEXTURE_BUFFER_BINDING_EXT +_m[0x8C2A] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/OES/OES_texture_buffer.txt # GL_TEXTURE_BUFFER_BINDING_OES +_m[0x8C2D] = (1,) # GL_TEXTURE_BUFFER_DATA_STORE_BINDING +_m[0x8C2D] = (1,) # GL_TEXTURE_BUFFER_DATA_STORE_BINDING_ARB +_m[0x8C2D] = (1,) # GL_TEXTURE_BUFFER_DATA_STORE_BINDING_EXT +_m[0x8C2A] = (1,) # GL_TEXTURE_BUFFER_EXT +_m[0x8C2E] = (1,) # GL_TEXTURE_BUFFER_FORMAT_ARB +_m[0x8C2E] = (1,) # GL_TEXTURE_BUFFER_FORMAT_EXT +_m[0x919D] = (1,) # GL_TEXTURE_BUFFER_OFFSET +_m[0x919F] = (1,) # GL_TEXTURE_BUFFER_OFFSET_ALIGNMENT +_m[0x919E] = (1,) # GL_TEXTURE_BUFFER_SIZE +_m[0x8171] = (2,) # GL_TEXTURE_CLIPMAP_CENTER_SGIX +_m[0x8176] = (1,) # GL_TEXTURE_CLIPMAP_DEPTH_SGIX +_m[0x8172] = (1,) # GL_TEXTURE_CLIPMAP_FRAME_SGIX +_m[0x8173] = (2,) # GL_TEXTURE_CLIPMAP_OFFSET_SGIX +_m[0x8174] = (3,) # GL_TEXTURE_CLIPMAP_VIRTUAL_DEPTH_SGIX +_m[0x9046] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/texture_multisample.txt # GL_TEXTURE_COLOR_SAMPLES_NV +_m[0x80BC] = (1,) # GL_TEXTURE_COLOR_TABLE_SGI +_m[0x81EF] = (4,) # GL_TEXTURE_COLOR_WRITEMASK_SGIS +_m[0x80BF] = (1,) # GL_TEXTURE_COMPARE_FAIL_VALUE_ARB +_m[0x884D] = (1,) # GL_TEXTURE_COMPARE_FUNC +_m[0x884C] = (1,) # GL_TEXTURE_COMPARE_MODE +_m[0x819B] = (1,) # GL_TEXTURE_COMPARE_OPERATOR_SGIX +_m[0x819A] = (1,) # GL_TEXTURE_COMPARE_SGIX +_m[0x86A1] = (1,) # GL_TEXTURE_COMPRESSED +_m[0x82B2] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_TEXTURE_COMPRESSED_BLOCK_HEIGHT +_m[0x82B3] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_TEXTURE_COMPRESSED_BLOCK_SIZE +_m[0x82B1] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_TEXTURE_COMPRESSED_BLOCK_WIDTH +_m[0x86A0] = (1,) # GL_TEXTURE_COMPRESSED_IMAGE_SIZE +_m[0x84EF] = (1,) # GL_TEXTURE_COMPRESSION_HINT +_m[0x84EF] = (1,) # GL_TEXTURE_COMPRESSION_HINT_ARB +_m[0x8078] = (1,) # GL_TEXTURE_COORD_ARRAY +_m[0x889A] = (1,) # GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING +_m[0x889A] = (1,) # GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING_ARB +_m[0x808B] = (1,) # GL_TEXTURE_COORD_ARRAY_COUNT_EXT +_m[0x8078] = (1,) # GL_TEXTURE_COORD_ARRAY_EXT +_m[0x83F8] = (1,)#TODO Review http://www.opengl.org/registry/specs//INTEL/parallel_arrays.txt # GL_TEXTURE_COORD_ARRAY_PARALLEL_POINTERS_INTEL +_m[0x8092] = (1,) # GL_TEXTURE_COORD_ARRAY_POINTER +_m[0x8088] = (1,) # GL_TEXTURE_COORD_ARRAY_SIZE +_m[0x8088] = (1,) # GL_TEXTURE_COORD_ARRAY_SIZE_EXT +_m[0x808A] = (1,) # GL_TEXTURE_COORD_ARRAY_STRIDE +_m[0x808A] = (1,) # GL_TEXTURE_COORD_ARRAY_STRIDE_EXT +_m[0x8089] = (1,) # GL_TEXTURE_COORD_ARRAY_TYPE +_m[0x8089] = (1,) # GL_TEXTURE_COORD_ARRAY_TYPE_EXT +_m[0x9045] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/texture_multisample.txt # GL_TEXTURE_COVERAGE_SAMPLES_NV +_m[0x8B9D] = (4,) # GL_TEXTURE_CROP_RECT_OES +_m[0x8513] = (1,) # GL_TEXTURE_CUBE_MAP +_m[0x8513] = (1,) # GL_TEXTURE_CUBE_MAP_ARB +_m[0x9009] = (1,) # GL_TEXTURE_CUBE_MAP_ARRAY +_m[0x884F] = (1,) # GL_TEXTURE_CUBE_MAP_SEAMLESS +_m[0x8071] = (1,) # GL_TEXTURE_DEPTH +_m[0x8071] = (1,) # GL_TEXTURE_DEPTH_EXT +_m[0x884A] = (1,) # GL_TEXTURE_DEPTH_SIZE +_m[0x8C16] = (1,) # GL_TEXTURE_DEPTH_TYPE +_m[0x871D] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/texture_shader.txt # GL_TEXTURE_DS_SIZE_NV +_m[0x871E] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/texture_shader.txt # GL_TEXTURE_DT_SIZE_NV +_m[0x2201] = (4,) # GL_TEXTURE_ENV_COLOR +_m[0x2200] = (1,) # GL_TEXTURE_ENV_MODE +_m[0x9107] = (1,) # GL_TEXTURE_FIXED_SAMPLE_LOCATIONS +_m[0x888C] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/float_buffer.txt # GL_TEXTURE_FLOAT_COMPONENTS_NV +_m[0x8BFD] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/QCOM/QCOM_texture_foveated.txt # GL_TEXTURE_FOVEATED_FEATURE_QUERY_QCOM +_m[0x8BFE] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/QCOM/QCOM_texture_foveated.txt # GL_TEXTURE_FOVEATED_NUM_FOCAL_POINTS_QUERY_QCOM +_m[0x87FC] = (1,) # GL_TEXTURE_FREE_MEMORY_ATI +_m[0x82A2] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_TEXTURE_GATHER +_m[0x82A3] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_TEXTURE_GATHER_SHADOW +_m[0x2500] = (1,) # GL_TEXTURE_GEN_MODE +_m[0x0C63] = (1,) # GL_TEXTURE_GEN_Q +_m[0x0C62] = (1,) # GL_TEXTURE_GEN_R +_m[0x0C60] = (1,) # GL_TEXTURE_GEN_S +_m[0x8D60] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/OES/OES_texture_cube_map.txt # GL_TEXTURE_GEN_STR_OES +_m[0x0C61] = (1,) # GL_TEXTURE_GEN_T +_m[0x805D] = (1,) # GL_TEXTURE_GREEN_SIZE +_m[0x8C11] = (1,) # GL_TEXTURE_GREEN_TYPE +_m[0x1001] = (1,) # GL_TEXTURE_HEIGHT +_m[0x871B] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/texture_shader.txt # GL_TEXTURE_HI_SIZE_NV +_m[0x828F] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_TEXTURE_IMAGE_FORMAT +_m[0x8290] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_TEXTURE_IMAGE_TYPE +_m[0x912F] = (1,) # GL_TEXTURE_IMMUTABLE_FORMAT +_m[0x82DF] = (1,) # GL_TEXTURE_IMMUTABLE_LEVELS +_m[0x80ED] = (1,) # GL_TEXTURE_INDEX_SIZE_EXT +_m[0x8061] = (1,) # GL_TEXTURE_INTENSITY_SIZE +_m[0x8C15] = (1,) # GL_TEXTURE_INTENSITY_TYPE +_m[0x1003] = (1,) # GL_TEXTURE_INTERNAL_FORMAT +_m[0x8350] = (1,) # GL_TEXTURE_LIGHT_EXT +_m[0x8501] = (1,) # GL_TEXTURE_LOD_BIAS +_m[0x8190] = (1,) # GL_TEXTURE_LOD_BIAS_R_SGIX +_m[0x818E] = (1,) # GL_TEXTURE_LOD_BIAS_S_SGIX +_m[0x818F] = (1,) # GL_TEXTURE_LOD_BIAS_T_SGIX +_m[0x871C] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/texture_shader.txt # GL_TEXTURE_LO_SIZE_NV +_m[0x8060] = (1,) # GL_TEXTURE_LUMINANCE_SIZE +_m[0x8C14] = (1,) # GL_TEXTURE_LUMINANCE_TYPE +_m[0x2800] = (1,) # GL_TEXTURE_MAG_FILTER +_m[0x871F] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/texture_shader.txt # GL_TEXTURE_MAG_SIZE_NV +_m[0x8351] = (1,) # GL_TEXTURE_MATERIAL_FACE_EXT +_m[0x8352] = (1,) # GL_TEXTURE_MATERIAL_PARAMETER_EXT +_m[0x0BA8] = (4, 4) # GL_TEXTURE_MATRIX +_m[0x898F] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/OES/OES_matrix_get.txt # GL_TEXTURE_MATRIX_FLOAT_AS_INT_BITS_OES +_m[0x84FE] = (1,) # GL_TEXTURE_MAX_ANISOTROPY_EXT +_m[0x836B] = (1,) # GL_TEXTURE_MAX_CLAMP_R_SGIX +_m[0x8369] = (1,) # GL_TEXTURE_MAX_CLAMP_S_SGIX +_m[0x836A] = (1,) # GL_TEXTURE_MAX_CLAMP_T_SGIX +_m[0x813D] = (1,) # GL_TEXTURE_MAX_LEVEL +_m[0x813D] = (1,) # GL_TEXTURE_MAX_LEVEL_SGIS +_m[0x813B] = (1,) # GL_TEXTURE_MAX_LOD +_m[0x813B] = (1,) # GL_TEXTURE_MAX_LOD_SGIS +_m[0x2801] = (1,) # GL_TEXTURE_MIN_FILTER +_m[0x813A] = (1,) # GL_TEXTURE_MIN_LOD +_m[0x813A] = (1,) # GL_TEXTURE_MIN_LOD_SGIS +_m[0x8066] = (1,) # GL_TEXTURE_PRIORITY +_m[0x85B8] = (1,) # GL_TEXTURE_RANGE_POINTER_APPLE +_m[0x84F5] = (1,) # GL_TEXTURE_RECTANGLE +_m[0x84F5] = (1,) # GL_TEXTURE_RECTANGLE_ARB +_m[0x84F5] = (1,) # GL_TEXTURE_RECTANGLE_NV +_m[0x805C] = (1,) # GL_TEXTURE_RED_SIZE +_m[0x8C10] = (1,) # GL_TEXTURE_RED_TYPE +_m[0x8E54] = (1,) # GL_TEXTURE_RENDERBUFFER_DATA_STORE_BINDING_NV +_m[0x8067] = (1,) # GL_TEXTURE_RESIDENT +_m[0x9106] = (1,) # GL_TEXTURE_SAMPLES +_m[0x9136] = (1,) # GL_TEXTURE_SAMPLES_IMG +_m[0x86DE] = (1,) # GL_TEXTURE_SHADER_NV +_m[0x82A1] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_TEXTURE_SHADOW +_m[0x8C3F] = (1,)#TODO Review http://www.opengl.org/registry/specs//EXT/texture_shared_exponent.txt # GL_TEXTURE_SHARED_SIZE_EXT +_m[0x8A48] = (1,) # GL_TEXTURE_SRGB_DECODE_EXT +_m[0x0BA5] = (1,) # GL_TEXTURE_STACK_DEPTH +_m[0x88F1] = (1,) # GL_TEXTURE_STENCIL_SIZE +_m[0x85BC] = (1,) # GL_TEXTURE_STORAGE_HINT_APPLE +_m[0x8E45] = (1,) # GL_TEXTURE_SWIZZLE_A +_m[0x8E44] = (1,) # GL_TEXTURE_SWIZZLE_B +_m[0x8E43] = (1,) # GL_TEXTURE_SWIZZLE_G +_m[0x8E42] = (1,) # GL_TEXTURE_SWIZZLE_R +_m[0x8E46] = (4,) # GL_TEXTURE_SWIZZLE_RGBA +_m[0x1006] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/direct_state_access.txt # GL_TEXTURE_TARGET +_m[0x888F] = (1,) # GL_TEXTURE_UNSIGNED_REMAP_MODE_NV +_m[0x82B5] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_TEXTURE_VIEW +_m[0x82DD] = (1,) # GL_TEXTURE_VIEW_MIN_LAYER +_m[0x82DB] = (1,) # GL_TEXTURE_VIEW_MIN_LEVEL +_m[0x82DE] = (1,) # GL_TEXTURE_VIEW_NUM_LAYERS +_m[0x82DC] = (1,) # GL_TEXTURE_VIEW_NUM_LEVELS +_m[0x1000] = (1,) # GL_TEXTURE_WIDTH +_m[0x8137] = (1,) # GL_TEXTURE_WRAP_Q_SGIS +_m[0x8072] = (1,) # GL_TEXTURE_WRAP_R +_m[0x8072] = (1,) # GL_TEXTURE_WRAP_R_EXT +_m[0x2802] = (1,) # GL_TEXTURE_WRAP_S +_m[0x2803] = (1,) # GL_TEXTURE_WRAP_T +_m[0x8200] = (1,) # GL_TEXT_FRAGMENT_SHADER_ATI +_m[0x8E28] = (1,) # GL_TIMESTAMP +_m[0x930C] = (1,) # GL_TOP_LEVEL_ARRAY_SIZE +_m[0x930D] = (1,) # GL_TOP_LEVEL_ARRAY_STRIDE +_m[0x8648] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/vertex_program.txt # GL_TRACK_MATRIX_NV +_m[0x8649] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/vertex_program.txt # GL_TRACK_MATRIX_TRANSFORM_NV +_m[0x8E25] = (1,) # GL_TRANSFORM_FEEDBACK_BINDING +_m[0x8E25] = (1,) # GL_TRANSFORM_FEEDBACK_BINDING_NV +_m[0x8E24] = (1,) # GL_TRANSFORM_FEEDBACK_BUFFER_ACTIVE +_m[0x8E24] = (1,) # GL_TRANSFORM_FEEDBACK_BUFFER_ACTIVE_NV +_m[0x8C8F] = (1,) # GL_TRANSFORM_FEEDBACK_BUFFER_BINDING +_m[0x8C7F] = (1,) # GL_TRANSFORM_FEEDBACK_BUFFER_MODE +_m[0x8C7F] = (1,)#TODO Review http://www.opengl.org/registry/specs//EXT/transform_feedback.txt # GL_TRANSFORM_FEEDBACK_BUFFER_MODE_EXT +_m[0x8C7F] = (1,) # GL_TRANSFORM_FEEDBACK_BUFFER_MODE_NV +_m[0x8E23] = (1,) # GL_TRANSFORM_FEEDBACK_BUFFER_PAUSED +_m[0x8E23] = (1,) # GL_TRANSFORM_FEEDBACK_BUFFER_PAUSED_NV +_m[0x8C85] = (1,) # GL_TRANSFORM_FEEDBACK_BUFFER_SIZE +_m[0x8C84] = (1,) # GL_TRANSFORM_FEEDBACK_BUFFER_START +_m[0x8C83] = (1,) # GL_TRANSFORM_FEEDBACK_VARYINGS +_m[0x8C83] = (1,)#TODO Review http://www.opengl.org/registry/specs//EXT/transform_feedback.txt # GL_TRANSFORM_FEEDBACK_VARYINGS_EXT +_m[0x8C76] = (1,) # GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH +_m[0x8C76] = (1,)#TODO Review http://www.opengl.org/registry/specs//EXT/transform_feedback.txt # GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH_EXT +_m[0x84E6] = (4,4) # GL_TRANSPOSE_COLOR_MATRIX +_m[0x84E6] = (4,4) # GL_TRANSPOSE_COLOR_MATRIX_ARB +_m[0x88B7] = (4, 4) # GL_TRANSPOSE_CURRENT_MATRIX_ARB +_m[0x84E3] = (4,4) # GL_TRANSPOSE_MODELVIEW_MATRIX +_m[0x84E3] = (4,4) # GL_TRANSPOSE_MODELVIEW_MATRIX_ARB +_m[0x8E2E] = (1,)#TODO Review http://www.opengl.org/registry/specs//EXT/direct_state_access.txt # GL_TRANSPOSE_PROGRAM_MATRIX_EXT +_m[0x84E4] = (4,4) # GL_TRANSPOSE_PROJECTION_MATRIX +_m[0x84E4] = (4,4) # GL_TRANSPOSE_PROJECTION_MATRIX_ARB +_m[0x84E5] = (4,4) # GL_TRANSPOSE_TEXTURE_MATRIX +_m[0x84E5] = (4,4) # GL_TRANSPOSE_TEXTURE_MATRIX_ARB +_m[0x92FA] = (1,) # GL_TYPE +_m[0x8A3C] = (1,) # GL_UNIFORM_ARRAY_STRIDE +_m[0x92DA] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/shader_atomic_counters.txt # GL_UNIFORM_ATOMIC_COUNTER_BUFFER_INDEX +_m[0x8A42] = (1,) # GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS +_m[0x8A43] = (1,) # GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES +_m[0x8A3F] = (1,) # GL_UNIFORM_BLOCK_BINDING +_m[0x8A40] = (1,) # GL_UNIFORM_BLOCK_DATA_SIZE +_m[0x8A3A] = (1,) # GL_UNIFORM_BLOCK_INDEX +_m[0x8A41] = (1,) # GL_UNIFORM_BLOCK_NAME_LENGTH +_m[0x90EC] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/compute_shader.txt # GL_UNIFORM_BLOCK_REFERENCED_BY_COMPUTE_SHADER +_m[0x8A46] = (1,) # GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER +_m[0x8A45] = (1,) # GL_UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER +_m[0x959C] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_UNIFORM_BLOCK_REFERENCED_BY_MESH_SHADER_NV +_m[0x959D] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_mesh_shader.txt # GL_UNIFORM_BLOCK_REFERENCED_BY_TASK_SHADER_NV +_m[0x84F0] = (1,) # GL_UNIFORM_BLOCK_REFERENCED_BY_TESS_CONTROL_SHADER +_m[0x84F1] = (1,) # GL_UNIFORM_BLOCK_REFERENCED_BY_TESS_EVALUATION_SHADER +_m[0x8A44] = (1,) # GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER +_m[0x8A28] = (1,) # GL_UNIFORM_BUFFER_BINDING +_m[0x8DEF] = (1,) # GL_UNIFORM_BUFFER_BINDING_EXT +_m[0x8A34] = (1,) # GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT +_m[0x8A2A] = (1,) # GL_UNIFORM_BUFFER_SIZE +_m[0x8A29] = (1,) # GL_UNIFORM_BUFFER_START +_m[0x8A3E] = (1,) # GL_UNIFORM_IS_ROW_MAJOR +_m[0x8A3D] = (1,) # GL_UNIFORM_MATRIX_STRIDE +_m[0x8A39] = (1,) # GL_UNIFORM_NAME_LENGTH +_m[0x8A3B] = (1,) # GL_UNIFORM_OFFSET +_m[0x8A38] = (1,) # GL_UNIFORM_SIZE +_m[0x8A37] = (1,) # GL_UNIFORM_TYPE +_m[0x0CF5] = (1,) # GL_UNPACK_ALIGNMENT +_m[0x85B2] = (1,) # GL_UNPACK_CLIENT_STORAGE_APPLE +_m[0x800F] = (1,) # GL_UNPACK_CMYK_HINT_EXT +_m[0x9129] = (1,) # GL_UNPACK_COMPRESSED_BLOCK_DEPTH +_m[0x9128] = (1,) # GL_UNPACK_COMPRESSED_BLOCK_HEIGHT +_m[0x912A] = (1,) # GL_UNPACK_COMPRESSED_BLOCK_SIZE +_m[0x9127] = (1,) # GL_UNPACK_COMPRESSED_BLOCK_WIDTH +_m[0x8133] = (1,) # GL_UNPACK_IMAGE_DEPTH_SGIS +_m[0x806E] = (1,) # GL_UNPACK_IMAGE_HEIGHT +_m[0x806E] = (1,) # GL_UNPACK_IMAGE_HEIGHT_EXT +_m[0x0CF1] = (1,) # GL_UNPACK_LSB_FIRST +_m[0x8985] = (1,) # GL_UNPACK_RESAMPLE_OML +_m[0x842F] = (1,) # GL_UNPACK_RESAMPLE_SGIX +_m[0x8A16] = (1,) # GL_UNPACK_ROW_BYTES_APPLE +_m[0x0CF2] = (1,) # GL_UNPACK_ROW_LENGTH +_m[0x806D] = (1,) # GL_UNPACK_SKIP_IMAGES +_m[0x806D] = (1,) # GL_UNPACK_SKIP_IMAGES_EXT +_m[0x0CF4] = (1,) # GL_UNPACK_SKIP_PIXELS +_m[0x0CF3] = (1,) # GL_UNPACK_SKIP_ROWS +_m[0x8132] = (1,) # GL_UNPACK_SKIP_VOLUMES_SGIS +_m[0x0CF0] = (1,) # GL_UNPACK_SWAP_BYTES +_m[0x954A] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NVX/NVX_gpu_multicast2.txt # GL_UPLOAD_GPU_MASK_NVX +_m[0x8B83] = (1,) # GL_VALIDATE_STATUS +_m[0x87E9] = (1,)#TODO Review http://www.opengl.org/registry/specs//EXT/vertex_shader.txt # GL_VARIANT_ARRAY_POINTER_EXT +_m[0x87E7] = (1,) # GL_VARIANT_ARRAY_TYPE_EXT +_m[0x87FB] = (1,) # GL_VBO_FREE_MEMORY_ATI +_m[0x1F00] = (1,) # GL_VENDOR +_m[0x1F02] = (1,) # GL_VERSION +_m[0x8074] = (1,) # GL_VERTEX_ARRAY +_m[0x85B5] = (1,) # GL_VERTEX_ARRAY_BINDING +_m[0x85B5] = (1,) # GL_VERTEX_ARRAY_BINDING_APPLE +_m[0x8896] = (1,) # GL_VERTEX_ARRAY_BUFFER_BINDING +_m[0x8896] = (1,) # GL_VERTEX_ARRAY_BUFFER_BINDING_ARB +_m[0x807D] = (1,) # GL_VERTEX_ARRAY_COUNT_EXT +_m[0x8074] = (1,) # GL_VERTEX_ARRAY_EXT +_m[0x8F2B] = (1,) # GL_VERTEX_ARRAY_LENGTH_NV +_m[0x83F5] = (1,)#TODO Review http://www.opengl.org/registry/specs//INTEL/parallel_arrays.txt # GL_VERTEX_ARRAY_PARALLEL_POINTERS_INTEL +_m[0x808E] = (1,) # GL_VERTEX_ARRAY_POINTER +_m[0x851E] = (1,) # GL_VERTEX_ARRAY_RANGE_LENGTH_APPLE +_m[0x851E] = (1,) # GL_VERTEX_ARRAY_RANGE_LENGTH_NV +_m[0x851D] = (1,) # GL_VERTEX_ARRAY_RANGE_NV +_m[0x8521] = (1,) # GL_VERTEX_ARRAY_RANGE_POINTER_NV +_m[0x851F] = (1,) # GL_VERTEX_ARRAY_RANGE_VALID_NV +_m[0x807A] = (1,) # GL_VERTEX_ARRAY_SIZE +_m[0x807A] = (1,) # GL_VERTEX_ARRAY_SIZE_EXT +_m[0x807C] = (1,) # GL_VERTEX_ARRAY_STRIDE +_m[0x807C] = (1,) # GL_VERTEX_ARRAY_STRIDE_EXT +_m[0x807B] = (1,) # GL_VERTEX_ARRAY_TYPE +_m[0x807B] = (1,) # GL_VERTEX_ARRAY_TYPE_EXT +_m[0x8650] = (1,) # GL_VERTEX_ATTRIB_ARRAY0_NV +_m[0x865A] = (1,) # GL_VERTEX_ATTRIB_ARRAY10_NV +_m[0x865B] = (1,) # GL_VERTEX_ATTRIB_ARRAY11_NV +_m[0x865C] = (1,) # GL_VERTEX_ATTRIB_ARRAY12_NV +_m[0x865D] = (1,) # GL_VERTEX_ATTRIB_ARRAY13_NV +_m[0x865E] = (1,) # GL_VERTEX_ATTRIB_ARRAY14_NV +_m[0x865F] = (1,) # GL_VERTEX_ATTRIB_ARRAY15_NV +_m[0x8651] = (1,) # GL_VERTEX_ATTRIB_ARRAY1_NV +_m[0x8652] = (1,) # GL_VERTEX_ATTRIB_ARRAY2_NV +_m[0x8653] = (1,) # GL_VERTEX_ATTRIB_ARRAY3_NV +_m[0x8654] = (1,) # GL_VERTEX_ATTRIB_ARRAY4_NV +_m[0x8655] = (1,) # GL_VERTEX_ATTRIB_ARRAY5_NV +_m[0x8656] = (1,) # GL_VERTEX_ATTRIB_ARRAY6_NV +_m[0x8657] = (1,) # GL_VERTEX_ATTRIB_ARRAY7_NV +_m[0x8658] = (1,) # GL_VERTEX_ATTRIB_ARRAY8_NV +_m[0x8659] = (1,) # GL_VERTEX_ATTRIB_ARRAY9_NV +_m[0x889F] = (1,) # GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING +_m[0x889F] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/vertex_buffer_object.txt # GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING_ARB +_m[0x88FE] = (1,) # GL_VERTEX_ATTRIB_ARRAY_DIVISOR +_m[0x8622] = (1,) # GL_VERTEX_ATTRIB_ARRAY_ENABLED +_m[0x88FD] = (1,) # GL_VERTEX_ATTRIB_ARRAY_INTEGER +_m[0x874E] = (1,) # GL_VERTEX_ATTRIB_ARRAY_LONG +_m[0x886A] = (1,) # GL_VERTEX_ATTRIB_ARRAY_NORMALIZED +_m[0x8645] = (1,) # GL_VERTEX_ATTRIB_ARRAY_POINTER +_m[0x8623] = (1,) # GL_VERTEX_ATTRIB_ARRAY_SIZE +_m[0x8624] = (1,) # GL_VERTEX_ATTRIB_ARRAY_STRIDE +_m[0x8625] = (1,) # GL_VERTEX_ATTRIB_ARRAY_TYPE +_m[0x82D4] = (1,) # GL_VERTEX_ATTRIB_BINDING +_m[0x82D5] = (1,) # GL_VERTEX_ATTRIB_RELATIVE_OFFSET +_m[0x82D6] = (1,) # GL_VERTEX_BINDING_DIVISOR +_m[0x82D7] = (1,) # GL_VERTEX_BINDING_OFFSET +_m[0x82D8] = (1,) # GL_VERTEX_BINDING_STRIDE +_m[0x86A7] = (1,) # GL_VERTEX_BLEND_ARB +_m[0x83EF] = (1,) # GL_VERTEX_PRECLIP_HINT_SGIX +_m[0x83EE] = (1,) # GL_VERTEX_PRECLIP_SGIX +_m[0x8620] = (1,) # GL_VERTEX_PROGRAM_ARB +_m[0x864A] = (1,) # GL_VERTEX_PROGRAM_BINDING_NV +_m[0x8620] = (1,) # GL_VERTEX_PROGRAM_NV +_m[0x8DA2] = (1,) # GL_VERTEX_PROGRAM_PARAMETER_BUFFER_NV +_m[0x8642] = (1,) # GL_VERTEX_PROGRAM_POINT_SIZE +_m[0x8642] = (1,) # GL_VERTEX_PROGRAM_POINT_SIZE_ARB +_m[0x8642] = (1,) # GL_VERTEX_PROGRAM_POINT_SIZE_NV +_m[0x8643] = (1,) # GL_VERTEX_PROGRAM_TWO_SIDE +_m[0x8643] = (1,) # GL_VERTEX_PROGRAM_TWO_SIDE_ARB +_m[0x8643] = (1,) # GL_VERTEX_PROGRAM_TWO_SIDE_NV +_m[0x8B31] = (1,) # GL_VERTEX_SHADER +_m[0x8781] = (1,) # GL_VERTEX_SHADER_BINDING_EXT +_m[0x8780] = (1,) # GL_VERTEX_SHADER_EXT +_m[0x87CF] = (1,) # GL_VERTEX_SHADER_INSTRUCTIONS_EXT +_m[0x87D1] = (1,) # GL_VERTEX_SHADER_INVARIANTS_EXT +_m[0x87D3] = (1,) # GL_VERTEX_SHADER_LOCALS_EXT +_m[0x87D2] = (1,) # GL_VERTEX_SHADER_LOCAL_CONSTANTS_EXT +_m[0x87D4] = (1,) # GL_VERTEX_SHADER_OPTIMIZED_EXT +_m[0x87D0] = (1,) # GL_VERTEX_SHADER_VARIANTS_EXT +_m[0x829B] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_VERTEX_TEXTURE +_m[0x850C] = (1,) # GL_VERTEX_WEIGHT_ARRAY_EXT +_m[0x8510] = (1,) # GL_VERTEX_WEIGHT_ARRAY_POINTER_EXT +_m[0x850D] = (1,) # GL_VERTEX_WEIGHT_ARRAY_SIZE_EXT +_m[0x850F] = (1,) # GL_VERTEX_WEIGHT_ARRAY_STRIDE_EXT +_m[0x850E] = (1,) # GL_VERTEX_WEIGHT_ARRAY_TYPE_EXT +_m[0x8719] = (1,) # GL_VIBRANCE_BIAS_NV +_m[0x8713] = (1,) # GL_VIBRANCE_SCALE_NV +_m[0x9021] = (1,) # GL_VIDEO_BUFFER_BINDING_NV +_m[0x0BA2] = (4,) # GL_VIEWPORT +_m[0x825D] = (2,) # GL_VIEWPORT_BOUNDS_RANGE +_m[0x825F] = (1,) # GL_VIEWPORT_INDEX_PROVOKING_VERTEX +_m[0x937D] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_clip_space_w_scaling.txt # GL_VIEWPORT_POSITION_W_SCALE_X_COEFF_NV +_m[0x937E] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_clip_space_w_scaling.txt # GL_VIEWPORT_POSITION_W_SCALE_Y_COEFF_NV +_m[0x825C] = (1,) # GL_VIEWPORT_SUBPIXEL_BITS +_m[0x935B] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_viewport_swizzle.txt # GL_VIEWPORT_SWIZZLE_W_NV +_m[0x9358] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_viewport_swizzle.txt # GL_VIEWPORT_SWIZZLE_X_NV +_m[0x9359] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_viewport_swizzle.txt # GL_VIEWPORT_SWIZZLE_Y_NV +_m[0x935A] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/NV/NV_viewport_swizzle.txt # GL_VIEWPORT_SWIZZLE_Z_NV +_m[0x82B6] = (1,)#TODO Review http://www.opengl.org/registry/specs//ARB/internalformat_query2.txt # GL_VIEW_COMPATIBILITY_CLASS +_m[0x933A] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/shader_thread_group.txt # GL_WARPS_PER_SM_NV +_m[0x9339] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/shader_thread_group.txt # GL_WARP_SIZE_NV +_m[0x86AD] = (1,) # GL_WEIGHT_ARRAY_ARB +_m[0x889E] = (1,) # GL_WEIGHT_ARRAY_BUFFER_BINDING +_m[0x889E] = (1,) # GL_WEIGHT_ARRAY_BUFFER_BINDING_ARB +_m[0x86AC] = (1,) # GL_WEIGHT_ARRAY_POINTER_ARB +_m[0x86AC] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/OES/OES_matrix_palette.txt # GL_WEIGHT_ARRAY_POINTER_OES +_m[0x86AB] = (1,) # GL_WEIGHT_ARRAY_SIZE_ARB +_m[0x86AB] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/OES/OES_matrix_palette.txt # GL_WEIGHT_ARRAY_SIZE_OES +_m[0x86AA] = (1,) # GL_WEIGHT_ARRAY_STRIDE_ARB +_m[0x86AA] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/OES/OES_matrix_palette.txt # GL_WEIGHT_ARRAY_STRIDE_OES +_m[0x86A9] = (1,) # GL_WEIGHT_ARRAY_TYPE_ARB +_m[0x86A9] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/OES/OES_matrix_palette.txt # GL_WEIGHT_ARRAY_TYPE_OES +_m[0x86A6] = (1,) # GL_WEIGHT_SUM_UNITY_ARB +_m[0x8F12] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/EXT/EXT_window_rectangles.txt # GL_WINDOW_RECTANGLE_EXT +_m[0x8F13] = (1,)#TODO Review /home/mcfletch/OpenGL-dev/pyopengl/src/khronosapi/extensions/EXT/EXT_window_rectangles.txt # GL_WINDOW_RECTANGLE_MODE_EXT +_m[0x887A] = (1,) # GL_WRITE_PIXEL_DATA_RANGE_LENGTH_NV +_m[0x887C] = (1,)#TODO Review http://www.opengl.org/registry/specs//NV/pixel_data_range.txt # GL_WRITE_PIXEL_DATA_RANGE_POINTER_NV +_m[0x0D16] = (1,) # GL_ZOOM_X +_m[0x0D17] = (1,) # GL_ZOOM_Y diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLES3/_types.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES3/_types.py new file mode 100644 index 00000000..81a2a706 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLES3/_types.py @@ -0,0 +1,4 @@ +from OpenGL.raw.GLES2._types import * + +from OpenGL.platform import PLATFORM as _p +_error_function = getattr(_p.GLES3, 'glGetError',None) diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLU/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLU/__init__.py new file mode 100644 index 00000000..1f76f638 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLU/__init__.py @@ -0,0 +1,807 @@ +# -*- coding: iso-8859-1 -*- +"""Raw (C-style) API for OpenGL.GLU + +Automatically generated by the generateraw script, do not edit! +""" +from OpenGL.raw.GLU.constants import * + +from ctypes import * +from OpenGL import platform, arrays +from OpenGL.constant import Constant +from OpenGL.raw.GL import _types as GL_types +GLvoid = GL_types.GLvoid + +FUNCTION_TYPE = platform.PLATFORM.functionTypeFor( platform.PLATFORM.GLU ) +from OpenGL.raw.GL._types import ( + GLint, + GLenum, + GLsizei, + GLboolean, + GLubyte, + GLdouble, + GLfloat, +) + + +class GLUnurbs(Structure): + pass +GLUnurbs._fields_ = [ + # /usr/include/GL/glu.h 257 +] +GLUnurbsObj = GLUnurbs +class GLUquadric(Structure): + pass +GLUquadric._fields_ = [ + # /usr/include/GL/glu.h 258 +] +GLUquadricObj = GLUquadric +class GLUtesselator(Structure): + pass +GLUtesselator._fields_ = [ + # /usr/include/GL/glu.h 259 +] +GLUtesselatorObj = GLUtesselator +GLUtriangulatorObj = GLUtesselator + + +# /usr/include/GL/glu.h 276 +gluBeginCurve = platform.createBaseFunction( + 'gluBeginCurve', dll=platform.PLATFORM.GLU, resultType=None, + argTypes=[POINTER(GLUnurbs)], + doc='gluBeginCurve( POINTER(GLUnurbs)(nurb) ) -> None', + argNames=('nurb',), +) + + +# /usr/include/GL/glu.h 277 +gluBeginPolygon = platform.createBaseFunction( + 'gluBeginPolygon', dll=platform.PLATFORM.GLU, resultType=None, + argTypes=[POINTER(GLUtesselator)], + doc='gluBeginPolygon( POINTER(GLUtesselator)(tess) ) -> None', + argNames=('tess',), +) + + +# /usr/include/GL/glu.h 278 +gluBeginSurface = platform.createBaseFunction( + 'gluBeginSurface', dll=platform.PLATFORM.GLU, resultType=None, + argTypes=[POINTER(GLUnurbs)], + doc='gluBeginSurface( POINTER(GLUnurbs)(nurb) ) -> None', + argNames=('nurb',), +) + + +# /usr/include/GL/glu.h 279 +gluBeginTrim = platform.createBaseFunction( + 'gluBeginTrim', dll=platform.PLATFORM.GLU, resultType=None, + argTypes=[POINTER(GLUnurbs)], + doc='gluBeginTrim( POINTER(GLUnurbs)(nurb) ) -> None', + argNames=('nurb',), +) + + +# /usr/include/GL/glu.h 280 +gluBuild1DMipmapLevels = platform.createBaseFunction( + 'gluBuild1DMipmapLevels', dll=platform.PLATFORM.GLU, resultType=GLint, + argTypes=[GLenum,GLint,GLsizei,GLenum,GLenum,GLint,GLint,GLint,c_void_p], + doc='gluBuild1DMipmapLevels( GLenum(target), GLint(internalFormat), GLsizei(width), GLenum(format), GLenum(type), GLint(level), GLint(base), GLint(max), c_void_p(data) ) -> GLint', + argNames=('target', 'internalFormat', 'width', 'format', 'type', 'level', 'base', 'max', 'data'), +) + + +# /usr/include/GL/glu.h 281 +gluBuild1DMipmaps = platform.createBaseFunction( + 'gluBuild1DMipmaps', dll=platform.PLATFORM.GLU, resultType=GLint, + argTypes=[GLenum,GLint,GLsizei,GLenum,GLenum,c_void_p], + doc='gluBuild1DMipmaps( GLenum(target), GLint(internalFormat), GLsizei(width), GLenum(format), GLenum(type), c_void_p(data) ) -> GLint', + argNames=('target', 'internalFormat', 'width', 'format', 'type', 'data'), +) + + +# /usr/include/GL/glu.h 282 +gluBuild2DMipmapLevels = platform.createBaseFunction( + 'gluBuild2DMipmapLevels', dll=platform.PLATFORM.GLU, resultType=GLint, + argTypes=[GLenum,GLint,GLsizei,GLsizei,GLenum,GLenum,GLint,GLint,GLint,c_void_p], + doc='gluBuild2DMipmapLevels( GLenum(target), GLint(internalFormat), GLsizei(width), GLsizei(height), GLenum(format), GLenum(type), GLint(level), GLint(base), GLint(max), c_void_p(data) ) -> GLint', + argNames=('target', 'internalFormat', 'width', 'height', 'format', 'type', 'level', 'base', 'max', 'data'), +) + + +# /usr/include/GL/glu.h 283 +gluBuild2DMipmaps = platform.createBaseFunction( + 'gluBuild2DMipmaps', dll=platform.PLATFORM.GLU, resultType=GLint, + argTypes=[GLenum,GLint,GLsizei,GLsizei,GLenum,GLenum,c_void_p], + doc='gluBuild2DMipmaps( GLenum(target), GLint(internalFormat), GLsizei(width), GLsizei(height), GLenum(format), GLenum(type), c_void_p(data) ) -> GLint', + argNames=('target', 'internalFormat', 'width', 'height', 'format', 'type', 'data'), +) + + +# /usr/include/GL/glu.h 284 +gluBuild3DMipmapLevels = platform.createBaseFunction( + 'gluBuild3DMipmapLevels', dll=platform.PLATFORM.GLU, resultType=GLint, + argTypes=[GLenum,GLint,GLsizei,GLsizei,GLsizei,GLenum,GLenum,GLint,GLint,GLint,c_void_p], + doc='gluBuild3DMipmapLevels( GLenum(target), GLint(internalFormat), GLsizei(width), GLsizei(height), GLsizei(depth), GLenum(format), GLenum(type), GLint(level), GLint(base), GLint(max), c_void_p(data) ) -> GLint', + argNames=('target', 'internalFormat', 'width', 'height', 'depth', 'format', 'type', 'level', 'base', 'max', 'data'), +) + + +# /usr/include/GL/glu.h 285 +gluBuild3DMipmaps = platform.createBaseFunction( + 'gluBuild3DMipmaps', dll=platform.PLATFORM.GLU, resultType=GLint, + argTypes=[GLenum,GLint,GLsizei,GLsizei,GLsizei,GLenum,GLenum,c_void_p], + doc='gluBuild3DMipmaps( GLenum(target), GLint(internalFormat), GLsizei(width), GLsizei(height), GLsizei(depth), GLenum(format), GLenum(type), c_void_p(data) ) -> GLint', + argNames=('target', 'internalFormat', 'width', 'height', 'depth', 'format', 'type', 'data'), +) + + +# /usr/include/GL/glu.h 286 +gluCheckExtension = platform.createBaseFunction( + 'gluCheckExtension', dll=platform.PLATFORM.GLU, resultType=GLboolean, + argTypes=[arrays.GLubyteArray,arrays.GLubyteArray], + doc='gluCheckExtension( arrays.GLubyteArray(extName), arrays.GLubyteArray(extString) ) -> GLboolean', + argNames=('extName', 'extString'), +) + + +# /usr/include/GL/glu.h 287 +gluCylinder = platform.createBaseFunction( + 'gluCylinder', dll=platform.PLATFORM.GLU, resultType=None, + argTypes=[POINTER(GLUquadric),GLdouble,GLdouble,GLdouble,GLint,GLint], + doc='gluCylinder( POINTER(GLUquadric)(quad), GLdouble(base), GLdouble(top), GLdouble(height), GLint(slices), GLint(stacks) ) -> None', + argNames=('quad', 'base', 'top', 'height', 'slices', 'stacks'), +) + + +# /usr/include/GL/glu.h 288 +gluDeleteNurbsRenderer = platform.createBaseFunction( + 'gluDeleteNurbsRenderer', dll=platform.PLATFORM.GLU, resultType=None, + argTypes=[POINTER(GLUnurbs)], + doc='gluDeleteNurbsRenderer( POINTER(GLUnurbs)(nurb) ) -> None', + argNames=('nurb',), +) + + +# /usr/include/GL/glu.h 289 +gluDeleteQuadric = platform.createBaseFunction( + 'gluDeleteQuadric', dll=platform.PLATFORM.GLU, resultType=None, + argTypes=[POINTER(GLUquadric)], + doc='gluDeleteQuadric( POINTER(GLUquadric)(quad) ) -> None', + argNames=('quad',), +) + + +# /usr/include/GL/glu.h 290 +gluDeleteTess = platform.createBaseFunction( + 'gluDeleteTess', dll=platform.PLATFORM.GLU, resultType=None, + argTypes=[POINTER(GLUtesselator)], + doc='gluDeleteTess( POINTER(GLUtesselator)(tess) ) -> None', + argNames=('tess',), +) + + +# /usr/include/GL/glu.h 291 +gluDisk = platform.createBaseFunction( + 'gluDisk', dll=platform.PLATFORM.GLU, resultType=None, + argTypes=[POINTER(GLUquadric),GLdouble,GLdouble,GLint,GLint], + doc='gluDisk( POINTER(GLUquadric)(quad), GLdouble(inner), GLdouble(outer), GLint(slices), GLint(loops) ) -> None', + argNames=('quad', 'inner', 'outer', 'slices', 'loops'), +) + + +# /usr/include/GL/glu.h 292 +gluEndCurve = platform.createBaseFunction( + 'gluEndCurve', dll=platform.PLATFORM.GLU, resultType=None, + argTypes=[POINTER(GLUnurbs)], + doc='gluEndCurve( POINTER(GLUnurbs)(nurb) ) -> None', + argNames=('nurb',), +) + + +# /usr/include/GL/glu.h 293 +gluEndPolygon = platform.createBaseFunction( + 'gluEndPolygon', dll=platform.PLATFORM.GLU, resultType=None, + argTypes=[POINTER(GLUtesselator)], + doc='gluEndPolygon( POINTER(GLUtesselator)(tess) ) -> None', + argNames=('tess',), +) + + +# /usr/include/GL/glu.h 294 +gluEndSurface = platform.createBaseFunction( + 'gluEndSurface', dll=platform.PLATFORM.GLU, resultType=None, + argTypes=[POINTER(GLUnurbs)], + doc='gluEndSurface( POINTER(GLUnurbs)(nurb) ) -> None', + argNames=('nurb',), +) + + +# /usr/include/GL/glu.h 295 +gluEndTrim = platform.createBaseFunction( + 'gluEndTrim', dll=platform.PLATFORM.GLU, resultType=None, + argTypes=[POINTER(GLUnurbs)], + doc='gluEndTrim( POINTER(GLUnurbs)(nurb) ) -> None', + argNames=('nurb',), +) + + +# /usr/include/GL/glu.h 296 +gluErrorString = platform.createBaseFunction( + 'gluErrorString', dll=platform.PLATFORM.GLU, resultType=POINTER(GLubyte), + argTypes=[GLenum], + doc='gluErrorString( GLenum(error) ) -> POINTER(GLubyte)', + argNames=('error',), +) + + +# /usr/include/GL/glu.h 297 +gluGetNurbsProperty = platform.createBaseFunction( + 'gluGetNurbsProperty', dll=platform.PLATFORM.GLU, resultType=None, + argTypes=[POINTER(GLUnurbs),GLenum,arrays.GLfloatArray], + doc='gluGetNurbsProperty( POINTER(GLUnurbs)(nurb), GLenum(property), arrays.GLfloatArray(data) ) -> None', + argNames=('nurb', 'property', 'data'), +) + + +# /usr/include/GL/glu.h 298 +gluGetString = platform.createBaseFunction( + 'gluGetString', dll=platform.PLATFORM.GLU, resultType=POINTER(GLubyte), + argTypes=[GLenum], + doc='gluGetString( GLenum(name) ) -> POINTER(GLubyte)', + argNames=('name',), +) + + +# /usr/include/GL/glu.h 299 +gluGetTessProperty = platform.createBaseFunction( + 'gluGetTessProperty', dll=platform.PLATFORM.GLU, resultType=None, + argTypes=[POINTER(GLUtesselator),GLenum,arrays.GLdoubleArray], + doc='gluGetTessProperty( POINTER(GLUtesselator)(tess), GLenum(which), arrays.GLdoubleArray(data) ) -> None', + argNames=('tess', 'which', 'data'), +) + + +# /usr/include/GL/glu.h 300 +gluLoadSamplingMatrices = platform.createBaseFunction( + 'gluLoadSamplingMatrices', dll=platform.PLATFORM.GLU, resultType=None, + argTypes=[POINTER(GLUnurbs),arrays.GLfloatArray,arrays.GLfloatArray,arrays.GLintArray], + doc='gluLoadSamplingMatrices( POINTER(GLUnurbs)(nurb), arrays.GLfloatArray(model), arrays.GLfloatArray(perspective), arrays.GLintArray(view) ) -> None', + argNames=('nurb', 'model', 'perspective', 'view'), +) + + +# /usr/include/GL/glu.h 301 +gluLookAt = platform.createBaseFunction( + 'gluLookAt', dll=platform.PLATFORM.GLU, resultType=None, + argTypes=[GLdouble,GLdouble,GLdouble,GLdouble,GLdouble,GLdouble,GLdouble,GLdouble,GLdouble], + doc='gluLookAt( GLdouble(eyeX), GLdouble(eyeY), GLdouble(eyeZ), GLdouble(centerX), GLdouble(centerY), GLdouble(centerZ), GLdouble(upX), GLdouble(upY), GLdouble(upZ) ) -> None', + argNames=('eyeX', 'eyeY', 'eyeZ', 'centerX', 'centerY', 'centerZ', 'upX', 'upY', 'upZ'), +) + + +# /usr/include/GL/glu.h 302 +gluNewNurbsRenderer = platform.createBaseFunction( + 'gluNewNurbsRenderer', dll=platform.PLATFORM.GLU, resultType=POINTER(GLUnurbs), + argTypes=[], + doc='gluNewNurbsRenderer( ) -> POINTER(GLUnurbs)', + argNames=(), +) + + +# /usr/include/GL/glu.h 303 +gluNewQuadric = platform.createBaseFunction( + 'gluNewQuadric', dll=platform.PLATFORM.GLU, resultType=POINTER(GLUquadric), + argTypes=[], + doc='gluNewQuadric( ) -> POINTER(GLUquadric)', + argNames=(), +) + + +# /usr/include/GL/glu.h 304 +gluNewTess = platform.createBaseFunction( + 'gluNewTess', dll=platform.PLATFORM.GLU, resultType=POINTER(GLUtesselator), + argTypes=[], + doc='gluNewTess( ) -> POINTER(GLUtesselator)', + argNames=(), +) + + +# /usr/include/GL/glu.h 305 +gluNextContour = platform.createBaseFunction( + 'gluNextContour', dll=platform.PLATFORM.GLU, resultType=None, + argTypes=[POINTER(GLUtesselator),GLenum], + doc='gluNextContour( POINTER(GLUtesselator)(tess), GLenum(type) ) -> None', + argNames=('tess', 'type'), +) + + +_GLUfuncptr = FUNCTION_TYPE(None) +# /usr/include/GL/glu.h 306 +gluNurbsCallback = platform.createBaseFunction( + 'gluNurbsCallback', dll=platform.PLATFORM.GLU, resultType=None, + argTypes=[POINTER(GLUnurbs),GLenum,_GLUfuncptr], + doc='gluNurbsCallback( POINTER(GLUnurbs)(nurb), GLenum(which), _GLUfuncptr(CallBackFunc) ) -> None', + argNames=('nurb', 'which', 'CallBackFunc'), +) + +GLvoid = None +# /usr/include/GL/glu.h 307 +gluNurbsCallbackData = platform.createBaseFunction( + 'gluNurbsCallbackData', dll=platform.PLATFORM.GLU, resultType=None, + argTypes=[POINTER(GLUnurbs),POINTER(GLvoid)], + doc='gluNurbsCallbackData( POINTER(GLUnurbs)(nurb), POINTER(GLvoid)(userData) ) -> None', + argNames=('nurb', 'userData'), +) + + +# /usr/include/GL/glu.h 308 +gluNurbsCallbackDataEXT = platform.createBaseFunction( + 'gluNurbsCallbackDataEXT', dll=platform.PLATFORM.GLU, resultType=None, + argTypes=[POINTER(GLUnurbs),POINTER(GLvoid)], + doc='gluNurbsCallbackDataEXT( POINTER(GLUnurbs)(nurb), POINTER(GLvoid)(userData) ) -> None', + argNames=('nurb', 'userData'), +) + + +# /usr/include/GL/glu.h 309 +gluNurbsCurve = platform.createBaseFunction( + 'gluNurbsCurve', dll=platform.PLATFORM.GLU, resultType=None, + argTypes=[POINTER(GLUnurbs),GLint,arrays.GLfloatArray,GLint,arrays.GLfloatArray,GLint,GLenum], + doc='gluNurbsCurve( POINTER(GLUnurbs)(nurb), GLint(knotCount), arrays.GLfloatArray(knots), GLint(stride), arrays.GLfloatArray(control), GLint(order), GLenum(type) ) -> None', + argNames=('nurb', 'knotCount', 'knots', 'stride', 'control', 'order', 'type'), +) + + +# /usr/include/GL/glu.h 310 +gluNurbsProperty = platform.createBaseFunction( + 'gluNurbsProperty', dll=platform.PLATFORM.GLU, resultType=None, + argTypes=[POINTER(GLUnurbs),GLenum,GLfloat], + doc='gluNurbsProperty( POINTER(GLUnurbs)(nurb), GLenum(property), GLfloat(value) ) -> None', + argNames=('nurb', 'property', 'value'), +) + + +# /usr/include/GL/glu.h 311 +gluNurbsSurface = platform.createBaseFunction( + 'gluNurbsSurface', dll=platform.PLATFORM.GLU, resultType=None, + argTypes=[POINTER(GLUnurbs),GLint,arrays.GLfloatArray,GLint,arrays.GLfloatArray,GLint,GLint,arrays.GLfloatArray,GLint,GLint,GLenum], + doc='gluNurbsSurface( POINTER(GLUnurbs)(nurb), GLint(sKnotCount), arrays.GLfloatArray(sKnots), GLint(tKnotCount), arrays.GLfloatArray(tKnots), GLint(sStride), GLint(tStride), arrays.GLfloatArray(control), GLint(sOrder), GLint(tOrder), GLenum(type) ) -> None', + argNames=('nurb', 'sKnotCount', 'sKnots', 'tKnotCount', 'tKnots', 'sStride', 'tStride', 'control', 'sOrder', 'tOrder', 'type'), +) + + +# /usr/include/GL/glu.h 312 +gluOrtho2D = platform.createBaseFunction( + 'gluOrtho2D', dll=platform.PLATFORM.GLU, resultType=None, + argTypes=[GLdouble,GLdouble,GLdouble,GLdouble], + doc='gluOrtho2D( GLdouble(left), GLdouble(right), GLdouble(bottom), GLdouble(top) ) -> None', + argNames=('left', 'right', 'bottom', 'top'), +) + + +# /usr/include/GL/glu.h 313 +gluPartialDisk = platform.createBaseFunction( + 'gluPartialDisk', dll=platform.PLATFORM.GLU, resultType=None, + argTypes=[POINTER(GLUquadric),GLdouble,GLdouble,GLint,GLint,GLdouble,GLdouble], + doc='gluPartialDisk( POINTER(GLUquadric)(quad), GLdouble(inner), GLdouble(outer), GLint(slices), GLint(loops), GLdouble(start), GLdouble(sweep) ) -> None', + argNames=('quad', 'inner', 'outer', 'slices', 'loops', 'start', 'sweep'), +) + + +# /usr/include/GL/glu.h 314 +gluPerspective = platform.createBaseFunction( + 'gluPerspective', dll=platform.PLATFORM.GLU, resultType=None, + argTypes=[GLdouble,GLdouble,GLdouble,GLdouble], + doc='gluPerspective( GLdouble(fovy), GLdouble(aspect), GLdouble(zNear), GLdouble(zFar) ) -> None', + argNames=('fovy', 'aspect', 'zNear', 'zFar'), +) + + +# /usr/include/GL/glu.h 315 +gluPickMatrix = platform.createBaseFunction( + 'gluPickMatrix', dll=platform.PLATFORM.GLU, resultType=None, + argTypes=[GLdouble,GLdouble,GLdouble,GLdouble,arrays.GLintArray], + doc='gluPickMatrix( GLdouble(x), GLdouble(y), GLdouble(delX), GLdouble(delY), arrays.GLintArray(viewport) ) -> None', + argNames=('x', 'y', 'delX', 'delY', 'viewport'), +) + + +# /usr/include/GL/glu.h 316 +gluProject = platform.createBaseFunction( + 'gluProject', dll=platform.PLATFORM.GLU, resultType=GLint, + argTypes=[GLdouble,GLdouble,GLdouble,arrays.GLdoubleArray,arrays.GLdoubleArray,arrays.GLintArray,arrays.GLdoubleArray,arrays.GLdoubleArray,arrays.GLdoubleArray], + doc='gluProject( GLdouble(objX), GLdouble(objY), GLdouble(objZ), arrays.GLdoubleArray(model), arrays.GLdoubleArray(proj), arrays.GLintArray(view), arrays.GLdoubleArray(winX), arrays.GLdoubleArray(winY), arrays.GLdoubleArray(winZ) ) -> GLint', + argNames=('objX', 'objY', 'objZ', 'model', 'proj', 'view', 'winX', 'winY', 'winZ'), +) + + +# /usr/include/GL/glu.h 317 +gluPwlCurve = platform.createBaseFunction( + 'gluPwlCurve', dll=platform.PLATFORM.GLU, resultType=None, + argTypes=[POINTER(GLUnurbs),GLint,arrays.GLfloatArray,GLint,GLenum], + doc='gluPwlCurve( POINTER(GLUnurbs)(nurb), GLint(count), arrays.GLfloatArray(data), GLint(stride), GLenum(type) ) -> None', + argNames=('nurb', 'count', 'data', 'stride', 'type'), +) + + +# /usr/include/GL/glu.h 318 +gluQuadricCallback = platform.createBaseFunction( + 'gluQuadricCallback', dll=platform.PLATFORM.GLU, resultType=None, + argTypes=[POINTER(GLUquadric),GLenum,_GLUfuncptr], + doc='gluQuadricCallback( POINTER(GLUquadric)(quad), GLenum(which), _GLUfuncptr(CallBackFunc) ) -> None', + argNames=('quad', 'which', 'CallBackFunc'), +) + + +# /usr/include/GL/glu.h 319 +gluQuadricDrawStyle = platform.createBaseFunction( + 'gluQuadricDrawStyle', dll=platform.PLATFORM.GLU, resultType=None, + argTypes=[POINTER(GLUquadric),GLenum], + doc='gluQuadricDrawStyle( POINTER(GLUquadric)(quad), GLenum(draw) ) -> None', + argNames=('quad', 'draw'), +) + + +# /usr/include/GL/glu.h 320 +gluQuadricNormals = platform.createBaseFunction( + 'gluQuadricNormals', dll=platform.PLATFORM.GLU, resultType=None, + argTypes=[POINTER(GLUquadric),GLenum], + doc='gluQuadricNormals( POINTER(GLUquadric)(quad), GLenum(normal) ) -> None', + argNames=('quad', 'normal'), +) + + +# /usr/include/GL/glu.h 321 +gluQuadricOrientation = platform.createBaseFunction( + 'gluQuadricOrientation', dll=platform.PLATFORM.GLU, resultType=None, + argTypes=[POINTER(GLUquadric),GLenum], + doc='gluQuadricOrientation( POINTER(GLUquadric)(quad), GLenum(orientation) ) -> None', + argNames=('quad', 'orientation'), +) + + +# /usr/include/GL/glu.h 322 +gluQuadricTexture = platform.createBaseFunction( + 'gluQuadricTexture', dll=platform.PLATFORM.GLU, resultType=None, + argTypes=[POINTER(GLUquadric),GLboolean], + doc='gluQuadricTexture( POINTER(GLUquadric)(quad), GLboolean(texture) ) -> None', + argNames=('quad', 'texture'), +) + + +# /usr/include/GL/glu.h 323 +gluScaleImage = platform.createBaseFunction( + 'gluScaleImage', dll=platform.PLATFORM.GLU, resultType=GLint, + argTypes=[GLenum,GLsizei,GLsizei,GLenum,c_void_p,GLsizei,GLsizei,GLenum,POINTER(GLvoid)], + doc='gluScaleImage( GLenum(format), GLsizei(wIn), GLsizei(hIn), GLenum(typeIn), c_void_p(dataIn), GLsizei(wOut), GLsizei(hOut), GLenum(typeOut), POINTER(GLvoid)(dataOut) ) -> GLint', + argNames=('format', 'wIn', 'hIn', 'typeIn', 'dataIn', 'wOut', 'hOut', 'typeOut', 'dataOut'), +) + + +# /usr/include/GL/glu.h 324 +gluSphere = platform.createBaseFunction( + 'gluSphere', dll=platform.PLATFORM.GLU, resultType=None, + argTypes=[POINTER(GLUquadric),GLdouble,GLint,GLint], + doc='gluSphere( POINTER(GLUquadric)(quad), GLdouble(radius), GLint(slices), GLint(stacks) ) -> None', + argNames=('quad', 'radius', 'slices', 'stacks'), +) + + +# /usr/include/GL/glu.h 325 +gluTessBeginContour = platform.createBaseFunction( + 'gluTessBeginContour', dll=platform.PLATFORM.GLU, resultType=None, + argTypes=[POINTER(GLUtesselator)], + doc='gluTessBeginContour( POINTER(GLUtesselator)(tess) ) -> None', + argNames=('tess',), +) + + +# /usr/include/GL/glu.h 326 +gluTessBeginPolygon = platform.createBaseFunction( + 'gluTessBeginPolygon', dll=platform.PLATFORM.GLU, resultType=None, + argTypes=[POINTER(GLUtesselator),POINTER(GLvoid)], + doc='gluTessBeginPolygon( POINTER(GLUtesselator)(tess), POINTER(GLvoid)(data) ) -> None', + argNames=('tess', 'data'), +) + + +# /usr/include/GL/glu.h 327 +gluTessCallback = platform.createBaseFunction( + 'gluTessCallback', dll=platform.PLATFORM.GLU, resultType=None, + argTypes=[POINTER(GLUtesselator),GLenum,_GLUfuncptr], + doc='gluTessCallback( POINTER(GLUtesselator)(tess), GLenum(which), _GLUfuncptr(CallBackFunc) ) -> None', + argNames=('tess', 'which', 'CallBackFunc'), +) + + +# /usr/include/GL/glu.h 328 +gluTessEndContour = platform.createBaseFunction( + 'gluTessEndContour', dll=platform.PLATFORM.GLU, resultType=None, + argTypes=[POINTER(GLUtesselator)], + doc='gluTessEndContour( POINTER(GLUtesselator)(tess) ) -> None', + argNames=('tess',), +) + + +# /usr/include/GL/glu.h 329 +gluTessEndPolygon = platform.createBaseFunction( + 'gluTessEndPolygon', dll=platform.PLATFORM.GLU, resultType=None, + argTypes=[POINTER(GLUtesselator)], + doc='gluTessEndPolygon( POINTER(GLUtesselator)(tess) ) -> None', + argNames=('tess',), +) + + +# /usr/include/GL/glu.h 330 +gluTessNormal = platform.createBaseFunction( + 'gluTessNormal', dll=platform.PLATFORM.GLU, resultType=None, + argTypes=[POINTER(GLUtesselator),GLdouble,GLdouble,GLdouble], + doc='gluTessNormal( POINTER(GLUtesselator)(tess), GLdouble(valueX), GLdouble(valueY), GLdouble(valueZ) ) -> None', + argNames=('tess', 'valueX', 'valueY', 'valueZ'), +) + + +# /usr/include/GL/glu.h 331 +gluTessProperty = platform.createBaseFunction( + 'gluTessProperty', dll=platform.PLATFORM.GLU, resultType=None, + argTypes=[POINTER(GLUtesselator),GLenum,GLdouble], + doc='gluTessProperty( POINTER(GLUtesselator)(tess), GLenum(which), GLdouble(data) ) -> None', + argNames=('tess', 'which', 'data'), +) + + +# /usr/include/GL/glu.h 332 +gluTessVertex = platform.createBaseFunction( + 'gluTessVertex', dll=platform.PLATFORM.GLU, resultType=None, + argTypes=[POINTER(GLUtesselator),arrays.GLdoubleArray,POINTER(GLvoid)], + doc='gluTessVertex( POINTER(GLUtesselator)(tess), arrays.GLdoubleArray(location), POINTER(GLvoid)(data) ) -> None', + argNames=('tess', 'location', 'data'), +) + + +# /usr/include/GL/glu.h 333 +gluUnProject = platform.createBaseFunction( + 'gluUnProject', dll=platform.PLATFORM.GLU, resultType=GLint, + argTypes=[GLdouble,GLdouble,GLdouble,arrays.GLdoubleArray,arrays.GLdoubleArray,arrays.GLintArray,arrays.GLdoubleArray,arrays.GLdoubleArray,arrays.GLdoubleArray], + doc='gluUnProject( GLdouble(winX), GLdouble(winY), GLdouble(winZ), arrays.GLdoubleArray(model), arrays.GLdoubleArray(proj), arrays.GLintArray(view), arrays.GLdoubleArray(objX), arrays.GLdoubleArray(objY), arrays.GLdoubleArray(objZ) ) -> GLint', + argNames=('winX', 'winY', 'winZ', 'model', 'proj', 'view', 'objX', 'objY', 'objZ'), +) + + +# /usr/include/GL/glu.h 334 +gluUnProject4 = platform.createBaseFunction( + 'gluUnProject4', dll=platform.PLATFORM.GLU, resultType=GLint, + argTypes=[GLdouble,GLdouble,GLdouble,GLdouble,arrays.GLdoubleArray,arrays.GLdoubleArray,arrays.GLintArray,GLdouble,GLdouble,arrays.GLdoubleArray,arrays.GLdoubleArray,arrays.GLdoubleArray,arrays.GLdoubleArray], + doc='gluUnProject4( GLdouble(winX), GLdouble(winY), GLdouble(winZ), GLdouble(clipW), arrays.GLdoubleArray(model), arrays.GLdoubleArray(proj), arrays.GLintArray(view), GLdouble(nearVal), GLdouble(farVal), arrays.GLdoubleArray(objX), arrays.GLdoubleArray(objY), arrays.GLdoubleArray(objZ), arrays.GLdoubleArray(objW) ) -> GLint', + argNames=('winX', 'winY', 'winZ', 'clipW', 'model', 'proj', 'view', 'nearVal', 'farVal', 'objX', 'objY', 'objZ', 'objW'), +) + +__all__ = [ + 'GLU_AUTO_LOAD_MATRIX', + 'GLU_BEGIN', + 'GLU_CCW', + 'GLU_CULLING', + 'GLU_CW', + 'GLU_DISPLAY_MODE', + 'GLU_DOMAIN_DISTANCE', + 'GLU_EDGE_FLAG', + 'GLU_END', + 'GLU_ERROR', + 'GLU_EXTENSIONS', + 'GLU_EXTERIOR', + 'GLU_FALSE', + 'GLU_FILL', + 'GLU_FLAT', + 'GLU_INCOMPATIBLE_GL_VERSION', + 'GLU_INSIDE', + 'GLU_INTERIOR', + 'GLU_INVALID_ENUM', + 'GLU_INVALID_OPERATION', + 'GLU_INVALID_VALUE', + 'GLU_LINE', + 'GLU_MAP1_TRIM_2', + 'GLU_MAP1_TRIM_3', + 'GLU_NONE', + 'GLU_NURBS_BEGIN', + 'GLU_NURBS_BEGIN_DATA', + 'GLU_NURBS_BEGIN_DATA_EXT', + 'GLU_NURBS_BEGIN_EXT', + 'GLU_NURBS_COLOR', + 'GLU_NURBS_COLOR_DATA', + 'GLU_NURBS_COLOR_DATA_EXT', + 'GLU_NURBS_COLOR_EXT', + 'GLU_NURBS_END', + 'GLU_NURBS_END_DATA', + 'GLU_NURBS_END_DATA_EXT', + 'GLU_NURBS_END_EXT', + 'GLU_NURBS_ERROR', + 'GLU_NURBS_ERROR1', + 'GLU_NURBS_ERROR10', + 'GLU_NURBS_ERROR11', + 'GLU_NURBS_ERROR12', + 'GLU_NURBS_ERROR13', + 'GLU_NURBS_ERROR14', + 'GLU_NURBS_ERROR15', + 'GLU_NURBS_ERROR16', + 'GLU_NURBS_ERROR17', + 'GLU_NURBS_ERROR18', + 'GLU_NURBS_ERROR19', + 'GLU_NURBS_ERROR2', + 'GLU_NURBS_ERROR20', + 'GLU_NURBS_ERROR21', + 'GLU_NURBS_ERROR22', + 'GLU_NURBS_ERROR23', + 'GLU_NURBS_ERROR24', + 'GLU_NURBS_ERROR25', + 'GLU_NURBS_ERROR26', + 'GLU_NURBS_ERROR27', + 'GLU_NURBS_ERROR28', + 'GLU_NURBS_ERROR29', + 'GLU_NURBS_ERROR3', + 'GLU_NURBS_ERROR30', + 'GLU_NURBS_ERROR31', + 'GLU_NURBS_ERROR32', + 'GLU_NURBS_ERROR33', + 'GLU_NURBS_ERROR34', + 'GLU_NURBS_ERROR35', + 'GLU_NURBS_ERROR36', + 'GLU_NURBS_ERROR37', + 'GLU_NURBS_ERROR4', + 'GLU_NURBS_ERROR5', + 'GLU_NURBS_ERROR6', + 'GLU_NURBS_ERROR7', + 'GLU_NURBS_ERROR8', + 'GLU_NURBS_ERROR9', + 'GLU_NURBS_MODE', + 'GLU_NURBS_MODE_EXT', + 'GLU_NURBS_NORMAL', + 'GLU_NURBS_NORMAL_DATA', + 'GLU_NURBS_NORMAL_DATA_EXT', + 'GLU_NURBS_NORMAL_EXT', + 'GLU_NURBS_RENDERER', + 'GLU_NURBS_RENDERER_EXT', + 'GLU_NURBS_TESSELLATOR', + 'GLU_NURBS_TESSELLATOR_EXT', + 'GLU_NURBS_TEXTURE_COORD', + 'GLU_NURBS_TEXTURE_COORD_DATA', + 'GLU_NURBS_TEX_COORD_DATA_EXT', + 'GLU_NURBS_TEX_COORD_EXT', + 'GLU_NURBS_VERTEX', + 'GLU_NURBS_VERTEX_DATA', + 'GLU_NURBS_VERTEX_DATA_EXT', + 'GLU_NURBS_VERTEX_EXT', + 'GLU_OBJECT_PARAMETRIC_ERROR', + 'GLU_OBJECT_PARAMETRIC_ERROR_EXT', + 'GLU_OBJECT_PATH_LENGTH', + 'GLU_OBJECT_PATH_LENGTH_EXT', + 'GLU_OUTLINE_PATCH', + 'GLU_OUTLINE_POLYGON', + 'GLU_OUTSIDE', + 'GLU_OUT_OF_MEMORY', + 'GLU_PARAMETRIC_ERROR', + 'GLU_PARAMETRIC_TOLERANCE', + 'GLU_PATH_LENGTH', + 'GLU_POINT', + 'GLU_SAMPLING_METHOD', + 'GLU_SAMPLING_TOLERANCE', + 'GLU_SILHOUETTE', + 'GLU_SMOOTH', + 'GLU_TESS_BEGIN', + 'GLU_TESS_BEGIN_DATA', + 'GLU_TESS_BOUNDARY_ONLY', + 'GLU_TESS_COMBINE', + 'GLU_TESS_COMBINE_DATA', + 'GLU_TESS_COORD_TOO_LARGE', + 'GLU_TESS_EDGE_FLAG', + 'GLU_TESS_EDGE_FLAG_DATA', + 'GLU_TESS_END', + 'GLU_TESS_END_DATA', + 'GLU_TESS_ERROR', + 'GLU_TESS_ERROR1', + 'GLU_TESS_ERROR2', + 'GLU_TESS_ERROR3', + 'GLU_TESS_ERROR4', + 'GLU_TESS_ERROR5', + 'GLU_TESS_ERROR6', + 'GLU_TESS_ERROR7', + 'GLU_TESS_ERROR8', + 'GLU_TESS_ERROR_DATA', + 'GLU_TESS_MAX_COORD', + 'GLU_TESS_MISSING_BEGIN_CONTOUR', + 'GLU_TESS_MISSING_BEGIN_POLYGON', + 'GLU_TESS_MISSING_END_CONTOUR', + 'GLU_TESS_MISSING_END_POLYGON', + 'GLU_TESS_NEED_COMBINE_CALLBACK', + 'GLU_TESS_TOLERANCE', + 'GLU_TESS_VERTEX', + 'GLU_TESS_VERTEX_DATA', + 'GLU_TESS_WINDING_ABS_GEQ_TWO', + 'GLU_TESS_WINDING_NEGATIVE', + 'GLU_TESS_WINDING_NONZERO', + 'GLU_TESS_WINDING_ODD', + 'GLU_TESS_WINDING_POSITIVE', + 'GLU_TESS_WINDING_RULE', + 'GLU_TRUE', + 'GLU_UNKNOWN', + 'GLU_U_STEP', + 'GLU_VERSION', + 'GLU_VERSION_1_1', + 'GLU_VERSION_1_2', + 'GLU_VERSION_1_3', + 'GLU_VERTEX', + 'GLU_V_STEP', + 'GLUnurbs', + 'GLUnurbsObj', + 'GLUquadric', + 'GLUquadricObj', + 'GLUtesselator', + 'GLUtesselatorObj', + 'GLUtriangulatorObj', + 'GLboolean', + 'GLdouble', + 'GLenum', + 'GLfloat', + 'GLint', + 'GLsizei', + 'GLubyte', + 'GLvoid', + '_GLUfuncptr', + 'gluBeginCurve', + 'gluBeginPolygon', + 'gluBeginSurface', + 'gluBeginTrim', + 'gluBuild1DMipmapLevels', + 'gluBuild1DMipmaps', + 'gluBuild2DMipmapLevels', + 'gluBuild2DMipmaps', + 'gluBuild3DMipmapLevels', + 'gluBuild3DMipmaps', + 'gluCheckExtension', + 'gluCylinder', + 'gluDeleteNurbsRenderer', + 'gluDeleteQuadric', + 'gluDeleteTess', + 'gluDisk', + 'gluEndCurve', + 'gluEndPolygon', + 'gluEndSurface', + 'gluEndTrim', + 'gluErrorString', + 'gluGetNurbsProperty', + 'gluGetString', + 'gluGetTessProperty', + 'gluLoadSamplingMatrices', + 'gluLookAt', + 'gluNewNurbsRenderer', + 'gluNewQuadric', + 'gluNewTess', + 'gluNextContour', + 'gluNurbsCallback', + 'gluNurbsCallbackData', + 'gluNurbsCallbackDataEXT', + 'gluNurbsCurve', + 'gluNurbsProperty', + 'gluNurbsSurface', + 'gluOrtho2D', + 'gluPartialDisk', + 'gluPerspective', + 'gluPickMatrix', + 'gluProject', + 'gluPwlCurve', + 'gluQuadricCallback', + 'gluQuadricDrawStyle', + 'gluQuadricNormals', + 'gluQuadricOrientation', + 'gluQuadricTexture', + 'gluScaleImage', + 'gluSphere', + 'gluTessBeginContour', + 'gluTessBeginPolygon', + 'gluTessCallback', + 'gluTessEndContour', + 'gluTessEndPolygon', + 'gluTessNormal', + 'gluTessProperty', + 'gluTessVertex', + 'gluUnProject', + 'gluUnProject4' +] diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLU/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLU/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..7b74d905 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLU/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLU/__pycache__/_errors.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLU/__pycache__/_errors.cpython-312.pyc new file mode 100644 index 00000000..bd49ebc2 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLU/__pycache__/_errors.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLU/__pycache__/annotations.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLU/__pycache__/annotations.cpython-312.pyc new file mode 100644 index 00000000..c63bd3d5 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLU/__pycache__/annotations.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLU/__pycache__/constants.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLU/__pycache__/constants.cpython-312.pyc new file mode 100644 index 00000000..b163429f Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLU/__pycache__/constants.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLU/_errors.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLU/_errors.py new file mode 100644 index 00000000..d67e9e11 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLU/_errors.py @@ -0,0 +1,6 @@ +from OpenGL.platform import PLATFORM as _p +from OpenGL.error import _ErrorChecker +if _ErrorChecker: + _error_checker = _ErrorChecker( _p, _p.GL.glGetError ) +else: + _error_checker = None diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLU/annotations.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLU/annotations.py new file mode 100644 index 00000000..c99ab202 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLU/annotations.py @@ -0,0 +1,222 @@ +"""Array-size annotations for OpenGL.raw.GLU + +Automatically generated by the generateraw script, do not edit! +""" +from OpenGL.raw import GLU as raw + +from ctypes import * +from OpenGL import platform, arrays +from OpenGL.constant import Constant +from OpenGL.raw.GL import _types as GL_types +GLvoid = GL_types.GLvoid + + + +gluCheckExtension = arrays.setInputArraySizeType( + arrays.setInputArraySizeType( + raw.gluCheckExtension, + None, # XXX Could not determine size of argument extName for gluCheckExtension arrays.GLubyteArray + arrays.GLubyteArray, + 'extName', + ), + None, # XXX Could not determine size of argument extString for gluCheckExtension arrays.GLubyteArray + arrays.GLubyteArray, + 'extString', +) + +gluGetNurbsProperty = arrays.setInputArraySizeType( + raw.gluGetNurbsProperty, + None, # XXX Could not determine size of argument data for gluGetNurbsProperty arrays.GLfloatArray + arrays.GLfloatArray, + 'data', +) + +gluGetTessProperty = arrays.setInputArraySizeType( + raw.gluGetTessProperty, + None, # XXX Could not determine size of argument data for gluGetTessProperty arrays.GLdoubleArray + arrays.GLdoubleArray, + 'data', +) + +gluLoadSamplingMatrices = arrays.setInputArraySizeType( + arrays.setInputArraySizeType( + arrays.setInputArraySizeType( + raw.gluLoadSamplingMatrices, + None, # XXX Could not determine size of argument model for gluLoadSamplingMatrices arrays.GLfloatArray + arrays.GLfloatArray, + 'model', + ), + None, # XXX Could not determine size of argument perspective for gluLoadSamplingMatrices arrays.GLfloatArray + arrays.GLfloatArray, + 'perspective', + ), + None, # XXX Could not determine size of argument view for gluLoadSamplingMatrices arrays.GLintArray + arrays.GLintArray, + 'view', +) + +gluNurbsCurve = arrays.setInputArraySizeType( + arrays.setInputArraySizeType( + raw.gluNurbsCurve, + None, # XXX Could not determine size of argument knots for gluNurbsCurve arrays.GLfloatArray + arrays.GLfloatArray, + 'knots', + ), + None, # XXX Could not determine size of argument control for gluNurbsCurve arrays.GLfloatArray + arrays.GLfloatArray, + 'control', +) + +gluNurbsSurface = arrays.setInputArraySizeType( + arrays.setInputArraySizeType( + arrays.setInputArraySizeType( + raw.gluNurbsSurface, + None, # XXX Could not determine size of argument sKnots for gluNurbsSurface arrays.GLfloatArray + arrays.GLfloatArray, + 'sKnots', + ), + None, # XXX Could not determine size of argument tKnots for gluNurbsSurface arrays.GLfloatArray + arrays.GLfloatArray, + 'tKnots', + ), + None, # XXX Could not determine size of argument control for gluNurbsSurface arrays.GLfloatArray + arrays.GLfloatArray, + 'control', +) + +gluPickMatrix = arrays.setInputArraySizeType( + raw.gluPickMatrix, + None, # XXX Could not determine size of argument viewport for gluPickMatrix arrays.GLintArray + arrays.GLintArray, + 'viewport', +) + +gluProject = arrays.setInputArraySizeType( + arrays.setInputArraySizeType( + arrays.setInputArraySizeType( + arrays.setInputArraySizeType( + arrays.setInputArraySizeType( + arrays.setInputArraySizeType( + raw.gluProject, + None, # XXX Could not determine size of argument model for gluProject arrays.GLdoubleArray + arrays.GLdoubleArray, + 'model', + ), + None, # XXX Could not determine size of argument proj for gluProject arrays.GLdoubleArray + arrays.GLdoubleArray, + 'proj', + ), + None, # XXX Could not determine size of argument view for gluProject arrays.GLintArray + arrays.GLintArray, + 'view', + ), + None, # XXX Could not determine size of argument winX for gluProject arrays.GLdoubleArray + arrays.GLdoubleArray, + 'winX', + ), + None, # XXX Could not determine size of argument winY for gluProject arrays.GLdoubleArray + arrays.GLdoubleArray, + 'winY', + ), + None, # XXX Could not determine size of argument winZ for gluProject arrays.GLdoubleArray + arrays.GLdoubleArray, + 'winZ', +) + +gluPwlCurve = arrays.setInputArraySizeType( + raw.gluPwlCurve, + None, # XXX Could not determine size of argument data for gluPwlCurve arrays.GLfloatArray + arrays.GLfloatArray, + 'data', +) + +gluTessVertex = arrays.setInputArraySizeType( + raw.gluTessVertex, + None, # XXX Could not determine size of argument location for gluTessVertex arrays.GLdoubleArray + arrays.GLdoubleArray, + 'location', +) + +gluUnProject = arrays.setInputArraySizeType( + arrays.setInputArraySizeType( + arrays.setInputArraySizeType( + arrays.setInputArraySizeType( + arrays.setInputArraySizeType( + arrays.setInputArraySizeType( + raw.gluUnProject, + None, # XXX Could not determine size of argument model for gluUnProject arrays.GLdoubleArray + arrays.GLdoubleArray, + 'model', + ), + None, # XXX Could not determine size of argument proj for gluUnProject arrays.GLdoubleArray + arrays.GLdoubleArray, + 'proj', + ), + None, # XXX Could not determine size of argument view for gluUnProject arrays.GLintArray + arrays.GLintArray, + 'view', + ), + None, # XXX Could not determine size of argument objX for gluUnProject arrays.GLdoubleArray + arrays.GLdoubleArray, + 'objX', + ), + None, # XXX Could not determine size of argument objY for gluUnProject arrays.GLdoubleArray + arrays.GLdoubleArray, + 'objY', + ), + None, # XXX Could not determine size of argument objZ for gluUnProject arrays.GLdoubleArray + arrays.GLdoubleArray, + 'objZ', +) + +gluUnProject4 = arrays.setInputArraySizeType( + arrays.setInputArraySizeType( + arrays.setInputArraySizeType( + arrays.setInputArraySizeType( + arrays.setInputArraySizeType( + arrays.setInputArraySizeType( + arrays.setInputArraySizeType( + raw.gluUnProject4, + None, # XXX Could not determine size of argument model for gluUnProject4 arrays.GLdoubleArray + arrays.GLdoubleArray, + 'model', + ), + None, # XXX Could not determine size of argument proj for gluUnProject4 arrays.GLdoubleArray + arrays.GLdoubleArray, + 'proj', + ), + None, # XXX Could not determine size of argument view for gluUnProject4 arrays.GLintArray + arrays.GLintArray, + 'view', + ), + None, # XXX Could not determine size of argument objX for gluUnProject4 arrays.GLdoubleArray + arrays.GLdoubleArray, + 'objX', + ), + None, # XXX Could not determine size of argument objY for gluUnProject4 arrays.GLdoubleArray + arrays.GLdoubleArray, + 'objY', + ), + None, # XXX Could not determine size of argument objZ for gluUnProject4 arrays.GLdoubleArray + arrays.GLdoubleArray, + 'objZ', + ), + None, # XXX Could not determine size of argument objW for gluUnProject4 arrays.GLdoubleArray + arrays.GLdoubleArray, + 'objW', +) + +__all__ = [ + 'gluCheckExtension', + 'gluGetNurbsProperty', + 'gluGetTessProperty', + 'gluLoadSamplingMatrices', + 'gluNurbsCurve', + 'gluNurbsSurface', + 'gluPickMatrix', + 'gluProject', + 'gluPwlCurve', + 'gluTessVertex', + 'gluUnProject', + 'gluUnProject4' +] diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLU/constants.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLU/constants.py new file mode 100644 index 00000000..773244f9 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLU/constants.py @@ -0,0 +1,320 @@ +"""Constants for OpenGL.GLU + +Automatically generated by the generateraw script, do not edit! +""" + +from ctypes import * +from OpenGL import platform, arrays +from OpenGL.constant import Constant +from OpenGL.raw.GL import _types as GL_types +GLvoid = GL_types.GLvoid + + +GLU_AUTO_LOAD_MATRIX = Constant( 'GLU_AUTO_LOAD_MATRIX', 100200) +GLU_BEGIN = Constant( 'GLU_BEGIN', 100100) +GLU_CCW = Constant( 'GLU_CCW', 100121) +GLU_CULLING = Constant( 'GLU_CULLING', 100201) +GLU_CW = Constant( 'GLU_CW', 100120) +GLU_DISPLAY_MODE = Constant( 'GLU_DISPLAY_MODE', 100204) +GLU_DOMAIN_DISTANCE = Constant( 'GLU_DOMAIN_DISTANCE', 100217) +GLU_EDGE_FLAG = Constant( 'GLU_EDGE_FLAG', 100104) +GLU_END = Constant( 'GLU_END', 100102) +GLU_ERROR = Constant( 'GLU_ERROR', 100103) +GLU_EXTENSIONS = Constant( 'GLU_EXTENSIONS', 100801) +GLU_EXTERIOR = Constant( 'GLU_EXTERIOR', 100123) +GLU_FALSE = Constant( 'GLU_FALSE', 0) +GLU_FILL = Constant( 'GLU_FILL', 100012) +GLU_FLAT = Constant( 'GLU_FLAT', 100001) +GLU_INCOMPATIBLE_GL_VERSION = Constant( 'GLU_INCOMPATIBLE_GL_VERSION', 100903) +GLU_INSIDE = Constant( 'GLU_INSIDE', 100021) +GLU_INTERIOR = Constant( 'GLU_INTERIOR', 100122) +GLU_INVALID_ENUM = Constant( 'GLU_INVALID_ENUM', 100900) +GLU_INVALID_OPERATION = Constant( 'GLU_INVALID_OPERATION', 100904) +GLU_INVALID_VALUE = Constant( 'GLU_INVALID_VALUE', 100901) +GLU_LINE = Constant( 'GLU_LINE', 100011) +GLU_MAP1_TRIM_2 = Constant( 'GLU_MAP1_TRIM_2', 100210) +GLU_MAP1_TRIM_3 = Constant( 'GLU_MAP1_TRIM_3', 100211) +GLU_NONE = Constant( 'GLU_NONE', 100002) +GLU_NURBS_BEGIN = Constant( 'GLU_NURBS_BEGIN', 100164) +GLU_NURBS_BEGIN_DATA = Constant( 'GLU_NURBS_BEGIN_DATA', 100170) +GLU_NURBS_BEGIN_DATA_EXT = Constant( 'GLU_NURBS_BEGIN_DATA_EXT', 100170) +GLU_NURBS_BEGIN_EXT = Constant( 'GLU_NURBS_BEGIN_EXT', 100164) +GLU_NURBS_COLOR = Constant( 'GLU_NURBS_COLOR', 100167) +GLU_NURBS_COLOR_DATA = Constant( 'GLU_NURBS_COLOR_DATA', 100173) +GLU_NURBS_COLOR_DATA_EXT = Constant( 'GLU_NURBS_COLOR_DATA_EXT', 100173) +GLU_NURBS_COLOR_EXT = Constant( 'GLU_NURBS_COLOR_EXT', 100167) +GLU_NURBS_END = Constant( 'GLU_NURBS_END', 100169) +GLU_NURBS_END_DATA = Constant( 'GLU_NURBS_END_DATA', 100175) +GLU_NURBS_END_DATA_EXT = Constant( 'GLU_NURBS_END_DATA_EXT', 100175) +GLU_NURBS_END_EXT = Constant( 'GLU_NURBS_END_EXT', 100169) +GLU_NURBS_ERROR = Constant( 'GLU_NURBS_ERROR', 100103) +GLU_NURBS_ERROR1 = Constant( 'GLU_NURBS_ERROR1', 100251) +GLU_NURBS_ERROR10 = Constant( 'GLU_NURBS_ERROR10', 100260) +GLU_NURBS_ERROR11 = Constant( 'GLU_NURBS_ERROR11', 100261) +GLU_NURBS_ERROR12 = Constant( 'GLU_NURBS_ERROR12', 100262) +GLU_NURBS_ERROR13 = Constant( 'GLU_NURBS_ERROR13', 100263) +GLU_NURBS_ERROR14 = Constant( 'GLU_NURBS_ERROR14', 100264) +GLU_NURBS_ERROR15 = Constant( 'GLU_NURBS_ERROR15', 100265) +GLU_NURBS_ERROR16 = Constant( 'GLU_NURBS_ERROR16', 100266) +GLU_NURBS_ERROR17 = Constant( 'GLU_NURBS_ERROR17', 100267) +GLU_NURBS_ERROR18 = Constant( 'GLU_NURBS_ERROR18', 100268) +GLU_NURBS_ERROR19 = Constant( 'GLU_NURBS_ERROR19', 100269) +GLU_NURBS_ERROR2 = Constant( 'GLU_NURBS_ERROR2', 100252) +GLU_NURBS_ERROR20 = Constant( 'GLU_NURBS_ERROR20', 100270) +GLU_NURBS_ERROR21 = Constant( 'GLU_NURBS_ERROR21', 100271) +GLU_NURBS_ERROR22 = Constant( 'GLU_NURBS_ERROR22', 100272) +GLU_NURBS_ERROR23 = Constant( 'GLU_NURBS_ERROR23', 100273) +GLU_NURBS_ERROR24 = Constant( 'GLU_NURBS_ERROR24', 100274) +GLU_NURBS_ERROR25 = Constant( 'GLU_NURBS_ERROR25', 100275) +GLU_NURBS_ERROR26 = Constant( 'GLU_NURBS_ERROR26', 100276) +GLU_NURBS_ERROR27 = Constant( 'GLU_NURBS_ERROR27', 100277) +GLU_NURBS_ERROR28 = Constant( 'GLU_NURBS_ERROR28', 100278) +GLU_NURBS_ERROR29 = Constant( 'GLU_NURBS_ERROR29', 100279) +GLU_NURBS_ERROR3 = Constant( 'GLU_NURBS_ERROR3', 100253) +GLU_NURBS_ERROR30 = Constant( 'GLU_NURBS_ERROR30', 100280) +GLU_NURBS_ERROR31 = Constant( 'GLU_NURBS_ERROR31', 100281) +GLU_NURBS_ERROR32 = Constant( 'GLU_NURBS_ERROR32', 100282) +GLU_NURBS_ERROR33 = Constant( 'GLU_NURBS_ERROR33', 100283) +GLU_NURBS_ERROR34 = Constant( 'GLU_NURBS_ERROR34', 100284) +GLU_NURBS_ERROR35 = Constant( 'GLU_NURBS_ERROR35', 100285) +GLU_NURBS_ERROR36 = Constant( 'GLU_NURBS_ERROR36', 100286) +GLU_NURBS_ERROR37 = Constant( 'GLU_NURBS_ERROR37', 100287) +GLU_NURBS_ERROR4 = Constant( 'GLU_NURBS_ERROR4', 100254) +GLU_NURBS_ERROR5 = Constant( 'GLU_NURBS_ERROR5', 100255) +GLU_NURBS_ERROR6 = Constant( 'GLU_NURBS_ERROR6', 100256) +GLU_NURBS_ERROR7 = Constant( 'GLU_NURBS_ERROR7', 100257) +GLU_NURBS_ERROR8 = Constant( 'GLU_NURBS_ERROR8', 100258) +GLU_NURBS_ERROR9 = Constant( 'GLU_NURBS_ERROR9', 100259) +GLU_NURBS_MODE = Constant( 'GLU_NURBS_MODE', 100160) +GLU_NURBS_MODE_EXT = Constant( 'GLU_NURBS_MODE_EXT', 100160) +GLU_NURBS_NORMAL = Constant( 'GLU_NURBS_NORMAL', 100166) +GLU_NURBS_NORMAL_DATA = Constant( 'GLU_NURBS_NORMAL_DATA', 100172) +GLU_NURBS_NORMAL_DATA_EXT = Constant( 'GLU_NURBS_NORMAL_DATA_EXT', 100172) +GLU_NURBS_NORMAL_EXT = Constant( 'GLU_NURBS_NORMAL_EXT', 100166) +GLU_NURBS_RENDERER = Constant( 'GLU_NURBS_RENDERER', 100162) +GLU_NURBS_RENDERER_EXT = Constant( 'GLU_NURBS_RENDERER_EXT', 100162) +GLU_NURBS_TESSELLATOR = Constant( 'GLU_NURBS_TESSELLATOR', 100161) +GLU_NURBS_TESSELLATOR_EXT = Constant( 'GLU_NURBS_TESSELLATOR_EXT', 100161) +GLU_NURBS_TEXTURE_COORD = Constant( 'GLU_NURBS_TEXTURE_COORD', 100168) +GLU_NURBS_TEXTURE_COORD_DATA = Constant( 'GLU_NURBS_TEXTURE_COORD_DATA', 100174) +GLU_NURBS_TEX_COORD_DATA_EXT = Constant( 'GLU_NURBS_TEX_COORD_DATA_EXT', 100174) +GLU_NURBS_TEX_COORD_EXT = Constant( 'GLU_NURBS_TEX_COORD_EXT', 100168) +GLU_NURBS_VERTEX = Constant( 'GLU_NURBS_VERTEX', 100165) +GLU_NURBS_VERTEX_DATA = Constant( 'GLU_NURBS_VERTEX_DATA', 100171) +GLU_NURBS_VERTEX_DATA_EXT = Constant( 'GLU_NURBS_VERTEX_DATA_EXT', 100171) +GLU_NURBS_VERTEX_EXT = Constant( 'GLU_NURBS_VERTEX_EXT', 100165) +GLU_OBJECT_PARAMETRIC_ERROR = Constant( 'GLU_OBJECT_PARAMETRIC_ERROR', 100208) +GLU_OBJECT_PARAMETRIC_ERROR_EXT = Constant( 'GLU_OBJECT_PARAMETRIC_ERROR_EXT', 100208) +GLU_OBJECT_PATH_LENGTH = Constant( 'GLU_OBJECT_PATH_LENGTH', 100209) +GLU_OBJECT_PATH_LENGTH_EXT = Constant( 'GLU_OBJECT_PATH_LENGTH_EXT', 100209) +GLU_OUTLINE_PATCH = Constant( 'GLU_OUTLINE_PATCH', 100241) +GLU_OUTLINE_POLYGON = Constant( 'GLU_OUTLINE_POLYGON', 100240) +GLU_OUTSIDE = Constant( 'GLU_OUTSIDE', 100020) +GLU_OUT_OF_MEMORY = Constant( 'GLU_OUT_OF_MEMORY', 100902) +GLU_PARAMETRIC_ERROR = Constant( 'GLU_PARAMETRIC_ERROR', 100216) +GLU_PARAMETRIC_TOLERANCE = Constant( 'GLU_PARAMETRIC_TOLERANCE', 100202) +GLU_PATH_LENGTH = Constant( 'GLU_PATH_LENGTH', 100215) +GLU_POINT = Constant( 'GLU_POINT', 100010) +GLU_SAMPLING_METHOD = Constant( 'GLU_SAMPLING_METHOD', 100205) +GLU_SAMPLING_TOLERANCE = Constant( 'GLU_SAMPLING_TOLERANCE', 100203) +GLU_SILHOUETTE = Constant( 'GLU_SILHOUETTE', 100013) +GLU_SMOOTH = Constant( 'GLU_SMOOTH', 100000) +GLU_TESS_BEGIN = Constant( 'GLU_TESS_BEGIN', 100100) +GLU_TESS_BEGIN_DATA = Constant( 'GLU_TESS_BEGIN_DATA', 100106) +GLU_TESS_BOUNDARY_ONLY = Constant( 'GLU_TESS_BOUNDARY_ONLY', 100141) +GLU_TESS_COMBINE = Constant( 'GLU_TESS_COMBINE', 100105) +GLU_TESS_COMBINE_DATA = Constant( 'GLU_TESS_COMBINE_DATA', 100111) +GLU_TESS_COORD_TOO_LARGE = Constant( 'GLU_TESS_COORD_TOO_LARGE', 100155) +GLU_TESS_EDGE_FLAG = Constant( 'GLU_TESS_EDGE_FLAG', 100104) +GLU_TESS_EDGE_FLAG_DATA = Constant( 'GLU_TESS_EDGE_FLAG_DATA', 100110) +GLU_TESS_END = Constant( 'GLU_TESS_END', 100102) +GLU_TESS_END_DATA = Constant( 'GLU_TESS_END_DATA', 100108) +GLU_TESS_ERROR = Constant( 'GLU_TESS_ERROR', 100103) +GLU_TESS_ERROR1 = Constant( 'GLU_TESS_ERROR1', 100151) +GLU_TESS_ERROR2 = Constant( 'GLU_TESS_ERROR2', 100152) +GLU_TESS_ERROR3 = Constant( 'GLU_TESS_ERROR3', 100153) +GLU_TESS_ERROR4 = Constant( 'GLU_TESS_ERROR4', 100154) +GLU_TESS_ERROR5 = Constant( 'GLU_TESS_ERROR5', 100155) +GLU_TESS_ERROR6 = Constant( 'GLU_TESS_ERROR6', 100156) +GLU_TESS_ERROR7 = Constant( 'GLU_TESS_ERROR7', 100157) +GLU_TESS_ERROR8 = Constant( 'GLU_TESS_ERROR8', 100158) +GLU_TESS_ERROR_DATA = Constant( 'GLU_TESS_ERROR_DATA', 100109) +GLU_TESS_MAX_COORD = Constant( 'GLU_TESS_MAX_COORD', 9.9999999999999998e+149) +GLU_TESS_MISSING_BEGIN_CONTOUR = Constant( 'GLU_TESS_MISSING_BEGIN_CONTOUR', 100152) +GLU_TESS_MISSING_BEGIN_POLYGON = Constant( 'GLU_TESS_MISSING_BEGIN_POLYGON', 100151) +GLU_TESS_MISSING_END_CONTOUR = Constant( 'GLU_TESS_MISSING_END_CONTOUR', 100154) +GLU_TESS_MISSING_END_POLYGON = Constant( 'GLU_TESS_MISSING_END_POLYGON', 100153) +GLU_TESS_NEED_COMBINE_CALLBACK = Constant( 'GLU_TESS_NEED_COMBINE_CALLBACK', 100156) +GLU_TESS_TOLERANCE = Constant( 'GLU_TESS_TOLERANCE', 100142) +GLU_TESS_VERTEX = Constant( 'GLU_TESS_VERTEX', 100101) +GLU_TESS_VERTEX_DATA = Constant( 'GLU_TESS_VERTEX_DATA', 100107) +GLU_TESS_WINDING_ABS_GEQ_TWO = Constant( 'GLU_TESS_WINDING_ABS_GEQ_TWO', 100134) +GLU_TESS_WINDING_NEGATIVE = Constant( 'GLU_TESS_WINDING_NEGATIVE', 100133) +GLU_TESS_WINDING_NONZERO = Constant( 'GLU_TESS_WINDING_NONZERO', 100131) +GLU_TESS_WINDING_ODD = Constant( 'GLU_TESS_WINDING_ODD', 100130) +GLU_TESS_WINDING_POSITIVE = Constant( 'GLU_TESS_WINDING_POSITIVE', 100132) +GLU_TESS_WINDING_RULE = Constant( 'GLU_TESS_WINDING_RULE', 100140) +GLU_TRUE = Constant( 'GLU_TRUE', 1) +GLU_UNKNOWN = Constant( 'GLU_UNKNOWN', 100124) +GLU_U_STEP = Constant( 'GLU_U_STEP', 100206) +GLU_VERSION = Constant( 'GLU_VERSION', 100800) +GLU_VERSION_1_1 = Constant( 'GLU_VERSION_1_1', 1) +GLU_VERSION_1_2 = Constant( 'GLU_VERSION_1_2', 1) +GLU_VERSION_1_3 = Constant( 'GLU_VERSION_1_3', 1) +GLU_VERTEX = Constant( 'GLU_VERTEX', 100101) +GLU_V_STEP = Constant( 'GLU_V_STEP', 100207) +__all__ = [ + 'GLU_AUTO_LOAD_MATRIX', + 'GLU_BEGIN', + 'GLU_CCW', + 'GLU_CULLING', + 'GLU_CW', + 'GLU_DISPLAY_MODE', + 'GLU_DOMAIN_DISTANCE', + 'GLU_EDGE_FLAG', + 'GLU_END', + 'GLU_ERROR', + 'GLU_EXTENSIONS', + 'GLU_EXTERIOR', + 'GLU_FALSE', + 'GLU_FILL', + 'GLU_FLAT', + 'GLU_INCOMPATIBLE_GL_VERSION', + 'GLU_INSIDE', + 'GLU_INTERIOR', + 'GLU_INVALID_ENUM', + 'GLU_INVALID_OPERATION', + 'GLU_INVALID_VALUE', + 'GLU_LINE', + 'GLU_MAP1_TRIM_2', + 'GLU_MAP1_TRIM_3', + 'GLU_NONE', + 'GLU_NURBS_BEGIN', + 'GLU_NURBS_BEGIN_DATA', + 'GLU_NURBS_BEGIN_DATA_EXT', + 'GLU_NURBS_BEGIN_EXT', + 'GLU_NURBS_COLOR', + 'GLU_NURBS_COLOR_DATA', + 'GLU_NURBS_COLOR_DATA_EXT', + 'GLU_NURBS_COLOR_EXT', + 'GLU_NURBS_END', + 'GLU_NURBS_END_DATA', + 'GLU_NURBS_END_DATA_EXT', + 'GLU_NURBS_END_EXT', + 'GLU_NURBS_ERROR', + 'GLU_NURBS_ERROR1', + 'GLU_NURBS_ERROR10', + 'GLU_NURBS_ERROR11', + 'GLU_NURBS_ERROR12', + 'GLU_NURBS_ERROR13', + 'GLU_NURBS_ERROR14', + 'GLU_NURBS_ERROR15', + 'GLU_NURBS_ERROR16', + 'GLU_NURBS_ERROR17', + 'GLU_NURBS_ERROR18', + 'GLU_NURBS_ERROR19', + 'GLU_NURBS_ERROR2', + 'GLU_NURBS_ERROR20', + 'GLU_NURBS_ERROR21', + 'GLU_NURBS_ERROR22', + 'GLU_NURBS_ERROR23', + 'GLU_NURBS_ERROR24', + 'GLU_NURBS_ERROR25', + 'GLU_NURBS_ERROR26', + 'GLU_NURBS_ERROR27', + 'GLU_NURBS_ERROR28', + 'GLU_NURBS_ERROR29', + 'GLU_NURBS_ERROR3', + 'GLU_NURBS_ERROR30', + 'GLU_NURBS_ERROR31', + 'GLU_NURBS_ERROR32', + 'GLU_NURBS_ERROR33', + 'GLU_NURBS_ERROR34', + 'GLU_NURBS_ERROR35', + 'GLU_NURBS_ERROR36', + 'GLU_NURBS_ERROR37', + 'GLU_NURBS_ERROR4', + 'GLU_NURBS_ERROR5', + 'GLU_NURBS_ERROR6', + 'GLU_NURBS_ERROR7', + 'GLU_NURBS_ERROR8', + 'GLU_NURBS_ERROR9', + 'GLU_NURBS_MODE', + 'GLU_NURBS_MODE_EXT', + 'GLU_NURBS_NORMAL', + 'GLU_NURBS_NORMAL_DATA', + 'GLU_NURBS_NORMAL_DATA_EXT', + 'GLU_NURBS_NORMAL_EXT', + 'GLU_NURBS_RENDERER', + 'GLU_NURBS_RENDERER_EXT', + 'GLU_NURBS_TESSELLATOR', + 'GLU_NURBS_TESSELLATOR_EXT', + 'GLU_NURBS_TEXTURE_COORD', + 'GLU_NURBS_TEXTURE_COORD_DATA', + 'GLU_NURBS_TEX_COORD_DATA_EXT', + 'GLU_NURBS_TEX_COORD_EXT', + 'GLU_NURBS_VERTEX', + 'GLU_NURBS_VERTEX_DATA', + 'GLU_NURBS_VERTEX_DATA_EXT', + 'GLU_NURBS_VERTEX_EXT', + 'GLU_OBJECT_PARAMETRIC_ERROR', + 'GLU_OBJECT_PARAMETRIC_ERROR_EXT', + 'GLU_OBJECT_PATH_LENGTH', + 'GLU_OBJECT_PATH_LENGTH_EXT', + 'GLU_OUTLINE_PATCH', + 'GLU_OUTLINE_POLYGON', + 'GLU_OUTSIDE', + 'GLU_OUT_OF_MEMORY', + 'GLU_PARAMETRIC_ERROR', + 'GLU_PARAMETRIC_TOLERANCE', + 'GLU_PATH_LENGTH', + 'GLU_POINT', + 'GLU_SAMPLING_METHOD', + 'GLU_SAMPLING_TOLERANCE', + 'GLU_SILHOUETTE', + 'GLU_SMOOTH', + 'GLU_TESS_BEGIN', + 'GLU_TESS_BEGIN_DATA', + 'GLU_TESS_BOUNDARY_ONLY', + 'GLU_TESS_COMBINE', + 'GLU_TESS_COMBINE_DATA', + 'GLU_TESS_COORD_TOO_LARGE', + 'GLU_TESS_EDGE_FLAG', + 'GLU_TESS_EDGE_FLAG_DATA', + 'GLU_TESS_END', + 'GLU_TESS_END_DATA', + 'GLU_TESS_ERROR', + 'GLU_TESS_ERROR1', + 'GLU_TESS_ERROR2', + 'GLU_TESS_ERROR3', + 'GLU_TESS_ERROR4', + 'GLU_TESS_ERROR5', + 'GLU_TESS_ERROR6', + 'GLU_TESS_ERROR7', + 'GLU_TESS_ERROR8', + 'GLU_TESS_ERROR_DATA', + 'GLU_TESS_MAX_COORD', + 'GLU_TESS_MISSING_BEGIN_CONTOUR', + 'GLU_TESS_MISSING_BEGIN_POLYGON', + 'GLU_TESS_MISSING_END_CONTOUR', + 'GLU_TESS_MISSING_END_POLYGON', + 'GLU_TESS_NEED_COMBINE_CALLBACK', + 'GLU_TESS_TOLERANCE', + 'GLU_TESS_VERTEX', + 'GLU_TESS_VERTEX_DATA', + 'GLU_TESS_WINDING_ABS_GEQ_TWO', + 'GLU_TESS_WINDING_NEGATIVE', + 'GLU_TESS_WINDING_NONZERO', + 'GLU_TESS_WINDING_ODD', + 'GLU_TESS_WINDING_POSITIVE', + 'GLU_TESS_WINDING_RULE', + 'GLU_TRUE', + 'GLU_UNKNOWN', + 'GLU_U_STEP', + 'GLU_VERSION', + 'GLU_VERSION_1_1', + 'GLU_VERSION_1_2', + 'GLU_VERSION_1_3', + 'GLU_VERTEX', + 'GLU_V_STEP' +] diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLUT/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLUT/__init__.py new file mode 100644 index 00000000..9bd6597f --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLUT/__init__.py @@ -0,0 +1,1344 @@ +# -*- coding: iso-8859-1 -*- +"""Raw (C-style) API for OpenGL.GLUT + +Automatically generated by the generateraw script, do not edit! +""" +from OpenGL.raw.GLUT.constants import * + +from ctypes import * +from OpenGL._bytes import unicode +from OpenGL import platform, arrays +from OpenGL.constant import Constant +from OpenGL.raw.GL import _types as GL_types +GLvoid = GL_types.GLvoid +from OpenGL.raw.GL._types import ( + GLint, + GLenum, + GLdouble, + GLfloat, +) + +if hasattr( platform.PLATFORM, 'GLUT_CALLBACK_TYPE' ): + # it's *always* CFUNCTYPE, AFAICT + CALLBACK_FUNCTION_TYPE = platform.PLATFORM.GLUT_CALLBACK_TYPE +else: + CALLBACK_FUNCTION_TYPE = platform.PLATFORM.functionTypeFor( platform.PLATFORM.GLUT ) + +class STRING( c_char_p ): + @classmethod + def from_param( cls, value ): + if isinstance( value, unicode ): + value = value.encode( 'utf-8' ) + return c_char_p.from_param( value ) + + +# /usr/include/GL/freeglut_std.h 445 +glutAddMenuEntry = platform.createBaseFunction( + 'glutAddMenuEntry', dll=platform.PLATFORM.GLUT, resultType=None, + argTypes=[STRING,c_int], + doc='glutAddMenuEntry( STRING(label), c_int(value) ) -> None', + argNames=('label', 'value'), +) + + +# /usr/include/GL/freeglut_std.h 446 +glutAddSubMenu = platform.createBaseFunction( + 'glutAddSubMenu', dll=platform.PLATFORM.GLUT, resultType=None, + argTypes=[STRING,c_int], + doc='glutAddSubMenu( STRING(label), c_int(subMenu) ) -> None', + argNames=('label', 'subMenu'), +) + + +# /usr/include/GL/freeglut_std.h 450 +glutAttachMenu = platform.createBaseFunction( + 'glutAttachMenu', dll=platform.PLATFORM.GLUT, resultType=None, + argTypes=[c_int], + doc='glutAttachMenu( c_int(button) ) -> None', + argNames=('button',), +) + + +# /usr/include/GL/freeglut_std.h 499 +glutBitmapCharacter = platform.createBaseFunction( + 'glutBitmapCharacter', dll=platform.PLATFORM.GLUT, resultType=None, + argTypes=[c_void_p,c_int], + doc='glutBitmapCharacter( c_void_p(font), c_int(character) ) -> None', + argNames=('font', 'character'), +) + + +# /usr/include/GL/freeglut_std.h 503 +glutBitmapLength = platform.createBaseFunction( + 'glutBitmapLength', dll=platform.PLATFORM.GLUT, resultType=c_int, + argTypes=[c_void_p,POINTER(c_ubyte)], + doc='glutBitmapLength( c_void_p(font), POINTER(c_ubyte)(string) ) -> c_int', + argNames=('font', 'string'), +) + + +# /usr/include/GL/freeglut_std.h 500 +glutBitmapWidth = platform.createBaseFunction( + 'glutBitmapWidth', dll=platform.PLATFORM.GLUT, resultType=c_int, + argTypes=[c_void_p,c_int], + doc='glutBitmapWidth( c_void_p(font), c_int(character) ) -> c_int', + argNames=('font', 'character'), +) + + +# /usr/include/GL/freeglut_std.h 483 +glutButtonBoxFunc = platform.createBaseFunction( + 'glutButtonBoxFunc', dll=platform.PLATFORM.GLUT, resultType=None, + argTypes=[CALLBACK_FUNCTION_TYPE(None, c_int, c_int)], + doc='glutButtonBoxFunc( FUNCTION_TYPE(None, c_int, c_int)(callback) ) -> None', + argNames=('callback',), +) + + +# /usr/include/GL/freeglut_std.h 447 +glutChangeToMenuEntry = platform.createBaseFunction( + 'glutChangeToMenuEntry', dll=platform.PLATFORM.GLUT, resultType=None, + argTypes=[c_int,STRING,c_int], + doc='glutChangeToMenuEntry( c_int(item), STRING(label), c_int(value) ) -> None', + argNames=('item', 'label', 'value'), +) + + +# /usr/include/GL/freeglut_std.h 448 +glutChangeToSubMenu = platform.createBaseFunction( + 'glutChangeToSubMenu', dll=platform.PLATFORM.GLUT, resultType=None, + argTypes=[c_int,STRING,c_int], + doc='glutChangeToSubMenu( c_int(item), STRING(label), c_int(value) ) -> None', + argNames=('item', 'label', 'value'), +) + + +# /usr/include/GL/freeglut_std.h 555 +glutCopyColormap = platform.createBaseFunction( + 'glutCopyColormap', dll=platform.PLATFORM.GLUT, resultType=None, + argTypes=[c_int], + doc='glutCopyColormap( c_int(window) ) -> None', + argNames=('window',), +) + + +# /usr/include/GL/freeglut_std.h 441 +glutCreateMenu = platform.createBaseFunction( + 'glutCreateMenu', dll=platform.PLATFORM.GLUT, resultType=c_int, + argTypes=[CALLBACK_FUNCTION_TYPE(c_int, c_int)], + doc='glutCreateMenu( FUNCTION_TYPE(c_int, c_int)(callback) ) -> c_int', + argNames=('callback',), +) + + +# /usr/include/GL/freeglut_std.h 399 +glutCreateSubWindow = platform.createBaseFunction( + 'glutCreateSubWindow', dll=platform.PLATFORM.GLUT, resultType=c_int, + argTypes=[c_int,c_int,c_int,c_int,c_int], + doc='glutCreateSubWindow( c_int(window), c_int(x), c_int(y), c_int(width), c_int(height) ) -> c_int', + argNames=('window', 'x', 'y', 'width', 'height'), +) + + +# /usr/include/GL/freeglut_std.h 398 +glutCreateWindow = platform.createBaseFunction( + 'glutCreateWindow', dll=platform.PLATFORM.GLUT, resultType=c_int, + argTypes=[STRING], + doc='glutCreateWindow( STRING(title) ) -> c_int', + argNames=('title',), +) + + +# /usr/include/GL/freeglut_std.h 442 +glutDestroyMenu = platform.createBaseFunction( + 'glutDestroyMenu', dll=platform.PLATFORM.GLUT, resultType=None, + argTypes=[c_int], + doc='glutDestroyMenu( c_int(menu) ) -> None', + argNames=('menu',), +) + + +# /usr/include/GL/freeglut_std.h 400 +glutDestroyWindow = platform.createBaseFunction( + 'glutDestroyWindow', dll=platform.PLATFORM.GLUT, resultType=None, + argTypes=[c_int], + doc='glutDestroyWindow( c_int(window) ) -> None', + argNames=('window',), +) + + +# /usr/include/GL/freeglut_std.h 451 +glutDetachMenu = platform.createBaseFunction( + 'glutDetachMenu', dll=platform.PLATFORM.GLUT, resultType=None, + argTypes=[c_int], + doc='glutDetachMenu( c_int(button) ) -> None', + argNames=('button',), +) + + +# /usr/include/GL/freeglut_std.h 492 +glutDeviceGet = platform.createBaseFunction( + 'glutDeviceGet', dll=platform.PLATFORM.GLUT, resultType=c_int, + argTypes=[GLenum], + doc='glutDeviceGet( GLenum(query) ) -> c_int', + argNames=('query',), +) + + +# /usr/include/GL/freeglut_std.h 484 +glutDialsFunc = platform.createBaseFunction( + 'glutDialsFunc', dll=platform.PLATFORM.GLUT, resultType=None, + argTypes=[CALLBACK_FUNCTION_TYPE(None, c_int, c_int)], + doc='glutDialsFunc( FUNCTION_TYPE(None, c_int, c_int)(callback) ) -> None', + argNames=('callback',), +) + + +# /usr/include/GL/freeglut_std.h 466 +glutDisplayFunc = platform.createBaseFunction( + 'glutDisplayFunc', dll=platform.PLATFORM.GLUT, resultType=None, + argTypes=[CALLBACK_FUNCTION_TYPE(None)], + doc='glutDisplayFunc( FUNCTION_TYPE(None)(callback) ) -> None', + argNames=('callback',), +) + + +# /usr/include/GL/freeglut_std.h 537 +glutEnterGameMode = platform.createBaseFunction( + 'glutEnterGameMode', dll=platform.PLATFORM.GLUT, resultType=c_int, + argTypes=[], + doc='glutEnterGameMode( ) -> c_int', + argNames=(), +) + + +# /usr/include/GL/freeglut_std.h 470 +glutEntryFunc = platform.createBaseFunction( + 'glutEntryFunc', dll=platform.PLATFORM.GLUT, resultType=None, + argTypes=[CALLBACK_FUNCTION_TYPE(None, c_int)], + doc='glutEntryFunc( FUNCTION_TYPE(None, c_int)(callback) ) -> None', + argNames=('callback',), +) + + +# /usr/include/GL/freeglut_std.h 430 +glutEstablishOverlay = platform.createBaseFunction( + 'glutEstablishOverlay', dll=platform.PLATFORM.GLUT, resultType=None, + argTypes=[], + doc='glutEstablishOverlay( ) -> None', + argNames=(), +) + + +# /usr/include/GL/freeglut_std.h 567 +glutExtensionSupported = platform.createBaseFunction( + 'glutExtensionSupported', dll=platform.PLATFORM.GLUT, resultType=c_int, + argTypes=[STRING], + doc='glutExtensionSupported( STRING(extension) ) -> c_int', + argNames=('extension',), +) + + +# /usr/include/GL/freeglut_std.h 562 +glutForceJoystickFunc = platform.createBaseFunction( + 'glutForceJoystickFunc', dll=platform.PLATFORM.GLUT, resultType=None, + argTypes=[], + doc='glutForceJoystickFunc( ) -> None', + argNames=(), +) + + +# /usr/include/GL/freeglut_std.h 412 +glutFullScreen = platform.createBaseFunction( + 'glutFullScreen', dll=platform.PLATFORM.GLUT, resultType=None, + argTypes=[], + doc='glutFullScreen( ) -> None', + argNames=(), +) + + +# /usr/include/GL/freeglut_std.h 539 +glutGameModeGet = platform.createBaseFunction( + 'glutGameModeGet', dll=platform.PLATFORM.GLUT, resultType=c_int, + argTypes=[GLenum], + doc='glutGameModeGet( GLenum(query) ) -> c_int', + argNames=('query',), +) + + +# /usr/include/GL/freeglut_std.h 536 +glutGameModeString = platform.createBaseFunction( + 'glutGameModeString', dll=platform.PLATFORM.GLUT, resultType=None, + argTypes=[STRING], + doc='glutGameModeString( STRING(string) ) -> None', + argNames=('string',), +) + + +# /usr/include/GL/freeglut_std.h 491 +glutGet = platform.createBaseFunction( + 'glutGet', dll=platform.PLATFORM.GLUT, resultType=c_int, + argTypes=[GLenum], + doc='glutGet( GLenum(query) ) -> c_int', + argNames=('query',), +) + + +# /usr/include/GL/freeglut_std.h 554 +glutGetColor = platform.createBaseFunction( + 'glutGetColor', dll=platform.PLATFORM.GLUT, resultType=GLfloat, + argTypes=[c_int,c_int], + doc='glutGetColor( c_int(color), c_int(component) ) -> GLfloat', + argNames=('color', 'component'), +) + + +# /usr/include/GL/freeglut_std.h 443 +glutGetMenu = platform.createBaseFunction( + 'glutGetMenu', dll=platform.PLATFORM.GLUT, resultType=c_int, + argTypes=[], + doc='glutGetMenu( ) -> c_int', + argNames=(), +) + + +# /usr/include/GL/freeglut_std.h 493 +glutGetModifiers = platform.createBaseFunction( + 'glutGetModifiers', dll=platform.PLATFORM.GLUT, resultType=c_int, + argTypes=[], + doc='glutGetModifiers( ) -> c_int', + argNames=(), +) + + +# /usr/include/GL/freeglut_std.h 402 +glutGetWindow = platform.createBaseFunction( + 'glutGetWindow', dll=platform.PLATFORM.GLUT, resultType=c_int, + argTypes=[], + doc='glutGetWindow( ) -> c_int', + argNames=(), +) + + +# /usr/include/GL/freeglut_std.h 436 +glutHideOverlay = platform.createBaseFunction( + 'glutHideOverlay', dll=platform.PLATFORM.GLUT, resultType=None, + argTypes=[], + doc='glutHideOverlay( ) -> None', + argNames=(), +) + + +# /usr/include/GL/freeglut_std.h 408 +glutHideWindow = platform.createBaseFunction( + 'glutHideWindow', dll=platform.PLATFORM.GLUT, resultType=None, + argTypes=[], + doc='glutHideWindow( ) -> None', + argNames=(), +) + + +# /usr/include/GL/freeglut_std.h 409 +glutIconifyWindow = platform.createBaseFunction( + 'glutIconifyWindow', dll=platform.PLATFORM.GLUT, resultType=None, + argTypes=[], + doc='glutIconifyWindow( ) -> None', + argNames=(), +) + + +# /usr/include/GL/freeglut_std.h 457 +glutIdleFunc = platform.createBaseFunction( + 'glutIdleFunc', dll=platform.PLATFORM.GLUT, resultType=None, + argTypes=[CALLBACK_FUNCTION_TYPE(None)], + doc='glutIdleFunc( FUNCTION_TYPE(None)(callback) ) -> None', + argNames=('callback',), +) + + +# /usr/include/GL/freeglut_std.h 560 +glutIgnoreKeyRepeat = platform.createBaseFunction( + 'glutIgnoreKeyRepeat', dll=platform.PLATFORM.GLUT, resultType=None, + argTypes=[c_int], + doc='glutIgnoreKeyRepeat( c_int(ignore) ) -> None', + argNames=('ignore',), +) + + +# /usr/include/GL/freeglut_std.h 384 +glutInit = platform.createBaseFunction( + 'glutInit', dll=platform.PLATFORM.GLUT, resultType=None, + argTypes=[POINTER(c_int),POINTER(STRING)], + doc='glutInit( POINTER(c_int)(pargc), POINTER(STRING)(argv) ) -> None', + argNames=('pargc', 'argv'), +) + + +# /usr/include/GL/freeglut_std.h 387 +glutInitDisplayMode = platform.createBaseFunction( + 'glutInitDisplayMode', dll=platform.PLATFORM.GLUT, resultType=None, + argTypes=[c_uint], + doc='glutInitDisplayMode( c_uint(displayMode) ) -> None', + argNames=('displayMode',), +) + + +# /usr/include/GL/freeglut_std.h 388 +glutInitDisplayString = platform.createBaseFunction( + 'glutInitDisplayString', dll=platform.PLATFORM.GLUT, resultType=None, + argTypes=[STRING], + doc='glutInitDisplayString( STRING(displayMode) ) -> None', + argNames=('displayMode',), +) + + +# /usr/include/GL/freeglut_std.h 385 +glutInitWindowPosition = platform.createBaseFunction( + 'glutInitWindowPosition', dll=platform.PLATFORM.GLUT, resultType=None, + argTypes=[c_int,c_int], + doc='glutInitWindowPosition( c_int(x), c_int(y) ) -> None', + argNames=('x', 'y'), +) + + +# /usr/include/GL/freeglut_std.h 386 +glutInitWindowSize = platform.createBaseFunction( + 'glutInitWindowSize', dll=platform.PLATFORM.GLUT, resultType=None, + argTypes=[c_int,c_int], + doc='glutInitWindowSize( c_int(width), c_int(height) ) -> None', + argNames=('width', 'height'), +) + + +# /usr/include/GL/freeglut_std.h 474 +glutJoystickFunc = platform.createBaseFunction( + 'glutJoystickFunc', dll=platform.PLATFORM.GLUT, resultType=None, + argTypes=[CALLBACK_FUNCTION_TYPE(None, c_uint, c_int, c_int, c_int),c_int], + doc='glutJoystickFunc( FUNCTION_TYPE(None, c_uint, c_int, c_int, c_int)(callback), c_int(pollInterval) ) -> None', + argNames=('callback', 'pollInterval'), +) + + +# /usr/include/GL/freeglut_std.h 462 +glutKeyboardFunc = platform.createBaseFunction( + 'glutKeyboardFunc', dll=platform.PLATFORM.GLUT, resultType=None, + argTypes=[CALLBACK_FUNCTION_TYPE(None, c_ubyte, c_int, c_int)], + doc='glutKeyboardFunc( FUNCTION_TYPE(None, c_ubyte, c_int, c_int)(callback) ) -> None', + argNames=('callback',), +) + + +# /usr/include/GL/freeglut_std.h 472 +glutKeyboardUpFunc = platform.createBaseFunction( + 'glutKeyboardUpFunc', dll=platform.PLATFORM.GLUT, resultType=None, + argTypes=[CALLBACK_FUNCTION_TYPE(None, c_ubyte, c_int, c_int)], + doc='glutKeyboardUpFunc( FUNCTION_TYPE(None, c_ubyte, c_int, c_int)(callback) ) -> None', + argNames=('callback',), +) + + +# /usr/include/GL/freeglut_std.h 494 +glutLayerGet = platform.createBaseFunction( + 'glutLayerGet', dll=platform.PLATFORM.GLUT, resultType=c_int, + argTypes=[GLenum], + doc='glutLayerGet( GLenum(query) ) -> c_int', + argNames=('query',), +) + + +# /usr/include/GL/freeglut_std.h 538 +glutLeaveGameMode = platform.createBaseFunction( + 'glutLeaveGameMode', dll=platform.PLATFORM.GLUT, resultType=None, + argTypes=[], + doc='glutLeaveGameMode( ) -> None', + argNames=(), +) + + +# /usr/include/GL/freeglut_std.h 393 +glutMainLoop = platform.createBaseFunction( + 'glutMainLoop', dll=platform.PLATFORM.GLUT, resultType=None, + argTypes=[], + doc='glutMainLoop( ) -> None', + argNames=(), +) + + +# /usr/include/GL/freeglut_std.h 475 +glutMenuStateFunc = platform.createBaseFunction( + 'glutMenuStateFunc', dll=platform.PLATFORM.GLUT, resultType=None, + argTypes=[CALLBACK_FUNCTION_TYPE(None, c_int)], + doc='glutMenuStateFunc( FUNCTION_TYPE(None, c_int)(callback) ) -> None', + argNames=('callback',), +) + + +# /usr/include/GL/freeglut_std.h 476 +glutMenuStatusFunc = platform.createBaseFunction( + 'glutMenuStatusFunc', dll=platform.PLATFORM.GLUT, resultType=None, + argTypes=[CALLBACK_FUNCTION_TYPE(None, c_int, c_int, c_int)], + doc='glutMenuStatusFunc( FUNCTION_TYPE(None, c_int, c_int, c_int)(callback) ) -> None', + argNames=('callback',), +) + + +# /usr/include/GL/freeglut_std.h 468 +glutMotionFunc = platform.createBaseFunction( + 'glutMotionFunc', dll=platform.PLATFORM.GLUT, resultType=None, + argTypes=[CALLBACK_FUNCTION_TYPE(None, c_int, c_int)], + doc='glutMotionFunc( FUNCTION_TYPE(None, c_int, c_int)(callback) ) -> None', + argNames=('callback',), +) + + +# /usr/include/GL/freeglut_std.h 467 +glutMouseFunc = platform.createBaseFunction( + 'glutMouseFunc', dll=platform.PLATFORM.GLUT, resultType=None, + argTypes=[CALLBACK_FUNCTION_TYPE(None, c_int, c_int, c_int, c_int)], + doc='glutMouseFunc( FUNCTION_TYPE(None, c_int, c_int, c_int, c_int)(callback) ) -> None', + argNames=('callback',), +) + + +# /usr/include/GL/freeglut_std.h 477 +glutOverlayDisplayFunc = platform.createBaseFunction( + 'glutOverlayDisplayFunc', dll=platform.PLATFORM.GLUT, resultType=None, + argTypes=[CALLBACK_FUNCTION_TYPE(None)], + doc='glutOverlayDisplayFunc( FUNCTION_TYPE(None)(callback) ) -> None', + argNames=('callback',), +) + + +# /usr/include/GL/freeglut_std.h 469 +glutPassiveMotionFunc = platform.createBaseFunction( + 'glutPassiveMotionFunc', dll=platform.PLATFORM.GLUT, resultType=None, + argTypes=[CALLBACK_FUNCTION_TYPE(None, c_int, c_int)], + doc='glutPassiveMotionFunc( FUNCTION_TYPE(None, c_int, c_int)(callback) ) -> None', + argNames=('callback',), +) + + +# /usr/include/GL/freeglut_std.h 411 +glutPopWindow = platform.createBaseFunction( + 'glutPopWindow', dll=platform.PLATFORM.GLUT, resultType=None, + argTypes=[], + doc='glutPopWindow( ) -> None', + argNames=(), +) + + +# /usr/include/GL/freeglut_std.h 406 +glutPositionWindow = platform.createBaseFunction( + 'glutPositionWindow', dll=platform.PLATFORM.GLUT, resultType=None, + argTypes=[c_int,c_int], + doc='glutPositionWindow( c_int(x), c_int(y) ) -> None', + argNames=('x', 'y'), +) + + +# /usr/include/GL/freeglut_std.h 433 +glutPostOverlayRedisplay = platform.createBaseFunction( + 'glutPostOverlayRedisplay', dll=platform.PLATFORM.GLUT, resultType=None, + argTypes=[], + doc='glutPostOverlayRedisplay( ) -> None', + argNames=(), +) + + +# /usr/include/GL/freeglut_std.h 418 +glutPostRedisplay = platform.createBaseFunction( + 'glutPostRedisplay', dll=platform.PLATFORM.GLUT, resultType=None, + argTypes=[], + doc='glutPostRedisplay( ) -> None', + argNames=(), +) + + +# /usr/include/GL/freeglut_std.h 434 +glutPostWindowOverlayRedisplay = platform.createBaseFunction( + 'glutPostWindowOverlayRedisplay', dll=platform.PLATFORM.GLUT, resultType=None, + argTypes=[c_int], + doc='glutPostWindowOverlayRedisplay( c_int(window) ) -> None', + argNames=('window',), +) + + +# /usr/include/GL/freeglut_std.h 417 +glutPostWindowRedisplay = platform.createBaseFunction( + 'glutPostWindowRedisplay', dll=platform.PLATFORM.GLUT, resultType=None, + argTypes=[c_int], + doc='glutPostWindowRedisplay( c_int(window) ) -> None', + argNames=('window',), +) + + +# /usr/include/GL/freeglut_std.h 410 +glutPushWindow = platform.createBaseFunction( + 'glutPushWindow', dll=platform.PLATFORM.GLUT, resultType=None, + argTypes=[], + doc='glutPushWindow( ) -> None', + argNames=(), +) + + +# /usr/include/GL/freeglut_std.h 449 +glutRemoveMenuItem = platform.createBaseFunction( + 'glutRemoveMenuItem', dll=platform.PLATFORM.GLUT, resultType=None, + argTypes=[c_int], + doc='glutRemoveMenuItem( c_int(item) ) -> None', + argNames=('item',), +) + + +# /usr/include/GL/freeglut_std.h 431 +glutRemoveOverlay = platform.createBaseFunction( + 'glutRemoveOverlay', dll=platform.PLATFORM.GLUT, resultType=None, + argTypes=[], + doc='glutRemoveOverlay( ) -> None', + argNames=(), +) + + +# /usr/include/GL/freeglut_std.h 568 +glutReportErrors = platform.createBaseFunction( + 'glutReportErrors', dll=platform.PLATFORM.GLUT, resultType=None, + argTypes=[], + doc='glutReportErrors( ) -> None', + argNames=(), +) + + +# /usr/include/GL/freeglut_std.h 464 +glutReshapeFunc = platform.createBaseFunction( + 'glutReshapeFunc', dll=platform.PLATFORM.GLUT, resultType=None, + argTypes=[CALLBACK_FUNCTION_TYPE(None, c_int, c_int)], + doc='glutReshapeFunc( FUNCTION_TYPE(None, c_int, c_int)(callback) ) -> None', + argNames=('callback',), +) + + +# /usr/include/GL/freeglut_std.h 405 +glutReshapeWindow = platform.createBaseFunction( + 'glutReshapeWindow', dll=platform.PLATFORM.GLUT, resultType=None, + argTypes=[c_int,c_int], + doc='glutReshapeWindow( c_int(width), c_int(height) ) -> None', + argNames=('width', 'height'), +) + + +# /usr/include/GL/freeglut_std.h 553 +glutSetColor = platform.createBaseFunction( + 'glutSetColor', dll=platform.PLATFORM.GLUT, resultType=None, + argTypes=[c_int,GLfloat,GLfloat,GLfloat], + doc='glutSetColor( c_int(color), GLfloat(red), GLfloat(green), GLfloat(blue) ) -> None', + argNames=('color', 'red', 'green', 'blue'), +) + + +# /usr/include/GL/freeglut_std.h 425 +glutSetCursor = platform.createBaseFunction( + 'glutSetCursor', dll=platform.PLATFORM.GLUT, resultType=None, + argTypes=[c_int], + doc='glutSetCursor( c_int(cursor) ) -> None', + argNames=('cursor',), +) + + +# /usr/include/GL/freeglut_std.h 404 +glutSetIconTitle = platform.createBaseFunction( + 'glutSetIconTitle', dll=platform.PLATFORM.GLUT, resultType=None, + argTypes=[STRING], + doc='glutSetIconTitle( STRING(title) ) -> None', + argNames=('title',), +) + + +# /usr/include/GL/freeglut_std.h 561 +glutSetKeyRepeat = platform.createBaseFunction( + 'glutSetKeyRepeat', dll=platform.PLATFORM.GLUT, resultType=None, + argTypes=[c_int], + doc='glutSetKeyRepeat( c_int(repeatMode) ) -> None', + argNames=('repeatMode',), +) + + +# /usr/include/GL/freeglut_std.h 444 +glutSetMenu = platform.createBaseFunction( + 'glutSetMenu', dll=platform.PLATFORM.GLUT, resultType=None, + argTypes=[c_int], + doc='glutSetMenu( c_int(menu) ) -> None', + argNames=('menu',), +) + + +# /usr/include/GL/freeglut_std.h 401 +glutSetWindow = platform.createBaseFunction( + 'glutSetWindow', dll=platform.PLATFORM.GLUT, resultType=None, + argTypes=[c_int], + doc='glutSetWindow( c_int(window) ) -> None', + argNames=('window',), +) + + +# /usr/include/GL/freeglut_std.h 403 +glutSetWindowTitle = platform.createBaseFunction( + 'glutSetWindowTitle', dll=platform.PLATFORM.GLUT, resultType=None, + argTypes=[STRING], + doc='glutSetWindowTitle( STRING(title) ) -> None', + argNames=('title',), +) + + +# /usr/include/GL/freeglut_std.h 545 +glutSetupVideoResizing = platform.createBaseFunction( + 'glutSetupVideoResizing', dll=platform.PLATFORM.GLUT, resultType=None, + argTypes=[], + doc='glutSetupVideoResizing( ) -> None', + argNames=(), +) + + +# /usr/include/GL/freeglut_std.h 435 +glutShowOverlay = platform.createBaseFunction( + 'glutShowOverlay', dll=platform.PLATFORM.GLUT, resultType=None, + argTypes=[], + doc='glutShowOverlay( ) -> None', + argNames=(), +) + + +# /usr/include/GL/freeglut_std.h 407 +glutShowWindow = platform.createBaseFunction( + 'glutShowWindow', dll=platform.PLATFORM.GLUT, resultType=None, + argTypes=[], + doc='glutShowWindow( ) -> None', + argNames=(), +) + + +# /usr/include/GL/freeglut_std.h 514 +glutSolidCone = platform.createBaseFunction( + 'glutSolidCone', dll=platform.PLATFORM.GLUT, resultType=None, + argTypes=[GLdouble,GLdouble,GLint,GLint], + doc='glutSolidCone( GLdouble(base), GLdouble(height), GLint(slices), GLint(stacks) ) -> None', + argNames=('base', 'height', 'slices', 'stacks'), +) + + +# /usr/include/GL/freeglut_std.h 510 +glutSolidCube = platform.createBaseFunction( + 'glutSolidCube', dll=platform.PLATFORM.GLUT, resultType=None, + argTypes=[GLdouble], + doc='glutSolidCube( GLdouble(size) ) -> None', + argNames=('size',), +) + + +# /usr/include/GL/freeglut_std.h 519 +glutSolidDodecahedron = platform.createBaseFunction( + 'glutSolidDodecahedron', dll=platform.PLATFORM.GLUT, resultType=None, + argTypes=[], + doc='glutSolidDodecahedron( ) -> None', + argNames=(), +) + + +# /usr/include/GL/freeglut_std.h 525 +glutSolidIcosahedron = platform.createBaseFunction( + 'glutSolidIcosahedron', dll=platform.PLATFORM.GLUT, resultType=None, + argTypes=[], + doc='glutSolidIcosahedron( ) -> None', + argNames=(), +) + + +# /usr/include/GL/freeglut_std.h 521 +glutSolidOctahedron = platform.createBaseFunction( + 'glutSolidOctahedron', dll=platform.PLATFORM.GLUT, resultType=None, + argTypes=[], + doc='glutSolidOctahedron( ) -> None', + argNames=(), +) + + +# /usr/include/GL/freeglut_std.h 512 +glutSolidSphere = platform.createBaseFunction( + 'glutSolidSphere', dll=platform.PLATFORM.GLUT, resultType=None, + argTypes=[GLdouble,GLint,GLint], + doc='glutSolidSphere( GLdouble(radius), GLint(slices), GLint(stacks) ) -> None', + argNames=('radius', 'slices', 'stacks'), +) + + +# /usr/include/GL/freeglut_std.h 531 +glutSolidTeapot = platform.createBaseFunction( + 'glutSolidTeapot', dll=platform.PLATFORM.GLUT, resultType=None, + argTypes=[GLdouble], + doc='glutSolidTeapot( GLdouble(size) ) -> None', + argNames=('size',), +) + + +# /usr/include/GL/freeglut_std.h 523 +glutSolidTetrahedron = platform.createBaseFunction( + 'glutSolidTetrahedron', dll=platform.PLATFORM.GLUT, resultType=None, + argTypes=[], + doc='glutSolidTetrahedron( ) -> None', + argNames=(), +) + + +# /usr/include/GL/freeglut_std.h 517 +glutSolidTorus = platform.createBaseFunction( + 'glutSolidTorus', dll=platform.PLATFORM.GLUT, resultType=None, + argTypes=[GLdouble,GLdouble,GLint,GLint], + doc='glutSolidTorus( GLdouble(innerRadius), GLdouble(outerRadius), GLint(sides), GLint(rings) ) -> None', + argNames=('innerRadius', 'outerRadius', 'sides', 'rings'), +) + + +# /usr/include/GL/freeglut_std.h 482 +glutSpaceballButtonFunc = platform.createBaseFunction( + 'glutSpaceballButtonFunc', dll=platform.PLATFORM.GLUT, resultType=None, + argTypes=[CALLBACK_FUNCTION_TYPE(None, c_int, c_int)], + doc='glutSpaceballButtonFunc( FUNCTION_TYPE(None, c_int, c_int)(callback) ) -> None', + argNames=('callback',), +) + + +# /usr/include/GL/freeglut_std.h 480 +glutSpaceballMotionFunc = platform.createBaseFunction( + 'glutSpaceballMotionFunc', dll=platform.PLATFORM.GLUT, resultType=None, + argTypes=[CALLBACK_FUNCTION_TYPE(None, c_int, c_int, c_int)], + doc='glutSpaceballMotionFunc( FUNCTION_TYPE(None, c_int, c_int, c_int)(callback) ) -> None', + argNames=('callback',), +) + + +# /usr/include/GL/freeglut_std.h 481 +glutSpaceballRotateFunc = platform.createBaseFunction( + 'glutSpaceballRotateFunc', dll=platform.PLATFORM.GLUT, resultType=None, + argTypes=[CALLBACK_FUNCTION_TYPE(None, c_int, c_int, c_int)], + doc='glutSpaceballRotateFunc( FUNCTION_TYPE(None, c_int, c_int, c_int)(callback) ) -> None', + argNames=('callback',), +) + + +# /usr/include/GL/freeglut_std.h 463 +glutSpecialFunc = platform.createBaseFunction( + 'glutSpecialFunc', dll=platform.PLATFORM.GLUT, resultType=None, + argTypes=[CALLBACK_FUNCTION_TYPE(None, c_int, c_int, c_int)], + doc='glutSpecialFunc( FUNCTION_TYPE(None, c_int, c_int, c_int)(callback) ) -> None', + argNames=('callback',), +) + + +# /usr/include/GL/freeglut_std.h 473 +glutSpecialUpFunc = platform.createBaseFunction( + 'glutSpecialUpFunc', dll=platform.PLATFORM.GLUT, resultType=None, + argTypes=[CALLBACK_FUNCTION_TYPE(None, c_int, c_int, c_int)], + doc='glutSpecialUpFunc( FUNCTION_TYPE(None, c_int, c_int, c_int)(callback) ) -> None', + argNames=('callback',), +) + + +# /usr/include/GL/freeglut_std.h 546 +glutStopVideoResizing = platform.createBaseFunction( + 'glutStopVideoResizing', dll=platform.PLATFORM.GLUT, resultType=None, + argTypes=[], + doc='glutStopVideoResizing( ) -> None', + argNames=(), +) + + +# /usr/include/GL/freeglut_std.h 501 +glutStrokeCharacter = platform.createBaseFunction( + 'glutStrokeCharacter', dll=platform.PLATFORM.GLUT, resultType=None, + argTypes=[c_void_p,c_int], + doc='glutStrokeCharacter( c_void_p(font), c_int(character) ) -> None', + argNames=('font', 'character'), +) + + +# /usr/include/GL/freeglut_std.h 504 +glutStrokeLength = platform.createBaseFunction( + 'glutStrokeLength', dll=platform.PLATFORM.GLUT, resultType=c_int, + argTypes=[c_void_p,POINTER(c_ubyte)], + doc='glutStrokeLength( c_void_p(font), POINTER(c_ubyte)(string) ) -> c_int', + argNames=('font', 'string'), +) + + +# /usr/include/GL/freeglut_std.h 502 +glutStrokeWidth = platform.createBaseFunction( + 'glutStrokeWidth', dll=platform.PLATFORM.GLUT, resultType=c_int, + argTypes=[c_void_p,c_int], + doc='glutStrokeWidth( c_void_p(font), c_int(character) ) -> c_int', + argNames=('font', 'character'), +) + + +# /usr/include/GL/freeglut_std.h 419 +glutSwapBuffers = platform.createBaseFunction( + 'glutSwapBuffers', dll=platform.PLATFORM.GLUT, resultType=None, + argTypes=[], + doc='glutSwapBuffers( ) -> None', + argNames=(), +) + + +# /usr/include/GL/freeglut_std.h 486 +glutTabletButtonFunc = platform.createBaseFunction( + 'glutTabletButtonFunc', dll=platform.PLATFORM.GLUT, resultType=None, + argTypes=[CALLBACK_FUNCTION_TYPE(None, c_int, c_int, c_int, c_int)], + doc='glutTabletButtonFunc( FUNCTION_TYPE(None, c_int, c_int, c_int, c_int)(callback) ) -> None', + argNames=('callback',), +) + + +# /usr/include/GL/freeglut_std.h 485 +glutTabletMotionFunc = platform.createBaseFunction( + 'glutTabletMotionFunc', dll=platform.PLATFORM.GLUT, resultType=None, + argTypes=[CALLBACK_FUNCTION_TYPE(None, c_int, c_int)], + doc='glutTabletMotionFunc( FUNCTION_TYPE(None, c_int, c_int)(callback) ) -> None', + argNames=('callback',), +) + + +# /usr/include/GL/freeglut_std.h 456 +glutTimerFunc = platform.createBaseFunction( + 'glutTimerFunc', dll=platform.PLATFORM.GLUT, resultType=None, + argTypes=[c_uint,CALLBACK_FUNCTION_TYPE(None, c_int),c_int], + doc='glutTimerFunc( c_uint(time), FUNCTION_TYPE(None, c_int)(callback), c_int(value) ) -> None', + argNames=('time', 'callback', 'value'), +) + + +# /usr/include/GL/freeglut_std.h 432 +glutUseLayer = platform.createBaseFunction( + 'glutUseLayer', dll=platform.PLATFORM.GLUT, resultType=None, + argTypes=[GLenum], + doc='glutUseLayer( GLenum(layer) ) -> None', + argNames=('layer',), +) + + +# /usr/include/GL/freeglut_std.h 548 +glutVideoPan = platform.createBaseFunction( + 'glutVideoPan', dll=platform.PLATFORM.GLUT, resultType=None, + argTypes=[c_int,c_int,c_int,c_int], + doc='glutVideoPan( c_int(x), c_int(y), c_int(width), c_int(height) ) -> None', + argNames=('x', 'y', 'width', 'height'), +) + + +# /usr/include/GL/freeglut_std.h 547 +glutVideoResize = platform.createBaseFunction( + 'glutVideoResize', dll=platform.PLATFORM.GLUT, resultType=None, + argTypes=[c_int,c_int,c_int,c_int], + doc='glutVideoResize( c_int(x), c_int(y), c_int(width), c_int(height) ) -> None', + argNames=('x', 'y', 'width', 'height'), +) + + +# /usr/include/GL/freeglut_std.h 544 +glutVideoResizeGet = platform.createBaseFunction( + 'glutVideoResizeGet', dll=platform.PLATFORM.GLUT, resultType=c_int, + argTypes=[GLenum], + doc='glutVideoResizeGet( GLenum(query) ) -> c_int', + argNames=('query',), +) + + +# /usr/include/GL/freeglut_std.h 465 +glutVisibilityFunc = platform.createBaseFunction( + 'glutVisibilityFunc', dll=platform.PLATFORM.GLUT, resultType=None, + argTypes=[CALLBACK_FUNCTION_TYPE(None, c_int)], + doc='glutVisibilityFunc( FUNCTION_TYPE(None, c_int)(callback) ) -> None', + argNames=('callback',), +) + + +# /usr/include/GL/freeglut_std.h 424 +glutWarpPointer = platform.createBaseFunction( + 'glutWarpPointer', dll=platform.PLATFORM.GLUT, resultType=None, + argTypes=[c_int,c_int], + doc='glutWarpPointer( c_int(x), c_int(y) ) -> None', + argNames=('x', 'y'), +) + + +# /usr/include/GL/freeglut_std.h 478 +glutWindowStatusFunc = platform.createBaseFunction( + 'glutWindowStatusFunc', dll=platform.PLATFORM.GLUT, resultType=None, + argTypes=[CALLBACK_FUNCTION_TYPE(None, c_int)], + doc='glutWindowStatusFunc( FUNCTION_TYPE(None, c_int)(callback) ) -> None', + argNames=('callback',), +) + + +# /usr/include/GL/freeglut_std.h 513 +glutWireCone = platform.createBaseFunction( + 'glutWireCone', dll=platform.PLATFORM.GLUT, resultType=None, + argTypes=[GLdouble,GLdouble,GLint,GLint], + doc='glutWireCone( GLdouble(base), GLdouble(height), GLint(slices), GLint(stacks) ) -> None', + argNames=('base', 'height', 'slices', 'stacks'), +) + + +# /usr/include/GL/freeglut_std.h 509 +glutWireCube = platform.createBaseFunction( + 'glutWireCube', dll=platform.PLATFORM.GLUT, resultType=None, + argTypes=[GLdouble], + doc='glutWireCube( GLdouble(size) ) -> None', + argNames=('size',), +) + + +# /usr/include/GL/freeglut_std.h 518 +glutWireDodecahedron = platform.createBaseFunction( + 'glutWireDodecahedron', dll=platform.PLATFORM.GLUT, resultType=None, + argTypes=[], + doc='glutWireDodecahedron( ) -> None', + argNames=(), +) + + +# /usr/include/GL/freeglut_std.h 524 +glutWireIcosahedron = platform.createBaseFunction( + 'glutWireIcosahedron', dll=platform.PLATFORM.GLUT, resultType=None, + argTypes=[], + doc='glutWireIcosahedron( ) -> None', + argNames=(), +) + + +# /usr/include/GL/freeglut_std.h 520 +glutWireOctahedron = platform.createBaseFunction( + 'glutWireOctahedron', dll=platform.PLATFORM.GLUT, resultType=None, + argTypes=[], + doc='glutWireOctahedron( ) -> None', + argNames=(), +) + + +# /usr/include/GL/freeglut_std.h 511 +glutWireSphere = platform.createBaseFunction( + 'glutWireSphere', dll=platform.PLATFORM.GLUT, resultType=None, + argTypes=[GLdouble,GLint,GLint], + doc='glutWireSphere( GLdouble(radius), GLint(slices), GLint(stacks) ) -> None', + argNames=('radius', 'slices', 'stacks'), +) + + +# /usr/include/GL/freeglut_std.h 530 +glutWireTeapot = platform.createBaseFunction( + 'glutWireTeapot', dll=platform.PLATFORM.GLUT, resultType=None, + argTypes=[GLdouble], + doc='glutWireTeapot( GLdouble(size) ) -> None', + argNames=('size',), +) + + +# /usr/include/GL/freeglut_std.h 522 +glutWireTetrahedron = platform.createBaseFunction( + 'glutWireTetrahedron', dll=platform.PLATFORM.GLUT, resultType=None, + argTypes=[], + doc='glutWireTetrahedron( ) -> None', + argNames=(), +) + + +# /usr/include/GL/freeglut_std.h 516 +glutWireTorus = platform.createBaseFunction( + 'glutWireTorus', dll=platform.PLATFORM.GLUT, resultType=None, + argTypes=[GLdouble,GLdouble,GLint,GLint], + doc='glutWireTorus( GLdouble(innerRadius), GLdouble(outerRadius), GLint(sides), GLint(rings) ) -> None', + argNames=('innerRadius', 'outerRadius', 'sides', 'rings'), +) + +__all__ = [ + 'GLUT_ACCUM', + 'GLUT_ACTIVE_ALT', + 'GLUT_ACTIVE_CTRL', + 'GLUT_ACTIVE_SHIFT', + 'GLUT_ALPHA', + 'GLUT_API_VERSION', + 'GLUT_BLUE', + 'GLUT_CURSOR_BOTTOM_LEFT_CORNER', + 'GLUT_CURSOR_BOTTOM_RIGHT_CORNER', + 'GLUT_CURSOR_BOTTOM_SIDE', + 'GLUT_CURSOR_CROSSHAIR', + 'GLUT_CURSOR_CYCLE', + 'GLUT_CURSOR_DESTROY', + 'GLUT_CURSOR_FULL_CROSSHAIR', + 'GLUT_CURSOR_HELP', + 'GLUT_CURSOR_INFO', + 'GLUT_CURSOR_INHERIT', + 'GLUT_CURSOR_LEFT_ARROW', + 'GLUT_CURSOR_LEFT_RIGHT', + 'GLUT_CURSOR_LEFT_SIDE', + 'GLUT_CURSOR_NONE', + 'GLUT_CURSOR_RIGHT_ARROW', + 'GLUT_CURSOR_RIGHT_SIDE', + 'GLUT_CURSOR_SPRAY', + 'GLUT_CURSOR_TEXT', + 'GLUT_CURSOR_TOP_LEFT_CORNER', + 'GLUT_CURSOR_TOP_RIGHT_CORNER', + 'GLUT_CURSOR_TOP_SIDE', + 'GLUT_CURSOR_UP_DOWN', + 'GLUT_CURSOR_WAIT', + 'GLUT_DEPTH', + 'GLUT_DEVICE_IGNORE_KEY_REPEAT', + 'GLUT_DEVICE_KEY_REPEAT', + 'GLUT_DISPLAY_MODE_POSSIBLE', + 'GLUT_DOUBLE', + 'GLUT_DOWN', + 'GLUT_ELAPSED_TIME', + 'GLUT_ENTERED', + 'GLUT_FULLY_COVERED', + 'GLUT_FULLY_RETAINED', + 'GLUT_GAME_MODE_ACTIVE', + 'GLUT_GAME_MODE_DISPLAY_CHANGED', + 'GLUT_GAME_MODE_HEIGHT', + 'GLUT_GAME_MODE_PIXEL_DEPTH', + 'GLUT_GAME_MODE_POSSIBLE', + 'GLUT_GAME_MODE_REFRESH_RATE', + 'GLUT_GAME_MODE_WIDTH', + 'GLUT_GREEN', + 'GLUT_HAS_DIAL_AND_BUTTON_BOX', + 'GLUT_HAS_JOYSTICK', + 'GLUT_HAS_KEYBOARD', + 'GLUT_HAS_MOUSE', + 'GLUT_HAS_OVERLAY', + 'GLUT_HAS_SPACEBALL', + 'GLUT_HAS_TABLET', + 'GLUT_HIDDEN', + 'GLUT_INDEX', + 'GLUT_INIT_DISPLAY_MODE', + 'GLUT_INIT_STATE', + 'GLUT_INIT_WINDOW_HEIGHT', + 'GLUT_INIT_WINDOW_WIDTH', + 'GLUT_INIT_WINDOW_X', + 'GLUT_INIT_WINDOW_Y', + 'GLUT_JOYSTICK_AXES', + 'GLUT_JOYSTICK_BUTTONS', + 'GLUT_JOYSTICK_BUTTON_A', + 'GLUT_JOYSTICK_BUTTON_B', + 'GLUT_JOYSTICK_BUTTON_C', + 'GLUT_JOYSTICK_BUTTON_D', + 'GLUT_JOYSTICK_POLL_RATE', + 'GLUT_KEY_DOWN', + 'GLUT_KEY_END', + 'GLUT_KEY_F1', + 'GLUT_KEY_F10', + 'GLUT_KEY_F11', + 'GLUT_KEY_F12', + 'GLUT_KEY_F2', + 'GLUT_KEY_F3', + 'GLUT_KEY_F4', + 'GLUT_KEY_F5', + 'GLUT_KEY_F6', + 'GLUT_KEY_F7', + 'GLUT_KEY_F8', + 'GLUT_KEY_F9', + 'GLUT_KEY_HOME', + 'GLUT_KEY_INSERT', + 'GLUT_KEY_LEFT', + 'GLUT_KEY_PAGE_DOWN', + 'GLUT_KEY_PAGE_UP', + 'GLUT_KEY_REPEAT_DEFAULT', + 'GLUT_KEY_REPEAT_OFF', + 'GLUT_KEY_REPEAT_ON', + 'GLUT_KEY_RIGHT', + 'GLUT_KEY_UP', + 'GLUT_LAYER_IN_USE', + 'GLUT_LEFT', + 'GLUT_LEFT_BUTTON', + 'GLUT_LUMINANCE', + 'GLUT_MENU_IN_USE', + 'GLUT_MENU_NOT_IN_USE', + 'GLUT_MENU_NUM_ITEMS', + 'GLUT_MIDDLE_BUTTON', + 'GLUT_MULTISAMPLE', + 'GLUT_NORMAL', + 'GLUT_NORMAL_DAMAGED', + 'GLUT_NOT_VISIBLE', + 'GLUT_NUM_BUTTON_BOX_BUTTONS', + 'GLUT_NUM_DIALS', + 'GLUT_NUM_MOUSE_BUTTONS', + 'GLUT_NUM_SPACEBALL_BUTTONS', + 'GLUT_NUM_TABLET_BUTTONS', + 'GLUT_OVERLAY', + 'GLUT_OVERLAY_DAMAGED', + 'GLUT_OVERLAY_POSSIBLE', + 'GLUT_OWNS_JOYSTICK', + 'GLUT_PARTIALLY_RETAINED', + 'GLUT_RED', + 'GLUT_RGB', + 'GLUT_RGBA', + 'GLUT_RIGHT_BUTTON', + 'GLUT_SCREEN_HEIGHT', + 'GLUT_SCREEN_HEIGHT_MM', + 'GLUT_SCREEN_WIDTH', + 'GLUT_SCREEN_WIDTH_MM', + 'GLUT_SINGLE', + 'GLUT_STENCIL', + 'GLUT_STEREO', + 'GLUT_TRANSPARENT_INDEX', + 'GLUT_UP', + 'GLUT_VIDEO_RESIZE_HEIGHT', + 'GLUT_VIDEO_RESIZE_HEIGHT_DELTA', + 'GLUT_VIDEO_RESIZE_IN_USE', + 'GLUT_VIDEO_RESIZE_POSSIBLE', + 'GLUT_VIDEO_RESIZE_WIDTH', + 'GLUT_VIDEO_RESIZE_WIDTH_DELTA', + 'GLUT_VIDEO_RESIZE_X', + 'GLUT_VIDEO_RESIZE_X_DELTA', + 'GLUT_VIDEO_RESIZE_Y', + 'GLUT_VIDEO_RESIZE_Y_DELTA', + 'GLUT_VISIBLE', + 'GLUT_WINDOW_ACCUM_ALPHA_SIZE', + 'GLUT_WINDOW_ACCUM_BLUE_SIZE', + 'GLUT_WINDOW_ACCUM_GREEN_SIZE', + 'GLUT_WINDOW_ACCUM_RED_SIZE', + 'GLUT_WINDOW_ALPHA_SIZE', + 'GLUT_WINDOW_BLUE_SIZE', + 'GLUT_WINDOW_BUFFER_SIZE', + 'GLUT_WINDOW_COLORMAP_SIZE', + 'GLUT_WINDOW_CURSOR', + 'GLUT_WINDOW_DEPTH_SIZE', + 'GLUT_WINDOW_DOUBLEBUFFER', + 'GLUT_WINDOW_FORMAT_ID', + 'GLUT_WINDOW_GREEN_SIZE', + 'GLUT_WINDOW_HEIGHT', + 'GLUT_WINDOW_NUM_CHILDREN', + 'GLUT_WINDOW_NUM_SAMPLES', + 'GLUT_WINDOW_PARENT', + 'GLUT_WINDOW_RED_SIZE', + 'GLUT_WINDOW_RGBA', + 'GLUT_WINDOW_STENCIL_SIZE', + 'GLUT_WINDOW_STEREO', + 'GLUT_WINDOW_WIDTH', + 'GLUT_WINDOW_X', + 'GLUT_WINDOW_Y', + 'GLUT_XLIB_IMPLEMENTATION', + 'GLdouble', + 'GLenum', + 'GLfloat', + 'GLint', + 'glutAddMenuEntry', + 'glutAddSubMenu', + 'glutAttachMenu', + 'glutBitmapCharacter', + 'glutBitmapLength', + 'glutBitmapWidth', + 'glutButtonBoxFunc', + 'glutChangeToMenuEntry', + 'glutChangeToSubMenu', + 'glutCopyColormap', + 'glutCreateMenu', + 'glutCreateSubWindow', + 'glutCreateWindow', + 'glutDestroyMenu', + 'glutDestroyWindow', + 'glutDetachMenu', + 'glutDeviceGet', + 'glutDialsFunc', + 'glutDisplayFunc', + 'glutEnterGameMode', + 'glutEntryFunc', + 'glutEstablishOverlay', + 'glutExtensionSupported', + 'glutForceJoystickFunc', + 'glutFullScreen', + 'glutGameModeGet', + 'glutGameModeString', + 'glutGet', + 'glutGetColor', + 'glutGetMenu', + 'glutGetModifiers', + 'glutGetWindow', + 'glutHideOverlay', + 'glutHideWindow', + 'glutIconifyWindow', + 'glutIdleFunc', + 'glutIgnoreKeyRepeat', + 'glutInit', + 'glutInitDisplayMode', + 'glutInitDisplayString', + 'glutInitWindowPosition', + 'glutInitWindowSize', + 'glutJoystickFunc', + 'glutKeyboardFunc', + 'glutKeyboardUpFunc', + 'glutLayerGet', + 'glutLeaveGameMode', + 'glutMainLoop', + 'glutMenuStateFunc', + 'glutMenuStatusFunc', + 'glutMotionFunc', + 'glutMouseFunc', + 'glutOverlayDisplayFunc', + 'glutPassiveMotionFunc', + 'glutPopWindow', + 'glutPositionWindow', + 'glutPostOverlayRedisplay', + 'glutPostRedisplay', + 'glutPostWindowOverlayRedisplay', + 'glutPostWindowRedisplay', + 'glutPushWindow', + 'glutRemoveMenuItem', + 'glutRemoveOverlay', + 'glutReportErrors', + 'glutReshapeFunc', + 'glutReshapeWindow', + 'glutSetColor', + 'glutSetCursor', + 'glutSetIconTitle', + 'glutSetKeyRepeat', + 'glutSetMenu', + 'glutSetWindow', + 'glutSetWindowTitle', + 'glutSetupVideoResizing', + 'glutShowOverlay', + 'glutShowWindow', + 'glutSolidCone', + 'glutSolidCube', + 'glutSolidDodecahedron', + 'glutSolidIcosahedron', + 'glutSolidOctahedron', + 'glutSolidSphere', + 'glutSolidTeapot', + 'glutSolidTetrahedron', + 'glutSolidTorus', + 'glutSpaceballButtonFunc', + 'glutSpaceballMotionFunc', + 'glutSpaceballRotateFunc', + 'glutSpecialFunc', + 'glutSpecialUpFunc', + 'glutStopVideoResizing', + 'glutStrokeCharacter', + 'glutStrokeLength', + 'glutStrokeWidth', + 'glutSwapBuffers', + 'glutTabletButtonFunc', + 'glutTabletMotionFunc', + 'glutTimerFunc', + 'glutUseLayer', + 'glutVideoPan', + 'glutVideoResize', + 'glutVideoResizeGet', + 'glutVisibilityFunc', + 'glutWarpPointer', + 'glutWindowStatusFunc', + 'glutWireCone', + 'glutWireCube', + 'glutWireDodecahedron', + 'glutWireIcosahedron', + 'glutWireOctahedron', + 'glutWireSphere', + 'glutWireTeapot', + 'glutWireTetrahedron', + 'glutWireTorus' +] diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLUT/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLUT/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..9c486254 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLUT/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLUT/__pycache__/annotations.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLUT/__pycache__/annotations.cpython-312.pyc new file mode 100644 index 00000000..1a555477 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLUT/__pycache__/annotations.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLUT/__pycache__/constants.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLUT/__pycache__/constants.cpython-312.pyc new file mode 100644 index 00000000..51997f95 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLUT/__pycache__/constants.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLUT/annotations.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLUT/annotations.py new file mode 100644 index 00000000..71177931 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLUT/annotations.py @@ -0,0 +1,19 @@ +"""Array-size annotations for OpenGL.raw.GLUT + +Automatically generated by the generateraw script, do not edit! +""" +from OpenGL.raw import GLUT as raw + +from ctypes import * +from OpenGL import platform, arrays +from OpenGL.constant import Constant +from OpenGL.raw.GL import _types as GL_types +GLvoid = GL_types.GLvoid + +STRING = c_char_p + + + +__all__ = [ + +] diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLUT/constants.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLUT/constants.py new file mode 100644 index 00000000..3907c65a --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLUT/constants.py @@ -0,0 +1,345 @@ +"""Constants for OpenGL.GLUT + +Automatically generated by the generateraw script, do not edit! +""" + +from ctypes import * +from OpenGL import platform, arrays +from OpenGL.constant import Constant +from OpenGL.raw.GL import _types as GL_types +GLvoid = GL_types.GLvoid + + + +GLUT_ACCUM = Constant( 'GLUT_ACCUM', 4) +GLUT_ACTIVE_ALT = Constant( 'GLUT_ACTIVE_ALT', 4) +GLUT_ACTIVE_CTRL = Constant( 'GLUT_ACTIVE_CTRL', 2) +GLUT_ACTIVE_SHIFT = Constant( 'GLUT_ACTIVE_SHIFT', 1) +GLUT_ALPHA = Constant( 'GLUT_ALPHA', 8) +GLUT_API_VERSION = Constant( 'GLUT_API_VERSION', 4) +GLUT_BLUE = Constant( 'GLUT_BLUE', 2) +GLUT_CURSOR_BOTTOM_LEFT_CORNER = Constant( 'GLUT_CURSOR_BOTTOM_LEFT_CORNER', 19) +GLUT_CURSOR_BOTTOM_RIGHT_CORNER = Constant( 'GLUT_CURSOR_BOTTOM_RIGHT_CORNER', 18) +GLUT_CURSOR_BOTTOM_SIDE = Constant( 'GLUT_CURSOR_BOTTOM_SIDE', 13) +GLUT_CURSOR_CROSSHAIR = Constant( 'GLUT_CURSOR_CROSSHAIR', 9) +GLUT_CURSOR_CYCLE = Constant( 'GLUT_CURSOR_CYCLE', 5) +GLUT_CURSOR_DESTROY = Constant( 'GLUT_CURSOR_DESTROY', 3) +GLUT_CURSOR_FULL_CROSSHAIR = Constant( 'GLUT_CURSOR_FULL_CROSSHAIR', 102) +GLUT_CURSOR_HELP = Constant( 'GLUT_CURSOR_HELP', 4) +GLUT_CURSOR_INFO = Constant( 'GLUT_CURSOR_INFO', 2) +GLUT_CURSOR_INHERIT = Constant( 'GLUT_CURSOR_INHERIT', 100) +GLUT_CURSOR_LEFT_ARROW = Constant( 'GLUT_CURSOR_LEFT_ARROW', 1) +GLUT_CURSOR_LEFT_RIGHT = Constant( 'GLUT_CURSOR_LEFT_RIGHT', 11) +GLUT_CURSOR_LEFT_SIDE = Constant( 'GLUT_CURSOR_LEFT_SIDE', 14) +GLUT_CURSOR_NONE = Constant( 'GLUT_CURSOR_NONE', 101) +GLUT_CURSOR_RIGHT_ARROW = Constant( 'GLUT_CURSOR_RIGHT_ARROW', 0) +GLUT_CURSOR_RIGHT_SIDE = Constant( 'GLUT_CURSOR_RIGHT_SIDE', 15) +GLUT_CURSOR_SPRAY = Constant( 'GLUT_CURSOR_SPRAY', 6) +GLUT_CURSOR_TEXT = Constant( 'GLUT_CURSOR_TEXT', 8) +GLUT_CURSOR_TOP_LEFT_CORNER = Constant( 'GLUT_CURSOR_TOP_LEFT_CORNER', 16) +GLUT_CURSOR_TOP_RIGHT_CORNER = Constant( 'GLUT_CURSOR_TOP_RIGHT_CORNER', 17) +GLUT_CURSOR_TOP_SIDE = Constant( 'GLUT_CURSOR_TOP_SIDE', 12) +GLUT_CURSOR_UP_DOWN = Constant( 'GLUT_CURSOR_UP_DOWN', 10) +GLUT_CURSOR_WAIT = Constant( 'GLUT_CURSOR_WAIT', 7) +GLUT_DEPTH = Constant( 'GLUT_DEPTH', 16) +GLUT_DEVICE_IGNORE_KEY_REPEAT = Constant( 'GLUT_DEVICE_IGNORE_KEY_REPEAT', 610) +GLUT_DEVICE_KEY_REPEAT = Constant( 'GLUT_DEVICE_KEY_REPEAT', 611) +GLUT_DISPLAY_MODE_POSSIBLE = Constant( 'GLUT_DISPLAY_MODE_POSSIBLE', 400) +GLUT_DOUBLE = Constant( 'GLUT_DOUBLE', 2) +GLUT_DOWN = Constant( 'GLUT_DOWN', 0) +GLUT_ELAPSED_TIME = Constant( 'GLUT_ELAPSED_TIME', 700) +GLUT_ENTERED = Constant( 'GLUT_ENTERED', 1) +GLUT_FULLY_COVERED = Constant( 'GLUT_FULLY_COVERED', 3) +GLUT_FULLY_RETAINED = Constant( 'GLUT_FULLY_RETAINED', 1) +GLUT_GAME_MODE_ACTIVE = Constant( 'GLUT_GAME_MODE_ACTIVE', 0) +GLUT_GAME_MODE_DISPLAY_CHANGED = Constant( 'GLUT_GAME_MODE_DISPLAY_CHANGED', 6) +GLUT_GAME_MODE_HEIGHT = Constant( 'GLUT_GAME_MODE_HEIGHT', 3) +GLUT_GAME_MODE_PIXEL_DEPTH = Constant( 'GLUT_GAME_MODE_PIXEL_DEPTH', 4) +GLUT_GAME_MODE_POSSIBLE = Constant( 'GLUT_GAME_MODE_POSSIBLE', 1) +GLUT_GAME_MODE_REFRESH_RATE = Constant( 'GLUT_GAME_MODE_REFRESH_RATE', 5) +GLUT_GAME_MODE_WIDTH = Constant( 'GLUT_GAME_MODE_WIDTH', 2) +GLUT_GREEN = Constant( 'GLUT_GREEN', 1) +GLUT_HAS_DIAL_AND_BUTTON_BOX = Constant( 'GLUT_HAS_DIAL_AND_BUTTON_BOX', 603) +GLUT_HAS_JOYSTICK = Constant( 'GLUT_HAS_JOYSTICK', 612) +GLUT_HAS_KEYBOARD = Constant( 'GLUT_HAS_KEYBOARD', 600) +GLUT_HAS_MOUSE = Constant( 'GLUT_HAS_MOUSE', 601) +GLUT_HAS_OVERLAY = Constant( 'GLUT_HAS_OVERLAY', 802) +GLUT_HAS_SPACEBALL = Constant( 'GLUT_HAS_SPACEBALL', 602) +GLUT_HAS_TABLET = Constant( 'GLUT_HAS_TABLET', 604) +GLUT_HIDDEN = Constant( 'GLUT_HIDDEN', 0) +GLUT_INDEX = Constant( 'GLUT_INDEX', 1) +GLUT_INIT_DISPLAY_MODE = Constant( 'GLUT_INIT_DISPLAY_MODE', 504) +GLUT_INIT_STATE = Constant( 'GLUT_INIT_STATE', 124) +GLUT_INIT_WINDOW_HEIGHT = Constant( 'GLUT_INIT_WINDOW_HEIGHT', 503) +GLUT_INIT_WINDOW_WIDTH = Constant( 'GLUT_INIT_WINDOW_WIDTH', 502) +GLUT_INIT_WINDOW_X = Constant( 'GLUT_INIT_WINDOW_X', 500) +GLUT_INIT_WINDOW_Y = Constant( 'GLUT_INIT_WINDOW_Y', 501) +GLUT_JOYSTICK_AXES = Constant( 'GLUT_JOYSTICK_AXES', 615) +GLUT_JOYSTICK_BUTTONS = Constant( 'GLUT_JOYSTICK_BUTTONS', 614) +GLUT_JOYSTICK_BUTTON_A = Constant( 'GLUT_JOYSTICK_BUTTON_A', 1) +GLUT_JOYSTICK_BUTTON_B = Constant( 'GLUT_JOYSTICK_BUTTON_B', 2) +GLUT_JOYSTICK_BUTTON_C = Constant( 'GLUT_JOYSTICK_BUTTON_C', 4) +GLUT_JOYSTICK_BUTTON_D = Constant( 'GLUT_JOYSTICK_BUTTON_D', 8) +GLUT_JOYSTICK_POLL_RATE = Constant( 'GLUT_JOYSTICK_POLL_RATE', 616) +GLUT_KEY_DOWN = Constant( 'GLUT_KEY_DOWN', 103) +GLUT_KEY_END = Constant( 'GLUT_KEY_END', 107) +GLUT_KEY_F1 = Constant( 'GLUT_KEY_F1', 1) +GLUT_KEY_F10 = Constant( 'GLUT_KEY_F10', 10) +GLUT_KEY_F11 = Constant( 'GLUT_KEY_F11', 11) +GLUT_KEY_F12 = Constant( 'GLUT_KEY_F12', 12) +GLUT_KEY_F2 = Constant( 'GLUT_KEY_F2', 2) +GLUT_KEY_F3 = Constant( 'GLUT_KEY_F3', 3) +GLUT_KEY_F4 = Constant( 'GLUT_KEY_F4', 4) +GLUT_KEY_F5 = Constant( 'GLUT_KEY_F5', 5) +GLUT_KEY_F6 = Constant( 'GLUT_KEY_F6', 6) +GLUT_KEY_F7 = Constant( 'GLUT_KEY_F7', 7) +GLUT_KEY_F8 = Constant( 'GLUT_KEY_F8', 8) +GLUT_KEY_F9 = Constant( 'GLUT_KEY_F9', 9) +GLUT_KEY_HOME = Constant( 'GLUT_KEY_HOME', 106) +GLUT_KEY_INSERT = Constant( 'GLUT_KEY_INSERT', 108) +GLUT_KEY_LEFT = Constant( 'GLUT_KEY_LEFT', 100) +GLUT_KEY_PAGE_DOWN = Constant( 'GLUT_KEY_PAGE_DOWN', 105) +GLUT_KEY_PAGE_UP = Constant( 'GLUT_KEY_PAGE_UP', 104) +GLUT_KEY_REPEAT_DEFAULT = Constant( 'GLUT_KEY_REPEAT_DEFAULT', 2) +GLUT_KEY_REPEAT_OFF = Constant( 'GLUT_KEY_REPEAT_OFF', 0) +GLUT_KEY_REPEAT_ON = Constant( 'GLUT_KEY_REPEAT_ON', 1) +GLUT_KEY_RIGHT = Constant( 'GLUT_KEY_RIGHT', 102) +GLUT_KEY_UP = Constant( 'GLUT_KEY_UP', 101) +GLUT_LAYER_IN_USE = Constant( 'GLUT_LAYER_IN_USE', 801) +GLUT_LEFT = Constant( 'GLUT_LEFT', 0) +GLUT_LEFT_BUTTON = Constant( 'GLUT_LEFT_BUTTON', 0) +GLUT_LUMINANCE = Constant( 'GLUT_LUMINANCE', 512) +GLUT_MENU_IN_USE = Constant( 'GLUT_MENU_IN_USE', 1) +GLUT_MENU_NOT_IN_USE = Constant( 'GLUT_MENU_NOT_IN_USE', 0) +GLUT_MENU_NUM_ITEMS = Constant( 'GLUT_MENU_NUM_ITEMS', 300) +GLUT_MIDDLE_BUTTON = Constant( 'GLUT_MIDDLE_BUTTON', 1) +GLUT_MULTISAMPLE = Constant( 'GLUT_MULTISAMPLE', 128) +GLUT_NORMAL = Constant( 'GLUT_NORMAL', 0) +GLUT_NORMAL_DAMAGED = Constant( 'GLUT_NORMAL_DAMAGED', 804) +GLUT_NOT_VISIBLE = Constant( 'GLUT_NOT_VISIBLE', 0) +GLUT_NUM_BUTTON_BOX_BUTTONS = Constant( 'GLUT_NUM_BUTTON_BOX_BUTTONS', 607) +GLUT_NUM_DIALS = Constant( 'GLUT_NUM_DIALS', 608) +GLUT_NUM_MOUSE_BUTTONS = Constant( 'GLUT_NUM_MOUSE_BUTTONS', 605) +GLUT_NUM_SPACEBALL_BUTTONS = Constant( 'GLUT_NUM_SPACEBALL_BUTTONS', 606) +GLUT_NUM_TABLET_BUTTONS = Constant( 'GLUT_NUM_TABLET_BUTTONS', 609) +GLUT_OVERLAY = Constant( 'GLUT_OVERLAY', 1) +GLUT_OVERLAY_DAMAGED = Constant( 'GLUT_OVERLAY_DAMAGED', 805) +GLUT_OVERLAY_POSSIBLE = Constant( 'GLUT_OVERLAY_POSSIBLE', 800) +GLUT_OWNS_JOYSTICK = Constant( 'GLUT_OWNS_JOYSTICK', 613) +GLUT_PARTIALLY_RETAINED = Constant( 'GLUT_PARTIALLY_RETAINED', 2) +GLUT_RED = Constant( 'GLUT_RED', 0) +GLUT_RGB = Constant( 'GLUT_RGB', 0) +GLUT_RGBA = Constant( 'GLUT_RGBA', 0) +GLUT_RIGHT_BUTTON = Constant( 'GLUT_RIGHT_BUTTON', 2) +GLUT_SCREEN_HEIGHT = Constant( 'GLUT_SCREEN_HEIGHT', 201) +GLUT_SCREEN_HEIGHT_MM = Constant( 'GLUT_SCREEN_HEIGHT_MM', 203) +GLUT_SCREEN_WIDTH = Constant( 'GLUT_SCREEN_WIDTH', 200) +GLUT_SCREEN_WIDTH_MM = Constant( 'GLUT_SCREEN_WIDTH_MM', 202) +GLUT_SINGLE = Constant( 'GLUT_SINGLE', 0) +GLUT_STENCIL = Constant( 'GLUT_STENCIL', 32) +GLUT_STEREO = Constant( 'GLUT_STEREO', 256) +GLUT_TRANSPARENT_INDEX = Constant( 'GLUT_TRANSPARENT_INDEX', 803) +GLUT_UP = Constant( 'GLUT_UP', 1) +GLUT_VIDEO_RESIZE_HEIGHT = Constant( 'GLUT_VIDEO_RESIZE_HEIGHT', 909) +GLUT_VIDEO_RESIZE_HEIGHT_DELTA = Constant( 'GLUT_VIDEO_RESIZE_HEIGHT_DELTA', 905) +GLUT_VIDEO_RESIZE_IN_USE = Constant( 'GLUT_VIDEO_RESIZE_IN_USE', 901) +GLUT_VIDEO_RESIZE_POSSIBLE = Constant( 'GLUT_VIDEO_RESIZE_POSSIBLE', 900) +GLUT_VIDEO_RESIZE_WIDTH = Constant( 'GLUT_VIDEO_RESIZE_WIDTH', 908) +GLUT_VIDEO_RESIZE_WIDTH_DELTA = Constant( 'GLUT_VIDEO_RESIZE_WIDTH_DELTA', 904) +GLUT_VIDEO_RESIZE_X = Constant( 'GLUT_VIDEO_RESIZE_X', 906) +GLUT_VIDEO_RESIZE_X_DELTA = Constant( 'GLUT_VIDEO_RESIZE_X_DELTA', 902) +GLUT_VIDEO_RESIZE_Y = Constant( 'GLUT_VIDEO_RESIZE_Y', 907) +GLUT_VIDEO_RESIZE_Y_DELTA = Constant( 'GLUT_VIDEO_RESIZE_Y_DELTA', 903) +GLUT_VISIBLE = Constant( 'GLUT_VISIBLE', 1) +GLUT_WINDOW_ACCUM_ALPHA_SIZE = Constant( 'GLUT_WINDOW_ACCUM_ALPHA_SIZE', 114) +GLUT_WINDOW_ACCUM_BLUE_SIZE = Constant( 'GLUT_WINDOW_ACCUM_BLUE_SIZE', 113) +GLUT_WINDOW_ACCUM_GREEN_SIZE = Constant( 'GLUT_WINDOW_ACCUM_GREEN_SIZE', 112) +GLUT_WINDOW_ACCUM_RED_SIZE = Constant( 'GLUT_WINDOW_ACCUM_RED_SIZE', 111) +GLUT_WINDOW_ALPHA_SIZE = Constant( 'GLUT_WINDOW_ALPHA_SIZE', 110) +GLUT_WINDOW_BLUE_SIZE = Constant( 'GLUT_WINDOW_BLUE_SIZE', 109) +GLUT_WINDOW_BUFFER_SIZE = Constant( 'GLUT_WINDOW_BUFFER_SIZE', 104) +GLUT_WINDOW_COLORMAP_SIZE = Constant( 'GLUT_WINDOW_COLORMAP_SIZE', 119) +GLUT_WINDOW_CURSOR = Constant( 'GLUT_WINDOW_CURSOR', 122) +GLUT_WINDOW_DEPTH_SIZE = Constant( 'GLUT_WINDOW_DEPTH_SIZE', 106) +GLUT_WINDOW_DOUBLEBUFFER = Constant( 'GLUT_WINDOW_DOUBLEBUFFER', 115) +GLUT_WINDOW_FORMAT_ID = Constant( 'GLUT_WINDOW_FORMAT_ID', 123) +GLUT_WINDOW_GREEN_SIZE = Constant( 'GLUT_WINDOW_GREEN_SIZE', 108) +GLUT_WINDOW_HEIGHT = Constant( 'GLUT_WINDOW_HEIGHT', 103) +GLUT_WINDOW_NUM_CHILDREN = Constant( 'GLUT_WINDOW_NUM_CHILDREN', 118) +GLUT_WINDOW_NUM_SAMPLES = Constant( 'GLUT_WINDOW_NUM_SAMPLES', 120) +GLUT_WINDOW_PARENT = Constant( 'GLUT_WINDOW_PARENT', 117) +GLUT_WINDOW_RED_SIZE = Constant( 'GLUT_WINDOW_RED_SIZE', 107) +GLUT_WINDOW_RGBA = Constant( 'GLUT_WINDOW_RGBA', 116) +GLUT_WINDOW_STENCIL_SIZE = Constant( 'GLUT_WINDOW_STENCIL_SIZE', 105) +GLUT_WINDOW_STEREO = Constant( 'GLUT_WINDOW_STEREO', 121) +GLUT_WINDOW_WIDTH = Constant( 'GLUT_WINDOW_WIDTH', 102) +GLUT_WINDOW_X = Constant( 'GLUT_WINDOW_X', 100) +GLUT_WINDOW_Y = Constant( 'GLUT_WINDOW_Y', 101) +GLUT_XLIB_IMPLEMENTATION = Constant( 'GLUT_XLIB_IMPLEMENTATION', 13) +__all__ = [ + 'GLUT_ACCUM', + 'GLUT_ACTIVE_ALT', + 'GLUT_ACTIVE_CTRL', + 'GLUT_ACTIVE_SHIFT', + 'GLUT_ALPHA', + 'GLUT_API_VERSION', + 'GLUT_BLUE', + 'GLUT_CURSOR_BOTTOM_LEFT_CORNER', + 'GLUT_CURSOR_BOTTOM_RIGHT_CORNER', + 'GLUT_CURSOR_BOTTOM_SIDE', + 'GLUT_CURSOR_CROSSHAIR', + 'GLUT_CURSOR_CYCLE', + 'GLUT_CURSOR_DESTROY', + 'GLUT_CURSOR_FULL_CROSSHAIR', + 'GLUT_CURSOR_HELP', + 'GLUT_CURSOR_INFO', + 'GLUT_CURSOR_INHERIT', + 'GLUT_CURSOR_LEFT_ARROW', + 'GLUT_CURSOR_LEFT_RIGHT', + 'GLUT_CURSOR_LEFT_SIDE', + 'GLUT_CURSOR_NONE', + 'GLUT_CURSOR_RIGHT_ARROW', + 'GLUT_CURSOR_RIGHT_SIDE', + 'GLUT_CURSOR_SPRAY', + 'GLUT_CURSOR_TEXT', + 'GLUT_CURSOR_TOP_LEFT_CORNER', + 'GLUT_CURSOR_TOP_RIGHT_CORNER', + 'GLUT_CURSOR_TOP_SIDE', + 'GLUT_CURSOR_UP_DOWN', + 'GLUT_CURSOR_WAIT', + 'GLUT_DEPTH', + 'GLUT_DEVICE_IGNORE_KEY_REPEAT', + 'GLUT_DEVICE_KEY_REPEAT', + 'GLUT_DISPLAY_MODE_POSSIBLE', + 'GLUT_DOUBLE', + 'GLUT_DOWN', + 'GLUT_ELAPSED_TIME', + 'GLUT_ENTERED', + 'GLUT_FULLY_COVERED', + 'GLUT_FULLY_RETAINED', + 'GLUT_GAME_MODE_ACTIVE', + 'GLUT_GAME_MODE_DISPLAY_CHANGED', + 'GLUT_GAME_MODE_HEIGHT', + 'GLUT_GAME_MODE_PIXEL_DEPTH', + 'GLUT_GAME_MODE_POSSIBLE', + 'GLUT_GAME_MODE_REFRESH_RATE', + 'GLUT_GAME_MODE_WIDTH', + 'GLUT_GREEN', + 'GLUT_HAS_DIAL_AND_BUTTON_BOX', + 'GLUT_HAS_JOYSTICK', + 'GLUT_HAS_KEYBOARD', + 'GLUT_HAS_MOUSE', + 'GLUT_HAS_OVERLAY', + 'GLUT_HAS_SPACEBALL', + 'GLUT_HAS_TABLET', + 'GLUT_HIDDEN', + 'GLUT_INDEX', + 'GLUT_INIT_DISPLAY_MODE', + 'GLUT_INIT_STATE', + 'GLUT_INIT_WINDOW_HEIGHT', + 'GLUT_INIT_WINDOW_WIDTH', + 'GLUT_INIT_WINDOW_X', + 'GLUT_INIT_WINDOW_Y', + 'GLUT_JOYSTICK_AXES', + 'GLUT_JOYSTICK_BUTTONS', + 'GLUT_JOYSTICK_BUTTON_A', + 'GLUT_JOYSTICK_BUTTON_B', + 'GLUT_JOYSTICK_BUTTON_C', + 'GLUT_JOYSTICK_BUTTON_D', + 'GLUT_JOYSTICK_POLL_RATE', + 'GLUT_KEY_DOWN', + 'GLUT_KEY_END', + 'GLUT_KEY_F1', + 'GLUT_KEY_F10', + 'GLUT_KEY_F11', + 'GLUT_KEY_F12', + 'GLUT_KEY_F2', + 'GLUT_KEY_F3', + 'GLUT_KEY_F4', + 'GLUT_KEY_F5', + 'GLUT_KEY_F6', + 'GLUT_KEY_F7', + 'GLUT_KEY_F8', + 'GLUT_KEY_F9', + 'GLUT_KEY_HOME', + 'GLUT_KEY_INSERT', + 'GLUT_KEY_LEFT', + 'GLUT_KEY_PAGE_DOWN', + 'GLUT_KEY_PAGE_UP', + 'GLUT_KEY_REPEAT_DEFAULT', + 'GLUT_KEY_REPEAT_OFF', + 'GLUT_KEY_REPEAT_ON', + 'GLUT_KEY_RIGHT', + 'GLUT_KEY_UP', + 'GLUT_LAYER_IN_USE', + 'GLUT_LEFT', + 'GLUT_LEFT_BUTTON', + 'GLUT_LUMINANCE', + 'GLUT_MENU_IN_USE', + 'GLUT_MENU_NOT_IN_USE', + 'GLUT_MENU_NUM_ITEMS', + 'GLUT_MIDDLE_BUTTON', + 'GLUT_MULTISAMPLE', + 'GLUT_NORMAL', + 'GLUT_NORMAL_DAMAGED', + 'GLUT_NOT_VISIBLE', + 'GLUT_NUM_BUTTON_BOX_BUTTONS', + 'GLUT_NUM_DIALS', + 'GLUT_NUM_MOUSE_BUTTONS', + 'GLUT_NUM_SPACEBALL_BUTTONS', + 'GLUT_NUM_TABLET_BUTTONS', + 'GLUT_OVERLAY', + 'GLUT_OVERLAY_DAMAGED', + 'GLUT_OVERLAY_POSSIBLE', + 'GLUT_OWNS_JOYSTICK', + 'GLUT_PARTIALLY_RETAINED', + 'GLUT_RED', + 'GLUT_RGB', + 'GLUT_RGBA', + 'GLUT_RIGHT_BUTTON', + 'GLUT_SCREEN_HEIGHT', + 'GLUT_SCREEN_HEIGHT_MM', + 'GLUT_SCREEN_WIDTH', + 'GLUT_SCREEN_WIDTH_MM', + 'GLUT_SINGLE', + 'GLUT_STENCIL', + 'GLUT_STEREO', + 'GLUT_TRANSPARENT_INDEX', + 'GLUT_UP', + 'GLUT_VIDEO_RESIZE_HEIGHT', + 'GLUT_VIDEO_RESIZE_HEIGHT_DELTA', + 'GLUT_VIDEO_RESIZE_IN_USE', + 'GLUT_VIDEO_RESIZE_POSSIBLE', + 'GLUT_VIDEO_RESIZE_WIDTH', + 'GLUT_VIDEO_RESIZE_WIDTH_DELTA', + 'GLUT_VIDEO_RESIZE_X', + 'GLUT_VIDEO_RESIZE_X_DELTA', + 'GLUT_VIDEO_RESIZE_Y', + 'GLUT_VIDEO_RESIZE_Y_DELTA', + 'GLUT_VISIBLE', + 'GLUT_WINDOW_ACCUM_ALPHA_SIZE', + 'GLUT_WINDOW_ACCUM_BLUE_SIZE', + 'GLUT_WINDOW_ACCUM_GREEN_SIZE', + 'GLUT_WINDOW_ACCUM_RED_SIZE', + 'GLUT_WINDOW_ALPHA_SIZE', + 'GLUT_WINDOW_BLUE_SIZE', + 'GLUT_WINDOW_BUFFER_SIZE', + 'GLUT_WINDOW_COLORMAP_SIZE', + 'GLUT_WINDOW_CURSOR', + 'GLUT_WINDOW_DEPTH_SIZE', + 'GLUT_WINDOW_DOUBLEBUFFER', + 'GLUT_WINDOW_FORMAT_ID', + 'GLUT_WINDOW_GREEN_SIZE', + 'GLUT_WINDOW_HEIGHT', + 'GLUT_WINDOW_NUM_CHILDREN', + 'GLUT_WINDOW_NUM_SAMPLES', + 'GLUT_WINDOW_PARENT', + 'GLUT_WINDOW_RED_SIZE', + 'GLUT_WINDOW_RGBA', + 'GLUT_WINDOW_STENCIL_SIZE', + 'GLUT_WINDOW_STEREO', + 'GLUT_WINDOW_WIDTH', + 'GLUT_WINDOW_X', + 'GLUT_WINDOW_Y', + 'GLUT_XLIB_IMPLEMENTATION' +] diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/AMD/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/AMD/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/AMD/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/AMD/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/AMD/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..ae23139d Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/AMD/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/AMD/__pycache__/gpu_association.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/AMD/__pycache__/gpu_association.cpython-312.pyc new file mode 100644 index 00000000..ee27c6a9 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/AMD/__pycache__/gpu_association.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/AMD/gpu_association.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/AMD/gpu_association.py new file mode 100644 index 00000000..4571d6ea --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/AMD/gpu_association.py @@ -0,0 +1,50 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLX import _types as _cs +# End users want this... +from OpenGL.raw.GLX._types import * +from OpenGL.raw.GLX import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLX_AMD_gpu_association' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLX,'GLX_AMD_gpu_association',error_checker=_errors._error_checker) +GLX_GPU_CLOCK_AMD=_C('GLX_GPU_CLOCK_AMD',0x21A4) +GLX_GPU_FASTEST_TARGET_GPUS_AMD=_C('GLX_GPU_FASTEST_TARGET_GPUS_AMD',0x21A2) +GLX_GPU_NUM_PIPES_AMD=_C('GLX_GPU_NUM_PIPES_AMD',0x21A5) +GLX_GPU_NUM_RB_AMD=_C('GLX_GPU_NUM_RB_AMD',0x21A7) +GLX_GPU_NUM_SIMD_AMD=_C('GLX_GPU_NUM_SIMD_AMD',0x21A6) +GLX_GPU_NUM_SPI_AMD=_C('GLX_GPU_NUM_SPI_AMD',0x21A8) +GLX_GPU_OPENGL_VERSION_STRING_AMD=_C('GLX_GPU_OPENGL_VERSION_STRING_AMD',0x1F02) +GLX_GPU_RAM_AMD=_C('GLX_GPU_RAM_AMD',0x21A3) +GLX_GPU_RENDERER_STRING_AMD=_C('GLX_GPU_RENDERER_STRING_AMD',0x1F01) +GLX_GPU_VENDOR_AMD=_C('GLX_GPU_VENDOR_AMD',0x1F00) +@_f +@_p.types(None,_cs.GLXContext,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLbitfield,_cs.GLenum) +def glXBlitContextFramebufferAMD(dstCtx,srcX0,srcY0,srcX1,srcY1,dstX0,dstY0,dstX1,dstY1,mask,filter):pass +@_f +@_p.types(_cs.GLXContext,_cs.c_uint,_cs.GLXContext) +def glXCreateAssociatedContextAMD(id,share_list):pass +@_f +@_p.types(_cs.GLXContext,_cs.c_uint,_cs.GLXContext,ctypes.POINTER(_cs.c_int)) +def glXCreateAssociatedContextAttribsAMD(id,share_context,attribList):pass +@_f +@_p.types(_cs.Bool,_cs.GLXContext) +def glXDeleteAssociatedContextAMD(ctx):pass +@_f +@_p.types(_cs.c_uint,_cs.GLXContext) +def glXGetContextGPUIDAMD(ctx):pass +@_f +@_p.types(_cs.GLXContext,) +def glXGetCurrentAssociatedContextAMD():pass +@_f +@_p.types(_cs.c_uint,_cs.c_uint,ctypes.POINTER(_cs.c_uint)) +def glXGetGPUIDsAMD(maxCount,ids):pass +@_f +@_p.types(_cs.c_int,_cs.c_uint,_cs.c_int,_cs.GLenum,_cs.c_uint,ctypes.c_void_p) +def glXGetGPUInfoAMD(id,property,dataType,size,data):pass +@_f +@_p.types(_cs.Bool,_cs.GLXContext) +def glXMakeAssociatedContextCurrentAMD(ctx):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/ARB/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/ARB/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/ARB/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/ARB/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/ARB/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..dc05d3a6 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/ARB/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/ARB/__pycache__/context_flush_control.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/ARB/__pycache__/context_flush_control.cpython-312.pyc new file mode 100644 index 00000000..ac0eb003 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/ARB/__pycache__/context_flush_control.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/ARB/__pycache__/create_context.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/ARB/__pycache__/create_context.cpython-312.pyc new file mode 100644 index 00000000..d1effc0d Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/ARB/__pycache__/create_context.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/ARB/__pycache__/create_context_no_error.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/ARB/__pycache__/create_context_no_error.cpython-312.pyc new file mode 100644 index 00000000..085258d0 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/ARB/__pycache__/create_context_no_error.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/ARB/__pycache__/create_context_profile.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/ARB/__pycache__/create_context_profile.cpython-312.pyc new file mode 100644 index 00000000..dcc44501 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/ARB/__pycache__/create_context_profile.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/ARB/__pycache__/create_context_robustness.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/ARB/__pycache__/create_context_robustness.cpython-312.pyc new file mode 100644 index 00000000..d22997d2 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/ARB/__pycache__/create_context_robustness.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/ARB/__pycache__/fbconfig_float.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/ARB/__pycache__/fbconfig_float.cpython-312.pyc new file mode 100644 index 00000000..d276c7e4 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/ARB/__pycache__/fbconfig_float.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/ARB/__pycache__/framebuffer_sRGB.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/ARB/__pycache__/framebuffer_sRGB.cpython-312.pyc new file mode 100644 index 00000000..82049920 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/ARB/__pycache__/framebuffer_sRGB.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/ARB/__pycache__/get_proc_address.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/ARB/__pycache__/get_proc_address.cpython-312.pyc new file mode 100644 index 00000000..94026c54 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/ARB/__pycache__/get_proc_address.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/ARB/__pycache__/multisample.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/ARB/__pycache__/multisample.cpython-312.pyc new file mode 100644 index 00000000..bd8f5802 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/ARB/__pycache__/multisample.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/ARB/__pycache__/robustness_application_isolation.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/ARB/__pycache__/robustness_application_isolation.cpython-312.pyc new file mode 100644 index 00000000..8fa84a82 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/ARB/__pycache__/robustness_application_isolation.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/ARB/__pycache__/robustness_share_group_isolation.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/ARB/__pycache__/robustness_share_group_isolation.cpython-312.pyc new file mode 100644 index 00000000..5ce8d07e Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/ARB/__pycache__/robustness_share_group_isolation.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/ARB/__pycache__/vertex_buffer_object.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/ARB/__pycache__/vertex_buffer_object.cpython-312.pyc new file mode 100644 index 00000000..09451e67 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/ARB/__pycache__/vertex_buffer_object.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/ARB/context_flush_control.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/ARB/context_flush_control.py new file mode 100644 index 00000000..7b179f19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/ARB/context_flush_control.py @@ -0,0 +1,17 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLX import _types as _cs +# End users want this... +from OpenGL.raw.GLX._types import * +from OpenGL.raw.GLX import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLX_ARB_context_flush_control' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLX,'GLX_ARB_context_flush_control',error_checker=_errors._error_checker) +GLX_CONTEXT_RELEASE_BEHAVIOR_ARB=_C('GLX_CONTEXT_RELEASE_BEHAVIOR_ARB',0x2097) +GLX_CONTEXT_RELEASE_BEHAVIOR_FLUSH_ARB=_C('GLX_CONTEXT_RELEASE_BEHAVIOR_FLUSH_ARB',0x2098) +GLX_CONTEXT_RELEASE_BEHAVIOR_NONE_ARB=_C('GLX_CONTEXT_RELEASE_BEHAVIOR_NONE_ARB',0) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/ARB/create_context.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/ARB/create_context.py new file mode 100644 index 00000000..f50761cc --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/ARB/create_context.py @@ -0,0 +1,21 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLX import _types as _cs +# End users want this... +from OpenGL.raw.GLX._types import * +from OpenGL.raw.GLX import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLX_ARB_create_context' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLX,'GLX_ARB_create_context',error_checker=_errors._error_checker) +GLX_CONTEXT_DEBUG_BIT_ARB=_C('GLX_CONTEXT_DEBUG_BIT_ARB',0x00000001) +GLX_CONTEXT_FLAGS_ARB=_C('GLX_CONTEXT_FLAGS_ARB',0x2094) +GLX_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB=_C('GLX_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB',0x00000002) +GLX_CONTEXT_MAJOR_VERSION_ARB=_C('GLX_CONTEXT_MAJOR_VERSION_ARB',0x2091) +GLX_CONTEXT_MINOR_VERSION_ARB=_C('GLX_CONTEXT_MINOR_VERSION_ARB',0x2092) +@_f +@_p.types(_cs.GLXContext,ctypes.POINTER(_cs.Display),_cs.GLXFBConfig,_cs.GLXContext,_cs.Bool,ctypes.POINTER(_cs.c_int)) +def glXCreateContextAttribsARB(dpy,config,share_context,direct,attrib_list):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/ARB/create_context_no_error.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/ARB/create_context_no_error.py new file mode 100644 index 00000000..1baf0871 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/ARB/create_context_no_error.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLX import _types as _cs +# End users want this... +from OpenGL.raw.GLX._types import * +from OpenGL.raw.GLX import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLX_ARB_create_context_no_error' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLX,'GLX_ARB_create_context_no_error',error_checker=_errors._error_checker) +GLX_CONTEXT_OPENGL_NO_ERROR_ARB=_C('GLX_CONTEXT_OPENGL_NO_ERROR_ARB',0x31B3) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/ARB/create_context_profile.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/ARB/create_context_profile.py new file mode 100644 index 00000000..93ec5955 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/ARB/create_context_profile.py @@ -0,0 +1,17 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLX import _types as _cs +# End users want this... +from OpenGL.raw.GLX._types import * +from OpenGL.raw.GLX import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLX_ARB_create_context_profile' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLX,'GLX_ARB_create_context_profile',error_checker=_errors._error_checker) +GLX_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB=_C('GLX_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB',0x00000002) +GLX_CONTEXT_CORE_PROFILE_BIT_ARB=_C('GLX_CONTEXT_CORE_PROFILE_BIT_ARB',0x00000001) +GLX_CONTEXT_PROFILE_MASK_ARB=_C('GLX_CONTEXT_PROFILE_MASK_ARB',0x9126) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/ARB/create_context_robustness.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/ARB/create_context_robustness.py new file mode 100644 index 00000000..b0e99e9d --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/ARB/create_context_robustness.py @@ -0,0 +1,18 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLX import _types as _cs +# End users want this... +from OpenGL.raw.GLX._types import * +from OpenGL.raw.GLX import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLX_ARB_create_context_robustness' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLX,'GLX_ARB_create_context_robustness',error_checker=_errors._error_checker) +GLX_CONTEXT_RESET_NOTIFICATION_STRATEGY_ARB=_C('GLX_CONTEXT_RESET_NOTIFICATION_STRATEGY_ARB',0x8256) +GLX_CONTEXT_ROBUST_ACCESS_BIT_ARB=_C('GLX_CONTEXT_ROBUST_ACCESS_BIT_ARB',0x00000004) +GLX_LOSE_CONTEXT_ON_RESET_ARB=_C('GLX_LOSE_CONTEXT_ON_RESET_ARB',0x8252) +GLX_NO_RESET_NOTIFICATION_ARB=_C('GLX_NO_RESET_NOTIFICATION_ARB',0x8261) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/ARB/fbconfig_float.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/ARB/fbconfig_float.py new file mode 100644 index 00000000..112a628d --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/ARB/fbconfig_float.py @@ -0,0 +1,16 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLX import _types as _cs +# End users want this... +from OpenGL.raw.GLX._types import * +from OpenGL.raw.GLX import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLX_ARB_fbconfig_float' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLX,'GLX_ARB_fbconfig_float',error_checker=_errors._error_checker) +GLX_RGBA_FLOAT_BIT_ARB=_C('GLX_RGBA_FLOAT_BIT_ARB',0x00000004) +GLX_RGBA_FLOAT_TYPE_ARB=_C('GLX_RGBA_FLOAT_TYPE_ARB',0x20B9) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/ARB/framebuffer_sRGB.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/ARB/framebuffer_sRGB.py new file mode 100644 index 00000000..e8145f99 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/ARB/framebuffer_sRGB.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLX import _types as _cs +# End users want this... +from OpenGL.raw.GLX._types import * +from OpenGL.raw.GLX import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLX_ARB_framebuffer_sRGB' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLX,'GLX_ARB_framebuffer_sRGB',error_checker=_errors._error_checker) +GLX_FRAMEBUFFER_SRGB_CAPABLE_ARB=_C('GLX_FRAMEBUFFER_SRGB_CAPABLE_ARB',0x20B2) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/ARB/get_proc_address.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/ARB/get_proc_address.py new file mode 100644 index 00000000..aae21ac2 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/ARB/get_proc_address.py @@ -0,0 +1,17 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLX import _types as _cs +# End users want this... +from OpenGL.raw.GLX._types import * +from OpenGL.raw.GLX import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLX_ARB_get_proc_address' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLX,'GLX_ARB_get_proc_address',error_checker=_errors._error_checker) + +@_f +@_p.types(_cs.__GLXextFuncPtr,arrays.GLubyteArray) +def glXGetProcAddressARB(procName):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/ARB/multisample.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/ARB/multisample.py new file mode 100644 index 00000000..3a8ce9a5 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/ARB/multisample.py @@ -0,0 +1,16 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLX import _types as _cs +# End users want this... +from OpenGL.raw.GLX._types import * +from OpenGL.raw.GLX import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLX_ARB_multisample' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLX,'GLX_ARB_multisample',error_checker=_errors._error_checker) +GLX_SAMPLES_ARB=_C('GLX_SAMPLES_ARB',100001) +GLX_SAMPLE_BUFFERS_ARB=_C('GLX_SAMPLE_BUFFERS_ARB',100000) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/ARB/robustness_application_isolation.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/ARB/robustness_application_isolation.py new file mode 100644 index 00000000..defb6e7d --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/ARB/robustness_application_isolation.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLX import _types as _cs +# End users want this... +from OpenGL.raw.GLX._types import * +from OpenGL.raw.GLX import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLX_ARB_robustness_application_isolation' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLX,'GLX_ARB_robustness_application_isolation',error_checker=_errors._error_checker) +GLX_CONTEXT_RESET_ISOLATION_BIT_ARB=_C('GLX_CONTEXT_RESET_ISOLATION_BIT_ARB',0x00000008) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/ARB/robustness_share_group_isolation.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/ARB/robustness_share_group_isolation.py new file mode 100644 index 00000000..8957cd49 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/ARB/robustness_share_group_isolation.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLX import _types as _cs +# End users want this... +from OpenGL.raw.GLX._types import * +from OpenGL.raw.GLX import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLX_ARB_robustness_share_group_isolation' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLX,'GLX_ARB_robustness_share_group_isolation',error_checker=_errors._error_checker) +GLX_CONTEXT_RESET_ISOLATION_BIT_ARB=_C('GLX_CONTEXT_RESET_ISOLATION_BIT_ARB',0x00000008) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/ARB/vertex_buffer_object.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/ARB/vertex_buffer_object.py new file mode 100644 index 00000000..0041a3a9 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/ARB/vertex_buffer_object.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLX import _types as _cs +# End users want this... +from OpenGL.raw.GLX._types import * +from OpenGL.raw.GLX import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLX_ARB_vertex_buffer_object' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLX,'GLX_ARB_vertex_buffer_object',error_checker=_errors._error_checker) +GLX_CONTEXT_ALLOW_BUFFER_BYTE_ORDER_MISMATCH_ARB=_C('GLX_CONTEXT_ALLOW_BUFFER_BYTE_ORDER_MISMATCH_ARB',0x2095) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/DFX/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/DFX/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/DFX/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/DFX/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/DFX/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..3d140b78 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/DFX/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/DFX/__pycache__/multisample.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/DFX/__pycache__/multisample.cpython-312.pyc new file mode 100644 index 00000000..861c77c8 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/DFX/__pycache__/multisample.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/DFX/multisample.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/DFX/multisample.py new file mode 100644 index 00000000..b9cc9d6c --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/DFX/multisample.py @@ -0,0 +1,16 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLX import _types as _cs +# End users want this... +from OpenGL.raw.GLX._types import * +from OpenGL.raw.GLX import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLX_DFX_multisample' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLX,'GLX_DFX_multisample',error_checker=_errors._error_checker) +GLX_SAMPLES_3DFX=_C('GLX_SAMPLES_3DFX',0x8051) +GLX_SAMPLE_BUFFERS_3DFX=_C('GLX_SAMPLE_BUFFERS_3DFX',0x8050) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/EXT/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/EXT/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/EXT/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/EXT/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/EXT/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..dbb2f861 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/EXT/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/EXT/__pycache__/buffer_age.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/EXT/__pycache__/buffer_age.cpython-312.pyc new file mode 100644 index 00000000..5c584f17 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/EXT/__pycache__/buffer_age.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/EXT/__pycache__/context_priority.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/EXT/__pycache__/context_priority.cpython-312.pyc new file mode 100644 index 00000000..64b70445 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/EXT/__pycache__/context_priority.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/EXT/__pycache__/create_context_es2_profile.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/EXT/__pycache__/create_context_es2_profile.cpython-312.pyc new file mode 100644 index 00000000..a1e9736c Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/EXT/__pycache__/create_context_es2_profile.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/EXT/__pycache__/create_context_es_profile.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/EXT/__pycache__/create_context_es_profile.cpython-312.pyc new file mode 100644 index 00000000..0f8b1690 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/EXT/__pycache__/create_context_es_profile.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/EXT/__pycache__/fbconfig_packed_float.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/EXT/__pycache__/fbconfig_packed_float.cpython-312.pyc new file mode 100644 index 00000000..f10e308f Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/EXT/__pycache__/fbconfig_packed_float.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/EXT/__pycache__/framebuffer_sRGB.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/EXT/__pycache__/framebuffer_sRGB.cpython-312.pyc new file mode 100644 index 00000000..2c44dc66 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/EXT/__pycache__/framebuffer_sRGB.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/EXT/__pycache__/import_context.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/EXT/__pycache__/import_context.cpython-312.pyc new file mode 100644 index 00000000..3834ec97 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/EXT/__pycache__/import_context.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/EXT/__pycache__/libglvnd.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/EXT/__pycache__/libglvnd.cpython-312.pyc new file mode 100644 index 00000000..dd545827 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/EXT/__pycache__/libglvnd.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/EXT/__pycache__/no_config_context.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/EXT/__pycache__/no_config_context.cpython-312.pyc new file mode 100644 index 00000000..77778e61 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/EXT/__pycache__/no_config_context.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/EXT/__pycache__/stereo_tree.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/EXT/__pycache__/stereo_tree.cpython-312.pyc new file mode 100644 index 00000000..b99a30a3 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/EXT/__pycache__/stereo_tree.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/EXT/__pycache__/swap_control.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/EXT/__pycache__/swap_control.cpython-312.pyc new file mode 100644 index 00000000..4a2a684d Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/EXT/__pycache__/swap_control.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/EXT/__pycache__/swap_control_tear.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/EXT/__pycache__/swap_control_tear.cpython-312.pyc new file mode 100644 index 00000000..f52aee80 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/EXT/__pycache__/swap_control_tear.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/EXT/__pycache__/texture_from_pixmap.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/EXT/__pycache__/texture_from_pixmap.cpython-312.pyc new file mode 100644 index 00000000..4c08a337 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/EXT/__pycache__/texture_from_pixmap.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/EXT/__pycache__/visual_info.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/EXT/__pycache__/visual_info.cpython-312.pyc new file mode 100644 index 00000000..ee032af4 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/EXT/__pycache__/visual_info.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/EXT/__pycache__/visual_rating.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/EXT/__pycache__/visual_rating.cpython-312.pyc new file mode 100644 index 00000000..9522536b Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/EXT/__pycache__/visual_rating.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/EXT/buffer_age.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/EXT/buffer_age.py new file mode 100644 index 00000000..1279d718 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/EXT/buffer_age.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLX import _types as _cs +# End users want this... +from OpenGL.raw.GLX._types import * +from OpenGL.raw.GLX import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLX_EXT_buffer_age' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLX,'GLX_EXT_buffer_age',error_checker=_errors._error_checker) +GLX_BACK_BUFFER_AGE_EXT=_C('GLX_BACK_BUFFER_AGE_EXT',0x20F4) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/EXT/context_priority.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/EXT/context_priority.py new file mode 100644 index 00000000..90c05a41 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/EXT/context_priority.py @@ -0,0 +1,18 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLX import _types as _cs +# End users want this... +from OpenGL.raw.GLX._types import * +from OpenGL.raw.GLX import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLX_EXT_context_priority' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLX,'GLX_EXT_context_priority',error_checker=_errors._error_checker) +GLX_CONTEXT_PRIORITY_HIGH_EXT=_C('GLX_CONTEXT_PRIORITY_HIGH_EXT',0x3101) +GLX_CONTEXT_PRIORITY_LEVEL_EXT=_C('GLX_CONTEXT_PRIORITY_LEVEL_EXT',0x3100) +GLX_CONTEXT_PRIORITY_LOW_EXT=_C('GLX_CONTEXT_PRIORITY_LOW_EXT',0x3103) +GLX_CONTEXT_PRIORITY_MEDIUM_EXT=_C('GLX_CONTEXT_PRIORITY_MEDIUM_EXT',0x3102) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/EXT/create_context_es2_profile.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/EXT/create_context_es2_profile.py new file mode 100644 index 00000000..fc6dfcc4 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/EXT/create_context_es2_profile.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLX import _types as _cs +# End users want this... +from OpenGL.raw.GLX._types import * +from OpenGL.raw.GLX import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLX_EXT_create_context_es2_profile' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLX,'GLX_EXT_create_context_es2_profile',error_checker=_errors._error_checker) +GLX_CONTEXT_ES2_PROFILE_BIT_EXT=_C('GLX_CONTEXT_ES2_PROFILE_BIT_EXT',0x00000004) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/EXT/create_context_es_profile.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/EXT/create_context_es_profile.py new file mode 100644 index 00000000..e5d8e374 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/EXT/create_context_es_profile.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLX import _types as _cs +# End users want this... +from OpenGL.raw.GLX._types import * +from OpenGL.raw.GLX import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLX_EXT_create_context_es_profile' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLX,'GLX_EXT_create_context_es_profile',error_checker=_errors._error_checker) +GLX_CONTEXT_ES_PROFILE_BIT_EXT=_C('GLX_CONTEXT_ES_PROFILE_BIT_EXT',0x00000004) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/EXT/fbconfig_packed_float.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/EXT/fbconfig_packed_float.py new file mode 100644 index 00000000..3b249c8c --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/EXT/fbconfig_packed_float.py @@ -0,0 +1,16 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLX import _types as _cs +# End users want this... +from OpenGL.raw.GLX._types import * +from OpenGL.raw.GLX import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLX_EXT_fbconfig_packed_float' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLX,'GLX_EXT_fbconfig_packed_float',error_checker=_errors._error_checker) +GLX_RGBA_UNSIGNED_FLOAT_BIT_EXT=_C('GLX_RGBA_UNSIGNED_FLOAT_BIT_EXT',0x00000008) +GLX_RGBA_UNSIGNED_FLOAT_TYPE_EXT=_C('GLX_RGBA_UNSIGNED_FLOAT_TYPE_EXT',0x20B1) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/EXT/framebuffer_sRGB.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/EXT/framebuffer_sRGB.py new file mode 100644 index 00000000..bd3a48b9 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/EXT/framebuffer_sRGB.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLX import _types as _cs +# End users want this... +from OpenGL.raw.GLX._types import * +from OpenGL.raw.GLX import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLX_EXT_framebuffer_sRGB' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLX,'GLX_EXT_framebuffer_sRGB',error_checker=_errors._error_checker) +GLX_FRAMEBUFFER_SRGB_CAPABLE_EXT=_C('GLX_FRAMEBUFFER_SRGB_CAPABLE_EXT',0x20B2) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/EXT/import_context.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/EXT/import_context.py new file mode 100644 index 00000000..5efc64ef --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/EXT/import_context.py @@ -0,0 +1,31 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLX import _types as _cs +# End users want this... +from OpenGL.raw.GLX._types import * +from OpenGL.raw.GLX import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLX_EXT_import_context' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLX,'GLX_EXT_import_context',error_checker=_errors._error_checker) +GLX_SCREEN_EXT=_C('GLX_SCREEN_EXT',0x800C) +GLX_SHARE_CONTEXT_EXT=_C('GLX_SHARE_CONTEXT_EXT',0x800A) +GLX_VISUAL_ID_EXT=_C('GLX_VISUAL_ID_EXT',0x800B) +@_f +@_p.types(None,ctypes.POINTER(_cs.Display),_cs.GLXContext) +def glXFreeContextEXT(dpy,context):pass +@_f +@_p.types(_cs.GLXContextID,_cs.GLXContext) +def glXGetContextIDEXT(context):pass +@_f +@_p.types(ctypes.POINTER(_cs.Display),) +def glXGetCurrentDisplayEXT():pass +@_f +@_p.types(_cs.GLXContext,ctypes.POINTER(_cs.Display),_cs.GLXContextID) +def glXImportContextEXT(dpy,contextID):pass +@_f +@_p.types(_cs.c_int,ctypes.POINTER(_cs.Display),_cs.GLXContext,_cs.c_int,ctypes.POINTER(_cs.c_int)) +def glXQueryContextInfoEXT(dpy,context,attribute,value):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/EXT/libglvnd.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/EXT/libglvnd.py new file mode 100644 index 00000000..7f40a504 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/EXT/libglvnd.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLX import _types as _cs +# End users want this... +from OpenGL.raw.GLX._types import * +from OpenGL.raw.GLX import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLX_EXT_libglvnd' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLX,'GLX_EXT_libglvnd',error_checker=_errors._error_checker) +GLX_VENDOR_NAMES_EXT=_C('GLX_VENDOR_NAMES_EXT',0x20F6) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/EXT/no_config_context.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/EXT/no_config_context.py new file mode 100644 index 00000000..06dd8ec0 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/EXT/no_config_context.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLX import _types as _cs +# End users want this... +from OpenGL.raw.GLX._types import * +from OpenGL.raw.GLX import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLX_EXT_no_config_context' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLX,'GLX_EXT_no_config_context',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/EXT/stereo_tree.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/EXT/stereo_tree.py new file mode 100644 index 00000000..bd5a53f2 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/EXT/stereo_tree.py @@ -0,0 +1,17 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLX import _types as _cs +# End users want this... +from OpenGL.raw.GLX._types import * +from OpenGL.raw.GLX import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLX_EXT_stereo_tree' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLX,'GLX_EXT_stereo_tree',error_checker=_errors._error_checker) +GLX_STEREO_NOTIFY_EXT=_C('GLX_STEREO_NOTIFY_EXT',0x00000000) +GLX_STEREO_NOTIFY_MASK_EXT=_C('GLX_STEREO_NOTIFY_MASK_EXT',0x00000001) +GLX_STEREO_TREE_EXT=_C('GLX_STEREO_TREE_EXT',0x20F5) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/EXT/swap_control.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/EXT/swap_control.py new file mode 100644 index 00000000..aac91fba --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/EXT/swap_control.py @@ -0,0 +1,18 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLX import _types as _cs +# End users want this... +from OpenGL.raw.GLX._types import * +from OpenGL.raw.GLX import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLX_EXT_swap_control' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLX,'GLX_EXT_swap_control',error_checker=_errors._error_checker) +GLX_MAX_SWAP_INTERVAL_EXT=_C('GLX_MAX_SWAP_INTERVAL_EXT',0x20F2) +GLX_SWAP_INTERVAL_EXT=_C('GLX_SWAP_INTERVAL_EXT',0x20F1) +@_f +@_p.types(None,ctypes.POINTER(_cs.Display),_cs.GLXDrawable,_cs.c_int) +def glXSwapIntervalEXT(dpy,drawable,interval):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/EXT/swap_control_tear.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/EXT/swap_control_tear.py new file mode 100644 index 00000000..5b3b3149 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/EXT/swap_control_tear.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLX import _types as _cs +# End users want this... +from OpenGL.raw.GLX._types import * +from OpenGL.raw.GLX import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLX_EXT_swap_control_tear' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLX,'GLX_EXT_swap_control_tear',error_checker=_errors._error_checker) +GLX_LATE_SWAPS_TEAR_EXT=_C('GLX_LATE_SWAPS_TEAR_EXT',0x20F3) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/EXT/texture_from_pixmap.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/EXT/texture_from_pixmap.py new file mode 100644 index 00000000..1f85d2c7 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/EXT/texture_from_pixmap.py @@ -0,0 +1,52 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLX import _types as _cs +# End users want this... +from OpenGL.raw.GLX._types import * +from OpenGL.raw.GLX import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLX_EXT_texture_from_pixmap' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLX,'GLX_EXT_texture_from_pixmap',error_checker=_errors._error_checker) +GLX_AUX0_EXT=_C('GLX_AUX0_EXT',0x20E2) +GLX_AUX1_EXT=_C('GLX_AUX1_EXT',0x20E3) +GLX_AUX2_EXT=_C('GLX_AUX2_EXT',0x20E4) +GLX_AUX3_EXT=_C('GLX_AUX3_EXT',0x20E5) +GLX_AUX4_EXT=_C('GLX_AUX4_EXT',0x20E6) +GLX_AUX5_EXT=_C('GLX_AUX5_EXT',0x20E7) +GLX_AUX6_EXT=_C('GLX_AUX6_EXT',0x20E8) +GLX_AUX7_EXT=_C('GLX_AUX7_EXT',0x20E9) +GLX_AUX8_EXT=_C('GLX_AUX8_EXT',0x20EA) +GLX_AUX9_EXT=_C('GLX_AUX9_EXT',0x20EB) +GLX_BACK_EXT=_C('GLX_BACK_EXT',0x20E0) +GLX_BACK_LEFT_EXT=_C('GLX_BACK_LEFT_EXT',0x20E0) +GLX_BACK_RIGHT_EXT=_C('GLX_BACK_RIGHT_EXT',0x20E1) +GLX_BIND_TO_MIPMAP_TEXTURE_EXT=_C('GLX_BIND_TO_MIPMAP_TEXTURE_EXT',0x20D2) +GLX_BIND_TO_TEXTURE_RGBA_EXT=_C('GLX_BIND_TO_TEXTURE_RGBA_EXT',0x20D1) +GLX_BIND_TO_TEXTURE_RGB_EXT=_C('GLX_BIND_TO_TEXTURE_RGB_EXT',0x20D0) +GLX_BIND_TO_TEXTURE_TARGETS_EXT=_C('GLX_BIND_TO_TEXTURE_TARGETS_EXT',0x20D3) +GLX_FRONT_EXT=_C('GLX_FRONT_EXT',0x20DE) +GLX_FRONT_LEFT_EXT=_C('GLX_FRONT_LEFT_EXT',0x20DE) +GLX_FRONT_RIGHT_EXT=_C('GLX_FRONT_RIGHT_EXT',0x20DF) +GLX_MIPMAP_TEXTURE_EXT=_C('GLX_MIPMAP_TEXTURE_EXT',0x20D7) +GLX_TEXTURE_1D_BIT_EXT=_C('GLX_TEXTURE_1D_BIT_EXT',0x00000001) +GLX_TEXTURE_1D_EXT=_C('GLX_TEXTURE_1D_EXT',0x20DB) +GLX_TEXTURE_2D_BIT_EXT=_C('GLX_TEXTURE_2D_BIT_EXT',0x00000002) +GLX_TEXTURE_2D_EXT=_C('GLX_TEXTURE_2D_EXT',0x20DC) +GLX_TEXTURE_FORMAT_EXT=_C('GLX_TEXTURE_FORMAT_EXT',0x20D5) +GLX_TEXTURE_FORMAT_NONE_EXT=_C('GLX_TEXTURE_FORMAT_NONE_EXT',0x20D8) +GLX_TEXTURE_FORMAT_RGBA_EXT=_C('GLX_TEXTURE_FORMAT_RGBA_EXT',0x20DA) +GLX_TEXTURE_FORMAT_RGB_EXT=_C('GLX_TEXTURE_FORMAT_RGB_EXT',0x20D9) +GLX_TEXTURE_RECTANGLE_BIT_EXT=_C('GLX_TEXTURE_RECTANGLE_BIT_EXT',0x00000004) +GLX_TEXTURE_RECTANGLE_EXT=_C('GLX_TEXTURE_RECTANGLE_EXT',0x20DD) +GLX_TEXTURE_TARGET_EXT=_C('GLX_TEXTURE_TARGET_EXT',0x20D6) +GLX_Y_INVERTED_EXT=_C('GLX_Y_INVERTED_EXT',0x20D4) +@_f +@_p.types(None,ctypes.POINTER(_cs.Display),_cs.GLXDrawable,_cs.c_int,ctypes.POINTER(_cs.c_int)) +def glXBindTexImageEXT(dpy,drawable,buffer,attrib_list):pass +@_f +@_p.types(None,ctypes.POINTER(_cs.Display),_cs.GLXDrawable,_cs.c_int) +def glXReleaseTexImageEXT(dpy,drawable,buffer):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/EXT/visual_info.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/EXT/visual_info.py new file mode 100644 index 00000000..a700430a --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/EXT/visual_info.py @@ -0,0 +1,30 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLX import _types as _cs +# End users want this... +from OpenGL.raw.GLX._types import * +from OpenGL.raw.GLX import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLX_EXT_visual_info' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLX,'GLX_EXT_visual_info',error_checker=_errors._error_checker) +GLX_DIRECT_COLOR_EXT=_C('GLX_DIRECT_COLOR_EXT',0x8003) +GLX_GRAY_SCALE_EXT=_C('GLX_GRAY_SCALE_EXT',0x8006) +GLX_NONE_EXT=_C('GLX_NONE_EXT',0x8000) +GLX_PSEUDO_COLOR_EXT=_C('GLX_PSEUDO_COLOR_EXT',0x8004) +GLX_STATIC_COLOR_EXT=_C('GLX_STATIC_COLOR_EXT',0x8005) +GLX_STATIC_GRAY_EXT=_C('GLX_STATIC_GRAY_EXT',0x8007) +GLX_TRANSPARENT_ALPHA_VALUE_EXT=_C('GLX_TRANSPARENT_ALPHA_VALUE_EXT',0x28) +GLX_TRANSPARENT_BLUE_VALUE_EXT=_C('GLX_TRANSPARENT_BLUE_VALUE_EXT',0x27) +GLX_TRANSPARENT_GREEN_VALUE_EXT=_C('GLX_TRANSPARENT_GREEN_VALUE_EXT',0x26) +GLX_TRANSPARENT_INDEX_EXT=_C('GLX_TRANSPARENT_INDEX_EXT',0x8009) +GLX_TRANSPARENT_INDEX_VALUE_EXT=_C('GLX_TRANSPARENT_INDEX_VALUE_EXT',0x24) +GLX_TRANSPARENT_RED_VALUE_EXT=_C('GLX_TRANSPARENT_RED_VALUE_EXT',0x25) +GLX_TRANSPARENT_RGB_EXT=_C('GLX_TRANSPARENT_RGB_EXT',0x8008) +GLX_TRANSPARENT_TYPE_EXT=_C('GLX_TRANSPARENT_TYPE_EXT',0x23) +GLX_TRUE_COLOR_EXT=_C('GLX_TRUE_COLOR_EXT',0x8002) +GLX_X_VISUAL_TYPE_EXT=_C('GLX_X_VISUAL_TYPE_EXT',0x22) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/EXT/visual_rating.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/EXT/visual_rating.py new file mode 100644 index 00000000..640727b7 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/EXT/visual_rating.py @@ -0,0 +1,18 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLX import _types as _cs +# End users want this... +from OpenGL.raw.GLX._types import * +from OpenGL.raw.GLX import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLX_EXT_visual_rating' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLX,'GLX_EXT_visual_rating',error_checker=_errors._error_checker) +GLX_NONE_EXT=_C('GLX_NONE_EXT',0x8000) +GLX_NON_CONFORMANT_VISUAL_EXT=_C('GLX_NON_CONFORMANT_VISUAL_EXT',0x800D) +GLX_SLOW_VISUAL_EXT=_C('GLX_SLOW_VISUAL_EXT',0x8001) +GLX_VISUAL_CAVEAT_EXT=_C('GLX_VISUAL_CAVEAT_EXT',0x20) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/INTEL/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/INTEL/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/INTEL/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/INTEL/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/INTEL/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..bb8a59d0 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/INTEL/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/INTEL/__pycache__/swap_event.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/INTEL/__pycache__/swap_event.cpython-312.pyc new file mode 100644 index 00000000..bfa4dc06 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/INTEL/__pycache__/swap_event.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/INTEL/swap_event.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/INTEL/swap_event.py new file mode 100644 index 00000000..a6081dda --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/INTEL/swap_event.py @@ -0,0 +1,18 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLX import _types as _cs +# End users want this... +from OpenGL.raw.GLX._types import * +from OpenGL.raw.GLX import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLX_INTEL_swap_event' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLX,'GLX_INTEL_swap_event',error_checker=_errors._error_checker) +GLX_BUFFER_SWAP_COMPLETE_INTEL_MASK=_C('GLX_BUFFER_SWAP_COMPLETE_INTEL_MASK',0x04000000) +GLX_COPY_COMPLETE_INTEL=_C('GLX_COPY_COMPLETE_INTEL',0x8181) +GLX_EXCHANGE_COMPLETE_INTEL=_C('GLX_EXCHANGE_COMPLETE_INTEL',0x8180) +GLX_FLIP_COMPLETE_INTEL=_C('GLX_FLIP_COMPLETE_INTEL',0x8182) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/MESA/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/MESA/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/MESA/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/MESA/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/MESA/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..3d8bf854 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/MESA/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/MESA/__pycache__/agp_offset.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/MESA/__pycache__/agp_offset.cpython-312.pyc new file mode 100644 index 00000000..f507b5f9 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/MESA/__pycache__/agp_offset.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/MESA/__pycache__/copy_sub_buffer.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/MESA/__pycache__/copy_sub_buffer.cpython-312.pyc new file mode 100644 index 00000000..d44aa3d5 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/MESA/__pycache__/copy_sub_buffer.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/MESA/__pycache__/pixmap_colormap.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/MESA/__pycache__/pixmap_colormap.cpython-312.pyc new file mode 100644 index 00000000..7b0a42d0 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/MESA/__pycache__/pixmap_colormap.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/MESA/__pycache__/query_renderer.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/MESA/__pycache__/query_renderer.cpython-312.pyc new file mode 100644 index 00000000..fe3bb816 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/MESA/__pycache__/query_renderer.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/MESA/__pycache__/release_buffers.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/MESA/__pycache__/release_buffers.cpython-312.pyc new file mode 100644 index 00000000..97a9710e Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/MESA/__pycache__/release_buffers.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/MESA/__pycache__/set_3dfx_mode.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/MESA/__pycache__/set_3dfx_mode.cpython-312.pyc new file mode 100644 index 00000000..c332315e Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/MESA/__pycache__/set_3dfx_mode.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/MESA/__pycache__/swap_control.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/MESA/__pycache__/swap_control.cpython-312.pyc new file mode 100644 index 00000000..27336c2e Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/MESA/__pycache__/swap_control.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/MESA/agp_offset.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/MESA/agp_offset.py new file mode 100644 index 00000000..5cdd93b0 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/MESA/agp_offset.py @@ -0,0 +1,17 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLX import _types as _cs +# End users want this... +from OpenGL.raw.GLX._types import * +from OpenGL.raw.GLX import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLX_MESA_agp_offset' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLX,'GLX_MESA_agp_offset',error_checker=_errors._error_checker) + +@_f +@_p.types(_cs.c_uint,ctypes.c_void_p) +def glXGetAGPOffsetMESA(pointer):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/MESA/copy_sub_buffer.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/MESA/copy_sub_buffer.py new file mode 100644 index 00000000..b6cc422a --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/MESA/copy_sub_buffer.py @@ -0,0 +1,17 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLX import _types as _cs +# End users want this... +from OpenGL.raw.GLX._types import * +from OpenGL.raw.GLX import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLX_MESA_copy_sub_buffer' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLX,'GLX_MESA_copy_sub_buffer',error_checker=_errors._error_checker) + +@_f +@_p.types(None,ctypes.POINTER(_cs.Display),_cs.GLXDrawable,_cs.c_int,_cs.c_int,_cs.c_int,_cs.c_int) +def glXCopySubBufferMESA(dpy,drawable,x,y,width,height):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/MESA/pixmap_colormap.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/MESA/pixmap_colormap.py new file mode 100644 index 00000000..eb286651 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/MESA/pixmap_colormap.py @@ -0,0 +1,17 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLX import _types as _cs +# End users want this... +from OpenGL.raw.GLX._types import * +from OpenGL.raw.GLX import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLX_MESA_pixmap_colormap' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLX,'GLX_MESA_pixmap_colormap',error_checker=_errors._error_checker) + +@_f +@_p.types(_cs.GLXPixmap,ctypes.POINTER(_cs.Display),ctypes.POINTER(_cs.XVisualInfo),_cs.Pixmap,_cs.Colormap) +def glXCreateGLXPixmapMESA(dpy,visual,pixmap,cmap):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/MESA/query_renderer.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/MESA/query_renderer.py new file mode 100644 index 00000000..072891b4 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/MESA/query_renderer.py @@ -0,0 +1,36 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLX import _types as _cs +# End users want this... +from OpenGL.raw.GLX._types import * +from OpenGL.raw.GLX import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLX_MESA_query_renderer' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLX,'GLX_MESA_query_renderer',error_checker=_errors._error_checker) +GLX_RENDERER_ACCELERATED_MESA=_C('GLX_RENDERER_ACCELERATED_MESA',0x8186) +GLX_RENDERER_DEVICE_ID_MESA=_C('GLX_RENDERER_DEVICE_ID_MESA',0x8184) +GLX_RENDERER_OPENGL_COMPATIBILITY_PROFILE_VERSION_MESA=_C('GLX_RENDERER_OPENGL_COMPATIBILITY_PROFILE_VERSION_MESA',0x818B) +GLX_RENDERER_OPENGL_CORE_PROFILE_VERSION_MESA=_C('GLX_RENDERER_OPENGL_CORE_PROFILE_VERSION_MESA',0x818A) +GLX_RENDERER_OPENGL_ES2_PROFILE_VERSION_MESA=_C('GLX_RENDERER_OPENGL_ES2_PROFILE_VERSION_MESA',0x818D) +GLX_RENDERER_OPENGL_ES_PROFILE_VERSION_MESA=_C('GLX_RENDERER_OPENGL_ES_PROFILE_VERSION_MESA',0x818C) +GLX_RENDERER_PREFERRED_PROFILE_MESA=_C('GLX_RENDERER_PREFERRED_PROFILE_MESA',0x8189) +GLX_RENDERER_UNIFIED_MEMORY_ARCHITECTURE_MESA=_C('GLX_RENDERER_UNIFIED_MEMORY_ARCHITECTURE_MESA',0x8188) +GLX_RENDERER_VENDOR_ID_MESA=_C('GLX_RENDERER_VENDOR_ID_MESA',0x8183) +GLX_RENDERER_VERSION_MESA=_C('GLX_RENDERER_VERSION_MESA',0x8185) +GLX_RENDERER_VIDEO_MEMORY_MESA=_C('GLX_RENDERER_VIDEO_MEMORY_MESA',0x8187) +@_f +@_p.types(_cs.Bool,_cs.c_int,ctypes.POINTER(_cs.c_uint)) +def glXQueryCurrentRendererIntegerMESA(attribute,value):pass +@_f +@_p.types(ctypes.c_char_p,_cs.c_int) +def glXQueryCurrentRendererStringMESA(attribute):pass +@_f +@_p.types(_cs.Bool,ctypes.POINTER(_cs.Display),_cs.c_int,_cs.c_int,_cs.c_int,ctypes.POINTER(_cs.c_uint)) +def glXQueryRendererIntegerMESA(dpy,screen,renderer,attribute,value):pass +@_f +@_p.types(ctypes.c_char_p,ctypes.POINTER(_cs.Display),_cs.c_int,_cs.c_int,_cs.c_int) +def glXQueryRendererStringMESA(dpy,screen,renderer,attribute):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/MESA/release_buffers.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/MESA/release_buffers.py new file mode 100644 index 00000000..33ada57d --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/MESA/release_buffers.py @@ -0,0 +1,17 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLX import _types as _cs +# End users want this... +from OpenGL.raw.GLX._types import * +from OpenGL.raw.GLX import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLX_MESA_release_buffers' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLX,'GLX_MESA_release_buffers',error_checker=_errors._error_checker) + +@_f +@_p.types(_cs.Bool,ctypes.POINTER(_cs.Display),_cs.GLXDrawable) +def glXReleaseBuffersMESA(dpy,drawable):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/MESA/set_3dfx_mode.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/MESA/set_3dfx_mode.py new file mode 100644 index 00000000..6261d334 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/MESA/set_3dfx_mode.py @@ -0,0 +1,18 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLX import _types as _cs +# End users want this... +from OpenGL.raw.GLX._types import * +from OpenGL.raw.GLX import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLX_MESA_set_3dfx_mode' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLX,'GLX_MESA_set_3dfx_mode',error_checker=_errors._error_checker) +GLX_3DFX_FULLSCREEN_MODE_MESA=_C('GLX_3DFX_FULLSCREEN_MODE_MESA',0x2) +GLX_3DFX_WINDOW_MODE_MESA=_C('GLX_3DFX_WINDOW_MODE_MESA',0x1) +@_f +@_p.types(_cs.GLboolean,_cs.GLint) +def glXSet3DfxModeMESA(mode):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/MESA/swap_control.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/MESA/swap_control.py new file mode 100644 index 00000000..a4a06e89 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/MESA/swap_control.py @@ -0,0 +1,20 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLX import _types as _cs +# End users want this... +from OpenGL.raw.GLX._types import * +from OpenGL.raw.GLX import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLX_MESA_swap_control' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLX,'GLX_MESA_swap_control',error_checker=_errors._error_checker) + +@_f +@_p.types(_cs.c_int,) +def glXGetSwapIntervalMESA():pass +@_f +@_p.types(_cs.c_int,_cs.c_uint) +def glXSwapIntervalMESA(interval):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/NV/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/NV/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/NV/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/NV/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/NV/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..a9bb06e0 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/NV/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/NV/__pycache__/copy_buffer.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/NV/__pycache__/copy_buffer.cpython-312.pyc new file mode 100644 index 00000000..17a03f16 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/NV/__pycache__/copy_buffer.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/NV/__pycache__/copy_image.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/NV/__pycache__/copy_image.cpython-312.pyc new file mode 100644 index 00000000..3a8d859b Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/NV/__pycache__/copy_image.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/NV/__pycache__/delay_before_swap.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/NV/__pycache__/delay_before_swap.cpython-312.pyc new file mode 100644 index 00000000..eca9ec11 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/NV/__pycache__/delay_before_swap.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/NV/__pycache__/float_buffer.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/NV/__pycache__/float_buffer.cpython-312.pyc new file mode 100644 index 00000000..eee903e3 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/NV/__pycache__/float_buffer.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/NV/__pycache__/multigpu_context.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/NV/__pycache__/multigpu_context.cpython-312.pyc new file mode 100644 index 00000000..c40804e3 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/NV/__pycache__/multigpu_context.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/NV/__pycache__/multisample_coverage.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/NV/__pycache__/multisample_coverage.cpython-312.pyc new file mode 100644 index 00000000..dd022bc6 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/NV/__pycache__/multisample_coverage.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/NV/__pycache__/present_video.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/NV/__pycache__/present_video.cpython-312.pyc new file mode 100644 index 00000000..107b41a7 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/NV/__pycache__/present_video.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/NV/__pycache__/robustness_video_memory_purge.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/NV/__pycache__/robustness_video_memory_purge.cpython-312.pyc new file mode 100644 index 00000000..c75455f2 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/NV/__pycache__/robustness_video_memory_purge.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/NV/__pycache__/swap_group.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/NV/__pycache__/swap_group.cpython-312.pyc new file mode 100644 index 00000000..3c3213ab Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/NV/__pycache__/swap_group.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/NV/__pycache__/video_capture.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/NV/__pycache__/video_capture.cpython-312.pyc new file mode 100644 index 00000000..f4a607f6 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/NV/__pycache__/video_capture.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/NV/__pycache__/video_out.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/NV/__pycache__/video_out.cpython-312.pyc new file mode 100644 index 00000000..fd9d4af5 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/NV/__pycache__/video_out.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/NV/__pycache__/video_output.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/NV/__pycache__/video_output.cpython-312.pyc new file mode 100644 index 00000000..32a9c70a Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/NV/__pycache__/video_output.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/NV/copy_buffer.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/NV/copy_buffer.py new file mode 100644 index 00000000..ef01c0a1 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/NV/copy_buffer.py @@ -0,0 +1,20 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLX import _types as _cs +# End users want this... +from OpenGL.raw.GLX._types import * +from OpenGL.raw.GLX import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLX_NV_copy_buffer' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLX,'GLX_NV_copy_buffer',error_checker=_errors._error_checker) + +@_f +@_p.types(None,ctypes.POINTER(_cs.Display),_cs.GLXContext,_cs.GLXContext,_cs.GLenum,_cs.GLenum,_cs.GLintptr,_cs.GLintptr,_cs.GLsizeiptr) +def glXCopyBufferSubDataNV(dpy,readCtx,writeCtx,readTarget,writeTarget,readOffset,writeOffset,size):pass +@_f +@_p.types(None,ctypes.POINTER(_cs.Display),_cs.GLXContext,_cs.GLXContext,_cs.GLuint,_cs.GLuint,_cs.GLintptr,_cs.GLintptr,_cs.GLsizeiptr) +def glXNamedCopyBufferSubDataNV(dpy,readCtx,writeCtx,readBuffer,writeBuffer,readOffset,writeOffset,size):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/NV/copy_image.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/NV/copy_image.py new file mode 100644 index 00000000..80db968c --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/NV/copy_image.py @@ -0,0 +1,17 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLX import _types as _cs +# End users want this... +from OpenGL.raw.GLX._types import * +from OpenGL.raw.GLX import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLX_NV_copy_image' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLX,'GLX_NV_copy_image',error_checker=_errors._error_checker) + +@_f +@_p.types(None,ctypes.POINTER(_cs.Display),_cs.GLXContext,_cs.GLuint,_cs.GLenum,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLXContext,_cs.GLuint,_cs.GLenum,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLsizei,_cs.GLsizei) +def glXCopyImageSubDataNV(dpy,srcCtx,srcName,srcTarget,srcLevel,srcX,srcY,srcZ,dstCtx,dstName,dstTarget,dstLevel,dstX,dstY,dstZ,width,height,depth):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/NV/delay_before_swap.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/NV/delay_before_swap.py new file mode 100644 index 00000000..b8cffd8b --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/NV/delay_before_swap.py @@ -0,0 +1,17 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLX import _types as _cs +# End users want this... +from OpenGL.raw.GLX._types import * +from OpenGL.raw.GLX import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLX_NV_delay_before_swap' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLX,'GLX_NV_delay_before_swap',error_checker=_errors._error_checker) + +@_f +@_p.types(_cs.Bool,ctypes.POINTER(_cs.Display),_cs.GLXDrawable,_cs.GLfloat) +def glXDelayBeforeSwapNV(dpy,drawable,seconds):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/NV/float_buffer.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/NV/float_buffer.py new file mode 100644 index 00000000..71f60e2f --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/NV/float_buffer.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLX import _types as _cs +# End users want this... +from OpenGL.raw.GLX._types import * +from OpenGL.raw.GLX import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLX_NV_float_buffer' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLX,'GLX_NV_float_buffer',error_checker=_errors._error_checker) +GLX_FLOAT_COMPONENTS_NV=_C('GLX_FLOAT_COMPONENTS_NV',0x20B0) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/NV/multigpu_context.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/NV/multigpu_context.py new file mode 100644 index 00000000..e3f1bba4 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/NV/multigpu_context.py @@ -0,0 +1,19 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLX import _types as _cs +# End users want this... +from OpenGL.raw.GLX._types import * +from OpenGL.raw.GLX import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLX_NV_multigpu_context' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLX,'GLX_NV_multigpu_context',error_checker=_errors._error_checker) +GLX_CONTEXT_MULTIGPU_ATTRIB_AFR_NV=_C('GLX_CONTEXT_MULTIGPU_ATTRIB_AFR_NV',0x20AC) +GLX_CONTEXT_MULTIGPU_ATTRIB_MULTICAST_NV=_C('GLX_CONTEXT_MULTIGPU_ATTRIB_MULTICAST_NV',0x20AD) +GLX_CONTEXT_MULTIGPU_ATTRIB_MULTI_DISPLAY_MULTICAST_NV=_C('GLX_CONTEXT_MULTIGPU_ATTRIB_MULTI_DISPLAY_MULTICAST_NV',0x20AE) +GLX_CONTEXT_MULTIGPU_ATTRIB_NV=_C('GLX_CONTEXT_MULTIGPU_ATTRIB_NV',0x20AA) +GLX_CONTEXT_MULTIGPU_ATTRIB_SINGLE_NV=_C('GLX_CONTEXT_MULTIGPU_ATTRIB_SINGLE_NV',0x20AB) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/NV/multisample_coverage.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/NV/multisample_coverage.py new file mode 100644 index 00000000..b5a6b565 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/NV/multisample_coverage.py @@ -0,0 +1,16 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLX import _types as _cs +# End users want this... +from OpenGL.raw.GLX._types import * +from OpenGL.raw.GLX import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLX_NV_multisample_coverage' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLX,'GLX_NV_multisample_coverage',error_checker=_errors._error_checker) +GLX_COLOR_SAMPLES_NV=_C('GLX_COLOR_SAMPLES_NV',0x20B3) +GLX_COVERAGE_SAMPLES_NV=_C('GLX_COVERAGE_SAMPLES_NV',100001) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/NV/present_video.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/NV/present_video.py new file mode 100644 index 00000000..7eb42e2d --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/NV/present_video.py @@ -0,0 +1,20 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLX import _types as _cs +# End users want this... +from OpenGL.raw.GLX._types import * +from OpenGL.raw.GLX import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLX_NV_present_video' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLX,'GLX_NV_present_video',error_checker=_errors._error_checker) +GLX_NUM_VIDEO_SLOTS_NV=_C('GLX_NUM_VIDEO_SLOTS_NV',0x20F0) +@_f +@_p.types(_cs.c_int,ctypes.POINTER(_cs.Display),_cs.c_uint,_cs.c_uint,ctypes.POINTER(_cs.c_int)) +def glXBindVideoDeviceNV(dpy,video_slot,video_device,attrib_list):pass +@_f +@_p.types(ctypes.POINTER(_cs.c_uint),ctypes.POINTER(_cs.Display),_cs.c_int,ctypes.POINTER(_cs.c_int)) +def glXEnumerateVideoDevicesNV(dpy,screen,nelements):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/NV/robustness_video_memory_purge.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/NV/robustness_video_memory_purge.py new file mode 100644 index 00000000..f0798a23 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/NV/robustness_video_memory_purge.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLX import _types as _cs +# End users want this... +from OpenGL.raw.GLX._types import * +from OpenGL.raw.GLX import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLX_NV_robustness_video_memory_purge' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLX,'GLX_NV_robustness_video_memory_purge',error_checker=_errors._error_checker) +GLX_GENERATE_RESET_ON_VIDEO_MEMORY_PURGE_NV=_C('GLX_GENERATE_RESET_ON_VIDEO_MEMORY_PURGE_NV',0x20F7) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/NV/swap_group.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/NV/swap_group.py new file mode 100644 index 00000000..bc43b26f --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/NV/swap_group.py @@ -0,0 +1,32 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLX import _types as _cs +# End users want this... +from OpenGL.raw.GLX._types import * +from OpenGL.raw.GLX import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLX_NV_swap_group' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLX,'GLX_NV_swap_group',error_checker=_errors._error_checker) + +@_f +@_p.types(_cs.Bool,ctypes.POINTER(_cs.Display),_cs.GLuint,_cs.GLuint) +def glXBindSwapBarrierNV(dpy,group,barrier):pass +@_f +@_p.types(_cs.Bool,ctypes.POINTER(_cs.Display),_cs.GLXDrawable,_cs.GLuint) +def glXJoinSwapGroupNV(dpy,drawable,group):pass +@_f +@_p.types(_cs.Bool,ctypes.POINTER(_cs.Display),_cs.c_int,arrays.GLuintArray) +def glXQueryFrameCountNV(dpy,screen,count):pass +@_f +@_p.types(_cs.Bool,ctypes.POINTER(_cs.Display),_cs.c_int,arrays.GLuintArray,arrays.GLuintArray) +def glXQueryMaxSwapGroupsNV(dpy,screen,maxGroups,maxBarriers):pass +@_f +@_p.types(_cs.Bool,ctypes.POINTER(_cs.Display),_cs.GLXDrawable,arrays.GLuintArray,arrays.GLuintArray) +def glXQuerySwapGroupNV(dpy,drawable,group,barrier):pass +@_f +@_p.types(_cs.Bool,ctypes.POINTER(_cs.Display),_cs.c_int) +def glXResetFrameCountNV(dpy,screen):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/NV/video_capture.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/NV/video_capture.py new file mode 100644 index 00000000..64d4299e --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/NV/video_capture.py @@ -0,0 +1,31 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLX import _types as _cs +# End users want this... +from OpenGL.raw.GLX._types import * +from OpenGL.raw.GLX import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLX_NV_video_capture' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLX,'GLX_NV_video_capture',error_checker=_errors._error_checker) +GLX_DEVICE_ID_NV=_C('GLX_DEVICE_ID_NV',0x20CD) +GLX_NUM_VIDEO_CAPTURE_SLOTS_NV=_C('GLX_NUM_VIDEO_CAPTURE_SLOTS_NV',0x20CF) +GLX_UNIQUE_ID_NV=_C('GLX_UNIQUE_ID_NV',0x20CE) +@_f +@_p.types(_cs.c_int,ctypes.POINTER(_cs.Display),_cs.c_uint,_cs.GLXVideoCaptureDeviceNV) +def glXBindVideoCaptureDeviceNV(dpy,video_capture_slot,device):pass +@_f +@_p.types(ctypes.POINTER(_cs.GLXVideoCaptureDeviceNV),ctypes.POINTER(_cs.Display),_cs.c_int,ctypes.POINTER(_cs.c_int)) +def glXEnumerateVideoCaptureDevicesNV(dpy,screen,nelements):pass +@_f +@_p.types(None,ctypes.POINTER(_cs.Display),_cs.GLXVideoCaptureDeviceNV) +def glXLockVideoCaptureDeviceNV(dpy,device):pass +@_f +@_p.types(_cs.c_int,ctypes.POINTER(_cs.Display),_cs.GLXVideoCaptureDeviceNV,_cs.c_int,ctypes.POINTER(_cs.c_int)) +def glXQueryVideoCaptureDeviceNV(dpy,device,attribute,value):pass +@_f +@_p.types(None,ctypes.POINTER(_cs.Display),_cs.GLXVideoCaptureDeviceNV) +def glXReleaseVideoCaptureDeviceNV(dpy,device):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/NV/video_out.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/NV/video_out.py new file mode 100644 index 00000000..489b5f8d --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/NV/video_out.py @@ -0,0 +1,41 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLX import _types as _cs +# End users want this... +from OpenGL.raw.GLX._types import * +from OpenGL.raw.GLX import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLX_NV_video_out' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLX,'GLX_NV_video_out',error_checker=_errors._error_checker) +GLX_VIDEO_OUT_ALPHA_NV=_C('GLX_VIDEO_OUT_ALPHA_NV',0x20C4) +GLX_VIDEO_OUT_COLOR_AND_ALPHA_NV=_C('GLX_VIDEO_OUT_COLOR_AND_ALPHA_NV',0x20C6) +GLX_VIDEO_OUT_COLOR_AND_DEPTH_NV=_C('GLX_VIDEO_OUT_COLOR_AND_DEPTH_NV',0x20C7) +GLX_VIDEO_OUT_COLOR_NV=_C('GLX_VIDEO_OUT_COLOR_NV',0x20C3) +GLX_VIDEO_OUT_DEPTH_NV=_C('GLX_VIDEO_OUT_DEPTH_NV',0x20C5) +GLX_VIDEO_OUT_FIELD_1_NV=_C('GLX_VIDEO_OUT_FIELD_1_NV',0x20C9) +GLX_VIDEO_OUT_FIELD_2_NV=_C('GLX_VIDEO_OUT_FIELD_2_NV',0x20CA) +GLX_VIDEO_OUT_FRAME_NV=_C('GLX_VIDEO_OUT_FRAME_NV',0x20C8) +GLX_VIDEO_OUT_STACKED_FIELDS_1_2_NV=_C('GLX_VIDEO_OUT_STACKED_FIELDS_1_2_NV',0x20CB) +GLX_VIDEO_OUT_STACKED_FIELDS_2_1_NV=_C('GLX_VIDEO_OUT_STACKED_FIELDS_2_1_NV',0x20CC) +@_f +@_p.types(_cs.c_int,ctypes.POINTER(_cs.Display),_cs.GLXVideoDeviceNV,_cs.GLXPbuffer,_cs.c_int) +def glXBindVideoImageNV(dpy,VideoDevice,pbuf,iVideoBuffer):pass +@_f +@_p.types(_cs.c_int,ctypes.POINTER(_cs.Display),_cs.c_int,_cs.c_int,ctypes.POINTER(_cs.GLXVideoDeviceNV)) +def glXGetVideoDeviceNV(dpy,screen,numVideoDevices,pVideoDevice):pass +@_f +@_p.types(_cs.c_int,ctypes.POINTER(_cs.Display),_cs.c_int,_cs.GLXVideoDeviceNV,ctypes.POINTER(_cs.c_ulong),ctypes.POINTER(_cs.c_ulong)) +def glXGetVideoInfoNV(dpy,screen,VideoDevice,pulCounterOutputPbuffer,pulCounterOutputVideo):pass +@_f +@_p.types(_cs.c_int,ctypes.POINTER(_cs.Display),_cs.c_int,_cs.GLXVideoDeviceNV) +def glXReleaseVideoDeviceNV(dpy,screen,VideoDevice):pass +@_f +@_p.types(_cs.c_int,ctypes.POINTER(_cs.Display),_cs.GLXPbuffer) +def glXReleaseVideoImageNV(dpy,pbuf):pass +@_f +@_p.types(_cs.c_int,ctypes.POINTER(_cs.Display),_cs.GLXPbuffer,_cs.c_int,ctypes.POINTER(_cs.c_ulong),_cs.GLboolean) +def glXSendPbufferToVideoNV(dpy,pbuf,iBufferType,pulCounterPbuffer,bBlock):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/NV/video_output.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/NV/video_output.py new file mode 100644 index 00000000..cb651c12 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/NV/video_output.py @@ -0,0 +1,41 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLX import _types as _cs +# End users want this... +from OpenGL.raw.GLX._types import * +from OpenGL.raw.GLX import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLX_NV_video_output' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLX,'GLX_NV_video_output',error_checker=_errors._error_checker) +GLX_VIDEO_OUT_ALPHA_NV=_C('GLX_VIDEO_OUT_ALPHA_NV',0x20C4) +GLX_VIDEO_OUT_COLOR_AND_ALPHA_NV=_C('GLX_VIDEO_OUT_COLOR_AND_ALPHA_NV',0x20C6) +GLX_VIDEO_OUT_COLOR_AND_DEPTH_NV=_C('GLX_VIDEO_OUT_COLOR_AND_DEPTH_NV',0x20C7) +GLX_VIDEO_OUT_COLOR_NV=_C('GLX_VIDEO_OUT_COLOR_NV',0x20C3) +GLX_VIDEO_OUT_DEPTH_NV=_C('GLX_VIDEO_OUT_DEPTH_NV',0x20C5) +GLX_VIDEO_OUT_FIELD_1_NV=_C('GLX_VIDEO_OUT_FIELD_1_NV',0x20C9) +GLX_VIDEO_OUT_FIELD_2_NV=_C('GLX_VIDEO_OUT_FIELD_2_NV',0x20CA) +GLX_VIDEO_OUT_FRAME_NV=_C('GLX_VIDEO_OUT_FRAME_NV',0x20C8) +GLX_VIDEO_OUT_STACKED_FIELDS_1_2_NV=_C('GLX_VIDEO_OUT_STACKED_FIELDS_1_2_NV',0x20CB) +GLX_VIDEO_OUT_STACKED_FIELDS_2_1_NV=_C('GLX_VIDEO_OUT_STACKED_FIELDS_2_1_NV',0x20CC) +@_f +@_p.types(_cs.c_int,ctypes.POINTER(_cs.Display),_cs.GLXVideoDeviceNV,_cs.GLXPbuffer,_cs.c_int) +def glXBindVideoImageNV(dpy,VideoDevice,pbuf,iVideoBuffer):pass +@_f +@_p.types(_cs.c_int,ctypes.POINTER(_cs.Display),_cs.c_int,_cs.c_int,ctypes.POINTER(_cs.GLXVideoDeviceNV)) +def glXGetVideoDeviceNV(dpy,screen,numVideoDevices,pVideoDevice):pass +@_f +@_p.types(_cs.c_int,ctypes.POINTER(_cs.Display),_cs.c_int,_cs.GLXVideoDeviceNV,ctypes.POINTER(_cs.c_ulong),ctypes.POINTER(_cs.c_ulong)) +def glXGetVideoInfoNV(dpy,screen,VideoDevice,pulCounterOutputPbuffer,pulCounterOutputVideo):pass +@_f +@_p.types(_cs.c_int,ctypes.POINTER(_cs.Display),_cs.c_int,_cs.GLXVideoDeviceNV) +def glXReleaseVideoDeviceNV(dpy,screen,VideoDevice):pass +@_f +@_p.types(_cs.c_int,ctypes.POINTER(_cs.Display),_cs.GLXPbuffer) +def glXReleaseVideoImageNV(dpy,pbuf):pass +@_f +@_p.types(_cs.c_int,ctypes.POINTER(_cs.Display),_cs.GLXPbuffer,_cs.c_int,ctypes.POINTER(_cs.c_ulong),_cs.GLboolean) +def glXSendPbufferToVideoNV(dpy,pbuf,iBufferType,pulCounterPbuffer,bBlock):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/OML/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/OML/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/OML/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/OML/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/OML/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..30d4f4f5 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/OML/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/OML/__pycache__/swap_method.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/OML/__pycache__/swap_method.cpython-312.pyc new file mode 100644 index 00000000..bd528c70 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/OML/__pycache__/swap_method.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/OML/__pycache__/sync_control.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/OML/__pycache__/sync_control.cpython-312.pyc new file mode 100644 index 00000000..c114b8f7 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/OML/__pycache__/sync_control.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/OML/swap_method.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/OML/swap_method.py new file mode 100644 index 00000000..18a3255f --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/OML/swap_method.py @@ -0,0 +1,18 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLX import _types as _cs +# End users want this... +from OpenGL.raw.GLX._types import * +from OpenGL.raw.GLX import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLX_OML_swap_method' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLX,'GLX_OML_swap_method',error_checker=_errors._error_checker) +GLX_SWAP_COPY_OML=_C('GLX_SWAP_COPY_OML',0x8062) +GLX_SWAP_EXCHANGE_OML=_C('GLX_SWAP_EXCHANGE_OML',0x8061) +GLX_SWAP_METHOD_OML=_C('GLX_SWAP_METHOD_OML',0x8060) +GLX_SWAP_UNDEFINED_OML=_C('GLX_SWAP_UNDEFINED_OML',0x8063) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/OML/sync_control.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/OML/sync_control.py new file mode 100644 index 00000000..3d941ddb --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/OML/sync_control.py @@ -0,0 +1,29 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLX import _types as _cs +# End users want this... +from OpenGL.raw.GLX._types import * +from OpenGL.raw.GLX import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLX_OML_sync_control' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLX,'GLX_OML_sync_control',error_checker=_errors._error_checker) + +@_f +@_p.types(_cs.Bool,ctypes.POINTER(_cs.Display),_cs.GLXDrawable,ctypes.POINTER(_cs.int32_t),ctypes.POINTER(_cs.int32_t)) +def glXGetMscRateOML(dpy,drawable,numerator,denominator):pass +@_f +@_p.types(_cs.Bool,ctypes.POINTER(_cs.Display),_cs.GLXDrawable,ctypes.POINTER(_cs.int64_t),ctypes.POINTER(_cs.int64_t),ctypes.POINTER(_cs.int64_t)) +def glXGetSyncValuesOML(dpy,drawable,ust,msc,sbc):pass +@_f +@_p.types(_cs.int64_t,ctypes.POINTER(_cs.Display),_cs.GLXDrawable,_cs.int64_t,_cs.int64_t,_cs.int64_t) +def glXSwapBuffersMscOML(dpy,drawable,target_msc,divisor,remainder):pass +@_f +@_p.types(_cs.Bool,ctypes.POINTER(_cs.Display),_cs.GLXDrawable,_cs.int64_t,_cs.int64_t,_cs.int64_t,ctypes.POINTER(_cs.int64_t),ctypes.POINTER(_cs.int64_t),ctypes.POINTER(_cs.int64_t)) +def glXWaitForMscOML(dpy,drawable,target_msc,divisor,remainder,ust,msc,sbc):pass +@_f +@_p.types(_cs.Bool,ctypes.POINTER(_cs.Display),_cs.GLXDrawable,_cs.int64_t,ctypes.POINTER(_cs.int64_t),ctypes.POINTER(_cs.int64_t),ctypes.POINTER(_cs.int64_t)) +def glXWaitForSbcOML(dpy,drawable,target_sbc,ust,msc,sbc):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/SGI/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/SGI/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/SGI/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/SGI/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/SGI/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..c8b7caae Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/SGI/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/SGI/__pycache__/cushion.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/SGI/__pycache__/cushion.cpython-312.pyc new file mode 100644 index 00000000..bc9f04aa Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/SGI/__pycache__/cushion.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/SGI/__pycache__/make_current_read.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/SGI/__pycache__/make_current_read.cpython-312.pyc new file mode 100644 index 00000000..ee73ae7a Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/SGI/__pycache__/make_current_read.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/SGI/__pycache__/swap_control.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/SGI/__pycache__/swap_control.cpython-312.pyc new file mode 100644 index 00000000..29fdf63a Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/SGI/__pycache__/swap_control.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/SGI/__pycache__/video_sync.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/SGI/__pycache__/video_sync.cpython-312.pyc new file mode 100644 index 00000000..6ee09392 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/SGI/__pycache__/video_sync.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/SGI/cushion.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/SGI/cushion.py new file mode 100644 index 00000000..2af5760f --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/SGI/cushion.py @@ -0,0 +1,17 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLX import _types as _cs +# End users want this... +from OpenGL.raw.GLX._types import * +from OpenGL.raw.GLX import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLX_SGI_cushion' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLX,'GLX_SGI_cushion',error_checker=_errors._error_checker) + +@_f +@_p.types(None,ctypes.POINTER(_cs.Display),_cs.Window,ctypes.c_float) +def glXCushionSGI(dpy,window,cushion):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/SGI/make_current_read.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/SGI/make_current_read.py new file mode 100644 index 00000000..4dae75f7 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/SGI/make_current_read.py @@ -0,0 +1,20 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLX import _types as _cs +# End users want this... +from OpenGL.raw.GLX._types import * +from OpenGL.raw.GLX import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLX_SGI_make_current_read' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLX,'GLX_SGI_make_current_read',error_checker=_errors._error_checker) + +@_f +@_p.types(_cs.GLXDrawable,) +def glXGetCurrentReadDrawableSGI():pass +@_f +@_p.types(_cs.Bool,ctypes.POINTER(_cs.Display),_cs.GLXDrawable,_cs.GLXDrawable,_cs.GLXContext) +def glXMakeCurrentReadSGI(dpy,draw,read,ctx):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/SGI/swap_control.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/SGI/swap_control.py new file mode 100644 index 00000000..fa88831a --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/SGI/swap_control.py @@ -0,0 +1,17 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLX import _types as _cs +# End users want this... +from OpenGL.raw.GLX._types import * +from OpenGL.raw.GLX import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLX_SGI_swap_control' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLX,'GLX_SGI_swap_control',error_checker=_errors._error_checker) + +@_f +@_p.types(_cs.c_int,_cs.c_int) +def glXSwapIntervalSGI(interval):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/SGI/video_sync.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/SGI/video_sync.py new file mode 100644 index 00000000..6329a67a --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/SGI/video_sync.py @@ -0,0 +1,20 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLX import _types as _cs +# End users want this... +from OpenGL.raw.GLX._types import * +from OpenGL.raw.GLX import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLX_SGI_video_sync' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLX,'GLX_SGI_video_sync',error_checker=_errors._error_checker) + +@_f +@_p.types(_cs.c_int,ctypes.POINTER(_cs.c_uint)) +def glXGetVideoSyncSGI(count):pass +@_f +@_p.types(_cs.c_int,_cs.c_int,_cs.c_int,ctypes.POINTER(_cs.c_uint)) +def glXWaitVideoSyncSGI(divisor,remainder,count):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/SGIS/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/SGIS/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/SGIS/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/SGIS/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/SGIS/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..a77fb284 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/SGIS/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/SGIS/__pycache__/blended_overlay.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/SGIS/__pycache__/blended_overlay.cpython-312.pyc new file mode 100644 index 00000000..1c161fc4 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/SGIS/__pycache__/blended_overlay.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/SGIS/__pycache__/multisample.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/SGIS/__pycache__/multisample.cpython-312.pyc new file mode 100644 index 00000000..33fd7650 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/SGIS/__pycache__/multisample.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/SGIS/__pycache__/shared_multisample.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/SGIS/__pycache__/shared_multisample.cpython-312.pyc new file mode 100644 index 00000000..04d24d6c Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/SGIS/__pycache__/shared_multisample.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/SGIS/blended_overlay.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/SGIS/blended_overlay.py new file mode 100644 index 00000000..24a7086d --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/SGIS/blended_overlay.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLX import _types as _cs +# End users want this... +from OpenGL.raw.GLX._types import * +from OpenGL.raw.GLX import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLX_SGIS_blended_overlay' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLX,'GLX_SGIS_blended_overlay',error_checker=_errors._error_checker) +GLX_BLENDED_RGBA_SGIS=_C('GLX_BLENDED_RGBA_SGIS',0x8025) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/SGIS/multisample.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/SGIS/multisample.py new file mode 100644 index 00000000..624da1c8 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/SGIS/multisample.py @@ -0,0 +1,16 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLX import _types as _cs +# End users want this... +from OpenGL.raw.GLX._types import * +from OpenGL.raw.GLX import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLX_SGIS_multisample' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLX,'GLX_SGIS_multisample',error_checker=_errors._error_checker) +GLX_SAMPLES_SGIS=_C('GLX_SAMPLES_SGIS',100001) +GLX_SAMPLE_BUFFERS_SGIS=_C('GLX_SAMPLE_BUFFERS_SGIS',100000) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/SGIS/shared_multisample.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/SGIS/shared_multisample.py new file mode 100644 index 00000000..7301a965 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/SGIS/shared_multisample.py @@ -0,0 +1,16 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLX import _types as _cs +# End users want this... +from OpenGL.raw.GLX._types import * +from OpenGL.raw.GLX import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLX_SGIS_shared_multisample' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLX,'GLX_SGIS_shared_multisample',error_checker=_errors._error_checker) +GLX_MULTISAMPLE_SUB_RECT_HEIGHT_SGIS=_C('GLX_MULTISAMPLE_SUB_RECT_HEIGHT_SGIS',0x8027) +GLX_MULTISAMPLE_SUB_RECT_WIDTH_SGIS=_C('GLX_MULTISAMPLE_SUB_RECT_WIDTH_SGIS',0x8026) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/SGIX/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/SGIX/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/SGIX/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/SGIX/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/SGIX/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..86155ef4 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/SGIX/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/SGIX/__pycache__/dmbuffer.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/SGIX/__pycache__/dmbuffer.cpython-312.pyc new file mode 100644 index 00000000..90b12502 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/SGIX/__pycache__/dmbuffer.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/SGIX/__pycache__/fbconfig.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/SGIX/__pycache__/fbconfig.cpython-312.pyc new file mode 100644 index 00000000..92772e61 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/SGIX/__pycache__/fbconfig.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/SGIX/__pycache__/hyperpipe.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/SGIX/__pycache__/hyperpipe.cpython-312.pyc new file mode 100644 index 00000000..838086d7 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/SGIX/__pycache__/hyperpipe.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/SGIX/__pycache__/pbuffer.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/SGIX/__pycache__/pbuffer.cpython-312.pyc new file mode 100644 index 00000000..be262255 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/SGIX/__pycache__/pbuffer.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/SGIX/__pycache__/swap_barrier.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/SGIX/__pycache__/swap_barrier.cpython-312.pyc new file mode 100644 index 00000000..0cb29a65 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/SGIX/__pycache__/swap_barrier.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/SGIX/__pycache__/swap_group.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/SGIX/__pycache__/swap_group.cpython-312.pyc new file mode 100644 index 00000000..68f09cbe Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/SGIX/__pycache__/swap_group.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/SGIX/__pycache__/video_resize.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/SGIX/__pycache__/video_resize.cpython-312.pyc new file mode 100644 index 00000000..be6553ff Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/SGIX/__pycache__/video_resize.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/SGIX/__pycache__/video_source.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/SGIX/__pycache__/video_source.cpython-312.pyc new file mode 100644 index 00000000..6ecff1f9 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/SGIX/__pycache__/video_source.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/SGIX/__pycache__/visual_select_group.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/SGIX/__pycache__/visual_select_group.cpython-312.pyc new file mode 100644 index 00000000..321ae528 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/SGIX/__pycache__/visual_select_group.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/SGIX/dmbuffer.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/SGIX/dmbuffer.py new file mode 100644 index 00000000..72114f56 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/SGIX/dmbuffer.py @@ -0,0 +1,17 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLX import _types as _cs +# End users want this... +from OpenGL.raw.GLX._types import * +from OpenGL.raw.GLX import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLX_SGIX_dmbuffer' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLX,'GLX_SGIX_dmbuffer',error_checker=_errors._error_checker) +GLX_DIGITAL_MEDIA_PBUFFER_SGIX=_C('GLX_DIGITAL_MEDIA_PBUFFER_SGIX',0x8024) +@_f +@_p.types(_cs.Bool,ctypes.POINTER(_cs.Display),_cs.GLXPbufferSGIX,ctypes.POINTER(_cs.DMparams),_cs.DMbuffer) +def glXAssociateDMPbufferSGIX(dpy,pbuffer,params,dmbuffer):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/SGIX/fbconfig.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/SGIX/fbconfig.py new file mode 100644 index 00000000..bb0f8c2e --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/SGIX/fbconfig.py @@ -0,0 +1,42 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLX import _types as _cs +# End users want this... +from OpenGL.raw.GLX._types import * +from OpenGL.raw.GLX import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLX_SGIX_fbconfig' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLX,'GLX_SGIX_fbconfig',error_checker=_errors._error_checker) +GLX_COLOR_INDEX_BIT_SGIX=_C('GLX_COLOR_INDEX_BIT_SGIX',0x00000002) +GLX_COLOR_INDEX_TYPE_SGIX=_C('GLX_COLOR_INDEX_TYPE_SGIX',0x8015) +GLX_DRAWABLE_TYPE_SGIX=_C('GLX_DRAWABLE_TYPE_SGIX',0x8010) +GLX_FBCONFIG_ID_SGIX=_C('GLX_FBCONFIG_ID_SGIX',0x8013) +GLX_PIXMAP_BIT_SGIX=_C('GLX_PIXMAP_BIT_SGIX',0x00000002) +GLX_RENDER_TYPE_SGIX=_C('GLX_RENDER_TYPE_SGIX',0x8011) +GLX_RGBA_BIT_SGIX=_C('GLX_RGBA_BIT_SGIX',0x00000001) +GLX_RGBA_TYPE_SGIX=_C('GLX_RGBA_TYPE_SGIX',0x8014) +GLX_SCREEN_EXT=_C('GLX_SCREEN_EXT',0x800C) +GLX_WINDOW_BIT_SGIX=_C('GLX_WINDOW_BIT_SGIX',0x00000001) +GLX_X_RENDERABLE_SGIX=_C('GLX_X_RENDERABLE_SGIX',0x8012) +@_f +@_p.types(ctypes.POINTER(_cs.GLXFBConfigSGIX),ctypes.POINTER(_cs.Display),_cs.c_int,ctypes.POINTER(_cs.c_int),ctypes.POINTER(_cs.c_int)) +def glXChooseFBConfigSGIX(dpy,screen,attrib_list,nelements):pass +@_f +@_p.types(_cs.GLXContext,ctypes.POINTER(_cs.Display),_cs.GLXFBConfigSGIX,_cs.c_int,_cs.GLXContext,_cs.Bool) +def glXCreateContextWithConfigSGIX(dpy,config,render_type,share_list,direct):pass +@_f +@_p.types(_cs.GLXPixmap,ctypes.POINTER(_cs.Display),_cs.GLXFBConfigSGIX,_cs.Pixmap) +def glXCreateGLXPixmapWithConfigSGIX(dpy,config,pixmap):pass +@_f +@_p.types(_cs.c_int,ctypes.POINTER(_cs.Display),_cs.GLXFBConfigSGIX,_cs.c_int,ctypes.POINTER(_cs.c_int)) +def glXGetFBConfigAttribSGIX(dpy,config,attribute,value):pass +@_f +@_p.types(_cs.GLXFBConfigSGIX,ctypes.POINTER(_cs.Display),ctypes.POINTER(_cs.XVisualInfo)) +def glXGetFBConfigFromVisualSGIX(dpy,vis):pass +@_f +@_p.types(ctypes.POINTER(_cs.XVisualInfo),ctypes.POINTER(_cs.Display),_cs.GLXFBConfigSGIX) +def glXGetVisualFromFBConfigSGIX(dpy,config):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/SGIX/hyperpipe.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/SGIX/hyperpipe.py new file mode 100644 index 00000000..23784216 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/SGIX/hyperpipe.py @@ -0,0 +1,47 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLX import _types as _cs +# End users want this... +from OpenGL.raw.GLX._types import * +from OpenGL.raw.GLX import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLX_SGIX_hyperpipe' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLX,'GLX_SGIX_hyperpipe',error_checker=_errors._error_checker) +GLX_BAD_HYPERPIPE_CONFIG_SGIX=_C('GLX_BAD_HYPERPIPE_CONFIG_SGIX',91) +GLX_BAD_HYPERPIPE_SGIX=_C('GLX_BAD_HYPERPIPE_SGIX',92) +GLX_HYPERPIPE_DISPLAY_PIPE_SGIX=_C('GLX_HYPERPIPE_DISPLAY_PIPE_SGIX',0x00000001) +GLX_HYPERPIPE_ID_SGIX=_C('GLX_HYPERPIPE_ID_SGIX',0x8030) +GLX_HYPERPIPE_PIPE_NAME_LENGTH_SGIX=_C('GLX_HYPERPIPE_PIPE_NAME_LENGTH_SGIX',80) +GLX_HYPERPIPE_PIXEL_AVERAGE_SGIX=_C('GLX_HYPERPIPE_PIXEL_AVERAGE_SGIX',0x00000004) +GLX_HYPERPIPE_RENDER_PIPE_SGIX=_C('GLX_HYPERPIPE_RENDER_PIPE_SGIX',0x00000002) +GLX_HYPERPIPE_STEREO_SGIX=_C('GLX_HYPERPIPE_STEREO_SGIX',0x00000003) +GLX_PIPE_RECT_LIMITS_SGIX=_C('GLX_PIPE_RECT_LIMITS_SGIX',0x00000002) +GLX_PIPE_RECT_SGIX=_C('GLX_PIPE_RECT_SGIX',0x00000001) +@_f +@_p.types(_cs.c_int,ctypes.POINTER(_cs.Display),_cs.c_int) +def glXBindHyperpipeSGIX(dpy,hpId):pass +@_f +@_p.types(_cs.c_int,ctypes.POINTER(_cs.Display),_cs.c_int) +def glXDestroyHyperpipeConfigSGIX(dpy,hpId):pass +@_f +@_p.types(_cs.c_int,ctypes.POINTER(_cs.Display),_cs.c_int,_cs.c_int,_cs.c_int,ctypes.c_void_p) +def glXHyperpipeAttribSGIX(dpy,timeSlice,attrib,size,attribList):pass +@_f +@_p.types(_cs.c_int,ctypes.POINTER(_cs.Display),_cs.c_int,_cs.c_int,ctypes.POINTER(_cs.GLXHyperpipeConfigSGIX),ctypes.POINTER(_cs.c_int)) +def glXHyperpipeConfigSGIX(dpy,networkId,npipes,cfg,hpId):pass +@_f +@_p.types(_cs.c_int,ctypes.POINTER(_cs.Display),_cs.c_int,_cs.c_int,_cs.c_int,ctypes.c_void_p) +def glXQueryHyperpipeAttribSGIX(dpy,timeSlice,attrib,size,returnAttribList):pass +@_f +@_p.types(_cs.c_int,ctypes.POINTER(_cs.Display),_cs.c_int,_cs.c_int,_cs.c_int,ctypes.c_void_p,ctypes.c_void_p) +def glXQueryHyperpipeBestAttribSGIX(dpy,timeSlice,attrib,size,attribList,returnAttribList):pass +@_f +@_p.types(ctypes.POINTER(_cs.GLXHyperpipeConfigSGIX),ctypes.POINTER(_cs.Display),_cs.c_int,ctypes.POINTER(_cs.c_int)) +def glXQueryHyperpipeConfigSGIX(dpy,hpId,npipes):pass +@_f +@_p.types(ctypes.POINTER(_cs.GLXHyperpipeNetworkSGIX),ctypes.POINTER(_cs.Display),ctypes.POINTER(_cs.c_int)) +def glXQueryHyperpipeNetworkSGIX(dpy,npipes):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/SGIX/pbuffer.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/SGIX/pbuffer.py new file mode 100644 index 00000000..549a5878 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/SGIX/pbuffer.py @@ -0,0 +1,53 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLX import _types as _cs +# End users want this... +from OpenGL.raw.GLX._types import * +from OpenGL.raw.GLX import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLX_SGIX_pbuffer' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLX,'GLX_SGIX_pbuffer',error_checker=_errors._error_checker) +GLX_ACCUM_BUFFER_BIT_SGIX=_C('GLX_ACCUM_BUFFER_BIT_SGIX',0x00000080) +GLX_AUX_BUFFERS_BIT_SGIX=_C('GLX_AUX_BUFFERS_BIT_SGIX',0x00000010) +GLX_BACK_LEFT_BUFFER_BIT_SGIX=_C('GLX_BACK_LEFT_BUFFER_BIT_SGIX',0x00000004) +GLX_BACK_RIGHT_BUFFER_BIT_SGIX=_C('GLX_BACK_RIGHT_BUFFER_BIT_SGIX',0x00000008) +GLX_BUFFER_CLOBBER_MASK_SGIX=_C('GLX_BUFFER_CLOBBER_MASK_SGIX',0x08000000) +GLX_DAMAGED_SGIX=_C('GLX_DAMAGED_SGIX',0x8020) +GLX_DEPTH_BUFFER_BIT_SGIX=_C('GLX_DEPTH_BUFFER_BIT_SGIX',0x00000020) +GLX_EVENT_MASK_SGIX=_C('GLX_EVENT_MASK_SGIX',0x801F) +GLX_FRONT_LEFT_BUFFER_BIT_SGIX=_C('GLX_FRONT_LEFT_BUFFER_BIT_SGIX',0x00000001) +GLX_FRONT_RIGHT_BUFFER_BIT_SGIX=_C('GLX_FRONT_RIGHT_BUFFER_BIT_SGIX',0x00000002) +GLX_HEIGHT_SGIX=_C('GLX_HEIGHT_SGIX',0x801E) +GLX_LARGEST_PBUFFER_SGIX=_C('GLX_LARGEST_PBUFFER_SGIX',0x801C) +GLX_MAX_PBUFFER_HEIGHT_SGIX=_C('GLX_MAX_PBUFFER_HEIGHT_SGIX',0x8017) +GLX_MAX_PBUFFER_PIXELS_SGIX=_C('GLX_MAX_PBUFFER_PIXELS_SGIX',0x8018) +GLX_MAX_PBUFFER_WIDTH_SGIX=_C('GLX_MAX_PBUFFER_WIDTH_SGIX',0x8016) +GLX_OPTIMAL_PBUFFER_HEIGHT_SGIX=_C('GLX_OPTIMAL_PBUFFER_HEIGHT_SGIX',0x801A) +GLX_OPTIMAL_PBUFFER_WIDTH_SGIX=_C('GLX_OPTIMAL_PBUFFER_WIDTH_SGIX',0x8019) +GLX_PBUFFER_BIT_SGIX=_C('GLX_PBUFFER_BIT_SGIX',0x00000004) +GLX_PBUFFER_SGIX=_C('GLX_PBUFFER_SGIX',0x8023) +GLX_PRESERVED_CONTENTS_SGIX=_C('GLX_PRESERVED_CONTENTS_SGIX',0x801B) +GLX_SAMPLE_BUFFERS_BIT_SGIX=_C('GLX_SAMPLE_BUFFERS_BIT_SGIX',0x00000100) +GLX_SAVED_SGIX=_C('GLX_SAVED_SGIX',0x8021) +GLX_STENCIL_BUFFER_BIT_SGIX=_C('GLX_STENCIL_BUFFER_BIT_SGIX',0x00000040) +GLX_WIDTH_SGIX=_C('GLX_WIDTH_SGIX',0x801D) +GLX_WINDOW_SGIX=_C('GLX_WINDOW_SGIX',0x8022) +@_f +@_p.types(_cs.GLXPbufferSGIX,ctypes.POINTER(_cs.Display),_cs.GLXFBConfigSGIX,_cs.c_uint,_cs.c_uint,ctypes.POINTER(_cs.c_int)) +def glXCreateGLXPbufferSGIX(dpy,config,width,height,attrib_list):pass +@_f +@_p.types(None,ctypes.POINTER(_cs.Display),_cs.GLXPbufferSGIX) +def glXDestroyGLXPbufferSGIX(dpy,pbuf):pass +@_f +@_p.types(None,ctypes.POINTER(_cs.Display),_cs.GLXDrawable,ctypes.POINTER(_cs.c_ulong)) +def glXGetSelectedEventSGIX(dpy,drawable,mask):pass +@_f +@_p.types(None,ctypes.POINTER(_cs.Display),_cs.GLXPbufferSGIX,_cs.c_int,ctypes.POINTER(_cs.c_uint)) +def glXQueryGLXPbufferSGIX(dpy,pbuf,attribute,value):pass +@_f +@_p.types(None,ctypes.POINTER(_cs.Display),_cs.GLXDrawable,_cs.c_ulong) +def glXSelectEventSGIX(dpy,drawable,mask):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/SGIX/swap_barrier.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/SGIX/swap_barrier.py new file mode 100644 index 00000000..8dc1e6a4 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/SGIX/swap_barrier.py @@ -0,0 +1,20 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLX import _types as _cs +# End users want this... +from OpenGL.raw.GLX._types import * +from OpenGL.raw.GLX import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLX_SGIX_swap_barrier' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLX,'GLX_SGIX_swap_barrier',error_checker=_errors._error_checker) + +@_f +@_p.types(None,ctypes.POINTER(_cs.Display),_cs.GLXDrawable,_cs.c_int) +def glXBindSwapBarrierSGIX(dpy,drawable,barrier):pass +@_f +@_p.types(_cs.Bool,ctypes.POINTER(_cs.Display),_cs.c_int,ctypes.POINTER(_cs.c_int)) +def glXQueryMaxSwapBarriersSGIX(dpy,screen,max):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/SGIX/swap_group.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/SGIX/swap_group.py new file mode 100644 index 00000000..5f336760 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/SGIX/swap_group.py @@ -0,0 +1,17 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLX import _types as _cs +# End users want this... +from OpenGL.raw.GLX._types import * +from OpenGL.raw.GLX import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLX_SGIX_swap_group' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLX,'GLX_SGIX_swap_group',error_checker=_errors._error_checker) + +@_f +@_p.types(None,ctypes.POINTER(_cs.Display),_cs.GLXDrawable,_cs.GLXDrawable) +def glXJoinSwapGroupSGIX(dpy,drawable,member):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/SGIX/video_resize.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/SGIX/video_resize.py new file mode 100644 index 00000000..da9afc57 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/SGIX/video_resize.py @@ -0,0 +1,30 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLX import _types as _cs +# End users want this... +from OpenGL.raw.GLX._types import * +from OpenGL.raw.GLX import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLX_SGIX_video_resize' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLX,'GLX_SGIX_video_resize',error_checker=_errors._error_checker) +GLX_SYNC_FRAME_SGIX=_C('GLX_SYNC_FRAME_SGIX',0x00000000) +GLX_SYNC_SWAP_SGIX=_C('GLX_SYNC_SWAP_SGIX',0x00000001) +@_f +@_p.types(_cs.c_int,ctypes.POINTER(_cs.Display),_cs.c_int,_cs.c_int,_cs.Window) +def glXBindChannelToWindowSGIX(display,screen,channel,window):pass +@_f +@_p.types(_cs.c_int,ctypes.POINTER(_cs.Display),_cs.c_int,_cs.c_int,_cs.c_int,_cs.c_int,_cs.c_int,_cs.c_int) +def glXChannelRectSGIX(display,screen,channel,x,y,w,h):pass +@_f +@_p.types(_cs.c_int,ctypes.POINTER(_cs.Display),_cs.c_int,_cs.c_int,_cs.GLenum) +def glXChannelRectSyncSGIX(display,screen,channel,synctype):pass +@_f +@_p.types(_cs.c_int,ctypes.POINTER(_cs.Display),_cs.c_int,_cs.c_int,ctypes.POINTER(_cs.c_int),ctypes.POINTER(_cs.c_int),ctypes.POINTER(_cs.c_int),ctypes.POINTER(_cs.c_int)) +def glXQueryChannelDeltasSGIX(display,screen,channel,x,y,w,h):pass +@_f +@_p.types(_cs.c_int,ctypes.POINTER(_cs.Display),_cs.c_int,_cs.c_int,ctypes.POINTER(_cs.c_int),ctypes.POINTER(_cs.c_int),ctypes.POINTER(_cs.c_int),ctypes.POINTER(_cs.c_int)) +def glXQueryChannelRectSGIX(display,screen,channel,dx,dy,dw,dh):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/SGIX/video_source.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/SGIX/video_source.py new file mode 100644 index 00000000..6ae98777 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/SGIX/video_source.py @@ -0,0 +1,20 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLX import _types as _cs +# End users want this... +from OpenGL.raw.GLX._types import * +from OpenGL.raw.GLX import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLX_SGIX_video_source' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLX,'GLX_SGIX_video_source',error_checker=_errors._error_checker) + +@_f +@_p.types(_cs.GLXVideoSourceSGIX,ctypes.POINTER(_cs.Display),_cs.c_int,_cs.VLServer,_cs.VLPath,_cs.c_int,_cs.VLNode) +def glXCreateGLXVideoSourceSGIX(display,screen,server,path,nodeClass,drainNode):pass +@_f +@_p.types(None,ctypes.POINTER(_cs.Display),_cs.GLXVideoSourceSGIX) +def glXDestroyGLXVideoSourceSGIX(dpy,glxvideosource):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/SGIX/visual_select_group.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/SGIX/visual_select_group.py new file mode 100644 index 00000000..fd646e0f --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/SGIX/visual_select_group.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLX import _types as _cs +# End users want this... +from OpenGL.raw.GLX._types import * +from OpenGL.raw.GLX import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLX_SGIX_visual_select_group' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLX,'GLX_SGIX_visual_select_group',error_checker=_errors._error_checker) +GLX_VISUAL_SELECT_GROUP_SGIX=_C('GLX_VISUAL_SELECT_GROUP_SGIX',0x8028) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/SUN/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/SUN/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/SUN/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/SUN/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/SUN/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..341f76a2 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/SUN/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/SUN/__pycache__/get_transparent_index.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/SUN/__pycache__/get_transparent_index.cpython-312.pyc new file mode 100644 index 00000000..c6f53c3c Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/SUN/__pycache__/get_transparent_index.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/SUN/get_transparent_index.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/SUN/get_transparent_index.py new file mode 100644 index 00000000..da941e03 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/SUN/get_transparent_index.py @@ -0,0 +1,17 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLX import _types as _cs +# End users want this... +from OpenGL.raw.GLX._types import * +from OpenGL.raw.GLX import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLX_SUN_get_transparent_index' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLX,'GLX_SUN_get_transparent_index',error_checker=_errors._error_checker) + +@_f +@_p.types(_cs.Status,ctypes.POINTER(_cs.Display),_cs.Window,_cs.Window,ctypes.POINTER(_cs.c_ulong)) +def glXGetTransparentIndexSUN(dpy,overlay,underlay,pTransparentIndex):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/VERSION/GLX_1_0.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/VERSION/GLX_1_0.py new file mode 100644 index 00000000..8c27ef96 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/VERSION/GLX_1_0.py @@ -0,0 +1,92 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLX import _types as _cs +# End users want this... +from OpenGL.raw.GLX._types import * +from OpenGL.raw.GLX import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLX_VERSION_GLX_1_0' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLX,'GLX_VERSION_GLX_1_0',error_checker=_errors._error_checker) +GLX_ACCUM_ALPHA_SIZE=_C('GLX_ACCUM_ALPHA_SIZE',17) +GLX_ACCUM_BLUE_SIZE=_C('GLX_ACCUM_BLUE_SIZE',16) +GLX_ACCUM_GREEN_SIZE=_C('GLX_ACCUM_GREEN_SIZE',15) +GLX_ACCUM_RED_SIZE=_C('GLX_ACCUM_RED_SIZE',14) +GLX_ALPHA_SIZE=_C('GLX_ALPHA_SIZE',11) +GLX_AUX_BUFFERS=_C('GLX_AUX_BUFFERS',7) +GLX_BAD_ATTRIBUTE=_C('GLX_BAD_ATTRIBUTE',2) +GLX_BAD_CONTEXT=_C('GLX_BAD_CONTEXT',5) +GLX_BAD_ENUM=_C('GLX_BAD_ENUM',7) +GLX_BAD_SCREEN=_C('GLX_BAD_SCREEN',1) +GLX_BAD_VALUE=_C('GLX_BAD_VALUE',6) +GLX_BAD_VISUAL=_C('GLX_BAD_VISUAL',4) +GLX_BLUE_SIZE=_C('GLX_BLUE_SIZE',10) +GLX_BUFFER_SIZE=_C('GLX_BUFFER_SIZE',2) +GLX_BufferSwapComplete=_C('GLX_BufferSwapComplete',1) +GLX_DEPTH_SIZE=_C('GLX_DEPTH_SIZE',12) +GLX_DOUBLEBUFFER=_C('GLX_DOUBLEBUFFER',5) +# GLX_EXTENSION_NAME=_C('GLX_EXTENSION_NAME',"GLX") +GLX_GREEN_SIZE=_C('GLX_GREEN_SIZE',9) +GLX_LEVEL=_C('GLX_LEVEL',3) +GLX_NO_EXTENSION=_C('GLX_NO_EXTENSION',3) +GLX_PbufferClobber=_C('GLX_PbufferClobber',0) +GLX_RED_SIZE=_C('GLX_RED_SIZE',8) +GLX_RGBA=_C('GLX_RGBA',4) +GLX_STENCIL_SIZE=_C('GLX_STENCIL_SIZE',13) +GLX_STEREO=_C('GLX_STEREO',6) +GLX_USE_GL=_C('GLX_USE_GL',1) +__GLX_NUMBER_EVENTS=_C('__GLX_NUMBER_EVENTS',17) +@_f +@_p.types(ctypes.POINTER(_cs.XVisualInfo),ctypes.POINTER(_cs.Display),_cs.c_int,ctypes.POINTER(_cs.c_int)) +def glXChooseVisual(dpy,screen,attribList):pass +@_f +@_p.types(None,ctypes.POINTER(_cs.Display),_cs.GLXContext,_cs.GLXContext,_cs.c_ulong) +def glXCopyContext(dpy,src,dst,mask):pass +@_f +@_p.types(_cs.GLXContext,ctypes.POINTER(_cs.Display),ctypes.POINTER(_cs.XVisualInfo),_cs.GLXContext,_cs.Bool) +def glXCreateContext(dpy,vis,shareList,direct):pass +@_f +@_p.types(_cs.GLXPixmap,ctypes.POINTER(_cs.Display),ctypes.POINTER(_cs.XVisualInfo),_cs.Pixmap) +def glXCreateGLXPixmap(dpy,visual,pixmap):pass +@_f +@_p.types(None,ctypes.POINTER(_cs.Display),_cs.GLXContext) +def glXDestroyContext(dpy,ctx):pass +@_f +@_p.types(None,ctypes.POINTER(_cs.Display),_cs.GLXPixmap) +def glXDestroyGLXPixmap(dpy,pixmap):pass +@_f +@_p.types(_cs.c_int,ctypes.POINTER(_cs.Display),ctypes.POINTER(_cs.XVisualInfo),_cs.c_int,ctypes.POINTER(_cs.c_int)) +def glXGetConfig(dpy,visual,attrib,value):pass +@_f +@_p.types(_cs.GLXContext,) +def glXGetCurrentContext():pass +@_f +@_p.types(_cs.GLXDrawable,) +def glXGetCurrentDrawable():pass +@_f +@_p.types(_cs.Bool,ctypes.POINTER(_cs.Display),_cs.GLXContext) +def glXIsDirect(dpy,ctx):pass +@_f +@_p.types(_cs.Bool,ctypes.POINTER(_cs.Display),_cs.GLXDrawable,_cs.GLXContext) +def glXMakeCurrent(dpy,drawable,ctx):pass +@_f +@_p.types(_cs.Bool,ctypes.POINTER(_cs.Display),ctypes.POINTER(_cs.c_int),ctypes.POINTER(_cs.c_int)) +def glXQueryExtension(dpy,errorb,event):pass +@_f +@_p.types(_cs.Bool,ctypes.POINTER(_cs.Display),ctypes.POINTER(_cs.c_int),ctypes.POINTER(_cs.c_int)) +def glXQueryVersion(dpy,maj,min):pass +@_f +@_p.types(None,ctypes.POINTER(_cs.Display),_cs.GLXDrawable) +def glXSwapBuffers(dpy,drawable):pass +@_f +@_p.types(None,_cs.Font,_cs.c_int,_cs.c_int,_cs.c_int) +def glXUseXFont(font,first,count,list):pass +@_f +@_p.types(None,) +def glXWaitGL():pass +@_f +@_p.types(None,) +def glXWaitX():pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/VERSION/GLX_1_1.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/VERSION/GLX_1_1.py new file mode 100644 index 00000000..cf9763ec --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/VERSION/GLX_1_1.py @@ -0,0 +1,25 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLX import _types as _cs +# End users want this... +from OpenGL.raw.GLX._types import * +from OpenGL.raw.GLX import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLX_VERSION_GLX_1_1' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLX,'GLX_VERSION_GLX_1_1',error_checker=_errors._error_checker) +GLX_EXTENSIONS=_C('GLX_EXTENSIONS',0x3) +GLX_VENDOR=_C('GLX_VENDOR',0x1) +GLX_VERSION=_C('GLX_VERSION',0x2) +@_f +@_p.types(ctypes.c_char_p,ctypes.POINTER(_cs.Display),_cs.c_int) +def glXGetClientString(dpy,name):pass +@_f +@_p.types(ctypes.c_char_p,ctypes.POINTER(_cs.Display),_cs.c_int) +def glXQueryExtensionsString(dpy,screen):pass +@_f +@_p.types(ctypes.c_char_p,ctypes.POINTER(_cs.Display),_cs.c_int,_cs.c_int) +def glXQueryServerString(dpy,screen,name):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/VERSION/GLX_1_2.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/VERSION/GLX_1_2.py new file mode 100644 index 00000000..82dafe91 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/VERSION/GLX_1_2.py @@ -0,0 +1,17 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLX import _types as _cs +# End users want this... +from OpenGL.raw.GLX._types import * +from OpenGL.raw.GLX import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLX_VERSION_GLX_1_2' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLX,'GLX_VERSION_GLX_1_2',error_checker=_errors._error_checker) + +@_f +@_p.types(ctypes.POINTER(_cs.Display),) +def glXGetCurrentDisplay():pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/VERSION/GLX_1_3.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/VERSION/GLX_1_3.py new file mode 100644 index 00000000..5bd16f79 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/VERSION/GLX_1_3.py @@ -0,0 +1,120 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLX import _types as _cs +# End users want this... +from OpenGL.raw.GLX._types import * +from OpenGL.raw.GLX import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLX_VERSION_GLX_1_3' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLX,'GLX_VERSION_GLX_1_3',error_checker=_errors._error_checker) +GLX_ACCUM_BUFFER_BIT=_C('GLX_ACCUM_BUFFER_BIT',0x00000080) +GLX_AUX_BUFFERS_BIT=_C('GLX_AUX_BUFFERS_BIT',0x00000010) +GLX_BACK_LEFT_BUFFER_BIT=_C('GLX_BACK_LEFT_BUFFER_BIT',0x00000004) +GLX_BACK_RIGHT_BUFFER_BIT=_C('GLX_BACK_RIGHT_BUFFER_BIT',0x00000008) +GLX_COLOR_INDEX_BIT=_C('GLX_COLOR_INDEX_BIT',0x00000002) +GLX_COLOR_INDEX_TYPE=_C('GLX_COLOR_INDEX_TYPE',0x8015) +GLX_CONFIG_CAVEAT=_C('GLX_CONFIG_CAVEAT',0x20) +GLX_DAMAGED=_C('GLX_DAMAGED',0x8020) +GLX_DEPTH_BUFFER_BIT=_C('GLX_DEPTH_BUFFER_BIT',0x00000020) +GLX_DIRECT_COLOR=_C('GLX_DIRECT_COLOR',0x8003) +GLX_DONT_CARE=_C('GLX_DONT_CARE',0xFFFFFFFF) +GLX_DRAWABLE_TYPE=_C('GLX_DRAWABLE_TYPE',0x8010) +GLX_EVENT_MASK=_C('GLX_EVENT_MASK',0x801F) +GLX_FBCONFIG_ID=_C('GLX_FBCONFIG_ID',0x8013) +GLX_FRONT_LEFT_BUFFER_BIT=_C('GLX_FRONT_LEFT_BUFFER_BIT',0x00000001) +GLX_FRONT_RIGHT_BUFFER_BIT=_C('GLX_FRONT_RIGHT_BUFFER_BIT',0x00000002) +GLX_GRAY_SCALE=_C('GLX_GRAY_SCALE',0x8006) +GLX_HEIGHT=_C('GLX_HEIGHT',0x801E) +GLX_LARGEST_PBUFFER=_C('GLX_LARGEST_PBUFFER',0x801C) +GLX_MAX_PBUFFER_HEIGHT=_C('GLX_MAX_PBUFFER_HEIGHT',0x8017) +GLX_MAX_PBUFFER_PIXELS=_C('GLX_MAX_PBUFFER_PIXELS',0x8018) +GLX_MAX_PBUFFER_WIDTH=_C('GLX_MAX_PBUFFER_WIDTH',0x8016) +GLX_NONE=_C('GLX_NONE',0x8000) +GLX_NON_CONFORMANT_CONFIG=_C('GLX_NON_CONFORMANT_CONFIG',0x800D) +GLX_PBUFFER=_C('GLX_PBUFFER',0x8023) +GLX_PBUFFER_BIT=_C('GLX_PBUFFER_BIT',0x00000004) +GLX_PBUFFER_CLOBBER_MASK=_C('GLX_PBUFFER_CLOBBER_MASK',0x08000000) +GLX_PBUFFER_HEIGHT=_C('GLX_PBUFFER_HEIGHT',0x8040) +GLX_PBUFFER_WIDTH=_C('GLX_PBUFFER_WIDTH',0x8041) +GLX_PIXMAP_BIT=_C('GLX_PIXMAP_BIT',0x00000002) +GLX_PRESERVED_CONTENTS=_C('GLX_PRESERVED_CONTENTS',0x801B) +GLX_PSEUDO_COLOR=_C('GLX_PSEUDO_COLOR',0x8004) +GLX_RENDER_TYPE=_C('GLX_RENDER_TYPE',0x8011) +GLX_RGBA_BIT=_C('GLX_RGBA_BIT',0x00000001) +GLX_RGBA_TYPE=_C('GLX_RGBA_TYPE',0x8014) +GLX_SAVED=_C('GLX_SAVED',0x8021) +GLX_SCREEN=_C('GLX_SCREEN',0x800C) +GLX_SLOW_CONFIG=_C('GLX_SLOW_CONFIG',0x8001) +GLX_STATIC_COLOR=_C('GLX_STATIC_COLOR',0x8005) +GLX_STATIC_GRAY=_C('GLX_STATIC_GRAY',0x8007) +GLX_STENCIL_BUFFER_BIT=_C('GLX_STENCIL_BUFFER_BIT',0x00000040) +GLX_TRANSPARENT_ALPHA_VALUE=_C('GLX_TRANSPARENT_ALPHA_VALUE',0x28) +GLX_TRANSPARENT_BLUE_VALUE=_C('GLX_TRANSPARENT_BLUE_VALUE',0x27) +GLX_TRANSPARENT_GREEN_VALUE=_C('GLX_TRANSPARENT_GREEN_VALUE',0x26) +GLX_TRANSPARENT_INDEX=_C('GLX_TRANSPARENT_INDEX',0x8009) +GLX_TRANSPARENT_INDEX_VALUE=_C('GLX_TRANSPARENT_INDEX_VALUE',0x24) +GLX_TRANSPARENT_RED_VALUE=_C('GLX_TRANSPARENT_RED_VALUE',0x25) +GLX_TRANSPARENT_RGB=_C('GLX_TRANSPARENT_RGB',0x8008) +GLX_TRANSPARENT_TYPE=_C('GLX_TRANSPARENT_TYPE',0x23) +GLX_TRUE_COLOR=_C('GLX_TRUE_COLOR',0x8002) +GLX_VISUAL_ID=_C('GLX_VISUAL_ID',0x800B) +GLX_WIDTH=_C('GLX_WIDTH',0x801D) +GLX_WINDOW=_C('GLX_WINDOW',0x8022) +GLX_WINDOW_BIT=_C('GLX_WINDOW_BIT',0x00000001) +GLX_X_RENDERABLE=_C('GLX_X_RENDERABLE',0x8012) +GLX_X_VISUAL_TYPE=_C('GLX_X_VISUAL_TYPE',0x22) +@_f +@_p.types(ctypes.POINTER(_cs.GLXFBConfig),ctypes.POINTER(_cs.Display),_cs.c_int,ctypes.POINTER(_cs.c_int),ctypes.POINTER(_cs.c_int)) +def glXChooseFBConfig(dpy,screen,attrib_list,nelements):pass +@_f +@_p.types(_cs.GLXContext,ctypes.POINTER(_cs.Display),_cs.GLXFBConfig,_cs.c_int,_cs.GLXContext,_cs.Bool) +def glXCreateNewContext(dpy,config,render_type,share_list,direct):pass +@_f +@_p.types(_cs.GLXPbuffer,ctypes.POINTER(_cs.Display),_cs.GLXFBConfig,ctypes.POINTER(_cs.c_int)) +def glXCreatePbuffer(dpy,config,attrib_list):pass +@_f +@_p.types(_cs.GLXPixmap,ctypes.POINTER(_cs.Display),_cs.GLXFBConfig,_cs.Pixmap,ctypes.POINTER(_cs.c_int)) +def glXCreatePixmap(dpy,config,pixmap,attrib_list):pass +@_f +@_p.types(_cs.GLXWindow,ctypes.POINTER(_cs.Display),_cs.GLXFBConfig,_cs.Window,ctypes.POINTER(_cs.c_int)) +def glXCreateWindow(dpy,config,win,attrib_list):pass +@_f +@_p.types(None,ctypes.POINTER(_cs.Display),_cs.GLXPbuffer) +def glXDestroyPbuffer(dpy,pbuf):pass +@_f +@_p.types(None,ctypes.POINTER(_cs.Display),_cs.GLXPixmap) +def glXDestroyPixmap(dpy,pixmap):pass +@_f +@_p.types(None,ctypes.POINTER(_cs.Display),_cs.GLXWindow) +def glXDestroyWindow(dpy,win):pass +@_f +@_p.types(_cs.GLXDrawable,) +def glXGetCurrentReadDrawable():pass +@_f +@_p.types(_cs.c_int,ctypes.POINTER(_cs.Display),_cs.GLXFBConfig,_cs.c_int,ctypes.POINTER(_cs.c_int)) +def glXGetFBConfigAttrib(dpy,config,attribute,value):pass +@_f +@_p.types(ctypes.POINTER(_cs.GLXFBConfig),ctypes.POINTER(_cs.Display),_cs.c_int,ctypes.POINTER(_cs.c_int)) +def glXGetFBConfigs(dpy,screen,nelements):pass +@_f +@_p.types(None,ctypes.POINTER(_cs.Display),_cs.GLXDrawable,ctypes.POINTER(_cs.c_ulong)) +def glXGetSelectedEvent(dpy,draw,event_mask):pass +@_f +@_p.types(ctypes.POINTER(_cs.XVisualInfo),ctypes.POINTER(_cs.Display),_cs.GLXFBConfig) +def glXGetVisualFromFBConfig(dpy,config):pass +@_f +@_p.types(_cs.Bool,ctypes.POINTER(_cs.Display),_cs.GLXDrawable,_cs.GLXDrawable,_cs.GLXContext) +def glXMakeContextCurrent(dpy,draw,read,ctx):pass +@_f +@_p.types(_cs.c_int,ctypes.POINTER(_cs.Display),_cs.GLXContext,_cs.c_int,ctypes.POINTER(_cs.c_int)) +def glXQueryContext(dpy,ctx,attribute,value):pass +@_f +@_p.types(None,ctypes.POINTER(_cs.Display),_cs.GLXDrawable,_cs.c_int,ctypes.POINTER(_cs.c_uint)) +def glXQueryDrawable(dpy,draw,attribute,value):pass +@_f +@_p.types(None,ctypes.POINTER(_cs.Display),_cs.GLXDrawable,_cs.c_ulong) +def glXSelectEvent(dpy,draw,event_mask):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/VERSION/GLX_1_4.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/VERSION/GLX_1_4.py new file mode 100644 index 00000000..4a9052dd --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/VERSION/GLX_1_4.py @@ -0,0 +1,18 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.GLX import _types as _cs +# End users want this... +from OpenGL.raw.GLX._types import * +from OpenGL.raw.GLX import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'GLX_VERSION_GLX_1_4' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.GLX,'GLX_VERSION_GLX_1_4',error_checker=_errors._error_checker) +GLX_SAMPLES=_C('GLX_SAMPLES',100001) +GLX_SAMPLE_BUFFERS=_C('GLX_SAMPLE_BUFFERS',100000) +@_f +@_p.types(_cs.__GLXextFuncPtr,arrays.GLubyteArray) +def glXGetProcAddress(procName):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/VERSION/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/VERSION/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/VERSION/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/VERSION/__pycache__/GLX_1_0.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/VERSION/__pycache__/GLX_1_0.cpython-312.pyc new file mode 100644 index 00000000..73256205 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/VERSION/__pycache__/GLX_1_0.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/VERSION/__pycache__/GLX_1_1.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/VERSION/__pycache__/GLX_1_1.cpython-312.pyc new file mode 100644 index 00000000..c8e801a2 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/VERSION/__pycache__/GLX_1_1.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/VERSION/__pycache__/GLX_1_2.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/VERSION/__pycache__/GLX_1_2.cpython-312.pyc new file mode 100644 index 00000000..3fb2819b Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/VERSION/__pycache__/GLX_1_2.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/VERSION/__pycache__/GLX_1_3.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/VERSION/__pycache__/GLX_1_3.cpython-312.pyc new file mode 100644 index 00000000..4248b3dd Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/VERSION/__pycache__/GLX_1_3.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/VERSION/__pycache__/GLX_1_4.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/VERSION/__pycache__/GLX_1_4.cpython-312.pyc new file mode 100644 index 00000000..3adbe2e8 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/VERSION/__pycache__/GLX_1_4.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/VERSION/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/VERSION/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..370f4529 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/VERSION/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..517a714e Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/__pycache__/_errors.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/__pycache__/_errors.cpython-312.pyc new file mode 100644 index 00000000..91769810 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/__pycache__/_errors.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/__pycache__/_glgets.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/__pycache__/_glgets.cpython-312.pyc new file mode 100644 index 00000000..746defc5 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/__pycache__/_glgets.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/__pycache__/_types.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/__pycache__/_types.cpython-312.pyc new file mode 100644 index 00000000..5c8cfdcb Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/__pycache__/_types.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/_errors.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/_errors.py new file mode 100644 index 00000000..34b451f2 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/_errors.py @@ -0,0 +1,6 @@ +from OpenGL.platform import PLATFORM as _p +from OpenGL.error import _ErrorChecker +if _ErrorChecker: + _error_checker = _ErrorChecker( _p, None ) +else: + _error_checker = None diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/_glgets.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/_glgets.py new file mode 100644 index 00000000..76bcbaca --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/_glgets.py @@ -0,0 +1,8 @@ +"""glGet* auto-generation of output arrays (DO NOT EDIT, AUTOGENERATED)""" +try: + from OpenGL.raw.GL._lookupint import LookupInt as _L +except ImportError: + def _L(*args): + raise RuntimeError( "Need to define a lookupint for this api" ) +_glget_size_mapping = _m = {} + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/_types.py b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/_types.py new file mode 100644 index 00000000..ca5e364e --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/GLX/_types.py @@ -0,0 +1,261 @@ +from OpenGL import platform as _p, constant, extensions +from ctypes import * +from OpenGL.raw.GL._types import * +from OpenGL._bytes import as_8_bit +c_void = None +void = None +Bool = c_uint + +class _GLXQuerier( extensions.ExtensionQuerier ): + prefix = as_8_bit('GLX_') + assumed_version = [1,1] + version_prefix = as_8_bit('GLX_VERSION_GLX_') + def getDisplay( self ): + from OpenGL.raw.GLX import _types + from OpenGL.platform import ctypesloader + import ctypes, os + X11 = ctypesloader.loadLibrary( ctypes.cdll, 'X11' ) + XOpenDisplay = X11.XOpenDisplay + XOpenDisplay.restype = ctypes.POINTER(_types.Display) + return XOpenDisplay( os.environ.get( 'DISPLAY' )) + def getScreen( self, display ): + from OpenGL.platform import ctypesloader + from OpenGL.raw.GLX import _types + import ctypes, os + X11 = ctypesloader.loadLibrary( ctypes.cdll, 'X11' ) + XDefaultScreen = X11.XDefaultScreen + XDefaultScreen.argtypes = [ctypes.POINTER(_types.Display)] + return XDefaultScreen( display ) + + def pullVersion( self ): + from OpenGL.GLX import glXQueryVersion + import ctypes + if glXQueryVersion: + display = self.getDisplay() + major,minor = ctypes.c_int(),ctypes.c_int() + glXQueryVersion(display, major, minor) + return [major.value,minor.value] + else: + return [1,1] + def pullExtensions( self ): + if self.getVersion() >= [1,2]: + from OpenGL.GLX import glXQueryExtensionsString + display = self.getDisplay() + screen = self.getScreen( display ) + + if glXQueryExtensionsString: + return glXQueryExtensionsString( display,screen ).split() + return [] +GLXQuerier=_GLXQuerier() + + +class struct___GLXcontextRec(Structure): + __slots__ = [ + ] +struct___GLXcontextRec._fields_ = [ + ('_opaque_struct', c_int) +] + +class struct___GLXcontextRec(Structure): + __slots__ = [ + ] +struct___GLXcontextRec._fields_ = [ + ('_opaque_struct', c_int) +] + +GLXContext = POINTER(struct___GLXcontextRec) # /usr/include/GL/glx.h:178 +XID = c_ulong # /usr/include/X11/X.h:66 +GLXPixmap = XID # /usr/include/GL/glx.h:179 +GLXDrawable = XID # /usr/include/GL/glx.h:180 +class struct___GLXFBConfigRec(Structure): + __slots__ = [ + ] +struct___GLXFBConfigRec._fields_ = [ + ('_opaque_struct', c_int) +] + +class struct___GLXFBConfigRec(Structure): + __slots__ = [ + ] +struct___GLXFBConfigRec._fields_ = [ + ('_opaque_struct', c_int) +] + +GLXFBConfig = POINTER(struct___GLXFBConfigRec) # /usr/include/GL/glx.h:182 +GLXFBConfigID = XID # /usr/include/GL/glx.h:183 +GLXContextID = XID # /usr/include/GL/glx.h:184 +GLXWindow = XID # /usr/include/GL/glx.h:185 +GLXPbuffer = XID # /usr/include/GL/glx.h:186 +GLXPbufferSGIX = XID +GLXVideoSourceSGIX = XID + +class struct_anon_103(Structure): + __slots__ = [ + 'visual', + 'visualid', + 'screen', + 'depth', + 'class', + 'red_mask', + 'green_mask', + 'blue_mask', + 'colormap_size', + 'bits_per_rgb', + ] +class struct_anon_18(Structure): + __slots__ = [ + 'ext_data', + 'visualid', + 'class', + 'red_mask', + 'green_mask', + 'blue_mask', + 'bits_per_rgb', + 'map_entries', + ] +class struct__XExtData(Structure): + __slots__ = [ + 'number', + 'next', + 'free_private', + 'private_data', + ] +XPointer = c_char_p # /usr/include/X11/Xlib.h:84 +struct__XExtData._fields_ = [ + ('number', c_int), + ('next', POINTER(struct__XExtData)), + ('free_private', POINTER(CFUNCTYPE(c_int, POINTER(struct__XExtData)))), + ('private_data', XPointer), +] + +XExtData = struct__XExtData # /usr/include/X11/Xlib.h:163 +VisualID = c_ulong # /usr/include/X11/X.h:76 +struct_anon_18._fields_ = [ + ('ext_data', POINTER(XExtData)), + ('visualid', VisualID), + ('class', c_int), + ('red_mask', c_ulong), + ('green_mask', c_ulong), + ('blue_mask', c_ulong), + ('bits_per_rgb', c_int), + ('map_entries', c_int), +] + +Visual = struct_anon_18 # /usr/include/X11/Xlib.h:246 +struct_anon_103._fields_ = [ + ('visual', POINTER(Visual)), + ('visualid', VisualID), + ('screen', c_int), + ('depth', c_int), + ('class', c_int), + ('red_mask', c_ulong), + ('green_mask', c_ulong), + ('blue_mask', c_ulong), + ('colormap_size', c_int), + ('bits_per_rgb', c_int), +] + +XVisualInfo = struct_anon_103 # /usr/include/X11/Xutil.h:294 +class struct__XDisplay(Structure): + __slots__ = [ + ] +struct__XDisplay._fields_ = [ + ('_opaque_struct', c_int) +] + +class struct__XDisplay(Structure): + __slots__ = [ + ] +struct__XDisplay._fields_ = [ + ('_opaque_struct', c_int) +] + +Display = struct__XDisplay # /usr/include/X11/Xlib.h:495 + +Pixmap = XID # /usr/include/X11/X.h:102 +Font = XID # /usr/include/X11/X.h:100 +Window = XID # /usr/include/X11/X.h:96 +GLX_ARB_get_proc_address = constant.Constant( 'GLX_ARB_get_proc_address', 1 ) +__GLXextFuncPtr = CFUNCTYPE(None) # /usr/include/GL/glx.h:330 + +# EXT_texture_from_pixmap (/usr/include/GL/glx.h:436) +class struct_anon_111(Structure): + __slots__ = [ + 'event_type', + 'draw_type', + 'serial', + 'send_event', + 'display', + 'drawable', + 'buffer_mask', + 'aux_buffer', + 'x', + 'y', + 'width', + 'height', + 'count', + ] +struct_anon_111._fields_ = [ + ('event_type', c_int), + ('draw_type', c_int), + ('serial', c_ulong), + ('send_event', c_int), + ('display', POINTER(Display)), + ('drawable', GLXDrawable), + ('buffer_mask', c_uint), + ('aux_buffer', c_uint), + ('x', c_int), + ('y', c_int), + ('width', c_int), + ('height', c_int), + ('count', c_int), +] + +GLXPbufferClobberEvent = struct_anon_111 # /usr/include/GL/glx.h:502 +class struct_anon_112(Structure): + __slots__ = [ + 'type', + 'serial', + 'send_event', + 'display', + 'drawable', + 'event_type', + 'ust', + 'msc', + 'sbc', + ] +struct_anon_112._fields_ = [ + ('type', c_int), + ('serial', c_ulong), + ('send_event', c_int), + ('display', POINTER(Display)), + ('drawable', GLXDrawable), + ('event_type', c_int), + ('ust', c_int64), + ('msc', c_int64), + ('sbc', c_int64), +] + +GLXBufferSwapComplete = struct_anon_112 # /usr/include/GL/glx.h:514 +class struct___GLXEvent(Union): + __slots__ = [ + 'glxpbufferclobber', + 'glxbufferswapcomplete', + 'pad', + ] +struct___GLXEvent._fields_ = [ + ('glxpbufferclobber', GLXPbufferClobberEvent), + ('glxbufferswapcomplete', GLXBufferSwapComplete), + ('pad', c_long * 24), +] + +GLXEvent = struct___GLXEvent # /usr/include/GL/glx.h:520 + +class GLXHyperpipeConfigSGIX( Structure ): + _fields_ = [ + ('pipeName', c_char * 80), + ('channel',c_int), + ('participationType',c_uint), + ('timeSlice',c_int), + ] + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/AMD/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/AMD/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/AMD/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/AMD/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/AMD/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..09fbbf4c Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/AMD/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/AMD/__pycache__/gpu_association.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/AMD/__pycache__/gpu_association.cpython-312.pyc new file mode 100644 index 00000000..c6a94e52 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/AMD/__pycache__/gpu_association.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/AMD/gpu_association.py b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/AMD/gpu_association.py new file mode 100644 index 00000000..f00a9810 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/AMD/gpu_association.py @@ -0,0 +1,50 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.WGL import _types as _cs +# End users want this... +from OpenGL.raw.WGL._types import * +from OpenGL.raw.WGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'WGL_AMD_gpu_association' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.WGL,'WGL_AMD_gpu_association',error_checker=_errors._error_checker) +WGL_GPU_CLOCK_AMD=_C('WGL_GPU_CLOCK_AMD',0x21A4) +WGL_GPU_FASTEST_TARGET_GPUS_AMD=_C('WGL_GPU_FASTEST_TARGET_GPUS_AMD',0x21A2) +WGL_GPU_NUM_PIPES_AMD=_C('WGL_GPU_NUM_PIPES_AMD',0x21A5) +WGL_GPU_NUM_RB_AMD=_C('WGL_GPU_NUM_RB_AMD',0x21A7) +WGL_GPU_NUM_SIMD_AMD=_C('WGL_GPU_NUM_SIMD_AMD',0x21A6) +WGL_GPU_NUM_SPI_AMD=_C('WGL_GPU_NUM_SPI_AMD',0x21A8) +WGL_GPU_OPENGL_VERSION_STRING_AMD=_C('WGL_GPU_OPENGL_VERSION_STRING_AMD',0x1F02) +WGL_GPU_RAM_AMD=_C('WGL_GPU_RAM_AMD',0x21A3) +WGL_GPU_RENDERER_STRING_AMD=_C('WGL_GPU_RENDERER_STRING_AMD',0x1F01) +WGL_GPU_VENDOR_AMD=_C('WGL_GPU_VENDOR_AMD',0x1F00) +@_f +@_p.types(_cs.VOID,_cs.HGLRC,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLbitfield,_cs.GLenum) +def wglBlitContextFramebufferAMD(dstCtx,srcX0,srcY0,srcX1,srcY1,dstX0,dstY0,dstX1,dstY1,mask,filter):pass +@_f +@_p.types(_cs.HGLRC,_cs.UINT) +def wglCreateAssociatedContextAMD(id):pass +@_f +@_p.types(_cs.HGLRC,_cs.UINT,_cs.HGLRC,ctypes.POINTER(_cs.c_int)) +def wglCreateAssociatedContextAttribsAMD(id,hShareContext,attribList):pass +@_f +@_p.types(_cs.BOOL,_cs.HGLRC) +def wglDeleteAssociatedContextAMD(hglrc):pass +@_f +@_p.types(_cs.UINT,_cs.HGLRC) +def wglGetContextGPUIDAMD(hglrc):pass +@_f +@_p.types(_cs.HGLRC,) +def wglGetCurrentAssociatedContextAMD():pass +@_f +@_p.types(_cs.UINT,_cs.UINT,ctypes.POINTER(_cs.UINT)) +def wglGetGPUIDsAMD(maxCount,ids):pass +@_f +@_p.types(_cs.INT,_cs.UINT,_cs.INT,_cs.GLenum,_cs.UINT,ctypes.c_void_p) +def wglGetGPUInfoAMD(id,property,dataType,size,data):pass +@_f +@_p.types(_cs.BOOL,_cs.HGLRC) +def wglMakeAssociatedContextCurrentAMD(hglrc):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/ARB/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/ARB/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/ARB/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/ARB/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/ARB/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..48db0e74 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/ARB/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/ARB/__pycache__/buffer_region.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/ARB/__pycache__/buffer_region.cpython-312.pyc new file mode 100644 index 00000000..adfdf60a Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/ARB/__pycache__/buffer_region.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/ARB/__pycache__/context_flush_control.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/ARB/__pycache__/context_flush_control.cpython-312.pyc new file mode 100644 index 00000000..0bf5e94b Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/ARB/__pycache__/context_flush_control.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/ARB/__pycache__/create_context.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/ARB/__pycache__/create_context.cpython-312.pyc new file mode 100644 index 00000000..0d8e835d Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/ARB/__pycache__/create_context.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/ARB/__pycache__/create_context_no_error.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/ARB/__pycache__/create_context_no_error.cpython-312.pyc new file mode 100644 index 00000000..ef82d2dc Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/ARB/__pycache__/create_context_no_error.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/ARB/__pycache__/create_context_profile.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/ARB/__pycache__/create_context_profile.cpython-312.pyc new file mode 100644 index 00000000..eb5c1921 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/ARB/__pycache__/create_context_profile.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/ARB/__pycache__/create_context_robustness.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/ARB/__pycache__/create_context_robustness.cpython-312.pyc new file mode 100644 index 00000000..f5043c39 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/ARB/__pycache__/create_context_robustness.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/ARB/__pycache__/extensions_string.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/ARB/__pycache__/extensions_string.cpython-312.pyc new file mode 100644 index 00000000..6cb3da37 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/ARB/__pycache__/extensions_string.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/ARB/__pycache__/framebuffer_sRGB.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/ARB/__pycache__/framebuffer_sRGB.cpython-312.pyc new file mode 100644 index 00000000..a68c39aa Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/ARB/__pycache__/framebuffer_sRGB.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/ARB/__pycache__/make_current_read.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/ARB/__pycache__/make_current_read.cpython-312.pyc new file mode 100644 index 00000000..8417abf4 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/ARB/__pycache__/make_current_read.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/ARB/__pycache__/multisample.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/ARB/__pycache__/multisample.cpython-312.pyc new file mode 100644 index 00000000..a573b60c Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/ARB/__pycache__/multisample.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/ARB/__pycache__/pbuffer.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/ARB/__pycache__/pbuffer.cpython-312.pyc new file mode 100644 index 00000000..153866f7 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/ARB/__pycache__/pbuffer.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/ARB/__pycache__/pixel_format.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/ARB/__pycache__/pixel_format.cpython-312.pyc new file mode 100644 index 00000000..19d01280 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/ARB/__pycache__/pixel_format.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/ARB/__pycache__/pixel_format_float.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/ARB/__pycache__/pixel_format_float.cpython-312.pyc new file mode 100644 index 00000000..d7a3382a Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/ARB/__pycache__/pixel_format_float.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/ARB/__pycache__/render_texture.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/ARB/__pycache__/render_texture.cpython-312.pyc new file mode 100644 index 00000000..ffb913e0 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/ARB/__pycache__/render_texture.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/ARB/__pycache__/robustness_application_isolation.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/ARB/__pycache__/robustness_application_isolation.cpython-312.pyc new file mode 100644 index 00000000..1b08618c Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/ARB/__pycache__/robustness_application_isolation.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/ARB/__pycache__/robustness_share_group_isolation.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/ARB/__pycache__/robustness_share_group_isolation.cpython-312.pyc new file mode 100644 index 00000000..a6a215e6 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/ARB/__pycache__/robustness_share_group_isolation.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/ARB/buffer_region.py b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/ARB/buffer_region.py new file mode 100644 index 00000000..9d231474 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/ARB/buffer_region.py @@ -0,0 +1,29 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.WGL import _types as _cs +# End users want this... +from OpenGL.raw.WGL._types import * +from OpenGL.raw.WGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'WGL_ARB_buffer_region' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.WGL,'WGL_ARB_buffer_region',error_checker=_errors._error_checker) +WGL_BACK_COLOR_BUFFER_BIT_ARB=_C('WGL_BACK_COLOR_BUFFER_BIT_ARB',0x00000002) +WGL_DEPTH_BUFFER_BIT_ARB=_C('WGL_DEPTH_BUFFER_BIT_ARB',0x00000004) +WGL_FRONT_COLOR_BUFFER_BIT_ARB=_C('WGL_FRONT_COLOR_BUFFER_BIT_ARB',0x00000001) +WGL_STENCIL_BUFFER_BIT_ARB=_C('WGL_STENCIL_BUFFER_BIT_ARB',0x00000008) +@_f +@_p.types(_cs.HANDLE,_cs.HDC,_cs.c_int,_cs.UINT) +def wglCreateBufferRegionARB(hDC,iLayerPlane,uType):pass +@_f +@_p.types(_cs.VOID,_cs.HANDLE) +def wglDeleteBufferRegionARB(hRegion):pass +@_f +@_p.types(_cs.BOOL,_cs.HANDLE,_cs.c_int,_cs.c_int,_cs.c_int,_cs.c_int,_cs.c_int,_cs.c_int) +def wglRestoreBufferRegionARB(hRegion,x,y,width,height,xSrc,ySrc):pass +@_f +@_p.types(_cs.BOOL,_cs.HANDLE,_cs.c_int,_cs.c_int,_cs.c_int,_cs.c_int) +def wglSaveBufferRegionARB(hRegion,x,y,width,height):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/ARB/context_flush_control.py b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/ARB/context_flush_control.py new file mode 100644 index 00000000..fab1fc9e --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/ARB/context_flush_control.py @@ -0,0 +1,17 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.WGL import _types as _cs +# End users want this... +from OpenGL.raw.WGL._types import * +from OpenGL.raw.WGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'WGL_ARB_context_flush_control' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.WGL,'WGL_ARB_context_flush_control',error_checker=_errors._error_checker) +WGL_CONTEXT_RELEASE_BEHAVIOR_ARB=_C('WGL_CONTEXT_RELEASE_BEHAVIOR_ARB',0x2097) +WGL_CONTEXT_RELEASE_BEHAVIOR_FLUSH_ARB=_C('WGL_CONTEXT_RELEASE_BEHAVIOR_FLUSH_ARB',0x2098) +WGL_CONTEXT_RELEASE_BEHAVIOR_NONE_ARB=_C('WGL_CONTEXT_RELEASE_BEHAVIOR_NONE_ARB',0) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/ARB/create_context.py b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/ARB/create_context.py new file mode 100644 index 00000000..8780a9ee --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/ARB/create_context.py @@ -0,0 +1,23 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.WGL import _types as _cs +# End users want this... +from OpenGL.raw.WGL._types import * +from OpenGL.raw.WGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'WGL_ARB_create_context' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.WGL,'WGL_ARB_create_context',error_checker=_errors._error_checker) +ERROR_INVALID_VERSION_ARB=_C('ERROR_INVALID_VERSION_ARB',0x2095) +WGL_CONTEXT_DEBUG_BIT_ARB=_C('WGL_CONTEXT_DEBUG_BIT_ARB',0x00000001) +WGL_CONTEXT_FLAGS_ARB=_C('WGL_CONTEXT_FLAGS_ARB',0x2094) +WGL_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB=_C('WGL_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB',0x00000002) +WGL_CONTEXT_LAYER_PLANE_ARB=_C('WGL_CONTEXT_LAYER_PLANE_ARB',0x2093) +WGL_CONTEXT_MAJOR_VERSION_ARB=_C('WGL_CONTEXT_MAJOR_VERSION_ARB',0x2091) +WGL_CONTEXT_MINOR_VERSION_ARB=_C('WGL_CONTEXT_MINOR_VERSION_ARB',0x2092) +@_f +@_p.types(_cs.HGLRC,_cs.HDC,_cs.HGLRC,ctypes.POINTER(_cs.c_int)) +def wglCreateContextAttribsARB(hDC,hShareContext,attribList):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/ARB/create_context_no_error.py b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/ARB/create_context_no_error.py new file mode 100644 index 00000000..2fe85147 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/ARB/create_context_no_error.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.WGL import _types as _cs +# End users want this... +from OpenGL.raw.WGL._types import * +from OpenGL.raw.WGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'WGL_ARB_create_context_no_error' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.WGL,'WGL_ARB_create_context_no_error',error_checker=_errors._error_checker) +WGL_CONTEXT_OPENGL_NO_ERROR_ARB=_C('WGL_CONTEXT_OPENGL_NO_ERROR_ARB',0x31B3) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/ARB/create_context_profile.py b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/ARB/create_context_profile.py new file mode 100644 index 00000000..82e97c74 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/ARB/create_context_profile.py @@ -0,0 +1,18 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.WGL import _types as _cs +# End users want this... +from OpenGL.raw.WGL._types import * +from OpenGL.raw.WGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'WGL_ARB_create_context_profile' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.WGL,'WGL_ARB_create_context_profile',error_checker=_errors._error_checker) +ERROR_INVALID_PROFILE_ARB=_C('ERROR_INVALID_PROFILE_ARB',0x2096) +WGL_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB=_C('WGL_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB',0x00000002) +WGL_CONTEXT_CORE_PROFILE_BIT_ARB=_C('WGL_CONTEXT_CORE_PROFILE_BIT_ARB',0x00000001) +WGL_CONTEXT_PROFILE_MASK_ARB=_C('WGL_CONTEXT_PROFILE_MASK_ARB',0x9126) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/ARB/create_context_robustness.py b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/ARB/create_context_robustness.py new file mode 100644 index 00000000..21377d98 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/ARB/create_context_robustness.py @@ -0,0 +1,18 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.WGL import _types as _cs +# End users want this... +from OpenGL.raw.WGL._types import * +from OpenGL.raw.WGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'WGL_ARB_create_context_robustness' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.WGL,'WGL_ARB_create_context_robustness',error_checker=_errors._error_checker) +WGL_CONTEXT_RESET_NOTIFICATION_STRATEGY_ARB=_C('WGL_CONTEXT_RESET_NOTIFICATION_STRATEGY_ARB',0x8256) +WGL_CONTEXT_ROBUST_ACCESS_BIT_ARB=_C('WGL_CONTEXT_ROBUST_ACCESS_BIT_ARB',0x00000004) +WGL_LOSE_CONTEXT_ON_RESET_ARB=_C('WGL_LOSE_CONTEXT_ON_RESET_ARB',0x8252) +WGL_NO_RESET_NOTIFICATION_ARB=_C('WGL_NO_RESET_NOTIFICATION_ARB',0x8261) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/ARB/extensions_string.py b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/ARB/extensions_string.py new file mode 100644 index 00000000..cdddce03 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/ARB/extensions_string.py @@ -0,0 +1,17 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.WGL import _types as _cs +# End users want this... +from OpenGL.raw.WGL._types import * +from OpenGL.raw.WGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'WGL_ARB_extensions_string' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.WGL,'WGL_ARB_extensions_string',error_checker=_errors._error_checker) + +@_f +@_p.types(ctypes.c_char_p,_cs.HDC) +def wglGetExtensionsStringARB(hdc):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/ARB/framebuffer_sRGB.py b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/ARB/framebuffer_sRGB.py new file mode 100644 index 00000000..8493ac5a --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/ARB/framebuffer_sRGB.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.WGL import _types as _cs +# End users want this... +from OpenGL.raw.WGL._types import * +from OpenGL.raw.WGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'WGL_ARB_framebuffer_sRGB' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.WGL,'WGL_ARB_framebuffer_sRGB',error_checker=_errors._error_checker) +WGL_FRAMEBUFFER_SRGB_CAPABLE_ARB=_C('WGL_FRAMEBUFFER_SRGB_CAPABLE_ARB',0x20A9) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/ARB/make_current_read.py b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/ARB/make_current_read.py new file mode 100644 index 00000000..dab249bb --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/ARB/make_current_read.py @@ -0,0 +1,21 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.WGL import _types as _cs +# End users want this... +from OpenGL.raw.WGL._types import * +from OpenGL.raw.WGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'WGL_ARB_make_current_read' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.WGL,'WGL_ARB_make_current_read',error_checker=_errors._error_checker) +ERROR_INCOMPATIBLE_DEVICE_CONTEXTS_ARB=_C('ERROR_INCOMPATIBLE_DEVICE_CONTEXTS_ARB',0x2054) +ERROR_INVALID_PIXEL_TYPE_ARB=_C('ERROR_INVALID_PIXEL_TYPE_ARB',0x2043) +@_f +@_p.types(_cs.HDC,) +def wglGetCurrentReadDCARB():pass +@_f +@_p.types(_cs.BOOL,_cs.HDC,_cs.HDC,_cs.HGLRC) +def wglMakeContextCurrentARB(hDrawDC,hReadDC,hglrc):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/ARB/multisample.py b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/ARB/multisample.py new file mode 100644 index 00000000..23f65430 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/ARB/multisample.py @@ -0,0 +1,16 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.WGL import _types as _cs +# End users want this... +from OpenGL.raw.WGL._types import * +from OpenGL.raw.WGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'WGL_ARB_multisample' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.WGL,'WGL_ARB_multisample',error_checker=_errors._error_checker) +WGL_SAMPLES_ARB=_C('WGL_SAMPLES_ARB',0x2042) +WGL_SAMPLE_BUFFERS_ARB=_C('WGL_SAMPLE_BUFFERS_ARB',0x2041) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/ARB/pbuffer.py b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/ARB/pbuffer.py new file mode 100644 index 00000000..4196edce --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/ARB/pbuffer.py @@ -0,0 +1,36 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.WGL import _types as _cs +# End users want this... +from OpenGL.raw.WGL._types import * +from OpenGL.raw.WGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'WGL_ARB_pbuffer' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.WGL,'WGL_ARB_pbuffer',error_checker=_errors._error_checker) +WGL_DRAW_TO_PBUFFER_ARB=_C('WGL_DRAW_TO_PBUFFER_ARB',0x202D) +WGL_MAX_PBUFFER_HEIGHT_ARB=_C('WGL_MAX_PBUFFER_HEIGHT_ARB',0x2030) +WGL_MAX_PBUFFER_PIXELS_ARB=_C('WGL_MAX_PBUFFER_PIXELS_ARB',0x202E) +WGL_MAX_PBUFFER_WIDTH_ARB=_C('WGL_MAX_PBUFFER_WIDTH_ARB',0x202F) +WGL_PBUFFER_HEIGHT_ARB=_C('WGL_PBUFFER_HEIGHT_ARB',0x2035) +WGL_PBUFFER_LARGEST_ARB=_C('WGL_PBUFFER_LARGEST_ARB',0x2033) +WGL_PBUFFER_LOST_ARB=_C('WGL_PBUFFER_LOST_ARB',0x2036) +WGL_PBUFFER_WIDTH_ARB=_C('WGL_PBUFFER_WIDTH_ARB',0x2034) +@_f +@_p.types(_cs.HPBUFFERARB,_cs.HDC,_cs.c_int,_cs.c_int,_cs.c_int,ctypes.POINTER(_cs.c_int)) +def wglCreatePbufferARB(hDC,iPixelFormat,iWidth,iHeight,piAttribList):pass +@_f +@_p.types(_cs.BOOL,_cs.HPBUFFERARB) +def wglDestroyPbufferARB(hPbuffer):pass +@_f +@_p.types(_cs.HDC,_cs.HPBUFFERARB) +def wglGetPbufferDCARB(hPbuffer):pass +@_f +@_p.types(_cs.BOOL,_cs.HPBUFFERARB,_cs.c_int,ctypes.POINTER(_cs.c_int)) +def wglQueryPbufferARB(hPbuffer,iAttribute,piValue):pass +@_f +@_p.types(_cs.c_int,_cs.HPBUFFERARB,_cs.HDC) +def wglReleasePbufferDCARB(hPbuffer,hDC):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/ARB/pixel_format.py b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/ARB/pixel_format.py new file mode 100644 index 00000000..6c372e98 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/ARB/pixel_format.py @@ -0,0 +1,71 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.WGL import _types as _cs +# End users want this... +from OpenGL.raw.WGL._types import * +from OpenGL.raw.WGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'WGL_ARB_pixel_format' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.WGL,'WGL_ARB_pixel_format',error_checker=_errors._error_checker) +WGL_ACCELERATION_ARB=_C('WGL_ACCELERATION_ARB',0x2003) +WGL_ACCUM_ALPHA_BITS_ARB=_C('WGL_ACCUM_ALPHA_BITS_ARB',0x2021) +WGL_ACCUM_BITS_ARB=_C('WGL_ACCUM_BITS_ARB',0x201D) +WGL_ACCUM_BLUE_BITS_ARB=_C('WGL_ACCUM_BLUE_BITS_ARB',0x2020) +WGL_ACCUM_GREEN_BITS_ARB=_C('WGL_ACCUM_GREEN_BITS_ARB',0x201F) +WGL_ACCUM_RED_BITS_ARB=_C('WGL_ACCUM_RED_BITS_ARB',0x201E) +WGL_ALPHA_BITS_ARB=_C('WGL_ALPHA_BITS_ARB',0x201B) +WGL_ALPHA_SHIFT_ARB=_C('WGL_ALPHA_SHIFT_ARB',0x201C) +WGL_AUX_BUFFERS_ARB=_C('WGL_AUX_BUFFERS_ARB',0x2024) +WGL_BLUE_BITS_ARB=_C('WGL_BLUE_BITS_ARB',0x2019) +WGL_BLUE_SHIFT_ARB=_C('WGL_BLUE_SHIFT_ARB',0x201A) +WGL_COLOR_BITS_ARB=_C('WGL_COLOR_BITS_ARB',0x2014) +WGL_DEPTH_BITS_ARB=_C('WGL_DEPTH_BITS_ARB',0x2022) +WGL_DOUBLE_BUFFER_ARB=_C('WGL_DOUBLE_BUFFER_ARB',0x2011) +WGL_DRAW_TO_BITMAP_ARB=_C('WGL_DRAW_TO_BITMAP_ARB',0x2002) +WGL_DRAW_TO_WINDOW_ARB=_C('WGL_DRAW_TO_WINDOW_ARB',0x2001) +WGL_FULL_ACCELERATION_ARB=_C('WGL_FULL_ACCELERATION_ARB',0x2027) +WGL_GENERIC_ACCELERATION_ARB=_C('WGL_GENERIC_ACCELERATION_ARB',0x2026) +WGL_GREEN_BITS_ARB=_C('WGL_GREEN_BITS_ARB',0x2017) +WGL_GREEN_SHIFT_ARB=_C('WGL_GREEN_SHIFT_ARB',0x2018) +WGL_NEED_PALETTE_ARB=_C('WGL_NEED_PALETTE_ARB',0x2004) +WGL_NEED_SYSTEM_PALETTE_ARB=_C('WGL_NEED_SYSTEM_PALETTE_ARB',0x2005) +WGL_NO_ACCELERATION_ARB=_C('WGL_NO_ACCELERATION_ARB',0x2025) +WGL_NUMBER_OVERLAYS_ARB=_C('WGL_NUMBER_OVERLAYS_ARB',0x2008) +WGL_NUMBER_PIXEL_FORMATS_ARB=_C('WGL_NUMBER_PIXEL_FORMATS_ARB',0x2000) +WGL_NUMBER_UNDERLAYS_ARB=_C('WGL_NUMBER_UNDERLAYS_ARB',0x2009) +WGL_PIXEL_TYPE_ARB=_C('WGL_PIXEL_TYPE_ARB',0x2013) +WGL_RED_BITS_ARB=_C('WGL_RED_BITS_ARB',0x2015) +WGL_RED_SHIFT_ARB=_C('WGL_RED_SHIFT_ARB',0x2016) +WGL_SHARE_ACCUM_ARB=_C('WGL_SHARE_ACCUM_ARB',0x200E) +WGL_SHARE_DEPTH_ARB=_C('WGL_SHARE_DEPTH_ARB',0x200C) +WGL_SHARE_STENCIL_ARB=_C('WGL_SHARE_STENCIL_ARB',0x200D) +WGL_STENCIL_BITS_ARB=_C('WGL_STENCIL_BITS_ARB',0x2023) +WGL_STEREO_ARB=_C('WGL_STEREO_ARB',0x2012) +WGL_SUPPORT_GDI_ARB=_C('WGL_SUPPORT_GDI_ARB',0x200F) +WGL_SUPPORT_OPENGL_ARB=_C('WGL_SUPPORT_OPENGL_ARB',0x2010) +WGL_SWAP_COPY_ARB=_C('WGL_SWAP_COPY_ARB',0x2029) +WGL_SWAP_EXCHANGE_ARB=_C('WGL_SWAP_EXCHANGE_ARB',0x2028) +WGL_SWAP_LAYER_BUFFERS_ARB=_C('WGL_SWAP_LAYER_BUFFERS_ARB',0x2006) +WGL_SWAP_METHOD_ARB=_C('WGL_SWAP_METHOD_ARB',0x2007) +WGL_SWAP_UNDEFINED_ARB=_C('WGL_SWAP_UNDEFINED_ARB',0x202A) +WGL_TRANSPARENT_ALPHA_VALUE_ARB=_C('WGL_TRANSPARENT_ALPHA_VALUE_ARB',0x203A) +WGL_TRANSPARENT_ARB=_C('WGL_TRANSPARENT_ARB',0x200A) +WGL_TRANSPARENT_BLUE_VALUE_ARB=_C('WGL_TRANSPARENT_BLUE_VALUE_ARB',0x2039) +WGL_TRANSPARENT_GREEN_VALUE_ARB=_C('WGL_TRANSPARENT_GREEN_VALUE_ARB',0x2038) +WGL_TRANSPARENT_INDEX_VALUE_ARB=_C('WGL_TRANSPARENT_INDEX_VALUE_ARB',0x203B) +WGL_TRANSPARENT_RED_VALUE_ARB=_C('WGL_TRANSPARENT_RED_VALUE_ARB',0x2037) +WGL_TYPE_COLORINDEX_ARB=_C('WGL_TYPE_COLORINDEX_ARB',0x202C) +WGL_TYPE_RGBA_ARB=_C('WGL_TYPE_RGBA_ARB',0x202B) +@_f +@_p.types(_cs.BOOL,_cs.HDC,ctypes.POINTER(_cs.c_int),ctypes.POINTER(_cs.FLOAT),_cs.UINT,ctypes.POINTER(_cs.c_int),ctypes.POINTER(_cs.UINT)) +def wglChoosePixelFormatARB(hdc,piAttribIList,pfAttribFList,nMaxFormats,piFormats,nNumFormats):pass +@_f +@_p.types(_cs.BOOL,_cs.HDC,_cs.c_int,_cs.c_int,_cs.UINT,ctypes.POINTER(_cs.c_int),ctypes.POINTER(_cs.FLOAT)) +def wglGetPixelFormatAttribfvARB(hdc,iPixelFormat,iLayerPlane,nAttributes,piAttributes,pfValues):pass +@_f +@_p.types(_cs.BOOL,_cs.HDC,_cs.c_int,_cs.c_int,_cs.UINT,ctypes.POINTER(_cs.c_int),ctypes.POINTER(_cs.c_int)) +def wglGetPixelFormatAttribivARB(hdc,iPixelFormat,iLayerPlane,nAttributes,piAttributes,piValues):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/ARB/pixel_format_float.py b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/ARB/pixel_format_float.py new file mode 100644 index 00000000..b203d9bc --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/ARB/pixel_format_float.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.WGL import _types as _cs +# End users want this... +from OpenGL.raw.WGL._types import * +from OpenGL.raw.WGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'WGL_ARB_pixel_format_float' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.WGL,'WGL_ARB_pixel_format_float',error_checker=_errors._error_checker) +WGL_TYPE_RGBA_FLOAT_ARB=_C('WGL_TYPE_RGBA_FLOAT_ARB',0x21A0) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/ARB/render_texture.py b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/ARB/render_texture.py new file mode 100644 index 00000000..cbe03f55 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/ARB/render_texture.py @@ -0,0 +1,55 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.WGL import _types as _cs +# End users want this... +from OpenGL.raw.WGL._types import * +from OpenGL.raw.WGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'WGL_ARB_render_texture' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.WGL,'WGL_ARB_render_texture',error_checker=_errors._error_checker) +WGL_AUX0_ARB=_C('WGL_AUX0_ARB',0x2087) +WGL_AUX1_ARB=_C('WGL_AUX1_ARB',0x2088) +WGL_AUX2_ARB=_C('WGL_AUX2_ARB',0x2089) +WGL_AUX3_ARB=_C('WGL_AUX3_ARB',0x208A) +WGL_AUX4_ARB=_C('WGL_AUX4_ARB',0x208B) +WGL_AUX5_ARB=_C('WGL_AUX5_ARB',0x208C) +WGL_AUX6_ARB=_C('WGL_AUX6_ARB',0x208D) +WGL_AUX7_ARB=_C('WGL_AUX7_ARB',0x208E) +WGL_AUX8_ARB=_C('WGL_AUX8_ARB',0x208F) +WGL_AUX9_ARB=_C('WGL_AUX9_ARB',0x2090) +WGL_BACK_LEFT_ARB=_C('WGL_BACK_LEFT_ARB',0x2085) +WGL_BACK_RIGHT_ARB=_C('WGL_BACK_RIGHT_ARB',0x2086) +WGL_BIND_TO_TEXTURE_RGBA_ARB=_C('WGL_BIND_TO_TEXTURE_RGBA_ARB',0x2071) +WGL_BIND_TO_TEXTURE_RGB_ARB=_C('WGL_BIND_TO_TEXTURE_RGB_ARB',0x2070) +WGL_CUBE_MAP_FACE_ARB=_C('WGL_CUBE_MAP_FACE_ARB',0x207C) +WGL_FRONT_LEFT_ARB=_C('WGL_FRONT_LEFT_ARB',0x2083) +WGL_FRONT_RIGHT_ARB=_C('WGL_FRONT_RIGHT_ARB',0x2084) +WGL_MIPMAP_LEVEL_ARB=_C('WGL_MIPMAP_LEVEL_ARB',0x207B) +WGL_MIPMAP_TEXTURE_ARB=_C('WGL_MIPMAP_TEXTURE_ARB',0x2074) +WGL_NO_TEXTURE_ARB=_C('WGL_NO_TEXTURE_ARB',0x2077) +WGL_TEXTURE_1D_ARB=_C('WGL_TEXTURE_1D_ARB',0x2079) +WGL_TEXTURE_2D_ARB=_C('WGL_TEXTURE_2D_ARB',0x207A) +WGL_TEXTURE_CUBE_MAP_ARB=_C('WGL_TEXTURE_CUBE_MAP_ARB',0x2078) +WGL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB=_C('WGL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB',0x207E) +WGL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB=_C('WGL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB',0x2080) +WGL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB=_C('WGL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB',0x2082) +WGL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB=_C('WGL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB',0x207D) +WGL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB=_C('WGL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB',0x207F) +WGL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB=_C('WGL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB',0x2081) +WGL_TEXTURE_FORMAT_ARB=_C('WGL_TEXTURE_FORMAT_ARB',0x2072) +WGL_TEXTURE_RGBA_ARB=_C('WGL_TEXTURE_RGBA_ARB',0x2076) +WGL_TEXTURE_RGB_ARB=_C('WGL_TEXTURE_RGB_ARB',0x2075) +WGL_TEXTURE_TARGET_ARB=_C('WGL_TEXTURE_TARGET_ARB',0x2073) +@_f +@_p.types(_cs.BOOL,_cs.HPBUFFERARB,_cs.c_int) +def wglBindTexImageARB(hPbuffer,iBuffer):pass +@_f +@_p.types(_cs.BOOL,_cs.HPBUFFERARB,_cs.c_int) +def wglReleaseTexImageARB(hPbuffer,iBuffer):pass +@_f +@_p.types(_cs.BOOL,_cs.HPBUFFERARB,ctypes.POINTER(_cs.c_int)) +def wglSetPbufferAttribARB(hPbuffer,piAttribList):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/ARB/robustness_application_isolation.py b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/ARB/robustness_application_isolation.py new file mode 100644 index 00000000..9bfb6722 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/ARB/robustness_application_isolation.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.WGL import _types as _cs +# End users want this... +from OpenGL.raw.WGL._types import * +from OpenGL.raw.WGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'WGL_ARB_robustness_application_isolation' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.WGL,'WGL_ARB_robustness_application_isolation',error_checker=_errors._error_checker) +WGL_CONTEXT_RESET_ISOLATION_BIT_ARB=_C('WGL_CONTEXT_RESET_ISOLATION_BIT_ARB',0x00000008) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/ARB/robustness_share_group_isolation.py b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/ARB/robustness_share_group_isolation.py new file mode 100644 index 00000000..9c9391e9 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/ARB/robustness_share_group_isolation.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.WGL import _types as _cs +# End users want this... +from OpenGL.raw.WGL._types import * +from OpenGL.raw.WGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'WGL_ARB_robustness_share_group_isolation' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.WGL,'WGL_ARB_robustness_share_group_isolation',error_checker=_errors._error_checker) +WGL_CONTEXT_RESET_ISOLATION_BIT_ARB=_C('WGL_CONTEXT_RESET_ISOLATION_BIT_ARB',0x00000008) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/ATI/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/ATI/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/ATI/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/ATI/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/ATI/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..f7c5920b Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/ATI/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/ATI/__pycache__/pixel_format_float.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/ATI/__pycache__/pixel_format_float.cpython-312.pyc new file mode 100644 index 00000000..8dfb59fe Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/ATI/__pycache__/pixel_format_float.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/ATI/__pycache__/render_texture_rectangle.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/ATI/__pycache__/render_texture_rectangle.cpython-312.pyc new file mode 100644 index 00000000..366f2c99 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/ATI/__pycache__/render_texture_rectangle.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/ATI/pixel_format_float.py b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/ATI/pixel_format_float.py new file mode 100644 index 00000000..2b44e61d --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/ATI/pixel_format_float.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.WGL import _types as _cs +# End users want this... +from OpenGL.raw.WGL._types import * +from OpenGL.raw.WGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'WGL_ATI_pixel_format_float' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.WGL,'WGL_ATI_pixel_format_float',error_checker=_errors._error_checker) +WGL_TYPE_RGBA_FLOAT_ATI=_C('WGL_TYPE_RGBA_FLOAT_ATI',0x21A0) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/ATI/render_texture_rectangle.py b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/ATI/render_texture_rectangle.py new file mode 100644 index 00000000..9e9b083f --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/ATI/render_texture_rectangle.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.WGL import _types as _cs +# End users want this... +from OpenGL.raw.WGL._types import * +from OpenGL.raw.WGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'WGL_ATI_render_texture_rectangle' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.WGL,'WGL_ATI_render_texture_rectangle',error_checker=_errors._error_checker) +WGL_TEXTURE_RECTANGLE_ATI=_C('WGL_TEXTURE_RECTANGLE_ATI',0x21A5) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/DFX/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/DFX/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/DFX/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/DFX/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/DFX/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..63e18659 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/DFX/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/DFX/__pycache__/multisample.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/DFX/__pycache__/multisample.cpython-312.pyc new file mode 100644 index 00000000..b10bbe5f Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/DFX/__pycache__/multisample.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/DFX/multisample.py b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/DFX/multisample.py new file mode 100644 index 00000000..78fcdd9b --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/DFX/multisample.py @@ -0,0 +1,16 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.WGL import _types as _cs +# End users want this... +from OpenGL.raw.WGL._types import * +from OpenGL.raw.WGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'WGL_DFX_multisample' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.WGL,'WGL_DFX_multisample',error_checker=_errors._error_checker) +WGL_SAMPLES_3DFX=_C('WGL_SAMPLES_3DFX',0x2061) +WGL_SAMPLE_BUFFERS_3DFX=_C('WGL_SAMPLE_BUFFERS_3DFX',0x2060) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/DL/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/DL/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/DL/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/DL/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/DL/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..2358f87f Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/DL/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/DL/__pycache__/stereo_control.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/DL/__pycache__/stereo_control.cpython-312.pyc new file mode 100644 index 00000000..da617b52 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/DL/__pycache__/stereo_control.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/DL/stereo_control.py b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/DL/stereo_control.py new file mode 100644 index 00000000..a7119710 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/DL/stereo_control.py @@ -0,0 +1,20 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.WGL import _types as _cs +# End users want this... +from OpenGL.raw.WGL._types import * +from OpenGL.raw.WGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'WGL_DL_stereo_control' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.WGL,'WGL_DL_stereo_control',error_checker=_errors._error_checker) +WGL_STEREO_EMITTER_DISABLE_3DL=_C('WGL_STEREO_EMITTER_DISABLE_3DL',0x2056) +WGL_STEREO_EMITTER_ENABLE_3DL=_C('WGL_STEREO_EMITTER_ENABLE_3DL',0x2055) +WGL_STEREO_POLARITY_INVERT_3DL=_C('WGL_STEREO_POLARITY_INVERT_3DL',0x2058) +WGL_STEREO_POLARITY_NORMAL_3DL=_C('WGL_STEREO_POLARITY_NORMAL_3DL',0x2057) +@_f +@_p.types(_cs.BOOL,_cs.HDC,_cs.UINT) +def wglSetStereoEmitterState3DL(hDC,uState):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/EXT/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/EXT/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/EXT/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/EXT/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/EXT/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..6cd20c04 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/EXT/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/EXT/__pycache__/colorspace.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/EXT/__pycache__/colorspace.cpython-312.pyc new file mode 100644 index 00000000..b0f939f9 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/EXT/__pycache__/colorspace.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/EXT/__pycache__/create_context_es2_profile.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/EXT/__pycache__/create_context_es2_profile.cpython-312.pyc new file mode 100644 index 00000000..2e8f9f62 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/EXT/__pycache__/create_context_es2_profile.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/EXT/__pycache__/create_context_es_profile.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/EXT/__pycache__/create_context_es_profile.cpython-312.pyc new file mode 100644 index 00000000..0e5c049b Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/EXT/__pycache__/create_context_es_profile.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/EXT/__pycache__/depth_float.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/EXT/__pycache__/depth_float.cpython-312.pyc new file mode 100644 index 00000000..a44ecc94 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/EXT/__pycache__/depth_float.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/EXT/__pycache__/display_color_table.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/EXT/__pycache__/display_color_table.cpython-312.pyc new file mode 100644 index 00000000..47cf6810 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/EXT/__pycache__/display_color_table.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/EXT/__pycache__/extensions_string.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/EXT/__pycache__/extensions_string.cpython-312.pyc new file mode 100644 index 00000000..60752767 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/EXT/__pycache__/extensions_string.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/EXT/__pycache__/framebuffer_sRGB.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/EXT/__pycache__/framebuffer_sRGB.cpython-312.pyc new file mode 100644 index 00000000..447bb2d1 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/EXT/__pycache__/framebuffer_sRGB.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/EXT/__pycache__/make_current_read.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/EXT/__pycache__/make_current_read.cpython-312.pyc new file mode 100644 index 00000000..9c36a804 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/EXT/__pycache__/make_current_read.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/EXT/__pycache__/multisample.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/EXT/__pycache__/multisample.cpython-312.pyc new file mode 100644 index 00000000..cb744cfe Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/EXT/__pycache__/multisample.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/EXT/__pycache__/pbuffer.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/EXT/__pycache__/pbuffer.cpython-312.pyc new file mode 100644 index 00000000..ed1cc34c Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/EXT/__pycache__/pbuffer.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/EXT/__pycache__/pixel_format.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/EXT/__pycache__/pixel_format.cpython-312.pyc new file mode 100644 index 00000000..73c3ca00 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/EXT/__pycache__/pixel_format.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/EXT/__pycache__/pixel_format_packed_float.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/EXT/__pycache__/pixel_format_packed_float.cpython-312.pyc new file mode 100644 index 00000000..1822a2b6 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/EXT/__pycache__/pixel_format_packed_float.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/EXT/__pycache__/swap_control.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/EXT/__pycache__/swap_control.cpython-312.pyc new file mode 100644 index 00000000..cca8427b Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/EXT/__pycache__/swap_control.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/EXT/__pycache__/swap_control_tear.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/EXT/__pycache__/swap_control_tear.cpython-312.pyc new file mode 100644 index 00000000..427e8e58 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/EXT/__pycache__/swap_control_tear.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/EXT/colorspace.py b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/EXT/colorspace.py new file mode 100644 index 00000000..8b36cfd3 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/EXT/colorspace.py @@ -0,0 +1,17 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.WGL import _types as _cs +# End users want this... +from OpenGL.raw.WGL._types import * +from OpenGL.raw.WGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'WGL_EXT_colorspace' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.WGL,'WGL_EXT_colorspace',error_checker=_errors._error_checker) +WGL_COLORSPACE_EXT=_C('WGL_COLORSPACE_EXT',0x309D) +WGL_COLORSPACE_LINEAR_EXT=_C('WGL_COLORSPACE_LINEAR_EXT',0x308A) +WGL_COLORSPACE_SRGB_EXT=_C('WGL_COLORSPACE_SRGB_EXT',0x3089) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/EXT/create_context_es2_profile.py b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/EXT/create_context_es2_profile.py new file mode 100644 index 00000000..c61ecfdf --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/EXT/create_context_es2_profile.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.WGL import _types as _cs +# End users want this... +from OpenGL.raw.WGL._types import * +from OpenGL.raw.WGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'WGL_EXT_create_context_es2_profile' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.WGL,'WGL_EXT_create_context_es2_profile',error_checker=_errors._error_checker) +WGL_CONTEXT_ES2_PROFILE_BIT_EXT=_C('WGL_CONTEXT_ES2_PROFILE_BIT_EXT',0x00000004) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/EXT/create_context_es_profile.py b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/EXT/create_context_es_profile.py new file mode 100644 index 00000000..b397eca8 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/EXT/create_context_es_profile.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.WGL import _types as _cs +# End users want this... +from OpenGL.raw.WGL._types import * +from OpenGL.raw.WGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'WGL_EXT_create_context_es_profile' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.WGL,'WGL_EXT_create_context_es_profile',error_checker=_errors._error_checker) +WGL_CONTEXT_ES_PROFILE_BIT_EXT=_C('WGL_CONTEXT_ES_PROFILE_BIT_EXT',0x00000004) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/EXT/depth_float.py b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/EXT/depth_float.py new file mode 100644 index 00000000..d6d8696c --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/EXT/depth_float.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.WGL import _types as _cs +# End users want this... +from OpenGL.raw.WGL._types import * +from OpenGL.raw.WGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'WGL_EXT_depth_float' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.WGL,'WGL_EXT_depth_float',error_checker=_errors._error_checker) +WGL_DEPTH_FLOAT_EXT=_C('WGL_DEPTH_FLOAT_EXT',0x2040) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/EXT/display_color_table.py b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/EXT/display_color_table.py new file mode 100644 index 00000000..728d57a1 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/EXT/display_color_table.py @@ -0,0 +1,26 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.WGL import _types as _cs +# End users want this... +from OpenGL.raw.WGL._types import * +from OpenGL.raw.WGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'WGL_EXT_display_color_table' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.WGL,'WGL_EXT_display_color_table',error_checker=_errors._error_checker) + +@_f +@_p.types(_cs.GLboolean,_cs.GLushort) +def wglBindDisplayColorTableEXT(id):pass +@_f +@_p.types(_cs.GLboolean,_cs.GLushort) +def wglCreateDisplayColorTableEXT(id):pass +@_f +@_p.types(_cs.VOID,_cs.GLushort) +def wglDestroyDisplayColorTableEXT(id):pass +@_f +@_p.types(_cs.GLboolean,arrays.GLushortArray,_cs.GLuint) +def wglLoadDisplayColorTableEXT(table,length):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/EXT/extensions_string.py b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/EXT/extensions_string.py new file mode 100644 index 00000000..e1e066b0 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/EXT/extensions_string.py @@ -0,0 +1,17 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.WGL import _types as _cs +# End users want this... +from OpenGL.raw.WGL._types import * +from OpenGL.raw.WGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'WGL_EXT_extensions_string' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.WGL,'WGL_EXT_extensions_string',error_checker=_errors._error_checker) + +@_f +@_p.types(ctypes.c_char_p,) +def wglGetExtensionsStringEXT():pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/EXT/framebuffer_sRGB.py b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/EXT/framebuffer_sRGB.py new file mode 100644 index 00000000..63334049 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/EXT/framebuffer_sRGB.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.WGL import _types as _cs +# End users want this... +from OpenGL.raw.WGL._types import * +from OpenGL.raw.WGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'WGL_EXT_framebuffer_sRGB' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.WGL,'WGL_EXT_framebuffer_sRGB',error_checker=_errors._error_checker) +WGL_FRAMEBUFFER_SRGB_CAPABLE_EXT=_C('WGL_FRAMEBUFFER_SRGB_CAPABLE_EXT',0x20A9) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/EXT/make_current_read.py b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/EXT/make_current_read.py new file mode 100644 index 00000000..c6a65a20 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/EXT/make_current_read.py @@ -0,0 +1,20 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.WGL import _types as _cs +# End users want this... +from OpenGL.raw.WGL._types import * +from OpenGL.raw.WGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'WGL_EXT_make_current_read' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.WGL,'WGL_EXT_make_current_read',error_checker=_errors._error_checker) +ERROR_INVALID_PIXEL_TYPE_EXT=_C('ERROR_INVALID_PIXEL_TYPE_EXT',0x2043) +@_f +@_p.types(_cs.HDC,) +def wglGetCurrentReadDCEXT():pass +@_f +@_p.types(_cs.BOOL,_cs.HDC,_cs.HDC,_cs.HGLRC) +def wglMakeContextCurrentEXT(hDrawDC,hReadDC,hglrc):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/EXT/multisample.py b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/EXT/multisample.py new file mode 100644 index 00000000..b558be0f --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/EXT/multisample.py @@ -0,0 +1,16 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.WGL import _types as _cs +# End users want this... +from OpenGL.raw.WGL._types import * +from OpenGL.raw.WGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'WGL_EXT_multisample' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.WGL,'WGL_EXT_multisample',error_checker=_errors._error_checker) +WGL_SAMPLES_EXT=_C('WGL_SAMPLES_EXT',0x2042) +WGL_SAMPLE_BUFFERS_EXT=_C('WGL_SAMPLE_BUFFERS_EXT',0x2041) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/EXT/pbuffer.py b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/EXT/pbuffer.py new file mode 100644 index 00000000..45519568 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/EXT/pbuffer.py @@ -0,0 +1,37 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.WGL import _types as _cs +# End users want this... +from OpenGL.raw.WGL._types import * +from OpenGL.raw.WGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'WGL_EXT_pbuffer' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.WGL,'WGL_EXT_pbuffer',error_checker=_errors._error_checker) +WGL_DRAW_TO_PBUFFER_EXT=_C('WGL_DRAW_TO_PBUFFER_EXT',0x202D) +WGL_MAX_PBUFFER_HEIGHT_EXT=_C('WGL_MAX_PBUFFER_HEIGHT_EXT',0x2030) +WGL_MAX_PBUFFER_PIXELS_EXT=_C('WGL_MAX_PBUFFER_PIXELS_EXT',0x202E) +WGL_MAX_PBUFFER_WIDTH_EXT=_C('WGL_MAX_PBUFFER_WIDTH_EXT',0x202F) +WGL_OPTIMAL_PBUFFER_HEIGHT_EXT=_C('WGL_OPTIMAL_PBUFFER_HEIGHT_EXT',0x2032) +WGL_OPTIMAL_PBUFFER_WIDTH_EXT=_C('WGL_OPTIMAL_PBUFFER_WIDTH_EXT',0x2031) +WGL_PBUFFER_HEIGHT_EXT=_C('WGL_PBUFFER_HEIGHT_EXT',0x2035) +WGL_PBUFFER_LARGEST_EXT=_C('WGL_PBUFFER_LARGEST_EXT',0x2033) +WGL_PBUFFER_WIDTH_EXT=_C('WGL_PBUFFER_WIDTH_EXT',0x2034) +@_f +@_p.types(_cs.HPBUFFEREXT,_cs.HDC,_cs.c_int,_cs.c_int,_cs.c_int,ctypes.POINTER(_cs.c_int)) +def wglCreatePbufferEXT(hDC,iPixelFormat,iWidth,iHeight,piAttribList):pass +@_f +@_p.types(_cs.BOOL,_cs.HPBUFFEREXT) +def wglDestroyPbufferEXT(hPbuffer):pass +@_f +@_p.types(_cs.HDC,_cs.HPBUFFEREXT) +def wglGetPbufferDCEXT(hPbuffer):pass +@_f +@_p.types(_cs.BOOL,_cs.HPBUFFEREXT,_cs.c_int,ctypes.POINTER(_cs.c_int)) +def wglQueryPbufferEXT(hPbuffer,iAttribute,piValue):pass +@_f +@_p.types(_cs.c_int,_cs.HPBUFFEREXT,_cs.HDC) +def wglReleasePbufferDCEXT(hPbuffer,hDC):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/EXT/pixel_format.py b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/EXT/pixel_format.py new file mode 100644 index 00000000..24885d80 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/EXT/pixel_format.py @@ -0,0 +1,67 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.WGL import _types as _cs +# End users want this... +from OpenGL.raw.WGL._types import * +from OpenGL.raw.WGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'WGL_EXT_pixel_format' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.WGL,'WGL_EXT_pixel_format',error_checker=_errors._error_checker) +WGL_ACCELERATION_EXT=_C('WGL_ACCELERATION_EXT',0x2003) +WGL_ACCUM_ALPHA_BITS_EXT=_C('WGL_ACCUM_ALPHA_BITS_EXT',0x2021) +WGL_ACCUM_BITS_EXT=_C('WGL_ACCUM_BITS_EXT',0x201D) +WGL_ACCUM_BLUE_BITS_EXT=_C('WGL_ACCUM_BLUE_BITS_EXT',0x2020) +WGL_ACCUM_GREEN_BITS_EXT=_C('WGL_ACCUM_GREEN_BITS_EXT',0x201F) +WGL_ACCUM_RED_BITS_EXT=_C('WGL_ACCUM_RED_BITS_EXT',0x201E) +WGL_ALPHA_BITS_EXT=_C('WGL_ALPHA_BITS_EXT',0x201B) +WGL_ALPHA_SHIFT_EXT=_C('WGL_ALPHA_SHIFT_EXT',0x201C) +WGL_AUX_BUFFERS_EXT=_C('WGL_AUX_BUFFERS_EXT',0x2024) +WGL_BLUE_BITS_EXT=_C('WGL_BLUE_BITS_EXT',0x2019) +WGL_BLUE_SHIFT_EXT=_C('WGL_BLUE_SHIFT_EXT',0x201A) +WGL_COLOR_BITS_EXT=_C('WGL_COLOR_BITS_EXT',0x2014) +WGL_DEPTH_BITS_EXT=_C('WGL_DEPTH_BITS_EXT',0x2022) +WGL_DOUBLE_BUFFER_EXT=_C('WGL_DOUBLE_BUFFER_EXT',0x2011) +WGL_DRAW_TO_BITMAP_EXT=_C('WGL_DRAW_TO_BITMAP_EXT',0x2002) +WGL_DRAW_TO_WINDOW_EXT=_C('WGL_DRAW_TO_WINDOW_EXT',0x2001) +WGL_FULL_ACCELERATION_EXT=_C('WGL_FULL_ACCELERATION_EXT',0x2027) +WGL_GENERIC_ACCELERATION_EXT=_C('WGL_GENERIC_ACCELERATION_EXT',0x2026) +WGL_GREEN_BITS_EXT=_C('WGL_GREEN_BITS_EXT',0x2017) +WGL_GREEN_SHIFT_EXT=_C('WGL_GREEN_SHIFT_EXT',0x2018) +WGL_NEED_PALETTE_EXT=_C('WGL_NEED_PALETTE_EXT',0x2004) +WGL_NEED_SYSTEM_PALETTE_EXT=_C('WGL_NEED_SYSTEM_PALETTE_EXT',0x2005) +WGL_NO_ACCELERATION_EXT=_C('WGL_NO_ACCELERATION_EXT',0x2025) +WGL_NUMBER_OVERLAYS_EXT=_C('WGL_NUMBER_OVERLAYS_EXT',0x2008) +WGL_NUMBER_PIXEL_FORMATS_EXT=_C('WGL_NUMBER_PIXEL_FORMATS_EXT',0x2000) +WGL_NUMBER_UNDERLAYS_EXT=_C('WGL_NUMBER_UNDERLAYS_EXT',0x2009) +WGL_PIXEL_TYPE_EXT=_C('WGL_PIXEL_TYPE_EXT',0x2013) +WGL_RED_BITS_EXT=_C('WGL_RED_BITS_EXT',0x2015) +WGL_RED_SHIFT_EXT=_C('WGL_RED_SHIFT_EXT',0x2016) +WGL_SHARE_ACCUM_EXT=_C('WGL_SHARE_ACCUM_EXT',0x200E) +WGL_SHARE_DEPTH_EXT=_C('WGL_SHARE_DEPTH_EXT',0x200C) +WGL_SHARE_STENCIL_EXT=_C('WGL_SHARE_STENCIL_EXT',0x200D) +WGL_STENCIL_BITS_EXT=_C('WGL_STENCIL_BITS_EXT',0x2023) +WGL_STEREO_EXT=_C('WGL_STEREO_EXT',0x2012) +WGL_SUPPORT_GDI_EXT=_C('WGL_SUPPORT_GDI_EXT',0x200F) +WGL_SUPPORT_OPENGL_EXT=_C('WGL_SUPPORT_OPENGL_EXT',0x2010) +WGL_SWAP_COPY_EXT=_C('WGL_SWAP_COPY_EXT',0x2029) +WGL_SWAP_EXCHANGE_EXT=_C('WGL_SWAP_EXCHANGE_EXT',0x2028) +WGL_SWAP_LAYER_BUFFERS_EXT=_C('WGL_SWAP_LAYER_BUFFERS_EXT',0x2006) +WGL_SWAP_METHOD_EXT=_C('WGL_SWAP_METHOD_EXT',0x2007) +WGL_SWAP_UNDEFINED_EXT=_C('WGL_SWAP_UNDEFINED_EXT',0x202A) +WGL_TRANSPARENT_EXT=_C('WGL_TRANSPARENT_EXT',0x200A) +WGL_TRANSPARENT_VALUE_EXT=_C('WGL_TRANSPARENT_VALUE_EXT',0x200B) +WGL_TYPE_COLORINDEX_EXT=_C('WGL_TYPE_COLORINDEX_EXT',0x202C) +WGL_TYPE_RGBA_EXT=_C('WGL_TYPE_RGBA_EXT',0x202B) +@_f +@_p.types(_cs.BOOL,_cs.HDC,ctypes.POINTER(_cs.c_int),ctypes.POINTER(_cs.FLOAT),_cs.UINT,ctypes.POINTER(_cs.c_int),ctypes.POINTER(_cs.UINT)) +def wglChoosePixelFormatEXT(hdc,piAttribIList,pfAttribFList,nMaxFormats,piFormats,nNumFormats):pass +@_f +@_p.types(_cs.BOOL,_cs.HDC,_cs.c_int,_cs.c_int,_cs.UINT,ctypes.POINTER(_cs.c_int),ctypes.POINTER(_cs.FLOAT)) +def wglGetPixelFormatAttribfvEXT(hdc,iPixelFormat,iLayerPlane,nAttributes,piAttributes,pfValues):pass +@_f +@_p.types(_cs.BOOL,_cs.HDC,_cs.c_int,_cs.c_int,_cs.UINT,ctypes.POINTER(_cs.c_int),ctypes.POINTER(_cs.c_int)) +def wglGetPixelFormatAttribivEXT(hdc,iPixelFormat,iLayerPlane,nAttributes,piAttributes,piValues):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/EXT/pixel_format_packed_float.py b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/EXT/pixel_format_packed_float.py new file mode 100644 index 00000000..018273f7 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/EXT/pixel_format_packed_float.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.WGL import _types as _cs +# End users want this... +from OpenGL.raw.WGL._types import * +from OpenGL.raw.WGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'WGL_EXT_pixel_format_packed_float' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.WGL,'WGL_EXT_pixel_format_packed_float',error_checker=_errors._error_checker) +WGL_TYPE_RGBA_UNSIGNED_FLOAT_EXT=_C('WGL_TYPE_RGBA_UNSIGNED_FLOAT_EXT',0x20A8) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/EXT/swap_control.py b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/EXT/swap_control.py new file mode 100644 index 00000000..c5c23293 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/EXT/swap_control.py @@ -0,0 +1,20 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.WGL import _types as _cs +# End users want this... +from OpenGL.raw.WGL._types import * +from OpenGL.raw.WGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'WGL_EXT_swap_control' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.WGL,'WGL_EXT_swap_control',error_checker=_errors._error_checker) + +@_f +@_p.types(_cs.c_int,) +def wglGetSwapIntervalEXT():pass +@_f +@_p.types(_cs.BOOL,_cs.c_int) +def wglSwapIntervalEXT(interval):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/EXT/swap_control_tear.py b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/EXT/swap_control_tear.py new file mode 100644 index 00000000..02f9d365 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/EXT/swap_control_tear.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.WGL import _types as _cs +# End users want this... +from OpenGL.raw.WGL._types import * +from OpenGL.raw.WGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'WGL_EXT_swap_control_tear' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.WGL,'WGL_EXT_swap_control_tear',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/I3D/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/I3D/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/I3D/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/I3D/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/I3D/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..3ab1fe78 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/I3D/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/I3D/__pycache__/digital_video_control.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/I3D/__pycache__/digital_video_control.cpython-312.pyc new file mode 100644 index 00000000..ad95216b Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/I3D/__pycache__/digital_video_control.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/I3D/__pycache__/gamma.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/I3D/__pycache__/gamma.cpython-312.pyc new file mode 100644 index 00000000..20c20dd5 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/I3D/__pycache__/gamma.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/I3D/__pycache__/genlock.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/I3D/__pycache__/genlock.cpython-312.pyc new file mode 100644 index 00000000..abe68e5d Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/I3D/__pycache__/genlock.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/I3D/__pycache__/image_buffer.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/I3D/__pycache__/image_buffer.cpython-312.pyc new file mode 100644 index 00000000..ae3b4c95 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/I3D/__pycache__/image_buffer.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/I3D/__pycache__/swap_frame_lock.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/I3D/__pycache__/swap_frame_lock.cpython-312.pyc new file mode 100644 index 00000000..1546e888 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/I3D/__pycache__/swap_frame_lock.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/I3D/__pycache__/swap_frame_usage.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/I3D/__pycache__/swap_frame_usage.cpython-312.pyc new file mode 100644 index 00000000..f6cabe96 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/I3D/__pycache__/swap_frame_usage.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/I3D/digital_video_control.py b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/I3D/digital_video_control.py new file mode 100644 index 00000000..1794b2b3 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/I3D/digital_video_control.py @@ -0,0 +1,23 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.WGL import _types as _cs +# End users want this... +from OpenGL.raw.WGL._types import * +from OpenGL.raw.WGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'WGL_I3D_digital_video_control' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.WGL,'WGL_I3D_digital_video_control',error_checker=_errors._error_checker) +WGL_DIGITAL_VIDEO_CURSOR_ALPHA_FRAMEBUFFER_I3D=_C('WGL_DIGITAL_VIDEO_CURSOR_ALPHA_FRAMEBUFFER_I3D',0x2050) +WGL_DIGITAL_VIDEO_CURSOR_ALPHA_VALUE_I3D=_C('WGL_DIGITAL_VIDEO_CURSOR_ALPHA_VALUE_I3D',0x2051) +WGL_DIGITAL_VIDEO_CURSOR_INCLUDED_I3D=_C('WGL_DIGITAL_VIDEO_CURSOR_INCLUDED_I3D',0x2052) +WGL_DIGITAL_VIDEO_GAMMA_CORRECTED_I3D=_C('WGL_DIGITAL_VIDEO_GAMMA_CORRECTED_I3D',0x2053) +@_f +@_p.types(_cs.BOOL,_cs.HDC,_cs.c_int,ctypes.POINTER(_cs.c_int)) +def wglGetDigitalVideoParametersI3D(hDC,iAttribute,piValue):pass +@_f +@_p.types(_cs.BOOL,_cs.HDC,_cs.c_int,ctypes.POINTER(_cs.c_int)) +def wglSetDigitalVideoParametersI3D(hDC,iAttribute,piValue):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/I3D/gamma.py b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/I3D/gamma.py new file mode 100644 index 00000000..5679573b --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/I3D/gamma.py @@ -0,0 +1,27 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.WGL import _types as _cs +# End users want this... +from OpenGL.raw.WGL._types import * +from OpenGL.raw.WGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'WGL_I3D_gamma' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.WGL,'WGL_I3D_gamma',error_checker=_errors._error_checker) +WGL_GAMMA_EXCLUDE_DESKTOP_I3D=_C('WGL_GAMMA_EXCLUDE_DESKTOP_I3D',0x204F) +WGL_GAMMA_TABLE_SIZE_I3D=_C('WGL_GAMMA_TABLE_SIZE_I3D',0x204E) +@_f +@_p.types(_cs.BOOL,_cs.HDC,_cs.c_int,ctypes.POINTER(_cs.USHORT),ctypes.POINTER(_cs.USHORT),ctypes.POINTER(_cs.USHORT)) +def wglGetGammaTableI3D(hDC,iEntries,puRed,puGreen,puBlue):pass +@_f +@_p.types(_cs.BOOL,_cs.HDC,_cs.c_int,ctypes.POINTER(_cs.c_int)) +def wglGetGammaTableParametersI3D(hDC,iAttribute,piValue):pass +@_f +@_p.types(_cs.BOOL,_cs.HDC,_cs.c_int,ctypes.POINTER(_cs.USHORT),ctypes.POINTER(_cs.USHORT),ctypes.POINTER(_cs.USHORT)) +def wglSetGammaTableI3D(hDC,iEntries,puRed,puGreen,puBlue):pass +@_f +@_p.types(_cs.BOOL,_cs.HDC,_cs.c_int,ctypes.POINTER(_cs.c_int)) +def wglSetGammaTableParametersI3D(hDC,iAttribute,piValue):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/I3D/genlock.py b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/I3D/genlock.py new file mode 100644 index 00000000..94faad93 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/I3D/genlock.py @@ -0,0 +1,58 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.WGL import _types as _cs +# End users want this... +from OpenGL.raw.WGL._types import * +from OpenGL.raw.WGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'WGL_I3D_genlock' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.WGL,'WGL_I3D_genlock',error_checker=_errors._error_checker) +WGL_GENLOCK_SOURCE_DIGITAL_FIELD_I3D=_C('WGL_GENLOCK_SOURCE_DIGITAL_FIELD_I3D',0x2049) +WGL_GENLOCK_SOURCE_DIGITAL_SYNC_I3D=_C('WGL_GENLOCK_SOURCE_DIGITAL_SYNC_I3D',0x2048) +WGL_GENLOCK_SOURCE_EDGE_BOTH_I3D=_C('WGL_GENLOCK_SOURCE_EDGE_BOTH_I3D',0x204C) +WGL_GENLOCK_SOURCE_EDGE_FALLING_I3D=_C('WGL_GENLOCK_SOURCE_EDGE_FALLING_I3D',0x204A) +WGL_GENLOCK_SOURCE_EDGE_RISING_I3D=_C('WGL_GENLOCK_SOURCE_EDGE_RISING_I3D',0x204B) +WGL_GENLOCK_SOURCE_EXTERNAL_FIELD_I3D=_C('WGL_GENLOCK_SOURCE_EXTERNAL_FIELD_I3D',0x2046) +WGL_GENLOCK_SOURCE_EXTERNAL_SYNC_I3D=_C('WGL_GENLOCK_SOURCE_EXTERNAL_SYNC_I3D',0x2045) +WGL_GENLOCK_SOURCE_EXTERNAL_TTL_I3D=_C('WGL_GENLOCK_SOURCE_EXTERNAL_TTL_I3D',0x2047) +WGL_GENLOCK_SOURCE_MULTIVIEW_I3D=_C('WGL_GENLOCK_SOURCE_MULTIVIEW_I3D',0x2044) +@_f +@_p.types(_cs.BOOL,_cs.HDC) +def wglDisableGenlockI3D(hDC):pass +@_f +@_p.types(_cs.BOOL,_cs.HDC) +def wglEnableGenlockI3D(hDC):pass +@_f +@_p.types(_cs.BOOL,_cs.HDC,_cs.UINT) +def wglGenlockSampleRateI3D(hDC,uRate):pass +@_f +@_p.types(_cs.BOOL,_cs.HDC,_cs.UINT) +def wglGenlockSourceDelayI3D(hDC,uDelay):pass +@_f +@_p.types(_cs.BOOL,_cs.HDC,_cs.UINT) +def wglGenlockSourceEdgeI3D(hDC,uEdge):pass +@_f +@_p.types(_cs.BOOL,_cs.HDC,_cs.UINT) +def wglGenlockSourceI3D(hDC,uSource):pass +@_f +@_p.types(_cs.BOOL,_cs.HDC,ctypes.POINTER(_cs.UINT)) +def wglGetGenlockSampleRateI3D(hDC,uRate):pass +@_f +@_p.types(_cs.BOOL,_cs.HDC,ctypes.POINTER(_cs.UINT)) +def wglGetGenlockSourceDelayI3D(hDC,uDelay):pass +@_f +@_p.types(_cs.BOOL,_cs.HDC,ctypes.POINTER(_cs.UINT)) +def wglGetGenlockSourceEdgeI3D(hDC,uEdge):pass +@_f +@_p.types(_cs.BOOL,_cs.HDC,ctypes.POINTER(_cs.UINT)) +def wglGetGenlockSourceI3D(hDC,uSource):pass +@_f +@_p.types(_cs.BOOL,_cs.HDC,ctypes.POINTER(_cs.BOOL)) +def wglIsEnabledGenlockI3D(hDC,pFlag):pass +@_f +@_p.types(_cs.BOOL,_cs.HDC,ctypes.POINTER(_cs.UINT),ctypes.POINTER(_cs.UINT)) +def wglQueryGenlockMaxSourceDelayI3D(hDC,uMaxLineDelay,uMaxPixelDelay):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/I3D/image_buffer.py b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/I3D/image_buffer.py new file mode 100644 index 00000000..dda3fa1e --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/I3D/image_buffer.py @@ -0,0 +1,27 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.WGL import _types as _cs +# End users want this... +from OpenGL.raw.WGL._types import * +from OpenGL.raw.WGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'WGL_I3D_image_buffer' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.WGL,'WGL_I3D_image_buffer',error_checker=_errors._error_checker) +WGL_IMAGE_BUFFER_LOCK_I3D=_C('WGL_IMAGE_BUFFER_LOCK_I3D',0x00000002) +WGL_IMAGE_BUFFER_MIN_ACCESS_I3D=_C('WGL_IMAGE_BUFFER_MIN_ACCESS_I3D',0x00000001) +@_f +@_p.types(_cs.BOOL,_cs.HDC,ctypes.POINTER(_cs.HANDLE),ctypes.POINTER(_cs.LPVOID),ctypes.POINTER(_cs.DWORD),_cs.UINT) +def wglAssociateImageBufferEventsI3D(hDC,pEvent,pAddress,pSize,count):pass +@_f +@_p.types(_cs.LPVOID,_cs.HDC,_cs.DWORD,_cs.UINT) +def wglCreateImageBufferI3D(hDC,dwSize,uFlags):pass +@_f +@_p.types(_cs.BOOL,_cs.HDC,_cs.LPVOID) +def wglDestroyImageBufferI3D(hDC,pAddress):pass +@_f +@_p.types(_cs.BOOL,_cs.HDC,ctypes.POINTER(_cs.LPVOID),_cs.UINT) +def wglReleaseImageBufferEventsI3D(hDC,pAddress,count):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/I3D/swap_frame_lock.py b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/I3D/swap_frame_lock.py new file mode 100644 index 00000000..7eb9f238 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/I3D/swap_frame_lock.py @@ -0,0 +1,26 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.WGL import _types as _cs +# End users want this... +from OpenGL.raw.WGL._types import * +from OpenGL.raw.WGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'WGL_I3D_swap_frame_lock' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.WGL,'WGL_I3D_swap_frame_lock',error_checker=_errors._error_checker) + +@_f +@_p.types(_cs.BOOL,) +def wglDisableFrameLockI3D():pass +@_f +@_p.types(_cs.BOOL,) +def wglEnableFrameLockI3D():pass +@_f +@_p.types(_cs.BOOL,ctypes.POINTER(_cs.BOOL)) +def wglIsEnabledFrameLockI3D(pFlag):pass +@_f +@_p.types(_cs.BOOL,ctypes.POINTER(_cs.BOOL)) +def wglQueryFrameLockMasterI3D(pFlag):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/I3D/swap_frame_usage.py b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/I3D/swap_frame_usage.py new file mode 100644 index 00000000..34450da4 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/I3D/swap_frame_usage.py @@ -0,0 +1,26 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.WGL import _types as _cs +# End users want this... +from OpenGL.raw.WGL._types import * +from OpenGL.raw.WGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'WGL_I3D_swap_frame_usage' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.WGL,'WGL_I3D_swap_frame_usage',error_checker=_errors._error_checker) + +@_f +@_p.types(_cs.BOOL,) +def wglBeginFrameTrackingI3D():pass +@_f +@_p.types(_cs.BOOL,) +def wglEndFrameTrackingI3D():pass +@_f +@_p.types(_cs.BOOL,arrays.GLfloatArray) +def wglGetFrameUsageI3D(pUsage):pass +@_f +@_p.types(_cs.BOOL,ctypes.POINTER(_cs.DWORD),ctypes.POINTER(_cs.DWORD),arrays.GLfloatArray) +def wglQueryFrameTrackingI3D(pFrameCount,pMissedFrames,pLastMissedUsage):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/NV/DX_interop.py b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/NV/DX_interop.py new file mode 100644 index 00000000..29c4f261 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/NV/DX_interop.py @@ -0,0 +1,40 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.WGL import _types as _cs +# End users want this... +from OpenGL.raw.WGL._types import * +from OpenGL.raw.WGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'WGL_NV_DX_interop' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.WGL,'WGL_NV_DX_interop',error_checker=_errors._error_checker) +WGL_ACCESS_READ_ONLY_NV=_C('WGL_ACCESS_READ_ONLY_NV',0x00000000) +WGL_ACCESS_READ_WRITE_NV=_C('WGL_ACCESS_READ_WRITE_NV',0x00000001) +WGL_ACCESS_WRITE_DISCARD_NV=_C('WGL_ACCESS_WRITE_DISCARD_NV',0x00000002) +@_f +@_p.types(_cs.BOOL,_cs.HANDLE) +def wglDXCloseDeviceNV(hDevice):pass +@_f +@_p.types(_cs.BOOL,_cs.HANDLE,_cs.GLint,ctypes.POINTER(_cs.HANDLE)) +def wglDXLockObjectsNV(hDevice,count,hObjects):pass +@_f +@_p.types(_cs.BOOL,_cs.HANDLE,_cs.GLenum) +def wglDXObjectAccessNV(hObject,access):pass +@_f +@_p.types(_cs.HANDLE,ctypes.c_void_p) +def wglDXOpenDeviceNV(dxDevice):pass +@_f +@_p.types(_cs.HANDLE,_cs.HANDLE,ctypes.c_void_p,_cs.GLuint,_cs.GLenum,_cs.GLenum) +def wglDXRegisterObjectNV(hDevice,dxObject,name,type,access):pass +@_f +@_p.types(_cs.BOOL,ctypes.c_void_p,_cs.HANDLE) +def wglDXSetResourceShareHandleNV(dxObject,shareHandle):pass +@_f +@_p.types(_cs.BOOL,_cs.HANDLE,_cs.GLint,ctypes.POINTER(_cs.HANDLE)) +def wglDXUnlockObjectsNV(hDevice,count,hObjects):pass +@_f +@_p.types(_cs.BOOL,_cs.HANDLE,_cs.HANDLE) +def wglDXUnregisterObjectNV(hDevice,hObject):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/NV/DX_interop2.py b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/NV/DX_interop2.py new file mode 100644 index 00000000..7f602b3b --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/NV/DX_interop2.py @@ -0,0 +1,15 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.WGL import _types as _cs +# End users want this... +from OpenGL.raw.WGL._types import * +from OpenGL.raw.WGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'WGL_NV_DX_interop2' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.WGL,'WGL_NV_DX_interop2',error_checker=_errors._error_checker) + + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/NV/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/NV/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/NV/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/NV/__pycache__/DX_interop.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/NV/__pycache__/DX_interop.cpython-312.pyc new file mode 100644 index 00000000..ac2fa990 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/NV/__pycache__/DX_interop.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/NV/__pycache__/DX_interop2.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/NV/__pycache__/DX_interop2.cpython-312.pyc new file mode 100644 index 00000000..f7f98573 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/NV/__pycache__/DX_interop2.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/NV/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/NV/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..e3468b2f Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/NV/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/NV/__pycache__/copy_image.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/NV/__pycache__/copy_image.cpython-312.pyc new file mode 100644 index 00000000..8e4a208a Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/NV/__pycache__/copy_image.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/NV/__pycache__/delay_before_swap.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/NV/__pycache__/delay_before_swap.cpython-312.pyc new file mode 100644 index 00000000..0772272c Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/NV/__pycache__/delay_before_swap.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/NV/__pycache__/float_buffer.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/NV/__pycache__/float_buffer.cpython-312.pyc new file mode 100644 index 00000000..3e793482 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/NV/__pycache__/float_buffer.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/NV/__pycache__/gpu_affinity.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/NV/__pycache__/gpu_affinity.cpython-312.pyc new file mode 100644 index 00000000..fa5396a9 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/NV/__pycache__/gpu_affinity.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/NV/__pycache__/multigpu_context.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/NV/__pycache__/multigpu_context.cpython-312.pyc new file mode 100644 index 00000000..76d54da4 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/NV/__pycache__/multigpu_context.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/NV/__pycache__/multisample_coverage.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/NV/__pycache__/multisample_coverage.cpython-312.pyc new file mode 100644 index 00000000..64592b17 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/NV/__pycache__/multisample_coverage.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/NV/__pycache__/present_video.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/NV/__pycache__/present_video.cpython-312.pyc new file mode 100644 index 00000000..c0105527 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/NV/__pycache__/present_video.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/NV/__pycache__/render_depth_texture.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/NV/__pycache__/render_depth_texture.cpython-312.pyc new file mode 100644 index 00000000..573118f6 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/NV/__pycache__/render_depth_texture.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/NV/__pycache__/render_texture_rectangle.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/NV/__pycache__/render_texture_rectangle.cpython-312.pyc new file mode 100644 index 00000000..4c26ae91 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/NV/__pycache__/render_texture_rectangle.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/NV/__pycache__/swap_group.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/NV/__pycache__/swap_group.cpython-312.pyc new file mode 100644 index 00000000..d31f5c2d Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/NV/__pycache__/swap_group.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/NV/__pycache__/vertex_array_range.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/NV/__pycache__/vertex_array_range.cpython-312.pyc new file mode 100644 index 00000000..c9588eee Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/NV/__pycache__/vertex_array_range.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/NV/__pycache__/video_capture.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/NV/__pycache__/video_capture.cpython-312.pyc new file mode 100644 index 00000000..556c7416 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/NV/__pycache__/video_capture.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/NV/__pycache__/video_output.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/NV/__pycache__/video_output.cpython-312.pyc new file mode 100644 index 00000000..dce50955 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/NV/__pycache__/video_output.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/NV/copy_image.py b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/NV/copy_image.py new file mode 100644 index 00000000..508d34da --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/NV/copy_image.py @@ -0,0 +1,17 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.WGL import _types as _cs +# End users want this... +from OpenGL.raw.WGL._types import * +from OpenGL.raw.WGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'WGL_NV_copy_image' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.WGL,'WGL_NV_copy_image',error_checker=_errors._error_checker) + +@_f +@_p.types(_cs.BOOL,_cs.HGLRC,_cs.GLuint,_cs.GLenum,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.HGLRC,_cs.GLuint,_cs.GLenum,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLint,_cs.GLsizei,_cs.GLsizei,_cs.GLsizei) +def wglCopyImageSubDataNV(hSrcRC,srcName,srcTarget,srcLevel,srcX,srcY,srcZ,hDstRC,dstName,dstTarget,dstLevel,dstX,dstY,dstZ,width,height,depth):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/NV/delay_before_swap.py b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/NV/delay_before_swap.py new file mode 100644 index 00000000..b3fe953d --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/NV/delay_before_swap.py @@ -0,0 +1,17 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.WGL import _types as _cs +# End users want this... +from OpenGL.raw.WGL._types import * +from OpenGL.raw.WGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'WGL_NV_delay_before_swap' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.WGL,'WGL_NV_delay_before_swap',error_checker=_errors._error_checker) + +@_f +@_p.types(_cs.BOOL,_cs.HDC,_cs.GLfloat) +def wglDelayBeforeSwapNV(hDC,seconds):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/NV/float_buffer.py b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/NV/float_buffer.py new file mode 100644 index 00000000..906061e0 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/NV/float_buffer.py @@ -0,0 +1,23 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.WGL import _types as _cs +# End users want this... +from OpenGL.raw.WGL._types import * +from OpenGL.raw.WGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'WGL_NV_float_buffer' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.WGL,'WGL_NV_float_buffer',error_checker=_errors._error_checker) +WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_RGBA_NV=_C('WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_RGBA_NV',0x20B4) +WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_RGB_NV=_C('WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_RGB_NV',0x20B3) +WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_RG_NV=_C('WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_RG_NV',0x20B2) +WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_R_NV=_C('WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_R_NV',0x20B1) +WGL_FLOAT_COMPONENTS_NV=_C('WGL_FLOAT_COMPONENTS_NV',0x20B0) +WGL_TEXTURE_FLOAT_RGBA_NV=_C('WGL_TEXTURE_FLOAT_RGBA_NV',0x20B8) +WGL_TEXTURE_FLOAT_RGB_NV=_C('WGL_TEXTURE_FLOAT_RGB_NV',0x20B7) +WGL_TEXTURE_FLOAT_RG_NV=_C('WGL_TEXTURE_FLOAT_RG_NV',0x20B6) +WGL_TEXTURE_FLOAT_R_NV=_C('WGL_TEXTURE_FLOAT_R_NV',0x20B5) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/NV/gpu_affinity.py b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/NV/gpu_affinity.py new file mode 100644 index 00000000..a9f4b9b6 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/NV/gpu_affinity.py @@ -0,0 +1,30 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.WGL import _types as _cs +# End users want this... +from OpenGL.raw.WGL._types import * +from OpenGL.raw.WGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'WGL_NV_gpu_affinity' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.WGL,'WGL_NV_gpu_affinity',error_checker=_errors._error_checker) +ERROR_INCOMPATIBLE_AFFINITY_MASKS_NV=_C('ERROR_INCOMPATIBLE_AFFINITY_MASKS_NV',0x20D0) +ERROR_MISSING_AFFINITY_MASK_NV=_C('ERROR_MISSING_AFFINITY_MASK_NV',0x20D1) +@_f +@_p.types(_cs.HDC,ctypes.POINTER(_cs.HGPUNV)) +def wglCreateAffinityDCNV(phGpuList):pass +@_f +@_p.types(_cs.BOOL,_cs.HDC) +def wglDeleteDCNV(hdc):pass +@_f +@_p.types(_cs.BOOL,_cs.HGPUNV,_cs.UINT,_cs.PGPU_DEVICE) +def wglEnumGpuDevicesNV(hGpu,iDeviceIndex,lpGpuDevice):pass +@_f +@_p.types(_cs.BOOL,_cs.HDC,_cs.UINT,ctypes.POINTER(_cs.HGPUNV)) +def wglEnumGpusFromAffinityDCNV(hAffinityDC,iGpuIndex,hGpu):pass +@_f +@_p.types(_cs.BOOL,_cs.UINT,ctypes.POINTER(_cs.HGPUNV)) +def wglEnumGpusNV(iGpuIndex,phGpu):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/NV/multigpu_context.py b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/NV/multigpu_context.py new file mode 100644 index 00000000..3e542bb9 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/NV/multigpu_context.py @@ -0,0 +1,19 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.WGL import _types as _cs +# End users want this... +from OpenGL.raw.WGL._types import * +from OpenGL.raw.WGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'WGL_NV_multigpu_context' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.WGL,'WGL_NV_multigpu_context',error_checker=_errors._error_checker) +WGL_CONTEXT_MULTIGPU_ATTRIB_AFR_NV=_C('WGL_CONTEXT_MULTIGPU_ATTRIB_AFR_NV',0x20AC) +WGL_CONTEXT_MULTIGPU_ATTRIB_MULTICAST_NV=_C('WGL_CONTEXT_MULTIGPU_ATTRIB_MULTICAST_NV',0x20AD) +WGL_CONTEXT_MULTIGPU_ATTRIB_MULTI_DISPLAY_MULTICAST_NV=_C('WGL_CONTEXT_MULTIGPU_ATTRIB_MULTI_DISPLAY_MULTICAST_NV',0x20AE) +WGL_CONTEXT_MULTIGPU_ATTRIB_NV=_C('WGL_CONTEXT_MULTIGPU_ATTRIB_NV',0x20AA) +WGL_CONTEXT_MULTIGPU_ATTRIB_SINGLE_NV=_C('WGL_CONTEXT_MULTIGPU_ATTRIB_SINGLE_NV',0x20AB) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/NV/multisample_coverage.py b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/NV/multisample_coverage.py new file mode 100644 index 00000000..e503f744 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/NV/multisample_coverage.py @@ -0,0 +1,16 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.WGL import _types as _cs +# End users want this... +from OpenGL.raw.WGL._types import * +from OpenGL.raw.WGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'WGL_NV_multisample_coverage' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.WGL,'WGL_NV_multisample_coverage',error_checker=_errors._error_checker) +WGL_COLOR_SAMPLES_NV=_C('WGL_COLOR_SAMPLES_NV',0x20B9) +WGL_COVERAGE_SAMPLES_NV=_C('WGL_COVERAGE_SAMPLES_NV',0x2042) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/NV/present_video.py b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/NV/present_video.py new file mode 100644 index 00000000..0c1fecc0 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/NV/present_video.py @@ -0,0 +1,23 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.WGL import _types as _cs +# End users want this... +from OpenGL.raw.WGL._types import * +from OpenGL.raw.WGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'WGL_NV_present_video' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.WGL,'WGL_NV_present_video',error_checker=_errors._error_checker) +WGL_NUM_VIDEO_SLOTS_NV=_C('WGL_NUM_VIDEO_SLOTS_NV',0x20F0) +@_f +@_p.types(_cs.BOOL,_cs.HDC,_cs.c_uint,_cs.HVIDEOOUTPUTDEVICENV,ctypes.POINTER(_cs.c_int)) +def wglBindVideoDeviceNV(hDc,uVideoSlot,hVideoDevice,piAttribList):pass +@_f +@_p.types(_cs.c_int,_cs.HDC,ctypes.POINTER(_cs.HVIDEOOUTPUTDEVICENV)) +def wglEnumerateVideoDevicesNV(hDc,phDeviceList):pass +@_f +@_p.types(_cs.BOOL,_cs.c_int,ctypes.POINTER(_cs.c_int)) +def wglQueryCurrentContextNV(iAttribute,piValue):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/NV/render_depth_texture.py b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/NV/render_depth_texture.py new file mode 100644 index 00000000..795683a5 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/NV/render_depth_texture.py @@ -0,0 +1,19 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.WGL import _types as _cs +# End users want this... +from OpenGL.raw.WGL._types import * +from OpenGL.raw.WGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'WGL_NV_render_depth_texture' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.WGL,'WGL_NV_render_depth_texture',error_checker=_errors._error_checker) +WGL_BIND_TO_TEXTURE_DEPTH_NV=_C('WGL_BIND_TO_TEXTURE_DEPTH_NV',0x20A3) +WGL_BIND_TO_TEXTURE_RECTANGLE_DEPTH_NV=_C('WGL_BIND_TO_TEXTURE_RECTANGLE_DEPTH_NV',0x20A4) +WGL_DEPTH_COMPONENT_NV=_C('WGL_DEPTH_COMPONENT_NV',0x20A7) +WGL_DEPTH_TEXTURE_FORMAT_NV=_C('WGL_DEPTH_TEXTURE_FORMAT_NV',0x20A5) +WGL_TEXTURE_DEPTH_COMPONENT_NV=_C('WGL_TEXTURE_DEPTH_COMPONENT_NV',0x20A6) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/NV/render_texture_rectangle.py b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/NV/render_texture_rectangle.py new file mode 100644 index 00000000..61c1d486 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/NV/render_texture_rectangle.py @@ -0,0 +1,17 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.WGL import _types as _cs +# End users want this... +from OpenGL.raw.WGL._types import * +from OpenGL.raw.WGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'WGL_NV_render_texture_rectangle' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.WGL,'WGL_NV_render_texture_rectangle',error_checker=_errors._error_checker) +WGL_BIND_TO_TEXTURE_RECTANGLE_RGBA_NV=_C('WGL_BIND_TO_TEXTURE_RECTANGLE_RGBA_NV',0x20A1) +WGL_BIND_TO_TEXTURE_RECTANGLE_RGB_NV=_C('WGL_BIND_TO_TEXTURE_RECTANGLE_RGB_NV',0x20A0) +WGL_TEXTURE_RECTANGLE_NV=_C('WGL_TEXTURE_RECTANGLE_NV',0x20A2) + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/NV/swap_group.py b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/NV/swap_group.py new file mode 100644 index 00000000..e8b638bd --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/NV/swap_group.py @@ -0,0 +1,32 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.WGL import _types as _cs +# End users want this... +from OpenGL.raw.WGL._types import * +from OpenGL.raw.WGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'WGL_NV_swap_group' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.WGL,'WGL_NV_swap_group',error_checker=_errors._error_checker) + +@_f +@_p.types(_cs.BOOL,_cs.GLuint,_cs.GLuint) +def wglBindSwapBarrierNV(group,barrier):pass +@_f +@_p.types(_cs.BOOL,_cs.HDC,_cs.GLuint) +def wglJoinSwapGroupNV(hDC,group):pass +@_f +@_p.types(_cs.BOOL,_cs.HDC,arrays.GLuintArray) +def wglQueryFrameCountNV(hDC,count):pass +@_f +@_p.types(_cs.BOOL,_cs.HDC,arrays.GLuintArray,arrays.GLuintArray) +def wglQueryMaxSwapGroupsNV(hDC,maxGroups,maxBarriers):pass +@_f +@_p.types(_cs.BOOL,_cs.HDC,arrays.GLuintArray,arrays.GLuintArray) +def wglQuerySwapGroupNV(hDC,group,barrier):pass +@_f +@_p.types(_cs.BOOL,_cs.HDC) +def wglResetFrameCountNV(hDC):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/NV/vertex_array_range.py b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/NV/vertex_array_range.py new file mode 100644 index 00000000..000104ee --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/NV/vertex_array_range.py @@ -0,0 +1,20 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.WGL import _types as _cs +# End users want this... +from OpenGL.raw.WGL._types import * +from OpenGL.raw.WGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'WGL_NV_vertex_array_range' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.WGL,'WGL_NV_vertex_array_range',error_checker=_errors._error_checker) + +@_f +@_p.types(ctypes.c_void_p,_cs.GLsizei,_cs.GLfloat,_cs.GLfloat,_cs.GLfloat) +def wglAllocateMemoryNV(size,readfreq,writefreq,priority):pass +@_f +@_p.types(None,ctypes.c_void_p) +def wglFreeMemoryNV(pointer):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/NV/video_capture.py b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/NV/video_capture.py new file mode 100644 index 00000000..24b3a481 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/NV/video_capture.py @@ -0,0 +1,30 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.WGL import _types as _cs +# End users want this... +from OpenGL.raw.WGL._types import * +from OpenGL.raw.WGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'WGL_NV_video_capture' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.WGL,'WGL_NV_video_capture',error_checker=_errors._error_checker) +WGL_NUM_VIDEO_CAPTURE_SLOTS_NV=_C('WGL_NUM_VIDEO_CAPTURE_SLOTS_NV',0x20CF) +WGL_UNIQUE_ID_NV=_C('WGL_UNIQUE_ID_NV',0x20CE) +@_f +@_p.types(_cs.BOOL,_cs.UINT,_cs.HVIDEOINPUTDEVICENV) +def wglBindVideoCaptureDeviceNV(uVideoSlot,hDevice):pass +@_f +@_p.types(_cs.UINT,_cs.HDC,ctypes.POINTER(_cs.HVIDEOINPUTDEVICENV)) +def wglEnumerateVideoCaptureDevicesNV(hDc,phDeviceList):pass +@_f +@_p.types(_cs.BOOL,_cs.HDC,_cs.HVIDEOINPUTDEVICENV) +def wglLockVideoCaptureDeviceNV(hDc,hDevice):pass +@_f +@_p.types(_cs.BOOL,_cs.HDC,_cs.HVIDEOINPUTDEVICENV,_cs.c_int,ctypes.POINTER(_cs.c_int)) +def wglQueryVideoCaptureDeviceNV(hDc,hDevice,iAttribute,piValue):pass +@_f +@_p.types(_cs.BOOL,_cs.HDC,_cs.HVIDEOINPUTDEVICENV) +def wglReleaseVideoCaptureDeviceNV(hDc,hDevice):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/NV/video_output.py b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/NV/video_output.py new file mode 100644 index 00000000..dc099699 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/NV/video_output.py @@ -0,0 +1,44 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.WGL import _types as _cs +# End users want this... +from OpenGL.raw.WGL._types import * +from OpenGL.raw.WGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'WGL_NV_video_output' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.WGL,'WGL_NV_video_output',error_checker=_errors._error_checker) +WGL_BIND_TO_VIDEO_RGBA_NV=_C('WGL_BIND_TO_VIDEO_RGBA_NV',0x20C1) +WGL_BIND_TO_VIDEO_RGB_AND_DEPTH_NV=_C('WGL_BIND_TO_VIDEO_RGB_AND_DEPTH_NV',0x20C2) +WGL_BIND_TO_VIDEO_RGB_NV=_C('WGL_BIND_TO_VIDEO_RGB_NV',0x20C0) +WGL_VIDEO_OUT_ALPHA_NV=_C('WGL_VIDEO_OUT_ALPHA_NV',0x20C4) +WGL_VIDEO_OUT_COLOR_AND_ALPHA_NV=_C('WGL_VIDEO_OUT_COLOR_AND_ALPHA_NV',0x20C6) +WGL_VIDEO_OUT_COLOR_AND_DEPTH_NV=_C('WGL_VIDEO_OUT_COLOR_AND_DEPTH_NV',0x20C7) +WGL_VIDEO_OUT_COLOR_NV=_C('WGL_VIDEO_OUT_COLOR_NV',0x20C3) +WGL_VIDEO_OUT_DEPTH_NV=_C('WGL_VIDEO_OUT_DEPTH_NV',0x20C5) +WGL_VIDEO_OUT_FIELD_1=_C('WGL_VIDEO_OUT_FIELD_1',0x20C9) +WGL_VIDEO_OUT_FIELD_2=_C('WGL_VIDEO_OUT_FIELD_2',0x20CA) +WGL_VIDEO_OUT_FRAME=_C('WGL_VIDEO_OUT_FRAME',0x20C8) +WGL_VIDEO_OUT_STACKED_FIELDS_1_2=_C('WGL_VIDEO_OUT_STACKED_FIELDS_1_2',0x20CB) +WGL_VIDEO_OUT_STACKED_FIELDS_2_1=_C('WGL_VIDEO_OUT_STACKED_FIELDS_2_1',0x20CC) +@_f +@_p.types(_cs.BOOL,_cs.HPVIDEODEV,_cs.HPBUFFERARB,_cs.c_int) +def wglBindVideoImageNV(hVideoDevice,hPbuffer,iVideoBuffer):pass +@_f +@_p.types(_cs.BOOL,_cs.HDC,_cs.c_int,ctypes.POINTER(_cs.HPVIDEODEV)) +def wglGetVideoDeviceNV(hDC,numDevices,hVideoDevice):pass +@_f +@_p.types(_cs.BOOL,_cs.HPVIDEODEV,ctypes.POINTER(_cs.c_ulong),ctypes.POINTER(_cs.c_ulong)) +def wglGetVideoInfoNV(hpVideoDevice,pulCounterOutputPbuffer,pulCounterOutputVideo):pass +@_f +@_p.types(_cs.BOOL,_cs.HPVIDEODEV) +def wglReleaseVideoDeviceNV(hVideoDevice):pass +@_f +@_p.types(_cs.BOOL,_cs.HPBUFFERARB,_cs.c_int) +def wglReleaseVideoImageNV(hPbuffer,iVideoBuffer):pass +@_f +@_p.types(_cs.BOOL,_cs.HPBUFFERARB,_cs.c_int,ctypes.POINTER(_cs.c_ulong),_cs.BOOL) +def wglSendPbufferToVideoNV(hPbuffer,iBufferType,pulCounterPbuffer,bBlock):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/OML/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/OML/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/OML/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/OML/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/OML/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..d2c2bf0f Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/OML/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/OML/__pycache__/sync_control.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/OML/__pycache__/sync_control.cpython-312.pyc new file mode 100644 index 00000000..8104f638 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/OML/__pycache__/sync_control.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/OML/sync_control.py b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/OML/sync_control.py new file mode 100644 index 00000000..7fbd81f1 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/OML/sync_control.py @@ -0,0 +1,32 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.WGL import _types as _cs +# End users want this... +from OpenGL.raw.WGL._types import * +from OpenGL.raw.WGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'WGL_OML_sync_control' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.WGL,'WGL_OML_sync_control',error_checker=_errors._error_checker) + +@_f +@_p.types(_cs.BOOL,_cs.HDC,ctypes.POINTER(_cs.INT32),ctypes.POINTER(_cs.INT32)) +def wglGetMscRateOML(hdc,numerator,denominator):pass +@_f +@_p.types(_cs.BOOL,_cs.HDC,ctypes.POINTER(_cs.INT64),ctypes.POINTER(_cs.INT64),ctypes.POINTER(_cs.INT64)) +def wglGetSyncValuesOML(hdc,ust,msc,sbc):pass +@_f +@_p.types(_cs.INT64,_cs.HDC,_cs.INT64,_cs.INT64,_cs.INT64) +def wglSwapBuffersMscOML(hdc,target_msc,divisor,remainder):pass +@_f +@_p.types(_cs.INT64,_cs.HDC,_cs.INT,_cs.INT64,_cs.INT64,_cs.INT64) +def wglSwapLayerBuffersMscOML(hdc,fuPlanes,target_msc,divisor,remainder):pass +@_f +@_p.types(_cs.BOOL,_cs.HDC,_cs.INT64,_cs.INT64,_cs.INT64,ctypes.POINTER(_cs.INT64),ctypes.POINTER(_cs.INT64),ctypes.POINTER(_cs.INT64)) +def wglWaitForMscOML(hdc,target_msc,divisor,remainder,ust,msc,sbc):pass +@_f +@_p.types(_cs.BOOL,_cs.HDC,_cs.INT64,ctypes.POINTER(_cs.INT64),ctypes.POINTER(_cs.INT64),ctypes.POINTER(_cs.INT64)) +def wglWaitForSbcOML(hdc,target_sbc,ust,msc,sbc):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/VERSION/WGL_1_0.py b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/VERSION/WGL_1_0.py new file mode 100644 index 00000000..431cc63f --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/VERSION/WGL_1_0.py @@ -0,0 +1,124 @@ +'''Autogenerated by xml_generate script, do not edit!''' +from OpenGL import platform as _p, arrays +# Code generation uses this +from OpenGL.raw.WGL import _types as _cs +# End users want this... +from OpenGL.raw.WGL._types import * +from OpenGL.raw.WGL import _errors +from OpenGL.constant import Constant as _C + +import ctypes +_EXTENSION_NAME = 'WGL_VERSION_WGL_1_0' +def _f( function ): + return _p.createFunction( function,_p.PLATFORM.WGL,'WGL_VERSION_WGL_1_0',error_checker=_errors._error_checker) +WGL_FONT_LINES=_C('WGL_FONT_LINES',0) +WGL_FONT_POLYGONS=_C('WGL_FONT_POLYGONS',1) +WGL_SWAP_MAIN_PLANE=_C('WGL_SWAP_MAIN_PLANE',0x00000001) +WGL_SWAP_OVERLAY1=_C('WGL_SWAP_OVERLAY1',0x00000002) +WGL_SWAP_OVERLAY10=_C('WGL_SWAP_OVERLAY10',0x00000400) +WGL_SWAP_OVERLAY11=_C('WGL_SWAP_OVERLAY11',0x00000800) +WGL_SWAP_OVERLAY12=_C('WGL_SWAP_OVERLAY12',0x00001000) +WGL_SWAP_OVERLAY13=_C('WGL_SWAP_OVERLAY13',0x00002000) +WGL_SWAP_OVERLAY14=_C('WGL_SWAP_OVERLAY14',0x00004000) +WGL_SWAP_OVERLAY15=_C('WGL_SWAP_OVERLAY15',0x00008000) +WGL_SWAP_OVERLAY2=_C('WGL_SWAP_OVERLAY2',0x00000004) +WGL_SWAP_OVERLAY3=_C('WGL_SWAP_OVERLAY3',0x00000008) +WGL_SWAP_OVERLAY4=_C('WGL_SWAP_OVERLAY4',0x00000010) +WGL_SWAP_OVERLAY5=_C('WGL_SWAP_OVERLAY5',0x00000020) +WGL_SWAP_OVERLAY6=_C('WGL_SWAP_OVERLAY6',0x00000040) +WGL_SWAP_OVERLAY7=_C('WGL_SWAP_OVERLAY7',0x00000080) +WGL_SWAP_OVERLAY8=_C('WGL_SWAP_OVERLAY8',0x00000100) +WGL_SWAP_OVERLAY9=_C('WGL_SWAP_OVERLAY9',0x00000200) +WGL_SWAP_UNDERLAY1=_C('WGL_SWAP_UNDERLAY1',0x00010000) +WGL_SWAP_UNDERLAY10=_C('WGL_SWAP_UNDERLAY10',0x02000000) +WGL_SWAP_UNDERLAY11=_C('WGL_SWAP_UNDERLAY11',0x04000000) +WGL_SWAP_UNDERLAY12=_C('WGL_SWAP_UNDERLAY12',0x08000000) +WGL_SWAP_UNDERLAY13=_C('WGL_SWAP_UNDERLAY13',0x10000000) +WGL_SWAP_UNDERLAY14=_C('WGL_SWAP_UNDERLAY14',0x20000000) +WGL_SWAP_UNDERLAY15=_C('WGL_SWAP_UNDERLAY15',0x40000000) +WGL_SWAP_UNDERLAY2=_C('WGL_SWAP_UNDERLAY2',0x00020000) +WGL_SWAP_UNDERLAY3=_C('WGL_SWAP_UNDERLAY3',0x00040000) +WGL_SWAP_UNDERLAY4=_C('WGL_SWAP_UNDERLAY4',0x00080000) +WGL_SWAP_UNDERLAY5=_C('WGL_SWAP_UNDERLAY5',0x00100000) +WGL_SWAP_UNDERLAY6=_C('WGL_SWAP_UNDERLAY6',0x00200000) +WGL_SWAP_UNDERLAY7=_C('WGL_SWAP_UNDERLAY7',0x00400000) +WGL_SWAP_UNDERLAY8=_C('WGL_SWAP_UNDERLAY8',0x00800000) +WGL_SWAP_UNDERLAY9=_C('WGL_SWAP_UNDERLAY9',0x01000000) +@_f +@_p.types(_cs.c_int,_cs.HDC,ctypes.POINTER(_cs.PIXELFORMATDESCRIPTOR)) +def ChoosePixelFormat(hDc,pPfd):pass +@_f +@_p.types(_cs.c_int,_cs.HDC,_cs.c_int,_cs.UINT,ctypes.POINTER(_cs.PIXELFORMATDESCRIPTOR)) +def DescribePixelFormat(hdc,ipfd,cjpfd,ppfd):pass +@_f +@_p.types(_cs.UINT,_cs.HENHMETAFILE,ctypes.POINTER(_cs.PIXELFORMATDESCRIPTOR)) +def GetEnhMetaFilePixelFormat(hemf,ppfd):pass +@_f +@_p.types(_cs.c_int,_cs.HDC) +def GetPixelFormat(hdc):pass +@_f +@_p.types(_cs.BOOL,_cs.HDC,_cs.c_int,ctypes.POINTER(_cs.PIXELFORMATDESCRIPTOR)) +def SetPixelFormat(hdc,ipfd,ppfd):pass +@_f +@_p.types(_cs.BOOL,_cs.HDC) +def SwapBuffers(hdc):pass +@_f +@_p.types(_cs.BOOL,_cs.HGLRC,_cs.HGLRC,_cs.UINT) +def wglCopyContext(hglrcSrc,hglrcDst,mask):pass +@_f +@_p.types(_cs.HGLRC,_cs.HDC) +def wglCreateContext(hDc):pass +@_f +@_p.types(_cs.HGLRC,_cs.HDC,_cs.c_int) +def wglCreateLayerContext(hDc,level):pass +@_f +@_p.types(_cs.BOOL,_cs.HGLRC) +def wglDeleteContext(oldContext):pass +@_f +@_p.types(_cs.BOOL,_cs.HDC,_cs.c_int,_cs.c_int,_cs.UINT,ctypes.POINTER(_cs.LAYERPLANEDESCRIPTOR)) +def wglDescribeLayerPlane(hDc,pixelFormat,layerPlane,nBytes,plpd):pass +@_f +@_p.types(_cs.HGLRC,) +def wglGetCurrentContext():pass +@_f +@_p.types(_cs.HDC,) +def wglGetCurrentDC():pass +@_f +@_p.types(_cs.c_int,_cs.HDC,_cs.c_int,_cs.c_int,_cs.c_int,ctypes.POINTER(_cs.COLORREF)) +def wglGetLayerPaletteEntries(hdc,iLayerPlane,iStart,cEntries,pcr):pass +@_f +@_p.types(_cs.PROC,_cs.LPCSTR) +def wglGetProcAddress(lpszProc):pass +@_f +@_p.types(_cs.BOOL,_cs.HDC,_cs.HGLRC) +def wglMakeCurrent(hDc,newContext):pass +@_f +@_p.types(_cs.BOOL,_cs.HDC,_cs.c_int,_cs.BOOL) +def wglRealizeLayerPalette(hdc,iLayerPlane,bRealize):pass +@_f +@_p.types(_cs.c_int,_cs.HDC,_cs.c_int,_cs.c_int,_cs.c_int,ctypes.POINTER(_cs.COLORREF)) +def wglSetLayerPaletteEntries(hdc,iLayerPlane,iStart,cEntries,pcr):pass +@_f +@_p.types(_cs.BOOL,_cs.HGLRC,_cs.HGLRC) +def wglShareLists(hrcSrvShare,hrcSrvSource):pass +@_f +@_p.types(_cs.BOOL,_cs.HDC,_cs.UINT) +def wglSwapLayerBuffers(hdc,fuFlags):pass +@_f +@_p.types(_cs.BOOL,_cs.HDC,_cs.DWORD,_cs.DWORD,_cs.DWORD) +def wglUseFontBitmaps(hDC,first,count,listBase):pass +@_f +@_p.types(_cs.BOOL,_cs.HDC,_cs.DWORD,_cs.DWORD,_cs.DWORD) +def wglUseFontBitmapsA(hDC,first,count,listBase):pass +@_f +@_p.types(_cs.BOOL,_cs.HDC,_cs.DWORD,_cs.DWORD,_cs.DWORD) +def wglUseFontBitmapsW(hDC,first,count,listBase):pass +@_f +@_p.types(_cs.BOOL,_cs.HDC,_cs.DWORD,_cs.DWORD,_cs.DWORD,_cs.FLOAT,_cs.FLOAT,_cs.c_int,_cs.LPGLYPHMETRICSFLOAT) +def wglUseFontOutlines(hDC,first,count,listBase,deviation,extrusion,format,lpgmf):pass +@_f +@_p.types(_cs.BOOL,_cs.HDC,_cs.DWORD,_cs.DWORD,_cs.DWORD,_cs.FLOAT,_cs.FLOAT,_cs.c_int,_cs.LPGLYPHMETRICSFLOAT) +def wglUseFontOutlinesA(hDC,first,count,listBase,deviation,extrusion,format,lpgmf):pass +@_f +@_p.types(_cs.BOOL,_cs.HDC,_cs.DWORD,_cs.DWORD,_cs.DWORD,_cs.FLOAT,_cs.FLOAT,_cs.c_int,_cs.LPGLYPHMETRICSFLOAT) +def wglUseFontOutlinesW(hDC,first,count,listBase,deviation,extrusion,format,lpgmf):pass diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/VERSION/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/VERSION/__init__.py new file mode 100644 index 00000000..9b912d19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/VERSION/__init__.py @@ -0,0 +1 @@ +"""OpenGL Extensions""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/VERSION/__pycache__/WGL_1_0.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/VERSION/__pycache__/WGL_1_0.cpython-312.pyc new file mode 100644 index 00000000..ad141508 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/VERSION/__pycache__/WGL_1_0.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/VERSION/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/VERSION/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..fdbd39fc Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/VERSION/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..c2c0ab72 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/__pycache__/_errors.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/__pycache__/_errors.cpython-312.pyc new file mode 100644 index 00000000..c61154e5 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/__pycache__/_errors.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/__pycache__/_glgets.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/__pycache__/_glgets.cpython-312.pyc new file mode 100644 index 00000000..92d07bd9 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/__pycache__/_glgets.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/__pycache__/_types.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/__pycache__/_types.cpython-312.pyc new file mode 100644 index 00000000..c3b47f5c Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/__pycache__/_types.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/_errors.py b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/_errors.py new file mode 100644 index 00000000..815343ce --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/_errors.py @@ -0,0 +1,2 @@ +from OpenGL.platform import PLATFORM as _p +_error_checker = None diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/_glgets.py b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/_glgets.py new file mode 100644 index 00000000..76bcbaca --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/_glgets.py @@ -0,0 +1,8 @@ +"""glGet* auto-generation of output arrays (DO NOT EDIT, AUTOGENERATED)""" +try: + from OpenGL.raw.GL._lookupint import LookupInt as _L +except ImportError: + def _L(*args): + raise RuntimeError( "Need to define a lookupint for this api" ) +_glget_size_mapping = _m = {} + diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/_types.py b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/_types.py new file mode 100644 index 00000000..d265cbca --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/WGL/_types.py @@ -0,0 +1,248 @@ +from ctypes import * +from ctypes import _SimpleCData, _check_size +from OpenGL import extensions +from OpenGL.raw.GL._types import * +from OpenGL._bytes import as_8_bit +from OpenGL._opaque import opaque_pointer_cls as _opaque_pointer_cls +c_void = None + +class _WGLQuerier( extensions.ExtensionQuerier ): + prefix = b'WGL_' + assumed_version = [1,0] + version_prefix = b'WGL_VERSION_WGL_' + def pullVersion( self ): + # only one version... + return [1,0] + def pullExtensions( self ): + from OpenGL.platform import PLATFORM + wglGetCurrentDC = PLATFORM.OpenGL.wglGetCurrentDC + wglGetCurrentDC.restyle = HDC + try: + dc = wglGetCurrentDC() + proc_address = PLATFORM.getExtensionProcedure(b'wglGetExtensionsStringARB') + wglGetExtensionStringARB = PLATFORM.functionTypeFor( PLATFORM.WGL )( + c_char_p, + HDC, + )( proc_address ) + except TypeError as err: + return None + except AttributeError as err: + return [] + else: + return wglGetExtensionStringARB(dc).split() +WGLQuerier=_WGLQuerier() + +INT8 = c_char # /home/mcfletch/pylive/OpenGL-ctypes/src/wgl.h:35 +PINT8 = c_char_p # /home/mcfletch/pylive/OpenGL-ctypes/src/wgl.h:35 +INT16 = c_short # /home/mcfletch/pylive/OpenGL-ctypes/src/wgl.h:36 +PINT16 = POINTER(c_short) # /home/mcfletch/pylive/OpenGL-ctypes/src/wgl.h:36 +INT32 = c_int # /home/mcfletch/pylive/OpenGL-ctypes/src/wgl.h:37 +PINT32 = POINTER(c_int) # /home/mcfletch/pylive/OpenGL-ctypes/src/wgl.h:37 +UINT8 = c_ubyte # /home/mcfletch/pylive/OpenGL-ctypes/src/wgl.h:38 +PUINT8 = POINTER(c_ubyte) # /home/mcfletch/pylive/OpenGL-ctypes/src/wgl.h:38 +UINT16 = c_ushort # /home/mcfletch/pylive/OpenGL-ctypes/src/wgl.h:39 +PUINT16 = POINTER(c_ushort) # /home/mcfletch/pylive/OpenGL-ctypes/src/wgl.h:39 +UINT32 = c_uint # /home/mcfletch/pylive/OpenGL-ctypes/src/wgl.h:40 +PUINT32 = POINTER(c_uint) # /home/mcfletch/pylive/OpenGL-ctypes/src/wgl.h:40 +LONG32 = c_int # /home/mcfletch/pylive/OpenGL-ctypes/src/wgl.h:41 +PLONG32 = POINTER(c_int) # /home/mcfletch/pylive/OpenGL-ctypes/src/wgl.h:41 +ULONG32 = c_uint # /home/mcfletch/pylive/OpenGL-ctypes/src/wgl.h:42 +PULONG32 = POINTER(c_uint) # /home/mcfletch/pylive/OpenGL-ctypes/src/wgl.h:42 +DWORD32 = c_uint # /home/mcfletch/pylive/OpenGL-ctypes/src/wgl.h:43 +PDWORD32 = POINTER(c_uint) # /home/mcfletch/pylive/OpenGL-ctypes/src/wgl.h:43 +INT64 = c_longlong # /home/mcfletch/pylive/OpenGL-ctypes/src/wgl.h:44 +PINT64 = POINTER(c_longlong) # /home/mcfletch/pylive/OpenGL-ctypes/src/wgl.h:44 +UINT64 = c_ulonglong # /home/mcfletch/pylive/OpenGL-ctypes/src/wgl.h:45 +PUINT64 = POINTER(c_ulonglong) # /home/mcfletch/pylive/OpenGL-ctypes/src/wgl.h:45 +VOID = None # /home/mcfletch/pylive/OpenGL-ctypes/src/wgl.h:47 +LPVOID = POINTER(None) # /home/mcfletch/pylive/OpenGL-ctypes/src/wgl.h:47 +LPCSTR = c_char_p # /home/mcfletch/pylive/OpenGL-ctypes/src/wgl.h:48 +CHAR = c_char # /home/mcfletch/pylive/OpenGL-ctypes/src/wgl.h:49 +BYTE = c_ubyte # /home/mcfletch/pylive/OpenGL-ctypes/src/wgl.h:50 +WORD = c_ushort # /home/mcfletch/pylive/OpenGL-ctypes/src/wgl.h:51 +USHORT = c_ushort # /home/mcfletch/pylive/OpenGL-ctypes/src/wgl.h:51 +UINT = c_uint # /home/mcfletch/pylive/OpenGL-ctypes/src/wgl.h:52 +INT = c_int # /home/mcfletch/pylive/OpenGL-ctypes/src/wgl.h:53 +INT_PTR = POINTER(c_int) # /home/mcfletch/pylive/OpenGL-ctypes/src/wgl.h:53 +BOOL = c_long # /home/mcfletch/pylive/OpenGL-ctypes/src/wgl.h:54 +LONG = c_long # /home/mcfletch/pylive/OpenGL-ctypes/src/wgl.h:55 +DWORD = c_ulong # /home/mcfletch/pylive/OpenGL-ctypes/src/wgl.h:56 +FLOAT = c_float # /home/mcfletch/pylive/OpenGL-ctypes/src/wgl.h:57 +COLORREF = DWORD # /home/mcfletch/pylive/OpenGL-ctypes/src/wgl.h:58 +LPCOLORREF = POINTER(DWORD) # /home/mcfletch/pylive/OpenGL-ctypes/src/wgl.h:58 + +#HANDLE = POINTER(None) # /home/mcfletch/pylive/OpenGL-ctypes/src/wgl.h:60 +# TODO: figure out how to make the handle not appear as a void_p within the code... +# This decorates *every* c_void_p reference, as ctypes now reuses the references +# which means it completely disables all of the array-handing machinery +class HANDLE(_SimpleCData): + """Github Issue #8 CTypes shares all references to c_void_p + + We have to have a separate type to avoid short-circuiting all + of the array-handling machinery for real c_void_p arguments. + """ + _type_ = "P" +_check_size(HANDLE) +HANDLE.final = True + +HGLRC = HANDLE # /home/mcfletch/pylive/OpenGL-ctypes/src/wgl.h:62 +HDC = HANDLE # /home/mcfletch/pylive/OpenGL-ctypes/src/wgl.h:63 +PROC = CFUNCTYPE(INT_PTR) # /home/mcfletch/pylive/OpenGL-ctypes/src/wgl.h:65 +HPBUFFERARB = HANDLE +HPBUFFEREXT = HANDLE + +class struct__POINTFLOAT(Structure): + __slots__ = [ + 'x', + 'y', + ] +struct__POINTFLOAT._fields_ = [ + ('x', FLOAT), + ('y', FLOAT), +] + +POINTFLOAT = struct__POINTFLOAT # /home/mcfletch/pylive/OpenGL-ctypes/src/wgl.h:83 +PPOINTFLOAT = POINTER(struct__POINTFLOAT) # /home/mcfletch/pylive/OpenGL-ctypes/src/wgl.h:83 +class struct__GLYPHMETRICSFLOAT(Structure): + __slots__ = [ + 'gmfBlackBoxX', + 'gmfBlackBoxY', + 'gmfptGlyphOrigin', + 'gmfCellIncX', + 'gmfCellIncY', + ] +struct__GLYPHMETRICSFLOAT._fields_ = [ + ('gmfBlackBoxX', FLOAT), + ('gmfBlackBoxY', FLOAT), + ('gmfptGlyphOrigin', POINTFLOAT), + ('gmfCellIncX', FLOAT), + ('gmfCellIncY', FLOAT), +] + +GLYPHMETRICSFLOAT = struct__GLYPHMETRICSFLOAT # /home/mcfletch/pylive/OpenGL-ctypes/src/wgl.h:91 +PGLYPHMETRICSFLOAT = POINTER(struct__GLYPHMETRICSFLOAT) # /home/mcfletch/pylive/OpenGL-ctypes/src/wgl.h:91 +LPGLYPHMETRICSFLOAT = POINTER(struct__GLYPHMETRICSFLOAT) # /home/mcfletch/pylive/OpenGL-ctypes/src/wgl.h:91 + +class struct_tagLAYERPLANEDESCRIPTOR(Structure): + __slots__ = [ + 'nSize', + 'nVersion', + 'dwFlags', + 'iPixelType', + 'cColorBits', + 'cRedBits', + 'cRedShift', + 'cGreenBits', + 'cGreenShift', + 'cBlueBits', + 'cBlueShift', + 'cAlphaBits', + 'cAlphaShift', + 'cAccumBits', + 'cAccumRedBits', + 'cAccumGreenBits', + 'cAccumBlueBits', + 'cAccumAlphaBits', + 'cDepthBits', + 'cStencilBits', + 'cAuxBuffers', + 'iLayerPlane', + 'bReserved', + 'crTransparent', + ] +struct_tagLAYERPLANEDESCRIPTOR._fields_ = [ + ('nSize', WORD), + ('nVersion', WORD), + ('dwFlags', DWORD), + ('iPixelType', BYTE), + ('cColorBits', BYTE), + ('cRedBits', BYTE), + ('cRedShift', BYTE), + ('cGreenBits', BYTE), + ('cGreenShift', BYTE), + ('cBlueBits', BYTE), + ('cBlueShift', BYTE), + ('cAlphaBits', BYTE), + ('cAlphaShift', BYTE), + ('cAccumBits', BYTE), + ('cAccumRedBits', BYTE), + ('cAccumGreenBits', BYTE), + ('cAccumBlueBits', BYTE), + ('cAccumAlphaBits', BYTE), + ('cDepthBits', BYTE), + ('cStencilBits', BYTE), + ('cAuxBuffers', BYTE), + ('iLayerPlane', BYTE), + ('bReserved', BYTE), + ('crTransparent', COLORREF), +] + +LAYERPLANEDESCRIPTOR = struct_tagLAYERPLANEDESCRIPTOR # /home/mcfletch/pylive/OpenGL-ctypes/src/wgl.h:127 +PLAYERPLANEDESCRIPTOR = POINTER(struct_tagLAYERPLANEDESCRIPTOR) # /home/mcfletch/pylive/OpenGL-ctypes/src/wgl.h:127 +LPLAYERPLANEDESCRIPTOR = POINTER(struct_tagLAYERPLANEDESCRIPTOR) # /home/mcfletch/pylive/OpenGL-ctypes/src/wgl.h:127 + +class struct__WGLSWAP(Structure): + __slots__ = [ + 'hdc', + 'uiFlags', + ] +struct__WGLSWAP._fields_ = [ + ('hdc', HDC), + ('uiFlags', UINT), +] + +WGLSWAP = struct__WGLSWAP # /home/mcfletch/pylive/OpenGL-ctypes/src/wgl.h:190 +PWGLSWAP = POINTER(struct__WGLSWAP) # /home/mcfletch/pylive/OpenGL-ctypes/src/wgl.h:190 +LPWGLSWAP = POINTER(struct__WGLSWAP) # /home/mcfletch/pylive/OpenGL-ctypes/src/wgl.h:190 + +class struct_tagRECT(Structure): + __slots__ = [ + 'left', + 'top', + 'right', + 'bottom', + ] +struct_tagRECT._fields_ = [ + ('left', LONG), + ('top', LONG), + ('right', LONG), + ('bottom', LONG), +] + +RECT = struct_tagRECT # /home/mcfletch/pylive/OpenGL-ctypes/src/wgl.h:202 +PRECT = POINTER(struct_tagRECT) # /home/mcfletch/pylive/OpenGL-ctypes/src/wgl.h:202 +NPRECT = POINTER(struct_tagRECT) # /home/mcfletch/pylive/OpenGL-ctypes/src/wgl.h:202 +LPRECT = POINTER(struct_tagRECT) # /home/mcfletch/pylive/OpenGL-ctypes/src/wgl.h:202 + +class PIXELFORMATDESCRIPTOR(Structure): + _fields_ = [ + ('nSize',WORD), + ('nVersion',WORD), + ('dwFlags',DWORD), + ('iPixelType',BYTE), + ('cColorBits',BYTE), + ('cRedBits',BYTE), + ('cRedShift',BYTE), + ('cGreenBits',BYTE), + ('cGreenShift',BYTE), + ('cBlueBits',BYTE), + ('cBlueShift',BYTE), + ('cAlphaBits',BYTE), + ('cAlphaShift',BYTE), + ('cAccumBits',BYTE), + ('cAccumRedBits',BYTE), + ('cAccumGreenBits',BYTE), + ('cAccumBlueBits',BYTE), + ('cAccumAlphaBits',BYTE), + ('cAccumDepthBits',BYTE), + ('cAccumStencilBits',BYTE), + ('cAuxBuffers',BYTE), + ('iLayerType',BYTE), + ('bReserved',BYTE), + ('dwLayerMask',DWORD), + ('dwVisibleMask',DWORD), + ('dwDamageMask',DWORD), + ] + +# TODO: This is *not* a working definition, calling any function with this will segfault +HENHMETAFILE = _opaque_pointer_cls( 'HENHMETAFILE' ) diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/raw/__init__.py new file mode 100644 index 00000000..a0113861 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/__init__.py @@ -0,0 +1,6 @@ +"""C-style "raw" API for low-level ctypes-specific access to OpenGL + +This sub-package is autogenerated using a customised version +of the ctypes codegenerator package (see src/openglgenerator.py and +src/generateraw.py). +""" \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..cdfefd32 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/osmesa/__init__.py b/venv/lib/python3.12/site-packages/OpenGL/raw/osmesa/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/osmesa/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/osmesa/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..a017c89a Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/osmesa/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/osmesa/__pycache__/_types.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/osmesa/__pycache__/_types.cpython-312.pyc new file mode 100644 index 00000000..f96b7851 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/osmesa/__pycache__/_types.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/osmesa/__pycache__/mesa.cpython-312.pyc b/venv/lib/python3.12/site-packages/OpenGL/raw/osmesa/__pycache__/mesa.cpython-312.pyc new file mode 100644 index 00000000..cadfc8e5 Binary files /dev/null and b/venv/lib/python3.12/site-packages/OpenGL/raw/osmesa/__pycache__/mesa.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/osmesa/_types.py b/venv/lib/python3.12/site-packages/OpenGL/raw/osmesa/_types.py new file mode 100644 index 00000000..d869bf26 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/osmesa/_types.py @@ -0,0 +1,11 @@ +import ctypes +from OpenGL import _opaque +GLenum = ctypes.c_uint +GLboolean = ctypes.c_ubyte +GLsizei = ctypes.c_int +GLint = ctypes.c_int +OSMesaContext = _opaque.opaque_pointer_cls( 'OSMesaContext' ) + +__all__ = [ + 'OSMesaContext', +] diff --git a/venv/lib/python3.12/site-packages/OpenGL/raw/osmesa/mesa.py b/venv/lib/python3.12/site-packages/OpenGL/raw/osmesa/mesa.py new file mode 100644 index 00000000..a2c6cdb1 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/raw/osmesa/mesa.py @@ -0,0 +1,133 @@ +from OpenGL import arrays +from OpenGL.raw.GL._types import GLenum,GLboolean,GLsizei,GLint,GLuint +from OpenGL.raw.osmesa._types import * +from OpenGL.constant import Constant as _C +from OpenGL import platform as _p +import ctypes + +def _f( function ): + return _p.createFunction( + function,_p.PLATFORM.OSMesa, + None, + error_checker=None + ) + +OSMESA_COLOR_INDEX = _C('OSMESA_COLOR_INDEX', 6400) +OSMESA_RGBA = _C('OSMESA_RGBA', 6408) +OSMESA_BGRA = _C('OSMESA_BGRA', 0x1) +OSMESA_ARGB = _C('OSMESA_ARGB', 0x2) +OSMESA_RGB = _C('OSMESA_RGB', 6407) +OSMESA_BGR = _C('OSMESA_BGR', 0x4) +OSMESA_RGB_565 = _C('OSMESA_BGR', 0x5) +OSMESA_ROW_LENGTH = _C('OSMESA_ROW_LENGTH', 0x10) +OSMESA_Y_UP = _C('OSMESA_Y_UP', 0x11) +OSMESA_WIDTH = _C('OSMESA_WIDTH', 0x20) +OSMESA_HEIGHT = _C('OSMESA_HEIGHT', 0x21) +OSMESA_FORMAT = _C('OSMESA_FORMAT', 0x22) +OSMESA_TYPE = _C('OSMESA_TYPE', 0x23) +OSMESA_MAX_WIDTH = _C('OSMESA_MAX_WIDTH', 0x24) +OSMESA_MAX_HEIGHT = _C('OSMESA_MAX_HEIGHT', 0x25) +OSMESA_DEPTH_BITS = _C('OSMESA_DEPTH_BITS', 0x30) +OSMESA_STENCIL_BITS = _C('OSMESA_STENCIL_BITS', 0x31) +OSMESA_ACCUM_BITS = _C('OSMESA_ACCUM_BITS', 0x32) +OSMESA_PROFILE = _C('OSMESA_PROFILE', 0x33) +OSMESA_CORE_PROFILE = _C('OSMESA_CORE_PROFILE', 0x34) +OSMESA_COMPAT_PROFILE = _C('OSMESA_CORE_PROFILE', 0x35) +OSMESA_CONTEXT_MAJOR_VERSION = _C('OSMESA_CONTEXT_MAJOR_VERSION', 0x36) +OSMESA_CONTEXT_MINOR_VERSION = _C('OSMESA_CONTEXT_MINOR_VERSION', 0x37) + +OSMesaGetCurrentContext = _p.GetCurrentContext + +@_f +@_p.types(OSMesaContext,GLenum, OSMesaContext) +def OSMesaCreateContext(format,sharelist): pass + +@_f +@_p.types(OSMesaContext,GLenum, GLint, GLint, GLint, OSMesaContext) +def OSMesaCreateContextExt(format, depthBits, stencilBits,accumBits,sharelist ): pass + +@_f +@_p.types(OSMesaContext,arrays.GLintArray, OSMesaContext) +def OSMesaCreateContextAttribs(attribList,sharelist ): pass + +@_f +@_p.types(None, OSMesaContext) +def OSMesaDestroyContext(ctx): pass + +@_f +@_p.types(GLboolean, OSMesaContext, ctypes.POINTER(None), GLenum, GLsizei, GLsizei ) +def OSMesaMakeCurrent( ctx, buffer, type,width,height ): pass + +@_f +@_p.types(None, GLint, GLint ) +def OSMesaPixelStore( ctx, buffer, type,width,height ): pass + +def OSMesaGetIntegerv(pname): + value = GLint() + _p.PLATFORM.GL.OSMesaGetIntegerv(pname, ctypes.byref(value)) + return value.value + +def OSMesaGetDepthBuffer(c): + width, height, bytesPerValue = GLint(), GLint(), GLint() + buffer = ctypes.POINTER(GLint)() + + if _p.PLATFORM.GL.OSMesaGetDepthBuffer(c, ctypes.byref(width), + ctypes.byref(height), + ctypes.byref(bytesPerValue), + ctypes.byref(buffer)): + return width.value, height.value, bytesPerValue.value, buffer + else: + return 0, 0, 0, None + +def OSMesaGetColorBuffer(c): + # TODO: make output array types which can handle the operation + # provide an API to convert pointers + sizes to array instances, + # e.g. numpy.ctypeslib.as_array( ptr, bytesize ).astype( 'B' ).reshape( height,width ) + width, height, format = GLint(), GLint(), GLint() + buffer = ctypes.c_void_p() + + if _p.PLATFORM.GL.OSMesaGetColorBuffer(c, ctypes.byref(width), + ctypes.byref(height), + ctypes.byref(format), + ctypes.byref(buffer)): + return width.value, height.value, format.value, buffer + else: + return 0, 0, 0, None + +@_f +@_p.types(GLboolean) +def OSMesaColorClamp(enable): + """Enable/disable color clamping, off by default + + New in Mesa 6.4.2 + """ + +@_f +@_p.types(OSMesaContext, arrays.GLcharArray, GLuint) +def OSMesaPostprocess(osmesa, filter, enable_value): + """Enable/disable Gallium post-process filters. + + This should be called after a context is created, but before it is + made current for the first time. After a context has been made + current, this function has no effect. + + If the enable_value param is zero, the filter is disabled. Otherwise + the filter is enabled, and the value may control the filter's quality. + New in Mesa 10.0 + """ + + +__all__ = [ + 'OSMesaCreateContext', + 'OSMesaCreateContextExt', 'OSMesaMakeCurrent', 'OSMesaGetIntegerv', + 'OSMesaGetCurrentContext', 'OSMesaDestroyContext', 'OSMesaPixelStore', + 'OSMesaGetDepthBuffer', 'OSMesaGetColorBuffer', 'OSMesaCreateContextAttribs', + 'OSMesaColorClamp','OSMesaPostprocess', + 'OSMESA_COLOR_INDEX', 'OSMESA_RGBA', 'OSMESA_BGRA', 'OSMESA_ARGB', + 'OSMESA_RGB', 'OSMESA_BGR', 'OSMESA_BGR', 'OSMESA_ROW_LENGTH', + 'OSMESA_Y_UP', 'OSMESA_WIDTH', 'OSMESA_HEIGHT', 'OSMESA_FORMAT', + 'OSMESA_TYPE', 'OSMESA_MAX_WIDTH', 'OSMESA_MAX_HEIGHT', + 'OSMESA_DEPTH_BITS', 'OSMESA_STENCIL_BITS', 'OSMESA_ACCUM_BITS', + 'OSMESA_PROFILE', 'OSMESA_CORE_PROFILE', 'OSMESA_COMPAT_PROFILE', + 'OSMESA_CONTEXT_MAJOR_VERSION', 'OSMESA_CONTEXT_MINOR_VERSION' +] diff --git a/venv/lib/python3.12/site-packages/OpenGL/version.py b/venv/lib/python3.12/site-packages/OpenGL/version.py new file mode 100644 index 00000000..cf5d50fe --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/version.py @@ -0,0 +1,2 @@ +"""Declares the current version for use in setuptools and the like""" +__version__ = "3.1.7" diff --git a/venv/lib/python3.12/site-packages/OpenGL/wrapper.py b/venv/lib/python3.12/site-packages/OpenGL/wrapper.py new file mode 100644 index 00000000..44a6f467 --- /dev/null +++ b/venv/lib/python3.12/site-packages/OpenGL/wrapper.py @@ -0,0 +1,1516 @@ +"""The wrapping code for providing natural ctypes-based OpenGL interface""" +import ctypes, logging +from OpenGL import platform, error +assert platform +from OpenGL._configflags import STORE_POINTERS, ERROR_ON_COPY, SIZE_1_ARRAY_UNPACK +from OpenGL import converters +from OpenGL.converters import DefaultCConverter +from OpenGL.converters import returnCArgument,returnPyArgument +from OpenGL.latebind import LateBind +from OpenGL.arrays import arrayhelpers, arraydatatype +from OpenGL._null import NULL +_log = logging.getLogger( 'OpenGL.wrapper' ) + +from OpenGL import acceleratesupport +cWrapper = None +if acceleratesupport.ACCELERATE_AVAILABLE: + try: + from OpenGL_accelerate.latebind import LateBind + from OpenGL_accelerate.wrapper import ( + Wrapper as cWrapper, + CArgCalculator, + PyArgCalculator, + CArgumentCalculator, + MultiReturn, + ) + except ImportError as err: + _log.warning( """OpenGL_accelerate seems to be installed, but unable to import expected wrapper entry points!""" ) + +if not STORE_POINTERS: + if not ERROR_ON_COPY: + _log.error( """You've specified (not STORE_POINTERS) yet ERROR_ON_COPY is False, this would cause segfaults, so (not STORE_POINTERS) is being ignored""" ) + STORE_POINTERS = True + + +def asList( o ): + """Convert to a list if not already one""" + if not isinstance( o, list ): + return list(o) + return o + +def none_or_pass( incoming, function, arguments ): + return incoming +none_or_pass.optional=True + +class Wrapper( LateBind ): + """Wrapper around a ctypes cFunction object providing SWIG-like hooks + + Attributes: + + wrappedOperation -- base operation, normally a ctypes function + with data-types and error-checking specified + pyConverters -- converters for incoming Python arguments, + provide 1:1 mapping to incoming Python arguments, can + suppress an argument from the argument-set as well + see setPyConverter + pyConverterNames -- caching/storage of the argument names + for the Python converters + cConverters -- converters for incoming C-level arguments + produce Python-level objects in 1:1 mapping to ctypes + arguments from pyConverters results + see setCConverter + cResolvers -- converters turning Python-level objects into + ctypes-compatible data-types + see setCResolver + + Generic Attributes: + + {ARG1}_LOOKUP_{ARG2} -- lookup dictionaries to provide sizes for + ARG1 output value from the value of ARG2, provided for + documentation/reference + {ARG1}_FROM_{ARG2} -- lookup functions to provide sizes for ARG1 + output value from the value of ARG2, provided for + documentation/reference + """ + localProperties = ( + 'wrappedOperation', + '__file__', + 'pyConverters', + 'pyConverterNames', + 'cConverters', + 'cResolvers', + 'storeValues', + 'returnValues', + '_finalCall', + ) + def __init__( self, wrappedOperation ): + """Initialise the wrapper, storing wrappedOperation""" + if isinstance( wrappedOperation, Wrapper ): + wrappedOperation = wrappedOperation.wrappedOperation + self.wrappedOperation = wrappedOperation + def __getattr__( self, key ): + """Delegate attribute lookup to our wrappedOperation""" + if key != 'wrappedOperation': + return getattr( self.wrappedOperation, key ) + raise AttributeError( key ) + def __nonzero__( self ): + """Is this function/wrapper available?""" + return bool( self.wrappedOperation ) + __bool__ = __nonzero__ + def __setattr__( self, key, value ): + """Forward attribute setting to our wrappedOperation""" + if key in self.localProperties: + super( Wrapper, self ).__setattr__( key, value ) + else: + return setattr( self.wrappedOperation, key, value ) + def pyArgIndex( self, argName ): + """Return the Python-argument index for the given argument name""" + argNames = getattr( self, 'pyConverterNames', None ) + if argNames is None: + argNames = self.wrappedOperation.argNames + try: + return asList( argNames ).index( argName ) + except (ValueError,IndexError): + raise KeyError( """No argument %r in argument list %r"""%( + argName, argNames + )) + def cArgIndex( self, argName ): + """Return the C-argument index for the given argument name""" + argNames = self.wrappedOperation.argNames + try: + return asList( argNames ).index( argName ) + except (ValueError,IndexError): + raise KeyError( """No argument %r in argument list %r"""%( + argName, argNames + )) + def setOutput( + self, outArg, size=(1,), pnameArg=None, + arrayType=None, oldStyleReturn=SIZE_1_ARRAY_UNPACK, + orPassIn = False, + ): + """Set the given argName to be an output array + + size -- either a tuple compatible with arrayType.zeros or + a function taking pname to produce such a value. + arrayType -- array data-type used to generate the output + array using the zeros class method... + pnameArg -- optional argument passed into size function, that + is, the name of the argument whose *value* will be passed + to the size function, often the name of an input argument + to be "sized" to match the output argument. + """ + if arrayType is None: + # figure out from self.wrappedOperation's argtypes + index = self.cArgIndex( outArg ) + arrayType = self.wrappedOperation.argtypes[ index ] + if not hasattr( arrayType, 'asArray' ): + if arrayType == ctypes.c_void_p: + from OpenGL.arrays import GLubyteArray + arrayType = GLubyteArray + else: + raise TypeError( "Should only have array types for output parameters %s on %s is %r"%( + outArg, self.wrappedOperation.__name__, arrayType, + ) ) + if pnameArg is None: + assert not hasattr(size,'__call__' ) + if orPassIn: + cls = converters.OutputOrInput + else: + cls = converters.Output + conv = cls( + name=outArg, + size=size, + arrayType=arrayType, + ) + else: + if isinstance( size, dict ): + setattr( self, '%s_LOOKUP_%s'%(outArg,pnameArg), size ) + size = size.__getitem__ + else: + setattr( self, '%s_FROM_%s'%(outArg,pnameArg), size ) + assert hasattr( size, '__call__' ) + if orPassIn: + cls = converters.SizedOutputOrInput + else: + cls = converters.SizedOutput + conv = cls( + name=outArg, + specifier=pnameArg, + lookup=size, + arrayType=arrayType, + ) + if oldStyleReturn: + returnObject = conv.oldStyleReturn + else: + returnObject = converters.returnCArgument( outArg ) + if orPassIn: + self.setPyConverter( + outArg, none_or_pass + ) + else: + self.setPyConverter( outArg ) + return self.setCConverter( + outArg, conv, + ).setReturnValues( + returnObject + ) + def typeOfArg( self, outArg ): + """Retrieve the defined data-type for the given outArg (name)""" + index = self.cArgIndex( outArg ) + return self.wrappedOperation.argtypes[ index ] + + if not ERROR_ON_COPY: + def setInputArraySize( self, argName, size=None ): + """Decorate function with vector-handling code for a single argument + + if OpenGL.ERROR_ON_COPY is False, then we return the + named argument, converting to the passed array type, + optionally checking that the array matches size. + + if OpenGL.ERROR_ON_COPY is True, then we will dramatically + simplify this function, only wrapping if size is True, i.e. + only wrapping if we intend to do a size check on the array. + """ + arrayType = self.typeOfArg( argName ) + if not hasattr( arrayType, 'asArray' ): + if arrayType == ctypes.c_void_p: + # special case, we will convert to a void * array... + self.setPyConverter( + argName, + converters.CallFuncPyConverter( arraydatatype.ArrayDatatype.asArray ) + ) + self.setCConverter( argName, converters.getPyArgsName( argName ) ) + return self + elif hasattr( arrayType, '_type_' ) and hasattr(arrayType._type_, '_type_' ): + # is a ctypes array-of-pointers data-type... + # requires special handling no matter what... + return self + else: + raise TypeError( "Should only have array types for output parameters: got %s"%(arrayType,) ) + if size is not None: + self.setPyConverter( argName, arrayhelpers.asArrayTypeSize(arrayType, size) ) + else: + self.setPyConverter( argName, arrayhelpers.asArrayType(arrayType) ) + self.setCConverter( argName, converters.getPyArgsName( argName ) ) + return self + else: + def setInputArraySize( self, argName, size=None ): + """Decorate function with vector-handling code for a single argument + + if OpenGL.ERROR_ON_COPY is False, then we return the + named argument, converting to the passed array type, + optionally checking that the array matches size. + + if OpenGL.ERROR_ON_COPY is True, then we will dramatically + simplify this function, only wrapping if size is True, i.e. + only wrapping if we intend to do a size check on the array. + """ + if size is not None: + arrayType = self.typeOfArg( argName ) + # return value is always the source array... + if hasattr( arrayType, 'asArray' ): + self.setPyConverter( argName, arrayhelpers.asArrayTypeSize(arrayType, size) ) + self.setCConverter( argName, + converters.getPyArgsName( argName ) + ) + return self + + def setPyConverter( self, argName, function = NULL ): + """Set Python-argument converter for given argument + + argName -- the argument name which will be coerced to a usable internal + format using the function provided. + function -- None (indicating a simple copy), NULL (default) to eliminate + the argument from the Python argument-list, or a callable object with + the signature: + + converter(arg, wrappedOperation, args) + + where arg is the particular argument on which the convert is working, + wrappedOperation is the underlying wrapper, and args is the set of + original Python arguments to the function. + + Note that you need exactly the same number of pyConverters as Python + arguments. + """ + if not hasattr( self, 'pyConverters' ): + self.pyConverters = [None]*len( self.wrappedOperation.argNames ) + self.pyConverterNames = list(self.wrappedOperation.argNames) + try: + i = asList( self.pyConverterNames ).index( argName ) + except ValueError: + raise AttributeError( """No argument named %r left in pyConverters for %r: %s"""%( + argName, self.wrappedOperation.__name__, self.pyConverterNames, + )) + if function is NULL: + del self.pyConverters[i] + del self.pyConverterNames[i] + else: + self.pyConverters[i] = function + return self + def setCConverter( self, argName, function ): + """Set C-argument converter for a given argument + + argName -- the argument name whose C-compatible representation will + be calculated with the passed function. + function -- None (indicating a simple copy), a non-callable object to + be copied into the result-list itself, or a callable object with + the signature: + + converter( pyArgs, index, wrappedOperation ) + + where pyArgs is the set of passed Python arguments, with the + pyConverters already applied, index is the index of the C argument + and wrappedOperation is the underlying function. + + C-argument converters are your chance to expand/contract a Python + argument list (pyArgs) to match the number of arguments expected by + the ctypes baseOperation. You can't have a "null" C-argument converter, + as *something* has to be passed to the C-level function in the + parameter. + """ + if not hasattr( self, 'cConverters' ): + self.cConverters = [None]*len( self.wrappedOperation.argNames ) + try: + if not isinstance(self.wrappedOperation.argNames, list): + self.wrappedOperation.argNames = list( self.wrappedOperation.argNames ) + i = asList( self.wrappedOperation.argNames ).index( argName ) + except ValueError: + raise AttributeError( """No argument named %r left in cConverters: %s"""%( + argName, self.wrappedOperation.argNames, + )) + if self.cConverters[i] is not None: + raise RuntimeError("Double wrapping of output parameter: %r on %s"%( + argName, self.__name__ + )) + self.cConverters[i] = function + return self + def setCResolver( self, argName, function=NULL ): + """Set C-argument converter for a given argument""" + if not hasattr( self, 'cResolvers' ): + self.cResolvers = [None]*len( self.wrappedOperation.argNames ) + try: + if not isinstance(self.wrappedOperation.argNames, list): + self.wrappedOperation.argNames = list( self.wrappedOperation.argNames ) + i = asList( self.wrappedOperation.argNames).index( argName ) + except ValueError: + raise AttributeError( """No argument named %r left in cConverters: %s"""%( + argName, self.wrappedOperation.argNames, + )) + if function is NULL: + del self.cResolvers[i] + else: + self.cResolvers[i] = function + return self + def setStoreValues( self, function=NULL ): + """Set the storage-of-arguments function for the whole wrapper""" + if function is NULL or ERROR_ON_COPY and not STORE_POINTERS: + try: + del self.storeValues + except Exception: + pass + else: + self.storeValues = function + return self + def setReturnValues( self, function=NULL ): + """Set the return-of-results function for the whole wrapper""" + if function is NULL: + try: + del self.returnValues + except Exception: + pass + else: + if hasattr(self,'returnValues'): + if isinstance(self.returnValues,MultiReturn): + self.returnValues.append( function ) + else: + self.returnValues = MultiReturn( self.returnValues, function ) + else: + self.returnValues = function + return self + + def finalise( self ): + """Finalise our various elements into simple index-based operations""" + for attribute in ('pyConverters','cConverters','cResolvers' ): + value = getattr( self, attribute, None ) + if value is not None: + for i,item in enumerate(value): + if hasattr( item, 'finalise' ): + try: + item.finalise( self ) + except Exception as err: + raise error.Error( + """Error finalising item %s in %s for %s (%r): %s"""%( + i,attribute,self,item,err, + ) + ) + if hasattr( self, 'cConverters' ): + for i,converter in enumerate( self.cConverters ): + if isinstance( converter, (type(None),DefaultCConverter )): + self.cConverters[i] = DefaultCConverter( self.pyArgIndex( self.argNames[i]) ) + for attribute in ('storeValues','returnValues',): + item = getattr( self, attribute, None ) + if hasattr( item, 'finalise' ): + item.finalise( self ) + callFunction = self.finaliseCall() + if not callFunction: + raise RuntimeError( """Missing finalised call type for %s"""%( self, )) + else: + #self.__class__.finalize = lambda *args: callFunction + #self.__call__ = callFunction + #self.__class__.__call__ = callFunction + #self.__class__.set_call( callFunction ) + #self.__class__.__dict__[ '__call__' ] = callFunction + #print 'setting class call', callFunction + self.setFinalCall( callFunction ) + return callFunction + #return self + def finaliseCall( self ): + """Produce specialised versions of call for finalised wrapper object + + This returns a version of __call__ that only does that work which is + required by the particular wrapper object + + This is essentially a huge set of expanded nested functions, very + inelegant... + """ + pyConverters = getattr( self, 'pyConverters', None ) + cConverters = getattr( self, 'cConverters', None ) + cResolvers = getattr( self, 'cResolvers', None ) + wrappedOperation = self.wrappedOperation + storeValues = getattr( self, 'storeValues', None ) + returnValues = getattr( self, 'returnValues', None ) + if pyConverters: + if cWrapper: + calculate_pyArgs = PyArgCalculator( + self,pyConverters, + ) + else: + pyConverters_mapped = [ + (i,converter,(converter is None)) + for (i,converter) in enumerate( pyConverters ) + ] + pyConverters_length = len([p for p in pyConverters if not getattr( p, 'optional', False)]) + def calculate_pyArgs( args ): + if pyConverters_length > len(args): + raise ValueError( + """%s requires %r arguments (%s), received %s: %r"""%( + wrappedOperation.__name__, + pyConverters_length, + ", ".join( self.pyConverterNames ), + len(args), + args + ) + ) + for index,converter,isNone in pyConverters_mapped: + if isNone: + yield args[index] + else: + try: + yield converter(args[index], self, args) + except IndexError as err: + yield NULL + except Exception as err: + if hasattr( err, 'args' ): + err.args += ( converter, ) + raise + else: + calculate_pyArgs = None + if cConverters: + if cWrapper: + calculate_cArgs = CArgCalculator( self, cConverters ) + else: + cConverters_mapped = [ + (i,converter,hasattr(converter,'__call__')) + for (i,converter) in enumerate( cConverters ) + ] + def calculate_cArgs( pyArgs ): + for index,converter,canCall in cConverters_mapped: + if canCall: + try: + yield converter( pyArgs, index, self ) + except Exception as err: + if hasattr( err, 'args' ): + err.args += ( + """Failure in cConverter %r"""%(converter), + pyArgs, index, self, + ) + raise + else: + yield converter + else: + calculate_cArgs = None + if cResolvers: + if cWrapper: + calculate_cArguments = CArgumentCalculator( cResolvers ) + else: + cResolvers_mapped = list(enumerate(cResolvers)) + def calculate_cArguments( cArgs ): + for i,converter in cResolvers_mapped: + if converter is None: + yield cArgs[i] + else: + try: + yield converter( cArgs[i] ) + except Exception as err: + err.args += (converter,) + raise + else: + calculate_cArguments = None + if cWrapper: + return cWrapper( + wrappedOperation, + calculate_pyArgs=calculate_pyArgs, + calculate_cArgs=calculate_cArgs, + calculate_cArguments=calculate_cArguments, + storeValues=storeValues, + returnValues=returnValues, + ) + if pyConverters: + if cConverters: + # create a map of index,converter, callable + if cResolvers: + if storeValues: + if returnValues: + def wrapperCall( *args ): + """Wrapper with all possible operations""" + pyArgs = tuple( calculate_pyArgs( args )) + cArgs = tuple(calculate_cArgs( pyArgs )) + cArguments = tuple(calculate_cArguments( cArgs )) + try: + result = wrappedOperation( *cArguments ) + except ctypes.ArgumentError as err: + err.args = err.args + (cArguments,) + raise err + except error.GLError as err: + err.cArgs = cArgs + err.pyArgs = pyArgs + raise err + # handle storage of persistent argument values... + storeValues( + result, + self, + pyArgs, + cArgs, + ) + return returnValues( + result, + self, + pyArgs, + cArgs, + ) + return wrapperCall + else: + def wrapperCall( *args ): + """Wrapper with all save returnValues""" + pyArgs = tuple( calculate_pyArgs( args )) + cArgs = tuple(calculate_cArgs( pyArgs )) + cArguments = tuple(calculate_cArguments( cArgs )) + try: + result = wrappedOperation( *cArguments ) + except ctypes.ArgumentError as err: + err.args = err.args + (cArguments,) + raise err + except error.GLError as err: + err.cArgs = cArgs + err.pyArgs = pyArgs + raise err + # handle storage of persistent argument values... + storeValues( + result, + self, + pyArgs, + cArgs, + ) + return result + return wrapperCall + else: # null storeValues + if returnValues: + def wrapperCall( *args ): + """Wrapper with all save storeValues""" + pyArgs = tuple( calculate_pyArgs( args )) + cArgs = tuple(calculate_cArgs( pyArgs )) + cArguments = tuple(calculate_cArguments( cArgs )) + try: + result = wrappedOperation( *cArguments ) + except ctypes.ArgumentError as err: + err.args = err.args + (cArguments,) + raise err + except error.GLError as err: + err.cArgs = cArgs + err.pyArgs = pyArgs + raise err + return returnValues( + result, + self, + pyArgs, + cArgs, + ) + return wrapperCall + else: + def wrapperCall( *args ): + """Wrapper with all save returnValues and storeValues""" + pyArgs = tuple( calculate_pyArgs( args )) + cArgs = tuple(calculate_cArgs( pyArgs )) + cArguments = tuple(calculate_cArguments( cArgs )) + try: + result = wrappedOperation( *cArguments ) + except ctypes.ArgumentError as err: + err.args = err.args + (cArguments,) + raise err + except error.GLError as err: + err.cArgs = cArgs + err.pyArgs = pyArgs + raise err + return result + return wrapperCall + else: + # null cResolvers + if storeValues: + if returnValues: + def wrapperCall( *args ): + """Wrapper with all possible operations""" + pyArgs = tuple( calculate_pyArgs( args )) + cArgs = tuple(calculate_cArgs( pyArgs )) + cArguments = cArgs + try: + result = wrappedOperation( *cArguments ) + except ctypes.ArgumentError as err: + err.args = err.args + (cArguments,) + raise err + except error.GLError as err: + err.cArgs = cArgs + err.pyArgs = pyArgs + raise err + # handle storage of persistent argument values... + storeValues( + result, + self, + pyArgs, + cArgs, + ) + return returnValues( + result, + self, + pyArgs, + cArgs, + ) + return wrapperCall + else: + def wrapperCall( *args ): + """Wrapper with all save returnValues""" + pyArgs = tuple( calculate_pyArgs( args )) + cArgs = tuple(calculate_cArgs( pyArgs )) + cArguments = cArgs + try: + result = wrappedOperation( *cArguments ) + except ctypes.ArgumentError as err: + err.args = err.args + (cArguments,) + raise err + except error.GLError as err: + err.cArgs = cArgs + err.pyArgs = pyArgs + raise err + # handle storage of persistent argument values... + storeValues( + result, + self, + pyArgs, + cArgs, + ) + return result + return wrapperCall + else: # null storeValues + if returnValues: + def wrapperCall( *args ): + """Wrapper with all save storeValues""" + pyArgs = tuple( calculate_pyArgs( args )) + cArgs = tuple(calculate_cArgs( pyArgs )) + cArguments = cArgs + try: + result = wrappedOperation( *cArguments ) + except ctypes.ArgumentError as err: + err.args = err.args + (cArguments,) + raise + except error.GLError as err: + err.cArgs = cArgs + err.pyArgs = pyArgs + raise err + return returnValues( + result, + self, + pyArgs, + cArgs, + ) + return wrapperCall + else: + def wrapperCall( *args ): + """Wrapper with all save returnValues and storeValues""" + pyArgs = tuple( calculate_pyArgs( args )) + cArgs = tuple(calculate_cArgs( pyArgs )) + cArguments = cArgs + try: + result = wrappedOperation( *cArguments ) + except ctypes.ArgumentError as err: + err.args = err.args + (cArguments,) + raise + except error.GLError as err: + err.cArgs = cArgs + err.pyArgs = pyArgs + raise err + return result + return wrapperCall + else: + # null cConverters + if cResolvers: + if storeValues: + if returnValues: + def wrapperCall( *args ): + """Wrapper with all possible operations""" + pyArgs = tuple( calculate_pyArgs( args )) + cArgs = pyArgs + cArguments = tuple(calculate_cArguments( cArgs )) + try: + result = wrappedOperation( *cArguments ) + except ctypes.ArgumentError as err: + err.args = err.args + (cArguments,) + raise err + except error.GLError as err: + err.cArgs = cArgs + err.pyArgs = pyArgs + raise err + # handle storage of persistent argument values... + storeValues( + result, + self, + pyArgs, + cArgs, + ) + return returnValues( + result, + self, + pyArgs, + cArgs, + ) + return wrapperCall + else: + def wrapperCall( *args ): + """Wrapper with all save returnValues""" + pyArgs = tuple( calculate_pyArgs( args )) + cArgs = pyArgs + cArguments = tuple(calculate_cArguments( cArgs )) + try: + result = wrappedOperation( *cArguments ) + except ctypes.ArgumentError as err: + err.args = err.args + (cArguments,) + raise err + except error.GLError as err: + err.cArgs = cArgs + err.pyArgs = pyArgs + raise err + # handle storage of persistent argument values... + storeValues( + result, + self, + pyArgs, + cArgs, + ) + return result + return wrapperCall + else: # null storeValues + if returnValues: + def wrapperCall( *args ): + """Wrapper with all save storeValues""" + pyArgs = tuple( calculate_pyArgs( args )) + cArgs = pyArgs + cArguments = tuple(calculate_cArguments( cArgs )) + try: + result = wrappedOperation( *cArguments ) + except ctypes.ArgumentError as err: + err.args = err.args + (cArguments,) + raise err + except error.GLError as err: + err.cArgs = cArgs + err.pyArgs = pyArgs + raise err + return returnValues( + result, + self, + pyArgs, + cArgs, + ) + return wrapperCall + else: + def wrapperCall( *args ): + """Wrapper with all save returnValues and storeValues""" + pyArgs = tuple( calculate_pyArgs( args )) + cArgs = pyArgs + cArguments = tuple(calculate_cArguments( cArgs )) + try: + result = wrappedOperation( *cArguments ) + except ctypes.ArgumentError as err: + err.args = err.args + (cArguments,) + raise err + except error.GLError as err: + err.cArgs = cArgs + err.pyArgs = pyArgs + raise err + return result + return wrapperCall + else: + # null cResolvers + if storeValues: + if returnValues: + def wrapperCall( *args ): + """Wrapper with all possible operations""" + pyArgs = tuple( calculate_pyArgs( args )) + cArguments = pyArgs + try: + result = wrappedOperation( *cArguments ) + except ctypes.ArgumentError as err: + err.args = err.args + (cArguments,) + raise err + except error.GLError as err: + err.cArgs = cArguments + err.pyArgs = pyArgs + raise err + # handle storage of persistent argument values... + storeValues( + result, + self, + pyArgs, + cArguments, + ) + return returnValues( + result, + self, + pyArgs, + cArguments, + ) + return wrapperCall + else: + def wrapperCall( *args ): + """Wrapper with all save returnValues""" + pyArgs = tuple( calculate_pyArgs( args )) + cArguments = pyArgs + try: + result = wrappedOperation( *cArguments ) + except ctypes.ArgumentError as err: + err.args = err.args + (cArguments,) + raise err + except error.GLError as err: + err.cArgs = cArguments + err.pyArgs = pyArgs + raise err + # handle storage of persistent argument values... + storeValues( + result, + self, + pyArgs, + cArguments, + ) + return result + return wrapperCall + else: # null storeValues + if returnValues: + def wrapperCall( *args ): + """Wrapper with all save storeValues""" + pyArgs = tuple( calculate_pyArgs( args )) + cArguments = pyArgs + try: + result = wrappedOperation( *cArguments ) + except ctypes.ArgumentError as err: + err.args = err.args + (cArguments,) + raise err + except error.GLError as err: + err.cArgs = cArguments + err.pyArgs = pyArgs + raise err + return returnValues( + result, + self, + pyArgs, + cArguments, + ) + return wrapperCall + else: + def wrapperCall( *args ): + """Wrapper with all save returnValues and storeValues""" + pyArgs = tuple( calculate_pyArgs( args )) + cArguments = pyArgs + try: + result = wrappedOperation( *cArguments ) + except ctypes.ArgumentError as err: + err.args = err.args + (cArguments,) + raise err + except error.GLError as err: + err.cArgs = cArguments + err.pyArgs = pyArgs + raise err + return result + return wrapperCall + else: + # null pyConverters + if cConverters: + if cResolvers: + if storeValues: + if returnValues: + def wrapperCall( *args ): + """Wrapper with all possible operations""" + pyArgs = args + cArgs = [] + for (index,converter) in enumerate( cConverters ): + # move enumerate out... + if not hasattr(converter,'__call__'): + cArgs.append( converter ) + else: + try: + cArgs.append( + converter( pyArgs, index, self ) + ) + except Exception as err: + if hasattr( err, 'args' ): + err.args += ( + """Failure in cConverter %r"""%(converter), + pyArgs, index, + ) + raise + cArguments = tuple(calculate_cArguments( cArgs )) + try: + result = wrappedOperation( *cArguments ) + except ctypes.ArgumentError as err: + err.args = err.args + (cArguments,) + raise err + except error.GLError as err: + err.cArgs = cArgs + err.pyArgs = pyArgs + raise err + # handle storage of persistent argument values... + storeValues( + result, + self, + pyArgs, + cArgs, + ) + return returnValues( + result, + self, + pyArgs, + cArgs, + ) + return wrapperCall + else: + def wrapperCall( *args ): + """Wrapper with all save returnValues""" + pyArgs = args + cArgs = [] + for (index,converter) in enumerate( cConverters ): + # move enumerate out... + if not hasattr(converter,'__call__'): + cArgs.append( converter ) + else: + try: + cArgs.append( + converter( pyArgs, index, self ) + ) + except Exception as err: + if hasattr( err, 'args' ): + err.args += ( + """Failure in cConverter %r"""%(converter), + pyArgs, index, + ) + raise + cArguments = tuple(calculate_cArguments( cArgs )) + try: + result = wrappedOperation( *cArguments ) + except ctypes.ArgumentError as err: + err.args = err.args + (cArguments,) + raise err + except error.GLError as err: + err.cArgs = cArgs + err.pyArgs = pyArgs + raise err + # handle storage of persistent argument values... + storeValues( + result, + self, + pyArgs, + cArgs, + ) + return result + return wrapperCall + else: # null storeValues + if returnValues: + def wrapperCall( *args ): + """Wrapper with all save storeValues""" + pyArgs = args + cArgs = [] + for (index,converter) in enumerate( cConverters ): + # move enumerate out... + if not hasattr(converter,'__call__'): + cArgs.append( converter ) + else: + try: + cArgs.append( + converter( pyArgs, index, self ) + ) + except Exception as err: + if hasattr( err, 'args' ): + err.args += ( + """Failure in cConverter %r"""%(converter), + pyArgs, index, + ) + raise + cArguments = tuple(calculate_cArguments( cArgs )) + try: + result = wrappedOperation( *cArguments ) + except ctypes.ArgumentError as err: + err.args = err.args + (cArguments,) + raise err + except error.GLError as err: + err.cArgs = cArgs + err.pyArgs = pyArgs + raise err + return returnValues( + result, + self, + pyArgs, + cArgs, + ) + return wrapperCall + else: + def wrapperCall( *args ): + """Wrapper with all save returnValues and storeValues""" + pyArgs = args + cArgs = [] + for (index,converter) in enumerate( cConverters ): + # move enumerate out... + if not hasattr(converter,'__call__'): + cArgs.append( converter ) + else: + try: + cArgs.append( + converter( pyArgs, index, self ) + ) + except Exception as err: + if hasattr( err, 'args' ): + err.args += ( + """Failure in cConverter %r"""%(converter), + pyArgs, index, + ) + raise + cArguments = tuple(calculate_cArguments( cArgs )) + try: + result = wrappedOperation( *cArguments ) + except ctypes.ArgumentError as err: + err.args = err.args + (cArguments,) + raise err + except error.GLError as err: + err.cArgs = cArgs + err.pyArgs = pyArgs + raise err + return result + return wrapperCall + else: + # null cResolvers + if storeValues: + if returnValues: + def wrapperCall( *args ): + """Wrapper with all possible operations""" + pyArgs = args + cArgs = [] + for (index,converter) in enumerate( cConverters ): + # move enumerate out... + if not hasattr(converter,'__call__'): + cArgs.append( converter ) + else: + try: + cArgs.append( + converter( pyArgs, index, self ) + ) + except Exception as err: + if hasattr( err, 'args' ): + err.args += ( + """Failure in cConverter %r"""%(converter), + pyArgs, index, + ) + raise + cArguments = cArgs + try: + result = wrappedOperation( *cArguments ) + except ctypes.ArgumentError as err: + err.args = err.args + (cArguments,) + raise err + except error.GLError as err: + err.cArgs = cArgs + err.pyArgs = pyArgs + raise err + # handle storage of persistent argument values... + storeValues( + result, + self, + pyArgs, + cArgs, + ) + return returnValues( + result, + self, + pyArgs, + cArgs, + ) + return wrapperCall + else: + def wrapperCall( *args ): + """Wrapper with all save returnValues""" + pyArgs = args + cArgs = [] + for (index,converter) in enumerate( cConverters ): + # move enumerate out... + if not hasattr(converter,'__call__'): + cArgs.append( converter ) + else: + try: + cArgs.append( + converter( pyArgs, index, self ) + ) + except Exception as err: + if hasattr( err, 'args' ): + err.args += ( + """Failure in cConverter %r"""%(converter), + pyArgs, index, + ) + raise + cArguments = cArgs + try: + result = wrappedOperation( *cArguments ) + except ctypes.ArgumentError as err: + err.args = err.args + (cArguments,) + raise err + except error.GLError as err: + err.cArgs = cArgs + err.pyArgs = pyArgs + raise err + # handle storage of persistent argument values... + storeValues( + result, + self, + pyArgs, + cArgs, + ) + return result + return wrapperCall + else: # null storeValues + if returnValues: + def wrapperCall( *args ): + """Wrapper with all save storeValues""" + pyArgs = args + cArgs = [] + for (index,converter) in enumerate( cConverters ): + # move enumerate out... + if not hasattr(converter,'__call__'): + cArgs.append( converter ) + else: + try: + cArgs.append( + converter( pyArgs, index, self ) + ) + except Exception as err: + if hasattr( err, 'args' ): + err.args += ( + """Failure in cConverter %r"""%(converter), + pyArgs, index, + ) + raise + cArguments = cArgs + try: + result = wrappedOperation( *cArguments ) + except ctypes.ArgumentError as err: + err.args = err.args + (cArguments,) + raise err + except error.GLError as err: + err.cArgs = cArgs + err.pyArgs = pyArgs + raise err + return returnValues( + result, + self, + pyArgs, + cArgs, + ) + return wrapperCall + else: + def wrapperCall( *args ): + """Wrapper with all save returnValues and storeValues""" + pyArgs = args + cArgs = [] + for (index,converter) in enumerate( cConverters ): + # move enumerate out... + if not hasattr(converter,'__call__'): + cArgs.append( converter ) + else: + try: + cArgs.append( + converter( pyArgs, index, self ) + ) + except Exception as err: + if hasattr( err, 'args' ): + err.args += ( + """Failure in cConverter %r"""%(converter), + pyArgs, index, + ) + raise + cArguments = cArgs + try: + result = wrappedOperation( *cArguments ) + except ctypes.ArgumentError as err: + err.args = err.args + (cArguments,) + raise err + except error.GLError as err: + err.cArgs = cArgs + err.pyArgs = pyArgs + raise err + return result + return wrapperCall + else: + # null cConverters + if cResolvers: + if storeValues: + if returnValues: + def wrapperCall( *args ): + """Wrapper with all possible operations""" + cArgs = args + cArguments = tuple(calculate_cArguments( cArgs )) + try: + result = wrappedOperation( *cArguments ) + except ctypes.ArgumentError as err: + err.args = err.args + (cArguments,) + raise err + except error.GLError as err: + err.cArgs = cArgs + err.pyArgs = args + raise err + # handle storage of persistent argument values... + storeValues( + result, + self, + args, + cArgs, + ) + return returnValues( + result, + self, + args, + cArgs, + ) + return wrapperCall + else: + def wrapperCall( *args ): + """Wrapper with all save returnValues""" + cArgs = args + cArguments = tuple(calculate_cArguments( cArgs )) + try: + result = wrappedOperation( *cArguments ) + except ctypes.ArgumentError as err: + err.args = err.args + (cArguments,) + raise err + except error.GLError as err: + err.cArgs = cArgs + err.pyArgs = args + raise err + # handle storage of persistent argument values... + storeValues( + result, + self, + args, + cArgs, + ) + return result + return wrapperCall + else: # null storeValues + if returnValues: + def wrapperCall( *args ): + """Wrapper with all save storeValues""" + cArgs = args + cArguments = tuple(calculate_cArguments( cArgs )) + try: + result = wrappedOperation( *cArguments ) + except ctypes.ArgumentError as err: + err.args = err.args + (cArguments,) + raise err + except error.GLError as err: + err.cArgs = cArgs + err.pyArgs = args + raise err + return returnValues( + result, + self, + args, + cArgs, + ) + return wrapperCall + else: + def wrapperCall( *args ): + """Wrapper with all save returnValues and storeValues""" + cArgs = args + cArguments = tuple(calculate_cArguments( cArgs )) + try: + result = wrappedOperation( *cArguments ) + except ctypes.ArgumentError as err: + err.args = err.args + (cArguments,) + raise err + except error.GLError as err: + err.cArgs = cArgs + err.pyArgs = args + raise err + return result + return wrapperCall + else: + # null cResolvers + if storeValues: + if returnValues: + def wrapperCall( *args ): + """Wrapper with all possible operations""" + cArguments = args + try: + result = wrappedOperation( *cArguments ) + except ctypes.ArgumentError as err: + err.args = err.args + (cArguments,) + raise err + except error.GLError as err: + err.cArgs = cArguments + err.pyArgs = args + raise err + # handle storage of persistent argument values... + storeValues( + result, + self, + args, + cArguments, + ) + return returnValues( + result, + self, + args, + cArguments, + ) + return wrapperCall + else: + def wrapperCall( *args ): + """Wrapper with all save returnValues""" + cArguments = args + try: + result = wrappedOperation( *cArguments ) + except ctypes.ArgumentError as err: + err.args = err.args + (cArguments,) + raise err + except error.GLError as err: + err.cArgs = cArguments + err.pyArgs = args + raise err + # handle storage of persistent argument values... + storeValues( + result, + self, + args, + cArguments, + ) + return result + return wrapperCall + else: # null storeValues + if returnValues: + def wrapperCall( *args ): + """Wrapper with all save storeValues""" + cArguments = args + try: + result = wrappedOperation( *cArguments ) + except ctypes.ArgumentError as err: + err.args = err.args + (cArguments,) + raise err + except error.GLError as err: + err.cArgs = cArguments + err.pyArgs = args + raise err + return returnValues( + result, + self, + args, + cArguments, + ) + return wrapperCall + else: + def wrapperCall( *args ): + """Wrapper with all save returnValues and storeValues""" + cArguments = args + try: + result = wrappedOperation( *cArguments ) + except ctypes.ArgumentError as err: + err.args = err.args + (cArguments,) + raise err + except error.GLError as err: + err.cArgs = cArguments + err.pyArgs = args + raise err + return result + return wrapperCall +# def __call__( self, *args, **named ): +# """Finalise the wrapper before calling it""" +# try: +# return self._finalCall( *args, **named ) +# except AttributeError, err: +# return self.finalise()( *args, **named ) + + def _unspecialised__call__( self, *args ): + """Expand arguments, call the function, store values and check errors""" + pyConverters = getattr( self, 'pyConverters', None ) + if pyConverters: + if len(pyConverters) != len(args): + raise ValueError( + """%s requires %r arguments (%s), received %s: %r"""%( + self.wrappedOperation.__name__, + len(pyConverters), + ", ".join( self.pyConverterNames ), + len(args), + args + ) + ) + pyArgs = [] + for (converter,arg) in zip(pyConverters,args): + if converter is None: + pyArgs.append( arg ) + else: + pyArgs.append( converter(arg, self, args) ) + else: + pyArgs = args + cConverters = getattr( self, 'cConverters', None ) + if cConverters: + cArgs = [] + for (index,converter) in enumerate( cConverters ): + if not hasattr(converter,'__call__'): + cArgs.append( converter ) + else: + try: + cArgs.append( + converter( pyArgs, index, self ) + ) + except Exception as err: + if hasattr( err, 'args' ): + err.args += ( + """Failure in cConverter %r"""%(converter), + pyArgs, index, self, + ) + raise + else: + cArgs = pyArgs + cResolvers = getattr( self, 'cResolvers', None ) + if cResolvers: + cArguments = [] + for (converter, value) in zip( cResolvers, cArgs ): + if converter is None: + cArguments.append( value ) + else: + cArguments.append( converter( value ) ) + else: + cArguments = cArgs + try: + result = self.wrappedOperation( *cArguments ) + except ctypes.ArgumentError as err: + err.args = err.args + (cArguments,) + raise err + except error.GLError as err: + err.cArgs = cArgs + err.pyArgs = pyArgs + raise err + storeValues = getattr( self, 'storeValues', None ) + if storeValues is not None: + # handle storage of persistent argument values... + storeValues( + result, + self, + pyArgs, + cArgs, + ) + returnValues = getattr( self, 'returnValues', None ) + if returnValues is not None: + return returnValues( + result, + self, + pyArgs, + cArgs, + ) + else: + return result + +class MultiReturn(object): + def __init__(self,*children): + self.children = list(children) + def append(self, child ): + self.children.append( child ) + def __call__(self,*args,**named): + result = [] + for child in self.children: + try: + result.append( child(*args,**named) ) + except Exception as err: + err.args += ( child, args, named ) + raise + return result + +def wrapper( wrappedOperation ): + """Create a Wrapper sub-class instance for the given wrappedOperation + + The purpose of this function is to create a subclass of Wrapper which + has the __doc__ and __name__ of the wrappedOperation so that the instance of + the wrapper will show up as by default, + and will have the docstring available naturally in pydoc and the like. + """ + if isinstance( wrappedOperation, Wrapper ): + return wrappedOperation + dict = { + '__doc__': wrappedOperation.__doc__, + '__slots__': ('wrappedOperation', ), + } + cls = type( wrappedOperation.__name__, (Wrapper,), dict ) + if hasattr( wrappedOperation, '__module__' ): + cls.__module__ = wrappedOperation.__module__ + instance = cls(wrappedOperation) + return instance diff --git a/venv/lib/python3.12/site-packages/PyOpenGL-3.1.7.dist-info/INSTALLER b/venv/lib/python3.12/site-packages/PyOpenGL-3.1.7.dist-info/INSTALLER new file mode 100644 index 00000000..a1b589e3 --- /dev/null +++ b/venv/lib/python3.12/site-packages/PyOpenGL-3.1.7.dist-info/INSTALLER @@ -0,0 +1 @@ +pip diff --git a/venv/lib/python3.12/site-packages/PyOpenGL-3.1.7.dist-info/METADATA b/venv/lib/python3.12/site-packages/PyOpenGL-3.1.7.dist-info/METADATA new file mode 100644 index 00000000..01513c66 --- /dev/null +++ b/venv/lib/python3.12/site-packages/PyOpenGL-3.1.7.dist-info/METADATA @@ -0,0 +1,95 @@ +Metadata-Version: 2.1 +Name: PyOpenGL +Version: 3.1.7 +Summary: Standard OpenGL bindings for Python +Home-page: http://pyopengl.sourceforge.net +Download-URL: https://pypi.org/project/PyOpenGL/ +Author: Mike C. Fletcher +Author-email: mcfletch@vrplumber.com +License: BSD +Keywords: Graphics,3D,OpenGL,GLU,GLUT,GLE,GLX,EXT,ARB,Mesa,ctypes +Classifier: License :: OSI Approved :: BSD License +Classifier: Programming Language :: Python +Classifier: Programming Language :: Python :: 2 +Classifier: Programming Language :: Python :: 3 +Classifier: Topic :: Multimedia :: Graphics :: 3D Rendering +Classifier: Topic :: Software Development :: Libraries :: Python Modules +Classifier: Intended Audience :: Developers +Description-Content-Type: text/x-rst + +PyOpenGL and PyOpenGL_Accelerate +================================= + +PyOpenGL is normally distributed via PyPI using standard pip:: + + $ pip install PyOpenGL PyOpenGL_accelerate + +You can install this repository by branching/cloning and running +``pip``:: + + $ cd pyopengl + $ pip install -e . + $ cd accelerate + $ pip install -e . + +Note that to compile PyOpenGL_accelerate you will need to have +a functioning Python extension-compiling environment. + +Learning PyOpenGL +----------------- + +If you are new to PyOpenGL, you likely want to start with the OpenGLContext `tutorial page`_. +Those tutorials require OpenGLContext, (which is a big wrapper including a whole +scenegraph engine, VRML97 parser, lots of demos, etc) you can install that with:: + + $ pip2.7 install "OpenGLContext-full==3.1.1" + +Or you can clone it (including the tutorial sources) with:: + + $ git clone https://github.com/mcfletch/openglcontext.git + +or (for GitHub usage):: + + $ git clone https://github.com/mcfletch/pyopengl.git + +The `documentation pages`_ are useful for looking up the parameters and semantics of +PyOpenGL calls. + +.. _`tutorial page`: http://pyopengl.sourceforge.net/context/tutorials/index.html +.. _`documentation pages`: https://mcfletch.github.io/pyopengl/documentation/index.html + + +Running Tests +-------------- + +You can run the PyOpenGL test suite from a source-code checkout, you will need: + +* git (for the checkout) +* GLUT (FreeGLUT) +* GLExtrusion library (libgle) +* GLU (normally available on any OpenGL-capable machine) +* tox (`pip install tox`) + +Running the test suite from a top-level checkout looks like:: + + $ tox + +The result being a lot of tests being run in a matrix of environments. +All of the environment will pull in pygame, some will also pull in +numpy. Some will have accelerate, and some will not. + +.. image:: https://travis-ci.org/mcfletch/pyopengl.svg?branch=master + :target: https://travis-ci.org/mcfletch/pyopengl + :alt: Travis Tests + +.. image:: https://ci.appveyor.com/api/projects/status/github/mcfletch/pyopengl + :target: https://ci.appveyor.com/project/MikeCFletcher/pyopengl + :alt: Appveyor Build + +.. image:: https://img.shields.io/pypi/v/pyopengl.svg + :target: https://pypi.python.org/pypi/pyopengl + :alt: Latest PyPI Version + +.. image:: https://img.shields.io/pypi/dm/pyopengl.svg + :target: https://pypi.python.org/pypi/pyopengl + :alt: Monthly download counter diff --git a/venv/lib/python3.12/site-packages/PyOpenGL-3.1.7.dist-info/RECORD b/venv/lib/python3.12/site-packages/PyOpenGL-3.1.7.dist-info/RECORD new file mode 100644 index 00000000..6ef12fc4 --- /dev/null +++ b/venv/lib/python3.12/site-packages/PyOpenGL-3.1.7.dist-info/RECORD @@ -0,0 +1,5604 @@ +OpenGL/AGL/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +OpenGL/AGL/__pycache__/__init__.cpython-312.pyc,, +OpenGL/EGL/ANDROID/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/EGL/ANDROID/__pycache__/__init__.cpython-312.pyc,, +OpenGL/EGL/ANDROID/__pycache__/blob_cache.cpython-312.pyc,, +OpenGL/EGL/ANDROID/__pycache__/framebuffer_target.cpython-312.pyc,, +OpenGL/EGL/ANDROID/__pycache__/image_native_buffer.cpython-312.pyc,, +OpenGL/EGL/ANDROID/__pycache__/native_fence_sync.cpython-312.pyc,, +OpenGL/EGL/ANDROID/__pycache__/recordable.cpython-312.pyc,, +OpenGL/EGL/ANDROID/blob_cache.py,sha256=O2Oz7udVzEXI4g1l5kyhdALBPoSzGuDiy51Rp_P2d4o,760 +OpenGL/EGL/ANDROID/framebuffer_target.py,sha256=JiIxg_OVE4QW8HFLBsbVOxfK9XxmcGSY984uTXlt9u8,808 +OpenGL/EGL/ANDROID/image_native_buffer.py,sha256=mR_QYOVcyVxKuA2T96aKCx73cKBumLqTjUAzToFAE0Y,813 +OpenGL/EGL/ANDROID/native_fence_sync.py,sha256=rc2Kl1-0nS7wQ5lnMCasvuT93_dXwgUNwfVXct2jMjI,801 +OpenGL/EGL/ANDROID/recordable.py,sha256=gwQlI3SVox3UNmJuhVo_gPgDYVlF2KUNjXtop129ClI,761 +OpenGL/EGL/ANGLE/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/EGL/ANGLE/__pycache__/__init__.cpython-312.pyc,, +OpenGL/EGL/ANGLE/__pycache__/d3d_share_handle_client_buffer.cpython-312.pyc,, +OpenGL/EGL/ANGLE/__pycache__/device_d3d.cpython-312.pyc,, +OpenGL/EGL/ANGLE/__pycache__/query_surface_pointer.cpython-312.pyc,, +OpenGL/EGL/ANGLE/__pycache__/surface_d3d_texture_2d_share_handle.cpython-312.pyc,, +OpenGL/EGL/ANGLE/__pycache__/window_fixed_size.cpython-312.pyc,, +OpenGL/EGL/ANGLE/d3d_share_handle_client_buffer.py,sha256=MNeSeOZv6b6eYdq6AZKusVbkNc7iHKuFTgK36VQMLHM,865 +OpenGL/EGL/ANGLE/device_d3d.py,sha256=GNDwiIauG8rD-PpLhm8VPE2Cj2yZ7sx3Iaxqw3v1VB8,748 +OpenGL/EGL/ANGLE/query_surface_pointer.py,sha256=dOuy9Z4O6_vzZFUz-RSAB09nljlDZBN2TIL_IuyywpA,813 +OpenGL/EGL/ANGLE/surface_d3d_texture_2d_share_handle.py,sha256=oPLLa8OTcNXiXYF4kbR0GWR79HQyFnkx_bdDVTpYdQk,894 +OpenGL/EGL/ANGLE/window_fixed_size.py,sha256=NRq1-NPYvUHBYmYm3bnj0Zs8RNe_jeoc617dNKrnQHc,789 +OpenGL/EGL/ARM/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/EGL/ARM/__pycache__/__init__.cpython-312.pyc,, +OpenGL/EGL/ARM/__pycache__/pixmap_multisample_discard.cpython-312.pyc,, +OpenGL/EGL/ARM/pixmap_multisample_discard.py,sha256=Ug6Rfz13Lk7Yt5jh52pLz4pYgV5dHBVd_xs8NISIMJ4,831 +OpenGL/EGL/EXT/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/EGL/EXT/__pycache__/__init__.cpython-312.pyc,, +OpenGL/EGL/EXT/__pycache__/buffer_age.cpython-312.pyc,, +OpenGL/EGL/EXT/__pycache__/client_extensions.cpython-312.pyc,, +OpenGL/EGL/EXT/__pycache__/create_context_robustness.cpython-312.pyc,, +OpenGL/EGL/EXT/__pycache__/device_base.cpython-312.pyc,, +OpenGL/EGL/EXT/__pycache__/device_drm.cpython-312.pyc,, +OpenGL/EGL/EXT/__pycache__/device_enumeration.cpython-312.pyc,, +OpenGL/EGL/EXT/__pycache__/device_openwf.cpython-312.pyc,, +OpenGL/EGL/EXT/__pycache__/device_query.cpython-312.pyc,, +OpenGL/EGL/EXT/__pycache__/image_dma_buf_import.cpython-312.pyc,, +OpenGL/EGL/EXT/__pycache__/multiview_window.cpython-312.pyc,, +OpenGL/EGL/EXT/__pycache__/output_base.cpython-312.pyc,, +OpenGL/EGL/EXT/__pycache__/output_drm.cpython-312.pyc,, +OpenGL/EGL/EXT/__pycache__/output_openwf.cpython-312.pyc,, +OpenGL/EGL/EXT/__pycache__/platform_base.cpython-312.pyc,, +OpenGL/EGL/EXT/__pycache__/platform_device.cpython-312.pyc,, +OpenGL/EGL/EXT/__pycache__/platform_wayland.cpython-312.pyc,, +OpenGL/EGL/EXT/__pycache__/platform_x11.cpython-312.pyc,, +OpenGL/EGL/EXT/__pycache__/protected_surface.cpython-312.pyc,, +OpenGL/EGL/EXT/__pycache__/stream_consumer_egloutput.cpython-312.pyc,, +OpenGL/EGL/EXT/__pycache__/swap_buffers_with_damage.cpython-312.pyc,, +OpenGL/EGL/EXT/__pycache__/yuv_surface.cpython-312.pyc,, +OpenGL/EGL/EXT/buffer_age.py,sha256=XdVOOloLOM62FUY5KebpM-jX7YX_qT9oNs-YctdP8hM,736 +OpenGL/EGL/EXT/client_extensions.py,sha256=X8wenpDA85jyZC8zchzEJH2_ajoRMkQdnPF5WcGB2UY,778 +OpenGL/EGL/EXT/create_context_robustness.py,sha256=nNCwfpcX9m35JLLS2z2wzc5bbfTt_tRnQD7xFddHDZE,825 +OpenGL/EGL/EXT/device_base.py,sha256=d-H5l7TftNjepD-MQSnAKSr4Sr93X3fDmRZlxg69gbI,1187 +OpenGL/EGL/EXT/device_drm.py,sha256=nZECACx3lEPv70XL9vqYFsmBaj4V079s16nzrMes3Aw,736 +OpenGL/EGL/EXT/device_enumeration.py,sha256=BTipRa8PVqBx1miPA0_TH6wVRXeAi0korBxvurtef6E,865 +OpenGL/EGL/EXT/device_openwf.py,sha256=082Vebvk85eWuhz98a8a4Lj_klTId4PGk2vVd0uoek0,754 +OpenGL/EGL/EXT/device_query.py,sha256=340QkqtUD676kP2BtKLynE_5JHm0xbftfHEMnmJfRpc,839 +OpenGL/EGL/EXT/image_dma_buf_import.py,sha256=tblqhcs2IvlZ2FE3HdIv4RNl51jy9cAot4Przo-4X6Q,794 +OpenGL/EGL/EXT/multiview_window.py,sha256=Uqe0DgUA6kysxXzp5kJczgnHCmlPtYRRe9kaZ5xczn4,772 +OpenGL/EGL/EXT/output_base.py,sha256=cFEj38t_llJ_gR2aclfoDjPXFm87nXXHgwhPbSgXs-8,742 +OpenGL/EGL/EXT/output_drm.py,sha256=2mQRhJuirg5NTwfQKMnnICCKum0_-b6VFMo-CGqumDY,736 +OpenGL/EGL/EXT/output_openwf.py,sha256=D91gRh_MNa9emgjqg_colN9ZPuJj4hA7p1M1LXATLzw,754 +OpenGL/EGL/EXT/platform_base.py,sha256=6NtI4riw_zx6_VT0l0ieLo2DVTeWn6qGMpHEqmKbQkM,943 +OpenGL/EGL/EXT/platform_device.py,sha256=C-wHTISQ7EYO_X9mfyW0_pVhzhesImTCnLydC_8ToZs,766 +OpenGL/EGL/EXT/platform_wayland.py,sha256=jvqYp3FSVu9vL7fnlHUPQKbdyyVq_auFgf2olGJf-GY,772 +OpenGL/EGL/EXT/platform_x11.py,sha256=2uONboeE6-Eh1PU1k_8MZmsepK2MyyUJdEGH4-c2Gn8,748 +OpenGL/EGL/EXT/protected_surface.py,sha256=GDa93FnetnwunkBGKNiurIu7WYNVzaTnBI9TrUhGvs0,778 +OpenGL/EGL/EXT/stream_consumer_egloutput.py,sha256=9blcPq4L2lgH4skPvsrkpJr5f_Mjy83FYBZ0jYUpxH8,825 +OpenGL/EGL/EXT/swap_buffers_with_damage.py,sha256=JFKxO-vzhEOKMvcyO2ZgdDkaFlGy_CcHwDHBxwPiF8M,818 +OpenGL/EGL/EXT/yuv_surface.py,sha256=ge8VFPH4rj7NCmtgGYDgkJdyeVTCvYALJKRuEHs7z9s,742 +OpenGL/EGL/HI/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/EGL/HI/__pycache__/__init__.cpython-312.pyc,, +OpenGL/EGL/HI/__pycache__/clientpixmap.cpython-312.pyc,, +OpenGL/EGL/HI/__pycache__/colorformats.cpython-312.pyc,, +OpenGL/EGL/HI/clientpixmap.py,sha256=yUvDz_foQGrgbK_Y6SRQjX12DGys9liyxiX9h0SnR84,743 +OpenGL/EGL/HI/colorformats.py,sha256=ilnXquzjw1vyz2C3sYOBLniD82WVB3F3iD3owJgCg0g,743 +OpenGL/EGL/IMG/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/EGL/IMG/__pycache__/__init__.cpython-312.pyc,, +OpenGL/EGL/IMG/__pycache__/context_priority.cpython-312.pyc,, +OpenGL/EGL/IMG/context_priority.py,sha256=0LwYeDhJ3oi_4DJ_C-VPCV1u_kFSdRmu3646eJO-JIU,772 +OpenGL/EGL/KHR/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/EGL/KHR/__pycache__/__init__.cpython-312.pyc,, +OpenGL/EGL/KHR/__pycache__/cl_event.cpython-312.pyc,, +OpenGL/EGL/KHR/__pycache__/cl_event2.cpython-312.pyc,, +OpenGL/EGL/KHR/__pycache__/client_get_all_proc_addresses.cpython-312.pyc,, +OpenGL/EGL/KHR/__pycache__/config_attribs.cpython-312.pyc,, +OpenGL/EGL/KHR/__pycache__/create_context.cpython-312.pyc,, +OpenGL/EGL/KHR/__pycache__/create_context_no_error.cpython-312.pyc,, +OpenGL/EGL/KHR/__pycache__/debug.cpython-312.pyc,, +OpenGL/EGL/KHR/__pycache__/fence_sync.cpython-312.pyc,, +OpenGL/EGL/KHR/__pycache__/get_all_proc_addresses.cpython-312.pyc,, +OpenGL/EGL/KHR/__pycache__/gl_colorspace.cpython-312.pyc,, +OpenGL/EGL/KHR/__pycache__/gl_renderbuffer_image.cpython-312.pyc,, +OpenGL/EGL/KHR/__pycache__/gl_texture_2D_image.cpython-312.pyc,, +OpenGL/EGL/KHR/__pycache__/gl_texture_3D_image.cpython-312.pyc,, +OpenGL/EGL/KHR/__pycache__/gl_texture_cubemap_image.cpython-312.pyc,, +OpenGL/EGL/KHR/__pycache__/image.cpython-312.pyc,, +OpenGL/EGL/KHR/__pycache__/image_base.cpython-312.pyc,, +OpenGL/EGL/KHR/__pycache__/image_pixmap.cpython-312.pyc,, +OpenGL/EGL/KHR/__pycache__/lock_surface.cpython-312.pyc,, +OpenGL/EGL/KHR/__pycache__/lock_surface2.cpython-312.pyc,, +OpenGL/EGL/KHR/__pycache__/lock_surface3.cpython-312.pyc,, +OpenGL/EGL/KHR/__pycache__/partial_update.cpython-312.pyc,, +OpenGL/EGL/KHR/__pycache__/platform_android.cpython-312.pyc,, +OpenGL/EGL/KHR/__pycache__/platform_gbm.cpython-312.pyc,, +OpenGL/EGL/KHR/__pycache__/platform_wayland.cpython-312.pyc,, +OpenGL/EGL/KHR/__pycache__/platform_x11.cpython-312.pyc,, +OpenGL/EGL/KHR/__pycache__/reusable_sync.cpython-312.pyc,, +OpenGL/EGL/KHR/__pycache__/stream.cpython-312.pyc,, +OpenGL/EGL/KHR/__pycache__/stream_consumer_gltexture.cpython-312.pyc,, +OpenGL/EGL/KHR/__pycache__/stream_cross_process_fd.cpython-312.pyc,, +OpenGL/EGL/KHR/__pycache__/stream_fifo.cpython-312.pyc,, +OpenGL/EGL/KHR/__pycache__/stream_producer_aldatalocator.cpython-312.pyc,, +OpenGL/EGL/KHR/__pycache__/stream_producer_eglsurface.cpython-312.pyc,, +OpenGL/EGL/KHR/__pycache__/surfaceless_context.cpython-312.pyc,, +OpenGL/EGL/KHR/__pycache__/swap_buffers_with_damage.cpython-312.pyc,, +OpenGL/EGL/KHR/__pycache__/vg_parent_image.cpython-312.pyc,, +OpenGL/EGL/KHR/__pycache__/wait_sync.cpython-312.pyc,, +OpenGL/EGL/KHR/cl_event.py,sha256=x5oMc5W8KcbFDLg7-aBNowhMHsrjGXleJqIkryF-wH4,724 +OpenGL/EGL/KHR/cl_event2.py,sha256=w1TKwgCyo46yMUe6USdMV6n9AjFqIDvzFZKhRJmB_qQ,730 +OpenGL/EGL/KHR/client_get_all_proc_addresses.py,sha256=qQhE-MiykmwPxHFSby3pqPsiml3Nse7rFeglJFZ304s,847 +OpenGL/EGL/KHR/config_attribs.py,sha256=9ef1-NycEtwrjZqAqJ-X4_GOeMEJvu8NhpxuQUFZZus,760 +OpenGL/EGL/KHR/create_context.py,sha256=a_YtRyK8jRPdJxXHf7sSvjoD0CBYOi_ioC4pwCmJlU8,760 +OpenGL/EGL/KHR/create_context_no_error.py,sha256=WFMpQTgUFcPz93nCbykmS8gMMvcC8i4vg3iHMZTtUSg,812 +OpenGL/EGL/KHR/debug.py,sha256=Jc5mFRHcBW8zb3pTd3j9X4Ax6SA1jZonE2lyB68wZco,707 +OpenGL/EGL/KHR/fence_sync.py,sha256=_8_vkU_oo45RoLp87JAJTTtQp3ZS7eOrey-nTu4abIM,736 +OpenGL/EGL/KHR/get_all_proc_addresses.py,sha256=CWyvaLxR8nMWNzY3tRqNfeJ-_MY7LBN3WUyPB6K6YsU,806 +OpenGL/EGL/KHR/gl_colorspace.py,sha256=n33kUx8o8InTw-McGRA0nShpGOIP8iCViO_htYN8V8c,754 +OpenGL/EGL/KHR/gl_renderbuffer_image.py,sha256=kq0WOHTbsKyS16GZJCAVnFHiMK8SLZQ4CSnMPnNtcuQ,801 +OpenGL/EGL/KHR/gl_texture_2D_image.py,sha256=V3tAazLUpjOwZz37or4ZQxXNtvbd02TPo93AiJQhTvU,788 +OpenGL/EGL/KHR/gl_texture_3D_image.py,sha256=OqDmLrQM5Q9Z052RiCQAKaVjxRFpMCVmdstOmGNBcKs,788 +OpenGL/EGL/KHR/gl_texture_cubemap_image.py,sha256=vmHn_rhWf3Ni1tWcSnPYcQA9Jex55gB1ZW--wbX2b9Q,818 +OpenGL/EGL/KHR/image.py,sha256=ocZifMRlBU6bALKfQ5d1VDwjoTFRFnMlENS2I0_ipRA,707 +OpenGL/EGL/KHR/image_base.py,sha256=EEkLE0Hf1PiaPhs4_egHLj9PX3SQfx5Ve_i3cnfgeEI,736 +OpenGL/EGL/KHR/image_pixmap.py,sha256=qHNpaOO5ANsYcznTSmUCaot3sMjN9FDIoaIE1rKmbIs,748 +OpenGL/EGL/KHR/lock_surface.py,sha256=mJPDzwYPUYtI_51-VYrFpiomcYLSNXqI-Z5xAHRNOvM,748 +OpenGL/EGL/KHR/lock_surface2.py,sha256=V-bGe8YwyXqZgMBRC8ymgyUrKBJk-a4-cKbXZ5QGmyk,754 +OpenGL/EGL/KHR/lock_surface3.py,sha256=hQ0U8aVZ1qF1WdJsTI76goyA9yWtlgb-xUUK3XeS0qM,754 +OpenGL/EGL/KHR/partial_update.py,sha256=hYXyc1asN1UV9hpj6gBZzvA_ob_TiWpqMpigK8BDCSU,760 +OpenGL/EGL/KHR/platform_android.py,sha256=-DHVgqWcnAoH9R9AKIfTA4bWvQ4Qp5icDOmgXCnpEb4,772 +OpenGL/EGL/KHR/platform_gbm.py,sha256=fhr6x6DXoxXXfIR_x2SKhAIOEukLPVanoWCbwnMuxbk,748 +OpenGL/EGL/KHR/platform_wayland.py,sha256=DwvGX0qBI0YaDZv1kDPh5u5a_xlylUs3iSyXSl3xrHk,772 +OpenGL/EGL/KHR/platform_x11.py,sha256=LzwY4iSC0NRNAUXjvTk4SZdSYenX9K2IG1FPeJPm2qM,748 +OpenGL/EGL/KHR/reusable_sync.py,sha256=71N12cPSMTV0pPuo-h2YTZZxSHGILEeestdLmeCZoIk,754 +OpenGL/EGL/KHR/stream.py,sha256=Skeq5eW267gqnT7jOt1xPDiY-qMpwspyqXV0ly65wos,713 +OpenGL/EGL/KHR/stream_consumer_gltexture.py,sha256=Rev4hbyPIXV8pwQaHhdNpLPUx_MXV0Jvfg6wx1LGNEQ,825 +OpenGL/EGL/KHR/stream_cross_process_fd.py,sha256=n7M0cMZQCMcFsryVnXert1Nj91CRqiBBQyiiz7OoTAs,812 +OpenGL/EGL/KHR/stream_fifo.py,sha256=6iX0NVGb2ozOXC9fnU73g3BkFrUuwxKUks1nns3nSDg,742 +OpenGL/EGL/KHR/stream_producer_aldatalocator.py,sha256=FShm0OzH0ayKBQmIBa-XeCi5emwKgBMzBdwcmzw-KyM,849 +OpenGL/EGL/KHR/stream_producer_eglsurface.py,sha256=8S1Yrtx6XPYjO0ONpW7OpEpGh8a_wC9aLoYb9ewpWpQ,831 +OpenGL/EGL/KHR/surfaceless_context.py,sha256=zrtHjnUVdabXXpqbTWGP-wX1JhnGLq6OhFpT_r02HcY,790 +OpenGL/EGL/KHR/swap_buffers_with_damage.py,sha256=mrtd7owFjE3PMiGBHuEK8z9LnRgnYCw5unxGMTG4eN4,818 +OpenGL/EGL/KHR/vg_parent_image.py,sha256=mG3gJL2zkAlghbxrlUvTS3biZdnUNbQyTg0tsNl3WeI,765 +OpenGL/EGL/KHR/wait_sync.py,sha256=fNyC0SK4HYKz5dEWgAQz8AWGEqrgeND9XNw6ijUHNFg,730 +OpenGL/EGL/MESA/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/EGL/MESA/__pycache__/__init__.cpython-312.pyc,, +OpenGL/EGL/MESA/__pycache__/drm_image.cpython-312.pyc,, +OpenGL/EGL/MESA/__pycache__/image_dma_buf_export.cpython-312.pyc,, +OpenGL/EGL/MESA/__pycache__/platform_gbm.cpython-312.pyc,, +OpenGL/EGL/MESA/drm_image.py,sha256=DIieAAEU8lEBdc5OmsiMEcR6AxfId1plRmzRQ7GttBQ,736 +OpenGL/EGL/MESA/image_dma_buf_export.py,sha256=wioBdPHsSYrI1mDwvp78uT7QcKikRyiW-tv_fXA3zv0,800 +OpenGL/EGL/MESA/platform_gbm.py,sha256=PUIYI_KWYOA5ftgDe8IPgOlvN0BsGEQeT0X3aCh3ibY,754 +OpenGL/EGL/NOK/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/EGL/NOK/__pycache__/__init__.cpython-312.pyc,, +OpenGL/EGL/NOK/__pycache__/swap_region.cpython-312.pyc,, +OpenGL/EGL/NOK/__pycache__/swap_region2.cpython-312.pyc,, +OpenGL/EGL/NOK/__pycache__/texture_from_pixmap.cpython-312.pyc,, +OpenGL/EGL/NOK/swap_region.py,sha256=9RqeW6NEnD8IqGDM9BIsvFkRtDTOM0f0tztS0sajDRM,742 +OpenGL/EGL/NOK/swap_region2.py,sha256=tRc2RfxNLkygxS24TkFJbjrE_K-Vt6cQ4rj-deBqQnM,748 +OpenGL/EGL/NOK/texture_from_pixmap.py,sha256=JwGn7KhfLeUD6D5As2w_7Rvv8QKDmM7zFG22R_mOJuM,789 +OpenGL/EGL/NV/EGL_3dvision_surface.py,sha256=CDDxUt-4Ew2vISSOkOA_1RjN8U78PPT3HhJR3NsVpBc,789 +OpenGL/EGL/NV/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/EGL/NV/__pycache__/EGL_3dvision_surface.cpython-312.pyc,, +OpenGL/EGL/NV/__pycache__/__init__.cpython-312.pyc,, +OpenGL/EGL/NV/__pycache__/coverage_sample.cpython-312.pyc,, +OpenGL/EGL/NV/__pycache__/coverage_sample_resolve.cpython-312.pyc,, +OpenGL/EGL/NV/__pycache__/cuda_event.cpython-312.pyc,, +OpenGL/EGL/NV/__pycache__/depth_nonlinear.cpython-312.pyc,, +OpenGL/EGL/NV/__pycache__/device_cuda.cpython-312.pyc,, +OpenGL/EGL/NV/__pycache__/native_query.cpython-312.pyc,, +OpenGL/EGL/NV/__pycache__/post_convert_rounding.cpython-312.pyc,, +OpenGL/EGL/NV/__pycache__/post_sub_buffer.cpython-312.pyc,, +OpenGL/EGL/NV/__pycache__/stream_consumer_gltexture_yuv.cpython-312.pyc,, +OpenGL/EGL/NV/__pycache__/stream_metadata.cpython-312.pyc,, +OpenGL/EGL/NV/__pycache__/stream_sync.cpython-312.pyc,, +OpenGL/EGL/NV/__pycache__/sync.cpython-312.pyc,, +OpenGL/EGL/NV/__pycache__/system_time.cpython-312.pyc,, +OpenGL/EGL/NV/coverage_sample.py,sha256=gm-mbYU15xUKQucPmXCqTbhlgCmMCXr4DMTXnTBXN1Q,760 +OpenGL/EGL/NV/coverage_sample_resolve.py,sha256=zDTHuXq8lj5FsBYNFsQvWF99sGutbJCywFWgcIFFXUc,807 +OpenGL/EGL/NV/cuda_event.py,sha256=3O6SLIDrpbBQADU9dYspVpymN-LeIQ3CiI9OMM95gqE,730 +OpenGL/EGL/NV/depth_nonlinear.py,sha256=VPhCPzJy9kWEm529pANWbp1uTomSqhT0_bDjJnSyF4o,760 +OpenGL/EGL/NV/device_cuda.py,sha256=Y2Q1-WGxSPvECypWON8FkugdnLQKof-0x67-KjLPQHk,736 +OpenGL/EGL/NV/native_query.py,sha256=eSutrUOXnqBKCzO4qsBMOFLKa_BthPcRZUWyn_zv8Xg,742 +OpenGL/EGL/NV/post_convert_rounding.py,sha256=c6gnjxRhQB-PTeVV9GYejRc45qeMFalr94nQAOJ-fqA,795 +OpenGL/EGL/NV/post_sub_buffer.py,sha256=r4Q8zNkGnKWyZpK_mXNIxhI6H8fjlaZm-RbyqKUudGY,759 +OpenGL/EGL/NV/stream_consumer_gltexture_yuv.py,sha256=ZA9TgylaIqtgV6DUi07dnhcYIkzpaa_4Sd0PjwbUfL8,842 +OpenGL/EGL/NV/stream_metadata.py,sha256=RoFxFqn99HnYbdFKZr8SChp1UKFwRiA24yw2KFesqYI,760 +OpenGL/EGL/NV/stream_sync.py,sha256=8RAaY2NgZbfyXvOI1cmR6q2IFhpVMtnnKUFR2SzT9Bc,736 +OpenGL/EGL/NV/sync.py,sha256=Oc4LEp7dgDxBGmPPq8VdkwkIrNvhD7LFGZ4DVEm_yxE,695 +OpenGL/EGL/NV/system_time.py,sha256=LE4i0iCCAIEMWPlSYYgMFNMw2Di7yt6UHPIFi5QZ3nU,736 +OpenGL/EGL/TIZEN/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/EGL/TIZEN/__pycache__/__init__.cpython-312.pyc,, +OpenGL/EGL/TIZEN/__pycache__/image_native_buffer.cpython-312.pyc,, +OpenGL/EGL/TIZEN/__pycache__/image_native_surface.cpython-312.pyc,, +OpenGL/EGL/TIZEN/image_native_buffer.py,sha256=tNGX4swVsOMVaXzlNcxjUYyWBlURu6Ml5sJpCoU77ow,801 +OpenGL/EGL/TIZEN/image_native_surface.py,sha256=nOe0whWt3CVnkD64071N6O5jkrDfyRRUTm2gGzUp3YI,807 +OpenGL/EGL/VERSION/EGL_1_0.py,sha256=qAE4PdrpklpLjvk8cPtJPZRyoVT2tPseSWIK5oG-mmo,741 +OpenGL/EGL/VERSION/EGL_1_1.py,sha256=Tm33KnnSlrUu9zKoPPwgHYu7pohzvkjLBpGzXbh16IY,741 +OpenGL/EGL/VERSION/EGL_1_2.py,sha256=qB0mh6QE1P-beAYzGQzacW3lPq2waZ3R-utPNhQabC0,741 +OpenGL/EGL/VERSION/EGL_1_3.py,sha256=1u7o4oNujJq7ur5QWDBCJHHuaF9RtVT7X8dRw8RP_Aw,741 +OpenGL/EGL/VERSION/EGL_1_4.py,sha256=aYsq3NI2PrDC8Chgl3Yv1iNPY7HrlVSs9aHZgK2gjGk,741 +OpenGL/EGL/VERSION/EGL_1_5.py,sha256=aikdKdMOK4pZMudAs5nBfRn6hl5nnR6s7Iwe0dqvVeY,1062 +OpenGL/EGL/VERSION/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/EGL/VERSION/__pycache__/EGL_1_0.cpython-312.pyc,, +OpenGL/EGL/VERSION/__pycache__/EGL_1_1.cpython-312.pyc,, +OpenGL/EGL/VERSION/__pycache__/EGL_1_2.cpython-312.pyc,, +OpenGL/EGL/VERSION/__pycache__/EGL_1_3.cpython-312.pyc,, +OpenGL/EGL/VERSION/__pycache__/EGL_1_4.cpython-312.pyc,, +OpenGL/EGL/VERSION/__pycache__/EGL_1_5.cpython-312.pyc,, +OpenGL/EGL/VERSION/__pycache__/__init__.cpython-312.pyc,, +OpenGL/EGL/__init__.py,sha256=E5eRFcCHNmeZfouli5hdyj9PO7P1toyJzlj05VBa1_0,385 +OpenGL/EGL/__pycache__/__init__.cpython-312.pyc,, +OpenGL/EGL/__pycache__/debug.cpython-312.pyc,, +OpenGL/EGL/__pycache__/gbmdevice.cpython-312.pyc,, +OpenGL/EGL/debug.py,sha256=mEFUYvh0AL7lv1Wz5ZtTv3wcAiRClhdI3KNqrOYWYFA,7524 +OpenGL/EGL/gbmdevice.py,sha256=MqVgb27dF__0nezX8_uFNYSMIUaUGQBwCuC0fMTN_nk,4247 +OpenGL/GL/AMD/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +OpenGL/GL/AMD/__pycache__/__init__.cpython-312.pyc,, +OpenGL/GL/AMD/__pycache__/blend_minmax_factor.cpython-312.pyc,, +OpenGL/GL/AMD/__pycache__/conservative_depth.cpython-312.pyc,, +OpenGL/GL/AMD/__pycache__/debug_output.cpython-312.pyc,, +OpenGL/GL/AMD/__pycache__/depth_clamp_separate.cpython-312.pyc,, +OpenGL/GL/AMD/__pycache__/draw_buffers_blend.cpython-312.pyc,, +OpenGL/GL/AMD/__pycache__/framebuffer_multisample_advanced.cpython-312.pyc,, +OpenGL/GL/AMD/__pycache__/framebuffer_sample_positions.cpython-312.pyc,, +OpenGL/GL/AMD/__pycache__/gcn_shader.cpython-312.pyc,, +OpenGL/GL/AMD/__pycache__/gpu_shader_half_float.cpython-312.pyc,, +OpenGL/GL/AMD/__pycache__/gpu_shader_int16.cpython-312.pyc,, +OpenGL/GL/AMD/__pycache__/gpu_shader_int64.cpython-312.pyc,, +OpenGL/GL/AMD/__pycache__/interleaved_elements.cpython-312.pyc,, +OpenGL/GL/AMD/__pycache__/multi_draw_indirect.cpython-312.pyc,, +OpenGL/GL/AMD/__pycache__/name_gen_delete.cpython-312.pyc,, +OpenGL/GL/AMD/__pycache__/occlusion_query_event.cpython-312.pyc,, +OpenGL/GL/AMD/__pycache__/performance_monitor.cpython-312.pyc,, +OpenGL/GL/AMD/__pycache__/pinned_memory.cpython-312.pyc,, +OpenGL/GL/AMD/__pycache__/query_buffer_object.cpython-312.pyc,, +OpenGL/GL/AMD/__pycache__/sample_positions.cpython-312.pyc,, +OpenGL/GL/AMD/__pycache__/seamless_cubemap_per_texture.cpython-312.pyc,, +OpenGL/GL/AMD/__pycache__/shader_atomic_counter_ops.cpython-312.pyc,, +OpenGL/GL/AMD/__pycache__/shader_ballot.cpython-312.pyc,, +OpenGL/GL/AMD/__pycache__/shader_explicit_vertex_parameter.cpython-312.pyc,, +OpenGL/GL/AMD/__pycache__/shader_gpu_shader_half_float_fetch.cpython-312.pyc,, +OpenGL/GL/AMD/__pycache__/shader_image_load_store_lod.cpython-312.pyc,, +OpenGL/GL/AMD/__pycache__/shader_stencil_export.cpython-312.pyc,, +OpenGL/GL/AMD/__pycache__/shader_trinary_minmax.cpython-312.pyc,, +OpenGL/GL/AMD/__pycache__/sparse_texture.cpython-312.pyc,, +OpenGL/GL/AMD/__pycache__/stencil_operation_extended.cpython-312.pyc,, +OpenGL/GL/AMD/__pycache__/texture_gather_bias_lod.cpython-312.pyc,, +OpenGL/GL/AMD/__pycache__/texture_texture4.cpython-312.pyc,, +OpenGL/GL/AMD/__pycache__/transform_feedback3_lines_triangles.cpython-312.pyc,, +OpenGL/GL/AMD/__pycache__/transform_feedback4.cpython-312.pyc,, +OpenGL/GL/AMD/__pycache__/vertex_shader_layer.cpython-312.pyc,, +OpenGL/GL/AMD/__pycache__/vertex_shader_tessellator.cpython-312.pyc,, +OpenGL/GL/AMD/__pycache__/vertex_shader_viewport_index.cpython-312.pyc,, +OpenGL/GL/AMD/blend_minmax_factor.py,sha256=1Tt7eYgOckQJb7lgTgFCLrKWHnzAa3azFnu4IwvMmrQ,1508 +OpenGL/GL/AMD/conservative_depth.py,sha256=w9pYgaOVvTQdioUxKfaM_ZD4sR5m5kLylljR2o10NoU,1568 +OpenGL/GL/AMD/debug_output.py,sha256=YqySx1G_GondAdLauXkVnBWZL0f9jIXbj0vQj0v8g8g,4091 +OpenGL/GL/AMD/depth_clamp_separate.py,sha256=YqXDgVo7_uIzcFOWfDl5EmpHKGQOe88N4w-UNxZhS7o,1245 +OpenGL/GL/AMD/draw_buffers_blend.py,sha256=rvSZ3nFuSd0cp_XK243tfLSWhp9-HQxfV8sKv7skJmY,1261 +OpenGL/GL/AMD/framebuffer_multisample_advanced.py,sha256=Lnc0qanjvDm6gVB1FR2Xt7ZsoSN4ODC9CQs-Tnj5suc,1918 +OpenGL/GL/AMD/framebuffer_sample_positions.py,sha256=GMwg7fSyBqIRR7c-DVLoKGYG6d6_DCx1oW1iJbjWbFE,1953 +OpenGL/GL/AMD/gcn_shader.py,sha256=aEr823__hpR0SUIUGMFLD8XRTq-6AfqwjnW4DjUClkc,1102 +OpenGL/GL/AMD/gpu_shader_half_float.py,sha256=adFz509cqs43Lt2cSLPoqY0Nc2bgJAmd008OQ7sT0i4,1770 +OpenGL/GL/AMD/gpu_shader_int16.py,sha256=KGnmVOBxKcTnlfCq66PbUJ9nTuuxzce8xEfWUEQ1vYw,1461 +OpenGL/GL/AMD/gpu_shader_int64.py,sha256=Us33I5Xav5FaK2ecuJXEdwR2J_Lgfo2ROS1fMtrX4bY,4763 +OpenGL/GL/AMD/interleaved_elements.py,sha256=HNYcOAhcxrh8igfcodm4duWuS6pTJiB1_ckK03A0-eU,2719 +OpenGL/GL/AMD/multi_draw_indirect.py,sha256=9dTzPCHvsBsmXBwbmKjUvhIYYtcNgkQvu3JDjn1cpKE,1528 +OpenGL/GL/AMD/name_gen_delete.py,sha256=5g7El0Sl1WfrbquUvdmYAfWeooNuxX04m8NK6Zsg3sI,1909 +OpenGL/GL/AMD/occlusion_query_event.py,sha256=buJHS3FHh5hNg-ypt65g8EkVT4StSGgeSByeZYwIzHU,1722 +OpenGL/GL/AMD/performance_monitor.py,sha256=m_cGloMQzFlSPuOZwwT20r4ChoFiBVlbgD0f95sCGWE,3045 +OpenGL/GL/AMD/pinned_memory.py,sha256=brNoMBY9ZmZw1W8TAi4BP4EYKe4kC9BWFbgyJZA-DFo,1275 +OpenGL/GL/AMD/query_buffer_object.py,sha256=3ikEbsqVJorKQQT-W2Ey6trmqGBeiOEmsIzSyYWW5Vw,2234 +OpenGL/GL/AMD/sample_positions.py,sha256=vTJVPELsm4rWm5bRuYa0LcUnYPtuX1073l9uNqNeybI,1399 +OpenGL/GL/AMD/seamless_cubemap_per_texture.py,sha256=ehK2Zog6PdSozLxvgQM9o5JoXOU7RboJP75twHwBdeo,2229 +OpenGL/GL/AMD/shader_atomic_counter_ops.py,sha256=qtbm4Q-JJBn0PkNTuM-xLROYYQL7Fq93fmfsr9HRBcE,1377 +OpenGL/GL/AMD/shader_ballot.py,sha256=m7kqaGTOB4ShuRbCYy2N94q21UkssHPAWsIiSfYaBs0,1082 +OpenGL/GL/AMD/shader_explicit_vertex_parameter.py,sha256=9eZ_t6dT0xI2_oebdAm5B1Jc3tceLs68YTi1pEcgdgI,1367 +OpenGL/GL/AMD/shader_gpu_shader_half_float_fetch.py,sha256=P3oKdNcOLG5C_OmbO0d5p9zVFPQKgzHi6zXKx24kn1A,872 +OpenGL/GL/AMD/shader_image_load_store_lod.py,sha256=WjEZF38VgWcozNOqzOOebPBKuQQEt-GAdyGqWHKHbBU,1021 +OpenGL/GL/AMD/shader_stencil_export.py,sha256=vLRTBImdcMbhA_0oYFQfxpTmjA1znfAge5HFZVY9TV8,1503 +OpenGL/GL/AMD/shader_trinary_minmax.py,sha256=phzhhoLaCWbsHLDVQku7ZVVMXx98AthSY_tQ4UWI7lg,1336 +OpenGL/GL/AMD/sparse_texture.py,sha256=LTqrJO6xbhT9TQhCswImlwhvBtA_Fn054xGjMvNZpVs,1842 +OpenGL/GL/AMD/stencil_operation_extended.py,sha256=RHOyoM43avLydj-hqWACsnw7hu97DeyUkfN7MVcDdG8,1755 +OpenGL/GL/AMD/texture_gather_bias_lod.py,sha256=AxKAOHrpzgGHplRGy3Y_q917rmoFdMmg5FH2ZRgloKI,1059 +OpenGL/GL/AMD/texture_texture4.py,sha256=Axzw-r9GKnWki2-yiv1XbTMJD72IdcDBbR8f6RD8ojc,1356 +OpenGL/GL/AMD/transform_feedback3_lines_triangles.py,sha256=El1jr6ejz3Gw559EyEzhO-IA_ZcH05SNHFr8ohyWkmw,1320 +OpenGL/GL/AMD/transform_feedback4.py,sha256=5ykdPdJSaozelnwT1Y7e5Rl9iWl5eKSM3nZAezEXNoI,2384 +OpenGL/GL/AMD/vertex_shader_layer.py,sha256=1ThMCZPcaHbtIzA7vhlQ2p5bSh8YPgreoLi0fX-aElM,2004 +OpenGL/GL/AMD/vertex_shader_tessellator.py,sha256=15FA_oMkV0cwVuMARaoNeROm1VuBPb38kQpC12hgn4g,2624 +OpenGL/GL/AMD/vertex_shader_viewport_index.py,sha256=J0WQ4HgG98RUZknO2PjBoz01B95MvC4AHajsxXdFE2k,1569 +OpenGL/GL/ANGLE/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/GL/ANGLE/__pycache__/__init__.cpython-312.pyc,, +OpenGL/GL/APPLE/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/GL/APPLE/__pycache__/__init__.cpython-312.pyc,, +OpenGL/GL/APPLE/__pycache__/aux_depth_stencil.cpython-312.pyc,, +OpenGL/GL/APPLE/__pycache__/client_storage.cpython-312.pyc,, +OpenGL/GL/APPLE/__pycache__/element_array.cpython-312.pyc,, +OpenGL/GL/APPLE/__pycache__/fence.cpython-312.pyc,, +OpenGL/GL/APPLE/__pycache__/float_pixels.cpython-312.pyc,, +OpenGL/GL/APPLE/__pycache__/flush_buffer_range.cpython-312.pyc,, +OpenGL/GL/APPLE/__pycache__/object_purgeable.cpython-312.pyc,, +OpenGL/GL/APPLE/__pycache__/rgb_422.cpython-312.pyc,, +OpenGL/GL/APPLE/__pycache__/row_bytes.cpython-312.pyc,, +OpenGL/GL/APPLE/__pycache__/specular_vector.cpython-312.pyc,, +OpenGL/GL/APPLE/__pycache__/texture_range.cpython-312.pyc,, +OpenGL/GL/APPLE/__pycache__/transform_hint.cpython-312.pyc,, +OpenGL/GL/APPLE/__pycache__/vertex_array_object.cpython-312.pyc,, +OpenGL/GL/APPLE/__pycache__/vertex_array_range.cpython-312.pyc,, +OpenGL/GL/APPLE/__pycache__/vertex_program_evaluators.cpython-312.pyc,, +OpenGL/GL/APPLE/__pycache__/ycbcr_422.cpython-312.pyc,, +OpenGL/GL/APPLE/aux_depth_stencil.py,sha256=_Pt7kiiOv1B-n1uuSpSaXifUBW6xxwWJr5kd7Vcci9A,2110 +OpenGL/GL/APPLE/client_storage.py,sha256=AZWzZWsVJrO85Rv7Uku1g9Vr4l1DCXJJhgggJ7zwzgI,6135 +OpenGL/GL/APPLE/element_array.py,sha256=LxBaMmS-Vry7jL_yBKvvEFEvD-MFZYTpd2nODcLxui4,2536 +OpenGL/GL/APPLE/fence.py,sha256=bVjJKTU8Y6skvULOVZQEzumiKRWCY6R-gQUDKZXbhgs,4079 +OpenGL/GL/APPLE/float_pixels.py,sha256=IlgFhg_3jOJOT988IsnLT_7xu6adFWoO7NgBS0UMZA4,3155 +OpenGL/GL/APPLE/flush_buffer_range.py,sha256=0d5mahWzwbthV_7-_AAHSGFy1AECf1PpY300EbadKYo,1911 +OpenGL/GL/APPLE/object_purgeable.py,sha256=4sg4mBB_9IfgirUwHO7pajX2B0Y6MsCrw_Egz1fTGQI,3881 +OpenGL/GL/APPLE/rgb_422.py,sha256=7aMYg1_7Jg8CSySV3w5qumAIIOkNt98Up-lSQNB643w,2858 +OpenGL/GL/APPLE/row_bytes.py,sha256=dXMnrSE2Czba1g5tG2JKGpcPfuJksWpwsQEPLJ4v1MQ,2348 +OpenGL/GL/APPLE/specular_vector.py,sha256=yOS_tde2qOR87YPkDW-KF1YCfllD9U1qS63-DZDim0g,2009 +OpenGL/GL/APPLE/texture_range.py,sha256=S_q-HQo0-ia5fhdnSLpsW8pEyQpwjbWOesJlZNmwDhs,1928 +OpenGL/GL/APPLE/transform_hint.py,sha256=PZNoo0yyAYudVRnCJV84K1Ipfbb5hib-DUnGcvJkcAU,1674 +OpenGL/GL/APPLE/vertex_array_object.py,sha256=jhM2gev034dSE4P-F4tSXHs4460paYpT7jw_mn4wAPw,2263 +OpenGL/GL/APPLE/vertex_array_range.py,sha256=6an-gvMmGw4kpAIteVv828RqB2wABCvBvVV7FUeMHCI,8805 +OpenGL/GL/APPLE/vertex_program_evaluators.py,sha256=gQigrqkpWteCEgkJqmShdMfjkoANz3YOxCPIDZ_U32o,2651 +OpenGL/GL/APPLE/ycbcr_422.py,sha256=4K7VnLNPoLfIsFUMPiBHPWrY0YC0nztbLSBRtO8BVRQ,3045 +OpenGL/GL/ARB/ES2_compatibility.py,sha256=t4RfLffqre2YV_uuGg4Mho8GkmmGFiyor-0cx7D26mo,1963 +OpenGL/GL/ARB/ES3_1_compatibility.py,sha256=NpavOAmSOqVFtY684JW9rxy-sE3GRdocg3-8zyArvXo,2182 +OpenGL/GL/ARB/ES3_2_compatibility.py,sha256=J2tCeRRYpTkKPyTvdtFLRS6oUwSq5ZJ7fpZ4YPTWHCQ,1495 +OpenGL/GL/ARB/ES3_compatibility.py,sha256=32o4oaPT9x_OUZUXwrXQU2Fehhm3ysw3-VsWWlcl9sc,1187 +OpenGL/GL/ARB/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/GL/ARB/__pycache__/ES2_compatibility.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/ES3_1_compatibility.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/ES3_2_compatibility.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/ES3_compatibility.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/__init__.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/arrays_of_arrays.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/base_instance.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/bindless_texture.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/blend_func_extended.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/buffer_storage.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/cl_event.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/clear_buffer_object.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/clear_texture.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/clip_control.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/color_buffer_float.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/compatibility.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/compressed_texture_pixel_storage.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/compute_shader.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/compute_variable_group_size.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/conditional_render_inverted.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/conservative_depth.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/copy_buffer.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/copy_image.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/cull_distance.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/debug_output.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/depth_buffer_float.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/depth_clamp.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/depth_texture.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/derivative_control.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/direct_state_access.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/draw_buffers.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/draw_buffers_blend.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/draw_elements_base_vertex.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/draw_indirect.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/draw_instanced.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/enhanced_layouts.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/explicit_attrib_location.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/explicit_uniform_location.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/fragment_coord_conventions.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/fragment_layer_viewport.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/fragment_program.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/fragment_program_shadow.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/fragment_shader.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/fragment_shader_interlock.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/framebuffer_no_attachments.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/framebuffer_object.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/framebuffer_sRGB.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/geometry_shader4.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/get_program_binary.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/get_texture_sub_image.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/gl_spirv.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/gpu_shader5.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/gpu_shader_fp64.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/gpu_shader_int64.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/half_float_pixel.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/half_float_vertex.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/imaging.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/indirect_parameters.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/instanced_arrays.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/internalformat_query.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/internalformat_query2.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/invalidate_subdata.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/map_buffer_alignment.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/map_buffer_range.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/matrix_palette.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/multi_bind.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/multi_draw_indirect.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/multisample.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/multitexture.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/occlusion_query.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/occlusion_query2.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/parallel_shader_compile.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/pipeline_statistics_query.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/pixel_buffer_object.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/point_parameters.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/point_sprite.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/polygon_offset_clamp.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/post_depth_coverage.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/program_interface_query.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/provoking_vertex.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/query_buffer_object.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/robust_buffer_access_behavior.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/robustness.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/robustness_isolation.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/sample_locations.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/sample_shading.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/sampler_objects.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/seamless_cube_map.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/seamless_cubemap_per_texture.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/separate_shader_objects.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/shader_atomic_counter_ops.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/shader_atomic_counters.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/shader_ballot.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/shader_bit_encoding.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/shader_clock.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/shader_draw_parameters.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/shader_group_vote.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/shader_image_load_store.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/shader_image_size.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/shader_objects.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/shader_precision.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/shader_stencil_export.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/shader_storage_buffer_object.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/shader_subroutine.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/shader_texture_image_samples.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/shader_texture_lod.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/shader_viewport_layer_array.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/shading_language_100.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/shading_language_420pack.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/shading_language_include.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/shading_language_packing.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/shadow.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/shadow_ambient.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/sparse_buffer.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/sparse_texture.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/sparse_texture2.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/sparse_texture_clamp.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/spirv_extensions.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/stencil_texturing.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/sync.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/tessellation_shader.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/texture_barrier.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/texture_border_clamp.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/texture_buffer_object.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/texture_buffer_object_rgb32.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/texture_buffer_range.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/texture_compression.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/texture_compression_bptc.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/texture_compression_rgtc.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/texture_cube_map.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/texture_cube_map_array.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/texture_env_add.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/texture_env_combine.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/texture_env_crossbar.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/texture_env_dot3.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/texture_filter_anisotropic.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/texture_filter_minmax.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/texture_float.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/texture_gather.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/texture_mirror_clamp_to_edge.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/texture_mirrored_repeat.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/texture_multisample.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/texture_non_power_of_two.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/texture_query_levels.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/texture_query_lod.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/texture_rectangle.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/texture_rg.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/texture_rgb10_a2ui.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/texture_stencil8.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/texture_storage.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/texture_storage_multisample.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/texture_swizzle.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/texture_view.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/timer_query.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/transform_feedback2.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/transform_feedback3.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/transform_feedback_instanced.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/transform_feedback_overflow_query.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/transpose_matrix.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/uniform_buffer_object.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/vboimplementation.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/vertex_array_bgra.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/vertex_array_object.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/vertex_attrib_64bit.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/vertex_attrib_binding.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/vertex_blend.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/vertex_buffer_object.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/vertex_program.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/vertex_shader.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/vertex_type_10f_11f_11f_rev.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/vertex_type_2_10_10_10_rev.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/viewport_array.cpython-312.pyc,, +OpenGL/GL/ARB/__pycache__/window_pos.cpython-312.pyc,, +OpenGL/GL/ARB/arrays_of_arrays.py,sha256=sBe5MW99bg13QJQ8Lf-vzL1hnQQ-D9-6pMv7bkJhoho,3563 +OpenGL/GL/ARB/base_instance.py,sha256=HX3cFS86dil9amnJI6Cw2dWfOB24JxfEzM6nR9uFz80,2359 +OpenGL/GL/ARB/bindless_texture.py,sha256=NYL4ZYBjyF5u9a7rBWyHs2xqIyBHhCJC5M9SwaAszW0,3835 +OpenGL/GL/ARB/blend_func_extended.py,sha256=gkepZvYUfqukiHfIFjwN22zSNiUEgmtSsoZhaffjJa0,1692 +OpenGL/GL/ARB/buffer_storage.py,sha256=OsnQ4UUYlBruiOnWghmVjkM0yBcbEE4eFORTWptdprQ,2114 +OpenGL/GL/ARB/cl_event.py,sha256=I78Iz2tp1AQRCOGjXPAd4oYcAPpOW5-mkseOmqxMtlo,1133 +OpenGL/GL/ARB/clear_buffer_object.py,sha256=0z4uNPZG7EeEvV1Tm_YuOpRhP1SqRkBZoV21CTuLUos,1929 +OpenGL/GL/ARB/clear_texture.py,sha256=MbXHA138ZhdadEtm9ttOULK1AMxr3r9dwdB4T8n1y8M,2627 +OpenGL/GL/ARB/clip_control.py,sha256=so6Ev-wgOyoWYs7l3WCpTDKtr1vzqo2RG50eEljyg8A,3917 +OpenGL/GL/ARB/color_buffer_float.py,sha256=LHHjmXLBNmZkfXQ-__hnERxTLlt6joQwdR9ri9KkOz0,2144 +OpenGL/GL/ARB/compatibility.py,sha256=98wkhpCRVukT3it-WQ9_HEYxwjDuz0RZi06H99QApsw,751 +OpenGL/GL/ARB/compressed_texture_pixel_storage.py,sha256=_u6ASi0lVOjg8Tm2DoFse0pOTHkLDYIN1LQldFWAUSs,2196 +OpenGL/GL/ARB/compute_shader.py,sha256=w91CF-60EGnYGOkE95aN79dSit9W4uVtkvqmR8S4mSY,3083 +OpenGL/GL/ARB/compute_variable_group_size.py,sha256=jwa3O-sdx2WVUXMLxQUN9jZ96L8fca2j06lea3bZJ3c,1670 +OpenGL/GL/ARB/conditional_render_inverted.py,sha256=2KE9l4yj3AQNDFprQp1GuESIfliucrf6Kg5He3B-dIo,988 +OpenGL/GL/ARB/conservative_depth.py,sha256=sJoKzaBps7WCqjwVhmCGLu3dS-0C5m_xuZg14k2qHg4,1568 +OpenGL/GL/ARB/copy_buffer.py,sha256=8Oyu7TEHfSv2icSRmhEx5fP_WUmA3f8PwP9_tb6QyFw,1007 +OpenGL/GL/ARB/copy_image.py,sha256=kI5pHVY2d5Ea2AEgMWjoohCvVhiYw7NKD6JDvqn0dnk,1602 +OpenGL/GL/ARB/cull_distance.py,sha256=eOLsDfAkw5-vdSrIS-uinCiv4Rzfimf6dqTD6SljZ0o,993 +OpenGL/GL/ARB/debug_output.py,sha256=XCpKSfHWJLfRZ6nHMB5lD7lllGiFWdmUbGRETIE4XYw,5121 +OpenGL/GL/ARB/depth_buffer_float.py,sha256=MXvQAEQIn5IcThHQWRvcoqtMbbwqvZQGXvFccd0s-cs,1767 +OpenGL/GL/ARB/depth_clamp.py,sha256=r9itqwNonpurc7XBk2kBINSjil1PMTx_5HVZG2MGSXs,2384 +OpenGL/GL/ARB/depth_texture.py,sha256=m2u65LkCWvwwl4opZMeOjZULYdPMLc58fBL7perZv4E,1387 +OpenGL/GL/ARB/derivative_control.py,sha256=wkmXBTuKpMUBfky0OhvmMj7jB8xGylTmrzFEdCITjcA,1782 +OpenGL/GL/ARB/direct_state_access.py,sha256=OcEcS3gh6uc7-8NegZzNz7EsmPmDC6zArpcKo8xRSnQ,4807 +OpenGL/GL/ARB/draw_buffers.py,sha256=y0novC4b8DXTwhNc8mML6p8wH71biV_hHFge3XApHtE,1579 +OpenGL/GL/ARB/draw_buffers_blend.py,sha256=IDLQ0s-LPC_3wpY8NyD10LgtNIWAFDnpfi1-iJvyCJA,1261 +OpenGL/GL/ARB/draw_elements_base_vertex.py,sha256=ddqT6TyHu05utzBd7LZW2W4vP6wyMUG-C5-BELraihE,4190 +OpenGL/GL/ARB/draw_indirect.py,sha256=ROF-wKVN0SqyjYIPqjrvKLJrh6JFUB0bLS2w3VuweF0,1567 +OpenGL/GL/ARB/draw_instanced.py,sha256=__Ob9LbSYbwHWYlm6yMqoIbXN3GVGSufDLkszBMbWRs,1916 +OpenGL/GL/ARB/enhanced_layouts.py,sha256=e4V8IZGI6_bnBHDZhZqCxI4JVn_r7QyJnTH7kzTvyGM,4204 +OpenGL/GL/ARB/explicit_attrib_location.py,sha256=Sg_ydEIMtFbViXunBaVoyzPRlVluye_SbE5AoOgFpjM,1224 +OpenGL/GL/ARB/explicit_uniform_location.py,sha256=KPmpcXkp8GfECZ0zDnaY_kYRXiLdNjYlLTN6Kts1N4A,1164 +OpenGL/GL/ARB/fragment_coord_conventions.py,sha256=HiwNHTsF2Q40016eRFlv88sTz5f9LrGjuCunvABc9dE,3566 +OpenGL/GL/ARB/fragment_layer_viewport.py,sha256=aAWVnU-mKjTabpZSdmLE5frOJrasrM4c6ciroVp288k,1398 +OpenGL/GL/ARB/fragment_program.py,sha256=JkM1Iw4WGsG7W1kIJTWBNQM-Y1O8ey7pyRZdfu031pE,5002 +OpenGL/GL/ARB/fragment_program_shadow.py,sha256=1J8bfKvkL_lAzC982hxeBdHW1_aWg_OWPNoC09uO6Ek,1784 +OpenGL/GL/ARB/fragment_shader.py,sha256=xj7m8eSsUYfMIBu0jcpR1dyFNhXrhlgBA3tSno83R18,1516 +OpenGL/GL/ARB/fragment_shader_interlock.py,sha256=5_YSnaLJhvHfb_hPrfxzmkazO9fKu5ctmlp9zBtCdNM,3918 +OpenGL/GL/ARB/framebuffer_no_attachments.py,sha256=t5svhplfbSrer25-EwLTyR-W9vVvGkmBoKDENMPpTl8,3815 +OpenGL/GL/ARB/framebuffer_object.py,sha256=pl0ubFkO93HH7uCLD_rbDPAMiOZx9-4-5kn87cNH6u4,16728 +OpenGL/GL/ARB/framebuffer_sRGB.py,sha256=XKzOAmi3lZtNfPRAj4UOmuLZTrUlSofGwtXRt2xiOk0,2408 +OpenGL/GL/ARB/geometry_shader4.py,sha256=0DNfMso6l8td4KGq16mTSIyaCVRimMo8UyNxDN7BLJs,2458 +OpenGL/GL/ARB/get_program_binary.py,sha256=Y9TqjHL6jHxINNtikyrEf3tTjunLQbSxSxpwaC3XYKI,2520 +OpenGL/GL/ARB/get_texture_sub_image.py,sha256=au2NsfxYoCZnNZp3y_pVqvCvHTTp10G3H-tNZZA4EZw,899 +OpenGL/GL/ARB/gl_spirv.py,sha256=qwXMyYnuITKZDULZ_D1QDpuzV3-XJdjyHbJL-3QjFkU,16082 +OpenGL/GL/ARB/gpu_shader5.py,sha256=meaxhYDU4N7ZB0Boc1uCK0KWq0F02yNkZzsJNgffXgU,4132 +OpenGL/GL/ARB/gpu_shader_fp64.py,sha256=Q7sBIS3I95w1qjiQTLl9Qw51SxtCft-MQiOUYI1HLlA,5170 +OpenGL/GL/ARB/gpu_shader_int64.py,sha256=yQ68Q9jUoDnnPxbJ4Ty3TK-yuyxe37BnlpH2ZPxWYr8,4899 +OpenGL/GL/ARB/half_float_pixel.py,sha256=pRyAtbmjDVavNAoMdzWR1Ly-KB59mVnP9o20SzeKqRg,1544 +OpenGL/GL/ARB/half_float_vertex.py,sha256=vxTBGUczKPzoLc1SuVYDK_7hnFwZ_NiEdfX7FPhXYy8,1295 +OpenGL/GL/ARB/imaging.py,sha256=EhLq9fe6B6451I9dlpP82stO6ms2dir-7I-vaEXUwS0,8511 +OpenGL/GL/ARB/indirect_parameters.py,sha256=HUEzGfiDeBAQPhWKkUXNICfJJLEK87HAN0t8Oxzm-vU,2126 +OpenGL/GL/ARB/instanced_arrays.py,sha256=glyDxKI0TLxYKECG5MuW6CuDz7fPTwHvLtYsdrEUZmw,2044 +OpenGL/GL/ARB/internalformat_query.py,sha256=rLswxEw6lFWbX-YDTogHEH-c2ObOmjYglgqp3aVdecQ,1526 +OpenGL/GL/ARB/internalformat_query2.py,sha256=k1KgXfMi85pADVwolZdaUfo1aalpgGsZMSUgvMkyPIU,3305 +OpenGL/GL/ARB/invalidate_subdata.py,sha256=6bRX4J6IFr4tHtc3Mjaa-HowVkyr7WTd2OcOrEZ0WR4,3121 +OpenGL/GL/ARB/map_buffer_alignment.py,sha256=TCyc7KM2sN2oTyBg3CudnxsOIDdqtiqZSyBj8FU4mMU,1053 +OpenGL/GL/ARB/map_buffer_range.py,sha256=Qo3wsp2AkU3M38WR_Km7ISst85t5WwyGRDuWcnLC5dg,2100 +OpenGL/GL/ARB/matrix_palette.py,sha256=34SkmSCpWO56xNEl2BLs8L5BwBufIMCZ978dIrWSkXg,2280 +OpenGL/GL/ARB/multi_bind.py,sha256=dSFUZcZFpRVY3EfP5M1lBikY9fnYnqnzve-sL-750sI,3706 +OpenGL/GL/ARB/multi_draw_indirect.py,sha256=fnN5ZCzqqbsvmDuiJoRNithRpDkHc5VXcG-7dcNpXo4,1929 +OpenGL/GL/ARB/multisample.py,sha256=ihIWKb_814-rUb7rJR26gj8bYxZnbcxhTmsCPc1poXA,2258 +OpenGL/GL/ARB/multitexture.py,sha256=9LGjAuLI5rRwLQ_RCcFueFkOMOPd8HSPeaZTpa6zuOI,2233 +OpenGL/GL/ARB/occlusion_query.py,sha256=J2nWWnwmTNZPpYXvCEpYTfNvfV3h_sjox17NL6dEMt4,5210 +OpenGL/GL/ARB/occlusion_query2.py,sha256=LjyFP3Hg7M-OYTycMs6t9ksKRK0Nc1qDuPSFNUyOeKA,1054 +OpenGL/GL/ARB/parallel_shader_compile.py,sha256=UIyyWU7VrDRx3TziMxaZSBsMnN0dEY10Ca2iGQaXf10,1227 +OpenGL/GL/ARB/pipeline_statistics_query.py,sha256=raRUlWg-vSw9bJ4hssz2ExbbxdjzEzYbU5vpC99YUWo,1471 +OpenGL/GL/ARB/pixel_buffer_object.py,sha256=B7hjYr7ZySsD3hiWka3GsL673fTmLkumVVxytsxLrCk,4352 +OpenGL/GL/ARB/point_parameters.py,sha256=dHGwInOcQ-J22VfNAjhzd0RGd9lG0WQ8R7MtbqL3yKI,3166 +OpenGL/GL/ARB/point_sprite.py,sha256=WMXuFF39QVV9HczbMDTSX2DXB60VJi-n5aqJAxu669c,1707 +OpenGL/GL/ARB/polygon_offset_clamp.py,sha256=Nj-xccZFv_eFT1cP--QVJc57fEHSkIccU7Vu2zGxn9Y,1390 +OpenGL/GL/ARB/post_depth_coverage.py,sha256=6cW1sn1J7SVkz2zZz3EY9YLgwOdPitxxrTHrAeUU4xQ,1175 +OpenGL/GL/ARB/program_interface_query.py,sha256=soWpEyscn4ZfOvagBgqyzwSDXtraIqJi4L5v_IoQc3A,4220 +OpenGL/GL/ARB/provoking_vertex.py,sha256=2JAenNkRNB9BDWcTWLLGw1gDiAI-mX3ZSqXP6FOuPtU,2070 +OpenGL/GL/ARB/query_buffer_object.py,sha256=NZ2Y6Io72-hgzyJQ9J5kRy3fANlChvwpFDDXwksZS-A,2267 +OpenGL/GL/ARB/robust_buffer_access_behavior.py,sha256=ek7U6vXlqk358DD5y5m2XWmcIYgrSerP0Cytu9cm0kE,1501 +OpenGL/GL/ARB/robustness.py,sha256=qyHDC5Yw5d0GfoLSeM0Gv0C53fhxXHKdgplxdYEMkjE,8447 +OpenGL/GL/ARB/robustness_isolation.py,sha256=zE_kFQRBNUxtBG2bDMfSl14meZvZ9JltLV5-Op2Acog,792 +OpenGL/GL/ARB/sample_locations.py,sha256=UiGKD8QwgNV28TeVi_W9nQ2jApLisSdSsCNW0rb5WXk,2715 +OpenGL/GL/ARB/sample_shading.py,sha256=x6VQZ-kfwE9cR343VCfTeVsNr7qqXlISS3JboGVoTUc,2108 +OpenGL/GL/ARB/sampler_objects.py,sha256=_RQ2aY0Nn1cR5C_goF2Lrgbxeziw0IKbduUL0Fvy_VQ,3963 +OpenGL/GL/ARB/seamless_cube_map.py,sha256=wT92fkvfOmRwBQwxGFS4lEh0wyrZf8jVjMCJZfg8cso,1880 +OpenGL/GL/ARB/seamless_cubemap_per_texture.py,sha256=-gA2Wuj0NM0PsFotLxew-daHENRdNFUeRGjVtax_uTw,2256 +OpenGL/GL/ARB/separate_shader_objects.py,sha256=lRGXLTqylpp4_h-_P7lKSYmMxQQd4WhaU53husOywaU,11367 +OpenGL/GL/ARB/shader_atomic_counter_ops.py,sha256=6nxSWVUA4SSt3X31qUj_oz0y2wmAoWa0SXidxr0_NsA,1316 +OpenGL/GL/ARB/shader_atomic_counters.py,sha256=9DPQ1ZuiQtTww-4xXJKNaUzTmgwy-cZriZTCTPrXIdk,2504 +OpenGL/GL/ARB/shader_ballot.py,sha256=oV7iO8nWnh0b1XGsbMJvZ7ru9MDkhklLnKwzj_02NNM,1063 +OpenGL/GL/ARB/shader_bit_encoding.py,sha256=jRxe6eyOhJr9nET5wFsrQxWWWFhdwbteSdpUBdK2H8U,1084 +OpenGL/GL/ARB/shader_clock.py,sha256=13to7lFEkcFoJWZ6J2VimCnEPYnbw8WTDRrafiitBjU,937 +OpenGL/GL/ARB/shader_draw_parameters.py,sha256=vywe85lTZnD0iHmk8odLuYO8kGGpdmZwHqgh9HcO5RQ,2373 +OpenGL/GL/ARB/shader_group_vote.py,sha256=mB29Y_WscqAp3Kni9JLDCCCcti8afiyCMtU4znpBw8s,3348 +OpenGL/GL/ARB/shader_image_load_store.py,sha256=CDM6dMSnIbGcnm0s4E1xENWz3PBM7zYdw3_row9lisg,3601 +OpenGL/GL/ARB/shader_image_size.py,sha256=bSv9F7G6hDYyxvtXoAfxtk_erQba3NSyqnWE3n9PVLU,897 +OpenGL/GL/ARB/shader_objects.py,sha256=9rJAlYe3wzzAAlq1-dVFiN7Mg2tOFvzdtoM34o198ZE,10655 +OpenGL/GL/ARB/shader_precision.py,sha256=NF7Bgbq_L9UC5io2rzhP8O6jCy8tV28PVQGHh3lrN8o,1242 +OpenGL/GL/ARB/shader_stencil_export.py,sha256=STN1K7eZ2h_Km0YVwxis4mS-dcPZx-1OnJ7fUHgqW7I,1503 +OpenGL/GL/ARB/shader_storage_buffer_object.py,sha256=0w91PR7nSHjbC8MDRH0IqtosEc8GsVzMfUbVKbMTqFg,3198 +OpenGL/GL/ARB/shader_subroutine.py,sha256=jz1wkRLN-RcKkvDA4OW8wDNM31al7HhjjVmM1vNAyE8,2181 +OpenGL/GL/ARB/shader_texture_image_samples.py,sha256=YYZ5Nfdlw2PKHqRBmDpu4Rjd2B1dC4VgnWOvUAYoPZA,978 +OpenGL/GL/ARB/shader_texture_lod.py,sha256=5XaYJuv3GOV-xaAC-OLcfr8fSZEEGUOPoxLYZawZiio,4493 +OpenGL/GL/ARB/shader_viewport_layer_array.py,sha256=fguTsXp2GMBTtSjgk8eZ5tYTY_taLwP09Zb-SEMp5Pw,1837 +OpenGL/GL/ARB/shading_language_100.py,sha256=HUd18O6hNGbBS6hRCcO1Y4ut3k4cU3AYrgLpMYNJIio,1053 +OpenGL/GL/ARB/shading_language_420pack.py,sha256=H0CPuM-0Y9QLipOuiztq07lcQMC7cQEk1IKcXT7oQNQ,2537 +OpenGL/GL/ARB/shading_language_include.py,sha256=x6uYc9gEncuPmFDpvuGT0AqafEYVsayQRqIk-XrCn5s,2542 +OpenGL/GL/ARB/shading_language_packing.py,sha256=2t9YwylcUh6nouyqU3aT1VXZRLXgSiRvD1iDovbtgRA,1779 +OpenGL/GL/ARB/shadow.py,sha256=qTc998rO2othQfDvVyqjSwg9H_YNCWNQ2-iLCTVjBOE,1094 +OpenGL/GL/ARB/shadow_ambient.py,sha256=S49rxgfJLLom0ke24DtgO4FJK6rjSDf49ia9BN2mems,1229 +OpenGL/GL/ARB/sparse_buffer.py,sha256=uBQhnszRoYdu5IuYGdYQw8gpQyiDD6gQOohokzjYM8Q,1189 +OpenGL/GL/ARB/sparse_texture.py,sha256=ddqSyJXbe9ZjaCEJu15A72E8bp0hxJl2H1c8fbziQcE,1842 +OpenGL/GL/ARB/sparse_texture2.py,sha256=tW6osqICD6lwwP81BPgjRtZpjS8qHlZWcMnjtqLlIgs,2190 +OpenGL/GL/ARB/sparse_texture_clamp.py,sha256=Ysp82QE-2AKJ1ql1VczjuJpP6dt1w7P3Ur1PBb0qt_Y,1415 +OpenGL/GL/ARB/spirv_extensions.py,sha256=XwngyaPXEkc28o44Gb4TaZgHnemijG6ckTd8JUxk2cE,2089 +OpenGL/GL/ARB/stencil_texturing.py,sha256=NL7A0PMlnp9uG4oJkarK66viFKsVxCLgaoBKb9bReUI,1115 +OpenGL/GL/ARB/sync.py,sha256=22y52cgc4kKOBpRraw17jmFKW8iTgRGdp6I5Ffxzqtk,3182 +OpenGL/GL/ARB/tessellation_shader.py,sha256=0j7tiEJ-ANX8yNTnGW6eGVHD7ppTzdFZMqC8kxWu0Wk,5185 +OpenGL/GL/ARB/texture_barrier.py,sha256=7m4JWvnGsVBjyF3oKaBxqOWHx16vowJty4ZM0suepzI,935 +OpenGL/GL/ARB/texture_border_clamp.py,sha256=T_3AFo6mbQD2GV14zapk7HB34WBvCwt1hSzAwLy_cVQ,1519 +OpenGL/GL/ARB/texture_buffer_object.py,sha256=ke4AYrgpcMJIJNc0wMjoWFtE1cckNaOFymUzfT5ZoCQ,2686 +OpenGL/GL/ARB/texture_buffer_object_rgb32.py,sha256=FzeqZFmsFJEU1JyHj2LDOlb-UBXWZn-uB4iTsRcVEmI,1144 +OpenGL/GL/ARB/texture_buffer_range.py,sha256=swtfaGVIzV6-12UvCsqx14KMIukKXimzDT9PlFxSvvs,1422 +OpenGL/GL/ARB/texture_compression.py,sha256=qmVX6YtnWTJtw1ejYS2_e1-f9-8Z6HfeMvHof_BcPuY,5943 +OpenGL/GL/ARB/texture_compression_bptc.py,sha256=j-IqQAE8-X5DgCAP8yL5afk26hquXt1OpW-gh6Ldnn0,1722 +OpenGL/GL/ARB/texture_compression_rgtc.py,sha256=tB46mu0iS6AVsCAkQyqWnvqAt7rLumiuKrXybe0huVk,1750 +OpenGL/GL/ARB/texture_cube_map.py,sha256=cC_llSWwbTsFVBQxx_f1SQZLB2ivYLg8AgmOpDV4GS0,3529 +OpenGL/GL/ARB/texture_cube_map_array.py,sha256=hX62bVP0CxrdXg1KsETpMslw-kmJj52iZxDfHJ-AZ_w,2171 +OpenGL/GL/ARB/texture_env_add.py,sha256=y7SHJj7YzXxDvAv_UEP9Xc3Eu8b0EkJZekd1hfbQizE,1124 +OpenGL/GL/ARB/texture_env_combine.py,sha256=u0mgrCegR2mJS1flhGmUWyw0QI9Pbwul8OapqYNo82Q,1645 +OpenGL/GL/ARB/texture_env_crossbar.py,sha256=xIOJEf3q_DJ2aqSSAGJqvBgpB_k82Akd8BtHgPWPpf8,1193 +OpenGL/GL/ARB/texture_env_dot3.py,sha256=HBTZse7yYL8Vjl1zuXrxsQEamcccuWcKoC9D0vEaoO4,1143 +OpenGL/GL/ARB/texture_filter_anisotropic.py,sha256=eRZ1hjnaVM3rsEv5OjRObSFdRRwB5h7xjOGI4WP5RBI,2894 +OpenGL/GL/ARB/texture_filter_minmax.py,sha256=SJTBP2k1rc4cHC8mCo72hhluWATReAOXKvGvH-W7PEA,1607 +OpenGL/GL/ARB/texture_float.py,sha256=jPVGfTYfgcB74q4o_YONvalYl_G61vOhq5qJIPjvmQ8,1145 +OpenGL/GL/ARB/texture_gather.py,sha256=cN7K_-mYYG5b_ITHAULRjWfV-h28kcz-6OjklzXK3vU,1072 +OpenGL/GL/ARB/texture_mirror_clamp_to_edge.py,sha256=72Ep7QQ1MkKO-hbjBqv_c1W0HpS9iaeO8Mscqf_ltfw,1400 +OpenGL/GL/ARB/texture_mirrored_repeat.py,sha256=S3h-A-Ge1meEZTWc3TJNGwljTw2kYZtpSnSEkucx4Xs,1281 +OpenGL/GL/ARB/texture_multisample.py,sha256=HSuiaNn5CiMBmMZ3HGKJDVTfqk9pygL5YMU3gesw8jw,1507 +OpenGL/GL/ARB/texture_non_power_of_two.py,sha256=xrlIDjvJQoUVl6GxkmhynGS0lFimkExKy2haTrD0nOc,1712 +OpenGL/GL/ARB/texture_query_levels.py,sha256=U_UR_soexN7uQbWMgLjf2YBACgC_friqluLAl0JQ9uU,2074 +OpenGL/GL/ARB/texture_query_lod.py,sha256=rcuroXeNEujr2gYaq18gSw1kND5kTSTr9TjDh82CUQM,1015 +OpenGL/GL/ARB/texture_rectangle.py,sha256=ZkcpVKPxbyGKb2cKCbfPzX5QrcPweAB1sceDrBBpPzU,2348 +OpenGL/GL/ARB/texture_rg.py,sha256=0tMnAJkpHkLI1OD8bw9NNdmC3v6_ZqV5mLslCYdpH3w,2248 +OpenGL/GL/ARB/texture_rgb10_a2ui.py,sha256=G73-MV4NdoTQDK7LBo85A9olyr9Cpi_W5ksVruGI45g,1165 +OpenGL/GL/ARB/texture_stencil8.py,sha256=r5vz9diQAS0Gt9543_zY-UC2WhzGBcKobTbVIoK1Dmk,1009 +OpenGL/GL/ARB/texture_storage.py,sha256=BZCl-ZB1fTct_gMn9LA7jh7MHkTqL4PnTKpSLyu0ZmM,1817 +OpenGL/GL/ARB/texture_storage_multisample.py,sha256=ySwzYhgxEbojJjIHdc6un6m8YG1oKZbu-8kBkCzDI_g,1621 +OpenGL/GL/ARB/texture_swizzle.py,sha256=0UkT8XdkwpClWuFOmfcUVVZ3jNTDUZBdp7RAmvh_9K4,1836 +OpenGL/GL/ARB/texture_view.py,sha256=080cQno1_Hjtr4PMK_x9JyJ92eDH9xLFe2J6HCUd_0s,1978 +OpenGL/GL/ARB/timer_query.py,sha256=0NxHGcTDjLNLtX77vNOgf-pM2SgV9Sk0f0TWORrWLPk,2369 +OpenGL/GL/ARB/transform_feedback2.py,sha256=Iuz8vpX7oYW-iQHclsVMtWq_pBsICUNeQanM_RnC_wI,2589 +OpenGL/GL/ARB/transform_feedback3.py,sha256=RbCmWDtMMf3ymMMR5LhU6t6lJNlSoC4EQXbTMNhbgUY,3795 +OpenGL/GL/ARB/transform_feedback_instanced.py,sha256=SUPkDBrKRVyHvSQF4_fYmAILylG3N-n984VCy7Ml9iU,1435 +OpenGL/GL/ARB/transform_feedback_overflow_query.py,sha256=d3nXagN0o0u6FWstr8JtgSGq1o6jYvcxrNpdW3N7MXY,1076 +OpenGL/GL/ARB/transpose_matrix.py,sha256=V-zhkXnUjQWUo1qhZqPF8AaK__agU3gUssUWCmA-vHU,1850 +OpenGL/GL/ARB/uniform_buffer_object.py,sha256=IL_5iRF2Bv1VmbIMsGkI_15P_1P_jXwpP6DKQDoqcFc,6810 +OpenGL/GL/ARB/vboimplementation.py,sha256=hPXkbHpu4xzsI_de8M23bSaoIg_x23H6SShBkZI0_go,1383 +OpenGL/GL/ARB/vertex_array_bgra.py,sha256=RthbmTDTdADuMJwKGlxyJQQXmOntFZpMDr1MSJhtvEI,3470 +OpenGL/GL/ARB/vertex_array_object.py,sha256=BMRzMifR34mLbWsffsp9Io124c6u_thyEHguPGW00tY,1833 +OpenGL/GL/ARB/vertex_attrib_64bit.py,sha256=bZHRLh8RtkTfX0tDC3zK8TIXPaCWRRUyGQLYsPVFdls,3920 +OpenGL/GL/ARB/vertex_attrib_binding.py,sha256=k22CG-WSScTqcJBKLKwlhE9sUdh-x-6nOr2bcopavxo,2240 +OpenGL/GL/ARB/vertex_blend.py,sha256=fJWMkVLMqJUxW6dMd27UICQ-o5lY9F4qCeNbXYD6Ins,2905 +OpenGL/GL/ARB/vertex_buffer_object.py,sha256=mG9jXaJT1eVwP4V2i0RJmeQ8ZAyGgmA_q0J1iZuNzx8,7400 +OpenGL/GL/ARB/vertex_program.py,sha256=GLnAGVmZHXXt9wrHZMcmExwgxph13s3g2WUQLQ4b6y4,9290 +OpenGL/GL/ARB/vertex_shader.py,sha256=df5X3lXCTN28J6zy-2v0Tf9bEUR4L1c1C4ly8KUtfNo,5900 +OpenGL/GL/ARB/vertex_type_10f_11f_11f_rev.py,sha256=xHoLLhHIRjlhXf8d7Fj6BGmk25F4vElVeack4p8O7x4,1285 +OpenGL/GL/ARB/vertex_type_2_10_10_10_rev.py,sha256=fBWQWNp5u6J7-LokmQWtU4xtRVTXwQKFpvA-TKRQhg0,3034 +OpenGL/GL/ARB/viewport_array.py,sha256=3HLIsxFIqTZOBmdOd8jjy9jsZ05QW5PjhsCvNWpFWiA,3238 +OpenGL/GL/ARB/window_pos.py,sha256=eSo3Uew-dFfPfGgmLN4TTuhqNLcPvr_KlrBIf4BjtgA,2349 +OpenGL/GL/ARM/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/GL/ARM/__pycache__/__init__.cpython-312.pyc,, +OpenGL/GL/ATI/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/GL/ATI/__pycache__/__init__.cpython-312.pyc,, +OpenGL/GL/ATI/__pycache__/draw_buffers.cpython-312.pyc,, +OpenGL/GL/ATI/__pycache__/element_array.cpython-312.pyc,, +OpenGL/GL/ATI/__pycache__/envmap_bumpmap.cpython-312.pyc,, +OpenGL/GL/ATI/__pycache__/fragment_shader.cpython-312.pyc,, +OpenGL/GL/ATI/__pycache__/map_object_buffer.cpython-312.pyc,, +OpenGL/GL/ATI/__pycache__/meminfo.cpython-312.pyc,, +OpenGL/GL/ATI/__pycache__/pixel_format_float.cpython-312.pyc,, +OpenGL/GL/ATI/__pycache__/pn_triangles.cpython-312.pyc,, +OpenGL/GL/ATI/__pycache__/separate_stencil.cpython-312.pyc,, +OpenGL/GL/ATI/__pycache__/text_fragment_shader.cpython-312.pyc,, +OpenGL/GL/ATI/__pycache__/texture_env_combine3.cpython-312.pyc,, +OpenGL/GL/ATI/__pycache__/texture_float.cpython-312.pyc,, +OpenGL/GL/ATI/__pycache__/texture_mirror_once.cpython-312.pyc,, +OpenGL/GL/ATI/__pycache__/vertex_array_object.cpython-312.pyc,, +OpenGL/GL/ATI/__pycache__/vertex_attrib_array_object.cpython-312.pyc,, +OpenGL/GL/ATI/__pycache__/vertex_streams.cpython-312.pyc,, +OpenGL/GL/ATI/draw_buffers.py,sha256=Xy1IVWfCAghO25MQawduJ5w5PbgCDrpnTcVBz2MO6zY,1557 +OpenGL/GL/ATI/element_array.py,sha256=rqZNsmOkDKtC7IFMXVCgOBIskvPLwq-6i5U3C27Yh2w,1645 +OpenGL/GL/ATI/envmap_bumpmap.py,sha256=Q7sM93rVxHj5Aa4Jfm35sVPyo6jMThdeIGbBjxb62Qk,2350 +OpenGL/GL/ATI/fragment_shader.py,sha256=6D3OAkX1P08tF65ctd-Unqk--nP907Rcik6NKvOl6zc,1871 +OpenGL/GL/ATI/map_object_buffer.py,sha256=zyG0-Ch4_D12yfiY0G9V6NyxUb4VYpFgF7OLRru99zo,1028 +OpenGL/GL/ATI/meminfo.py,sha256=rtPuZvY46a8-SqUAJ78MgmXavxHHBRvr2JLT-Visddk,1208 +OpenGL/GL/ATI/pixel_format_float.py,sha256=F6WDME8UrUmagbUFvHueHnZdfbYSNr8LWnd6LKrbJDk,779 +OpenGL/GL/ATI/pn_triangles.py,sha256=UFe-uGgj2wB_-9ksnNpGNqnOKZdXcrzSqVukhf2_Osg,1469 +OpenGL/GL/ATI/separate_stencil.py,sha256=H1Hu5zZjISE-6yic0IChg6pnPIyU0UnkfivOCRWGSQU,952 +OpenGL/GL/ATI/text_fragment_shader.py,sha256=P_Oc6fUtEh0HUBPtrN8HfJ7F0GPjGGRktn7KG71-GOk,3880 +OpenGL/GL/ATI/texture_env_combine3.py,sha256=Eo8oxfwy4XT921w4vaj0kcV7oPuy53SMqWs-lkZROqQ,1618 +OpenGL/GL/ATI/texture_float.py,sha256=UnKUIAtTa7r4_228s3t8wLMrrETZVFE1wA9IOiowCZY,1144 +OpenGL/GL/ATI/texture_mirror_once.py,sha256=FH7yydCM8mE1jZnmHkuCPzJn7hmEh51CmxV2yG2_9xA,1359 +OpenGL/GL/ATI/vertex_array_object.py,sha256=24HLpv1Y0uOxQe1RQ_qdboEydam6S2iZX9XtOEbWMQw,2100 +OpenGL/GL/ATI/vertex_attrib_array_object.py,sha256=RBNFLs03bb5XTKweV_RyaXVkuSNuM28YVf_vWAaEZUU,1463 +OpenGL/GL/ATI/vertex_streams.py,sha256=mHIgo27xLdeErin9FqEJAGSQZS6V6yFffqd0maa4kQk,3144 +OpenGL/GL/DFX/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/GL/DFX/__pycache__/__init__.cpython-312.pyc,, +OpenGL/GL/DFX/__pycache__/multisample.cpython-312.pyc,, +OpenGL/GL/DFX/__pycache__/tbuffer.cpython-312.pyc,, +OpenGL/GL/DFX/__pycache__/texture_compression_FXT1.cpython-312.pyc,, +OpenGL/GL/DFX/multisample.py,sha256=Vf0n-gZXCbsCr_ZpimvpR8CU8mby_fIUaM0rhFCHtkw,2902 +OpenGL/GL/DFX/tbuffer.py,sha256=IbgeGdIW7dgglreUa-E6Tk5E7KWp7Rzv0mjX76iEAKU,939 +OpenGL/GL/DFX/texture_compression_FXT1.py,sha256=7cN24URntHldKbieob3wDOSpuAvucwIe6cmSgrc2ajk,1667 +OpenGL/GL/DMP/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/GL/DMP/__pycache__/__init__.cpython-312.pyc,, +OpenGL/GL/EXT/EGL_image_storage.py,sha256=uxt5A7gWgOUy92_GrcgJBAKn2gbx3oHy4Gcsi-I13Mo,1909 +OpenGL/GL/EXT/EGL_sync.py,sha256=dTxtNzc-6Eka5uUh1b5D3zM0mSyxbhCtO--NmnfUIBk,1057 +OpenGL/GL/EXT/GL_422_pixels.py,sha256=tBWgCeCeXviZ5sweWTjX1Z4bp6rSchN0sX-TqyejJHw,1545 +OpenGL/GL/EXT/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/GL/EXT/__pycache__/EGL_image_storage.cpython-312.pyc,, +OpenGL/GL/EXT/__pycache__/EGL_sync.cpython-312.pyc,, +OpenGL/GL/EXT/__pycache__/GL_422_pixels.cpython-312.pyc,, +OpenGL/GL/EXT/__pycache__/__init__.cpython-312.pyc,, +OpenGL/GL/EXT/__pycache__/abgr.cpython-312.pyc,, +OpenGL/GL/EXT/__pycache__/bgra.cpython-312.pyc,, +OpenGL/GL/EXT/__pycache__/bindable_uniform.cpython-312.pyc,, +OpenGL/GL/EXT/__pycache__/blend_color.cpython-312.pyc,, +OpenGL/GL/EXT/__pycache__/blend_equation_separate.cpython-312.pyc,, +OpenGL/GL/EXT/__pycache__/blend_func_separate.cpython-312.pyc,, +OpenGL/GL/EXT/__pycache__/blend_logic_op.cpython-312.pyc,, +OpenGL/GL/EXT/__pycache__/blend_minmax.cpython-312.pyc,, +OpenGL/GL/EXT/__pycache__/blend_subtract.cpython-312.pyc,, +OpenGL/GL/EXT/__pycache__/clip_volume_hint.cpython-312.pyc,, +OpenGL/GL/EXT/__pycache__/cmyka.cpython-312.pyc,, +OpenGL/GL/EXT/__pycache__/color_subtable.cpython-312.pyc,, +OpenGL/GL/EXT/__pycache__/compiled_vertex_array.cpython-312.pyc,, +OpenGL/GL/EXT/__pycache__/convolution.cpython-312.pyc,, +OpenGL/GL/EXT/__pycache__/coordinate_frame.cpython-312.pyc,, +OpenGL/GL/EXT/__pycache__/copy_texture.cpython-312.pyc,, +OpenGL/GL/EXT/__pycache__/cull_vertex.cpython-312.pyc,, +OpenGL/GL/EXT/__pycache__/debug_label.cpython-312.pyc,, +OpenGL/GL/EXT/__pycache__/debug_marker.cpython-312.pyc,, +OpenGL/GL/EXT/__pycache__/depth_bounds_test.cpython-312.pyc,, +OpenGL/GL/EXT/__pycache__/direct_state_access.cpython-312.pyc,, +OpenGL/GL/EXT/__pycache__/draw_buffers2.cpython-312.pyc,, +OpenGL/GL/EXT/__pycache__/draw_instanced.cpython-312.pyc,, +OpenGL/GL/EXT/__pycache__/draw_range_elements.cpython-312.pyc,, +OpenGL/GL/EXT/__pycache__/external_buffer.cpython-312.pyc,, +OpenGL/GL/EXT/__pycache__/fog_coord.cpython-312.pyc,, +OpenGL/GL/EXT/__pycache__/framebuffer_blit.cpython-312.pyc,, +OpenGL/GL/EXT/__pycache__/framebuffer_multisample.cpython-312.pyc,, +OpenGL/GL/EXT/__pycache__/framebuffer_multisample_blit_scaled.cpython-312.pyc,, +OpenGL/GL/EXT/__pycache__/framebuffer_object.cpython-312.pyc,, +OpenGL/GL/EXT/__pycache__/framebuffer_sRGB.cpython-312.pyc,, +OpenGL/GL/EXT/__pycache__/geometry_shader4.cpython-312.pyc,, +OpenGL/GL/EXT/__pycache__/gpu_program_parameters.cpython-312.pyc,, +OpenGL/GL/EXT/__pycache__/gpu_shader4.cpython-312.pyc,, +OpenGL/GL/EXT/__pycache__/histogram.cpython-312.pyc,, +OpenGL/GL/EXT/__pycache__/index_array_formats.cpython-312.pyc,, +OpenGL/GL/EXT/__pycache__/index_func.cpython-312.pyc,, +OpenGL/GL/EXT/__pycache__/index_material.cpython-312.pyc,, +OpenGL/GL/EXT/__pycache__/index_texture.cpython-312.pyc,, +OpenGL/GL/EXT/__pycache__/light_texture.cpython-312.pyc,, +OpenGL/GL/EXT/__pycache__/memory_object.cpython-312.pyc,, +OpenGL/GL/EXT/__pycache__/memory_object_fd.cpython-312.pyc,, +OpenGL/GL/EXT/__pycache__/memory_object_win32.cpython-312.pyc,, +OpenGL/GL/EXT/__pycache__/misc_attribute.cpython-312.pyc,, +OpenGL/GL/EXT/__pycache__/multi_draw_arrays.cpython-312.pyc,, +OpenGL/GL/EXT/__pycache__/multisample.cpython-312.pyc,, +OpenGL/GL/EXT/__pycache__/multiview_tessellation_geometry_shader.cpython-312.pyc,, +OpenGL/GL/EXT/__pycache__/multiview_texture_multisample.cpython-312.pyc,, +OpenGL/GL/EXT/__pycache__/multiview_timer_query.cpython-312.pyc,, +OpenGL/GL/EXT/__pycache__/packed_depth_stencil.cpython-312.pyc,, +OpenGL/GL/EXT/__pycache__/packed_float.cpython-312.pyc,, +OpenGL/GL/EXT/__pycache__/packed_pixels.cpython-312.pyc,, +OpenGL/GL/EXT/__pycache__/paletted_texture.cpython-312.pyc,, +OpenGL/GL/EXT/__pycache__/pixel_buffer_object.cpython-312.pyc,, +OpenGL/GL/EXT/__pycache__/pixel_transform.cpython-312.pyc,, +OpenGL/GL/EXT/__pycache__/pixel_transform_color_table.cpython-312.pyc,, +OpenGL/GL/EXT/__pycache__/point_parameters.cpython-312.pyc,, +OpenGL/GL/EXT/__pycache__/polygon_offset.cpython-312.pyc,, +OpenGL/GL/EXT/__pycache__/polygon_offset_clamp.cpython-312.pyc,, +OpenGL/GL/EXT/__pycache__/post_depth_coverage.cpython-312.pyc,, +OpenGL/GL/EXT/__pycache__/provoking_vertex.cpython-312.pyc,, +OpenGL/GL/EXT/__pycache__/raster_multisample.cpython-312.pyc,, +OpenGL/GL/EXT/__pycache__/rescale_normal.cpython-312.pyc,, +OpenGL/GL/EXT/__pycache__/secondary_color.cpython-312.pyc,, +OpenGL/GL/EXT/__pycache__/semaphore.cpython-312.pyc,, +OpenGL/GL/EXT/__pycache__/semaphore_fd.cpython-312.pyc,, +OpenGL/GL/EXT/__pycache__/semaphore_win32.cpython-312.pyc,, +OpenGL/GL/EXT/__pycache__/separate_shader_objects.cpython-312.pyc,, +OpenGL/GL/EXT/__pycache__/separate_specular_color.cpython-312.pyc,, +OpenGL/GL/EXT/__pycache__/shader_framebuffer_fetch.cpython-312.pyc,, +OpenGL/GL/EXT/__pycache__/shader_framebuffer_fetch_non_coherent.cpython-312.pyc,, +OpenGL/GL/EXT/__pycache__/shader_image_load_formatted.cpython-312.pyc,, +OpenGL/GL/EXT/__pycache__/shader_image_load_store.cpython-312.pyc,, +OpenGL/GL/EXT/__pycache__/shader_integer_mix.cpython-312.pyc,, +OpenGL/GL/EXT/__pycache__/shadow_funcs.cpython-312.pyc,, +OpenGL/GL/EXT/__pycache__/shared_texture_palette.cpython-312.pyc,, +OpenGL/GL/EXT/__pycache__/sparse_texture2.cpython-312.pyc,, +OpenGL/GL/EXT/__pycache__/stencil_clear_tag.cpython-312.pyc,, +OpenGL/GL/EXT/__pycache__/stencil_two_side.cpython-312.pyc,, +OpenGL/GL/EXT/__pycache__/stencil_wrap.cpython-312.pyc,, +OpenGL/GL/EXT/__pycache__/subtexture.cpython-312.pyc,, +OpenGL/GL/EXT/__pycache__/texture.cpython-312.pyc,, +OpenGL/GL/EXT/__pycache__/texture3D.cpython-312.pyc,, +OpenGL/GL/EXT/__pycache__/texture_array.cpython-312.pyc,, +OpenGL/GL/EXT/__pycache__/texture_buffer_object.cpython-312.pyc,, +OpenGL/GL/EXT/__pycache__/texture_compression_latc.cpython-312.pyc,, +OpenGL/GL/EXT/__pycache__/texture_compression_rgtc.cpython-312.pyc,, +OpenGL/GL/EXT/__pycache__/texture_compression_s3tc.cpython-312.pyc,, +OpenGL/GL/EXT/__pycache__/texture_cube_map.cpython-312.pyc,, +OpenGL/GL/EXT/__pycache__/texture_env_add.cpython-312.pyc,, +OpenGL/GL/EXT/__pycache__/texture_env_combine.cpython-312.pyc,, +OpenGL/GL/EXT/__pycache__/texture_env_dot3.cpython-312.pyc,, +OpenGL/GL/EXT/__pycache__/texture_filter_anisotropic.cpython-312.pyc,, +OpenGL/GL/EXT/__pycache__/texture_filter_minmax.cpython-312.pyc,, +OpenGL/GL/EXT/__pycache__/texture_integer.cpython-312.pyc,, +OpenGL/GL/EXT/__pycache__/texture_lod_bias.cpython-312.pyc,, +OpenGL/GL/EXT/__pycache__/texture_mirror_clamp.cpython-312.pyc,, +OpenGL/GL/EXT/__pycache__/texture_object.cpython-312.pyc,, +OpenGL/GL/EXT/__pycache__/texture_perturb_normal.cpython-312.pyc,, +OpenGL/GL/EXT/__pycache__/texture_sRGB.cpython-312.pyc,, +OpenGL/GL/EXT/__pycache__/texture_sRGB_R8.cpython-312.pyc,, +OpenGL/GL/EXT/__pycache__/texture_sRGB_decode.cpython-312.pyc,, +OpenGL/GL/EXT/__pycache__/texture_shadow_lod.cpython-312.pyc,, +OpenGL/GL/EXT/__pycache__/texture_shared_exponent.cpython-312.pyc,, +OpenGL/GL/EXT/__pycache__/texture_snorm.cpython-312.pyc,, +OpenGL/GL/EXT/__pycache__/texture_swizzle.cpython-312.pyc,, +OpenGL/GL/EXT/__pycache__/timer_query.cpython-312.pyc,, +OpenGL/GL/EXT/__pycache__/transform_feedback.cpython-312.pyc,, +OpenGL/GL/EXT/__pycache__/vertex_array.cpython-312.pyc,, +OpenGL/GL/EXT/__pycache__/vertex_array_bgra.cpython-312.pyc,, +OpenGL/GL/EXT/__pycache__/vertex_attrib_64bit.cpython-312.pyc,, +OpenGL/GL/EXT/__pycache__/vertex_shader.cpython-312.pyc,, +OpenGL/GL/EXT/__pycache__/vertex_weighting.cpython-312.pyc,, +OpenGL/GL/EXT/__pycache__/win32_keyed_mutex.cpython-312.pyc,, +OpenGL/GL/EXT/__pycache__/window_rectangles.cpython-312.pyc,, +OpenGL/GL/EXT/__pycache__/x11_sync_object.cpython-312.pyc,, +OpenGL/GL/EXT/abgr.py,sha256=TPnuAqCYmlCJotG1bpVk3-DoIvEpTePWZcd-OpSLhBs,1017 +OpenGL/GL/EXT/bgra.py,sha256=nUsuF7nsxhFslEH__hVkwkzWH0vAl4yP9AHmN95IIU4,962 +OpenGL/GL/EXT/bindable_uniform.py,sha256=YArtwlVKGAjIn6QusAmpDK1rXEn_hY8zMte7Ti9Z8_A,1787 +OpenGL/GL/EXT/blend_color.py,sha256=S14fSTsfTg3aPDkPndTJX656Xn7EACRg98Vi6hLLYAs,1042 +OpenGL/GL/EXT/blend_equation_separate.py,sha256=qKx60O0Kg1Lucn7RlNT3Uhsh0jsnxMuJFj5IuM4JIkU,1474 +OpenGL/GL/EXT/blend_func_separate.py,sha256=Sk9yDQ8Y-YbJztQDxz18Nbj5LHoCjnnsDiKuUSvdriA,1095 +OpenGL/GL/EXT/blend_logic_op.py,sha256=qkCX9MSMZO0aoR69kR3owu_-7BHWF36tlhQnXZ3ZJ-w,1150 +OpenGL/GL/EXT/blend_minmax.py,sha256=pG_VQaryNCwXe0xfx9MYWaNHNROwx7mPyogviZmPy8s,1265 +OpenGL/GL/EXT/blend_subtract.py,sha256=ZR67MqKusRx2FcTE3pgMwzTrR05oWXgKzqBFTyury8o,1100 +OpenGL/GL/EXT/clip_volume_hint.py,sha256=hPFK6A-0KLe0BdVx1tDR57UBMQDU9pG1fdkm6W-WIgQ,1136 +OpenGL/GL/EXT/cmyka.py,sha256=QPMrCbgiuQDKKJIJCrgJ7ibWchPMQ4i4rAO7-VTLmNM,1681 +OpenGL/GL/EXT/color_subtable.py,sha256=-j2eg3cB0JHoMe8ZCGlbp-e4826rsvT5a1iDrYORIaQ,1163 +OpenGL/GL/EXT/compiled_vertex_array.py,sha256=zMsBeG4OHKny80mw3SpBUfMg2TDGB5JfhmKThkWF4fg,1742 +OpenGL/GL/EXT/convolution.py,sha256=jah6w-k3jnqf8XX75lmnxdbiC4EwG1QQSLB5TG3c4p8,2964 +OpenGL/GL/EXT/coordinate_frame.py,sha256=I8uO9kMhCUYQhG-FYaYVJw1uAdmEXi05QmJuwRK5__Q,2222 +OpenGL/GL/EXT/copy_texture.py,sha256=qiAJo9dIQL2-HTUeCvobBYuYcdmkaLziG5VRXnqR_BE,1090 +OpenGL/GL/EXT/cull_vertex.py,sha256=uVaDGfVd71QIyOePYQM1fiPLLNOFe-eaYhe3W2Q8aSw,1664 +OpenGL/GL/EXT/debug_label.py,sha256=IcHGDJOkAJvk3SweRgMpcPzgglYZyVM0gfR7-P6arO4,1579 +OpenGL/GL/EXT/debug_marker.py,sha256=o5sPaLKaDMQrnBR7BKUMyfMUzqToHeypWthaaIlbx8o,1404 +OpenGL/GL/EXT/depth_bounds_test.py,sha256=Ns98V6HQr24G1JKF9h23wwiPNScV3artKm3hv9ljJ4o,3121 +OpenGL/GL/EXT/direct_state_access.py,sha256=gC_Xhm1a5vngGOEx6nS1bl0zmtg_JRKhwKuPDDT6H1g,33171 +OpenGL/GL/EXT/draw_buffers2.py,sha256=Gs0fM___hQfrRdzsCkUzGEm2t1Oziq3rvpivDfUXH-4,1556 +OpenGL/GL/EXT/draw_instanced.py,sha256=ngwSCvOuNcsKidBVjHMlwb1b-KhVGqH7J2xqIWHyJhM,1216 +OpenGL/GL/EXT/draw_range_elements.py,sha256=ArmrUO60Iio--qjYkvHWK19hPrJV0fvFiL_-_BC5-wQ,1172 +OpenGL/GL/EXT/external_buffer.py,sha256=88iMQT9NAfWwS4QIyzLpdoMCK1WdgX688sylwA9roAc,2971 +OpenGL/GL/EXT/fog_coord.py,sha256=5lZaJEFnewktpO6HwaJ1hv0tqTWzZI3fVmTO8dgGv8E,1260 +OpenGL/GL/EXT/framebuffer_blit.py,sha256=W6xwLs9w3uvZYeexlARGxAgJMLSxC_xERZgl0DUIHeQ,1134 +OpenGL/GL/EXT/framebuffer_multisample.py,sha256=b5Ki82MBeVGiJpzqFSzWjEzpPTamjLSN2CiJwYhVrKc,4606 +OpenGL/GL/EXT/framebuffer_multisample_blit_scaled.py,sha256=Ad-0I8CXJXkQnpQdtKm_iY8kZrdOmmL00nhTT-LtqnA,2638 +OpenGL/GL/EXT/framebuffer_object.py,sha256=igCz17ZxdGzYyXlr9mhVxvZgmD9YQJw6ikdz_8KmohQ,6750 +OpenGL/GL/EXT/framebuffer_sRGB.py,sha256=qo5dbLvpYOjd7RIhdLRSCeuIdzC7pEZnKPqZtc4bYH4,2408 +OpenGL/GL/EXT/geometry_shader4.py,sha256=SmAZFEuHPi9CAtz5XM6O2w2j-T2ejK-epgTW-KF2flk,2458 +OpenGL/GL/EXT/gpu_program_parameters.py,sha256=YA5hrFWsHhPiEA_yzKpCbV8ZElIrF-i1MAk4CfV2XtA,1883 +OpenGL/GL/EXT/gpu_shader4.py,sha256=Dz6vFJ7jhZz7QdLsd0V-P0Y19sONgGjCPm6-blqj86s,6525 +OpenGL/GL/EXT/histogram.py,sha256=ha1PWzWAR94uEpLgT8D9uRRdDWkBXQaCOXXGil3LcgI,2150 +OpenGL/GL/EXT/index_array_formats.py,sha256=zHJ6vHrBa9cEQSoPmHNMARdk1kudTiR0P8_LeD9bB3I,967 +OpenGL/GL/EXT/index_func.py,sha256=4HIz6NK0jz4GZBDYRiKCBWkrsmgTmAgzMRNUEcVHG9c,975 +OpenGL/GL/EXT/index_material.py,sha256=H5f9vGS19PfxO6fcVQDrUGJn6rXM25UvLTp2u93kq-c,1267 +OpenGL/GL/EXT/index_texture.py,sha256=axeWRMV5Roa7tB847QNarZ5Ry2fdP9BZGFGD8k4xS5g,1158 +OpenGL/GL/EXT/light_texture.py,sha256=DzXu0sZmBZk8s94pNxK8J5cbz4PTVnyGK3LqaakOhIs,1662 +OpenGL/GL/EXT/memory_object.py,sha256=tNmQiWlJyS1XBhkUs5RX_fFns1EM3ADLlVoK9PCa5v4,1278 +OpenGL/GL/EXT/memory_object_fd.py,sha256=sJQnSk5JFqOvhp0XvrfFsvqvXsNHYm1HCe96ODp7ZBo,767 +OpenGL/GL/EXT/memory_object_win32.py,sha256=8DVy6Ak7j-MBCK4-zZmk_4ZCa7qdX1BuGL8Or90ChjE,785 +OpenGL/GL/EXT/misc_attribute.py,sha256=CptF6XJQPI07nXkJ3v6JlT1kiw0wVJGSiq86kfvtpOk,1010 +OpenGL/GL/EXT/multi_draw_arrays.py,sha256=smejL4W2s0OiviLg8tzMB6UL6-cyHwYHxyHA53M1WmY,1673 +OpenGL/GL/EXT/multisample.py,sha256=IqUzDMF5ZAFgIGoObBdvnaXDh-ub9iX8Ykj6ji9Kh9o,739 +OpenGL/GL/EXT/multiview_tessellation_geometry_shader.py,sha256=ZcrUE5y-omkbamV0DKfn334RILnligxC5iNb3Poiy6w,2177 +OpenGL/GL/EXT/multiview_texture_multisample.py,sha256=ri4n0lu-jb8PB1Zy-k5uilvgOv9tD3fVA0m5b2A8vsw,2229 +OpenGL/GL/EXT/multiview_timer_query.py,sha256=Udbo2v1JGQe80dEbzRsruIM3ydacuRf9eCxi_CX3Pwo,1179 +OpenGL/GL/EXT/packed_depth_stencil.py,sha256=1ff5CFqGDwvH-61suCBYymj5zKNroOz2BXiPCZehMKo,5590 +OpenGL/GL/EXT/packed_float.py,sha256=0BG1sTt81YC378cxW0FHzP7WPvKx3DLLe2quymOzhE0,1773 +OpenGL/GL/EXT/packed_pixels.py,sha256=-PIbYhecv1nkgJmma3IMaDqQdRZBsxXmeKTiayCS_9c,1294 +OpenGL/GL/EXT/paletted_texture.py,sha256=jLtMM5FYB7QXgmFQHRJ_7EW5AQvdp7iMA0itZFvY3W8,3576 +OpenGL/GL/EXT/pixel_buffer_object.py,sha256=eQChdJ_Uu7Towp1jKxI6r8blLfjrG3Y_XRuAe4U5y8o,3418 +OpenGL/GL/EXT/pixel_transform.py,sha256=uJupHL9Uzb5mh2TMMWAGF8fJTWaYsAvSRJty4rpCXU0,1757 +OpenGL/GL/EXT/pixel_transform_color_table.py,sha256=U2GdhLUX1zdBPzuXrJkrLOMhV51ev8jw-NPsyeerVqg,969 +OpenGL/GL/EXT/point_parameters.py,sha256=uO5-g0RkvK8-RzN74gmzOiydETNEcOGqbhdTHV8nd8c,3188 +OpenGL/GL/EXT/polygon_offset.py,sha256=WKiktgOehrCEmNRht_s6b_8MdNYdMPNR9VzpQzxzEGw,1507 +OpenGL/GL/EXT/polygon_offset_clamp.py,sha256=1mXTRkKg5U0mhOIMwTabHtl1i4lU5_VHRa_gmFig5yA,1390 +OpenGL/GL/EXT/post_depth_coverage.py,sha256=BH5zCXfno64HAnPwiBJJzy9oPnfGKFuHZ3N0N-1gYHg,1246 +OpenGL/GL/EXT/provoking_vertex.py,sha256=-dyEBeFHTWjCU-WAAq2IaZh2xVSATbtMEmTNJxDjD3g,2070 +OpenGL/GL/EXT/raster_multisample.py,sha256=BpzNbRQ_jUuZwBQ6sq1fRNExcYw3lEqlLyxV22FIxXo,1728 +OpenGL/GL/EXT/rescale_normal.py,sha256=KXBIw_7d7NN2QewCU7BgRfLI1J2M2BOlCjOPHwmYTrs,1217 +OpenGL/GL/EXT/secondary_color.py,sha256=7V_lA-S6xm49dtIVr_X63GwcWg154JOErlJgIJXfQjY,1968 +OpenGL/GL/EXT/semaphore.py,sha256=xKBCiC26JvUKxbMOCt_aw_4FVsoIaMmBMGXNzMvCyvU,2270 +OpenGL/GL/EXT/semaphore_fd.py,sha256=SAMgh2MorJNW4VgfX7EsPfJ-yRAydQ8irxC311jmShY,744 +OpenGL/GL/EXT/semaphore_win32.py,sha256=iGvRofadpWDUK0cquz1ZXr_h3gS03yMYtT6jLAoxXCQ,762 +OpenGL/GL/EXT/separate_shader_objects.py,sha256=El5FpKG8KfvB8ZH9ag9Y5OUsYdYvAgVq6NAaUt64gLY,5607 +OpenGL/GL/EXT/separate_specular_color.py,sha256=L6UEmm6dUxLuc0-Greb5AnKFdGOhRzLh10hZdY9KOT4,2420 +OpenGL/GL/EXT/shader_framebuffer_fetch.py,sha256=z_YvZ2VuxjBy2bKNAjCMkGYnmgUpLQDNjTFeoZq8KKw,2768 +OpenGL/GL/EXT/shader_framebuffer_fetch_non_coherent.py,sha256=Dnygf3FOG4w6BRiGbqF7MoBX13F91IWgoz-POath9TE,891 +OpenGL/GL/EXT/shader_image_load_formatted.py,sha256=cqArhcDTt0RNhii9oxhm2fdLcvAVkDoViu9kol3VqXw,1232 +OpenGL/GL/EXT/shader_image_load_store.py,sha256=uT2Vabr14ufkB6HGUR6BSUDhgVB35oFAICD2R9htIxs,3764 +OpenGL/GL/EXT/shader_integer_mix.py,sha256=MvRE5IcLEr3ZuyLvrsM5vO6HvJBjFheL11JfRVGqUzs,1034 +OpenGL/GL/EXT/shadow_funcs.py,sha256=lJZEhONrPNU8JfqXwhQ_3QQp3J4KybBePF84RvzCldE,929 +OpenGL/GL/EXT/shared_texture_palette.py,sha256=6rgtAb0zOGIMrvJ8PzVnI4HB1BYzsaq1kby5onffdrg,1264 +OpenGL/GL/EXT/sparse_texture2.py,sha256=MraarQQ0S3tY-1l8mFActEvGUSgniR-8t_kscSh_qSk,2190 +OpenGL/GL/EXT/stencil_clear_tag.py,sha256=1X-zVvGP4tGgWPxLK4R9dFTF9jWHNQr8x_Liypxq9iE,4069 +OpenGL/GL/EXT/stencil_two_side.py,sha256=LNsJsTM4vZANJ-fBL6QXgbU3SMltk9BVU6wvmVbQZEE,1147 +OpenGL/GL/EXT/stencil_wrap.py,sha256=Vc1gkQIjukhljhABGi5EmkED4WUOhu9DY73FuR2GQcg,1667 +OpenGL/GL/EXT/subtexture.py,sha256=2mQEX3oTlS4eP3W2uM0OTDvoOhHmU1NQ_R8qMEBEKXU,1605 +OpenGL/GL/EXT/texture.py,sha256=5hIqMyAhWXXBdG01jbDR1cREhsm5bfCVBTEYjNMbCXg,2131 +OpenGL/GL/EXT/texture3D.py,sha256=088upzl2GoIKwhVYcqWVkSDTYOlOLTRoOANkuGlAm70,1422 +OpenGL/GL/EXT/texture_array.py,sha256=TPEsbo03wjpZh-EupQc2B7_TBC0LYH2loTF3CJpMxgc,2612 +OpenGL/GL/EXT/texture_buffer_object.py,sha256=FwA9qdmXB1epAjT1R6f-RYth6u2QVbOluUjBw5qI1Jk,2838 +OpenGL/GL/EXT/texture_compression_latc.py,sha256=PVWji2m4jN-ml63zlNGLB3umMMErelWHNu1AS18xhe0,1461 +OpenGL/GL/EXT/texture_compression_rgtc.py,sha256=3iJYWsDNoZoWQWJPY8JW7sbb9Eh1UmfeBxgk9UQ7c8U,1750 +OpenGL/GL/EXT/texture_compression_s3tc.py,sha256=vrUNsO_NOXN3izSh9eHLrptJi5XjXuZGbMm1lhhPvI0,1302 +OpenGL/GL/EXT/texture_cube_map.py,sha256=wGNQYrreUupLSghBh42HzCrO4jRJbfL-OelSPRQh6oM,3511 +OpenGL/GL/EXT/texture_env_add.py,sha256=b9_ILA5cvibaQIOpKAiufD-jzgrzKNlOFFBGrvCvC_k,983 +OpenGL/GL/EXT/texture_env_combine.py,sha256=pQPy-FydGfwKa4z0f4A5O_fgZRGa02zYa0Xd_W2WwP8,1682 +OpenGL/GL/EXT/texture_env_dot3.py,sha256=MFs2WN7fyaGkmBIkQ7FyJRtBmyFBXv1-FELoCya1Eio,1444 +OpenGL/GL/EXT/texture_filter_anisotropic.py,sha256=Kvsu0QYk4ogNU-Ahq9Jap9Qsz57qTJOKSU2ljKEkW-U,2893 +OpenGL/GL/EXT/texture_filter_minmax.py,sha256=tuXxCBkAhKhaHMp_5B0dZ8sSwT3tuIa6YLybBt8FUXQ,1611 +OpenGL/GL/EXT/texture_integer.py,sha256=IJ2D0aVFGt0jE8Bb7Mg7KJMSgibcMC0oSFtuvketpnE,3866 +OpenGL/GL/EXT/texture_lod_bias.py,sha256=sCbzPQb_lxUp3R8ndMwfimloBNs-99cTUbEf71FdKlg,1587 +OpenGL/GL/EXT/texture_mirror_clamp.py,sha256=ILsMOgX6ceoXbgFlxLNkdomqpIZlGe5xz7NM3myLj4Q,1396 +OpenGL/GL/EXT/texture_object.py,sha256=j16kewE22qMDqxIXDZs_KZr8sHfuq7kv4_NqCEaRKKU,1902 +OpenGL/GL/EXT/texture_perturb_normal.py,sha256=HPpTTFRM9aWeGPjGMzQajFiLg2wdpcojL5q0074HUuU,1051 +OpenGL/GL/EXT/texture_sRGB.py,sha256=Z20qmcGpBNNzWFTUru1m330fvGG-GhnfAlwVHKD0ARE,1394 +OpenGL/GL/EXT/texture_sRGB_R8.py,sha256=8Gnp58aF4rWEqTB9wrte2wO3v0l4HHWP8pS80YvLS28,956 +OpenGL/GL/EXT/texture_sRGB_decode.py,sha256=nWi5nUXjqyjll1fouDCwGgENnn_0DU4KiYuimKnz9f8,1616 +OpenGL/GL/EXT/texture_shadow_lod.py,sha256=abGKdE1VYDs3slBcuPPYIR00L_esu7Gqa-aTH41vJ4A,1428 +OpenGL/GL/EXT/texture_shared_exponent.py,sha256=SAgFT3hwa_v4WXWYA2nHPVWtab_PTM4D3qGDiMDZ8PI,1874 +OpenGL/GL/EXT/texture_snorm.py,sha256=A_WwP2f7hPlHcls22cYjhvuU8RxJEtR_mP7xsaiA5BQ,1336 +OpenGL/GL/EXT/texture_swizzle.py,sha256=LRaFW2S4iTaWUv4qbFtreMqF6OuAZ1tCQFWlGd93KNI,1836 +OpenGL/GL/EXT/timer_query.py,sha256=K3yKlP3ss7PccmlRw2Zf4ldIgMZYcKYS2SimSOFSTyw,2381 +OpenGL/GL/EXT/transform_feedback.py,sha256=EQQpVWxK5SdtXBK93p6RRdlYl8k8_5KAxAEcrsrfTyI,3177 +OpenGL/GL/EXT/vertex_array.py,sha256=CIA04TsZRUN5JqXpD0xDyMSp6xW570u_YJ78RZ_n6VA,2683 +OpenGL/GL/EXT/vertex_array_bgra.py,sha256=M8guyLN-JAamQOdvn_GRL4ir1Si6vgu9wAfbd77Vy7Y,3470 +OpenGL/GL/EXT/vertex_attrib_64bit.py,sha256=DCfAGmRsYZOsQea8sRbeKiRFxZu4iGokeHoFh7ZX3WA,3961 +OpenGL/GL/EXT/vertex_shader.py,sha256=CA-LlEVhqWBGVaJJvJzFBgqOHUhTxk8NXZ697Hot_nc,4295 +OpenGL/GL/EXT/vertex_weighting.py,sha256=4_DyqHpsucxfcYWmtKnJBxXnvDOBJj6RGrJJoIJBbCM,2037 +OpenGL/GL/EXT/win32_keyed_mutex.py,sha256=ikSB4skXsyHsgoLTp4cw9DINWATTV5WUuJeHfhK-rFk,1110 +OpenGL/GL/EXT/window_rectangles.py,sha256=6-zjSH6MDh5FRUP5d7lbLEo8YRWUp1W82xWAnXvcYog,2065 +OpenGL/GL/EXT/x11_sync_object.py,sha256=7BH5m46eILyWEUI1SlWBytD33zFs3KagUgUO0PgPk-w,1703 +OpenGL/GL/FJ/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/GL/FJ/__pycache__/__init__.cpython-312.pyc,, +OpenGL/GL/GREMEDY/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/GL/GREMEDY/__pycache__/__init__.cpython-312.pyc,, +OpenGL/GL/GREMEDY/__pycache__/frame_terminator.cpython-312.pyc,, +OpenGL/GL/GREMEDY/__pycache__/string_marker.cpython-312.pyc,, +OpenGL/GL/GREMEDY/frame_terminator.py,sha256=rqk969AvJ5kLQw7xaAdP8BBgW-ABmJlhJNt03t1-oTA,1944 +OpenGL/GL/GREMEDY/string_marker.py,sha256=4OWAdM-m7ZzVNz0mxrJftNkNGmGWrnxDr8omyU_HqLI,2354 +OpenGL/GL/HP/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/GL/HP/__pycache__/__init__.cpython-312.pyc,, +OpenGL/GL/HP/__pycache__/convolution_border_modes.cpython-312.pyc,, +OpenGL/GL/HP/__pycache__/image_transform.cpython-312.pyc,, +OpenGL/GL/HP/__pycache__/occlusion_test.cpython-312.pyc,, +OpenGL/GL/HP/__pycache__/texture_lighting.cpython-312.pyc,, +OpenGL/GL/HP/convolution_border_modes.py,sha256=eYyAXfWAVU1qda8uifpHHLtrm8VYoZ2rrD3YfBK6HAU,927 +OpenGL/GL/HP/image_transform.py,sha256=XB-oXN24i_pL3pQGxqXSz2C_DPwS68KyygSiA8UrnaQ,2098 +OpenGL/GL/HP/occlusion_test.py,sha256=HbvAiHFn6-0leaI8NnSO0Z32AYLtv1DB2Xmdhb2K2u0,777 +OpenGL/GL/HP/texture_lighting.py,sha256=wrp43IRa63ds5pygZVxpIG_ZYu0ZNSlfaG4lRiZPQNE,962 +OpenGL/GL/IBM/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/GL/IBM/__pycache__/__init__.cpython-312.pyc,, +OpenGL/GL/IBM/__pycache__/cull_vertex.cpython-312.pyc,, +OpenGL/GL/IBM/__pycache__/multimode_draw_arrays.cpython-312.pyc,, +OpenGL/GL/IBM/__pycache__/rasterpos_clip.cpython-312.pyc,, +OpenGL/GL/IBM/__pycache__/static_data.cpython-312.pyc,, +OpenGL/GL/IBM/__pycache__/texture_mirrored_repeat.cpython-312.pyc,, +OpenGL/GL/IBM/__pycache__/vertex_array_lists.cpython-312.pyc,, +OpenGL/GL/IBM/cull_vertex.py,sha256=AxpE-fkbaugLEuFzJ_M4xJloTv9BaMPOJ4u0q0ydwJ8,1149 +OpenGL/GL/IBM/multimode_draw_arrays.py,sha256=F31YafTGf7clIojvy1VH9V4ZL6I-n2N_BfKN5j8nz0U,2133 +OpenGL/GL/IBM/rasterpos_clip.py,sha256=XYKU2CDgpqEghMz7_OvDbx_zyzzyfKMAc436g4pGnlo,1248 +OpenGL/GL/IBM/static_data.py,sha256=aZ_xUACIFO9voz8QHe-gfZeHQCsKZOnl9v78DW7ij4o,1422 +OpenGL/GL/IBM/texture_mirrored_repeat.py,sha256=CUgPbWLRmq7uO4rWgezGBG_aqEdc0C69Fyp1gcn9ldE,1258 +OpenGL/GL/IBM/vertex_array_lists.py,sha256=LNQo5-EGhBTauR1j3sCRUSQcjU0RYS2ANHZKUIaUeF4,4274 +OpenGL/GL/IMG/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/GL/IMG/__pycache__/__init__.cpython-312.pyc,, +OpenGL/GL/INGR/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/GL/INGR/__pycache__/__init__.cpython-312.pyc,, +OpenGL/GL/INGR/__pycache__/blend_func_separate.cpython-312.pyc,, +OpenGL/GL/INGR/__pycache__/color_clamp.cpython-312.pyc,, +OpenGL/GL/INGR/__pycache__/interlace_read.cpython-312.pyc,, +OpenGL/GL/INGR/blend_func_separate.py,sha256=LAvm4co_tNVX9_EB2UIh0xIqcqvol7U27KrorKyPv4g,791 +OpenGL/GL/INGR/color_clamp.py,sha256=KNm9I8JAbnhyT3vKNxMAtNr6YPn8On2GlOO_Tck-tPY,1081 +OpenGL/GL/INGR/interlace_read.py,sha256=BS-hQ8oE8RXNs_kR8aaQ6rfxJFMRsZuDL8H9dm0FRNQ,1009 +OpenGL/GL/INTEL/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/GL/INTEL/__pycache__/__init__.cpython-312.pyc,, +OpenGL/GL/INTEL/__pycache__/blackhole_render.cpython-312.pyc,, +OpenGL/GL/INTEL/__pycache__/conservative_rasterization.cpython-312.pyc,, +OpenGL/GL/INTEL/__pycache__/fragment_shader_ordering.cpython-312.pyc,, +OpenGL/GL/INTEL/__pycache__/framebuffer_CMAA.cpython-312.pyc,, +OpenGL/GL/INTEL/__pycache__/map_texture.cpython-312.pyc,, +OpenGL/GL/INTEL/__pycache__/parallel_arrays.cpython-312.pyc,, +OpenGL/GL/INTEL/__pycache__/performance_query.cpython-312.pyc,, +OpenGL/GL/INTEL/blackhole_render.py,sha256=FxTrgNicSU-8E3qXYtTElyi_oM_rrp2kT42bfC0_Uqo,1175 +OpenGL/GL/INTEL/conservative_rasterization.py,sha256=iy4OA1rkg1zxKzzIqVlTWFIsu_P5ofDF8Mc_P2L14fc,1682 +OpenGL/GL/INTEL/fragment_shader_ordering.py,sha256=cZZbm4wXkNQJThIp9r_9h57AbQEE5vHQC7Gm-rYGZkM,2025 +OpenGL/GL/INTEL/framebuffer_CMAA.py,sha256=wm4PDBP4bs_rp4-k-dhE_XCGhTHOiZovtjitA-bjUDA,1549 +OpenGL/GL/INTEL/map_texture.py,sha256=2HrDOz4JyO6rQAANbQ3Y5XvRPWu0G6Lza1k0zEX6buY,1716 +OpenGL/GL/INTEL/parallel_arrays.py,sha256=R1tUpSh8_shJlOjK68BhldBoZw9wavkkdVPAyFpAeUM,1273 +OpenGL/GL/INTEL/performance_query.py,sha256=_Vb_tjaR1HlqM7edh9PM0tRVnwd5yfDWRbhAD1m2GnM,2807 +OpenGL/GL/KHR/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +OpenGL/GL/KHR/__pycache__/__init__.cpython-312.pyc,, +OpenGL/GL/KHR/__pycache__/blend_equation_advanced.cpython-312.pyc,, +OpenGL/GL/KHR/__pycache__/blend_equation_advanced_coherent.cpython-312.pyc,, +OpenGL/GL/KHR/__pycache__/context_flush_control.cpython-312.pyc,, +OpenGL/GL/KHR/__pycache__/debug.cpython-312.pyc,, +OpenGL/GL/KHR/__pycache__/no_error.cpython-312.pyc,, +OpenGL/GL/KHR/__pycache__/parallel_shader_compile.cpython-312.pyc,, +OpenGL/GL/KHR/__pycache__/robust_buffer_access_behavior.cpython-312.pyc,, +OpenGL/GL/KHR/__pycache__/robustness.cpython-312.pyc,, +OpenGL/GL/KHR/__pycache__/shader_subgroup.cpython-312.pyc,, +OpenGL/GL/KHR/__pycache__/texture_compression_astc_hdr.cpython-312.pyc,, +OpenGL/GL/KHR/__pycache__/texture_compression_astc_ldr.cpython-312.pyc,, +OpenGL/GL/KHR/__pycache__/texture_compression_astc_sliced_3d.cpython-312.pyc,, +OpenGL/GL/KHR/blend_equation_advanced.py,sha256=qQ3IbgmJJQaMl4vxwfmHyhxuT-V6CFAFyanD_26chy8,4428 +OpenGL/GL/KHR/blend_equation_advanced_coherent.py,sha256=m-eod_bFrq8p5kcjbdQYR7YsL803HzDgpV0rzxfZY48,862 +OpenGL/GL/KHR/context_flush_control.py,sha256=iRQaoMi6P5_STBoa0HZGN_id2bGFxiikGDGV32mCExk,2314 +OpenGL/GL/KHR/debug.py,sha256=NmfzxG5YKPFuYaMnwJamwtIyD3rSv9ws5PuH8OIevQA,9485 +OpenGL/GL/KHR/no_error.py,sha256=cyg_JEgcpaixhCDTAlfYtpKOlj045FYwB0dl3E7_T9o,1327 +OpenGL/GL/KHR/parallel_shader_compile.py,sha256=S0xwHBXEMWe1UEhemHiropJc848s4eAgzKCNksXs8Ms,1227 +OpenGL/GL/KHR/robust_buffer_access_behavior.py,sha256=iYXCkruIItzB4uAXAAiEtz2EOxyU82PV5iQ3EQhBlJQ,1475 +OpenGL/GL/KHR/robustness.py,sha256=Ep_NvVPdP-WmA1WAnD_zHbNwGd2PTKWU9VHuDKLGLvU,4848 +OpenGL/GL/KHR/shader_subgroup.py,sha256=wvBUAhiW1PORljQVCwhnBE0ce24liI4jTalBI_MUsNw,1711 +OpenGL/GL/KHR/texture_compression_astc_hdr.py,sha256=A5RMJiGKjPhrBumCKKUixIDSNewRuIKAqbU2IxjDV8E,1688 +OpenGL/GL/KHR/texture_compression_astc_ldr.py,sha256=ZZTFYkjMOwwaHAk9R-nv-rOcJiTu_8-AGnw5eODBrJk,838 +OpenGL/GL/KHR/texture_compression_astc_sliced_3d.py,sha256=XtpErf7CAk2Yxobd0iJP3N1VyZ8TeYOMSCngnHMG2cE,1511 +OpenGL/GL/MESA/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/GL/MESA/__pycache__/__init__.cpython-312.pyc,, +OpenGL/GL/MESA/__pycache__/framebuffer_flip_y.cpython-312.pyc,, +OpenGL/GL/MESA/__pycache__/pack_invert.cpython-312.pyc,, +OpenGL/GL/MESA/__pycache__/program_binary_formats.cpython-312.pyc,, +OpenGL/GL/MESA/__pycache__/resize_buffers.cpython-312.pyc,, +OpenGL/GL/MESA/__pycache__/shader_integer_functions.cpython-312.pyc,, +OpenGL/GL/MESA/__pycache__/tile_raster_order.cpython-312.pyc,, +OpenGL/GL/MESA/__pycache__/window_pos.cpython-312.pyc,, +OpenGL/GL/MESA/__pycache__/ycbcr_texture.cpython-312.pyc,, +OpenGL/GL/MESA/framebuffer_flip_y.py,sha256=9afLPmc-gMy0LNasazkSLaAD3xc9rEY7-XybcKeYS4c,1715 +OpenGL/GL/MESA/pack_invert.py,sha256=g3jWthEb_dGEDwfK-DKjlCuHJWeT2u2t0oR7mrAU070,1380 +OpenGL/GL/MESA/program_binary_formats.py,sha256=RexTQSdZIme2ePuvE2l-PdC7E5npACytZvjfXo95HF4,959 +OpenGL/GL/MESA/resize_buffers.py,sha256=COrPSYOM4TCurahW0uczsrGCVp5IDbAfe5SCA0Ced-I,1565 +OpenGL/GL/MESA/shader_integer_functions.py,sha256=CBv-l4B7CF1mt1VQf709vVNzo_j4cb-QepYpbwoqTVY,2555 +OpenGL/GL/MESA/tile_raster_order.py,sha256=aKjkrIQr8-j49B5B6-qrRvIUboo2jJsCkZcM3_xlhkM,1124 +OpenGL/GL/MESA/window_pos.py,sha256=0Nrw832uJeYdSAumqVUBZTm1Fl-d6RYvjiEUEZtPnJs,2574 +OpenGL/GL/MESA/ycbcr_texture.py,sha256=SJs-Pm4SoZnp7Q-5YeOrZBGQq9dZ3EPWfoJLYSMR6x0,1565 +OpenGL/GL/MESAX/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +OpenGL/GL/MESAX/__pycache__/__init__.cpython-312.pyc,, +OpenGL/GL/MESAX/__pycache__/texture_stack.cpython-312.pyc,, +OpenGL/GL/MESAX/texture_stack.py,sha256=elvasI7UIGcBekWRnJE86fUyEw1Bon5MKSrhMBiqMY8,2903 +OpenGL/GL/NV/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/GL/NV/__pycache__/__init__.cpython-312.pyc,, +OpenGL/GL/NV/__pycache__/alpha_to_coverage_dither_control.cpython-312.pyc,, +OpenGL/GL/NV/__pycache__/bindless_multi_draw_indirect.cpython-312.pyc,, +OpenGL/GL/NV/__pycache__/bindless_multi_draw_indirect_count.cpython-312.pyc,, +OpenGL/GL/NV/__pycache__/bindless_texture.cpython-312.pyc,, +OpenGL/GL/NV/__pycache__/blend_equation_advanced.cpython-312.pyc,, +OpenGL/GL/NV/__pycache__/blend_equation_advanced_coherent.cpython-312.pyc,, +OpenGL/GL/NV/__pycache__/blend_minmax_factor.cpython-312.pyc,, +OpenGL/GL/NV/__pycache__/blend_square.cpython-312.pyc,, +OpenGL/GL/NV/__pycache__/clip_space_w_scaling.cpython-312.pyc,, +OpenGL/GL/NV/__pycache__/command_list.cpython-312.pyc,, +OpenGL/GL/NV/__pycache__/compute_program5.cpython-312.pyc,, +OpenGL/GL/NV/__pycache__/compute_shader_derivatives.cpython-312.pyc,, +OpenGL/GL/NV/__pycache__/conditional_render.cpython-312.pyc,, +OpenGL/GL/NV/__pycache__/conservative_raster.cpython-312.pyc,, +OpenGL/GL/NV/__pycache__/conservative_raster_dilate.cpython-312.pyc,, +OpenGL/GL/NV/__pycache__/conservative_raster_pre_snap.cpython-312.pyc,, +OpenGL/GL/NV/__pycache__/conservative_raster_pre_snap_triangles.cpython-312.pyc,, +OpenGL/GL/NV/__pycache__/conservative_raster_underestimation.cpython-312.pyc,, +OpenGL/GL/NV/__pycache__/copy_depth_to_color.cpython-312.pyc,, +OpenGL/GL/NV/__pycache__/copy_image.cpython-312.pyc,, +OpenGL/GL/NV/__pycache__/deep_texture3D.cpython-312.pyc,, +OpenGL/GL/NV/__pycache__/depth_buffer_float.cpython-312.pyc,, +OpenGL/GL/NV/__pycache__/depth_clamp.cpython-312.pyc,, +OpenGL/GL/NV/__pycache__/draw_texture.cpython-312.pyc,, +OpenGL/GL/NV/__pycache__/draw_vulkan_image.cpython-312.pyc,, +OpenGL/GL/NV/__pycache__/evaluators.cpython-312.pyc,, +OpenGL/GL/NV/__pycache__/explicit_multisample.cpython-312.pyc,, +OpenGL/GL/NV/__pycache__/fence.cpython-312.pyc,, +OpenGL/GL/NV/__pycache__/fill_rectangle.cpython-312.pyc,, +OpenGL/GL/NV/__pycache__/float_buffer.cpython-312.pyc,, +OpenGL/GL/NV/__pycache__/fog_distance.cpython-312.pyc,, +OpenGL/GL/NV/__pycache__/fragment_coverage_to_color.cpython-312.pyc,, +OpenGL/GL/NV/__pycache__/fragment_program.cpython-312.pyc,, +OpenGL/GL/NV/__pycache__/fragment_program2.cpython-312.pyc,, +OpenGL/GL/NV/__pycache__/fragment_program4.cpython-312.pyc,, +OpenGL/GL/NV/__pycache__/fragment_program_option.cpython-312.pyc,, +OpenGL/GL/NV/__pycache__/fragment_shader_barycentric.cpython-312.pyc,, +OpenGL/GL/NV/__pycache__/fragment_shader_interlock.cpython-312.pyc,, +OpenGL/GL/NV/__pycache__/framebuffer_mixed_samples.cpython-312.pyc,, +OpenGL/GL/NV/__pycache__/framebuffer_multisample_coverage.cpython-312.pyc,, +OpenGL/GL/NV/__pycache__/geometry_program4.cpython-312.pyc,, +OpenGL/GL/NV/__pycache__/geometry_shader4.cpython-312.pyc,, +OpenGL/GL/NV/__pycache__/geometry_shader_passthrough.cpython-312.pyc,, +OpenGL/GL/NV/__pycache__/gpu_multicast.cpython-312.pyc,, +OpenGL/GL/NV/__pycache__/gpu_program4.cpython-312.pyc,, +OpenGL/GL/NV/__pycache__/gpu_program5.cpython-312.pyc,, +OpenGL/GL/NV/__pycache__/gpu_program5_mem_extended.cpython-312.pyc,, +OpenGL/GL/NV/__pycache__/gpu_shader5.cpython-312.pyc,, +OpenGL/GL/NV/__pycache__/half_float.cpython-312.pyc,, +OpenGL/GL/NV/__pycache__/internalformat_sample_query.cpython-312.pyc,, +OpenGL/GL/NV/__pycache__/light_max_exponent.cpython-312.pyc,, +OpenGL/GL/NV/__pycache__/memory_attachment.cpython-312.pyc,, +OpenGL/GL/NV/__pycache__/mesh_shader.cpython-312.pyc,, +OpenGL/GL/NV/__pycache__/multisample_coverage.cpython-312.pyc,, +OpenGL/GL/NV/__pycache__/multisample_filter_hint.cpython-312.pyc,, +OpenGL/GL/NV/__pycache__/occlusion_query.cpython-312.pyc,, +OpenGL/GL/NV/__pycache__/packed_depth_stencil.cpython-312.pyc,, +OpenGL/GL/NV/__pycache__/parameter_buffer_object.cpython-312.pyc,, +OpenGL/GL/NV/__pycache__/parameter_buffer_object2.cpython-312.pyc,, +OpenGL/GL/NV/__pycache__/path_rendering.cpython-312.pyc,, +OpenGL/GL/NV/__pycache__/path_rendering_shared_edge.cpython-312.pyc,, +OpenGL/GL/NV/__pycache__/pixel_data_range.cpython-312.pyc,, +OpenGL/GL/NV/__pycache__/point_sprite.cpython-312.pyc,, +OpenGL/GL/NV/__pycache__/present_video.cpython-312.pyc,, +OpenGL/GL/NV/__pycache__/primitive_restart.cpython-312.pyc,, +OpenGL/GL/NV/__pycache__/query_resource.cpython-312.pyc,, +OpenGL/GL/NV/__pycache__/query_resource_tag.cpython-312.pyc,, +OpenGL/GL/NV/__pycache__/register_combiners.cpython-312.pyc,, +OpenGL/GL/NV/__pycache__/register_combiners2.cpython-312.pyc,, +OpenGL/GL/NV/__pycache__/representative_fragment_test.cpython-312.pyc,, +OpenGL/GL/NV/__pycache__/robustness_video_memory_purge.cpython-312.pyc,, +OpenGL/GL/NV/__pycache__/sample_locations.cpython-312.pyc,, +OpenGL/GL/NV/__pycache__/sample_mask_override_coverage.cpython-312.pyc,, +OpenGL/GL/NV/__pycache__/scissor_exclusive.cpython-312.pyc,, +OpenGL/GL/NV/__pycache__/shader_atomic_counters.cpython-312.pyc,, +OpenGL/GL/NV/__pycache__/shader_atomic_float.cpython-312.pyc,, +OpenGL/GL/NV/__pycache__/shader_atomic_float64.cpython-312.pyc,, +OpenGL/GL/NV/__pycache__/shader_atomic_fp16_vector.cpython-312.pyc,, +OpenGL/GL/NV/__pycache__/shader_atomic_int64.cpython-312.pyc,, +OpenGL/GL/NV/__pycache__/shader_buffer_load.cpython-312.pyc,, +OpenGL/GL/NV/__pycache__/shader_buffer_store.cpython-312.pyc,, +OpenGL/GL/NV/__pycache__/shader_storage_buffer_object.cpython-312.pyc,, +OpenGL/GL/NV/__pycache__/shader_subgroup_partitioned.cpython-312.pyc,, +OpenGL/GL/NV/__pycache__/shader_texture_footprint.cpython-312.pyc,, +OpenGL/GL/NV/__pycache__/shader_thread_group.cpython-312.pyc,, +OpenGL/GL/NV/__pycache__/shader_thread_shuffle.cpython-312.pyc,, +OpenGL/GL/NV/__pycache__/shading_rate_image.cpython-312.pyc,, +OpenGL/GL/NV/__pycache__/stereo_view_rendering.cpython-312.pyc,, +OpenGL/GL/NV/__pycache__/tessellation_program5.cpython-312.pyc,, +OpenGL/GL/NV/__pycache__/texgen_emboss.cpython-312.pyc,, +OpenGL/GL/NV/__pycache__/texgen_reflection.cpython-312.pyc,, +OpenGL/GL/NV/__pycache__/texture_barrier.cpython-312.pyc,, +OpenGL/GL/NV/__pycache__/texture_compression_vtc.cpython-312.pyc,, +OpenGL/GL/NV/__pycache__/texture_env_combine4.cpython-312.pyc,, +OpenGL/GL/NV/__pycache__/texture_expand_normal.cpython-312.pyc,, +OpenGL/GL/NV/__pycache__/texture_multisample.cpython-312.pyc,, +OpenGL/GL/NV/__pycache__/texture_rectangle.cpython-312.pyc,, +OpenGL/GL/NV/__pycache__/texture_rectangle_compressed.cpython-312.pyc,, +OpenGL/GL/NV/__pycache__/texture_shader.cpython-312.pyc,, +OpenGL/GL/NV/__pycache__/texture_shader2.cpython-312.pyc,, +OpenGL/GL/NV/__pycache__/texture_shader3.cpython-312.pyc,, +OpenGL/GL/NV/__pycache__/transform_feedback.cpython-312.pyc,, +OpenGL/GL/NV/__pycache__/transform_feedback2.cpython-312.pyc,, +OpenGL/GL/NV/__pycache__/uniform_buffer_unified_memory.cpython-312.pyc,, +OpenGL/GL/NV/__pycache__/vdpau_interop.cpython-312.pyc,, +OpenGL/GL/NV/__pycache__/vdpau_interop2.cpython-312.pyc,, +OpenGL/GL/NV/__pycache__/vertex_array_range.cpython-312.pyc,, +OpenGL/GL/NV/__pycache__/vertex_array_range2.cpython-312.pyc,, +OpenGL/GL/NV/__pycache__/vertex_attrib_integer_64bit.cpython-312.pyc,, +OpenGL/GL/NV/__pycache__/vertex_buffer_unified_memory.cpython-312.pyc,, +OpenGL/GL/NV/__pycache__/vertex_program.cpython-312.pyc,, +OpenGL/GL/NV/__pycache__/vertex_program1_1.cpython-312.pyc,, +OpenGL/GL/NV/__pycache__/vertex_program2.cpython-312.pyc,, +OpenGL/GL/NV/__pycache__/vertex_program2_option.cpython-312.pyc,, +OpenGL/GL/NV/__pycache__/vertex_program3.cpython-312.pyc,, +OpenGL/GL/NV/__pycache__/vertex_program4.cpython-312.pyc,, +OpenGL/GL/NV/__pycache__/video_capture.cpython-312.pyc,, +OpenGL/GL/NV/__pycache__/viewport_array2.cpython-312.pyc,, +OpenGL/GL/NV/__pycache__/viewport_swizzle.cpython-312.pyc,, +OpenGL/GL/NV/alpha_to_coverage_dither_control.py,sha256=oGwICaCN5fkTAOv3e8WQ1tP-o_NiehqQcjLYxw5PAmg,1058 +OpenGL/GL/NV/bindless_multi_draw_indirect.py,sha256=SFfDXJtHy_pzmt90HnAUEwHW2OngfjXS2UgzyubsipA,1822 +OpenGL/GL/NV/bindless_multi_draw_indirect_count.py,sha256=tRbTHey62IItymLq8P72-J3DrK6ykuXRsVFzenPZegM,1118 +OpenGL/GL/NV/bindless_texture.py,sha256=8EFKv4K4axa-w9Kmd123WtH33pkzb3V7wQ7Cp-hCYM8,3845 +OpenGL/GL/NV/blend_equation_advanced.py,sha256=PxEimoyuxcjfhxZWULg7oTrOHpDc9TLA0aPHGa7iIlg,5340 +OpenGL/GL/NV/blend_equation_advanced_coherent.py,sha256=mPMNAEdvOoaPsi9xm3z34NCzewA8jY6vxmmd-WrqDsU,856 +OpenGL/GL/NV/blend_minmax_factor.py,sha256=xRr-wVKNwUgLre7_nnf1tXKsFnQkZU1VltjFKfeIDqA,1630 +OpenGL/GL/NV/blend_square.py,sha256=iZUO4AWIyb93oL_6kgX1FbXm4Cj33v3OGrZRsAHBmeA,1294 +OpenGL/GL/NV/clip_space_w_scaling.py,sha256=dB0Vyg98Q4BIvC9KLh4yWMmQhuYmeMFbhygkuVbCQfc,2581 +OpenGL/GL/NV/command_list.py,sha256=Gvno5UvHK9TYUwD9Gmd7nYN_qbaE6GVXT1429GPjpmg,2680 +OpenGL/GL/NV/compute_program5.py,sha256=i31ZW2-Rs_jjApx-CM6srswhTs3be846wCjTta19O-I,1199 +OpenGL/GL/NV/compute_shader_derivatives.py,sha256=evpE9AZv6TaDbe2MS08uZMMG-ZE9EbsTGKWRfG32Zf4,1429 +OpenGL/GL/NV/conditional_render.py,sha256=wkUaNodRsdJXm2mhFP7akF_J7qdSKc0N5D5wTegbxlg,2269 +OpenGL/GL/NV/conservative_raster.py,sha256=JoZ7j2lCZRHcdImTdsLxe2v5OZbdu1l-XYzyRu1c5gg,1627 +OpenGL/GL/NV/conservative_raster_dilate.py,sha256=gGY0skaWnYr7Uky2XHXhKM6QM0rez_XDrg9gMKjivpY,1452 +OpenGL/GL/NV/conservative_raster_pre_snap.py,sha256=KPwXfv_INoC8bppPy5IT_xSARMR7LTKioVAbIizAl60,1167 +OpenGL/GL/NV/conservative_raster_pre_snap_triangles.py,sha256=nyYaUkGbFfXbKy7w2bLegCB6MgDJthoyrn9VpdWhRlc,2268 +OpenGL/GL/NV/conservative_raster_underestimation.py,sha256=G9fAqjmDH0AI5g7LzXOx_AB65jLeWUVRtQeWy4T-5ac,1523 +OpenGL/GL/NV/copy_depth_to_color.py,sha256=MlVOdy3PTEHUieDgjrEnYROWNgcmWl-PsUZ1h3AJmsk,2411 +OpenGL/GL/NV/copy_image.py,sha256=pcpEo7cPoNMWzYfy1a7Kqlko5QIIrp7Zn3ja4jmhpNo,1121 +OpenGL/GL/NV/deep_texture3D.py,sha256=nMip_TarhvQzAwvec0RV10LTC4fRanu2SB_KBV98lPU,1192 +OpenGL/GL/NV/depth_buffer_float.py,sha256=XKiEKaOY9eXn8uG9glA7ZzlY21KpOB4yQeRgL93bhCI,2022 +OpenGL/GL/NV/depth_clamp.py,sha256=fyjlcq8AUPjKNwHefh-Pl6I_6aV9bNZ73a1i1mtjBEI,2378 +OpenGL/GL/NV/draw_texture.py,sha256=tOULYZ2-B15NWYFEV3cUExoHT6W14VEJ6prGP40fArI,2060 +OpenGL/GL/NV/draw_vulkan_image.py,sha256=jVUP-adJ60Vy-ik_PghrpiaSlPlxb_L1YioHxaiKg4Y,2342 +OpenGL/GL/NV/evaluators.py,sha256=vkBbceDBqUdrdrYY9EwQda3TkQLFzj6zC6gt8nSeAoI,4893 +OpenGL/GL/NV/explicit_multisample.py,sha256=znDcGTiG1GD5-2FPWrCnklP9FAPownAoTCxuEoi1vXE,1660 +OpenGL/GL/NV/fence.py,sha256=DeN0_yuaixpbIsQJVRGVBTmT3_JIcAzNEAjj8c1pko0,2757 +OpenGL/GL/NV/fill_rectangle.py,sha256=tw4KFTGycBMRsebLUK2LlPamy6So_THuTjProbOQuJ0,1189 +OpenGL/GL/NV/float_buffer.py,sha256=0TgvV5fnqfx3NxY6IqbuATNLShhVEVed_dQQYJflTyU,4432 +OpenGL/GL/NV/fog_distance.py,sha256=CPS41BGhthPX6aeB0rNE_pT1rgKrhcD2WBLrQxkHlNM,2500 +OpenGL/GL/NV/fragment_coverage_to_color.py,sha256=kj5TxU9zHwOh1EZm9lqxyahMhcpA-S3U4R_9TcfTtBg,1535 +OpenGL/GL/NV/fragment_program.py,sha256=V10Dx1kJwlAHZZLhvCQpg3bVKVMvUnFhIveYXFtMBpI,4648 +OpenGL/GL/NV/fragment_program2.py,sha256=SQC4nPs2isqtFxB8siXLuhW0eW4UnAX556I1UpO30WQ,1966 +OpenGL/GL/NV/fragment_program4.py,sha256=5II8bgVTMX41WQIPUVFlbCJ2RNvL_20LdLXRn8f1Ojc,2251 +OpenGL/GL/NV/fragment_program_option.py,sha256=uidqledtrUw-UvtoSIPTg2eu3Rpuhu0RN40oNlGgATQ,1835 +OpenGL/GL/NV/fragment_shader_barycentric.py,sha256=WQSrlSGFw4jv86DTETeMEnQqrCbsUekOnnir2CuSk1o,1296 +OpenGL/GL/NV/fragment_shader_interlock.py,sha256=U-ZS8d2nmnwA9AO1Y8kv0iA-BnGmrXG02mLTgSXsZM0,3927 +OpenGL/GL/NV/framebuffer_mixed_samples.py,sha256=k4IbJ9dk1ZwTcM_rifqlnwtobO1jfmKA2CPBBGzyw7w,3631 +OpenGL/GL/NV/framebuffer_multisample_coverage.py,sha256=L9MX2CIrS3J4882usdRJmDGaWC2p0LXcQE2Xhqz7oTs,1856 +OpenGL/GL/NV/geometry_program4.py,sha256=nEqnzmhJuTKHAFSs-4ZRpW6faciMxKR03ik0xAbKb7E,3307 +OpenGL/GL/NV/geometry_shader4.py,sha256=AxaKBnX7dXl1vKgQ3Gn5qT-ofsamJ7-RbbYOBH-uYT0,1328 +OpenGL/GL/NV/geometry_shader_passthrough.py,sha256=bd_yYYJPU-unD38tecU7_xUg0LOrpfpk8tiyNPZSQzQ,3359 +OpenGL/GL/NV/gpu_multicast.py,sha256=PdfF-yLDo26gXq_28sF0o05wYStGdX4EWxepODkpwp4,2764 +OpenGL/GL/NV/gpu_program4.py,sha256=rjVjUA5EFeggEO3n8XNmD-zfnXm18FKwbOpa37aklDU,4520 +OpenGL/GL/NV/gpu_program5.py,sha256=sHPhT-fk2tlrpgYKMyrVNRxOzBGQ-p05rffif_NIt4M,6612 +OpenGL/GL/NV/gpu_program5_mem_extended.py,sha256=AAenHRVSi7rfEYjHFlFqXdrORYLvDevdnMsHsi6hqmQ,2504 +OpenGL/GL/NV/gpu_shader5.py,sha256=kGWsbJcWFRARqZLKErH6IZw63XfmCIwwEcOE_8dNTxs,6416 +OpenGL/GL/NV/half_float.py,sha256=eq7GZ91QZfx8MEzJ7Cv_El2rWekSvVa_zJcaHjoyJhs,4007 +OpenGL/GL/NV/internalformat_sample_query.py,sha256=FwY5lPgxoZBfDfCZPJciIEzb_l_chplXIZwnAieVrjg,2989 +OpenGL/GL/NV/light_max_exponent.py,sha256=BuL-6RocRkLlplHBvXEIxoHVtQmeoAYwkil7NhHjVyU,1291 +OpenGL/GL/NV/memory_attachment.py,sha256=_MyrNmZVMm3EQ2HD4AxAXrBmI4qYlWAwEG0DRnk2-os,1138 +OpenGL/GL/NV/mesh_shader.py,sha256=OeAbcmJlR-ZwCnkUEE0kbDb8RbggTpjryqpIROb_jrI,1256 +OpenGL/GL/NV/multisample_coverage.py,sha256=-fniFWuU998cx902PTmTOF5eOKFcpN4DmVAoK9HYiyE,2079 +OpenGL/GL/NV/multisample_filter_hint.py,sha256=9FWmw2I6L-ufbItmGwLPmEEhL19i_Ipv1i7kaDZ_d20,1543 +OpenGL/GL/NV/occlusion_query.py,sha256=P9BiD9Nv3cuPZ6_MPJM2jWYMfy80-Kb-ug0-4MKcflM,4454 +OpenGL/GL/NV/packed_depth_stencil.py,sha256=y6wb4bFkXo8zao8ygVkRrSSekq6IEulO9EcUW3JIXpQ,4567 +OpenGL/GL/NV/parameter_buffer_object.py,sha256=XBYUIQqZB1OzvmojJx-Y4f-s10wTEz-bnjtOPMRR_gg,2582 +OpenGL/GL/NV/parameter_buffer_object2.py,sha256=yJY-WPjib9MIu4kRcI5gVS1lSSVEVi8LFGsOnovE35Y,2578 +OpenGL/GL/NV/path_rendering.py,sha256=Xu2DyJgI_gI_tTGmdx9BkxrR-kohQ3-DtSKfqyp3Xtc,24677 +OpenGL/GL/NV/path_rendering_shared_edge.py,sha256=3uTW2NpF82ZvZsIV4l9knbR07-uo96LGtqSRYPddYJQ,1446 +OpenGL/GL/NV/pixel_data_range.py,sha256=zUOmaX0Fz9RiEF4HK06puDWBZr8rRUBICivc0wx06lM,3911 +OpenGL/GL/NV/point_sprite.py,sha256=ihJhcjuL05Szd0JEp_JxlKbaJnafzYlYFbXK6oph-Bw,2210 +OpenGL/GL/NV/present_video.py,sha256=VVZzzJyjuP07hQ60rjzw1_O952oTwoPx7ihIHAf9rns,2133 +OpenGL/GL/NV/primitive_restart.py,sha256=_Y0LXUlo08PFAHCCtKoVRJ7vyMhkIpWuX08Q0MQtFqU,2044 +OpenGL/GL/NV/query_resource.py,sha256=oGpxVVKOCOeovie627pM2m9AHFyKQ_ImPU3X1Sw-I9o,1924 +OpenGL/GL/NV/query_resource_tag.py,sha256=TDt9vAGQpXH42IQ42Nx0ycnihwYU6J_5QGcQp1W5KdE,1476 +OpenGL/GL/NV/register_combiners.py,sha256=HNrboPerXJn1oNFl43oSbVACmaPJ_JqtIVdirnXnKLc,5567 +OpenGL/GL/NV/register_combiners2.py,sha256=YmTEytu8rMU5aTXhEtSlueQcQlwfUkM0DT-RXY8I5wI,2543 +OpenGL/GL/NV/representative_fragment_test.py,sha256=oejUrOHKRvUIj2nEXB7YIW14zyl64Y8footeaIPlUcY,2424 +OpenGL/GL/NV/robustness_video_memory_purge.py,sha256=Nr8pcRVyeqMVdty_JXph5MTLvjBdVw_W_9PODMxg0R8,2023 +OpenGL/GL/NV/sample_locations.py,sha256=Ot4OuW8BmizgVoGNQZh5xj0_kLTZNOpH6c8YbW1zRaw,2707 +OpenGL/GL/NV/sample_mask_override_coverage.py,sha256=cADDoxqOWO9BZ2f87czEuXseuMvscgtHRwvqh7-XVZE,1236 +OpenGL/GL/NV/scissor_exclusive.py,sha256=2Vrr6-eIGp7foE04SP-Nt1eg7HJbhIiybx_Bqu6YWKE,1696 +OpenGL/GL/NV/shader_atomic_counters.py,sha256=kRyeDDLZ9-M_QQS_FTHHm6qR12Gf0XlTAobt3qVq4Ao,1271 +OpenGL/GL/NV/shader_atomic_float.py,sha256=r1k5e5PUC7Son9Mqj_mhkPUQ2QoVVtQQWTEg8bsGFMw,1621 +OpenGL/GL/NV/shader_atomic_float64.py,sha256=Ir0ixurGi3_DkTvEFOF1IXqPs7W9sdyMLuzHwq6o8Jc,1565 +OpenGL/GL/NV/shader_atomic_fp16_vector.py,sha256=BwZVdoNQhQloLzGFgxjN2EYSR52KKxpRL0Rruu2a7po,1075 +OpenGL/GL/NV/shader_atomic_int64.py,sha256=uMAUahZsjru4hCNimto_JA-z3Jm8Nh2pjJK3a2Pym6k,1037 +OpenGL/GL/NV/shader_buffer_load.py,sha256=lD7MlC_fm7yJu3_gaT11K4B2DMVklgXbbugMQigiPPI,5977 +OpenGL/GL/NV/shader_buffer_store.py,sha256=MNNRx_AyDaT4MgED53QeKdyKnUD4xECuhqUNhDw3wGU,2209 +OpenGL/GL/NV/shader_storage_buffer_object.py,sha256=iMPD_k-YptNovR83gtPP2xxkGs0kB-FNo-DqNxIsOsg,1287 +OpenGL/GL/NV/shader_subgroup_partitioned.py,sha256=Yg8HQtvjts-8yL-Dcpu6W6YzN8ZiwpObmVBz_O2IYzI,1440 +OpenGL/GL/NV/shader_texture_footprint.py,sha256=Wu7XWBO5mJtuSZ6ISyfUc9QemqjaNPG2LWQNdo8CDAQ,3923 +OpenGL/GL/NV/shader_thread_group.py,sha256=hzljeTCbOW_hQlgtG7W-ROKspeUeSg2Y11-DWz96fow,2565 +OpenGL/GL/NV/shader_thread_shuffle.py,sha256=ZC7xG8ymVODAv6i1Df56f6Lx3SSNvxHp0kZsLKuETtk,1564 +OpenGL/GL/NV/shading_rate_image.py,sha256=vNs0_MLz8z_osQkHPOb_b9p5wlwMaeKCAaT0ROnZ_rI,3923 +OpenGL/GL/NV/stereo_view_rendering.py,sha256=Ao8lqPbdvLx-KY1tfJW7thbL6nm2oorUuMyBGwyXAFU,2146 +OpenGL/GL/NV/tessellation_program5.py,sha256=BTq3JU1wtZ-72nlr5msXLV5CcG7Ies5i2BISw1D3Y6U,5359 +OpenGL/GL/NV/texgen_emboss.py,sha256=WMdIkmDsBZaxtGf8u_52Z7XkSJrWzoSwZQm51w-kzxI,1741 +OpenGL/GL/NV/texgen_reflection.py,sha256=62KGxRlLTZNMPAg4XR63x86wwQBbLUjyJkv0uFGmK3c,1371 +OpenGL/GL/NV/texture_barrier.py,sha256=UkfLG58iu3tfoQyZXnpFYirjgIWAWpODdZIjyZAGROM,929 +OpenGL/GL/NV/texture_compression_vtc.py,sha256=FowdhLKdL8YwjwaudNr-gZtTuyIFqDYu8qTx4OTaoIk,1162 +OpenGL/GL/NV/texture_env_combine4.py,sha256=bgnZq38sD7CxD3PgA-KRjZcgFbc7soFgriXoodvu__M,1611 +OpenGL/GL/NV/texture_expand_normal.py,sha256=zkOXTxCF8BU0zyZYU76Rud7hqegwDl-1FlZvgzYzx20,1288 +OpenGL/GL/NV/texture_multisample.py,sha256=hROdujoUQpEn_5_d1bkZ85vvndrYD3aCT5I-sOcp8LA,1383 +OpenGL/GL/NV/texture_rectangle.py,sha256=h6A6bUtnbDKmxCImCO4D-4iS_THOQRisgz_MrtKrBy0,2250 +OpenGL/GL/NV/texture_rectangle_compressed.py,sha256=Jyd9wKUJ17RaG8ZQRyXencwRc-D8FMhJQRJj2l_ZbF4,1063 +OpenGL/GL/NV/texture_shader.py,sha256=KmSdP4lULXj7UnbyUWmQrIeesO80Dl70SzBHs2XY3Kg,8820 +OpenGL/GL/NV/texture_shader2.py,sha256=HhH5nyjA6ul5Jsp1IcXphXMTMFNLv-LvjKZPSGMKrI8,1456 +OpenGL/GL/NV/texture_shader3.py,sha256=OdpNMkJobIF4hoyAz2Xm7Yxhez6BjFzYCFByxqE_CcM,4821 +OpenGL/GL/NV/transform_feedback.py,sha256=62CQOaCysXF__DCga-QRHeg3PssZd_GVLNW-NYiNGz0,4300 +OpenGL/GL/NV/transform_feedback2.py,sha256=JyFwQdc5y45FC0bzlkkLGZPFol55fpE0d0-RVhJaCPc,2618 +OpenGL/GL/NV/uniform_buffer_unified_memory.py,sha256=seK7pHlPFM10yhPM3cBsb4v1hbhjT2vOmgLQMwlOwX4,1348 +OpenGL/GL/NV/vdpau_interop.py,sha256=Yw4HhmZFrey7yo3YVtVpiLm4vibVC2K0c3dU-cH1Xo0,2319 +OpenGL/GL/NV/vdpau_interop2.py,sha256=rC5vPRlvwCvhruDDS8Hay8JZehr6JzRjWXJj8RPVT0c,1175 +OpenGL/GL/NV/vertex_array_range.py,sha256=lQIHaliYt3eiQi92Ehg5cqQ9uLokMPAaAuIfhZtKwys,4952 +OpenGL/GL/NV/vertex_array_range2.py,sha256=RIIHIICgND1K9TuTc_NxYbSERtRcprB8JTtHQf42fCU,1375 +OpenGL/GL/NV/vertex_attrib_integer_64bit.py,sha256=CdyYv1lHsgP2TiuPzRoQYf7lMCXzB0ZkfhC_IPHxR5g,2350 +OpenGL/GL/NV/vertex_buffer_unified_memory.py,sha256=lAZJngKzXlIEwuuY8LiIR9TzWjuU3_2AsqkHw-Q_Lfc,1516 +OpenGL/GL/NV/vertex_program.py,sha256=TGmAy1fqMGbUEo87FwqR2S7HVRKDHZSL92UOEyhnR_Y,9238 +OpenGL/GL/NV/vertex_program1_1.py,sha256=ilgd296QK2AH_DXLndy_aW3Xmx47fPfNOPgCfxONTOM,2029 +OpenGL/GL/NV/vertex_program2.py,sha256=7qvr5mDTpoalqcy0_Q1XdmRjR9hOcK_9_kRnXLWuqOc,4720 +OpenGL/GL/NV/vertex_program2_option.py,sha256=BL4YUDrKuVRYVS7fJnCEriPFCDOJO6vpF_5gpfk2hUs,1736 +OpenGL/GL/NV/vertex_program3.py,sha256=r_yLYMi05M62HHzug4pCayG7O9X1bgsRkOpze8U92xE,1521 +OpenGL/GL/NV/vertex_program4.py,sha256=CqHJZaJQk1yf137LCOe2q9M5QH74nMcbTgnZXgMRQ4U,3798 +OpenGL/GL/NV/video_capture.py,sha256=W2uM8yE221tLi9lvXFfWQIE7Ta9p0Vx5vjCA9n2xqfo,2433 +OpenGL/GL/NV/viewport_array2.py,sha256=RrjJQx_PVKfBDf1M8wxvbNaJdrpNFwCH03a1lcU-9jM,1927 +OpenGL/GL/NV/viewport_swizzle.py,sha256=D-bNVBHaEsVsAGuZAuUlNjjjdY2zXTjfruMFEh9jiL8,1725 +OpenGL/GL/NVX/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +OpenGL/GL/NVX/__pycache__/__init__.cpython-312.pyc,, +OpenGL/GL/NVX/__pycache__/blend_equation_advanced_multi_draw_buffers.cpython-312.pyc,, +OpenGL/GL/NVX/__pycache__/conditional_render.cpython-312.pyc,, +OpenGL/GL/NVX/__pycache__/gpu_memory_info.cpython-312.pyc,, +OpenGL/GL/NVX/__pycache__/gpu_multicast2.cpython-312.pyc,, +OpenGL/GL/NVX/__pycache__/linked_gpu_multicast.cpython-312.pyc,, +OpenGL/GL/NVX/__pycache__/progress_fence.cpython-312.pyc,, +OpenGL/GL/NVX/blend_equation_advanced_multi_draw_buffers.py,sha256=poA6EEnNPey3jCnPWWoQ9ixyFoKoqPcFMc_4I7hTjyo,1420 +OpenGL/GL/NVX/conditional_render.py,sha256=QciVp_J6VvP0gRmiD9oaw4vDuop9B_3xLnjd7h1Lg9M,1605 +OpenGL/GL/NVX/gpu_memory_info.py,sha256=PBjn2kbRDrQmzxknBRDLWnfgyiD90mhxZcnXAw3Byoc,2172 +OpenGL/GL/NVX/gpu_multicast2.py,sha256=9KSZAGGl12QllhQWe8FBcUR3H5AW5ISe6xTtfEYXsuU,2619 +OpenGL/GL/NVX/linked_gpu_multicast.py,sha256=Fp6vpY6g5-PrKUE5jMupKUkdEetv83VFsVCt4K7d8c0,2822 +OpenGL/GL/NVX/progress_fence.py,sha256=3QeYwWRSW91lEmCbJbS-Hn9FvnryfZhkswd7QLUQfmo,2734 +OpenGL/GL/OES/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/GL/OES/__pycache__/__init__.cpython-312.pyc,, +OpenGL/GL/OES/__pycache__/byte_coordinates.cpython-312.pyc,, +OpenGL/GL/OES/__pycache__/compressed_paletted_texture.cpython-312.pyc,, +OpenGL/GL/OES/__pycache__/fixed_point.cpython-312.pyc,, +OpenGL/GL/OES/__pycache__/query_matrix.cpython-312.pyc,, +OpenGL/GL/OES/__pycache__/read_format.cpython-312.pyc,, +OpenGL/GL/OES/__pycache__/single_precision.cpython-312.pyc,, +OpenGL/GL/OES/byte_coordinates.py,sha256=9Dq-w4vnl5aagl74XjCIc3-A5ujHyBS3Cq9b9C0YDb8,2050 +OpenGL/GL/OES/compressed_paletted_texture.py,sha256=lhQ3KIANNp1UueYtVxebcKrddzLIHBGW-n_KINde1XM,2362 +OpenGL/GL/OES/fixed_point.py,sha256=Sbaf-ZS0IemO5CWlai1vsA73WktSptoHIpWEv40RrDU,7978 +OpenGL/GL/OES/query_matrix.py,sha256=MvHd2PRLIrWFp-BKNUd5y-3wQgiT1QHMh1Mhlf-zqpI,1525 +OpenGL/GL/OES/read_format.py,sha256=IogryviSZfOKolMFSgq2PMT6QtnEimV_oWT1FruIhnQ,1298 +OpenGL/GL/OES/single_precision.py,sha256=nxoUXOYhAMsI2KZRozkcfEAjdLSi4ZjEuLmOIDMG7i8,1305 +OpenGL/GL/OML/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/GL/OML/__pycache__/__init__.cpython-312.pyc,, +OpenGL/GL/OML/__pycache__/interlace.cpython-312.pyc,, +OpenGL/GL/OML/__pycache__/resample.cpython-312.pyc,, +OpenGL/GL/OML/__pycache__/subsample.cpython-312.pyc,, +OpenGL/GL/OML/interlace.py,sha256=QELR7YYuIUCyQ7qqRkKcKhILNzE_ltxhAa3SsxbkudA,1422 +OpenGL/GL/OML/resample.py,sha256=rNYx6HsMrZtuU0lCPXmuISnOsgBvfDEWn03czMAqQ8g,1502 +OpenGL/GL/OML/subsample.py,sha256=8ppqGqyB6s1rTGzb3ddJ7wkpApRCEvMAvpezhWWFQO4,2284 +OpenGL/GL/OVR/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/GL/OVR/__pycache__/__init__.cpython-312.pyc,, +OpenGL/GL/OVR/__pycache__/multiview.cpython-312.pyc,, +OpenGL/GL/OVR/__pycache__/multiview2.cpython-312.pyc,, +OpenGL/GL/OVR/multiview.py,sha256=fgwbGmeUFw71-y1uitBFO2MvcMKcc1UFDzWyokHJFBc,2617 +OpenGL/GL/OVR/multiview2.py,sha256=7kSrxWbMXwbZHffXKNuVATVB_q7faYv0lPnlcpGsWfw,978 +OpenGL/GL/PGI/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/GL/PGI/__pycache__/__init__.cpython-312.pyc,, +OpenGL/GL/PGI/__pycache__/misc_hints.cpython-312.pyc,, +OpenGL/GL/PGI/__pycache__/vertex_hints.cpython-312.pyc,, +OpenGL/GL/PGI/misc_hints.py,sha256=nc9mkqdG1CxBvPXu1V5FM6DyaiO4cRNIXgmSCRu1sEE,882 +OpenGL/GL/PGI/vertex_hints.py,sha256=pMDaylzk1WhScAPkuOFrDKIpdkh3MigDZmsIK7yIgR4,900 +OpenGL/GL/QCOM/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/GL/QCOM/__pycache__/__init__.cpython-312.pyc,, +OpenGL/GL/REND/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/GL/REND/__pycache__/__init__.cpython-312.pyc,, +OpenGL/GL/REND/__pycache__/screen_coordinates.cpython-312.pyc,, +OpenGL/GL/REND/screen_coordinates.py,sha256=rBhVd6th3AFgaSj8nOWSUd_R5xdXbEySeeRTfkScxr4,2616 +OpenGL/GL/S3/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/GL/S3/__pycache__/__init__.cpython-312.pyc,, +OpenGL/GL/S3/__pycache__/s3tc.cpython-312.pyc,, +OpenGL/GL/S3/s3tc.py,sha256=Nv1E3cxMZ9X8A9UhaZRPoweuSwupSyk6D7-Ie9ksNmY,794 +OpenGL/GL/SGI/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/GL/SGI/__pycache__/__init__.cpython-312.pyc,, +OpenGL/GL/SGI/__pycache__/color_matrix.cpython-312.pyc,, +OpenGL/GL/SGI/__pycache__/color_table.cpython-312.pyc,, +OpenGL/GL/SGI/__pycache__/texture_color_table.cpython-312.pyc,, +OpenGL/GL/SGI/color_matrix.py,sha256=d2Yq5-srNMb97PYyhGMNJ1UFapYEJPA55jsqb7Y-v7A,1441 +OpenGL/GL/SGI/color_table.py,sha256=1MGvcN7TLGmguImvl15LydO2wiuMZqzXzejeCSyZ4Xk,2535 +OpenGL/GL/SGI/texture_color_table.py,sha256=olCYhP_037K5a8qTSbf4_YMwk0dM4kT0ZVgR3ZLFalk,1505 +OpenGL/GL/SGIS/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/GL/SGIS/__pycache__/__init__.cpython-312.pyc,, +OpenGL/GL/SGIS/__pycache__/detail_texture.cpython-312.pyc,, +OpenGL/GL/SGIS/__pycache__/fog_function.cpython-312.pyc,, +OpenGL/GL/SGIS/__pycache__/generate_mipmap.cpython-312.pyc,, +OpenGL/GL/SGIS/__pycache__/multisample.cpython-312.pyc,, +OpenGL/GL/SGIS/__pycache__/pixel_texture.cpython-312.pyc,, +OpenGL/GL/SGIS/__pycache__/point_line_texgen.cpython-312.pyc,, +OpenGL/GL/SGIS/__pycache__/point_parameters.cpython-312.pyc,, +OpenGL/GL/SGIS/__pycache__/sharpen_texture.cpython-312.pyc,, +OpenGL/GL/SGIS/__pycache__/texture4D.cpython-312.pyc,, +OpenGL/GL/SGIS/__pycache__/texture_border_clamp.cpython-312.pyc,, +OpenGL/GL/SGIS/__pycache__/texture_color_mask.cpython-312.pyc,, +OpenGL/GL/SGIS/__pycache__/texture_edge_clamp.cpython-312.pyc,, +OpenGL/GL/SGIS/__pycache__/texture_filter4.cpython-312.pyc,, +OpenGL/GL/SGIS/__pycache__/texture_lod.cpython-312.pyc,, +OpenGL/GL/SGIS/__pycache__/texture_select.cpython-312.pyc,, +OpenGL/GL/SGIS/detail_texture.py,sha256=4_uhY7sGwVHZqf6ttykEW7rdHsAxWmxkBNbv8in8bo0,1873 +OpenGL/GL/SGIS/fog_function.py,sha256=faybh49VbuxVb62NNhSWb1Z7m7zyVT99Rizal12a7Uw,1445 +OpenGL/GL/SGIS/generate_mipmap.py,sha256=REGydDNrZalzt-P97nIYoiJmppAuDWRbcMgz60jLqEc,1050 +OpenGL/GL/SGIS/multisample.py,sha256=ut88xfi87gfoW6lPs6tVAwRLZKaOJRIf1CTVRXyfs5c,2264 +OpenGL/GL/SGIS/pixel_texture.py,sha256=SFTrhk6ewq75Qjz-VyXN7kL-Ty9yczYgb5wSZN8CrGM,3808 +OpenGL/GL/SGIS/point_line_texgen.py,sha256=YxhLgUKiK9gNRyEez1s05UEUdOXaflCv-2s6Mp-gYH0,978 +OpenGL/GL/SGIS/point_parameters.py,sha256=5dd5EG8q2oNbUbhSTEMfaXGjRUKxZl4J6_sG1FGUDiI,947 +OpenGL/GL/SGIS/sharpen_texture.py,sha256=0fOHAffMM5yO7x2cLgKM8QvKwvxB1M1lAUfxLXa5dUM,1396 +OpenGL/GL/SGIS/texture4D.py,sha256=8mwmHsGNmjHXSCGAO1OxURgrDmkQ_X8ExhPg47nLCEU,2313 +OpenGL/GL/SGIS/texture_border_clamp.py,sha256=W0GTM4xrDZaXOTJZ637Mna99QvRS2mhtjRZWnEtGbbY,1664 +OpenGL/GL/SGIS/texture_color_mask.py,sha256=7f-lWYslL1AORbLM6vdm9BOStnFpS2PBusoxJkVF0yo,1353 +OpenGL/GL/SGIS/texture_edge_clamp.py,sha256=ufa9dDMMl_qIThTntgl5ItTnAr7KduOTjbnwkh4gIY0,1827 +OpenGL/GL/SGIS/texture_filter4.py,sha256=rTFbHSR3dWVi6kTnhjAxOfJhyXGlrwgQYlOygulfeJU,1414 +OpenGL/GL/SGIS/texture_lod.py,sha256=f40Eiem1KKNnsXwe1NjgTJgz1CBoo6SoFj5S7i7VurM,1977 +OpenGL/GL/SGIS/texture_select.py,sha256=RE441GP2ZgsmNR0e7NOYi_RtSwItQxRLNduw6u23c_Q,1682 +OpenGL/GL/SGIX/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/GL/SGIX/__pycache__/__init__.cpython-312.pyc,, +OpenGL/GL/SGIX/__pycache__/async_.cpython-312.pyc,, +OpenGL/GL/SGIX/__pycache__/async_histogram.cpython-312.pyc,, +OpenGL/GL/SGIX/__pycache__/async_pixel.cpython-312.pyc,, +OpenGL/GL/SGIX/__pycache__/blend_alpha_minmax.cpython-312.pyc,, +OpenGL/GL/SGIX/__pycache__/calligraphic_fragment.cpython-312.pyc,, +OpenGL/GL/SGIX/__pycache__/clipmap.cpython-312.pyc,, +OpenGL/GL/SGIX/__pycache__/convolution_accuracy.cpython-312.pyc,, +OpenGL/GL/SGIX/__pycache__/depth_pass_instrument.cpython-312.pyc,, +OpenGL/GL/SGIX/__pycache__/depth_texture.cpython-312.pyc,, +OpenGL/GL/SGIX/__pycache__/flush_raster.cpython-312.pyc,, +OpenGL/GL/SGIX/__pycache__/fog_offset.cpython-312.pyc,, +OpenGL/GL/SGIX/__pycache__/fragment_lighting.cpython-312.pyc,, +OpenGL/GL/SGIX/__pycache__/framezoom.cpython-312.pyc,, +OpenGL/GL/SGIX/__pycache__/igloo_interface.cpython-312.pyc,, +OpenGL/GL/SGIX/__pycache__/instruments.cpython-312.pyc,, +OpenGL/GL/SGIX/__pycache__/interlace.cpython-312.pyc,, +OpenGL/GL/SGIX/__pycache__/ir_instrument1.cpython-312.pyc,, +OpenGL/GL/SGIX/__pycache__/list_priority.cpython-312.pyc,, +OpenGL/GL/SGIX/__pycache__/pixel_texture.cpython-312.pyc,, +OpenGL/GL/SGIX/__pycache__/pixel_tiles.cpython-312.pyc,, +OpenGL/GL/SGIX/__pycache__/polynomial_ffd.cpython-312.pyc,, +OpenGL/GL/SGIX/__pycache__/reference_plane.cpython-312.pyc,, +OpenGL/GL/SGIX/__pycache__/resample.cpython-312.pyc,, +OpenGL/GL/SGIX/__pycache__/scalebias_hint.cpython-312.pyc,, +OpenGL/GL/SGIX/__pycache__/shadow.cpython-312.pyc,, +OpenGL/GL/SGIX/__pycache__/shadow_ambient.cpython-312.pyc,, +OpenGL/GL/SGIX/__pycache__/sprite.cpython-312.pyc,, +OpenGL/GL/SGIX/__pycache__/subsample.cpython-312.pyc,, +OpenGL/GL/SGIX/__pycache__/tag_sample_buffer.cpython-312.pyc,, +OpenGL/GL/SGIX/__pycache__/texture_add_env.cpython-312.pyc,, +OpenGL/GL/SGIX/__pycache__/texture_coordinate_clamp.cpython-312.pyc,, +OpenGL/GL/SGIX/__pycache__/texture_lod_bias.cpython-312.pyc,, +OpenGL/GL/SGIX/__pycache__/texture_multi_buffer.cpython-312.pyc,, +OpenGL/GL/SGIX/__pycache__/texture_scale_bias.cpython-312.pyc,, +OpenGL/GL/SGIX/__pycache__/vertex_preclip.cpython-312.pyc,, +OpenGL/GL/SGIX/__pycache__/ycrcb.cpython-312.pyc,, +OpenGL/GL/SGIX/__pycache__/ycrcb_subsample.cpython-312.pyc,, +OpenGL/GL/SGIX/__pycache__/ycrcba.cpython-312.pyc,, +OpenGL/GL/SGIX/async_.py,sha256=RQel0Bca1nBHBUnO3QiWqeh0szLYMt6MnMfVQRr-Sk4,3069 +OpenGL/GL/SGIX/async_histogram.py,sha256=XkSstoxB9vIESUaUJJOpRiW7oJ5zBqAmpZf-a7AZxxw,1037 +OpenGL/GL/SGIX/async_pixel.py,sha256=abjUZ0x5VuSGPM6R72BiLzqYTrq37NJIqPLY8neWUWk,1323 +OpenGL/GL/SGIX/blend_alpha_minmax.py,sha256=JkvNMwi8tGp3vCNnbBUFti45DZiTHMXLl0YWhcCzrUg,1210 +OpenGL/GL/SGIX/calligraphic_fragment.py,sha256=5YjpSjPASaERg6qIdKyVedPd1gh0--I2FHgr6HglHXE,1231 +OpenGL/GL/SGIX/clipmap.py,sha256=Vt720DAWcxdVNQT9qq0dRN_hLBgqW0zt-vtcWjiX4OY,1059 +OpenGL/GL/SGIX/convolution_accuracy.py,sha256=h5HVwHcIl2IZ-AlYOUs_-42QkjrdJ192XIebM02IMUE,939 +OpenGL/GL/SGIX/depth_pass_instrument.py,sha256=A9gj5ag001u9KEY7Jnmi9NbLzepnqXNs-ow3tzdVPFM,1577 +OpenGL/GL/SGIX/depth_texture.py,sha256=a4kK_ef2jZLbHQSSLB_BONOzoFnsHHkx1effK5wkzKY,1294 +OpenGL/GL/SGIX/flush_raster.py,sha256=6cGLircTYlxkys7iLNJq8gib0pkqNu5bzjH8xPvLGtw,1414 +OpenGL/GL/SGIX/fog_offset.py,sha256=NOYY61IiO3gJkk8zCBXjYq_2C2Q5GQln1AsqEGQiNeY,1586 +OpenGL/GL/SGIX/fragment_lighting.py,sha256=6gfKTP1DdIvWSIE0RbFy2XGEwexXeog3jN4xtgJtHtg,2493 +OpenGL/GL/SGIX/framezoom.py,sha256=8migKjt6leHeWSYOHXoHNoHWKgQtv3WMtOyKweaXDCI,1821 +OpenGL/GL/SGIX/igloo_interface.py,sha256=ymOgc2OEosokaPFNBDGzYN0a0LmzdYGDIfp5nFQMkXs,1132 +OpenGL/GL/SGIX/instruments.py,sha256=daAykZkOlmQpnHFNCQOvzlSHfUI5TfIGP2cb4qUmBCc,2628 +OpenGL/GL/SGIX/interlace.py,sha256=wIJsJzx2YNY2CuKBWZpwk8_HDiMoeYM5_-m0-_yut-8,1230 +OpenGL/GL/SGIX/ir_instrument1.py,sha256=uKwm3K8Wwo-k97b8VNNbih8bOBKVREJE-IbR5gwbCJQ,789 +OpenGL/GL/SGIX/list_priority.py,sha256=E-TJNB8qt6mSVP8mIyF8sZKINiAm8sXJoJM9qqMHDu8,1662 +OpenGL/GL/SGIX/pixel_texture.py,sha256=J00gSsYkTZW8Xukjy9bbUTJjZuhk23-gd3onIyKxxLE,1190 +OpenGL/GL/SGIX/pixel_tiles.py,sha256=q4pfseOFtAv7BgTKFMA1YYSIqCAVfQn10nVAD-lvb2E,2532 +OpenGL/GL/SGIX/polynomial_ffd.py,sha256=vDEjiXFIfcMx81W4efGqUJSCe7pjvgRJqGH0tDSvah0,1876 +OpenGL/GL/SGIX/reference_plane.py,sha256=Iz45ccNP0Xy0rVjkp1tOXZxHQKeUb7mZamsXnkbaO4Q,2042 +OpenGL/GL/SGIX/resample.py,sha256=aJYXnBNBsb5wimgQZ8gc9D3uGj5ygYpbviC4SFu_jpE,1494 +OpenGL/GL/SGIX/scalebias_hint.py,sha256=JHKwfLTJf5vTikU1og2fhtV7ZEulnBUFD-pf5Qxfweg,1036 +OpenGL/GL/SGIX/shadow.py,sha256=OqxF0lnK8M_9Xd2IoiQArCMg_teXlgRnqFlFDPts-EA,1051 +OpenGL/GL/SGIX/shadow_ambient.py,sha256=rNiCV2Txc0KPzZTQRMNEUniYxFOsEKmaVzwTKWtlDjk,1198 +OpenGL/GL/SGIX/sprite.py,sha256=Hl8kt7mr-Jw4--w_uCBDLKNHPfhAIfPX1nc5tx46t8w,3385 +OpenGL/GL/SGIX/subsample.py,sha256=sZ_HYD6iDURvT7GThBLB3AwKmD2DVQUlQa75eyncKjQ,2089 +OpenGL/GL/SGIX/tag_sample_buffer.py,sha256=sI1A1JJY6nPWGxP724Huy8KyQK4IuH9Jz07aCJAGAEg,1112 +OpenGL/GL/SGIX/texture_add_env.py,sha256=wlEmwzftWcNRjoRLryxnobKvLc4i0yCump_jC8UTC4k,1093 +OpenGL/GL/SGIX/texture_coordinate_clamp.py,sha256=za3nVLQNVxQFUIKXycz8-xtl6NOzWvlCXStRXSmUcjc,1196 +OpenGL/GL/SGIX/texture_lod_bias.py,sha256=eMmUyXlOYe3FBhmMjXjXeuJpqrWIOUEU-fiqh7AiU3s,1941 +OpenGL/GL/SGIX/texture_multi_buffer.py,sha256=Q3jcZU3Xu7om-iXBM2h-iKbRRa6BjaXbMtw0BIOELys,2289 +OpenGL/GL/SGIX/texture_scale_bias.py,sha256=EW0oIDV3mNxueh4E5mej6j0j4ObRicjWjGjPRG1J880,1462 +OpenGL/GL/SGIX/vertex_preclip.py,sha256=l4eTY-HkXqYtaenUdXRZ0mcngRr8cWooKdwYtJKFg9A,1483 +OpenGL/GL/SGIX/ycrcb.py,sha256=APV2-b9ND842ykBjWYqxj09IaDUiNsarY2WOq0jfVEo,2144 +OpenGL/GL/SGIX/ycrcb_subsample.py,sha256=bmH-eF4TgjOChab-WCqSwwdpeEmORPcmaoqkf__AEbM,853 +OpenGL/GL/SGIX/ycrcba.py,sha256=eikQwwXANo2ueM7ZqOCkauNg_1kQKUxwHvbcgc8xP2A,1823 +OpenGL/GL/SUN/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/GL/SUN/__pycache__/__init__.cpython-312.pyc,, +OpenGL/GL/SUN/__pycache__/convolution_border_modes.cpython-312.pyc,, +OpenGL/GL/SUN/__pycache__/global_alpha.cpython-312.pyc,, +OpenGL/GL/SUN/__pycache__/mesh_array.cpython-312.pyc,, +OpenGL/GL/SUN/__pycache__/slice_accum.cpython-312.pyc,, +OpenGL/GL/SUN/__pycache__/triangle_list.cpython-312.pyc,, +OpenGL/GL/SUN/__pycache__/vertex.cpython-312.pyc,, +OpenGL/GL/SUN/convolution_border_modes.py,sha256=hLmiBwIfcsZvtQ4Vf9pCHUvT1dnlIOXzr2yopKfvX2M,930 +OpenGL/GL/SUN/global_alpha.py,sha256=4k8nd39AA18AakVAxueWdMruJ1O5BsAhws7JSDhBxhg,1991 +OpenGL/GL/SUN/mesh_array.py,sha256=GCEF-fb-rAs1WPUeZZEfGgshxl-lvG38WP5nJjUYM4Y,1124 +OpenGL/GL/SUN/slice_accum.py,sha256=X8kONd80CzWKvUdcFKpiGi7Hs_b_qmzRWcwOqB2OLig,997 +OpenGL/GL/SUN/triangle_list.py,sha256=0jGei_hudtRPxMBE5lQ2eXEXLXPw5QoIw2LilrucSYE,3603 +OpenGL/GL/SUN/vertex.py,sha256=VfylSw8hY-5SISLdmH2Nf1qnLAuzoazUDAYcK3eNUCA,4598 +OpenGL/GL/SUNX/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/GL/SUNX/__pycache__/__init__.cpython-312.pyc,, +OpenGL/GL/SUNX/__pycache__/constant_data.cpython-312.pyc,, +OpenGL/GL/SUNX/constant_data.py,sha256=JFT4Y-q8PIGYoTDwQ2v6iMpqWKHVPp9WpWRU0qk5y0s,1094 +OpenGL/GL/VERSION/GL_1_0.py,sha256=a-UPEe4X92hgDW7uOfdoB7XaHknMvwquKFSfd82A4m8,14357 +OpenGL/GL/VERSION/GL_1_1.py,sha256=nldnBOBJPWho58DDlvNlSnbqvjYwVy0F1FvRUw-gKHM,3918 +OpenGL/GL/VERSION/GL_1_2.py,sha256=QCWbrsqSxz-MVUi2sf3xqyVdEQoYumOeafuZ37AWpqQ,1786 +OpenGL/GL/VERSION/GL_1_2_images.py,sha256=1JXPQKKGU14idqGblwpQgReeBawWOIvSwVZD6oYCf_w,1587 +OpenGL/GL/VERSION/GL_1_3.py,sha256=n8eLOePXdbhr_HKAnUJL7oOK7yy_MlCY4rVZqGGmyms,4874 +OpenGL/GL/VERSION/GL_1_4.py,sha256=nG8AUoqPPveK0jijEFC3Qg1Gr9SyyIVF4AGB-J9oYPg,3868 +OpenGL/GL/VERSION/GL_1_5.py,sha256=2X5TSlXj-2nIUL2Ww3WGbIjenPPoAdHpnLjmoNEOI8M,5848 +OpenGL/GL/VERSION/GL_2_0.py,sha256=cUQJwdRddh7bVppjyJiqTr-80sup-mkW9lKjH2n7OwM,17573 +OpenGL/GL/VERSION/GL_2_1.py,sha256=PKBQN-pQaJ2dB3Z8EUD3eobfEojQC_1X638WRCcL6O8,1728 +OpenGL/GL/VERSION/GL_3_0.py,sha256=-4X7OlqohTdAUwe_5qwyxcQk5aGhgnHL6Y4nwfQUC5U,6327 +OpenGL/GL/VERSION/GL_3_1.py,sha256=MTiBieKnzc6wCppTcxwjO6P0IYHmNPmWuaLvOcETLwk,2286 +OpenGL/GL/VERSION/GL_3_2.py,sha256=93TRxZ5imvdK_9NOQdsqM8V9NRWdwHgLTFEK1-P4c-k,2532 +OpenGL/GL/VERSION/GL_3_3.py,sha256=am1e1n4ARoSslRk80Ryhuwn4TyOJHl7FcsBEwyPtxlE,4291 +OpenGL/GL/VERSION/GL_4_0.py,sha256=95Llkq79_J8ZBj6p_l0fWrTtl_eL4nXDd3b20W2LL7c,4429 +OpenGL/GL/VERSION/GL_4_1.py,sha256=knP7f7neZEuJa4NbIdbcBdmf96z_3hy-XjLRQflRV8g,10176 +OpenGL/GL/VERSION/GL_4_2.py,sha256=wNtJ4UYGtusZpT9ArcmgH2eloY-mCnd_0n_fHsQGf60,2058 +OpenGL/GL/VERSION/GL_4_3.py,sha256=4SunWdoY509IjPTFA6aFEgRk3tFr0A44sgykxB0Dbd8,6422 +OpenGL/GL/VERSION/GL_4_4.py,sha256=NSuBdIG2nL51Gzod7eqY-slcq6CTdoHg4A5wbuTOHVA,2579 +OpenGL/GL/VERSION/GL_4_5.py,sha256=_rnPUkTnvoouARws4MC-sNRSpFnZiU4p72N1aQGerXg,3430 +OpenGL/GL/VERSION/GL_4_6.py,sha256=cnRwfx1EQSXcAd6UE-cqnTgKpJvmqfIwJXl_Q2JbpkY,731 +OpenGL/GL/VERSION/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +OpenGL/GL/VERSION/__pycache__/GL_1_0.cpython-312.pyc,, +OpenGL/GL/VERSION/__pycache__/GL_1_1.cpython-312.pyc,, +OpenGL/GL/VERSION/__pycache__/GL_1_2.cpython-312.pyc,, +OpenGL/GL/VERSION/__pycache__/GL_1_2_images.cpython-312.pyc,, +OpenGL/GL/VERSION/__pycache__/GL_1_3.cpython-312.pyc,, +OpenGL/GL/VERSION/__pycache__/GL_1_4.cpython-312.pyc,, +OpenGL/GL/VERSION/__pycache__/GL_1_5.cpython-312.pyc,, +OpenGL/GL/VERSION/__pycache__/GL_2_0.cpython-312.pyc,, +OpenGL/GL/VERSION/__pycache__/GL_2_1.cpython-312.pyc,, +OpenGL/GL/VERSION/__pycache__/GL_3_0.cpython-312.pyc,, +OpenGL/GL/VERSION/__pycache__/GL_3_1.cpython-312.pyc,, +OpenGL/GL/VERSION/__pycache__/GL_3_2.cpython-312.pyc,, +OpenGL/GL/VERSION/__pycache__/GL_3_3.cpython-312.pyc,, +OpenGL/GL/VERSION/__pycache__/GL_4_0.cpython-312.pyc,, +OpenGL/GL/VERSION/__pycache__/GL_4_1.cpython-312.pyc,, +OpenGL/GL/VERSION/__pycache__/GL_4_2.cpython-312.pyc,, +OpenGL/GL/VERSION/__pycache__/GL_4_3.cpython-312.pyc,, +OpenGL/GL/VERSION/__pycache__/GL_4_4.cpython-312.pyc,, +OpenGL/GL/VERSION/__pycache__/GL_4_5.cpython-312.pyc,, +OpenGL/GL/VERSION/__pycache__/GL_4_6.cpython-312.pyc,, +OpenGL/GL/VERSION/__pycache__/__init__.cpython-312.pyc,, +OpenGL/GL/VIV/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/GL/VIV/__pycache__/__init__.cpython-312.pyc,, +OpenGL/GL/WIN/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/GL/WIN/__pycache__/__init__.cpython-312.pyc,, +OpenGL/GL/WIN/__pycache__/phong_shading.cpython-312.pyc,, +OpenGL/GL/WIN/__pycache__/specular_fog.cpython-312.pyc,, +OpenGL/GL/WIN/phong_shading.py,sha256=YEwZIQcWtQAswRGQ4RbFccLPVTs5sX_5noNA9l6Qr94,1425 +OpenGL/GL/WIN/specular_fog.py,sha256=dF1LNjui5IAPzUaAK0qaBuztA2Lei4lCMeEeuceo3x4,2143 +OpenGL/GL/__init__.py,sha256=gwKKMGq16fJbijAYt5Ir6wATYS3qN6r96qy2WHWPFJ0,1497 +OpenGL/GL/__pycache__/__init__.cpython-312.pyc,, +OpenGL/GL/__pycache__/exceptional.cpython-312.pyc,, +OpenGL/GL/__pycache__/feedback.cpython-312.pyc,, +OpenGL/GL/__pycache__/framebufferobjects.cpython-312.pyc,, +OpenGL/GL/__pycache__/glget.cpython-312.pyc,, +OpenGL/GL/__pycache__/images.cpython-312.pyc,, +OpenGL/GL/__pycache__/pointers.cpython-312.pyc,, +OpenGL/GL/__pycache__/selection.cpython-312.pyc,, +OpenGL/GL/__pycache__/shaders.cpython-312.pyc,, +OpenGL/GL/__pycache__/vboimplementation.cpython-312.pyc,, +OpenGL/GL/exceptional.py,sha256=EExKkgIqcL3T1OmO60PKa4-opk0fIajM2c32G_vZCWc,8506 +OpenGL/GL/feedback.py,sha256=FzZbBc-yGlBgjgsRKGr6R40k-NhTT-coZkk3RiEbY3M,3420 +OpenGL/GL/framebufferobjects.py,sha256=8-Ofxo36OVYMQ03DnFDBISUJtvPDkUP0ilceTcCq17I,2976 +OpenGL/GL/glget.py,sha256=hFCtVLoKgUWFzI1SZgt2hoYf4cJhgciF_xnNuYLsgk4,710 +OpenGL/GL/images.py,sha256=RIzc_0f_yU1-81LRdYG9LyPYidA3n9-VyZLwSGkrt-8,21467 +OpenGL/GL/pointers.py,sha256=DJg6_W7mIXjG5rYcHCvoSQlSQQ6dQuiNzCckUfy6wys,14280 +OpenGL/GL/selection.py,sha256=w2OqYCgxKfKdkq4wQ90mLQfWExWHaHv2X0O-VRB6oY4,2383 +OpenGL/GL/shaders.py,sha256=K1tXJ99FgXEcYOjplnXFeP3Fl3wezV0fqiwoJGMQj9U,8987 +OpenGL/GL/vboimplementation.py,sha256=0CCvloUQKL_CHLiR-cmuPWuSBEoKj9DJNu0a77NrwMU,694 +OpenGL/GLE/__init__.py,sha256=Uw-bs-u9NakCC_k3JmbbMGD-5_HOzivpRJyfYRP5xhE,174 +OpenGL/GLE/__pycache__/__init__.cpython-312.pyc,, +OpenGL/GLE/__pycache__/exceptional.cpython-312.pyc,, +OpenGL/GLE/exceptional.py,sha256=01NZTbmcmUJMI3a4DqNvFDwRuTQbYQfY2xiso45aKaY,1683 +OpenGL/GLES1/AMD/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/GLES1/AMD/__pycache__/__init__.cpython-312.pyc,, +OpenGL/GLES1/AMD/__pycache__/compressed_3DC_texture.cpython-312.pyc,, +OpenGL/GLES1/AMD/__pycache__/compressed_ATC_texture.cpython-312.pyc,, +OpenGL/GLES1/AMD/compressed_3DC_texture.py,sha256=rwT2ltS3DKPZGEbc1fhm2uNu2fqLYh9QWkaOK-oh8yk,3503 +OpenGL/GLES1/AMD/compressed_ATC_texture.py,sha256=ZFHopNx4aR9IuN3j3uAxtouqnEQfG62BR9B82oqw1Kw,1312 +OpenGL/GLES1/APPLE/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/GLES1/APPLE/__pycache__/__init__.cpython-312.pyc,, +OpenGL/GLES1/APPLE/__pycache__/copy_texture_levels.cpython-312.pyc,, +OpenGL/GLES1/APPLE/__pycache__/framebuffer_multisample.cpython-312.pyc,, +OpenGL/GLES1/APPLE/__pycache__/sync.cpython-312.pyc,, +OpenGL/GLES1/APPLE/__pycache__/texture_2D_limited_npot.cpython-312.pyc,, +OpenGL/GLES1/APPLE/__pycache__/texture_format_BGRA8888.cpython-312.pyc,, +OpenGL/GLES1/APPLE/__pycache__/texture_max_level.cpython-312.pyc,, +OpenGL/GLES1/APPLE/copy_texture_levels.py,sha256=XmcbN86ghzDRSNIH_5EvUKHuNIpib0nnry5F7XH-iZI,2383 +OpenGL/GLES1/APPLE/framebuffer_multisample.py,sha256=A_b_RCLUv5UVLD1k4_50M90iu-t0Afz9qeSr-QD6pjg,2111 +OpenGL/GLES1/APPLE/sync.py,sha256=uTudouAuA6ymdBzqbaILhpwUE18xXx-pzaPa0rwhjhc,1957 +OpenGL/GLES1/APPLE/texture_2D_limited_npot.py,sha256=S1DheS0DATqfVp7wUpbzowR-sBiiO1gikMHv_ch7n5g,1811 +OpenGL/GLES1/APPLE/texture_format_BGRA8888.py,sha256=Y2Xh3_FlxbmrDgQg7fk1Y4LiwuulR8DN1u6O2GQdGco,1052 +OpenGL/GLES1/APPLE/texture_max_level.py,sha256=0TJ_QC1KxZjSd5_d8PHdOge4CQ9FoUeGgkDQJUaRFxs,1080 +OpenGL/GLES1/ARM/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/GLES1/ARM/__pycache__/__init__.cpython-312.pyc,, +OpenGL/GLES1/ARM/__pycache__/rgba8.cpython-312.pyc,, +OpenGL/GLES1/ARM/rgba8.py,sha256=LbJ20dCzYcLNUxOYFoSX8VPmwfKfpwJa-NzefbnokYY,862 +OpenGL/GLES1/EXT/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/GLES1/EXT/__pycache__/__init__.cpython-312.pyc,, +OpenGL/GLES1/EXT/__pycache__/blend_minmax.cpython-312.pyc,, +OpenGL/GLES1/EXT/__pycache__/debug_marker.cpython-312.pyc,, +OpenGL/GLES1/EXT/__pycache__/discard_framebuffer.cpython-312.pyc,, +OpenGL/GLES1/EXT/__pycache__/map_buffer_range.cpython-312.pyc,, +OpenGL/GLES1/EXT/__pycache__/multi_draw_arrays.cpython-312.pyc,, +OpenGL/GLES1/EXT/__pycache__/multisampled_render_to_texture.cpython-312.pyc,, +OpenGL/GLES1/EXT/__pycache__/read_format_bgra.cpython-312.pyc,, +OpenGL/GLES1/EXT/__pycache__/robustness.cpython-312.pyc,, +OpenGL/GLES1/EXT/__pycache__/sRGB.cpython-312.pyc,, +OpenGL/GLES1/EXT/__pycache__/texture_compression_dxt1.cpython-312.pyc,, +OpenGL/GLES1/EXT/__pycache__/texture_filter_anisotropic.cpython-312.pyc,, +OpenGL/GLES1/EXT/__pycache__/texture_format_BGRA8888.cpython-312.pyc,, +OpenGL/GLES1/EXT/__pycache__/texture_lod_bias.cpython-312.pyc,, +OpenGL/GLES1/EXT/__pycache__/texture_storage.cpython-312.pyc,, +OpenGL/GLES1/EXT/blend_minmax.py,sha256=R_bEQ_DDDNRNwvEe3FMqHC7RJAV2eIDc9Q6ko6O23DE,1277 +OpenGL/GLES1/EXT/debug_marker.py,sha256=VNN1PvmmLNgngb0A0GgBm8riHw5wJpRIaZjAaVfqeac,1416 +OpenGL/GLES1/EXT/discard_framebuffer.py,sha256=ynhagYsIXqN1Jyq_C1ZZ4JkDs4diIGZYcGktoaS5G_I,2489 +OpenGL/GLES1/EXT/map_buffer_range.py,sha256=mU6vgR51ufYvParxsQOO269-zxLfn1xpz7bDUHZm2SU,2017 +OpenGL/GLES1/EXT/multi_draw_arrays.py,sha256=VeXVxcn7bHQDYx8jm9CMLeh4kEv3-vWk0YIeQym0H5E,1684 +OpenGL/GLES1/EXT/multisampled_render_to_texture.py,sha256=TClg7a4CUTy-_NZR8FFD2pk8Lf8mTgqm8Kin8XdCwZA,2157 +OpenGL/GLES1/EXT/read_format_bgra.py,sha256=ZWVvATGPzdwBwD-edGJ39SgVO6mfKpevl0bcTrmylQM,1888 +OpenGL/GLES1/EXT/robustness.py,sha256=srC34Wp0tlQhjZJgxO6do5SEL0YyHaBBScT8qe9IOmE,4054 +OpenGL/GLES1/EXT/sRGB.py,sha256=75_-uRKxpgqZuFX_5zUeEOwSu9NfOYf6Vzf-b71ClBs,2161 +OpenGL/GLES1/EXT/texture_compression_dxt1.py,sha256=LGYkabN8UH8Jn7ucnUPhPTkt8jPuZc9A00k3EZR8JUM,2415 +OpenGL/GLES1/EXT/texture_filter_anisotropic.py,sha256=NOWMeNiuWVlsK61-5908p2WgWsCT7Dx_WbniV_fqWKY,2905 +OpenGL/GLES1/EXT/texture_format_BGRA8888.py,sha256=mUbdCffH9oaXT4a8UFOymlEz3VtHIxtMhKFLRA7sDnQ,2554 +OpenGL/GLES1/EXT/texture_lod_bias.py,sha256=j6PpzooxYb6ZYWP2EUb4hYWA6kN7KTpM2fhVlCuPrgk,1599 +OpenGL/GLES1/EXT/texture_storage.py,sha256=Ex0Xe3vZ13HFV7UqZ4ROE3kKPoOItMMkil99BLJS6ok,1829 +OpenGL/GLES1/IMG/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/GLES1/IMG/__pycache__/__init__.cpython-312.pyc,, +OpenGL/GLES1/IMG/__pycache__/multisampled_render_to_texture.cpython-312.pyc,, +OpenGL/GLES1/IMG/__pycache__/read_format.cpython-312.pyc,, +OpenGL/GLES1/IMG/__pycache__/texture_compression_pvrtc.cpython-312.pyc,, +OpenGL/GLES1/IMG/__pycache__/texture_env_enhanced_fixed_function.cpython-312.pyc,, +OpenGL/GLES1/IMG/__pycache__/user_clip_plane.cpython-312.pyc,, +OpenGL/GLES1/IMG/multisampled_render_to_texture.py,sha256=bAQ_gSEqb5JnUnlziNWgUX940MCYylVirBH_fcSu1XY,2176 +OpenGL/GLES1/IMG/read_format.py,sha256=oB01xTi0Z5zN2yeaimH9QVWU9WNqtuHw5OHkJ0VqOpI,1795 +OpenGL/GLES1/IMG/texture_compression_pvrtc.py,sha256=g-hyqM1-CJfuXrj71RENR_2QIBjOiCeF-WybN1LkhvQ,1402 +OpenGL/GLES1/IMG/texture_env_enhanced_fixed_function.py,sha256=-ydxB4Yb1viGzbptZf4-v8BInQj-AXTWnYKoJkoGFgw,1388 +OpenGL/GLES1/IMG/user_clip_plane.py,sha256=vdftr7bNhuXz9Mgxs3z6kNd5Eg9WqLE19fWfmK90UHw,1131 +OpenGL/GLES1/KHR/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/GLES1/KHR/__pycache__/__init__.cpython-312.pyc,, +OpenGL/GLES1/KHR/__pycache__/debug.cpython-312.pyc,, +OpenGL/GLES1/KHR/debug.py,sha256=fzrFXjf9OLe_M1iw5kKYh6gBehsW1OGAY2OH2ZOjiK4,9497 +OpenGL/GLES1/NV/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/GLES1/NV/__pycache__/__init__.cpython-312.pyc,, +OpenGL/GLES1/NV/__pycache__/fence.cpython-312.pyc,, +OpenGL/GLES1/NV/fence.py,sha256=Ltm_fwNWVh7fKN0MEnbBs6FozkXnCboTaPwYQu8Q3Nk,2769 +OpenGL/GLES1/OES/EGL_image.py,sha256=rGm2izJBxY8-gujPycG_Ml1jJBXAtPWFgqBeIujN2c8,1535 +OpenGL/GLES1/OES/EGL_image_external.py,sha256=G4_Y93SginW98YRa0oHXLE6YEDtQnm4YICTIufK0-tg,1611 +OpenGL/GLES1/OES/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/GLES1/OES/__pycache__/EGL_image.cpython-312.pyc,, +OpenGL/GLES1/OES/__pycache__/EGL_image_external.cpython-312.pyc,, +OpenGL/GLES1/OES/__pycache__/__init__.cpython-312.pyc,, +OpenGL/GLES1/OES/__pycache__/blend_equation_separate.cpython-312.pyc,, +OpenGL/GLES1/OES/__pycache__/blend_func_separate.cpython-312.pyc,, +OpenGL/GLES1/OES/__pycache__/blend_subtract.cpython-312.pyc,, +OpenGL/GLES1/OES/__pycache__/byte_coordinates.cpython-312.pyc,, +OpenGL/GLES1/OES/__pycache__/compressed_ETC1_RGB8_sub_texture.cpython-312.pyc,, +OpenGL/GLES1/OES/__pycache__/compressed_ETC1_RGB8_texture.cpython-312.pyc,, +OpenGL/GLES1/OES/__pycache__/compressed_paletted_texture.cpython-312.pyc,, +OpenGL/GLES1/OES/__pycache__/depth24.cpython-312.pyc,, +OpenGL/GLES1/OES/__pycache__/depth32.cpython-312.pyc,, +OpenGL/GLES1/OES/__pycache__/draw_texture.cpython-312.pyc,, +OpenGL/GLES1/OES/__pycache__/element_index_uint.cpython-312.pyc,, +OpenGL/GLES1/OES/__pycache__/extended_matrix_palette.cpython-312.pyc,, +OpenGL/GLES1/OES/__pycache__/fbo_render_mipmap.cpython-312.pyc,, +OpenGL/GLES1/OES/__pycache__/fixed_point.cpython-312.pyc,, +OpenGL/GLES1/OES/__pycache__/framebuffer_object.cpython-312.pyc,, +OpenGL/GLES1/OES/__pycache__/mapbuffer.cpython-312.pyc,, +OpenGL/GLES1/OES/__pycache__/matrix_get.cpython-312.pyc,, +OpenGL/GLES1/OES/__pycache__/matrix_palette.cpython-312.pyc,, +OpenGL/GLES1/OES/__pycache__/packed_depth_stencil.cpython-312.pyc,, +OpenGL/GLES1/OES/__pycache__/point_size_array.cpython-312.pyc,, +OpenGL/GLES1/OES/__pycache__/point_sprite.cpython-312.pyc,, +OpenGL/GLES1/OES/__pycache__/query_matrix.cpython-312.pyc,, +OpenGL/GLES1/OES/__pycache__/read_format.cpython-312.pyc,, +OpenGL/GLES1/OES/__pycache__/required_internalformat.cpython-312.pyc,, +OpenGL/GLES1/OES/__pycache__/rgb8_rgba8.cpython-312.pyc,, +OpenGL/GLES1/OES/__pycache__/single_precision.cpython-312.pyc,, +OpenGL/GLES1/OES/__pycache__/stencil1.cpython-312.pyc,, +OpenGL/GLES1/OES/__pycache__/stencil4.cpython-312.pyc,, +OpenGL/GLES1/OES/__pycache__/stencil8.cpython-312.pyc,, +OpenGL/GLES1/OES/__pycache__/stencil_wrap.cpython-312.pyc,, +OpenGL/GLES1/OES/__pycache__/surfaceless_context.cpython-312.pyc,, +OpenGL/GLES1/OES/__pycache__/texture_cube_map.cpython-312.pyc,, +OpenGL/GLES1/OES/__pycache__/texture_env_crossbar.cpython-312.pyc,, +OpenGL/GLES1/OES/__pycache__/texture_mirrored_repeat.cpython-312.pyc,, +OpenGL/GLES1/OES/__pycache__/texture_npot.cpython-312.pyc,, +OpenGL/GLES1/OES/__pycache__/vertex_array_object.cpython-312.pyc,, +OpenGL/GLES1/OES/blend_equation_separate.py,sha256=kQzAXwUapF_hy4QeobSKarwuC_jvmxOqSwfZA6Fyk20,1081 +OpenGL/GLES1/OES/blend_func_separate.py,sha256=dhMVYm_NF79UcF5Bp8bi8XAUBSTlwGUIfRlRPbw2maM,1107 +OpenGL/GLES1/OES/blend_subtract.py,sha256=C_-3gRI5A7trbbKJ8nuqA_7blLgOoSiCLmIEvHnfmSI,1366 +OpenGL/GLES1/OES/byte_coordinates.py,sha256=9teECW6QgbOJ_8vD_U0wVjvNe_Sn1KiY075WgKpfitw,2062 +OpenGL/GLES1/OES/compressed_ETC1_RGB8_sub_texture.py,sha256=ecRs3plxw-c1zR_wjYKsyJB5gTYYM9J0Qt20a1Bq2h8,873 +OpenGL/GLES1/OES/compressed_ETC1_RGB8_texture.py,sha256=KOQpArcvhXnL8Ft69vD1BspConXvkV4dpXR9TDtU_IE,1256 +OpenGL/GLES1/OES/compressed_paletted_texture.py,sha256=2I8cdNdjK4lFfhn69jz1TyjJurYU9_yvwSWrohsOKB8,2374 +OpenGL/GLES1/OES/depth24.py,sha256=6D42LKgxhynPbyXU3xRqiKjzA_EANUrvleokRg_K4BE,845 +OpenGL/GLES1/OES/depth32.py,sha256=QGSm4zHNIiTZWXRmGQ-Hns5p3oxaoH7C8PTKEmqrQVs,845 +OpenGL/GLES1/OES/draw_texture.py,sha256=gcHno_925nWc1Ycdxij_q6N3xBYFw7DheWyPbaCcRCc,2226 +OpenGL/GLES1/OES/element_index_uint.py,sha256=C0FhV2iJX2_y8eQgH2FpBgGzO4CwcQG989erhu2lRiw,974 +OpenGL/GLES1/OES/extended_matrix_palette.py,sha256=ySGyovd5jHXkIOYxoFPAeKhTfElxlZBRWnKBNtuW8Cs,2511 +OpenGL/GLES1/OES/fbo_render_mipmap.py,sha256=fSJ8QwsyfEwTm5gGdMSrg2qRqHsjLBRUhv6Pj7mZdIs,1223 +OpenGL/GLES1/OES/fixed_point.py,sha256=jdh9njsrThlo-NPJIYDkIgcPK0_p8kPM5PjmGZGUClg,7990 +OpenGL/GLES1/OES/framebuffer_object.py,sha256=K9YTrUCVse4bb9zChFijDnkJNcneFlQ7cd1_JeWqoYY,6684 +OpenGL/GLES1/OES/mapbuffer.py,sha256=PaCekRAogP1__uF0EApbxecYqztPZPZPfOCken_lXwI,970 +OpenGL/GLES1/OES/matrix_get.py,sha256=8bXSMWq6FlRxUf6uT44EOzM7mf8njJ86qmw6fubIH-o,1872 +OpenGL/GLES1/OES/matrix_palette.py,sha256=udRoivt8RSvtETeGElffO0jEEVfwab8aGIikuh7jEig,2317 +OpenGL/GLES1/OES/packed_depth_stencil.py,sha256=Brt_T8Epp7TtGWImNwNBfX1EsbB7lhXBckXGZ_qH_tU,3033 +OpenGL/GLES1/OES/point_size_array.py,sha256=iKrq1OGv_HV8t6-NLStZV6O6kN8Glq4k777t898Z2zQ,1653 +OpenGL/GLES1/OES/point_sprite.py,sha256=l4uPuWp_aSGs86cr_9gOtQ04ALt_AwZ-aaTdLMHvmHU,1719 +OpenGL/GLES1/OES/query_matrix.py,sha256=0Jnt59YLve_bApQotSJ96g8X62HCm070ZnhuxkfOgcs,1537 +OpenGL/GLES1/OES/read_format.py,sha256=lfEQ4-EB49BG1MYddZKxd8ZEeQStX1YjJCocD2yrW_M,1310 +OpenGL/GLES1/OES/required_internalformat.py,sha256=qSweuQV96Kbv4hA0vSruFttiC_DUkoJCR7qr8r06Cl8,3686 +OpenGL/GLES1/OES/rgb8_rgba8.py,sha256=WXIbj8udAJuYJLwrfubC1l_9vxLrLqQuUy7mUaqbs1g,841 +OpenGL/GLES1/OES/single_precision.py,sha256=DRPX25i-WtSWQsv2IiDQnKbSGxBjwmd84TDD2JNUN7E,1317 +OpenGL/GLES1/OES/stencil1.py,sha256=1J6fj6doRx4bht5Hp9vyfDCbdyOHt8TMgM4pUTf_BUw,851 +OpenGL/GLES1/OES/stencil4.py,sha256=Ph2Dr7Zz-O26rryaqpBd-58Oo2mhUA4mL8ovCvkF_MA,851 +OpenGL/GLES1/OES/stencil8.py,sha256=hkfIH79yylpscfBEY4hDgIiLuDqH6lI1p0Y5SsXmM8s,851 +OpenGL/GLES1/OES/stencil_wrap.py,sha256=awpnx5qK08nCz7odbOVXIOkV0KytG_K16P4oTzBVz7U,756 +OpenGL/GLES1/OES/surfaceless_context.py,sha256=LGZjH7HZi52mtKm7cXBQqyHzw3XlCPbL5BWilcG85BQ,1227 +OpenGL/GLES1/OES/texture_cube_map.py,sha256=GDuiguch_DER8xY-ZACQW1cukysZu8gcuBhRIbIhvxc,4434 +OpenGL/GLES1/OES/texture_env_crossbar.py,sha256=eUoLChQ56xxEGumftRpSCKim06ri1W2iK7H0nfQc6vk,1173 +OpenGL/GLES1/OES/texture_mirrored_repeat.py,sha256=kbyMx0kheE_muYYyY96p19no0fxlgxWjyM9Ap6_DQqo,1276 +OpenGL/GLES1/OES/texture_npot.py,sha256=cupRFVoNNt9yS8D0HlMyYEBkedICiZDG_ogRttuCSHg,1482 +OpenGL/GLES1/OES/vertex_array_object.py,sha256=H1_MYTMyG6IOaaPp_KKV5HOiErOHo6ql9q9jYvhxsjA,1553 +OpenGL/GLES1/QCOM/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/GLES1/QCOM/__pycache__/__init__.cpython-312.pyc,, +OpenGL/GLES1/QCOM/__pycache__/driver_control.cpython-312.pyc,, +OpenGL/GLES1/QCOM/__pycache__/extended_get.cpython-312.pyc,, +OpenGL/GLES1/QCOM/__pycache__/extended_get2.cpython-312.pyc,, +OpenGL/GLES1/QCOM/__pycache__/perfmon_global_mode.cpython-312.pyc,, +OpenGL/GLES1/QCOM/__pycache__/tiled_rendering.cpython-312.pyc,, +OpenGL/GLES1/QCOM/__pycache__/writeonly_rendering.cpython-312.pyc,, +OpenGL/GLES1/QCOM/driver_control.py,sha256=Yk8hUDA_eVt_VZTBUZp6HXc_o10IXMkuVSG-D87DI1A,2012 +OpenGL/GLES1/QCOM/extended_get.py,sha256=ZaPD6aisAZyj5fpTXEfmqL3xSGD7EbKbQxJt4A6AfwI,1591 +OpenGL/GLES1/QCOM/extended_get2.py,sha256=WtxVamnrvqDF5tCdTd_aI22iGC2H5JklZ4gCIzwwyHI,1316 +OpenGL/GLES1/QCOM/perfmon_global_mode.py,sha256=fK1xkTkYTtzoTl1bsE5lCgYREer6CsCpFQdlUyh1jyA,803 +OpenGL/GLES1/QCOM/tiled_rendering.py,sha256=KtXJluw2W-gx779VqdO7ewsjtcrhZHPw4URFp-qYEqc,5825 +OpenGL/GLES1/QCOM/writeonly_rendering.py,sha256=Y5fT0PbRYu6dYfSW6Gywlc_T5L2wHokOgSyjvc3kua0,831 +OpenGL/GLES1/VERSION/GLES1_1_0.py,sha256=fgaM8YK-n6dmJXpCc_1Xv3DYZU8D40XOR29T0RZ8W00,8207 +OpenGL/GLES1/VERSION/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/GLES1/VERSION/__pycache__/GLES1_1_0.cpython-312.pyc,, +OpenGL/GLES1/VERSION/__pycache__/__init__.cpython-312.pyc,, +OpenGL/GLES1/__init__.py,sha256=Dst_kYvWjYLUhsNCwRZttPqLDkJfkPvsjw8Ib2tchGw,142 +OpenGL/GLES1/__pycache__/__init__.cpython-312.pyc,, +OpenGL/GLES2/AMD/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/GLES2/AMD/__pycache__/__init__.cpython-312.pyc,, +OpenGL/GLES2/AMD/__pycache__/compressed_3DC_texture.cpython-312.pyc,, +OpenGL/GLES2/AMD/__pycache__/compressed_ATC_texture.cpython-312.pyc,, +OpenGL/GLES2/AMD/__pycache__/framebuffer_multisample_advanced.cpython-312.pyc,, +OpenGL/GLES2/AMD/__pycache__/performance_monitor.cpython-312.pyc,, +OpenGL/GLES2/AMD/__pycache__/program_binary_Z400.cpython-312.pyc,, +OpenGL/GLES2/AMD/compressed_3DC_texture.py,sha256=Q09TXqVag-Dz25oNO1QQIFKavJmyIsZxOmtTmozYafw,3503 +OpenGL/GLES2/AMD/compressed_ATC_texture.py,sha256=rXscxxEkOFkzd3Q3THpvvRktPx0MZaBKXcHgAwcGdA8,1312 +OpenGL/GLES2/AMD/framebuffer_multisample_advanced.py,sha256=rYx8pdgiXTU1rC7Fd2sNSsFgUm-rP7IONKT8cf3dBKQ,1930 +OpenGL/GLES2/AMD/performance_monitor.py,sha256=pRZN-yAi-FJD-P0V7RehTs2HcU_dl1quB2xBoeCf_Xo,3057 +OpenGL/GLES2/AMD/program_binary_Z400.py,sha256=Jlgzj9efCRCsEFDK7DokwNlPGEi0WiaV_dA2KwNUe7Y,1802 +OpenGL/GLES2/ANDROID/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/GLES2/ANDROID/__pycache__/__init__.cpython-312.pyc,, +OpenGL/GLES2/ANDROID/__pycache__/extension_pack_es31a.cpython-312.pyc,, +OpenGL/GLES2/ANDROID/extension_pack_es31a.py,sha256=hz2bw7-SgdNCo8gL4hQPJerK2lF4sT15Cjo2y9dlruE,1540 +OpenGL/GLES2/ANGLE/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/GLES2/ANGLE/__pycache__/__init__.cpython-312.pyc,, +OpenGL/GLES2/ANGLE/__pycache__/depth_texture.cpython-312.pyc,, +OpenGL/GLES2/ANGLE/__pycache__/framebuffer_blit.cpython-312.pyc,, +OpenGL/GLES2/ANGLE/__pycache__/framebuffer_multisample.cpython-312.pyc,, +OpenGL/GLES2/ANGLE/__pycache__/instanced_arrays.cpython-312.pyc,, +OpenGL/GLES2/ANGLE/__pycache__/pack_reverse_row_order.cpython-312.pyc,, +OpenGL/GLES2/ANGLE/__pycache__/program_binary.cpython-312.pyc,, +OpenGL/GLES2/ANGLE/__pycache__/texture_compression_dxt3.cpython-312.pyc,, +OpenGL/GLES2/ANGLE/__pycache__/texture_compression_dxt5.cpython-312.pyc,, +OpenGL/GLES2/ANGLE/__pycache__/texture_usage.cpython-312.pyc,, +OpenGL/GLES2/ANGLE/__pycache__/translated_shader_source.cpython-312.pyc,, +OpenGL/GLES2/ANGLE/depth_texture.py,sha256=IMvyRtgvopSImi00vgdrpykj74xZzlAO3YEkm08ez58,1309 +OpenGL/GLES2/ANGLE/framebuffer_blit.py,sha256=fasPhiQL9svxGF801ar57P55JU_96Es7Ht578oW3ol4,1155 +OpenGL/GLES2/ANGLE/framebuffer_multisample.py,sha256=kAtjFEhSp20TXBDF_meQ6_xugg53zx-EkTNbZTXoGkY,1969 +OpenGL/GLES2/ANGLE/instanced_arrays.py,sha256=ZoAJfsNYiUFNR4ZVK4lPhFI_ikmjjDHXzr3G9HXOniQ,1957 +OpenGL/GLES2/ANGLE/pack_reverse_row_order.py,sha256=LooyDQ8ISiUfxaJ7E-wHFlViOwsRsXqsKvjATflOu20,1544 +OpenGL/GLES2/ANGLE/program_binary.py,sha256=AWStbF3dBL4CBagcg0so_5CNk8G7OUl-u560l78MdoA,960 +OpenGL/GLES2/ANGLE/texture_compression_dxt3.py,sha256=mXOmgU9l7aE1OcH53TVa1nPaNRPT8ZDpiNUpWtDkJJA,839 +OpenGL/GLES2/ANGLE/texture_compression_dxt5.py,sha256=O_k-HxUWC7mCcO8SMdRiulIKJ_z22gkxh87CYlK2epo,839 +OpenGL/GLES2/ANGLE/texture_usage.py,sha256=vKTOv1ca8WINfS4Xk-6Q2j003nt_PAO2RCHvwBGHCso,1529 +OpenGL/GLES2/ANGLE/translated_shader_source.py,sha256=BikEUlWDr5cCctaiRj11ednhbx79b--VDO9XAbUoy84,1412 +OpenGL/GLES2/APPLE/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/GLES2/APPLE/__pycache__/__init__.cpython-312.pyc,, +OpenGL/GLES2/APPLE/__pycache__/clip_distance.cpython-312.pyc,, +OpenGL/GLES2/APPLE/__pycache__/color_buffer_packed_float.cpython-312.pyc,, +OpenGL/GLES2/APPLE/__pycache__/copy_texture_levels.cpython-312.pyc,, +OpenGL/GLES2/APPLE/__pycache__/framebuffer_multisample.cpython-312.pyc,, +OpenGL/GLES2/APPLE/__pycache__/rgb_422.cpython-312.pyc,, +OpenGL/GLES2/APPLE/__pycache__/sync.cpython-312.pyc,, +OpenGL/GLES2/APPLE/__pycache__/texture_format_BGRA8888.cpython-312.pyc,, +OpenGL/GLES2/APPLE/__pycache__/texture_max_level.cpython-312.pyc,, +OpenGL/GLES2/APPLE/__pycache__/texture_packed_float.cpython-312.pyc,, +OpenGL/GLES2/APPLE/clip_distance.py,sha256=oQ4iqk2A8CIlNss_fG69bqKS0WZXvu7WU5gKTNYgFw4,1056 +OpenGL/GLES2/APPLE/color_buffer_packed_float.py,sha256=AGCJY2aW446K_NorHIzx3JfL7cJp9B4C_JTNo6JMyrA,1063 +OpenGL/GLES2/APPLE/copy_texture_levels.py,sha256=UTXtB1qlbWMG2zFlSL7E18JdVsHZoCpEqTWozXMKKns,2383 +OpenGL/GLES2/APPLE/framebuffer_multisample.py,sha256=BN7Qs1D79MpdNFBlOem5Ss2743JPVdl1l6wUavyz7As,2111 +OpenGL/GLES2/APPLE/rgb_422.py,sha256=6P8AF-To4A2eIsAs5X6knxwAg7UwD0a69wORTrm4BdE,2870 +OpenGL/GLES2/APPLE/sync.py,sha256=f_liQrLORLdTK8_jkT15_gGo7bqs8pP5YdqTd7dU5sI,1957 +OpenGL/GLES2/APPLE/texture_format_BGRA8888.py,sha256=feaExfOq3o0-GHO4f3yRFzpAZ4yvlvid9uokczCzM1o,1052 +OpenGL/GLES2/APPLE/texture_max_level.py,sha256=qYat_0YJTCbC2iJ-6QQK3mx1WC5kdNOM_yqe8Slw2V4,1080 +OpenGL/GLES2/APPLE/texture_packed_float.py,sha256=NIsCnmij6SABMfWP3FckF7jw8RotE0RTfh_VxBK3QVM,1971 +OpenGL/GLES2/ARM/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/GLES2/ARM/__pycache__/__init__.cpython-312.pyc,, +OpenGL/GLES2/ARM/__pycache__/mali_program_binary.cpython-312.pyc,, +OpenGL/GLES2/ARM/__pycache__/mali_shader_binary.cpython-312.pyc,, +OpenGL/GLES2/ARM/__pycache__/rgba8.cpython-312.pyc,, +OpenGL/GLES2/ARM/__pycache__/shader_framebuffer_fetch.cpython-312.pyc,, +OpenGL/GLES2/ARM/__pycache__/shader_framebuffer_fetch_depth_stencil.cpython-312.pyc,, +OpenGL/GLES2/ARM/mali_program_binary.py,sha256=lq_ho-G_5ZHH4EjutG-gh6Tz72gY6Oxo7iVTvX1nIIY,1230 +OpenGL/GLES2/ARM/mali_shader_binary.py,sha256=4DYc3UCD7kcRMunzprvCs9W8bGlkOLlCZ1nVqFQWrOk,1217 +OpenGL/GLES2/ARM/rgba8.py,sha256=uA2bYppok0CBOZR1gCPA_nlliq1bbicRmmtYsoeq1Vg,862 +OpenGL/GLES2/ARM/shader_framebuffer_fetch.py,sha256=LZ5yZg1a3uV-MVNoJ93_b3RTUYj5F6vhP5xw9U8GN7I,1409 +OpenGL/GLES2/ARM/shader_framebuffer_fetch_depth_stencil.py,sha256=FSOwYH3fSuRTf4cfb2LyxPREISW9A73UGPapfwf7a0Y,1636 +OpenGL/GLES2/DMP/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/GLES2/DMP/__pycache__/__init__.cpython-312.pyc,, +OpenGL/GLES2/DMP/__pycache__/program_binary.cpython-312.pyc,, +OpenGL/GLES2/DMP/__pycache__/shader_binary.cpython-312.pyc,, +OpenGL/GLES2/DMP/program_binary.py,sha256=dKDNDbO7SjxNq69ghdYd6PpEi1l3IPoHtrst4UbMTjE,925 +OpenGL/GLES2/DMP/shader_binary.py,sha256=HROGfj4h9316_TxxRg3iool-30oSVPCMDD_NZ2r6KWQ,917 +OpenGL/GLES2/ES/VERSION_3_2.py,sha256=YHzUHU3qfkQaEWxmThc4L2KhKUP8-Qwu1VsPN0ENOaU,5018 +OpenGL/GLES2/ES/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/GLES2/ES/__pycache__/VERSION_3_2.cpython-312.pyc,, +OpenGL/GLES2/ES/__pycache__/__init__.cpython-312.pyc,, +OpenGL/GLES2/EXT/EGL_image_array.py,sha256=qBRyzAvZaETgWG09tgt71IO5dxxGCXXN7nU0D9o8eAY,1275 +OpenGL/GLES2/EXT/EGL_image_storage.py,sha256=FT1y064HWaZYoYhesmjFUpJ_jzbJ-hW3WKrJewf6ccs,1921 +OpenGL/GLES2/EXT/YUV_target.py,sha256=SUKLx3iIAuWGFC7piCjvNAywos3vPmzpaxeU3t-iqVs,1604 +OpenGL/GLES2/EXT/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/GLES2/EXT/__pycache__/EGL_image_array.cpython-312.pyc,, +OpenGL/GLES2/EXT/__pycache__/EGL_image_storage.cpython-312.pyc,, +OpenGL/GLES2/EXT/__pycache__/YUV_target.cpython-312.pyc,, +OpenGL/GLES2/EXT/__pycache__/__init__.cpython-312.pyc,, +OpenGL/GLES2/EXT/__pycache__/base_instance.cpython-312.pyc,, +OpenGL/GLES2/EXT/__pycache__/blend_func_extended.cpython-312.pyc,, +OpenGL/GLES2/EXT/__pycache__/blend_minmax.cpython-312.pyc,, +OpenGL/GLES2/EXT/__pycache__/buffer_storage.cpython-312.pyc,, +OpenGL/GLES2/EXT/__pycache__/clear_texture.cpython-312.pyc,, +OpenGL/GLES2/EXT/__pycache__/clip_control.cpython-312.pyc,, +OpenGL/GLES2/EXT/__pycache__/clip_cull_distance.cpython-312.pyc,, +OpenGL/GLES2/EXT/__pycache__/color_buffer_float.cpython-312.pyc,, +OpenGL/GLES2/EXT/__pycache__/color_buffer_half_float.cpython-312.pyc,, +OpenGL/GLES2/EXT/__pycache__/conservative_depth.cpython-312.pyc,, +OpenGL/GLES2/EXT/__pycache__/copy_image.cpython-312.pyc,, +OpenGL/GLES2/EXT/__pycache__/debug_label.cpython-312.pyc,, +OpenGL/GLES2/EXT/__pycache__/debug_marker.cpython-312.pyc,, +OpenGL/GLES2/EXT/__pycache__/depth_clamp.cpython-312.pyc,, +OpenGL/GLES2/EXT/__pycache__/discard_framebuffer.cpython-312.pyc,, +OpenGL/GLES2/EXT/__pycache__/disjoint_timer_query.cpython-312.pyc,, +OpenGL/GLES2/EXT/__pycache__/draw_buffers.cpython-312.pyc,, +OpenGL/GLES2/EXT/__pycache__/draw_buffers_indexed.cpython-312.pyc,, +OpenGL/GLES2/EXT/__pycache__/draw_elements_base_vertex.cpython-312.pyc,, +OpenGL/GLES2/EXT/__pycache__/draw_instanced.cpython-312.pyc,, +OpenGL/GLES2/EXT/__pycache__/draw_transform_feedback.cpython-312.pyc,, +OpenGL/GLES2/EXT/__pycache__/external_buffer.cpython-312.pyc,, +OpenGL/GLES2/EXT/__pycache__/float_blend.cpython-312.pyc,, +OpenGL/GLES2/EXT/__pycache__/geometry_point_size.cpython-312.pyc,, +OpenGL/GLES2/EXT/__pycache__/geometry_shader.cpython-312.pyc,, +OpenGL/GLES2/EXT/__pycache__/gpu_shader5.cpython-312.pyc,, +OpenGL/GLES2/EXT/__pycache__/instanced_arrays.cpython-312.pyc,, +OpenGL/GLES2/EXT/__pycache__/map_buffer_range.cpython-312.pyc,, +OpenGL/GLES2/EXT/__pycache__/memory_object.cpython-312.pyc,, +OpenGL/GLES2/EXT/__pycache__/memory_object_fd.cpython-312.pyc,, +OpenGL/GLES2/EXT/__pycache__/memory_object_win32.cpython-312.pyc,, +OpenGL/GLES2/EXT/__pycache__/multi_draw_arrays.cpython-312.pyc,, +OpenGL/GLES2/EXT/__pycache__/multi_draw_indirect.cpython-312.pyc,, +OpenGL/GLES2/EXT/__pycache__/multisampled_compatibility.cpython-312.pyc,, +OpenGL/GLES2/EXT/__pycache__/multisampled_render_to_texture.cpython-312.pyc,, +OpenGL/GLES2/EXT/__pycache__/multiview_draw_buffers.cpython-312.pyc,, +OpenGL/GLES2/EXT/__pycache__/multiview_tessellation_geometry_shader.cpython-312.pyc,, +OpenGL/GLES2/EXT/__pycache__/multiview_texture_multisample.cpython-312.pyc,, +OpenGL/GLES2/EXT/__pycache__/multiview_timer_query.cpython-312.pyc,, +OpenGL/GLES2/EXT/__pycache__/occlusion_query_boolean.cpython-312.pyc,, +OpenGL/GLES2/EXT/__pycache__/polygon_offset_clamp.cpython-312.pyc,, +OpenGL/GLES2/EXT/__pycache__/post_depth_coverage.cpython-312.pyc,, +OpenGL/GLES2/EXT/__pycache__/primitive_bounding_box.cpython-312.pyc,, +OpenGL/GLES2/EXT/__pycache__/protected_textures.cpython-312.pyc,, +OpenGL/GLES2/EXT/__pycache__/pvrtc_sRGB.cpython-312.pyc,, +OpenGL/GLES2/EXT/__pycache__/raster_multisample.cpython-312.pyc,, +OpenGL/GLES2/EXT/__pycache__/read_format_bgra.cpython-312.pyc,, +OpenGL/GLES2/EXT/__pycache__/render_snorm.cpython-312.pyc,, +OpenGL/GLES2/EXT/__pycache__/robustness.cpython-312.pyc,, +OpenGL/GLES2/EXT/__pycache__/sRGB.cpython-312.pyc,, +OpenGL/GLES2/EXT/__pycache__/sRGB_write_control.cpython-312.pyc,, +OpenGL/GLES2/EXT/__pycache__/semaphore.cpython-312.pyc,, +OpenGL/GLES2/EXT/__pycache__/semaphore_fd.cpython-312.pyc,, +OpenGL/GLES2/EXT/__pycache__/semaphore_win32.cpython-312.pyc,, +OpenGL/GLES2/EXT/__pycache__/separate_shader_objects.cpython-312.pyc,, +OpenGL/GLES2/EXT/__pycache__/shader_framebuffer_fetch.cpython-312.pyc,, +OpenGL/GLES2/EXT/__pycache__/shader_framebuffer_fetch_non_coherent.cpython-312.pyc,, +OpenGL/GLES2/EXT/__pycache__/shader_group_vote.cpython-312.pyc,, +OpenGL/GLES2/EXT/__pycache__/shader_implicit_conversions.cpython-312.pyc,, +OpenGL/GLES2/EXT/__pycache__/shader_integer_mix.cpython-312.pyc,, +OpenGL/GLES2/EXT/__pycache__/shader_io_blocks.cpython-312.pyc,, +OpenGL/GLES2/EXT/__pycache__/shader_non_constant_global_initializers.cpython-312.pyc,, +OpenGL/GLES2/EXT/__pycache__/shader_pixel_local_storage.cpython-312.pyc,, +OpenGL/GLES2/EXT/__pycache__/shader_pixel_local_storage2.cpython-312.pyc,, +OpenGL/GLES2/EXT/__pycache__/shader_texture_lod.cpython-312.pyc,, +OpenGL/GLES2/EXT/__pycache__/shadow_samplers.cpython-312.pyc,, +OpenGL/GLES2/EXT/__pycache__/sparse_texture.cpython-312.pyc,, +OpenGL/GLES2/EXT/__pycache__/sparse_texture2.cpython-312.pyc,, +OpenGL/GLES2/EXT/__pycache__/tessellation_point_size.cpython-312.pyc,, +OpenGL/GLES2/EXT/__pycache__/tessellation_shader.cpython-312.pyc,, +OpenGL/GLES2/EXT/__pycache__/texture_border_clamp.cpython-312.pyc,, +OpenGL/GLES2/EXT/__pycache__/texture_buffer.cpython-312.pyc,, +OpenGL/GLES2/EXT/__pycache__/texture_compression_astc_decode_mode.cpython-312.pyc,, +OpenGL/GLES2/EXT/__pycache__/texture_compression_bptc.cpython-312.pyc,, +OpenGL/GLES2/EXT/__pycache__/texture_compression_dxt1.cpython-312.pyc,, +OpenGL/GLES2/EXT/__pycache__/texture_compression_rgtc.cpython-312.pyc,, +OpenGL/GLES2/EXT/__pycache__/texture_compression_s3tc.cpython-312.pyc,, +OpenGL/GLES2/EXT/__pycache__/texture_compression_s3tc_srgb.cpython-312.pyc,, +OpenGL/GLES2/EXT/__pycache__/texture_cube_map_array.cpython-312.pyc,, +OpenGL/GLES2/EXT/__pycache__/texture_filter_anisotropic.cpython-312.pyc,, +OpenGL/GLES2/EXT/__pycache__/texture_filter_minmax.cpython-312.pyc,, +OpenGL/GLES2/EXT/__pycache__/texture_format_BGRA8888.cpython-312.pyc,, +OpenGL/GLES2/EXT/__pycache__/texture_format_sRGB_override.cpython-312.pyc,, +OpenGL/GLES2/EXT/__pycache__/texture_mirror_clamp_to_edge.cpython-312.pyc,, +OpenGL/GLES2/EXT/__pycache__/texture_norm16.cpython-312.pyc,, +OpenGL/GLES2/EXT/__pycache__/texture_query_lod.cpython-312.pyc,, +OpenGL/GLES2/EXT/__pycache__/texture_rg.cpython-312.pyc,, +OpenGL/GLES2/EXT/__pycache__/texture_sRGB_R8.cpython-312.pyc,, +OpenGL/GLES2/EXT/__pycache__/texture_sRGB_RG8.cpython-312.pyc,, +OpenGL/GLES2/EXT/__pycache__/texture_sRGB_decode.cpython-312.pyc,, +OpenGL/GLES2/EXT/__pycache__/texture_shadow_lod.cpython-312.pyc,, +OpenGL/GLES2/EXT/__pycache__/texture_storage.cpython-312.pyc,, +OpenGL/GLES2/EXT/__pycache__/texture_type_2_10_10_10_REV.cpython-312.pyc,, +OpenGL/GLES2/EXT/__pycache__/texture_view.cpython-312.pyc,, +OpenGL/GLES2/EXT/__pycache__/unpack_subimage.cpython-312.pyc,, +OpenGL/GLES2/EXT/__pycache__/win32_keyed_mutex.cpython-312.pyc,, +OpenGL/GLES2/EXT/__pycache__/window_rectangles.cpython-312.pyc,, +OpenGL/GLES2/EXT/base_instance.py,sha256=Yw7e22mP3iCd1_d_w5akC0zE_5BnK1zRjUrxj8Fhmi4,2392 +OpenGL/GLES2/EXT/blend_func_extended.py,sha256=QMeJmi0m5Ajwsfrkc1Sa8qTNa4fqL8Kb9bxpLaaMwRE,2596 +OpenGL/GLES2/EXT/blend_minmax.py,sha256=bzIXsjy58LhpFeThZZVIWpD1iabAIOn2OoUhP9nIquI,1277 +OpenGL/GLES2/EXT/buffer_storage.py,sha256=v44zGY9tNsJUKmy-eBdmGpN260mT3EY-fJnYyPpoLUM,2142 +OpenGL/GLES2/EXT/clear_texture.py,sha256=-57cBN6GU0bKReLQiiRbKIwvJQIjPOTH_xFe-i-e_c8,2663 +OpenGL/GLES2/EXT/clip_control.py,sha256=IcKdXjh5hhX5s1aNPVhffOmDcnkS_ADWjXj_kt3wS1s,1254 +OpenGL/GLES2/EXT/clip_cull_distance.py,sha256=7S6dLRqUXQaGyIm_Rs5lAxxfk0N0V19LyBq2Y2lTah8,1024 +OpenGL/GLES2/EXT/color_buffer_float.py,sha256=bk1MgzITeFqsxjcvhfIBvmAa0LqR_skr6pA6IhtGvhI,922 +OpenGL/GLES2/EXT/color_buffer_half_float.py,sha256=9_LhjtMhOTAsWv2Ln3eBEwYVNmZTqyhjel6GyCVKJLk,1160 +OpenGL/GLES2/EXT/conservative_depth.py,sha256=0R4mDBIA_IU9sICI0fD1EBVlWq4KoWe0jye1isRcII4,1583 +OpenGL/GLES2/EXT/copy_image.py,sha256=8kaLCWM6QdDfcfCZh2dddFwYZ40l1UF_y_16Igx_g40,1627 +OpenGL/GLES2/EXT/debug_label.py,sha256=sFEMy2C2r6FTpb1hLwaaqRJrKQ0w5njHLSRAmmC2KDA,1591 +OpenGL/GLES2/EXT/debug_marker.py,sha256=pLtWd2kONa5KfBb3mIb1u-8hhAK4Oa0b9ceSbIRA2xk,1416 +OpenGL/GLES2/EXT/depth_clamp.py,sha256=qXYovUZo3i2VR2wck0MRbxlnxeIpCY2Re0OLBFw60gM,2396 +OpenGL/GLES2/EXT/discard_framebuffer.py,sha256=ZLR3QMzxbsgoUdTMtp7ji4Kq2cHb4IvHJITNqmxQbrs,2489 +OpenGL/GLES2/EXT/disjoint_timer_query.py,sha256=Di-6bPH60k175BB2ti_qF13ktPQu1_8S12XG1GCacyc,3235 +OpenGL/GLES2/EXT/draw_buffers.py,sha256=q0ZTCtMxqEpsv-LluH38riIwaWt1FP-OSBEPG6PNF8Y,1811 +OpenGL/GLES2/EXT/draw_buffers_indexed.py,sha256=FxUGgRxYf8F2s1d27ge_y4PqTggi-d5qLLSrx28VWc0,1563 +OpenGL/GLES2/EXT/draw_elements_base_vertex.py,sha256=-lGTtlwMmyDRmY15txCrzilEtATxoY_tKk_UIq6R7fU,4247 +OpenGL/GLES2/EXT/draw_instanced.py,sha256=MFEpVMbDryIPcNavlngG0kxT7vErOc3LNi_YJkuOKcs,1228 +OpenGL/GLES2/EXT/draw_transform_feedback.py,sha256=wnK0OGAAEW9jD-cg-7E32x22h6AgKfzIpi5qGE0hMho,1305 +OpenGL/GLES2/EXT/external_buffer.py,sha256=1-RZ8uyI7-wJG7YmtnHwsnhKVYS3J0SAbBzUhaRoiyk,2983 +OpenGL/GLES2/EXT/float_blend.py,sha256=NQ7LSVtzPSnUNMC9nWcLhQRHChbf0TSrEDyJXXedkRA,918 +OpenGL/GLES2/EXT/geometry_point_size.py,sha256=J58_7SwiPNxGLDjti4-par1wR3HzBTnI6M3hEko27No,797 +OpenGL/GLES2/EXT/geometry_shader.py,sha256=eZ3bLGANEw1jq8xiRtt3oGOXxE1A892_dE2THs9Mb38,3327 +OpenGL/GLES2/EXT/gpu_shader5.py,sha256=wMqDzdAMAl1qLExIIPDo1bicqq6_oI69tz8_h4nfrpk,2329 +OpenGL/GLES2/EXT/instanced_arrays.py,sha256=eAQgcsTL1rBPtmm5YzQRqEUNgHDEIzq2HeGR8q0JvT4,1941 +OpenGL/GLES2/EXT/map_buffer_range.py,sha256=8amGARvmbwIVhOHFtpf6i8DC-U_DkJyFc4_ZeGMpydE,2017 +OpenGL/GLES2/EXT/memory_object.py,sha256=dF1twZWgi7QdTEQMJPj6lYcwCVJLeCFVEitUJTOILEM,1290 +OpenGL/GLES2/EXT/memory_object_fd.py,sha256=UsdP3JNNne_p5lId6y9KEsnUpPxZYkR6GlICEMavanY,779 +OpenGL/GLES2/EXT/memory_object_win32.py,sha256=4NpiQkb5OWbnQdnqJZvJpC8FW6IB8HiDo4TEg4YdRuA,797 +OpenGL/GLES2/EXT/multi_draw_arrays.py,sha256=rB7vjYHRCv4kuPFH6wTku9S8b9n80DhbxQp8mebar1w,1684 +OpenGL/GLES2/EXT/multi_draw_indirect.py,sha256=4Zlx-457uXc7Gi8dm3mtYrSU6b7ZQSxn_8fURkJQcR4,1978 +OpenGL/GLES2/EXT/multisampled_compatibility.py,sha256=s-gXNIrnAVXGGKRn2xqu18Bd6RC-6Ttmkx39ukAsKn8,840 +OpenGL/GLES2/EXT/multisampled_render_to_texture.py,sha256=7sTF2RqFLCmOzZqPG5r7nBvDds3ozPdJhFffIOUajt8,2157 +OpenGL/GLES2/EXT/multiview_draw_buffers.py,sha256=MX7Jb4WTU-lH71Sr2XsUtIZqBj-RMqPfz5xLIx-qq1o,2556 +OpenGL/GLES2/EXT/multiview_tessellation_geometry_shader.py,sha256=FcIGeSL0LB7En9_axfcX5edPRVUn2EbMuv8iOneQM4Y,2189 +OpenGL/GLES2/EXT/multiview_texture_multisample.py,sha256=0xF097Qqft_fmDGizWOI1IFyaApUYou0ZZAMTiB4O2U,2241 +OpenGL/GLES2/EXT/multiview_timer_query.py,sha256=orJeyB_TE5dMIrkaAvukO_Bs2Np65qmM4hTfjmEbZwY,1191 +OpenGL/GLES2/EXT/occlusion_query_boolean.py,sha256=RnKb8I9EbiEfBZ8Sue6uX5Z_RbozTFRVpJVopmvijuI,2039 +OpenGL/GLES2/EXT/polygon_offset_clamp.py,sha256=-M_oPqzrZh7rzM3GWpRdPJCpJFcTOuqjcRc2hWNxa8g,1402 +OpenGL/GLES2/EXT/post_depth_coverage.py,sha256=cs0vOR0jzZn6KE-zRRz3pkIGe4djB9Z_twVtACf2tmc,1258 +OpenGL/GLES2/EXT/primitive_bounding_box.py,sha256=Mj-LfybVU8eMbcmrr82C_kP30TDj_qFBEBDSn6WqEjE,2460 +OpenGL/GLES2/EXT/protected_textures.py,sha256=vwdJabKB-fghBy3J-fNaLHY3k_HS8SvvNlUU3Pj6bto,2342 +OpenGL/GLES2/EXT/pvrtc_sRGB.py,sha256=_Z0OrCgKiv6wHZouoU-fYxIkztyH7JB3ayv6XCwTzGg,2264 +OpenGL/GLES2/EXT/raster_multisample.py,sha256=mTZWyS2m8-me2LTactkm2GO3OjieXuOTP1g5rWeFzo0,1740 +OpenGL/GLES2/EXT/read_format_bgra.py,sha256=0i4KSgnbrkQksQBbRT0dS6REe1GdllHgzEbxouVYFsI,1888 +OpenGL/GLES2/EXT/render_snorm.py,sha256=rFVNI_rATw3v54Pkt4xOIf_kNf1TRk452wannav7oy4,1007 +OpenGL/GLES2/EXT/robustness.py,sha256=S71ki-bAs1o4bqvvWY5cTfrVDamrwGjOyp-MeuqICZE,4054 +OpenGL/GLES2/EXT/sRGB.py,sha256=IQxY1Pwtx09G15JW7xKTjtWW94T5L3AWczfbJNPmt3g,2161 +OpenGL/GLES2/EXT/sRGB_write_control.py,sha256=0OdDTUa2WQIs57-MSopCusuvvfCcGCk1YBEWEWIfz20,1292 +OpenGL/GLES2/EXT/semaphore.py,sha256=Vh2kewZkN1Z80BaIs5Q8jIpX8aFoo0hDmGWrjbIJJ-c,2282 +OpenGL/GLES2/EXT/semaphore_fd.py,sha256=ThBtYmoD2D1hul3jRu45GMR_K4uCQxd77-JRS1Hs9lg,756 +OpenGL/GLES2/EXT/semaphore_win32.py,sha256=f8lAKB9AXi5msUl2VzctgvwFuaracHglOkPFvwcfSak,774 +OpenGL/GLES2/EXT/separate_shader_objects.py,sha256=3dPbjK-wzP6xzFA0qnSRhqpwzUlpDrNC5TT5FA5DGEw,5619 +OpenGL/GLES2/EXT/shader_framebuffer_fetch.py,sha256=oVFUUKIyaWrdGrI4crn-2cJhb0yCYtLs_YYtFP0H6lw,2780 +OpenGL/GLES2/EXT/shader_framebuffer_fetch_non_coherent.py,sha256=IPUtracKMRgG_nBcTvDVy39W3rrzDZsgB8UlZatPRtU,903 +OpenGL/GLES2/EXT/shader_group_vote.py,sha256=_Ay6nKNaoB3iVr3hCRypLbVWGKgrAmUhMYlxJ-uZANk,3363 +OpenGL/GLES2/EXT/shader_implicit_conversions.py,sha256=UQ0wJj-KAJaLnRb2J6OADuxJPzLDH4l5MEmiDy383fw,1117 +OpenGL/GLES2/EXT/shader_integer_mix.py,sha256=cxml1mrjd7Umxbknuge-4qla01Y5INmIlGg2gLtQPls,1046 +OpenGL/GLES2/EXT/shader_io_blocks.py,sha256=hxw7J9qNTOlRU_5B-3HFwGwOJe_lS39fY8WasH1IQqQ,1923 +OpenGL/GLES2/EXT/shader_non_constant_global_initializers.py,sha256=a0oayd7H6I_w-NoSOOWknBVkUxRcNatpN-Yu8pDdd34,1167 +OpenGL/GLES2/EXT/shader_pixel_local_storage.py,sha256=R0A-WPqjc6cQX8bPXQIE_2eZd6VCCHKTW4QJbgMi7lw,2343 +OpenGL/GLES2/EXT/shader_pixel_local_storage2.py,sha256=qlLzy9M8jGE3D6lCBvrayz_HSlAU53mXysiADM05B4M,1722 +OpenGL/GLES2/EXT/shader_texture_lod.py,sha256=6MFSKi8q9U0xgIf19SkpoGEc1RWBr3JH8Lw7OnVZVUU,3362 +OpenGL/GLES2/EXT/shadow_samplers.py,sha256=-peGZowF8bPiC5YUOcjU8qQVp9qiuKdO7IMcN0Ci3bQ,991 +OpenGL/GLES2/EXT/sparse_texture.py,sha256=MDfbhEcS_ZDA5ffdoKlUVZzIBcv_9O29Vv7FLi6cQj8,1854 +OpenGL/GLES2/EXT/sparse_texture2.py,sha256=shGDBZJ4_Qx2fvXhC3F8JLQJtuPq9wlRvoX6GtB5FGE,2202 +OpenGL/GLES2/EXT/tessellation_point_size.py,sha256=lfc2WRXzD0CgEeE6SUnuuLtRvmx7QUKdWLzAUHgpoik,821 +OpenGL/GLES2/EXT/tessellation_shader.py,sha256=OuM5TqMo1-xaG3_kE_J0lGg6vQ5pqs3UMNjm48hgj-8,5289 +OpenGL/GLES2/EXT/texture_border_clamp.py,sha256=Av6NrSGIvlnphTRRmFDymunlZVCYW64OBlkVl6I1Y1A,2950 +OpenGL/GLES2/EXT/texture_buffer.py,sha256=2mJmKhHBH15SRs6k6NmznostwnwV9bz8Fr1jXe06cO8,2943 +OpenGL/GLES2/EXT/texture_compression_astc_decode_mode.py,sha256=hORGlrVST8NNmXEIzlJ3e6qLLyLUSQg4TOCRB6UXiR8,2394 +OpenGL/GLES2/EXT/texture_compression_bptc.py,sha256=hkVcZ9dFqBBJ-UjtBnS-AdiF98jObYY_cH1n_qewdxc,1629 +OpenGL/GLES2/EXT/texture_compression_dxt1.py,sha256=tNgKGOaoTIQFQ7in-pu65_248gVID-O4U47BoB7h0Fo,2415 +OpenGL/GLES2/EXT/texture_compression_rgtc.py,sha256=MkAjrEKoZo0uqux-DLijtQoq6d9685U_SGAgiff8f3g,1762 +OpenGL/GLES2/EXT/texture_compression_s3tc.py,sha256=xZJquH7eYaG-z3aW77Y-vvVIVLuzCgVJjar95dCUZFo,1314 +OpenGL/GLES2/EXT/texture_compression_s3tc_srgb.py,sha256=Wbq-EX52NR9nghs-L5o8qLRR-4OlkNeE1Pf1cnRzytw,992 +OpenGL/GLES2/EXT/texture_cube_map_array.py,sha256=kZxtfJ4hh3pvQlOuy3ekHhrSE2ZvlFFOqFv1gYm6kFk,1985 +OpenGL/GLES2/EXT/texture_filter_anisotropic.py,sha256=V8H0UL2zDJMftxr-3QLhwiGpiYUeKuqkvps4RBfrqUM,2905 +OpenGL/GLES2/EXT/texture_filter_minmax.py,sha256=eus51SPhZNyZd0vMWcbDC0lO42x96FcKHkJVn6tZLH8,1623 +OpenGL/GLES2/EXT/texture_format_BGRA8888.py,sha256=Miza-tbfWSLHO3VtNNNqKba2RFWs90TbbAvNuJezqNk,2554 +OpenGL/GLES2/EXT/texture_format_sRGB_override.py,sha256=TaJgfKqhMihiqhWE9meWbcCuOFwaT5C-6Tj9S8fPVEI,1433 +OpenGL/GLES2/EXT/texture_mirror_clamp_to_edge.py,sha256=Prk6f27HgI1HbVtLR9giEM8k1B8SwfrQCDxJ8l58UXw,1416 +OpenGL/GLES2/EXT/texture_norm16.py,sha256=kogvvfijN7vD-lYOuq_tMlXLmZ3GYyRzORBEaCGvG3w,1011 +OpenGL/GLES2/EXT/texture_query_lod.py,sha256=NLi2LcrQlx0vvjnpdIFPg9Nu6FTLAtSRPKr1Pl7q00E,1022 +OpenGL/GLES2/EXT/texture_rg.py,sha256=lyCzfCzvabKSWfBW2IxBAAMYdfaCc0dmCbb49JtIDcY,1913 +OpenGL/GLES2/EXT/texture_sRGB_R8.py,sha256=0tGFOH8proZAvgYzoi0FKhgPrrt1hVp1G8Bgns8m5u0,968 +OpenGL/GLES2/EXT/texture_sRGB_RG8.py,sha256=rD7EcL_C5OwZV5OANlhaKdXUWner8XLGxJn5AQ58it4,957 +OpenGL/GLES2/EXT/texture_sRGB_decode.py,sha256=0Cv6M-LcYCpvmlwGuMk-kCe5xIVMLkukXAsHmjJE3WI,1628 +OpenGL/GLES2/EXT/texture_shadow_lod.py,sha256=5oJE_KS8AEQyLEpFTuuepoOC2vIB8N2oR8AsZQSsjK0,1440 +OpenGL/GLES2/EXT/texture_storage.py,sha256=cyLcllcWTCdYAicO9ZWTlEvW0etAdwr5kDoqcHLwNro,1829 +OpenGL/GLES2/EXT/texture_type_2_10_10_10_REV.py,sha256=ClxqJeihEUHZa9-VTDbD-YNMoPBLFHKCrEl7ZXtMaiY,986 +OpenGL/GLES2/EXT/texture_view.py,sha256=HFRrZsRg5yx5gyVbb8hG6tXK436Up8n5Rk_5eC7UGvs,1963 +OpenGL/GLES2/EXT/unpack_subimage.py,sha256=n362-xmWUBV1YGcVLCX0X7dKfxuZRryIyFsE-Ka2UmA,1113 +OpenGL/GLES2/EXT/win32_keyed_mutex.py,sha256=dUF6TZyAo1vUAROc2cLYFYbN0SHVYqdPqqJ_TfeuPco,1122 +OpenGL/GLES2/EXT/window_rectangles.py,sha256=f5BRLnYdhB23YpdGDXtQQYUUdDlNOx-z3b36CC3-r74,2077 +OpenGL/GLES2/FJ/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/GLES2/FJ/__pycache__/__init__.cpython-312.pyc,, +OpenGL/GLES2/FJ/__pycache__/shader_binary_GCCSO.cpython-312.pyc,, +OpenGL/GLES2/FJ/shader_binary_GCCSO.py,sha256=yHfUA2GuKu1cWdoqzKxdjtl3b2UHPz1o4-bOxyri75k,936 +OpenGL/GLES2/IMG/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/GLES2/IMG/__pycache__/__init__.cpython-312.pyc,, +OpenGL/GLES2/IMG/__pycache__/bindless_texture.cpython-312.pyc,, +OpenGL/GLES2/IMG/__pycache__/framebuffer_downsample.cpython-312.pyc,, +OpenGL/GLES2/IMG/__pycache__/multisampled_render_to_texture.cpython-312.pyc,, +OpenGL/GLES2/IMG/__pycache__/program_binary.cpython-312.pyc,, +OpenGL/GLES2/IMG/__pycache__/read_format.cpython-312.pyc,, +OpenGL/GLES2/IMG/__pycache__/shader_binary.cpython-312.pyc,, +OpenGL/GLES2/IMG/__pycache__/texture_compression_pvrtc.cpython-312.pyc,, +OpenGL/GLES2/IMG/__pycache__/texture_compression_pvrtc2.cpython-312.pyc,, +OpenGL/GLES2/IMG/__pycache__/texture_filter_cubic.cpython-312.pyc,, +OpenGL/GLES2/IMG/bindless_texture.py,sha256=sFb3VPIaTsToIPeiUvdWJCYBSePpIuePVUpnoOB7NlQ,2299 +OpenGL/GLES2/IMG/framebuffer_downsample.py,sha256=ir9SJiH59xl3BnTQzlKhrixIG-Y33Tqrq1fmP7WMLjI,1386 +OpenGL/GLES2/IMG/multisampled_render_to_texture.py,sha256=SNiLBZZWmlynf0kvD4_Zv0dIHuG7UqeFjs3RKNddNS8,2176 +OpenGL/GLES2/IMG/program_binary.py,sha256=M3YD1B-B1d7ee9wowY62LuDu1PtS_JoHRgkPk4Ren_E,992 +OpenGL/GLES2/IMG/read_format.py,sha256=DmVGVVSX-yW5pTPBE5_9wAc8IEgtRbJzopZpUuP3dVU,1795 +OpenGL/GLES2/IMG/shader_binary.py,sha256=pq5lpcWjpTC4VjqiACaqRRlA0XzYYUc3rTqhNUQ4y-k,911 +OpenGL/GLES2/IMG/texture_compression_pvrtc.py,sha256=TVg-hY8CBQs5Yiu56XHZQuDvVrAvaTWwfuwv2gjVa_E,1402 +OpenGL/GLES2/IMG/texture_compression_pvrtc2.py,sha256=Jg-7KQIaoBUk0GFvMyY0pebdcVLmFDjFcEzK1QKsokg,1406 +OpenGL/GLES2/IMG/texture_filter_cubic.py,sha256=H3bxtekh-TK9wyI2nPs__2lLjBpHhECI8rgHzz8CvPg,1574 +OpenGL/GLES2/INTEL/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/GLES2/INTEL/__pycache__/__init__.cpython-312.pyc,, +OpenGL/GLES2/INTEL/__pycache__/blackhole_render.cpython-312.pyc,, +OpenGL/GLES2/INTEL/__pycache__/conservative_rasterization.cpython-312.pyc,, +OpenGL/GLES2/INTEL/__pycache__/framebuffer_CMAA.cpython-312.pyc,, +OpenGL/GLES2/INTEL/__pycache__/performance_query.cpython-312.pyc,, +OpenGL/GLES2/INTEL/blackhole_render.py,sha256=j_D7qRgmjK2xxo_V0v49nRKa_NNrYadkNa1Mk9P0_RA,1187 +OpenGL/GLES2/INTEL/conservative_rasterization.py,sha256=hh0m-zSQQye-x5AK5_v8MccHCBvPljzoq5lRdyYWNmc,1694 +OpenGL/GLES2/INTEL/framebuffer_CMAA.py,sha256=wpexjf79PcwH_nrL_ZfA5JZe1IHuveT7STnGG4by7Ss,1561 +OpenGL/GLES2/INTEL/performance_query.py,sha256=Fy6tgMOEl6M_WiQbtWNKwB9NxOGDxDpdE0dRa65sluw,2819 +OpenGL/GLES2/KHR/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/GLES2/KHR/__pycache__/__init__.cpython-312.pyc,, +OpenGL/GLES2/KHR/__pycache__/blend_equation_advanced.cpython-312.pyc,, +OpenGL/GLES2/KHR/__pycache__/blend_equation_advanced_coherent.cpython-312.pyc,, +OpenGL/GLES2/KHR/__pycache__/context_flush_control.cpython-312.pyc,, +OpenGL/GLES2/KHR/__pycache__/debug.cpython-312.pyc,, +OpenGL/GLES2/KHR/__pycache__/no_error.cpython-312.pyc,, +OpenGL/GLES2/KHR/__pycache__/parallel_shader_compile.cpython-312.pyc,, +OpenGL/GLES2/KHR/__pycache__/robust_buffer_access_behavior.cpython-312.pyc,, +OpenGL/GLES2/KHR/__pycache__/robustness.cpython-312.pyc,, +OpenGL/GLES2/KHR/__pycache__/shader_subgroup.cpython-312.pyc,, +OpenGL/GLES2/KHR/__pycache__/texture_compression_astc_hdr.cpython-312.pyc,, +OpenGL/GLES2/KHR/__pycache__/texture_compression_astc_ldr.cpython-312.pyc,, +OpenGL/GLES2/KHR/__pycache__/texture_compression_astc_sliced_3d.cpython-312.pyc,, +OpenGL/GLES2/KHR/blend_equation_advanced.py,sha256=db2k0SmJepIgvqgcqxanKS5ua4ss5Ymxw5P54zmlYxU,4440 +OpenGL/GLES2/KHR/blend_equation_advanced_coherent.py,sha256=BkgwbkkyQMsGMySI2zxdCX9SL30tx-ABqK0sLTB5ong,874 +OpenGL/GLES2/KHR/context_flush_control.py,sha256=CUC6MYSrEGlntbVrXDJsP21i1Tgp-pzj3HpGy2NyApU,2326 +OpenGL/GLES2/KHR/debug.py,sha256=RZuYdN_R_qvNf6OVleFDKuoPMKL05iQiUf5jUWldGlc,9497 +OpenGL/GLES2/KHR/no_error.py,sha256=BG_BCkD1Pz-96nJHnbZWOe5JC5neyO1hzg0kmjQ5pgw,1339 +OpenGL/GLES2/KHR/parallel_shader_compile.py,sha256=4zpgEOhj7UxF-k2EHVJQuLKwosQKWi72kHpP0jtyDp0,1239 +OpenGL/GLES2/KHR/robust_buffer_access_behavior.py,sha256=Rp8PsmmXSiaNcE0RAcJA0D6ndOZSxG4IU77Uzr8qa6k,1487 +OpenGL/GLES2/KHR/robustness.py,sha256=pCQYiGcnUZ8axXGgRgIM-CI_HRoMk3BoZqiXT6QCO2U,4860 +OpenGL/GLES2/KHR/shader_subgroup.py,sha256=1rgxhXG-7quvQNBN2Bw0pM-9VuKCFllquBU9UPzBI_E,1723 +OpenGL/GLES2/KHR/texture_compression_astc_hdr.py,sha256=2uai_pA-4EbnItHZHV9K5f22H4cwEq739tX_Hto6E5M,1700 +OpenGL/GLES2/KHR/texture_compression_astc_ldr.py,sha256=pfg5ZSLVmJN8sCF81SwFlEnFfj6uFe2VxmyXsFzFrTI,850 +OpenGL/GLES2/KHR/texture_compression_astc_sliced_3d.py,sha256=zTOLQ3WTu-PQWXWSBhSKyQtGaEOn2k9fOpFw-lB1hJc,1523 +OpenGL/GLES2/MESA/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/GLES2/MESA/__pycache__/__init__.cpython-312.pyc,, +OpenGL/GLES2/MESA/__pycache__/framebuffer_flip_y.cpython-312.pyc,, +OpenGL/GLES2/MESA/__pycache__/program_binary_formats.cpython-312.pyc,, +OpenGL/GLES2/MESA/__pycache__/shader_integer_functions.cpython-312.pyc,, +OpenGL/GLES2/MESA/framebuffer_flip_y.py,sha256=YsPD0sUjmLssRKk-pt2Kf6l3qtmruij2kPuYhxSLWCw,1727 +OpenGL/GLES2/MESA/program_binary_formats.py,sha256=Bc-67c-cuSX_Fgyp98nSKePQ94WUXsxTI2Xg54a-SeQ,971 +OpenGL/GLES2/MESA/shader_integer_functions.py,sha256=pZRRt72HgSf2EJQqp1k2cgfDwHunWRG1an7UJhnF4WE,2567 +OpenGL/GLES2/NV/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/GLES2/NV/__pycache__/__init__.cpython-312.pyc,, +OpenGL/GLES2/NV/__pycache__/bindless_texture.cpython-312.pyc,, +OpenGL/GLES2/NV/__pycache__/blend_equation_advanced.cpython-312.pyc,, +OpenGL/GLES2/NV/__pycache__/blend_equation_advanced_coherent.cpython-312.pyc,, +OpenGL/GLES2/NV/__pycache__/blend_minmax_factor.cpython-312.pyc,, +OpenGL/GLES2/NV/__pycache__/clip_space_w_scaling.cpython-312.pyc,, +OpenGL/GLES2/NV/__pycache__/compute_shader_derivatives.cpython-312.pyc,, +OpenGL/GLES2/NV/__pycache__/conditional_render.cpython-312.pyc,, +OpenGL/GLES2/NV/__pycache__/conservative_raster.cpython-312.pyc,, +OpenGL/GLES2/NV/__pycache__/conservative_raster_pre_snap.cpython-312.pyc,, +OpenGL/GLES2/NV/__pycache__/conservative_raster_pre_snap_triangles.cpython-312.pyc,, +OpenGL/GLES2/NV/__pycache__/copy_buffer.cpython-312.pyc,, +OpenGL/GLES2/NV/__pycache__/coverage_sample.cpython-312.pyc,, +OpenGL/GLES2/NV/__pycache__/depth_nonlinear.cpython-312.pyc,, +OpenGL/GLES2/NV/__pycache__/draw_buffers.cpython-312.pyc,, +OpenGL/GLES2/NV/__pycache__/draw_instanced.cpython-312.pyc,, +OpenGL/GLES2/NV/__pycache__/draw_vulkan_image.cpython-312.pyc,, +OpenGL/GLES2/NV/__pycache__/explicit_attrib_location.cpython-312.pyc,, +OpenGL/GLES2/NV/__pycache__/fbo_color_attachments.cpython-312.pyc,, +OpenGL/GLES2/NV/__pycache__/fence.cpython-312.pyc,, +OpenGL/GLES2/NV/__pycache__/fill_rectangle.cpython-312.pyc,, +OpenGL/GLES2/NV/__pycache__/fragment_coverage_to_color.cpython-312.pyc,, +OpenGL/GLES2/NV/__pycache__/fragment_shader_barycentric.cpython-312.pyc,, +OpenGL/GLES2/NV/__pycache__/fragment_shader_interlock.cpython-312.pyc,, +OpenGL/GLES2/NV/__pycache__/framebuffer_blit.cpython-312.pyc,, +OpenGL/GLES2/NV/__pycache__/framebuffer_mixed_samples.cpython-312.pyc,, +OpenGL/GLES2/NV/__pycache__/framebuffer_multisample.cpython-312.pyc,, +OpenGL/GLES2/NV/__pycache__/generate_mipmap_sRGB.cpython-312.pyc,, +OpenGL/GLES2/NV/__pycache__/geometry_shader_passthrough.cpython-312.pyc,, +OpenGL/GLES2/NV/__pycache__/gpu_shader5.cpython-312.pyc,, +OpenGL/GLES2/NV/__pycache__/image_formats.cpython-312.pyc,, +OpenGL/GLES2/NV/__pycache__/instanced_arrays.cpython-312.pyc,, +OpenGL/GLES2/NV/__pycache__/internalformat_sample_query.cpython-312.pyc,, +OpenGL/GLES2/NV/__pycache__/memory_attachment.cpython-312.pyc,, +OpenGL/GLES2/NV/__pycache__/mesh_shader.cpython-312.pyc,, +OpenGL/GLES2/NV/__pycache__/non_square_matrices.cpython-312.pyc,, +OpenGL/GLES2/NV/__pycache__/path_rendering.cpython-312.pyc,, +OpenGL/GLES2/NV/__pycache__/path_rendering_shared_edge.cpython-312.pyc,, +OpenGL/GLES2/NV/__pycache__/pixel_buffer_object.cpython-312.pyc,, +OpenGL/GLES2/NV/__pycache__/polygon_mode.cpython-312.pyc,, +OpenGL/GLES2/NV/__pycache__/read_buffer.cpython-312.pyc,, +OpenGL/GLES2/NV/__pycache__/read_buffer_front.cpython-312.pyc,, +OpenGL/GLES2/NV/__pycache__/read_depth.cpython-312.pyc,, +OpenGL/GLES2/NV/__pycache__/read_depth_stencil.cpython-312.pyc,, +OpenGL/GLES2/NV/__pycache__/read_stencil.cpython-312.pyc,, +OpenGL/GLES2/NV/__pycache__/representative_fragment_test.cpython-312.pyc,, +OpenGL/GLES2/NV/__pycache__/sRGB_formats.cpython-312.pyc,, +OpenGL/GLES2/NV/__pycache__/sample_locations.cpython-312.pyc,, +OpenGL/GLES2/NV/__pycache__/sample_mask_override_coverage.cpython-312.pyc,, +OpenGL/GLES2/NV/__pycache__/scissor_exclusive.cpython-312.pyc,, +OpenGL/GLES2/NV/__pycache__/shader_atomic_fp16_vector.cpython-312.pyc,, +OpenGL/GLES2/NV/__pycache__/shader_noperspective_interpolation.cpython-312.pyc,, +OpenGL/GLES2/NV/__pycache__/shader_subgroup_partitioned.cpython-312.pyc,, +OpenGL/GLES2/NV/__pycache__/shader_texture_footprint.cpython-312.pyc,, +OpenGL/GLES2/NV/__pycache__/shading_rate_image.cpython-312.pyc,, +OpenGL/GLES2/NV/__pycache__/shadow_samplers_array.cpython-312.pyc,, +OpenGL/GLES2/NV/__pycache__/shadow_samplers_cube.cpython-312.pyc,, +OpenGL/GLES2/NV/__pycache__/stereo_view_rendering.cpython-312.pyc,, +OpenGL/GLES2/NV/__pycache__/texture_border_clamp.cpython-312.pyc,, +OpenGL/GLES2/NV/__pycache__/texture_compression_s3tc_update.cpython-312.pyc,, +OpenGL/GLES2/NV/__pycache__/texture_npot_2D_mipmap.cpython-312.pyc,, +OpenGL/GLES2/NV/__pycache__/viewport_array.cpython-312.pyc,, +OpenGL/GLES2/NV/__pycache__/viewport_array2.cpython-312.pyc,, +OpenGL/GLES2/NV/__pycache__/viewport_swizzle.cpython-312.pyc,, +OpenGL/GLES2/NV/bindless_texture.py,sha256=4PXao1gr14UywinraSbs0sYasEJ500TcQll7PjibZKQ,3857 +OpenGL/GLES2/NV/blend_equation_advanced.py,sha256=OQoPB52DLD8K6nk_JMlwm6kMtIGvSo9-z8D7-Uz2GCA,5352 +OpenGL/GLES2/NV/blend_equation_advanced_coherent.py,sha256=IM8p4v8XyIwD8Bb-EWy-EWgcepGRQDxE9d-pUlvrzQk,868 +OpenGL/GLES2/NV/blend_minmax_factor.py,sha256=-JGcVP136lZ4QsoRrVLv1xgE8BLjToVAtQG431osiIA,1642 +OpenGL/GLES2/NV/clip_space_w_scaling.py,sha256=TtP01Vu3UTHfWhpPt4MSXIUxnco7CqQf8RzNxkjRajs,2593 +OpenGL/GLES2/NV/compute_shader_derivatives.py,sha256=65gFipycxzhSW2mIIruUVUMly9uiXH5AyOVG6oa2fsg,1441 +OpenGL/GLES2/NV/conditional_render.py,sha256=Mas_IVrChXl6106Cy79r8illS8oJdmzgGjDRkS71Aw8,2281 +OpenGL/GLES2/NV/conservative_raster.py,sha256=qE6nBe1-7N-xfNu2-TMAEpByk88n7Mw_EEFBqMroSl8,1639 +OpenGL/GLES2/NV/conservative_raster_pre_snap.py,sha256=Oif0PS_OrWLYd5a4mNkMRo_zjX8IVidxcj1Sb2fstlY,1179 +OpenGL/GLES2/NV/conservative_raster_pre_snap_triangles.py,sha256=bH1NwDSJcu8fMqJ7HG15VsIAORI5y8MJR-Y7x2b6Qlw,2280 +OpenGL/GLES2/NV/copy_buffer.py,sha256=6KYdgwgMtybHjnji-RpzYnPEZp5S9BlQaYQwgn_Q7Ac,1013 +OpenGL/GLES2/NV/coverage_sample.py,sha256=Gjcgx-5fcbuIhD9ma71O-rTX-oTviYXIgTmcYoX2Ya4,768 +OpenGL/GLES2/NV/depth_nonlinear.py,sha256=AgCi1VkvkXgIo4IDrlbFWOVel6eeFiHLp0A_KiFxGxs,768 +OpenGL/GLES2/NV/draw_buffers.py,sha256=4s8s4mq6uLReUrneXskWoxrhzYfL_PUhGVTipTexDJ0,1306 +OpenGL/GLES2/NV/draw_instanced.py,sha256=xOV0I3EGcqpOcfMkyCvXznfJAdPbNXWe4fq_JQ5uoXw,1921 +OpenGL/GLES2/NV/draw_vulkan_image.py,sha256=1-1k6Q8ZFUcDbx5rwfcP1G_49IZhpiPF5IzU0rNRD9A,2354 +OpenGL/GLES2/NV/explicit_attrib_location.py,sha256=nzhQeFQipPKmbpWWcDWLYbhB0MLXmS_bowyJ55rKzXY,1178 +OpenGL/GLES2/NV/fbo_color_attachments.py,sha256=elP-iZl6If13gpPJN-8bbI46N3-BdKO6R2TmM_6BXdg,926 +OpenGL/GLES2/NV/fence.py,sha256=0ZBexHoXSA1jM4e89NQH4ZTRY-u4JW4rMZMAVIyaoKg,2769 +OpenGL/GLES2/NV/fill_rectangle.py,sha256=QkXNriaVaf2U0QHtQ2W-5q1ZPjmAKNCo_PRdQq_mLpA,1201 +OpenGL/GLES2/NV/fragment_coverage_to_color.py,sha256=pg6Mp4R3H8U-Df_9VPHXTuspOd-wchcLPweKjz27ARQ,1547 +OpenGL/GLES2/NV/fragment_shader_barycentric.py,sha256=q8adDCwap0AIBNBOE0Thg-mcXMZJ0prQQFzkfSIJTAE,1308 +OpenGL/GLES2/NV/fragment_shader_interlock.py,sha256=pyS1JT7lePmQ5XeLhZ6T1mA5ShSksrR5R7-_pEEwqz4,3939 +OpenGL/GLES2/NV/framebuffer_blit.py,sha256=1q6UQDpyJEGYutWd7oO97-uz0I2gLhhMN_-nVy7010U,1129 +OpenGL/GLES2/NV/framebuffer_mixed_samples.py,sha256=kGTD3B_ksNs_rgewATAoETgHnK_4bQtKmVT0SkPr0qI,3643 +OpenGL/GLES2/NV/framebuffer_multisample.py,sha256=_U8RpaVVmOjnd69GE6KEnV1JFC2sDXD61jN7qwdw6dc,1960 +OpenGL/GLES2/NV/generate_mipmap_sRGB.py,sha256=1NYIkkBzErabf0DQedCohyXJw3FcYuLNibeMMwTlwDQ,969 +OpenGL/GLES2/NV/geometry_shader_passthrough.py,sha256=HlI-KlZnNlVPuFvKwmR4-yH9DnKkOnSL53042_8FFa0,3371 +OpenGL/GLES2/NV/gpu_shader5.py,sha256=Cg8-NWdAr2bHsx62CxyKN1Txj31BDbDVuqxASzURyJw,6428 +OpenGL/GLES2/NV/image_formats.py,sha256=shbMaWdXqJkPfYJ0zvI6SRKlHC79HOXvPunfD8Fh8oI,965 +OpenGL/GLES2/NV/instanced_arrays.py,sha256=4bh0d15VHR2KY6s7fm2Qv6NhV8PORwZ9itPm_6H4OPY,2047 +OpenGL/GLES2/NV/internalformat_sample_query.py,sha256=O-ClQn4odtA8W1CVeHR7h1vB0pucPAzp60zbVWJIQik,3001 +OpenGL/GLES2/NV/memory_attachment.py,sha256=oyJX5qpUXN4bkL29SUI10wgVT_6nXFrkQ81R6QIi09A,1150 +OpenGL/GLES2/NV/mesh_shader.py,sha256=OmuJShWhsgDBvtKdrnrCW-oymvvYkQQcaK8fi5XSFrk,1268 +OpenGL/GLES2/NV/non_square_matrices.py,sha256=yFi7RDUt-x7cJqsyIVe4w_L1Z-BfjvkoaNt9xEF4rsM,1930 +OpenGL/GLES2/NV/path_rendering.py,sha256=ixficuwg8LVYWXGceZcvhJ5rSYagMm2roOP3NOzKE18,24689 +OpenGL/GLES2/NV/path_rendering_shared_edge.py,sha256=r9GQcdEYsGLs260cjoYDJ-sAkm0cF77JqtGCyj7D4Vg,1458 +OpenGL/GLES2/NV/pixel_buffer_object.py,sha256=USXxwyoGmC8GXr8g3au9UMFTt-wwC89sN9jziqCz_zU,3230 +OpenGL/GLES2/NV/polygon_mode.py,sha256=Lk2zRxr3Umie3KFQiW3hqbgG8KqylWd4x-7CAI_dzBY,1259 +OpenGL/GLES2/NV/read_buffer.py,sha256=qmbIndQHxiy6ABWfVwvqN4pzSOEN25PWGBHoIlmdaqA,2091 +OpenGL/GLES2/NV/read_buffer_front.py,sha256=tb9B8FxOrHsHIQFurbmZNR7OuIXIqwbzYFF1Ag7Cmlk,779 +OpenGL/GLES2/NV/read_depth.py,sha256=dTbe1yHPLRJK3Lh9boX__aeYTb7wLSUWPR-Kg2UN_wA,738 +OpenGL/GLES2/NV/read_depth_stencil.py,sha256=c00FywVyJxLFMCaEvt4-07CDF__U7txcCRFHYUxnvAo,1517 +OpenGL/GLES2/NV/read_stencil.py,sha256=oxGxmQ-GYNf_KIF2NaUXdFA78Y51NYMtspHCvHD7P1g,750 +OpenGL/GLES2/NV/representative_fragment_test.py,sha256=HFl_XCS9T51wuRVThGgSaSvkoVnM3WnYZcONjH7EGrw,2436 +OpenGL/GLES2/NV/sRGB_formats.py,sha256=jHFPaAV_uaxqszC7rsmC8LxklQv7Ra5734XcX-JsPRY,1315 +OpenGL/GLES2/NV/sample_locations.py,sha256=3RHJwasv80tNXJEGF2eDnyQFkT9yXvvhJ_baR3kK9S0,2719 +OpenGL/GLES2/NV/sample_mask_override_coverage.py,sha256=e1oCHmdYgz5vc1G3EFdzqynpJuBo8WEOxePxukpUxRw,1248 +OpenGL/GLES2/NV/scissor_exclusive.py,sha256=4pHvvahy-Lr_XniglT4nix-_Nbln1mXjVHO93N6AB7U,1708 +OpenGL/GLES2/NV/shader_atomic_fp16_vector.py,sha256=Yhpl-0y5ytzMFvhDMPPTnXwtZ5o6qdJcKmxpHQItgYk,1087 +OpenGL/GLES2/NV/shader_noperspective_interpolation.py,sha256=HXFfoypf3yjJ6v0rc7M21hFr1AwX-80b46aHjaJpuP8,2016 +OpenGL/GLES2/NV/shader_subgroup_partitioned.py,sha256=kgRT3vG-wlGaKWxFBm2BxS2mPuiU4jAQipUGOSW0nh0,1452 +OpenGL/GLES2/NV/shader_texture_footprint.py,sha256=ntLf2dB6prWvsPNk8SgH1GOVhgQ6ET5_y5AQoZ0vgGo,3935 +OpenGL/GLES2/NV/shading_rate_image.py,sha256=5YjWG8kmsMS0tOKx0G4K_6s91-nhoJxceNxnTCgoQZc,3935 +OpenGL/GLES2/NV/shadow_samplers_array.py,sha256=NDRo19aWCOFWgjDWHMyh99-zlW0vDpyfLZHAJZlA3wc,977 +OpenGL/GLES2/NV/shadow_samplers_cube.py,sha256=Y2jeJGeZfJ7Lfc8YEj06PTJh9VSqANgBC_AVJdch3wY,971 +OpenGL/GLES2/NV/stereo_view_rendering.py,sha256=IFcz942PKNo6IlzLCInnbaBhGPLBPVCJAWDfBQuC1Cs,2158 +OpenGL/GLES2/NV/texture_border_clamp.py,sha256=JVeMqHt0zKAQ9wwbnSS2JJ14V4KL9izaLCo60_Bjt4g,1529 +OpenGL/GLES2/NV/texture_compression_s3tc_update.py,sha256=cvTjJhGwqlq9D-3_Bt_M9C1yXlDeVWlPQ6ipbKZVpno,1285 +OpenGL/GLES2/NV/texture_npot_2D_mipmap.py,sha256=MgVqWmxH2f1zDwx876fgkuYF371S1OMoDtn1FjE0X_g,1558 +OpenGL/GLES2/NV/viewport_array.py,sha256=Sk4Zt9F-V_BixKy6YeWwmGjTUtvb821CaoQcNA3YpjQ,2995 +OpenGL/GLES2/NV/viewport_array2.py,sha256=-zlDWRF3pG1q2Y7BdoEcH_X-3-6kfVREumD4Hpz2RQQ,1939 +OpenGL/GLES2/NV/viewport_swizzle.py,sha256=oc4k1rzgfFT_RwgN2j1Vn0pXQ90znMWBCaa0BWOnKdI,1737 +OpenGL/GLES2/NVX/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/GLES2/NVX/__pycache__/__init__.cpython-312.pyc,, +OpenGL/GLES2/NVX/__pycache__/blend_equation_advanced_multi_draw_buffers.cpython-312.pyc,, +OpenGL/GLES2/NVX/blend_equation_advanced_multi_draw_buffers.py,sha256=aN_njlm1p5I61oJScReO1LQ9Uakky6jJ25_xAqjWhO0,1432 +OpenGL/GLES2/OES/EGL_image.py,sha256=umPpg_ARLr8QdfeUpqt4IvCjeJTTrXYdaRGR4OTvwoM,1535 +OpenGL/GLES2/OES/EGL_image_external.py,sha256=wXM5JP01wIjzVWl2cAGhDAtABdvMGLE0azntdYNlHyE,1611 +OpenGL/GLES2/OES/EGL_image_external_essl3.py,sha256=QfwAgVM6gyIdWZ0oEb-9WPPltAGnL_H3iAguYF56McY,1125 +OpenGL/GLES2/OES/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/GLES2/OES/__pycache__/EGL_image.cpython-312.pyc,, +OpenGL/GLES2/OES/__pycache__/EGL_image_external.cpython-312.pyc,, +OpenGL/GLES2/OES/__pycache__/EGL_image_external_essl3.cpython-312.pyc,, +OpenGL/GLES2/OES/__pycache__/__init__.cpython-312.pyc,, +OpenGL/GLES2/OES/__pycache__/compressed_ETC1_RGB8_sub_texture.cpython-312.pyc,, +OpenGL/GLES2/OES/__pycache__/compressed_ETC1_RGB8_texture.cpython-312.pyc,, +OpenGL/GLES2/OES/__pycache__/compressed_paletted_texture.cpython-312.pyc,, +OpenGL/GLES2/OES/__pycache__/copy_image.cpython-312.pyc,, +OpenGL/GLES2/OES/__pycache__/depth24.cpython-312.pyc,, +OpenGL/GLES2/OES/__pycache__/depth32.cpython-312.pyc,, +OpenGL/GLES2/OES/__pycache__/depth_texture.cpython-312.pyc,, +OpenGL/GLES2/OES/__pycache__/draw_buffers_indexed.cpython-312.pyc,, +OpenGL/GLES2/OES/__pycache__/draw_elements_base_vertex.cpython-312.pyc,, +OpenGL/GLES2/OES/__pycache__/element_index_uint.cpython-312.pyc,, +OpenGL/GLES2/OES/__pycache__/fbo_render_mipmap.cpython-312.pyc,, +OpenGL/GLES2/OES/__pycache__/fragment_precision_high.cpython-312.pyc,, +OpenGL/GLES2/OES/__pycache__/geometry_point_size.cpython-312.pyc,, +OpenGL/GLES2/OES/__pycache__/geometry_shader.cpython-312.pyc,, +OpenGL/GLES2/OES/__pycache__/get_program_binary.cpython-312.pyc,, +OpenGL/GLES2/OES/__pycache__/gpu_shader5.cpython-312.pyc,, +OpenGL/GLES2/OES/__pycache__/mapbuffer.cpython-312.pyc,, +OpenGL/GLES2/OES/__pycache__/packed_depth_stencil.cpython-312.pyc,, +OpenGL/GLES2/OES/__pycache__/primitive_bounding_box.cpython-312.pyc,, +OpenGL/GLES2/OES/__pycache__/required_internalformat.cpython-312.pyc,, +OpenGL/GLES2/OES/__pycache__/rgb8_rgba8.cpython-312.pyc,, +OpenGL/GLES2/OES/__pycache__/sample_shading.cpython-312.pyc,, +OpenGL/GLES2/OES/__pycache__/sample_variables.cpython-312.pyc,, +OpenGL/GLES2/OES/__pycache__/shader_image_atomic.cpython-312.pyc,, +OpenGL/GLES2/OES/__pycache__/shader_io_blocks.cpython-312.pyc,, +OpenGL/GLES2/OES/__pycache__/shader_multisample_interpolation.cpython-312.pyc,, +OpenGL/GLES2/OES/__pycache__/standard_derivatives.cpython-312.pyc,, +OpenGL/GLES2/OES/__pycache__/stencil1.cpython-312.pyc,, +OpenGL/GLES2/OES/__pycache__/stencil4.cpython-312.pyc,, +OpenGL/GLES2/OES/__pycache__/surfaceless_context.cpython-312.pyc,, +OpenGL/GLES2/OES/__pycache__/tessellation_point_size.cpython-312.pyc,, +OpenGL/GLES2/OES/__pycache__/tessellation_shader.cpython-312.pyc,, +OpenGL/GLES2/OES/__pycache__/texture_3D.cpython-312.pyc,, +OpenGL/GLES2/OES/__pycache__/texture_border_clamp.cpython-312.pyc,, +OpenGL/GLES2/OES/__pycache__/texture_buffer.cpython-312.pyc,, +OpenGL/GLES2/OES/__pycache__/texture_compression_astc.cpython-312.pyc,, +OpenGL/GLES2/OES/__pycache__/texture_cube_map_array.cpython-312.pyc,, +OpenGL/GLES2/OES/__pycache__/texture_float.cpython-312.pyc,, +OpenGL/GLES2/OES/__pycache__/texture_float_linear.cpython-312.pyc,, +OpenGL/GLES2/OES/__pycache__/texture_half_float.cpython-312.pyc,, +OpenGL/GLES2/OES/__pycache__/texture_half_float_linear.cpython-312.pyc,, +OpenGL/GLES2/OES/__pycache__/texture_npot.cpython-312.pyc,, +OpenGL/GLES2/OES/__pycache__/texture_stencil8.cpython-312.pyc,, +OpenGL/GLES2/OES/__pycache__/texture_storage_multisample_2d_array.cpython-312.pyc,, +OpenGL/GLES2/OES/__pycache__/texture_view.cpython-312.pyc,, +OpenGL/GLES2/OES/__pycache__/vertex_array_object.cpython-312.pyc,, +OpenGL/GLES2/OES/__pycache__/vertex_half_float.cpython-312.pyc,, +OpenGL/GLES2/OES/__pycache__/vertex_type_10_10_10_2.cpython-312.pyc,, +OpenGL/GLES2/OES/__pycache__/viewport_array.cpython-312.pyc,, +OpenGL/GLES2/OES/compressed_ETC1_RGB8_sub_texture.py,sha256=F0z9nQcw69vKiWGd7wTUMd-HwY93798-6iiHljOM7tU,873 +OpenGL/GLES2/OES/compressed_ETC1_RGB8_texture.py,sha256=7lDoAiHNepN07ebiHqnveDrIiTqnut5jzkA3EIGTjqU,1256 +OpenGL/GLES2/OES/compressed_paletted_texture.py,sha256=-LdUQPMeVKV7-qFjE0MVsv79oJmocXp0jYZlYpyeK_w,2374 +OpenGL/GLES2/OES/copy_image.py,sha256=DWqe3q9VABGWzgYkOrpdP6J4zkS9QU2-MBYtzYB0pT0,1627 +OpenGL/GLES2/OES/depth24.py,sha256=uG7h4maF6gP5vPudyEMiCOU1tAciE1dKBbUz5m7ckfc,845 +OpenGL/GLES2/OES/depth32.py,sha256=BO1XVRPrn1vvs-3_88Ubs-SOA3Uxj7wJIcOb5SFTpV8,845 +OpenGL/GLES2/OES/depth_texture.py,sha256=iJwrWd-ODNJ-k9B6I8EJxuWQbEs1gH0TuTysvcw6YPU,1038 +OpenGL/GLES2/OES/draw_buffers_indexed.py,sha256=Ahm6DxFjDfpV0aKMrj170_n_iePIkpl1FY5u6b7e1i0,1563 +OpenGL/GLES2/OES/draw_elements_base_vertex.py,sha256=Uf4zt7UqvJ3DnHAr0Dh4LwUbPmBWUwvUlDD3jvTrc4w,4247 +OpenGL/GLES2/OES/element_index_uint.py,sha256=sKlpb8Pmp8PDjih-yjmHerRcrbLUf54OdO2QHeIFjHU,974 +OpenGL/GLES2/OES/fbo_render_mipmap.py,sha256=v9H983ngIzZTOovMSfJqk0GzQpUuo_n3wpPMsJ3fCiU,1223 +OpenGL/GLES2/OES/fragment_precision_high.py,sha256=J7KIrUo9T_gtRh58qInHrpJ7fCCFgbtIjW3K5nc7CXE,1098 +OpenGL/GLES2/OES/geometry_point_size.py,sha256=HkzJ-7XQlGf8R2anpcjAQMUOVdaZ8KIp5U9XmV2aIb0,797 +OpenGL/GLES2/OES/geometry_shader.py,sha256=cK6m0mHXIV97jTUEpj4oHhhhkeJ0nTnaEpeFeEQ9dyE,3327 +OpenGL/GLES2/OES/get_program_binary.py,sha256=BfnUXXsa6itDER1ft8siHJ7c32bmPsGB8ohE3tQjzQw,2708 +OpenGL/GLES2/OES/gpu_shader5.py,sha256=jdNRhwcQkHhHNVt0FflOjmTHMcOP4UW9KIU5ihqYGm4,2329 +OpenGL/GLES2/OES/mapbuffer.py,sha256=4kdGrRIWUx404u49toHlUHDR9ZnFOyboA_BaTLHD3rc,970 +OpenGL/GLES2/OES/packed_depth_stencil.py,sha256=5uj2q---P5XaINP3rISTSUb-KP5aBoUEP6lpTAjJJGo,3033 +OpenGL/GLES2/OES/primitive_bounding_box.py,sha256=7WTWpw0-VKXE1AjelHZ8Z1V4HVqn3C4ioia9zOWfQdI,2460 +OpenGL/GLES2/OES/required_internalformat.py,sha256=A8mCGwLYSKkx9k4bcZHLOTqSolJdyHmsgFd3sMUylko,3686 +OpenGL/GLES2/OES/rgb8_rgba8.py,sha256=GmASyFXe-R1mwTeGVqBXl1CCoA5oeAwxzKOv_0IZs8Y,841 +OpenGL/GLES2/OES/sample_shading.py,sha256=jUopxQ6k7EtHhSprj7Yw83-0djV7B-rCtz21NNwN4Mo,1647 +OpenGL/GLES2/OES/sample_variables.py,sha256=nVhowCe_Go4dXdq5QmtVdD66mMVrKDv08GzPFS1ri64,1978 +OpenGL/GLES2/OES/shader_image_atomic.py,sha256=AbMqL9ZLJ9J5qkF-Ry5n-BrLYIuSIUyEI_0yMW3wL3Q,1175 +OpenGL/GLES2/OES/shader_io_blocks.py,sha256=kjGZkAe8NmWgmdI1Bj4H3JRxl0j5akgE15FM0OtoX3s,1923 +OpenGL/GLES2/OES/shader_multisample_interpolation.py,sha256=54wQlbKuNXjbPpXW_KT6A7GLee7oHRcfC90nCdfJw6U,1776 +OpenGL/GLES2/OES/standard_derivatives.py,sha256=x6hOlZokN5zLPPGo-SamBlyZ0BWGlfwIXEejq1PCy6M,1081 +OpenGL/GLES2/OES/stencil1.py,sha256=uZeWJ2Kp-b24zd0Em6slVwWKvfHjd93FRWXqvtTVQbI,851 +OpenGL/GLES2/OES/stencil4.py,sha256=pImpsB8rL-dGfBvjxJ1xnXTBc3dA66amVG3K8BA0BVs,851 +OpenGL/GLES2/OES/surfaceless_context.py,sha256=vKt3E6mvVYxAT15-8nBBz1wx0dsfHpnMxaQHQvKLGrw,1227 +OpenGL/GLES2/OES/tessellation_point_size.py,sha256=UdxQxF8V6mGdORVK2Y783shrls6GVaGfAzajbAMEfh0,821 +OpenGL/GLES2/OES/tessellation_shader.py,sha256=hPNpPix__0dLr9yAGJmWmYcYsvUk1i5_al5B9GavhGs,5332 +OpenGL/GLES2/OES/texture_3D.py,sha256=RX1s70zXoN7phZqBMvZ19pEZkRa0JEY8MfDnyiJK6AQ,1898 +OpenGL/GLES2/OES/texture_border_clamp.py,sha256=8j2iw3dppWgHK8TahVyf-pTIhrRamydcm4CWPX9Gm8c,2995 +OpenGL/GLES2/OES/texture_buffer.py,sha256=LJ4s1zrY2apcYkg5zaCKyCXZFWcesXpNUxkPsa4phH0,2943 +OpenGL/GLES2/OES/texture_compression_astc.py,sha256=5cBBEG2WJdY89zvJ0UEzwuYlv3aTrk0tqKRb12zQ6Hs,1498 +OpenGL/GLES2/OES/texture_cube_map_array.py,sha256=0CNwTN_jtE16RFouei_Bgb95V3ELxNoDcMvJaifpKGg,1985 +OpenGL/GLES2/OES/texture_float.py,sha256=L48lOyEFqPx-DjbXKHp_XH5z7V-073-ZRkRg-6_8JgM,1561 +OpenGL/GLES2/OES/texture_float_linear.py,sha256=WzOUUCXvhVSl3UwKMZZ3mVAyVNA2aD-WpZa7M9ER0mU,1253 +OpenGL/GLES2/OES/texture_half_float.py,sha256=nnOsxi_od2UEYNFdok1ADggsNg8AkdaAEriw15h1Jq0,791 +OpenGL/GLES2/OES/texture_half_float_linear.py,sha256=btRc-iNRPMYshbxyI_8Dhfa0P0gP8RvoZFhat9746JQ,832 +OpenGL/GLES2/OES/texture_npot.py,sha256=Vp_YdqvxzSKyTfMnKBqE_7LWZohDEPIXXaL7wkf_PSw,1482 +OpenGL/GLES2/OES/texture_stencil8.py,sha256=8Bsy33a5tRvbaBFpcpYhZsy66UrUe3a3fUZtLybu1To,1021 +OpenGL/GLES2/OES/texture_storage_multisample_2d_array.py,sha256=YfC8aReeEUf6hx_n8D2-VNHiOSBGgaso5kiTNq3Oqys,1159 +OpenGL/GLES2/OES/texture_view.py,sha256=nNpOdRA2qZVEBv9X9aeYXDm9nnBR-cXmdk3UlKtggLw,1963 +OpenGL/GLES2/OES/vertex_array_object.py,sha256=Iq71bNzFKGuGLkZXMTl9EtwE0C0vxAXmFCjiTr1uwr8,1553 +OpenGL/GLES2/OES/vertex_half_float.py,sha256=Ppt0bWssJ0OZSPTW5kw1Vp8LuCyj-LL0GN9A1q9IjVA,1819 +OpenGL/GLES2/OES/vertex_type_10_10_10_2.py,sha256=WyP-EgrpWlsqw_57yeqWjDImvb2oFUPdOoa9mqNgn8o,1351 +OpenGL/GLES2/OES/viewport_array.py,sha256=Cfd7FLoGXfVuHUxfTqd1Uw7s-72kFLJ9wJfbm7lnuSI,3029 +OpenGL/GLES2/OVR/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/GLES2/OVR/__pycache__/__init__.cpython-312.pyc,, +OpenGL/GLES2/OVR/__pycache__/multiview.cpython-312.pyc,, +OpenGL/GLES2/OVR/__pycache__/multiview2.cpython-312.pyc,, +OpenGL/GLES2/OVR/__pycache__/multiview_multisampled_render_to_texture.cpython-312.pyc,, +OpenGL/GLES2/OVR/multiview.py,sha256=5bHZG5p8i6c35UlFGDBe7kX4R1cgjp7yCPVC5ud5ZUE,2629 +OpenGL/GLES2/OVR/multiview2.py,sha256=pnBv-dBridBTvlQQbI13khx1DKqejxriHoSF1qSXt_M,990 +OpenGL/GLES2/OVR/multiview_multisampled_render_to_texture.py,sha256=MkWn8q7QjOCDoUrdEDRu8nPoSxFGjOwowPSzwSmEBtM,1200 +OpenGL/GLES2/QCOM/YUV_texture_gather.py,sha256=EFV0qO-bLsylsnbXh8xCtEoK9IC4LmI9HNLyD3sx8dQ,1130 +OpenGL/GLES2/QCOM/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/GLES2/QCOM/__pycache__/YUV_texture_gather.cpython-312.pyc,, +OpenGL/GLES2/QCOM/__pycache__/__init__.cpython-312.pyc,, +OpenGL/GLES2/QCOM/__pycache__/alpha_test.cpython-312.pyc,, +OpenGL/GLES2/QCOM/__pycache__/binning_control.cpython-312.pyc,, +OpenGL/GLES2/QCOM/__pycache__/driver_control.cpython-312.pyc,, +OpenGL/GLES2/QCOM/__pycache__/extended_get.cpython-312.pyc,, +OpenGL/GLES2/QCOM/__pycache__/extended_get2.cpython-312.pyc,, +OpenGL/GLES2/QCOM/__pycache__/framebuffer_foveated.cpython-312.pyc,, +OpenGL/GLES2/QCOM/__pycache__/perfmon_global_mode.cpython-312.pyc,, +OpenGL/GLES2/QCOM/__pycache__/shader_framebuffer_fetch_noncoherent.cpython-312.pyc,, +OpenGL/GLES2/QCOM/__pycache__/shader_framebuffer_fetch_rate.cpython-312.pyc,, +OpenGL/GLES2/QCOM/__pycache__/texture_foveated.cpython-312.pyc,, +OpenGL/GLES2/QCOM/__pycache__/texture_foveated_subsampled_layout.cpython-312.pyc,, +OpenGL/GLES2/QCOM/__pycache__/tiled_rendering.cpython-312.pyc,, +OpenGL/GLES2/QCOM/__pycache__/writeonly_rendering.cpython-312.pyc,, +OpenGL/GLES2/QCOM/alpha_test.py,sha256=3ichrvYxRNpfEaGRznEKyFUcnggl_nTtMtp01wCw6ws,1033 +OpenGL/GLES2/QCOM/binning_control.py,sha256=NAcRuvhO1mmr1aCIRdQM6bqRIgQ5CsF9zetV_myzNB8,1060 +OpenGL/GLES2/QCOM/driver_control.py,sha256=OiVEU0Sgx4lX4pejCwgoOo9NnREoM7rbL8f7yP5MbQA,2012 +OpenGL/GLES2/QCOM/extended_get.py,sha256=xcFukd7SDS6HBzjkHvqJWS61F-yW2P61YccVckgUK2s,1591 +OpenGL/GLES2/QCOM/extended_get2.py,sha256=Pt3WUJFhlvhGLHozBxC7B7aItifxlN8GyGzU0nhcRhM,1316 +OpenGL/GLES2/QCOM/framebuffer_foveated.py,sha256=yQBG5izkwolm1vegiOssoyCZO29WqLBPSVvvy4YJhl4,2716 +OpenGL/GLES2/QCOM/perfmon_global_mode.py,sha256=MKuV2RFw5B9ORsOdhMY3nJfuSfxetjE2A1zRZ0vPXzA,803 +OpenGL/GLES2/QCOM/shader_framebuffer_fetch_noncoherent.py,sha256=J2tEv2X1S219t1M5FoZBFpyFSbz_naktgPgVmmU2EAA,1677 +OpenGL/GLES2/QCOM/shader_framebuffer_fetch_rate.py,sha256=JB6nhYm21z8PChiaADsFPAJhGzvIUWI0jNCIB-EBQjg,1776 +OpenGL/GLES2/QCOM/texture_foveated.py,sha256=Oqe9Iq-Qj_imX0wC60xlb0iwjaTKVFfuh6JZjvDmB34,2575 +OpenGL/GLES2/QCOM/texture_foveated_subsampled_layout.py,sha256=ysenflLNof2HfrTE3YeKG-2TiKo0T89bywc2zHwN0fg,1815 +OpenGL/GLES2/QCOM/tiled_rendering.py,sha256=JHRYRPSBChSWIUF4A162dizBTaywjjs9YbIoWK2fL64,5825 +OpenGL/GLES2/QCOM/writeonly_rendering.py,sha256=BCyR4ZbFxU59BAbz4DEwNPn2cT-XdiuxqILxf7wednE,831 +OpenGL/GLES2/VERSION/GLES2_2_0.py,sha256=S44ldxtMozUXlzpHuAEkouZa9mvlhH_YI93wgswKgT4,17097 +OpenGL/GLES2/VERSION/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/GLES2/VERSION/__pycache__/GLES2_2_0.cpython-312.pyc,, +OpenGL/GLES2/VERSION/__pycache__/__init__.cpython-312.pyc,, +OpenGL/GLES2/VIV/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/GLES2/VIV/__pycache__/__init__.cpython-312.pyc,, +OpenGL/GLES2/VIV/__pycache__/shader_binary.cpython-312.pyc,, +OpenGL/GLES2/VIV/shader_binary.py,sha256=ALKCX1OuXjXHF5aOLI46pBBq5zMwhrNuJKQhke34AFg,906 +OpenGL/GLES2/__init__.py,sha256=G9vO0_K0_0ke4Y_KhMy1q01DHHfX4yuN2Uf8QyNsPGM,211 +OpenGL/GLES2/__pycache__/__init__.cpython-312.pyc,, +OpenGL/GLES2/__pycache__/shaders.cpython-312.pyc,, +OpenGL/GLES2/__pycache__/vboimplementation.cpython-312.pyc,, +OpenGL/GLES2/shaders.py,sha256=3a_0UP36wXSgLPgs52izsVB_Mk5fZiYXjr9A4fOemiE,5691 +OpenGL/GLES2/vboimplementation.py,sha256=P9jd4QMQc2t64v_cM-nkp45H1Y3cD7B3vlTuLpQTiEw,755 +OpenGL/GLES3/VERSION/GLES3_3_0.py,sha256=Gu6-f1RgnbONy787u9Q6IhxoRj_u1zCpkqpzlR44oh4,10155 +OpenGL/GLES3/VERSION/GLES3_3_1.py,sha256=PkufVpdzGI2RhvldKswdjF42imGKwRzul22jXetTNmA,7007 +OpenGL/GLES3/VERSION/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/GLES3/VERSION/__pycache__/GLES3_3_0.cpython-312.pyc,, +OpenGL/GLES3/VERSION/__pycache__/GLES3_3_1.cpython-312.pyc,, +OpenGL/GLES3/VERSION/__pycache__/__init__.cpython-312.pyc,, +OpenGL/GLES3/__init__.py,sha256=vhQ3q4Tg5YXujZpegQ-z2TkF3m-tUBUVHhsslWrEJZA,232 +OpenGL/GLES3/__pycache__/__init__.cpython-312.pyc,, +OpenGL/GLES3/__pycache__/vboimplementation.cpython-312.pyc,, +OpenGL/GLES3/vboimplementation.py,sha256=yRLJKB7FBKTA5MKE8dnUc18IaEH2-DKCuJoC5zBo1J8,755 +OpenGL/GLU/EXT/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +OpenGL/GLU/EXT/__pycache__/__init__.cpython-312.pyc,, +OpenGL/GLU/EXT/__pycache__/nurbs_tessellator.cpython-312.pyc,, +OpenGL/GLU/EXT/__pycache__/object_space_tess.cpython-312.pyc,, +OpenGL/GLU/EXT/nurbs_tessellator.py,sha256=UEyUfstieXa9Joc962QLP3RItzMAlaOxmD84QdrOvw8,1092 +OpenGL/GLU/EXT/object_space_tess.py,sha256=L31Dw3wjCNgT5PoP2m4pkHn79V3MiN234nNfmhdJz7k,498 +OpenGL/GLU/__init__.py,sha256=UH17sHws2Ja3IRaKfBDA1lXpusefCYmd31dBdnGH9n0,402 +OpenGL/GLU/__pycache__/__init__.cpython-312.pyc,, +OpenGL/GLU/__pycache__/glunurbs.cpython-312.pyc,, +OpenGL/GLU/__pycache__/glustruct.cpython-312.pyc,, +OpenGL/GLU/__pycache__/projection.cpython-312.pyc,, +OpenGL/GLU/__pycache__/quadrics.cpython-312.pyc,, +OpenGL/GLU/__pycache__/tess.cpython-312.pyc,, +OpenGL/GLU/glunurbs.py,sha256=gnvEk2GSayovsmUTnc4aPKErLiB3W2ejUPrzUCjQTbc,10550 +OpenGL/GLU/glustruct.py,sha256=YC4atsjtcv89rTO-RVTslB_ndr2xkyqoCVGSvh3tRis,3633 +OpenGL/GLU/projection.py,sha256=2kZSElMGcyNK16Bl23fg8nCqAS-5k7VVZm_zPyUU3xU,3216 +OpenGL/GLU/quadrics.py,sha256=AHfNxdChf0H7D508RVlT5kOXDo8kbGbbYk_ldIH8Aow,1977 +OpenGL/GLU/tess.py,sha256=F4Owsz-zcDE3tGdH78voktT7dmYS0SEOPgY8fO3Pea8,9695 +OpenGL/GLUT/__init__.py,sha256=E52SJ8VUQutHOQbUiSDG4s9JDeA3pLP6ZnHWD_x4dbI,293 +OpenGL/GLUT/__pycache__/__init__.cpython-312.pyc,, +OpenGL/GLUT/__pycache__/fonts.cpython-312.pyc,, +OpenGL/GLUT/__pycache__/freeglut.cpython-312.pyc,, +OpenGL/GLUT/__pycache__/osx.cpython-312.pyc,, +OpenGL/GLUT/__pycache__/special.cpython-312.pyc,, +OpenGL/GLUT/fonts.py,sha256=axXy1prbpmA_Op531JbqluTaDE0TaJZy304kDXCRbiQ,966 +OpenGL/GLUT/freeglut.py,sha256=F6FzT_yFvvVkzrWQyHE2KYkDpEHOcksnzONJ8mVVaHs,11323 +OpenGL/GLUT/osx.py,sha256=5W_V095IBlyodH-7Pt-vpiokhTKjG_a_fL6NldUhCI0,519 +OpenGL/GLUT/special.py,sha256=hzfvE0Q5Rrj-hoidOhyDceWEw0zLqouCUnR8DPd7Tkk,13979 +OpenGL/GLX/AMD/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/GLX/AMD/__pycache__/__init__.cpython-312.pyc,, +OpenGL/GLX/AMD/__pycache__/gpu_association.cpython-312.pyc,, +OpenGL/GLX/AMD/gpu_association.py,sha256=IDjhfJ3o7GAJuOlL11hdWrhFbnuq9FXO1NbkGvGy88o,766 +OpenGL/GLX/ARB/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/GLX/ARB/__pycache__/__init__.cpython-312.pyc,, +OpenGL/GLX/ARB/__pycache__/context_flush_control.cpython-312.pyc,, +OpenGL/GLX/ARB/__pycache__/create_context.cpython-312.pyc,, +OpenGL/GLX/ARB/__pycache__/create_context_no_error.cpython-312.pyc,, +OpenGL/GLX/ARB/__pycache__/create_context_profile.cpython-312.pyc,, +OpenGL/GLX/ARB/__pycache__/create_context_robustness.cpython-312.pyc,, +OpenGL/GLX/ARB/__pycache__/fbconfig_float.cpython-312.pyc,, +OpenGL/GLX/ARB/__pycache__/framebuffer_sRGB.cpython-312.pyc,, +OpenGL/GLX/ARB/__pycache__/get_proc_address.cpython-312.pyc,, +OpenGL/GLX/ARB/__pycache__/multisample.cpython-312.pyc,, +OpenGL/GLX/ARB/__pycache__/robustness_application_isolation.cpython-312.pyc,, +OpenGL/GLX/ARB/__pycache__/robustness_share_group_isolation.cpython-312.pyc,, +OpenGL/GLX/ARB/__pycache__/vertex_buffer_object.cpython-312.pyc,, +OpenGL/GLX/ARB/context_flush_control.py,sha256=dyavpOld3hEZN0cZluzyKUnIMX0MNzhK6x7VhpF75Ug,801 +OpenGL/GLX/ARB/create_context.py,sha256=31su0H7gMozDS2vGinMjb5kkPfbCJJeWwopKbCNvIZc,760 +OpenGL/GLX/ARB/create_context_no_error.py,sha256=Hn6BgXW4vqemHG6MiTvOnda0fr9zIxA2FiVYnvL5Jz8,1065 +OpenGL/GLX/ARB/create_context_profile.py,sha256=UNg0tixBF2JC7N8RcxxHi_OOik-2huQeCVrBlgVEGes,807 +OpenGL/GLX/ARB/create_context_robustness.py,sha256=p64v2mHxML4e0Jgndz3awyQfalVC_ZZ15_WKLCLOsBI,825 +OpenGL/GLX/ARB/fbconfig_float.py,sha256=i0mrgrp0_VIT0_b0eRRrTM1xAWQvVpyNhq17D9OM-g4,760 +OpenGL/GLX/ARB/framebuffer_sRGB.py,sha256=hKzYPQYU87d244Gywp_xxxrdb-CX8FwYqJEno8l_G3E,2412 +OpenGL/GLX/ARB/get_proc_address.py,sha256=SPhHdAkZ9GPcqt1eKAHuEKBICNPGF5fBOTDEdaPrcwc,771 +OpenGL/GLX/ARB/multisample.py,sha256=2zAe8J06qZ62pVjf1j77PWUwTIV8aHYepS0ue3V37io,2262 +OpenGL/GLX/ARB/robustness_application_isolation.py,sha256=fuendp-au6cKgx620SR3iUVdlvm5qeZ2GD7egeYGbQA,1679 +OpenGL/GLX/ARB/robustness_share_group_isolation.py,sha256=SGwXbD8eZMO5v4BUYa0V6pXdVvcZrEcoPgNFmajoB9U,866 +OpenGL/GLX/ARB/vertex_buffer_object.py,sha256=zxR0300ZNdHv2ipWpQwiRtdQEyo7mZAFj_fDsDPilQ8,3943 +OpenGL/GLX/DFX/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/GLX/DFX/__pycache__/__init__.cpython-312.pyc,, +OpenGL/GLX/DFX/__pycache__/multisample.cpython-312.pyc,, +OpenGL/GLX/DFX/multisample.py,sha256=x-OV68BBhN9429fWbA-fYfyG1c1EE_UhCmUHvdFDliQ,2906 +OpenGL/GLX/EXT/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/GLX/EXT/__pycache__/__init__.cpython-312.pyc,, +OpenGL/GLX/EXT/__pycache__/buffer_age.cpython-312.pyc,, +OpenGL/GLX/EXT/__pycache__/context_priority.cpython-312.pyc,, +OpenGL/GLX/EXT/__pycache__/create_context_es2_profile.cpython-312.pyc,, +OpenGL/GLX/EXT/__pycache__/create_context_es_profile.cpython-312.pyc,, +OpenGL/GLX/EXT/__pycache__/fbconfig_packed_float.cpython-312.pyc,, +OpenGL/GLX/EXT/__pycache__/framebuffer_sRGB.cpython-312.pyc,, +OpenGL/GLX/EXT/__pycache__/import_context.cpython-312.pyc,, +OpenGL/GLX/EXT/__pycache__/libglvnd.cpython-312.pyc,, +OpenGL/GLX/EXT/__pycache__/no_config_context.cpython-312.pyc,, +OpenGL/GLX/EXT/__pycache__/stereo_tree.cpython-312.pyc,, +OpenGL/GLX/EXT/__pycache__/swap_control.cpython-312.pyc,, +OpenGL/GLX/EXT/__pycache__/swap_control_tear.cpython-312.pyc,, +OpenGL/GLX/EXT/__pycache__/texture_from_pixmap.cpython-312.pyc,, +OpenGL/GLX/EXT/__pycache__/visual_info.cpython-312.pyc,, +OpenGL/GLX/EXT/__pycache__/visual_rating.cpython-312.pyc,, +OpenGL/GLX/EXT/buffer_age.py,sha256=isBlx9axRyo3_OOxu7L4yF_u_sGPm3tIFVrwzll8n1k,736 +OpenGL/GLX/EXT/context_priority.py,sha256=zgSLvVVx4bj4mny4L7U6d2oATfzSpwNERyK85Pf3knY,772 +OpenGL/GLX/EXT/create_context_es2_profile.py,sha256=DgDSUAi8P8In_0_cMpDHl3kxHvI0vgkpIaLTyvqr2LY,830 +OpenGL/GLX/EXT/create_context_es_profile.py,sha256=UTLA7xdAFetv96NltVIdhZTcD5gFTKRaUv7ugFM8sjU,824 +OpenGL/GLX/EXT/fbconfig_packed_float.py,sha256=eTPS_f7__VxW7Ma2JYA7ohJF0b0Bdd_-r57yJOXs9i8,801 +OpenGL/GLX/EXT/framebuffer_sRGB.py,sha256=j9GuppewZS1rIvtVjnW4EoQH6wQUNAJEn9XOSECxQ4w,2412 +OpenGL/GLX/EXT/import_context.py,sha256=PqUQYE5p020k7f8YB1qGDD7V2arvIjpfPgJoNBWhWIc,760 +OpenGL/GLX/EXT/libglvnd.py,sha256=QyX-lJCZ5lHnPYjOUk8pB2Y36tMGBZOCWWA8EJjUsPk,725 +OpenGL/GLX/EXT/no_config_context.py,sha256=YL-N8yW9Q-HJxYhaHix_fghuIc5e9XvixR9EENBglBk,777 +OpenGL/GLX/EXT/stereo_tree.py,sha256=OwlpsfaMNe632FPrxAXZibNcshpSV-_ChodbrjssZ0o,742 +OpenGL/GLX/EXT/swap_control.py,sha256=muBtUmH73pbecKENNpsrI_0ap_rbuo0FjDuEPoCW5xU,1061 +OpenGL/GLX/EXT/swap_control_tear.py,sha256=hDX44WPpSw4jAwnT50Jpla5_FStXKoqt4dtjR1OL4xQ,777 +OpenGL/GLX/EXT/texture_from_pixmap.py,sha256=FL9hIvMaAVfdPcXTmBUB5AUbao9924eMs6GkVwYM0us,789 +OpenGL/GLX/EXT/visual_info.py,sha256=snPW150c6iK1jX3Np1FzkidZs4lnHrDjhaPDCHolHo0,742 +OpenGL/GLX/EXT/visual_rating.py,sha256=vOt61Mz1WV5g4Lk1CKV0gvyy-Tw7PZzx4Vo2Otqrq5s,754 +OpenGL/GLX/INTEL/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/GLX/INTEL/__pycache__/__init__.cpython-312.pyc,, +OpenGL/GLX/INTEL/__pycache__/swap_event.cpython-312.pyc,, +OpenGL/GLX/INTEL/swap_event.py,sha256=7Agoo-faZG-5vvNzH0ZVJB9j2rnD1imm-Weh6Yjfo4Q,748 +OpenGL/GLX/MESA/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/GLX/MESA/__pycache__/__init__.cpython-312.pyc,, +OpenGL/GLX/MESA/__pycache__/agp_offset.cpython-312.pyc,, +OpenGL/GLX/MESA/__pycache__/copy_sub_buffer.cpython-312.pyc,, +OpenGL/GLX/MESA/__pycache__/pixmap_colormap.cpython-312.pyc,, +OpenGL/GLX/MESA/__pycache__/query_renderer.cpython-312.pyc,, +OpenGL/GLX/MESA/__pycache__/release_buffers.cpython-312.pyc,, +OpenGL/GLX/MESA/__pycache__/set_3dfx_mode.cpython-312.pyc,, +OpenGL/GLX/MESA/__pycache__/swap_control.cpython-312.pyc,, +OpenGL/GLX/MESA/agp_offset.py,sha256=KUWUUMmmDM2tZUOAVXGIJ409urftGUurnVtlHtySZQQ,742 +OpenGL/GLX/MESA/copy_sub_buffer.py,sha256=QaoIzLI9Vibu5wvohsfIkrK8BcErWdp4CnlOB13TOyA,771 +OpenGL/GLX/MESA/pixmap_colormap.py,sha256=109TWYat20JWWhijKRimhaiPpH8v2inWOrltm_XYahQ,772 +OpenGL/GLX/MESA/query_renderer.py,sha256=5dOs2nPEJfPYnHPIyLxbISL-6hoZRbJooIOTY2z11-c,766 +OpenGL/GLX/MESA/release_buffers.py,sha256=zTprtYw_PElL89CX-ibybXlrGqsPQz77-fc2_4v9Gpw,772 +OpenGL/GLX/MESA/set_3dfx_mode.py,sha256=1RK4y4aaR9qegL-oSHFptAINR63Atd2LIqKPnaKN10A,759 +OpenGL/GLX/MESA/swap_control.py,sha256=8EVm3uRiyssMV7mO-RMuU1uPCtuBJcmxg58vo2m5ynU,754 +OpenGL/GLX/NV/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/GLX/NV/__pycache__/__init__.cpython-312.pyc,, +OpenGL/GLX/NV/__pycache__/copy_buffer.cpython-312.pyc,, +OpenGL/GLX/NV/__pycache__/copy_image.cpython-312.pyc,, +OpenGL/GLX/NV/__pycache__/delay_before_swap.cpython-312.pyc,, +OpenGL/GLX/NV/__pycache__/float_buffer.cpython-312.pyc,, +OpenGL/GLX/NV/__pycache__/multigpu_context.cpython-312.pyc,, +OpenGL/GLX/NV/__pycache__/multisample_coverage.cpython-312.pyc,, +OpenGL/GLX/NV/__pycache__/present_video.cpython-312.pyc,, +OpenGL/GLX/NV/__pycache__/robustness_video_memory_purge.cpython-312.pyc,, +OpenGL/GLX/NV/__pycache__/swap_group.cpython-312.pyc,, +OpenGL/GLX/NV/__pycache__/video_capture.cpython-312.pyc,, +OpenGL/GLX/NV/__pycache__/video_out.cpython-312.pyc,, +OpenGL/GLX/NV/__pycache__/video_output.cpython-312.pyc,, +OpenGL/GLX/NV/copy_buffer.py,sha256=FBisI0p1YKFnToTcU1uo-VoAX4yuZw7eNH2W4Ef3IfM,1005 +OpenGL/GLX/NV/copy_image.py,sha256=QEaHNjlhW-bwoCZtAXsUBqAIOIHwrxWifkYVKz2VNig,1125 +OpenGL/GLX/NV/delay_before_swap.py,sha256=LamFyCmTouMCgnDvHG2Qs-iimOYHzxKR1NHVrvdZk3k,771 +OpenGL/GLX/NV/float_buffer.py,sha256=5xs3WMTtCzg1wBDrDOwDjceq7l2IPZDhGISgxlBjeOc,4436 +OpenGL/GLX/NV/multigpu_context.py,sha256=1DOG1RXyakmEwbkd4iwyGk9MG804Mh3wQGNfdx1Nlkw,766 +OpenGL/GLX/NV/multisample_coverage.py,sha256=u_lOg4ASEnq2P3sYARuDyl5_5KgZeMlAd8Nach82n7I,2083 +OpenGL/GLX/NV/present_video.py,sha256=7fKPfALjQ1qJ2YBqvd3rGafX1aIgPXlWgWL4eDStTnQ,1578 +OpenGL/GLX/NV/robustness_video_memory_purge.py,sha256=dHC9CPpKHK1wXBC9ys8l6U-M3n0LTQKRMpDjiVyqFp8,2027 +OpenGL/GLX/NV/swap_group.py,sha256=tZqtX14jA3i8vYGjQa_YUNXMctnj-GLvktg5StlewoQ,730 +OpenGL/GLX/NV/video_capture.py,sha256=-Z_u0InXf6FwfM8lZOyzyWjIp6hv3m-gowlTE7O92GQ,1041 +OpenGL/GLX/NV/video_out.py,sha256=1i2gfJMA4RiOjVMdxDusJ6NvW1tqi4vPxxUl5n4v5To,724 +OpenGL/GLX/NV/video_output.py,sha256=6Jkot1Zsx7YB6ZX8Z57F_n8xcRY3N9Bb1RMVC6OSNLc,742 +OpenGL/GLX/OML/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/GLX/OML/__pycache__/__init__.cpython-312.pyc,, +OpenGL/GLX/OML/__pycache__/swap_method.cpython-312.pyc,, +OpenGL/GLX/OML/__pycache__/sync_control.cpython-312.pyc,, +OpenGL/GLX/OML/swap_method.py,sha256=YfzAhs7JtLPmZljvWRZoaC3fhohaycGAhBBsB7zBc9U,742 +OpenGL/GLX/OML/sync_control.py,sha256=DvUgwhWYv_xEu3JKsYOdc9l0rHoTwaFh7TZK8y1cX4o,748 +OpenGL/GLX/SGI/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/GLX/SGI/__pycache__/__init__.cpython-312.pyc,, +OpenGL/GLX/SGI/__pycache__/cushion.cpython-312.pyc,, +OpenGL/GLX/SGI/__pycache__/make_current_read.cpython-312.pyc,, +OpenGL/GLX/SGI/__pycache__/swap_control.cpython-312.pyc,, +OpenGL/GLX/SGI/__pycache__/video_sync.cpython-312.pyc,, +OpenGL/GLX/SGI/cushion.py,sha256=_5m3AVSCmNg2eMWri1jKw0a0pn5q7cZjPfyDnBORD4Q,719 +OpenGL/GLX/SGI/make_current_read.py,sha256=G0C1OyxKH4QvPvNytgYJ8_jwbgYvgTaxearXsTOGSQY,777 +OpenGL/GLX/SGI/swap_control.py,sha256=lyTELrwp48vka3BXFEr0Q0-9IJj58Z8Ku6qHT4sdx3g,748 +OpenGL/GLX/SGI/video_sync.py,sha256=0ggsq6aaeKBpo5ywbIgxGL0ZArnhxbIcsjTjEcFMZ3U,736 +OpenGL/GLX/SGIS/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/GLX/SGIS/__pycache__/__init__.cpython-312.pyc,, +OpenGL/GLX/SGIS/__pycache__/blended_overlay.cpython-312.pyc,, +OpenGL/GLX/SGIS/__pycache__/multisample.cpython-312.pyc,, +OpenGL/GLX/SGIS/__pycache__/shared_multisample.cpython-312.pyc,, +OpenGL/GLX/SGIS/blended_overlay.py,sha256=f9zqqRgyoeDaChR6LqGFzw94S0Tdqq86Q6XuLaCB65c,772 +OpenGL/GLX/SGIS/multisample.py,sha256=KBZ18_4tvyvVHFFqX9f2x1Eu1YcGgNjkB7NjrMxn3RE,2268 +OpenGL/GLX/SGIS/shared_multisample.py,sha256=S15_1Q8HJCvG9cf1yYquPkjsgzmqmvJzTHWkKufJlWM,4381 +OpenGL/GLX/SGIX/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/GLX/SGIX/__pycache__/__init__.cpython-312.pyc,, +OpenGL/GLX/SGIX/__pycache__/dmbuffer.cpython-312.pyc,, +OpenGL/GLX/SGIX/__pycache__/fbconfig.cpython-312.pyc,, +OpenGL/GLX/SGIX/__pycache__/hyperpipe.cpython-312.pyc,, +OpenGL/GLX/SGIX/__pycache__/pbuffer.cpython-312.pyc,, +OpenGL/GLX/SGIX/__pycache__/swap_barrier.cpython-312.pyc,, +OpenGL/GLX/SGIX/__pycache__/swap_group.cpython-312.pyc,, +OpenGL/GLX/SGIX/__pycache__/video_resize.cpython-312.pyc,, +OpenGL/GLX/SGIX/__pycache__/video_source.cpython-312.pyc,, +OpenGL/GLX/SGIX/__pycache__/visual_select_group.cpython-312.pyc,, +OpenGL/GLX/SGIX/dmbuffer.py,sha256=gdZnM73Cfz882vWPcUDayLtctDretqwGoF_XuAurztM,731 +OpenGL/GLX/SGIX/fbconfig.py,sha256=dTaBWA6uGCE8zrl3JztwqgwHJPp8f5IzXlUfCNYL3Hg,731 +OpenGL/GLX/SGIX/hyperpipe.py,sha256=rHaunw_wudgWIkhvllEcZZLr1Lon2W3Tkrgci5ZBDoM,737 +OpenGL/GLX/SGIX/pbuffer.py,sha256=QW3fnNVq-A697BpMSu7onYhpbrXxmIZrNgh-rPEIa4c,725 +OpenGL/GLX/SGIX/swap_barrier.py,sha256=66ygUNRrx12Ie814qFH6BUEOk8snp33_alTMiPWVyKI,754 +OpenGL/GLX/SGIX/swap_group.py,sha256=OrbiommQzk8dQ-K0vMtwr_AoMtYoCj0AEiSwuF0ltdk,742 +OpenGL/GLX/SGIX/video_resize.py,sha256=MPh32Ub9eSS3kf_KWiMbMIqW29iRwYLzlUsxJwWLOFM,754 +OpenGL/GLX/SGIX/video_source.py,sha256=aCgykNvtGtjuvChl2YP6DY5K5O4uF_Rq41KNkhH_bu8,754 +OpenGL/GLX/SGIX/visual_select_group.py,sha256=nhJ9GhxYelC_QYVKQ5nSadhufYqhpaMDmQ__8ykMWCQ,795 +OpenGL/GLX/SUN/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/GLX/SUN/__pycache__/__init__.cpython-312.pyc,, +OpenGL/GLX/SUN/__pycache__/get_transparent_index.cpython-312.pyc,, +OpenGL/GLX/SUN/get_transparent_index.py,sha256=1lQksW_gbwAoSZ60dA1unYYPBu5JQg4efl29c46TjAE,801 +OpenGL/GLX/VERSION/GLX_1_0.py,sha256=LpdRLNaYvTmx-JmcQ1PmGeDamf8WHBkZWK79pdOdL-E,741 +OpenGL/GLX/VERSION/GLX_1_1.py,sha256=Z0k-PwUVV4xZ4_HhYDSERMiGf1QvUtrjaXZTsEUGcPk,741 +OpenGL/GLX/VERSION/GLX_1_2.py,sha256=ltNdhSHqTMmtRF7dBDPxA4WOGhYS2bLu3h4-wRWQfvs,741 +OpenGL/GLX/VERSION/GLX_1_3.py,sha256=T0RUAQWs5mRG1tAynmiGN321xGFuVPP6euo3RwfWSY0,741 +OpenGL/GLX/VERSION/GLX_1_4.py,sha256=SzSZCMUP_NVMMmMUYKDYMHV9JDGknfMl5oIeOwDIUEw,741 +OpenGL/GLX/VERSION/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/GLX/VERSION/__pycache__/GLX_1_0.cpython-312.pyc,, +OpenGL/GLX/VERSION/__pycache__/GLX_1_1.cpython-312.pyc,, +OpenGL/GLX/VERSION/__pycache__/GLX_1_2.cpython-312.pyc,, +OpenGL/GLX/VERSION/__pycache__/GLX_1_3.cpython-312.pyc,, +OpenGL/GLX/VERSION/__pycache__/GLX_1_4.cpython-312.pyc,, +OpenGL/GLX/VERSION/__pycache__/__init__.cpython-312.pyc,, +OpenGL/GLX/__init__.py,sha256=_GxypFyNm8LBSupBE1qgAZNCQxrSy1W59FuVAPEm5Fw,317 +OpenGL/GLX/__pycache__/__init__.cpython-312.pyc,, +OpenGL/Tk/__init__.py,sha256=9aMO0iBtltjeFNoZQo1Ztd65QC-xejnsERip-ddxsm0,16800 +OpenGL/Tk/__pycache__/__init__.cpython-312.pyc,, +OpenGL/WGL/AMD/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/WGL/AMD/__pycache__/__init__.cpython-312.pyc,, +OpenGL/WGL/AMD/__pycache__/gpu_association.cpython-312.pyc,, +OpenGL/WGL/AMD/gpu_association.py,sha256=_RZ_RqcO_h6fplEBuGJ9XT5uAPOW1UNRAKRim53v7tA,766 +OpenGL/WGL/ARB/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/WGL/ARB/__pycache__/__init__.cpython-312.pyc,, +OpenGL/WGL/ARB/__pycache__/buffer_region.cpython-312.pyc,, +OpenGL/WGL/ARB/__pycache__/context_flush_control.cpython-312.pyc,, +OpenGL/WGL/ARB/__pycache__/create_context.cpython-312.pyc,, +OpenGL/WGL/ARB/__pycache__/create_context_no_error.cpython-312.pyc,, +OpenGL/WGL/ARB/__pycache__/create_context_profile.cpython-312.pyc,, +OpenGL/WGL/ARB/__pycache__/create_context_robustness.cpython-312.pyc,, +OpenGL/WGL/ARB/__pycache__/extensions_string.cpython-312.pyc,, +OpenGL/WGL/ARB/__pycache__/framebuffer_sRGB.cpython-312.pyc,, +OpenGL/WGL/ARB/__pycache__/make_current_read.cpython-312.pyc,, +OpenGL/WGL/ARB/__pycache__/multisample.cpython-312.pyc,, +OpenGL/WGL/ARB/__pycache__/pbuffer.cpython-312.pyc,, +OpenGL/WGL/ARB/__pycache__/pixel_format.cpython-312.pyc,, +OpenGL/WGL/ARB/__pycache__/pixel_format_float.cpython-312.pyc,, +OpenGL/WGL/ARB/__pycache__/render_texture.cpython-312.pyc,, +OpenGL/WGL/ARB/__pycache__/robustness_application_isolation.cpython-312.pyc,, +OpenGL/WGL/ARB/__pycache__/robustness_share_group_isolation.cpython-312.pyc,, +OpenGL/WGL/ARB/buffer_region.py,sha256=Y9D35gKIVcY_S7vy-UnqSr07YD2urD6WaPwM3CR9AA8,754 +OpenGL/WGL/ARB/context_flush_control.py,sha256=Z4RLUPRRZc_eeKLkFzuU8bzcZfunJ4lplD5oJPX_rD4,801 +OpenGL/WGL/ARB/create_context.py,sha256=X8qFITIvx-qxDsvsidr0x5q7BKFWMzV2MSOw9YI5OA4,760 +OpenGL/WGL/ARB/create_context_no_error.py,sha256=hmJMMASMgg5W8kctcuXGeNGW-NFKziFHIQDcf8_GHzg,1065 +OpenGL/WGL/ARB/create_context_profile.py,sha256=YMF2jyilTy8W0h20DJlIvQwKMpb00Fcf5GlSWvSqVXA,807 +OpenGL/WGL/ARB/create_context_robustness.py,sha256=SZ5GDcHFQApNJ6Jc0ANxlfgV7P9QpTuWdYYcrcGR_bM,825 +OpenGL/WGL/ARB/extensions_string.py,sha256=8qH_GWZQXZqR4PLH6lIkEz74vZU67llCxz25btFV-2U,778 +OpenGL/WGL/ARB/framebuffer_sRGB.py,sha256=BRyQ6bJTO8pIcS25lE7kJFX96ornDmOfgppL8DlE9js,2412 +OpenGL/WGL/ARB/make_current_read.py,sha256=_J65ulMhWBgNZHv6bkP5S--AcGDzbPvHFq21iBpha2A,777 +OpenGL/WGL/ARB/multisample.py,sha256=lWxEXXcef5163sJ5fOzL-t8HflZZap0lc0PFGw961A0,2262 +OpenGL/WGL/ARB/pbuffer.py,sha256=kYuSj_lNspkTtBWvWA6EXzsJsUXdWj5RCmiI3TQ5Mco,719 +OpenGL/WGL/ARB/pixel_format.py,sha256=QoUhG_5E96R_1c7-8vrxCyGo1t3BCJPH0uDsA625bBs,748 +OpenGL/WGL/ARB/pixel_format_float.py,sha256=qQqPBqFlXrUhZrh_E_GBQeiA7qQmP191gzK35d4eX3g,783 +OpenGL/WGL/ARB/render_texture.py,sha256=-686ZvtavhP6nevk42S9wuLVwjC2mKjx48hWzeN47Tg,760 +OpenGL/WGL/ARB/robustness_application_isolation.py,sha256=0WnjQ2BBfNr9aOpmy4H42SH6IoTlg2WimRedmYQJtRo,1679 +OpenGL/WGL/ARB/robustness_share_group_isolation.py,sha256=gvZ-f3yRmP35OY2mA71Y9KXRO7vA_ClS2ZzwPW9ISx4,866 +OpenGL/WGL/ATI/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/WGL/ATI/__pycache__/__init__.cpython-312.pyc,, +OpenGL/WGL/ATI/__pycache__/pixel_format_float.cpython-312.pyc,, +OpenGL/WGL/ATI/__pycache__/render_texture_rectangle.cpython-312.pyc,, +OpenGL/WGL/ATI/pixel_format_float.py,sha256=5Pt6FjG_eFlcI7LwChGCen2Tzps9PejCM_tac5UNbOA,783 +OpenGL/WGL/ATI/render_texture_rectangle.py,sha256=EvE27xYC-71GPieZcxs6ks91iIRvazw3fBs2ZLOArMg,819 +OpenGL/WGL/DFX/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/WGL/DFX/__pycache__/__init__.cpython-312.pyc,, +OpenGL/WGL/DFX/__pycache__/multisample.cpython-312.pyc,, +OpenGL/WGL/DFX/multisample.py,sha256=ngOLPIP2dDycByIIpPPZoa9tzat0aqTVfh7Gf5RYWbw,2906 +OpenGL/WGL/DL/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/WGL/DL/__pycache__/__init__.cpython-312.pyc,, +OpenGL/WGL/DL/__pycache__/stereo_control.cpython-312.pyc,, +OpenGL/WGL/DL/stereo_control.py,sha256=XMez7JWWNZ1VubsPwOLuKWHnbQjToeorxsJxL85Fh5Y,754 +OpenGL/WGL/EXT/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/WGL/EXT/__pycache__/__init__.cpython-312.pyc,, +OpenGL/WGL/EXT/__pycache__/colorspace.cpython-312.pyc,, +OpenGL/WGL/EXT/__pycache__/create_context_es2_profile.cpython-312.pyc,, +OpenGL/WGL/EXT/__pycache__/create_context_es_profile.cpython-312.pyc,, +OpenGL/WGL/EXT/__pycache__/depth_float.cpython-312.pyc,, +OpenGL/WGL/EXT/__pycache__/display_color_table.cpython-312.pyc,, +OpenGL/WGL/EXT/__pycache__/extensions_string.cpython-312.pyc,, +OpenGL/WGL/EXT/__pycache__/framebuffer_sRGB.cpython-312.pyc,, +OpenGL/WGL/EXT/__pycache__/make_current_read.cpython-312.pyc,, +OpenGL/WGL/EXT/__pycache__/multisample.cpython-312.pyc,, +OpenGL/WGL/EXT/__pycache__/pbuffer.cpython-312.pyc,, +OpenGL/WGL/EXT/__pycache__/pixel_format.cpython-312.pyc,, +OpenGL/WGL/EXT/__pycache__/pixel_format_packed_float.cpython-312.pyc,, +OpenGL/WGL/EXT/__pycache__/swap_control.cpython-312.pyc,, +OpenGL/WGL/EXT/__pycache__/swap_control_tear.cpython-312.pyc,, +OpenGL/WGL/EXT/colorspace.py,sha256=mf1xQ8uKMkvkpGiyS6i2RMiTubmuZ2LcOnfkZwCo07g,737 +OpenGL/WGL/EXT/create_context_es2_profile.py,sha256=laRJbRgrzYst6ahlrw73BRuhVBpAiCyn1KkZedJ1tvQ,830 +OpenGL/WGL/EXT/create_context_es_profile.py,sha256=Z6BKRhR0VgfmzVo0o2cV0445T-wj9AxBC4q9kCbBJIw,824 +OpenGL/WGL/EXT/depth_float.py,sha256=Y-z36vTnLTMkOZZPbcAhJLWOfQwDwJfSM8n-p8RZdOQ,742 +OpenGL/WGL/EXT/display_color_table.py,sha256=Qd7rX7QJJ7KTTlLOKebdUDOLBjDVbBt3ktaZo9m-qm8,789 +OpenGL/WGL/EXT/extensions_string.py,sha256=z5m7Cj1rAgxNVIEpJHuQyD1Q_SqqdmLEJaCjvEehQQw,778 +OpenGL/WGL/EXT/framebuffer_sRGB.py,sha256=_-D_8cGA9sziEsuut7ahpj2qEIliRynn_jkLK-vpv8Q,2412 +OpenGL/WGL/EXT/make_current_read.py,sha256=TaxG5H3jjko20cbPUxNmkm0fFe2c5eQTTsAZInTFfT0,777 +OpenGL/WGL/EXT/multisample.py,sha256=HCiKlZP6JcrzUc-ql14KxcQZDR_eBaPjCLEKqkGiHY0,743 +OpenGL/WGL/EXT/pbuffer.py,sha256=5JWzyYjAHxUeKUEUK5ZL2h9IELv7chZuKQyq74Ejk3k,719 +OpenGL/WGL/EXT/pixel_format.py,sha256=FUvRdr4L2kZ5KMS9Ttbf7WXdfRLNJLye4dflC9_clL4,748 +OpenGL/WGL/EXT/pixel_format_packed_float.py,sha256=svDgmDe68jfvbAKrBqaOd68ZvTu7qKb7P4DeVnl1Lqo,824 +OpenGL/WGL/EXT/swap_control.py,sha256=sPeyS8DWRa0doFWfLkzqEHYhp_Zyi-iJcrpRxfcZMmI,1061 +OpenGL/WGL/EXT/swap_control_tear.py,sha256=xqOP48HWMUWA8ayPL5IoUxSxOfxQmmS3wMeit66urE8,777 +OpenGL/WGL/I3D/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/WGL/I3D/__pycache__/__init__.cpython-312.pyc,, +OpenGL/WGL/I3D/__pycache__/digital_video_control.cpython-312.pyc,, +OpenGL/WGL/I3D/__pycache__/gamma.cpython-312.pyc,, +OpenGL/WGL/I3D/__pycache__/genlock.cpython-312.pyc,, +OpenGL/WGL/I3D/__pycache__/image_buffer.cpython-312.pyc,, +OpenGL/WGL/I3D/__pycache__/swap_frame_lock.cpython-312.pyc,, +OpenGL/WGL/I3D/__pycache__/swap_frame_usage.cpython-312.pyc,, +OpenGL/WGL/I3D/digital_video_control.py,sha256=-k7_VKrt3tFT5l94YjJQxMiHc_-YEk5IxNhzu9dNxmI,801 +OpenGL/WGL/I3D/gamma.py,sha256=jx8TKEauaFj2HwvdjUBkRaeVXwprcP0a0H1PmRX8j5g,707 +OpenGL/WGL/I3D/genlock.py,sha256=GMbyGQew-v8Dz4xQY4-SzjAu6qN5MiXnNMIzs_Q9lwE,719 +OpenGL/WGL/I3D/image_buffer.py,sha256=EiJ5Rgx21xI0qVU3otqR2OEFyb73aiTLBQkXtDGo6ig,748 +OpenGL/WGL/I3D/swap_frame_lock.py,sha256=GLp1JPavf551Qd_-t716W-ladidbtVjai97XC-JhJwQ,765 +OpenGL/WGL/I3D/swap_frame_usage.py,sha256=qUJgN5TunXkrpA4djodJCtcXnS8wwkWEfA8l25byUek,771 +OpenGL/WGL/NV/DX_interop.py,sha256=BBugPpv4qKSwKb0ewZQxsDTbNnJ6GtDk1KYPm3OyYxg,730 +OpenGL/WGL/NV/DX_interop2.py,sha256=Aasf7nNIKDEq17zIO4qQygXVs1h31Fkt3HYW-S_PRo0,736 +OpenGL/WGL/NV/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/WGL/NV/__pycache__/DX_interop.cpython-312.pyc,, +OpenGL/WGL/NV/__pycache__/DX_interop2.cpython-312.pyc,, +OpenGL/WGL/NV/__pycache__/__init__.cpython-312.pyc,, +OpenGL/WGL/NV/__pycache__/copy_image.cpython-312.pyc,, +OpenGL/WGL/NV/__pycache__/delay_before_swap.cpython-312.pyc,, +OpenGL/WGL/NV/__pycache__/float_buffer.cpython-312.pyc,, +OpenGL/WGL/NV/__pycache__/gpu_affinity.cpython-312.pyc,, +OpenGL/WGL/NV/__pycache__/multigpu_context.cpython-312.pyc,, +OpenGL/WGL/NV/__pycache__/multisample_coverage.cpython-312.pyc,, +OpenGL/WGL/NV/__pycache__/present_video.cpython-312.pyc,, +OpenGL/WGL/NV/__pycache__/render_depth_texture.cpython-312.pyc,, +OpenGL/WGL/NV/__pycache__/render_texture_rectangle.cpython-312.pyc,, +OpenGL/WGL/NV/__pycache__/swap_group.cpython-312.pyc,, +OpenGL/WGL/NV/__pycache__/vertex_array_range.cpython-312.pyc,, +OpenGL/WGL/NV/__pycache__/video_capture.cpython-312.pyc,, +OpenGL/WGL/NV/__pycache__/video_output.cpython-312.pyc,, +OpenGL/WGL/NV/copy_image.py,sha256=eaXWKwQbHYMrRGwzI9P_O8C1BaXG-s4giae214rG0Z0,1125 +OpenGL/WGL/NV/delay_before_swap.py,sha256=9IbUXc3UDa2qIaWXn2BUADguq8ZqFNTI3dIwrG3rong,771 +OpenGL/WGL/NV/float_buffer.py,sha256=rC37YbHCJLKjgRmv41ituUc8lRVB7xOiNcdwQ6t5CVs,4436 +OpenGL/WGL/NV/gpu_affinity.py,sha256=Vs6_rtYBIB1d58Cbhvryp2LUZ0be-K0zmFUBK19VeVk,742 +OpenGL/WGL/NV/multigpu_context.py,sha256=YO6p2A1sfeIWVBYXF-Id6wuGxFMly9DqkEFtpRuYP1c,766 +OpenGL/WGL/NV/multisample_coverage.py,sha256=YzEVMDsFkP-fUH5jwA_HwPK8HRyZ0OEEj11-zg4cH2U,2083 +OpenGL/WGL/NV/present_video.py,sha256=N1z3eUD9TmuZVqwy8qNswAU4Jfg3pX9I__AO6Kpl3wo,1578 +OpenGL/WGL/NV/render_depth_texture.py,sha256=eMMacLayN4WVbKDFrELFTXlp4ZeZeUj7htwhyVBcP6c,789 +OpenGL/WGL/NV/render_texture_rectangle.py,sha256=FTZ9nEAUZy8s5HfqD8A_c3oYUKne3PnxtXvTNLgIhcg,813 +OpenGL/WGL/NV/swap_group.py,sha256=STzQXGpAXLj5Mj1fOBHI46UkxxLs9Wb7XfUlPwe62Pc,730 +OpenGL/WGL/NV/vertex_array_range.py,sha256=EmUwsYhf-1H7RfhbFBpVnPGRImq6ZdXsS3j3xHD5fbs,4786 +OpenGL/WGL/NV/video_capture.py,sha256=RaRKwf06bPAajwdQtnQXrV6onvm7Lxa_gUxgdmX8a54,1041 +OpenGL/WGL/NV/video_output.py,sha256=xnfB2zraT0hQc-3RNkzK9hRlV0C2wstZZB2P1E_2Q3Y,742 +OpenGL/WGL/OML/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/WGL/OML/__pycache__/__init__.cpython-312.pyc,, +OpenGL/WGL/OML/__pycache__/sync_control.cpython-312.pyc,, +OpenGL/WGL/OML/sync_control.py,sha256=9Pm53ng1HONHoeWzt-JA76o-KsCpXDFAUjCBPVXjm6Y,748 +OpenGL/WGL/VERSION/WGL_1_0.py,sha256=vghHUD2tELvyPXssLjaIwArmC19CImiFaE_jL918huw,780 +OpenGL/WGL/VERSION/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/WGL/VERSION/__pycache__/WGL_1_0.cpython-312.pyc,, +OpenGL/WGL/VERSION/__pycache__/__init__.cpython-312.pyc,, +OpenGL/WGL/__init__.py,sha256=2YxL1dG2dDyB44Ov9muRyVTQUWq7g67HSjRvKV2p5LE,85 +OpenGL/WGL/__pycache__/__init__.cpython-312.pyc,, +OpenGL/__init__.py,sha256=TfrCuqdQf1x0lcAKBKPIrwZXKkEowd_0QC6aLnF8gVU,12634 +OpenGL/__pycache__/__init__.cpython-312.pyc,, +OpenGL/__pycache__/_bytes.cpython-312.pyc,, +OpenGL/__pycache__/_configflags.cpython-312.pyc,, +OpenGL/__pycache__/_null.cpython-312.pyc,, +OpenGL/__pycache__/_opaque.cpython-312.pyc,, +OpenGL/__pycache__/acceleratesupport.cpython-312.pyc,, +OpenGL/__pycache__/constant.cpython-312.pyc,, +OpenGL/__pycache__/constants.cpython-312.pyc,, +OpenGL/__pycache__/contextdata.cpython-312.pyc,, +OpenGL/__pycache__/converters.cpython-312.pyc,, +OpenGL/__pycache__/error.cpython-312.pyc,, +OpenGL/__pycache__/extensions.cpython-312.pyc,, +OpenGL/__pycache__/images.cpython-312.pyc,, +OpenGL/__pycache__/latebind.cpython-312.pyc,, +OpenGL/__pycache__/lazywrapper.cpython-312.pyc,, +OpenGL/__pycache__/logs.cpython-312.pyc,, +OpenGL/__pycache__/plugins.cpython-312.pyc,, +OpenGL/__pycache__/version.cpython-312.pyc,, +OpenGL/__pycache__/wrapper.cpython-312.pyc,, +OpenGL/_bytes.py,sha256=-7En82Yn0JxZBr8Rd-tgRhISzk00_vNgXJ_Qr7RQSGQ,2621 +OpenGL/_configflags.py,sha256=-EG49gelg--JcOcTmdtBpU9Bk_X2_oqv6tDWU_Sj-Sc,450 +OpenGL/_null.py,sha256=UoeBiQ14A5_bXqQPzTFqrjehUUMU-VBFZSR3xw-02MI,72 +OpenGL/_opaque.py,sha256=j6-aLuYtEYoBUQkO1UvkyKbBFCEa_hFgjR7F5l3GXWs,850 +OpenGL/acceleratesupport.py,sha256=XggPhDTrB_7B0X9qbUhjP9PbHv0BcZMycgGNpGhhOoc,883 +OpenGL/arrays/__init__.py,sha256=Z_PwaKXCgPbIi02WBDSE5WO7UHXGPdWz3HEoY-75LN0,637 +OpenGL/arrays/__pycache__/__init__.cpython-312.pyc,, +OpenGL/arrays/__pycache__/_arrayconstants.cpython-312.pyc,, +OpenGL/arrays/__pycache__/_buffers.cpython-312.pyc,, +OpenGL/arrays/__pycache__/_strings.cpython-312.pyc,, +OpenGL/arrays/__pycache__/arraydatatype.cpython-312.pyc,, +OpenGL/arrays/__pycache__/arrayhelpers.cpython-312.pyc,, +OpenGL/arrays/__pycache__/buffers.cpython-312.pyc,, +OpenGL/arrays/__pycache__/ctypesarrays.cpython-312.pyc,, +OpenGL/arrays/__pycache__/ctypesparameters.cpython-312.pyc,, +OpenGL/arrays/__pycache__/ctypespointers.cpython-312.pyc,, +OpenGL/arrays/__pycache__/formathandler.cpython-312.pyc,, +OpenGL/arrays/__pycache__/lists.cpython-312.pyc,, +OpenGL/arrays/__pycache__/nones.cpython-312.pyc,, +OpenGL/arrays/__pycache__/numbers.cpython-312.pyc,, +OpenGL/arrays/__pycache__/numpybuffers.cpython-312.pyc,, +OpenGL/arrays/__pycache__/numpymodule.cpython-312.pyc,, +OpenGL/arrays/__pycache__/strings.cpython-312.pyc,, +OpenGL/arrays/__pycache__/vbo.cpython-312.pyc,, +OpenGL/arrays/_arrayconstants.py,sha256=5sO-3V8J5pMUdk2y66yWBCvu0jonyJ3p8uTs_wT4wvA,1439 +OpenGL/arrays/_buffers.py,sha256=JHRExZJcWn0XcSlx_pnwG7sdGDyA_-ibH9wvktMPVFc,3351 +OpenGL/arrays/_strings.py,sha256=4NxJfzuTbRHLp30ws9G2RMjv_Qvhqk12DdomLtHaINg,2306 +OpenGL/arrays/arraydatatype.py,sha256=sQHelLBLU4VPNZo4EAQxWvfcoDPSfesVKsbKlvpHx38,13964 +OpenGL/arrays/arrayhelpers.py,sha256=3Mt9oJzqofZtvqBTntpp7bZ_1QD2eDaVpn_cyRqAnYg,7253 +OpenGL/arrays/buffers.py,sha256=LNCvOsCgkcjpt3Clc26Q1GFOESt36QH0uCEdMrVoaaI,4349 +OpenGL/arrays/ctypesarrays.py,sha256=zc7jZq0D_C_PCZtWprPB_-tutIOiXCImsjGUlSZb3Ho,5386 +OpenGL/arrays/ctypesparameters.py,sha256=29TtIPeOok0417uIZrTQ_X75w7D1UcLMqqRbpdBA80U,5554 +OpenGL/arrays/ctypespointers.py,sha256=bJWq1od8wrljjdSeZwXrcJhQBDBXAJnnwZX7j3pEq24,3445 +OpenGL/arrays/formathandler.py,sha256=t9FUEkZUBrJPCnW0nI_jatdlR4A-uSp6WrCUOuaEi5E,3836 +OpenGL/arrays/lists.py,sha256=-u6AmzuFu2z9caYCvz5SLt4G1ejBHO6sS9BM3aF7x78,7811 +OpenGL/arrays/nones.py,sha256=pEqaKiRPVPWh6rMkskxEnwOPzde8BtFrfqq7ng0S-W0,2480 +OpenGL/arrays/numbers.py,sha256=F8zkoyib_2zl52jlttJ4xSEMTLHYaJtg1bL83vkLKxI,3703 +OpenGL/arrays/numpybuffers.py,sha256=1kdIDwQWgCpATgnpEOC18NrGcFjOY1ONh4BwYyAl1N0,4805 +OpenGL/arrays/numpymodule.py,sha256=-ZTQDS30C2a2eUqm3gKtvSVYmfD5gCJmMp86IwQsgmk,10646 +OpenGL/arrays/strings.py,sha256=wdWv8BYxTyxiodO-P_vILNHxrqlx90hToYapMdJT0CQ,3687 +OpenGL/arrays/vbo.py,sha256=g-agaOlRFDk3f7cbuxQ8-UXhiQ2llzBZ-yY8VWo26zc,19443 +OpenGL/constant.py,sha256=L2jWgMu6QjNF2ycvy37k9gcReXupTY79gSipONrzzS0,3305 +OpenGL/constants.py,sha256=i-HtdPKOZ7CsGMhIEWddL1HG7kyzyXV2MI8MPBxm9tw,149 +OpenGL/contextdata.py,sha256=Ejs_dlQDcjzOnaraulThsDPhvXX4prlMeY4KZaN1s1g,4545 +OpenGL/converters.py,sha256=H3hRoHvPPdbwlPzP34VFHbeDUTj-ExP15Pf2qaxdSNg,12793 +OpenGL/error.py,sha256=QJ4UFqWDQJ2-mfy3j86W5u0Pzf2C-jSSNFaS79joHoY,9612 +OpenGL/extensions.py,sha256=o4jl2zRIOewObvoDAsjCGUFkviV16drOl292DGUUdSU,9506 +OpenGL/images.py,sha256=Ih2TEjOidqsoabqL8z2Cmc6CNikfyH0LFDaYfffLhNQ,6892 +OpenGL/latebind.py,sha256=kQmn9XnV8x0NWOun3CJmpLt2TJYSPDsXF9olR-vCOAU,2530 +OpenGL/lazywrapper.py,sha256=KrZXet6eVqx3LzhcAkqOf5uLZDF25oTJUbVVs-Tcaag,2119 +OpenGL/logs.py,sha256=43pOZmdOFeEit6Lb0aRinRNy0WZMie0_WMe5Xv4xdnM,3159 +OpenGL/osmesa/__init__.py,sha256=TMA2PvWIwTaB4lw7CVjBzMGGcMUNZg4Vr7Zj1nFpayg,76 +OpenGL/osmesa/__pycache__/__init__.cpython-312.pyc,, +OpenGL/platform/__init__.py,sha256=vWqptZcMHUFg7apBXrssbYsnm0iRnQ9g-Y6nOnMllTU,3484 +OpenGL/platform/__pycache__/__init__.cpython-312.pyc,, +OpenGL/platform/__pycache__/baseplatform.cpython-312.pyc,, +OpenGL/platform/__pycache__/ctypesloader.cpython-312.pyc,, +OpenGL/platform/__pycache__/darwin.cpython-312.pyc,, +OpenGL/platform/__pycache__/egl.cpython-312.pyc,, +OpenGL/platform/__pycache__/entrypoint31.cpython-312.pyc,, +OpenGL/platform/__pycache__/glx.cpython-312.pyc,, +OpenGL/platform/__pycache__/osmesa.cpython-312.pyc,, +OpenGL/platform/__pycache__/win32.cpython-312.pyc,, +OpenGL/platform/baseplatform.py,sha256=gfSUhZrcwZlQf119NJfuTO0txGObBlBstxSO8TM90O8,16169 +OpenGL/platform/ctypesloader.py,sha256=4BtSOgVLciLsBi7H7O0Je2Wdb8-zLtNAKS2eE5uLdLM,3411 +OpenGL/platform/darwin.py,sha256=8KCp0px-1-9xNUm8giHYopcvijWDXwaEJ5Sh2QnF1Mc,3459 +OpenGL/platform/egl.py,sha256=MP6GVQnqvAJZRPddxbonXJNqjBU-0oyonmzM4hlfJjg,4135 +OpenGL/platform/entrypoint31.py,sha256=PbfR2tc8bQqpAqxGxmxTJkyU6JotL4CSTrhwLilYvFs,3447 +OpenGL/platform/glx.py,sha256=t8xOiwos3FLGEmD1ipLILrxEWz4pzfMDvd5tH7GBKf0,3923 +OpenGL/platform/osmesa.py,sha256=ewbnbeKJhhrfcrZWmGzy_9RXS3xsZsBe8TCH0Oxldw0,3024 +OpenGL/platform/win32.py,sha256=3R1VXIDjcKq0xBsSOxDtSkUssUYPeP37MhUGVr9zyEU,5276 +OpenGL/plugins.py,sha256=oCclPPwGVlEjVAJmF_TKWVN2GGtFqT6qlbRzTZ3XXio,2467 +OpenGL/raw/EGL/ANDROID/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/raw/EGL/ANDROID/__pycache__/__init__.cpython-312.pyc,, +OpenGL/raw/EGL/ANDROID/__pycache__/blob_cache.cpython-312.pyc,, +OpenGL/raw/EGL/ANDROID/__pycache__/framebuffer_target.cpython-312.pyc,, +OpenGL/raw/EGL/ANDROID/__pycache__/image_native_buffer.cpython-312.pyc,, +OpenGL/raw/EGL/ANDROID/__pycache__/native_fence_sync.cpython-312.pyc,, +OpenGL/raw/EGL/ANDROID/__pycache__/recordable.cpython-312.pyc,, +OpenGL/raw/EGL/ANDROID/blob_cache.py,sha256=TC0UaZfCLCYcWqfIAzDc4hmuMo2yOzp5y635Xo-tMnM,641 +OpenGL/raw/EGL/ANDROID/framebuffer_target.py,sha256=HZBfEtX6bgq0d19k57som6s26tgYwS4i8V7L7tJOG9c,595 +OpenGL/raw/EGL/ANDROID/image_native_buffer.py,sha256=W0RSjhr-T80QqAXqRWqEFj6bcNIT0Sg_KELDAsyJlDU,587 +OpenGL/raw/EGL/ANDROID/native_fence_sync.py,sha256=TrkeVaSC-oDvCOEp8BWd5WdmSGZqCzTvp2q9G047g7o,933 +OpenGL/raw/EGL/ANDROID/recordable.py,sha256=X-MniXBNUq_Pm9od9EdgB4KL8bEmk4lRP1kIEZc--oQ,563 +OpenGL/raw/EGL/ANGLE/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/raw/EGL/ANGLE/__pycache__/__init__.cpython-312.pyc,, +OpenGL/raw/EGL/ANGLE/__pycache__/d3d_share_handle_client_buffer.cpython-312.pyc,, +OpenGL/raw/EGL/ANGLE/__pycache__/device_d3d.cpython-312.pyc,, +OpenGL/raw/EGL/ANGLE/__pycache__/query_surface_pointer.cpython-312.pyc,, +OpenGL/raw/EGL/ANGLE/__pycache__/surface_d3d_texture_2d_share_handle.cpython-312.pyc,, +OpenGL/raw/EGL/ANGLE/__pycache__/window_fixed_size.cpython-312.pyc,, +OpenGL/raw/EGL/ANGLE/d3d_share_handle_client_buffer.py,sha256=2xFg7rym7WkDveZPvUNuHBBTDBV1roMBKrX3z8xm3gc,629 +OpenGL/raw/EGL/ANGLE/device_d3d.py,sha256=Z9hOaogWLDmygF4VAnW6CH27Km6FoirdI3n_iJIbS94,616 +OpenGL/raw/EGL/ANGLE/query_surface_pointer.py,sha256=VyHMVv4dWd3ABbaJeHvDPigg94CeIEOjsUAsR1K66h8,679 +OpenGL/raw/EGL/ANGLE/surface_d3d_texture_2d_share_handle.py,sha256=fPyKbgXFSG6av647vxKywn--kEEQ3AHaGTbELl1rhMc,639 +OpenGL/raw/EGL/ANGLE/window_fixed_size.py,sha256=hFfvCl9Fgt0-UfXMZ_vUcoPmgR5wYqiiGNSiOZSLOqs,569 +OpenGL/raw/EGL/ARM/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/raw/EGL/ARM/__pycache__/__init__.cpython-312.pyc,, +OpenGL/raw/EGL/ARM/__pycache__/pixmap_multisample_discard.cpython-312.pyc,, +OpenGL/raw/EGL/ARM/pixmap_multisample_discard.py,sha256=2nI6dcLaEfjr_SYarmOCwH1LNIOgjQnkZASrSErxBVw,589 +OpenGL/raw/EGL/EXT/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/raw/EGL/EXT/__pycache__/__init__.cpython-312.pyc,, +OpenGL/raw/EGL/EXT/__pycache__/buffer_age.cpython-312.pyc,, +OpenGL/raw/EGL/EXT/__pycache__/client_extensions.cpython-312.pyc,, +OpenGL/raw/EGL/EXT/__pycache__/create_context_robustness.cpython-312.pyc,, +OpenGL/raw/EGL/EXT/__pycache__/device_base.cpython-312.pyc,, +OpenGL/raw/EGL/EXT/__pycache__/device_drm.cpython-312.pyc,, +OpenGL/raw/EGL/EXT/__pycache__/device_enumeration.cpython-312.pyc,, +OpenGL/raw/EGL/EXT/__pycache__/device_openwf.cpython-312.pyc,, +OpenGL/raw/EGL/EXT/__pycache__/device_query.cpython-312.pyc,, +OpenGL/raw/EGL/EXT/__pycache__/image_dma_buf_import.cpython-312.pyc,, +OpenGL/raw/EGL/EXT/__pycache__/multiview_window.cpython-312.pyc,, +OpenGL/raw/EGL/EXT/__pycache__/output_base.cpython-312.pyc,, +OpenGL/raw/EGL/EXT/__pycache__/output_drm.cpython-312.pyc,, +OpenGL/raw/EGL/EXT/__pycache__/output_openwf.cpython-312.pyc,, +OpenGL/raw/EGL/EXT/__pycache__/platform_base.cpython-312.pyc,, +OpenGL/raw/EGL/EXT/__pycache__/platform_device.cpython-312.pyc,, +OpenGL/raw/EGL/EXT/__pycache__/platform_wayland.cpython-312.pyc,, +OpenGL/raw/EGL/EXT/__pycache__/platform_x11.cpython-312.pyc,, +OpenGL/raw/EGL/EXT/__pycache__/protected_surface.cpython-312.pyc,, +OpenGL/raw/EGL/EXT/__pycache__/stream_consumer_egloutput.cpython-312.pyc,, +OpenGL/raw/EGL/EXT/__pycache__/swap_buffers_with_damage.cpython-312.pyc,, +OpenGL/raw/EGL/EXT/__pycache__/yuv_surface.cpython-312.pyc,, +OpenGL/raw/EGL/EXT/buffer_age.py,sha256=KH9Ca-bvKZ1hh-OOZ-q01feZy14PSMn8XmDYgUR_I58,547 +OpenGL/raw/EGL/EXT/client_extensions.py,sha256=5rnx6aWfcEECzNcdNr34YVj8-m34mLaoUxdTIgCaXsQ,511 +OpenGL/raw/EGL/EXT/create_context_robustness.py,sha256=bKPey2DHjRrbESNsH6whpA02gElqtHOveKhj3TiIzvo,874 +OpenGL/raw/EGL/EXT/device_base.py,sha256=JMCICo-ePnO4zmjO2Q3XKLZZijX-FPhIj1m98P-EQsM,1183 +OpenGL/raw/EGL/EXT/device_drm.py,sha256=bpo1uSQqC1OQIrpAdBOe2zan3225lwi06NxLKgGnuTY,557 +OpenGL/raw/EGL/EXT/device_enumeration.py,sha256=bGs7MpblOEvaCAEMKDZUmNcpnXgp9EV6X29cR4Dc_B0,665 +OpenGL/raw/EGL/EXT/device_openwf.py,sha256=VazkSgJ0HI68HFyzBj5B2y5Xl1kYSrIl35-QK0JuiH0,565 +OpenGL/raw/EGL/EXT/device_query.py,sha256=a7sKZpcg0nPYynMfn3p6m7Vwef0pPHXo47wibGQr1os,1032 +OpenGL/raw/EGL/EXT/image_dma_buf_import.py,sha256=EtwdypWEoA1g0wQfmTkBiZWXGFsmtBb0Ld93CsegcTo,2008 +OpenGL/raw/EGL/EXT/multiview_window.py,sha256=VZAZswbEDS5mH26eGdZ_IWU1EdYUwOz2mgxM9KEs_Js,579 +OpenGL/raw/EGL/EXT/output_base.py,sha256=V-vQUQv_kwBv47-d2odQmMJpMKFG5-SBC_cf4_WGj1w,2141 +OpenGL/raw/EGL/EXT/output_drm.py,sha256=Y6cJKT4yzTp9YzBR4tVllNdox4R3-PdqfpKv1fk4Euc,649 +OpenGL/raw/EGL/EXT/output_openwf.py,sha256=YJFAshCMNGvL_pblrgYqfwqBHtDfz4ZAlyR5Vauvxag,628 +OpenGL/raw/EGL/EXT/platform_base.py,sha256=eP6_D7MkACu28NVQjfBpabz9nRN-MF5m8Hczu5E3KIM,997 +OpenGL/raw/EGL/EXT/platform_device.py,sha256=1FVMF-4O68zqMdZU_wECZ7Hz-Wczkoj28GRhjWg5QvQ,567 +OpenGL/raw/EGL/EXT/platform_wayland.py,sha256=fTxGuNLlr0foR9Sk06-7iKWLnkN70B8jFfnls8aEHCI,571 +OpenGL/raw/EGL/EXT/platform_x11.py,sha256=56sANJQTVd73B5N1qcfk0TAneGhNXW-9CK256zXVWrA,624 +OpenGL/raw/EGL/EXT/protected_surface.py,sha256=zdPcITulJMVI2EMaabzIwf_ku4BlwkYd3UoeZAicp5U,575 +OpenGL/raw/EGL/EXT/stream_consumer_egloutput.py,sha256=84lhs21iIW5gR1d_1C392HZh4elOFM4jN09Eo7n_PKI,664 +OpenGL/raw/EGL/EXT/swap_buffers_with_damage.py,sha256=2ry2u0gstMbntyytnaWEVIvecqYOphlspJABeVKMzr0,677 +OpenGL/raw/EGL/EXT/yuv_surface.py,sha256=NRytJS0NkvLU1-3rwSL7UOblWWAk1pgRY1rGu-ZuKog,2071 +OpenGL/raw/EGL/HI/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/raw/EGL/HI/__pycache__/__init__.cpython-312.pyc,, +OpenGL/raw/EGL/HI/__pycache__/clientpixmap.cpython-312.pyc,, +OpenGL/raw/EGL/HI/__pycache__/colorformats.cpython-312.pyc,, +OpenGL/raw/EGL/HI/clientpixmap.py,sha256=0quq8OfAMeVt99D39WIp6KOipAH57uBxlszIqnk_rBI,718 +OpenGL/raw/EGL/HI/colorformats.py,sha256=hCC-ItmeH6PzTJp_2wyEPF0s-B4rKsEeN9SCwEvxluo,696 +OpenGL/raw/EGL/IMG/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/raw/EGL/IMG/__pycache__/__init__.cpython-312.pyc,, +OpenGL/raw/EGL/IMG/__pycache__/context_priority.cpython-312.pyc,, +OpenGL/raw/EGL/IMG/context_priority.py,sha256=aGg0sOpO6Bv4c0nL5tM4gWh6hb52EpOO32wruWKE19Y,804 +OpenGL/raw/EGL/KHR/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/raw/EGL/KHR/__pycache__/__init__.cpython-312.pyc,, +OpenGL/raw/EGL/KHR/__pycache__/cl_event.cpython-312.pyc,, +OpenGL/raw/EGL/KHR/__pycache__/cl_event2.cpython-312.pyc,, +OpenGL/raw/EGL/KHR/__pycache__/client_get_all_proc_addresses.cpython-312.pyc,, +OpenGL/raw/EGL/KHR/__pycache__/config_attribs.cpython-312.pyc,, +OpenGL/raw/EGL/KHR/__pycache__/create_context.cpython-312.pyc,, +OpenGL/raw/EGL/KHR/__pycache__/create_context_no_error.cpython-312.pyc,, +OpenGL/raw/EGL/KHR/__pycache__/debug.cpython-312.pyc,, +OpenGL/raw/EGL/KHR/__pycache__/fence_sync.cpython-312.pyc,, +OpenGL/raw/EGL/KHR/__pycache__/get_all_proc_addresses.cpython-312.pyc,, +OpenGL/raw/EGL/KHR/__pycache__/gl_colorspace.cpython-312.pyc,, +OpenGL/raw/EGL/KHR/__pycache__/gl_renderbuffer_image.cpython-312.pyc,, +OpenGL/raw/EGL/KHR/__pycache__/gl_texture_2D_image.cpython-312.pyc,, +OpenGL/raw/EGL/KHR/__pycache__/gl_texture_3D_image.cpython-312.pyc,, +OpenGL/raw/EGL/KHR/__pycache__/gl_texture_cubemap_image.cpython-312.pyc,, +OpenGL/raw/EGL/KHR/__pycache__/image.cpython-312.pyc,, +OpenGL/raw/EGL/KHR/__pycache__/image_base.cpython-312.pyc,, +OpenGL/raw/EGL/KHR/__pycache__/image_pixmap.cpython-312.pyc,, +OpenGL/raw/EGL/KHR/__pycache__/lock_surface.cpython-312.pyc,, +OpenGL/raw/EGL/KHR/__pycache__/lock_surface2.cpython-312.pyc,, +OpenGL/raw/EGL/KHR/__pycache__/lock_surface3.cpython-312.pyc,, +OpenGL/raw/EGL/KHR/__pycache__/partial_update.cpython-312.pyc,, +OpenGL/raw/EGL/KHR/__pycache__/platform_android.cpython-312.pyc,, +OpenGL/raw/EGL/KHR/__pycache__/platform_gbm.cpython-312.pyc,, +OpenGL/raw/EGL/KHR/__pycache__/platform_wayland.cpython-312.pyc,, +OpenGL/raw/EGL/KHR/__pycache__/platform_x11.cpython-312.pyc,, +OpenGL/raw/EGL/KHR/__pycache__/reusable_sync.cpython-312.pyc,, +OpenGL/raw/EGL/KHR/__pycache__/stream.cpython-312.pyc,, +OpenGL/raw/EGL/KHR/__pycache__/stream_consumer_gltexture.cpython-312.pyc,, +OpenGL/raw/EGL/KHR/__pycache__/stream_cross_process_fd.cpython-312.pyc,, +OpenGL/raw/EGL/KHR/__pycache__/stream_fifo.cpython-312.pyc,, +OpenGL/raw/EGL/KHR/__pycache__/stream_producer_aldatalocator.cpython-312.pyc,, +OpenGL/raw/EGL/KHR/__pycache__/stream_producer_eglsurface.cpython-312.pyc,, +OpenGL/raw/EGL/KHR/__pycache__/surfaceless_context.cpython-312.pyc,, +OpenGL/raw/EGL/KHR/__pycache__/swap_buffers_with_damage.cpython-312.pyc,, +OpenGL/raw/EGL/KHR/__pycache__/vg_parent_image.cpython-312.pyc,, +OpenGL/raw/EGL/KHR/__pycache__/wait_sync.cpython-312.pyc,, +OpenGL/raw/EGL/KHR/cl_event.py,sha256=jo9L7ntvLurf4SCe4O80XkP_-YWgWhH9ZADdlVoYMIA,685 +OpenGL/raw/EGL/KHR/cl_event2.py,sha256=uvAa2ocgGNyhQh7y0Ojh3HkXlVRApaTohCxK9orudBc,826 +OpenGL/raw/EGL/KHR/client_get_all_proc_addresses.py,sha256=nHUt65Xzs2FFWmuaErvfQ0vid2hpa6cvHGVfMBLPl_4,535 +OpenGL/raw/EGL/KHR/config_attribs.py,sha256=Hq-8alZdk2BtS93mjUUyUMHwgsMstx61e7WPeDsPUkk,711 +OpenGL/raw/EGL/KHR/create_context.py,sha256=NO--No30luiupjQihGjq5Y7HtNup6SeubKM38BDbI5Y,1674 +OpenGL/raw/EGL/KHR/create_context_no_error.py,sha256=aCELgY7M_d6x6t6Htd9N2TwoO8gxP7CYsyWRERrUiaQ,599 +OpenGL/raw/EGL/KHR/debug.py,sha256=PUdhJoHcSryAAtRCGg6cpmVthI1EsF6o9O0n9Po5bhg,1566 +OpenGL/raw/EGL/KHR/fence_sync.py,sha256=QCSeQpXdLhULjsQuDPBKcnd5J6lN4IZE4glwwV5Vczs,1192 +OpenGL/raw/EGL/KHR/get_all_proc_addresses.py,sha256=AbdHTU0teU21xfcaUW2HlsqJ1JJhLpG2FQePh6cog14,521 +OpenGL/raw/EGL/KHR/gl_colorspace.py,sha256=xzs7PpBx4Xv4WL_SuMRTRZtxqsp-Kj2zN85BmCnhcfQ,697 +OpenGL/raw/EGL/KHR/gl_renderbuffer_image.py,sha256=475D4qqhbpCHUtoDE6MqDa_SfuTJQ1nSHzniUM5yDCE,579 +OpenGL/raw/EGL/KHR/gl_texture_2D_image.py,sha256=YuJNrYj0Wu6MPCn4y_IZ9_2SIoLwDVZ6EKpqU6WJFEE,634 +OpenGL/raw/EGL/KHR/gl_texture_3D_image.py,sha256=h8BNELSLQlp4pbAF1_admYmJe1LDLblRftiqdGAh6sc,638 +OpenGL/raw/EGL/KHR/gl_texture_cubemap_image.py,sha256=U8FaJ9Qa1HtymUflGkMWIHzzfAmtQxoOvmMB7l3Xvfg,1070 +OpenGL/raw/EGL/KHR/image.py,sha256=-zTC25vbSdLqnT5Cao_71XJaG0VTN-bWlV2wCncXpr8,874 +OpenGL/raw/EGL/KHR/image_base.py,sha256=N4TKJyhDUvCJDPJR5OhFq7MmKBxt7p2I3BsHjOyU-YM,888 +OpenGL/raw/EGL/KHR/image_pixmap.py,sha256=uNP_mjm_xuzFgrz07O9r2Hjf-WJUlSBZPFTlM-jYftk,557 +OpenGL/raw/EGL/KHR/lock_surface.py,sha256=xsyOPgvSuvw-WjxCjoGlhLBHigy4HEG7Ym5Nu55Efms,2122 +OpenGL/raw/EGL/KHR/lock_surface2.py,sha256=JDEWf3mjMqxDtDYr20HLlyGYx6_KMaJhVd4Dq7IpcYQ,567 +OpenGL/raw/EGL/KHR/lock_surface3.py,sha256=k-fNKyzgbM4cuakPnooah5jkIQQopMhKx4-legmSsY4,2352 +OpenGL/raw/EGL/KHR/partial_update.py,sha256=vxVWDUV9Tf8WeKepDeZKpVmELArfPJnNCA1xvkr3zKc,701 +OpenGL/raw/EGL/KHR/platform_android.py,sha256=Lrw5QB8Sgw4xMsdu6CfwGRWb96wx1BK_qWhT1JMjQDs,571 +OpenGL/raw/EGL/KHR/platform_gbm.py,sha256=jBDeWsATYNA-l04Hhj01tRVvoJOye3UgZu3Hfv3HyKo,555 +OpenGL/raw/EGL/KHR/platform_wayland.py,sha256=nixyvY_Z9gJhPIV8P8APEfMTZVGPK2gT_K1EE5GLqf4,571 +OpenGL/raw/EGL/KHR/platform_x11.py,sha256=zPI3j0V4TPbHyL3h3LnsWPim8RrHFNHUVGqijUkk9Ls,624 +OpenGL/raw/EGL/KHR/reusable_sync.py,sha256=Mb_ai4y2rEiNhb7qoLf6-FXeDm61pDm0h3c_r4wQGho,1691 +OpenGL/raw/EGL/KHR/stream.py,sha256=FFnOCXrc_5ejz9rSo_wV5999JIuZoWycqZFIlWVrJ5s,2035 +OpenGL/raw/EGL/KHR/stream_consumer_gltexture.py,sha256=y3Gv9X48QeDYTKx3gnj_jns8gTSYEix2WmcT8rFNKn0,957 +OpenGL/raw/EGL/KHR/stream_cross_process_fd.py,sha256=RxunWrRpzq89yJdBlCpTwsvGTszKu5s1YdaojlIsuNA,892 +OpenGL/raw/EGL/KHR/stream_fifo.py,sha256=LHW2mlmDPn3QwPfSdr-eERBoKtclmF6jF-5XFbdrQq8,921 +OpenGL/raw/EGL/KHR/stream_producer_aldatalocator.py,sha256=JF7wih7S3ISyUiastD584Ga0yLbtSg3w5tCD_niQ038,535 +OpenGL/raw/EGL/KHR/stream_producer_eglsurface.py,sha256=w3neDRuKRaHU8GcPgEz6C-OwkpyqI_T_b58yYvGZRKk,746 +OpenGL/raw/EGL/KHR/surfaceless_context.py,sha256=exKTfQ2Fb05KFr_44X_VFD3GN8RoVHZgyvsIpCBy7NA,515 +OpenGL/raw/EGL/KHR/swap_buffers_with_damage.py,sha256=3GwSebgfP_pD6gn7ZFP05Ay5_81M4LmvdmJreNshVXY,677 +OpenGL/raw/EGL/KHR/vg_parent_image.py,sha256=eIPqsqPCP1l07YE6XORiAQHsYiKX8I7SNJEI0nLrdws,567 +OpenGL/raw/EGL/KHR/wait_sync.py,sha256=aopyT2dudmY56ynBD3hYI6rRnNe-SmF69jiPCmnX4BI,601 +OpenGL/raw/EGL/MESA/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/raw/EGL/MESA/__pycache__/__init__.cpython-312.pyc,, +OpenGL/raw/EGL/MESA/__pycache__/drm_image.cpython-312.pyc,, +OpenGL/raw/EGL/MESA/__pycache__/image_dma_buf_export.cpython-312.pyc,, +OpenGL/raw/EGL/MESA/__pycache__/platform_gbm.cpython-312.pyc,, +OpenGL/raw/EGL/MESA/drm_image.py,sha256=g-wtQHnijSFEa_ksAjXxaNv6j2X1jj3n3uTWmvhxnjA,1270 +OpenGL/raw/EGL/MESA/image_dma_buf_export.py,sha256=vqR-5TEG2SE1iHBpxv6kruH1sIeHH45qfAoXeGvb6Ps,918 +OpenGL/raw/EGL/MESA/platform_gbm.py,sha256=ltdNogpjXoNNCBg54SB-15ix-KnUuIDnQ2MfppF-g6o,559 +OpenGL/raw/EGL/NOK/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/raw/EGL/NOK/__pycache__/__init__.cpython-312.pyc,, +OpenGL/raw/EGL/NOK/__pycache__/swap_region.cpython-312.pyc,, +OpenGL/raw/EGL/NOK/__pycache__/swap_region2.cpython-312.pyc,, +OpenGL/raw/EGL/NOK/__pycache__/texture_from_pixmap.cpython-312.pyc,, +OpenGL/raw/EGL/NOK/swap_region.py,sha256=nz_yDZvyGO8HApbOTM9RZvX8Y9hgNPlT4sSHx7jdGQc,648 +OpenGL/raw/EGL/NOK/swap_region2.py,sha256=LRio88XfTtmQnfPC-3x0ioPjJsTHctIa3c9WV8TVEc0,651 +OpenGL/raw/EGL/NOK/texture_from_pixmap.py,sha256=H7ZHWQxjv9P1bbPB4iJTPH4CuHMP5bC4jXgvm1uO5xI,565 +OpenGL/raw/EGL/NV/EGL_3dvision_surface.py,sha256=-o-JhZ_WBYKw0EEZd93U4Hx0bDa_pxfeK-5shDgAo60,565 +OpenGL/raw/EGL/NV/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/raw/EGL/NV/__pycache__/EGL_3dvision_surface.cpython-312.pyc,, +OpenGL/raw/EGL/NV/__pycache__/__init__.cpython-312.pyc,, +OpenGL/raw/EGL/NV/__pycache__/coverage_sample.cpython-312.pyc,, +OpenGL/raw/EGL/NV/__pycache__/coverage_sample_resolve.cpython-312.pyc,, +OpenGL/raw/EGL/NV/__pycache__/cuda_event.cpython-312.pyc,, +OpenGL/raw/EGL/NV/__pycache__/depth_nonlinear.cpython-312.pyc,, +OpenGL/raw/EGL/NV/__pycache__/device_cuda.cpython-312.pyc,, +OpenGL/raw/EGL/NV/__pycache__/native_query.cpython-312.pyc,, +OpenGL/raw/EGL/NV/__pycache__/post_convert_rounding.cpython-312.pyc,, +OpenGL/raw/EGL/NV/__pycache__/post_sub_buffer.cpython-312.pyc,, +OpenGL/raw/EGL/NV/__pycache__/stream_consumer_gltexture_yuv.cpython-312.pyc,, +OpenGL/raw/EGL/NV/__pycache__/stream_metadata.cpython-312.pyc,, +OpenGL/raw/EGL/NV/__pycache__/stream_sync.cpython-312.pyc,, +OpenGL/raw/EGL/NV/__pycache__/sync.cpython-312.pyc,, +OpenGL/raw/EGL/NV/__pycache__/system_time.cpython-312.pyc,, +OpenGL/raw/EGL/NV/coverage_sample.py,sha256=nWkhXNzb5bOhyAvuplh_pG8yzrTAb9-a3MuE4StOivs,626 +OpenGL/raw/EGL/NV/coverage_sample_resolve.py,sha256=Ea4dUwVDbXw-jdUIIzAfwSyVGR38ZOXXl9_SXjNRMKg,771 +OpenGL/raw/EGL/NV/cuda_event.py,sha256=6oT0EulWNCZxtYB3z3B7GbP6tGcMonwZrSGCwh1xY2M,693 +OpenGL/raw/EGL/NV/depth_nonlinear.py,sha256=nliJstuwUfN6gSH81OqVoULZDLZVqzkOJuFYpVjZOHM,700 +OpenGL/raw/EGL/NV/device_cuda.py,sha256=0SVcLmuJcN0jTX3L0JiAdoiLoowiT5otsA6dL70l9t4,547 +OpenGL/raw/EGL/NV/native_query.py,sha256=3OyeGuPSB3aBz-Rmr30SwzeakO-eHJoL0QqgdD67zCw,870 +OpenGL/raw/EGL/NV/post_convert_rounding.py,sha256=pqgGlXUsGQOFzngr-e_VkmUv4Cb0HM6ND0WOkQ1iau8,517 +OpenGL/raw/EGL/NV/post_sub_buffer.py,sha256=rAEhLwLeTCFDtnIrXzHuWhipICJJgMXl0IBcQgDno-c,744 +OpenGL/raw/EGL/NV/stream_consumer_gltexture_yuv.py,sha256=GntwObUTboP9WJWHk09oe4ZKyWnXv3kUTedXNbbjwVQ,1032 +OpenGL/raw/EGL/NV/stream_metadata.py,sha256=tkAWQlBqWW4cVFZDWjwFaQ5d3mAPSU9id4r6NpMn7-E,1904 +OpenGL/raw/EGL/NV/stream_sync.py,sha256=gYEksXQb1xUdjoPKqjhyvxATUTdCNwYEDST3rS0RujU,753 +OpenGL/raw/EGL/NV/sync.py,sha256=VQCsEgb7u87tfVuLek7qf2dOnu2rTRFcEjxXY4ySDkE,1840 +OpenGL/raw/EGL/NV/system_time.py,sha256=Y4pdRgQMIJ1Ocin45aL5Sq8h_fnSojhRPnlh5cqa-tM,629 +OpenGL/raw/EGL/TIZEN/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/raw/EGL/TIZEN/__pycache__/__init__.cpython-312.pyc,, +OpenGL/raw/EGL/TIZEN/__pycache__/image_native_buffer.cpython-312.pyc,, +OpenGL/raw/EGL/TIZEN/__pycache__/image_native_surface.cpython-312.pyc,, +OpenGL/raw/EGL/TIZEN/image_native_buffer.py,sha256=195212Xvda7y7B-SkoFEJ-Avn2lc-5ZyOJvJk4xtBnk,579 +OpenGL/raw/EGL/TIZEN/image_native_surface.py,sha256=T9TEbFijmVK0_gf2bbXLvZpDskONwSVsjkGo9xmu2Vs,583 +OpenGL/raw/EGL/VERSION/EGL_1_0.py,sha256=3uBZZX7KMIYlYfJKZdMuNJ9SpJ38qXnk2Hai_ORIaPU,5983 +OpenGL/raw/EGL/VERSION/EGL_1_1.py,sha256=0XWHPu5J-0jCcb47tE1CFBZ3mknSbzkM4C7mhBvJ_Hg,1672 +OpenGL/raw/EGL/VERSION/EGL_1_2.py,sha256=BxwUmnAJpK_4H9r4JpEk6LsZvnWJEskslDP6LNNojUU,2424 +OpenGL/raw/EGL/VERSION/EGL_1_3.py,sha256=pNhy1BsJvHgI_34bQoMySlK8xn68NPDffsFmTt8lewY,1212 +OpenGL/raw/EGL/VERSION/EGL_1_4.py,sha256=RzDyyaaI1OdCoYKKwsu0JAUAvKO0KQymJebql-CilH4,1081 +OpenGL/raw/EGL/VERSION/EGL_1_5.py,sha256=Xb9awJ3RHatsnKyC0J9PUiATX62m2GlZYDFKTcOu5vg,4780 +OpenGL/raw/EGL/VERSION/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/raw/EGL/VERSION/__pycache__/EGL_1_0.cpython-312.pyc,, +OpenGL/raw/EGL/VERSION/__pycache__/EGL_1_1.cpython-312.pyc,, +OpenGL/raw/EGL/VERSION/__pycache__/EGL_1_2.cpython-312.pyc,, +OpenGL/raw/EGL/VERSION/__pycache__/EGL_1_3.cpython-312.pyc,, +OpenGL/raw/EGL/VERSION/__pycache__/EGL_1_4.cpython-312.pyc,, +OpenGL/raw/EGL/VERSION/__pycache__/EGL_1_5.cpython-312.pyc,, +OpenGL/raw/EGL/VERSION/__pycache__/__init__.cpython-312.pyc,, +OpenGL/raw/EGL/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +OpenGL/raw/EGL/__pycache__/__init__.cpython-312.pyc,, +OpenGL/raw/EGL/__pycache__/_errors.cpython-312.pyc,, +OpenGL/raw/EGL/__pycache__/_glgets.cpython-312.pyc,, +OpenGL/raw/EGL/__pycache__/_types.cpython-312.pyc,, +OpenGL/raw/EGL/_errors.py,sha256=sBZjUIIDJg--t3cSpoGIxUr7dNG7MKNXErZVQC8cfo8,538 +OpenGL/raw/EGL/_glgets.py,sha256=pdbDplGI61RlSwbxPgFPDuLPgWbQzMu8XaofqtPw2B8,279 +OpenGL/raw/EGL/_types.py,sha256=HTStgiq5OKLkD1eGmZD1MYbYPyCxZDiUqIIw3eRCywI,4321 +OpenGL/raw/GL/AMD/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/raw/GL/AMD/__pycache__/__init__.cpython-312.pyc,, +OpenGL/raw/GL/AMD/__pycache__/blend_minmax_factor.cpython-312.pyc,, +OpenGL/raw/GL/AMD/__pycache__/conservative_depth.cpython-312.pyc,, +OpenGL/raw/GL/AMD/__pycache__/debug_output.cpython-312.pyc,, +OpenGL/raw/GL/AMD/__pycache__/depth_clamp_separate.cpython-312.pyc,, +OpenGL/raw/GL/AMD/__pycache__/draw_buffers_blend.cpython-312.pyc,, +OpenGL/raw/GL/AMD/__pycache__/framebuffer_multisample_advanced.cpython-312.pyc,, +OpenGL/raw/GL/AMD/__pycache__/framebuffer_sample_positions.cpython-312.pyc,, +OpenGL/raw/GL/AMD/__pycache__/gcn_shader.cpython-312.pyc,, +OpenGL/raw/GL/AMD/__pycache__/gpu_shader_half_float.cpython-312.pyc,, +OpenGL/raw/GL/AMD/__pycache__/gpu_shader_int16.cpython-312.pyc,, +OpenGL/raw/GL/AMD/__pycache__/gpu_shader_int64.cpython-312.pyc,, +OpenGL/raw/GL/AMD/__pycache__/interleaved_elements.cpython-312.pyc,, +OpenGL/raw/GL/AMD/__pycache__/multi_draw_indirect.cpython-312.pyc,, +OpenGL/raw/GL/AMD/__pycache__/name_gen_delete.cpython-312.pyc,, +OpenGL/raw/GL/AMD/__pycache__/occlusion_query_event.cpython-312.pyc,, +OpenGL/raw/GL/AMD/__pycache__/performance_monitor.cpython-312.pyc,, +OpenGL/raw/GL/AMD/__pycache__/pinned_memory.cpython-312.pyc,, +OpenGL/raw/GL/AMD/__pycache__/query_buffer_object.cpython-312.pyc,, +OpenGL/raw/GL/AMD/__pycache__/sample_positions.cpython-312.pyc,, +OpenGL/raw/GL/AMD/__pycache__/seamless_cubemap_per_texture.cpython-312.pyc,, +OpenGL/raw/GL/AMD/__pycache__/shader_atomic_counter_ops.cpython-312.pyc,, +OpenGL/raw/GL/AMD/__pycache__/shader_ballot.cpython-312.pyc,, +OpenGL/raw/GL/AMD/__pycache__/shader_explicit_vertex_parameter.cpython-312.pyc,, +OpenGL/raw/GL/AMD/__pycache__/shader_gpu_shader_half_float_fetch.cpython-312.pyc,, +OpenGL/raw/GL/AMD/__pycache__/shader_image_load_store_lod.cpython-312.pyc,, +OpenGL/raw/GL/AMD/__pycache__/shader_stencil_export.cpython-312.pyc,, +OpenGL/raw/GL/AMD/__pycache__/shader_trinary_minmax.cpython-312.pyc,, +OpenGL/raw/GL/AMD/__pycache__/sparse_texture.cpython-312.pyc,, +OpenGL/raw/GL/AMD/__pycache__/stencil_operation_extended.cpython-312.pyc,, +OpenGL/raw/GL/AMD/__pycache__/texture_gather_bias_lod.cpython-312.pyc,, +OpenGL/raw/GL/AMD/__pycache__/texture_texture4.cpython-312.pyc,, +OpenGL/raw/GL/AMD/__pycache__/transform_feedback3_lines_triangles.cpython-312.pyc,, +OpenGL/raw/GL/AMD/__pycache__/transform_feedback4.cpython-312.pyc,, +OpenGL/raw/GL/AMD/__pycache__/vertex_shader_layer.cpython-312.pyc,, +OpenGL/raw/GL/AMD/__pycache__/vertex_shader_tessellator.cpython-312.pyc,, +OpenGL/raw/GL/AMD/__pycache__/vertex_shader_viewport_index.cpython-312.pyc,, +OpenGL/raw/GL/AMD/blend_minmax_factor.py,sha256=GvDgtFI_Eyjd8d80CH7lyGinj8xsXmhUVZhgyy3Bc68,606 +OpenGL/raw/GL/AMD/conservative_depth.py,sha256=GuD2e9HsLptG4FFnp5w33abo2y0ax8isYtpsCldXUNs,507 +OpenGL/raw/GL/AMD/debug_output.py,sha256=VB-Vv4Z8fg8fX4uqfALGePoSiuIz_v2vlj0FWLwNwuk,2233 +OpenGL/raw/GL/AMD/depth_clamp_separate.py,sha256=8SUYvywI3KUfNiDCsvKtvVDdYfxXfV4A45JRbemvQ7g,630 +OpenGL/raw/GL/AMD/draw_buffers_blend.py,sha256=1w-vNZMQRTaLB5cm2DJ0umbYKbFOjf0E7831aKugRrA,960 +OpenGL/raw/GL/AMD/framebuffer_multisample_advanced.py,sha256=wyiHHfpdVZYHr6KSrZwXW5zt7F36CRfFUNYFExfIdqg,1500 +OpenGL/raw/GL/AMD/framebuffer_sample_positions.py,sha256=1x1zvn4msGtbQ7eGE1U_Ek6XGEBz2ioTPeaBgYBFc18,1503 +OpenGL/raw/GL/AMD/gcn_shader.py,sha256=H1km-zP0uYFSRdRQZfPvYygDstznUAWeSONRMwta6F4,491 +OpenGL/raw/GL/AMD/gpu_shader_half_float.py,sha256=ExfDeIG8SDIKvSaj2Klp5puKavud48vI6ra9KzE_APk,1207 +OpenGL/raw/GL/AMD/gpu_shader_int16.py,sha256=x0ulj2CdcvmUoc1jpPDJPHsyO2pifzLnVHVx6MufFEU,503 +OpenGL/raw/GL/AMD/gpu_shader_int64.py,sha256=lPHHkhNr8M1t5K-V5dC4kE7G63c8W8iw-WnHHdwET14,6133 +OpenGL/raw/GL/AMD/interleaved_elements.py,sha256=mv2uQiaoT02YCBBzxlVA6yptc2yvF1OfSGZyF5UBBsk,970 +OpenGL/raw/GL/AMD/multi_draw_indirect.py,sha256=2DJPqwXrH0jMZDwHLPBGcaRcMy6j2z4VVn9LTP0HJIk,808 +OpenGL/raw/GL/AMD/name_gen_delete.py,sha256=WwM1mwyGSBspDOtmWqdfxinF_c4TC96cCpKb4KO4suI,1098 +OpenGL/raw/GL/AMD/occlusion_query_event.py,sha256=17bkPVmbHkL3yQexwrW8A01SNApYlJ2gJYfcLz-mAvE,1147 +OpenGL/raw/GL/AMD/performance_monitor.py,sha256=J7g0LQQSJk9PjVDboyWA-dzpULA19n60k5XXKF6ZUkg,2391 +OpenGL/raw/GL/AMD/pinned_memory.py,sha256=uEcNuwHE_DPQBm-MmDJslY7W1tfEKgw02QU6J5dbwu8,585 +OpenGL/raw/GL/AMD/query_buffer_object.py,sha256=pWvXbk_mlFo4XFEkVA0-prlodBaGFr4DPWmHNHnzfs0,699 +OpenGL/raw/GL/AMD/sample_positions.py,sha256=ZhyDQzYDyDzsox975JHZZwlGEmXAjWjEOSdNfWTKvb8,676 +OpenGL/raw/GL/AMD/seamless_cubemap_per_texture.py,sha256=n7PR_VFVJ9McHnjKJZhuWR3a0UU7pAnI3e0J5NcRhDg,597 +OpenGL/raw/GL/AMD/shader_atomic_counter_ops.py,sha256=lZ9UYC7TzKLnIpYSlqLRjTlUkQ1XcBXkvqIryTEOdLo,521 +OpenGL/raw/GL/AMD/shader_ballot.py,sha256=DrZJk3JJq9yM3daWV7USfz5XydJ7YVhgAvh11qf1cuY,497 +OpenGL/raw/GL/AMD/shader_explicit_vertex_parameter.py,sha256=9jDtrM6gS0p2yffOclG1w7_GdI_YdB8VKWPb3spAaXc,535 +OpenGL/raw/GL/AMD/shader_gpu_shader_half_float_fetch.py,sha256=DEC3JbjGbHS7DFfAzrOE37-oXp5QNOlw7kiS2wXlovc,539 +OpenGL/raw/GL/AMD/shader_image_load_store_lod.py,sha256=FSIbpioF7v7tc9rQ8AMzvkLD7ohCypNPIY6orzHNUy8,525 +OpenGL/raw/GL/AMD/shader_stencil_export.py,sha256=Jgk3rTzepTccmFBo0vl8og77j9iCsWxlFuUq_Aj65oY,513 +OpenGL/raw/GL/AMD/shader_trinary_minmax.py,sha256=xevIiQ69sjHWThI1-VGjNOJkVSD4GHyScg4Dwxn-yVI,513 +OpenGL/raw/GL/AMD/sparse_texture.py,sha256=3pkTwqnLY_erwMmZhItcEx2Dct8-WuNDx-88pYINi9Y,1547 +OpenGL/raw/GL/AMD/stencil_operation_extended.py,sha256=THR8h4WBc8zdKz69Tc8syAoNLsBgUN-HUO5nXRAoc00,826 +OpenGL/raw/GL/AMD/texture_gather_bias_lod.py,sha256=ETxjJZNDNbGHx38_LdiaHNmQ1wvpNUATxPjYsOTQMdY,517 +OpenGL/raw/GL/AMD/texture_texture4.py,sha256=368gF2vRPBFdrTT1QeHhgOqbcrbMe0RpqPWJcaLKLCM,503 +OpenGL/raw/GL/AMD/transform_feedback3_lines_triangles.py,sha256=gAhQJBWq5KIQsch5RSFQxgc4GM-W1b49cm22GUv52Rk,541 +OpenGL/raw/GL/AMD/transform_feedback4.py,sha256=YowzjC_uOzh3cwUl04x59PJahc-OStYKzToGZjeG7tw,577 +OpenGL/raw/GL/AMD/vertex_shader_layer.py,sha256=SPRDa1tDOhv0U2PTNW63iFxN4sZcwDlG8Vop1SVbodg,509 +OpenGL/raw/GL/AMD/vertex_shader_tessellator.py,sha256=vxmAWw-eBJA_uQKRaqASvvvjC_WB-6t_0AqvEAQZ6dQ,1089 +OpenGL/raw/GL/AMD/vertex_shader_viewport_index.py,sha256=7U-IYF19dr2m_QdvZGT0F2RjYzmpBU-4Y2Aw_gVGlEs,527 +OpenGL/raw/GL/ANGLE/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/raw/GL/ANGLE/__pycache__/__init__.cpython-312.pyc,, +OpenGL/raw/GL/APPLE/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/raw/GL/APPLE/__pycache__/__init__.cpython-312.pyc,, +OpenGL/raw/GL/APPLE/__pycache__/aux_depth_stencil.cpython-312.pyc,, +OpenGL/raw/GL/APPLE/__pycache__/client_storage.cpython-312.pyc,, +OpenGL/raw/GL/APPLE/__pycache__/element_array.cpython-312.pyc,, +OpenGL/raw/GL/APPLE/__pycache__/fence.cpython-312.pyc,, +OpenGL/raw/GL/APPLE/__pycache__/float_pixels.cpython-312.pyc,, +OpenGL/raw/GL/APPLE/__pycache__/flush_buffer_range.cpython-312.pyc,, +OpenGL/raw/GL/APPLE/__pycache__/object_purgeable.cpython-312.pyc,, +OpenGL/raw/GL/APPLE/__pycache__/rgb_422.cpython-312.pyc,, +OpenGL/raw/GL/APPLE/__pycache__/row_bytes.cpython-312.pyc,, +OpenGL/raw/GL/APPLE/__pycache__/specular_vector.cpython-312.pyc,, +OpenGL/raw/GL/APPLE/__pycache__/texture_range.cpython-312.pyc,, +OpenGL/raw/GL/APPLE/__pycache__/transform_hint.cpython-312.pyc,, +OpenGL/raw/GL/APPLE/__pycache__/vertex_array_object.cpython-312.pyc,, +OpenGL/raw/GL/APPLE/__pycache__/vertex_array_range.cpython-312.pyc,, +OpenGL/raw/GL/APPLE/__pycache__/vertex_program_evaluators.cpython-312.pyc,, +OpenGL/raw/GL/APPLE/__pycache__/ycbcr_422.cpython-312.pyc,, +OpenGL/raw/GL/APPLE/aux_depth_stencil.py,sha256=eIPIqpNmIzghSmFyXTez8Sk5BgpgGjpu4f2RvCYm4-Y,575 +OpenGL/raw/GL/APPLE/client_storage.py,sha256=02HWkh2YDfv97lYwKOQai9Rhg-7kSpZz6F7mb7G7-XI,577 +OpenGL/raw/GL/APPLE/element_array.py,sha256=e92O0KTMYXbbDfaVzXL4PHtS9UPU3B3taVtZkW5_Fug,1370 +OpenGL/raw/GL/APPLE/fence.py,sha256=8pmG0395rb_rTNNS7jYiSBHFeoCTJPhpUswi7C1sPHE,1205 +OpenGL/raw/GL/APPLE/float_pixels.py,sha256=KbKGf4GwreeVHniTWxLSebelVxlgRZLuHJweFHxBFgY,1362 +OpenGL/raw/GL/APPLE/flush_buffer_range.py,sha256=4KSJnIVj6Su710S6HQBveNRcBTmmxdNPp-muKD8cupQ,888 +OpenGL/raw/GL/APPLE/object_purgeable.py,sha256=IA8zZl-DYGnNCVXAGu0P8TTKowZcGefZqP9Gs6_Z6lg,1183 +OpenGL/raw/GL/APPLE/rgb_422.py,sha256=yqVIkEgaeMZvIW7KS6dnadYRZ9P5l5UA1KOlwZKV7q4,736 +OpenGL/raw/GL/APPLE/row_bytes.py,sha256=RCOpFq91K2EzYU8LGP7VsKrRD1foCgh73DaRlBFITLY,618 +OpenGL/raw/GL/APPLE/specular_vector.py,sha256=vNS_vlg72xrTA7ahzhrJqZnzbDW-EVEVv3OH0wI64G0,591 +OpenGL/raw/GL/APPLE/texture_range.py,sha256=lpACVjO8ruliRU8Z0NhzL2AVwLvDx10iLjJWqlx_Xr0,1139 +OpenGL/raw/GL/APPLE/transform_hint.py,sha256=X96uVH3KIkNImwlMBmgeJ_WkSHkzzYR5jYX4F-Zty_E,563 +OpenGL/raw/GL/APPLE/vertex_array_object.py,sha256=0dCB8E0tv8bzXwYkyMfavn6O6O4gmTZBgE9JeGSxbxU,920 +OpenGL/raw/GL/APPLE/vertex_array_range.py,sha256=gCanCkfCSB7pHrVSZVnedszN3bUrHXRuMc6bQU8aa94,1303 +OpenGL/raw/GL/APPLE/vertex_program_evaluators.py,sha256=81clVh71FQhMA0Gm7KMp5G3lN4gAanjlHaqVhfygUEA,2446 +OpenGL/raw/GL/APPLE/ycbcr_422.py,sha256=e7J2aKiN1K-HGKarQW_2WUL8kGZnigD9XwMbxKUzj4o,689 +OpenGL/raw/GL/ARB/ES2_compatibility.py,sha256=zJlX7H0LURDvGlQJrPVADWGsX0VAY0T8xmyHlUaQqxQ,1863 +OpenGL/raw/GL/ARB/ES3_1_compatibility.py,sha256=-Rmq6xIAK4yGoRa4nYIUhrWtmqzSSmYpJ5WhxESjVHw,614 +OpenGL/raw/GL/ARB/ES3_2_compatibility.py,sha256=OD2J5A8Af6kjoUvzsc3y99XfH1qwEg2JcH0aBFuSLRE,954 +OpenGL/raw/GL/ARB/ES3_compatibility.py,sha256=LuW62uwvxSWFL0QianMaj_V9A-QMtT6HAm4hYNIcZUc,1465 +OpenGL/raw/GL/ARB/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/raw/GL/ARB/__pycache__/ES2_compatibility.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/ES3_1_compatibility.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/ES3_2_compatibility.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/ES3_compatibility.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/__init__.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/arrays_of_arrays.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/base_instance.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/bindless_texture.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/blend_func_extended.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/buffer_storage.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/cl_event.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/clear_buffer_object.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/clear_texture.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/clip_control.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/color_buffer_float.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/compatibility.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/compressed_texture_pixel_storage.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/compute_shader.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/compute_variable_group_size.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/conditional_render_inverted.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/conservative_depth.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/copy_buffer.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/copy_image.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/cull_distance.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/debug_output.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/depth_buffer_float.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/depth_clamp.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/depth_texture.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/derivative_control.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/direct_state_access.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/draw_buffers.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/draw_buffers_blend.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/draw_elements_base_vertex.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/draw_indirect.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/draw_instanced.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/enhanced_layouts.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/explicit_attrib_location.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/explicit_uniform_location.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/fragment_coord_conventions.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/fragment_layer_viewport.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/fragment_program.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/fragment_program_shadow.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/fragment_shader.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/fragment_shader_interlock.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/framebuffer_no_attachments.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/framebuffer_object.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/framebuffer_sRGB.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/geometry_shader4.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/get_program_binary.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/get_texture_sub_image.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/gl_spirv.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/gpu_shader5.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/gpu_shader_fp64.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/gpu_shader_int64.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/half_float_pixel.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/half_float_vertex.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/imaging.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/indirect_parameters.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/instanced_arrays.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/internalformat_query.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/internalformat_query2.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/invalidate_subdata.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/map_buffer_alignment.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/map_buffer_range.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/matrix_palette.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/multi_bind.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/multi_draw_indirect.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/multisample.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/multitexture.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/occlusion_query.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/occlusion_query2.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/parallel_shader_compile.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/pipeline_statistics_query.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/pixel_buffer_object.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/point_parameters.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/point_sprite.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/polygon_offset_clamp.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/post_depth_coverage.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/program_interface_query.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/provoking_vertex.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/query_buffer_object.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/robust_buffer_access_behavior.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/robustness.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/robustness_isolation.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/sample_locations.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/sample_shading.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/sampler_objects.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/seamless_cube_map.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/seamless_cubemap_per_texture.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/separate_shader_objects.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/shader_atomic_counter_ops.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/shader_atomic_counters.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/shader_ballot.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/shader_bit_encoding.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/shader_clock.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/shader_draw_parameters.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/shader_group_vote.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/shader_image_load_store.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/shader_image_size.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/shader_objects.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/shader_precision.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/shader_stencil_export.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/shader_storage_buffer_object.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/shader_subroutine.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/shader_texture_image_samples.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/shader_texture_lod.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/shader_viewport_layer_array.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/shading_language_100.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/shading_language_420pack.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/shading_language_include.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/shading_language_packing.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/shadow.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/shadow_ambient.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/sparse_buffer.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/sparse_texture.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/sparse_texture2.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/sparse_texture_clamp.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/spirv_extensions.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/stencil_texturing.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/sync.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/tessellation_shader.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/texture_barrier.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/texture_border_clamp.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/texture_buffer_object.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/texture_buffer_object_rgb32.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/texture_buffer_range.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/texture_compression.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/texture_compression_bptc.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/texture_compression_rgtc.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/texture_cube_map.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/texture_cube_map_array.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/texture_env_add.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/texture_env_combine.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/texture_env_crossbar.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/texture_env_dot3.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/texture_filter_anisotropic.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/texture_filter_minmax.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/texture_float.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/texture_gather.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/texture_mirror_clamp_to_edge.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/texture_mirrored_repeat.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/texture_multisample.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/texture_non_power_of_two.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/texture_query_levels.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/texture_query_lod.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/texture_rectangle.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/texture_rg.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/texture_rgb10_a2ui.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/texture_stencil8.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/texture_storage.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/texture_storage_multisample.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/texture_swizzle.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/texture_view.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/timer_query.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/transform_feedback2.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/transform_feedback3.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/transform_feedback_instanced.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/transform_feedback_overflow_query.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/transpose_matrix.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/uniform_buffer_object.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/vertex_array_bgra.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/vertex_array_object.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/vertex_attrib_64bit.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/vertex_attrib_binding.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/vertex_blend.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/vertex_buffer_object.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/vertex_program.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/vertex_shader.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/vertex_type_10f_11f_11f_rev.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/vertex_type_2_10_10_10_rev.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/viewport_array.cpython-312.pyc,, +OpenGL/raw/GL/ARB/__pycache__/window_pos.cpython-312.pyc,, +OpenGL/raw/GL/ARB/arrays_of_arrays.py,sha256=v0nsrcJ1RqczW9lPm2lJqEmqDk7AUgdrpi-NP4lIG0Q,503 +OpenGL/raw/GL/ARB/base_instance.py,sha256=PyGf4bSXU-_ysYYQyw9EJ_Qs0hwBn5Qe6lZYQZACBU4,1071 +OpenGL/raw/GL/ARB/bindless_texture.py,sha256=HMt-61oVpwQzvs0ckS6s6gpKIPdSJHj7kkUQ54XXN2E,2183 +OpenGL/raw/GL/ARB/blend_func_extended.py,sha256=NWWBedS4S12QHk-duSwodY-VXyudHDlvbR8CI-Pj2d8,1028 +OpenGL/raw/GL/ARB/buffer_storage.py,sha256=16u8BOze8MQlcVTo9NKWzoJ6QPI0PZA_OSBXb0cbBEk,1160 +OpenGL/raw/GL/ARB/cl_event.py,sha256=FUMMyASY6cK8f2hRzxYtUFtPdSd0W4w3iTxfL_NiJVo,773 +OpenGL/raw/GL/ARB/clear_buffer_object.py,sha256=nTbllu5Hvh2ApMGpfGlE1oTx1_eiKuY-8W9qAseJz9o,845 +OpenGL/raw/GL/ARB/clear_texture.py,sha256=3S-ddBXiJ2hAnfKhj6NuCqkUu4AW576chEAJvcpW6sA,926 +OpenGL/raw/GL/ARB/clip_control.py,sha256=r3DtTJf-N8lsuZLtwMfTa8iovF147ozMaJLHb8fIp5E,850 +OpenGL/raw/GL/ARB/color_buffer_float.py,sha256=-z6AqR12B3RPh0MqSR33mKtUxXL0v7AXolJREJdpq48,889 +OpenGL/raw/GL/ARB/compatibility.py,sha256=HlUMIN34Zg8R4DN1DdLbj5pst3Y1zadEQiVSLrBIJHA,497 +OpenGL/raw/GL/ARB/compressed_texture_pixel_storage.py,sha256=IL8UNqWuv328nGa7HwDi8wD8hr_eCIEx5LS8_-xNjcM,1150 +OpenGL/raw/GL/ARB/compute_shader.py,sha256=-1u3mBbIp1dx9evrJIOqFhaVMRCHIXadyHMGMOgx1tU,2147 +OpenGL/raw/GL/ARB/compute_variable_group_size.py,sha256=KlGi7QCu-Nhn4qUCGIanv6vRKhJ9cBfe76Z92eCHETY,1107 +OpenGL/raw/GL/ARB/conditional_render_inverted.py,sha256=qHDVcw6B8k8TFPx_5aOYmtKKPQYuDAKUfw8j74qO3aQ,812 +OpenGL/raw/GL/ARB/conservative_depth.py,sha256=0PefeRXHNZQBCqHev-oUEFBk4xQBjhy_dxQQTR3TMSs,507 +OpenGL/raw/GL/ARB/copy_buffer.py,sha256=PfrRenYvNt0nwXwI4Mybw6TXkm9BpQDVxPqRE_cknFI,763 +OpenGL/raw/GL/ARB/copy_image.py,sha256=rcyquLyGjBzD7ORLI2LXAKmDdhBo-6fuAKo1o3eZhZs,811 +OpenGL/raw/GL/ARB/cull_distance.py,sha256=dxJ_Jp-V1jHa6yYwHEOtmT-lXWF4mokoRgGutCGVpKk,646 +OpenGL/raw/GL/ARB/debug_output.py,sha256=jeVUZJWC-EJ8_kC04abjEuYEuVTS0BddEwsuzdNeJ7E,2843 +OpenGL/raw/GL/ARB/depth_buffer_float.py,sha256=DOcBqNoKjxRxMIkvWba83-bNgp9_RQGQqAJZkqmWyxc,699 +OpenGL/raw/GL/ARB/depth_clamp.py,sha256=4MSZqTrVML9CI6sFJBHPYoQSUt_O9AOK1GXP_pPyFEc,535 +OpenGL/raw/GL/ARB/depth_texture.py,sha256=rd3HCZtvM-lBW51QToOudrcpx8NUVEHyCmJuAsdSaas,815 +OpenGL/raw/GL/ARB/derivative_control.py,sha256=hugcABylaLECKzqVLIi27f715sjJf9U11d6QkLvKRxA,507 +OpenGL/raw/GL/ARB/direct_state_access.py,sha256=N3XI2W8Pb5BkmFKc21wE4PV1HQ6Hl6QbKuq6CHHnP2Y,14699 +OpenGL/raw/GL/ARB/draw_buffers.py,sha256=uFr13Oyw-sQ5Stx1ltCiVT3az0P7mI1iZ6OOd_DoRaA,1499 +OpenGL/raw/GL/ARB/draw_buffers_blend.py,sha256=JxtSbOD-yz1xvo_5Z6QDOX6PwzC_eZHligdeeKtnSLE,936 +OpenGL/raw/GL/ARB/draw_elements_base_vertex.py,sha256=hAuLUgCsvoR6IganSZv8AnQ2raH2AJ4bKUC9FQ8waDA,1239 +OpenGL/raw/GL/ARB/draw_indirect.py,sha256=GA58Jid1yjTOmrRZUWlEOy5ob023PC-KoQIUxtG-r8o,835 +OpenGL/raw/GL/ARB/draw_instanced.py,sha256=E0_uIgRV-ezq7ZEWiF4Do3fsZs_cAhRPCxe1TV_3oow,778 +OpenGL/raw/GL/ARB/enhanced_layouts.py,sha256=lcYCdBjJ8GFp57SiJSITv1uZQETVu6u8j2a47NADfsg,798 +OpenGL/raw/GL/ARB/explicit_attrib_location.py,sha256=cI1VllATgEFMuVGrnJp2drpgTlvmhf1XOLImpJh-e-I,519 +OpenGL/raw/GL/ARB/explicit_uniform_location.py,sha256=TwKAa0GWcH4qDXeWv5d31ic_buQdQZ-24gbtZVQpoxE,583 +OpenGL/raw/GL/ARB/fragment_coord_conventions.py,sha256=GFy0bEAmKTHRBp7sWSNZBgNm2xZc3wEHd2JPpkV7K5g,523 +OpenGL/raw/GL/ARB/fragment_layer_viewport.py,sha256=pRluYWEc9sJas5AIleVy_drmTdTxhKIXKZl_TSL6Xoo,517 +OpenGL/raw/GL/ARB/fragment_program.py,sha256=DTe_nhuZAVwQWj1QEfD9K9LlVy0PmwwzYaNA14cOObU,7721 +OpenGL/raw/GL/ARB/fragment_program_shadow.py,sha256=sIDqm2T9LJ-3SyBXMNDRAQLeaSDozZwq1IFTGZOg2TA,517 +OpenGL/raw/GL/ARB/fragment_shader.py,sha256=jCDNN6R2Qxyvw0syXO-rv9cENMj72vDb9D-LeNTA5Bw,741 +OpenGL/raw/GL/ARB/fragment_shader_interlock.py,sha256=lcb4RGM5SAHixOHJZdxXtgwqsodtb9JaX6J8sI2tv7M,521 +OpenGL/raw/GL/ARB/framebuffer_no_attachments.py,sha256=f4jNwUrkMZqSO5nNY_UPCdJSCOFOS5C6J7wEHkHXDzI,1401 +OpenGL/raw/GL/ARB/framebuffer_object.py,sha256=yXKSFCYnnoC2lH4mZtWsZWyHCFEeVfVMxFsCb4qHN0c,7734 +OpenGL/raw/GL/ARB/framebuffer_sRGB.py,sha256=yperUIfAiakgV3hSnk7LyM9TIjLaEGwLFEgXu6obFCo,555 +OpenGL/raw/GL/ARB/geometry_shader4.py,sha256=_IDUAlJPMSQTQLvMEygWtRa1DXUwc5_dOyG3rmTK_KY,2630 +OpenGL/raw/GL/ARB/get_program_binary.py,sha256=j07KE46wniaS43xK0i4cnhTRS1nTxZGSBsxeFS0eok8,1192 +OpenGL/raw/GL/ARB/get_texture_sub_image.py,sha256=qn9SkQ_nfGZpeOqXoZDbyqHACfluJBo1X6mwMF5BVWM,1032 +OpenGL/raw/GL/ARB/gl_spirv.py,sha256=htlUetI3lSxQEC0zEIIPr54eDpowDCpz4a-HsYf8y6s,830 +OpenGL/raw/GL/ARB/gpu_shader5.py,sha256=ktQEawCEMjna6afonzte6dQkxPvcF0Dvtf5wEU4szqA,970 +OpenGL/raw/GL/ARB/gpu_shader_fp64.py,sha256=Xa6fzTIj2bxtAR8OZFvdAftoSANR0nJC-ASzNMBR3yM,3250 +OpenGL/raw/GL/ARB/gpu_shader_int64.py,sha256=3Ow_v20BPWm6XJxP7c84bLWHE5TtIdjTAtISsXe-hG8,5303 +OpenGL/raw/GL/ARB/half_float_pixel.py,sha256=4foaabP7zT5U3yzHIf0nhk5PSPdskJja6ZKpXVlhHyk,551 +OpenGL/raw/GL/ARB/half_float_vertex.py,sha256=KKEpQniGAuqsgBxZPU7K6jz3RoFIChw4iipSZt_NHWM,545 +OpenGL/raw/GL/ARB/imaging.py,sha256=vI8jSb-B6nC6D-qqrbdPpdz267wQRief4sjD1GM_XJU,9314 +OpenGL/raw/GL/ARB/indirect_parameters.py,sha256=EAUlMavT0jSbu6pyb9-mjOUniYHqCHHXnCDfE_tcpwQ,1007 +OpenGL/raw/GL/ARB/instanced_arrays.py,sha256=_V-NmYU-nnB8f-4PCCvxNOhMY725hfASPZOPaFOUXDY,675 +OpenGL/raw/GL/ARB/internalformat_query.py,sha256=nP5wcFZj0rlNA_ndQVWNkyRy3QOYckDMA3V89k-Njhw,722 +OpenGL/raw/GL/ARB/internalformat_query2.py,sha256=uvbrJnJtakKt_vh0K-Z7jyGTdiE48sH5iPWweX3bKHk,8809 +OpenGL/raw/GL/ARB/invalidate_subdata.py,sha256=M0M-Pb-_0oS-J4_6vIyRAobDp0gkfJoaWoiVaunkHa0,1301 +OpenGL/raw/GL/ARB/map_buffer_alignment.py,sha256=7MzCd6aSDIPQ47kqYv_GakdvX5Ieh6pf6FEdbOMlZ7k,579 +OpenGL/raw/GL/ARB/map_buffer_range.py,sha256=zM0pbzCnT3vIdnncUZVe3NfpbuXP1qriW69vVzpuLbo,1118 +OpenGL/raw/GL/ARB/matrix_palette.py,sha256=VlL9-5AFlVmR4VPYcP-TWqstgNYY9lZN0FNrqXw1koY,1708 +OpenGL/raw/GL/ARB/multi_bind.py,sha256=fq9urvLr3Xu-MtDCVv7xrOybUeQeSTBTIgB_XkMP1gE,1327 +OpenGL/raw/GL/ARB/multi_draw_indirect.py,sha256=tjzELd29v9rZ69Qb228E5seBaFc-X71Akol259KGCbo,802 +OpenGL/raw/GL/ARB/multisample.py,sha256=RRjvx9IHresRbbScyA8nN35pcVfJGEirkZvMiIlYoAw,1141 +OpenGL/raw/GL/ARB/multitexture.py,sha256=EBuK_ECd4fXAphTtpISuzt4gT5GbUyoS_sBTvWYZsAY,5432 +OpenGL/raw/GL/ARB/occlusion_query.py,sha256=2wOyJ-70FI0KgEvRXR561x_dlNHXqakL5EKIGjHTP-c,1501 +OpenGL/raw/GL/ARB/occlusion_query2.py,sha256=Xlwm59iFLV6PzMg9DxprK3-19XJjN9bgXw74IDr0Nbc,559 +OpenGL/raw/GL/ARB/parallel_shader_compile.py,sha256=OsxLBtzIS3GGqvgXFIpAUHHYtGQOrq8dife_LDHx9aA,738 +OpenGL/raw/GL/ARB/pipeline_statistics_query.py,sha256=0ig4bnpmNtf1ovb-pRrFohgcq3-uGt-tSHrvAPJeLd8,1409 +OpenGL/raw/GL/ARB/pixel_buffer_object.py,sha256=C7epvrxgN4ZbzEY4jt5EhGX5COgx5EdtZIrgR-_hX0s,800 +OpenGL/raw/GL/ARB/point_parameters.py,sha256=lSJCKXVGC3LVuLWPf9FDHgTpvC1PK5hK6hx_LMtZcUM,957 +OpenGL/raw/GL/ARB/point_sprite.py,sha256=cD7MNwLIf9DC1XGkC1Jod-inLcHy6d6Xf4p3WqOGbNo,602 +OpenGL/raw/GL/ARB/polygon_offset_clamp.py,sha256=JmbfTXP0ssofX4T069wCGkoY9LDj_HKqQPUd3CMQIEU,676 +OpenGL/raw/GL/ARB/post_depth_coverage.py,sha256=RdnLSA6D6tF1qEhPhr8xpCt9oEZTHvClH_b-gDgfV9c,509 +OpenGL/raw/GL/ARB/program_interface_query.py,sha256=peHrm8h7R496B-3ty05y-orgILVxdUhjMbf3LXlQtSM,4510 +OpenGL/raw/GL/ARB/provoking_vertex.py,sha256=PgNNqXR-e_NzezrlKxJqYTd-egSypgxMSJHd7ZgTFhI,851 +OpenGL/raw/GL/ARB/query_buffer_object.py,sha256=wMKmwLzXSSSTcvPVxL32CoxVdzOQqwwCN9BU-WHHEtc,748 +OpenGL/raw/GL/ARB/robust_buffer_access_behavior.py,sha256=_jHP51JsvR_4ZkBSRmmarMO36m3n4zx_3nXsY8HoJkE,529 +OpenGL/raw/GL/ARB/robustness.py,sha256=aVTb8-ML9kMPOyc7ynEHyZpf-SJrZgHMszoLp8UUHiQ,3767 +OpenGL/raw/GL/ARB/robustness_isolation.py,sha256=zGOskrRDUxj4eZ-k1FhNw3abv6xnzVaSD6oNbuKpewQ,511 +OpenGL/raw/GL/ARB/sample_locations.py,sha256=ftZCh6ww5jvzjUu6047MV5Kbdt9rvZGGg76MFManSL8,1588 +OpenGL/raw/GL/ARB/sample_shading.py,sha256=xmU_6v9x4_iFe9XRpDf96sBh2wj56-6a9FEOeqasXMA,701 +OpenGL/raw/GL/ARB/sampler_objects.py,sha256=aBsm_Bl1QjUDiT-MQhL1dMUJzV9D32S6qPB_dLejHUc,2004 +OpenGL/raw/GL/ARB/seamless_cube_map.py,sha256=AGaoTwQXIb0u1ttTP-fQDlDpeit7TFzLuEyog7tHE8A,575 +OpenGL/raw/GL/ARB/seamless_cubemap_per_texture.py,sha256=HszZX-MdZBjWBzrVdqbpio_FEjz0l8G-5a5dSQObeOs,597 +OpenGL/raw/GL/ARB/separate_shader_objects.py,sha256=2nhh0Y22w8sJ93b-FxtC9HwYsLMivyCLXi3bGQ-HNPQ,9246 +OpenGL/raw/GL/ARB/shader_atomic_counter_ops.py,sha256=VPocFHc_WeqtzJACXbj8DOQLcBdh9gALbBZhtNm142U,521 +OpenGL/raw/GL/ARB/shader_atomic_counters.py,sha256=oFa1gw6NZQWz1v3JAANc_oaSw0C4RB_hXwR8j4vhzBw,3357 +OpenGL/raw/GL/ARB/shader_ballot.py,sha256=UDON_EquHWUEl_G-WEpfcV_jd-VZM-HY98b1vSoFSxg,497 +OpenGL/raw/GL/ARB/shader_bit_encoding.py,sha256=QI0TBU_87_7Dlnj9Vm4imugBGQX7aLATQZkxMM0opyk,509 +OpenGL/raw/GL/ARB/shader_clock.py,sha256=V6sYsTR9QBX0lBaNPAG8V3jP3g6rfeTcxra9vfROlDo,495 +OpenGL/raw/GL/ARB/shader_draw_parameters.py,sha256=6ovVgNolWlIO5TQBNZyxUtH_OKOUG4YugB2a85g0YxI,515 +OpenGL/raw/GL/ARB/shader_group_vote.py,sha256=UxPJKHBNNR13Tgjl7gHRLG5_0kaPfDrIgsBjVWjD9GQ,505 +OpenGL/raw/GL/ARB/shader_image_load_store.py,sha256=gGB0BkYATkS941s-dBMtS-NMHqXKEXjAgjI1eXa6_nM,5017 +OpenGL/raw/GL/ARB/shader_image_size.py,sha256=aYi2vnqQigJXFAvrIEONcW80-QAxiMde8_tGosuZqW4,505 +OpenGL/raw/GL/ARB/shader_objects.py,sha256=w3iPu2RdSzl09qZmJMJMZfK_KEh3A7Mk9qiTBgkIpyA,6761 +OpenGL/raw/GL/ARB/shader_precision.py,sha256=QaZXr4xLYeKk1C7-skaqOy0qNxT2PVWNefgZySCUkY4,503 +OpenGL/raw/GL/ARB/shader_stencil_export.py,sha256=mhKrh94f3ulVg8aGPUkSIAW7vJv8zPZkfGUKitTMU8o,513 +OpenGL/raw/GL/ARB/shader_storage_buffer_object.py,sha256=AUPBU3lBK_mgNrip7joa9H1CeTTHS6qZ2I47DDY8jYc,2137 +OpenGL/raw/GL/ARB/shader_subroutine.py,sha256=hAWf05xUVlpvDFoNkLpadRtJKOIWfz-65OcweBWdgT4,2440 +OpenGL/raw/GL/ARB/shader_texture_image_samples.py,sha256=KIfABJtXt-w0XybPSVWJqjjmXANoI7x42F7G5La7jnc,527 +OpenGL/raw/GL/ARB/shader_texture_lod.py,sha256=xctcEv76gfYXyV0O6EUlW2RMJ-HGbwOLUy88uY9Jtk0,507 +OpenGL/raw/GL/ARB/shader_viewport_layer_array.py,sha256=-E9hUftCGNskCB3Z59uZj6dZhqbWGb8-n5PZZTRKH6s,525 +OpenGL/raw/GL/ARB/shading_language_100.py,sha256=edi7a4CUu8WLiAimE_EMT8fU9teGPhJbxbyNw134n44,587 +OpenGL/raw/GL/ARB/shading_language_420pack.py,sha256=eq0xLS8a8LIRj0FHgZAF5Hl_noy4bWiQYhcb7U0n4Hw,519 +OpenGL/raw/GL/ARB/shading_language_include.py,sha256=TuOIT6kKsUPhN-i4ttjp773seOoxd5d9dLJVhiDULog,1520 +OpenGL/raw/GL/ARB/shading_language_packing.py,sha256=V1jRv40MOisTCB9XuFmsO1RIIzgdO5IRC_GObO8jr5c,519 +OpenGL/raw/GL/ARB/shadow.py,sha256=VJrdqnXLx9vrPn09OVmP_Pewygu6e1ed-FzdKrV16PA,689 +OpenGL/raw/GL/ARB/shadow_ambient.py,sha256=hGRFjblkTAFTFGJByKy0CGYnBGDT6pz_qQ8ob2Kz95k,579 +OpenGL/raw/GL/ARB/sparse_buffer.py,sha256=-_L3rNbVt0e3lKGMA6OpcPIX_BOKPY08g1OasJDZ8G0,1050 +OpenGL/raw/GL/ARB/sparse_texture.py,sha256=3-3SOyUyvCKv5ITTXdstSYjQui5LlLo8SoCCXjCrFZo,1535 +OpenGL/raw/GL/ARB/sparse_texture2.py,sha256=bBSiuY0aFnXvZ_WyZI11lT0vnXfBDSKAiXgxktNgsIw,501 +OpenGL/raw/GL/ARB/sparse_texture_clamp.py,sha256=fGk8fK4L5n_Fyv1kEh4wFBpWOjyrDcAcbjC2DCSu9Gw,511 +OpenGL/raw/GL/ARB/spirv_extensions.py,sha256=G1fuK9jHKmmO0zcNphbiIK8UlSPrtXST2uJHoYoP3Vo,620 +OpenGL/raw/GL/ARB/stencil_texturing.py,sha256=AeaeSMzl0-oMO9fuE-6HWdtEdb-EA9EKocvFj_GXae8,577 +OpenGL/raw/GL/ARB/sync.py,sha256=CEI5g3D1iMJVVSeW_sdcB0v9evMsu5e_t2H9DLw7udE,1910 +OpenGL/raw/GL/ARB/tessellation_shader.py,sha256=6Ly4cZldx07X376MeU2VQeg2GyEpHU7lNQv87GPUyF0,3282 +OpenGL/raw/GL/ARB/texture_barrier.py,sha256=Uraltx3DH6iE6FNHrlYOf7Uw2Dg6AROYT0Cbg8iw-WQ,549 +OpenGL/raw/GL/ARB/texture_border_clamp.py,sha256=hWnQYrLMM9sCPhwVbWbx6u8c-ISPrwRkjj-xioNaBuU,569 +OpenGL/raw/GL/ARB/texture_buffer_object.py,sha256=Ce9jf2n0ou1YVuxNj-H1HTXW4BVjgRPi7cidqbV1t84,989 +OpenGL/raw/GL/ARB/texture_buffer_object_rgb32.py,sha256=vmb9_yktVOSU63ocXZLPueSeAnzoVmwTtZozssHnXRw,625 +OpenGL/raw/GL/ARB/texture_buffer_range.py,sha256=Esq1m_7SNJsXQoGWQCcCSnXGLeeUHUs5qpGPnEAnJMk,863 +OpenGL/raw/GL/ARB/texture_compression.py,sha256=4qpBlTsNDs5VCTy9QVXsHkFeW-xv-7A3mVj8PWKtWvM,2731 +OpenGL/raw/GL/ARB/texture_compression_bptc.py,sha256=a1LIzG_dAVRdf6NRbGppHWZr-OWd-IhXWXZBS7FVkN8,882 +OpenGL/raw/GL/ARB/texture_compression_rgtc.py,sha256=wYU-xsL2T5-hIdU-wWT4I9c-0VXYX2M2bBuKh7k4IoY,786 +OpenGL/raw/GL/ARB/texture_cube_map.py,sha256=YJ5La_MJ9acI92juTNb9RQr-BZpsLxD9iL0Yqj1RcfI,1396 +OpenGL/raw/GL/ARB/texture_cube_map_array.py,sha256=hCTwTKheMU417WXkS6hor7dXB0gL4kQ4ZQ-H8mkQ5N4,1101 +OpenGL/raw/GL/ARB/texture_env_add.py,sha256=kUvOLCzBeEo417f4LHm43IjBoGd2eNA_h8CNCo_SzQ0,501 +OpenGL/raw/GL/ARB/texture_env_combine.py,sha256=ONzc_mhZG6IUYPqZRBSQKlVs1vNuGiVxMCjMy_bPHwA,1642 +OpenGL/raw/GL/ARB/texture_env_crossbar.py,sha256=TQzVv-I0CmsVzkbspnPijGZl3EGuSDVNAdJQF2YEBBI,511 +OpenGL/raw/GL/ARB/texture_env_dot3.py,sha256=pSt_LZoTdmVU-rM950R1PUA-RXV4rKUnp1zpDYVP4c4,594 +OpenGL/raw/GL/ARB/texture_filter_anisotropic.py,sha256=X5XPe7u2C59o1v1g5gJfUjVwNT1ZOdZiOmhF7YYYKZY,660 +OpenGL/raw/GL/ARB/texture_filter_minmax.py,sha256=ua1Qcce2MGj7YAlXoUxaK47ehAcjAIHq6YtMNhyb4WY,646 +OpenGL/raw/GL/ARB/texture_float.py,sha256=kKiHRxk8b-mbEr-lvGfdLyvFZeBusNG9-iZKb6TqlGo,1628 +OpenGL/raw/GL/ARB/texture_gather.py,sha256=2Kbs9O2K-HvP72d5UEaU98Iuen8JECIR2gwNLz70DeA,791 +OpenGL/raw/GL/ARB/texture_mirror_clamp_to_edge.py,sha256=ddCO07lgaRYf2zeaLgFLNJ7wzw7LId0RJhe4TlM6VlI,587 +OpenGL/raw/GL/ARB/texture_mirrored_repeat.py,sha256=fgYOoGN1RxiQ4FuYiOXSZtTExQc8nUsmhDhKSnKxvfM,575 +OpenGL/raw/GL/ARB/texture_multisample.py,sha256=uxk7OPXmHqCftQ2DJlCE6uWpYmHCDTiKKX9-X2XEgPE,2619 +OpenGL/raw/GL/ARB/texture_non_power_of_two.py,sha256=FKUP_PGJx4xLSKXF_QcLSTZjGD-QQnTqVasrJBD72Ps,519 +OpenGL/raw/GL/ARB/texture_query_levels.py,sha256=izpRRUGAgHFrVMzbBAczDsXLSgax0Wab-Ys5_W9ixTk,511 +OpenGL/raw/GL/ARB/texture_query_lod.py,sha256=GV6-Wbs1XkFRJ85VrAUy0zFB57i2XqqfY809QZbqyKU,505 +OpenGL/raw/GL/ARB/texture_rectangle.py,sha256=HshNk8a-fZ7Xdh1NH-pv3-eRlv1aoMfhtLJGuYoHqxE,802 +OpenGL/raw/GL/ARB/texture_rg.py,sha256=hYSQgma4ghA3O35tEgZgN321hqE66vPFnb27_N6pqks,1148 +OpenGL/raw/GL/ARB/texture_rgb10_a2ui.py,sha256=kho5rDTJodeVonyzhmJtYbEOxtwACY1-NDTvM7-zLbU,547 +OpenGL/raw/GL/ARB/texture_stencil8.py,sha256=-ROwIhoYNcLWKJe0HwXxrTBZ4RaI9ODyMMZZnzmdJdQ,598 +OpenGL/raw/GL/ARB/texture_storage.py,sha256=UAJFaP1WZivUgRw9GMzuRTGy7KYflk7lt_BGnywY9w4,1002 +OpenGL/raw/GL/ARB/texture_storage_multisample.py,sha256=IYdJ-eJBd375oyZ0qsyizoNBRORlsDLnf-ujL0ARmUU,926 +OpenGL/raw/GL/ARB/texture_swizzle.py,sha256=9zwZPYy5fb7UM0_bCfOSfJjV9R3KdMVmkfln_T5q_Iw,781 +OpenGL/raw/GL/ARB/texture_view.py,sha256=QXE9JjQy8t1guq3_l2iCmBPuGZ_LSLZf_1MQMzmsl68,1038 +OpenGL/raw/GL/ARB/timer_query.py,sha256=AjBOduDlcaL0Jv7j53Q-9zB7TQqgZjCSlPyBv8JFsUc,872 +OpenGL/raw/GL/ARB/transform_feedback2.py,sha256=5J9cbK9GPDDt-bqs877xGSQTmjNB4UwM0Edt4t7h4GA,1352 +OpenGL/raw/GL/ARB/transform_feedback3.py,sha256=kn63DcKBPznlrDPsPEcemjA-_bnWQt-p8UAlGvyq9zk,1062 +OpenGL/raw/GL/ARB/transform_feedback_instanced.py,sha256=AhcPEWrY0Db5gzOtfTnNJwgassm1AyZjReHTe4BVKqI,788 +OpenGL/raw/GL/ARB/transform_feedback_overflow_query.py,sha256=5VWojot0JYWuHhpgT1ztLOvrL2Ne0lqCEfPJZaXe_Ks,716 +OpenGL/raw/GL/ARB/transpose_matrix.py,sha256=jnBbZTH2x9D-Q3q939LgeAqKxMKGYYHXGKvKS3CBmHk,1129 +OpenGL/raw/GL/ARB/uniform_buffer_object.py,sha256=5ry6WhaAEkdlS1uSxNvg6mHWcXsjBXMT1TGFYTVviUs,4360 +OpenGL/raw/GL/ARB/vertex_array_bgra.py,sha256=JdgDtU-aiZ823m6J3w3TpYa9GNncwbbWzXhYqi3JJ30,533 +OpenGL/raw/GL/ARB/vertex_array_object.py,sha256=yRz25nA4iXyAe7Dq401NcvffvH7-MjHTzw0R-356ZqU,884 +OpenGL/raw/GL/ARB/vertex_attrib_64bit.py,sha256=1pPvBF0PYeSUDyN5YCAQSsCXA2gU1SQd3V1jQvTqNck,2103 +OpenGL/raw/GL/ARB/vertex_attrib_binding.py,sha256=kaMrwmxI_8vDzd8FTp0_w9gc0ZUWoYi1KAXx2ear-2A,1749 +OpenGL/raw/GL/ARB/vertex_blend.py,sha256=IHyIt6fMwRC-_YJ5XeQAtCOdeeLHyUOpWW83jM4X1FA,3602 +OpenGL/raw/GL/ARB/vertex_buffer_object.py,sha256=229UlwEWwxc44du4p_C65hlromIKlTSWxkCxOkxebpo,3691 +OpenGL/raw/GL/ARB/vertex_program.py,sha256=_nlJt_UT6cXfOBXov3KMr572KJ_nzNYet7p-j-4oq0A,11929 +OpenGL/raw/GL/ARB/vertex_shader.py,sha256=ZSQK4M3GJMazq-c0PhyezJf9D8RpaOD-VH-Fy4FkeDM,6983 +OpenGL/raw/GL/ARB/vertex_type_10f_11f_11f_rev.py,sha256=7_vfU08aAzokoaBLKGcV11OC1aWDL-YxJ73FETn5wbI,601 +OpenGL/raw/GL/ARB/vertex_type_2_10_10_10_rev.py,sha256=x8GDFfX8XTcNkUrtv6GcTkkrF5zpX6BPeaGLcmRn4lo,4350 +OpenGL/raw/GL/ARB/viewport_array.py,sha256=RaevvalvHbgoRkZOFtY6Vr6C0opKIgIi4zKXy9eMrQE,2274 +OpenGL/raw/GL/ARB/window_pos.py,sha256=jW118oxXRHj9OWcvJfZM2plRYJaXoXxsqAVXNyAFWbM,1699 +OpenGL/raw/GL/ARM/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/raw/GL/ARM/__pycache__/__init__.cpython-312.pyc,, +OpenGL/raw/GL/ATI/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/raw/GL/ATI/__pycache__/__init__.cpython-312.pyc,, +OpenGL/raw/GL/ATI/__pycache__/draw_buffers.cpython-312.pyc,, +OpenGL/raw/GL/ATI/__pycache__/element_array.cpython-312.pyc,, +OpenGL/raw/GL/ATI/__pycache__/envmap_bumpmap.cpython-312.pyc,, +OpenGL/raw/GL/ATI/__pycache__/fragment_shader.cpython-312.pyc,, +OpenGL/raw/GL/ATI/__pycache__/map_object_buffer.cpython-312.pyc,, +OpenGL/raw/GL/ATI/__pycache__/meminfo.cpython-312.pyc,, +OpenGL/raw/GL/ATI/__pycache__/pixel_format_float.cpython-312.pyc,, +OpenGL/raw/GL/ATI/__pycache__/pn_triangles.cpython-312.pyc,, +OpenGL/raw/GL/ATI/__pycache__/separate_stencil.cpython-312.pyc,, +OpenGL/raw/GL/ATI/__pycache__/text_fragment_shader.cpython-312.pyc,, +OpenGL/raw/GL/ATI/__pycache__/texture_env_combine3.cpython-312.pyc,, +OpenGL/raw/GL/ATI/__pycache__/texture_float.cpython-312.pyc,, +OpenGL/raw/GL/ATI/__pycache__/texture_mirror_once.cpython-312.pyc,, +OpenGL/raw/GL/ATI/__pycache__/vertex_array_object.cpython-312.pyc,, +OpenGL/raw/GL/ATI/__pycache__/vertex_attrib_array_object.cpython-312.pyc,, +OpenGL/raw/GL/ATI/__pycache__/vertex_streams.cpython-312.pyc,, +OpenGL/raw/GL/ATI/draw_buffers.py,sha256=Lbo65lARN5sMO1Hf7BFIy7M24C910KsIOxb-6nKN4Dw,1499 +OpenGL/raw/GL/ATI/element_array.py,sha256=GWsIrOwC9_dnZH81izI5tvIlM6uFteq6RibsuLXbI64,985 +OpenGL/raw/GL/ATI/envmap_bumpmap.py,sha256=9hqP1--Y8t4hYL5MLhbDDoCDKaFeqOpadvP2C1Fxwgg,1317 +OpenGL/raw/GL/ATI/fragment_shader.py,sha256=hHO6fM8ltnTD9r-cZ7XMrlINS_0q9Fb2ddDiVADkGLc,7101 +OpenGL/raw/GL/ATI/map_object_buffer.py,sha256=2VN1d1ErQ_tMCjjT6cNSkYbbIbk9tk5av8EBtM5GX5g,655 +OpenGL/raw/GL/ATI/meminfo.py,sha256=_u1pPgXIneop93SFQvwZHNlVaVVlSu3zaMbspoSIEvM,687 +OpenGL/raw/GL/ATI/pixel_format_float.py,sha256=V91Kn8o1iQT2nTACl_fEIP3FPQr2CMrJmAl3qyFbVT4,648 +OpenGL/raw/GL/ATI/pn_triangles.py,sha256=P38P_oWpcuIHb-Nm5XlUOr8F8pPflmu58cMN60YAk50,1412 +OpenGL/raw/GL/ATI/separate_stencil.py,sha256=aZiSGxe7ylbhG0pVtdFldgpDT33-V1xujh7T0JzBwpg,1045 +OpenGL/raw/GL/ATI/text_fragment_shader.py,sha256=e2w-J6sbPQESdoGtwp8HZq4AdwIu-kQp0f242xqFleo,579 +OpenGL/raw/GL/ATI/texture_env_combine3.py,sha256=Cxqu17h0nzR1SxSfd8tHWSE6i169fCS_6cCUk3NqBmA,693 +OpenGL/raw/GL/ATI/texture_float.py,sha256=INcgpCn3XtlhknXQo0FkyTnsMahVRmWPIEknZgr36wA,1216 +OpenGL/raw/GL/ATI/texture_mirror_once.py,sha256=G7vkq1Q6FG43dJQY7wLHNzz7dvOKjivztafFZeqLw6o,630 +OpenGL/raw/GL/ATI/vertex_array_object.py,sha256=YCjoeWReLfqlsApIRrH8yieuJfoLnEe-S0LCiRvoqfM,2331 +OpenGL/raw/GL/ATI/vertex_attrib_array_object.py,sha256=0k7b8aQWjMxbGd8k6nOzj7g5jVvR0nBtyQHsPydfbSM,957 +OpenGL/raw/GL/ATI/vertex_streams.py,sha256=ltXvya0iCzb13MhF0Bt-7MI-YmLh_fHXTFTqbDO60hA,5528 +OpenGL/raw/GL/DFX/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/raw/GL/DFX/__pycache__/__init__.cpython-312.pyc,, +OpenGL/raw/GL/DFX/__pycache__/multisample.cpython-312.pyc,, +OpenGL/raw/GL/DFX/__pycache__/tbuffer.cpython-312.pyc,, +OpenGL/raw/GL/DFX/__pycache__/texture_compression_FXT1.cpython-312.pyc,, +OpenGL/raw/GL/DFX/multisample.py,sha256=tNPzjH06gInZCDqI9g49DOTezijqGYZ9U-2qlChutcQ,714 +OpenGL/raw/GL/DFX/tbuffer.py,sha256=c1tyrfCU7KGjAxVD6v0oGd8bBhhAF6GhRk6c4fBjfEQ,548 +OpenGL/raw/GL/DFX/texture_compression_FXT1.py,sha256=IyXugI7-yrVtnMmOfgTeENMXjyMjeg2QXkQHsXAuJDE,658 +OpenGL/raw/GL/DMP/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/raw/GL/DMP/__pycache__/__init__.cpython-312.pyc,, +OpenGL/raw/GL/EXT/EGL_image_storage.py,sha256=PCiQxMM2fw-X7YXENe1JNn50wDd3A581c83pWUAGccQ,773 +OpenGL/raw/GL/EXT/EGL_sync.py,sha256=Vgtw-k2Uv6HsiMLpmEYvH3Ax_MWQcV5_-iUR6RKR1To,487 +OpenGL/raw/GL/EXT/GL_422_pixels.py,sha256=cpd9UrzAs_kf_q6Nr3hFBWx0yIqinSAY645RjxGi7uA,684 +OpenGL/raw/GL/EXT/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/raw/GL/EXT/__pycache__/EGL_image_storage.cpython-312.pyc,, +OpenGL/raw/GL/EXT/__pycache__/EGL_sync.cpython-312.pyc,, +OpenGL/raw/GL/EXT/__pycache__/GL_422_pixels.cpython-312.pyc,, +OpenGL/raw/GL/EXT/__pycache__/__init__.cpython-312.pyc,, +OpenGL/raw/GL/EXT/__pycache__/abgr.cpython-312.pyc,, +OpenGL/raw/GL/EXT/__pycache__/bgra.cpython-312.pyc,, +OpenGL/raw/GL/EXT/__pycache__/bindable_uniform.cpython-312.pyc,, +OpenGL/raw/GL/EXT/__pycache__/blend_color.cpython-312.pyc,, +OpenGL/raw/GL/EXT/__pycache__/blend_equation_separate.cpython-312.pyc,, +OpenGL/raw/GL/EXT/__pycache__/blend_func_separate.cpython-312.pyc,, +OpenGL/raw/GL/EXT/__pycache__/blend_logic_op.cpython-312.pyc,, +OpenGL/raw/GL/EXT/__pycache__/blend_minmax.cpython-312.pyc,, +OpenGL/raw/GL/EXT/__pycache__/blend_subtract.cpython-312.pyc,, +OpenGL/raw/GL/EXT/__pycache__/clip_volume_hint.cpython-312.pyc,, +OpenGL/raw/GL/EXT/__pycache__/cmyka.cpython-312.pyc,, +OpenGL/raw/GL/EXT/__pycache__/color_subtable.cpython-312.pyc,, +OpenGL/raw/GL/EXT/__pycache__/compiled_vertex_array.cpython-312.pyc,, +OpenGL/raw/GL/EXT/__pycache__/convolution.cpython-312.pyc,, +OpenGL/raw/GL/EXT/__pycache__/coordinate_frame.cpython-312.pyc,, +OpenGL/raw/GL/EXT/__pycache__/copy_texture.cpython-312.pyc,, +OpenGL/raw/GL/EXT/__pycache__/cull_vertex.cpython-312.pyc,, +OpenGL/raw/GL/EXT/__pycache__/debug_label.cpython-312.pyc,, +OpenGL/raw/GL/EXT/__pycache__/debug_marker.cpython-312.pyc,, +OpenGL/raw/GL/EXT/__pycache__/depth_bounds_test.cpython-312.pyc,, +OpenGL/raw/GL/EXT/__pycache__/direct_state_access.cpython-312.pyc,, +OpenGL/raw/GL/EXT/__pycache__/draw_buffers2.cpython-312.pyc,, +OpenGL/raw/GL/EXT/__pycache__/draw_instanced.cpython-312.pyc,, +OpenGL/raw/GL/EXT/__pycache__/draw_range_elements.cpython-312.pyc,, +OpenGL/raw/GL/EXT/__pycache__/external_buffer.cpython-312.pyc,, +OpenGL/raw/GL/EXT/__pycache__/fog_coord.cpython-312.pyc,, +OpenGL/raw/GL/EXT/__pycache__/framebuffer_blit.cpython-312.pyc,, +OpenGL/raw/GL/EXT/__pycache__/framebuffer_multisample.cpython-312.pyc,, +OpenGL/raw/GL/EXT/__pycache__/framebuffer_multisample_blit_scaled.cpython-312.pyc,, +OpenGL/raw/GL/EXT/__pycache__/framebuffer_object.cpython-312.pyc,, +OpenGL/raw/GL/EXT/__pycache__/framebuffer_sRGB.cpython-312.pyc,, +OpenGL/raw/GL/EXT/__pycache__/geometry_shader4.cpython-312.pyc,, +OpenGL/raw/GL/EXT/__pycache__/gpu_program_parameters.cpython-312.pyc,, +OpenGL/raw/GL/EXT/__pycache__/gpu_shader4.cpython-312.pyc,, +OpenGL/raw/GL/EXT/__pycache__/histogram.cpython-312.pyc,, +OpenGL/raw/GL/EXT/__pycache__/index_array_formats.cpython-312.pyc,, +OpenGL/raw/GL/EXT/__pycache__/index_func.cpython-312.pyc,, +OpenGL/raw/GL/EXT/__pycache__/index_material.cpython-312.pyc,, +OpenGL/raw/GL/EXT/__pycache__/index_texture.cpython-312.pyc,, +OpenGL/raw/GL/EXT/__pycache__/light_texture.cpython-312.pyc,, +OpenGL/raw/GL/EXT/__pycache__/memory_object.cpython-312.pyc,, +OpenGL/raw/GL/EXT/__pycache__/memory_object_fd.cpython-312.pyc,, +OpenGL/raw/GL/EXT/__pycache__/memory_object_win32.cpython-312.pyc,, +OpenGL/raw/GL/EXT/__pycache__/misc_attribute.cpython-312.pyc,, +OpenGL/raw/GL/EXT/__pycache__/multi_draw_arrays.cpython-312.pyc,, +OpenGL/raw/GL/EXT/__pycache__/multisample.cpython-312.pyc,, +OpenGL/raw/GL/EXT/__pycache__/multiview_tessellation_geometry_shader.cpython-312.pyc,, +OpenGL/raw/GL/EXT/__pycache__/multiview_texture_multisample.cpython-312.pyc,, +OpenGL/raw/GL/EXT/__pycache__/multiview_timer_query.cpython-312.pyc,, +OpenGL/raw/GL/EXT/__pycache__/packed_depth_stencil.cpython-312.pyc,, +OpenGL/raw/GL/EXT/__pycache__/packed_float.cpython-312.pyc,, +OpenGL/raw/GL/EXT/__pycache__/packed_pixels.cpython-312.pyc,, +OpenGL/raw/GL/EXT/__pycache__/paletted_texture.cpython-312.pyc,, +OpenGL/raw/GL/EXT/__pycache__/pixel_buffer_object.cpython-312.pyc,, +OpenGL/raw/GL/EXT/__pycache__/pixel_transform.cpython-312.pyc,, +OpenGL/raw/GL/EXT/__pycache__/pixel_transform_color_table.cpython-312.pyc,, +OpenGL/raw/GL/EXT/__pycache__/point_parameters.cpython-312.pyc,, +OpenGL/raw/GL/EXT/__pycache__/polygon_offset.cpython-312.pyc,, +OpenGL/raw/GL/EXT/__pycache__/polygon_offset_clamp.cpython-312.pyc,, +OpenGL/raw/GL/EXT/__pycache__/post_depth_coverage.cpython-312.pyc,, +OpenGL/raw/GL/EXT/__pycache__/provoking_vertex.cpython-312.pyc,, +OpenGL/raw/GL/EXT/__pycache__/raster_multisample.cpython-312.pyc,, +OpenGL/raw/GL/EXT/__pycache__/rescale_normal.cpython-312.pyc,, +OpenGL/raw/GL/EXT/__pycache__/secondary_color.cpython-312.pyc,, +OpenGL/raw/GL/EXT/__pycache__/semaphore.cpython-312.pyc,, +OpenGL/raw/GL/EXT/__pycache__/semaphore_fd.cpython-312.pyc,, +OpenGL/raw/GL/EXT/__pycache__/semaphore_win32.cpython-312.pyc,, +OpenGL/raw/GL/EXT/__pycache__/separate_shader_objects.cpython-312.pyc,, +OpenGL/raw/GL/EXT/__pycache__/separate_specular_color.cpython-312.pyc,, +OpenGL/raw/GL/EXT/__pycache__/shader_framebuffer_fetch.cpython-312.pyc,, +OpenGL/raw/GL/EXT/__pycache__/shader_framebuffer_fetch_non_coherent.cpython-312.pyc,, +OpenGL/raw/GL/EXT/__pycache__/shader_image_load_formatted.cpython-312.pyc,, +OpenGL/raw/GL/EXT/__pycache__/shader_image_load_store.cpython-312.pyc,, +OpenGL/raw/GL/EXT/__pycache__/shader_integer_mix.cpython-312.pyc,, +OpenGL/raw/GL/EXT/__pycache__/shadow_funcs.cpython-312.pyc,, +OpenGL/raw/GL/EXT/__pycache__/shared_texture_palette.cpython-312.pyc,, +OpenGL/raw/GL/EXT/__pycache__/sparse_texture2.cpython-312.pyc,, +OpenGL/raw/GL/EXT/__pycache__/stencil_clear_tag.cpython-312.pyc,, +OpenGL/raw/GL/EXT/__pycache__/stencil_two_side.cpython-312.pyc,, +OpenGL/raw/GL/EXT/__pycache__/stencil_wrap.cpython-312.pyc,, +OpenGL/raw/GL/EXT/__pycache__/subtexture.cpython-312.pyc,, +OpenGL/raw/GL/EXT/__pycache__/texture.cpython-312.pyc,, +OpenGL/raw/GL/EXT/__pycache__/texture3D.cpython-312.pyc,, +OpenGL/raw/GL/EXT/__pycache__/texture_array.cpython-312.pyc,, +OpenGL/raw/GL/EXT/__pycache__/texture_buffer_object.cpython-312.pyc,, +OpenGL/raw/GL/EXT/__pycache__/texture_compression_latc.cpython-312.pyc,, +OpenGL/raw/GL/EXT/__pycache__/texture_compression_rgtc.cpython-312.pyc,, +OpenGL/raw/GL/EXT/__pycache__/texture_compression_s3tc.cpython-312.pyc,, +OpenGL/raw/GL/EXT/__pycache__/texture_cube_map.cpython-312.pyc,, +OpenGL/raw/GL/EXT/__pycache__/texture_env_add.cpython-312.pyc,, +OpenGL/raw/GL/EXT/__pycache__/texture_env_combine.cpython-312.pyc,, +OpenGL/raw/GL/EXT/__pycache__/texture_env_dot3.cpython-312.pyc,, +OpenGL/raw/GL/EXT/__pycache__/texture_filter_anisotropic.cpython-312.pyc,, +OpenGL/raw/GL/EXT/__pycache__/texture_filter_minmax.cpython-312.pyc,, +OpenGL/raw/GL/EXT/__pycache__/texture_integer.cpython-312.pyc,, +OpenGL/raw/GL/EXT/__pycache__/texture_lod_bias.cpython-312.pyc,, +OpenGL/raw/GL/EXT/__pycache__/texture_mirror_clamp.cpython-312.pyc,, +OpenGL/raw/GL/EXT/__pycache__/texture_object.cpython-312.pyc,, +OpenGL/raw/GL/EXT/__pycache__/texture_perturb_normal.cpython-312.pyc,, +OpenGL/raw/GL/EXT/__pycache__/texture_sRGB.cpython-312.pyc,, +OpenGL/raw/GL/EXT/__pycache__/texture_sRGB_R8.cpython-312.pyc,, +OpenGL/raw/GL/EXT/__pycache__/texture_sRGB_decode.cpython-312.pyc,, +OpenGL/raw/GL/EXT/__pycache__/texture_shadow_lod.cpython-312.pyc,, +OpenGL/raw/GL/EXT/__pycache__/texture_shared_exponent.cpython-312.pyc,, +OpenGL/raw/GL/EXT/__pycache__/texture_snorm.cpython-312.pyc,, +OpenGL/raw/GL/EXT/__pycache__/texture_swizzle.cpython-312.pyc,, +OpenGL/raw/GL/EXT/__pycache__/timer_query.cpython-312.pyc,, +OpenGL/raw/GL/EXT/__pycache__/transform_feedback.cpython-312.pyc,, +OpenGL/raw/GL/EXT/__pycache__/vertex_array.cpython-312.pyc,, +OpenGL/raw/GL/EXT/__pycache__/vertex_array_bgra.cpython-312.pyc,, +OpenGL/raw/GL/EXT/__pycache__/vertex_attrib_64bit.cpython-312.pyc,, +OpenGL/raw/GL/EXT/__pycache__/vertex_shader.cpython-312.pyc,, +OpenGL/raw/GL/EXT/__pycache__/vertex_weighting.cpython-312.pyc,, +OpenGL/raw/GL/EXT/__pycache__/win32_keyed_mutex.cpython-312.pyc,, +OpenGL/raw/GL/EXT/__pycache__/window_rectangles.cpython-312.pyc,, +OpenGL/raw/GL/EXT/__pycache__/x11_sync_object.cpython-312.pyc,, +OpenGL/raw/GL/EXT/abgr.py,sha256=_23tmG1BCU0P209OrQsjYIZAyJQa5_uQTe74WvZ7Y2A,515 +OpenGL/raw/GL/EXT/bgra.py,sha256=eTvYdMhmK048JJ47NERjZQ1TvEiKA3c8WmAkE6E2oFs,550 +OpenGL/raw/GL/EXT/bindable_uniform.py,sha256=TrAK4qWWGo38i_xPh8JioWh7zmDtNqyDj7ZzhbG_BSg,1275 +OpenGL/raw/GL/EXT/blend_color.py,sha256=7bzCDyUrAMR1e5If2ddoSQKrwi_qU3Cdrh-urA-mDws,925 +OpenGL/raw/GL/EXT/blend_equation_separate.py,sha256=cpKoI61cUKQg6lVgjZrN9Bn0yo1gbBriHp3YgKxAd84,746 +OpenGL/raw/GL/EXT/blend_func_separate.py,sha256=s2C9bnzzk25wLP28avqRjgeEugNke8737ichagmpB7E,880 +OpenGL/raw/GL/EXT/blend_logic_op.py,sha256=TAANMPUl5TYs_MSzy8R3nmYUe-UXOmzAZq2JKyCMc5Y,499 +OpenGL/raw/GL/EXT/blend_minmax.py,sha256=GS16b_wktPDtw0rziciOyUTNCX4fXlBdo-v9hZbPI3g,730 +OpenGL/raw/GL/EXT/blend_subtract.py,sha256=SZjc3FgzflF3NIO7SCxwzjh6KRUP4pJB0h3oRhjNtxs,624 +OpenGL/raw/GL/EXT/clip_volume_hint.py,sha256=inXLeDh3xDGN1iFB2pU6RsOctIHc-c5O5FV4VNRpW94,581 +OpenGL/raw/GL/EXT/cmyka.py,sha256=lZqMI-ps1nJexpmgQqdUKEPceeji3QmtguncoH746Ow,674 +OpenGL/raw/GL/EXT/color_subtable.py,sha256=VZqsdOu_GeCXqU2TGlf6XVfOD3hhLsuStKy5mJVxgV8,787 +OpenGL/raw/GL/EXT/compiled_vertex_array.py,sha256=teFOPFI31Mmm4rxvIfPifqFeCrDJNka7j6EtQ-ztuJU,795 +OpenGL/raw/GL/EXT/convolution.py,sha256=_AjAzpEMzpIS1h90d_ULJmA-VAR10RqdkAUMb13YrCY,3810 +OpenGL/raw/GL/EXT/coordinate_frame.py,sha256=debY2dtwH7yVSfRfLcqKUEPNugHxjhQMeG8dbX1tdYM,3158 +OpenGL/raw/GL/EXT/copy_texture.py,sha256=00JMcSBZT6-_4XXSZAmvsAJrybB_v5RjX6rE4d0dig4,1384 +OpenGL/raw/GL/EXT/cull_vertex.py,sha256=5Kl81xssInTUDt6UpbfKSeVtVq1Kiam9CVKzgyKc9us,893 +OpenGL/raw/GL/EXT/debug_label.py,sha256=7xP0Ss1owLdZVEFcBuQTmxG_hS218cf0nbpgxRL9l3U,1226 +OpenGL/raw/GL/EXT/debug_marker.py,sha256=IW5my9uvQCUCPjBUIdyXbjDraeJH1o7ByknpFmIm1QY,740 +OpenGL/raw/GL/EXT/depth_bounds_test.py,sha256=ba6p8enhBkwIU4yzNb6cZwdI9sbsl0_W48P6HEwE6n8,702 +OpenGL/raw/GL/EXT/direct_state_access.py,sha256=5naUYeOoMrHacFbJokju6Q6I-tqBwL2r95TTgb8-aTc,38648 +OpenGL/raw/GL/EXT/draw_buffers2.py,sha256=5ra2vofDLlgv1uOoDnwJvjeV4m6cj7nFlEF0M6qkQnY,1122 +OpenGL/raw/GL/EXT/draw_instanced.py,sha256=or9Do1YWO5o9DRRW_MHdv23rpVP4Ub_3rOlMs1-uTL8,778 +OpenGL/raw/GL/EXT/draw_range_elements.py,sha256=031MLhy9tdJx6r_xLDtzBuPdg24pwTtnNTHHS8xniqo,806 +OpenGL/raw/GL/EXT/external_buffer.py,sha256=Lh5NBWoyqNr52WstWXZK9_gaFVAOqdp5gF7cEWKb_2c,853 +OpenGL/raw/GL/EXT/fog_coord.py,sha256=ly_NDlpjCymEimix0ggGBxnYtkTmqDc1pHwle0x21b8,1443 +OpenGL/raw/GL/EXT/framebuffer_blit.py,sha256=kgGiHXKF7IkEeI_NqTOvSfBAP4XhUzL0T3nzLLzIKIw,994 +OpenGL/raw/GL/EXT/framebuffer_multisample.py,sha256=cvzOVvl4lBAohpPCHsK4h72MaYaJtpHybWJ00zyQ82E,899 +OpenGL/raw/GL/EXT/framebuffer_multisample_blit_scaled.py,sha256=FubvSPU0FG5lqpEJoOgjYRIpbRI3JweYwwKe5ZONCxs,684 +OpenGL/raw/GL/EXT/framebuffer_object.py,sha256=lJUVpSpmbu5Pb8Mh6jezT8hPbDi2os-aqGcHP0hHYqA,6202 +OpenGL/raw/GL/EXT/framebuffer_sRGB.py,sha256=zHgnfraLXiDpbMEutJcqBMoBS3xIVB7wRfIfEOdAuho,640 +OpenGL/raw/GL/EXT/geometry_shader4.py,sha256=ljmEfSWbtSzNrbk5bkdCSnoB3kWjwHmSv7iSQNn0MXo,2218 +OpenGL/raw/GL/EXT/gpu_program_parameters.py,sha256=ncz4sNhE3j5-_4A3lDkh20qT-Bi_IBlP6izKOG8GIOU,794 +OpenGL/raw/GL/EXT/gpu_shader4.py,sha256=N_cFDyu9fo3AR7AnxmUJL0WpCQ6UQMxdfODc3wlNS7g,3629 +OpenGL/raw/GL/EXT/histogram.py,sha256=ZEMzRJTGzAE5asPksrP4e18r0sPcHCSXtmzcZ4yfWIQ,2444 +OpenGL/raw/GL/EXT/index_array_formats.py,sha256=0Z7yZSMY3hOyk4oVJXzb6cCGdIOkwHsRNWJ8ShqpytI,916 +OpenGL/raw/GL/EXT/index_func.py,sha256=GUni_p1rbz7DYLZYYHFACdD7yucKJlnLphB4-1THc1U,732 +OpenGL/raw/GL/EXT/index_material.py,sha256=pfB2kwzw42J2AmUq4Vga5mWcx-DPSJbHqlSLTUwUK_w,779 +OpenGL/raw/GL/EXT/index_texture.py,sha256=g3SWzrKYO021m28ySZPNsPRUMKSXEg64QS4LAyh86fY,497 +OpenGL/raw/GL/EXT/light_texture.py,sha256=ZiQIhKeRiYhTbW3HohWJrpvuWOoWs-D7oaLTQM76Qho,1343 +OpenGL/raw/GL/EXT/memory_object.py,sha256=E86nWEeb4b1BgaYSyinfI0vQYC3NxfZ7LolMqYK1nmI,4280 +OpenGL/raw/GL/EXT/memory_object_fd.py,sha256=HSzuLsBtOk-zqJGqxBGeUfavZ94wIx-JwvUIBIhgOw4,693 +OpenGL/raw/GL/EXT/memory_object_win32.py,sha256=_i0XIfqG32rE9CAK-NFT0MPEPKqYgT2CEX4wdd1D6ls,1419 +OpenGL/raw/GL/EXT/misc_attribute.py,sha256=CQGBUIByf6lnRYJfAbAcBTLIeYhjkaUOyQoBNSNU8Hs,499 +OpenGL/raw/GL/EXT/multi_draw_arrays.py,sha256=mpxxuLVGmxwTu7Gm5eBuD6agwcxRUXLtO2LSBakKCgI,804 +OpenGL/raw/GL/EXT/multisample.py,sha256=VIjphE2hMHooKkFHMcnbLRVfsUKXuEldC7L1V56TypE,1528 +OpenGL/raw/GL/EXT/multiview_tessellation_geometry_shader.py,sha256=7diBMLXOxPMBmYde_R4fodVf8D-MANUoH-r06MwD8Qo,547 +OpenGL/raw/GL/EXT/multiview_texture_multisample.py,sha256=OS-d-3J1VFoFXkvra1SLRslc9uF7k5Y8btiUg9mqpYw,529 +OpenGL/raw/GL/EXT/multiview_timer_query.py,sha256=JNCb-aoIHIc3Q7UnYyJQ0uhRpBoox64dRysMvzLMjec,513 +OpenGL/raw/GL/EXT/packed_depth_stencil.py,sha256=fNB-SgxV6UERDx-9dJephywSemsCDTsqelUu-XfdY6U,758 +OpenGL/raw/GL/EXT/packed_float.py,sha256=-os00mjX-t2xJwySE9rlruUF-rM3bM01KQfAPycKKNA,709 +OpenGL/raw/GL/EXT/packed_pixels.py,sha256=38LX7PWdKyY3pk1fi51IlizorghsXdjwE0W56XDLIVU,853 +OpenGL/raw/GL/EXT/paletted_texture.py,sha256=8RmQ0fZCGn7IwT13KSo1xcZ3os0_nv6pu0PF2_T9_NM,1416 +OpenGL/raw/GL/EXT/pixel_buffer_object.py,sha256=oswgOc_5BRcB2OC0W0pOjtMk1yMcC7Ed5aTHdkG6S8c,800 +OpenGL/raw/GL/EXT/pixel_transform.py,sha256=HgDjFQs7iBczHgphVFDBdS4o8vgga-4GO-eMiYtsJjk,1816 +OpenGL/raw/GL/EXT/pixel_transform_color_table.py,sha256=z6jODXZxVEjwBML0egmWw7AdiFdPDugE9DWK9Sose-E,525 +OpenGL/raw/GL/EXT/point_parameters.py,sha256=AsuuexaU8iarQtGGh3BAkjTuBoX1W-DFZYwKp6NZivs,945 +OpenGL/raw/GL/EXT/polygon_offset.py,sha256=rk7xoX4KiUwHZpXJ_z-6BLGCATfCBRSphWnkHvfo9Bw,777 +OpenGL/raw/GL/EXT/polygon_offset_clamp.py,sha256=KsvPBbB7a9SmE24CVqVq6rr7pqYlQO3MiU-Tw78oEAA,687 +OpenGL/raw/GL/EXT/post_depth_coverage.py,sha256=p0hJ9r7K7lbiiIJ__se3ZhB_fCcUssth3i5AgLq3ORo,509 +OpenGL/raw/GL/EXT/provoking_vertex.py,sha256=15wFhHIuaCWGYGQNkzaDpsIAoGMSVgvNr3SsbE4XObM,886 +OpenGL/raw/GL/EXT/raster_multisample.py,sha256=9xkkoz0kExYppJjOgjKf3_lTXSAiGtzb5csF_0Qi6mQ,1054 +OpenGL/raw/GL/EXT/rescale_normal.py,sha256=7c3l5Gc444Sfw8Q3EG9AHaUQVfeTT3qJ062EU7ckiUk,555 +OpenGL/raw/GL/EXT/secondary_color.py,sha256=BgYkW7IfC4ni6GemfFQ0lMRtKzZ8rRNrB7bSZhuIPS0,2579 +OpenGL/raw/GL/EXT/semaphore.py,sha256=Pjwmq8qxpp2l17zalv6NnetkEj2kNimu-WQWOnZIhR8,2593 +OpenGL/raw/GL/EXT/semaphore_fd.py,sha256=9-t5AYqgZ2dLgfhwWLpk9zCEzXx-4jK4yhspso43UrE,673 +OpenGL/raw/GL/EXT/semaphore_win32.py,sha256=Tss_kMcPMgIpTOo_bdR8KPSA7hJVFWpHkTFRvkmSfIc,1205 +OpenGL/raw/GL/EXT/separate_shader_objects.py,sha256=8_p92pUw_l-ZaQVVnoxhqKnvVaeWSrx9JzZ5pv5qzho,7176 +OpenGL/raw/GL/EXT/separate_specular_color.py,sha256=1JXisE-Q70xweG_lWfw-oAw9I55h7tIgkyz5ABH412g,723 +OpenGL/raw/GL/EXT/shader_framebuffer_fetch.py,sha256=-A6J2M4_B3alenENz1HuqosF_zKAJ4NQWaURz34Eles,611 +OpenGL/raw/GL/EXT/shader_framebuffer_fetch_non_coherent.py,sha256=fbzrGxsHpDQU7qyE8o7y57ms571Y0VAvWa0qjjth64g,697 +OpenGL/raw/GL/EXT/shader_image_load_formatted.py,sha256=cgG2FzBNWNjdCsB3MITExzMXXvayBkYe2_SMzvsznm8,525 +OpenGL/raw/GL/EXT/shader_image_load_store.py,sha256=vFR-m95pPCR9Jdu8mwDpCVYt0yV4YccNHDCsrCTCd6Y,4732 +OpenGL/raw/GL/EXT/shader_integer_mix.py,sha256=iHb2ytvBtAMJ1qEI5E8-l6Yggj8Ug9Dhxmut9o6Q6T0,507 +OpenGL/raw/GL/EXT/shadow_funcs.py,sha256=f3GY4gVW0VeOq4pmLmGF9XuXF7pCll4w4FWL3TbiYKg,495 +OpenGL/raw/GL/EXT/shared_texture_palette.py,sha256=ycrLzKLlzq_QMp28XZfrkcYUx6WyUs-j3Fzmxuw99PY,587 +OpenGL/raw/GL/EXT/sparse_texture2.py,sha256=RD-0tN8gXWYOZkK5S8TWK5CRqGLqfaD3r6kgELtQ9L0,501 +OpenGL/raw/GL/EXT/stencil_clear_tag.py,sha256=1cBBSg1mWCgMTw_UIs4bwY_PGinXF1sfN1Dv0fHrwHo,744 +OpenGL/raw/GL/EXT/stencil_two_side.py,sha256=SFBIPJDD223qWPrH4w_2u0wDvyctCVVvrEoO3IYi-4Y,708 +OpenGL/raw/GL/EXT/stencil_wrap.py,sha256=y98X1YNdpg49NP3WmmCHINF485UC4BrAyKgMhAmXqYM,588 +OpenGL/raw/GL/EXT/subtexture.py,sha256=dhjNFT8p1bjUHVtJSUC0zDSep1xBXXWIcC1uj1HH5XA,879 +OpenGL/raw/GL/EXT/texture.py,sha256=munEblAXuUAYYJIdnvIs-F9sP4l4k714KwTvpICRcIk,2667 +OpenGL/raw/GL/EXT/texture3D.py,sha256=uKay03rRq8nAOcSFULZcPGqJJqWJVY_dd8PNg4_oOyc,1516 +OpenGL/raw/GL/EXT/texture_array.py,sha256=twMMYGzV2CUQYgecBGLa1ji5iXBh3E9fzX0puBi4-QQ,1330 +OpenGL/raw/GL/EXT/texture_buffer_object.py,sha256=ytdtTSARW9ZcD8_Vetf2d0kCyxJ9VtZ6r1ITy8ts8M8,989 +OpenGL/raw/GL/EXT/texture_compression_latc.py,sha256=_ATN1dQsIzBmhIXS8Gvr-Mt9uEkyzTsZYCDAHwLjt_4,894 +OpenGL/raw/GL/EXT/texture_compression_rgtc.py,sha256=Qkv8XifraSbfIfNZUaVn-3fsdX8eidkKrPhAGIjWMZg,846 +OpenGL/raw/GL/EXT/texture_compression_s3tc.py,sha256=WbW5CuaRq7a76JfNCnHx0qNHGyuj29eRSEtJZwMWDbs,832 +OpenGL/raw/GL/EXT/texture_cube_map.py,sha256=NRc4CH5-XcorUiNX7VtYLjnJnULf6SnBKqOuJLgrJIQ,1396 +OpenGL/raw/GL/EXT/texture_env_add.py,sha256=xmL17xjbipCgiyn1PJJ-4dMiASR6zYJ28uwirWmC9uw,501 +OpenGL/raw/GL/EXT/texture_env_combine.py,sha256=SDg27JXYNQw7q_1g7jkv9VoBqqZp7SIS_QI5R524duY,1597 +OpenGL/raw/GL/EXT/texture_env_dot3.py,sha256=QLOEXDKcInHZ1r9WIpeYCUcPYbmhS4gQf7lhupWr-Sg,594 +OpenGL/raw/GL/EXT/texture_filter_anisotropic.py,sha256=bfMY02b1qbMxVX3wQ4l1AxjmlvcrPgX3Nq8A_pgUdwk,676 +OpenGL/raw/GL/EXT/texture_filter_minmax.py,sha256=SFJnv_dqTQGn9MlqWe64m324qfccRx1DD7PQ0sVtCFQ,646 +OpenGL/raw/GL/EXT/texture_integer.py,sha256=qehFzwSEzzuImH5J-ETYeSH0ielviN1IRY8CUlVrREM,3611 +OpenGL/raw/GL/EXT/texture_lod_bias.py,sha256=2UdPfS3lHhtaoa0abpkUKYyF9K57EihLeiBVDRqfeLE,705 +OpenGL/raw/GL/EXT/texture_mirror_clamp.py,sha256=wtpktXrXuheknoQq4W2wj1m_QdS8_cfpn0EMg3443Nw,705 +OpenGL/raw/GL/EXT/texture_object.py,sha256=guBFkhdRISvdbVFxHi2uZ1iH4_rkwDIfFNmg5pb5Ewg,1419 +OpenGL/raw/GL/EXT/texture_perturb_normal.py,sha256=v0gbNlnym8vkyKK5xIapgQBqndeIn6IGp4L45Sl6w6Q,678 +OpenGL/raw/GL/EXT/texture_sRGB.py,sha256=MBlXjywXIVzV1OvbYNJxeumTBuRo3Vc6HFHnmgzNHP0,1534 +OpenGL/raw/GL/EXT/texture_sRGB_R8.py,sha256=WEXiEVuz_nnd4bBhCCT_gGdY5LNNyvMsicbGtdYMihY,535 +OpenGL/raw/GL/EXT/texture_sRGB_decode.py,sha256=YnSYOpMVZZsxMZ688aGaYev4XirXuXqIVRFGbBjxMLQ,667 +OpenGL/raw/GL/EXT/texture_shadow_lod.py,sha256=TWO0SAG4a2ZAElHby5RXkJxpiVSwru4wmO8zN07ZIc0,507 +OpenGL/raw/GL/EXT/texture_shared_exponent.py,sha256=PQUm0Heebmy54xS4f8WG--UXOIFislzeFh3ZxUPRGM0,703 +OpenGL/raw/GL/EXT/texture_snorm.py,sha256=HT1yeBoSL3-twPZRpbLhFpThFG-ZyLD-gcPziuBGNY4,1689 +OpenGL/raw/GL/EXT/texture_swizzle.py,sha256=kLjEksOlsNfg8DM2lrVtpWgO3JrB-BEZ24HEHBhfn8M,821 +OpenGL/raw/GL/EXT/timer_query.py,sha256=2tr7Qeqp1VMJ9kh6OlhUeSeg6NALImGNhNGgqZgJGlQ,770 +OpenGL/raw/GL/EXT/transform_feedback.py,sha256=mofiI3CyWQtiHMgiv86XpFfkX3YT0ALLNs7vjaOIiec,2745 +OpenGL/raw/GL/EXT/vertex_array.py,sha256=pzFQ3PPg_YK4PdHRt-K_FCz7x66OU79HJPb17VSwIAM,3647 +OpenGL/raw/GL/EXT/vertex_array_bgra.py,sha256=ugcfxF6ZCWzjxV_08KPKlyMKr38xVprEYpyu-JtG1EM,533 +OpenGL/raw/GL/EXT/vertex_attrib_64bit.py,sha256=5S_b6LMGXovNChhpXjDWulz0Jnlid6bNxIY06gOq7pw,2229 +OpenGL/raw/GL/EXT/vertex_shader.py,sha256=pmO5KkPX0kMZDUT2Gb2_Yp77CJMs4nIdoP9XJbJzcZ8,11362 +OpenGL/raw/GL/EXT/vertex_weighting.py,sha256=PbUmV7DYoHluGJgBaIYyzQaD5kXe8HOQTNSRPA-oCk8,1662 +OpenGL/raw/GL/EXT/win32_keyed_mutex.py,sha256=ee4ZeQBuPplQ7rLLpBo2yoD6lqcaO-TJ49xC9sohJho,727 +OpenGL/raw/GL/EXT/window_rectangles.py,sha256=tUlY4xzVAY1anHvsAZtFecJl7ou59kjpnePyvrJvFw0,979 +OpenGL/raw/GL/EXT/x11_sync_object.py,sha256=odPwon8u_Jyt_Rixv63xOn6Fwx48UvF0uK0MCWUmGeU,686 +OpenGL/raw/GL/FJ/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/raw/GL/FJ/__pycache__/__init__.cpython-312.pyc,, +OpenGL/raw/GL/GREMEDY/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/raw/GL/GREMEDY/__pycache__/__init__.cpython-312.pyc,, +OpenGL/raw/GL/GREMEDY/__pycache__/frame_terminator.cpython-312.pyc,, +OpenGL/raw/GL/GREMEDY/__pycache__/string_marker.cpython-312.pyc,, +OpenGL/raw/GL/GREMEDY/frame_terminator.py,sha256=D0MP6phsMCKq5isr2x5JE0CJzke856X_msQfn9z2lbs,567 +OpenGL/raw/GL/GREMEDY/string_marker.py,sha256=dIYuLnBkMpPoSgyctdAmwz2mq6BeJ_uiNBHraUAYOw4,595 +OpenGL/raw/GL/HP/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/raw/GL/HP/__pycache__/__init__.cpython-312.pyc,, +OpenGL/raw/GL/HP/__pycache__/convolution_border_modes.cpython-312.pyc,, +OpenGL/raw/GL/HP/__pycache__/image_transform.cpython-312.pyc,, +OpenGL/raw/GL/HP/__pycache__/occlusion_test.cpython-312.pyc,, +OpenGL/raw/GL/HP/__pycache__/texture_lighting.cpython-312.pyc,, +OpenGL/raw/GL/HP/convolution_border_modes.py,sha256=Knj5Z9abt11xo5KzQkQeuk0GBJNyPrwkcHrhK0jJyKk,760 +OpenGL/raw/GL/HP/image_transform.py,sha256=2-glL0ue_KZqx-02O8GpDJStbnNhK4mh9w_ZOqepT40,2154 +OpenGL/raw/GL/HP/occlusion_test.py,sha256=DpqjIZThTKAeOcMZtmKvUjz0iUgPKty0EP2kCaYQEBE,620 +OpenGL/raw/GL/HP/texture_lighting.py,sha256=UB5-EIAirP_z0bArq-YfkEs_hMdiW8NAuG20zh104t4,705 +OpenGL/raw/GL/IBM/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/raw/GL/IBM/__pycache__/__init__.cpython-312.pyc,, +OpenGL/raw/GL/IBM/__pycache__/cull_vertex.cpython-312.pyc,, +OpenGL/raw/GL/IBM/__pycache__/multimode_draw_arrays.cpython-312.pyc,, +OpenGL/raw/GL/IBM/__pycache__/rasterpos_clip.cpython-312.pyc,, +OpenGL/raw/GL/IBM/__pycache__/static_data.cpython-312.pyc,, +OpenGL/raw/GL/IBM/__pycache__/texture_mirrored_repeat.cpython-312.pyc,, +OpenGL/raw/GL/IBM/__pycache__/vertex_array_lists.cpython-312.pyc,, +OpenGL/raw/GL/IBM/cull_vertex.py,sha256=hXGp_lLdIPxEk8PBydWY3WezcVPnEXzaD6YFQmRILTg,543 +OpenGL/raw/GL/IBM/multimode_draw_arrays.py,sha256=ecTV6cOGyURIKB03WCfktaY8r7QMtW6QUtAL7OYZG1c,878 +OpenGL/raw/GL/IBM/rasterpos_clip.py,sha256=svxVbtlhhGQ9Yt22gmD7VRCjG6p6mgDB1VlwmFYB95k,578 +OpenGL/raw/GL/IBM/static_data.py,sha256=6oNU7S8i5ZBc847E7sahtimzMYamutrunsp79G2N2xI,686 +OpenGL/raw/GL/IBM/texture_mirrored_repeat.py,sha256=rkEwO0utwXm3nKtMq0QA3kRhBO6C8loMi2iqHmWJAkg,575 +OpenGL/raw/GL/IBM/vertex_array_lists.py,sha256=03wsDspHAXaDRhFBrOPI-UuGjoSYXHbjmNCRYOETzN0,2855 +OpenGL/raw/GL/IMG/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/raw/GL/IMG/__pycache__/__init__.cpython-312.pyc,, +OpenGL/raw/GL/INGR/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/raw/GL/INGR/__pycache__/__init__.cpython-312.pyc,, +OpenGL/raw/GL/INGR/__pycache__/blend_func_separate.cpython-312.pyc,, +OpenGL/raw/GL/INGR/__pycache__/color_clamp.cpython-312.pyc,, +OpenGL/raw/GL/INGR/__pycache__/interlace_read.cpython-312.pyc,, +OpenGL/raw/GL/INGR/blend_func_separate.py,sha256=_eF2j3jf4Yw8QyvsJZTy09NuzF-pcKus8VxdAuivd1w,656 +OpenGL/raw/GL/INGR/color_clamp.py,sha256=MD0A0ikqBEQaPYsRkeAcfAKDNjP_AB00d-wKeFPGX4M,970 +OpenGL/raw/GL/INGR/interlace_read.py,sha256=yk_I0fxey9Kf4S0I86k-rK7WhKBk6CHITVuVvyZVC5Y,559 +OpenGL/raw/GL/INTEL/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/raw/GL/INTEL/__pycache__/__init__.cpython-312.pyc,, +OpenGL/raw/GL/INTEL/__pycache__/blackhole_render.cpython-312.pyc,, +OpenGL/raw/GL/INTEL/__pycache__/conservative_rasterization.cpython-312.pyc,, +OpenGL/raw/GL/INTEL/__pycache__/fragment_shader_ordering.cpython-312.pyc,, +OpenGL/raw/GL/INTEL/__pycache__/framebuffer_CMAA.cpython-312.pyc,, +OpenGL/raw/GL/INTEL/__pycache__/map_texture.cpython-312.pyc,, +OpenGL/raw/GL/INTEL/__pycache__/parallel_arrays.cpython-312.pyc,, +OpenGL/raw/GL/INTEL/__pycache__/performance_query.cpython-312.pyc,, +OpenGL/raw/GL/INTEL/blackhole_render.py,sha256=jyTNdEBz3pMe811QOhwJiR-LRgeQ-EF5L422AR_AE_8,571 +OpenGL/raw/GL/INTEL/conservative_rasterization.py,sha256=cM2Y8ZdbFwOaGOuoOiy8cSB4Z2P5RM3O3evFWoDDdZw,611 +OpenGL/raw/GL/INTEL/fragment_shader_ordering.py,sha256=30IcUG0EAlRjBd_4XnfsqDPA7WhiBPOyBpv6dNIuxRM,523 +OpenGL/raw/GL/INTEL/framebuffer_CMAA.py,sha256=9tDSYNolR_NQ3q7IOfewFxhDmcOZp5yn1Ctuqh7oWt0,576 +OpenGL/raw/GL/INTEL/map_texture.py,sha256=SQP6VyaV9p_9lhwvzT7dKa07ljSWsKQAQyt9qVXa4hg,1080 +OpenGL/raw/GL/INTEL/parallel_arrays.py,sha256=u_BBPJbL97gk7O11LNBK5Ma0fHGJ3C6aPNOlxng7_p0,1380 +OpenGL/raw/GL/INTEL/performance_query.py,sha256=zN36DyTW7gCxKxy-iyoyNvHBfXBVFzgRa6zV77vVkD8,3678 +OpenGL/raw/GL/KHR/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/raw/GL/KHR/__pycache__/__init__.cpython-312.pyc,, +OpenGL/raw/GL/KHR/__pycache__/blend_equation_advanced.cpython-312.pyc,, +OpenGL/raw/GL/KHR/__pycache__/blend_equation_advanced_coherent.cpython-312.pyc,, +OpenGL/raw/GL/KHR/__pycache__/context_flush_control.cpython-312.pyc,, +OpenGL/raw/GL/KHR/__pycache__/debug.cpython-312.pyc,, +OpenGL/raw/GL/KHR/__pycache__/no_error.cpython-312.pyc,, +OpenGL/raw/GL/KHR/__pycache__/parallel_shader_compile.cpython-312.pyc,, +OpenGL/raw/GL/KHR/__pycache__/robust_buffer_access_behavior.cpython-312.pyc,, +OpenGL/raw/GL/KHR/__pycache__/robustness.cpython-312.pyc,, +OpenGL/raw/GL/KHR/__pycache__/shader_subgroup.cpython-312.pyc,, +OpenGL/raw/GL/KHR/__pycache__/texture_compression_astc_hdr.cpython-312.pyc,, +OpenGL/raw/GL/KHR/__pycache__/texture_compression_astc_ldr.cpython-312.pyc,, +OpenGL/raw/GL/KHR/__pycache__/texture_compression_astc_sliced_3d.cpython-312.pyc,, +OpenGL/raw/GL/KHR/blend_equation_advanced.py,sha256=13Hucfe4UI7rN5TOuA2rejYshFfkndUNQFrCGco8YxU,1268 +OpenGL/raw/GL/KHR/blend_equation_advanced_coherent.py,sha256=jtkaxy0p1_O_fLonklcVfjZsaLCJBaO7xfISSiShyFg,609 +OpenGL/raw/GL/KHR/context_flush_control.py,sha256=t3csqa4gZ9LO7D34I6BT9hVwy9OGEF3juAm5UhKrZ9o,876 +OpenGL/raw/GL/KHR/debug.py,sha256=nnXG7FpRh2PmA7zVal_E4uF4n3JLPcZLoPJzOAci95A,8648 +OpenGL/raw/GL/KHR/no_error.py,sha256=LY_hnb4yd6c6ZBpLlsVY7QEUINpWStBtcmTtacoUVoM,569 +OpenGL/raw/GL/KHR/parallel_shader_compile.py,sha256=k-yRDEiCdy8fzpgoxqYzscPAC9eQkJh0Nj1xMkForFM,738 +OpenGL/raw/GL/KHR/robust_buffer_access_behavior.py,sha256=q225eAN6vs-gE6aGMyXIwB-cs8IjAz5Xq7W9hD2jP_E,529 +OpenGL/raw/GL/KHR/robustness.py,sha256=smbs5GqdIluOnTV94UkqJSZcWLfmdSWoMuEkl28mUiQ,2896 +OpenGL/raw/GL/KHR/shader_subgroup.py,sha256=BEgXlAWlASo9XxKmxhOauAd_11B2w2gClDSVLlaZ6UM,1516 +OpenGL/raw/GL/KHR/texture_compression_astc_hdr.py,sha256=D3i_gsPIocXXru8e3eGyYCj0Wjhu6-MY0NDlddoVC_k,2942 +OpenGL/raw/GL/KHR/texture_compression_astc_ldr.py,sha256=hbFDQFTqSkBwuwDLtcI46VFlwfkOxbUXzCiXxobEOzQ,2942 +OpenGL/raw/GL/KHR/texture_compression_astc_sliced_3d.py,sha256=yZufBdVQBfOq_z-dLDi3QVMXsQZpXO7A7_K3xUarO2I,539 +OpenGL/raw/GL/MESA/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/raw/GL/MESA/__pycache__/__init__.cpython-312.pyc,, +OpenGL/raw/GL/MESA/__pycache__/framebuffer_flip_y.cpython-312.pyc,, +OpenGL/raw/GL/MESA/__pycache__/pack_invert.cpython-312.pyc,, +OpenGL/raw/GL/MESA/__pycache__/program_binary_formats.cpython-312.pyc,, +OpenGL/raw/GL/MESA/__pycache__/resize_buffers.cpython-312.pyc,, +OpenGL/raw/GL/MESA/__pycache__/shader_integer_functions.cpython-312.pyc,, +OpenGL/raw/GL/MESA/__pycache__/tile_raster_order.cpython-312.pyc,, +OpenGL/raw/GL/MESA/__pycache__/window_pos.cpython-312.pyc,, +OpenGL/raw/GL/MESA/__pycache__/ycbcr_texture.cpython-312.pyc,, +OpenGL/raw/GL/MESA/framebuffer_flip_y.py,sha256=YhEdts1jA3IzPshz35ydsqxe-j9P3VSHQdThUVumXIo,805 +OpenGL/raw/GL/MESA/pack_invert.py,sha256=at1PMlSjrlGuSuNte21kXbkCVwlqxJxh9Zmm9rY5omk,547 +OpenGL/raw/GL/MESA/program_binary_formats.py,sha256=mQpmAiZu4ihtGZNhRkTQ7fqe8UL_TJWy7QYVczjc_hY,589 +OpenGL/raw/GL/MESA/resize_buffers.py,sha256=P896g35l-qkh3mm4k8WB1-BfjJAP02YLLLp-PUhJKTE,552 +OpenGL/raw/GL/MESA/shader_integer_functions.py,sha256=VSsNIU4-F3ByGV8oG6HdkXpi0dJwOtOUarZ61-X7skQ,521 +OpenGL/raw/GL/MESA/tile_raster_order.py,sha256=e-w015E3s6qZFX5rlGkkZSHz8U0e_2JzZXUcwhh8Ugw,765 +OpenGL/raw/GL/MESA/window_pos.py,sha256=05pw0HUZ3QJ97MWw04v0vlpD-7lraYtfY0Js9IDNpv8,2412 +OpenGL/raw/GL/MESA/ycbcr_texture.py,sha256=i8Gw5skH_oK9juEeMxOX6wBP3slxswCqhnTGKQYB5Jk,681 +OpenGL/raw/GL/MESAX/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/raw/GL/MESAX/__pycache__/__init__.cpython-312.pyc,, +OpenGL/raw/GL/MESAX/__pycache__/texture_stack.cpython-312.pyc,, +OpenGL/raw/GL/MESAX/texture_stack.py,sha256=LlB-LRTUyGz9W4uB54IMZjZ-birbXHb33zYRI4dTaLk,946 +OpenGL/raw/GL/NV/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/raw/GL/NV/__pycache__/__init__.cpython-312.pyc,, +OpenGL/raw/GL/NV/__pycache__/alpha_to_coverage_dither_control.cpython-312.pyc,, +OpenGL/raw/GL/NV/__pycache__/bindless_multi_draw_indirect.cpython-312.pyc,, +OpenGL/raw/GL/NV/__pycache__/bindless_multi_draw_indirect_count.cpython-312.pyc,, +OpenGL/raw/GL/NV/__pycache__/bindless_texture.cpython-312.pyc,, +OpenGL/raw/GL/NV/__pycache__/blend_equation_advanced.cpython-312.pyc,, +OpenGL/raw/GL/NV/__pycache__/blend_equation_advanced_coherent.cpython-312.pyc,, +OpenGL/raw/GL/NV/__pycache__/blend_minmax_factor.cpython-312.pyc,, +OpenGL/raw/GL/NV/__pycache__/blend_square.cpython-312.pyc,, +OpenGL/raw/GL/NV/__pycache__/clip_space_w_scaling.cpython-312.pyc,, +OpenGL/raw/GL/NV/__pycache__/command_list.cpython-312.pyc,, +OpenGL/raw/GL/NV/__pycache__/compute_program5.cpython-312.pyc,, +OpenGL/raw/GL/NV/__pycache__/compute_shader_derivatives.cpython-312.pyc,, +OpenGL/raw/GL/NV/__pycache__/conditional_render.cpython-312.pyc,, +OpenGL/raw/GL/NV/__pycache__/conservative_raster.cpython-312.pyc,, +OpenGL/raw/GL/NV/__pycache__/conservative_raster_dilate.cpython-312.pyc,, +OpenGL/raw/GL/NV/__pycache__/conservative_raster_pre_snap.cpython-312.pyc,, +OpenGL/raw/GL/NV/__pycache__/conservative_raster_pre_snap_triangles.cpython-312.pyc,, +OpenGL/raw/GL/NV/__pycache__/conservative_raster_underestimation.cpython-312.pyc,, +OpenGL/raw/GL/NV/__pycache__/copy_depth_to_color.cpython-312.pyc,, +OpenGL/raw/GL/NV/__pycache__/copy_image.cpython-312.pyc,, +OpenGL/raw/GL/NV/__pycache__/deep_texture3D.cpython-312.pyc,, +OpenGL/raw/GL/NV/__pycache__/depth_buffer_float.cpython-312.pyc,, +OpenGL/raw/GL/NV/__pycache__/depth_clamp.cpython-312.pyc,, +OpenGL/raw/GL/NV/__pycache__/draw_texture.cpython-312.pyc,, +OpenGL/raw/GL/NV/__pycache__/draw_vulkan_image.cpython-312.pyc,, +OpenGL/raw/GL/NV/__pycache__/evaluators.cpython-312.pyc,, +OpenGL/raw/GL/NV/__pycache__/explicit_multisample.cpython-312.pyc,, +OpenGL/raw/GL/NV/__pycache__/fence.cpython-312.pyc,, +OpenGL/raw/GL/NV/__pycache__/fill_rectangle.cpython-312.pyc,, +OpenGL/raw/GL/NV/__pycache__/float_buffer.cpython-312.pyc,, +OpenGL/raw/GL/NV/__pycache__/fog_distance.cpython-312.pyc,, +OpenGL/raw/GL/NV/__pycache__/fragment_coverage_to_color.cpython-312.pyc,, +OpenGL/raw/GL/NV/__pycache__/fragment_program.cpython-312.pyc,, +OpenGL/raw/GL/NV/__pycache__/fragment_program2.cpython-312.pyc,, +OpenGL/raw/GL/NV/__pycache__/fragment_program4.cpython-312.pyc,, +OpenGL/raw/GL/NV/__pycache__/fragment_program_option.cpython-312.pyc,, +OpenGL/raw/GL/NV/__pycache__/fragment_shader_barycentric.cpython-312.pyc,, +OpenGL/raw/GL/NV/__pycache__/fragment_shader_interlock.cpython-312.pyc,, +OpenGL/raw/GL/NV/__pycache__/framebuffer_mixed_samples.cpython-312.pyc,, +OpenGL/raw/GL/NV/__pycache__/framebuffer_multisample_coverage.cpython-312.pyc,, +OpenGL/raw/GL/NV/__pycache__/geometry_program4.cpython-312.pyc,, +OpenGL/raw/GL/NV/__pycache__/geometry_shader4.cpython-312.pyc,, +OpenGL/raw/GL/NV/__pycache__/geometry_shader_passthrough.cpython-312.pyc,, +OpenGL/raw/GL/NV/__pycache__/gpu_multicast.cpython-312.pyc,, +OpenGL/raw/GL/NV/__pycache__/gpu_program4.cpython-312.pyc,, +OpenGL/raw/GL/NV/__pycache__/gpu_program5.cpython-312.pyc,, +OpenGL/raw/GL/NV/__pycache__/gpu_program5_mem_extended.cpython-312.pyc,, +OpenGL/raw/GL/NV/__pycache__/gpu_shader5.cpython-312.pyc,, +OpenGL/raw/GL/NV/__pycache__/half_float.cpython-312.pyc,, +OpenGL/raw/GL/NV/__pycache__/internalformat_sample_query.cpython-312.pyc,, +OpenGL/raw/GL/NV/__pycache__/light_max_exponent.cpython-312.pyc,, +OpenGL/raw/GL/NV/__pycache__/memory_attachment.cpython-312.pyc,, +OpenGL/raw/GL/NV/__pycache__/mesh_shader.cpython-312.pyc,, +OpenGL/raw/GL/NV/__pycache__/multisample_coverage.cpython-312.pyc,, +OpenGL/raw/GL/NV/__pycache__/multisample_filter_hint.cpython-312.pyc,, +OpenGL/raw/GL/NV/__pycache__/occlusion_query.cpython-312.pyc,, +OpenGL/raw/GL/NV/__pycache__/packed_depth_stencil.cpython-312.pyc,, +OpenGL/raw/GL/NV/__pycache__/parameter_buffer_object.cpython-312.pyc,, +OpenGL/raw/GL/NV/__pycache__/parameter_buffer_object2.cpython-312.pyc,, +OpenGL/raw/GL/NV/__pycache__/path_rendering.cpython-312.pyc,, +OpenGL/raw/GL/NV/__pycache__/path_rendering_shared_edge.cpython-312.pyc,, +OpenGL/raw/GL/NV/__pycache__/pixel_data_range.cpython-312.pyc,, +OpenGL/raw/GL/NV/__pycache__/point_sprite.cpython-312.pyc,, +OpenGL/raw/GL/NV/__pycache__/present_video.cpython-312.pyc,, +OpenGL/raw/GL/NV/__pycache__/primitive_restart.cpython-312.pyc,, +OpenGL/raw/GL/NV/__pycache__/query_resource.cpython-312.pyc,, +OpenGL/raw/GL/NV/__pycache__/query_resource_tag.cpython-312.pyc,, +OpenGL/raw/GL/NV/__pycache__/register_combiners.cpython-312.pyc,, +OpenGL/raw/GL/NV/__pycache__/register_combiners2.cpython-312.pyc,, +OpenGL/raw/GL/NV/__pycache__/representative_fragment_test.cpython-312.pyc,, +OpenGL/raw/GL/NV/__pycache__/robustness_video_memory_purge.cpython-312.pyc,, +OpenGL/raw/GL/NV/__pycache__/sample_locations.cpython-312.pyc,, +OpenGL/raw/GL/NV/__pycache__/sample_mask_override_coverage.cpython-312.pyc,, +OpenGL/raw/GL/NV/__pycache__/scissor_exclusive.cpython-312.pyc,, +OpenGL/raw/GL/NV/__pycache__/shader_atomic_counters.cpython-312.pyc,, +OpenGL/raw/GL/NV/__pycache__/shader_atomic_float.cpython-312.pyc,, +OpenGL/raw/GL/NV/__pycache__/shader_atomic_float64.cpython-312.pyc,, +OpenGL/raw/GL/NV/__pycache__/shader_atomic_fp16_vector.cpython-312.pyc,, +OpenGL/raw/GL/NV/__pycache__/shader_atomic_int64.cpython-312.pyc,, +OpenGL/raw/GL/NV/__pycache__/shader_buffer_load.cpython-312.pyc,, +OpenGL/raw/GL/NV/__pycache__/shader_buffer_store.cpython-312.pyc,, +OpenGL/raw/GL/NV/__pycache__/shader_storage_buffer_object.cpython-312.pyc,, +OpenGL/raw/GL/NV/__pycache__/shader_subgroup_partitioned.cpython-312.pyc,, +OpenGL/raw/GL/NV/__pycache__/shader_texture_footprint.cpython-312.pyc,, +OpenGL/raw/GL/NV/__pycache__/shader_thread_group.cpython-312.pyc,, +OpenGL/raw/GL/NV/__pycache__/shader_thread_shuffle.cpython-312.pyc,, +OpenGL/raw/GL/NV/__pycache__/shading_rate_image.cpython-312.pyc,, +OpenGL/raw/GL/NV/__pycache__/stereo_view_rendering.cpython-312.pyc,, +OpenGL/raw/GL/NV/__pycache__/tessellation_program5.cpython-312.pyc,, +OpenGL/raw/GL/NV/__pycache__/texgen_emboss.cpython-312.pyc,, +OpenGL/raw/GL/NV/__pycache__/texgen_reflection.cpython-312.pyc,, +OpenGL/raw/GL/NV/__pycache__/texture_barrier.cpython-312.pyc,, +OpenGL/raw/GL/NV/__pycache__/texture_compression_vtc.cpython-312.pyc,, +OpenGL/raw/GL/NV/__pycache__/texture_env_combine4.cpython-312.pyc,, +OpenGL/raw/GL/NV/__pycache__/texture_expand_normal.cpython-312.pyc,, +OpenGL/raw/GL/NV/__pycache__/texture_multisample.cpython-312.pyc,, +OpenGL/raw/GL/NV/__pycache__/texture_rectangle.cpython-312.pyc,, +OpenGL/raw/GL/NV/__pycache__/texture_rectangle_compressed.cpython-312.pyc,, +OpenGL/raw/GL/NV/__pycache__/texture_shader.cpython-312.pyc,, +OpenGL/raw/GL/NV/__pycache__/texture_shader2.cpython-312.pyc,, +OpenGL/raw/GL/NV/__pycache__/texture_shader3.cpython-312.pyc,, +OpenGL/raw/GL/NV/__pycache__/transform_feedback.cpython-312.pyc,, +OpenGL/raw/GL/NV/__pycache__/transform_feedback2.cpython-312.pyc,, +OpenGL/raw/GL/NV/__pycache__/uniform_buffer_unified_memory.cpython-312.pyc,, +OpenGL/raw/GL/NV/__pycache__/vdpau_interop.cpython-312.pyc,, +OpenGL/raw/GL/NV/__pycache__/vdpau_interop2.cpython-312.pyc,, +OpenGL/raw/GL/NV/__pycache__/vertex_array_range.cpython-312.pyc,, +OpenGL/raw/GL/NV/__pycache__/vertex_array_range2.cpython-312.pyc,, +OpenGL/raw/GL/NV/__pycache__/vertex_attrib_integer_64bit.cpython-312.pyc,, +OpenGL/raw/GL/NV/__pycache__/vertex_buffer_unified_memory.cpython-312.pyc,, +OpenGL/raw/GL/NV/__pycache__/vertex_program.cpython-312.pyc,, +OpenGL/raw/GL/NV/__pycache__/vertex_program1_1.cpython-312.pyc,, +OpenGL/raw/GL/NV/__pycache__/vertex_program2.cpython-312.pyc,, +OpenGL/raw/GL/NV/__pycache__/vertex_program2_option.cpython-312.pyc,, +OpenGL/raw/GL/NV/__pycache__/vertex_program3.cpython-312.pyc,, +OpenGL/raw/GL/NV/__pycache__/vertex_program4.cpython-312.pyc,, +OpenGL/raw/GL/NV/__pycache__/video_capture.cpython-312.pyc,, +OpenGL/raw/GL/NV/__pycache__/viewport_array2.cpython-312.pyc,, +OpenGL/raw/GL/NV/__pycache__/viewport_swizzle.cpython-312.pyc,, +OpenGL/raw/GL/NV/alpha_to_coverage_dither_control.py,sha256=Asdar7ZxsZoqYxwFyb1RAL_YcTGDvwvmuDU1Pbdsi8Q,966 +OpenGL/raw/GL/NV/bindless_multi_draw_indirect.py,sha256=PLQgBtcnLPHhDBLreySaM3u_F1SL88lsDDqxw3meCPc,894 +OpenGL/raw/GL/NV/bindless_multi_draw_indirect_count.py,sha256=USwAnL3h1ZeH5miAJH8NKUbt8-U8s1kQgtNwqUNldbo,966 +OpenGL/raw/GL/NV/bindless_texture.py,sha256=0_rXPTrL-kK6PU4SPpTyjG81RDbf4JD4S5Bv154dRmw,1809 +OpenGL/raw/GL/NV/blend_equation_advanced.py,sha256=e2TkIYP3i1mtHeRqNOgzadWSfidQ5ncgD0Jf9aljGkE,2875 +OpenGL/raw/GL/NV/blend_equation_advanced_coherent.py,sha256=8LmG-YnRe9uROys5HjeOwQFqVqvjTIhpb2HJBrJASoU,605 +OpenGL/raw/GL/NV/blend_minmax_factor.py,sha256=fBBAfIqZXBBar6vKDOS-8nL3fH-VRd6HaN6iXITGdHE,604 +OpenGL/raw/GL/NV/blend_square.py,sha256=8EkYUu5hcZNgN6OnQUpCjK87Vc3e2WvsrLLONXNWB7c,493 +OpenGL/raw/GL/NV/clip_space_w_scaling.py,sha256=KjWmedpzVz5ims3QLs102jX_-_ZrYKUPQZelumH0vZQ,882 +OpenGL/raw/GL/NV/command_list.py,sha256=zsOsv4EStxdZLcTnTo8ngBeQyc-Dnx-TNB7x087CHBA,3719 +OpenGL/raw/GL/NV/compute_program5.py,sha256=o9PY87rdqlepm4ME1PledUxkocn4J9NJcCXlqmVqUl0,648 +OpenGL/raw/GL/NV/compute_shader_derivatives.py,sha256=ssl14aeiFQvzeEd8UJqWqLNaywhJRKc_4gxXX2kQJ3U,521 +OpenGL/raw/GL/NV/conditional_render.py,sha256=lQfkdCkMnc2Vv67W8QY_n28F2E6ddl_YcTrPvfsnWVE,887 +OpenGL/raw/GL/NV/conservative_raster.py,sha256=6MykjSlq6DDoLIUOHJGo4VfIju6hfr7dP-WxeWYb-bY,939 +OpenGL/raw/GL/NV/conservative_raster_dilate.py,sha256=QsFBsevsjputZT0QT2CObbe0EJS_HDt15MK0-LUCMUQ,890 +OpenGL/raw/GL/NV/conservative_raster_pre_snap.py,sha256=PCMfLWsqs9IhPuF6Vl9GLcciXutZBU6gXhY3jEIJvJY,617 +OpenGL/raw/GL/NV/conservative_raster_pre_snap_triangles.py,sha256=d7WGp2VE74rAqDSqqhJvbXIaXKRHkFQyyxecwIqZf_I,997 +OpenGL/raw/GL/NV/conservative_raster_underestimation.py,sha256=cFAwUW4mDQ1OPaSFSyU0QJSqbrgOQuXYnFccmkY9cuw,539 +OpenGL/raw/GL/NV/copy_depth_to_color.py,sha256=ORjch6BxQ5e6YyWa8hh849DEi9eYPZrp_0GRfeKnGdA,644 +OpenGL/raw/GL/NV/copy_image.py,sha256=vuoYsI4GCKkStV5hV55YfIRwTt63SEP50aVm4rummOM,802 +OpenGL/raw/GL/NV/deep_texture3D.py,sha256=rMEaCrJ9A2NFinKILHoIgtSc_G0VocfCf3UsTcaLVGw,664 +OpenGL/raw/GL/NV/depth_buffer_float.py,sha256=ymnGE9Amwnw4dz3URXLTT7y51y6WUbTHtAyWxa_hERE,1018 +OpenGL/raw/GL/NV/depth_clamp.py,sha256=yhI329pyh6ecUu1UO_4F6Ps-Och6n5kW_mePgEvTlmg,539 +OpenGL/raw/GL/NV/draw_texture.py,sha256=zmgFsfrX78EuVsrg91bLeivO5fnkSX0MtGoDdFhiuag,710 +OpenGL/raw/GL/NV/draw_vulkan_image.py,sha256=np_wACEhLTS4vATSpRkAK9kVvFKV_uIewRFjAKSaG68,1029 +OpenGL/raw/GL/NV/evaluators.py,sha256=XSu2tFjL0AT_lTmyWDLaH-URqQGqUZwJL2_uR8nocA4,3255 +OpenGL/raw/GL/NV/explicit_multisample.py,sha256=9yB9j8a3DP8tt_iUqnfAs1Zwp0UqerLV8Hj2ts49thc,1523 +OpenGL/raw/GL/NV/fence.py,sha256=Nw0oYAiLvIXjYgSdhKdpusswaQHl7rLOx_J7FTu4rV4,1195 +OpenGL/raw/GL/NV/fill_rectangle.py,sha256=MzM95EUz4QR6ZYIgEaPNcLrvDpbHY8MGCN6HBy2354s,551 +OpenGL/raw/GL/NV/float_buffer.py,sha256=SPQwxIfUiB0DWKjTuuZSXLNCxP07mO9E8E7Wn5Jlwv4,1257 +OpenGL/raw/GL/NV/fog_distance.py,sha256=7kc80Cxlb9TQu8FxTRSfIxk3QJPlHgJ5HK21mQuF-1g,702 +OpenGL/raw/GL/NV/fragment_coverage_to_color.py,sha256=BpzXPxoRKOkYf4MWoGllzae37P6d0khjipKcHjSqSpg,744 +OpenGL/raw/GL/NV/fragment_program.py,sha256=EdOgld0nu-AHy3PrSmhWkII_00U4E4IEdWNG4RqOT44,1839 +OpenGL/raw/GL/NV/fragment_program2.py,sha256=o992JXKxcD8q3R5AV0Q8R1ItLN2aj3sw1ROZBa1zUjA,867 +OpenGL/raw/GL/NV/fragment_program4.py,sha256=td2s3ETLmjkzDj_z4-b-GHOtgYKdT5Uc2dwqDzilM40,503 +OpenGL/raw/GL/NV/fragment_program_option.py,sha256=Jh3TVELRQow5ZmaWzHuIYRuFoEVV0QAETcS9NP04eSM,515 +OpenGL/raw/GL/NV/fragment_shader_barycentric.py,sha256=xAErVA3zn-8uTcMUltkmqftJSeDG2-D86gtFrcGa_DM,523 +OpenGL/raw/GL/NV/fragment_shader_interlock.py,sha256=5O6rfyP-FQKmBq9Qt4WxqlQ3EYdoOE-MCrTPkL2LkRY,519 +OpenGL/raw/GL/NV/framebuffer_mixed_samples.py,sha256=7bAbNkesPoWARzzTJJfcYOHUkbIZKYKlaf5lU2yqysk,1904 +OpenGL/raw/GL/NV/framebuffer_multisample_coverage.py,sha256=LY0ZlhkXsbBoZ9p-W9t7rfQ3cLE3joegSpUuoW5H5y0,1068 +OpenGL/raw/GL/NV/geometry_program4.py,sha256=fsWzs0ThfjEpLnA7hyQwtsMLyY11jOovEEd8BnblfhQ,2278 +OpenGL/raw/GL/NV/geometry_shader4.py,sha256=uXqqvGZlBF2UlbUFi0Y3tTDcjIQcS95uFpWY6Kr10SE,501 +OpenGL/raw/GL/NV/geometry_shader_passthrough.py,sha256=G9xwhlrJtsv-AnGBItpA6XiYeAoXU6hBZ0ufxamnrsk,523 +OpenGL/raw/GL/NV/gpu_multicast.py,sha256=eNrtAkLYaW5bm-H_R-smc3kHf62A66ciLh0aCrQzTMY,2772 +OpenGL/raw/GL/NV/gpu_program4.py,sha256=dWlil_Oi8pjfP-asTIU7n-1H7J_H8mRtmkqnwGtm9eI,3225 +OpenGL/raw/GL/NV/gpu_program5.py,sha256=F46ScO3G6WocjGU9qzD-5q-Jt8JX8SGdYMdbCvBtzrs,1491 +OpenGL/raw/GL/NV/gpu_program5_mem_extended.py,sha256=WLp2veCRbDHx_ymUSitHR1hFhFF-Pm9_IELl-tgTub4,519 +OpenGL/raw/GL/NV/gpu_shader5.py,sha256=mmHOejhLh7XAMZWyecu-pvPtt1StTEVBnt9CrDLgQ9Y,6040 +OpenGL/raw/GL/NV/half_float.py,sha256=XMaPgRXqHjNEIgcLnWxz39WOdZOAJsQ_Kmk_Uq5GCMM,4546 +OpenGL/raw/GL/NV/internalformat_sample_query.py,sha256=aSGkmJLxyO34MSFRzVQguP1j328aqb-PUi5Wj3wNqWU,1122 +OpenGL/raw/GL/NV/light_max_exponent.py,sha256=DpUMsDH-ajZrGQBCYpvwZ0E9pEjlqBe0kfrpiVq3Fgk,618 +OpenGL/raw/GL/NV/memory_attachment.py,sha256=H8CYDYA9CcyU-cKeOAtvKpJuyCtBVfevGwKI1UNYPlE,1894 +OpenGL/raw/GL/NV/mesh_shader.py,sha256=lA__JVhH4itmPm8TZN0NProSE35X_1q6t3nSSknfJQk,4690 +OpenGL/raw/GL/NV/multisample_coverage.py,sha256=a-2XxbADxtt_ho3-7ysSQj5weXOFooLyd1gVQac17h0,604 +OpenGL/raw/GL/NV/multisample_filter_hint.py,sha256=jzvBRXyf6uIlj1eZcH_mHo-RjYPM9u4OXDu86NmJBbg,587 +OpenGL/raw/GL/NV/occlusion_query.py,sha256=SRzTUR49e7dsJcUVgUcGkmr7GfqEPWtzo6W530R_d2M,1360 +OpenGL/raw/GL/NV/packed_depth_stencil.py,sha256=_LLK3d79uD-3G_Q8QmFyQBIXUKt5kwIlhI1GSww54xY,622 +OpenGL/raw/GL/NV/parameter_buffer_object.py,sha256=7V_NAoUdvMVg1igqHCJg-_gfS2c95Q8B_JmnR4VcuQw,1486 +OpenGL/raw/GL/NV/parameter_buffer_object2.py,sha256=cxJTcp7yPs5bSGqQ1YESUXoN2NmoOZ_38TGx_Knbe5o,517 +OpenGL/raw/GL/NV/path_rendering.py,sha256=m8Es-86wG_YsZV7ToXVGHi3Sktbt6_N-1_C_ClJndyw,22035 +OpenGL/raw/GL/NV/path_rendering_shared_edge.py,sha256=RZvBrhuIWRos546vUInlqEn_wiDfb6QCiEzI8hW_xS8,567 +OpenGL/raw/GL/NV/pixel_data_range.py,sha256=AZABvBOwpWWImHexRTwZbQ-0uKL8KMgHZQ3mRNE0jPU,1161 +OpenGL/raw/GL/NV/point_sprite.py,sha256=IyHBCX5N7h0FJKkyXKIooHEZJ9ScHLf1QL95hCBPEKM,836 +OpenGL/raw/GL/NV/present_video.py,sha256=6SRzDnQDuTRMQzgSBU6M0rr3gEBUH21RmAWcmTmebPo,1848 +OpenGL/raw/GL/NV/primitive_restart.py,sha256=XVyard7pay5LZJk33tNL_qa1Py0wBfhsmFiuQM0nUJo,761 +OpenGL/raw/GL/NV/query_resource.py,sha256=ksPb7iPcwWs4NDVRIp7hy5KSZocNLqmpoIHGGbVh3gw,1119 +OpenGL/raw/GL/NV/query_resource_tag.py,sha256=yF38YBJdGthj3xmWdWq2hFaJvvnp8gES3LCeAI7W5ns,789 +OpenGL/raw/GL/NV/register_combiners.py,sha256=4UNVaL0jomI7XxrtDPCRS84-Gq8tYmr5eS_Hs_De6E0,5260 +OpenGL/raw/GL/NV/register_combiners2.py,sha256=BEeB1xQy0YK4LcaS5SPMnnC_3mDatqWSZH9Dc0gD_oY,813 +OpenGL/raw/GL/NV/representative_fragment_test.py,sha256=h9CNklW578Mp4d-TO0dzqlFX5peOFngMnX3HqcU0CYs,607 +OpenGL/raw/GL/NV/robustness_video_memory_purge.py,sha256=QND3vpVeNWgic_4IrGwhYYZNL2CwJiv4zjFEcxiGgiE,593 +OpenGL/raw/GL/NV/sample_locations.py,sha256=08cenc48b1ZFNztsghqpON790dWWglCWyEkwVcCMkco,1566 +OpenGL/raw/GL/NV/sample_mask_override_coverage.py,sha256=0o__ZxE5oklTDUcuD-KlX17SzHrmGJzveM0n0qMAexQ,527 +OpenGL/raw/GL/NV/scissor_exclusive.py,sha256=F23QtbmwxdIGX0hy2mzTcG0fDwl-LAz83bLVaZfoCvg,865 +OpenGL/raw/GL/NV/shader_atomic_counters.py,sha256=-zn7TP8sqZCUfCZ9gLzvH4qWGiyZuzz3vU-2tay2c4A,513 +OpenGL/raw/GL/NV/shader_atomic_float.py,sha256=VsXHVeDDE9bUfyPIe63-sEeDL2KIgC0Bh_YWTGH6ZHs,507 +OpenGL/raw/GL/NV/shader_atomic_float64.py,sha256=CJUwnj7nUeoWgFDiQcqzS7ydJ__DGWC1rWdaLfmAZVk,511 +OpenGL/raw/GL/NV/shader_atomic_fp16_vector.py,sha256=FVnss3_ZtHqyDx6O9adaM4f3AteyRvBjEWxUzCCTcR8,519 +OpenGL/raw/GL/NV/shader_atomic_int64.py,sha256=yVUJXUGyFvYsFncRQTRZMd5ne3i6pRuVsMhrrsKHrss,507 +OpenGL/raw/GL/NV/shader_buffer_load.py,sha256=Q85Uq4zZ2H-i1caYEqocBAGLQWRpqwpHajSP-D90ebo,2095 +OpenGL/raw/GL/NV/shader_buffer_store.py,sha256=CyJpihtbT5fwPeb9ghkq-4irUO2EII6cAR49wBvLt-U,683 +OpenGL/raw/GL/NV/shader_storage_buffer_object.py,sha256=cI8iWyoqG2FUO_-q1jEF4T24mMlyE2xKJFijPgBRwN4,525 +OpenGL/raw/GL/NV/shader_subgroup_partitioned.py,sha256=WhfSZ2qoFpSeqO6J5AinZMI1bhPL_VhuRRjpGxiauNo,617 +OpenGL/raw/GL/NV/shader_texture_footprint.py,sha256=OxvKkMPE_Blt7v1UonLjNuYIcRwsT6Exl32QB2cOiog,517 +OpenGL/raw/GL/NV/shader_thread_group.py,sha256=fHFqr2dO2K8f0fBFJP6dzW0n1X7OfyyuPD2hf7tuqAo,645 +OpenGL/raw/GL/NV/shader_thread_shuffle.py,sha256=lqS_nbbLBr1UFtpU_5fBZp8VE9R_AXirpvTcd3-Fk9s,511 +OpenGL/raw/GL/NV/shading_rate_image.py,sha256=ariClyLcGzl0mduZzUQ6DDTT1Pt7iaEG4hensw_xKhM,3352 +OpenGL/raw/GL/NV/stereo_view_rendering.py,sha256=KO07h4NXvCXMF4mdOIGfi9UQeVbXcgqLxxJ3rzd6eKo,511 +OpenGL/raw/GL/NV/tessellation_program5.py,sha256=606IYWNUnyfeALNoZo89QojR1oP4782nQ9FOoY3QhrI,935 +OpenGL/raw/GL/NV/texgen_emboss.py,sha256=eWvIfvRzSiHHLd0-gjzMILfP4uiqdYkj2lfAe_MUkR8,649 +OpenGL/raw/GL/NV/texgen_reflection.py,sha256=ADumvA16cqeWRVeATcXXqmq-6c_CuhSKOzDXiRGoTfE,604 +OpenGL/raw/GL/NV/texture_barrier.py,sha256=Ifl1sSbCksA-kr8YpWSCNQqO9zoUK-cbh1zzoi-6xjU,549 +OpenGL/raw/GL/NV/texture_compression_vtc.py,sha256=pUCH9FajTapuI5nGSG0M_9nxXNyshNFPNzZxME2bcyw,515 +OpenGL/raw/GL/NV/texture_env_combine4.py,sha256=nJwVzIkuZO6bOJHhrpVeEdMLOl9Ks4-XPprQdN1-Suc,759 +OpenGL/raw/GL/NV/texture_expand_normal.py,sha256=yixiKHQOfQoQUyXqDSeeAfIrJ82RGleLKcYnZhbo19s,591 +OpenGL/raw/GL/NV/texture_multisample.py,sha256=_SNWtAS7wSkZ0QxsoJrPDtG3_F5I-pdhDWObTM2rDFI,2105 +OpenGL/raw/GL/NV/texture_rectangle.py,sha256=nm63ZlxSpFD1L-JTeMW31B-AMLb9iNF2DpEK5c5E5rs,792 +OpenGL/raw/GL/NV/texture_rectangle_compressed.py,sha256=sgwPO5Pi2svVoQPuMawuy8TFKJVuFDYceqWtknsZvj0,525 +OpenGL/raw/GL/NV/texture_shader.py,sha256=wd1DIbqctWMGMzh5BtYnGEMGJMiKWOjYypb3n1NE_Us,4881 +OpenGL/raw/GL/NV/texture_shader2.py,sha256=ccg5GfZiftTgfM_w2PC3kLLqowSGHQVCK0Tzr3ze4vw,569 +OpenGL/raw/GL/NV/texture_shader3.py,sha256=1tvR3e5y2f6qGEWsQv_ollXooex2ZfH-9cDryVylzVg,1863 +OpenGL/raw/GL/NV/transform_feedback.py,sha256=B3wLs94w1tsvYWeLQORs3mTrdWjlTwlOYQ5xTonn5UA,4169 +OpenGL/raw/GL/NV/transform_feedback2.py,sha256=sP-8p6ENPwk9DZ2CglEwgF_Ru-97KRycLIZzDTIZ_UI,1388 +OpenGL/raw/GL/NV/uniform_buffer_unified_memory.py,sha256=5uXC1oDSAY1PwpMVb3KcmYMHK--6rxQdfoJ8TiT-FGo,737 +OpenGL/raw/GL/NV/vdpau_interop.py,sha256=XoePCoSqH3EnvkcoqmUb6iQTyHfl6BKtxJlieWcSNdU,1913 +OpenGL/raw/GL/NV/vdpau_interop2.py,sha256=4d5radHkWYXfJJOwFUGHlIIk4Jj_ycHvLTm3IcI4UWM,728 +OpenGL/raw/GL/NV/vertex_array_range.py,sha256=BuyhVfQF_Dj9iDvOeP9p_0P_2ue-WBkQnF74jGSCzmo,1036 +OpenGL/raw/GL/NV/vertex_array_range2.py,sha256=Kkkcz99yzLZiabVh2NF9S-4qCl1yzsIe5CInt_ssqgE,597 +OpenGL/raw/GL/NV/vertex_attrib_integer_64bit.py,sha256=k0AZo9NIsdReNC8S78vVn8qVqWxT6UtkOBpWqeW7Mu4,2618 +OpenGL/raw/GL/NV/vertex_buffer_unified_memory.py,sha256=8oW8QFAEQQaBc-mDC2M1FJboCj32bn5kpa39Z1eo9mI,3535 +OpenGL/raw/GL/NV/vertex_program.py,sha256=-Y3oCcPgikpK57RVoAO9v-m27BLGHtP_SWdSHlYFk8Q,12630 +OpenGL/raw/GL/NV/vertex_program1_1.py,sha256=M_kJNXDb6LFrTTfzCugsrmgOpFLHHFArNw7qCbNWSsE,503 +OpenGL/raw/GL/NV/vertex_program2.py,sha256=ptSOX_RSVmYaEc88V0oNz9VSk1JVfnMZdxt6x-YswEM,499 +OpenGL/raw/GL/NV/vertex_program2_option.py,sha256=BZX8Oj66vR7Xc-8KNayRUV_HxMTG03KA29jR1G1lczA,668 +OpenGL/raw/GL/NV/vertex_program3.py,sha256=6r_M7Uzoyi2VZrbhxD2wyursA1gq79Yl1hljtYfSI-0,587 +OpenGL/raw/GL/NV/vertex_program4.py,sha256=KgknD15IPyJEJIKmg1nfIrSjRsa2em6pHuScYEiWKlw,2837 +OpenGL/raw/GL/NV/video_capture.py,sha256=eO55ztMfi2miUdz5GLxlSJRD-oBcgR2DoypZkHMbC8w,4290 +OpenGL/raw/GL/NV/viewport_array2.py,sha256=U7PsfqgvHCXuV79gGgcd4zsJWxypHfzour4dpzbBG3U,499 +OpenGL/raw/GL/NV/viewport_swizzle.py,sha256=AuEwaAgINg66vIU-pmobfbFYgNbLLz-nhJ_vP-UNtNA,1546 +OpenGL/raw/GL/NVX/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/raw/GL/NVX/__pycache__/__init__.cpython-312.pyc,, +OpenGL/raw/GL/NVX/__pycache__/blend_equation_advanced_multi_draw_buffers.cpython-312.pyc,, +OpenGL/raw/GL/NVX/__pycache__/conditional_render.cpython-312.pyc,, +OpenGL/raw/GL/NVX/__pycache__/gpu_memory_info.cpython-312.pyc,, +OpenGL/raw/GL/NVX/__pycache__/gpu_multicast2.cpython-312.pyc,, +OpenGL/raw/GL/NVX/__pycache__/linked_gpu_multicast.cpython-312.pyc,, +OpenGL/raw/GL/NVX/__pycache__/progress_fence.cpython-312.pyc,, +OpenGL/raw/GL/NVX/blend_equation_advanced_multi_draw_buffers.py,sha256=Aa7BYOpAS1y-1YCEspPJL1gRkmX5KTByT7kNgrI8bAM,555 +OpenGL/raw/GL/NVX/conditional_render.py,sha256=5HU9nPbMn_f1HbjYGfZGLHb00i6UCVcm1hrqjdnyK8c,636 +OpenGL/raw/GL/NVX/gpu_memory_info.py,sha256=CA6du83Ir2vSzoinKU-Qk9qOjQ8rr8bCtnPemCUEKl0,985 +OpenGL/raw/GL/NVX/gpu_multicast2.py,sha256=8EanmlNd-2W-EULxi0_hLhFxo4NBntKg54N5qUtZAVU,2058 +OpenGL/raw/GL/NVX/linked_gpu_multicast.py,sha256=Lt3Ji-TS5DHdOab_y7QI07WZ2uC-AUpvNMwyKhVDLMI,1228 +OpenGL/raw/GL/NVX/progress_fence.py,sha256=eOLtKBXbzfXbwZxeh8e6sZgP2jEUZ4wUZ9jR8W5QTNY,1068 +OpenGL/raw/GL/OES/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/raw/GL/OES/__pycache__/__init__.cpython-312.pyc,, +OpenGL/raw/GL/OES/__pycache__/byte_coordinates.cpython-312.pyc,, +OpenGL/raw/GL/OES/__pycache__/compressed_paletted_texture.cpython-312.pyc,, +OpenGL/raw/GL/OES/__pycache__/fixed_point.cpython-312.pyc,, +OpenGL/raw/GL/OES/__pycache__/query_matrix.cpython-312.pyc,, +OpenGL/raw/GL/OES/__pycache__/read_format.cpython-312.pyc,, +OpenGL/raw/GL/OES/__pycache__/single_precision.cpython-312.pyc,, +OpenGL/raw/GL/OES/byte_coordinates.py,sha256=9RPGqjmdVv47fn_5H5N6A86_BDa2_NpO4qnqS1r56qE,2396 +OpenGL/raw/GL/OES/compressed_paletted_texture.py,sha256=UgOVDhFqnM8S27JaL_dHAEooQFpNHl7Vq3vOOc-KJUI,1110 +OpenGL/raw/GL/OES/fixed_point.py,sha256=IdkPsDe5OGMhMkpOJak1HZ4MpuO-gVVOPWKNrUQT1_8,10538 +OpenGL/raw/GL/OES/query_matrix.py,sha256=6-TMdWsEtEprPvZtlHzL7Te21sAnKRsL8l7gbxUhZpE,608 +OpenGL/raw/GL/OES/read_format.py,sha256=asX6vg71YNhPpSDpaPF5UPZbUgPE-_8TqKoy_zDSzuM,674 +OpenGL/raw/GL/OES/single_precision.py,sha256=0V1L_qFTZQ9iAvAtDaGDlLIQTRkb35tK2_g0aqpUpJ0,1086 +OpenGL/raw/GL/OML/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/raw/GL/OML/__pycache__/__init__.cpython-312.pyc,, +OpenGL/raw/GL/OML/__pycache__/interlace.cpython-312.pyc,, +OpenGL/raw/GL/OML/__pycache__/resample.cpython-312.pyc,, +OpenGL/raw/GL/OML/__pycache__/subsample.cpython-312.pyc,, +OpenGL/raw/GL/OML/interlace.py,sha256=bu50JQsubm31E615QmwJjfrs4VVYq-BhSl6Z4XdeunM,592 +OpenGL/raw/GL/OML/resample.py,sha256=U6XhisWUZSLxykFpeG7N5TGtx5wh1TlkJ3Qk6zvsQBY,854 +OpenGL/raw/GL/OML/subsample.py,sha256=GUkfuftCSBhmpE1s_BktEqi5zyZwHlmWOjLgOW47oRg,638 +OpenGL/raw/GL/OVR/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/raw/GL/OVR/__pycache__/__init__.cpython-312.pyc,, +OpenGL/raw/GL/OVR/__pycache__/multiview.cpython-312.pyc,, +OpenGL/raw/GL/OVR/__pycache__/multiview2.cpython-312.pyc,, +OpenGL/raw/GL/OVR/multiview.py,sha256=NdgIA0CitsOQWuzslsrTRD0HBemwXB0gwWSj5FQht9I,1046 +OpenGL/raw/GL/OVR/multiview2.py,sha256=npByk0Y1Zp0LciLZBYwVIDtDxyHsBmOwkleMneQnsdc,491 +OpenGL/raw/GL/PGI/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/raw/GL/PGI/__pycache__/__init__.cpython-312.pyc,, +OpenGL/raw/GL/PGI/__pycache__/misc_hints.cpython-312.pyc,, +OpenGL/raw/GL/PGI/__pycache__/vertex_hints.cpython-312.pyc,, +OpenGL/raw/GL/PGI/misc_hints.py,sha256=SsQDyH4mQVtBhSZ8Hv-u9qW4ACT6h1uZW3Fsp9gXbCY,1918 +OpenGL/raw/GL/PGI/vertex_hints.py,sha256=bqUjl39PcPctZYAkxhGIX1yvJBzpwJyB5BiR6JR5CIU,1856 +OpenGL/raw/GL/QCOM/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/raw/GL/QCOM/__pycache__/__init__.cpython-312.pyc,, +OpenGL/raw/GL/REND/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/raw/GL/REND/__pycache__/__init__.cpython-312.pyc,, +OpenGL/raw/GL/REND/__pycache__/screen_coordinates.cpython-312.pyc,, +OpenGL/raw/GL/REND/screen_coordinates.py,sha256=nHbrlWslSyIfVrSd99IQrL6HwSk1TfiUMdXy_uQOlMg,640 +OpenGL/raw/GL/S3/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/raw/GL/S3/__pycache__/__init__.cpython-312.pyc,, +OpenGL/raw/GL/S3/__pycache__/s3tc.cpython-312.pyc,, +OpenGL/raw/GL/S3/s3tc.py,sha256=SwtDoNnhcpZdOGYT27B1xOpKsrspZFwlKmLepjaZiPM,732 +OpenGL/raw/GL/SGI/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/raw/GL/SGI/__pycache__/__init__.cpython-312.pyc,, +OpenGL/raw/GL/SGI/__pycache__/color_matrix.cpython-312.pyc,, +OpenGL/raw/GL/SGI/__pycache__/color_table.cpython-312.pyc,, +OpenGL/raw/GL/SGI/__pycache__/texture_color_table.cpython-312.pyc,, +OpenGL/raw/GL/SGI/color_matrix.py,sha256=iU7i9IH7P56srUVpbOJop0l9eFgiVFYmkgdBpJn6oxs,1385 +OpenGL/raw/GL/SGI/color_table.py,sha256=UEiIlL0tLpswWXEwifXIq477rD-7mCv5lmFJMQm6sYY,2574 +OpenGL/raw/GL/SGI/texture_color_table.py,sha256=xIZIc0ET2KV_AnQNCUnedQjZ75aBaVNlpF-nOgg06K0,654 +OpenGL/raw/GL/SGIS/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/raw/GL/SGIS/__pycache__/__init__.cpython-312.pyc,, +OpenGL/raw/GL/SGIS/__pycache__/detail_texture.cpython-312.pyc,, +OpenGL/raw/GL/SGIS/__pycache__/fog_function.cpython-312.pyc,, +OpenGL/raw/GL/SGIS/__pycache__/generate_mipmap.cpython-312.pyc,, +OpenGL/raw/GL/SGIS/__pycache__/multisample.cpython-312.pyc,, +OpenGL/raw/GL/SGIS/__pycache__/pixel_texture.cpython-312.pyc,, +OpenGL/raw/GL/SGIS/__pycache__/point_line_texgen.cpython-312.pyc,, +OpenGL/raw/GL/SGIS/__pycache__/point_parameters.cpython-312.pyc,, +OpenGL/raw/GL/SGIS/__pycache__/sharpen_texture.cpython-312.pyc,, +OpenGL/raw/GL/SGIS/__pycache__/texture4D.cpython-312.pyc,, +OpenGL/raw/GL/SGIS/__pycache__/texture_border_clamp.cpython-312.pyc,, +OpenGL/raw/GL/SGIS/__pycache__/texture_color_mask.cpython-312.pyc,, +OpenGL/raw/GL/SGIS/__pycache__/texture_edge_clamp.cpython-312.pyc,, +OpenGL/raw/GL/SGIS/__pycache__/texture_filter4.cpython-312.pyc,, +OpenGL/raw/GL/SGIS/__pycache__/texture_lod.cpython-312.pyc,, +OpenGL/raw/GL/SGIS/__pycache__/texture_select.cpython-312.pyc,, +OpenGL/raw/GL/SGIS/detail_texture.py,sha256=iZG1JscNkutRdgY3vGBFUpTxKjBQK3dbQF8lSWn4uSI,1270 +OpenGL/raw/GL/SGIS/fog_function.py,sha256=cjlu0tagm-4Zc-kFnC8OLmovAAqnXw1qj05xe1tTPhg,831 +OpenGL/raw/GL/SGIS/generate_mipmap.py,sha256=wI77KGtxQwSdYoVI2uEwyfKee6G97ZlFj8Zdaf8-Q40,634 +OpenGL/raw/GL/SGIS/multisample.py,sha256=6dtMqIk_eeNUgqpepbqEMCTuU4JITENIAfcNkV2HjXA,1501 +OpenGL/raw/GL/SGIS/pixel_texture.py,sha256=Tn00eVTYO6_aa9hgkTaT80fWy4Tu6ds3BTdLb997Ubw,1383 +OpenGL/raw/GL/SGIS/point_line_texgen.py,sha256=VkKtMn7f6CvVRGWrCriIm3LvAaO3oxpqiLpORfjscRI,1010 +OpenGL/raw/GL/SGIS/point_parameters.py,sha256=aNhRwYw7Y9s4kROhtjB-Ekw2esQuzO5_EOwbazlrn_w,957 +OpenGL/raw/GL/SGIS/sharpen_texture.py,sha256=NUqC19Df-b0zyWUMxb3sUNQIulflwnR6viNp5zV2shU,996 +OpenGL/raw/GL/SGIS/texture4D.py,sha256=9HVX1wuIA3PN_k96L-BLDD7VZzyj0FMsP0LNUNA3ODU,1663 +OpenGL/raw/GL/SGIS/texture_border_clamp.py,sha256=rHIG6Uk9msVRsVgu6-2ObcdZusYTxDNv4c3pjMtXsIw,573 +OpenGL/raw/GL/SGIS/texture_color_mask.py,sha256=yU9aSDdAvZlJormEv2-Ye9u3QDxpq-mZDypIEuRZ544,714 +OpenGL/raw/GL/SGIS/texture_edge_clamp.py,sha256=tXv-sZEh9CJ_En7MV2YlpU8tL3sCEbdPv1ATD3TAIn8,565 +OpenGL/raw/GL/SGIS/texture_filter4.py,sha256=WMHhBTpy-1S0675PlrzuI1dr0qqgrI8IOwfHJ9wkYYE,862 +OpenGL/raw/GL/SGIS/texture_lod.py,sha256=lQpuzEEjbAvX9rP3t71ZwPjUqUsaA5mYK5B_7bRcFa8,748 +OpenGL/raw/GL/SGIS/texture_select.py,sha256=4Q5kwiZhhbd0_taM7YhCaIZhNNSdxRtN229wJa3dCOk,1846 +OpenGL/raw/GL/SGIX/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/raw/GL/SGIX/__pycache__/__init__.cpython-312.pyc,, +OpenGL/raw/GL/SGIX/__pycache__/async_.cpython-312.pyc,, +OpenGL/raw/GL/SGIX/__pycache__/async_histogram.cpython-312.pyc,, +OpenGL/raw/GL/SGIX/__pycache__/async_pixel.cpython-312.pyc,, +OpenGL/raw/GL/SGIX/__pycache__/blend_alpha_minmax.cpython-312.pyc,, +OpenGL/raw/GL/SGIX/__pycache__/calligraphic_fragment.cpython-312.pyc,, +OpenGL/raw/GL/SGIX/__pycache__/clipmap.cpython-312.pyc,, +OpenGL/raw/GL/SGIX/__pycache__/convolution_accuracy.cpython-312.pyc,, +OpenGL/raw/GL/SGIX/__pycache__/depth_pass_instrument.cpython-312.pyc,, +OpenGL/raw/GL/SGIX/__pycache__/depth_texture.cpython-312.pyc,, +OpenGL/raw/GL/SGIX/__pycache__/flush_raster.cpython-312.pyc,, +OpenGL/raw/GL/SGIX/__pycache__/fog_offset.cpython-312.pyc,, +OpenGL/raw/GL/SGIX/__pycache__/fragment_lighting.cpython-312.pyc,, +OpenGL/raw/GL/SGIX/__pycache__/framezoom.cpython-312.pyc,, +OpenGL/raw/GL/SGIX/__pycache__/igloo_interface.cpython-312.pyc,, +OpenGL/raw/GL/SGIX/__pycache__/instruments.cpython-312.pyc,, +OpenGL/raw/GL/SGIX/__pycache__/interlace.cpython-312.pyc,, +OpenGL/raw/GL/SGIX/__pycache__/ir_instrument1.cpython-312.pyc,, +OpenGL/raw/GL/SGIX/__pycache__/list_priority.cpython-312.pyc,, +OpenGL/raw/GL/SGIX/__pycache__/pixel_texture.cpython-312.pyc,, +OpenGL/raw/GL/SGIX/__pycache__/pixel_tiles.cpython-312.pyc,, +OpenGL/raw/GL/SGIX/__pycache__/polynomial_ffd.cpython-312.pyc,, +OpenGL/raw/GL/SGIX/__pycache__/reference_plane.cpython-312.pyc,, +OpenGL/raw/GL/SGIX/__pycache__/resample.cpython-312.pyc,, +OpenGL/raw/GL/SGIX/__pycache__/scalebias_hint.cpython-312.pyc,, +OpenGL/raw/GL/SGIX/__pycache__/shadow.cpython-312.pyc,, +OpenGL/raw/GL/SGIX/__pycache__/shadow_ambient.cpython-312.pyc,, +OpenGL/raw/GL/SGIX/__pycache__/sprite.cpython-312.pyc,, +OpenGL/raw/GL/SGIX/__pycache__/subsample.cpython-312.pyc,, +OpenGL/raw/GL/SGIX/__pycache__/tag_sample_buffer.cpython-312.pyc,, +OpenGL/raw/GL/SGIX/__pycache__/texture_add_env.cpython-312.pyc,, +OpenGL/raw/GL/SGIX/__pycache__/texture_coordinate_clamp.cpython-312.pyc,, +OpenGL/raw/GL/SGIX/__pycache__/texture_lod_bias.cpython-312.pyc,, +OpenGL/raw/GL/SGIX/__pycache__/texture_multi_buffer.cpython-312.pyc,, +OpenGL/raw/GL/SGIX/__pycache__/texture_scale_bias.cpython-312.pyc,, +OpenGL/raw/GL/SGIX/__pycache__/vertex_preclip.cpython-312.pyc,, +OpenGL/raw/GL/SGIX/__pycache__/ycrcb.cpython-312.pyc,, +OpenGL/raw/GL/SGIX/__pycache__/ycrcb_subsample.cpython-312.pyc,, +OpenGL/raw/GL/SGIX/__pycache__/ycrcba.cpython-312.pyc,, +OpenGL/raw/GL/SGIX/async_.py,sha256=lo1-Ucxyb8clNCkXeptkhKDxQNBOmb9BgoZ8inzjNeI,1006 +OpenGL/raw/GL/SGIX/async_histogram.py,sha256=tbqLY2QEqXBvlIgGkZn3_MO7xTHtQii7pijuJ1zif_M,632 +OpenGL/raw/GL/SGIX/async_pixel.py,sha256=EltIJteHE8jDRJwpByMF6p-FPX9XUB2XEp9zCQG6iqE,900 +OpenGL/raw/GL/SGIX/blend_alpha_minmax.py,sha256=gltV4TCz47xR6uBk02Hs_QwPoHxp6DpdwdlGHyN9x-c,606 +OpenGL/raw/GL/SGIX/calligraphic_fragment.py,sha256=2hgjNUv5NJ4yZb5XwjIFWzzsRiPKNYaLPfI82vbNFoc,587 +OpenGL/raw/GL/SGIX/clipmap.py,sha256=ygNUJZhq81uyc6AygytO6SbhBSYrl4uiFihk1DL118s,1400 +OpenGL/raw/GL/SGIX/convolution_accuracy.py,sha256=P_DS3GEOKN9PkawpH_BAipM79CjH2VzQnZqCxqKINgE,575 +OpenGL/raw/GL/SGIX/depth_pass_instrument.py,sha256=v-S9TfuxyYbQn7o8qpQyJYojqkPN8_v8qWrcSbX75Ok,515 +OpenGL/raw/GL/SGIX/depth_texture.py,sha256=IBpBU0Sr5WKJm45LVCBu2QHkeVftPIY7eLr0A_i7Nwg,693 +OpenGL/raw/GL/SGIX/flush_raster.py,sha256=K8ALNXO3Houi5lCcT1KpCuEzrzNL5bi5i1jgCDNDEQ8,546 +OpenGL/raw/GL/SGIX/fog_offset.py,sha256=LWtZ7SDeXOPE9inBufH9KFSckrFbZbst2hOlauv3KTY,606 +OpenGL/raw/GL/SGIX/fragment_lighting.py,sha256=2XTZ8sGnT2exjWYE9g3PsWhIZESG0iKXhQgdba6zM10,3848 +OpenGL/raw/GL/SGIX/framezoom.py,sha256=XRrk9m2xjBmH3t1H05IhA2LgxHge0EKjKEU9U2Rq3fY,735 +OpenGL/raw/GL/SGIX/igloo_interface.py,sha256=aRzwZyjrxpFlcndlGWvXggfXU3zwmEwoZAWUTYR7_4k,593 +OpenGL/raw/GL/SGIX/instruments.py,sha256=F70hEN5qnd_3BCViGWSw5qLYJwiIZiy-LBSy492iNFM,1082 +OpenGL/raw/GL/SGIX/interlace.py,sha256=yavuRZfEzh3SOxg5jvAOrJG2m4r_ombWaJQNNzK6zPQ,539 +OpenGL/raw/GL/SGIX/ir_instrument1.py,sha256=Jc82-2DZVVGtnwC3eQAR01EGnBofHN30eoA2aN5VqB4,559 +OpenGL/raw/GL/SGIX/list_priority.py,sha256=uUlv-nqLtDeb_K4u8a9_eUo7zD0sjwZSTwVQy4KBBts,1206 +OpenGL/raw/GL/SGIX/pixel_texture.py,sha256=Hcr-VxjFfrVb9O_Em0hoRpArG-wg4cB47BIZnBgcR70,685 +OpenGL/raw/GL/SGIX/pixel_tiles.py,sha256=5pEmygkomDZq07-ZfiQ9RMLPVJ3hkKBAv3BtayB_aUo,1080 +OpenGL/raw/GL/SGIX/polynomial_ffd.py,sha256=8Rk3xqwtefI8gYg8igrNhIyN6Qd2S_83GnOeb9Qc7Ls,1680 +OpenGL/raw/GL/SGIX/reference_plane.py,sha256=RUn-u61iXN9WB1U2MHgsR-vC4Oqw_wA2OFfU_oQ3UbI,722 +OpenGL/raw/GL/SGIX/resample.py,sha256=h6h3EyYLpmgKvTtzXN0_H5WNnxtnBhJaVrbj-F98d6c,805 +OpenGL/raw/GL/SGIX/scalebias_hint.py,sha256=77u99N9NUGa2ezBFhRpdXPIdNkKctYNLQK8OQaYhHvA,559 +OpenGL/raw/GL/SGIX/shadow.py,sha256=BWR8yiH9qB76u61CkUqxFRM9T86RooDgIC6Pnl-3h10,750 +OpenGL/raw/GL/SGIX/shadow_ambient.py,sha256=X2F0o-iWjBMbkpJCSea7i-I3Eoc_N9gFW3TXRvWLWlk,559 +OpenGL/raw/GL/SGIX/sprite.py,sha256=rgZKW2-YMNh2ysznqyQ8Ejs7igs3vh8y-HPPXDMJnoY,1262 +OpenGL/raw/GL/SGIX/subsample.py,sha256=T-7eJx_lqsBVNblAGb6HYbQTUIHS1-PapWj_GEF-IDY,845 +OpenGL/raw/GL/SGIX/tag_sample_buffer.py,sha256=7w-MuCm6j5WumJ1Myexh34jygOOs6cm4Jgi5i-58VdY,560 +OpenGL/raw/GL/SGIX/texture_add_env.py,sha256=WGLDc-UVwEaJ8jseQcgn-WqprV699qx8fa0GbKPb0TM,565 +OpenGL/raw/GL/SGIX/texture_coordinate_clamp.py,sha256=7Plpl7_ZYy-7WedDXTQ9FJ5gwL_lgXNWqSteZVuHhiw,727 +OpenGL/raw/GL/SGIX/texture_lod_bias.py,sha256=DLtOZTAM64JC-PbzDHwgFG9Qvoa2Pfl-fLmNo8jT-AM,705 +OpenGL/raw/GL/SGIX/texture_multi_buffer.py,sha256=CqP81nDVRh1t8-9BbKQj_1TdHhhr4jpHP0O7qcqbcR8,593 +OpenGL/raw/GL/SGIX/texture_scale_bias.py,sha256=kYw3mll2MKL8uLA6zzcIHNb7Fcl12cZGbb4cCNEV1O8,852 +OpenGL/raw/GL/SGIX/vertex_preclip.py,sha256=SpYPFymeFQDb2QlV7VY3_XdhZOP2ZlrpXYVL7vJhhH0,628 +OpenGL/raw/GL/SGIX/ycrcb.py,sha256=rxJYIh5EgI4gknlf4-XJataaKXT7d1vGfjJ5nexRWBw,580 +OpenGL/raw/GL/SGIX/ycrcb_subsample.py,sha256=OYLPtH3mCoR2Y-C-apuCx7O8_zaAaAPzzIkl-caS45I,503 +OpenGL/raw/GL/SGIX/ycrcba.py,sha256=gNIjRAsHkcZp3B2L-8LfZWU5y2_mUd7DFH8UINEP5yA,568 +OpenGL/raw/GL/SUN/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/raw/GL/SUN/__pycache__/__init__.cpython-312.pyc,, +OpenGL/raw/GL/SUN/__pycache__/convolution_border_modes.cpython-312.pyc,, +OpenGL/raw/GL/SUN/__pycache__/global_alpha.cpython-312.pyc,, +OpenGL/raw/GL/SUN/__pycache__/mesh_array.cpython-312.pyc,, +OpenGL/raw/GL/SUN/__pycache__/slice_accum.cpython-312.pyc,, +OpenGL/raw/GL/SUN/__pycache__/triangle_list.cpython-312.pyc,, +OpenGL/raw/GL/SUN/__pycache__/vertex.cpython-312.pyc,, +OpenGL/raw/GL/SUN/convolution_border_modes.py,sha256=66GBARdoA5qj8cDAft40k7zfNgrjKGLwjhe7AK58ZfI,569 +OpenGL/raw/GL/SUN/global_alpha.py,sha256=4HMkwHI78bWprkhRVr3W1SUEZyo1VPonygekZ4s_I6s,1198 +OpenGL/raw/GL/SUN/mesh_array.py,sha256=cv2ZE9jF4-RGb__nkA8nfOCCPdGboR14xZ2Mc6IZVyM,709 +OpenGL/raw/GL/SUN/slice_accum.py,sha256=zLKKMo114i6knSgxIBnJJ76dZuRJ4CP9ZTpFEelFuqY,543 +OpenGL/raw/GL/SUN/triangle_list.py,sha256=CeI5CVa9EI2lK3Y5QjlSOWlN8FUDm16VjBQbTtYDnZU,2118 +OpenGL/raw/GL/SUN/vertex.py,sha256=hU2TI6eWBbGMq0ZP2hOdCt6zadHimtyr-4UN7QeSgBs,6699 +OpenGL/raw/GL/SUNX/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/raw/GL/SUNX/__pycache__/__init__.cpython-312.pyc,, +OpenGL/raw/GL/SUNX/__pycache__/constant_data.cpython-312.pyc,, +OpenGL/raw/GL/SUNX/constant_data.py,sha256=qyxtzW1X5-zeXmDERhIsZUbEqPtWn1GKCtckiairdPI,693 +OpenGL/raw/GL/VERSION/GL_1_0.py,sha256=elVyqxjpoKoiZe9vxtEQGcYbKs_8041JqRL7OBFtOO8,44426 +OpenGL/raw/GL/VERSION/GL_1_1.py,sha256=4ScMC2WURCE69nuRkx7qgHu7FbB0UGQWW07uGr_v_Ms,9001 +OpenGL/raw/GL/VERSION/GL_1_2.py,sha256=aoVG_1hOom2k2uFnYCd-T4TBYw9jEzO_EznEDftGRHQ,3758 +OpenGL/raw/GL/VERSION/GL_1_3.py,sha256=j-Bpbp8hYMutwCaZVRxupokWwcArlMM5UOcH5JodTP0,10203 +OpenGL/raw/GL/VERSION/GL_1_4.py,sha256=G8YOIRIczC3NBmJVWyWcwJXWtijv-zvOfkgCx1F7QK0,7307 +OpenGL/raw/GL/VERSION/GL_1_5.py,sha256=Y_jGgr1w3KLMuz9Oi-oxov9zzOSViSCwcBc1CGKsFEE,5013 +OpenGL/raw/GL/VERSION/GL_2_0.py,sha256=_am2yXpCTuPwH3odE6Z0CQe304rqqL6oSbW6AzwcMcQ,14306 +OpenGL/raw/GL/VERSION/GL_2_1.py,sha256=UUJQyFiZDCYbwIfWgaLsF1Zs9lke3iZB0NEpF-tutjU,2520 +OpenGL/raw/GL/VERSION/GL_3_0.py,sha256=0yS1t_03YWnxfI02UBmnml3s8Z5wxqlb0B_XnSGPONE,22949 +OpenGL/raw/GL/VERSION/GL_3_1.py,sha256=51xV3ydtS__70NF8BAVeTUBBrh8a8W9XMvm12F2Bz2k,6539 +OpenGL/raw/GL/VERSION/GL_3_2.py,sha256=Z4Q4d_chJ0ipTH5ac1DI6jOSn-1nPCAOBGQ99rjv0VI,7152 +OpenGL/raw/GL/VERSION/GL_3_3.py,sha256=rt8ek5W7DOPO9QRsUNZ-u0I8DCV3QJaonlbROKPdt2Y,7151 +OpenGL/raw/GL/VERSION/GL_4_0.py,sha256=251xTTLGOqGseykVm_61GXt0iCjK-nlBy9U6MupLbKE,11219 +OpenGL/raw/GL/VERSION/GL_4_1.py,sha256=6X3B5d3M9MfqS5xGm0nSKwlffEX1kQlREXG3XuQW5yI,13714 +OpenGL/raw/GL/VERSION/GL_4_2.py,sha256=YrY7o1D2nLME6nzlNsSg4sNio9ylxTKXn7E2CTk864A,10687 +OpenGL/raw/GL/VERSION/GL_4_3.py,sha256=GQEeJr78JUbwsrn0R_MZAtCGG4okDgZvh1UAEmaQvik,23927 +OpenGL/raw/GL/VERSION/GL_4_4.py,sha256=nsh4jwPHgOvCoy4FaYGG5H00snmWKUwSB6qKApg1ZTA,3423 +OpenGL/raw/GL/VERSION/GL_4_5.py,sha256=9MWEHJbEpUBW5EaD-t_5TDySknuN5fh0lguhykg4Hmk,19584 +OpenGL/raw/GL/VERSION/GL_4_6.py,sha256=GfQZRPNNj3_YnXuxKgz0SCiF_AzzLh9f3dRfI8mrDnw,2938 +OpenGL/raw/GL/VERSION/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/raw/GL/VERSION/__pycache__/GL_1_0.cpython-312.pyc,, +OpenGL/raw/GL/VERSION/__pycache__/GL_1_1.cpython-312.pyc,, +OpenGL/raw/GL/VERSION/__pycache__/GL_1_2.cpython-312.pyc,, +OpenGL/raw/GL/VERSION/__pycache__/GL_1_3.cpython-312.pyc,, +OpenGL/raw/GL/VERSION/__pycache__/GL_1_4.cpython-312.pyc,, +OpenGL/raw/GL/VERSION/__pycache__/GL_1_5.cpython-312.pyc,, +OpenGL/raw/GL/VERSION/__pycache__/GL_2_0.cpython-312.pyc,, +OpenGL/raw/GL/VERSION/__pycache__/GL_2_1.cpython-312.pyc,, +OpenGL/raw/GL/VERSION/__pycache__/GL_3_0.cpython-312.pyc,, +OpenGL/raw/GL/VERSION/__pycache__/GL_3_1.cpython-312.pyc,, +OpenGL/raw/GL/VERSION/__pycache__/GL_3_2.cpython-312.pyc,, +OpenGL/raw/GL/VERSION/__pycache__/GL_3_3.cpython-312.pyc,, +OpenGL/raw/GL/VERSION/__pycache__/GL_4_0.cpython-312.pyc,, +OpenGL/raw/GL/VERSION/__pycache__/GL_4_1.cpython-312.pyc,, +OpenGL/raw/GL/VERSION/__pycache__/GL_4_2.cpython-312.pyc,, +OpenGL/raw/GL/VERSION/__pycache__/GL_4_3.cpython-312.pyc,, +OpenGL/raw/GL/VERSION/__pycache__/GL_4_4.cpython-312.pyc,, +OpenGL/raw/GL/VERSION/__pycache__/GL_4_5.cpython-312.pyc,, +OpenGL/raw/GL/VERSION/__pycache__/GL_4_6.cpython-312.pyc,, +OpenGL/raw/GL/VERSION/__pycache__/__init__.cpython-312.pyc,, +OpenGL/raw/GL/VIV/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/raw/GL/VIV/__pycache__/__init__.cpython-312.pyc,, +OpenGL/raw/GL/WIN/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/raw/GL/WIN/__pycache__/__init__.cpython-312.pyc,, +OpenGL/raw/GL/WIN/__pycache__/phong_shading.cpython-312.pyc,, +OpenGL/raw/GL/WIN/__pycache__/specular_fog.cpython-312.pyc,, +OpenGL/raw/GL/WIN/phong_shading.py,sha256=KpeG8Uk-_I6tc2MBzqBsCfVnF-SJwI2x4nbfzIE8XTg,584 +OpenGL/raw/GL/WIN/specular_fog.py,sha256=gkK2dvvlHu8kmnofrT9fAC5jS03BaojTzB2L-dNO24Y,563 +OpenGL/raw/GL/__init__.py,sha256=lB94yv1MZYmgaaV8fvDkOk79pwMadwV4GKhs68LvJT4,38 +OpenGL/raw/GL/__pycache__/__init__.cpython-312.pyc,, +OpenGL/raw/GL/__pycache__/_errors.cpython-312.pyc,, +OpenGL/raw/GL/__pycache__/_glgets.cpython-312.pyc,, +OpenGL/raw/GL/__pycache__/_lookupint.cpython-312.pyc,, +OpenGL/raw/GL/__pycache__/_types.cpython-312.pyc,, +OpenGL/raw/GL/_errors.py,sha256=P3qCvHLvPfP1gJ2EIUpw6aiuqs30-zWNrZ75wKC68dE,191 +OpenGL/raw/GL/_glgets.py,sha256=GqC8rv1afGq7BlFLHO3avEgv01NkZD5_fVsBZg4M47E,145541 +OpenGL/raw/GL/_lookupint.py,sha256=K4z295hFMalEFebJMZinJWveq_vY5NHwgDj8JlczEDA,866 +OpenGL/raw/GL/_types.py,sha256=a9NhDsGpDaGQdRJkQBjN2IcIrbu1JtupRcgr4gjir5c,5874 +OpenGL/raw/GLE/__init__.py,sha256=NjvJHzV59PrV62AZHImu9QFW_kkozsxm7zAbL-IUnW0,12380 +OpenGL/raw/GLE/__pycache__/__init__.cpython-312.pyc,, +OpenGL/raw/GLE/__pycache__/annotations.cpython-312.pyc,, +OpenGL/raw/GLE/__pycache__/constants.cpython-312.pyc,, +OpenGL/raw/GLE/annotations.py,sha256=hWHV5I-WHQESYaKFj_G2tluBnasieFqlCpkyFrZ-hZE,12902 +OpenGL/raw/GLE/constants.py,sha256=88CUKuBUspChahPmngGxzy71w1SrDAmou4rF2LNFewQ,2554 +OpenGL/raw/GLES1/AMD/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/raw/GLES1/AMD/__pycache__/__init__.cpython-312.pyc,, +OpenGL/raw/GLES1/AMD/__pycache__/compressed_3DC_texture.cpython-312.pyc,, +OpenGL/raw/GLES1/AMD/__pycache__/compressed_ATC_texture.cpython-312.pyc,, +OpenGL/raw/GLES1/AMD/compressed_3DC_texture.py,sha256=t0apGcoWyKqOzdXWA3OxvU5diiF0lglbFADZ9y2z4wM,612 +OpenGL/raw/GLES1/AMD/compressed_ATC_texture.py,sha256=7fXu0s98ViVJrF7F9oL2IC496zPLscxMqd-bcQiMyO4,733 +OpenGL/raw/GLES1/APPLE/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/raw/GLES1/APPLE/__pycache__/__init__.cpython-312.pyc,, +OpenGL/raw/GLES1/APPLE/__pycache__/copy_texture_levels.cpython-312.pyc,, +OpenGL/raw/GLES1/APPLE/__pycache__/framebuffer_multisample.cpython-312.pyc,, +OpenGL/raw/GLES1/APPLE/__pycache__/sync.cpython-312.pyc,, +OpenGL/raw/GLES1/APPLE/__pycache__/texture_2D_limited_npot.cpython-312.pyc,, +OpenGL/raw/GLES1/APPLE/__pycache__/texture_format_BGRA8888.cpython-312.pyc,, +OpenGL/raw/GLES1/APPLE/__pycache__/texture_max_level.cpython-312.pyc,, +OpenGL/raw/GLES1/APPLE/copy_texture_levels.py,sha256=1zXBCpK5YNf93IvV2zW0U0qzuVI1d0pWtDo5G6YNA7I,695 +OpenGL/raw/GLES1/APPLE/framebuffer_multisample.py,sha256=N9VxX7FVUaSYZoycjZ6VKO0h2dxrft040lf6f7ttVso,1296 +OpenGL/raw/GLES1/APPLE/sync.py,sha256=TUqTOzYmlLfiCkbIPTDMcYW40YgggrLz_Y5LvGFcxs8,2204 +OpenGL/raw/GLES1/APPLE/texture_2D_limited_npot.py,sha256=ncwYgWejaACwn92coz3gZKRjM3JGLG5xw3md05_8_oo,539 +OpenGL/raw/GLES1/APPLE/texture_format_BGRA8888.py,sha256=ys0s4GT41xXD-C17Q_5qyXB98AqpcmHYlxYR8OhghRA,614 +OpenGL/raw/GLES1/APPLE/texture_max_level.py,sha256=4eLDwqXZM80e3_SejS8WYIP8d0jhs8f4QkMwz8Zhpnc,593 +OpenGL/raw/GLES1/ARM/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/raw/GLES1/ARM/__pycache__/__init__.cpython-312.pyc,, +OpenGL/raw/GLES1/ARM/__pycache__/rgba8.cpython-312.pyc,, +OpenGL/raw/GLES1/ARM/rgba8.py,sha256=OoSfboQJMfbfv8_hyu6YInHYGicGkj2lkitqhvKOFBQ,499 +OpenGL/raw/GLES1/EXT/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/raw/GLES1/EXT/__pycache__/__init__.cpython-312.pyc,, +OpenGL/raw/GLES1/EXT/__pycache__/blend_minmax.cpython-312.pyc,, +OpenGL/raw/GLES1/EXT/__pycache__/debug_marker.cpython-312.pyc,, +OpenGL/raw/GLES1/EXT/__pycache__/discard_framebuffer.cpython-312.pyc,, +OpenGL/raw/GLES1/EXT/__pycache__/map_buffer_range.cpython-312.pyc,, +OpenGL/raw/GLES1/EXT/__pycache__/multi_draw_arrays.cpython-312.pyc,, +OpenGL/raw/GLES1/EXT/__pycache__/multisampled_render_to_texture.cpython-312.pyc,, +OpenGL/raw/GLES1/EXT/__pycache__/read_format_bgra.cpython-312.pyc,, +OpenGL/raw/GLES1/EXT/__pycache__/robustness.cpython-312.pyc,, +OpenGL/raw/GLES1/EXT/__pycache__/sRGB.cpython-312.pyc,, +OpenGL/raw/GLES1/EXT/__pycache__/texture_compression_dxt1.cpython-312.pyc,, +OpenGL/raw/GLES1/EXT/__pycache__/texture_filter_anisotropic.cpython-312.pyc,, +OpenGL/raw/GLES1/EXT/__pycache__/texture_format_BGRA8888.cpython-312.pyc,, +OpenGL/raw/GLES1/EXT/__pycache__/texture_lod_bias.cpython-312.pyc,, +OpenGL/raw/GLES1/EXT/__pycache__/texture_storage.cpython-312.pyc,, +OpenGL/raw/GLES1/EXT/blend_minmax.py,sha256=z8OSBMd4iYdf343CF2PQhupJcSVRVWY48l_6WKEO28E,748 +OpenGL/raw/GLES1/EXT/debug_marker.py,sha256=TEWroNnHQtvvPrZhiS7CWJE7Vx5Ne-khN9IUnMDiV04,758 +OpenGL/raw/GLES1/EXT/discard_framebuffer.py,sha256=Lo66JHQZ70bSd6e3BhW3FzYdlJxHpFB0cqs8-nYGsRY,776 +OpenGL/raw/GLES1/EXT/map_buffer_range.py,sha256=RCgQWs0xIEeTtBLwniloxgcaLCoC4f6Ag33j584Pj2Y,1190 +OpenGL/raw/GLES1/EXT/multi_draw_arrays.py,sha256=cBLGw1ULsbdyI86zic8tf2IcH5Gt2NOhDzFfe8vIg6k,822 +OpenGL/raw/GLES1/EXT/multisampled_render_to_texture.py,sha256=feEgiN1Hu5I2VUt8FjuDvSVVJBz6KEj_g2nJtxFukHI,1219 +OpenGL/raw/GLES1/EXT/read_format_bgra.py,sha256=_B67zWVnZTQp3dEpSqEGSRHy0pMH4K_M1tN8BoTXIFU,719 +OpenGL/raw/GLES1/EXT/robustness.py,sha256=I1-Q4GSdTTG0Jw8pgvP6eH4xkWxe6Er-OFMp_3nYjGc,1563 +OpenGL/raw/GLES1/EXT/sRGB.py,sha256=leTbhG0733pbRhIxHhmvEQpcnKOT8av8j9YXT2yhId0,738 +OpenGL/raw/GLES1/EXT/texture_compression_dxt1.py,sha256=uLUnNPQYZjiDMBL0PYXZJlJ-Em9r817HxYqBXH7lI-M,692 +OpenGL/raw/GLES1/EXT/texture_filter_anisotropic.py,sha256=dlhIFMXJVok9RSt9pfHPkioRNRRBJoG4ag-lDPTdrTI,694 +OpenGL/raw/GLES1/EXT/texture_format_BGRA8888.py,sha256=u7FqI0BnET8ipf_QC4kz9o8v14vUVSUtf2XWsAZAQAE,571 +OpenGL/raw/GLES1/EXT/texture_lod_bias.py,sha256=kxsepiOg3fvRoyBM1CEuti3a9MORJDDIxN6Sby3Usc4,723 +OpenGL/raw/GLES1/EXT/texture_storage.py,sha256=ltDZJszzqcrIYPu4s_MCMp_xrThV_WstCNehKhJl6Wc,2539 +OpenGL/raw/GLES1/IMG/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/raw/GLES1/IMG/__pycache__/__init__.cpython-312.pyc,, +OpenGL/raw/GLES1/IMG/__pycache__/multisampled_render_to_texture.cpython-312.pyc,, +OpenGL/raw/GLES1/IMG/__pycache__/read_format.cpython-312.pyc,, +OpenGL/raw/GLES1/IMG/__pycache__/texture_compression_pvrtc.cpython-312.pyc,, +OpenGL/raw/GLES1/IMG/__pycache__/texture_env_enhanced_fixed_function.cpython-312.pyc,, +OpenGL/raw/GLES1/IMG/__pycache__/user_clip_plane.cpython-312.pyc,, +OpenGL/raw/GLES1/IMG/multisampled_render_to_texture.py,sha256=Z1TARdz4z5eGVq9nIGUZ06XgAPw_eTrpglKUuVxqJmM,1173 +OpenGL/raw/GLES1/IMG/read_format.py,sha256=HpiHRODXgyiE2L6f-ljYLrnAmIdrZFCo5rZlSWCj9u0,628 +OpenGL/raw/GLES1/IMG/texture_compression_pvrtc.py,sha256=t5ydh-uwfwtZjOGFtBAANtV8d9MK7vH0J-kThpr6v9s,874 +OpenGL/raw/GLES1/IMG/texture_env_enhanced_fixed_function.py,sha256=vCQjBe8s1Azpb1Dr6bJdPAQROcyQBAOYsMXf1pQNgjc,1001 +OpenGL/raw/GLES1/IMG/user_clip_plane.py,sha256=ukqBmCRAi5qrBaOZd_io-v8IPRr9Qoh0g2Sun4-8zjU,1048 +OpenGL/raw/GLES1/KHR/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/raw/GLES1/KHR/__pycache__/__init__.cpython-312.pyc,, +OpenGL/raw/GLES1/KHR/__pycache__/debug.cpython-312.pyc,, +OpenGL/raw/GLES1/KHR/debug.py,sha256=e5opBkFbvKxTTr0Uo60qhLAKPJwCR0yMWVFI1FiJRDo,8666 +OpenGL/raw/GLES1/NV/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/raw/GLES1/NV/__pycache__/__init__.cpython-312.pyc,, +OpenGL/raw/GLES1/NV/__pycache__/fence.cpython-312.pyc,, +OpenGL/raw/GLES1/NV/fence.py,sha256=t1t5TOS-vexECGLDwS4-i2d6oMNGrRV_sN0S_eje2xE,1213 +OpenGL/raw/GLES1/OES/EGL_image.py,sha256=ysbcPAcLB-o2nFWvKDzZ_IeCaxF3zVAawwfCVgXG4Ps,718 +OpenGL/raw/GLES1/OES/EGL_image_external.py,sha256=yS4lW8tpbaQGzEVaN-aEEa5BK24XAFHGa7VY_9IVlW8,808 +OpenGL/raw/GLES1/OES/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/raw/GLES1/OES/__pycache__/EGL_image.cpython-312.pyc,, +OpenGL/raw/GLES1/OES/__pycache__/EGL_image_external.cpython-312.pyc,, +OpenGL/raw/GLES1/OES/__pycache__/__init__.cpython-312.pyc,, +OpenGL/raw/GLES1/OES/__pycache__/blend_equation_separate.cpython-312.pyc,, +OpenGL/raw/GLES1/OES/__pycache__/blend_func_separate.cpython-312.pyc,, +OpenGL/raw/GLES1/OES/__pycache__/blend_subtract.cpython-312.pyc,, +OpenGL/raw/GLES1/OES/__pycache__/byte_coordinates.cpython-312.pyc,, +OpenGL/raw/GLES1/OES/__pycache__/compressed_ETC1_RGB8_sub_texture.cpython-312.pyc,, +OpenGL/raw/GLES1/OES/__pycache__/compressed_ETC1_RGB8_texture.cpython-312.pyc,, +OpenGL/raw/GLES1/OES/__pycache__/compressed_paletted_texture.cpython-312.pyc,, +OpenGL/raw/GLES1/OES/__pycache__/depth24.cpython-312.pyc,, +OpenGL/raw/GLES1/OES/__pycache__/depth32.cpython-312.pyc,, +OpenGL/raw/GLES1/OES/__pycache__/draw_texture.cpython-312.pyc,, +OpenGL/raw/GLES1/OES/__pycache__/element_index_uint.cpython-312.pyc,, +OpenGL/raw/GLES1/OES/__pycache__/extended_matrix_palette.cpython-312.pyc,, +OpenGL/raw/GLES1/OES/__pycache__/fbo_render_mipmap.cpython-312.pyc,, +OpenGL/raw/GLES1/OES/__pycache__/fixed_point.cpython-312.pyc,, +OpenGL/raw/GLES1/OES/__pycache__/framebuffer_object.cpython-312.pyc,, +OpenGL/raw/GLES1/OES/__pycache__/mapbuffer.cpython-312.pyc,, +OpenGL/raw/GLES1/OES/__pycache__/matrix_get.cpython-312.pyc,, +OpenGL/raw/GLES1/OES/__pycache__/matrix_palette.cpython-312.pyc,, +OpenGL/raw/GLES1/OES/__pycache__/packed_depth_stencil.cpython-312.pyc,, +OpenGL/raw/GLES1/OES/__pycache__/point_size_array.cpython-312.pyc,, +OpenGL/raw/GLES1/OES/__pycache__/point_sprite.cpython-312.pyc,, +OpenGL/raw/GLES1/OES/__pycache__/query_matrix.cpython-312.pyc,, +OpenGL/raw/GLES1/OES/__pycache__/read_format.cpython-312.pyc,, +OpenGL/raw/GLES1/OES/__pycache__/required_internalformat.cpython-312.pyc,, +OpenGL/raw/GLES1/OES/__pycache__/rgb8_rgba8.cpython-312.pyc,, +OpenGL/raw/GLES1/OES/__pycache__/single_precision.cpython-312.pyc,, +OpenGL/raw/GLES1/OES/__pycache__/stencil1.cpython-312.pyc,, +OpenGL/raw/GLES1/OES/__pycache__/stencil4.cpython-312.pyc,, +OpenGL/raw/GLES1/OES/__pycache__/stencil8.cpython-312.pyc,, +OpenGL/raw/GLES1/OES/__pycache__/stencil_wrap.cpython-312.pyc,, +OpenGL/raw/GLES1/OES/__pycache__/surfaceless_context.cpython-312.pyc,, +OpenGL/raw/GLES1/OES/__pycache__/texture_cube_map.cpython-312.pyc,, +OpenGL/raw/GLES1/OES/__pycache__/texture_env_crossbar.cpython-312.pyc,, +OpenGL/raw/GLES1/OES/__pycache__/texture_mirrored_repeat.cpython-312.pyc,, +OpenGL/raw/GLES1/OES/__pycache__/texture_npot.cpython-312.pyc,, +OpenGL/raw/GLES1/OES/__pycache__/vertex_array_object.cpython-312.pyc,, +OpenGL/raw/GLES1/OES/blend_equation_separate.py,sha256=M8kP0fqQLBLivQ42QE3iU0pFVPO5KY16By_1w3hUkmg,764 +OpenGL/raw/GLES1/OES/blend_func_separate.py,sha256=0TJnNSepTd40kiWuSaPLZbseoOh3zERtLoJs6ovWPYQ,882 +OpenGL/raw/GLES1/OES/blend_subtract.py,sha256=cS9tR77jSFm92zTPsYOWWaDdh_a1aAFWPQPWiUR8B9Y,808 +OpenGL/raw/GLES1/OES/byte_coordinates.py,sha256=nEuy6XeWoH3GTKxnmQxmI_c_kMsEg0to-wChvXWh8ZE,2414 +OpenGL/raw/GLES1/OES/compressed_ETC1_RGB8_sub_texture.py,sha256=pKQW8fDFg0wRR1tDoJkQcu63slpb1Ql5dZzO5-a1WXA,553 +OpenGL/raw/GLES1/OES/compressed_ETC1_RGB8_texture.py,sha256=k_7qkU9r3obFDXW0onLLd-WmkIdiiTp8EfgSLU30808,591 +OpenGL/raw/GLES1/OES/compressed_paletted_texture.py,sha256=dYBAwAvKRC_YSSkcz8udPGer-cZO4az-jB5kBnTuWak,1128 +OpenGL/raw/GLES1/OES/depth24.py,sha256=BcH-lln8nayxVPZKHKHB93kSAGSizWuaOzCj1gwZS5k,565 +OpenGL/raw/GLES1/OES/depth32.py,sha256=sXpv2-aAHVbCgzBcD6dZLkjmETMDtqmA4psH2WaDIyM,565 +OpenGL/raw/GLES1/OES/draw_texture.py,sha256=A_I_RbHqR_8yU2KxMIHDg6OLUHA2cKiomlHZn1n1mnU,1342 +OpenGL/raw/GLES1/OES/element_index_uint.py,sha256=cllbarU_MQ24-Hq-qQrP94FwNcXsqDGsdi2nedipL8s,569 +OpenGL/raw/GLES1/OES/extended_matrix_palette.py,sha256=EcBRR3RwNQnkC4CD8CyvlQcx76Fd1hvi9Hr0JEVkvjM,535 +OpenGL/raw/GLES1/OES/fbo_render_mipmap.py,sha256=v0O2lyhLdOeplsAxZ88YRoNsHRNMHQG1Nx5Fy9C1KN4,523 +OpenGL/raw/GLES1/OES/fixed_point.py,sha256=HjSqhz4l_WPwTENsBWKfGYbZU1sSoFWQKHmo1BUv2xU,10556 +OpenGL/raw/GLES1/OES/framebuffer_object.py,sha256=VToIpiQWxErMFb8-wbihKQrVIuhtivQ7UrEUINRG420,4553 +OpenGL/raw/GLES1/OES/mapbuffer.py,sha256=w_YIAF7HwcauJrZsh54FRJaYmUCxA90gEl6128jR8NI,1010 +OpenGL/raw/GLES1/OES/matrix_get.py,sha256=HZnl8LkaYX-DHNtAz2teRF86bsn8usL1-aPBVWGKgEs,797 +OpenGL/raw/GLES1/OES/matrix_palette.py,sha256=sllB-kjurdj8gQlUB3i7pn-lI62NWKo8nlYXLzOb6fs,2048 +OpenGL/raw/GLES1/OES/packed_depth_stencil.py,sha256=bW5ZS1HkoFjrfliPjl0R2IPb3M5hnz0vRirDV4jsrbc,707 +OpenGL/raw/GLES1/OES/point_size_array.py,sha256=4J3DMqLYL6hdO4DWHpJ5jL22Vu7ZnLQ726CNoNUSpwM,1005 +OpenGL/raw/GLES1/OES/point_sprite.py,sha256=jUffZm-P9FkHnbdh8W3nO_2V9fEwo6ODAlbeA-1zco8,620 +OpenGL/raw/GLES1/OES/query_matrix.py,sha256=oIRPT14c9hDIfw4xD2i0R2sHhruToANz7hvPDm2-mz4,626 +OpenGL/raw/GLES1/OES/read_format.py,sha256=Qe7gtGWf8YVDYw0hPJB45CVicCtvvJp-nU0RRvOl-sk,692 +OpenGL/raw/GLES1/OES/required_internalformat.py,sha256=gcMvxvcwtPRxNgflzggkEGTXcV-9ex7vo4W_UKkWeag,1283 +OpenGL/raw/GLES1/OES/rgb8_rgba8.py,sha256=T-RiCxktZvdwrKaxkqqEleQrRUHuX9AiwXJrKbddSwU,584 +OpenGL/raw/GLES1/OES/single_precision.py,sha256=TUdW7ClLca6tNrI4ptqs_rh0fo0aT1iHhoG3t8xuFmw,1104 +OpenGL/raw/GLES1/OES/stencil1.py,sha256=xEjyKhLtgx-jOBqLeYpGZ-z-5U8KdxXuONlogFFDi60,561 +OpenGL/raw/GLES1/OES/stencil4.py,sha256=xfjGsuVqyZCed8sThKtuL5Y9_XzeOTfBN7d4pRt5da4,561 +OpenGL/raw/GLES1/OES/stencil8.py,sha256=XwwtwH5eFJv7UX3MA_I-dFeKDfMowLtn736N4LwymVU,561 +OpenGL/raw/GLES1/OES/stencil_wrap.py,sha256=HJ3BoZG61_d09CQzllaC7Gk2riy4-fotbY4KICbZhjs,606 +OpenGL/raw/GLES1/OES/surfaceless_context.py,sha256=VOfdR9PJ2Y1T5_oaLpeDxlDJYgA9gBCM7HFHpQtKvv8,597 +OpenGL/raw/GLES1/OES/texture_cube_map.py,sha256=gyU9LLjzMhPIQxEWxBoDYXQKqPgGTN2TSSvCz0kGFGA,2378 +OpenGL/raw/GLES1/OES/texture_env_crossbar.py,sha256=t2Y8Y5oCvs85tzzIFkXLyWdbNs03hR-vCdtdJDTKtQo,529 +OpenGL/raw/GLES1/OES/texture_mirrored_repeat.py,sha256=rC-u0yxVTglF9MYbMUrHmm5VQl7YXAMIScXbMAxX_6E,593 +OpenGL/raw/GLES1/OES/texture_npot.py,sha256=S7-S02ptIe1PIHD-iMQraH8vZIMRypc_Wl5m_4sPYR8,513 +OpenGL/raw/GLES1/OES/vertex_array_object.py,sha256=8AYK-EdgW41BLc_vqljecQImy4Axvs_XZS62yOwrwUs,922 +OpenGL/raw/GLES1/QCOM/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/raw/GLES1/QCOM/__pycache__/__init__.cpython-312.pyc,, +OpenGL/raw/GLES1/QCOM/__pycache__/driver_control.cpython-312.pyc,, +OpenGL/raw/GLES1/QCOM/__pycache__/extended_get.cpython-312.pyc,, +OpenGL/raw/GLES1/QCOM/__pycache__/extended_get2.cpython-312.pyc,, +OpenGL/raw/GLES1/QCOM/__pycache__/perfmon_global_mode.cpython-312.pyc,, +OpenGL/raw/GLES1/QCOM/__pycache__/tiled_rendering.cpython-312.pyc,, +OpenGL/raw/GLES1/QCOM/__pycache__/writeonly_rendering.cpython-312.pyc,, +OpenGL/raw/GLES1/QCOM/driver_control.py,sha256=L_YgLdkpfuqFlS0H0A7WhQYGflpRGJCViyz-p4SIf9s,978 +OpenGL/raw/GLES1/QCOM/extended_get.py,sha256=0ijKysFYrz5FilmQruiMRa9K3zeJ-99aC39aCGunewk,2371 +OpenGL/raw/GLES1/QCOM/extended_get2.py,sha256=JG4znDOjAEf0WyGZrT5gSULPX-HWz5MG8cZQ9v4ItFg,1011 +OpenGL/raw/GLES1/QCOM/perfmon_global_mode.py,sha256=Y4EmITjccfwwJxE623_JuICPe75ZPdx3wQKRuxzZlEI,597 +OpenGL/raw/GLES1/QCOM/tiled_rendering.py,sha256=dbc0MTPq4zUtbHFQebypfX_d463gqMfeckdYEJKdVF0,3066 +OpenGL/raw/GLES1/QCOM/writeonly_rendering.py,sha256=InVgNfxUnPmY_5FTRQ3L2yRbRqXUSp3NGV4x4VABpkk,597 +OpenGL/raw/GLES1/VERSION/GLES1_1_0.py,sha256=_vqOB4nejFztHehxqsgHyH9Axphzet4WuwL_t40-GHk,28883 +OpenGL/raw/GLES1/VERSION/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/raw/GLES1/VERSION/__pycache__/GLES1_1_0.cpython-312.pyc,, +OpenGL/raw/GLES1/VERSION/__pycache__/__init__.cpython-312.pyc,, +OpenGL/raw/GLES1/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +OpenGL/raw/GLES1/__pycache__/__init__.cpython-312.pyc,, +OpenGL/raw/GLES1/__pycache__/_errors.cpython-312.pyc,, +OpenGL/raw/GLES1/__pycache__/_glgets.cpython-312.pyc,, +OpenGL/raw/GLES1/__pycache__/_types.cpython-312.pyc,, +OpenGL/raw/GLES1/_errors.py,sha256=T9cJ2-uHNHHz07IKMVNk3LJTnpxyMiuMbOWwJI3C2AI,231 +OpenGL/raw/GLES1/_glgets.py,sha256=GqC8rv1afGq7BlFLHO3avEgv01NkZD5_fVsBZg4M47E,145541 +OpenGL/raw/GLES1/_types.py,sha256=rTpXxgICEXUD-IhuPbC3lmJo8sFIb34FJWiq75RTioY,201 +OpenGL/raw/GLES2/AMD/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/raw/GLES2/AMD/__pycache__/__init__.cpython-312.pyc,, +OpenGL/raw/GLES2/AMD/__pycache__/compressed_3DC_texture.cpython-312.pyc,, +OpenGL/raw/GLES2/AMD/__pycache__/compressed_ATC_texture.cpython-312.pyc,, +OpenGL/raw/GLES2/AMD/__pycache__/framebuffer_multisample_advanced.cpython-312.pyc,, +OpenGL/raw/GLES2/AMD/__pycache__/performance_monitor.cpython-312.pyc,, +OpenGL/raw/GLES2/AMD/__pycache__/program_binary_Z400.cpython-312.pyc,, +OpenGL/raw/GLES2/AMD/compressed_3DC_texture.py,sha256=LFRqT3ajbAnZhtypO7v_NDIS4QcrNXqAwCbqrSqT1X0,612 +OpenGL/raw/GLES2/AMD/compressed_ATC_texture.py,sha256=dkdqLpETQGqL38HfHAyxVRsDYOQitBh98xsZCgwmQrU,733 +OpenGL/raw/GLES2/AMD/framebuffer_multisample_advanced.py,sha256=YFqOzucPyezW007_b29PQtoq-PBWgX5Lv9aoOCvvBUA,1518 +OpenGL/raw/GLES2/AMD/performance_monitor.py,sha256=wBqVSuSxxd9x_gOMJBOul08EdImgHptI_YN_I9UHfMs,2409 +OpenGL/raw/GLES2/AMD/program_binary_Z400.py,sha256=qhPyyTlWqA8ETRvlDnY3NV5-mbWq1TklQbarwUhtR58,577 +OpenGL/raw/GLES2/ANDROID/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/raw/GLES2/ANDROID/__pycache__/__init__.cpython-312.pyc,, +OpenGL/raw/GLES2/ANDROID/__pycache__/extension_pack_es31a.cpython-312.pyc,, +OpenGL/raw/GLES2/ANDROID/extension_pack_es31a.py,sha256=Y8EUH6PnsB2EiOOEHbwNRsmktw9BTyId6maPYLTvN5c,537 +OpenGL/raw/GLES2/ANGLE/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/raw/GLES2/ANGLE/__pycache__/__init__.cpython-312.pyc,, +OpenGL/raw/GLES2/ANGLE/__pycache__/depth_texture.cpython-312.pyc,, +OpenGL/raw/GLES2/ANGLE/__pycache__/framebuffer_blit.cpython-312.pyc,, +OpenGL/raw/GLES2/ANGLE/__pycache__/framebuffer_multisample.cpython-312.pyc,, +OpenGL/raw/GLES2/ANGLE/__pycache__/instanced_arrays.cpython-312.pyc,, +OpenGL/raw/GLES2/ANGLE/__pycache__/pack_reverse_row_order.cpython-312.pyc,, +OpenGL/raw/GLES2/ANGLE/__pycache__/program_binary.cpython-312.pyc,, +OpenGL/raw/GLES2/ANGLE/__pycache__/texture_compression_dxt3.cpython-312.pyc,, +OpenGL/raw/GLES2/ANGLE/__pycache__/texture_compression_dxt5.cpython-312.pyc,, +OpenGL/raw/GLES2/ANGLE/__pycache__/texture_usage.cpython-312.pyc,, +OpenGL/raw/GLES2/ANGLE/__pycache__/translated_shader_source.cpython-312.pyc,, +OpenGL/raw/GLES2/ANGLE/depth_texture.py,sha256=xD9vEyoMOj6PbfkkDuqkldmJ3nBuY2N9T18ygN_jtNU,960 +OpenGL/raw/GLES2/ANGLE/framebuffer_blit.py,sha256=bnOJxaeKCBKhg-h6cqaobDkhsajXai-Mf79yYDs-nG8,1034 +OpenGL/raw/GLES2/ANGLE/framebuffer_multisample.py,sha256=0XOrz7DticPkpOvPu_Zo7yIUXeZeEjL_dysx9c4jNmw,935 +OpenGL/raw/GLES2/ANGLE/instanced_arrays.py,sha256=veuCZDMbjYkrQzO0ewsxM4zpUitMAhbxcESHOGJKZno,987 +OpenGL/raw/GLES2/ANGLE/pack_reverse_row_order.py,sha256=WDTnzGLsxki0jtMO4umkrtOKD8-oZ7bo_2nr10GNc_0,613 +OpenGL/raw/GLES2/ANGLE/program_binary.py,sha256=IHwUHFcL7LblYDU3uFYI1oIK3dmVajhnxGx2OMePx4k,581 +OpenGL/raw/GLES2/ANGLE/texture_compression_dxt3.py,sha256=RPAea9ygS1Cpb62RHWnUlSlntK40uBd5q7FAgIwwL20,623 +OpenGL/raw/GLES2/ANGLE/texture_compression_dxt5.py,sha256=02dGmwb8F-FVXP7nzr45heZf9M5k0yD_shVmD0Z_WGM,623 +OpenGL/raw/GLES2/ANGLE/texture_usage.py,sha256=6AYPrhbX4f1UBHd63kG0IovPXUve1nsWM4MTTyXP9vk,654 +OpenGL/raw/GLES2/ANGLE/translated_shader_source.py,sha256=RqEv0DKuZpP8VkXdrDYAm137lWe1rYFahGM4_tVeCyc,788 +OpenGL/raw/GLES2/APPLE/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/raw/GLES2/APPLE/__pycache__/__init__.cpython-312.pyc,, +OpenGL/raw/GLES2/APPLE/__pycache__/clip_distance.cpython-312.pyc,, +OpenGL/raw/GLES2/APPLE/__pycache__/color_buffer_packed_float.cpython-312.pyc,, +OpenGL/raw/GLES2/APPLE/__pycache__/copy_texture_levels.cpython-312.pyc,, +OpenGL/raw/GLES2/APPLE/__pycache__/framebuffer_multisample.cpython-312.pyc,, +OpenGL/raw/GLES2/APPLE/__pycache__/rgb_422.cpython-312.pyc,, +OpenGL/raw/GLES2/APPLE/__pycache__/sync.cpython-312.pyc,, +OpenGL/raw/GLES2/APPLE/__pycache__/texture_format_BGRA8888.cpython-312.pyc,, +OpenGL/raw/GLES2/APPLE/__pycache__/texture_max_level.cpython-312.pyc,, +OpenGL/raw/GLES2/APPLE/__pycache__/texture_packed_float.cpython-312.pyc,, +OpenGL/raw/GLES2/APPLE/clip_distance.py,sha256=tSyyJA19SivjOgf91rFcZSm9eP50utIe2mL_VrYUi8g,1075 +OpenGL/raw/GLES2/APPLE/color_buffer_packed_float.py,sha256=UPbDGcHACkGr-ErLeDUVefJ2leogZ5eaYqRqIWn5bXI,543 +OpenGL/raw/GLES2/APPLE/copy_texture_levels.py,sha256=sxwn6Sw0glZqrts4UwtlIQTCYzBxOXFPHJT_NWsgT5Y,695 +OpenGL/raw/GLES2/APPLE/framebuffer_multisample.py,sha256=uyqdR63bHU--H_qw42cUvyAiQ2xOm9lbURd1mV31WxA,1296 +OpenGL/raw/GLES2/APPLE/rgb_422.py,sha256=Y_WMyUpo_P_jjdVZYCTsSb5m3kPUIle13owgVe4I3co,754 +OpenGL/raw/GLES2/APPLE/sync.py,sha256=ooCRqAVg6kCQqDK72kjtFuA4C05lCVqJtUWs66ZAiHI,2204 +OpenGL/raw/GLES2/APPLE/texture_format_BGRA8888.py,sha256=h4PhhcWxhqjuo8nNaQuU5BoKwRih0GI8DzTSE0kJprI,614 +OpenGL/raw/GLES2/APPLE/texture_max_level.py,sha256=dxiZuakCokZxiUp657nL7QggPOQuvPmKAbRt-zWRYUw,593 +OpenGL/raw/GLES2/APPLE/texture_packed_float.py,sha256=QYp5GCpdLZiIbHWqaNjADMvqvBSXwDHAjFGTRjO4cNo,810 +OpenGL/raw/GLES2/ARM/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/raw/GLES2/ARM/__pycache__/__init__.cpython-312.pyc,, +OpenGL/raw/GLES2/ARM/__pycache__/mali_program_binary.cpython-312.pyc,, +OpenGL/raw/GLES2/ARM/__pycache__/mali_shader_binary.cpython-312.pyc,, +OpenGL/raw/GLES2/ARM/__pycache__/rgba8.cpython-312.pyc,, +OpenGL/raw/GLES2/ARM/__pycache__/shader_framebuffer_fetch.cpython-312.pyc,, +OpenGL/raw/GLES2/ARM/__pycache__/shader_framebuffer_fetch_depth_stencil.cpython-312.pyc,, +OpenGL/raw/GLES2/ARM/mali_program_binary.py,sha256=od_9FarBA540_4NseJLWkSiWQZrSqjE420TFiwRIxso,593 +OpenGL/raw/GLES2/ARM/mali_shader_binary.py,sha256=6zRM0hISICsRE-xzzGYqib7orw4cHa0b5aWehUH3uY4,589 +OpenGL/raw/GLES2/ARM/rgba8.py,sha256=U7WZlbUl0tpErHyAcPhZPn_ofiel6KyBHCsCJaSjdV8,499 +OpenGL/raw/GLES2/ARM/shader_framebuffer_fetch.py,sha256=jBhq3zxbRIgNU-KV-n4E_F3MFdDrkV0MDEVODRF9uHw,700 +OpenGL/raw/GLES2/ARM/shader_framebuffer_fetch_depth_stencil.py,sha256=0QGb3ivCWLAmKPQVVOEM0G4R9Exef3AxxWKyl6XaS_Q,565 +OpenGL/raw/GLES2/DMP/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/raw/GLES2/DMP/__pycache__/__init__.cpython-312.pyc,, +OpenGL/raw/GLES2/DMP/__pycache__/program_binary.cpython-312.pyc,, +OpenGL/raw/GLES2/DMP/__pycache__/shader_binary.cpython-312.pyc,, +OpenGL/raw/GLES2/DMP/program_binary.py,sha256=mQWd5nD2UPUxXlATHBJPkAfuR57y-a07C5YD3MjogzU,727 +OpenGL/raw/GLES2/DMP/shader_binary.py,sha256=b6Tj9E7wc_J9Zx4tEWUvHPC_DAY6ZTX7LeZ7i9maFGo,569 +OpenGL/raw/GLES2/ES/VERSION_3_2.py,sha256=EyAG0nXbXZDXZNhBrTpClWLGM1NLjpNS07JfYX83riA,20561 +OpenGL/raw/GLES2/ES/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/raw/GLES2/ES/__pycache__/VERSION_3_2.cpython-312.pyc,, +OpenGL/raw/GLES2/ES/__pycache__/__init__.cpython-312.pyc,, +OpenGL/raw/GLES2/EXT/EGL_image_array.py,sha256=mVEnJRGLZdhWs9PQJkxV7l7VlCdxxH-KSjvKhGxpeq0,519 +OpenGL/raw/GLES2/EXT/EGL_image_storage.py,sha256=nR6mRdtWqvkCOdGysJ2FJxeKw2bKK0LrxM4of64z2xg,791 +OpenGL/raw/GLES2/EXT/YUV_target.py,sha256=jmQald7eNm7422E-7yk5Ooxzq90ErLuxDuuguqRLaNM,806 +OpenGL/raw/GLES2/EXT/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/raw/GLES2/EXT/__pycache__/EGL_image_array.cpython-312.pyc,, +OpenGL/raw/GLES2/EXT/__pycache__/EGL_image_storage.cpython-312.pyc,, +OpenGL/raw/GLES2/EXT/__pycache__/YUV_target.cpython-312.pyc,, +OpenGL/raw/GLES2/EXT/__pycache__/__init__.cpython-312.pyc,, +OpenGL/raw/GLES2/EXT/__pycache__/base_instance.cpython-312.pyc,, +OpenGL/raw/GLES2/EXT/__pycache__/blend_func_extended.cpython-312.pyc,, +OpenGL/raw/GLES2/EXT/__pycache__/blend_minmax.cpython-312.pyc,, +OpenGL/raw/GLES2/EXT/__pycache__/buffer_storage.cpython-312.pyc,, +OpenGL/raw/GLES2/EXT/__pycache__/clear_texture.cpython-312.pyc,, +OpenGL/raw/GLES2/EXT/__pycache__/clip_control.cpython-312.pyc,, +OpenGL/raw/GLES2/EXT/__pycache__/clip_cull_distance.cpython-312.pyc,, +OpenGL/raw/GLES2/EXT/__pycache__/color_buffer_float.cpython-312.pyc,, +OpenGL/raw/GLES2/EXT/__pycache__/color_buffer_half_float.cpython-312.pyc,, +OpenGL/raw/GLES2/EXT/__pycache__/conservative_depth.cpython-312.pyc,, +OpenGL/raw/GLES2/EXT/__pycache__/copy_image.cpython-312.pyc,, +OpenGL/raw/GLES2/EXT/__pycache__/debug_label.cpython-312.pyc,, +OpenGL/raw/GLES2/EXT/__pycache__/debug_marker.cpython-312.pyc,, +OpenGL/raw/GLES2/EXT/__pycache__/depth_clamp.cpython-312.pyc,, +OpenGL/raw/GLES2/EXT/__pycache__/discard_framebuffer.cpython-312.pyc,, +OpenGL/raw/GLES2/EXT/__pycache__/disjoint_timer_query.cpython-312.pyc,, +OpenGL/raw/GLES2/EXT/__pycache__/draw_buffers.cpython-312.pyc,, +OpenGL/raw/GLES2/EXT/__pycache__/draw_buffers_indexed.cpython-312.pyc,, +OpenGL/raw/GLES2/EXT/__pycache__/draw_elements_base_vertex.cpython-312.pyc,, +OpenGL/raw/GLES2/EXT/__pycache__/draw_instanced.cpython-312.pyc,, +OpenGL/raw/GLES2/EXT/__pycache__/draw_transform_feedback.cpython-312.pyc,, +OpenGL/raw/GLES2/EXT/__pycache__/external_buffer.cpython-312.pyc,, +OpenGL/raw/GLES2/EXT/__pycache__/float_blend.cpython-312.pyc,, +OpenGL/raw/GLES2/EXT/__pycache__/geometry_point_size.cpython-312.pyc,, +OpenGL/raw/GLES2/EXT/__pycache__/geometry_shader.cpython-312.pyc,, +OpenGL/raw/GLES2/EXT/__pycache__/gpu_shader5.cpython-312.pyc,, +OpenGL/raw/GLES2/EXT/__pycache__/instanced_arrays.cpython-312.pyc,, +OpenGL/raw/GLES2/EXT/__pycache__/map_buffer_range.cpython-312.pyc,, +OpenGL/raw/GLES2/EXT/__pycache__/memory_object.cpython-312.pyc,, +OpenGL/raw/GLES2/EXT/__pycache__/memory_object_fd.cpython-312.pyc,, +OpenGL/raw/GLES2/EXT/__pycache__/memory_object_win32.cpython-312.pyc,, +OpenGL/raw/GLES2/EXT/__pycache__/multi_draw_arrays.cpython-312.pyc,, +OpenGL/raw/GLES2/EXT/__pycache__/multi_draw_indirect.cpython-312.pyc,, +OpenGL/raw/GLES2/EXT/__pycache__/multisampled_compatibility.cpython-312.pyc,, +OpenGL/raw/GLES2/EXT/__pycache__/multisampled_render_to_texture.cpython-312.pyc,, +OpenGL/raw/GLES2/EXT/__pycache__/multiview_draw_buffers.cpython-312.pyc,, +OpenGL/raw/GLES2/EXT/__pycache__/multiview_tessellation_geometry_shader.cpython-312.pyc,, +OpenGL/raw/GLES2/EXT/__pycache__/multiview_texture_multisample.cpython-312.pyc,, +OpenGL/raw/GLES2/EXT/__pycache__/multiview_timer_query.cpython-312.pyc,, +OpenGL/raw/GLES2/EXT/__pycache__/occlusion_query_boolean.cpython-312.pyc,, +OpenGL/raw/GLES2/EXT/__pycache__/polygon_offset_clamp.cpython-312.pyc,, +OpenGL/raw/GLES2/EXT/__pycache__/post_depth_coverage.cpython-312.pyc,, +OpenGL/raw/GLES2/EXT/__pycache__/primitive_bounding_box.cpython-312.pyc,, +OpenGL/raw/GLES2/EXT/__pycache__/protected_textures.cpython-312.pyc,, +OpenGL/raw/GLES2/EXT/__pycache__/pvrtc_sRGB.cpython-312.pyc,, +OpenGL/raw/GLES2/EXT/__pycache__/raster_multisample.cpython-312.pyc,, +OpenGL/raw/GLES2/EXT/__pycache__/read_format_bgra.cpython-312.pyc,, +OpenGL/raw/GLES2/EXT/__pycache__/render_snorm.cpython-312.pyc,, +OpenGL/raw/GLES2/EXT/__pycache__/robustness.cpython-312.pyc,, +OpenGL/raw/GLES2/EXT/__pycache__/sRGB.cpython-312.pyc,, +OpenGL/raw/GLES2/EXT/__pycache__/sRGB_write_control.cpython-312.pyc,, +OpenGL/raw/GLES2/EXT/__pycache__/semaphore.cpython-312.pyc,, +OpenGL/raw/GLES2/EXT/__pycache__/semaphore_fd.cpython-312.pyc,, +OpenGL/raw/GLES2/EXT/__pycache__/semaphore_win32.cpython-312.pyc,, +OpenGL/raw/GLES2/EXT/__pycache__/separate_shader_objects.cpython-312.pyc,, +OpenGL/raw/GLES2/EXT/__pycache__/shader_framebuffer_fetch.cpython-312.pyc,, +OpenGL/raw/GLES2/EXT/__pycache__/shader_framebuffer_fetch_non_coherent.cpython-312.pyc,, +OpenGL/raw/GLES2/EXT/__pycache__/shader_group_vote.cpython-312.pyc,, +OpenGL/raw/GLES2/EXT/__pycache__/shader_implicit_conversions.cpython-312.pyc,, +OpenGL/raw/GLES2/EXT/__pycache__/shader_integer_mix.cpython-312.pyc,, +OpenGL/raw/GLES2/EXT/__pycache__/shader_io_blocks.cpython-312.pyc,, +OpenGL/raw/GLES2/EXT/__pycache__/shader_non_constant_global_initializers.cpython-312.pyc,, +OpenGL/raw/GLES2/EXT/__pycache__/shader_pixel_local_storage.cpython-312.pyc,, +OpenGL/raw/GLES2/EXT/__pycache__/shader_pixel_local_storage2.cpython-312.pyc,, +OpenGL/raw/GLES2/EXT/__pycache__/shader_texture_lod.cpython-312.pyc,, +OpenGL/raw/GLES2/EXT/__pycache__/shadow_samplers.cpython-312.pyc,, +OpenGL/raw/GLES2/EXT/__pycache__/sparse_texture.cpython-312.pyc,, +OpenGL/raw/GLES2/EXT/__pycache__/sparse_texture2.cpython-312.pyc,, +OpenGL/raw/GLES2/EXT/__pycache__/tessellation_point_size.cpython-312.pyc,, +OpenGL/raw/GLES2/EXT/__pycache__/tessellation_shader.cpython-312.pyc,, +OpenGL/raw/GLES2/EXT/__pycache__/texture_border_clamp.cpython-312.pyc,, +OpenGL/raw/GLES2/EXT/__pycache__/texture_buffer.cpython-312.pyc,, +OpenGL/raw/GLES2/EXT/__pycache__/texture_compression_astc_decode_mode.cpython-312.pyc,, +OpenGL/raw/GLES2/EXT/__pycache__/texture_compression_bptc.cpython-312.pyc,, +OpenGL/raw/GLES2/EXT/__pycache__/texture_compression_dxt1.cpython-312.pyc,, +OpenGL/raw/GLES2/EXT/__pycache__/texture_compression_rgtc.cpython-312.pyc,, +OpenGL/raw/GLES2/EXT/__pycache__/texture_compression_s3tc.cpython-312.pyc,, +OpenGL/raw/GLES2/EXT/__pycache__/texture_compression_s3tc_srgb.cpython-312.pyc,, +OpenGL/raw/GLES2/EXT/__pycache__/texture_cube_map_array.cpython-312.pyc,, +OpenGL/raw/GLES2/EXT/__pycache__/texture_filter_anisotropic.cpython-312.pyc,, +OpenGL/raw/GLES2/EXT/__pycache__/texture_filter_minmax.cpython-312.pyc,, +OpenGL/raw/GLES2/EXT/__pycache__/texture_format_BGRA8888.cpython-312.pyc,, +OpenGL/raw/GLES2/EXT/__pycache__/texture_format_sRGB_override.cpython-312.pyc,, +OpenGL/raw/GLES2/EXT/__pycache__/texture_mirror_clamp_to_edge.cpython-312.pyc,, +OpenGL/raw/GLES2/EXT/__pycache__/texture_norm16.cpython-312.pyc,, +OpenGL/raw/GLES2/EXT/__pycache__/texture_query_lod.cpython-312.pyc,, +OpenGL/raw/GLES2/EXT/__pycache__/texture_rg.cpython-312.pyc,, +OpenGL/raw/GLES2/EXT/__pycache__/texture_sRGB_R8.cpython-312.pyc,, +OpenGL/raw/GLES2/EXT/__pycache__/texture_sRGB_RG8.cpython-312.pyc,, +OpenGL/raw/GLES2/EXT/__pycache__/texture_sRGB_decode.cpython-312.pyc,, +OpenGL/raw/GLES2/EXT/__pycache__/texture_shadow_lod.cpython-312.pyc,, +OpenGL/raw/GLES2/EXT/__pycache__/texture_storage.cpython-312.pyc,, +OpenGL/raw/GLES2/EXT/__pycache__/texture_type_2_10_10_10_REV.cpython-312.pyc,, +OpenGL/raw/GLES2/EXT/__pycache__/texture_view.cpython-312.pyc,, +OpenGL/raw/GLES2/EXT/__pycache__/unpack_subimage.cpython-312.pyc,, +OpenGL/raw/GLES2/EXT/__pycache__/win32_keyed_mutex.cpython-312.pyc,, +OpenGL/raw/GLES2/EXT/__pycache__/window_rectangles.cpython-312.pyc,, +OpenGL/raw/GLES2/EXT/base_instance.py,sha256=9fByow5hP4wTMUPTwZ0rgBOCwif3IIoZFyQvzKFTXE0,1098 +OpenGL/raw/GLES2/EXT/blend_func_extended.py,sha256=2R-tWY8N-O1JZj55shn8a7TASXJC-SdIxcZGGoxFXpk,1473 +OpenGL/raw/GLES2/EXT/blend_minmax.py,sha256=lTjRZfzo0mkirPNPaAWYsqret54D2jkjZmUC4qEcy2s,748 +OpenGL/raw/GLES2/EXT/buffer_storage.py,sha256=kXpoGq3okGubn4EBUrjnEI4Pd59NhTz2mzx3U4J_kfI,1237 +OpenGL/raw/GLES2/EXT/clear_texture.py,sha256=vMvkGyLESN-GtuIdpmqRxUtKapr_AQqkZfJZaMmlsy4,904 +OpenGL/raw/GLES2/EXT/clip_control.py,sha256=U5NoDRfQpU3-WjcoovYZMc4p7stySu2RgB-tnDYHTqo,919 +OpenGL/raw/GLES2/EXT/clip_cull_distance.py,sha256=AJ2r_PjYTFiERSej01xeTUmERCPkx7_6c2t3liND8Vw,1211 +OpenGL/raw/GLES2/EXT/color_buffer_float.py,sha256=mB_qpzsa6VjLCjl25nPrK5iW8b9cfIjNuWvNWeTETl8,525 +OpenGL/raw/GLES2/EXT/color_buffer_half_float.py,sha256=YCyuF10HiHRZCnJjU-xxlHHdPEybGvX463qbw2_PZps,864 +OpenGL/raw/GLES2/EXT/conservative_depth.py,sha256=DX0k11arNDVNsOf8tU9_uc6Q-WHZ9vhhFuZIR3ptJWU,525 +OpenGL/raw/GLES2/EXT/copy_image.py,sha256=zmzqoVcwPiq7Fu1hc9iQeAN-zBSeBr8g5HA1RhnO7Is,832 +OpenGL/raw/GLES2/EXT/debug_label.py,sha256=wnuCwL80c-aAyxCcQpp-dstOmDxRiskYppx_DaznTGo,1244 +OpenGL/raw/GLES2/EXT/debug_marker.py,sha256=NA0cAtEw2M7CnLX4igKwv9qWgnHZPyEnyhabpPk1nlU,758 +OpenGL/raw/GLES2/EXT/depth_clamp.py,sha256=6dzyQj9m9acSRft1AaF8bprFk5Hd-0i_Ftv5ndXkxhY,561 +OpenGL/raw/GLES2/EXT/discard_framebuffer.py,sha256=AJGuu6uPpEPVxgfFv_JxKacW1SwrOMiCU7oSpG3PtR0,776 +OpenGL/raw/GLES2/EXT/disjoint_timer_query.py,sha256=lTtlD3ZtoAEm7nmPmTKKCHXIv-9f-B3EmHj0xP513t8,1931 +OpenGL/raw/GLES2/EXT/draw_buffers.py,sha256=4rxrnwEAu6UjN2KLt2s0Ls4BobhHO9h0C3z8AJnAnoo,2608 +OpenGL/raw/GLES2/EXT/draw_buffers_indexed.py,sha256=zdlsz5WlQfkBtyn9matJQ2NQePGgC7T1Lw6-mejEW6M,2659 +OpenGL/raw/GLES2/EXT/draw_elements_base_vertex.py,sha256=bdXDxqzV7EfVw3VXEwQVVzmM69lS7ts_D_yAx1xCO70,1269 +OpenGL/raw/GLES2/EXT/draw_instanced.py,sha256=DKsHs9skh7G__AEKhIncnOJJ6rdBlhlnrUB0XDJPpYs,796 +OpenGL/raw/GLES2/EXT/draw_transform_feedback.py,sha256=44ouk8PowFJPYMfES6m0H4UnpJ2WhUUZ4E5MLN6bwPI,743 +OpenGL/raw/GLES2/EXT/external_buffer.py,sha256=Bw0RATyrI7cHDSoPOxzYSMl7g_p_KuENmwQR3kn3ldc,871 +OpenGL/raw/GLES2/EXT/float_blend.py,sha256=tbdQ1PLhy5bp0jlfaArUSHbWcIt10V9Jj49h2vNugzk,511 +OpenGL/raw/GLES2/EXT/geometry_point_size.py,sha256=o4d6O7CucYx0W8AnIW6ph-Q61YTq9OtFuLHWcKRHFvU,527 +OpenGL/raw/GLES2/EXT/geometry_shader.py,sha256=0KhsgVw_pxV9RaTwZjFqvsH1gWrNB5-t1pzZ-os1uzI,3355 +OpenGL/raw/GLES2/EXT/gpu_shader5.py,sha256=BWe0h0BJo8rgpRg-wZpGWirbGvcHfAQBHhXDZ0DsL9U,511 +OpenGL/raw/GLES2/EXT/instanced_arrays.py,sha256=qaH-KMzPTK19Hr7JcOPTXWRtUR_FAkDZfzevoXlVxuY,973 +OpenGL/raw/GLES2/EXT/map_buffer_range.py,sha256=_i3BxjN4NaV1foC-RkRNKL82jUiJcEHWAhGbAsSL1dU,1190 +OpenGL/raw/GLES2/EXT/memory_object.py,sha256=P-eC3cVFZYVnLIh7zp_6JHfpALHfvHKu717NrUiRjS4,4298 +OpenGL/raw/GLES2/EXT/memory_object_fd.py,sha256=zTYJ_Qnshpk-5ldMU1TnnoIM4ljqJxNumUOapYxjdfA,711 +OpenGL/raw/GLES2/EXT/memory_object_win32.py,sha256=sbWrnMqiFckTsIeUIVduYzFOMqop9b3rroQN92HDmus,1437 +OpenGL/raw/GLES2/EXT/multi_draw_arrays.py,sha256=T6N29U7D0Djs41MIw7DxkdB8RH9DCOx7ZjXQQnxrRxc,822 +OpenGL/raw/GLES2/EXT/multi_draw_indirect.py,sha256=h52N0eRgpJZNe8OdRfz8dN5aa5416LM-uZFuyzT28II,826 +OpenGL/raw/GLES2/EXT/multisampled_compatibility.py,sha256=rDHyQNioJ4plPBhl8VCpNRSZeH-42aTN-yZchaSfyyw,658 +OpenGL/raw/GLES2/EXT/multisampled_render_to_texture.py,sha256=cHZUKqocZsMlmYrwTXRUpwLi4nOL5tq9qaCxREP3y34,1219 +OpenGL/raw/GLES2/EXT/multiview_draw_buffers.py,sha256=Yf3wSe6v1imzGRtR03BfRuu0kXv3Vwks6sd0rLT6kbY,1123 +OpenGL/raw/GLES2/EXT/multiview_tessellation_geometry_shader.py,sha256=0z-bA1w5SFhtCgNX6YMhWu5IdNb2UeE-Oa3Jlyx8OpE,565 +OpenGL/raw/GLES2/EXT/multiview_texture_multisample.py,sha256=9RHYwUW9cJiH3cuGmNkTWoJNug-HpgQdCqy8dYIOV3U,547 +OpenGL/raw/GLES2/EXT/multiview_timer_query.py,sha256=iJjZ9xuIRCIu51P_DwvfwTuwjoD_4tvlUE3LK_020VI,531 +OpenGL/raw/GLES2/EXT/occlusion_query_boolean.py,sha256=Gx_wT9l2LzGfDii1IDv3lcYyCOkxfgVGtyFvSEjC7TQ,1461 +OpenGL/raw/GLES2/EXT/polygon_offset_clamp.py,sha256=7x4Ze7jFmMNIZeB-f1DFqJNnydBGwS4mfWRjDLkTwlY,705 +OpenGL/raw/GLES2/EXT/post_depth_coverage.py,sha256=MKAyJoZ05zGPlDwIFRxxxRauX0Fvb7__u2iEhFSPkms,527 +OpenGL/raw/GLES2/EXT/primitive_bounding_box.py,sha256=TyC4nuI-aiaDYwylKsyMlHEj2OdX9nWdffjrarXrCZ0,796 +OpenGL/raw/GLES2/EXT/protected_textures.py,sha256=nSxYf4Ntv7FqRFKwQjCfJXVW-eg6yjAlAIIEm_tT32k,688 +OpenGL/raw/GLES2/EXT/pvrtc_sRGB.py,sha256=6MTGbL99m2_mC90dFjuN2UgSSYmH7Xrta1oK29_rEOI,1066 +OpenGL/raw/GLES2/EXT/raster_multisample.py,sha256=0amec7S2F9KsNBuCKXDnHJ7EM7p8VIsFUr4tGwIU-fM,1072 +OpenGL/raw/GLES2/EXT/read_format_bgra.py,sha256=ou4LKz4xC6O-iXQHYP488IPowr94V70vtaxlbjFUkJM,719 +OpenGL/raw/GLES2/EXT/render_snorm.py,sha256=o4neBthmbwO5pccL973zvjau9qrRAm7Hp_V_liLKg48,840 +OpenGL/raw/GLES2/EXT/robustness.py,sha256=mVdp30n7s_loTf3x-QSHtYEpfePJfmIHDDz5RsV_RZE,1563 +OpenGL/raw/GLES2/EXT/sRGB.py,sha256=c_uHCGQtG5elR1fO_e96Aqt3CAvP5DzRbtBg03JA6C0,738 +OpenGL/raw/GLES2/EXT/sRGB_write_control.py,sha256=AVJpZ4q4vdOCr1vw6_QMFnogQKyX38TXr5Vqzoyybyk,585 +OpenGL/raw/GLES2/EXT/semaphore.py,sha256=eMQJcoum1KDXUTvb3AvGWV1rSXz9OSRMT1dFx9mUqNk,2611 +OpenGL/raw/GLES2/EXT/semaphore_fd.py,sha256=opTfhFLGzW5KXcSSjgFWLa_ok2aMJ1TgLdzzixb2A-Q,691 +OpenGL/raw/GLES2/EXT/semaphore_win32.py,sha256=ryiLtjJXMcVcz-MY0gfGUUszm6JSYQ9OzHpNcz6wRLo,1223 +OpenGL/raw/GLES2/EXT/separate_shader_objects.py,sha256=bG-y9M_QQojcr4d8rDiw23x0VoYmi5ISOtaw3rfUhBg,7194 +OpenGL/raw/GLES2/EXT/shader_framebuffer_fetch.py,sha256=_UPw0Il_IqAaS50LDDa9yCyZ8UuGh4rxqwdW11-jF-k,629 +OpenGL/raw/GLES2/EXT/shader_framebuffer_fetch_non_coherent.py,sha256=GYjFavKm7kZAJ3bG46sRiHQo5plizQa3sqI4icA-6uM,715 +OpenGL/raw/GLES2/EXT/shader_group_vote.py,sha256=7HfPNZ8XhHBQA01mhdtGsUT6Im1m6SAGSnnGQm8ekZk,523 +OpenGL/raw/GLES2/EXT/shader_implicit_conversions.py,sha256=AWD5_YmPRLCIldqXDuFYhP8xg3l6zi9Jbz7cL1cEQ2M,543 +OpenGL/raw/GLES2/EXT/shader_integer_mix.py,sha256=2Pv-5eNsh_YqeRDgEYtuslXG4NYujcDpHQnHCUD-cDQ,525 +OpenGL/raw/GLES2/EXT/shader_io_blocks.py,sha256=Vv-fUnARe_y7WOwVbWKamkoK4uvfSTxuCyqJSBgCCUo,521 +OpenGL/raw/GLES2/EXT/shader_non_constant_global_initializers.py,sha256=aFiFG3MsJRQvYUcdrCrcAsHiN4QYRKyMfvfbbemOZ68,567 +OpenGL/raw/GLES2/EXT/shader_pixel_local_storage.py,sha256=TDm_9in1jmzOFps3nCItbvadh7mXE49p4fKsPjLDQOA,829 +OpenGL/raw/GLES2/EXT/shader_pixel_local_storage2.py,sha256=n4XNVLdWRJ5hi69WPX2_F3tcsucFnEIAYy0xl8h3VJ8,1238 +OpenGL/raw/GLES2/EXT/shader_texture_lod.py,sha256=UkzESjzzgaSqlR__zlZNHgUPaTqeHejNWSTUjoVuxbI,525 +OpenGL/raw/GLES2/EXT/shadow_samplers.py,sha256=G_DEETSVlrO6TrVFfPd-lzH1iR8R0h0G-2rrZC-9pN8,792 +OpenGL/raw/GLES2/EXT/sparse_texture.py,sha256=0aDK8ND8n4vnoFw9Ci6g8ayM-WjKR2zK2X4IFibbO_E,1814 +OpenGL/raw/GLES2/EXT/sparse_texture2.py,sha256=yLbO-QqvfG3SyyD_9EfXfaJaqUb0jJkbWm7LLuJL3lk,519 +OpenGL/raw/GLES2/EXT/tessellation_point_size.py,sha256=ooFgrBVmT2QBVAL_HgivM_xhiFVGsAx56erLpXxv9fc,535 +OpenGL/raw/GLES2/EXT/tessellation_shader.py,sha256=qpXAV0KqT03Rhp0ROsUTG_D5nbFKcZTkmAGbxn8-hkg,4392 +OpenGL/raw/GLES2/EXT/texture_border_clamp.py,sha256=ZwHp2eIg67DazDkrTO0CP2U-kQYNqbR_-Ef-YStZz5U,1581 +OpenGL/raw/GLES2/EXT/texture_buffer.py,sha256=7WP-BGgk2IJCORnr7gIrUCS23DF_8ouCca7_Hv2PKzc,1774 +OpenGL/raw/GLES2/EXT/texture_compression_astc_decode_mode.py,sha256=W7hhlzX5__dM3ZCcgU5PSDuflDxoK1wQFkTVOIsqPxs,647 +OpenGL/raw/GLES2/EXT/texture_compression_bptc.py,sha256=Or5kAzS5bqoV0_HdMIIsXutM17sfP9pRNfPOTcnOZds,900 +OpenGL/raw/GLES2/EXT/texture_compression_dxt1.py,sha256=E-vVc0Xk3oMjM4-6AZl_nUAyH_W_t19wcUOkxizRpuU,692 +OpenGL/raw/GLES2/EXT/texture_compression_rgtc.py,sha256=ToBXeIb56WZGSpGTeuREYLvbFVJlu9GltTTEMLepM5Q,864 +OpenGL/raw/GLES2/EXT/texture_compression_s3tc.py,sha256=Wij85wbONDGr39GM99PNq-zaRkfJysLegEEcXvay-po,850 +OpenGL/raw/GLES2/EXT/texture_compression_s3tc_srgb.py,sha256=iqaXKJS0NfI0iNvS2B4kH0zA6fCO2DfqCsrwSSHqXaQ,898 +OpenGL/raw/GLES2/EXT/texture_cube_map_array.py,sha256=NwuEZ0VMKwOdHCm-rN-uwievt8cYPreMMaAcbZs9PLQ,1275 +OpenGL/raw/GLES2/EXT/texture_filter_anisotropic.py,sha256=qY0iaBs72x_yS0eHAeI6zSG8GTBqpvlkKl8JV54VKBA,694 +OpenGL/raw/GLES2/EXT/texture_filter_minmax.py,sha256=I8dJUcS8uzmJiUPrCWdBgaSIQdazXBootsqz4neyNvA,664 +OpenGL/raw/GLES2/EXT/texture_format_BGRA8888.py,sha256=DWz4RcKdlfoU2zw0DtJMraOgxlFlKNdc06OlZU7CU7M,571 +OpenGL/raw/GLES2/EXT/texture_format_sRGB_override.py,sha256=u3OBKfWzcBjDqsi5SMOOr8Tx0I5Qcx3DzLP5ps2rZ4I,629 +OpenGL/raw/GLES2/EXT/texture_mirror_clamp_to_edge.py,sha256=JBfUEJVKI7xh0u_wDP5YhJ2f9IBZG2IP6isLR6Vq6po,613 +OpenGL/raw/GLES2/EXT/texture_norm16.py,sha256=NWje1Ps-wFEFeTbMlb8-leYHmzKjE9S3ke6bg-e8XdU,868 +OpenGL/raw/GLES2/EXT/texture_query_lod.py,sha256=YalbLUDP646OqiAVbm5A9b4VGpZ9Vslt4PD-9_fJmx4,523 +OpenGL/raw/GLES2/EXT/texture_rg.py,sha256=CdNtW-GCi8ru3gy98AeQB1ghXOnrvEB33jt4c5VRpOU,644 +OpenGL/raw/GLES2/EXT/texture_sRGB_R8.py,sha256=W3wWzBklwjlotyKVEmlBVSLCBVwz_K8DxHxcxSAAfNM,553 +OpenGL/raw/GLES2/EXT/texture_sRGB_RG8.py,sha256=1-wXZq0ZIUeqZDlRBJ8PYPSdOICMtNMvcu_aVc5-En0,557 +OpenGL/raw/GLES2/EXT/texture_sRGB_decode.py,sha256=p4gpcznjvq5Ux8gxPV5gGuJtgUOSBjHqC68ryzyJVeQ,685 +OpenGL/raw/GLES2/EXT/texture_shadow_lod.py,sha256=5uwS9__ll33VYaCy0qnCbbviDm7ca8D00obr80MNDqs,525 +OpenGL/raw/GLES2/EXT/texture_storage.py,sha256=Wv0LUmypuawc3Ipbc8XjrywMuhoNH--HNJ_1Ru7KR2Q,2539 +OpenGL/raw/GLES2/EXT/texture_type_2_10_10_10_REV.py,sha256=t1IaTTGTAMau4RUanDKBIJKofQ5qw0Q-O3qmjl9WFXI,625 +OpenGL/raw/GLES2/EXT/texture_view.py,sha256=jx7SYrBLjXcvUvQ8NVa-NJTukEw5h4w-kFBZ0n8afE8,1091 +OpenGL/raw/GLES2/EXT/unpack_subimage.py,sha256=z9xu-zCYImVaG_zFn5_8S_F94cSrj0QmDF_5wbcu7Ro,707 +OpenGL/raw/GLES2/EXT/win32_keyed_mutex.py,sha256=GXhMu4naxmuiVESR0LmFZvr_QQcQpqzxfYT5gdqhNuw,745 +OpenGL/raw/GLES2/EXT/window_rectangles.py,sha256=5dHbKiskZLkcyQ7YvnXB5mg1vrr87183ZyBPPmYFACM,997 +OpenGL/raw/GLES2/FJ/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/raw/GLES2/FJ/__pycache__/__init__.cpython-312.pyc,, +OpenGL/raw/GLES2/FJ/__pycache__/shader_binary_GCCSO.cpython-312.pyc,, +OpenGL/raw/GLES2/FJ/shader_binary_GCCSO.py,sha256=rcz9U1bCI1QCBzH8wd5ukZ7ix-8-E5g6JveE5XJLBao,589 +OpenGL/raw/GLES2/IMG/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/raw/GLES2/IMG/__pycache__/__init__.cpython-312.pyc,, +OpenGL/raw/GLES2/IMG/__pycache__/bindless_texture.cpython-312.pyc,, +OpenGL/raw/GLES2/IMG/__pycache__/framebuffer_downsample.cpython-312.pyc,, +OpenGL/raw/GLES2/IMG/__pycache__/multisampled_render_to_texture.cpython-312.pyc,, +OpenGL/raw/GLES2/IMG/__pycache__/program_binary.cpython-312.pyc,, +OpenGL/raw/GLES2/IMG/__pycache__/read_format.cpython-312.pyc,, +OpenGL/raw/GLES2/IMG/__pycache__/shader_binary.cpython-312.pyc,, +OpenGL/raw/GLES2/IMG/__pycache__/texture_compression_pvrtc.cpython-312.pyc,, +OpenGL/raw/GLES2/IMG/__pycache__/texture_compression_pvrtc2.cpython-312.pyc,, +OpenGL/raw/GLES2/IMG/__pycache__/texture_filter_cubic.cpython-312.pyc,, +OpenGL/raw/GLES2/IMG/bindless_texture.py,sha256=p2cuSuZJXDFZANtWM6MQa1eDd09-2z303U4a5lpSal8,1175 +OpenGL/raw/GLES2/IMG/framebuffer_downsample.py,sha256=AXUjNipr9xk9FFqBb2cidNxSbIeHCcYh2Ck539EhaoA,1283 +OpenGL/raw/GLES2/IMG/multisampled_render_to_texture.py,sha256=GYgDb0turuoCAAvdhYFpvN6PyimGITRTgaEenAvZYxg,1173 +OpenGL/raw/GLES2/IMG/program_binary.py,sha256=11hKVbVszIx6qmdDk2T1y6wE_RKQm5v8EEKVpKVs9D8,581 +OpenGL/raw/GLES2/IMG/read_format.py,sha256=408-ZJjGcZAdN33q37suI7f0cmqEfYvrbNtaKVnDtrg,628 +OpenGL/raw/GLES2/IMG/shader_binary.py,sha256=_eXOobKR98yimj5t9gV9OBjd2pB5sLsdH2cCFgJNXXM,563 +OpenGL/raw/GLES2/IMG/texture_compression_pvrtc.py,sha256=egMyILA3sCcIdunaGBchmv_kSSxc9sD07eUA4FRpe0A,874 +OpenGL/raw/GLES2/IMG/texture_compression_pvrtc2.py,sha256=2wfxisYsNw_YDYOKpjuYd4Wy3EssGElnjUJnJ_maLdk,710 +OpenGL/raw/GLES2/IMG/texture_filter_cubic.py,sha256=fb9hkbMYYPmr83hQuDtGT05Bo0WQDACQpfuUQk4s4ao,703 +OpenGL/raw/GLES2/INTEL/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/raw/GLES2/INTEL/__pycache__/__init__.cpython-312.pyc,, +OpenGL/raw/GLES2/INTEL/__pycache__/blackhole_render.cpython-312.pyc,, +OpenGL/raw/GLES2/INTEL/__pycache__/conservative_rasterization.cpython-312.pyc,, +OpenGL/raw/GLES2/INTEL/__pycache__/framebuffer_CMAA.cpython-312.pyc,, +OpenGL/raw/GLES2/INTEL/__pycache__/performance_query.cpython-312.pyc,, +OpenGL/raw/GLES2/INTEL/blackhole_render.py,sha256=h4qltRKVjBKKGwcXUGHnbYLsUzSRf8F7MonfGpnsWJY,589 +OpenGL/raw/GLES2/INTEL/conservative_rasterization.py,sha256=-rnrcQ6FAM_BubA6EojzsmDNVt17T_KOffjme7YWliM,629 +OpenGL/raw/GLES2/INTEL/framebuffer_CMAA.py,sha256=zs_teHU3ay2epEBUPDZYHiuy-93sZD5s993bvKHNGug,594 +OpenGL/raw/GLES2/INTEL/performance_query.py,sha256=Xsq44uZhLyF__nqLHfu7TAw3QrqD1PwWTgIH4ib385o,3696 +OpenGL/raw/GLES2/KHR/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/raw/GLES2/KHR/__pycache__/__init__.cpython-312.pyc,, +OpenGL/raw/GLES2/KHR/__pycache__/blend_equation_advanced.cpython-312.pyc,, +OpenGL/raw/GLES2/KHR/__pycache__/blend_equation_advanced_coherent.cpython-312.pyc,, +OpenGL/raw/GLES2/KHR/__pycache__/context_flush_control.cpython-312.pyc,, +OpenGL/raw/GLES2/KHR/__pycache__/debug.cpython-312.pyc,, +OpenGL/raw/GLES2/KHR/__pycache__/no_error.cpython-312.pyc,, +OpenGL/raw/GLES2/KHR/__pycache__/parallel_shader_compile.cpython-312.pyc,, +OpenGL/raw/GLES2/KHR/__pycache__/robust_buffer_access_behavior.cpython-312.pyc,, +OpenGL/raw/GLES2/KHR/__pycache__/robustness.cpython-312.pyc,, +OpenGL/raw/GLES2/KHR/__pycache__/shader_subgroup.cpython-312.pyc,, +OpenGL/raw/GLES2/KHR/__pycache__/texture_compression_astc_hdr.cpython-312.pyc,, +OpenGL/raw/GLES2/KHR/__pycache__/texture_compression_astc_ldr.cpython-312.pyc,, +OpenGL/raw/GLES2/KHR/__pycache__/texture_compression_astc_sliced_3d.cpython-312.pyc,, +OpenGL/raw/GLES2/KHR/blend_equation_advanced.py,sha256=-iWSQBNz-iqASWo2x7yrHhlC1NsBljGJAJyOco12Wsc,1286 +OpenGL/raw/GLES2/KHR/blend_equation_advanced_coherent.py,sha256=vMVFcD5zPq1iXet6qq9Nq2FVhE3_6olrf6Y0uVxhkwE,627 +OpenGL/raw/GLES2/KHR/context_flush_control.py,sha256=nlGwQ0PWBhRgMzVx6YrwoFx3DlgFu-Mc5JGotfn1Va8,894 +OpenGL/raw/GLES2/KHR/debug.py,sha256=-xM5E-MHloDFHrPKRNcBgs6-Ejiszrce0t7cK3KyDqE,8666 +OpenGL/raw/GLES2/KHR/no_error.py,sha256=7KlLqIPsdWRFT-QJsEYEklpDJ8VBtHRCRW-OoBRI3Mc,587 +OpenGL/raw/GLES2/KHR/parallel_shader_compile.py,sha256=j16f-inLaSO7x0NMlUNpAVQFDJ2vZST9DqeXHuL1whE,756 +OpenGL/raw/GLES2/KHR/robust_buffer_access_behavior.py,sha256=kqmAAAvU5PkinV0McCefoNK2hWhUnWwWLhPPTzcYaeU,547 +OpenGL/raw/GLES2/KHR/robustness.py,sha256=H70bFO05YLTaHLFdl3ESjowecK5ZXw6lAc7R3p7ZHa4,2914 +OpenGL/raw/GLES2/KHR/shader_subgroup.py,sha256=P2V2CeS07eOVNYJ_JQpkbTkElJ1L1nJmOPfHT8Jq43I,1534 +OpenGL/raw/GLES2/KHR/texture_compression_astc_hdr.py,sha256=4LO-Z9Hd8zr9jRKsua6U0C5xndd4q6cdkavstz0b-WU,2960 +OpenGL/raw/GLES2/KHR/texture_compression_astc_ldr.py,sha256=LnpGmDCdNG9DGp2O-vUpCMkr1wAlAQuW7Aq_WEV3RUA,2960 +OpenGL/raw/GLES2/KHR/texture_compression_astc_sliced_3d.py,sha256=6WLNkawkHwqWDdUfgxcO_6euCJPwEOoZQuLbSLlZDNc,557 +OpenGL/raw/GLES2/MESA/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/raw/GLES2/MESA/__pycache__/__init__.cpython-312.pyc,, +OpenGL/raw/GLES2/MESA/__pycache__/framebuffer_flip_y.cpython-312.pyc,, +OpenGL/raw/GLES2/MESA/__pycache__/program_binary_formats.cpython-312.pyc,, +OpenGL/raw/GLES2/MESA/__pycache__/shader_integer_functions.cpython-312.pyc,, +OpenGL/raw/GLES2/MESA/framebuffer_flip_y.py,sha256=vpKhuGzOwsxPL72TdzGefH0rltvENfvvimVJxljLel4,823 +OpenGL/raw/GLES2/MESA/program_binary_formats.py,sha256=skavMgxopGY1dzS1yFPXat7HKuuPTIT1yYWUaCcGf8g,607 +OpenGL/raw/GLES2/MESA/shader_integer_functions.py,sha256=_nSROelzqi5malkjeh1a1U3n0LRLzCF-rBdnylCQ5FI,539 +OpenGL/raw/GLES2/NV/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/raw/GLES2/NV/__pycache__/__init__.cpython-312.pyc,, +OpenGL/raw/GLES2/NV/__pycache__/bindless_texture.cpython-312.pyc,, +OpenGL/raw/GLES2/NV/__pycache__/blend_equation_advanced.cpython-312.pyc,, +OpenGL/raw/GLES2/NV/__pycache__/blend_equation_advanced_coherent.cpython-312.pyc,, +OpenGL/raw/GLES2/NV/__pycache__/blend_minmax_factor.cpython-312.pyc,, +OpenGL/raw/GLES2/NV/__pycache__/clip_space_w_scaling.cpython-312.pyc,, +OpenGL/raw/GLES2/NV/__pycache__/compute_shader_derivatives.cpython-312.pyc,, +OpenGL/raw/GLES2/NV/__pycache__/conditional_render.cpython-312.pyc,, +OpenGL/raw/GLES2/NV/__pycache__/conservative_raster.cpython-312.pyc,, +OpenGL/raw/GLES2/NV/__pycache__/conservative_raster_pre_snap.cpython-312.pyc,, +OpenGL/raw/GLES2/NV/__pycache__/conservative_raster_pre_snap_triangles.cpython-312.pyc,, +OpenGL/raw/GLES2/NV/__pycache__/copy_buffer.cpython-312.pyc,, +OpenGL/raw/GLES2/NV/__pycache__/coverage_sample.cpython-312.pyc,, +OpenGL/raw/GLES2/NV/__pycache__/depth_nonlinear.cpython-312.pyc,, +OpenGL/raw/GLES2/NV/__pycache__/draw_buffers.cpython-312.pyc,, +OpenGL/raw/GLES2/NV/__pycache__/draw_instanced.cpython-312.pyc,, +OpenGL/raw/GLES2/NV/__pycache__/draw_vulkan_image.cpython-312.pyc,, +OpenGL/raw/GLES2/NV/__pycache__/explicit_attrib_location.cpython-312.pyc,, +OpenGL/raw/GLES2/NV/__pycache__/fbo_color_attachments.cpython-312.pyc,, +OpenGL/raw/GLES2/NV/__pycache__/fence.cpython-312.pyc,, +OpenGL/raw/GLES2/NV/__pycache__/fill_rectangle.cpython-312.pyc,, +OpenGL/raw/GLES2/NV/__pycache__/fragment_coverage_to_color.cpython-312.pyc,, +OpenGL/raw/GLES2/NV/__pycache__/fragment_shader_barycentric.cpython-312.pyc,, +OpenGL/raw/GLES2/NV/__pycache__/fragment_shader_interlock.cpython-312.pyc,, +OpenGL/raw/GLES2/NV/__pycache__/framebuffer_blit.cpython-312.pyc,, +OpenGL/raw/GLES2/NV/__pycache__/framebuffer_mixed_samples.cpython-312.pyc,, +OpenGL/raw/GLES2/NV/__pycache__/framebuffer_multisample.cpython-312.pyc,, +OpenGL/raw/GLES2/NV/__pycache__/generate_mipmap_sRGB.cpython-312.pyc,, +OpenGL/raw/GLES2/NV/__pycache__/geometry_shader_passthrough.cpython-312.pyc,, +OpenGL/raw/GLES2/NV/__pycache__/gpu_shader5.cpython-312.pyc,, +OpenGL/raw/GLES2/NV/__pycache__/image_formats.cpython-312.pyc,, +OpenGL/raw/GLES2/NV/__pycache__/instanced_arrays.cpython-312.pyc,, +OpenGL/raw/GLES2/NV/__pycache__/internalformat_sample_query.cpython-312.pyc,, +OpenGL/raw/GLES2/NV/__pycache__/memory_attachment.cpython-312.pyc,, +OpenGL/raw/GLES2/NV/__pycache__/mesh_shader.cpython-312.pyc,, +OpenGL/raw/GLES2/NV/__pycache__/non_square_matrices.cpython-312.pyc,, +OpenGL/raw/GLES2/NV/__pycache__/path_rendering.cpython-312.pyc,, +OpenGL/raw/GLES2/NV/__pycache__/path_rendering_shared_edge.cpython-312.pyc,, +OpenGL/raw/GLES2/NV/__pycache__/pixel_buffer_object.cpython-312.pyc,, +OpenGL/raw/GLES2/NV/__pycache__/polygon_mode.cpython-312.pyc,, +OpenGL/raw/GLES2/NV/__pycache__/read_buffer.cpython-312.pyc,, +OpenGL/raw/GLES2/NV/__pycache__/read_buffer_front.cpython-312.pyc,, +OpenGL/raw/GLES2/NV/__pycache__/read_depth.cpython-312.pyc,, +OpenGL/raw/GLES2/NV/__pycache__/read_depth_stencil.cpython-312.pyc,, +OpenGL/raw/GLES2/NV/__pycache__/read_stencil.cpython-312.pyc,, +OpenGL/raw/GLES2/NV/__pycache__/representative_fragment_test.cpython-312.pyc,, +OpenGL/raw/GLES2/NV/__pycache__/sRGB_formats.cpython-312.pyc,, +OpenGL/raw/GLES2/NV/__pycache__/sample_locations.cpython-312.pyc,, +OpenGL/raw/GLES2/NV/__pycache__/sample_mask_override_coverage.cpython-312.pyc,, +OpenGL/raw/GLES2/NV/__pycache__/scissor_exclusive.cpython-312.pyc,, +OpenGL/raw/GLES2/NV/__pycache__/shader_atomic_fp16_vector.cpython-312.pyc,, +OpenGL/raw/GLES2/NV/__pycache__/shader_noperspective_interpolation.cpython-312.pyc,, +OpenGL/raw/GLES2/NV/__pycache__/shader_subgroup_partitioned.cpython-312.pyc,, +OpenGL/raw/GLES2/NV/__pycache__/shader_texture_footprint.cpython-312.pyc,, +OpenGL/raw/GLES2/NV/__pycache__/shading_rate_image.cpython-312.pyc,, +OpenGL/raw/GLES2/NV/__pycache__/shadow_samplers_array.cpython-312.pyc,, +OpenGL/raw/GLES2/NV/__pycache__/shadow_samplers_cube.cpython-312.pyc,, +OpenGL/raw/GLES2/NV/__pycache__/stereo_view_rendering.cpython-312.pyc,, +OpenGL/raw/GLES2/NV/__pycache__/texture_border_clamp.cpython-312.pyc,, +OpenGL/raw/GLES2/NV/__pycache__/texture_compression_s3tc_update.cpython-312.pyc,, +OpenGL/raw/GLES2/NV/__pycache__/texture_npot_2D_mipmap.cpython-312.pyc,, +OpenGL/raw/GLES2/NV/__pycache__/viewport_array.cpython-312.pyc,, +OpenGL/raw/GLES2/NV/__pycache__/viewport_array2.cpython-312.pyc,, +OpenGL/raw/GLES2/NV/__pycache__/viewport_swizzle.cpython-312.pyc,, +OpenGL/raw/GLES2/NV/bindless_texture.py,sha256=AfAlGK1JP_SY6huTlO23N8tSJxWQYsNEaQ60TgPo5Ag,1827 +OpenGL/raw/GLES2/NV/blend_equation_advanced.py,sha256=XsXL2Dj1Y_auTMGjvhrN9UqXg9QmfjHAC3yJSozN9HQ,2893 +OpenGL/raw/GLES2/NV/blend_equation_advanced_coherent.py,sha256=vkG3I9HPMfu9ZXGx3eqJE_RJWTBDVuZx7iYTtRIyrv0,623 +OpenGL/raw/GLES2/NV/blend_minmax_factor.py,sha256=slulwx0mkjO_qC9u7etZCeacJH5gaHiFd0RwbxxkJW0,622 +OpenGL/raw/GLES2/NV/clip_space_w_scaling.py,sha256=L4Sz7lmwj0HIS2NUzGjD1rWJrjiX3XaQ1D3Nb1zDKvw,900 +OpenGL/raw/GLES2/NV/compute_shader_derivatives.py,sha256=auR9wmm4lw1qBB_TJ16nkd7oV2qiepG5CYER2h-yJkM,539 +OpenGL/raw/GLES2/NV/conditional_render.py,sha256=dpPM4l6L90wU_MQf_gaXK9Ehc5eLfyADcGr3Q8yqtvo,905 +OpenGL/raw/GLES2/NV/conservative_raster.py,sha256=KHov6kpZkY3IC30B2wcwl4NK7egq809GlmTHBdl0o8M,957 +OpenGL/raw/GLES2/NV/conservative_raster_pre_snap.py,sha256=1oQb5-aePplhX3tA5_DzeHjraffqRy0VroJZxVqxX98,635 +OpenGL/raw/GLES2/NV/conservative_raster_pre_snap_triangles.py,sha256=UBUuhPgHufxdcv-l8okUErulSuWGQ021HVr1_HKRvGk,1015 +OpenGL/raw/GLES2/NV/copy_buffer.py,sha256=XuAJkfPvYklUm-NRLKeihRTXyJYU2jne4asx5EQ56KE,793 +OpenGL/raw/GLES2/NV/coverage_sample.py,sha256=FMYpCdqD507liqcL30M1zuO3wj0wWOtIYGeQn0Zym1c,1241 +OpenGL/raw/GLES2/NV/depth_nonlinear.py,sha256=mTo9WTTmTMguiIm5g4VGR8hergJXFRQOZ9pyISDikFg,597 +OpenGL/raw/GLES2/NV/draw_buffers.py,sha256=HZcfj6s3oYT722eOW-T_NioeK8HTDGXJ-ssDOA7g4p8,2468 +OpenGL/raw/GLES2/NV/draw_instanced.py,sha256=CgFDrAK7-KW9W76daTl9CmsoSUQJekGRj2qVZgyYelg,792 +OpenGL/raw/GLES2/NV/draw_vulkan_image.py,sha256=A7zN1pJO2zuE3eLhZnDShBP0wrGBsqoRMlzVkn_InOw,1047 +OpenGL/raw/GLES2/NV/explicit_attrib_location.py,sha256=WkDa5zghYUKpe5sA5ZNpdr-b69wjmjyef87mmfnsj88,535 +OpenGL/raw/GLES2/NV/fbo_color_attachments.py,sha256=z4G5oYZOL1UWaBIplOklZkdrNw6_SuvECY9Av4wUmqo,1585 +OpenGL/raw/GLES2/NV/fence.py,sha256=uIHF7-pXWr-7CPvz7a0S_V6VrK0VY2GVKeYnZbWxnrk,1213 +OpenGL/raw/GLES2/NV/fill_rectangle.py,sha256=EbBCXNO9XKtSMZTq53ePkNZW7UdbGC-LIbNnd0Bwop4,569 +OpenGL/raw/GLES2/NV/fragment_coverage_to_color.py,sha256=1G8AqccgxyZQHNtxt7R2TBVf3bSXLX2eJvQHWn4jmDM,762 +OpenGL/raw/GLES2/NV/fragment_shader_barycentric.py,sha256=5JXE25-NvFxQWuTZcZvYNFUgtXujcanJzDwaZPFRDIQ,541 +OpenGL/raw/GLES2/NV/fragment_shader_interlock.py,sha256=OWcJarfW9LOHWk_ScsYqP48XbRKUR30nUhd4quT-UBg,537 +OpenGL/raw/GLES2/NV/framebuffer_blit.py,sha256=_bzMGwUe51rhOOddAyGV5UFsp9ANLx5WjTu6jgUW4Jo,1001 +OpenGL/raw/GLES2/NV/framebuffer_mixed_samples.py,sha256=bV_juKFTO-q8pNCsMuEWZw0xJKCC7qr8yeNsd6M4AyE,1922 +OpenGL/raw/GLES2/NV/framebuffer_multisample.py,sha256=rFtmKk7tvHn1jxugUY99pa3wZsJ8ZE6spwQtM41x6mo,908 +OpenGL/raw/GLES2/NV/generate_mipmap_sRGB.py,sha256=Njk8uUo0vix8tqA3z3aipyxSyIRHTOLSLzE9ZFHWEtI,527 +OpenGL/raw/GLES2/NV/geometry_shader_passthrough.py,sha256=LjDPJpGGfvv_m_6T3_1EYcFbh81PjFeSjGpf7dqqhmU,541 +OpenGL/raw/GLES2/NV/gpu_shader5.py,sha256=ahyk_who5XUY7SwD1c2JdwUkgPavXVOoOPtzN38WpTE,6058 +OpenGL/raw/GLES2/NV/image_formats.py,sha256=df5qRflWB9j3iz1lW-ZjpWAb-nucPXyV76t4igeCVmM,513 +OpenGL/raw/GLES2/NV/instanced_arrays.py,sha256=mCsYgnWclSVHfr1zFZBlolkMWNDXaoVIXnfiFbCazDg,688 +OpenGL/raw/GLES2/NV/internalformat_sample_query.py,sha256=b2wPC-bZT-2KeowGjMyfP7q4YGejgsEu_QIK4KBDvwY,1140 +OpenGL/raw/GLES2/NV/memory_attachment.py,sha256=BjzHmdE8Duf3_tq_8_WoiIDI7B3mufKKcGFLlknsEek,1912 +OpenGL/raw/GLES2/NV/mesh_shader.py,sha256=86IE62-IJBsWdOCRQCUrA5xvKlXPsGFR1I_iCG4jmOE,4708 +OpenGL/raw/GLES2/NV/non_square_matrices.py,sha256=pHgjwQqCt5zuYQF2nSOIq7hFUI8w5sWf6EEI6EV1M9E,1669 +OpenGL/raw/GLES2/NV/path_rendering.py,sha256=GQw8Wn1b30Ct23ufyDMYWA1aMUl44BKMA8kTfurmnBM,22053 +OpenGL/raw/GLES2/NV/path_rendering_shared_edge.py,sha256=BOX_6J81o7brKlxe9-Vi-xaGHn-PO3iE0qu72ZS7uhc,585 +OpenGL/raw/GLES2/NV/pixel_buffer_object.py,sha256=9DVDT_oZCgS35lTd2wWjUGOkxr5Plr4T-e0v9eqaktA,808 +OpenGL/raw/GLES2/NV/polygon_mode.py,sha256=csegCQ6a9fPRBdRttbMnqWXnDRYhKunaJ-QfolfjGXc,877 +OpenGL/raw/GLES2/NV/read_buffer.py,sha256=gt1cs2YCKYz3Hevczb8NV5-rwcJiBRNXKTi6HHMxhvk,617 +OpenGL/raw/GLES2/NV/read_buffer_front.py,sha256=XcvbT1TaOVaI_VqZxhfIUoygLJQuhagXyJb0mCDjyDc,521 +OpenGL/raw/GLES2/NV/read_depth.py,sha256=zeWfsPFYAJzqYgi9wZUdCtUS_SF9I7cYPWcNpM6taoM,507 +OpenGL/raw/GLES2/NV/read_depth_stencil.py,sha256=7CL6oTQqPCc5Z7s9BhGPc5irTkkCNs0H-tiO9hxcNn4,523 +OpenGL/raw/GLES2/NV/read_stencil.py,sha256=AnRRETqvoSGWpxZsPYjxtmUIfgZ-qd4-hiqOAc9Z78A,511 +OpenGL/raw/GLES2/NV/representative_fragment_test.py,sha256=O3Hyz595ck2qdDSGKqTrepuoZ-b7BI15cR4w8u70thg,625 +OpenGL/raw/GLES2/NV/sRGB_formats.py,sha256=kO-UhUQ_eftV0icbZiRJTwzvv6olBjxVC05UMxwQ4Ic,1156 +OpenGL/raw/GLES2/NV/sample_locations.py,sha256=vD_ALrjqNY7eck4XM2H5qbb2tT8m3NTZAEnCVdEEYZ8,1584 +OpenGL/raw/GLES2/NV/sample_mask_override_coverage.py,sha256=cAMcS9hvomHuAYHIiMDEfI57ZyvPrm8xe3SM-w2vJkE,545 +OpenGL/raw/GLES2/NV/scissor_exclusive.py,sha256=tK_m0HGXjd0TnZL3gu_0MQMgUOoQaOONuk9vtxVrmqU,883 +OpenGL/raw/GLES2/NV/shader_atomic_fp16_vector.py,sha256=z3IOn6rt0YeINcnfzTueFXvbDsEPMkPtTpy4XWnhL7o,537 +OpenGL/raw/GLES2/NV/shader_noperspective_interpolation.py,sha256=ysnishlk7S7c7c7QNCQG5eUUQikfQF-a0u376O8H1QU,555 +OpenGL/raw/GLES2/NV/shader_subgroup_partitioned.py,sha256=1FDs5fsRJkYWeIwRK_bG1-s5J3vo7z8FDRIyPOwsUk0,635 +OpenGL/raw/GLES2/NV/shader_texture_footprint.py,sha256=aI-LS6zVhuJENSaDu0GsfnXr53Ke0oe6Nwo-f81LEv0,535 +OpenGL/raw/GLES2/NV/shading_rate_image.py,sha256=OAHORKad_9AzbdoHbGaxYHeEDOjIbKOc1ZpL1-9kMB0,3370 +OpenGL/raw/GLES2/NV/shadow_samplers_array.py,sha256=MNtU1uLEZPG6S8_nKBLm6JKspFJAqRYBSIuzAGPcwX4,601 +OpenGL/raw/GLES2/NV/shadow_samplers_cube.py,sha256=c48KLNYzRbdJ_qXNTN_H5FthAanG9-oUKCV8IZv1P2w,591 +OpenGL/raw/GLES2/NV/stereo_view_rendering.py,sha256=TIfXCBh-J3OY_y2Y0cGgoA3AcYxAxkuEsfv4UR52hG8,529 +OpenGL/raw/GLES2/NV/texture_border_clamp.py,sha256=2NIpcNF6spK7-gy7MiUqi1ss4RvqztpN0G0DskWOb80,650 +OpenGL/raw/GLES2/NV/texture_compression_s3tc_update.py,sha256=CCKbq436fcCsZQ9nirqF8_eVI70sgAxk_EHlP1bNKl4,549 +OpenGL/raw/GLES2/NV/texture_npot_2D_mipmap.py,sha256=3Lq1uA4GG6pFdFn9I6i7VZmCgqGnoLH89C1fiqKZcmo,531 +OpenGL/raw/GLES2/NV/viewport_array.py,sha256=1fl7z_VZmbrH5gjPiV6DXTBZxCx7JQij74pYueihizc,2166 +OpenGL/raw/GLES2/NV/viewport_array2.py,sha256=Mfj89YBiCHtPCw3FvQ4ArxYHaCSlHCVVrmIdDwNsYyM,517 +OpenGL/raw/GLES2/NV/viewport_swizzle.py,sha256=r3DyaS0MSlr3UTKO6-kdXMRl9m86C-lWHFYqDvQ1KeY,1564 +OpenGL/raw/GLES2/NVX/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/raw/GLES2/NVX/__pycache__/__init__.cpython-312.pyc,, +OpenGL/raw/GLES2/NVX/__pycache__/blend_equation_advanced_multi_draw_buffers.cpython-312.pyc,, +OpenGL/raw/GLES2/NVX/blend_equation_advanced_multi_draw_buffers.py,sha256=zIi13QpitSmo9idY4SENp9WQwUTu64eAdaCX9o2SwXY,573 +OpenGL/raw/GLES2/OES/EGL_image.py,sha256=HxnKoBJF-1JVjSwKzX3pfYGuko8ouBB-xhMGlAepU4s,718 +OpenGL/raw/GLES2/OES/EGL_image_external.py,sha256=NbIu__PnTAd2nh4UZNJJYQLarIYTSG4ux6tIQxFBnyE,808 +OpenGL/raw/GLES2/OES/EGL_image_external_essl3.py,sha256=JSTGiv48plAkBwpPxkYAsh-pbs-hgYhE4k4yM46ahKo,537 +OpenGL/raw/GLES2/OES/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/raw/GLES2/OES/__pycache__/EGL_image.cpython-312.pyc,, +OpenGL/raw/GLES2/OES/__pycache__/EGL_image_external.cpython-312.pyc,, +OpenGL/raw/GLES2/OES/__pycache__/EGL_image_external_essl3.cpython-312.pyc,, +OpenGL/raw/GLES2/OES/__pycache__/__init__.cpython-312.pyc,, +OpenGL/raw/GLES2/OES/__pycache__/compressed_ETC1_RGB8_sub_texture.cpython-312.pyc,, +OpenGL/raw/GLES2/OES/__pycache__/compressed_ETC1_RGB8_texture.cpython-312.pyc,, +OpenGL/raw/GLES2/OES/__pycache__/compressed_paletted_texture.cpython-312.pyc,, +OpenGL/raw/GLES2/OES/__pycache__/copy_image.cpython-312.pyc,, +OpenGL/raw/GLES2/OES/__pycache__/depth24.cpython-312.pyc,, +OpenGL/raw/GLES2/OES/__pycache__/depth32.cpython-312.pyc,, +OpenGL/raw/GLES2/OES/__pycache__/depth_texture.cpython-312.pyc,, +OpenGL/raw/GLES2/OES/__pycache__/draw_buffers_indexed.cpython-312.pyc,, +OpenGL/raw/GLES2/OES/__pycache__/draw_elements_base_vertex.cpython-312.pyc,, +OpenGL/raw/GLES2/OES/__pycache__/element_index_uint.cpython-312.pyc,, +OpenGL/raw/GLES2/OES/__pycache__/fbo_render_mipmap.cpython-312.pyc,, +OpenGL/raw/GLES2/OES/__pycache__/fragment_precision_high.cpython-312.pyc,, +OpenGL/raw/GLES2/OES/__pycache__/geometry_point_size.cpython-312.pyc,, +OpenGL/raw/GLES2/OES/__pycache__/geometry_shader.cpython-312.pyc,, +OpenGL/raw/GLES2/OES/__pycache__/get_program_binary.cpython-312.pyc,, +OpenGL/raw/GLES2/OES/__pycache__/gpu_shader5.cpython-312.pyc,, +OpenGL/raw/GLES2/OES/__pycache__/mapbuffer.cpython-312.pyc,, +OpenGL/raw/GLES2/OES/__pycache__/packed_depth_stencil.cpython-312.pyc,, +OpenGL/raw/GLES2/OES/__pycache__/primitive_bounding_box.cpython-312.pyc,, +OpenGL/raw/GLES2/OES/__pycache__/required_internalformat.cpython-312.pyc,, +OpenGL/raw/GLES2/OES/__pycache__/rgb8_rgba8.cpython-312.pyc,, +OpenGL/raw/GLES2/OES/__pycache__/sample_shading.cpython-312.pyc,, +OpenGL/raw/GLES2/OES/__pycache__/sample_variables.cpython-312.pyc,, +OpenGL/raw/GLES2/OES/__pycache__/shader_image_atomic.cpython-312.pyc,, +OpenGL/raw/GLES2/OES/__pycache__/shader_io_blocks.cpython-312.pyc,, +OpenGL/raw/GLES2/OES/__pycache__/shader_multisample_interpolation.cpython-312.pyc,, +OpenGL/raw/GLES2/OES/__pycache__/standard_derivatives.cpython-312.pyc,, +OpenGL/raw/GLES2/OES/__pycache__/stencil1.cpython-312.pyc,, +OpenGL/raw/GLES2/OES/__pycache__/stencil4.cpython-312.pyc,, +OpenGL/raw/GLES2/OES/__pycache__/surfaceless_context.cpython-312.pyc,, +OpenGL/raw/GLES2/OES/__pycache__/tessellation_point_size.cpython-312.pyc,, +OpenGL/raw/GLES2/OES/__pycache__/tessellation_shader.cpython-312.pyc,, +OpenGL/raw/GLES2/OES/__pycache__/texture_3D.cpython-312.pyc,, +OpenGL/raw/GLES2/OES/__pycache__/texture_border_clamp.cpython-312.pyc,, +OpenGL/raw/GLES2/OES/__pycache__/texture_buffer.cpython-312.pyc,, +OpenGL/raw/GLES2/OES/__pycache__/texture_compression_astc.cpython-312.pyc,, +OpenGL/raw/GLES2/OES/__pycache__/texture_cube_map_array.cpython-312.pyc,, +OpenGL/raw/GLES2/OES/__pycache__/texture_float.cpython-312.pyc,, +OpenGL/raw/GLES2/OES/__pycache__/texture_float_linear.cpython-312.pyc,, +OpenGL/raw/GLES2/OES/__pycache__/texture_half_float.cpython-312.pyc,, +OpenGL/raw/GLES2/OES/__pycache__/texture_half_float_linear.cpython-312.pyc,, +OpenGL/raw/GLES2/OES/__pycache__/texture_npot.cpython-312.pyc,, +OpenGL/raw/GLES2/OES/__pycache__/texture_stencil8.cpython-312.pyc,, +OpenGL/raw/GLES2/OES/__pycache__/texture_storage_multisample_2d_array.cpython-312.pyc,, +OpenGL/raw/GLES2/OES/__pycache__/texture_view.cpython-312.pyc,, +OpenGL/raw/GLES2/OES/__pycache__/vertex_array_object.cpython-312.pyc,, +OpenGL/raw/GLES2/OES/__pycache__/vertex_half_float.cpython-312.pyc,, +OpenGL/raw/GLES2/OES/__pycache__/vertex_type_10_10_10_2.cpython-312.pyc,, +OpenGL/raw/GLES2/OES/__pycache__/viewport_array.cpython-312.pyc,, +OpenGL/raw/GLES2/OES/compressed_ETC1_RGB8_sub_texture.py,sha256=EFhxizrXUoPypPWuVHevX-G3fpRKojFgLp7jtVBX6to,553 +OpenGL/raw/GLES2/OES/compressed_ETC1_RGB8_texture.py,sha256=1YVVflung00L5BtlUsz-MUq7zGrA7a0RQI8c-pzfT-Q,591 +OpenGL/raw/GLES2/OES/compressed_paletted_texture.py,sha256=egJvUgu4zvtfVh4i7n__OBo-UDhjtJMWrnATx0cpj6o,1128 +OpenGL/raw/GLES2/OES/copy_image.py,sha256=CqDfr0z5p8x6kyec3hoPLzjtHyp0gOxuTaoZTDFc25g,832 +OpenGL/raw/GLES2/OES/depth24.py,sha256=4gZ4pdZRWHsWlCHfnnMrNGcpa-Ya7HADylflX7KJJXM,565 +OpenGL/raw/GLES2/OES/depth32.py,sha256=PbZPdgh5KDh49wkPYsO6jSVgGka9bVFr_t-2PiEhWHk,565 +OpenGL/raw/GLES2/OES/depth_texture.py,sha256=tpoZNpQxVss3U13ZMesOXFkql3xAe5V6y_gzz8ArmZw,659 +OpenGL/raw/GLES2/OES/draw_buffers_indexed.py,sha256=NMe57g4FjRwCT2kfIHsX2Wzexigx6m9W98IGuPbS-Lk,2659 +OpenGL/raw/GLES2/OES/draw_elements_base_vertex.py,sha256=zLeIW9JaAvZAWJJTM1wFkJHZnVzw44iN12DilQM8QZY,1269 +OpenGL/raw/GLES2/OES/element_index_uint.py,sha256=M9iN31mX1CzCbbmrv0LseTvag2epKo6-_35Tvi9d7EM,569 +OpenGL/raw/GLES2/OES/fbo_render_mipmap.py,sha256=Cv7Hjdal8oPlu4qtiaEc5GkTa0qVfUJTvUl_b3Sf-D0,523 +OpenGL/raw/GLES2/OES/fragment_precision_high.py,sha256=SYgKsN1Lmvc9C5BTHnMagjjjT5B5_jE-gr0Wbaqct7A,535 +OpenGL/raw/GLES2/OES/geometry_point_size.py,sha256=vNMWMlLd-X6GHt9joy9wKtUJ7AklXYJZutIRVfGDVUY,527 +OpenGL/raw/GLES2/OES/geometry_shader.py,sha256=Dzliwj_hTQi1rPUT_2bnpFHdrs-We2GNVZB_dvYGsg0,3355 +OpenGL/raw/GLES2/OES/get_program_binary.py,sha256=W5g-dN6f8HdoAJRpoOJ7vBOMvlfUvjsJFpyLskpF2nA,1053 +OpenGL/raw/GLES2/OES/gpu_shader5.py,sha256=LgFvOBkmgJj9i6dSrZ4tfuer4wueP5ugPZN27BKGNDM,511 +OpenGL/raw/GLES2/OES/mapbuffer.py,sha256=qS6cbtMhkt-ij-QHKHN48aYgn3p5prW_eoz9850KX3c,1010 +OpenGL/raw/GLES2/OES/packed_depth_stencil.py,sha256=tnZBL70lsnPNNNZdv4_SKskaatC9LimGxwAJyEY7gck,707 +OpenGL/raw/GLES2/OES/primitive_bounding_box.py,sha256=ptSnLBL8-bTZXR_RlTBGTyV7oX7GX-CG8CRmUluNaz0,796 +OpenGL/raw/GLES2/OES/required_internalformat.py,sha256=7Vp3jLqHtappSlEkgORSx-jjKbYbNIo7ggcbkr6cuRs,1283 +OpenGL/raw/GLES2/OES/rgb8_rgba8.py,sha256=ZpYL4jjmzrn90YV4t6sqgL3lMeglI5w_eeq8HH-LdjE,584 +OpenGL/raw/GLES2/OES/sample_shading.py,sha256=PZA6_Mvlvp4T-A_7WG7dFPzW_LQiaPEWmvtPk2ORZ-0,719 +OpenGL/raw/GLES2/OES/sample_variables.py,sha256=nMhWyTHUCx4ZxLR5gQSvbusWV6IkjFTqPLEiMz9CMks,521 +OpenGL/raw/GLES2/OES/shader_image_atomic.py,sha256=2cGg2TOA0zhmHG3A8XmXZaAeoYvt5lEZCfe09Avj5I4,527 +OpenGL/raw/GLES2/OES/shader_io_blocks.py,sha256=Az5-tceWm7e3nisf9ZEJ5tPEtAUdsxfVJCuD_dfPO9s,521 +OpenGL/raw/GLES2/OES/shader_multisample_interpolation.py,sha256=FjdQpJeNbby86UnUjEFXjAOAOjQDbCIOU6w5z5nTXzg,839 +OpenGL/raw/GLES2/OES/standard_derivatives.py,sha256=dz9hqvxbPk3CqzUYGgUCx07bu46XlvobdLVIGVXP3Qg,619 +OpenGL/raw/GLES2/OES/stencil1.py,sha256=iSaRdp8ZXOd5ag9-1qJ2vMnVG585o1cfQ0hFQ6462gA,561 +OpenGL/raw/GLES2/OES/stencil4.py,sha256=fYM_LGhWG0DDrs_xPOYawsJ68PbYPmkKwYYa4Mo-zuo,561 +OpenGL/raw/GLES2/OES/surfaceless_context.py,sha256=pbg1fGLd1z5H1dZvIUMDcOc6Kd8X4k7XwjyK9Ecn0cY,597 +OpenGL/raw/GLES2/OES/tessellation_point_size.py,sha256=5agyQtnxlF0JHpkAfpZr6a9ZLbk8qpt29idIfsiHW2A,535 +OpenGL/raw/GLES2/OES/tessellation_shader.py,sha256=ZwP7znQP0r7OBQP5YyMOAzDqGLuRjJO-Le9kS3pz_yA,4400 +OpenGL/raw/GLES2/OES/texture_3D.py,sha256=EU_MRjU3_LagXAci85rha0LHtBQ-qZXYvMsDXNmDp7E,2255 +OpenGL/raw/GLES2/OES/texture_border_clamp.py,sha256=BjRTcAgp2hislgleSiocpm_jVSdfb3xhjfs9fmP7bA4,1581 +OpenGL/raw/GLES2/OES/texture_buffer.py,sha256=vl2ECIYhXn7swt1EPI4U66shienQqsD4sot9FhE-z_o,1774 +OpenGL/raw/GLES2/OES/texture_compression_astc.py,sha256=TZ_zCEn21cka1NruC4JWFTU8xhobxw2qGnjmStOkxPc,4732 +OpenGL/raw/GLES2/OES/texture_cube_map_array.py,sha256=QVefq2LQxHiH4c5rYM8wLZHXF97nSv9NrOLBurtHz-4,1275 +OpenGL/raw/GLES2/OES/texture_float.py,sha256=0XDAaxpEa31G9o7EkD6CBdoWuIadr4_EZk0Bsv5ohXM,545 +OpenGL/raw/GLES2/OES/texture_float_linear.py,sha256=dFX6Kp7QeWZV9Ywmh1ZjUu5BcsCBRAGiqKLn4gxyjIM,529 +OpenGL/raw/GLES2/OES/texture_half_float.py,sha256=GnzIYQl_VO1uEaCrafSWM860fLo_qqoEkLNHNJP_cps,573 +OpenGL/raw/GLES2/OES/texture_half_float_linear.py,sha256=KGImsFWvh0V2QsUaRdpJZ27bTWuJTwa7HT4aG5t-8ko,539 +OpenGL/raw/GLES2/OES/texture_npot.py,sha256=vLLB8JMLxDVxrd3RMRPFB95QPSKZ1yLd-c86lMC2tQk,513 +OpenGL/raw/GLES2/OES/texture_stencil8.py,sha256=Gz1JMT0-095pTl8Oj4vhj3wRPBsn0SNTv1xHUvFlzl0,632 +OpenGL/raw/GLES2/OES/texture_storage_multisample_2d_array.py,sha256=cIzv_fRIX0Kh0Tf4T9mXtZ-o-WKbnvKDlgjcGN7Yqmo,1247 +OpenGL/raw/GLES2/OES/texture_view.py,sha256=AJNLFme0aIo88Xpyi7lDK0Q0xn-E1pmzHVUPz8yckBA,1091 +OpenGL/raw/GLES2/OES/vertex_array_object.py,sha256=P27Paj8HVB5FGxKROx7Wze0IQ9MRtn3uCiVRVT_7qgM,922 +OpenGL/raw/GLES2/OES/vertex_half_float.py,sha256=GShVez0dOiaEHel9TffqXmELwvEEwea2DO93nQSE56E,571 +OpenGL/raw/GLES2/OES/vertex_type_10_10_10_2.py,sha256=8V89dTDYxKQChXj8B1QX1ukXL-1cB4-UHSjn3-sOG5M,664 +OpenGL/raw/GLES2/OES/viewport_array.py,sha256=hWsFNOfNTSvkIWdaBlnH_POmtAIeD4t0a1PC9YBVYjI,2188 +OpenGL/raw/GLES2/OVR/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/raw/GLES2/OVR/__pycache__/__init__.cpython-312.pyc,, +OpenGL/raw/GLES2/OVR/__pycache__/multiview.cpython-312.pyc,, +OpenGL/raw/GLES2/OVR/__pycache__/multiview2.cpython-312.pyc,, +OpenGL/raw/GLES2/OVR/__pycache__/multiview_multisampled_render_to_texture.cpython-312.pyc,, +OpenGL/raw/GLES2/OVR/multiview.py,sha256=Rtp5HK2taztz5Nwia9dKSBwOeG0jckebNjZKH_j2VkQ,1064 +OpenGL/raw/GLES2/OVR/multiview2.py,sha256=A9wbZuDPomvyUEhDD1_zHCIJ2tNsLrxeyxUy1GW52H4,509 +OpenGL/raw/GLES2/OVR/multiview_multisampled_render_to_texture.py,sha256=Ql7QjrppfIMX66Q2enemkewMp9SSkjbPH1b8OtSgeZE,782 +OpenGL/raw/GLES2/QCOM/YUV_texture_gather.py,sha256=aRvx99M41UGK3iNLqykhvm-wT0qKGuuC-ThJmKvZrTk,527 +OpenGL/raw/GLES2/QCOM/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/raw/GLES2/QCOM/__pycache__/YUV_texture_gather.cpython-312.pyc,, +OpenGL/raw/GLES2/QCOM/__pycache__/__init__.cpython-312.pyc,, +OpenGL/raw/GLES2/QCOM/__pycache__/alpha_test.cpython-312.pyc,, +OpenGL/raw/GLES2/QCOM/__pycache__/binning_control.cpython-312.pyc,, +OpenGL/raw/GLES2/QCOM/__pycache__/driver_control.cpython-312.pyc,, +OpenGL/raw/GLES2/QCOM/__pycache__/extended_get.cpython-312.pyc,, +OpenGL/raw/GLES2/QCOM/__pycache__/extended_get2.cpython-312.pyc,, +OpenGL/raw/GLES2/QCOM/__pycache__/framebuffer_foveated.cpython-312.pyc,, +OpenGL/raw/GLES2/QCOM/__pycache__/perfmon_global_mode.cpython-312.pyc,, +OpenGL/raw/GLES2/QCOM/__pycache__/shader_framebuffer_fetch_noncoherent.cpython-312.pyc,, +OpenGL/raw/GLES2/QCOM/__pycache__/shader_framebuffer_fetch_rate.cpython-312.pyc,, +OpenGL/raw/GLES2/QCOM/__pycache__/texture_foveated.cpython-312.pyc,, +OpenGL/raw/GLES2/QCOM/__pycache__/texture_foveated_subsampled_layout.cpython-312.pyc,, +OpenGL/raw/GLES2/QCOM/__pycache__/tiled_rendering.cpython-312.pyc,, +OpenGL/raw/GLES2/QCOM/__pycache__/writeonly_rendering.cpython-312.pyc,, +OpenGL/raw/GLES2/QCOM/alpha_test.py,sha256=RUyYpt5lT-tRd0Grrgt1OANZj4zSDgKuIDYZza59GD8,759 +OpenGL/raw/GLES2/QCOM/binning_control.py,sha256=g644xzIbchcElxVr_uMP3eKNhLAzci06Cx7_vmOIV0o,792 +OpenGL/raw/GLES2/QCOM/driver_control.py,sha256=87KnnKt1Fw4lj_jhdcudoriA-nzJLnybHQluNwUvXWw,978 +OpenGL/raw/GLES2/QCOM/extended_get.py,sha256=B52S5Xj7EX2pQqHa4IgyW9qLOzRRx6jpiTjL_tslVLc,2371 +OpenGL/raw/GLES2/QCOM/extended_get2.py,sha256=JkJGuezywXBMgrJ2rGOA7dafvGqBDFF0EOnCRzj-eVg,1011 +OpenGL/raw/GLES2/QCOM/framebuffer_foveated.py,sha256=HiPFZTJ-PJOPJzjGGIQTxHI-6-SQ-Rs2MaUPn_Q5RYI,1129 +OpenGL/raw/GLES2/QCOM/perfmon_global_mode.py,sha256=jFFvuXg3tym68aQqCFT2GcNsJUvMyigNr9j1pYLzSyw,597 +OpenGL/raw/GLES2/QCOM/shader_framebuffer_fetch_noncoherent.py,sha256=RRe5-XViHxEg1g1eiBudZfXKAunRJ83Zl9CJm74WnXA,712 +OpenGL/raw/GLES2/QCOM/shader_framebuffer_fetch_rate.py,sha256=dsmfnbk5ic_QAs4emG7UFG5Gu2IdX25GYnR9KU-t0vY,549 +OpenGL/raw/GLES2/QCOM/texture_foveated.py,sha256=3CV1Gy4VUR9L9NC7mrNDcblLOTeC9qHHw4x93TDrstM,1393 +OpenGL/raw/GLES2/QCOM/texture_foveated_subsampled_layout.py,sha256=PpegmpBxcKpKLjVFxfHSzcXTC5pTUXlEEFaUTEk5Zng,766 +OpenGL/raw/GLES2/QCOM/tiled_rendering.py,sha256=yWeFHR-PhSWjZK9GpPluBAMmHSh3EGljMuKMVFNxLxg,3066 +OpenGL/raw/GLES2/QCOM/writeonly_rendering.py,sha256=f1bWBO7_y9VO6k5DrlegHM1ZrNv7-ZzgK6h2hFF6owg,597 +OpenGL/raw/GLES2/VERSION/GLES2_2_0.py,sha256=EVbA8qBXtrTW0BeInq3q8mreZZxQjPDrmb1HaiCUFX8,29871 +OpenGL/raw/GLES2/VERSION/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/raw/GLES2/VERSION/__pycache__/GLES2_2_0.cpython-312.pyc,, +OpenGL/raw/GLES2/VERSION/__pycache__/__init__.cpython-312.pyc,, +OpenGL/raw/GLES2/VIV/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/raw/GLES2/VIV/__pycache__/__init__.cpython-312.pyc,, +OpenGL/raw/GLES2/VIV/__pycache__/shader_binary.cpython-312.pyc,, +OpenGL/raw/GLES2/VIV/shader_binary.py,sha256=HIkU2S5CX8mzsNg7sFI1H0RzuxD-4bm1mWGlPmtAkic,569 +OpenGL/raw/GLES2/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +OpenGL/raw/GLES2/__pycache__/__init__.cpython-312.pyc,, +OpenGL/raw/GLES2/__pycache__/_errors.cpython-312.pyc,, +OpenGL/raw/GLES2/__pycache__/_glgets.cpython-312.pyc,, +OpenGL/raw/GLES2/__pycache__/_types.cpython-312.pyc,, +OpenGL/raw/GLES2/_errors.py,sha256=b9PL4NGKPmiWuLJi63mpa7_4AwcMzxwp7JzAV84Wmk4,195 +OpenGL/raw/GLES2/_glgets.py,sha256=GqC8rv1afGq7BlFLHO3avEgv01NkZD5_fVsBZg4M47E,145541 +OpenGL/raw/GLES2/_types.py,sha256=6ET3Pds2K4GBWpmalKtR-IItdOvu1x4cGiiXXwgiRls,179 +OpenGL/raw/GLES3/VERSION/GLES3_3_0.py,sha256=SrT5Ukqgx-8tTeESVvJrKJbk_qUkdjhBNhsAZCo1AYI,30987 +OpenGL/raw/GLES3/VERSION/GLES3_3_1.py,sha256=ILdw8y0fiq4PFdMnIs9uJk0MZLV2pGa_QnLtd_ipQ34,20935 +OpenGL/raw/GLES3/VERSION/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/raw/GLES3/VERSION/__pycache__/GLES3_3_0.cpython-312.pyc,, +OpenGL/raw/GLES3/VERSION/__pycache__/GLES3_3_1.cpython-312.pyc,, +OpenGL/raw/GLES3/VERSION/__pycache__/__init__.cpython-312.pyc,, +OpenGL/raw/GLES3/__init__.py,sha256=2iFonQZlTYZIovUS6Z2EBjGrQbqWrXIgxj6l8sNUgEo,83 +OpenGL/raw/GLES3/__pycache__/__init__.cpython-312.pyc,, +OpenGL/raw/GLES3/__pycache__/_errors.cpython-312.pyc,, +OpenGL/raw/GLES3/__pycache__/_glgets.cpython-312.pyc,, +OpenGL/raw/GLES3/__pycache__/_types.cpython-312.pyc,, +OpenGL/raw/GLES3/_errors.py,sha256=PHpsurZ03sYVki7dxbDp-iDoC0yAzIsRalTc-o_X5uU,211 +OpenGL/raw/GLES3/_glgets.py,sha256=GqC8rv1afGq7BlFLHO3avEgv01NkZD5_fVsBZg4M47E,145541 +OpenGL/raw/GLES3/_types.py,sha256=at3ce6b-FRWjmnq77RGvIQ--W3gg6-sHBoGfQWxH6PA,137 +OpenGL/raw/GLU/__init__.py,sha256=m2J625Tb7GvLtDU7_ad_yxm__Td69dwxd5b29ov8zDs,28894 +OpenGL/raw/GLU/__pycache__/__init__.cpython-312.pyc,, +OpenGL/raw/GLU/__pycache__/_errors.cpython-312.pyc,, +OpenGL/raw/GLU/__pycache__/annotations.cpython-312.pyc,, +OpenGL/raw/GLU/__pycache__/constants.cpython-312.pyc,, +OpenGL/raw/GLU/_errors.py,sha256=P3qCvHLvPfP1gJ2EIUpw6aiuqs30-zWNrZ75wKC68dE,191 +OpenGL/raw/GLU/annotations.py,sha256=lbC04EfPYoaf9LDT5F4rptVuydPMcbFkLpj1lh4P8cg,8179 +OpenGL/raw/GLU/constants.py,sha256=IBWo9MB2dKD-jWNcGAAjR9e9fEtm7xDBbxeMVjw82iY,13325 +OpenGL/raw/GLUT/__init__.py,sha256=4jESKD2h2KGrjL8NUF1x9tbvSto24YZ36iazFniYrzw,40838 +OpenGL/raw/GLUT/__pycache__/__init__.cpython-312.pyc,, +OpenGL/raw/GLUT/__pycache__/annotations.cpython-312.pyc,, +OpenGL/raw/GLUT/__pycache__/constants.cpython-312.pyc,, +OpenGL/raw/GLUT/annotations.py,sha256=1RP0Wj5eEypgHBq8QY7d13Zeb5aFpLa9Rb5HIDQ6pbw,356 +OpenGL/raw/GLUT/constants.py,sha256=uoLhbQcof_3FZJY-jJqlUNF9br1Rvj24fMPAzi6iUxc,14187 +OpenGL/raw/GLX/AMD/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/raw/GLX/AMD/__pycache__/__init__.cpython-312.pyc,, +OpenGL/raw/GLX/AMD/__pycache__/gpu_association.cpython-312.pyc,, +OpenGL/raw/GLX/AMD/gpu_association.py,sha256=_85Zjlalus_J2nMvTCt7yv_Xl_F7eu6OE3bsgxyN834,2176 +OpenGL/raw/GLX/ARB/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/raw/GLX/ARB/__pycache__/__init__.cpython-312.pyc,, +OpenGL/raw/GLX/ARB/__pycache__/context_flush_control.cpython-312.pyc,, +OpenGL/raw/GLX/ARB/__pycache__/create_context.cpython-312.pyc,, +OpenGL/raw/GLX/ARB/__pycache__/create_context_no_error.cpython-312.pyc,, +OpenGL/raw/GLX/ARB/__pycache__/create_context_profile.cpython-312.pyc,, +OpenGL/raw/GLX/ARB/__pycache__/create_context_robustness.cpython-312.pyc,, +OpenGL/raw/GLX/ARB/__pycache__/fbconfig_float.cpython-312.pyc,, +OpenGL/raw/GLX/ARB/__pycache__/framebuffer_sRGB.cpython-312.pyc,, +OpenGL/raw/GLX/ARB/__pycache__/get_proc_address.cpython-312.pyc,, +OpenGL/raw/GLX/ARB/__pycache__/multisample.cpython-312.pyc,, +OpenGL/raw/GLX/ARB/__pycache__/robustness_application_isolation.cpython-312.pyc,, +OpenGL/raw/GLX/ARB/__pycache__/robustness_share_group_isolation.cpython-312.pyc,, +OpenGL/raw/GLX/ARB/__pycache__/vertex_buffer_object.cpython-312.pyc,, +OpenGL/raw/GLX/ARB/context_flush_control.py,sha256=itzxbGVFn8GhHoii53cEwCABa-dsvdtLlJj_h0Z3rFU,772 +OpenGL/raw/GLX/ARB/create_context.py,sha256=V838tqh_gnV7wyECSJjNb9DoaE4F6U6McS80MUtuJng,1075 +OpenGL/raw/GLX/ARB/create_context_no_error.py,sha256=bMxuwnTkDGw4k4E7b6awI3-1TNykwrRrHDj5JI5CBns,599 +OpenGL/raw/GLX/ARB/create_context_profile.py,sha256=PPpCG7j4BF02mX1f9T1E2cuZcHyHIqVnIri-ZV_9ES8,775 +OpenGL/raw/GLX/ARB/create_context_robustness.py,sha256=JTUxNImNtmP_PdAD4AGu91szuT7-KYNQrp5XD63u0ZQ,858 +OpenGL/raw/GLX/ARB/fbconfig_float.py,sha256=-leP9IQJDKbGBWQ5S95fnmZPg7ZIMUKRgbh-Eie1Spk,628 +OpenGL/raw/GLX/ARB/framebuffer_sRGB.py,sha256=bOeBmSDI5e86eRrA1Ky_pWYa9KmaHkItVZP2CqNb-jQ,587 +OpenGL/raw/GLX/ARB/get_proc_address.py,sha256=6fa_jIyd2vxVfTB9oZc8MNqfYshaDHQ6RVgvPJTq1HI,603 +OpenGL/raw/GLX/ARB/multisample.py,sha256=oprs-PH4u9HD3G98z1WR0_algT15s2Qft86WA5yX2X8,602 +OpenGL/raw/GLX/ARB/robustness_application_isolation.py,sha256=RxkM9uKsJEwokivfw6F9_cUC2g2PQr6fSwDtNnOi9pM,629 +OpenGL/raw/GLX/ARB/robustness_share_group_isolation.py,sha256=N7lNLtnCcRQzawmgMqXFLaHHbt9YaRfU7D0YZc7wSQo,629 +OpenGL/raw/GLX/ARB/vertex_buffer_object.py,sha256=nmd8a9jXw5J4c4NqmlXC-D31_WCWaWy6nrTvnGolJEU,627 +OpenGL/raw/GLX/DFX/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/raw/GLX/DFX/__pycache__/__init__.cpython-312.pyc,, +OpenGL/raw/GLX/DFX/__pycache__/multisample.cpython-312.pyc,, +OpenGL/raw/GLX/DFX/multisample.py,sha256=Ig6lYgZe5CknzAGFD8XkWrK7nUZyANzm0w4eWc-s67U,606 +OpenGL/raw/GLX/EXT/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/raw/GLX/EXT/__pycache__/__init__.cpython-312.pyc,, +OpenGL/raw/GLX/EXT/__pycache__/buffer_age.cpython-312.pyc,, +OpenGL/raw/GLX/EXT/__pycache__/context_priority.cpython-312.pyc,, +OpenGL/raw/GLX/EXT/__pycache__/create_context_es2_profile.cpython-312.pyc,, +OpenGL/raw/GLX/EXT/__pycache__/create_context_es_profile.cpython-312.pyc,, +OpenGL/raw/GLX/EXT/__pycache__/fbconfig_packed_float.cpython-312.pyc,, +OpenGL/raw/GLX/EXT/__pycache__/framebuffer_sRGB.cpython-312.pyc,, +OpenGL/raw/GLX/EXT/__pycache__/import_context.cpython-312.pyc,, +OpenGL/raw/GLX/EXT/__pycache__/libglvnd.cpython-312.pyc,, +OpenGL/raw/GLX/EXT/__pycache__/no_config_context.cpython-312.pyc,, +OpenGL/raw/GLX/EXT/__pycache__/stereo_tree.cpython-312.pyc,, +OpenGL/raw/GLX/EXT/__pycache__/swap_control.cpython-312.pyc,, +OpenGL/raw/GLX/EXT/__pycache__/swap_control_tear.cpython-312.pyc,, +OpenGL/raw/GLX/EXT/__pycache__/texture_from_pixmap.cpython-312.pyc,, +OpenGL/raw/GLX/EXT/__pycache__/visual_info.cpython-312.pyc,, +OpenGL/raw/GLX/EXT/__pycache__/visual_rating.cpython-312.pyc,, +OpenGL/raw/GLX/EXT/buffer_age.py,sha256=GQk6L8fcBZC3emkw5hqrVOUa-ZMOHzDEWpwvDCLtsOs,557 +OpenGL/raw/GLX/EXT/context_priority.py,sha256=mxveuSkLByqPlBE8d0lNwBLtyp9xm4tCUJAPLyr_AyY,804 +OpenGL/raw/GLX/EXT/create_context_es2_profile.py,sha256=lAX9otLSy9sRZUGgNC_itS44aNsvkkDtFSo61dHTg-4,609 +OpenGL/raw/GLX/EXT/create_context_es_profile.py,sha256=rnpWybHpdN2opf-aVPj-zpEutXJaE13_yrS8xzSg32w,605 +OpenGL/raw/GLX/EXT/fbconfig_packed_float.py,sha256=-gLIdfrfOWSPwrDpnJBmjQVulHSlXMYkVrAMxzLxhR0,678 +OpenGL/raw/GLX/EXT/framebuffer_sRGB.py,sha256=iAuMJfeFuZV2CM86wd-cZn5xQU-DoUe4IY8lIiZ0ZaI,587 +OpenGL/raw/GLX/EXT/import_context.py,sha256=CHVdUnh4dTxCGV4lOJWmq6xUAZkvzgOeyb13kb5B2Zw,1202 +OpenGL/raw/GLX/EXT/libglvnd.py,sha256=aVQowDyYo7ovioGOLj6Hu2I4NQqOkP88ECw0gpdJOw4,547 +OpenGL/raw/GLX/EXT/no_config_context.py,sha256=yQdqktYTU0JyaTEBk-nXOEkSlGNu-P38JUWdzXMwlCc,511 +OpenGL/raw/GLX/EXT/stereo_tree.py,sha256=CDYUZQJrtFSUnNuUTUvMJWOc0EMjczFdWQ0Gpo5-zIw,683 +OpenGL/raw/GLX/EXT/swap_control.py,sha256=FGyAi1vbKQf6u7-YZXi9VvRFQpVeKvcmlyICTcdb984,746 +OpenGL/raw/GLX/EXT/swap_control_tear.py,sha256=ZLixNBNeEf4jbOJ1E9EMsbGAzfBlWrPrM-ldRZ5AB6Y,571 +OpenGL/raw/GLX/EXT/texture_from_pixmap.py,sha256=Iw0NoOyVHBuwoiQecvg8DelzA9TBADJO4_zbk0MBiPQ,2569 +OpenGL/raw/GLX/EXT/visual_info.py,sha256=WFW14gStczZJGXcpG8gNQLsX8OxpQNSt4XRT2X1KVUc,1468 +OpenGL/raw/GLX/EXT/visual_rating.py,sha256=oEieT53nQt2LlF6EQNkK_rbFL6-NBS46vpkoq4w65pA,722 +OpenGL/raw/GLX/INTEL/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/raw/GLX/INTEL/__pycache__/__init__.cpython-312.pyc,, +OpenGL/raw/GLX/INTEL/__pycache__/swap_event.cpython-312.pyc,, +OpenGL/raw/GLX/INTEL/swap_event.py,sha256=39sO69tAxwzcFkLjDZfAAyHIvxTSKOXakMjX4VeGl4Q,780 +OpenGL/raw/GLX/MESA/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/raw/GLX/MESA/__pycache__/__init__.cpython-312.pyc,, +OpenGL/raw/GLX/MESA/__pycache__/agp_offset.cpython-312.pyc,, +OpenGL/raw/GLX/MESA/__pycache__/copy_sub_buffer.cpython-312.pyc,, +OpenGL/raw/GLX/MESA/__pycache__/pixmap_colormap.cpython-312.pyc,, +OpenGL/raw/GLX/MESA/__pycache__/query_renderer.cpython-312.pyc,, +OpenGL/raw/GLX/MESA/__pycache__/release_buffers.cpython-312.pyc,, +OpenGL/raw/GLX/MESA/__pycache__/set_3dfx_mode.cpython-312.pyc,, +OpenGL/raw/GLX/MESA/__pycache__/swap_control.cpython-312.pyc,, +OpenGL/raw/GLX/MESA/agp_offset.py,sha256=5BjLMDHHNCAqfD7g4zX3nLLf6Uo1v7g_NBnxM9GQR1c,578 +OpenGL/raw/GLX/MESA/copy_sub_buffer.py,sha256=ralzhu7Tx8C5NvHEDRQ9TRc4n_RpXaUxSt_B2nFwh04,673 +OpenGL/raw/GLX/MESA/pixmap_colormap.py,sha256=woxxT5HZ_ezFikOhNmQl5o_hR78aYfMi3MPBtyWDOo8,677 +OpenGL/raw/GLX/MESA/query_renderer.py,sha256=sLvCYATawJlpPrYPaauamzo33NPQkRnbUS2qggWeQIU,2034 +OpenGL/raw/GLX/MESA/release_buffers.py,sha256=slYYjdHl_A_sBThL2ZK4Lcqw3SLsEDKzBXRa9kpUT4o,621 +OpenGL/raw/GLX/MESA/set_3dfx_mode.py,sha256=gRcyNcmNAUSehtc6zr45MdW0VlgRyd6DRraSAbc0Uww,708 +OpenGL/raw/GLX/MESA/swap_control.py,sha256=1JqUFzPEVc9s30doWBznpG1GFTL8eHMLLnZeoX-V3-k,637 +OpenGL/raw/GLX/NV/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/raw/GLX/NV/__pycache__/__init__.cpython-312.pyc,, +OpenGL/raw/GLX/NV/__pycache__/copy_buffer.cpython-312.pyc,, +OpenGL/raw/GLX/NV/__pycache__/copy_image.cpython-312.pyc,, +OpenGL/raw/GLX/NV/__pycache__/delay_before_swap.cpython-312.pyc,, +OpenGL/raw/GLX/NV/__pycache__/float_buffer.cpython-312.pyc,, +OpenGL/raw/GLX/NV/__pycache__/multigpu_context.cpython-312.pyc,, +OpenGL/raw/GLX/NV/__pycache__/multisample_coverage.cpython-312.pyc,, +OpenGL/raw/GLX/NV/__pycache__/present_video.cpython-312.pyc,, +OpenGL/raw/GLX/NV/__pycache__/robustness_video_memory_purge.cpython-312.pyc,, +OpenGL/raw/GLX/NV/__pycache__/swap_group.cpython-312.pyc,, +OpenGL/raw/GLX/NV/__pycache__/video_capture.cpython-312.pyc,, +OpenGL/raw/GLX/NV/__pycache__/video_out.cpython-312.pyc,, +OpenGL/raw/GLX/NV/__pycache__/video_output.cpython-312.pyc,, +OpenGL/raw/GLX/NV/copy_buffer.py,sha256=GawAIUkVwTMS2z8tgfnBhUNX3P8U1YBquCVacmKMveg,993 +OpenGL/raw/GLX/NV/copy_image.py,sha256=Jkq5iQIhOmMmBPapp84Vdb5bbsu5_vebU93hAHesREA,885 +OpenGL/raw/GLX/NV/delay_before_swap.py,sha256=QwsAbDHtQWoxco3emND4CtwuIpctT5TolT-C8Kyo9IE,640 +OpenGL/raw/GLX/NV/float_buffer.py,sha256=e8YNUnJNElg0db6PPlnM7h0FT7T2NCydUvKyTSXgebE,559 +OpenGL/raw/GLX/NV/multigpu_context.py,sha256=jjLcOkosIcDCVUJRAXfCCpJ6Z2y3-OG-NeGEq9FN5ok,971 +OpenGL/raw/GLX/NV/multisample_coverage.py,sha256=wSFmBPSt7pD80TVlThIJEtxO35VeRnAk5_7ENK-zNVs,630 +OpenGL/raw/GLX/NV/present_video.py,sha256=HjmRmyA6plfpgnaqXF77pn_vsqxzZcgPV9YWHOXAn38,894 +OpenGL/raw/GLX/NV/robustness_video_memory_purge.py,sha256=3GYSeXb8qlNI-WA7feUeaarUcM_3DzU9YXS_v8RQHGk,633 +OpenGL/raw/GLX/NV/swap_group.py,sha256=HCMQtXpa2rYZsGKxqPAqPABFvJvbLsLFHnvRxEDMUwg,1307 +OpenGL/raw/GLX/NV/video_capture.py,sha256=aimd6_Ca-mJiSEEPFj-jCaGWGrG19pyEZTutQSUEj9Q,1452 +OpenGL/raw/GLX/NV/video_out.py,sha256=x1tOE8mcnL3jxAaSIEBVLqhlyeNPd3nbH66omBxWl8c,2212 +OpenGL/raw/GLX/NV/video_output.py,sha256=vdppgduJkWr1QPjOi4YwSMPRkFx1sRjavh98d1JtRYo,2218 +OpenGL/raw/GLX/OML/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/raw/GLX/OML/__pycache__/__init__.cpython-312.pyc,, +OpenGL/raw/GLX/OML/__pycache__/swap_method.cpython-312.pyc,, +OpenGL/raw/GLX/OML/__pycache__/sync_control.cpython-312.pyc,, +OpenGL/raw/GLX/OML/swap_method.py,sha256=zvlYVxuurum4ZILrsDGGwufhxfa7Hjmfe7G48YSG8uM,716 +OpenGL/raw/GLX/OML/sync_control.py,sha256=wyp3iQ4Rcyccyf11izdwhBwBFHxEJvwLqZYVDKVbA0o,1569 +OpenGL/raw/GLX/SGI/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/raw/GLX/SGI/__pycache__/__init__.cpython-312.pyc,, +OpenGL/raw/GLX/SGI/__pycache__/cushion.cpython-312.pyc,, +OpenGL/raw/GLX/SGI/__pycache__/make_current_read.cpython-312.pyc,, +OpenGL/raw/GLX/SGI/__pycache__/swap_control.cpython-312.pyc,, +OpenGL/raw/GLX/SGI/__pycache__/video_sync.cpython-312.pyc,, +OpenGL/raw/GLX/SGI/cushion.py,sha256=Y6H86W9zFvo6tKdsRXuDFeZEWzWK2HdwuhVWLssbxRo,607 +OpenGL/raw/GLX/SGI/make_current_read.py,sha256=bTqTkMG5-4hzPR0J7iGBNNvLsePoMDQrb7gbNPaMNn4,731 +OpenGL/raw/GLX/SGI/swap_control.py,sha256=n85RwxMe8AcYx4LuVKRDGrg_IglnBdP0GhrthXmMRS0,573 +OpenGL/raw/GLX/SGI/video_sync.py,sha256=-o_-XTJDKScB_zl9cBFi3plDVnmmXZo59qYHYxzNWCo,709 +OpenGL/raw/GLX/SGIS/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/raw/GLX/SGIS/__pycache__/__init__.cpython-312.pyc,, +OpenGL/raw/GLX/SGIS/__pycache__/blended_overlay.cpython-312.pyc,, +OpenGL/raw/GLX/SGIS/__pycache__/multisample.cpython-312.pyc,, +OpenGL/raw/GLX/SGIS/__pycache__/shared_multisample.cpython-312.pyc,, +OpenGL/raw/GLX/SGIS/blended_overlay.py,sha256=NYOEZSPonvdxjVNxilwQChnfr9hU7lxHX-bD7Pg9ATk,565 +OpenGL/raw/GLX/SGIS/multisample.py,sha256=jdLIv2ZSpSFNVk05q0mqAIzfGteggGYMkwYn18WmcAs,608 +OpenGL/raw/GLX/SGIS/shared_multisample.py,sha256=jm1DuD4iCIXFC_7J5ITfD2kXOOE1l8FM9wipmW9vZwg,686 +OpenGL/raw/GLX/SGIX/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/raw/GLX/SGIX/__pycache__/__init__.cpython-312.pyc,, +OpenGL/raw/GLX/SGIX/__pycache__/dmbuffer.cpython-312.pyc,, +OpenGL/raw/GLX/SGIX/__pycache__/fbconfig.cpython-312.pyc,, +OpenGL/raw/GLX/SGIX/__pycache__/hyperpipe.cpython-312.pyc,, +OpenGL/raw/GLX/SGIX/__pycache__/pbuffer.cpython-312.pyc,, +OpenGL/raw/GLX/SGIX/__pycache__/swap_barrier.cpython-312.pyc,, +OpenGL/raw/GLX/SGIX/__pycache__/swap_group.cpython-312.pyc,, +OpenGL/raw/GLX/SGIX/__pycache__/video_resize.cpython-312.pyc,, +OpenGL/raw/GLX/SGIX/__pycache__/video_source.cpython-312.pyc,, +OpenGL/raw/GLX/SGIX/__pycache__/visual_select_group.cpython-312.pyc,, +OpenGL/raw/GLX/SGIX/dmbuffer.py,sha256=zt9LBJ3hjO-Di6husfdATM99uTEfuxAsOkIGSul1xd0,745 +OpenGL/raw/GLX/SGIX/fbconfig.py,sha256=Mu4C4hahZRAyky1j8zRL9WArdGGI8nrzIl1Tc59-J7k,2119 +OpenGL/raw/GLX/SGIX/hyperpipe.py,sha256=W7R7HsB7lWkmZxqH5K0CpFIyBedkXwEy6IG0hWKdCgg,2512 +OpenGL/raw/GLX/SGIX/pbuffer.py,sha256=rISFCQqMoAgXL2Qba6ywA21jP1f612YghIAtzCYDzG0,2844 +OpenGL/raw/GLX/SGIX/swap_barrier.py,sha256=-3ED3s1TomIitGjdDNI0u38Yhh-kvR7Av2U2R3LQABo,771 +OpenGL/raw/GLX/SGIX/swap_group.py,sha256=gpymo7vnWF_dsYvL2UenJ6711ebS6mrbnOjP_uXCais,629 +OpenGL/raw/GLX/SGIX/video_resize.py,sha256=KrWohzDUd_gHCGawny86_keX5mXzq9PFqMvavJTgjt8,1576 +OpenGL/raw/GLX/SGIX/video_source.py,sha256=EC10jhlhm6owxzd83mnCL50wL0HbPmLMvpQPnF460tE,837 +OpenGL/raw/GLX/SGIX/visual_select_group.py,sha256=IhMo38tJbhPPDM1LqZX__Gj1pPjalFTJOf3qKrx6VMY,587 +OpenGL/raw/GLX/SUN/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/raw/GLX/SUN/__pycache__/__init__.cpython-312.pyc,, +OpenGL/raw/GLX/SUN/__pycache__/get_transparent_index.cpython-312.pyc,, +OpenGL/raw/GLX/SUN/get_transparent_index.py,sha256=cnzoblRHJl8_bmnlib9-gzHfV03MwjjI3LrpTUWeUQE,697 +OpenGL/raw/GLX/VERSION/GLX_1_0.py,sha256=nnIImn1fLgG2ndAKBoGKzR6G9f5MtvlmLocvoP2nBnc,3537 +OpenGL/raw/GLX/VERSION/GLX_1_1.py,sha256=NrM7ojSjG-LNk4LEuABSNgZ1CC470YirLyizvbCihCw,951 +OpenGL/raw/GLX/VERSION/GLX_1_2.py,sha256=5uUkz1GIQSyguFqMeR0FZBDI55XMFoS6YZUcmTXC2q8,574 +OpenGL/raw/GLX/VERSION/GLX_1_3.py,sha256=GdhmPtGjCdfZusZoV7HifxVixSSaH9lFdvIsAQmWUZk,5762 +OpenGL/raw/GLX/VERSION/GLX_1_4.py,sha256=CmHwsPhBn7GcQXINZHdjE_2JL0K3BLwyQd2tMu2EBxU,677 +OpenGL/raw/GLX/VERSION/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/raw/GLX/VERSION/__pycache__/GLX_1_0.cpython-312.pyc,, +OpenGL/raw/GLX/VERSION/__pycache__/GLX_1_1.cpython-312.pyc,, +OpenGL/raw/GLX/VERSION/__pycache__/GLX_1_2.cpython-312.pyc,, +OpenGL/raw/GLX/VERSION/__pycache__/GLX_1_3.cpython-312.pyc,, +OpenGL/raw/GLX/VERSION/__pycache__/GLX_1_4.cpython-312.pyc,, +OpenGL/raw/GLX/VERSION/__pycache__/__init__.cpython-312.pyc,, +OpenGL/raw/GLX/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +OpenGL/raw/GLX/__pycache__/__init__.cpython-312.pyc,, +OpenGL/raw/GLX/__pycache__/_errors.cpython-312.pyc,, +OpenGL/raw/GLX/__pycache__/_glgets.cpython-312.pyc,, +OpenGL/raw/GLX/__pycache__/_types.cpython-312.pyc,, +OpenGL/raw/GLX/_errors.py,sha256=90GrLzNryJ4dVjEX1GR5oFM9lkedkAp-YbnYPWIwgTU,179 +OpenGL/raw/GLX/_glgets.py,sha256=pdbDplGI61RlSwbxPgFPDuLPgWbQzMu8XaofqtPw2B8,279 +OpenGL/raw/GLX/_types.py,sha256=WcHAKLsadj0fkDswdG1cuMksZemGYBL191zLRH0zr-4,7020 +OpenGL/raw/WGL/AMD/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/raw/WGL/AMD/__pycache__/__init__.cpython-312.pyc,, +OpenGL/raw/WGL/AMD/__pycache__/gpu_association.cpython-312.pyc,, +OpenGL/raw/WGL/AMD/gpu_association.py,sha256=T5Pu4L_dJW1dxu_lko8t3K7Q4t-eOW1f-EDWx7obbI0,2100 +OpenGL/raw/WGL/ARB/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/raw/WGL/ARB/__pycache__/__init__.cpython-312.pyc,, +OpenGL/raw/WGL/ARB/__pycache__/buffer_region.cpython-312.pyc,, +OpenGL/raw/WGL/ARB/__pycache__/context_flush_control.cpython-312.pyc,, +OpenGL/raw/WGL/ARB/__pycache__/create_context.cpython-312.pyc,, +OpenGL/raw/WGL/ARB/__pycache__/create_context_no_error.cpython-312.pyc,, +OpenGL/raw/WGL/ARB/__pycache__/create_context_profile.cpython-312.pyc,, +OpenGL/raw/WGL/ARB/__pycache__/create_context_robustness.cpython-312.pyc,, +OpenGL/raw/WGL/ARB/__pycache__/extensions_string.cpython-312.pyc,, +OpenGL/raw/WGL/ARB/__pycache__/framebuffer_sRGB.cpython-312.pyc,, +OpenGL/raw/WGL/ARB/__pycache__/make_current_read.cpython-312.pyc,, +OpenGL/raw/WGL/ARB/__pycache__/multisample.cpython-312.pyc,, +OpenGL/raw/WGL/ARB/__pycache__/pbuffer.cpython-312.pyc,, +OpenGL/raw/WGL/ARB/__pycache__/pixel_format.cpython-312.pyc,, +OpenGL/raw/WGL/ARB/__pycache__/pixel_format_float.cpython-312.pyc,, +OpenGL/raw/WGL/ARB/__pycache__/render_texture.cpython-312.pyc,, +OpenGL/raw/WGL/ARB/__pycache__/robustness_application_isolation.cpython-312.pyc,, +OpenGL/raw/WGL/ARB/__pycache__/robustness_share_group_isolation.cpython-312.pyc,, +OpenGL/raw/WGL/ARB/buffer_region.py,sha256=CnAMAMPavXiqNhc7qIiGMi1uZyYNEHofDPoRJ7tKuyk,1282 +OpenGL/raw/WGL/ARB/context_flush_control.py,sha256=mDrE-YZoyrPxpJIx9RYi3F30V0FLB-tcrZgPgavy0Oo,772 +OpenGL/raw/WGL/ARB/create_context.py,sha256=lyjqMez7uUPlaxwgvN4bJ7d6_lr2PXQz5fzOml8lL5g,1139 +OpenGL/raw/WGL/ARB/create_context_no_error.py,sha256=01RXay_ZUKDPzPZegOMgi8pH1CyhEtAoLuZGQWdVl9o,599 +OpenGL/raw/WGL/ARB/create_context_profile.py,sha256=snAWEwCN8j87M_mzA2F1-NsM6y0owfLAmlEn-OOFuMg,840 +OpenGL/raw/WGL/ARB/create_context_robustness.py,sha256=t5XiNZEywVoJhkfV2TanbUtCDER2ZpuTk435QbZf-4E,858 +OpenGL/raw/WGL/ARB/extensions_string.py,sha256=n7ptRftD93GK7Ijh0uQkdbYQk0xe4Ddlc_wgn1WeAaM,589 +OpenGL/raw/WGL/ARB/framebuffer_sRGB.py,sha256=Nlo4Xz8SfYYx1vYy_YMJVIrUJBNSemTlcoguzWeLiK8,587 +OpenGL/raw/WGL/ARB/make_current_read.py,sha256=tTELzHP9h9BSn1kAklH-35j5IygG4fhgAzpp08mBLTk,836 +OpenGL/raw/WGL/ARB/multisample.py,sha256=AEZfPJHKYG3zhhGjkwACe3GjIK7uTBFx_kiJVTqRS-o,602 +OpenGL/raw/WGL/ARB/pbuffer.py,sha256=ZZwsa2bFBtJEXwYnbuQ5zA6Fu9XTuAKlYopln7qxWjY,1536 +OpenGL/raw/WGL/ARB/pixel_format.py,sha256=G7u5jtbnPUj1kUY9gJgu3BCy4kfDTpr_QXqxeou-CeY,4026 +OpenGL/raw/WGL/ARB/pixel_format_float.py,sha256=jVZKWU01AOX3hz8rYsJL0S4Yhagp94jjYjWpWv3UZYg,573 +OpenGL/raw/WGL/ARB/render_texture.py,sha256=sFQAl1ubsc0y4ansxMCJd0HekXBI4ZXtaL4x0Nl9dHk,2676 +OpenGL/raw/WGL/ARB/robustness_application_isolation.py,sha256=r4xzgYyScOqZWO1ztR63nJhNkVNoTeFrJyGaMhL7qqw,629 +OpenGL/raw/WGL/ARB/robustness_share_group_isolation.py,sha256=hF0cLxjQdQG-Ho8j4enEAxjOJWNNZGMmgnmQDOSLZqc,629 +OpenGL/raw/WGL/ATI/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/raw/WGL/ATI/__pycache__/__init__.cpython-312.pyc,, +OpenGL/raw/WGL/ATI/__pycache__/pixel_format_float.cpython-312.pyc,, +OpenGL/raw/WGL/ATI/__pycache__/render_texture_rectangle.cpython-312.pyc,, +OpenGL/raw/WGL/ATI/pixel_format_float.py,sha256=gIC381PediLoMGTEZXH73gPAE468d27Pq6DrWhl8JAg,573 +OpenGL/raw/WGL/ATI/render_texture_rectangle.py,sha256=TTUlx7pxr0sLMm7vLSdA6KFLU0EjUoLS-iW-leSY2Pw,589 +OpenGL/raw/WGL/DFX/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/raw/WGL/DFX/__pycache__/__init__.cpython-312.pyc,, +OpenGL/raw/WGL/DFX/__pycache__/multisample.cpython-312.pyc,, +OpenGL/raw/WGL/DFX/multisample.py,sha256=Iv8p52DfmtMyUcQ-zgOWwr0xRGzYKF7fceYsUKYL8QU,606 +OpenGL/raw/WGL/DL/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/raw/WGL/DL/__pycache__/__init__.cpython-312.pyc,, +OpenGL/raw/WGL/DL/__pycache__/stereo_control.cpython-312.pyc,, +OpenGL/raw/WGL/DL/stereo_control.py,sha256=uA1-fVxjcAWb2g4uz78osOrwQwtbSZP_9CETohpMCi8,889 +OpenGL/raw/WGL/EXT/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/raw/WGL/EXT/__pycache__/__init__.cpython-312.pyc,, +OpenGL/raw/WGL/EXT/__pycache__/colorspace.cpython-312.pyc,, +OpenGL/raw/WGL/EXT/__pycache__/create_context_es2_profile.cpython-312.pyc,, +OpenGL/raw/WGL/EXT/__pycache__/create_context_es_profile.cpython-312.pyc,, +OpenGL/raw/WGL/EXT/__pycache__/depth_float.cpython-312.pyc,, +OpenGL/raw/WGL/EXT/__pycache__/display_color_table.cpython-312.pyc,, +OpenGL/raw/WGL/EXT/__pycache__/extensions_string.cpython-312.pyc,, +OpenGL/raw/WGL/EXT/__pycache__/framebuffer_sRGB.cpython-312.pyc,, +OpenGL/raw/WGL/EXT/__pycache__/make_current_read.cpython-312.pyc,, +OpenGL/raw/WGL/EXT/__pycache__/multisample.cpython-312.pyc,, +OpenGL/raw/WGL/EXT/__pycache__/pbuffer.cpython-312.pyc,, +OpenGL/raw/WGL/EXT/__pycache__/pixel_format.cpython-312.pyc,, +OpenGL/raw/WGL/EXT/__pycache__/pixel_format_packed_float.cpython-312.pyc,, +OpenGL/raw/WGL/EXT/__pycache__/swap_control.cpython-312.pyc,, +OpenGL/raw/WGL/EXT/__pycache__/swap_control_tear.cpython-312.pyc,, +OpenGL/raw/WGL/EXT/colorspace.py,sha256=FHIVc8xRB5-1wnXn6bsIOhA4Dwq74Mlow0MamZIPfdg,673 +OpenGL/raw/WGL/EXT/create_context_es2_profile.py,sha256=JuN_8-p4DHcK6isG6y2HiMgnlNXS_aD1gUxpZ7Pk3Gg,609 +OpenGL/raw/WGL/EXT/create_context_es_profile.py,sha256=bvb8vSfCaNLUi8zKrrjyHnvdwQB1KGSVt7ZEIGh2lW0,605 +OpenGL/raw/WGL/EXT/depth_float.py,sha256=0wtg6l8S1gZ_bEDtmWSNAgtcrMgTj81mIxOtVx_Cxao,551 +OpenGL/raw/WGL/EXT/display_color_table.py,sha256=dq1FC1M3ppakbOVlt_v3zz4NO1K5b6jZteXlpobYOBU,875 +OpenGL/raw/WGL/EXT/extensions_string.py,sha256=7JsdYSJsH249WM9uQ7tBDmrw44wEjuxEQIhLxCigoX0,579 +OpenGL/raw/WGL/EXT/framebuffer_sRGB.py,sha256=f30jHDo_SVVCmnG4U0AodBDnS7YwhMQFYuWGSEotXNQ,587 +OpenGL/raw/WGL/EXT/make_current_read.py,sha256=zEmJ3LcqdUuAhENZAL_0Qk6fJqQRMe7HQcOGYC9hm2s,745 +OpenGL/raw/WGL/EXT/multisample.py,sha256=UZ5e3D0dRzjqlUhagRwwVw7xvNUZ_-eDABEPuS-X0wY,602 +OpenGL/raw/WGL/EXT/pbuffer.py,sha256=9nbcvzjSGOeCTsELZKNKvuXWZmQCOH0ttU9ixNGHKzI,1629 +OpenGL/raw/WGL/EXT/pixel_format.py,sha256=bmlKsXiYNjdP642md5J4w-bUScuB351uL_idPQwLg6g,3712 +OpenGL/raw/WGL/EXT/pixel_format_packed_float.py,sha256=Hp5QSm1_w_my5XJ79GrRsWgTD_uPO7y0vGKLLc3VBhs,605 +OpenGL/raw/WGL/EXT/swap_control.py,sha256=CEjx3RWd6GiRcWxYmsPMsEY5_ulnR5PUjWWtiV8gEys,631 +OpenGL/raw/WGL/EXT/swap_control_tear.py,sha256=gfY16pK0FF8V9LtgGifM69jhk12x2JAvNQkWe9j3J0o,511 +OpenGL/raw/WGL/I3D/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/raw/WGL/I3D/__pycache__/__init__.cpython-312.pyc,, +OpenGL/raw/WGL/I3D/__pycache__/digital_video_control.cpython-312.pyc,, +OpenGL/raw/WGL/I3D/__pycache__/gamma.cpython-312.pyc,, +OpenGL/raw/WGL/I3D/__pycache__/genlock.cpython-312.pyc,, +OpenGL/raw/WGL/I3D/__pycache__/image_buffer.cpython-312.pyc,, +OpenGL/raw/WGL/I3D/__pycache__/swap_frame_lock.cpython-312.pyc,, +OpenGL/raw/WGL/I3D/__pycache__/swap_frame_usage.cpython-312.pyc,, +OpenGL/raw/WGL/I3D/digital_video_control.py,sha256=P6HTTMshRzMuwi-IqORZBG9v5VVDAimENOZRiD6F6yI,1163 +OpenGL/raw/WGL/I3D/gamma.py,sha256=1CNAlVLtlH1X_z4dZaCpimpBFKc9x1RxAR0dU0_-FXE,1257 +OpenGL/raw/WGL/I3D/genlock.py,sha256=QiCx1NgmWM6hfvGU9Wg0-R39QiOOFF53WuUzVfqd-yQ,2395 +OpenGL/raw/WGL/I3D/image_buffer.py,sha256=eJ9dY94R0LR5LKuwoDVe1bzncG9x5R2elbjBRRaFQ8A,1169 +OpenGL/raw/WGL/I3D/swap_frame_lock.py,sha256=1quDjSvDmMivw53KpkEgvpw6srADf1SdFeYL-gRpLVs,805 +OpenGL/raw/WGL/I3D/swap_frame_usage.py,sha256=kKDUIcqcTee5ntFX2ZgP0IPpRYFmTk0iAd2OKTvdAGM,883 +OpenGL/raw/WGL/NV/DX_interop.py,sha256=daUPfpn4eCwl_whZzDb783bB29RT9RCYLT-3mRqbB8Y,1550 +OpenGL/raw/WGL/NV/DX_interop2.py,sha256=pm8gJ96ZQ5xjax_GpQ9XVZKAYXMV7wl0k7D7GIUpXsg,497 +OpenGL/raw/WGL/NV/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/raw/WGL/NV/__pycache__/DX_interop.cpython-312.pyc,, +OpenGL/raw/WGL/NV/__pycache__/DX_interop2.cpython-312.pyc,, +OpenGL/raw/WGL/NV/__pycache__/__init__.cpython-312.pyc,, +OpenGL/raw/WGL/NV/__pycache__/copy_image.cpython-312.pyc,, +OpenGL/raw/WGL/NV/__pycache__/delay_before_swap.cpython-312.pyc,, +OpenGL/raw/WGL/NV/__pycache__/float_buffer.cpython-312.pyc,, +OpenGL/raw/WGL/NV/__pycache__/gpu_affinity.cpython-312.pyc,, +OpenGL/raw/WGL/NV/__pycache__/multigpu_context.cpython-312.pyc,, +OpenGL/raw/WGL/NV/__pycache__/multisample_coverage.cpython-312.pyc,, +OpenGL/raw/WGL/NV/__pycache__/present_video.cpython-312.pyc,, +OpenGL/raw/WGL/NV/__pycache__/render_depth_texture.cpython-312.pyc,, +OpenGL/raw/WGL/NV/__pycache__/render_texture_rectangle.cpython-312.pyc,, +OpenGL/raw/WGL/NV/__pycache__/swap_group.cpython-312.pyc,, +OpenGL/raw/WGL/NV/__pycache__/vertex_array_range.cpython-312.pyc,, +OpenGL/raw/WGL/NV/__pycache__/video_capture.cpython-312.pyc,, +OpenGL/raw/WGL/NV/__pycache__/video_output.cpython-312.pyc,, +OpenGL/raw/WGL/NV/copy_image.py,sha256=vE5wXF-5LUYkXv9ouhwbNZTTFVHxkSKKdsNfyHmr_qc,847 +OpenGL/raw/WGL/NV/delay_before_swap.py,sha256=SRquROZt5yjEAoYNfP-I24yoKGSgAJUej9p-VE3J-KU,595 +OpenGL/raw/WGL/NV/float_buffer.py,sha256=GAw_mlauMz1KUqR_3sHHsJHou7eN5TVYXg-DC3sHcNQ,1199 +OpenGL/raw/WGL/NV/gpu_affinity.py,sha256=MmH2Y0gjj9rmsMo455SMr2y9qgZQZ-aGy_i7K570_qk,1164 +OpenGL/raw/WGL/NV/multigpu_context.py,sha256=6ag9RXWkTvLaNtNVQ4VtrAxPXGV3llN64RarqxEXb0A,971 +OpenGL/raw/WGL/NV/multisample_coverage.py,sha256=G-BQSgnsxlMhwFpJNATcTAA5hCECivgknDPIRxa-uSE,630 +OpenGL/raw/WGL/NV/present_video.py,sha256=BkCgL3U5NQTwc2vSKAEdqS0V8uuKSwzSAEBQCOavntA,966 +OpenGL/raw/WGL/NV/render_depth_texture.py,sha256=dpnqEUmW-h0tSsahqMbUoDa5lwrUIbamVBtdGZeZJr8,879 +OpenGL/raw/WGL/NV/render_texture_rectangle.py,sha256=bSV7O4gwrHBGdh1FZNr0YIzg4L09a9I94vpQJiXn5ZU,761 +OpenGL/raw/WGL/NV/swap_group.py,sha256=IQvYuor6C5yPEyZmaYNZL1ZP4qcC4hsYtj68etqsEiY,1074 +OpenGL/raw/WGL/NV/vertex_array_range.py,sha256=95vX5FqKe7xfBLca9Z1qGRPf51nixrfZDpkNvsvZeVs,722 +OpenGL/raw/WGL/NV/video_capture.py,sha256=-YQWP0eDLUvGLgmzTNOeH87Ckck3WdMgjQJ0-ZOQGj8,1245 +OpenGL/raw/WGL/NV/video_output.py,sha256=7vasR2HvrO5Q_mNTRROoA8hsUCYy_PuiJ6jhDHLrDBk,2170 +OpenGL/raw/WGL/OML/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/raw/WGL/OML/__pycache__/__init__.cpython-312.pyc,, +OpenGL/raw/WGL/OML/__pycache__/sync_control.cpython-312.pyc,, +OpenGL/raw/WGL/OML/sync_control.py,sha256=VTX48IuSrYuZ0pgrLtpaN0LYO8EqBclLjjG33fBQ4pI,1455 +OpenGL/raw/WGL/VERSION/WGL_1_0.py,sha256=UYjo8dxOyNOjn1FnoQr__PWc7VWaDiUH_g6uqesCrbk,5237 +OpenGL/raw/WGL/VERSION/__init__.py,sha256=rXV_eFW_EDg7wkZT0NRFqsWOAvJ4MxqK0y7yfO-xIEs,23 +OpenGL/raw/WGL/VERSION/__pycache__/WGL_1_0.cpython-312.pyc,, +OpenGL/raw/WGL/VERSION/__pycache__/__init__.cpython-312.pyc,, +OpenGL/raw/WGL/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +OpenGL/raw/WGL/__pycache__/__init__.cpython-312.pyc,, +OpenGL/raw/WGL/__pycache__/_errors.cpython-312.pyc,, +OpenGL/raw/WGL/__pycache__/_glgets.cpython-312.pyc,, +OpenGL/raw/WGL/__pycache__/_types.cpython-312.pyc,, +OpenGL/raw/WGL/_errors.py,sha256=TY-UCVF_scJtXJiE7jZ7EzI5Eq0q7KDa0CCSoc0WuTc,65 +OpenGL/raw/WGL/_glgets.py,sha256=pdbDplGI61RlSwbxPgFPDuLPgWbQzMu8XaofqtPw2B8,279 +OpenGL/raw/WGL/_types.py,sha256=Q09-nWd6fwIKNbNKtRuQuWGBtTXX9Bci80EyB36iaJ8,9386 +OpenGL/raw/__init__.py,sha256=X7TOvLJYUh2kxuSlevZZsVDj_KhtUgvYgOrJBfiU6HI,222 +OpenGL/raw/__pycache__/__init__.cpython-312.pyc,, +OpenGL/raw/osmesa/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +OpenGL/raw/osmesa/__pycache__/__init__.cpython-312.pyc,, +OpenGL/raw/osmesa/__pycache__/_types.cpython-312.pyc,, +OpenGL/raw/osmesa/__pycache__/mesa.cpython-312.pyc,, +OpenGL/raw/osmesa/_types.py,sha256=DBL8jUYaP7J7yJcOFOMRJujFXMW6gq6vQ-41gHhDbgU,233 +OpenGL/raw/osmesa/mesa.py,sha256=3RVhCQHOPLG-doiCUmint8LcsVjf4jyS4j0FpS8ncps,4958 +OpenGL/version.py,sha256=cEnKVAo4HjbtuPuHN7wMHk6gjX49Wi3OzALnU50Ti1I,92 +OpenGL/wrapper.py,sha256=fHlTOjfxUOVVjwzt90fzR8kwQLVvt9BjIRjPpQjuXUQ,74874 +PyOpenGL-3.1.7.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4 +PyOpenGL-3.1.7.dist-info/METADATA,sha256=6yghG79MVecw7cMBjawJ8NkZZakU4-dPk-_qYDRmSJc,3159 +PyOpenGL-3.1.7.dist-info/RECORD,, +PyOpenGL-3.1.7.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +PyOpenGL-3.1.7.dist-info/WHEEL,sha256=pkctZYzUS4AYVn6dJ-7367OJZivF2e8RA9b_ZBjif18,92 +PyOpenGL-3.1.7.dist-info/top_level.txt,sha256=45QHLHukmPY076bb7HlU9pLoE41t1I-S_hAwokgqMQs,7 diff --git a/venv/lib/python3.12/site-packages/PyOpenGL-3.1.7.dist-info/REQUESTED b/venv/lib/python3.12/site-packages/PyOpenGL-3.1.7.dist-info/REQUESTED new file mode 100644 index 00000000..e69de29b diff --git a/venv/lib/python3.12/site-packages/PyOpenGL-3.1.7.dist-info/WHEEL b/venv/lib/python3.12/site-packages/PyOpenGL-3.1.7.dist-info/WHEEL new file mode 100644 index 00000000..1f37c02f --- /dev/null +++ b/venv/lib/python3.12/site-packages/PyOpenGL-3.1.7.dist-info/WHEEL @@ -0,0 +1,5 @@ +Wheel-Version: 1.0 +Generator: bdist_wheel (0.40.0) +Root-Is-Purelib: true +Tag: py3-none-any + diff --git a/venv/lib/python3.12/site-packages/PyOpenGL-3.1.7.dist-info/top_level.txt b/venv/lib/python3.12/site-packages/PyOpenGL-3.1.7.dist-info/top_level.txt new file mode 100644 index 00000000..dcc2329d --- /dev/null +++ b/venv/lib/python3.12/site-packages/PyOpenGL-3.1.7.dist-info/top_level.txt @@ -0,0 +1 @@ +OpenGL diff --git a/venv/lib/python3.12/site-packages/_cffi_backend.cpython-312-darwin.so b/venv/lib/python3.12/site-packages/_cffi_backend.cpython-312-darwin.so new file mode 100755 index 00000000..06106f4a Binary files /dev/null and b/venv/lib/python3.12/site-packages/_cffi_backend.cpython-312-darwin.so differ diff --git a/venv/lib/python3.12/site-packages/cffi-1.17.1.dist-info/INSTALLER b/venv/lib/python3.12/site-packages/cffi-1.17.1.dist-info/INSTALLER new file mode 100644 index 00000000..a1b589e3 --- /dev/null +++ b/venv/lib/python3.12/site-packages/cffi-1.17.1.dist-info/INSTALLER @@ -0,0 +1 @@ +pip diff --git a/venv/lib/python3.12/site-packages/cffi-1.17.1.dist-info/LICENSE b/venv/lib/python3.12/site-packages/cffi-1.17.1.dist-info/LICENSE new file mode 100644 index 00000000..29225eee --- /dev/null +++ b/venv/lib/python3.12/site-packages/cffi-1.17.1.dist-info/LICENSE @@ -0,0 +1,26 @@ + +Except when otherwise stated (look for LICENSE files in directories or +information at the beginning of each file) all software and +documentation is licensed as follows: + + The MIT License + + Permission is hereby granted, free of charge, to any person + obtaining a copy of this software and associated documentation + files (the "Software"), to deal in the Software without + restriction, including without limitation the rights to use, + copy, modify, merge, publish, distribute, sublicense, and/or + sell copies of the Software, and to permit persons to whom the + Software is furnished to do so, subject to the following conditions: + + The above copyright notice and this permission notice shall be included + in all copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + DEALINGS IN THE SOFTWARE. + diff --git a/venv/lib/python3.12/site-packages/cffi-1.17.1.dist-info/METADATA b/venv/lib/python3.12/site-packages/cffi-1.17.1.dist-info/METADATA new file mode 100644 index 00000000..60b0779f --- /dev/null +++ b/venv/lib/python3.12/site-packages/cffi-1.17.1.dist-info/METADATA @@ -0,0 +1,40 @@ +Metadata-Version: 2.1 +Name: cffi +Version: 1.17.1 +Summary: Foreign Function Interface for Python calling C code. +Home-page: http://cffi.readthedocs.org +Author: Armin Rigo, Maciej Fijalkowski +Author-email: python-cffi@googlegroups.com +License: MIT +Project-URL: Documentation, http://cffi.readthedocs.org/ +Project-URL: Source Code, https://github.com/python-cffi/cffi +Project-URL: Issue Tracker, https://github.com/python-cffi/cffi/issues +Project-URL: Changelog, https://cffi.readthedocs.io/en/latest/whatsnew.html +Project-URL: Downloads, https://github.com/python-cffi/cffi/releases +Project-URL: Contact, https://groups.google.com/forum/#!forum/python-cffi +Classifier: Programming Language :: Python +Classifier: Programming Language :: Python :: 3 +Classifier: Programming Language :: Python :: 3.8 +Classifier: Programming Language :: Python :: 3.9 +Classifier: Programming Language :: Python :: 3.10 +Classifier: Programming Language :: Python :: 3.11 +Classifier: Programming Language :: Python :: 3.12 +Classifier: Programming Language :: Python :: 3.13 +Classifier: Programming Language :: Python :: Implementation :: CPython +Classifier: Programming Language :: Python :: Implementation :: PyPy +Classifier: License :: OSI Approved :: MIT License +Requires-Python: >=3.8 +License-File: LICENSE +Requires-Dist: pycparser + + +CFFI +==== + +Foreign Function Interface for Python calling C code. +Please see the `Documentation `_. + +Contact +------- + +`Mailing list `_ diff --git a/venv/lib/python3.12/site-packages/cffi-1.17.1.dist-info/RECORD b/venv/lib/python3.12/site-packages/cffi-1.17.1.dist-info/RECORD new file mode 100644 index 00000000..bdbc3abd --- /dev/null +++ b/venv/lib/python3.12/site-packages/cffi-1.17.1.dist-info/RECORD @@ -0,0 +1,48 @@ +_cffi_backend.cpython-312-darwin.so,sha256=6qy9gp_c20Aj_LcOa3eGCDoFKFd_GQEqAWVpKZ1LlJs,212672 +cffi-1.17.1.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4 +cffi-1.17.1.dist-info/LICENSE,sha256=BLgPWwd7vtaICM_rreteNSPyqMmpZJXFh72W3x6sKjM,1294 +cffi-1.17.1.dist-info/METADATA,sha256=u6nuvP_qPJKu2zvIbi2zkGzVu7KjnnRIYUFyIrOY3j4,1531 +cffi-1.17.1.dist-info/RECORD,, +cffi-1.17.1.dist-info/WHEEL,sha256=9HYhHBSXqQgNvT0g8jACTyEC8IDg99GXAmWMPaX5RAo,109 +cffi-1.17.1.dist-info/entry_points.txt,sha256=y6jTxnyeuLnL-XJcDv8uML3n6wyYiGRg8MTp_QGJ9Ho,75 +cffi-1.17.1.dist-info/top_level.txt,sha256=rE7WR3rZfNKxWI9-jn6hsHCAl7MDkB-FmuQbxWjFehQ,19 +cffi/__init__.py,sha256=H6t_ebva6EeHpUuItFLW1gbRp94eZRNJODLaWKdbx1I,513 +cffi/__pycache__/__init__.cpython-312.pyc,, +cffi/__pycache__/_imp_emulation.cpython-312.pyc,, +cffi/__pycache__/_shimmed_dist_utils.cpython-312.pyc,, +cffi/__pycache__/api.cpython-312.pyc,, +cffi/__pycache__/backend_ctypes.cpython-312.pyc,, +cffi/__pycache__/cffi_opcode.cpython-312.pyc,, +cffi/__pycache__/commontypes.cpython-312.pyc,, +cffi/__pycache__/cparser.cpython-312.pyc,, +cffi/__pycache__/error.cpython-312.pyc,, +cffi/__pycache__/ffiplatform.cpython-312.pyc,, +cffi/__pycache__/lock.cpython-312.pyc,, +cffi/__pycache__/model.cpython-312.pyc,, +cffi/__pycache__/pkgconfig.cpython-312.pyc,, +cffi/__pycache__/recompiler.cpython-312.pyc,, +cffi/__pycache__/setuptools_ext.cpython-312.pyc,, +cffi/__pycache__/vengine_cpy.cpython-312.pyc,, +cffi/__pycache__/vengine_gen.cpython-312.pyc,, +cffi/__pycache__/verifier.cpython-312.pyc,, +cffi/_cffi_errors.h,sha256=zQXt7uR_m8gUW-fI2hJg0KoSkJFwXv8RGUkEDZ177dQ,3908 +cffi/_cffi_include.h,sha256=Exhmgm9qzHWzWivjfTe0D7Xp4rPUkVxdNuwGhMTMzbw,15055 +cffi/_embedding.h,sha256=EDKw5QrLvQoe3uosXB3H1xPVTYxsn33eV3A43zsA_Fw,18787 +cffi/_imp_emulation.py,sha256=RxREG8zAbI2RPGBww90u_5fi8sWdahpdipOoPzkp7C0,2960 +cffi/_shimmed_dist_utils.py,sha256=Bjj2wm8yZbvFvWEx5AEfmqaqZyZFhYfoyLLQHkXZuao,2230 +cffi/api.py,sha256=alBv6hZQkjpmZplBphdaRn2lPO9-CORs_M7ixabvZWI,42169 +cffi/backend_ctypes.py,sha256=h5ZIzLc6BFVXnGyc9xPqZWUS7qGy7yFSDqXe68Sa8z4,42454 +cffi/cffi_opcode.py,sha256=JDV5l0R0_OadBX_uE7xPPTYtMdmpp8I9UYd6av7aiDU,5731 +cffi/commontypes.py,sha256=7N6zPtCFlvxXMWhHV08psUjdYIK2XgsN3yo5dgua_v4,2805 +cffi/cparser.py,sha256=0qI3mEzZSNVcCangoyXOoAcL-RhpQL08eG8798T024s,44789 +cffi/error.py,sha256=v6xTiS4U0kvDcy4h_BDRo5v39ZQuj-IMRYLv5ETddZs,877 +cffi/ffiplatform.py,sha256=avxFjdikYGJoEtmJO7ewVmwG_VEVl6EZ_WaNhZYCqv4,3584 +cffi/lock.py,sha256=l9TTdwMIMpi6jDkJGnQgE9cvTIR7CAntIJr8EGHt3pY,747 +cffi/model.py,sha256=W30UFQZE73jL5Mx5N81YT77us2W2iJjTm0XYfnwz1cg,21797 +cffi/parse_c_type.h,sha256=OdwQfwM9ktq6vlCB43exFQmxDBtj2MBNdK8LYl15tjw,5976 +cffi/pkgconfig.py,sha256=LP1w7vmWvmKwyqLaU1Z243FOWGNQMrgMUZrvgFuOlco,4374 +cffi/recompiler.py,sha256=sim4Tm7lamt2Jn8uzKN0wMYp6ODByk3g7of47-h9LD4,65367 +cffi/setuptools_ext.py,sha256=-ebj79lO2_AUH-kRcaja2pKY1Z_5tloGwsJgzK8P3Cc,8871 +cffi/vengine_cpy.py,sha256=8UagT6ZEOZf6Dju7_CfNulue8CnsHLEzJYhnqUhoF04,43752 +cffi/vengine_gen.py,sha256=DUlEIrDiVin1Pnhn1sfoamnS5NLqfJcOdhRoeSNeJRg,26939 +cffi/verifier.py,sha256=oX8jpaohg2Qm3aHcznidAdvrVm5N4sQYG0a3Eo5mIl4,11182 diff --git a/venv/lib/python3.12/site-packages/cffi-1.17.1.dist-info/WHEEL b/venv/lib/python3.12/site-packages/cffi-1.17.1.dist-info/WHEEL new file mode 100644 index 00000000..f9771d91 --- /dev/null +++ b/venv/lib/python3.12/site-packages/cffi-1.17.1.dist-info/WHEEL @@ -0,0 +1,5 @@ +Wheel-Version: 1.0 +Generator: setuptools (74.1.1) +Root-Is-Purelib: false +Tag: cp312-cp312-macosx_11_0_arm64 + diff --git a/venv/lib/python3.12/site-packages/cffi-1.17.1.dist-info/entry_points.txt b/venv/lib/python3.12/site-packages/cffi-1.17.1.dist-info/entry_points.txt new file mode 100644 index 00000000..4b0274f2 --- /dev/null +++ b/venv/lib/python3.12/site-packages/cffi-1.17.1.dist-info/entry_points.txt @@ -0,0 +1,2 @@ +[distutils.setup_keywords] +cffi_modules = cffi.setuptools_ext:cffi_modules diff --git a/venv/lib/python3.12/site-packages/cffi-1.17.1.dist-info/top_level.txt b/venv/lib/python3.12/site-packages/cffi-1.17.1.dist-info/top_level.txt new file mode 100644 index 00000000..f6457795 --- /dev/null +++ b/venv/lib/python3.12/site-packages/cffi-1.17.1.dist-info/top_level.txt @@ -0,0 +1,2 @@ +_cffi_backend +cffi diff --git a/venv/lib/python3.12/site-packages/cffi/__init__.py b/venv/lib/python3.12/site-packages/cffi/__init__.py new file mode 100644 index 00000000..2e35a38c --- /dev/null +++ b/venv/lib/python3.12/site-packages/cffi/__init__.py @@ -0,0 +1,14 @@ +__all__ = ['FFI', 'VerificationError', 'VerificationMissing', 'CDefError', + 'FFIError'] + +from .api import FFI +from .error import CDefError, FFIError, VerificationError, VerificationMissing +from .error import PkgConfigError + +__version__ = "1.17.1" +__version_info__ = (1, 17, 1) + +# The verifier module file names are based on the CRC32 of a string that +# contains the following version number. It may be older than __version__ +# if nothing is clearly incompatible. +__version_verifier_modules__ = "0.8.6" diff --git a/venv/lib/python3.12/site-packages/cffi/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/cffi/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..784be864 Binary files /dev/null and b/venv/lib/python3.12/site-packages/cffi/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/cffi/__pycache__/_imp_emulation.cpython-312.pyc b/venv/lib/python3.12/site-packages/cffi/__pycache__/_imp_emulation.cpython-312.pyc new file mode 100644 index 00000000..55bef9ac Binary files /dev/null and b/venv/lib/python3.12/site-packages/cffi/__pycache__/_imp_emulation.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/cffi/__pycache__/_shimmed_dist_utils.cpython-312.pyc b/venv/lib/python3.12/site-packages/cffi/__pycache__/_shimmed_dist_utils.cpython-312.pyc new file mode 100644 index 00000000..3db2c580 Binary files /dev/null and b/venv/lib/python3.12/site-packages/cffi/__pycache__/_shimmed_dist_utils.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/cffi/__pycache__/api.cpython-312.pyc b/venv/lib/python3.12/site-packages/cffi/__pycache__/api.cpython-312.pyc new file mode 100644 index 00000000..7b8f7055 Binary files /dev/null and b/venv/lib/python3.12/site-packages/cffi/__pycache__/api.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/cffi/__pycache__/backend_ctypes.cpython-312.pyc b/venv/lib/python3.12/site-packages/cffi/__pycache__/backend_ctypes.cpython-312.pyc new file mode 100644 index 00000000..7c7f8f86 Binary files /dev/null and b/venv/lib/python3.12/site-packages/cffi/__pycache__/backend_ctypes.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/cffi/__pycache__/cffi_opcode.cpython-312.pyc b/venv/lib/python3.12/site-packages/cffi/__pycache__/cffi_opcode.cpython-312.pyc new file mode 100644 index 00000000..59e0f2a9 Binary files /dev/null and b/venv/lib/python3.12/site-packages/cffi/__pycache__/cffi_opcode.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/cffi/__pycache__/commontypes.cpython-312.pyc b/venv/lib/python3.12/site-packages/cffi/__pycache__/commontypes.cpython-312.pyc new file mode 100644 index 00000000..c463b04c Binary files /dev/null and b/venv/lib/python3.12/site-packages/cffi/__pycache__/commontypes.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/cffi/__pycache__/cparser.cpython-312.pyc b/venv/lib/python3.12/site-packages/cffi/__pycache__/cparser.cpython-312.pyc new file mode 100644 index 00000000..8e4dbb0f Binary files /dev/null and b/venv/lib/python3.12/site-packages/cffi/__pycache__/cparser.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/cffi/__pycache__/error.cpython-312.pyc b/venv/lib/python3.12/site-packages/cffi/__pycache__/error.cpython-312.pyc new file mode 100644 index 00000000..6f485569 Binary files /dev/null and b/venv/lib/python3.12/site-packages/cffi/__pycache__/error.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/cffi/__pycache__/ffiplatform.cpython-312.pyc b/venv/lib/python3.12/site-packages/cffi/__pycache__/ffiplatform.cpython-312.pyc new file mode 100644 index 00000000..b29d8fbf Binary files /dev/null and b/venv/lib/python3.12/site-packages/cffi/__pycache__/ffiplatform.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/cffi/__pycache__/lock.cpython-312.pyc b/venv/lib/python3.12/site-packages/cffi/__pycache__/lock.cpython-312.pyc new file mode 100644 index 00000000..d211c048 Binary files /dev/null and b/venv/lib/python3.12/site-packages/cffi/__pycache__/lock.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/cffi/__pycache__/model.cpython-312.pyc b/venv/lib/python3.12/site-packages/cffi/__pycache__/model.cpython-312.pyc new file mode 100644 index 00000000..368b7035 Binary files /dev/null and b/venv/lib/python3.12/site-packages/cffi/__pycache__/model.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/cffi/__pycache__/pkgconfig.cpython-312.pyc b/venv/lib/python3.12/site-packages/cffi/__pycache__/pkgconfig.cpython-312.pyc new file mode 100644 index 00000000..24ec4d2d Binary files /dev/null and b/venv/lib/python3.12/site-packages/cffi/__pycache__/pkgconfig.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/cffi/__pycache__/recompiler.cpython-312.pyc b/venv/lib/python3.12/site-packages/cffi/__pycache__/recompiler.cpython-312.pyc new file mode 100644 index 00000000..26e4827b Binary files /dev/null and b/venv/lib/python3.12/site-packages/cffi/__pycache__/recompiler.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/cffi/__pycache__/setuptools_ext.cpython-312.pyc b/venv/lib/python3.12/site-packages/cffi/__pycache__/setuptools_ext.cpython-312.pyc new file mode 100644 index 00000000..703ebdba Binary files /dev/null and b/venv/lib/python3.12/site-packages/cffi/__pycache__/setuptools_ext.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/cffi/__pycache__/vengine_cpy.cpython-312.pyc b/venv/lib/python3.12/site-packages/cffi/__pycache__/vengine_cpy.cpython-312.pyc new file mode 100644 index 00000000..134ff7d4 Binary files /dev/null and b/venv/lib/python3.12/site-packages/cffi/__pycache__/vengine_cpy.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/cffi/__pycache__/vengine_gen.cpython-312.pyc b/venv/lib/python3.12/site-packages/cffi/__pycache__/vengine_gen.cpython-312.pyc new file mode 100644 index 00000000..1c4f0a83 Binary files /dev/null and b/venv/lib/python3.12/site-packages/cffi/__pycache__/vengine_gen.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/cffi/__pycache__/verifier.cpython-312.pyc b/venv/lib/python3.12/site-packages/cffi/__pycache__/verifier.cpython-312.pyc new file mode 100644 index 00000000..ff136b1b Binary files /dev/null and b/venv/lib/python3.12/site-packages/cffi/__pycache__/verifier.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/cffi/_cffi_errors.h b/venv/lib/python3.12/site-packages/cffi/_cffi_errors.h new file mode 100644 index 00000000..158e0590 --- /dev/null +++ b/venv/lib/python3.12/site-packages/cffi/_cffi_errors.h @@ -0,0 +1,149 @@ +#ifndef CFFI_MESSAGEBOX +# ifdef _MSC_VER +# define CFFI_MESSAGEBOX 1 +# else +# define CFFI_MESSAGEBOX 0 +# endif +#endif + + +#if CFFI_MESSAGEBOX +/* Windows only: logic to take the Python-CFFI embedding logic + initialization errors and display them in a background thread + with MessageBox. The idea is that if the whole program closes + as a result of this problem, then likely it is already a console + program and you can read the stderr output in the console too. + If it is not a console program, then it will likely show its own + dialog to complain, or generally not abruptly close, and for this + case the background thread should stay alive. +*/ +static void *volatile _cffi_bootstrap_text; + +static PyObject *_cffi_start_error_capture(void) +{ + PyObject *result = NULL; + PyObject *x, *m, *bi; + + if (InterlockedCompareExchangePointer(&_cffi_bootstrap_text, + (void *)1, NULL) != NULL) + return (PyObject *)1; + + m = PyImport_AddModule("_cffi_error_capture"); + if (m == NULL) + goto error; + + result = PyModule_GetDict(m); + if (result == NULL) + goto error; + +#if PY_MAJOR_VERSION >= 3 + bi = PyImport_ImportModule("builtins"); +#else + bi = PyImport_ImportModule("__builtin__"); +#endif + if (bi == NULL) + goto error; + PyDict_SetItemString(result, "__builtins__", bi); + Py_DECREF(bi); + + x = PyRun_String( + "import sys\n" + "class FileLike:\n" + " def write(self, x):\n" + " try:\n" + " of.write(x)\n" + " except: pass\n" + " self.buf += x\n" + " def flush(self):\n" + " pass\n" + "fl = FileLike()\n" + "fl.buf = ''\n" + "of = sys.stderr\n" + "sys.stderr = fl\n" + "def done():\n" + " sys.stderr = of\n" + " return fl.buf\n", /* make sure the returned value stays alive */ + Py_file_input, + result, result); + Py_XDECREF(x); + + error: + if (PyErr_Occurred()) + { + PyErr_WriteUnraisable(Py_None); + PyErr_Clear(); + } + return result; +} + +#pragma comment(lib, "user32.lib") + +static DWORD WINAPI _cffi_bootstrap_dialog(LPVOID ignored) +{ + Sleep(666); /* may be interrupted if the whole process is closing */ +#if PY_MAJOR_VERSION >= 3 + MessageBoxW(NULL, (wchar_t *)_cffi_bootstrap_text, + L"Python-CFFI error", + MB_OK | MB_ICONERROR); +#else + MessageBoxA(NULL, (char *)_cffi_bootstrap_text, + "Python-CFFI error", + MB_OK | MB_ICONERROR); +#endif + _cffi_bootstrap_text = NULL; + return 0; +} + +static void _cffi_stop_error_capture(PyObject *ecap) +{ + PyObject *s; + void *text; + + if (ecap == (PyObject *)1) + return; + + if (ecap == NULL) + goto error; + + s = PyRun_String("done()", Py_eval_input, ecap, ecap); + if (s == NULL) + goto error; + + /* Show a dialog box, but in a background thread, and + never show multiple dialog boxes at once. */ +#if PY_MAJOR_VERSION >= 3 + text = PyUnicode_AsWideCharString(s, NULL); +#else + text = PyString_AsString(s); +#endif + + _cffi_bootstrap_text = text; + + if (text != NULL) + { + HANDLE h; + h = CreateThread(NULL, 0, _cffi_bootstrap_dialog, + NULL, 0, NULL); + if (h != NULL) + CloseHandle(h); + } + /* decref the string, but it should stay alive as 'fl.buf' + in the small module above. It will really be freed only if + we later get another similar error. So it's a leak of at + most one copy of the small module. That's fine for this + situation which is usually a "fatal error" anyway. */ + Py_DECREF(s); + PyErr_Clear(); + return; + + error: + _cffi_bootstrap_text = NULL; + PyErr_Clear(); +} + +#else + +static PyObject *_cffi_start_error_capture(void) { return NULL; } +static void _cffi_stop_error_capture(PyObject *ecap) { } + +#endif diff --git a/venv/lib/python3.12/site-packages/cffi/_cffi_include.h b/venv/lib/python3.12/site-packages/cffi/_cffi_include.h new file mode 100644 index 00000000..908a1d73 --- /dev/null +++ b/venv/lib/python3.12/site-packages/cffi/_cffi_include.h @@ -0,0 +1,389 @@ +#define _CFFI_ + +/* We try to define Py_LIMITED_API before including Python.h. + + Mess: we can only define it if Py_DEBUG, Py_TRACE_REFS and + Py_REF_DEBUG are not defined. This is a best-effort approximation: + we can learn about Py_DEBUG from pyconfig.h, but it is unclear if + the same works for the other two macros. Py_DEBUG implies them, + but not the other way around. + + The implementation is messy (issue #350): on Windows, with _MSC_VER, + we have to define Py_LIMITED_API even before including pyconfig.h. + In that case, we guess what pyconfig.h will do to the macros above, + and check our guess after the #include. + + Note that on Windows, with CPython 3.x, you need >= 3.5 and virtualenv + version >= 16.0.0. With older versions of either, you don't get a + copy of PYTHON3.DLL in the virtualenv. We can't check the version of + CPython *before* we even include pyconfig.h. ffi.set_source() puts + a ``#define _CFFI_NO_LIMITED_API'' at the start of this file if it is + running on Windows < 3.5, as an attempt at fixing it, but that's + arguably wrong because it may not be the target version of Python. + Still better than nothing I guess. As another workaround, you can + remove the definition of Py_LIMITED_API here. + + See also 'py_limited_api' in cffi/setuptools_ext.py. +*/ +#if !defined(_CFFI_USE_EMBEDDING) && !defined(Py_LIMITED_API) +# ifdef _MSC_VER +# if !defined(_DEBUG) && !defined(Py_DEBUG) && !defined(Py_TRACE_REFS) && !defined(Py_REF_DEBUG) && !defined(_CFFI_NO_LIMITED_API) +# define Py_LIMITED_API +# endif +# include + /* sanity-check: Py_LIMITED_API will cause crashes if any of these + are also defined. Normally, the Python file PC/pyconfig.h does not + cause any of these to be defined, with the exception that _DEBUG + causes Py_DEBUG. Double-check that. */ +# ifdef Py_LIMITED_API +# if defined(Py_DEBUG) +# error "pyconfig.h unexpectedly defines Py_DEBUG, but Py_LIMITED_API is set" +# endif +# if defined(Py_TRACE_REFS) +# error "pyconfig.h unexpectedly defines Py_TRACE_REFS, but Py_LIMITED_API is set" +# endif +# if defined(Py_REF_DEBUG) +# error "pyconfig.h unexpectedly defines Py_REF_DEBUG, but Py_LIMITED_API is set" +# endif +# endif +# else +# include +# if !defined(Py_DEBUG) && !defined(Py_TRACE_REFS) && !defined(Py_REF_DEBUG) && !defined(_CFFI_NO_LIMITED_API) +# define Py_LIMITED_API +# endif +# endif +#endif + +#include +#ifdef __cplusplus +extern "C" { +#endif +#include +#include "parse_c_type.h" + +/* this block of #ifs should be kept exactly identical between + c/_cffi_backend.c, cffi/vengine_cpy.py, cffi/vengine_gen.py + and cffi/_cffi_include.h */ +#if defined(_MSC_VER) +# include /* for alloca() */ +# if _MSC_VER < 1600 /* MSVC < 2010 */ + typedef __int8 int8_t; + typedef __int16 int16_t; + typedef __int32 int32_t; + typedef __int64 int64_t; + typedef unsigned __int8 uint8_t; + typedef unsigned __int16 uint16_t; + typedef unsigned __int32 uint32_t; + typedef unsigned __int64 uint64_t; + typedef __int8 int_least8_t; + typedef __int16 int_least16_t; + typedef __int32 int_least32_t; + typedef __int64 int_least64_t; + typedef unsigned __int8 uint_least8_t; + typedef unsigned __int16 uint_least16_t; + typedef unsigned __int32 uint_least32_t; + typedef unsigned __int64 uint_least64_t; + typedef __int8 int_fast8_t; + typedef __int16 int_fast16_t; + typedef __int32 int_fast32_t; + typedef __int64 int_fast64_t; + typedef unsigned __int8 uint_fast8_t; + typedef unsigned __int16 uint_fast16_t; + typedef unsigned __int32 uint_fast32_t; + typedef unsigned __int64 uint_fast64_t; + typedef __int64 intmax_t; + typedef unsigned __int64 uintmax_t; +# else +# include +# endif +# if _MSC_VER < 1800 /* MSVC < 2013 */ +# ifndef __cplusplus + typedef unsigned char _Bool; +# endif +# endif +# define _cffi_float_complex_t _Fcomplex /* include for it */ +# define _cffi_double_complex_t _Dcomplex /* include for it */ +#else +# include +# if (defined (__SVR4) && defined (__sun)) || defined(_AIX) || defined(__hpux) +# include +# endif +# define _cffi_float_complex_t float _Complex +# define _cffi_double_complex_t double _Complex +#endif + +#ifdef __GNUC__ +# define _CFFI_UNUSED_FN __attribute__((unused)) +#else +# define _CFFI_UNUSED_FN /* nothing */ +#endif + +#ifdef __cplusplus +# ifndef _Bool + typedef bool _Bool; /* semi-hackish: C++ has no _Bool; bool is builtin */ +# endif +#endif + +/********** CPython-specific section **********/ +#ifndef PYPY_VERSION + + +#if PY_MAJOR_VERSION >= 3 +# define PyInt_FromLong PyLong_FromLong +#endif + +#define _cffi_from_c_double PyFloat_FromDouble +#define _cffi_from_c_float PyFloat_FromDouble +#define _cffi_from_c_long PyInt_FromLong +#define _cffi_from_c_ulong PyLong_FromUnsignedLong +#define _cffi_from_c_longlong PyLong_FromLongLong +#define _cffi_from_c_ulonglong PyLong_FromUnsignedLongLong +#define _cffi_from_c__Bool PyBool_FromLong + +#define _cffi_to_c_double PyFloat_AsDouble +#define _cffi_to_c_float PyFloat_AsDouble + +#define _cffi_from_c_int(x, type) \ + (((type)-1) > 0 ? /* unsigned */ \ + (sizeof(type) < sizeof(long) ? \ + PyInt_FromLong((long)x) : \ + sizeof(type) == sizeof(long) ? \ + PyLong_FromUnsignedLong((unsigned long)x) : \ + PyLong_FromUnsignedLongLong((unsigned long long)x)) : \ + (sizeof(type) <= sizeof(long) ? \ + PyInt_FromLong((long)x) : \ + PyLong_FromLongLong((long long)x))) + +#define _cffi_to_c_int(o, type) \ + ((type)( \ + sizeof(type) == 1 ? (((type)-1) > 0 ? (type)_cffi_to_c_u8(o) \ + : (type)_cffi_to_c_i8(o)) : \ + sizeof(type) == 2 ? (((type)-1) > 0 ? (type)_cffi_to_c_u16(o) \ + : (type)_cffi_to_c_i16(o)) : \ + sizeof(type) == 4 ? (((type)-1) > 0 ? (type)_cffi_to_c_u32(o) \ + : (type)_cffi_to_c_i32(o)) : \ + sizeof(type) == 8 ? (((type)-1) > 0 ? (type)_cffi_to_c_u64(o) \ + : (type)_cffi_to_c_i64(o)) : \ + (Py_FatalError("unsupported size for type " #type), (type)0))) + +#define _cffi_to_c_i8 \ + ((int(*)(PyObject *))_cffi_exports[1]) +#define _cffi_to_c_u8 \ + ((int(*)(PyObject *))_cffi_exports[2]) +#define _cffi_to_c_i16 \ + ((int(*)(PyObject *))_cffi_exports[3]) +#define _cffi_to_c_u16 \ + ((int(*)(PyObject *))_cffi_exports[4]) +#define _cffi_to_c_i32 \ + ((int(*)(PyObject *))_cffi_exports[5]) +#define _cffi_to_c_u32 \ + ((unsigned int(*)(PyObject *))_cffi_exports[6]) +#define _cffi_to_c_i64 \ + ((long long(*)(PyObject *))_cffi_exports[7]) +#define _cffi_to_c_u64 \ + ((unsigned long long(*)(PyObject *))_cffi_exports[8]) +#define _cffi_to_c_char \ + ((int(*)(PyObject *))_cffi_exports[9]) +#define _cffi_from_c_pointer \ + ((PyObject *(*)(char *, struct _cffi_ctypedescr *))_cffi_exports[10]) +#define _cffi_to_c_pointer \ + ((char *(*)(PyObject *, struct _cffi_ctypedescr *))_cffi_exports[11]) +#define _cffi_get_struct_layout \ + not used any more +#define _cffi_restore_errno \ + ((void(*)(void))_cffi_exports[13]) +#define _cffi_save_errno \ + ((void(*)(void))_cffi_exports[14]) +#define _cffi_from_c_char \ + ((PyObject *(*)(char))_cffi_exports[15]) +#define _cffi_from_c_deref \ + ((PyObject *(*)(char *, struct _cffi_ctypedescr *))_cffi_exports[16]) +#define _cffi_to_c \ + ((int(*)(char *, struct _cffi_ctypedescr *, PyObject *))_cffi_exports[17]) +#define _cffi_from_c_struct \ + ((PyObject *(*)(char *, struct _cffi_ctypedescr *))_cffi_exports[18]) +#define _cffi_to_c_wchar_t \ + ((_cffi_wchar_t(*)(PyObject *))_cffi_exports[19]) +#define _cffi_from_c_wchar_t \ + ((PyObject *(*)(_cffi_wchar_t))_cffi_exports[20]) +#define _cffi_to_c_long_double \ + ((long double(*)(PyObject *))_cffi_exports[21]) +#define _cffi_to_c__Bool \ + ((_Bool(*)(PyObject *))_cffi_exports[22]) +#define _cffi_prepare_pointer_call_argument \ + ((Py_ssize_t(*)(struct _cffi_ctypedescr *, \ + PyObject *, char **))_cffi_exports[23]) +#define _cffi_convert_array_from_object \ + ((int(*)(char *, struct _cffi_ctypedescr *, PyObject *))_cffi_exports[24]) +#define _CFFI_CPIDX 25 +#define _cffi_call_python \ + ((void(*)(struct _cffi_externpy_s *, char *))_cffi_exports[_CFFI_CPIDX]) +#define _cffi_to_c_wchar3216_t \ + ((int(*)(PyObject *))_cffi_exports[26]) +#define _cffi_from_c_wchar3216_t \ + ((PyObject *(*)(int))_cffi_exports[27]) +#define _CFFI_NUM_EXPORTS 28 + +struct _cffi_ctypedescr; + +static void *_cffi_exports[_CFFI_NUM_EXPORTS]; + +#define _cffi_type(index) ( \ + assert((((uintptr_t)_cffi_types[index]) & 1) == 0), \ + (struct _cffi_ctypedescr *)_cffi_types[index]) + +static PyObject *_cffi_init(const char *module_name, Py_ssize_t version, + const struct _cffi_type_context_s *ctx) +{ + PyObject *module, *o_arg, *new_module; + void *raw[] = { + (void *)module_name, + (void *)version, + (void *)_cffi_exports, + (void *)ctx, + }; + + module = PyImport_ImportModule("_cffi_backend"); + if (module == NULL) + goto failure; + + o_arg = PyLong_FromVoidPtr((void *)raw); + if (o_arg == NULL) + goto failure; + + new_module = PyObject_CallMethod( + module, (char *)"_init_cffi_1_0_external_module", (char *)"O", o_arg); + + Py_DECREF(o_arg); + Py_DECREF(module); + return new_module; + + failure: + Py_XDECREF(module); + return NULL; +} + + +#ifdef HAVE_WCHAR_H +typedef wchar_t _cffi_wchar_t; +#else +typedef uint16_t _cffi_wchar_t; /* same random pick as _cffi_backend.c */ +#endif + +_CFFI_UNUSED_FN static uint16_t _cffi_to_c_char16_t(PyObject *o) +{ + if (sizeof(_cffi_wchar_t) == 2) + return (uint16_t)_cffi_to_c_wchar_t(o); + else + return (uint16_t)_cffi_to_c_wchar3216_t(o); +} + +_CFFI_UNUSED_FN static PyObject *_cffi_from_c_char16_t(uint16_t x) +{ + if (sizeof(_cffi_wchar_t) == 2) + return _cffi_from_c_wchar_t((_cffi_wchar_t)x); + else + return _cffi_from_c_wchar3216_t((int)x); +} + +_CFFI_UNUSED_FN static int _cffi_to_c_char32_t(PyObject *o) +{ + if (sizeof(_cffi_wchar_t) == 4) + return (int)_cffi_to_c_wchar_t(o); + else + return (int)_cffi_to_c_wchar3216_t(o); +} + +_CFFI_UNUSED_FN static PyObject *_cffi_from_c_char32_t(unsigned int x) +{ + if (sizeof(_cffi_wchar_t) == 4) + return _cffi_from_c_wchar_t((_cffi_wchar_t)x); + else + return _cffi_from_c_wchar3216_t((int)x); +} + +union _cffi_union_alignment_u { + unsigned char m_char; + unsigned short m_short; + unsigned int m_int; + unsigned long m_long; + unsigned long long m_longlong; + float m_float; + double m_double; + long double m_longdouble; +}; + +struct _cffi_freeme_s { + struct _cffi_freeme_s *next; + union _cffi_union_alignment_u alignment; +}; + +_CFFI_UNUSED_FN static int +_cffi_convert_array_argument(struct _cffi_ctypedescr *ctptr, PyObject *arg, + char **output_data, Py_ssize_t datasize, + struct _cffi_freeme_s **freeme) +{ + char *p; + if (datasize < 0) + return -1; + + p = *output_data; + if (p == NULL) { + struct _cffi_freeme_s *fp = (struct _cffi_freeme_s *)PyObject_Malloc( + offsetof(struct _cffi_freeme_s, alignment) + (size_t)datasize); + if (fp == NULL) + return -1; + fp->next = *freeme; + *freeme = fp; + p = *output_data = (char *)&fp->alignment; + } + memset((void *)p, 0, (size_t)datasize); + return _cffi_convert_array_from_object(p, ctptr, arg); +} + +_CFFI_UNUSED_FN static void +_cffi_free_array_arguments(struct _cffi_freeme_s *freeme) +{ + do { + void *p = (void *)freeme; + freeme = freeme->next; + PyObject_Free(p); + } while (freeme != NULL); +} + +/********** end CPython-specific section **********/ +#else +_CFFI_UNUSED_FN +static void (*_cffi_call_python_org)(struct _cffi_externpy_s *, char *); +# define _cffi_call_python _cffi_call_python_org +#endif + + +#define _cffi_array_len(array) (sizeof(array) / sizeof((array)[0])) + +#define _cffi_prim_int(size, sign) \ + ((size) == 1 ? ((sign) ? _CFFI_PRIM_INT8 : _CFFI_PRIM_UINT8) : \ + (size) == 2 ? ((sign) ? _CFFI_PRIM_INT16 : _CFFI_PRIM_UINT16) : \ + (size) == 4 ? ((sign) ? _CFFI_PRIM_INT32 : _CFFI_PRIM_UINT32) : \ + (size) == 8 ? ((sign) ? _CFFI_PRIM_INT64 : _CFFI_PRIM_UINT64) : \ + _CFFI__UNKNOWN_PRIM) + +#define _cffi_prim_float(size) \ + ((size) == sizeof(float) ? _CFFI_PRIM_FLOAT : \ + (size) == sizeof(double) ? _CFFI_PRIM_DOUBLE : \ + (size) == sizeof(long double) ? _CFFI__UNKNOWN_LONG_DOUBLE : \ + _CFFI__UNKNOWN_FLOAT_PRIM) + +#define _cffi_check_int(got, got_nonpos, expected) \ + ((got_nonpos) == (expected <= 0) && \ + (got) == (unsigned long long)expected) + +#ifdef MS_WIN32 +# define _cffi_stdcall __stdcall +#else +# define _cffi_stdcall /* nothing */ +#endif + +#ifdef __cplusplus +} +#endif diff --git a/venv/lib/python3.12/site-packages/cffi/_embedding.h b/venv/lib/python3.12/site-packages/cffi/_embedding.h new file mode 100644 index 00000000..94d8b30a --- /dev/null +++ b/venv/lib/python3.12/site-packages/cffi/_embedding.h @@ -0,0 +1,550 @@ + +/***** Support code for embedding *****/ + +#ifdef __cplusplus +extern "C" { +#endif + + +#if defined(_WIN32) +# define CFFI_DLLEXPORT __declspec(dllexport) +#elif defined(__GNUC__) +# define CFFI_DLLEXPORT __attribute__((visibility("default"))) +#else +# define CFFI_DLLEXPORT /* nothing */ +#endif + + +/* There are two global variables of type _cffi_call_python_fnptr: + + * _cffi_call_python, which we declare just below, is the one called + by ``extern "Python"`` implementations. + + * _cffi_call_python_org, which on CPython is actually part of the + _cffi_exports[] array, is the function pointer copied from + _cffi_backend. If _cffi_start_python() fails, then this is set + to NULL; otherwise, it should never be NULL. + + After initialization is complete, both are equal. However, the + first one remains equal to &_cffi_start_and_call_python until the + very end of initialization, when we are (or should be) sure that + concurrent threads also see a completely initialized world, and + only then is it changed. +*/ +#undef _cffi_call_python +typedef void (*_cffi_call_python_fnptr)(struct _cffi_externpy_s *, char *); +static void _cffi_start_and_call_python(struct _cffi_externpy_s *, char *); +static _cffi_call_python_fnptr _cffi_call_python = &_cffi_start_and_call_python; + + +#ifndef _MSC_VER + /* --- Assuming a GCC not infinitely old --- */ +# define cffi_compare_and_swap(l,o,n) __sync_bool_compare_and_swap(l,o,n) +# define cffi_write_barrier() __sync_synchronize() +# if !defined(__amd64__) && !defined(__x86_64__) && \ + !defined(__i386__) && !defined(__i386) +# define cffi_read_barrier() __sync_synchronize() +# else +# define cffi_read_barrier() (void)0 +# endif +#else + /* --- Windows threads version --- */ +# include +# define cffi_compare_and_swap(l,o,n) \ + (InterlockedCompareExchangePointer(l,n,o) == (o)) +# define cffi_write_barrier() InterlockedCompareExchange(&_cffi_dummy,0,0) +# define cffi_read_barrier() (void)0 +static volatile LONG _cffi_dummy; +#endif + +#ifdef WITH_THREAD +# ifndef _MSC_VER +# include + static pthread_mutex_t _cffi_embed_startup_lock; +# else + static CRITICAL_SECTION _cffi_embed_startup_lock; +# endif + static char _cffi_embed_startup_lock_ready = 0; +#endif + +static void _cffi_acquire_reentrant_mutex(void) +{ + static void *volatile lock = NULL; + + while (!cffi_compare_and_swap(&lock, NULL, (void *)1)) { + /* should ideally do a spin loop instruction here, but + hard to do it portably and doesn't really matter I + think: pthread_mutex_init() should be very fast, and + this is only run at start-up anyway. */ + } + +#ifdef WITH_THREAD + if (!_cffi_embed_startup_lock_ready) { +# ifndef _MSC_VER + pthread_mutexattr_t attr; + pthread_mutexattr_init(&attr); + pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE); + pthread_mutex_init(&_cffi_embed_startup_lock, &attr); +# else + InitializeCriticalSection(&_cffi_embed_startup_lock); +# endif + _cffi_embed_startup_lock_ready = 1; + } +#endif + + while (!cffi_compare_and_swap(&lock, (void *)1, NULL)) + ; + +#ifndef _MSC_VER + pthread_mutex_lock(&_cffi_embed_startup_lock); +#else + EnterCriticalSection(&_cffi_embed_startup_lock); +#endif +} + +static void _cffi_release_reentrant_mutex(void) +{ +#ifndef _MSC_VER + pthread_mutex_unlock(&_cffi_embed_startup_lock); +#else + LeaveCriticalSection(&_cffi_embed_startup_lock); +#endif +} + + +/********** CPython-specific section **********/ +#ifndef PYPY_VERSION + +#include "_cffi_errors.h" + + +#define _cffi_call_python_org _cffi_exports[_CFFI_CPIDX] + +PyMODINIT_FUNC _CFFI_PYTHON_STARTUP_FUNC(void); /* forward */ + +static void _cffi_py_initialize(void) +{ + /* XXX use initsigs=0, which "skips initialization registration of + signal handlers, which might be useful when Python is + embedded" according to the Python docs. But review and think + if it should be a user-controllable setting. + + XXX we should also give a way to write errors to a buffer + instead of to stderr. + + XXX if importing 'site' fails, CPython (any version) calls + exit(). Should we try to work around this behavior here? + */ + Py_InitializeEx(0); +} + +static int _cffi_initialize_python(void) +{ + /* This initializes Python, imports _cffi_backend, and then the + present .dll/.so is set up as a CPython C extension module. + */ + int result; + PyGILState_STATE state; + PyObject *pycode=NULL, *global_dict=NULL, *x; + PyObject *builtins; + + state = PyGILState_Ensure(); + + /* Call the initxxx() function from the present module. It will + create and initialize us as a CPython extension module, instead + of letting the startup Python code do it---it might reimport + the same .dll/.so and get maybe confused on some platforms. + It might also have troubles locating the .dll/.so again for all + I know. + */ + (void)_CFFI_PYTHON_STARTUP_FUNC(); + if (PyErr_Occurred()) + goto error; + + /* Now run the Python code provided to ffi.embedding_init_code(). + */ + pycode = Py_CompileString(_CFFI_PYTHON_STARTUP_CODE, + "", + Py_file_input); + if (pycode == NULL) + goto error; + global_dict = PyDict_New(); + if (global_dict == NULL) + goto error; + builtins = PyEval_GetBuiltins(); + if (builtins == NULL) + goto error; + if (PyDict_SetItemString(global_dict, "__builtins__", builtins) < 0) + goto error; + x = PyEval_EvalCode( +#if PY_MAJOR_VERSION < 3 + (PyCodeObject *) +#endif + pycode, global_dict, global_dict); + if (x == NULL) + goto error; + Py_DECREF(x); + + /* Done! Now if we've been called from + _cffi_start_and_call_python() in an ``extern "Python"``, we can + only hope that the Python code did correctly set up the + corresponding @ffi.def_extern() function. Otherwise, the + general logic of ``extern "Python"`` functions (inside the + _cffi_backend module) will find that the reference is still + missing and print an error. + */ + result = 0; + done: + Py_XDECREF(pycode); + Py_XDECREF(global_dict); + PyGILState_Release(state); + return result; + + error:; + { + /* Print as much information as potentially useful. + Debugging load-time failures with embedding is not fun + */ + PyObject *ecap; + PyObject *exception, *v, *tb, *f, *modules, *mod; + PyErr_Fetch(&exception, &v, &tb); + ecap = _cffi_start_error_capture(); + f = PySys_GetObject((char *)"stderr"); + if (f != NULL && f != Py_None) { + PyFile_WriteString( + "Failed to initialize the Python-CFFI embedding logic:\n\n", f); + } + + if (exception != NULL) { + PyErr_NormalizeException(&exception, &v, &tb); + PyErr_Display(exception, v, tb); + } + Py_XDECREF(exception); + Py_XDECREF(v); + Py_XDECREF(tb); + + if (f != NULL && f != Py_None) { + PyFile_WriteString("\nFrom: " _CFFI_MODULE_NAME + "\ncompiled with cffi version: 1.17.1" + "\n_cffi_backend module: ", f); + modules = PyImport_GetModuleDict(); + mod = PyDict_GetItemString(modules, "_cffi_backend"); + if (mod == NULL) { + PyFile_WriteString("not loaded", f); + } + else { + v = PyObject_GetAttrString(mod, "__file__"); + PyFile_WriteObject(v, f, 0); + Py_XDECREF(v); + } + PyFile_WriteString("\nsys.path: ", f); + PyFile_WriteObject(PySys_GetObject((char *)"path"), f, 0); + PyFile_WriteString("\n\n", f); + } + _cffi_stop_error_capture(ecap); + } + result = -1; + goto done; +} + +#if PY_VERSION_HEX < 0x03080000 +PyAPI_DATA(char *) _PyParser_TokenNames[]; /* from CPython */ +#endif + +static int _cffi_carefully_make_gil(void) +{ + /* This does the basic initialization of Python. It can be called + completely concurrently from unrelated threads. It assumes + that we don't hold the GIL before (if it exists), and we don't + hold it afterwards. + + (What it really does used to be completely different in Python 2 + and Python 3, with the Python 2 solution avoiding the spin-lock + around the Py_InitializeEx() call. However, after recent changes + to CPython 2.7 (issue #358) it no longer works. So we use the + Python 3 solution everywhere.) + + This initializes Python by calling Py_InitializeEx(). + Important: this must not be called concurrently at all. + So we use a global variable as a simple spin lock. This global + variable must be from 'libpythonX.Y.so', not from this + cffi-based extension module, because it must be shared from + different cffi-based extension modules. + + In Python < 3.8, we choose + _PyParser_TokenNames[0] as a completely arbitrary pointer value + that is never written to. The default is to point to the + string "ENDMARKER". We change it temporarily to point to the + next character in that string. (Yes, I know it's REALLY + obscure.) + + In Python >= 3.8, this string array is no longer writable, so + instead we pick PyCapsuleType.tp_version_tag. We can't change + Python < 3.8 because someone might use a mixture of cffi + embedded modules, some of which were compiled before this file + changed. + + In Python >= 3.12, this stopped working because that particular + tp_version_tag gets modified during interpreter startup. It's + arguably a bad idea before 3.12 too, but again we can't change + that because someone might use a mixture of cffi embedded + modules, and no-one reported a bug so far. In Python >= 3.12 + we go instead for PyCapsuleType.tp_as_buffer, which is supposed + to always be NULL. We write to it temporarily a pointer to + a struct full of NULLs, which is semantically the same. + */ + +#ifdef WITH_THREAD +# if PY_VERSION_HEX < 0x03080000 + char *volatile *lock = (char *volatile *)_PyParser_TokenNames; + char *old_value, *locked_value; + + while (1) { /* spin loop */ + old_value = *lock; + locked_value = old_value + 1; + if (old_value[0] == 'E') { + assert(old_value[1] == 'N'); + if (cffi_compare_and_swap(lock, old_value, locked_value)) + break; + } + else { + assert(old_value[0] == 'N'); + /* should ideally do a spin loop instruction here, but + hard to do it portably and doesn't really matter I + think: PyEval_InitThreads() should be very fast, and + this is only run at start-up anyway. */ + } + } +# else +# if PY_VERSION_HEX < 0x030C0000 + int volatile *lock = (int volatile *)&PyCapsule_Type.tp_version_tag; + int old_value, locked_value = -42; + assert(!(PyCapsule_Type.tp_flags & Py_TPFLAGS_HAVE_VERSION_TAG)); +# else + static struct ebp_s { PyBufferProcs buf; int mark; } empty_buffer_procs; + empty_buffer_procs.mark = -42; + PyBufferProcs *volatile *lock = (PyBufferProcs *volatile *) + &PyCapsule_Type.tp_as_buffer; + PyBufferProcs *old_value, *locked_value = &empty_buffer_procs.buf; +# endif + + while (1) { /* spin loop */ + old_value = *lock; + if (old_value == 0) { + if (cffi_compare_and_swap(lock, old_value, locked_value)) + break; + } + else { +# if PY_VERSION_HEX < 0x030C0000 + assert(old_value == locked_value); +# else + /* The pointer should point to a possibly different + empty_buffer_procs from another C extension module */ + assert(((struct ebp_s *)old_value)->mark == -42); +# endif + /* should ideally do a spin loop instruction here, but + hard to do it portably and doesn't really matter I + think: PyEval_InitThreads() should be very fast, and + this is only run at start-up anyway. */ + } + } +# endif +#endif + + /* call Py_InitializeEx() */ + if (!Py_IsInitialized()) { + _cffi_py_initialize(); +#if PY_VERSION_HEX < 0x03070000 + PyEval_InitThreads(); +#endif + PyEval_SaveThread(); /* release the GIL */ + /* the returned tstate must be the one that has been stored into the + autoTLSkey by _PyGILState_Init() called from Py_Initialize(). */ + } + else { +#if PY_VERSION_HEX < 0x03070000 + /* PyEval_InitThreads() is always a no-op from CPython 3.7 */ + PyGILState_STATE state = PyGILState_Ensure(); + PyEval_InitThreads(); + PyGILState_Release(state); +#endif + } + +#ifdef WITH_THREAD + /* release the lock */ + while (!cffi_compare_and_swap(lock, locked_value, old_value)) + ; +#endif + + return 0; +} + +/********** end CPython-specific section **********/ + + +#else + + +/********** PyPy-specific section **********/ + +PyMODINIT_FUNC _CFFI_PYTHON_STARTUP_FUNC(const void *[]); /* forward */ + +static struct _cffi_pypy_init_s { + const char *name; + void *func; /* function pointer */ + const char *code; +} _cffi_pypy_init = { + _CFFI_MODULE_NAME, + _CFFI_PYTHON_STARTUP_FUNC, + _CFFI_PYTHON_STARTUP_CODE, +}; + +extern int pypy_carefully_make_gil(const char *); +extern int pypy_init_embedded_cffi_module(int, struct _cffi_pypy_init_s *); + +static int _cffi_carefully_make_gil(void) +{ + return pypy_carefully_make_gil(_CFFI_MODULE_NAME); +} + +static int _cffi_initialize_python(void) +{ + return pypy_init_embedded_cffi_module(0xB011, &_cffi_pypy_init); +} + +/********** end PyPy-specific section **********/ + + +#endif + + +#ifdef __GNUC__ +__attribute__((noinline)) +#endif +static _cffi_call_python_fnptr _cffi_start_python(void) +{ + /* Delicate logic to initialize Python. This function can be + called multiple times concurrently, e.g. when the process calls + its first ``extern "Python"`` functions in multiple threads at + once. It can also be called recursively, in which case we must + ignore it. We also have to consider what occurs if several + different cffi-based extensions reach this code in parallel + threads---it is a different copy of the code, then, and we + can't have any shared global variable unless it comes from + 'libpythonX.Y.so'. + + Idea: + + * _cffi_carefully_make_gil(): "carefully" call + PyEval_InitThreads() (possibly with Py_InitializeEx() first). + + * then we use a (local) custom lock to make sure that a call to this + cffi-based extension will wait if another call to the *same* + extension is running the initialization in another thread. + It is reentrant, so that a recursive call will not block, but + only one from a different thread. + + * then we grab the GIL and (Python 2) we call Py_InitializeEx(). + At this point, concurrent calls to Py_InitializeEx() are not + possible: we have the GIL. + + * do the rest of the specific initialization, which may + temporarily release the GIL but not the custom lock. + Only release the custom lock when we are done. + */ + static char called = 0; + + if (_cffi_carefully_make_gil() != 0) + return NULL; + + _cffi_acquire_reentrant_mutex(); + + /* Here the GIL exists, but we don't have it. We're only protected + from concurrency by the reentrant mutex. */ + + /* This file only initializes the embedded module once, the first + time this is called, even if there are subinterpreters. */ + if (!called) { + called = 1; /* invoke _cffi_initialize_python() only once, + but don't set '_cffi_call_python' right now, + otherwise concurrent threads won't call + this function at all (we need them to wait) */ + if (_cffi_initialize_python() == 0) { + /* now initialization is finished. Switch to the fast-path. */ + + /* We would like nobody to see the new value of + '_cffi_call_python' without also seeing the rest of the + data initialized. However, this is not possible. But + the new value of '_cffi_call_python' is the function + 'cffi_call_python()' from _cffi_backend. So: */ + cffi_write_barrier(); + /* ^^^ we put a write barrier here, and a corresponding + read barrier at the start of cffi_call_python(). This + ensures that after that read barrier, we see everything + done here before the write barrier. + */ + + assert(_cffi_call_python_org != NULL); + _cffi_call_python = (_cffi_call_python_fnptr)_cffi_call_python_org; + } + else { + /* initialization failed. Reset this to NULL, even if it was + already set to some other value. Future calls to + _cffi_start_python() are still forced to occur, and will + always return NULL from now on. */ + _cffi_call_python_org = NULL; + } + } + + _cffi_release_reentrant_mutex(); + + return (_cffi_call_python_fnptr)_cffi_call_python_org; +} + +static +void _cffi_start_and_call_python(struct _cffi_externpy_s *externpy, char *args) +{ + _cffi_call_python_fnptr fnptr; + int current_err = errno; +#ifdef _MSC_VER + int current_lasterr = GetLastError(); +#endif + fnptr = _cffi_start_python(); + if (fnptr == NULL) { + fprintf(stderr, "function %s() called, but initialization code " + "failed. Returning 0.\n", externpy->name); + memset(args, 0, externpy->size_of_result); + } +#ifdef _MSC_VER + SetLastError(current_lasterr); +#endif + errno = current_err; + + if (fnptr != NULL) + fnptr(externpy, args); +} + + +/* The cffi_start_python() function makes sure Python is initialized + and our cffi module is set up. It can be called manually from the + user C code. The same effect is obtained automatically from any + dll-exported ``extern "Python"`` function. This function returns + -1 if initialization failed, 0 if all is OK. */ +_CFFI_UNUSED_FN +static int cffi_start_python(void) +{ + if (_cffi_call_python == &_cffi_start_and_call_python) { + if (_cffi_start_python() == NULL) + return -1; + } + cffi_read_barrier(); + return 0; +} + +#undef cffi_compare_and_swap +#undef cffi_write_barrier +#undef cffi_read_barrier + +#ifdef __cplusplus +} +#endif diff --git a/venv/lib/python3.12/site-packages/cffi/_imp_emulation.py b/venv/lib/python3.12/site-packages/cffi/_imp_emulation.py new file mode 100644 index 00000000..136abddd --- /dev/null +++ b/venv/lib/python3.12/site-packages/cffi/_imp_emulation.py @@ -0,0 +1,83 @@ + +try: + # this works on Python < 3.12 + from imp import * + +except ImportError: + # this is a limited emulation for Python >= 3.12. + # Note that this is used only for tests or for the old ffi.verify(). + # This is copied from the source code of Python 3.11. + + from _imp import (acquire_lock, release_lock, + is_builtin, is_frozen) + + from importlib._bootstrap import _load + + from importlib import machinery + import os + import sys + import tokenize + + SEARCH_ERROR = 0 + PY_SOURCE = 1 + PY_COMPILED = 2 + C_EXTENSION = 3 + PY_RESOURCE = 4 + PKG_DIRECTORY = 5 + C_BUILTIN = 6 + PY_FROZEN = 7 + PY_CODERESOURCE = 8 + IMP_HOOK = 9 + + def get_suffixes(): + extensions = [(s, 'rb', C_EXTENSION) + for s in machinery.EXTENSION_SUFFIXES] + source = [(s, 'r', PY_SOURCE) for s in machinery.SOURCE_SUFFIXES] + bytecode = [(s, 'rb', PY_COMPILED) for s in machinery.BYTECODE_SUFFIXES] + return extensions + source + bytecode + + def find_module(name, path=None): + if not isinstance(name, str): + raise TypeError("'name' must be a str, not {}".format(type(name))) + elif not isinstance(path, (type(None), list)): + # Backwards-compatibility + raise RuntimeError("'path' must be None or a list, " + "not {}".format(type(path))) + + if path is None: + if is_builtin(name): + return None, None, ('', '', C_BUILTIN) + elif is_frozen(name): + return None, None, ('', '', PY_FROZEN) + else: + path = sys.path + + for entry in path: + package_directory = os.path.join(entry, name) + for suffix in ['.py', machinery.BYTECODE_SUFFIXES[0]]: + package_file_name = '__init__' + suffix + file_path = os.path.join(package_directory, package_file_name) + if os.path.isfile(file_path): + return None, package_directory, ('', '', PKG_DIRECTORY) + for suffix, mode, type_ in get_suffixes(): + file_name = name + suffix + file_path = os.path.join(entry, file_name) + if os.path.isfile(file_path): + break + else: + continue + break # Break out of outer loop when breaking out of inner loop. + else: + raise ImportError(name, name=name) + + encoding = None + if 'b' not in mode: + with open(file_path, 'rb') as file: + encoding = tokenize.detect_encoding(file.readline)[0] + file = open(file_path, mode, encoding=encoding) + return file, file_path, (suffix, mode, type_) + + def load_dynamic(name, path, file=None): + loader = machinery.ExtensionFileLoader(name, path) + spec = machinery.ModuleSpec(name=name, loader=loader, origin=path) + return _load(spec) diff --git a/venv/lib/python3.12/site-packages/cffi/_shimmed_dist_utils.py b/venv/lib/python3.12/site-packages/cffi/_shimmed_dist_utils.py new file mode 100644 index 00000000..c3d23128 --- /dev/null +++ b/venv/lib/python3.12/site-packages/cffi/_shimmed_dist_utils.py @@ -0,0 +1,45 @@ +""" +Temporary shim module to indirect the bits of distutils we need from setuptools/distutils while providing useful +error messages beyond `No module named 'distutils' on Python >= 3.12, or when setuptools' vendored distutils is broken. + +This is a compromise to avoid a hard-dep on setuptools for Python >= 3.12, since many users don't need runtime compilation support from CFFI. +""" +import sys + +try: + # import setuptools first; this is the most robust way to ensure its embedded distutils is available + # (the .pth shim should usually work, but this is even more robust) + import setuptools +except Exception as ex: + if sys.version_info >= (3, 12): + # Python 3.12 has no built-in distutils to fall back on, so any import problem is fatal + raise Exception("This CFFI feature requires setuptools on Python >= 3.12. The setuptools module is missing or non-functional.") from ex + + # silently ignore on older Pythons (support fallback to stdlib distutils where available) +else: + del setuptools + +try: + # bring in just the bits of distutils we need, whether they really came from setuptools or stdlib-embedded distutils + from distutils import log, sysconfig + from distutils.ccompiler import CCompiler + from distutils.command.build_ext import build_ext + from distutils.core import Distribution, Extension + from distutils.dir_util import mkpath + from distutils.errors import DistutilsSetupError, CompileError, LinkError + from distutils.log import set_threshold, set_verbosity + + if sys.platform == 'win32': + try: + # FUTURE: msvc9compiler module was removed in setuptools 74; consider removing, as it's only used by an ancient patch in `recompiler` + from distutils.msvc9compiler import MSVCCompiler + except ImportError: + MSVCCompiler = None +except Exception as ex: + if sys.version_info >= (3, 12): + raise Exception("This CFFI feature requires setuptools on Python >= 3.12. Please install the setuptools package.") from ex + + # anything older, just let the underlying distutils import error fly + raise Exception("This CFFI feature requires distutils. Please install the distutils or setuptools package.") from ex + +del sys diff --git a/venv/lib/python3.12/site-packages/cffi/api.py b/venv/lib/python3.12/site-packages/cffi/api.py new file mode 100644 index 00000000..5a474f3d --- /dev/null +++ b/venv/lib/python3.12/site-packages/cffi/api.py @@ -0,0 +1,967 @@ +import sys, types +from .lock import allocate_lock +from .error import CDefError +from . import model + +try: + callable +except NameError: + # Python 3.1 + from collections import Callable + callable = lambda x: isinstance(x, Callable) + +try: + basestring +except NameError: + # Python 3.x + basestring = str + +_unspecified = object() + + + +class FFI(object): + r''' + The main top-level class that you instantiate once, or once per module. + + Example usage: + + ffi = FFI() + ffi.cdef(""" + int printf(const char *, ...); + """) + + C = ffi.dlopen(None) # standard library + -or- + C = ffi.verify() # use a C compiler: verify the decl above is right + + C.printf("hello, %s!\n", ffi.new("char[]", "world")) + ''' + + def __init__(self, backend=None): + """Create an FFI instance. The 'backend' argument is used to + select a non-default backend, mostly for tests. + """ + if backend is None: + # You need PyPy (>= 2.0 beta), or a CPython (>= 2.6) with + # _cffi_backend.so compiled. + import _cffi_backend as backend + from . import __version__ + if backend.__version__ != __version__: + # bad version! Try to be as explicit as possible. + if hasattr(backend, '__file__'): + # CPython + raise Exception("Version mismatch: this is the 'cffi' package version %s, located in %r. When we import the top-level '_cffi_backend' extension module, we get version %s, located in %r. The two versions should be equal; check your installation." % ( + __version__, __file__, + backend.__version__, backend.__file__)) + else: + # PyPy + raise Exception("Version mismatch: this is the 'cffi' package version %s, located in %r. This interpreter comes with a built-in '_cffi_backend' module, which is version %s. The two versions should be equal; check your installation." % ( + __version__, __file__, backend.__version__)) + # (If you insist you can also try to pass the option + # 'backend=backend_ctypes.CTypesBackend()', but don't + # rely on it! It's probably not going to work well.) + + from . import cparser + self._backend = backend + self._lock = allocate_lock() + self._parser = cparser.Parser() + self._cached_btypes = {} + self._parsed_types = types.ModuleType('parsed_types').__dict__ + self._new_types = types.ModuleType('new_types').__dict__ + self._function_caches = [] + self._libraries = [] + self._cdefsources = [] + self._included_ffis = [] + self._windows_unicode = None + self._init_once_cache = {} + self._cdef_version = None + self._embedding = None + self._typecache = model.get_typecache(backend) + if hasattr(backend, 'set_ffi'): + backend.set_ffi(self) + for name in list(backend.__dict__): + if name.startswith('RTLD_'): + setattr(self, name, getattr(backend, name)) + # + with self._lock: + self.BVoidP = self._get_cached_btype(model.voidp_type) + self.BCharA = self._get_cached_btype(model.char_array_type) + if isinstance(backend, types.ModuleType): + # _cffi_backend: attach these constants to the class + if not hasattr(FFI, 'NULL'): + FFI.NULL = self.cast(self.BVoidP, 0) + FFI.CData, FFI.CType = backend._get_types() + else: + # ctypes backend: attach these constants to the instance + self.NULL = self.cast(self.BVoidP, 0) + self.CData, self.CType = backend._get_types() + self.buffer = backend.buffer + + def cdef(self, csource, override=False, packed=False, pack=None): + """Parse the given C source. This registers all declared functions, + types, and global variables. The functions and global variables can + then be accessed via either 'ffi.dlopen()' or 'ffi.verify()'. + The types can be used in 'ffi.new()' and other functions. + If 'packed' is specified as True, all structs declared inside this + cdef are packed, i.e. laid out without any field alignment at all. + Alternatively, 'pack' can be a small integer, and requests for + alignment greater than that are ignored (pack=1 is equivalent to + packed=True). + """ + self._cdef(csource, override=override, packed=packed, pack=pack) + + def embedding_api(self, csource, packed=False, pack=None): + self._cdef(csource, packed=packed, pack=pack, dllexport=True) + if self._embedding is None: + self._embedding = '' + + def _cdef(self, csource, override=False, **options): + if not isinstance(csource, str): # unicode, on Python 2 + if not isinstance(csource, basestring): + raise TypeError("cdef() argument must be a string") + csource = csource.encode('ascii') + with self._lock: + self._cdef_version = object() + self._parser.parse(csource, override=override, **options) + self._cdefsources.append(csource) + if override: + for cache in self._function_caches: + cache.clear() + finishlist = self._parser._recomplete + if finishlist: + self._parser._recomplete = [] + for tp in finishlist: + tp.finish_backend_type(self, finishlist) + + def dlopen(self, name, flags=0): + """Load and return a dynamic library identified by 'name'. + The standard C library can be loaded by passing None. + Note that functions and types declared by 'ffi.cdef()' are not + linked to a particular library, just like C headers; in the + library we only look for the actual (untyped) symbols. + """ + if not (isinstance(name, basestring) or + name is None or + isinstance(name, self.CData)): + raise TypeError("dlopen(name): name must be a file name, None, " + "or an already-opened 'void *' handle") + with self._lock: + lib, function_cache = _make_ffi_library(self, name, flags) + self._function_caches.append(function_cache) + self._libraries.append(lib) + return lib + + def dlclose(self, lib): + """Close a library obtained with ffi.dlopen(). After this call, + access to functions or variables from the library will fail + (possibly with a segmentation fault). + """ + type(lib).__cffi_close__(lib) + + def _typeof_locked(self, cdecl): + # call me with the lock! + key = cdecl + if key in self._parsed_types: + return self._parsed_types[key] + # + if not isinstance(cdecl, str): # unicode, on Python 2 + cdecl = cdecl.encode('ascii') + # + type = self._parser.parse_type(cdecl) + really_a_function_type = type.is_raw_function + if really_a_function_type: + type = type.as_function_pointer() + btype = self._get_cached_btype(type) + result = btype, really_a_function_type + self._parsed_types[key] = result + return result + + def _typeof(self, cdecl, consider_function_as_funcptr=False): + # string -> ctype object + try: + result = self._parsed_types[cdecl] + except KeyError: + with self._lock: + result = self._typeof_locked(cdecl) + # + btype, really_a_function_type = result + if really_a_function_type and not consider_function_as_funcptr: + raise CDefError("the type %r is a function type, not a " + "pointer-to-function type" % (cdecl,)) + return btype + + def typeof(self, cdecl): + """Parse the C type given as a string and return the + corresponding object. + It can also be used on 'cdata' instance to get its C type. + """ + if isinstance(cdecl, basestring): + return self._typeof(cdecl) + if isinstance(cdecl, self.CData): + return self._backend.typeof(cdecl) + if isinstance(cdecl, types.BuiltinFunctionType): + res = _builtin_function_type(cdecl) + if res is not None: + return res + if (isinstance(cdecl, types.FunctionType) + and hasattr(cdecl, '_cffi_base_type')): + with self._lock: + return self._get_cached_btype(cdecl._cffi_base_type) + raise TypeError(type(cdecl)) + + def sizeof(self, cdecl): + """Return the size in bytes of the argument. It can be a + string naming a C type, or a 'cdata' instance. + """ + if isinstance(cdecl, basestring): + BType = self._typeof(cdecl) + return self._backend.sizeof(BType) + else: + return self._backend.sizeof(cdecl) + + def alignof(self, cdecl): + """Return the natural alignment size in bytes of the C type + given as a string. + """ + if isinstance(cdecl, basestring): + cdecl = self._typeof(cdecl) + return self._backend.alignof(cdecl) + + def offsetof(self, cdecl, *fields_or_indexes): + """Return the offset of the named field inside the given + structure or array, which must be given as a C type name. + You can give several field names in case of nested structures. + You can also give numeric values which correspond to array + items, in case of an array type. + """ + if isinstance(cdecl, basestring): + cdecl = self._typeof(cdecl) + return self._typeoffsetof(cdecl, *fields_or_indexes)[1] + + def new(self, cdecl, init=None): + """Allocate an instance according to the specified C type and + return a pointer to it. The specified C type must be either a + pointer or an array: ``new('X *')`` allocates an X and returns + a pointer to it, whereas ``new('X[n]')`` allocates an array of + n X'es and returns an array referencing it (which works + mostly like a pointer, like in C). You can also use + ``new('X[]', n)`` to allocate an array of a non-constant + length n. + + The memory is initialized following the rules of declaring a + global variable in C: by default it is zero-initialized, but + an explicit initializer can be given which can be used to + fill all or part of the memory. + + When the returned object goes out of scope, the memory + is freed. In other words the returned object has + ownership of the value of type 'cdecl' that it points to. This + means that the raw data can be used as long as this object is + kept alive, but must not be used for a longer time. Be careful + about that when copying the pointer to the memory somewhere + else, e.g. into another structure. + """ + if isinstance(cdecl, basestring): + cdecl = self._typeof(cdecl) + return self._backend.newp(cdecl, init) + + def new_allocator(self, alloc=None, free=None, + should_clear_after_alloc=True): + """Return a new allocator, i.e. a function that behaves like ffi.new() + but uses the provided low-level 'alloc' and 'free' functions. + + 'alloc' is called with the size as argument. If it returns NULL, a + MemoryError is raised. 'free' is called with the result of 'alloc' + as argument. Both can be either Python function or directly C + functions. If 'free' is None, then no free function is called. + If both 'alloc' and 'free' are None, the default is used. + + If 'should_clear_after_alloc' is set to False, then the memory + returned by 'alloc' is assumed to be already cleared (or you are + fine with garbage); otherwise CFFI will clear it. + """ + compiled_ffi = self._backend.FFI() + allocator = compiled_ffi.new_allocator(alloc, free, + should_clear_after_alloc) + def allocate(cdecl, init=None): + if isinstance(cdecl, basestring): + cdecl = self._typeof(cdecl) + return allocator(cdecl, init) + return allocate + + def cast(self, cdecl, source): + """Similar to a C cast: returns an instance of the named C + type initialized with the given 'source'. The source is + casted between integers or pointers of any type. + """ + if isinstance(cdecl, basestring): + cdecl = self._typeof(cdecl) + return self._backend.cast(cdecl, source) + + def string(self, cdata, maxlen=-1): + """Return a Python string (or unicode string) from the 'cdata'. + If 'cdata' is a pointer or array of characters or bytes, returns + the null-terminated string. The returned string extends until + the first null character, or at most 'maxlen' characters. If + 'cdata' is an array then 'maxlen' defaults to its length. + + If 'cdata' is a pointer or array of wchar_t, returns a unicode + string following the same rules. + + If 'cdata' is a single character or byte or a wchar_t, returns + it as a string or unicode string. + + If 'cdata' is an enum, returns the value of the enumerator as a + string, or 'NUMBER' if the value is out of range. + """ + return self._backend.string(cdata, maxlen) + + def unpack(self, cdata, length): + """Unpack an array of C data of the given length, + returning a Python string/unicode/list. + + If 'cdata' is a pointer to 'char', returns a byte string. + It does not stop at the first null. This is equivalent to: + ffi.buffer(cdata, length)[:] + + If 'cdata' is a pointer to 'wchar_t', returns a unicode string. + 'length' is measured in wchar_t's; it is not the size in bytes. + + If 'cdata' is a pointer to anything else, returns a list of + 'length' items. This is a faster equivalent to: + [cdata[i] for i in range(length)] + """ + return self._backend.unpack(cdata, length) + + #def buffer(self, cdata, size=-1): + # """Return a read-write buffer object that references the raw C data + # pointed to by the given 'cdata'. The 'cdata' must be a pointer or + # an array. Can be passed to functions expecting a buffer, or directly + # manipulated with: + # + # buf[:] get a copy of it in a regular string, or + # buf[idx] as a single character + # buf[:] = ... + # buf[idx] = ... change the content + # """ + # note that 'buffer' is a type, set on this instance by __init__ + + def from_buffer(self, cdecl, python_buffer=_unspecified, + require_writable=False): + """Return a cdata of the given type pointing to the data of the + given Python object, which must support the buffer interface. + Note that this is not meant to be used on the built-in types + str or unicode (you can build 'char[]' arrays explicitly) + but only on objects containing large quantities of raw data + in some other format, like 'array.array' or numpy arrays. + + The first argument is optional and default to 'char[]'. + """ + if python_buffer is _unspecified: + cdecl, python_buffer = self.BCharA, cdecl + elif isinstance(cdecl, basestring): + cdecl = self._typeof(cdecl) + return self._backend.from_buffer(cdecl, python_buffer, + require_writable) + + def memmove(self, dest, src, n): + """ffi.memmove(dest, src, n) copies n bytes of memory from src to dest. + + Like the C function memmove(), the memory areas may overlap; + apart from that it behaves like the C function memcpy(). + + 'src' can be any cdata ptr or array, or any Python buffer object. + 'dest' can be any cdata ptr or array, or a writable Python buffer + object. The size to copy, 'n', is always measured in bytes. + + Unlike other methods, this one supports all Python buffer including + byte strings and bytearrays---but it still does not support + non-contiguous buffers. + """ + return self._backend.memmove(dest, src, n) + + def callback(self, cdecl, python_callable=None, error=None, onerror=None): + """Return a callback object or a decorator making such a + callback object. 'cdecl' must name a C function pointer type. + The callback invokes the specified 'python_callable' (which may + be provided either directly or via a decorator). Important: the + callback object must be manually kept alive for as long as the + callback may be invoked from the C level. + """ + def callback_decorator_wrap(python_callable): + if not callable(python_callable): + raise TypeError("the 'python_callable' argument " + "is not callable") + return self._backend.callback(cdecl, python_callable, + error, onerror) + if isinstance(cdecl, basestring): + cdecl = self._typeof(cdecl, consider_function_as_funcptr=True) + if python_callable is None: + return callback_decorator_wrap # decorator mode + else: + return callback_decorator_wrap(python_callable) # direct mode + + def getctype(self, cdecl, replace_with=''): + """Return a string giving the C type 'cdecl', which may be itself + a string or a object. If 'replace_with' is given, it gives + extra text to append (or insert for more complicated C types), like + a variable name, or '*' to get actually the C type 'pointer-to-cdecl'. + """ + if isinstance(cdecl, basestring): + cdecl = self._typeof(cdecl) + replace_with = replace_with.strip() + if (replace_with.startswith('*') + and '&[' in self._backend.getcname(cdecl, '&')): + replace_with = '(%s)' % replace_with + elif replace_with and not replace_with[0] in '[(': + replace_with = ' ' + replace_with + return self._backend.getcname(cdecl, replace_with) + + def gc(self, cdata, destructor, size=0): + """Return a new cdata object that points to the same + data. Later, when this new cdata object is garbage-collected, + 'destructor(old_cdata_object)' will be called. + + The optional 'size' gives an estimate of the size, used to + trigger the garbage collection more eagerly. So far only used + on PyPy. It tells the GC that the returned object keeps alive + roughly 'size' bytes of external memory. + """ + return self._backend.gcp(cdata, destructor, size) + + def _get_cached_btype(self, type): + assert self._lock.acquire(False) is False + # call me with the lock! + try: + BType = self._cached_btypes[type] + except KeyError: + finishlist = [] + BType = type.get_cached_btype(self, finishlist) + for type in finishlist: + type.finish_backend_type(self, finishlist) + return BType + + def verify(self, source='', tmpdir=None, **kwargs): + """Verify that the current ffi signatures compile on this + machine, and return a dynamic library object. The dynamic + library can be used to call functions and access global + variables declared in this 'ffi'. The library is compiled + by the C compiler: it gives you C-level API compatibility + (including calling macros). This is unlike 'ffi.dlopen()', + which requires binary compatibility in the signatures. + """ + from .verifier import Verifier, _caller_dir_pycache + # + # If set_unicode(True) was called, insert the UNICODE and + # _UNICODE macro declarations + if self._windows_unicode: + self._apply_windows_unicode(kwargs) + # + # Set the tmpdir here, and not in Verifier.__init__: it picks + # up the caller's directory, which we want to be the caller of + # ffi.verify(), as opposed to the caller of Veritier(). + tmpdir = tmpdir or _caller_dir_pycache() + # + # Make a Verifier() and use it to load the library. + self.verifier = Verifier(self, source, tmpdir, **kwargs) + lib = self.verifier.load_library() + # + # Save the loaded library for keep-alive purposes, even + # if the caller doesn't keep it alive itself (it should). + self._libraries.append(lib) + return lib + + def _get_errno(self): + return self._backend.get_errno() + def _set_errno(self, errno): + self._backend.set_errno(errno) + errno = property(_get_errno, _set_errno, None, + "the value of 'errno' from/to the C calls") + + def getwinerror(self, code=-1): + return self._backend.getwinerror(code) + + def _pointer_to(self, ctype): + with self._lock: + return model.pointer_cache(self, ctype) + + def addressof(self, cdata, *fields_or_indexes): + """Return the address of a . + If 'fields_or_indexes' are given, returns the address of that + field or array item in the structure or array, recursively in + case of nested structures. + """ + try: + ctype = self._backend.typeof(cdata) + except TypeError: + if '__addressof__' in type(cdata).__dict__: + return type(cdata).__addressof__(cdata, *fields_or_indexes) + raise + if fields_or_indexes: + ctype, offset = self._typeoffsetof(ctype, *fields_or_indexes) + else: + if ctype.kind == "pointer": + raise TypeError("addressof(pointer)") + offset = 0 + ctypeptr = self._pointer_to(ctype) + return self._backend.rawaddressof(ctypeptr, cdata, offset) + + def _typeoffsetof(self, ctype, field_or_index, *fields_or_indexes): + ctype, offset = self._backend.typeoffsetof(ctype, field_or_index) + for field1 in fields_or_indexes: + ctype, offset1 = self._backend.typeoffsetof(ctype, field1, 1) + offset += offset1 + return ctype, offset + + def include(self, ffi_to_include): + """Includes the typedefs, structs, unions and enums defined + in another FFI instance. Usage is similar to a #include in C, + where a part of the program might include types defined in + another part for its own usage. Note that the include() + method has no effect on functions, constants and global + variables, which must anyway be accessed directly from the + lib object returned by the original FFI instance. + """ + if not isinstance(ffi_to_include, FFI): + raise TypeError("ffi.include() expects an argument that is also of" + " type cffi.FFI, not %r" % ( + type(ffi_to_include).__name__,)) + if ffi_to_include is self: + raise ValueError("self.include(self)") + with ffi_to_include._lock: + with self._lock: + self._parser.include(ffi_to_include._parser) + self._cdefsources.append('[') + self._cdefsources.extend(ffi_to_include._cdefsources) + self._cdefsources.append(']') + self._included_ffis.append(ffi_to_include) + + def new_handle(self, x): + return self._backend.newp_handle(self.BVoidP, x) + + def from_handle(self, x): + return self._backend.from_handle(x) + + def release(self, x): + self._backend.release(x) + + def set_unicode(self, enabled_flag): + """Windows: if 'enabled_flag' is True, enable the UNICODE and + _UNICODE defines in C, and declare the types like TCHAR and LPTCSTR + to be (pointers to) wchar_t. If 'enabled_flag' is False, + declare these types to be (pointers to) plain 8-bit characters. + This is mostly for backward compatibility; you usually want True. + """ + if self._windows_unicode is not None: + raise ValueError("set_unicode() can only be called once") + enabled_flag = bool(enabled_flag) + if enabled_flag: + self.cdef("typedef wchar_t TBYTE;" + "typedef wchar_t TCHAR;" + "typedef const wchar_t *LPCTSTR;" + "typedef const wchar_t *PCTSTR;" + "typedef wchar_t *LPTSTR;" + "typedef wchar_t *PTSTR;" + "typedef TBYTE *PTBYTE;" + "typedef TCHAR *PTCHAR;") + else: + self.cdef("typedef char TBYTE;" + "typedef char TCHAR;" + "typedef const char *LPCTSTR;" + "typedef const char *PCTSTR;" + "typedef char *LPTSTR;" + "typedef char *PTSTR;" + "typedef TBYTE *PTBYTE;" + "typedef TCHAR *PTCHAR;") + self._windows_unicode = enabled_flag + + def _apply_windows_unicode(self, kwds): + defmacros = kwds.get('define_macros', ()) + if not isinstance(defmacros, (list, tuple)): + raise TypeError("'define_macros' must be a list or tuple") + defmacros = list(defmacros) + [('UNICODE', '1'), + ('_UNICODE', '1')] + kwds['define_macros'] = defmacros + + def _apply_embedding_fix(self, kwds): + # must include an argument like "-lpython2.7" for the compiler + def ensure(key, value): + lst = kwds.setdefault(key, []) + if value not in lst: + lst.append(value) + # + if '__pypy__' in sys.builtin_module_names: + import os + if sys.platform == "win32": + # we need 'libpypy-c.lib'. Current distributions of + # pypy (>= 4.1) contain it as 'libs/python27.lib'. + pythonlib = "python{0[0]}{0[1]}".format(sys.version_info) + if hasattr(sys, 'prefix'): + ensure('library_dirs', os.path.join(sys.prefix, 'libs')) + else: + # we need 'libpypy-c.{so,dylib}', which should be by + # default located in 'sys.prefix/bin' for installed + # systems. + if sys.version_info < (3,): + pythonlib = "pypy-c" + else: + pythonlib = "pypy3-c" + if hasattr(sys, 'prefix'): + ensure('library_dirs', os.path.join(sys.prefix, 'bin')) + # On uninstalled pypy's, the libpypy-c is typically found in + # .../pypy/goal/. + if hasattr(sys, 'prefix'): + ensure('library_dirs', os.path.join(sys.prefix, 'pypy', 'goal')) + else: + if sys.platform == "win32": + template = "python%d%d" + if hasattr(sys, 'gettotalrefcount'): + template += '_d' + else: + try: + import sysconfig + except ImportError: # 2.6 + from cffi._shimmed_dist_utils import sysconfig + template = "python%d.%d" + if sysconfig.get_config_var('DEBUG_EXT'): + template += sysconfig.get_config_var('DEBUG_EXT') + pythonlib = (template % + (sys.hexversion >> 24, (sys.hexversion >> 16) & 0xff)) + if hasattr(sys, 'abiflags'): + pythonlib += sys.abiflags + ensure('libraries', pythonlib) + if sys.platform == "win32": + ensure('extra_link_args', '/MANIFEST') + + def set_source(self, module_name, source, source_extension='.c', **kwds): + import os + if hasattr(self, '_assigned_source'): + raise ValueError("set_source() cannot be called several times " + "per ffi object") + if not isinstance(module_name, basestring): + raise TypeError("'module_name' must be a string") + if os.sep in module_name or (os.altsep and os.altsep in module_name): + raise ValueError("'module_name' must not contain '/': use a dotted " + "name to make a 'package.module' location") + self._assigned_source = (str(module_name), source, + source_extension, kwds) + + def set_source_pkgconfig(self, module_name, pkgconfig_libs, source, + source_extension='.c', **kwds): + from . import pkgconfig + if not isinstance(pkgconfig_libs, list): + raise TypeError("the pkgconfig_libs argument must be a list " + "of package names") + kwds2 = pkgconfig.flags_from_pkgconfig(pkgconfig_libs) + pkgconfig.merge_flags(kwds, kwds2) + self.set_source(module_name, source, source_extension, **kwds) + + def distutils_extension(self, tmpdir='build', verbose=True): + from cffi._shimmed_dist_utils import mkpath + from .recompiler import recompile + # + if not hasattr(self, '_assigned_source'): + if hasattr(self, 'verifier'): # fallback, 'tmpdir' ignored + return self.verifier.get_extension() + raise ValueError("set_source() must be called before" + " distutils_extension()") + module_name, source, source_extension, kwds = self._assigned_source + if source is None: + raise TypeError("distutils_extension() is only for C extension " + "modules, not for dlopen()-style pure Python " + "modules") + mkpath(tmpdir) + ext, updated = recompile(self, module_name, + source, tmpdir=tmpdir, extradir=tmpdir, + source_extension=source_extension, + call_c_compiler=False, **kwds) + if verbose: + if updated: + sys.stderr.write("regenerated: %r\n" % (ext.sources[0],)) + else: + sys.stderr.write("not modified: %r\n" % (ext.sources[0],)) + return ext + + def emit_c_code(self, filename): + from .recompiler import recompile + # + if not hasattr(self, '_assigned_source'): + raise ValueError("set_source() must be called before emit_c_code()") + module_name, source, source_extension, kwds = self._assigned_source + if source is None: + raise TypeError("emit_c_code() is only for C extension modules, " + "not for dlopen()-style pure Python modules") + recompile(self, module_name, source, + c_file=filename, call_c_compiler=False, + uses_ffiplatform=False, **kwds) + + def emit_python_code(self, filename): + from .recompiler import recompile + # + if not hasattr(self, '_assigned_source'): + raise ValueError("set_source() must be called before emit_c_code()") + module_name, source, source_extension, kwds = self._assigned_source + if source is not None: + raise TypeError("emit_python_code() is only for dlopen()-style " + "pure Python modules, not for C extension modules") + recompile(self, module_name, source, + c_file=filename, call_c_compiler=False, + uses_ffiplatform=False, **kwds) + + def compile(self, tmpdir='.', verbose=0, target=None, debug=None): + """The 'target' argument gives the final file name of the + compiled DLL. Use '*' to force distutils' choice, suitable for + regular CPython C API modules. Use a file name ending in '.*' + to ask for the system's default extension for dynamic libraries + (.so/.dll/.dylib). + + The default is '*' when building a non-embedded C API extension, + and (module_name + '.*') when building an embedded library. + """ + from .recompiler import recompile + # + if not hasattr(self, '_assigned_source'): + raise ValueError("set_source() must be called before compile()") + module_name, source, source_extension, kwds = self._assigned_source + return recompile(self, module_name, source, tmpdir=tmpdir, + target=target, source_extension=source_extension, + compiler_verbose=verbose, debug=debug, **kwds) + + def init_once(self, func, tag): + # Read _init_once_cache[tag], which is either (False, lock) if + # we're calling the function now in some thread, or (True, result). + # Don't call setdefault() in most cases, to avoid allocating and + # immediately freeing a lock; but still use setdefaut() to avoid + # races. + try: + x = self._init_once_cache[tag] + except KeyError: + x = self._init_once_cache.setdefault(tag, (False, allocate_lock())) + # Common case: we got (True, result), so we return the result. + if x[0]: + return x[1] + # Else, it's a lock. Acquire it to serialize the following tests. + with x[1]: + # Read again from _init_once_cache the current status. + x = self._init_once_cache[tag] + if x[0]: + return x[1] + # Call the function and store the result back. + result = func() + self._init_once_cache[tag] = (True, result) + return result + + def embedding_init_code(self, pysource): + if self._embedding: + raise ValueError("embedding_init_code() can only be called once") + # fix 'pysource' before it gets dumped into the C file: + # - remove empty lines at the beginning, so it starts at "line 1" + # - dedent, if all non-empty lines are indented + # - check for SyntaxErrors + import re + match = re.match(r'\s*\n', pysource) + if match: + pysource = pysource[match.end():] + lines = pysource.splitlines() or [''] + prefix = re.match(r'\s*', lines[0]).group() + for i in range(1, len(lines)): + line = lines[i] + if line.rstrip(): + while not line.startswith(prefix): + prefix = prefix[:-1] + i = len(prefix) + lines = [line[i:]+'\n' for line in lines] + pysource = ''.join(lines) + # + compile(pysource, "cffi_init", "exec") + # + self._embedding = pysource + + def def_extern(self, *args, **kwds): + raise ValueError("ffi.def_extern() is only available on API-mode FFI " + "objects") + + def list_types(self): + """Returns the user type names known to this FFI instance. + This returns a tuple containing three lists of names: + (typedef_names, names_of_structs, names_of_unions) + """ + typedefs = [] + structs = [] + unions = [] + for key in self._parser._declarations: + if key.startswith('typedef '): + typedefs.append(key[8:]) + elif key.startswith('struct '): + structs.append(key[7:]) + elif key.startswith('union '): + unions.append(key[6:]) + typedefs.sort() + structs.sort() + unions.sort() + return (typedefs, structs, unions) + + +def _load_backend_lib(backend, name, flags): + import os + if not isinstance(name, basestring): + if sys.platform != "win32" or name is not None: + return backend.load_library(name, flags) + name = "c" # Windows: load_library(None) fails, but this works + # on Python 2 (backward compatibility hack only) + first_error = None + if '.' in name or '/' in name or os.sep in name: + try: + return backend.load_library(name, flags) + except OSError as e: + first_error = e + import ctypes.util + path = ctypes.util.find_library(name) + if path is None: + if name == "c" and sys.platform == "win32" and sys.version_info >= (3,): + raise OSError("dlopen(None) cannot work on Windows for Python 3 " + "(see http://bugs.python.org/issue23606)") + msg = ("ctypes.util.find_library() did not manage " + "to locate a library called %r" % (name,)) + if first_error is not None: + msg = "%s. Additionally, %s" % (first_error, msg) + raise OSError(msg) + return backend.load_library(path, flags) + +def _make_ffi_library(ffi, libname, flags): + backend = ffi._backend + backendlib = _load_backend_lib(backend, libname, flags) + # + def accessor_function(name): + key = 'function ' + name + tp, _ = ffi._parser._declarations[key] + BType = ffi._get_cached_btype(tp) + value = backendlib.load_function(BType, name) + library.__dict__[name] = value + # + def accessor_variable(name): + key = 'variable ' + name + tp, _ = ffi._parser._declarations[key] + BType = ffi._get_cached_btype(tp) + read_variable = backendlib.read_variable + write_variable = backendlib.write_variable + setattr(FFILibrary, name, property( + lambda self: read_variable(BType, name), + lambda self, value: write_variable(BType, name, value))) + # + def addressof_var(name): + try: + return addr_variables[name] + except KeyError: + with ffi._lock: + if name not in addr_variables: + key = 'variable ' + name + tp, _ = ffi._parser._declarations[key] + BType = ffi._get_cached_btype(tp) + if BType.kind != 'array': + BType = model.pointer_cache(ffi, BType) + p = backendlib.load_function(BType, name) + addr_variables[name] = p + return addr_variables[name] + # + def accessor_constant(name): + raise NotImplementedError("non-integer constant '%s' cannot be " + "accessed from a dlopen() library" % (name,)) + # + def accessor_int_constant(name): + library.__dict__[name] = ffi._parser._int_constants[name] + # + accessors = {} + accessors_version = [False] + addr_variables = {} + # + def update_accessors(): + if accessors_version[0] is ffi._cdef_version: + return + # + for key, (tp, _) in ffi._parser._declarations.items(): + if not isinstance(tp, model.EnumType): + tag, name = key.split(' ', 1) + if tag == 'function': + accessors[name] = accessor_function + elif tag == 'variable': + accessors[name] = accessor_variable + elif tag == 'constant': + accessors[name] = accessor_constant + else: + for i, enumname in enumerate(tp.enumerators): + def accessor_enum(name, tp=tp, i=i): + tp.check_not_partial() + library.__dict__[name] = tp.enumvalues[i] + accessors[enumname] = accessor_enum + for name in ffi._parser._int_constants: + accessors.setdefault(name, accessor_int_constant) + accessors_version[0] = ffi._cdef_version + # + def make_accessor(name): + with ffi._lock: + if name in library.__dict__ or name in FFILibrary.__dict__: + return # added by another thread while waiting for the lock + if name not in accessors: + update_accessors() + if name not in accessors: + raise AttributeError(name) + accessors[name](name) + # + class FFILibrary(object): + def __getattr__(self, name): + make_accessor(name) + return getattr(self, name) + def __setattr__(self, name, value): + try: + property = getattr(self.__class__, name) + except AttributeError: + make_accessor(name) + setattr(self, name, value) + else: + property.__set__(self, value) + def __dir__(self): + with ffi._lock: + update_accessors() + return accessors.keys() + def __addressof__(self, name): + if name in library.__dict__: + return library.__dict__[name] + if name in FFILibrary.__dict__: + return addressof_var(name) + make_accessor(name) + if name in library.__dict__: + return library.__dict__[name] + if name in FFILibrary.__dict__: + return addressof_var(name) + raise AttributeError("cffi library has no function or " + "global variable named '%s'" % (name,)) + def __cffi_close__(self): + backendlib.close_lib() + self.__dict__.clear() + # + if isinstance(libname, basestring): + try: + if not isinstance(libname, str): # unicode, on Python 2 + libname = libname.encode('utf-8') + FFILibrary.__name__ = 'FFILibrary_%s' % libname + except UnicodeError: + pass + library = FFILibrary() + return library, library.__dict__ + +def _builtin_function_type(func): + # a hack to make at least ffi.typeof(builtin_function) work, + # if the builtin function was obtained by 'vengine_cpy'. + import sys + try: + module = sys.modules[func.__module__] + ffi = module._cffi_original_ffi + types_of_builtin_funcs = module._cffi_types_of_builtin_funcs + tp = types_of_builtin_funcs[func] + except (KeyError, AttributeError, TypeError): + return None + else: + with ffi._lock: + return ffi._get_cached_btype(tp) diff --git a/venv/lib/python3.12/site-packages/cffi/backend_ctypes.py b/venv/lib/python3.12/site-packages/cffi/backend_ctypes.py new file mode 100644 index 00000000..e7956a79 --- /dev/null +++ b/venv/lib/python3.12/site-packages/cffi/backend_ctypes.py @@ -0,0 +1,1121 @@ +import ctypes, ctypes.util, operator, sys +from . import model + +if sys.version_info < (3,): + bytechr = chr +else: + unicode = str + long = int + xrange = range + bytechr = lambda num: bytes([num]) + +class CTypesType(type): + pass + +class CTypesData(object): + __metaclass__ = CTypesType + __slots__ = ['__weakref__'] + __name__ = '' + + def __init__(self, *args): + raise TypeError("cannot instantiate %r" % (self.__class__,)) + + @classmethod + def _newp(cls, init): + raise TypeError("expected a pointer or array ctype, got '%s'" + % (cls._get_c_name(),)) + + @staticmethod + def _to_ctypes(value): + raise TypeError + + @classmethod + def _arg_to_ctypes(cls, *value): + try: + ctype = cls._ctype + except AttributeError: + raise TypeError("cannot create an instance of %r" % (cls,)) + if value: + res = cls._to_ctypes(*value) + if not isinstance(res, ctype): + res = cls._ctype(res) + else: + res = cls._ctype() + return res + + @classmethod + def _create_ctype_obj(cls, init): + if init is None: + return cls._arg_to_ctypes() + else: + return cls._arg_to_ctypes(init) + + @staticmethod + def _from_ctypes(ctypes_value): + raise TypeError + + @classmethod + def _get_c_name(cls, replace_with=''): + return cls._reftypename.replace(' &', replace_with) + + @classmethod + def _fix_class(cls): + cls.__name__ = 'CData<%s>' % (cls._get_c_name(),) + cls.__qualname__ = 'CData<%s>' % (cls._get_c_name(),) + cls.__module__ = 'ffi' + + def _get_own_repr(self): + raise NotImplementedError + + def _addr_repr(self, address): + if address == 0: + return 'NULL' + else: + if address < 0: + address += 1 << (8*ctypes.sizeof(ctypes.c_void_p)) + return '0x%x' % address + + def __repr__(self, c_name=None): + own = self._get_own_repr() + return '' % (c_name or self._get_c_name(), own) + + def _convert_to_address(self, BClass): + if BClass is None: + raise TypeError("cannot convert %r to an address" % ( + self._get_c_name(),)) + else: + raise TypeError("cannot convert %r to %r" % ( + self._get_c_name(), BClass._get_c_name())) + + @classmethod + def _get_size(cls): + return ctypes.sizeof(cls._ctype) + + def _get_size_of_instance(self): + return ctypes.sizeof(self._ctype) + + @classmethod + def _cast_from(cls, source): + raise TypeError("cannot cast to %r" % (cls._get_c_name(),)) + + def _cast_to_integer(self): + return self._convert_to_address(None) + + @classmethod + def _alignment(cls): + return ctypes.alignment(cls._ctype) + + def __iter__(self): + raise TypeError("cdata %r does not support iteration" % ( + self._get_c_name()),) + + def _make_cmp(name): + cmpfunc = getattr(operator, name) + def cmp(self, other): + v_is_ptr = not isinstance(self, CTypesGenericPrimitive) + w_is_ptr = (isinstance(other, CTypesData) and + not isinstance(other, CTypesGenericPrimitive)) + if v_is_ptr and w_is_ptr: + return cmpfunc(self._convert_to_address(None), + other._convert_to_address(None)) + elif v_is_ptr or w_is_ptr: + return NotImplemented + else: + if isinstance(self, CTypesGenericPrimitive): + self = self._value + if isinstance(other, CTypesGenericPrimitive): + other = other._value + return cmpfunc(self, other) + cmp.func_name = name + return cmp + + __eq__ = _make_cmp('__eq__') + __ne__ = _make_cmp('__ne__') + __lt__ = _make_cmp('__lt__') + __le__ = _make_cmp('__le__') + __gt__ = _make_cmp('__gt__') + __ge__ = _make_cmp('__ge__') + + def __hash__(self): + return hash(self._convert_to_address(None)) + + def _to_string(self, maxlen): + raise TypeError("string(): %r" % (self,)) + + +class CTypesGenericPrimitive(CTypesData): + __slots__ = [] + + def __hash__(self): + return hash(self._value) + + def _get_own_repr(self): + return repr(self._from_ctypes(self._value)) + + +class CTypesGenericArray(CTypesData): + __slots__ = [] + + @classmethod + def _newp(cls, init): + return cls(init) + + def __iter__(self): + for i in xrange(len(self)): + yield self[i] + + def _get_own_repr(self): + return self._addr_repr(ctypes.addressof(self._blob)) + + +class CTypesGenericPtr(CTypesData): + __slots__ = ['_address', '_as_ctype_ptr'] + _automatic_casts = False + kind = "pointer" + + @classmethod + def _newp(cls, init): + return cls(init) + + @classmethod + def _cast_from(cls, source): + if source is None: + address = 0 + elif isinstance(source, CTypesData): + address = source._cast_to_integer() + elif isinstance(source, (int, long)): + address = source + else: + raise TypeError("bad type for cast to %r: %r" % + (cls, type(source).__name__)) + return cls._new_pointer_at(address) + + @classmethod + def _new_pointer_at(cls, address): + self = cls.__new__(cls) + self._address = address + self._as_ctype_ptr = ctypes.cast(address, cls._ctype) + return self + + def _get_own_repr(self): + try: + return self._addr_repr(self._address) + except AttributeError: + return '???' + + def _cast_to_integer(self): + return self._address + + def __nonzero__(self): + return bool(self._address) + __bool__ = __nonzero__ + + @classmethod + def _to_ctypes(cls, value): + if not isinstance(value, CTypesData): + raise TypeError("unexpected %s object" % type(value).__name__) + address = value._convert_to_address(cls) + return ctypes.cast(address, cls._ctype) + + @classmethod + def _from_ctypes(cls, ctypes_ptr): + address = ctypes.cast(ctypes_ptr, ctypes.c_void_p).value or 0 + return cls._new_pointer_at(address) + + @classmethod + def _initialize(cls, ctypes_ptr, value): + if value: + ctypes_ptr.contents = cls._to_ctypes(value).contents + + def _convert_to_address(self, BClass): + if (BClass in (self.__class__, None) or BClass._automatic_casts + or self._automatic_casts): + return self._address + else: + return CTypesData._convert_to_address(self, BClass) + + +class CTypesBaseStructOrUnion(CTypesData): + __slots__ = ['_blob'] + + @classmethod + def _create_ctype_obj(cls, init): + # may be overridden + raise TypeError("cannot instantiate opaque type %s" % (cls,)) + + def _get_own_repr(self): + return self._addr_repr(ctypes.addressof(self._blob)) + + @classmethod + def _offsetof(cls, fieldname): + return getattr(cls._ctype, fieldname).offset + + def _convert_to_address(self, BClass): + if getattr(BClass, '_BItem', None) is self.__class__: + return ctypes.addressof(self._blob) + else: + return CTypesData._convert_to_address(self, BClass) + + @classmethod + def _from_ctypes(cls, ctypes_struct_or_union): + self = cls.__new__(cls) + self._blob = ctypes_struct_or_union + return self + + @classmethod + def _to_ctypes(cls, value): + return value._blob + + def __repr__(self, c_name=None): + return CTypesData.__repr__(self, c_name or self._get_c_name(' &')) + + +class CTypesBackend(object): + + PRIMITIVE_TYPES = { + 'char': ctypes.c_char, + 'short': ctypes.c_short, + 'int': ctypes.c_int, + 'long': ctypes.c_long, + 'long long': ctypes.c_longlong, + 'signed char': ctypes.c_byte, + 'unsigned char': ctypes.c_ubyte, + 'unsigned short': ctypes.c_ushort, + 'unsigned int': ctypes.c_uint, + 'unsigned long': ctypes.c_ulong, + 'unsigned long long': ctypes.c_ulonglong, + 'float': ctypes.c_float, + 'double': ctypes.c_double, + '_Bool': ctypes.c_bool, + } + + for _name in ['unsigned long long', 'unsigned long', + 'unsigned int', 'unsigned short', 'unsigned char']: + _size = ctypes.sizeof(PRIMITIVE_TYPES[_name]) + PRIMITIVE_TYPES['uint%d_t' % (8*_size)] = PRIMITIVE_TYPES[_name] + if _size == ctypes.sizeof(ctypes.c_void_p): + PRIMITIVE_TYPES['uintptr_t'] = PRIMITIVE_TYPES[_name] + if _size == ctypes.sizeof(ctypes.c_size_t): + PRIMITIVE_TYPES['size_t'] = PRIMITIVE_TYPES[_name] + + for _name in ['long long', 'long', 'int', 'short', 'signed char']: + _size = ctypes.sizeof(PRIMITIVE_TYPES[_name]) + PRIMITIVE_TYPES['int%d_t' % (8*_size)] = PRIMITIVE_TYPES[_name] + if _size == ctypes.sizeof(ctypes.c_void_p): + PRIMITIVE_TYPES['intptr_t'] = PRIMITIVE_TYPES[_name] + PRIMITIVE_TYPES['ptrdiff_t'] = PRIMITIVE_TYPES[_name] + if _size == ctypes.sizeof(ctypes.c_size_t): + PRIMITIVE_TYPES['ssize_t'] = PRIMITIVE_TYPES[_name] + + + def __init__(self): + self.RTLD_LAZY = 0 # not supported anyway by ctypes + self.RTLD_NOW = 0 + self.RTLD_GLOBAL = ctypes.RTLD_GLOBAL + self.RTLD_LOCAL = ctypes.RTLD_LOCAL + + def set_ffi(self, ffi): + self.ffi = ffi + + def _get_types(self): + return CTypesData, CTypesType + + def load_library(self, path, flags=0): + cdll = ctypes.CDLL(path, flags) + return CTypesLibrary(self, cdll) + + def new_void_type(self): + class CTypesVoid(CTypesData): + __slots__ = [] + _reftypename = 'void &' + @staticmethod + def _from_ctypes(novalue): + return None + @staticmethod + def _to_ctypes(novalue): + if novalue is not None: + raise TypeError("None expected, got %s object" % + (type(novalue).__name__,)) + return None + CTypesVoid._fix_class() + return CTypesVoid + + def new_primitive_type(self, name): + if name == 'wchar_t': + raise NotImplementedError(name) + ctype = self.PRIMITIVE_TYPES[name] + if name == 'char': + kind = 'char' + elif name in ('float', 'double'): + kind = 'float' + else: + if name in ('signed char', 'unsigned char'): + kind = 'byte' + elif name == '_Bool': + kind = 'bool' + else: + kind = 'int' + is_signed = (ctype(-1).value == -1) + # + def _cast_source_to_int(source): + if isinstance(source, (int, long, float)): + source = int(source) + elif isinstance(source, CTypesData): + source = source._cast_to_integer() + elif isinstance(source, bytes): + source = ord(source) + elif source is None: + source = 0 + else: + raise TypeError("bad type for cast to %r: %r" % + (CTypesPrimitive, type(source).__name__)) + return source + # + kind1 = kind + class CTypesPrimitive(CTypesGenericPrimitive): + __slots__ = ['_value'] + _ctype = ctype + _reftypename = '%s &' % name + kind = kind1 + + def __init__(self, value): + self._value = value + + @staticmethod + def _create_ctype_obj(init): + if init is None: + return ctype() + return ctype(CTypesPrimitive._to_ctypes(init)) + + if kind == 'int' or kind == 'byte': + @classmethod + def _cast_from(cls, source): + source = _cast_source_to_int(source) + source = ctype(source).value # cast within range + return cls(source) + def __int__(self): + return self._value + + if kind == 'bool': + @classmethod + def _cast_from(cls, source): + if not isinstance(source, (int, long, float)): + source = _cast_source_to_int(source) + return cls(bool(source)) + def __int__(self): + return int(self._value) + + if kind == 'char': + @classmethod + def _cast_from(cls, source): + source = _cast_source_to_int(source) + source = bytechr(source & 0xFF) + return cls(source) + def __int__(self): + return ord(self._value) + + if kind == 'float': + @classmethod + def _cast_from(cls, source): + if isinstance(source, float): + pass + elif isinstance(source, CTypesGenericPrimitive): + if hasattr(source, '__float__'): + source = float(source) + else: + source = int(source) + else: + source = _cast_source_to_int(source) + source = ctype(source).value # fix precision + return cls(source) + def __int__(self): + return int(self._value) + def __float__(self): + return self._value + + _cast_to_integer = __int__ + + if kind == 'int' or kind == 'byte' or kind == 'bool': + @staticmethod + def _to_ctypes(x): + if not isinstance(x, (int, long)): + if isinstance(x, CTypesData): + x = int(x) + else: + raise TypeError("integer expected, got %s" % + type(x).__name__) + if ctype(x).value != x: + if not is_signed and x < 0: + raise OverflowError("%s: negative integer" % name) + else: + raise OverflowError("%s: integer out of bounds" + % name) + return x + + if kind == 'char': + @staticmethod + def _to_ctypes(x): + if isinstance(x, bytes) and len(x) == 1: + return x + if isinstance(x, CTypesPrimitive): # > + return x._value + raise TypeError("character expected, got %s" % + type(x).__name__) + def __nonzero__(self): + return ord(self._value) != 0 + else: + def __nonzero__(self): + return self._value != 0 + __bool__ = __nonzero__ + + if kind == 'float': + @staticmethod + def _to_ctypes(x): + if not isinstance(x, (int, long, float, CTypesData)): + raise TypeError("float expected, got %s" % + type(x).__name__) + return ctype(x).value + + @staticmethod + def _from_ctypes(value): + return getattr(value, 'value', value) + + @staticmethod + def _initialize(blob, init): + blob.value = CTypesPrimitive._to_ctypes(init) + + if kind == 'char': + def _to_string(self, maxlen): + return self._value + if kind == 'byte': + def _to_string(self, maxlen): + return chr(self._value & 0xff) + # + CTypesPrimitive._fix_class() + return CTypesPrimitive + + def new_pointer_type(self, BItem): + getbtype = self.ffi._get_cached_btype + if BItem is getbtype(model.PrimitiveType('char')): + kind = 'charp' + elif BItem in (getbtype(model.PrimitiveType('signed char')), + getbtype(model.PrimitiveType('unsigned char'))): + kind = 'bytep' + elif BItem is getbtype(model.void_type): + kind = 'voidp' + else: + kind = 'generic' + # + class CTypesPtr(CTypesGenericPtr): + __slots__ = ['_own'] + if kind == 'charp': + __slots__ += ['__as_strbuf'] + _BItem = BItem + if hasattr(BItem, '_ctype'): + _ctype = ctypes.POINTER(BItem._ctype) + _bitem_size = ctypes.sizeof(BItem._ctype) + else: + _ctype = ctypes.c_void_p + if issubclass(BItem, CTypesGenericArray): + _reftypename = BItem._get_c_name('(* &)') + else: + _reftypename = BItem._get_c_name(' * &') + + def __init__(self, init): + ctypeobj = BItem._create_ctype_obj(init) + if kind == 'charp': + self.__as_strbuf = ctypes.create_string_buffer( + ctypeobj.value + b'\x00') + self._as_ctype_ptr = ctypes.cast( + self.__as_strbuf, self._ctype) + else: + self._as_ctype_ptr = ctypes.pointer(ctypeobj) + self._address = ctypes.cast(self._as_ctype_ptr, + ctypes.c_void_p).value + self._own = True + + def __add__(self, other): + if isinstance(other, (int, long)): + return self._new_pointer_at(self._address + + other * self._bitem_size) + else: + return NotImplemented + + def __sub__(self, other): + if isinstance(other, (int, long)): + return self._new_pointer_at(self._address - + other * self._bitem_size) + elif type(self) is type(other): + return (self._address - other._address) // self._bitem_size + else: + return NotImplemented + + def __getitem__(self, index): + if getattr(self, '_own', False) and index != 0: + raise IndexError + return BItem._from_ctypes(self._as_ctype_ptr[index]) + + def __setitem__(self, index, value): + self._as_ctype_ptr[index] = BItem._to_ctypes(value) + + if kind == 'charp' or kind == 'voidp': + @classmethod + def _arg_to_ctypes(cls, *value): + if value and isinstance(value[0], bytes): + return ctypes.c_char_p(value[0]) + else: + return super(CTypesPtr, cls)._arg_to_ctypes(*value) + + if kind == 'charp' or kind == 'bytep': + def _to_string(self, maxlen): + if maxlen < 0: + maxlen = sys.maxsize + p = ctypes.cast(self._as_ctype_ptr, + ctypes.POINTER(ctypes.c_char)) + n = 0 + while n < maxlen and p[n] != b'\x00': + n += 1 + return b''.join([p[i] for i in range(n)]) + + def _get_own_repr(self): + if getattr(self, '_own', False): + return 'owning %d bytes' % ( + ctypes.sizeof(self._as_ctype_ptr.contents),) + return super(CTypesPtr, self)._get_own_repr() + # + if (BItem is self.ffi._get_cached_btype(model.void_type) or + BItem is self.ffi._get_cached_btype(model.PrimitiveType('char'))): + CTypesPtr._automatic_casts = True + # + CTypesPtr._fix_class() + return CTypesPtr + + def new_array_type(self, CTypesPtr, length): + if length is None: + brackets = ' &[]' + else: + brackets = ' &[%d]' % length + BItem = CTypesPtr._BItem + getbtype = self.ffi._get_cached_btype + if BItem is getbtype(model.PrimitiveType('char')): + kind = 'char' + elif BItem in (getbtype(model.PrimitiveType('signed char')), + getbtype(model.PrimitiveType('unsigned char'))): + kind = 'byte' + else: + kind = 'generic' + # + class CTypesArray(CTypesGenericArray): + __slots__ = ['_blob', '_own'] + if length is not None: + _ctype = BItem._ctype * length + else: + __slots__.append('_ctype') + _reftypename = BItem._get_c_name(brackets) + _declared_length = length + _CTPtr = CTypesPtr + + def __init__(self, init): + if length is None: + if isinstance(init, (int, long)): + len1 = init + init = None + elif kind == 'char' and isinstance(init, bytes): + len1 = len(init) + 1 # extra null + else: + init = tuple(init) + len1 = len(init) + self._ctype = BItem._ctype * len1 + self._blob = self._ctype() + self._own = True + if init is not None: + self._initialize(self._blob, init) + + @staticmethod + def _initialize(blob, init): + if isinstance(init, bytes): + init = [init[i:i+1] for i in range(len(init))] + else: + if isinstance(init, CTypesGenericArray): + if (len(init) != len(blob) or + not isinstance(init, CTypesArray)): + raise TypeError("length/type mismatch: %s" % (init,)) + init = tuple(init) + if len(init) > len(blob): + raise IndexError("too many initializers") + addr = ctypes.cast(blob, ctypes.c_void_p).value + PTR = ctypes.POINTER(BItem._ctype) + itemsize = ctypes.sizeof(BItem._ctype) + for i, value in enumerate(init): + p = ctypes.cast(addr + i * itemsize, PTR) + BItem._initialize(p.contents, value) + + def __len__(self): + return len(self._blob) + + def __getitem__(self, index): + if not (0 <= index < len(self._blob)): + raise IndexError + return BItem._from_ctypes(self._blob[index]) + + def __setitem__(self, index, value): + if not (0 <= index < len(self._blob)): + raise IndexError + self._blob[index] = BItem._to_ctypes(value) + + if kind == 'char' or kind == 'byte': + def _to_string(self, maxlen): + if maxlen < 0: + maxlen = len(self._blob) + p = ctypes.cast(self._blob, + ctypes.POINTER(ctypes.c_char)) + n = 0 + while n < maxlen and p[n] != b'\x00': + n += 1 + return b''.join([p[i] for i in range(n)]) + + def _get_own_repr(self): + if getattr(self, '_own', False): + return 'owning %d bytes' % (ctypes.sizeof(self._blob),) + return super(CTypesArray, self)._get_own_repr() + + def _convert_to_address(self, BClass): + if BClass in (CTypesPtr, None) or BClass._automatic_casts: + return ctypes.addressof(self._blob) + else: + return CTypesData._convert_to_address(self, BClass) + + @staticmethod + def _from_ctypes(ctypes_array): + self = CTypesArray.__new__(CTypesArray) + self._blob = ctypes_array + return self + + @staticmethod + def _arg_to_ctypes(value): + return CTypesPtr._arg_to_ctypes(value) + + def __add__(self, other): + if isinstance(other, (int, long)): + return CTypesPtr._new_pointer_at( + ctypes.addressof(self._blob) + + other * ctypes.sizeof(BItem._ctype)) + else: + return NotImplemented + + @classmethod + def _cast_from(cls, source): + raise NotImplementedError("casting to %r" % ( + cls._get_c_name(),)) + # + CTypesArray._fix_class() + return CTypesArray + + def _new_struct_or_union(self, kind, name, base_ctypes_class): + # + class struct_or_union(base_ctypes_class): + pass + struct_or_union.__name__ = '%s_%s' % (kind, name) + kind1 = kind + # + class CTypesStructOrUnion(CTypesBaseStructOrUnion): + __slots__ = ['_blob'] + _ctype = struct_or_union + _reftypename = '%s &' % (name,) + _kind = kind = kind1 + # + CTypesStructOrUnion._fix_class() + return CTypesStructOrUnion + + def new_struct_type(self, name): + return self._new_struct_or_union('struct', name, ctypes.Structure) + + def new_union_type(self, name): + return self._new_struct_or_union('union', name, ctypes.Union) + + def complete_struct_or_union(self, CTypesStructOrUnion, fields, tp, + totalsize=-1, totalalignment=-1, sflags=0, + pack=0): + if totalsize >= 0 or totalalignment >= 0: + raise NotImplementedError("the ctypes backend of CFFI does not support " + "structures completed by verify(); please " + "compile and install the _cffi_backend module.") + struct_or_union = CTypesStructOrUnion._ctype + fnames = [fname for (fname, BField, bitsize) in fields] + btypes = [BField for (fname, BField, bitsize) in fields] + bitfields = [bitsize for (fname, BField, bitsize) in fields] + # + bfield_types = {} + cfields = [] + for (fname, BField, bitsize) in fields: + if bitsize < 0: + cfields.append((fname, BField._ctype)) + bfield_types[fname] = BField + else: + cfields.append((fname, BField._ctype, bitsize)) + bfield_types[fname] = Ellipsis + if sflags & 8: + struct_or_union._pack_ = 1 + elif pack: + struct_or_union._pack_ = pack + struct_or_union._fields_ = cfields + CTypesStructOrUnion._bfield_types = bfield_types + # + @staticmethod + def _create_ctype_obj(init): + result = struct_or_union() + if init is not None: + initialize(result, init) + return result + CTypesStructOrUnion._create_ctype_obj = _create_ctype_obj + # + def initialize(blob, init): + if is_union: + if len(init) > 1: + raise ValueError("union initializer: %d items given, but " + "only one supported (use a dict if needed)" + % (len(init),)) + if not isinstance(init, dict): + if isinstance(init, (bytes, unicode)): + raise TypeError("union initializer: got a str") + init = tuple(init) + if len(init) > len(fnames): + raise ValueError("too many values for %s initializer" % + CTypesStructOrUnion._get_c_name()) + init = dict(zip(fnames, init)) + addr = ctypes.addressof(blob) + for fname, value in init.items(): + BField, bitsize = name2fieldtype[fname] + assert bitsize < 0, \ + "not implemented: initializer with bit fields" + offset = CTypesStructOrUnion._offsetof(fname) + PTR = ctypes.POINTER(BField._ctype) + p = ctypes.cast(addr + offset, PTR) + BField._initialize(p.contents, value) + is_union = CTypesStructOrUnion._kind == 'union' + name2fieldtype = dict(zip(fnames, zip(btypes, bitfields))) + # + for fname, BField, bitsize in fields: + if fname == '': + raise NotImplementedError("nested anonymous structs/unions") + if hasattr(CTypesStructOrUnion, fname): + raise ValueError("the field name %r conflicts in " + "the ctypes backend" % fname) + if bitsize < 0: + def getter(self, fname=fname, BField=BField, + offset=CTypesStructOrUnion._offsetof(fname), + PTR=ctypes.POINTER(BField._ctype)): + addr = ctypes.addressof(self._blob) + p = ctypes.cast(addr + offset, PTR) + return BField._from_ctypes(p.contents) + def setter(self, value, fname=fname, BField=BField): + setattr(self._blob, fname, BField._to_ctypes(value)) + # + if issubclass(BField, CTypesGenericArray): + setter = None + if BField._declared_length == 0: + def getter(self, fname=fname, BFieldPtr=BField._CTPtr, + offset=CTypesStructOrUnion._offsetof(fname), + PTR=ctypes.POINTER(BField._ctype)): + addr = ctypes.addressof(self._blob) + p = ctypes.cast(addr + offset, PTR) + return BFieldPtr._from_ctypes(p) + # + else: + def getter(self, fname=fname, BField=BField): + return BField._from_ctypes(getattr(self._blob, fname)) + def setter(self, value, fname=fname, BField=BField): + # xxx obscure workaround + value = BField._to_ctypes(value) + oldvalue = getattr(self._blob, fname) + setattr(self._blob, fname, value) + if value != getattr(self._blob, fname): + setattr(self._blob, fname, oldvalue) + raise OverflowError("value too large for bitfield") + setattr(CTypesStructOrUnion, fname, property(getter, setter)) + # + CTypesPtr = self.ffi._get_cached_btype(model.PointerType(tp)) + for fname in fnames: + if hasattr(CTypesPtr, fname): + raise ValueError("the field name %r conflicts in " + "the ctypes backend" % fname) + def getter(self, fname=fname): + return getattr(self[0], fname) + def setter(self, value, fname=fname): + setattr(self[0], fname, value) + setattr(CTypesPtr, fname, property(getter, setter)) + + def new_function_type(self, BArgs, BResult, has_varargs): + nameargs = [BArg._get_c_name() for BArg in BArgs] + if has_varargs: + nameargs.append('...') + nameargs = ', '.join(nameargs) + # + class CTypesFunctionPtr(CTypesGenericPtr): + __slots__ = ['_own_callback', '_name'] + _ctype = ctypes.CFUNCTYPE(getattr(BResult, '_ctype', None), + *[BArg._ctype for BArg in BArgs], + use_errno=True) + _reftypename = BResult._get_c_name('(* &)(%s)' % (nameargs,)) + + def __init__(self, init, error=None): + # create a callback to the Python callable init() + import traceback + assert not has_varargs, "varargs not supported for callbacks" + if getattr(BResult, '_ctype', None) is not None: + error = BResult._from_ctypes( + BResult._create_ctype_obj(error)) + else: + error = None + def callback(*args): + args2 = [] + for arg, BArg in zip(args, BArgs): + args2.append(BArg._from_ctypes(arg)) + try: + res2 = init(*args2) + res2 = BResult._to_ctypes(res2) + except: + traceback.print_exc() + res2 = error + if issubclass(BResult, CTypesGenericPtr): + if res2: + res2 = ctypes.cast(res2, ctypes.c_void_p).value + # .value: http://bugs.python.org/issue1574593 + else: + res2 = None + #print repr(res2) + return res2 + if issubclass(BResult, CTypesGenericPtr): + # The only pointers callbacks can return are void*s: + # http://bugs.python.org/issue5710 + callback_ctype = ctypes.CFUNCTYPE( + ctypes.c_void_p, + *[BArg._ctype for BArg in BArgs], + use_errno=True) + else: + callback_ctype = CTypesFunctionPtr._ctype + self._as_ctype_ptr = callback_ctype(callback) + self._address = ctypes.cast(self._as_ctype_ptr, + ctypes.c_void_p).value + self._own_callback = init + + @staticmethod + def _initialize(ctypes_ptr, value): + if value: + raise NotImplementedError("ctypes backend: not supported: " + "initializers for function pointers") + + def __repr__(self): + c_name = getattr(self, '_name', None) + if c_name: + i = self._reftypename.index('(* &)') + if self._reftypename[i-1] not in ' )*': + c_name = ' ' + c_name + c_name = self._reftypename.replace('(* &)', c_name) + return CTypesData.__repr__(self, c_name) + + def _get_own_repr(self): + if getattr(self, '_own_callback', None) is not None: + return 'calling %r' % (self._own_callback,) + return super(CTypesFunctionPtr, self)._get_own_repr() + + def __call__(self, *args): + if has_varargs: + assert len(args) >= len(BArgs) + extraargs = args[len(BArgs):] + args = args[:len(BArgs)] + else: + assert len(args) == len(BArgs) + ctypes_args = [] + for arg, BArg in zip(args, BArgs): + ctypes_args.append(BArg._arg_to_ctypes(arg)) + if has_varargs: + for i, arg in enumerate(extraargs): + if arg is None: + ctypes_args.append(ctypes.c_void_p(0)) # NULL + continue + if not isinstance(arg, CTypesData): + raise TypeError( + "argument %d passed in the variadic part " + "needs to be a cdata object (got %s)" % + (1 + len(BArgs) + i, type(arg).__name__)) + ctypes_args.append(arg._arg_to_ctypes(arg)) + result = self._as_ctype_ptr(*ctypes_args) + return BResult._from_ctypes(result) + # + CTypesFunctionPtr._fix_class() + return CTypesFunctionPtr + + def new_enum_type(self, name, enumerators, enumvalues, CTypesInt): + assert isinstance(name, str) + reverse_mapping = dict(zip(reversed(enumvalues), + reversed(enumerators))) + # + class CTypesEnum(CTypesInt): + __slots__ = [] + _reftypename = '%s &' % name + + def _get_own_repr(self): + value = self._value + try: + return '%d: %s' % (value, reverse_mapping[value]) + except KeyError: + return str(value) + + def _to_string(self, maxlen): + value = self._value + try: + return reverse_mapping[value] + except KeyError: + return str(value) + # + CTypesEnum._fix_class() + return CTypesEnum + + def get_errno(self): + return ctypes.get_errno() + + def set_errno(self, value): + ctypes.set_errno(value) + + def string(self, b, maxlen=-1): + return b._to_string(maxlen) + + def buffer(self, bptr, size=-1): + raise NotImplementedError("buffer() with ctypes backend") + + def sizeof(self, cdata_or_BType): + if isinstance(cdata_or_BType, CTypesData): + return cdata_or_BType._get_size_of_instance() + else: + assert issubclass(cdata_or_BType, CTypesData) + return cdata_or_BType._get_size() + + def alignof(self, BType): + assert issubclass(BType, CTypesData) + return BType._alignment() + + def newp(self, BType, source): + if not issubclass(BType, CTypesData): + raise TypeError + return BType._newp(source) + + def cast(self, BType, source): + return BType._cast_from(source) + + def callback(self, BType, source, error, onerror): + assert onerror is None # XXX not implemented + return BType(source, error) + + _weakref_cache_ref = None + + def gcp(self, cdata, destructor, size=0): + if self._weakref_cache_ref is None: + import weakref + class MyRef(weakref.ref): + def __eq__(self, other): + myref = self() + return self is other or ( + myref is not None and myref is other()) + def __ne__(self, other): + return not (self == other) + def __hash__(self): + try: + return self._hash + except AttributeError: + self._hash = hash(self()) + return self._hash + self._weakref_cache_ref = {}, MyRef + weak_cache, MyRef = self._weakref_cache_ref + + if destructor is None: + try: + del weak_cache[MyRef(cdata)] + except KeyError: + raise TypeError("Can remove destructor only on a object " + "previously returned by ffi.gc()") + return None + + def remove(k): + cdata, destructor = weak_cache.pop(k, (None, None)) + if destructor is not None: + destructor(cdata) + + new_cdata = self.cast(self.typeof(cdata), cdata) + assert new_cdata is not cdata + weak_cache[MyRef(new_cdata, remove)] = (cdata, destructor) + return new_cdata + + typeof = type + + def getcname(self, BType, replace_with): + return BType._get_c_name(replace_with) + + def typeoffsetof(self, BType, fieldname, num=0): + if isinstance(fieldname, str): + if num == 0 and issubclass(BType, CTypesGenericPtr): + BType = BType._BItem + if not issubclass(BType, CTypesBaseStructOrUnion): + raise TypeError("expected a struct or union ctype") + BField = BType._bfield_types[fieldname] + if BField is Ellipsis: + raise TypeError("not supported for bitfields") + return (BField, BType._offsetof(fieldname)) + elif isinstance(fieldname, (int, long)): + if issubclass(BType, CTypesGenericArray): + BType = BType._CTPtr + if not issubclass(BType, CTypesGenericPtr): + raise TypeError("expected an array or ptr ctype") + BItem = BType._BItem + offset = BItem._get_size() * fieldname + if offset > sys.maxsize: + raise OverflowError + return (BItem, offset) + else: + raise TypeError(type(fieldname)) + + def rawaddressof(self, BTypePtr, cdata, offset=None): + if isinstance(cdata, CTypesBaseStructOrUnion): + ptr = ctypes.pointer(type(cdata)._to_ctypes(cdata)) + elif isinstance(cdata, CTypesGenericPtr): + if offset is None or not issubclass(type(cdata)._BItem, + CTypesBaseStructOrUnion): + raise TypeError("unexpected cdata type") + ptr = type(cdata)._to_ctypes(cdata) + elif isinstance(cdata, CTypesGenericArray): + ptr = type(cdata)._to_ctypes(cdata) + else: + raise TypeError("expected a ") + if offset: + ptr = ctypes.cast( + ctypes.c_void_p( + ctypes.cast(ptr, ctypes.c_void_p).value + offset), + type(ptr)) + return BTypePtr._from_ctypes(ptr) + + +class CTypesLibrary(object): + + def __init__(self, backend, cdll): + self.backend = backend + self.cdll = cdll + + def load_function(self, BType, name): + c_func = getattr(self.cdll, name) + funcobj = BType._from_ctypes(c_func) + funcobj._name = name + return funcobj + + def read_variable(self, BType, name): + try: + ctypes_obj = BType._ctype.in_dll(self.cdll, name) + except AttributeError as e: + raise NotImplementedError(e) + return BType._from_ctypes(ctypes_obj) + + def write_variable(self, BType, name, value): + new_ctypes_obj = BType._to_ctypes(value) + ctypes_obj = BType._ctype.in_dll(self.cdll, name) + ctypes.memmove(ctypes.addressof(ctypes_obj), + ctypes.addressof(new_ctypes_obj), + ctypes.sizeof(BType._ctype)) diff --git a/venv/lib/python3.12/site-packages/cffi/cffi_opcode.py b/venv/lib/python3.12/site-packages/cffi/cffi_opcode.py new file mode 100644 index 00000000..6421df62 --- /dev/null +++ b/venv/lib/python3.12/site-packages/cffi/cffi_opcode.py @@ -0,0 +1,187 @@ +from .error import VerificationError + +class CffiOp(object): + def __init__(self, op, arg): + self.op = op + self.arg = arg + + def as_c_expr(self): + if self.op is None: + assert isinstance(self.arg, str) + return '(_cffi_opcode_t)(%s)' % (self.arg,) + classname = CLASS_NAME[self.op] + return '_CFFI_OP(_CFFI_OP_%s, %s)' % (classname, self.arg) + + def as_python_bytes(self): + if self.op is None and self.arg.isdigit(): + value = int(self.arg) # non-negative: '-' not in self.arg + if value >= 2**31: + raise OverflowError("cannot emit %r: limited to 2**31-1" + % (self.arg,)) + return format_four_bytes(value) + if isinstance(self.arg, str): + raise VerificationError("cannot emit to Python: %r" % (self.arg,)) + return format_four_bytes((self.arg << 8) | self.op) + + def __str__(self): + classname = CLASS_NAME.get(self.op, self.op) + return '(%s %s)' % (classname, self.arg) + +def format_four_bytes(num): + return '\\x%02X\\x%02X\\x%02X\\x%02X' % ( + (num >> 24) & 0xFF, + (num >> 16) & 0xFF, + (num >> 8) & 0xFF, + (num ) & 0xFF) + +OP_PRIMITIVE = 1 +OP_POINTER = 3 +OP_ARRAY = 5 +OP_OPEN_ARRAY = 7 +OP_STRUCT_UNION = 9 +OP_ENUM = 11 +OP_FUNCTION = 13 +OP_FUNCTION_END = 15 +OP_NOOP = 17 +OP_BITFIELD = 19 +OP_TYPENAME = 21 +OP_CPYTHON_BLTN_V = 23 # varargs +OP_CPYTHON_BLTN_N = 25 # noargs +OP_CPYTHON_BLTN_O = 27 # O (i.e. a single arg) +OP_CONSTANT = 29 +OP_CONSTANT_INT = 31 +OP_GLOBAL_VAR = 33 +OP_DLOPEN_FUNC = 35 +OP_DLOPEN_CONST = 37 +OP_GLOBAL_VAR_F = 39 +OP_EXTERN_PYTHON = 41 + +PRIM_VOID = 0 +PRIM_BOOL = 1 +PRIM_CHAR = 2 +PRIM_SCHAR = 3 +PRIM_UCHAR = 4 +PRIM_SHORT = 5 +PRIM_USHORT = 6 +PRIM_INT = 7 +PRIM_UINT = 8 +PRIM_LONG = 9 +PRIM_ULONG = 10 +PRIM_LONGLONG = 11 +PRIM_ULONGLONG = 12 +PRIM_FLOAT = 13 +PRIM_DOUBLE = 14 +PRIM_LONGDOUBLE = 15 + +PRIM_WCHAR = 16 +PRIM_INT8 = 17 +PRIM_UINT8 = 18 +PRIM_INT16 = 19 +PRIM_UINT16 = 20 +PRIM_INT32 = 21 +PRIM_UINT32 = 22 +PRIM_INT64 = 23 +PRIM_UINT64 = 24 +PRIM_INTPTR = 25 +PRIM_UINTPTR = 26 +PRIM_PTRDIFF = 27 +PRIM_SIZE = 28 +PRIM_SSIZE = 29 +PRIM_INT_LEAST8 = 30 +PRIM_UINT_LEAST8 = 31 +PRIM_INT_LEAST16 = 32 +PRIM_UINT_LEAST16 = 33 +PRIM_INT_LEAST32 = 34 +PRIM_UINT_LEAST32 = 35 +PRIM_INT_LEAST64 = 36 +PRIM_UINT_LEAST64 = 37 +PRIM_INT_FAST8 = 38 +PRIM_UINT_FAST8 = 39 +PRIM_INT_FAST16 = 40 +PRIM_UINT_FAST16 = 41 +PRIM_INT_FAST32 = 42 +PRIM_UINT_FAST32 = 43 +PRIM_INT_FAST64 = 44 +PRIM_UINT_FAST64 = 45 +PRIM_INTMAX = 46 +PRIM_UINTMAX = 47 +PRIM_FLOATCOMPLEX = 48 +PRIM_DOUBLECOMPLEX = 49 +PRIM_CHAR16 = 50 +PRIM_CHAR32 = 51 + +_NUM_PRIM = 52 +_UNKNOWN_PRIM = -1 +_UNKNOWN_FLOAT_PRIM = -2 +_UNKNOWN_LONG_DOUBLE = -3 + +_IO_FILE_STRUCT = -1 + +PRIMITIVE_TO_INDEX = { + 'char': PRIM_CHAR, + 'short': PRIM_SHORT, + 'int': PRIM_INT, + 'long': PRIM_LONG, + 'long long': PRIM_LONGLONG, + 'signed char': PRIM_SCHAR, + 'unsigned char': PRIM_UCHAR, + 'unsigned short': PRIM_USHORT, + 'unsigned int': PRIM_UINT, + 'unsigned long': PRIM_ULONG, + 'unsigned long long': PRIM_ULONGLONG, + 'float': PRIM_FLOAT, + 'double': PRIM_DOUBLE, + 'long double': PRIM_LONGDOUBLE, + '_cffi_float_complex_t': PRIM_FLOATCOMPLEX, + '_cffi_double_complex_t': PRIM_DOUBLECOMPLEX, + '_Bool': PRIM_BOOL, + 'wchar_t': PRIM_WCHAR, + 'char16_t': PRIM_CHAR16, + 'char32_t': PRIM_CHAR32, + 'int8_t': PRIM_INT8, + 'uint8_t': PRIM_UINT8, + 'int16_t': PRIM_INT16, + 'uint16_t': PRIM_UINT16, + 'int32_t': PRIM_INT32, + 'uint32_t': PRIM_UINT32, + 'int64_t': PRIM_INT64, + 'uint64_t': PRIM_UINT64, + 'intptr_t': PRIM_INTPTR, + 'uintptr_t': PRIM_UINTPTR, + 'ptrdiff_t': PRIM_PTRDIFF, + 'size_t': PRIM_SIZE, + 'ssize_t': PRIM_SSIZE, + 'int_least8_t': PRIM_INT_LEAST8, + 'uint_least8_t': PRIM_UINT_LEAST8, + 'int_least16_t': PRIM_INT_LEAST16, + 'uint_least16_t': PRIM_UINT_LEAST16, + 'int_least32_t': PRIM_INT_LEAST32, + 'uint_least32_t': PRIM_UINT_LEAST32, + 'int_least64_t': PRIM_INT_LEAST64, + 'uint_least64_t': PRIM_UINT_LEAST64, + 'int_fast8_t': PRIM_INT_FAST8, + 'uint_fast8_t': PRIM_UINT_FAST8, + 'int_fast16_t': PRIM_INT_FAST16, + 'uint_fast16_t': PRIM_UINT_FAST16, + 'int_fast32_t': PRIM_INT_FAST32, + 'uint_fast32_t': PRIM_UINT_FAST32, + 'int_fast64_t': PRIM_INT_FAST64, + 'uint_fast64_t': PRIM_UINT_FAST64, + 'intmax_t': PRIM_INTMAX, + 'uintmax_t': PRIM_UINTMAX, + } + +F_UNION = 0x01 +F_CHECK_FIELDS = 0x02 +F_PACKED = 0x04 +F_EXTERNAL = 0x08 +F_OPAQUE = 0x10 + +G_FLAGS = dict([('_CFFI_' + _key, globals()[_key]) + for _key in ['F_UNION', 'F_CHECK_FIELDS', 'F_PACKED', + 'F_EXTERNAL', 'F_OPAQUE']]) + +CLASS_NAME = {} +for _name, _value in list(globals().items()): + if _name.startswith('OP_') and isinstance(_value, int): + CLASS_NAME[_value] = _name[3:] diff --git a/venv/lib/python3.12/site-packages/cffi/commontypes.py b/venv/lib/python3.12/site-packages/cffi/commontypes.py new file mode 100644 index 00000000..d4dae351 --- /dev/null +++ b/venv/lib/python3.12/site-packages/cffi/commontypes.py @@ -0,0 +1,82 @@ +import sys +from . import model +from .error import FFIError + + +COMMON_TYPES = {} + +try: + # fetch "bool" and all simple Windows types + from _cffi_backend import _get_common_types + _get_common_types(COMMON_TYPES) +except ImportError: + pass + +COMMON_TYPES['FILE'] = model.unknown_type('FILE', '_IO_FILE') +COMMON_TYPES['bool'] = '_Bool' # in case we got ImportError above +COMMON_TYPES['float _Complex'] = '_cffi_float_complex_t' +COMMON_TYPES['double _Complex'] = '_cffi_double_complex_t' + +for _type in model.PrimitiveType.ALL_PRIMITIVE_TYPES: + if _type.endswith('_t'): + COMMON_TYPES[_type] = _type +del _type + +_CACHE = {} + +def resolve_common_type(parser, commontype): + try: + return _CACHE[commontype] + except KeyError: + cdecl = COMMON_TYPES.get(commontype, commontype) + if not isinstance(cdecl, str): + result, quals = cdecl, 0 # cdecl is already a BaseType + elif cdecl in model.PrimitiveType.ALL_PRIMITIVE_TYPES: + result, quals = model.PrimitiveType(cdecl), 0 + elif cdecl == 'set-unicode-needed': + raise FFIError("The Windows type %r is only available after " + "you call ffi.set_unicode()" % (commontype,)) + else: + if commontype == cdecl: + raise FFIError( + "Unsupported type: %r. Please look at " + "http://cffi.readthedocs.io/en/latest/cdef.html#ffi-cdef-limitations " + "and file an issue if you think this type should really " + "be supported." % (commontype,)) + result, quals = parser.parse_type_and_quals(cdecl) # recursive + + assert isinstance(result, model.BaseTypeByIdentity) + _CACHE[commontype] = result, quals + return result, quals + + +# ____________________________________________________________ +# extra types for Windows (most of them are in commontypes.c) + + +def win_common_types(): + return { + "UNICODE_STRING": model.StructType( + "_UNICODE_STRING", + ["Length", + "MaximumLength", + "Buffer"], + [model.PrimitiveType("unsigned short"), + model.PrimitiveType("unsigned short"), + model.PointerType(model.PrimitiveType("wchar_t"))], + [-1, -1, -1]), + "PUNICODE_STRING": "UNICODE_STRING *", + "PCUNICODE_STRING": "const UNICODE_STRING *", + + "TBYTE": "set-unicode-needed", + "TCHAR": "set-unicode-needed", + "LPCTSTR": "set-unicode-needed", + "PCTSTR": "set-unicode-needed", + "LPTSTR": "set-unicode-needed", + "PTSTR": "set-unicode-needed", + "PTBYTE": "set-unicode-needed", + "PTCHAR": "set-unicode-needed", + } + +if sys.platform == 'win32': + COMMON_TYPES.update(win_common_types()) diff --git a/venv/lib/python3.12/site-packages/cffi/cparser.py b/venv/lib/python3.12/site-packages/cffi/cparser.py new file mode 100644 index 00000000..eee83caf --- /dev/null +++ b/venv/lib/python3.12/site-packages/cffi/cparser.py @@ -0,0 +1,1015 @@ +from . import model +from .commontypes import COMMON_TYPES, resolve_common_type +from .error import FFIError, CDefError +try: + from . import _pycparser as pycparser +except ImportError: + import pycparser +import weakref, re, sys + +try: + if sys.version_info < (3,): + import thread as _thread + else: + import _thread + lock = _thread.allocate_lock() +except ImportError: + lock = None + +def _workaround_for_static_import_finders(): + # Issue #392: packaging tools like cx_Freeze can not find these + # because pycparser uses exec dynamic import. This is an obscure + # workaround. This function is never called. + import pycparser.yacctab + import pycparser.lextab + +CDEF_SOURCE_STRING = "" +_r_comment = re.compile(r"/\*.*?\*/|//([^\n\\]|\\.)*?$", + re.DOTALL | re.MULTILINE) +_r_define = re.compile(r"^\s*#\s*define\s+([A-Za-z_][A-Za-z_0-9]*)" + r"\b((?:[^\n\\]|\\.)*?)$", + re.DOTALL | re.MULTILINE) +_r_line_directive = re.compile(r"^[ \t]*#[ \t]*(?:line|\d+)\b.*$", re.MULTILINE) +_r_partial_enum = re.compile(r"=\s*\.\.\.\s*[,}]|\.\.\.\s*\}") +_r_enum_dotdotdot = re.compile(r"__dotdotdot\d+__$") +_r_partial_array = re.compile(r"\[\s*\.\.\.\s*\]") +_r_words = re.compile(r"\w+|\S") +_parser_cache = None +_r_int_literal = re.compile(r"-?0?x?[0-9a-f]+[lu]*$", re.IGNORECASE) +_r_stdcall1 = re.compile(r"\b(__stdcall|WINAPI)\b") +_r_stdcall2 = re.compile(r"[(]\s*(__stdcall|WINAPI)\b") +_r_cdecl = re.compile(r"\b__cdecl\b") +_r_extern_python = re.compile(r'\bextern\s*"' + r'(Python|Python\s*\+\s*C|C\s*\+\s*Python)"\s*.') +_r_star_const_space = re.compile( # matches "* const " + r"[*]\s*((const|volatile|restrict)\b\s*)+") +_r_int_dotdotdot = re.compile(r"(\b(int|long|short|signed|unsigned|char)\s*)+" + r"\.\.\.") +_r_float_dotdotdot = re.compile(r"\b(double|float)\s*\.\.\.") + +def _get_parser(): + global _parser_cache + if _parser_cache is None: + _parser_cache = pycparser.CParser() + return _parser_cache + +def _workaround_for_old_pycparser(csource): + # Workaround for a pycparser issue (fixed between pycparser 2.10 and + # 2.14): "char*const***" gives us a wrong syntax tree, the same as + # for "char***(*const)". This means we can't tell the difference + # afterwards. But "char(*const(***))" gives us the right syntax + # tree. The issue only occurs if there are several stars in + # sequence with no parenthesis inbetween, just possibly qualifiers. + # Attempt to fix it by adding some parentheses in the source: each + # time we see "* const" or "* const *", we add an opening + # parenthesis before each star---the hard part is figuring out where + # to close them. + parts = [] + while True: + match = _r_star_const_space.search(csource) + if not match: + break + #print repr(''.join(parts)+csource), '=>', + parts.append(csource[:match.start()]) + parts.append('('); closing = ')' + parts.append(match.group()) # e.g. "* const " + endpos = match.end() + if csource.startswith('*', endpos): + parts.append('('); closing += ')' + level = 0 + i = endpos + while i < len(csource): + c = csource[i] + if c == '(': + level += 1 + elif c == ')': + if level == 0: + break + level -= 1 + elif c in ',;=': + if level == 0: + break + i += 1 + csource = csource[endpos:i] + closing + csource[i:] + #print repr(''.join(parts)+csource) + parts.append(csource) + return ''.join(parts) + +def _preprocess_extern_python(csource): + # input: `extern "Python" int foo(int);` or + # `extern "Python" { int foo(int); }` + # output: + # void __cffi_extern_python_start; + # int foo(int); + # void __cffi_extern_python_stop; + # + # input: `extern "Python+C" int foo(int);` + # output: + # void __cffi_extern_python_plus_c_start; + # int foo(int); + # void __cffi_extern_python_stop; + parts = [] + while True: + match = _r_extern_python.search(csource) + if not match: + break + endpos = match.end() - 1 + #print + #print ''.join(parts)+csource + #print '=>' + parts.append(csource[:match.start()]) + if 'C' in match.group(1): + parts.append('void __cffi_extern_python_plus_c_start; ') + else: + parts.append('void __cffi_extern_python_start; ') + if csource[endpos] == '{': + # grouping variant + closing = csource.find('}', endpos) + if closing < 0: + raise CDefError("'extern \"Python\" {': no '}' found") + if csource.find('{', endpos + 1, closing) >= 0: + raise NotImplementedError("cannot use { } inside a block " + "'extern \"Python\" { ... }'") + parts.append(csource[endpos+1:closing]) + csource = csource[closing+1:] + else: + # non-grouping variant + semicolon = csource.find(';', endpos) + if semicolon < 0: + raise CDefError("'extern \"Python\": no ';' found") + parts.append(csource[endpos:semicolon+1]) + csource = csource[semicolon+1:] + parts.append(' void __cffi_extern_python_stop;') + #print ''.join(parts)+csource + #print + parts.append(csource) + return ''.join(parts) + +def _warn_for_string_literal(csource): + if '"' not in csource: + return + for line in csource.splitlines(): + if '"' in line and not line.lstrip().startswith('#'): + import warnings + warnings.warn("String literal found in cdef() or type source. " + "String literals are ignored here, but you should " + "remove them anyway because some character sequences " + "confuse pre-parsing.") + break + +def _warn_for_non_extern_non_static_global_variable(decl): + if not decl.storage: + import warnings + warnings.warn("Global variable '%s' in cdef(): for consistency " + "with C it should have a storage class specifier " + "(usually 'extern')" % (decl.name,)) + +def _remove_line_directives(csource): + # _r_line_directive matches whole lines, without the final \n, if they + # start with '#line' with some spacing allowed, or '#NUMBER'. This + # function stores them away and replaces them with exactly the string + # '#line@N', where N is the index in the list 'line_directives'. + line_directives = [] + def replace(m): + i = len(line_directives) + line_directives.append(m.group()) + return '#line@%d' % i + csource = _r_line_directive.sub(replace, csource) + return csource, line_directives + +def _put_back_line_directives(csource, line_directives): + def replace(m): + s = m.group() + if not s.startswith('#line@'): + raise AssertionError("unexpected #line directive " + "(should have been processed and removed") + return line_directives[int(s[6:])] + return _r_line_directive.sub(replace, csource) + +def _preprocess(csource): + # First, remove the lines of the form '#line N "filename"' because + # the "filename" part could confuse the rest + csource, line_directives = _remove_line_directives(csource) + # Remove comments. NOTE: this only work because the cdef() section + # should not contain any string literals (except in line directives)! + def replace_keeping_newlines(m): + return ' ' + m.group().count('\n') * '\n' + csource = _r_comment.sub(replace_keeping_newlines, csource) + # Remove the "#define FOO x" lines + macros = {} + for match in _r_define.finditer(csource): + macroname, macrovalue = match.groups() + macrovalue = macrovalue.replace('\\\n', '').strip() + macros[macroname] = macrovalue + csource = _r_define.sub('', csource) + # + if pycparser.__version__ < '2.14': + csource = _workaround_for_old_pycparser(csource) + # + # BIG HACK: replace WINAPI or __stdcall with "volatile const". + # It doesn't make sense for the return type of a function to be + # "volatile volatile const", so we abuse it to detect __stdcall... + # Hack number 2 is that "int(volatile *fptr)();" is not valid C + # syntax, so we place the "volatile" before the opening parenthesis. + csource = _r_stdcall2.sub(' volatile volatile const(', csource) + csource = _r_stdcall1.sub(' volatile volatile const ', csource) + csource = _r_cdecl.sub(' ', csource) + # + # Replace `extern "Python"` with start/end markers + csource = _preprocess_extern_python(csource) + # + # Now there should not be any string literal left; warn if we get one + _warn_for_string_literal(csource) + # + # Replace "[...]" with "[__dotdotdotarray__]" + csource = _r_partial_array.sub('[__dotdotdotarray__]', csource) + # + # Replace "...}" with "__dotdotdotNUM__}". This construction should + # occur only at the end of enums; at the end of structs we have "...;}" + # and at the end of vararg functions "...);". Also replace "=...[,}]" + # with ",__dotdotdotNUM__[,}]": this occurs in the enums too, when + # giving an unknown value. + matches = list(_r_partial_enum.finditer(csource)) + for number, match in enumerate(reversed(matches)): + p = match.start() + if csource[p] == '=': + p2 = csource.find('...', p, match.end()) + assert p2 > p + csource = '%s,__dotdotdot%d__ %s' % (csource[:p], number, + csource[p2+3:]) + else: + assert csource[p:p+3] == '...' + csource = '%s __dotdotdot%d__ %s' % (csource[:p], number, + csource[p+3:]) + # Replace "int ..." or "unsigned long int..." with "__dotdotdotint__" + csource = _r_int_dotdotdot.sub(' __dotdotdotint__ ', csource) + # Replace "float ..." or "double..." with "__dotdotdotfloat__" + csource = _r_float_dotdotdot.sub(' __dotdotdotfloat__ ', csource) + # Replace all remaining "..." with the same name, "__dotdotdot__", + # which is declared with a typedef for the purpose of C parsing. + csource = csource.replace('...', ' __dotdotdot__ ') + # Finally, put back the line directives + csource = _put_back_line_directives(csource, line_directives) + return csource, macros + +def _common_type_names(csource): + # Look in the source for what looks like usages of types from the + # list of common types. A "usage" is approximated here as the + # appearance of the word, minus a "definition" of the type, which + # is the last word in a "typedef" statement. Approximative only + # but should be fine for all the common types. + look_for_words = set(COMMON_TYPES) + look_for_words.add(';') + look_for_words.add(',') + look_for_words.add('(') + look_for_words.add(')') + look_for_words.add('typedef') + words_used = set() + is_typedef = False + paren = 0 + previous_word = '' + for word in _r_words.findall(csource): + if word in look_for_words: + if word == ';': + if is_typedef: + words_used.discard(previous_word) + look_for_words.discard(previous_word) + is_typedef = False + elif word == 'typedef': + is_typedef = True + paren = 0 + elif word == '(': + paren += 1 + elif word == ')': + paren -= 1 + elif word == ',': + if is_typedef and paren == 0: + words_used.discard(previous_word) + look_for_words.discard(previous_word) + else: # word in COMMON_TYPES + words_used.add(word) + previous_word = word + return words_used + + +class Parser(object): + + def __init__(self): + self._declarations = {} + self._included_declarations = set() + self._anonymous_counter = 0 + self._structnode2type = weakref.WeakKeyDictionary() + self._options = {} + self._int_constants = {} + self._recomplete = [] + self._uses_new_feature = None + + def _parse(self, csource): + csource, macros = _preprocess(csource) + # XXX: for more efficiency we would need to poke into the + # internals of CParser... the following registers the + # typedefs, because their presence or absence influences the + # parsing itself (but what they are typedef'ed to plays no role) + ctn = _common_type_names(csource) + typenames = [] + for name in sorted(self._declarations): + if name.startswith('typedef '): + name = name[8:] + typenames.append(name) + ctn.discard(name) + typenames += sorted(ctn) + # + csourcelines = [] + csourcelines.append('# 1 ""') + for typename in typenames: + csourcelines.append('typedef int %s;' % typename) + csourcelines.append('typedef int __dotdotdotint__, __dotdotdotfloat__,' + ' __dotdotdot__;') + # this forces pycparser to consider the following in the file + # called from line 1 + csourcelines.append('# 1 "%s"' % (CDEF_SOURCE_STRING,)) + csourcelines.append(csource) + csourcelines.append('') # see test_missing_newline_bug + fullcsource = '\n'.join(csourcelines) + if lock is not None: + lock.acquire() # pycparser is not thread-safe... + try: + ast = _get_parser().parse(fullcsource) + except pycparser.c_parser.ParseError as e: + self.convert_pycparser_error(e, csource) + finally: + if lock is not None: + lock.release() + # csource will be used to find buggy source text + return ast, macros, csource + + def _convert_pycparser_error(self, e, csource): + # xxx look for ":NUM:" at the start of str(e) + # and interpret that as a line number. This will not work if + # the user gives explicit ``# NUM "FILE"`` directives. + line = None + msg = str(e) + match = re.match(r"%s:(\d+):" % (CDEF_SOURCE_STRING,), msg) + if match: + linenum = int(match.group(1), 10) + csourcelines = csource.splitlines() + if 1 <= linenum <= len(csourcelines): + line = csourcelines[linenum-1] + return line + + def convert_pycparser_error(self, e, csource): + line = self._convert_pycparser_error(e, csource) + + msg = str(e) + if line: + msg = 'cannot parse "%s"\n%s' % (line.strip(), msg) + else: + msg = 'parse error\n%s' % (msg,) + raise CDefError(msg) + + def parse(self, csource, override=False, packed=False, pack=None, + dllexport=False): + if packed: + if packed != True: + raise ValueError("'packed' should be False or True; use " + "'pack' to give another value") + if pack: + raise ValueError("cannot give both 'pack' and 'packed'") + pack = 1 + elif pack: + if pack & (pack - 1): + raise ValueError("'pack' must be a power of two, not %r" % + (pack,)) + else: + pack = 0 + prev_options = self._options + try: + self._options = {'override': override, + 'packed': pack, + 'dllexport': dllexport} + self._internal_parse(csource) + finally: + self._options = prev_options + + def _internal_parse(self, csource): + ast, macros, csource = self._parse(csource) + # add the macros + self._process_macros(macros) + # find the first "__dotdotdot__" and use that as a separator + # between the repeated typedefs and the real csource + iterator = iter(ast.ext) + for decl in iterator: + if decl.name == '__dotdotdot__': + break + else: + assert 0 + current_decl = None + # + try: + self._inside_extern_python = '__cffi_extern_python_stop' + for decl in iterator: + current_decl = decl + if isinstance(decl, pycparser.c_ast.Decl): + self._parse_decl(decl) + elif isinstance(decl, pycparser.c_ast.Typedef): + if not decl.name: + raise CDefError("typedef does not declare any name", + decl) + quals = 0 + if (isinstance(decl.type.type, pycparser.c_ast.IdentifierType) and + decl.type.type.names[-1].startswith('__dotdotdot')): + realtype = self._get_unknown_type(decl) + elif (isinstance(decl.type, pycparser.c_ast.PtrDecl) and + isinstance(decl.type.type, pycparser.c_ast.TypeDecl) and + isinstance(decl.type.type.type, + pycparser.c_ast.IdentifierType) and + decl.type.type.type.names[-1].startswith('__dotdotdot')): + realtype = self._get_unknown_ptr_type(decl) + else: + realtype, quals = self._get_type_and_quals( + decl.type, name=decl.name, partial_length_ok=True, + typedef_example="*(%s *)0" % (decl.name,)) + self._declare('typedef ' + decl.name, realtype, quals=quals) + elif decl.__class__.__name__ == 'Pragma': + # skip pragma, only in pycparser 2.15 + import warnings + warnings.warn( + "#pragma in cdef() are entirely ignored. " + "They should be removed for now, otherwise your " + "code might behave differently in a future version " + "of CFFI if #pragma support gets added. Note that " + "'#pragma pack' needs to be replaced with the " + "'packed' keyword argument to cdef().") + else: + raise CDefError("unexpected <%s>: this construct is valid " + "C but not valid in cdef()" % + decl.__class__.__name__, decl) + except CDefError as e: + if len(e.args) == 1: + e.args = e.args + (current_decl,) + raise + except FFIError as e: + msg = self._convert_pycparser_error(e, csource) + if msg: + e.args = (e.args[0] + "\n *** Err: %s" % msg,) + raise + + def _add_constants(self, key, val): + if key in self._int_constants: + if self._int_constants[key] == val: + return # ignore identical double declarations + raise FFIError( + "multiple declarations of constant: %s" % (key,)) + self._int_constants[key] = val + + def _add_integer_constant(self, name, int_str): + int_str = int_str.lower().rstrip("ul") + neg = int_str.startswith('-') + if neg: + int_str = int_str[1:] + # "010" is not valid oct in py3 + if (int_str.startswith("0") and int_str != '0' + and not int_str.startswith("0x")): + int_str = "0o" + int_str[1:] + pyvalue = int(int_str, 0) + if neg: + pyvalue = -pyvalue + self._add_constants(name, pyvalue) + self._declare('macro ' + name, pyvalue) + + def _process_macros(self, macros): + for key, value in macros.items(): + value = value.strip() + if _r_int_literal.match(value): + self._add_integer_constant(key, value) + elif value == '...': + self._declare('macro ' + key, value) + else: + raise CDefError( + 'only supports one of the following syntax:\n' + ' #define %s ... (literally dot-dot-dot)\n' + ' #define %s NUMBER (with NUMBER an integer' + ' constant, decimal/hex/octal)\n' + 'got:\n' + ' #define %s %s' + % (key, key, key, value)) + + def _declare_function(self, tp, quals, decl): + tp = self._get_type_pointer(tp, quals) + if self._options.get('dllexport'): + tag = 'dllexport_python ' + elif self._inside_extern_python == '__cffi_extern_python_start': + tag = 'extern_python ' + elif self._inside_extern_python == '__cffi_extern_python_plus_c_start': + tag = 'extern_python_plus_c ' + else: + tag = 'function ' + self._declare(tag + decl.name, tp) + + def _parse_decl(self, decl): + node = decl.type + if isinstance(node, pycparser.c_ast.FuncDecl): + tp, quals = self._get_type_and_quals(node, name=decl.name) + assert isinstance(tp, model.RawFunctionType) + self._declare_function(tp, quals, decl) + else: + if isinstance(node, pycparser.c_ast.Struct): + self._get_struct_union_enum_type('struct', node) + elif isinstance(node, pycparser.c_ast.Union): + self._get_struct_union_enum_type('union', node) + elif isinstance(node, pycparser.c_ast.Enum): + self._get_struct_union_enum_type('enum', node) + elif not decl.name: + raise CDefError("construct does not declare any variable", + decl) + # + if decl.name: + tp, quals = self._get_type_and_quals(node, + partial_length_ok=True) + if tp.is_raw_function: + self._declare_function(tp, quals, decl) + elif (tp.is_integer_type() and + hasattr(decl, 'init') and + hasattr(decl.init, 'value') and + _r_int_literal.match(decl.init.value)): + self._add_integer_constant(decl.name, decl.init.value) + elif (tp.is_integer_type() and + isinstance(decl.init, pycparser.c_ast.UnaryOp) and + decl.init.op == '-' and + hasattr(decl.init.expr, 'value') and + _r_int_literal.match(decl.init.expr.value)): + self._add_integer_constant(decl.name, + '-' + decl.init.expr.value) + elif (tp is model.void_type and + decl.name.startswith('__cffi_extern_python_')): + # hack: `extern "Python"` in the C source is replaced + # with "void __cffi_extern_python_start;" and + # "void __cffi_extern_python_stop;" + self._inside_extern_python = decl.name + else: + if self._inside_extern_python !='__cffi_extern_python_stop': + raise CDefError( + "cannot declare constants or " + "variables with 'extern \"Python\"'") + if (quals & model.Q_CONST) and not tp.is_array_type: + self._declare('constant ' + decl.name, tp, quals=quals) + else: + _warn_for_non_extern_non_static_global_variable(decl) + self._declare('variable ' + decl.name, tp, quals=quals) + + def parse_type(self, cdecl): + return self.parse_type_and_quals(cdecl)[0] + + def parse_type_and_quals(self, cdecl): + ast, macros = self._parse('void __dummy(\n%s\n);' % cdecl)[:2] + assert not macros + exprnode = ast.ext[-1].type.args.params[0] + if isinstance(exprnode, pycparser.c_ast.ID): + raise CDefError("unknown identifier '%s'" % (exprnode.name,)) + return self._get_type_and_quals(exprnode.type) + + def _declare(self, name, obj, included=False, quals=0): + if name in self._declarations: + prevobj, prevquals = self._declarations[name] + if prevobj is obj and prevquals == quals: + return + if not self._options.get('override'): + raise FFIError( + "multiple declarations of %s (for interactive usage, " + "try cdef(xx, override=True))" % (name,)) + assert '__dotdotdot__' not in name.split() + self._declarations[name] = (obj, quals) + if included: + self._included_declarations.add(obj) + + def _extract_quals(self, type): + quals = 0 + if isinstance(type, (pycparser.c_ast.TypeDecl, + pycparser.c_ast.PtrDecl)): + if 'const' in type.quals: + quals |= model.Q_CONST + if 'volatile' in type.quals: + quals |= model.Q_VOLATILE + if 'restrict' in type.quals: + quals |= model.Q_RESTRICT + return quals + + def _get_type_pointer(self, type, quals, declname=None): + if isinstance(type, model.RawFunctionType): + return type.as_function_pointer() + if (isinstance(type, model.StructOrUnionOrEnum) and + type.name.startswith('$') and type.name[1:].isdigit() and + type.forcename is None and declname is not None): + return model.NamedPointerType(type, declname, quals) + return model.PointerType(type, quals) + + def _get_type_and_quals(self, typenode, name=None, partial_length_ok=False, + typedef_example=None): + # first, dereference typedefs, if we have it already parsed, we're good + if (isinstance(typenode, pycparser.c_ast.TypeDecl) and + isinstance(typenode.type, pycparser.c_ast.IdentifierType) and + len(typenode.type.names) == 1 and + ('typedef ' + typenode.type.names[0]) in self._declarations): + tp, quals = self._declarations['typedef ' + typenode.type.names[0]] + quals |= self._extract_quals(typenode) + return tp, quals + # + if isinstance(typenode, pycparser.c_ast.ArrayDecl): + # array type + if typenode.dim is None: + length = None + else: + length = self._parse_constant( + typenode.dim, partial_length_ok=partial_length_ok) + # a hack: in 'typedef int foo_t[...][...];', don't use '...' as + # the length but use directly the C expression that would be + # generated by recompiler.py. This lets the typedef be used in + # many more places within recompiler.py + if typedef_example is not None: + if length == '...': + length = '_cffi_array_len(%s)' % (typedef_example,) + typedef_example = "*" + typedef_example + # + tp, quals = self._get_type_and_quals(typenode.type, + partial_length_ok=partial_length_ok, + typedef_example=typedef_example) + return model.ArrayType(tp, length), quals + # + if isinstance(typenode, pycparser.c_ast.PtrDecl): + # pointer type + itemtype, itemquals = self._get_type_and_quals(typenode.type) + tp = self._get_type_pointer(itemtype, itemquals, declname=name) + quals = self._extract_quals(typenode) + return tp, quals + # + if isinstance(typenode, pycparser.c_ast.TypeDecl): + quals = self._extract_quals(typenode) + type = typenode.type + if isinstance(type, pycparser.c_ast.IdentifierType): + # assume a primitive type. get it from .names, but reduce + # synonyms to a single chosen combination + names = list(type.names) + if names != ['signed', 'char']: # keep this unmodified + prefixes = {} + while names: + name = names[0] + if name in ('short', 'long', 'signed', 'unsigned'): + prefixes[name] = prefixes.get(name, 0) + 1 + del names[0] + else: + break + # ignore the 'signed' prefix below, and reorder the others + newnames = [] + for prefix in ('unsigned', 'short', 'long'): + for i in range(prefixes.get(prefix, 0)): + newnames.append(prefix) + if not names: + names = ['int'] # implicitly + if names == ['int']: # but kill it if 'short' or 'long' + if 'short' in prefixes or 'long' in prefixes: + names = [] + names = newnames + names + ident = ' '.join(names) + if ident == 'void': + return model.void_type, quals + if ident == '__dotdotdot__': + raise FFIError(':%d: bad usage of "..."' % + typenode.coord.line) + tp0, quals0 = resolve_common_type(self, ident) + return tp0, (quals | quals0) + # + if isinstance(type, pycparser.c_ast.Struct): + # 'struct foobar' + tp = self._get_struct_union_enum_type('struct', type, name) + return tp, quals + # + if isinstance(type, pycparser.c_ast.Union): + # 'union foobar' + tp = self._get_struct_union_enum_type('union', type, name) + return tp, quals + # + if isinstance(type, pycparser.c_ast.Enum): + # 'enum foobar' + tp = self._get_struct_union_enum_type('enum', type, name) + return tp, quals + # + if isinstance(typenode, pycparser.c_ast.FuncDecl): + # a function type + return self._parse_function_type(typenode, name), 0 + # + # nested anonymous structs or unions end up here + if isinstance(typenode, pycparser.c_ast.Struct): + return self._get_struct_union_enum_type('struct', typenode, name, + nested=True), 0 + if isinstance(typenode, pycparser.c_ast.Union): + return self._get_struct_union_enum_type('union', typenode, name, + nested=True), 0 + # + raise FFIError(":%d: bad or unsupported type declaration" % + typenode.coord.line) + + def _parse_function_type(self, typenode, funcname=None): + params = list(getattr(typenode.args, 'params', [])) + for i, arg in enumerate(params): + if not hasattr(arg, 'type'): + raise CDefError("%s arg %d: unknown type '%s'" + " (if you meant to use the old C syntax of giving" + " untyped arguments, it is not supported)" + % (funcname or 'in expression', i + 1, + getattr(arg, 'name', '?'))) + ellipsis = ( + len(params) > 0 and + isinstance(params[-1].type, pycparser.c_ast.TypeDecl) and + isinstance(params[-1].type.type, + pycparser.c_ast.IdentifierType) and + params[-1].type.type.names == ['__dotdotdot__']) + if ellipsis: + params.pop() + if not params: + raise CDefError( + "%s: a function with only '(...)' as argument" + " is not correct C" % (funcname or 'in expression')) + args = [self._as_func_arg(*self._get_type_and_quals(argdeclnode.type)) + for argdeclnode in params] + if not ellipsis and args == [model.void_type]: + args = [] + result, quals = self._get_type_and_quals(typenode.type) + # the 'quals' on the result type are ignored. HACK: we absure them + # to detect __stdcall functions: we textually replace "__stdcall" + # with "volatile volatile const" above. + abi = None + if hasattr(typenode.type, 'quals'): # else, probable syntax error anyway + if typenode.type.quals[-3:] == ['volatile', 'volatile', 'const']: + abi = '__stdcall' + return model.RawFunctionType(tuple(args), result, ellipsis, abi) + + def _as_func_arg(self, type, quals): + if isinstance(type, model.ArrayType): + return model.PointerType(type.item, quals) + elif isinstance(type, model.RawFunctionType): + return type.as_function_pointer() + else: + return type + + def _get_struct_union_enum_type(self, kind, type, name=None, nested=False): + # First, a level of caching on the exact 'type' node of the AST. + # This is obscure, but needed because pycparser "unrolls" declarations + # such as "typedef struct { } foo_t, *foo_p" and we end up with + # an AST that is not a tree, but a DAG, with the "type" node of the + # two branches foo_t and foo_p of the trees being the same node. + # It's a bit silly but detecting "DAG-ness" in the AST tree seems + # to be the only way to distinguish this case from two independent + # structs. See test_struct_with_two_usages. + try: + return self._structnode2type[type] + except KeyError: + pass + # + # Note that this must handle parsing "struct foo" any number of + # times and always return the same StructType object. Additionally, + # one of these times (not necessarily the first), the fields of + # the struct can be specified with "struct foo { ...fields... }". + # If no name is given, then we have to create a new anonymous struct + # with no caching; in this case, the fields are either specified + # right now or never. + # + force_name = name + name = type.name + # + # get the type or create it if needed + if name is None: + # 'force_name' is used to guess a more readable name for + # anonymous structs, for the common case "typedef struct { } foo". + if force_name is not None: + explicit_name = '$%s' % force_name + else: + self._anonymous_counter += 1 + explicit_name = '$%d' % self._anonymous_counter + tp = None + else: + explicit_name = name + key = '%s %s' % (kind, name) + tp, _ = self._declarations.get(key, (None, None)) + # + if tp is None: + if kind == 'struct': + tp = model.StructType(explicit_name, None, None, None) + elif kind == 'union': + tp = model.UnionType(explicit_name, None, None, None) + elif kind == 'enum': + if explicit_name == '__dotdotdot__': + raise CDefError("Enums cannot be declared with ...") + tp = self._build_enum_type(explicit_name, type.values) + else: + raise AssertionError("kind = %r" % (kind,)) + if name is not None: + self._declare(key, tp) + else: + if kind == 'enum' and type.values is not None: + raise NotImplementedError( + "enum %s: the '{}' declaration should appear on the first " + "time the enum is mentioned, not later" % explicit_name) + if not tp.forcename: + tp.force_the_name(force_name) + if tp.forcename and '$' in tp.name: + self._declare('anonymous %s' % tp.forcename, tp) + # + self._structnode2type[type] = tp + # + # enums: done here + if kind == 'enum': + return tp + # + # is there a 'type.decls'? If yes, then this is the place in the + # C sources that declare the fields. If no, then just return the + # existing type, possibly still incomplete. + if type.decls is None: + return tp + # + if tp.fldnames is not None: + raise CDefError("duplicate declaration of struct %s" % name) + fldnames = [] + fldtypes = [] + fldbitsize = [] + fldquals = [] + for decl in type.decls: + if (isinstance(decl.type, pycparser.c_ast.IdentifierType) and + ''.join(decl.type.names) == '__dotdotdot__'): + # XXX pycparser is inconsistent: 'names' should be a list + # of strings, but is sometimes just one string. Use + # str.join() as a way to cope with both. + self._make_partial(tp, nested) + continue + if decl.bitsize is None: + bitsize = -1 + else: + bitsize = self._parse_constant(decl.bitsize) + self._partial_length = False + type, fqual = self._get_type_and_quals(decl.type, + partial_length_ok=True) + if self._partial_length: + self._make_partial(tp, nested) + if isinstance(type, model.StructType) and type.partial: + self._make_partial(tp, nested) + fldnames.append(decl.name or '') + fldtypes.append(type) + fldbitsize.append(bitsize) + fldquals.append(fqual) + tp.fldnames = tuple(fldnames) + tp.fldtypes = tuple(fldtypes) + tp.fldbitsize = tuple(fldbitsize) + tp.fldquals = tuple(fldquals) + if fldbitsize != [-1] * len(fldbitsize): + if isinstance(tp, model.StructType) and tp.partial: + raise NotImplementedError("%s: using both bitfields and '...;'" + % (tp,)) + tp.packed = self._options.get('packed') + if tp.completed: # must be re-completed: it is not opaque any more + tp.completed = 0 + self._recomplete.append(tp) + return tp + + def _make_partial(self, tp, nested): + if not isinstance(tp, model.StructOrUnion): + raise CDefError("%s cannot be partial" % (tp,)) + if not tp.has_c_name() and not nested: + raise NotImplementedError("%s is partial but has no C name" %(tp,)) + tp.partial = True + + def _parse_constant(self, exprnode, partial_length_ok=False): + # for now, limited to expressions that are an immediate number + # or positive/negative number + if isinstance(exprnode, pycparser.c_ast.Constant): + s = exprnode.value + if '0' <= s[0] <= '9': + s = s.rstrip('uUlL') + try: + if s.startswith('0'): + return int(s, 8) + else: + return int(s, 10) + except ValueError: + if len(s) > 1: + if s.lower()[0:2] == '0x': + return int(s, 16) + elif s.lower()[0:2] == '0b': + return int(s, 2) + raise CDefError("invalid constant %r" % (s,)) + elif s[0] == "'" and s[-1] == "'" and ( + len(s) == 3 or (len(s) == 4 and s[1] == "\\")): + return ord(s[-2]) + else: + raise CDefError("invalid constant %r" % (s,)) + # + if (isinstance(exprnode, pycparser.c_ast.UnaryOp) and + exprnode.op == '+'): + return self._parse_constant(exprnode.expr) + # + if (isinstance(exprnode, pycparser.c_ast.UnaryOp) and + exprnode.op == '-'): + return -self._parse_constant(exprnode.expr) + # load previously defined int constant + if (isinstance(exprnode, pycparser.c_ast.ID) and + exprnode.name in self._int_constants): + return self._int_constants[exprnode.name] + # + if (isinstance(exprnode, pycparser.c_ast.ID) and + exprnode.name == '__dotdotdotarray__'): + if partial_length_ok: + self._partial_length = True + return '...' + raise FFIError(":%d: unsupported '[...]' here, cannot derive " + "the actual array length in this context" + % exprnode.coord.line) + # + if isinstance(exprnode, pycparser.c_ast.BinaryOp): + left = self._parse_constant(exprnode.left) + right = self._parse_constant(exprnode.right) + if exprnode.op == '+': + return left + right + elif exprnode.op == '-': + return left - right + elif exprnode.op == '*': + return left * right + elif exprnode.op == '/': + return self._c_div(left, right) + elif exprnode.op == '%': + return left - self._c_div(left, right) * right + elif exprnode.op == '<<': + return left << right + elif exprnode.op == '>>': + return left >> right + elif exprnode.op == '&': + return left & right + elif exprnode.op == '|': + return left | right + elif exprnode.op == '^': + return left ^ right + # + raise FFIError(":%d: unsupported expression: expected a " + "simple numeric constant" % exprnode.coord.line) + + def _c_div(self, a, b): + result = a // b + if ((a < 0) ^ (b < 0)) and (a % b) != 0: + result += 1 + return result + + def _build_enum_type(self, explicit_name, decls): + if decls is not None: + partial = False + enumerators = [] + enumvalues = [] + nextenumvalue = 0 + for enum in decls.enumerators: + if _r_enum_dotdotdot.match(enum.name): + partial = True + continue + if enum.value is not None: + nextenumvalue = self._parse_constant(enum.value) + enumerators.append(enum.name) + enumvalues.append(nextenumvalue) + self._add_constants(enum.name, nextenumvalue) + nextenumvalue += 1 + enumerators = tuple(enumerators) + enumvalues = tuple(enumvalues) + tp = model.EnumType(explicit_name, enumerators, enumvalues) + tp.partial = partial + else: # opaque enum + tp = model.EnumType(explicit_name, (), ()) + return tp + + def include(self, other): + for name, (tp, quals) in other._declarations.items(): + if name.startswith('anonymous $enum_$'): + continue # fix for test_anonymous_enum_include + kind = name.split(' ', 1)[0] + if kind in ('struct', 'union', 'enum', 'anonymous', 'typedef'): + self._declare(name, tp, included=True, quals=quals) + for k, v in other._int_constants.items(): + self._add_constants(k, v) + + def _get_unknown_type(self, decl): + typenames = decl.type.type.names + if typenames == ['__dotdotdot__']: + return model.unknown_type(decl.name) + + if typenames == ['__dotdotdotint__']: + if self._uses_new_feature is None: + self._uses_new_feature = "'typedef int... %s'" % decl.name + return model.UnknownIntegerType(decl.name) + + if typenames == ['__dotdotdotfloat__']: + # note: not for 'long double' so far + if self._uses_new_feature is None: + self._uses_new_feature = "'typedef float... %s'" % decl.name + return model.UnknownFloatType(decl.name) + + raise FFIError(':%d: unsupported usage of "..." in typedef' + % decl.coord.line) + + def _get_unknown_ptr_type(self, decl): + if decl.type.type.type.names == ['__dotdotdot__']: + return model.unknown_ptr_type(decl.name) + raise FFIError(':%d: unsupported usage of "..." in typedef' + % decl.coord.line) diff --git a/venv/lib/python3.12/site-packages/cffi/error.py b/venv/lib/python3.12/site-packages/cffi/error.py new file mode 100644 index 00000000..0a27247c --- /dev/null +++ b/venv/lib/python3.12/site-packages/cffi/error.py @@ -0,0 +1,31 @@ + +class FFIError(Exception): + __module__ = 'cffi' + +class CDefError(Exception): + __module__ = 'cffi' + def __str__(self): + try: + current_decl = self.args[1] + filename = current_decl.coord.file + linenum = current_decl.coord.line + prefix = '%s:%d: ' % (filename, linenum) + except (AttributeError, TypeError, IndexError): + prefix = '' + return '%s%s' % (prefix, self.args[0]) + +class VerificationError(Exception): + """ An error raised when verification fails + """ + __module__ = 'cffi' + +class VerificationMissing(Exception): + """ An error raised when incomplete structures are passed into + cdef, but no verification has been done + """ + __module__ = 'cffi' + +class PkgConfigError(Exception): + """ An error raised for missing modules in pkg-config + """ + __module__ = 'cffi' diff --git a/venv/lib/python3.12/site-packages/cffi/ffiplatform.py b/venv/lib/python3.12/site-packages/cffi/ffiplatform.py new file mode 100644 index 00000000..adca28f1 --- /dev/null +++ b/venv/lib/python3.12/site-packages/cffi/ffiplatform.py @@ -0,0 +1,113 @@ +import sys, os +from .error import VerificationError + + +LIST_OF_FILE_NAMES = ['sources', 'include_dirs', 'library_dirs', + 'extra_objects', 'depends'] + +def get_extension(srcfilename, modname, sources=(), **kwds): + from cffi._shimmed_dist_utils import Extension + allsources = [srcfilename] + for src in sources: + allsources.append(os.path.normpath(src)) + return Extension(name=modname, sources=allsources, **kwds) + +def compile(tmpdir, ext, compiler_verbose=0, debug=None): + """Compile a C extension module using distutils.""" + + saved_environ = os.environ.copy() + try: + outputfilename = _build(tmpdir, ext, compiler_verbose, debug) + outputfilename = os.path.abspath(outputfilename) + finally: + # workaround for a distutils bugs where some env vars can + # become longer and longer every time it is used + for key, value in saved_environ.items(): + if os.environ.get(key) != value: + os.environ[key] = value + return outputfilename + +def _build(tmpdir, ext, compiler_verbose=0, debug=None): + # XXX compact but horrible :-( + from cffi._shimmed_dist_utils import Distribution, CompileError, LinkError, set_threshold, set_verbosity + + dist = Distribution({'ext_modules': [ext]}) + dist.parse_config_files() + options = dist.get_option_dict('build_ext') + if debug is None: + debug = sys.flags.debug + options['debug'] = ('ffiplatform', debug) + options['force'] = ('ffiplatform', True) + options['build_lib'] = ('ffiplatform', tmpdir) + options['build_temp'] = ('ffiplatform', tmpdir) + # + try: + old_level = set_threshold(0) or 0 + try: + set_verbosity(compiler_verbose) + dist.run_command('build_ext') + cmd_obj = dist.get_command_obj('build_ext') + [soname] = cmd_obj.get_outputs() + finally: + set_threshold(old_level) + except (CompileError, LinkError) as e: + raise VerificationError('%s: %s' % (e.__class__.__name__, e)) + # + return soname + +try: + from os.path import samefile +except ImportError: + def samefile(f1, f2): + return os.path.abspath(f1) == os.path.abspath(f2) + +def maybe_relative_path(path): + if not os.path.isabs(path): + return path # already relative + dir = path + names = [] + while True: + prevdir = dir + dir, name = os.path.split(prevdir) + if dir == prevdir or not dir: + return path # failed to make it relative + names.append(name) + try: + if samefile(dir, os.curdir): + names.reverse() + return os.path.join(*names) + except OSError: + pass + +# ____________________________________________________________ + +try: + int_or_long = (int, long) + import cStringIO +except NameError: + int_or_long = int # Python 3 + import io as cStringIO + +def _flatten(x, f): + if isinstance(x, str): + f.write('%ds%s' % (len(x), x)) + elif isinstance(x, dict): + keys = sorted(x.keys()) + f.write('%dd' % len(keys)) + for key in keys: + _flatten(key, f) + _flatten(x[key], f) + elif isinstance(x, (list, tuple)): + f.write('%dl' % len(x)) + for value in x: + _flatten(value, f) + elif isinstance(x, int_or_long): + f.write('%di' % (x,)) + else: + raise TypeError( + "the keywords to verify() contains unsupported object %r" % (x,)) + +def flatten(x): + f = cStringIO.StringIO() + _flatten(x, f) + return f.getvalue() diff --git a/venv/lib/python3.12/site-packages/cffi/lock.py b/venv/lib/python3.12/site-packages/cffi/lock.py new file mode 100644 index 00000000..db91b715 --- /dev/null +++ b/venv/lib/python3.12/site-packages/cffi/lock.py @@ -0,0 +1,30 @@ +import sys + +if sys.version_info < (3,): + try: + from thread import allocate_lock + except ImportError: + from dummy_thread import allocate_lock +else: + try: + from _thread import allocate_lock + except ImportError: + from _dummy_thread import allocate_lock + + +##import sys +##l1 = allocate_lock + +##class allocate_lock(object): +## def __init__(self): +## self._real = l1() +## def __enter__(self): +## for i in range(4, 0, -1): +## print sys._getframe(i).f_code +## print +## return self._real.__enter__() +## def __exit__(self, *args): +## return self._real.__exit__(*args) +## def acquire(self, f): +## assert f is False +## return self._real.acquire(f) diff --git a/venv/lib/python3.12/site-packages/cffi/model.py b/venv/lib/python3.12/site-packages/cffi/model.py new file mode 100644 index 00000000..e5f4cae3 --- /dev/null +++ b/venv/lib/python3.12/site-packages/cffi/model.py @@ -0,0 +1,618 @@ +import types +import weakref + +from .lock import allocate_lock +from .error import CDefError, VerificationError, VerificationMissing + +# type qualifiers +Q_CONST = 0x01 +Q_RESTRICT = 0x02 +Q_VOLATILE = 0x04 + +def qualify(quals, replace_with): + if quals & Q_CONST: + replace_with = ' const ' + replace_with.lstrip() + if quals & Q_VOLATILE: + replace_with = ' volatile ' + replace_with.lstrip() + if quals & Q_RESTRICT: + # It seems that __restrict is supported by gcc and msvc. + # If you hit some different compiler, add a #define in + # _cffi_include.h for it (and in its copies, documented there) + replace_with = ' __restrict ' + replace_with.lstrip() + return replace_with + + +class BaseTypeByIdentity(object): + is_array_type = False + is_raw_function = False + + def get_c_name(self, replace_with='', context='a C file', quals=0): + result = self.c_name_with_marker + assert result.count('&') == 1 + # some logic duplication with ffi.getctype()... :-( + replace_with = replace_with.strip() + if replace_with: + if replace_with.startswith('*') and '&[' in result: + replace_with = '(%s)' % replace_with + elif not replace_with[0] in '[(': + replace_with = ' ' + replace_with + replace_with = qualify(quals, replace_with) + result = result.replace('&', replace_with) + if '$' in result: + raise VerificationError( + "cannot generate '%s' in %s: unknown type name" + % (self._get_c_name(), context)) + return result + + def _get_c_name(self): + return self.c_name_with_marker.replace('&', '') + + def has_c_name(self): + return '$' not in self._get_c_name() + + def is_integer_type(self): + return False + + def get_cached_btype(self, ffi, finishlist, can_delay=False): + try: + BType = ffi._cached_btypes[self] + except KeyError: + BType = self.build_backend_type(ffi, finishlist) + BType2 = ffi._cached_btypes.setdefault(self, BType) + assert BType2 is BType + return BType + + def __repr__(self): + return '<%s>' % (self._get_c_name(),) + + def _get_items(self): + return [(name, getattr(self, name)) for name in self._attrs_] + + +class BaseType(BaseTypeByIdentity): + + def __eq__(self, other): + return (self.__class__ == other.__class__ and + self._get_items() == other._get_items()) + + def __ne__(self, other): + return not self == other + + def __hash__(self): + return hash((self.__class__, tuple(self._get_items()))) + + +class VoidType(BaseType): + _attrs_ = () + + def __init__(self): + self.c_name_with_marker = 'void&' + + def build_backend_type(self, ffi, finishlist): + return global_cache(self, ffi, 'new_void_type') + +void_type = VoidType() + + +class BasePrimitiveType(BaseType): + def is_complex_type(self): + return False + + +class PrimitiveType(BasePrimitiveType): + _attrs_ = ('name',) + + ALL_PRIMITIVE_TYPES = { + 'char': 'c', + 'short': 'i', + 'int': 'i', + 'long': 'i', + 'long long': 'i', + 'signed char': 'i', + 'unsigned char': 'i', + 'unsigned short': 'i', + 'unsigned int': 'i', + 'unsigned long': 'i', + 'unsigned long long': 'i', + 'float': 'f', + 'double': 'f', + 'long double': 'f', + '_cffi_float_complex_t': 'j', + '_cffi_double_complex_t': 'j', + '_Bool': 'i', + # the following types are not primitive in the C sense + 'wchar_t': 'c', + 'char16_t': 'c', + 'char32_t': 'c', + 'int8_t': 'i', + 'uint8_t': 'i', + 'int16_t': 'i', + 'uint16_t': 'i', + 'int32_t': 'i', + 'uint32_t': 'i', + 'int64_t': 'i', + 'uint64_t': 'i', + 'int_least8_t': 'i', + 'uint_least8_t': 'i', + 'int_least16_t': 'i', + 'uint_least16_t': 'i', + 'int_least32_t': 'i', + 'uint_least32_t': 'i', + 'int_least64_t': 'i', + 'uint_least64_t': 'i', + 'int_fast8_t': 'i', + 'uint_fast8_t': 'i', + 'int_fast16_t': 'i', + 'uint_fast16_t': 'i', + 'int_fast32_t': 'i', + 'uint_fast32_t': 'i', + 'int_fast64_t': 'i', + 'uint_fast64_t': 'i', + 'intptr_t': 'i', + 'uintptr_t': 'i', + 'intmax_t': 'i', + 'uintmax_t': 'i', + 'ptrdiff_t': 'i', + 'size_t': 'i', + 'ssize_t': 'i', + } + + def __init__(self, name): + assert name in self.ALL_PRIMITIVE_TYPES + self.name = name + self.c_name_with_marker = name + '&' + + def is_char_type(self): + return self.ALL_PRIMITIVE_TYPES[self.name] == 'c' + def is_integer_type(self): + return self.ALL_PRIMITIVE_TYPES[self.name] == 'i' + def is_float_type(self): + return self.ALL_PRIMITIVE_TYPES[self.name] == 'f' + def is_complex_type(self): + return self.ALL_PRIMITIVE_TYPES[self.name] == 'j' + + def build_backend_type(self, ffi, finishlist): + return global_cache(self, ffi, 'new_primitive_type', self.name) + + +class UnknownIntegerType(BasePrimitiveType): + _attrs_ = ('name',) + + def __init__(self, name): + self.name = name + self.c_name_with_marker = name + '&' + + def is_integer_type(self): + return True + + def build_backend_type(self, ffi, finishlist): + raise NotImplementedError("integer type '%s' can only be used after " + "compilation" % self.name) + +class UnknownFloatType(BasePrimitiveType): + _attrs_ = ('name', ) + + def __init__(self, name): + self.name = name + self.c_name_with_marker = name + '&' + + def build_backend_type(self, ffi, finishlist): + raise NotImplementedError("float type '%s' can only be used after " + "compilation" % self.name) + + +class BaseFunctionType(BaseType): + _attrs_ = ('args', 'result', 'ellipsis', 'abi') + + def __init__(self, args, result, ellipsis, abi=None): + self.args = args + self.result = result + self.ellipsis = ellipsis + self.abi = abi + # + reprargs = [arg._get_c_name() for arg in self.args] + if self.ellipsis: + reprargs.append('...') + reprargs = reprargs or ['void'] + replace_with = self._base_pattern % (', '.join(reprargs),) + if abi is not None: + replace_with = replace_with[:1] + abi + ' ' + replace_with[1:] + self.c_name_with_marker = ( + self.result.c_name_with_marker.replace('&', replace_with)) + + +class RawFunctionType(BaseFunctionType): + # Corresponds to a C type like 'int(int)', which is the C type of + # a function, but not a pointer-to-function. The backend has no + # notion of such a type; it's used temporarily by parsing. + _base_pattern = '(&)(%s)' + is_raw_function = True + + def build_backend_type(self, ffi, finishlist): + raise CDefError("cannot render the type %r: it is a function " + "type, not a pointer-to-function type" % (self,)) + + def as_function_pointer(self): + return FunctionPtrType(self.args, self.result, self.ellipsis, self.abi) + + +class FunctionPtrType(BaseFunctionType): + _base_pattern = '(*&)(%s)' + + def build_backend_type(self, ffi, finishlist): + result = self.result.get_cached_btype(ffi, finishlist) + args = [] + for tp in self.args: + args.append(tp.get_cached_btype(ffi, finishlist)) + abi_args = () + if self.abi == "__stdcall": + if not self.ellipsis: # __stdcall ignored for variadic funcs + try: + abi_args = (ffi._backend.FFI_STDCALL,) + except AttributeError: + pass + return global_cache(self, ffi, 'new_function_type', + tuple(args), result, self.ellipsis, *abi_args) + + def as_raw_function(self): + return RawFunctionType(self.args, self.result, self.ellipsis, self.abi) + + +class PointerType(BaseType): + _attrs_ = ('totype', 'quals') + + def __init__(self, totype, quals=0): + self.totype = totype + self.quals = quals + extra = " *&" + if totype.is_array_type: + extra = "(%s)" % (extra.lstrip(),) + extra = qualify(quals, extra) + self.c_name_with_marker = totype.c_name_with_marker.replace('&', extra) + + def build_backend_type(self, ffi, finishlist): + BItem = self.totype.get_cached_btype(ffi, finishlist, can_delay=True) + return global_cache(self, ffi, 'new_pointer_type', BItem) + +voidp_type = PointerType(void_type) + +def ConstPointerType(totype): + return PointerType(totype, Q_CONST) + +const_voidp_type = ConstPointerType(void_type) + + +class NamedPointerType(PointerType): + _attrs_ = ('totype', 'name') + + def __init__(self, totype, name, quals=0): + PointerType.__init__(self, totype, quals) + self.name = name + self.c_name_with_marker = name + '&' + + +class ArrayType(BaseType): + _attrs_ = ('item', 'length') + is_array_type = True + + def __init__(self, item, length): + self.item = item + self.length = length + # + if length is None: + brackets = '&[]' + elif length == '...': + brackets = '&[/*...*/]' + else: + brackets = '&[%s]' % length + self.c_name_with_marker = ( + self.item.c_name_with_marker.replace('&', brackets)) + + def length_is_unknown(self): + return isinstance(self.length, str) + + def resolve_length(self, newlength): + return ArrayType(self.item, newlength) + + def build_backend_type(self, ffi, finishlist): + if self.length_is_unknown(): + raise CDefError("cannot render the type %r: unknown length" % + (self,)) + self.item.get_cached_btype(ffi, finishlist) # force the item BType + BPtrItem = PointerType(self.item).get_cached_btype(ffi, finishlist) + return global_cache(self, ffi, 'new_array_type', BPtrItem, self.length) + +char_array_type = ArrayType(PrimitiveType('char'), None) + + +class StructOrUnionOrEnum(BaseTypeByIdentity): + _attrs_ = ('name',) + forcename = None + + def build_c_name_with_marker(self): + name = self.forcename or '%s %s' % (self.kind, self.name) + self.c_name_with_marker = name + '&' + + def force_the_name(self, forcename): + self.forcename = forcename + self.build_c_name_with_marker() + + def get_official_name(self): + assert self.c_name_with_marker.endswith('&') + return self.c_name_with_marker[:-1] + + +class StructOrUnion(StructOrUnionOrEnum): + fixedlayout = None + completed = 0 + partial = False + packed = 0 + + def __init__(self, name, fldnames, fldtypes, fldbitsize, fldquals=None): + self.name = name + self.fldnames = fldnames + self.fldtypes = fldtypes + self.fldbitsize = fldbitsize + self.fldquals = fldquals + self.build_c_name_with_marker() + + def anonymous_struct_fields(self): + if self.fldtypes is not None: + for name, type in zip(self.fldnames, self.fldtypes): + if name == '' and isinstance(type, StructOrUnion): + yield type + + def enumfields(self, expand_anonymous_struct_union=True): + fldquals = self.fldquals + if fldquals is None: + fldquals = (0,) * len(self.fldnames) + for name, type, bitsize, quals in zip(self.fldnames, self.fldtypes, + self.fldbitsize, fldquals): + if (name == '' and isinstance(type, StructOrUnion) + and expand_anonymous_struct_union): + # nested anonymous struct/union + for result in type.enumfields(): + yield result + else: + yield (name, type, bitsize, quals) + + def force_flatten(self): + # force the struct or union to have a declaration that lists + # directly all fields returned by enumfields(), flattening + # nested anonymous structs/unions. + names = [] + types = [] + bitsizes = [] + fldquals = [] + for name, type, bitsize, quals in self.enumfields(): + names.append(name) + types.append(type) + bitsizes.append(bitsize) + fldquals.append(quals) + self.fldnames = tuple(names) + self.fldtypes = tuple(types) + self.fldbitsize = tuple(bitsizes) + self.fldquals = tuple(fldquals) + + def get_cached_btype(self, ffi, finishlist, can_delay=False): + BType = StructOrUnionOrEnum.get_cached_btype(self, ffi, finishlist, + can_delay) + if not can_delay: + self.finish_backend_type(ffi, finishlist) + return BType + + def finish_backend_type(self, ffi, finishlist): + if self.completed: + if self.completed != 2: + raise NotImplementedError("recursive structure declaration " + "for '%s'" % (self.name,)) + return + BType = ffi._cached_btypes[self] + # + self.completed = 1 + # + if self.fldtypes is None: + pass # not completing it: it's an opaque struct + # + elif self.fixedlayout is None: + fldtypes = [tp.get_cached_btype(ffi, finishlist) + for tp in self.fldtypes] + lst = list(zip(self.fldnames, fldtypes, self.fldbitsize)) + extra_flags = () + if self.packed: + if self.packed == 1: + extra_flags = (8,) # SF_PACKED + else: + extra_flags = (0, self.packed) + ffi._backend.complete_struct_or_union(BType, lst, self, + -1, -1, *extra_flags) + # + else: + fldtypes = [] + fieldofs, fieldsize, totalsize, totalalignment = self.fixedlayout + for i in range(len(self.fldnames)): + fsize = fieldsize[i] + ftype = self.fldtypes[i] + # + if isinstance(ftype, ArrayType) and ftype.length_is_unknown(): + # fix the length to match the total size + BItemType = ftype.item.get_cached_btype(ffi, finishlist) + nlen, nrest = divmod(fsize, ffi.sizeof(BItemType)) + if nrest != 0: + self._verification_error( + "field '%s.%s' has a bogus size?" % ( + self.name, self.fldnames[i] or '{}')) + ftype = ftype.resolve_length(nlen) + self.fldtypes = (self.fldtypes[:i] + (ftype,) + + self.fldtypes[i+1:]) + # + BFieldType = ftype.get_cached_btype(ffi, finishlist) + if isinstance(ftype, ArrayType) and ftype.length is None: + assert fsize == 0 + else: + bitemsize = ffi.sizeof(BFieldType) + if bitemsize != fsize: + self._verification_error( + "field '%s.%s' is declared as %d bytes, but is " + "really %d bytes" % (self.name, + self.fldnames[i] or '{}', + bitemsize, fsize)) + fldtypes.append(BFieldType) + # + lst = list(zip(self.fldnames, fldtypes, self.fldbitsize, fieldofs)) + ffi._backend.complete_struct_or_union(BType, lst, self, + totalsize, totalalignment) + self.completed = 2 + + def _verification_error(self, msg): + raise VerificationError(msg) + + def check_not_partial(self): + if self.partial and self.fixedlayout is None: + raise VerificationMissing(self._get_c_name()) + + def build_backend_type(self, ffi, finishlist): + self.check_not_partial() + finishlist.append(self) + # + return global_cache(self, ffi, 'new_%s_type' % self.kind, + self.get_official_name(), key=self) + + +class StructType(StructOrUnion): + kind = 'struct' + + +class UnionType(StructOrUnion): + kind = 'union' + + +class EnumType(StructOrUnionOrEnum): + kind = 'enum' + partial = False + partial_resolved = False + + def __init__(self, name, enumerators, enumvalues, baseinttype=None): + self.name = name + self.enumerators = enumerators + self.enumvalues = enumvalues + self.baseinttype = baseinttype + self.build_c_name_with_marker() + + def force_the_name(self, forcename): + StructOrUnionOrEnum.force_the_name(self, forcename) + if self.forcename is None: + name = self.get_official_name() + self.forcename = '$' + name.replace(' ', '_') + + def check_not_partial(self): + if self.partial and not self.partial_resolved: + raise VerificationMissing(self._get_c_name()) + + def build_backend_type(self, ffi, finishlist): + self.check_not_partial() + base_btype = self.build_baseinttype(ffi, finishlist) + return global_cache(self, ffi, 'new_enum_type', + self.get_official_name(), + self.enumerators, self.enumvalues, + base_btype, key=self) + + def build_baseinttype(self, ffi, finishlist): + if self.baseinttype is not None: + return self.baseinttype.get_cached_btype(ffi, finishlist) + # + if self.enumvalues: + smallest_value = min(self.enumvalues) + largest_value = max(self.enumvalues) + else: + import warnings + try: + # XXX! The goal is to ensure that the warnings.warn() + # will not suppress the warning. We want to get it + # several times if we reach this point several times. + __warningregistry__.clear() + except NameError: + pass + warnings.warn("%r has no values explicitly defined; " + "guessing that it is equivalent to 'unsigned int'" + % self._get_c_name()) + smallest_value = largest_value = 0 + if smallest_value < 0: # needs a signed type + sign = 1 + candidate1 = PrimitiveType("int") + candidate2 = PrimitiveType("long") + else: + sign = 0 + candidate1 = PrimitiveType("unsigned int") + candidate2 = PrimitiveType("unsigned long") + btype1 = candidate1.get_cached_btype(ffi, finishlist) + btype2 = candidate2.get_cached_btype(ffi, finishlist) + size1 = ffi.sizeof(btype1) + size2 = ffi.sizeof(btype2) + if (smallest_value >= ((-1) << (8*size1-1)) and + largest_value < (1 << (8*size1-sign))): + return btype1 + if (smallest_value >= ((-1) << (8*size2-1)) and + largest_value < (1 << (8*size2-sign))): + return btype2 + raise CDefError("%s values don't all fit into either 'long' " + "or 'unsigned long'" % self._get_c_name()) + +def unknown_type(name, structname=None): + if structname is None: + structname = '$%s' % name + tp = StructType(structname, None, None, None) + tp.force_the_name(name) + tp.origin = "unknown_type" + return tp + +def unknown_ptr_type(name, structname=None): + if structname is None: + structname = '$$%s' % name + tp = StructType(structname, None, None, None) + return NamedPointerType(tp, name) + + +global_lock = allocate_lock() +_typecache_cffi_backend = weakref.WeakValueDictionary() + +def get_typecache(backend): + # returns _typecache_cffi_backend if backend is the _cffi_backend + # module, or type(backend).__typecache if backend is an instance of + # CTypesBackend (or some FakeBackend class during tests) + if isinstance(backend, types.ModuleType): + return _typecache_cffi_backend + with global_lock: + if not hasattr(type(backend), '__typecache'): + type(backend).__typecache = weakref.WeakValueDictionary() + return type(backend).__typecache + +def global_cache(srctype, ffi, funcname, *args, **kwds): + key = kwds.pop('key', (funcname, args)) + assert not kwds + try: + return ffi._typecache[key] + except KeyError: + pass + try: + res = getattr(ffi._backend, funcname)(*args) + except NotImplementedError as e: + raise NotImplementedError("%s: %r: %s" % (funcname, srctype, e)) + # note that setdefault() on WeakValueDictionary is not atomic + # and contains a rare bug (http://bugs.python.org/issue19542); + # we have to use a lock and do it ourselves + cache = ffi._typecache + with global_lock: + res1 = cache.get(key) + if res1 is None: + cache[key] = res + return res + else: + return res1 + +def pointer_cache(ffi, BType): + return global_cache('?', ffi, 'new_pointer_type', BType) + +def attach_exception_info(e, name): + if e.args and type(e.args[0]) is str: + e.args = ('%s: %s' % (name, e.args[0]),) + e.args[1:] diff --git a/venv/lib/python3.12/site-packages/cffi/parse_c_type.h b/venv/lib/python3.12/site-packages/cffi/parse_c_type.h new file mode 100644 index 00000000..84e4ef85 --- /dev/null +++ b/venv/lib/python3.12/site-packages/cffi/parse_c_type.h @@ -0,0 +1,181 @@ + +/* This part is from file 'cffi/parse_c_type.h'. It is copied at the + beginning of C sources generated by CFFI's ffi.set_source(). */ + +typedef void *_cffi_opcode_t; + +#define _CFFI_OP(opcode, arg) (_cffi_opcode_t)(opcode | (((uintptr_t)(arg)) << 8)) +#define _CFFI_GETOP(cffi_opcode) ((unsigned char)(uintptr_t)cffi_opcode) +#define _CFFI_GETARG(cffi_opcode) (((intptr_t)cffi_opcode) >> 8) + +#define _CFFI_OP_PRIMITIVE 1 +#define _CFFI_OP_POINTER 3 +#define _CFFI_OP_ARRAY 5 +#define _CFFI_OP_OPEN_ARRAY 7 +#define _CFFI_OP_STRUCT_UNION 9 +#define _CFFI_OP_ENUM 11 +#define _CFFI_OP_FUNCTION 13 +#define _CFFI_OP_FUNCTION_END 15 +#define _CFFI_OP_NOOP 17 +#define _CFFI_OP_BITFIELD 19 +#define _CFFI_OP_TYPENAME 21 +#define _CFFI_OP_CPYTHON_BLTN_V 23 // varargs +#define _CFFI_OP_CPYTHON_BLTN_N 25 // noargs +#define _CFFI_OP_CPYTHON_BLTN_O 27 // O (i.e. a single arg) +#define _CFFI_OP_CONSTANT 29 +#define _CFFI_OP_CONSTANT_INT 31 +#define _CFFI_OP_GLOBAL_VAR 33 +#define _CFFI_OP_DLOPEN_FUNC 35 +#define _CFFI_OP_DLOPEN_CONST 37 +#define _CFFI_OP_GLOBAL_VAR_F 39 +#define _CFFI_OP_EXTERN_PYTHON 41 + +#define _CFFI_PRIM_VOID 0 +#define _CFFI_PRIM_BOOL 1 +#define _CFFI_PRIM_CHAR 2 +#define _CFFI_PRIM_SCHAR 3 +#define _CFFI_PRIM_UCHAR 4 +#define _CFFI_PRIM_SHORT 5 +#define _CFFI_PRIM_USHORT 6 +#define _CFFI_PRIM_INT 7 +#define _CFFI_PRIM_UINT 8 +#define _CFFI_PRIM_LONG 9 +#define _CFFI_PRIM_ULONG 10 +#define _CFFI_PRIM_LONGLONG 11 +#define _CFFI_PRIM_ULONGLONG 12 +#define _CFFI_PRIM_FLOAT 13 +#define _CFFI_PRIM_DOUBLE 14 +#define _CFFI_PRIM_LONGDOUBLE 15 + +#define _CFFI_PRIM_WCHAR 16 +#define _CFFI_PRIM_INT8 17 +#define _CFFI_PRIM_UINT8 18 +#define _CFFI_PRIM_INT16 19 +#define _CFFI_PRIM_UINT16 20 +#define _CFFI_PRIM_INT32 21 +#define _CFFI_PRIM_UINT32 22 +#define _CFFI_PRIM_INT64 23 +#define _CFFI_PRIM_UINT64 24 +#define _CFFI_PRIM_INTPTR 25 +#define _CFFI_PRIM_UINTPTR 26 +#define _CFFI_PRIM_PTRDIFF 27 +#define _CFFI_PRIM_SIZE 28 +#define _CFFI_PRIM_SSIZE 29 +#define _CFFI_PRIM_INT_LEAST8 30 +#define _CFFI_PRIM_UINT_LEAST8 31 +#define _CFFI_PRIM_INT_LEAST16 32 +#define _CFFI_PRIM_UINT_LEAST16 33 +#define _CFFI_PRIM_INT_LEAST32 34 +#define _CFFI_PRIM_UINT_LEAST32 35 +#define _CFFI_PRIM_INT_LEAST64 36 +#define _CFFI_PRIM_UINT_LEAST64 37 +#define _CFFI_PRIM_INT_FAST8 38 +#define _CFFI_PRIM_UINT_FAST8 39 +#define _CFFI_PRIM_INT_FAST16 40 +#define _CFFI_PRIM_UINT_FAST16 41 +#define _CFFI_PRIM_INT_FAST32 42 +#define _CFFI_PRIM_UINT_FAST32 43 +#define _CFFI_PRIM_INT_FAST64 44 +#define _CFFI_PRIM_UINT_FAST64 45 +#define _CFFI_PRIM_INTMAX 46 +#define _CFFI_PRIM_UINTMAX 47 +#define _CFFI_PRIM_FLOATCOMPLEX 48 +#define _CFFI_PRIM_DOUBLECOMPLEX 49 +#define _CFFI_PRIM_CHAR16 50 +#define _CFFI_PRIM_CHAR32 51 + +#define _CFFI__NUM_PRIM 52 +#define _CFFI__UNKNOWN_PRIM (-1) +#define _CFFI__UNKNOWN_FLOAT_PRIM (-2) +#define _CFFI__UNKNOWN_LONG_DOUBLE (-3) + +#define _CFFI__IO_FILE_STRUCT (-1) + + +struct _cffi_global_s { + const char *name; + void *address; + _cffi_opcode_t type_op; + void *size_or_direct_fn; // OP_GLOBAL_VAR: size, or 0 if unknown + // OP_CPYTHON_BLTN_*: addr of direct function +}; + +struct _cffi_getconst_s { + unsigned long long value; + const struct _cffi_type_context_s *ctx; + int gindex; +}; + +struct _cffi_struct_union_s { + const char *name; + int type_index; // -> _cffi_types, on a OP_STRUCT_UNION + int flags; // _CFFI_F_* flags below + size_t size; + int alignment; + int first_field_index; // -> _cffi_fields array + int num_fields; +}; +#define _CFFI_F_UNION 0x01 // is a union, not a struct +#define _CFFI_F_CHECK_FIELDS 0x02 // complain if fields are not in the + // "standard layout" or if some are missing +#define _CFFI_F_PACKED 0x04 // for CHECK_FIELDS, assume a packed struct +#define _CFFI_F_EXTERNAL 0x08 // in some other ffi.include() +#define _CFFI_F_OPAQUE 0x10 // opaque + +struct _cffi_field_s { + const char *name; + size_t field_offset; + size_t field_size; + _cffi_opcode_t field_type_op; +}; + +struct _cffi_enum_s { + const char *name; + int type_index; // -> _cffi_types, on a OP_ENUM + int type_prim; // _CFFI_PRIM_xxx + const char *enumerators; // comma-delimited string +}; + +struct _cffi_typename_s { + const char *name; + int type_index; /* if opaque, points to a possibly artificial + OP_STRUCT which is itself opaque */ +}; + +struct _cffi_type_context_s { + _cffi_opcode_t *types; + const struct _cffi_global_s *globals; + const struct _cffi_field_s *fields; + const struct _cffi_struct_union_s *struct_unions; + const struct _cffi_enum_s *enums; + const struct _cffi_typename_s *typenames; + int num_globals; + int num_struct_unions; + int num_enums; + int num_typenames; + const char *const *includes; + int num_types; + int flags; /* future extension */ +}; + +struct _cffi_parse_info_s { + const struct _cffi_type_context_s *ctx; + _cffi_opcode_t *output; + unsigned int output_size; + size_t error_location; + const char *error_message; +}; + +struct _cffi_externpy_s { + const char *name; + size_t size_of_result; + void *reserved1, *reserved2; +}; + +#ifdef _CFFI_INTERNAL +static int parse_c_type(struct _cffi_parse_info_s *info, const char *input); +static int search_in_globals(const struct _cffi_type_context_s *ctx, + const char *search, size_t search_len); +static int search_in_struct_unions(const struct _cffi_type_context_s *ctx, + const char *search, size_t search_len); +#endif diff --git a/venv/lib/python3.12/site-packages/cffi/pkgconfig.py b/venv/lib/python3.12/site-packages/cffi/pkgconfig.py new file mode 100644 index 00000000..5c93f15a --- /dev/null +++ b/venv/lib/python3.12/site-packages/cffi/pkgconfig.py @@ -0,0 +1,121 @@ +# pkg-config, https://www.freedesktop.org/wiki/Software/pkg-config/ integration for cffi +import sys, os, subprocess + +from .error import PkgConfigError + + +def merge_flags(cfg1, cfg2): + """Merge values from cffi config flags cfg2 to cf1 + + Example: + merge_flags({"libraries": ["one"]}, {"libraries": ["two"]}) + {"libraries": ["one", "two"]} + """ + for key, value in cfg2.items(): + if key not in cfg1: + cfg1[key] = value + else: + if not isinstance(cfg1[key], list): + raise TypeError("cfg1[%r] should be a list of strings" % (key,)) + if not isinstance(value, list): + raise TypeError("cfg2[%r] should be a list of strings" % (key,)) + cfg1[key].extend(value) + return cfg1 + + +def call(libname, flag, encoding=sys.getfilesystemencoding()): + """Calls pkg-config and returns the output if found + """ + a = ["pkg-config", "--print-errors"] + a.append(flag) + a.append(libname) + try: + pc = subprocess.Popen(a, stdout=subprocess.PIPE, stderr=subprocess.PIPE) + except EnvironmentError as e: + raise PkgConfigError("cannot run pkg-config: %s" % (str(e).strip(),)) + + bout, berr = pc.communicate() + if pc.returncode != 0: + try: + berr = berr.decode(encoding) + except Exception: + pass + raise PkgConfigError(berr.strip()) + + if sys.version_info >= (3,) and not isinstance(bout, str): # Python 3.x + try: + bout = bout.decode(encoding) + except UnicodeDecodeError: + raise PkgConfigError("pkg-config %s %s returned bytes that cannot " + "be decoded with encoding %r:\n%r" % + (flag, libname, encoding, bout)) + + if os.altsep != '\\' and '\\' in bout: + raise PkgConfigError("pkg-config %s %s returned an unsupported " + "backslash-escaped output:\n%r" % + (flag, libname, bout)) + return bout + + +def flags_from_pkgconfig(libs): + r"""Return compiler line flags for FFI.set_source based on pkg-config output + + Usage + ... + ffibuilder.set_source("_foo", pkgconfig = ["libfoo", "libbar >= 1.8.3"]) + + If pkg-config is installed on build machine, then arguments include_dirs, + library_dirs, libraries, define_macros, extra_compile_args and + extra_link_args are extended with an output of pkg-config for libfoo and + libbar. + + Raises PkgConfigError in case the pkg-config call fails. + """ + + def get_include_dirs(string): + return [x[2:] for x in string.split() if x.startswith("-I")] + + def get_library_dirs(string): + return [x[2:] for x in string.split() if x.startswith("-L")] + + def get_libraries(string): + return [x[2:] for x in string.split() if x.startswith("-l")] + + # convert -Dfoo=bar to list of tuples [("foo", "bar")] expected by distutils + def get_macros(string): + def _macro(x): + x = x[2:] # drop "-D" + if '=' in x: + return tuple(x.split("=", 1)) # "-Dfoo=bar" => ("foo", "bar") + else: + return (x, None) # "-Dfoo" => ("foo", None) + return [_macro(x) for x in string.split() if x.startswith("-D")] + + def get_other_cflags(string): + return [x for x in string.split() if not x.startswith("-I") and + not x.startswith("-D")] + + def get_other_libs(string): + return [x for x in string.split() if not x.startswith("-L") and + not x.startswith("-l")] + + # return kwargs for given libname + def kwargs(libname): + fse = sys.getfilesystemencoding() + all_cflags = call(libname, "--cflags") + all_libs = call(libname, "--libs") + return { + "include_dirs": get_include_dirs(all_cflags), + "library_dirs": get_library_dirs(all_libs), + "libraries": get_libraries(all_libs), + "define_macros": get_macros(all_cflags), + "extra_compile_args": get_other_cflags(all_cflags), + "extra_link_args": get_other_libs(all_libs), + } + + # merge all arguments together + ret = {} + for libname in libs: + lib_flags = kwargs(libname) + merge_flags(ret, lib_flags) + return ret diff --git a/venv/lib/python3.12/site-packages/cffi/recompiler.py b/venv/lib/python3.12/site-packages/cffi/recompiler.py new file mode 100644 index 00000000..57781a3c --- /dev/null +++ b/venv/lib/python3.12/site-packages/cffi/recompiler.py @@ -0,0 +1,1598 @@ +import os, sys, io +from . import ffiplatform, model +from .error import VerificationError +from .cffi_opcode import * + +VERSION_BASE = 0x2601 +VERSION_EMBEDDED = 0x2701 +VERSION_CHAR16CHAR32 = 0x2801 + +USE_LIMITED_API = (sys.platform != 'win32' or sys.version_info < (3, 0) or + sys.version_info >= (3, 5)) + + +class GlobalExpr: + def __init__(self, name, address, type_op, size=0, check_value=0): + self.name = name + self.address = address + self.type_op = type_op + self.size = size + self.check_value = check_value + + def as_c_expr(self): + return ' { "%s", (void *)%s, %s, (void *)%s },' % ( + self.name, self.address, self.type_op.as_c_expr(), self.size) + + def as_python_expr(self): + return "b'%s%s',%d" % (self.type_op.as_python_bytes(), self.name, + self.check_value) + +class FieldExpr: + def __init__(self, name, field_offset, field_size, fbitsize, field_type_op): + self.name = name + self.field_offset = field_offset + self.field_size = field_size + self.fbitsize = fbitsize + self.field_type_op = field_type_op + + def as_c_expr(self): + spaces = " " * len(self.name) + return (' { "%s", %s,\n' % (self.name, self.field_offset) + + ' %s %s,\n' % (spaces, self.field_size) + + ' %s %s },' % (spaces, self.field_type_op.as_c_expr())) + + def as_python_expr(self): + raise NotImplementedError + + def as_field_python_expr(self): + if self.field_type_op.op == OP_NOOP: + size_expr = '' + elif self.field_type_op.op == OP_BITFIELD: + size_expr = format_four_bytes(self.fbitsize) + else: + raise NotImplementedError + return "b'%s%s%s'" % (self.field_type_op.as_python_bytes(), + size_expr, + self.name) + +class StructUnionExpr: + def __init__(self, name, type_index, flags, size, alignment, comment, + first_field_index, c_fields): + self.name = name + self.type_index = type_index + self.flags = flags + self.size = size + self.alignment = alignment + self.comment = comment + self.first_field_index = first_field_index + self.c_fields = c_fields + + def as_c_expr(self): + return (' { "%s", %d, %s,' % (self.name, self.type_index, self.flags) + + '\n %s, %s, ' % (self.size, self.alignment) + + '%d, %d ' % (self.first_field_index, len(self.c_fields)) + + ('/* %s */ ' % self.comment if self.comment else '') + + '},') + + def as_python_expr(self): + flags = eval(self.flags, G_FLAGS) + fields_expr = [c_field.as_field_python_expr() + for c_field in self.c_fields] + return "(b'%s%s%s',%s)" % ( + format_four_bytes(self.type_index), + format_four_bytes(flags), + self.name, + ','.join(fields_expr)) + +class EnumExpr: + def __init__(self, name, type_index, size, signed, allenums): + self.name = name + self.type_index = type_index + self.size = size + self.signed = signed + self.allenums = allenums + + def as_c_expr(self): + return (' { "%s", %d, _cffi_prim_int(%s, %s),\n' + ' "%s" },' % (self.name, self.type_index, + self.size, self.signed, self.allenums)) + + def as_python_expr(self): + prim_index = { + (1, 0): PRIM_UINT8, (1, 1): PRIM_INT8, + (2, 0): PRIM_UINT16, (2, 1): PRIM_INT16, + (4, 0): PRIM_UINT32, (4, 1): PRIM_INT32, + (8, 0): PRIM_UINT64, (8, 1): PRIM_INT64, + }[self.size, self.signed] + return "b'%s%s%s\\x00%s'" % (format_four_bytes(self.type_index), + format_four_bytes(prim_index), + self.name, self.allenums) + +class TypenameExpr: + def __init__(self, name, type_index): + self.name = name + self.type_index = type_index + + def as_c_expr(self): + return ' { "%s", %d },' % (self.name, self.type_index) + + def as_python_expr(self): + return "b'%s%s'" % (format_four_bytes(self.type_index), self.name) + + +# ____________________________________________________________ + + +class Recompiler: + _num_externpy = 0 + + def __init__(self, ffi, module_name, target_is_python=False): + self.ffi = ffi + self.module_name = module_name + self.target_is_python = target_is_python + self._version = VERSION_BASE + + def needs_version(self, ver): + self._version = max(self._version, ver) + + def collect_type_table(self): + self._typesdict = {} + self._generate("collecttype") + # + all_decls = sorted(self._typesdict, key=str) + # + # prepare all FUNCTION bytecode sequences first + self.cffi_types = [] + for tp in all_decls: + if tp.is_raw_function: + assert self._typesdict[tp] is None + self._typesdict[tp] = len(self.cffi_types) + self.cffi_types.append(tp) # placeholder + for tp1 in tp.args: + assert isinstance(tp1, (model.VoidType, + model.BasePrimitiveType, + model.PointerType, + model.StructOrUnionOrEnum, + model.FunctionPtrType)) + if self._typesdict[tp1] is None: + self._typesdict[tp1] = len(self.cffi_types) + self.cffi_types.append(tp1) # placeholder + self.cffi_types.append('END') # placeholder + # + # prepare all OTHER bytecode sequences + for tp in all_decls: + if not tp.is_raw_function and self._typesdict[tp] is None: + self._typesdict[tp] = len(self.cffi_types) + self.cffi_types.append(tp) # placeholder + if tp.is_array_type and tp.length is not None: + self.cffi_types.append('LEN') # placeholder + assert None not in self._typesdict.values() + # + # collect all structs and unions and enums + self._struct_unions = {} + self._enums = {} + for tp in all_decls: + if isinstance(tp, model.StructOrUnion): + self._struct_unions[tp] = None + elif isinstance(tp, model.EnumType): + self._enums[tp] = None + for i, tp in enumerate(sorted(self._struct_unions, + key=lambda tp: tp.name)): + self._struct_unions[tp] = i + for i, tp in enumerate(sorted(self._enums, + key=lambda tp: tp.name)): + self._enums[tp] = i + # + # emit all bytecode sequences now + for tp in all_decls: + method = getattr(self, '_emit_bytecode_' + tp.__class__.__name__) + method(tp, self._typesdict[tp]) + # + # consistency check + for op in self.cffi_types: + assert isinstance(op, CffiOp) + self.cffi_types = tuple(self.cffi_types) # don't change any more + + def _enum_fields(self, tp): + # When producing C, expand all anonymous struct/union fields. + # That's necessary to have C code checking the offsets of the + # individual fields contained in them. When producing Python, + # don't do it and instead write it like it is, with the + # corresponding fields having an empty name. Empty names are + # recognized at runtime when we import the generated Python + # file. + expand_anonymous_struct_union = not self.target_is_python + return tp.enumfields(expand_anonymous_struct_union) + + def _do_collect_type(self, tp): + if not isinstance(tp, model.BaseTypeByIdentity): + if isinstance(tp, tuple): + for x in tp: + self._do_collect_type(x) + return + if tp not in self._typesdict: + self._typesdict[tp] = None + if isinstance(tp, model.FunctionPtrType): + self._do_collect_type(tp.as_raw_function()) + elif isinstance(tp, model.StructOrUnion): + if tp.fldtypes is not None and ( + tp not in self.ffi._parser._included_declarations): + for name1, tp1, _, _ in self._enum_fields(tp): + self._do_collect_type(self._field_type(tp, name1, tp1)) + else: + for _, x in tp._get_items(): + self._do_collect_type(x) + + def _generate(self, step_name): + lst = self.ffi._parser._declarations.items() + for name, (tp, quals) in sorted(lst): + kind, realname = name.split(' ', 1) + try: + method = getattr(self, '_generate_cpy_%s_%s' % (kind, + step_name)) + except AttributeError: + raise VerificationError( + "not implemented in recompile(): %r" % name) + try: + self._current_quals = quals + method(tp, realname) + except Exception as e: + model.attach_exception_info(e, name) + raise + + # ---------- + + ALL_STEPS = ["global", "field", "struct_union", "enum", "typename"] + + def collect_step_tables(self): + # collect the declarations for '_cffi_globals', '_cffi_typenames', etc. + self._lsts = {} + for step_name in self.ALL_STEPS: + self._lsts[step_name] = [] + self._seen_struct_unions = set() + self._generate("ctx") + self._add_missing_struct_unions() + # + for step_name in self.ALL_STEPS: + lst = self._lsts[step_name] + if step_name != "field": + lst.sort(key=lambda entry: entry.name) + self._lsts[step_name] = tuple(lst) # don't change any more + # + # check for a possible internal inconsistency: _cffi_struct_unions + # should have been generated with exactly self._struct_unions + lst = self._lsts["struct_union"] + for tp, i in self._struct_unions.items(): + assert i < len(lst) + assert lst[i].name == tp.name + assert len(lst) == len(self._struct_unions) + # same with enums + lst = self._lsts["enum"] + for tp, i in self._enums.items(): + assert i < len(lst) + assert lst[i].name == tp.name + assert len(lst) == len(self._enums) + + # ---------- + + def _prnt(self, what=''): + self._f.write(what + '\n') + + def write_source_to_f(self, f, preamble): + if self.target_is_python: + assert preamble is None + self.write_py_source_to_f(f) + else: + assert preamble is not None + self.write_c_source_to_f(f, preamble) + + def _rel_readlines(self, filename): + g = open(os.path.join(os.path.dirname(__file__), filename), 'r') + lines = g.readlines() + g.close() + return lines + + def write_c_source_to_f(self, f, preamble): + self._f = f + prnt = self._prnt + if self.ffi._embedding is not None: + prnt('#define _CFFI_USE_EMBEDDING') + if not USE_LIMITED_API: + prnt('#define _CFFI_NO_LIMITED_API') + # + # first the '#include' (actually done by inlining the file's content) + lines = self._rel_readlines('_cffi_include.h') + i = lines.index('#include "parse_c_type.h"\n') + lines[i:i+1] = self._rel_readlines('parse_c_type.h') + prnt(''.join(lines)) + # + # if we have ffi._embedding != None, we give it here as a macro + # and include an extra file + base_module_name = self.module_name.split('.')[-1] + if self.ffi._embedding is not None: + prnt('#define _CFFI_MODULE_NAME "%s"' % (self.module_name,)) + prnt('static const char _CFFI_PYTHON_STARTUP_CODE[] = {') + self._print_string_literal_in_array(self.ffi._embedding) + prnt('0 };') + prnt('#ifdef PYPY_VERSION') + prnt('# define _CFFI_PYTHON_STARTUP_FUNC _cffi_pypyinit_%s' % ( + base_module_name,)) + prnt('#elif PY_MAJOR_VERSION >= 3') + prnt('# define _CFFI_PYTHON_STARTUP_FUNC PyInit_%s' % ( + base_module_name,)) + prnt('#else') + prnt('# define _CFFI_PYTHON_STARTUP_FUNC init%s' % ( + base_module_name,)) + prnt('#endif') + lines = self._rel_readlines('_embedding.h') + i = lines.index('#include "_cffi_errors.h"\n') + lines[i:i+1] = self._rel_readlines('_cffi_errors.h') + prnt(''.join(lines)) + self.needs_version(VERSION_EMBEDDED) + # + # then paste the C source given by the user, verbatim. + prnt('/************************************************************/') + prnt() + prnt(preamble) + prnt() + prnt('/************************************************************/') + prnt() + # + # the declaration of '_cffi_types' + prnt('static void *_cffi_types[] = {') + typeindex2type = dict([(i, tp) for (tp, i) in self._typesdict.items()]) + for i, op in enumerate(self.cffi_types): + comment = '' + if i in typeindex2type: + comment = ' // ' + typeindex2type[i]._get_c_name() + prnt('/* %2d */ %s,%s' % (i, op.as_c_expr(), comment)) + if not self.cffi_types: + prnt(' 0') + prnt('};') + prnt() + # + # call generate_cpy_xxx_decl(), for every xxx found from + # ffi._parser._declarations. This generates all the functions. + self._seen_constants = set() + self._generate("decl") + # + # the declaration of '_cffi_globals' and '_cffi_typenames' + nums = {} + for step_name in self.ALL_STEPS: + lst = self._lsts[step_name] + nums[step_name] = len(lst) + if nums[step_name] > 0: + prnt('static const struct _cffi_%s_s _cffi_%ss[] = {' % ( + step_name, step_name)) + for entry in lst: + prnt(entry.as_c_expr()) + prnt('};') + prnt() + # + # the declaration of '_cffi_includes' + if self.ffi._included_ffis: + prnt('static const char * const _cffi_includes[] = {') + for ffi_to_include in self.ffi._included_ffis: + try: + included_module_name, included_source = ( + ffi_to_include._assigned_source[:2]) + except AttributeError: + raise VerificationError( + "ffi object %r includes %r, but the latter has not " + "been prepared with set_source()" % ( + self.ffi, ffi_to_include,)) + if included_source is None: + raise VerificationError( + "not implemented yet: ffi.include() of a Python-based " + "ffi inside a C-based ffi") + prnt(' "%s",' % (included_module_name,)) + prnt(' NULL') + prnt('};') + prnt() + # + # the declaration of '_cffi_type_context' + prnt('static const struct _cffi_type_context_s _cffi_type_context = {') + prnt(' _cffi_types,') + for step_name in self.ALL_STEPS: + if nums[step_name] > 0: + prnt(' _cffi_%ss,' % step_name) + else: + prnt(' NULL, /* no %ss */' % step_name) + for step_name in self.ALL_STEPS: + if step_name != "field": + prnt(' %d, /* num_%ss */' % (nums[step_name], step_name)) + if self.ffi._included_ffis: + prnt(' _cffi_includes,') + else: + prnt(' NULL, /* no includes */') + prnt(' %d, /* num_types */' % (len(self.cffi_types),)) + flags = 0 + if self._num_externpy > 0 or self.ffi._embedding is not None: + flags |= 1 # set to mean that we use extern "Python" + prnt(' %d, /* flags */' % flags) + prnt('};') + prnt() + # + # the init function + prnt('#ifdef __GNUC__') + prnt('# pragma GCC visibility push(default) /* for -fvisibility= */') + prnt('#endif') + prnt() + prnt('#ifdef PYPY_VERSION') + prnt('PyMODINIT_FUNC') + prnt('_cffi_pypyinit_%s(const void *p[])' % (base_module_name,)) + prnt('{') + if flags & 1: + prnt(' if (((intptr_t)p[0]) >= 0x0A03) {') + prnt(' _cffi_call_python_org = ' + '(void(*)(struct _cffi_externpy_s *, char *))p[1];') + prnt(' }') + prnt(' p[0] = (const void *)0x%x;' % self._version) + prnt(' p[1] = &_cffi_type_context;') + prnt('#if PY_MAJOR_VERSION >= 3') + prnt(' return NULL;') + prnt('#endif') + prnt('}') + # on Windows, distutils insists on putting init_cffi_xyz in + # 'export_symbols', so instead of fighting it, just give up and + # give it one + prnt('# ifdef _MSC_VER') + prnt(' PyMODINIT_FUNC') + prnt('# if PY_MAJOR_VERSION >= 3') + prnt(' PyInit_%s(void) { return NULL; }' % (base_module_name,)) + prnt('# else') + prnt(' init%s(void) { }' % (base_module_name,)) + prnt('# endif') + prnt('# endif') + prnt('#elif PY_MAJOR_VERSION >= 3') + prnt('PyMODINIT_FUNC') + prnt('PyInit_%s(void)' % (base_module_name,)) + prnt('{') + prnt(' return _cffi_init("%s", 0x%x, &_cffi_type_context);' % ( + self.module_name, self._version)) + prnt('}') + prnt('#else') + prnt('PyMODINIT_FUNC') + prnt('init%s(void)' % (base_module_name,)) + prnt('{') + prnt(' _cffi_init("%s", 0x%x, &_cffi_type_context);' % ( + self.module_name, self._version)) + prnt('}') + prnt('#endif') + prnt() + prnt('#ifdef __GNUC__') + prnt('# pragma GCC visibility pop') + prnt('#endif') + self._version = None + + def _to_py(self, x): + if isinstance(x, str): + return "b'%s'" % (x,) + if isinstance(x, (list, tuple)): + rep = [self._to_py(item) for item in x] + if len(rep) == 1: + rep.append('') + return "(%s)" % (','.join(rep),) + return x.as_python_expr() # Py2: unicode unexpected; Py3: bytes unexp. + + def write_py_source_to_f(self, f): + self._f = f + prnt = self._prnt + # + # header + prnt("# auto-generated file") + prnt("import _cffi_backend") + # + # the 'import' of the included ffis + num_includes = len(self.ffi._included_ffis or ()) + for i in range(num_includes): + ffi_to_include = self.ffi._included_ffis[i] + try: + included_module_name, included_source = ( + ffi_to_include._assigned_source[:2]) + except AttributeError: + raise VerificationError( + "ffi object %r includes %r, but the latter has not " + "been prepared with set_source()" % ( + self.ffi, ffi_to_include,)) + if included_source is not None: + raise VerificationError( + "not implemented yet: ffi.include() of a C-based " + "ffi inside a Python-based ffi") + prnt('from %s import ffi as _ffi%d' % (included_module_name, i)) + prnt() + prnt("ffi = _cffi_backend.FFI('%s'," % (self.module_name,)) + prnt(" _version = 0x%x," % (self._version,)) + self._version = None + # + # the '_types' keyword argument + self.cffi_types = tuple(self.cffi_types) # don't change any more + types_lst = [op.as_python_bytes() for op in self.cffi_types] + prnt(' _types = %s,' % (self._to_py(''.join(types_lst)),)) + typeindex2type = dict([(i, tp) for (tp, i) in self._typesdict.items()]) + # + # the keyword arguments from ALL_STEPS + for step_name in self.ALL_STEPS: + lst = self._lsts[step_name] + if len(lst) > 0 and step_name != "field": + prnt(' _%ss = %s,' % (step_name, self._to_py(lst))) + # + # the '_includes' keyword argument + if num_includes > 0: + prnt(' _includes = (%s,),' % ( + ', '.join(['_ffi%d' % i for i in range(num_includes)]),)) + # + # the footer + prnt(')') + + # ---------- + + def _gettypenum(self, type): + # a KeyError here is a bug. please report it! :-) + return self._typesdict[type] + + def _convert_funcarg_to_c(self, tp, fromvar, tovar, errcode): + extraarg = '' + if isinstance(tp, model.BasePrimitiveType) and not tp.is_complex_type(): + if tp.is_integer_type() and tp.name != '_Bool': + converter = '_cffi_to_c_int' + extraarg = ', %s' % tp.name + elif isinstance(tp, model.UnknownFloatType): + # don't check with is_float_type(): it may be a 'long + # double' here, and _cffi_to_c_double would loose precision + converter = '(%s)_cffi_to_c_double' % (tp.get_c_name(''),) + else: + cname = tp.get_c_name('') + converter = '(%s)_cffi_to_c_%s' % (cname, + tp.name.replace(' ', '_')) + if cname in ('char16_t', 'char32_t'): + self.needs_version(VERSION_CHAR16CHAR32) + errvalue = '-1' + # + elif isinstance(tp, model.PointerType): + self._convert_funcarg_to_c_ptr_or_array(tp, fromvar, + tovar, errcode) + return + # + elif (isinstance(tp, model.StructOrUnionOrEnum) or + isinstance(tp, model.BasePrimitiveType)): + # a struct (not a struct pointer) as a function argument; + # or, a complex (the same code works) + self._prnt(' if (_cffi_to_c((char *)&%s, _cffi_type(%d), %s) < 0)' + % (tovar, self._gettypenum(tp), fromvar)) + self._prnt(' %s;' % errcode) + return + # + elif isinstance(tp, model.FunctionPtrType): + converter = '(%s)_cffi_to_c_pointer' % tp.get_c_name('') + extraarg = ', _cffi_type(%d)' % self._gettypenum(tp) + errvalue = 'NULL' + # + else: + raise NotImplementedError(tp) + # + self._prnt(' %s = %s(%s%s);' % (tovar, converter, fromvar, extraarg)) + self._prnt(' if (%s == (%s)%s && PyErr_Occurred())' % ( + tovar, tp.get_c_name(''), errvalue)) + self._prnt(' %s;' % errcode) + + def _extra_local_variables(self, tp, localvars, freelines): + if isinstance(tp, model.PointerType): + localvars.add('Py_ssize_t datasize') + localvars.add('struct _cffi_freeme_s *large_args_free = NULL') + freelines.add('if (large_args_free != NULL)' + ' _cffi_free_array_arguments(large_args_free);') + + def _convert_funcarg_to_c_ptr_or_array(self, tp, fromvar, tovar, errcode): + self._prnt(' datasize = _cffi_prepare_pointer_call_argument(') + self._prnt(' _cffi_type(%d), %s, (char **)&%s);' % ( + self._gettypenum(tp), fromvar, tovar)) + self._prnt(' if (datasize != 0) {') + self._prnt(' %s = ((size_t)datasize) <= 640 ? ' + '(%s)alloca((size_t)datasize) : NULL;' % ( + tovar, tp.get_c_name(''))) + self._prnt(' if (_cffi_convert_array_argument(_cffi_type(%d), %s, ' + '(char **)&%s,' % (self._gettypenum(tp), fromvar, tovar)) + self._prnt(' datasize, &large_args_free) < 0)') + self._prnt(' %s;' % errcode) + self._prnt(' }') + + def _convert_expr_from_c(self, tp, var, context): + if isinstance(tp, model.BasePrimitiveType): + if tp.is_integer_type() and tp.name != '_Bool': + return '_cffi_from_c_int(%s, %s)' % (var, tp.name) + elif isinstance(tp, model.UnknownFloatType): + return '_cffi_from_c_double(%s)' % (var,) + elif tp.name != 'long double' and not tp.is_complex_type(): + cname = tp.name.replace(' ', '_') + if cname in ('char16_t', 'char32_t'): + self.needs_version(VERSION_CHAR16CHAR32) + return '_cffi_from_c_%s(%s)' % (cname, var) + else: + return '_cffi_from_c_deref((char *)&%s, _cffi_type(%d))' % ( + var, self._gettypenum(tp)) + elif isinstance(tp, (model.PointerType, model.FunctionPtrType)): + return '_cffi_from_c_pointer((char *)%s, _cffi_type(%d))' % ( + var, self._gettypenum(tp)) + elif isinstance(tp, model.ArrayType): + return '_cffi_from_c_pointer((char *)%s, _cffi_type(%d))' % ( + var, self._gettypenum(model.PointerType(tp.item))) + elif isinstance(tp, model.StructOrUnion): + if tp.fldnames is None: + raise TypeError("'%s' is used as %s, but is opaque" % ( + tp._get_c_name(), context)) + return '_cffi_from_c_struct((char *)&%s, _cffi_type(%d))' % ( + var, self._gettypenum(tp)) + elif isinstance(tp, model.EnumType): + return '_cffi_from_c_deref((char *)&%s, _cffi_type(%d))' % ( + var, self._gettypenum(tp)) + else: + raise NotImplementedError(tp) + + # ---------- + # typedefs + + def _typedef_type(self, tp, name): + return self._global_type(tp, "(*(%s *)0)" % (name,)) + + def _generate_cpy_typedef_collecttype(self, tp, name): + self._do_collect_type(self._typedef_type(tp, name)) + + def _generate_cpy_typedef_decl(self, tp, name): + pass + + def _typedef_ctx(self, tp, name): + type_index = self._typesdict[tp] + self._lsts["typename"].append(TypenameExpr(name, type_index)) + + def _generate_cpy_typedef_ctx(self, tp, name): + tp = self._typedef_type(tp, name) + self._typedef_ctx(tp, name) + if getattr(tp, "origin", None) == "unknown_type": + self._struct_ctx(tp, tp.name, approxname=None) + elif isinstance(tp, model.NamedPointerType): + self._struct_ctx(tp.totype, tp.totype.name, approxname=tp.name, + named_ptr=tp) + + # ---------- + # function declarations + + def _generate_cpy_function_collecttype(self, tp, name): + self._do_collect_type(tp.as_raw_function()) + if tp.ellipsis and not self.target_is_python: + self._do_collect_type(tp) + + def _generate_cpy_function_decl(self, tp, name): + assert not self.target_is_python + assert isinstance(tp, model.FunctionPtrType) + if tp.ellipsis: + # cannot support vararg functions better than this: check for its + # exact type (including the fixed arguments), and build it as a + # constant function pointer (no CPython wrapper) + self._generate_cpy_constant_decl(tp, name) + return + prnt = self._prnt + numargs = len(tp.args) + if numargs == 0: + argname = 'noarg' + elif numargs == 1: + argname = 'arg0' + else: + argname = 'args' + # + # ------------------------------ + # the 'd' version of the function, only for addressof(lib, 'func') + arguments = [] + call_arguments = [] + context = 'argument of %s' % name + for i, type in enumerate(tp.args): + arguments.append(type.get_c_name(' x%d' % i, context)) + call_arguments.append('x%d' % i) + repr_arguments = ', '.join(arguments) + repr_arguments = repr_arguments or 'void' + if tp.abi: + abi = tp.abi + ' ' + else: + abi = '' + name_and_arguments = '%s_cffi_d_%s(%s)' % (abi, name, repr_arguments) + prnt('static %s' % (tp.result.get_c_name(name_and_arguments),)) + prnt('{') + call_arguments = ', '.join(call_arguments) + result_code = 'return ' + if isinstance(tp.result, model.VoidType): + result_code = '' + prnt(' %s%s(%s);' % (result_code, name, call_arguments)) + prnt('}') + # + prnt('#ifndef PYPY_VERSION') # ------------------------------ + # + prnt('static PyObject *') + prnt('_cffi_f_%s(PyObject *self, PyObject *%s)' % (name, argname)) + prnt('{') + # + context = 'argument of %s' % name + for i, type in enumerate(tp.args): + arg = type.get_c_name(' x%d' % i, context) + prnt(' %s;' % arg) + # + localvars = set() + freelines = set() + for type in tp.args: + self._extra_local_variables(type, localvars, freelines) + for decl in sorted(localvars): + prnt(' %s;' % (decl,)) + # + if not isinstance(tp.result, model.VoidType): + result_code = 'result = ' + context = 'result of %s' % name + result_decl = ' %s;' % tp.result.get_c_name(' result', context) + prnt(result_decl) + prnt(' PyObject *pyresult;') + else: + result_decl = None + result_code = '' + # + if len(tp.args) > 1: + rng = range(len(tp.args)) + for i in rng: + prnt(' PyObject *arg%d;' % i) + prnt() + prnt(' if (!PyArg_UnpackTuple(args, "%s", %d, %d, %s))' % ( + name, len(rng), len(rng), + ', '.join(['&arg%d' % i for i in rng]))) + prnt(' return NULL;') + prnt() + # + for i, type in enumerate(tp.args): + self._convert_funcarg_to_c(type, 'arg%d' % i, 'x%d' % i, + 'return NULL') + prnt() + # + prnt(' Py_BEGIN_ALLOW_THREADS') + prnt(' _cffi_restore_errno();') + call_arguments = ['x%d' % i for i in range(len(tp.args))] + call_arguments = ', '.join(call_arguments) + prnt(' { %s%s(%s); }' % (result_code, name, call_arguments)) + prnt(' _cffi_save_errno();') + prnt(' Py_END_ALLOW_THREADS') + prnt() + # + prnt(' (void)self; /* unused */') + if numargs == 0: + prnt(' (void)noarg; /* unused */') + if result_code: + prnt(' pyresult = %s;' % + self._convert_expr_from_c(tp.result, 'result', 'result type')) + for freeline in freelines: + prnt(' ' + freeline) + prnt(' return pyresult;') + else: + for freeline in freelines: + prnt(' ' + freeline) + prnt(' Py_INCREF(Py_None);') + prnt(' return Py_None;') + prnt('}') + # + prnt('#else') # ------------------------------ + # + # the PyPy version: need to replace struct/union arguments with + # pointers, and if the result is a struct/union, insert a first + # arg that is a pointer to the result. We also do that for + # complex args and return type. + def need_indirection(type): + return (isinstance(type, model.StructOrUnion) or + (isinstance(type, model.PrimitiveType) and + type.is_complex_type())) + difference = False + arguments = [] + call_arguments = [] + context = 'argument of %s' % name + for i, type in enumerate(tp.args): + indirection = '' + if need_indirection(type): + indirection = '*' + difference = True + arg = type.get_c_name(' %sx%d' % (indirection, i), context) + arguments.append(arg) + call_arguments.append('%sx%d' % (indirection, i)) + tp_result = tp.result + if need_indirection(tp_result): + context = 'result of %s' % name + arg = tp_result.get_c_name(' *result', context) + arguments.insert(0, arg) + tp_result = model.void_type + result_decl = None + result_code = '*result = ' + difference = True + if difference: + repr_arguments = ', '.join(arguments) + repr_arguments = repr_arguments or 'void' + name_and_arguments = '%s_cffi_f_%s(%s)' % (abi, name, + repr_arguments) + prnt('static %s' % (tp_result.get_c_name(name_and_arguments),)) + prnt('{') + if result_decl: + prnt(result_decl) + call_arguments = ', '.join(call_arguments) + prnt(' { %s%s(%s); }' % (result_code, name, call_arguments)) + if result_decl: + prnt(' return result;') + prnt('}') + else: + prnt('# define _cffi_f_%s _cffi_d_%s' % (name, name)) + # + prnt('#endif') # ------------------------------ + prnt() + + def _generate_cpy_function_ctx(self, tp, name): + if tp.ellipsis and not self.target_is_python: + self._generate_cpy_constant_ctx(tp, name) + return + type_index = self._typesdict[tp.as_raw_function()] + numargs = len(tp.args) + if self.target_is_python: + meth_kind = OP_DLOPEN_FUNC + elif numargs == 0: + meth_kind = OP_CPYTHON_BLTN_N # 'METH_NOARGS' + elif numargs == 1: + meth_kind = OP_CPYTHON_BLTN_O # 'METH_O' + else: + meth_kind = OP_CPYTHON_BLTN_V # 'METH_VARARGS' + self._lsts["global"].append( + GlobalExpr(name, '_cffi_f_%s' % name, + CffiOp(meth_kind, type_index), + size='_cffi_d_%s' % name)) + + # ---------- + # named structs or unions + + def _field_type(self, tp_struct, field_name, tp_field): + if isinstance(tp_field, model.ArrayType): + actual_length = tp_field.length + if actual_length == '...': + ptr_struct_name = tp_struct.get_c_name('*') + actual_length = '_cffi_array_len(((%s)0)->%s)' % ( + ptr_struct_name, field_name) + tp_item = self._field_type(tp_struct, '%s[0]' % field_name, + tp_field.item) + tp_field = model.ArrayType(tp_item, actual_length) + return tp_field + + def _struct_collecttype(self, tp): + self._do_collect_type(tp) + if self.target_is_python: + # also requires nested anon struct/unions in ABI mode, recursively + for fldtype in tp.anonymous_struct_fields(): + self._struct_collecttype(fldtype) + + def _struct_decl(self, tp, cname, approxname): + if tp.fldtypes is None: + return + prnt = self._prnt + checkfuncname = '_cffi_checkfld_%s' % (approxname,) + prnt('_CFFI_UNUSED_FN') + prnt('static void %s(%s *p)' % (checkfuncname, cname)) + prnt('{') + prnt(' /* only to generate compile-time warnings or errors */') + prnt(' (void)p;') + for fname, ftype, fbitsize, fqual in self._enum_fields(tp): + try: + if ftype.is_integer_type() or fbitsize >= 0: + # accept all integers, but complain on float or double + if fname != '': + prnt(" (void)((p->%s) | 0); /* check that '%s.%s' is " + "an integer */" % (fname, cname, fname)) + continue + # only accept exactly the type declared, except that '[]' + # is interpreted as a '*' and so will match any array length. + # (It would also match '*', but that's harder to detect...) + while (isinstance(ftype, model.ArrayType) + and (ftype.length is None or ftype.length == '...')): + ftype = ftype.item + fname = fname + '[0]' + prnt(' { %s = &p->%s; (void)tmp; }' % ( + ftype.get_c_name('*tmp', 'field %r'%fname, quals=fqual), + fname)) + except VerificationError as e: + prnt(' /* %s */' % str(e)) # cannot verify it, ignore + prnt('}') + prnt('struct _cffi_align_%s { char x; %s y; };' % (approxname, cname)) + prnt() + + def _struct_ctx(self, tp, cname, approxname, named_ptr=None): + type_index = self._typesdict[tp] + reason_for_not_expanding = None + flags = [] + if isinstance(tp, model.UnionType): + flags.append("_CFFI_F_UNION") + if tp.fldtypes is None: + flags.append("_CFFI_F_OPAQUE") + reason_for_not_expanding = "opaque" + if (tp not in self.ffi._parser._included_declarations and + (named_ptr is None or + named_ptr not in self.ffi._parser._included_declarations)): + if tp.fldtypes is None: + pass # opaque + elif tp.partial or any(tp.anonymous_struct_fields()): + pass # field layout obtained silently from the C compiler + else: + flags.append("_CFFI_F_CHECK_FIELDS") + if tp.packed: + if tp.packed > 1: + raise NotImplementedError( + "%r is declared with 'pack=%r'; only 0 or 1 are " + "supported in API mode (try to use \"...;\", which " + "does not require a 'pack' declaration)" % + (tp, tp.packed)) + flags.append("_CFFI_F_PACKED") + else: + flags.append("_CFFI_F_EXTERNAL") + reason_for_not_expanding = "external" + flags = '|'.join(flags) or '0' + c_fields = [] + if reason_for_not_expanding is None: + enumfields = list(self._enum_fields(tp)) + for fldname, fldtype, fbitsize, fqual in enumfields: + fldtype = self._field_type(tp, fldname, fldtype) + self._check_not_opaque(fldtype, + "field '%s.%s'" % (tp.name, fldname)) + # cname is None for _add_missing_struct_unions() only + op = OP_NOOP + if fbitsize >= 0: + op = OP_BITFIELD + size = '%d /* bits */' % fbitsize + elif cname is None or ( + isinstance(fldtype, model.ArrayType) and + fldtype.length is None): + size = '(size_t)-1' + else: + size = 'sizeof(((%s)0)->%s)' % ( + tp.get_c_name('*') if named_ptr is None + else named_ptr.name, + fldname) + if cname is None or fbitsize >= 0: + offset = '(size_t)-1' + elif named_ptr is not None: + offset = '((char *)&((%s)4096)->%s) - (char *)4096' % ( + named_ptr.name, fldname) + else: + offset = 'offsetof(%s, %s)' % (tp.get_c_name(''), fldname) + c_fields.append( + FieldExpr(fldname, offset, size, fbitsize, + CffiOp(op, self._typesdict[fldtype]))) + first_field_index = len(self._lsts["field"]) + self._lsts["field"].extend(c_fields) + # + if cname is None: # unknown name, for _add_missing_struct_unions + size = '(size_t)-2' + align = -2 + comment = "unnamed" + else: + if named_ptr is not None: + size = 'sizeof(*(%s)0)' % (named_ptr.name,) + align = '-1 /* unknown alignment */' + else: + size = 'sizeof(%s)' % (cname,) + align = 'offsetof(struct _cffi_align_%s, y)' % (approxname,) + comment = None + else: + size = '(size_t)-1' + align = -1 + first_field_index = -1 + comment = reason_for_not_expanding + self._lsts["struct_union"].append( + StructUnionExpr(tp.name, type_index, flags, size, align, comment, + first_field_index, c_fields)) + self._seen_struct_unions.add(tp) + + def _check_not_opaque(self, tp, location): + while isinstance(tp, model.ArrayType): + tp = tp.item + if isinstance(tp, model.StructOrUnion) and tp.fldtypes is None: + raise TypeError( + "%s is of an opaque type (not declared in cdef())" % location) + + def _add_missing_struct_unions(self): + # not very nice, but some struct declarations might be missing + # because they don't have any known C name. Check that they are + # not partial (we can't complete or verify them!) and emit them + # anonymously. + lst = list(self._struct_unions.items()) + lst.sort(key=lambda tp_order: tp_order[1]) + for tp, order in lst: + if tp not in self._seen_struct_unions: + if tp.partial: + raise NotImplementedError("internal inconsistency: %r is " + "partial but was not seen at " + "this point" % (tp,)) + if tp.name.startswith('$') and tp.name[1:].isdigit(): + approxname = tp.name[1:] + elif tp.name == '_IO_FILE' and tp.forcename == 'FILE': + approxname = 'FILE' + self._typedef_ctx(tp, 'FILE') + else: + raise NotImplementedError("internal inconsistency: %r" % + (tp,)) + self._struct_ctx(tp, None, approxname) + + def _generate_cpy_struct_collecttype(self, tp, name): + self._struct_collecttype(tp) + _generate_cpy_union_collecttype = _generate_cpy_struct_collecttype + + def _struct_names(self, tp): + cname = tp.get_c_name('') + if ' ' in cname: + return cname, cname.replace(' ', '_') + else: + return cname, '_' + cname + + def _generate_cpy_struct_decl(self, tp, name): + self._struct_decl(tp, *self._struct_names(tp)) + _generate_cpy_union_decl = _generate_cpy_struct_decl + + def _generate_cpy_struct_ctx(self, tp, name): + self._struct_ctx(tp, *self._struct_names(tp)) + _generate_cpy_union_ctx = _generate_cpy_struct_ctx + + # ---------- + # 'anonymous' declarations. These are produced for anonymous structs + # or unions; the 'name' is obtained by a typedef. + + def _generate_cpy_anonymous_collecttype(self, tp, name): + if isinstance(tp, model.EnumType): + self._generate_cpy_enum_collecttype(tp, name) + else: + self._struct_collecttype(tp) + + def _generate_cpy_anonymous_decl(self, tp, name): + if isinstance(tp, model.EnumType): + self._generate_cpy_enum_decl(tp) + else: + self._struct_decl(tp, name, 'typedef_' + name) + + def _generate_cpy_anonymous_ctx(self, tp, name): + if isinstance(tp, model.EnumType): + self._enum_ctx(tp, name) + else: + self._struct_ctx(tp, name, 'typedef_' + name) + + # ---------- + # constants, declared with "static const ..." + + def _generate_cpy_const(self, is_int, name, tp=None, category='const', + check_value=None): + if (category, name) in self._seen_constants: + raise VerificationError( + "duplicate declaration of %s '%s'" % (category, name)) + self._seen_constants.add((category, name)) + # + prnt = self._prnt + funcname = '_cffi_%s_%s' % (category, name) + if is_int: + prnt('static int %s(unsigned long long *o)' % funcname) + prnt('{') + prnt(' int n = (%s) <= 0;' % (name,)) + prnt(' *o = (unsigned long long)((%s) | 0);' + ' /* check that %s is an integer */' % (name, name)) + if check_value is not None: + if check_value > 0: + check_value = '%dU' % (check_value,) + prnt(' if (!_cffi_check_int(*o, n, %s))' % (check_value,)) + prnt(' n |= 2;') + prnt(' return n;') + prnt('}') + else: + assert check_value is None + prnt('static void %s(char *o)' % funcname) + prnt('{') + prnt(' *(%s)o = %s;' % (tp.get_c_name('*'), name)) + prnt('}') + prnt() + + def _generate_cpy_constant_collecttype(self, tp, name): + is_int = tp.is_integer_type() + if not is_int or self.target_is_python: + self._do_collect_type(tp) + + def _generate_cpy_constant_decl(self, tp, name): + is_int = tp.is_integer_type() + self._generate_cpy_const(is_int, name, tp) + + def _generate_cpy_constant_ctx(self, tp, name): + if not self.target_is_python and tp.is_integer_type(): + type_op = CffiOp(OP_CONSTANT_INT, -1) + else: + if self.target_is_python: + const_kind = OP_DLOPEN_CONST + else: + const_kind = OP_CONSTANT + type_index = self._typesdict[tp] + type_op = CffiOp(const_kind, type_index) + self._lsts["global"].append( + GlobalExpr(name, '_cffi_const_%s' % name, type_op)) + + # ---------- + # enums + + def _generate_cpy_enum_collecttype(self, tp, name): + self._do_collect_type(tp) + + def _generate_cpy_enum_decl(self, tp, name=None): + for enumerator in tp.enumerators: + self._generate_cpy_const(True, enumerator) + + def _enum_ctx(self, tp, cname): + type_index = self._typesdict[tp] + type_op = CffiOp(OP_ENUM, -1) + if self.target_is_python: + tp.check_not_partial() + for enumerator, enumvalue in zip(tp.enumerators, tp.enumvalues): + self._lsts["global"].append( + GlobalExpr(enumerator, '_cffi_const_%s' % enumerator, type_op, + check_value=enumvalue)) + # + if cname is not None and '$' not in cname and not self.target_is_python: + size = "sizeof(%s)" % cname + signed = "((%s)-1) <= 0" % cname + else: + basetp = tp.build_baseinttype(self.ffi, []) + size = self.ffi.sizeof(basetp) + signed = int(int(self.ffi.cast(basetp, -1)) < 0) + allenums = ",".join(tp.enumerators) + self._lsts["enum"].append( + EnumExpr(tp.name, type_index, size, signed, allenums)) + + def _generate_cpy_enum_ctx(self, tp, name): + self._enum_ctx(tp, tp._get_c_name()) + + # ---------- + # macros: for now only for integers + + def _generate_cpy_macro_collecttype(self, tp, name): + pass + + def _generate_cpy_macro_decl(self, tp, name): + if tp == '...': + check_value = None + else: + check_value = tp # an integer + self._generate_cpy_const(True, name, check_value=check_value) + + def _generate_cpy_macro_ctx(self, tp, name): + if tp == '...': + if self.target_is_python: + raise VerificationError( + "cannot use the syntax '...' in '#define %s ...' when " + "using the ABI mode" % (name,)) + check_value = None + else: + check_value = tp # an integer + type_op = CffiOp(OP_CONSTANT_INT, -1) + self._lsts["global"].append( + GlobalExpr(name, '_cffi_const_%s' % name, type_op, + check_value=check_value)) + + # ---------- + # global variables + + def _global_type(self, tp, global_name): + if isinstance(tp, model.ArrayType): + actual_length = tp.length + if actual_length == '...': + actual_length = '_cffi_array_len(%s)' % (global_name,) + tp_item = self._global_type(tp.item, '%s[0]' % global_name) + tp = model.ArrayType(tp_item, actual_length) + return tp + + def _generate_cpy_variable_collecttype(self, tp, name): + self._do_collect_type(self._global_type(tp, name)) + + def _generate_cpy_variable_decl(self, tp, name): + prnt = self._prnt + tp = self._global_type(tp, name) + if isinstance(tp, model.ArrayType) and tp.length is None: + tp = tp.item + ampersand = '' + else: + ampersand = '&' + # This code assumes that casts from "tp *" to "void *" is a + # no-op, i.e. a function that returns a "tp *" can be called + # as if it returned a "void *". This should be generally true + # on any modern machine. The only exception to that rule (on + # uncommon architectures, and as far as I can tell) might be + # if 'tp' were a function type, but that is not possible here. + # (If 'tp' is a function _pointer_ type, then casts from "fn_t + # **" to "void *" are again no-ops, as far as I can tell.) + decl = '*_cffi_var_%s(void)' % (name,) + prnt('static ' + tp.get_c_name(decl, quals=self._current_quals)) + prnt('{') + prnt(' return %s(%s);' % (ampersand, name)) + prnt('}') + prnt() + + def _generate_cpy_variable_ctx(self, tp, name): + tp = self._global_type(tp, name) + type_index = self._typesdict[tp] + if self.target_is_python: + op = OP_GLOBAL_VAR + else: + op = OP_GLOBAL_VAR_F + self._lsts["global"].append( + GlobalExpr(name, '_cffi_var_%s' % name, CffiOp(op, type_index))) + + # ---------- + # extern "Python" + + def _generate_cpy_extern_python_collecttype(self, tp, name): + assert isinstance(tp, model.FunctionPtrType) + self._do_collect_type(tp) + _generate_cpy_dllexport_python_collecttype = \ + _generate_cpy_extern_python_plus_c_collecttype = \ + _generate_cpy_extern_python_collecttype + + def _extern_python_decl(self, tp, name, tag_and_space): + prnt = self._prnt + if isinstance(tp.result, model.VoidType): + size_of_result = '0' + else: + context = 'result of %s' % name + size_of_result = '(int)sizeof(%s)' % ( + tp.result.get_c_name('', context),) + prnt('static struct _cffi_externpy_s _cffi_externpy__%s =' % name) + prnt(' { "%s.%s", %s, 0, 0 };' % ( + self.module_name, name, size_of_result)) + prnt() + # + arguments = [] + context = 'argument of %s' % name + for i, type in enumerate(tp.args): + arg = type.get_c_name(' a%d' % i, context) + arguments.append(arg) + # + repr_arguments = ', '.join(arguments) + repr_arguments = repr_arguments or 'void' + name_and_arguments = '%s(%s)' % (name, repr_arguments) + if tp.abi == "__stdcall": + name_and_arguments = '_cffi_stdcall ' + name_and_arguments + # + def may_need_128_bits(tp): + return (isinstance(tp, model.PrimitiveType) and + tp.name == 'long double') + # + size_of_a = max(len(tp.args)*8, 8) + if may_need_128_bits(tp.result): + size_of_a = max(size_of_a, 16) + if isinstance(tp.result, model.StructOrUnion): + size_of_a = 'sizeof(%s) > %d ? sizeof(%s) : %d' % ( + tp.result.get_c_name(''), size_of_a, + tp.result.get_c_name(''), size_of_a) + prnt('%s%s' % (tag_and_space, tp.result.get_c_name(name_and_arguments))) + prnt('{') + prnt(' char a[%s];' % size_of_a) + prnt(' char *p = a;') + for i, type in enumerate(tp.args): + arg = 'a%d' % i + if (isinstance(type, model.StructOrUnion) or + may_need_128_bits(type)): + arg = '&' + arg + type = model.PointerType(type) + prnt(' *(%s)(p + %d) = %s;' % (type.get_c_name('*'), i*8, arg)) + prnt(' _cffi_call_python(&_cffi_externpy__%s, p);' % name) + if not isinstance(tp.result, model.VoidType): + prnt(' return *(%s)p;' % (tp.result.get_c_name('*'),)) + prnt('}') + prnt() + self._num_externpy += 1 + + def _generate_cpy_extern_python_decl(self, tp, name): + self._extern_python_decl(tp, name, 'static ') + + def _generate_cpy_dllexport_python_decl(self, tp, name): + self._extern_python_decl(tp, name, 'CFFI_DLLEXPORT ') + + def _generate_cpy_extern_python_plus_c_decl(self, tp, name): + self._extern_python_decl(tp, name, '') + + def _generate_cpy_extern_python_ctx(self, tp, name): + if self.target_is_python: + raise VerificationError( + "cannot use 'extern \"Python\"' in the ABI mode") + if tp.ellipsis: + raise NotImplementedError("a vararg function is extern \"Python\"") + type_index = self._typesdict[tp] + type_op = CffiOp(OP_EXTERN_PYTHON, type_index) + self._lsts["global"].append( + GlobalExpr(name, '&_cffi_externpy__%s' % name, type_op, name)) + + _generate_cpy_dllexport_python_ctx = \ + _generate_cpy_extern_python_plus_c_ctx = \ + _generate_cpy_extern_python_ctx + + def _print_string_literal_in_array(self, s): + prnt = self._prnt + prnt('// # NB. this is not a string because of a size limit in MSVC') + if not isinstance(s, bytes): # unicode + s = s.encode('utf-8') # -> bytes + else: + s.decode('utf-8') # got bytes, check for valid utf-8 + try: + s.decode('ascii') + except UnicodeDecodeError: + s = b'# -*- encoding: utf8 -*-\n' + s + for line in s.splitlines(True): + comment = line + if type('//') is bytes: # python2 + line = map(ord, line) # make a list of integers + else: # python3 + # type(line) is bytes, which enumerates like a list of integers + comment = ascii(comment)[1:-1] + prnt(('// ' + comment).rstrip()) + printed_line = '' + for c in line: + if len(printed_line) >= 76: + prnt(printed_line) + printed_line = '' + printed_line += '%d,' % (c,) + prnt(printed_line) + + # ---------- + # emitting the opcodes for individual types + + def _emit_bytecode_VoidType(self, tp, index): + self.cffi_types[index] = CffiOp(OP_PRIMITIVE, PRIM_VOID) + + def _emit_bytecode_PrimitiveType(self, tp, index): + prim_index = PRIMITIVE_TO_INDEX[tp.name] + self.cffi_types[index] = CffiOp(OP_PRIMITIVE, prim_index) + + def _emit_bytecode_UnknownIntegerType(self, tp, index): + s = ('_cffi_prim_int(sizeof(%s), (\n' + ' ((%s)-1) | 0 /* check that %s is an integer type */\n' + ' ) <= 0)' % (tp.name, tp.name, tp.name)) + self.cffi_types[index] = CffiOp(OP_PRIMITIVE, s) + + def _emit_bytecode_UnknownFloatType(self, tp, index): + s = ('_cffi_prim_float(sizeof(%s) *\n' + ' (((%s)1) / 2) * 2 /* integer => 0, float => 1 */\n' + ' )' % (tp.name, tp.name)) + self.cffi_types[index] = CffiOp(OP_PRIMITIVE, s) + + def _emit_bytecode_RawFunctionType(self, tp, index): + self.cffi_types[index] = CffiOp(OP_FUNCTION, self._typesdict[tp.result]) + index += 1 + for tp1 in tp.args: + realindex = self._typesdict[tp1] + if index != realindex: + if isinstance(tp1, model.PrimitiveType): + self._emit_bytecode_PrimitiveType(tp1, index) + else: + self.cffi_types[index] = CffiOp(OP_NOOP, realindex) + index += 1 + flags = int(tp.ellipsis) + if tp.abi is not None: + if tp.abi == '__stdcall': + flags |= 2 + else: + raise NotImplementedError("abi=%r" % (tp.abi,)) + self.cffi_types[index] = CffiOp(OP_FUNCTION_END, flags) + + def _emit_bytecode_PointerType(self, tp, index): + self.cffi_types[index] = CffiOp(OP_POINTER, self._typesdict[tp.totype]) + + _emit_bytecode_ConstPointerType = _emit_bytecode_PointerType + _emit_bytecode_NamedPointerType = _emit_bytecode_PointerType + + def _emit_bytecode_FunctionPtrType(self, tp, index): + raw = tp.as_raw_function() + self.cffi_types[index] = CffiOp(OP_POINTER, self._typesdict[raw]) + + def _emit_bytecode_ArrayType(self, tp, index): + item_index = self._typesdict[tp.item] + if tp.length is None: + self.cffi_types[index] = CffiOp(OP_OPEN_ARRAY, item_index) + elif tp.length == '...': + raise VerificationError( + "type %s badly placed: the '...' array length can only be " + "used on global arrays or on fields of structures" % ( + str(tp).replace('/*...*/', '...'),)) + else: + assert self.cffi_types[index + 1] == 'LEN' + self.cffi_types[index] = CffiOp(OP_ARRAY, item_index) + self.cffi_types[index + 1] = CffiOp(None, str(tp.length)) + + def _emit_bytecode_StructType(self, tp, index): + struct_index = self._struct_unions[tp] + self.cffi_types[index] = CffiOp(OP_STRUCT_UNION, struct_index) + _emit_bytecode_UnionType = _emit_bytecode_StructType + + def _emit_bytecode_EnumType(self, tp, index): + enum_index = self._enums[tp] + self.cffi_types[index] = CffiOp(OP_ENUM, enum_index) + + +if sys.version_info >= (3,): + NativeIO = io.StringIO +else: + class NativeIO(io.BytesIO): + def write(self, s): + if isinstance(s, unicode): + s = s.encode('ascii') + super(NativeIO, self).write(s) + +def _is_file_like(maybefile): + # compare to xml.etree.ElementTree._get_writer + return hasattr(maybefile, 'write') + +def _make_c_or_py_source(ffi, module_name, preamble, target_file, verbose): + if verbose: + print("generating %s" % (target_file,)) + recompiler = Recompiler(ffi, module_name, + target_is_python=(preamble is None)) + recompiler.collect_type_table() + recompiler.collect_step_tables() + if _is_file_like(target_file): + recompiler.write_source_to_f(target_file, preamble) + return True + f = NativeIO() + recompiler.write_source_to_f(f, preamble) + output = f.getvalue() + try: + with open(target_file, 'r') as f1: + if f1.read(len(output) + 1) != output: + raise IOError + if verbose: + print("(already up-to-date)") + return False # already up-to-date + except IOError: + tmp_file = '%s.~%d' % (target_file, os.getpid()) + with open(tmp_file, 'w') as f1: + f1.write(output) + try: + os.rename(tmp_file, target_file) + except OSError: + os.unlink(target_file) + os.rename(tmp_file, target_file) + return True + +def make_c_source(ffi, module_name, preamble, target_c_file, verbose=False): + assert preamble is not None + return _make_c_or_py_source(ffi, module_name, preamble, target_c_file, + verbose) + +def make_py_source(ffi, module_name, target_py_file, verbose=False): + return _make_c_or_py_source(ffi, module_name, None, target_py_file, + verbose) + +def _modname_to_file(outputdir, modname, extension): + parts = modname.split('.') + try: + os.makedirs(os.path.join(outputdir, *parts[:-1])) + except OSError: + pass + parts[-1] += extension + return os.path.join(outputdir, *parts), parts + + +# Aaargh. Distutils is not tested at all for the purpose of compiling +# DLLs that are not extension modules. Here are some hacks to work +# around that, in the _patch_for_*() functions... + +def _patch_meth(patchlist, cls, name, new_meth): + old = getattr(cls, name) + patchlist.append((cls, name, old)) + setattr(cls, name, new_meth) + return old + +def _unpatch_meths(patchlist): + for cls, name, old_meth in reversed(patchlist): + setattr(cls, name, old_meth) + +def _patch_for_embedding(patchlist): + if sys.platform == 'win32': + # we must not remove the manifest when building for embedding! + # FUTURE: this module was removed in setuptools 74; this is likely dead code and should be removed, + # since the toolchain it supports (VS2005-2008) is also long dead. + from cffi._shimmed_dist_utils import MSVCCompiler + if MSVCCompiler is not None: + _patch_meth(patchlist, MSVCCompiler, '_remove_visual_c_ref', + lambda self, manifest_file: manifest_file) + + if sys.platform == 'darwin': + # we must not make a '-bundle', but a '-dynamiclib' instead + from cffi._shimmed_dist_utils import CCompiler + def my_link_shared_object(self, *args, **kwds): + if '-bundle' in self.linker_so: + self.linker_so = list(self.linker_so) + i = self.linker_so.index('-bundle') + self.linker_so[i] = '-dynamiclib' + return old_link_shared_object(self, *args, **kwds) + old_link_shared_object = _patch_meth(patchlist, CCompiler, + 'link_shared_object', + my_link_shared_object) + +def _patch_for_target(patchlist, target): + from cffi._shimmed_dist_utils import build_ext + # if 'target' is different from '*', we need to patch some internal + # method to just return this 'target' value, instead of having it + # built from module_name + if target.endswith('.*'): + target = target[:-2] + if sys.platform == 'win32': + target += '.dll' + elif sys.platform == 'darwin': + target += '.dylib' + else: + target += '.so' + _patch_meth(patchlist, build_ext, 'get_ext_filename', + lambda self, ext_name: target) + + +def recompile(ffi, module_name, preamble, tmpdir='.', call_c_compiler=True, + c_file=None, source_extension='.c', extradir=None, + compiler_verbose=1, target=None, debug=None, + uses_ffiplatform=True, **kwds): + if not isinstance(module_name, str): + module_name = module_name.encode('ascii') + if ffi._windows_unicode: + ffi._apply_windows_unicode(kwds) + if preamble is not None: + if call_c_compiler and _is_file_like(c_file): + raise TypeError("Writing to file-like objects is not supported " + "with call_c_compiler=True") + embedding = (ffi._embedding is not None) + if embedding: + ffi._apply_embedding_fix(kwds) + if c_file is None: + c_file, parts = _modname_to_file(tmpdir, module_name, + source_extension) + if extradir: + parts = [extradir] + parts + ext_c_file = os.path.join(*parts) + else: + ext_c_file = c_file + # + if target is None: + if embedding: + target = '%s.*' % module_name + else: + target = '*' + # + if uses_ffiplatform: + ext = ffiplatform.get_extension(ext_c_file, module_name, **kwds) + else: + ext = None + updated = make_c_source(ffi, module_name, preamble, c_file, + verbose=compiler_verbose) + if call_c_compiler: + patchlist = [] + cwd = os.getcwd() + try: + if embedding: + _patch_for_embedding(patchlist) + if target != '*': + _patch_for_target(patchlist, target) + if compiler_verbose: + if tmpdir == '.': + msg = 'the current directory is' + else: + msg = 'setting the current directory to' + print('%s %r' % (msg, os.path.abspath(tmpdir))) + os.chdir(tmpdir) + outputfilename = ffiplatform.compile('.', ext, + compiler_verbose, debug) + finally: + os.chdir(cwd) + _unpatch_meths(patchlist) + return outputfilename + else: + return ext, updated + else: + if c_file is None: + c_file, _ = _modname_to_file(tmpdir, module_name, '.py') + updated = make_py_source(ffi, module_name, c_file, + verbose=compiler_verbose) + if call_c_compiler: + return c_file + else: + return None, updated + diff --git a/venv/lib/python3.12/site-packages/cffi/setuptools_ext.py b/venv/lib/python3.12/site-packages/cffi/setuptools_ext.py new file mode 100644 index 00000000..681b49d7 --- /dev/null +++ b/venv/lib/python3.12/site-packages/cffi/setuptools_ext.py @@ -0,0 +1,216 @@ +import os +import sys + +try: + basestring +except NameError: + # Python 3.x + basestring = str + +def error(msg): + from cffi._shimmed_dist_utils import DistutilsSetupError + raise DistutilsSetupError(msg) + + +def execfile(filename, glob): + # We use execfile() (here rewritten for Python 3) instead of + # __import__() to load the build script. The problem with + # a normal import is that in some packages, the intermediate + # __init__.py files may already try to import the file that + # we are generating. + with open(filename) as f: + src = f.read() + src += '\n' # Python 2.6 compatibility + code = compile(src, filename, 'exec') + exec(code, glob, glob) + + +def add_cffi_module(dist, mod_spec): + from cffi.api import FFI + + if not isinstance(mod_spec, basestring): + error("argument to 'cffi_modules=...' must be a str or a list of str," + " not %r" % (type(mod_spec).__name__,)) + mod_spec = str(mod_spec) + try: + build_file_name, ffi_var_name = mod_spec.split(':') + except ValueError: + error("%r must be of the form 'path/build.py:ffi_variable'" % + (mod_spec,)) + if not os.path.exists(build_file_name): + ext = '' + rewritten = build_file_name.replace('.', '/') + '.py' + if os.path.exists(rewritten): + ext = ' (rewrite cffi_modules to [%r])' % ( + rewritten + ':' + ffi_var_name,) + error("%r does not name an existing file%s" % (build_file_name, ext)) + + mod_vars = {'__name__': '__cffi__', '__file__': build_file_name} + execfile(build_file_name, mod_vars) + + try: + ffi = mod_vars[ffi_var_name] + except KeyError: + error("%r: object %r not found in module" % (mod_spec, + ffi_var_name)) + if not isinstance(ffi, FFI): + ffi = ffi() # maybe it's a function instead of directly an ffi + if not isinstance(ffi, FFI): + error("%r is not an FFI instance (got %r)" % (mod_spec, + type(ffi).__name__)) + if not hasattr(ffi, '_assigned_source'): + error("%r: the set_source() method was not called" % (mod_spec,)) + module_name, source, source_extension, kwds = ffi._assigned_source + if ffi._windows_unicode: + kwds = kwds.copy() + ffi._apply_windows_unicode(kwds) + + if source is None: + _add_py_module(dist, ffi, module_name) + else: + _add_c_module(dist, ffi, module_name, source, source_extension, kwds) + +def _set_py_limited_api(Extension, kwds): + """ + Add py_limited_api to kwds if setuptools >= 26 is in use. + Do not alter the setting if it already exists. + Setuptools takes care of ignoring the flag on Python 2 and PyPy. + + CPython itself should ignore the flag in a debugging version + (by not listing .abi3.so in the extensions it supports), but + it doesn't so far, creating troubles. That's why we check + for "not hasattr(sys, 'gettotalrefcount')" (the 2.7 compatible equivalent + of 'd' not in sys.abiflags). (http://bugs.python.org/issue28401) + + On Windows, with CPython <= 3.4, it's better not to use py_limited_api + because virtualenv *still* doesn't copy PYTHON3.DLL on these versions. + Recently (2020) we started shipping only >= 3.5 wheels, though. So + we'll give it another try and set py_limited_api on Windows >= 3.5. + """ + from cffi import recompiler + + if ('py_limited_api' not in kwds and not hasattr(sys, 'gettotalrefcount') + and recompiler.USE_LIMITED_API): + import setuptools + try: + setuptools_major_version = int(setuptools.__version__.partition('.')[0]) + if setuptools_major_version >= 26: + kwds['py_limited_api'] = True + except ValueError: # certain development versions of setuptools + # If we don't know the version number of setuptools, we + # try to set 'py_limited_api' anyway. At worst, we get a + # warning. + kwds['py_limited_api'] = True + return kwds + +def _add_c_module(dist, ffi, module_name, source, source_extension, kwds): + # We are a setuptools extension. Need this build_ext for py_limited_api. + from setuptools.command.build_ext import build_ext + from cffi._shimmed_dist_utils import Extension, log, mkpath + from cffi import recompiler + + allsources = ['$PLACEHOLDER'] + allsources.extend(kwds.pop('sources', [])) + kwds = _set_py_limited_api(Extension, kwds) + ext = Extension(name=module_name, sources=allsources, **kwds) + + def make_mod(tmpdir, pre_run=None): + c_file = os.path.join(tmpdir, module_name + source_extension) + log.info("generating cffi module %r" % c_file) + mkpath(tmpdir) + # a setuptools-only, API-only hook: called with the "ext" and "ffi" + # arguments just before we turn the ffi into C code. To use it, + # subclass the 'distutils.command.build_ext.build_ext' class and + # add a method 'def pre_run(self, ext, ffi)'. + if pre_run is not None: + pre_run(ext, ffi) + updated = recompiler.make_c_source(ffi, module_name, source, c_file) + if not updated: + log.info("already up-to-date") + return c_file + + if dist.ext_modules is None: + dist.ext_modules = [] + dist.ext_modules.append(ext) + + base_class = dist.cmdclass.get('build_ext', build_ext) + class build_ext_make_mod(base_class): + def run(self): + if ext.sources[0] == '$PLACEHOLDER': + pre_run = getattr(self, 'pre_run', None) + ext.sources[0] = make_mod(self.build_temp, pre_run) + base_class.run(self) + dist.cmdclass['build_ext'] = build_ext_make_mod + # NB. multiple runs here will create multiple 'build_ext_make_mod' + # classes. Even in this case the 'build_ext' command should be + # run once; but just in case, the logic above does nothing if + # called again. + + +def _add_py_module(dist, ffi, module_name): + from setuptools.command.build_py import build_py + from setuptools.command.build_ext import build_ext + from cffi._shimmed_dist_utils import log, mkpath + from cffi import recompiler + + def generate_mod(py_file): + log.info("generating cffi module %r" % py_file) + mkpath(os.path.dirname(py_file)) + updated = recompiler.make_py_source(ffi, module_name, py_file) + if not updated: + log.info("already up-to-date") + + base_class = dist.cmdclass.get('build_py', build_py) + class build_py_make_mod(base_class): + def run(self): + base_class.run(self) + module_path = module_name.split('.') + module_path[-1] += '.py' + generate_mod(os.path.join(self.build_lib, *module_path)) + def get_source_files(self): + # This is called from 'setup.py sdist' only. Exclude + # the generate .py module in this case. + saved_py_modules = self.py_modules + try: + if saved_py_modules: + self.py_modules = [m for m in saved_py_modules + if m != module_name] + return base_class.get_source_files(self) + finally: + self.py_modules = saved_py_modules + dist.cmdclass['build_py'] = build_py_make_mod + + # distutils and setuptools have no notion I could find of a + # generated python module. If we don't add module_name to + # dist.py_modules, then things mostly work but there are some + # combination of options (--root and --record) that will miss + # the module. So we add it here, which gives a few apparently + # harmless warnings about not finding the file outside the + # build directory. + # Then we need to hack more in get_source_files(); see above. + if dist.py_modules is None: + dist.py_modules = [] + dist.py_modules.append(module_name) + + # the following is only for "build_ext -i" + base_class_2 = dist.cmdclass.get('build_ext', build_ext) + class build_ext_make_mod(base_class_2): + def run(self): + base_class_2.run(self) + if self.inplace: + # from get_ext_fullpath() in distutils/command/build_ext.py + module_path = module_name.split('.') + package = '.'.join(module_path[:-1]) + build_py = self.get_finalized_command('build_py') + package_dir = build_py.get_package_dir(package) + file_name = module_path[-1] + '.py' + generate_mod(os.path.join(package_dir, file_name)) + dist.cmdclass['build_ext'] = build_ext_make_mod + +def cffi_modules(dist, attr, value): + assert attr == 'cffi_modules' + if isinstance(value, basestring): + value = [value] + + for cffi_module in value: + add_cffi_module(dist, cffi_module) diff --git a/venv/lib/python3.12/site-packages/cffi/vengine_cpy.py b/venv/lib/python3.12/site-packages/cffi/vengine_cpy.py new file mode 100644 index 00000000..eb0b6f70 --- /dev/null +++ b/venv/lib/python3.12/site-packages/cffi/vengine_cpy.py @@ -0,0 +1,1084 @@ +# +# DEPRECATED: implementation for ffi.verify() +# +import sys +from . import model +from .error import VerificationError +from . import _imp_emulation as imp + + +class VCPythonEngine(object): + _class_key = 'x' + _gen_python_module = True + + def __init__(self, verifier): + self.verifier = verifier + self.ffi = verifier.ffi + self._struct_pending_verification = {} + self._types_of_builtin_functions = {} + + def patch_extension_kwds(self, kwds): + pass + + def find_module(self, module_name, path, so_suffixes): + try: + f, filename, descr = imp.find_module(module_name, path) + except ImportError: + return None + if f is not None: + f.close() + # Note that after a setuptools installation, there are both .py + # and .so files with the same basename. The code here relies on + # imp.find_module() locating the .so in priority. + if descr[0] not in so_suffixes: + return None + return filename + + def collect_types(self): + self._typesdict = {} + self._generate("collecttype") + + def _prnt(self, what=''): + self._f.write(what + '\n') + + def _gettypenum(self, type): + # a KeyError here is a bug. please report it! :-) + return self._typesdict[type] + + def _do_collect_type(self, tp): + if ((not isinstance(tp, model.PrimitiveType) + or tp.name == 'long double') + and tp not in self._typesdict): + num = len(self._typesdict) + self._typesdict[tp] = num + + def write_source_to_f(self): + self.collect_types() + # + # The new module will have a _cffi_setup() function that receives + # objects from the ffi world, and that calls some setup code in + # the module. This setup code is split in several independent + # functions, e.g. one per constant. The functions are "chained" + # by ending in a tail call to each other. + # + # This is further split in two chained lists, depending on if we + # can do it at import-time or if we must wait for _cffi_setup() to + # provide us with the objects. This is needed because we + # need the values of the enum constants in order to build the + # that we may have to pass to _cffi_setup(). + # + # The following two 'chained_list_constants' items contains + # the head of these two chained lists, as a string that gives the + # call to do, if any. + self._chained_list_constants = ['((void)lib,0)', '((void)lib,0)'] + # + prnt = self._prnt + # first paste some standard set of lines that are mostly '#define' + prnt(cffimod_header) + prnt() + # then paste the C source given by the user, verbatim. + prnt(self.verifier.preamble) + prnt() + # + # call generate_cpy_xxx_decl(), for every xxx found from + # ffi._parser._declarations. This generates all the functions. + self._generate("decl") + # + # implement the function _cffi_setup_custom() as calling the + # head of the chained list. + self._generate_setup_custom() + prnt() + # + # produce the method table, including the entries for the + # generated Python->C function wrappers, which are done + # by generate_cpy_function_method(). + prnt('static PyMethodDef _cffi_methods[] = {') + self._generate("method") + prnt(' {"_cffi_setup", _cffi_setup, METH_VARARGS, NULL},') + prnt(' {NULL, NULL, 0, NULL} /* Sentinel */') + prnt('};') + prnt() + # + # standard init. + modname = self.verifier.get_module_name() + constants = self._chained_list_constants[False] + prnt('#if PY_MAJOR_VERSION >= 3') + prnt() + prnt('static struct PyModuleDef _cffi_module_def = {') + prnt(' PyModuleDef_HEAD_INIT,') + prnt(' "%s",' % modname) + prnt(' NULL,') + prnt(' -1,') + prnt(' _cffi_methods,') + prnt(' NULL, NULL, NULL, NULL') + prnt('};') + prnt() + prnt('PyMODINIT_FUNC') + prnt('PyInit_%s(void)' % modname) + prnt('{') + prnt(' PyObject *lib;') + prnt(' lib = PyModule_Create(&_cffi_module_def);') + prnt(' if (lib == NULL)') + prnt(' return NULL;') + prnt(' if (%s < 0 || _cffi_init() < 0) {' % (constants,)) + prnt(' Py_DECREF(lib);') + prnt(' return NULL;') + prnt(' }') + prnt(' return lib;') + prnt('}') + prnt() + prnt('#else') + prnt() + prnt('PyMODINIT_FUNC') + prnt('init%s(void)' % modname) + prnt('{') + prnt(' PyObject *lib;') + prnt(' lib = Py_InitModule("%s", _cffi_methods);' % modname) + prnt(' if (lib == NULL)') + prnt(' return;') + prnt(' if (%s < 0 || _cffi_init() < 0)' % (constants,)) + prnt(' return;') + prnt(' return;') + prnt('}') + prnt() + prnt('#endif') + + def load_library(self, flags=None): + # XXX review all usages of 'self' here! + # import it as a new extension module + imp.acquire_lock() + try: + if hasattr(sys, "getdlopenflags"): + previous_flags = sys.getdlopenflags() + try: + if hasattr(sys, "setdlopenflags") and flags is not None: + sys.setdlopenflags(flags) + module = imp.load_dynamic(self.verifier.get_module_name(), + self.verifier.modulefilename) + except ImportError as e: + error = "importing %r: %s" % (self.verifier.modulefilename, e) + raise VerificationError(error) + finally: + if hasattr(sys, "setdlopenflags"): + sys.setdlopenflags(previous_flags) + finally: + imp.release_lock() + # + # call loading_cpy_struct() to get the struct layout inferred by + # the C compiler + self._load(module, 'loading') + # + # the C code will need the objects. Collect them in + # order in a list. + revmapping = dict([(value, key) + for (key, value) in self._typesdict.items()]) + lst = [revmapping[i] for i in range(len(revmapping))] + lst = list(map(self.ffi._get_cached_btype, lst)) + # + # build the FFILibrary class and instance and call _cffi_setup(). + # this will set up some fields like '_cffi_types', and only then + # it will invoke the chained list of functions that will really + # build (notably) the constant objects, as if they are + # pointers, and store them as attributes on the 'library' object. + class FFILibrary(object): + _cffi_python_module = module + _cffi_ffi = self.ffi + _cffi_dir = [] + def __dir__(self): + return FFILibrary._cffi_dir + list(self.__dict__) + library = FFILibrary() + if module._cffi_setup(lst, VerificationError, library): + import warnings + warnings.warn("reimporting %r might overwrite older definitions" + % (self.verifier.get_module_name())) + # + # finally, call the loaded_cpy_xxx() functions. This will perform + # the final adjustments, like copying the Python->C wrapper + # functions from the module to the 'library' object, and setting + # up the FFILibrary class with properties for the global C variables. + self._load(module, 'loaded', library=library) + module._cffi_original_ffi = self.ffi + module._cffi_types_of_builtin_funcs = self._types_of_builtin_functions + return library + + def _get_declarations(self): + lst = [(key, tp) for (key, (tp, qual)) in + self.ffi._parser._declarations.items()] + lst.sort() + return lst + + def _generate(self, step_name): + for name, tp in self._get_declarations(): + kind, realname = name.split(' ', 1) + try: + method = getattr(self, '_generate_cpy_%s_%s' % (kind, + step_name)) + except AttributeError: + raise VerificationError( + "not implemented in verify(): %r" % name) + try: + method(tp, realname) + except Exception as e: + model.attach_exception_info(e, name) + raise + + def _load(self, module, step_name, **kwds): + for name, tp in self._get_declarations(): + kind, realname = name.split(' ', 1) + method = getattr(self, '_%s_cpy_%s' % (step_name, kind)) + try: + method(tp, realname, module, **kwds) + except Exception as e: + model.attach_exception_info(e, name) + raise + + def _generate_nothing(self, tp, name): + pass + + def _loaded_noop(self, tp, name, module, **kwds): + pass + + # ---------- + + def _convert_funcarg_to_c(self, tp, fromvar, tovar, errcode): + extraarg = '' + if isinstance(tp, model.PrimitiveType): + if tp.is_integer_type() and tp.name != '_Bool': + converter = '_cffi_to_c_int' + extraarg = ', %s' % tp.name + elif tp.is_complex_type(): + raise VerificationError( + "not implemented in verify(): complex types") + else: + converter = '(%s)_cffi_to_c_%s' % (tp.get_c_name(''), + tp.name.replace(' ', '_')) + errvalue = '-1' + # + elif isinstance(tp, model.PointerType): + self._convert_funcarg_to_c_ptr_or_array(tp, fromvar, + tovar, errcode) + return + # + elif isinstance(tp, (model.StructOrUnion, model.EnumType)): + # a struct (not a struct pointer) as a function argument + self._prnt(' if (_cffi_to_c((char *)&%s, _cffi_type(%d), %s) < 0)' + % (tovar, self._gettypenum(tp), fromvar)) + self._prnt(' %s;' % errcode) + return + # + elif isinstance(tp, model.FunctionPtrType): + converter = '(%s)_cffi_to_c_pointer' % tp.get_c_name('') + extraarg = ', _cffi_type(%d)' % self._gettypenum(tp) + errvalue = 'NULL' + # + else: + raise NotImplementedError(tp) + # + self._prnt(' %s = %s(%s%s);' % (tovar, converter, fromvar, extraarg)) + self._prnt(' if (%s == (%s)%s && PyErr_Occurred())' % ( + tovar, tp.get_c_name(''), errvalue)) + self._prnt(' %s;' % errcode) + + def _extra_local_variables(self, tp, localvars, freelines): + if isinstance(tp, model.PointerType): + localvars.add('Py_ssize_t datasize') + localvars.add('struct _cffi_freeme_s *large_args_free = NULL') + freelines.add('if (large_args_free != NULL)' + ' _cffi_free_array_arguments(large_args_free);') + + def _convert_funcarg_to_c_ptr_or_array(self, tp, fromvar, tovar, errcode): + self._prnt(' datasize = _cffi_prepare_pointer_call_argument(') + self._prnt(' _cffi_type(%d), %s, (char **)&%s);' % ( + self._gettypenum(tp), fromvar, tovar)) + self._prnt(' if (datasize != 0) {') + self._prnt(' %s = ((size_t)datasize) <= 640 ? ' + 'alloca((size_t)datasize) : NULL;' % (tovar,)) + self._prnt(' if (_cffi_convert_array_argument(_cffi_type(%d), %s, ' + '(char **)&%s,' % (self._gettypenum(tp), fromvar, tovar)) + self._prnt(' datasize, &large_args_free) < 0)') + self._prnt(' %s;' % errcode) + self._prnt(' }') + + def _convert_expr_from_c(self, tp, var, context): + if isinstance(tp, model.PrimitiveType): + if tp.is_integer_type() and tp.name != '_Bool': + return '_cffi_from_c_int(%s, %s)' % (var, tp.name) + elif tp.name != 'long double': + return '_cffi_from_c_%s(%s)' % (tp.name.replace(' ', '_'), var) + else: + return '_cffi_from_c_deref((char *)&%s, _cffi_type(%d))' % ( + var, self._gettypenum(tp)) + elif isinstance(tp, (model.PointerType, model.FunctionPtrType)): + return '_cffi_from_c_pointer((char *)%s, _cffi_type(%d))' % ( + var, self._gettypenum(tp)) + elif isinstance(tp, model.ArrayType): + return '_cffi_from_c_pointer((char *)%s, _cffi_type(%d))' % ( + var, self._gettypenum(model.PointerType(tp.item))) + elif isinstance(tp, model.StructOrUnion): + if tp.fldnames is None: + raise TypeError("'%s' is used as %s, but is opaque" % ( + tp._get_c_name(), context)) + return '_cffi_from_c_struct((char *)&%s, _cffi_type(%d))' % ( + var, self._gettypenum(tp)) + elif isinstance(tp, model.EnumType): + return '_cffi_from_c_deref((char *)&%s, _cffi_type(%d))' % ( + var, self._gettypenum(tp)) + else: + raise NotImplementedError(tp) + + # ---------- + # typedefs: generates no code so far + + _generate_cpy_typedef_collecttype = _generate_nothing + _generate_cpy_typedef_decl = _generate_nothing + _generate_cpy_typedef_method = _generate_nothing + _loading_cpy_typedef = _loaded_noop + _loaded_cpy_typedef = _loaded_noop + + # ---------- + # function declarations + + def _generate_cpy_function_collecttype(self, tp, name): + assert isinstance(tp, model.FunctionPtrType) + if tp.ellipsis: + self._do_collect_type(tp) + else: + # don't call _do_collect_type(tp) in this common case, + # otherwise test_autofilled_struct_as_argument fails + for type in tp.args: + self._do_collect_type(type) + self._do_collect_type(tp.result) + + def _generate_cpy_function_decl(self, tp, name): + assert isinstance(tp, model.FunctionPtrType) + if tp.ellipsis: + # cannot support vararg functions better than this: check for its + # exact type (including the fixed arguments), and build it as a + # constant function pointer (no CPython wrapper) + self._generate_cpy_const(False, name, tp) + return + prnt = self._prnt + numargs = len(tp.args) + if numargs == 0: + argname = 'noarg' + elif numargs == 1: + argname = 'arg0' + else: + argname = 'args' + prnt('static PyObject *') + prnt('_cffi_f_%s(PyObject *self, PyObject *%s)' % (name, argname)) + prnt('{') + # + context = 'argument of %s' % name + for i, type in enumerate(tp.args): + prnt(' %s;' % type.get_c_name(' x%d' % i, context)) + # + localvars = set() + freelines = set() + for type in tp.args: + self._extra_local_variables(type, localvars, freelines) + for decl in sorted(localvars): + prnt(' %s;' % (decl,)) + # + if not isinstance(tp.result, model.VoidType): + result_code = 'result = ' + context = 'result of %s' % name + prnt(' %s;' % tp.result.get_c_name(' result', context)) + prnt(' PyObject *pyresult;') + else: + result_code = '' + # + if len(tp.args) > 1: + rng = range(len(tp.args)) + for i in rng: + prnt(' PyObject *arg%d;' % i) + prnt() + prnt(' if (!PyArg_ParseTuple(args, "%s:%s", %s))' % ( + 'O' * numargs, name, ', '.join(['&arg%d' % i for i in rng]))) + prnt(' return NULL;') + prnt() + # + for i, type in enumerate(tp.args): + self._convert_funcarg_to_c(type, 'arg%d' % i, 'x%d' % i, + 'return NULL') + prnt() + # + prnt(' Py_BEGIN_ALLOW_THREADS') + prnt(' _cffi_restore_errno();') + prnt(' { %s%s(%s); }' % ( + result_code, name, + ', '.join(['x%d' % i for i in range(len(tp.args))]))) + prnt(' _cffi_save_errno();') + prnt(' Py_END_ALLOW_THREADS') + prnt() + # + prnt(' (void)self; /* unused */') + if numargs == 0: + prnt(' (void)noarg; /* unused */') + if result_code: + prnt(' pyresult = %s;' % + self._convert_expr_from_c(tp.result, 'result', 'result type')) + for freeline in freelines: + prnt(' ' + freeline) + prnt(' return pyresult;') + else: + for freeline in freelines: + prnt(' ' + freeline) + prnt(' Py_INCREF(Py_None);') + prnt(' return Py_None;') + prnt('}') + prnt() + + def _generate_cpy_function_method(self, tp, name): + if tp.ellipsis: + return + numargs = len(tp.args) + if numargs == 0: + meth = 'METH_NOARGS' + elif numargs == 1: + meth = 'METH_O' + else: + meth = 'METH_VARARGS' + self._prnt(' {"%s", _cffi_f_%s, %s, NULL},' % (name, name, meth)) + + _loading_cpy_function = _loaded_noop + + def _loaded_cpy_function(self, tp, name, module, library): + if tp.ellipsis: + return + func = getattr(module, name) + setattr(library, name, func) + self._types_of_builtin_functions[func] = tp + + # ---------- + # named structs + + _generate_cpy_struct_collecttype = _generate_nothing + def _generate_cpy_struct_decl(self, tp, name): + assert name == tp.name + self._generate_struct_or_union_decl(tp, 'struct', name) + def _generate_cpy_struct_method(self, tp, name): + self._generate_struct_or_union_method(tp, 'struct', name) + def _loading_cpy_struct(self, tp, name, module): + self._loading_struct_or_union(tp, 'struct', name, module) + def _loaded_cpy_struct(self, tp, name, module, **kwds): + self._loaded_struct_or_union(tp) + + _generate_cpy_union_collecttype = _generate_nothing + def _generate_cpy_union_decl(self, tp, name): + assert name == tp.name + self._generate_struct_or_union_decl(tp, 'union', name) + def _generate_cpy_union_method(self, tp, name): + self._generate_struct_or_union_method(tp, 'union', name) + def _loading_cpy_union(self, tp, name, module): + self._loading_struct_or_union(tp, 'union', name, module) + def _loaded_cpy_union(self, tp, name, module, **kwds): + self._loaded_struct_or_union(tp) + + def _generate_struct_or_union_decl(self, tp, prefix, name): + if tp.fldnames is None: + return # nothing to do with opaque structs + checkfuncname = '_cffi_check_%s_%s' % (prefix, name) + layoutfuncname = '_cffi_layout_%s_%s' % (prefix, name) + cname = ('%s %s' % (prefix, name)).strip() + # + prnt = self._prnt + prnt('static void %s(%s *p)' % (checkfuncname, cname)) + prnt('{') + prnt(' /* only to generate compile-time warnings or errors */') + prnt(' (void)p;') + for fname, ftype, fbitsize, fqual in tp.enumfields(): + if (isinstance(ftype, model.PrimitiveType) + and ftype.is_integer_type()) or fbitsize >= 0: + # accept all integers, but complain on float or double + prnt(' (void)((p->%s) << 1);' % fname) + else: + # only accept exactly the type declared. + try: + prnt(' { %s = &p->%s; (void)tmp; }' % ( + ftype.get_c_name('*tmp', 'field %r'%fname, quals=fqual), + fname)) + except VerificationError as e: + prnt(' /* %s */' % str(e)) # cannot verify it, ignore + prnt('}') + prnt('static PyObject *') + prnt('%s(PyObject *self, PyObject *noarg)' % (layoutfuncname,)) + prnt('{') + prnt(' struct _cffi_aligncheck { char x; %s y; };' % cname) + prnt(' static Py_ssize_t nums[] = {') + prnt(' sizeof(%s),' % cname) + prnt(' offsetof(struct _cffi_aligncheck, y),') + for fname, ftype, fbitsize, fqual in tp.enumfields(): + if fbitsize >= 0: + continue # xxx ignore fbitsize for now + prnt(' offsetof(%s, %s),' % (cname, fname)) + if isinstance(ftype, model.ArrayType) and ftype.length is None: + prnt(' 0, /* %s */' % ftype._get_c_name()) + else: + prnt(' sizeof(((%s *)0)->%s),' % (cname, fname)) + prnt(' -1') + prnt(' };') + prnt(' (void)self; /* unused */') + prnt(' (void)noarg; /* unused */') + prnt(' return _cffi_get_struct_layout(nums);') + prnt(' /* the next line is not executed, but compiled */') + prnt(' %s(0);' % (checkfuncname,)) + prnt('}') + prnt() + + def _generate_struct_or_union_method(self, tp, prefix, name): + if tp.fldnames is None: + return # nothing to do with opaque structs + layoutfuncname = '_cffi_layout_%s_%s' % (prefix, name) + self._prnt(' {"%s", %s, METH_NOARGS, NULL},' % (layoutfuncname, + layoutfuncname)) + + def _loading_struct_or_union(self, tp, prefix, name, module): + if tp.fldnames is None: + return # nothing to do with opaque structs + layoutfuncname = '_cffi_layout_%s_%s' % (prefix, name) + # + function = getattr(module, layoutfuncname) + layout = function() + if isinstance(tp, model.StructOrUnion) and tp.partial: + # use the function()'s sizes and offsets to guide the + # layout of the struct + totalsize = layout[0] + totalalignment = layout[1] + fieldofs = layout[2::2] + fieldsize = layout[3::2] + tp.force_flatten() + assert len(fieldofs) == len(fieldsize) == len(tp.fldnames) + tp.fixedlayout = fieldofs, fieldsize, totalsize, totalalignment + else: + cname = ('%s %s' % (prefix, name)).strip() + self._struct_pending_verification[tp] = layout, cname + + def _loaded_struct_or_union(self, tp): + if tp.fldnames is None: + return # nothing to do with opaque structs + self.ffi._get_cached_btype(tp) # force 'fixedlayout' to be considered + + if tp in self._struct_pending_verification: + # check that the layout sizes and offsets match the real ones + def check(realvalue, expectedvalue, msg): + if realvalue != expectedvalue: + raise VerificationError( + "%s (we have %d, but C compiler says %d)" + % (msg, expectedvalue, realvalue)) + ffi = self.ffi + BStruct = ffi._get_cached_btype(tp) + layout, cname = self._struct_pending_verification.pop(tp) + check(layout[0], ffi.sizeof(BStruct), "wrong total size") + check(layout[1], ffi.alignof(BStruct), "wrong total alignment") + i = 2 + for fname, ftype, fbitsize, fqual in tp.enumfields(): + if fbitsize >= 0: + continue # xxx ignore fbitsize for now + check(layout[i], ffi.offsetof(BStruct, fname), + "wrong offset for field %r" % (fname,)) + if layout[i+1] != 0: + BField = ffi._get_cached_btype(ftype) + check(layout[i+1], ffi.sizeof(BField), + "wrong size for field %r" % (fname,)) + i += 2 + assert i == len(layout) + + # ---------- + # 'anonymous' declarations. These are produced for anonymous structs + # or unions; the 'name' is obtained by a typedef. + + _generate_cpy_anonymous_collecttype = _generate_nothing + + def _generate_cpy_anonymous_decl(self, tp, name): + if isinstance(tp, model.EnumType): + self._generate_cpy_enum_decl(tp, name, '') + else: + self._generate_struct_or_union_decl(tp, '', name) + + def _generate_cpy_anonymous_method(self, tp, name): + if not isinstance(tp, model.EnumType): + self._generate_struct_or_union_method(tp, '', name) + + def _loading_cpy_anonymous(self, tp, name, module): + if isinstance(tp, model.EnumType): + self._loading_cpy_enum(tp, name, module) + else: + self._loading_struct_or_union(tp, '', name, module) + + def _loaded_cpy_anonymous(self, tp, name, module, **kwds): + if isinstance(tp, model.EnumType): + self._loaded_cpy_enum(tp, name, module, **kwds) + else: + self._loaded_struct_or_union(tp) + + # ---------- + # constants, likely declared with '#define' + + def _generate_cpy_const(self, is_int, name, tp=None, category='const', + vartp=None, delayed=True, size_too=False, + check_value=None): + prnt = self._prnt + funcname = '_cffi_%s_%s' % (category, name) + prnt('static int %s(PyObject *lib)' % funcname) + prnt('{') + prnt(' PyObject *o;') + prnt(' int res;') + if not is_int: + prnt(' %s;' % (vartp or tp).get_c_name(' i', name)) + else: + assert category == 'const' + # + if check_value is not None: + self._check_int_constant_value(name, check_value) + # + if not is_int: + if category == 'var': + realexpr = '&' + name + else: + realexpr = name + prnt(' i = (%s);' % (realexpr,)) + prnt(' o = %s;' % (self._convert_expr_from_c(tp, 'i', + 'variable type'),)) + assert delayed + else: + prnt(' o = _cffi_from_c_int_const(%s);' % name) + prnt(' if (o == NULL)') + prnt(' return -1;') + if size_too: + prnt(' {') + prnt(' PyObject *o1 = o;') + prnt(' o = Py_BuildValue("On", o1, (Py_ssize_t)sizeof(%s));' + % (name,)) + prnt(' Py_DECREF(o1);') + prnt(' if (o == NULL)') + prnt(' return -1;') + prnt(' }') + prnt(' res = PyObject_SetAttrString(lib, "%s", o);' % name) + prnt(' Py_DECREF(o);') + prnt(' if (res < 0)') + prnt(' return -1;') + prnt(' return %s;' % self._chained_list_constants[delayed]) + self._chained_list_constants[delayed] = funcname + '(lib)' + prnt('}') + prnt() + + def _generate_cpy_constant_collecttype(self, tp, name): + is_int = isinstance(tp, model.PrimitiveType) and tp.is_integer_type() + if not is_int: + self._do_collect_type(tp) + + def _generate_cpy_constant_decl(self, tp, name): + is_int = isinstance(tp, model.PrimitiveType) and tp.is_integer_type() + self._generate_cpy_const(is_int, name, tp) + + _generate_cpy_constant_method = _generate_nothing + _loading_cpy_constant = _loaded_noop + _loaded_cpy_constant = _loaded_noop + + # ---------- + # enums + + def _check_int_constant_value(self, name, value, err_prefix=''): + prnt = self._prnt + if value <= 0: + prnt(' if ((%s) > 0 || (long)(%s) != %dL) {' % ( + name, name, value)) + else: + prnt(' if ((%s) <= 0 || (unsigned long)(%s) != %dUL) {' % ( + name, name, value)) + prnt(' char buf[64];') + prnt(' if ((%s) <= 0)' % name) + prnt(' snprintf(buf, 63, "%%ld", (long)(%s));' % name) + prnt(' else') + prnt(' snprintf(buf, 63, "%%lu", (unsigned long)(%s));' % + name) + prnt(' PyErr_Format(_cffi_VerificationError,') + prnt(' "%s%s has the real value %s, not %s",') + prnt(' "%s", "%s", buf, "%d");' % ( + err_prefix, name, value)) + prnt(' return -1;') + prnt(' }') + + def _enum_funcname(self, prefix, name): + # "$enum_$1" => "___D_enum____D_1" + name = name.replace('$', '___D_') + return '_cffi_e_%s_%s' % (prefix, name) + + def _generate_cpy_enum_decl(self, tp, name, prefix='enum'): + if tp.partial: + for enumerator in tp.enumerators: + self._generate_cpy_const(True, enumerator, delayed=False) + return + # + funcname = self._enum_funcname(prefix, name) + prnt = self._prnt + prnt('static int %s(PyObject *lib)' % funcname) + prnt('{') + for enumerator, enumvalue in zip(tp.enumerators, tp.enumvalues): + self._check_int_constant_value(enumerator, enumvalue, + "enum %s: " % name) + prnt(' return %s;' % self._chained_list_constants[True]) + self._chained_list_constants[True] = funcname + '(lib)' + prnt('}') + prnt() + + _generate_cpy_enum_collecttype = _generate_nothing + _generate_cpy_enum_method = _generate_nothing + + def _loading_cpy_enum(self, tp, name, module): + if tp.partial: + enumvalues = [getattr(module, enumerator) + for enumerator in tp.enumerators] + tp.enumvalues = tuple(enumvalues) + tp.partial_resolved = True + + def _loaded_cpy_enum(self, tp, name, module, library): + for enumerator, enumvalue in zip(tp.enumerators, tp.enumvalues): + setattr(library, enumerator, enumvalue) + + # ---------- + # macros: for now only for integers + + def _generate_cpy_macro_decl(self, tp, name): + if tp == '...': + check_value = None + else: + check_value = tp # an integer + self._generate_cpy_const(True, name, check_value=check_value) + + _generate_cpy_macro_collecttype = _generate_nothing + _generate_cpy_macro_method = _generate_nothing + _loading_cpy_macro = _loaded_noop + _loaded_cpy_macro = _loaded_noop + + # ---------- + # global variables + + def _generate_cpy_variable_collecttype(self, tp, name): + if isinstance(tp, model.ArrayType): + tp_ptr = model.PointerType(tp.item) + else: + tp_ptr = model.PointerType(tp) + self._do_collect_type(tp_ptr) + + def _generate_cpy_variable_decl(self, tp, name): + if isinstance(tp, model.ArrayType): + tp_ptr = model.PointerType(tp.item) + self._generate_cpy_const(False, name, tp, vartp=tp_ptr, + size_too = tp.length_is_unknown()) + else: + tp_ptr = model.PointerType(tp) + self._generate_cpy_const(False, name, tp_ptr, category='var') + + _generate_cpy_variable_method = _generate_nothing + _loading_cpy_variable = _loaded_noop + + def _loaded_cpy_variable(self, tp, name, module, library): + value = getattr(library, name) + if isinstance(tp, model.ArrayType): # int a[5] is "constant" in the + # sense that "a=..." is forbidden + if tp.length_is_unknown(): + assert isinstance(value, tuple) + (value, size) = value + BItemType = self.ffi._get_cached_btype(tp.item) + length, rest = divmod(size, self.ffi.sizeof(BItemType)) + if rest != 0: + raise VerificationError( + "bad size: %r does not seem to be an array of %s" % + (name, tp.item)) + tp = tp.resolve_length(length) + # 'value' is a which we have to replace with + # a if the N is actually known + if tp.length is not None: + BArray = self.ffi._get_cached_btype(tp) + value = self.ffi.cast(BArray, value) + setattr(library, name, value) + return + # remove ptr= from the library instance, and replace + # it by a property on the class, which reads/writes into ptr[0]. + ptr = value + delattr(library, name) + def getter(library): + return ptr[0] + def setter(library, value): + ptr[0] = value + setattr(type(library), name, property(getter, setter)) + type(library)._cffi_dir.append(name) + + # ---------- + + def _generate_setup_custom(self): + prnt = self._prnt + prnt('static int _cffi_setup_custom(PyObject *lib)') + prnt('{') + prnt(' return %s;' % self._chained_list_constants[True]) + prnt('}') + +cffimod_header = r''' +#include +#include + +/* this block of #ifs should be kept exactly identical between + c/_cffi_backend.c, cffi/vengine_cpy.py, cffi/vengine_gen.py + and cffi/_cffi_include.h */ +#if defined(_MSC_VER) +# include /* for alloca() */ +# if _MSC_VER < 1600 /* MSVC < 2010 */ + typedef __int8 int8_t; + typedef __int16 int16_t; + typedef __int32 int32_t; + typedef __int64 int64_t; + typedef unsigned __int8 uint8_t; + typedef unsigned __int16 uint16_t; + typedef unsigned __int32 uint32_t; + typedef unsigned __int64 uint64_t; + typedef __int8 int_least8_t; + typedef __int16 int_least16_t; + typedef __int32 int_least32_t; + typedef __int64 int_least64_t; + typedef unsigned __int8 uint_least8_t; + typedef unsigned __int16 uint_least16_t; + typedef unsigned __int32 uint_least32_t; + typedef unsigned __int64 uint_least64_t; + typedef __int8 int_fast8_t; + typedef __int16 int_fast16_t; + typedef __int32 int_fast32_t; + typedef __int64 int_fast64_t; + typedef unsigned __int8 uint_fast8_t; + typedef unsigned __int16 uint_fast16_t; + typedef unsigned __int32 uint_fast32_t; + typedef unsigned __int64 uint_fast64_t; + typedef __int64 intmax_t; + typedef unsigned __int64 uintmax_t; +# else +# include +# endif +# if _MSC_VER < 1800 /* MSVC < 2013 */ +# ifndef __cplusplus + typedef unsigned char _Bool; +# endif +# endif +# define _cffi_float_complex_t _Fcomplex /* include for it */ +# define _cffi_double_complex_t _Dcomplex /* include for it */ +#else +# include +# if (defined (__SVR4) && defined (__sun)) || defined(_AIX) || defined(__hpux) +# include +# endif +# define _cffi_float_complex_t float _Complex +# define _cffi_double_complex_t double _Complex +#endif + +#if PY_MAJOR_VERSION < 3 +# undef PyCapsule_CheckExact +# undef PyCapsule_GetPointer +# define PyCapsule_CheckExact(capsule) (PyCObject_Check(capsule)) +# define PyCapsule_GetPointer(capsule, name) \ + (PyCObject_AsVoidPtr(capsule)) +#endif + +#if PY_MAJOR_VERSION >= 3 +# define PyInt_FromLong PyLong_FromLong +#endif + +#define _cffi_from_c_double PyFloat_FromDouble +#define _cffi_from_c_float PyFloat_FromDouble +#define _cffi_from_c_long PyInt_FromLong +#define _cffi_from_c_ulong PyLong_FromUnsignedLong +#define _cffi_from_c_longlong PyLong_FromLongLong +#define _cffi_from_c_ulonglong PyLong_FromUnsignedLongLong +#define _cffi_from_c__Bool PyBool_FromLong + +#define _cffi_to_c_double PyFloat_AsDouble +#define _cffi_to_c_float PyFloat_AsDouble + +#define _cffi_from_c_int_const(x) \ + (((x) > 0) ? \ + ((unsigned long long)(x) <= (unsigned long long)LONG_MAX) ? \ + PyInt_FromLong((long)(x)) : \ + PyLong_FromUnsignedLongLong((unsigned long long)(x)) : \ + ((long long)(x) >= (long long)LONG_MIN) ? \ + PyInt_FromLong((long)(x)) : \ + PyLong_FromLongLong((long long)(x))) + +#define _cffi_from_c_int(x, type) \ + (((type)-1) > 0 ? /* unsigned */ \ + (sizeof(type) < sizeof(long) ? \ + PyInt_FromLong((long)x) : \ + sizeof(type) == sizeof(long) ? \ + PyLong_FromUnsignedLong((unsigned long)x) : \ + PyLong_FromUnsignedLongLong((unsigned long long)x)) : \ + (sizeof(type) <= sizeof(long) ? \ + PyInt_FromLong((long)x) : \ + PyLong_FromLongLong((long long)x))) + +#define _cffi_to_c_int(o, type) \ + ((type)( \ + sizeof(type) == 1 ? (((type)-1) > 0 ? (type)_cffi_to_c_u8(o) \ + : (type)_cffi_to_c_i8(o)) : \ + sizeof(type) == 2 ? (((type)-1) > 0 ? (type)_cffi_to_c_u16(o) \ + : (type)_cffi_to_c_i16(o)) : \ + sizeof(type) == 4 ? (((type)-1) > 0 ? (type)_cffi_to_c_u32(o) \ + : (type)_cffi_to_c_i32(o)) : \ + sizeof(type) == 8 ? (((type)-1) > 0 ? (type)_cffi_to_c_u64(o) \ + : (type)_cffi_to_c_i64(o)) : \ + (Py_FatalError("unsupported size for type " #type), (type)0))) + +#define _cffi_to_c_i8 \ + ((int(*)(PyObject *))_cffi_exports[1]) +#define _cffi_to_c_u8 \ + ((int(*)(PyObject *))_cffi_exports[2]) +#define _cffi_to_c_i16 \ + ((int(*)(PyObject *))_cffi_exports[3]) +#define _cffi_to_c_u16 \ + ((int(*)(PyObject *))_cffi_exports[4]) +#define _cffi_to_c_i32 \ + ((int(*)(PyObject *))_cffi_exports[5]) +#define _cffi_to_c_u32 \ + ((unsigned int(*)(PyObject *))_cffi_exports[6]) +#define _cffi_to_c_i64 \ + ((long long(*)(PyObject *))_cffi_exports[7]) +#define _cffi_to_c_u64 \ + ((unsigned long long(*)(PyObject *))_cffi_exports[8]) +#define _cffi_to_c_char \ + ((int(*)(PyObject *))_cffi_exports[9]) +#define _cffi_from_c_pointer \ + ((PyObject *(*)(char *, CTypeDescrObject *))_cffi_exports[10]) +#define _cffi_to_c_pointer \ + ((char *(*)(PyObject *, CTypeDescrObject *))_cffi_exports[11]) +#define _cffi_get_struct_layout \ + ((PyObject *(*)(Py_ssize_t[]))_cffi_exports[12]) +#define _cffi_restore_errno \ + ((void(*)(void))_cffi_exports[13]) +#define _cffi_save_errno \ + ((void(*)(void))_cffi_exports[14]) +#define _cffi_from_c_char \ + ((PyObject *(*)(char))_cffi_exports[15]) +#define _cffi_from_c_deref \ + ((PyObject *(*)(char *, CTypeDescrObject *))_cffi_exports[16]) +#define _cffi_to_c \ + ((int(*)(char *, CTypeDescrObject *, PyObject *))_cffi_exports[17]) +#define _cffi_from_c_struct \ + ((PyObject *(*)(char *, CTypeDescrObject *))_cffi_exports[18]) +#define _cffi_to_c_wchar_t \ + ((wchar_t(*)(PyObject *))_cffi_exports[19]) +#define _cffi_from_c_wchar_t \ + ((PyObject *(*)(wchar_t))_cffi_exports[20]) +#define _cffi_to_c_long_double \ + ((long double(*)(PyObject *))_cffi_exports[21]) +#define _cffi_to_c__Bool \ + ((_Bool(*)(PyObject *))_cffi_exports[22]) +#define _cffi_prepare_pointer_call_argument \ + ((Py_ssize_t(*)(CTypeDescrObject *, PyObject *, char **))_cffi_exports[23]) +#define _cffi_convert_array_from_object \ + ((int(*)(char *, CTypeDescrObject *, PyObject *))_cffi_exports[24]) +#define _CFFI_NUM_EXPORTS 25 + +typedef struct _ctypedescr CTypeDescrObject; + +static void *_cffi_exports[_CFFI_NUM_EXPORTS]; +static PyObject *_cffi_types, *_cffi_VerificationError; + +static int _cffi_setup_custom(PyObject *lib); /* forward */ + +static PyObject *_cffi_setup(PyObject *self, PyObject *args) +{ + PyObject *library; + int was_alive = (_cffi_types != NULL); + (void)self; /* unused */ + if (!PyArg_ParseTuple(args, "OOO", &_cffi_types, &_cffi_VerificationError, + &library)) + return NULL; + Py_INCREF(_cffi_types); + Py_INCREF(_cffi_VerificationError); + if (_cffi_setup_custom(library) < 0) + return NULL; + return PyBool_FromLong(was_alive); +} + +union _cffi_union_alignment_u { + unsigned char m_char; + unsigned short m_short; + unsigned int m_int; + unsigned long m_long; + unsigned long long m_longlong; + float m_float; + double m_double; + long double m_longdouble; +}; + +struct _cffi_freeme_s { + struct _cffi_freeme_s *next; + union _cffi_union_alignment_u alignment; +}; + +#ifdef __GNUC__ + __attribute__((unused)) +#endif +static int _cffi_convert_array_argument(CTypeDescrObject *ctptr, PyObject *arg, + char **output_data, Py_ssize_t datasize, + struct _cffi_freeme_s **freeme) +{ + char *p; + if (datasize < 0) + return -1; + + p = *output_data; + if (p == NULL) { + struct _cffi_freeme_s *fp = (struct _cffi_freeme_s *)PyObject_Malloc( + offsetof(struct _cffi_freeme_s, alignment) + (size_t)datasize); + if (fp == NULL) + return -1; + fp->next = *freeme; + *freeme = fp; + p = *output_data = (char *)&fp->alignment; + } + memset((void *)p, 0, (size_t)datasize); + return _cffi_convert_array_from_object(p, ctptr, arg); +} + +#ifdef __GNUC__ + __attribute__((unused)) +#endif +static void _cffi_free_array_arguments(struct _cffi_freeme_s *freeme) +{ + do { + void *p = (void *)freeme; + freeme = freeme->next; + PyObject_Free(p); + } while (freeme != NULL); +} + +static int _cffi_init(void) +{ + PyObject *module, *c_api_object = NULL; + + module = PyImport_ImportModule("_cffi_backend"); + if (module == NULL) + goto failure; + + c_api_object = PyObject_GetAttrString(module, "_C_API"); + if (c_api_object == NULL) + goto failure; + if (!PyCapsule_CheckExact(c_api_object)) { + PyErr_SetNone(PyExc_ImportError); + goto failure; + } + memcpy(_cffi_exports, PyCapsule_GetPointer(c_api_object, "cffi"), + _CFFI_NUM_EXPORTS * sizeof(void *)); + + Py_DECREF(module); + Py_DECREF(c_api_object); + return 0; + + failure: + Py_XDECREF(module); + Py_XDECREF(c_api_object); + return -1; +} + +#define _cffi_type(num) ((CTypeDescrObject *)PyList_GET_ITEM(_cffi_types, num)) + +/**********/ +''' diff --git a/venv/lib/python3.12/site-packages/cffi/vengine_gen.py b/venv/lib/python3.12/site-packages/cffi/vengine_gen.py new file mode 100644 index 00000000..bffc8212 --- /dev/null +++ b/venv/lib/python3.12/site-packages/cffi/vengine_gen.py @@ -0,0 +1,679 @@ +# +# DEPRECATED: implementation for ffi.verify() +# +import sys, os +import types + +from . import model +from .error import VerificationError + + +class VGenericEngine(object): + _class_key = 'g' + _gen_python_module = False + + def __init__(self, verifier): + self.verifier = verifier + self.ffi = verifier.ffi + self.export_symbols = [] + self._struct_pending_verification = {} + + def patch_extension_kwds(self, kwds): + # add 'export_symbols' to the dictionary. Note that we add the + # list before filling it. When we fill it, it will thus also show + # up in kwds['export_symbols']. + kwds.setdefault('export_symbols', self.export_symbols) + + def find_module(self, module_name, path, so_suffixes): + for so_suffix in so_suffixes: + basename = module_name + so_suffix + if path is None: + path = sys.path + for dirname in path: + filename = os.path.join(dirname, basename) + if os.path.isfile(filename): + return filename + + def collect_types(self): + pass # not needed in the generic engine + + def _prnt(self, what=''): + self._f.write(what + '\n') + + def write_source_to_f(self): + prnt = self._prnt + # first paste some standard set of lines that are mostly '#include' + prnt(cffimod_header) + # then paste the C source given by the user, verbatim. + prnt(self.verifier.preamble) + # + # call generate_gen_xxx_decl(), for every xxx found from + # ffi._parser._declarations. This generates all the functions. + self._generate('decl') + # + # on Windows, distutils insists on putting init_cffi_xyz in + # 'export_symbols', so instead of fighting it, just give up and + # give it one + if sys.platform == 'win32': + if sys.version_info >= (3,): + prefix = 'PyInit_' + else: + prefix = 'init' + modname = self.verifier.get_module_name() + prnt("void %s%s(void) { }\n" % (prefix, modname)) + + def load_library(self, flags=0): + # import it with the CFFI backend + backend = self.ffi._backend + # needs to make a path that contains '/', on Posix + filename = os.path.join(os.curdir, self.verifier.modulefilename) + module = backend.load_library(filename, flags) + # + # call loading_gen_struct() to get the struct layout inferred by + # the C compiler + self._load(module, 'loading') + + # build the FFILibrary class and instance, this is a module subclass + # because modules are expected to have usually-constant-attributes and + # in PyPy this means the JIT is able to treat attributes as constant, + # which we want. + class FFILibrary(types.ModuleType): + _cffi_generic_module = module + _cffi_ffi = self.ffi + _cffi_dir = [] + def __dir__(self): + return FFILibrary._cffi_dir + library = FFILibrary("") + # + # finally, call the loaded_gen_xxx() functions. This will set + # up the 'library' object. + self._load(module, 'loaded', library=library) + return library + + def _get_declarations(self): + lst = [(key, tp) for (key, (tp, qual)) in + self.ffi._parser._declarations.items()] + lst.sort() + return lst + + def _generate(self, step_name): + for name, tp in self._get_declarations(): + kind, realname = name.split(' ', 1) + try: + method = getattr(self, '_generate_gen_%s_%s' % (kind, + step_name)) + except AttributeError: + raise VerificationError( + "not implemented in verify(): %r" % name) + try: + method(tp, realname) + except Exception as e: + model.attach_exception_info(e, name) + raise + + def _load(self, module, step_name, **kwds): + for name, tp in self._get_declarations(): + kind, realname = name.split(' ', 1) + method = getattr(self, '_%s_gen_%s' % (step_name, kind)) + try: + method(tp, realname, module, **kwds) + except Exception as e: + model.attach_exception_info(e, name) + raise + + def _generate_nothing(self, tp, name): + pass + + def _loaded_noop(self, tp, name, module, **kwds): + pass + + # ---------- + # typedefs: generates no code so far + + _generate_gen_typedef_decl = _generate_nothing + _loading_gen_typedef = _loaded_noop + _loaded_gen_typedef = _loaded_noop + + # ---------- + # function declarations + + def _generate_gen_function_decl(self, tp, name): + assert isinstance(tp, model.FunctionPtrType) + if tp.ellipsis: + # cannot support vararg functions better than this: check for its + # exact type (including the fixed arguments), and build it as a + # constant function pointer (no _cffi_f_%s wrapper) + self._generate_gen_const(False, name, tp) + return + prnt = self._prnt + numargs = len(tp.args) + argnames = [] + for i, type in enumerate(tp.args): + indirection = '' + if isinstance(type, model.StructOrUnion): + indirection = '*' + argnames.append('%sx%d' % (indirection, i)) + context = 'argument of %s' % name + arglist = [type.get_c_name(' %s' % arg, context) + for type, arg in zip(tp.args, argnames)] + tpresult = tp.result + if isinstance(tpresult, model.StructOrUnion): + arglist.insert(0, tpresult.get_c_name(' *r', context)) + tpresult = model.void_type + arglist = ', '.join(arglist) or 'void' + wrappername = '_cffi_f_%s' % name + self.export_symbols.append(wrappername) + if tp.abi: + abi = tp.abi + ' ' + else: + abi = '' + funcdecl = ' %s%s(%s)' % (abi, wrappername, arglist) + context = 'result of %s' % name + prnt(tpresult.get_c_name(funcdecl, context)) + prnt('{') + # + if isinstance(tp.result, model.StructOrUnion): + result_code = '*r = ' + elif not isinstance(tp.result, model.VoidType): + result_code = 'return ' + else: + result_code = '' + prnt(' %s%s(%s);' % (result_code, name, ', '.join(argnames))) + prnt('}') + prnt() + + _loading_gen_function = _loaded_noop + + def _loaded_gen_function(self, tp, name, module, library): + assert isinstance(tp, model.FunctionPtrType) + if tp.ellipsis: + newfunction = self._load_constant(False, tp, name, module) + else: + indirections = [] + base_tp = tp + if (any(isinstance(typ, model.StructOrUnion) for typ in tp.args) + or isinstance(tp.result, model.StructOrUnion)): + indirect_args = [] + for i, typ in enumerate(tp.args): + if isinstance(typ, model.StructOrUnion): + typ = model.PointerType(typ) + indirections.append((i, typ)) + indirect_args.append(typ) + indirect_result = tp.result + if isinstance(indirect_result, model.StructOrUnion): + if indirect_result.fldtypes is None: + raise TypeError("'%s' is used as result type, " + "but is opaque" % ( + indirect_result._get_c_name(),)) + indirect_result = model.PointerType(indirect_result) + indirect_args.insert(0, indirect_result) + indirections.insert(0, ("result", indirect_result)) + indirect_result = model.void_type + tp = model.FunctionPtrType(tuple(indirect_args), + indirect_result, tp.ellipsis) + BFunc = self.ffi._get_cached_btype(tp) + wrappername = '_cffi_f_%s' % name + newfunction = module.load_function(BFunc, wrappername) + for i, typ in indirections: + newfunction = self._make_struct_wrapper(newfunction, i, typ, + base_tp) + setattr(library, name, newfunction) + type(library)._cffi_dir.append(name) + + def _make_struct_wrapper(self, oldfunc, i, tp, base_tp): + backend = self.ffi._backend + BType = self.ffi._get_cached_btype(tp) + if i == "result": + ffi = self.ffi + def newfunc(*args): + res = ffi.new(BType) + oldfunc(res, *args) + return res[0] + else: + def newfunc(*args): + args = args[:i] + (backend.newp(BType, args[i]),) + args[i+1:] + return oldfunc(*args) + newfunc._cffi_base_type = base_tp + return newfunc + + # ---------- + # named structs + + def _generate_gen_struct_decl(self, tp, name): + assert name == tp.name + self._generate_struct_or_union_decl(tp, 'struct', name) + + def _loading_gen_struct(self, tp, name, module): + self._loading_struct_or_union(tp, 'struct', name, module) + + def _loaded_gen_struct(self, tp, name, module, **kwds): + self._loaded_struct_or_union(tp) + + def _generate_gen_union_decl(self, tp, name): + assert name == tp.name + self._generate_struct_or_union_decl(tp, 'union', name) + + def _loading_gen_union(self, tp, name, module): + self._loading_struct_or_union(tp, 'union', name, module) + + def _loaded_gen_union(self, tp, name, module, **kwds): + self._loaded_struct_or_union(tp) + + def _generate_struct_or_union_decl(self, tp, prefix, name): + if tp.fldnames is None: + return # nothing to do with opaque structs + checkfuncname = '_cffi_check_%s_%s' % (prefix, name) + layoutfuncname = '_cffi_layout_%s_%s' % (prefix, name) + cname = ('%s %s' % (prefix, name)).strip() + # + prnt = self._prnt + prnt('static void %s(%s *p)' % (checkfuncname, cname)) + prnt('{') + prnt(' /* only to generate compile-time warnings or errors */') + prnt(' (void)p;') + for fname, ftype, fbitsize, fqual in tp.enumfields(): + if (isinstance(ftype, model.PrimitiveType) + and ftype.is_integer_type()) or fbitsize >= 0: + # accept all integers, but complain on float or double + prnt(' (void)((p->%s) << 1);' % fname) + else: + # only accept exactly the type declared. + try: + prnt(' { %s = &p->%s; (void)tmp; }' % ( + ftype.get_c_name('*tmp', 'field %r'%fname, quals=fqual), + fname)) + except VerificationError as e: + prnt(' /* %s */' % str(e)) # cannot verify it, ignore + prnt('}') + self.export_symbols.append(layoutfuncname) + prnt('intptr_t %s(intptr_t i)' % (layoutfuncname,)) + prnt('{') + prnt(' struct _cffi_aligncheck { char x; %s y; };' % cname) + prnt(' static intptr_t nums[] = {') + prnt(' sizeof(%s),' % cname) + prnt(' offsetof(struct _cffi_aligncheck, y),') + for fname, ftype, fbitsize, fqual in tp.enumfields(): + if fbitsize >= 0: + continue # xxx ignore fbitsize for now + prnt(' offsetof(%s, %s),' % (cname, fname)) + if isinstance(ftype, model.ArrayType) and ftype.length is None: + prnt(' 0, /* %s */' % ftype._get_c_name()) + else: + prnt(' sizeof(((%s *)0)->%s),' % (cname, fname)) + prnt(' -1') + prnt(' };') + prnt(' return nums[i];') + prnt(' /* the next line is not executed, but compiled */') + prnt(' %s(0);' % (checkfuncname,)) + prnt('}') + prnt() + + def _loading_struct_or_union(self, tp, prefix, name, module): + if tp.fldnames is None: + return # nothing to do with opaque structs + layoutfuncname = '_cffi_layout_%s_%s' % (prefix, name) + # + BFunc = self.ffi._typeof_locked("intptr_t(*)(intptr_t)")[0] + function = module.load_function(BFunc, layoutfuncname) + layout = [] + num = 0 + while True: + x = function(num) + if x < 0: break + layout.append(x) + num += 1 + if isinstance(tp, model.StructOrUnion) and tp.partial: + # use the function()'s sizes and offsets to guide the + # layout of the struct + totalsize = layout[0] + totalalignment = layout[1] + fieldofs = layout[2::2] + fieldsize = layout[3::2] + tp.force_flatten() + assert len(fieldofs) == len(fieldsize) == len(tp.fldnames) + tp.fixedlayout = fieldofs, fieldsize, totalsize, totalalignment + else: + cname = ('%s %s' % (prefix, name)).strip() + self._struct_pending_verification[tp] = layout, cname + + def _loaded_struct_or_union(self, tp): + if tp.fldnames is None: + return # nothing to do with opaque structs + self.ffi._get_cached_btype(tp) # force 'fixedlayout' to be considered + + if tp in self._struct_pending_verification: + # check that the layout sizes and offsets match the real ones + def check(realvalue, expectedvalue, msg): + if realvalue != expectedvalue: + raise VerificationError( + "%s (we have %d, but C compiler says %d)" + % (msg, expectedvalue, realvalue)) + ffi = self.ffi + BStruct = ffi._get_cached_btype(tp) + layout, cname = self._struct_pending_verification.pop(tp) + check(layout[0], ffi.sizeof(BStruct), "wrong total size") + check(layout[1], ffi.alignof(BStruct), "wrong total alignment") + i = 2 + for fname, ftype, fbitsize, fqual in tp.enumfields(): + if fbitsize >= 0: + continue # xxx ignore fbitsize for now + check(layout[i], ffi.offsetof(BStruct, fname), + "wrong offset for field %r" % (fname,)) + if layout[i+1] != 0: + BField = ffi._get_cached_btype(ftype) + check(layout[i+1], ffi.sizeof(BField), + "wrong size for field %r" % (fname,)) + i += 2 + assert i == len(layout) + + # ---------- + # 'anonymous' declarations. These are produced for anonymous structs + # or unions; the 'name' is obtained by a typedef. + + def _generate_gen_anonymous_decl(self, tp, name): + if isinstance(tp, model.EnumType): + self._generate_gen_enum_decl(tp, name, '') + else: + self._generate_struct_or_union_decl(tp, '', name) + + def _loading_gen_anonymous(self, tp, name, module): + if isinstance(tp, model.EnumType): + self._loading_gen_enum(tp, name, module, '') + else: + self._loading_struct_or_union(tp, '', name, module) + + def _loaded_gen_anonymous(self, tp, name, module, **kwds): + if isinstance(tp, model.EnumType): + self._loaded_gen_enum(tp, name, module, **kwds) + else: + self._loaded_struct_or_union(tp) + + # ---------- + # constants, likely declared with '#define' + + def _generate_gen_const(self, is_int, name, tp=None, category='const', + check_value=None): + prnt = self._prnt + funcname = '_cffi_%s_%s' % (category, name) + self.export_symbols.append(funcname) + if check_value is not None: + assert is_int + assert category == 'const' + prnt('int %s(char *out_error)' % funcname) + prnt('{') + self._check_int_constant_value(name, check_value) + prnt(' return 0;') + prnt('}') + elif is_int: + assert category == 'const' + prnt('int %s(long long *out_value)' % funcname) + prnt('{') + prnt(' *out_value = (long long)(%s);' % (name,)) + prnt(' return (%s) <= 0;' % (name,)) + prnt('}') + else: + assert tp is not None + assert check_value is None + if category == 'var': + ampersand = '&' + else: + ampersand = '' + extra = '' + if category == 'const' and isinstance(tp, model.StructOrUnion): + extra = 'const *' + ampersand = '&' + prnt(tp.get_c_name(' %s%s(void)' % (extra, funcname), name)) + prnt('{') + prnt(' return (%s%s);' % (ampersand, name)) + prnt('}') + prnt() + + def _generate_gen_constant_decl(self, tp, name): + is_int = isinstance(tp, model.PrimitiveType) and tp.is_integer_type() + self._generate_gen_const(is_int, name, tp) + + _loading_gen_constant = _loaded_noop + + def _load_constant(self, is_int, tp, name, module, check_value=None): + funcname = '_cffi_const_%s' % name + if check_value is not None: + assert is_int + self._load_known_int_constant(module, funcname) + value = check_value + elif is_int: + BType = self.ffi._typeof_locked("long long*")[0] + BFunc = self.ffi._typeof_locked("int(*)(long long*)")[0] + function = module.load_function(BFunc, funcname) + p = self.ffi.new(BType) + negative = function(p) + value = int(p[0]) + if value < 0 and not negative: + BLongLong = self.ffi._typeof_locked("long long")[0] + value += (1 << (8*self.ffi.sizeof(BLongLong))) + else: + assert check_value is None + fntypeextra = '(*)(void)' + if isinstance(tp, model.StructOrUnion): + fntypeextra = '*' + fntypeextra + BFunc = self.ffi._typeof_locked(tp.get_c_name(fntypeextra, name))[0] + function = module.load_function(BFunc, funcname) + value = function() + if isinstance(tp, model.StructOrUnion): + value = value[0] + return value + + def _loaded_gen_constant(self, tp, name, module, library): + is_int = isinstance(tp, model.PrimitiveType) and tp.is_integer_type() + value = self._load_constant(is_int, tp, name, module) + setattr(library, name, value) + type(library)._cffi_dir.append(name) + + # ---------- + # enums + + def _check_int_constant_value(self, name, value): + prnt = self._prnt + if value <= 0: + prnt(' if ((%s) > 0 || (long)(%s) != %dL) {' % ( + name, name, value)) + else: + prnt(' if ((%s) <= 0 || (unsigned long)(%s) != %dUL) {' % ( + name, name, value)) + prnt(' char buf[64];') + prnt(' if ((%s) <= 0)' % name) + prnt(' sprintf(buf, "%%ld", (long)(%s));' % name) + prnt(' else') + prnt(' sprintf(buf, "%%lu", (unsigned long)(%s));' % + name) + prnt(' sprintf(out_error, "%s has the real value %s, not %s",') + prnt(' "%s", buf, "%d");' % (name[:100], value)) + prnt(' return -1;') + prnt(' }') + + def _load_known_int_constant(self, module, funcname): + BType = self.ffi._typeof_locked("char[]")[0] + BFunc = self.ffi._typeof_locked("int(*)(char*)")[0] + function = module.load_function(BFunc, funcname) + p = self.ffi.new(BType, 256) + if function(p) < 0: + error = self.ffi.string(p) + if sys.version_info >= (3,): + error = str(error, 'utf-8') + raise VerificationError(error) + + def _enum_funcname(self, prefix, name): + # "$enum_$1" => "___D_enum____D_1" + name = name.replace('$', '___D_') + return '_cffi_e_%s_%s' % (prefix, name) + + def _generate_gen_enum_decl(self, tp, name, prefix='enum'): + if tp.partial: + for enumerator in tp.enumerators: + self._generate_gen_const(True, enumerator) + return + # + funcname = self._enum_funcname(prefix, name) + self.export_symbols.append(funcname) + prnt = self._prnt + prnt('int %s(char *out_error)' % funcname) + prnt('{') + for enumerator, enumvalue in zip(tp.enumerators, tp.enumvalues): + self._check_int_constant_value(enumerator, enumvalue) + prnt(' return 0;') + prnt('}') + prnt() + + def _loading_gen_enum(self, tp, name, module, prefix='enum'): + if tp.partial: + enumvalues = [self._load_constant(True, tp, enumerator, module) + for enumerator in tp.enumerators] + tp.enumvalues = tuple(enumvalues) + tp.partial_resolved = True + else: + funcname = self._enum_funcname(prefix, name) + self._load_known_int_constant(module, funcname) + + def _loaded_gen_enum(self, tp, name, module, library): + for enumerator, enumvalue in zip(tp.enumerators, tp.enumvalues): + setattr(library, enumerator, enumvalue) + type(library)._cffi_dir.append(enumerator) + + # ---------- + # macros: for now only for integers + + def _generate_gen_macro_decl(self, tp, name): + if tp == '...': + check_value = None + else: + check_value = tp # an integer + self._generate_gen_const(True, name, check_value=check_value) + + _loading_gen_macro = _loaded_noop + + def _loaded_gen_macro(self, tp, name, module, library): + if tp == '...': + check_value = None + else: + check_value = tp # an integer + value = self._load_constant(True, tp, name, module, + check_value=check_value) + setattr(library, name, value) + type(library)._cffi_dir.append(name) + + # ---------- + # global variables + + def _generate_gen_variable_decl(self, tp, name): + if isinstance(tp, model.ArrayType): + if tp.length_is_unknown(): + prnt = self._prnt + funcname = '_cffi_sizeof_%s' % (name,) + self.export_symbols.append(funcname) + prnt("size_t %s(void)" % funcname) + prnt("{") + prnt(" return sizeof(%s);" % (name,)) + prnt("}") + tp_ptr = model.PointerType(tp.item) + self._generate_gen_const(False, name, tp_ptr) + else: + tp_ptr = model.PointerType(tp) + self._generate_gen_const(False, name, tp_ptr, category='var') + + _loading_gen_variable = _loaded_noop + + def _loaded_gen_variable(self, tp, name, module, library): + if isinstance(tp, model.ArrayType): # int a[5] is "constant" in the + # sense that "a=..." is forbidden + if tp.length_is_unknown(): + funcname = '_cffi_sizeof_%s' % (name,) + BFunc = self.ffi._typeof_locked('size_t(*)(void)')[0] + function = module.load_function(BFunc, funcname) + size = function() + BItemType = self.ffi._get_cached_btype(tp.item) + length, rest = divmod(size, self.ffi.sizeof(BItemType)) + if rest != 0: + raise VerificationError( + "bad size: %r does not seem to be an array of %s" % + (name, tp.item)) + tp = tp.resolve_length(length) + tp_ptr = model.PointerType(tp.item) + value = self._load_constant(False, tp_ptr, name, module) + # 'value' is a which we have to replace with + # a if the N is actually known + if tp.length is not None: + BArray = self.ffi._get_cached_btype(tp) + value = self.ffi.cast(BArray, value) + setattr(library, name, value) + type(library)._cffi_dir.append(name) + return + # remove ptr= from the library instance, and replace + # it by a property on the class, which reads/writes into ptr[0]. + funcname = '_cffi_var_%s' % name + BFunc = self.ffi._typeof_locked(tp.get_c_name('*(*)(void)', name))[0] + function = module.load_function(BFunc, funcname) + ptr = function() + def getter(library): + return ptr[0] + def setter(library, value): + ptr[0] = value + setattr(type(library), name, property(getter, setter)) + type(library)._cffi_dir.append(name) + +cffimod_header = r''' +#include +#include +#include +#include +#include /* XXX for ssize_t on some platforms */ + +/* this block of #ifs should be kept exactly identical between + c/_cffi_backend.c, cffi/vengine_cpy.py, cffi/vengine_gen.py + and cffi/_cffi_include.h */ +#if defined(_MSC_VER) +# include /* for alloca() */ +# if _MSC_VER < 1600 /* MSVC < 2010 */ + typedef __int8 int8_t; + typedef __int16 int16_t; + typedef __int32 int32_t; + typedef __int64 int64_t; + typedef unsigned __int8 uint8_t; + typedef unsigned __int16 uint16_t; + typedef unsigned __int32 uint32_t; + typedef unsigned __int64 uint64_t; + typedef __int8 int_least8_t; + typedef __int16 int_least16_t; + typedef __int32 int_least32_t; + typedef __int64 int_least64_t; + typedef unsigned __int8 uint_least8_t; + typedef unsigned __int16 uint_least16_t; + typedef unsigned __int32 uint_least32_t; + typedef unsigned __int64 uint_least64_t; + typedef __int8 int_fast8_t; + typedef __int16 int_fast16_t; + typedef __int32 int_fast32_t; + typedef __int64 int_fast64_t; + typedef unsigned __int8 uint_fast8_t; + typedef unsigned __int16 uint_fast16_t; + typedef unsigned __int32 uint_fast32_t; + typedef unsigned __int64 uint_fast64_t; + typedef __int64 intmax_t; + typedef unsigned __int64 uintmax_t; +# else +# include +# endif +# if _MSC_VER < 1800 /* MSVC < 2013 */ +# ifndef __cplusplus + typedef unsigned char _Bool; +# endif +# endif +# define _cffi_float_complex_t _Fcomplex /* include for it */ +# define _cffi_double_complex_t _Dcomplex /* include for it */ +#else +# include +# if (defined (__SVR4) && defined (__sun)) || defined(_AIX) || defined(__hpux) +# include +# endif +# define _cffi_float_complex_t float _Complex +# define _cffi_double_complex_t double _Complex +#endif +''' diff --git a/venv/lib/python3.12/site-packages/cffi/verifier.py b/venv/lib/python3.12/site-packages/cffi/verifier.py new file mode 100644 index 00000000..e392a2b7 --- /dev/null +++ b/venv/lib/python3.12/site-packages/cffi/verifier.py @@ -0,0 +1,306 @@ +# +# DEPRECATED: implementation for ffi.verify() +# +import sys, os, binascii, shutil, io +from . import __version_verifier_modules__ +from . import ffiplatform +from .error import VerificationError + +if sys.version_info >= (3, 3): + import importlib.machinery + def _extension_suffixes(): + return importlib.machinery.EXTENSION_SUFFIXES[:] +else: + import imp + def _extension_suffixes(): + return [suffix for suffix, _, type in imp.get_suffixes() + if type == imp.C_EXTENSION] + + +if sys.version_info >= (3,): + NativeIO = io.StringIO +else: + class NativeIO(io.BytesIO): + def write(self, s): + if isinstance(s, unicode): + s = s.encode('ascii') + super(NativeIO, self).write(s) + + +class Verifier(object): + + def __init__(self, ffi, preamble, tmpdir=None, modulename=None, + ext_package=None, tag='', force_generic_engine=False, + source_extension='.c', flags=None, relative_to=None, **kwds): + if ffi._parser._uses_new_feature: + raise VerificationError( + "feature not supported with ffi.verify(), but only " + "with ffi.set_source(): %s" % (ffi._parser._uses_new_feature,)) + self.ffi = ffi + self.preamble = preamble + if not modulename: + flattened_kwds = ffiplatform.flatten(kwds) + vengine_class = _locate_engine_class(ffi, force_generic_engine) + self._vengine = vengine_class(self) + self._vengine.patch_extension_kwds(kwds) + self.flags = flags + self.kwds = self.make_relative_to(kwds, relative_to) + # + if modulename: + if tag: + raise TypeError("can't specify both 'modulename' and 'tag'") + else: + key = '\x00'.join(['%d.%d' % sys.version_info[:2], + __version_verifier_modules__, + preamble, flattened_kwds] + + ffi._cdefsources) + if sys.version_info >= (3,): + key = key.encode('utf-8') + k1 = hex(binascii.crc32(key[0::2]) & 0xffffffff) + k1 = k1.lstrip('0x').rstrip('L') + k2 = hex(binascii.crc32(key[1::2]) & 0xffffffff) + k2 = k2.lstrip('0').rstrip('L') + modulename = '_cffi_%s_%s%s%s' % (tag, self._vengine._class_key, + k1, k2) + suffix = _get_so_suffixes()[0] + self.tmpdir = tmpdir or _caller_dir_pycache() + self.sourcefilename = os.path.join(self.tmpdir, modulename + source_extension) + self.modulefilename = os.path.join(self.tmpdir, modulename + suffix) + self.ext_package = ext_package + self._has_source = False + self._has_module = False + + def write_source(self, file=None): + """Write the C source code. It is produced in 'self.sourcefilename', + which can be tweaked beforehand.""" + with self.ffi._lock: + if self._has_source and file is None: + raise VerificationError( + "source code already written") + self._write_source(file) + + def compile_module(self): + """Write the C source code (if not done already) and compile it. + This produces a dynamic link library in 'self.modulefilename'.""" + with self.ffi._lock: + if self._has_module: + raise VerificationError("module already compiled") + if not self._has_source: + self._write_source() + self._compile_module() + + def load_library(self): + """Get a C module from this Verifier instance. + Returns an instance of a FFILibrary class that behaves like the + objects returned by ffi.dlopen(), but that delegates all + operations to the C module. If necessary, the C code is written + and compiled first. + """ + with self.ffi._lock: + if not self._has_module: + self._locate_module() + if not self._has_module: + if not self._has_source: + self._write_source() + self._compile_module() + return self._load_library() + + def get_module_name(self): + basename = os.path.basename(self.modulefilename) + # kill both the .so extension and the other .'s, as introduced + # by Python 3: 'basename.cpython-33m.so' + basename = basename.split('.', 1)[0] + # and the _d added in Python 2 debug builds --- but try to be + # conservative and not kill a legitimate _d + if basename.endswith('_d') and hasattr(sys, 'gettotalrefcount'): + basename = basename[:-2] + return basename + + def get_extension(self): + if not self._has_source: + with self.ffi._lock: + if not self._has_source: + self._write_source() + sourcename = ffiplatform.maybe_relative_path(self.sourcefilename) + modname = self.get_module_name() + return ffiplatform.get_extension(sourcename, modname, **self.kwds) + + def generates_python_module(self): + return self._vengine._gen_python_module + + def make_relative_to(self, kwds, relative_to): + if relative_to and os.path.dirname(relative_to): + dirname = os.path.dirname(relative_to) + kwds = kwds.copy() + for key in ffiplatform.LIST_OF_FILE_NAMES: + if key in kwds: + lst = kwds[key] + if not isinstance(lst, (list, tuple)): + raise TypeError("keyword '%s' should be a list or tuple" + % (key,)) + lst = [os.path.join(dirname, fn) for fn in lst] + kwds[key] = lst + return kwds + + # ---------- + + def _locate_module(self): + if not os.path.isfile(self.modulefilename): + if self.ext_package: + try: + pkg = __import__(self.ext_package, None, None, ['__doc__']) + except ImportError: + return # cannot import the package itself, give up + # (e.g. it might be called differently before installation) + path = pkg.__path__ + else: + path = None + filename = self._vengine.find_module(self.get_module_name(), path, + _get_so_suffixes()) + if filename is None: + return + self.modulefilename = filename + self._vengine.collect_types() + self._has_module = True + + def _write_source_to(self, file): + self._vengine._f = file + try: + self._vengine.write_source_to_f() + finally: + del self._vengine._f + + def _write_source(self, file=None): + if file is not None: + self._write_source_to(file) + else: + # Write our source file to an in memory file. + f = NativeIO() + self._write_source_to(f) + source_data = f.getvalue() + + # Determine if this matches the current file + if os.path.exists(self.sourcefilename): + with open(self.sourcefilename, "r") as fp: + needs_written = not (fp.read() == source_data) + else: + needs_written = True + + # Actually write the file out if it doesn't match + if needs_written: + _ensure_dir(self.sourcefilename) + with open(self.sourcefilename, "w") as fp: + fp.write(source_data) + + # Set this flag + self._has_source = True + + def _compile_module(self): + # compile this C source + tmpdir = os.path.dirname(self.sourcefilename) + outputfilename = ffiplatform.compile(tmpdir, self.get_extension()) + try: + same = ffiplatform.samefile(outputfilename, self.modulefilename) + except OSError: + same = False + if not same: + _ensure_dir(self.modulefilename) + shutil.move(outputfilename, self.modulefilename) + self._has_module = True + + def _load_library(self): + assert self._has_module + if self.flags is not None: + return self._vengine.load_library(self.flags) + else: + return self._vengine.load_library() + +# ____________________________________________________________ + +_FORCE_GENERIC_ENGINE = False # for tests + +def _locate_engine_class(ffi, force_generic_engine): + if _FORCE_GENERIC_ENGINE: + force_generic_engine = True + if not force_generic_engine: + if '__pypy__' in sys.builtin_module_names: + force_generic_engine = True + else: + try: + import _cffi_backend + except ImportError: + _cffi_backend = '?' + if ffi._backend is not _cffi_backend: + force_generic_engine = True + if force_generic_engine: + from . import vengine_gen + return vengine_gen.VGenericEngine + else: + from . import vengine_cpy + return vengine_cpy.VCPythonEngine + +# ____________________________________________________________ + +_TMPDIR = None + +def _caller_dir_pycache(): + if _TMPDIR: + return _TMPDIR + result = os.environ.get('CFFI_TMPDIR') + if result: + return result + filename = sys._getframe(2).f_code.co_filename + return os.path.abspath(os.path.join(os.path.dirname(filename), + '__pycache__')) + +def set_tmpdir(dirname): + """Set the temporary directory to use instead of __pycache__.""" + global _TMPDIR + _TMPDIR = dirname + +def cleanup_tmpdir(tmpdir=None, keep_so=False): + """Clean up the temporary directory by removing all files in it + called `_cffi_*.{c,so}` as well as the `build` subdirectory.""" + tmpdir = tmpdir or _caller_dir_pycache() + try: + filelist = os.listdir(tmpdir) + except OSError: + return + if keep_so: + suffix = '.c' # only remove .c files + else: + suffix = _get_so_suffixes()[0].lower() + for fn in filelist: + if fn.lower().startswith('_cffi_') and ( + fn.lower().endswith(suffix) or fn.lower().endswith('.c')): + try: + os.unlink(os.path.join(tmpdir, fn)) + except OSError: + pass + clean_dir = [os.path.join(tmpdir, 'build')] + for dir in clean_dir: + try: + for fn in os.listdir(dir): + fn = os.path.join(dir, fn) + if os.path.isdir(fn): + clean_dir.append(fn) + else: + os.unlink(fn) + except OSError: + pass + +def _get_so_suffixes(): + suffixes = _extension_suffixes() + if not suffixes: + # bah, no C_EXTENSION available. Occurs on pypy without cpyext + if sys.platform == 'win32': + suffixes = [".pyd"] + else: + suffixes = [".so"] + + return suffixes + +def _ensure_dir(filename): + dirname = os.path.dirname(filename) + if dirname and not os.path.isdir(dirname): + os.makedirs(dirname) diff --git a/venv/lib/python3.12/site-packages/numpy-2.1.3.dist-info/INSTALLER b/venv/lib/python3.12/site-packages/numpy-2.1.3.dist-info/INSTALLER new file mode 100644 index 00000000..a1b589e3 --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy-2.1.3.dist-info/INSTALLER @@ -0,0 +1 @@ +pip diff --git a/venv/lib/python3.12/site-packages/numpy-2.1.3.dist-info/LICENSE.txt b/venv/lib/python3.12/site-packages/numpy-2.1.3.dist-info/LICENSE.txt new file mode 100644 index 00000000..29817bec --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy-2.1.3.dist-info/LICENSE.txt @@ -0,0 +1,970 @@ +Copyright (c) 2005-2024, NumPy Developers. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + + * Neither the name of the NumPy Developers nor the names of any + contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +---- + +The NumPy repository and source distributions bundle several libraries that are +compatibly licensed. We list these here. + +Name: lapack-lite +Files: numpy/linalg/lapack_lite/* +License: BSD-3-Clause + For details, see numpy/linalg/lapack_lite/LICENSE.txt + +Name: dragon4 +Files: numpy/_core/src/multiarray/dragon4.c +License: MIT + For license text, see numpy/_core/src/multiarray/dragon4.c + +Name: libdivide +Files: numpy/_core/include/numpy/libdivide/* +License: Zlib + For license text, see numpy/_core/include/numpy/libdivide/LICENSE.txt + + +Note that the following files are vendored in the repository and sdist but not +installed in built numpy packages: + +Name: Meson +Files: vendored-meson/meson/* +License: Apache 2.0 + For license text, see vendored-meson/meson/COPYING + +Name: spin +Files: .spin/cmds.py +License: BSD-3 + For license text, see .spin/LICENSE + +Name: tempita +Files: numpy/_build_utils/tempita/* +License: MIT + For details, see numpy/_build_utils/tempita/LICENCE.txt + +---- + +This binary distribution of NumPy also bundles the following software: + +Name: OpenBLAS +Files: numpy/.dylibs/libscipy_openblas*.so +Description: bundled as a dynamically linked library +Availability: https://github.com/OpenMathLib/OpenBLAS/ +License: BSD-3-Clause + Copyright (c) 2011-2014, The OpenBLAS Project + 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 OpenBLAS project nor the names of + its contributors may be used to endorse or promote products + derived from this software without specific prior written + permission. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE + USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + +Name: LAPACK +Files: numpy/.dylibs/libscipy_openblas*.so +Description: bundled in OpenBLAS +Availability: https://github.com/OpenMathLib/OpenBLAS/ +License: BSD-3-Clause-Attribution + Copyright (c) 1992-2013 The University of Tennessee and The University + of Tennessee Research Foundation. All rights + reserved. + Copyright (c) 2000-2013 The University of California Berkeley. All + rights reserved. + Copyright (c) 2006-2013 The University of Colorado Denver. All rights + reserved. + + $COPYRIGHT$ + + Additional copyrights may follow + + $HEADER$ + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are + met: + + - Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + - Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer listed + in this license in the documentation and/or other materials + provided with the distribution. + + - Neither the name of the copyright holders nor the names of its + contributors may be used to endorse or promote products derived from + this software without specific prior written permission. + + The copyright holders provide no reassurances that the source code + provided does not infringe any patent, copyright, or any other + intellectual property rights of third parties. The copyright holders + disclaim any liability to any recipient for claims brought against + recipient by any third party for infringement of that parties + intellectual property rights. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + +Name: GCC runtime library +Files: numpy/.dylibs/libgfortran*, numpy/.dylibs/libgcc* +Description: dynamically linked to files compiled with gcc +Availability: https://gcc.gnu.org/git/?p=gcc.git;a=tree;f=libgfortran +License: GPL-3.0-with-GCC-exception + Copyright (C) 2002-2017 Free Software Foundation, Inc. + + Libgfortran is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3, or (at your option) + any later version. + + Libgfortran is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + Under Section 7 of GPL version 3, you are granted additional + permissions described in the GCC Runtime Library Exception, version + 3.1, as published by the Free Software Foundation. + + You should have received a copy of the GNU General Public License and + a copy of the GCC Runtime Library Exception along with this program; + see the files COPYING3 and COPYING.RUNTIME respectively. If not, see + . + +---- + +Full text of license texts referred to above follows (that they are +listed below does not necessarily imply the conditions apply to the +present binary release): + +---- + +GCC RUNTIME LIBRARY EXCEPTION + +Version 3.1, 31 March 2009 + +Copyright (C) 2009 Free Software Foundation, Inc. + +Everyone is permitted to copy and distribute verbatim copies of this +license document, but changing it is not allowed. + +This GCC Runtime Library Exception ("Exception") is an additional +permission under section 7 of the GNU General Public License, version +3 ("GPLv3"). It applies to a given file (the "Runtime Library") that +bears a notice placed by the copyright holder of the file stating that +the file is governed by GPLv3 along with this Exception. + +When you use GCC to compile a program, GCC may combine portions of +certain GCC header files and runtime libraries with the compiled +program. The purpose of this Exception is to allow compilation of +non-GPL (including proprietary) programs to use, in this way, the +header files and runtime libraries covered by this Exception. + +0. Definitions. + +A file is an "Independent Module" if it either requires the Runtime +Library for execution after a Compilation Process, or makes use of an +interface provided by the Runtime Library, but is not otherwise based +on the Runtime Library. + +"GCC" means a version of the GNU Compiler Collection, with or without +modifications, governed by version 3 (or a specified later version) of +the GNU General Public License (GPL) with the option of using any +subsequent versions published by the FSF. + +"GPL-compatible Software" is software whose conditions of propagation, +modification and use would permit combination with GCC in accord with +the license of GCC. + +"Target Code" refers to output from any compiler for a real or virtual +target processor architecture, in executable form or suitable for +input to an assembler, loader, linker and/or execution +phase. Notwithstanding that, Target Code does not include data in any +format that is used as a compiler intermediate representation, or used +for producing a compiler intermediate representation. + +The "Compilation Process" transforms code entirely represented in +non-intermediate languages designed for human-written code, and/or in +Java Virtual Machine byte code, into Target Code. Thus, for example, +use of source code generators and preprocessors need not be considered +part of the Compilation Process, since the Compilation Process can be +understood as starting with the output of the generators or +preprocessors. + +A Compilation Process is "Eligible" if it is done using GCC, alone or +with other GPL-compatible software, or if it is done without using any +work based on GCC. For example, using non-GPL-compatible Software to +optimize any GCC intermediate representations would not qualify as an +Eligible Compilation Process. + +1. Grant of Additional Permission. + +You have permission to propagate a work of Target Code formed by +combining the Runtime Library with Independent Modules, even if such +propagation would otherwise violate the terms of GPLv3, provided that +all Target Code was generated by Eligible Compilation Processes. You +may then convey such a combination under terms of your choice, +consistent with the licensing of the Independent Modules. + +2. No Weakening of GCC Copyleft. + +The availability of this Exception does not imply any general +presumption that third-party software is unaffected by the copyleft +requirements of the license of GCC. + +---- + + GNU GENERAL PUBLIC LICENSE + Version 3, 29 June 2007 + + Copyright (C) 2007 Free Software Foundation, Inc. + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + Preamble + + The GNU General Public License is a free, copyleft license for +software and other kinds of works. + + The licenses for most software and other practical works are designed +to take away your freedom to share and change the works. By contrast, +the GNU General Public License is intended to guarantee your freedom to +share and change all versions of a program--to make sure it remains free +software for all its users. We, the Free Software Foundation, use the +GNU General Public License for most of our software; it applies also to +any other work released this way by its authors. You can apply it to +your programs, too. + + When we speak of free software, we are referring to freedom, not +price. Our General Public Licenses are designed to make sure that you +have the freedom to distribute copies of free software (and charge for +them if you wish), that you receive source code or can get it if you +want it, that you can change the software or use pieces of it in new +free programs, and that you know you can do these things. + + To protect your rights, we need to prevent others from denying you +these rights or asking you to surrender the rights. Therefore, you have +certain responsibilities if you distribute copies of the software, or if +you modify it: responsibilities to respect the freedom of others. + + For example, if you distribute copies of such a program, whether +gratis or for a fee, you must pass on to the recipients the same +freedoms that you received. You must make sure that they, too, receive +or can get the source code. And you must show them these terms so they +know their rights. + + Developers that use the GNU GPL protect your rights with two steps: +(1) assert copyright on the software, and (2) offer you this License +giving you legal permission to copy, distribute and/or modify it. + + For the developers' and authors' protection, the GPL clearly explains +that there is no warranty for this free software. For both users' and +authors' sake, the GPL requires that modified versions be marked as +changed, so that their problems will not be attributed erroneously to +authors of previous versions. + + Some devices are designed to deny users access to install or run +modified versions of the software inside them, although the manufacturer +can do so. This is fundamentally incompatible with the aim of +protecting users' freedom to change the software. The systematic +pattern of such abuse occurs in the area of products for individuals to +use, which is precisely where it is most unacceptable. Therefore, we +have designed this version of the GPL to prohibit the practice for those +products. If such problems arise substantially in other domains, we +stand ready to extend this provision to those domains in future versions +of the GPL, as needed to protect the freedom of users. + + Finally, every program is threatened constantly by software patents. +States should not allow patents to restrict development and use of +software on general-purpose computers, but in those that do, we wish to +avoid the special danger that patents applied to a free program could +make it effectively proprietary. To prevent this, the GPL assures that +patents cannot be used to render the program non-free. + + The precise terms and conditions for copying, distribution and +modification follow. + + TERMS AND CONDITIONS + + 0. Definitions. + + "This License" refers to version 3 of the GNU General Public License. + + "Copyright" also means copyright-like laws that apply to other kinds of +works, such as semiconductor masks. + + "The Program" refers to any copyrightable work licensed under this +License. Each licensee is addressed as "you". "Licensees" and +"recipients" may be individuals or organizations. + + To "modify" a work means to copy from or adapt all or part of the work +in a fashion requiring copyright permission, other than the making of an +exact copy. The resulting work is called a "modified version" of the +earlier work or a work "based on" the earlier work. + + A "covered work" means either the unmodified Program or a work based +on the Program. + + To "propagate" a work means to do anything with it that, without +permission, would make you directly or secondarily liable for +infringement under applicable copyright law, except executing it on a +computer or modifying a private copy. Propagation includes copying, +distribution (with or without modification), making available to the +public, and in some countries other activities as well. + + To "convey" a work means any kind of propagation that enables other +parties to make or receive copies. Mere interaction with a user through +a computer network, with no transfer of a copy, is not conveying. + + An interactive user interface displays "Appropriate Legal Notices" +to the extent that it includes a convenient and prominently visible +feature that (1) displays an appropriate copyright notice, and (2) +tells the user that there is no warranty for the work (except to the +extent that warranties are provided), that licensees may convey the +work under this License, and how to view a copy of this License. If +the interface presents a list of user commands or options, such as a +menu, a prominent item in the list meets this criterion. + + 1. Source Code. + + The "source code" for a work means the preferred form of the work +for making modifications to it. "Object code" means any non-source +form of a work. + + A "Standard Interface" means an interface that either is an official +standard defined by a recognized standards body, or, in the case of +interfaces specified for a particular programming language, one that +is widely used among developers working in that language. + + The "System Libraries" of an executable work include anything, other +than the work as a whole, that (a) is included in the normal form of +packaging a Major Component, but which is not part of that Major +Component, and (b) serves only to enable use of the work with that +Major Component, or to implement a Standard Interface for which an +implementation is available to the public in source code form. A +"Major Component", in this context, means a major essential component +(kernel, window system, and so on) of the specific operating system +(if any) on which the executable work runs, or a compiler used to +produce the work, or an object code interpreter used to run it. + + The "Corresponding Source" for a work in object code form means all +the source code needed to generate, install, and (for an executable +work) run the object code and to modify the work, including scripts to +control those activities. However, it does not include the work's +System Libraries, or general-purpose tools or generally available free +programs which are used unmodified in performing those activities but +which are not part of the work. For example, Corresponding Source +includes interface definition files associated with source files for +the work, and the source code for shared libraries and dynamically +linked subprograms that the work is specifically designed to require, +such as by intimate data communication or control flow between those +subprograms and other parts of the work. + + The Corresponding Source need not include anything that users +can regenerate automatically from other parts of the Corresponding +Source. + + The Corresponding Source for a work in source code form is that +same work. + + 2. Basic Permissions. + + All rights granted under this License are granted for the term of +copyright on the Program, and are irrevocable provided the stated +conditions are met. This License explicitly affirms your unlimited +permission to run the unmodified Program. The output from running a +covered work is covered by this License only if the output, given its +content, constitutes a covered work. This License acknowledges your +rights of fair use or other equivalent, as provided by copyright law. + + You may make, run and propagate covered works that you do not +convey, without conditions so long as your license otherwise remains +in force. You may convey covered works to others for the sole purpose +of having them make modifications exclusively for you, or provide you +with facilities for running those works, provided that you comply with +the terms of this License in conveying all material for which you do +not control copyright. Those thus making or running the covered works +for you must do so exclusively on your behalf, under your direction +and control, on terms that prohibit them from making any copies of +your copyrighted material outside their relationship with you. + + Conveying under any other circumstances is permitted solely under +the conditions stated below. Sublicensing is not allowed; section 10 +makes it unnecessary. + + 3. Protecting Users' Legal Rights From Anti-Circumvention Law. + + No covered work shall be deemed part of an effective technological +measure under any applicable law fulfilling obligations under article +11 of the WIPO copyright treaty adopted on 20 December 1996, or +similar laws prohibiting or restricting circumvention of such +measures. + + When you convey a covered work, you waive any legal power to forbid +circumvention of technological measures to the extent such circumvention +is effected by exercising rights under this License with respect to +the covered work, and you disclaim any intention to limit operation or +modification of the work as a means of enforcing, against the work's +users, your or third parties' legal rights to forbid circumvention of +technological measures. + + 4. Conveying Verbatim Copies. + + You may convey verbatim copies of the Program's source code as you +receive it, in any medium, provided that you conspicuously and +appropriately publish on each copy an appropriate copyright notice; +keep intact all notices stating that this License and any +non-permissive terms added in accord with section 7 apply to the code; +keep intact all notices of the absence of any warranty; and give all +recipients a copy of this License along with the Program. + + You may charge any price or no price for each copy that you convey, +and you may offer support or warranty protection for a fee. + + 5. Conveying Modified Source Versions. + + You may convey a work based on the Program, or the modifications to +produce it from the Program, in the form of source code under the +terms of section 4, provided that you also meet all of these conditions: + + a) The work must carry prominent notices stating that you modified + it, and giving a relevant date. + + b) The work must carry prominent notices stating that it is + released under this License and any conditions added under section + 7. This requirement modifies the requirement in section 4 to + "keep intact all notices". + + c) You must license the entire work, as a whole, under this + License to anyone who comes into possession of a copy. This + License will therefore apply, along with any applicable section 7 + additional terms, to the whole of the work, and all its parts, + regardless of how they are packaged. This License gives no + permission to license the work in any other way, but it does not + invalidate such permission if you have separately received it. + + d) If the work has interactive user interfaces, each must display + Appropriate Legal Notices; however, if the Program has interactive + interfaces that do not display Appropriate Legal Notices, your + work need not make them do so. + + A compilation of a covered work with other separate and independent +works, which are not by their nature extensions of the covered work, +and which are not combined with it such as to form a larger program, +in or on a volume of a storage or distribution medium, is called an +"aggregate" if the compilation and its resulting copyright are not +used to limit the access or legal rights of the compilation's users +beyond what the individual works permit. Inclusion of a covered work +in an aggregate does not cause this License to apply to the other +parts of the aggregate. + + 6. Conveying Non-Source Forms. + + You may convey a covered work in object code form under the terms +of sections 4 and 5, provided that you also convey the +machine-readable Corresponding Source under the terms of this License, +in one of these ways: + + a) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by the + Corresponding Source fixed on a durable physical medium + customarily used for software interchange. + + b) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by a + written offer, valid for at least three years and valid for as + long as you offer spare parts or customer support for that product + model, to give anyone who possesses the object code either (1) a + copy of the Corresponding Source for all the software in the + product that is covered by this License, on a durable physical + medium customarily used for software interchange, for a price no + more than your reasonable cost of physically performing this + conveying of source, or (2) access to copy the + Corresponding Source from a network server at no charge. + + c) Convey individual copies of the object code with a copy of the + written offer to provide the Corresponding Source. This + alternative is allowed only occasionally and noncommercially, and + only if you received the object code with such an offer, in accord + with subsection 6b. + + d) Convey the object code by offering access from a designated + place (gratis or for a charge), and offer equivalent access to the + Corresponding Source in the same way through the same place at no + further charge. You need not require recipients to copy the + Corresponding Source along with the object code. If the place to + copy the object code is a network server, the Corresponding Source + may be on a different server (operated by you or a third party) + that supports equivalent copying facilities, provided you maintain + clear directions next to the object code saying where to find the + Corresponding Source. Regardless of what server hosts the + Corresponding Source, you remain obligated to ensure that it is + available for as long as needed to satisfy these requirements. + + e) Convey the object code using peer-to-peer transmission, provided + you inform other peers where the object code and Corresponding + Source of the work are being offered to the general public at no + charge under subsection 6d. + + A separable portion of the object code, whose source code is excluded +from the Corresponding Source as a System Library, need not be +included in conveying the object code work. + + A "User Product" is either (1) a "consumer product", which means any +tangible personal property which is normally used for personal, family, +or household purposes, or (2) anything designed or sold for incorporation +into a dwelling. In determining whether a product is a consumer product, +doubtful cases shall be resolved in favor of coverage. For a particular +product received by a particular user, "normally used" refers to a +typical or common use of that class of product, regardless of the status +of the particular user or of the way in which the particular user +actually uses, or expects or is expected to use, the product. A product +is a consumer product regardless of whether the product has substantial +commercial, industrial or non-consumer uses, unless such uses represent +the only significant mode of use of the product. + + "Installation Information" for a User Product means any methods, +procedures, authorization keys, or other information required to install +and execute modified versions of a covered work in that User Product from +a modified version of its Corresponding Source. The information must +suffice to ensure that the continued functioning of the modified object +code is in no case prevented or interfered with solely because +modification has been made. + + If you convey an object code work under this section in, or with, or +specifically for use in, a User Product, and the conveying occurs as +part of a transaction in which the right of possession and use of the +User Product is transferred to the recipient in perpetuity or for a +fixed term (regardless of how the transaction is characterized), the +Corresponding Source conveyed under this section must be accompanied +by the Installation Information. But this requirement does not apply +if neither you nor any third party retains the ability to install +modified object code on the User Product (for example, the work has +been installed in ROM). + + The requirement to provide Installation Information does not include a +requirement to continue to provide support service, warranty, or updates +for a work that has been modified or installed by the recipient, or for +the User Product in which it has been modified or installed. Access to a +network may be denied when the modification itself materially and +adversely affects the operation of the network or violates the rules and +protocols for communication across the network. + + Corresponding Source conveyed, and Installation Information provided, +in accord with this section must be in a format that is publicly +documented (and with an implementation available to the public in +source code form), and must require no special password or key for +unpacking, reading or copying. + + 7. Additional Terms. + + "Additional permissions" are terms that supplement the terms of this +License by making exceptions from one or more of its conditions. +Additional permissions that are applicable to the entire Program shall +be treated as though they were included in this License, to the extent +that they are valid under applicable law. If additional permissions +apply only to part of the Program, that part may be used separately +under those permissions, but the entire Program remains governed by +this License without regard to the additional permissions. + + When you convey a copy of a covered work, you may at your option +remove any additional permissions from that copy, or from any part of +it. (Additional permissions may be written to require their own +removal in certain cases when you modify the work.) You may place +additional permissions on material, added by you to a covered work, +for which you have or can give appropriate copyright permission. + + Notwithstanding any other provision of this License, for material you +add to a covered work, you may (if authorized by the copyright holders of +that material) supplement the terms of this License with terms: + + a) Disclaiming warranty or limiting liability differently from the + terms of sections 15 and 16 of this License; or + + b) Requiring preservation of specified reasonable legal notices or + author attributions in that material or in the Appropriate Legal + Notices displayed by works containing it; or + + c) Prohibiting misrepresentation of the origin of that material, or + requiring that modified versions of such material be marked in + reasonable ways as different from the original version; or + + d) Limiting the use for publicity purposes of names of licensors or + authors of the material; or + + e) Declining to grant rights under trademark law for use of some + trade names, trademarks, or service marks; or + + f) Requiring indemnification of licensors and authors of that + material by anyone who conveys the material (or modified versions of + it) with contractual assumptions of liability to the recipient, for + any liability that these contractual assumptions directly impose on + those licensors and authors. + + All other non-permissive additional terms are considered "further +restrictions" within the meaning of section 10. If the Program as you +received it, or any part of it, contains a notice stating that it is +governed by this License along with a term that is a further +restriction, you may remove that term. If a license document contains +a further restriction but permits relicensing or conveying under this +License, you may add to a covered work material governed by the terms +of that license document, provided that the further restriction does +not survive such relicensing or conveying. + + If you add terms to a covered work in accord with this section, you +must place, in the relevant source files, a statement of the +additional terms that apply to those files, or a notice indicating +where to find the applicable terms. + + Additional terms, permissive or non-permissive, may be stated in the +form of a separately written license, or stated as exceptions; +the above requirements apply either way. + + 8. Termination. + + You may not propagate or modify a covered work except as expressly +provided under this License. Any attempt otherwise to propagate or +modify it is void, and will automatically terminate your rights under +this License (including any patent licenses granted under the third +paragraph of section 11). + + However, if you cease all violation of this License, then your +license from a particular copyright holder is reinstated (a) +provisionally, unless and until the copyright holder explicitly and +finally terminates your license, and (b) permanently, if the copyright +holder fails to notify you of the violation by some reasonable means +prior to 60 days after the cessation. + + Moreover, your license from a particular copyright holder is +reinstated permanently if the copyright holder notifies you of the +violation by some reasonable means, this is the first time you have +received notice of violation of this License (for any work) from that +copyright holder, and you cure the violation prior to 30 days after +your receipt of the notice. + + Termination of your rights under this section does not terminate the +licenses of parties who have received copies or rights from you under +this License. If your rights have been terminated and not permanently +reinstated, you do not qualify to receive new licenses for the same +material under section 10. + + 9. Acceptance Not Required for Having Copies. + + You are not required to accept this License in order to receive or +run a copy of the Program. Ancillary propagation of a covered work +occurring solely as a consequence of using peer-to-peer transmission +to receive a copy likewise does not require acceptance. However, +nothing other than this License grants you permission to propagate or +modify any covered work. These actions infringe copyright if you do +not accept this License. Therefore, by modifying or propagating a +covered work, you indicate your acceptance of this License to do so. + + 10. Automatic Licensing of Downstream Recipients. + + Each time you convey a covered work, the recipient automatically +receives a license from the original licensors, to run, modify and +propagate that work, subject to this License. You are not responsible +for enforcing compliance by third parties with this License. + + An "entity transaction" is a transaction transferring control of an +organization, or substantially all assets of one, or subdividing an +organization, or merging organizations. If propagation of a covered +work results from an entity transaction, each party to that +transaction who receives a copy of the work also receives whatever +licenses to the work the party's predecessor in interest had or could +give under the previous paragraph, plus a right to possession of the +Corresponding Source of the work from the predecessor in interest, if +the predecessor has it or can get it with reasonable efforts. + + You may not impose any further restrictions on the exercise of the +rights granted or affirmed under this License. For example, you may +not impose a license fee, royalty, or other charge for exercise of +rights granted under this License, and you may not initiate litigation +(including a cross-claim or counterclaim in a lawsuit) alleging that +any patent claim is infringed by making, using, selling, offering for +sale, or importing the Program or any portion of it. + + 11. Patents. + + A "contributor" is a copyright holder who authorizes use under this +License of the Program or a work on which the Program is based. The +work thus licensed is called the contributor's "contributor version". + + A contributor's "essential patent claims" are all patent claims +owned or controlled by the contributor, whether already acquired or +hereafter acquired, that would be infringed by some manner, permitted +by this License, of making, using, or selling its contributor version, +but do not include claims that would be infringed only as a +consequence of further modification of the contributor version. For +purposes of this definition, "control" includes the right to grant +patent sublicenses in a manner consistent with the requirements of +this License. + + Each contributor grants you a non-exclusive, worldwide, royalty-free +patent license under the contributor's essential patent claims, to +make, use, sell, offer for sale, import and otherwise run, modify and +propagate the contents of its contributor version. + + In the following three paragraphs, a "patent license" is any express +agreement or commitment, however denominated, not to enforce a patent +(such as an express permission to practice a patent or covenant not to +sue for patent infringement). To "grant" such a patent license to a +party means to make such an agreement or commitment not to enforce a +patent against the party. + + If you convey a covered work, knowingly relying on a patent license, +and the Corresponding Source of the work is not available for anyone +to copy, free of charge and under the terms of this License, through a +publicly available network server or other readily accessible means, +then you must either (1) cause the Corresponding Source to be so +available, or (2) arrange to deprive yourself of the benefit of the +patent license for this particular work, or (3) arrange, in a manner +consistent with the requirements of this License, to extend the patent +license to downstream recipients. "Knowingly relying" means you have +actual knowledge that, but for the patent license, your conveying the +covered work in a country, or your recipient's use of the covered work +in a country, would infringe one or more identifiable patents in that +country that you have reason to believe are valid. + + If, pursuant to or in connection with a single transaction or +arrangement, you convey, or propagate by procuring conveyance of, a +covered work, and grant a patent license to some of the parties +receiving the covered work authorizing them to use, propagate, modify +or convey a specific copy of the covered work, then the patent license +you grant is automatically extended to all recipients of the covered +work and works based on it. + + A patent license is "discriminatory" if it does not include within +the scope of its coverage, prohibits the exercise of, or is +conditioned on the non-exercise of one or more of the rights that are +specifically granted under this License. You may not convey a covered +work if you are a party to an arrangement with a third party that is +in the business of distributing software, under which you make payment +to the third party based on the extent of your activity of conveying +the work, and under which the third party grants, to any of the +parties who would receive the covered work from you, a discriminatory +patent license (a) in connection with copies of the covered work +conveyed by you (or copies made from those copies), or (b) primarily +for and in connection with specific products or compilations that +contain the covered work, unless you entered into that arrangement, +or that patent license was granted, prior to 28 March 2007. + + Nothing in this License shall be construed as excluding or limiting +any implied license or other defenses to infringement that may +otherwise be available to you under applicable patent law. + + 12. No Surrender of Others' Freedom. + + If conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot convey a +covered work so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you may +not convey it at all. For example, if you agree to terms that obligate you +to collect a royalty for further conveying from those to whom you convey +the Program, the only way you could satisfy both those terms and this +License would be to refrain entirely from conveying the Program. + + 13. Use with the GNU Affero General Public License. + + Notwithstanding any other provision of this License, you have +permission to link or combine any covered work with a work licensed +under version 3 of the GNU Affero General Public License into a single +combined work, and to convey the resulting work. The terms of this +License will continue to apply to the part which is the covered work, +but the special requirements of the GNU Affero General Public License, +section 13, concerning interaction through a network will apply to the +combination as such. + + 14. Revised Versions of this License. + + The Free Software Foundation may publish revised and/or new versions of +the GNU General Public License from time to time. Such new versions will +be similar in spirit to the present version, but may differ in detail to +address new problems or concerns. + + Each version is given a distinguishing version number. If the +Program specifies that a certain numbered version of the GNU General +Public License "or any later version" applies to it, you have the +option of following the terms and conditions either of that numbered +version or of any later version published by the Free Software +Foundation. If the Program does not specify a version number of the +GNU General Public License, you may choose any version ever published +by the Free Software Foundation. + + If the Program specifies that a proxy can decide which future +versions of the GNU General Public License can be used, that proxy's +public statement of acceptance of a version permanently authorizes you +to choose that version for the Program. + + Later license versions may give you additional or different +permissions. However, no additional obligations are imposed on any +author or copyright holder as a result of your choosing to follow a +later version. + + 15. Disclaimer of Warranty. + + THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY +APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT +HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY +OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, +THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM +IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF +ALL NECESSARY SERVICING, REPAIR OR CORRECTION. + + 16. Limitation of Liability. + + IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING +WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS +THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY +GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE +USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF +DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD +PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), +EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF +SUCH DAMAGES. + + 17. Interpretation of Sections 15 and 16. + + If the disclaimer of warranty and limitation of liability provided +above cannot be given local legal effect according to their terms, +reviewing courts shall apply local law that most closely approximates +an absolute waiver of all civil liability in connection with the +Program, unless a warranty or assumption of liability accompanies a +copy of the Program in return for a fee. + + END OF TERMS AND CONDITIONS + + How to Apply These Terms to Your New Programs + + If you develop a new program, and you want it to be of the greatest +possible use to the public, the best way to achieve this is to make it +free software which everyone can redistribute and change under these terms. + + To do so, attach the following notices to the program. It is safest +to attach them to the start of each source file to most effectively +state the exclusion of warranty; and each file should have at least +the "copyright" line and a pointer to where the full notice is found. + + + Copyright (C) + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . + +Also add information on how to contact you by electronic and paper mail. + + If the program does terminal interaction, make it output a short +notice like this when it starts in an interactive mode: + + Copyright (C) + This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'. + This is free software, and you are welcome to redistribute it + under certain conditions; type `show c' for details. + +The hypothetical commands `show w' and `show c' should show the appropriate +parts of the General Public License. Of course, your program's commands +might be different; for a GUI interface, you would use an "about box". + + You should also get your employer (if you work as a programmer) or school, +if any, to sign a "copyright disclaimer" for the program, if necessary. +For more information on this, and how to apply and follow the GNU GPL, see +. + + The GNU General Public License does not permit incorporating your program +into proprietary programs. If your program is a subroutine library, you +may consider it more useful to permit linking proprietary applications with +the library. If this is what you want to do, use the GNU Lesser General +Public License instead of this License. But first, please read +. + +Name: libquadmath +Files: numpy/.dylibs/libquadmath*.so +Description: dynamically linked to files compiled with gcc +Availability: https://gcc.gnu.org/git/?p=gcc.git;a=tree;f=libquadmath +License: LGPL-2.1-or-later + + GCC Quad-Precision Math Library + Copyright (C) 2010-2019 Free Software Foundation, Inc. + Written by Francois-Xavier Coudert + + This file is part of the libquadmath library. + Libquadmath is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + Libquadmath is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + https://www.gnu.org/licenses/old-licenses/lgpl-2.1.html diff --git a/venv/lib/python3.12/site-packages/numpy-2.1.3.dist-info/METADATA b/venv/lib/python3.12/site-packages/numpy-2.1.3.dist-info/METADATA new file mode 100644 index 00000000..ede7720a --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy-2.1.3.dist-info/METADATA @@ -0,0 +1,1091 @@ +Metadata-Version: 2.1 +Name: numpy +Version: 2.1.3 +Summary: Fundamental package for array computing in Python +Author: Travis E. Oliphant et al. +Maintainer-Email: NumPy Developers +License: Copyright (c) 2005-2024, NumPy Developers. + All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are + met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + + * Neither the name of the NumPy Developers nor the names of any + contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + ---- + + The NumPy repository and source distributions bundle several libraries that are + compatibly licensed. We list these here. + + Name: lapack-lite + Files: numpy/linalg/lapack_lite/* + License: BSD-3-Clause + For details, see numpy/linalg/lapack_lite/LICENSE.txt + + Name: dragon4 + Files: numpy/_core/src/multiarray/dragon4.c + License: MIT + For license text, see numpy/_core/src/multiarray/dragon4.c + + Name: libdivide + Files: numpy/_core/include/numpy/libdivide/* + License: Zlib + For license text, see numpy/_core/include/numpy/libdivide/LICENSE.txt + + + Note that the following files are vendored in the repository and sdist but not + installed in built numpy packages: + + Name: Meson + Files: vendored-meson/meson/* + License: Apache 2.0 + For license text, see vendored-meson/meson/COPYING + + Name: spin + Files: .spin/cmds.py + License: BSD-3 + For license text, see .spin/LICENSE + + Name: tempita + Files: numpy/_build_utils/tempita/* + License: MIT + For details, see numpy/_build_utils/tempita/LICENCE.txt + + ---- + + This binary distribution of NumPy also bundles the following software: + + Name: OpenBLAS + Files: numpy/.dylibs/libscipy_openblas*.so + Description: bundled as a dynamically linked library + Availability: https://github.com/OpenMathLib/OpenBLAS/ + License: BSD-3-Clause + Copyright (c) 2011-2014, The OpenBLAS Project + 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 OpenBLAS project nor the names of + its contributors may be used to endorse or promote products + derived from this software without specific prior written + permission. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE + USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + + Name: LAPACK + Files: numpy/.dylibs/libscipy_openblas*.so + Description: bundled in OpenBLAS + Availability: https://github.com/OpenMathLib/OpenBLAS/ + License: BSD-3-Clause-Attribution + Copyright (c) 1992-2013 The University of Tennessee and The University + of Tennessee Research Foundation. All rights + reserved. + Copyright (c) 2000-2013 The University of California Berkeley. All + rights reserved. + Copyright (c) 2006-2013 The University of Colorado Denver. All rights + reserved. + + $COPYRIGHT$ + + Additional copyrights may follow + + $HEADER$ + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are + met: + + - Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + - Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer listed + in this license in the documentation and/or other materials + provided with the distribution. + + - Neither the name of the copyright holders nor the names of its + contributors may be used to endorse or promote products derived from + this software without specific prior written permission. + + The copyright holders provide no reassurances that the source code + provided does not infringe any patent, copyright, or any other + intellectual property rights of third parties. The copyright holders + disclaim any liability to any recipient for claims brought against + recipient by any third party for infringement of that parties + intellectual property rights. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + + Name: GCC runtime library + Files: numpy/.dylibs/libgfortran*, numpy/.dylibs/libgcc* + Description: dynamically linked to files compiled with gcc + Availability: https://gcc.gnu.org/git/?p=gcc.git;a=tree;f=libgfortran + License: GPL-3.0-with-GCC-exception + Copyright (C) 2002-2017 Free Software Foundation, Inc. + + Libgfortran is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3, or (at your option) + any later version. + + Libgfortran is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + Under Section 7 of GPL version 3, you are granted additional + permissions described in the GCC Runtime Library Exception, version + 3.1, as published by the Free Software Foundation. + + You should have received a copy of the GNU General Public License and + a copy of the GCC Runtime Library Exception along with this program; + see the files COPYING3 and COPYING.RUNTIME respectively. If not, see + . + + ---- + + Full text of license texts referred to above follows (that they are + listed below does not necessarily imply the conditions apply to the + present binary release): + + ---- + + GCC RUNTIME LIBRARY EXCEPTION + + Version 3.1, 31 March 2009 + + Copyright (C) 2009 Free Software Foundation, Inc. + + Everyone is permitted to copy and distribute verbatim copies of this + license document, but changing it is not allowed. + + This GCC Runtime Library Exception ("Exception") is an additional + permission under section 7 of the GNU General Public License, version + 3 ("GPLv3"). It applies to a given file (the "Runtime Library") that + bears a notice placed by the copyright holder of the file stating that + the file is governed by GPLv3 along with this Exception. + + When you use GCC to compile a program, GCC may combine portions of + certain GCC header files and runtime libraries with the compiled + program. The purpose of this Exception is to allow compilation of + non-GPL (including proprietary) programs to use, in this way, the + header files and runtime libraries covered by this Exception. + + 0. Definitions. + + A file is an "Independent Module" if it either requires the Runtime + Library for execution after a Compilation Process, or makes use of an + interface provided by the Runtime Library, but is not otherwise based + on the Runtime Library. + + "GCC" means a version of the GNU Compiler Collection, with or without + modifications, governed by version 3 (or a specified later version) of + the GNU General Public License (GPL) with the option of using any + subsequent versions published by the FSF. + + "GPL-compatible Software" is software whose conditions of propagation, + modification and use would permit combination with GCC in accord with + the license of GCC. + + "Target Code" refers to output from any compiler for a real or virtual + target processor architecture, in executable form or suitable for + input to an assembler, loader, linker and/or execution + phase. Notwithstanding that, Target Code does not include data in any + format that is used as a compiler intermediate representation, or used + for producing a compiler intermediate representation. + + The "Compilation Process" transforms code entirely represented in + non-intermediate languages designed for human-written code, and/or in + Java Virtual Machine byte code, into Target Code. Thus, for example, + use of source code generators and preprocessors need not be considered + part of the Compilation Process, since the Compilation Process can be + understood as starting with the output of the generators or + preprocessors. + + A Compilation Process is "Eligible" if it is done using GCC, alone or + with other GPL-compatible software, or if it is done without using any + work based on GCC. For example, using non-GPL-compatible Software to + optimize any GCC intermediate representations would not qualify as an + Eligible Compilation Process. + + 1. Grant of Additional Permission. + + You have permission to propagate a work of Target Code formed by + combining the Runtime Library with Independent Modules, even if such + propagation would otherwise violate the terms of GPLv3, provided that + all Target Code was generated by Eligible Compilation Processes. You + may then convey such a combination under terms of your choice, + consistent with the licensing of the Independent Modules. + + 2. No Weakening of GCC Copyleft. + + The availability of this Exception does not imply any general + presumption that third-party software is unaffected by the copyleft + requirements of the license of GCC. + + ---- + + GNU GENERAL PUBLIC LICENSE + Version 3, 29 June 2007 + + Copyright (C) 2007 Free Software Foundation, Inc. + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + Preamble + + The GNU General Public License is a free, copyleft license for + software and other kinds of works. + + The licenses for most software and other practical works are designed + to take away your freedom to share and change the works. By contrast, + the GNU General Public License is intended to guarantee your freedom to + share and change all versions of a program--to make sure it remains free + software for all its users. We, the Free Software Foundation, use the + GNU General Public License for most of our software; it applies also to + any other work released this way by its authors. You can apply it to + your programs, too. + + When we speak of free software, we are referring to freedom, not + price. Our General Public Licenses are designed to make sure that you + have the freedom to distribute copies of free software (and charge for + them if you wish), that you receive source code or can get it if you + want it, that you can change the software or use pieces of it in new + free programs, and that you know you can do these things. + + To protect your rights, we need to prevent others from denying you + these rights or asking you to surrender the rights. Therefore, you have + certain responsibilities if you distribute copies of the software, or if + you modify it: responsibilities to respect the freedom of others. + + For example, if you distribute copies of such a program, whether + gratis or for a fee, you must pass on to the recipients the same + freedoms that you received. You must make sure that they, too, receive + or can get the source code. And you must show them these terms so they + know their rights. + + Developers that use the GNU GPL protect your rights with two steps: + (1) assert copyright on the software, and (2) offer you this License + giving you legal permission to copy, distribute and/or modify it. + + For the developers' and authors' protection, the GPL clearly explains + that there is no warranty for this free software. For both users' and + authors' sake, the GPL requires that modified versions be marked as + changed, so that their problems will not be attributed erroneously to + authors of previous versions. + + Some devices are designed to deny users access to install or run + modified versions of the software inside them, although the manufacturer + can do so. This is fundamentally incompatible with the aim of + protecting users' freedom to change the software. The systematic + pattern of such abuse occurs in the area of products for individuals to + use, which is precisely where it is most unacceptable. Therefore, we + have designed this version of the GPL to prohibit the practice for those + products. If such problems arise substantially in other domains, we + stand ready to extend this provision to those domains in future versions + of the GPL, as needed to protect the freedom of users. + + Finally, every program is threatened constantly by software patents. + States should not allow patents to restrict development and use of + software on general-purpose computers, but in those that do, we wish to + avoid the special danger that patents applied to a free program could + make it effectively proprietary. To prevent this, the GPL assures that + patents cannot be used to render the program non-free. + + The precise terms and conditions for copying, distribution and + modification follow. + + TERMS AND CONDITIONS + + 0. Definitions. + + "This License" refers to version 3 of the GNU General Public License. + + "Copyright" also means copyright-like laws that apply to other kinds of + works, such as semiconductor masks. + + "The Program" refers to any copyrightable work licensed under this + License. Each licensee is addressed as "you". "Licensees" and + "recipients" may be individuals or organizations. + + To "modify" a work means to copy from or adapt all or part of the work + in a fashion requiring copyright permission, other than the making of an + exact copy. The resulting work is called a "modified version" of the + earlier work or a work "based on" the earlier work. + + A "covered work" means either the unmodified Program or a work based + on the Program. + + To "propagate" a work means to do anything with it that, without + permission, would make you directly or secondarily liable for + infringement under applicable copyright law, except executing it on a + computer or modifying a private copy. Propagation includes copying, + distribution (with or without modification), making available to the + public, and in some countries other activities as well. + + To "convey" a work means any kind of propagation that enables other + parties to make or receive copies. Mere interaction with a user through + a computer network, with no transfer of a copy, is not conveying. + + An interactive user interface displays "Appropriate Legal Notices" + to the extent that it includes a convenient and prominently visible + feature that (1) displays an appropriate copyright notice, and (2) + tells the user that there is no warranty for the work (except to the + extent that warranties are provided), that licensees may convey the + work under this License, and how to view a copy of this License. If + the interface presents a list of user commands or options, such as a + menu, a prominent item in the list meets this criterion. + + 1. Source Code. + + The "source code" for a work means the preferred form of the work + for making modifications to it. "Object code" means any non-source + form of a work. + + A "Standard Interface" means an interface that either is an official + standard defined by a recognized standards body, or, in the case of + interfaces specified for a particular programming language, one that + is widely used among developers working in that language. + + The "System Libraries" of an executable work include anything, other + than the work as a whole, that (a) is included in the normal form of + packaging a Major Component, but which is not part of that Major + Component, and (b) serves only to enable use of the work with that + Major Component, or to implement a Standard Interface for which an + implementation is available to the public in source code form. A + "Major Component", in this context, means a major essential component + (kernel, window system, and so on) of the specific operating system + (if any) on which the executable work runs, or a compiler used to + produce the work, or an object code interpreter used to run it. + + The "Corresponding Source" for a work in object code form means all + the source code needed to generate, install, and (for an executable + work) run the object code and to modify the work, including scripts to + control those activities. However, it does not include the work's + System Libraries, or general-purpose tools or generally available free + programs which are used unmodified in performing those activities but + which are not part of the work. For example, Corresponding Source + includes interface definition files associated with source files for + the work, and the source code for shared libraries and dynamically + linked subprograms that the work is specifically designed to require, + such as by intimate data communication or control flow between those + subprograms and other parts of the work. + + The Corresponding Source need not include anything that users + can regenerate automatically from other parts of the Corresponding + Source. + + The Corresponding Source for a work in source code form is that + same work. + + 2. Basic Permissions. + + All rights granted under this License are granted for the term of + copyright on the Program, and are irrevocable provided the stated + conditions are met. This License explicitly affirms your unlimited + permission to run the unmodified Program. The output from running a + covered work is covered by this License only if the output, given its + content, constitutes a covered work. This License acknowledges your + rights of fair use or other equivalent, as provided by copyright law. + + You may make, run and propagate covered works that you do not + convey, without conditions so long as your license otherwise remains + in force. You may convey covered works to others for the sole purpose + of having them make modifications exclusively for you, or provide you + with facilities for running those works, provided that you comply with + the terms of this License in conveying all material for which you do + not control copyright. Those thus making or running the covered works + for you must do so exclusively on your behalf, under your direction + and control, on terms that prohibit them from making any copies of + your copyrighted material outside their relationship with you. + + Conveying under any other circumstances is permitted solely under + the conditions stated below. Sublicensing is not allowed; section 10 + makes it unnecessary. + + 3. Protecting Users' Legal Rights From Anti-Circumvention Law. + + No covered work shall be deemed part of an effective technological + measure under any applicable law fulfilling obligations under article + 11 of the WIPO copyright treaty adopted on 20 December 1996, or + similar laws prohibiting or restricting circumvention of such + measures. + + When you convey a covered work, you waive any legal power to forbid + circumvention of technological measures to the extent such circumvention + is effected by exercising rights under this License with respect to + the covered work, and you disclaim any intention to limit operation or + modification of the work as a means of enforcing, against the work's + users, your or third parties' legal rights to forbid circumvention of + technological measures. + + 4. Conveying Verbatim Copies. + + You may convey verbatim copies of the Program's source code as you + receive it, in any medium, provided that you conspicuously and + appropriately publish on each copy an appropriate copyright notice; + keep intact all notices stating that this License and any + non-permissive terms added in accord with section 7 apply to the code; + keep intact all notices of the absence of any warranty; and give all + recipients a copy of this License along with the Program. + + You may charge any price or no price for each copy that you convey, + and you may offer support or warranty protection for a fee. + + 5. Conveying Modified Source Versions. + + You may convey a work based on the Program, or the modifications to + produce it from the Program, in the form of source code under the + terms of section 4, provided that you also meet all of these conditions: + + a) The work must carry prominent notices stating that you modified + it, and giving a relevant date. + + b) The work must carry prominent notices stating that it is + released under this License and any conditions added under section + 7. This requirement modifies the requirement in section 4 to + "keep intact all notices". + + c) You must license the entire work, as a whole, under this + License to anyone who comes into possession of a copy. This + License will therefore apply, along with any applicable section 7 + additional terms, to the whole of the work, and all its parts, + regardless of how they are packaged. This License gives no + permission to license the work in any other way, but it does not + invalidate such permission if you have separately received it. + + d) If the work has interactive user interfaces, each must display + Appropriate Legal Notices; however, if the Program has interactive + interfaces that do not display Appropriate Legal Notices, your + work need not make them do so. + + A compilation of a covered work with other separate and independent + works, which are not by their nature extensions of the covered work, + and which are not combined with it such as to form a larger program, + in or on a volume of a storage or distribution medium, is called an + "aggregate" if the compilation and its resulting copyright are not + used to limit the access or legal rights of the compilation's users + beyond what the individual works permit. Inclusion of a covered work + in an aggregate does not cause this License to apply to the other + parts of the aggregate. + + 6. Conveying Non-Source Forms. + + You may convey a covered work in object code form under the terms + of sections 4 and 5, provided that you also convey the + machine-readable Corresponding Source under the terms of this License, + in one of these ways: + + a) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by the + Corresponding Source fixed on a durable physical medium + customarily used for software interchange. + + b) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by a + written offer, valid for at least three years and valid for as + long as you offer spare parts or customer support for that product + model, to give anyone who possesses the object code either (1) a + copy of the Corresponding Source for all the software in the + product that is covered by this License, on a durable physical + medium customarily used for software interchange, for a price no + more than your reasonable cost of physically performing this + conveying of source, or (2) access to copy the + Corresponding Source from a network server at no charge. + + c) Convey individual copies of the object code with a copy of the + written offer to provide the Corresponding Source. This + alternative is allowed only occasionally and noncommercially, and + only if you received the object code with such an offer, in accord + with subsection 6b. + + d) Convey the object code by offering access from a designated + place (gratis or for a charge), and offer equivalent access to the + Corresponding Source in the same way through the same place at no + further charge. You need not require recipients to copy the + Corresponding Source along with the object code. If the place to + copy the object code is a network server, the Corresponding Source + may be on a different server (operated by you or a third party) + that supports equivalent copying facilities, provided you maintain + clear directions next to the object code saying where to find the + Corresponding Source. Regardless of what server hosts the + Corresponding Source, you remain obligated to ensure that it is + available for as long as needed to satisfy these requirements. + + e) Convey the object code using peer-to-peer transmission, provided + you inform other peers where the object code and Corresponding + Source of the work are being offered to the general public at no + charge under subsection 6d. + + A separable portion of the object code, whose source code is excluded + from the Corresponding Source as a System Library, need not be + included in conveying the object code work. + + A "User Product" is either (1) a "consumer product", which means any + tangible personal property which is normally used for personal, family, + or household purposes, or (2) anything designed or sold for incorporation + into a dwelling. In determining whether a product is a consumer product, + doubtful cases shall be resolved in favor of coverage. For a particular + product received by a particular user, "normally used" refers to a + typical or common use of that class of product, regardless of the status + of the particular user or of the way in which the particular user + actually uses, or expects or is expected to use, the product. A product + is a consumer product regardless of whether the product has substantial + commercial, industrial or non-consumer uses, unless such uses represent + the only significant mode of use of the product. + + "Installation Information" for a User Product means any methods, + procedures, authorization keys, or other information required to install + and execute modified versions of a covered work in that User Product from + a modified version of its Corresponding Source. The information must + suffice to ensure that the continued functioning of the modified object + code is in no case prevented or interfered with solely because + modification has been made. + + If you convey an object code work under this section in, or with, or + specifically for use in, a User Product, and the conveying occurs as + part of a transaction in which the right of possession and use of the + User Product is transferred to the recipient in perpetuity or for a + fixed term (regardless of how the transaction is characterized), the + Corresponding Source conveyed under this section must be accompanied + by the Installation Information. But this requirement does not apply + if neither you nor any third party retains the ability to install + modified object code on the User Product (for example, the work has + been installed in ROM). + + The requirement to provide Installation Information does not include a + requirement to continue to provide support service, warranty, or updates + for a work that has been modified or installed by the recipient, or for + the User Product in which it has been modified or installed. Access to a + network may be denied when the modification itself materially and + adversely affects the operation of the network or violates the rules and + protocols for communication across the network. + + Corresponding Source conveyed, and Installation Information provided, + in accord with this section must be in a format that is publicly + documented (and with an implementation available to the public in + source code form), and must require no special password or key for + unpacking, reading or copying. + + 7. Additional Terms. + + "Additional permissions" are terms that supplement the terms of this + License by making exceptions from one or more of its conditions. + Additional permissions that are applicable to the entire Program shall + be treated as though they were included in this License, to the extent + that they are valid under applicable law. If additional permissions + apply only to part of the Program, that part may be used separately + under those permissions, but the entire Program remains governed by + this License without regard to the additional permissions. + + When you convey a copy of a covered work, you may at your option + remove any additional permissions from that copy, or from any part of + it. (Additional permissions may be written to require their own + removal in certain cases when you modify the work.) You may place + additional permissions on material, added by you to a covered work, + for which you have or can give appropriate copyright permission. + + Notwithstanding any other provision of this License, for material you + add to a covered work, you may (if authorized by the copyright holders of + that material) supplement the terms of this License with terms: + + a) Disclaiming warranty or limiting liability differently from the + terms of sections 15 and 16 of this License; or + + b) Requiring preservation of specified reasonable legal notices or + author attributions in that material or in the Appropriate Legal + Notices displayed by works containing it; or + + c) Prohibiting misrepresentation of the origin of that material, or + requiring that modified versions of such material be marked in + reasonable ways as different from the original version; or + + d) Limiting the use for publicity purposes of names of licensors or + authors of the material; or + + e) Declining to grant rights under trademark law for use of some + trade names, trademarks, or service marks; or + + f) Requiring indemnification of licensors and authors of that + material by anyone who conveys the material (or modified versions of + it) with contractual assumptions of liability to the recipient, for + any liability that these contractual assumptions directly impose on + those licensors and authors. + + All other non-permissive additional terms are considered "further + restrictions" within the meaning of section 10. If the Program as you + received it, or any part of it, contains a notice stating that it is + governed by this License along with a term that is a further + restriction, you may remove that term. If a license document contains + a further restriction but permits relicensing or conveying under this + License, you may add to a covered work material governed by the terms + of that license document, provided that the further restriction does + not survive such relicensing or conveying. + + If you add terms to a covered work in accord with this section, you + must place, in the relevant source files, a statement of the + additional terms that apply to those files, or a notice indicating + where to find the applicable terms. + + Additional terms, permissive or non-permissive, may be stated in the + form of a separately written license, or stated as exceptions; + the above requirements apply either way. + + 8. Termination. + + You may not propagate or modify a covered work except as expressly + provided under this License. Any attempt otherwise to propagate or + modify it is void, and will automatically terminate your rights under + this License (including any patent licenses granted under the third + paragraph of section 11). + + However, if you cease all violation of this License, then your + license from a particular copyright holder is reinstated (a) + provisionally, unless and until the copyright holder explicitly and + finally terminates your license, and (b) permanently, if the copyright + holder fails to notify you of the violation by some reasonable means + prior to 60 days after the cessation. + + Moreover, your license from a particular copyright holder is + reinstated permanently if the copyright holder notifies you of the + violation by some reasonable means, this is the first time you have + received notice of violation of this License (for any work) from that + copyright holder, and you cure the violation prior to 30 days after + your receipt of the notice. + + Termination of your rights under this section does not terminate the + licenses of parties who have received copies or rights from you under + this License. If your rights have been terminated and not permanently + reinstated, you do not qualify to receive new licenses for the same + material under section 10. + + 9. Acceptance Not Required for Having Copies. + + You are not required to accept this License in order to receive or + run a copy of the Program. Ancillary propagation of a covered work + occurring solely as a consequence of using peer-to-peer transmission + to receive a copy likewise does not require acceptance. However, + nothing other than this License grants you permission to propagate or + modify any covered work. These actions infringe copyright if you do + not accept this License. Therefore, by modifying or propagating a + covered work, you indicate your acceptance of this License to do so. + + 10. Automatic Licensing of Downstream Recipients. + + Each time you convey a covered work, the recipient automatically + receives a license from the original licensors, to run, modify and + propagate that work, subject to this License. You are not responsible + for enforcing compliance by third parties with this License. + + An "entity transaction" is a transaction transferring control of an + organization, or substantially all assets of one, or subdividing an + organization, or merging organizations. If propagation of a covered + work results from an entity transaction, each party to that + transaction who receives a copy of the work also receives whatever + licenses to the work the party's predecessor in interest had or could + give under the previous paragraph, plus a right to possession of the + Corresponding Source of the work from the predecessor in interest, if + the predecessor has it or can get it with reasonable efforts. + + You may not impose any further restrictions on the exercise of the + rights granted or affirmed under this License. For example, you may + not impose a license fee, royalty, or other charge for exercise of + rights granted under this License, and you may not initiate litigation + (including a cross-claim or counterclaim in a lawsuit) alleging that + any patent claim is infringed by making, using, selling, offering for + sale, or importing the Program or any portion of it. + + 11. Patents. + + A "contributor" is a copyright holder who authorizes use under this + License of the Program or a work on which the Program is based. The + work thus licensed is called the contributor's "contributor version". + + A contributor's "essential patent claims" are all patent claims + owned or controlled by the contributor, whether already acquired or + hereafter acquired, that would be infringed by some manner, permitted + by this License, of making, using, or selling its contributor version, + but do not include claims that would be infringed only as a + consequence of further modification of the contributor version. For + purposes of this definition, "control" includes the right to grant + patent sublicenses in a manner consistent with the requirements of + this License. + + Each contributor grants you a non-exclusive, worldwide, royalty-free + patent license under the contributor's essential patent claims, to + make, use, sell, offer for sale, import and otherwise run, modify and + propagate the contents of its contributor version. + + In the following three paragraphs, a "patent license" is any express + agreement or commitment, however denominated, not to enforce a patent + (such as an express permission to practice a patent or covenant not to + sue for patent infringement). To "grant" such a patent license to a + party means to make such an agreement or commitment not to enforce a + patent against the party. + + If you convey a covered work, knowingly relying on a patent license, + and the Corresponding Source of the work is not available for anyone + to copy, free of charge and under the terms of this License, through a + publicly available network server or other readily accessible means, + then you must either (1) cause the Corresponding Source to be so + available, or (2) arrange to deprive yourself of the benefit of the + patent license for this particular work, or (3) arrange, in a manner + consistent with the requirements of this License, to extend the patent + license to downstream recipients. "Knowingly relying" means you have + actual knowledge that, but for the patent license, your conveying the + covered work in a country, or your recipient's use of the covered work + in a country, would infringe one or more identifiable patents in that + country that you have reason to believe are valid. + + If, pursuant to or in connection with a single transaction or + arrangement, you convey, or propagate by procuring conveyance of, a + covered work, and grant a patent license to some of the parties + receiving the covered work authorizing them to use, propagate, modify + or convey a specific copy of the covered work, then the patent license + you grant is automatically extended to all recipients of the covered + work and works based on it. + + A patent license is "discriminatory" if it does not include within + the scope of its coverage, prohibits the exercise of, or is + conditioned on the non-exercise of one or more of the rights that are + specifically granted under this License. You may not convey a covered + work if you are a party to an arrangement with a third party that is + in the business of distributing software, under which you make payment + to the third party based on the extent of your activity of conveying + the work, and under which the third party grants, to any of the + parties who would receive the covered work from you, a discriminatory + patent license (a) in connection with copies of the covered work + conveyed by you (or copies made from those copies), or (b) primarily + for and in connection with specific products or compilations that + contain the covered work, unless you entered into that arrangement, + or that patent license was granted, prior to 28 March 2007. + + Nothing in this License shall be construed as excluding or limiting + any implied license or other defenses to infringement that may + otherwise be available to you under applicable patent law. + + 12. No Surrender of Others' Freedom. + + If conditions are imposed on you (whether by court order, agreement or + otherwise) that contradict the conditions of this License, they do not + excuse you from the conditions of this License. If you cannot convey a + covered work so as to satisfy simultaneously your obligations under this + License and any other pertinent obligations, then as a consequence you may + not convey it at all. For example, if you agree to terms that obligate you + to collect a royalty for further conveying from those to whom you convey + the Program, the only way you could satisfy both those terms and this + License would be to refrain entirely from conveying the Program. + + 13. Use with the GNU Affero General Public License. + + Notwithstanding any other provision of this License, you have + permission to link or combine any covered work with a work licensed + under version 3 of the GNU Affero General Public License into a single + combined work, and to convey the resulting work. The terms of this + License will continue to apply to the part which is the covered work, + but the special requirements of the GNU Affero General Public License, + section 13, concerning interaction through a network will apply to the + combination as such. + + 14. Revised Versions of this License. + + The Free Software Foundation may publish revised and/or new versions of + the GNU General Public License from time to time. Such new versions will + be similar in spirit to the present version, but may differ in detail to + address new problems or concerns. + + Each version is given a distinguishing version number. If the + Program specifies that a certain numbered version of the GNU General + Public License "or any later version" applies to it, you have the + option of following the terms and conditions either of that numbered + version or of any later version published by the Free Software + Foundation. If the Program does not specify a version number of the + GNU General Public License, you may choose any version ever published + by the Free Software Foundation. + + If the Program specifies that a proxy can decide which future + versions of the GNU General Public License can be used, that proxy's + public statement of acceptance of a version permanently authorizes you + to choose that version for the Program. + + Later license versions may give you additional or different + permissions. However, no additional obligations are imposed on any + author or copyright holder as a result of your choosing to follow a + later version. + + 15. Disclaimer of Warranty. + + THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY + APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT + HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY + OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, + THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM + IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF + ALL NECESSARY SERVICING, REPAIR OR CORRECTION. + + 16. Limitation of Liability. + + IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING + WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS + THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY + GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE + USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF + DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD + PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), + EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF + SUCH DAMAGES. + + 17. Interpretation of Sections 15 and 16. + + If the disclaimer of warranty and limitation of liability provided + above cannot be given local legal effect according to their terms, + reviewing courts shall apply local law that most closely approximates + an absolute waiver of all civil liability in connection with the + Program, unless a warranty or assumption of liability accompanies a + copy of the Program in return for a fee. + + END OF TERMS AND CONDITIONS + + How to Apply These Terms to Your New Programs + + If you develop a new program, and you want it to be of the greatest + possible use to the public, the best way to achieve this is to make it + free software which everyone can redistribute and change under these terms. + + To do so, attach the following notices to the program. It is safest + to attach them to the start of each source file to most effectively + state the exclusion of warranty; and each file should have at least + the "copyright" line and a pointer to where the full notice is found. + + + Copyright (C) + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . + + Also add information on how to contact you by electronic and paper mail. + + If the program does terminal interaction, make it output a short + notice like this when it starts in an interactive mode: + + Copyright (C) + This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'. + This is free software, and you are welcome to redistribute it + under certain conditions; type `show c' for details. + + The hypothetical commands `show w' and `show c' should show the appropriate + parts of the General Public License. Of course, your program's commands + might be different; for a GUI interface, you would use an "about box". + + You should also get your employer (if you work as a programmer) or school, + if any, to sign a "copyright disclaimer" for the program, if necessary. + For more information on this, and how to apply and follow the GNU GPL, see + . + + The GNU General Public License does not permit incorporating your program + into proprietary programs. If your program is a subroutine library, you + may consider it more useful to permit linking proprietary applications with + the library. If this is what you want to do, use the GNU Lesser General + Public License instead of this License. But first, please read + . + + Name: libquadmath + Files: numpy/.dylibs/libquadmath*.so + Description: dynamically linked to files compiled with gcc + Availability: https://gcc.gnu.org/git/?p=gcc.git;a=tree;f=libquadmath + License: LGPL-2.1-or-later + + GCC Quad-Precision Math Library + Copyright (C) 2010-2019 Free Software Foundation, Inc. + Written by Francois-Xavier Coudert + + This file is part of the libquadmath library. + Libquadmath is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + Libquadmath is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + https://www.gnu.org/licenses/old-licenses/lgpl-2.1.html + +Classifier: Development Status :: 5 - Production/Stable +Classifier: Intended Audience :: Science/Research +Classifier: Intended Audience :: Developers +Classifier: License :: OSI Approved :: BSD License +Classifier: Programming Language :: C +Classifier: Programming Language :: Python +Classifier: Programming Language :: Python :: 3 +Classifier: Programming Language :: Python :: 3.10 +Classifier: Programming Language :: Python :: 3.11 +Classifier: Programming Language :: Python :: 3.12 +Classifier: Programming Language :: Python :: 3.13 +Classifier: Programming Language :: Python :: 3 :: Only +Classifier: Programming Language :: Python :: Implementation :: CPython +Classifier: Topic :: Software Development +Classifier: Topic :: Scientific/Engineering +Classifier: Typing :: Typed +Classifier: Operating System :: Microsoft :: Windows +Classifier: Operating System :: POSIX +Classifier: Operating System :: Unix +Classifier: Operating System :: MacOS +Project-URL: homepage, https://numpy.org +Project-URL: documentation, https://numpy.org/doc/ +Project-URL: source, https://github.com/numpy/numpy +Project-URL: download, https://pypi.org/project/numpy/#files +Project-URL: tracker, https://github.com/numpy/numpy/issues +Project-URL: release notes, https://numpy.org/doc/stable/release +Requires-Python: >=3.10 +Description-Content-Type: text/markdown + +

+ +


+ + +[![Powered by NumFOCUS](https://img.shields.io/badge/powered%20by-NumFOCUS-orange.svg?style=flat&colorA=E1523D&colorB=007D8A)]( +https://numfocus.org) +[![PyPI Downloads](https://img.shields.io/pypi/dm/numpy.svg?label=PyPI%20downloads)]( +https://pypi.org/project/numpy/) +[![Conda Downloads](https://img.shields.io/conda/dn/conda-forge/numpy.svg?label=Conda%20downloads)]( +https://anaconda.org/conda-forge/numpy) +[![Stack Overflow](https://img.shields.io/badge/stackoverflow-Ask%20questions-blue.svg)]( +https://stackoverflow.com/questions/tagged/numpy) +[![Nature Paper](https://img.shields.io/badge/DOI-10.1038%2Fs41586--020--2649--2-blue)]( +https://doi.org/10.1038/s41586-020-2649-2) +[![OpenSSF Scorecard](https://api.securityscorecards.dev/projects/github.com/numpy/numpy/badge)](https://securityscorecards.dev/viewer/?uri=github.com/numpy/numpy) + + +NumPy is the fundamental package for scientific computing with Python. + +- **Website:** https://www.numpy.org +- **Documentation:** https://numpy.org/doc +- **Mailing list:** https://mail.python.org/mailman/listinfo/numpy-discussion +- **Source code:** https://github.com/numpy/numpy +- **Contributing:** https://www.numpy.org/devdocs/dev/index.html +- **Bug reports:** https://github.com/numpy/numpy/issues +- **Report a security vulnerability:** https://tidelift.com/docs/security + +It provides: + +- a powerful N-dimensional array object +- sophisticated (broadcasting) functions +- tools for integrating C/C++ and Fortran code +- useful linear algebra, Fourier transform, and random number capabilities + +Testing: + +NumPy requires `pytest` and `hypothesis`. Tests can then be run after installation with: + + python -c "import numpy, sys; sys.exit(numpy.test() is False)" + +Code of Conduct +---------------------- + +NumPy is a community-driven open source project developed by a diverse group of +[contributors](https://numpy.org/teams/). The NumPy leadership has made a strong +commitment to creating an open, inclusive, and positive community. Please read the +[NumPy Code of Conduct](https://numpy.org/code-of-conduct/) for guidance on how to interact +with others in a way that makes our community thrive. + +Call for Contributions +---------------------- + +The NumPy project welcomes your expertise and enthusiasm! + +Small improvements or fixes are always appreciated. If you are considering larger contributions +to the source code, please contact us through the [mailing +list](https://mail.python.org/mailman/listinfo/numpy-discussion) first. + +Writing code isn’t the only way to contribute to NumPy. You can also: +- review pull requests +- help us stay on top of new and old issues +- develop tutorials, presentations, and other educational materials +- maintain and improve [our website](https://github.com/numpy/numpy.org) +- develop graphic design for our brand assets and promotional materials +- translate website content +- help with outreach and onboard new contributors +- write grant proposals and help with other fundraising efforts + +For more information about the ways you can contribute to NumPy, visit [our website](https://numpy.org/contribute/). +If you’re unsure where to start or how your skills fit in, reach out! You can +ask on the mailing list or here, on GitHub, by opening a new issue or leaving a +comment on a relevant issue that is already open. + +Our preferred channels of communication are all public, but if you’d like to +speak to us in private first, contact our community coordinators at +numpy-team@googlegroups.com or on Slack (write numpy-team@googlegroups.com for +an invitation). + +We also have a biweekly community call, details of which are announced on the +mailing list. You are very welcome to join. + +If you are new to contributing to open source, [this +guide](https://opensource.guide/how-to-contribute/) helps explain why, what, +and how to successfully get involved. diff --git a/venv/lib/python3.12/site-packages/numpy-2.1.3.dist-info/RECORD b/venv/lib/python3.12/site-packages/numpy-2.1.3.dist-info/RECORD new file mode 100644 index 00000000..c3417686 --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy-2.1.3.dist-info/RECORD @@ -0,0 +1,1225 @@ +../../../bin/f2py,sha256=n_lFRTTcOUiEBzPGEEMhQZG3H5Qti3wyPHF0PVrjNjg,265 +../../../bin/numpy-config,sha256=v2qKs7oaK0Bdb1Q3DNW-fjrx4CFUcEyphMm9vBZ-VHc,265 +numpy-2.1.3.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4 +numpy-2.1.3.dist-info/LICENSE.txt,sha256=tK5iiH9N1ulDCxqNcBejuoTF16pjC50X7W8lwhsOxbQ,47786 +numpy-2.1.3.dist-info/METADATA,sha256=VvADxEsO6Y1q2xy0nyktLvB9qqt8e6QJqyZ5yEb-a_g,62048 +numpy-2.1.3.dist-info/RECORD,, +numpy-2.1.3.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +numpy-2.1.3.dist-info/WHEEL,sha256=ySBagz5FwlI-5j9-I-4JmuCo9M5S9b0JoHIId2xKGes,93 +numpy-2.1.3.dist-info/entry_points.txt,sha256=4mXDNhJDQ9GHqMBeRJ8B3PlixTFmkXGqU3RVuac20q0,172 +numpy/__config__.py,sha256=BZU8-1AuF_I5f3wQalfQaj9JFf2RomP64zZF3gAlEu8,4718 +numpy/__init__.cython-30.pxd,sha256=2q-p82Z36yscZNHW1FDTo7DELx6wv06_kaX-HtvnApM,45784 +numpy/__init__.pxd,sha256=uEqFZ3kgTA7uKP-67XAj4410tQ6ZfHxuy5mnWTx_2zI,42418 +numpy/__init__.py,sha256=OcQtsCdUj5WOCW6Lq-P6Dj53PSSqOetjY_wOOrvsNLE,22007 +numpy/__init__.pyi,sha256=2sZwIRwaCQeU1UFPI8mBrMKeYkxj3HNSdR2pIt-eyz0,150455 +numpy/__pycache__/__config__.cpython-312.pyc,, +numpy/__pycache__/__init__.cpython-312.pyc,, +numpy/__pycache__/_array_api_info.cpython-312.pyc,, +numpy/__pycache__/_configtool.cpython-312.pyc,, +numpy/__pycache__/_distributor_init.cpython-312.pyc,, +numpy/__pycache__/_expired_attrs_2_0.cpython-312.pyc,, +numpy/__pycache__/_globals.cpython-312.pyc,, +numpy/__pycache__/_pytesttester.cpython-312.pyc,, +numpy/__pycache__/conftest.cpython-312.pyc,, +numpy/__pycache__/ctypeslib.cpython-312.pyc,, +numpy/__pycache__/dtypes.cpython-312.pyc,, +numpy/__pycache__/exceptions.cpython-312.pyc,, +numpy/__pycache__/matlib.cpython-312.pyc,, +numpy/__pycache__/version.cpython-312.pyc,, +numpy/_array_api_info.py,sha256=qiHJDVG58rAk1iTlXsFrnhZ7Y-ghPUkyBpJiMvPK2jg,10381 +numpy/_array_api_info.pyi,sha256=4BzgW4K9n_ZNxeY-Htyr1QohEPvAENeoD6WUrUN0_pM,5025 +numpy/_configtool.py,sha256=asiPfz_TX2Dp0msoNjG43pZKRYgNYusSIg2ieczK8as,1007 +numpy/_core/__init__.py,sha256=H95-zST0CH6pnnObjXUXXiPgtub9M35IBGaYE-q4wrU,5612 +numpy/_core/__init__.pyi,sha256=Mj2I4BtqBVNUZVs5o1T58Z7wSaWjfhX0nCl-a0ULjgA,86 +numpy/_core/__pycache__/__init__.cpython-312.pyc,, +numpy/_core/__pycache__/_add_newdocs.cpython-312.pyc,, +numpy/_core/__pycache__/_add_newdocs_scalars.cpython-312.pyc,, +numpy/_core/__pycache__/_asarray.cpython-312.pyc,, +numpy/_core/__pycache__/_dtype.cpython-312.pyc,, +numpy/_core/__pycache__/_dtype_ctypes.cpython-312.pyc,, +numpy/_core/__pycache__/_exceptions.cpython-312.pyc,, +numpy/_core/__pycache__/_internal.cpython-312.pyc,, +numpy/_core/__pycache__/_machar.cpython-312.pyc,, +numpy/_core/__pycache__/_methods.cpython-312.pyc,, +numpy/_core/__pycache__/_string_helpers.cpython-312.pyc,, +numpy/_core/__pycache__/_type_aliases.cpython-312.pyc,, +numpy/_core/__pycache__/_ufunc_config.cpython-312.pyc,, +numpy/_core/__pycache__/arrayprint.cpython-312.pyc,, +numpy/_core/__pycache__/cversions.cpython-312.pyc,, +numpy/_core/__pycache__/defchararray.cpython-312.pyc,, +numpy/_core/__pycache__/einsumfunc.cpython-312.pyc,, +numpy/_core/__pycache__/fromnumeric.cpython-312.pyc,, +numpy/_core/__pycache__/function_base.cpython-312.pyc,, +numpy/_core/__pycache__/getlimits.cpython-312.pyc,, +numpy/_core/__pycache__/memmap.cpython-312.pyc,, +numpy/_core/__pycache__/multiarray.cpython-312.pyc,, +numpy/_core/__pycache__/numeric.cpython-312.pyc,, +numpy/_core/__pycache__/numerictypes.cpython-312.pyc,, +numpy/_core/__pycache__/overrides.cpython-312.pyc,, +numpy/_core/__pycache__/printoptions.cpython-312.pyc,, +numpy/_core/__pycache__/records.cpython-312.pyc,, +numpy/_core/__pycache__/shape_base.cpython-312.pyc,, +numpy/_core/__pycache__/strings.cpython-312.pyc,, +numpy/_core/__pycache__/umath.cpython-312.pyc,, +numpy/_core/_add_newdocs.py,sha256=SxbBrYFDlenUqTgO9QNHV9bhWwISlP0BvfWnr0hhcf0,211380 +numpy/_core/_add_newdocs_scalars.py,sha256=99L7x4iLLYNeVQmiqik-NgEFzwNxD8gnKRkaynze-nY,12613 +numpy/_core/_asarray.py,sha256=qHfjtg7BDT29rG_AJsqRhyBV16UF3WL7xgDVPuYHb8w,3910 +numpy/_core/_asarray.pyi,sha256=UgVEqBCv5MbJkXSYsVoG6a_4ARTIoKHeeouyG0LPMH8,1041 +numpy/_core/_dtype.py,sha256=4Pz6KJQJRywlsMhdH8NbIugziDyQi1ekv2ZMw7zomzo,10734 +numpy/_core/_dtype_ctypes.py,sha256=dcZHQ46qjV0n7l934WIYw7kv-1HoHxelu50oIIX7GWU,3718 +numpy/_core/_exceptions.py,sha256=dZWKqfdLRvJvbAEG_fof_8ikEKxjakADMty1kLC_l_M,5379 +numpy/_core/_internal.py,sha256=B8t6mxvaDouxE-COR010v4_PUHNzOF8mHgFatRPlJWk,29164 +numpy/_core/_internal.pyi,sha256=06EhTNYJ7HUtuV-oFz14OijSOCkT8f71-qBc7GOrCGk,1022 +numpy/_core/_machar.py,sha256=ZGDDdOxsfa2JBZdWcRpUAFHZPAC2nAQnjqceiY7bWjg,11566 +numpy/_core/_methods.py,sha256=EemMgHPaeXhYegA6kGOVpka6psheHyq8NbII4nGprxk,9655 +numpy/_core/_multiarray_tests.cpython-312-darwin.so,sha256=kauF_gKbCzeVlmIS-cJut-mMhum_OJyIcJ9z0eO7NEg,120408 +numpy/_core/_multiarray_umath.cpython-312-darwin.so,sha256=StaKPVWwkINYGYr2gQOcQ9ZDCjDnVUlrdxcUbP4y5n4,3328216 +numpy/_core/_operand_flag_tests.cpython-312-darwin.so,sha256=kTg6R2tFqUWzNUDHC6dPg8r3JopspxipSJs58h2IJjs,51240 +numpy/_core/_rational_tests.cpython-312-darwin.so,sha256=ZWqOAlrsxnBSCMBm5I--po2WH8ZuR7SGlCA6SQszMec,72792 +numpy/_core/_simd.cpython-312-darwin.so,sha256=N636zRcXKR2Ly_UQnRnufskSOTJQdYntxe5V89XUZHo,339592 +numpy/_core/_string_helpers.py,sha256=gu3x0dEnRnh3mnOkviX17r8rCmagVgYHfxILt9Q9irA,2837 +numpy/_core/_struct_ufunc_tests.cpython-312-darwin.so,sha256=I-2RBddxXuQ5Wbwv7EqfJmks-mJCgJj2VSrhse9CnII,51480 +numpy/_core/_type_aliases.py,sha256=3MfPJXIhE0-Gxsmw3HZTlLgulAY9lowvyrjjzzxY77Y,3493 +numpy/_core/_type_aliases.pyi,sha256=pQ0FXzLol6L7XATTBfrbpNwEay-P0cl2DZVYqM43o7E,70 +numpy/_core/_ufunc_config.py,sha256=nIrlf66xV1h9WMM4mNs9k268ljZyy-bGTuo0_OBSsMc,15577 +numpy/_core/_ufunc_config.pyi,sha256=-615enOVQMBhVx7Pln7DY_s4H6JjSgSnBy89YkpvuLg,1066 +numpy/_core/_umath_tests.cpython-312-darwin.so,sha256=HM6vYw_UCbIA9bWHnQUHaiEh1OIytGm7wN9NDFxsWOw,71712 +numpy/_core/arrayprint.py,sha256=4pgm3ik6GXLsl3e8hYbvjVp3wMRLQ9g7xz4E1P_CJ5I,64286 +numpy/_core/arrayprint.pyi,sha256=X057JuO_ZrmXRkDnbIHW_Yefnu76wQukCs5YoErB3SY,4298 +numpy/_core/cversions.py,sha256=H_iNIpx9-hY1cQNxqjT2d_5SXZhJbMo_caq4_q6LB7I,347 +numpy/_core/defchararray.py,sha256=WL-Q0swlMo0Lbl3TRNaKyozEijhNdZq568HtEe1KRk8,37508 +numpy/_core/defchararray.pyi,sha256=RpuCpG59ykbW_fze6TZDvmC5VhN43-3hac6DnTLmDLg,19812 +numpy/_core/einsumfunc.py,sha256=066W9VApLUi5TL22tRYT3729fdY0KqAdudtiY18d5nc,52921 +numpy/_core/einsumfunc.pyi,sha256=Ai7745UQf8-oZgrDod9z2NMj8BrDNJYzJWTltSDZd5Q,4821 +numpy/_core/fromnumeric.py,sha256=DA7ghaA06vZ-rlJgsb8avGwoJe3eaJdKPGQuHwdIG40,144225 +numpy/_core/fromnumeric.pyi,sha256=U_dlNA1xuGOgFPkccPgVY-L8JC-wjvtVOElLULKIhC0,28362 +numpy/_core/function_base.py,sha256=FHE1Wt8YjmXHEtRwgLe-Xyy-CToe2FLIbLEcmoCpvS8,20026 +numpy/_core/function_base.pyi,sha256=lMuu0qyK6IHl17CSdDxK7o6TTDYTvfNfd14GLe2Zv8Y,5021 +numpy/_core/getlimits.py,sha256=FS5i6vxu8Snq3173Q4VhVcGY_ygZYIam6m8gpwxKawQ,25985 +numpy/_core/getlimits.pyi,sha256=qeIXUEtognTHr_T-tv-VcZI7n8Z2VzAyIpIgKXzsLkc,82 +numpy/_core/include/numpy/__multiarray_api.c,sha256=u7HxPIx7xdxAPTE0gristUOO0-1L-_fl0IeKqR4voxI,12669 +numpy/_core/include/numpy/__multiarray_api.h,sha256=akdAXdNQvHxPFPbdeobhoGzyLUkoVdwzKDjzdbtk5zQ,61383 +numpy/_core/include/numpy/__ufunc_api.c,sha256=Fg7WlH4Ow6jETKRArVL_QF11ABKYz1VpOve56_U3E0w,1755 +numpy/_core/include/numpy/__ufunc_api.h,sha256=tayZuDCeuqm3ggFvWxJuoARz5obz6Saas9L7JcKO_eQ,13166 +numpy/_core/include/numpy/_neighborhood_iterator_imp.h,sha256=s-Hw_l5WRwKtYvsiIghF0bg-mA_CgWnzFFOYVFJ-q4k,1857 +numpy/_core/include/numpy/_numpyconfig.h,sha256=MuJjpqwVFBqqHattoyPQTYDFFMTdcwWaTWZVR8u8Nio,928 +numpy/_core/include/numpy/_public_dtype_api_table.h,sha256=n6_Kb98SyvsR_X7stiNA6VuGp_c5W1e4fMVcJdO0wis,4574 +numpy/_core/include/numpy/arrayobject.h,sha256=mU5vpcQ95PH1j3bp8KYhJOFHB-GxwRjSUsR7nxlTSRk,204 +numpy/_core/include/numpy/arrayscalars.h,sha256=LlyrZIa_5td11BfqfMCv1hYbiG6__zxxGv1MRj8uIVo,4243 +numpy/_core/include/numpy/dtype_api.h,sha256=nCsBY26NtXTFaglc-2Jekmsuws6rmaLi9hhYZjN_pw8,19192 +numpy/_core/include/numpy/halffloat.h,sha256=TRZfXgipa-dFppX2uNgkrjrPli-1BfJtadWjAembJ4s,1959 +numpy/_core/include/numpy/ndarrayobject.h,sha256=MnykWmchyS05ler_ZyhFIr_0j6c0IcndEi3X3n0ZWDk,12057 +numpy/_core/include/numpy/ndarraytypes.h,sha256=Ll-jCTQ3zMkZQzLCXNNRtGRxSq-TQRw6mUxos6MTzlw,64951 +numpy/_core/include/numpy/npy_1_7_deprecated_api.h,sha256=90kGcNaBPgT5FJArB_MPgW24_Mpl5RcfUR3Y0rRB5Bw,3746 +numpy/_core/include/numpy/npy_2_compat.h,sha256=wdjB7_-AtW3op67Xbj3EVH6apSF7cRG6h3c5hBz-YMs,8546 +numpy/_core/include/numpy/npy_2_complexcompat.h,sha256=eE9dV_Iq3jEfGGJFH_pQjJnvC6eQ12WgOB7cZMmHByE,857 +numpy/_core/include/numpy/npy_3kcompat.h,sha256=grN6W1n7benj3F2pSAOpl_s6vn1Y50QfAP-DaleD7cA,9648 +numpy/_core/include/numpy/npy_common.h,sha256=wbV1Z6m3w1h4qVcOxfF38s3H13UfFHEuBGRfDhTeUKE,36551 +numpy/_core/include/numpy/npy_cpu.h,sha256=pcVRtj-Y6120C5kWB1VAiAjZoxkTPDEg0gGm5IAt3jM,4629 +numpy/_core/include/numpy/npy_endian.h,sha256=we7X9fPeWzNpo_YTh09MPGDwdE0Rw_WDM4c9y4nBj5I,2786 +numpy/_core/include/numpy/npy_math.h,sha256=YoJBuiXRXnq0_1tZ-EGvTcVP3DWUV_QZc3JRJs-Kx-k,18890 +numpy/_core/include/numpy/npy_no_deprecated_api.h,sha256=0yZrJcQEJ6MCHJInQk5TP9_qZ4t7EfBuoLOJ34IlJd4,678 +numpy/_core/include/numpy/npy_os.h,sha256=hlQsg_7-RkvS3s8OM8KXy99xxyJbCm-W1AYVcdnO1cw,1256 +numpy/_core/include/numpy/numpyconfig.h,sha256=OvRlre4eb9KBWt6gAE5cQ4K-P2uRmIKU1rAKxWFygmA,7161 +numpy/_core/include/numpy/random/LICENSE.txt,sha256=-8U59H0M-DvGE3gID7hz1cFGMBJsrL_nVANcOSbapew,1018 +numpy/_core/include/numpy/random/bitgen.h,sha256=49AwKOR552r-NkhuSOF1usb_URiMSRMvD22JF5pKIng,488 +numpy/_core/include/numpy/random/distributions.h,sha256=W5tOyETd0m1W0GdaZ5dJP8fKlBtsTpG23V2Zlmrlqpg,9861 +numpy/_core/include/numpy/random/libdivide.h,sha256=ew9MNhPQd1LsCZiWiFmj9IZ7yOnA3HKOXffDeR9X1jw,80138 +numpy/_core/include/numpy/ufuncobject.h,sha256=cgEIXDsLhdY55HxNK9i4BAVrq4Q2LQ1WRZ8PCvsY-hQ,11911 +numpy/_core/include/numpy/utils.h,sha256=wMNomSH3Dfj0q78PrjLVtFtN-FPo7UJ4o0ifCUO-6Es,1185 +numpy/_core/lib/libnpymath.a,sha256=Q2Ym1dUdHvSeUg2U5aQ_d1oAs07-GNKtRoZ57KqtUyU,35240 +numpy/_core/lib/npy-pkg-config/mlib.ini,sha256=_LsWV1eStNqwhdiYPa2538GL46dnfVwT4MrI1zbsoFw,147 +numpy/_core/lib/npy-pkg-config/npymath.ini,sha256=0iMzarBfkkZ_EXO95_kz-SHZRcNIEwIeOjE_esVBkRQ,361 +numpy/_core/lib/pkgconfig/numpy.pc,sha256=jflW6SYfGuV3RcNbLPxoCSLGsT5MetvH4QvOnDXY7HQ,191 +numpy/_core/memmap.py,sha256=5CDRv-7BkIla30Hox-VCM411JVSV9axG5fRc-3S94IM,12211 +numpy/_core/memmap.pyi,sha256=sxIQ7T5hPLG-RBNndAc8JPvrsKEX1amBSH2HGg48Obo,55 +numpy/_core/multiarray.py,sha256=YPRRXD7gK8_ZMNFFwQpG7o7uX3d40uyJjrhKv3rDsnc,57646 +numpy/_core/multiarray.pyi,sha256=SgwPTH-HjURp_Q5dautihGPiZaUB4F9_Ee2-mj-jGbk,26510 +numpy/_core/numeric.py,sha256=cdV8daLwmQY3MnqjEhvt959caY6-rNzSV-uAnB5RU0Y,81825 +numpy/_core/numeric.pyi,sha256=-Vg0Au46q_CRcFhQP6aKnXdrtTIu7Z9cg5Cc_qFPHXU,15313 +numpy/_core/numerictypes.py,sha256=7JwlBGlxoiIMZ2td4JD8bo7jIjL7sc1LgR5WFBWEc5w,16113 +numpy/_core/numerictypes.pyi,sha256=4BLrwt9_YHKJydksp09ZFVI3IpFPkDNeTTPRtlpmt-4,1680 +numpy/_core/overrides.py,sha256=uq6llUwm2-tnF4FNrEHoQ09aoqbo_Xf-WNj4Z1coPK0,7094 +numpy/_core/printoptions.py,sha256=FUY--hG0-oobvtHOY64D50Bs_-JFmf-Nza7C9IXORFY,1063 +numpy/_core/records.py,sha256=xvHJmb2JuJS8W7au5BvM--CI1jnANg-dxJbUzHSULok,36867 +numpy/_core/records.pyi,sha256=M1XTqfVc_fH5m_ya8kUBYLChgXNfi_tI9fsoa1TYDA0,8774 +numpy/_core/shape_base.py,sha256=JGQ0m-v3z-vTJ6Nw4cETtIh7q3ZbiTn32Dc7wIwm8vA,32429 +numpy/_core/shape_base.pyi,sha256=grYlKtPWTZnhtysCSiXcD-XtUB8zC6jRHshKZwtB3VE,3031 +numpy/_core/strings.py,sha256=u5-8OqFaRSYNDPMQWC4AEHPvpFDWSuWSZlz7DR-J-iE,44229 +numpy/_core/strings.pyi,sha256=qv0ms8Nj9nrTQ5d6qzfEaU-g490jX3TKXvxJZXzTwNw,7520 +numpy/_core/tests/__pycache__/_locales.cpython-312.pyc,, +numpy/_core/tests/__pycache__/_natype.cpython-312.pyc,, +numpy/_core/tests/__pycache__/test__exceptions.cpython-312.pyc,, +numpy/_core/tests/__pycache__/test_abc.cpython-312.pyc,, +numpy/_core/tests/__pycache__/test_api.cpython-312.pyc,, +numpy/_core/tests/__pycache__/test_argparse.cpython-312.pyc,, +numpy/_core/tests/__pycache__/test_array_api_info.cpython-312.pyc,, +numpy/_core/tests/__pycache__/test_array_coercion.cpython-312.pyc,, +numpy/_core/tests/__pycache__/test_array_interface.cpython-312.pyc,, +numpy/_core/tests/__pycache__/test_arraymethod.cpython-312.pyc,, +numpy/_core/tests/__pycache__/test_arrayobject.cpython-312.pyc,, +numpy/_core/tests/__pycache__/test_arrayprint.cpython-312.pyc,, +numpy/_core/tests/__pycache__/test_casting_floatingpoint_errors.cpython-312.pyc,, +numpy/_core/tests/__pycache__/test_casting_unittests.cpython-312.pyc,, +numpy/_core/tests/__pycache__/test_conversion_utils.cpython-312.pyc,, +numpy/_core/tests/__pycache__/test_cpu_dispatcher.cpython-312.pyc,, +numpy/_core/tests/__pycache__/test_cpu_features.cpython-312.pyc,, +numpy/_core/tests/__pycache__/test_custom_dtypes.cpython-312.pyc,, +numpy/_core/tests/__pycache__/test_cython.cpython-312.pyc,, +numpy/_core/tests/__pycache__/test_datetime.cpython-312.pyc,, +numpy/_core/tests/__pycache__/test_defchararray.cpython-312.pyc,, +numpy/_core/tests/__pycache__/test_deprecations.cpython-312.pyc,, +numpy/_core/tests/__pycache__/test_dlpack.cpython-312.pyc,, +numpy/_core/tests/__pycache__/test_dtype.cpython-312.pyc,, +numpy/_core/tests/__pycache__/test_einsum.cpython-312.pyc,, +numpy/_core/tests/__pycache__/test_errstate.cpython-312.pyc,, +numpy/_core/tests/__pycache__/test_extint128.cpython-312.pyc,, +numpy/_core/tests/__pycache__/test_function_base.cpython-312.pyc,, +numpy/_core/tests/__pycache__/test_getlimits.cpython-312.pyc,, +numpy/_core/tests/__pycache__/test_half.cpython-312.pyc,, +numpy/_core/tests/__pycache__/test_hashtable.cpython-312.pyc,, +numpy/_core/tests/__pycache__/test_indexerrors.cpython-312.pyc,, +numpy/_core/tests/__pycache__/test_indexing.cpython-312.pyc,, +numpy/_core/tests/__pycache__/test_item_selection.cpython-312.pyc,, +numpy/_core/tests/__pycache__/test_limited_api.cpython-312.pyc,, +numpy/_core/tests/__pycache__/test_longdouble.cpython-312.pyc,, +numpy/_core/tests/__pycache__/test_machar.cpython-312.pyc,, +numpy/_core/tests/__pycache__/test_mem_overlap.cpython-312.pyc,, +numpy/_core/tests/__pycache__/test_mem_policy.cpython-312.pyc,, +numpy/_core/tests/__pycache__/test_memmap.cpython-312.pyc,, +numpy/_core/tests/__pycache__/test_multiarray.cpython-312.pyc,, +numpy/_core/tests/__pycache__/test_multithreading.cpython-312.pyc,, +numpy/_core/tests/__pycache__/test_nditer.cpython-312.pyc,, +numpy/_core/tests/__pycache__/test_nep50_promotions.cpython-312.pyc,, +numpy/_core/tests/__pycache__/test_numeric.cpython-312.pyc,, +numpy/_core/tests/__pycache__/test_numerictypes.cpython-312.pyc,, +numpy/_core/tests/__pycache__/test_overrides.cpython-312.pyc,, +numpy/_core/tests/__pycache__/test_print.cpython-312.pyc,, +numpy/_core/tests/__pycache__/test_protocols.cpython-312.pyc,, +numpy/_core/tests/__pycache__/test_records.cpython-312.pyc,, +numpy/_core/tests/__pycache__/test_regression.cpython-312.pyc,, +numpy/_core/tests/__pycache__/test_scalar_ctors.cpython-312.pyc,, +numpy/_core/tests/__pycache__/test_scalar_methods.cpython-312.pyc,, +numpy/_core/tests/__pycache__/test_scalarbuffer.cpython-312.pyc,, +numpy/_core/tests/__pycache__/test_scalarinherit.cpython-312.pyc,, +numpy/_core/tests/__pycache__/test_scalarmath.cpython-312.pyc,, +numpy/_core/tests/__pycache__/test_scalarprint.cpython-312.pyc,, +numpy/_core/tests/__pycache__/test_shape_base.cpython-312.pyc,, +numpy/_core/tests/__pycache__/test_simd.cpython-312.pyc,, +numpy/_core/tests/__pycache__/test_simd_module.cpython-312.pyc,, +numpy/_core/tests/__pycache__/test_stringdtype.cpython-312.pyc,, +numpy/_core/tests/__pycache__/test_strings.cpython-312.pyc,, +numpy/_core/tests/__pycache__/test_ufunc.cpython-312.pyc,, +numpy/_core/tests/__pycache__/test_umath.cpython-312.pyc,, +numpy/_core/tests/__pycache__/test_umath_accuracy.cpython-312.pyc,, +numpy/_core/tests/__pycache__/test_umath_complex.cpython-312.pyc,, +numpy/_core/tests/__pycache__/test_unicode.cpython-312.pyc,, +numpy/_core/tests/_locales.py,sha256=S4x5soqF0oxpBYOE8J9Iky72O9J25IiZ8349m93pWC4,2206 +numpy/_core/tests/_natype.py,sha256=9N-pE9LuQKrqT7ef-P9mtXpWls3YAsZ8JR-3cR7TRjs,6259 +numpy/_core/tests/data/astype_copy.pkl,sha256=lWSzCcvzRB_wpuRGj92spGIw-rNPFcd9hwJaRVvfWdk,716 +numpy/_core/tests/data/generate_umath_validation_data.cpp,sha256=BQakB5o8Mq60zex5ovVO0IatNa7xbF8JvXmtk6373So,5842 +numpy/_core/tests/data/recarray_from_file.fits,sha256=NA0kliz31FlLnYxv3ppzeruONqNYkuEvts5wzXEeIc4,8640 +numpy/_core/tests/data/umath-validation-set-README.txt,sha256=pxWwOaGGahaRd-AlAidDfocLyrAiDp0whf5hC7hYwqM,967 +numpy/_core/tests/data/umath-validation-set-arccos.csv,sha256=yBlz8r6RnnAYhdlobzGGo2FKY-DoSTQaP26y8138a3I,61365 +numpy/_core/tests/data/umath-validation-set-arccosh.csv,sha256=0GXe7XG1Z3jXAcK-OlEot_Df3MetDQSlbm3MJ__iMQk,61365 +numpy/_core/tests/data/umath-validation-set-arcsin.csv,sha256=w_Sv2NDn-mLZSAqb56JT2g4bqBzxYAihedWxHuf82uU,61339 +numpy/_core/tests/data/umath-validation-set-arcsinh.csv,sha256=DZrMYoZZZyM1DDyXNUxSlzx6bOgajnRSLWAzxcPck8k,60289 +numpy/_core/tests/data/umath-validation-set-arctan.csv,sha256=0aosXZ-9DYTop0lj4bfcBNwYVvjZdW13hbMRTRRTmV0,60305 +numpy/_core/tests/data/umath-validation-set-arctanh.csv,sha256=HEK9ePx1OkKrXIKkMUV0IxrmsDqIlgKddiI-LvF2J20,61339 +numpy/_core/tests/data/umath-validation-set-cbrt.csv,sha256=v855MTZih-fZp_GuEDst2qaIsxU4a7vlAbeIJy2xKpc,60846 +numpy/_core/tests/data/umath-validation-set-cos.csv,sha256=0PNnDqKkokZ7ERVDgbes8KNZc-ISJrZUlVZc5LkW18E,59122 +numpy/_core/tests/data/umath-validation-set-cosh.csv,sha256=JKC4nKr3wTzA_XNSiQvVUq9zkYy4djvtu2-j4ZZ_7Oc,60869 +numpy/_core/tests/data/umath-validation-set-exp.csv,sha256=rUAWIbvyeKh9rPfp2n0Zq7AKq_nvHpgbgzLjAllhsek,17491 +numpy/_core/tests/data/umath-validation-set-exp2.csv,sha256=djosT-3fTpiN_f_2WOumgMuuKgC_XhpVO-QsUFwI6uU,58624 +numpy/_core/tests/data/umath-validation-set-expm1.csv,sha256=K7jL6N4KQGX71fj5hvYkzcMXk7MmQes8FwrNfyrPpgU,60299 +numpy/_core/tests/data/umath-validation-set-log.csv,sha256=ynzbVbKxFzxWFwxHnxX7Fpm-va09oI3oK1_lTe19g4w,11692 +numpy/_core/tests/data/umath-validation-set-log10.csv,sha256=NOBD-rOWI_FPG4Vmbzu3JtX9UA838f2AaDFA-waiqGA,68922 +numpy/_core/tests/data/umath-validation-set-log1p.csv,sha256=tdbYWPqWIz8BEbIyklynh_tpQJzo970Edd4ek6DsPb8,60303 +numpy/_core/tests/data/umath-validation-set-log2.csv,sha256=39EUD0vFMbwyoXoOhgCmid6NeEAQU7Ff7QFjPsVObIE,68917 +numpy/_core/tests/data/umath-validation-set-sin.csv,sha256=8PUjnQ_YfmxFb42XJrvpvmkeSpEOlEXSmNvIK4VgfAM,58611 +numpy/_core/tests/data/umath-validation-set-sinh.csv,sha256=XOsBUuPcMjiO_pevMalpmd0iRv2gmnh9u7bV9ZLLg8I,60293 +numpy/_core/tests/data/umath-validation-set-tan.csv,sha256=Hv2WUMIscfvQJ5Y5BipuHk4oE4VY6QKbQp_kNRdCqYQ,60299 +numpy/_core/tests/data/umath-validation-set-tanh.csv,sha256=iolZF_MOyWRgYSa-SsD4df5mnyFK18zrICI740SWoTc,60299 +numpy/_core/tests/examples/cython/__pycache__/setup.cpython-312.pyc,, +numpy/_core/tests/examples/cython/checks.pyx,sha256=aGJS1WAuTIGtQpQxRK9SpXqlM0XFKn97giS3Pi2rt4Y,7344 +numpy/_core/tests/examples/cython/meson.build,sha256=uuXVPKemNVMQ5MiEDqS4BXhwGHa96JHjS50WxZuJS_8,1268 +numpy/_core/tests/examples/cython/setup.py,sha256=6k4eEMjzjXPhGAW440qpMp2S2l5Ltv-e9e-FnVnzl3w,857 +numpy/_core/tests/examples/limited_api/__pycache__/setup.cpython-312.pyc,, +numpy/_core/tests/examples/limited_api/limited_api1.c,sha256=htSR9ER3S8AJqv4EZMsrxQ-SufTIlXNpuFI6MXQs87w,346 +numpy/_core/tests/examples/limited_api/limited_api2.pyx,sha256=1q4I59pdkCmMhLcYngN_XwQnPoLmDEo1uTGnhrLRjDc,203 +numpy/_core/tests/examples/limited_api/limited_api_latest.c,sha256=ltBLbrl1g9XxD2wvN_-g3NhIizc8mxnh2Z6wCyXo-8E,452 +numpy/_core/tests/examples/limited_api/meson.build,sha256=YM5RwW_waFymlWSHFhCCOHO6KCknooN0jCiqScL0i5M,1627 +numpy/_core/tests/examples/limited_api/setup.py,sha256=p2w7F1ardi_GRXSrnNIR8W1oeH_pgmw_1P2wS0A2I6M,435 +numpy/_core/tests/test__exceptions.py,sha256=PA9MhiaEITLOaIe86lnOwqAa3RFrA5Ra4IrqKXF-nMU,2881 +numpy/_core/tests/test_abc.py,sha256=mIZtCZ8PEIOd6pxLqdUws3wMfXUjsVO3vOE9vK5YPd8,2221 +numpy/_core/tests/test_api.py,sha256=D6x2gFFB_C7-SQ0dZhk_ecAz7We7wL0uiNHKNEmWzjo,22932 +numpy/_core/tests/test_argparse.py,sha256=DRLQD5TxhudrQZ79hm5ds3eKsXh_Ub7QsvEYzsdDSX0,2824 +numpy/_core/tests/test_array_api_info.py,sha256=zZvWezQ9raqNgO9gofXgYDcyXYT_wfIYtb3Wy-IjR_8,3062 +numpy/_core/tests/test_array_coercion.py,sha256=wFskNvCBNB72SqcylcqVRAlAI6bim4gOtNhBdSqyVoM,34852 +numpy/_core/tests/test_array_interface.py,sha256=9ND3Y00rgdBSgst5555zrzkvdWzZ4vZgWJOw3djXZAk,7767 +numpy/_core/tests/test_arraymethod.py,sha256=gdRXJjnvAs6-QWZ7o18LX9cHdOIBvZ90neCWW1clRso,3264 +numpy/_core/tests/test_arrayobject.py,sha256=cybY9FWXY34oapV9VWj9Lq4Yem-BbaFLu-NZcV7tuf0,790 +numpy/_core/tests/test_arrayprint.py,sha256=qSa-PgHFjBmMAP9QqLY_a0enqfl_PvCWQ0KDSRJYDxg,47938 +numpy/_core/tests/test_casting_floatingpoint_errors.py,sha256=nnBEgeRIENrOOZvTzRK7SRYYW9dD6E6npDmIuN0ggCc,5074 +numpy/_core/tests/test_casting_unittests.py,sha256=jHnE_9O1YcquVLBzO9UANf83PUIph3CxVRmGOYEXp8M,34308 +numpy/_core/tests/test_conversion_utils.py,sha256=fpduQ79yLpvZ8fdLs4H0CCsBEh3TlZs3SMr-lUQ6pTg,6605 +numpy/_core/tests/test_cpu_dispatcher.py,sha256=nqlgFk-Ocfgc18g-b4fprYssfcpReiyvgbWPzsNEoFI,1552 +numpy/_core/tests/test_cpu_features.py,sha256=zUqiY5TZwK201-SdccthhDg4UslQTC9ygP7Eo94wXbQ,15309 +numpy/_core/tests/test_custom_dtypes.py,sha256=EjHB0Tl9sIoa5AJ4aGwotGDe5OP0nZEpBU4th2bn0VE,11633 +numpy/_core/tests/test_cython.py,sha256=qnL1H7E8zu7s5b24s01gOQ6VA57Lazb9E7vuzUue8VU,8498 +numpy/_core/tests/test_datetime.py,sha256=mxN5VHOyMv7KUYV5MKNVPx_vaifknpnr7w19qoph_9Y,117386 +numpy/_core/tests/test_defchararray.py,sha256=tLrnS4oEVDwjbx74fHyi9r43yAE0J7mJZVfdeHvlSJg,30601 +numpy/_core/tests/test_deprecations.py,sha256=YRpiqYQcwkHWSba42HRqiG5CXghqiji533i1rQivMsU,28674 +numpy/_core/tests/test_dlpack.py,sha256=KMUlft-fmLF8tIHupr5W6griJ7GD5r-McqZEMWg5-Fw,5475 +numpy/_core/tests/test_dtype.py,sha256=PSBPpWZc7-gYxq1O289DQ6LjNqt8kQyeb3EKFQ_boP8,78238 +numpy/_core/tests/test_einsum.py,sha256=kLCN_rgcBsJ9d3P2TDZEQqzXKqNMhPxXWBps21YED3g,52944 +numpy/_core/tests/test_errstate.py,sha256=fno3tnaY1U8uIgd7JZSgJoM_yWkd5GrHXDC6-PIYVhY,4646 +numpy/_core/tests/test_extint128.py,sha256=tVrw3jMHQkA0ebk7Pnq33I5Yu9V24KNHotYIG3V8ds0,5644 +numpy/_core/tests/test_function_base.py,sha256=0hHLDmLconROrue_DEQ06mwhGakmDAfZ2w23aXVsorY,17119 +numpy/_core/tests/test_getlimits.py,sha256=mVtBnC0QtZKHf83a2gr-Y9aZ3NIr1JogWZ1vVQCfQXU,6738 +numpy/_core/tests/test_half.py,sha256=VYPyap9GYOWZuphsfFofcIRl-oa5Ufrtv83OTp6azdU,24593 +numpy/_core/tests/test_hashtable.py,sha256=Ws1EeQWCf7vz8G_VsFTIZUVI-hgKXUEAbtQpvoBjBHo,1147 +numpy/_core/tests/test_indexerrors.py,sha256=wvatr7JlqAAYv-hHAAT-9DwUCnRcKiJ9qLcl6aKe9RU,4734 +numpy/_core/tests/test_indexing.py,sha256=R6Hv-fSYst2lPbROX9Ak6FwogNghceuERlEDOhkNpj4,55064 +numpy/_core/tests/test_item_selection.py,sha256=kI30kiX8mIrZYPn0jw3lGGw1ruZF4PpE9zw-aai9EPA,6458 +numpy/_core/tests/test_limited_api.py,sha256=khmxJnnaPqquzKUg4tPbFkrdd0pGarg8VBjQQla5Tvg,2824 +numpy/_core/tests/test_longdouble.py,sha256=H7VeOyaLfSMHClUDSKloOuHiDbZxeoypJnc5AtsM4xw,13890 +numpy/_core/tests/test_machar.py,sha256=eDTrzJgwfaus0Ts86-HR9YkAPOwOSOPImPTHugn1EOc,1069 +numpy/_core/tests/test_mem_overlap.py,sha256=SSe1tvi8BBAs-0osQd0y1IauR47Axsk7pK74x9GOWwU,29140 +numpy/_core/tests/test_mem_policy.py,sha256=S1dznz5gBfEimb1kXlFsU6CDz22dPxZrnDS6kaIL8r4,16676 +numpy/_core/tests/test_memmap.py,sha256=g-vr5Zys-NGc3IwK8UkqhkjSXYJx4d_enElyw6ydh6A,7743 +numpy/_core/tests/test_multiarray.py,sha256=rcZ4Cs9YfnI62I1BQNw9hu8QyWjrBnT3p_T1AT_L3mI,390638 +numpy/_core/tests/test_multithreading.py,sha256=oXqLo4FRQEw13VWN6rjMT8t4r-URNOr2Hoi_Asp0tIw,3552 +numpy/_core/tests/test_nditer.py,sha256=L0qk1bdYAZ2lKjHLRJyAsOvqdr6cY-f96l0p4kP8QGk,131269 +numpy/_core/tests/test_nep50_promotions.py,sha256=K9xRzpSpRK6H2sr0PWDCFDiF21yoJMDHhobcnSnP44g,12841 +numpy/_core/tests/test_numeric.py,sha256=AoFQv2EE6LCZ98ayb5WhaeqHT6Ez040uG1wyp1CSTWI,157414 +numpy/_core/tests/test_numerictypes.py,sha256=aADiXLPAkgAFF80_tRczhuH6lVyMLcA3k_AbGcDemp4,23292 +numpy/_core/tests/test_overrides.py,sha256=Qq2dVlTwJiCb5t8kE_RN2xlpN3xwOO9L3WVc_8mQWAY,25686 +numpy/_core/tests/test_print.py,sha256=mzUSbQ2kSa1aDl7NRUexj5UG4IM4zaZ-5EIoEoXhA_Q,6836 +numpy/_core/tests/test_protocols.py,sha256=6pxSZKmde5KHoN3iEMKReAFHrMldAm3ZZQwVh_kQ9Uw,1189 +numpy/_core/tests/test_records.py,sha256=0JJJ4FHRQq_9C7OimEo3ayfxYY3z4yeIyIkGMzfghlQ,20535 +numpy/_core/tests/test_regression.py,sha256=z_Upeg9mqcd_506IxIpkDytljfv__jHzEN481GLK-f4,94869 +numpy/_core/tests/test_scalar_ctors.py,sha256=3mhZlumKJs5WazhPgATWf5Y4E4POQy-bcUBSEt5pasc,6719 +numpy/_core/tests/test_scalar_methods.py,sha256=A-3dotRg9kZ8CLEqnuNViTLORqMPoxWtkv1tIm00Gh4,8182 +numpy/_core/tests/test_scalarbuffer.py,sha256=EdiF5tVrZXDchoK0P5sbQgluyyYQCIrLCaxvafaCKNk,5582 +numpy/_core/tests/test_scalarinherit.py,sha256=Kq7KS2pF7m3kUYdxy5QfJbVRKFZvPVCZ5Wq3iAp4pdQ,2592 +numpy/_core/tests/test_scalarmath.py,sha256=yXcE1_2HqoRbxRPTJmFKfiajksl3-85XHkPnFTAxbaw,46572 +numpy/_core/tests/test_scalarprint.py,sha256=9ITKVAklqVuphseF1lfMFrv1pBHKNJvTJFZQw8NDhfY,18788 +numpy/_core/tests/test_shape_base.py,sha256=4fWGEOtsEmX-VJMg84WyT8RILwJO4LbyyBHMtap50NA,31009 +numpy/_core/tests/test_simd.py,sha256=cIKbJZbJY6Jh_4GbZOM6fPFG68c_rvsz-VH0-SHWuYU,48698 +numpy/_core/tests/test_simd_module.py,sha256=g0XWjB1TE4E0y4McOjkZKhR7OB-K01eqy4pJcGfU2zg,3903 +numpy/_core/tests/test_stringdtype.py,sha256=kSMIZ0sw6LbbrGG77vhNOrJyCccpZiG8bQ8_lWGk-lk,54918 +numpy/_core/tests/test_strings.py,sha256=lIM5AborDEEdewMvRlW-WlmoFXKNR4LQdPgWzJoQJJE,48667 +numpy/_core/tests/test_ufunc.py,sha256=t3Ns9ZUPk8HRR7lqCHi9UhYRHcI138cuIUAIVLQo2u4,131619 +numpy/_core/tests/test_umath.py,sha256=o4W61y8p0ocAY1PRnPkFYYi3QoYxhXj_0D3jn9Zg8YM,192318 +numpy/_core/tests/test_umath_accuracy.py,sha256=tj-RfH2NqnuCHjGjZhzyRFXmfYlLW9hvBq76h_DF_Yo,5450 +numpy/_core/tests/test_umath_complex.py,sha256=pWRHpzBodvDGoKG1gkRAKJ1uPxQ_fV_VqIm77SD0BlA,23290 +numpy/_core/tests/test_unicode.py,sha256=eAUcEFUGAfWASXdqTgW1sQ2mU9jnUlzWBhLgctKDo7Q,12868 +numpy/_core/umath.py,sha256=Z4ytcJ5nuqjhS6LHYzqalqYz1CVJUED4DRMcEcyTwH0,2063 +numpy/_distributor_init.py,sha256=IKy2THwmu5UgBjtVbwbD9H-Ap8uaUJoPJ2btQ4Jatdo,407 +numpy/_expired_attrs_2_0.py,sha256=cnmE3ryrFo0CKf_gFhNu388jh055JgYAU6ah8r0aCrM,3913 +numpy/_globals.py,sha256=XVuUPpFLueqKUTNwqiOjWWahnM-vGxGy4tYA3ph-EAE,3090 +numpy/_pyinstaller/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +numpy/_pyinstaller/__pycache__/__init__.cpython-312.pyc,, +numpy/_pyinstaller/__pycache__/hook-numpy.cpython-312.pyc,, +numpy/_pyinstaller/hook-numpy.py,sha256=Ood-XcWlQQkk90SY0yDg7RKsUFVGwas9TqI-Gbc58_s,1393 +numpy/_pyinstaller/tests/__init__.py,sha256=IJtzzjPSw419P-c2T4OT48p-Zu4JohoF9svWqhDshgk,329 +numpy/_pyinstaller/tests/__pycache__/__init__.cpython-312.pyc,, +numpy/_pyinstaller/tests/__pycache__/pyinstaller-smoke.cpython-312.pyc,, +numpy/_pyinstaller/tests/__pycache__/test_pyinstaller.cpython-312.pyc,, +numpy/_pyinstaller/tests/pyinstaller-smoke.py,sha256=6iL-eHMQaG3rxnS5EgcvrCqElm9aKL07Cjr1FZJSXls,1143 +numpy/_pyinstaller/tests/test_pyinstaller.py,sha256=8K-7QxmfoXCG0NwR0bhIgCNrDjGlrTzWnrR1sR8btgU,1135 +numpy/_pytesttester.py,sha256=3PD0aJCA6x2VlfUr0oI63_dkuZXBuL23lCJ07zK5Ge0,6287 +numpy/_pytesttester.pyi,sha256=OtyXSiuSy8o_78w3QNQRjMLpvvNyEdC0aMsx6T-vRxU,489 +numpy/_typing/__init__.py,sha256=FzB-zSTTh4iB8zZfae9jYPgvKJPJq2YtT4ZxsHvjUdk,7093 +numpy/_typing/__pycache__/__init__.cpython-312.pyc,, +numpy/_typing/__pycache__/_add_docstring.cpython-312.pyc,, +numpy/_typing/__pycache__/_array_like.cpython-312.pyc,, +numpy/_typing/__pycache__/_char_codes.cpython-312.pyc,, +numpy/_typing/__pycache__/_dtype_like.cpython-312.pyc,, +numpy/_typing/__pycache__/_extended_precision.cpython-312.pyc,, +numpy/_typing/__pycache__/_nbit.cpython-312.pyc,, +numpy/_typing/__pycache__/_nested_sequence.cpython-312.pyc,, +numpy/_typing/__pycache__/_scalars.cpython-312.pyc,, +numpy/_typing/__pycache__/_shape.cpython-312.pyc,, +numpy/_typing/_add_docstring.py,sha256=5T3jfL4n7l_xQwgk611rlRACRwYmLFLSXaI1zFRuEsw,3970 +numpy/_typing/_array_like.py,sha256=qan8K7oV-jcy-vgUNaCdvX_wUYIMV7Iam-X_6qNBw4M,4693 +numpy/_typing/_callable.pyi,sha256=81nH6Oq-tp7FyDSCe5-b63eU0wc72tF-GFx7zikewlg,12555 +numpy/_typing/_char_codes.py,sha256=j-S7cfBXfxUPFsOgHYcaueimdd_tYJ2NJUwJS_pkM14,6980 +numpy/_typing/_dtype_like.py,sha256=S2PQRxFn2EPUMyRGAANNCf6m4ZInIhm9SxJ4DCRXsQQ,5889 +numpy/_typing/_extended_precision.py,sha256=dGios-1k-QBGew7YFzONZTzVWxz-aYAaqlccl2_h5Bo,777 +numpy/_typing/_nbit.py,sha256=9WFXtFFjveTV-5qLDBXh8TYwOGTanix_k67OZWmc_FQ,361 +numpy/_typing/_nested_sequence.py,sha256=5eNaVZAV9tZQLFWHYOuVs336JjoiaWxyZQ7cMKb6m1I,2566 +numpy/_typing/_scalars.py,sha256=9v-1xahC9TZg28FTfBG15vWCcnDB1bfWz7ejT0eDrVw,1031 +numpy/_typing/_shape.py,sha256=fY1qi6UDFjPW1b4GaxhcJ9tRAQu6SXLZINd_Vy60XSY,231 +numpy/_typing/_ufunc.pyi,sha256=q_rcajMSJ8xi9jniUOSI-zAq24iJHWoepjhg3f-G_3Q,12127 +numpy/_utils/__init__.py,sha256=Lsv7p1NzTQNaMG8vkYxvHPYDoMUolFzG1KdhGFZMedE,3224 +numpy/_utils/__pycache__/__init__.cpython-312.pyc,, +numpy/_utils/__pycache__/_convertions.cpython-312.pyc,, +numpy/_utils/__pycache__/_inspect.cpython-312.pyc,, +numpy/_utils/__pycache__/_pep440.cpython-312.pyc,, +numpy/_utils/_convertions.py,sha256=0xMxdeLOziDmHsRM_8luEh4S-kQdMoMg6GxNDDas69k,329 +numpy/_utils/_inspect.py,sha256=8Ma7QBRwfSWKeK1ShJpFNc7CDhE6fkIE_wr1FxrG1A8,7447 +numpy/_utils/_pep440.py,sha256=Vr7B3QsijR5p6h8YAz2LjNGUyzHUJ5gZ4v26NpZAKDc,14069 +numpy/char/__init__.py,sha256=WGpEng-lsHKxUlmuANY8hKCl3ZC622HYSAFnpf7sgUE,93 +numpy/char/__init__.pyi,sha256=HWtTk64fLvQGvS_2MFk_zKv1Kt1lD-7EQ8SG-tR39XM,1332 +numpy/char/__pycache__/__init__.cpython-312.pyc,, +numpy/compat/__init__.py,sha256=b3rw1J_V3MwU-LZf8uISRKvfXzFaBjFHACbgyLo785Y,727 +numpy/compat/__pycache__/__init__.cpython-312.pyc,, +numpy/compat/__pycache__/py3k.cpython-312.pyc,, +numpy/compat/py3k.py,sha256=Je74CVk_7qI_qX7pLbYcuQJsxlMq1poGIfRIrH99kZQ,3833 +numpy/compat/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +numpy/compat/tests/__pycache__/__init__.cpython-312.pyc,, +numpy/conftest.py,sha256=XX6VW1nFUYiyC-Su3hZU8o1ZjJB0dT_prx29uo_7Xuo,8402 +numpy/core/__init__.py,sha256=FWRkekGqZ1NF4YYNfm46mOAO9u3v4ZYts_lc8ygQfqY,1275 +numpy/core/__init__.pyi,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +numpy/core/__pycache__/__init__.cpython-312.pyc,, +numpy/core/__pycache__/_dtype.cpython-312.pyc,, +numpy/core/__pycache__/_dtype_ctypes.cpython-312.pyc,, +numpy/core/__pycache__/_internal.cpython-312.pyc,, +numpy/core/__pycache__/_multiarray_umath.cpython-312.pyc,, +numpy/core/__pycache__/_utils.cpython-312.pyc,, +numpy/core/__pycache__/arrayprint.cpython-312.pyc,, +numpy/core/__pycache__/defchararray.cpython-312.pyc,, +numpy/core/__pycache__/einsumfunc.cpython-312.pyc,, +numpy/core/__pycache__/fromnumeric.cpython-312.pyc,, +numpy/core/__pycache__/function_base.cpython-312.pyc,, +numpy/core/__pycache__/getlimits.cpython-312.pyc,, +numpy/core/__pycache__/multiarray.cpython-312.pyc,, +numpy/core/__pycache__/numeric.cpython-312.pyc,, +numpy/core/__pycache__/numerictypes.cpython-312.pyc,, +numpy/core/__pycache__/overrides.cpython-312.pyc,, +numpy/core/__pycache__/records.cpython-312.pyc,, +numpy/core/__pycache__/shape_base.cpython-312.pyc,, +numpy/core/__pycache__/umath.cpython-312.pyc,, +numpy/core/_dtype.py,sha256=3SnNsjxlKobD8Dn8B9egjIQuQLdbWz9OtVAZ4_wlDw8,322 +numpy/core/_dtype_ctypes.py,sha256=lLzxauA8PVnopTuGh9USt1nVw2qCI8Z7bL66er3JoHU,350 +numpy/core/_internal.py,sha256=f3eVtRx2tKrJxxavZNe_f1Ln-_1shhSlfeRZEDTlxhU,947 +numpy/core/_multiarray_umath.py,sha256=Yb0HORec_wcEV3RNNU4RZnlATYTUQtjAHMYmL4pvNLs,2096 +numpy/core/_utils.py,sha256=s57m7yaOneaUIljT4WrwqX-tqqexCIomSQKgeL10RIU,917 +numpy/core/arrayprint.py,sha256=a1DkStlBSsVViSJw523Mm-lboVaAtCloBNCrigyOpbI,338 +numpy/core/defchararray.py,sha256=G9S6jkdXegRkXl58hSpPnmndjdym4801Yzq2lzzmApM,346 +numpy/core/einsumfunc.py,sha256=px-rSPkwAMbRNmp5uILgVC2QSr73InKFfvW7LSfNGGw,338 +numpy/core/fromnumeric.py,sha256=aNquLnfZX1XZRAz5MJza5ZT7IlgJo0TMHlR62YT2biM,342 +numpy/core/function_base.py,sha256=Sa9Ec2Y21kPmjn4Xsh7Y1V1c7bUdxYjzixIwHZJ4sCo,350 +numpy/core/getlimits.py,sha256=aYJVaVqiSGKuPfSIa7r0MMZMQkJP2NRNJ7Zd2dszygU,334 +numpy/core/multiarray.py,sha256=SwVF8KNm29qyaq7vx8rrljNNxfn0e6G5y1H830n1Rac,792 +numpy/core/numeric.py,sha256=LSuzJ9OsQ0IEpW2rKlAwuvNypZeDZ0AJDoJOt93XB-k,359 +numpy/core/numerictypes.py,sha256=RvhfWFh9KR0SPDNcrAYnW-PO9TKAND75ONXhL5Djs8Q,346 +numpy/core/overrides.py,sha256=sWaAgbH_piO0mWDeVqqoqkFqqpPHM87FqOZFJ3AO8lU,334 +numpy/core/records.py,sha256=j9BftQLLljVdcENT41eGflG7DA7miXQ7q3Yf53-zYcY,326 +numpy/core/shape_base.py,sha256=MhuxPRwwg5hIdHcJ-LABdQ0oYEYGVxeD-aomaFs9-f4,338 +numpy/core/umath.py,sha256=f6KbsWYh5oTj3_FWHip_dr51BdczTAtMqgpn9_eHcz4,318 +numpy/ctypeslib.py,sha256=OGUL21cShz1-L-ukq7O22fQO_c3I20D0vHnTfPB3qo4,17626 +numpy/ctypeslib.pyi,sha256=UIko2MzsafWZm8C3TUE5ujXhx_ODK19el6yJRGsDFn4,8052 +numpy/doc/__pycache__/ufuncs.cpython-312.pyc,, +numpy/doc/ufuncs.py,sha256=9xt8H34GhrXrFq9cWFUGvJFePa9YuH9Tq1DzAnm2E2E,5414 +numpy/dtypes.py,sha256=zuPwgC0ijF2oDRAOJ6I9JKhaJuhXFAygByLQaoVtT54,1312 +numpy/dtypes.pyi,sha256=fyJsHFlxw591c6KxT4telUuyHCfkMJREvDnV8cghiBA,14047 +numpy/exceptions.py,sha256=CL6CCTFew1anOiTbpTsujjoV1Dd1ztFSJoxuDrTs0Mg,7874 +numpy/exceptions.pyi,sha256=rc61wK_jQEfT7IZrlVZObnxuJ8KRgyPXAabGUwblsaE,639 +numpy/f2py/__init__.py,sha256=aov9Lx4W4n19yV4gmvAi7Z1nMQJxDWnAdDAu81F44Dg,2526 +numpy/f2py/__init__.pyi,sha256=eA7uYXZr0p0aaz5rBW-EypLx9RchrvqDYtSnkEJQsYw,1087 +numpy/f2py/__main__.py,sha256=6i2jVH2fPriV1aocTY_dUFvWK18qa-zjpnISA-OpF3w,130 +numpy/f2py/__pycache__/__init__.cpython-312.pyc,, +numpy/f2py/__pycache__/__main__.cpython-312.pyc,, +numpy/f2py/__pycache__/__version__.cpython-312.pyc,, +numpy/f2py/__pycache__/_isocbind.cpython-312.pyc,, +numpy/f2py/__pycache__/_src_pyf.cpython-312.pyc,, +numpy/f2py/__pycache__/auxfuncs.cpython-312.pyc,, +numpy/f2py/__pycache__/capi_maps.cpython-312.pyc,, +numpy/f2py/__pycache__/cb_rules.cpython-312.pyc,, +numpy/f2py/__pycache__/cfuncs.cpython-312.pyc,, +numpy/f2py/__pycache__/common_rules.cpython-312.pyc,, +numpy/f2py/__pycache__/crackfortran.cpython-312.pyc,, +numpy/f2py/__pycache__/diagnose.cpython-312.pyc,, +numpy/f2py/__pycache__/f2py2e.cpython-312.pyc,, +numpy/f2py/__pycache__/f90mod_rules.cpython-312.pyc,, +numpy/f2py/__pycache__/func2subr.cpython-312.pyc,, +numpy/f2py/__pycache__/rules.cpython-312.pyc,, +numpy/f2py/__pycache__/symbolic.cpython-312.pyc,, +numpy/f2py/__pycache__/use_rules.cpython-312.pyc,, +numpy/f2py/__version__.py,sha256=7HHdjR82FCBmftwMRyrlhcEj-8mGQb6oCH-wlUPH4Nw,34 +numpy/f2py/_backends/__init__.py,sha256=7_bA7c_xDpLc4_8vPfH32-Lxn9fcUTgjQ25srdvwvAM,299 +numpy/f2py/_backends/__pycache__/__init__.cpython-312.pyc,, +numpy/f2py/_backends/__pycache__/_backend.cpython-312.pyc,, +numpy/f2py/_backends/__pycache__/_distutils.cpython-312.pyc,, +numpy/f2py/_backends/__pycache__/_meson.cpython-312.pyc,, +numpy/f2py/_backends/_backend.py,sha256=GKb9-UaFszT045vUgVukPs1n97iyyjqahrWKxLOKNYo,1187 +numpy/f2py/_backends/_distutils.py,sha256=D9UkK_cvecPdqahGO-D0rck3luTPlyP7Trc3pV7eVIs,2388 +numpy/f2py/_backends/_meson.py,sha256=AZqZ2FJQl3by26Nez85JrjpmmNSKb9nq3S7RaBRrpPs,8116 +numpy/f2py/_backends/meson.build.template,sha256=hQeTapAY0xtni5Li-QaEtWx9DH9WDKah2lcEuSZfLLo,1599 +numpy/f2py/_isocbind.py,sha256=zaBgpfPNRmxVG3doUIlbZIiyB990MsXiwDabrSj9HnQ,2360 +numpy/f2py/_src_pyf.py,sha256=4t6TN4ZKWciC4f1z6fwaGrpIGhHKRiwHfcrNj4FIzCg,7654 +numpy/f2py/auxfuncs.py,sha256=Nf2Ip9CYmVyhzhl9OrWs9lI48Kf7oHqwPtBw8HvBOME,26825 +numpy/f2py/capi_maps.py,sha256=OmDkzbytC6ifqiF9RGe_mPIeyqIPC-xcE0t1DP_FaBA,30627 +numpy/f2py/cb_rules.py,sha256=fSxXAxjNaPXt54E957v1-Q3oCM06vbST5gFu1D98ic4,25004 +numpy/f2py/cfuncs.py,sha256=T5sxuNGU5NbUJRF3KkdfFoHn1MbVVSDOHxaM_qC-ZTg,52125 +numpy/f2py/common_rules.py,sha256=gHB76WypbkVmhaD_RWhy8Od4zDTgj8cbDOdUdIp6PIQ,5131 +numpy/f2py/crackfortran.py,sha256=XAyygoIAKQOmd9KATKNV3GC1B25XJpaD6tz0rRzeqXA,148023 +numpy/f2py/diagnose.py,sha256=0SRXBE2hJgKJN_Rf4Zn00oKXC_Tka3efPWM47zg6BoY,5197 +numpy/f2py/f2py2e.py,sha256=bT2E3LeTd0wU_LVnmpwBmfrvrafSXduVzZU3c9ezMq0,28941 +numpy/f2py/f90mod_rules.py,sha256=zmL53Fftnah3Gu8699qsrks1yNjHu0oc9jOTqfYEOyw,9992 +numpy/f2py/func2subr.py,sha256=6d2R5awuHRT4xzgfUfwS7JHTqhhAieSXcENlssD_2c4,10298 +numpy/f2py/rules.py,sha256=HL9RNAQRXohvP5Zcr9sJ8r-NjRZYlG9tQW40WhOFQ7o,62874 +numpy/f2py/setup.cfg,sha256=Fpn4sjqTl5OT5sp8haqKIRnUcTPZNM6MIvUJBU7BIhg,48 +numpy/f2py/src/fortranobject.c,sha256=YPF0qUjOUnGdOFZEcvId1ooZMfmuDcGkaWbOG7_4HmM,46048 +numpy/f2py/src/fortranobject.h,sha256=7cfRN_tToAQ1Na13VQ2Kzb2ujMHUAgGsbScnfLVOHqs,5823 +numpy/f2py/symbolic.py,sha256=nm65BDeRr74QdIWjg6aFA8IkR_9uZHxRb6z8OcnqLU4,53268 +numpy/f2py/tests/__init__.py,sha256=46XgeBE0seimp3wD4Ox0KutYeLwdsdRSiGECcG1iYu8,328 +numpy/f2py/tests/__pycache__/__init__.cpython-312.pyc,, +numpy/f2py/tests/__pycache__/test_abstract_interface.cpython-312.pyc,, +numpy/f2py/tests/__pycache__/test_array_from_pyobj.cpython-312.pyc,, +numpy/f2py/tests/__pycache__/test_assumed_shape.cpython-312.pyc,, +numpy/f2py/tests/__pycache__/test_block_docstring.cpython-312.pyc,, +numpy/f2py/tests/__pycache__/test_callback.cpython-312.pyc,, +numpy/f2py/tests/__pycache__/test_character.cpython-312.pyc,, +numpy/f2py/tests/__pycache__/test_common.cpython-312.pyc,, +numpy/f2py/tests/__pycache__/test_crackfortran.cpython-312.pyc,, +numpy/f2py/tests/__pycache__/test_data.cpython-312.pyc,, +numpy/f2py/tests/__pycache__/test_docs.cpython-312.pyc,, +numpy/f2py/tests/__pycache__/test_f2cmap.cpython-312.pyc,, +numpy/f2py/tests/__pycache__/test_f2py2e.cpython-312.pyc,, +numpy/f2py/tests/__pycache__/test_isoc.cpython-312.pyc,, +numpy/f2py/tests/__pycache__/test_kind.cpython-312.pyc,, +numpy/f2py/tests/__pycache__/test_mixed.cpython-312.pyc,, +numpy/f2py/tests/__pycache__/test_modules.cpython-312.pyc,, +numpy/f2py/tests/__pycache__/test_parameter.cpython-312.pyc,, +numpy/f2py/tests/__pycache__/test_pyf_src.cpython-312.pyc,, +numpy/f2py/tests/__pycache__/test_quoted_character.cpython-312.pyc,, +numpy/f2py/tests/__pycache__/test_regression.cpython-312.pyc,, +numpy/f2py/tests/__pycache__/test_return_character.cpython-312.pyc,, +numpy/f2py/tests/__pycache__/test_return_complex.cpython-312.pyc,, +numpy/f2py/tests/__pycache__/test_return_integer.cpython-312.pyc,, +numpy/f2py/tests/__pycache__/test_return_logical.cpython-312.pyc,, +numpy/f2py/tests/__pycache__/test_return_real.cpython-312.pyc,, +numpy/f2py/tests/__pycache__/test_semicolon_split.cpython-312.pyc,, +numpy/f2py/tests/__pycache__/test_size.cpython-312.pyc,, +numpy/f2py/tests/__pycache__/test_string.cpython-312.pyc,, +numpy/f2py/tests/__pycache__/test_symbolic.cpython-312.pyc,, +numpy/f2py/tests/__pycache__/test_value_attrspec.cpython-312.pyc,, +numpy/f2py/tests/__pycache__/util.cpython-312.pyc,, +numpy/f2py/tests/src/abstract_interface/foo.f90,sha256=JFU2w98cB_XNwfrqNtI0yDTmpEdxYO_UEl2pgI_rnt8,658 +numpy/f2py/tests/src/abstract_interface/gh18403_mod.f90,sha256=gvQJIzNtvacWE0dhysxn30-iUeI65Hpq7DiE9oRauz8,105 +numpy/f2py/tests/src/array_from_pyobj/wrapmodule.c,sha256=s6XLwujiCr6Xi8yBkvLPBXRmo2WsGVohU7K9ALnKUng,7478 +numpy/f2py/tests/src/assumed_shape/.f2py_f2cmap,sha256=But9r9m4iL7EGq_haMW8IiQ4VivH0TgUozxX4pPvdpE,29 +numpy/f2py/tests/src/assumed_shape/foo_free.f90,sha256=oBwbGSlbr9MkFyhVO2aldjc01dr9GHrMrSiRQek8U64,460 +numpy/f2py/tests/src/assumed_shape/foo_mod.f90,sha256=rfzw3QdI-eaDSl-hslCgGpd5tHftJOVhXvb21Y9Gf6M,499 +numpy/f2py/tests/src/assumed_shape/foo_use.f90,sha256=rmT9k4jP9Ru1PLcGqepw9Jc6P9XNXM0axY7o4hi9lUw,269 +numpy/f2py/tests/src/assumed_shape/precision.f90,sha256=r08JeTVmTTExA-hYZ6HzaxVwBn1GMbPAuuwBhBDtJUk,130 +numpy/f2py/tests/src/block_docstring/foo.f,sha256=y7lPCPu7_Fhs_Tf2hfdpDQo1bhtvNSKRaZAOpM_l3dg,97 +numpy/f2py/tests/src/callback/foo.f,sha256=C1hjfpRCQWiOVVzIHqnsYcnLrqQcixrnHCn8hd9GhVk,1254 +numpy/f2py/tests/src/callback/gh17797.f90,sha256=_Nrl0a2HgUbtymGU0twaJ--7rMa1Uco2A3swbWvHoMo,148 +numpy/f2py/tests/src/callback/gh18335.f90,sha256=NraOyKIXyvv_Y-3xGnmTjtNjW2Znsnlk8AViI8zfovc,506 +numpy/f2py/tests/src/callback/gh25211.f,sha256=a2sxlQhtDVbYn8KOKHUYqwc-aCFt7sDPSnJsXFG35uI,179 +numpy/f2py/tests/src/callback/gh25211.pyf,sha256=FWxo0JWQlw519BpZV8PoYeI_FZ_K6C-3Wk6gLrfBPlw,447 +numpy/f2py/tests/src/cli/gh_22819.pyf,sha256=5rvOfCv-wSosB354LC9pExJmMoSHnbGZGl_rtA2fogA,142 +numpy/f2py/tests/src/cli/hi77.f,sha256=ttyI6vAP3qLnDqy82V04XmoqrXNM6uhMvvLri2p0dq0,71 +numpy/f2py/tests/src/cli/hiworld.f90,sha256=QWOLPrTxYQu1yrEtyQMbM0fE9M2RmXe7c185KnD5x3o,51 +numpy/f2py/tests/src/common/block.f,sha256=GQ0Pd-VMX3H3a-__f2SuosSdwNXHpBqoGnQDjf8aG9g,224 +numpy/f2py/tests/src/common/gh19161.f90,sha256=BUejyhqpNVfHZHQ-QC7o7ZSo7lQ6YHyX08lSmQqs6YM,193 +numpy/f2py/tests/src/crackfortran/accesstype.f90,sha256=-5Din7YlY1TU7tUHD2p-_DSTxGBpDsWYNeT9WOwGhno,208 +numpy/f2py/tests/src/crackfortran/data_common.f,sha256=ZSUAh3uhn9CCF-cYqK5TNmosBGPfsuHBIEfudgysun4,193 +numpy/f2py/tests/src/crackfortran/data_multiplier.f,sha256=jYrJKZWF_59JF9EMOSALUjn0UupWvp1teuGpcL5s1Sc,197 +numpy/f2py/tests/src/crackfortran/data_stmts.f90,sha256=19YO7OGj0IksyBlmMLZGRBQLjoE3erfkR4tFvhznvvE,693 +numpy/f2py/tests/src/crackfortran/data_with_comments.f,sha256=hoyXw330VHh8duMVmAQZjr1lgLVF4zFCIuEaUIrupv0,175 +numpy/f2py/tests/src/crackfortran/foo_deps.f90,sha256=CaH7mnWTG7FcnJe2vXN_0zDbMadw6NCqK-JJ2HmDjK8,128 +numpy/f2py/tests/src/crackfortran/gh15035.f,sha256=jJly1AzF5L9VxbVQ0vr-sf4LaUo4eQzJguhuemFxnvg,375 +numpy/f2py/tests/src/crackfortran/gh17859.f,sha256=7K5dtOXGuBDAENPNCt-tAGJqTfNKz5OsqVSk16_e7Es,340 +numpy/f2py/tests/src/crackfortran/gh22648.pyf,sha256=qZHPRNQljIeYNwbqPLxREnOrSdVV14f3fnaHqB1M7c0,241 +numpy/f2py/tests/src/crackfortran/gh23533.f,sha256=w3tr_KcY3s7oSWGDmjfMHv5h0RYVGUpyXquNdNFOJQg,126 +numpy/f2py/tests/src/crackfortran/gh23598.f90,sha256=41W6Ire-5wjJTTg6oAo7O1WZfd1Ug9vvNtNgHS5MhEU,101 +numpy/f2py/tests/src/crackfortran/gh23598Warn.f90,sha256=1v-hMCT_K7prhhamoM20nMU9zILam84Hr-imck_dYYk,205 +numpy/f2py/tests/src/crackfortran/gh23879.f90,sha256=LWDJTYR3t9h1IsrKC8dVXZlBfWX7clLeU006X6Ow8oI,332 +numpy/f2py/tests/src/crackfortran/gh2848.f90,sha256=gPNasx98SIf7Z9ibk_DHiGKCvl7ERtsfoGXiFDT7FbM,282 +numpy/f2py/tests/src/crackfortran/operators.f90,sha256=-Fc-qjW1wBr3Dkvdd5dMTrt0hnjnV-1AYo-NFWcwFSo,1184 +numpy/f2py/tests/src/crackfortran/privatemod.f90,sha256=7bubZGMIn7iD31wDkjF1TlXCUM7naCIK69M9d0e3y-U,174 +numpy/f2py/tests/src/crackfortran/publicmod.f90,sha256=Pnwyf56Qd6W3FUH-ZMgnXEYkb7gn18ptNTdwmGan0Jo,167 +numpy/f2py/tests/src/crackfortran/pubprivmod.f90,sha256=eYpJwBYLKGOxVbKgEqfny1znib-b7uYhxcRXIf7uwXg,165 +numpy/f2py/tests/src/crackfortran/unicode_comment.f90,sha256=aINLh6GlfTwFewxvDoqnMqwuCNb4XAqi5Nj5vXguXYs,98 +numpy/f2py/tests/src/f2cmap/.f2py_f2cmap,sha256=iUOtfHd3OuT1Rz2-yiSgt4uPKGvCt5AzQ1iygJt_yjg,82 +numpy/f2py/tests/src/f2cmap/isoFortranEnvMap.f90,sha256=iJCD8a8MUTmuPuedbcmxW54Nr4alYuLhksBe1sHS4K0,298 +numpy/f2py/tests/src/isocintrin/isoCtests.f90,sha256=jcw-fzrFh0w5U66uJYfeUW4gv94L5MnWQ_NpsV9y0oI,998 +numpy/f2py/tests/src/kind/foo.f90,sha256=zIHpw1KdkWbTzbXb73hPbCg4N2Htj3XL8DIwM7seXpo,347 +numpy/f2py/tests/src/mixed/foo.f,sha256=90zmbSHloY1XQYcPb8B5d9bv9mCZx8Z8AMTtgDwJDz8,85 +numpy/f2py/tests/src/mixed/foo_fixed.f90,sha256=pxKuPzxF3Kn5khyFq9ayCsQiolxB3SaNtcWaK5j6Rv4,179 +numpy/f2py/tests/src/mixed/foo_free.f90,sha256=fIQ71wrBc00JUAVUj_r3QF9SdeNniBiMw6Ly7CGgPWU,139 +numpy/f2py/tests/src/modules/gh25337/data.f90,sha256=9Uz8CHB9i3_mjC3cTOmkTgPAF5tWSwYacG3MUrU-SY0,180 +numpy/f2py/tests/src/modules/gh25337/use_data.f90,sha256=WATiDGAoCKnGgMzm_iMgmfVU0UKOQlk5Fm0iXCmPAkE,179 +numpy/f2py/tests/src/modules/gh26920/two_mods_with_no_public_entities.f90,sha256=c7VU4SbK3yWn-6wksP3tDx_Hxh5u_g8UnlDpjU_-tBg,402 +numpy/f2py/tests/src/modules/gh26920/two_mods_with_one_public_routine.f90,sha256=eEU7RgFPh-TnNXEuJFdtJmTF-wPnpbHLQhG4fEeJnag,403 +numpy/f2py/tests/src/modules/module_data_docstring.f90,sha256=tDZ3fUlazLL8ThJm3VwNGJ75QIlLcW70NnMFv-JA4W0,224 +numpy/f2py/tests/src/modules/use_modules.f90,sha256=UsFfx0B2gu_tS-H-BpLWed_yoMDl1kbydMIOz8fvXWA,398 +numpy/f2py/tests/src/negative_bounds/issue_20853.f90,sha256=fdOPhRi7ipygwYCXcda7p_dlrws5Hd2GlpF9EZ-qnck,157 +numpy/f2py/tests/src/parameter/constant_array.f90,sha256=KRg7Gmq_r3B7t3IEgRkP1FT8ve8AuUFWT0WcTlXoN5U,1468 +numpy/f2py/tests/src/parameter/constant_both.f90,sha256=-bBf2eqHb-uFxgo6Q7iAtVUUQzrGFqzhHDNaxwSICfQ,1939 +numpy/f2py/tests/src/parameter/constant_compound.f90,sha256=re7pfzcuaquiOia53UT7qNNrTYu2euGKOF4IhoLmT6g,469 +numpy/f2py/tests/src/parameter/constant_integer.f90,sha256=nEmMLitKoSAG7gBBEQLWumogN-KS3DBZOAZJWcSDnFw,612 +numpy/f2py/tests/src/parameter/constant_non_compound.f90,sha256=IcxESVLKJUZ1k9uYKoSb8Hfm9-O_4rVnlkiUU2diy8Q,609 +numpy/f2py/tests/src/parameter/constant_real.f90,sha256=quNbDsM1Ts2rN4WtPO67S9Xi_8l2cXabWRO00CPQSSQ,610 +numpy/f2py/tests/src/quoted_character/foo.f,sha256=WjC9D9171fe2f7rkUAZUvik9bkIf9adByfRGzh6V0cM,482 +numpy/f2py/tests/src/regression/AB.inc,sha256=cSNxitwrjTKMiJzhY2AI5FaXJ5y9zDgA27x79jyoI6s,16 +numpy/f2py/tests/src/regression/f77comments.f,sha256=bqTsmO8WuSLVFsViIV7Nj7wQbJoZ7IAA3d2tpRDKsnA,626 +numpy/f2py/tests/src/regression/f77fixedform.f95,sha256=hcLZbdozMJ3V9pByVRp3RoeUvZgLMRLFctpZvxK2hTI,139 +numpy/f2py/tests/src/regression/f90continuation.f90,sha256=_W1fj0wXLqT91Q14qpBnM3F7rJKaiSR8upe0mR6_OIE,276 +numpy/f2py/tests/src/regression/incfile.f90,sha256=i7Y1zgMXR9bSxnjeYWSDGeCfsS5jiyn7BLb-wbwjz2U,92 +numpy/f2py/tests/src/regression/inout.f90,sha256=CpHpgMrf0bqA1W3Ozo3vInDz0RP904S7LkpdAH6ODck,277 +numpy/f2py/tests/src/return_character/foo77.f,sha256=WzDNF3d_hUDSSZjtxd3DtE-bSx1ilOMEviGyYHbcFgM,980 +numpy/f2py/tests/src/return_character/foo90.f90,sha256=ULcETDEt7gXHRzmsMhPsGG4o3lGrcx-FEFaJsPGFKyA,1248 +numpy/f2py/tests/src/return_complex/foo77.f,sha256=8ECRJkfX82oFvGWKbIrCvKjf5QQQClx4sSEvsbkB6A8,973 +numpy/f2py/tests/src/return_complex/foo90.f90,sha256=c1BnrtWwL2dkrTr7wvlEqNDg59SeNMo3gyJuGdRwcDw,1238 +numpy/f2py/tests/src/return_integer/foo77.f,sha256=_8k1evlzBwvgZ047ofpdcbwKdF8Bm3eQ7VYl2Y8b5kA,1178 +numpy/f2py/tests/src/return_integer/foo90.f90,sha256=bzxbYtofivGRYH35Ang9ScnbNsVERN8-6ub5-eI-LGQ,1531 +numpy/f2py/tests/src/return_logical/foo77.f,sha256=FxiF_X0HkyXHzJM2rLyTubZJu4JB-ObLnVqfZwAQFl8,1188 +numpy/f2py/tests/src/return_logical/foo90.f90,sha256=9KmCe7yJYpi4ftkKOM3BCDnPOdBPTbUNrKxY3p37O14,1531 +numpy/f2py/tests/src/return_real/foo77.f,sha256=ZTrzb6oDrIDPlrVWP3Bmtkbz3ffHaaSQoXkfTGtCuFE,933 +numpy/f2py/tests/src/return_real/foo90.f90,sha256=gZuH5lj2lG6gqHlH766KQ3J4-Ero-G4WpOOo2MG3ohU,1194 +numpy/f2py/tests/src/size/foo.f90,sha256=IlFAQazwBRr3zyT7v36-tV0-fXtB1d7WFp6S1JVMstg,815 +numpy/f2py/tests/src/string/char.f90,sha256=ihr_BH9lY7eXcQpHHDQhFoKcbu7VMOX5QP2Tlr7xlaM,618 +numpy/f2py/tests/src/string/fixed_string.f90,sha256=5n6IkuASFKgYICXY9foCVoqndfAY0AQZFEK8L8ARBGM,695 +numpy/f2py/tests/src/string/gh24008.f,sha256=UA8Pr-_yplfOFmc6m4v9ryFQ8W9OulaglulefkFWD68,217 +numpy/f2py/tests/src/string/gh24662.f90,sha256=-Tp9Kd1avvM7AIr8ZukFA9RVr-wusziAnE8AvG9QQI4,197 +numpy/f2py/tests/src/string/gh25286.f90,sha256=2EpxvC-0_dA58MBfGQcLyHzpZgKcMf_W9c73C_Mqnok,304 +numpy/f2py/tests/src/string/gh25286.pyf,sha256=GjgWKh1fHNdPGRiX5ek60i1XSeZsfFalydWqjISPVV8,381 +numpy/f2py/tests/src/string/gh25286_bc.pyf,sha256=6Y9zU66NfcGhTXlFOdFjCSMSwKXpq5ZfAe3FwpkAsm4,384 +numpy/f2py/tests/src/string/scalar_string.f90,sha256=ACxV2i6iPDk-a6L_Bs4jryVKYJMEGUTitEIYTjbJes4,176 +numpy/f2py/tests/src/string/string.f,sha256=shr3fLVZaa6SyUJFYIF1OZuhff8v5lCwsVNBU2B-3pk,248 +numpy/f2py/tests/src/value_attrspec/gh21665.f90,sha256=JC0FfVXsnB2lZHb-nGbySnxv_9VHAyD0mKaLDowczFU,190 +numpy/f2py/tests/test_abstract_interface.py,sha256=SGJqspdwvo6JWjQ-VAifepzTo86cU5VNxe9E_sH4Yts,850 +numpy/f2py/tests/test_array_from_pyobj.py,sha256=I4jCiXSMJ-boNX4LyXVjwdZtH-yTbyqhknke65wy15E,23783 +numpy/f2py/tests/test_assumed_shape.py,sha256=FeaqtrWyBf5uyArcmI0D2e_f763aSMpgU3QmdDXe-tA,1466 +numpy/f2py/tests/test_block_docstring.py,sha256=2WGCsNBxtH57BjAYyPAzUZgiBRYWAQpC9zODP02OZec,582 +numpy/f2py/tests/test_callback.py,sha256=19lLfl2HmJpKUPaTu3mdtK9meJXx_nx9vXpIC6LmwuI,6560 +numpy/f2py/tests/test_character.py,sha256=29o5PCGC_t5UsOwmxM4dL3k3IPZ6hpUD25VFSZk5N9E,21926 +numpy/f2py/tests/test_common.py,sha256=VPsy0SLqbKaUGgDqesYXmjYuLpnPK-XyzseqmV5QnhM,641 +numpy/f2py/tests/test_crackfortran.py,sha256=VfM7uwXxuf0hhemV8QAQI31RKHxMefL2I56C5we0CZU,15888 +numpy/f2py/tests/test_data.py,sha256=sFaaYt8EdWu6hI2Kyg2gK38ug5XsCUkPOEkl6zarh58,2898 +numpy/f2py/tests/test_docs.py,sha256=DXAAqi0DHa6S25R6zQ5VhtbZYJxBKvnrs5KVw-ZAUI8,1874 +numpy/f2py/tests/test_f2cmap.py,sha256=-WnN0HlqiG9RPgc1P_KSLZvqgQ4wGYDf0lFcyfWOLfs,385 +numpy/f2py/tests/test_f2py2e.py,sha256=-ZFQWaxCdsnv6y2nun3bVe_ND6WIFss0hmjE-jUROuw,27844 +numpy/f2py/tests/test_isoc.py,sha256=kY7yg7Jtyn_RBlozwe6UpQvtwPbPcpTC0B27s2GRo7s,1428 +numpy/f2py/tests/test_kind.py,sha256=mLoh2b9XAQpirywOw9_qEelgKMRdMIMUqkkhAhgpols,1793 +numpy/f2py/tests/test_mixed.py,sha256=ie1hr7-3QlyYkUt3suPTCNOqUbcaawphSlRLHmU6czA,870 +numpy/f2py/tests/test_modules.py,sha256=wli_Cq9FroWg9nnOZplGAd9L5OX49h_Z-e8PyVVnk0w,2299 +numpy/f2py/tests/test_parameter.py,sha256=Nt6elnMp5zJ-lk0Yu-mwUdLzYwhCFNtPT7o0EVr5Ip8,4633 +numpy/f2py/tests/test_pyf_src.py,sha256=eD0bZu_GWfoCq--wWqEKRf-F2h5AwoTyO6GMA9wJPr4,1135 +numpy/f2py/tests/test_quoted_character.py,sha256=T6I2EyopdItKamcokG0ylvhT7krZYhBU6hF3UFIBr2g,476 +numpy/f2py/tests/test_regression.py,sha256=PfYdtgKW-6pn5VjU4hi2VNMClSFNl_rzt5EkpNBWX1s,4737 +numpy/f2py/tests/test_return_character.py,sha256=DP63vrF6bIV-QRBsJ1ZpPsKz-u906Ph8M6_biPEzBJs,1511 +numpy/f2py/tests/test_return_complex.py,sha256=4vtpIYqAZZrbKYi3fnP7l_Zn42YnBbPwl8-eNfZOHHo,2415 +numpy/f2py/tests/test_return_integer.py,sha256=qR8Ismf40Ml2impqjGzjL2i-CRyGTxXVEvzQQMkJfJo,1776 +numpy/f2py/tests/test_return_logical.py,sha256=XCmp8E8I6BOeNYF59HjSFAdv1hM9WaDvl8UDS10_05o,2017 +numpy/f2py/tests/test_return_real.py,sha256=rxgglxBljLavw3LzWCeT41mYYVhvkTMlQE5E2rfg_LI,3253 +numpy/f2py/tests/test_semicolon_split.py,sha256=gi0I439sNF1x2dl4fnJmkFzhoGUpE7ni7_mJ8tQdH5c,1653 +numpy/f2py/tests/test_size.py,sha256=q6YqQvcyqdXJeWbGijTiCbxyEG3EkPcvT8AlAW6RCMo,1164 +numpy/f2py/tests/test_string.py,sha256=5xZOfdReoHnId0950XfmtfduPPfBbtMkzBoXMtygvMk,2962 +numpy/f2py/tests/test_symbolic.py,sha256=28quk2kTKfWhKe56n4vINJ8G9weKBfc7HysMlE9J3_g,18341 +numpy/f2py/tests/test_value_attrspec.py,sha256=SKi010iuwoWCH5fGfLDpjYrqOxKtSGZ6a0W1EKPnHj8,339 +numpy/f2py/tests/util.py,sha256=jPct2y1RaUxY-Tt0-_9OhyhR7pjhbziiZIIyYCNL5Tg,12217 +numpy/f2py/use_rules.py,sha256=3pTDOPur6gbPHPtwuMJPQvpnUMw39Law1KFSH0coB_0,3527 +numpy/fft/__init__.py,sha256=cW8oJRorHlG10mhnhAB1OOkg4HpG2NGYHDgonFNI04s,8326 +numpy/fft/__init__.pyi,sha256=IYRQ9v8fS2H9iMdCJfO9am_86vbcpWFpzXLbwPjSSZo,531 +numpy/fft/__pycache__/__init__.cpython-312.pyc,, +numpy/fft/__pycache__/_helper.cpython-312.pyc,, +numpy/fft/__pycache__/_pocketfft.cpython-312.pyc,, +numpy/fft/__pycache__/helper.cpython-312.pyc,, +numpy/fft/_helper.py,sha256=Yvph-5gksd0HebLSXq4UKfVYOwSiqNIa4THpv0aA2HE,6775 +numpy/fft/_helper.pyi,sha256=4Z9lTaHKEldkDrh8vpYJKOeGfPrTJAs9UATt1u8FlEw,1330 +numpy/fft/_pocketfft.py,sha256=_HhbYRHUWykBONqrifnmx8MzCjp7c4vtEomxL-LNvUY,63168 +numpy/fft/_pocketfft.pyi,sha256=JZJM0TeqqY0WrnYpr1mzfe3FWTa8yzEcrqEoTLJhGZc,2961 +numpy/fft/_pocketfft_umath.cpython-312-darwin.so,sha256=7JVHUqQHLzvnw06PB3fJpB3Gww5MAZ52OjLgrUZ0bXw,329816 +numpy/fft/helper.py,sha256=str0NJ1vpLNlC_3vMfulTu9D9_cThxKG2zkaGuZ5NTY,610 +numpy/fft/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +numpy/fft/tests/__pycache__/__init__.cpython-312.pyc,, +numpy/fft/tests/__pycache__/test_helper.cpython-312.pyc,, +numpy/fft/tests/__pycache__/test_pocketfft.cpython-312.pyc,, +numpy/fft/tests/test_helper.py,sha256=pVYVLUwNEcE9M8eyHaRi7JOgc6k5p_JVzJ0AKnelgvI,6149 +numpy/fft/tests/test_pocketfft.py,sha256=xGbyPmmqizmAhlsiUW8K1NziI7ZFsr6TGeJuVAS4r0Q,24412 +numpy/lib/__init__.py,sha256=Nfa0hj1MaQAl4HcI2Xs3c49Idmg3T1qZ14MI1g-DUkY,3187 +numpy/lib/__init__.pyi,sha256=f6_weeFha_MBO1TfKATaqRKHv3N9n5A2azKB7jd_9UY,770 +numpy/lib/__pycache__/__init__.cpython-312.pyc,, +numpy/lib/__pycache__/_array_utils_impl.cpython-312.pyc,, +numpy/lib/__pycache__/_arraypad_impl.cpython-312.pyc,, +numpy/lib/__pycache__/_arraysetops_impl.cpython-312.pyc,, +numpy/lib/__pycache__/_arrayterator_impl.cpython-312.pyc,, +numpy/lib/__pycache__/_datasource.cpython-312.pyc,, +numpy/lib/__pycache__/_function_base_impl.cpython-312.pyc,, +numpy/lib/__pycache__/_histograms_impl.cpython-312.pyc,, +numpy/lib/__pycache__/_index_tricks_impl.cpython-312.pyc,, +numpy/lib/__pycache__/_iotools.cpython-312.pyc,, +numpy/lib/__pycache__/_nanfunctions_impl.cpython-312.pyc,, +numpy/lib/__pycache__/_npyio_impl.cpython-312.pyc,, +numpy/lib/__pycache__/_polynomial_impl.cpython-312.pyc,, +numpy/lib/__pycache__/_scimath_impl.cpython-312.pyc,, +numpy/lib/__pycache__/_shape_base_impl.cpython-312.pyc,, +numpy/lib/__pycache__/_stride_tricks_impl.cpython-312.pyc,, +numpy/lib/__pycache__/_twodim_base_impl.cpython-312.pyc,, +numpy/lib/__pycache__/_type_check_impl.cpython-312.pyc,, +numpy/lib/__pycache__/_ufunclike_impl.cpython-312.pyc,, +numpy/lib/__pycache__/_user_array_impl.cpython-312.pyc,, +numpy/lib/__pycache__/_utils_impl.cpython-312.pyc,, +numpy/lib/__pycache__/_version.cpython-312.pyc,, +numpy/lib/__pycache__/array_utils.cpython-312.pyc,, +numpy/lib/__pycache__/format.cpython-312.pyc,, +numpy/lib/__pycache__/introspect.cpython-312.pyc,, +numpy/lib/__pycache__/mixins.cpython-312.pyc,, +numpy/lib/__pycache__/npyio.cpython-312.pyc,, +numpy/lib/__pycache__/recfunctions.cpython-312.pyc,, +numpy/lib/__pycache__/scimath.cpython-312.pyc,, +numpy/lib/__pycache__/stride_tricks.cpython-312.pyc,, +numpy/lib/__pycache__/user_array.cpython-312.pyc,, +numpy/lib/_array_utils_impl.py,sha256=eMGdZi7auu6201h4v4eQZ2miF8KmdMGDApbBFgRE-6Q,1689 +numpy/lib/_array_utils_impl.pyi,sha256=w37sTX4F4AJNrN4pnUovcqEcxfsdkpdhF4CDtsbB36o,748 +numpy/lib/_arraypad_impl.py,sha256=dLDDK2K6tFa7YIpCn3hUfNJs5k4raJE5jGIR3zPIp60,32408 +numpy/lib/_arraypad_impl.pyi,sha256=ADXphtAORYl3EqvE5qs_u32B_TALKSOtF43jOLmoxRw,1728 +numpy/lib/_arraysetops_impl.py,sha256=y2oL_wfZ9c0lOAtavTFDUO4Kc0LCvtLh5O7K1JWstFs,39540 +numpy/lib/_arraysetops_impl.pyi,sha256=eHCK7aprLhBsPCaeyhnZyzDuNCX2jW7cQBvOmON55z8,9315 +numpy/lib/_arrayterator_impl.py,sha256=d_Rhl-pERrhxSuCxRNPIIle9b0WoMvVNhkupPn0BIaE,7168 +numpy/lib/_arrayterator_impl.pyi,sha256=M-oDG2ShygvxufQG0NMimXYMJtTQcCPHPwogWO1bN00,1514 +numpy/lib/_datasource.py,sha256=FJ7k1HghREU7udh8ZuO5ZZF3nHJfOkj7iWijhoVFqIQ,22729 +numpy/lib/_function_base_impl.py,sha256=3C7KxtRV7iiYULVDK24BTmsy8uwJeCnNJNkhOZEs_ow,194622 +numpy/lib/_function_base_impl.pyi,sha256=JNyxgAPGbwFcq8kGXRCdN3gXYzui0hLalmxtMoNXfz8,18763 +numpy/lib/_histograms_impl.py,sha256=HR7WHm6OJ1kSO7Xe6RsvXGSMkm6ZoeRvhw-xz-325K4,38658 +numpy/lib/_histograms_impl.pyi,sha256=hfWyE2pyRJcijx0qsZYXNjJ3PvApbPPNjzTa-u25bVs,1001 +numpy/lib/_index_tricks_impl.py,sha256=R42AzmmnRKVEs0PQZdQ8WW26rKs-eqrdwHLf4quCPDE,32305 +numpy/lib/_index_tricks_impl.pyi,sha256=udLQYETv5PGTWWIGvaUMhHE22DA1kYWmlkk40043BqU,4163 +numpy/lib/_iotools.py,sha256=mMhxeGBt-T8prjWpNhn_xvZCj6u6OWWmmsvKP6vbM5w,30941 +numpy/lib/_nanfunctions_impl.py,sha256=P0j6zikzsvWaK2FPRauhxc9HbOWUqnbwj2vqnb1WYwc,72643 +numpy/lib/_nanfunctions_impl.pyi,sha256=WI7OtJWk9HLWpYSw5hufi3q-sCvscZxNByar7fBkM5U,613 +numpy/lib/_npyio_impl.py,sha256=NmDSSrU52p3IAtqmvauquFhrmOfrOEd_JYMFOPzVRHs,98977 +numpy/lib/_npyio_impl.pyi,sha256=BGMto5xQF78N-NXKpllg-9CqxXdYoo7yboHobbaK1PA,10259 +numpy/lib/_polynomial_impl.py,sha256=6rD5Cy4mSDk2CsuAdJOq2he-PSa-ZiqsdgyyQAF5qx0,44294 +numpy/lib/_polynomial_impl.pyi,sha256=hwookIwMJ8VrQWaZhjcJb8nunseXfm_Z1nlJ2W9Xdng,6936 +numpy/lib/_scimath_impl.py,sha256=rB2YoGQUv7G8l8MBO-BBGf-ygZZ6Ek2Z2IwxcMBOLvc,15526 +numpy/lib/_scimath_impl.pyi,sha256=E2roKJzMFwWSyhLu8UPUr54WOpxF8jp_pyXYBgsUSQ8,2883 +numpy/lib/_shape_base_impl.py,sha256=ZV_oyGh8rj7rjQjnmnVqyF7SByu5mz-7A7Y43vElRJI,39647 +numpy/lib/_shape_base_impl.pyi,sha256=JGwVgkKV16P0a5iDAPYrq1Z8tY0JvF6MWwsHDNCW9HQ,4723 +numpy/lib/_stride_tricks_impl.py,sha256=fUKDv5PfDh-CjnIYlccDPgQ8tD5oV4YS8YG4dvNB1XQ,18202 +numpy/lib/_stride_tricks_impl.pyi,sha256=J_DcfNwm4btn7ynKMAdDGHDSNRbxuWlQKsbGLat3T9o,1753 +numpy/lib/_twodim_base_impl.py,sha256=dXJBvQwpwBPgGybEK5KZTscRs5TD4P7lqi8SL6e1jHY,33698 +numpy/lib/_twodim_base_impl.pyi,sha256=HGRS44kgPKp1gJisZZ4hBDxT3wuBldsR8dgPypbFcko,10845 +numpy/lib/_type_check_impl.py,sha256=QRKyUp1CY_560_ZmUoIyOdRuVul9UJ1l7t8fEDH_ZRw,19350 +numpy/lib/_type_check_impl.pyi,sha256=hRKacjRatDTGfYhJYYnfpFwj3uHgQJuVpRGUdcoqkJ4,5207 +numpy/lib/_ufunclike_impl.py,sha256=empYifZ0_BxOBpTFVmb7X6cMjX4ilBl0a398nzBD75E,6342 +numpy/lib/_ufunclike_impl.pyi,sha256=vxaQ_C9VeH9OzAxotaBTwPNu247jo3tAbwq4O6xPBHA,1299 +numpy/lib/_user_array_impl.py,sha256=n36wSKrwpatZVc7CBZSXLZhyUYqy5XKemnZ4gBjpaUE,7890 +numpy/lib/_utils_impl.py,sha256=8eRQqHw5i-Y9nnFmdE0yhhKW5xxCwuGacxiY1ktTxM8,23404 +numpy/lib/_utils_impl.pyi,sha256=beIHx7IktQu13uqwpOJ0dz5P6CtYV_MN8xREYAfqxA4,644 +numpy/lib/_version.py,sha256=eWioqEi0TN4fC6db-sfbP9f9VC7YMs6AjR_Qgzg02SY,4853 +numpy/lib/_version.pyi,sha256=B572hyWrUWG-TAAAXrNNAT4AgyUAmJ4lvgpwMkDzunk,633 +numpy/lib/array_utils.py,sha256=zoaLw9TvrAFRkh9n8uMyr8kvug3IvVlUT7LcJzB3Tk0,130 +numpy/lib/array_utils.pyi,sha256=kEO5wShp8zEbNTPu-Kw-EHuZQvq1rXHzgjK797xCV0Q,191 +numpy/lib/format.py,sha256=EBKCaCtsDHIjPOb04fhFXI2tT4eqn4q1FSqDpeBXgfE,36310 +numpy/lib/format.pyi,sha256=YWBxC3GdsZ7SKBN8I7nMwWeVuFD1aT9d-VJ8zE4-P-o,748 +numpy/lib/introspect.py,sha256=Jg78l8sYniZzPhAPGRmqa0_BLTb-VjghzA5oEqmRSqE,2737 +numpy/lib/mixins.py,sha256=jedTdqltOakWU1sZ_GY_oFHmFJP7Q3JbONo5ZRpJNJY,7365 +numpy/lib/mixins.pyi,sha256=yJM9NNPaU1-TQ3D9vj9QgcY3L_lDKEjI6a8Y9NWylzo,3114 +numpy/lib/npyio.py,sha256=NCxqWedJbSM5M-wr69TED8x7KXcyBJ0x5u49vj4sPkI,62 +numpy/lib/npyio.pyi,sha256=b_cbxg8tD8AA9ql9mqMCcA0Wts5iUBCXSpVNBLNzvZ0,92 +numpy/lib/recfunctions.py,sha256=GPJsQ0whE27grE_Ifre-5-mt1IQYVDDUSaWaWEvK_Vw,59908 +numpy/lib/scimath.py,sha256=iO0IiDgpHk1EurdUvJIE2KqDzVOfvSsU3MFIlJskIOE,118 +numpy/lib/scimath.pyi,sha256=MIWKfkv7MVE063prnzdSzI8pnVHPnXIFWOhBwlL6_0U,241 +numpy/lib/stride_tricks.py,sha256=VGR5M8Jyw8IC4S6XEB9NN_GULTJJQj_1QrItIi_BJiM,82 +numpy/lib/stride_tricks.pyi,sha256=Fqn9EZXdjIgUTce6UMD7rBBb8289QTMzohhjHwYP3TU,124 +numpy/lib/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +numpy/lib/tests/__pycache__/__init__.cpython-312.pyc,, +numpy/lib/tests/__pycache__/test__datasource.cpython-312.pyc,, +numpy/lib/tests/__pycache__/test__iotools.cpython-312.pyc,, +numpy/lib/tests/__pycache__/test__version.cpython-312.pyc,, +numpy/lib/tests/__pycache__/test_array_utils.cpython-312.pyc,, +numpy/lib/tests/__pycache__/test_arraypad.cpython-312.pyc,, +numpy/lib/tests/__pycache__/test_arraysetops.cpython-312.pyc,, +numpy/lib/tests/__pycache__/test_arrayterator.cpython-312.pyc,, +numpy/lib/tests/__pycache__/test_format.cpython-312.pyc,, +numpy/lib/tests/__pycache__/test_function_base.cpython-312.pyc,, +numpy/lib/tests/__pycache__/test_histograms.cpython-312.pyc,, +numpy/lib/tests/__pycache__/test_index_tricks.cpython-312.pyc,, +numpy/lib/tests/__pycache__/test_io.cpython-312.pyc,, +numpy/lib/tests/__pycache__/test_loadtxt.cpython-312.pyc,, +numpy/lib/tests/__pycache__/test_mixins.cpython-312.pyc,, +numpy/lib/tests/__pycache__/test_nanfunctions.cpython-312.pyc,, +numpy/lib/tests/__pycache__/test_packbits.cpython-312.pyc,, +numpy/lib/tests/__pycache__/test_polynomial.cpython-312.pyc,, +numpy/lib/tests/__pycache__/test_recfunctions.cpython-312.pyc,, +numpy/lib/tests/__pycache__/test_regression.cpython-312.pyc,, +numpy/lib/tests/__pycache__/test_shape_base.cpython-312.pyc,, +numpy/lib/tests/__pycache__/test_stride_tricks.cpython-312.pyc,, +numpy/lib/tests/__pycache__/test_twodim_base.cpython-312.pyc,, +numpy/lib/tests/__pycache__/test_type_check.cpython-312.pyc,, +numpy/lib/tests/__pycache__/test_ufunclike.cpython-312.pyc,, +numpy/lib/tests/__pycache__/test_utils.cpython-312.pyc,, +numpy/lib/tests/data/py2-np0-objarr.npy,sha256=ZLoI7K3iQpXDkuoDF1Ymyc6Jbw4JngbQKC9grauVRsk,258 +numpy/lib/tests/data/py2-objarr.npy,sha256=F4cyUC-_TB9QSFLAo2c7c44rC6NUYIgrfGx9PqWPSKk,258 +numpy/lib/tests/data/py2-objarr.npz,sha256=xo13HBT0FbFZ2qvZz0LWGDb3SuQASSaXh7rKfVcJjx4,366 +numpy/lib/tests/data/py3-objarr.npy,sha256=7mtikKlHXp4unZhM8eBot8Cknlx1BofJdd73Np2PW8o,325 +numpy/lib/tests/data/py3-objarr.npz,sha256=vVRl9_NZ7_q-hjduUr8YWnzRy8ESNlmvMPlaSSC69fk,453 +numpy/lib/tests/data/python3.npy,sha256=X0ad3hAaLGXig9LtSHAo-BgOvLlFfPYMnZuVIxRmj-0,96 +numpy/lib/tests/data/win64python2.npy,sha256=agOcgHVYFJrV-nrRJDbGnUnF4ZTPYXuSeF-Mtg7GMpc,96 +numpy/lib/tests/test__datasource.py,sha256=65KXfUUvp8wXSqgQisuYlkhg-qHjBV5FXYetL8Ba-rc,10571 +numpy/lib/tests/test__iotools.py,sha256=W2gLNsi2S8-4qixUs6EKkTYnOOp55qLLuM3zpBzZoR4,13744 +numpy/lib/tests/test__version.py,sha256=aO3YgkAohLsLzCNQ7vjIwdpFUMz0cPLbcuuxIkjuN74,1999 +numpy/lib/tests/test_array_utils.py,sha256=vOC6AmlPIQbVxQf2DiRL02May5IK5BK2GUFK0nP83FM,1119 +numpy/lib/tests/test_arraypad.py,sha256=pPTksDqBqZT9TnzRS8mjhBykFBcib-n0Xc4GWR1lqWE,56087 +numpy/lib/tests/test_arraysetops.py,sha256=0s5uYlB-WgsnIboqiROFBHD-9BcfPVNtee8QhEpCHK4,38012 +numpy/lib/tests/test_arrayterator.py,sha256=AYs2SwV5ankgwnvKI9RSO1jZck118nu3SyZ4ngzZNso,1291 +numpy/lib/tests/test_format.py,sha256=b3mu6GruBY9uQJmAAThnbQ4I4zBdaz6v0zBU5wmXbJw,40951 +numpy/lib/tests/test_function_base.py,sha256=UbcsDvZXdSsm5oazvxFwrwi_Al-O82hOLNarvc4l1FI,167324 +numpy/lib/tests/test_histograms.py,sha256=3GfHDMqAihBcbU6qoki_G8dSOzBbD5jU1SColm6i8Sg,33554 +numpy/lib/tests/test_index_tricks.py,sha256=ZpKsvd3P3p2hwfj6sHlL_lysJp1IevAoM6AdpeTAx8M,20368 +numpy/lib/tests/test_io.py,sha256=TpKQ5q_ClEZxcU9VRDi50kBIjSn6ST5B5qazz1Igp60,109391 +numpy/lib/tests/test_loadtxt.py,sha256=1fsmA0b9d6BVIzj5gWnagGKYjmmXAnAY1W2eyw1XnN8,39499 +numpy/lib/tests/test_mixins.py,sha256=Wivwz3XBWsEozGzrzsyyvL3qAuE14t1BHk2LPm9Z9Zc,7030 +numpy/lib/tests/test_nanfunctions.py,sha256=e8IxqRADPgtHzjZpIZUFbtxYoB1-xBHnfaNMg8lyNWc,53351 +numpy/lib/tests/test_packbits.py,sha256=2QaNYKH29cVD-S4YYBIQBd1xQ9bc2OqHdZT6yS7Txjk,17544 +numpy/lib/tests/test_polynomial.py,sha256=XwAkZbKZaF2yyeEjbo0WevOwewGWPaox-8liLZZ4YnU,11400 +numpy/lib/tests/test_recfunctions.py,sha256=6jzouPEQ7Uhtj8_-W5yTI6ymNp2nLgmdHzxdd74jVuM,44001 +numpy/lib/tests/test_regression.py,sha256=XufkjEqWF1qqS7m76tqvg4Za8yW04jEz_QaKNphZPuU,7714 +numpy/lib/tests/test_shape_base.py,sha256=W1q-tgBENS19wpOKSzEi63OSjatE4qC1viQG22qoacE,27488 +numpy/lib/tests/test_stride_tricks.py,sha256=9g25TXSGLsvfeIrlkQ8l1fx_pZ48b4dxCzXXUbsKC5g,22997 +numpy/lib/tests/test_twodim_base.py,sha256=ll-72RhqCItIPB97nOWhH7H292h4nVIX_w1toKTPMUg,18841 +numpy/lib/tests/test_type_check.py,sha256=kh2n-xjjmygmul0L0vMvmcXySX9ViBjWGKJYQbN6yCA,14702 +numpy/lib/tests/test_ufunclike.py,sha256=5AFySuvUfggh0tpBuQHJ7iZRrP0r_yZZv5xHxOuCZ1s,3023 +numpy/lib/tests/test_utils.py,sha256=zzgwQGId2P8RUgimSsm7uMCYb61xPenrP_N0kcZU8x4,2374 +numpy/lib/user_array.py,sha256=Ev3yeNNLZVNWk9xZuiCIbODYKwQ6XfYGpI5WAoYvtok,49 +numpy/linalg/__init__.py,sha256=XNtdLo33SVTjQbXeimLFa5ZudzpEEwnfJBNorVbxuyc,2106 +numpy/linalg/__init__.pyi,sha256=WeROFcujp1o9g_5HJ5j1DSXSMn-3ZCp1NlkqBhfHOMg,960 +numpy/linalg/__pycache__/__init__.cpython-312.pyc,, +numpy/linalg/__pycache__/_linalg.cpython-312.pyc,, +numpy/linalg/__pycache__/linalg.cpython-312.pyc,, +numpy/linalg/_linalg.py,sha256=8Acn4v42LxIr1QwhYeRYZkB2WU-YGNQEpE4aCzhjYxI,115454 +numpy/linalg/_linalg.pyi,sha256=BCWPfxz8dx4nYfR7QBB_PvAoy57yCHp8E5SnzhpAJnE,10725 +numpy/linalg/_umath_linalg.cpython-312-darwin.so,sha256=bheebuPc-AiVAJCrBNDLdNEV_4cUB8yNrpWyKEDsrG4,154752 +numpy/linalg/lapack_lite.cpython-312-darwin.so,sha256=FK2-WDj3YWe2D2CeQV5psxDBej0kKM75wj2YZNGayNA,52928 +numpy/linalg/linalg.py,sha256=JQWcEvjY_bjhaMHXY5vDk69OIoMzX5Rvbn1eGW2FCvE,584 +numpy/linalg/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +numpy/linalg/tests/__pycache__/__init__.cpython-312.pyc,, +numpy/linalg/tests/__pycache__/test_deprecations.cpython-312.pyc,, +numpy/linalg/tests/__pycache__/test_linalg.cpython-312.pyc,, +numpy/linalg/tests/__pycache__/test_regression.cpython-312.pyc,, +numpy/linalg/tests/test_deprecations.py,sha256=9p_SRmtxj2zc1doY9Ie3dyy5JzWy-tCQWFoajcAJUmM,640 +numpy/linalg/tests/test_linalg.py,sha256=wKnbuMyOqJ1s_NVPA6xXaYjJxNIL3fHhh114cheflVg,83355 +numpy/linalg/tests/test_regression.py,sha256=-iM74Wagl4_vZ2CPFG_IBt0UEJpAYvsd30sf3QZsOY4,6705 +numpy/ma/API_CHANGES.txt,sha256=F_4jW8X5cYBbzpcwteymkonTmvzgKKY2kGrHF1AtnrI,3405 +numpy/ma/LICENSE,sha256=BfO4g1GYjs-tEKvpLAxQ5YdcZFLVAJoAhMwpFVH_zKY,1593 +numpy/ma/README.rst,sha256=krf2cvVK_zNQf1d3yVYwg0uDHzTiR4vHbr91zwaAyoI,9874 +numpy/ma/__init__.py,sha256=iv-YxXUZe4z7W53QZWY0ndicV43AGsIygArsoN3tQb8,1419 +numpy/ma/__init__.pyi,sha256=HQBOppzm8lvEENgI3k6DtGT5eB9nuaiuNeKa-2jjLqQ,6041 +numpy/ma/__pycache__/__init__.cpython-312.pyc,, +numpy/ma/__pycache__/core.cpython-312.pyc,, +numpy/ma/__pycache__/extras.cpython-312.pyc,, +numpy/ma/__pycache__/mrecords.cpython-312.pyc,, +numpy/ma/__pycache__/testutils.cpython-312.pyc,, +numpy/ma/__pycache__/timer_comparison.cpython-312.pyc,, +numpy/ma/core.py,sha256=jz7OnJEyOrxUn64EGvrroGs-cvNTyYAaMc7zblJUYRk,287660 +numpy/ma/core.pyi,sha256=3shisCCbyuDiejyRR_wIgoVLHuK4jbILGVpVtKpcKT4,14301 +numpy/ma/extras.py,sha256=_1rMjo--D-8yL5mq9Ri88RtO38DpIoPCH2DTVN3ppjc,71023 +numpy/ma/extras.pyi,sha256=8VHhU_A5uaULPhmnXbQgrgWBQx9R7ejmTUCYFEyx3w4,2653 +numpy/ma/mrecords.py,sha256=0hMM8idHDAtZaqnSpfkEVQ97i9Kr3y9crCCKeQFiY58,27194 +numpy/ma/mrecords.pyi,sha256=xRZj2cS2HlZ1mSBm2DZKJH4WKn1cbP5EaHw-GfQpsP0,1884 +numpy/ma/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +numpy/ma/tests/__pycache__/__init__.cpython-312.pyc,, +numpy/ma/tests/__pycache__/test_arrayobject.cpython-312.pyc,, +numpy/ma/tests/__pycache__/test_core.cpython-312.pyc,, +numpy/ma/tests/__pycache__/test_deprecations.cpython-312.pyc,, +numpy/ma/tests/__pycache__/test_extras.cpython-312.pyc,, +numpy/ma/tests/__pycache__/test_mrecords.cpython-312.pyc,, +numpy/ma/tests/__pycache__/test_old_ma.cpython-312.pyc,, +numpy/ma/tests/__pycache__/test_regression.cpython-312.pyc,, +numpy/ma/tests/__pycache__/test_subclassing.cpython-312.pyc,, +numpy/ma/tests/test_arrayobject.py,sha256=MSvEcxlsVt4YZ7mVXU8q_hkwM0I7xsxWejEqnUQx6hE,1099 +numpy/ma/tests/test_core.py,sha256=B1ISKIABRG1YadaP59SkSiOVVMrt39ar2Mau4ZlDXG8,215883 +numpy/ma/tests/test_deprecations.py,sha256=nq_wFVt2EBHcT3AHxattfKXx2JDf1K5D-QBzUU0_15A,2566 +numpy/ma/tests/test_extras.py,sha256=h0Zc0u4dXlQ3E0qADNYlH7iF4XX3K2A6HiY5hseRwSs,78314 +numpy/ma/tests/test_mrecords.py,sha256=-nFjKUNYG_-gJ6RpZbWnx_TJlmkRAagA7AnVaf9YJfI,19855 +numpy/ma/tests/test_old_ma.py,sha256=BW01_4m8wZcHvAkZ8FIjDmFfusnjgFmGVbRyqbWD000,32753 +numpy/ma/tests/test_regression.py,sha256=foMpI0luAvwkkRpAfPDV_810h1URISXDZhmaNhxb50k,3287 +numpy/ma/tests/test_subclassing.py,sha256=X8HylxMtWb55lCVslO0-w7URLgRIL5oK_Ahh9vMdTPg,17026 +numpy/ma/testutils.py,sha256=sbiHivmwPQX3fPAPUe9OMktEqrwg1rcr8xgKfMM1Ex0,10272 +numpy/ma/timer_comparison.py,sha256=Gm5zQYF_X8IEMdKBSnS4mFMi2wmojyftUa-iLg4lwcU,15694 +numpy/matlib.py,sha256=hBmpfUQRZuNUQdvBFqlr4ZpX5gnODbaSkojNgbV4gAE,10691 +numpy/matrixlib/__init__.py,sha256=BHBpQKoQv4EjT0UpWBA-Ck4L5OsMqTI2IuY24p-ucXk,242 +numpy/matrixlib/__init__.pyi,sha256=WAYa7HoOr3wIRWLWg2Of80HlEfSJbGlCLXC1y0DO9k8,232 +numpy/matrixlib/__pycache__/__init__.cpython-312.pyc,, +numpy/matrixlib/__pycache__/defmatrix.cpython-312.pyc,, +numpy/matrixlib/defmatrix.py,sha256=4Sat_jwWLiwlm5h1m4um0l0Uz2KspmHJQHUhvnZ4hoI,30756 +numpy/matrixlib/defmatrix.pyi,sha256=lmBMRahKcMOl2PHDo79J67VRAZOkI54BzfDaTLpE0LI,451 +numpy/matrixlib/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +numpy/matrixlib/tests/__pycache__/__init__.cpython-312.pyc,, +numpy/matrixlib/tests/__pycache__/test_defmatrix.cpython-312.pyc,, +numpy/matrixlib/tests/__pycache__/test_interaction.cpython-312.pyc,, +numpy/matrixlib/tests/__pycache__/test_masked_matrix.cpython-312.pyc,, +numpy/matrixlib/tests/__pycache__/test_matrix_linalg.cpython-312.pyc,, +numpy/matrixlib/tests/__pycache__/test_multiarray.cpython-312.pyc,, +numpy/matrixlib/tests/__pycache__/test_numeric.cpython-312.pyc,, +numpy/matrixlib/tests/__pycache__/test_regression.cpython-312.pyc,, +numpy/matrixlib/tests/test_defmatrix.py,sha256=tLHvsnn2xIKLLZULYqhQ1IJOtSdS52BfOOhU8-7jjvA,15035 +numpy/matrixlib/tests/test_interaction.py,sha256=jiLmXS0JtwEx0smkb5hUnY5Slp9I8FwGlYGHKE3iG1w,11895 +numpy/matrixlib/tests/test_masked_matrix.py,sha256=1x3mzFol1GYvVxKXcmRYLi-On3cmK7gEjSVEyvbkh-w,8914 +numpy/matrixlib/tests/test_matrix_linalg.py,sha256=ObbSUXU4R2pWajH__xAdizADrU2kBKDDCxkDV-oVBXc,2059 +numpy/matrixlib/tests/test_multiarray.py,sha256=jB3XCBmAtcqf-Wb9PwBW6uIykPpMPthuXLJ0giTKzZE,554 +numpy/matrixlib/tests/test_numeric.py,sha256=MP70qUwgshTtThKZaZDp7_6U-Z66NIV1geVhasGXejQ,441 +numpy/matrixlib/tests/test_regression.py,sha256=LBkm6_moDjuU9RY4FszgaknOj3IyCp3t-Ej3HJfqpdk,932 +numpy/polynomial/__init__.py,sha256=XNK7ZWsBECCoHnJZ0NqKiF1ErZqvdxszE1NJ6Hc2Vz0,6760 +numpy/polynomial/__init__.pyi,sha256=u2ZJqcaXqDtkpAELYqvJyXR9GDP7nY8g1RSf5uLUX5w,611 +numpy/polynomial/__pycache__/__init__.cpython-312.pyc,, +numpy/polynomial/__pycache__/_polybase.cpython-312.pyc,, +numpy/polynomial/__pycache__/chebyshev.cpython-312.pyc,, +numpy/polynomial/__pycache__/hermite.cpython-312.pyc,, +numpy/polynomial/__pycache__/hermite_e.cpython-312.pyc,, +numpy/polynomial/__pycache__/laguerre.cpython-312.pyc,, +numpy/polynomial/__pycache__/legendre.cpython-312.pyc,, +numpy/polynomial/__pycache__/polynomial.cpython-312.pyc,, +numpy/polynomial/__pycache__/polyutils.cpython-312.pyc,, +numpy/polynomial/_polybase.py,sha256=YYhJc7aRY8loDBaeUVOYJycxJIHvHAExxCDWE89Orh0,39892 +numpy/polynomial/_polybase.pyi,sha256=yACuOVhbb_t3FXojkgFGVoZPubuEE-g82AKjVFNb5nQ,8760 +numpy/polynomial/_polytypes.pyi,sha256=-FuvgcwdO3ZvBH4kg2Oa1j7qBvGdpoqYaBHDNsOlfCU,22891 +numpy/polynomial/chebyshev.py,sha256=KvqDOupsi0yfPHund77cWt8LW6pYHuhwSBsMCx7_hgQ,62939 +numpy/polynomial/chebyshev.pyi,sha256=9cJoCeRvzHuunQoCEy2pGOUdCp0KU65q7Tb8pTqLvGU,4725 +numpy/polynomial/hermite.py,sha256=tulZ27-NhQS9IM7tmfsUZjyIoXQ5tpLSbAwDnd875qY,55058 +numpy/polynomial/hermite.pyi,sha256=dm1gYq04GxQu5T4N5LqTYbZblLoXDqZDs6CtmycCU3w,2445 +numpy/polynomial/hermite_e.py,sha256=RC0JYrI4GtFtIHPtsfGZ8tehfaYyjpJq4vJQr5P0kIg,52808 +numpy/polynomial/hermite_e.pyi,sha256=klpXixSq5MRTlh6AlN1jRXPDXcnRdgUZPTxQjZpFKhM,2537 +numpy/polynomial/laguerre.py,sha256=thRzmp-2OS6z006Iailq10LgQxmIvLqNPcELfWnAOZI,52941 +numpy/polynomial/laguerre.pyi,sha256=QiCFjYZRAuYaty8LelfOvomgal1xFU9-4oKL68l1jyc,2174 +numpy/polynomial/legendre.py,sha256=9dqxsvoQRA-BFvv_UULt6yXSHh77yyVEZkoTlEdTl3Y,51597 +numpy/polynomial/legendre.pyi,sha256=SaQ9PZG50KF4g0iQd6B-xYOBz1vTDGtI4wChAINlFZY,2173 +numpy/polynomial/polynomial.py,sha256=hc-KSTR21tuOvkrIjGT4DGjucPmKJxnVQE1pRf_mE3w,52699 +numpy/polynomial/polynomial.pyi,sha256=Y4yeYfi879s5_Xm3SqdRmhQhbgJJBRRbajhCj1irTSw,2002 +numpy/polynomial/polyutils.py,sha256=JhrI05cXg0nGNu-C1X2Q7L5OKUdvl8S23pu7r-AqI-c,22486 +numpy/polynomial/polyutils.pyi,sha256=XYAYqUmjZVS_49uDszZE3SNI_lxJgx1SkjqqBVDrz44,10426 +numpy/polynomial/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +numpy/polynomial/tests/__pycache__/__init__.cpython-312.pyc,, +numpy/polynomial/tests/__pycache__/test_chebyshev.cpython-312.pyc,, +numpy/polynomial/tests/__pycache__/test_classes.cpython-312.pyc,, +numpy/polynomial/tests/__pycache__/test_hermite.cpython-312.pyc,, +numpy/polynomial/tests/__pycache__/test_hermite_e.cpython-312.pyc,, +numpy/polynomial/tests/__pycache__/test_laguerre.cpython-312.pyc,, +numpy/polynomial/tests/__pycache__/test_legendre.cpython-312.pyc,, +numpy/polynomial/tests/__pycache__/test_polynomial.cpython-312.pyc,, +numpy/polynomial/tests/__pycache__/test_polyutils.cpython-312.pyc,, +numpy/polynomial/tests/__pycache__/test_printing.cpython-312.pyc,, +numpy/polynomial/tests/__pycache__/test_symbol.cpython-312.pyc,, +numpy/polynomial/tests/test_chebyshev.py,sha256=6tMsFP1h7K8Zf72mNOta6Tv52_fVTlXknseuffj080c,20522 +numpy/polynomial/tests/test_classes.py,sha256=Tf6p3qCINxOfh7hsOdVp81-CJPkqNg1HnH2smcWbRBw,18450 +numpy/polynomial/tests/test_hermite.py,sha256=N9b2dx2UWPyja5v02dSoWYPnKvb6H-Ozgtrx-xjWz2k,18577 +numpy/polynomial/tests/test_hermite_e.py,sha256=_A3ohAWS4HXrQG06S8L47dImdZGTwYosCXnoyw7L45o,18911 +numpy/polynomial/tests/test_laguerre.py,sha256=BZOgs49VBXOFBepHopxuEDkIROHEvFBfWe4X73UZhn8,17511 +numpy/polynomial/tests/test_legendre.py,sha256=b_bblHs0F_BWw9ESuSq52ZsLKcQKFR5eqPf_SppWFqo,18673 +numpy/polynomial/tests/test_polynomial.py,sha256=-NGrdiaM24zQUn9ugtAViwFtbVQ34qgErXTQ5KF-Fd8,22022 +numpy/polynomial/tests/test_polyutils.py,sha256=ULZMU2soHOZ4uO0eJoRjxNkT3yGURuX35MXx1Bg5Wyk,3772 +numpy/polynomial/tests/test_printing.py,sha256=x5JzVg3yfub38RkKhBG_zzlIxXkcRn0mkbTECG1Bc90,21333 +numpy/polynomial/tests/test_symbol.py,sha256=Hg-V7jR7qz5FKg_DrlkaiFcCI1UujYFUJfpf2TuoJZM,5372 +numpy/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +numpy/random/LICENSE.md,sha256=EDFmtiuARDr7nrNIjgUuoGvgz_VmuQjxmeVh_eSa8Z8,3511 +numpy/random/__init__.pxd,sha256=9JbnX540aJNSothGs-7e23ozhilG6U8tINOUEp08M_k,431 +numpy/random/__init__.py,sha256=81Thnexg5umN5WZwD5TRyzNc2Yp-d14B6UC7NBgVKh8,7506 +numpy/random/__init__.pyi,sha256=2SxvWDuxTcI2gcgIAU4A-cG_Azq8QV-EPi8SScO4D2w,2123 +numpy/random/__pycache__/__init__.cpython-312.pyc,, +numpy/random/__pycache__/_pickle.cpython-312.pyc,, +numpy/random/_bounded_integers.cpython-312-darwin.so,sha256=Tn7z1eH7TNOY9QM8aErVfVoIhwPbCEY_jDAki8ea6d0,299384 +numpy/random/_bounded_integers.pxd,sha256=SH_FwJDigFEInhdliSaNH2H2ZIZoX02xYhNQA81g2-g,1678 +numpy/random/_common.cpython-312-darwin.so,sha256=51cH7_IRZLozBa-9Qd2KbTtk5n6yvXJ45-E0sUXpMwo,235712 +numpy/random/_common.pxd,sha256=7kGArYkBcemrxJcSttwvtDGbimLszdQnZdNvPMgN5xQ,4982 +numpy/random/_examples/cffi/__pycache__/extending.cpython-312.pyc,, +numpy/random/_examples/cffi/__pycache__/parse.cpython-312.pyc,, +numpy/random/_examples/cffi/extending.py,sha256=xSla3zWqxi6Hj48EvnYfD3WHfE189VvC4XsKu4_T_Iw,880 +numpy/random/_examples/cffi/parse.py,sha256=Bnb7t_6S_c5-3dZrQ-XX9EazOKhftUfcCejXXWyd1EU,1771 +numpy/random/_examples/cython/extending.pyx,sha256=4IE692pq1V53UhPZqQiQGcIHXDoNyqTx62x5a36puVg,2290 +numpy/random/_examples/cython/extending_distributions.pyx,sha256=oazFVWeemfE0eDzax7r7MMHNL1_Yofws2m-c_KT2Hbo,3870 +numpy/random/_examples/cython/meson.build,sha256=GxZZT_Lu3nZsgcqo_7sTR_IdMJaHA1fxyjwrQTcodPs,1694 +numpy/random/_examples/numba/__pycache__/extending.cpython-312.pyc,, +numpy/random/_examples/numba/__pycache__/extending_distributions.cpython-312.pyc,, +numpy/random/_examples/numba/extending.py,sha256=Ipyzel_h5iU_DMJ_vnXUgQC38uMDMn7adUpWSeEQLFE,1957 +numpy/random/_examples/numba/extending_distributions.py,sha256=M3Rt9RKupwEq71JjxpQFbUO7WKSOuLfR1skRM2a-hbI,2036 +numpy/random/_generator.cpython-312-darwin.so,sha256=-P2BLJEux87gNscmnddQ_Od_-uFSC-SWtnLvmH3TBXc,837360 +numpy/random/_generator.pyi,sha256=10sKaoew5r7dEJYlpESLdpKROrz9h_iEFOTgBZ1PesU,24608 +numpy/random/_mt19937.cpython-312-darwin.so,sha256=qALOUORDaw6Xl9HUFhhCO_4hFJPtngRbsb5txvl7MtM,132848 +numpy/random/_mt19937.pyi,sha256=WWnxy1KiYOun55nB0du7jArWKmJd5GTcltt_L9sPivA,724 +numpy/random/_pcg64.cpython-312-darwin.so,sha256=O4bEkFYh0r3xHM5WBYZ3vCcjbGc3NTQOjngWfgndv74,133344 +numpy/random/_pcg64.pyi,sha256=uxr5CbEJetN6lv9vBG21jlRhuzOK8SQnXrwqAQBxj_c,1091 +numpy/random/_philox.cpython-312-darwin.so,sha256=mln96lrMYhi5QBdKu8w4LQ5OBCM1eWzzAYefC9RwLYA,132320 +numpy/random/_philox.pyi,sha256=6OGeH8PMjzs9t21IdQJAz-5eKkjY4jX0vYgv3bkCwGw,954 +numpy/random/_pickle.py,sha256=4iS9ofvvuD0KKMtRpZEdBslH79blhK8wtjqxeWN_gcE,2743 +numpy/random/_sfc64.cpython-312-darwin.so,sha256=eVleuG_F9xKGGS--JuVVqQpjwfautpvazOpTkB1QtfM,97168 +numpy/random/_sfc64.pyi,sha256=xscekcSRmOwEAmMIwJUUTBYNgYO1I-PN8-JLKJamKLc,631 +numpy/random/bit_generator.cpython-312-darwin.so,sha256=YepRXSI68jskLxUZgrQEDo3bP33imvB0x4EkyP_K0jU,210432 +numpy/random/bit_generator.pxd,sha256=lArpIXSgTwVnJMYc4XX0NGxegXq3h_QsUDK6qeZKbNc,1007 +numpy/random/bit_generator.pyi,sha256=EkXmABq21fF-wiCFmAehXLOSMQJk0fYyEJefzchBi0Q,3595 +numpy/random/c_distributions.pxd,sha256=7DE-mV3H_Dihk4OK4gMHHkyD4tPX1cAi4570zi5CI30,6344 +numpy/random/lib/libnpyrandom.a,sha256=Tu7dmlEVIL0V5YqF3iLImAk9dJwiSgZca7AgJsOGB4E,55288 +numpy/random/mtrand.cpython-312-darwin.so,sha256=dtOtdhtlS6uWHzaLywVb2aflnQSP_EazW_gE0I7RWgk,709424 +numpy/random/mtrand.pyi,sha256=4xzN5Ep8hN_NnOCBRI5PTOSv0gpGwSeev43AN23JXSA,22441 +numpy/random/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +numpy/random/tests/__pycache__/__init__.cpython-312.pyc,, +numpy/random/tests/__pycache__/test_direct.cpython-312.pyc,, +numpy/random/tests/__pycache__/test_extending.cpython-312.pyc,, +numpy/random/tests/__pycache__/test_generator_mt19937.cpython-312.pyc,, +numpy/random/tests/__pycache__/test_generator_mt19937_regressions.cpython-312.pyc,, +numpy/random/tests/__pycache__/test_random.cpython-312.pyc,, +numpy/random/tests/__pycache__/test_randomstate.cpython-312.pyc,, +numpy/random/tests/__pycache__/test_randomstate_regression.cpython-312.pyc,, +numpy/random/tests/__pycache__/test_regression.cpython-312.pyc,, +numpy/random/tests/__pycache__/test_seed_sequence.cpython-312.pyc,, +numpy/random/tests/__pycache__/test_smoke.cpython-312.pyc,, +numpy/random/tests/data/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +numpy/random/tests/data/__pycache__/__init__.cpython-312.pyc,, +numpy/random/tests/data/generator_pcg64_np121.pkl.gz,sha256=EfQ-X70KkHgBAFX2pIPcCUl4MNP1ZNROaXOU75vdiqM,203 +numpy/random/tests/data/generator_pcg64_np126.pkl.gz,sha256=fN8deNVxX-HELA1eIZ32kdtYvc4hwKya6wv00GJeH0Y,208 +numpy/random/tests/data/mt19937-testset-1.csv,sha256=Xkef402AVB-eZgYQkVtoxERHkxffCA9Jyt_oMbtJGwY,15844 +numpy/random/tests/data/mt19937-testset-2.csv,sha256=nsBEQNnff-aFjHYK4thjvUK4xSXDSfv5aTbcE59pOkE,15825 +numpy/random/tests/data/pcg64-testset-1.csv,sha256=xB00DpknGUTTCxDr9L6aNo9Hs-sfzEMbUSS4t11TTfE,23839 +numpy/random/tests/data/pcg64-testset-2.csv,sha256=NTdzTKvG2U7_WyU_IoQUtMzU3kEvDH39CgnR6VzhTkw,23845 +numpy/random/tests/data/pcg64dxsm-testset-1.csv,sha256=vNSUT-gXS_oEw_awR3O30ziVO4seNPUv1UIZ01SfVnI,23833 +numpy/random/tests/data/pcg64dxsm-testset-2.csv,sha256=uylS8PU2AIKZ185OC04RBr_OePweGRtvn-dE4YN0yYA,23839 +numpy/random/tests/data/philox-testset-1.csv,sha256=SedRaIy5zFadmk71nKrGxCFZ6BwKz8g1A9-OZp3IkkY,23852 +numpy/random/tests/data/philox-testset-2.csv,sha256=dWECt-sbfvaSiK8-Ygp5AqyjoN5i26VEOrXqg01rk3g,23838 +numpy/random/tests/data/sfc64-testset-1.csv,sha256=iHs6iX6KR8bxGwKk-3tedAdMPz6ZW8slDSUECkAqC8Q,23840 +numpy/random/tests/data/sfc64-testset-2.csv,sha256=FIDIDFCaPZfWUSxsJMAe58hPNmMrU27kCd9FhCEYt_k,23833 +numpy/random/tests/data/sfc64_np126.pkl.gz,sha256=MVa1ylFy7DUPgUBK-oIeKSdVl4UYEiN3AZ7G3sdzzaw,290 +numpy/random/tests/test_direct.py,sha256=4QsNnYfZZtVq-uiLKnsCOdp3yk_bsLDjIFwC3UGdACs,19251 +numpy/random/tests/test_extending.py,sha256=h9qrU2o5MxaxfzU2aO8x9VCgcyTReWApOXDIfE6uAL0,3988 +numpy/random/tests/test_generator_mt19937.py,sha256=2-kLPE1yPSo-SMuBoTNtbYoTvJLecI3GxUy2wlInHGo,117294 +numpy/random/tests/test_generator_mt19937_regressions.py,sha256=r2wzyXTRfyVk__f2PO9yKPRdwx5ez671OQyAglMfPpc,8094 +numpy/random/tests/test_random.py,sha256=i44DXCHEBtKtOzwSBfADh_kBSjMPgaCJYHdFfs6sfCQ,70150 +numpy/random/tests/test_randomstate.py,sha256=Cp-op2kfopZ8wq-SBQ12Mh5RQ0p8mcBQHYSh0h-DegU,85275 +numpy/random/tests/test_randomstate_regression.py,sha256=xS_HOwtijRdgq-gZn0IDUcm0NxdjjJXYv6ex8WN7FPU,7999 +numpy/random/tests/test_regression.py,sha256=RbAzZYLfyzUKmup5uJR19sK2N17L_d1rLRy-CWjtIaQ,5462 +numpy/random/tests/test_seed_sequence.py,sha256=GNRJ4jyzrtfolOND3gUWamnbvK6-b_p1bBK_RIG0sfU,3311 +numpy/random/tests/test_smoke.py,sha256=CsXvEgv1T3wvCAH6qYu8RCWoQOaI4_gm7aWNhAS4QRg,28174 +numpy/rec/__init__.py,sha256=w2G_npkmqm5vrWgds8V6Gusehmi1bRbiqCxsl9yOjow,83 +numpy/rec/__init__.pyi,sha256=02w4lxCiiwaw1V4hb35x3xn0Xd0Tz83mJGSsYGovxtc,297 +numpy/rec/__pycache__/__init__.cpython-312.pyc,, +numpy/strings/__init__.py,sha256=-hT1HYpbswLkRWswieJQwAYn72IAwuaSCA5S1sdSPMk,83 +numpy/strings/__init__.pyi,sha256=Ki81NEwY5NABr-qIDvAvI3vVbDzCBJ9THlGJK3Zcdbw,1210 +numpy/strings/__pycache__/__init__.cpython-312.pyc,, +numpy/testing/__init__.py,sha256=InpVKoDAzMKO_l_HNcatziW_u1k9_JZze__t2nybrL0,595 +numpy/testing/__init__.pyi,sha256=cYNKSlLuYnm6T1_qJlxRQMzxk9LfIglDSSZFGGTultw,1654 +numpy/testing/__pycache__/__init__.cpython-312.pyc,, +numpy/testing/__pycache__/overrides.cpython-312.pyc,, +numpy/testing/__pycache__/print_coercion_tables.cpython-312.pyc,, +numpy/testing/_private/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +numpy/testing/_private/__pycache__/__init__.cpython-312.pyc,, +numpy/testing/_private/__pycache__/extbuild.cpython-312.pyc,, +numpy/testing/_private/__pycache__/utils.cpython-312.pyc,, +numpy/testing/_private/extbuild.py,sha256=r5Coglv6iICgnKSesD-BUEY3ZhGAfmzx_qBfDSMgiqo,8115 +numpy/testing/_private/utils.py,sha256=-SAtWc-QwJA1VuGcWtw21LQnrgjjPVeWdnyiLDdORVQ,93573 +numpy/testing/_private/utils.pyi,sha256=SXeZE5z-ROrww1w84V5weWd7YLVVKhsoBZRuy_T2JNg,10229 +numpy/testing/overrides.py,sha256=IB0inJ_540YOcATsjm0Qy8jEvrY_mHRI5fQj-yI6Z6Q,2125 +numpy/testing/print_coercion_tables.py,sha256=v9RlpFnOlaw34QGWnDIovDGhG1clwGhha0UnCqni0RE,6223 +numpy/testing/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +numpy/testing/tests/__pycache__/__init__.cpython-312.pyc,, +numpy/testing/tests/__pycache__/test_utils.cpython-312.pyc,, +numpy/testing/tests/test_utils.py,sha256=2iTpm6fC_7QPYWyINCTchagXtW9i8pd8ZbdwKRsse68,70461 +numpy/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +numpy/tests/__pycache__/__init__.cpython-312.pyc,, +numpy/tests/__pycache__/test__all__.cpython-312.pyc,, +numpy/tests/__pycache__/test_configtool.cpython-312.pyc,, +numpy/tests/__pycache__/test_ctypeslib.cpython-312.pyc,, +numpy/tests/__pycache__/test_lazyloading.cpython-312.pyc,, +numpy/tests/__pycache__/test_matlib.cpython-312.pyc,, +numpy/tests/__pycache__/test_numpy_config.cpython-312.pyc,, +numpy/tests/__pycache__/test_numpy_version.cpython-312.pyc,, +numpy/tests/__pycache__/test_public_api.cpython-312.pyc,, +numpy/tests/__pycache__/test_reloading.cpython-312.pyc,, +numpy/tests/__pycache__/test_scripts.cpython-312.pyc,, +numpy/tests/__pycache__/test_warnings.cpython-312.pyc,, +numpy/tests/test__all__.py,sha256=L3mCnYPTpzAgNfedVuq9g7xPWbc0c1Pot94k9jZ9NpI,221 +numpy/tests/test_configtool.py,sha256=lhtwsoUPSOSdgnSdxvrvS4roiid86eWzSrGjdrKkH7g,1555 +numpy/tests/test_ctypeslib.py,sha256=c0x56qlAMnxTCO9MiuV05LCoqju8cidHj1URV5gOwQE,12351 +numpy/tests/test_lazyloading.py,sha256=YETrYiDLAqLX04K_u5_3NVxAfxDoeguxwkIRfz6qKcY,1162 +numpy/tests/test_matlib.py,sha256=gwhIXrJJo9DiecaGLCHLJBjhx2nVGl6yHq80AOUQSRM,1852 +numpy/tests/test_numpy_config.py,sha256=qHvepgi9oyAbQuZD06k7hpcCC2MYhdzcY6D1iQDPNMI,1241 +numpy/tests/test_numpy_version.py,sha256=2d0EtPJZYP3XRE6C6rfJW6QsPlFoDxqgO1yPxObaiE0,1754 +numpy/tests/test_public_api.py,sha256=B2vX4UjxpgqZrB-FBmD8ynu3cVHA8za8j7iQpPrr3v8,22829 +numpy/tests/test_reloading.py,sha256=sGu5XM-_VCNphyJcY5VCoQCmy5MgtL6_hDnsqf2j_ro,2367 +numpy/tests/test_scripts.py,sha256=jluCLfG94VM1cuX-5RcLFBli_yaJZpIvmVuMxRKRJrc,1645 +numpy/tests/test_warnings.py,sha256=HOqWSVu80PY-zacrgMfzPF0XPqEC24BNSw6Lmvw32Vg,2346 +numpy/typing/__init__.py,sha256=ph9_WtDCJ7tKrbbRcz5OZEbXwxRXZfzSd2K1mLab910,5267 +numpy/typing/__pycache__/__init__.cpython-312.pyc,, +numpy/typing/__pycache__/mypy_plugin.cpython-312.pyc,, +numpy/typing/mypy_plugin.py,sha256=r53CPvn4IujSWOAnub_InD44qc90-XmSpUSXOIhWZ74,6409 +numpy/typing/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +numpy/typing/tests/__pycache__/__init__.cpython-312.pyc,, +numpy/typing/tests/__pycache__/test_isfile.cpython-312.pyc,, +numpy/typing/tests/__pycache__/test_runtime.cpython-312.pyc,, +numpy/typing/tests/__pycache__/test_typing.cpython-312.pyc,, +numpy/typing/tests/data/fail/arithmetic.pyi,sha256=HKbBj3T6tw0jkJ-QOtm6zZDaYf7637F38fGbj2UJk8g,3778 +numpy/typing/tests/data/fail/array_constructors.pyi,sha256=SjiwoGrefYsuScJcBQZlwzfvENADeRMxHYCDCo685Vc,1129 +numpy/typing/tests/data/fail/array_like.pyi,sha256=OVAlEJZ5k8ZRKt0aGpZQwIjlUGpy0PzOOYqfI-IMqBQ,455 +numpy/typing/tests/data/fail/array_pad.pyi,sha256=57oK0Yp53rtKjjIrRFYLcxa-IfIGhtI-bEem7ggJKwI,132 +numpy/typing/tests/data/fail/arrayprint.pyi,sha256=f27hi9dyYgh3JbEuvFroYwTKU2a7ZUKUcOEgqiZLioo,590 +numpy/typing/tests/data/fail/arrayterator.pyi,sha256=Qb7oMI1GdDQO_jcoJEAsMkXLjzOdcb3sx-b5mW73cAE,470 +numpy/typing/tests/data/fail/bitwise_ops.pyi,sha256=gJ-ZL-e-yMbHMRKUv8r2KqJ08Mkgpg74nUe6lgi2RDU,583 +numpy/typing/tests/data/fail/char.pyi,sha256=Zi3dygeaxHT8-5aFNCAreGU-T89zLg5pcE6c9NBCs6c,2712 +numpy/typing/tests/data/fail/chararray.pyi,sha256=cWyxV7TuJVUHlhxgkmktqZSzt8KghctCc3eOfOvsK5g,2306 +numpy/typing/tests/data/fail/comparisons.pyi,sha256=YrcL2POtM1g8GEWW4AJMl9vAkV-lG_6kEb7FzueeiLU,822 +numpy/typing/tests/data/fail/constants.pyi,sha256=IzmswvmTKbAOkCjgyxu1jChlikIwqeAETHGVH2TtY0k,85 +numpy/typing/tests/data/fail/datasource.pyi,sha256=gACpSdzMDej9WZbNvDQlkWX9DvHD7DjucesbH0EWEaM,405 +numpy/typing/tests/data/fail/dtype.pyi,sha256=OAGABqdXNB8gClJFEGMckoycuZcIasMaAlS2RkiKROI,334 +numpy/typing/tests/data/fail/einsumfunc.pyi,sha256=32Bsrr3ueX2CMaiBZN1xLGGsbjqKZWF2WopvNWRqCT4,487 +numpy/typing/tests/data/fail/false_positives.pyi,sha256=Q61qMsSsNCtmO0EMRxHj5Z7RYTyrELVpkzfJY5eK8Z0,366 +numpy/typing/tests/data/fail/flatiter.pyi,sha256=JcggwDkKcMWDBz0Ky8-dkJzjwnKxQ-kyea5br5DDqq0,866 +numpy/typing/tests/data/fail/fromnumeric.pyi,sha256=57E3-vHlXpN9YC6jkpBbAlHaydbRlgK49LZ019IM68Y,5591 +numpy/typing/tests/data/fail/histograms.pyi,sha256=yAPVt0rYTwtxnigoGT-u7hhKCE9iYxsXc24x2HGBrmA,367 +numpy/typing/tests/data/fail/index_tricks.pyi,sha256=moINir9iQoi6Q1ZuVg5BuSB9hSBtbg_uzv-Qm_lLYZk,509 +numpy/typing/tests/data/fail/lib_function_base.pyi,sha256=0Wb5Dy0A2NRXWIBrjZ3Gsu6XkulJUu1lHECw5tUkVUI,1950 +numpy/typing/tests/data/fail/lib_polynomial.pyi,sha256=Ur7Y4iZX6WmoH5SDm0ePi8C8LPsuPs2Yr7g7P5O613g,899 +numpy/typing/tests/data/fail/lib_utils.pyi,sha256=6oI_kPhJqL0P0q-rsC3WtGso3V-hF7ntbNUmbhUPfXE,96 +numpy/typing/tests/data/fail/lib_version.pyi,sha256=7-ZJDZwDcB-wzpMN8TeYtZAgaqc7xnQ8Dnx2ISiX2Ts,158 +numpy/typing/tests/data/fail/linalg.pyi,sha256=yDd05aK1dI37RPt3pD2eJYo4dZFaT2yB1PEu3K0y9Tg,1322 +numpy/typing/tests/data/fail/memmap.pyi,sha256=HSTCQYNuW1Y6X1Woj361pN4rusSPs4oDCXywqk20yUo,159 +numpy/typing/tests/data/fail/modules.pyi,sha256=_ek4zKcdP-sIh_f-IDY0tP-RbLORKCSWelM9AOYxsyA,670 +numpy/typing/tests/data/fail/multiarray.pyi,sha256=1_9X7BW6hukiappz0kn3WCWN6OWXtT6OQqmJmJpdkfQ,1643 +numpy/typing/tests/data/fail/ndarray.pyi,sha256=cgoWlpQqBQ5pkfiYsoz2f6o-DASrVRCraKBCgXLJQSk,404 +numpy/typing/tests/data/fail/ndarray_misc.pyi,sha256=VaPL5mDB0OkHpDslehpIG_420O5-qDGNnLMCMJfwQVo,1333 +numpy/typing/tests/data/fail/nditer.pyi,sha256=w7emjnOxnf3NcvLktNLlke6Cuivn2gU3sVmGCfbG6rw,325 +numpy/typing/tests/data/fail/nested_sequence.pyi,sha256=em4GZwLDFE0QSxxg081wVwhh-Dmtkn8f7wThI0DiXVs,427 +numpy/typing/tests/data/fail/npyio.pyi,sha256=ix5WhSp3vKf7UZE5X6h_Cs1gOIhzisHpMoOCfEg8Dpo,518 +numpy/typing/tests/data/fail/numerictypes.pyi,sha256=jl_pxMAq_VmkaK13-sfhUOUYGAQ4OV2pQ1d7wG-DNZg,120 +numpy/typing/tests/data/fail/random.pyi,sha256=0sFOsJeHwYc1cUNF-MByWONEF_MP8CQWTjdyGFvgl90,2821 +numpy/typing/tests/data/fail/rec.pyi,sha256=Ws3TyesnoQjt7Q0wwtpShRDJmZCs2jjP17buFMomVGA,704 +numpy/typing/tests/data/fail/scalars.pyi,sha256=hr5uVhIa0DcpRxKleFTgUmsrN6XXoxM-uhQsV2_ZYn0,2951 +numpy/typing/tests/data/fail/shape.pyi,sha256=pSxiQ6Stq60xGFKOGZUsisxIO0y4inJ8UpKeio89K04,137 +numpy/typing/tests/data/fail/shape_base.pyi,sha256=Y_f4buHtX2Q2ZA4kaDTyR8LErlPXTzCB_-jBoScGh_Q,152 +numpy/typing/tests/data/fail/stride_tricks.pyi,sha256=IjA0Xrnx0lG3m07d1Hjbhtyo1Te5cXgjgr5fLUo4LYQ,315 +numpy/typing/tests/data/fail/strings.pyi,sha256=l4Q3_tyER2UESkzKZPyVpaIweuzbYzYyR1drV_k_eFk,2842 +numpy/typing/tests/data/fail/testing.pyi,sha256=e7b5GKTWCtKGoB8z2a8edsW0Xjl1rMheALsvzEJjlCw,1370 +numpy/typing/tests/data/fail/twodim_base.pyi,sha256=eRFtqBbwkVI6G6MZMVpep1UKnFMDYzhrN82fO3ilnH0,898 +numpy/typing/tests/data/fail/type_check.pyi,sha256=CIyI0j0Buxv0QgCvNG2urjaKpoIZ-ZNawC2m6NzGlbo,379 +numpy/typing/tests/data/fail/ufunc_config.pyi,sha256=0t_yJ4eVOhneDSfa3EsoTh6RreyMtkHVOi9oQ35_EW0,734 +numpy/typing/tests/data/fail/ufunclike.pyi,sha256=JsJ3M8QZv9-6GKwRnojJGIfeIkdtJFe-3ix5reLXx-M,627 +numpy/typing/tests/data/fail/ufuncs.pyi,sha256=8N8m_GbRAH0bWjDEzYnH4MREX86iBD46Ug9mm-vc1co,476 +numpy/typing/tests/data/fail/warnings_and_errors.pyi,sha256=KXExnFGz9O7Veut_U7YEIpi6x-BdfeaGtpqWf1Yd274,185 +numpy/typing/tests/data/misc/extended_precision.pyi,sha256=bS8bBeCFqjgtOiy-8_y39wfa7rwhdjLz2Vmo-RXAYD4,884 +numpy/typing/tests/data/mypy.ini,sha256=KLojiWL5k-6Aj-b6Y3kyv2q4OoK3L5M7z2g5VT5Cor0,168 +numpy/typing/tests/data/pass/__pycache__/arithmetic.cpython-312.pyc,, +numpy/typing/tests/data/pass/__pycache__/array_constructors.cpython-312.pyc,, +numpy/typing/tests/data/pass/__pycache__/array_like.cpython-312.pyc,, +numpy/typing/tests/data/pass/__pycache__/arrayprint.cpython-312.pyc,, +numpy/typing/tests/data/pass/__pycache__/arrayterator.cpython-312.pyc,, +numpy/typing/tests/data/pass/__pycache__/bitwise_ops.cpython-312.pyc,, +numpy/typing/tests/data/pass/__pycache__/comparisons.cpython-312.pyc,, +numpy/typing/tests/data/pass/__pycache__/dtype.cpython-312.pyc,, +numpy/typing/tests/data/pass/__pycache__/einsumfunc.cpython-312.pyc,, +numpy/typing/tests/data/pass/__pycache__/flatiter.cpython-312.pyc,, +numpy/typing/tests/data/pass/__pycache__/fromnumeric.cpython-312.pyc,, +numpy/typing/tests/data/pass/__pycache__/index_tricks.cpython-312.pyc,, +numpy/typing/tests/data/pass/__pycache__/lib_utils.cpython-312.pyc,, +numpy/typing/tests/data/pass/__pycache__/lib_version.cpython-312.pyc,, +numpy/typing/tests/data/pass/__pycache__/literal.cpython-312.pyc,, +numpy/typing/tests/data/pass/__pycache__/ma.cpython-312.pyc,, +numpy/typing/tests/data/pass/__pycache__/mod.cpython-312.pyc,, +numpy/typing/tests/data/pass/__pycache__/modules.cpython-312.pyc,, +numpy/typing/tests/data/pass/__pycache__/multiarray.cpython-312.pyc,, +numpy/typing/tests/data/pass/__pycache__/ndarray_conversion.cpython-312.pyc,, +numpy/typing/tests/data/pass/__pycache__/ndarray_misc.cpython-312.pyc,, +numpy/typing/tests/data/pass/__pycache__/ndarray_shape_manipulation.cpython-312.pyc,, +numpy/typing/tests/data/pass/__pycache__/numeric.cpython-312.pyc,, +numpy/typing/tests/data/pass/__pycache__/numerictypes.cpython-312.pyc,, +numpy/typing/tests/data/pass/__pycache__/random.cpython-312.pyc,, +numpy/typing/tests/data/pass/__pycache__/scalars.cpython-312.pyc,, +numpy/typing/tests/data/pass/__pycache__/shape.cpython-312.pyc,, +numpy/typing/tests/data/pass/__pycache__/simple.cpython-312.pyc,, +numpy/typing/tests/data/pass/__pycache__/simple_py3.cpython-312.pyc,, +numpy/typing/tests/data/pass/__pycache__/ufunc_config.cpython-312.pyc,, +numpy/typing/tests/data/pass/__pycache__/ufunclike.cpython-312.pyc,, +numpy/typing/tests/data/pass/__pycache__/ufuncs.cpython-312.pyc,, +numpy/typing/tests/data/pass/__pycache__/warnings_and_errors.cpython-312.pyc,, +numpy/typing/tests/data/pass/arithmetic.py,sha256=hTtW4N1AdLDZNHCqK1--td9RQbEysSaWx9TIjmfvUo0,7532 +numpy/typing/tests/data/pass/array_constructors.py,sha256=rfJ8SRB4raElxRjsHBCsZIkZAfqZMie0VE8sSKMgkHg,2447 +numpy/typing/tests/data/pass/array_like.py,sha256=Pptxuxfy0ccmLo47LTA8VFohJh6rXxl8V5Xsm1ym_Q8,1018 +numpy/typing/tests/data/pass/arrayprint.py,sha256=y_KkuLz1uM7pv53qfq7GQOuud4LoXE3apK1wtARdVyM,766 +numpy/typing/tests/data/pass/arrayterator.py,sha256=FqcpKdUQBQ0FazHFxr9MsLEZG-jnJVGKWZX2owRr4DQ,393 +numpy/typing/tests/data/pass/bitwise_ops.py,sha256=FmEs_sKaU9ox-5f0NU3_TRIv0XxLQVEZ8rou9VNehb4,964 +numpy/typing/tests/data/pass/comparisons.py,sha256=0H6YT3cRqKkWNwX-VXJPZG3Xh6xvjkogADQH8zInk0c,2993 +numpy/typing/tests/data/pass/dtype.py,sha256=YDuYAb0oKoJc9eOnKJuoPfLbIKOgEdE04_CYxRS4U5I,1070 +numpy/typing/tests/data/pass/einsumfunc.py,sha256=eXj5L5MWPtQHgrHPsJ36qqrmBHqct9UoujjJCvHnF1k,1370 +numpy/typing/tests/data/pass/flatiter.py,sha256=0BnbuLMBC7MQlprNZ0QhNSscfYwPhEhXOhWoyiRACWU,174 +numpy/typing/tests/data/pass/fromnumeric.py,sha256=d_hVLyrVDFPVx33aqLIyAGYYQ8XAJFIzrAsE8QCoof4,3991 +numpy/typing/tests/data/pass/index_tricks.py,sha256=oaFD9vY01_RI5OkrXt-xTk1n_dd-SpuPp-eZ58XR3c8,1492 +numpy/typing/tests/data/pass/lib_utils.py,sha256=bj1sEA4gsmezqbYdqKnVtKzY_fb64w7PEoZwNvaaUdA,317 +numpy/typing/tests/data/pass/lib_version.py,sha256=HnuGOx7tQA_bcxFIJ3dRoMAR0fockxg4lGqQ4g7LGIw,299 +numpy/typing/tests/data/pass/literal.py,sha256=ObHVl2_Ja7-DSR-2FfuFwW8US-O0opZmChPmIDhQzgw,1360 +numpy/typing/tests/data/pass/ma.py,sha256=slJZQFGPI4I13qc-CRfreEGhIUk4TdFk-Pv75yWanNM,171 +numpy/typing/tests/data/pass/mod.py,sha256=owFL1fys3LPTWpAlsjS-IzW4sSu98ncp2BnsIetLSrA,1576 +numpy/typing/tests/data/pass/modules.py,sha256=g9PhyLO6rflYHZtmryx1VWTubphN4TAPUSfoiYriTqE,625 +numpy/typing/tests/data/pass/multiarray.py,sha256=MxHax6l94yqlTVZleAqG77ILEbW6wU5osPcHzxJ85ns,1331 +numpy/typing/tests/data/pass/ndarray_conversion.py,sha256=d7cFNUrofdLXh9T_9RG3Esz1XOihWWQNlz5Lb0yt6dM,1525 +numpy/typing/tests/data/pass/ndarray_misc.py,sha256=UOZZdelG843BuO11QAvfnB2W6NRA0aCsVnCoukQJTxk,2619 +numpy/typing/tests/data/pass/ndarray_shape_manipulation.py,sha256=37eYwMNqMLwanIW9-63hrokacnSz2K_qtPUlkdpsTjo,640 +numpy/typing/tests/data/pass/numeric.py,sha256=bn0SCWOUKks0LOa8xIV8LwoXh9M_ERQsKl68vez8aBM,1531 +numpy/typing/tests/data/pass/numerictypes.py,sha256=6x6eN9-5NsSQUSc6rf3fYieS2poYEY0t_ujbwgF9S5Q,331 +numpy/typing/tests/data/pass/random.py,sha256=LOycKHYsF1F0OvXC6W0rfdwuDGT0p1xypdqbsF4mU6Q,61810 +numpy/typing/tests/data/pass/scalars.py,sha256=7jy6s0VuTPnGxlqZOLdPicefyKt3SAzdC2sHtONrMzk,3393 +numpy/typing/tests/data/pass/shape.py,sha256=ZilyhS3fdV49sPUJAsdBuumMayULMc0syF0WD0NaKQY,369 +numpy/typing/tests/data/pass/simple.py,sha256=kQEQK59ISrra5i7p-_ijdRq9OdCdV0l7GEalDQtC1VQ,2737 +numpy/typing/tests/data/pass/simple_py3.py,sha256=HuLrc5aphThQkLjU2_19KgGFaXwKOfSzXe0p2xMm8ZI,96 +numpy/typing/tests/data/pass/ufunc_config.py,sha256=uzXOhCl9N4LPV9hV2Iqg_skgkKMbBPBF0GXPU9EMeuE,1205 +numpy/typing/tests/data/pass/ufunclike.py,sha256=U4Aay11VALvm22bWEX0eDWuN5qxJlg_hH5IpOL62M3I,1125 +numpy/typing/tests/data/pass/ufuncs.py,sha256=1Rem_geEm4qyD3XaRA1NAPKwr3YjRq68zbIlC_Xhi9M,422 +numpy/typing/tests/data/pass/warnings_and_errors.py,sha256=ETLZkDTGpZspvwjVYAZlnA1gH4PJ4bSY5PkWyxTjusU,161 +numpy/typing/tests/data/reveal/arithmetic.pyi,sha256=Oqg-yp6l9Iie7IiTrmHg2vEKj_3AAVu-REqJR-_NCJw,19762 +numpy/typing/tests/data/reveal/array_api_info.pyi,sha256=B9vrUZokB3taS3TeNXf_pKmbMoh0n-dvRpBWcZPfwpc,3142 +numpy/typing/tests/data/reveal/array_constructors.pyi,sha256=CK_MDzsXFECNOITU43pTkdHkIWNoQwcBzKGgi9UslBU,11004 +numpy/typing/tests/data/reveal/arraypad.pyi,sha256=Q1pcU4B3eRsw5jsv-S0MsEfNUbp_4aMdO_o3n0rtA2A,776 +numpy/typing/tests/data/reveal/arrayprint.pyi,sha256=soSfSAZPBOI3dvaHW5DXIUmTGDFaljbvcVXIqQjgZmk,905 +numpy/typing/tests/data/reveal/arraysetops.pyi,sha256=MApdRBAeWajSdDQFVCF4yF8-WZhOJLJUmZkqBz_fmzY,4509 +numpy/typing/tests/data/reveal/arrayterator.pyi,sha256=Sdl-xlxIVYSZnB9C0Mo6GwXzcJRFHz7kwQevIuWW6Zk,1097 +numpy/typing/tests/data/reveal/bitwise_ops.pyi,sha256=WIwuobIYzgJhN3Wm-nYqJftxN5R1AzhMC8oV4FaFVHU,3911 +numpy/typing/tests/data/reveal/char.pyi,sha256=-LyIxSayAdJDHICYq7KaMgHAnGDjPvZ4ezQzNRZ6Uds,7197 +numpy/typing/tests/data/reveal/chararray.pyi,sha256=r_i5FIC-2WWu6xd8uCsEmrndwQRyfIqY3KZ9ARVOdx0,6259 +numpy/typing/tests/data/reveal/comparisons.pyi,sha256=wcWh7WRI5lPOk4bMtaSWdbEeIhJG2uWNxFXTd2eFbUg,7313 +numpy/typing/tests/data/reveal/constants.pyi,sha256=22VOM0_IpimXviyx98OTfNVHtFu4XsPAuN7F04q1xhA,393 +numpy/typing/tests/data/reveal/ctypeslib.pyi,sha256=cj8a0Z_DQZJOlZ3BqtCjKIroJz9vQkWCaAgES2GxkRk,4814 +numpy/typing/tests/data/reveal/datasource.pyi,sha256=A10C5zPFLo7ggtCJdeWSx4U15ZaXXOjE6_rM91zi120,701 +numpy/typing/tests/data/reveal/dtype.pyi,sha256=eQeL3ny5S6aESd3ut3NjZAFR4my2jn-8nqIR9WH2HnQ,2874 +numpy/typing/tests/data/reveal/einsumfunc.pyi,sha256=pbtSfzIWUJRkDpe2riHBlvFlNSC3CqVM-SbYtBgX9H0,2044 +numpy/typing/tests/data/reveal/emath.pyi,sha256=-muNpWOv_niIn-zS3gUnFO4qBZAouNlVGue2x1L5Ris,2423 +numpy/typing/tests/data/reveal/false_positives.pyi,sha256=AplTmZV7TS7nivU8vegbstMN5MdMv4U0JJdZ4IeeA5M,482 +numpy/typing/tests/data/reveal/fft.pyi,sha256=ReQ9qn5frvJEy-g0RWpUGlPBntUS1cFSIu6WfPotHzE,1749 +numpy/typing/tests/data/reveal/flatiter.pyi,sha256=pY8X8zjG8VpQOGf-NFGxN6eBYHhyqsKfxrHLSp-5JLo,1470 +numpy/typing/tests/data/reveal/fromnumeric.pyi,sha256=DVYei9Ar5v7vG9DiwPprzBb-OYF2Pc1YJTEFHUOatcM,13265 +numpy/typing/tests/data/reveal/getlimits.pyi,sha256=VK59PfKYvl8cF5joz3oUXyI9UgqSBdPIl-1uJzJ-oso,1642 +numpy/typing/tests/data/reveal/histograms.pyi,sha256=wTkDU-4kSjz5ybOgb0-R7sQQO4U1_1FC0U_tM9W_PUg,1375 +numpy/typing/tests/data/reveal/index_tricks.pyi,sha256=SUkSqiPhuYAA8f_XFkyF9YjQH9jmtzYDGqvfOenKyqg,3566 +numpy/typing/tests/data/reveal/lib_function_base.pyi,sha256=xOTYIua7jmWPvhZ2LusgjodO9gsABPFziS6IweHGoAM,8936 +numpy/typing/tests/data/reveal/lib_polynomial.pyi,sha256=gPrcYAohiyFlC3IgXqMOc-9UB5_oHL6ejG3ZK2hlEZA,5983 +numpy/typing/tests/data/reveal/lib_utils.pyi,sha256=hYb7ELrXZXK9xpG4Sm_sRbwRuBS6moMJJ4V7yJJpdhk,536 +numpy/typing/tests/data/reveal/lib_version.pyi,sha256=UCioUeykot8-nWL6goKxZnKZxtgB4lFEi9wdN_xyF1U,672 +numpy/typing/tests/data/reveal/linalg.pyi,sha256=RzeKBHXnW1U2Q9krz5F6EZSmk_yjo29T1R-iDyeb8gw,6324 +numpy/typing/tests/data/reveal/matrix.pyi,sha256=1Dl5XuO7xCRAnox5EwM-ySj9asFWx2N09Cj8eG9Q8OU,2918 +numpy/typing/tests/data/reveal/memmap.pyi,sha256=A5PovMzjRp2zslF1vw3TdTQjj4Y0dIEJ__HDBV_svGM,842 +numpy/typing/tests/data/reveal/mod.pyi,sha256=1MKvcgPBWEWEiAtTmQCkDcqX2haPYJx3c-6XF_PtCQU,5664 +numpy/typing/tests/data/reveal/modules.pyi,sha256=0WPq7A-aqWkJsV-IA1_7dFNCcxBacj1AWExaXbXErG4,1958 +numpy/typing/tests/data/reveal/multiarray.pyi,sha256=v0Xgh013jdYuBsHGg2qJRPldiLpuOkl0RLIOzWiA61U,5149 +numpy/typing/tests/data/reveal/nbit_base_example.pyi,sha256=DRUMGatQvQXTuovKEMF4dzazIU6it6FU53LkOEo2vNo,657 +numpy/typing/tests/data/reveal/ndarray_conversion.pyi,sha256=ovigNoNijqvE-Z1ZvGSWEwqG8Rut8JCInj_bMdoEYz4,1856 +numpy/typing/tests/data/reveal/ndarray_misc.pyi,sha256=J5fq1z_SSjczJOXMFj3K0wwWPAMi-7ewQSg7ZIdNXDY,7354 +numpy/typing/tests/data/reveal/ndarray_shape_manipulation.pyi,sha256=QDQ9g6l-e73pTJp-Dosiynb-okbqi91D4KirjhIjcv4,1233 +numpy/typing/tests/data/reveal/nditer.pyi,sha256=VFXnT75BgWSUpb-dD-q5cZkfeOqsk-x9cH626g9FWT4,2021 +numpy/typing/tests/data/reveal/nested_sequence.pyi,sha256=IQyRlXduk-ZEakOtoliMLCqNgGbeg0mzZf-a-a3Gq_0,734 +numpy/typing/tests/data/reveal/npyio.pyi,sha256=CimelY4GQX-RMx6FjBz99egW3X7bZGaG0rInQXZaR6s,3611 +numpy/typing/tests/data/reveal/numeric.pyi,sha256=--WlV8PubhLm151OKLk7qwuuryPQaJ1v7G8ePNZN-9Q,6152 +numpy/typing/tests/data/reveal/numerictypes.pyi,sha256=TXsRnRhWFwdxckiQH_aJ1pfJbXnUfYS1OrhlixyP-2U,1390 +numpy/typing/tests/data/reveal/polynomial_polybase.pyi,sha256=LMlqHMbwRSpzQT6LiqWIykKZgO59viVVmdetzEyreHs,8102 +numpy/typing/tests/data/reveal/polynomial_polyutils.pyi,sha256=1R4tvQVZb6zXq7ZpiaU-7sZxBbEl9QbbCXwe5wS306g,10905 +numpy/typing/tests/data/reveal/polynomial_series.pyi,sha256=CuhuEoOTcbwoBmgFjQ3Tp8dadRKlwoAw1wRTPB57lw0,7216 +numpy/typing/tests/data/reveal/random.pyi,sha256=GratcSvCMhnV0oRvCrf1_5NwYrKvQFQHxUtJ3leWGAM,104393 +numpy/typing/tests/data/reveal/rec.pyi,sha256=tQS7ozIsq6uJ-atFuluT_pNkgQDqYl-zfXkCwNftlcw,3853 +numpy/typing/tests/data/reveal/scalars.pyi,sha256=PWo_pzZnTJKL7d3dbPLnq1d_9DEO3Y8VR-Kg7u_7kRQ,4591 +numpy/typing/tests/data/reveal/shape.pyi,sha256=r0y0iSyVabz6hnIRQFdomLV6yvPqiXrGm0pVtTmm1Eg,292 +numpy/typing/tests/data/reveal/shape_base.pyi,sha256=cU-ud4H33LXQ-tgmrEoOZ3ofIpER0KbDf4hOSr6-7zE,2134 +numpy/typing/tests/data/reveal/stride_tricks.pyi,sha256=9-XEw94BheIL7mFuW4KdWgFCqpYxjH7I9tKYBougMEc,1433 +numpy/typing/tests/data/reveal/strings.pyi,sha256=kfz7t_jZjUFvtp2ySC0H3NW8xtUcptPdltKh9Bew6zw,6373 +numpy/typing/tests/data/reveal/testing.pyi,sha256=-uDO8ueb84xFgzrj1HGrLqtnhrRr5_4HCVlccBcdAZc,8610 +numpy/typing/tests/data/reveal/twodim_base.pyi,sha256=0BpwrWZVzJH1M1dphlurTfk_9_IC2Y9tOnmPWAltKTw,4387 +numpy/typing/tests/data/reveal/type_check.pyi,sha256=wKHbJXNosHyuV5Cmk3XdI4tAEmYgz-JklOD6P4pEblA,2756 +numpy/typing/tests/data/reveal/ufunc_config.pyi,sha256=m9Cu_D8ygBCXWP_86cnfz5xHjTXFkVTxv-E_TuSQlW4,1316 +numpy/typing/tests/data/reveal/ufunclike.pyi,sha256=5VhzeeEJTTY0s3RObhWIsxpuGAvpBG0BE9acvODPROU,1321 +numpy/typing/tests/data/reveal/ufuncs.pyi,sha256=0WNLpLljh_EBKpHmN84Y5b5TM0rVwGf_SExGxoIHvG0,4512 +numpy/typing/tests/data/reveal/warnings_and_errors.pyi,sha256=4KVv0HCz6Fu54WPq-594ruuPiPIGSiLewfRDAScNxrM,549 +numpy/typing/tests/test_isfile.py,sha256=77lnjlxFqhrIRfGpSrqmvIVwpo9VoOPGiS7rRQSdKT0,865 +numpy/typing/tests/test_runtime.py,sha256=2qu8JEliITnZCBJ_QJpohacj_OQ08o73ixS2w2ooNXI,3275 +numpy/typing/tests/test_typing.py,sha256=A5JAOarysBiYRo5kKlANM0iYQ8xTETk0Uf-zVrl8ihE,8306 +numpy/version.py,sha256=Vv6Fqb2ltfMLT851uHmE2kfj-0T064KrD5cdYrjFVCM,293 +numpy/version.pyi,sha256=vD0wC6rZasZXrv6VKzpyvgMcCb0cUB8AaMEyMZvY2Yc,476 diff --git a/venv/lib/python3.12/site-packages/numpy-2.1.3.dist-info/REQUESTED b/venv/lib/python3.12/site-packages/numpy-2.1.3.dist-info/REQUESTED new file mode 100644 index 00000000..e69de29b diff --git a/venv/lib/python3.12/site-packages/numpy-2.1.3.dist-info/WHEEL b/venv/lib/python3.12/site-packages/numpy-2.1.3.dist-info/WHEEL new file mode 100644 index 00000000..7e75f604 --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy-2.1.3.dist-info/WHEEL @@ -0,0 +1,4 @@ +Wheel-Version: 1.0 +Generator: meson +Root-Is-Purelib: false +Tag: cp312-cp312-macosx_14_0_arm64 \ No newline at end of file diff --git a/venv/lib/python3.12/site-packages/numpy-2.1.3.dist-info/entry_points.txt b/venv/lib/python3.12/site-packages/numpy-2.1.3.dist-info/entry_points.txt new file mode 100644 index 00000000..963c00f7 --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy-2.1.3.dist-info/entry_points.txt @@ -0,0 +1,10 @@ +[array_api] +numpy = numpy + +[pyinstaller40] +hook-dirs = numpy:_pyinstaller_hooks_dir + +[console_scripts] +f2py = numpy.f2py.f2py2e:main +numpy-config = numpy._configtool:main + diff --git a/venv/lib/python3.12/site-packages/numpy/__config__.py b/venv/lib/python3.12/site-packages/numpy/__config__.py new file mode 100644 index 00000000..4d75d9bd --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/__config__.py @@ -0,0 +1,162 @@ +# This file is generated by numpy's build process +# It contains system_info results at the time of building this package. +from enum import Enum +from numpy._core._multiarray_umath import ( + __cpu_features__, + __cpu_baseline__, + __cpu_dispatch__, +) + +__all__ = ["show"] +_built_with_meson = True + + +class DisplayModes(Enum): + stdout = "stdout" + dicts = "dicts" + + +def _cleanup(d): + """ + Removes empty values in a `dict` recursively + This ensures we remove values that Meson could not provide to CONFIG + """ + if isinstance(d, dict): + return {k: _cleanup(v) for k, v in d.items() if v and _cleanup(v)} + else: + return d + + +CONFIG = _cleanup( + { + "Compilers": { + "c": { + "name": "clang", + "linker": r"ld64", + "version": "15.0.0", + "commands": r"cc", + "args": r"", + "linker args": r"", + }, + "cython": { + "name": "cython", + "linker": r"cython", + "version": "3.0.11", + "commands": r"cython", + "args": r"", + "linker args": r"", + }, + "c++": { + "name": "clang", + "linker": r"ld64", + "version": "15.0.0", + "commands": r"c++", + "args": r"", + "linker args": r"", + }, + }, + "Machine Information": { + "host": { + "cpu": "aarch64", + "family": "aarch64", + "endian": "little", + "system": "darwin", + }, + "build": { + "cpu": "aarch64", + "family": "aarch64", + "endian": "little", + "system": "darwin", + }, + "cross-compiled": bool("False".lower().replace("false", "")), + }, + "Build Dependencies": { + "blas": { + "name": "accelerate", + "found": bool("True".lower().replace("false", "")), + "version": "unknown", + "detection method": "system", + "include directory": r"unknown", + "lib directory": r"unknown", + "openblas configuration": r"unknown", + "pc file directory": r"unknown", + }, + "lapack": { + "name": "accelerate", + "found": bool("True".lower().replace("false", "")), + "version": "unknown", + "detection method": "system", + "include directory": r"unknown", + "lib directory": r"unknown", + "openblas configuration": r"unknown", + "pc file directory": r"unknown", + }, + }, + "Python Information": { + "path": r"/private/var/folders/g6/rgtlsw6n123b0gt5483s5_cm0000gn/T/build-env-l0yq0xr5/bin/python", + "version": "3.12", + }, + "SIMD Extensions": { + "baseline": __cpu_baseline__, + "found": [ + feature for feature in __cpu_dispatch__ if __cpu_features__[feature] + ], + "not found": [ + feature for feature in __cpu_dispatch__ if not __cpu_features__[feature] + ], + }, + } +) + + +def _check_pyyaml(): + import yaml + + return yaml + + +def show(mode=DisplayModes.stdout.value): + """ + Show libraries and system information on which NumPy was built + and is being used + + Parameters + ---------- + mode : {`'stdout'`, `'dicts'`}, optional. + Indicates how to display the config information. + `'stdout'` prints to console, `'dicts'` returns a dictionary + of the configuration. + + Returns + ------- + out : {`dict`, `None`} + If mode is `'dicts'`, a dict is returned, else None + + See Also + -------- + get_include : Returns the directory containing NumPy C + header files. + + Notes + ----- + 1. The `'stdout'` mode will give more readable + output if ``pyyaml`` is installed + + """ + if mode == DisplayModes.stdout.value: + try: # Non-standard library, check import + yaml = _check_pyyaml() + + print(yaml.dump(CONFIG)) + except ModuleNotFoundError: + import warnings + import json + + warnings.warn("Install `pyyaml` for better output", stacklevel=1) + print(json.dumps(CONFIG, indent=2)) + elif mode == DisplayModes.dicts.value: + return CONFIG + else: + raise AttributeError( + f"Invalid `mode`, use one of: {', '.join([e.value for e in DisplayModes])}" + ) diff --git a/venv/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd b/venv/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd new file mode 100644 index 00000000..2151a18b --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd @@ -0,0 +1,1225 @@ +# NumPy static imports for Cython >= 3.0 +# +# If any of the PyArray_* functions are called, import_array must be +# called first. This is done automatically by Cython 3.0+ if a call +# is not detected inside of the module. +# +# Author: Dag Sverre Seljebotn +# + +from cpython.ref cimport Py_INCREF +from cpython.object cimport PyObject, PyTypeObject, PyObject_TypeCheck +cimport libc.stdio as stdio + + +cdef extern from *: + # Leave a marker that the NumPy declarations came from NumPy itself and not from Cython. + # See https://github.com/cython/cython/issues/3573 + """ + /* Using NumPy API declarations from "numpy/__init__.cython-30.pxd" */ + """ + + +cdef extern from "numpy/arrayobject.h": + # It would be nice to use size_t and ssize_t, but ssize_t has special + # implicit conversion rules, so just use "long". + # Note: The actual type only matters for Cython promotion, so long + # is closer than int, but could lead to incorrect promotion. + # (Not to worrying, and always the status-quo.) + ctypedef signed long npy_intp + ctypedef unsigned long npy_uintp + + ctypedef unsigned char npy_bool + + ctypedef signed char npy_byte + ctypedef signed short npy_short + ctypedef signed int npy_int + ctypedef signed long npy_long + ctypedef signed long long npy_longlong + + ctypedef unsigned char npy_ubyte + ctypedef unsigned short npy_ushort + ctypedef unsigned int npy_uint + ctypedef unsigned long npy_ulong + ctypedef unsigned long long npy_ulonglong + + ctypedef float npy_float + ctypedef double npy_double + ctypedef long double npy_longdouble + + ctypedef signed char npy_int8 + ctypedef signed short npy_int16 + ctypedef signed int npy_int32 + ctypedef signed long long npy_int64 + ctypedef signed long long npy_int96 + ctypedef signed long long npy_int128 + + ctypedef unsigned char npy_uint8 + ctypedef unsigned short npy_uint16 + ctypedef unsigned int npy_uint32 + ctypedef unsigned long long npy_uint64 + ctypedef unsigned long long npy_uint96 + ctypedef unsigned long long npy_uint128 + + ctypedef float npy_float32 + ctypedef double npy_float64 + ctypedef long double npy_float80 + ctypedef long double npy_float96 + ctypedef long double npy_float128 + + ctypedef struct npy_cfloat: + pass + + ctypedef struct npy_cdouble: + pass + + ctypedef struct npy_clongdouble: + pass + + ctypedef struct npy_complex64: + pass + + ctypedef struct npy_complex128: + pass + + ctypedef struct npy_complex160: + pass + + ctypedef struct npy_complex192: + pass + + ctypedef struct npy_complex256: + pass + + ctypedef struct PyArray_Dims: + npy_intp *ptr + int len + + + cdef enum NPY_TYPES: + NPY_BOOL + NPY_BYTE + NPY_UBYTE + NPY_SHORT + NPY_USHORT + NPY_INT + NPY_UINT + NPY_LONG + NPY_ULONG + NPY_LONGLONG + NPY_ULONGLONG + NPY_FLOAT + NPY_DOUBLE + NPY_LONGDOUBLE + NPY_CFLOAT + NPY_CDOUBLE + NPY_CLONGDOUBLE + NPY_OBJECT + NPY_STRING + NPY_UNICODE + NPY_VOID + NPY_DATETIME + NPY_TIMEDELTA + NPY_NTYPES_LEGACY + NPY_NOTYPE + + NPY_INT8 + NPY_INT16 + NPY_INT32 + NPY_INT64 + NPY_INT128 + NPY_INT256 + NPY_UINT8 + NPY_UINT16 + NPY_UINT32 + NPY_UINT64 + NPY_UINT128 + NPY_UINT256 + NPY_FLOAT16 + NPY_FLOAT32 + NPY_FLOAT64 + NPY_FLOAT80 + NPY_FLOAT96 + NPY_FLOAT128 + NPY_FLOAT256 + NPY_COMPLEX32 + NPY_COMPLEX64 + NPY_COMPLEX128 + NPY_COMPLEX160 + NPY_COMPLEX192 + NPY_COMPLEX256 + NPY_COMPLEX512 + + NPY_INTP + NPY_DEFAULT_INT # Not a compile time constant (normally)! + + ctypedef enum NPY_ORDER: + NPY_ANYORDER + NPY_CORDER + NPY_FORTRANORDER + NPY_KEEPORDER + + ctypedef enum NPY_CASTING: + NPY_NO_CASTING + NPY_EQUIV_CASTING + NPY_SAFE_CASTING + NPY_SAME_KIND_CASTING + NPY_UNSAFE_CASTING + + ctypedef enum NPY_CLIPMODE: + NPY_CLIP + NPY_WRAP + NPY_RAISE + + ctypedef enum NPY_SCALARKIND: + NPY_NOSCALAR, + NPY_BOOL_SCALAR, + NPY_INTPOS_SCALAR, + NPY_INTNEG_SCALAR, + NPY_FLOAT_SCALAR, + NPY_COMPLEX_SCALAR, + NPY_OBJECT_SCALAR + + ctypedef enum NPY_SORTKIND: + NPY_QUICKSORT + NPY_HEAPSORT + NPY_MERGESORT + + ctypedef enum NPY_SEARCHSIDE: + NPY_SEARCHLEFT + NPY_SEARCHRIGHT + + enum: + # DEPRECATED since NumPy 1.7 ! Do not use in new code! + NPY_C_CONTIGUOUS + NPY_F_CONTIGUOUS + NPY_CONTIGUOUS + NPY_FORTRAN + NPY_OWNDATA + NPY_FORCECAST + NPY_ENSURECOPY + NPY_ENSUREARRAY + NPY_ELEMENTSTRIDES + NPY_ALIGNED + NPY_NOTSWAPPED + NPY_WRITEABLE + NPY_ARR_HAS_DESCR + + NPY_BEHAVED + NPY_BEHAVED_NS + NPY_CARRAY + NPY_CARRAY_RO + NPY_FARRAY + NPY_FARRAY_RO + NPY_DEFAULT + + NPY_IN_ARRAY + NPY_OUT_ARRAY + NPY_INOUT_ARRAY + NPY_IN_FARRAY + NPY_OUT_FARRAY + NPY_INOUT_FARRAY + + NPY_UPDATE_ALL + + enum: + # Added in NumPy 1.7 to replace the deprecated enums above. + NPY_ARRAY_C_CONTIGUOUS + NPY_ARRAY_F_CONTIGUOUS + NPY_ARRAY_OWNDATA + NPY_ARRAY_FORCECAST + NPY_ARRAY_ENSURECOPY + NPY_ARRAY_ENSUREARRAY + NPY_ARRAY_ELEMENTSTRIDES + NPY_ARRAY_ALIGNED + NPY_ARRAY_NOTSWAPPED + NPY_ARRAY_WRITEABLE + NPY_ARRAY_WRITEBACKIFCOPY + + NPY_ARRAY_BEHAVED + NPY_ARRAY_BEHAVED_NS + NPY_ARRAY_CARRAY + NPY_ARRAY_CARRAY_RO + NPY_ARRAY_FARRAY + NPY_ARRAY_FARRAY_RO + NPY_ARRAY_DEFAULT + + NPY_ARRAY_IN_ARRAY + NPY_ARRAY_OUT_ARRAY + NPY_ARRAY_INOUT_ARRAY + NPY_ARRAY_IN_FARRAY + NPY_ARRAY_OUT_FARRAY + NPY_ARRAY_INOUT_FARRAY + + NPY_ARRAY_UPDATE_ALL + + cdef enum: + NPY_MAXDIMS # 64 on NumPy 2.x and 32 on NumPy 1.x + NPY_RAVEL_AXIS # Used for functions like PyArray_Mean + + ctypedef void (*PyArray_VectorUnaryFunc)(void *, void *, npy_intp, void *, void *) + + ctypedef struct PyArray_ArrayDescr: + # shape is a tuple, but Cython doesn't support "tuple shape" + # inside a non-PyObject declaration, so we have to declare it + # as just a PyObject*. + PyObject* shape + + ctypedef struct PyArray_Descr: + pass + + ctypedef class numpy.dtype [object PyArray_Descr, check_size ignore]: + # Use PyDataType_* macros when possible, however there are no macros + # for accessing some of the fields, so some are defined. + cdef PyTypeObject* typeobj + cdef char kind + cdef char type + # Numpy sometimes mutates this without warning (e.g. it'll + # sometimes change "|" to "<" in shared dtype objects on + # little-endian machines). If this matters to you, use + # PyArray_IsNativeByteOrder(dtype.byteorder) instead of + # directly accessing this field. + cdef char byteorder + cdef int type_num + + @property + cdef inline npy_intp itemsize(self) noexcept nogil: + return PyDataType_ELSIZE(self) + + @property + cdef inline npy_intp alignment(self) noexcept nogil: + return PyDataType_ALIGNMENT(self) + + # Use fields/names with care as they may be NULL. You must check + # for this using PyDataType_HASFIELDS. + @property + cdef inline object fields(self): + return PyDataType_FIELDS(self) + + @property + cdef inline tuple names(self): + return PyDataType_NAMES(self) + + # Use PyDataType_HASSUBARRAY to test whether this field is + # valid (the pointer can be NULL). Most users should access + # this field via the inline helper method PyDataType_SHAPE. + @property + cdef inline PyArray_ArrayDescr* subarray(self) noexcept nogil: + return PyDataType_SUBARRAY(self) + + @property + cdef inline npy_uint64 flags(self) noexcept nogil: + """The data types flags.""" + return PyDataType_FLAGS(self) + + + ctypedef class numpy.flatiter [object PyArrayIterObject, check_size ignore]: + # Use through macros + pass + + ctypedef class numpy.broadcast [object PyArrayMultiIterObject, check_size ignore]: + + @property + cdef inline int numiter(self) noexcept nogil: + """The number of arrays that need to be broadcast to the same shape.""" + return PyArray_MultiIter_NUMITER(self) + + @property + cdef inline npy_intp size(self) noexcept nogil: + """The total broadcasted size.""" + return PyArray_MultiIter_SIZE(self) + + @property + cdef inline npy_intp index(self) noexcept nogil: + """The current (1-d) index into the broadcasted result.""" + return PyArray_MultiIter_INDEX(self) + + @property + cdef inline int nd(self) noexcept nogil: + """The number of dimensions in the broadcasted result.""" + return PyArray_MultiIter_NDIM(self) + + @property + cdef inline npy_intp* dimensions(self) noexcept nogil: + """The shape of the broadcasted result.""" + return PyArray_MultiIter_DIMS(self) + + @property + cdef inline void** iters(self) noexcept nogil: + """An array of iterator objects that holds the iterators for the arrays to be broadcast together. + On return, the iterators are adjusted for broadcasting.""" + return PyArray_MultiIter_ITERS(self) + + + ctypedef struct PyArrayObject: + # For use in situations where ndarray can't replace PyArrayObject*, + # like PyArrayObject**. + pass + + ctypedef class numpy.ndarray [object PyArrayObject, check_size ignore]: + cdef __cythonbufferdefaults__ = {"mode": "strided"} + + # NOTE: no field declarations since direct access is deprecated since NumPy 1.7 + # Instead, we use properties that map to the corresponding C-API functions. + + @property + cdef inline PyObject* base(self) noexcept nogil: + """Returns a borrowed reference to the object owning the data/memory. + """ + return PyArray_BASE(self) + + @property + cdef inline dtype descr(self): + """Returns an owned reference to the dtype of the array. + """ + return PyArray_DESCR(self) + + @property + cdef inline int ndim(self) noexcept nogil: + """Returns the number of dimensions in the array. + """ + return PyArray_NDIM(self) + + @property + cdef inline npy_intp *shape(self) noexcept nogil: + """Returns a pointer to the dimensions/shape of the array. + The number of elements matches the number of dimensions of the array (ndim). + Can return NULL for 0-dimensional arrays. + """ + return PyArray_DIMS(self) + + @property + cdef inline npy_intp *strides(self) noexcept nogil: + """Returns a pointer to the strides of the array. + The number of elements matches the number of dimensions of the array (ndim). + """ + return PyArray_STRIDES(self) + + @property + cdef inline npy_intp size(self) noexcept nogil: + """Returns the total size (in number of elements) of the array. + """ + return PyArray_SIZE(self) + + @property + cdef inline char* data(self) noexcept nogil: + """The pointer to the data buffer as a char*. + This is provided for legacy reasons to avoid direct struct field access. + For new code that needs this access, you probably want to cast the result + of `PyArray_DATA()` instead, which returns a 'void*'. + """ + return PyArray_BYTES(self) + + + int _import_array() except -1 + # A second definition so _import_array isn't marked as used when we use it here. + # Do not use - subject to change any time. + int __pyx_import_array "_import_array"() except -1 + + # + # Macros from ndarrayobject.h + # + bint PyArray_CHKFLAGS(ndarray m, int flags) nogil + bint PyArray_IS_C_CONTIGUOUS(ndarray arr) nogil + bint PyArray_IS_F_CONTIGUOUS(ndarray arr) nogil + bint PyArray_ISCONTIGUOUS(ndarray m) nogil + bint PyArray_ISWRITEABLE(ndarray m) nogil + bint PyArray_ISALIGNED(ndarray m) nogil + + int PyArray_NDIM(ndarray) nogil + bint PyArray_ISONESEGMENT(ndarray) nogil + bint PyArray_ISFORTRAN(ndarray) nogil + int PyArray_FORTRANIF(ndarray) nogil + + void* PyArray_DATA(ndarray) nogil + char* PyArray_BYTES(ndarray) nogil + + npy_intp* PyArray_DIMS(ndarray) nogil + npy_intp* PyArray_STRIDES(ndarray) nogil + npy_intp PyArray_DIM(ndarray, size_t) nogil + npy_intp PyArray_STRIDE(ndarray, size_t) nogil + + PyObject *PyArray_BASE(ndarray) nogil # returns borrowed reference! + PyArray_Descr *PyArray_DESCR(ndarray) nogil # returns borrowed reference to dtype! + PyArray_Descr *PyArray_DTYPE(ndarray) nogil # returns borrowed reference to dtype! NP 1.7+ alias for descr. + int PyArray_FLAGS(ndarray) nogil + void PyArray_CLEARFLAGS(ndarray, int flags) nogil # Added in NumPy 1.7 + void PyArray_ENABLEFLAGS(ndarray, int flags) nogil # Added in NumPy 1.7 + npy_intp PyArray_ITEMSIZE(ndarray) nogil + int PyArray_TYPE(ndarray arr) nogil + + object PyArray_GETITEM(ndarray arr, void *itemptr) + int PyArray_SETITEM(ndarray arr, void *itemptr, object obj) except -1 + + bint PyTypeNum_ISBOOL(int) nogil + bint PyTypeNum_ISUNSIGNED(int) nogil + bint PyTypeNum_ISSIGNED(int) nogil + bint PyTypeNum_ISINTEGER(int) nogil + bint PyTypeNum_ISFLOAT(int) nogil + bint PyTypeNum_ISNUMBER(int) nogil + bint PyTypeNum_ISSTRING(int) nogil + bint PyTypeNum_ISCOMPLEX(int) nogil + bint PyTypeNum_ISFLEXIBLE(int) nogil + bint PyTypeNum_ISUSERDEF(int) nogil + bint PyTypeNum_ISEXTENDED(int) nogil + bint PyTypeNum_ISOBJECT(int) nogil + + npy_intp PyDataType_ELSIZE(dtype) nogil + npy_intp PyDataType_ALIGNMENT(dtype) nogil + PyObject* PyDataType_METADATA(dtype) nogil + PyArray_ArrayDescr* PyDataType_SUBARRAY(dtype) nogil + PyObject* PyDataType_NAMES(dtype) nogil + PyObject* PyDataType_FIELDS(dtype) nogil + + bint PyDataType_ISBOOL(dtype) nogil + bint PyDataType_ISUNSIGNED(dtype) nogil + bint PyDataType_ISSIGNED(dtype) nogil + bint PyDataType_ISINTEGER(dtype) nogil + bint PyDataType_ISFLOAT(dtype) nogil + bint PyDataType_ISNUMBER(dtype) nogil + bint PyDataType_ISSTRING(dtype) nogil + bint PyDataType_ISCOMPLEX(dtype) nogil + bint PyDataType_ISFLEXIBLE(dtype) nogil + bint PyDataType_ISUSERDEF(dtype) nogil + bint PyDataType_ISEXTENDED(dtype) nogil + bint PyDataType_ISOBJECT(dtype) nogil + bint PyDataType_HASFIELDS(dtype) nogil + bint PyDataType_HASSUBARRAY(dtype) nogil + npy_uint64 PyDataType_FLAGS(dtype) nogil + + bint PyArray_ISBOOL(ndarray) nogil + bint PyArray_ISUNSIGNED(ndarray) nogil + bint PyArray_ISSIGNED(ndarray) nogil + bint PyArray_ISINTEGER(ndarray) nogil + bint PyArray_ISFLOAT(ndarray) nogil + bint PyArray_ISNUMBER(ndarray) nogil + bint PyArray_ISSTRING(ndarray) nogil + bint PyArray_ISCOMPLEX(ndarray) nogil + bint PyArray_ISFLEXIBLE(ndarray) nogil + bint PyArray_ISUSERDEF(ndarray) nogil + bint PyArray_ISEXTENDED(ndarray) nogil + bint PyArray_ISOBJECT(ndarray) nogil + bint PyArray_HASFIELDS(ndarray) nogil + + bint PyArray_ISVARIABLE(ndarray) nogil + + bint PyArray_SAFEALIGNEDCOPY(ndarray) nogil + bint PyArray_ISNBO(char) nogil # works on ndarray.byteorder + bint PyArray_IsNativeByteOrder(char) nogil # works on ndarray.byteorder + bint PyArray_ISNOTSWAPPED(ndarray) nogil + bint PyArray_ISBYTESWAPPED(ndarray) nogil + + bint PyArray_FLAGSWAP(ndarray, int) nogil + + bint PyArray_ISCARRAY(ndarray) nogil + bint PyArray_ISCARRAY_RO(ndarray) nogil + bint PyArray_ISFARRAY(ndarray) nogil + bint PyArray_ISFARRAY_RO(ndarray) nogil + bint PyArray_ISBEHAVED(ndarray) nogil + bint PyArray_ISBEHAVED_RO(ndarray) nogil + + + bint PyDataType_ISNOTSWAPPED(dtype) nogil + bint PyDataType_ISBYTESWAPPED(dtype) nogil + + bint PyArray_DescrCheck(object) + + bint PyArray_Check(object) + bint PyArray_CheckExact(object) + + # Cannot be supported due to out arg: + # bint PyArray_HasArrayInterfaceType(object, dtype, object, object&) + # bint PyArray_HasArrayInterface(op, out) + + + bint PyArray_IsZeroDim(object) + # Cannot be supported due to ## ## in macro: + # bint PyArray_IsScalar(object, verbatim work) + bint PyArray_CheckScalar(object) + bint PyArray_IsPythonNumber(object) + bint PyArray_IsPythonScalar(object) + bint PyArray_IsAnyScalar(object) + bint PyArray_CheckAnyScalar(object) + + ndarray PyArray_GETCONTIGUOUS(ndarray) + bint PyArray_SAMESHAPE(ndarray, ndarray) nogil + npy_intp PyArray_SIZE(ndarray) nogil + npy_intp PyArray_NBYTES(ndarray) nogil + + object PyArray_FROM_O(object) + object PyArray_FROM_OF(object m, int flags) + object PyArray_FROM_OT(object m, int type) + object PyArray_FROM_OTF(object m, int type, int flags) + object PyArray_FROMANY(object m, int type, int min, int max, int flags) + object PyArray_ZEROS(int nd, npy_intp* dims, int type, int fortran) + object PyArray_EMPTY(int nd, npy_intp* dims, int type, int fortran) + void PyArray_FILLWBYTE(ndarray, int val) + object PyArray_ContiguousFromAny(op, int, int min_depth, int max_depth) + unsigned char PyArray_EquivArrTypes(ndarray a1, ndarray a2) + bint PyArray_EquivByteorders(int b1, int b2) nogil + object PyArray_SimpleNew(int nd, npy_intp* dims, int typenum) + object PyArray_SimpleNewFromData(int nd, npy_intp* dims, int typenum, void* data) + #object PyArray_SimpleNewFromDescr(int nd, npy_intp* dims, dtype descr) + object PyArray_ToScalar(void* data, ndarray arr) + + void* PyArray_GETPTR1(ndarray m, npy_intp i) nogil + void* PyArray_GETPTR2(ndarray m, npy_intp i, npy_intp j) nogil + void* PyArray_GETPTR3(ndarray m, npy_intp i, npy_intp j, npy_intp k) nogil + void* PyArray_GETPTR4(ndarray m, npy_intp i, npy_intp j, npy_intp k, npy_intp l) nogil + + # Cannot be supported due to out arg + # void PyArray_DESCR_REPLACE(descr) + + + object PyArray_Copy(ndarray) + object PyArray_FromObject(object op, int type, int min_depth, int max_depth) + object PyArray_ContiguousFromObject(object op, int type, int min_depth, int max_depth) + object PyArray_CopyFromObject(object op, int type, int min_depth, int max_depth) + + object PyArray_Cast(ndarray mp, int type_num) + object PyArray_Take(ndarray ap, object items, int axis) + object PyArray_Put(ndarray ap, object items, object values) + + void PyArray_ITER_RESET(flatiter it) nogil + void PyArray_ITER_NEXT(flatiter it) nogil + void PyArray_ITER_GOTO(flatiter it, npy_intp* destination) nogil + void PyArray_ITER_GOTO1D(flatiter it, npy_intp ind) nogil + void* PyArray_ITER_DATA(flatiter it) nogil + bint PyArray_ITER_NOTDONE(flatiter it) nogil + + void PyArray_MultiIter_RESET(broadcast multi) nogil + void PyArray_MultiIter_NEXT(broadcast multi) nogil + void PyArray_MultiIter_GOTO(broadcast multi, npy_intp dest) nogil + void PyArray_MultiIter_GOTO1D(broadcast multi, npy_intp ind) nogil + void* PyArray_MultiIter_DATA(broadcast multi, npy_intp i) nogil + void PyArray_MultiIter_NEXTi(broadcast multi, npy_intp i) nogil + bint PyArray_MultiIter_NOTDONE(broadcast multi) nogil + npy_intp PyArray_MultiIter_SIZE(broadcast multi) nogil + int PyArray_MultiIter_NDIM(broadcast multi) nogil + npy_intp PyArray_MultiIter_INDEX(broadcast multi) nogil + int PyArray_MultiIter_NUMITER(broadcast multi) nogil + npy_intp* PyArray_MultiIter_DIMS(broadcast multi) nogil + void** PyArray_MultiIter_ITERS(broadcast multi) nogil + + # Functions from __multiarray_api.h + + # Functions taking dtype and returning object/ndarray are disabled + # for now as they steal dtype references. I'm conservative and disable + # more than is probably needed until it can be checked further. + int PyArray_INCREF (ndarray) except * # uses PyArray_Item_INCREF... + int PyArray_XDECREF (ndarray) except * # uses PyArray_Item_DECREF... + dtype PyArray_DescrFromType (int) + object PyArray_TypeObjectFromType (int) + char * PyArray_Zero (ndarray) + char * PyArray_One (ndarray) + #object PyArray_CastToType (ndarray, dtype, int) + int PyArray_CanCastSafely (int, int) # writes errors + npy_bool PyArray_CanCastTo (dtype, dtype) # writes errors + int PyArray_ObjectType (object, int) except 0 + dtype PyArray_DescrFromObject (object, dtype) + #ndarray* PyArray_ConvertToCommonType (object, int *) + dtype PyArray_DescrFromScalar (object) + dtype PyArray_DescrFromTypeObject (object) + npy_intp PyArray_Size (object) + #object PyArray_Scalar (void *, dtype, object) + #object PyArray_FromScalar (object, dtype) + void PyArray_ScalarAsCtype (object, void *) + #int PyArray_CastScalarToCtype (object, void *, dtype) + #int PyArray_CastScalarDirect (object, dtype, void *, int) + #PyArray_VectorUnaryFunc * PyArray_GetCastFunc (dtype, int) + #object PyArray_FromAny (object, dtype, int, int, int, object) + object PyArray_EnsureArray (object) + object PyArray_EnsureAnyArray (object) + #object PyArray_FromFile (stdio.FILE *, dtype, npy_intp, char *) + #object PyArray_FromString (char *, npy_intp, dtype, npy_intp, char *) + #object PyArray_FromBuffer (object, dtype, npy_intp, npy_intp) + #object PyArray_FromIter (object, dtype, npy_intp) + object PyArray_Return (ndarray) + #object PyArray_GetField (ndarray, dtype, int) + #int PyArray_SetField (ndarray, dtype, int, object) except -1 + object PyArray_Byteswap (ndarray, npy_bool) + object PyArray_Resize (ndarray, PyArray_Dims *, int, NPY_ORDER) + int PyArray_CopyInto (ndarray, ndarray) except -1 + int PyArray_CopyAnyInto (ndarray, ndarray) except -1 + int PyArray_CopyObject (ndarray, object) except -1 + object PyArray_NewCopy (ndarray, NPY_ORDER) + object PyArray_ToList (ndarray) + object PyArray_ToString (ndarray, NPY_ORDER) + int PyArray_ToFile (ndarray, stdio.FILE *, char *, char *) except -1 + int PyArray_Dump (object, object, int) except -1 + object PyArray_Dumps (object, int) + int PyArray_ValidType (int) # Cannot error + void PyArray_UpdateFlags (ndarray, int) + object PyArray_New (type, int, npy_intp *, int, npy_intp *, void *, int, int, object) + #object PyArray_NewFromDescr (type, dtype, int, npy_intp *, npy_intp *, void *, int, object) + #dtype PyArray_DescrNew (dtype) + dtype PyArray_DescrNewFromType (int) + double PyArray_GetPriority (object, double) # clears errors as of 1.25 + object PyArray_IterNew (object) + object PyArray_MultiIterNew (int, ...) + + int PyArray_PyIntAsInt (object) except? -1 + npy_intp PyArray_PyIntAsIntp (object) + int PyArray_Broadcast (broadcast) except -1 + int PyArray_FillWithScalar (ndarray, object) except -1 + npy_bool PyArray_CheckStrides (int, int, npy_intp, npy_intp, npy_intp *, npy_intp *) + dtype PyArray_DescrNewByteorder (dtype, char) + object PyArray_IterAllButAxis (object, int *) + #object PyArray_CheckFromAny (object, dtype, int, int, int, object) + #object PyArray_FromArray (ndarray, dtype, int) + object PyArray_FromInterface (object) + object PyArray_FromStructInterface (object) + #object PyArray_FromArrayAttr (object, dtype, object) + #NPY_SCALARKIND PyArray_ScalarKind (int, ndarray*) + int PyArray_CanCoerceScalar (int, int, NPY_SCALARKIND) + npy_bool PyArray_CanCastScalar (type, type) + int PyArray_RemoveSmallest (broadcast) except -1 + int PyArray_ElementStrides (object) + void PyArray_Item_INCREF (char *, dtype) except * + void PyArray_Item_XDECREF (char *, dtype) except * + object PyArray_Transpose (ndarray, PyArray_Dims *) + object PyArray_TakeFrom (ndarray, object, int, ndarray, NPY_CLIPMODE) + object PyArray_PutTo (ndarray, object, object, NPY_CLIPMODE) + object PyArray_PutMask (ndarray, object, object) + object PyArray_Repeat (ndarray, object, int) + object PyArray_Choose (ndarray, object, ndarray, NPY_CLIPMODE) + int PyArray_Sort (ndarray, int, NPY_SORTKIND) except -1 + object PyArray_ArgSort (ndarray, int, NPY_SORTKIND) + object PyArray_SearchSorted (ndarray, object, NPY_SEARCHSIDE, PyObject *) + object PyArray_ArgMax (ndarray, int, ndarray) + object PyArray_ArgMin (ndarray, int, ndarray) + object PyArray_Reshape (ndarray, object) + object PyArray_Newshape (ndarray, PyArray_Dims *, NPY_ORDER) + object PyArray_Squeeze (ndarray) + #object PyArray_View (ndarray, dtype, type) + object PyArray_SwapAxes (ndarray, int, int) + object PyArray_Max (ndarray, int, ndarray) + object PyArray_Min (ndarray, int, ndarray) + object PyArray_Ptp (ndarray, int, ndarray) + object PyArray_Mean (ndarray, int, int, ndarray) + object PyArray_Trace (ndarray, int, int, int, int, ndarray) + object PyArray_Diagonal (ndarray, int, int, int) + object PyArray_Clip (ndarray, object, object, ndarray) + object PyArray_Conjugate (ndarray, ndarray) + object PyArray_Nonzero (ndarray) + object PyArray_Std (ndarray, int, int, ndarray, int) + object PyArray_Sum (ndarray, int, int, ndarray) + object PyArray_CumSum (ndarray, int, int, ndarray) + object PyArray_Prod (ndarray, int, int, ndarray) + object PyArray_CumProd (ndarray, int, int, ndarray) + object PyArray_All (ndarray, int, ndarray) + object PyArray_Any (ndarray, int, ndarray) + object PyArray_Compress (ndarray, object, int, ndarray) + object PyArray_Flatten (ndarray, NPY_ORDER) + object PyArray_Ravel (ndarray, NPY_ORDER) + npy_intp PyArray_MultiplyList (npy_intp *, int) + int PyArray_MultiplyIntList (int *, int) + void * PyArray_GetPtr (ndarray, npy_intp*) + int PyArray_CompareLists (npy_intp *, npy_intp *, int) + #int PyArray_AsCArray (object*, void *, npy_intp *, int, dtype) + int PyArray_Free (object, void *) + #int PyArray_Converter (object, object*) + int PyArray_IntpFromSequence (object, npy_intp *, int) except -1 + object PyArray_Concatenate (object, int) + object PyArray_InnerProduct (object, object) + object PyArray_MatrixProduct (object, object) + object PyArray_Correlate (object, object, int) + #int PyArray_DescrConverter (object, dtype*) except 0 + #int PyArray_DescrConverter2 (object, dtype*) except 0 + int PyArray_IntpConverter (object, PyArray_Dims *) except 0 + #int PyArray_BufferConverter (object, chunk) except 0 + int PyArray_AxisConverter (object, int *) except 0 + int PyArray_BoolConverter (object, npy_bool *) except 0 + int PyArray_ByteorderConverter (object, char *) except 0 + int PyArray_OrderConverter (object, NPY_ORDER *) except 0 + unsigned char PyArray_EquivTypes (dtype, dtype) # clears errors + #object PyArray_Zeros (int, npy_intp *, dtype, int) + #object PyArray_Empty (int, npy_intp *, dtype, int) + object PyArray_Where (object, object, object) + object PyArray_Arange (double, double, double, int) + #object PyArray_ArangeObj (object, object, object, dtype) + int PyArray_SortkindConverter (object, NPY_SORTKIND *) except 0 + object PyArray_LexSort (object, int) + object PyArray_Round (ndarray, int, ndarray) + unsigned char PyArray_EquivTypenums (int, int) + int PyArray_RegisterDataType (dtype) except -1 + int PyArray_RegisterCastFunc (dtype, int, PyArray_VectorUnaryFunc *) except -1 + int PyArray_RegisterCanCast (dtype, int, NPY_SCALARKIND) except -1 + #void PyArray_InitArrFuncs (PyArray_ArrFuncs *) + object PyArray_IntTupleFromIntp (int, npy_intp *) + int PyArray_ClipmodeConverter (object, NPY_CLIPMODE *) except 0 + #int PyArray_OutputConverter (object, ndarray*) except 0 + object PyArray_BroadcastToShape (object, npy_intp *, int) + #int PyArray_DescrAlignConverter (object, dtype*) except 0 + #int PyArray_DescrAlignConverter2 (object, dtype*) except 0 + int PyArray_SearchsideConverter (object, void *) except 0 + object PyArray_CheckAxis (ndarray, int *, int) + npy_intp PyArray_OverflowMultiplyList (npy_intp *, int) + int PyArray_SetBaseObject(ndarray, base) except -1 # NOTE: steals a reference to base! Use "set_array_base()" instead. + + # additional datetime related functions are defined below + + +# Typedefs that matches the runtime dtype objects in +# the numpy module. + +# The ones that are commented out needs an IFDEF function +# in Cython to enable them only on the right systems. + +ctypedef npy_int8 int8_t +ctypedef npy_int16 int16_t +ctypedef npy_int32 int32_t +ctypedef npy_int64 int64_t +#ctypedef npy_int96 int96_t +#ctypedef npy_int128 int128_t + +ctypedef npy_uint8 uint8_t +ctypedef npy_uint16 uint16_t +ctypedef npy_uint32 uint32_t +ctypedef npy_uint64 uint64_t +#ctypedef npy_uint96 uint96_t +#ctypedef npy_uint128 uint128_t + +ctypedef npy_float32 float32_t +ctypedef npy_float64 float64_t +#ctypedef npy_float80 float80_t +#ctypedef npy_float128 float128_t + +ctypedef float complex complex64_t +ctypedef double complex complex128_t + +ctypedef npy_longlong longlong_t +ctypedef npy_ulonglong ulonglong_t + +ctypedef npy_intp intp_t +ctypedef npy_uintp uintp_t + +ctypedef npy_double float_t +ctypedef npy_double double_t +ctypedef npy_longdouble longdouble_t + +ctypedef float complex cfloat_t +ctypedef double complex cdouble_t +ctypedef double complex complex_t +ctypedef long double complex clongdouble_t + +cdef inline object PyArray_MultiIterNew1(a): + return PyArray_MultiIterNew(1, a) + +cdef inline object PyArray_MultiIterNew2(a, b): + return PyArray_MultiIterNew(2, a, b) + +cdef inline object PyArray_MultiIterNew3(a, b, c): + return PyArray_MultiIterNew(3, a, b, c) + +cdef inline object PyArray_MultiIterNew4(a, b, c, d): + return PyArray_MultiIterNew(4, a, b, c, d) + +cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): + return PyArray_MultiIterNew(5, a, b, c, d, e) + +cdef inline tuple PyDataType_SHAPE(dtype d): + if PyDataType_HASSUBARRAY(d): + return d.subarray.shape + else: + return () + + +cdef extern from "numpy/ndarrayobject.h": + PyTypeObject PyTimedeltaArrType_Type + PyTypeObject PyDatetimeArrType_Type + ctypedef int64_t npy_timedelta + ctypedef int64_t npy_datetime + +cdef extern from "numpy/ndarraytypes.h": + ctypedef struct PyArray_DatetimeMetaData: + NPY_DATETIMEUNIT base + int64_t num + + ctypedef struct npy_datetimestruct: + int64_t year + int32_t month, day, hour, min, sec, us, ps, as + + +cdef extern from "numpy/arrayscalars.h": + + # abstract types + ctypedef class numpy.generic [object PyObject]: + pass + ctypedef class numpy.number [object PyObject]: + pass + ctypedef class numpy.integer [object PyObject]: + pass + ctypedef class numpy.signedinteger [object PyObject]: + pass + ctypedef class numpy.unsignedinteger [object PyObject]: + pass + ctypedef class numpy.inexact [object PyObject]: + pass + ctypedef class numpy.floating [object PyObject]: + pass + ctypedef class numpy.complexfloating [object PyObject]: + pass + ctypedef class numpy.flexible [object PyObject]: + pass + ctypedef class numpy.character [object PyObject]: + pass + + ctypedef struct PyDatetimeScalarObject: + # PyObject_HEAD + npy_datetime obval + PyArray_DatetimeMetaData obmeta + + ctypedef struct PyTimedeltaScalarObject: + # PyObject_HEAD + npy_timedelta obval + PyArray_DatetimeMetaData obmeta + + ctypedef enum NPY_DATETIMEUNIT: + NPY_FR_Y + NPY_FR_M + NPY_FR_W + NPY_FR_D + NPY_FR_B + NPY_FR_h + NPY_FR_m + NPY_FR_s + NPY_FR_ms + NPY_FR_us + NPY_FR_ns + NPY_FR_ps + NPY_FR_fs + NPY_FR_as + NPY_FR_GENERIC + + +cdef extern from "numpy/arrayobject.h": + # These are part of the C-API defined in `__multiarray_api.h` + + # NumPy internal definitions in datetime_strings.c: + int get_datetime_iso_8601_strlen "NpyDatetime_GetDatetimeISO8601StrLen" ( + int local, NPY_DATETIMEUNIT base) + int make_iso_8601_datetime "NpyDatetime_MakeISO8601Datetime" ( + npy_datetimestruct *dts, char *outstr, npy_intp outlen, + int local, int utc, NPY_DATETIMEUNIT base, int tzoffset, + NPY_CASTING casting) except -1 + + # NumPy internal definition in datetime.c: + # May return 1 to indicate that object does not appear to be a datetime + # (returns 0 on success). + int convert_pydatetime_to_datetimestruct "NpyDatetime_ConvertPyDateTimeToDatetimeStruct" ( + PyObject *obj, npy_datetimestruct *out, + NPY_DATETIMEUNIT *out_bestunit, int apply_tzinfo) except -1 + int convert_datetime64_to_datetimestruct "NpyDatetime_ConvertDatetime64ToDatetimeStruct" ( + PyArray_DatetimeMetaData *meta, npy_datetime dt, + npy_datetimestruct *out) except -1 + int convert_datetimestruct_to_datetime64 "NpyDatetime_ConvertDatetimeStructToDatetime64"( + PyArray_DatetimeMetaData *meta, const npy_datetimestruct *dts, + npy_datetime *out) except -1 + + +# +# ufunc API +# + +cdef extern from "numpy/ufuncobject.h": + + ctypedef void (*PyUFuncGenericFunction) (char **, npy_intp *, npy_intp *, void *) + + ctypedef class numpy.ufunc [object PyUFuncObject, check_size ignore]: + cdef: + int nin, nout, nargs + int identity + PyUFuncGenericFunction *functions + void **data + int ntypes + int check_return + char *name + char *types + char *doc + void *ptr + PyObject *obj + PyObject *userloops + + cdef enum: + PyUFunc_Zero + PyUFunc_One + PyUFunc_None + UFUNC_FPE_DIVIDEBYZERO + UFUNC_FPE_OVERFLOW + UFUNC_FPE_UNDERFLOW + UFUNC_FPE_INVALID + + object PyUFunc_FromFuncAndData(PyUFuncGenericFunction *, + void **, char *, int, int, int, int, char *, char *, int) + int PyUFunc_RegisterLoopForType(ufunc, int, + PyUFuncGenericFunction, int *, void *) except -1 + void PyUFunc_f_f_As_d_d \ + (char **, npy_intp *, npy_intp *, void *) + void PyUFunc_d_d \ + (char **, npy_intp *, npy_intp *, void *) + void PyUFunc_f_f \ + (char **, npy_intp *, npy_intp *, void *) + void PyUFunc_g_g \ + (char **, npy_intp *, npy_intp *, void *) + void PyUFunc_F_F_As_D_D \ + (char **, npy_intp *, npy_intp *, void *) + void PyUFunc_F_F \ + (char **, npy_intp *, npy_intp *, void *) + void PyUFunc_D_D \ + (char **, npy_intp *, npy_intp *, void *) + void PyUFunc_G_G \ + (char **, npy_intp *, npy_intp *, void *) + void PyUFunc_O_O \ + (char **, npy_intp *, npy_intp *, void *) + void PyUFunc_ff_f_As_dd_d \ + (char **, npy_intp *, npy_intp *, void *) + void PyUFunc_ff_f \ + (char **, npy_intp *, npy_intp *, void *) + void PyUFunc_dd_d \ + (char **, npy_intp *, npy_intp *, void *) + void PyUFunc_gg_g \ + (char **, npy_intp *, npy_intp *, void *) + void PyUFunc_FF_F_As_DD_D \ + (char **, npy_intp *, npy_intp *, void *) + void PyUFunc_DD_D \ + (char **, npy_intp *, npy_intp *, void *) + void PyUFunc_FF_F \ + (char **, npy_intp *, npy_intp *, void *) + void PyUFunc_GG_G \ + (char **, npy_intp *, npy_intp *, void *) + void PyUFunc_OO_O \ + (char **, npy_intp *, npy_intp *, void *) + void PyUFunc_O_O_method \ + (char **, npy_intp *, npy_intp *, void *) + void PyUFunc_OO_O_method \ + (char **, npy_intp *, npy_intp *, void *) + void PyUFunc_On_Om \ + (char **, npy_intp *, npy_intp *, void *) + void PyUFunc_clearfperr() + int PyUFunc_getfperr() + int PyUFunc_ReplaceLoopBySignature \ + (ufunc, PyUFuncGenericFunction, int *, PyUFuncGenericFunction *) + object PyUFunc_FromFuncAndDataAndSignature \ + (PyUFuncGenericFunction *, void **, char *, int, int, int, + int, char *, char *, int, char *) + + int _import_umath() except -1 + +cdef inline void set_array_base(ndarray arr, object base) except *: + Py_INCREF(base) # important to do this before stealing the reference below! + PyArray_SetBaseObject(arr, base) + +cdef inline object get_array_base(ndarray arr): + base = PyArray_BASE(arr) + if base is NULL: + return None + return base + +# Versions of the import_* functions which are more suitable for +# Cython code. +cdef inline int import_array() except -1: + try: + __pyx_import_array() + except Exception: + raise ImportError("numpy._core.multiarray failed to import") + +cdef inline int import_umath() except -1: + try: + _import_umath() + except Exception: + raise ImportError("numpy._core.umath failed to import") + +cdef inline int import_ufunc() except -1: + try: + _import_umath() + except Exception: + raise ImportError("numpy._core.umath failed to import") + + +cdef inline bint is_timedelta64_object(object obj) noexcept: + """ + Cython equivalent of `isinstance(obj, np.timedelta64)` + + Parameters + ---------- + obj : object + + Returns + ------- + bool + """ + return PyObject_TypeCheck(obj, &PyTimedeltaArrType_Type) + + +cdef inline bint is_datetime64_object(object obj) noexcept: + """ + Cython equivalent of `isinstance(obj, np.datetime64)` + + Parameters + ---------- + obj : object + + Returns + ------- + bool + """ + return PyObject_TypeCheck(obj, &PyDatetimeArrType_Type) + + +cdef inline npy_datetime get_datetime64_value(object obj) noexcept nogil: + """ + returns the int64 value underlying scalar numpy datetime64 object + + Note that to interpret this as a datetime, the corresponding unit is + also needed. That can be found using `get_datetime64_unit`. + """ + return (obj).obval + + +cdef inline npy_timedelta get_timedelta64_value(object obj) noexcept nogil: + """ + returns the int64 value underlying scalar numpy timedelta64 object + """ + return (obj).obval + + +cdef inline NPY_DATETIMEUNIT get_datetime64_unit(object obj) noexcept nogil: + """ + returns the unit part of the dtype for a numpy datetime64 object. + """ + return (obj).obmeta.base + + +# Iterator API added in v1.6 +ctypedef int (*NpyIter_IterNextFunc)(NpyIter* it) noexcept nogil +ctypedef void (*NpyIter_GetMultiIndexFunc)(NpyIter* it, npy_intp* outcoords) noexcept nogil + +cdef extern from "numpy/arrayobject.h": + + ctypedef struct NpyIter: + pass + + cdef enum: + NPY_FAIL + NPY_SUCCEED + + cdef enum: + # Track an index representing C order + NPY_ITER_C_INDEX + # Track an index representing Fortran order + NPY_ITER_F_INDEX + # Track a multi-index + NPY_ITER_MULTI_INDEX + # User code external to the iterator does the 1-dimensional innermost loop + NPY_ITER_EXTERNAL_LOOP + # Convert all the operands to a common data type + NPY_ITER_COMMON_DTYPE + # Operands may hold references, requiring API access during iteration + NPY_ITER_REFS_OK + # Zero-sized operands should be permitted, iteration checks IterSize for 0 + NPY_ITER_ZEROSIZE_OK + # Permits reductions (size-0 stride with dimension size > 1) + NPY_ITER_REDUCE_OK + # Enables sub-range iteration + NPY_ITER_RANGED + # Enables buffering + NPY_ITER_BUFFERED + # When buffering is enabled, grows the inner loop if possible + NPY_ITER_GROWINNER + # Delay allocation of buffers until first Reset* call + NPY_ITER_DELAY_BUFALLOC + # When NPY_KEEPORDER is specified, disable reversing negative-stride axes + NPY_ITER_DONT_NEGATE_STRIDES + NPY_ITER_COPY_IF_OVERLAP + # The operand will be read from and written to + NPY_ITER_READWRITE + # The operand will only be read from + NPY_ITER_READONLY + # The operand will only be written to + NPY_ITER_WRITEONLY + # The operand's data must be in native byte order + NPY_ITER_NBO + # The operand's data must be aligned + NPY_ITER_ALIGNED + # The operand's data must be contiguous (within the inner loop) + NPY_ITER_CONTIG + # The operand may be copied to satisfy requirements + NPY_ITER_COPY + # The operand may be copied with WRITEBACKIFCOPY to satisfy requirements + NPY_ITER_UPDATEIFCOPY + # Allocate the operand if it is NULL + NPY_ITER_ALLOCATE + # If an operand is allocated, don't use any subtype + NPY_ITER_NO_SUBTYPE + # This is a virtual array slot, operand is NULL but temporary data is there + NPY_ITER_VIRTUAL + # Require that the dimension match the iterator dimensions exactly + NPY_ITER_NO_BROADCAST + # A mask is being used on this array, affects buffer -> array copy + NPY_ITER_WRITEMASKED + # This array is the mask for all WRITEMASKED operands + NPY_ITER_ARRAYMASK + # Assume iterator order data access for COPY_IF_OVERLAP + NPY_ITER_OVERLAP_ASSUME_ELEMENTWISE + + # construction and destruction functions + NpyIter* NpyIter_New(ndarray arr, npy_uint32 flags, NPY_ORDER order, + NPY_CASTING casting, dtype datatype) except NULL + NpyIter* NpyIter_MultiNew(npy_intp nop, PyArrayObject** op, npy_uint32 flags, + NPY_ORDER order, NPY_CASTING casting, npy_uint32* + op_flags, PyArray_Descr** op_dtypes) except NULL + NpyIter* NpyIter_AdvancedNew(npy_intp nop, PyArrayObject** op, + npy_uint32 flags, NPY_ORDER order, + NPY_CASTING casting, npy_uint32* op_flags, + PyArray_Descr** op_dtypes, int oa_ndim, + int** op_axes, const npy_intp* itershape, + npy_intp buffersize) except NULL + NpyIter* NpyIter_Copy(NpyIter* it) except NULL + int NpyIter_RemoveAxis(NpyIter* it, int axis) except NPY_FAIL + int NpyIter_RemoveMultiIndex(NpyIter* it) except NPY_FAIL + int NpyIter_EnableExternalLoop(NpyIter* it) except NPY_FAIL + int NpyIter_Deallocate(NpyIter* it) except NPY_FAIL + int NpyIter_Reset(NpyIter* it, char** errmsg) except NPY_FAIL + int NpyIter_ResetToIterIndexRange(NpyIter* it, npy_intp istart, + npy_intp iend, char** errmsg) except NPY_FAIL + int NpyIter_ResetBasePointers(NpyIter* it, char** baseptrs, char** errmsg) except NPY_FAIL + int NpyIter_GotoMultiIndex(NpyIter* it, const npy_intp* multi_index) except NPY_FAIL + int NpyIter_GotoIndex(NpyIter* it, npy_intp index) except NPY_FAIL + npy_intp NpyIter_GetIterSize(NpyIter* it) nogil + npy_intp NpyIter_GetIterIndex(NpyIter* it) nogil + void NpyIter_GetIterIndexRange(NpyIter* it, npy_intp* istart, + npy_intp* iend) nogil + int NpyIter_GotoIterIndex(NpyIter* it, npy_intp iterindex) except NPY_FAIL + npy_bool NpyIter_HasDelayedBufAlloc(NpyIter* it) nogil + npy_bool NpyIter_HasExternalLoop(NpyIter* it) nogil + npy_bool NpyIter_HasMultiIndex(NpyIter* it) nogil + npy_bool NpyIter_HasIndex(NpyIter* it) nogil + npy_bool NpyIter_RequiresBuffering(NpyIter* it) nogil + npy_bool NpyIter_IsBuffered(NpyIter* it) nogil + npy_bool NpyIter_IsGrowInner(NpyIter* it) nogil + npy_intp NpyIter_GetBufferSize(NpyIter* it) nogil + int NpyIter_GetNDim(NpyIter* it) nogil + int NpyIter_GetNOp(NpyIter* it) nogil + npy_intp* NpyIter_GetAxisStrideArray(NpyIter* it, int axis) except NULL + int NpyIter_GetShape(NpyIter* it, npy_intp* outshape) nogil + PyArray_Descr** NpyIter_GetDescrArray(NpyIter* it) + PyArrayObject** NpyIter_GetOperandArray(NpyIter* it) + ndarray NpyIter_GetIterView(NpyIter* it, npy_intp i) + void NpyIter_GetReadFlags(NpyIter* it, char* outreadflags) + void NpyIter_GetWriteFlags(NpyIter* it, char* outwriteflags) + int NpyIter_CreateCompatibleStrides(NpyIter* it, npy_intp itemsize, + npy_intp* outstrides) except NPY_FAIL + npy_bool NpyIter_IsFirstVisit(NpyIter* it, int iop) nogil + # functions for iterating an NpyIter object + NpyIter_IterNextFunc* NpyIter_GetIterNext(NpyIter* it, char** errmsg) except NULL + NpyIter_GetMultiIndexFunc* NpyIter_GetGetMultiIndex(NpyIter* it, + char** errmsg) except NULL + char** NpyIter_GetDataPtrArray(NpyIter* it) nogil + char** NpyIter_GetInitialDataPtrArray(NpyIter* it) nogil + npy_intp* NpyIter_GetIndexPtr(NpyIter* it) + npy_intp* NpyIter_GetInnerStrideArray(NpyIter* it) nogil + npy_intp* NpyIter_GetInnerLoopSizePtr(NpyIter* it) nogil + void NpyIter_GetInnerFixedStrideArray(NpyIter* it, npy_intp* outstrides) nogil + npy_bool NpyIter_IterationNeedsAPI(NpyIter* it) nogil + void NpyIter_DebugPrint(NpyIter* it) diff --git a/venv/lib/python3.12/site-packages/numpy/__init__.pxd b/venv/lib/python3.12/site-packages/numpy/__init__.pxd new file mode 100644 index 00000000..8e7583bc --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/__init__.pxd @@ -0,0 +1,1140 @@ +# NumPy static imports for Cython < 3.0 +# +# If any of the PyArray_* functions are called, import_array must be +# called first. +# +# Author: Dag Sverre Seljebotn +# + +DEF _buffer_format_string_len = 255 + +cimport cpython.buffer as pybuf +from cpython.ref cimport Py_INCREF +from cpython.mem cimport PyObject_Malloc, PyObject_Free +from cpython.object cimport PyObject, PyTypeObject +from cpython.buffer cimport PyObject_GetBuffer +from cpython.type cimport type +cimport libc.stdio as stdio + + +cdef extern from *: + # Leave a marker that the NumPy declarations came from NumPy itself and not from Cython. + # See https://github.com/cython/cython/issues/3573 + """ + /* Using NumPy API declarations from "numpy/__init__.pxd" */ + """ + + +cdef extern from "Python.h": + ctypedef int Py_intptr_t + bint PyObject_TypeCheck(object obj, PyTypeObject* type) + +cdef extern from "numpy/arrayobject.h": + # It would be nice to use size_t and ssize_t, but ssize_t has special + # implicit conversion rules, so just use "long". + # Note: The actual type only matters for Cython promotion, so long + # is closer than int, but could lead to incorrect promotion. + # (Not to worrying, and always the status-quo.) + ctypedef signed long npy_intp + ctypedef unsigned long npy_uintp + + ctypedef unsigned char npy_bool + + ctypedef signed char npy_byte + ctypedef signed short npy_short + ctypedef signed int npy_int + ctypedef signed long npy_long + ctypedef signed long long npy_longlong + + ctypedef unsigned char npy_ubyte + ctypedef unsigned short npy_ushort + ctypedef unsigned int npy_uint + ctypedef unsigned long npy_ulong + ctypedef unsigned long long npy_ulonglong + + ctypedef float npy_float + ctypedef double npy_double + ctypedef long double npy_longdouble + + ctypedef signed char npy_int8 + ctypedef signed short npy_int16 + ctypedef signed int npy_int32 + ctypedef signed long long npy_int64 + ctypedef signed long long npy_int96 + ctypedef signed long long npy_int128 + + ctypedef unsigned char npy_uint8 + ctypedef unsigned short npy_uint16 + ctypedef unsigned int npy_uint32 + ctypedef unsigned long long npy_uint64 + ctypedef unsigned long long npy_uint96 + ctypedef unsigned long long npy_uint128 + + ctypedef float npy_float32 + ctypedef double npy_float64 + ctypedef long double npy_float80 + ctypedef long double npy_float96 + ctypedef long double npy_float128 + + ctypedef struct npy_cfloat: + pass + + ctypedef struct npy_cdouble: + pass + + ctypedef struct npy_clongdouble: + pass + + ctypedef struct npy_complex64: + pass + + ctypedef struct npy_complex128: + pass + + ctypedef struct npy_complex160: + pass + + ctypedef struct npy_complex192: + pass + + ctypedef struct npy_complex256: + pass + + ctypedef struct PyArray_Dims: + npy_intp *ptr + int len + + + cdef enum NPY_TYPES: + NPY_BOOL + NPY_BYTE + NPY_UBYTE + NPY_SHORT + NPY_USHORT + NPY_INT + NPY_UINT + NPY_LONG + NPY_ULONG + NPY_LONGLONG + NPY_ULONGLONG + NPY_FLOAT + NPY_DOUBLE + NPY_LONGDOUBLE + NPY_CFLOAT + NPY_CDOUBLE + NPY_CLONGDOUBLE + NPY_OBJECT + NPY_STRING + NPY_UNICODE + NPY_VOID + NPY_DATETIME + NPY_TIMEDELTA + NPY_NTYPES_LEGACY + NPY_NOTYPE + + NPY_INT8 + NPY_INT16 + NPY_INT32 + NPY_INT64 + NPY_INT128 + NPY_INT256 + NPY_UINT8 + NPY_UINT16 + NPY_UINT32 + NPY_UINT64 + NPY_UINT128 + NPY_UINT256 + NPY_FLOAT16 + NPY_FLOAT32 + NPY_FLOAT64 + NPY_FLOAT80 + NPY_FLOAT96 + NPY_FLOAT128 + NPY_FLOAT256 + NPY_COMPLEX32 + NPY_COMPLEX64 + NPY_COMPLEX128 + NPY_COMPLEX160 + NPY_COMPLEX192 + NPY_COMPLEX256 + NPY_COMPLEX512 + + NPY_INTP + NPY_DEFAULT_INT # Not a compile time constant (normally)! + + ctypedef enum NPY_ORDER: + NPY_ANYORDER + NPY_CORDER + NPY_FORTRANORDER + NPY_KEEPORDER + + ctypedef enum NPY_CASTING: + NPY_NO_CASTING + NPY_EQUIV_CASTING + NPY_SAFE_CASTING + NPY_SAME_KIND_CASTING + NPY_UNSAFE_CASTING + + ctypedef enum NPY_CLIPMODE: + NPY_CLIP + NPY_WRAP + NPY_RAISE + + ctypedef enum NPY_SCALARKIND: + NPY_NOSCALAR, + NPY_BOOL_SCALAR, + NPY_INTPOS_SCALAR, + NPY_INTNEG_SCALAR, + NPY_FLOAT_SCALAR, + NPY_COMPLEX_SCALAR, + NPY_OBJECT_SCALAR + + ctypedef enum NPY_SORTKIND: + NPY_QUICKSORT + NPY_HEAPSORT + NPY_MERGESORT + + ctypedef enum NPY_SEARCHSIDE: + NPY_SEARCHLEFT + NPY_SEARCHRIGHT + + enum: + # DEPRECATED since NumPy 1.7 ! Do not use in new code! + NPY_C_CONTIGUOUS + NPY_F_CONTIGUOUS + NPY_CONTIGUOUS + NPY_FORTRAN + NPY_OWNDATA + NPY_FORCECAST + NPY_ENSURECOPY + NPY_ENSUREARRAY + NPY_ELEMENTSTRIDES + NPY_ALIGNED + NPY_NOTSWAPPED + NPY_WRITEABLE + NPY_ARR_HAS_DESCR + + NPY_BEHAVED + NPY_BEHAVED_NS + NPY_CARRAY + NPY_CARRAY_RO + NPY_FARRAY + NPY_FARRAY_RO + NPY_DEFAULT + + NPY_IN_ARRAY + NPY_OUT_ARRAY + NPY_INOUT_ARRAY + NPY_IN_FARRAY + NPY_OUT_FARRAY + NPY_INOUT_FARRAY + + NPY_UPDATE_ALL + + enum: + # Added in NumPy 1.7 to replace the deprecated enums above. + NPY_ARRAY_C_CONTIGUOUS + NPY_ARRAY_F_CONTIGUOUS + NPY_ARRAY_OWNDATA + NPY_ARRAY_FORCECAST + NPY_ARRAY_ENSURECOPY + NPY_ARRAY_ENSUREARRAY + NPY_ARRAY_ELEMENTSTRIDES + NPY_ARRAY_ALIGNED + NPY_ARRAY_NOTSWAPPED + NPY_ARRAY_WRITEABLE + NPY_ARRAY_WRITEBACKIFCOPY + + NPY_ARRAY_BEHAVED + NPY_ARRAY_BEHAVED_NS + NPY_ARRAY_CARRAY + NPY_ARRAY_CARRAY_RO + NPY_ARRAY_FARRAY + NPY_ARRAY_FARRAY_RO + NPY_ARRAY_DEFAULT + + NPY_ARRAY_IN_ARRAY + NPY_ARRAY_OUT_ARRAY + NPY_ARRAY_INOUT_ARRAY + NPY_ARRAY_IN_FARRAY + NPY_ARRAY_OUT_FARRAY + NPY_ARRAY_INOUT_FARRAY + + NPY_ARRAY_UPDATE_ALL + + cdef enum: + NPY_MAXDIMS # 64 on NumPy 2.x and 32 on NumPy 1.x + NPY_RAVEL_AXIS # Used for functions like PyArray_Mean + + ctypedef void (*PyArray_VectorUnaryFunc)(void *, void *, npy_intp, void *, void *) + + ctypedef struct PyArray_ArrayDescr: + # shape is a tuple, but Cython doesn't support "tuple shape" + # inside a non-PyObject declaration, so we have to declare it + # as just a PyObject*. + PyObject* shape + + ctypedef struct PyArray_Descr: + pass + + ctypedef class numpy.dtype [object PyArray_Descr, check_size ignore]: + # Use PyDataType_* macros when possible, however there are no macros + # for accessing some of the fields, so some are defined. + cdef PyTypeObject* typeobj + cdef char kind + cdef char type + # Numpy sometimes mutates this without warning (e.g. it'll + # sometimes change "|" to "<" in shared dtype objects on + # little-endian machines). If this matters to you, use + # PyArray_IsNativeByteOrder(dtype.byteorder) instead of + # directly accessing this field. + cdef char byteorder + # Flags are not directly accessible on Cython <3. Use PyDataType_FLAGS. + # cdef char flags + cdef int type_num + # itemsize/elsize, alignment, fields, names, and subarray must + # use the `PyDataType_*` accessor macros. With Cython 3 you can + # still use getter attributes `dtype.itemsize` + + ctypedef class numpy.flatiter [object PyArrayIterObject, check_size ignore]: + # Use through macros + pass + + ctypedef class numpy.broadcast [object PyArrayMultiIterObject, check_size ignore]: + cdef int numiter + cdef npy_intp size, index + cdef int nd + cdef npy_intp *dimensions + cdef void **iters + + ctypedef struct PyArrayObject: + # For use in situations where ndarray can't replace PyArrayObject*, + # like PyArrayObject**. + pass + + ctypedef class numpy.ndarray [object PyArrayObject, check_size ignore]: + cdef __cythonbufferdefaults__ = {"mode": "strided"} + + cdef: + # Only taking a few of the most commonly used and stable fields. + # One should use PyArray_* macros instead to access the C fields. + char *data + int ndim "nd" + npy_intp *shape "dimensions" + npy_intp *strides + dtype descr # deprecated since NumPy 1.7 ! + PyObject* base # NOT PUBLIC, DO NOT USE ! + + + int _import_array() except -1 + # A second definition so _import_array isn't marked as used when we use it here. + # Do not use - subject to change any time. + int __pyx_import_array "_import_array"() except -1 + + # + # Macros from ndarrayobject.h + # + bint PyArray_CHKFLAGS(ndarray m, int flags) nogil + bint PyArray_IS_C_CONTIGUOUS(ndarray arr) nogil + bint PyArray_IS_F_CONTIGUOUS(ndarray arr) nogil + bint PyArray_ISCONTIGUOUS(ndarray m) nogil + bint PyArray_ISWRITEABLE(ndarray m) nogil + bint PyArray_ISALIGNED(ndarray m) nogil + + int PyArray_NDIM(ndarray) nogil + bint PyArray_ISONESEGMENT(ndarray) nogil + bint PyArray_ISFORTRAN(ndarray) nogil + int PyArray_FORTRANIF(ndarray) nogil + + void* PyArray_DATA(ndarray) nogil + char* PyArray_BYTES(ndarray) nogil + + npy_intp* PyArray_DIMS(ndarray) nogil + npy_intp* PyArray_STRIDES(ndarray) nogil + npy_intp PyArray_DIM(ndarray, size_t) nogil + npy_intp PyArray_STRIDE(ndarray, size_t) nogil + + PyObject *PyArray_BASE(ndarray) nogil # returns borrowed reference! + PyArray_Descr *PyArray_DESCR(ndarray) nogil # returns borrowed reference to dtype! + PyArray_Descr *PyArray_DTYPE(ndarray) nogil # returns borrowed reference to dtype! NP 1.7+ alias for descr. + int PyArray_FLAGS(ndarray) nogil + void PyArray_CLEARFLAGS(ndarray, int flags) nogil # Added in NumPy 1.7 + void PyArray_ENABLEFLAGS(ndarray, int flags) nogil # Added in NumPy 1.7 + npy_intp PyArray_ITEMSIZE(ndarray) nogil + int PyArray_TYPE(ndarray arr) nogil + + object PyArray_GETITEM(ndarray arr, void *itemptr) + int PyArray_SETITEM(ndarray arr, void *itemptr, object obj) except -1 + + bint PyTypeNum_ISBOOL(int) nogil + bint PyTypeNum_ISUNSIGNED(int) nogil + bint PyTypeNum_ISSIGNED(int) nogil + bint PyTypeNum_ISINTEGER(int) nogil + bint PyTypeNum_ISFLOAT(int) nogil + bint PyTypeNum_ISNUMBER(int) nogil + bint PyTypeNum_ISSTRING(int) nogil + bint PyTypeNum_ISCOMPLEX(int) nogil + bint PyTypeNum_ISFLEXIBLE(int) nogil + bint PyTypeNum_ISUSERDEF(int) nogil + bint PyTypeNum_ISEXTENDED(int) nogil + bint PyTypeNum_ISOBJECT(int) nogil + + npy_intp PyDataType_ELSIZE(dtype) nogil + npy_intp PyDataType_ALIGNMENT(dtype) nogil + PyObject* PyDataType_METADATA(dtype) nogil + PyArray_ArrayDescr* PyDataType_SUBARRAY(dtype) nogil + PyObject* PyDataType_NAMES(dtype) nogil + PyObject* PyDataType_FIELDS(dtype) nogil + + bint PyDataType_ISBOOL(dtype) nogil + bint PyDataType_ISUNSIGNED(dtype) nogil + bint PyDataType_ISSIGNED(dtype) nogil + bint PyDataType_ISINTEGER(dtype) nogil + bint PyDataType_ISFLOAT(dtype) nogil + bint PyDataType_ISNUMBER(dtype) nogil + bint PyDataType_ISSTRING(dtype) nogil + bint PyDataType_ISCOMPLEX(dtype) nogil + bint PyDataType_ISFLEXIBLE(dtype) nogil + bint PyDataType_ISUSERDEF(dtype) nogil + bint PyDataType_ISEXTENDED(dtype) nogil + bint PyDataType_ISOBJECT(dtype) nogil + bint PyDataType_HASFIELDS(dtype) nogil + bint PyDataType_HASSUBARRAY(dtype) nogil + npy_uint64 PyDataType_FLAGS(dtype) nogil + + bint PyArray_ISBOOL(ndarray) nogil + bint PyArray_ISUNSIGNED(ndarray) nogil + bint PyArray_ISSIGNED(ndarray) nogil + bint PyArray_ISINTEGER(ndarray) nogil + bint PyArray_ISFLOAT(ndarray) nogil + bint PyArray_ISNUMBER(ndarray) nogil + bint PyArray_ISSTRING(ndarray) nogil + bint PyArray_ISCOMPLEX(ndarray) nogil + bint PyArray_ISFLEXIBLE(ndarray) nogil + bint PyArray_ISUSERDEF(ndarray) nogil + bint PyArray_ISEXTENDED(ndarray) nogil + bint PyArray_ISOBJECT(ndarray) nogil + bint PyArray_HASFIELDS(ndarray) nogil + + bint PyArray_ISVARIABLE(ndarray) nogil + + bint PyArray_SAFEALIGNEDCOPY(ndarray) nogil + bint PyArray_ISNBO(char) nogil # works on ndarray.byteorder + bint PyArray_IsNativeByteOrder(char) nogil # works on ndarray.byteorder + bint PyArray_ISNOTSWAPPED(ndarray) nogil + bint PyArray_ISBYTESWAPPED(ndarray) nogil + + bint PyArray_FLAGSWAP(ndarray, int) nogil + + bint PyArray_ISCARRAY(ndarray) nogil + bint PyArray_ISCARRAY_RO(ndarray) nogil + bint PyArray_ISFARRAY(ndarray) nogil + bint PyArray_ISFARRAY_RO(ndarray) nogil + bint PyArray_ISBEHAVED(ndarray) nogil + bint PyArray_ISBEHAVED_RO(ndarray) nogil + + + bint PyDataType_ISNOTSWAPPED(dtype) nogil + bint PyDataType_ISBYTESWAPPED(dtype) nogil + + bint PyArray_DescrCheck(object) + + bint PyArray_Check(object) + bint PyArray_CheckExact(object) + + # Cannot be supported due to out arg: + # bint PyArray_HasArrayInterfaceType(object, dtype, object, object&) + # bint PyArray_HasArrayInterface(op, out) + + + bint PyArray_IsZeroDim(object) + # Cannot be supported due to ## ## in macro: + # bint PyArray_IsScalar(object, verbatim work) + bint PyArray_CheckScalar(object) + bint PyArray_IsPythonNumber(object) + bint PyArray_IsPythonScalar(object) + bint PyArray_IsAnyScalar(object) + bint PyArray_CheckAnyScalar(object) + + ndarray PyArray_GETCONTIGUOUS(ndarray) + bint PyArray_SAMESHAPE(ndarray, ndarray) nogil + npy_intp PyArray_SIZE(ndarray) nogil + npy_intp PyArray_NBYTES(ndarray) nogil + + object PyArray_FROM_O(object) + object PyArray_FROM_OF(object m, int flags) + object PyArray_FROM_OT(object m, int type) + object PyArray_FROM_OTF(object m, int type, int flags) + object PyArray_FROMANY(object m, int type, int min, int max, int flags) + object PyArray_ZEROS(int nd, npy_intp* dims, int type, int fortran) + object PyArray_EMPTY(int nd, npy_intp* dims, int type, int fortran) + void PyArray_FILLWBYTE(ndarray, int val) + object PyArray_ContiguousFromAny(op, int, int min_depth, int max_depth) + unsigned char PyArray_EquivArrTypes(ndarray a1, ndarray a2) + bint PyArray_EquivByteorders(int b1, int b2) nogil + object PyArray_SimpleNew(int nd, npy_intp* dims, int typenum) + object PyArray_SimpleNewFromData(int nd, npy_intp* dims, int typenum, void* data) + #object PyArray_SimpleNewFromDescr(int nd, npy_intp* dims, dtype descr) + object PyArray_ToScalar(void* data, ndarray arr) + + void* PyArray_GETPTR1(ndarray m, npy_intp i) nogil + void* PyArray_GETPTR2(ndarray m, npy_intp i, npy_intp j) nogil + void* PyArray_GETPTR3(ndarray m, npy_intp i, npy_intp j, npy_intp k) nogil + void* PyArray_GETPTR4(ndarray m, npy_intp i, npy_intp j, npy_intp k, npy_intp l) nogil + + # Cannot be supported due to out arg + # void PyArray_DESCR_REPLACE(descr) + + + object PyArray_Copy(ndarray) + object PyArray_FromObject(object op, int type, int min_depth, int max_depth) + object PyArray_ContiguousFromObject(object op, int type, int min_depth, int max_depth) + object PyArray_CopyFromObject(object op, int type, int min_depth, int max_depth) + + object PyArray_Cast(ndarray mp, int type_num) + object PyArray_Take(ndarray ap, object items, int axis) + object PyArray_Put(ndarray ap, object items, object values) + + void PyArray_ITER_RESET(flatiter it) nogil + void PyArray_ITER_NEXT(flatiter it) nogil + void PyArray_ITER_GOTO(flatiter it, npy_intp* destination) nogil + void PyArray_ITER_GOTO1D(flatiter it, npy_intp ind) nogil + void* PyArray_ITER_DATA(flatiter it) nogil + bint PyArray_ITER_NOTDONE(flatiter it) nogil + + void PyArray_MultiIter_RESET(broadcast multi) nogil + void PyArray_MultiIter_NEXT(broadcast multi) nogil + void PyArray_MultiIter_GOTO(broadcast multi, npy_intp dest) nogil + void PyArray_MultiIter_GOTO1D(broadcast multi, npy_intp ind) nogil + void* PyArray_MultiIter_DATA(broadcast multi, npy_intp i) nogil + void PyArray_MultiIter_NEXTi(broadcast multi, npy_intp i) nogil + bint PyArray_MultiIter_NOTDONE(broadcast multi) nogil + npy_intp PyArray_MultiIter_SIZE(broadcast multi) nogil + int PyArray_MultiIter_NDIM(broadcast multi) nogil + npy_intp PyArray_MultiIter_INDEX(broadcast multi) nogil + int PyArray_MultiIter_NUMITER(broadcast multi) nogil + npy_intp* PyArray_MultiIter_DIMS(broadcast multi) nogil + void** PyArray_MultiIter_ITERS(broadcast multi) nogil + + # Functions from __multiarray_api.h + + # Functions taking dtype and returning object/ndarray are disabled + # for now as they steal dtype references. I'm conservative and disable + # more than is probably needed until it can be checked further. + int PyArray_INCREF (ndarray) except * # uses PyArray_Item_INCREF... + int PyArray_XDECREF (ndarray) except * # uses PyArray_Item_DECREF... + dtype PyArray_DescrFromType (int) + object PyArray_TypeObjectFromType (int) + char * PyArray_Zero (ndarray) + char * PyArray_One (ndarray) + #object PyArray_CastToType (ndarray, dtype, int) + int PyArray_CanCastSafely (int, int) # writes errors + npy_bool PyArray_CanCastTo (dtype, dtype) # writes errors + int PyArray_ObjectType (object, int) except 0 + dtype PyArray_DescrFromObject (object, dtype) + #ndarray* PyArray_ConvertToCommonType (object, int *) + dtype PyArray_DescrFromScalar (object) + dtype PyArray_DescrFromTypeObject (object) + npy_intp PyArray_Size (object) + #object PyArray_Scalar (void *, dtype, object) + #object PyArray_FromScalar (object, dtype) + void PyArray_ScalarAsCtype (object, void *) + #int PyArray_CastScalarToCtype (object, void *, dtype) + #int PyArray_CastScalarDirect (object, dtype, void *, int) + #PyArray_VectorUnaryFunc * PyArray_GetCastFunc (dtype, int) + #object PyArray_FromAny (object, dtype, int, int, int, object) + object PyArray_EnsureArray (object) + object PyArray_EnsureAnyArray (object) + #object PyArray_FromFile (stdio.FILE *, dtype, npy_intp, char *) + #object PyArray_FromString (char *, npy_intp, dtype, npy_intp, char *) + #object PyArray_FromBuffer (object, dtype, npy_intp, npy_intp) + #object PyArray_FromIter (object, dtype, npy_intp) + object PyArray_Return (ndarray) + #object PyArray_GetField (ndarray, dtype, int) + #int PyArray_SetField (ndarray, dtype, int, object) except -1 + object PyArray_Byteswap (ndarray, npy_bool) + object PyArray_Resize (ndarray, PyArray_Dims *, int, NPY_ORDER) + int PyArray_CopyInto (ndarray, ndarray) except -1 + int PyArray_CopyAnyInto (ndarray, ndarray) except -1 + int PyArray_CopyObject (ndarray, object) except -1 + object PyArray_NewCopy (ndarray, NPY_ORDER) + object PyArray_ToList (ndarray) + object PyArray_ToString (ndarray, NPY_ORDER) + int PyArray_ToFile (ndarray, stdio.FILE *, char *, char *) except -1 + int PyArray_Dump (object, object, int) except -1 + object PyArray_Dumps (object, int) + int PyArray_ValidType (int) # Cannot error + void PyArray_UpdateFlags (ndarray, int) + object PyArray_New (type, int, npy_intp *, int, npy_intp *, void *, int, int, object) + #object PyArray_NewFromDescr (type, dtype, int, npy_intp *, npy_intp *, void *, int, object) + #dtype PyArray_DescrNew (dtype) + dtype PyArray_DescrNewFromType (int) + double PyArray_GetPriority (object, double) # clears errors as of 1.25 + object PyArray_IterNew (object) + object PyArray_MultiIterNew (int, ...) + + int PyArray_PyIntAsInt (object) except? -1 + npy_intp PyArray_PyIntAsIntp (object) + int PyArray_Broadcast (broadcast) except -1 + int PyArray_FillWithScalar (ndarray, object) except -1 + npy_bool PyArray_CheckStrides (int, int, npy_intp, npy_intp, npy_intp *, npy_intp *) + dtype PyArray_DescrNewByteorder (dtype, char) + object PyArray_IterAllButAxis (object, int *) + #object PyArray_CheckFromAny (object, dtype, int, int, int, object) + #object PyArray_FromArray (ndarray, dtype, int) + object PyArray_FromInterface (object) + object PyArray_FromStructInterface (object) + #object PyArray_FromArrayAttr (object, dtype, object) + #NPY_SCALARKIND PyArray_ScalarKind (int, ndarray*) + int PyArray_CanCoerceScalar (int, int, NPY_SCALARKIND) + npy_bool PyArray_CanCastScalar (type, type) + int PyArray_RemoveSmallest (broadcast) except -1 + int PyArray_ElementStrides (object) + void PyArray_Item_INCREF (char *, dtype) except * + void PyArray_Item_XDECREF (char *, dtype) except * + object PyArray_Transpose (ndarray, PyArray_Dims *) + object PyArray_TakeFrom (ndarray, object, int, ndarray, NPY_CLIPMODE) + object PyArray_PutTo (ndarray, object, object, NPY_CLIPMODE) + object PyArray_PutMask (ndarray, object, object) + object PyArray_Repeat (ndarray, object, int) + object PyArray_Choose (ndarray, object, ndarray, NPY_CLIPMODE) + int PyArray_Sort (ndarray, int, NPY_SORTKIND) except -1 + object PyArray_ArgSort (ndarray, int, NPY_SORTKIND) + object PyArray_SearchSorted (ndarray, object, NPY_SEARCHSIDE, PyObject *) + object PyArray_ArgMax (ndarray, int, ndarray) + object PyArray_ArgMin (ndarray, int, ndarray) + object PyArray_Reshape (ndarray, object) + object PyArray_Newshape (ndarray, PyArray_Dims *, NPY_ORDER) + object PyArray_Squeeze (ndarray) + #object PyArray_View (ndarray, dtype, type) + object PyArray_SwapAxes (ndarray, int, int) + object PyArray_Max (ndarray, int, ndarray) + object PyArray_Min (ndarray, int, ndarray) + object PyArray_Ptp (ndarray, int, ndarray) + object PyArray_Mean (ndarray, int, int, ndarray) + object PyArray_Trace (ndarray, int, int, int, int, ndarray) + object PyArray_Diagonal (ndarray, int, int, int) + object PyArray_Clip (ndarray, object, object, ndarray) + object PyArray_Conjugate (ndarray, ndarray) + object PyArray_Nonzero (ndarray) + object PyArray_Std (ndarray, int, int, ndarray, int) + object PyArray_Sum (ndarray, int, int, ndarray) + object PyArray_CumSum (ndarray, int, int, ndarray) + object PyArray_Prod (ndarray, int, int, ndarray) + object PyArray_CumProd (ndarray, int, int, ndarray) + object PyArray_All (ndarray, int, ndarray) + object PyArray_Any (ndarray, int, ndarray) + object PyArray_Compress (ndarray, object, int, ndarray) + object PyArray_Flatten (ndarray, NPY_ORDER) + object PyArray_Ravel (ndarray, NPY_ORDER) + npy_intp PyArray_MultiplyList (npy_intp *, int) + int PyArray_MultiplyIntList (int *, int) + void * PyArray_GetPtr (ndarray, npy_intp*) + int PyArray_CompareLists (npy_intp *, npy_intp *, int) + #int PyArray_AsCArray (object*, void *, npy_intp *, int, dtype) + int PyArray_Free (object, void *) + #int PyArray_Converter (object, object*) + int PyArray_IntpFromSequence (object, npy_intp *, int) except -1 + object PyArray_Concatenate (object, int) + object PyArray_InnerProduct (object, object) + object PyArray_MatrixProduct (object, object) + object PyArray_Correlate (object, object, int) + #int PyArray_DescrConverter (object, dtype*) except 0 + #int PyArray_DescrConverter2 (object, dtype*) except 0 + int PyArray_IntpConverter (object, PyArray_Dims *) except 0 + #int PyArray_BufferConverter (object, chunk) except 0 + int PyArray_AxisConverter (object, int *) except 0 + int PyArray_BoolConverter (object, npy_bool *) except 0 + int PyArray_ByteorderConverter (object, char *) except 0 + int PyArray_OrderConverter (object, NPY_ORDER *) except 0 + unsigned char PyArray_EquivTypes (dtype, dtype) # clears errors + #object PyArray_Zeros (int, npy_intp *, dtype, int) + #object PyArray_Empty (int, npy_intp *, dtype, int) + object PyArray_Where (object, object, object) + object PyArray_Arange (double, double, double, int) + #object PyArray_ArangeObj (object, object, object, dtype) + int PyArray_SortkindConverter (object, NPY_SORTKIND *) except 0 + object PyArray_LexSort (object, int) + object PyArray_Round (ndarray, int, ndarray) + unsigned char PyArray_EquivTypenums (int, int) + int PyArray_RegisterDataType (dtype) except -1 + int PyArray_RegisterCastFunc (dtype, int, PyArray_VectorUnaryFunc *) except -1 + int PyArray_RegisterCanCast (dtype, int, NPY_SCALARKIND) except -1 + #void PyArray_InitArrFuncs (PyArray_ArrFuncs *) + object PyArray_IntTupleFromIntp (int, npy_intp *) + int PyArray_ClipmodeConverter (object, NPY_CLIPMODE *) except 0 + #int PyArray_OutputConverter (object, ndarray*) except 0 + object PyArray_BroadcastToShape (object, npy_intp *, int) + #int PyArray_DescrAlignConverter (object, dtype*) except 0 + #int PyArray_DescrAlignConverter2 (object, dtype*) except 0 + int PyArray_SearchsideConverter (object, void *) except 0 + object PyArray_CheckAxis (ndarray, int *, int) + npy_intp PyArray_OverflowMultiplyList (npy_intp *, int) + int PyArray_SetBaseObject(ndarray, base) except -1 # NOTE: steals a reference to base! Use "set_array_base()" instead. + + # additional datetime related functions are defined below + + +# Typedefs that matches the runtime dtype objects in +# the numpy module. + +# The ones that are commented out needs an IFDEF function +# in Cython to enable them only on the right systems. + +ctypedef npy_int8 int8_t +ctypedef npy_int16 int16_t +ctypedef npy_int32 int32_t +ctypedef npy_int64 int64_t +#ctypedef npy_int96 int96_t +#ctypedef npy_int128 int128_t + +ctypedef npy_uint8 uint8_t +ctypedef npy_uint16 uint16_t +ctypedef npy_uint32 uint32_t +ctypedef npy_uint64 uint64_t +#ctypedef npy_uint96 uint96_t +#ctypedef npy_uint128 uint128_t + +ctypedef npy_float32 float32_t +ctypedef npy_float64 float64_t +#ctypedef npy_float80 float80_t +#ctypedef npy_float128 float128_t + +ctypedef float complex complex64_t +ctypedef double complex complex128_t + +ctypedef npy_longlong longlong_t +ctypedef npy_ulonglong ulonglong_t + +ctypedef npy_intp intp_t +ctypedef npy_uintp uintp_t + +ctypedef npy_double float_t +ctypedef npy_double double_t +ctypedef npy_longdouble longdouble_t + +ctypedef float complex cfloat_t +ctypedef double complex cdouble_t +ctypedef double complex complex_t +ctypedef long double complex clongdouble_t + +cdef inline object PyArray_MultiIterNew1(a): + return PyArray_MultiIterNew(1, a) + +cdef inline object PyArray_MultiIterNew2(a, b): + return PyArray_MultiIterNew(2, a, b) + +cdef inline object PyArray_MultiIterNew3(a, b, c): + return PyArray_MultiIterNew(3, a, b, c) + +cdef inline object PyArray_MultiIterNew4(a, b, c, d): + return PyArray_MultiIterNew(4, a, b, c, d) + +cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): + return PyArray_MultiIterNew(5, a, b, c, d, e) + +cdef inline tuple PyDataType_SHAPE(dtype d): + if PyDataType_HASSUBARRAY(d): + return d.subarray.shape + else: + return () + + +cdef extern from "numpy/ndarrayobject.h": + PyTypeObject PyTimedeltaArrType_Type + PyTypeObject PyDatetimeArrType_Type + ctypedef int64_t npy_timedelta + ctypedef int64_t npy_datetime + +cdef extern from "numpy/ndarraytypes.h": + ctypedef struct PyArray_DatetimeMetaData: + NPY_DATETIMEUNIT base + int64_t num + + ctypedef struct npy_datetimestruct: + int64_t year + int32_t month, day, hour, min, sec, us, ps, as + + +cdef extern from "numpy/arrayscalars.h": + + # abstract types + ctypedef class numpy.generic [object PyObject]: + pass + ctypedef class numpy.number [object PyObject]: + pass + ctypedef class numpy.integer [object PyObject]: + pass + ctypedef class numpy.signedinteger [object PyObject]: + pass + ctypedef class numpy.unsignedinteger [object PyObject]: + pass + ctypedef class numpy.inexact [object PyObject]: + pass + ctypedef class numpy.floating [object PyObject]: + pass + ctypedef class numpy.complexfloating [object PyObject]: + pass + ctypedef class numpy.flexible [object PyObject]: + pass + ctypedef class numpy.character [object PyObject]: + pass + + ctypedef struct PyDatetimeScalarObject: + # PyObject_HEAD + npy_datetime obval + PyArray_DatetimeMetaData obmeta + + ctypedef struct PyTimedeltaScalarObject: + # PyObject_HEAD + npy_timedelta obval + PyArray_DatetimeMetaData obmeta + + ctypedef enum NPY_DATETIMEUNIT: + NPY_FR_Y + NPY_FR_M + NPY_FR_W + NPY_FR_D + NPY_FR_B + NPY_FR_h + NPY_FR_m + NPY_FR_s + NPY_FR_ms + NPY_FR_us + NPY_FR_ns + NPY_FR_ps + NPY_FR_fs + NPY_FR_as + NPY_FR_GENERIC + + +cdef extern from "numpy/arrayobject.h": + # These are part of the C-API defined in `__multiarray_api.h` + + # NumPy internal definitions in datetime_strings.c: + int get_datetime_iso_8601_strlen "NpyDatetime_GetDatetimeISO8601StrLen" ( + int local, NPY_DATETIMEUNIT base) + int make_iso_8601_datetime "NpyDatetime_MakeISO8601Datetime" ( + npy_datetimestruct *dts, char *outstr, npy_intp outlen, + int local, int utc, NPY_DATETIMEUNIT base, int tzoffset, + NPY_CASTING casting) except -1 + + # NumPy internal definition in datetime.c: + # May return 1 to indicate that object does not appear to be a datetime + # (returns 0 on success). + int convert_pydatetime_to_datetimestruct "NpyDatetime_ConvertPyDateTimeToDatetimeStruct" ( + PyObject *obj, npy_datetimestruct *out, + NPY_DATETIMEUNIT *out_bestunit, int apply_tzinfo) except -1 + int convert_datetime64_to_datetimestruct "NpyDatetime_ConvertDatetime64ToDatetimeStruct" ( + PyArray_DatetimeMetaData *meta, npy_datetime dt, + npy_datetimestruct *out) except -1 + int convert_datetimestruct_to_datetime64 "NpyDatetime_ConvertDatetimeStructToDatetime64"( + PyArray_DatetimeMetaData *meta, const npy_datetimestruct *dts, + npy_datetime *out) except -1 + + +# +# ufunc API +# + +cdef extern from "numpy/ufuncobject.h": + + ctypedef void (*PyUFuncGenericFunction) (char **, npy_intp *, npy_intp *, void *) + + ctypedef class numpy.ufunc [object PyUFuncObject, check_size ignore]: + cdef: + int nin, nout, nargs + int identity + PyUFuncGenericFunction *functions + void **data + int ntypes + int check_return + char *name + char *types + char *doc + void *ptr + PyObject *obj + PyObject *userloops + + cdef enum: + PyUFunc_Zero + PyUFunc_One + PyUFunc_None + UFUNC_FPE_DIVIDEBYZERO + UFUNC_FPE_OVERFLOW + UFUNC_FPE_UNDERFLOW + UFUNC_FPE_INVALID + + object PyUFunc_FromFuncAndData(PyUFuncGenericFunction *, + void **, char *, int, int, int, int, char *, char *, int) + int PyUFunc_RegisterLoopForType(ufunc, int, + PyUFuncGenericFunction, int *, void *) except -1 + void PyUFunc_f_f_As_d_d \ + (char **, npy_intp *, npy_intp *, void *) + void PyUFunc_d_d \ + (char **, npy_intp *, npy_intp *, void *) + void PyUFunc_f_f \ + (char **, npy_intp *, npy_intp *, void *) + void PyUFunc_g_g \ + (char **, npy_intp *, npy_intp *, void *) + void PyUFunc_F_F_As_D_D \ + (char **, npy_intp *, npy_intp *, void *) + void PyUFunc_F_F \ + (char **, npy_intp *, npy_intp *, void *) + void PyUFunc_D_D \ + (char **, npy_intp *, npy_intp *, void *) + void PyUFunc_G_G \ + (char **, npy_intp *, npy_intp *, void *) + void PyUFunc_O_O \ + (char **, npy_intp *, npy_intp *, void *) + void PyUFunc_ff_f_As_dd_d \ + (char **, npy_intp *, npy_intp *, void *) + void PyUFunc_ff_f \ + (char **, npy_intp *, npy_intp *, void *) + void PyUFunc_dd_d \ + (char **, npy_intp *, npy_intp *, void *) + void PyUFunc_gg_g \ + (char **, npy_intp *, npy_intp *, void *) + void PyUFunc_FF_F_As_DD_D \ + (char **, npy_intp *, npy_intp *, void *) + void PyUFunc_DD_D \ + (char **, npy_intp *, npy_intp *, void *) + void PyUFunc_FF_F \ + (char **, npy_intp *, npy_intp *, void *) + void PyUFunc_GG_G \ + (char **, npy_intp *, npy_intp *, void *) + void PyUFunc_OO_O \ + (char **, npy_intp *, npy_intp *, void *) + void PyUFunc_O_O_method \ + (char **, npy_intp *, npy_intp *, void *) + void PyUFunc_OO_O_method \ + (char **, npy_intp *, npy_intp *, void *) + void PyUFunc_On_Om \ + (char **, npy_intp *, npy_intp *, void *) + void PyUFunc_clearfperr() + int PyUFunc_getfperr() + int PyUFunc_ReplaceLoopBySignature \ + (ufunc, PyUFuncGenericFunction, int *, PyUFuncGenericFunction *) + object PyUFunc_FromFuncAndDataAndSignature \ + (PyUFuncGenericFunction *, void **, char *, int, int, int, + int, char *, char *, int, char *) + + int _import_umath() except -1 + +cdef inline void set_array_base(ndarray arr, object base): + Py_INCREF(base) # important to do this before stealing the reference below! + PyArray_SetBaseObject(arr, base) + +cdef inline object get_array_base(ndarray arr): + base = PyArray_BASE(arr) + if base is NULL: + return None + return base + +# Versions of the import_* functions which are more suitable for +# Cython code. +cdef inline int import_array() except -1: + try: + __pyx_import_array() + except Exception: + raise ImportError("numpy._core.multiarray failed to import") + +cdef inline int import_umath() except -1: + try: + _import_umath() + except Exception: + raise ImportError("numpy._core.umath failed to import") + +cdef inline int import_ufunc() except -1: + try: + _import_umath() + except Exception: + raise ImportError("numpy._core.umath failed to import") + + +cdef inline bint is_timedelta64_object(object obj): + """ + Cython equivalent of `isinstance(obj, np.timedelta64)` + + Parameters + ---------- + obj : object + + Returns + ------- + bool + """ + return PyObject_TypeCheck(obj, &PyTimedeltaArrType_Type) + + +cdef inline bint is_datetime64_object(object obj): + """ + Cython equivalent of `isinstance(obj, np.datetime64)` + + Parameters + ---------- + obj : object + + Returns + ------- + bool + """ + return PyObject_TypeCheck(obj, &PyDatetimeArrType_Type) + + +cdef inline npy_datetime get_datetime64_value(object obj) nogil: + """ + returns the int64 value underlying scalar numpy datetime64 object + + Note that to interpret this as a datetime, the corresponding unit is + also needed. That can be found using `get_datetime64_unit`. + """ + return (obj).obval + + +cdef inline npy_timedelta get_timedelta64_value(object obj) nogil: + """ + returns the int64 value underlying scalar numpy timedelta64 object + """ + return (obj).obval + + +cdef inline NPY_DATETIMEUNIT get_datetime64_unit(object obj) nogil: + """ + returns the unit part of the dtype for a numpy datetime64 object. + """ + return (obj).obmeta.base + + +# Iterator API added in v1.6 +ctypedef int (*NpyIter_IterNextFunc)(NpyIter* it) noexcept nogil +ctypedef void (*NpyIter_GetMultiIndexFunc)(NpyIter* it, npy_intp* outcoords) noexcept nogil + +cdef extern from "numpy/arrayobject.h": + + ctypedef struct NpyIter: + pass + + cdef enum: + NPY_FAIL + NPY_SUCCEED + + cdef enum: + # Track an index representing C order + NPY_ITER_C_INDEX + # Track an index representing Fortran order + NPY_ITER_F_INDEX + # Track a multi-index + NPY_ITER_MULTI_INDEX + # User code external to the iterator does the 1-dimensional innermost loop + NPY_ITER_EXTERNAL_LOOP + # Convert all the operands to a common data type + NPY_ITER_COMMON_DTYPE + # Operands may hold references, requiring API access during iteration + NPY_ITER_REFS_OK + # Zero-sized operands should be permitted, iteration checks IterSize for 0 + NPY_ITER_ZEROSIZE_OK + # Permits reductions (size-0 stride with dimension size > 1) + NPY_ITER_REDUCE_OK + # Enables sub-range iteration + NPY_ITER_RANGED + # Enables buffering + NPY_ITER_BUFFERED + # When buffering is enabled, grows the inner loop if possible + NPY_ITER_GROWINNER + # Delay allocation of buffers until first Reset* call + NPY_ITER_DELAY_BUFALLOC + # When NPY_KEEPORDER is specified, disable reversing negative-stride axes + NPY_ITER_DONT_NEGATE_STRIDES + NPY_ITER_COPY_IF_OVERLAP + # The operand will be read from and written to + NPY_ITER_READWRITE + # The operand will only be read from + NPY_ITER_READONLY + # The operand will only be written to + NPY_ITER_WRITEONLY + # The operand's data must be in native byte order + NPY_ITER_NBO + # The operand's data must be aligned + NPY_ITER_ALIGNED + # The operand's data must be contiguous (within the inner loop) + NPY_ITER_CONTIG + # The operand may be copied to satisfy requirements + NPY_ITER_COPY + # The operand may be copied with WRITEBACKIFCOPY to satisfy requirements + NPY_ITER_UPDATEIFCOPY + # Allocate the operand if it is NULL + NPY_ITER_ALLOCATE + # If an operand is allocated, don't use any subtype + NPY_ITER_NO_SUBTYPE + # This is a virtual array slot, operand is NULL but temporary data is there + NPY_ITER_VIRTUAL + # Require that the dimension match the iterator dimensions exactly + NPY_ITER_NO_BROADCAST + # A mask is being used on this array, affects buffer -> array copy + NPY_ITER_WRITEMASKED + # This array is the mask for all WRITEMASKED operands + NPY_ITER_ARRAYMASK + # Assume iterator order data access for COPY_IF_OVERLAP + NPY_ITER_OVERLAP_ASSUME_ELEMENTWISE + + # construction and destruction functions + NpyIter* NpyIter_New(ndarray arr, npy_uint32 flags, NPY_ORDER order, + NPY_CASTING casting, dtype datatype) except NULL + NpyIter* NpyIter_MultiNew(npy_intp nop, PyArrayObject** op, npy_uint32 flags, + NPY_ORDER order, NPY_CASTING casting, npy_uint32* + op_flags, PyArray_Descr** op_dtypes) except NULL + NpyIter* NpyIter_AdvancedNew(npy_intp nop, PyArrayObject** op, + npy_uint32 flags, NPY_ORDER order, + NPY_CASTING casting, npy_uint32* op_flags, + PyArray_Descr** op_dtypes, int oa_ndim, + int** op_axes, const npy_intp* itershape, + npy_intp buffersize) except NULL + NpyIter* NpyIter_Copy(NpyIter* it) except NULL + int NpyIter_RemoveAxis(NpyIter* it, int axis) except NPY_FAIL + int NpyIter_RemoveMultiIndex(NpyIter* it) except NPY_FAIL + int NpyIter_EnableExternalLoop(NpyIter* it) except NPY_FAIL + int NpyIter_Deallocate(NpyIter* it) except NPY_FAIL + int NpyIter_Reset(NpyIter* it, char** errmsg) except NPY_FAIL + int NpyIter_ResetToIterIndexRange(NpyIter* it, npy_intp istart, + npy_intp iend, char** errmsg) except NPY_FAIL + int NpyIter_ResetBasePointers(NpyIter* it, char** baseptrs, char** errmsg) except NPY_FAIL + int NpyIter_GotoMultiIndex(NpyIter* it, const npy_intp* multi_index) except NPY_FAIL + int NpyIter_GotoIndex(NpyIter* it, npy_intp index) except NPY_FAIL + npy_intp NpyIter_GetIterSize(NpyIter* it) nogil + npy_intp NpyIter_GetIterIndex(NpyIter* it) nogil + void NpyIter_GetIterIndexRange(NpyIter* it, npy_intp* istart, + npy_intp* iend) nogil + int NpyIter_GotoIterIndex(NpyIter* it, npy_intp iterindex) except NPY_FAIL + npy_bool NpyIter_HasDelayedBufAlloc(NpyIter* it) nogil + npy_bool NpyIter_HasExternalLoop(NpyIter* it) nogil + npy_bool NpyIter_HasMultiIndex(NpyIter* it) nogil + npy_bool NpyIter_HasIndex(NpyIter* it) nogil + npy_bool NpyIter_RequiresBuffering(NpyIter* it) nogil + npy_bool NpyIter_IsBuffered(NpyIter* it) nogil + npy_bool NpyIter_IsGrowInner(NpyIter* it) nogil + npy_intp NpyIter_GetBufferSize(NpyIter* it) nogil + int NpyIter_GetNDim(NpyIter* it) nogil + int NpyIter_GetNOp(NpyIter* it) nogil + npy_intp* NpyIter_GetAxisStrideArray(NpyIter* it, int axis) except NULL + int NpyIter_GetShape(NpyIter* it, npy_intp* outshape) nogil + PyArray_Descr** NpyIter_GetDescrArray(NpyIter* it) + PyArrayObject** NpyIter_GetOperandArray(NpyIter* it) + ndarray NpyIter_GetIterView(NpyIter* it, npy_intp i) + void NpyIter_GetReadFlags(NpyIter* it, char* outreadflags) + void NpyIter_GetWriteFlags(NpyIter* it, char* outwriteflags) + int NpyIter_CreateCompatibleStrides(NpyIter* it, npy_intp itemsize, + npy_intp* outstrides) except NPY_FAIL + npy_bool NpyIter_IsFirstVisit(NpyIter* it, int iop) nogil + # functions for iterating an NpyIter object + NpyIter_IterNextFunc* NpyIter_GetIterNext(NpyIter* it, char** errmsg) except NULL + NpyIter_GetMultiIndexFunc* NpyIter_GetGetMultiIndex(NpyIter* it, + char** errmsg) except NULL + char** NpyIter_GetDataPtrArray(NpyIter* it) nogil + char** NpyIter_GetInitialDataPtrArray(NpyIter* it) nogil + npy_intp* NpyIter_GetIndexPtr(NpyIter* it) + npy_intp* NpyIter_GetInnerStrideArray(NpyIter* it) nogil + npy_intp* NpyIter_GetInnerLoopSizePtr(NpyIter* it) nogil + void NpyIter_GetInnerFixedStrideArray(NpyIter* it, npy_intp* outstrides) nogil + npy_bool NpyIter_IterationNeedsAPI(NpyIter* it) nogil + void NpyIter_DebugPrint(NpyIter* it) diff --git a/venv/lib/python3.12/site-packages/numpy/__init__.py b/venv/lib/python3.12/site-packages/numpy/__init__.py new file mode 100644 index 00000000..27e5d2d6 --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/__init__.py @@ -0,0 +1,542 @@ +""" +NumPy +===== + +Provides + 1. An array object of arbitrary homogeneous items + 2. Fast mathematical operations over arrays + 3. Linear Algebra, Fourier Transforms, Random Number Generation + +How to use the documentation +---------------------------- +Documentation is available in two forms: docstrings provided +with the code, and a loose standing reference guide, available from +`the NumPy homepage `_. + +We recommend exploring the docstrings using +`IPython `_, an advanced Python shell with +TAB-completion and introspection capabilities. See below for further +instructions. + +The docstring examples assume that `numpy` has been imported as ``np``:: + + >>> import numpy as np + +Code snippets are indicated by three greater-than signs:: + + >>> x = 42 + >>> x = x + 1 + +Use the built-in ``help`` function to view a function's docstring:: + + >>> help(np.sort) + ... # doctest: +SKIP + +For some objects, ``np.info(obj)`` may provide additional help. This is +particularly true if you see the line "Help on ufunc object:" at the top +of the help() page. Ufuncs are implemented in C, not Python, for speed. +The native Python help() does not know how to view their help, but our +np.info() function does. + +Available subpackages +--------------------- +lib + Basic functions used by several sub-packages. +random + Core Random Tools +linalg + Core Linear Algebra Tools +fft + Core FFT routines +polynomial + Polynomial tools +testing + NumPy testing tools +distutils + Enhancements to distutils with support for + Fortran compilers support and more (for Python <= 3.11) + +Utilities +--------- +test + Run numpy unittests +show_config + Show numpy build configuration +__version__ + NumPy version string + +Viewing documentation using IPython +----------------------------------- + +Start IPython and import `numpy` usually under the alias ``np``: `import +numpy as np`. Then, directly past or use the ``%cpaste`` magic to paste +examples into the shell. To see which functions are available in `numpy`, +type ``np.`` (where ```` refers to the TAB key), or use +``np.*cos*?`` (where ```` refers to the ENTER key) to narrow +down the list. To view the docstring for a function, use +``np.cos?`` (to view the docstring) and ``np.cos??`` (to view +the source code). + +Copies vs. in-place operation +----------------------------- +Most of the functions in `numpy` return a copy of the array argument +(e.g., `np.sort`). In-place versions of these functions are often +available as array methods, i.e. ``x = np.array([1,2,3]); x.sort()``. +Exceptions to this rule are documented. + +""" +import os +import sys +import warnings + +from ._globals import _NoValue, _CopyMode +from ._expired_attrs_2_0 import __expired_attributes__ + + +# If a version with git hash was stored, use that instead +from . import version +from .version import __version__ + +# We first need to detect if we're being called as part of the numpy setup +# procedure itself in a reliable manner. +try: + __NUMPY_SETUP__ +except NameError: + __NUMPY_SETUP__ = False + +if __NUMPY_SETUP__: + sys.stderr.write('Running from numpy source directory.\n') +else: + # Allow distributors to run custom init code before importing numpy._core + from . import _distributor_init + + try: + from numpy.__config__ import show as show_config + except ImportError as e: + msg = """Error importing numpy: you should not try to import numpy from + its source directory; please exit the numpy source tree, and relaunch + your python interpreter from there.""" + raise ImportError(msg) from e + + from . import _core + from ._core import ( + False_, ScalarType, True_, _get_promotion_state, _no_nep50_warning, + _set_promotion_state, abs, absolute, acos, acosh, add, all, allclose, + amax, amin, any, arange, arccos, arccosh, arcsin, arcsinh, + arctan, arctan2, arctanh, argmax, argmin, argpartition, argsort, + argwhere, around, array, array2string, array_equal, array_equiv, + array_repr, array_str, asanyarray, asarray, ascontiguousarray, + asfortranarray, asin, asinh, atan, atanh, atan2, astype, atleast_1d, + atleast_2d, atleast_3d, base_repr, binary_repr, bitwise_and, + bitwise_count, bitwise_invert, bitwise_left_shift, bitwise_not, + bitwise_or, bitwise_right_shift, bitwise_xor, block, bool, bool_, + broadcast, busday_count, busday_offset, busdaycalendar, byte, bytes_, + can_cast, cbrt, cdouble, ceil, character, choose, clip, clongdouble, + complex128, complex64, complexfloating, compress, concat, concatenate, + conj, conjugate, convolve, copysign, copyto, correlate, cos, cosh, + count_nonzero, cross, csingle, cumprod, cumsum, cumulative_prod, + cumulative_sum, datetime64, datetime_as_string, datetime_data, + deg2rad, degrees, diagonal, divide, divmod, dot, double, dtype, e, + einsum, einsum_path, empty, empty_like, equal, errstate, euler_gamma, + exp, exp2, expm1, fabs, finfo, flatiter, flatnonzero, flexible, + float16, float32, float64, float_power, floating, floor, floor_divide, + fmax, fmin, fmod, format_float_positional, format_float_scientific, + frexp, from_dlpack, frombuffer, fromfile, fromfunction, fromiter, + frompyfunc, fromstring, full, full_like, gcd, generic, geomspace, + get_printoptions, getbufsize, geterr, geterrcall, greater, + greater_equal, half, heaviside, hstack, hypot, identity, iinfo, iinfo, + indices, inexact, inf, inner, int16, int32, int64, int8, int_, intc, + integer, intp, invert, is_busday, isclose, isdtype, isfinite, + isfortran, isinf, isnan, isnat, isscalar, issubdtype, lcm, ldexp, + left_shift, less, less_equal, lexsort, linspace, little_endian, log, + log10, log1p, log2, logaddexp, logaddexp2, logical_and, logical_not, + logical_or, logical_xor, logspace, long, longdouble, longlong, matmul, + matrix_transpose, max, maximum, may_share_memory, mean, memmap, min, + min_scalar_type, minimum, mod, modf, moveaxis, multiply, nan, ndarray, + ndim, nditer, negative, nested_iters, newaxis, nextafter, nonzero, + not_equal, number, object_, ones, ones_like, outer, partition, + permute_dims, pi, positive, pow, power, printoptions, prod, + promote_types, ptp, put, putmask, rad2deg, radians, ravel, recarray, + reciprocal, record, remainder, repeat, require, reshape, resize, + result_type, right_shift, rint, roll, rollaxis, round, sctypeDict, + searchsorted, set_printoptions, setbufsize, seterr, seterrcall, shape, + shares_memory, short, sign, signbit, signedinteger, sin, single, sinh, + size, sort, spacing, sqrt, square, squeeze, stack, std, + str_, subtract, sum, swapaxes, take, tan, tanh, tensordot, + timedelta64, trace, transpose, true_divide, trunc, typecodes, ubyte, + ufunc, uint, uint16, uint32, uint64, uint8, uintc, uintp, ulong, + ulonglong, unsignedinteger, unstack, ushort, var, vdot, vecdot, void, + vstack, where, zeros, zeros_like + ) + + # NOTE: It's still under discussion whether these aliases + # should be removed. + for ta in ["float96", "float128", "complex192", "complex256"]: + try: + globals()[ta] = getattr(_core, ta) + except AttributeError: + pass + del ta + + from . import lib + from .lib import scimath as emath + from .lib._histograms_impl import ( + histogram, histogram_bin_edges, histogramdd + ) + from .lib._nanfunctions_impl import ( + nanargmax, nanargmin, nancumprod, nancumsum, nanmax, nanmean, + nanmedian, nanmin, nanpercentile, nanprod, nanquantile, nanstd, + nansum, nanvar + ) + from .lib._function_base_impl import ( + select, piecewise, trim_zeros, copy, iterable, percentile, diff, + gradient, angle, unwrap, sort_complex, flip, rot90, extract, place, + vectorize, asarray_chkfinite, average, bincount, digitize, cov, + corrcoef, median, sinc, hamming, hanning, bartlett, blackman, + kaiser, trapezoid, trapz, i0, meshgrid, delete, insert, append, + interp, quantile + ) + from .lib._twodim_base_impl import ( + diag, diagflat, eye, fliplr, flipud, tri, triu, tril, vander, + histogram2d, mask_indices, tril_indices, tril_indices_from, + triu_indices, triu_indices_from + ) + from .lib._shape_base_impl import ( + apply_over_axes, apply_along_axis, array_split, column_stack, dsplit, + dstack, expand_dims, hsplit, kron, put_along_axis, row_stack, split, + take_along_axis, tile, vsplit + ) + from .lib._type_check_impl import ( + iscomplexobj, isrealobj, imag, iscomplex, isreal, nan_to_num, real, + real_if_close, typename, mintypecode, common_type + ) + from .lib._arraysetops_impl import ( + ediff1d, in1d, intersect1d, isin, setdiff1d, setxor1d, union1d, + unique, unique_all, unique_counts, unique_inverse, unique_values + ) + from .lib._ufunclike_impl import fix, isneginf, isposinf + from .lib._arraypad_impl import pad + from .lib._utils_impl import ( + show_runtime, get_include, info + ) + from .lib._stride_tricks_impl import ( + broadcast_arrays, broadcast_shapes, broadcast_to + ) + from .lib._polynomial_impl import ( + poly, polyint, polyder, polyadd, polysub, polymul, polydiv, polyval, + polyfit, poly1d, roots + ) + from .lib._npyio_impl import ( + savetxt, loadtxt, genfromtxt, load, save, savez, packbits, + savez_compressed, unpackbits, fromregex + ) + from .lib._index_tricks_impl import ( + diag_indices_from, diag_indices, fill_diagonal, ndindex, ndenumerate, + ix_, c_, r_, s_, ogrid, mgrid, unravel_index, ravel_multi_index, + index_exp + ) + + from . import matrixlib as _mat + from .matrixlib import ( + asmatrix, bmat, matrix + ) + + # public submodules are imported lazily, therefore are accessible from + # __getattr__. Note that `distutils` (deprecated) and `array_api` + # (experimental label) are not added here, because `from numpy import *` + # must not raise any warnings - that's too disruptive. + __numpy_submodules__ = { + "linalg", "fft", "dtypes", "random", "polynomial", "ma", + "exceptions", "lib", "ctypeslib", "testing", "typing", + "f2py", "test", "rec", "char", "core", "strings", + } + + # We build warning messages for former attributes + _msg = ( + "module 'numpy' has no attribute '{n}'.\n" + "`np.{n}` was a deprecated alias for the builtin `{n}`. " + "To avoid this error in existing code, use `{n}` by itself. " + "Doing this will not modify any behavior and is safe. {extended_msg}\n" + "The aliases was originally deprecated in NumPy 1.20; for more " + "details and guidance see the original release note at:\n" + " https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations") + + _specific_msg = ( + "If you specifically wanted the numpy scalar type, use `np.{}` here.") + + _int_extended_msg = ( + "When replacing `np.{}`, you may wish to use e.g. `np.int64` " + "or `np.int32` to specify the precision. If you wish to review " + "your current use, check the release note link for " + "additional information.") + + _type_info = [ + ("object", ""), # The NumPy scalar only exists by name. + ("float", _specific_msg.format("float64")), + ("complex", _specific_msg.format("complex128")), + ("str", _specific_msg.format("str_")), + ("int", _int_extended_msg.format("int"))] + + __former_attrs__ = { + n: _msg.format(n=n, extended_msg=extended_msg) + for n, extended_msg in _type_info + } + + + # Some of these could be defined right away, but most were aliases to + # the Python objects and only removed in NumPy 1.24. Defining them should + # probably wait for NumPy 1.26 or 2.0. + # When defined, these should possibly not be added to `__all__` to avoid + # import with `from numpy import *`. + __future_scalars__ = {"str", "bytes", "object"} + + __array_api_version__ = "2023.12" + + from ._array_api_info import __array_namespace_info__ + + # now that numpy core module is imported, can initialize limits + _core.getlimits._register_known_types() + + __all__ = list( + __numpy_submodules__ | + set(_core.__all__) | + set(_mat.__all__) | + set(lib._histograms_impl.__all__) | + set(lib._nanfunctions_impl.__all__) | + set(lib._function_base_impl.__all__) | + set(lib._twodim_base_impl.__all__) | + set(lib._shape_base_impl.__all__) | + set(lib._type_check_impl.__all__) | + set(lib._arraysetops_impl.__all__) | + set(lib._ufunclike_impl.__all__) | + set(lib._arraypad_impl.__all__) | + set(lib._utils_impl.__all__) | + set(lib._stride_tricks_impl.__all__) | + set(lib._polynomial_impl.__all__) | + set(lib._npyio_impl.__all__) | + set(lib._index_tricks_impl.__all__) | + {"emath", "show_config", "__version__", "__array_namespace_info__"} + ) + + # Filter out Cython harmless warnings + warnings.filterwarnings("ignore", message="numpy.dtype size changed") + warnings.filterwarnings("ignore", message="numpy.ufunc size changed") + warnings.filterwarnings("ignore", message="numpy.ndarray size changed") + + def __getattr__(attr): + # Warn for expired attributes + import warnings + + if attr == "linalg": + import numpy.linalg as linalg + return linalg + elif attr == "fft": + import numpy.fft as fft + return fft + elif attr == "dtypes": + import numpy.dtypes as dtypes + return dtypes + elif attr == "random": + import numpy.random as random + return random + elif attr == "polynomial": + import numpy.polynomial as polynomial + return polynomial + elif attr == "ma": + import numpy.ma as ma + return ma + elif attr == "ctypeslib": + import numpy.ctypeslib as ctypeslib + return ctypeslib + elif attr == "exceptions": + import numpy.exceptions as exceptions + return exceptions + elif attr == "testing": + import numpy.testing as testing + return testing + elif attr == "matlib": + import numpy.matlib as matlib + return matlib + elif attr == "f2py": + import numpy.f2py as f2py + return f2py + elif attr == "typing": + import numpy.typing as typing + return typing + elif attr == "rec": + import numpy.rec as rec + return rec + elif attr == "char": + import numpy.char as char + return char + elif attr == "array_api": + raise AttributeError("`numpy.array_api` is not available from " + "numpy 2.0 onwards", name=None) + elif attr == "core": + import numpy.core as core + return core + elif attr == "strings": + import numpy.strings as strings + return strings + elif attr == "distutils": + if 'distutils' in __numpy_submodules__: + import numpy.distutils as distutils + return distutils + else: + raise AttributeError("`numpy.distutils` is not available from " + "Python 3.12 onwards", name=None) + + if attr in __future_scalars__: + # And future warnings for those that will change, but also give + # the AttributeError + warnings.warn( + f"In the future `np.{attr}` will be defined as the " + "corresponding NumPy scalar.", FutureWarning, stacklevel=2) + + if attr in __former_attrs__: + raise AttributeError(__former_attrs__[attr], name=None) + + if attr in __expired_attributes__: + raise AttributeError( + f"`np.{attr}` was removed in the NumPy 2.0 release. " + f"{__expired_attributes__[attr]}", + name=None + ) + + if attr == "chararray": + warnings.warn( + "`np.chararray` is deprecated and will be removed from " + "the main namespace in the future. Use an array with a string " + "or bytes dtype instead.", DeprecationWarning, stacklevel=2) + import numpy.char as char + return char.chararray + + raise AttributeError("module {!r} has no attribute " + "{!r}".format(__name__, attr)) + + def __dir__(): + public_symbols = ( + globals().keys() | __numpy_submodules__ + ) + public_symbols -= { + "matrixlib", "matlib", "tests", "conftest", "version", + "compat", "distutils", "array_api" + } + return list(public_symbols) + + # Pytest testing + from numpy._pytesttester import PytestTester + test = PytestTester(__name__) + del PytestTester + + def _sanity_check(): + """ + Quick sanity checks for common bugs caused by environment. + There are some cases e.g. with wrong BLAS ABI that cause wrong + results under specific runtime conditions that are not necessarily + achieved during test suite runs, and it is useful to catch those early. + + See https://github.com/numpy/numpy/issues/8577 and other + similar bug reports. + + """ + try: + x = ones(2, dtype=float32) + if not abs(x.dot(x) - float32(2.0)) < 1e-5: + raise AssertionError() + except AssertionError: + msg = ("The current Numpy installation ({!r}) fails to " + "pass simple sanity checks. This can be caused for example " + "by incorrect BLAS library being linked in, or by mixing " + "package managers (pip, conda, apt, ...). Search closed " + "numpy issues for similar problems.") + raise RuntimeError(msg.format(__file__)) from None + + _sanity_check() + del _sanity_check + + def _mac_os_check(): + """ + Quick Sanity check for Mac OS look for accelerate build bugs. + Testing numpy polyfit calls init_dgelsd(LAPACK) + """ + try: + c = array([3., 2., 1.]) + x = linspace(0, 2, 5) + y = polyval(c, x) + _ = polyfit(x, y, 2, cov=True) + except ValueError: + pass + + if sys.platform == "darwin": + from . import exceptions + with warnings.catch_warnings(record=True) as w: + _mac_os_check() + # Throw runtime error, if the test failed Check for warning and error_message + if len(w) > 0: + for _wn in w: + if _wn.category is exceptions.RankWarning: + # Ignore other warnings, they may not be relevant (see gh-25433). + error_message = f"{_wn.category.__name__}: {str(_wn.message)}" + msg = ( + "Polyfit sanity test emitted a warning, most likely due " + "to using a buggy Accelerate backend." + "\nIf you compiled yourself, more information is available at:" + "\nhttps://numpy.org/devdocs/building/index.html" + "\nOtherwise report this to the vendor " + "that provided NumPy.\n\n{}\n".format(error_message)) + raise RuntimeError(msg) + del _wn + del w + del _mac_os_check + + def hugepage_setup(): + """ + We usually use madvise hugepages support, but on some old kernels it + is slow and thus better avoided. Specifically kernel version 4.6 + had a bug fix which probably fixed this: + https://github.com/torvalds/linux/commit/7cf91a98e607c2f935dbcc177d70011e95b8faff + """ + use_hugepage = os.environ.get("NUMPY_MADVISE_HUGEPAGE", None) + if sys.platform == "linux" and use_hugepage is None: + # If there is an issue with parsing the kernel version, + # set use_hugepage to 0. Usage of LooseVersion will handle + # the kernel version parsing better, but avoided since it + # will increase the import time. + # See: #16679 for related discussion. + try: + use_hugepage = 1 + kernel_version = os.uname().release.split(".")[:2] + kernel_version = tuple(int(v) for v in kernel_version) + if kernel_version < (4, 6): + use_hugepage = 0 + except ValueError: + use_hugepage = 0 + elif use_hugepage is None: + # This is not Linux, so it should not matter, just enable anyway + use_hugepage = 1 + else: + use_hugepage = int(use_hugepage) + return use_hugepage + + # Note that this will currently only make a difference on Linux + _core.multiarray._set_madvise_hugepage(hugepage_setup()) + del hugepage_setup + + # Give a warning if NumPy is reloaded or imported on a sub-interpreter + # We do this from python, since the C-module may not be reloaded and + # it is tidier organized. + _core.multiarray._multiarray_umath._reload_guard() + + # TODO: Remove the environment variable entirely now that it is "weak" + _core._set_promotion_state( + os.environ.get("NPY_PROMOTION_STATE", "weak")) + + # Tell PyInstaller where to find hook-numpy.py + def _pyinstaller_hooks_dir(): + from pathlib import Path + return [str(Path(__file__).with_name("_pyinstaller").resolve())] + + +# Remove symbols imported for internal use +del os, sys, warnings diff --git a/venv/lib/python3.12/site-packages/numpy/__init__.pyi b/venv/lib/python3.12/site-packages/numpy/__init__.pyi new file mode 100644 index 00000000..e73d6f16 --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/__init__.pyi @@ -0,0 +1,4095 @@ +import builtins +import sys +import os +import mmap +import ctypes as ct +import array as _array +import datetime as dt +import enum +from abc import abstractmethod +from types import TracebackType, MappingProxyType, GenericAlias +from contextlib import contextmanager + +import numpy as np +from numpy._pytesttester import PytestTester +from numpy._core._internal import _ctypes + +from numpy._typing import ( + # Arrays + ArrayLike, + NDArray, + _ArrayLike, + _SupportsArray, + _NestedSequence, + _FiniteNestedSequence, + _SupportsArray, + _ArrayLikeBool_co, + _ArrayLikeUInt_co, + _ArrayLikeInt_co, + _ArrayLikeFloat_co, + _ArrayLikeComplex_co, + _ArrayLikeNumber_co, + _ArrayLikeTD64_co, + _ArrayLikeDT64_co, + _ArrayLikeObject_co, + _ArrayLikeStr_co, + _ArrayLikeBytes_co, + _ArrayLikeUnknown, + _UnknownType, + + # DTypes + DTypeLike, + _DTypeLike, + _DTypeLikeVoid, + _SupportsDType, + _VoidDTypeLike, + + # Shapes + _Shape, + _ShapeLike, + + # Scalars + _CharLike_co, + _IntLike_co, + _FloatLike_co, + _TD64Like_co, + _NumberLike_co, + _ScalarLike_co, + + # `number` precision + NBitBase, + # NOTE: Do not remove the extended precision bit-types even if seemingly unused; + # they're used by the mypy plugin + _256Bit, + _128Bit, + _96Bit, + _80Bit, + _64Bit, + _32Bit, + _16Bit, + _8Bit, + _NBitByte, + _NBitShort, + _NBitIntC, + _NBitIntP, + _NBitInt, + _NBitLong, + _NBitLongLong, + _NBitHalf, + _NBitSingle, + _NBitDouble, + _NBitLongDouble, + + # Character codes + _BoolCodes, + _UInt8Codes, + _UInt16Codes, + _UInt32Codes, + _UInt64Codes, + _Int8Codes, + _Int16Codes, + _Int32Codes, + _Int64Codes, + _Float16Codes, + _Float32Codes, + _Float64Codes, + _Complex64Codes, + _Complex128Codes, + _ByteCodes, + _ShortCodes, + _IntCCodes, + _IntPCodes, + _LongCodes, + _LongLongCodes, + _UByteCodes, + _UShortCodes, + _UIntCCodes, + _UIntPCodes, + _ULongCodes, + _ULongLongCodes, + _HalfCodes, + _SingleCodes, + _DoubleCodes, + _LongDoubleCodes, + _CSingleCodes, + _CDoubleCodes, + _CLongDoubleCodes, + _DT64Codes, + _TD64Codes, + _StrCodes, + _BytesCodes, + _VoidCodes, + _ObjectCodes, + + # Ufuncs + _UFunc_Nin1_Nout1, + _UFunc_Nin2_Nout1, + _UFunc_Nin1_Nout2, + _UFunc_Nin2_Nout2, + _GUFunc_Nin2_Nout1, +) + +from numpy._typing._callable import ( + _BoolOp, + _BoolBitOp, + _BoolSub, + _BoolTrueDiv, + _BoolMod, + _BoolDivMod, + _TD64Div, + _IntTrueDiv, + _UnsignedIntOp, + _UnsignedIntBitOp, + _UnsignedIntMod, + _UnsignedIntDivMod, + _SignedIntOp, + _SignedIntBitOp, + _SignedIntMod, + _SignedIntDivMod, + _FloatOp, + _FloatMod, + _FloatDivMod, + _ComplexOp, + _NumberOp, + _ComparisonOpLT, + _ComparisonOpLE, + _ComparisonOpGT, + _ComparisonOpGE, +) + +# NOTE: Numpy's mypy plugin is used for removing the types unavailable +# to the specific platform +from numpy._typing._extended_precision import ( + uint128 as uint128, + uint256 as uint256, + int128 as int128, + int256 as int256, + float80 as float80, + float96 as float96, + float128 as float128, + float256 as float256, + complex160 as complex160, + complex192 as complex192, + complex256 as complex256, + complex512 as complex512, +) + +from numpy._array_api_info import __array_namespace_info__ as __array_namespace_info__ + +from collections.abc import ( + Callable, + Iterable, + Iterator, + Mapping, + Sequence, +) +from typing import ( + TYPE_CHECKING, + Literal as L, + Any, + Generator, + Generic, + NoReturn, + overload, + SupportsComplex, + SupportsFloat, + SupportsInt, + TypeVar, + Protocol, + SupportsIndex, + Final, + final, + ClassVar, + TypeAlias, +) + +if sys.version_info >= (3, 11): + from typing import LiteralString +elif TYPE_CHECKING: + from typing_extensions import LiteralString +else: + LiteralString: TypeAlias = str + +# Ensures that the stubs are picked up +from numpy import ( + ctypeslib as ctypeslib, + exceptions as exceptions, + fft as fft, + lib as lib, + linalg as linalg, + ma as ma, + polynomial as polynomial, + random as random, + testing as testing, + version as version, + exceptions as exceptions, + dtypes as dtypes, + rec as rec, + char as char, + strings as strings, +) + +from numpy._core.records import ( + record as record, + recarray as recarray, +) + +from numpy._core.defchararray import ( + chararray as chararray, +) + +from numpy._core.function_base import ( + linspace as linspace, + logspace as logspace, + geomspace as geomspace, +) + +from numpy._core.fromnumeric import ( + take as take, + reshape as reshape, + choose as choose, + repeat as repeat, + put as put, + swapaxes as swapaxes, + transpose as transpose, + matrix_transpose as matrix_transpose, + partition as partition, + argpartition as argpartition, + sort as sort, + argsort as argsort, + argmax as argmax, + argmin as argmin, + searchsorted as searchsorted, + resize as resize, + squeeze as squeeze, + diagonal as diagonal, + trace as trace, + ravel as ravel, + nonzero as nonzero, + shape as shape, + compress as compress, + clip as clip, + sum as sum, + all as all, + any as any, + cumsum as cumsum, + cumulative_sum as cumulative_sum, + ptp as ptp, + max as max, + min as min, + amax as amax, + amin as amin, + prod as prod, + cumprod as cumprod, + cumulative_prod as cumulative_prod, + ndim as ndim, + size as size, + around as around, + round as round, + mean as mean, + std as std, + var as var, +) + +from numpy._core._asarray import ( + require as require, +) + +from numpy._core._type_aliases import ( + sctypeDict as sctypeDict, +) + +from numpy._core._ufunc_config import ( + seterr as seterr, + geterr as geterr, + setbufsize as setbufsize, + getbufsize as getbufsize, + seterrcall as seterrcall, + geterrcall as geterrcall, + _ErrKind, + _ErrFunc, +) + +from numpy._core.arrayprint import ( + set_printoptions as set_printoptions, + get_printoptions as get_printoptions, + array2string as array2string, + format_float_scientific as format_float_scientific, + format_float_positional as format_float_positional, + array_repr as array_repr, + array_str as array_str, + printoptions as printoptions, +) + +from numpy._core.einsumfunc import ( + einsum as einsum, + einsum_path as einsum_path, +) + +from numpy._core.multiarray import ( + array as array, + empty_like as empty_like, + empty as empty, + zeros as zeros, + concatenate as concatenate, + inner as inner, + where as where, + lexsort as lexsort, + can_cast as can_cast, + min_scalar_type as min_scalar_type, + result_type as result_type, + dot as dot, + vdot as vdot, + bincount as bincount, + copyto as copyto, + putmask as putmask, + packbits as packbits, + unpackbits as unpackbits, + shares_memory as shares_memory, + may_share_memory as may_share_memory, + asarray as asarray, + asanyarray as asanyarray, + ascontiguousarray as ascontiguousarray, + asfortranarray as asfortranarray, + arange as arange, + busday_count as busday_count, + busday_offset as busday_offset, + datetime_as_string as datetime_as_string, + datetime_data as datetime_data, + frombuffer as frombuffer, + fromfile as fromfile, + fromiter as fromiter, + is_busday as is_busday, + promote_types as promote_types, + fromstring as fromstring, + frompyfunc as frompyfunc, + nested_iters as nested_iters, + flagsobj, +) + +from numpy._core.numeric import ( + zeros_like as zeros_like, + ones as ones, + ones_like as ones_like, + full as full, + full_like as full_like, + count_nonzero as count_nonzero, + isfortran as isfortran, + argwhere as argwhere, + flatnonzero as flatnonzero, + correlate as correlate, + convolve as convolve, + outer as outer, + tensordot as tensordot, + roll as roll, + rollaxis as rollaxis, + moveaxis as moveaxis, + cross as cross, + indices as indices, + fromfunction as fromfunction, + isscalar as isscalar, + binary_repr as binary_repr, + base_repr as base_repr, + identity as identity, + allclose as allclose, + isclose as isclose, + array_equal as array_equal, + array_equiv as array_equiv, + astype as astype, +) + +from numpy._core.numerictypes import ( + isdtype as isdtype, + issubdtype as issubdtype, + ScalarType as ScalarType, + typecodes as typecodes, +) + +from numpy._core.shape_base import ( + atleast_1d as atleast_1d, + atleast_2d as atleast_2d, + atleast_3d as atleast_3d, + block as block, + hstack as hstack, + stack as stack, + vstack as vstack, + unstack as unstack, +) + +from numpy.lib import ( + scimath as emath, +) + +from numpy.lib._arraypad_impl import ( + pad as pad, +) + +from numpy.lib._arraysetops_impl import ( + ediff1d as ediff1d, + intersect1d as intersect1d, + isin as isin, + setdiff1d as setdiff1d, + setxor1d as setxor1d, + union1d as union1d, + unique as unique, + unique_all as unique_all, + unique_counts as unique_counts, + unique_inverse as unique_inverse, + unique_values as unique_values, +) + +from numpy.lib._function_base_impl import ( + select as select, + piecewise as piecewise, + trim_zeros as trim_zeros, + copy as copy, + iterable as iterable, + percentile as percentile, + diff as diff, + gradient as gradient, + angle as angle, + unwrap as unwrap, + sort_complex as sort_complex, + flip as flip, + rot90 as rot90, + extract as extract, + place as place, + asarray_chkfinite as asarray_chkfinite, + average as average, + bincount as bincount, + digitize as digitize, + cov as cov, + corrcoef as corrcoef, + median as median, + sinc as sinc, + hamming as hamming, + hanning as hanning, + bartlett as bartlett, + blackman as blackman, + kaiser as kaiser, + i0 as i0, + meshgrid as meshgrid, + delete as delete, + insert as insert, + append as append, + interp as interp, + quantile as quantile, + trapezoid as trapezoid, +) + +from numpy.lib._histograms_impl import ( + histogram_bin_edges as histogram_bin_edges, + histogram as histogram, + histogramdd as histogramdd, +) + +from numpy.lib._index_tricks_impl import ( + ravel_multi_index as ravel_multi_index, + unravel_index as unravel_index, + mgrid as mgrid, + ogrid as ogrid, + r_ as r_, + c_ as c_, + s_ as s_, + index_exp as index_exp, + ix_ as ix_, + fill_diagonal as fill_diagonal, + diag_indices as diag_indices, + diag_indices_from as diag_indices_from, +) + +from numpy.lib._nanfunctions_impl import ( + nansum as nansum, + nanmax as nanmax, + nanmin as nanmin, + nanargmax as nanargmax, + nanargmin as nanargmin, + nanmean as nanmean, + nanmedian as nanmedian, + nanpercentile as nanpercentile, + nanvar as nanvar, + nanstd as nanstd, + nanprod as nanprod, + nancumsum as nancumsum, + nancumprod as nancumprod, + nanquantile as nanquantile, +) + +from numpy.lib._npyio_impl import ( + savetxt as savetxt, + loadtxt as loadtxt, + genfromtxt as genfromtxt, + load as load, + save as save, + savez as savez, + savez_compressed as savez_compressed, + packbits as packbits, + unpackbits as unpackbits, + fromregex as fromregex, +) + +from numpy.lib._polynomial_impl import ( + poly as poly, + roots as roots, + polyint as polyint, + polyder as polyder, + polyadd as polyadd, + polysub as polysub, + polymul as polymul, + polydiv as polydiv, + polyval as polyval, + polyfit as polyfit, +) + +from numpy.lib._shape_base_impl import ( + column_stack as column_stack, + dstack as dstack, + array_split as array_split, + split as split, + hsplit as hsplit, + vsplit as vsplit, + dsplit as dsplit, + apply_over_axes as apply_over_axes, + expand_dims as expand_dims, + apply_along_axis as apply_along_axis, + kron as kron, + tile as tile, + take_along_axis as take_along_axis, + put_along_axis as put_along_axis, +) + +from numpy.lib._stride_tricks_impl import ( + broadcast_to as broadcast_to, + broadcast_arrays as broadcast_arrays, + broadcast_shapes as broadcast_shapes, +) + +from numpy.lib._twodim_base_impl import ( + diag as diag, + diagflat as diagflat, + eye as eye, + fliplr as fliplr, + flipud as flipud, + tri as tri, + triu as triu, + tril as tril, + vander as vander, + histogram2d as histogram2d, + mask_indices as mask_indices, + tril_indices as tril_indices, + tril_indices_from as tril_indices_from, + triu_indices as triu_indices, + triu_indices_from as triu_indices_from, +) + +from numpy.lib._type_check_impl import ( + mintypecode as mintypecode, + real as real, + imag as imag, + iscomplex as iscomplex, + isreal as isreal, + iscomplexobj as iscomplexobj, + isrealobj as isrealobj, + nan_to_num as nan_to_num, + real_if_close as real_if_close, + typename as typename, + common_type as common_type, +) + +from numpy.lib._ufunclike_impl import ( + fix as fix, + isposinf as isposinf, + isneginf as isneginf, +) + +from numpy.lib._utils_impl import ( + get_include as get_include, + info as info, + show_runtime as show_runtime, +) + +from numpy.matrixlib import ( + asmatrix as asmatrix, + bmat as bmat, +) + +_AnyStr_contra = TypeVar("_AnyStr_contra", LiteralString, builtins.str, bytes, contravariant=True) + +# Protocol for representing file-like-objects accepted +# by `ndarray.tofile` and `fromfile` +class _IOProtocol(Protocol): + def flush(self) -> object: ... + def fileno(self) -> int: ... + def tell(self) -> SupportsIndex: ... + def seek(self, offset: int, whence: int, /) -> object: ... + +# NOTE: `seek`, `write` and `flush` are technically only required +# for `readwrite`/`write` modes +class _MemMapIOProtocol(Protocol): + def flush(self) -> object: ... + def fileno(self) -> SupportsIndex: ... + def tell(self) -> int: ... + def seek(self, offset: int, whence: int, /) -> object: ... + def write(self, s: bytes, /) -> object: ... + @property + def read(self) -> object: ... + +class _SupportsWrite(Protocol[_AnyStr_contra]): + def write(self, s: _AnyStr_contra, /) -> object: ... + +__all__: list[str] +def __dir__() -> Sequence[str]: ... + +__version__: LiteralString +__array_api_version__: LiteralString +test: PytestTester + +# TODO: Move placeholders to their respective module once +# their annotations are properly implemented +# +# Placeholders for classes + +def show_config() -> None: ... + +_NdArraySubClass = TypeVar("_NdArraySubClass", bound=NDArray[Any]) +_NdArraySubClass_co = TypeVar("_NdArraySubClass_co", bound=NDArray[Any], covariant=True) +_DTypeScalar_co = TypeVar("_DTypeScalar_co", covariant=True, bound=generic) +_SCT = TypeVar("_SCT", bound=generic) + +_ByteOrderChar: TypeAlias = L[ + "<", # little-endian + ">", # big-endian + "=", # native order + "|", # ignore +] +# can be anything, is case-insensitive, and only the first character matters +_ByteOrder: TypeAlias = L[ + "S", # swap the current order (default) + "<", "L", "little", # little-endian + ">", "B", "big", # big endian + "=", "N", "native", # native order + "|", "I", # ignore +] +_DTypeKind: TypeAlias = L[ + "b", # boolean + "i", # signed integer + "u", # unsigned integer + "f", # floating-point + "c", # complex floating-point + "m", # timedelta64 + "M", # datetime64 + "O", # python object + "S", # byte-string (fixed-width) + "U", # unicode-string (fixed-width) + "V", # void + "T", # unicode-string (variable-width) +] +_DTypeChar: TypeAlias = L[ + "?", # bool + "b", # byte + "B", # ubyte + "h", # short + "H", # ushort + "i", # intc + "I", # uintc + "l", # long + "L", # ulong + "q", # longlong + "Q", # ulonglong + "e", # half + "f", # single + "d", # double + "g", # longdouble + "F", # csingle + "D", # cdouble + "G", # clongdouble + "O", # object + "S", # bytes_ (S0) + "a", # bytes_ (deprecated) + "U", # str_ + "V", # void + "M", # datetime64 + "m", # timedelta64 + "c", # bytes_ (S1) + "T", # StringDType +] +_DTypeNum: TypeAlias = L[ + 0, # bool + 1, # byte + 2, # ubyte + 3, # short + 4, # ushort + 5, # intc + 6, # uintc + 7, # long + 8, # ulong + 9, # longlong + 10, # ulonglong + 23, # half + 11, # single + 12, # double + 13, # longdouble + 14, # csingle + 15, # cdouble + 16, # clongdouble + 17, # object + 18, # bytes_ + 19, # str_ + 20, # void + 21, # datetime64 + 22, # timedelta64 + 25, # no type + 256, # user-defined + 2056, # StringDType +] +_DTypeBuiltinKind: TypeAlias = L[ + 0, # structured array type, with fields + 1, # compiled into numpy + 2, # user-defined +] + +@final +class dtype(Generic[_DTypeScalar_co]): + names: None | tuple[builtins.str, ...] + def __hash__(self) -> int: ... + # Overload for subclass of generic + @overload + def __new__( + cls, + dtype: type[_DTypeScalar_co], + align: builtins.bool = ..., + copy: builtins.bool = ..., + metadata: dict[builtins.str, Any] = ..., + ) -> dtype[_DTypeScalar_co]: ... + # Overloads for string aliases, Python types, and some assorted + # other special cases. Order is sometimes important because of the + # subtype relationships + # + # builtins.bool < int < float < complex < object + # + # so we have to make sure the overloads for the narrowest type is + # first. + # Builtin types + @overload + def __new__(cls, dtype: type[builtins.bool], align: builtins.bool = ..., copy: builtins.bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[np.bool]: ... + @overload + def __new__(cls, dtype: type[int], align: builtins.bool = ..., copy: builtins.bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[int_]: ... + @overload + def __new__(cls, dtype: None | type[float], align: builtins.bool = ..., copy: builtins.bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[float64]: ... + @overload + def __new__(cls, dtype: type[complex], align: builtins.bool = ..., copy: builtins.bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[complex128]: ... + @overload + def __new__(cls, dtype: type[builtins.str], align: builtins.bool = ..., copy: builtins.bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[str_]: ... + @overload + def __new__(cls, dtype: type[bytes], align: builtins.bool = ..., copy: builtins.bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[bytes_]: ... + + # `unsignedinteger` string-based representations and ctypes + @overload + def __new__(cls, dtype: _UInt8Codes | type[ct.c_uint8], align: builtins.bool = ..., copy: builtins.bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[uint8]: ... + @overload + def __new__(cls, dtype: _UInt16Codes | type[ct.c_uint16], align: builtins.bool = ..., copy: builtins.bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[uint16]: ... + @overload + def __new__(cls, dtype: _UInt32Codes | type[ct.c_uint32], align: builtins.bool = ..., copy: builtins.bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[uint32]: ... + @overload + def __new__(cls, dtype: _UInt64Codes | type[ct.c_uint64], align: builtins.bool = ..., copy: builtins.bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[uint64]: ... + @overload + def __new__(cls, dtype: _UByteCodes | type[ct.c_ubyte], align: builtins.bool = ..., copy: builtins.bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[ubyte]: ... + @overload + def __new__(cls, dtype: _UShortCodes | type[ct.c_ushort], align: builtins.bool = ..., copy: builtins.bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[ushort]: ... + @overload + def __new__(cls, dtype: _UIntCCodes | type[ct.c_uint], align: builtins.bool = ..., copy: builtins.bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[uintc]: ... + + # NOTE: We're assuming here that `uint_ptr_t == size_t`, + # an assumption that does not hold in rare cases (same for `ssize_t`) + @overload + def __new__(cls, dtype: _UIntPCodes | type[ct.c_void_p] | type[ct.c_size_t], align: builtins.bool = ..., copy: builtins.bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[uintp]: ... + @overload + def __new__(cls, dtype: _ULongCodes | type[ct.c_ulong], align: builtins.bool = ..., copy: builtins.bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[ulong]: ... + @overload + def __new__(cls, dtype: _ULongLongCodes | type[ct.c_ulonglong], align: builtins.bool = ..., copy: builtins.bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[ulonglong]: ... + + # `signedinteger` string-based representations and ctypes + @overload + def __new__(cls, dtype: _Int8Codes | type[ct.c_int8], align: builtins.bool = ..., copy: builtins.bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[int8]: ... + @overload + def __new__(cls, dtype: _Int16Codes | type[ct.c_int16], align: builtins.bool = ..., copy: builtins.bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[int16]: ... + @overload + def __new__(cls, dtype: _Int32Codes | type[ct.c_int32], align: builtins.bool = ..., copy: builtins.bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[int32]: ... + @overload + def __new__(cls, dtype: _Int64Codes | type[ct.c_int64], align: builtins.bool = ..., copy: builtins.bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[int64]: ... + @overload + def __new__(cls, dtype: _ByteCodes | type[ct.c_byte], align: builtins.bool = ..., copy: builtins.bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[byte]: ... + @overload + def __new__(cls, dtype: _ShortCodes | type[ct.c_short], align: builtins.bool = ..., copy: builtins.bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[short]: ... + @overload + def __new__(cls, dtype: _IntCCodes | type[ct.c_int], align: builtins.bool = ..., copy: builtins.bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[intc]: ... + @overload + def __new__(cls, dtype: _IntPCodes | type[ct.c_ssize_t], align: builtins.bool = ..., copy: builtins.bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[intp]: ... + @overload + def __new__(cls, dtype: _LongCodes | type[ct.c_long], align: builtins.bool = ..., copy: builtins.bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[long]: ... + @overload + def __new__(cls, dtype: _LongLongCodes | type[ct.c_longlong], align: builtins.bool = ..., copy: builtins.bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[longlong]: ... + + # `floating` string-based representations and ctypes + @overload + def __new__(cls, dtype: _Float16Codes, align: builtins.bool = ..., copy: builtins.bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[float16]: ... + @overload + def __new__(cls, dtype: _Float32Codes, align: builtins.bool = ..., copy: builtins.bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[float32]: ... + @overload + def __new__(cls, dtype: _Float64Codes, align: builtins.bool = ..., copy: builtins.bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[float64]: ... + @overload + def __new__(cls, dtype: _HalfCodes, align: builtins.bool = ..., copy: builtins.bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[half]: ... + @overload + def __new__(cls, dtype: _SingleCodes | type[ct.c_float], align: builtins.bool = ..., copy: builtins.bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[single]: ... + @overload + def __new__(cls, dtype: _DoubleCodes | type[ct.c_double], align: builtins.bool = ..., copy: builtins.bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[double]: ... + @overload + def __new__(cls, dtype: _LongDoubleCodes | type[ct.c_longdouble], align: builtins.bool = ..., copy: builtins.bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[longdouble]: ... + + # `complexfloating` string-based representations + @overload + def __new__(cls, dtype: _Complex64Codes, align: builtins.bool = ..., copy: builtins.bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[complex64]: ... + @overload + def __new__(cls, dtype: _Complex128Codes, align: builtins.bool = ..., copy: builtins.bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[complex128]: ... + @overload + def __new__(cls, dtype: _CSingleCodes, align: builtins.bool = ..., copy: builtins.bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[csingle]: ... + @overload + def __new__(cls, dtype: _CDoubleCodes, align: builtins.bool = ..., copy: builtins.bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[cdouble]: ... + @overload + def __new__(cls, dtype: _CLongDoubleCodes, align: builtins.bool = ..., copy: builtins.bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[clongdouble]: ... + + # Miscellaneous string-based representations and ctypes + @overload + def __new__(cls, dtype: _BoolCodes | type[ct.c_bool], align: builtins.bool = ..., copy: builtins.bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[np.bool]: ... + @overload + def __new__(cls, dtype: _TD64Codes, align: builtins.bool = ..., copy: builtins.bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[timedelta64]: ... + @overload + def __new__(cls, dtype: _DT64Codes, align: builtins.bool = ..., copy: builtins.bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[datetime64]: ... + @overload + def __new__(cls, dtype: _StrCodes, align: builtins.bool = ..., copy: builtins.bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[str_]: ... + @overload + def __new__(cls, dtype: _BytesCodes | type[ct.c_char], align: builtins.bool = ..., copy: builtins.bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[bytes_]: ... + @overload + def __new__(cls, dtype: _VoidCodes, align: builtins.bool = ..., copy: builtins.bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[void]: ... + @overload + def __new__(cls, dtype: _ObjectCodes | type[ct.py_object[Any]], align: builtins.bool = ..., copy: builtins.bool = ..., metadata: dict[builtins.str, Any] = ...) -> dtype[object_]: ... + + # dtype of a dtype is the same dtype + @overload + def __new__( + cls, + dtype: dtype[_DTypeScalar_co], + align: builtins.bool = ..., + copy: builtins.bool = ..., + metadata: dict[builtins.str, Any] = ..., + ) -> dtype[_DTypeScalar_co]: ... + @overload + def __new__( + cls, + dtype: _SupportsDType[dtype[_DTypeScalar_co]], + align: builtins.bool = ..., + copy: builtins.bool = ..., + metadata: dict[builtins.str, Any] = ..., + ) -> dtype[_DTypeScalar_co]: ... + # Handle strings that can't be expressed as literals; i.e. s1, s2, ... + @overload + def __new__( + cls, + dtype: builtins.str, + align: builtins.bool = ..., + copy: builtins.bool = ..., + metadata: dict[builtins.str, Any] = ..., + ) -> dtype[Any]: ... + # Catchall overload for void-likes + @overload + def __new__( + cls, + dtype: _VoidDTypeLike, + align: builtins.bool = ..., + copy: builtins.bool = ..., + metadata: dict[builtins.str, Any] = ..., + ) -> dtype[void]: ... + # Catchall overload for object-likes + @overload + def __new__( + cls, + dtype: type[object], + align: builtins.bool = ..., + copy: builtins.bool = ..., + metadata: dict[builtins.str, Any] = ..., + ) -> dtype[object_]: ... + + def __class_getitem__(cls, item: Any, /) -> GenericAlias: ... + + @overload + def __getitem__(self: dtype[void], key: list[builtins.str], /) -> dtype[void]: ... + @overload + def __getitem__(self: dtype[void], key: builtins.str | SupportsIndex, /) -> dtype[Any]: ... + + # NOTE: In the future 1-based multiplications will also yield `flexible` dtypes + @overload + def __mul__(self: _DType, value: L[1], /) -> _DType: ... + @overload + def __mul__(self: _FlexDType, value: SupportsIndex, /) -> _FlexDType: ... + @overload + def __mul__(self, value: SupportsIndex, /) -> dtype[void]: ... + + # NOTE: `__rmul__` seems to be broken when used in combination with + # literals as of mypy 0.902. Set the return-type to `dtype[Any]` for + # now for non-flexible dtypes. + @overload + def __rmul__(self: _FlexDType, value: SupportsIndex, /) -> _FlexDType: ... + @overload + def __rmul__(self, value: SupportsIndex, /) -> dtype[Any]: ... + + def __gt__(self, other: DTypeLike, /) -> builtins.bool: ... + def __ge__(self, other: DTypeLike, /) -> builtins.bool: ... + def __lt__(self, other: DTypeLike, /) -> builtins.bool: ... + def __le__(self, other: DTypeLike, /) -> builtins.bool: ... + + # Explicitly defined `__eq__` and `__ne__` to get around mypy's + # `strict_equality` option; even though their signatures are + # identical to their `object`-based counterpart + def __eq__(self, other: Any, /) -> builtins.bool: ... + def __ne__(self, other: Any, /) -> builtins.bool: ... + + @property + def alignment(self) -> int: ... + @property + def base(self) -> dtype[Any]: ... + @property + def byteorder(self) -> _ByteOrderChar: ... + @property + def char(self) -> _DTypeChar: ... + @property + def descr(self) -> list[tuple[LiteralString, LiteralString] | tuple[LiteralString, LiteralString, _Shape]]: ... + @property + def fields(self,) -> None | MappingProxyType[LiteralString, tuple[dtype[Any], int] | tuple[dtype[Any], int, Any]]: ... + @property + def flags(self) -> int: ... + @property + def hasobject(self) -> builtins.bool: ... + @property + def isbuiltin(self) -> _DTypeBuiltinKind: ... + @property + def isnative(self) -> builtins.bool: ... + @property + def isalignedstruct(self) -> builtins.bool: ... + @property + def itemsize(self) -> int: ... + @property + def kind(self) -> _DTypeKind: ... + @property + def metadata(self) -> None | MappingProxyType[builtins.str, Any]: ... + @property + def name(self) -> LiteralString: ... + @property + def num(self) -> _DTypeNum: ... + @property + def shape(self) -> tuple[()] | _Shape: ... + @property + def ndim(self) -> int: ... + @property + def subdtype(self) -> None | tuple[dtype[Any], _Shape]: ... + def newbyteorder(self: _DType, new_order: _ByteOrder = ..., /) -> _DType: ... + @property + def str(self) -> LiteralString: ... + @property + def type(self) -> type[_DTypeScalar_co]: ... + +_ArrayLikeInt: TypeAlias = ( + int + | integer[Any] + | Sequence[int | integer[Any]] + | Sequence[Sequence[Any]] # TODO: wait for support for recursive types + | NDArray[Any] +) + +_FlatIterSelf = TypeVar("_FlatIterSelf", bound=flatiter[Any]) +_FlatShapeType = TypeVar("_FlatShapeType", bound=tuple[int]) + +@final +class flatiter(Generic[_NdArraySubClass_co]): + __hash__: ClassVar[None] + @property + def base(self) -> _NdArraySubClass_co: ... + @property + def coords(self) -> _Shape: ... + @property + def index(self) -> int: ... + def copy(self) -> _NdArraySubClass_co: ... + def __iter__(self: _FlatIterSelf) -> _FlatIterSelf: ... + def __next__(self: flatiter[NDArray[_ScalarType]]) -> _ScalarType: ... + def __len__(self) -> int: ... + @overload + def __getitem__( + self: flatiter[NDArray[_ScalarType]], + key: int | integer[Any] | tuple[int | integer[Any]], + ) -> _ScalarType: ... + @overload + def __getitem__( + self, + key: _ArrayLikeInt | slice | ellipsis | tuple[_ArrayLikeInt | slice | ellipsis], + ) -> _NdArraySubClass_co: ... + # TODO: `__setitem__` operates via `unsafe` casting rules, and can + # thus accept any type accepted by the relevant underlying `np.generic` + # constructor. + # This means that `value` must in reality be a supertype of `npt.ArrayLike`. + def __setitem__( + self, + key: _ArrayLikeInt | slice | ellipsis | tuple[_ArrayLikeInt | slice | ellipsis], + value: Any, + ) -> None: ... + @overload + def __array__(self: flatiter[ndarray[_FlatShapeType, _DType]], dtype: None = ..., /) -> ndarray[_FlatShapeType, _DType]: ... + @overload + def __array__(self: flatiter[ndarray[_FlatShapeType, Any]], dtype: _DType, /) -> ndarray[_FlatShapeType, _DType]: ... + @overload + def __array__(self: flatiter[ndarray[Any, _DType]], dtype: None = ..., /) -> ndarray[Any, _DType]: ... + @overload + def __array__(self, dtype: _DType, /) -> ndarray[Any, _DType]: ... + +_OrderKACF: TypeAlias = L[None, "K", "A", "C", "F"] +_OrderACF: TypeAlias = L[None, "A", "C", "F"] +_OrderCF: TypeAlias = L[None, "C", "F"] + +_ModeKind: TypeAlias = L["raise", "wrap", "clip"] +_PartitionKind: TypeAlias = L["introselect"] +# in practice, only the first case-insensitive character is considered (so e.g. +# "QuantumSort3000" will be interpreted as quicksort). +_SortKind: TypeAlias = L[ + "Q", "quick", "quicksort", + "M", "merge", "mergesort", + "H", "heap", "heapsort", + "S", "stable", "stablesort", +] +_SortSide: TypeAlias = L["left", "right"] + +_ArraySelf = TypeVar("_ArraySelf", bound=_ArrayOrScalarCommon) + +class _ArrayOrScalarCommon: + @property + def T(self: _ArraySelf) -> _ArraySelf: ... + @property + def mT(self: _ArraySelf) -> _ArraySelf: ... + @property + def data(self) -> memoryview: ... + @property + def flags(self) -> flagsobj: ... + @property + def itemsize(self) -> int: ... + @property + def nbytes(self) -> int: ... + @property + def device(self) -> L["cpu"]: ... + def __bool__(self) -> builtins.bool: ... + def __bytes__(self) -> bytes: ... + def __str__(self) -> str: ... + def __repr__(self) -> str: ... + def __copy__(self: _ArraySelf) -> _ArraySelf: ... + def __deepcopy__(self: _ArraySelf, memo: None | dict[int, Any], /) -> _ArraySelf: ... + + # TODO: How to deal with the non-commutative nature of `==` and `!=`? + # xref numpy/numpy#17368 + def __eq__(self, other: Any, /) -> Any: ... + def __ne__(self, other: Any, /) -> Any: ... + def copy(self: _ArraySelf, order: _OrderKACF = ...) -> _ArraySelf: ... + def dump(self, file: str | bytes | os.PathLike[str] | os.PathLike[bytes] | _SupportsWrite[bytes]) -> None: ... + def dumps(self) -> bytes: ... + def tobytes(self, order: _OrderKACF = ...) -> bytes: ... + # NOTE: `tostring()` is deprecated and therefore excluded + # def tostring(self, order=...): ... + def tofile( + self, + fid: str | bytes | os.PathLike[str] | os.PathLike[bytes] | _IOProtocol, + sep: str = ..., + format: str = ..., + ) -> None: ... + # generics and 0d arrays return builtin scalars + def tolist(self) -> Any: ... + + @property + def __array_interface__(self) -> dict[str, Any]: ... + @property + def __array_priority__(self) -> float: ... + @property + def __array_struct__(self) -> Any: ... # builtins.PyCapsule + def __array_namespace__(self, *, api_version: None | _ArrayAPIVersion = ...) -> Any: ... + def __setstate__(self, state: tuple[ + SupportsIndex, # version + _ShapeLike, # Shape + _DType_co, # DType + np.bool, # F-continuous + bytes | list[Any], # Data + ], /) -> None: ... + # an `np.bool` is returned when `keepdims=True` and `self` is a 0d array + + @overload + def all( + self, + axis: None = ..., + out: None = ..., + keepdims: L[False] = ..., + *, + where: _ArrayLikeBool_co = ..., + ) -> np.bool: ... + @overload + def all( + self, + axis: None | _ShapeLike = ..., + out: None = ..., + keepdims: builtins.bool = ..., + *, + where: _ArrayLikeBool_co = ..., + ) -> Any: ... + @overload + def all( + self, + axis: None | _ShapeLike = ..., + out: _NdArraySubClass = ..., + keepdims: builtins.bool = ..., + *, + where: _ArrayLikeBool_co = ..., + ) -> _NdArraySubClass: ... + + @overload + def any( + self, + axis: None = ..., + out: None = ..., + keepdims: L[False] = ..., + *, + where: _ArrayLikeBool_co = ..., + ) -> np.bool: ... + @overload + def any( + self, + axis: None | _ShapeLike = ..., + out: None = ..., + keepdims: builtins.bool = ..., + *, + where: _ArrayLikeBool_co = ..., + ) -> Any: ... + @overload + def any( + self, + axis: None | _ShapeLike = ..., + out: _NdArraySubClass = ..., + keepdims: builtins.bool = ..., + *, + where: _ArrayLikeBool_co = ..., + ) -> _NdArraySubClass: ... + + @overload + def argmax( + self, + axis: None = ..., + out: None = ..., + *, + keepdims: L[False] = ..., + ) -> intp: ... + @overload + def argmax( + self, + axis: SupportsIndex = ..., + out: None = ..., + *, + keepdims: builtins.bool = ..., + ) -> Any: ... + @overload + def argmax( + self, + axis: None | SupportsIndex = ..., + out: _NdArraySubClass = ..., + *, + keepdims: builtins.bool = ..., + ) -> _NdArraySubClass: ... + + @overload + def argmin( + self, + axis: None = ..., + out: None = ..., + *, + keepdims: L[False] = ..., + ) -> intp: ... + @overload + def argmin( + self, + axis: SupportsIndex = ..., + out: None = ..., + *, + keepdims: builtins.bool = ..., + ) -> Any: ... + @overload + def argmin( + self, + axis: None | SupportsIndex = ..., + out: _NdArraySubClass = ..., + *, + keepdims: builtins.bool = ..., + ) -> _NdArraySubClass: ... + + def argsort( + self, + axis: None | SupportsIndex = ..., + kind: None | _SortKind = ..., + order: None | str | Sequence[str] = ..., + *, + stable: None | bool = ..., + ) -> NDArray[Any]: ... + + @overload + def choose( + self, + choices: ArrayLike, + out: None = ..., + mode: _ModeKind = ..., + ) -> NDArray[Any]: ... + @overload + def choose( + self, + choices: ArrayLike, + out: _NdArraySubClass = ..., + mode: _ModeKind = ..., + ) -> _NdArraySubClass: ... + + @overload + def clip( + self, + min: ArrayLike = ..., + max: None | ArrayLike = ..., + out: None = ..., + **kwargs: Any, + ) -> NDArray[Any]: ... + @overload + def clip( + self, + min: None = ..., + max: ArrayLike = ..., + out: None = ..., + **kwargs: Any, + ) -> NDArray[Any]: ... + @overload + def clip( + self, + min: ArrayLike = ..., + max: None | ArrayLike = ..., + out: _NdArraySubClass = ..., + **kwargs: Any, + ) -> _NdArraySubClass: ... + @overload + def clip( + self, + min: None = ..., + max: ArrayLike = ..., + out: _NdArraySubClass = ..., + **kwargs: Any, + ) -> _NdArraySubClass: ... + + @overload + def compress( + self, + a: ArrayLike, + axis: None | SupportsIndex = ..., + out: None = ..., + ) -> NDArray[Any]: ... + @overload + def compress( + self, + a: ArrayLike, + axis: None | SupportsIndex = ..., + out: _NdArraySubClass = ..., + ) -> _NdArraySubClass: ... + + def conj(self: _ArraySelf) -> _ArraySelf: ... + + def conjugate(self: _ArraySelf) -> _ArraySelf: ... + + @overload + def cumprod( + self, + axis: None | SupportsIndex = ..., + dtype: DTypeLike = ..., + out: None = ..., + ) -> NDArray[Any]: ... + @overload + def cumprod( + self, + axis: None | SupportsIndex = ..., + dtype: DTypeLike = ..., + out: _NdArraySubClass = ..., + ) -> _NdArraySubClass: ... + + @overload + def cumsum( + self, + axis: None | SupportsIndex = ..., + dtype: DTypeLike = ..., + out: None = ..., + ) -> NDArray[Any]: ... + @overload + def cumsum( + self, + axis: None | SupportsIndex = ..., + dtype: DTypeLike = ..., + out: _NdArraySubClass = ..., + ) -> _NdArraySubClass: ... + + @overload + def max( + self, + axis: None | _ShapeLike = ..., + out: None = ..., + keepdims: builtins.bool = ..., + initial: _NumberLike_co = ..., + where: _ArrayLikeBool_co = ..., + ) -> Any: ... + @overload + def max( + self, + axis: None | _ShapeLike = ..., + out: _NdArraySubClass = ..., + keepdims: builtins.bool = ..., + initial: _NumberLike_co = ..., + where: _ArrayLikeBool_co = ..., + ) -> _NdArraySubClass: ... + + @overload + def mean( + self, + axis: None | _ShapeLike = ..., + dtype: DTypeLike = ..., + out: None = ..., + keepdims: builtins.bool = ..., + *, + where: _ArrayLikeBool_co = ..., + ) -> Any: ... + @overload + def mean( + self, + axis: None | _ShapeLike = ..., + dtype: DTypeLike = ..., + out: _NdArraySubClass = ..., + keepdims: builtins.bool = ..., + *, + where: _ArrayLikeBool_co = ..., + ) -> _NdArraySubClass: ... + + @overload + def min( + self, + axis: None | _ShapeLike = ..., + out: None = ..., + keepdims: builtins.bool = ..., + initial: _NumberLike_co = ..., + where: _ArrayLikeBool_co = ..., + ) -> Any: ... + @overload + def min( + self, + axis: None | _ShapeLike = ..., + out: _NdArraySubClass = ..., + keepdims: builtins.bool = ..., + initial: _NumberLike_co = ..., + where: _ArrayLikeBool_co = ..., + ) -> _NdArraySubClass: ... + + @overload + def prod( + self, + axis: None | _ShapeLike = ..., + dtype: DTypeLike = ..., + out: None = ..., + keepdims: builtins.bool = ..., + initial: _NumberLike_co = ..., + where: _ArrayLikeBool_co = ..., + ) -> Any: ... + @overload + def prod( + self, + axis: None | _ShapeLike = ..., + dtype: DTypeLike = ..., + out: _NdArraySubClass = ..., + keepdims: builtins.bool = ..., + initial: _NumberLike_co = ..., + where: _ArrayLikeBool_co = ..., + ) -> _NdArraySubClass: ... + + @overload + def round( + self: _ArraySelf, + decimals: SupportsIndex = ..., + out: None = ..., + ) -> _ArraySelf: ... + @overload + def round( + self, + decimals: SupportsIndex = ..., + out: _NdArraySubClass = ..., + ) -> _NdArraySubClass: ... + + @overload + def std( + self, + axis: None | _ShapeLike = ..., + dtype: DTypeLike = ..., + out: None = ..., + ddof: float = ..., + keepdims: builtins.bool = ..., + *, + where: _ArrayLikeBool_co = ..., + ) -> Any: ... + @overload + def std( + self, + axis: None | _ShapeLike = ..., + dtype: DTypeLike = ..., + out: _NdArraySubClass = ..., + ddof: float = ..., + keepdims: builtins.bool = ..., + *, + where: _ArrayLikeBool_co = ..., + ) -> _NdArraySubClass: ... + + @overload + def sum( + self, + axis: None | _ShapeLike = ..., + dtype: DTypeLike = ..., + out: None = ..., + keepdims: builtins.bool = ..., + initial: _NumberLike_co = ..., + where: _ArrayLikeBool_co = ..., + ) -> Any: ... + @overload + def sum( + self, + axis: None | _ShapeLike = ..., + dtype: DTypeLike = ..., + out: _NdArraySubClass = ..., + keepdims: builtins.bool = ..., + initial: _NumberLike_co = ..., + where: _ArrayLikeBool_co = ..., + ) -> _NdArraySubClass: ... + + @overload + def var( + self, + axis: None | _ShapeLike = ..., + dtype: DTypeLike = ..., + out: None = ..., + ddof: float = ..., + keepdims: builtins.bool = ..., + *, + where: _ArrayLikeBool_co = ..., + ) -> Any: ... + @overload + def var( + self, + axis: None | _ShapeLike = ..., + dtype: DTypeLike = ..., + out: _NdArraySubClass = ..., + ddof: float = ..., + keepdims: builtins.bool = ..., + *, + where: _ArrayLikeBool_co = ..., + ) -> _NdArraySubClass: ... + +_DType = TypeVar("_DType", bound=dtype[Any]) +_DType_co = TypeVar("_DType_co", covariant=True, bound=dtype[Any]) +_FlexDType = TypeVar("_FlexDType", bound=dtype[flexible]) + +_ShapeType_co = TypeVar("_ShapeType_co", covariant=True, bound=tuple[int, ...]) +_ShapeType2 = TypeVar("_ShapeType2", bound=tuple[int, ...]) +_Shape2DType_co = TypeVar("_Shape2DType_co", covariant=True, bound=tuple[int, int]) +_NumberType = TypeVar("_NumberType", bound=number[Any]) + +if sys.version_info >= (3, 12): + from collections.abc import Buffer as _SupportsBuffer +else: + _SupportsBuffer: TypeAlias = ( + bytes + | bytearray + | memoryview + | _array.array[Any] + | mmap.mmap + | NDArray[Any] + | generic + ) + +_T = TypeVar("_T") +_T_co = TypeVar("_T_co", covariant=True) +_T_contra = TypeVar("_T_contra", contravariant=True) +_2Tuple: TypeAlias = tuple[_T, _T] +_CastingKind: TypeAlias = L["no", "equiv", "safe", "same_kind", "unsafe"] + +_ArrayUInt_co: TypeAlias = NDArray[np.bool | unsignedinteger[Any]] +_ArrayInt_co: TypeAlias = NDArray[np.bool | integer[Any]] +_ArrayFloat_co: TypeAlias = NDArray[np.bool | integer[Any] | floating[Any]] +_ArrayComplex_co: TypeAlias = NDArray[np.bool | integer[Any] | floating[Any] | complexfloating[Any, Any]] +_ArrayNumber_co: TypeAlias = NDArray[np.bool | number[Any]] +_ArrayTD64_co: TypeAlias = NDArray[np.bool | integer[Any] | timedelta64] + +# Introduce an alias for `dtype` to avoid naming conflicts. +_dtype: TypeAlias = dtype[_ScalarType] + +if sys.version_info >= (3, 13): + from types import CapsuleType as _PyCapsule +else: + _PyCapsule: TypeAlias = Any + +_ArrayAPIVersion: TypeAlias = L["2021.12", "2022.12", "2023.12"] + +class _SupportsItem(Protocol[_T_co]): + def item(self, args: Any, /) -> _T_co: ... + +class _SupportsReal(Protocol[_T_co]): + @property + def real(self) -> _T_co: ... + +class _SupportsImag(Protocol[_T_co]): + @property + def imag(self) -> _T_co: ... + +class ndarray(_ArrayOrScalarCommon, Generic[_ShapeType_co, _DType_co]): + __hash__: ClassVar[None] + @property + def base(self) -> None | NDArray[Any]: ... + @property + def ndim(self) -> int: ... + @property + def size(self) -> int: ... + @property + def real( + self: ndarray[_ShapeType_co, dtype[_SupportsReal[_ScalarType]]], # type: ignore[type-var] + ) -> ndarray[_ShapeType_co, _dtype[_ScalarType]]: ... + @real.setter + def real(self, value: ArrayLike) -> None: ... + @property + def imag( + self: ndarray[_ShapeType_co, dtype[_SupportsImag[_ScalarType]]], # type: ignore[type-var] + ) -> ndarray[_ShapeType_co, _dtype[_ScalarType]]: ... + @imag.setter + def imag(self, value: ArrayLike) -> None: ... + def __new__( + cls: type[_ArraySelf], + shape: _ShapeLike, + dtype: DTypeLike = ..., + buffer: None | _SupportsBuffer = ..., + offset: SupportsIndex = ..., + strides: None | _ShapeLike = ..., + order: _OrderKACF = ..., + ) -> _ArraySelf: ... + + if sys.version_info >= (3, 12): + def __buffer__(self, flags: int, /) -> memoryview: ... + + def __class_getitem__(cls, item: Any, /) -> GenericAlias: ... + + @overload + def __array__( + self, dtype: None = ..., /, *, copy: None | bool = ... + ) -> ndarray[_ShapeType_co, _DType_co]: ... + @overload + def __array__( + self, dtype: _DType, /, *, copy: None | bool = ... + ) -> ndarray[_ShapeType_co, _DType]: ... + + def __array_ufunc__( + self, + ufunc: ufunc, + method: L["__call__", "reduce", "reduceat", "accumulate", "outer", "at"], + *inputs: Any, + **kwargs: Any, + ) -> Any: ... + + def __array_function__( + self, + func: Callable[..., Any], + types: Iterable[type], + args: Iterable[Any], + kwargs: Mapping[str, Any], + ) -> Any: ... + + # NOTE: In practice any object is accepted by `obj`, but as `__array_finalize__` + # is a pseudo-abstract method the type has been narrowed down in order to + # grant subclasses a bit more flexibility + def __array_finalize__(self, obj: None | NDArray[Any], /) -> None: ... + + def __array_wrap__( + self, + array: ndarray[_ShapeType2, _DType], + context: None | tuple[ufunc, tuple[Any, ...], int] = ..., + return_scalar: builtins.bool = ..., + /, + ) -> ndarray[_ShapeType2, _DType]: ... + + @overload + def __getitem__(self, key: ( + NDArray[integer[Any]] + | NDArray[np.bool] + | tuple[NDArray[integer[Any]] | NDArray[np.bool], ...] + )) -> ndarray[Any, _DType_co]: ... + @overload + def __getitem__(self, key: SupportsIndex | tuple[SupportsIndex, ...]) -> Any: ... + @overload + def __getitem__(self, key: ( + None + | slice + | ellipsis + | SupportsIndex + | _ArrayLikeInt_co + | tuple[None | slice | ellipsis | _ArrayLikeInt_co | SupportsIndex, ...] + )) -> ndarray[Any, _DType_co]: ... + @overload + def __getitem__(self: NDArray[void], key: str) -> NDArray[Any]: ... + @overload + def __getitem__(self: NDArray[void], key: list[str]) -> ndarray[_ShapeType_co, _dtype[void]]: ... + + @property + def ctypes(self) -> _ctypes[int]: ... + @property + def shape(self) -> _ShapeType_co: ... + @shape.setter + def shape(self, value: _ShapeLike) -> None: ... + @property + def strides(self) -> _Shape: ... + @strides.setter + def strides(self, value: _ShapeLike) -> None: ... + def byteswap(self: _ArraySelf, inplace: builtins.bool = ...) -> _ArraySelf: ... + def fill(self, value: Any) -> None: ... + @property + def flat(self: _NdArraySubClass) -> flatiter[_NdArraySubClass]: ... + + # Use the same output type as that of the underlying `generic` + @overload + def item( + self: ndarray[Any, _dtype[_SupportsItem[_T]]], # type: ignore[type-var] + *args: SupportsIndex, + ) -> _T: ... + @overload + def item( + self: ndarray[Any, _dtype[_SupportsItem[_T]]], # type: ignore[type-var] + args: tuple[SupportsIndex, ...], + /, + ) -> _T: ... + + @overload + def resize(self, new_shape: _ShapeLike, /, *, refcheck: builtins.bool = ...) -> None: ... + @overload + def resize(self, *new_shape: SupportsIndex, refcheck: builtins.bool = ...) -> None: ... + + def setflags( + self, write: builtins.bool = ..., align: builtins.bool = ..., uic: builtins.bool = ... + ) -> None: ... + + def squeeze( + self, + axis: None | SupportsIndex | tuple[SupportsIndex, ...] = ..., + ) -> ndarray[Any, _DType_co]: ... + + def swapaxes( + self, + axis1: SupportsIndex, + axis2: SupportsIndex, + ) -> ndarray[Any, _DType_co]: ... + + @overload + def transpose(self: _ArraySelf, axes: None | _ShapeLike, /) -> _ArraySelf: ... + @overload + def transpose(self: _ArraySelf, *axes: SupportsIndex) -> _ArraySelf: ... + + def argpartition( + self, + kth: _ArrayLikeInt_co, + axis: None | SupportsIndex = ..., + kind: _PartitionKind = ..., + order: None | str | Sequence[str] = ..., + ) -> NDArray[intp]: ... + + def diagonal( + self, + offset: SupportsIndex = ..., + axis1: SupportsIndex = ..., + axis2: SupportsIndex = ..., + ) -> ndarray[Any, _DType_co]: ... + + # 1D + 1D returns a scalar; + # all other with at least 1 non-0D array return an ndarray. + @overload + def dot(self, b: _ScalarLike_co, out: None = ...) -> NDArray[Any]: ... + @overload + def dot(self, b: ArrayLike, out: None = ...) -> Any: ... # type: ignore[misc] + @overload + def dot(self, b: ArrayLike, out: _NdArraySubClass) -> _NdArraySubClass: ... + + # `nonzero()` is deprecated for 0d arrays/generics + def nonzero(self) -> tuple[NDArray[intp], ...]: ... + + def partition( + self, + kth: _ArrayLikeInt_co, + axis: SupportsIndex = ..., + kind: _PartitionKind = ..., + order: None | str | Sequence[str] = ..., + ) -> None: ... + + # `put` is technically available to `generic`, + # but is pointless as `generic`s are immutable + def put( + self, + ind: _ArrayLikeInt_co, + v: ArrayLike, + mode: _ModeKind = ..., + ) -> None: ... + + @overload + def searchsorted( # type: ignore[misc] + self, # >= 1D array + v: _ScalarLike_co, # 0D array-like + side: _SortSide = ..., + sorter: None | _ArrayLikeInt_co = ..., + ) -> intp: ... + @overload + def searchsorted( + self, # >= 1D array + v: ArrayLike, + side: _SortSide = ..., + sorter: None | _ArrayLikeInt_co = ..., + ) -> NDArray[intp]: ... + + def setfield( + self, + val: ArrayLike, + dtype: DTypeLike, + offset: SupportsIndex = ..., + ) -> None: ... + + def sort( + self, + axis: SupportsIndex = ..., + kind: None | _SortKind = ..., + order: None | str | Sequence[str] = ..., + *, + stable: None | bool = ..., + ) -> None: ... + + @overload + def trace( + self, # >= 2D array + offset: SupportsIndex = ..., + axis1: SupportsIndex = ..., + axis2: SupportsIndex = ..., + dtype: DTypeLike = ..., + out: None = ..., + ) -> Any: ... + @overload + def trace( + self, # >= 2D array + offset: SupportsIndex = ..., + axis1: SupportsIndex = ..., + axis2: SupportsIndex = ..., + dtype: DTypeLike = ..., + out: _NdArraySubClass = ..., + ) -> _NdArraySubClass: ... + + @overload + def take( # type: ignore[misc] + self: NDArray[_ScalarType], + indices: _IntLike_co, + axis: None | SupportsIndex = ..., + out: None = ..., + mode: _ModeKind = ..., + ) -> _ScalarType: ... + @overload + def take( # type: ignore[misc] + self, + indices: _ArrayLikeInt_co, + axis: None | SupportsIndex = ..., + out: None = ..., + mode: _ModeKind = ..., + ) -> ndarray[Any, _DType_co]: ... + @overload + def take( + self, + indices: _ArrayLikeInt_co, + axis: None | SupportsIndex = ..., + out: _NdArraySubClass = ..., + mode: _ModeKind = ..., + ) -> _NdArraySubClass: ... + + def repeat( + self, + repeats: _ArrayLikeInt_co, + axis: None | SupportsIndex = ..., + ) -> ndarray[Any, _DType_co]: ... + + # TODO: use `tuple[int]` as shape type once covariant (#26081) + def flatten( + self, + order: _OrderKACF = ..., + ) -> ndarray[Any, _DType_co]: ... + + # TODO: use `tuple[int]` as shape type once covariant (#26081) + def ravel( + self, + order: _OrderKACF = ..., + ) -> ndarray[Any, _DType_co]: ... + + @overload + def reshape( + self, + shape: _ShapeLike, + /, + *, + order: _OrderACF = ..., + copy: None | bool = ..., + ) -> ndarray[Any, _DType_co]: ... + @overload + def reshape( + self, + *shape: SupportsIndex, + order: _OrderACF = ..., + copy: None | bool = ..., + ) -> ndarray[Any, _DType_co]: ... + + @overload + def astype( + self, + dtype: _DTypeLike[_ScalarType], + order: _OrderKACF = ..., + casting: _CastingKind = ..., + subok: builtins.bool = ..., + copy: builtins.bool | _CopyMode = ..., + ) -> NDArray[_ScalarType]: ... + @overload + def astype( + self, + dtype: DTypeLike, + order: _OrderKACF = ..., + casting: _CastingKind = ..., + subok: builtins.bool = ..., + copy: builtins.bool | _CopyMode = ..., + ) -> NDArray[Any]: ... + + @overload + def view(self: _ArraySelf) -> _ArraySelf: ... + @overload + def view(self, type: type[_NdArraySubClass]) -> _NdArraySubClass: ... + @overload + def view(self, dtype: _DTypeLike[_ScalarType]) -> NDArray[_ScalarType]: ... + @overload + def view(self, dtype: DTypeLike) -> NDArray[Any]: ... + @overload + def view( + self, + dtype: DTypeLike, + type: type[_NdArraySubClass], + ) -> _NdArraySubClass: ... + + @overload + def getfield( + self, + dtype: _DTypeLike[_ScalarType], + offset: SupportsIndex = ... + ) -> NDArray[_ScalarType]: ... + @overload + def getfield( + self, + dtype: DTypeLike, + offset: SupportsIndex = ... + ) -> NDArray[Any]: ... + + # Dispatch to the underlying `generic` via protocols + def __int__( + self: NDArray[SupportsInt], # type: ignore[type-var] + ) -> int: ... + + def __float__( + self: NDArray[SupportsFloat], # type: ignore[type-var] + ) -> float: ... + + def __complex__( + self: NDArray[SupportsComplex], # type: ignore[type-var] + ) -> complex: ... + + def __index__( + self: NDArray[SupportsIndex], # type: ignore[type-var] + ) -> int: ... + + def __len__(self) -> int: ... + def __setitem__(self, key, value): ... + def __iter__(self) -> Any: ... + def __contains__(self, key) -> builtins.bool: ... + + # The last overload is for catching recursive objects whose + # nesting is too deep. + # The first overload is for catching `bytes` (as they are a subtype of + # `Sequence[int]`) and `str`. As `str` is a recursive sequence of + # strings, it will pass through the final overload otherwise + + @overload + def __lt__(self: _ArrayNumber_co, other: _ArrayLikeNumber_co, /) -> NDArray[np.bool]: ... + @overload + def __lt__(self: _ArrayTD64_co, other: _ArrayLikeTD64_co, /) -> NDArray[np.bool]: ... + @overload + def __lt__(self: NDArray[datetime64], other: _ArrayLikeDT64_co, /) -> NDArray[np.bool]: ... + @overload + def __lt__(self: NDArray[object_], other: Any, /) -> NDArray[np.bool]: ... + @overload + def __lt__(self: NDArray[Any], other: _ArrayLikeObject_co, /) -> NDArray[np.bool]: ... + + @overload + def __le__(self: _ArrayNumber_co, other: _ArrayLikeNumber_co, /) -> NDArray[np.bool]: ... + @overload + def __le__(self: _ArrayTD64_co, other: _ArrayLikeTD64_co, /) -> NDArray[np.bool]: ... + @overload + def __le__(self: NDArray[datetime64], other: _ArrayLikeDT64_co, /) -> NDArray[np.bool]: ... + @overload + def __le__(self: NDArray[object_], other: Any, /) -> NDArray[np.bool]: ... + @overload + def __le__(self: NDArray[Any], other: _ArrayLikeObject_co, /) -> NDArray[np.bool]: ... + + @overload + def __gt__(self: _ArrayNumber_co, other: _ArrayLikeNumber_co, /) -> NDArray[np.bool]: ... + @overload + def __gt__(self: _ArrayTD64_co, other: _ArrayLikeTD64_co, /) -> NDArray[np.bool]: ... + @overload + def __gt__(self: NDArray[datetime64], other: _ArrayLikeDT64_co, /) -> NDArray[np.bool]: ... + @overload + def __gt__(self: NDArray[object_], other: Any, /) -> NDArray[np.bool]: ... + @overload + def __gt__(self: NDArray[Any], other: _ArrayLikeObject_co, /) -> NDArray[np.bool]: ... + + @overload + def __ge__(self: _ArrayNumber_co, other: _ArrayLikeNumber_co, /) -> NDArray[np.bool]: ... + @overload + def __ge__(self: _ArrayTD64_co, other: _ArrayLikeTD64_co, /) -> NDArray[np.bool]: ... + @overload + def __ge__(self: NDArray[datetime64], other: _ArrayLikeDT64_co, /) -> NDArray[np.bool]: ... + @overload + def __ge__(self: NDArray[object_], other: Any, /) -> NDArray[np.bool]: ... + @overload + def __ge__(self: NDArray[Any], other: _ArrayLikeObject_co, /) -> NDArray[np.bool]: ... + + # Unary ops + @overload + def __abs__(self: NDArray[_UnknownType]) -> NDArray[Any]: ... + @overload + def __abs__(self: NDArray[np.bool]) -> NDArray[np.bool]: ... + @overload + def __abs__(self: NDArray[complexfloating[_NBit1, _NBit1]]) -> NDArray[floating[_NBit1]]: ... + @overload + def __abs__(self: NDArray[_NumberType]) -> NDArray[_NumberType]: ... + @overload + def __abs__(self: NDArray[timedelta64]) -> NDArray[timedelta64]: ... + @overload + def __abs__(self: NDArray[object_]) -> Any: ... + + @overload + def __invert__(self: NDArray[_UnknownType]) -> NDArray[Any]: ... + @overload + def __invert__(self: NDArray[np.bool]) -> NDArray[np.bool]: ... + @overload + def __invert__(self: NDArray[_IntType]) -> NDArray[_IntType]: ... + @overload + def __invert__(self: NDArray[object_]) -> Any: ... + + @overload + def __pos__(self: NDArray[_NumberType]) -> NDArray[_NumberType]: ... + @overload + def __pos__(self: NDArray[timedelta64]) -> NDArray[timedelta64]: ... + @overload + def __pos__(self: NDArray[object_]) -> Any: ... + + @overload + def __neg__(self: NDArray[_NumberType]) -> NDArray[_NumberType]: ... + @overload + def __neg__(self: NDArray[timedelta64]) -> NDArray[timedelta64]: ... + @overload + def __neg__(self: NDArray[object_]) -> Any: ... + + # Binary ops + @overload + def __matmul__(self: NDArray[_UnknownType], other: _ArrayLikeUnknown, /) -> NDArray[Any]: ... + @overload + def __matmul__(self: NDArray[np.bool], other: _ArrayLikeBool_co, /) -> NDArray[np.bool]: ... # type: ignore[misc] + @overload + def __matmul__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co, /) -> NDArray[unsignedinteger[Any]]: ... # type: ignore[misc] + @overload + def __matmul__(self: _ArrayInt_co, other: _ArrayLikeInt_co, /) -> NDArray[signedinteger[Any]]: ... # type: ignore[misc] + @overload + def __matmul__(self: _ArrayFloat_co, other: _ArrayLikeFloat_co, /) -> NDArray[floating[Any]]: ... # type: ignore[misc] + @overload + def __matmul__(self: _ArrayComplex_co, other: _ArrayLikeComplex_co, /) -> NDArray[complexfloating[Any, Any]]: ... + @overload + def __matmul__(self: NDArray[number[Any]], other: _ArrayLikeNumber_co, /) -> NDArray[number[Any]]: ... + @overload + def __matmul__(self: NDArray[object_], other: Any, /) -> Any: ... + @overload + def __matmul__(self: NDArray[Any], other: _ArrayLikeObject_co, /) -> Any: ... + + @overload + def __rmatmul__(self: NDArray[_UnknownType], other: _ArrayLikeUnknown, /) -> NDArray[Any]: ... + @overload + def __rmatmul__(self: NDArray[np.bool], other: _ArrayLikeBool_co, /) -> NDArray[np.bool]: ... # type: ignore[misc] + @overload + def __rmatmul__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co, /) -> NDArray[unsignedinteger[Any]]: ... # type: ignore[misc] + @overload + def __rmatmul__(self: _ArrayInt_co, other: _ArrayLikeInt_co, /) -> NDArray[signedinteger[Any]]: ... # type: ignore[misc] + @overload + def __rmatmul__(self: _ArrayFloat_co, other: _ArrayLikeFloat_co, /) -> NDArray[floating[Any]]: ... # type: ignore[misc] + @overload + def __rmatmul__(self: _ArrayComplex_co, other: _ArrayLikeComplex_co, /) -> NDArray[complexfloating[Any, Any]]: ... + @overload + def __rmatmul__(self: NDArray[number[Any]], other: _ArrayLikeNumber_co, /) -> NDArray[number[Any]]: ... + @overload + def __rmatmul__(self: NDArray[object_], other: Any, /) -> Any: ... + @overload + def __rmatmul__(self: NDArray[Any], other: _ArrayLikeObject_co, /) -> Any: ... + + @overload + def __mod__(self: NDArray[_UnknownType], other: _ArrayLikeUnknown, /) -> NDArray[Any]: ... + @overload + def __mod__(self: NDArray[np.bool], other: _ArrayLikeBool_co, /) -> NDArray[int8]: ... # type: ignore[misc] + @overload + def __mod__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co, /) -> NDArray[unsignedinteger[Any]]: ... # type: ignore[misc] + @overload + def __mod__(self: _ArrayInt_co, other: _ArrayLikeInt_co, /) -> NDArray[signedinteger[Any]]: ... # type: ignore[misc] + @overload + def __mod__(self: _ArrayFloat_co, other: _ArrayLikeFloat_co, /) -> NDArray[floating[Any]]: ... # type: ignore[misc] + @overload + def __mod__(self: _ArrayTD64_co, other: _SupportsArray[_dtype[timedelta64]] | _NestedSequence[_SupportsArray[_dtype[timedelta64]]], /) -> NDArray[timedelta64]: ... + @overload + def __mod__(self: NDArray[object_], other: Any, /) -> Any: ... + @overload + def __mod__(self: NDArray[Any], other: _ArrayLikeObject_co, /) -> Any: ... + + @overload + def __rmod__(self: NDArray[_UnknownType], other: _ArrayLikeUnknown, /) -> NDArray[Any]: ... + @overload + def __rmod__(self: NDArray[np.bool], other: _ArrayLikeBool_co, /) -> NDArray[int8]: ... # type: ignore[misc] + @overload + def __rmod__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co, /) -> NDArray[unsignedinteger[Any]]: ... # type: ignore[misc] + @overload + def __rmod__(self: _ArrayInt_co, other: _ArrayLikeInt_co, /) -> NDArray[signedinteger[Any]]: ... # type: ignore[misc] + @overload + def __rmod__(self: _ArrayFloat_co, other: _ArrayLikeFloat_co, /) -> NDArray[floating[Any]]: ... # type: ignore[misc] + @overload + def __rmod__(self: _ArrayTD64_co, other: _SupportsArray[_dtype[timedelta64]] | _NestedSequence[_SupportsArray[_dtype[timedelta64]]], /) -> NDArray[timedelta64]: ... + @overload + def __rmod__(self: NDArray[object_], other: Any, /) -> Any: ... + @overload + def __rmod__(self: NDArray[Any], other: _ArrayLikeObject_co, /) -> Any: ... + + @overload + def __divmod__(self: NDArray[_UnknownType], other: _ArrayLikeUnknown, /) -> _2Tuple[NDArray[Any]]: ... + @overload + def __divmod__(self: NDArray[np.bool], other: _ArrayLikeBool_co) -> _2Tuple[NDArray[int8]]: ... # type: ignore[misc] + @overload + def __divmod__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co, /) -> _2Tuple[NDArray[unsignedinteger[Any]]]: ... # type: ignore[misc] + @overload + def __divmod__(self: _ArrayInt_co, other: _ArrayLikeInt_co, /) -> _2Tuple[NDArray[signedinteger[Any]]]: ... # type: ignore[misc] + @overload + def __divmod__(self: _ArrayFloat_co, other: _ArrayLikeFloat_co, /) -> _2Tuple[NDArray[floating[Any]]]: ... # type: ignore[misc] + @overload + def __divmod__(self: _ArrayTD64_co, other: _SupportsArray[_dtype[timedelta64]] | _NestedSequence[_SupportsArray[_dtype[timedelta64]]], /) -> tuple[NDArray[int64], NDArray[timedelta64]]: ... + + @overload + def __rdivmod__(self: NDArray[_UnknownType], other: _ArrayLikeUnknown, /) -> _2Tuple[NDArray[Any]]: ... + @overload + def __rdivmod__(self: NDArray[np.bool], other: _ArrayLikeBool_co, /) -> _2Tuple[NDArray[int8]]: ... # type: ignore[misc] + @overload + def __rdivmod__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co, /) -> _2Tuple[NDArray[unsignedinteger[Any]]]: ... # type: ignore[misc] + @overload + def __rdivmod__(self: _ArrayInt_co, other: _ArrayLikeInt_co, /) -> _2Tuple[NDArray[signedinteger[Any]]]: ... # type: ignore[misc] + @overload + def __rdivmod__(self: _ArrayFloat_co, other: _ArrayLikeFloat_co, /) -> _2Tuple[NDArray[floating[Any]]]: ... # type: ignore[misc] + @overload + def __rdivmod__(self: _ArrayTD64_co, other: _SupportsArray[_dtype[timedelta64]] | _NestedSequence[_SupportsArray[_dtype[timedelta64]]], /) -> tuple[NDArray[int64], NDArray[timedelta64]]: ... + + @overload + def __add__(self: NDArray[_UnknownType], other: _ArrayLikeUnknown, /) -> NDArray[Any]: ... + @overload + def __add__(self: NDArray[np.bool], other: _ArrayLikeBool_co, /) -> NDArray[np.bool]: ... # type: ignore[misc] + @overload + def __add__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co, /) -> NDArray[unsignedinteger[Any]]: ... # type: ignore[misc] + @overload + def __add__(self: _ArrayInt_co, other: _ArrayLikeInt_co, /) -> NDArray[signedinteger[Any]]: ... # type: ignore[misc] + @overload + def __add__(self: _ArrayFloat_co, other: _ArrayLikeFloat_co, /) -> NDArray[floating[Any]]: ... # type: ignore[misc] + @overload + def __add__(self: _ArrayComplex_co, other: _ArrayLikeComplex_co, /) -> NDArray[complexfloating[Any, Any]]: ... # type: ignore[misc] + @overload + def __add__(self: NDArray[number[Any]], other: _ArrayLikeNumber_co, /) -> NDArray[number[Any]]: ... + @overload + def __add__(self: _ArrayTD64_co, other: _ArrayLikeTD64_co, /) -> NDArray[timedelta64]: ... # type: ignore[misc] + @overload + def __add__(self: _ArrayTD64_co, other: _ArrayLikeDT64_co, /) -> NDArray[datetime64]: ... + @overload + def __add__(self: NDArray[datetime64], other: _ArrayLikeTD64_co, /) -> NDArray[datetime64]: ... + @overload + def __add__(self: NDArray[object_], other: Any, /) -> Any: ... + @overload + def __add__(self: NDArray[Any], other: _ArrayLikeObject_co, /) -> Any: ... + + @overload + def __radd__(self: NDArray[_UnknownType], other: _ArrayLikeUnknown, /) -> NDArray[Any]: ... + @overload + def __radd__(self: NDArray[np.bool], other: _ArrayLikeBool_co, /) -> NDArray[np.bool]: ... # type: ignore[misc] + @overload + def __radd__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co, /) -> NDArray[unsignedinteger[Any]]: ... # type: ignore[misc] + @overload + def __radd__(self: _ArrayInt_co, other: _ArrayLikeInt_co, /) -> NDArray[signedinteger[Any]]: ... # type: ignore[misc] + @overload + def __radd__(self: _ArrayFloat_co, other: _ArrayLikeFloat_co, /) -> NDArray[floating[Any]]: ... # type: ignore[misc] + @overload + def __radd__(self: _ArrayComplex_co, other: _ArrayLikeComplex_co, /) -> NDArray[complexfloating[Any, Any]]: ... # type: ignore[misc] + @overload + def __radd__(self: NDArray[number[Any]], other: _ArrayLikeNumber_co, /) -> NDArray[number[Any]]: ... + @overload + def __radd__(self: _ArrayTD64_co, other: _ArrayLikeTD64_co, /) -> NDArray[timedelta64]: ... # type: ignore[misc] + @overload + def __radd__(self: _ArrayTD64_co, other: _ArrayLikeDT64_co, /) -> NDArray[datetime64]: ... + @overload + def __radd__(self: NDArray[datetime64], other: _ArrayLikeTD64_co, /) -> NDArray[datetime64]: ... + @overload + def __radd__(self: NDArray[object_], other: Any, /) -> Any: ... + @overload + def __radd__(self: NDArray[Any], other: _ArrayLikeObject_co, /) -> Any: ... + + @overload + def __sub__(self: NDArray[_UnknownType], other: _ArrayLikeUnknown, /) -> NDArray[Any]: ... + @overload + def __sub__(self: NDArray[np.bool], other: _ArrayLikeBool_co, /) -> NoReturn: ... + @overload + def __sub__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co, /) -> NDArray[unsignedinteger[Any]]: ... # type: ignore[misc] + @overload + def __sub__(self: _ArrayInt_co, other: _ArrayLikeInt_co, /) -> NDArray[signedinteger[Any]]: ... # type: ignore[misc] + @overload + def __sub__(self: _ArrayFloat_co, other: _ArrayLikeFloat_co, /) -> NDArray[floating[Any]]: ... # type: ignore[misc] + @overload + def __sub__(self: _ArrayComplex_co, other: _ArrayLikeComplex_co, /) -> NDArray[complexfloating[Any, Any]]: ... # type: ignore[misc] + @overload + def __sub__(self: NDArray[number[Any]], other: _ArrayLikeNumber_co, /) -> NDArray[number[Any]]: ... + @overload + def __sub__(self: _ArrayTD64_co, other: _ArrayLikeTD64_co, /) -> NDArray[timedelta64]: ... # type: ignore[misc] + @overload + def __sub__(self: NDArray[datetime64], other: _ArrayLikeTD64_co, /) -> NDArray[datetime64]: ... + @overload + def __sub__(self: NDArray[datetime64], other: _ArrayLikeDT64_co, /) -> NDArray[timedelta64]: ... + @overload + def __sub__(self: NDArray[object_], other: Any, /) -> Any: ... + @overload + def __sub__(self: NDArray[Any], other: _ArrayLikeObject_co, /) -> Any: ... + + @overload + def __rsub__(self: NDArray[_UnknownType], other: _ArrayLikeUnknown, /) -> NDArray[Any]: ... + @overload + def __rsub__(self: NDArray[np.bool], other: _ArrayLikeBool_co, /) -> NoReturn: ... + @overload + def __rsub__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co, /) -> NDArray[unsignedinteger[Any]]: ... # type: ignore[misc] + @overload + def __rsub__(self: _ArrayInt_co, other: _ArrayLikeInt_co, /) -> NDArray[signedinteger[Any]]: ... # type: ignore[misc] + @overload + def __rsub__(self: _ArrayFloat_co, other: _ArrayLikeFloat_co, /) -> NDArray[floating[Any]]: ... # type: ignore[misc] + @overload + def __rsub__(self: _ArrayComplex_co, other: _ArrayLikeComplex_co, /) -> NDArray[complexfloating[Any, Any]]: ... # type: ignore[misc] + @overload + def __rsub__(self: NDArray[number[Any]], other: _ArrayLikeNumber_co, /) -> NDArray[number[Any]]: ... + @overload + def __rsub__(self: _ArrayTD64_co, other: _ArrayLikeTD64_co, /) -> NDArray[timedelta64]: ... # type: ignore[misc] + @overload + def __rsub__(self: _ArrayTD64_co, other: _ArrayLikeDT64_co, /) -> NDArray[datetime64]: ... # type: ignore[misc] + @overload + def __rsub__(self: NDArray[datetime64], other: _ArrayLikeDT64_co, /) -> NDArray[timedelta64]: ... + @overload + def __rsub__(self: NDArray[object_], other: Any, /) -> Any: ... + @overload + def __rsub__(self: NDArray[Any], other: _ArrayLikeObject_co, /) -> Any: ... + + @overload + def __mul__(self: NDArray[_UnknownType], other: _ArrayLikeUnknown, /) -> NDArray[Any]: ... + @overload + def __mul__(self: NDArray[np.bool], other: _ArrayLikeBool_co, /) -> NDArray[np.bool]: ... # type: ignore[misc] + @overload + def __mul__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co, /) -> NDArray[unsignedinteger[Any]]: ... # type: ignore[misc] + @overload + def __mul__(self: _ArrayInt_co, other: _ArrayLikeInt_co, /) -> NDArray[signedinteger[Any]]: ... # type: ignore[misc] + @overload + def __mul__(self: _ArrayFloat_co, other: _ArrayLikeFloat_co, /) -> NDArray[floating[Any]]: ... # type: ignore[misc] + @overload + def __mul__(self: _ArrayComplex_co, other: _ArrayLikeComplex_co, /) -> NDArray[complexfloating[Any, Any]]: ... # type: ignore[misc] + @overload + def __mul__(self: NDArray[number[Any]], other: _ArrayLikeNumber_co, /) -> NDArray[number[Any]]: ... + @overload + def __mul__(self: _ArrayTD64_co, other: _ArrayLikeFloat_co, /) -> NDArray[timedelta64]: ... + @overload + def __mul__(self: _ArrayFloat_co, other: _ArrayLikeTD64_co, /) -> NDArray[timedelta64]: ... + @overload + def __mul__(self: NDArray[object_], other: Any, /) -> Any: ... + @overload + def __mul__(self: NDArray[Any], other: _ArrayLikeObject_co, /) -> Any: ... + + @overload + def __rmul__(self: NDArray[_UnknownType], other: _ArrayLikeUnknown, /) -> NDArray[Any]: ... + @overload + def __rmul__(self: NDArray[np.bool], other: _ArrayLikeBool_co, /) -> NDArray[np.bool]: ... # type: ignore[misc] + @overload + def __rmul__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co, /) -> NDArray[unsignedinteger[Any]]: ... # type: ignore[misc] + @overload + def __rmul__(self: _ArrayInt_co, other: _ArrayLikeInt_co, /) -> NDArray[signedinteger[Any]]: ... # type: ignore[misc] + @overload + def __rmul__(self: _ArrayFloat_co, other: _ArrayLikeFloat_co, /) -> NDArray[floating[Any]]: ... # type: ignore[misc] + @overload + def __rmul__(self: _ArrayComplex_co, other: _ArrayLikeComplex_co, /) -> NDArray[complexfloating[Any, Any]]: ... # type: ignore[misc] + @overload + def __rmul__(self: NDArray[number[Any]], other: _ArrayLikeNumber_co, /) -> NDArray[number[Any]]: ... + @overload + def __rmul__(self: _ArrayTD64_co, other: _ArrayLikeFloat_co, /) -> NDArray[timedelta64]: ... + @overload + def __rmul__(self: _ArrayFloat_co, other: _ArrayLikeTD64_co, /) -> NDArray[timedelta64]: ... + @overload + def __rmul__(self: NDArray[object_], other: Any, /) -> Any: ... + @overload + def __rmul__(self: NDArray[Any], other: _ArrayLikeObject_co, /) -> Any: ... + + @overload + def __floordiv__(self: NDArray[_UnknownType], other: _ArrayLikeUnknown, /) -> NDArray[Any]: ... + @overload + def __floordiv__(self: NDArray[np.bool], other: _ArrayLikeBool_co, /) -> NDArray[int8]: ... # type: ignore[misc] + @overload + def __floordiv__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co, /) -> NDArray[unsignedinteger[Any]]: ... # type: ignore[misc] + @overload + def __floordiv__(self: _ArrayInt_co, other: _ArrayLikeInt_co, /) -> NDArray[signedinteger[Any]]: ... # type: ignore[misc] + @overload + def __floordiv__(self: _ArrayFloat_co, other: _ArrayLikeFloat_co, /) -> NDArray[floating[Any]]: ... # type: ignore[misc] + @overload + def __floordiv__(self: NDArray[timedelta64], other: _SupportsArray[_dtype[timedelta64]] | _NestedSequence[_SupportsArray[_dtype[timedelta64]]], /) -> NDArray[int64]: ... + @overload + def __floordiv__(self: NDArray[timedelta64], other: _ArrayLikeBool_co, /) -> NoReturn: ... + @overload + def __floordiv__(self: NDArray[timedelta64], other: _ArrayLikeFloat_co, /) -> NDArray[timedelta64]: ... + @overload + def __floordiv__(self: NDArray[object_], other: Any, /) -> Any: ... + @overload + def __floordiv__(self: NDArray[Any], other: _ArrayLikeObject_co, /) -> Any: ... + + @overload + def __rfloordiv__(self: NDArray[_UnknownType], other: _ArrayLikeUnknown, /) -> NDArray[Any]: ... + @overload + def __rfloordiv__(self: NDArray[np.bool], other: _ArrayLikeBool_co, /) -> NDArray[int8]: ... # type: ignore[misc] + @overload + def __rfloordiv__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co, /) -> NDArray[unsignedinteger[Any]]: ... # type: ignore[misc] + @overload + def __rfloordiv__(self: _ArrayInt_co, other: _ArrayLikeInt_co, /) -> NDArray[signedinteger[Any]]: ... # type: ignore[misc] + @overload + def __rfloordiv__(self: _ArrayFloat_co, other: _ArrayLikeFloat_co, /) -> NDArray[floating[Any]]: ... # type: ignore[misc] + @overload + def __rfloordiv__(self: NDArray[timedelta64], other: _SupportsArray[_dtype[timedelta64]] | _NestedSequence[_SupportsArray[_dtype[timedelta64]]], /) -> NDArray[int64]: ... + @overload + def __rfloordiv__(self: NDArray[np.bool], other: _ArrayLikeTD64_co, /) -> NoReturn: ... + @overload + def __rfloordiv__(self: _ArrayFloat_co, other: _ArrayLikeTD64_co, /) -> NDArray[timedelta64]: ... + @overload + def __rfloordiv__(self: NDArray[object_], other: Any, /) -> Any: ... + @overload + def __rfloordiv__(self: NDArray[Any], other: _ArrayLikeObject_co, /) -> Any: ... + + @overload + def __pow__(self: NDArray[_UnknownType], other: _ArrayLikeUnknown, /) -> NDArray[Any]: ... + @overload + def __pow__(self: NDArray[np.bool], other: _ArrayLikeBool_co, /) -> NDArray[int8]: ... # type: ignore[misc] + @overload + def __pow__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co, /) -> NDArray[unsignedinteger[Any]]: ... # type: ignore[misc] + @overload + def __pow__(self: _ArrayInt_co, other: _ArrayLikeInt_co, /) -> NDArray[signedinteger[Any]]: ... # type: ignore[misc] + @overload + def __pow__(self: _ArrayFloat_co, other: _ArrayLikeFloat_co, /) -> NDArray[floating[Any]]: ... # type: ignore[misc] + @overload + def __pow__(self: _ArrayComplex_co, other: _ArrayLikeComplex_co, /) -> NDArray[complexfloating[Any, Any]]: ... + @overload + def __pow__(self: NDArray[number[Any]], other: _ArrayLikeNumber_co, /) -> NDArray[number[Any]]: ... + @overload + def __pow__(self: NDArray[object_], other: Any, /) -> Any: ... + @overload + def __pow__(self: NDArray[Any], other: _ArrayLikeObject_co, /) -> Any: ... + + @overload + def __rpow__(self: NDArray[_UnknownType], other: _ArrayLikeUnknown, /) -> NDArray[Any]: ... + @overload + def __rpow__(self: NDArray[np.bool], other: _ArrayLikeBool_co, /) -> NDArray[int8]: ... # type: ignore[misc] + @overload + def __rpow__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co, /) -> NDArray[unsignedinteger[Any]]: ... # type: ignore[misc] + @overload + def __rpow__(self: _ArrayInt_co, other: _ArrayLikeInt_co, /) -> NDArray[signedinteger[Any]]: ... # type: ignore[misc] + @overload + def __rpow__(self: _ArrayFloat_co, other: _ArrayLikeFloat_co, /) -> NDArray[floating[Any]]: ... # type: ignore[misc] + @overload + def __rpow__(self: _ArrayComplex_co, other: _ArrayLikeComplex_co, /) -> NDArray[complexfloating[Any, Any]]: ... + @overload + def __rpow__(self: NDArray[number[Any]], other: _ArrayLikeNumber_co, /) -> NDArray[number[Any]]: ... + @overload + def __rpow__(self: NDArray[object_], other: Any, /) -> Any: ... + @overload + def __rpow__(self: NDArray[Any], other: _ArrayLikeObject_co, /) -> Any: ... + + @overload + def __truediv__(self: NDArray[_UnknownType], other: _ArrayLikeUnknown, /) -> NDArray[Any]: ... + @overload + def __truediv__(self: _ArrayInt_co, other: _ArrayInt_co, /) -> NDArray[float64]: ... # type: ignore[misc] + @overload + def __truediv__(self: _ArrayFloat_co, other: _ArrayLikeFloat_co, /) -> NDArray[floating[Any]]: ... # type: ignore[misc] + @overload + def __truediv__(self: _ArrayComplex_co, other: _ArrayLikeComplex_co, /) -> NDArray[complexfloating[Any, Any]]: ... # type: ignore[misc] + @overload + def __truediv__(self: NDArray[number[Any]], other: _ArrayLikeNumber_co, /) -> NDArray[number[Any]]: ... + @overload + def __truediv__(self: NDArray[timedelta64], other: _SupportsArray[_dtype[timedelta64]] | _NestedSequence[_SupportsArray[_dtype[timedelta64]]], /) -> NDArray[float64]: ... + @overload + def __truediv__(self: NDArray[timedelta64], other: _ArrayLikeBool_co, /) -> NoReturn: ... + @overload + def __truediv__(self: NDArray[timedelta64], other: _ArrayLikeFloat_co, /) -> NDArray[timedelta64]: ... + @overload + def __truediv__(self: NDArray[object_], other: Any, /) -> Any: ... + @overload + def __truediv__(self: NDArray[Any], other: _ArrayLikeObject_co, /) -> Any: ... + + @overload + def __rtruediv__(self: NDArray[_UnknownType], other: _ArrayLikeUnknown, /) -> NDArray[Any]: ... + @overload + def __rtruediv__(self: _ArrayInt_co, other: _ArrayInt_co, /) -> NDArray[float64]: ... # type: ignore[misc] + @overload + def __rtruediv__(self: _ArrayFloat_co, other: _ArrayLikeFloat_co, /) -> NDArray[floating[Any]]: ... # type: ignore[misc] + @overload + def __rtruediv__(self: _ArrayComplex_co, other: _ArrayLikeComplex_co, /) -> NDArray[complexfloating[Any, Any]]: ... # type: ignore[misc] + @overload + def __rtruediv__(self: NDArray[number[Any]], other: _ArrayLikeNumber_co, /) -> NDArray[number[Any]]: ... + @overload + def __rtruediv__(self: NDArray[timedelta64], other: _SupportsArray[_dtype[timedelta64]] | _NestedSequence[_SupportsArray[_dtype[timedelta64]]], /) -> NDArray[float64]: ... + @overload + def __rtruediv__(self: NDArray[np.bool], other: _ArrayLikeTD64_co, /) -> NoReturn: ... + @overload + def __rtruediv__(self: _ArrayFloat_co, other: _ArrayLikeTD64_co, /) -> NDArray[timedelta64]: ... + @overload + def __rtruediv__(self: NDArray[object_], other: Any, /) -> Any: ... + @overload + def __rtruediv__(self: NDArray[Any], other: _ArrayLikeObject_co, /) -> Any: ... + + @overload + def __lshift__(self: NDArray[_UnknownType], other: _ArrayLikeUnknown, /) -> NDArray[Any]: ... + @overload + def __lshift__(self: NDArray[np.bool], other: _ArrayLikeBool_co, /) -> NDArray[int8]: ... # type: ignore[misc] + @overload + def __lshift__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co, /) -> NDArray[unsignedinteger[Any]]: ... # type: ignore[misc] + @overload + def __lshift__(self: _ArrayInt_co, other: _ArrayLikeInt_co, /) -> NDArray[signedinteger[Any]]: ... + @overload + def __lshift__(self: NDArray[object_], other: Any, /) -> Any: ... + @overload + def __lshift__(self: NDArray[Any], other: _ArrayLikeObject_co, /) -> Any: ... + + @overload + def __rlshift__(self: NDArray[_UnknownType], other: _ArrayLikeUnknown, /) -> NDArray[Any]: ... + @overload + def __rlshift__(self: NDArray[np.bool], other: _ArrayLikeBool_co, /) -> NDArray[int8]: ... # type: ignore[misc] + @overload + def __rlshift__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co, /) -> NDArray[unsignedinteger[Any]]: ... # type: ignore[misc] + @overload + def __rlshift__(self: _ArrayInt_co, other: _ArrayLikeInt_co, /) -> NDArray[signedinteger[Any]]: ... + @overload + def __rlshift__(self: NDArray[object_], other: Any, /) -> Any: ... + @overload + def __rlshift__(self: NDArray[Any], other: _ArrayLikeObject_co, /) -> Any: ... + + @overload + def __rshift__(self: NDArray[_UnknownType], other: _ArrayLikeUnknown, /) -> NDArray[Any]: ... + @overload + def __rshift__(self: NDArray[np.bool], other: _ArrayLikeBool_co, /) -> NDArray[int8]: ... # type: ignore[misc] + @overload + def __rshift__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co, /) -> NDArray[unsignedinteger[Any]]: ... # type: ignore[misc] + @overload + def __rshift__(self: _ArrayInt_co, other: _ArrayLikeInt_co, /) -> NDArray[signedinteger[Any]]: ... + @overload + def __rshift__(self: NDArray[object_], other: Any, /) -> Any: ... + @overload + def __rshift__(self: NDArray[Any], other: _ArrayLikeObject_co, /) -> Any: ... + + @overload + def __rrshift__(self: NDArray[_UnknownType], other: _ArrayLikeUnknown, /) -> NDArray[Any]: ... + @overload + def __rrshift__(self: NDArray[np.bool], other: _ArrayLikeBool_co, /) -> NDArray[int8]: ... # type: ignore[misc] + @overload + def __rrshift__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co, /) -> NDArray[unsignedinteger[Any]]: ... # type: ignore[misc] + @overload + def __rrshift__(self: _ArrayInt_co, other: _ArrayLikeInt_co, /) -> NDArray[signedinteger[Any]]: ... + @overload + def __rrshift__(self: NDArray[object_], other: Any, /) -> Any: ... + @overload + def __rrshift__(self: NDArray[Any], other: _ArrayLikeObject_co, /) -> Any: ... + + @overload + def __and__(self: NDArray[_UnknownType], other: _ArrayLikeUnknown, /) -> NDArray[Any]: ... + @overload + def __and__(self: NDArray[np.bool], other: _ArrayLikeBool_co, /) -> NDArray[np.bool]: ... # type: ignore[misc] + @overload + def __and__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co, /) -> NDArray[unsignedinteger[Any]]: ... # type: ignore[misc] + @overload + def __and__(self: _ArrayInt_co, other: _ArrayLikeInt_co, /) -> NDArray[signedinteger[Any]]: ... + @overload + def __and__(self: NDArray[object_], other: Any, /) -> Any: ... + @overload + def __and__(self: NDArray[Any], other: _ArrayLikeObject_co, /) -> Any: ... + + @overload + def __rand__(self: NDArray[_UnknownType], other: _ArrayLikeUnknown, /) -> NDArray[Any]: ... + @overload + def __rand__(self: NDArray[np.bool], other: _ArrayLikeBool_co, /) -> NDArray[np.bool]: ... # type: ignore[misc] + @overload + def __rand__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co, /) -> NDArray[unsignedinteger[Any]]: ... # type: ignore[misc] + @overload + def __rand__(self: _ArrayInt_co, other: _ArrayLikeInt_co, /) -> NDArray[signedinteger[Any]]: ... + @overload + def __rand__(self: NDArray[object_], other: Any, /) -> Any: ... + @overload + def __rand__(self: NDArray[Any], other: _ArrayLikeObject_co, /) -> Any: ... + + @overload + def __xor__(self: NDArray[_UnknownType], other: _ArrayLikeUnknown, /) -> NDArray[Any]: ... + @overload + def __xor__(self: NDArray[np.bool], other: _ArrayLikeBool_co, /) -> NDArray[np.bool]: ... # type: ignore[misc] + @overload + def __xor__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co, /) -> NDArray[unsignedinteger[Any]]: ... # type: ignore[misc] + @overload + def __xor__(self: _ArrayInt_co, other: _ArrayLikeInt_co, /) -> NDArray[signedinteger[Any]]: ... + @overload + def __xor__(self: NDArray[object_], other: Any, /) -> Any: ... + @overload + def __xor__(self: NDArray[Any], other: _ArrayLikeObject_co, /) -> Any: ... + + @overload + def __rxor__(self: NDArray[_UnknownType], other: _ArrayLikeUnknown, /) -> NDArray[Any]: ... + @overload + def __rxor__(self: NDArray[np.bool], other: _ArrayLikeBool_co, /) -> NDArray[np.bool]: ... # type: ignore[misc] + @overload + def __rxor__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co, /) -> NDArray[unsignedinteger[Any]]: ... # type: ignore[misc] + @overload + def __rxor__(self: _ArrayInt_co, other: _ArrayLikeInt_co, /) -> NDArray[signedinteger[Any]]: ... + @overload + def __rxor__(self: NDArray[object_], other: Any, /) -> Any: ... + @overload + def __rxor__(self: NDArray[Any], other: _ArrayLikeObject_co, /) -> Any: ... + + @overload + def __or__(self: NDArray[_UnknownType], other: _ArrayLikeUnknown, /) -> NDArray[Any]: ... + @overload + def __or__(self: NDArray[np.bool], other: _ArrayLikeBool_co, /) -> NDArray[np.bool]: ... # type: ignore[misc] + @overload + def __or__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co, /) -> NDArray[unsignedinteger[Any]]: ... # type: ignore[misc] + @overload + def __or__(self: _ArrayInt_co, other: _ArrayLikeInt_co, /) -> NDArray[signedinteger[Any]]: ... + @overload + def __or__(self: NDArray[object_], other: Any, /) -> Any: ... + @overload + def __or__(self: NDArray[Any], other: _ArrayLikeObject_co, /) -> Any: ... + + @overload + def __ror__(self: NDArray[_UnknownType], other: _ArrayLikeUnknown, /) -> NDArray[Any]: ... + @overload + def __ror__(self: NDArray[np.bool], other: _ArrayLikeBool_co, /) -> NDArray[np.bool]: ... # type: ignore[misc] + @overload + def __ror__(self: _ArrayUInt_co, other: _ArrayLikeUInt_co, /) -> NDArray[unsignedinteger[Any]]: ... # type: ignore[misc] + @overload + def __ror__(self: _ArrayInt_co, other: _ArrayLikeInt_co, /) -> NDArray[signedinteger[Any]]: ... + @overload + def __ror__(self: NDArray[object_], other: Any, /) -> Any: ... + @overload + def __ror__(self: NDArray[Any], other: _ArrayLikeObject_co, /) -> Any: ... + + # `np.generic` does not support inplace operations + + # NOTE: Inplace ops generally use "same_kind" casting w.r.t. to the left + # operand. An exception to this rule are unsigned integers though, which + # also accepts a signed integer for the right operand as long it is a 0D + # object and its value is >= 0 + @overload + def __iadd__(self: NDArray[_UnknownType], other: _ArrayLikeUnknown, /) -> NDArray[Any]: ... + @overload + def __iadd__(self: NDArray[np.bool], other: _ArrayLikeBool_co, /) -> NDArray[np.bool]: ... + @overload + def __iadd__(self: NDArray[unsignedinteger[_NBit1]], other: _ArrayLikeUInt_co | _IntLike_co, /) -> NDArray[unsignedinteger[_NBit1]]: ... + @overload + def __iadd__(self: NDArray[signedinteger[_NBit1]], other: _ArrayLikeInt_co, /) -> NDArray[signedinteger[_NBit1]]: ... + @overload + def __iadd__(self: NDArray[floating[_NBit1]], other: _ArrayLikeFloat_co, /) -> NDArray[floating[_NBit1]]: ... + @overload + def __iadd__(self: NDArray[complexfloating[_NBit1, _NBit1]], other: _ArrayLikeComplex_co, /) -> NDArray[complexfloating[_NBit1, _NBit1]]: ... + @overload + def __iadd__(self: NDArray[timedelta64], other: _ArrayLikeTD64_co, /) -> NDArray[timedelta64]: ... + @overload + def __iadd__(self: NDArray[datetime64], other: _ArrayLikeTD64_co, /) -> NDArray[datetime64]: ... + @overload + def __iadd__(self: NDArray[object_], other: Any, /) -> NDArray[object_]: ... + + @overload + def __isub__(self: NDArray[_UnknownType], other: _ArrayLikeUnknown, /) -> NDArray[Any]: ... + @overload + def __isub__(self: NDArray[unsignedinteger[_NBit1]], other: _ArrayLikeUInt_co | _IntLike_co, /) -> NDArray[unsignedinteger[_NBit1]]: ... + @overload + def __isub__(self: NDArray[signedinteger[_NBit1]], other: _ArrayLikeInt_co, /) -> NDArray[signedinteger[_NBit1]]: ... + @overload + def __isub__(self: NDArray[floating[_NBit1]], other: _ArrayLikeFloat_co, /) -> NDArray[floating[_NBit1]]: ... + @overload + def __isub__(self: NDArray[complexfloating[_NBit1, _NBit1]], other: _ArrayLikeComplex_co, /) -> NDArray[complexfloating[_NBit1, _NBit1]]: ... + @overload + def __isub__(self: NDArray[timedelta64], other: _ArrayLikeTD64_co, /) -> NDArray[timedelta64]: ... + @overload + def __isub__(self: NDArray[datetime64], other: _ArrayLikeTD64_co, /) -> NDArray[datetime64]: ... + @overload + def __isub__(self: NDArray[object_], other: Any, /) -> NDArray[object_]: ... + + @overload + def __imul__(self: NDArray[_UnknownType], other: _ArrayLikeUnknown, /) -> NDArray[Any]: ... + @overload + def __imul__(self: NDArray[np.bool], other: _ArrayLikeBool_co, /) -> NDArray[np.bool]: ... + @overload + def __imul__(self: NDArray[unsignedinteger[_NBit1]], other: _ArrayLikeUInt_co | _IntLike_co, /) -> NDArray[unsignedinteger[_NBit1]]: ... + @overload + def __imul__(self: NDArray[signedinteger[_NBit1]], other: _ArrayLikeInt_co, /) -> NDArray[signedinteger[_NBit1]]: ... + @overload + def __imul__(self: NDArray[floating[_NBit1]], other: _ArrayLikeFloat_co, /) -> NDArray[floating[_NBit1]]: ... + @overload + def __imul__(self: NDArray[complexfloating[_NBit1, _NBit1]], other: _ArrayLikeComplex_co, /) -> NDArray[complexfloating[_NBit1, _NBit1]]: ... + @overload + def __imul__(self: NDArray[timedelta64], other: _ArrayLikeFloat_co, /) -> NDArray[timedelta64]: ... + @overload + def __imul__(self: NDArray[object_], other: Any, /) -> NDArray[object_]: ... + + @overload + def __itruediv__(self: NDArray[_UnknownType], other: _ArrayLikeUnknown, /) -> NDArray[Any]: ... + @overload + def __itruediv__(self: NDArray[floating[_NBit1]], other: _ArrayLikeFloat_co, /) -> NDArray[floating[_NBit1]]: ... + @overload + def __itruediv__(self: NDArray[complexfloating[_NBit1, _NBit1]], other: _ArrayLikeComplex_co, /) -> NDArray[complexfloating[_NBit1, _NBit1]]: ... + @overload + def __itruediv__(self: NDArray[timedelta64], other: _ArrayLikeBool_co, /) -> NoReturn: ... + @overload + def __itruediv__(self: NDArray[timedelta64], other: _ArrayLikeInt_co, /) -> NDArray[timedelta64]: ... + @overload + def __itruediv__(self: NDArray[object_], other: Any, /) -> NDArray[object_]: ... + + @overload + def __ifloordiv__(self: NDArray[_UnknownType], other: _ArrayLikeUnknown, /) -> NDArray[Any]: ... + @overload + def __ifloordiv__(self: NDArray[unsignedinteger[_NBit1]], other: _ArrayLikeUInt_co | _IntLike_co, /) -> NDArray[unsignedinteger[_NBit1]]: ... + @overload + def __ifloordiv__(self: NDArray[signedinteger[_NBit1]], other: _ArrayLikeInt_co, /) -> NDArray[signedinteger[_NBit1]]: ... + @overload + def __ifloordiv__(self: NDArray[floating[_NBit1]], other: _ArrayLikeFloat_co, /) -> NDArray[floating[_NBit1]]: ... + @overload + def __ifloordiv__(self: NDArray[complexfloating[_NBit1, _NBit1]], other: _ArrayLikeComplex_co, /) -> NDArray[complexfloating[_NBit1, _NBit1]]: ... + @overload + def __ifloordiv__(self: NDArray[timedelta64], other: _ArrayLikeBool_co, /) -> NoReturn: ... + @overload + def __ifloordiv__(self: NDArray[timedelta64], other: _ArrayLikeInt_co, /) -> NDArray[timedelta64]: ... + @overload + def __ifloordiv__(self: NDArray[object_], other: Any, /) -> NDArray[object_]: ... + + @overload + def __ipow__(self: NDArray[_UnknownType], other: _ArrayLikeUnknown, /) -> NDArray[Any]: ... + @overload + def __ipow__(self: NDArray[unsignedinteger[_NBit1]], other: _ArrayLikeUInt_co | _IntLike_co, /) -> NDArray[unsignedinteger[_NBit1]]: ... + @overload + def __ipow__(self: NDArray[signedinteger[_NBit1]], other: _ArrayLikeInt_co, /) -> NDArray[signedinteger[_NBit1]]: ... + @overload + def __ipow__(self: NDArray[floating[_NBit1]], other: _ArrayLikeFloat_co, /) -> NDArray[floating[_NBit1]]: ... + @overload + def __ipow__(self: NDArray[complexfloating[_NBit1, _NBit1]], other: _ArrayLikeComplex_co, /) -> NDArray[complexfloating[_NBit1, _NBit1]]: ... + @overload + def __ipow__(self: NDArray[object_], other: Any, /) -> NDArray[object_]: ... + + @overload + def __imod__(self: NDArray[_UnknownType], other: _ArrayLikeUnknown, /) -> NDArray[Any]: ... + @overload + def __imod__(self: NDArray[unsignedinteger[_NBit1]], other: _ArrayLikeUInt_co | _IntLike_co, /) -> NDArray[unsignedinteger[_NBit1]]: ... + @overload + def __imod__(self: NDArray[signedinteger[_NBit1]], other: _ArrayLikeInt_co, /) -> NDArray[signedinteger[_NBit1]]: ... + @overload + def __imod__(self: NDArray[floating[_NBit1]], other: _ArrayLikeFloat_co, /) -> NDArray[floating[_NBit1]]: ... + @overload + def __imod__(self: NDArray[timedelta64], other: _SupportsArray[_dtype[timedelta64]] | _NestedSequence[_SupportsArray[_dtype[timedelta64]]], /) -> NDArray[timedelta64]: ... + @overload + def __imod__(self: NDArray[object_], other: Any, /) -> NDArray[object_]: ... + + @overload + def __ilshift__(self: NDArray[_UnknownType], other: _ArrayLikeUnknown, /) -> NDArray[Any]: ... + @overload + def __ilshift__(self: NDArray[unsignedinteger[_NBit1]], other: _ArrayLikeUInt_co | _IntLike_co, /) -> NDArray[unsignedinteger[_NBit1]]: ... + @overload + def __ilshift__(self: NDArray[signedinteger[_NBit1]], other: _ArrayLikeInt_co, /) -> NDArray[signedinteger[_NBit1]]: ... + @overload + def __ilshift__(self: NDArray[object_], other: Any, /) -> NDArray[object_]: ... + + @overload + def __irshift__(self: NDArray[_UnknownType], other: _ArrayLikeUnknown, /) -> NDArray[Any]: ... + @overload + def __irshift__(self: NDArray[unsignedinteger[_NBit1]], other: _ArrayLikeUInt_co | _IntLike_co, /) -> NDArray[unsignedinteger[_NBit1]]: ... + @overload + def __irshift__(self: NDArray[signedinteger[_NBit1]], other: _ArrayLikeInt_co, /) -> NDArray[signedinteger[_NBit1]]: ... + @overload + def __irshift__(self: NDArray[object_], other: Any, /) -> NDArray[object_]: ... + + @overload + def __iand__(self: NDArray[_UnknownType], other: _ArrayLikeUnknown, /) -> NDArray[Any]: ... + @overload + def __iand__(self: NDArray[np.bool], other: _ArrayLikeBool_co, /) -> NDArray[np.bool]: ... + @overload + def __iand__(self: NDArray[unsignedinteger[_NBit1]], other: _ArrayLikeUInt_co | _IntLike_co, /) -> NDArray[unsignedinteger[_NBit1]]: ... + @overload + def __iand__(self: NDArray[signedinteger[_NBit1]], other: _ArrayLikeInt_co, /) -> NDArray[signedinteger[_NBit1]]: ... + @overload + def __iand__(self: NDArray[object_], other: Any, /) -> NDArray[object_]: ... + + @overload + def __ixor__(self: NDArray[_UnknownType], other: _ArrayLikeUnknown, /) -> NDArray[Any]: ... + @overload + def __ixor__(self: NDArray[np.bool], other: _ArrayLikeBool_co, /) -> NDArray[np.bool]: ... + @overload + def __ixor__(self: NDArray[unsignedinteger[_NBit1]], other: _ArrayLikeUInt_co | _IntLike_co, /) -> NDArray[unsignedinteger[_NBit1]]: ... + @overload + def __ixor__(self: NDArray[signedinteger[_NBit1]], other: _ArrayLikeInt_co, /) -> NDArray[signedinteger[_NBit1]]: ... + @overload + def __ixor__(self: NDArray[object_], other: Any, /) -> NDArray[object_]: ... + + @overload + def __ior__(self: NDArray[_UnknownType], other: _ArrayLikeUnknown, /) -> NDArray[Any]: ... + @overload + def __ior__(self: NDArray[np.bool], other: _ArrayLikeBool_co, /) -> NDArray[np.bool]: ... + @overload + def __ior__(self: NDArray[unsignedinteger[_NBit1]], other: _ArrayLikeUInt_co | _IntLike_co, /) -> NDArray[unsignedinteger[_NBit1]]: ... + @overload + def __ior__(self: NDArray[signedinteger[_NBit1]], other: _ArrayLikeInt_co, /) -> NDArray[signedinteger[_NBit1]]: ... + @overload + def __ior__(self: NDArray[object_], other: Any, /) -> NDArray[object_]: ... + + @overload + def __imatmul__(self: NDArray[_UnknownType], other: _ArrayLikeUnknown, /) -> NDArray[Any]: ... + @overload + def __imatmul__(self: NDArray[np.bool], other: _ArrayLikeBool_co, /) -> NDArray[np.bool]: ... + @overload + def __imatmul__(self: NDArray[unsignedinteger[_NBit1]], other: _ArrayLikeUInt_co, /) -> NDArray[unsignedinteger[_NBit1]]: ... + @overload + def __imatmul__(self: NDArray[signedinteger[_NBit1]], other: _ArrayLikeInt_co, /) -> NDArray[signedinteger[_NBit1]]: ... + @overload + def __imatmul__(self: NDArray[floating[_NBit1]], other: _ArrayLikeFloat_co, /) -> NDArray[floating[_NBit1]]: ... + @overload + def __imatmul__(self: NDArray[complexfloating[_NBit1, _NBit1]], other: _ArrayLikeComplex_co, /) -> NDArray[complexfloating[_NBit1, _NBit1]]: ... + @overload + def __imatmul__(self: NDArray[object_], other: Any, /) -> NDArray[object_]: ... + + def __dlpack__( + self: NDArray[number[Any]], + *, + stream: int | Any | None = ..., + max_version: tuple[int, int] | None = ..., + dl_device: tuple[int, L[0]] | None = ..., + copy: bool | None = ..., + ) -> _PyCapsule: ... + + def __dlpack_device__(self) -> tuple[int, L[0]]: ... + + @overload + def to_device(self: NDArray[_SCT], device: L["cpu"], /, *, stream: None | int | Any = ...) -> NDArray[_SCT]: ... + @overload + def to_device(self: NDArray[Any], device: L["cpu"], /, *, stream: None | int | Any = ...) -> NDArray[Any]: ... + + def bitwise_count( + self, + out: None | NDArray[Any] = ..., + *, + where: _ArrayLikeBool_co = ..., + casting: _CastingKind = ..., + order: _OrderKACF = ..., + dtype: DTypeLike = ..., + subok: builtins.bool = ..., + ) -> NDArray[Any]: ... + + # Keep `dtype` at the bottom to avoid name conflicts with `np.dtype` + @property + def dtype(self) -> _DType_co: ... + +# NOTE: while `np.generic` is not technically an instance of `ABCMeta`, +# the `@abstractmethod` decorator is herein used to (forcefully) deny +# the creation of `np.generic` instances. +# The `# type: ignore` comments are necessary to silence mypy errors regarding +# the missing `ABCMeta` metaclass. + +# See https://github.com/numpy/numpy-stubs/pull/80 for more details. + +_ScalarType = TypeVar("_ScalarType", bound=generic) +_NBit1 = TypeVar("_NBit1", bound=NBitBase) +_NBit2 = TypeVar("_NBit2", bound=NBitBase) + +class generic(_ArrayOrScalarCommon): + @abstractmethod + def __init__(self, *args: Any, **kwargs: Any) -> None: ... + # TODO: use `tuple[()]` as shape type once covariant (#26081) + @overload + def __array__(self: _ScalarType, dtype: None = ..., /) -> NDArray[_ScalarType]: ... + @overload + def __array__(self, dtype: _DType, /) -> ndarray[Any, _DType]: ... + def __hash__(self) -> int: ... + @property + def base(self) -> None: ... + @property + def ndim(self) -> L[0]: ... + @property + def size(self) -> L[1]: ... + @property + def shape(self) -> tuple[()]: ... + @property + def strides(self) -> tuple[()]: ... + def byteswap(self: _ScalarType, inplace: L[False] = ...) -> _ScalarType: ... + @property + def flat(self: _ScalarType) -> flatiter[NDArray[_ScalarType]]: ... + + if sys.version_info >= (3, 12): + def __buffer__(self, flags: int, /) -> memoryview: ... + + def to_device(self: _ScalarType, device: L["cpu"], /, *, stream: None | int | Any = ...) -> _ScalarType: ... + + @overload + def astype( + self, + dtype: _DTypeLike[_ScalarType], + order: _OrderKACF = ..., + casting: _CastingKind = ..., + subok: builtins.bool = ..., + copy: builtins.bool | _CopyMode = ..., + ) -> _ScalarType: ... + @overload + def astype( + self, + dtype: DTypeLike, + order: _OrderKACF = ..., + casting: _CastingKind = ..., + subok: builtins.bool = ..., + copy: builtins.bool | _CopyMode = ..., + ) -> Any: ... + + # NOTE: `view` will perform a 0D->scalar cast, + # thus the array `type` is irrelevant to the output type + @overload + def view( + self: _ScalarType, + type: type[NDArray[Any]] = ..., + ) -> _ScalarType: ... + @overload + def view( + self, + dtype: _DTypeLike[_ScalarType], + type: type[NDArray[Any]] = ..., + ) -> _ScalarType: ... + @overload + def view( + self, + dtype: DTypeLike, + type: type[NDArray[Any]] = ..., + ) -> Any: ... + + @overload + def getfield( + self, + dtype: _DTypeLike[_ScalarType], + offset: SupportsIndex = ... + ) -> _ScalarType: ... + @overload + def getfield( + self, + dtype: DTypeLike, + offset: SupportsIndex = ... + ) -> Any: ... + + def item( + self, args: L[0] | tuple[()] | tuple[L[0]] = ..., /, + ) -> Any: ... + + @overload + def take( # type: ignore[misc] + self: _ScalarType, + indices: _IntLike_co, + axis: None | SupportsIndex = ..., + out: None = ..., + mode: _ModeKind = ..., + ) -> _ScalarType: ... + @overload + def take( # type: ignore[misc] + self: _ScalarType, + indices: _ArrayLikeInt_co, + axis: None | SupportsIndex = ..., + out: None = ..., + mode: _ModeKind = ..., + ) -> NDArray[_ScalarType]: ... + @overload + def take( + self, + indices: _ArrayLikeInt_co, + axis: None | SupportsIndex = ..., + out: _NdArraySubClass = ..., + mode: _ModeKind = ..., + ) -> _NdArraySubClass: ... + + def repeat( + self: _ScalarType, + repeats: _ArrayLikeInt_co, + axis: None | SupportsIndex = ..., + ) -> NDArray[_ScalarType]: ... + + def flatten( + self: _ScalarType, + order: _OrderKACF = ..., + ) -> NDArray[_ScalarType]: ... + + def ravel( + self: _ScalarType, + order: _OrderKACF = ..., + ) -> NDArray[_ScalarType]: ... + + @overload + def reshape( + self: _ScalarType, shape: _ShapeLike, /, *, order: _OrderACF = ... + ) -> NDArray[_ScalarType]: ... + @overload + def reshape( + self: _ScalarType, *shape: SupportsIndex, order: _OrderACF = ... + ) -> NDArray[_ScalarType]: ... + + def bitwise_count( + self, + out: None | NDArray[Any] = ..., + *, + where: _ArrayLikeBool_co = ..., + casting: _CastingKind = ..., + order: _OrderKACF = ..., + dtype: DTypeLike = ..., + subok: builtins.bool = ..., + ) -> Any: ... + + def squeeze( + self: _ScalarType, axis: None | L[0] | tuple[()] = ... + ) -> _ScalarType: ... + def transpose(self: _ScalarType, axes: None | tuple[()] = ..., /) -> _ScalarType: ... + # Keep `dtype` at the bottom to avoid name conflicts with `np.dtype` + @property + def dtype(self: _ScalarType) -> _dtype[_ScalarType]: ... + +class number(generic, Generic[_NBit1]): # type: ignore + @property + def real(self: _ArraySelf) -> _ArraySelf: ... + @property + def imag(self: _ArraySelf) -> _ArraySelf: ... + def __class_getitem__(cls, item: Any, /) -> GenericAlias: ... + def __int__(self) -> int: ... + def __float__(self) -> float: ... + def __complex__(self) -> complex: ... + def __neg__(self: _ArraySelf) -> _ArraySelf: ... + def __pos__(self: _ArraySelf) -> _ArraySelf: ... + def __abs__(self: _ArraySelf) -> _ArraySelf: ... + # Ensure that objects annotated as `number` support arithmetic operations + __add__: _NumberOp + __radd__: _NumberOp + __sub__: _NumberOp + __rsub__: _NumberOp + __mul__: _NumberOp + __rmul__: _NumberOp + __floordiv__: _NumberOp + __rfloordiv__: _NumberOp + __pow__: _NumberOp + __rpow__: _NumberOp + __truediv__: _NumberOp + __rtruediv__: _NumberOp + __lt__: _ComparisonOpLT[_NumberLike_co, _ArrayLikeNumber_co] + __le__: _ComparisonOpLE[_NumberLike_co, _ArrayLikeNumber_co] + __gt__: _ComparisonOpGT[_NumberLike_co, _ArrayLikeNumber_co] + __ge__: _ComparisonOpGE[_NumberLike_co, _ArrayLikeNumber_co] + +class bool(generic): + def __init__(self, value: object = ..., /) -> None: ... + def item( + self, args: L[0] | tuple[()] | tuple[L[0]] = ..., /, + ) -> builtins.bool: ... + def tolist(self) -> builtins.bool: ... + @property + def real(self: _ArraySelf) -> _ArraySelf: ... + @property + def imag(self: _ArraySelf) -> _ArraySelf: ... + def __int__(self) -> int: ... + def __float__(self) -> float: ... + def __complex__(self) -> complex: ... + def __abs__(self: _ArraySelf) -> _ArraySelf: ... + __add__: _BoolOp[np.bool] + __radd__: _BoolOp[np.bool] + __sub__: _BoolSub + __rsub__: _BoolSub + __mul__: _BoolOp[np.bool] + __rmul__: _BoolOp[np.bool] + __floordiv__: _BoolOp[int8] + __rfloordiv__: _BoolOp[int8] + __pow__: _BoolOp[int8] + __rpow__: _BoolOp[int8] + __truediv__: _BoolTrueDiv + __rtruediv__: _BoolTrueDiv + def __invert__(self) -> np.bool: ... + __lshift__: _BoolBitOp[int8] + __rlshift__: _BoolBitOp[int8] + __rshift__: _BoolBitOp[int8] + __rrshift__: _BoolBitOp[int8] + __and__: _BoolBitOp[np.bool] + __rand__: _BoolBitOp[np.bool] + __xor__: _BoolBitOp[np.bool] + __rxor__: _BoolBitOp[np.bool] + __or__: _BoolBitOp[np.bool] + __ror__: _BoolBitOp[np.bool] + __mod__: _BoolMod + __rmod__: _BoolMod + __divmod__: _BoolDivMod + __rdivmod__: _BoolDivMod + __lt__: _ComparisonOpLT[_NumberLike_co, _ArrayLikeNumber_co] + __le__: _ComparisonOpLE[_NumberLike_co, _ArrayLikeNumber_co] + __gt__: _ComparisonOpGT[_NumberLike_co, _ArrayLikeNumber_co] + __ge__: _ComparisonOpGE[_NumberLike_co, _ArrayLikeNumber_co] + +bool_: TypeAlias = bool + +@final +class object_(generic): + def __init__(self, value: object = ..., /) -> None: ... + @property + def real(self: _ArraySelf) -> _ArraySelf: ... + @property + def imag(self: _ArraySelf) -> _ArraySelf: ... + # The 3 protocols below may or may not raise, + # depending on the underlying object + def __int__(self) -> int: ... + def __float__(self) -> float: ... + def __complex__(self) -> complex: ... + + if sys.version_info >= (3, 12): + def __release_buffer__(self, buffer: memoryview, /) -> None: ... + +# The `datetime64` constructors requires an object with the three attributes below, +# and thus supports datetime duck typing +class _DatetimeScalar(Protocol): + @property + def day(self) -> int: ... + @property + def month(self) -> int: ... + @property + def year(self) -> int: ... + +# TODO: `item`/`tolist` returns either `dt.date`, `dt.datetime` or `int` +# depending on the unit +class datetime64(generic): + @overload + def __init__( + self, + value: None | datetime64 | _CharLike_co | _DatetimeScalar = ..., + format: _CharLike_co | tuple[_CharLike_co, _IntLike_co] = ..., + /, + ) -> None: ... + @overload + def __init__( + self, + value: int, + format: _CharLike_co | tuple[_CharLike_co, _IntLike_co], + /, + ) -> None: ... + def __add__(self, other: _TD64Like_co, /) -> datetime64: ... + def __radd__(self, other: _TD64Like_co, /) -> datetime64: ... + @overload + def __sub__(self, other: datetime64, /) -> timedelta64: ... + @overload + def __sub__(self, other: _TD64Like_co, /) -> datetime64: ... + def __rsub__(self, other: datetime64, /) -> timedelta64: ... + __lt__: _ComparisonOpLT[datetime64, _ArrayLikeDT64_co] + __le__: _ComparisonOpLE[datetime64, _ArrayLikeDT64_co] + __gt__: _ComparisonOpGT[datetime64, _ArrayLikeDT64_co] + __ge__: _ComparisonOpGE[datetime64, _ArrayLikeDT64_co] + +_IntValue: TypeAlias = SupportsInt | _CharLike_co | SupportsIndex +_FloatValue: TypeAlias = None | _CharLike_co | SupportsFloat | SupportsIndex +_ComplexValue: TypeAlias = ( + None + | _CharLike_co + | SupportsFloat + | SupportsComplex + | SupportsIndex + | complex # `complex` is not a subtype of `SupportsComplex` +) + +class integer(number[_NBit1]): # type: ignore + @property + def numerator(self: _ScalarType) -> _ScalarType: ... + @property + def denominator(self) -> L[1]: ... + @overload + def __round__(self, ndigits: None = ..., /) -> int: ... + @overload + def __round__(self: _ScalarType, ndigits: SupportsIndex, /) -> _ScalarType: ... + + # NOTE: `__index__` is technically defined in the bottom-most + # sub-classes (`int64`, `uint32`, etc) + def item( + self, args: L[0] | tuple[()] | tuple[L[0]] = ..., /, + ) -> int: ... + def tolist(self) -> int: ... + def is_integer(self) -> L[True]: ... + def bit_count(self: _ScalarType) -> int: ... + def __index__(self) -> int: ... + __truediv__: _IntTrueDiv[_NBit1] + __rtruediv__: _IntTrueDiv[_NBit1] + def __mod__(self, value: _IntLike_co, /) -> integer[Any]: ... + def __rmod__(self, value: _IntLike_co, /) -> integer[Any]: ... + def __invert__(self: _IntType) -> _IntType: ... + # Ensure that objects annotated as `integer` support bit-wise operations + def __lshift__(self, other: _IntLike_co, /) -> integer[Any]: ... + def __rlshift__(self, other: _IntLike_co, /) -> integer[Any]: ... + def __rshift__(self, other: _IntLike_co, /) -> integer[Any]: ... + def __rrshift__(self, other: _IntLike_co, /) -> integer[Any]: ... + def __and__(self, other: _IntLike_co, /) -> integer[Any]: ... + def __rand__(self, other: _IntLike_co, /) -> integer[Any]: ... + def __or__(self, other: _IntLike_co, /) -> integer[Any]: ... + def __ror__(self, other: _IntLike_co, /) -> integer[Any]: ... + def __xor__(self, other: _IntLike_co, /) -> integer[Any]: ... + def __rxor__(self, other: _IntLike_co, /) -> integer[Any]: ... + +class signedinteger(integer[_NBit1]): + def __init__(self, value: _IntValue = ..., /) -> None: ... + __add__: _SignedIntOp[_NBit1] + __radd__: _SignedIntOp[_NBit1] + __sub__: _SignedIntOp[_NBit1] + __rsub__: _SignedIntOp[_NBit1] + __mul__: _SignedIntOp[_NBit1] + __rmul__: _SignedIntOp[_NBit1] + __floordiv__: _SignedIntOp[_NBit1] + __rfloordiv__: _SignedIntOp[_NBit1] + __pow__: _SignedIntOp[_NBit1] + __rpow__: _SignedIntOp[_NBit1] + __lshift__: _SignedIntBitOp[_NBit1] + __rlshift__: _SignedIntBitOp[_NBit1] + __rshift__: _SignedIntBitOp[_NBit1] + __rrshift__: _SignedIntBitOp[_NBit1] + __and__: _SignedIntBitOp[_NBit1] + __rand__: _SignedIntBitOp[_NBit1] + __xor__: _SignedIntBitOp[_NBit1] + __rxor__: _SignedIntBitOp[_NBit1] + __or__: _SignedIntBitOp[_NBit1] + __ror__: _SignedIntBitOp[_NBit1] + __mod__: _SignedIntMod[_NBit1] + __rmod__: _SignedIntMod[_NBit1] + __divmod__: _SignedIntDivMod[_NBit1] + __rdivmod__: _SignedIntDivMod[_NBit1] + +int8 = signedinteger[_8Bit] +int16 = signedinteger[_16Bit] +int32 = signedinteger[_32Bit] +int64 = signedinteger[_64Bit] + +byte = signedinteger[_NBitByte] +short = signedinteger[_NBitShort] +intc = signedinteger[_NBitIntC] +intp = signedinteger[_NBitIntP] +int_ = intp +long = signedinteger[_NBitLong] +longlong = signedinteger[_NBitLongLong] + +# TODO: `item`/`tolist` returns either `dt.timedelta` or `int` +# depending on the unit +class timedelta64(generic): + def __init__( + self, + value: None | int | _CharLike_co | dt.timedelta | timedelta64 = ..., + format: _CharLike_co | tuple[_CharLike_co, _IntLike_co] = ..., + /, + ) -> None: ... + @property + def numerator(self: _ScalarType) -> _ScalarType: ... + @property + def denominator(self) -> L[1]: ... + + # NOTE: Only a limited number of units support conversion + # to builtin scalar types: `Y`, `M`, `ns`, `ps`, `fs`, `as` + def __int__(self) -> int: ... + def __float__(self) -> float: ... + def __complex__(self) -> complex: ... + def __neg__(self: _ArraySelf) -> _ArraySelf: ... + def __pos__(self: _ArraySelf) -> _ArraySelf: ... + def __abs__(self: _ArraySelf) -> _ArraySelf: ... + def __add__(self, other: _TD64Like_co, /) -> timedelta64: ... + def __radd__(self, other: _TD64Like_co, /) -> timedelta64: ... + def __sub__(self, other: _TD64Like_co, /) -> timedelta64: ... + def __rsub__(self, other: _TD64Like_co, /) -> timedelta64: ... + def __mul__(self, other: _FloatLike_co, /) -> timedelta64: ... + def __rmul__(self, other: _FloatLike_co, /) -> timedelta64: ... + __truediv__: _TD64Div[float64] + __floordiv__: _TD64Div[int64] + def __rtruediv__(self, other: timedelta64, /) -> float64: ... + def __rfloordiv__(self, other: timedelta64, /) -> int64: ... + def __mod__(self, other: timedelta64, /) -> timedelta64: ... + def __rmod__(self, other: timedelta64, /) -> timedelta64: ... + def __divmod__(self, other: timedelta64, /) -> tuple[int64, timedelta64]: ... + def __rdivmod__(self, other: timedelta64, /) -> tuple[int64, timedelta64]: ... + __lt__: _ComparisonOpLT[_TD64Like_co, _ArrayLikeTD64_co] + __le__: _ComparisonOpLE[_TD64Like_co, _ArrayLikeTD64_co] + __gt__: _ComparisonOpGT[_TD64Like_co, _ArrayLikeTD64_co] + __ge__: _ComparisonOpGE[_TD64Like_co, _ArrayLikeTD64_co] + +class unsignedinteger(integer[_NBit1]): + # NOTE: `uint64 + signedinteger -> float64` + def __init__(self, value: _IntValue = ..., /) -> None: ... + __add__: _UnsignedIntOp[_NBit1] + __radd__: _UnsignedIntOp[_NBit1] + __sub__: _UnsignedIntOp[_NBit1] + __rsub__: _UnsignedIntOp[_NBit1] + __mul__: _UnsignedIntOp[_NBit1] + __rmul__: _UnsignedIntOp[_NBit1] + __floordiv__: _UnsignedIntOp[_NBit1] + __rfloordiv__: _UnsignedIntOp[_NBit1] + __pow__: _UnsignedIntOp[_NBit1] + __rpow__: _UnsignedIntOp[_NBit1] + __lshift__: _UnsignedIntBitOp[_NBit1] + __rlshift__: _UnsignedIntBitOp[_NBit1] + __rshift__: _UnsignedIntBitOp[_NBit1] + __rrshift__: _UnsignedIntBitOp[_NBit1] + __and__: _UnsignedIntBitOp[_NBit1] + __rand__: _UnsignedIntBitOp[_NBit1] + __xor__: _UnsignedIntBitOp[_NBit1] + __rxor__: _UnsignedIntBitOp[_NBit1] + __or__: _UnsignedIntBitOp[_NBit1] + __ror__: _UnsignedIntBitOp[_NBit1] + __mod__: _UnsignedIntMod[_NBit1] + __rmod__: _UnsignedIntMod[_NBit1] + __divmod__: _UnsignedIntDivMod[_NBit1] + __rdivmod__: _UnsignedIntDivMod[_NBit1] + +uint8: TypeAlias = unsignedinteger[_8Bit] +uint16: TypeAlias = unsignedinteger[_16Bit] +uint32: TypeAlias = unsignedinteger[_32Bit] +uint64: TypeAlias = unsignedinteger[_64Bit] + +ubyte: TypeAlias = unsignedinteger[_NBitByte] +ushort: TypeAlias = unsignedinteger[_NBitShort] +uintc: TypeAlias = unsignedinteger[_NBitIntC] +uintp: TypeAlias = unsignedinteger[_NBitIntP] +uint: TypeAlias = uintp +ulong: TypeAlias = unsignedinteger[_NBitLong] +ulonglong: TypeAlias = unsignedinteger[_NBitLongLong] + +class inexact(number[_NBit1]): # type: ignore + def __getnewargs__(self: inexact[_64Bit]) -> tuple[float, ...]: ... + +_IntType = TypeVar("_IntType", bound=integer[Any]) +_FloatType = TypeVar('_FloatType', bound=floating[Any]) + +class floating(inexact[_NBit1]): + def __init__(self, value: _FloatValue = ..., /) -> None: ... + def item( + self, args: L[0] | tuple[()] | tuple[L[0]] = ..., + /, + ) -> float: ... + def tolist(self) -> float: ... + def is_integer(self) -> builtins.bool: ... + def hex(self: float64) -> str: ... + @classmethod + def fromhex(cls: type[float64], string: str, /) -> float64: ... + def as_integer_ratio(self) -> tuple[int, int]: ... + def __ceil__(self: float64) -> int: ... + def __floor__(self: float64) -> int: ... + def __trunc__(self: float64) -> int: ... + def __getnewargs__(self: float64) -> tuple[float]: ... + def __getformat__(self: float64, typestr: L["double", "float"], /) -> str: ... + @overload + def __round__(self, ndigits: None = ..., /) -> int: ... + @overload + def __round__(self: _ScalarType, ndigits: SupportsIndex, /) -> _ScalarType: ... + __add__: _FloatOp[_NBit1] + __radd__: _FloatOp[_NBit1] + __sub__: _FloatOp[_NBit1] + __rsub__: _FloatOp[_NBit1] + __mul__: _FloatOp[_NBit1] + __rmul__: _FloatOp[_NBit1] + __truediv__: _FloatOp[_NBit1] + __rtruediv__: _FloatOp[_NBit1] + __floordiv__: _FloatOp[_NBit1] + __rfloordiv__: _FloatOp[_NBit1] + __pow__: _FloatOp[_NBit1] + __rpow__: _FloatOp[_NBit1] + __mod__: _FloatMod[_NBit1] + __rmod__: _FloatMod[_NBit1] + __divmod__: _FloatDivMod[_NBit1] + __rdivmod__: _FloatDivMod[_NBit1] + +float16: TypeAlias = floating[_16Bit] +float32: TypeAlias = floating[_32Bit] +float64: TypeAlias = floating[_64Bit] + +half: TypeAlias = floating[_NBitHalf] +single: TypeAlias = floating[_NBitSingle] +double: TypeAlias = floating[_NBitDouble] +longdouble: TypeAlias = floating[_NBitLongDouble] + +# The main reason for `complexfloating` having two typevars is cosmetic. +# It is used to clarify why `complex128`s precision is `_64Bit`, the latter +# describing the two 64 bit floats representing its real and imaginary component + +class complexfloating(inexact[_NBit1], Generic[_NBit1, _NBit2]): + def __init__(self, value: _ComplexValue = ..., /) -> None: ... + def item( + self, args: L[0] | tuple[()] | tuple[L[0]] = ..., /, + ) -> complex: ... + def tolist(self) -> complex: ... + @property + def real(self) -> floating[_NBit1]: ... # type: ignore[override] + @property + def imag(self) -> floating[_NBit2]: ... # type: ignore[override] + def __abs__(self) -> floating[_NBit1]: ... # type: ignore[override] + def __getnewargs__(self: complex128) -> tuple[float, float]: ... + # NOTE: Deprecated + # def __round__(self, ndigits=...): ... + __add__: _ComplexOp[_NBit1] + __radd__: _ComplexOp[_NBit1] + __sub__: _ComplexOp[_NBit1] + __rsub__: _ComplexOp[_NBit1] + __mul__: _ComplexOp[_NBit1] + __rmul__: _ComplexOp[_NBit1] + __truediv__: _ComplexOp[_NBit1] + __rtruediv__: _ComplexOp[_NBit1] + __pow__: _ComplexOp[_NBit1] + __rpow__: _ComplexOp[_NBit1] + +complex64: TypeAlias = complexfloating[_32Bit, _32Bit] +complex128: TypeAlias = complexfloating[_64Bit, _64Bit] + +csingle: TypeAlias = complexfloating[_NBitSingle, _NBitSingle] +cdouble: TypeAlias = complexfloating[_NBitDouble, _NBitDouble] +clongdouble: TypeAlias = complexfloating[_NBitLongDouble, _NBitLongDouble] + +class flexible(generic): ... # type: ignore + +# TODO: `item`/`tolist` returns either `bytes` or `tuple` +# depending on whether or not it's used as an opaque bytes sequence +# or a structure +class void(flexible): + @overload + def __init__(self, value: _IntLike_co | bytes, /, dtype : None = ...) -> None: ... + @overload + def __init__(self, value: Any, /, dtype: _DTypeLikeVoid) -> None: ... + @property + def real(self: _ArraySelf) -> _ArraySelf: ... + @property + def imag(self: _ArraySelf) -> _ArraySelf: ... + def setfield( + self, val: ArrayLike, dtype: DTypeLike, offset: int = ... + ) -> None: ... + @overload + def __getitem__(self, key: str | SupportsIndex, /) -> Any: ... + @overload + def __getitem__(self, key: list[str], /) -> void: ... + def __setitem__( + self, + key: str | list[str] | SupportsIndex, + value: ArrayLike, + /, + ) -> None: ... + +class character(flexible): # type: ignore + def __int__(self) -> int: ... + def __float__(self) -> float: ... + +# NOTE: Most `np.bytes_` / `np.str_` methods return their +# builtin `bytes` / `str` counterpart + +class bytes_(character, bytes): + @overload + def __init__(self, value: object = ..., /) -> None: ... + @overload + def __init__( + self, value: str, /, encoding: str = ..., errors: str = ... + ) -> None: ... + def item( + self, args: L[0] | tuple[()] | tuple[L[0]] = ..., /, + ) -> bytes: ... + def tolist(self) -> bytes: ... + +class str_(character, str): + @overload + def __init__(self, value: object = ..., /) -> None: ... + @overload + def __init__( + self, value: bytes, /, encoding: str = ..., errors: str = ... + ) -> None: ... + def item( + self, args: L[0] | tuple[()] | tuple[L[0]] = ..., /, + ) -> str: ... + def tolist(self) -> str: ... + +# +# Constants +# + +e: Final[float] +euler_gamma: Final[float] +inf: Final[float] +nan: Final[float] +pi: Final[float] + +little_endian: Final[builtins.bool] +True_: Final[np.bool] +False_: Final[np.bool] + +newaxis: None + +# See `numpy._typing._ufunc` for more concrete nin-/nout-specific stubs +@final +class ufunc: + @property + def __name__(self) -> LiteralString: ... + @property + def __doc__(self) -> str: ... + @property + def nin(self) -> int: ... + @property + def nout(self) -> int: ... + @property + def nargs(self) -> int: ... + @property + def ntypes(self) -> int: ... + @property + def types(self) -> list[LiteralString]: ... + # Broad return type because it has to encompass things like + # + # >>> np.logical_and.identity is True + # True + # >>> np.add.identity is 0 + # True + # >>> np.sin.identity is None + # True + # + # and any user-defined ufuncs. + @property + def identity(self) -> Any: ... + # This is None for ufuncs and a string for gufuncs. + @property + def signature(self) -> None | LiteralString: ... + + def __call__(self, *args: Any, **kwargs: Any) -> Any: ... + # The next four methods will always exist, but they will just + # raise a ValueError ufuncs with that don't accept two input + # arguments and return one output argument. Because of that we + # can't type them very precisely. + def reduce(self, /, *args: Any, **kwargs: Any) -> NoReturn | Any: ... + def accumulate(self, /, *args: Any, **kwargs: Any) -> NoReturn | NDArray[Any]: ... + def reduceat(self, /, *args: Any, **kwargs: Any) -> NoReturn | NDArray[Any]: ... + def outer(self, *args: Any, **kwargs: Any) -> NoReturn | Any: ... + # Similarly at won't be defined for ufuncs that return multiple + # outputs, so we can't type it very precisely. + def at(self, /, *args: Any, **kwargs: Any) -> NoReturn | None: ... + +# Parameters: `__name__`, `ntypes` and `identity` +absolute: _UFunc_Nin1_Nout1[L['absolute'], L[20], None] +add: _UFunc_Nin2_Nout1[L['add'], L[22], L[0]] +arccos: _UFunc_Nin1_Nout1[L['arccos'], L[8], None] +arccosh: _UFunc_Nin1_Nout1[L['arccosh'], L[8], None] +arcsin: _UFunc_Nin1_Nout1[L['arcsin'], L[8], None] +arcsinh: _UFunc_Nin1_Nout1[L['arcsinh'], L[8], None] +arctan2: _UFunc_Nin2_Nout1[L['arctan2'], L[5], None] +arctan: _UFunc_Nin1_Nout1[L['arctan'], L[8], None] +arctanh: _UFunc_Nin1_Nout1[L['arctanh'], L[8], None] +bitwise_and: _UFunc_Nin2_Nout1[L['bitwise_and'], L[12], L[-1]] +bitwise_count: _UFunc_Nin1_Nout1[L['bitwise_count'], L[11], None] +bitwise_not: _UFunc_Nin1_Nout1[L['invert'], L[12], None] +bitwise_or: _UFunc_Nin2_Nout1[L['bitwise_or'], L[12], L[0]] +bitwise_xor: _UFunc_Nin2_Nout1[L['bitwise_xor'], L[12], L[0]] +cbrt: _UFunc_Nin1_Nout1[L['cbrt'], L[5], None] +ceil: _UFunc_Nin1_Nout1[L['ceil'], L[7], None] +conj: _UFunc_Nin1_Nout1[L['conjugate'], L[18], None] +conjugate: _UFunc_Nin1_Nout1[L['conjugate'], L[18], None] +copysign: _UFunc_Nin2_Nout1[L['copysign'], L[4], None] +cos: _UFunc_Nin1_Nout1[L['cos'], L[9], None] +cosh: _UFunc_Nin1_Nout1[L['cosh'], L[8], None] +deg2rad: _UFunc_Nin1_Nout1[L['deg2rad'], L[5], None] +degrees: _UFunc_Nin1_Nout1[L['degrees'], L[5], None] +divide: _UFunc_Nin2_Nout1[L['true_divide'], L[11], None] +divmod: _UFunc_Nin2_Nout2[L['divmod'], L[15], None] +equal: _UFunc_Nin2_Nout1[L['equal'], L[23], None] +exp2: _UFunc_Nin1_Nout1[L['exp2'], L[8], None] +exp: _UFunc_Nin1_Nout1[L['exp'], L[10], None] +expm1: _UFunc_Nin1_Nout1[L['expm1'], L[8], None] +fabs: _UFunc_Nin1_Nout1[L['fabs'], L[5], None] +float_power: _UFunc_Nin2_Nout1[L['float_power'], L[4], None] +floor: _UFunc_Nin1_Nout1[L['floor'], L[7], None] +floor_divide: _UFunc_Nin2_Nout1[L['floor_divide'], L[21], None] +fmax: _UFunc_Nin2_Nout1[L['fmax'], L[21], None] +fmin: _UFunc_Nin2_Nout1[L['fmin'], L[21], None] +fmod: _UFunc_Nin2_Nout1[L['fmod'], L[15], None] +frexp: _UFunc_Nin1_Nout2[L['frexp'], L[4], None] +gcd: _UFunc_Nin2_Nout1[L['gcd'], L[11], L[0]] +greater: _UFunc_Nin2_Nout1[L['greater'], L[23], None] +greater_equal: _UFunc_Nin2_Nout1[L['greater_equal'], L[23], None] +heaviside: _UFunc_Nin2_Nout1[L['heaviside'], L[4], None] +hypot: _UFunc_Nin2_Nout1[L['hypot'], L[5], L[0]] +invert: _UFunc_Nin1_Nout1[L['invert'], L[12], None] +isfinite: _UFunc_Nin1_Nout1[L['isfinite'], L[20], None] +isinf: _UFunc_Nin1_Nout1[L['isinf'], L[20], None] +isnan: _UFunc_Nin1_Nout1[L['isnan'], L[20], None] +isnat: _UFunc_Nin1_Nout1[L['isnat'], L[2], None] +lcm: _UFunc_Nin2_Nout1[L['lcm'], L[11], None] +ldexp: _UFunc_Nin2_Nout1[L['ldexp'], L[8], None] +left_shift: _UFunc_Nin2_Nout1[L['left_shift'], L[11], None] +less: _UFunc_Nin2_Nout1[L['less'], L[23], None] +less_equal: _UFunc_Nin2_Nout1[L['less_equal'], L[23], None] +log10: _UFunc_Nin1_Nout1[L['log10'], L[8], None] +log1p: _UFunc_Nin1_Nout1[L['log1p'], L[8], None] +log2: _UFunc_Nin1_Nout1[L['log2'], L[8], None] +log: _UFunc_Nin1_Nout1[L['log'], L[10], None] +logaddexp2: _UFunc_Nin2_Nout1[L['logaddexp2'], L[4], float] +logaddexp: _UFunc_Nin2_Nout1[L['logaddexp'], L[4], float] +logical_and: _UFunc_Nin2_Nout1[L['logical_and'], L[20], L[True]] +logical_not: _UFunc_Nin1_Nout1[L['logical_not'], L[20], None] +logical_or: _UFunc_Nin2_Nout1[L['logical_or'], L[20], L[False]] +logical_xor: _UFunc_Nin2_Nout1[L['logical_xor'], L[19], L[False]] +matmul: _GUFunc_Nin2_Nout1[L['matmul'], L[19], None, L["(n?,k),(k,m?)->(n?,m?)"]] +maximum: _UFunc_Nin2_Nout1[L['maximum'], L[21], None] +minimum: _UFunc_Nin2_Nout1[L['minimum'], L[21], None] +mod: _UFunc_Nin2_Nout1[L['remainder'], L[16], None] +modf: _UFunc_Nin1_Nout2[L['modf'], L[4], None] +multiply: _UFunc_Nin2_Nout1[L['multiply'], L[23], L[1]] +negative: _UFunc_Nin1_Nout1[L['negative'], L[19], None] +nextafter: _UFunc_Nin2_Nout1[L['nextafter'], L[4], None] +not_equal: _UFunc_Nin2_Nout1[L['not_equal'], L[23], None] +positive: _UFunc_Nin1_Nout1[L['positive'], L[19], None] +power: _UFunc_Nin2_Nout1[L['power'], L[18], None] +rad2deg: _UFunc_Nin1_Nout1[L['rad2deg'], L[5], None] +radians: _UFunc_Nin1_Nout1[L['radians'], L[5], None] +reciprocal: _UFunc_Nin1_Nout1[L['reciprocal'], L[18], None] +remainder: _UFunc_Nin2_Nout1[L['remainder'], L[16], None] +right_shift: _UFunc_Nin2_Nout1[L['right_shift'], L[11], None] +rint: _UFunc_Nin1_Nout1[L['rint'], L[10], None] +sign: _UFunc_Nin1_Nout1[L['sign'], L[19], None] +signbit: _UFunc_Nin1_Nout1[L['signbit'], L[4], None] +sin: _UFunc_Nin1_Nout1[L['sin'], L[9], None] +sinh: _UFunc_Nin1_Nout1[L['sinh'], L[8], None] +spacing: _UFunc_Nin1_Nout1[L['spacing'], L[4], None] +sqrt: _UFunc_Nin1_Nout1[L['sqrt'], L[10], None] +square: _UFunc_Nin1_Nout1[L['square'], L[18], None] +subtract: _UFunc_Nin2_Nout1[L['subtract'], L[21], None] +tan: _UFunc_Nin1_Nout1[L['tan'], L[8], None] +tanh: _UFunc_Nin1_Nout1[L['tanh'], L[8], None] +true_divide: _UFunc_Nin2_Nout1[L['true_divide'], L[11], None] +trunc: _UFunc_Nin1_Nout1[L['trunc'], L[7], None] +vecdot: _GUFunc_Nin2_Nout1[L['vecdot'], L[19], None, L["(n),(n)->()"]] + +abs = absolute +acos = arccos +acosh = arccosh +asin = arcsin +asinh = arcsinh +atan = arctan +atanh = arctanh +atan2 = arctan2 +concat = concatenate +bitwise_left_shift = left_shift +bitwise_invert = invert +bitwise_right_shift = right_shift +permute_dims = transpose +pow = power + +class _CopyMode(enum.Enum): + ALWAYS: L[True] + IF_NEEDED: L[False] + NEVER: L[2] + +_CallType = TypeVar("_CallType", bound=Callable[..., Any]) + +class errstate: + def __init__( + self, + *, + call: _ErrFunc | _SupportsWrite[str] = ..., + all: None | _ErrKind = ..., + divide: None | _ErrKind = ..., + over: None | _ErrKind = ..., + under: None | _ErrKind = ..., + invalid: None | _ErrKind = ..., + ) -> None: ... + def __enter__(self) -> None: ... + def __exit__( + self, + exc_type: None | type[BaseException], + exc_value: None | BaseException, + traceback: None | TracebackType, + /, + ) -> None: ... + def __call__(self, func: _CallType) -> _CallType: ... + +@contextmanager +def _no_nep50_warning() -> Generator[None, None, None]: ... +def _get_promotion_state() -> str: ... +def _set_promotion_state(state: str, /) -> None: ... + +_ScalarType_co = TypeVar("_ScalarType_co", bound=generic, covariant=True) + +class ndenumerate(Generic[_ScalarType_co]): + @property + def iter(self) -> flatiter[NDArray[_ScalarType_co]]: ... + + @overload + def __new__( + cls, arr: _FiniteNestedSequence[_SupportsArray[dtype[_ScalarType]]], + ) -> ndenumerate[_ScalarType]: ... + @overload + def __new__(cls, arr: str | _NestedSequence[str]) -> ndenumerate[str_]: ... + @overload + def __new__(cls, arr: bytes | _NestedSequence[bytes]) -> ndenumerate[bytes_]: ... + @overload + def __new__(cls, arr: builtins.bool | _NestedSequence[builtins.bool]) -> ndenumerate[np.bool]: ... + @overload + def __new__(cls, arr: int | _NestedSequence[int]) -> ndenumerate[int_]: ... + @overload + def __new__(cls, arr: float | _NestedSequence[float]) -> ndenumerate[float64]: ... + @overload + def __new__(cls, arr: complex | _NestedSequence[complex]) -> ndenumerate[complex128]: ... + @overload + def __new__(cls, arr: object) -> ndenumerate[object_]: ... + + # The first overload is a (semi-)workaround for a mypy bug (tested with v1.10 and v1.11) + @overload + def __next__( + self: ndenumerate[np.bool | datetime64 | timedelta64 | number[Any] | flexible], + /, + ) -> tuple[_Shape, _ScalarType_co]: ... + @overload + def __next__(self: ndenumerate[object_], /) -> tuple[_Shape, Any]: ... + @overload + def __next__(self, /) -> tuple[_Shape, _ScalarType_co]: ... + + def __iter__(self: _T) -> _T: ... + +class ndindex: + @overload + def __init__(self, shape: tuple[SupportsIndex, ...], /) -> None: ... + @overload + def __init__(self, *shape: SupportsIndex) -> None: ... + def __iter__(self: _T) -> _T: ... + def __next__(self) -> _Shape: ... + +# TODO: The type of each `__next__` and `iters` return-type depends +# on the length and dtype of `args`; we can't describe this behavior yet +# as we lack variadics (PEP 646). +@final +class broadcast: + def __new__(cls, *args: ArrayLike) -> broadcast: ... + @property + def index(self) -> int: ... + @property + def iters(self) -> tuple[flatiter[Any], ...]: ... + @property + def nd(self) -> int: ... + @property + def ndim(self) -> int: ... + @property + def numiter(self) -> int: ... + @property + def shape(self) -> _Shape: ... + @property + def size(self) -> int: ... + def __next__(self) -> tuple[Any, ...]: ... + def __iter__(self: _T) -> _T: ... + def reset(self) -> None: ... + +@final +class busdaycalendar: + def __new__( + cls, + weekmask: ArrayLike = ..., + holidays: ArrayLike | dt.date | _NestedSequence[dt.date] = ..., + ) -> busdaycalendar: ... + @property + def weekmask(self) -> NDArray[np.bool]: ... + @property + def holidays(self) -> NDArray[datetime64]: ... + +class finfo(Generic[_FloatType]): + dtype: dtype[_FloatType] + bits: int + eps: _FloatType + epsneg: _FloatType + iexp: int + machep: int + max: _FloatType + maxexp: int + min: _FloatType + minexp: int + negep: int + nexp: int + nmant: int + precision: int + resolution: _FloatType + smallest_subnormal: _FloatType + @property + def smallest_normal(self) -> _FloatType: ... + @property + def tiny(self) -> _FloatType: ... + @overload + def __new__( + cls, dtype: inexact[_NBit1] | _DTypeLike[inexact[_NBit1]] + ) -> finfo[floating[_NBit1]]: ... + @overload + def __new__( + cls, dtype: complex | float | type[complex] | type[float] + ) -> finfo[float64]: ... + @overload + def __new__( + cls, dtype: str + ) -> finfo[floating[Any]]: ... + +class iinfo(Generic[_IntType]): + dtype: dtype[_IntType] + kind: LiteralString + bits: int + key: LiteralString + @property + def min(self) -> int: ... + @property + def max(self) -> int: ... + + @overload + def __new__(cls, dtype: _IntType | _DTypeLike[_IntType]) -> iinfo[_IntType]: ... + @overload + def __new__(cls, dtype: int | type[int]) -> iinfo[int_]: ... + @overload + def __new__(cls, dtype: str) -> iinfo[Any]: ... + +_NDIterFlagsKind: TypeAlias = L[ + "buffered", + "c_index", + "copy_if_overlap", + "common_dtype", + "delay_bufalloc", + "external_loop", + "f_index", + "grow_inner", "growinner", + "multi_index", + "ranged", + "refs_ok", + "reduce_ok", + "zerosize_ok", +] + +_NDIterOpFlagsKind: TypeAlias = L[ + "aligned", + "allocate", + "arraymask", + "copy", + "config", + "nbo", + "no_subtype", + "no_broadcast", + "overlap_assume_elementwise", + "readonly", + "readwrite", + "updateifcopy", + "virtual", + "writeonly", + "writemasked" +] + +@final +class nditer: + def __new__( + cls, + op: ArrayLike | Sequence[ArrayLike], + flags: None | Sequence[_NDIterFlagsKind] = ..., + op_flags: None | Sequence[Sequence[_NDIterOpFlagsKind]] = ..., + op_dtypes: DTypeLike | Sequence[DTypeLike] = ..., + order: _OrderKACF = ..., + casting: _CastingKind = ..., + op_axes: None | Sequence[Sequence[SupportsIndex]] = ..., + itershape: None | _ShapeLike = ..., + buffersize: SupportsIndex = ..., + ) -> nditer: ... + def __enter__(self) -> nditer: ... + def __exit__( + self, + exc_type: None | type[BaseException], + exc_value: None | BaseException, + traceback: None | TracebackType, + ) -> None: ... + def __iter__(self) -> nditer: ... + def __next__(self) -> tuple[NDArray[Any], ...]: ... + def __len__(self) -> int: ... + def __copy__(self) -> nditer: ... + @overload + def __getitem__(self, index: SupportsIndex) -> NDArray[Any]: ... + @overload + def __getitem__(self, index: slice) -> tuple[NDArray[Any], ...]: ... + def __setitem__(self, index: slice | SupportsIndex, value: ArrayLike) -> None: ... + def close(self) -> None: ... + def copy(self) -> nditer: ... + def debug_print(self) -> None: ... + def enable_external_loop(self) -> None: ... + def iternext(self) -> builtins.bool: ... + def remove_axis(self, i: SupportsIndex, /) -> None: ... + def remove_multi_index(self) -> None: ... + def reset(self) -> None: ... + @property + def dtypes(self) -> tuple[dtype[Any], ...]: ... + @property + def finished(self) -> builtins.bool: ... + @property + def has_delayed_bufalloc(self) -> builtins.bool: ... + @property + def has_index(self) -> builtins.bool: ... + @property + def has_multi_index(self) -> builtins.bool: ... + @property + def index(self) -> int: ... + @property + def iterationneedsapi(self) -> builtins.bool: ... + @property + def iterindex(self) -> int: ... + @property + def iterrange(self) -> tuple[int, ...]: ... + @property + def itersize(self) -> int: ... + @property + def itviews(self) -> tuple[NDArray[Any], ...]: ... + @property + def multi_index(self) -> tuple[int, ...]: ... + @property + def ndim(self) -> int: ... + @property + def nop(self) -> int: ... + @property + def operands(self) -> tuple[NDArray[Any], ...]: ... + @property + def shape(self) -> tuple[int, ...]: ... + @property + def value(self) -> tuple[NDArray[Any], ...]: ... + +_MemMapModeKind: TypeAlias = L[ + "readonly", "r", + "copyonwrite", "c", + "readwrite", "r+", + "write", "w+", +] + +class memmap(ndarray[_ShapeType_co, _DType_co]): + __array_priority__: ClassVar[float] + filename: str | None + offset: int + mode: str + @overload + def __new__( + subtype, + filename: str | bytes | os.PathLike[str] | os.PathLike[bytes] | _MemMapIOProtocol, + dtype: type[uint8] = ..., + mode: _MemMapModeKind = ..., + offset: int = ..., + shape: None | int | tuple[int, ...] = ..., + order: _OrderKACF = ..., + ) -> memmap[Any, dtype[uint8]]: ... + @overload + def __new__( + subtype, + filename: str | bytes | os.PathLike[str] | os.PathLike[bytes] | _MemMapIOProtocol, + dtype: _DTypeLike[_ScalarType], + mode: _MemMapModeKind = ..., + offset: int = ..., + shape: None | int | tuple[int, ...] = ..., + order: _OrderKACF = ..., + ) -> memmap[Any, dtype[_ScalarType]]: ... + @overload + def __new__( + subtype, + filename: str | bytes | os.PathLike[str] | os.PathLike[bytes] | _MemMapIOProtocol, + dtype: DTypeLike, + mode: _MemMapModeKind = ..., + offset: int = ..., + shape: None | int | tuple[int, ...] = ..., + order: _OrderKACF = ..., + ) -> memmap[Any, dtype[Any]]: ... + def __array_finalize__(self, obj: object) -> None: ... + def __array_wrap__( + self, + array: memmap[_ShapeType_co, _DType_co], + context: None | tuple[ufunc, tuple[Any, ...], int] = ..., + return_scalar: builtins.bool = ..., + ) -> Any: ... + def flush(self) -> None: ... + +# TODO: Add a mypy plugin for managing functions whose output type is dependent +# on the literal value of some sort of signature (e.g. `einsum` and `vectorize`) +class vectorize: + pyfunc: Callable[..., Any] + cache: builtins.bool + signature: None | LiteralString + otypes: None | LiteralString + excluded: set[int | str] + __doc__: None | str + def __init__( + self, + pyfunc: Callable[..., Any], + otypes: None | str | Iterable[DTypeLike] = ..., + doc: None | str = ..., + excluded: None | Iterable[int | str] = ..., + cache: builtins.bool = ..., + signature: None | str = ..., + ) -> None: ... + def __call__(self, *args: Any, **kwargs: Any) -> Any: ... + +class poly1d: + @property + def variable(self) -> LiteralString: ... + @property + def order(self) -> int: ... + @property + def o(self) -> int: ... + @property + def roots(self) -> NDArray[Any]: ... + @property + def r(self) -> NDArray[Any]: ... + + @property + def coeffs(self) -> NDArray[Any]: ... + @coeffs.setter + def coeffs(self, value: NDArray[Any]) -> None: ... + + @property + def c(self) -> NDArray[Any]: ... + @c.setter + def c(self, value: NDArray[Any]) -> None: ... + + @property + def coef(self) -> NDArray[Any]: ... + @coef.setter + def coef(self, value: NDArray[Any]) -> None: ... + + @property + def coefficients(self) -> NDArray[Any]: ... + @coefficients.setter + def coefficients(self, value: NDArray[Any]) -> None: ... + + __hash__: ClassVar[None] # type: ignore + + # TODO: use `tuple[int]` as shape type once covariant (#26081) + @overload + def __array__(self, t: None = ..., copy: None | bool = ...) -> NDArray[Any]: ... + @overload + def __array__(self, t: _DType, copy: None | bool = ...) -> ndarray[Any, _DType]: ... + + @overload + def __call__(self, val: _ScalarLike_co) -> Any: ... + @overload + def __call__(self, val: poly1d) -> poly1d: ... + @overload + def __call__(self, val: ArrayLike) -> NDArray[Any]: ... + + def __init__( + self, + c_or_r: ArrayLike, + r: builtins.bool = ..., + variable: None | str = ..., + ) -> None: ... + def __len__(self) -> int: ... + def __neg__(self) -> poly1d: ... + def __pos__(self) -> poly1d: ... + def __mul__(self, other: ArrayLike, /) -> poly1d: ... + def __rmul__(self, other: ArrayLike, /) -> poly1d: ... + def __add__(self, other: ArrayLike, /) -> poly1d: ... + def __radd__(self, other: ArrayLike, /) -> poly1d: ... + def __pow__(self, val: _FloatLike_co, /) -> poly1d: ... # Integral floats are accepted + def __sub__(self, other: ArrayLike, /) -> poly1d: ... + def __rsub__(self, other: ArrayLike, /) -> poly1d: ... + def __div__(self, other: ArrayLike, /) -> poly1d: ... + def __truediv__(self, other: ArrayLike, /) -> poly1d: ... + def __rdiv__(self, other: ArrayLike, /) -> poly1d: ... + def __rtruediv__(self, other: ArrayLike, /) -> poly1d: ... + def __getitem__(self, val: int, /) -> Any: ... + def __setitem__(self, key: int, val: Any, /) -> None: ... + def __iter__(self) -> Iterator[Any]: ... + def deriv(self, m: SupportsInt | SupportsIndex = ...) -> poly1d: ... + def integ( + self, + m: SupportsInt | SupportsIndex = ..., + k: None | _ArrayLikeComplex_co | _ArrayLikeObject_co = ..., + ) -> poly1d: ... + + + +class matrix(ndarray[_Shape2DType_co, _DType_co]): + __array_priority__: ClassVar[float] + def __new__( + subtype, + data: ArrayLike, + dtype: DTypeLike = ..., + copy: builtins.bool = ..., + ) -> matrix[Any, Any]: ... + def __array_finalize__(self, obj: object) -> None: ... + + @overload + def __getitem__( + self, + key: ( + SupportsIndex + | _ArrayLikeInt_co + | tuple[SupportsIndex | _ArrayLikeInt_co, ...] + ), + /, + ) -> Any: ... + @overload + def __getitem__( + self, + key: ( + None + | slice + | ellipsis + | SupportsIndex + | _ArrayLikeInt_co + | tuple[None | slice | ellipsis | _ArrayLikeInt_co | SupportsIndex, ...] + ), + /, + ) -> matrix[Any, _DType_co]: ... + @overload + def __getitem__(self: NDArray[void], key: str, /) -> matrix[Any, dtype[Any]]: ... + @overload + def __getitem__(self: NDArray[void], key: list[str], /) -> matrix[_Shape2DType_co, dtype[void]]: ... + + def __mul__(self, other: ArrayLike, /) -> matrix[Any, Any]: ... + def __rmul__(self, other: ArrayLike, /) -> matrix[Any, Any]: ... + def __imul__(self, other: ArrayLike, /) -> matrix[_Shape2DType_co, _DType_co]: ... + def __pow__(self, other: ArrayLike, /) -> matrix[Any, Any]: ... + def __ipow__(self, other: ArrayLike, /) -> matrix[_Shape2DType_co, _DType_co]: ... + + @overload + def sum(self, axis: None = ..., dtype: DTypeLike = ..., out: None = ...) -> Any: ... + @overload + def sum(self, axis: _ShapeLike, dtype: DTypeLike = ..., out: None = ...) -> matrix[Any, Any]: ... + @overload + def sum(self, axis: None | _ShapeLike = ..., dtype: DTypeLike = ..., out: _NdArraySubClass = ...) -> _NdArraySubClass: ... + + @overload + def mean(self, axis: None = ..., dtype: DTypeLike = ..., out: None = ...) -> Any: ... + @overload + def mean(self, axis: _ShapeLike, dtype: DTypeLike = ..., out: None = ...) -> matrix[Any, Any]: ... + @overload + def mean(self, axis: None | _ShapeLike = ..., dtype: DTypeLike = ..., out: _NdArraySubClass = ...) -> _NdArraySubClass: ... + + @overload + def std(self, axis: None = ..., dtype: DTypeLike = ..., out: None = ..., ddof: float = ...) -> Any: ... + @overload + def std(self, axis: _ShapeLike, dtype: DTypeLike = ..., out: None = ..., ddof: float = ...) -> matrix[Any, Any]: ... + @overload + def std(self, axis: None | _ShapeLike = ..., dtype: DTypeLike = ..., out: _NdArraySubClass = ..., ddof: float = ...) -> _NdArraySubClass: ... + + @overload + def var(self, axis: None = ..., dtype: DTypeLike = ..., out: None = ..., ddof: float = ...) -> Any: ... + @overload + def var(self, axis: _ShapeLike, dtype: DTypeLike = ..., out: None = ..., ddof: float = ...) -> matrix[Any, Any]: ... + @overload + def var(self, axis: None | _ShapeLike = ..., dtype: DTypeLike = ..., out: _NdArraySubClass = ..., ddof: float = ...) -> _NdArraySubClass: ... + + @overload + def prod(self, axis: None = ..., dtype: DTypeLike = ..., out: None = ...) -> Any: ... + @overload + def prod(self, axis: _ShapeLike, dtype: DTypeLike = ..., out: None = ...) -> matrix[Any, Any]: ... + @overload + def prod(self, axis: None | _ShapeLike = ..., dtype: DTypeLike = ..., out: _NdArraySubClass = ...) -> _NdArraySubClass: ... + + @overload + def any(self, axis: None = ..., out: None = ...) -> np.bool: ... + @overload + def any(self, axis: _ShapeLike, out: None = ...) -> matrix[Any, dtype[np.bool]]: ... + @overload + def any(self, axis: None | _ShapeLike = ..., out: _NdArraySubClass = ...) -> _NdArraySubClass: ... + + @overload + def all(self, axis: None = ..., out: None = ...) -> np.bool: ... + @overload + def all(self, axis: _ShapeLike, out: None = ...) -> matrix[Any, dtype[np.bool]]: ... + @overload + def all(self, axis: None | _ShapeLike = ..., out: _NdArraySubClass = ...) -> _NdArraySubClass: ... + + @overload + def max(self: NDArray[_ScalarType], axis: None = ..., out: None = ...) -> _ScalarType: ... + @overload + def max(self, axis: _ShapeLike, out: None = ...) -> matrix[Any, _DType_co]: ... + @overload + def max(self, axis: None | _ShapeLike = ..., out: _NdArraySubClass = ...) -> _NdArraySubClass: ... + + @overload + def min(self: NDArray[_ScalarType], axis: None = ..., out: None = ...) -> _ScalarType: ... + @overload + def min(self, axis: _ShapeLike, out: None = ...) -> matrix[Any, _DType_co]: ... + @overload + def min(self, axis: None | _ShapeLike = ..., out: _NdArraySubClass = ...) -> _NdArraySubClass: ... + + @overload + def argmax(self: NDArray[_ScalarType], axis: None = ..., out: None = ...) -> intp: ... + @overload + def argmax(self, axis: _ShapeLike, out: None = ...) -> matrix[Any, dtype[intp]]: ... + @overload + def argmax(self, axis: None | _ShapeLike = ..., out: _NdArraySubClass = ...) -> _NdArraySubClass: ... + + @overload + def argmin(self: NDArray[_ScalarType], axis: None = ..., out: None = ...) -> intp: ... + @overload + def argmin(self, axis: _ShapeLike, out: None = ...) -> matrix[Any, dtype[intp]]: ... + @overload + def argmin(self, axis: None | _ShapeLike = ..., out: _NdArraySubClass = ...) -> _NdArraySubClass: ... + + @overload + def ptp(self: NDArray[_ScalarType], axis: None = ..., out: None = ...) -> _ScalarType: ... + @overload + def ptp(self, axis: _ShapeLike, out: None = ...) -> matrix[Any, _DType_co]: ... + @overload + def ptp(self, axis: None | _ShapeLike = ..., out: _NdArraySubClass = ...) -> _NdArraySubClass: ... + + def squeeze(self, axis: None | _ShapeLike = ...) -> matrix[Any, _DType_co]: ... + def tolist(self: matrix[Any, dtype[_SupportsItem[_T]]]) -> list[list[_T]]: ... # type: ignore[typevar] + def ravel(self, order: _OrderKACF = ...) -> matrix[Any, _DType_co]: ... + def flatten(self, order: _OrderKACF = ...) -> matrix[Any, _DType_co]: ... + + @property + def T(self) -> matrix[Any, _DType_co]: ... + @property + def I(self) -> matrix[Any, Any]: ... + @property + def A(self) -> ndarray[_Shape2DType_co, _DType_co]: ... + @property + def A1(self) -> ndarray[Any, _DType_co]: ... + @property + def H(self) -> matrix[Any, _DType_co]: ... + def getT(self) -> matrix[Any, _DType_co]: ... + def getI(self) -> matrix[Any, Any]: ... + def getA(self) -> ndarray[_Shape2DType_co, _DType_co]: ... + def getA1(self) -> ndarray[Any, _DType_co]: ... + def getH(self) -> matrix[Any, _DType_co]: ... + +_CharType = TypeVar("_CharType", str_, bytes_) +_CharDType = TypeVar("_CharDType", dtype[str_], dtype[bytes_]) + +# NOTE: Deprecated +# class MachAr: ... + +class _SupportsDLPack(Protocol[_T_contra]): + def __dlpack__(self, *, stream: None | _T_contra = ...) -> _PyCapsule: ... + +def from_dlpack( + obj: _SupportsDLPack[None], + /, + *, + device: L["cpu"] | None = ..., + copy: bool | None = ..., +) -> NDArray[Any]: ... diff --git a/venv/lib/python3.12/site-packages/numpy/__pycache__/__config__.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/__pycache__/__config__.cpython-312.pyc new file mode 100644 index 00000000..72db2a5e Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/__pycache__/__config__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/numpy/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..8838a3b6 Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/numpy/__pycache__/_array_api_info.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/__pycache__/_array_api_info.cpython-312.pyc new file mode 100644 index 00000000..15fb4575 Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/__pycache__/_array_api_info.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/numpy/__pycache__/_configtool.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/__pycache__/_configtool.cpython-312.pyc new file mode 100644 index 00000000..e357bc6b Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/__pycache__/_configtool.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/numpy/__pycache__/_distributor_init.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/__pycache__/_distributor_init.cpython-312.pyc new file mode 100644 index 00000000..a4de879c Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/__pycache__/_distributor_init.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/numpy/__pycache__/_expired_attrs_2_0.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/__pycache__/_expired_attrs_2_0.cpython-312.pyc new file mode 100644 index 00000000..bfc000dd Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/__pycache__/_expired_attrs_2_0.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/numpy/__pycache__/_globals.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/__pycache__/_globals.cpython-312.pyc new file mode 100644 index 00000000..13e86893 Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/__pycache__/_globals.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/numpy/__pycache__/_pytesttester.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/__pycache__/_pytesttester.cpython-312.pyc new file mode 100644 index 00000000..3e3ca4a0 Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/__pycache__/_pytesttester.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/numpy/__pycache__/conftest.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/__pycache__/conftest.cpython-312.pyc new file mode 100644 index 00000000..9d3ad2a6 Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/__pycache__/conftest.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/numpy/__pycache__/ctypeslib.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/__pycache__/ctypeslib.cpython-312.pyc new file mode 100644 index 00000000..6f3b5548 Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/__pycache__/ctypeslib.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/numpy/__pycache__/dtypes.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/__pycache__/dtypes.cpython-312.pyc new file mode 100644 index 00000000..3808b2b3 Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/__pycache__/dtypes.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/numpy/__pycache__/exceptions.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/__pycache__/exceptions.cpython-312.pyc new file mode 100644 index 00000000..96b6baf9 Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/__pycache__/exceptions.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/numpy/__pycache__/matlib.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/__pycache__/matlib.cpython-312.pyc new file mode 100644 index 00000000..4c247aa6 Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/__pycache__/matlib.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/numpy/__pycache__/version.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/__pycache__/version.cpython-312.pyc new file mode 100644 index 00000000..ef840b98 Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/__pycache__/version.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/numpy/_array_api_info.py b/venv/lib/python3.12/site-packages/numpy/_array_api_info.py new file mode 100644 index 00000000..0167a2fe --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_array_api_info.py @@ -0,0 +1,346 @@ +""" +Array API Inspection namespace + +This is the namespace for inspection functions as defined by the array API +standard. See +https://data-apis.org/array-api/latest/API_specification/inspection.html for +more details. + +""" +from numpy._core import ( + dtype, + bool, + intp, + int8, + int16, + int32, + int64, + uint8, + uint16, + uint32, + uint64, + float32, + float64, + complex64, + complex128, +) + + +class __array_namespace_info__: + """ + Get the array API inspection namespace for NumPy. + + The array API inspection namespace defines the following functions: + + - capabilities() + - default_device() + - default_dtypes() + - dtypes() + - devices() + + See + https://data-apis.org/array-api/latest/API_specification/inspection.html + for more details. + + Returns + ------- + info : ModuleType + The array API inspection namespace for NumPy. + + Examples + -------- + >>> info = np.__array_namespace_info__() + >>> info.default_dtypes() + {'real floating': numpy.float64, + 'complex floating': numpy.complex128, + 'integral': numpy.int64, + 'indexing': numpy.int64} + + """ + + __module__ = 'numpy' + + def capabilities(self): + """ + Return a dictionary of array API library capabilities. + + The resulting dictionary has the following keys: + + - **"boolean indexing"**: boolean indicating whether an array library + supports boolean indexing. Always ``True`` for NumPy. + + - **"data-dependent shapes"**: boolean indicating whether an array + library supports data-dependent output shapes. Always ``True`` for + NumPy. + + See + https://data-apis.org/array-api/latest/API_specification/generated/array_api.info.capabilities.html + for more details. + + See Also + -------- + __array_namespace_info__.default_device, + __array_namespace_info__.default_dtypes, + __array_namespace_info__.dtypes, + __array_namespace_info__.devices + + Returns + ------- + capabilities : dict + A dictionary of array API library capabilities. + + Examples + -------- + >>> info = np.__array_namespace_info__() + >>> info.capabilities() + {'boolean indexing': True, + 'data-dependent shapes': True} + + """ + return { + "boolean indexing": True, + "data-dependent shapes": True, + # 'max rank' will be part of the 2024.12 standard + # "max rank": 64, + } + + def default_device(self): + """ + The default device used for new NumPy arrays. + + For NumPy, this always returns ``'cpu'``. + + See Also + -------- + __array_namespace_info__.capabilities, + __array_namespace_info__.default_dtypes, + __array_namespace_info__.dtypes, + __array_namespace_info__.devices + + Returns + ------- + device : str + The default device used for new NumPy arrays. + + Examples + -------- + >>> info = np.__array_namespace_info__() + >>> info.default_device() + 'cpu' + + """ + return "cpu" + + def default_dtypes(self, *, device=None): + """ + The default data types used for new NumPy arrays. + + For NumPy, this always returns the following dictionary: + + - **"real floating"**: ``numpy.float64`` + - **"complex floating"**: ``numpy.complex128`` + - **"integral"**: ``numpy.intp`` + - **"indexing"**: ``numpy.intp`` + + Parameters + ---------- + device : str, optional + The device to get the default data types for. For NumPy, only + ``'cpu'`` is allowed. + + Returns + ------- + dtypes : dict + A dictionary describing the default data types used for new NumPy + arrays. + + See Also + -------- + __array_namespace_info__.capabilities, + __array_namespace_info__.default_device, + __array_namespace_info__.dtypes, + __array_namespace_info__.devices + + Examples + -------- + >>> info = np.__array_namespace_info__() + >>> info.default_dtypes() + {'real floating': numpy.float64, + 'complex floating': numpy.complex128, + 'integral': numpy.int64, + 'indexing': numpy.int64} + + """ + if device not in ["cpu", None]: + raise ValueError( + 'Device not understood. Only "cpu" is allowed, but received:' + f' {device}' + ) + return { + "real floating": dtype(float64), + "complex floating": dtype(complex128), + "integral": dtype(intp), + "indexing": dtype(intp), + } + + def dtypes(self, *, device=None, kind=None): + """ + The array API data types supported by NumPy. + + Note that this function only returns data types that are defined by + the array API. + + Parameters + ---------- + device : str, optional + The device to get the data types for. For NumPy, only ``'cpu'`` is + allowed. + kind : str or tuple of str, optional + The kind of data types to return. If ``None``, all data types are + returned. If a string, only data types of that kind are returned. + If a tuple, a dictionary containing the union of the given kinds + is returned. The following kinds are supported: + + - ``'bool'``: boolean data types (i.e., ``bool``). + - ``'signed integer'``: signed integer data types (i.e., ``int8``, + ``int16``, ``int32``, ``int64``). + - ``'unsigned integer'``: unsigned integer data types (i.e., + ``uint8``, ``uint16``, ``uint32``, ``uint64``). + - ``'integral'``: integer data types. Shorthand for ``('signed + integer', 'unsigned integer')``. + - ``'real floating'``: real-valued floating-point data types + (i.e., ``float32``, ``float64``). + - ``'complex floating'``: complex floating-point data types (i.e., + ``complex64``, ``complex128``). + - ``'numeric'``: numeric data types. Shorthand for ``('integral', + 'real floating', 'complex floating')``. + + Returns + ------- + dtypes : dict + A dictionary mapping the names of data types to the corresponding + NumPy data types. + + See Also + -------- + __array_namespace_info__.capabilities, + __array_namespace_info__.default_device, + __array_namespace_info__.default_dtypes, + __array_namespace_info__.devices + + Examples + -------- + >>> info = np.__array_namespace_info__() + >>> info.dtypes(kind='signed integer') + {'int8': numpy.int8, + 'int16': numpy.int16, + 'int32': numpy.int32, + 'int64': numpy.int64} + + """ + if device not in ["cpu", None]: + raise ValueError( + 'Device not understood. Only "cpu" is allowed, but received:' + f' {device}' + ) + if kind is None: + return { + "bool": dtype(bool), + "int8": dtype(int8), + "int16": dtype(int16), + "int32": dtype(int32), + "int64": dtype(int64), + "uint8": dtype(uint8), + "uint16": dtype(uint16), + "uint32": dtype(uint32), + "uint64": dtype(uint64), + "float32": dtype(float32), + "float64": dtype(float64), + "complex64": dtype(complex64), + "complex128": dtype(complex128), + } + if kind == "bool": + return {"bool": bool} + if kind == "signed integer": + return { + "int8": dtype(int8), + "int16": dtype(int16), + "int32": dtype(int32), + "int64": dtype(int64), + } + if kind == "unsigned integer": + return { + "uint8": dtype(uint8), + "uint16": dtype(uint16), + "uint32": dtype(uint32), + "uint64": dtype(uint64), + } + if kind == "integral": + return { + "int8": dtype(int8), + "int16": dtype(int16), + "int32": dtype(int32), + "int64": dtype(int64), + "uint8": dtype(uint8), + "uint16": dtype(uint16), + "uint32": dtype(uint32), + "uint64": dtype(uint64), + } + if kind == "real floating": + return { + "float32": dtype(float32), + "float64": dtype(float64), + } + if kind == "complex floating": + return { + "complex64": dtype(complex64), + "complex128": dtype(complex128), + } + if kind == "numeric": + return { + "int8": dtype(int8), + "int16": dtype(int16), + "int32": dtype(int32), + "int64": dtype(int64), + "uint8": dtype(uint8), + "uint16": dtype(uint16), + "uint32": dtype(uint32), + "uint64": dtype(uint64), + "float32": dtype(float32), + "float64": dtype(float64), + "complex64": dtype(complex64), + "complex128": dtype(complex128), + } + if isinstance(kind, tuple): + res = {} + for k in kind: + res.update(self.dtypes(kind=k)) + return res + raise ValueError(f"unsupported kind: {kind!r}") + + def devices(self): + """ + The devices supported by NumPy. + + For NumPy, this always returns ``['cpu']``. + + Returns + ------- + devices : list of str + The devices supported by NumPy. + + See Also + -------- + __array_namespace_info__.capabilities, + __array_namespace_info__.default_device, + __array_namespace_info__.default_dtypes, + __array_namespace_info__.dtypes + + Examples + -------- + >>> info = np.__array_namespace_info__() + >>> info.devices() + ['cpu'] + + """ + return ["cpu"] diff --git a/venv/lib/python3.12/site-packages/numpy/_array_api_info.pyi b/venv/lib/python3.12/site-packages/numpy/_array_api_info.pyi new file mode 100644 index 00000000..52b98fc0 --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_array_api_info.pyi @@ -0,0 +1,213 @@ +import sys +from typing import ( + TYPE_CHECKING, + ClassVar, + Literal, + TypeAlias, + TypedDict, + TypeVar, + final, + overload, +) + +import numpy as np + +if sys.version_info >= (3, 11): + from typing import Never +elif TYPE_CHECKING: + from typing_extensions import Never +else: + # `NoReturn` and `Never` are equivalent (but not equal) for type-checkers, + # but are used in different places by convention + from typing import NoReturn as Never + +_Device: TypeAlias = Literal["cpu"] +_DeviceLike: TypeAlias = None | _Device + +_Capabilities = TypedDict( + "_Capabilities", + { + "boolean indexing": Literal[True], + "data-dependent shapes": Literal[True], + }, +) + +_DefaultDTypes = TypedDict( + "_DefaultDTypes", + { + "real floating": np.dtype[np.float64], + "complex floating": np.dtype[np.complex128], + "integral": np.dtype[np.intp], + "indexing": np.dtype[np.intp], + }, +) + + +_KindBool: TypeAlias = Literal["bool"] +_KindInt: TypeAlias = Literal["signed integer"] +_KindUInt: TypeAlias = Literal["unsigned integer"] +_KindInteger: TypeAlias = Literal["integral"] +_KindFloat: TypeAlias = Literal["real floating"] +_KindComplex: TypeAlias = Literal["complex floating"] +_KindNumber: TypeAlias = Literal["numeric"] +_Kind: TypeAlias = ( + _KindBool + | _KindInt + | _KindUInt + | _KindInteger + | _KindFloat + | _KindComplex + | _KindNumber +) + + +_T1 = TypeVar("_T1") +_T2 = TypeVar("_T2") +_T3 = TypeVar("_T3") +_Permute1: TypeAlias = _T1 | tuple[_T1] +_Permute2: TypeAlias = tuple[_T1, _T2] | tuple[_T2, _T1] +_Permute3: TypeAlias = ( + tuple[_T1, _T2, _T3] | tuple[_T1, _T3, _T2] + | tuple[_T2, _T1, _T3] | tuple[_T2, _T3, _T1] + | tuple[_T3, _T1, _T2] | tuple[_T3, _T2, _T1] +) + +class _DTypesBool(TypedDict): + bool: np.dtype[np.bool] + +class _DTypesInt(TypedDict): + int8: np.dtype[np.int8] + int16: np.dtype[np.int16] + int32: np.dtype[np.int32] + int64: np.dtype[np.int64] + +class _DTypesUInt(TypedDict): + uint8: np.dtype[np.uint8] + uint16: np.dtype[np.uint16] + uint32: np.dtype[np.uint32] + uint64: np.dtype[np.uint64] + +class _DTypesInteger(_DTypesInt, _DTypesUInt): + ... + +class _DTypesFloat(TypedDict): + float32: np.dtype[np.float32] + float64: np.dtype[np.float64] + +class _DTypesComplex(TypedDict): + complex64: np.dtype[np.complex64] + complex128: np.dtype[np.complex128] + +class _DTypesNumber(_DTypesInteger, _DTypesFloat, _DTypesComplex): + ... + +class _DTypes(_DTypesBool, _DTypesNumber): + ... + +class _DTypesUnion(TypedDict, total=False): + bool: np.dtype[np.bool] + int8: np.dtype[np.int8] + int16: np.dtype[np.int16] + int32: np.dtype[np.int32] + int64: np.dtype[np.int64] + uint8: np.dtype[np.uint8] + uint16: np.dtype[np.uint16] + uint32: np.dtype[np.uint32] + uint64: np.dtype[np.uint64] + float32: np.dtype[np.float32] + float64: np.dtype[np.float64] + complex64: np.dtype[np.complex64] + complex128: np.dtype[np.complex128] + +_EmptyDict: TypeAlias = dict[Never, Never] + + +@final +class __array_namespace_info__: + __module__: ClassVar[Literal['numpy']] + + def capabilities(self) -> _Capabilities: ... + def default_device(self) -> _Device: ... + def default_dtypes( + self, + *, + device: _DeviceLike = ..., + ) -> _DefaultDTypes: ... + def devices(self) -> list[_Device]: ... + + @overload + def dtypes( + self, + *, + device: _DeviceLike = ..., + kind: None = ..., + ) -> _DTypes: ... + @overload + def dtypes( + self, + *, + device: _DeviceLike = ..., + kind: _Permute1[_KindBool], + ) -> _DTypesBool: ... + @overload + def dtypes( + self, + *, + device: _DeviceLike = ..., + kind: _Permute1[_KindInt], + ) -> _DTypesInt: ... + @overload + def dtypes( + self, + *, + device: _DeviceLike = ..., + kind: _Permute1[_KindUInt], + ) -> _DTypesUInt: ... + @overload + def dtypes( + self, + *, + device: _DeviceLike = ..., + kind: _Permute1[_KindFloat], + ) -> _DTypesFloat: ... + @overload + def dtypes( + self, + *, + device: _DeviceLike = ..., + kind: _Permute1[_KindComplex], + ) -> _DTypesComplex: ... + @overload + def dtypes( + self, + *, + device: _DeviceLike = ..., + kind: ( + _Permute1[_KindInteger] + | _Permute2[_KindInt, _KindUInt] + ), + ) -> _DTypesInteger: ... + @overload + def dtypes( + self, + *, + device: _DeviceLike = ..., + kind: ( + _Permute1[_KindNumber] + | _Permute3[_KindInteger, _KindFloat, _KindComplex] + ), + ) -> _DTypesNumber: ... + @overload + def dtypes( + self, + *, + device: _DeviceLike = ..., + kind: tuple[()], + ) -> _EmptyDict: ... + @overload + def dtypes( + self, + *, + device: _DeviceLike = ..., + kind: tuple[_Kind, ...], + ) -> _DTypesUnion: ... diff --git a/venv/lib/python3.12/site-packages/numpy/_configtool.py b/venv/lib/python3.12/site-packages/numpy/_configtool.py new file mode 100644 index 00000000..70a14b87 --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_configtool.py @@ -0,0 +1,39 @@ +import argparse +from pathlib import Path +import sys + +from .version import __version__ +from .lib._utils_impl import get_include + + +def main() -> None: + parser = argparse.ArgumentParser() + parser.add_argument( + "--version", + action="version", + version=__version__, + help="Print the version and exit.", + ) + parser.add_argument( + "--cflags", + action="store_true", + help="Compile flag needed when using the NumPy headers.", + ) + parser.add_argument( + "--pkgconfigdir", + action="store_true", + help=("Print the pkgconfig directory in which `numpy.pc` is stored " + "(useful for setting $PKG_CONFIG_PATH)."), + ) + args = parser.parse_args() + if not sys.argv[1:]: + parser.print_help() + if args.cflags: + print("-I" + get_include()) + if args.pkgconfigdir: + _path = Path(get_include()) / '..' / 'lib' / 'pkgconfig' + print(_path.resolve()) + + +if __name__ == "__main__": + main() diff --git a/venv/lib/python3.12/site-packages/numpy/_core/__init__.py b/venv/lib/python3.12/site-packages/numpy/_core/__init__.py new file mode 100644 index 00000000..4b908771 --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/__init__.py @@ -0,0 +1,180 @@ +""" +Contains the core of NumPy: ndarray, ufuncs, dtypes, etc. + +Please note that this module is private. All functions and objects +are available in the main ``numpy`` namespace - use that instead. + +""" + +import os + +from numpy.version import version as __version__ + + +# disables OpenBLAS affinity setting of the main thread that limits +# python threads or processes to one core +env_added = [] +for envkey in ['OPENBLAS_MAIN_FREE', 'GOTOBLAS_MAIN_FREE']: + if envkey not in os.environ: + os.environ[envkey] = '1' + env_added.append(envkey) + +try: + from . import multiarray +except ImportError as exc: + import sys + msg = """ + +IMPORTANT: PLEASE READ THIS FOR ADVICE ON HOW TO SOLVE THIS ISSUE! + +Importing the numpy C-extensions failed. This error can happen for +many reasons, often due to issues with your setup or how NumPy was +installed. + +We have compiled some common reasons and troubleshooting tips at: + + https://numpy.org/devdocs/user/troubleshooting-importerror.html + +Please note and check the following: + + * The Python version is: Python%d.%d from "%s" + * The NumPy version is: "%s" + +and make sure that they are the versions you expect. +Please carefully study the documentation linked above for further help. + +Original error was: %s +""" % (sys.version_info[0], sys.version_info[1], sys.executable, + __version__, exc) + raise ImportError(msg) +finally: + for envkey in env_added: + del os.environ[envkey] +del envkey +del env_added +del os + +from . import umath + +# Check that multiarray,umath are pure python modules wrapping +# _multiarray_umath and not either of the old c-extension modules +if not (hasattr(multiarray, '_multiarray_umath') and + hasattr(umath, '_multiarray_umath')): + import sys + path = sys.modules['numpy'].__path__ + msg = ("Something is wrong with the numpy installation. " + "While importing we detected an older version of " + "numpy in {}. One method of fixing this is to repeatedly uninstall " + "numpy until none is found, then reinstall this version.") + raise ImportError(msg.format(path)) + +from . import numerictypes as nt +from .numerictypes import sctypes, sctypeDict +multiarray.set_typeDict(nt.sctypeDict) +from . import numeric +from .numeric import * +from . import fromnumeric +from .fromnumeric import * +from .records import record, recarray +# Note: module name memmap is overwritten by a class with same name +from .memmap import * +from . import function_base +from .function_base import * +from . import _machar +from . import getlimits +from .getlimits import * +from . import shape_base +from .shape_base import * +from . import einsumfunc +from .einsumfunc import * +del nt + +from .numeric import absolute as abs + +# do this after everything else, to minimize the chance of this misleadingly +# appearing in an import-time traceback +from . import _add_newdocs +from . import _add_newdocs_scalars +# add these for module-freeze analysis (like PyInstaller) +from . import _dtype_ctypes +from . import _internal +from . import _dtype +from . import _methods + +acos = numeric.arccos +acosh = numeric.arccosh +asin = numeric.arcsin +asinh = numeric.arcsinh +atan = numeric.arctan +atanh = numeric.arctanh +atan2 = numeric.arctan2 +concat = numeric.concatenate +bitwise_left_shift = numeric.left_shift +bitwise_invert = numeric.invert +bitwise_right_shift = numeric.right_shift +permute_dims = numeric.transpose +pow = numeric.power + +__all__ = [ + "abs", "acos", "acosh", "asin", "asinh", "atan", "atanh", "atan2", + "bitwise_invert", "bitwise_left_shift", "bitwise_right_shift", "concat", + "pow", "permute_dims", "memmap", "sctypeDict", "record", "recarray" +] +__all__ += numeric.__all__ +__all__ += function_base.__all__ +__all__ += getlimits.__all__ +__all__ += shape_base.__all__ +__all__ += einsumfunc.__all__ + + +def _ufunc_reduce(func): + # Report the `__name__`. pickle will try to find the module. Note that + # pickle supports for this `__name__` to be a `__qualname__`. It may + # make sense to add a `__qualname__` to ufuncs, to allow this more + # explicitly (Numba has ufuncs as attributes). + # See also: https://github.com/dask/distributed/issues/3450 + return func.__name__ + + +def _DType_reconstruct(scalar_type): + # This is a work-around to pickle type(np.dtype(np.float64)), etc. + # and it should eventually be replaced with a better solution, e.g. when + # DTypes become HeapTypes. + return type(dtype(scalar_type)) + + +def _DType_reduce(DType): + # As types/classes, most DTypes can simply be pickled by their name: + if not DType._legacy or DType.__module__ == "numpy.dtypes": + return DType.__name__ + + # However, user defined legacy dtypes (like rational) do not end up in + # `numpy.dtypes` as module and do not have a public class at all. + # For these, we pickle them by reconstructing them from the scalar type: + scalar_type = DType.type + return _DType_reconstruct, (scalar_type,) + + +def __getattr__(name): + # Deprecated 2022-11-22, NumPy 1.25. + if name == "MachAr": + import warnings + warnings.warn( + "The `np._core.MachAr` is considered private API (NumPy 1.24)", + DeprecationWarning, stacklevel=2, + ) + return _machar.MachAr + raise AttributeError(f"Module {__name__!r} has no attribute {name!r}") + + +import copyreg + +copyreg.pickle(ufunc, _ufunc_reduce) +copyreg.pickle(type(dtype), _DType_reduce, _DType_reconstruct) + +# Unclutter namespace (must keep _*_reconstruct for unpickling) +del copyreg, _ufunc_reduce, _DType_reduce + +from numpy._pytesttester import PytestTester +test = PytestTester(__name__) +del PytestTester diff --git a/venv/lib/python3.12/site-packages/numpy/_core/__init__.pyi b/venv/lib/python3.12/site-packages/numpy/_core/__init__.pyi new file mode 100644 index 00000000..40d9c411 --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/__init__.pyi @@ -0,0 +1,2 @@ +# NOTE: The `np._core` namespace is deliberately kept empty due to it +# being private diff --git a/venv/lib/python3.12/site-packages/numpy/_core/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/_core/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..314ee410 Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/_core/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/numpy/_core/__pycache__/_add_newdocs.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/_core/__pycache__/_add_newdocs.cpython-312.pyc new file mode 100644 index 00000000..d394b730 Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/_core/__pycache__/_add_newdocs.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/numpy/_core/__pycache__/_add_newdocs_scalars.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/_core/__pycache__/_add_newdocs_scalars.cpython-312.pyc new file mode 100644 index 00000000..6c36353b Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/_core/__pycache__/_add_newdocs_scalars.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/numpy/_core/__pycache__/_asarray.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/_core/__pycache__/_asarray.cpython-312.pyc new file mode 100644 index 00000000..56f46b15 Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/_core/__pycache__/_asarray.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/numpy/_core/__pycache__/_dtype.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/_core/__pycache__/_dtype.cpython-312.pyc new file mode 100644 index 00000000..c8c32b86 Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/_core/__pycache__/_dtype.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/numpy/_core/__pycache__/_dtype_ctypes.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/_core/__pycache__/_dtype_ctypes.cpython-312.pyc new file mode 100644 index 00000000..8ae38e1e Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/_core/__pycache__/_dtype_ctypes.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/numpy/_core/__pycache__/_exceptions.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/_core/__pycache__/_exceptions.cpython-312.pyc new file mode 100644 index 00000000..b811fe9e Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/_core/__pycache__/_exceptions.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/numpy/_core/__pycache__/_internal.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/_core/__pycache__/_internal.cpython-312.pyc new file mode 100644 index 00000000..116f0bdf Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/_core/__pycache__/_internal.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/numpy/_core/__pycache__/_machar.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/_core/__pycache__/_machar.cpython-312.pyc new file mode 100644 index 00000000..622fcd90 Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/_core/__pycache__/_machar.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/numpy/_core/__pycache__/_methods.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/_core/__pycache__/_methods.cpython-312.pyc new file mode 100644 index 00000000..aaaea752 Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/_core/__pycache__/_methods.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/numpy/_core/__pycache__/_string_helpers.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/_core/__pycache__/_string_helpers.cpython-312.pyc new file mode 100644 index 00000000..a5c5c387 Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/_core/__pycache__/_string_helpers.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/numpy/_core/__pycache__/_type_aliases.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/_core/__pycache__/_type_aliases.cpython-312.pyc new file mode 100644 index 00000000..5e594c28 Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/_core/__pycache__/_type_aliases.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/numpy/_core/__pycache__/_ufunc_config.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/_core/__pycache__/_ufunc_config.cpython-312.pyc new file mode 100644 index 00000000..9838ef91 Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/_core/__pycache__/_ufunc_config.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/numpy/_core/__pycache__/arrayprint.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/_core/__pycache__/arrayprint.cpython-312.pyc new file mode 100644 index 00000000..c0a3116c Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/_core/__pycache__/arrayprint.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/numpy/_core/__pycache__/cversions.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/_core/__pycache__/cversions.cpython-312.pyc new file mode 100644 index 00000000..4b764883 Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/_core/__pycache__/cversions.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/numpy/_core/__pycache__/defchararray.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/_core/__pycache__/defchararray.cpython-312.pyc new file mode 100644 index 00000000..18890aad Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/_core/__pycache__/defchararray.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/numpy/_core/__pycache__/einsumfunc.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/_core/__pycache__/einsumfunc.cpython-312.pyc new file mode 100644 index 00000000..ccbd4344 Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/_core/__pycache__/einsumfunc.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/numpy/_core/__pycache__/fromnumeric.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/_core/__pycache__/fromnumeric.cpython-312.pyc new file mode 100644 index 00000000..534f8b6d Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/_core/__pycache__/fromnumeric.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/numpy/_core/__pycache__/function_base.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/_core/__pycache__/function_base.cpython-312.pyc new file mode 100644 index 00000000..3c2dd31a Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/_core/__pycache__/function_base.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/numpy/_core/__pycache__/getlimits.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/_core/__pycache__/getlimits.cpython-312.pyc new file mode 100644 index 00000000..732f98f9 Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/_core/__pycache__/getlimits.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/numpy/_core/__pycache__/memmap.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/_core/__pycache__/memmap.cpython-312.pyc new file mode 100644 index 00000000..a0799817 Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/_core/__pycache__/memmap.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/numpy/_core/__pycache__/multiarray.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/_core/__pycache__/multiarray.cpython-312.pyc new file mode 100644 index 00000000..7e39a298 Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/_core/__pycache__/multiarray.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/numpy/_core/__pycache__/numeric.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/_core/__pycache__/numeric.cpython-312.pyc new file mode 100644 index 00000000..310f229d Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/_core/__pycache__/numeric.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/numpy/_core/__pycache__/numerictypes.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/_core/__pycache__/numerictypes.cpython-312.pyc new file mode 100644 index 00000000..3b26c4ac Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/_core/__pycache__/numerictypes.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/numpy/_core/__pycache__/overrides.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/_core/__pycache__/overrides.cpython-312.pyc new file mode 100644 index 00000000..8423e845 Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/_core/__pycache__/overrides.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/numpy/_core/__pycache__/printoptions.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/_core/__pycache__/printoptions.cpython-312.pyc new file mode 100644 index 00000000..beaa048f Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/_core/__pycache__/printoptions.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/numpy/_core/__pycache__/records.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/_core/__pycache__/records.cpython-312.pyc new file mode 100644 index 00000000..8da17b35 Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/_core/__pycache__/records.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/numpy/_core/__pycache__/shape_base.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/_core/__pycache__/shape_base.cpython-312.pyc new file mode 100644 index 00000000..bb11b33d Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/_core/__pycache__/shape_base.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/numpy/_core/__pycache__/strings.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/_core/__pycache__/strings.cpython-312.pyc new file mode 100644 index 00000000..8aa88dbd Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/_core/__pycache__/strings.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/numpy/_core/__pycache__/umath.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/_core/__pycache__/umath.cpython-312.pyc new file mode 100644 index 00000000..25b10a3e Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/_core/__pycache__/umath.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/numpy/_core/_add_newdocs.py b/venv/lib/python3.12/site-packages/numpy/_core/_add_newdocs.py new file mode 100644 index 00000000..3a2bf40d --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/_add_newdocs.py @@ -0,0 +1,7089 @@ +""" +This is only meant to add docs to objects defined in C-extension modules. +The purpose is to allow easier editing of the docstrings without +requiring a re-compile. + +NOTE: Many of the methods of ndarray have corresponding functions. + If you update these docstrings, please keep also the ones in + _core/fromnumeric.py, matrixlib/defmatrix.py up-to-date. + +""" + +from numpy._core.function_base import add_newdoc +from numpy._core.overrides import array_function_like_doc + + +############################################################################### +# +# flatiter +# +# flatiter needs a toplevel description +# +############################################################################### + +add_newdoc('numpy._core', 'flatiter', + """ + Flat iterator object to iterate over arrays. + + A `flatiter` iterator is returned by ``x.flat`` for any array `x`. + It allows iterating over the array as if it were a 1-D array, + either in a for-loop or by calling its `next` method. + + Iteration is done in row-major, C-style order (the last + index varying the fastest). The iterator can also be indexed using + basic slicing or advanced indexing. + + See Also + -------- + ndarray.flat : Return a flat iterator over an array. + ndarray.flatten : Returns a flattened copy of an array. + + Notes + ----- + A `flatiter` iterator can not be constructed directly from Python code + by calling the `flatiter` constructor. + + Examples + -------- + >>> import numpy as np + >>> x = np.arange(6).reshape(2, 3) + >>> fl = x.flat + >>> type(fl) + + >>> for item in fl: + ... print(item) + ... + 0 + 1 + 2 + 3 + 4 + 5 + + >>> fl[2:4] + array([2, 3]) + + """) + +# flatiter attributes + +add_newdoc('numpy._core', 'flatiter', ('base', + """ + A reference to the array that is iterated over. + + Examples + -------- + >>> import numpy as np + >>> x = np.arange(5) + >>> fl = x.flat + >>> fl.base is x + True + + """)) + + +add_newdoc('numpy._core', 'flatiter', ('coords', + """ + An N-dimensional tuple of current coordinates. + + Examples + -------- + >>> import numpy as np + >>> x = np.arange(6).reshape(2, 3) + >>> fl = x.flat + >>> fl.coords + (0, 0) + >>> next(fl) + 0 + >>> fl.coords + (0, 1) + + """)) + + +add_newdoc('numpy._core', 'flatiter', ('index', + """ + Current flat index into the array. + + Examples + -------- + >>> import numpy as np + >>> x = np.arange(6).reshape(2, 3) + >>> fl = x.flat + >>> fl.index + 0 + >>> next(fl) + 0 + >>> fl.index + 1 + + """)) + +# flatiter functions + +add_newdoc('numpy._core', 'flatiter', ('__array__', + """__array__(type=None) Get array from iterator + + """)) + + +add_newdoc('numpy._core', 'flatiter', ('copy', + """ + copy() + + Get a copy of the iterator as a 1-D array. + + Examples + -------- + >>> import numpy as np + >>> x = np.arange(6).reshape(2, 3) + >>> x + array([[0, 1, 2], + [3, 4, 5]]) + >>> fl = x.flat + >>> fl.copy() + array([0, 1, 2, 3, 4, 5]) + + """)) + + +############################################################################### +# +# nditer +# +############################################################################### + +add_newdoc('numpy._core', 'nditer', + """ + nditer(op, flags=None, op_flags=None, op_dtypes=None, order='K', + casting='safe', op_axes=None, itershape=None, buffersize=0) + + Efficient multi-dimensional iterator object to iterate over arrays. + To get started using this object, see the + :ref:`introductory guide to array iteration `. + + Parameters + ---------- + op : ndarray or sequence of array_like + The array(s) to iterate over. + + flags : sequence of str, optional + Flags to control the behavior of the iterator. + + * ``buffered`` enables buffering when required. + * ``c_index`` causes a C-order index to be tracked. + * ``f_index`` causes a Fortran-order index to be tracked. + * ``multi_index`` causes a multi-index, or a tuple of indices + with one per iteration dimension, to be tracked. + * ``common_dtype`` causes all the operands to be converted to + a common data type, with copying or buffering as necessary. + * ``copy_if_overlap`` causes the iterator to determine if read + operands have overlap with write operands, and make temporary + copies as necessary to avoid overlap. False positives (needless + copying) are possible in some cases. + * ``delay_bufalloc`` delays allocation of the buffers until + a reset() call is made. Allows ``allocate`` operands to + be initialized before their values are copied into the buffers. + * ``external_loop`` causes the ``values`` given to be + one-dimensional arrays with multiple values instead of + zero-dimensional arrays. + * ``grow_inner`` allows the ``value`` array sizes to be made + larger than the buffer size when both ``buffered`` and + ``external_loop`` is used. + * ``ranged`` allows the iterator to be restricted to a sub-range + of the iterindex values. + * ``refs_ok`` enables iteration of reference types, such as + object arrays. + * ``reduce_ok`` enables iteration of ``readwrite`` operands + which are broadcasted, also known as reduction operands. + * ``zerosize_ok`` allows `itersize` to be zero. + op_flags : list of list of str, optional + This is a list of flags for each operand. At minimum, one of + ``readonly``, ``readwrite``, or ``writeonly`` must be specified. + + * ``readonly`` indicates the operand will only be read from. + * ``readwrite`` indicates the operand will be read from and written to. + * ``writeonly`` indicates the operand will only be written to. + * ``no_broadcast`` prevents the operand from being broadcasted. + * ``contig`` forces the operand data to be contiguous. + * ``aligned`` forces the operand data to be aligned. + * ``nbo`` forces the operand data to be in native byte order. + * ``copy`` allows a temporary read-only copy if required. + * ``updateifcopy`` allows a temporary read-write copy if required. + * ``allocate`` causes the array to be allocated if it is None + in the ``op`` parameter. + * ``no_subtype`` prevents an ``allocate`` operand from using a subtype. + * ``arraymask`` indicates that this operand is the mask to use + for selecting elements when writing to operands with the + 'writemasked' flag set. The iterator does not enforce this, + but when writing from a buffer back to the array, it only + copies those elements indicated by this mask. + * ``writemasked`` indicates that only elements where the chosen + ``arraymask`` operand is True will be written to. + * ``overlap_assume_elementwise`` can be used to mark operands that are + accessed only in the iterator order, to allow less conservative + copying when ``copy_if_overlap`` is present. + op_dtypes : dtype or tuple of dtype(s), optional + The required data type(s) of the operands. If copying or buffering + is enabled, the data will be converted to/from their original types. + order : {'C', 'F', 'A', 'K'}, optional + Controls the iteration order. 'C' means C order, 'F' means + Fortran order, 'A' means 'F' order if all the arrays are Fortran + contiguous, 'C' order otherwise, and 'K' means as close to the + order the array elements appear in memory as possible. This also + affects the element memory order of ``allocate`` operands, as they + are allocated to be compatible with iteration order. + Default is 'K'. + casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional + Controls what kind of data casting may occur when making a copy + or buffering. Setting this to 'unsafe' is not recommended, + as it can adversely affect accumulations. + + * 'no' means the data types should not be cast at all. + * 'equiv' means only byte-order changes are allowed. + * 'safe' means only casts which can preserve values are allowed. + * 'same_kind' means only safe casts or casts within a kind, + like float64 to float32, are allowed. + * 'unsafe' means any data conversions may be done. + op_axes : list of list of ints, optional + If provided, is a list of ints or None for each operands. + The list of axes for an operand is a mapping from the dimensions + of the iterator to the dimensions of the operand. A value of + -1 can be placed for entries, causing that dimension to be + treated as `newaxis`. + itershape : tuple of ints, optional + The desired shape of the iterator. This allows ``allocate`` operands + with a dimension mapped by op_axes not corresponding to a dimension + of a different operand to get a value not equal to 1 for that + dimension. + buffersize : int, optional + When buffering is enabled, controls the size of the temporary + buffers. Set to 0 for the default value. + + Attributes + ---------- + dtypes : tuple of dtype(s) + The data types of the values provided in `value`. This may be + different from the operand data types if buffering is enabled. + Valid only before the iterator is closed. + finished : bool + Whether the iteration over the operands is finished or not. + has_delayed_bufalloc : bool + If True, the iterator was created with the ``delay_bufalloc`` flag, + and no reset() function was called on it yet. + has_index : bool + If True, the iterator was created with either the ``c_index`` or + the ``f_index`` flag, and the property `index` can be used to + retrieve it. + has_multi_index : bool + If True, the iterator was created with the ``multi_index`` flag, + and the property `multi_index` can be used to retrieve it. + index + When the ``c_index`` or ``f_index`` flag was used, this property + provides access to the index. Raises a ValueError if accessed + and ``has_index`` is False. + iterationneedsapi : bool + Whether iteration requires access to the Python API, for example + if one of the operands is an object array. + iterindex : int + An index which matches the order of iteration. + itersize : int + Size of the iterator. + itviews + Structured view(s) of `operands` in memory, matching the reordered + and optimized iterator access pattern. Valid only before the iterator + is closed. + multi_index + When the ``multi_index`` flag was used, this property + provides access to the index. Raises a ValueError if accessed + accessed and ``has_multi_index`` is False. + ndim : int + The dimensions of the iterator. + nop : int + The number of iterator operands. + operands : tuple of operand(s) + The array(s) to be iterated over. Valid only before the iterator is + closed. + shape : tuple of ints + Shape tuple, the shape of the iterator. + value + Value of ``operands`` at current iteration. Normally, this is a + tuple of array scalars, but if the flag ``external_loop`` is used, + it is a tuple of one dimensional arrays. + + Notes + ----- + `nditer` supersedes `flatiter`. The iterator implementation behind + `nditer` is also exposed by the NumPy C API. + + The Python exposure supplies two iteration interfaces, one which follows + the Python iterator protocol, and another which mirrors the C-style + do-while pattern. The native Python approach is better in most cases, but + if you need the coordinates or index of an iterator, use the C-style pattern. + + Examples + -------- + Here is how we might write an ``iter_add`` function, using the + Python iterator protocol: + + >>> import numpy as np + + >>> def iter_add_py(x, y, out=None): + ... addop = np.add + ... it = np.nditer([x, y, out], [], + ... [['readonly'], ['readonly'], ['writeonly','allocate']]) + ... with it: + ... for (a, b, c) in it: + ... addop(a, b, out=c) + ... return it.operands[2] + + Here is the same function, but following the C-style pattern: + + >>> def iter_add(x, y, out=None): + ... addop = np.add + ... it = np.nditer([x, y, out], [], + ... [['readonly'], ['readonly'], ['writeonly','allocate']]) + ... with it: + ... while not it.finished: + ... addop(it[0], it[1], out=it[2]) + ... it.iternext() + ... return it.operands[2] + + Here is an example outer product function: + + >>> def outer_it(x, y, out=None): + ... mulop = np.multiply + ... it = np.nditer([x, y, out], ['external_loop'], + ... [['readonly'], ['readonly'], ['writeonly', 'allocate']], + ... op_axes=[list(range(x.ndim)) + [-1] * y.ndim, + ... [-1] * x.ndim + list(range(y.ndim)), + ... None]) + ... with it: + ... for (a, b, c) in it: + ... mulop(a, b, out=c) + ... return it.operands[2] + + >>> a = np.arange(2)+1 + >>> b = np.arange(3)+1 + >>> outer_it(a,b) + array([[1, 2, 3], + [2, 4, 6]]) + + Here is an example function which operates like a "lambda" ufunc: + + >>> def luf(lamdaexpr, *args, **kwargs): + ... '''luf(lambdaexpr, op1, ..., opn, out=None, order='K', casting='safe', buffersize=0)''' + ... nargs = len(args) + ... op = (kwargs.get('out',None),) + args + ... it = np.nditer(op, ['buffered','external_loop'], + ... [['writeonly','allocate','no_broadcast']] + + ... [['readonly','nbo','aligned']]*nargs, + ... order=kwargs.get('order','K'), + ... casting=kwargs.get('casting','safe'), + ... buffersize=kwargs.get('buffersize',0)) + ... while not it.finished: + ... it[0] = lamdaexpr(*it[1:]) + ... it.iternext() + ... return it.operands[0] + + >>> a = np.arange(5) + >>> b = np.ones(5) + >>> luf(lambda i,j:i*i + j/2, a, b) + array([ 0.5, 1.5, 4.5, 9.5, 16.5]) + + If operand flags ``"writeonly"`` or ``"readwrite"`` are used the + operands may be views into the original data with the + `WRITEBACKIFCOPY` flag. In this case `nditer` must be used as a + context manager or the `nditer.close` method must be called before + using the result. The temporary data will be written back to the + original data when the :meth:`~object.__exit__` function is called + but not before: + + >>> a = np.arange(6, dtype='i4')[::-2] + >>> with np.nditer(a, [], + ... [['writeonly', 'updateifcopy']], + ... casting='unsafe', + ... op_dtypes=[np.dtype('f4')]) as i: + ... x = i.operands[0] + ... x[:] = [-1, -2, -3] + ... # a still unchanged here + >>> a, x + (array([-1, -2, -3], dtype=int32), array([-1., -2., -3.], dtype=float32)) + + It is important to note that once the iterator is exited, dangling + references (like `x` in the example) may or may not share data with + the original data `a`. If writeback semantics were active, i.e. if + `x.base.flags.writebackifcopy` is `True`, then exiting the iterator + will sever the connection between `x` and `a`, writing to `x` will + no longer write to `a`. If writeback semantics are not active, then + `x.data` will still point at some part of `a.data`, and writing to + one will affect the other. + + Context management and the `close` method appeared in version 1.15.0. + + """) + +# nditer methods + +add_newdoc('numpy._core', 'nditer', ('copy', + """ + copy() + + Get a copy of the iterator in its current state. + + Examples + -------- + >>> import numpy as np + >>> x = np.arange(10) + >>> y = x + 1 + >>> it = np.nditer([x, y]) + >>> next(it) + (array(0), array(1)) + >>> it2 = it.copy() + >>> next(it2) + (array(1), array(2)) + + """)) + +add_newdoc('numpy._core', 'nditer', ('operands', + """ + operands[`Slice`] + + The array(s) to be iterated over. Valid only before the iterator is closed. + """)) + +add_newdoc('numpy._core', 'nditer', ('debug_print', + """ + debug_print() + + Print the current state of the `nditer` instance and debug info to stdout. + + """)) + +add_newdoc('numpy._core', 'nditer', ('enable_external_loop', + """ + enable_external_loop() + + When the "external_loop" was not used during construction, but + is desired, this modifies the iterator to behave as if the flag + was specified. + + """)) + +add_newdoc('numpy._core', 'nditer', ('iternext', + """ + iternext() + + Check whether iterations are left, and perform a single internal iteration + without returning the result. Used in the C-style pattern do-while + pattern. For an example, see `nditer`. + + Returns + ------- + iternext : bool + Whether or not there are iterations left. + + """)) + +add_newdoc('numpy._core', 'nditer', ('remove_axis', + """ + remove_axis(i, /) + + Removes axis `i` from the iterator. Requires that the flag "multi_index" + be enabled. + + """)) + +add_newdoc('numpy._core', 'nditer', ('remove_multi_index', + """ + remove_multi_index() + + When the "multi_index" flag was specified, this removes it, allowing + the internal iteration structure to be optimized further. + + """)) + +add_newdoc('numpy._core', 'nditer', ('reset', + """ + reset() + + Reset the iterator to its initial state. + + """)) + +add_newdoc('numpy._core', 'nested_iters', + """ + nested_iters(op, axes, flags=None, op_flags=None, op_dtypes=None, \ + order="K", casting="safe", buffersize=0) + + Create nditers for use in nested loops + + Create a tuple of `nditer` objects which iterate in nested loops over + different axes of the op argument. The first iterator is used in the + outermost loop, the last in the innermost loop. Advancing one will change + the subsequent iterators to point at its new element. + + Parameters + ---------- + op : ndarray or sequence of array_like + The array(s) to iterate over. + + axes : list of list of int + Each item is used as an "op_axes" argument to an nditer + + flags, op_flags, op_dtypes, order, casting, buffersize (optional) + See `nditer` parameters of the same name + + Returns + ------- + iters : tuple of nditer + An nditer for each item in `axes`, outermost first + + See Also + -------- + nditer + + Examples + -------- + + Basic usage. Note how y is the "flattened" version of + [a[:, 0, :], a[:, 1, 0], a[:, 2, :]] since we specified + the first iter's axes as [1] + + >>> import numpy as np + >>> a = np.arange(12).reshape(2, 3, 2) + >>> i, j = np.nested_iters(a, [[1], [0, 2]], flags=["multi_index"]) + >>> for x in i: + ... print(i.multi_index) + ... for y in j: + ... print('', j.multi_index, y) + (0,) + (0, 0) 0 + (0, 1) 1 + (1, 0) 6 + (1, 1) 7 + (1,) + (0, 0) 2 + (0, 1) 3 + (1, 0) 8 + (1, 1) 9 + (2,) + (0, 0) 4 + (0, 1) 5 + (1, 0) 10 + (1, 1) 11 + + """) + +add_newdoc('numpy._core', 'nditer', ('close', + """ + close() + + Resolve all writeback semantics in writeable operands. + + .. versionadded:: 1.15.0 + + See Also + -------- + + :ref:`nditer-context-manager` + + """)) + + +############################################################################### +# +# broadcast +# +############################################################################### + +add_newdoc('numpy._core', 'broadcast', + """ + Produce an object that mimics broadcasting. + + Parameters + ---------- + in1, in2, ... : array_like + Input parameters. + + Returns + ------- + b : broadcast object + Broadcast the input parameters against one another, and + return an object that encapsulates the result. + Amongst others, it has ``shape`` and ``nd`` properties, and + may be used as an iterator. + + See Also + -------- + broadcast_arrays + broadcast_to + broadcast_shapes + + Examples + -------- + + Manually adding two vectors, using broadcasting: + + >>> import numpy as np + >>> x = np.array([[1], [2], [3]]) + >>> y = np.array([4, 5, 6]) + >>> b = np.broadcast(x, y) + + >>> out = np.empty(b.shape) + >>> out.flat = [u+v for (u,v) in b] + >>> out + array([[5., 6., 7.], + [6., 7., 8.], + [7., 8., 9.]]) + + Compare against built-in broadcasting: + + >>> x + y + array([[5, 6, 7], + [6, 7, 8], + [7, 8, 9]]) + + """) + +# attributes + +add_newdoc('numpy._core', 'broadcast', ('index', + """ + current index in broadcasted result + + Examples + -------- + + >>> import numpy as np + >>> x = np.array([[1], [2], [3]]) + >>> y = np.array([4, 5, 6]) + >>> b = np.broadcast(x, y) + >>> b.index + 0 + >>> next(b), next(b), next(b) + ((1, 4), (1, 5), (1, 6)) + >>> b.index + 3 + + """)) + +add_newdoc('numpy._core', 'broadcast', ('iters', + """ + tuple of iterators along ``self``'s "components." + + Returns a tuple of `numpy.flatiter` objects, one for each "component" + of ``self``. + + See Also + -------- + numpy.flatiter + + Examples + -------- + + >>> import numpy as np + >>> x = np.array([1, 2, 3]) + >>> y = np.array([[4], [5], [6]]) + >>> b = np.broadcast(x, y) + >>> row, col = b.iters + >>> next(row), next(col) + (1, 4) + + """)) + +add_newdoc('numpy._core', 'broadcast', ('ndim', + """ + Number of dimensions of broadcasted result. Alias for `nd`. + + .. versionadded:: 1.12.0 + + Examples + -------- + >>> import numpy as np + >>> x = np.array([1, 2, 3]) + >>> y = np.array([[4], [5], [6]]) + >>> b = np.broadcast(x, y) + >>> b.ndim + 2 + + """)) + +add_newdoc('numpy._core', 'broadcast', ('nd', + """ + Number of dimensions of broadcasted result. For code intended for NumPy + 1.12.0 and later the more consistent `ndim` is preferred. + + Examples + -------- + >>> import numpy as np + >>> x = np.array([1, 2, 3]) + >>> y = np.array([[4], [5], [6]]) + >>> b = np.broadcast(x, y) + >>> b.nd + 2 + + """)) + +add_newdoc('numpy._core', 'broadcast', ('numiter', + """ + Number of iterators possessed by the broadcasted result. + + Examples + -------- + >>> import numpy as np + >>> x = np.array([1, 2, 3]) + >>> y = np.array([[4], [5], [6]]) + >>> b = np.broadcast(x, y) + >>> b.numiter + 2 + + """)) + +add_newdoc('numpy._core', 'broadcast', ('shape', + """ + Shape of broadcasted result. + + Examples + -------- + >>> import numpy as np + >>> x = np.array([1, 2, 3]) + >>> y = np.array([[4], [5], [6]]) + >>> b = np.broadcast(x, y) + >>> b.shape + (3, 3) + + """)) + +add_newdoc('numpy._core', 'broadcast', ('size', + """ + Total size of broadcasted result. + + Examples + -------- + >>> import numpy as np + >>> x = np.array([1, 2, 3]) + >>> y = np.array([[4], [5], [6]]) + >>> b = np.broadcast(x, y) + >>> b.size + 9 + + """)) + +add_newdoc('numpy._core', 'broadcast', ('reset', + """ + reset() + + Reset the broadcasted result's iterator(s). + + Parameters + ---------- + None + + Returns + ------- + None + + Examples + -------- + >>> import numpy as np + >>> x = np.array([1, 2, 3]) + >>> y = np.array([[4], [5], [6]]) + >>> b = np.broadcast(x, y) + >>> b.index + 0 + >>> next(b), next(b), next(b) + ((1, 4), (2, 4), (3, 4)) + >>> b.index + 3 + >>> b.reset() + >>> b.index + 0 + + """)) + +############################################################################### +# +# numpy functions +# +############################################################################### + +add_newdoc('numpy._core.multiarray', 'array', + """ + array(object, dtype=None, *, copy=True, order='K', subok=False, ndmin=0, + like=None) + + Create an array. + + Parameters + ---------- + object : array_like + An array, any object exposing the array interface, an object whose + ``__array__`` method returns an array, or any (nested) sequence. + If object is a scalar, a 0-dimensional array containing object is + returned. + dtype : data-type, optional + The desired data-type for the array. If not given, NumPy will try to use + a default ``dtype`` that can represent the values (by applying promotion + rules when necessary.) + copy : bool, optional + If ``True`` (default), then the array data is copied. If ``None``, + a copy will only be made if ``__array__`` returns a copy, if obj is + a nested sequence, or if a copy is needed to satisfy any of the other + requirements (``dtype``, ``order``, etc.). Note that any copy of + the data is shallow, i.e., for arrays with object dtype, the new + array will point to the same objects. See Examples for `ndarray.copy`. + For ``False`` it raises a ``ValueError`` if a copy cannot be avoided. + Default: ``True``. + order : {'K', 'A', 'C', 'F'}, optional + Specify the memory layout of the array. If object is not an array, the + newly created array will be in C order (row major) unless 'F' is + specified, in which case it will be in Fortran order (column major). + If object is an array the following holds. + + ===== ========= =================================================== + order no copy copy=True + ===== ========= =================================================== + 'K' unchanged F & C order preserved, otherwise most similar order + 'A' unchanged F order if input is F and not C, otherwise C order + 'C' C order C order + 'F' F order F order + ===== ========= =================================================== + + When ``copy=None`` and a copy is made for other reasons, the result is + the same as if ``copy=True``, with some exceptions for 'A', see the + Notes section. The default order is 'K'. + subok : bool, optional + If True, then sub-classes will be passed-through, otherwise + the returned array will be forced to be a base-class array (default). + ndmin : int, optional + Specifies the minimum number of dimensions that the resulting + array should have. Ones will be prepended to the shape as + needed to meet this requirement. + ${ARRAY_FUNCTION_LIKE} + + .. versionadded:: 1.20.0 + + Returns + ------- + out : ndarray + An array object satisfying the specified requirements. + + See Also + -------- + empty_like : Return an empty array with shape and type of input. + ones_like : Return an array of ones with shape and type of input. + zeros_like : Return an array of zeros with shape and type of input. + full_like : Return a new array with shape of input filled with value. + empty : Return a new uninitialized array. + ones : Return a new array setting values to one. + zeros : Return a new array setting values to zero. + full : Return a new array of given shape filled with value. + copy: Return an array copy of the given object. + + + Notes + ----- + When order is 'A' and ``object`` is an array in neither 'C' nor 'F' order, + and a copy is forced by a change in dtype, then the order of the result is + not necessarily 'C' as expected. This is likely a bug. + + Examples + -------- + >>> import numpy as np + >>> np.array([1, 2, 3]) + array([1, 2, 3]) + + Upcasting: + + >>> np.array([1, 2, 3.0]) + array([ 1., 2., 3.]) + + More than one dimension: + + >>> np.array([[1, 2], [3, 4]]) + array([[1, 2], + [3, 4]]) + + Minimum dimensions 2: + + >>> np.array([1, 2, 3], ndmin=2) + array([[1, 2, 3]]) + + Type provided: + + >>> np.array([1, 2, 3], dtype=complex) + array([ 1.+0.j, 2.+0.j, 3.+0.j]) + + Data-type consisting of more than one element: + + >>> x = np.array([(1,2),(3,4)],dtype=[('a','>> x['a'] + array([1, 3]) + + Creating an array from sub-classes: + + >>> np.array(np.asmatrix('1 2; 3 4')) + array([[1, 2], + [3, 4]]) + + >>> np.array(np.asmatrix('1 2; 3 4'), subok=True) + matrix([[1, 2], + [3, 4]]) + + """.replace( + "${ARRAY_FUNCTION_LIKE}", + array_function_like_doc, + )) + +add_newdoc('numpy._core.multiarray', 'asarray', + """ + asarray(a, dtype=None, order=None, *, device=None, copy=None, like=None) + + Convert the input to an array. + + Parameters + ---------- + a : array_like + Input data, in any form that can be converted to an array. This + includes lists, lists of tuples, tuples, tuples of tuples, tuples + of lists and ndarrays. + dtype : data-type, optional + By default, the data-type is inferred from the input data. + order : {'C', 'F', 'A', 'K'}, optional + Memory layout. 'A' and 'K' depend on the order of input array a. + 'C' row-major (C-style), + 'F' column-major (Fortran-style) memory representation. + 'A' (any) means 'F' if `a` is Fortran contiguous, 'C' otherwise + 'K' (keep) preserve input order + Defaults to 'K'. + device : str, optional + The device on which to place the created array. Default: ``None``. + For Array-API interoperability only, so must be ``"cpu"`` if passed. + + .. versionadded:: 2.0.0 + copy : bool, optional + If ``True``, then the object is copied. If ``None`` then the object is + copied only if needed, i.e. if ``__array__`` returns a copy, if obj + is a nested sequence, or if a copy is needed to satisfy any of + the other requirements (``dtype``, ``order``, etc.). + For ``False`` it raises a ``ValueError`` if a copy cannot be avoided. + Default: ``None``. + + .. versionadded:: 2.0.0 + ${ARRAY_FUNCTION_LIKE} + + .. versionadded:: 1.20.0 + + Returns + ------- + out : ndarray + Array interpretation of ``a``. No copy is performed if the input + is already an ndarray with matching dtype and order. If ``a`` is a + subclass of ndarray, a base class ndarray is returned. + + See Also + -------- + asanyarray : Similar function which passes through subclasses. + ascontiguousarray : Convert input to a contiguous array. + asfortranarray : Convert input to an ndarray with column-major + memory order. + asarray_chkfinite : Similar function which checks input for NaNs and Infs. + fromiter : Create an array from an iterator. + fromfunction : Construct an array by executing a function on grid + positions. + + Examples + -------- + Convert a list into an array: + + >>> a = [1, 2] + >>> import numpy as np + >>> np.asarray(a) + array([1, 2]) + + Existing arrays are not copied: + + >>> a = np.array([1, 2]) + >>> np.asarray(a) is a + True + + If `dtype` is set, array is copied only if dtype does not match: + + >>> a = np.array([1, 2], dtype=np.float32) + >>> np.shares_memory(np.asarray(a, dtype=np.float32), a) + True + >>> np.shares_memory(np.asarray(a, dtype=np.float64), a) + False + + Contrary to `asanyarray`, ndarray subclasses are not passed through: + + >>> issubclass(np.recarray, np.ndarray) + True + >>> a = np.array([(1., 2), (3., 4)], dtype='f4,i4').view(np.recarray) + >>> np.asarray(a) is a + False + >>> np.asanyarray(a) is a + True + + """.replace( + "${ARRAY_FUNCTION_LIKE}", + array_function_like_doc, + )) + +add_newdoc('numpy._core.multiarray', 'asanyarray', + """ + asanyarray(a, dtype=None, order=None, *, like=None) + + Convert the input to an ndarray, but pass ndarray subclasses through. + + Parameters + ---------- + a : array_like + Input data, in any form that can be converted to an array. This + includes scalars, lists, lists of tuples, tuples, tuples of tuples, + tuples of lists, and ndarrays. + dtype : data-type, optional + By default, the data-type is inferred from the input data. + order : {'C', 'F', 'A', 'K'}, optional + Memory layout. 'A' and 'K' depend on the order of input array a. + 'C' row-major (C-style), + 'F' column-major (Fortran-style) memory representation. + 'A' (any) means 'F' if `a` is Fortran contiguous, 'C' otherwise + 'K' (keep) preserve input order + Defaults to 'C'. + device : str, optional + The device on which to place the created array. Default: ``None``. + For Array-API interoperability only, so must be ``"cpu"`` if passed. + + .. versionadded:: 2.1.0 + + copy : bool, optional + If ``True``, then the object is copied. If ``None`` then the object is + copied only if needed, i.e. if ``__array__`` returns a copy, if obj + is a nested sequence, or if a copy is needed to satisfy any of + the other requirements (``dtype``, ``order``, etc.). + For ``False`` it raises a ``ValueError`` if a copy cannot be avoided. + Default: ``None``. + + .. versionadded:: 2.1.0 + + ${ARRAY_FUNCTION_LIKE} + + .. versionadded:: 1.20.0 + + Returns + ------- + out : ndarray or an ndarray subclass + Array interpretation of `a`. If `a` is an ndarray or a subclass + of ndarray, it is returned as-is and no copy is performed. + + See Also + -------- + asarray : Similar function which always returns ndarrays. + ascontiguousarray : Convert input to a contiguous array. + asfortranarray : Convert input to an ndarray with column-major + memory order. + asarray_chkfinite : Similar function which checks input for NaNs and + Infs. + fromiter : Create an array from an iterator. + fromfunction : Construct an array by executing a function on grid + positions. + + Examples + -------- + Convert a list into an array: + + >>> a = [1, 2] + >>> import numpy as np + >>> np.asanyarray(a) + array([1, 2]) + + Instances of `ndarray` subclasses are passed through as-is: + + >>> a = np.array([(1., 2), (3., 4)], dtype='f4,i4').view(np.recarray) + >>> np.asanyarray(a) is a + True + + """.replace( + "${ARRAY_FUNCTION_LIKE}", + array_function_like_doc, + )) + +add_newdoc('numpy._core.multiarray', 'ascontiguousarray', + """ + ascontiguousarray(a, dtype=None, *, like=None) + + Return a contiguous array (ndim >= 1) in memory (C order). + + Parameters + ---------- + a : array_like + Input array. + dtype : str or dtype object, optional + Data-type of returned array. + ${ARRAY_FUNCTION_LIKE} + + .. versionadded:: 1.20.0 + + Returns + ------- + out : ndarray + Contiguous array of same shape and content as `a`, with type `dtype` + if specified. + + See Also + -------- + asfortranarray : Convert input to an ndarray with column-major + memory order. + require : Return an ndarray that satisfies requirements. + ndarray.flags : Information about the memory layout of the array. + + Examples + -------- + Starting with a Fortran-contiguous array: + + >>> import numpy as np + >>> x = np.ones((2, 3), order='F') + >>> x.flags['F_CONTIGUOUS'] + True + + Calling ``ascontiguousarray`` makes a C-contiguous copy: + + >>> y = np.ascontiguousarray(x) + >>> y.flags['C_CONTIGUOUS'] + True + >>> np.may_share_memory(x, y) + False + + Now, starting with a C-contiguous array: + + >>> x = np.ones((2, 3), order='C') + >>> x.flags['C_CONTIGUOUS'] + True + + Then, calling ``ascontiguousarray`` returns the same object: + + >>> y = np.ascontiguousarray(x) + >>> x is y + True + + Note: This function returns an array with at least one-dimension (1-d) + so it will not preserve 0-d arrays. + + """.replace( + "${ARRAY_FUNCTION_LIKE}", + array_function_like_doc, + )) + +add_newdoc('numpy._core.multiarray', 'asfortranarray', + """ + asfortranarray(a, dtype=None, *, like=None) + + Return an array (ndim >= 1) laid out in Fortran order in memory. + + Parameters + ---------- + a : array_like + Input array. + dtype : str or dtype object, optional + By default, the data-type is inferred from the input data. + ${ARRAY_FUNCTION_LIKE} + + .. versionadded:: 1.20.0 + + Returns + ------- + out : ndarray + The input `a` in Fortran, or column-major, order. + + See Also + -------- + ascontiguousarray : Convert input to a contiguous (C order) array. + asanyarray : Convert input to an ndarray with either row or + column-major memory order. + require : Return an ndarray that satisfies requirements. + ndarray.flags : Information about the memory layout of the array. + + Examples + -------- + Starting with a C-contiguous array: + + >>> import numpy as np + >>> x = np.ones((2, 3), order='C') + >>> x.flags['C_CONTIGUOUS'] + True + + Calling ``asfortranarray`` makes a Fortran-contiguous copy: + + >>> y = np.asfortranarray(x) + >>> y.flags['F_CONTIGUOUS'] + True + >>> np.may_share_memory(x, y) + False + + Now, starting with a Fortran-contiguous array: + + >>> x = np.ones((2, 3), order='F') + >>> x.flags['F_CONTIGUOUS'] + True + + Then, calling ``asfortranarray`` returns the same object: + + >>> y = np.asfortranarray(x) + >>> x is y + True + + Note: This function returns an array with at least one-dimension (1-d) + so it will not preserve 0-d arrays. + + """.replace( + "${ARRAY_FUNCTION_LIKE}", + array_function_like_doc, + )) + +add_newdoc('numpy._core.multiarray', 'empty', + """ + empty(shape, dtype=float, order='C', *, device=None, like=None) + + Return a new array of given shape and type, without initializing entries. + + Parameters + ---------- + shape : int or tuple of int + Shape of the empty array, e.g., ``(2, 3)`` or ``2``. + dtype : data-type, optional + Desired output data-type for the array, e.g, `numpy.int8`. Default is + `numpy.float64`. + order : {'C', 'F'}, optional, default: 'C' + Whether to store multi-dimensional data in row-major + (C-style) or column-major (Fortran-style) order in + memory. + device : str, optional + The device on which to place the created array. Default: ``None``. + For Array-API interoperability only, so must be ``"cpu"`` if passed. + + .. versionadded:: 2.0.0 + ${ARRAY_FUNCTION_LIKE} + + .. versionadded:: 1.20.0 + + Returns + ------- + out : ndarray + Array of uninitialized (arbitrary) data of the given shape, dtype, and + order. Object arrays will be initialized to None. + + See Also + -------- + empty_like : Return an empty array with shape and type of input. + ones : Return a new array setting values to one. + zeros : Return a new array setting values to zero. + full : Return a new array of given shape filled with value. + + Notes + ----- + Unlike other array creation functions (e.g. `zeros`, `ones`, `full`), + `empty` does not initialize the values of the array, and may therefore be + marginally faster. However, the values stored in the newly allocated array + are arbitrary. For reproducible behavior, be sure to set each element of + the array before reading. + + Examples + -------- + >>> import numpy as np + >>> np.empty([2, 2]) + array([[ -9.74499359e+001, 6.69583040e-309], + [ 2.13182611e-314, 3.06959433e-309]]) #uninitialized + + >>> np.empty([2, 2], dtype=int) + array([[-1073741821, -1067949133], + [ 496041986, 19249760]]) #uninitialized + + """.replace( + "${ARRAY_FUNCTION_LIKE}", + array_function_like_doc, + )) + +add_newdoc('numpy._core.multiarray', 'scalar', + """ + scalar(dtype, obj) + + Return a new scalar array of the given type initialized with obj. + + This function is meant mainly for pickle support. `dtype` must be a + valid data-type descriptor. If `dtype` corresponds to an object + descriptor, then `obj` can be any object, otherwise `obj` must be a + string. If `obj` is not given, it will be interpreted as None for object + type and as zeros for all other types. + + """) + +add_newdoc('numpy._core.multiarray', 'zeros', + """ + zeros(shape, dtype=float, order='C', *, like=None) + + Return a new array of given shape and type, filled with zeros. + + Parameters + ---------- + shape : int or tuple of ints + Shape of the new array, e.g., ``(2, 3)`` or ``2``. + dtype : data-type, optional + The desired data-type for the array, e.g., `numpy.int8`. Default is + `numpy.float64`. + order : {'C', 'F'}, optional, default: 'C' + Whether to store multi-dimensional data in row-major + (C-style) or column-major (Fortran-style) order in + memory. + ${ARRAY_FUNCTION_LIKE} + + .. versionadded:: 1.20.0 + + Returns + ------- + out : ndarray + Array of zeros with the given shape, dtype, and order. + + See Also + -------- + zeros_like : Return an array of zeros with shape and type of input. + empty : Return a new uninitialized array. + ones : Return a new array setting values to one. + full : Return a new array of given shape filled with value. + + Examples + -------- + >>> import numpy as np + >>> np.zeros(5) + array([ 0., 0., 0., 0., 0.]) + + >>> np.zeros((5,), dtype=int) + array([0, 0, 0, 0, 0]) + + >>> np.zeros((2, 1)) + array([[ 0.], + [ 0.]]) + + >>> s = (2,2) + >>> np.zeros(s) + array([[ 0., 0.], + [ 0., 0.]]) + + >>> np.zeros((2,), dtype=[('x', 'i4'), ('y', 'i4')]) # custom dtype + array([(0, 0), (0, 0)], + dtype=[('x', '>> import numpy as np + >>> np.fromstring('1 2', dtype=int, sep=' ') + array([1, 2]) + >>> np.fromstring('1, 2', dtype=int, sep=',') + array([1, 2]) + + """.replace( + "${ARRAY_FUNCTION_LIKE}", + array_function_like_doc, + )) + +add_newdoc('numpy._core.multiarray', 'compare_chararrays', + """ + compare_chararrays(a1, a2, cmp, rstrip) + + Performs element-wise comparison of two string arrays using the + comparison operator specified by `cmp`. + + Parameters + ---------- + a1, a2 : array_like + Arrays to be compared. + cmp : {"<", "<=", "==", ">=", ">", "!="} + Type of comparison. + rstrip : Boolean + If True, the spaces at the end of Strings are removed before the comparison. + + Returns + ------- + out : ndarray + The output array of type Boolean with the same shape as a and b. + + Raises + ------ + ValueError + If `cmp` is not valid. + TypeError + If at least one of `a` or `b` is a non-string array + + Examples + -------- + >>> import numpy as np + >>> a = np.array(["a", "b", "cde"]) + >>> b = np.array(["a", "a", "dec"]) + >>> np.char.compare_chararrays(a, b, ">", True) + array([False, True, False]) + + """) + +add_newdoc('numpy._core.multiarray', 'fromiter', + """ + fromiter(iter, dtype, count=-1, *, like=None) + + Create a new 1-dimensional array from an iterable object. + + Parameters + ---------- + iter : iterable object + An iterable object providing data for the array. + dtype : data-type + The data-type of the returned array. + + .. versionchanged:: 1.23 + Object and subarray dtypes are now supported (note that the final + result is not 1-D for a subarray dtype). + + count : int, optional + The number of items to read from *iterable*. The default is -1, + which means all data is read. + ${ARRAY_FUNCTION_LIKE} + + .. versionadded:: 1.20.0 + + Returns + ------- + out : ndarray + The output array. + + Notes + ----- + Specify `count` to improve performance. It allows ``fromiter`` to + pre-allocate the output array, instead of resizing it on demand. + + Examples + -------- + >>> import numpy as np + >>> iterable = (x*x for x in range(5)) + >>> np.fromiter(iterable, float) + array([ 0., 1., 4., 9., 16.]) + + A carefully constructed subarray dtype will lead to higher dimensional + results: + + >>> iterable = ((x+1, x+2) for x in range(5)) + >>> np.fromiter(iterable, dtype=np.dtype((int, 2))) + array([[1, 2], + [2, 3], + [3, 4], + [4, 5], + [5, 6]]) + + + """.replace( + "${ARRAY_FUNCTION_LIKE}", + array_function_like_doc, + )) + +add_newdoc('numpy._core.multiarray', 'fromfile', + """ + fromfile(file, dtype=float, count=-1, sep='', offset=0, *, like=None) + + Construct an array from data in a text or binary file. + + A highly efficient way of reading binary data with a known data-type, + as well as parsing simply formatted text files. Data written using the + `tofile` method can be read using this function. + + Parameters + ---------- + file : file or str or Path + Open file object or filename. + + .. versionchanged:: 1.17.0 + `pathlib.Path` objects are now accepted. + + dtype : data-type + Data type of the returned array. + For binary files, it is used to determine the size and byte-order + of the items in the file. + Most builtin numeric types are supported and extension types may be supported. + + .. versionadded:: 1.18.0 + Complex dtypes. + + count : int + Number of items to read. ``-1`` means all items (i.e., the complete + file). + sep : str + Separator between items if file is a text file. + Empty ("") separator means the file should be treated as binary. + Spaces (" ") in the separator match zero or more whitespace characters. + A separator consisting only of spaces must match at least one + whitespace. + offset : int + The offset (in bytes) from the file's current position. Defaults to 0. + Only permitted for binary files. + + .. versionadded:: 1.17.0 + ${ARRAY_FUNCTION_LIKE} + + .. versionadded:: 1.20.0 + + See also + -------- + load, save + ndarray.tofile + loadtxt : More flexible way of loading data from a text file. + + Notes + ----- + Do not rely on the combination of `tofile` and `fromfile` for + data storage, as the binary files generated are not platform + independent. In particular, no byte-order or data-type information is + saved. Data can be stored in the platform independent ``.npy`` format + using `save` and `load` instead. + + Examples + -------- + Construct an ndarray: + + >>> import numpy as np + >>> dt = np.dtype([('time', [('min', np.int64), ('sec', np.int64)]), + ... ('temp', float)]) + >>> x = np.zeros((1,), dtype=dt) + >>> x['time']['min'] = 10; x['temp'] = 98.25 + >>> x + array([((10, 0), 98.25)], + dtype=[('time', [('min', '>> import tempfile + >>> fname = tempfile.mkstemp()[1] + >>> x.tofile(fname) + + Read the raw data from disk: + + >>> np.fromfile(fname, dtype=dt) + array([((10, 0), 98.25)], + dtype=[('time', [('min', '>> np.save(fname, x) + >>> np.load(fname + '.npy') + array([((10, 0), 98.25)], + dtype=[('time', [('min', '>> dt = np.dtype(int) + >>> dt = dt.newbyteorder('>') + >>> np.frombuffer(buf, dtype=dt) # doctest: +SKIP + + The data of the resulting array will not be byteswapped, but will be + interpreted correctly. + + This function creates a view into the original object. This should be safe + in general, but it may make sense to copy the result when the original + object is mutable or untrusted. + + Examples + -------- + >>> import numpy as np + >>> s = b'hello world' + >>> np.frombuffer(s, dtype='S1', count=5, offset=6) + array([b'w', b'o', b'r', b'l', b'd'], dtype='|S1') + + >>> np.frombuffer(b'\\x01\\x02', dtype=np.uint8) + array([1, 2], dtype=uint8) + >>> np.frombuffer(b'\\x01\\x02\\x03\\x04\\x05', dtype=np.uint8, count=3) + array([1, 2, 3], dtype=uint8) + + """.replace( + "${ARRAY_FUNCTION_LIKE}", + array_function_like_doc, + )) + +add_newdoc('numpy._core.multiarray', 'from_dlpack', + """ + from_dlpack(x, /, *, device=None, copy=None) + + Create a NumPy array from an object implementing the ``__dlpack__`` + protocol. Generally, the returned NumPy array is a read-only view + of the input object. See [1]_ and [2]_ for more details. + + Parameters + ---------- + x : object + A Python object that implements the ``__dlpack__`` and + ``__dlpack_device__`` methods. + device : device, optional + Device on which to place the created array. Default: ``None``. + Must be ``"cpu"`` if passed which may allow importing an array + that is not already CPU available. + copy : bool, optional + Boolean indicating whether or not to copy the input. If ``True``, + the copy will be made. If ``False``, the function will never copy, + and will raise ``BufferError`` in case a copy is deemed necessary. + Passing it requests a copy from the exporter who may or may not + implement the capability. + If ``None``, the function will reuse the existing memory buffer if + possible and copy otherwise. Default: ``None``. + + + Returns + ------- + out : ndarray + + References + ---------- + .. [1] Array API documentation, + https://data-apis.org/array-api/latest/design_topics/data_interchange.html#syntax-for-data-interchange-with-dlpack + + .. [2] Python specification for DLPack, + https://dmlc.github.io/dlpack/latest/python_spec.html + + Examples + -------- + >>> import torch # doctest: +SKIP + >>> x = torch.arange(10) # doctest: +SKIP + >>> # create a view of the torch tensor "x" in NumPy + >>> y = np.from_dlpack(x) # doctest: +SKIP + """) + +add_newdoc('numpy._core.multiarray', 'correlate', + """cross_correlate(a,v, mode=0)""") + +add_newdoc('numpy._core.multiarray', 'arange', + """ + arange([start,] stop[, step,], dtype=None, *, device=None, like=None) + + Return evenly spaced values within a given interval. + + ``arange`` can be called with a varying number of positional arguments: + + * ``arange(stop)``: Values are generated within the half-open interval + ``[0, stop)`` (in other words, the interval including `start` but + excluding `stop`). + * ``arange(start, stop)``: Values are generated within the half-open + interval ``[start, stop)``. + * ``arange(start, stop, step)`` Values are generated within the half-open + interval ``[start, stop)``, with spacing between values given by + ``step``. + + For integer arguments the function is roughly equivalent to the Python + built-in :py:class:`range`, but returns an ndarray rather than a ``range`` + instance. + + When using a non-integer step, such as 0.1, it is often better to use + `numpy.linspace`. + + See the Warning sections below for more information. + + Parameters + ---------- + start : integer or real, optional + Start of interval. The interval includes this value. The default + start value is 0. + stop : integer or real + End of interval. The interval does not include this value, except + in some cases where `step` is not an integer and floating point + round-off affects the length of `out`. + step : integer or real, optional + Spacing between values. For any output `out`, this is the distance + between two adjacent values, ``out[i+1] - out[i]``. The default + step size is 1. If `step` is specified as a position argument, + `start` must also be given. + dtype : dtype, optional + The type of the output array. If `dtype` is not given, infer the data + type from the other input arguments. + device : str, optional + The device on which to place the created array. Default: ``None``. + For Array-API interoperability only, so must be ``"cpu"`` if passed. + + .. versionadded:: 2.0.0 + ${ARRAY_FUNCTION_LIKE} + + .. versionadded:: 1.20.0 + + Returns + ------- + arange : ndarray + Array of evenly spaced values. + + For floating point arguments, the length of the result is + ``ceil((stop - start)/step)``. Because of floating point overflow, + this rule may result in the last element of `out` being greater + than `stop`. + + Warnings + -------- + The length of the output might not be numerically stable. + + Another stability issue is due to the internal implementation of + `numpy.arange`. + The actual step value used to populate the array is + ``dtype(start + step) - dtype(start)`` and not `step`. Precision loss + can occur here, due to casting or due to using floating points when + `start` is much larger than `step`. This can lead to unexpected + behaviour. For example:: + + >>> np.arange(0, 5, 0.5, dtype=int) + array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0]) + >>> np.arange(-3, 3, 0.5, dtype=int) + array([-3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8]) + + In such cases, the use of `numpy.linspace` should be preferred. + + The built-in :py:class:`range` generates :std:doc:`Python built-in integers + that have arbitrary size `, while `numpy.arange` + produces `numpy.int32` or `numpy.int64` numbers. This may result in + incorrect results for large integer values:: + + >>> power = 40 + >>> modulo = 10000 + >>> x1 = [(n ** power) % modulo for n in range(8)] + >>> x2 = [(n ** power) % modulo for n in np.arange(8)] + >>> print(x1) + [0, 1, 7776, 8801, 6176, 625, 6576, 4001] # correct + >>> print(x2) + [0, 1, 7776, 7185, 0, 5969, 4816, 3361] # incorrect + + See Also + -------- + numpy.linspace : Evenly spaced numbers with careful handling of endpoints. + numpy.ogrid: Arrays of evenly spaced numbers in N-dimensions. + numpy.mgrid: Grid-shaped arrays of evenly spaced numbers in N-dimensions. + :ref:`how-to-partition` + + Examples + -------- + >>> import numpy as np + >>> np.arange(3) + array([0, 1, 2]) + >>> np.arange(3.0) + array([ 0., 1., 2.]) + >>> np.arange(3,7) + array([3, 4, 5, 6]) + >>> np.arange(3,7,2) + array([3, 5]) + + """.replace( + "${ARRAY_FUNCTION_LIKE}", + array_function_like_doc, + )) + +add_newdoc('numpy._core.multiarray', '_get_ndarray_c_version', + """_get_ndarray_c_version() + + Return the compile time NPY_VERSION (formerly called NDARRAY_VERSION) number. + + """) + +add_newdoc('numpy._core.multiarray', '_reconstruct', + """_reconstruct(subtype, shape, dtype) + + Construct an empty array. Used by Pickles. + + """) + +add_newdoc('numpy._core.multiarray', 'promote_types', + """ + promote_types(type1, type2) + + Returns the data type with the smallest size and smallest scalar + kind to which both ``type1`` and ``type2`` may be safely cast. + The returned data type is always considered "canonical", this mainly + means that the promoted dtype will always be in native byte order. + + This function is symmetric, but rarely associative. + + Parameters + ---------- + type1 : dtype or dtype specifier + First data type. + type2 : dtype or dtype specifier + Second data type. + + Returns + ------- + out : dtype + The promoted data type. + + Notes + ----- + Please see `numpy.result_type` for additional information about promotion. + + .. versionadded:: 1.6.0 + + Starting in NumPy 1.9, promote_types function now returns a valid string + length when given an integer or float dtype as one argument and a string + dtype as another argument. Previously it always returned the input string + dtype, even if it wasn't long enough to store the max integer/float value + converted to a string. + + .. versionchanged:: 1.23.0 + + NumPy now supports promotion for more structured dtypes. It will now + remove unnecessary padding from a structure dtype and promote included + fields individually. + + See Also + -------- + result_type, dtype, can_cast + + Examples + -------- + >>> import numpy as np + >>> np.promote_types('f4', 'f8') + dtype('float64') + + >>> np.promote_types('i8', 'f4') + dtype('float64') + + >>> np.promote_types('>i8', '>> np.promote_types('i4', 'S8') + dtype('S11') + + An example of a non-associative case: + + >>> p = np.promote_types + >>> p('S', p('i1', 'u1')) + dtype('S6') + >>> p(p('S', 'i1'), 'u1') + dtype('S4') + + """) + +add_newdoc('numpy._core.multiarray', 'c_einsum', + """ + c_einsum(subscripts, *operands, out=None, dtype=None, order='K', + casting='safe') + + *This documentation shadows that of the native python implementation of the `einsum` function, + except all references and examples related to the `optimize` argument (v 0.12.0) have been removed.* + + Evaluates the Einstein summation convention on the operands. + + Using the Einstein summation convention, many common multi-dimensional, + linear algebraic array operations can be represented in a simple fashion. + In *implicit* mode `einsum` computes these values. + + In *explicit* mode, `einsum` provides further flexibility to compute + other array operations that might not be considered classical Einstein + summation operations, by disabling, or forcing summation over specified + subscript labels. + + See the notes and examples for clarification. + + Parameters + ---------- + subscripts : str + Specifies the subscripts for summation as comma separated list of + subscript labels. An implicit (classical Einstein summation) + calculation is performed unless the explicit indicator '->' is + included as well as subscript labels of the precise output form. + operands : list of array_like + These are the arrays for the operation. + out : ndarray, optional + If provided, the calculation is done into this array. + dtype : {data-type, None}, optional + If provided, forces the calculation to use the data type specified. + Note that you may have to also give a more liberal `casting` + parameter to allow the conversions. Default is None. + order : {'C', 'F', 'A', 'K'}, optional + Controls the memory layout of the output. 'C' means it should + be C contiguous. 'F' means it should be Fortran contiguous, + 'A' means it should be 'F' if the inputs are all 'F', 'C' otherwise. + 'K' means it should be as close to the layout of the inputs as + is possible, including arbitrarily permuted axes. + Default is 'K'. + casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional + Controls what kind of data casting may occur. Setting this to + 'unsafe' is not recommended, as it can adversely affect accumulations. + + * 'no' means the data types should not be cast at all. + * 'equiv' means only byte-order changes are allowed. + * 'safe' means only casts which can preserve values are allowed. + * 'same_kind' means only safe casts or casts within a kind, + like float64 to float32, are allowed. + * 'unsafe' means any data conversions may be done. + + Default is 'safe'. + optimize : {False, True, 'greedy', 'optimal'}, optional + Controls if intermediate optimization should occur. No optimization + will occur if False and True will default to the 'greedy' algorithm. + Also accepts an explicit contraction list from the ``np.einsum_path`` + function. See ``np.einsum_path`` for more details. Defaults to False. + + Returns + ------- + output : ndarray + The calculation based on the Einstein summation convention. + + See Also + -------- + einsum_path, dot, inner, outer, tensordot, linalg.multi_dot + + Notes + ----- + .. versionadded:: 1.6.0 + + The Einstein summation convention can be used to compute + many multi-dimensional, linear algebraic array operations. `einsum` + provides a succinct way of representing these. + + A non-exhaustive list of these operations, + which can be computed by `einsum`, is shown below along with examples: + + * Trace of an array, :py:func:`numpy.trace`. + * Return a diagonal, :py:func:`numpy.diag`. + * Array axis summations, :py:func:`numpy.sum`. + * Transpositions and permutations, :py:func:`numpy.transpose`. + * Matrix multiplication and dot product, :py:func:`numpy.matmul` :py:func:`numpy.dot`. + * Vector inner and outer products, :py:func:`numpy.inner` :py:func:`numpy.outer`. + * Broadcasting, element-wise and scalar multiplication, :py:func:`numpy.multiply`. + * Tensor contractions, :py:func:`numpy.tensordot`. + * Chained array operations, in efficient calculation order, :py:func:`numpy.einsum_path`. + + The subscripts string is a comma-separated list of subscript labels, + where each label refers to a dimension of the corresponding operand. + Whenever a label is repeated it is summed, so ``np.einsum('i,i', a, b)`` + is equivalent to :py:func:`np.inner(a,b) `. If a label + appears only once, it is not summed, so ``np.einsum('i', a)`` produces a + view of ``a`` with no changes. A further example ``np.einsum('ij,jk', a, b)`` + describes traditional matrix multiplication and is equivalent to + :py:func:`np.matmul(a,b) `. Repeated subscript labels in one + operand take the diagonal. For example, ``np.einsum('ii', a)`` is equivalent + to :py:func:`np.trace(a) `. + + In *implicit mode*, the chosen subscripts are important + since the axes of the output are reordered alphabetically. This + means that ``np.einsum('ij', a)`` doesn't affect a 2D array, while + ``np.einsum('ji', a)`` takes its transpose. Additionally, + ``np.einsum('ij,jk', a, b)`` returns a matrix multiplication, while, + ``np.einsum('ij,jh', a, b)`` returns the transpose of the + multiplication since subscript 'h' precedes subscript 'i'. + + In *explicit mode* the output can be directly controlled by + specifying output subscript labels. This requires the + identifier '->' as well as the list of output subscript labels. + This feature increases the flexibility of the function since + summing can be disabled or forced when required. The call + ``np.einsum('i->', a)`` is like :py:func:`np.sum(a) ` + if ``a`` is a 1-D array, and ``np.einsum('ii->i', a)`` + is like :py:func:`np.diag(a) ` if ``a`` is a square 2-D array. + The difference is that `einsum` does not allow broadcasting by default. + Additionally ``np.einsum('ij,jh->ih', a, b)`` directly specifies the + order of the output subscript labels and therefore returns matrix + multiplication, unlike the example above in implicit mode. + + To enable and control broadcasting, use an ellipsis. Default + NumPy-style broadcasting is done by adding an ellipsis + to the left of each term, like ``np.einsum('...ii->...i', a)``. + ``np.einsum('...i->...', a)`` is like + :py:func:`np.sum(a, axis=-1) ` for array ``a`` of any shape. + To take the trace along the first and last axes, + you can do ``np.einsum('i...i', a)``, or to do a matrix-matrix + product with the left-most indices instead of rightmost, one can do + ``np.einsum('ij...,jk...->ik...', a, b)``. + + When there is only one operand, no axes are summed, and no output + parameter is provided, a view into the operand is returned instead + of a new array. Thus, taking the diagonal as ``np.einsum('ii->i', a)`` + produces a view (changed in version 1.10.0). + + `einsum` also provides an alternative way to provide the subscripts + and operands as ``einsum(op0, sublist0, op1, sublist1, ..., [sublistout])``. + If the output shape is not provided in this format `einsum` will be + calculated in implicit mode, otherwise it will be performed explicitly. + The examples below have corresponding `einsum` calls with the two + parameter methods. + + .. versionadded:: 1.10.0 + + Views returned from einsum are now writeable whenever the input array + is writeable. For example, ``np.einsum('ijk...->kji...', a)`` will now + have the same effect as :py:func:`np.swapaxes(a, 0, 2) ` + and ``np.einsum('ii->i', a)`` will return a writeable view of the diagonal + of a 2D array. + + Examples + -------- + >>> import numpy as np + >>> a = np.arange(25).reshape(5,5) + >>> b = np.arange(5) + >>> c = np.arange(6).reshape(2,3) + + Trace of a matrix: + + >>> np.einsum('ii', a) + 60 + >>> np.einsum(a, [0,0]) + 60 + >>> np.trace(a) + 60 + + Extract the diagonal (requires explicit form): + + >>> np.einsum('ii->i', a) + array([ 0, 6, 12, 18, 24]) + >>> np.einsum(a, [0,0], [0]) + array([ 0, 6, 12, 18, 24]) + >>> np.diag(a) + array([ 0, 6, 12, 18, 24]) + + Sum over an axis (requires explicit form): + + >>> np.einsum('ij->i', a) + array([ 10, 35, 60, 85, 110]) + >>> np.einsum(a, [0,1], [0]) + array([ 10, 35, 60, 85, 110]) + >>> np.sum(a, axis=1) + array([ 10, 35, 60, 85, 110]) + + For higher dimensional arrays summing a single axis can be done with ellipsis: + + >>> np.einsum('...j->...', a) + array([ 10, 35, 60, 85, 110]) + >>> np.einsum(a, [Ellipsis,1], [Ellipsis]) + array([ 10, 35, 60, 85, 110]) + + Compute a matrix transpose, or reorder any number of axes: + + >>> np.einsum('ji', c) + array([[0, 3], + [1, 4], + [2, 5]]) + >>> np.einsum('ij->ji', c) + array([[0, 3], + [1, 4], + [2, 5]]) + >>> np.einsum(c, [1,0]) + array([[0, 3], + [1, 4], + [2, 5]]) + >>> np.transpose(c) + array([[0, 3], + [1, 4], + [2, 5]]) + + Vector inner products: + + >>> np.einsum('i,i', b, b) + 30 + >>> np.einsum(b, [0], b, [0]) + 30 + >>> np.inner(b,b) + 30 + + Matrix vector multiplication: + + >>> np.einsum('ij,j', a, b) + array([ 30, 80, 130, 180, 230]) + >>> np.einsum(a, [0,1], b, [1]) + array([ 30, 80, 130, 180, 230]) + >>> np.dot(a, b) + array([ 30, 80, 130, 180, 230]) + >>> np.einsum('...j,j', a, b) + array([ 30, 80, 130, 180, 230]) + + Broadcasting and scalar multiplication: + + >>> np.einsum('..., ...', 3, c) + array([[ 0, 3, 6], + [ 9, 12, 15]]) + >>> np.einsum(',ij', 3, c) + array([[ 0, 3, 6], + [ 9, 12, 15]]) + >>> np.einsum(3, [Ellipsis], c, [Ellipsis]) + array([[ 0, 3, 6], + [ 9, 12, 15]]) + >>> np.multiply(3, c) + array([[ 0, 3, 6], + [ 9, 12, 15]]) + + Vector outer product: + + >>> np.einsum('i,j', np.arange(2)+1, b) + array([[0, 1, 2, 3, 4], + [0, 2, 4, 6, 8]]) + >>> np.einsum(np.arange(2)+1, [0], b, [1]) + array([[0, 1, 2, 3, 4], + [0, 2, 4, 6, 8]]) + >>> np.outer(np.arange(2)+1, b) + array([[0, 1, 2, 3, 4], + [0, 2, 4, 6, 8]]) + + Tensor contraction: + + >>> a = np.arange(60.).reshape(3,4,5) + >>> b = np.arange(24.).reshape(4,3,2) + >>> np.einsum('ijk,jil->kl', a, b) + array([[ 4400., 4730.], + [ 4532., 4874.], + [ 4664., 5018.], + [ 4796., 5162.], + [ 4928., 5306.]]) + >>> np.einsum(a, [0,1,2], b, [1,0,3], [2,3]) + array([[ 4400., 4730.], + [ 4532., 4874.], + [ 4664., 5018.], + [ 4796., 5162.], + [ 4928., 5306.]]) + >>> np.tensordot(a,b, axes=([1,0],[0,1])) + array([[ 4400., 4730.], + [ 4532., 4874.], + [ 4664., 5018.], + [ 4796., 5162.], + [ 4928., 5306.]]) + + Writeable returned arrays (since version 1.10.0): + + >>> a = np.zeros((3, 3)) + >>> np.einsum('ii->i', a)[:] = 1 + >>> a + array([[ 1., 0., 0.], + [ 0., 1., 0.], + [ 0., 0., 1.]]) + + Example of ellipsis use: + + >>> a = np.arange(6).reshape((3,2)) + >>> b = np.arange(12).reshape((4,3)) + >>> np.einsum('ki,jk->ij', a, b) + array([[10, 28, 46, 64], + [13, 40, 67, 94]]) + >>> np.einsum('ki,...k->i...', a, b) + array([[10, 28, 46, 64], + [13, 40, 67, 94]]) + >>> np.einsum('k...,jk', a, b) + array([[10, 28, 46, 64], + [13, 40, 67, 94]]) + + """) + + +############################################################################## +# +# Documentation for ndarray attributes and methods +# +############################################################################## + + +############################################################################## +# +# ndarray object +# +############################################################################## + + +add_newdoc('numpy._core.multiarray', 'ndarray', + """ + ndarray(shape, dtype=float, buffer=None, offset=0, + strides=None, order=None) + + An array object represents a multidimensional, homogeneous array + of fixed-size items. An associated data-type object describes the + format of each element in the array (its byte-order, how many bytes it + occupies in memory, whether it is an integer, a floating point number, + or something else, etc.) + + Arrays should be constructed using `array`, `zeros` or `empty` (refer + to the See Also section below). The parameters given here refer to + a low-level method (`ndarray(...)`) for instantiating an array. + + For more information, refer to the `numpy` module and examine the + methods and attributes of an array. + + Parameters + ---------- + (for the __new__ method; see Notes below) + + shape : tuple of ints + Shape of created array. + dtype : data-type, optional + Any object that can be interpreted as a numpy data type. + buffer : object exposing buffer interface, optional + Used to fill the array with data. + offset : int, optional + Offset of array data in buffer. + strides : tuple of ints, optional + Strides of data in memory. + order : {'C', 'F'}, optional + Row-major (C-style) or column-major (Fortran-style) order. + + Attributes + ---------- + T : ndarray + Transpose of the array. + data : buffer + The array's elements, in memory. + dtype : dtype object + Describes the format of the elements in the array. + flags : dict + Dictionary containing information related to memory use, e.g., + 'C_CONTIGUOUS', 'OWNDATA', 'WRITEABLE', etc. + flat : numpy.flatiter object + Flattened version of the array as an iterator. The iterator + allows assignments, e.g., ``x.flat = 3`` (See `ndarray.flat` for + assignment examples; TODO). + imag : ndarray + Imaginary part of the array. + real : ndarray + Real part of the array. + size : int + Number of elements in the array. + itemsize : int + The memory use of each array element in bytes. + nbytes : int + The total number of bytes required to store the array data, + i.e., ``itemsize * size``. + ndim : int + The array's number of dimensions. + shape : tuple of ints + Shape of the array. + strides : tuple of ints + The step-size required to move from one element to the next in + memory. For example, a contiguous ``(3, 4)`` array of type + ``int16`` in C-order has strides ``(8, 2)``. This implies that + to move from element to element in memory requires jumps of 2 bytes. + To move from row-to-row, one needs to jump 8 bytes at a time + (``2 * 4``). + ctypes : ctypes object + Class containing properties of the array needed for interaction + with ctypes. + base : ndarray + If the array is a view into another array, that array is its `base` + (unless that array is also a view). The `base` array is where the + array data is actually stored. + + See Also + -------- + array : Construct an array. + zeros : Create an array, each element of which is zero. + empty : Create an array, but leave its allocated memory unchanged (i.e., + it contains "garbage"). + dtype : Create a data-type. + numpy.typing.NDArray : An ndarray alias :term:`generic ` + w.r.t. its `dtype.type `. + + Notes + ----- + There are two modes of creating an array using ``__new__``: + + 1. If `buffer` is None, then only `shape`, `dtype`, and `order` + are used. + 2. If `buffer` is an object exposing the buffer interface, then + all keywords are interpreted. + + No ``__init__`` method is needed because the array is fully initialized + after the ``__new__`` method. + + Examples + -------- + These examples illustrate the low-level `ndarray` constructor. Refer + to the `See Also` section above for easier ways of constructing an + ndarray. + + First mode, `buffer` is None: + + >>> import numpy as np + >>> np.ndarray(shape=(2,2), dtype=float, order='F') + array([[0.0e+000, 0.0e+000], # random + [ nan, 2.5e-323]]) + + Second mode: + + >>> np.ndarray((2,), buffer=np.array([1,2,3]), + ... offset=np.int_().itemsize, + ... dtype=int) # offset = 1*itemsize, i.e. skip first element + array([2, 3]) + + """) + + +############################################################################## +# +# ndarray attributes +# +############################################################################## + + +add_newdoc('numpy._core.multiarray', 'ndarray', ('__array_interface__', + """Array protocol: Python side.""")) + + +add_newdoc('numpy._core.multiarray', 'ndarray', ('__array_priority__', + """Array priority.""")) + + +add_newdoc('numpy._core.multiarray', 'ndarray', ('__array_struct__', + """Array protocol: C-struct side.""")) + +add_newdoc('numpy._core.multiarray', 'ndarray', ('__dlpack__', + """ + a.__dlpack__(*, stream=None, max_version=None, dl_device=None, copy=None) + + DLPack Protocol: Part of the Array API. + + """)) + +add_newdoc('numpy._core.multiarray', 'ndarray', ('__dlpack_device__', + """ + a.__dlpack_device__() + + DLPack Protocol: Part of the Array API. + + """)) + +add_newdoc('numpy._core.multiarray', 'ndarray', ('base', + """ + Base object if memory is from some other object. + + Examples + -------- + The base of an array that owns its memory is None: + + >>> import numpy as np + >>> x = np.array([1,2,3,4]) + >>> x.base is None + True + + Slicing creates a view, whose memory is shared with x: + + >>> y = x[2:] + >>> y.base is x + True + + """)) + + +add_newdoc('numpy._core.multiarray', 'ndarray', ('ctypes', + """ + An object to simplify the interaction of the array with the ctypes + module. + + This attribute creates an object that makes it easier to use arrays + when calling shared libraries with the ctypes module. The returned + object has, among others, data, shape, and strides attributes (see + Notes below) which themselves return ctypes objects that can be used + as arguments to a shared library. + + Parameters + ---------- + None + + Returns + ------- + c : Python object + Possessing attributes data, shape, strides, etc. + + See Also + -------- + numpy.ctypeslib + + Notes + ----- + Below are the public attributes of this object which were documented + in "Guide to NumPy" (we have omitted undocumented public attributes, + as well as documented private attributes): + + .. autoattribute:: numpy._core._internal._ctypes.data + :noindex: + + .. autoattribute:: numpy._core._internal._ctypes.shape + :noindex: + + .. autoattribute:: numpy._core._internal._ctypes.strides + :noindex: + + .. automethod:: numpy._core._internal._ctypes.data_as + :noindex: + + .. automethod:: numpy._core._internal._ctypes.shape_as + :noindex: + + .. automethod:: numpy._core._internal._ctypes.strides_as + :noindex: + + If the ctypes module is not available, then the ctypes attribute + of array objects still returns something useful, but ctypes objects + are not returned and errors may be raised instead. In particular, + the object will still have the ``as_parameter`` attribute which will + return an integer equal to the data attribute. + + Examples + -------- + >>> import numpy as np + >>> import ctypes + >>> x = np.array([[0, 1], [2, 3]], dtype=np.int32) + >>> x + array([[0, 1], + [2, 3]], dtype=int32) + >>> x.ctypes.data + 31962608 # may vary + >>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_uint32)) + <__main__.LP_c_uint object at 0x7ff2fc1fc200> # may vary + >>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_uint32)).contents + c_uint(0) + >>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_uint64)).contents + c_ulong(4294967296) + >>> x.ctypes.shape + # may vary + >>> x.ctypes.strides + # may vary + + """)) + + +add_newdoc('numpy._core.multiarray', 'ndarray', ('data', + """Python buffer object pointing to the start of the array's data.""")) + + +add_newdoc('numpy._core.multiarray', 'ndarray', ('dtype', + """ + Data-type of the array's elements. + + .. warning:: + + Setting ``arr.dtype`` is discouraged and may be deprecated in the + future. Setting will replace the ``dtype`` without modifying the + memory (see also `ndarray.view` and `ndarray.astype`). + + Parameters + ---------- + None + + Returns + ------- + d : numpy dtype object + + See Also + -------- + ndarray.astype : Cast the values contained in the array to a new data-type. + ndarray.view : Create a view of the same data but a different data-type. + numpy.dtype + + Examples + -------- + >>> x + array([[0, 1], + [2, 3]]) + >>> x.dtype + dtype('int32') + >>> type(x.dtype) + + + """)) + + +add_newdoc('numpy._core.multiarray', 'ndarray', ('imag', + """ + The imaginary part of the array. + + Examples + -------- + >>> import numpy as np + >>> x = np.sqrt([1+0j, 0+1j]) + >>> x.imag + array([ 0. , 0.70710678]) + >>> x.imag.dtype + dtype('float64') + + """)) + + +add_newdoc('numpy._core.multiarray', 'ndarray', ('itemsize', + """ + Length of one array element in bytes. + + Examples + -------- + >>> import numpy as np + >>> x = np.array([1,2,3], dtype=np.float64) + >>> x.itemsize + 8 + >>> x = np.array([1,2,3], dtype=np.complex128) + >>> x.itemsize + 16 + + """)) + + +add_newdoc('numpy._core.multiarray', 'ndarray', ('flags', + """ + Information about the memory layout of the array. + + Attributes + ---------- + C_CONTIGUOUS (C) + The data is in a single, C-style contiguous segment. + F_CONTIGUOUS (F) + The data is in a single, Fortran-style contiguous segment. + OWNDATA (O) + The array owns the memory it uses or borrows it from another object. + WRITEABLE (W) + The data area can be written to. Setting this to False locks + the data, making it read-only. A view (slice, etc.) inherits WRITEABLE + from its base array at creation time, but a view of a writeable + array may be subsequently locked while the base array remains writeable. + (The opposite is not true, in that a view of a locked array may not + be made writeable. However, currently, locking a base object does not + lock any views that already reference it, so under that circumstance it + is possible to alter the contents of a locked array via a previously + created writeable view onto it.) Attempting to change a non-writeable + array raises a RuntimeError exception. + ALIGNED (A) + The data and all elements are aligned appropriately for the hardware. + WRITEBACKIFCOPY (X) + This array is a copy of some other array. The C-API function + PyArray_ResolveWritebackIfCopy must be called before deallocating + to the base array will be updated with the contents of this array. + FNC + F_CONTIGUOUS and not C_CONTIGUOUS. + FORC + F_CONTIGUOUS or C_CONTIGUOUS (one-segment test). + BEHAVED (B) + ALIGNED and WRITEABLE. + CARRAY (CA) + BEHAVED and C_CONTIGUOUS. + FARRAY (FA) + BEHAVED and F_CONTIGUOUS and not C_CONTIGUOUS. + + Notes + ----- + The `flags` object can be accessed dictionary-like (as in ``a.flags['WRITEABLE']``), + or by using lowercased attribute names (as in ``a.flags.writeable``). Short flag + names are only supported in dictionary access. + + Only the WRITEBACKIFCOPY, WRITEABLE, and ALIGNED flags can be + changed by the user, via direct assignment to the attribute or dictionary + entry, or by calling `ndarray.setflags`. + + The array flags cannot be set arbitrarily: + + - WRITEBACKIFCOPY can only be set ``False``. + - ALIGNED can only be set ``True`` if the data is truly aligned. + - WRITEABLE can only be set ``True`` if the array owns its own memory + or the ultimate owner of the memory exposes a writeable buffer + interface or is a string. + + Arrays can be both C-style and Fortran-style contiguous simultaneously. + This is clear for 1-dimensional arrays, but can also be true for higher + dimensional arrays. + + Even for contiguous arrays a stride for a given dimension + ``arr.strides[dim]`` may be *arbitrary* if ``arr.shape[dim] == 1`` + or the array has no elements. + It does *not* generally hold that ``self.strides[-1] == self.itemsize`` + for C-style contiguous arrays or ``self.strides[0] == self.itemsize`` for + Fortran-style contiguous arrays is true. + """)) + + +add_newdoc('numpy._core.multiarray', 'ndarray', ('flat', + """ + A 1-D iterator over the array. + + This is a `numpy.flatiter` instance, which acts similarly to, but is not + a subclass of, Python's built-in iterator object. + + See Also + -------- + flatten : Return a copy of the array collapsed into one dimension. + + flatiter + + Examples + -------- + >>> import numpy as np + >>> x = np.arange(1, 7).reshape(2, 3) + >>> x + array([[1, 2, 3], + [4, 5, 6]]) + >>> x.flat[3] + 4 + >>> x.T + array([[1, 4], + [2, 5], + [3, 6]]) + >>> x.T.flat[3] + 5 + >>> type(x.flat) + + + An assignment example: + + >>> x.flat = 3; x + array([[3, 3, 3], + [3, 3, 3]]) + >>> x.flat[[1,4]] = 1; x + array([[3, 1, 3], + [3, 1, 3]]) + + """)) + + +add_newdoc('numpy._core.multiarray', 'ndarray', ('nbytes', + """ + Total bytes consumed by the elements of the array. + + Notes + ----- + Does not include memory consumed by non-element attributes of the + array object. + + See Also + -------- + sys.getsizeof + Memory consumed by the object itself without parents in case view. + This does include memory consumed by non-element attributes. + + Examples + -------- + >>> import numpy as np + >>> x = np.zeros((3,5,2), dtype=np.complex128) + >>> x.nbytes + 480 + >>> np.prod(x.shape) * x.itemsize + 480 + + """)) + + +add_newdoc('numpy._core.multiarray', 'ndarray', ('ndim', + """ + Number of array dimensions. + + Examples + -------- + >>> import numpy as np + >>> x = np.array([1, 2, 3]) + >>> x.ndim + 1 + >>> y = np.zeros((2, 3, 4)) + >>> y.ndim + 3 + + """)) + + +add_newdoc('numpy._core.multiarray', 'ndarray', ('real', + """ + The real part of the array. + + Examples + -------- + >>> import numpy as np + >>> x = np.sqrt([1+0j, 0+1j]) + >>> x.real + array([ 1. , 0.70710678]) + >>> x.real.dtype + dtype('float64') + + See Also + -------- + numpy.real : equivalent function + + """)) + + +add_newdoc('numpy._core.multiarray', 'ndarray', ('shape', + """ + Tuple of array dimensions. + + The shape property is usually used to get the current shape of an array, + but may also be used to reshape the array in-place by assigning a tuple of + array dimensions to it. As with `numpy.reshape`, one of the new shape + dimensions can be -1, in which case its value is inferred from the size of + the array and the remaining dimensions. Reshaping an array in-place will + fail if a copy is required. + + .. warning:: + + Setting ``arr.shape`` is discouraged and may be deprecated in the + future. Using `ndarray.reshape` is the preferred approach. + + Examples + -------- + >>> import numpy as np + >>> x = np.array([1, 2, 3, 4]) + >>> x.shape + (4,) + >>> y = np.zeros((2, 3, 4)) + >>> y.shape + (2, 3, 4) + >>> y.shape = (3, 8) + >>> y + array([[ 0., 0., 0., 0., 0., 0., 0., 0.], + [ 0., 0., 0., 0., 0., 0., 0., 0.], + [ 0., 0., 0., 0., 0., 0., 0., 0.]]) + >>> y.shape = (3, 6) + Traceback (most recent call last): + File "", line 1, in + ValueError: total size of new array must be unchanged + >>> np.zeros((4,2))[::2].shape = (-1,) + Traceback (most recent call last): + File "", line 1, in + AttributeError: Incompatible shape for in-place modification. Use + `.reshape()` to make a copy with the desired shape. + + See Also + -------- + numpy.shape : Equivalent getter function. + numpy.reshape : Function similar to setting ``shape``. + ndarray.reshape : Method similar to setting ``shape``. + + """)) + + +add_newdoc('numpy._core.multiarray', 'ndarray', ('size', + """ + Number of elements in the array. + + Equal to ``np.prod(a.shape)``, i.e., the product of the array's + dimensions. + + Notes + ----- + `a.size` returns a standard arbitrary precision Python integer. This + may not be the case with other methods of obtaining the same value + (like the suggested ``np.prod(a.shape)``, which returns an instance + of ``np.int_``), and may be relevant if the value is used further in + calculations that may overflow a fixed size integer type. + + Examples + -------- + >>> import numpy as np + >>> x = np.zeros((3, 5, 2), dtype=np.complex128) + >>> x.size + 30 + >>> np.prod(x.shape) + 30 + + """)) + + +add_newdoc('numpy._core.multiarray', 'ndarray', ('strides', + """ + Tuple of bytes to step in each dimension when traversing an array. + + The byte offset of element ``(i[0], i[1], ..., i[n])`` in an array `a` + is:: + + offset = sum(np.array(i) * a.strides) + + A more detailed explanation of strides can be found in + :ref:`arrays.ndarray`. + + .. warning:: + + Setting ``arr.strides`` is discouraged and may be deprecated in the + future. `numpy.lib.stride_tricks.as_strided` should be preferred + to create a new view of the same data in a safer way. + + Notes + ----- + Imagine an array of 32-bit integers (each 4 bytes):: + + x = np.array([[0, 1, 2, 3, 4], + [5, 6, 7, 8, 9]], dtype=np.int32) + + This array is stored in memory as 40 bytes, one after the other + (known as a contiguous block of memory). The strides of an array tell + us how many bytes we have to skip in memory to move to the next position + along a certain axis. For example, we have to skip 4 bytes (1 value) to + move to the next column, but 20 bytes (5 values) to get to the same + position in the next row. As such, the strides for the array `x` will be + ``(20, 4)``. + + See Also + -------- + numpy.lib.stride_tricks.as_strided + + Examples + -------- + >>> import numpy as np + >>> y = np.reshape(np.arange(2*3*4), (2,3,4)) + >>> y + array([[[ 0, 1, 2, 3], + [ 4, 5, 6, 7], + [ 8, 9, 10, 11]], + [[12, 13, 14, 15], + [16, 17, 18, 19], + [20, 21, 22, 23]]]) + >>> y.strides + (48, 16, 4) + >>> y[1,1,1] + 17 + >>> offset=sum(y.strides * np.array((1,1,1))) + >>> offset/y.itemsize + 17 + + >>> x = np.reshape(np.arange(5*6*7*8), (5,6,7,8)).transpose(2,3,1,0) + >>> x.strides + (32, 4, 224, 1344) + >>> i = np.array([3,5,2,2]) + >>> offset = sum(i * x.strides) + >>> x[3,5,2,2] + 813 + >>> offset / x.itemsize + 813 + + """)) + + +add_newdoc('numpy._core.multiarray', 'ndarray', ('T', + """ + View of the transposed array. + + Same as ``self.transpose()``. + + Examples + -------- + >>> import numpy as np + >>> a = np.array([[1, 2], [3, 4]]) + >>> a + array([[1, 2], + [3, 4]]) + >>> a.T + array([[1, 3], + [2, 4]]) + + >>> a = np.array([1, 2, 3, 4]) + >>> a + array([1, 2, 3, 4]) + >>> a.T + array([1, 2, 3, 4]) + + See Also + -------- + transpose + + """)) + + +add_newdoc('numpy._core.multiarray', 'ndarray', ('mT', + """ + View of the matrix transposed array. + + The matrix transpose is the transpose of the last two dimensions, even + if the array is of higher dimension. + + .. versionadded:: 2.0 + + Raises + ------ + ValueError + If the array is of dimension less than 2. + + Examples + -------- + >>> import numpy as np + >>> a = np.array([[1, 2], [3, 4]]) + >>> a + array([[1, 2], + [3, 4]]) + >>> a.mT + array([[1, 3], + [2, 4]]) + + >>> a = np.arange(8).reshape((2, 2, 2)) + >>> a + array([[[0, 1], + [2, 3]], + + [[4, 5], + [6, 7]]]) + >>> a.mT + array([[[0, 2], + [1, 3]], + + [[4, 6], + [5, 7]]]) + + """)) +############################################################################## +# +# ndarray methods +# +############################################################################## + + +add_newdoc('numpy._core.multiarray', 'ndarray', ('__array__', + """ + a.__array__([dtype], *, copy=None) + + For ``dtype`` parameter it returns a new reference to self if + ``dtype`` is not given or it matches array's data type. + A new array of provided data type is returned if ``dtype`` + is different from the current data type of the array. + For ``copy`` parameter it returns a new reference to self if + ``copy=False`` or ``copy=None`` and copying isn't enforced by ``dtype`` + parameter. The method returns a new array for ``copy=True``, regardless of + ``dtype`` parameter. + + A more detailed explanation of the ``__array__`` interface + can be found in :ref:`dunder_array.interface`. + + """)) + + +add_newdoc('numpy._core.multiarray', 'ndarray', ('__array_finalize__', + """ + a.__array_finalize__(obj, /) + + Present so subclasses can call super. Does nothing. + + """)) + + +add_newdoc('numpy._core.multiarray', 'ndarray', ('__array_wrap__', + """ + a.__array_wrap__(array[, context], /) + + Returns a view of `array` with the same type as self. + + """)) + + +add_newdoc('numpy._core.multiarray', 'ndarray', ('__copy__', + """ + a.__copy__() + + Used if :func:`copy.copy` is called on an array. Returns a copy of the array. + + Equivalent to ``a.copy(order='K')``. + + """)) + + +add_newdoc('numpy._core.multiarray', 'ndarray', ('__class_getitem__', + """ + a.__class_getitem__(item, /) + + Return a parametrized wrapper around the `~numpy.ndarray` type. + + .. versionadded:: 1.22 + + Returns + ------- + alias : types.GenericAlias + A parametrized `~numpy.ndarray` type. + + Examples + -------- + >>> from typing import Any + >>> import numpy as np + + >>> np.ndarray[Any, np.dtype[Any]] + numpy.ndarray[typing.Any, numpy.dtype[typing.Any]] + + See Also + -------- + :pep:`585` : Type hinting generics in standard collections. + numpy.typing.NDArray : An ndarray alias :term:`generic ` + w.r.t. its `dtype.type `. + + """)) + + +add_newdoc('numpy._core.multiarray', 'ndarray', ('__deepcopy__', + """ + a.__deepcopy__(memo, /) + + Used if :func:`copy.deepcopy` is called on an array. + + """)) + + +add_newdoc('numpy._core.multiarray', 'ndarray', ('__reduce__', + """ + a.__reduce__() + + For pickling. + + """)) + + +add_newdoc('numpy._core.multiarray', 'ndarray', ('__setstate__', + """ + a.__setstate__(state, /) + + For unpickling. + + The `state` argument must be a sequence that contains the following + elements: + + Parameters + ---------- + version : int + optional pickle version. If omitted defaults to 0. + shape : tuple + dtype : data-type + isFortran : bool + rawdata : string or list + a binary string with the data (or a list if 'a' is an object array) + + """)) + + +add_newdoc('numpy._core.multiarray', 'ndarray', ('all', + """ + a.all(axis=None, out=None, keepdims=False, *, where=True) + + Returns True if all elements evaluate to True. + + Refer to `numpy.all` for full documentation. + + See Also + -------- + numpy.all : equivalent function + + """)) + + +add_newdoc('numpy._core.multiarray', 'ndarray', ('any', + """ + a.any(axis=None, out=None, keepdims=False, *, where=True) + + Returns True if any of the elements of `a` evaluate to True. + + Refer to `numpy.any` for full documentation. + + See Also + -------- + numpy.any : equivalent function + + """)) + + +add_newdoc('numpy._core.multiarray', 'ndarray', ('argmax', + """ + a.argmax(axis=None, out=None, *, keepdims=False) + + Return indices of the maximum values along the given axis. + + Refer to `numpy.argmax` for full documentation. + + See Also + -------- + numpy.argmax : equivalent function + + """)) + + +add_newdoc('numpy._core.multiarray', 'ndarray', ('argmin', + """ + a.argmin(axis=None, out=None, *, keepdims=False) + + Return indices of the minimum values along the given axis. + + Refer to `numpy.argmin` for detailed documentation. + + See Also + -------- + numpy.argmin : equivalent function + + """)) + + +add_newdoc('numpy._core.multiarray', 'ndarray', ('argsort', + """ + a.argsort(axis=-1, kind=None, order=None) + + Returns the indices that would sort this array. + + Refer to `numpy.argsort` for full documentation. + + See Also + -------- + numpy.argsort : equivalent function + + """)) + + +add_newdoc('numpy._core.multiarray', 'ndarray', ('argpartition', + """ + a.argpartition(kth, axis=-1, kind='introselect', order=None) + + Returns the indices that would partition this array. + + Refer to `numpy.argpartition` for full documentation. + + .. versionadded:: 1.8.0 + + See Also + -------- + numpy.argpartition : equivalent function + + """)) + + +add_newdoc('numpy._core.multiarray', 'ndarray', ('astype', + """ + a.astype(dtype, order='K', casting='unsafe', subok=True, copy=True) + + Copy of the array, cast to a specified type. + + Parameters + ---------- + dtype : str or dtype + Typecode or data-type to which the array is cast. + order : {'C', 'F', 'A', 'K'}, optional + Controls the memory layout order of the result. + 'C' means C order, 'F' means Fortran order, 'A' + means 'F' order if all the arrays are Fortran contiguous, + 'C' order otherwise, and 'K' means as close to the + order the array elements appear in memory as possible. + Default is 'K'. + casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional + Controls what kind of data casting may occur. Defaults to 'unsafe' + for backwards compatibility. + + * 'no' means the data types should not be cast at all. + * 'equiv' means only byte-order changes are allowed. + * 'safe' means only casts which can preserve values are allowed. + * 'same_kind' means only safe casts or casts within a kind, + like float64 to float32, are allowed. + * 'unsafe' means any data conversions may be done. + subok : bool, optional + If True, then sub-classes will be passed-through (default), otherwise + the returned array will be forced to be a base-class array. + copy : bool, optional + By default, astype always returns a newly allocated array. If this + is set to false, and the `dtype`, `order`, and `subok` + requirements are satisfied, the input array is returned instead + of a copy. + + Returns + ------- + arr_t : ndarray + Unless `copy` is False and the other conditions for returning the input + array are satisfied (see description for `copy` input parameter), `arr_t` + is a new array of the same shape as the input array, with dtype, order + given by `dtype`, `order`. + + Notes + ----- + .. versionchanged:: 1.17.0 + Casting between a simple data type and a structured one is possible only + for "unsafe" casting. Casting to multiple fields is allowed, but + casting from multiple fields is not. + + .. versionchanged:: 1.9.0 + Casting from numeric to string types in 'safe' casting mode requires + that the string dtype length is long enough to store the max + integer/float value converted. + + Raises + ------ + ComplexWarning + When casting from complex to float or int. To avoid this, + one should use ``a.real.astype(t)``. + + Examples + -------- + >>> import numpy as np + >>> x = np.array([1, 2, 2.5]) + >>> x + array([1. , 2. , 2.5]) + + >>> x.astype(int) + array([1, 2, 2]) + + """)) + + +add_newdoc('numpy._core.multiarray', 'ndarray', ('byteswap', + """ + a.byteswap(inplace=False) + + Swap the bytes of the array elements + + Toggle between low-endian and big-endian data representation by + returning a byteswapped array, optionally swapped in-place. + Arrays of byte-strings are not swapped. The real and imaginary + parts of a complex number are swapped individually. + + Parameters + ---------- + inplace : bool, optional + If ``True``, swap bytes in-place, default is ``False``. + + Returns + ------- + out : ndarray + The byteswapped array. If `inplace` is ``True``, this is + a view to self. + + Examples + -------- + >>> import numpy as np + >>> A = np.array([1, 256, 8755], dtype=np.int16) + >>> list(map(hex, A)) + ['0x1', '0x100', '0x2233'] + >>> A.byteswap(inplace=True) + array([ 256, 1, 13090], dtype=int16) + >>> list(map(hex, A)) + ['0x100', '0x1', '0x3322'] + + Arrays of byte-strings are not swapped + + >>> A = np.array([b'ceg', b'fac']) + >>> A.byteswap() + array([b'ceg', b'fac'], dtype='|S3') + + ``A.view(A.dtype.newbyteorder()).byteswap()`` produces an array with + the same values but different representation in memory + + >>> A = np.array([1, 2, 3]) + >>> A.view(np.uint8) + array([1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, + 0, 0], dtype=uint8) + >>> A.view(A.dtype.newbyteorder()).byteswap(inplace=True) + array([1, 2, 3]) + >>> A.view(np.uint8) + array([0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, + 0, 3], dtype=uint8) + + """)) + + +add_newdoc('numpy._core.multiarray', 'ndarray', ('choose', + """ + a.choose(choices, out=None, mode='raise') + + Use an index array to construct a new array from a set of choices. + + Refer to `numpy.choose` for full documentation. + + See Also + -------- + numpy.choose : equivalent function + + """)) + + +add_newdoc('numpy._core.multiarray', 'ndarray', ('clip', + """ + a.clip(min=None, max=None, out=None, **kwargs) + + Return an array whose values are limited to ``[min, max]``. + One of max or min must be given. + + Refer to `numpy.clip` for full documentation. + + See Also + -------- + numpy.clip : equivalent function + + """)) + + +add_newdoc('numpy._core.multiarray', 'ndarray', ('compress', + """ + a.compress(condition, axis=None, out=None) + + Return selected slices of this array along given axis. + + Refer to `numpy.compress` for full documentation. + + See Also + -------- + numpy.compress : equivalent function + + """)) + + +add_newdoc('numpy._core.multiarray', 'ndarray', ('conj', + """ + a.conj() + + Complex-conjugate all elements. + + Refer to `numpy.conjugate` for full documentation. + + See Also + -------- + numpy.conjugate : equivalent function + + """)) + + +add_newdoc('numpy._core.multiarray', 'ndarray', ('conjugate', + """ + a.conjugate() + + Return the complex conjugate, element-wise. + + Refer to `numpy.conjugate` for full documentation. + + See Also + -------- + numpy.conjugate : equivalent function + + """)) + + +add_newdoc('numpy._core.multiarray', 'ndarray', ('copy', + """ + a.copy(order='C') + + Return a copy of the array. + + Parameters + ---------- + order : {'C', 'F', 'A', 'K'}, optional + Controls the memory layout of the copy. 'C' means C-order, + 'F' means F-order, 'A' means 'F' if `a` is Fortran contiguous, + 'C' otherwise. 'K' means match the layout of `a` as closely + as possible. (Note that this function and :func:`numpy.copy` are very + similar but have different default values for their order= + arguments, and this function always passes sub-classes through.) + + See also + -------- + numpy.copy : Similar function with different default behavior + numpy.copyto + + Notes + ----- + This function is the preferred method for creating an array copy. The + function :func:`numpy.copy` is similar, but it defaults to using order 'K', + and will not pass sub-classes through by default. + + Examples + -------- + >>> import numpy as np + >>> x = np.array([[1,2,3],[4,5,6]], order='F') + + >>> y = x.copy() + + >>> x.fill(0) + + >>> x + array([[0, 0, 0], + [0, 0, 0]]) + + >>> y + array([[1, 2, 3], + [4, 5, 6]]) + + >>> y.flags['C_CONTIGUOUS'] + True + + For arrays containing Python objects (e.g. dtype=object), + the copy is a shallow one. The new array will contain the + same object which may lead to surprises if that object can + be modified (is mutable): + + >>> a = np.array([1, 'm', [2, 3, 4]], dtype=object) + >>> b = a.copy() + >>> b[2][0] = 10 + >>> a + array([1, 'm', list([10, 3, 4])], dtype=object) + + To ensure all elements within an ``object`` array are copied, + use `copy.deepcopy`: + + >>> import copy + >>> a = np.array([1, 'm', [2, 3, 4]], dtype=object) + >>> c = copy.deepcopy(a) + >>> c[2][0] = 10 + >>> c + array([1, 'm', list([10, 3, 4])], dtype=object) + >>> a + array([1, 'm', list([2, 3, 4])], dtype=object) + + """)) + + +add_newdoc('numpy._core.multiarray', 'ndarray', ('cumprod', + """ + a.cumprod(axis=None, dtype=None, out=None) + + Return the cumulative product of the elements along the given axis. + + Refer to `numpy.cumprod` for full documentation. + + See Also + -------- + numpy.cumprod : equivalent function + + """)) + + +add_newdoc('numpy._core.multiarray', 'ndarray', ('cumsum', + """ + a.cumsum(axis=None, dtype=None, out=None) + + Return the cumulative sum of the elements along the given axis. + + Refer to `numpy.cumsum` for full documentation. + + See Also + -------- + numpy.cumsum : equivalent function + + """)) + + +add_newdoc('numpy._core.multiarray', 'ndarray', ('diagonal', + """ + a.diagonal(offset=0, axis1=0, axis2=1) + + Return specified diagonals. In NumPy 1.9 the returned array is a + read-only view instead of a copy as in previous NumPy versions. In + a future version the read-only restriction will be removed. + + Refer to :func:`numpy.diagonal` for full documentation. + + See Also + -------- + numpy.diagonal : equivalent function + + """)) + + +add_newdoc('numpy._core.multiarray', 'ndarray', ('dot')) + + +add_newdoc('numpy._core.multiarray', 'ndarray', ('dump', + """ + a.dump(file) + + Dump a pickle of the array to the specified file. + The array can be read back with pickle.load or numpy.load. + + Parameters + ---------- + file : str or Path + A string naming the dump file. + + .. versionchanged:: 1.17.0 + `pathlib.Path` objects are now accepted. + + """)) + + +add_newdoc('numpy._core.multiarray', 'ndarray', ('dumps', + """ + a.dumps() + + Returns the pickle of the array as a string. + pickle.loads will convert the string back to an array. + + Parameters + ---------- + None + + """)) + + +add_newdoc('numpy._core.multiarray', 'ndarray', ('fill', + """ + a.fill(value) + + Fill the array with a scalar value. + + Parameters + ---------- + value : scalar + All elements of `a` will be assigned this value. + + Examples + -------- + >>> import numpy as np + >>> a = np.array([1, 2]) + >>> a.fill(0) + >>> a + array([0, 0]) + >>> a = np.empty(2) + >>> a.fill(1) + >>> a + array([1., 1.]) + + Fill expects a scalar value and always behaves the same as assigning + to a single array element. The following is a rare example where this + distinction is important: + + >>> a = np.array([None, None], dtype=object) + >>> a[0] = np.array(3) + >>> a + array([array(3), None], dtype=object) + >>> a.fill(np.array(3)) + >>> a + array([array(3), array(3)], dtype=object) + + Where other forms of assignments will unpack the array being assigned: + + >>> a[...] = np.array(3) + >>> a + array([3, 3], dtype=object) + + """)) + + +add_newdoc('numpy._core.multiarray', 'ndarray', ('flatten', + """ + a.flatten(order='C') + + Return a copy of the array collapsed into one dimension. + + Parameters + ---------- + order : {'C', 'F', 'A', 'K'}, optional + 'C' means to flatten in row-major (C-style) order. + 'F' means to flatten in column-major (Fortran- + style) order. 'A' means to flatten in column-major + order if `a` is Fortran *contiguous* in memory, + row-major order otherwise. 'K' means to flatten + `a` in the order the elements occur in memory. + The default is 'C'. + + Returns + ------- + y : ndarray + A copy of the input array, flattened to one dimension. + + See Also + -------- + ravel : Return a flattened array. + flat : A 1-D flat iterator over the array. + + Examples + -------- + >>> import numpy as np + >>> a = np.array([[1,2], [3,4]]) + >>> a.flatten() + array([1, 2, 3, 4]) + >>> a.flatten('F') + array([1, 3, 2, 4]) + + """)) + + +add_newdoc('numpy._core.multiarray', 'ndarray', ('getfield', + """ + a.getfield(dtype, offset=0) + + Returns a field of the given array as a certain type. + + A field is a view of the array data with a given data-type. The values in + the view are determined by the given type and the offset into the current + array in bytes. The offset needs to be such that the view dtype fits in the + array dtype; for example an array of dtype complex128 has 16-byte elements. + If taking a view with a 32-bit integer (4 bytes), the offset needs to be + between 0 and 12 bytes. + + Parameters + ---------- + dtype : str or dtype + The data type of the view. The dtype size of the view can not be larger + than that of the array itself. + offset : int + Number of bytes to skip before beginning the element view. + + Examples + -------- + >>> import numpy as np + >>> x = np.diag([1.+1.j]*2) + >>> x[1, 1] = 2 + 4.j + >>> x + array([[1.+1.j, 0.+0.j], + [0.+0.j, 2.+4.j]]) + >>> x.getfield(np.float64) + array([[1., 0.], + [0., 2.]]) + + By choosing an offset of 8 bytes we can select the complex part of the + array for our view: + + >>> x.getfield(np.float64, offset=8) + array([[1., 0.], + [0., 4.]]) + + """)) + + +add_newdoc('numpy._core.multiarray', 'ndarray', ('item', + """ + a.item(*args) + + Copy an element of an array to a standard Python scalar and return it. + + Parameters + ---------- + \\*args : Arguments (variable number and type) + + * none: in this case, the method only works for arrays + with one element (`a.size == 1`), which element is + copied into a standard Python scalar object and returned. + + * int_type: this argument is interpreted as a flat index into + the array, specifying which element to copy and return. + + * tuple of int_types: functions as does a single int_type argument, + except that the argument is interpreted as an nd-index into the + array. + + Returns + ------- + z : Standard Python scalar object + A copy of the specified element of the array as a suitable + Python scalar + + Notes + ----- + When the data type of `a` is longdouble or clongdouble, item() returns + a scalar array object because there is no available Python scalar that + would not lose information. Void arrays return a buffer object for item(), + unless fields are defined, in which case a tuple is returned. + + `item` is very similar to a[args], except, instead of an array scalar, + a standard Python scalar is returned. This can be useful for speeding up + access to elements of the array and doing arithmetic on elements of the + array using Python's optimized math. + + Examples + -------- + >>> import numpy as np + >>> np.random.seed(123) + >>> x = np.random.randint(9, size=(3, 3)) + >>> x + array([[2, 2, 6], + [1, 3, 6], + [1, 0, 1]]) + >>> x.item(3) + 1 + >>> x.item(7) + 0 + >>> x.item((0, 1)) + 2 + >>> x.item((2, 2)) + 1 + + For an array with object dtype, elements are returned as-is. + + >>> a = np.array([np.int64(1)], dtype=object) + >>> a.item() #return np.int64 + np.int64(1) + + """)) + + +add_newdoc('numpy._core.multiarray', 'ndarray', ('max', + """ + a.max(axis=None, out=None, keepdims=False, initial=, where=True) + + Return the maximum along a given axis. + + Refer to `numpy.amax` for full documentation. + + See Also + -------- + numpy.amax : equivalent function + + """)) + + +add_newdoc('numpy._core.multiarray', 'ndarray', ('mean', + """ + a.mean(axis=None, dtype=None, out=None, keepdims=False, *, where=True) + + Returns the average of the array elements along given axis. + + Refer to `numpy.mean` for full documentation. + + See Also + -------- + numpy.mean : equivalent function + + """)) + + +add_newdoc('numpy._core.multiarray', 'ndarray', ('min', + """ + a.min(axis=None, out=None, keepdims=False, initial=, where=True) + + Return the minimum along a given axis. + + Refer to `numpy.amin` for full documentation. + + See Also + -------- + numpy.amin : equivalent function + + """)) + + +add_newdoc('numpy._core.multiarray', 'ndarray', ('nonzero', + """ + a.nonzero() + + Return the indices of the elements that are non-zero. + + Refer to `numpy.nonzero` for full documentation. + + See Also + -------- + numpy.nonzero : equivalent function + + """)) + + +add_newdoc('numpy._core.multiarray', 'ndarray', ('prod', + """ + a.prod(axis=None, dtype=None, out=None, keepdims=False, + initial=1, where=True) + + Return the product of the array elements over the given axis + + Refer to `numpy.prod` for full documentation. + + See Also + -------- + numpy.prod : equivalent function + + """)) + + +add_newdoc('numpy._core.multiarray', 'ndarray', ('put', + """ + a.put(indices, values, mode='raise') + + Set ``a.flat[n] = values[n]`` for all `n` in indices. + + Refer to `numpy.put` for full documentation. + + See Also + -------- + numpy.put : equivalent function + + """)) + + +add_newdoc('numpy._core.multiarray', 'ndarray', ('ravel', + """ + a.ravel([order]) + + Return a flattened array. + + Refer to `numpy.ravel` for full documentation. + + See Also + -------- + numpy.ravel : equivalent function + + ndarray.flat : a flat iterator on the array. + + """)) + + +add_newdoc('numpy._core.multiarray', 'ndarray', ('repeat', + """ + a.repeat(repeats, axis=None) + + Repeat elements of an array. + + Refer to `numpy.repeat` for full documentation. + + See Also + -------- + numpy.repeat : equivalent function + + """)) + + +add_newdoc('numpy._core.multiarray', 'ndarray', ('reshape', + """ + a.reshape(shape, /, *, order='C', copy=None) + + Returns an array containing the same data with a new shape. + + Refer to `numpy.reshape` for full documentation. + + See Also + -------- + numpy.reshape : equivalent function + + Notes + ----- + Unlike the free function `numpy.reshape`, this method on `ndarray` allows + the elements of the shape parameter to be passed in as separate arguments. + For example, ``a.reshape(10, 11)`` is equivalent to + ``a.reshape((10, 11))``. + + """)) + + +add_newdoc('numpy._core.multiarray', 'ndarray', ('resize', + """ + a.resize(new_shape, refcheck=True) + + Change shape and size of array in-place. + + Parameters + ---------- + new_shape : tuple of ints, or `n` ints + Shape of resized array. + refcheck : bool, optional + If False, reference count will not be checked. Default is True. + + Returns + ------- + None + + Raises + ------ + ValueError + If `a` does not own its own data or references or views to it exist, + and the data memory must be changed. + PyPy only: will always raise if the data memory must be changed, since + there is no reliable way to determine if references or views to it + exist. + + SystemError + If the `order` keyword argument is specified. This behaviour is a + bug in NumPy. + + See Also + -------- + resize : Return a new array with the specified shape. + + Notes + ----- + This reallocates space for the data area if necessary. + + Only contiguous arrays (data elements consecutive in memory) can be + resized. + + The purpose of the reference count check is to make sure you + do not use this array as a buffer for another Python object and then + reallocate the memory. However, reference counts can increase in + other ways so if you are sure that you have not shared the memory + for this array with another Python object, then you may safely set + `refcheck` to False. + + Examples + -------- + Shrinking an array: array is flattened (in the order that the data are + stored in memory), resized, and reshaped: + + >>> import numpy as np + + >>> a = np.array([[0, 1], [2, 3]], order='C') + >>> a.resize((2, 1)) + >>> a + array([[0], + [1]]) + + >>> a = np.array([[0, 1], [2, 3]], order='F') + >>> a.resize((2, 1)) + >>> a + array([[0], + [2]]) + + Enlarging an array: as above, but missing entries are filled with zeros: + + >>> b = np.array([[0, 1], [2, 3]]) + >>> b.resize(2, 3) # new_shape parameter doesn't have to be a tuple + >>> b + array([[0, 1, 2], + [3, 0, 0]]) + + Referencing an array prevents resizing... + + >>> c = a + >>> a.resize((1, 1)) + Traceback (most recent call last): + ... + ValueError: cannot resize an array that references or is referenced ... + + Unless `refcheck` is False: + + >>> a.resize((1, 1), refcheck=False) + >>> a + array([[0]]) + >>> c + array([[0]]) + + """)) + + +add_newdoc('numpy._core.multiarray', 'ndarray', ('round', + """ + a.round(decimals=0, out=None) + + Return `a` with each element rounded to the given number of decimals. + + Refer to `numpy.around` for full documentation. + + See Also + -------- + numpy.around : equivalent function + + """)) + + +add_newdoc('numpy._core.multiarray', 'ndarray', ('searchsorted', + """ + a.searchsorted(v, side='left', sorter=None) + + Find indices where elements of v should be inserted in a to maintain order. + + For full documentation, see `numpy.searchsorted` + + See Also + -------- + numpy.searchsorted : equivalent function + + """)) + + +add_newdoc('numpy._core.multiarray', 'ndarray', ('setfield', + """ + a.setfield(val, dtype, offset=0) + + Put a value into a specified place in a field defined by a data-type. + + Place `val` into `a`'s field defined by `dtype` and beginning `offset` + bytes into the field. + + Parameters + ---------- + val : object + Value to be placed in field. + dtype : dtype object + Data-type of the field in which to place `val`. + offset : int, optional + The number of bytes into the field at which to place `val`. + + Returns + ------- + None + + See Also + -------- + getfield + + Examples + -------- + >>> import numpy as np + >>> x = np.eye(3) + >>> x.getfield(np.float64) + array([[1., 0., 0.], + [0., 1., 0.], + [0., 0., 1.]]) + >>> x.setfield(3, np.int32) + >>> x.getfield(np.int32) + array([[3, 3, 3], + [3, 3, 3], + [3, 3, 3]], dtype=int32) + >>> x + array([[1.0e+000, 1.5e-323, 1.5e-323], + [1.5e-323, 1.0e+000, 1.5e-323], + [1.5e-323, 1.5e-323, 1.0e+000]]) + >>> x.setfield(np.eye(3), np.int32) + >>> x + array([[1., 0., 0.], + [0., 1., 0.], + [0., 0., 1.]]) + + """)) + + +add_newdoc('numpy._core.multiarray', 'ndarray', ('setflags', + """ + a.setflags(write=None, align=None, uic=None) + + Set array flags WRITEABLE, ALIGNED, WRITEBACKIFCOPY, + respectively. + + These Boolean-valued flags affect how numpy interprets the memory + area used by `a` (see Notes below). The ALIGNED flag can only + be set to True if the data is actually aligned according to the type. + The WRITEBACKIFCOPY flag can never be set + to True. The flag WRITEABLE can only be set to True if the array owns its + own memory, or the ultimate owner of the memory exposes a writeable buffer + interface, or is a string. (The exception for string is made so that + unpickling can be done without copying memory.) + + Parameters + ---------- + write : bool, optional + Describes whether or not `a` can be written to. + align : bool, optional + Describes whether or not `a` is aligned properly for its type. + uic : bool, optional + Describes whether or not `a` is a copy of another "base" array. + + Notes + ----- + Array flags provide information about how the memory area used + for the array is to be interpreted. There are 7 Boolean flags + in use, only three of which can be changed by the user: + WRITEBACKIFCOPY, WRITEABLE, and ALIGNED. + + WRITEABLE (W) the data area can be written to; + + ALIGNED (A) the data and strides are aligned appropriately for the hardware + (as determined by the compiler); + + WRITEBACKIFCOPY (X) this array is a copy of some other array (referenced + by .base). When the C-API function PyArray_ResolveWritebackIfCopy is + called, the base array will be updated with the contents of this array. + + All flags can be accessed using the single (upper case) letter as well + as the full name. + + Examples + -------- + >>> import numpy as np + >>> y = np.array([[3, 1, 7], + ... [2, 0, 0], + ... [8, 5, 9]]) + >>> y + array([[3, 1, 7], + [2, 0, 0], + [8, 5, 9]]) + >>> y.flags + C_CONTIGUOUS : True + F_CONTIGUOUS : False + OWNDATA : True + WRITEABLE : True + ALIGNED : True + WRITEBACKIFCOPY : False + >>> y.setflags(write=0, align=0) + >>> y.flags + C_CONTIGUOUS : True + F_CONTIGUOUS : False + OWNDATA : True + WRITEABLE : False + ALIGNED : False + WRITEBACKIFCOPY : False + >>> y.setflags(uic=1) + Traceback (most recent call last): + File "", line 1, in + ValueError: cannot set WRITEBACKIFCOPY flag to True + + """)) + + +add_newdoc('numpy._core.multiarray', 'ndarray', ('sort', + """ + a.sort(axis=-1, kind=None, order=None) + + Sort an array in-place. Refer to `numpy.sort` for full documentation. + + Parameters + ---------- + axis : int, optional + Axis along which to sort. Default is -1, which means sort along the + last axis. + kind : {'quicksort', 'mergesort', 'heapsort', 'stable'}, optional + Sorting algorithm. The default is 'quicksort'. Note that both 'stable' + and 'mergesort' use timsort under the covers and, in general, the + actual implementation will vary with datatype. The 'mergesort' option + is retained for backwards compatibility. + + .. versionchanged:: 1.15.0 + The 'stable' option was added. + + order : str or list of str, optional + When `a` is an array with fields defined, this argument specifies + which fields to compare first, second, etc. A single field can + be specified as a string, and not all fields need be specified, + but unspecified fields will still be used, in the order in which + they come up in the dtype, to break ties. + + See Also + -------- + numpy.sort : Return a sorted copy of an array. + numpy.argsort : Indirect sort. + numpy.lexsort : Indirect stable sort on multiple keys. + numpy.searchsorted : Find elements in sorted array. + numpy.partition: Partial sort. + + Notes + ----- + See `numpy.sort` for notes on the different sorting algorithms. + + Examples + -------- + >>> import numpy as np + >>> a = np.array([[1,4], [3,1]]) + >>> a.sort(axis=1) + >>> a + array([[1, 4], + [1, 3]]) + >>> a.sort(axis=0) + >>> a + array([[1, 3], + [1, 4]]) + + Use the `order` keyword to specify a field to use when sorting a + structured array: + + >>> a = np.array([('a', 2), ('c', 1)], dtype=[('x', 'S1'), ('y', int)]) + >>> a.sort(order='y') + >>> a + array([(b'c', 1), (b'a', 2)], + dtype=[('x', 'S1'), ('y', '>> import numpy as np + >>> a = np.array([3, 4, 2, 1]) + >>> a.partition(3) + >>> a + array([2, 1, 3, 4]) # may vary + + >>> a.partition((1, 3)) + >>> a + array([1, 2, 3, 4]) + """)) + + +add_newdoc('numpy._core.multiarray', 'ndarray', ('squeeze', + """ + a.squeeze(axis=None) + + Remove axes of length one from `a`. + + Refer to `numpy.squeeze` for full documentation. + + See Also + -------- + numpy.squeeze : equivalent function + + """)) + + +add_newdoc('numpy._core.multiarray', 'ndarray', ('std', + """ + a.std(axis=None, dtype=None, out=None, ddof=0, keepdims=False, *, where=True) + + Returns the standard deviation of the array elements along given axis. + + Refer to `numpy.std` for full documentation. + + See Also + -------- + numpy.std : equivalent function + + """)) + + +add_newdoc('numpy._core.multiarray', 'ndarray', ('sum', + """ + a.sum(axis=None, dtype=None, out=None, keepdims=False, initial=0, where=True) + + Return the sum of the array elements over the given axis. + + Refer to `numpy.sum` for full documentation. + + See Also + -------- + numpy.sum : equivalent function + + """)) + + +add_newdoc('numpy._core.multiarray', 'ndarray', ('swapaxes', + """ + a.swapaxes(axis1, axis2) + + Return a view of the array with `axis1` and `axis2` interchanged. + + Refer to `numpy.swapaxes` for full documentation. + + See Also + -------- + numpy.swapaxes : equivalent function + + """)) + + +add_newdoc('numpy._core.multiarray', 'ndarray', ('take', + """ + a.take(indices, axis=None, out=None, mode='raise') + + Return an array formed from the elements of `a` at the given indices. + + Refer to `numpy.take` for full documentation. + + See Also + -------- + numpy.take : equivalent function + + """)) + + +add_newdoc('numpy._core.multiarray', 'ndarray', ('tofile', + """ + a.tofile(fid, sep="", format="%s") + + Write array to a file as text or binary (default). + + Data is always written in 'C' order, independent of the order of `a`. + The data produced by this method can be recovered using the function + fromfile(). + + Parameters + ---------- + fid : file or str or Path + An open file object, or a string containing a filename. + + .. versionchanged:: 1.17.0 + `pathlib.Path` objects are now accepted. + + sep : str + Separator between array items for text output. + If "" (empty), a binary file is written, equivalent to + ``file.write(a.tobytes())``. + format : str + Format string for text file output. + Each entry in the array is formatted to text by first converting + it to the closest Python type, and then using "format" % item. + + Notes + ----- + This is a convenience function for quick storage of array data. + Information on endianness and precision is lost, so this method is not a + good choice for files intended to archive data or transport data between + machines with different endianness. Some of these problems can be overcome + by outputting the data as text files, at the expense of speed and file + size. + + When fid is a file object, array contents are directly written to the + file, bypassing the file object's ``write`` method. As a result, tofile + cannot be used with files objects supporting compression (e.g., GzipFile) + or file-like objects that do not support ``fileno()`` (e.g., BytesIO). + + """)) + + +add_newdoc('numpy._core.multiarray', 'ndarray', ('tolist', + """ + a.tolist() + + Return the array as an ``a.ndim``-levels deep nested list of Python scalars. + + Return a copy of the array data as a (nested) Python list. + Data items are converted to the nearest compatible builtin Python type, via + the `~numpy.ndarray.item` function. + + If ``a.ndim`` is 0, then since the depth of the nested list is 0, it will + not be a list at all, but a simple Python scalar. + + Parameters + ---------- + none + + Returns + ------- + y : object, or list of object, or list of list of object, or ... + The possibly nested list of array elements. + + Notes + ----- + The array may be recreated via ``a = np.array(a.tolist())``, although this + may sometimes lose precision. + + Examples + -------- + For a 1D array, ``a.tolist()`` is almost the same as ``list(a)``, + except that ``tolist`` changes numpy scalars to Python scalars: + + >>> import numpy as np + >>> a = np.uint32([1, 2]) + >>> a_list = list(a) + >>> a_list + [1, 2] + >>> type(a_list[0]) + + >>> a_tolist = a.tolist() + >>> a_tolist + [1, 2] + >>> type(a_tolist[0]) + + + Additionally, for a 2D array, ``tolist`` applies recursively: + + >>> a = np.array([[1, 2], [3, 4]]) + >>> list(a) + [array([1, 2]), array([3, 4])] + >>> a.tolist() + [[1, 2], [3, 4]] + + The base case for this recursion is a 0D array: + + >>> a = np.array(1) + >>> list(a) + Traceback (most recent call last): + ... + TypeError: iteration over a 0-d array + >>> a.tolist() + 1 + """)) + + +add_newdoc('numpy._core.multiarray', 'ndarray', ('tobytes', """ + a.tobytes(order='C') + + Construct Python bytes containing the raw data bytes in the array. + + Constructs Python bytes showing a copy of the raw contents of + data memory. The bytes object is produced in C-order by default. + This behavior is controlled by the ``order`` parameter. + + .. versionadded:: 1.9.0 + + Parameters + ---------- + order : {'C', 'F', 'A'}, optional + Controls the memory layout of the bytes object. 'C' means C-order, + 'F' means F-order, 'A' (short for *Any*) means 'F' if `a` is + Fortran contiguous, 'C' otherwise. Default is 'C'. + + Returns + ------- + s : bytes + Python bytes exhibiting a copy of `a`'s raw data. + + See also + -------- + frombuffer + Inverse of this operation, construct a 1-dimensional array from Python + bytes. + + Examples + -------- + >>> import numpy as np + >>> x = np.array([[0, 1], [2, 3]], dtype='>> x.tobytes() + b'\\x00\\x00\\x01\\x00\\x02\\x00\\x03\\x00' + >>> x.tobytes('C') == x.tobytes() + True + >>> x.tobytes('F') + b'\\x00\\x00\\x02\\x00\\x01\\x00\\x03\\x00' + + """)) + + +add_newdoc('numpy._core.multiarray', 'ndarray', ('tostring', r""" + a.tostring(order='C') + + A compatibility alias for `~ndarray.tobytes`, with exactly the same + behavior. + + Despite its name, it returns :class:`bytes` not :class:`str`\ s. + + .. deprecated:: 1.19.0 + """)) + + +add_newdoc('numpy._core.multiarray', 'ndarray', ('trace', + """ + a.trace(offset=0, axis1=0, axis2=1, dtype=None, out=None) + + Return the sum along diagonals of the array. + + Refer to `numpy.trace` for full documentation. + + See Also + -------- + numpy.trace : equivalent function + + """)) + + +add_newdoc('numpy._core.multiarray', 'ndarray', ('transpose', + """ + a.transpose(*axes) + + Returns a view of the array with axes transposed. + + Refer to `numpy.transpose` for full documentation. + + Parameters + ---------- + axes : None, tuple of ints, or `n` ints + + * None or no argument: reverses the order of the axes. + + * tuple of ints: `i` in the `j`-th place in the tuple means that the + array's `i`-th axis becomes the transposed array's `j`-th axis. + + * `n` ints: same as an n-tuple of the same ints (this form is + intended simply as a "convenience" alternative to the tuple form). + + Returns + ------- + p : ndarray + View of the array with its axes suitably permuted. + + See Also + -------- + transpose : Equivalent function. + ndarray.T : Array property returning the array transposed. + ndarray.reshape : Give a new shape to an array without changing its data. + + Examples + -------- + >>> import numpy as np + >>> a = np.array([[1, 2], [3, 4]]) + >>> a + array([[1, 2], + [3, 4]]) + >>> a.transpose() + array([[1, 3], + [2, 4]]) + >>> a.transpose((1, 0)) + array([[1, 3], + [2, 4]]) + >>> a.transpose(1, 0) + array([[1, 3], + [2, 4]]) + + >>> a = np.array([1, 2, 3, 4]) + >>> a + array([1, 2, 3, 4]) + >>> a.transpose() + array([1, 2, 3, 4]) + + """)) + + +add_newdoc('numpy._core.multiarray', 'ndarray', ('var', + """ + a.var(axis=None, dtype=None, out=None, ddof=0, keepdims=False, *, where=True) + + Returns the variance of the array elements, along given axis. + + Refer to `numpy.var` for full documentation. + + See Also + -------- + numpy.var : equivalent function + + """)) + + +add_newdoc('numpy._core.multiarray', 'ndarray', ('view', + """ + a.view([dtype][, type]) + + New view of array with the same data. + + .. note:: + Passing None for ``dtype`` is different from omitting the parameter, + since the former invokes ``dtype(None)`` which is an alias for + ``dtype('float64')``. + + Parameters + ---------- + dtype : data-type or ndarray sub-class, optional + Data-type descriptor of the returned view, e.g., float32 or int16. + Omitting it results in the view having the same data-type as `a`. + This argument can also be specified as an ndarray sub-class, which + then specifies the type of the returned object (this is equivalent to + setting the ``type`` parameter). + type : Python type, optional + Type of the returned view, e.g., ndarray or matrix. Again, omission + of the parameter results in type preservation. + + Notes + ----- + ``a.view()`` is used two different ways: + + ``a.view(some_dtype)`` or ``a.view(dtype=some_dtype)`` constructs a view + of the array's memory with a different data-type. This can cause a + reinterpretation of the bytes of memory. + + ``a.view(ndarray_subclass)`` or ``a.view(type=ndarray_subclass)`` just + returns an instance of `ndarray_subclass` that looks at the same array + (same shape, dtype, etc.) This does not cause a reinterpretation of the + memory. + + For ``a.view(some_dtype)``, if ``some_dtype`` has a different number of + bytes per entry than the previous dtype (for example, converting a regular + array to a structured array), then the last axis of ``a`` must be + contiguous. This axis will be resized in the result. + + .. versionchanged:: 1.23.0 + Only the last axis needs to be contiguous. Previously, the entire array + had to be C-contiguous. + + Examples + -------- + >>> import numpy as np + >>> x = np.array([(-1, 2)], dtype=[('a', np.int8), ('b', np.int8)]) + + Viewing array data using a different type and dtype: + + >>> nonneg = np.dtype([("a", np.uint8), ("b", np.uint8)]) + >>> y = x.view(dtype=nonneg, type=np.recarray) + >>> x["a"] + array([-1], dtype=int8) + >>> y.a + array([255], dtype=uint8) + + Creating a view on a structured array so it can be used in calculations + + >>> x = np.array([(1, 2),(3,4)], dtype=[('a', np.int8), ('b', np.int8)]) + >>> xv = x.view(dtype=np.int8).reshape(-1,2) + >>> xv + array([[1, 2], + [3, 4]], dtype=int8) + >>> xv.mean(0) + array([2., 3.]) + + Making changes to the view changes the underlying array + + >>> xv[0,1] = 20 + >>> x + array([(1, 20), (3, 4)], dtype=[('a', 'i1'), ('b', 'i1')]) + + Using a view to convert an array to a recarray: + + >>> z = x.view(np.recarray) + >>> z.a + array([1, 3], dtype=int8) + + Views share data: + + >>> x[0] = (9, 10) + >>> z[0] + np.record((9, 10), dtype=[('a', 'i1'), ('b', 'i1')]) + + Views that change the dtype size (bytes per entry) should normally be + avoided on arrays defined by slices, transposes, fortran-ordering, etc.: + + >>> x = np.array([[1, 2, 3], [4, 5, 6]], dtype=np.int16) + >>> y = x[:, ::2] + >>> y + array([[1, 3], + [4, 6]], dtype=int16) + >>> y.view(dtype=[('width', np.int16), ('length', np.int16)]) + Traceback (most recent call last): + ... + ValueError: To change to a dtype of a different size, the last axis must be contiguous + >>> z = y.copy() + >>> z.view(dtype=[('width', np.int16), ('length', np.int16)]) + array([[(1, 3)], + [(4, 6)]], dtype=[('width', '>> x = np.arange(2 * 3 * 4, dtype=np.int8).reshape(2, 3, 4) + >>> x.transpose(1, 0, 2).view(np.int16) + array([[[ 256, 770], + [3340, 3854]], + + [[1284, 1798], + [4368, 4882]], + + [[2312, 2826], + [5396, 5910]]], dtype=int16) + + """)) + + +############################################################################## +# +# umath functions +# +############################################################################## + +add_newdoc('numpy._core.umath', 'frompyfunc', + """ + frompyfunc(func, /, nin, nout, *[, identity]) + + Takes an arbitrary Python function and returns a NumPy ufunc. + + Can be used, for example, to add broadcasting to a built-in Python + function (see Examples section). + + Parameters + ---------- + func : Python function object + An arbitrary Python function. + nin : int + The number of input arguments. + nout : int + The number of objects returned by `func`. + identity : object, optional + The value to use for the `~numpy.ufunc.identity` attribute of the resulting + object. If specified, this is equivalent to setting the underlying + C ``identity`` field to ``PyUFunc_IdentityValue``. + If omitted, the identity is set to ``PyUFunc_None``. Note that this is + _not_ equivalent to setting the identity to ``None``, which implies the + operation is reorderable. + + Returns + ------- + out : ufunc + Returns a NumPy universal function (``ufunc``) object. + + See Also + -------- + vectorize : Evaluates pyfunc over input arrays using broadcasting rules of numpy. + + Notes + ----- + The returned ufunc always returns PyObject arrays. + + Examples + -------- + Use frompyfunc to add broadcasting to the Python function ``oct``: + + >>> import numpy as np + >>> oct_array = np.frompyfunc(oct, 1, 1) + >>> oct_array(np.array((10, 30, 100))) + array(['0o12', '0o36', '0o144'], dtype=object) + >>> np.array((oct(10), oct(30), oct(100))) # for comparison + array(['0o12', '0o36', '0o144'], dtype='doc is NULL.) + + Parameters + ---------- + ufunc : numpy.ufunc + A ufunc whose current doc is NULL. + new_docstring : string + The new docstring for the ufunc. + + Notes + ----- + This method allocates memory for new_docstring on + the heap. Technically this creates a memory leak, since this + memory will not be reclaimed until the end of the program + even if the ufunc itself is removed. However this will only + be a problem if the user is repeatedly creating ufuncs with + no documentation, adding documentation via add_newdoc_ufunc, + and then throwing away the ufunc. + """) + +add_newdoc('numpy._core.multiarray', 'get_handler_name', + """ + get_handler_name(a: ndarray) -> str,None + + Return the name of the memory handler used by `a`. If not provided, return + the name of the memory handler that will be used to allocate data for the + next `ndarray` in this context. May return None if `a` does not own its + memory, in which case you can traverse ``a.base`` for a memory handler. + """) + +add_newdoc('numpy._core.multiarray', 'get_handler_version', + """ + get_handler_version(a: ndarray) -> int,None + + Return the version of the memory handler used by `a`. If not provided, + return the version of the memory handler that will be used to allocate data + for the next `ndarray` in this context. May return None if `a` does not own + its memory, in which case you can traverse ``a.base`` for a memory handler. + """) + +add_newdoc('numpy._core._multiarray_umath', '_array_converter', + """ + _array_converter(*array_likes) + + Helper to convert one or more objects to arrays. Integrates machinery + to deal with the ``result_type`` and ``__array_wrap__``. + + The reason for this is that e.g. ``result_type`` needs to convert to arrays + to find the ``dtype``. But converting to an array before calling + ``result_type`` would incorrectly "forget" whether it was a Python int, + float, or complex. + """) + +add_newdoc( + 'numpy._core._multiarray_umath', '_array_converter', ('scalar_input', + """ + A tuple which indicates for each input whether it was a scalar that + was coerced to a 0-D array (and was not already an array or something + converted via a protocol like ``__array__()``). + """)) + +add_newdoc('numpy._core._multiarray_umath', '_array_converter', ('as_arrays', + """ + as_arrays(/, subok=True, pyscalars="convert_if_no_array") + + Return the inputs as arrays or scalars. + + Parameters + ---------- + subok : True or False, optional + Whether array subclasses are preserved. + pyscalars : {"convert", "preserve", "convert_if_no_array"}, optional + To allow NEP 50 weak promotion later, it may be desirable to preserve + Python scalars. As default, these are preserved unless all inputs + are Python scalars. "convert" enforces an array return. + """)) + +add_newdoc('numpy._core._multiarray_umath', '_array_converter', ('result_type', + """result_type(/, extra_dtype=None, ensure_inexact=False) + + Find the ``result_type`` just as ``np.result_type`` would, but taking + into account that the original inputs (before converting to an array) may + have been Python scalars with weak promotion. + + Parameters + ---------- + extra_dtype : dtype instance or class + An additional DType or dtype instance to promote (e.g. could be used + to ensure the result precision is at least float32). + ensure_inexact : True or False + When ``True``, ensures a floating point (or complex) result replacing + the ``arr * 1.`` or ``result_type(..., 0.0)`` pattern. + """)) + +add_newdoc('numpy._core._multiarray_umath', '_array_converter', ('wrap', + """ + wrap(arr, /, to_scalar=None) + + Call ``__array_wrap__`` on ``arr`` if ``arr`` is not the same subclass + as the input the ``__array_wrap__`` method was retrieved from. + + Parameters + ---------- + arr : ndarray + The object to be wrapped. Normally an ndarray or subclass, + although for backward compatibility NumPy scalars are also accepted + (these will be converted to a NumPy array before being passed on to + the ``__array_wrap__`` method). + to_scalar : {True, False, None}, optional + When ``True`` will convert a 0-d array to a scalar via ``result[()]`` + (with a fast-path for non-subclasses). If ``False`` the result should + be an array-like (as ``__array_wrap__`` is free to return a non-array). + By default (``None``), a scalar is returned if all inputs were scalar. + """)) + + +add_newdoc('numpy._core.multiarray', '_get_madvise_hugepage', + """ + _get_madvise_hugepage() -> bool + + Get use of ``madvise (2)`` MADV_HUGEPAGE support when + allocating the array data. Returns the currently set value. + See `global_state` for more information. + """) + +add_newdoc('numpy._core.multiarray', '_set_madvise_hugepage', + """ + _set_madvise_hugepage(enabled: bool) -> bool + + Set or unset use of ``madvise (2)`` MADV_HUGEPAGE support when + allocating the array data. Returns the previously set value. + See `global_state` for more information. + """) + + +############################################################################## +# +# Documentation for ufunc attributes and methods +# +############################################################################## + + +############################################################################## +# +# ufunc object +# +############################################################################## + +add_newdoc('numpy._core', 'ufunc', + """ + Functions that operate element by element on whole arrays. + + To see the documentation for a specific ufunc, use `info`. For + example, ``np.info(np.sin)``. Because ufuncs are written in C + (for speed) and linked into Python with NumPy's ufunc facility, + Python's help() function finds this page whenever help() is called + on a ufunc. + + A detailed explanation of ufuncs can be found in the docs for :ref:`ufuncs`. + + **Calling ufuncs:** ``op(*x[, out], where=True, **kwargs)`` + + Apply `op` to the arguments `*x` elementwise, broadcasting the arguments. + + The broadcasting rules are: + + * Dimensions of length 1 may be prepended to either array. + * Arrays may be repeated along dimensions of length 1. + + Parameters + ---------- + *x : array_like + Input arrays. + out : ndarray, None, or tuple of ndarray and None, optional + Alternate array object(s) in which to put the result; if provided, it + must have a shape that the inputs broadcast to. A tuple of arrays + (possible only as a keyword argument) must have length equal to the + number of outputs; use None for uninitialized outputs to be + allocated by the ufunc. + where : array_like, optional + This condition is broadcast over the input. At locations where the + condition is True, the `out` array will be set to the ufunc result. + Elsewhere, the `out` array will retain its original value. + Note that if an uninitialized `out` array is created via the default + ``out=None``, locations within it where the condition is False will + remain uninitialized. + **kwargs + For other keyword-only arguments, see the :ref:`ufunc docs `. + + Returns + ------- + r : ndarray or tuple of ndarray + `r` will have the shape that the arrays in `x` broadcast to; if `out` is + provided, it will be returned. If not, `r` will be allocated and + may contain uninitialized values. If the function has more than one + output, then the result will be a tuple of arrays. + + """) + + +############################################################################## +# +# ufunc attributes +# +############################################################################## + +add_newdoc('numpy._core', 'ufunc', ('identity', + """ + The identity value. + + Data attribute containing the identity element for the ufunc, + if it has one. If it does not, the attribute value is None. + + Examples + -------- + >>> import numpy as np + >>> np.add.identity + 0 + >>> np.multiply.identity + 1 + >>> np.power.identity + 1 + >>> print(np.exp.identity) + None + """)) + +add_newdoc('numpy._core', 'ufunc', ('nargs', + """ + The number of arguments. + + Data attribute containing the number of arguments the ufunc takes, including + optional ones. + + Notes + ----- + Typically this value will be one more than what you might expect + because all ufuncs take the optional "out" argument. + + Examples + -------- + >>> import numpy as np + >>> np.add.nargs + 3 + >>> np.multiply.nargs + 3 + >>> np.power.nargs + 3 + >>> np.exp.nargs + 2 + """)) + +add_newdoc('numpy._core', 'ufunc', ('nin', + """ + The number of inputs. + + Data attribute containing the number of arguments the ufunc treats as input. + + Examples + -------- + >>> import numpy as np + >>> np.add.nin + 2 + >>> np.multiply.nin + 2 + >>> np.power.nin + 2 + >>> np.exp.nin + 1 + """)) + +add_newdoc('numpy._core', 'ufunc', ('nout', + """ + The number of outputs. + + Data attribute containing the number of arguments the ufunc treats as output. + + Notes + ----- + Since all ufuncs can take output arguments, this will always be at least 1. + + Examples + -------- + >>> import numpy as np + >>> np.add.nout + 1 + >>> np.multiply.nout + 1 + >>> np.power.nout + 1 + >>> np.exp.nout + 1 + + """)) + +add_newdoc('numpy._core', 'ufunc', ('ntypes', + """ + The number of types. + + The number of numerical NumPy types - of which there are 18 total - on which + the ufunc can operate. + + See Also + -------- + numpy.ufunc.types + + Examples + -------- + >>> import numpy as np + >>> np.add.ntypes + 18 + >>> np.multiply.ntypes + 18 + >>> np.power.ntypes + 17 + >>> np.exp.ntypes + 7 + >>> np.remainder.ntypes + 14 + + """)) + +add_newdoc('numpy._core', 'ufunc', ('types', + """ + Returns a list with types grouped input->output. + + Data attribute listing the data-type "Domain-Range" groupings the ufunc can + deliver. The data-types are given using the character codes. + + See Also + -------- + numpy.ufunc.ntypes + + Examples + -------- + >>> import numpy as np + >>> np.add.types + ['??->?', 'bb->b', 'BB->B', 'hh->h', 'HH->H', 'ii->i', 'II->I', 'll->l', + 'LL->L', 'qq->q', 'QQ->Q', 'ff->f', 'dd->d', 'gg->g', 'FF->F', 'DD->D', + 'GG->G', 'OO->O'] + + >>> np.multiply.types + ['??->?', 'bb->b', 'BB->B', 'hh->h', 'HH->H', 'ii->i', 'II->I', 'll->l', + 'LL->L', 'qq->q', 'QQ->Q', 'ff->f', 'dd->d', 'gg->g', 'FF->F', 'DD->D', + 'GG->G', 'OO->O'] + + >>> np.power.types + ['bb->b', 'BB->B', 'hh->h', 'HH->H', 'ii->i', 'II->I', 'll->l', 'LL->L', + 'qq->q', 'QQ->Q', 'ff->f', 'dd->d', 'gg->g', 'FF->F', 'DD->D', 'GG->G', + 'OO->O'] + + >>> np.exp.types + ['f->f', 'd->d', 'g->g', 'F->F', 'D->D', 'G->G', 'O->O'] + + >>> np.remainder.types + ['bb->b', 'BB->B', 'hh->h', 'HH->H', 'ii->i', 'II->I', 'll->l', 'LL->L', + 'qq->q', 'QQ->Q', 'ff->f', 'dd->d', 'gg->g', 'OO->O'] + + """)) + +add_newdoc('numpy._core', 'ufunc', ('signature', + """ + Definition of the core elements a generalized ufunc operates on. + + The signature determines how the dimensions of each input/output array + are split into core and loop dimensions: + + 1. Each dimension in the signature is matched to a dimension of the + corresponding passed-in array, starting from the end of the shape tuple. + 2. Core dimensions assigned to the same label in the signature must have + exactly matching sizes, no broadcasting is performed. + 3. The core dimensions are removed from all inputs and the remaining + dimensions are broadcast together, defining the loop dimensions. + + Notes + ----- + Generalized ufuncs are used internally in many linalg functions, and in + the testing suite; the examples below are taken from these. + For ufuncs that operate on scalars, the signature is None, which is + equivalent to '()' for every argument. + + Examples + -------- + >>> import numpy as np + >>> np.linalg._umath_linalg.det.signature + '(m,m)->()' + >>> np.matmul.signature + '(n?,k),(k,m?)->(n?,m?)' + >>> np.add.signature is None + True # equivalent to '(),()->()' + """)) + +############################################################################## +# +# ufunc methods +# +############################################################################## + +add_newdoc('numpy._core', 'ufunc', ('reduce', + """ + reduce(array, axis=0, dtype=None, out=None, keepdims=False, initial=, where=True) + + Reduces `array`'s dimension by one, by applying ufunc along one axis. + + Let :math:`array.shape = (N_0, ..., N_i, ..., N_{M-1})`. Then + :math:`ufunc.reduce(array, axis=i)[k_0, ..,k_{i-1}, k_{i+1}, .., k_{M-1}]` = + the result of iterating `j` over :math:`range(N_i)`, cumulatively applying + ufunc to each :math:`array[k_0, ..,k_{i-1}, j, k_{i+1}, .., k_{M-1}]`. + For a one-dimensional array, reduce produces results equivalent to: + :: + + r = op.identity # op = ufunc + for i in range(len(A)): + r = op(r, A[i]) + return r + + For example, add.reduce() is equivalent to sum(). + + Parameters + ---------- + array : array_like + The array to act on. + axis : None or int or tuple of ints, optional + Axis or axes along which a reduction is performed. + The default (`axis` = 0) is perform a reduction over the first + dimension of the input array. `axis` may be negative, in + which case it counts from the last to the first axis. + + .. versionadded:: 1.7.0 + + If this is None, a reduction is performed over all the axes. + If this is a tuple of ints, a reduction is performed on multiple + axes, instead of a single axis or all the axes as before. + + For operations which are either not commutative or not associative, + doing a reduction over multiple axes is not well-defined. The + ufuncs do not currently raise an exception in this case, but will + likely do so in the future. + dtype : data-type code, optional + The data type used to perform the operation. Defaults to that of + ``out`` if given, and the data type of ``array`` otherwise (though + upcast to conserve precision for some cases, such as + ``numpy.add.reduce`` for integer or boolean input). + out : ndarray, None, or tuple of ndarray and None, optional + A location into which the result is stored. If not provided or None, + a freshly-allocated array is returned. For consistency with + ``ufunc.__call__``, if given as a keyword, this may be wrapped in a + 1-element tuple. + + .. versionchanged:: 1.13.0 + Tuples are allowed for keyword argument. + keepdims : bool, optional + If this is set to True, the axes which are reduced are left + in the result as dimensions with size one. With this option, + the result will broadcast correctly against the original `array`. + + .. versionadded:: 1.7.0 + initial : scalar, optional + The value with which to start the reduction. + If the ufunc has no identity or the dtype is object, this defaults + to None - otherwise it defaults to ufunc.identity. + If ``None`` is given, the first element of the reduction is used, + and an error is thrown if the reduction is empty. + + .. versionadded:: 1.15.0 + + where : array_like of bool, optional + A boolean array which is broadcasted to match the dimensions + of `array`, and selects elements to include in the reduction. Note + that for ufuncs like ``minimum`` that do not have an identity + defined, one has to pass in also ``initial``. + + .. versionadded:: 1.17.0 + + Returns + ------- + r : ndarray + The reduced array. If `out` was supplied, `r` is a reference to it. + + Examples + -------- + >>> import numpy as np + >>> np.multiply.reduce([2,3,5]) + 30 + + A multi-dimensional array example: + + >>> X = np.arange(8).reshape((2,2,2)) + >>> X + array([[[0, 1], + [2, 3]], + [[4, 5], + [6, 7]]]) + >>> np.add.reduce(X, 0) + array([[ 4, 6], + [ 8, 10]]) + >>> np.add.reduce(X) # confirm: default axis value is 0 + array([[ 4, 6], + [ 8, 10]]) + >>> np.add.reduce(X, 1) + array([[ 2, 4], + [10, 12]]) + >>> np.add.reduce(X, 2) + array([[ 1, 5], + [ 9, 13]]) + + You can use the ``initial`` keyword argument to initialize the reduction + with a different value, and ``where`` to select specific elements to include: + + >>> np.add.reduce([10], initial=5) + 15 + >>> np.add.reduce(np.ones((2, 2, 2)), axis=(0, 2), initial=10) + array([14., 14.]) + >>> a = np.array([10., np.nan, 10]) + >>> np.add.reduce(a, where=~np.isnan(a)) + 20.0 + + Allows reductions of empty arrays where they would normally fail, i.e. + for ufuncs without an identity. + + >>> np.minimum.reduce([], initial=np.inf) + inf + >>> np.minimum.reduce([[1., 2.], [3., 4.]], initial=10., where=[True, False]) + array([ 1., 10.]) + >>> np.minimum.reduce([]) + Traceback (most recent call last): + ... + ValueError: zero-size array to reduction operation minimum which has no identity + """)) + +add_newdoc('numpy._core', 'ufunc', ('accumulate', + """ + accumulate(array, axis=0, dtype=None, out=None) + + Accumulate the result of applying the operator to all elements. + + For a one-dimensional array, accumulate produces results equivalent to:: + + r = np.empty(len(A)) + t = op.identity # op = the ufunc being applied to A's elements + for i in range(len(A)): + t = op(t, A[i]) + r[i] = t + return r + + For example, add.accumulate() is equivalent to np.cumsum(). + + For a multi-dimensional array, accumulate is applied along only one + axis (axis zero by default; see Examples below) so repeated use is + necessary if one wants to accumulate over multiple axes. + + Parameters + ---------- + array : array_like + The array to act on. + axis : int, optional + The axis along which to apply the accumulation; default is zero. + dtype : data-type code, optional + The data-type used to represent the intermediate results. Defaults + to the data-type of the output array if such is provided, or the + data-type of the input array if no output array is provided. + out : ndarray, None, or tuple of ndarray and None, optional + A location into which the result is stored. If not provided or None, + a freshly-allocated array is returned. For consistency with + ``ufunc.__call__``, if given as a keyword, this may be wrapped in a + 1-element tuple. + + .. versionchanged:: 1.13.0 + Tuples are allowed for keyword argument. + + Returns + ------- + r : ndarray + The accumulated values. If `out` was supplied, `r` is a reference to + `out`. + + Examples + -------- + 1-D array examples: + + >>> import numpy as np + >>> np.add.accumulate([2, 3, 5]) + array([ 2, 5, 10]) + >>> np.multiply.accumulate([2, 3, 5]) + array([ 2, 6, 30]) + + 2-D array examples: + + >>> I = np.eye(2) + >>> I + array([[1., 0.], + [0., 1.]]) + + Accumulate along axis 0 (rows), down columns: + + >>> np.add.accumulate(I, 0) + array([[1., 0.], + [1., 1.]]) + >>> np.add.accumulate(I) # no axis specified = axis zero + array([[1., 0.], + [1., 1.]]) + + Accumulate along axis 1 (columns), through rows: + + >>> np.add.accumulate(I, 1) + array([[1., 1.], + [0., 1.]]) + + """)) + +add_newdoc('numpy._core', 'ufunc', ('reduceat', + """ + reduceat(array, indices, axis=0, dtype=None, out=None) + + Performs a (local) reduce with specified slices over a single axis. + + For i in ``range(len(indices))``, `reduceat` computes + ``ufunc.reduce(array[indices[i]:indices[i+1]])``, which becomes the i-th + generalized "row" parallel to `axis` in the final result (i.e., in a + 2-D array, for example, if `axis = 0`, it becomes the i-th row, but if + `axis = 1`, it becomes the i-th column). There are three exceptions to this: + + * when ``i = len(indices) - 1`` (so for the last index), + ``indices[i+1] = array.shape[axis]``. + * if ``indices[i] >= indices[i + 1]``, the i-th generalized "row" is + simply ``array[indices[i]]``. + * if ``indices[i] >= len(array)`` or ``indices[i] < 0``, an error is raised. + + The shape of the output depends on the size of `indices`, and may be + larger than `array` (this happens if ``len(indices) > array.shape[axis]``). + + Parameters + ---------- + array : array_like + The array to act on. + indices : array_like + Paired indices, comma separated (not colon), specifying slices to + reduce. + axis : int, optional + The axis along which to apply the reduceat. + dtype : data-type code, optional + The data type used to perform the operation. Defaults to that of + ``out`` if given, and the data type of ``array`` otherwise (though + upcast to conserve precision for some cases, such as + ``numpy.add.reduce`` for integer or boolean input). + out : ndarray, None, or tuple of ndarray and None, optional + A location into which the result is stored. If not provided or None, + a freshly-allocated array is returned. For consistency with + ``ufunc.__call__``, if given as a keyword, this may be wrapped in a + 1-element tuple. + + .. versionchanged:: 1.13.0 + Tuples are allowed for keyword argument. + + Returns + ------- + r : ndarray + The reduced values. If `out` was supplied, `r` is a reference to + `out`. + + Notes + ----- + A descriptive example: + + If `array` is 1-D, the function `ufunc.accumulate(array)` is the same as + ``ufunc.reduceat(array, indices)[::2]`` where `indices` is + ``range(len(array) - 1)`` with a zero placed + in every other element: + ``indices = zeros(2 * len(array) - 1)``, + ``indices[1::2] = range(1, len(array))``. + + Don't be fooled by this attribute's name: `reduceat(array)` is not + necessarily smaller than `array`. + + Examples + -------- + To take the running sum of four successive values: + + >>> import numpy as np + >>> np.add.reduceat(np.arange(8),[0,4, 1,5, 2,6, 3,7])[::2] + array([ 6, 10, 14, 18]) + + A 2-D example: + + >>> x = np.linspace(0, 15, 16).reshape(4,4) + >>> x + array([[ 0., 1., 2., 3.], + [ 4., 5., 6., 7.], + [ 8., 9., 10., 11.], + [12., 13., 14., 15.]]) + + :: + + # reduce such that the result has the following five rows: + # [row1 + row2 + row3] + # [row4] + # [row2] + # [row3] + # [row1 + row2 + row3 + row4] + + >>> np.add.reduceat(x, [0, 3, 1, 2, 0]) + array([[12., 15., 18., 21.], + [12., 13., 14., 15.], + [ 4., 5., 6., 7.], + [ 8., 9., 10., 11.], + [24., 28., 32., 36.]]) + + :: + + # reduce such that result has the following two columns: + # [col1 * col2 * col3, col4] + + >>> np.multiply.reduceat(x, [0, 3], 1) + array([[ 0., 3.], + [ 120., 7.], + [ 720., 11.], + [2184., 15.]]) + + """)) + +add_newdoc('numpy._core', 'ufunc', ('outer', + r""" + outer(A, B, /, **kwargs) + + Apply the ufunc `op` to all pairs (a, b) with a in `A` and b in `B`. + + Let ``M = A.ndim``, ``N = B.ndim``. Then the result, `C`, of + ``op.outer(A, B)`` is an array of dimension M + N such that: + + .. math:: C[i_0, ..., i_{M-1}, j_0, ..., j_{N-1}] = + op(A[i_0, ..., i_{M-1}], B[j_0, ..., j_{N-1}]) + + For `A` and `B` one-dimensional, this is equivalent to:: + + r = empty(len(A),len(B)) + for i in range(len(A)): + for j in range(len(B)): + r[i,j] = op(A[i], B[j]) # op = ufunc in question + + Parameters + ---------- + A : array_like + First array + B : array_like + Second array + kwargs : any + Arguments to pass on to the ufunc. Typically `dtype` or `out`. + See `ufunc` for a comprehensive overview of all available arguments. + + Returns + ------- + r : ndarray + Output array + + See Also + -------- + numpy.outer : A less powerful version of ``np.multiply.outer`` + that `ravel`\ s all inputs to 1D. This exists + primarily for compatibility with old code. + + tensordot : ``np.tensordot(a, b, axes=((), ()))`` and + ``np.multiply.outer(a, b)`` behave same for all + dimensions of a and b. + + Examples + -------- + >>> np.multiply.outer([1, 2, 3], [4, 5, 6]) + array([[ 4, 5, 6], + [ 8, 10, 12], + [12, 15, 18]]) + + A multi-dimensional example: + + >>> A = np.array([[1, 2, 3], [4, 5, 6]]) + >>> A.shape + (2, 3) + >>> B = np.array([[1, 2, 3, 4]]) + >>> B.shape + (1, 4) + >>> C = np.multiply.outer(A, B) + >>> C.shape; C + (2, 3, 1, 4) + array([[[[ 1, 2, 3, 4]], + [[ 2, 4, 6, 8]], + [[ 3, 6, 9, 12]]], + [[[ 4, 8, 12, 16]], + [[ 5, 10, 15, 20]], + [[ 6, 12, 18, 24]]]]) + + """)) + +add_newdoc('numpy._core', 'ufunc', ('at', + """ + at(a, indices, b=None, /) + + Performs unbuffered in place operation on operand 'a' for elements + specified by 'indices'. For addition ufunc, this method is equivalent to + ``a[indices] += b``, except that results are accumulated for elements that + are indexed more than once. For example, ``a[[0,0]] += 1`` will only + increment the first element once because of buffering, whereas + ``add.at(a, [0,0], 1)`` will increment the first element twice. + + .. versionadded:: 1.8.0 + + Parameters + ---------- + a : array_like + The array to perform in place operation on. + indices : array_like or tuple + Array like index object or slice object for indexing into first + operand. If first operand has multiple dimensions, indices can be a + tuple of array like index objects or slice objects. + b : array_like + Second operand for ufuncs requiring two operands. Operand must be + broadcastable over first operand after indexing or slicing. + + Examples + -------- + Set items 0 and 1 to their negative values: + + >>> import numpy as np + >>> a = np.array([1, 2, 3, 4]) + >>> np.negative.at(a, [0, 1]) + >>> a + array([-1, -2, 3, 4]) + + Increment items 0 and 1, and increment item 2 twice: + + >>> a = np.array([1, 2, 3, 4]) + >>> np.add.at(a, [0, 1, 2, 2], 1) + >>> a + array([2, 3, 5, 4]) + + Add items 0 and 1 in first array to second array, + and store results in first array: + + >>> a = np.array([1, 2, 3, 4]) + >>> b = np.array([1, 2]) + >>> np.add.at(a, [0, 1], b) + >>> a + array([2, 4, 3, 4]) + + """)) + +add_newdoc('numpy._core', 'ufunc', ('resolve_dtypes', + """ + resolve_dtypes(dtypes, *, signature=None, casting=None, reduction=False) + + Find the dtypes NumPy will use for the operation. Both input and + output dtypes are returned and may differ from those provided. + + .. note:: + + This function always applies NEP 50 rules since it is not provided + any actual values. The Python types ``int``, ``float``, and + ``complex`` thus behave weak and should be passed for "untyped" + Python input. + + Parameters + ---------- + dtypes : tuple of dtypes, None, or literal int, float, complex + The input dtypes for each operand. Output operands can be + None, indicating that the dtype must be found. + signature : tuple of DTypes or None, optional + If given, enforces exact DType (classes) of the specific operand. + The ufunc ``dtype`` argument is equivalent to passing a tuple with + only output dtypes set. + casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional + The casting mode when casting is necessary. This is identical to + the ufunc call casting modes. + reduction : boolean + If given, the resolution assumes a reduce operation is happening + which slightly changes the promotion and type resolution rules. + `dtypes` is usually something like ``(None, np.dtype("i2"), None)`` + for reductions (first input is also the output). + + .. note:: + + The default casting mode is "same_kind", however, as of + NumPy 1.24, NumPy uses "unsafe" for reductions. + + Returns + ------- + dtypes : tuple of dtypes + The dtypes which NumPy would use for the calculation. Note that + dtypes may not match the passed in ones (casting is necessary). + + + Examples + -------- + This API requires passing dtypes, define them for convenience: + + >>> import numpy as np + >>> int32 = np.dtype("int32") + >>> float32 = np.dtype("float32") + + The typical ufunc call does not pass an output dtype. `numpy.add` has two + inputs and one output, so leave the output as ``None`` (not provided): + + >>> np.add.resolve_dtypes((int32, float32, None)) + (dtype('float64'), dtype('float64'), dtype('float64')) + + The loop found uses "float64" for all operands (including the output), the + first input would be cast. + + ``resolve_dtypes`` supports "weak" handling for Python scalars by passing + ``int``, ``float``, or ``complex``: + + >>> np.add.resolve_dtypes((float32, float, None)) + (dtype('float32'), dtype('float32'), dtype('float32')) + + Where the Python ``float`` behaves samilar to a Python value ``0.0`` + in a ufunc call. (See :ref:`NEP 50 ` for details.) + + """)) + +add_newdoc('numpy._core', 'ufunc', ('_resolve_dtypes_and_context', + """ + _resolve_dtypes_and_context(dtypes, *, signature=None, casting=None, reduction=False) + + See `numpy.ufunc.resolve_dtypes` for parameter information. This + function is considered *unstable*. You may use it, but the returned + information is NumPy version specific and expected to change. + Large API/ABI changes are not expected, but a new NumPy version is + expected to require updating code using this functionality. + + This function is designed to be used in conjunction with + `numpy.ufunc._get_strided_loop`. The calls are split to mirror the C API + and allow future improvements. + + Returns + ------- + dtypes : tuple of dtypes + call_info : + PyCapsule with all necessary information to get access to low level + C calls. See `numpy.ufunc._get_strided_loop` for more information. + + """)) + +add_newdoc('numpy._core', 'ufunc', ('_get_strided_loop', + """ + _get_strided_loop(call_info, /, *, fixed_strides=None) + + This function fills in the ``call_info`` capsule to include all + information necessary to call the low-level strided loop from NumPy. + + See notes for more information. + + Parameters + ---------- + call_info : PyCapsule + The PyCapsule returned by `numpy.ufunc._resolve_dtypes_and_context`. + fixed_strides : tuple of int or None, optional + A tuple with fixed byte strides of all input arrays. NumPy may use + this information to find specialized loops, so any call must follow + the given stride. Use ``None`` to indicate that the stride is not + known (or not fixed) for all calls. + + Notes + ----- + Together with `numpy.ufunc._resolve_dtypes_and_context` this function + gives low-level access to the NumPy ufunc loops. + The first function does general preparation and returns the required + information. It returns this as a C capsule with the version specific + name ``numpy_1.24_ufunc_call_info``. + The NumPy 1.24 ufunc call info capsule has the following layout:: + + typedef struct { + PyArrayMethod_StridedLoop *strided_loop; + PyArrayMethod_Context *context; + NpyAuxData *auxdata; + + /* Flag information (expected to change) */ + npy_bool requires_pyapi; /* GIL is required by loop */ + + /* Loop doesn't set FPE flags; if not set check FPE flags */ + npy_bool no_floatingpoint_errors; + } ufunc_call_info; + + Note that the first call only fills in the ``context``. The call to + ``_get_strided_loop`` fills in all other data. The main thing to note is + that the new-style loops return 0 on success, -1 on failure. They are + passed context as new first input and ``auxdata`` as (replaced) last. + + Only the ``strided_loop``signature is considered guaranteed stable + for NumPy bug-fix releases. All other API is tied to the experimental + API versioning. + + The reason for the split call is that cast information is required to + decide what the fixed-strides will be. + + NumPy ties the lifetime of the ``auxdata`` information to the capsule. + + """)) + + + +############################################################################## +# +# Documentation for dtype attributes and methods +# +############################################################################## + +############################################################################## +# +# dtype object +# +############################################################################## + +add_newdoc('numpy._core.multiarray', 'dtype', + """ + dtype(dtype, align=False, copy=False, [metadata]) + + Create a data type object. + + A numpy array is homogeneous, and contains elements described by a + dtype object. A dtype object can be constructed from different + combinations of fundamental numeric types. + + Parameters + ---------- + dtype + Object to be converted to a data type object. + align : bool, optional + Add padding to the fields to match what a C compiler would output + for a similar C-struct. Can be ``True`` only if `obj` is a dictionary + or a comma-separated string. If a struct dtype is being created, + this also sets a sticky alignment flag ``isalignedstruct``. + copy : bool, optional + Make a new copy of the data-type object. If ``False``, the result + may just be a reference to a built-in data-type object. + metadata : dict, optional + An optional dictionary with dtype metadata. + + See also + -------- + result_type + + Examples + -------- + Using array-scalar type: + + >>> import numpy as np + >>> np.dtype(np.int16) + dtype('int16') + + Structured type, one field name 'f1', containing int16: + + >>> np.dtype([('f1', np.int16)]) + dtype([('f1', '>> np.dtype([('f1', [('f1', np.int16)])]) + dtype([('f1', [('f1', '>> np.dtype([('f1', np.uint64), ('f2', np.int32)]) + dtype([('f1', '>> np.dtype([('a','f8'),('b','S10')]) + dtype([('a', '>> np.dtype("i4, (2,3)f8") + dtype([('f0', '>> np.dtype([('hello',(np.int64,3)),('world',np.void,10)]) + dtype([('hello', '>> np.dtype((np.int16, {'x':(np.int8,0), 'y':(np.int8,1)})) + dtype((numpy.int16, [('x', 'i1'), ('y', 'i1')])) + + Using dictionaries. Two fields named 'gender' and 'age': + + >>> np.dtype({'names':['gender','age'], 'formats':['S1',np.uint8]}) + dtype([('gender', 'S1'), ('age', 'u1')]) + + Offsets in bytes, here 0 and 25: + + >>> np.dtype({'surname':('S25',0),'age':(np.uint8,25)}) + dtype([('surname', 'S25'), ('age', 'u1')]) + + """) + +############################################################################## +# +# dtype attributes +# +############################################################################## + +add_newdoc('numpy._core.multiarray', 'dtype', ('alignment', + """ + The required alignment (bytes) of this data-type according to the compiler. + + More information is available in the C-API section of the manual. + + Examples + -------- + + >>> import numpy as np + >>> x = np.dtype('i4') + >>> x.alignment + 4 + + >>> x = np.dtype(float) + >>> x.alignment + 8 + + """)) + +add_newdoc('numpy._core.multiarray', 'dtype', ('byteorder', + """ + A character indicating the byte-order of this data-type object. + + One of: + + === ============== + '=' native + '<' little-endian + '>' big-endian + '|' not applicable + === ============== + + All built-in data-type objects have byteorder either '=' or '|'. + + Examples + -------- + + >>> import numpy as np + >>> dt = np.dtype('i2') + >>> dt.byteorder + '=' + >>> # endian is not relevant for 8 bit numbers + >>> np.dtype('i1').byteorder + '|' + >>> # or ASCII strings + >>> np.dtype('S2').byteorder + '|' + >>> # Even if specific code is given, and it is native + >>> # '=' is the byteorder + >>> import sys + >>> sys_is_le = sys.byteorder == 'little' + >>> native_code = '<' if sys_is_le else '>' + >>> swapped_code = '>' if sys_is_le else '<' + >>> dt = np.dtype(native_code + 'i2') + >>> dt.byteorder + '=' + >>> # Swapped code shows up as itself + >>> dt = np.dtype(swapped_code + 'i2') + >>> dt.byteorder == swapped_code + True + + """)) + +add_newdoc('numpy._core.multiarray', 'dtype', ('char', + """A unique character code for each of the 21 different built-in types. + + Examples + -------- + + >>> import numpy as np + >>> x = np.dtype(float) + >>> x.char + 'd' + + """)) + +add_newdoc('numpy._core.multiarray', 'dtype', ('descr', + """ + `__array_interface__` description of the data-type. + + The format is that required by the 'descr' key in the + `__array_interface__` attribute. + + Warning: This attribute exists specifically for `__array_interface__`, + and passing it directly to `numpy.dtype` will not accurately reconstruct + some dtypes (e.g., scalar and subarray dtypes). + + Examples + -------- + + >>> import numpy as np + >>> x = np.dtype(float) + >>> x.descr + [('', '>> dt = np.dtype([('name', np.str_, 16), ('grades', np.float64, (2,))]) + >>> dt.descr + [('name', '>> import numpy as np + >>> dt = np.dtype([('name', np.str_, 16), ('grades', np.float64, (2,))]) + >>> print(dt.fields) + {'grades': (dtype(('float64',(2,))), 16), 'name': (dtype('|S16'), 0)} + + """)) + +add_newdoc('numpy._core.multiarray', 'dtype', ('flags', + """ + Bit-flags describing how this data type is to be interpreted. + + Bit-masks are in ``numpy._core.multiarray`` as the constants + `ITEM_HASOBJECT`, `LIST_PICKLE`, `ITEM_IS_POINTER`, `NEEDS_INIT`, + `NEEDS_PYAPI`, `USE_GETITEM`, `USE_SETITEM`. A full explanation + of these flags is in C-API documentation; they are largely useful + for user-defined data-types. + + The following example demonstrates that operations on this particular + dtype requires Python C-API. + + Examples + -------- + + >>> import numpy as np + >>> x = np.dtype([('a', np.int32, 8), ('b', np.float64, 6)]) + >>> x.flags + 16 + >>> np._core.multiarray.NEEDS_PYAPI + 16 + + """)) + +add_newdoc('numpy._core.multiarray', 'dtype', ('hasobject', + """ + Boolean indicating whether this dtype contains any reference-counted + objects in any fields or sub-dtypes. + + Recall that what is actually in the ndarray memory representing + the Python object is the memory address of that object (a pointer). + Special handling may be required, and this attribute is useful for + distinguishing data types that may contain arbitrary Python objects + and data-types that won't. + + """)) + +add_newdoc('numpy._core.multiarray', 'dtype', ('isbuiltin', + """ + Integer indicating how this dtype relates to the built-in dtypes. + + Read-only. + + = ======================================================================== + 0 if this is a structured array type, with fields + 1 if this is a dtype compiled into numpy (such as ints, floats etc) + 2 if the dtype is for a user-defined numpy type + A user-defined type uses the numpy C-API machinery to extend + numpy to handle a new array type. See + :ref:`user.user-defined-data-types` in the NumPy manual. + = ======================================================================== + + Examples + -------- + + >>> import numpy as np + >>> dt = np.dtype('i2') + >>> dt.isbuiltin + 1 + >>> dt = np.dtype('f8') + >>> dt.isbuiltin + 1 + >>> dt = np.dtype([('field1', 'f8')]) + >>> dt.isbuiltin + 0 + + """)) + +add_newdoc('numpy._core.multiarray', 'dtype', ('isnative', + """ + Boolean indicating whether the byte order of this dtype is native + to the platform. + + """)) + +add_newdoc('numpy._core.multiarray', 'dtype', ('isalignedstruct', + """ + Boolean indicating whether the dtype is a struct which maintains + field alignment. This flag is sticky, so when combining multiple + structs together, it is preserved and produces new dtypes which + are also aligned. + + """)) + +add_newdoc('numpy._core.multiarray', 'dtype', ('itemsize', + """ + The element size of this data-type object. + + For 18 of the 21 types this number is fixed by the data-type. + For the flexible data-types, this number can be anything. + + Examples + -------- + + >>> import numpy as np + >>> arr = np.array([[1, 2], [3, 4]]) + >>> arr.dtype + dtype('int64') + >>> arr.itemsize + 8 + + >>> dt = np.dtype([('name', np.str_, 16), ('grades', np.float64, (2,))]) + >>> dt.itemsize + 80 + + """)) + +add_newdoc('numpy._core.multiarray', 'dtype', ('kind', + """ + A character code (one of 'biufcmMOSUV') identifying the general kind of data. + + = ====================== + b boolean + i signed integer + u unsigned integer + f floating-point + c complex floating-point + m timedelta + M datetime + O object + S (byte-)string + U Unicode + V void + = ====================== + + Examples + -------- + + >>> import numpy as np + >>> dt = np.dtype('i4') + >>> dt.kind + 'i' + >>> dt = np.dtype('f8') + >>> dt.kind + 'f' + >>> dt = np.dtype([('field1', 'f8')]) + >>> dt.kind + 'V' + + """)) + +add_newdoc('numpy._core.multiarray', 'dtype', ('metadata', + """ + Either ``None`` or a readonly dictionary of metadata (mappingproxy). + + The metadata field can be set using any dictionary at data-type + creation. NumPy currently has no uniform approach to propagating + metadata; although some array operations preserve it, there is no + guarantee that others will. + + .. warning:: + + Although used in certain projects, this feature was long undocumented + and is not well supported. Some aspects of metadata propagation + are expected to change in the future. + + Examples + -------- + + >>> import numpy as np + >>> dt = np.dtype(float, metadata={"key": "value"}) + >>> dt.metadata["key"] + 'value' + >>> arr = np.array([1, 2, 3], dtype=dt) + >>> arr.dtype.metadata + mappingproxy({'key': 'value'}) + + Adding arrays with identical datatypes currently preserves the metadata: + + >>> (arr + arr).dtype.metadata + mappingproxy({'key': 'value'}) + + But if the arrays have different dtype metadata, the metadata may be + dropped: + + >>> dt2 = np.dtype(float, metadata={"key2": "value2"}) + >>> arr2 = np.array([3, 2, 1], dtype=dt2) + >>> (arr + arr2).dtype.metadata is None + True # The metadata field is cleared so None is returned + """)) + +add_newdoc('numpy._core.multiarray', 'dtype', ('name', + """ + A bit-width name for this data-type. + + Un-sized flexible data-type objects do not have this attribute. + + Examples + -------- + + >>> import numpy as np + >>> x = np.dtype(float) + >>> x.name + 'float64' + >>> x = np.dtype([('a', np.int32, 8), ('b', np.float64, 6)]) + >>> x.name + 'void640' + + """)) + +add_newdoc('numpy._core.multiarray', 'dtype', ('names', + """ + Ordered list of field names, or ``None`` if there are no fields. + + The names are ordered according to increasing byte offset. This can be + used, for example, to walk through all of the named fields in offset order. + + Examples + -------- + >>> dt = np.dtype([('name', np.str_, 16), ('grades', np.float64, (2,))]) + >>> dt.names + ('name', 'grades') + + """)) + +add_newdoc('numpy._core.multiarray', 'dtype', ('num', + """ + A unique number for each of the 21 different built-in types. + + These are roughly ordered from least-to-most precision. + + Examples + -------- + + >>> import numpy as np + >>> dt = np.dtype(str) + >>> dt.num + 19 + + >>> dt = np.dtype(float) + >>> dt.num + 12 + + """)) + +add_newdoc('numpy._core.multiarray', 'dtype', ('shape', + """ + Shape tuple of the sub-array if this data type describes a sub-array, + and ``()`` otherwise. + + Examples + -------- + + >>> import numpy as np + >>> dt = np.dtype(('i4', 4)) + >>> dt.shape + (4,) + + >>> dt = np.dtype(('i4', (2, 3))) + >>> dt.shape + (2, 3) + + """)) + +add_newdoc('numpy._core.multiarray', 'dtype', ('ndim', + """ + Number of dimensions of the sub-array if this data type describes a + sub-array, and ``0`` otherwise. + + .. versionadded:: 1.13.0 + + Examples + -------- + >>> import numpy as np + >>> x = np.dtype(float) + >>> x.ndim + 0 + + >>> x = np.dtype((float, 8)) + >>> x.ndim + 1 + + >>> x = np.dtype(('i4', (3, 4))) + >>> x.ndim + 2 + + """)) + +add_newdoc('numpy._core.multiarray', 'dtype', ('str', + """The array-protocol typestring of this data-type object.""")) + +add_newdoc('numpy._core.multiarray', 'dtype', ('subdtype', + """ + Tuple ``(item_dtype, shape)`` if this `dtype` describes a sub-array, and + None otherwise. + + The *shape* is the fixed shape of the sub-array described by this + data type, and *item_dtype* the data type of the array. + + If a field whose dtype object has this attribute is retrieved, + then the extra dimensions implied by *shape* are tacked on to + the end of the retrieved array. + + See Also + -------- + dtype.base + + Examples + -------- + >>> import numpy as np + >>> x = numpy.dtype('8f') + >>> x.subdtype + (dtype('float32'), (8,)) + + >>> x = numpy.dtype('i2') + >>> x.subdtype + >>> + + """)) + +add_newdoc('numpy._core.multiarray', 'dtype', ('base', + """ + Returns dtype for the base element of the subarrays, + regardless of their dimension or shape. + + See Also + -------- + dtype.subdtype + + Examples + -------- + >>> import numpy as np + >>> x = numpy.dtype('8f') + >>> x.base + dtype('float32') + + >>> x = numpy.dtype('i2') + >>> x.base + dtype('int16') + + """)) + +add_newdoc('numpy._core.multiarray', 'dtype', ('type', + """The type object used to instantiate a scalar of this data-type.""")) + +############################################################################## +# +# dtype methods +# +############################################################################## + +add_newdoc('numpy._core.multiarray', 'dtype', ('newbyteorder', + """ + newbyteorder(new_order='S', /) + + Return a new dtype with a different byte order. + + Changes are also made in all fields and sub-arrays of the data type. + + Parameters + ---------- + new_order : string, optional + Byte order to force; a value from the byte order specifications + below. The default value ('S') results in swapping the current + byte order. `new_order` codes can be any of: + + * 'S' - swap dtype from current to opposite endian + * {'<', 'little'} - little endian + * {'>', 'big'} - big endian + * {'=', 'native'} - native order + * {'|', 'I'} - ignore (no change to byte order) + + Returns + ------- + new_dtype : dtype + New dtype object with the given change to the byte order. + + Notes + ----- + Changes are also made in all fields and sub-arrays of the data type. + + Examples + -------- + >>> import sys + >>> sys_is_le = sys.byteorder == 'little' + >>> native_code = '<' if sys_is_le else '>' + >>> swapped_code = '>' if sys_is_le else '<' + >>> import numpy as np + >>> native_dt = np.dtype(native_code+'i2') + >>> swapped_dt = np.dtype(swapped_code+'i2') + >>> native_dt.newbyteorder('S') == swapped_dt + True + >>> native_dt.newbyteorder() == swapped_dt + True + >>> native_dt == swapped_dt.newbyteorder('S') + True + >>> native_dt == swapped_dt.newbyteorder('=') + True + >>> native_dt == swapped_dt.newbyteorder('N') + True + >>> native_dt == native_dt.newbyteorder('|') + True + >>> np.dtype('>> np.dtype('>> np.dtype('>i2') == native_dt.newbyteorder('>') + True + >>> np.dtype('>i2') == native_dt.newbyteorder('B') + True + + """)) + +add_newdoc('numpy._core.multiarray', 'dtype', ('__class_getitem__', + """ + __class_getitem__(item, /) + + Return a parametrized wrapper around the `~numpy.dtype` type. + + .. versionadded:: 1.22 + + Returns + ------- + alias : types.GenericAlias + A parametrized `~numpy.dtype` type. + + Examples + -------- + >>> import numpy as np + + >>> np.dtype[np.int64] + numpy.dtype[numpy.int64] + + See Also + -------- + :pep:`585` : Type hinting generics in standard collections. + + """)) + +add_newdoc('numpy._core.multiarray', 'dtype', ('__ge__', + """ + __ge__(value, /) + + Return ``self >= value``. + + Equivalent to ``np.can_cast(value, self, casting="safe")``. + + See Also + -------- + can_cast : Returns True if cast between data types can occur according to + the casting rule. + + """)) + +add_newdoc('numpy._core.multiarray', 'dtype', ('__le__', + """ + __le__(value, /) + + Return ``self <= value``. + + Equivalent to ``np.can_cast(self, value, casting="safe")``. + + See Also + -------- + can_cast : Returns True if cast between data types can occur according to + the casting rule. + + """)) + +add_newdoc('numpy._core.multiarray', 'dtype', ('__gt__', + """ + __ge__(value, /) + + Return ``self > value``. + + Equivalent to + ``self != value and np.can_cast(value, self, casting="safe")``. + + See Also + -------- + can_cast : Returns True if cast between data types can occur according to + the casting rule. + + """)) + +add_newdoc('numpy._core.multiarray', 'dtype', ('__lt__', + """ + __lt__(value, /) + + Return ``self < value``. + + Equivalent to + ``self != value and np.can_cast(self, value, casting="safe")``. + + See Also + -------- + can_cast : Returns True if cast between data types can occur according to + the casting rule. + + """)) + +############################################################################## +# +# Datetime-related Methods +# +############################################################################## + +add_newdoc('numpy._core.multiarray', 'busdaycalendar', + """ + busdaycalendar(weekmask='1111100', holidays=None) + + A business day calendar object that efficiently stores information + defining valid days for the busday family of functions. + + The default valid days are Monday through Friday ("business days"). + A busdaycalendar object can be specified with any set of weekly + valid days, plus an optional "holiday" dates that always will be invalid. + + Once a busdaycalendar object is created, the weekmask and holidays + cannot be modified. + + .. versionadded:: 1.7.0 + + Parameters + ---------- + weekmask : str or array_like of bool, optional + A seven-element array indicating which of Monday through Sunday are + valid days. May be specified as a length-seven list or array, like + [1,1,1,1,1,0,0]; a length-seven string, like '1111100'; or a string + like "Mon Tue Wed Thu Fri", made up of 3-character abbreviations for + weekdays, optionally separated by white space. Valid abbreviations + are: Mon Tue Wed Thu Fri Sat Sun + holidays : array_like of datetime64[D], optional + An array of dates to consider as invalid dates, no matter which + weekday they fall upon. Holiday dates may be specified in any + order, and NaT (not-a-time) dates are ignored. This list is + saved in a normalized form that is suited for fast calculations + of valid days. + + Returns + ------- + out : busdaycalendar + A business day calendar object containing the specified + weekmask and holidays values. + + See Also + -------- + is_busday : Returns a boolean array indicating valid days. + busday_offset : Applies an offset counted in valid days. + busday_count : Counts how many valid days are in a half-open date range. + + Attributes + ---------- + weekmask : (copy) seven-element array of bool + holidays : (copy) sorted array of datetime64[D] + + Notes + ----- + Once a busdaycalendar object is created, you cannot modify the + weekmask or holidays. The attributes return copies of internal data. + + Examples + -------- + >>> import numpy as np + >>> # Some important days in July + ... bdd = np.busdaycalendar( + ... holidays=['2011-07-01', '2011-07-04', '2011-07-17']) + >>> # Default is Monday to Friday weekdays + ... bdd.weekmask + array([ True, True, True, True, True, False, False]) + >>> # Any holidays already on the weekend are removed + ... bdd.holidays + array(['2011-07-01', '2011-07-04'], dtype='datetime64[D]') + """) + +add_newdoc('numpy._core.multiarray', 'busdaycalendar', ('weekmask', + """A copy of the seven-element boolean mask indicating valid days.""")) + +add_newdoc('numpy._core.multiarray', 'busdaycalendar', ('holidays', + """A copy of the holiday array indicating additional invalid days.""")) + +add_newdoc('numpy._core.multiarray', 'normalize_axis_index', + """ + normalize_axis_index(axis, ndim, msg_prefix=None) + + Normalizes an axis index, `axis`, such that is a valid positive index into + the shape of array with `ndim` dimensions. Raises an AxisError with an + appropriate message if this is not possible. + + Used internally by all axis-checking logic. + + .. versionadded:: 1.13.0 + + Parameters + ---------- + axis : int + The un-normalized index of the axis. Can be negative + ndim : int + The number of dimensions of the array that `axis` should be normalized + against + msg_prefix : str + A prefix to put before the message, typically the name of the argument + + Returns + ------- + normalized_axis : int + The normalized axis index, such that `0 <= normalized_axis < ndim` + + Raises + ------ + AxisError + If the axis index is invalid, when `-ndim <= axis < ndim` is false. + + Examples + -------- + >>> import numpy as np + >>> from numpy.lib.array_utils import normalize_axis_index + >>> normalize_axis_index(0, ndim=3) + 0 + >>> normalize_axis_index(1, ndim=3) + 1 + >>> normalize_axis_index(-1, ndim=3) + 2 + + >>> normalize_axis_index(3, ndim=3) + Traceback (most recent call last): + ... + numpy.exceptions.AxisError: axis 3 is out of bounds for array ... + >>> normalize_axis_index(-4, ndim=3, msg_prefix='axes_arg') + Traceback (most recent call last): + ... + numpy.exceptions.AxisError: axes_arg: axis -4 is out of bounds ... + """) + +add_newdoc('numpy._core.multiarray', 'datetime_data', + """ + datetime_data(dtype, /) + + Get information about the step size of a date or time type. + + The returned tuple can be passed as the second argument of `numpy.datetime64` and + `numpy.timedelta64`. + + Parameters + ---------- + dtype : dtype + The dtype object, which must be a `datetime64` or `timedelta64` type. + + Returns + ------- + unit : str + The :ref:`datetime unit ` on which this dtype + is based. + count : int + The number of base units in a step. + + Examples + -------- + >>> import numpy as np + >>> dt_25s = np.dtype('timedelta64[25s]') + >>> np.datetime_data(dt_25s) + ('s', 25) + >>> np.array(10, dt_25s).astype('timedelta64[s]') + array(250, dtype='timedelta64[s]') + + The result can be used to construct a datetime that uses the same units + as a timedelta + + >>> np.datetime64('2010', np.datetime_data(dt_25s)) + np.datetime64('2010-01-01T00:00:00','25s') + """) + + +############################################################################## +# +# Documentation for `generic` attributes and methods +# +############################################################################## + +add_newdoc('numpy._core.numerictypes', 'generic', + """ + Base class for numpy scalar types. + + Class from which most (all?) numpy scalar types are derived. For + consistency, exposes the same API as `ndarray`, despite many + consequent attributes being either "get-only," or completely irrelevant. + This is the class from which it is strongly suggested users should derive + custom scalar types. + + """) + +# Attributes + +def refer_to_array_attribute(attr, method=True): + docstring = """ + Scalar {} identical to the corresponding array attribute. + + Please see `ndarray.{}`. + """ + + return attr, docstring.format("method" if method else "attribute", attr) + + +add_newdoc('numpy._core.numerictypes', 'generic', + refer_to_array_attribute('T', method=False)) + +add_newdoc('numpy._core.numerictypes', 'generic', + refer_to_array_attribute('base', method=False)) + +add_newdoc('numpy._core.numerictypes', 'generic', ('data', + """Pointer to start of data.""")) + +add_newdoc('numpy._core.numerictypes', 'generic', ('dtype', + """Get array data-descriptor.""")) + +add_newdoc('numpy._core.numerictypes', 'generic', ('flags', + """The integer value of flags.""")) + +add_newdoc('numpy._core.numerictypes', 'generic', ('flat', + """A 1-D view of the scalar.""")) + +add_newdoc('numpy._core.numerictypes', 'generic', ('imag', + """The imaginary part of the scalar.""")) + +add_newdoc('numpy._core.numerictypes', 'generic', ('itemsize', + """The length of one element in bytes.""")) + +add_newdoc('numpy._core.numerictypes', 'generic', ('ndim', + """The number of array dimensions.""")) + +add_newdoc('numpy._core.numerictypes', 'generic', ('real', + """The real part of the scalar.""")) + +add_newdoc('numpy._core.numerictypes', 'generic', ('shape', + """Tuple of array dimensions.""")) + +add_newdoc('numpy._core.numerictypes', 'generic', ('size', + """The number of elements in the gentype.""")) + +add_newdoc('numpy._core.numerictypes', 'generic', ('strides', + """Tuple of bytes steps in each dimension.""")) + +# Methods + +add_newdoc('numpy._core.numerictypes', 'generic', + refer_to_array_attribute('all')) + +add_newdoc('numpy._core.numerictypes', 'generic', + refer_to_array_attribute('any')) + +add_newdoc('numpy._core.numerictypes', 'generic', + refer_to_array_attribute('argmax')) + +add_newdoc('numpy._core.numerictypes', 'generic', + refer_to_array_attribute('argmin')) + +add_newdoc('numpy._core.numerictypes', 'generic', + refer_to_array_attribute('argsort')) + +add_newdoc('numpy._core.numerictypes', 'generic', + refer_to_array_attribute('astype')) + +add_newdoc('numpy._core.numerictypes', 'generic', + refer_to_array_attribute('byteswap')) + +add_newdoc('numpy._core.numerictypes', 'generic', + refer_to_array_attribute('choose')) + +add_newdoc('numpy._core.numerictypes', 'generic', + refer_to_array_attribute('clip')) + +add_newdoc('numpy._core.numerictypes', 'generic', + refer_to_array_attribute('compress')) + +add_newdoc('numpy._core.numerictypes', 'generic', + refer_to_array_attribute('conjugate')) + +add_newdoc('numpy._core.numerictypes', 'generic', + refer_to_array_attribute('copy')) + +add_newdoc('numpy._core.numerictypes', 'generic', + refer_to_array_attribute('cumprod')) + +add_newdoc('numpy._core.numerictypes', 'generic', + refer_to_array_attribute('cumsum')) + +add_newdoc('numpy._core.numerictypes', 'generic', + refer_to_array_attribute('diagonal')) + +add_newdoc('numpy._core.numerictypes', 'generic', + refer_to_array_attribute('dump')) + +add_newdoc('numpy._core.numerictypes', 'generic', + refer_to_array_attribute('dumps')) + +add_newdoc('numpy._core.numerictypes', 'generic', + refer_to_array_attribute('fill')) + +add_newdoc('numpy._core.numerictypes', 'generic', + refer_to_array_attribute('flatten')) + +add_newdoc('numpy._core.numerictypes', 'generic', + refer_to_array_attribute('getfield')) + +add_newdoc('numpy._core.numerictypes', 'generic', + refer_to_array_attribute('item')) + +add_newdoc('numpy._core.numerictypes', 'generic', + refer_to_array_attribute('max')) + +add_newdoc('numpy._core.numerictypes', 'generic', + refer_to_array_attribute('mean')) + +add_newdoc('numpy._core.numerictypes', 'generic', + refer_to_array_attribute('min')) + +add_newdoc('numpy._core.numerictypes', 'generic', + refer_to_array_attribute('nonzero')) + +add_newdoc('numpy._core.numerictypes', 'generic', + refer_to_array_attribute('prod')) + +add_newdoc('numpy._core.numerictypes', 'generic', + refer_to_array_attribute('put')) + +add_newdoc('numpy._core.numerictypes', 'generic', + refer_to_array_attribute('ravel')) + +add_newdoc('numpy._core.numerictypes', 'generic', + refer_to_array_attribute('repeat')) + +add_newdoc('numpy._core.numerictypes', 'generic', + refer_to_array_attribute('reshape')) + +add_newdoc('numpy._core.numerictypes', 'generic', + refer_to_array_attribute('resize')) + +add_newdoc('numpy._core.numerictypes', 'generic', + refer_to_array_attribute('round')) + +add_newdoc('numpy._core.numerictypes', 'generic', + refer_to_array_attribute('searchsorted')) + +add_newdoc('numpy._core.numerictypes', 'generic', + refer_to_array_attribute('setfield')) + +add_newdoc('numpy._core.numerictypes', 'generic', + refer_to_array_attribute('setflags')) + +add_newdoc('numpy._core.numerictypes', 'generic', + refer_to_array_attribute('sort')) + +add_newdoc('numpy._core.numerictypes', 'generic', + refer_to_array_attribute('squeeze')) + +add_newdoc('numpy._core.numerictypes', 'generic', + refer_to_array_attribute('std')) + +add_newdoc('numpy._core.numerictypes', 'generic', + refer_to_array_attribute('sum')) + +add_newdoc('numpy._core.numerictypes', 'generic', + refer_to_array_attribute('swapaxes')) + +add_newdoc('numpy._core.numerictypes', 'generic', + refer_to_array_attribute('take')) + +add_newdoc('numpy._core.numerictypes', 'generic', + refer_to_array_attribute('tofile')) + +add_newdoc('numpy._core.numerictypes', 'generic', + refer_to_array_attribute('tolist')) + +add_newdoc('numpy._core.numerictypes', 'generic', + refer_to_array_attribute('tostring')) + +add_newdoc('numpy._core.numerictypes', 'generic', + refer_to_array_attribute('trace')) + +add_newdoc('numpy._core.numerictypes', 'generic', + refer_to_array_attribute('transpose')) + +add_newdoc('numpy._core.numerictypes', 'generic', + refer_to_array_attribute('var')) + +add_newdoc('numpy._core.numerictypes', 'generic', + refer_to_array_attribute('view')) + +add_newdoc('numpy._core.numerictypes', 'number', ('__class_getitem__', + """ + __class_getitem__(item, /) + + Return a parametrized wrapper around the `~numpy.number` type. + + .. versionadded:: 1.22 + + Returns + ------- + alias : types.GenericAlias + A parametrized `~numpy.number` type. + + Examples + -------- + >>> from typing import Any + >>> import numpy as np + + >>> np.signedinteger[Any] + numpy.signedinteger[typing.Any] + + See Also + -------- + :pep:`585` : Type hinting generics in standard collections. + + """)) + +############################################################################## +# +# Documentation for scalar type abstract base classes in type hierarchy +# +############################################################################## + + +add_newdoc('numpy._core.numerictypes', 'number', + """ + Abstract base class of all numeric scalar types. + + """) + +add_newdoc('numpy._core.numerictypes', 'integer', + """ + Abstract base class of all integer scalar types. + + """) + +add_newdoc('numpy._core.numerictypes', 'signedinteger', + """ + Abstract base class of all signed integer scalar types. + + """) + +add_newdoc('numpy._core.numerictypes', 'unsignedinteger', + """ + Abstract base class of all unsigned integer scalar types. + + """) + +add_newdoc('numpy._core.numerictypes', 'inexact', + """ + Abstract base class of all numeric scalar types with a (potentially) + inexact representation of the values in its range, such as + floating-point numbers. + + """) + +add_newdoc('numpy._core.numerictypes', 'floating', + """ + Abstract base class of all floating-point scalar types. + + """) + +add_newdoc('numpy._core.numerictypes', 'complexfloating', + """ + Abstract base class of all complex number scalar types that are made up of + floating-point numbers. + + """) + +add_newdoc('numpy._core.numerictypes', 'flexible', + """ + Abstract base class of all scalar types without predefined length. + The actual size of these types depends on the specific `numpy.dtype` + instantiation. + + """) + +add_newdoc('numpy._core.numerictypes', 'character', + """ + Abstract base class of all character string scalar types. + + """) + +add_newdoc('numpy._core.multiarray', 'StringDType', + """ + StringDType(*, na_object=np._NoValue, coerce=True) + + Create a StringDType instance. + + StringDType can be used to store UTF-8 encoded variable-width strings in + a NumPy array. + + Parameters + ---------- + na_object : object, optional + Object used to represent missing data. If unset, the array will not + use a missing data sentinel. + coerce : bool, optional + Whether or not items in an array-like passed to an array creation + function that are neither a str or str subtype should be coerced to + str. Defaults to True. If set to False, creating a StringDType + array from an array-like containing entries that are not already + strings will raise an error. + + Examples + -------- + + >>> import numpy as np + + >>> from numpy.dtypes import StringDType + >>> np.array(["hello", "world"], dtype=StringDType()) + array(["hello", "world"], dtype=StringDType()) + + >>> arr = np.array(["hello", None, "world"], + ... dtype=StringDType(na_object=None)) + >>> arr + array(["hello", None, "world"], dtype=StringDType(na_object=None)) + >>> arr[1] is None + True + + >>> arr = np.array(["hello", np.nan, "world"], + ... dtype=StringDType(na_object=np.nan)) + >>> np.isnan(arr) + array([False, True, False]) + + >>> np.array([1.2, object(), "hello world"], + ... dtype=StringDType(coerce=True)) + ValueError: StringDType only allows string data when string coercion + is disabled. + + >>> np.array(["hello", "world"], dtype=StringDType(coerce=True)) + array(["hello", "world"], dtype=StringDType(coerce=True)) + """) diff --git a/venv/lib/python3.12/site-packages/numpy/_core/_add_newdocs_scalars.py b/venv/lib/python3.12/site-packages/numpy/_core/_add_newdocs_scalars.py new file mode 100644 index 00000000..d7f2853e --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/_add_newdocs_scalars.py @@ -0,0 +1,389 @@ +""" +This file is separate from ``_add_newdocs.py`` so that it can be mocked out by +our sphinx ``conf.py`` during doc builds, where we want to avoid showing +platform-dependent information. +""" +import sys +import os +from numpy._core import dtype +from numpy._core import numerictypes as _numerictypes +from numpy._core.function_base import add_newdoc + +############################################################################## +# +# Documentation for concrete scalar classes +# +############################################################################## + +def numeric_type_aliases(aliases): + def type_aliases_gen(): + for alias, doc in aliases: + try: + alias_type = getattr(_numerictypes, alias) + except AttributeError: + # The set of aliases that actually exist varies between platforms + pass + else: + yield (alias_type, alias, doc) + return list(type_aliases_gen()) + + +possible_aliases = numeric_type_aliases([ + ('int8', '8-bit signed integer (``-128`` to ``127``)'), + ('int16', '16-bit signed integer (``-32_768`` to ``32_767``)'), + ('int32', '32-bit signed integer (``-2_147_483_648`` to ``2_147_483_647``)'), + ('int64', '64-bit signed integer (``-9_223_372_036_854_775_808`` to ``9_223_372_036_854_775_807``)'), + ('intp', 'Signed integer large enough to fit pointer, compatible with C ``intptr_t``'), + ('uint8', '8-bit unsigned integer (``0`` to ``255``)'), + ('uint16', '16-bit unsigned integer (``0`` to ``65_535``)'), + ('uint32', '32-bit unsigned integer (``0`` to ``4_294_967_295``)'), + ('uint64', '64-bit unsigned integer (``0`` to ``18_446_744_073_709_551_615``)'), + ('uintp', 'Unsigned integer large enough to fit pointer, compatible with C ``uintptr_t``'), + ('float16', '16-bit-precision floating-point number type: sign bit, 5 bits exponent, 10 bits mantissa'), + ('float32', '32-bit-precision floating-point number type: sign bit, 8 bits exponent, 23 bits mantissa'), + ('float64', '64-bit precision floating-point number type: sign bit, 11 bits exponent, 52 bits mantissa'), + ('float96', '96-bit extended-precision floating-point number type'), + ('float128', '128-bit extended-precision floating-point number type'), + ('complex64', 'Complex number type composed of 2 32-bit-precision floating-point numbers'), + ('complex128', 'Complex number type composed of 2 64-bit-precision floating-point numbers'), + ('complex192', 'Complex number type composed of 2 96-bit extended-precision floating-point numbers'), + ('complex256', 'Complex number type composed of 2 128-bit extended-precision floating-point numbers'), + ]) + + +def _get_platform_and_machine(): + try: + system, _, _, _, machine = os.uname() + except AttributeError: + system = sys.platform + if system == 'win32': + machine = os.environ.get('PROCESSOR_ARCHITEW6432', '') \ + or os.environ.get('PROCESSOR_ARCHITECTURE', '') + else: + machine = 'unknown' + return system, machine + + +_system, _machine = _get_platform_and_machine() +_doc_alias_string = f":Alias on this platform ({_system} {_machine}):" + + +def add_newdoc_for_scalar_type(obj, fixed_aliases, doc): + # note: `:field: value` is rST syntax which renders as field lists. + o = getattr(_numerictypes, obj) + + character_code = dtype(o).char + canonical_name_doc = "" if obj == o.__name__ else \ + f":Canonical name: `numpy.{obj}`\n " + if fixed_aliases: + alias_doc = ''.join(f":Alias: `numpy.{alias}`\n " + for alias in fixed_aliases) + else: + alias_doc = '' + alias_doc += ''.join(f"{_doc_alias_string} `numpy.{alias}`: {doc}.\n " + for (alias_type, alias, doc) in possible_aliases if alias_type is o) + + docstring = f""" + {doc.strip()} + + :Character code: ``'{character_code}'`` + {canonical_name_doc}{alias_doc} + """ + + add_newdoc('numpy._core.numerictypes', obj, docstring) + + +_bool_docstring = ( + """ + Boolean type (True or False), stored as a byte. + + .. warning:: + + The :class:`bool` type is not a subclass of the :class:`int_` type + (the :class:`bool` is not even a number type). This is different + than Python's default implementation of :class:`bool` as a + sub-class of :class:`int`. + """ +) + +add_newdoc_for_scalar_type('bool', [], _bool_docstring) + +add_newdoc_for_scalar_type('bool_', [], _bool_docstring) + +add_newdoc_for_scalar_type('byte', [], + """ + Signed integer type, compatible with C ``char``. + """) + +add_newdoc_for_scalar_type('short', [], + """ + Signed integer type, compatible with C ``short``. + """) + +add_newdoc_for_scalar_type('intc', [], + """ + Signed integer type, compatible with C ``int``. + """) + +# TODO: These docs probably need an if to highlight the default rather than +# the C-types (and be correct). +add_newdoc_for_scalar_type('int_', [], + """ + Default signed integer type, 64bit on 64bit systems and 32bit on 32bit + systems. + """) + +add_newdoc_for_scalar_type('longlong', [], + """ + Signed integer type, compatible with C ``long long``. + """) + +add_newdoc_for_scalar_type('ubyte', [], + """ + Unsigned integer type, compatible with C ``unsigned char``. + """) + +add_newdoc_for_scalar_type('ushort', [], + """ + Unsigned integer type, compatible with C ``unsigned short``. + """) + +add_newdoc_for_scalar_type('uintc', [], + """ + Unsigned integer type, compatible with C ``unsigned int``. + """) + +add_newdoc_for_scalar_type('uint', [], + """ + Unsigned signed integer type, 64bit on 64bit systems and 32bit on 32bit + systems. + """) + +add_newdoc_for_scalar_type('ulonglong', [], + """ + Signed integer type, compatible with C ``unsigned long long``. + """) + +add_newdoc_for_scalar_type('half', [], + """ + Half-precision floating-point number type. + """) + +add_newdoc_for_scalar_type('single', [], + """ + Single-precision floating-point number type, compatible with C ``float``. + """) + +add_newdoc_for_scalar_type('double', [], + """ + Double-precision floating-point number type, compatible with Python + :class:`float` and C ``double``. + """) + +add_newdoc_for_scalar_type('longdouble', [], + """ + Extended-precision floating-point number type, compatible with C + ``long double`` but not necessarily with IEEE 754 quadruple-precision. + """) + +add_newdoc_for_scalar_type('csingle', [], + """ + Complex number type composed of two single-precision floating-point + numbers. + """) + +add_newdoc_for_scalar_type('cdouble', [], + """ + Complex number type composed of two double-precision floating-point + numbers, compatible with Python :class:`complex`. + """) + +add_newdoc_for_scalar_type('clongdouble', [], + """ + Complex number type composed of two extended-precision floating-point + numbers. + """) + +add_newdoc_for_scalar_type('object_', [], + """ + Any Python object. + """) + +add_newdoc_for_scalar_type('str_', [], + r""" + A unicode string. + + This type strips trailing null codepoints. + + >>> s = np.str_("abc\x00") + >>> s + 'abc' + + Unlike the builtin :class:`str`, this supports the + :ref:`python:bufferobjects`, exposing its contents as UCS4: + + >>> m = memoryview(np.str_("abc")) + >>> m.format + '3w' + >>> m.tobytes() + b'a\x00\x00\x00b\x00\x00\x00c\x00\x00\x00' + """) + +add_newdoc_for_scalar_type('bytes_', [], + r""" + A byte string. + + When used in arrays, this type strips trailing null bytes. + """) + +add_newdoc_for_scalar_type('void', [], + r""" + np.void(length_or_data, /, dtype=None) + + Create a new structured or unstructured void scalar. + + Parameters + ---------- + length_or_data : int, array-like, bytes-like, object + One of multiple meanings (see notes). The length or + bytes data of an unstructured void. Or alternatively, + the data to be stored in the new scalar when `dtype` + is provided. + This can be an array-like, in which case an array may + be returned. + dtype : dtype, optional + If provided the dtype of the new scalar. This dtype must + be "void" dtype (i.e. a structured or unstructured void, + see also :ref:`defining-structured-types`). + + .. versionadded:: 1.24 + + Notes + ----- + For historical reasons and because void scalars can represent both + arbitrary byte data and structured dtypes, the void constructor + has three calling conventions: + + 1. ``np.void(5)`` creates a ``dtype="V5"`` scalar filled with five + ``\0`` bytes. The 5 can be a Python or NumPy integer. + 2. ``np.void(b"bytes-like")`` creates a void scalar from the byte string. + The dtype itemsize will match the byte string length, here ``"V10"``. + 3. When a ``dtype=`` is passed the call is roughly the same as an + array creation. However, a void scalar rather than array is returned. + + Please see the examples which show all three different conventions. + + Examples + -------- + >>> np.void(5) + np.void(b'\x00\x00\x00\x00\x00') + >>> np.void(b'abcd') + np.void(b'\x61\x62\x63\x64') + >>> np.void((3.2, b'eggs'), dtype="d,S5") + np.void((3.2, b'eggs'), dtype=[('f0', '>> np.void(3, dtype=[('x', np.int8), ('y', np.int8)]) + np.void((3, 3), dtype=[('x', 'i1'), ('y', 'i1')]) + + """) + +add_newdoc_for_scalar_type('datetime64', [], + """ + If created from a 64-bit integer, it represents an offset from + ``1970-01-01T00:00:00``. + If created from string, the string can be in ISO 8601 date + or datetime format. + + When parsing a string to create a datetime object, if the string contains + a trailing timezone (A 'Z' or a timezone offset), the timezone will be + dropped and a User Warning is given. + + Datetime64 objects should be considered to be UTC and therefore have an + offset of +0000. + + >>> np.datetime64(10, 'Y') + np.datetime64('1980') + >>> np.datetime64('1980', 'Y') + np.datetime64('1980') + >>> np.datetime64(10, 'D') + np.datetime64('1970-01-11') + + See :ref:`arrays.datetime` for more information. + """) + +add_newdoc_for_scalar_type('timedelta64', [], + """ + A timedelta stored as a 64-bit integer. + + See :ref:`arrays.datetime` for more information. + """) + +add_newdoc('numpy._core.numerictypes', "integer", ('is_integer', + """ + integer.is_integer() -> bool + + Return ``True`` if the number is finite with integral value. + + .. versionadded:: 1.22 + + Examples + -------- + >>> import numpy as np + >>> np.int64(-2).is_integer() + True + >>> np.uint32(5).is_integer() + True + """)) + +# TODO: work out how to put this on the base class, np.floating +for float_name in ('half', 'single', 'double', 'longdouble'): + add_newdoc('numpy._core.numerictypes', float_name, ('as_integer_ratio', + """ + {ftype}.as_integer_ratio() -> (int, int) + + Return a pair of integers, whose ratio is exactly equal to the original + floating point number, and with a positive denominator. + Raise `OverflowError` on infinities and a `ValueError` on NaNs. + + >>> np.{ftype}(10.0).as_integer_ratio() + (10, 1) + >>> np.{ftype}(0.0).as_integer_ratio() + (0, 1) + >>> np.{ftype}(-.25).as_integer_ratio() + (-1, 4) + """.format(ftype=float_name))) + + add_newdoc('numpy._core.numerictypes', float_name, ('is_integer', + f""" + {float_name}.is_integer() -> bool + + Return ``True`` if the floating point number is finite with integral + value, and ``False`` otherwise. + + .. versionadded:: 1.22 + + Examples + -------- + >>> np.{float_name}(-2.0).is_integer() + True + >>> np.{float_name}(3.2).is_integer() + False + """)) + +for int_name in ('int8', 'uint8', 'int16', 'uint16', 'int32', 'uint32', + 'int64', 'uint64', 'int64', 'uint64', 'int64', 'uint64'): + # Add negative examples for signed cases by checking typecode + add_newdoc('numpy._core.numerictypes', int_name, ('bit_count', + f""" + {int_name}.bit_count() -> int + + Computes the number of 1-bits in the absolute value of the input. + Analogous to the builtin `int.bit_count` or ``popcount`` in C++. + + Examples + -------- + >>> np.{int_name}(127).bit_count() + 7""" + + (f""" + >>> np.{int_name}(-127).bit_count() + 7 + """ if dtype(int_name).char.islower() else ""))) diff --git a/venv/lib/python3.12/site-packages/numpy/_core/_asarray.py b/venv/lib/python3.12/site-packages/numpy/_core/_asarray.py new file mode 100644 index 00000000..2908813e --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/_asarray.py @@ -0,0 +1,135 @@ +""" +Functions in the ``as*array`` family that promote array-likes into arrays. + +`require` fits this category despite its name not matching this pattern. +""" +from .overrides import ( + array_function_dispatch, + set_array_function_like_doc, + set_module, +) +from .multiarray import array, asanyarray + + +__all__ = ["require"] + + +POSSIBLE_FLAGS = { + 'C': 'C', 'C_CONTIGUOUS': 'C', 'CONTIGUOUS': 'C', + 'F': 'F', 'F_CONTIGUOUS': 'F', 'FORTRAN': 'F', + 'A': 'A', 'ALIGNED': 'A', + 'W': 'W', 'WRITEABLE': 'W', + 'O': 'O', 'OWNDATA': 'O', + 'E': 'E', 'ENSUREARRAY': 'E' +} + + +@set_array_function_like_doc +@set_module('numpy') +def require(a, dtype=None, requirements=None, *, like=None): + """ + Return an ndarray of the provided type that satisfies requirements. + + This function is useful to be sure that an array with the correct flags + is returned for passing to compiled code (perhaps through ctypes). + + Parameters + ---------- + a : array_like + The object to be converted to a type-and-requirement-satisfying array. + dtype : data-type + The required data-type. If None preserve the current dtype. If your + application requires the data to be in native byteorder, include + a byteorder specification as a part of the dtype specification. + requirements : str or sequence of str + The requirements list can be any of the following + + * 'F_CONTIGUOUS' ('F') - ensure a Fortran-contiguous array + * 'C_CONTIGUOUS' ('C') - ensure a C-contiguous array + * 'ALIGNED' ('A') - ensure a data-type aligned array + * 'WRITEABLE' ('W') - ensure a writable array + * 'OWNDATA' ('O') - ensure an array that owns its own data + * 'ENSUREARRAY', ('E') - ensure a base array, instead of a subclass + ${ARRAY_FUNCTION_LIKE} + + .. versionadded:: 1.20.0 + + Returns + ------- + out : ndarray + Array with specified requirements and type if given. + + See Also + -------- + asarray : Convert input to an ndarray. + asanyarray : Convert to an ndarray, but pass through ndarray subclasses. + ascontiguousarray : Convert input to a contiguous array. + asfortranarray : Convert input to an ndarray with column-major + memory order. + ndarray.flags : Information about the memory layout of the array. + + Notes + ----- + The returned array will be guaranteed to have the listed requirements + by making a copy if needed. + + Examples + -------- + >>> import numpy as np + >>> x = np.arange(6).reshape(2,3) + >>> x.flags + C_CONTIGUOUS : True + F_CONTIGUOUS : False + OWNDATA : False + WRITEABLE : True + ALIGNED : True + WRITEBACKIFCOPY : False + + >>> y = np.require(x, dtype=np.float32, requirements=['A', 'O', 'W', 'F']) + >>> y.flags + C_CONTIGUOUS : False + F_CONTIGUOUS : True + OWNDATA : True + WRITEABLE : True + ALIGNED : True + WRITEBACKIFCOPY : False + + """ + if like is not None: + return _require_with_like( + like, + a, + dtype=dtype, + requirements=requirements, + ) + + if not requirements: + return asanyarray(a, dtype=dtype) + + requirements = {POSSIBLE_FLAGS[x.upper()] for x in requirements} + + if 'E' in requirements: + requirements.remove('E') + subok = False + else: + subok = True + + order = 'A' + if requirements >= {'C', 'F'}: + raise ValueError('Cannot specify both "C" and "F" order') + elif 'F' in requirements: + order = 'F' + requirements.remove('F') + elif 'C' in requirements: + order = 'C' + requirements.remove('C') + + arr = array(a, dtype=dtype, order=order, copy=None, subok=subok) + + for prop in requirements: + if not arr.flags[prop]: + return arr.copy(order) + return arr + + +_require_with_like = array_function_dispatch()(require) diff --git a/venv/lib/python3.12/site-packages/numpy/_core/_asarray.pyi b/venv/lib/python3.12/site-packages/numpy/_core/_asarray.pyi new file mode 100644 index 00000000..5cd49659 --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/_asarray.pyi @@ -0,0 +1,41 @@ +from collections.abc import Iterable +from typing import Any, TypeVar, overload, Literal + +from numpy._typing import NDArray, DTypeLike, _SupportsArrayFunc + +_ArrayType = TypeVar("_ArrayType", bound=NDArray[Any]) + +_Requirements = Literal[ + "C", "C_CONTIGUOUS", "CONTIGUOUS", + "F", "F_CONTIGUOUS", "FORTRAN", + "A", "ALIGNED", + "W", "WRITEABLE", + "O", "OWNDATA" +] +_E = Literal["E", "ENSUREARRAY"] +_RequirementsWithE = _Requirements | _E + +@overload +def require( + a: _ArrayType, + dtype: None = ..., + requirements: None | _Requirements | Iterable[_Requirements] = ..., + *, + like: _SupportsArrayFunc = ... +) -> _ArrayType: ... +@overload +def require( + a: object, + dtype: DTypeLike = ..., + requirements: _E | Iterable[_RequirementsWithE] = ..., + *, + like: _SupportsArrayFunc = ... +) -> NDArray[Any]: ... +@overload +def require( + a: object, + dtype: DTypeLike = ..., + requirements: None | _Requirements | Iterable[_Requirements] = ..., + *, + like: _SupportsArrayFunc = ... +) -> NDArray[Any]: ... diff --git a/venv/lib/python3.12/site-packages/numpy/_core/_dtype.py b/venv/lib/python3.12/site-packages/numpy/_core/_dtype.py new file mode 100644 index 00000000..ee9b9659 --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/_dtype.py @@ -0,0 +1,374 @@ +""" +A place for code to be called from the implementation of np.dtype + +String handling is much easier to do correctly in python. +""" +import numpy as np + + +_kind_to_stem = { + 'u': 'uint', + 'i': 'int', + 'c': 'complex', + 'f': 'float', + 'b': 'bool', + 'V': 'void', + 'O': 'object', + 'M': 'datetime', + 'm': 'timedelta', + 'S': 'bytes', + 'U': 'str', +} + + +def _kind_name(dtype): + try: + return _kind_to_stem[dtype.kind] + except KeyError as e: + raise RuntimeError( + "internal dtype error, unknown kind {!r}" + .format(dtype.kind) + ) from None + + +def __str__(dtype): + if dtype.fields is not None: + return _struct_str(dtype, include_align=True) + elif dtype.subdtype: + return _subarray_str(dtype) + elif issubclass(dtype.type, np.flexible) or not dtype.isnative: + return dtype.str + else: + return dtype.name + + +def __repr__(dtype): + arg_str = _construction_repr(dtype, include_align=False) + if dtype.isalignedstruct: + arg_str = arg_str + ", align=True" + return "dtype({})".format(arg_str) + + +def _unpack_field(dtype, offset, title=None): + """ + Helper function to normalize the items in dtype.fields. + + Call as: + + dtype, offset, title = _unpack_field(*dtype.fields[name]) + """ + return dtype, offset, title + + +def _isunsized(dtype): + # PyDataType_ISUNSIZED + return dtype.itemsize == 0 + + +def _construction_repr(dtype, include_align=False, short=False): + """ + Creates a string repr of the dtype, excluding the 'dtype()' part + surrounding the object. This object may be a string, a list, or + a dict depending on the nature of the dtype. This + is the object passed as the first parameter to the dtype + constructor, and if no additional constructor parameters are + given, will reproduce the exact memory layout. + + Parameters + ---------- + short : bool + If true, this creates a shorter repr using 'kind' and 'itemsize', + instead of the longer type name. + + include_align : bool + If true, this includes the 'align=True' parameter + inside the struct dtype construction dict when needed. Use this flag + if you want a proper repr string without the 'dtype()' part around it. + + If false, this does not preserve the + 'align=True' parameter or sticky NPY_ALIGNED_STRUCT flag for + struct arrays like the regular repr does, because the 'align' + flag is not part of first dtype constructor parameter. This + mode is intended for a full 'repr', where the 'align=True' is + provided as the second parameter. + """ + if dtype.fields is not None: + return _struct_str(dtype, include_align=include_align) + elif dtype.subdtype: + return _subarray_str(dtype) + else: + return _scalar_str(dtype, short=short) + + +def _scalar_str(dtype, short): + byteorder = _byte_order_str(dtype) + + if dtype.type == np.bool: + if short: + return "'?'" + else: + return "'bool'" + + elif dtype.type == np.object_: + # The object reference may be different sizes on different + # platforms, so it should never include the itemsize here. + return "'O'" + + elif dtype.type == np.bytes_: + if _isunsized(dtype): + return "'S'" + else: + return "'S%d'" % dtype.itemsize + + elif dtype.type == np.str_: + if _isunsized(dtype): + return "'%sU'" % byteorder + else: + return "'%sU%d'" % (byteorder, dtype.itemsize / 4) + + elif dtype.type == str: + return "'T'" + + elif not type(dtype)._legacy: + return f"'{byteorder}{type(dtype).__name__}{dtype.itemsize * 8}'" + + # unlike the other types, subclasses of void are preserved - but + # historically the repr does not actually reveal the subclass + elif issubclass(dtype.type, np.void): + if _isunsized(dtype): + return "'V'" + else: + return "'V%d'" % dtype.itemsize + + elif dtype.type == np.datetime64: + return "'%sM8%s'" % (byteorder, _datetime_metadata_str(dtype)) + + elif dtype.type == np.timedelta64: + return "'%sm8%s'" % (byteorder, _datetime_metadata_str(dtype)) + + elif np.issubdtype(dtype, np.number): + # Short repr with endianness, like '' """ + # hack to obtain the native and swapped byte order characters + swapped = np.dtype(int).newbyteorder('S') + native = swapped.newbyteorder('S') + + byteorder = dtype.byteorder + if byteorder == '=': + return native.byteorder + if byteorder == 'S': + # TODO: this path can never be reached + return swapped.byteorder + elif byteorder == '|': + return '' + else: + return byteorder + + +def _datetime_metadata_str(dtype): + # TODO: this duplicates the C metastr_to_unicode functionality + unit, count = np.datetime_data(dtype) + if unit == 'generic': + return '' + elif count == 1: + return '[{}]'.format(unit) + else: + return '[{}{}]'.format(count, unit) + + +def _struct_dict_str(dtype, includealignedflag): + # unpack the fields dictionary into ls + names = dtype.names + fld_dtypes = [] + offsets = [] + titles = [] + for name in names: + fld_dtype, offset, title = _unpack_field(*dtype.fields[name]) + fld_dtypes.append(fld_dtype) + offsets.append(offset) + titles.append(title) + + # Build up a string to make the dictionary + + if np._core.arrayprint._get_legacy_print_mode() <= 121: + colon = ":" + fieldsep = "," + else: + colon = ": " + fieldsep = ", " + + # First, the names + ret = "{'names'%s[" % colon + ret += fieldsep.join(repr(name) for name in names) + + # Second, the formats + ret += "], 'formats'%s[" % colon + ret += fieldsep.join( + _construction_repr(fld_dtype, short=True) for fld_dtype in fld_dtypes) + + # Third, the offsets + ret += "], 'offsets'%s[" % colon + ret += fieldsep.join("%d" % offset for offset in offsets) + + # Fourth, the titles + if any(title is not None for title in titles): + ret += "], 'titles'%s[" % colon + ret += fieldsep.join(repr(title) for title in titles) + + # Fifth, the itemsize + ret += "], 'itemsize'%s%d" % (colon, dtype.itemsize) + + if (includealignedflag and dtype.isalignedstruct): + # Finally, the aligned flag + ret += ", 'aligned'%sTrue}" % colon + else: + ret += "}" + + return ret + + +def _aligned_offset(offset, alignment): + # round up offset: + return - (-offset // alignment) * alignment + + +def _is_packed(dtype): + """ + Checks whether the structured data type in 'dtype' + has a simple layout, where all the fields are in order, + and follow each other with no alignment padding. + + When this returns true, the dtype can be reconstructed + from a list of the field names and dtypes with no additional + dtype parameters. + + Duplicates the C `is_dtype_struct_simple_unaligned_layout` function. + """ + align = dtype.isalignedstruct + max_alignment = 1 + total_offset = 0 + for name in dtype.names: + fld_dtype, fld_offset, title = _unpack_field(*dtype.fields[name]) + + if align: + total_offset = _aligned_offset(total_offset, fld_dtype.alignment) + max_alignment = max(max_alignment, fld_dtype.alignment) + + if fld_offset != total_offset: + return False + total_offset += fld_dtype.itemsize + + if align: + total_offset = _aligned_offset(total_offset, max_alignment) + + return total_offset == dtype.itemsize + + +def _struct_list_str(dtype): + items = [] + for name in dtype.names: + fld_dtype, fld_offset, title = _unpack_field(*dtype.fields[name]) + + item = "(" + if title is not None: + item += "({!r}, {!r}), ".format(title, name) + else: + item += "{!r}, ".format(name) + # Special case subarray handling here + if fld_dtype.subdtype is not None: + base, shape = fld_dtype.subdtype + item += "{}, {}".format( + _construction_repr(base, short=True), + shape + ) + else: + item += _construction_repr(fld_dtype, short=True) + + item += ")" + items.append(item) + + return "[" + ", ".join(items) + "]" + + +def _struct_str(dtype, include_align): + # The list str representation can't include the 'align=' flag, + # so if it is requested and the struct has the aligned flag set, + # we must use the dict str instead. + if not (include_align and dtype.isalignedstruct) and _is_packed(dtype): + sub = _struct_list_str(dtype) + + else: + sub = _struct_dict_str(dtype, include_align) + + # If the data type isn't the default, void, show it + if dtype.type != np.void: + return "({t.__module__}.{t.__name__}, {f})".format(t=dtype.type, f=sub) + else: + return sub + + +def _subarray_str(dtype): + base, shape = dtype.subdtype + return "({}, {})".format( + _construction_repr(base, short=True), + shape + ) + + +def _name_includes_bit_suffix(dtype): + if dtype.type == np.object_: + # pointer size varies by system, best to omit it + return False + elif dtype.type == np.bool: + # implied + return False + elif dtype.type is None: + return True + elif np.issubdtype(dtype, np.flexible) and _isunsized(dtype): + # unspecified + return False + else: + return True + + +def _name_get(dtype): + # provides dtype.name.__get__, documented as returning a "bit name" + + if dtype.isbuiltin == 2: + # user dtypes don't promise to do anything special + return dtype.type.__name__ + + if not type(dtype)._legacy: + name = type(dtype).__name__ + + elif issubclass(dtype.type, np.void): + # historically, void subclasses preserve their name, eg `record64` + name = dtype.type.__name__ + else: + name = _kind_name(dtype) + + # append bit counts + if _name_includes_bit_suffix(dtype): + name += "{}".format(dtype.itemsize * 8) + + # append metadata to datetimes + if dtype.type in (np.datetime64, np.timedelta64): + name += _datetime_metadata_str(dtype) + + return name diff --git a/venv/lib/python3.12/site-packages/numpy/_core/_dtype_ctypes.py b/venv/lib/python3.12/site-packages/numpy/_core/_dtype_ctypes.py new file mode 100644 index 00000000..fef1e0db --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/_dtype_ctypes.py @@ -0,0 +1,120 @@ +""" +Conversion from ctypes to dtype. + +In an ideal world, we could achieve this through the PEP3118 buffer protocol, +something like:: + + def dtype_from_ctypes_type(t): + # needed to ensure that the shape of `t` is within memoryview.format + class DummyStruct(ctypes.Structure): + _fields_ = [('a', t)] + + # empty to avoid memory allocation + ctype_0 = (DummyStruct * 0)() + mv = memoryview(ctype_0) + + # convert the struct, and slice back out the field + return _dtype_from_pep3118(mv.format)['a'] + +Unfortunately, this fails because: + +* ctypes cannot handle length-0 arrays with PEP3118 (bpo-32782) +* PEP3118 cannot represent unions, but both numpy and ctypes can +* ctypes cannot handle big-endian structs with PEP3118 (bpo-32780) +""" + +# We delay-import ctypes for distributions that do not include it. +# While this module is not used unless the user passes in ctypes +# members, it is eagerly imported from numpy/_core/__init__.py. +import numpy as np + + +def _from_ctypes_array(t): + return np.dtype((dtype_from_ctypes_type(t._type_), (t._length_,))) + + +def _from_ctypes_structure(t): + for item in t._fields_: + if len(item) > 2: + raise TypeError( + "ctypes bitfields have no dtype equivalent") + + if hasattr(t, "_pack_"): + import ctypes + formats = [] + offsets = [] + names = [] + current_offset = 0 + for fname, ftyp in t._fields_: + names.append(fname) + formats.append(dtype_from_ctypes_type(ftyp)) + # Each type has a default offset, this is platform dependent + # for some types. + effective_pack = min(t._pack_, ctypes.alignment(ftyp)) + current_offset = ( + (current_offset + effective_pack - 1) // effective_pack + ) * effective_pack + offsets.append(current_offset) + current_offset += ctypes.sizeof(ftyp) + + return np.dtype(dict( + formats=formats, + offsets=offsets, + names=names, + itemsize=ctypes.sizeof(t))) + else: + fields = [] + for fname, ftyp in t._fields_: + fields.append((fname, dtype_from_ctypes_type(ftyp))) + + # by default, ctypes structs are aligned + return np.dtype(fields, align=True) + + +def _from_ctypes_scalar(t): + """ + Return the dtype type with endianness included if it's the case + """ + if getattr(t, '__ctype_be__', None) is t: + return np.dtype('>' + t._type_) + elif getattr(t, '__ctype_le__', None) is t: + return np.dtype('<' + t._type_) + else: + return np.dtype(t._type_) + + +def _from_ctypes_union(t): + import ctypes + formats = [] + offsets = [] + names = [] + for fname, ftyp in t._fields_: + names.append(fname) + formats.append(dtype_from_ctypes_type(ftyp)) + offsets.append(0) # Union fields are offset to 0 + + return np.dtype(dict( + formats=formats, + offsets=offsets, + names=names, + itemsize=ctypes.sizeof(t))) + + +def dtype_from_ctypes_type(t): + """ + Construct a dtype object from a ctypes type + """ + import _ctypes + if issubclass(t, _ctypes.Array): + return _from_ctypes_array(t) + elif issubclass(t, _ctypes._Pointer): + raise TypeError("ctypes pointers have no dtype equivalent") + elif issubclass(t, _ctypes.Structure): + return _from_ctypes_structure(t) + elif issubclass(t, _ctypes.Union): + return _from_ctypes_union(t) + elif isinstance(getattr(t, '_type_', None), str): + return _from_ctypes_scalar(t) + else: + raise NotImplementedError( + "Unknown ctypes type {}".format(t.__name__)) diff --git a/venv/lib/python3.12/site-packages/numpy/_core/_exceptions.py b/venv/lib/python3.12/site-packages/numpy/_core/_exceptions.py new file mode 100644 index 00000000..87d4213a --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/_exceptions.py @@ -0,0 +1,172 @@ +""" +Various richly-typed exceptions, that also help us deal with string formatting +in python where it's easier. + +By putting the formatting in `__str__`, we also avoid paying the cost for +users who silence the exceptions. +""" +from .._utils import set_module + +def _unpack_tuple(tup): + if len(tup) == 1: + return tup[0] + else: + return tup + + +def _display_as_base(cls): + """ + A decorator that makes an exception class look like its base. + + We use this to hide subclasses that are implementation details - the user + should catch the base type, which is what the traceback will show them. + + Classes decorated with this decorator are subject to removal without a + deprecation warning. + """ + assert issubclass(cls, Exception) + cls.__name__ = cls.__base__.__name__ + return cls + + +class UFuncTypeError(TypeError): + """ Base class for all ufunc exceptions """ + def __init__(self, ufunc): + self.ufunc = ufunc + + +@_display_as_base +class _UFuncNoLoopError(UFuncTypeError): + """ Thrown when a ufunc loop cannot be found """ + def __init__(self, ufunc, dtypes): + super().__init__(ufunc) + self.dtypes = tuple(dtypes) + + def __str__(self): + return ( + "ufunc {!r} did not contain a loop with signature matching types " + "{!r} -> {!r}" + ).format( + self.ufunc.__name__, + _unpack_tuple(self.dtypes[:self.ufunc.nin]), + _unpack_tuple(self.dtypes[self.ufunc.nin:]) + ) + + +@_display_as_base +class _UFuncBinaryResolutionError(_UFuncNoLoopError): + """ Thrown when a binary resolution fails """ + def __init__(self, ufunc, dtypes): + super().__init__(ufunc, dtypes) + assert len(self.dtypes) == 2 + + def __str__(self): + return ( + "ufunc {!r} cannot use operands with types {!r} and {!r}" + ).format( + self.ufunc.__name__, *self.dtypes + ) + + +@_display_as_base +class _UFuncCastingError(UFuncTypeError): + def __init__(self, ufunc, casting, from_, to): + super().__init__(ufunc) + self.casting = casting + self.from_ = from_ + self.to = to + + +@_display_as_base +class _UFuncInputCastingError(_UFuncCastingError): + """ Thrown when a ufunc input cannot be casted """ + def __init__(self, ufunc, casting, from_, to, i): + super().__init__(ufunc, casting, from_, to) + self.in_i = i + + def __str__(self): + # only show the number if more than one input exists + i_str = "{} ".format(self.in_i) if self.ufunc.nin != 1 else "" + return ( + "Cannot cast ufunc {!r} input {}from {!r} to {!r} with casting " + "rule {!r}" + ).format( + self.ufunc.__name__, i_str, self.from_, self.to, self.casting + ) + + +@_display_as_base +class _UFuncOutputCastingError(_UFuncCastingError): + """ Thrown when a ufunc output cannot be casted """ + def __init__(self, ufunc, casting, from_, to, i): + super().__init__(ufunc, casting, from_, to) + self.out_i = i + + def __str__(self): + # only show the number if more than one output exists + i_str = "{} ".format(self.out_i) if self.ufunc.nout != 1 else "" + return ( + "Cannot cast ufunc {!r} output {}from {!r} to {!r} with casting " + "rule {!r}" + ).format( + self.ufunc.__name__, i_str, self.from_, self.to, self.casting + ) + + +@_display_as_base +class _ArrayMemoryError(MemoryError): + """ Thrown when an array cannot be allocated""" + def __init__(self, shape, dtype): + self.shape = shape + self.dtype = dtype + + @property + def _total_size(self): + num_bytes = self.dtype.itemsize + for dim in self.shape: + num_bytes *= dim + return num_bytes + + @staticmethod + def _size_to_string(num_bytes): + """ Convert a number of bytes into a binary size string """ + + # https://en.wikipedia.org/wiki/Binary_prefix + LOG2_STEP = 10 + STEP = 1024 + units = ['bytes', 'KiB', 'MiB', 'GiB', 'TiB', 'PiB', 'EiB'] + + unit_i = max(num_bytes.bit_length() - 1, 1) // LOG2_STEP + unit_val = 1 << (unit_i * LOG2_STEP) + n_units = num_bytes / unit_val + del unit_val + + # ensure we pick a unit that is correct after rounding + if round(n_units) == STEP: + unit_i += 1 + n_units /= STEP + + # deal with sizes so large that we don't have units for them + if unit_i >= len(units): + new_unit_i = len(units) - 1 + n_units *= 1 << ((unit_i - new_unit_i) * LOG2_STEP) + unit_i = new_unit_i + + unit_name = units[unit_i] + # format with a sensible number of digits + if unit_i == 0: + # no decimal point on bytes + return '{:.0f} {}'.format(n_units, unit_name) + elif round(n_units) < 1000: + # 3 significant figures, if none are dropped to the left of the . + return '{:#.3g} {}'.format(n_units, unit_name) + else: + # just give all the digits otherwise + return '{:#.0f} {}'.format(n_units, unit_name) + + def __str__(self): + size_str = self._size_to_string(self._total_size) + return ( + "Unable to allocate {} for an array with shape {} and data type {}" + .format(size_str, self.shape, self.dtype) + ) diff --git a/venv/lib/python3.12/site-packages/numpy/_core/_internal.py b/venv/lib/python3.12/site-packages/numpy/_core/_internal.py new file mode 100644 index 00000000..c0142bf4 --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/_internal.py @@ -0,0 +1,963 @@ +""" +A place for internal code + +Some things are more easily handled Python. + +""" +import ast +import math +import re +import sys +import warnings + +from ..exceptions import DTypePromotionError +from .multiarray import dtype, array, ndarray, promote_types, StringDType +from numpy import _NoValue +try: + import ctypes +except ImportError: + ctypes = None + +IS_PYPY = sys.implementation.name == 'pypy' + +if sys.byteorder == 'little': + _nbo = '<' +else: + _nbo = '>' + +def _makenames_list(adict, align): + allfields = [] + + for fname, obj in adict.items(): + n = len(obj) + if not isinstance(obj, tuple) or n not in (2, 3): + raise ValueError("entry not a 2- or 3- tuple") + if n > 2 and obj[2] == fname: + continue + num = int(obj[1]) + if num < 0: + raise ValueError("invalid offset.") + format = dtype(obj[0], align=align) + if n > 2: + title = obj[2] + else: + title = None + allfields.append((fname, format, num, title)) + # sort by offsets + allfields.sort(key=lambda x: x[2]) + names = [x[0] for x in allfields] + formats = [x[1] for x in allfields] + offsets = [x[2] for x in allfields] + titles = [x[3] for x in allfields] + + return names, formats, offsets, titles + +# Called in PyArray_DescrConverter function when +# a dictionary without "names" and "formats" +# fields is used as a data-type descriptor. +def _usefields(adict, align): + try: + names = adict[-1] + except KeyError: + names = None + if names is None: + names, formats, offsets, titles = _makenames_list(adict, align) + else: + formats = [] + offsets = [] + titles = [] + for name in names: + res = adict[name] + formats.append(res[0]) + offsets.append(res[1]) + if len(res) > 2: + titles.append(res[2]) + else: + titles.append(None) + + return dtype({"names": names, + "formats": formats, + "offsets": offsets, + "titles": titles}, align) + + +# construct an array_protocol descriptor list +# from the fields attribute of a descriptor +# This calls itself recursively but should eventually hit +# a descriptor that has no fields and then return +# a simple typestring + +def _array_descr(descriptor): + fields = descriptor.fields + if fields is None: + subdtype = descriptor.subdtype + if subdtype is None: + if descriptor.metadata is None: + return descriptor.str + else: + new = descriptor.metadata.copy() + if new: + return (descriptor.str, new) + else: + return descriptor.str + else: + return (_array_descr(subdtype[0]), subdtype[1]) + + names = descriptor.names + ordered_fields = [fields[x] + (x,) for x in names] + result = [] + offset = 0 + for field in ordered_fields: + if field[1] > offset: + num = field[1] - offset + result.append(('', f'|V{num}')) + offset += num + elif field[1] < offset: + raise ValueError( + "dtype.descr is not defined for types with overlapping or " + "out-of-order fields") + if len(field) > 3: + name = (field[2], field[3]) + else: + name = field[2] + if field[0].subdtype: + tup = (name, _array_descr(field[0].subdtype[0]), + field[0].subdtype[1]) + else: + tup = (name, _array_descr(field[0])) + offset += field[0].itemsize + result.append(tup) + + if descriptor.itemsize > offset: + num = descriptor.itemsize - offset + result.append(('', f'|V{num}')) + + return result + + +# format_re was originally from numarray by J. Todd Miller + +format_re = re.compile(r'(?P[<>|=]?)' + r'(?P *[(]?[ ,0-9]*[)]? *)' + r'(?P[<>|=]?)' + r'(?P[A-Za-z0-9.?]*(?:\[[a-zA-Z0-9,.]+\])?)') +sep_re = re.compile(r'\s*,\s*') +space_re = re.compile(r'\s+$') + +# astr is a string (perhaps comma separated) + +_convorder = {'=': _nbo} + +def _commastring(astr): + startindex = 0 + result = [] + islist = False + while startindex < len(astr): + mo = format_re.match(astr, pos=startindex) + try: + (order1, repeats, order2, dtype) = mo.groups() + except (TypeError, AttributeError): + raise ValueError( + f'format number {len(result)+1} of "{astr}" is not recognized' + ) from None + startindex = mo.end() + # Separator or ending padding + if startindex < len(astr): + if space_re.match(astr, pos=startindex): + startindex = len(astr) + else: + mo = sep_re.match(astr, pos=startindex) + if not mo: + raise ValueError( + 'format number %d of "%s" is not recognized' % + (len(result)+1, astr)) + startindex = mo.end() + islist = True + + if order2 == '': + order = order1 + elif order1 == '': + order = order2 + else: + order1 = _convorder.get(order1, order1) + order2 = _convorder.get(order2, order2) + if (order1 != order2): + raise ValueError( + 'inconsistent byte-order specification %s and %s' % + (order1, order2)) + order = order1 + + if order in ('|', '=', _nbo): + order = '' + dtype = order + dtype + if repeats == '': + newitem = dtype + else: + if (repeats[0] == "(" and repeats[-1] == ")" + and repeats[1:-1].strip() != "" + and "," not in repeats): + warnings.warn( + 'Passing in a parenthesized single number for repeats ' + 'is deprecated; pass either a single number or indicate ' + 'a tuple with a comma, like "(2,)".', DeprecationWarning, + stacklevel=2) + newitem = (dtype, ast.literal_eval(repeats)) + + result.append(newitem) + + return result if islist else result[0] + +class dummy_ctype: + + def __init__(self, cls): + self._cls = cls + + def __mul__(self, other): + return self + + def __call__(self, *other): + return self._cls(other) + + def __eq__(self, other): + return self._cls == other._cls + + def __ne__(self, other): + return self._cls != other._cls + +def _getintp_ctype(): + val = _getintp_ctype.cache + if val is not None: + return val + if ctypes is None: + import numpy as np + val = dummy_ctype(np.intp) + else: + char = dtype('n').char + if char == 'i': + val = ctypes.c_int + elif char == 'l': + val = ctypes.c_long + elif char == 'q': + val = ctypes.c_longlong + else: + val = ctypes.c_long + _getintp_ctype.cache = val + return val + + +_getintp_ctype.cache = None + +# Used for .ctypes attribute of ndarray + +class _missing_ctypes: + def cast(self, num, obj): + return num.value + + class c_void_p: + def __init__(self, ptr): + self.value = ptr + + +class _ctypes: + def __init__(self, array, ptr=None): + self._arr = array + + if ctypes: + self._ctypes = ctypes + self._data = self._ctypes.c_void_p(ptr) + else: + # fake a pointer-like object that holds onto the reference + self._ctypes = _missing_ctypes() + self._data = self._ctypes.c_void_p(ptr) + self._data._objects = array + + if self._arr.ndim == 0: + self._zerod = True + else: + self._zerod = False + + def data_as(self, obj): + """ + Return the data pointer cast to a particular c-types object. + For example, calling ``self._as_parameter_`` is equivalent to + ``self.data_as(ctypes.c_void_p)``. Perhaps you want to use + the data as a pointer to a ctypes array of floating-point data: + ``self.data_as(ctypes.POINTER(ctypes.c_double))``. + + The returned pointer will keep a reference to the array. + """ + # _ctypes.cast function causes a circular reference of self._data in + # self._data._objects. Attributes of self._data cannot be released + # until gc.collect is called. Make a copy of the pointer first then + # let it hold the array reference. This is a workaround to circumvent + # the CPython bug https://bugs.python.org/issue12836. + ptr = self._ctypes.cast(self._data, obj) + ptr._arr = self._arr + return ptr + + def shape_as(self, obj): + """ + Return the shape tuple as an array of some other c-types + type. For example: ``self.shape_as(ctypes.c_short)``. + """ + if self._zerod: + return None + return (obj*self._arr.ndim)(*self._arr.shape) + + def strides_as(self, obj): + """ + Return the strides tuple as an array of some other + c-types type. For example: ``self.strides_as(ctypes.c_longlong)``. + """ + if self._zerod: + return None + return (obj*self._arr.ndim)(*self._arr.strides) + + @property + def data(self): + """ + A pointer to the memory area of the array as a Python integer. + This memory area may contain data that is not aligned, or not in + correct byte-order. The memory area may not even be writeable. + The array flags and data-type of this array should be respected + when passing this attribute to arbitrary C-code to avoid trouble + that can include Python crashing. User Beware! The value of this + attribute is exactly the same as: + ``self._array_interface_['data'][0]``. + + Note that unlike ``data_as``, a reference won't be kept to the array: + code like ``ctypes.c_void_p((a + b).ctypes.data)`` will result in a + pointer to a deallocated array, and should be spelt + ``(a + b).ctypes.data_as(ctypes.c_void_p)`` + """ + return self._data.value + + @property + def shape(self): + """ + (c_intp*self.ndim): A ctypes array of length self.ndim where + the basetype is the C-integer corresponding to ``dtype('p')`` on this + platform (see `~numpy.ctypeslib.c_intp`). This base-type could be + `ctypes.c_int`, `ctypes.c_long`, or `ctypes.c_longlong` depending on + the platform. The ctypes array contains the shape of + the underlying array. + """ + return self.shape_as(_getintp_ctype()) + + @property + def strides(self): + """ + (c_intp*self.ndim): A ctypes array of length self.ndim where + the basetype is the same as for the shape attribute. This ctypes + array contains the strides information from the underlying array. + This strides information is important for showing how many bytes + must be jumped to get to the next element in the array. + """ + return self.strides_as(_getintp_ctype()) + + @property + def _as_parameter_(self): + """ + Overrides the ctypes semi-magic method + + Enables `c_func(some_array.ctypes)` + """ + return self.data_as(ctypes.c_void_p) + + # Numpy 1.21.0, 2021-05-18 + + def get_data(self): + """Deprecated getter for the `_ctypes.data` property. + + .. deprecated:: 1.21 + """ + warnings.warn('"get_data" is deprecated. Use "data" instead', + DeprecationWarning, stacklevel=2) + return self.data + + def get_shape(self): + """Deprecated getter for the `_ctypes.shape` property. + + .. deprecated:: 1.21 + """ + warnings.warn('"get_shape" is deprecated. Use "shape" instead', + DeprecationWarning, stacklevel=2) + return self.shape + + def get_strides(self): + """Deprecated getter for the `_ctypes.strides` property. + + .. deprecated:: 1.21 + """ + warnings.warn('"get_strides" is deprecated. Use "strides" instead', + DeprecationWarning, stacklevel=2) + return self.strides + + def get_as_parameter(self): + """Deprecated getter for the `_ctypes._as_parameter_` property. + + .. deprecated:: 1.21 + """ + warnings.warn( + '"get_as_parameter" is deprecated. Use "_as_parameter_" instead', + DeprecationWarning, stacklevel=2, + ) + return self._as_parameter_ + + +def _newnames(datatype, order): + """ + Given a datatype and an order object, return a new names tuple, with the + order indicated + """ + oldnames = datatype.names + nameslist = list(oldnames) + if isinstance(order, str): + order = [order] + seen = set() + if isinstance(order, (list, tuple)): + for name in order: + try: + nameslist.remove(name) + except ValueError: + if name in seen: + raise ValueError(f"duplicate field name: {name}") from None + else: + raise ValueError(f"unknown field name: {name}") from None + seen.add(name) + return tuple(list(order) + nameslist) + raise ValueError(f"unsupported order value: {order}") + +def _copy_fields(ary): + """Return copy of structured array with padding between fields removed. + + Parameters + ---------- + ary : ndarray + Structured array from which to remove padding bytes + + Returns + ------- + ary_copy : ndarray + Copy of ary with padding bytes removed + """ + dt = ary.dtype + copy_dtype = {'names': dt.names, + 'formats': [dt.fields[name][0] for name in dt.names]} + return array(ary, dtype=copy_dtype, copy=True) + +def _promote_fields(dt1, dt2): + """ Perform type promotion for two structured dtypes. + + Parameters + ---------- + dt1 : structured dtype + First dtype. + dt2 : structured dtype + Second dtype. + + Returns + ------- + out : dtype + The promoted dtype + + Notes + ----- + If one of the inputs is aligned, the result will be. The titles of + both descriptors must match (point to the same field). + """ + # Both must be structured and have the same names in the same order + if (dt1.names is None or dt2.names is None) or dt1.names != dt2.names: + raise DTypePromotionError( + f"field names `{dt1.names}` and `{dt2.names}` mismatch.") + + # if both are identical, we can (maybe!) just return the same dtype. + identical = dt1 is dt2 + new_fields = [] + for name in dt1.names: + field1 = dt1.fields[name] + field2 = dt2.fields[name] + new_descr = promote_types(field1[0], field2[0]) + identical = identical and new_descr is field1[0] + + # Check that the titles match (if given): + if field1[2:] != field2[2:]: + raise DTypePromotionError( + f"field titles of field '{name}' mismatch") + if len(field1) == 2: + new_fields.append((name, new_descr)) + else: + new_fields.append(((field1[2], name), new_descr)) + + res = dtype(new_fields, align=dt1.isalignedstruct or dt2.isalignedstruct) + + # Might as well preserve identity (and metadata) if the dtype is identical + # and the itemsize, offsets are also unmodified. This could probably be + # sped up, but also probably just be removed entirely. + if identical and res.itemsize == dt1.itemsize: + for name in dt1.names: + if dt1.fields[name][1] != res.fields[name][1]: + return res # the dtype changed. + return dt1 + + return res + + +def _getfield_is_safe(oldtype, newtype, offset): + """ Checks safety of getfield for object arrays. + + As in _view_is_safe, we need to check that memory containing objects is not + reinterpreted as a non-object datatype and vice versa. + + Parameters + ---------- + oldtype : data-type + Data type of the original ndarray. + newtype : data-type + Data type of the field being accessed by ndarray.getfield + offset : int + Offset of the field being accessed by ndarray.getfield + + Raises + ------ + TypeError + If the field access is invalid + + """ + if newtype.hasobject or oldtype.hasobject: + if offset == 0 and newtype == oldtype: + return + if oldtype.names is not None: + for name in oldtype.names: + if (oldtype.fields[name][1] == offset and + oldtype.fields[name][0] == newtype): + return + raise TypeError("Cannot get/set field of an object array") + return + +def _view_is_safe(oldtype, newtype): + """ Checks safety of a view involving object arrays, for example when + doing:: + + np.zeros(10, dtype=oldtype).view(newtype) + + Parameters + ---------- + oldtype : data-type + Data type of original ndarray + newtype : data-type + Data type of the view + + Raises + ------ + TypeError + If the new type is incompatible with the old type. + + """ + + # if the types are equivalent, there is no problem. + # for example: dtype((np.record, 'i4,i4')) == dtype((np.void, 'i4,i4')) + if oldtype == newtype: + return + + if newtype.hasobject or oldtype.hasobject: + raise TypeError("Cannot change data-type for array of references.") + return + + +# Given a string containing a PEP 3118 format specifier, +# construct a NumPy dtype + +_pep3118_native_map = { + '?': '?', + 'c': 'S1', + 'b': 'b', + 'B': 'B', + 'h': 'h', + 'H': 'H', + 'i': 'i', + 'I': 'I', + 'l': 'l', + 'L': 'L', + 'q': 'q', + 'Q': 'Q', + 'e': 'e', + 'f': 'f', + 'd': 'd', + 'g': 'g', + 'Zf': 'F', + 'Zd': 'D', + 'Zg': 'G', + 's': 'S', + 'w': 'U', + 'O': 'O', + 'x': 'V', # padding +} +_pep3118_native_typechars = ''.join(_pep3118_native_map.keys()) + +_pep3118_standard_map = { + '?': '?', + 'c': 'S1', + 'b': 'b', + 'B': 'B', + 'h': 'i2', + 'H': 'u2', + 'i': 'i4', + 'I': 'u4', + 'l': 'i4', + 'L': 'u4', + 'q': 'i8', + 'Q': 'u8', + 'e': 'f2', + 'f': 'f', + 'd': 'd', + 'Zf': 'F', + 'Zd': 'D', + 's': 'S', + 'w': 'U', + 'O': 'O', + 'x': 'V', # padding +} +_pep3118_standard_typechars = ''.join(_pep3118_standard_map.keys()) + +_pep3118_unsupported_map = { + 'u': 'UCS-2 strings', + '&': 'pointers', + 't': 'bitfields', + 'X': 'function pointers', +} + +class _Stream: + def __init__(self, s): + self.s = s + self.byteorder = '@' + + def advance(self, n): + res = self.s[:n] + self.s = self.s[n:] + return res + + def consume(self, c): + if self.s[:len(c)] == c: + self.advance(len(c)) + return True + return False + + def consume_until(self, c): + if callable(c): + i = 0 + while i < len(self.s) and not c(self.s[i]): + i = i + 1 + return self.advance(i) + else: + i = self.s.index(c) + res = self.advance(i) + self.advance(len(c)) + return res + + @property + def next(self): + return self.s[0] + + def __bool__(self): + return bool(self.s) + + +def _dtype_from_pep3118(spec): + stream = _Stream(spec) + dtype, align = __dtype_from_pep3118(stream, is_subdtype=False) + return dtype + +def __dtype_from_pep3118(stream, is_subdtype): + field_spec = dict( + names=[], + formats=[], + offsets=[], + itemsize=0 + ) + offset = 0 + common_alignment = 1 + is_padding = False + + # Parse spec + while stream: + value = None + + # End of structure, bail out to upper level + if stream.consume('}'): + break + + # Sub-arrays (1) + shape = None + if stream.consume('('): + shape = stream.consume_until(')') + shape = tuple(map(int, shape.split(','))) + + # Byte order + if stream.next in ('@', '=', '<', '>', '^', '!'): + byteorder = stream.advance(1) + if byteorder == '!': + byteorder = '>' + stream.byteorder = byteorder + + # Byte order characters also control native vs. standard type sizes + if stream.byteorder in ('@', '^'): + type_map = _pep3118_native_map + type_map_chars = _pep3118_native_typechars + else: + type_map = _pep3118_standard_map + type_map_chars = _pep3118_standard_typechars + + # Item sizes + itemsize_str = stream.consume_until(lambda c: not c.isdigit()) + if itemsize_str: + itemsize = int(itemsize_str) + else: + itemsize = 1 + + # Data types + is_padding = False + + if stream.consume('T{'): + value, align = __dtype_from_pep3118( + stream, is_subdtype=True) + elif stream.next in type_map_chars: + if stream.next == 'Z': + typechar = stream.advance(2) + else: + typechar = stream.advance(1) + + is_padding = (typechar == 'x') + dtypechar = type_map[typechar] + if dtypechar in 'USV': + dtypechar += '%d' % itemsize + itemsize = 1 + numpy_byteorder = {'@': '=', '^': '='}.get( + stream.byteorder, stream.byteorder) + value = dtype(numpy_byteorder + dtypechar) + align = value.alignment + elif stream.next in _pep3118_unsupported_map: + desc = _pep3118_unsupported_map[stream.next] + raise NotImplementedError( + "Unrepresentable PEP 3118 data type {!r} ({})" + .format(stream.next, desc)) + else: + raise ValueError( + "Unknown PEP 3118 data type specifier %r" % stream.s + ) + + # + # Native alignment may require padding + # + # Here we assume that the presence of a '@' character implicitly + # implies that the start of the array is *already* aligned. + # + extra_offset = 0 + if stream.byteorder == '@': + start_padding = (-offset) % align + intra_padding = (-value.itemsize) % align + + offset += start_padding + + if intra_padding != 0: + if itemsize > 1 or (shape is not None and _prod(shape) > 1): + # Inject internal padding to the end of the sub-item + value = _add_trailing_padding(value, intra_padding) + else: + # We can postpone the injection of internal padding, + # as the item appears at most once + extra_offset += intra_padding + + # Update common alignment + common_alignment = _lcm(align, common_alignment) + + # Convert itemsize to sub-array + if itemsize != 1: + value = dtype((value, (itemsize,))) + + # Sub-arrays (2) + if shape is not None: + value = dtype((value, shape)) + + # Field name + if stream.consume(':'): + name = stream.consume_until(':') + else: + name = None + + if not (is_padding and name is None): + if name is not None and name in field_spec['names']: + raise RuntimeError( + f"Duplicate field name '{name}' in PEP3118 format" + ) + field_spec['names'].append(name) + field_spec['formats'].append(value) + field_spec['offsets'].append(offset) + + offset += value.itemsize + offset += extra_offset + + field_spec['itemsize'] = offset + + # extra final padding for aligned types + if stream.byteorder == '@': + field_spec['itemsize'] += (-offset) % common_alignment + + # Check if this was a simple 1-item type, and unwrap it + if (field_spec['names'] == [None] + and field_spec['offsets'][0] == 0 + and field_spec['itemsize'] == field_spec['formats'][0].itemsize + and not is_subdtype): + ret = field_spec['formats'][0] + else: + _fix_names(field_spec) + ret = dtype(field_spec) + + # Finished + return ret, common_alignment + +def _fix_names(field_spec): + """ Replace names which are None with the next unused f%d name """ + names = field_spec['names'] + for i, name in enumerate(names): + if name is not None: + continue + + j = 0 + while True: + name = f'f{j}' + if name not in names: + break + j = j + 1 + names[i] = name + +def _add_trailing_padding(value, padding): + """Inject the specified number of padding bytes at the end of a dtype""" + if value.fields is None: + field_spec = dict( + names=['f0'], + formats=[value], + offsets=[0], + itemsize=value.itemsize + ) + else: + fields = value.fields + names = value.names + field_spec = dict( + names=names, + formats=[fields[name][0] for name in names], + offsets=[fields[name][1] for name in names], + itemsize=value.itemsize + ) + + field_spec['itemsize'] += padding + return dtype(field_spec) + +def _prod(a): + p = 1 + for x in a: + p *= x + return p + +def _gcd(a, b): + """Calculate the greatest common divisor of a and b""" + if not (math.isfinite(a) and math.isfinite(b)): + raise ValueError('Can only find greatest common divisor of ' + f'finite arguments, found "{a}" and "{b}"') + while b: + a, b = b, a % b + return a + +def _lcm(a, b): + return a // _gcd(a, b) * b + +def array_ufunc_errmsg_formatter(dummy, ufunc, method, *inputs, **kwargs): + """ Format the error message for when __array_ufunc__ gives up. """ + args_string = ', '.join(['{!r}'.format(arg) for arg in inputs] + + ['{}={!r}'.format(k, v) + for k, v in kwargs.items()]) + args = inputs + kwargs.get('out', ()) + types_string = ', '.join(repr(type(arg).__name__) for arg in args) + return ('operand type(s) all returned NotImplemented from ' + '__array_ufunc__({!r}, {!r}, {}): {}' + .format(ufunc, method, args_string, types_string)) + + +def array_function_errmsg_formatter(public_api, types): + """ Format the error message for when __array_ufunc__ gives up. """ + func_name = '{}.{}'.format(public_api.__module__, public_api.__name__) + return ("no implementation found for '{}' on types that implement " + '__array_function__: {}'.format(func_name, list(types))) + + +def _ufunc_doc_signature_formatter(ufunc): + """ + Builds a signature string which resembles PEP 457 + + This is used to construct the first line of the docstring + """ + + # input arguments are simple + if ufunc.nin == 1: + in_args = 'x' + else: + in_args = ', '.join(f'x{i+1}' for i in range(ufunc.nin)) + + # output arguments are both keyword or positional + if ufunc.nout == 0: + out_args = ', /, out=()' + elif ufunc.nout == 1: + out_args = ', /, out=None' + else: + out_args = '[, {positional}], / [, out={default}]'.format( + positional=', '.join( + 'out{}'.format(i+1) for i in range(ufunc.nout)), + default=repr((None,)*ufunc.nout) + ) + + # keyword only args depend on whether this is a gufunc + kwargs = ( + ", casting='same_kind'" + ", order='K'" + ", dtype=None" + ", subok=True" + ) + + # NOTE: gufuncs may or may not support the `axis` parameter + if ufunc.signature is None: + kwargs = f", where=True{kwargs}[, signature]" + else: + kwargs += "[, signature, axes, axis]" + + # join all the parts together + return '{name}({in_args}{out_args}, *{kwargs})'.format( + name=ufunc.__name__, + in_args=in_args, + out_args=out_args, + kwargs=kwargs + ) + + +def npy_ctypes_check(cls): + # determine if a class comes from ctypes, in order to work around + # a bug in the buffer protocol for those objects, bpo-10746 + try: + # ctypes class are new-style, so have an __mro__. This probably fails + # for ctypes classes with multiple inheritance. + if IS_PYPY: + # (..., _ctypes.basics._CData, Bufferable, object) + ctype_base = cls.__mro__[-3] + else: + # # (..., _ctypes._CData, object) + ctype_base = cls.__mro__[-2] + # right now, they're part of the _ctypes module + return '_ctypes' in ctype_base.__module__ + except Exception: + return False + +# used to handle the _NoValue default argument for na_object +# in the C implementation of the __reduce__ method for stringdtype +def _convert_to_stringdtype_kwargs(coerce, na_object=_NoValue): + if na_object is _NoValue: + return StringDType(coerce=coerce) + return StringDType(coerce=coerce, na_object=na_object) diff --git a/venv/lib/python3.12/site-packages/numpy/_core/_internal.pyi b/venv/lib/python3.12/site-packages/numpy/_core/_internal.pyi new file mode 100644 index 00000000..690554f6 --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/_internal.pyi @@ -0,0 +1,30 @@ +from typing import Any, TypeVar, overload, Generic +import ctypes as ct + +from numpy.typing import NDArray +from numpy.ctypeslib import c_intp + +_CastT = TypeVar("_CastT", bound=ct._CanCastTo) # Copied from `ctypes.cast` +_CT = TypeVar("_CT", bound=ct._CData) +_PT = TypeVar("_PT", bound=int) + +# TODO: Let the likes of `shape_as` and `strides_as` return `None` +# for 0D arrays once we've got shape-support + +class _ctypes(Generic[_PT]): + @overload + def __new__(cls, array: NDArray[Any], ptr: None = ...) -> _ctypes[None]: ... + @overload + def __new__(cls, array: NDArray[Any], ptr: _PT) -> _ctypes[_PT]: ... + @property + def data(self) -> _PT: ... + @property + def shape(self) -> ct.Array[c_intp]: ... + @property + def strides(self) -> ct.Array[c_intp]: ... + @property + def _as_parameter_(self) -> ct.c_void_p: ... + + def data_as(self, obj: type[_CastT]) -> _CastT: ... + def shape_as(self, obj: type[_CT]) -> ct.Array[_CT]: ... + def strides_as(self, obj: type[_CT]) -> ct.Array[_CT]: ... diff --git a/venv/lib/python3.12/site-packages/numpy/_core/_machar.py b/venv/lib/python3.12/site-packages/numpy/_core/_machar.py new file mode 100644 index 00000000..2b1812f4 --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/_machar.py @@ -0,0 +1,356 @@ +""" +Machine arithmetic - determine the parameters of the +floating-point arithmetic system + +Author: Pearu Peterson, September 2003 + +""" +__all__ = ['MachAr'] + +from .fromnumeric import any +from ._ufunc_config import errstate +from .._utils import set_module + +# Need to speed this up...especially for longdouble + +# Deprecated 2021-10-20, NumPy 1.22 +class MachAr: + """ + Diagnosing machine parameters. + + Attributes + ---------- + ibeta : int + Radix in which numbers are represented. + it : int + Number of base-`ibeta` digits in the floating point mantissa M. + machep : int + Exponent of the smallest (most negative) power of `ibeta` that, + added to 1.0, gives something different from 1.0 + eps : float + Floating-point number ``beta**machep`` (floating point precision) + negep : int + Exponent of the smallest power of `ibeta` that, subtracted + from 1.0, gives something different from 1.0. + epsneg : float + Floating-point number ``beta**negep``. + iexp : int + Number of bits in the exponent (including its sign and bias). + minexp : int + Smallest (most negative) power of `ibeta` consistent with there + being no leading zeros in the mantissa. + xmin : float + Floating-point number ``beta**minexp`` (the smallest [in + magnitude] positive floating point number with full precision). + maxexp : int + Smallest (positive) power of `ibeta` that causes overflow. + xmax : float + ``(1-epsneg) * beta**maxexp`` (the largest [in magnitude] + usable floating value). + irnd : int + In ``range(6)``, information on what kind of rounding is done + in addition, and on how underflow is handled. + ngrd : int + Number of 'guard digits' used when truncating the product + of two mantissas to fit the representation. + epsilon : float + Same as `eps`. + tiny : float + An alias for `smallest_normal`, kept for backwards compatibility. + huge : float + Same as `xmax`. + precision : float + ``- int(-log10(eps))`` + resolution : float + ``- 10**(-precision)`` + smallest_normal : float + The smallest positive floating point number with 1 as leading bit in + the mantissa following IEEE-754. Same as `xmin`. + smallest_subnormal : float + The smallest positive floating point number with 0 as leading bit in + the mantissa following IEEE-754. + + Parameters + ---------- + float_conv : function, optional + Function that converts an integer or integer array to a float + or float array. Default is `float`. + int_conv : function, optional + Function that converts a float or float array to an integer or + integer array. Default is `int`. + float_to_float : function, optional + Function that converts a float array to float. Default is `float`. + Note that this does not seem to do anything useful in the current + implementation. + float_to_str : function, optional + Function that converts a single float to a string. Default is + ``lambda v:'%24.16e' %v``. + title : str, optional + Title that is printed in the string representation of `MachAr`. + + See Also + -------- + finfo : Machine limits for floating point types. + iinfo : Machine limits for integer types. + + References + ---------- + .. [1] Press, Teukolsky, Vetterling and Flannery, + "Numerical Recipes in C++," 2nd ed, + Cambridge University Press, 2002, p. 31. + + """ + + def __init__(self, float_conv=float,int_conv=int, + float_to_float=float, + float_to_str=lambda v:'%24.16e' % v, + title='Python floating point number'): + """ + + float_conv - convert integer to float (array) + int_conv - convert float (array) to integer + float_to_float - convert float array to float + float_to_str - convert array float to str + title - description of used floating point numbers + + """ + # We ignore all errors here because we are purposely triggering + # underflow to detect the properties of the runninng arch. + with errstate(under='ignore'): + self._do_init(float_conv, int_conv, float_to_float, float_to_str, title) + + def _do_init(self, float_conv, int_conv, float_to_float, float_to_str, title): + max_iterN = 10000 + msg = "Did not converge after %d tries with %s" + one = float_conv(1) + two = one + one + zero = one - one + + # Do we really need to do this? Aren't they 2 and 2.0? + # Determine ibeta and beta + a = one + for _ in range(max_iterN): + a = a + a + temp = a + one + temp1 = temp - a + if any(temp1 - one != zero): + break + else: + raise RuntimeError(msg % (_, one.dtype)) + b = one + for _ in range(max_iterN): + b = b + b + temp = a + b + itemp = int_conv(temp-a) + if any(itemp != 0): + break + else: + raise RuntimeError(msg % (_, one.dtype)) + ibeta = itemp + beta = float_conv(ibeta) + + # Determine it and irnd + it = -1 + b = one + for _ in range(max_iterN): + it = it + 1 + b = b * beta + temp = b + one + temp1 = temp - b + if any(temp1 - one != zero): + break + else: + raise RuntimeError(msg % (_, one.dtype)) + + betah = beta / two + a = one + for _ in range(max_iterN): + a = a + a + temp = a + one + temp1 = temp - a + if any(temp1 - one != zero): + break + else: + raise RuntimeError(msg % (_, one.dtype)) + temp = a + betah + irnd = 0 + if any(temp-a != zero): + irnd = 1 + tempa = a + beta + temp = tempa + betah + if irnd == 0 and any(temp-tempa != zero): + irnd = 2 + + # Determine negep and epsneg + negep = it + 3 + betain = one / beta + a = one + for i in range(negep): + a = a * betain + b = a + for _ in range(max_iterN): + temp = one - a + if any(temp-one != zero): + break + a = a * beta + negep = negep - 1 + # Prevent infinite loop on PPC with gcc 4.0: + if negep < 0: + raise RuntimeError("could not determine machine tolerance " + "for 'negep', locals() -> %s" % (locals())) + else: + raise RuntimeError(msg % (_, one.dtype)) + negep = -negep + epsneg = a + + # Determine machep and eps + machep = - it - 3 + a = b + + for _ in range(max_iterN): + temp = one + a + if any(temp-one != zero): + break + a = a * beta + machep = machep + 1 + else: + raise RuntimeError(msg % (_, one.dtype)) + eps = a + + # Determine ngrd + ngrd = 0 + temp = one + eps + if irnd == 0 and any(temp*one - one != zero): + ngrd = 1 + + # Determine iexp + i = 0 + k = 1 + z = betain + t = one + eps + nxres = 0 + for _ in range(max_iterN): + y = z + z = y*y + a = z*one # Check here for underflow + temp = z*t + if any(a+a == zero) or any(abs(z) >= y): + break + temp1 = temp * betain + if any(temp1*beta == z): + break + i = i + 1 + k = k + k + else: + raise RuntimeError(msg % (_, one.dtype)) + if ibeta != 10: + iexp = i + 1 + mx = k + k + else: + iexp = 2 + iz = ibeta + while k >= iz: + iz = iz * ibeta + iexp = iexp + 1 + mx = iz + iz - 1 + + # Determine minexp and xmin + for _ in range(max_iterN): + xmin = y + y = y * betain + a = y * one + temp = y * t + if any((a + a) != zero) and any(abs(y) < xmin): + k = k + 1 + temp1 = temp * betain + if any(temp1*beta == y) and any(temp != y): + nxres = 3 + xmin = y + break + else: + break + else: + raise RuntimeError(msg % (_, one.dtype)) + minexp = -k + + # Determine maxexp, xmax + if mx <= k + k - 3 and ibeta != 10: + mx = mx + mx + iexp = iexp + 1 + maxexp = mx + minexp + irnd = irnd + nxres + if irnd >= 2: + maxexp = maxexp - 2 + i = maxexp + minexp + if ibeta == 2 and not i: + maxexp = maxexp - 1 + if i > 20: + maxexp = maxexp - 1 + if any(a != y): + maxexp = maxexp - 2 + xmax = one - epsneg + if any(xmax*one != xmax): + xmax = one - beta*epsneg + xmax = xmax / (xmin*beta*beta*beta) + i = maxexp + minexp + 3 + for j in range(i): + if ibeta == 2: + xmax = xmax + xmax + else: + xmax = xmax * beta + + smallest_subnormal = abs(xmin / beta ** (it)) + + self.ibeta = ibeta + self.it = it + self.negep = negep + self.epsneg = float_to_float(epsneg) + self._str_epsneg = float_to_str(epsneg) + self.machep = machep + self.eps = float_to_float(eps) + self._str_eps = float_to_str(eps) + self.ngrd = ngrd + self.iexp = iexp + self.minexp = minexp + self.xmin = float_to_float(xmin) + self._str_xmin = float_to_str(xmin) + self.maxexp = maxexp + self.xmax = float_to_float(xmax) + self._str_xmax = float_to_str(xmax) + self.irnd = irnd + + self.title = title + # Commonly used parameters + self.epsilon = self.eps + self.tiny = self.xmin + self.huge = self.xmax + self.smallest_normal = self.xmin + self._str_smallest_normal = float_to_str(self.xmin) + self.smallest_subnormal = float_to_float(smallest_subnormal) + self._str_smallest_subnormal = float_to_str(smallest_subnormal) + + import math + self.precision = int(-math.log10(float_to_float(self.eps))) + ten = two + two + two + two + two + resolution = ten ** (-self.precision) + self.resolution = float_to_float(resolution) + self._str_resolution = float_to_str(resolution) + + def __str__(self): + fmt = ( + 'Machine parameters for %(title)s\n' + '---------------------------------------------------------------------\n' + 'ibeta=%(ibeta)s it=%(it)s iexp=%(iexp)s ngrd=%(ngrd)s irnd=%(irnd)s\n' + 'machep=%(machep)s eps=%(_str_eps)s (beta**machep == epsilon)\n' + 'negep =%(negep)s epsneg=%(_str_epsneg)s (beta**epsneg)\n' + 'minexp=%(minexp)s xmin=%(_str_xmin)s (beta**minexp == tiny)\n' + 'maxexp=%(maxexp)s xmax=%(_str_xmax)s ((1-epsneg)*beta**maxexp == huge)\n' + 'smallest_normal=%(smallest_normal)s ' + 'smallest_subnormal=%(smallest_subnormal)s\n' + '---------------------------------------------------------------------\n' + ) + return fmt % self.__dict__ + + +if __name__ == '__main__': + print(MachAr()) diff --git a/venv/lib/python3.12/site-packages/numpy/_core/_methods.py b/venv/lib/python3.12/site-packages/numpy/_core/_methods.py new file mode 100644 index 00000000..388854e6 --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/_methods.py @@ -0,0 +1,260 @@ +""" +Array methods which are called by both the C-code for the method +and the Python code for the NumPy-namespace function + +""" +import os +import pickle +import warnings +from contextlib import nullcontext + +import numpy as np +from numpy._core import multiarray as mu +from numpy._core import umath as um +from numpy._core.multiarray import asanyarray +from numpy._core import numerictypes as nt +from numpy._core import _exceptions +from numpy._core._ufunc_config import _no_nep50_warning +from numpy._globals import _NoValue + +# save those O(100) nanoseconds! +bool_dt = mu.dtype("bool") +umr_maximum = um.maximum.reduce +umr_minimum = um.minimum.reduce +umr_sum = um.add.reduce +umr_prod = um.multiply.reduce +umr_bitwise_count = um.bitwise_count +umr_any = um.logical_or.reduce +umr_all = um.logical_and.reduce + +# Complex types to -> (2,)float view for fast-path computation in _var() +_complex_to_float = { + nt.dtype(nt.csingle) : nt.dtype(nt.single), + nt.dtype(nt.cdouble) : nt.dtype(nt.double), +} +# Special case for windows: ensure double takes precedence +if nt.dtype(nt.longdouble) != nt.dtype(nt.double): + _complex_to_float.update({ + nt.dtype(nt.clongdouble) : nt.dtype(nt.longdouble), + }) + +# avoid keyword arguments to speed up parsing, saves about 15%-20% for very +# small reductions +def _amax(a, axis=None, out=None, keepdims=False, + initial=_NoValue, where=True): + return umr_maximum(a, axis, None, out, keepdims, initial, where) + +def _amin(a, axis=None, out=None, keepdims=False, + initial=_NoValue, where=True): + return umr_minimum(a, axis, None, out, keepdims, initial, where) + +def _sum(a, axis=None, dtype=None, out=None, keepdims=False, + initial=_NoValue, where=True): + return umr_sum(a, axis, dtype, out, keepdims, initial, where) + +def _prod(a, axis=None, dtype=None, out=None, keepdims=False, + initial=_NoValue, where=True): + return umr_prod(a, axis, dtype, out, keepdims, initial, where) + +def _any(a, axis=None, dtype=None, out=None, keepdims=False, *, where=True): + # By default, return a boolean for any and all + if dtype is None: + dtype = bool_dt + # Parsing keyword arguments is currently fairly slow, so avoid it for now + if where is True: + return umr_any(a, axis, dtype, out, keepdims) + return umr_any(a, axis, dtype, out, keepdims, where=where) + +def _all(a, axis=None, dtype=None, out=None, keepdims=False, *, where=True): + # By default, return a boolean for any and all + if dtype is None: + dtype = bool_dt + # Parsing keyword arguments is currently fairly slow, so avoid it for now + if where is True: + return umr_all(a, axis, dtype, out, keepdims) + return umr_all(a, axis, dtype, out, keepdims, where=where) + +def _count_reduce_items(arr, axis, keepdims=False, where=True): + # fast-path for the default case + if where is True: + # no boolean mask given, calculate items according to axis + if axis is None: + axis = tuple(range(arr.ndim)) + elif not isinstance(axis, tuple): + axis = (axis,) + items = 1 + for ax in axis: + items *= arr.shape[mu.normalize_axis_index(ax, arr.ndim)] + items = nt.intp(items) + else: + # TODO: Optimize case when `where` is broadcast along a non-reduction + # axis and full sum is more excessive than needed. + + # guarded to protect circular imports + from numpy.lib._stride_tricks_impl import broadcast_to + # count True values in (potentially broadcasted) boolean mask + items = umr_sum(broadcast_to(where, arr.shape), axis, nt.intp, None, + keepdims) + return items + +def _clip(a, min=None, max=None, out=None, **kwargs): + if a.dtype.kind in "iu": + # If min/max is a Python integer, deal with out-of-bound values here. + # (This enforces NEP 50 rules as no value based promotion is done.) + if type(min) is int and min <= np.iinfo(a.dtype).min: + min = None + if type(max) is int and max >= np.iinfo(a.dtype).max: + max = None + + if min is None and max is None: + # return identity + return um.positive(a, out=out, **kwargs) + elif min is None: + return um.minimum(a, max, out=out, **kwargs) + elif max is None: + return um.maximum(a, min, out=out, **kwargs) + else: + return um.clip(a, min, max, out=out, **kwargs) + +def _mean(a, axis=None, dtype=None, out=None, keepdims=False, *, where=True): + arr = asanyarray(a) + + is_float16_result = False + + rcount = _count_reduce_items(arr, axis, keepdims=keepdims, where=where) + if rcount == 0 if where is True else umr_any(rcount == 0, axis=None): + warnings.warn("Mean of empty slice.", RuntimeWarning, stacklevel=2) + + # Cast bool, unsigned int, and int to float64 by default + if dtype is None: + if issubclass(arr.dtype.type, (nt.integer, nt.bool)): + dtype = mu.dtype('f8') + elif issubclass(arr.dtype.type, nt.float16): + dtype = mu.dtype('f4') + is_float16_result = True + + ret = umr_sum(arr, axis, dtype, out, keepdims, where=where) + if isinstance(ret, mu.ndarray): + with _no_nep50_warning(): + ret = um.true_divide( + ret, rcount, out=ret, casting='unsafe', subok=False) + if is_float16_result and out is None: + ret = arr.dtype.type(ret) + elif hasattr(ret, 'dtype'): + if is_float16_result: + ret = arr.dtype.type(ret / rcount) + else: + ret = ret.dtype.type(ret / rcount) + else: + ret = ret / rcount + + return ret + +def _var(a, axis=None, dtype=None, out=None, ddof=0, keepdims=False, *, + where=True, mean=None): + arr = asanyarray(a) + + rcount = _count_reduce_items(arr, axis, keepdims=keepdims, where=where) + # Make this warning show up on top. + if ddof >= rcount if where is True else umr_any(ddof >= rcount, axis=None): + warnings.warn("Degrees of freedom <= 0 for slice", RuntimeWarning, + stacklevel=2) + + # Cast bool, unsigned int, and int to float64 by default + if dtype is None and issubclass(arr.dtype.type, (nt.integer, nt.bool)): + dtype = mu.dtype('f8') + + if mean is not None: + arrmean = mean + else: + # Compute the mean. + # Note that if dtype is not of inexact type then arraymean will + # not be either. + arrmean = umr_sum(arr, axis, dtype, keepdims=True, where=where) + # The shape of rcount has to match arrmean to not change the shape of + # out in broadcasting. Otherwise, it cannot be stored back to arrmean. + if rcount.ndim == 0: + # fast-path for default case when where is True + div = rcount + else: + # matching rcount to arrmean when where is specified as array + div = rcount.reshape(arrmean.shape) + if isinstance(arrmean, mu.ndarray): + with _no_nep50_warning(): + arrmean = um.true_divide(arrmean, div, out=arrmean, + casting='unsafe', subok=False) + elif hasattr(arrmean, "dtype"): + arrmean = arrmean.dtype.type(arrmean / rcount) + else: + arrmean = arrmean / rcount + + # Compute sum of squared deviations from mean + # Note that x may not be inexact and that we need it to be an array, + # not a scalar. + x = asanyarray(arr - arrmean) + + if issubclass(arr.dtype.type, (nt.floating, nt.integer)): + x = um.multiply(x, x, out=x) + # Fast-paths for built-in complex types + elif x.dtype in _complex_to_float: + xv = x.view(dtype=(_complex_to_float[x.dtype], (2,))) + um.multiply(xv, xv, out=xv) + x = um.add(xv[..., 0], xv[..., 1], out=x.real).real + # Most general case; includes handling object arrays containing imaginary + # numbers and complex types with non-native byteorder + else: + x = um.multiply(x, um.conjugate(x), out=x).real + + ret = umr_sum(x, axis, dtype, out, keepdims=keepdims, where=where) + + # Compute degrees of freedom and make sure it is not negative. + rcount = um.maximum(rcount - ddof, 0) + + # divide by degrees of freedom + if isinstance(ret, mu.ndarray): + with _no_nep50_warning(): + ret = um.true_divide( + ret, rcount, out=ret, casting='unsafe', subok=False) + elif hasattr(ret, 'dtype'): + ret = ret.dtype.type(ret / rcount) + else: + ret = ret / rcount + + return ret + +def _std(a, axis=None, dtype=None, out=None, ddof=0, keepdims=False, *, + where=True, mean=None): + ret = _var(a, axis=axis, dtype=dtype, out=out, ddof=ddof, + keepdims=keepdims, where=where, mean=mean) + + if isinstance(ret, mu.ndarray): + ret = um.sqrt(ret, out=ret) + elif hasattr(ret, 'dtype'): + ret = ret.dtype.type(um.sqrt(ret)) + else: + ret = um.sqrt(ret) + + return ret + +def _ptp(a, axis=None, out=None, keepdims=False): + return um.subtract( + umr_maximum(a, axis, None, out, keepdims), + umr_minimum(a, axis, None, None, keepdims), + out + ) + +def _dump(self, file, protocol=2): + if hasattr(file, 'write'): + ctx = nullcontext(file) + else: + ctx = open(os.fspath(file), "wb") + with ctx as f: + pickle.dump(self, f, protocol=protocol) + +def _dumps(self, protocol=2): + return pickle.dumps(self, protocol=protocol) + +def _bitwise_count(a, out=None, *, where=True, casting='same_kind', + order='K', dtype=None, subok=True): + return umr_bitwise_count(a, out, where=where, casting=casting, + order=order, dtype=dtype, subok=subok) diff --git a/venv/lib/python3.12/site-packages/numpy/_core/_multiarray_tests.cpython-312-darwin.so b/venv/lib/python3.12/site-packages/numpy/_core/_multiarray_tests.cpython-312-darwin.so new file mode 100755 index 00000000..348a1cad Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/_core/_multiarray_tests.cpython-312-darwin.so differ diff --git a/venv/lib/python3.12/site-packages/numpy/_core/_multiarray_umath.cpython-312-darwin.so b/venv/lib/python3.12/site-packages/numpy/_core/_multiarray_umath.cpython-312-darwin.so new file mode 100755 index 00000000..5bc4d085 Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/_core/_multiarray_umath.cpython-312-darwin.so differ diff --git a/venv/lib/python3.12/site-packages/numpy/_core/_operand_flag_tests.cpython-312-darwin.so b/venv/lib/python3.12/site-packages/numpy/_core/_operand_flag_tests.cpython-312-darwin.so new file mode 100755 index 00000000..14f60197 Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/_core/_operand_flag_tests.cpython-312-darwin.so differ diff --git a/venv/lib/python3.12/site-packages/numpy/_core/_rational_tests.cpython-312-darwin.so b/venv/lib/python3.12/site-packages/numpy/_core/_rational_tests.cpython-312-darwin.so new file mode 100755 index 00000000..1cf0a1f2 Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/_core/_rational_tests.cpython-312-darwin.so differ diff --git a/venv/lib/python3.12/site-packages/numpy/_core/_simd.cpython-312-darwin.so b/venv/lib/python3.12/site-packages/numpy/_core/_simd.cpython-312-darwin.so new file mode 100755 index 00000000..210be0ef Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/_core/_simd.cpython-312-darwin.so differ diff --git a/venv/lib/python3.12/site-packages/numpy/_core/_string_helpers.py b/venv/lib/python3.12/site-packages/numpy/_core/_string_helpers.py new file mode 100644 index 00000000..8a64ab5a --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/_string_helpers.py @@ -0,0 +1,100 @@ +""" +String-handling utilities to avoid locale-dependence. + +Used primarily to generate type name aliases. +""" +# "import string" is costly to import! +# Construct the translation tables directly +# "A" = chr(65), "a" = chr(97) +_all_chars = tuple(map(chr, range(256))) +_ascii_upper = _all_chars[65:65+26] +_ascii_lower = _all_chars[97:97+26] +LOWER_TABLE = _all_chars[:65] + _ascii_lower + _all_chars[65+26:] +UPPER_TABLE = _all_chars[:97] + _ascii_upper + _all_chars[97+26:] + + +def english_lower(s): + """ Apply English case rules to convert ASCII strings to all lower case. + + This is an internal utility function to replace calls to str.lower() such + that we can avoid changing behavior with changing locales. In particular, + Turkish has distinct dotted and dotless variants of the Latin letter "I" in + both lowercase and uppercase. Thus, "I".lower() != "i" in a "tr" locale. + + Parameters + ---------- + s : str + + Returns + ------- + lowered : str + + Examples + -------- + >>> from numpy._core.numerictypes import english_lower + >>> english_lower('ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_') + 'abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz0123456789_' + >>> english_lower('') + '' + """ + lowered = s.translate(LOWER_TABLE) + return lowered + + +def english_upper(s): + """ Apply English case rules to convert ASCII strings to all upper case. + + This is an internal utility function to replace calls to str.upper() such + that we can avoid changing behavior with changing locales. In particular, + Turkish has distinct dotted and dotless variants of the Latin letter "I" in + both lowercase and uppercase. Thus, "i".upper() != "I" in a "tr" locale. + + Parameters + ---------- + s : str + + Returns + ------- + uppered : str + + Examples + -------- + >>> from numpy._core.numerictypes import english_upper + >>> english_upper('ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_') + 'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_' + >>> english_upper('') + '' + """ + uppered = s.translate(UPPER_TABLE) + return uppered + + +def english_capitalize(s): + """ Apply English case rules to convert the first character of an ASCII + string to upper case. + + This is an internal utility function to replace calls to str.capitalize() + such that we can avoid changing behavior with changing locales. + + Parameters + ---------- + s : str + + Returns + ------- + capitalized : str + + Examples + -------- + >>> from numpy._core.numerictypes import english_capitalize + >>> english_capitalize('int8') + 'Int8' + >>> english_capitalize('Int8') + 'Int8' + >>> english_capitalize('') + '' + """ + if s: + return english_upper(s[0]) + s[1:] + else: + return s diff --git a/venv/lib/python3.12/site-packages/numpy/_core/_struct_ufunc_tests.cpython-312-darwin.so b/venv/lib/python3.12/site-packages/numpy/_core/_struct_ufunc_tests.cpython-312-darwin.so new file mode 100755 index 00000000..24298fd3 Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/_core/_struct_ufunc_tests.cpython-312-darwin.so differ diff --git a/venv/lib/python3.12/site-packages/numpy/_core/_type_aliases.py b/venv/lib/python3.12/site-packages/numpy/_core/_type_aliases.py new file mode 100644 index 00000000..80a59e7b --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/_type_aliases.py @@ -0,0 +1,119 @@ +""" +Due to compatibility, numpy has a very large number of different naming +conventions for the scalar types (those subclassing from `numpy.generic`). +This file produces a convoluted set of dictionaries mapping names to types, +and sometimes other mappings too. + +.. data:: allTypes + A dictionary of names to types that will be exposed as attributes through + ``np._core.numerictypes.*`` + +.. data:: sctypeDict + Similar to `allTypes`, but maps a broader set of aliases to their types. + +.. data:: sctypes + A dictionary keyed by a "type group" string, providing a list of types + under that group. + +""" + +import numpy._core.multiarray as ma +from numpy._core.multiarray import typeinfo, dtype + +###################################### +# Building `sctypeDict` and `allTypes` +###################################### + +sctypeDict = {} +allTypes = {} +c_names_dict = {} + +_abstract_type_names = { + "generic", "integer", "inexact", "floating", "number", + "flexible", "character", "complexfloating", "unsignedinteger", + "signedinteger" +} + +for _abstract_type_name in _abstract_type_names: + allTypes[_abstract_type_name] = getattr(ma, _abstract_type_name) + +for k, v in typeinfo.items(): + if k.startswith("NPY_") and v not in c_names_dict: + c_names_dict[k[4:]] = v + else: + concrete_type = v.type + allTypes[k] = concrete_type + sctypeDict[k] = concrete_type + +_aliases = { + "double": "float64", + "cdouble": "complex128", + "single": "float32", + "csingle": "complex64", + "half": "float16", + "bool_": "bool", + # Default integer: + "int_": "intp", + "uint": "uintp", +} + +for k, v in _aliases.items(): + sctypeDict[k] = allTypes[v] + allTypes[k] = allTypes[v] + +# extra aliases are added only to `sctypeDict` +# to support dtype name access, such as`np.dtype("float")` +_extra_aliases = { + "float": "float64", + "complex": "complex128", + "object": "object_", + "bytes": "bytes_", + "a": "bytes_", + "int": "int_", + "str": "str_", + "unicode": "str_", +} + +for k, v in _extra_aliases.items(): + sctypeDict[k] = allTypes[v] + +# include extended precision sized aliases +for is_complex, full_name in [(False, "longdouble"), (True, "clongdouble")]: + longdouble_type: type = allTypes[full_name] + + bits: int = dtype(longdouble_type).itemsize * 8 + base_name: str = "complex" if is_complex else "float" + extended_prec_name: str = f"{base_name}{bits}" + if extended_prec_name not in allTypes: + sctypeDict[extended_prec_name] = longdouble_type + allTypes[extended_prec_name] = longdouble_type + + +#################### +# Building `sctypes` +#################### + +sctypes = {"int": set(), "uint": set(), "float": set(), + "complex": set(), "others": set()} + +for type_info in typeinfo.values(): + if type_info.kind in ["M", "m"]: # exclude timedelta and datetime + continue + + concrete_type = type_info.type + + # find proper group for each concrete type + for type_group, abstract_type in [ + ("int", ma.signedinteger), ("uint", ma.unsignedinteger), + ("float", ma.floating), ("complex", ma.complexfloating), + ("others", ma.generic) + ]: + if issubclass(concrete_type, abstract_type): + sctypes[type_group].add(concrete_type) + break + +# sort sctype groups by bitsize +for sctype_key in sctypes.keys(): + sctype_list = list(sctypes[sctype_key]) + sctype_list.sort(key=lambda x: dtype(x).itemsize) + sctypes[sctype_key] = sctype_list diff --git a/venv/lib/python3.12/site-packages/numpy/_core/_type_aliases.pyi b/venv/lib/python3.12/site-packages/numpy/_core/_type_aliases.pyi new file mode 100644 index 00000000..1adaa933 --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/_type_aliases.pyi @@ -0,0 +1,3 @@ +from numpy import generic + +sctypeDict: dict[int | str, type[generic]] diff --git a/venv/lib/python3.12/site-packages/numpy/_core/_ufunc_config.py b/venv/lib/python3.12/site-packages/numpy/_core/_ufunc_config.py new file mode 100644 index 00000000..d60e7cbb --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/_ufunc_config.py @@ -0,0 +1,503 @@ +""" +Functions for changing global ufunc configuration + +This provides helpers which wrap `_get_extobj_dict` and `_make_extobj`, and +`_extobj_contextvar` from umath. +""" +import collections.abc +import contextlib +import contextvars +import functools + +from .._utils import set_module +from .umath import _make_extobj, _get_extobj_dict, _extobj_contextvar + +__all__ = [ + "seterr", "geterr", "setbufsize", "getbufsize", "seterrcall", "geterrcall", + "errstate", '_no_nep50_warning' +] + + +@set_module('numpy') +def seterr(all=None, divide=None, over=None, under=None, invalid=None): + """ + Set how floating-point errors are handled. + + Note that operations on integer scalar types (such as `int16`) are + handled like floating point, and are affected by these settings. + + Parameters + ---------- + all : {'ignore', 'warn', 'raise', 'call', 'print', 'log'}, optional + Set treatment for all types of floating-point errors at once: + + - ignore: Take no action when the exception occurs. + - warn: Print a :exc:`RuntimeWarning` (via the Python `warnings` + module). + - raise: Raise a :exc:`FloatingPointError`. + - call: Call a function specified using the `seterrcall` function. + - print: Print a warning directly to ``stdout``. + - log: Record error in a Log object specified by `seterrcall`. + + The default is not to change the current behavior. + divide : {'ignore', 'warn', 'raise', 'call', 'print', 'log'}, optional + Treatment for division by zero. + over : {'ignore', 'warn', 'raise', 'call', 'print', 'log'}, optional + Treatment for floating-point overflow. + under : {'ignore', 'warn', 'raise', 'call', 'print', 'log'}, optional + Treatment for floating-point underflow. + invalid : {'ignore', 'warn', 'raise', 'call', 'print', 'log'}, optional + Treatment for invalid floating-point operation. + + Returns + ------- + old_settings : dict + Dictionary containing the old settings. + + See also + -------- + seterrcall : Set a callback function for the 'call' mode. + geterr, geterrcall, errstate + + Notes + ----- + The floating-point exceptions are defined in the IEEE 754 standard [1]_: + + - Division by zero: infinite result obtained from finite numbers. + - Overflow: result too large to be expressed. + - Underflow: result so close to zero that some precision + was lost. + - Invalid operation: result is not an expressible number, typically + indicates that a NaN was produced. + + .. [1] https://en.wikipedia.org/wiki/IEEE_754 + + Examples + -------- + >>> import numpy as np + >>> orig_settings = np.seterr(all='ignore') # seterr to known value + >>> np.int16(32000) * np.int16(3) + 30464 + >>> np.seterr(over='raise') + {'divide': 'ignore', 'over': 'ignore', 'under': 'ignore', 'invalid': 'ignore'} + >>> old_settings = np.seterr(all='warn', over='raise') + >>> np.int16(32000) * np.int16(3) + Traceback (most recent call last): + File "", line 1, in + FloatingPointError: overflow encountered in scalar multiply + + >>> old_settings = np.seterr(all='print') + >>> np.geterr() + {'divide': 'print', 'over': 'print', 'under': 'print', 'invalid': 'print'} + >>> np.int16(32000) * np.int16(3) + 30464 + >>> np.seterr(**orig_settings) # restore original + {'divide': 'print', 'over': 'print', 'under': 'print', 'invalid': 'print'} + + """ + + old = _get_extobj_dict() + # The errstate doesn't include call and bufsize, so pop them: + old.pop("call", None) + old.pop("bufsize", None) + + extobj = _make_extobj( + all=all, divide=divide, over=over, under=under, invalid=invalid) + _extobj_contextvar.set(extobj) + return old + + +@set_module('numpy') +def geterr(): + """ + Get the current way of handling floating-point errors. + + Returns + ------- + res : dict + A dictionary with keys "divide", "over", "under", and "invalid", + whose values are from the strings "ignore", "print", "log", "warn", + "raise", and "call". The keys represent possible floating-point + exceptions, and the values define how these exceptions are handled. + + See Also + -------- + geterrcall, seterr, seterrcall + + Notes + ----- + For complete documentation of the types of floating-point exceptions and + treatment options, see `seterr`. + + Examples + -------- + >>> import numpy as np + >>> np.geterr() + {'divide': 'warn', 'over': 'warn', 'under': 'ignore', 'invalid': 'warn'} + >>> np.arange(3.) / np.arange(3.) # doctest: +SKIP + array([nan, 1., 1.]) + RuntimeWarning: invalid value encountered in divide + + >>> oldsettings = np.seterr(all='warn', invalid='raise') + >>> np.geterr() + {'divide': 'warn', 'over': 'warn', 'under': 'warn', 'invalid': 'raise'} + >>> np.arange(3.) / np.arange(3.) + Traceback (most recent call last): + ... + FloatingPointError: invalid value encountered in divide + >>> oldsettings = np.seterr(**oldsettings) # restore original + + """ + res = _get_extobj_dict() + # The "geterr" doesn't include call and bufsize,: + res.pop("call", None) + res.pop("bufsize", None) + return res + + +@set_module('numpy') +def setbufsize(size): + """ + Set the size of the buffer used in ufuncs. + + .. versionchanged:: 2.0 + The scope of setting the buffer is tied to the `numpy.errstate` + context. Exiting a ``with errstate():`` will also restore the bufsize. + + Parameters + ---------- + size : int + Size of buffer. + + Returns + ------- + bufsize : int + Previous size of ufunc buffer in bytes. + + Examples + -------- + When exiting a `numpy.errstate` context manager the bufsize is restored: + + >>> import numpy as np + >>> with np.errstate(): + ... np.setbufsize(4096) + ... print(np.getbufsize()) + ... + 8192 + 4096 + >>> np.getbufsize() + 8192 + + """ + old = _get_extobj_dict()["bufsize"] + extobj = _make_extobj(bufsize=size) + _extobj_contextvar.set(extobj) + return old + + +@set_module('numpy') +def getbufsize(): + """ + Return the size of the buffer used in ufuncs. + + Returns + ------- + getbufsize : int + Size of ufunc buffer in bytes. + + Examples + -------- + >>> import numpy as np + >>> np.getbufsize() + 8192 + + """ + return _get_extobj_dict()["bufsize"] + + +@set_module('numpy') +def seterrcall(func): + """ + Set the floating-point error callback function or log object. + + There are two ways to capture floating-point error messages. The first + is to set the error-handler to 'call', using `seterr`. Then, set + the function to call using this function. + + The second is to set the error-handler to 'log', using `seterr`. + Floating-point errors then trigger a call to the 'write' method of + the provided object. + + Parameters + ---------- + func : callable f(err, flag) or object with write method + Function to call upon floating-point errors ('call'-mode) or + object whose 'write' method is used to log such message ('log'-mode). + + The call function takes two arguments. The first is a string describing + the type of error (such as "divide by zero", "overflow", "underflow", + or "invalid value"), and the second is the status flag. The flag is a + byte, whose four least-significant bits indicate the type of error, one + of "divide", "over", "under", "invalid":: + + [0 0 0 0 divide over under invalid] + + In other words, ``flags = divide + 2*over + 4*under + 8*invalid``. + + If an object is provided, its write method should take one argument, + a string. + + Returns + ------- + h : callable, log instance or None + The old error handler. + + See Also + -------- + seterr, geterr, geterrcall + + Examples + -------- + Callback upon error: + + >>> def err_handler(type, flag): + ... print("Floating point error (%s), with flag %s" % (type, flag)) + ... + + >>> import numpy as np + + >>> orig_handler = np.seterrcall(err_handler) + >>> orig_err = np.seterr(all='call') + + >>> np.array([1, 2, 3]) / 0.0 + Floating point error (divide by zero), with flag 1 + array([inf, inf, inf]) + + >>> np.seterrcall(orig_handler) + + >>> np.seterr(**orig_err) + {'divide': 'call', 'over': 'call', 'under': 'call', 'invalid': 'call'} + + Log error message: + + >>> class Log: + ... def write(self, msg): + ... print("LOG: %s" % msg) + ... + + >>> log = Log() + >>> saved_handler = np.seterrcall(log) + >>> save_err = np.seterr(all='log') + + >>> np.array([1, 2, 3]) / 0.0 + LOG: Warning: divide by zero encountered in divide + array([inf, inf, inf]) + + >>> np.seterrcall(orig_handler) + + >>> np.seterr(**orig_err) + {'divide': 'log', 'over': 'log', 'under': 'log', 'invalid': 'log'} + + """ + old = _get_extobj_dict()["call"] + extobj = _make_extobj(call=func) + _extobj_contextvar.set(extobj) + return old + + +@set_module('numpy') +def geterrcall(): + """ + Return the current callback function used on floating-point errors. + + When the error handling for a floating-point error (one of "divide", + "over", "under", or "invalid") is set to 'call' or 'log', the function + that is called or the log instance that is written to is returned by + `geterrcall`. This function or log instance has been set with + `seterrcall`. + + Returns + ------- + errobj : callable, log instance or None + The current error handler. If no handler was set through `seterrcall`, + ``None`` is returned. + + See Also + -------- + seterrcall, seterr, geterr + + Notes + ----- + For complete documentation of the types of floating-point exceptions and + treatment options, see `seterr`. + + Examples + -------- + >>> import numpy as np + >>> np.geterrcall() # we did not yet set a handler, returns None + + >>> orig_settings = np.seterr(all='call') + >>> def err_handler(type, flag): + ... print("Floating point error (%s), with flag %s" % (type, flag)) + >>> old_handler = np.seterrcall(err_handler) + >>> np.array([1, 2, 3]) / 0.0 + Floating point error (divide by zero), with flag 1 + array([inf, inf, inf]) + + >>> cur_handler = np.geterrcall() + >>> cur_handler is err_handler + True + >>> old_settings = np.seterr(**orig_settings) # restore original + >>> old_handler = np.seterrcall(None) # restore original + + """ + return _get_extobj_dict()["call"] + + +class _unspecified: + pass + + +_Unspecified = _unspecified() + + +@set_module('numpy') +class errstate: + """ + errstate(**kwargs) + + Context manager for floating-point error handling. + + Using an instance of `errstate` as a context manager allows statements in + that context to execute with a known error handling behavior. Upon entering + the context the error handling is set with `seterr` and `seterrcall`, and + upon exiting it is reset to what it was before. + + .. versionchanged:: 1.17.0 + `errstate` is also usable as a function decorator, saving + a level of indentation if an entire function is wrapped. + + .. versionchanged:: 2.0 + `errstate` is now fully thread and asyncio safe, but may not be + entered more than once. + It is not safe to decorate async functions using ``errstate``. + + Parameters + ---------- + kwargs : {divide, over, under, invalid} + Keyword arguments. The valid keywords are the possible floating-point + exceptions. Each keyword should have a string value that defines the + treatment for the particular error. Possible values are + {'ignore', 'warn', 'raise', 'call', 'print', 'log'}. + + See Also + -------- + seterr, geterr, seterrcall, geterrcall + + Notes + ----- + For complete documentation of the types of floating-point exceptions and + treatment options, see `seterr`. + + Examples + -------- + >>> import numpy as np + >>> olderr = np.seterr(all='ignore') # Set error handling to known state. + + >>> np.arange(3) / 0. + array([nan, inf, inf]) + >>> with np.errstate(divide='ignore'): + ... np.arange(3) / 0. + array([nan, inf, inf]) + + >>> np.sqrt(-1) + np.float64(nan) + >>> with np.errstate(invalid='raise'): + ... np.sqrt(-1) + Traceback (most recent call last): + File "", line 2, in + FloatingPointError: invalid value encountered in sqrt + + Outside the context the error handling behavior has not changed: + + >>> np.geterr() + {'divide': 'ignore', 'over': 'ignore', 'under': 'ignore', 'invalid': 'ignore'} + >>> olderr = np.seterr(**olderr) # restore original state + + """ + __slots__ = ( + "_call", "_all", "_divide", "_over", "_under", "_invalid", "_token") + + def __init__(self, *, call=_Unspecified, + all=None, divide=None, over=None, under=None, invalid=None): + self._token = None + self._call = call + self._all = all + self._divide = divide + self._over = over + self._under = under + self._invalid = invalid + + def __enter__(self): + # Note that __call__ duplicates much of this logic + if self._token is not None: + raise TypeError("Cannot enter `np.errstate` twice.") + if self._call is _Unspecified: + extobj = _make_extobj( + all=self._all, divide=self._divide, over=self._over, + under=self._under, invalid=self._invalid) + else: + extobj = _make_extobj( + call=self._call, + all=self._all, divide=self._divide, over=self._over, + under=self._under, invalid=self._invalid) + + self._token = _extobj_contextvar.set(extobj) + + def __exit__(self, *exc_info): + _extobj_contextvar.reset(self._token) + + def __call__(self, func): + # We need to customize `__call__` compared to `ContextDecorator` + # because we must store the token per-thread so cannot store it on + # the instance (we could create a new instance for this). + # This duplicates the code from `__enter__`. + @functools.wraps(func) + def inner(*args, **kwargs): + if self._call is _Unspecified: + extobj = _make_extobj( + all=self._all, divide=self._divide, over=self._over, + under=self._under, invalid=self._invalid) + else: + extobj = _make_extobj( + call=self._call, + all=self._all, divide=self._divide, over=self._over, + under=self._under, invalid=self._invalid) + + _token = _extobj_contextvar.set(extobj) + try: + # Call the original, decorated, function: + return func(*args, **kwargs) + finally: + _extobj_contextvar.reset(_token) + + return inner + + +NO_NEP50_WARNING = contextvars.ContextVar("_no_nep50_warning", default=False) + +@set_module('numpy') +@contextlib.contextmanager +def _no_nep50_warning(): + """ + Context manager to disable NEP 50 warnings. This context manager is + only relevant if the NEP 50 warnings are enabled globally (which is not + thread/context safe). + + This warning context manager itself is fully safe, however. + """ + token = NO_NEP50_WARNING.set(True) + try: + yield + finally: + NO_NEP50_WARNING.reset(token) diff --git a/venv/lib/python3.12/site-packages/numpy/_core/_ufunc_config.pyi b/venv/lib/python3.12/site-packages/numpy/_core/_ufunc_config.pyi new file mode 100644 index 00000000..f5650450 --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/_ufunc_config.pyi @@ -0,0 +1,37 @@ +from collections.abc import Callable +from typing import Any, Literal, TypedDict + +from numpy import _SupportsWrite + +_ErrKind = Literal["ignore", "warn", "raise", "call", "print", "log"] +_ErrFunc = Callable[[str, int], Any] + +class _ErrDict(TypedDict): + divide: _ErrKind + over: _ErrKind + under: _ErrKind + invalid: _ErrKind + +class _ErrDictOptional(TypedDict, total=False): + all: None | _ErrKind + divide: None | _ErrKind + over: None | _ErrKind + under: None | _ErrKind + invalid: None | _ErrKind + +def seterr( + all: None | _ErrKind = ..., + divide: None | _ErrKind = ..., + over: None | _ErrKind = ..., + under: None | _ErrKind = ..., + invalid: None | _ErrKind = ..., +) -> _ErrDict: ... +def geterr() -> _ErrDict: ... +def setbufsize(size: int) -> int: ... +def getbufsize() -> int: ... +def seterrcall( + func: None | _ErrFunc | _SupportsWrite[str] +) -> None | _ErrFunc | _SupportsWrite[str]: ... +def geterrcall() -> None | _ErrFunc | _SupportsWrite[str]: ... + +# See `numpy/__init__.pyi` for the `errstate` class and `no_nep5_warnings` diff --git a/venv/lib/python3.12/site-packages/numpy/_core/_umath_tests.cpython-312-darwin.so b/venv/lib/python3.12/site-packages/numpy/_core/_umath_tests.cpython-312-darwin.so new file mode 100755 index 00000000..f5b746ef Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/_core/_umath_tests.cpython-312-darwin.so differ diff --git a/venv/lib/python3.12/site-packages/numpy/_core/arrayprint.py b/venv/lib/python3.12/site-packages/numpy/_core/arrayprint.py new file mode 100644 index 00000000..fde0d7d4 --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/arrayprint.py @@ -0,0 +1,1746 @@ +"""Array printing function + +$Id: arrayprint.py,v 1.9 2005/09/13 13:58:44 teoliphant Exp $ + +""" +__all__ = ["array2string", "array_str", "array_repr", + "set_printoptions", "get_printoptions", "printoptions", + "format_float_positional", "format_float_scientific"] +__docformat__ = 'restructuredtext' + +# +# Written by Konrad Hinsen +# last revision: 1996-3-13 +# modified by Jim Hugunin 1997-3-3 for repr's and str's (and other details) +# and by Perry Greenfield 2000-4-1 for numarray +# and by Travis Oliphant 2005-8-22 for numpy + + +# Note: Both scalartypes.c.src and arrayprint.py implement strs for numpy +# scalars but for different purposes. scalartypes.c.src has str/reprs for when +# the scalar is printed on its own, while arrayprint.py has strs for when +# scalars are printed inside an ndarray. Only the latter strs are currently +# user-customizable. + +import functools +import numbers +import sys +try: + from _thread import get_ident +except ImportError: + from _dummy_thread import get_ident + +import numpy as np +from . import numerictypes as _nt +from .umath import absolute, isinf, isfinite, isnat +from . import multiarray +from .multiarray import (array, dragon4_positional, dragon4_scientific, + datetime_as_string, datetime_data, ndarray) +from .fromnumeric import any +from .numeric import concatenate, asarray, errstate +from .numerictypes import (longlong, intc, int_, float64, complex128, + flexible) +from .overrides import array_function_dispatch, set_module +from .printoptions import format_options +import operator +import warnings +import contextlib + + +def _make_options_dict(precision=None, threshold=None, edgeitems=None, + linewidth=None, suppress=None, nanstr=None, infstr=None, + sign=None, formatter=None, floatmode=None, legacy=None, + override_repr=None): + """ + Make a dictionary out of the non-None arguments, plus conversion of + *legacy* and sanity checks. + """ + + options = {k: v for k, v in list(locals().items()) if v is not None} + + if suppress is not None: + options['suppress'] = bool(suppress) + + modes = ['fixed', 'unique', 'maxprec', 'maxprec_equal'] + if floatmode not in modes + [None]: + raise ValueError("floatmode option must be one of " + + ", ".join('"{}"'.format(m) for m in modes)) + + if sign not in [None, '-', '+', ' ']: + raise ValueError("sign option must be one of ' ', '+', or '-'") + + if legacy == False: + options['legacy'] = sys.maxsize + elif legacy == '1.13': + options['legacy'] = 113 + elif legacy == '1.21': + options['legacy'] = 121 + elif legacy == '1.25': + options['legacy'] = 125 + elif legacy is None: + pass # OK, do nothing. + else: + warnings.warn( + "legacy printing option can currently only be '1.13', '1.21', " + "'1.25', or `False`", stacklevel=3) + + if threshold is not None: + # forbid the bad threshold arg suggested by stack overflow, gh-12351 + if not isinstance(threshold, numbers.Number): + raise TypeError("threshold must be numeric") + if np.isnan(threshold): + raise ValueError("threshold must be non-NAN, try " + "sys.maxsize for untruncated representation") + + if precision is not None: + # forbid the bad precision arg as suggested by issue #18254 + try: + options['precision'] = operator.index(precision) + except TypeError as e: + raise TypeError('precision must be an integer') from e + + return options + + +@set_module('numpy') +def set_printoptions(precision=None, threshold=None, edgeitems=None, + linewidth=None, suppress=None, nanstr=None, + infstr=None, formatter=None, sign=None, floatmode=None, + *, legacy=None, override_repr=None): + """ + Set printing options. + + These options determine the way floating point numbers, arrays and + other NumPy objects are displayed. + + Parameters + ---------- + precision : int or None, optional + Number of digits of precision for floating point output (default 8). + May be None if `floatmode` is not `fixed`, to print as many digits as + necessary to uniquely specify the value. + threshold : int, optional + Total number of array elements which trigger summarization + rather than full repr (default 1000). + To always use the full repr without summarization, pass `sys.maxsize`. + edgeitems : int, optional + Number of array items in summary at beginning and end of + each dimension (default 3). + linewidth : int, optional + The number of characters per line for the purpose of inserting + line breaks (default 75). + suppress : bool, optional + If True, always print floating point numbers using fixed point + notation, in which case numbers equal to zero in the current precision + will print as zero. If False, then scientific notation is used when + absolute value of the smallest number is < 1e-4 or the ratio of the + maximum absolute value to the minimum is > 1e3. The default is False. + nanstr : str, optional + String representation of floating point not-a-number (default nan). + infstr : str, optional + String representation of floating point infinity (default inf). + sign : string, either '-', '+', or ' ', optional + Controls printing of the sign of floating-point types. If '+', always + print the sign of positive values. If ' ', always prints a space + (whitespace character) in the sign position of positive values. If + '-', omit the sign character of positive values. (default '-') + + .. versionchanged:: 2.0 + The sign parameter can now be an integer type, previously + types were floating-point types. + + formatter : dict of callables, optional + If not None, the keys should indicate the type(s) that the respective + formatting function applies to. Callables should return a string. + Types that are not specified (by their corresponding keys) are handled + by the default formatters. Individual types for which a formatter + can be set are: + + - 'bool' + - 'int' + - 'timedelta' : a `numpy.timedelta64` + - 'datetime' : a `numpy.datetime64` + - 'float' + - 'longfloat' : 128-bit floats + - 'complexfloat' + - 'longcomplexfloat' : composed of two 128-bit floats + - 'numpystr' : types `numpy.bytes_` and `numpy.str_` + - 'object' : `np.object_` arrays + + Other keys that can be used to set a group of types at once are: + + - 'all' : sets all types + - 'int_kind' : sets 'int' + - 'float_kind' : sets 'float' and 'longfloat' + - 'complex_kind' : sets 'complexfloat' and 'longcomplexfloat' + - 'str_kind' : sets 'numpystr' + floatmode : str, optional + Controls the interpretation of the `precision` option for + floating-point types. Can take the following values + (default maxprec_equal): + + * 'fixed': Always print exactly `precision` fractional digits, + even if this would print more or fewer digits than + necessary to specify the value uniquely. + * 'unique': Print the minimum number of fractional digits necessary + to represent each value uniquely. Different elements may + have a different number of digits. The value of the + `precision` option is ignored. + * 'maxprec': Print at most `precision` fractional digits, but if + an element can be uniquely represented with fewer digits + only print it with that many. + * 'maxprec_equal': Print at most `precision` fractional digits, + but if every element in the array can be uniquely + represented with an equal number of fewer digits, use that + many digits for all elements. + legacy : string or `False`, optional + If set to the string ``'1.13'`` enables 1.13 legacy printing mode. This + approximates numpy 1.13 print output by including a space in the sign + position of floats and different behavior for 0d arrays. This also + enables 1.21 legacy printing mode (described below). + + If set to the string ``'1.21'`` enables 1.21 legacy printing mode. This + approximates numpy 1.21 print output of complex structured dtypes + by not inserting spaces after commas that separate fields and after + colons. + + If set to ``'1.25'`` approximates printing of 1.25 which mainly means + that numeric scalars are printed without their type information, e.g. + as ``3.0`` rather than ``np.float64(3.0)``. + + If set to `False`, disables legacy mode. + + Unrecognized strings will be ignored with a warning for forward + compatibility. + + .. versionadded:: 1.14.0 + .. versionchanged:: 1.22.0 + .. versionchanged:: 2.0 + + override_repr: callable, optional + If set a passed function will be used for generating arrays' repr. + Other options will be ignored. + + See Also + -------- + get_printoptions, printoptions, array2string + + Notes + ----- + `formatter` is always reset with a call to `set_printoptions`. + + Use `printoptions` as a context manager to set the values temporarily. + + Examples + -------- + Floating point precision can be set: + + >>> import numpy as np + >>> np.set_printoptions(precision=4) + >>> np.array([1.123456789]) + [1.1235] + + Long arrays can be summarised: + + >>> np.set_printoptions(threshold=5) + >>> np.arange(10) + array([0, 1, 2, ..., 7, 8, 9]) + + Small results can be suppressed: + + >>> eps = np.finfo(float).eps + >>> x = np.arange(4.) + >>> x**2 - (x + eps)**2 + array([-4.9304e-32, -4.4409e-16, 0.0000e+00, 0.0000e+00]) + >>> np.set_printoptions(suppress=True) + >>> x**2 - (x + eps)**2 + array([-0., -0., 0., 0.]) + + A custom formatter can be used to display array elements as desired: + + >>> np.set_printoptions(formatter={'all':lambda x: 'int: '+str(-x)}) + >>> x = np.arange(3) + >>> x + array([int: 0, int: -1, int: -2]) + >>> np.set_printoptions() # formatter gets reset + >>> x + array([0, 1, 2]) + + To put back the default options, you can use: + + >>> np.set_printoptions(edgeitems=3, infstr='inf', + ... linewidth=75, nanstr='nan', precision=8, + ... suppress=False, threshold=1000, formatter=None) + + Also to temporarily override options, use `printoptions` + as a context manager: + + >>> with np.printoptions(precision=2, suppress=True, threshold=5): + ... np.linspace(0, 10, 10) + array([ 0. , 1.11, 2.22, ..., 7.78, 8.89, 10. ]) + + """ + _set_printoptions(precision, threshold, edgeitems, linewidth, suppress, + nanstr, infstr, formatter, sign, floatmode, + legacy=legacy, override_repr=override_repr) + + +def _set_printoptions(precision=None, threshold=None, edgeitems=None, + linewidth=None, suppress=None, nanstr=None, + infstr=None, formatter=None, sign=None, floatmode=None, + *, legacy=None, override_repr=None): + new_opt = _make_options_dict(precision, threshold, edgeitems, linewidth, + suppress, nanstr, infstr, sign, formatter, + floatmode, legacy) + # formatter and override_repr are always reset + new_opt['formatter'] = formatter + new_opt['override_repr'] = override_repr + + updated_opt = format_options.get() | new_opt + updated_opt.update(new_opt) + + if updated_opt['legacy'] == 113: + updated_opt['sign'] = '-' + + return format_options.set(updated_opt) + + +@set_module('numpy') +def get_printoptions(): + """ + Return the current print options. + + Returns + ------- + print_opts : dict + Dictionary of current print options with keys + + - precision : int + - threshold : int + - edgeitems : int + - linewidth : int + - suppress : bool + - nanstr : str + - infstr : str + - sign : str + - formatter : dict of callables + - floatmode : str + - legacy : str or False + + For a full description of these options, see `set_printoptions`. + + See Also + -------- + set_printoptions, printoptions + + Examples + -------- + >>> import numpy as np + + >>> np.get_printoptions() + {'edgeitems': 3, 'threshold': 1000, ..., 'override_repr': None} + + >>> np.get_printoptions()['linewidth'] + 75 + >>> np.set_printoptions(linewidth=100) + >>> np.get_printoptions()['linewidth'] + 100 + + """ + opts = format_options.get().copy() + opts['legacy'] = { + 113: '1.13', 121: '1.21', 125: '1.25', sys.maxsize: False, + }[opts['legacy']] + return opts + + +def _get_legacy_print_mode(): + """Return the legacy print mode as an int.""" + return format_options.get()['legacy'] + + +@set_module('numpy') +@contextlib.contextmanager +def printoptions(*args, **kwargs): + """Context manager for setting print options. + + Set print options for the scope of the `with` block, and restore the old + options at the end. See `set_printoptions` for the full description of + available options. + + Examples + -------- + >>> import numpy as np + + >>> from numpy.testing import assert_equal + >>> with np.printoptions(precision=2): + ... np.array([2.0]) / 3 + array([0.67]) + + The `as`-clause of the `with`-statement gives the current print options: + + >>> with np.printoptions(precision=2) as opts: + ... assert_equal(opts, np.get_printoptions()) + + See Also + -------- + set_printoptions, get_printoptions + + """ + token = _set_printoptions(*args, **kwargs) + + try: + yield get_printoptions() + finally: + format_options.reset(token) + + +def _leading_trailing(a, edgeitems, index=()): + """ + Keep only the N-D corners (leading and trailing edges) of an array. + + Should be passed a base-class ndarray, since it makes no guarantees about + preserving subclasses. + """ + axis = len(index) + if axis == a.ndim: + return a[index] + + if a.shape[axis] > 2*edgeitems: + return concatenate(( + _leading_trailing(a, edgeitems, index + np.index_exp[:edgeitems]), + _leading_trailing(a, edgeitems, index + np.index_exp[-edgeitems:]) + ), axis=axis) + else: + return _leading_trailing(a, edgeitems, index + np.index_exp[:]) + + +def _object_format(o): + """ Object arrays containing lists should be printed unambiguously """ + if type(o) is list: + fmt = 'list({!r})' + else: + fmt = '{!r}' + return fmt.format(o) + +def repr_format(x): + if isinstance(x, (np.str_, np.bytes_)): + return repr(x.item()) + return repr(x) + +def str_format(x): + if isinstance(x, (np.str_, np.bytes_)): + return str(x.item()) + return str(x) + +def _get_formatdict(data, *, precision, floatmode, suppress, sign, legacy, + formatter, **kwargs): + # note: extra arguments in kwargs are ignored + + # wrapped in lambdas to avoid taking a code path + # with the wrong type of data + formatdict = { + 'bool': lambda: BoolFormat(data), + 'int': lambda: IntegerFormat(data, sign), + 'float': lambda: FloatingFormat( + data, precision, floatmode, suppress, sign, legacy=legacy), + 'longfloat': lambda: FloatingFormat( + data, precision, floatmode, suppress, sign, legacy=legacy), + 'complexfloat': lambda: ComplexFloatingFormat( + data, precision, floatmode, suppress, sign, legacy=legacy), + 'longcomplexfloat': lambda: ComplexFloatingFormat( + data, precision, floatmode, suppress, sign, legacy=legacy), + 'datetime': lambda: DatetimeFormat(data, legacy=legacy), + 'timedelta': lambda: TimedeltaFormat(data), + 'object': lambda: _object_format, + 'void': lambda: str_format, + 'numpystr': lambda: repr_format} + + # we need to wrap values in `formatter` in a lambda, so that the interface + # is the same as the above values. + def indirect(x): + return lambda: x + + if formatter is not None: + fkeys = [k for k in formatter.keys() if formatter[k] is not None] + if 'all' in fkeys: + for key in formatdict.keys(): + formatdict[key] = indirect(formatter['all']) + if 'int_kind' in fkeys: + for key in ['int']: + formatdict[key] = indirect(formatter['int_kind']) + if 'float_kind' in fkeys: + for key in ['float', 'longfloat']: + formatdict[key] = indirect(formatter['float_kind']) + if 'complex_kind' in fkeys: + for key in ['complexfloat', 'longcomplexfloat']: + formatdict[key] = indirect(formatter['complex_kind']) + if 'str_kind' in fkeys: + formatdict['numpystr'] = indirect(formatter['str_kind']) + for key in formatdict.keys(): + if key in fkeys: + formatdict[key] = indirect(formatter[key]) + + return formatdict + +def _get_format_function(data, **options): + """ + find the right formatting function for the dtype_ + """ + dtype_ = data.dtype + dtypeobj = dtype_.type + formatdict = _get_formatdict(data, **options) + if dtypeobj is None: + return formatdict["numpystr"]() + elif issubclass(dtypeobj, _nt.bool): + return formatdict['bool']() + elif issubclass(dtypeobj, _nt.integer): + if issubclass(dtypeobj, _nt.timedelta64): + return formatdict['timedelta']() + else: + return formatdict['int']() + elif issubclass(dtypeobj, _nt.floating): + if issubclass(dtypeobj, _nt.longdouble): + return formatdict['longfloat']() + else: + return formatdict['float']() + elif issubclass(dtypeobj, _nt.complexfloating): + if issubclass(dtypeobj, _nt.clongdouble): + return formatdict['longcomplexfloat']() + else: + return formatdict['complexfloat']() + elif issubclass(dtypeobj, (_nt.str_, _nt.bytes_)): + return formatdict['numpystr']() + elif issubclass(dtypeobj, _nt.datetime64): + return formatdict['datetime']() + elif issubclass(dtypeobj, _nt.object_): + return formatdict['object']() + elif issubclass(dtypeobj, _nt.void): + if dtype_.names is not None: + return StructuredVoidFormat.from_data(data, **options) + else: + return formatdict['void']() + else: + return formatdict['numpystr']() + + +def _recursive_guard(fillvalue='...'): + """ + Like the python 3.2 reprlib.recursive_repr, but forwards *args and **kwargs + + Decorates a function such that if it calls itself with the same first + argument, it returns `fillvalue` instead of recursing. + + Largely copied from reprlib.recursive_repr + """ + + def decorating_function(f): + repr_running = set() + + @functools.wraps(f) + def wrapper(self, *args, **kwargs): + key = id(self), get_ident() + if key in repr_running: + return fillvalue + repr_running.add(key) + try: + return f(self, *args, **kwargs) + finally: + repr_running.discard(key) + + return wrapper + + return decorating_function + + +# gracefully handle recursive calls, when object arrays contain themselves +@_recursive_guard() +def _array2string(a, options, separator=' ', prefix=""): + # The formatter __init__s in _get_format_function cannot deal with + # subclasses yet, and we also need to avoid recursion issues in + # _formatArray with subclasses which return 0d arrays in place of scalars + data = asarray(a) + if a.shape == (): + a = data + + if a.size > options['threshold']: + summary_insert = "..." + data = _leading_trailing(data, options['edgeitems']) + else: + summary_insert = "" + + # find the right formatting function for the array + format_function = _get_format_function(data, **options) + + # skip over "[" + next_line_prefix = " " + # skip over array( + next_line_prefix += " "*len(prefix) + + lst = _formatArray(a, format_function, options['linewidth'], + next_line_prefix, separator, options['edgeitems'], + summary_insert, options['legacy']) + return lst + + +def _array2string_dispatcher( + a, max_line_width=None, precision=None, + suppress_small=None, separator=None, prefix=None, + style=None, formatter=None, threshold=None, + edgeitems=None, sign=None, floatmode=None, suffix=None, + *, legacy=None): + return (a,) + + +@array_function_dispatch(_array2string_dispatcher, module='numpy') +def array2string(a, max_line_width=None, precision=None, + suppress_small=None, separator=' ', prefix="", + style=np._NoValue, formatter=None, threshold=None, + edgeitems=None, sign=None, floatmode=None, suffix="", + *, legacy=None): + """ + Return a string representation of an array. + + Parameters + ---------- + a : ndarray + Input array. + max_line_width : int, optional + Inserts newlines if text is longer than `max_line_width`. + Defaults to ``numpy.get_printoptions()['linewidth']``. + precision : int or None, optional + Floating point precision. + Defaults to ``numpy.get_printoptions()['precision']``. + suppress_small : bool, optional + Represent numbers "very close" to zero as zero; default is False. + Very close is defined by precision: if the precision is 8, e.g., + numbers smaller (in absolute value) than 5e-9 are represented as + zero. + Defaults to ``numpy.get_printoptions()['suppress']``. + separator : str, optional + Inserted between elements. + prefix : str, optional + suffix : str, optional + The length of the prefix and suffix strings are used to respectively + align and wrap the output. An array is typically printed as:: + + prefix + array2string(a) + suffix + + The output is left-padded by the length of the prefix string, and + wrapping is forced at the column ``max_line_width - len(suffix)``. + It should be noted that the content of prefix and suffix strings are + not included in the output. + style : _NoValue, optional + Has no effect, do not use. + + .. deprecated:: 1.14.0 + formatter : dict of callables, optional + If not None, the keys should indicate the type(s) that the respective + formatting function applies to. Callables should return a string. + Types that are not specified (by their corresponding keys) are handled + by the default formatters. Individual types for which a formatter + can be set are: + + - 'bool' + - 'int' + - 'timedelta' : a `numpy.timedelta64` + - 'datetime' : a `numpy.datetime64` + - 'float' + - 'longfloat' : 128-bit floats + - 'complexfloat' + - 'longcomplexfloat' : composed of two 128-bit floats + - 'void' : type `numpy.void` + - 'numpystr' : types `numpy.bytes_` and `numpy.str_` + + Other keys that can be used to set a group of types at once are: + + - 'all' : sets all types + - 'int_kind' : sets 'int' + - 'float_kind' : sets 'float' and 'longfloat' + - 'complex_kind' : sets 'complexfloat' and 'longcomplexfloat' + - 'str_kind' : sets 'numpystr' + threshold : int, optional + Total number of array elements which trigger summarization + rather than full repr. + Defaults to ``numpy.get_printoptions()['threshold']``. + edgeitems : int, optional + Number of array items in summary at beginning and end of + each dimension. + Defaults to ``numpy.get_printoptions()['edgeitems']``. + sign : string, either '-', '+', or ' ', optional + Controls printing of the sign of floating-point types. If '+', always + print the sign of positive values. If ' ', always prints a space + (whitespace character) in the sign position of positive values. If + '-', omit the sign character of positive values. + Defaults to ``numpy.get_printoptions()['sign']``. + + .. versionchanged:: 2.0 + The sign parameter can now be an integer type, previously + types were floating-point types. + + floatmode : str, optional + Controls the interpretation of the `precision` option for + floating-point types. + Defaults to ``numpy.get_printoptions()['floatmode']``. + Can take the following values: + + - 'fixed': Always print exactly `precision` fractional digits, + even if this would print more or fewer digits than + necessary to specify the value uniquely. + - 'unique': Print the minimum number of fractional digits necessary + to represent each value uniquely. Different elements may + have a different number of digits. The value of the + `precision` option is ignored. + - 'maxprec': Print at most `precision` fractional digits, but if + an element can be uniquely represented with fewer digits + only print it with that many. + - 'maxprec_equal': Print at most `precision` fractional digits, + but if every element in the array can be uniquely + represented with an equal number of fewer digits, use that + many digits for all elements. + legacy : string or `False`, optional + If set to the string ``'1.13'`` enables 1.13 legacy printing mode. This + approximates numpy 1.13 print output by including a space in the sign + position of floats and different behavior for 0d arrays. If set to + `False`, disables legacy mode. Unrecognized strings will be ignored + with a warning for forward compatibility. + + .. versionadded:: 1.14.0 + + Returns + ------- + array_str : str + String representation of the array. + + Raises + ------ + TypeError + if a callable in `formatter` does not return a string. + + See Also + -------- + array_str, array_repr, set_printoptions, get_printoptions + + Notes + ----- + If a formatter is specified for a certain type, the `precision` keyword is + ignored for that type. + + This is a very flexible function; `array_repr` and `array_str` are using + `array2string` internally so keywords with the same name should work + identically in all three functions. + + Examples + -------- + >>> import numpy as np + >>> x = np.array([1e-16,1,2,3]) + >>> np.array2string(x, precision=2, separator=',', + ... suppress_small=True) + '[0.,1.,2.,3.]' + + >>> x = np.arange(3.) + >>> np.array2string(x, formatter={'float_kind':lambda x: "%.2f" % x}) + '[0.00 1.00 2.00]' + + >>> x = np.arange(3) + >>> np.array2string(x, formatter={'int':lambda x: hex(x)}) + '[0x0 0x1 0x2]' + + """ + + overrides = _make_options_dict(precision, threshold, edgeitems, + max_line_width, suppress_small, None, None, + sign, formatter, floatmode, legacy) + options = format_options.get().copy() + options.update(overrides) + + if options['legacy'] <= 113: + if style is np._NoValue: + style = repr + + if a.shape == () and a.dtype.names is None: + return style(a.item()) + elif style is not np._NoValue: + # Deprecation 11-9-2017 v1.14 + warnings.warn("'style' argument is deprecated and no longer functional" + " except in 1.13 'legacy' mode", + DeprecationWarning, stacklevel=2) + + if options['legacy'] > 113: + options['linewidth'] -= len(suffix) + + # treat as a null array if any of shape elements == 0 + if a.size == 0: + return "[]" + + return _array2string(a, options, separator, prefix) + + +def _extendLine(s, line, word, line_width, next_line_prefix, legacy): + needs_wrap = len(line) + len(word) > line_width + if legacy > 113: + # don't wrap lines if it won't help + if len(line) <= len(next_line_prefix): + needs_wrap = False + + if needs_wrap: + s += line.rstrip() + "\n" + line = next_line_prefix + line += word + return s, line + + +def _extendLine_pretty(s, line, word, line_width, next_line_prefix, legacy): + """ + Extends line with nicely formatted (possibly multi-line) string ``word``. + """ + words = word.splitlines() + if len(words) == 1 or legacy <= 113: + return _extendLine(s, line, word, line_width, next_line_prefix, legacy) + + max_word_length = max(len(word) for word in words) + if (len(line) + max_word_length > line_width and + len(line) > len(next_line_prefix)): + s += line.rstrip() + '\n' + line = next_line_prefix + words[0] + indent = next_line_prefix + else: + indent = len(line)*' ' + line += words[0] + + for word in words[1::]: + s += line.rstrip() + '\n' + line = indent + word + + suffix_length = max_word_length - len(words[-1]) + line += suffix_length*' ' + + return s, line + +def _formatArray(a, format_function, line_width, next_line_prefix, + separator, edge_items, summary_insert, legacy): + """formatArray is designed for two modes of operation: + + 1. Full output + + 2. Summarized output + + """ + def recurser(index, hanging_indent, curr_width): + """ + By using this local function, we don't need to recurse with all the + arguments. Since this function is not created recursively, the cost is + not significant + """ + axis = len(index) + axes_left = a.ndim - axis + + if axes_left == 0: + return format_function(a[index]) + + # when recursing, add a space to align with the [ added, and reduce the + # length of the line by 1 + next_hanging_indent = hanging_indent + ' ' + if legacy <= 113: + next_width = curr_width + else: + next_width = curr_width - len(']') + + a_len = a.shape[axis] + show_summary = summary_insert and 2*edge_items < a_len + if show_summary: + leading_items = edge_items + trailing_items = edge_items + else: + leading_items = 0 + trailing_items = a_len + + # stringify the array with the hanging indent on the first line too + s = '' + + # last axis (rows) - wrap elements if they would not fit on one line + if axes_left == 1: + # the length up until the beginning of the separator / bracket + if legacy <= 113: + elem_width = curr_width - len(separator.rstrip()) + else: + elem_width = curr_width - max( + len(separator.rstrip()), len(']') + ) + + line = hanging_indent + for i in range(leading_items): + word = recurser(index + (i,), next_hanging_indent, next_width) + s, line = _extendLine_pretty( + s, line, word, elem_width, hanging_indent, legacy) + line += separator + + if show_summary: + s, line = _extendLine( + s, line, summary_insert, elem_width, hanging_indent, legacy + ) + if legacy <= 113: + line += ", " + else: + line += separator + + for i in range(trailing_items, 1, -1): + word = recurser(index + (-i,), next_hanging_indent, next_width) + s, line = _extendLine_pretty( + s, line, word, elem_width, hanging_indent, legacy) + line += separator + + if legacy <= 113: + # width of the separator is not considered on 1.13 + elem_width = curr_width + word = recurser(index + (-1,), next_hanging_indent, next_width) + s, line = _extendLine_pretty( + s, line, word, elem_width, hanging_indent, legacy) + + s += line + + # other axes - insert newlines between rows + else: + s = '' + line_sep = separator.rstrip() + '\n'*(axes_left - 1) + + for i in range(leading_items): + nested = recurser( + index + (i,), next_hanging_indent, next_width + ) + s += hanging_indent + nested + line_sep + + if show_summary: + if legacy <= 113: + # trailing space, fixed nbr of newlines, + # and fixed separator + s += hanging_indent + summary_insert + ", \n" + else: + s += hanging_indent + summary_insert + line_sep + + for i in range(trailing_items, 1, -1): + nested = recurser(index + (-i,), next_hanging_indent, + next_width) + s += hanging_indent + nested + line_sep + + nested = recurser(index + (-1,), next_hanging_indent, next_width) + s += hanging_indent + nested + + # remove the hanging indent, and wrap in [] + s = '[' + s[len(hanging_indent):] + ']' + return s + + try: + # invoke the recursive part with an initial index and prefix + return recurser(index=(), + hanging_indent=next_line_prefix, + curr_width=line_width) + finally: + # recursive closures have a cyclic reference to themselves, which + # requires gc to collect (gh-10620). To avoid this problem, for + # performance and PyPy friendliness, we break the cycle: + recurser = None + +def _none_or_positive_arg(x, name): + if x is None: + return -1 + if x < 0: + raise ValueError("{} must be >= 0".format(name)) + return x + +class FloatingFormat: + """ Formatter for subtypes of np.floating """ + def __init__(self, data, precision, floatmode, suppress_small, sign=False, + *, legacy=None): + # for backcompatibility, accept bools + if isinstance(sign, bool): + sign = '+' if sign else '-' + + self._legacy = legacy + if self._legacy <= 113: + # when not 0d, legacy does not support '-' + if data.shape != () and sign == '-': + sign = ' ' + + self.floatmode = floatmode + if floatmode == 'unique': + self.precision = None + else: + self.precision = precision + + self.precision = _none_or_positive_arg(self.precision, 'precision') + + self.suppress_small = suppress_small + self.sign = sign + self.exp_format = False + self.large_exponent = False + self.fillFormat(data) + + def fillFormat(self, data): + # only the finite values are used to compute the number of digits + finite_vals = data[isfinite(data)] + + # choose exponential mode based on the non-zero finite values: + abs_non_zero = absolute(finite_vals[finite_vals != 0]) + if len(abs_non_zero) != 0: + max_val = np.max(abs_non_zero) + min_val = np.min(abs_non_zero) + with errstate(over='ignore'): # division can overflow + if max_val >= 1.e8 or (not self.suppress_small and + (min_val < 0.0001 or max_val/min_val > 1000.)): + self.exp_format = True + + # do a first pass of printing all the numbers, to determine sizes + if len(finite_vals) == 0: + self.pad_left = 0 + self.pad_right = 0 + self.trim = '.' + self.exp_size = -1 + self.unique = True + self.min_digits = None + elif self.exp_format: + trim, unique = '.', True + if self.floatmode == 'fixed' or self._legacy <= 113: + trim, unique = 'k', False + strs = (dragon4_scientific(x, precision=self.precision, + unique=unique, trim=trim, sign=self.sign == '+') + for x in finite_vals) + frac_strs, _, exp_strs = zip(*(s.partition('e') for s in strs)) + int_part, frac_part = zip(*(s.split('.') for s in frac_strs)) + self.exp_size = max(len(s) for s in exp_strs) - 1 + + self.trim = 'k' + self.precision = max(len(s) for s in frac_part) + self.min_digits = self.precision + self.unique = unique + + # for back-compat with np 1.13, use 2 spaces & sign and full prec + if self._legacy <= 113: + self.pad_left = 3 + else: + # this should be only 1 or 2. Can be calculated from sign. + self.pad_left = max(len(s) for s in int_part) + # pad_right is only needed for nan length calculation + self.pad_right = self.exp_size + 2 + self.precision + else: + trim, unique = '.', True + if self.floatmode == 'fixed': + trim, unique = 'k', False + strs = (dragon4_positional(x, precision=self.precision, + fractional=True, + unique=unique, trim=trim, + sign=self.sign == '+') + for x in finite_vals) + int_part, frac_part = zip(*(s.split('.') for s in strs)) + if self._legacy <= 113: + self.pad_left = 1 + max(len(s.lstrip('-+')) for s in int_part) + else: + self.pad_left = max(len(s) for s in int_part) + self.pad_right = max(len(s) for s in frac_part) + self.exp_size = -1 + self.unique = unique + + if self.floatmode in ['fixed', 'maxprec_equal']: + self.precision = self.min_digits = self.pad_right + self.trim = 'k' + else: + self.trim = '.' + self.min_digits = 0 + + if self._legacy > 113: + # account for sign = ' ' by adding one to pad_left + if self.sign == ' ' and not any(np.signbit(finite_vals)): + self.pad_left += 1 + + # if there are non-finite values, may need to increase pad_left + if data.size != finite_vals.size: + neginf = self.sign != '-' or any(data[isinf(data)] < 0) + offset = self.pad_right + 1 # +1 for decimal pt + current_options = format_options.get() + self.pad_left = max( + self.pad_left, len(current_options['nanstr']) - offset, + len(current_options['infstr']) + neginf - offset + ) + + def __call__(self, x): + if not np.isfinite(x): + with errstate(invalid='ignore'): + current_options = format_options.get() + if np.isnan(x): + sign = '+' if self.sign == '+' else '' + ret = sign + current_options['nanstr'] + else: # isinf + sign = '-' if x < 0 else '+' if self.sign == '+' else '' + ret = sign + current_options['infstr'] + return ' '*( + self.pad_left + self.pad_right + 1 - len(ret) + ) + ret + + if self.exp_format: + return dragon4_scientific(x, + precision=self.precision, + min_digits=self.min_digits, + unique=self.unique, + trim=self.trim, + sign=self.sign == '+', + pad_left=self.pad_left, + exp_digits=self.exp_size) + else: + return dragon4_positional(x, + precision=self.precision, + min_digits=self.min_digits, + unique=self.unique, + fractional=True, + trim=self.trim, + sign=self.sign == '+', + pad_left=self.pad_left, + pad_right=self.pad_right) + + +@set_module('numpy') +def format_float_scientific(x, precision=None, unique=True, trim='k', + sign=False, pad_left=None, exp_digits=None, + min_digits=None): + """ + Format a floating-point scalar as a decimal string in scientific notation. + + Provides control over rounding, trimming and padding. Uses and assumes + IEEE unbiased rounding. Uses the "Dragon4" algorithm. + + Parameters + ---------- + x : python float or numpy floating scalar + Value to format. + precision : non-negative integer or None, optional + Maximum number of digits to print. May be None if `unique` is + `True`, but must be an integer if unique is `False`. + unique : boolean, optional + If `True`, use a digit-generation strategy which gives the shortest + representation which uniquely identifies the floating-point number from + other values of the same type, by judicious rounding. If `precision` + is given fewer digits than necessary can be printed. If `min_digits` + is given more can be printed, in which cases the last digit is rounded + with unbiased rounding. + If `False`, digits are generated as if printing an infinite-precision + value and stopping after `precision` digits, rounding the remaining + value with unbiased rounding + trim : one of 'k', '.', '0', '-', optional + Controls post-processing trimming of trailing digits, as follows: + + * 'k' : keep trailing zeros, keep decimal point (no trimming) + * '.' : trim all trailing zeros, leave decimal point + * '0' : trim all but the zero before the decimal point. Insert the + zero if it is missing. + * '-' : trim trailing zeros and any trailing decimal point + sign : boolean, optional + Whether to show the sign for positive values. + pad_left : non-negative integer, optional + Pad the left side of the string with whitespace until at least that + many characters are to the left of the decimal point. + exp_digits : non-negative integer, optional + Pad the exponent with zeros until it contains at least this + many digits. If omitted, the exponent will be at least 2 digits. + min_digits : non-negative integer or None, optional + Minimum number of digits to print. This only has an effect for + `unique=True`. In that case more digits than necessary to uniquely + identify the value may be printed and rounded unbiased. + + .. versionadded:: 1.21.0 + + Returns + ------- + rep : string + The string representation of the floating point value + + See Also + -------- + format_float_positional + + Examples + -------- + >>> import numpy as np + >>> np.format_float_scientific(np.float32(np.pi)) + '3.1415927e+00' + >>> s = np.float32(1.23e24) + >>> np.format_float_scientific(s, unique=False, precision=15) + '1.230000071797338e+24' + >>> np.format_float_scientific(s, exp_digits=4) + '1.23e+0024' + """ + precision = _none_or_positive_arg(precision, 'precision') + pad_left = _none_or_positive_arg(pad_left, 'pad_left') + exp_digits = _none_or_positive_arg(exp_digits, 'exp_digits') + min_digits = _none_or_positive_arg(min_digits, 'min_digits') + if min_digits > 0 and precision > 0 and min_digits > precision: + raise ValueError("min_digits must be less than or equal to precision") + return dragon4_scientific(x, precision=precision, unique=unique, + trim=trim, sign=sign, pad_left=pad_left, + exp_digits=exp_digits, min_digits=min_digits) + + +@set_module('numpy') +def format_float_positional(x, precision=None, unique=True, + fractional=True, trim='k', sign=False, + pad_left=None, pad_right=None, min_digits=None): + """ + Format a floating-point scalar as a decimal string in positional notation. + + Provides control over rounding, trimming and padding. Uses and assumes + IEEE unbiased rounding. Uses the "Dragon4" algorithm. + + Parameters + ---------- + x : python float or numpy floating scalar + Value to format. + precision : non-negative integer or None, optional + Maximum number of digits to print. May be None if `unique` is + `True`, but must be an integer if unique is `False`. + unique : boolean, optional + If `True`, use a digit-generation strategy which gives the shortest + representation which uniquely identifies the floating-point number from + other values of the same type, by judicious rounding. If `precision` + is given fewer digits than necessary can be printed, or if `min_digits` + is given more can be printed, in which cases the last digit is rounded + with unbiased rounding. + If `False`, digits are generated as if printing an infinite-precision + value and stopping after `precision` digits, rounding the remaining + value with unbiased rounding + fractional : boolean, optional + If `True`, the cutoffs of `precision` and `min_digits` refer to the + total number of digits after the decimal point, including leading + zeros. + If `False`, `precision` and `min_digits` refer to the total number of + significant digits, before or after the decimal point, ignoring leading + zeros. + trim : one of 'k', '.', '0', '-', optional + Controls post-processing trimming of trailing digits, as follows: + + * 'k' : keep trailing zeros, keep decimal point (no trimming) + * '.' : trim all trailing zeros, leave decimal point + * '0' : trim all but the zero before the decimal point. Insert the + zero if it is missing. + * '-' : trim trailing zeros and any trailing decimal point + sign : boolean, optional + Whether to show the sign for positive values. + pad_left : non-negative integer, optional + Pad the left side of the string with whitespace until at least that + many characters are to the left of the decimal point. + pad_right : non-negative integer, optional + Pad the right side of the string with whitespace until at least that + many characters are to the right of the decimal point. + min_digits : non-negative integer or None, optional + Minimum number of digits to print. Only has an effect if `unique=True` + in which case additional digits past those necessary to uniquely + identify the value may be printed, rounding the last additional digit. + + .. versionadded:: 1.21.0 + + Returns + ------- + rep : string + The string representation of the floating point value + + See Also + -------- + format_float_scientific + + Examples + -------- + >>> import numpy as np + >>> np.format_float_positional(np.float32(np.pi)) + '3.1415927' + >>> np.format_float_positional(np.float16(np.pi)) + '3.14' + >>> np.format_float_positional(np.float16(0.3)) + '0.3' + >>> np.format_float_positional(np.float16(0.3), unique=False, precision=10) + '0.3000488281' + """ + precision = _none_or_positive_arg(precision, 'precision') + pad_left = _none_or_positive_arg(pad_left, 'pad_left') + pad_right = _none_or_positive_arg(pad_right, 'pad_right') + min_digits = _none_or_positive_arg(min_digits, 'min_digits') + if not fractional and precision == 0: + raise ValueError("precision must be greater than 0 if " + "fractional=False") + if min_digits > 0 and precision > 0 and min_digits > precision: + raise ValueError("min_digits must be less than or equal to precision") + return dragon4_positional(x, precision=precision, unique=unique, + fractional=fractional, trim=trim, + sign=sign, pad_left=pad_left, + pad_right=pad_right, min_digits=min_digits) + +class IntegerFormat: + def __init__(self, data, sign='-'): + if data.size > 0: + data_max = np.max(data) + data_min = np.min(data) + data_max_str_len = len(str(data_max)) + if sign == ' ' and data_min < 0: + sign = '-' + if data_max >= 0 and sign in "+ ": + data_max_str_len += 1 + max_str_len = max(data_max_str_len, + len(str(data_min))) + else: + max_str_len = 0 + self.format = f'{{:{sign}{max_str_len}d}}' + + def __call__(self, x): + return self.format.format(x) + +class BoolFormat: + def __init__(self, data, **kwargs): + # add an extra space so " True" and "False" have the same length and + # array elements align nicely when printed, except in 0d arrays + self.truestr = ' True' if data.shape != () else 'True' + + def __call__(self, x): + return self.truestr if x else "False" + + +class ComplexFloatingFormat: + """ Formatter for subtypes of np.complexfloating """ + def __init__(self, x, precision, floatmode, suppress_small, + sign=False, *, legacy=None): + # for backcompatibility, accept bools + if isinstance(sign, bool): + sign = '+' if sign else '-' + + floatmode_real = floatmode_imag = floatmode + if legacy <= 113: + floatmode_real = 'maxprec_equal' + floatmode_imag = 'maxprec' + + self.real_format = FloatingFormat( + x.real, precision, floatmode_real, suppress_small, + sign=sign, legacy=legacy + ) + self.imag_format = FloatingFormat( + x.imag, precision, floatmode_imag, suppress_small, + sign='+', legacy=legacy + ) + + def __call__(self, x): + r = self.real_format(x.real) + i = self.imag_format(x.imag) + + # add the 'j' before the terminal whitespace in i + sp = len(i.rstrip()) + i = i[:sp] + 'j' + i[sp:] + + return r + i + + +class _TimelikeFormat: + def __init__(self, data): + non_nat = data[~isnat(data)] + if len(non_nat) > 0: + # Max str length of non-NaT elements + max_str_len = max(len(self._format_non_nat(np.max(non_nat))), + len(self._format_non_nat(np.min(non_nat)))) + else: + max_str_len = 0 + if len(non_nat) < data.size: + # data contains a NaT + max_str_len = max(max_str_len, 5) + self._format = '%{}s'.format(max_str_len) + self._nat = "'NaT'".rjust(max_str_len) + + def _format_non_nat(self, x): + # override in subclass + raise NotImplementedError + + def __call__(self, x): + if isnat(x): + return self._nat + else: + return self._format % self._format_non_nat(x) + + +class DatetimeFormat(_TimelikeFormat): + def __init__(self, x, unit=None, timezone=None, casting='same_kind', + legacy=False): + # Get the unit from the dtype + if unit is None: + if x.dtype.kind == 'M': + unit = datetime_data(x.dtype)[0] + else: + unit = 's' + + if timezone is None: + timezone = 'naive' + self.timezone = timezone + self.unit = unit + self.casting = casting + self.legacy = legacy + + # must be called after the above are configured + super().__init__(x) + + def __call__(self, x): + if self.legacy <= 113: + return self._format_non_nat(x) + return super().__call__(x) + + def _format_non_nat(self, x): + return "'%s'" % datetime_as_string(x, + unit=self.unit, + timezone=self.timezone, + casting=self.casting) + + +class TimedeltaFormat(_TimelikeFormat): + def _format_non_nat(self, x): + return str(x.astype('i8')) + + +class SubArrayFormat: + def __init__(self, format_function, **options): + self.format_function = format_function + self.threshold = options['threshold'] + self.edge_items = options['edgeitems'] + + def __call__(self, a): + self.summary_insert = "..." if a.size > self.threshold else "" + return self.format_array(a) + + def format_array(self, a): + if np.ndim(a) == 0: + return self.format_function(a) + + if self.summary_insert and a.shape[0] > 2*self.edge_items: + formatted = ( + [self.format_array(a_) for a_ in a[:self.edge_items]] + + [self.summary_insert] + + [self.format_array(a_) for a_ in a[-self.edge_items:]] + ) + else: + formatted = [self.format_array(a_) for a_ in a] + + return "[" + ", ".join(formatted) + "]" + + +class StructuredVoidFormat: + """ + Formatter for structured np.void objects. + + This does not work on structured alias types like + np.dtype(('i4', 'i2,i2')), as alias scalars lose their field information, + and the implementation relies upon np.void.__getitem__. + """ + def __init__(self, format_functions): + self.format_functions = format_functions + + @classmethod + def from_data(cls, data, **options): + """ + This is a second way to initialize StructuredVoidFormat, + using the raw data as input. Added to avoid changing + the signature of __init__. + """ + format_functions = [] + for field_name in data.dtype.names: + format_function = _get_format_function(data[field_name], **options) + if data.dtype[field_name].shape != (): + format_function = SubArrayFormat(format_function, **options) + format_functions.append(format_function) + return cls(format_functions) + + def __call__(self, x): + str_fields = [ + format_function(field) + for field, format_function in zip(x, self.format_functions) + ] + if len(str_fields) == 1: + return "({},)".format(str_fields[0]) + else: + return "({})".format(", ".join(str_fields)) + + +def _void_scalar_to_string(x, is_repr=True): + """ + Implements the repr for structured-void scalars. It is called from the + scalartypes.c.src code, and is placed here because it uses the elementwise + formatters defined above. + """ + options = format_options.get().copy() + + if options["legacy"] <= 125: + return StructuredVoidFormat.from_data(array(x), **options)(x) + + if options.get('formatter') is None: + options['formatter'] = {} + options['formatter'].setdefault('float_kind', str) + val_repr = StructuredVoidFormat.from_data(array(x), **options)(x) + if not is_repr: + return val_repr + cls = type(x) + cls_fqn = cls.__module__.replace("numpy", "np") + "." + cls.__name__ + void_dtype = np.dtype((np.void, x.dtype)) + return f"{cls_fqn}({val_repr}, dtype={void_dtype!s})" + + +_typelessdata = [int_, float64, complex128, _nt.bool] + + +def dtype_is_implied(dtype): + """ + Determine if the given dtype is implied by the representation + of its values. + + Parameters + ---------- + dtype : dtype + Data type + + Returns + ------- + implied : bool + True if the dtype is implied by the representation of its values. + + Examples + -------- + >>> import numpy as np + >>> np._core.arrayprint.dtype_is_implied(int) + True + >>> np.array([1, 2, 3], int) + array([1, 2, 3]) + >>> np._core.arrayprint.dtype_is_implied(np.int8) + False + >>> np.array([1, 2, 3], np.int8) + array([1, 2, 3], dtype=int8) + """ + dtype = np.dtype(dtype) + if format_options.get()['legacy'] <= 113 and dtype.type == np.bool: + return False + + # not just void types can be structured, and names are not part of the repr + if dtype.names is not None: + return False + + # should care about endianness *unless size is 1* (e.g., int8, bool) + if not dtype.isnative: + return False + + return dtype.type in _typelessdata + + +def dtype_short_repr(dtype): + """ + Convert a dtype to a short form which evaluates to the same dtype. + + The intent is roughly that the following holds + + >>> from numpy import * + >>> dt = np.int64([1, 2]).dtype + >>> assert eval(dtype_short_repr(dt)) == dt + """ + if type(dtype).__repr__ != np.dtype.__repr__: + # TODO: Custom repr for user DTypes, logic should likely move. + return repr(dtype) + if dtype.names is not None: + # structured dtypes give a list or tuple repr + return str(dtype) + elif issubclass(dtype.type, flexible): + # handle these separately so they don't give garbage like str256 + return "'%s'" % str(dtype) + + typename = dtype.name + if not dtype.isnative: + # deal with cases like dtype(' 0 + + prefix = class_name + "(" + suffix = ")" if skipdtype else "," + + if (current_options['legacy'] <= 113 and + arr.shape == () and not arr.dtype.names): + lst = repr(arr.item()) + elif arr.size > 0 or arr.shape == (0,): + lst = array2string(arr, max_line_width, precision, suppress_small, + ', ', prefix, suffix=suffix) + else: # show zero-length shape unless it is (0,) + lst = "[], shape=%s" % (repr(arr.shape),) + + arr_str = prefix + lst + suffix + + if skipdtype: + return arr_str + + dtype_str = "dtype={})".format(dtype_short_repr(arr.dtype)) + + # compute whether we should put dtype on a new line: Do so if adding the + # dtype would extend the last line past max_line_width. + # Note: This line gives the correct result even when rfind returns -1. + last_line_len = len(arr_str) - (arr_str.rfind('\n') + 1) + spacer = " " + if current_options['legacy'] <= 113: + if issubclass(arr.dtype.type, flexible): + spacer = '\n' + ' '*len(class_name + "(") + elif last_line_len + len(dtype_str) + 1 > max_line_width: + spacer = '\n' + ' '*len(class_name + "(") + + return arr_str + spacer + dtype_str + + +def _array_repr_dispatcher( + arr, max_line_width=None, precision=None, suppress_small=None): + return (arr,) + + +@array_function_dispatch(_array_repr_dispatcher, module='numpy') +def array_repr(arr, max_line_width=None, precision=None, suppress_small=None): + """ + Return the string representation of an array. + + Parameters + ---------- + arr : ndarray + Input array. + max_line_width : int, optional + Inserts newlines if text is longer than `max_line_width`. + Defaults to ``numpy.get_printoptions()['linewidth']``. + precision : int, optional + Floating point precision. + Defaults to ``numpy.get_printoptions()['precision']``. + suppress_small : bool, optional + Represent numbers "very close" to zero as zero; default is False. + Very close is defined by precision: if the precision is 8, e.g., + numbers smaller (in absolute value) than 5e-9 are represented as + zero. + Defaults to ``numpy.get_printoptions()['suppress']``. + + Returns + ------- + string : str + The string representation of an array. + + See Also + -------- + array_str, array2string, set_printoptions + + Examples + -------- + >>> import numpy as np + >>> np.array_repr(np.array([1,2])) + 'array([1, 2])' + >>> np.array_repr(np.ma.array([0.])) + 'MaskedArray([0.])' + >>> np.array_repr(np.array([], np.int32)) + 'array([], dtype=int32)' + + >>> x = np.array([1e-6, 4e-7, 2, 3]) + >>> np.array_repr(x, precision=6, suppress_small=True) + 'array([0.000001, 0. , 2. , 3. ])' + + """ + return _array_repr_implementation( + arr, max_line_width, precision, suppress_small) + + +@_recursive_guard() +def _guarded_repr_or_str(v): + if isinstance(v, bytes): + return repr(v) + return str(v) + + +def _array_str_implementation( + a, max_line_width=None, precision=None, suppress_small=None, + array2string=array2string): + """Internal version of array_str() that allows overriding array2string.""" + if (format_options.get()['legacy'] <= 113 and + a.shape == () and not a.dtype.names): + return str(a.item()) + + # the str of 0d arrays is a special case: It should appear like a scalar, + # so floats are not truncated by `precision`, and strings are not wrapped + # in quotes. So we return the str of the scalar value. + if a.shape == (): + # obtain a scalar and call str on it, avoiding problems for subclasses + # for which indexing with () returns a 0d instead of a scalar by using + # ndarray's getindex. Also guard against recursive 0d object arrays. + return _guarded_repr_or_str(np.ndarray.__getitem__(a, ())) + + return array2string(a, max_line_width, precision, suppress_small, ' ', "") + + +def _array_str_dispatcher( + a, max_line_width=None, precision=None, suppress_small=None): + return (a,) + + +@array_function_dispatch(_array_str_dispatcher, module='numpy') +def array_str(a, max_line_width=None, precision=None, suppress_small=None): + """ + Return a string representation of the data in an array. + + The data in the array is returned as a single string. This function is + similar to `array_repr`, the difference being that `array_repr` also + returns information on the kind of array and its data type. + + Parameters + ---------- + a : ndarray + Input array. + max_line_width : int, optional + Inserts newlines if text is longer than `max_line_width`. + Defaults to ``numpy.get_printoptions()['linewidth']``. + precision : int, optional + Floating point precision. + Defaults to ``numpy.get_printoptions()['precision']``. + suppress_small : bool, optional + Represent numbers "very close" to zero as zero; default is False. + Very close is defined by precision: if the precision is 8, e.g., + numbers smaller (in absolute value) than 5e-9 are represented as + zero. + Defaults to ``numpy.get_printoptions()['suppress']``. + + See Also + -------- + array2string, array_repr, set_printoptions + + Examples + -------- + >>> import numpy as np + >>> np.array_str(np.arange(3)) + '[0 1 2]' + + """ + return _array_str_implementation( + a, max_line_width, precision, suppress_small) + + +# needed if __array_function__ is disabled +_array2string_impl = getattr(array2string, '__wrapped__', array2string) +_default_array_str = functools.partial(_array_str_implementation, + array2string=_array2string_impl) +_default_array_repr = functools.partial(_array_repr_implementation, + array2string=_array2string_impl) diff --git a/venv/lib/python3.12/site-packages/numpy/_core/arrayprint.pyi b/venv/lib/python3.12/site-packages/numpy/_core/arrayprint.pyi new file mode 100644 index 00000000..44d77083 --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/arrayprint.pyi @@ -0,0 +1,135 @@ +from collections.abc import Callable +from typing import Any, Literal, TypedDict, SupportsIndex + +# Using a private class is by no means ideal, but it is simply a consequence +# of a `contextlib.context` returning an instance of aforementioned class +from contextlib import _GeneratorContextManager + +import numpy as np +from numpy import ( + integer, + timedelta64, + datetime64, + floating, + complexfloating, + void, + longdouble, + clongdouble, +) +from numpy._typing import NDArray, _CharLike_co, _FloatLike_co + +_FloatMode = Literal["fixed", "unique", "maxprec", "maxprec_equal"] + +class _FormatDict(TypedDict, total=False): + bool: Callable[[np.bool], str] + int: Callable[[integer[Any]], str] + timedelta: Callable[[timedelta64], str] + datetime: Callable[[datetime64], str] + float: Callable[[floating[Any]], str] + longfloat: Callable[[longdouble], str] + complexfloat: Callable[[complexfloating[Any, Any]], str] + longcomplexfloat: Callable[[clongdouble], str] + void: Callable[[void], str] + numpystr: Callable[[_CharLike_co], str] + object: Callable[[object], str] + all: Callable[[object], str] + int_kind: Callable[[integer[Any]], str] + float_kind: Callable[[floating[Any]], str] + complex_kind: Callable[[complexfloating[Any, Any]], str] + str_kind: Callable[[_CharLike_co], str] + +class _FormatOptions(TypedDict): + precision: int + threshold: int + edgeitems: int + linewidth: int + suppress: bool + nanstr: str + infstr: str + formatter: None | _FormatDict + sign: Literal["-", "+", " "] + floatmode: _FloatMode + legacy: Literal[False, "1.13", "1.21"] + +def set_printoptions( + precision: None | SupportsIndex = ..., + threshold: None | int = ..., + edgeitems: None | int = ..., + linewidth: None | int = ..., + suppress: None | bool = ..., + nanstr: None | str = ..., + infstr: None | str = ..., + formatter: None | _FormatDict = ..., + sign: Literal[None, "-", "+", " "] = ..., + floatmode: None | _FloatMode = ..., + *, + legacy: Literal[None, False, "1.13", "1.21"] = ..., + override_repr: None | Callable[[NDArray[Any]], str] = ..., +) -> None: ... +def get_printoptions() -> _FormatOptions: ... +def array2string( + a: NDArray[Any], + max_line_width: None | int = ..., + precision: None | SupportsIndex = ..., + suppress_small: None | bool = ..., + separator: str = ..., + prefix: str = ..., + # NOTE: With the `style` argument being deprecated, + # all arguments between `formatter` and `suffix` are de facto + # keyworld-only arguments + *, + formatter: None | _FormatDict = ..., + threshold: None | int = ..., + edgeitems: None | int = ..., + sign: Literal[None, "-", "+", " "] = ..., + floatmode: None | _FloatMode = ..., + suffix: str = ..., + legacy: Literal[None, False, "1.13", "1.21"] = ..., +) -> str: ... +def format_float_scientific( + x: _FloatLike_co, + precision: None | int = ..., + unique: bool = ..., + trim: Literal["k", ".", "0", "-"] = ..., + sign: bool = ..., + pad_left: None | int = ..., + exp_digits: None | int = ..., + min_digits: None | int = ..., +) -> str: ... +def format_float_positional( + x: _FloatLike_co, + precision: None | int = ..., + unique: bool = ..., + fractional: bool = ..., + trim: Literal["k", ".", "0", "-"] = ..., + sign: bool = ..., + pad_left: None | int = ..., + pad_right: None | int = ..., + min_digits: None | int = ..., +) -> str: ... +def array_repr( + arr: NDArray[Any], + max_line_width: None | int = ..., + precision: None | SupportsIndex = ..., + suppress_small: None | bool = ..., +) -> str: ... +def array_str( + a: NDArray[Any], + max_line_width: None | int = ..., + precision: None | SupportsIndex = ..., + suppress_small: None | bool = ..., +) -> str: ... +def printoptions( + precision: None | SupportsIndex = ..., + threshold: None | int = ..., + edgeitems: None | int = ..., + linewidth: None | int = ..., + suppress: None | bool = ..., + nanstr: None | str = ..., + infstr: None | str = ..., + formatter: None | _FormatDict = ..., + sign: Literal[None, "-", "+", " "] = ..., + floatmode: None | _FloatMode = ..., + *, + legacy: Literal[None, False, "1.13", "1.21"] = ... +) -> _GeneratorContextManager[_FormatOptions]: ... diff --git a/venv/lib/python3.12/site-packages/numpy/_core/cversions.py b/venv/lib/python3.12/site-packages/numpy/_core/cversions.py new file mode 100644 index 00000000..00159c3a --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/cversions.py @@ -0,0 +1,13 @@ +"""Simple script to compute the api hash of the current API. + +The API has is defined by numpy_api_order and ufunc_api_order. + +""" +from os.path import dirname + +from code_generators.genapi import fullapi_hash +from code_generators.numpy_api import full_api + +if __name__ == '__main__': + curdir = dirname(__file__) + print(fullapi_hash(full_api)) diff --git a/venv/lib/python3.12/site-packages/numpy/_core/defchararray.py b/venv/lib/python3.12/site-packages/numpy/_core/defchararray.py new file mode 100644 index 00000000..6301556a --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/defchararray.py @@ -0,0 +1,1402 @@ +""" +This module contains a set of functions for vectorized string +operations and methods. + +.. note:: + The `chararray` class exists for backwards compatibility with + Numarray, it is not recommended for new development. Starting from numpy + 1.4, if one needs arrays of strings, it is recommended to use arrays of + `dtype` `object_`, `bytes_` or `str_`, and use the free functions + in the `numpy.char` module for fast vectorized string operations. + +Some methods will only be available if the corresponding string method is +available in your version of Python. + +The preferred alias for `defchararray` is `numpy.char`. + +""" +import functools + +import numpy as np +from .._utils import set_module +from .numerictypes import bytes_, str_, character +from .numeric import ndarray, array as narray, asarray as asnarray +from numpy._core.multiarray import compare_chararrays +from numpy._core import overrides +from numpy.strings import * +from numpy.strings import ( + multiply as strings_multiply, + partition as strings_partition, + rpartition as strings_rpartition, +) +from numpy._core.strings import ( + _split as split, + _rsplit as rsplit, + _splitlines as splitlines, + _join as join, +) + +__all__ = [ + 'equal', 'not_equal', 'greater_equal', 'less_equal', + 'greater', 'less', 'str_len', 'add', 'multiply', 'mod', 'capitalize', + 'center', 'count', 'decode', 'encode', 'endswith', 'expandtabs', + 'find', 'index', 'isalnum', 'isalpha', 'isdigit', 'islower', 'isspace', + 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'partition', + 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', + 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', + 'title', 'translate', 'upper', 'zfill', 'isnumeric', 'isdecimal', + 'array', 'asarray', 'compare_chararrays', 'chararray' + ] + + +array_function_dispatch = functools.partial( + overrides.array_function_dispatch, module='numpy.char') + + +def _binary_op_dispatcher(x1, x2): + return (x1, x2) + + +@array_function_dispatch(_binary_op_dispatcher) +def equal(x1, x2): + """ + Return (x1 == x2) element-wise. + + Unlike `numpy.equal`, this comparison is performed by first + stripping whitespace characters from the end of the string. This + behavior is provided for backward-compatibility with numarray. + + Parameters + ---------- + x1, x2 : array_like of str or unicode + Input arrays of the same shape. + + Returns + ------- + out : ndarray + Output array of bools. + + Examples + -------- + >>> import numpy as np + >>> y = "aa " + >>> x = "aa" + >>> np.char.equal(x, y) + array(True) + + See Also + -------- + not_equal, greater_equal, less_equal, greater, less + """ + return compare_chararrays(x1, x2, '==', True) + + +@array_function_dispatch(_binary_op_dispatcher) +def not_equal(x1, x2): + """ + Return (x1 != x2) element-wise. + + Unlike `numpy.not_equal`, this comparison is performed by first + stripping whitespace characters from the end of the string. This + behavior is provided for backward-compatibility with numarray. + + Parameters + ---------- + x1, x2 : array_like of str or unicode + Input arrays of the same shape. + + Returns + ------- + out : ndarray + Output array of bools. + + See Also + -------- + equal, greater_equal, less_equal, greater, less + + Examples + -------- + >>> import numpy as np + >>> x1 = np.array(['a', 'b', 'c']) + >>> np.char.not_equal(x1, 'b') + array([ True, False, True]) + + """ + return compare_chararrays(x1, x2, '!=', True) + + +@array_function_dispatch(_binary_op_dispatcher) +def greater_equal(x1, x2): + """ + Return (x1 >= x2) element-wise. + + Unlike `numpy.greater_equal`, this comparison is performed by + first stripping whitespace characters from the end of the string. + This behavior is provided for backward-compatibility with + numarray. + + Parameters + ---------- + x1, x2 : array_like of str or unicode + Input arrays of the same shape. + + Returns + ------- + out : ndarray + Output array of bools. + + See Also + -------- + equal, not_equal, less_equal, greater, less + + Examples + -------- + >>> import numpy as np + >>> x1 = np.array(['a', 'b', 'c']) + >>> np.char.greater_equal(x1, 'b') + array([False, True, True]) + + """ + return compare_chararrays(x1, x2, '>=', True) + + +@array_function_dispatch(_binary_op_dispatcher) +def less_equal(x1, x2): + """ + Return (x1 <= x2) element-wise. + + Unlike `numpy.less_equal`, this comparison is performed by first + stripping whitespace characters from the end of the string. This + behavior is provided for backward-compatibility with numarray. + + Parameters + ---------- + x1, x2 : array_like of str or unicode + Input arrays of the same shape. + + Returns + ------- + out : ndarray + Output array of bools. + + See Also + -------- + equal, not_equal, greater_equal, greater, less + + Examples + -------- + >>> import numpy as np + >>> x1 = np.array(['a', 'b', 'c']) + >>> np.char.less_equal(x1, 'b') + array([ True, True, False]) + + """ + return compare_chararrays(x1, x2, '<=', True) + + +@array_function_dispatch(_binary_op_dispatcher) +def greater(x1, x2): + """ + Return (x1 > x2) element-wise. + + Unlike `numpy.greater`, this comparison is performed by first + stripping whitespace characters from the end of the string. This + behavior is provided for backward-compatibility with numarray. + + Parameters + ---------- + x1, x2 : array_like of str or unicode + Input arrays of the same shape. + + Returns + ------- + out : ndarray + Output array of bools. + + See Also + -------- + equal, not_equal, greater_equal, less_equal, less + + Examples + -------- + >>> import numpy as np + >>> x1 = np.array(['a', 'b', 'c']) + >>> np.char.greater(x1, 'b') + array([False, False, True]) + + """ + return compare_chararrays(x1, x2, '>', True) + + +@array_function_dispatch(_binary_op_dispatcher) +def less(x1, x2): + """ + Return (x1 < x2) element-wise. + + Unlike `numpy.greater`, this comparison is performed by first + stripping whitespace characters from the end of the string. This + behavior is provided for backward-compatibility with numarray. + + Parameters + ---------- + x1, x2 : array_like of str or unicode + Input arrays of the same shape. + + Returns + ------- + out : ndarray + Output array of bools. + + See Also + -------- + equal, not_equal, greater_equal, less_equal, greater + + Examples + -------- + >>> import numpy as np + >>> x1 = np.array(['a', 'b', 'c']) + >>> np.char.less(x1, 'b') + array([True, False, False]) + + """ + return compare_chararrays(x1, x2, '<', True) + + +def multiply(a, i): + """ + Return (a * i), that is string multiple concatenation, + element-wise. + + Values in ``i`` of less than 0 are treated as 0 (which yields an + empty string). + + Parameters + ---------- + a : array_like, with `np.bytes_` or `np.str_` dtype + + i : array_like, with any integer dtype + + Returns + ------- + out : ndarray + Output array of str or unicode, depending on input types + + Notes + ----- + This is a thin wrapper around np.strings.multiply that raises + `ValueError` when ``i`` is not an integer. It only + exists for backwards-compatibility. + + Examples + -------- + >>> import numpy as np + >>> a = np.array(["a", "b", "c"]) + >>> np.strings.multiply(a, 3) + array(['aaa', 'bbb', 'ccc'], dtype='>> i = np.array([1, 2, 3]) + >>> np.strings.multiply(a, i) + array(['a', 'bb', 'ccc'], dtype='>> np.strings.multiply(np.array(['a']), i) + array(['a', 'aa', 'aaa'], dtype='>> a = np.array(['a', 'b', 'c', 'd', 'e', 'f']).reshape((2, 3)) + >>> np.strings.multiply(a, 3) + array([['aaa', 'bbb', 'ccc'], + ['ddd', 'eee', 'fff']], dtype='>> np.strings.multiply(a, i) + array([['a', 'bb', 'ccc'], + ['d', 'ee', 'fff']], dtype='>> import numpy as np + >>> x = np.array(["Numpy is nice!"]) + >>> np.char.partition(x, " ") + array([['Numpy', ' ', 'is nice!']], dtype='>> import numpy as np + >>> a = np.array(['aAaAaA', ' aA ', 'abBABba']) + >>> np.char.rpartition(a, 'A') + array([['aAaAa', 'A', ''], + [' a', 'A', ' '], + ['abB', 'A', 'Bba']], dtype='= 2`` and ``order='F'``, in which case `strides` + is in "Fortran order". + + Methods + ------- + astype + argsort + copy + count + decode + dump + dumps + encode + endswith + expandtabs + fill + find + flatten + getfield + index + isalnum + isalpha + isdecimal + isdigit + islower + isnumeric + isspace + istitle + isupper + item + join + ljust + lower + lstrip + nonzero + put + ravel + repeat + replace + reshape + resize + rfind + rindex + rjust + rsplit + rstrip + searchsorted + setfield + setflags + sort + split + splitlines + squeeze + startswith + strip + swapaxes + swapcase + take + title + tofile + tolist + tostring + translate + transpose + upper + view + zfill + + Parameters + ---------- + shape : tuple + Shape of the array. + itemsize : int, optional + Length of each array element, in number of characters. Default is 1. + unicode : bool, optional + Are the array elements of type unicode (True) or string (False). + Default is False. + buffer : object exposing the buffer interface or str, optional + Memory address of the start of the array data. Default is None, + in which case a new array is created. + offset : int, optional + Fixed stride displacement from the beginning of an axis? + Default is 0. Needs to be >=0. + strides : array_like of ints, optional + Strides for the array (see `~numpy.ndarray.strides` for + full description). Default is None. + order : {'C', 'F'}, optional + The order in which the array data is stored in memory: 'C' -> + "row major" order (the default), 'F' -> "column major" + (Fortran) order. + + Examples + -------- + >>> import numpy as np + >>> charar = np.char.chararray((3, 3)) + >>> charar[:] = 'a' + >>> charar + chararray([[b'a', b'a', b'a'], + [b'a', b'a', b'a'], + [b'a', b'a', b'a']], dtype='|S1') + + >>> charar = np.char.chararray(charar.shape, itemsize=5) + >>> charar[:] = 'abc' + >>> charar + chararray([[b'abc', b'abc', b'abc'], + [b'abc', b'abc', b'abc'], + [b'abc', b'abc', b'abc']], dtype='|S5') + + """ + def __new__(subtype, shape, itemsize=1, unicode=False, buffer=None, + offset=0, strides=None, order='C'): + if unicode: + dtype = str_ + else: + dtype = bytes_ + + # force itemsize to be a Python int, since using NumPy integer + # types results in itemsize.itemsize being used as the size of + # strings in the new array. + itemsize = int(itemsize) + + if isinstance(buffer, str): + # unicode objects do not have the buffer interface + filler = buffer + buffer = None + else: + filler = None + + if buffer is None: + self = ndarray.__new__(subtype, shape, (dtype, itemsize), + order=order) + else: + self = ndarray.__new__(subtype, shape, (dtype, itemsize), + buffer=buffer, + offset=offset, strides=strides, + order=order) + if filler is not None: + self[...] = filler + + return self + + def __array_wrap__(self, arr, context=None, return_scalar=False): + # When calling a ufunc (and some other functions), we return a + # chararray if the ufunc output is a string-like array, + # or an ndarray otherwise + if arr.dtype.char in "SUbc": + return arr.view(type(self)) + return arr + + def __array_finalize__(self, obj): + # The b is a special case because it is used for reconstructing. + if self.dtype.char not in 'VSUbc': + raise ValueError("Can only create a chararray from string data.") + + def __getitem__(self, obj): + val = ndarray.__getitem__(self, obj) + if isinstance(val, character): + return val.rstrip() + return val + + # IMPLEMENTATION NOTE: Most of the methods of this class are + # direct delegations to the free functions in this module. + # However, those that return an array of strings should instead + # return a chararray, so some extra wrapping is required. + + def __eq__(self, other): + """ + Return (self == other) element-wise. + + See Also + -------- + equal + """ + return equal(self, other) + + def __ne__(self, other): + """ + Return (self != other) element-wise. + + See Also + -------- + not_equal + """ + return not_equal(self, other) + + def __ge__(self, other): + """ + Return (self >= other) element-wise. + + See Also + -------- + greater_equal + """ + return greater_equal(self, other) + + def __le__(self, other): + """ + Return (self <= other) element-wise. + + See Also + -------- + less_equal + """ + return less_equal(self, other) + + def __gt__(self, other): + """ + Return (self > other) element-wise. + + See Also + -------- + greater + """ + return greater(self, other) + + def __lt__(self, other): + """ + Return (self < other) element-wise. + + See Also + -------- + less + """ + return less(self, other) + + def __add__(self, other): + """ + Return (self + other), that is string concatenation, + element-wise for a pair of array_likes of str or unicode. + + See Also + -------- + add + """ + return add(self, other) + + def __radd__(self, other): + """ + Return (other + self), that is string concatenation, + element-wise for a pair of array_likes of `bytes_` or `str_`. + + See Also + -------- + add + """ + return add(other, self) + + def __mul__(self, i): + """ + Return (self * i), that is string multiple concatenation, + element-wise. + + See Also + -------- + multiply + """ + return asarray(multiply(self, i)) + + def __rmul__(self, i): + """ + Return (self * i), that is string multiple concatenation, + element-wise. + + See Also + -------- + multiply + """ + return asarray(multiply(self, i)) + + def __mod__(self, i): + """ + Return (self % i), that is pre-Python 2.6 string formatting + (interpolation), element-wise for a pair of array_likes of `bytes_` + or `str_`. + + See Also + -------- + mod + """ + return asarray(mod(self, i)) + + def __rmod__(self, other): + return NotImplemented + + def argsort(self, axis=-1, kind=None, order=None): + """ + Return the indices that sort the array lexicographically. + + For full documentation see `numpy.argsort`, for which this method is + in fact merely a "thin wrapper." + + Examples + -------- + >>> c = np.array(['a1b c', '1b ca', 'b ca1', 'Ca1b'], 'S5') + >>> c = c.view(np.char.chararray); c + chararray(['a1b c', '1b ca', 'b ca1', 'Ca1b'], + dtype='|S5') + >>> c[c.argsort()] + chararray(['1b ca', 'Ca1b', 'a1b c', 'b ca1'], + dtype='|S5') + + """ + return self.__array__().argsort(axis, kind, order) + argsort.__doc__ = ndarray.argsort.__doc__ + + def capitalize(self): + """ + Return a copy of `self` with only the first character of each element + capitalized. + + See Also + -------- + char.capitalize + + """ + return asarray(capitalize(self)) + + def center(self, width, fillchar=' '): + """ + Return a copy of `self` with its elements centered in a + string of length `width`. + + See Also + -------- + center + """ + return asarray(center(self, width, fillchar)) + + def count(self, sub, start=0, end=None): + """ + Returns an array with the number of non-overlapping occurrences of + substring `sub` in the range [`start`, `end`]. + + See Also + -------- + char.count + + """ + return count(self, sub, start, end) + + def decode(self, encoding=None, errors=None): + """ + Calls ``bytes.decode`` element-wise. + + See Also + -------- + char.decode + + """ + return decode(self, encoding, errors) + + def encode(self, encoding=None, errors=None): + """ + Calls :meth:`str.encode` element-wise. + + See Also + -------- + char.encode + + """ + return encode(self, encoding, errors) + + def endswith(self, suffix, start=0, end=None): + """ + Returns a boolean array which is `True` where the string element + in `self` ends with `suffix`, otherwise `False`. + + See Also + -------- + char.endswith + + """ + return endswith(self, suffix, start, end) + + def expandtabs(self, tabsize=8): + """ + Return a copy of each string element where all tab characters are + replaced by one or more spaces. + + See Also + -------- + char.expandtabs + + """ + return asarray(expandtabs(self, tabsize)) + + def find(self, sub, start=0, end=None): + """ + For each element, return the lowest index in the string where + substring `sub` is found. + + See Also + -------- + char.find + + """ + return find(self, sub, start, end) + + def index(self, sub, start=0, end=None): + """ + Like `find`, but raises :exc:`ValueError` when the substring is not + found. + + See Also + -------- + char.index + + """ + return index(self, sub, start, end) + + def isalnum(self): + """ + Returns true for each element if all characters in the string + are alphanumeric and there is at least one character, false + otherwise. + + See Also + -------- + char.isalnum + + """ + return isalnum(self) + + def isalpha(self): + """ + Returns true for each element if all characters in the string + are alphabetic and there is at least one character, false + otherwise. + + See Also + -------- + char.isalpha + + """ + return isalpha(self) + + def isdigit(self): + """ + Returns true for each element if all characters in the string are + digits and there is at least one character, false otherwise. + + See Also + -------- + char.isdigit + + """ + return isdigit(self) + + def islower(self): + """ + Returns true for each element if all cased characters in the + string are lowercase and there is at least one cased character, + false otherwise. + + See Also + -------- + char.islower + + """ + return islower(self) + + def isspace(self): + """ + Returns true for each element if there are only whitespace + characters in the string and there is at least one character, + false otherwise. + + See Also + -------- + char.isspace + + """ + return isspace(self) + + def istitle(self): + """ + Returns true for each element if the element is a titlecased + string and there is at least one character, false otherwise. + + See Also + -------- + char.istitle + + """ + return istitle(self) + + def isupper(self): + """ + Returns true for each element if all cased characters in the + string are uppercase and there is at least one character, false + otherwise. + + See Also + -------- + char.isupper + + """ + return isupper(self) + + def join(self, seq): + """ + Return a string which is the concatenation of the strings in the + sequence `seq`. + + See Also + -------- + char.join + + """ + return join(self, seq) + + def ljust(self, width, fillchar=' '): + """ + Return an array with the elements of `self` left-justified in a + string of length `width`. + + See Also + -------- + char.ljust + + """ + return asarray(ljust(self, width, fillchar)) + + def lower(self): + """ + Return an array with the elements of `self` converted to + lowercase. + + See Also + -------- + char.lower + + """ + return asarray(lower(self)) + + def lstrip(self, chars=None): + """ + For each element in `self`, return a copy with the leading characters + removed. + + See Also + -------- + char.lstrip + + """ + return lstrip(self, chars) + + def partition(self, sep): + """ + Partition each element in `self` around `sep`. + + See Also + -------- + partition + """ + return asarray(partition(self, sep)) + + def replace(self, old, new, count=None): + """ + For each element in `self`, return a copy of the string with all + occurrences of substring `old` replaced by `new`. + + See Also + -------- + char.replace + + """ + return replace(self, old, new, count if count is not None else -1) + + def rfind(self, sub, start=0, end=None): + """ + For each element in `self`, return the highest index in the string + where substring `sub` is found, such that `sub` is contained + within [`start`, `end`]. + + See Also + -------- + char.rfind + + """ + return rfind(self, sub, start, end) + + def rindex(self, sub, start=0, end=None): + """ + Like `rfind`, but raises :exc:`ValueError` when the substring `sub` is + not found. + + See Also + -------- + char.rindex + + """ + return rindex(self, sub, start, end) + + def rjust(self, width, fillchar=' '): + """ + Return an array with the elements of `self` + right-justified in a string of length `width`. + + See Also + -------- + char.rjust + + """ + return asarray(rjust(self, width, fillchar)) + + def rpartition(self, sep): + """ + Partition each element in `self` around `sep`. + + See Also + -------- + rpartition + """ + return asarray(rpartition(self, sep)) + + def rsplit(self, sep=None, maxsplit=None): + """ + For each element in `self`, return a list of the words in + the string, using `sep` as the delimiter string. + + See Also + -------- + char.rsplit + + """ + return rsplit(self, sep, maxsplit) + + def rstrip(self, chars=None): + """ + For each element in `self`, return a copy with the trailing + characters removed. + + See Also + -------- + char.rstrip + + """ + return rstrip(self, chars) + + def split(self, sep=None, maxsplit=None): + """ + For each element in `self`, return a list of the words in the + string, using `sep` as the delimiter string. + + See Also + -------- + char.split + + """ + return split(self, sep, maxsplit) + + def splitlines(self, keepends=None): + """ + For each element in `self`, return a list of the lines in the + element, breaking at line boundaries. + + See Also + -------- + char.splitlines + + """ + return splitlines(self, keepends) + + def startswith(self, prefix, start=0, end=None): + """ + Returns a boolean array which is `True` where the string element + in `self` starts with `prefix`, otherwise `False`. + + See Also + -------- + char.startswith + + """ + return startswith(self, prefix, start, end) + + def strip(self, chars=None): + """ + For each element in `self`, return a copy with the leading and + trailing characters removed. + + See Also + -------- + char.strip + + """ + return strip(self, chars) + + def swapcase(self): + """ + For each element in `self`, return a copy of the string with + uppercase characters converted to lowercase and vice versa. + + See Also + -------- + char.swapcase + + """ + return asarray(swapcase(self)) + + def title(self): + """ + For each element in `self`, return a titlecased version of the + string: words start with uppercase characters, all remaining cased + characters are lowercase. + + See Also + -------- + char.title + + """ + return asarray(title(self)) + + def translate(self, table, deletechars=None): + """ + For each element in `self`, return a copy of the string where + all characters occurring in the optional argument + `deletechars` are removed, and the remaining characters have + been mapped through the given translation table. + + See Also + -------- + char.translate + + """ + return asarray(translate(self, table, deletechars)) + + def upper(self): + """ + Return an array with the elements of `self` converted to + uppercase. + + See Also + -------- + char.upper + + """ + return asarray(upper(self)) + + def zfill(self, width): + """ + Return the numeric string left-filled with zeros in a string of + length `width`. + + See Also + -------- + char.zfill + + """ + return asarray(zfill(self, width)) + + def isnumeric(self): + """ + For each element in `self`, return True if there are only + numeric characters in the element. + + See Also + -------- + char.isnumeric + + """ + return isnumeric(self) + + def isdecimal(self): + """ + For each element in `self`, return True if there are only + decimal characters in the element. + + See Also + -------- + char.isdecimal + + """ + return isdecimal(self) + + +@set_module("numpy.char") +def array(obj, itemsize=None, copy=True, unicode=None, order=None): + """ + Create a `~numpy.char.chararray`. + + .. note:: + This class is provided for numarray backward-compatibility. + New code (not concerned with numarray compatibility) should use + arrays of type `bytes_` or `str_` and use the free functions + in :mod:`numpy.char` for fast vectorized string operations instead. + + Versus a NumPy array of dtype `bytes_` or `str_`, this + class adds the following functionality: + + 1) values automatically have whitespace removed from the end + when indexed + + 2) comparison operators automatically remove whitespace from the + end when comparing values + + 3) vectorized string operations are provided as methods + (e.g. `chararray.endswith `) + and infix operators (e.g. ``+, *, %``) + + Parameters + ---------- + obj : array of str or unicode-like + + itemsize : int, optional + `itemsize` is the number of characters per scalar in the + resulting array. If `itemsize` is None, and `obj` is an + object array or a Python list, the `itemsize` will be + automatically determined. If `itemsize` is provided and `obj` + is of type str or unicode, then the `obj` string will be + chunked into `itemsize` pieces. + + copy : bool, optional + If true (default), then the object is copied. Otherwise, a copy + will only be made if ``__array__`` returns a copy, if obj is a + nested sequence, or if a copy is needed to satisfy any of the other + requirements (`itemsize`, unicode, `order`, etc.). + + unicode : bool, optional + When true, the resulting `~numpy.char.chararray` can contain Unicode + characters, when false only 8-bit characters. If unicode is + None and `obj` is one of the following: + + - a `~numpy.char.chararray`, + - an ndarray of type :class:`str_` or :class:`bytes_` + - a Python :class:`str` or :class:`bytes` object, + + then the unicode setting of the output array will be + automatically determined. + + order : {'C', 'F', 'A'}, optional + Specify the order of the array. If order is 'C' (default), then the + array will be in C-contiguous order (last-index varies the + fastest). If order is 'F', then the returned array + will be in Fortran-contiguous order (first-index varies the + fastest). If order is 'A', then the returned array may + be in any order (either C-, Fortran-contiguous, or even + discontiguous). + """ + if isinstance(obj, (bytes, str)): + if unicode is None: + if isinstance(obj, str): + unicode = True + else: + unicode = False + + if itemsize is None: + itemsize = len(obj) + shape = len(obj) // itemsize + + return chararray(shape, itemsize=itemsize, unicode=unicode, + buffer=obj, order=order) + + if isinstance(obj, (list, tuple)): + obj = asnarray(obj) + + if isinstance(obj, ndarray) and issubclass(obj.dtype.type, character): + # If we just have a vanilla chararray, create a chararray + # view around it. + if not isinstance(obj, chararray): + obj = obj.view(chararray) + + if itemsize is None: + itemsize = obj.itemsize + # itemsize is in 8-bit chars, so for Unicode, we need + # to divide by the size of a single Unicode character, + # which for NumPy is always 4 + if issubclass(obj.dtype.type, str_): + itemsize //= 4 + + if unicode is None: + if issubclass(obj.dtype.type, str_): + unicode = True + else: + unicode = False + + if unicode: + dtype = str_ + else: + dtype = bytes_ + + if order is not None: + obj = asnarray(obj, order=order) + if (copy or + (itemsize != obj.itemsize) or + (not unicode and isinstance(obj, str_)) or + (unicode and isinstance(obj, bytes_))): + obj = obj.astype((dtype, int(itemsize))) + return obj + + if isinstance(obj, ndarray) and issubclass(obj.dtype.type, object): + if itemsize is None: + # Since no itemsize was specified, convert the input array to + # a list so the ndarray constructor will automatically + # determine the itemsize for us. + obj = obj.tolist() + # Fall through to the default case + + if unicode: + dtype = str_ + else: + dtype = bytes_ + + if itemsize is None: + val = narray(obj, dtype=dtype, order=order, subok=True) + else: + val = narray(obj, dtype=(dtype, itemsize), order=order, subok=True) + return val.view(chararray) + + +@set_module("numpy.char") +def asarray(obj, itemsize=None, unicode=None, order=None): + """ + Convert the input to a `~numpy.char.chararray`, copying the data only if + necessary. + + Versus a NumPy array of dtype `bytes_` or `str_`, this + class adds the following functionality: + + 1) values automatically have whitespace removed from the end + when indexed + + 2) comparison operators automatically remove whitespace from the + end when comparing values + + 3) vectorized string operations are provided as methods + (e.g. `chararray.endswith `) + and infix operators (e.g. ``+``, ``*``, ``%``) + + Parameters + ---------- + obj : array of str or unicode-like + + itemsize : int, optional + `itemsize` is the number of characters per scalar in the + resulting array. If `itemsize` is None, and `obj` is an + object array or a Python list, the `itemsize` will be + automatically determined. If `itemsize` is provided and `obj` + is of type str or unicode, then the `obj` string will be + chunked into `itemsize` pieces. + + unicode : bool, optional + When true, the resulting `~numpy.char.chararray` can contain Unicode + characters, when false only 8-bit characters. If unicode is + None and `obj` is one of the following: + + - a `~numpy.char.chararray`, + - an ndarray of type `str_` or `unicode_` + - a Python str or unicode object, + + then the unicode setting of the output array will be + automatically determined. + + order : {'C', 'F'}, optional + Specify the order of the array. If order is 'C' (default), then the + array will be in C-contiguous order (last-index varies the + fastest). If order is 'F', then the returned array + will be in Fortran-contiguous order (first-index varies the + fastest). + + Examples + -------- + >>> import numpy as np + >>> np.char.asarray(['hello', 'world']) + chararray(['hello', 'world'], dtype=' chararray[Any, dtype[bytes_]]: ... + @overload + def __new__( + subtype, + shape: _ShapeLike, + itemsize: SupportsIndex | SupportsInt = ..., + unicode: L[True] = ..., + buffer: _SupportsBuffer = ..., + offset: SupportsIndex = ..., + strides: _ShapeLike = ..., + order: _OrderKACF = ..., + ) -> chararray[Any, dtype[str_]]: ... + + def __array_finalize__(self, obj: object) -> None: ... + def __mul__(self, other: i_co) -> chararray[Any, _CharDType]: ... + def __rmul__(self, other: i_co) -> chararray[Any, _CharDType]: ... + def __mod__(self, i: Any) -> chararray[Any, _CharDType]: ... + + @overload + def __eq__( + self: _CharArray[str_], + other: U_co, + ) -> NDArray[np.bool]: ... + @overload + def __eq__( + self: _CharArray[bytes_], + other: S_co, + ) -> NDArray[np.bool]: ... + + @overload + def __ne__( + self: _CharArray[str_], + other: U_co, + ) -> NDArray[np.bool]: ... + @overload + def __ne__( + self: _CharArray[bytes_], + other: S_co, + ) -> NDArray[np.bool]: ... + + @overload + def __ge__( + self: _CharArray[str_], + other: U_co, + ) -> NDArray[np.bool]: ... + @overload + def __ge__( + self: _CharArray[bytes_], + other: S_co, + ) -> NDArray[np.bool]: ... + + @overload + def __le__( + self: _CharArray[str_], + other: U_co, + ) -> NDArray[np.bool]: ... + @overload + def __le__( + self: _CharArray[bytes_], + other: S_co, + ) -> NDArray[np.bool]: ... + + @overload + def __gt__( + self: _CharArray[str_], + other: U_co, + ) -> NDArray[np.bool]: ... + @overload + def __gt__( + self: _CharArray[bytes_], + other: S_co, + ) -> NDArray[np.bool]: ... + + @overload + def __lt__( + self: _CharArray[str_], + other: U_co, + ) -> NDArray[np.bool]: ... + @overload + def __lt__( + self: _CharArray[bytes_], + other: S_co, + ) -> NDArray[np.bool]: ... + + @overload + def __add__( + self: _CharArray[str_], + other: U_co, + ) -> _CharArray[str_]: ... + @overload + def __add__( + self: _CharArray[bytes_], + other: S_co, + ) -> _CharArray[bytes_]: ... + + @overload + def __radd__( + self: _CharArray[str_], + other: U_co, + ) -> _CharArray[str_]: ... + @overload + def __radd__( + self: _CharArray[bytes_], + other: S_co, + ) -> _CharArray[bytes_]: ... + + @overload + def center( + self: _CharArray[str_], + width: i_co, + fillchar: U_co = ..., + ) -> _CharArray[str_]: ... + @overload + def center( + self: _CharArray[bytes_], + width: i_co, + fillchar: S_co = ..., + ) -> _CharArray[bytes_]: ... + + @overload + def count( + self: _CharArray[str_], + sub: U_co, + start: i_co = ..., + end: None | i_co = ..., + ) -> NDArray[int_]: ... + @overload + def count( + self: _CharArray[bytes_], + sub: S_co, + start: i_co = ..., + end: None | i_co = ..., + ) -> NDArray[int_]: ... + + def decode( + self: _CharArray[bytes_], + encoding: None | str = ..., + errors: None | str = ..., + ) -> _CharArray[str_]: ... + + def encode( + self: _CharArray[str_], + encoding: None | str = ..., + errors: None | str = ..., + ) -> _CharArray[bytes_]: ... + + @overload + def endswith( + self: _CharArray[str_], + suffix: U_co, + start: i_co = ..., + end: None | i_co = ..., + ) -> NDArray[np.bool]: ... + @overload + def endswith( + self: _CharArray[bytes_], + suffix: S_co, + start: i_co = ..., + end: None | i_co = ..., + ) -> NDArray[np.bool]: ... + + def expandtabs( + self, + tabsize: i_co = ..., + ) -> chararray[Any, _CharDType]: ... + + @overload + def find( + self: _CharArray[str_], + sub: U_co, + start: i_co = ..., + end: None | i_co = ..., + ) -> NDArray[int_]: ... + @overload + def find( + self: _CharArray[bytes_], + sub: S_co, + start: i_co = ..., + end: None | i_co = ..., + ) -> NDArray[int_]: ... + + @overload + def index( + self: _CharArray[str_], + sub: U_co, + start: i_co = ..., + end: None | i_co = ..., + ) -> NDArray[int_]: ... + @overload + def index( + self: _CharArray[bytes_], + sub: S_co, + start: i_co = ..., + end: None | i_co = ..., + ) -> NDArray[int_]: ... + + @overload + def join( + self: _CharArray[str_], + seq: U_co, + ) -> _CharArray[str_]: ... + @overload + def join( + self: _CharArray[bytes_], + seq: S_co, + ) -> _CharArray[bytes_]: ... + + @overload + def ljust( + self: _CharArray[str_], + width: i_co, + fillchar: U_co = ..., + ) -> _CharArray[str_]: ... + @overload + def ljust( + self: _CharArray[bytes_], + width: i_co, + fillchar: S_co = ..., + ) -> _CharArray[bytes_]: ... + + @overload + def lstrip( + self: _CharArray[str_], + chars: None | U_co = ..., + ) -> _CharArray[str_]: ... + @overload + def lstrip( + self: _CharArray[bytes_], + chars: None | S_co = ..., + ) -> _CharArray[bytes_]: ... + + @overload + def partition( + self: _CharArray[str_], + sep: U_co, + ) -> _CharArray[str_]: ... + @overload + def partition( + self: _CharArray[bytes_], + sep: S_co, + ) -> _CharArray[bytes_]: ... + + @overload + def replace( + self: _CharArray[str_], + old: U_co, + new: U_co, + count: None | i_co = ..., + ) -> _CharArray[str_]: ... + @overload + def replace( + self: _CharArray[bytes_], + old: S_co, + new: S_co, + count: None | i_co = ..., + ) -> _CharArray[bytes_]: ... + + @overload + def rfind( + self: _CharArray[str_], + sub: U_co, + start: i_co = ..., + end: None | i_co = ..., + ) -> NDArray[int_]: ... + @overload + def rfind( + self: _CharArray[bytes_], + sub: S_co, + start: i_co = ..., + end: None | i_co = ..., + ) -> NDArray[int_]: ... + + @overload + def rindex( + self: _CharArray[str_], + sub: U_co, + start: i_co = ..., + end: None | i_co = ..., + ) -> NDArray[int_]: ... + @overload + def rindex( + self: _CharArray[bytes_], + sub: S_co, + start: i_co = ..., + end: None | i_co = ..., + ) -> NDArray[int_]: ... + + @overload + def rjust( + self: _CharArray[str_], + width: i_co, + fillchar: U_co = ..., + ) -> _CharArray[str_]: ... + @overload + def rjust( + self: _CharArray[bytes_], + width: i_co, + fillchar: S_co = ..., + ) -> _CharArray[bytes_]: ... + + @overload + def rpartition( + self: _CharArray[str_], + sep: U_co, + ) -> _CharArray[str_]: ... + @overload + def rpartition( + self: _CharArray[bytes_], + sep: S_co, + ) -> _CharArray[bytes_]: ... + + @overload + def rsplit( + self: _CharArray[str_], + sep: None | U_co = ..., + maxsplit: None | i_co = ..., + ) -> NDArray[object_]: ... + @overload + def rsplit( + self: _CharArray[bytes_], + sep: None | S_co = ..., + maxsplit: None | i_co = ..., + ) -> NDArray[object_]: ... + + @overload + def rstrip( + self: _CharArray[str_], + chars: None | U_co = ..., + ) -> _CharArray[str_]: ... + @overload + def rstrip( + self: _CharArray[bytes_], + chars: None | S_co = ..., + ) -> _CharArray[bytes_]: ... + + @overload + def split( + self: _CharArray[str_], + sep: None | U_co = ..., + maxsplit: None | i_co = ..., + ) -> NDArray[object_]: ... + @overload + def split( + self: _CharArray[bytes_], + sep: None | S_co = ..., + maxsplit: None | i_co = ..., + ) -> NDArray[object_]: ... + + def splitlines(self, keepends: None | b_co = ...) -> NDArray[object_]: ... + + @overload + def startswith( + self: _CharArray[str_], + prefix: U_co, + start: i_co = ..., + end: None | i_co = ..., + ) -> NDArray[np.bool]: ... + @overload + def startswith( + self: _CharArray[bytes_], + prefix: S_co, + start: i_co = ..., + end: None | i_co = ..., + ) -> NDArray[np.bool]: ... + + @overload + def strip( + self: _CharArray[str_], + chars: None | U_co = ..., + ) -> _CharArray[str_]: ... + @overload + def strip( + self: _CharArray[bytes_], + chars: None | S_co = ..., + ) -> _CharArray[bytes_]: ... + + @overload + def translate( + self: _CharArray[str_], + table: U_co, + deletechars: None | U_co = ..., + ) -> _CharArray[str_]: ... + @overload + def translate( + self: _CharArray[bytes_], + table: S_co, + deletechars: None | S_co = ..., + ) -> _CharArray[bytes_]: ... + + def zfill(self, width: _ArrayLikeInt_co) -> chararray[Any, _CharDType]: ... + def capitalize(self) -> chararray[_ShapeType_co, _CharDType]: ... + def title(self) -> chararray[_ShapeType_co, _CharDType]: ... + def swapcase(self) -> chararray[_ShapeType_co, _CharDType]: ... + def lower(self) -> chararray[_ShapeType_co, _CharDType]: ... + def upper(self) -> chararray[_ShapeType_co, _CharDType]: ... + def isalnum(self) -> ndarray[_ShapeType_co, dtype[np.bool]]: ... + def isalpha(self) -> ndarray[_ShapeType_co, dtype[np.bool]]: ... + def isdigit(self) -> ndarray[_ShapeType_co, dtype[np.bool]]: ... + def islower(self) -> ndarray[_ShapeType_co, dtype[np.bool]]: ... + def isspace(self) -> ndarray[_ShapeType_co, dtype[np.bool]]: ... + def istitle(self) -> ndarray[_ShapeType_co, dtype[np.bool]]: ... + def isupper(self) -> ndarray[_ShapeType_co, dtype[np.bool]]: ... + def isnumeric(self) -> ndarray[_ShapeType_co, dtype[np.bool]]: ... + def isdecimal(self) -> ndarray[_ShapeType_co, dtype[np.bool]]: ... + +__all__: list[str] + +# Comparison +@overload +def equal(x1: U_co, x2: U_co) -> NDArray[np.bool]: ... +@overload +def equal(x1: S_co, x2: S_co) -> NDArray[np.bool]: ... + +@overload +def not_equal(x1: U_co, x2: U_co) -> NDArray[np.bool]: ... +@overload +def not_equal(x1: S_co, x2: S_co) -> NDArray[np.bool]: ... + +@overload +def greater_equal(x1: U_co, x2: U_co) -> NDArray[np.bool]: ... +@overload +def greater_equal(x1: S_co, x2: S_co) -> NDArray[np.bool]: ... + +@overload +def less_equal(x1: U_co, x2: U_co) -> NDArray[np.bool]: ... +@overload +def less_equal(x1: S_co, x2: S_co) -> NDArray[np.bool]: ... + +@overload +def greater(x1: U_co, x2: U_co) -> NDArray[np.bool]: ... +@overload +def greater(x1: S_co, x2: S_co) -> NDArray[np.bool]: ... + +@overload +def less(x1: U_co, x2: U_co) -> NDArray[np.bool]: ... +@overload +def less(x1: S_co, x2: S_co) -> NDArray[np.bool]: ... + +# String operations +@overload +def add(x1: U_co, x2: U_co) -> NDArray[str_]: ... +@overload +def add(x1: S_co, x2: S_co) -> NDArray[bytes_]: ... + +@overload +def multiply(a: U_co, i: i_co) -> NDArray[str_]: ... +@overload +def multiply(a: S_co, i: i_co) -> NDArray[bytes_]: ... + +@overload +def mod(a: U_co, value: Any) -> NDArray[str_]: ... +@overload +def mod(a: S_co, value: Any) -> NDArray[bytes_]: ... + +@overload +def capitalize(a: U_co) -> NDArray[str_]: ... +@overload +def capitalize(a: S_co) -> NDArray[bytes_]: ... + +@overload +def center(a: U_co, width: i_co, fillchar: U_co = ...) -> NDArray[str_]: ... +@overload +def center(a: S_co, width: i_co, fillchar: S_co = ...) -> NDArray[bytes_]: ... + +def decode( + a: S_co, + encoding: None | str = ..., + errors: None | str = ..., +) -> NDArray[str_]: ... + +def encode( + a: U_co, + encoding: None | str = ..., + errors: None | str = ..., +) -> NDArray[bytes_]: ... + +@overload +def expandtabs(a: U_co, tabsize: i_co = ...) -> NDArray[str_]: ... +@overload +def expandtabs(a: S_co, tabsize: i_co = ...) -> NDArray[bytes_]: ... + +@overload +def join(sep: U_co, seq: U_co) -> NDArray[str_]: ... +@overload +def join(sep: S_co, seq: S_co) -> NDArray[bytes_]: ... + +@overload +def ljust(a: U_co, width: i_co, fillchar: U_co = ...) -> NDArray[str_]: ... +@overload +def ljust(a: S_co, width: i_co, fillchar: S_co = ...) -> NDArray[bytes_]: ... + +@overload +def lower(a: U_co) -> NDArray[str_]: ... +@overload +def lower(a: S_co) -> NDArray[bytes_]: ... + +@overload +def lstrip(a: U_co, chars: None | U_co = ...) -> NDArray[str_]: ... +@overload +def lstrip(a: S_co, chars: None | S_co = ...) -> NDArray[bytes_]: ... + +@overload +def partition(a: U_co, sep: U_co) -> NDArray[str_]: ... +@overload +def partition(a: S_co, sep: S_co) -> NDArray[bytes_]: ... + +@overload +def replace( + a: U_co, + old: U_co, + new: U_co, + count: None | i_co = ..., +) -> NDArray[str_]: ... +@overload +def replace( + a: S_co, + old: S_co, + new: S_co, + count: None | i_co = ..., +) -> NDArray[bytes_]: ... + +@overload +def rjust( + a: U_co, + width: i_co, + fillchar: U_co = ..., +) -> NDArray[str_]: ... +@overload +def rjust( + a: S_co, + width: i_co, + fillchar: S_co = ..., +) -> NDArray[bytes_]: ... + +@overload +def rpartition(a: U_co, sep: U_co) -> NDArray[str_]: ... +@overload +def rpartition(a: S_co, sep: S_co) -> NDArray[bytes_]: ... + +@overload +def rsplit( + a: U_co, + sep: None | U_co = ..., + maxsplit: None | i_co = ..., +) -> NDArray[object_]: ... +@overload +def rsplit( + a: S_co, + sep: None | S_co = ..., + maxsplit: None | i_co = ..., +) -> NDArray[object_]: ... + +@overload +def rstrip(a: U_co, chars: None | U_co = ...) -> NDArray[str_]: ... +@overload +def rstrip(a: S_co, chars: None | S_co = ...) -> NDArray[bytes_]: ... + +@overload +def split( + a: U_co, + sep: None | U_co = ..., + maxsplit: None | i_co = ..., +) -> NDArray[object_]: ... +@overload +def split( + a: S_co, + sep: None | S_co = ..., + maxsplit: None | i_co = ..., +) -> NDArray[object_]: ... + +@overload +def splitlines(a: U_co, keepends: None | b_co = ...) -> NDArray[object_]: ... +@overload +def splitlines(a: S_co, keepends: None | b_co = ...) -> NDArray[object_]: ... + +@overload +def strip(a: U_co, chars: None | U_co = ...) -> NDArray[str_]: ... +@overload +def strip(a: S_co, chars: None | S_co = ...) -> NDArray[bytes_]: ... + +@overload +def swapcase(a: U_co) -> NDArray[str_]: ... +@overload +def swapcase(a: S_co) -> NDArray[bytes_]: ... + +@overload +def title(a: U_co) -> NDArray[str_]: ... +@overload +def title(a: S_co) -> NDArray[bytes_]: ... + +@overload +def translate( + a: U_co, + table: U_co, + deletechars: None | U_co = ..., +) -> NDArray[str_]: ... +@overload +def translate( + a: S_co, + table: S_co, + deletechars: None | S_co = ..., +) -> NDArray[bytes_]: ... + +@overload +def upper(a: U_co) -> NDArray[str_]: ... +@overload +def upper(a: S_co) -> NDArray[bytes_]: ... + +@overload +def zfill(a: U_co, width: i_co) -> NDArray[str_]: ... +@overload +def zfill(a: S_co, width: i_co) -> NDArray[bytes_]: ... + +# String information +@overload +def count( + a: U_co, + sub: U_co, + start: i_co = ..., + end: None | i_co = ..., +) -> NDArray[int_]: ... +@overload +def count( + a: S_co, + sub: S_co, + start: i_co = ..., + end: None | i_co = ..., +) -> NDArray[int_]: ... + +@overload +def endswith( + a: U_co, + suffix: U_co, + start: i_co = ..., + end: None | i_co = ..., +) -> NDArray[np.bool]: ... +@overload +def endswith( + a: S_co, + suffix: S_co, + start: i_co = ..., + end: None | i_co = ..., +) -> NDArray[np.bool]: ... + +@overload +def find( + a: U_co, + sub: U_co, + start: i_co = ..., + end: None | i_co = ..., +) -> NDArray[int_]: ... +@overload +def find( + a: S_co, + sub: S_co, + start: i_co = ..., + end: None | i_co = ..., +) -> NDArray[int_]: ... + +@overload +def index( + a: U_co, + sub: U_co, + start: i_co = ..., + end: None | i_co = ..., +) -> NDArray[int_]: ... +@overload +def index( + a: S_co, + sub: S_co, + start: i_co = ..., + end: None | i_co = ..., +) -> NDArray[int_]: ... + +def isalpha(a: U_co | S_co) -> NDArray[np.bool]: ... +def isalnum(a: U_co | S_co) -> NDArray[np.bool]: ... +def isdecimal(a: U_co) -> NDArray[np.bool]: ... +def isdigit(a: U_co | S_co) -> NDArray[np.bool]: ... +def islower(a: U_co | S_co) -> NDArray[np.bool]: ... +def isnumeric(a: U_co) -> NDArray[np.bool]: ... +def isspace(a: U_co | S_co) -> NDArray[np.bool]: ... +def istitle(a: U_co | S_co) -> NDArray[np.bool]: ... +def isupper(a: U_co | S_co) -> NDArray[np.bool]: ... + +@overload +def rfind( + a: U_co, + sub: U_co, + start: i_co = ..., + end: None | i_co = ..., +) -> NDArray[int_]: ... +@overload +def rfind( + a: S_co, + sub: S_co, + start: i_co = ..., + end: None | i_co = ..., +) -> NDArray[int_]: ... + +@overload +def rindex( + a: U_co, + sub: U_co, + start: i_co = ..., + end: None | i_co = ..., +) -> NDArray[int_]: ... +@overload +def rindex( + a: S_co, + sub: S_co, + start: i_co = ..., + end: None | i_co = ..., +) -> NDArray[int_]: ... + +@overload +def startswith( + a: U_co, + prefix: U_co, + start: i_co = ..., + end: None | i_co = ..., +) -> NDArray[np.bool]: ... +@overload +def startswith( + a: S_co, + prefix: S_co, + start: i_co = ..., + end: None | i_co = ..., +) -> NDArray[np.bool]: ... + +def str_len(A: U_co | S_co) -> NDArray[int_]: ... + +# Overload 1 and 2: str- or bytes-based array-likes +# overload 3: arbitrary object with unicode=False (-> bytes_) +# overload 4: arbitrary object with unicode=True (-> str_) +@overload +def array( + obj: U_co, + itemsize: None | int = ..., + copy: bool = ..., + unicode: L[False] = ..., + order: _OrderKACF = ..., +) -> _CharArray[str_]: ... +@overload +def array( + obj: S_co, + itemsize: None | int = ..., + copy: bool = ..., + unicode: L[False] = ..., + order: _OrderKACF = ..., +) -> _CharArray[bytes_]: ... +@overload +def array( + obj: object, + itemsize: None | int = ..., + copy: bool = ..., + unicode: L[False] = ..., + order: _OrderKACF = ..., +) -> _CharArray[bytes_]: ... +@overload +def array( + obj: object, + itemsize: None | int = ..., + copy: bool = ..., + unicode: L[True] = ..., + order: _OrderKACF = ..., +) -> _CharArray[str_]: ... + +@overload +def asarray( + obj: U_co, + itemsize: None | int = ..., + unicode: L[False] = ..., + order: _OrderKACF = ..., +) -> _CharArray[str_]: ... +@overload +def asarray( + obj: S_co, + itemsize: None | int = ..., + unicode: L[False] = ..., + order: _OrderKACF = ..., +) -> _CharArray[bytes_]: ... +@overload +def asarray( + obj: object, + itemsize: None | int = ..., + unicode: L[False] = ..., + order: _OrderKACF = ..., +) -> _CharArray[bytes_]: ... +@overload +def asarray( + obj: object, + itemsize: None | int = ..., + unicode: L[True] = ..., + order: _OrderKACF = ..., +) -> _CharArray[str_]: ... diff --git a/venv/lib/python3.12/site-packages/numpy/_core/einsumfunc.py b/venv/lib/python3.12/site-packages/numpy/_core/einsumfunc.py new file mode 100644 index 00000000..7aa5f22f --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/einsumfunc.py @@ -0,0 +1,1505 @@ +""" +Implementation of optimized einsum. + +""" +import itertools +import operator + +from numpy._core.multiarray import c_einsum +from numpy._core.numeric import asanyarray, tensordot +from numpy._core.overrides import array_function_dispatch + +__all__ = ['einsum', 'einsum_path'] + +# importing string for string.ascii_letters would be too slow +# the first import before caching has been measured to take 800 µs (#23777) +einsum_symbols = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ' +einsum_symbols_set = set(einsum_symbols) + + +def _flop_count(idx_contraction, inner, num_terms, size_dictionary): + """ + Computes the number of FLOPS in the contraction. + + Parameters + ---------- + idx_contraction : iterable + The indices involved in the contraction + inner : bool + Does this contraction require an inner product? + num_terms : int + The number of terms in a contraction + size_dictionary : dict + The size of each of the indices in idx_contraction + + Returns + ------- + flop_count : int + The total number of FLOPS required for the contraction. + + Examples + -------- + + >>> _flop_count('abc', False, 1, {'a': 2, 'b':3, 'c':5}) + 30 + + >>> _flop_count('abc', True, 2, {'a': 2, 'b':3, 'c':5}) + 60 + + """ + + overall_size = _compute_size_by_dict(idx_contraction, size_dictionary) + op_factor = max(1, num_terms - 1) + if inner: + op_factor += 1 + + return overall_size * op_factor + +def _compute_size_by_dict(indices, idx_dict): + """ + Computes the product of the elements in indices based on the dictionary + idx_dict. + + Parameters + ---------- + indices : iterable + Indices to base the product on. + idx_dict : dictionary + Dictionary of index sizes + + Returns + ------- + ret : int + The resulting product. + + Examples + -------- + >>> _compute_size_by_dict('abbc', {'a': 2, 'b':3, 'c':5}) + 90 + + """ + ret = 1 + for i in indices: + ret *= idx_dict[i] + return ret + + +def _find_contraction(positions, input_sets, output_set): + """ + Finds the contraction for a given set of input and output sets. + + Parameters + ---------- + positions : iterable + Integer positions of terms used in the contraction. + input_sets : list + List of sets that represent the lhs side of the einsum subscript + output_set : set + Set that represents the rhs side of the overall einsum subscript + + Returns + ------- + new_result : set + The indices of the resulting contraction + remaining : list + List of sets that have not been contracted, the new set is appended to + the end of this list + idx_removed : set + Indices removed from the entire contraction + idx_contraction : set + The indices used in the current contraction + + Examples + -------- + + # A simple dot product test case + >>> pos = (0, 1) + >>> isets = [set('ab'), set('bc')] + >>> oset = set('ac') + >>> _find_contraction(pos, isets, oset) + ({'a', 'c'}, [{'a', 'c'}], {'b'}, {'a', 'b', 'c'}) + + # A more complex case with additional terms in the contraction + >>> pos = (0, 2) + >>> isets = [set('abd'), set('ac'), set('bdc')] + >>> oset = set('ac') + >>> _find_contraction(pos, isets, oset) + ({'a', 'c'}, [{'a', 'c'}, {'a', 'c'}], {'b', 'd'}, {'a', 'b', 'c', 'd'}) + """ + + idx_contract = set() + idx_remain = output_set.copy() + remaining = [] + for ind, value in enumerate(input_sets): + if ind in positions: + idx_contract |= value + else: + remaining.append(value) + idx_remain |= value + + new_result = idx_remain & idx_contract + idx_removed = (idx_contract - new_result) + remaining.append(new_result) + + return (new_result, remaining, idx_removed, idx_contract) + + +def _optimal_path(input_sets, output_set, idx_dict, memory_limit): + """ + Computes all possible pair contractions, sieves the results based + on ``memory_limit`` and returns the lowest cost path. This algorithm + scales factorial with respect to the elements in the list ``input_sets``. + + Parameters + ---------- + input_sets : list + List of sets that represent the lhs side of the einsum subscript + output_set : set + Set that represents the rhs side of the overall einsum subscript + idx_dict : dictionary + Dictionary of index sizes + memory_limit : int + The maximum number of elements in a temporary array + + Returns + ------- + path : list + The optimal contraction order within the memory limit constraint. + + Examples + -------- + >>> isets = [set('abd'), set('ac'), set('bdc')] + >>> oset = set() + >>> idx_sizes = {'a': 1, 'b':2, 'c':3, 'd':4} + >>> _optimal_path(isets, oset, idx_sizes, 5000) + [(0, 2), (0, 1)] + """ + + full_results = [(0, [], input_sets)] + for iteration in range(len(input_sets) - 1): + iter_results = [] + + # Compute all unique pairs + for curr in full_results: + cost, positions, remaining = curr + for con in itertools.combinations( + range(len(input_sets) - iteration), 2 + ): + + # Find the contraction + cont = _find_contraction(con, remaining, output_set) + new_result, new_input_sets, idx_removed, idx_contract = cont + + # Sieve the results based on memory_limit + new_size = _compute_size_by_dict(new_result, idx_dict) + if new_size > memory_limit: + continue + + # Build (total_cost, positions, indices_remaining) + total_cost = cost + _flop_count( + idx_contract, idx_removed, len(con), idx_dict + ) + new_pos = positions + [con] + iter_results.append((total_cost, new_pos, new_input_sets)) + + # Update combinatorial list, if we did not find anything return best + # path + remaining contractions + if iter_results: + full_results = iter_results + else: + path = min(full_results, key=lambda x: x[0])[1] + path += [tuple(range(len(input_sets) - iteration))] + return path + + # If we have not found anything return single einsum contraction + if len(full_results) == 0: + return [tuple(range(len(input_sets)))] + + path = min(full_results, key=lambda x: x[0])[1] + return path + +def _parse_possible_contraction( + positions, input_sets, output_set, idx_dict, + memory_limit, path_cost, naive_cost + ): + """Compute the cost (removed size + flops) and resultant indices for + performing the contraction specified by ``positions``. + + Parameters + ---------- + positions : tuple of int + The locations of the proposed tensors to contract. + input_sets : list of sets + The indices found on each tensors. + output_set : set + The output indices of the expression. + idx_dict : dict + Mapping of each index to its size. + memory_limit : int + The total allowed size for an intermediary tensor. + path_cost : int + The contraction cost so far. + naive_cost : int + The cost of the unoptimized expression. + + Returns + ------- + cost : (int, int) + A tuple containing the size of any indices removed, and the flop cost. + positions : tuple of int + The locations of the proposed tensors to contract. + new_input_sets : list of sets + The resulting new list of indices if this proposed contraction + is performed. + + """ + + # Find the contraction + contract = _find_contraction(positions, input_sets, output_set) + idx_result, new_input_sets, idx_removed, idx_contract = contract + + # Sieve the results based on memory_limit + new_size = _compute_size_by_dict(idx_result, idx_dict) + if new_size > memory_limit: + return None + + # Build sort tuple + old_sizes = ( + _compute_size_by_dict(input_sets[p], idx_dict) for p in positions + ) + removed_size = sum(old_sizes) - new_size + + # NB: removed_size used to be just the size of any removed indices i.e.: + # helpers.compute_size_by_dict(idx_removed, idx_dict) + cost = _flop_count(idx_contract, idx_removed, len(positions), idx_dict) + sort = (-removed_size, cost) + + # Sieve based on total cost as well + if (path_cost + cost) > naive_cost: + return None + + # Add contraction to possible choices + return [sort, positions, new_input_sets] + + +def _update_other_results(results, best): + """Update the positions and provisional input_sets of ``results`` + based on performing the contraction result ``best``. Remove any + involving the tensors contracted. + + Parameters + ---------- + results : list + List of contraction results produced by + ``_parse_possible_contraction``. + best : list + The best contraction of ``results`` i.e. the one that + will be performed. + + Returns + ------- + mod_results : list + The list of modified results, updated with outcome of + ``best`` contraction. + """ + + best_con = best[1] + bx, by = best_con + mod_results = [] + + for cost, (x, y), con_sets in results: + + # Ignore results involving tensors just contracted + if x in best_con or y in best_con: + continue + + # Update the input_sets + del con_sets[by - int(by > x) - int(by > y)] + del con_sets[bx - int(bx > x) - int(bx > y)] + con_sets.insert(-1, best[2][-1]) + + # Update the position indices + mod_con = x - int(x > bx) - int(x > by), y - int(y > bx) - int(y > by) + mod_results.append((cost, mod_con, con_sets)) + + return mod_results + +def _greedy_path(input_sets, output_set, idx_dict, memory_limit): + """ + Finds the path by contracting the best pair until the input list is + exhausted. The best pair is found by minimizing the tuple + ``(-prod(indices_removed), cost)``. What this amounts to is prioritizing + matrix multiplication or inner product operations, then Hadamard like + operations, and finally outer operations. Outer products are limited by + ``memory_limit``. This algorithm scales cubically with respect to the + number of elements in the list ``input_sets``. + + Parameters + ---------- + input_sets : list + List of sets that represent the lhs side of the einsum subscript + output_set : set + Set that represents the rhs side of the overall einsum subscript + idx_dict : dictionary + Dictionary of index sizes + memory_limit : int + The maximum number of elements in a temporary array + + Returns + ------- + path : list + The greedy contraction order within the memory limit constraint. + + Examples + -------- + >>> isets = [set('abd'), set('ac'), set('bdc')] + >>> oset = set() + >>> idx_sizes = {'a': 1, 'b':2, 'c':3, 'd':4} + >>> _greedy_path(isets, oset, idx_sizes, 5000) + [(0, 2), (0, 1)] + """ + + # Handle trivial cases that leaked through + if len(input_sets) == 1: + return [(0,)] + elif len(input_sets) == 2: + return [(0, 1)] + + # Build up a naive cost + contract = _find_contraction( + range(len(input_sets)), input_sets, output_set + ) + idx_result, new_input_sets, idx_removed, idx_contract = contract + naive_cost = _flop_count( + idx_contract, idx_removed, len(input_sets), idx_dict + ) + + # Initially iterate over all pairs + comb_iter = itertools.combinations(range(len(input_sets)), 2) + known_contractions = [] + + path_cost = 0 + path = [] + + for iteration in range(len(input_sets) - 1): + + # Iterate over all pairs on the first step, only previously + # found pairs on subsequent steps + for positions in comb_iter: + + # Always initially ignore outer products + if input_sets[positions[0]].isdisjoint(input_sets[positions[1]]): + continue + + result = _parse_possible_contraction( + positions, input_sets, output_set, idx_dict, + memory_limit, path_cost, naive_cost + ) + if result is not None: + known_contractions.append(result) + + # If we do not have a inner contraction, rescan pairs + # including outer products + if len(known_contractions) == 0: + + # Then check the outer products + for positions in itertools.combinations( + range(len(input_sets)), 2 + ): + result = _parse_possible_contraction( + positions, input_sets, output_set, idx_dict, + memory_limit, path_cost, naive_cost + ) + if result is not None: + known_contractions.append(result) + + # If we still did not find any remaining contractions, + # default back to einsum like behavior + if len(known_contractions) == 0: + path.append(tuple(range(len(input_sets)))) + break + + # Sort based on first index + best = min(known_contractions, key=lambda x: x[0]) + + # Now propagate as many unused contractions as possible + # to the next iteration + known_contractions = _update_other_results(known_contractions, best) + + # Next iteration only compute contractions with the new tensor + # All other contractions have been accounted for + input_sets = best[2] + new_tensor_pos = len(input_sets) - 1 + comb_iter = ((i, new_tensor_pos) for i in range(new_tensor_pos)) + + # Update path and total cost + path.append(best[1]) + path_cost += best[0][1] + + return path + + +def _can_dot(inputs, result, idx_removed): + """ + Checks if we can use BLAS (np.tensordot) call and its beneficial to do so. + + Parameters + ---------- + inputs : list of str + Specifies the subscripts for summation. + result : str + Resulting summation. + idx_removed : set + Indices that are removed in the summation + + + Returns + ------- + type : bool + Returns true if BLAS should and can be used, else False + + Notes + ----- + If the operations is BLAS level 1 or 2 and is not already aligned + we default back to einsum as the memory movement to copy is more + costly than the operation itself. + + + Examples + -------- + + # Standard GEMM operation + >>> _can_dot(['ij', 'jk'], 'ik', set('j')) + True + + # Can use the standard BLAS, but requires odd data movement + >>> _can_dot(['ijj', 'jk'], 'ik', set('j')) + False + + # DDOT where the memory is not aligned + >>> _can_dot(['ijk', 'ikj'], '', set('ijk')) + False + + """ + + # All `dot` calls remove indices + if len(idx_removed) == 0: + return False + + # BLAS can only handle two operands + if len(inputs) != 2: + return False + + input_left, input_right = inputs + + for c in set(input_left + input_right): + # can't deal with repeated indices on same input or more than 2 total + nl, nr = input_left.count(c), input_right.count(c) + if (nl > 1) or (nr > 1) or (nl + nr > 2): + return False + + # can't do implicit summation or dimension collapse e.g. + # "ab,bc->c" (implicitly sum over 'a') + # "ab,ca->ca" (take diagonal of 'a') + if nl + nr - 1 == int(c in result): + return False + + # Build a few temporaries + set_left = set(input_left) + set_right = set(input_right) + keep_left = set_left - idx_removed + keep_right = set_right - idx_removed + rs = len(idx_removed) + + # At this point we are a DOT, GEMV, or GEMM operation + + # Handle inner products + + # DDOT with aligned data + if input_left == input_right: + return True + + # DDOT without aligned data (better to use einsum) + if set_left == set_right: + return False + + # Handle the 4 possible (aligned) GEMV or GEMM cases + + # GEMM or GEMV no transpose + if input_left[-rs:] == input_right[:rs]: + return True + + # GEMM or GEMV transpose both + if input_left[:rs] == input_right[-rs:]: + return True + + # GEMM or GEMV transpose right + if input_left[-rs:] == input_right[-rs:]: + return True + + # GEMM or GEMV transpose left + if input_left[:rs] == input_right[:rs]: + return True + + # Einsum is faster than GEMV if we have to copy data + if not keep_left or not keep_right: + return False + + # We are a matrix-matrix product, but we need to copy data + return True + + +def _parse_einsum_input(operands): + """ + A reproduction of einsum c side einsum parsing in python. + + Returns + ------- + input_strings : str + Parsed input strings + output_string : str + Parsed output string + operands : list of array_like + The operands to use in the numpy contraction + + Examples + -------- + The operand list is simplified to reduce printing: + + >>> np.random.seed(123) + >>> a = np.random.rand(4, 4) + >>> b = np.random.rand(4, 4, 4) + >>> _parse_einsum_input(('...a,...a->...', a, b)) + ('za,xza', 'xz', [a, b]) # may vary + + >>> _parse_einsum_input((a, [Ellipsis, 0], b, [Ellipsis, 0])) + ('za,xza', 'xz', [a, b]) # may vary + """ + + if len(operands) == 0: + raise ValueError("No input operands") + + if isinstance(operands[0], str): + subscripts = operands[0].replace(" ", "") + operands = [asanyarray(v) for v in operands[1:]] + + # Ensure all characters are valid + for s in subscripts: + if s in '.,->': + continue + if s not in einsum_symbols: + raise ValueError("Character %s is not a valid symbol." % s) + + else: + tmp_operands = list(operands) + operand_list = [] + subscript_list = [] + for p in range(len(operands) // 2): + operand_list.append(tmp_operands.pop(0)) + subscript_list.append(tmp_operands.pop(0)) + + output_list = tmp_operands[-1] if len(tmp_operands) else None + operands = [asanyarray(v) for v in operand_list] + subscripts = "" + last = len(subscript_list) - 1 + for num, sub in enumerate(subscript_list): + for s in sub: + if s is Ellipsis: + subscripts += "..." + else: + try: + s = operator.index(s) + except TypeError as e: + raise TypeError( + "For this input type lists must contain " + "either int or Ellipsis" + ) from e + subscripts += einsum_symbols[s] + if num != last: + subscripts += "," + + if output_list is not None: + subscripts += "->" + for s in output_list: + if s is Ellipsis: + subscripts += "..." + else: + try: + s = operator.index(s) + except TypeError as e: + raise TypeError( + "For this input type lists must contain " + "either int or Ellipsis" + ) from e + subscripts += einsum_symbols[s] + # Check for proper "->" + if ("-" in subscripts) or (">" in subscripts): + invalid = (subscripts.count("-") > 1) or (subscripts.count(">") > 1) + if invalid or (subscripts.count("->") != 1): + raise ValueError("Subscripts can only contain one '->'.") + + # Parse ellipses + if "." in subscripts: + used = subscripts.replace(".", "").replace(",", "").replace("->", "") + unused = list(einsum_symbols_set - set(used)) + ellipse_inds = "".join(unused) + longest = 0 + + if "->" in subscripts: + input_tmp, output_sub = subscripts.split("->") + split_subscripts = input_tmp.split(",") + out_sub = True + else: + split_subscripts = subscripts.split(',') + out_sub = False + + for num, sub in enumerate(split_subscripts): + if "." in sub: + if (sub.count(".") != 3) or (sub.count("...") != 1): + raise ValueError("Invalid Ellipses.") + + # Take into account numerical values + if operands[num].shape == (): + ellipse_count = 0 + else: + ellipse_count = max(operands[num].ndim, 1) + ellipse_count -= (len(sub) - 3) + + if ellipse_count > longest: + longest = ellipse_count + + if ellipse_count < 0: + raise ValueError("Ellipses lengths do not match.") + elif ellipse_count == 0: + split_subscripts[num] = sub.replace('...', '') + else: + rep_inds = ellipse_inds[-ellipse_count:] + split_subscripts[num] = sub.replace('...', rep_inds) + + subscripts = ",".join(split_subscripts) + if longest == 0: + out_ellipse = "" + else: + out_ellipse = ellipse_inds[-longest:] + + if out_sub: + subscripts += "->" + output_sub.replace("...", out_ellipse) + else: + # Special care for outputless ellipses + output_subscript = "" + tmp_subscripts = subscripts.replace(",", "") + for s in sorted(set(tmp_subscripts)): + if s not in (einsum_symbols): + raise ValueError("Character %s is not a valid symbol." % s) + if tmp_subscripts.count(s) == 1: + output_subscript += s + normal_inds = ''.join(sorted(set(output_subscript) - + set(out_ellipse))) + + subscripts += "->" + out_ellipse + normal_inds + + # Build output string if does not exist + if "->" in subscripts: + input_subscripts, output_subscript = subscripts.split("->") + else: + input_subscripts = subscripts + # Build output subscripts + tmp_subscripts = subscripts.replace(",", "") + output_subscript = "" + for s in sorted(set(tmp_subscripts)): + if s not in einsum_symbols: + raise ValueError("Character %s is not a valid symbol." % s) + if tmp_subscripts.count(s) == 1: + output_subscript += s + + # Make sure output subscripts are in the input + for char in output_subscript: + if output_subscript.count(char) != 1: + raise ValueError("Output character %s appeared more than once in " + "the output." % char) + if char not in input_subscripts: + raise ValueError("Output character %s did not appear in the input" + % char) + + # Make sure number operands is equivalent to the number of terms + if len(input_subscripts.split(',')) != len(operands): + raise ValueError("Number of einsum subscripts must be equal to the " + "number of operands.") + + return (input_subscripts, output_subscript, operands) + + +def _einsum_path_dispatcher(*operands, optimize=None, einsum_call=None): + # NOTE: technically, we should only dispatch on array-like arguments, not + # subscripts (given as strings). But separating operands into + # arrays/subscripts is a little tricky/slow (given einsum's two supported + # signatures), so as a practical shortcut we dispatch on everything. + # Strings will be ignored for dispatching since they don't define + # __array_function__. + return operands + + +@array_function_dispatch(_einsum_path_dispatcher, module='numpy') +def einsum_path(*operands, optimize='greedy', einsum_call=False): + """ + einsum_path(subscripts, *operands, optimize='greedy') + + Evaluates the lowest cost contraction order for an einsum expression by + considering the creation of intermediate arrays. + + Parameters + ---------- + subscripts : str + Specifies the subscripts for summation. + *operands : list of array_like + These are the arrays for the operation. + optimize : {bool, list, tuple, 'greedy', 'optimal'} + Choose the type of path. If a tuple is provided, the second argument is + assumed to be the maximum intermediate size created. If only a single + argument is provided the largest input or output array size is used + as a maximum intermediate size. + + * if a list is given that starts with ``einsum_path``, uses this as the + contraction path + * if False no optimization is taken + * if True defaults to the 'greedy' algorithm + * 'optimal' An algorithm that combinatorially explores all possible + ways of contracting the listed tensors and chooses the least costly + path. Scales exponentially with the number of terms in the + contraction. + * 'greedy' An algorithm that chooses the best pair contraction + at each step. Effectively, this algorithm searches the largest inner, + Hadamard, and then outer products at each step. Scales cubically with + the number of terms in the contraction. Equivalent to the 'optimal' + path for most contractions. + + Default is 'greedy'. + + Returns + ------- + path : list of tuples + A list representation of the einsum path. + string_repr : str + A printable representation of the einsum path. + + Notes + ----- + The resulting path indicates which terms of the input contraction should be + contracted first, the result of this contraction is then appended to the + end of the contraction list. This list can then be iterated over until all + intermediate contractions are complete. + + See Also + -------- + einsum, linalg.multi_dot + + Examples + -------- + + We can begin with a chain dot example. In this case, it is optimal to + contract the ``b`` and ``c`` tensors first as represented by the first + element of the path ``(1, 2)``. The resulting tensor is added to the end + of the contraction and the remaining contraction ``(0, 1)`` is then + completed. + + >>> np.random.seed(123) + >>> a = np.random.rand(2, 2) + >>> b = np.random.rand(2, 5) + >>> c = np.random.rand(5, 2) + >>> path_info = np.einsum_path('ij,jk,kl->il', a, b, c, optimize='greedy') + >>> print(path_info[0]) + ['einsum_path', (1, 2), (0, 1)] + >>> print(path_info[1]) + Complete contraction: ij,jk,kl->il # may vary + Naive scaling: 4 + Optimized scaling: 3 + Naive FLOP count: 1.600e+02 + Optimized FLOP count: 5.600e+01 + Theoretical speedup: 2.857 + Largest intermediate: 4.000e+00 elements + ------------------------------------------------------------------------- + scaling current remaining + ------------------------------------------------------------------------- + 3 kl,jk->jl ij,jl->il + 3 jl,ij->il il->il + + + A more complex index transformation example. + + >>> I = np.random.rand(10, 10, 10, 10) + >>> C = np.random.rand(10, 10) + >>> path_info = np.einsum_path('ea,fb,abcd,gc,hd->efgh', C, C, I, C, C, + ... optimize='greedy') + + >>> print(path_info[0]) + ['einsum_path', (0, 2), (0, 3), (0, 2), (0, 1)] + >>> print(path_info[1]) + Complete contraction: ea,fb,abcd,gc,hd->efgh # may vary + Naive scaling: 8 + Optimized scaling: 5 + Naive FLOP count: 8.000e+08 + Optimized FLOP count: 8.000e+05 + Theoretical speedup: 1000.000 + Largest intermediate: 1.000e+04 elements + -------------------------------------------------------------------------- + scaling current remaining + -------------------------------------------------------------------------- + 5 abcd,ea->bcde fb,gc,hd,bcde->efgh + 5 bcde,fb->cdef gc,hd,cdef->efgh + 5 cdef,gc->defg hd,defg->efgh + 5 defg,hd->efgh efgh->efgh + """ + + # Figure out what the path really is + path_type = optimize + if path_type is True: + path_type = 'greedy' + if path_type is None: + path_type = False + + explicit_einsum_path = False + memory_limit = None + + # No optimization or a named path algorithm + if (path_type is False) or isinstance(path_type, str): + pass + + # Given an explicit path + elif len(path_type) and (path_type[0] == 'einsum_path'): + explicit_einsum_path = True + + # Path tuple with memory limit + elif ((len(path_type) == 2) and isinstance(path_type[0], str) and + isinstance(path_type[1], (int, float))): + memory_limit = int(path_type[1]) + path_type = path_type[0] + + else: + raise TypeError("Did not understand the path: %s" % str(path_type)) + + # Hidden option, only einsum should call this + einsum_call_arg = einsum_call + + # Python side parsing + input_subscripts, output_subscript, operands = ( + _parse_einsum_input(operands) + ) + + # Build a few useful list and sets + input_list = input_subscripts.split(',') + input_sets = [set(x) for x in input_list] + output_set = set(output_subscript) + indices = set(input_subscripts.replace(',', '')) + + # Get length of each unique dimension and ensure all dimensions are correct + dimension_dict = {} + broadcast_indices = [[] for x in range(len(input_list))] + for tnum, term in enumerate(input_list): + sh = operands[tnum].shape + if len(sh) != len(term): + raise ValueError("Einstein sum subscript %s does not contain the " + "correct number of indices for operand %d." + % (input_subscripts[tnum], tnum)) + for cnum, char in enumerate(term): + dim = sh[cnum] + + # Build out broadcast indices + if dim == 1: + broadcast_indices[tnum].append(char) + + if char in dimension_dict.keys(): + # For broadcasting cases we always want the largest dim size + if dimension_dict[char] == 1: + dimension_dict[char] = dim + elif dim not in (1, dimension_dict[char]): + raise ValueError("Size of label '%s' for operand %d (%d) " + "does not match previous terms (%d)." + % (char, tnum, dimension_dict[char], dim)) + else: + dimension_dict[char] = dim + + # Convert broadcast inds to sets + broadcast_indices = [set(x) for x in broadcast_indices] + + # Compute size of each input array plus the output array + size_list = [_compute_size_by_dict(term, dimension_dict) + for term in input_list + [output_subscript]] + max_size = max(size_list) + + if memory_limit is None: + memory_arg = max_size + else: + memory_arg = memory_limit + + # Compute naive cost + # This isn't quite right, need to look into exactly how einsum does this + inner_product = (sum(len(x) for x in input_sets) - len(indices)) > 0 + naive_cost = _flop_count( + indices, inner_product, len(input_list), dimension_dict + ) + + # Compute the path + if explicit_einsum_path: + path = path_type[1:] + elif ( + (path_type is False) + or (len(input_list) in [1, 2]) + or (indices == output_set) + ): + # Nothing to be optimized, leave it to einsum + path = [tuple(range(len(input_list)))] + elif path_type == "greedy": + path = _greedy_path( + input_sets, output_set, dimension_dict, memory_arg + ) + elif path_type == "optimal": + path = _optimal_path( + input_sets, output_set, dimension_dict, memory_arg + ) + else: + raise KeyError("Path name %s not found", path_type) + + cost_list, scale_list, size_list, contraction_list = [], [], [], [] + + # Build contraction tuple (positions, gemm, einsum_str, remaining) + for cnum, contract_inds in enumerate(path): + # Make sure we remove inds from right to left + contract_inds = tuple(sorted(list(contract_inds), reverse=True)) + + contract = _find_contraction(contract_inds, input_sets, output_set) + out_inds, input_sets, idx_removed, idx_contract = contract + + cost = _flop_count( + idx_contract, idx_removed, len(contract_inds), dimension_dict + ) + cost_list.append(cost) + scale_list.append(len(idx_contract)) + size_list.append(_compute_size_by_dict(out_inds, dimension_dict)) + + bcast = set() + tmp_inputs = [] + for x in contract_inds: + tmp_inputs.append(input_list.pop(x)) + bcast |= broadcast_indices.pop(x) + + new_bcast_inds = bcast - idx_removed + + # If we're broadcasting, nix blas + if not len(idx_removed & bcast): + do_blas = _can_dot(tmp_inputs, out_inds, idx_removed) + else: + do_blas = False + + # Last contraction + if (cnum - len(path)) == -1: + idx_result = output_subscript + else: + sort_result = [(dimension_dict[ind], ind) for ind in out_inds] + idx_result = "".join([x[1] for x in sorted(sort_result)]) + + input_list.append(idx_result) + broadcast_indices.append(new_bcast_inds) + einsum_str = ",".join(tmp_inputs) + "->" + idx_result + + contraction = ( + contract_inds, idx_removed, einsum_str, input_list[:], do_blas + ) + contraction_list.append(contraction) + + opt_cost = sum(cost_list) + 1 + + if len(input_list) != 1: + # Explicit "einsum_path" is usually trusted, but we detect this kind of + # mistake in order to prevent from returning an intermediate value. + raise RuntimeError( + "Invalid einsum_path is specified: {} more operands has to be " + "contracted.".format(len(input_list) - 1)) + + if einsum_call_arg: + return (operands, contraction_list) + + # Return the path along with a nice string representation + overall_contraction = input_subscripts + "->" + output_subscript + header = ("scaling", "current", "remaining") + + speedup = naive_cost / opt_cost + max_i = max(size_list) + + path_print = " Complete contraction: %s\n" % overall_contraction + path_print += " Naive scaling: %d\n" % len(indices) + path_print += " Optimized scaling: %d\n" % max(scale_list) + path_print += " Naive FLOP count: %.3e\n" % naive_cost + path_print += " Optimized FLOP count: %.3e\n" % opt_cost + path_print += " Theoretical speedup: %3.3f\n" % speedup + path_print += " Largest intermediate: %.3e elements\n" % max_i + path_print += "-" * 74 + "\n" + path_print += "%6s %24s %40s\n" % header + path_print += "-" * 74 + + for n, contraction in enumerate(contraction_list): + inds, idx_rm, einsum_str, remaining, blas = contraction + remaining_str = ",".join(remaining) + "->" + output_subscript + path_run = (scale_list[n], einsum_str, remaining_str) + path_print += "\n%4d %24s %40s" % path_run + + path = ['einsum_path'] + path + return (path, path_print) + + +def _einsum_dispatcher(*operands, out=None, optimize=None, **kwargs): + # Arguably we dispatch on more arguments than we really should; see note in + # _einsum_path_dispatcher for why. + yield from operands + yield out + + +# Rewrite einsum to handle different cases +@array_function_dispatch(_einsum_dispatcher, module='numpy') +def einsum(*operands, out=None, optimize=False, **kwargs): + """ + einsum(subscripts, *operands, out=None, dtype=None, order='K', + casting='safe', optimize=False) + + Evaluates the Einstein summation convention on the operands. + + Using the Einstein summation convention, many common multi-dimensional, + linear algebraic array operations can be represented in a simple fashion. + In *implicit* mode `einsum` computes these values. + + In *explicit* mode, `einsum` provides further flexibility to compute + other array operations that might not be considered classical Einstein + summation operations, by disabling, or forcing summation over specified + subscript labels. + + See the notes and examples for clarification. + + Parameters + ---------- + subscripts : str + Specifies the subscripts for summation as comma separated list of + subscript labels. An implicit (classical Einstein summation) + calculation is performed unless the explicit indicator '->' is + included as well as subscript labels of the precise output form. + operands : list of array_like + These are the arrays for the operation. + out : ndarray, optional + If provided, the calculation is done into this array. + dtype : {data-type, None}, optional + If provided, forces the calculation to use the data type specified. + Note that you may have to also give a more liberal `casting` + parameter to allow the conversions. Default is None. + order : {'C', 'F', 'A', 'K'}, optional + Controls the memory layout of the output. 'C' means it should + be C contiguous. 'F' means it should be Fortran contiguous, + 'A' means it should be 'F' if the inputs are all 'F', 'C' otherwise. + 'K' means it should be as close to the layout as the inputs as + is possible, including arbitrarily permuted axes. + Default is 'K'. + casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional + Controls what kind of data casting may occur. Setting this to + 'unsafe' is not recommended, as it can adversely affect accumulations. + + * 'no' means the data types should not be cast at all. + * 'equiv' means only byte-order changes are allowed. + * 'safe' means only casts which can preserve values are allowed. + * 'same_kind' means only safe casts or casts within a kind, + like float64 to float32, are allowed. + * 'unsafe' means any data conversions may be done. + + Default is 'safe'. + optimize : {False, True, 'greedy', 'optimal'}, optional + Controls if intermediate optimization should occur. No optimization + will occur if False and True will default to the 'greedy' algorithm. + Also accepts an explicit contraction list from the ``np.einsum_path`` + function. See ``np.einsum_path`` for more details. Defaults to False. + + Returns + ------- + output : ndarray + The calculation based on the Einstein summation convention. + + See Also + -------- + einsum_path, dot, inner, outer, tensordot, linalg.multi_dot + einsum: + Similar verbose interface is provided by the + `einops `_ package to cover + additional operations: transpose, reshape/flatten, repeat/tile, + squeeze/unsqueeze and reductions. + The `opt_einsum `_ + optimizes contraction order for einsum-like expressions + in backend-agnostic manner. + + Notes + ----- + .. versionadded:: 1.6.0 + + The Einstein summation convention can be used to compute + many multi-dimensional, linear algebraic array operations. `einsum` + provides a succinct way of representing these. + + A non-exhaustive list of these operations, + which can be computed by `einsum`, is shown below along with examples: + + * Trace of an array, :py:func:`numpy.trace`. + * Return a diagonal, :py:func:`numpy.diag`. + * Array axis summations, :py:func:`numpy.sum`. + * Transpositions and permutations, :py:func:`numpy.transpose`. + * Matrix multiplication and dot product, :py:func:`numpy.matmul` + :py:func:`numpy.dot`. + * Vector inner and outer products, :py:func:`numpy.inner` + :py:func:`numpy.outer`. + * Broadcasting, element-wise and scalar multiplication, + :py:func:`numpy.multiply`. + * Tensor contractions, :py:func:`numpy.tensordot`. + * Chained array operations, in efficient calculation order, + :py:func:`numpy.einsum_path`. + + The subscripts string is a comma-separated list of subscript labels, + where each label refers to a dimension of the corresponding operand. + Whenever a label is repeated it is summed, so ``np.einsum('i,i', a, b)`` + is equivalent to :py:func:`np.inner(a,b) `. If a label + appears only once, it is not summed, so ``np.einsum('i', a)`` + produces a view of ``a`` with no changes. A further example + ``np.einsum('ij,jk', a, b)`` describes traditional matrix multiplication + and is equivalent to :py:func:`np.matmul(a,b) `. + Repeated subscript labels in one operand take the diagonal. + For example, ``np.einsum('ii', a)`` is equivalent to + :py:func:`np.trace(a) `. + + In *implicit mode*, the chosen subscripts are important + since the axes of the output are reordered alphabetically. This + means that ``np.einsum('ij', a)`` doesn't affect a 2D array, while + ``np.einsum('ji', a)`` takes its transpose. Additionally, + ``np.einsum('ij,jk', a, b)`` returns a matrix multiplication, while, + ``np.einsum('ij,jh', a, b)`` returns the transpose of the + multiplication since subscript 'h' precedes subscript 'i'. + + In *explicit mode* the output can be directly controlled by + specifying output subscript labels. This requires the + identifier '->' as well as the list of output subscript labels. + This feature increases the flexibility of the function since + summing can be disabled or forced when required. The call + ``np.einsum('i->', a)`` is like :py:func:`np.sum(a) ` + if ``a`` is a 1-D array, and ``np.einsum('ii->i', a)`` + is like :py:func:`np.diag(a) ` if ``a`` is a square 2-D array. + The difference is that `einsum` does not allow broadcasting by default. + Additionally ``np.einsum('ij,jh->ih', a, b)`` directly specifies the + order of the output subscript labels and therefore returns matrix + multiplication, unlike the example above in implicit mode. + + To enable and control broadcasting, use an ellipsis. Default + NumPy-style broadcasting is done by adding an ellipsis + to the left of each term, like ``np.einsum('...ii->...i', a)``. + ``np.einsum('...i->...', a)`` is like + :py:func:`np.sum(a, axis=-1) ` for array ``a`` of any shape. + To take the trace along the first and last axes, + you can do ``np.einsum('i...i', a)``, or to do a matrix-matrix + product with the left-most indices instead of rightmost, one can do + ``np.einsum('ij...,jk...->ik...', a, b)``. + + When there is only one operand, no axes are summed, and no output + parameter is provided, a view into the operand is returned instead + of a new array. Thus, taking the diagonal as ``np.einsum('ii->i', a)`` + produces a view (changed in version 1.10.0). + + `einsum` also provides an alternative way to provide the subscripts and + operands as ``einsum(op0, sublist0, op1, sublist1, ..., [sublistout])``. + If the output shape is not provided in this format `einsum` will be + calculated in implicit mode, otherwise it will be performed explicitly. + The examples below have corresponding `einsum` calls with the two + parameter methods. + + .. versionadded:: 1.10.0 + + Views returned from einsum are now writeable whenever the input array + is writeable. For example, ``np.einsum('ijk...->kji...', a)`` will now + have the same effect as :py:func:`np.swapaxes(a, 0, 2) ` + and ``np.einsum('ii->i', a)`` will return a writeable view of the diagonal + of a 2D array. + + .. versionadded:: 1.12.0 + + Added the ``optimize`` argument which will optimize the contraction order + of an einsum expression. For a contraction with three or more operands + this can greatly increase the computational efficiency at the cost of + a larger memory footprint during computation. + + Typically a 'greedy' algorithm is applied which empirical tests have shown + returns the optimal path in the majority of cases. In some cases 'optimal' + will return the superlative path through a more expensive, exhaustive + search. For iterative calculations it may be advisable to calculate + the optimal path once and reuse that path by supplying it as an argument. + An example is given below. + + See :py:func:`numpy.einsum_path` for more details. + + Examples + -------- + >>> a = np.arange(25).reshape(5,5) + >>> b = np.arange(5) + >>> c = np.arange(6).reshape(2,3) + + Trace of a matrix: + + >>> np.einsum('ii', a) + 60 + >>> np.einsum(a, [0,0]) + 60 + >>> np.trace(a) + 60 + + Extract the diagonal (requires explicit form): + + >>> np.einsum('ii->i', a) + array([ 0, 6, 12, 18, 24]) + >>> np.einsum(a, [0,0], [0]) + array([ 0, 6, 12, 18, 24]) + >>> np.diag(a) + array([ 0, 6, 12, 18, 24]) + + Sum over an axis (requires explicit form): + + >>> np.einsum('ij->i', a) + array([ 10, 35, 60, 85, 110]) + >>> np.einsum(a, [0,1], [0]) + array([ 10, 35, 60, 85, 110]) + >>> np.sum(a, axis=1) + array([ 10, 35, 60, 85, 110]) + + For higher dimensional arrays summing a single axis can be done + with ellipsis: + + >>> np.einsum('...j->...', a) + array([ 10, 35, 60, 85, 110]) + >>> np.einsum(a, [Ellipsis,1], [Ellipsis]) + array([ 10, 35, 60, 85, 110]) + + Compute a matrix transpose, or reorder any number of axes: + + >>> np.einsum('ji', c) + array([[0, 3], + [1, 4], + [2, 5]]) + >>> np.einsum('ij->ji', c) + array([[0, 3], + [1, 4], + [2, 5]]) + >>> np.einsum(c, [1,0]) + array([[0, 3], + [1, 4], + [2, 5]]) + >>> np.transpose(c) + array([[0, 3], + [1, 4], + [2, 5]]) + + Vector inner products: + + >>> np.einsum('i,i', b, b) + 30 + >>> np.einsum(b, [0], b, [0]) + 30 + >>> np.inner(b,b) + 30 + + Matrix vector multiplication: + + >>> np.einsum('ij,j', a, b) + array([ 30, 80, 130, 180, 230]) + >>> np.einsum(a, [0,1], b, [1]) + array([ 30, 80, 130, 180, 230]) + >>> np.dot(a, b) + array([ 30, 80, 130, 180, 230]) + >>> np.einsum('...j,j', a, b) + array([ 30, 80, 130, 180, 230]) + + Broadcasting and scalar multiplication: + + >>> np.einsum('..., ...', 3, c) + array([[ 0, 3, 6], + [ 9, 12, 15]]) + >>> np.einsum(',ij', 3, c) + array([[ 0, 3, 6], + [ 9, 12, 15]]) + >>> np.einsum(3, [Ellipsis], c, [Ellipsis]) + array([[ 0, 3, 6], + [ 9, 12, 15]]) + >>> np.multiply(3, c) + array([[ 0, 3, 6], + [ 9, 12, 15]]) + + Vector outer product: + + >>> np.einsum('i,j', np.arange(2)+1, b) + array([[0, 1, 2, 3, 4], + [0, 2, 4, 6, 8]]) + >>> np.einsum(np.arange(2)+1, [0], b, [1]) + array([[0, 1, 2, 3, 4], + [0, 2, 4, 6, 8]]) + >>> np.outer(np.arange(2)+1, b) + array([[0, 1, 2, 3, 4], + [0, 2, 4, 6, 8]]) + + Tensor contraction: + + >>> a = np.arange(60.).reshape(3,4,5) + >>> b = np.arange(24.).reshape(4,3,2) + >>> np.einsum('ijk,jil->kl', a, b) + array([[4400., 4730.], + [4532., 4874.], + [4664., 5018.], + [4796., 5162.], + [4928., 5306.]]) + >>> np.einsum(a, [0,1,2], b, [1,0,3], [2,3]) + array([[4400., 4730.], + [4532., 4874.], + [4664., 5018.], + [4796., 5162.], + [4928., 5306.]]) + >>> np.tensordot(a,b, axes=([1,0],[0,1])) + array([[4400., 4730.], + [4532., 4874.], + [4664., 5018.], + [4796., 5162.], + [4928., 5306.]]) + + Writeable returned arrays (since version 1.10.0): + + >>> a = np.zeros((3, 3)) + >>> np.einsum('ii->i', a)[:] = 1 + >>> a + array([[1., 0., 0.], + [0., 1., 0.], + [0., 0., 1.]]) + + Example of ellipsis use: + + >>> a = np.arange(6).reshape((3,2)) + >>> b = np.arange(12).reshape((4,3)) + >>> np.einsum('ki,jk->ij', a, b) + array([[10, 28, 46, 64], + [13, 40, 67, 94]]) + >>> np.einsum('ki,...k->i...', a, b) + array([[10, 28, 46, 64], + [13, 40, 67, 94]]) + >>> np.einsum('k...,jk', a, b) + array([[10, 28, 46, 64], + [13, 40, 67, 94]]) + + Chained array operations. For more complicated contractions, speed ups + might be achieved by repeatedly computing a 'greedy' path or pre-computing + the 'optimal' path and repeatedly applying it, using an `einsum_path` + insertion (since version 1.12.0). Performance improvements can be + particularly significant with larger arrays: + + >>> a = np.ones(64).reshape(2,4,8) + + Basic `einsum`: ~1520ms (benchmarked on 3.1GHz Intel i5.) + + >>> for iteration in range(500): + ... _ = np.einsum('ijk,ilm,njm,nlk,abc->',a,a,a,a,a) + + Sub-optimal `einsum` (due to repeated path calculation time): ~330ms + + >>> for iteration in range(500): + ... _ = np.einsum('ijk,ilm,njm,nlk,abc->',a,a,a,a,a, + ... optimize='optimal') + + Greedy `einsum` (faster optimal path approximation): ~160ms + + >>> for iteration in range(500): + ... _ = np.einsum('ijk,ilm,njm,nlk,abc->',a,a,a,a,a, optimize='greedy') + + Optimal `einsum` (best usage pattern in some use cases): ~110ms + + >>> path = np.einsum_path('ijk,ilm,njm,nlk,abc->',a,a,a,a,a, + ... optimize='optimal')[0] + >>> for iteration in range(500): + ... _ = np.einsum('ijk,ilm,njm,nlk,abc->',a,a,a,a,a, optimize=path) + + """ + # Special handling if out is specified + specified_out = out is not None + + # If no optimization, run pure einsum + if optimize is False: + if specified_out: + kwargs['out'] = out + return c_einsum(*operands, **kwargs) + + # Check the kwargs to avoid a more cryptic error later, without having to + # repeat default values here + valid_einsum_kwargs = ['dtype', 'order', 'casting'] + unknown_kwargs = [k for (k, v) in kwargs.items() if + k not in valid_einsum_kwargs] + if len(unknown_kwargs): + raise TypeError("Did not understand the following kwargs: %s" + % unknown_kwargs) + + # Build the contraction list and operand + operands, contraction_list = einsum_path(*operands, optimize=optimize, + einsum_call=True) + + # Handle order kwarg for output array, c_einsum allows mixed case + output_order = kwargs.pop('order', 'K') + if output_order.upper() == 'A': + if all(arr.flags.f_contiguous for arr in operands): + output_order = 'F' + else: + output_order = 'C' + + # Start contraction loop + for num, contraction in enumerate(contraction_list): + inds, idx_rm, einsum_str, remaining, blas = contraction + tmp_operands = [operands.pop(x) for x in inds] + + # Do we need to deal with the output? + handle_out = specified_out and ((num + 1) == len(contraction_list)) + + # Call tensordot if still possible + if blas: + # Checks have already been handled + input_str, results_index = einsum_str.split('->') + input_left, input_right = input_str.split(',') + + tensor_result = input_left + input_right + for s in idx_rm: + tensor_result = tensor_result.replace(s, "") + + # Find indices to contract over + left_pos, right_pos = [], [] + for s in sorted(idx_rm): + left_pos.append(input_left.find(s)) + right_pos.append(input_right.find(s)) + + # Contract! + new_view = tensordot( + *tmp_operands, axes=(tuple(left_pos), tuple(right_pos)) + ) + + # Build a new view if needed + if (tensor_result != results_index) or handle_out: + if handle_out: + kwargs["out"] = out + new_view = c_einsum( + tensor_result + '->' + results_index, new_view, **kwargs + ) + + # Call einsum + else: + # If out was specified + if handle_out: + kwargs["out"] = out + + # Do the contraction + new_view = c_einsum(einsum_str, *tmp_operands, **kwargs) + + # Append new items and dereference what we can + operands.append(new_view) + del tmp_operands, new_view + + if specified_out: + return out + else: + return asanyarray(operands[0], order=output_order) diff --git a/venv/lib/python3.12/site-packages/numpy/_core/einsumfunc.pyi b/venv/lib/python3.12/site-packages/numpy/_core/einsumfunc.pyi new file mode 100644 index 00000000..513f0635 --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/einsumfunc.pyi @@ -0,0 +1,183 @@ +from collections.abc import Sequence +from typing import TypeVar, Any, overload, Literal + +import numpy as np +from numpy import number, _OrderKACF +from numpy._typing import ( + NDArray, + _ArrayLikeBool_co, + _ArrayLikeUInt_co, + _ArrayLikeInt_co, + _ArrayLikeFloat_co, + _ArrayLikeComplex_co, + _ArrayLikeObject_co, + _DTypeLikeBool, + _DTypeLikeUInt, + _DTypeLikeInt, + _DTypeLikeFloat, + _DTypeLikeComplex, + _DTypeLikeComplex_co, + _DTypeLikeObject, +) + +_ArrayType = TypeVar( + "_ArrayType", + bound=NDArray[np.bool | number[Any]], +) + +_OptimizeKind = None | bool | Literal["greedy", "optimal"] | Sequence[Any] +_CastingSafe = Literal["no", "equiv", "safe", "same_kind"] +_CastingUnsafe = Literal["unsafe"] + +__all__: list[str] + +# TODO: Properly handle the `casting`-based combinatorics +# TODO: We need to evaluate the content `__subscripts` in order +# to identify whether or an array or scalar is returned. At a cursory +# glance this seems like something that can quite easily be done with +# a mypy plugin. +# Something like `is_scalar = bool(__subscripts.partition("->")[-1])` +@overload +def einsum( + subscripts: str | _ArrayLikeInt_co, + /, + *operands: _ArrayLikeBool_co, + out: None = ..., + dtype: None | _DTypeLikeBool = ..., + order: _OrderKACF = ..., + casting: _CastingSafe = ..., + optimize: _OptimizeKind = ..., +) -> Any: ... +@overload +def einsum( + subscripts: str | _ArrayLikeInt_co, + /, + *operands: _ArrayLikeUInt_co, + out: None = ..., + dtype: None | _DTypeLikeUInt = ..., + order: _OrderKACF = ..., + casting: _CastingSafe = ..., + optimize: _OptimizeKind = ..., +) -> Any: ... +@overload +def einsum( + subscripts: str | _ArrayLikeInt_co, + /, + *operands: _ArrayLikeInt_co, + out: None = ..., + dtype: None | _DTypeLikeInt = ..., + order: _OrderKACF = ..., + casting: _CastingSafe = ..., + optimize: _OptimizeKind = ..., +) -> Any: ... +@overload +def einsum( + subscripts: str | _ArrayLikeInt_co, + /, + *operands: _ArrayLikeFloat_co, + out: None = ..., + dtype: None | _DTypeLikeFloat = ..., + order: _OrderKACF = ..., + casting: _CastingSafe = ..., + optimize: _OptimizeKind = ..., +) -> Any: ... +@overload +def einsum( + subscripts: str | _ArrayLikeInt_co, + /, + *operands: _ArrayLikeComplex_co, + out: None = ..., + dtype: None | _DTypeLikeComplex = ..., + order: _OrderKACF = ..., + casting: _CastingSafe = ..., + optimize: _OptimizeKind = ..., +) -> Any: ... +@overload +def einsum( + subscripts: str | _ArrayLikeInt_co, + /, + *operands: Any, + casting: _CastingUnsafe, + dtype: None | _DTypeLikeComplex_co = ..., + out: None = ..., + order: _OrderKACF = ..., + optimize: _OptimizeKind = ..., +) -> Any: ... +@overload +def einsum( + subscripts: str | _ArrayLikeInt_co, + /, + *operands: _ArrayLikeComplex_co, + out: _ArrayType, + dtype: None | _DTypeLikeComplex_co = ..., + order: _OrderKACF = ..., + casting: _CastingSafe = ..., + optimize: _OptimizeKind = ..., +) -> _ArrayType: ... +@overload +def einsum( + subscripts: str | _ArrayLikeInt_co, + /, + *operands: Any, + out: _ArrayType, + casting: _CastingUnsafe, + dtype: None | _DTypeLikeComplex_co = ..., + order: _OrderKACF = ..., + optimize: _OptimizeKind = ..., +) -> _ArrayType: ... + +@overload +def einsum( + subscripts: str | _ArrayLikeInt_co, + /, + *operands: _ArrayLikeObject_co, + out: None = ..., + dtype: None | _DTypeLikeObject = ..., + order: _OrderKACF = ..., + casting: _CastingSafe = ..., + optimize: _OptimizeKind = ..., +) -> Any: ... +@overload +def einsum( + subscripts: str | _ArrayLikeInt_co, + /, + *operands: Any, + casting: _CastingUnsafe, + dtype: None | _DTypeLikeObject = ..., + out: None = ..., + order: _OrderKACF = ..., + optimize: _OptimizeKind = ..., +) -> Any: ... +@overload +def einsum( + subscripts: str | _ArrayLikeInt_co, + /, + *operands: _ArrayLikeObject_co, + out: _ArrayType, + dtype: None | _DTypeLikeObject = ..., + order: _OrderKACF = ..., + casting: _CastingSafe = ..., + optimize: _OptimizeKind = ..., +) -> _ArrayType: ... +@overload +def einsum( + subscripts: str | _ArrayLikeInt_co, + /, + *operands: Any, + out: _ArrayType, + casting: _CastingUnsafe, + dtype: None | _DTypeLikeObject = ..., + order: _OrderKACF = ..., + optimize: _OptimizeKind = ..., +) -> _ArrayType: ... + +# NOTE: `einsum_call` is a hidden kwarg unavailable for public use. +# It is therefore excluded from the signatures below. +# NOTE: In practice the list consists of a `str` (first element) +# and a variable number of integer tuples. +def einsum_path( + subscripts: str | _ArrayLikeInt_co, + /, + *operands: _ArrayLikeComplex_co | _DTypeLikeObject, + optimize: _OptimizeKind = ..., +) -> tuple[list[Any], str]: ... diff --git a/venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py b/venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py new file mode 100644 index 00000000..a3d87127 --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py @@ -0,0 +1,4320 @@ +"""Module containing non-deprecated functions borrowed from Numeric. + +""" +import functools +import types +import warnings + +import numpy as np +from .._utils import set_module +from . import multiarray as mu +from . import overrides +from . import umath as um +from . import numerictypes as nt +from .multiarray import asarray, array, asanyarray, concatenate +from ._multiarray_umath import _array_converter +from . import _methods + +_dt_ = nt.sctype2char + +# functions that are methods +__all__ = [ + 'all', 'amax', 'amin', 'any', 'argmax', + 'argmin', 'argpartition', 'argsort', 'around', 'choose', 'clip', + 'compress', 'cumprod', 'cumsum', 'cumulative_prod', 'cumulative_sum', + 'diagonal', 'mean', 'max', 'min', 'matrix_transpose', + 'ndim', 'nonzero', 'partition', 'prod', 'ptp', 'put', + 'ravel', 'repeat', 'reshape', 'resize', 'round', + 'searchsorted', 'shape', 'size', 'sort', 'squeeze', + 'std', 'sum', 'swapaxes', 'take', 'trace', 'transpose', 'var', +] + +_gentype = types.GeneratorType +# save away Python sum +_sum_ = sum + +array_function_dispatch = functools.partial( + overrides.array_function_dispatch, module='numpy') + + +# functions that are now methods +def _wrapit(obj, method, *args, **kwds): + conv = _array_converter(obj) + # As this already tried the method, subok is maybe quite reasonable here + # but this follows what was done before. TODO: revisit this. + arr, = conv.as_arrays(subok=False) + result = getattr(arr, method)(*args, **kwds) + + return conv.wrap(result, to_scalar=False) + + +def _wrapfunc(obj, method, *args, **kwds): + bound = getattr(obj, method, None) + if bound is None: + return _wrapit(obj, method, *args, **kwds) + + try: + return bound(*args, **kwds) + except TypeError: + # A TypeError occurs if the object does have such a method in its + # class, but its signature is not identical to that of NumPy's. This + # situation has occurred in the case of a downstream library like + # 'pandas'. + # + # Call _wrapit from within the except clause to ensure a potential + # exception has a traceback chain. + return _wrapit(obj, method, *args, **kwds) + + +def _wrapreduction(obj, ufunc, method, axis, dtype, out, **kwargs): + passkwargs = {k: v for k, v in kwargs.items() + if v is not np._NoValue} + + if type(obj) is not mu.ndarray: + try: + reduction = getattr(obj, method) + except AttributeError: + pass + else: + # This branch is needed for reductions like any which don't + # support a dtype. + if dtype is not None: + return reduction(axis=axis, dtype=dtype, out=out, **passkwargs) + else: + return reduction(axis=axis, out=out, **passkwargs) + + return ufunc.reduce(obj, axis, dtype, out, **passkwargs) + + +def _wrapreduction_any_all(obj, ufunc, method, axis, out, **kwargs): + # Same as above function, but dtype is always bool (but never passed on) + passkwargs = {k: v for k, v in kwargs.items() + if v is not np._NoValue} + + if type(obj) is not mu.ndarray: + try: + reduction = getattr(obj, method) + except AttributeError: + pass + else: + return reduction(axis=axis, out=out, **passkwargs) + + return ufunc.reduce(obj, axis, bool, out, **passkwargs) + + +def _take_dispatcher(a, indices, axis=None, out=None, mode=None): + return (a, out) + + +@array_function_dispatch(_take_dispatcher) +def take(a, indices, axis=None, out=None, mode='raise'): + """ + Take elements from an array along an axis. + + When axis is not None, this function does the same thing as "fancy" + indexing (indexing arrays using arrays); however, it can be easier to use + if you need elements along a given axis. A call such as + ``np.take(arr, indices, axis=3)`` is equivalent to + ``arr[:,:,:,indices,...]``. + + Explained without fancy indexing, this is equivalent to the following use + of `ndindex`, which sets each of ``ii``, ``jj``, and ``kk`` to a tuple of + indices:: + + Ni, Nk = a.shape[:axis], a.shape[axis+1:] + Nj = indices.shape + for ii in ndindex(Ni): + for jj in ndindex(Nj): + for kk in ndindex(Nk): + out[ii + jj + kk] = a[ii + (indices[jj],) + kk] + + Parameters + ---------- + a : array_like (Ni..., M, Nk...) + The source array. + indices : array_like (Nj...) + The indices of the values to extract. + + .. versionadded:: 1.8.0 + + Also allow scalars for indices. + axis : int, optional + The axis over which to select values. By default, the flattened + input array is used. + out : ndarray, optional (Ni..., Nj..., Nk...) + If provided, the result will be placed in this array. It should + be of the appropriate shape and dtype. Note that `out` is always + buffered if `mode='raise'`; use other modes for better performance. + mode : {'raise', 'wrap', 'clip'}, optional + Specifies how out-of-bounds indices will behave. + + * 'raise' -- raise an error (default) + * 'wrap' -- wrap around + * 'clip' -- clip to the range + + 'clip' mode means that all indices that are too large are replaced + by the index that addresses the last element along that axis. Note + that this disables indexing with negative numbers. + + Returns + ------- + out : ndarray (Ni..., Nj..., Nk...) + The returned array has the same type as `a`. + + See Also + -------- + compress : Take elements using a boolean mask + ndarray.take : equivalent method + take_along_axis : Take elements by matching the array and the index arrays + + Notes + ----- + + By eliminating the inner loop in the description above, and using `s_` to + build simple slice objects, `take` can be expressed in terms of applying + fancy indexing to each 1-d slice:: + + Ni, Nk = a.shape[:axis], a.shape[axis+1:] + for ii in ndindex(Ni): + for kk in ndindex(Nj): + out[ii + s_[...,] + kk] = a[ii + s_[:,] + kk][indices] + + For this reason, it is equivalent to (but faster than) the following use + of `apply_along_axis`:: + + out = np.apply_along_axis(lambda a_1d: a_1d[indices], axis, a) + + Examples + -------- + >>> import numpy as np + >>> a = [4, 3, 5, 7, 6, 8] + >>> indices = [0, 1, 4] + >>> np.take(a, indices) + array([4, 3, 6]) + + In this example if `a` is an ndarray, "fancy" indexing can be used. + + >>> a = np.array(a) + >>> a[indices] + array([4, 3, 6]) + + If `indices` is not one dimensional, the output also has these dimensions. + + >>> np.take(a, [[0, 1], [2, 3]]) + array([[4, 3], + [5, 7]]) + """ + return _wrapfunc(a, 'take', indices, axis=axis, out=out, mode=mode) + + +def _reshape_dispatcher(a, /, shape=None, order=None, *, newshape=None, + copy=None): + return (a,) + + +@array_function_dispatch(_reshape_dispatcher) +def reshape(a, /, shape=None, order='C', *, newshape=None, copy=None): + """ + Gives a new shape to an array without changing its data. + + Parameters + ---------- + a : array_like + Array to be reshaped. + shape : int or tuple of ints + The new shape should be compatible with the original shape. If + an integer, then the result will be a 1-D array of that length. + One shape dimension can be -1. In this case, the value is + inferred from the length of the array and remaining dimensions. + order : {'C', 'F', 'A'}, optional + Read the elements of ``a`` using this index order, and place the + elements into the reshaped array using this index order. 'C' + means to read / write the elements using C-like index order, + with the last axis index changing fastest, back to the first + axis index changing slowest. 'F' means to read / write the + elements using Fortran-like index order, with the first index + changing fastest, and the last index changing slowest. Note that + the 'C' and 'F' options take no account of the memory layout of + the underlying array, and only refer to the order of indexing. + 'A' means to read / write the elements in Fortran-like index + order if ``a`` is Fortran *contiguous* in memory, C-like order + otherwise. + newshape : int or tuple of ints + .. deprecated:: 2.1 + Replaced by ``shape`` argument. Retained for backward + compatibility. + copy : bool, optional + If ``True``, then the array data is copied. If ``None``, a copy will + only be made if it's required by ``order``. For ``False`` it raises + a ``ValueError`` if a copy cannot be avoided. Default: ``None``. + + Returns + ------- + reshaped_array : ndarray + This will be a new view object if possible; otherwise, it will + be a copy. Note there is no guarantee of the *memory layout* (C- or + Fortran- contiguous) of the returned array. + + See Also + -------- + ndarray.reshape : Equivalent method. + + Notes + ----- + It is not always possible to change the shape of an array without copying + the data. + + The ``order`` keyword gives the index ordering both for *fetching* + the values from ``a``, and then *placing* the values into the output + array. For example, let's say you have an array: + + >>> a = np.arange(6).reshape((3, 2)) + >>> a + array([[0, 1], + [2, 3], + [4, 5]]) + + You can think of reshaping as first raveling the array (using the given + index order), then inserting the elements from the raveled array into the + new array using the same kind of index ordering as was used for the + raveling. + + >>> np.reshape(a, (2, 3)) # C-like index ordering + array([[0, 1, 2], + [3, 4, 5]]) + >>> np.reshape(np.ravel(a), (2, 3)) # equivalent to C ravel then C reshape + array([[0, 1, 2], + [3, 4, 5]]) + >>> np.reshape(a, (2, 3), order='F') # Fortran-like index ordering + array([[0, 4, 3], + [2, 1, 5]]) + >>> np.reshape(np.ravel(a, order='F'), (2, 3), order='F') + array([[0, 4, 3], + [2, 1, 5]]) + + Examples + -------- + >>> import numpy as np + >>> a = np.array([[1,2,3], [4,5,6]]) + >>> np.reshape(a, 6) + array([1, 2, 3, 4, 5, 6]) + >>> np.reshape(a, 6, order='F') + array([1, 4, 2, 5, 3, 6]) + + >>> np.reshape(a, (3,-1)) # the unspecified value is inferred to be 2 + array([[1, 2], + [3, 4], + [5, 6]]) + """ + if newshape is None and shape is None: + raise TypeError( + "reshape() missing 1 required positional argument: 'shape'") + if newshape is not None: + if shape is not None: + raise TypeError( + "You cannot specify 'newshape' and 'shape' arguments " + "at the same time.") + # Deprecated in NumPy 2.1, 2024-04-18 + warnings.warn( + "`newshape` keyword argument is deprecated, " + "use `shape=...` or pass shape positionally instead. " + "(deprecated in NumPy 2.1)", + DeprecationWarning, + stacklevel=2, + ) + shape = newshape + if copy is not None: + return _wrapfunc(a, 'reshape', shape, order=order, copy=copy) + return _wrapfunc(a, 'reshape', shape, order=order) + + +def _choose_dispatcher(a, choices, out=None, mode=None): + yield a + yield from choices + yield out + + +@array_function_dispatch(_choose_dispatcher) +def choose(a, choices, out=None, mode='raise'): + """ + Construct an array from an index array and a list of arrays to choose from. + + First of all, if confused or uncertain, definitely look at the Examples - + in its full generality, this function is less simple than it might + seem from the following code description (below ndi = + `numpy.lib.index_tricks`): + + ``np.choose(a,c) == np.array([c[a[I]][I] for I in ndi.ndindex(a.shape)])``. + + But this omits some subtleties. Here is a fully general summary: + + Given an "index" array (`a`) of integers and a sequence of ``n`` arrays + (`choices`), `a` and each choice array are first broadcast, as necessary, + to arrays of a common shape; calling these *Ba* and *Bchoices[i], i = + 0,...,n-1* we have that, necessarily, ``Ba.shape == Bchoices[i].shape`` + for each ``i``. Then, a new array with shape ``Ba.shape`` is created as + follows: + + * if ``mode='raise'`` (the default), then, first of all, each element of + ``a`` (and thus ``Ba``) must be in the range ``[0, n-1]``; now, suppose + that ``i`` (in that range) is the value at the ``(j0, j1, ..., jm)`` + position in ``Ba`` - then the value at the same position in the new array + is the value in ``Bchoices[i]`` at that same position; + + * if ``mode='wrap'``, values in `a` (and thus `Ba`) may be any (signed) + integer; modular arithmetic is used to map integers outside the range + `[0, n-1]` back into that range; and then the new array is constructed + as above; + + * if ``mode='clip'``, values in `a` (and thus ``Ba``) may be any (signed) + integer; negative integers are mapped to 0; values greater than ``n-1`` + are mapped to ``n-1``; and then the new array is constructed as above. + + Parameters + ---------- + a : int array + This array must contain integers in ``[0, n-1]``, where ``n`` is the + number of choices, unless ``mode=wrap`` or ``mode=clip``, in which + cases any integers are permissible. + choices : sequence of arrays + Choice arrays. `a` and all of the choices must be broadcastable to the + same shape. If `choices` is itself an array (not recommended), then + its outermost dimension (i.e., the one corresponding to + ``choices.shape[0]``) is taken as defining the "sequence". + out : array, optional + If provided, the result will be inserted into this array. It should + be of the appropriate shape and dtype. Note that `out` is always + buffered if ``mode='raise'``; use other modes for better performance. + mode : {'raise' (default), 'wrap', 'clip'}, optional + Specifies how indices outside ``[0, n-1]`` will be treated: + + * 'raise' : an exception is raised + * 'wrap' : value becomes value mod ``n`` + * 'clip' : values < 0 are mapped to 0, values > n-1 are mapped to n-1 + + Returns + ------- + merged_array : array + The merged result. + + Raises + ------ + ValueError: shape mismatch + If `a` and each choice array are not all broadcastable to the same + shape. + + See Also + -------- + ndarray.choose : equivalent method + numpy.take_along_axis : Preferable if `choices` is an array + + Notes + ----- + To reduce the chance of misinterpretation, even though the following + "abuse" is nominally supported, `choices` should neither be, nor be + thought of as, a single array, i.e., the outermost sequence-like container + should be either a list or a tuple. + + Examples + -------- + + >>> import numpy as np + >>> choices = [[0, 1, 2, 3], [10, 11, 12, 13], + ... [20, 21, 22, 23], [30, 31, 32, 33]] + >>> np.choose([2, 3, 1, 0], choices + ... # the first element of the result will be the first element of the + ... # third (2+1) "array" in choices, namely, 20; the second element + ... # will be the second element of the fourth (3+1) choice array, i.e., + ... # 31, etc. + ... ) + array([20, 31, 12, 3]) + >>> np.choose([2, 4, 1, 0], choices, mode='clip') # 4 goes to 3 (4-1) + array([20, 31, 12, 3]) + >>> # because there are 4 choice arrays + >>> np.choose([2, 4, 1, 0], choices, mode='wrap') # 4 goes to (4 mod 4) + array([20, 1, 12, 3]) + >>> # i.e., 0 + + A couple examples illustrating how choose broadcasts: + + >>> a = [[1, 0, 1], [0, 1, 0], [1, 0, 1]] + >>> choices = [-10, 10] + >>> np.choose(a, choices) + array([[ 10, -10, 10], + [-10, 10, -10], + [ 10, -10, 10]]) + + >>> # With thanks to Anne Archibald + >>> a = np.array([0, 1]).reshape((2,1,1)) + >>> c1 = np.array([1, 2, 3]).reshape((1,3,1)) + >>> c2 = np.array([-1, -2, -3, -4, -5]).reshape((1,1,5)) + >>> np.choose(a, (c1, c2)) # result is 2x3x5, res[0,:,:]=c1, res[1,:,:]=c2 + array([[[ 1, 1, 1, 1, 1], + [ 2, 2, 2, 2, 2], + [ 3, 3, 3, 3, 3]], + [[-1, -2, -3, -4, -5], + [-1, -2, -3, -4, -5], + [-1, -2, -3, -4, -5]]]) + + """ + return _wrapfunc(a, 'choose', choices, out=out, mode=mode) + + +def _repeat_dispatcher(a, repeats, axis=None): + return (a,) + + +@array_function_dispatch(_repeat_dispatcher) +def repeat(a, repeats, axis=None): + """ + Repeat each element of an array after themselves + + Parameters + ---------- + a : array_like + Input array. + repeats : int or array of ints + The number of repetitions for each element. `repeats` is broadcasted + to fit the shape of the given axis. + axis : int, optional + The axis along which to repeat values. By default, use the + flattened input array, and return a flat output array. + + Returns + ------- + repeated_array : ndarray + Output array which has the same shape as `a`, except along + the given axis. + + See Also + -------- + tile : Tile an array. + unique : Find the unique elements of an array. + + Examples + -------- + >>> import numpy as np + >>> np.repeat(3, 4) + array([3, 3, 3, 3]) + >>> x = np.array([[1,2],[3,4]]) + >>> np.repeat(x, 2) + array([1, 1, 2, 2, 3, 3, 4, 4]) + >>> np.repeat(x, 3, axis=1) + array([[1, 1, 1, 2, 2, 2], + [3, 3, 3, 4, 4, 4]]) + >>> np.repeat(x, [1, 2], axis=0) + array([[1, 2], + [3, 4], + [3, 4]]) + + """ + return _wrapfunc(a, 'repeat', repeats, axis=axis) + + +def _put_dispatcher(a, ind, v, mode=None): + return (a, ind, v) + + +@array_function_dispatch(_put_dispatcher) +def put(a, ind, v, mode='raise'): + """ + Replaces specified elements of an array with given values. + + The indexing works on the flattened target array. `put` is roughly + equivalent to: + + :: + + a.flat[ind] = v + + Parameters + ---------- + a : ndarray + Target array. + ind : array_like + Target indices, interpreted as integers. + v : array_like + Values to place in `a` at target indices. If `v` is shorter than + `ind` it will be repeated as necessary. + mode : {'raise', 'wrap', 'clip'}, optional + Specifies how out-of-bounds indices will behave. + + * 'raise' -- raise an error (default) + * 'wrap' -- wrap around + * 'clip' -- clip to the range + + 'clip' mode means that all indices that are too large are replaced + by the index that addresses the last element along that axis. Note + that this disables indexing with negative numbers. In 'raise' mode, + if an exception occurs the target array may still be modified. + + See Also + -------- + putmask, place + put_along_axis : Put elements by matching the array and the index arrays + + Examples + -------- + >>> import numpy as np + >>> a = np.arange(5) + >>> np.put(a, [0, 2], [-44, -55]) + >>> a + array([-44, 1, -55, 3, 4]) + + >>> a = np.arange(5) + >>> np.put(a, 22, -5, mode='clip') + >>> a + array([ 0, 1, 2, 3, -5]) + + """ + try: + put = a.put + except AttributeError as e: + raise TypeError("argument 1 must be numpy.ndarray, " + "not {name}".format(name=type(a).__name__)) from e + + return put(ind, v, mode=mode) + + +def _swapaxes_dispatcher(a, axis1, axis2): + return (a,) + + +@array_function_dispatch(_swapaxes_dispatcher) +def swapaxes(a, axis1, axis2): + """ + Interchange two axes of an array. + + Parameters + ---------- + a : array_like + Input array. + axis1 : int + First axis. + axis2 : int + Second axis. + + Returns + ------- + a_swapped : ndarray + For NumPy >= 1.10.0, if `a` is an ndarray, then a view of `a` is + returned; otherwise a new array is created. For earlier NumPy + versions a view of `a` is returned only if the order of the + axes is changed, otherwise the input array is returned. + + Examples + -------- + >>> import numpy as np + >>> x = np.array([[1,2,3]]) + >>> np.swapaxes(x,0,1) + array([[1], + [2], + [3]]) + + >>> x = np.array([[[0,1],[2,3]],[[4,5],[6,7]]]) + >>> x + array([[[0, 1], + [2, 3]], + [[4, 5], + [6, 7]]]) + + >>> np.swapaxes(x,0,2) + array([[[0, 4], + [2, 6]], + [[1, 5], + [3, 7]]]) + + """ + return _wrapfunc(a, 'swapaxes', axis1, axis2) + + +def _transpose_dispatcher(a, axes=None): + return (a,) + + +@array_function_dispatch(_transpose_dispatcher) +def transpose(a, axes=None): + """ + Returns an array with axes transposed. + + For a 1-D array, this returns an unchanged view of the original array, as a + transposed vector is simply the same vector. + To convert a 1-D array into a 2-D column vector, an additional dimension + must be added, e.g., ``np.atleast_2d(a).T`` achieves this, as does + ``a[:, np.newaxis]``. + For a 2-D array, this is the standard matrix transpose. + For an n-D array, if axes are given, their order indicates how the + axes are permuted (see Examples). If axes are not provided, then + ``transpose(a).shape == a.shape[::-1]``. + + Parameters + ---------- + a : array_like + Input array. + axes : tuple or list of ints, optional + If specified, it must be a tuple or list which contains a permutation + of [0,1,...,N-1] where N is the number of axes of `a`. The `i`'th axis + of the returned array will correspond to the axis numbered ``axes[i]`` + of the input. If not specified, defaults to ``range(a.ndim)[::-1]``, + which reverses the order of the axes. + + Returns + ------- + p : ndarray + `a` with its axes permuted. A view is returned whenever possible. + + See Also + -------- + ndarray.transpose : Equivalent method. + moveaxis : Move axes of an array to new positions. + argsort : Return the indices that would sort an array. + + Notes + ----- + Use ``transpose(a, argsort(axes))`` to invert the transposition of tensors + when using the `axes` keyword argument. + + Examples + -------- + >>> import numpy as np + >>> a = np.array([[1, 2], [3, 4]]) + >>> a + array([[1, 2], + [3, 4]]) + >>> np.transpose(a) + array([[1, 3], + [2, 4]]) + + >>> a = np.array([1, 2, 3, 4]) + >>> a + array([1, 2, 3, 4]) + >>> np.transpose(a) + array([1, 2, 3, 4]) + + >>> a = np.ones((1, 2, 3)) + >>> np.transpose(a, (1, 0, 2)).shape + (2, 1, 3) + + >>> a = np.ones((2, 3, 4, 5)) + >>> np.transpose(a).shape + (5, 4, 3, 2) + + """ + return _wrapfunc(a, 'transpose', axes) + + +def _matrix_transpose_dispatcher(x): + return (x,) + +@array_function_dispatch(_matrix_transpose_dispatcher) +def matrix_transpose(x, /): + """ + Transposes a matrix (or a stack of matrices) ``x``. + + This function is Array API compatible. + + Parameters + ---------- + x : array_like + Input array having shape (..., M, N) and whose two innermost + dimensions form ``MxN`` matrices. + + Returns + ------- + out : ndarray + An array containing the transpose for each matrix and having shape + (..., N, M). + + See Also + -------- + transpose : Generic transpose method. + + Examples + -------- + >>> import numpy as np + >>> np.matrix_transpose([[1, 2], [3, 4]]) + array([[1, 3], + [2, 4]]) + + >>> np.matrix_transpose([[[1, 2], [3, 4]], [[5, 6], [7, 8]]]) + array([[[1, 3], + [2, 4]], + [[5, 7], + [6, 8]]]) + + """ + x = asanyarray(x) + if x.ndim < 2: + raise ValueError( + f"Input array must be at least 2-dimensional, but it is {x.ndim}" + ) + return swapaxes(x, -1, -2) + + +def _partition_dispatcher(a, kth, axis=None, kind=None, order=None): + return (a,) + + +@array_function_dispatch(_partition_dispatcher) +def partition(a, kth, axis=-1, kind='introselect', order=None): + """ + Return a partitioned copy of an array. + + Creates a copy of the array and partially sorts it in such a way that + the value of the element in k-th position is in the position it would be + in a sorted array. In the output array, all elements smaller than the k-th + element are located to the left of this element and all equal or greater + are located to its right. The ordering of the elements in the two + partitions on the either side of the k-th element in the output array is + undefined. + + .. versionadded:: 1.8.0 + + Parameters + ---------- + a : array_like + Array to be sorted. + kth : int or sequence of ints + Element index to partition by. The k-th value of the element + will be in its final sorted position and all smaller elements + will be moved before it and all equal or greater elements behind + it. The order of all elements in the partitions is undefined. If + provided with a sequence of k-th it will partition all elements + indexed by k-th of them into their sorted position at once. + + .. deprecated:: 1.22.0 + Passing booleans as index is deprecated. + axis : int or None, optional + Axis along which to sort. If None, the array is flattened before + sorting. The default is -1, which sorts along the last axis. + kind : {'introselect'}, optional + Selection algorithm. Default is 'introselect'. + order : str or list of str, optional + When `a` is an array with fields defined, this argument + specifies which fields to compare first, second, etc. A single + field can be specified as a string. Not all fields need be + specified, but unspecified fields will still be used, in the + order in which they come up in the dtype, to break ties. + + Returns + ------- + partitioned_array : ndarray + Array of the same type and shape as `a`. + + See Also + -------- + ndarray.partition : Method to sort an array in-place. + argpartition : Indirect partition. + sort : Full sorting + + Notes + ----- + The various selection algorithms are characterized by their average + speed, worst case performance, work space size, and whether they are + stable. A stable sort keeps items with the same key in the same + relative order. The available algorithms have the following + properties: + + ================= ======= ============= ============ ======= + kind speed worst case work space stable + ================= ======= ============= ============ ======= + 'introselect' 1 O(n) 0 no + ================= ======= ============= ============ ======= + + All the partition algorithms make temporary copies of the data when + partitioning along any but the last axis. Consequently, + partitioning along the last axis is faster and uses less space than + partitioning along any other axis. + + The sort order for complex numbers is lexicographic. If both the + real and imaginary parts are non-nan then the order is determined by + the real parts except when they are equal, in which case the order + is determined by the imaginary parts. + + The sort order of ``np.nan`` is bigger than ``np.inf``. + + Examples + -------- + >>> import numpy as np + >>> a = np.array([7, 1, 7, 7, 1, 5, 7, 2, 3, 2, 6, 2, 3, 0]) + >>> p = np.partition(a, 4) + >>> p + array([0, 1, 2, 1, 2, 5, 2, 3, 3, 6, 7, 7, 7, 7]) # may vary + + ``p[4]`` is 2; all elements in ``p[:4]`` are less than or equal + to ``p[4]``, and all elements in ``p[5:]`` are greater than or + equal to ``p[4]``. The partition is:: + + [0, 1, 2, 1], [2], [5, 2, 3, 3, 6, 7, 7, 7, 7] + + The next example shows the use of multiple values passed to `kth`. + + >>> p2 = np.partition(a, (4, 8)) + >>> p2 + array([0, 1, 2, 1, 2, 3, 3, 2, 5, 6, 7, 7, 7, 7]) + + ``p2[4]`` is 2 and ``p2[8]`` is 5. All elements in ``p2[:4]`` + are less than or equal to ``p2[4]``, all elements in ``p2[5:8]`` + are greater than or equal to ``p2[4]`` and less than or equal to + ``p2[8]``, and all elements in ``p2[9:]`` are greater than or + equal to ``p2[8]``. The partition is:: + + [0, 1, 2, 1], [2], [3, 3, 2], [5], [6, 7, 7, 7, 7] + """ + if axis is None: + # flatten returns (1, N) for np.matrix, so always use the last axis + a = asanyarray(a).flatten() + axis = -1 + else: + a = asanyarray(a).copy(order="K") + a.partition(kth, axis=axis, kind=kind, order=order) + return a + + +def _argpartition_dispatcher(a, kth, axis=None, kind=None, order=None): + return (a,) + + +@array_function_dispatch(_argpartition_dispatcher) +def argpartition(a, kth, axis=-1, kind='introselect', order=None): + """ + Perform an indirect partition along the given axis using the + algorithm specified by the `kind` keyword. It returns an array of + indices of the same shape as `a` that index data along the given + axis in partitioned order. + + .. versionadded:: 1.8.0 + + Parameters + ---------- + a : array_like + Array to sort. + kth : int or sequence of ints + Element index to partition by. The k-th element will be in its + final sorted position and all smaller elements will be moved + before it and all larger elements behind it. The order of all + elements in the partitions is undefined. If provided with a + sequence of k-th it will partition all of them into their sorted + position at once. + + .. deprecated:: 1.22.0 + Passing booleans as index is deprecated. + axis : int or None, optional + Axis along which to sort. The default is -1 (the last axis). If + None, the flattened array is used. + kind : {'introselect'}, optional + Selection algorithm. Default is 'introselect' + order : str or list of str, optional + When `a` is an array with fields defined, this argument + specifies which fields to compare first, second, etc. A single + field can be specified as a string, and not all fields need be + specified, but unspecified fields will still be used, in the + order in which they come up in the dtype, to break ties. + + Returns + ------- + index_array : ndarray, int + Array of indices that partition `a` along the specified axis. + If `a` is one-dimensional, ``a[index_array]`` yields a partitioned `a`. + More generally, ``np.take_along_axis(a, index_array, axis=axis)`` + always yields the partitioned `a`, irrespective of dimensionality. + + See Also + -------- + partition : Describes partition algorithms used. + ndarray.partition : Inplace partition. + argsort : Full indirect sort. + take_along_axis : Apply ``index_array`` from argpartition + to an array as if by calling partition. + + Notes + ----- + The returned indices are not guaranteed to be sorted according to + the values. Furthermore, the default selection algorithm ``introselect`` + is unstable, and hence the returned indices are not guaranteed + to be the earliest/latest occurrence of the element. + + `argpartition` works for real/complex inputs with nan values, + see `partition` for notes on the enhanced sort order and + different selection algorithms. + + Examples + -------- + One dimensional array: + + >>> import numpy as np + >>> x = np.array([3, 4, 2, 1]) + >>> x[np.argpartition(x, 3)] + array([2, 1, 3, 4]) # may vary + >>> x[np.argpartition(x, (1, 3))] + array([1, 2, 3, 4]) # may vary + + >>> x = [3, 4, 2, 1] + >>> np.array(x)[np.argpartition(x, 3)] + array([2, 1, 3, 4]) # may vary + + Multi-dimensional array: + + >>> x = np.array([[3, 4, 2], [1, 3, 1]]) + >>> index_array = np.argpartition(x, kth=1, axis=-1) + >>> # below is the same as np.partition(x, kth=1) + >>> np.take_along_axis(x, index_array, axis=-1) + array([[2, 3, 4], + [1, 1, 3]]) + + """ + return _wrapfunc(a, 'argpartition', kth, axis=axis, kind=kind, order=order) + + +def _sort_dispatcher(a, axis=None, kind=None, order=None, *, stable=None): + return (a,) + + +@array_function_dispatch(_sort_dispatcher) +def sort(a, axis=-1, kind=None, order=None, *, stable=None): + """ + Return a sorted copy of an array. + + Parameters + ---------- + a : array_like + Array to be sorted. + axis : int or None, optional + Axis along which to sort. If None, the array is flattened before + sorting. The default is -1, which sorts along the last axis. + kind : {'quicksort', 'mergesort', 'heapsort', 'stable'}, optional + Sorting algorithm. The default is 'quicksort'. Note that both 'stable' + and 'mergesort' use timsort or radix sort under the covers and, + in general, the actual implementation will vary with data type. + The 'mergesort' option is retained for backwards compatibility. + + .. versionchanged:: 1.15.0. + The 'stable' option was added. + + order : str or list of str, optional + When `a` is an array with fields defined, this argument specifies + which fields to compare first, second, etc. A single field can + be specified as a string, and not all fields need be specified, + but unspecified fields will still be used, in the order in which + they come up in the dtype, to break ties. + stable : bool, optional + Sort stability. If ``True``, the returned array will maintain + the relative order of ``a`` values which compare as equal. + If ``False`` or ``None``, this is not guaranteed. Internally, + this option selects ``kind='stable'``. Default: ``None``. + + .. versionadded:: 2.0.0 + + Returns + ------- + sorted_array : ndarray + Array of the same type and shape as `a`. + + See Also + -------- + ndarray.sort : Method to sort an array in-place. + argsort : Indirect sort. + lexsort : Indirect stable sort on multiple keys. + searchsorted : Find elements in a sorted array. + partition : Partial sort. + + Notes + ----- + The various sorting algorithms are characterized by their average speed, + worst case performance, work space size, and whether they are stable. A + stable sort keeps items with the same key in the same relative + order. The four algorithms implemented in NumPy have the following + properties: + + =========== ======= ============= ============ ======== + kind speed worst case work space stable + =========== ======= ============= ============ ======== + 'quicksort' 1 O(n^2) 0 no + 'heapsort' 3 O(n*log(n)) 0 no + 'mergesort' 2 O(n*log(n)) ~n/2 yes + 'timsort' 2 O(n*log(n)) ~n/2 yes + =========== ======= ============= ============ ======== + + .. note:: The datatype determines which of 'mergesort' or 'timsort' + is actually used, even if 'mergesort' is specified. User selection + at a finer scale is not currently available. + + For performance, ``sort`` makes a temporary copy if needed to make the data + `contiguous `_ + in memory along the sort axis. For even better performance and reduced + memory consumption, ensure that the array is already contiguous along the + sort axis. + + The sort order for complex numbers is lexicographic. If both the real + and imaginary parts are non-nan then the order is determined by the + real parts except when they are equal, in which case the order is + determined by the imaginary parts. + + Previous to numpy 1.4.0 sorting real and complex arrays containing nan + values led to undefined behaviour. In numpy versions >= 1.4.0 nan + values are sorted to the end. The extended sort order is: + + * Real: [R, nan] + * Complex: [R + Rj, R + nanj, nan + Rj, nan + nanj] + + where R is a non-nan real value. Complex values with the same nan + placements are sorted according to the non-nan part if it exists. + Non-nan values are sorted as before. + + .. versionadded:: 1.12.0 + + quicksort has been changed to: + `introsort `_. + When sorting does not make enough progress it switches to + `heapsort `_. + This implementation makes quicksort O(n*log(n)) in the worst case. + + 'stable' automatically chooses the best stable sorting algorithm + for the data type being sorted. + It, along with 'mergesort' is currently mapped to + `timsort `_ + or `radix sort `_ + depending on the data type. + API forward compatibility currently limits the + ability to select the implementation and it is hardwired for the different + data types. + + .. versionadded:: 1.17.0 + + Timsort is added for better performance on already or nearly + sorted data. On random data timsort is almost identical to + mergesort. It is now used for stable sort while quicksort is still the + default sort if none is chosen. For timsort details, refer to + `CPython listsort.txt + `_ + 'mergesort' and 'stable' are mapped to radix sort for integer data types. + Radix sort is an O(n) sort instead of O(n log n). + + .. versionchanged:: 1.18.0 + + NaT now sorts to the end of arrays for consistency with NaN. + + Examples + -------- + >>> import numpy as np + >>> a = np.array([[1,4],[3,1]]) + >>> np.sort(a) # sort along the last axis + array([[1, 4], + [1, 3]]) + >>> np.sort(a, axis=None) # sort the flattened array + array([1, 1, 3, 4]) + >>> np.sort(a, axis=0) # sort along the first axis + array([[1, 1], + [3, 4]]) + + Use the `order` keyword to specify a field to use when sorting a + structured array: + + >>> dtype = [('name', 'S10'), ('height', float), ('age', int)] + >>> values = [('Arthur', 1.8, 41), ('Lancelot', 1.9, 38), + ... ('Galahad', 1.7, 38)] + >>> a = np.array(values, dtype=dtype) # create a structured array + >>> np.sort(a, order='height') # doctest: +SKIP + array([('Galahad', 1.7, 38), ('Arthur', 1.8, 41), + ('Lancelot', 1.8999999999999999, 38)], + dtype=[('name', '|S10'), ('height', '>> np.sort(a, order=['age', 'height']) # doctest: +SKIP + array([('Galahad', 1.7, 38), ('Lancelot', 1.8999999999999999, 38), + ('Arthur', 1.8, 41)], + dtype=[('name', '|S10'), ('height', '>> import numpy as np + >>> x = np.array([3, 1, 2]) + >>> np.argsort(x) + array([1, 2, 0]) + + Two-dimensional array: + + >>> x = np.array([[0, 3], [2, 2]]) + >>> x + array([[0, 3], + [2, 2]]) + + >>> ind = np.argsort(x, axis=0) # sorts along first axis (down) + >>> ind + array([[0, 1], + [1, 0]]) + >>> np.take_along_axis(x, ind, axis=0) # same as np.sort(x, axis=0) + array([[0, 2], + [2, 3]]) + + >>> ind = np.argsort(x, axis=1) # sorts along last axis (across) + >>> ind + array([[0, 1], + [0, 1]]) + >>> np.take_along_axis(x, ind, axis=1) # same as np.sort(x, axis=1) + array([[0, 3], + [2, 2]]) + + Indices of the sorted elements of a N-dimensional array: + + >>> ind = np.unravel_index(np.argsort(x, axis=None), x.shape) + >>> ind + (array([0, 1, 1, 0]), array([0, 0, 1, 1])) + >>> x[ind] # same as np.sort(x, axis=None) + array([0, 2, 2, 3]) + + Sorting with keys: + + >>> x = np.array([(1, 0), (0, 1)], dtype=[('x', '>> x + array([(1, 0), (0, 1)], + dtype=[('x', '>> np.argsort(x, order=('x','y')) + array([1, 0]) + + >>> np.argsort(x, order=('y','x')) + array([0, 1]) + + """ + return _wrapfunc( + a, 'argsort', axis=axis, kind=kind, order=order, stable=stable + ) + +def _argmax_dispatcher(a, axis=None, out=None, *, keepdims=np._NoValue): + return (a, out) + + +@array_function_dispatch(_argmax_dispatcher) +def argmax(a, axis=None, out=None, *, keepdims=np._NoValue): + """ + Returns the indices of the maximum values along an axis. + + Parameters + ---------- + a : array_like + Input array. + axis : int, optional + By default, the index is into the flattened array, otherwise + along the specified axis. + out : array, optional + If provided, the result will be inserted into this array. It should + be of the appropriate shape and dtype. + keepdims : bool, optional + If this is set to True, the axes which are reduced are left + in the result as dimensions with size one. With this option, + the result will broadcast correctly against the array. + + .. versionadded:: 1.22.0 + + Returns + ------- + index_array : ndarray of ints + Array of indices into the array. It has the same shape as ``a.shape`` + with the dimension along `axis` removed. If `keepdims` is set to True, + then the size of `axis` will be 1 with the resulting array having same + shape as ``a.shape``. + + See Also + -------- + ndarray.argmax, argmin + amax : The maximum value along a given axis. + unravel_index : Convert a flat index into an index tuple. + take_along_axis : Apply ``np.expand_dims(index_array, axis)`` + from argmax to an array as if by calling max. + + Notes + ----- + In case of multiple occurrences of the maximum values, the indices + corresponding to the first occurrence are returned. + + Examples + -------- + >>> import numpy as np + >>> a = np.arange(6).reshape(2,3) + 10 + >>> a + array([[10, 11, 12], + [13, 14, 15]]) + >>> np.argmax(a) + 5 + >>> np.argmax(a, axis=0) + array([1, 1, 1]) + >>> np.argmax(a, axis=1) + array([2, 2]) + + Indexes of the maximal elements of a N-dimensional array: + + >>> ind = np.unravel_index(np.argmax(a, axis=None), a.shape) + >>> ind + (1, 2) + >>> a[ind] + 15 + + >>> b = np.arange(6) + >>> b[1] = 5 + >>> b + array([0, 5, 2, 3, 4, 5]) + >>> np.argmax(b) # Only the first occurrence is returned. + 1 + + >>> x = np.array([[4,2,3], [1,0,3]]) + >>> index_array = np.argmax(x, axis=-1) + >>> # Same as np.amax(x, axis=-1, keepdims=True) + >>> np.take_along_axis(x, np.expand_dims(index_array, axis=-1), axis=-1) + array([[4], + [3]]) + >>> # Same as np.amax(x, axis=-1) + >>> np.take_along_axis(x, np.expand_dims(index_array, axis=-1), + ... axis=-1).squeeze(axis=-1) + array([4, 3]) + + Setting `keepdims` to `True`, + + >>> x = np.arange(24).reshape((2, 3, 4)) + >>> res = np.argmax(x, axis=1, keepdims=True) + >>> res.shape + (2, 1, 4) + """ + kwds = {'keepdims': keepdims} if keepdims is not np._NoValue else {} + return _wrapfunc(a, 'argmax', axis=axis, out=out, **kwds) + + +def _argmin_dispatcher(a, axis=None, out=None, *, keepdims=np._NoValue): + return (a, out) + + +@array_function_dispatch(_argmin_dispatcher) +def argmin(a, axis=None, out=None, *, keepdims=np._NoValue): + """ + Returns the indices of the minimum values along an axis. + + Parameters + ---------- + a : array_like + Input array. + axis : int, optional + By default, the index is into the flattened array, otherwise + along the specified axis. + out : array, optional + If provided, the result will be inserted into this array. It should + be of the appropriate shape and dtype. + keepdims : bool, optional + If this is set to True, the axes which are reduced are left + in the result as dimensions with size one. With this option, + the result will broadcast correctly against the array. + + .. versionadded:: 1.22.0 + + Returns + ------- + index_array : ndarray of ints + Array of indices into the array. It has the same shape as `a.shape` + with the dimension along `axis` removed. If `keepdims` is set to True, + then the size of `axis` will be 1 with the resulting array having same + shape as `a.shape`. + + See Also + -------- + ndarray.argmin, argmax + amin : The minimum value along a given axis. + unravel_index : Convert a flat index into an index tuple. + take_along_axis : Apply ``np.expand_dims(index_array, axis)`` + from argmin to an array as if by calling min. + + Notes + ----- + In case of multiple occurrences of the minimum values, the indices + corresponding to the first occurrence are returned. + + Examples + -------- + >>> import numpy as np + >>> a = np.arange(6).reshape(2,3) + 10 + >>> a + array([[10, 11, 12], + [13, 14, 15]]) + >>> np.argmin(a) + 0 + >>> np.argmin(a, axis=0) + array([0, 0, 0]) + >>> np.argmin(a, axis=1) + array([0, 0]) + + Indices of the minimum elements of a N-dimensional array: + + >>> ind = np.unravel_index(np.argmin(a, axis=None), a.shape) + >>> ind + (0, 0) + >>> a[ind] + 10 + + >>> b = np.arange(6) + 10 + >>> b[4] = 10 + >>> b + array([10, 11, 12, 13, 10, 15]) + >>> np.argmin(b) # Only the first occurrence is returned. + 0 + + >>> x = np.array([[4,2,3], [1,0,3]]) + >>> index_array = np.argmin(x, axis=-1) + >>> # Same as np.amin(x, axis=-1, keepdims=True) + >>> np.take_along_axis(x, np.expand_dims(index_array, axis=-1), axis=-1) + array([[2], + [0]]) + >>> # Same as np.amax(x, axis=-1) + >>> np.take_along_axis(x, np.expand_dims(index_array, axis=-1), + ... axis=-1).squeeze(axis=-1) + array([2, 0]) + + Setting `keepdims` to `True`, + + >>> x = np.arange(24).reshape((2, 3, 4)) + >>> res = np.argmin(x, axis=1, keepdims=True) + >>> res.shape + (2, 1, 4) + """ + kwds = {'keepdims': keepdims} if keepdims is not np._NoValue else {} + return _wrapfunc(a, 'argmin', axis=axis, out=out, **kwds) + + +def _searchsorted_dispatcher(a, v, side=None, sorter=None): + return (a, v, sorter) + + +@array_function_dispatch(_searchsorted_dispatcher) +def searchsorted(a, v, side='left', sorter=None): + """ + Find indices where elements should be inserted to maintain order. + + Find the indices into a sorted array `a` such that, if the + corresponding elements in `v` were inserted before the indices, the + order of `a` would be preserved. + + Assuming that `a` is sorted: + + ====== ============================ + `side` returned index `i` satisfies + ====== ============================ + left ``a[i-1] < v <= a[i]`` + right ``a[i-1] <= v < a[i]`` + ====== ============================ + + Parameters + ---------- + a : 1-D array_like + Input array. If `sorter` is None, then it must be sorted in + ascending order, otherwise `sorter` must be an array of indices + that sort it. + v : array_like + Values to insert into `a`. + side : {'left', 'right'}, optional + If 'left', the index of the first suitable location found is given. + If 'right', return the last such index. If there is no suitable + index, return either 0 or N (where N is the length of `a`). + sorter : 1-D array_like, optional + Optional array of integer indices that sort array a into ascending + order. They are typically the result of argsort. + + .. versionadded:: 1.7.0 + + Returns + ------- + indices : int or array of ints + Array of insertion points with the same shape as `v`, + or an integer if `v` is a scalar. + + See Also + -------- + sort : Return a sorted copy of an array. + histogram : Produce histogram from 1-D data. + + Notes + ----- + Binary search is used to find the required insertion points. + + As of NumPy 1.4.0 `searchsorted` works with real/complex arrays containing + `nan` values. The enhanced sort order is documented in `sort`. + + This function uses the same algorithm as the builtin python + `bisect.bisect_left` (``side='left'``) and `bisect.bisect_right` + (``side='right'``) functions, which is also vectorized + in the `v` argument. + + Examples + -------- + >>> import numpy as np + >>> np.searchsorted([11,12,13,14,15], 13) + 2 + >>> np.searchsorted([11,12,13,14,15], 13, side='right') + 3 + >>> np.searchsorted([11,12,13,14,15], [-10, 20, 12, 13]) + array([0, 5, 1, 2]) + + """ + return _wrapfunc(a, 'searchsorted', v, side=side, sorter=sorter) + + +def _resize_dispatcher(a, new_shape): + return (a,) + + +@array_function_dispatch(_resize_dispatcher) +def resize(a, new_shape): + """ + Return a new array with the specified shape. + + If the new array is larger than the original array, then the new + array is filled with repeated copies of `a`. Note that this behavior + is different from a.resize(new_shape) which fills with zeros instead + of repeated copies of `a`. + + Parameters + ---------- + a : array_like + Array to be resized. + + new_shape : int or tuple of int + Shape of resized array. + + Returns + ------- + reshaped_array : ndarray + The new array is formed from the data in the old array, repeated + if necessary to fill out the required number of elements. The + data are repeated iterating over the array in C-order. + + See Also + -------- + numpy.reshape : Reshape an array without changing the total size. + numpy.pad : Enlarge and pad an array. + numpy.repeat : Repeat elements of an array. + ndarray.resize : resize an array in-place. + + Notes + ----- + When the total size of the array does not change `~numpy.reshape` should + be used. In most other cases either indexing (to reduce the size) + or padding (to increase the size) may be a more appropriate solution. + + Warning: This functionality does **not** consider axes separately, + i.e. it does not apply interpolation/extrapolation. + It fills the return array with the required number of elements, iterating + over `a` in C-order, disregarding axes (and cycling back from the start if + the new shape is larger). This functionality is therefore not suitable to + resize images, or data where each axis represents a separate and distinct + entity. + + Examples + -------- + >>> import numpy as np + >>> a = np.array([[0,1],[2,3]]) + >>> np.resize(a,(2,3)) + array([[0, 1, 2], + [3, 0, 1]]) + >>> np.resize(a,(1,4)) + array([[0, 1, 2, 3]]) + >>> np.resize(a,(2,4)) + array([[0, 1, 2, 3], + [0, 1, 2, 3]]) + + """ + if isinstance(new_shape, (int, nt.integer)): + new_shape = (new_shape,) + + a = ravel(a) + + new_size = 1 + for dim_length in new_shape: + new_size *= dim_length + if dim_length < 0: + raise ValueError( + 'all elements of `new_shape` must be non-negative' + ) + + if a.size == 0 or new_size == 0: + # First case must zero fill. The second would have repeats == 0. + return np.zeros_like(a, shape=new_shape) + + repeats = -(-new_size // a.size) # ceil division + a = concatenate((a,) * repeats)[:new_size] + + return reshape(a, new_shape) + + +def _squeeze_dispatcher(a, axis=None): + return (a,) + + +@array_function_dispatch(_squeeze_dispatcher) +def squeeze(a, axis=None): + """ + Remove axes of length one from `a`. + + Parameters + ---------- + a : array_like + Input data. + axis : None or int or tuple of ints, optional + .. versionadded:: 1.7.0 + + Selects a subset of the entries of length one in the + shape. If an axis is selected with shape entry greater than + one, an error is raised. + + Returns + ------- + squeezed : ndarray + The input array, but with all or a subset of the + dimensions of length 1 removed. This is always `a` itself + or a view into `a`. Note that if all axes are squeezed, + the result is a 0d array and not a scalar. + + Raises + ------ + ValueError + If `axis` is not None, and an axis being squeezed is not of length 1 + + See Also + -------- + expand_dims : The inverse operation, adding entries of length one + reshape : Insert, remove, and combine dimensions, and resize existing ones + + Examples + -------- + >>> import numpy as np + >>> x = np.array([[[0], [1], [2]]]) + >>> x.shape + (1, 3, 1) + >>> np.squeeze(x).shape + (3,) + >>> np.squeeze(x, axis=0).shape + (3, 1) + >>> np.squeeze(x, axis=1).shape + Traceback (most recent call last): + ... + ValueError: cannot select an axis to squeeze out which has size + not equal to one + >>> np.squeeze(x, axis=2).shape + (1, 3) + >>> x = np.array([[1234]]) + >>> x.shape + (1, 1) + >>> np.squeeze(x) + array(1234) # 0d array + >>> np.squeeze(x).shape + () + >>> np.squeeze(x)[()] + 1234 + + """ + try: + squeeze = a.squeeze + except AttributeError: + return _wrapit(a, 'squeeze', axis=axis) + if axis is None: + return squeeze() + else: + return squeeze(axis=axis) + + +def _diagonal_dispatcher(a, offset=None, axis1=None, axis2=None): + return (a,) + + +@array_function_dispatch(_diagonal_dispatcher) +def diagonal(a, offset=0, axis1=0, axis2=1): + """ + Return specified diagonals. + + If `a` is 2-D, returns the diagonal of `a` with the given offset, + i.e., the collection of elements of the form ``a[i, i+offset]``. If + `a` has more than two dimensions, then the axes specified by `axis1` + and `axis2` are used to determine the 2-D sub-array whose diagonal is + returned. The shape of the resulting array can be determined by + removing `axis1` and `axis2` and appending an index to the right equal + to the size of the resulting diagonals. + + In versions of NumPy prior to 1.7, this function always returned a new, + independent array containing a copy of the values in the diagonal. + + In NumPy 1.7 and 1.8, it continues to return a copy of the diagonal, + but depending on this fact is deprecated. Writing to the resulting + array continues to work as it used to, but a FutureWarning is issued. + + Starting in NumPy 1.9 it returns a read-only view on the original array. + Attempting to write to the resulting array will produce an error. + + In some future release, it will return a read/write view and writing to + the returned array will alter your original array. The returned array + will have the same type as the input array. + + If you don't write to the array returned by this function, then you can + just ignore all of the above. + + If you depend on the current behavior, then we suggest copying the + returned array explicitly, i.e., use ``np.diagonal(a).copy()`` instead + of just ``np.diagonal(a)``. This will work with both past and future + versions of NumPy. + + Parameters + ---------- + a : array_like + Array from which the diagonals are taken. + offset : int, optional + Offset of the diagonal from the main diagonal. Can be positive or + negative. Defaults to main diagonal (0). + axis1 : int, optional + Axis to be used as the first axis of the 2-D sub-arrays from which + the diagonals should be taken. Defaults to first axis (0). + axis2 : int, optional + Axis to be used as the second axis of the 2-D sub-arrays from + which the diagonals should be taken. Defaults to second axis (1). + + Returns + ------- + array_of_diagonals : ndarray + If `a` is 2-D, then a 1-D array containing the diagonal and of the + same type as `a` is returned unless `a` is a `matrix`, in which case + a 1-D array rather than a (2-D) `matrix` is returned in order to + maintain backward compatibility. + + If ``a.ndim > 2``, then the dimensions specified by `axis1` and `axis2` + are removed, and a new axis inserted at the end corresponding to the + diagonal. + + Raises + ------ + ValueError + If the dimension of `a` is less than 2. + + See Also + -------- + diag : MATLAB work-a-like for 1-D and 2-D arrays. + diagflat : Create diagonal arrays. + trace : Sum along diagonals. + + Examples + -------- + >>> import numpy as np + >>> a = np.arange(4).reshape(2,2) + >>> a + array([[0, 1], + [2, 3]]) + >>> a.diagonal() + array([0, 3]) + >>> a.diagonal(1) + array([1]) + + A 3-D example: + + >>> a = np.arange(8).reshape(2,2,2); a + array([[[0, 1], + [2, 3]], + [[4, 5], + [6, 7]]]) + >>> a.diagonal(0, # Main diagonals of two arrays created by skipping + ... 0, # across the outer(left)-most axis last and + ... 1) # the "middle" (row) axis first. + array([[0, 6], + [1, 7]]) + + The sub-arrays whose main diagonals we just obtained; note that each + corresponds to fixing the right-most (column) axis, and that the + diagonals are "packed" in rows. + + >>> a[:,:,0] # main diagonal is [0 6] + array([[0, 2], + [4, 6]]) + >>> a[:,:,1] # main diagonal is [1 7] + array([[1, 3], + [5, 7]]) + + The anti-diagonal can be obtained by reversing the order of elements + using either `numpy.flipud` or `numpy.fliplr`. + + >>> a = np.arange(9).reshape(3, 3) + >>> a + array([[0, 1, 2], + [3, 4, 5], + [6, 7, 8]]) + >>> np.fliplr(a).diagonal() # Horizontal flip + array([2, 4, 6]) + >>> np.flipud(a).diagonal() # Vertical flip + array([6, 4, 2]) + + Note that the order in which the diagonal is retrieved varies depending + on the flip function. + """ + if isinstance(a, np.matrix): + # Make diagonal of matrix 1-D to preserve backward compatibility. + return asarray(a).diagonal(offset=offset, axis1=axis1, axis2=axis2) + else: + return asanyarray(a).diagonal(offset=offset, axis1=axis1, axis2=axis2) + + +def _trace_dispatcher( + a, offset=None, axis1=None, axis2=None, dtype=None, out=None): + return (a, out) + + +@array_function_dispatch(_trace_dispatcher) +def trace(a, offset=0, axis1=0, axis2=1, dtype=None, out=None): + """ + Return the sum along diagonals of the array. + + If `a` is 2-D, the sum along its diagonal with the given offset + is returned, i.e., the sum of elements ``a[i,i+offset]`` for all i. + + If `a` has more than two dimensions, then the axes specified by axis1 and + axis2 are used to determine the 2-D sub-arrays whose traces are returned. + The shape of the resulting array is the same as that of `a` with `axis1` + and `axis2` removed. + + Parameters + ---------- + a : array_like + Input array, from which the diagonals are taken. + offset : int, optional + Offset of the diagonal from the main diagonal. Can be both positive + and negative. Defaults to 0. + axis1, axis2 : int, optional + Axes to be used as the first and second axis of the 2-D sub-arrays + from which the diagonals should be taken. Defaults are the first two + axes of `a`. + dtype : dtype, optional + Determines the data-type of the returned array and of the accumulator + where the elements are summed. If dtype has the value None and `a` is + of integer type of precision less than the default integer + precision, then the default integer precision is used. Otherwise, + the precision is the same as that of `a`. + out : ndarray, optional + Array into which the output is placed. Its type is preserved and + it must be of the right shape to hold the output. + + Returns + ------- + sum_along_diagonals : ndarray + If `a` is 2-D, the sum along the diagonal is returned. If `a` has + larger dimensions, then an array of sums along diagonals is returned. + + See Also + -------- + diag, diagonal, diagflat + + Examples + -------- + >>> import numpy as np + >>> np.trace(np.eye(3)) + 3.0 + >>> a = np.arange(8).reshape((2,2,2)) + >>> np.trace(a) + array([6, 8]) + + >>> a = np.arange(24).reshape((2,2,2,3)) + >>> np.trace(a).shape + (2, 3) + + """ + if isinstance(a, np.matrix): + # Get trace of matrix via an array to preserve backward compatibility. + return asarray(a).trace( + offset=offset, axis1=axis1, axis2=axis2, dtype=dtype, out=out + ) + else: + return asanyarray(a).trace( + offset=offset, axis1=axis1, axis2=axis2, dtype=dtype, out=out + ) + + +def _ravel_dispatcher(a, order=None): + return (a,) + + +@array_function_dispatch(_ravel_dispatcher) +def ravel(a, order='C'): + """Return a contiguous flattened array. + + A 1-D array, containing the elements of the input, is returned. A copy is + made only if needed. + + As of NumPy 1.10, the returned array will have the same type as the input + array. (for example, a masked array will be returned for a masked array + input) + + Parameters + ---------- + a : array_like + Input array. The elements in `a` are read in the order specified by + `order`, and packed as a 1-D array. + order : {'C','F', 'A', 'K'}, optional + + The elements of `a` are read using this index order. 'C' means + to index the elements in row-major, C-style order, + with the last axis index changing fastest, back to the first + axis index changing slowest. 'F' means to index the elements + in column-major, Fortran-style order, with the + first index changing fastest, and the last index changing + slowest. Note that the 'C' and 'F' options take no account of + the memory layout of the underlying array, and only refer to + the order of axis indexing. 'A' means to read the elements in + Fortran-like index order if `a` is Fortran *contiguous* in + memory, C-like order otherwise. 'K' means to read the + elements in the order they occur in memory, except for + reversing the data when strides are negative. By default, 'C' + index order is used. + + Returns + ------- + y : array_like + y is a contiguous 1-D array of the same subtype as `a`, + with shape ``(a.size,)``. + Note that matrices are special cased for backward compatibility, + if `a` is a matrix, then y is a 1-D ndarray. + + See Also + -------- + ndarray.flat : 1-D iterator over an array. + ndarray.flatten : 1-D array copy of the elements of an array + in row-major order. + ndarray.reshape : Change the shape of an array without changing its data. + + Notes + ----- + In row-major, C-style order, in two dimensions, the row index + varies the slowest, and the column index the quickest. This can + be generalized to multiple dimensions, where row-major order + implies that the index along the first axis varies slowest, and + the index along the last quickest. The opposite holds for + column-major, Fortran-style index ordering. + + When a view is desired in as many cases as possible, ``arr.reshape(-1)`` + may be preferable. However, ``ravel`` supports ``K`` in the optional + ``order`` argument while ``reshape`` does not. + + Examples + -------- + It is equivalent to ``reshape(-1, order=order)``. + + >>> import numpy as np + >>> x = np.array([[1, 2, 3], [4, 5, 6]]) + >>> np.ravel(x) + array([1, 2, 3, 4, 5, 6]) + + >>> x.reshape(-1) + array([1, 2, 3, 4, 5, 6]) + + >>> np.ravel(x, order='F') + array([1, 4, 2, 5, 3, 6]) + + When ``order`` is 'A', it will preserve the array's 'C' or 'F' ordering: + + >>> np.ravel(x.T) + array([1, 4, 2, 5, 3, 6]) + >>> np.ravel(x.T, order='A') + array([1, 2, 3, 4, 5, 6]) + + When ``order`` is 'K', it will preserve orderings that are neither 'C' + nor 'F', but won't reverse axes: + + >>> a = np.arange(3)[::-1]; a + array([2, 1, 0]) + >>> a.ravel(order='C') + array([2, 1, 0]) + >>> a.ravel(order='K') + array([2, 1, 0]) + + >>> a = np.arange(12).reshape(2,3,2).swapaxes(1,2); a + array([[[ 0, 2, 4], + [ 1, 3, 5]], + [[ 6, 8, 10], + [ 7, 9, 11]]]) + >>> a.ravel(order='C') + array([ 0, 2, 4, 1, 3, 5, 6, 8, 10, 7, 9, 11]) + >>> a.ravel(order='K') + array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]) + + """ + if isinstance(a, np.matrix): + return asarray(a).ravel(order=order) + else: + return asanyarray(a).ravel(order=order) + + +def _nonzero_dispatcher(a): + return (a,) + + +@array_function_dispatch(_nonzero_dispatcher) +def nonzero(a): + """ + Return the indices of the elements that are non-zero. + + Returns a tuple of arrays, one for each dimension of `a`, + containing the indices of the non-zero elements in that + dimension. The values in `a` are always tested and returned in + row-major, C-style order. + + To group the indices by element, rather than dimension, use `argwhere`, + which returns a row for each non-zero element. + + .. note:: + + When called on a zero-d array or scalar, ``nonzero(a)`` is treated + as ``nonzero(atleast_1d(a))``. + + .. deprecated:: 1.17.0 + + Use `atleast_1d` explicitly if this behavior is deliberate. + + Parameters + ---------- + a : array_like + Input array. + + Returns + ------- + tuple_of_arrays : tuple + Indices of elements that are non-zero. + + See Also + -------- + flatnonzero : + Return indices that are non-zero in the flattened version of the input + array. + ndarray.nonzero : + Equivalent ndarray method. + count_nonzero : + Counts the number of non-zero elements in the input array. + + Notes + ----- + While the nonzero values can be obtained with ``a[nonzero(a)]``, it is + recommended to use ``x[x.astype(bool)]`` or ``x[x != 0]`` instead, which + will correctly handle 0-d arrays. + + Examples + -------- + >>> import numpy as np + >>> x = np.array([[3, 0, 0], [0, 4, 0], [5, 6, 0]]) + >>> x + array([[3, 0, 0], + [0, 4, 0], + [5, 6, 0]]) + >>> np.nonzero(x) + (array([0, 1, 2, 2]), array([0, 1, 0, 1])) + + >>> x[np.nonzero(x)] + array([3, 4, 5, 6]) + >>> np.transpose(np.nonzero(x)) + array([[0, 0], + [1, 1], + [2, 0], + [2, 1]]) + + A common use for ``nonzero`` is to find the indices of an array, where + a condition is True. Given an array `a`, the condition `a` > 3 is a + boolean array and since False is interpreted as 0, np.nonzero(a > 3) + yields the indices of the `a` where the condition is true. + + >>> a = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]) + >>> a > 3 + array([[False, False, False], + [ True, True, True], + [ True, True, True]]) + >>> np.nonzero(a > 3) + (array([1, 1, 1, 2, 2, 2]), array([0, 1, 2, 0, 1, 2])) + + Using this result to index `a` is equivalent to using the mask directly: + + >>> a[np.nonzero(a > 3)] + array([4, 5, 6, 7, 8, 9]) + >>> a[a > 3] # prefer this spelling + array([4, 5, 6, 7, 8, 9]) + + ``nonzero`` can also be called as a method of the array. + + >>> (a > 3).nonzero() + (array([1, 1, 1, 2, 2, 2]), array([0, 1, 2, 0, 1, 2])) + + """ + return _wrapfunc(a, 'nonzero') + + +def _shape_dispatcher(a): + return (a,) + + +@array_function_dispatch(_shape_dispatcher) +def shape(a): + """ + Return the shape of an array. + + Parameters + ---------- + a : array_like + Input array. + + Returns + ------- + shape : tuple of ints + The elements of the shape tuple give the lengths of the + corresponding array dimensions. + + See Also + -------- + len : ``len(a)`` is equivalent to ``np.shape(a)[0]`` for N-D arrays with + ``N>=1``. + ndarray.shape : Equivalent array method. + + Examples + -------- + >>> import numpy as np + >>> np.shape(np.eye(3)) + (3, 3) + >>> np.shape([[1, 3]]) + (1, 2) + >>> np.shape([0]) + (1,) + >>> np.shape(0) + () + + >>> a = np.array([(1, 2), (3, 4), (5, 6)], + ... dtype=[('x', 'i4'), ('y', 'i4')]) + >>> np.shape(a) + (3,) + >>> a.shape + (3,) + + """ + try: + result = a.shape + except AttributeError: + result = asarray(a).shape + return result + + +def _compress_dispatcher(condition, a, axis=None, out=None): + return (condition, a, out) + + +@array_function_dispatch(_compress_dispatcher) +def compress(condition, a, axis=None, out=None): + """ + Return selected slices of an array along given axis. + + When working along a given axis, a slice along that axis is returned in + `output` for each index where `condition` evaluates to True. When + working on a 1-D array, `compress` is equivalent to `extract`. + + Parameters + ---------- + condition : 1-D array of bools + Array that selects which entries to return. If len(condition) + is less than the size of `a` along the given axis, then output is + truncated to the length of the condition array. + a : array_like + Array from which to extract a part. + axis : int, optional + Axis along which to take slices. If None (default), work on the + flattened array. + out : ndarray, optional + Output array. Its type is preserved and it must be of the right + shape to hold the output. + + Returns + ------- + compressed_array : ndarray + A copy of `a` without the slices along axis for which `condition` + is false. + + See Also + -------- + take, choose, diag, diagonal, select + ndarray.compress : Equivalent method in ndarray + extract : Equivalent method when working on 1-D arrays + :ref:`ufuncs-output-type` + + Examples + -------- + >>> import numpy as np + >>> a = np.array([[1, 2], [3, 4], [5, 6]]) + >>> a + array([[1, 2], + [3, 4], + [5, 6]]) + >>> np.compress([0, 1], a, axis=0) + array([[3, 4]]) + >>> np.compress([False, True, True], a, axis=0) + array([[3, 4], + [5, 6]]) + >>> np.compress([False, True], a, axis=1) + array([[2], + [4], + [6]]) + + Working on the flattened array does not return slices along an axis but + selects elements. + + >>> np.compress([False, True], a) + array([2]) + + """ + return _wrapfunc(a, 'compress', condition, axis=axis, out=out) + + +def _clip_dispatcher(a, a_min=None, a_max=None, out=None, *, min=None, + max=None, **kwargs): + return (a, a_min, a_max, out, min, max) + + +@array_function_dispatch(_clip_dispatcher) +def clip(a, a_min=np._NoValue, a_max=np._NoValue, out=None, *, + min=np._NoValue, max=np._NoValue, **kwargs): + """ + Clip (limit) the values in an array. + + Given an interval, values outside the interval are clipped to + the interval edges. For example, if an interval of ``[0, 1]`` + is specified, values smaller than 0 become 0, and values larger + than 1 become 1. + + Equivalent to but faster than ``np.minimum(a_max, np.maximum(a, a_min))``. + + No check is performed to ensure ``a_min < a_max``. + + Parameters + ---------- + a : array_like + Array containing elements to clip. + a_min, a_max : array_like or None + Minimum and maximum value. If ``None``, clipping is not performed on + the corresponding edge. If both ``a_min`` and ``a_max`` are ``None``, + the elements of the returned array stay the same. Both are broadcasted + against ``a``. + out : ndarray, optional + The results will be placed in this array. It may be the input + array for in-place clipping. `out` must be of the right shape + to hold the output. Its type is preserved. + min, max : array_like or None + Array API compatible alternatives for ``a_min`` and ``a_max`` + arguments. Either ``a_min`` and ``a_max`` or ``min`` and ``max`` + can be passed at the same time. Default: ``None``. + + .. versionadded:: 2.1.0 + **kwargs + For other keyword-only arguments, see the + :ref:`ufunc docs `. + + .. versionadded:: 1.17.0 + + Returns + ------- + clipped_array : ndarray + An array with the elements of `a`, but where values + < `a_min` are replaced with `a_min`, and those > `a_max` + with `a_max`. + + See Also + -------- + :ref:`ufuncs-output-type` + + Notes + ----- + When `a_min` is greater than `a_max`, `clip` returns an + array in which all values are equal to `a_max`, + as shown in the second example. + + Examples + -------- + >>> import numpy as np + >>> a = np.arange(10) + >>> a + array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]) + >>> np.clip(a, 1, 8) + array([1, 1, 2, 3, 4, 5, 6, 7, 8, 8]) + >>> np.clip(a, 8, 1) + array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1]) + >>> np.clip(a, 3, 6, out=a) + array([3, 3, 3, 3, 4, 5, 6, 6, 6, 6]) + >>> a + array([3, 3, 3, 3, 4, 5, 6, 6, 6, 6]) + >>> a = np.arange(10) + >>> a + array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]) + >>> np.clip(a, [3, 4, 1, 1, 1, 4, 4, 4, 4, 4], 8) + array([3, 4, 2, 3, 4, 5, 6, 7, 8, 8]) + + """ + if a_min is np._NoValue and a_max is np._NoValue: + a_min = None if min is np._NoValue else min + a_max = None if max is np._NoValue else max + elif a_min is np._NoValue: + raise TypeError("clip() missing 1 required positional " + "argument: 'a_min'") + elif a_max is np._NoValue: + raise TypeError("clip() missing 1 required positional " + "argument: 'a_max'") + elif min is not np._NoValue or max is not np._NoValue: + raise ValueError("Passing `min` or `max` keyword argument when " + "`a_min` and `a_max` are provided is forbidden.") + + return _wrapfunc(a, 'clip', a_min, a_max, out=out, **kwargs) + + +def _sum_dispatcher(a, axis=None, dtype=None, out=None, keepdims=None, + initial=None, where=None): + return (a, out) + + +@array_function_dispatch(_sum_dispatcher) +def sum(a, axis=None, dtype=None, out=None, keepdims=np._NoValue, + initial=np._NoValue, where=np._NoValue): + """ + Sum of array elements over a given axis. + + Parameters + ---------- + a : array_like + Elements to sum. + axis : None or int or tuple of ints, optional + Axis or axes along which a sum is performed. The default, + axis=None, will sum all of the elements of the input array. If + axis is negative it counts from the last to the first axis. + + .. versionadded:: 1.7.0 + + If axis is a tuple of ints, a sum is performed on all of the axes + specified in the tuple instead of a single axis or all the axes as + before. + dtype : dtype, optional + The type of the returned array and of the accumulator in which the + elements are summed. The dtype of `a` is used by default unless `a` + has an integer dtype of less precision than the default platform + integer. In that case, if `a` is signed then the platform integer + is used while if `a` is unsigned then an unsigned integer of the + same precision as the platform integer is used. + out : ndarray, optional + Alternative output array in which to place the result. It must have + the same shape as the expected output, but the type of the output + values will be cast if necessary. + keepdims : bool, optional + If this is set to True, the axes which are reduced are left + in the result as dimensions with size one. With this option, + the result will broadcast correctly against the input array. + + If the default value is passed, then `keepdims` will not be + passed through to the `sum` method of sub-classes of + `ndarray`, however any non-default value will be. If the + sub-class' method does not implement `keepdims` any + exceptions will be raised. + initial : scalar, optional + Starting value for the sum. See `~numpy.ufunc.reduce` for details. + + .. versionadded:: 1.15.0 + + where : array_like of bool, optional + Elements to include in the sum. See `~numpy.ufunc.reduce` for details. + + .. versionadded:: 1.17.0 + + Returns + ------- + sum_along_axis : ndarray + An array with the same shape as `a`, with the specified + axis removed. If `a` is a 0-d array, or if `axis` is None, a scalar + is returned. If an output array is specified, a reference to + `out` is returned. + + See Also + -------- + ndarray.sum : Equivalent method. + add: ``numpy.add.reduce`` equivalent function. + cumsum : Cumulative sum of array elements. + trapezoid : Integration of array values using composite trapezoidal rule. + + mean, average + + Notes + ----- + Arithmetic is modular when using integer types, and no error is + raised on overflow. + + The sum of an empty array is the neutral element 0: + + >>> np.sum([]) + 0.0 + + For floating point numbers the numerical precision of sum (and + ``np.add.reduce``) is in general limited by directly adding each number + individually to the result causing rounding errors in every step. + However, often numpy will use a numerically better approach (partial + pairwise summation) leading to improved precision in many use-cases. + This improved precision is always provided when no ``axis`` is given. + When ``axis`` is given, it will depend on which axis is summed. + Technically, to provide the best speed possible, the improved precision + is only used when the summation is along the fast axis in memory. + Note that the exact precision may vary depending on other parameters. + In contrast to NumPy, Python's ``math.fsum`` function uses a slower but + more precise approach to summation. + Especially when summing a large number of lower precision floating point + numbers, such as ``float32``, numerical errors can become significant. + In such cases it can be advisable to use `dtype="float64"` to use a higher + precision for the output. + + Examples + -------- + >>> import numpy as np + >>> np.sum([0.5, 1.5]) + 2.0 + >>> np.sum([0.5, 0.7, 0.2, 1.5], dtype=np.int32) + 1 + >>> np.sum([[0, 1], [0, 5]]) + 6 + >>> np.sum([[0, 1], [0, 5]], axis=0) + array([0, 6]) + >>> np.sum([[0, 1], [0, 5]], axis=1) + array([1, 5]) + >>> np.sum([[0, 1], [np.nan, 5]], where=[False, True], axis=1) + array([1., 5.]) + + If the accumulator is too small, overflow occurs: + + >>> np.ones(128, dtype=np.int8).sum(dtype=np.int8) + -128 + + You can also start the sum with a value other than zero: + + >>> np.sum([10], initial=5) + 15 + """ + if isinstance(a, _gentype): + # 2018-02-25, 1.15.0 + warnings.warn( + "Calling np.sum(generator) is deprecated, and in the future will " + "give a different result. Use np.sum(np.fromiter(generator)) or " + "the python sum builtin instead.", + DeprecationWarning, stacklevel=2 + ) + + res = _sum_(a) + if out is not None: + out[...] = res + return out + return res + + return _wrapreduction( + a, np.add, 'sum', axis, dtype, out, + keepdims=keepdims, initial=initial, where=where + ) + + +def _any_dispatcher(a, axis=None, out=None, keepdims=None, *, + where=np._NoValue): + return (a, where, out) + + +@array_function_dispatch(_any_dispatcher) +def any(a, axis=None, out=None, keepdims=np._NoValue, *, where=np._NoValue): + """ + Test whether any array element along a given axis evaluates to True. + + Returns single boolean if `axis` is ``None`` + + Parameters + ---------- + a : array_like + Input array or object that can be converted to an array. + axis : None or int or tuple of ints, optional + Axis or axes along which a logical OR reduction is performed. + The default (``axis=None``) is to perform a logical OR over all + the dimensions of the input array. `axis` may be negative, in + which case it counts from the last to the first axis. + + .. versionadded:: 1.7.0 + + If this is a tuple of ints, a reduction is performed on multiple + axes, instead of a single axis or all the axes as before. + out : ndarray, optional + Alternate output array in which to place the result. It must have + the same shape as the expected output and its type is preserved + (e.g., if it is of type float, then it will remain so, returning + 1.0 for True and 0.0 for False, regardless of the type of `a`). + See :ref:`ufuncs-output-type` for more details. + + keepdims : bool, optional + If this is set to True, the axes which are reduced are left + in the result as dimensions with size one. With this option, + the result will broadcast correctly against the input array. + + If the default value is passed, then `keepdims` will not be + passed through to the `any` method of sub-classes of + `ndarray`, however any non-default value will be. If the + sub-class' method does not implement `keepdims` any + exceptions will be raised. + + where : array_like of bool, optional + Elements to include in checking for any `True` values. + See `~numpy.ufunc.reduce` for details. + + .. versionadded:: 1.20.0 + + Returns + ------- + any : bool or ndarray + A new boolean or `ndarray` is returned unless `out` is specified, + in which case a reference to `out` is returned. + + See Also + -------- + ndarray.any : equivalent method + + all : Test whether all elements along a given axis evaluate to True. + + Notes + ----- + Not a Number (NaN), positive infinity and negative infinity evaluate + to `True` because these are not equal to zero. + + .. versionchanged:: 2.0 + Before NumPy 2.0, ``any`` did not return booleans for object dtype + input arrays. + This behavior is still available via ``np.logical_or.reduce``. + + Examples + -------- + >>> import numpy as np + >>> np.any([[True, False], [True, True]]) + True + + >>> np.any([[True, False, True ], + ... [False, False, False]], axis=0) + array([ True, False, True]) + + >>> np.any([-1, 0, 5]) + True + + >>> np.any([[np.nan], [np.inf]], axis=1, keepdims=True) + array([[ True], + [ True]]) + + >>> np.any([[True, False], [False, False]], where=[[False], [True]]) + False + + >>> a = np.array([[1, 0, 0], + ... [0, 0, 1], + ... [0, 0, 0]]) + >>> np.any(a, axis=0) + array([ True, False, True]) + >>> np.any(a, axis=1) + array([ True, True, False]) + + >>> o=np.array(False) + >>> z=np.any([-1, 4, 5], out=o) + >>> z, o + (array(True), array(True)) + >>> # Check now that z is a reference to o + >>> z is o + True + >>> id(z), id(o) # identity of z and o # doctest: +SKIP + (191614240, 191614240) + + """ + return _wrapreduction_any_all(a, np.logical_or, 'any', axis, out, + keepdims=keepdims, where=where) + + +def _all_dispatcher(a, axis=None, out=None, keepdims=None, *, + where=None): + return (a, where, out) + + +@array_function_dispatch(_all_dispatcher) +def all(a, axis=None, out=None, keepdims=np._NoValue, *, where=np._NoValue): + """ + Test whether all array elements along a given axis evaluate to True. + + Parameters + ---------- + a : array_like + Input array or object that can be converted to an array. + axis : None or int or tuple of ints, optional + Axis or axes along which a logical AND reduction is performed. + The default (``axis=None``) is to perform a logical AND over all + the dimensions of the input array. `axis` may be negative, in + which case it counts from the last to the first axis. + + .. versionadded:: 1.7.0 + + If this is a tuple of ints, a reduction is performed on multiple + axes, instead of a single axis or all the axes as before. + out : ndarray, optional + Alternate output array in which to place the result. + It must have the same shape as the expected output and its + type is preserved (e.g., if ``dtype(out)`` is float, the result + will consist of 0.0's and 1.0's). See :ref:`ufuncs-output-type` + for more details. + + keepdims : bool, optional + If this is set to True, the axes which are reduced are left + in the result as dimensions with size one. With this option, + the result will broadcast correctly against the input array. + + If the default value is passed, then `keepdims` will not be + passed through to the `all` method of sub-classes of + `ndarray`, however any non-default value will be. If the + sub-class' method does not implement `keepdims` any + exceptions will be raised. + + where : array_like of bool, optional + Elements to include in checking for all `True` values. + See `~numpy.ufunc.reduce` for details. + + .. versionadded:: 1.20.0 + + Returns + ------- + all : ndarray, bool + A new boolean or array is returned unless `out` is specified, + in which case a reference to `out` is returned. + + See Also + -------- + ndarray.all : equivalent method + + any : Test whether any element along a given axis evaluates to True. + + Notes + ----- + Not a Number (NaN), positive infinity and negative infinity + evaluate to `True` because these are not equal to zero. + + .. versionchanged:: 2.0 + Before NumPy 2.0, ``all`` did not return booleans for object dtype + input arrays. + This behavior is still available via ``np.logical_and.reduce``. + + Examples + -------- + >>> import numpy as np + >>> np.all([[True,False],[True,True]]) + False + + >>> np.all([[True,False],[True,True]], axis=0) + array([ True, False]) + + >>> np.all([-1, 4, 5]) + True + + >>> np.all([1.0, np.nan]) + True + + >>> np.all([[True, True], [False, True]], where=[[True], [False]]) + True + + >>> o=np.array(False) + >>> z=np.all([-1, 4, 5], out=o) + >>> id(z), id(o), z + (28293632, 28293632, array(True)) # may vary + + """ + return _wrapreduction_any_all(a, np.logical_and, 'all', axis, out, + keepdims=keepdims, where=where) + + +def _cumulative_func(x, func, axis, dtype, out, include_initial): + x = np.atleast_1d(x) + x_ndim = x.ndim + if axis is None: + if x_ndim >= 2: + raise ValueError("For arrays which have more than one dimension " + "``axis`` argument is required.") + axis = 0 + + if out is not None and include_initial: + item = [slice(None)] * x_ndim + item[axis] = slice(1, None) + func.accumulate(x, axis=axis, dtype=dtype, out=out[tuple(item)]) + item[axis] = 0 + out[tuple(item)] = func.identity + return out + + res = func.accumulate(x, axis=axis, dtype=dtype, out=out) + if include_initial: + initial_shape = list(x.shape) + initial_shape[axis] = 1 + res = np.concat( + [np.full_like(res, func.identity, shape=initial_shape), res], + axis=axis, + ) + + return res + + +def _cumulative_prod_dispatcher(x, /, *, axis=None, dtype=None, out=None, + include_initial=None): + return (x, out) + + +@array_function_dispatch(_cumulative_prod_dispatcher) +def cumulative_prod(x, /, *, axis=None, dtype=None, out=None, + include_initial=False): + """ + Return the cumulative product of elements along a given axis. + + This function is an Array API compatible alternative to `numpy.cumprod`. + + Parameters + ---------- + x : array_like + Input array. + axis : int, optional + Axis along which the cumulative product is computed. The default + (None) is only allowed for one-dimensional arrays. For arrays + with more than one dimension ``axis`` is required. + dtype : dtype, optional + Type of the returned array, as well as of the accumulator in which + the elements are multiplied. If ``dtype`` is not specified, it + defaults to the dtype of ``x``, unless ``x`` has an integer dtype + with a precision less than that of the default platform integer. + In that case, the default platform integer is used instead. + out : ndarray, optional + Alternative output array in which to place the result. It must + have the same shape and buffer length as the expected output + but the type of the resulting values will be cast if necessary. + See :ref:`ufuncs-output-type` for more details. + include_initial : bool, optional + Boolean indicating whether to include the initial value (ones) as + the first value in the output. With ``include_initial=True`` + the shape of the output is different than the shape of the input. + Default: ``False``. + + Returns + ------- + cumulative_prod_along_axis : ndarray + A new array holding the result is returned unless ``out`` is + specified, in which case a reference to ``out`` is returned. The + result has the same shape as ``x`` if ``include_initial=False``. + + Notes + ----- + Arithmetic is modular when using integer types, and no error is + raised on overflow. + + Examples + -------- + >>> a = np.array([1, 2, 3]) + >>> np.cumulative_prod(a) # intermediate results 1, 1*2 + ... # total product 1*2*3 = 6 + array([1, 2, 6]) + >>> a = np.array([1, 2, 3, 4, 5, 6]) + >>> np.cumulative_prod(a, dtype=float) # specify type of output + array([ 1., 2., 6., 24., 120., 720.]) + + The cumulative product for each column (i.e., over the rows) of ``b``: + + >>> b = np.array([[1, 2, 3], [4, 5, 6]]) + >>> np.cumulative_prod(b, axis=0) + array([[ 1, 2, 3], + [ 4, 10, 18]]) + + The cumulative product for each row (i.e. over the columns) of ``b``: + + >>> np.cumulative_prod(b, axis=1) + array([[ 1, 2, 6], + [ 4, 20, 120]]) + + """ + return _cumulative_func(x, um.multiply, axis, dtype, out, include_initial) + + +def _cumulative_sum_dispatcher(x, /, *, axis=None, dtype=None, out=None, + include_initial=None): + return (x, out) + + +@array_function_dispatch(_cumulative_sum_dispatcher) +def cumulative_sum(x, /, *, axis=None, dtype=None, out=None, + include_initial=False): + """ + Return the cumulative sum of the elements along a given axis. + + This function is an Array API compatible alternative to `numpy.cumsum`. + + Parameters + ---------- + x : array_like + Input array. + axis : int, optional + Axis along which the cumulative sum is computed. The default + (None) is only allowed for one-dimensional arrays. For arrays + with more than one dimension ``axis`` is required. + dtype : dtype, optional + Type of the returned array and of the accumulator in which the + elements are summed. If ``dtype`` is not specified, it defaults + to the dtype of ``x``, unless ``x`` has an integer dtype with + a precision less than that of the default platform integer. + In that case, the default platform integer is used. + out : ndarray, optional + Alternative output array in which to place the result. It must + have the same shape and buffer length as the expected output + but the type will be cast if necessary. See :ref:`ufuncs-output-type` + for more details. + include_initial : bool, optional + Boolean indicating whether to include the initial value (ones) as + the first value in the output. With ``include_initial=True`` + the shape of the output is different than the shape of the input. + Default: ``False``. + + Returns + ------- + cumulative_sum_along_axis : ndarray + A new array holding the result is returned unless ``out`` is + specified, in which case a reference to ``out`` is returned. The + result has the same shape as ``x`` if ``include_initial=False``. + + See Also + -------- + sum : Sum array elements. + trapezoid : Integration of array values using composite trapezoidal rule. + diff : Calculate the n-th discrete difference along given axis. + + Notes + ----- + Arithmetic is modular when using integer types, and no error is + raised on overflow. + + ``cumulative_sum(a)[-1]`` may not be equal to ``sum(a)`` for + floating-point values since ``sum`` may use a pairwise summation routine, + reducing the roundoff-error. See `sum` for more information. + + Examples + -------- + >>> a = np.array([1, 2, 3, 4, 5, 6]) + >>> a + array([1, 2, 3, 4, 5, 6]) + >>> np.cumulative_sum(a) + array([ 1, 3, 6, 10, 15, 21]) + >>> np.cumulative_sum(a, dtype=float) # specifies type of output value(s) + array([ 1., 3., 6., 10., 15., 21.]) + + >>> b = np.array([[1, 2, 3], [4, 5, 6]]) + >>> np.cumulative_sum(b,axis=0) # sum over rows for each of the 3 columns + array([[1, 2, 3], + [5, 7, 9]]) + >>> np.cumulative_sum(b,axis=1) # sum over columns for each of the 2 rows + array([[ 1, 3, 6], + [ 4, 9, 15]]) + + ``cumulative_sum(c)[-1]`` may not be equal to ``sum(c)`` + + >>> c = np.array([1, 2e-9, 3e-9] * 1000000) + >>> np.cumulative_sum(c)[-1] + 1000000.0050045159 + >>> c.sum() + 1000000.0050000029 + + """ + return _cumulative_func(x, um.add, axis, dtype, out, include_initial) + + +def _cumsum_dispatcher(a, axis=None, dtype=None, out=None): + return (a, out) + + +@array_function_dispatch(_cumsum_dispatcher) +def cumsum(a, axis=None, dtype=None, out=None): + """ + Return the cumulative sum of the elements along a given axis. + + Parameters + ---------- + a : array_like + Input array. + axis : int, optional + Axis along which the cumulative sum is computed. The default + (None) is to compute the cumsum over the flattened array. + dtype : dtype, optional + Type of the returned array and of the accumulator in which the + elements are summed. If `dtype` is not specified, it defaults + to the dtype of `a`, unless `a` has an integer dtype with a + precision less than that of the default platform integer. In + that case, the default platform integer is used. + out : ndarray, optional + Alternative output array in which to place the result. It must + have the same shape and buffer length as the expected output + but the type will be cast if necessary. See :ref:`ufuncs-output-type` + for more details. + + Returns + ------- + cumsum_along_axis : ndarray. + A new array holding the result is returned unless `out` is + specified, in which case a reference to `out` is returned. The + result has the same size as `a`, and the same shape as `a` if + `axis` is not None or `a` is a 1-d array. + + See Also + -------- + cumulative_sum : Array API compatible alternative for ``cumsum``. + sum : Sum array elements. + trapezoid : Integration of array values using composite trapezoidal rule. + diff : Calculate the n-th discrete difference along given axis. + + Notes + ----- + Arithmetic is modular when using integer types, and no error is + raised on overflow. + + ``cumsum(a)[-1]`` may not be equal to ``sum(a)`` for floating-point + values since ``sum`` may use a pairwise summation routine, reducing + the roundoff-error. See `sum` for more information. + + Examples + -------- + >>> import numpy as np + >>> a = np.array([[1,2,3], [4,5,6]]) + >>> a + array([[1, 2, 3], + [4, 5, 6]]) + >>> np.cumsum(a) + array([ 1, 3, 6, 10, 15, 21]) + >>> np.cumsum(a, dtype=float) # specifies type of output value(s) + array([ 1., 3., 6., 10., 15., 21.]) + + >>> np.cumsum(a,axis=0) # sum over rows for each of the 3 columns + array([[1, 2, 3], + [5, 7, 9]]) + >>> np.cumsum(a,axis=1) # sum over columns for each of the 2 rows + array([[ 1, 3, 6], + [ 4, 9, 15]]) + + ``cumsum(b)[-1]`` may not be equal to ``sum(b)`` + + >>> b = np.array([1, 2e-9, 3e-9] * 1000000) + >>> b.cumsum()[-1] + 1000000.0050045159 + >>> b.sum() + 1000000.0050000029 + + """ + return _wrapfunc(a, 'cumsum', axis=axis, dtype=dtype, out=out) + + +def _ptp_dispatcher(a, axis=None, out=None, keepdims=None): + return (a, out) + + +@array_function_dispatch(_ptp_dispatcher) +def ptp(a, axis=None, out=None, keepdims=np._NoValue): + """ + Range of values (maximum - minimum) along an axis. + + The name of the function comes from the acronym for 'peak to peak'. + + .. warning:: + `ptp` preserves the data type of the array. This means the + return value for an input of signed integers with n bits + (e.g. `numpy.int8`, `numpy.int16`, etc) is also a signed integer + with n bits. In that case, peak-to-peak values greater than + ``2**(n-1)-1`` will be returned as negative values. An example + with a work-around is shown below. + + Parameters + ---------- + a : array_like + Input values. + axis : None or int or tuple of ints, optional + Axis along which to find the peaks. By default, flatten the + array. `axis` may be negative, in + which case it counts from the last to the first axis. + + .. versionadded:: 1.15.0 + + If this is a tuple of ints, a reduction is performed on multiple + axes, instead of a single axis or all the axes as before. + out : array_like + Alternative output array in which to place the result. It must + have the same shape and buffer length as the expected output, + but the type of the output values will be cast if necessary. + + keepdims : bool, optional + If this is set to True, the axes which are reduced are left + in the result as dimensions with size one. With this option, + the result will broadcast correctly against the input array. + + If the default value is passed, then `keepdims` will not be + passed through to the `ptp` method of sub-classes of + `ndarray`, however any non-default value will be. If the + sub-class' method does not implement `keepdims` any + exceptions will be raised. + + Returns + ------- + ptp : ndarray or scalar + The range of a given array - `scalar` if array is one-dimensional + or a new array holding the result along the given axis + + Examples + -------- + >>> import numpy as np + >>> x = np.array([[4, 9, 2, 10], + ... [6, 9, 7, 12]]) + + >>> np.ptp(x, axis=1) + array([8, 6]) + + >>> np.ptp(x, axis=0) + array([2, 0, 5, 2]) + + >>> np.ptp(x) + 10 + + This example shows that a negative value can be returned when + the input is an array of signed integers. + + >>> y = np.array([[1, 127], + ... [0, 127], + ... [-1, 127], + ... [-2, 127]], dtype=np.int8) + >>> np.ptp(y, axis=1) + array([ 126, 127, -128, -127], dtype=int8) + + A work-around is to use the `view()` method to view the result as + unsigned integers with the same bit width: + + >>> np.ptp(y, axis=1).view(np.uint8) + array([126, 127, 128, 129], dtype=uint8) + + """ + kwargs = {} + if keepdims is not np._NoValue: + kwargs['keepdims'] = keepdims + return _methods._ptp(a, axis=axis, out=out, **kwargs) + + +def _max_dispatcher(a, axis=None, out=None, keepdims=None, initial=None, + where=None): + return (a, out) + + +@array_function_dispatch(_max_dispatcher) +@set_module('numpy') +def max(a, axis=None, out=None, keepdims=np._NoValue, initial=np._NoValue, + where=np._NoValue): + """ + Return the maximum of an array or maximum along an axis. + + Parameters + ---------- + a : array_like + Input data. + axis : None or int or tuple of ints, optional + Axis or axes along which to operate. By default, flattened input is + used. + + .. versionadded:: 1.7.0 + + If this is a tuple of ints, the maximum is selected over multiple axes, + instead of a single axis or all the axes as before. + out : ndarray, optional + Alternative output array in which to place the result. Must + be of the same shape and buffer length as the expected output. + See :ref:`ufuncs-output-type` for more details. + + keepdims : bool, optional + If this is set to True, the axes which are reduced are left + in the result as dimensions with size one. With this option, + the result will broadcast correctly against the input array. + + If the default value is passed, then `keepdims` will not be + passed through to the ``max`` method of sub-classes of + `ndarray`, however any non-default value will be. If the + sub-class' method does not implement `keepdims` any + exceptions will be raised. + + initial : scalar, optional + The minimum value of an output element. Must be present to allow + computation on empty slice. See `~numpy.ufunc.reduce` for details. + + .. versionadded:: 1.15.0 + + where : array_like of bool, optional + Elements to compare for the maximum. See `~numpy.ufunc.reduce` + for details. + + .. versionadded:: 1.17.0 + + Returns + ------- + max : ndarray or scalar + Maximum of `a`. If `axis` is None, the result is a scalar value. + If `axis` is an int, the result is an array of dimension + ``a.ndim - 1``. If `axis` is a tuple, the result is an array of + dimension ``a.ndim - len(axis)``. + + See Also + -------- + amin : + The minimum value of an array along a given axis, propagating any NaNs. + nanmax : + The maximum value of an array along a given axis, ignoring any NaNs. + maximum : + Element-wise maximum of two arrays, propagating any NaNs. + fmax : + Element-wise maximum of two arrays, ignoring any NaNs. + argmax : + Return the indices of the maximum values. + + nanmin, minimum, fmin + + Notes + ----- + NaN values are propagated, that is if at least one item is NaN, the + corresponding max value will be NaN as well. To ignore NaN values + (MATLAB behavior), please use nanmax. + + Don't use `~numpy.max` for element-wise comparison of 2 arrays; when + ``a.shape[0]`` is 2, ``maximum(a[0], a[1])`` is faster than + ``max(a, axis=0)``. + + Examples + -------- + >>> import numpy as np + >>> a = np.arange(4).reshape((2,2)) + >>> a + array([[0, 1], + [2, 3]]) + >>> np.max(a) # Maximum of the flattened array + 3 + >>> np.max(a, axis=0) # Maxima along the first axis + array([2, 3]) + >>> np.max(a, axis=1) # Maxima along the second axis + array([1, 3]) + >>> np.max(a, where=[False, True], initial=-1, axis=0) + array([-1, 3]) + >>> b = np.arange(5, dtype=float) + >>> b[2] = np.nan + >>> np.max(b) + np.float64(nan) + >>> np.max(b, where=~np.isnan(b), initial=-1) + 4.0 + >>> np.nanmax(b) + 4.0 + + You can use an initial value to compute the maximum of an empty slice, or + to initialize it to a different value: + + >>> np.max([[-50], [10]], axis=-1, initial=0) + array([ 0, 10]) + + Notice that the initial value is used as one of the elements for which the + maximum is determined, unlike for the default argument Python's max + function, which is only used for empty iterables. + + >>> np.max([5], initial=6) + 6 + >>> max([5], default=6) + 5 + """ + return _wrapreduction(a, np.maximum, 'max', axis, None, out, + keepdims=keepdims, initial=initial, where=where) + + +@array_function_dispatch(_max_dispatcher) +def amax(a, axis=None, out=None, keepdims=np._NoValue, initial=np._NoValue, + where=np._NoValue): + """ + Return the maximum of an array or maximum along an axis. + + `amax` is an alias of `~numpy.max`. + + See Also + -------- + max : alias of this function + ndarray.max : equivalent method + """ + return _wrapreduction(a, np.maximum, 'max', axis, None, out, + keepdims=keepdims, initial=initial, where=where) + + +def _min_dispatcher(a, axis=None, out=None, keepdims=None, initial=None, + where=None): + return (a, out) + + +@array_function_dispatch(_min_dispatcher) +def min(a, axis=None, out=None, keepdims=np._NoValue, initial=np._NoValue, + where=np._NoValue): + """ + Return the minimum of an array or minimum along an axis. + + Parameters + ---------- + a : array_like + Input data. + axis : None or int or tuple of ints, optional + Axis or axes along which to operate. By default, flattened input is + used. + + .. versionadded:: 1.7.0 + + If this is a tuple of ints, the minimum is selected over multiple axes, + instead of a single axis or all the axes as before. + out : ndarray, optional + Alternative output array in which to place the result. Must + be of the same shape and buffer length as the expected output. + See :ref:`ufuncs-output-type` for more details. + + keepdims : bool, optional + If this is set to True, the axes which are reduced are left + in the result as dimensions with size one. With this option, + the result will broadcast correctly against the input array. + + If the default value is passed, then `keepdims` will not be + passed through to the ``min`` method of sub-classes of + `ndarray`, however any non-default value will be. If the + sub-class' method does not implement `keepdims` any + exceptions will be raised. + + initial : scalar, optional + The maximum value of an output element. Must be present to allow + computation on empty slice. See `~numpy.ufunc.reduce` for details. + + .. versionadded:: 1.15.0 + + where : array_like of bool, optional + Elements to compare for the minimum. See `~numpy.ufunc.reduce` + for details. + + .. versionadded:: 1.17.0 + + Returns + ------- + min : ndarray or scalar + Minimum of `a`. If `axis` is None, the result is a scalar value. + If `axis` is an int, the result is an array of dimension + ``a.ndim - 1``. If `axis` is a tuple, the result is an array of + dimension ``a.ndim - len(axis)``. + + See Also + -------- + amax : + The maximum value of an array along a given axis, propagating any NaNs. + nanmin : + The minimum value of an array along a given axis, ignoring any NaNs. + minimum : + Element-wise minimum of two arrays, propagating any NaNs. + fmin : + Element-wise minimum of two arrays, ignoring any NaNs. + argmin : + Return the indices of the minimum values. + + nanmax, maximum, fmax + + Notes + ----- + NaN values are propagated, that is if at least one item is NaN, the + corresponding min value will be NaN as well. To ignore NaN values + (MATLAB behavior), please use nanmin. + + Don't use `~numpy.min` for element-wise comparison of 2 arrays; when + ``a.shape[0]`` is 2, ``minimum(a[0], a[1])`` is faster than + ``min(a, axis=0)``. + + Examples + -------- + >>> import numpy as np + >>> a = np.arange(4).reshape((2,2)) + >>> a + array([[0, 1], + [2, 3]]) + >>> np.min(a) # Minimum of the flattened array + 0 + >>> np.min(a, axis=0) # Minima along the first axis + array([0, 1]) + >>> np.min(a, axis=1) # Minima along the second axis + array([0, 2]) + >>> np.min(a, where=[False, True], initial=10, axis=0) + array([10, 1]) + + >>> b = np.arange(5, dtype=float) + >>> b[2] = np.nan + >>> np.min(b) + np.float64(nan) + >>> np.min(b, where=~np.isnan(b), initial=10) + 0.0 + >>> np.nanmin(b) + 0.0 + + >>> np.min([[-50], [10]], axis=-1, initial=0) + array([-50, 0]) + + Notice that the initial value is used as one of the elements for which the + minimum is determined, unlike for the default argument Python's max + function, which is only used for empty iterables. + + Notice that this isn't the same as Python's ``default`` argument. + + >>> np.min([6], initial=5) + 5 + >>> min([6], default=5) + 6 + """ + return _wrapreduction(a, np.minimum, 'min', axis, None, out, + keepdims=keepdims, initial=initial, where=where) + + +@array_function_dispatch(_min_dispatcher) +def amin(a, axis=None, out=None, keepdims=np._NoValue, initial=np._NoValue, + where=np._NoValue): + """ + Return the minimum of an array or minimum along an axis. + + `amin` is an alias of `~numpy.min`. + + See Also + -------- + min : alias of this function + ndarray.min : equivalent method + """ + return _wrapreduction(a, np.minimum, 'min', axis, None, out, + keepdims=keepdims, initial=initial, where=where) + + +def _prod_dispatcher(a, axis=None, dtype=None, out=None, keepdims=None, + initial=None, where=None): + return (a, out) + + +@array_function_dispatch(_prod_dispatcher) +def prod(a, axis=None, dtype=None, out=None, keepdims=np._NoValue, + initial=np._NoValue, where=np._NoValue): + """ + Return the product of array elements over a given axis. + + Parameters + ---------- + a : array_like + Input data. + axis : None or int or tuple of ints, optional + Axis or axes along which a product is performed. The default, + axis=None, will calculate the product of all the elements in the + input array. If axis is negative it counts from the last to the + first axis. + + .. versionadded:: 1.7.0 + + If axis is a tuple of ints, a product is performed on all of the + axes specified in the tuple instead of a single axis or all the + axes as before. + dtype : dtype, optional + The type of the returned array, as well as of the accumulator in + which the elements are multiplied. The dtype of `a` is used by + default unless `a` has an integer dtype of less precision than the + default platform integer. In that case, if `a` is signed then the + platform integer is used while if `a` is unsigned then an unsigned + integer of the same precision as the platform integer is used. + out : ndarray, optional + Alternative output array in which to place the result. It must have + the same shape as the expected output, but the type of the output + values will be cast if necessary. + keepdims : bool, optional + If this is set to True, the axes which are reduced are left in the + result as dimensions with size one. With this option, the result + will broadcast correctly against the input array. + + If the default value is passed, then `keepdims` will not be + passed through to the `prod` method of sub-classes of + `ndarray`, however any non-default value will be. If the + sub-class' method does not implement `keepdims` any + exceptions will be raised. + initial : scalar, optional + The starting value for this product. See `~numpy.ufunc.reduce` + for details. + + .. versionadded:: 1.15.0 + + where : array_like of bool, optional + Elements to include in the product. See `~numpy.ufunc.reduce` + for details. + + .. versionadded:: 1.17.0 + + Returns + ------- + product_along_axis : ndarray, see `dtype` parameter above. + An array shaped as `a` but with the specified axis removed. + Returns a reference to `out` if specified. + + See Also + -------- + ndarray.prod : equivalent method + :ref:`ufuncs-output-type` + + Notes + ----- + Arithmetic is modular when using integer types, and no error is + raised on overflow. That means that, on a 32-bit platform: + + >>> x = np.array([536870910, 536870910, 536870910, 536870910]) + >>> np.prod(x) + 16 # may vary + + The product of an empty array is the neutral element 1: + + >>> np.prod([]) + 1.0 + + Examples + -------- + By default, calculate the product of all elements: + + >>> import numpy as np + >>> np.prod([1.,2.]) + 2.0 + + Even when the input array is two-dimensional: + + >>> a = np.array([[1., 2.], [3., 4.]]) + >>> np.prod(a) + 24.0 + + But we can also specify the axis over which to multiply: + + >>> np.prod(a, axis=1) + array([ 2., 12.]) + >>> np.prod(a, axis=0) + array([3., 8.]) + + Or select specific elements to include: + + >>> np.prod([1., np.nan, 3.], where=[True, False, True]) + 3.0 + + If the type of `x` is unsigned, then the output type is + the unsigned platform integer: + + >>> x = np.array([1, 2, 3], dtype=np.uint8) + >>> np.prod(x).dtype == np.uint + True + + If `x` is of a signed integer type, then the output type + is the default platform integer: + + >>> x = np.array([1, 2, 3], dtype=np.int8) + >>> np.prod(x).dtype == int + True + + You can also start the product with a value other than one: + + >>> np.prod([1, 2], initial=5) + 10 + """ + return _wrapreduction(a, np.multiply, 'prod', axis, dtype, out, + keepdims=keepdims, initial=initial, where=where) + + +def _cumprod_dispatcher(a, axis=None, dtype=None, out=None): + return (a, out) + + +@array_function_dispatch(_cumprod_dispatcher) +def cumprod(a, axis=None, dtype=None, out=None): + """ + Return the cumulative product of elements along a given axis. + + Parameters + ---------- + a : array_like + Input array. + axis : int, optional + Axis along which the cumulative product is computed. By default + the input is flattened. + dtype : dtype, optional + Type of the returned array, as well as of the accumulator in which + the elements are multiplied. If *dtype* is not specified, it + defaults to the dtype of `a`, unless `a` has an integer dtype with + a precision less than that of the default platform integer. In + that case, the default platform integer is used instead. + out : ndarray, optional + Alternative output array in which to place the result. It must + have the same shape and buffer length as the expected output + but the type of the resulting values will be cast if necessary. + + Returns + ------- + cumprod : ndarray + A new array holding the result is returned unless `out` is + specified, in which case a reference to out is returned. + + See Also + -------- + cumulative_prod : Array API compatible alternative for ``cumprod``. + :ref:`ufuncs-output-type` + + Notes + ----- + Arithmetic is modular when using integer types, and no error is + raised on overflow. + + Examples + -------- + >>> import numpy as np + >>> a = np.array([1,2,3]) + >>> np.cumprod(a) # intermediate results 1, 1*2 + ... # total product 1*2*3 = 6 + array([1, 2, 6]) + >>> a = np.array([[1, 2, 3], [4, 5, 6]]) + >>> np.cumprod(a, dtype=float) # specify type of output + array([ 1., 2., 6., 24., 120., 720.]) + + The cumulative product for each column (i.e., over the rows) of `a`: + + >>> np.cumprod(a, axis=0) + array([[ 1, 2, 3], + [ 4, 10, 18]]) + + The cumulative product for each row (i.e. over the columns) of `a`: + + >>> np.cumprod(a,axis=1) + array([[ 1, 2, 6], + [ 4, 20, 120]]) + + """ + return _wrapfunc(a, 'cumprod', axis=axis, dtype=dtype, out=out) + + +def _ndim_dispatcher(a): + return (a,) + + +@array_function_dispatch(_ndim_dispatcher) +def ndim(a): + """ + Return the number of dimensions of an array. + + Parameters + ---------- + a : array_like + Input array. If it is not already an ndarray, a conversion is + attempted. + + Returns + ------- + number_of_dimensions : int + The number of dimensions in `a`. Scalars are zero-dimensional. + + See Also + -------- + ndarray.ndim : equivalent method + shape : dimensions of array + ndarray.shape : dimensions of array + + Examples + -------- + >>> import numpy as np + >>> np.ndim([[1,2,3],[4,5,6]]) + 2 + >>> np.ndim(np.array([[1,2,3],[4,5,6]])) + 2 + >>> np.ndim(1) + 0 + + """ + try: + return a.ndim + except AttributeError: + return asarray(a).ndim + + +def _size_dispatcher(a, axis=None): + return (a,) + + +@array_function_dispatch(_size_dispatcher) +def size(a, axis=None): + """ + Return the number of elements along a given axis. + + Parameters + ---------- + a : array_like + Input data. + axis : int, optional + Axis along which the elements are counted. By default, give + the total number of elements. + + Returns + ------- + element_count : int + Number of elements along the specified axis. + + See Also + -------- + shape : dimensions of array + ndarray.shape : dimensions of array + ndarray.size : number of elements in array + + Examples + -------- + >>> import numpy as np + >>> a = np.array([[1,2,3],[4,5,6]]) + >>> np.size(a) + 6 + >>> np.size(a,1) + 3 + >>> np.size(a,0) + 2 + + """ + if axis is None: + try: + return a.size + except AttributeError: + return asarray(a).size + else: + try: + return a.shape[axis] + except AttributeError: + return asarray(a).shape[axis] + + +def _round_dispatcher(a, decimals=None, out=None): + return (a, out) + + +@array_function_dispatch(_round_dispatcher) +def round(a, decimals=0, out=None): + """ + Evenly round to the given number of decimals. + + Parameters + ---------- + a : array_like + Input data. + decimals : int, optional + Number of decimal places to round to (default: 0). If + decimals is negative, it specifies the number of positions to + the left of the decimal point. + out : ndarray, optional + Alternative output array in which to place the result. It must have + the same shape as the expected output, but the type of the output + values will be cast if necessary. See :ref:`ufuncs-output-type` + for more details. + + Returns + ------- + rounded_array : ndarray + An array of the same type as `a`, containing the rounded values. + Unless `out` was specified, a new array is created. A reference to + the result is returned. + + The real and imaginary parts of complex numbers are rounded + separately. The result of rounding a float is a float. + + See Also + -------- + ndarray.round : equivalent method + around : an alias for this function + ceil, fix, floor, rint, trunc + + + Notes + ----- + For values exactly halfway between rounded decimal values, NumPy + rounds to the nearest even value. Thus 1.5 and 2.5 round to 2.0, + -0.5 and 0.5 round to 0.0, etc. + + ``np.round`` uses a fast but sometimes inexact algorithm to round + floating-point datatypes. For positive `decimals` it is equivalent to + ``np.true_divide(np.rint(a * 10**decimals), 10**decimals)``, which has + error due to the inexact representation of decimal fractions in the IEEE + floating point standard [1]_ and errors introduced when scaling by powers + of ten. For instance, note the extra "1" in the following: + + >>> np.round(56294995342131.5, 3) + 56294995342131.51 + + If your goal is to print such values with a fixed number of decimals, it is + preferable to use numpy's float printing routines to limit the number of + printed decimals: + + >>> np.format_float_positional(56294995342131.5, precision=3) + '56294995342131.5' + + The float printing routines use an accurate but much more computationally + demanding algorithm to compute the number of digits after the decimal + point. + + Alternatively, Python's builtin `round` function uses a more accurate + but slower algorithm for 64-bit floating point values: + + >>> round(56294995342131.5, 3) + 56294995342131.5 + >>> np.round(16.055, 2), round(16.055, 2) # equals 16.0549999999999997 + (16.06, 16.05) + + + References + ---------- + .. [1] "Lecture Notes on the Status of IEEE 754", William Kahan, + https://people.eecs.berkeley.edu/~wkahan/ieee754status/IEEE754.PDF + + Examples + -------- + >>> import numpy as np + >>> np.round([0.37, 1.64]) + array([0., 2.]) + >>> np.round([0.37, 1.64], decimals=1) + array([0.4, 1.6]) + >>> np.round([.5, 1.5, 2.5, 3.5, 4.5]) # rounds to nearest even value + array([0., 2., 2., 4., 4.]) + >>> np.round([1,2,3,11], decimals=1) # ndarray of ints is returned + array([ 1, 2, 3, 11]) + >>> np.round([1,2,3,11], decimals=-1) + array([ 0, 0, 0, 10]) + + """ + return _wrapfunc(a, 'round', decimals=decimals, out=out) + + +@array_function_dispatch(_round_dispatcher) +def around(a, decimals=0, out=None): + """ + Round an array to the given number of decimals. + + `around` is an alias of `~numpy.round`. + + See Also + -------- + ndarray.round : equivalent method + round : alias for this function + ceil, fix, floor, rint, trunc + + """ + return _wrapfunc(a, 'round', decimals=decimals, out=out) + + +def _mean_dispatcher(a, axis=None, dtype=None, out=None, keepdims=None, *, + where=None): + return (a, where, out) + + +@array_function_dispatch(_mean_dispatcher) +def mean(a, axis=None, dtype=None, out=None, keepdims=np._NoValue, *, + where=np._NoValue): + """ + Compute the arithmetic mean along the specified axis. + + Returns the average of the array elements. The average is taken over + the flattened array by default, otherwise over the specified axis. + `float64` intermediate and return values are used for integer inputs. + + Parameters + ---------- + a : array_like + Array containing numbers whose mean is desired. If `a` is not an + array, a conversion is attempted. + axis : None or int or tuple of ints, optional + Axis or axes along which the means are computed. The default is to + compute the mean of the flattened array. + + .. versionadded:: 1.7.0 + + If this is a tuple of ints, a mean is performed over multiple axes, + instead of a single axis or all the axes as before. + dtype : data-type, optional + Type to use in computing the mean. For integer inputs, the default + is `float64`; for floating point inputs, it is the same as the + input dtype. + out : ndarray, optional + Alternate output array in which to place the result. The default + is ``None``; if provided, it must have the same shape as the + expected output, but the type will be cast if necessary. + See :ref:`ufuncs-output-type` for more details. + See :ref:`ufuncs-output-type` for more details. + + keepdims : bool, optional + If this is set to True, the axes which are reduced are left + in the result as dimensions with size one. With this option, + the result will broadcast correctly against the input array. + + If the default value is passed, then `keepdims` will not be + passed through to the `mean` method of sub-classes of + `ndarray`, however any non-default value will be. If the + sub-class' method does not implement `keepdims` any + exceptions will be raised. + + where : array_like of bool, optional + Elements to include in the mean. See `~numpy.ufunc.reduce` for details. + + .. versionadded:: 1.20.0 + + Returns + ------- + m : ndarray, see dtype parameter above + If `out=None`, returns a new array containing the mean values, + otherwise a reference to the output array is returned. + + See Also + -------- + average : Weighted average + std, var, nanmean, nanstd, nanvar + + Notes + ----- + The arithmetic mean is the sum of the elements along the axis divided + by the number of elements. + + Note that for floating-point input, the mean is computed using the + same precision the input has. Depending on the input data, this can + cause the results to be inaccurate, especially for `float32` (see + example below). Specifying a higher-precision accumulator using the + `dtype` keyword can alleviate this issue. + + By default, `float16` results are computed using `float32` intermediates + for extra precision. + + Examples + -------- + >>> import numpy as np + >>> a = np.array([[1, 2], [3, 4]]) + >>> np.mean(a) + 2.5 + >>> np.mean(a, axis=0) + array([2., 3.]) + >>> np.mean(a, axis=1) + array([1.5, 3.5]) + + In single precision, `mean` can be inaccurate: + + >>> a = np.zeros((2, 512*512), dtype=np.float32) + >>> a[0, :] = 1.0 + >>> a[1, :] = 0.1 + >>> np.mean(a) + 0.54999924 + + Computing the mean in float64 is more accurate: + + >>> np.mean(a, dtype=np.float64) + 0.55000000074505806 # may vary + + Specifying a where argument: + + >>> a = np.array([[5, 9, 13], [14, 10, 12], [11, 15, 19]]) + >>> np.mean(a) + 12.0 + >>> np.mean(a, where=[[True], [False], [False]]) + 9.0 + + """ + kwargs = {} + if keepdims is not np._NoValue: + kwargs['keepdims'] = keepdims + if where is not np._NoValue: + kwargs['where'] = where + if type(a) is not mu.ndarray: + try: + mean = a.mean + except AttributeError: + pass + else: + return mean(axis=axis, dtype=dtype, out=out, **kwargs) + + return _methods._mean(a, axis=axis, dtype=dtype, + out=out, **kwargs) + + +def _std_dispatcher(a, axis=None, dtype=None, out=None, ddof=None, + keepdims=None, *, where=None, mean=None, correction=None): + return (a, where, out, mean) + + +@array_function_dispatch(_std_dispatcher) +def std(a, axis=None, dtype=None, out=None, ddof=0, keepdims=np._NoValue, *, + where=np._NoValue, mean=np._NoValue, correction=np._NoValue): + r""" + Compute the standard deviation along the specified axis. + + Returns the standard deviation, a measure of the spread of a distribution, + of the array elements. The standard deviation is computed for the + flattened array by default, otherwise over the specified axis. + + Parameters + ---------- + a : array_like + Calculate the standard deviation of these values. + axis : None or int or tuple of ints, optional + Axis or axes along which the standard deviation is computed. The + default is to compute the standard deviation of the flattened array. + + .. versionadded:: 1.7.0 + + If this is a tuple of ints, a standard deviation is performed over + multiple axes, instead of a single axis or all the axes as before. + dtype : dtype, optional + Type to use in computing the standard deviation. For arrays of + integer type the default is float64, for arrays of float types it is + the same as the array type. + out : ndarray, optional + Alternative output array in which to place the result. It must have + the same shape as the expected output but the type (of the calculated + values) will be cast if necessary. + See :ref:`ufuncs-output-type` for more details. + ddof : {int, float}, optional + Means Delta Degrees of Freedom. The divisor used in calculations + is ``N - ddof``, where ``N`` represents the number of elements. + By default `ddof` is zero. See Notes for details about use of `ddof`. + keepdims : bool, optional + If this is set to True, the axes which are reduced are left + in the result as dimensions with size one. With this option, + the result will broadcast correctly against the input array. + + If the default value is passed, then `keepdims` will not be + passed through to the `std` method of sub-classes of + `ndarray`, however any non-default value will be. If the + sub-class' method does not implement `keepdims` any + exceptions will be raised. + where : array_like of bool, optional + Elements to include in the standard deviation. + See `~numpy.ufunc.reduce` for details. + + .. versionadded:: 1.20.0 + + mean : array_like, optional + Provide the mean to prevent its recalculation. The mean should have + a shape as if it was calculated with ``keepdims=True``. + The axis for the calculation of the mean should be the same as used in + the call to this std function. + + .. versionadded:: 1.26.0 + + correction : {int, float}, optional + Array API compatible name for the ``ddof`` parameter. Only one of them + can be provided at the same time. + + .. versionadded:: 2.0.0 + + Returns + ------- + standard_deviation : ndarray, see dtype parameter above. + If `out` is None, return a new array containing the standard deviation, + otherwise return a reference to the output array. + + See Also + -------- + var, mean, nanmean, nanstd, nanvar + :ref:`ufuncs-output-type` + + Notes + ----- + There are several common variants of the array standard deviation + calculation. Assuming the input `a` is a one-dimensional NumPy array + and ``mean`` is either provided as an argument or computed as + ``a.mean()``, NumPy computes the standard deviation of an array as:: + + N = len(a) + d2 = abs(a - mean)**2 # abs is for complex `a` + var = d2.sum() / (N - ddof) # note use of `ddof` + std = var**0.5 + + Different values of the argument `ddof` are useful in different + contexts. NumPy's default ``ddof=0`` corresponds with the expression: + + .. math:: + + \sqrt{\frac{\sum_i{|a_i - \bar{a}|^2 }}{N}} + + which is sometimes called the "population standard deviation" in the field + of statistics because it applies the definition of standard deviation to + `a` as if `a` were a complete population of possible observations. + + Many other libraries define the standard deviation of an array + differently, e.g.: + + .. math:: + + \sqrt{\frac{\sum_i{|a_i - \bar{a}|^2 }}{N - 1}} + + In statistics, the resulting quantity is sometimed called the "sample + standard deviation" because if `a` is a random sample from a larger + population, this calculation provides the square root of an unbiased + estimate of the variance of the population. The use of :math:`N-1` in the + denominator is often called "Bessel's correction" because it corrects for + bias (toward lower values) in the variance estimate introduced when the + sample mean of `a` is used in place of the true mean of the population. + The resulting estimate of the standard deviation is still biased, but less + than it would have been without the correction. For this quantity, use + ``ddof=1``. + + Note that, for complex numbers, `std` takes the absolute + value before squaring, so that the result is always real and nonnegative. + + For floating-point input, the standard deviation is computed using the same + precision the input has. Depending on the input data, this can cause + the results to be inaccurate, especially for float32 (see example below). + Specifying a higher-accuracy accumulator using the `dtype` keyword can + alleviate this issue. + + Examples + -------- + >>> import numpy as np + >>> a = np.array([[1, 2], [3, 4]]) + >>> np.std(a) + 1.1180339887498949 # may vary + >>> np.std(a, axis=0) + array([1., 1.]) + >>> np.std(a, axis=1) + array([0.5, 0.5]) + + In single precision, std() can be inaccurate: + + >>> a = np.zeros((2, 512*512), dtype=np.float32) + >>> a[0, :] = 1.0 + >>> a[1, :] = 0.1 + >>> np.std(a) + 0.45000005 + + Computing the standard deviation in float64 is more accurate: + + >>> np.std(a, dtype=np.float64) + 0.44999999925494177 # may vary + + Specifying a where argument: + + >>> a = np.array([[14, 8, 11, 10], [7, 9, 10, 11], [10, 15, 5, 10]]) + >>> np.std(a) + 2.614064523559687 # may vary + >>> np.std(a, where=[[True], [True], [False]]) + 2.0 + + Using the mean keyword to save computation time: + + >>> import numpy as np + >>> from timeit import timeit + >>> a = np.array([[14, 8, 11, 10], [7, 9, 10, 11], [10, 15, 5, 10]]) + >>> mean = np.mean(a, axis=1, keepdims=True) + >>> + >>> g = globals() + >>> n = 10000 + >>> t1 = timeit("std = np.std(a, axis=1, mean=mean)", globals=g, number=n) + >>> t2 = timeit("std = np.std(a, axis=1)", globals=g, number=n) + >>> print(f'Percentage execution time saved {100*(t2-t1)/t2:.0f}%') + #doctest: +SKIP + Percentage execution time saved 30% + + """ + kwargs = {} + if keepdims is not np._NoValue: + kwargs['keepdims'] = keepdims + if where is not np._NoValue: + kwargs['where'] = where + if mean is not np._NoValue: + kwargs['mean'] = mean + + if correction != np._NoValue: + if ddof != 0: + raise ValueError( + "ddof and correction can't be provided simultaneously." + ) + else: + ddof = correction + + if type(a) is not mu.ndarray: + try: + std = a.std + except AttributeError: + pass + else: + return std(axis=axis, dtype=dtype, out=out, ddof=ddof, **kwargs) + + return _methods._std(a, axis=axis, dtype=dtype, out=out, ddof=ddof, + **kwargs) + + +def _var_dispatcher(a, axis=None, dtype=None, out=None, ddof=None, + keepdims=None, *, where=None, mean=None, correction=None): + return (a, where, out, mean) + + +@array_function_dispatch(_var_dispatcher) +def var(a, axis=None, dtype=None, out=None, ddof=0, keepdims=np._NoValue, *, + where=np._NoValue, mean=np._NoValue, correction=np._NoValue): + r""" + Compute the variance along the specified axis. + + Returns the variance of the array elements, a measure of the spread of a + distribution. The variance is computed for the flattened array by + default, otherwise over the specified axis. + + Parameters + ---------- + a : array_like + Array containing numbers whose variance is desired. If `a` is not an + array, a conversion is attempted. + axis : None or int or tuple of ints, optional + Axis or axes along which the variance is computed. The default is to + compute the variance of the flattened array. + + .. versionadded:: 1.7.0 + + If this is a tuple of ints, a variance is performed over multiple axes, + instead of a single axis or all the axes as before. + dtype : data-type, optional + Type to use in computing the variance. For arrays of integer type + the default is `float64`; for arrays of float types it is the same as + the array type. + out : ndarray, optional + Alternate output array in which to place the result. It must have + the same shape as the expected output, but the type is cast if + necessary. + ddof : {int, float}, optional + "Delta Degrees of Freedom": the divisor used in the calculation is + ``N - ddof``, where ``N`` represents the number of elements. By + default `ddof` is zero. See notes for details about use of `ddof`. + keepdims : bool, optional + If this is set to True, the axes which are reduced are left + in the result as dimensions with size one. With this option, + the result will broadcast correctly against the input array. + + If the default value is passed, then `keepdims` will not be + passed through to the `var` method of sub-classes of + `ndarray`, however any non-default value will be. If the + sub-class' method does not implement `keepdims` any + exceptions will be raised. + where : array_like of bool, optional + Elements to include in the variance. See `~numpy.ufunc.reduce` for + details. + + .. versionadded:: 1.20.0 + + mean : array like, optional + Provide the mean to prevent its recalculation. The mean should have + a shape as if it was calculated with ``keepdims=True``. + The axis for the calculation of the mean should be the same as used in + the call to this var function. + + .. versionadded:: 1.26.0 + + correction : {int, float}, optional + Array API compatible name for the ``ddof`` parameter. Only one of them + can be provided at the same time. + + .. versionadded:: 2.0.0 + + Returns + ------- + variance : ndarray, see dtype parameter above + If ``out=None``, returns a new array containing the variance; + otherwise, a reference to the output array is returned. + + See Also + -------- + std, mean, nanmean, nanstd, nanvar + :ref:`ufuncs-output-type` + + Notes + ----- + There are several common variants of the array variance calculation. + Assuming the input `a` is a one-dimensional NumPy array and ``mean`` is + either provided as an argument or computed as ``a.mean()``, NumPy + computes the variance of an array as:: + + N = len(a) + d2 = abs(a - mean)**2 # abs is for complex `a` + var = d2.sum() / (N - ddof) # note use of `ddof` + + Different values of the argument `ddof` are useful in different + contexts. NumPy's default ``ddof=0`` corresponds with the expression: + + .. math:: + + \frac{\sum_i{|a_i - \bar{a}|^2 }}{N} + + which is sometimes called the "population variance" in the field of + statistics because it applies the definition of variance to `a` as if `a` + were a complete population of possible observations. + + Many other libraries define the variance of an array differently, e.g.: + + .. math:: + + \frac{\sum_i{|a_i - \bar{a}|^2}}{N - 1} + + In statistics, the resulting quantity is sometimed called the "sample + variance" because if `a` is a random sample from a larger population, + this calculation provides an unbiased estimate of the variance of the + population. The use of :math:`N-1` in the denominator is often called + "Bessel's correction" because it corrects for bias (toward lower values) + in the variance estimate introduced when the sample mean of `a` is used + in place of the true mean of the population. For this quantity, use + ``ddof=1``. + + Note that for complex numbers, the absolute value is taken before + squaring, so that the result is always real and nonnegative. + + For floating-point input, the variance is computed using the same + precision the input has. Depending on the input data, this can cause + the results to be inaccurate, especially for `float32` (see example + below). Specifying a higher-accuracy accumulator using the ``dtype`` + keyword can alleviate this issue. + + Examples + -------- + >>> import numpy as np + >>> a = np.array([[1, 2], [3, 4]]) + >>> np.var(a) + 1.25 + >>> np.var(a, axis=0) + array([1., 1.]) + >>> np.var(a, axis=1) + array([0.25, 0.25]) + + In single precision, var() can be inaccurate: + + >>> a = np.zeros((2, 512*512), dtype=np.float32) + >>> a[0, :] = 1.0 + >>> a[1, :] = 0.1 + >>> np.var(a) + 0.20250003 + + Computing the variance in float64 is more accurate: + + >>> np.var(a, dtype=np.float64) + 0.20249999932944759 # may vary + >>> ((1-0.55)**2 + (0.1-0.55)**2)/2 + 0.2025 + + Specifying a where argument: + + >>> a = np.array([[14, 8, 11, 10], [7, 9, 10, 11], [10, 15, 5, 10]]) + >>> np.var(a) + 6.833333333333333 # may vary + >>> np.var(a, where=[[True], [True], [False]]) + 4.0 + + Using the mean keyword to save computation time: + + >>> import numpy as np + >>> from timeit import timeit + >>> + >>> a = np.array([[14, 8, 11, 10], [7, 9, 10, 11], [10, 15, 5, 10]]) + >>> mean = np.mean(a, axis=1, keepdims=True) + >>> + >>> g = globals() + >>> n = 10000 + >>> t1 = timeit("var = np.var(a, axis=1, mean=mean)", globals=g, number=n) + >>> t2 = timeit("var = np.var(a, axis=1)", globals=g, number=n) + >>> print(f'Percentage execution time saved {100*(t2-t1)/t2:.0f}%') + #doctest: +SKIP + Percentage execution time saved 32% + + """ + kwargs = {} + if keepdims is not np._NoValue: + kwargs['keepdims'] = keepdims + if where is not np._NoValue: + kwargs['where'] = where + if mean is not np._NoValue: + kwargs['mean'] = mean + + if correction != np._NoValue: + if ddof != 0: + raise ValueError( + "ddof and correction can't be provided simultaneously." + ) + else: + ddof = correction + + if type(a) is not mu.ndarray: + try: + var = a.var + + except AttributeError: + pass + else: + return var(axis=axis, dtype=dtype, out=out, ddof=ddof, **kwargs) + + return _methods._var(a, axis=axis, dtype=dtype, out=out, ddof=ddof, + **kwargs) + diff --git a/venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.pyi b/venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.pyi new file mode 100644 index 00000000..08e79178 --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.pyi @@ -0,0 +1,1245 @@ +from collections.abc import Sequence +from typing import Any, overload, TypeVar, Literal, SupportsIndex + +import numpy as np +from numpy import ( + number, + uint64, + int_, + int64, + intp, + float16, + floating, + complexfloating, + object_, + generic, + _OrderKACF, + _OrderACF, + _ModeKind, + _PartitionKind, + _SortKind, + _SortSide, + _CastingKind, +) +from numpy._typing import ( + DTypeLike, + _DTypeLike, + ArrayLike, + _ArrayLike, + NDArray, + _ShapeLike, + _Shape, + _ArrayLikeBool_co, + _ArrayLikeUInt_co, + _ArrayLikeInt_co, + _ArrayLikeFloat_co, + _ArrayLikeComplex_co, + _ArrayLikeObject_co, + _IntLike_co, + _BoolLike_co, + _ComplexLike_co, + _NumberLike_co, + _ScalarLike_co, +) + +_SCT = TypeVar("_SCT", bound=generic) +_SCT_uifcO = TypeVar("_SCT_uifcO", bound=number[Any] | object_) +_ArrayType = TypeVar("_ArrayType", bound=NDArray[Any]) + +__all__: list[str] + +@overload +def take( + a: _ArrayLike[_SCT], + indices: _IntLike_co, + axis: None = ..., + out: None = ..., + mode: _ModeKind = ..., +) -> _SCT: ... +@overload +def take( + a: ArrayLike, + indices: _IntLike_co, + axis: None | SupportsIndex = ..., + out: None = ..., + mode: _ModeKind = ..., +) -> Any: ... +@overload +def take( + a: _ArrayLike[_SCT], + indices: _ArrayLikeInt_co, + axis: None | SupportsIndex = ..., + out: None = ..., + mode: _ModeKind = ..., +) -> NDArray[_SCT]: ... +@overload +def take( + a: ArrayLike, + indices: _ArrayLikeInt_co, + axis: None | SupportsIndex = ..., + out: None = ..., + mode: _ModeKind = ..., +) -> NDArray[Any]: ... +@overload +def take( + a: ArrayLike, + indices: _ArrayLikeInt_co, + axis: None | SupportsIndex = ..., + out: _ArrayType = ..., + mode: _ModeKind = ..., +) -> _ArrayType: ... + +@overload +def reshape( + a: _ArrayLike[_SCT], + /, + shape: _ShapeLike = ..., + order: _OrderACF = ..., + *, + newshape: _ShapeLike = ..., + copy: None | bool = ..., +) -> NDArray[_SCT]: ... +@overload +def reshape( + a: ArrayLike, + /, + shape: _ShapeLike = ..., + order: _OrderACF = ..., + *, + newshape: _ShapeLike = ..., + copy: None | bool = ..., +) -> NDArray[Any]: ... + +@overload +def choose( + a: _IntLike_co, + choices: ArrayLike, + out: None = ..., + mode: _ModeKind = ..., +) -> Any: ... +@overload +def choose( + a: _ArrayLikeInt_co, + choices: _ArrayLike[_SCT], + out: None = ..., + mode: _ModeKind = ..., +) -> NDArray[_SCT]: ... +@overload +def choose( + a: _ArrayLikeInt_co, + choices: ArrayLike, + out: None = ..., + mode: _ModeKind = ..., +) -> NDArray[Any]: ... +@overload +def choose( + a: _ArrayLikeInt_co, + choices: ArrayLike, + out: _ArrayType = ..., + mode: _ModeKind = ..., +) -> _ArrayType: ... + +@overload +def repeat( + a: _ArrayLike[_SCT], + repeats: _ArrayLikeInt_co, + axis: None | SupportsIndex = ..., +) -> NDArray[_SCT]: ... +@overload +def repeat( + a: ArrayLike, + repeats: _ArrayLikeInt_co, + axis: None | SupportsIndex = ..., +) -> NDArray[Any]: ... + +def put( + a: NDArray[Any], + ind: _ArrayLikeInt_co, + v: ArrayLike, + mode: _ModeKind = ..., +) -> None: ... + +@overload +def swapaxes( + a: _ArrayLike[_SCT], + axis1: SupportsIndex, + axis2: SupportsIndex, +) -> NDArray[_SCT]: ... +@overload +def swapaxes( + a: ArrayLike, + axis1: SupportsIndex, + axis2: SupportsIndex, +) -> NDArray[Any]: ... + +@overload +def transpose( + a: _ArrayLike[_SCT], + axes: None | _ShapeLike = ... +) -> NDArray[_SCT]: ... +@overload +def transpose( + a: ArrayLike, + axes: None | _ShapeLike = ... +) -> NDArray[Any]: ... + +@overload +def matrix_transpose(x: _ArrayLike[_SCT]) -> NDArray[_SCT]: ... +@overload +def matrix_transpose(x: ArrayLike) -> NDArray[Any]: ... + +@overload +def partition( + a: _ArrayLike[_SCT], + kth: _ArrayLikeInt_co, + axis: None | SupportsIndex = ..., + kind: _PartitionKind = ..., + order: None | str | Sequence[str] = ..., +) -> NDArray[_SCT]: ... +@overload +def partition( + a: ArrayLike, + kth: _ArrayLikeInt_co, + axis: None | SupportsIndex = ..., + kind: _PartitionKind = ..., + order: None | str | Sequence[str] = ..., +) -> NDArray[Any]: ... + +def argpartition( + a: ArrayLike, + kth: _ArrayLikeInt_co, + axis: None | SupportsIndex = ..., + kind: _PartitionKind = ..., + order: None | str | Sequence[str] = ..., +) -> NDArray[intp]: ... + +@overload +def sort( + a: _ArrayLike[_SCT], + axis: None | SupportsIndex = ..., + kind: None | _SortKind = ..., + order: None | str | Sequence[str] = ..., + *, + stable: None | bool = ..., +) -> NDArray[_SCT]: ... +@overload +def sort( + a: ArrayLike, + axis: None | SupportsIndex = ..., + kind: None | _SortKind = ..., + order: None | str | Sequence[str] = ..., + *, + stable: None | bool = ..., +) -> NDArray[Any]: ... + +def argsort( + a: ArrayLike, + axis: None | SupportsIndex = ..., + kind: None | _SortKind = ..., + order: None | str | Sequence[str] = ..., + *, + stable: None | bool = ..., +) -> NDArray[intp]: ... + +@overload +def argmax( + a: ArrayLike, + axis: None = ..., + out: None = ..., + *, + keepdims: Literal[False] = ..., +) -> intp: ... +@overload +def argmax( + a: ArrayLike, + axis: None | SupportsIndex = ..., + out: None = ..., + *, + keepdims: bool = ..., +) -> Any: ... +@overload +def argmax( + a: ArrayLike, + axis: None | SupportsIndex = ..., + out: _ArrayType = ..., + *, + keepdims: bool = ..., +) -> _ArrayType: ... + +@overload +def argmin( + a: ArrayLike, + axis: None = ..., + out: None = ..., + *, + keepdims: Literal[False] = ..., +) -> intp: ... +@overload +def argmin( + a: ArrayLike, + axis: None | SupportsIndex = ..., + out: None = ..., + *, + keepdims: bool = ..., +) -> Any: ... +@overload +def argmin( + a: ArrayLike, + axis: None | SupportsIndex = ..., + out: _ArrayType = ..., + *, + keepdims: bool = ..., +) -> _ArrayType: ... + +@overload +def searchsorted( + a: ArrayLike, + v: _ScalarLike_co, + side: _SortSide = ..., + sorter: None | _ArrayLikeInt_co = ..., # 1D int array +) -> intp: ... +@overload +def searchsorted( + a: ArrayLike, + v: ArrayLike, + side: _SortSide = ..., + sorter: None | _ArrayLikeInt_co = ..., # 1D int array +) -> NDArray[intp]: ... + +@overload +def resize( + a: _ArrayLike[_SCT], + new_shape: _ShapeLike, +) -> NDArray[_SCT]: ... +@overload +def resize( + a: ArrayLike, + new_shape: _ShapeLike, +) -> NDArray[Any]: ... + +@overload +def squeeze( + a: _SCT, + axis: None | _ShapeLike = ..., +) -> _SCT: ... +@overload +def squeeze( + a: _ArrayLike[_SCT], + axis: None | _ShapeLike = ..., +) -> NDArray[_SCT]: ... +@overload +def squeeze( + a: ArrayLike, + axis: None | _ShapeLike = ..., +) -> NDArray[Any]: ... + +@overload +def diagonal( + a: _ArrayLike[_SCT], + offset: SupportsIndex = ..., + axis1: SupportsIndex = ..., + axis2: SupportsIndex = ..., # >= 2D array +) -> NDArray[_SCT]: ... +@overload +def diagonal( + a: ArrayLike, + offset: SupportsIndex = ..., + axis1: SupportsIndex = ..., + axis2: SupportsIndex = ..., # >= 2D array +) -> NDArray[Any]: ... + +@overload +def trace( + a: ArrayLike, # >= 2D array + offset: SupportsIndex = ..., + axis1: SupportsIndex = ..., + axis2: SupportsIndex = ..., + dtype: DTypeLike = ..., + out: None = ..., +) -> Any: ... +@overload +def trace( + a: ArrayLike, # >= 2D array + offset: SupportsIndex = ..., + axis1: SupportsIndex = ..., + axis2: SupportsIndex = ..., + dtype: DTypeLike = ..., + out: _ArrayType = ..., +) -> _ArrayType: ... + +@overload +def ravel(a: _ArrayLike[_SCT], order: _OrderKACF = ...) -> NDArray[_SCT]: ... +@overload +def ravel(a: ArrayLike, order: _OrderKACF = ...) -> NDArray[Any]: ... + +def nonzero(a: ArrayLike) -> tuple[NDArray[intp], ...]: ... + +def shape(a: ArrayLike) -> _Shape: ... + +@overload +def compress( + condition: _ArrayLikeBool_co, # 1D bool array + a: _ArrayLike[_SCT], + axis: None | SupportsIndex = ..., + out: None = ..., +) -> NDArray[_SCT]: ... +@overload +def compress( + condition: _ArrayLikeBool_co, # 1D bool array + a: ArrayLike, + axis: None | SupportsIndex = ..., + out: None = ..., +) -> NDArray[Any]: ... +@overload +def compress( + condition: _ArrayLikeBool_co, # 1D bool array + a: ArrayLike, + axis: None | SupportsIndex = ..., + out: _ArrayType = ..., +) -> _ArrayType: ... + +@overload +def clip( + a: _SCT, + a_min: None | ArrayLike, + a_max: None | ArrayLike, + out: None = ..., + *, + min: None | ArrayLike = ..., + max: None | ArrayLike = ..., + dtype: None = ..., + where: None | _ArrayLikeBool_co = ..., + order: _OrderKACF = ..., + subok: bool = ..., + signature: str | tuple[None | str, ...] = ..., + casting: _CastingKind = ..., +) -> _SCT: ... +@overload +def clip( + a: _ScalarLike_co, + a_min: None | ArrayLike, + a_max: None | ArrayLike, + out: None = ..., + *, + min: None | ArrayLike = ..., + max: None | ArrayLike = ..., + dtype: None = ..., + where: None | _ArrayLikeBool_co = ..., + order: _OrderKACF = ..., + subok: bool = ..., + signature: str | tuple[None | str, ...] = ..., + casting: _CastingKind = ..., +) -> Any: ... +@overload +def clip( + a: _ArrayLike[_SCT], + a_min: None | ArrayLike, + a_max: None | ArrayLike, + out: None = ..., + *, + min: None | ArrayLike = ..., + max: None | ArrayLike = ..., + dtype: None = ..., + where: None | _ArrayLikeBool_co = ..., + order: _OrderKACF = ..., + subok: bool = ..., + signature: str | tuple[None | str, ...] = ..., + casting: _CastingKind = ..., +) -> NDArray[_SCT]: ... +@overload +def clip( + a: ArrayLike, + a_min: None | ArrayLike, + a_max: None | ArrayLike, + out: None = ..., + *, + min: None | ArrayLike = ..., + max: None | ArrayLike = ..., + dtype: None = ..., + where: None | _ArrayLikeBool_co = ..., + order: _OrderKACF = ..., + subok: bool = ..., + signature: str | tuple[None | str, ...] = ..., + casting: _CastingKind = ..., +) -> NDArray[Any]: ... +@overload +def clip( + a: ArrayLike, + a_min: None | ArrayLike, + a_max: None | ArrayLike, + out: _ArrayType = ..., + *, + min: None | ArrayLike = ..., + max: None | ArrayLike = ..., + dtype: DTypeLike, + where: None | _ArrayLikeBool_co = ..., + order: _OrderKACF = ..., + subok: bool = ..., + signature: str | tuple[None | str, ...] = ..., + casting: _CastingKind = ..., +) -> Any: ... +@overload +def clip( + a: ArrayLike, + a_min: None | ArrayLike, + a_max: None | ArrayLike, + out: _ArrayType, + *, + min: None | ArrayLike = ..., + max: None | ArrayLike = ..., + dtype: DTypeLike = ..., + where: None | _ArrayLikeBool_co = ..., + order: _OrderKACF = ..., + subok: bool = ..., + signature: str | tuple[None | str, ...] = ..., + casting: _CastingKind = ..., +) -> _ArrayType: ... + +@overload +def sum( + a: _ArrayLike[_SCT], + axis: None = ..., + dtype: None = ..., + out: None = ..., + keepdims: bool = ..., + initial: _NumberLike_co = ..., + where: _ArrayLikeBool_co = ..., +) -> _SCT: ... +@overload +def sum( + a: ArrayLike, + axis: None | _ShapeLike = ..., + dtype: DTypeLike = ..., + out: None = ..., + keepdims: bool = ..., + initial: _NumberLike_co = ..., + where: _ArrayLikeBool_co = ..., +) -> Any: ... +@overload +def sum( + a: ArrayLike, + axis: None | _ShapeLike = ..., + dtype: DTypeLike = ..., + out: _ArrayType = ..., + keepdims: bool = ..., + initial: _NumberLike_co = ..., + where: _ArrayLikeBool_co = ..., +) -> _ArrayType: ... + +@overload +def all( + a: ArrayLike, + axis: None = ..., + out: None = ..., + keepdims: Literal[False] = ..., + *, + where: _ArrayLikeBool_co = ..., +) -> np.bool: ... +@overload +def all( + a: ArrayLike, + axis: None | _ShapeLike = ..., + out: None = ..., + keepdims: bool = ..., + *, + where: _ArrayLikeBool_co = ..., +) -> Any: ... +@overload +def all( + a: ArrayLike, + axis: None | _ShapeLike = ..., + out: _ArrayType = ..., + keepdims: bool = ..., + *, + where: _ArrayLikeBool_co = ..., +) -> _ArrayType: ... + +@overload +def any( + a: ArrayLike, + axis: None = ..., + out: None = ..., + keepdims: Literal[False] = ..., + *, + where: _ArrayLikeBool_co = ..., +) -> np.bool: ... +@overload +def any( + a: ArrayLike, + axis: None | _ShapeLike = ..., + out: None = ..., + keepdims: bool = ..., + *, + where: _ArrayLikeBool_co = ..., +) -> Any: ... +@overload +def any( + a: ArrayLike, + axis: None | _ShapeLike = ..., + out: _ArrayType = ..., + keepdims: bool = ..., + *, + where: _ArrayLikeBool_co = ..., +) -> _ArrayType: ... + +@overload +def cumsum( + a: _ArrayLike[_SCT], + axis: None | SupportsIndex = ..., + dtype: None = ..., + out: None = ..., +) -> NDArray[_SCT]: ... +@overload +def cumsum( + a: ArrayLike, + axis: None | SupportsIndex = ..., + dtype: None = ..., + out: None = ..., +) -> NDArray[Any]: ... +@overload +def cumsum( + a: ArrayLike, + axis: None | SupportsIndex = ..., + dtype: _DTypeLike[_SCT] = ..., + out: None = ..., +) -> NDArray[_SCT]: ... +@overload +def cumsum( + a: ArrayLike, + axis: None | SupportsIndex = ..., + dtype: DTypeLike = ..., + out: None = ..., +) -> NDArray[Any]: ... +@overload +def cumsum( + a: ArrayLike, + axis: None | SupportsIndex = ..., + dtype: DTypeLike = ..., + out: _ArrayType = ..., +) -> _ArrayType: ... + +@overload +def cumulative_sum( + x: _ArrayLike[_SCT], + /, + *, + axis: None | SupportsIndex = ..., + dtype: None = ..., + out: None = ..., + include_initial: bool = ..., +) -> NDArray[_SCT]: ... +@overload +def cumulative_sum( + x: ArrayLike, + /, + *, + axis: None | SupportsIndex = ..., + dtype: None = ..., + out: None = ..., + include_initial: bool = ..., +) -> NDArray[Any]: ... +@overload +def cumulative_sum( + x: ArrayLike, + /, + *, + axis: None | SupportsIndex = ..., + dtype: _DTypeLike[_SCT] = ..., + out: None = ..., + include_initial: bool = ..., +) -> NDArray[_SCT]: ... +@overload +def cumulative_sum( + x: ArrayLike, + /, + *, + axis: None | SupportsIndex = ..., + dtype: DTypeLike = ..., + out: None = ..., + include_initial: bool = ..., +) -> NDArray[Any]: ... +@overload +def cumulative_sum( + x: ArrayLike, + /, + *, + axis: None | SupportsIndex = ..., + dtype: DTypeLike = ..., + out: _ArrayType = ..., + include_initial: bool = ..., +) -> _ArrayType: ... + +@overload +def ptp( + a: _ArrayLike[_SCT], + axis: None = ..., + out: None = ..., + keepdims: Literal[False] = ..., +) -> _SCT: ... +@overload +def ptp( + a: ArrayLike, + axis: None | _ShapeLike = ..., + out: None = ..., + keepdims: bool = ..., +) -> Any: ... +@overload +def ptp( + a: ArrayLike, + axis: None | _ShapeLike = ..., + out: _ArrayType = ..., + keepdims: bool = ..., +) -> _ArrayType: ... + +@overload +def amax( + a: _ArrayLike[_SCT], + axis: None = ..., + out: None = ..., + keepdims: Literal[False] = ..., + initial: _NumberLike_co = ..., + where: _ArrayLikeBool_co = ..., +) -> _SCT: ... +@overload +def amax( + a: ArrayLike, + axis: None | _ShapeLike = ..., + out: None = ..., + keepdims: bool = ..., + initial: _NumberLike_co = ..., + where: _ArrayLikeBool_co = ..., +) -> Any: ... +@overload +def amax( + a: ArrayLike, + axis: None | _ShapeLike = ..., + out: _ArrayType = ..., + keepdims: bool = ..., + initial: _NumberLike_co = ..., + where: _ArrayLikeBool_co = ..., +) -> _ArrayType: ... + +@overload +def amin( + a: _ArrayLike[_SCT], + axis: None = ..., + out: None = ..., + keepdims: Literal[False] = ..., + initial: _NumberLike_co = ..., + where: _ArrayLikeBool_co = ..., +) -> _SCT: ... +@overload +def amin( + a: ArrayLike, + axis: None | _ShapeLike = ..., + out: None = ..., + keepdims: bool = ..., + initial: _NumberLike_co = ..., + where: _ArrayLikeBool_co = ..., +) -> Any: ... +@overload +def amin( + a: ArrayLike, + axis: None | _ShapeLike = ..., + out: _ArrayType = ..., + keepdims: bool = ..., + initial: _NumberLike_co = ..., + where: _ArrayLikeBool_co = ..., +) -> _ArrayType: ... + +# TODO: `np.prod()``: For object arrays `initial` does not necessarily +# have to be a numerical scalar. +# The only requirement is that it is compatible +# with the `.__mul__()` method(s) of the passed array's elements. + +# Note that the same situation holds for all wrappers around +# `np.ufunc.reduce`, e.g. `np.sum()` (`.__add__()`). +@overload +def prod( + a: _ArrayLikeBool_co, + axis: None = ..., + dtype: None = ..., + out: None = ..., + keepdims: Literal[False] = ..., + initial: _NumberLike_co = ..., + where: _ArrayLikeBool_co = ..., +) -> int_: ... +@overload +def prod( + a: _ArrayLikeUInt_co, + axis: None = ..., + dtype: None = ..., + out: None = ..., + keepdims: Literal[False] = ..., + initial: _NumberLike_co = ..., + where: _ArrayLikeBool_co = ..., +) -> uint64: ... +@overload +def prod( + a: _ArrayLikeInt_co, + axis: None = ..., + dtype: None = ..., + out: None = ..., + keepdims: Literal[False] = ..., + initial: _NumberLike_co = ..., + where: _ArrayLikeBool_co = ..., +) -> int64: ... +@overload +def prod( + a: _ArrayLikeFloat_co, + axis: None = ..., + dtype: None = ..., + out: None = ..., + keepdims: Literal[False] = ..., + initial: _NumberLike_co = ..., + where: _ArrayLikeBool_co = ..., +) -> floating[Any]: ... +@overload +def prod( + a: _ArrayLikeComplex_co, + axis: None = ..., + dtype: None = ..., + out: None = ..., + keepdims: Literal[False] = ..., + initial: _NumberLike_co = ..., + where: _ArrayLikeBool_co = ..., +) -> complexfloating[Any, Any]: ... +@overload +def prod( + a: _ArrayLikeComplex_co | _ArrayLikeObject_co, + axis: None | _ShapeLike = ..., + dtype: None = ..., + out: None = ..., + keepdims: bool = ..., + initial: _NumberLike_co = ..., + where: _ArrayLikeBool_co = ..., +) -> Any: ... +@overload +def prod( + a: _ArrayLikeComplex_co | _ArrayLikeObject_co, + axis: None = ..., + dtype: _DTypeLike[_SCT] = ..., + out: None = ..., + keepdims: Literal[False] = ..., + initial: _NumberLike_co = ..., + where: _ArrayLikeBool_co = ..., +) -> _SCT: ... +@overload +def prod( + a: _ArrayLikeComplex_co | _ArrayLikeObject_co, + axis: None | _ShapeLike = ..., + dtype: None | DTypeLike = ..., + out: None = ..., + keepdims: bool = ..., + initial: _NumberLike_co = ..., + where: _ArrayLikeBool_co = ..., +) -> Any: ... +@overload +def prod( + a: _ArrayLikeComplex_co | _ArrayLikeObject_co, + axis: None | _ShapeLike = ..., + dtype: None | DTypeLike = ..., + out: _ArrayType = ..., + keepdims: bool = ..., + initial: _NumberLike_co = ..., + where: _ArrayLikeBool_co = ..., +) -> _ArrayType: ... + +@overload +def cumprod( + a: _ArrayLikeBool_co, + axis: None | SupportsIndex = ..., + dtype: None = ..., + out: None = ..., +) -> NDArray[int_]: ... +@overload +def cumprod( + a: _ArrayLikeUInt_co, + axis: None | SupportsIndex = ..., + dtype: None = ..., + out: None = ..., +) -> NDArray[uint64]: ... +@overload +def cumprod( + a: _ArrayLikeInt_co, + axis: None | SupportsIndex = ..., + dtype: None = ..., + out: None = ..., +) -> NDArray[int64]: ... +@overload +def cumprod( + a: _ArrayLikeFloat_co, + axis: None | SupportsIndex = ..., + dtype: None = ..., + out: None = ..., +) -> NDArray[floating[Any]]: ... +@overload +def cumprod( + a: _ArrayLikeComplex_co, + axis: None | SupportsIndex = ..., + dtype: None = ..., + out: None = ..., +) -> NDArray[complexfloating[Any, Any]]: ... +@overload +def cumprod( + a: _ArrayLikeObject_co, + axis: None | SupportsIndex = ..., + dtype: None = ..., + out: None = ..., +) -> NDArray[object_]: ... +@overload +def cumprod( + a: _ArrayLikeComplex_co | _ArrayLikeObject_co, + axis: None | SupportsIndex = ..., + dtype: _DTypeLike[_SCT] = ..., + out: None = ..., +) -> NDArray[_SCT]: ... +@overload +def cumprod( + a: _ArrayLikeComplex_co | _ArrayLikeObject_co, + axis: None | SupportsIndex = ..., + dtype: DTypeLike = ..., + out: None = ..., +) -> NDArray[Any]: ... +@overload +def cumprod( + a: _ArrayLikeComplex_co | _ArrayLikeObject_co, + axis: None | SupportsIndex = ..., + dtype: DTypeLike = ..., + out: _ArrayType = ..., +) -> _ArrayType: ... + +@overload +def cumulative_prod( + x: _ArrayLikeBool_co, + /, + *, + axis: None | SupportsIndex = ..., + dtype: None = ..., + out: None = ..., + include_initial: bool = ..., +) -> NDArray[int_]: ... +@overload +def cumulative_prod( + x: _ArrayLikeUInt_co, + /, + *, + axis: None | SupportsIndex = ..., + dtype: None = ..., + out: None = ..., + include_initial: bool = ..., +) -> NDArray[uint64]: ... +@overload +def cumulative_prod( + x: _ArrayLikeInt_co, + /, + *, + axis: None | SupportsIndex = ..., + dtype: None = ..., + out: None = ..., + include_initial: bool = ..., +) -> NDArray[int64]: ... +@overload +def cumulative_prod( + x: _ArrayLikeFloat_co, + /, + *, + axis: None | SupportsIndex = ..., + dtype: None = ..., + out: None = ..., + include_initial: bool = ..., +) -> NDArray[floating[Any]]: ... +@overload +def cumulative_prod( + x: _ArrayLikeComplex_co, + /, + *, + axis: None | SupportsIndex = ..., + dtype: None = ..., + out: None = ..., + include_initial: bool = ..., +) -> NDArray[complexfloating[Any, Any]]: ... +@overload +def cumulative_prod( + x: _ArrayLikeObject_co, + /, + *, + axis: None | SupportsIndex = ..., + dtype: None = ..., + out: None = ..., + include_initial: bool = ..., +) -> NDArray[object_]: ... +@overload +def cumulative_prod( + x: _ArrayLikeComplex_co | _ArrayLikeObject_co, + /, + *, + axis: None | SupportsIndex = ..., + dtype: _DTypeLike[_SCT] = ..., + out: None = ..., + include_initial: bool = ..., +) -> NDArray[_SCT]: ... +@overload +def cumulative_prod( + x: _ArrayLikeComplex_co | _ArrayLikeObject_co, + /, + *, + axis: None | SupportsIndex = ..., + dtype: DTypeLike = ..., + out: None = ..., + include_initial: bool = ..., +) -> NDArray[Any]: ... +@overload +def cumulative_prod( + x: _ArrayLikeComplex_co | _ArrayLikeObject_co, + /, + *, + axis: None | SupportsIndex = ..., + dtype: DTypeLike = ..., + out: _ArrayType = ..., + include_initial: bool = ..., +) -> _ArrayType: ... + +def ndim(a: ArrayLike) -> int: ... + +def size(a: ArrayLike, axis: None | int = ...) -> int: ... + +@overload +def around( + a: _BoolLike_co, + decimals: SupportsIndex = ..., + out: None = ..., +) -> float16: ... +@overload +def around( + a: _SCT_uifcO, + decimals: SupportsIndex = ..., + out: None = ..., +) -> _SCT_uifcO: ... +@overload +def around( + a: _ComplexLike_co | object_, + decimals: SupportsIndex = ..., + out: None = ..., +) -> Any: ... +@overload +def around( + a: _ArrayLikeBool_co, + decimals: SupportsIndex = ..., + out: None = ..., +) -> NDArray[float16]: ... +@overload +def around( + a: _ArrayLike[_SCT_uifcO], + decimals: SupportsIndex = ..., + out: None = ..., +) -> NDArray[_SCT_uifcO]: ... +@overload +def around( + a: _ArrayLikeComplex_co | _ArrayLikeObject_co, + decimals: SupportsIndex = ..., + out: None = ..., +) -> NDArray[Any]: ... +@overload +def around( + a: _ArrayLikeComplex_co | _ArrayLikeObject_co, + decimals: SupportsIndex = ..., + out: _ArrayType = ..., +) -> _ArrayType: ... + +@overload +def mean( + a: _ArrayLikeFloat_co, + axis: None = ..., + dtype: None = ..., + out: None = ..., + keepdims: Literal[False] = ..., + *, + where: _ArrayLikeBool_co = ..., +) -> floating[Any]: ... +@overload +def mean( + a: _ArrayLikeComplex_co, + axis: None = ..., + dtype: None = ..., + out: None = ..., + keepdims: Literal[False] = ..., + *, + where: _ArrayLikeBool_co = ..., +) -> complexfloating[Any, Any]: ... +@overload +def mean( + a: _ArrayLikeComplex_co | _ArrayLikeObject_co, + axis: None | _ShapeLike = ..., + dtype: None = ..., + out: None = ..., + keepdims: bool = ..., + *, + where: _ArrayLikeBool_co = ..., +) -> Any: ... +@overload +def mean( + a: _ArrayLikeComplex_co | _ArrayLikeObject_co, + axis: None = ..., + dtype: _DTypeLike[_SCT] = ..., + out: None = ..., + keepdims: Literal[False] = ..., + *, + where: _ArrayLikeBool_co = ..., +) -> _SCT: ... +@overload +def mean( + a: _ArrayLikeComplex_co | _ArrayLikeObject_co, + axis: None | _ShapeLike = ..., + dtype: DTypeLike = ..., + out: None = ..., + keepdims: bool = ..., + *, + where: _ArrayLikeBool_co = ..., +) -> Any: ... +@overload +def mean( + a: _ArrayLikeComplex_co | _ArrayLikeObject_co, + axis: None | _ShapeLike = ..., + dtype: DTypeLike = ..., + out: _ArrayType = ..., + keepdims: bool = ..., + *, + where: _ArrayLikeBool_co = ..., +) -> _ArrayType: ... + +@overload +def std( + a: _ArrayLikeComplex_co, + axis: None = ..., + dtype: None = ..., + out: None = ..., + ddof: int | float = ..., + keepdims: Literal[False] = ..., + *, + where: _ArrayLikeBool_co = ..., + mean: _ArrayLikeComplex_co = ..., + correction: int | float = ..., +) -> floating[Any]: ... +@overload +def std( + a: _ArrayLikeComplex_co | _ArrayLikeObject_co, + axis: None | _ShapeLike = ..., + dtype: None = ..., + out: None = ..., + ddof: int | float = ..., + keepdims: bool = ..., + *, + where: _ArrayLikeBool_co = ..., + mean: _ArrayLikeComplex_co | _ArrayLikeObject_co = ..., + correction: int | float = ..., +) -> Any: ... +@overload +def std( + a: _ArrayLikeComplex_co | _ArrayLikeObject_co, + axis: None = ..., + dtype: _DTypeLike[_SCT] = ..., + out: None = ..., + ddof: int | float = ..., + keepdims: Literal[False] = ..., + *, + where: _ArrayLikeBool_co = ..., + mean: _ArrayLikeComplex_co | _ArrayLikeObject_co = ..., + correction: int | float = ..., +) -> _SCT: ... +@overload +def std( + a: _ArrayLikeComplex_co | _ArrayLikeObject_co, + axis: None | _ShapeLike = ..., + dtype: DTypeLike = ..., + out: None = ..., + ddof: int | float = ..., + keepdims: bool = ..., + *, + where: _ArrayLikeBool_co = ..., + mean: _ArrayLikeComplex_co | _ArrayLikeObject_co = ..., + correction: int | float = ..., +) -> Any: ... +@overload +def std( + a: _ArrayLikeComplex_co | _ArrayLikeObject_co, + axis: None | _ShapeLike = ..., + dtype: DTypeLike = ..., + out: _ArrayType = ..., + ddof: int | float = ..., + keepdims: bool = ..., + *, + where: _ArrayLikeBool_co = ..., + mean: _ArrayLikeComplex_co | _ArrayLikeObject_co = ..., + correction: int | float = ..., +) -> _ArrayType: ... + +@overload +def var( + a: _ArrayLikeComplex_co, + axis: None = ..., + dtype: None = ..., + out: None = ..., + ddof: int | float = ..., + keepdims: Literal[False] = ..., + *, + where: _ArrayLikeBool_co = ..., + mean: _ArrayLikeComplex_co = ..., + correction: int | float = ..., +) -> floating[Any]: ... +@overload +def var( + a: _ArrayLikeComplex_co | _ArrayLikeObject_co, + axis: None | _ShapeLike = ..., + dtype: None = ..., + out: None = ..., + ddof: int | float = ..., + keepdims: bool = ..., + *, + where: _ArrayLikeBool_co = ..., + mean: _ArrayLikeComplex_co | _ArrayLikeObject_co = ..., + correction: int | float = ..., +) -> Any: ... +@overload +def var( + a: _ArrayLikeComplex_co | _ArrayLikeObject_co, + axis: None = ..., + dtype: _DTypeLike[_SCT] = ..., + out: None = ..., + ddof: int | float = ..., + keepdims: Literal[False] = ..., + *, + where: _ArrayLikeBool_co = ..., + mean: _ArrayLikeComplex_co | _ArrayLikeObject_co = ..., + correction: int | float = ..., +) -> _SCT: ... +@overload +def var( + a: _ArrayLikeComplex_co | _ArrayLikeObject_co, + axis: None | _ShapeLike = ..., + dtype: DTypeLike = ..., + out: None = ..., + ddof: int | float = ..., + keepdims: bool = ..., + *, + where: _ArrayLikeBool_co = ..., + mean: _ArrayLikeComplex_co | _ArrayLikeObject_co = ..., + correction: int | float = ..., +) -> Any: ... +@overload +def var( + a: _ArrayLikeComplex_co | _ArrayLikeObject_co, + axis: None | _ShapeLike = ..., + dtype: DTypeLike = ..., + out: _ArrayType = ..., + ddof: int | float = ..., + keepdims: bool = ..., + *, + where: _ArrayLikeBool_co = ..., + mean: _ArrayLikeComplex_co | _ArrayLikeObject_co = ..., + correction: int | float = ..., +) -> _ArrayType: ... + +max = amax +min = amin +round = around diff --git a/venv/lib/python3.12/site-packages/numpy/_core/function_base.py b/venv/lib/python3.12/site-packages/numpy/_core/function_base.py new file mode 100644 index 00000000..0e98196f --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/function_base.py @@ -0,0 +1,562 @@ +import functools +import warnings +import operator +import types + +import numpy as np +from . import numeric as _nx +from .numeric import result_type, nan, asanyarray, ndim +from numpy._core.multiarray import add_docstring +from numpy._core._multiarray_umath import _array_converter +from numpy._core import overrides + +__all__ = ['logspace', 'linspace', 'geomspace'] + + +array_function_dispatch = functools.partial( + overrides.array_function_dispatch, module='numpy') + + +def _linspace_dispatcher(start, stop, num=None, endpoint=None, retstep=None, + dtype=None, axis=None, *, device=None): + return (start, stop) + + +@array_function_dispatch(_linspace_dispatcher) +def linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None, + axis=0, *, device=None): + """ + Return evenly spaced numbers over a specified interval. + + Returns `num` evenly spaced samples, calculated over the + interval [`start`, `stop`]. + + The endpoint of the interval can optionally be excluded. + + .. versionchanged:: 1.16.0 + Non-scalar `start` and `stop` are now supported. + + .. versionchanged:: 1.20.0 + Values are rounded towards ``-inf`` instead of ``0`` when an + integer ``dtype`` is specified. The old behavior can + still be obtained with ``np.linspace(start, stop, num).astype(int)`` + + Parameters + ---------- + start : array_like + The starting value of the sequence. + stop : array_like + The end value of the sequence, unless `endpoint` is set to False. + In that case, the sequence consists of all but the last of ``num + 1`` + evenly spaced samples, so that `stop` is excluded. Note that the step + size changes when `endpoint` is False. + num : int, optional + Number of samples to generate. Default is 50. Must be non-negative. + endpoint : bool, optional + If True, `stop` is the last sample. Otherwise, it is not included. + Default is True. + retstep : bool, optional + If True, return (`samples`, `step`), where `step` is the spacing + between samples. + dtype : dtype, optional + The type of the output array. If `dtype` is not given, the data type + is inferred from `start` and `stop`. The inferred dtype will never be + an integer; `float` is chosen even if the arguments would produce an + array of integers. + + .. versionadded:: 1.9.0 + axis : int, optional + The axis in the result to store the samples. Relevant only if start + or stop are array-like. By default (0), the samples will be along a + new axis inserted at the beginning. Use -1 to get an axis at the end. + + .. versionadded:: 1.16.0 + device : str, optional + The device on which to place the created array. Default: None. + For Array-API interoperability only, so must be ``"cpu"`` if passed. + + .. versionadded:: 2.0.0 + + Returns + ------- + samples : ndarray + There are `num` equally spaced samples in the closed interval + ``[start, stop]`` or the half-open interval ``[start, stop)`` + (depending on whether `endpoint` is True or False). + step : float, optional + Only returned if `retstep` is True + + Size of spacing between samples. + + + See Also + -------- + arange : Similar to `linspace`, but uses a step size (instead of the + number of samples). + geomspace : Similar to `linspace`, but with numbers spaced evenly on a log + scale (a geometric progression). + logspace : Similar to `geomspace`, but with the end points specified as + logarithms. + :ref:`how-to-partition` + + Examples + -------- + >>> import numpy as np + >>> np.linspace(2.0, 3.0, num=5) + array([2. , 2.25, 2.5 , 2.75, 3. ]) + >>> np.linspace(2.0, 3.0, num=5, endpoint=False) + array([2. , 2.2, 2.4, 2.6, 2.8]) + >>> np.linspace(2.0, 3.0, num=5, retstep=True) + (array([2. , 2.25, 2.5 , 2.75, 3. ]), 0.25) + + Graphical illustration: + + >>> import matplotlib.pyplot as plt + >>> N = 8 + >>> y = np.zeros(N) + >>> x1 = np.linspace(0, 10, N, endpoint=True) + >>> x2 = np.linspace(0, 10, N, endpoint=False) + >>> plt.plot(x1, y, 'o') + [] + >>> plt.plot(x2, y + 0.5, 'o') + [] + >>> plt.ylim([-0.5, 1]) + (-0.5, 1) + >>> plt.show() + + """ + num = operator.index(num) + if num < 0: + raise ValueError( + "Number of samples, %s, must be non-negative." % num + ) + div = (num - 1) if endpoint else num + + conv = _array_converter(start, stop) + start, stop = conv.as_arrays() + dt = conv.result_type(ensure_inexact=True) + + if dtype is None: + dtype = dt + integer_dtype = False + else: + integer_dtype = _nx.issubdtype(dtype, _nx.integer) + + # Use `dtype=type(dt)` to enforce a floating point evaluation: + delta = np.subtract(stop, start, dtype=type(dt)) + y = _nx.arange( + 0, num, dtype=dt, device=device + ).reshape((-1,) + (1,) * ndim(delta)) + + # In-place multiplication y *= delta/div is faster, but prevents + # the multiplicant from overriding what class is produced, and thus + # prevents, e.g. use of Quantities, see gh-7142. Hence, we multiply + # in place only for standard scalar types. + if div > 0: + _mult_inplace = _nx.isscalar(delta) + step = delta / div + any_step_zero = ( + step == 0 if _mult_inplace else _nx.asanyarray(step == 0).any()) + if any_step_zero: + # Special handling for denormal numbers, gh-5437 + y /= div + if _mult_inplace: + y *= delta + else: + y = y * delta + else: + if _mult_inplace: + y *= step + else: + y = y * step + else: + # sequences with 0 items or 1 item with endpoint=True (i.e. div <= 0) + # have an undefined step + step = nan + # Multiply with delta to allow possible override of output class. + y = y * delta + + y += start + + if endpoint and num > 1: + y[-1, ...] = stop + + if axis != 0: + y = _nx.moveaxis(y, 0, axis) + + if integer_dtype: + _nx.floor(y, out=y) + + y = conv.wrap(y.astype(dtype, copy=False)) + if retstep: + return y, step + else: + return y + + +def _logspace_dispatcher(start, stop, num=None, endpoint=None, base=None, + dtype=None, axis=None): + return (start, stop, base) + + +@array_function_dispatch(_logspace_dispatcher) +def logspace(start, stop, num=50, endpoint=True, base=10.0, dtype=None, + axis=0): + """ + Return numbers spaced evenly on a log scale. + + In linear space, the sequence starts at ``base ** start`` + (`base` to the power of `start`) and ends with ``base ** stop`` + (see `endpoint` below). + + .. versionchanged:: 1.16.0 + Non-scalar `start` and `stop` are now supported. + + .. versionchanged:: 1.25.0 + Non-scalar 'base` is now supported + + Parameters + ---------- + start : array_like + ``base ** start`` is the starting value of the sequence. + stop : array_like + ``base ** stop`` is the final value of the sequence, unless `endpoint` + is False. In that case, ``num + 1`` values are spaced over the + interval in log-space, of which all but the last (a sequence of + length `num`) are returned. + num : integer, optional + Number of samples to generate. Default is 50. + endpoint : boolean, optional + If true, `stop` is the last sample. Otherwise, it is not included. + Default is True. + base : array_like, optional + The base of the log space. The step size between the elements in + ``ln(samples) / ln(base)`` (or ``log_base(samples)``) is uniform. + Default is 10.0. + dtype : dtype + The type of the output array. If `dtype` is not given, the data type + is inferred from `start` and `stop`. The inferred type will never be + an integer; `float` is chosen even if the arguments would produce an + array of integers. + axis : int, optional + The axis in the result to store the samples. Relevant only if start, + stop, or base are array-like. By default (0), the samples will be + along a new axis inserted at the beginning. Use -1 to get an axis at + the end. + + .. versionadded:: 1.16.0 + + + Returns + ------- + samples : ndarray + `num` samples, equally spaced on a log scale. + + See Also + -------- + arange : Similar to linspace, with the step size specified instead of the + number of samples. Note that, when used with a float endpoint, the + endpoint may or may not be included. + linspace : Similar to logspace, but with the samples uniformly distributed + in linear space, instead of log space. + geomspace : Similar to logspace, but with endpoints specified directly. + :ref:`how-to-partition` + + Notes + ----- + If base is a scalar, logspace is equivalent to the code + + >>> y = np.linspace(start, stop, num=num, endpoint=endpoint) + ... # doctest: +SKIP + >>> power(base, y).astype(dtype) + ... # doctest: +SKIP + + Examples + -------- + >>> import numpy as np + >>> np.logspace(2.0, 3.0, num=4) + array([ 100. , 215.443469 , 464.15888336, 1000. ]) + >>> np.logspace(2.0, 3.0, num=4, endpoint=False) + array([100. , 177.827941 , 316.22776602, 562.34132519]) + >>> np.logspace(2.0, 3.0, num=4, base=2.0) + array([4. , 5.0396842 , 6.34960421, 8. ]) + >>> np.logspace(2.0, 3.0, num=4, base=[2.0, 3.0], axis=-1) + array([[ 4. , 5.0396842 , 6.34960421, 8. ], + [ 9. , 12.98024613, 18.72075441, 27. ]]) + + Graphical illustration: + + >>> import matplotlib.pyplot as plt + >>> N = 10 + >>> x1 = np.logspace(0.1, 1, N, endpoint=True) + >>> x2 = np.logspace(0.1, 1, N, endpoint=False) + >>> y = np.zeros(N) + >>> plt.plot(x1, y, 'o') + [] + >>> plt.plot(x2, y + 0.5, 'o') + [] + >>> plt.ylim([-0.5, 1]) + (-0.5, 1) + >>> plt.show() + + """ + if not isinstance(base, (float, int)) and np.ndim(base): + # If base is non-scalar, broadcast it with the others, since it + # may influence how axis is interpreted. + ndmax = np.broadcast(start, stop, base).ndim + start, stop, base = ( + np.array(a, copy=None, subok=True, ndmin=ndmax) + for a in (start, stop, base) + ) + base = np.expand_dims(base, axis=axis) + y = linspace(start, stop, num=num, endpoint=endpoint, axis=axis) + if dtype is None: + return _nx.power(base, y) + return _nx.power(base, y).astype(dtype, copy=False) + + +def _geomspace_dispatcher(start, stop, num=None, endpoint=None, dtype=None, + axis=None): + return (start, stop) + + +@array_function_dispatch(_geomspace_dispatcher) +def geomspace(start, stop, num=50, endpoint=True, dtype=None, axis=0): + """ + Return numbers spaced evenly on a log scale (a geometric progression). + + This is similar to `logspace`, but with endpoints specified directly. + Each output sample is a constant multiple of the previous. + + .. versionchanged:: 1.16.0 + Non-scalar `start` and `stop` are now supported. + + Parameters + ---------- + start : array_like + The starting value of the sequence. + stop : array_like + The final value of the sequence, unless `endpoint` is False. + In that case, ``num + 1`` values are spaced over the + interval in log-space, of which all but the last (a sequence of + length `num`) are returned. + num : integer, optional + Number of samples to generate. Default is 50. + endpoint : boolean, optional + If true, `stop` is the last sample. Otherwise, it is not included. + Default is True. + dtype : dtype + The type of the output array. If `dtype` is not given, the data type + is inferred from `start` and `stop`. The inferred dtype will never be + an integer; `float` is chosen even if the arguments would produce an + array of integers. + axis : int, optional + The axis in the result to store the samples. Relevant only if start + or stop are array-like. By default (0), the samples will be along a + new axis inserted at the beginning. Use -1 to get an axis at the end. + + .. versionadded:: 1.16.0 + + Returns + ------- + samples : ndarray + `num` samples, equally spaced on a log scale. + + See Also + -------- + logspace : Similar to geomspace, but with endpoints specified using log + and base. + linspace : Similar to geomspace, but with arithmetic instead of geometric + progression. + arange : Similar to linspace, with the step size specified instead of the + number of samples. + :ref:`how-to-partition` + + Notes + ----- + If the inputs or dtype are complex, the output will follow a logarithmic + spiral in the complex plane. (There are an infinite number of spirals + passing through two points; the output will follow the shortest such path.) + + Examples + -------- + >>> import numpy as np + >>> np.geomspace(1, 1000, num=4) + array([ 1., 10., 100., 1000.]) + >>> np.geomspace(1, 1000, num=3, endpoint=False) + array([ 1., 10., 100.]) + >>> np.geomspace(1, 1000, num=4, endpoint=False) + array([ 1. , 5.62341325, 31.6227766 , 177.827941 ]) + >>> np.geomspace(1, 256, num=9) + array([ 1., 2., 4., 8., 16., 32., 64., 128., 256.]) + + Note that the above may not produce exact integers: + + >>> np.geomspace(1, 256, num=9, dtype=int) + array([ 1, 2, 4, 7, 16, 32, 63, 127, 256]) + >>> np.around(np.geomspace(1, 256, num=9)).astype(int) + array([ 1, 2, 4, 8, 16, 32, 64, 128, 256]) + + Negative, decreasing, and complex inputs are allowed: + + >>> np.geomspace(1000, 1, num=4) + array([1000., 100., 10., 1.]) + >>> np.geomspace(-1000, -1, num=4) + array([-1000., -100., -10., -1.]) + >>> np.geomspace(1j, 1000j, num=4) # Straight line + array([0. +1.j, 0. +10.j, 0. +100.j, 0.+1000.j]) + >>> np.geomspace(-1+0j, 1+0j, num=5) # Circle + array([-1.00000000e+00+1.22464680e-16j, -7.07106781e-01+7.07106781e-01j, + 6.12323400e-17+1.00000000e+00j, 7.07106781e-01+7.07106781e-01j, + 1.00000000e+00+0.00000000e+00j]) + + Graphical illustration of `endpoint` parameter: + + >>> import matplotlib.pyplot as plt + >>> N = 10 + >>> y = np.zeros(N) + >>> plt.semilogx(np.geomspace(1, 1000, N, endpoint=True), y + 1, 'o') + [] + >>> plt.semilogx(np.geomspace(1, 1000, N, endpoint=False), y + 2, 'o') + [] + >>> plt.axis([0.5, 2000, 0, 3]) + [0.5, 2000, 0, 3] + >>> plt.grid(True, color='0.7', linestyle='-', which='both', axis='both') + >>> plt.show() + + """ + start = asanyarray(start) + stop = asanyarray(stop) + if _nx.any(start == 0) or _nx.any(stop == 0): + raise ValueError('Geometric sequence cannot include zero') + + dt = result_type(start, stop, float(num), _nx.zeros((), dtype)) + if dtype is None: + dtype = dt + else: + # complex to dtype('complex128'), for instance + dtype = _nx.dtype(dtype) + + # Promote both arguments to the same dtype in case, for instance, one is + # complex and another is negative and log would produce NaN otherwise. + # Copy since we may change things in-place further down. + start = start.astype(dt, copy=True) + stop = stop.astype(dt, copy=True) + + # Allow negative real values and ensure a consistent result for complex + # (including avoiding negligible real or imaginary parts in output) by + # rotating start to positive real, calculating, then undoing rotation. + out_sign = _nx.sign(start) + start /= out_sign + stop = stop / out_sign + + log_start = _nx.log10(start) + log_stop = _nx.log10(stop) + result = logspace(log_start, log_stop, num=num, + endpoint=endpoint, base=10.0, dtype=dt) + + # Make sure the endpoints match the start and stop arguments. This is + # necessary because np.exp(np.log(x)) is not necessarily equal to x. + if num > 0: + result[0] = start + if num > 1 and endpoint: + result[-1] = stop + + result *= out_sign + + if axis != 0: + result = _nx.moveaxis(result, 0, axis) + + return result.astype(dtype, copy=False) + + +def _needs_add_docstring(obj): + """ + Returns true if the only way to set the docstring of `obj` from python is + via add_docstring. + + This function errs on the side of being overly conservative. + """ + Py_TPFLAGS_HEAPTYPE = 1 << 9 + + if isinstance(obj, (types.FunctionType, types.MethodType, property)): + return False + + if isinstance(obj, type) and obj.__flags__ & Py_TPFLAGS_HEAPTYPE: + return False + + return True + + +def _add_docstring(obj, doc, warn_on_python): + if warn_on_python and not _needs_add_docstring(obj): + warnings.warn( + "add_newdoc was used on a pure-python object {}. " + "Prefer to attach it directly to the source." + .format(obj), + UserWarning, + stacklevel=3) + try: + add_docstring(obj, doc) + except Exception: + pass + + +def add_newdoc(place, obj, doc, warn_on_python=True): + """ + Add documentation to an existing object, typically one defined in C + + The purpose is to allow easier editing of the docstrings without requiring + a re-compile. This exists primarily for internal use within numpy itself. + + Parameters + ---------- + place : str + The absolute name of the module to import from + obj : str or None + The name of the object to add documentation to, typically a class or + function name. + doc : {str, Tuple[str, str], List[Tuple[str, str]]} + If a string, the documentation to apply to `obj` + + If a tuple, then the first element is interpreted as an attribute + of `obj` and the second as the docstring to apply - + ``(method, docstring)`` + + If a list, then each element of the list should be a tuple of length + two - ``[(method1, docstring1), (method2, docstring2), ...]`` + warn_on_python : bool + If True, the default, emit `UserWarning` if this is used to attach + documentation to a pure-python object. + + Notes + ----- + This routine never raises an error if the docstring can't be written, but + will raise an error if the object being documented does not exist. + + This routine cannot modify read-only docstrings, as appear + in new-style classes or built-in functions. Because this + routine never raises an error the caller must check manually + that the docstrings were changed. + + Since this function grabs the ``char *`` from a c-level str object and puts + it into the ``tp_doc`` slot of the type of `obj`, it violates a number of + C-API best-practices, by: + + - modifying a `PyTypeObject` after calling `PyType_Ready` + - calling `Py_INCREF` on the str and losing the reference, so the str + will never be released + + If possible it should be avoided. + """ + new = getattr(__import__(place, globals(), {}, [obj]), obj) + if isinstance(doc, str): + _add_docstring(new, doc.strip(), warn_on_python) + elif isinstance(doc, tuple): + attr, docstring = doc + _add_docstring(getattr(new, attr), docstring.strip(), warn_on_python) + elif isinstance(doc, list): + for attr, docstring in doc: + _add_docstring( + getattr(new, attr), docstring.strip(), warn_on_python + ) diff --git a/venv/lib/python3.12/site-packages/numpy/_core/function_base.pyi b/venv/lib/python3.12/site-packages/numpy/_core/function_base.pyi new file mode 100644 index 00000000..59c3d6b4 --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/function_base.pyi @@ -0,0 +1,202 @@ +from typing import ( + Literal as L, + overload, + Any, + SupportsIndex, + TypeVar, +) + +from numpy import floating, complexfloating, generic +from numpy._typing import ( + NDArray, + DTypeLike, + _DTypeLike, + _ArrayLikeFloat_co, + _ArrayLikeComplex_co, +) + +_SCT = TypeVar("_SCT", bound=generic) + +__all__: list[str] + +@overload +def linspace( + start: _ArrayLikeFloat_co, + stop: _ArrayLikeFloat_co, + num: SupportsIndex = ..., + endpoint: bool = ..., + retstep: L[False] = ..., + dtype: None = ..., + axis: SupportsIndex = ..., + *, + device: None | L["cpu"] = ..., +) -> NDArray[floating[Any]]: ... +@overload +def linspace( + start: _ArrayLikeComplex_co, + stop: _ArrayLikeComplex_co, + num: SupportsIndex = ..., + endpoint: bool = ..., + retstep: L[False] = ..., + dtype: None = ..., + axis: SupportsIndex = ..., + *, + device: None | L["cpu"] = ..., +) -> NDArray[complexfloating[Any, Any]]: ... +@overload +def linspace( + start: _ArrayLikeComplex_co, + stop: _ArrayLikeComplex_co, + num: SupportsIndex = ..., + endpoint: bool = ..., + retstep: L[False] = ..., + dtype: _DTypeLike[_SCT] = ..., + axis: SupportsIndex = ..., + *, + device: None | L["cpu"] = ..., +) -> NDArray[_SCT]: ... +@overload +def linspace( + start: _ArrayLikeComplex_co, + stop: _ArrayLikeComplex_co, + num: SupportsIndex = ..., + endpoint: bool = ..., + retstep: L[False] = ..., + dtype: DTypeLike = ..., + axis: SupportsIndex = ..., + *, + device: None | L["cpu"] = ..., +) -> NDArray[Any]: ... +@overload +def linspace( + start: _ArrayLikeFloat_co, + stop: _ArrayLikeFloat_co, + num: SupportsIndex = ..., + endpoint: bool = ..., + retstep: L[True] = ..., + dtype: None = ..., + axis: SupportsIndex = ..., + *, + device: None | L["cpu"] = ..., +) -> tuple[NDArray[floating[Any]], floating[Any]]: ... +@overload +def linspace( + start: _ArrayLikeComplex_co, + stop: _ArrayLikeComplex_co, + num: SupportsIndex = ..., + endpoint: bool = ..., + retstep: L[True] = ..., + dtype: None = ..., + axis: SupportsIndex = ..., + *, + device: None | L["cpu"] = ..., +) -> tuple[NDArray[complexfloating[Any, Any]], complexfloating[Any, Any]]: ... +@overload +def linspace( + start: _ArrayLikeComplex_co, + stop: _ArrayLikeComplex_co, + num: SupportsIndex = ..., + endpoint: bool = ..., + retstep: L[True] = ..., + dtype: _DTypeLike[_SCT] = ..., + axis: SupportsIndex = ..., + *, + device: None | L["cpu"] = ..., +) -> tuple[NDArray[_SCT], _SCT]: ... +@overload +def linspace( + start: _ArrayLikeComplex_co, + stop: _ArrayLikeComplex_co, + num: SupportsIndex = ..., + endpoint: bool = ..., + retstep: L[True] = ..., + dtype: DTypeLike = ..., + axis: SupportsIndex = ..., + *, + device: None | L["cpu"] = ..., +) -> tuple[NDArray[Any], Any]: ... + +@overload +def logspace( + start: _ArrayLikeFloat_co, + stop: _ArrayLikeFloat_co, + num: SupportsIndex = ..., + endpoint: bool = ..., + base: _ArrayLikeFloat_co = ..., + dtype: None = ..., + axis: SupportsIndex = ..., +) -> NDArray[floating[Any]]: ... +@overload +def logspace( + start: _ArrayLikeComplex_co, + stop: _ArrayLikeComplex_co, + num: SupportsIndex = ..., + endpoint: bool = ..., + base: _ArrayLikeComplex_co = ..., + dtype: None = ..., + axis: SupportsIndex = ..., +) -> NDArray[complexfloating[Any, Any]]: ... +@overload +def logspace( + start: _ArrayLikeComplex_co, + stop: _ArrayLikeComplex_co, + num: SupportsIndex = ..., + endpoint: bool = ..., + base: _ArrayLikeComplex_co = ..., + dtype: _DTypeLike[_SCT] = ..., + axis: SupportsIndex = ..., +) -> NDArray[_SCT]: ... +@overload +def logspace( + start: _ArrayLikeComplex_co, + stop: _ArrayLikeComplex_co, + num: SupportsIndex = ..., + endpoint: bool = ..., + base: _ArrayLikeComplex_co = ..., + dtype: DTypeLike = ..., + axis: SupportsIndex = ..., +) -> NDArray[Any]: ... + +@overload +def geomspace( + start: _ArrayLikeFloat_co, + stop: _ArrayLikeFloat_co, + num: SupportsIndex = ..., + endpoint: bool = ..., + dtype: None = ..., + axis: SupportsIndex = ..., +) -> NDArray[floating[Any]]: ... +@overload +def geomspace( + start: _ArrayLikeComplex_co, + stop: _ArrayLikeComplex_co, + num: SupportsIndex = ..., + endpoint: bool = ..., + dtype: None = ..., + axis: SupportsIndex = ..., +) -> NDArray[complexfloating[Any, Any]]: ... +@overload +def geomspace( + start: _ArrayLikeComplex_co, + stop: _ArrayLikeComplex_co, + num: SupportsIndex = ..., + endpoint: bool = ..., + dtype: _DTypeLike[_SCT] = ..., + axis: SupportsIndex = ..., +) -> NDArray[_SCT]: ... +@overload +def geomspace( + start: _ArrayLikeComplex_co, + stop: _ArrayLikeComplex_co, + num: SupportsIndex = ..., + endpoint: bool = ..., + dtype: DTypeLike = ..., + axis: SupportsIndex = ..., +) -> NDArray[Any]: ... + +def add_newdoc( + place: str, + obj: str, + doc: str | tuple[str, str] | list[tuple[str, str]], + warn_on_python: bool = ..., +) -> None: ... diff --git a/venv/lib/python3.12/site-packages/numpy/_core/getlimits.py b/venv/lib/python3.12/site-packages/numpy/_core/getlimits.py new file mode 100644 index 00000000..669dfc71 --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/getlimits.py @@ -0,0 +1,742 @@ +"""Machine limits for Float32 and Float64 and (long double) if available... + +""" +__all__ = ['finfo', 'iinfo'] + +import warnings + +from .._utils import set_module +from ._machar import MachAr +from . import numeric +from . import numerictypes as ntypes +from .numeric import array, inf, nan +from .umath import log10, exp2, nextafter, isnan + + +def _fr0(a): + """fix rank-0 --> rank-1""" + if a.ndim == 0: + a = a.copy() + a.shape = (1,) + return a + + +def _fr1(a): + """fix rank > 0 --> rank-0""" + if a.size == 1: + a = a.copy() + a.shape = () + return a + + +class MachArLike: + """ Object to simulate MachAr instance """ + def __init__(self, ftype, *, eps, epsneg, huge, tiny, + ibeta, smallest_subnormal=None, **kwargs): + self.params = _MACHAR_PARAMS[ftype] + self.ftype = ftype + self.title = self.params['title'] + # Parameter types same as for discovered MachAr object. + if not smallest_subnormal: + self._smallest_subnormal = nextafter( + self.ftype(0), self.ftype(1), dtype=self.ftype) + else: + self._smallest_subnormal = smallest_subnormal + self.epsilon = self.eps = self._float_to_float(eps) + self.epsneg = self._float_to_float(epsneg) + self.xmax = self.huge = self._float_to_float(huge) + self.xmin = self._float_to_float(tiny) + self.smallest_normal = self.tiny = self._float_to_float(tiny) + self.ibeta = self.params['itype'](ibeta) + self.__dict__.update(kwargs) + self.precision = int(-log10(self.eps)) + self.resolution = self._float_to_float( + self._float_conv(10) ** (-self.precision)) + self._str_eps = self._float_to_str(self.eps) + self._str_epsneg = self._float_to_str(self.epsneg) + self._str_xmin = self._float_to_str(self.xmin) + self._str_xmax = self._float_to_str(self.xmax) + self._str_resolution = self._float_to_str(self.resolution) + self._str_smallest_normal = self._float_to_str(self.xmin) + + @property + def smallest_subnormal(self): + """Return the value for the smallest subnormal. + + Returns + ------- + smallest_subnormal : float + value for the smallest subnormal. + + Warns + ----- + UserWarning + If the calculated value for the smallest subnormal is zero. + """ + # Check that the calculated value is not zero, in case it raises a + # warning. + value = self._smallest_subnormal + if self.ftype(0) == value: + warnings.warn( + 'The value of the smallest subnormal for {} type ' + 'is zero.'.format(self.ftype), UserWarning, stacklevel=2) + + return self._float_to_float(value) + + @property + def _str_smallest_subnormal(self): + """Return the string representation of the smallest subnormal.""" + return self._float_to_str(self.smallest_subnormal) + + def _float_to_float(self, value): + """Converts float to float. + + Parameters + ---------- + value : float + value to be converted. + """ + return _fr1(self._float_conv(value)) + + def _float_conv(self, value): + """Converts float to conv. + + Parameters + ---------- + value : float + value to be converted. + """ + return array([value], self.ftype) + + def _float_to_str(self, value): + """Converts float to str. + + Parameters + ---------- + value : float + value to be converted. + """ + return self.params['fmt'] % array(_fr0(value)[0], self.ftype) + + +_convert_to_float = { + ntypes.csingle: ntypes.single, + ntypes.complex128: ntypes.float64, + ntypes.clongdouble: ntypes.longdouble + } + +# Parameters for creating MachAr / MachAr-like objects +_title_fmt = 'numpy {} precision floating point number' +_MACHAR_PARAMS = { + ntypes.double: dict( + itype = ntypes.int64, + fmt = '%24.16e', + title = _title_fmt.format('double')), + ntypes.single: dict( + itype = ntypes.int32, + fmt = '%15.7e', + title = _title_fmt.format('single')), + ntypes.longdouble: dict( + itype = ntypes.longlong, + fmt = '%s', + title = _title_fmt.format('long double')), + ntypes.half: dict( + itype = ntypes.int16, + fmt = '%12.5e', + title = _title_fmt.format('half'))} + +# Key to identify the floating point type. Key is result of +# +# ftype = np.longdouble # or float64, float32, etc. +# v = (ftype(-1.0) / ftype(10.0)) +# v.view(v.dtype.newbyteorder('<')).tobytes() +# +# Uses division to work around deficiencies in strtold on some platforms. +# See: +# https://perl5.git.perl.org/perl.git/blob/3118d7d684b56cbeb702af874f4326683c45f045:/Configure + +_KNOWN_TYPES = {} +def _register_type(machar, bytepat): + _KNOWN_TYPES[bytepat] = machar + + +_float_ma = {} + + +def _register_known_types(): + # Known parameters for float16 + # See docstring of MachAr class for description of parameters. + f16 = ntypes.float16 + float16_ma = MachArLike(f16, + machep=-10, + negep=-11, + minexp=-14, + maxexp=16, + it=10, + iexp=5, + ibeta=2, + irnd=5, + ngrd=0, + eps=exp2(f16(-10)), + epsneg=exp2(f16(-11)), + huge=f16(65504), + tiny=f16(2 ** -14)) + _register_type(float16_ma, b'f\xae') + _float_ma[16] = float16_ma + + # Known parameters for float32 + f32 = ntypes.float32 + float32_ma = MachArLike(f32, + machep=-23, + negep=-24, + minexp=-126, + maxexp=128, + it=23, + iexp=8, + ibeta=2, + irnd=5, + ngrd=0, + eps=exp2(f32(-23)), + epsneg=exp2(f32(-24)), + huge=f32((1 - 2 ** -24) * 2**128), + tiny=exp2(f32(-126))) + _register_type(float32_ma, b'\xcd\xcc\xcc\xbd') + _float_ma[32] = float32_ma + + # Known parameters for float64 + f64 = ntypes.float64 + epsneg_f64 = 2.0 ** -53.0 + tiny_f64 = 2.0 ** -1022.0 + float64_ma = MachArLike(f64, + machep=-52, + negep=-53, + minexp=-1022, + maxexp=1024, + it=52, + iexp=11, + ibeta=2, + irnd=5, + ngrd=0, + eps=2.0 ** -52.0, + epsneg=epsneg_f64, + huge=(1.0 - epsneg_f64) / tiny_f64 * f64(4), + tiny=tiny_f64) + _register_type(float64_ma, b'\x9a\x99\x99\x99\x99\x99\xb9\xbf') + _float_ma[64] = float64_ma + + # Known parameters for IEEE 754 128-bit binary float + ld = ntypes.longdouble + epsneg_f128 = exp2(ld(-113)) + tiny_f128 = exp2(ld(-16382)) + # Ignore runtime error when this is not f128 + with numeric.errstate(all='ignore'): + huge_f128 = (ld(1) - epsneg_f128) / tiny_f128 * ld(4) + float128_ma = MachArLike(ld, + machep=-112, + negep=-113, + minexp=-16382, + maxexp=16384, + it=112, + iexp=15, + ibeta=2, + irnd=5, + ngrd=0, + eps=exp2(ld(-112)), + epsneg=epsneg_f128, + huge=huge_f128, + tiny=tiny_f128) + # IEEE 754 128-bit binary float + _register_type(float128_ma, + b'\x9a\x99\x99\x99\x99\x99\x99\x99\x99\x99\x99\x99\x99\x99\xfb\xbf') + _float_ma[128] = float128_ma + + # Known parameters for float80 (Intel 80-bit extended precision) + epsneg_f80 = exp2(ld(-64)) + tiny_f80 = exp2(ld(-16382)) + # Ignore runtime error when this is not f80 + with numeric.errstate(all='ignore'): + huge_f80 = (ld(1) - epsneg_f80) / tiny_f80 * ld(4) + float80_ma = MachArLike(ld, + machep=-63, + negep=-64, + minexp=-16382, + maxexp=16384, + it=63, + iexp=15, + ibeta=2, + irnd=5, + ngrd=0, + eps=exp2(ld(-63)), + epsneg=epsneg_f80, + huge=huge_f80, + tiny=tiny_f80) + # float80, first 10 bytes containing actual storage + _register_type(float80_ma, b'\xcd\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xfb\xbf') + _float_ma[80] = float80_ma + + # Guessed / known parameters for double double; see: + # https://en.wikipedia.org/wiki/Quadruple-precision_floating-point_format#Double-double_arithmetic + # These numbers have the same exponent range as float64, but extended + # number of digits in the significand. + huge_dd = nextafter(ld(inf), ld(0), dtype=ld) + # As the smallest_normal in double double is so hard to calculate we set + # it to NaN. + smallest_normal_dd = nan + # Leave the same value for the smallest subnormal as double + smallest_subnormal_dd = ld(nextafter(0., 1.)) + float_dd_ma = MachArLike(ld, + machep=-105, + negep=-106, + minexp=-1022, + maxexp=1024, + it=105, + iexp=11, + ibeta=2, + irnd=5, + ngrd=0, + eps=exp2(ld(-105)), + epsneg=exp2(ld(-106)), + huge=huge_dd, + tiny=smallest_normal_dd, + smallest_subnormal=smallest_subnormal_dd) + # double double; low, high order (e.g. PPC 64) + _register_type(float_dd_ma, + b'\x9a\x99\x99\x99\x99\x99Y<\x9a\x99\x99\x99\x99\x99\xb9\xbf') + # double double; high, low order (e.g. PPC 64 le) + _register_type(float_dd_ma, + b'\x9a\x99\x99\x99\x99\x99\xb9\xbf\x9a\x99\x99\x99\x99\x99Y<') + _float_ma['dd'] = float_dd_ma + + +def _get_machar(ftype): + """ Get MachAr instance or MachAr-like instance + + Get parameters for floating point type, by first trying signatures of + various known floating point types, then, if none match, attempting to + identify parameters by analysis. + + Parameters + ---------- + ftype : class + Numpy floating point type class (e.g. ``np.float64``) + + Returns + ------- + ma_like : instance of :class:`MachAr` or :class:`MachArLike` + Object giving floating point parameters for `ftype`. + + Warns + ----- + UserWarning + If the binary signature of the float type is not in the dictionary of + known float types. + """ + params = _MACHAR_PARAMS.get(ftype) + if params is None: + raise ValueError(repr(ftype)) + # Detect known / suspected types + # ftype(-1.0) / ftype(10.0) is better than ftype('-0.1') because stold + # may be deficient + key = (ftype(-1.0) / ftype(10.)) + key = key.view(key.dtype.newbyteorder("<")).tobytes() + ma_like = None + if ftype == ntypes.longdouble: + # Could be 80 bit == 10 byte extended precision, where last bytes can + # be random garbage. + # Comparing first 10 bytes to pattern first to avoid branching on the + # random garbage. + ma_like = _KNOWN_TYPES.get(key[:10]) + if ma_like is None: + # see if the full key is known. + ma_like = _KNOWN_TYPES.get(key) + if ma_like is None and len(key) == 16: + # machine limits could be f80 masquerading as np.float128, + # find all keys with length 16 and make new dict, but make the keys + # only 10 bytes long, the last bytes can be random garbage + _kt = {k[:10]: v for k, v in _KNOWN_TYPES.items() if len(k) == 16} + ma_like = _kt.get(key[:10]) + if ma_like is not None: + return ma_like + # Fall back to parameter discovery + warnings.warn( + f'Signature {key} for {ftype} does not match any known type: ' + 'falling back to type probe function.\n' + 'This warnings indicates broken support for the dtype!', + UserWarning, stacklevel=2) + return _discovered_machar(ftype) + + +def _discovered_machar(ftype): + """ Create MachAr instance with found information on float types + + TODO: MachAr should be retired completely ideally. We currently only + ever use it system with broken longdouble (valgrind, WSL). + """ + params = _MACHAR_PARAMS[ftype] + return MachAr(lambda v: array([v], ftype), + lambda v: _fr0(v.astype(params['itype']))[0], + lambda v: array(_fr0(v)[0], ftype), + lambda v: params['fmt'] % array(_fr0(v)[0], ftype), + params['title']) + + +@set_module('numpy') +class finfo: + """ + finfo(dtype) + + Machine limits for floating point types. + + Attributes + ---------- + bits : int + The number of bits occupied by the type. + dtype : dtype + Returns the dtype for which `finfo` returns information. For complex + input, the returned dtype is the associated ``float*`` dtype for its + real and complex components. + eps : float + The difference between 1.0 and the next smallest representable float + larger than 1.0. For example, for 64-bit binary floats in the IEEE-754 + standard, ``eps = 2**-52``, approximately 2.22e-16. + epsneg : float + The difference between 1.0 and the next smallest representable float + less than 1.0. For example, for 64-bit binary floats in the IEEE-754 + standard, ``epsneg = 2**-53``, approximately 1.11e-16. + iexp : int + The number of bits in the exponent portion of the floating point + representation. + machep : int + The exponent that yields `eps`. + max : floating point number of the appropriate type + The largest representable number. + maxexp : int + The smallest positive power of the base (2) that causes overflow. + min : floating point number of the appropriate type + The smallest representable number, typically ``-max``. + minexp : int + The most negative power of the base (2) consistent with there + being no leading 0's in the mantissa. + negep : int + The exponent that yields `epsneg`. + nexp : int + The number of bits in the exponent including its sign and bias. + nmant : int + The number of bits in the mantissa. + precision : int + The approximate number of decimal digits to which this kind of + float is precise. + resolution : floating point number of the appropriate type + The approximate decimal resolution of this type, i.e., + ``10**-precision``. + tiny : float + An alias for `smallest_normal`, kept for backwards compatibility. + smallest_normal : float + The smallest positive floating point number with 1 as leading bit in + the mantissa following IEEE-754 (see Notes). + smallest_subnormal : float + The smallest positive floating point number with 0 as leading bit in + the mantissa following IEEE-754. + + Parameters + ---------- + dtype : float, dtype, or instance + Kind of floating point or complex floating point + data-type about which to get information. + + See Also + -------- + iinfo : The equivalent for integer data types. + spacing : The distance between a value and the nearest adjacent number + nextafter : The next floating point value after x1 towards x2 + + Notes + ----- + For developers of NumPy: do not instantiate this at the module level. + The initial calculation of these parameters is expensive and negatively + impacts import times. These objects are cached, so calling ``finfo()`` + repeatedly inside your functions is not a problem. + + Note that ``smallest_normal`` is not actually the smallest positive + representable value in a NumPy floating point type. As in the IEEE-754 + standard [1]_, NumPy floating point types make use of subnormal numbers to + fill the gap between 0 and ``smallest_normal``. However, subnormal numbers + may have significantly reduced precision [2]_. + + This function can also be used for complex data types as well. If used, + the output will be the same as the corresponding real float type + (e.g. numpy.finfo(numpy.csingle) is the same as numpy.finfo(numpy.single)). + However, the output is true for the real and imaginary components. + + References + ---------- + .. [1] IEEE Standard for Floating-Point Arithmetic, IEEE Std 754-2008, + pp.1-70, 2008, https://doi.org/10.1109/IEEESTD.2008.4610935 + .. [2] Wikipedia, "Denormal Numbers", + https://en.wikipedia.org/wiki/Denormal_number + + Examples + -------- + >>> import numpy as np + >>> np.finfo(np.float64).dtype + dtype('float64') + >>> np.finfo(np.complex64).dtype + dtype('float32') + + """ + + _finfo_cache = {} + + def __new__(cls, dtype): + try: + obj = cls._finfo_cache.get(dtype) # most common path + if obj is not None: + return obj + except TypeError: + pass + + if dtype is None: + # Deprecated in NumPy 1.25, 2023-01-16 + warnings.warn( + "finfo() dtype cannot be None. This behavior will " + "raise an error in the future. (Deprecated in NumPy 1.25)", + DeprecationWarning, + stacklevel=2 + ) + + try: + dtype = numeric.dtype(dtype) + except TypeError: + # In case a float instance was given + dtype = numeric.dtype(type(dtype)) + + obj = cls._finfo_cache.get(dtype) + if obj is not None: + return obj + dtypes = [dtype] + newdtype = ntypes.obj2sctype(dtype) + if newdtype is not dtype: + dtypes.append(newdtype) + dtype = newdtype + if not issubclass(dtype, numeric.inexact): + raise ValueError("data type %r not inexact" % (dtype)) + obj = cls._finfo_cache.get(dtype) + if obj is not None: + return obj + if not issubclass(dtype, numeric.floating): + newdtype = _convert_to_float[dtype] + if newdtype is not dtype: + # dtype changed, for example from complex128 to float64 + dtypes.append(newdtype) + dtype = newdtype + + obj = cls._finfo_cache.get(dtype, None) + if obj is not None: + # the original dtype was not in the cache, but the new + # dtype is in the cache. we add the original dtypes to + # the cache and return the result + for dt in dtypes: + cls._finfo_cache[dt] = obj + return obj + obj = object.__new__(cls)._init(dtype) + for dt in dtypes: + cls._finfo_cache[dt] = obj + return obj + + def _init(self, dtype): + self.dtype = numeric.dtype(dtype) + machar = _get_machar(dtype) + + for word in ['precision', 'iexp', + 'maxexp', 'minexp', 'negep', + 'machep']: + setattr(self, word, getattr(machar, word)) + for word in ['resolution', 'epsneg', 'smallest_subnormal']: + setattr(self, word, getattr(machar, word).flat[0]) + self.bits = self.dtype.itemsize * 8 + self.max = machar.huge.flat[0] + self.min = -self.max + self.eps = machar.eps.flat[0] + self.nexp = machar.iexp + self.nmant = machar.it + self._machar = machar + self._str_tiny = machar._str_xmin.strip() + self._str_max = machar._str_xmax.strip() + self._str_epsneg = machar._str_epsneg.strip() + self._str_eps = machar._str_eps.strip() + self._str_resolution = machar._str_resolution.strip() + self._str_smallest_normal = machar._str_smallest_normal.strip() + self._str_smallest_subnormal = machar._str_smallest_subnormal.strip() + return self + + def __str__(self): + fmt = ( + 'Machine parameters for %(dtype)s\n' + '---------------------------------------------------------------\n' + 'precision = %(precision)3s resolution = %(_str_resolution)s\n' + 'machep = %(machep)6s eps = %(_str_eps)s\n' + 'negep = %(negep)6s epsneg = %(_str_epsneg)s\n' + 'minexp = %(minexp)6s tiny = %(_str_tiny)s\n' + 'maxexp = %(maxexp)6s max = %(_str_max)s\n' + 'nexp = %(nexp)6s min = -max\n' + 'smallest_normal = %(_str_smallest_normal)s ' + 'smallest_subnormal = %(_str_smallest_subnormal)s\n' + '---------------------------------------------------------------\n' + ) + return fmt % self.__dict__ + + def __repr__(self): + c = self.__class__.__name__ + d = self.__dict__.copy() + d['klass'] = c + return (("%(klass)s(resolution=%(resolution)s, min=-%(_str_max)s," + " max=%(_str_max)s, dtype=%(dtype)s)") % d) + + @property + def smallest_normal(self): + """Return the value for the smallest normal. + + Returns + ------- + smallest_normal : float + Value for the smallest normal. + + Warns + ----- + UserWarning + If the calculated value for the smallest normal is requested for + double-double. + """ + # This check is necessary because the value for smallest_normal is + # platform dependent for longdouble types. + if isnan(self._machar.smallest_normal.flat[0]): + warnings.warn( + 'The value of smallest normal is undefined for double double', + UserWarning, stacklevel=2) + return self._machar.smallest_normal.flat[0] + + @property + def tiny(self): + """Return the value for tiny, alias of smallest_normal. + + Returns + ------- + tiny : float + Value for the smallest normal, alias of smallest_normal. + + Warns + ----- + UserWarning + If the calculated value for the smallest normal is requested for + double-double. + """ + return self.smallest_normal + + +@set_module('numpy') +class iinfo: + """ + iinfo(type) + + Machine limits for integer types. + + Attributes + ---------- + bits : int + The number of bits occupied by the type. + dtype : dtype + Returns the dtype for which `iinfo` returns information. + min : int + The smallest integer expressible by the type. + max : int + The largest integer expressible by the type. + + Parameters + ---------- + int_type : integer type, dtype, or instance + The kind of integer data type to get information about. + + See Also + -------- + finfo : The equivalent for floating point data types. + + Examples + -------- + With types: + + >>> import numpy as np + >>> ii16 = np.iinfo(np.int16) + >>> ii16.min + -32768 + >>> ii16.max + 32767 + >>> ii32 = np.iinfo(np.int32) + >>> ii32.min + -2147483648 + >>> ii32.max + 2147483647 + + With instances: + + >>> ii32 = np.iinfo(np.int32(10)) + >>> ii32.min + -2147483648 + >>> ii32.max + 2147483647 + + """ + + _min_vals = {} + _max_vals = {} + + def __init__(self, int_type): + try: + self.dtype = numeric.dtype(int_type) + except TypeError: + self.dtype = numeric.dtype(type(int_type)) + self.kind = self.dtype.kind + self.bits = self.dtype.itemsize * 8 + self.key = "%s%d" % (self.kind, self.bits) + if self.kind not in 'iu': + raise ValueError("Invalid integer data type %r." % (self.kind,)) + + @property + def min(self): + """Minimum value of given dtype.""" + if self.kind == 'u': + return 0 + else: + try: + val = iinfo._min_vals[self.key] + except KeyError: + val = int(-(1 << (self.bits-1))) + iinfo._min_vals[self.key] = val + return val + + @property + def max(self): + """Maximum value of given dtype.""" + try: + val = iinfo._max_vals[self.key] + except KeyError: + if self.kind == 'u': + val = int((1 << self.bits) - 1) + else: + val = int((1 << (self.bits-1)) - 1) + iinfo._max_vals[self.key] = val + return val + + def __str__(self): + """String representation.""" + fmt = ( + 'Machine parameters for %(dtype)s\n' + '---------------------------------------------------------------\n' + 'min = %(min)s\n' + 'max = %(max)s\n' + '---------------------------------------------------------------\n' + ) + return fmt % {'dtype': self.dtype, 'min': self.min, 'max': self.max} + + def __repr__(self): + return "%s(min=%s, max=%s, dtype=%s)" % (self.__class__.__name__, + self.min, self.max, self.dtype) diff --git a/venv/lib/python3.12/site-packages/numpy/_core/getlimits.pyi b/venv/lib/python3.12/site-packages/numpy/_core/getlimits.pyi new file mode 100644 index 00000000..da5e3c23 --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/getlimits.pyi @@ -0,0 +1,6 @@ +from numpy import ( + finfo as finfo, + iinfo as iinfo, +) + +__all__: list[str] diff --git a/venv/lib/python3.12/site-packages/numpy/_core/include/numpy/__multiarray_api.c b/venv/lib/python3.12/site-packages/numpy/_core/include/numpy/__multiarray_api.c new file mode 100644 index 00000000..c1a15270 --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/include/numpy/__multiarray_api.c @@ -0,0 +1,376 @@ + +/* These pointers will be stored in the C-object for use in other + extension modules +*/ + +void *PyArray_API[] = { + (void *) PyArray_GetNDArrayCVersion, + NULL, + (void *) &PyArray_Type, + (void *) &PyArrayDescr_Type, + NULL, + (void *) &PyArrayIter_Type, + (void *) &PyArrayMultiIter_Type, + (int *) &NPY_NUMUSERTYPES, + (void *) &PyBoolArrType_Type, + (void *) &_PyArrayScalar_BoolValues, + (void *) &PyGenericArrType_Type, + (void *) &PyNumberArrType_Type, + (void *) &PyIntegerArrType_Type, + (void *) &PySignedIntegerArrType_Type, + (void *) &PyUnsignedIntegerArrType_Type, + (void *) &PyInexactArrType_Type, + (void *) &PyFloatingArrType_Type, + (void *) &PyComplexFloatingArrType_Type, + (void *) &PyFlexibleArrType_Type, + (void *) &PyCharacterArrType_Type, + (void *) &PyByteArrType_Type, + (void *) &PyShortArrType_Type, + (void *) &PyIntArrType_Type, + (void *) &PyLongArrType_Type, + (void *) &PyLongLongArrType_Type, + (void *) &PyUByteArrType_Type, + (void *) &PyUShortArrType_Type, + (void *) &PyUIntArrType_Type, + (void *) &PyULongArrType_Type, + (void *) &PyULongLongArrType_Type, + (void *) &PyFloatArrType_Type, + (void *) &PyDoubleArrType_Type, + (void *) &PyLongDoubleArrType_Type, + (void *) &PyCFloatArrType_Type, + (void *) &PyCDoubleArrType_Type, + (void *) &PyCLongDoubleArrType_Type, + (void *) &PyObjectArrType_Type, + (void *) &PyStringArrType_Type, + (void *) &PyUnicodeArrType_Type, + (void *) &PyVoidArrType_Type, + NULL, + NULL, + (void *) PyArray_INCREF, + (void *) PyArray_XDECREF, + (void *) PyArray_SetStringFunction, + (void *) PyArray_DescrFromType, + (void *) PyArray_TypeObjectFromType, + (void *) PyArray_Zero, + (void *) PyArray_One, + (void *) PyArray_CastToType, + (void *) PyArray_CopyInto, + (void *) PyArray_CopyAnyInto, + (void *) PyArray_CanCastSafely, + (void *) PyArray_CanCastTo, + (void *) PyArray_ObjectType, + (void *) PyArray_DescrFromObject, + (void *) PyArray_ConvertToCommonType, + (void *) PyArray_DescrFromScalar, + (void *) PyArray_DescrFromTypeObject, + (void *) PyArray_Size, + (void *) PyArray_Scalar, + (void *) PyArray_FromScalar, + (void *) PyArray_ScalarAsCtype, + (void *) PyArray_CastScalarToCtype, + (void *) PyArray_CastScalarDirect, + (void *) PyArray_Pack, + NULL, + NULL, + NULL, + (void *) PyArray_FromAny, + (void *) PyArray_EnsureArray, + (void *) PyArray_EnsureAnyArray, + (void *) PyArray_FromFile, + (void *) PyArray_FromString, + (void *) PyArray_FromBuffer, + (void *) PyArray_FromIter, + (void *) PyArray_Return, + (void *) PyArray_GetField, + (void *) PyArray_SetField, + (void *) PyArray_Byteswap, + (void *) PyArray_Resize, + NULL, + NULL, + NULL, + (void *) PyArray_CopyObject, + (void *) PyArray_NewCopy, + (void *) PyArray_ToList, + (void *) PyArray_ToString, + (void *) PyArray_ToFile, + (void *) PyArray_Dump, + (void *) PyArray_Dumps, + (void *) PyArray_ValidType, + (void *) PyArray_UpdateFlags, + (void *) PyArray_New, + (void *) PyArray_NewFromDescr, + (void *) PyArray_DescrNew, + (void *) PyArray_DescrNewFromType, + (void *) PyArray_GetPriority, + (void *) PyArray_IterNew, + (void *) PyArray_MultiIterNew, + (void *) PyArray_PyIntAsInt, + (void *) PyArray_PyIntAsIntp, + (void *) PyArray_Broadcast, + NULL, + (void *) PyArray_FillWithScalar, + (void *) PyArray_CheckStrides, + (void *) PyArray_DescrNewByteorder, + (void *) PyArray_IterAllButAxis, + (void *) PyArray_CheckFromAny, + (void *) PyArray_FromArray, + (void *) PyArray_FromInterface, + (void *) PyArray_FromStructInterface, + (void *) PyArray_FromArrayAttr, + (void *) PyArray_ScalarKind, + (void *) PyArray_CanCoerceScalar, + NULL, + (void *) PyArray_CanCastScalar, + NULL, + (void *) PyArray_RemoveSmallest, + (void *) PyArray_ElementStrides, + (void *) PyArray_Item_INCREF, + (void *) PyArray_Item_XDECREF, + NULL, + (void *) PyArray_Transpose, + (void *) PyArray_TakeFrom, + (void *) PyArray_PutTo, + (void *) PyArray_PutMask, + (void *) PyArray_Repeat, + (void *) PyArray_Choose, + (void *) PyArray_Sort, + (void *) PyArray_ArgSort, + (void *) PyArray_SearchSorted, + (void *) PyArray_ArgMax, + (void *) PyArray_ArgMin, + (void *) PyArray_Reshape, + (void *) PyArray_Newshape, + (void *) PyArray_Squeeze, + (void *) PyArray_View, + (void *) PyArray_SwapAxes, + (void *) PyArray_Max, + (void *) PyArray_Min, + (void *) PyArray_Ptp, + (void *) PyArray_Mean, + (void *) PyArray_Trace, + (void *) PyArray_Diagonal, + (void *) PyArray_Clip, + (void *) PyArray_Conjugate, + (void *) PyArray_Nonzero, + (void *) PyArray_Std, + (void *) PyArray_Sum, + (void *) PyArray_CumSum, + (void *) PyArray_Prod, + (void *) PyArray_CumProd, + (void *) PyArray_All, + (void *) PyArray_Any, + (void *) PyArray_Compress, + (void *) PyArray_Flatten, + (void *) PyArray_Ravel, + (void *) PyArray_MultiplyList, + (void *) PyArray_MultiplyIntList, + (void *) PyArray_GetPtr, + (void *) PyArray_CompareLists, + (void *) PyArray_AsCArray, + NULL, + NULL, + (void *) PyArray_Free, + (void *) PyArray_Converter, + (void *) PyArray_IntpFromSequence, + (void *) PyArray_Concatenate, + (void *) PyArray_InnerProduct, + (void *) PyArray_MatrixProduct, + NULL, + (void *) PyArray_Correlate, + NULL, + (void *) PyArray_DescrConverter, + (void *) PyArray_DescrConverter2, + (void *) PyArray_IntpConverter, + (void *) PyArray_BufferConverter, + (void *) PyArray_AxisConverter, + (void *) PyArray_BoolConverter, + (void *) PyArray_ByteorderConverter, + (void *) PyArray_OrderConverter, + (void *) PyArray_EquivTypes, + (void *) PyArray_Zeros, + (void *) PyArray_Empty, + (void *) PyArray_Where, + (void *) PyArray_Arange, + (void *) PyArray_ArangeObj, + (void *) PyArray_SortkindConverter, + (void *) PyArray_LexSort, + (void *) PyArray_Round, + (void *) PyArray_EquivTypenums, + (void *) PyArray_RegisterDataType, + (void *) PyArray_RegisterCastFunc, + (void *) PyArray_RegisterCanCast, + (void *) PyArray_InitArrFuncs, + (void *) PyArray_IntTupleFromIntp, + NULL, + (void *) PyArray_ClipmodeConverter, + (void *) PyArray_OutputConverter, + (void *) PyArray_BroadcastToShape, + NULL, + NULL, + (void *) PyArray_DescrAlignConverter, + (void *) PyArray_DescrAlignConverter2, + (void *) PyArray_SearchsideConverter, + (void *) PyArray_CheckAxis, + (void *) PyArray_OverflowMultiplyList, + NULL, + (void *) PyArray_MultiIterFromObjects, + (void *) PyArray_GetEndianness, + (void *) PyArray_GetNDArrayCFeatureVersion, + (void *) PyArray_Correlate2, + (void *) PyArray_NeighborhoodIterNew, + (void *) &PyTimeIntegerArrType_Type, + (void *) &PyDatetimeArrType_Type, + (void *) &PyTimedeltaArrType_Type, + (void *) &PyHalfArrType_Type, + (void *) &NpyIter_Type, + NULL, + NULL, + NULL, + NULL, + NULL, + (void *) NpyIter_New, + (void *) NpyIter_MultiNew, + (void *) NpyIter_AdvancedNew, + (void *) NpyIter_Copy, + (void *) NpyIter_Deallocate, + (void *) NpyIter_HasDelayedBufAlloc, + (void *) NpyIter_HasExternalLoop, + (void *) NpyIter_EnableExternalLoop, + (void *) NpyIter_GetInnerStrideArray, + (void *) NpyIter_GetInnerLoopSizePtr, + (void *) NpyIter_Reset, + (void *) NpyIter_ResetBasePointers, + (void *) NpyIter_ResetToIterIndexRange, + (void *) NpyIter_GetNDim, + (void *) NpyIter_GetNOp, + (void *) NpyIter_GetIterNext, + (void *) NpyIter_GetIterSize, + (void *) NpyIter_GetIterIndexRange, + (void *) NpyIter_GetIterIndex, + (void *) NpyIter_GotoIterIndex, + (void *) NpyIter_HasMultiIndex, + (void *) NpyIter_GetShape, + (void *) NpyIter_GetGetMultiIndex, + (void *) NpyIter_GotoMultiIndex, + (void *) NpyIter_RemoveMultiIndex, + (void *) NpyIter_HasIndex, + (void *) NpyIter_IsBuffered, + (void *) NpyIter_IsGrowInner, + (void *) NpyIter_GetBufferSize, + (void *) NpyIter_GetIndexPtr, + (void *) NpyIter_GotoIndex, + (void *) NpyIter_GetDataPtrArray, + (void *) NpyIter_GetDescrArray, + (void *) NpyIter_GetOperandArray, + (void *) NpyIter_GetIterView, + (void *) NpyIter_GetReadFlags, + (void *) NpyIter_GetWriteFlags, + (void *) NpyIter_DebugPrint, + (void *) NpyIter_IterationNeedsAPI, + (void *) NpyIter_GetInnerFixedStrideArray, + (void *) NpyIter_RemoveAxis, + (void *) NpyIter_GetAxisStrideArray, + (void *) NpyIter_RequiresBuffering, + (void *) NpyIter_GetInitialDataPtrArray, + (void *) NpyIter_CreateCompatibleStrides, + (void *) PyArray_CastingConverter, + (void *) PyArray_CountNonzero, + (void *) PyArray_PromoteTypes, + (void *) PyArray_MinScalarType, + (void *) PyArray_ResultType, + (void *) PyArray_CanCastArrayTo, + (void *) PyArray_CanCastTypeTo, + (void *) PyArray_EinsteinSum, + (void *) PyArray_NewLikeArray, + NULL, + (void *) PyArray_ConvertClipmodeSequence, + (void *) PyArray_MatrixProduct2, + (void *) NpyIter_IsFirstVisit, + (void *) PyArray_SetBaseObject, + (void *) PyArray_CreateSortedStridePerm, + (void *) PyArray_RemoveAxesInPlace, + (void *) PyArray_DebugPrint, + (void *) PyArray_FailUnlessWriteable, + (void *) PyArray_SetUpdateIfCopyBase, + (void *) PyDataMem_NEW, + (void *) PyDataMem_FREE, + (void *) PyDataMem_RENEW, + NULL, + (NPY_CASTING *) &NPY_DEFAULT_ASSIGN_CASTING, + NULL, + NULL, + NULL, + (void *) PyArray_Partition, + (void *) PyArray_ArgPartition, + (void *) PyArray_SelectkindConverter, + (void *) PyDataMem_NEW_ZEROED, + (void *) PyArray_CheckAnyScalarExact, + NULL, + (void *) PyArray_ResolveWritebackIfCopy, + (void *) PyArray_SetWritebackIfCopyBase, + (void *) PyDataMem_SetHandler, + (void *) PyDataMem_GetHandler, + (PyObject* *) &PyDataMem_DefaultHandler, + (void *) NpyDatetime_ConvertDatetime64ToDatetimeStruct, + (void *) NpyDatetime_ConvertDatetimeStructToDatetime64, + (void *) NpyDatetime_ConvertPyDateTimeToDatetimeStruct, + (void *) NpyDatetime_GetDatetimeISO8601StrLen, + (void *) NpyDatetime_MakeISO8601Datetime, + (void *) NpyDatetime_ParseISO8601Datetime, + (void *) NpyString_load, + (void *) NpyString_pack, + (void *) NpyString_pack_null, + (void *) NpyString_acquire_allocator, + (void *) NpyString_acquire_allocators, + (void *) NpyString_release_allocator, + (void *) NpyString_release_allocators, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + (void *) PyArray_GetDefaultDescr, + (void *) PyArrayInitDTypeMeta_FromSpec, + (void *) PyArray_CommonDType, + (void *) PyArray_PromoteDTypeSequence, + (void *) _PyDataType_GetArrFuncs, + NULL, + NULL, + NULL +}; diff --git a/venv/lib/python3.12/site-packages/numpy/_core/include/numpy/__multiarray_api.h b/venv/lib/python3.12/site-packages/numpy/_core/include/numpy/__multiarray_api.h new file mode 100644 index 00000000..cfc3628a --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/include/numpy/__multiarray_api.h @@ -0,0 +1,1613 @@ + +#if defined(_MULTIARRAYMODULE) || defined(WITH_CPYCHECKER_STEALS_REFERENCE_TO_ARG_ATTRIBUTE) + +typedef struct { + PyObject_HEAD + npy_bool obval; +} PyBoolScalarObject; + +extern NPY_NO_EXPORT PyTypeObject PyArrayNeighborhoodIter_Type; +extern NPY_NO_EXPORT PyBoolScalarObject _PyArrayScalar_BoolValues[2]; + +NPY_NO_EXPORT unsigned int PyArray_GetNDArrayCVersion \ + (void); +extern NPY_NO_EXPORT PyTypeObject PyArray_Type; + +extern NPY_NO_EXPORT PyArray_DTypeMeta PyArrayDescr_TypeFull; +#define PyArrayDescr_Type (*(PyTypeObject *)(&PyArrayDescr_TypeFull)) + +extern NPY_NO_EXPORT PyTypeObject PyArrayIter_Type; + +extern NPY_NO_EXPORT PyTypeObject PyArrayMultiIter_Type; + +extern NPY_NO_EXPORT int NPY_NUMUSERTYPES; + +extern NPY_NO_EXPORT PyTypeObject PyBoolArrType_Type; + +extern NPY_NO_EXPORT PyBoolScalarObject _PyArrayScalar_BoolValues[2]; + +extern NPY_NO_EXPORT PyTypeObject PyGenericArrType_Type; + +extern NPY_NO_EXPORT PyTypeObject PyNumberArrType_Type; + +extern NPY_NO_EXPORT PyTypeObject PyIntegerArrType_Type; + +extern NPY_NO_EXPORT PyTypeObject PySignedIntegerArrType_Type; + +extern NPY_NO_EXPORT PyTypeObject PyUnsignedIntegerArrType_Type; + +extern NPY_NO_EXPORT PyTypeObject PyInexactArrType_Type; + +extern NPY_NO_EXPORT PyTypeObject PyFloatingArrType_Type; + +extern NPY_NO_EXPORT PyTypeObject PyComplexFloatingArrType_Type; + +extern NPY_NO_EXPORT PyTypeObject PyFlexibleArrType_Type; + +extern NPY_NO_EXPORT PyTypeObject PyCharacterArrType_Type; + +extern NPY_NO_EXPORT PyTypeObject PyByteArrType_Type; + +extern NPY_NO_EXPORT PyTypeObject PyShortArrType_Type; + +extern NPY_NO_EXPORT PyTypeObject PyIntArrType_Type; + +extern NPY_NO_EXPORT PyTypeObject PyLongArrType_Type; + +extern NPY_NO_EXPORT PyTypeObject PyLongLongArrType_Type; + +extern NPY_NO_EXPORT PyTypeObject PyUByteArrType_Type; + +extern NPY_NO_EXPORT PyTypeObject PyUShortArrType_Type; + +extern NPY_NO_EXPORT PyTypeObject PyUIntArrType_Type; + +extern NPY_NO_EXPORT PyTypeObject PyULongArrType_Type; + +extern NPY_NO_EXPORT PyTypeObject PyULongLongArrType_Type; + +extern NPY_NO_EXPORT PyTypeObject PyFloatArrType_Type; + +extern NPY_NO_EXPORT PyTypeObject PyDoubleArrType_Type; + +extern NPY_NO_EXPORT PyTypeObject PyLongDoubleArrType_Type; + +extern NPY_NO_EXPORT PyTypeObject PyCFloatArrType_Type; + +extern NPY_NO_EXPORT PyTypeObject PyCDoubleArrType_Type; + +extern NPY_NO_EXPORT PyTypeObject PyCLongDoubleArrType_Type; + +extern NPY_NO_EXPORT PyTypeObject PyObjectArrType_Type; + +extern NPY_NO_EXPORT PyTypeObject PyStringArrType_Type; + +extern NPY_NO_EXPORT PyTypeObject PyUnicodeArrType_Type; + +extern NPY_NO_EXPORT PyTypeObject PyVoidArrType_Type; + +NPY_NO_EXPORT int PyArray_INCREF \ + (PyArrayObject *); +NPY_NO_EXPORT int PyArray_XDECREF \ + (PyArrayObject *); +NPY_NO_EXPORT void PyArray_SetStringFunction \ + (PyObject *, int); +NPY_NO_EXPORT PyArray_Descr * PyArray_DescrFromType \ + (int); +NPY_NO_EXPORT PyObject * PyArray_TypeObjectFromType \ + (int); +NPY_NO_EXPORT char * PyArray_Zero \ + (PyArrayObject *); +NPY_NO_EXPORT char * PyArray_One \ + (PyArrayObject *); +NPY_NO_EXPORT NPY_STEALS_REF_TO_ARG(2) PyObject * PyArray_CastToType \ + (PyArrayObject *, PyArray_Descr *, int); +NPY_NO_EXPORT int PyArray_CopyInto \ + (PyArrayObject *, PyArrayObject *); +NPY_NO_EXPORT int PyArray_CopyAnyInto \ + (PyArrayObject *, PyArrayObject *); +NPY_NO_EXPORT int PyArray_CanCastSafely \ + (int, int); +NPY_NO_EXPORT npy_bool PyArray_CanCastTo \ + (PyArray_Descr *, PyArray_Descr *); +NPY_NO_EXPORT int PyArray_ObjectType \ + (PyObject *, int); +NPY_NO_EXPORT PyArray_Descr * PyArray_DescrFromObject \ + (PyObject *, PyArray_Descr *); +NPY_NO_EXPORT PyArrayObject ** PyArray_ConvertToCommonType \ + (PyObject *, int *); +NPY_NO_EXPORT PyArray_Descr * PyArray_DescrFromScalar \ + (PyObject *); +NPY_NO_EXPORT PyArray_Descr * PyArray_DescrFromTypeObject \ + (PyObject *); +NPY_NO_EXPORT npy_intp PyArray_Size \ + (PyObject *); +NPY_NO_EXPORT PyObject * PyArray_Scalar \ + (void *, PyArray_Descr *, PyObject *); +NPY_NO_EXPORT NPY_STEALS_REF_TO_ARG(2) PyObject * PyArray_FromScalar \ + (PyObject *, PyArray_Descr *); +NPY_NO_EXPORT void PyArray_ScalarAsCtype \ + (PyObject *, void *); +NPY_NO_EXPORT int PyArray_CastScalarToCtype \ + (PyObject *, void *, PyArray_Descr *); +NPY_NO_EXPORT int PyArray_CastScalarDirect \ + (PyObject *, PyArray_Descr *, void *, int); +NPY_NO_EXPORT int PyArray_Pack \ + (PyArray_Descr *, void *, PyObject *); +NPY_NO_EXPORT NPY_STEALS_REF_TO_ARG(2) PyObject * PyArray_FromAny \ + (PyObject *, PyArray_Descr *, int, int, int, PyObject *); +NPY_NO_EXPORT NPY_STEALS_REF_TO_ARG(1) PyObject * PyArray_EnsureArray \ + (PyObject *); +NPY_NO_EXPORT NPY_STEALS_REF_TO_ARG(1) PyObject * PyArray_EnsureAnyArray \ + (PyObject *); +NPY_NO_EXPORT PyObject * PyArray_FromFile \ + (FILE *, PyArray_Descr *, npy_intp, char *); +NPY_NO_EXPORT PyObject * PyArray_FromString \ + (char *, npy_intp, PyArray_Descr *, npy_intp, char *); +NPY_NO_EXPORT PyObject * PyArray_FromBuffer \ + (PyObject *, PyArray_Descr *, npy_intp, npy_intp); +NPY_NO_EXPORT NPY_STEALS_REF_TO_ARG(2) PyObject * PyArray_FromIter \ + (PyObject *, PyArray_Descr *, npy_intp); +NPY_NO_EXPORT NPY_STEALS_REF_TO_ARG(1) PyObject * PyArray_Return \ + (PyArrayObject *); +NPY_NO_EXPORT NPY_STEALS_REF_TO_ARG(2) PyObject * PyArray_GetField \ + (PyArrayObject *, PyArray_Descr *, int); +NPY_NO_EXPORT NPY_STEALS_REF_TO_ARG(2) int PyArray_SetField \ + (PyArrayObject *, PyArray_Descr *, int, PyObject *); +NPY_NO_EXPORT PyObject * PyArray_Byteswap \ + (PyArrayObject *, npy_bool); +NPY_NO_EXPORT PyObject * PyArray_Resize \ + (PyArrayObject *, PyArray_Dims *, int, NPY_ORDER NPY_UNUSED(order)); +NPY_NO_EXPORT int PyArray_CopyObject \ + (PyArrayObject *, PyObject *); +NPY_NO_EXPORT PyObject * PyArray_NewCopy \ + (PyArrayObject *, NPY_ORDER); +NPY_NO_EXPORT PyObject * PyArray_ToList \ + (PyArrayObject *); +NPY_NO_EXPORT PyObject * PyArray_ToString \ + (PyArrayObject *, NPY_ORDER); +NPY_NO_EXPORT int PyArray_ToFile \ + (PyArrayObject *, FILE *, char *, char *); +NPY_NO_EXPORT int PyArray_Dump \ + (PyObject *, PyObject *, int); +NPY_NO_EXPORT PyObject * PyArray_Dumps \ + (PyObject *, int); +NPY_NO_EXPORT int PyArray_ValidType \ + (int); +NPY_NO_EXPORT void PyArray_UpdateFlags \ + (PyArrayObject *, int); +NPY_NO_EXPORT PyObject * PyArray_New \ + (PyTypeObject *, int, npy_intp const *, int, npy_intp const *, void *, int, int, PyObject *); +NPY_NO_EXPORT NPY_STEALS_REF_TO_ARG(2) PyObject * PyArray_NewFromDescr \ + (PyTypeObject *, PyArray_Descr *, int, npy_intp const *, npy_intp const *, void *, int, PyObject *); +NPY_NO_EXPORT PyArray_Descr * PyArray_DescrNew \ + (PyArray_Descr *); +NPY_NO_EXPORT PyArray_Descr * PyArray_DescrNewFromType \ + (int); +NPY_NO_EXPORT double PyArray_GetPriority \ + (PyObject *, double); +NPY_NO_EXPORT PyObject * PyArray_IterNew \ + (PyObject *); +NPY_NO_EXPORT PyObject* PyArray_MultiIterNew \ + (int, ...); +NPY_NO_EXPORT int PyArray_PyIntAsInt \ + (PyObject *); +NPY_NO_EXPORT npy_intp PyArray_PyIntAsIntp \ + (PyObject *); +NPY_NO_EXPORT int PyArray_Broadcast \ + (PyArrayMultiIterObject *); +NPY_NO_EXPORT int PyArray_FillWithScalar \ + (PyArrayObject *, PyObject *); +NPY_NO_EXPORT npy_bool PyArray_CheckStrides \ + (int, int, npy_intp, npy_intp, npy_intp const *, npy_intp const *); +NPY_NO_EXPORT PyArray_Descr * PyArray_DescrNewByteorder \ + (PyArray_Descr *, char); +NPY_NO_EXPORT PyObject * PyArray_IterAllButAxis \ + (PyObject *, int *); +NPY_NO_EXPORT NPY_STEALS_REF_TO_ARG(2) PyObject * PyArray_CheckFromAny \ + (PyObject *, PyArray_Descr *, int, int, int, PyObject *); +NPY_NO_EXPORT NPY_STEALS_REF_TO_ARG(2) PyObject * PyArray_FromArray \ + (PyArrayObject *, PyArray_Descr *, int); +NPY_NO_EXPORT PyObject * PyArray_FromInterface \ + (PyObject *); +NPY_NO_EXPORT PyObject * PyArray_FromStructInterface \ + (PyObject *); +NPY_NO_EXPORT PyObject * PyArray_FromArrayAttr \ + (PyObject *, PyArray_Descr *, PyObject *); +NPY_NO_EXPORT NPY_SCALARKIND PyArray_ScalarKind \ + (int, PyArrayObject **); +NPY_NO_EXPORT int PyArray_CanCoerceScalar \ + (int, int, NPY_SCALARKIND); +NPY_NO_EXPORT npy_bool PyArray_CanCastScalar \ + (PyTypeObject *, PyTypeObject *); +NPY_NO_EXPORT int PyArray_RemoveSmallest \ + (PyArrayMultiIterObject *); +NPY_NO_EXPORT int PyArray_ElementStrides \ + (PyObject *); +NPY_NO_EXPORT void PyArray_Item_INCREF \ + (char *, PyArray_Descr *); +NPY_NO_EXPORT void PyArray_Item_XDECREF \ + (char *, PyArray_Descr *); +NPY_NO_EXPORT PyObject * PyArray_Transpose \ + (PyArrayObject *, PyArray_Dims *); +NPY_NO_EXPORT PyObject * PyArray_TakeFrom \ + (PyArrayObject *, PyObject *, int, PyArrayObject *, NPY_CLIPMODE); +NPY_NO_EXPORT PyObject * PyArray_PutTo \ + (PyArrayObject *, PyObject*, PyObject *, NPY_CLIPMODE); +NPY_NO_EXPORT PyObject * PyArray_PutMask \ + (PyArrayObject *, PyObject*, PyObject*); +NPY_NO_EXPORT PyObject * PyArray_Repeat \ + (PyArrayObject *, PyObject *, int); +NPY_NO_EXPORT PyObject * PyArray_Choose \ + (PyArrayObject *, PyObject *, PyArrayObject *, NPY_CLIPMODE); +NPY_NO_EXPORT int PyArray_Sort \ + (PyArrayObject *, int, NPY_SORTKIND); +NPY_NO_EXPORT PyObject * PyArray_ArgSort \ + (PyArrayObject *, int, NPY_SORTKIND); +NPY_NO_EXPORT PyObject * PyArray_SearchSorted \ + (PyArrayObject *, PyObject *, NPY_SEARCHSIDE, PyObject *); +NPY_NO_EXPORT PyObject * PyArray_ArgMax \ + (PyArrayObject *, int, PyArrayObject *); +NPY_NO_EXPORT PyObject * PyArray_ArgMin \ + (PyArrayObject *, int, PyArrayObject *); +NPY_NO_EXPORT PyObject * PyArray_Reshape \ + (PyArrayObject *, PyObject *); +NPY_NO_EXPORT PyObject * PyArray_Newshape \ + (PyArrayObject *, PyArray_Dims *, NPY_ORDER); +NPY_NO_EXPORT PyObject * PyArray_Squeeze \ + (PyArrayObject *); +NPY_NO_EXPORT NPY_STEALS_REF_TO_ARG(2) PyObject * PyArray_View \ + (PyArrayObject *, PyArray_Descr *, PyTypeObject *); +NPY_NO_EXPORT PyObject * PyArray_SwapAxes \ + (PyArrayObject *, int, int); +NPY_NO_EXPORT PyObject * PyArray_Max \ + (PyArrayObject *, int, PyArrayObject *); +NPY_NO_EXPORT PyObject * PyArray_Min \ + (PyArrayObject *, int, PyArrayObject *); +NPY_NO_EXPORT PyObject * PyArray_Ptp \ + (PyArrayObject *, int, PyArrayObject *); +NPY_NO_EXPORT PyObject * PyArray_Mean \ + (PyArrayObject *, int, int, PyArrayObject *); +NPY_NO_EXPORT PyObject * PyArray_Trace \ + (PyArrayObject *, int, int, int, int, PyArrayObject *); +NPY_NO_EXPORT PyObject * PyArray_Diagonal \ + (PyArrayObject *, int, int, int); +NPY_NO_EXPORT PyObject * PyArray_Clip \ + (PyArrayObject *, PyObject *, PyObject *, PyArrayObject *); +NPY_NO_EXPORT PyObject * PyArray_Conjugate \ + (PyArrayObject *, PyArrayObject *); +NPY_NO_EXPORT PyObject * PyArray_Nonzero \ + (PyArrayObject *); +NPY_NO_EXPORT PyObject * PyArray_Std \ + (PyArrayObject *, int, int, PyArrayObject *, int); +NPY_NO_EXPORT PyObject * PyArray_Sum \ + (PyArrayObject *, int, int, PyArrayObject *); +NPY_NO_EXPORT PyObject * PyArray_CumSum \ + (PyArrayObject *, int, int, PyArrayObject *); +NPY_NO_EXPORT PyObject * PyArray_Prod \ + (PyArrayObject *, int, int, PyArrayObject *); +NPY_NO_EXPORT PyObject * PyArray_CumProd \ + (PyArrayObject *, int, int, PyArrayObject *); +NPY_NO_EXPORT PyObject * PyArray_All \ + (PyArrayObject *, int, PyArrayObject *); +NPY_NO_EXPORT PyObject * PyArray_Any \ + (PyArrayObject *, int, PyArrayObject *); +NPY_NO_EXPORT PyObject * PyArray_Compress \ + (PyArrayObject *, PyObject *, int, PyArrayObject *); +NPY_NO_EXPORT PyObject * PyArray_Flatten \ + (PyArrayObject *, NPY_ORDER); +NPY_NO_EXPORT PyObject * PyArray_Ravel \ + (PyArrayObject *, NPY_ORDER); +NPY_NO_EXPORT npy_intp PyArray_MultiplyList \ + (npy_intp const *, int); +NPY_NO_EXPORT int PyArray_MultiplyIntList \ + (int const *, int); +NPY_NO_EXPORT void * PyArray_GetPtr \ + (PyArrayObject *, npy_intp const*); +NPY_NO_EXPORT int PyArray_CompareLists \ + (npy_intp const *, npy_intp const *, int); +NPY_NO_EXPORT NPY_STEALS_REF_TO_ARG(5) int PyArray_AsCArray \ + (PyObject **, void *, npy_intp *, int, PyArray_Descr*); +NPY_NO_EXPORT int PyArray_Free \ + (PyObject *, void *); +NPY_NO_EXPORT int PyArray_Converter \ + (PyObject *, PyObject **); +NPY_NO_EXPORT int PyArray_IntpFromSequence \ + (PyObject *, npy_intp *, int); +NPY_NO_EXPORT PyObject * PyArray_Concatenate \ + (PyObject *, int); +NPY_NO_EXPORT PyObject * PyArray_InnerProduct \ + (PyObject *, PyObject *); +NPY_NO_EXPORT PyObject * PyArray_MatrixProduct \ + (PyObject *, PyObject *); +NPY_NO_EXPORT PyObject * PyArray_Correlate \ + (PyObject *, PyObject *, int); +NPY_NO_EXPORT int PyArray_DescrConverter \ + (PyObject *, PyArray_Descr **); +NPY_NO_EXPORT int PyArray_DescrConverter2 \ + (PyObject *, PyArray_Descr **); +NPY_NO_EXPORT int PyArray_IntpConverter \ + (PyObject *, PyArray_Dims *); +NPY_NO_EXPORT int PyArray_BufferConverter \ + (PyObject *, PyArray_Chunk *); +NPY_NO_EXPORT int PyArray_AxisConverter \ + (PyObject *, int *); +NPY_NO_EXPORT int PyArray_BoolConverter \ + (PyObject *, npy_bool *); +NPY_NO_EXPORT int PyArray_ByteorderConverter \ + (PyObject *, char *); +NPY_NO_EXPORT int PyArray_OrderConverter \ + (PyObject *, NPY_ORDER *); +NPY_NO_EXPORT unsigned char PyArray_EquivTypes \ + (PyArray_Descr *, PyArray_Descr *); +NPY_NO_EXPORT NPY_STEALS_REF_TO_ARG(3) PyObject * PyArray_Zeros \ + (int, npy_intp const *, PyArray_Descr *, int); +NPY_NO_EXPORT NPY_STEALS_REF_TO_ARG(3) PyObject * PyArray_Empty \ + (int, npy_intp const *, PyArray_Descr *, int); +NPY_NO_EXPORT PyObject * PyArray_Where \ + (PyObject *, PyObject *, PyObject *); +NPY_NO_EXPORT PyObject * PyArray_Arange \ + (double, double, double, int); +NPY_NO_EXPORT PyObject * PyArray_ArangeObj \ + (PyObject *, PyObject *, PyObject *, PyArray_Descr *); +NPY_NO_EXPORT int PyArray_SortkindConverter \ + (PyObject *, NPY_SORTKIND *); +NPY_NO_EXPORT PyObject * PyArray_LexSort \ + (PyObject *, int); +NPY_NO_EXPORT PyObject * PyArray_Round \ + (PyArrayObject *, int, PyArrayObject *); +NPY_NO_EXPORT unsigned char PyArray_EquivTypenums \ + (int, int); +NPY_NO_EXPORT int PyArray_RegisterDataType \ + (PyArray_DescrProto *); +NPY_NO_EXPORT int PyArray_RegisterCastFunc \ + (PyArray_Descr *, int, PyArray_VectorUnaryFunc *); +NPY_NO_EXPORT int PyArray_RegisterCanCast \ + (PyArray_Descr *, int, NPY_SCALARKIND); +NPY_NO_EXPORT void PyArray_InitArrFuncs \ + (PyArray_ArrFuncs *); +NPY_NO_EXPORT PyObject * PyArray_IntTupleFromIntp \ + (int, npy_intp const *); +NPY_NO_EXPORT int PyArray_ClipmodeConverter \ + (PyObject *, NPY_CLIPMODE *); +NPY_NO_EXPORT int PyArray_OutputConverter \ + (PyObject *, PyArrayObject **); +NPY_NO_EXPORT PyObject * PyArray_BroadcastToShape \ + (PyObject *, npy_intp *, int); +NPY_NO_EXPORT int PyArray_DescrAlignConverter \ + (PyObject *, PyArray_Descr **); +NPY_NO_EXPORT int PyArray_DescrAlignConverter2 \ + (PyObject *, PyArray_Descr **); +NPY_NO_EXPORT int PyArray_SearchsideConverter \ + (PyObject *, void *); +NPY_NO_EXPORT PyObject * PyArray_CheckAxis \ + (PyArrayObject *, int *, int); +NPY_NO_EXPORT npy_intp PyArray_OverflowMultiplyList \ + (npy_intp const *, int); +NPY_NO_EXPORT PyObject* PyArray_MultiIterFromObjects \ + (PyObject **, int, int, ...); +NPY_NO_EXPORT int PyArray_GetEndianness \ + (void); +NPY_NO_EXPORT unsigned int PyArray_GetNDArrayCFeatureVersion \ + (void); +NPY_NO_EXPORT PyObject * PyArray_Correlate2 \ + (PyObject *, PyObject *, int); +NPY_NO_EXPORT PyObject* PyArray_NeighborhoodIterNew \ + (PyArrayIterObject *, const npy_intp *, int, PyArrayObject*); +extern NPY_NO_EXPORT PyTypeObject PyTimeIntegerArrType_Type; + +extern NPY_NO_EXPORT PyTypeObject PyDatetimeArrType_Type; + +extern NPY_NO_EXPORT PyTypeObject PyTimedeltaArrType_Type; + +extern NPY_NO_EXPORT PyTypeObject PyHalfArrType_Type; + +extern NPY_NO_EXPORT PyTypeObject NpyIter_Type; + +NPY_NO_EXPORT NpyIter * NpyIter_New \ + (PyArrayObject *, npy_uint32, NPY_ORDER, NPY_CASTING, PyArray_Descr*); +NPY_NO_EXPORT NpyIter * NpyIter_MultiNew \ + (int, PyArrayObject **, npy_uint32, NPY_ORDER, NPY_CASTING, npy_uint32 *, PyArray_Descr **); +NPY_NO_EXPORT NpyIter * NpyIter_AdvancedNew \ + (int, PyArrayObject **, npy_uint32, NPY_ORDER, NPY_CASTING, npy_uint32 *, PyArray_Descr **, int, int **, npy_intp *, npy_intp); +NPY_NO_EXPORT NpyIter * NpyIter_Copy \ + (NpyIter *); +NPY_NO_EXPORT int NpyIter_Deallocate \ + (NpyIter *); +NPY_NO_EXPORT npy_bool NpyIter_HasDelayedBufAlloc \ + (NpyIter *); +NPY_NO_EXPORT npy_bool NpyIter_HasExternalLoop \ + (NpyIter *); +NPY_NO_EXPORT int NpyIter_EnableExternalLoop \ + (NpyIter *); +NPY_NO_EXPORT npy_intp * NpyIter_GetInnerStrideArray \ + (NpyIter *); +NPY_NO_EXPORT npy_intp * NpyIter_GetInnerLoopSizePtr \ + (NpyIter *); +NPY_NO_EXPORT int NpyIter_Reset \ + (NpyIter *, char **); +NPY_NO_EXPORT int NpyIter_ResetBasePointers \ + (NpyIter *, char **, char **); +NPY_NO_EXPORT int NpyIter_ResetToIterIndexRange \ + (NpyIter *, npy_intp, npy_intp, char **); +NPY_NO_EXPORT int NpyIter_GetNDim \ + (NpyIter *); +NPY_NO_EXPORT int NpyIter_GetNOp \ + (NpyIter *); +NPY_NO_EXPORT NpyIter_IterNextFunc * NpyIter_GetIterNext \ + (NpyIter *, char **); +NPY_NO_EXPORT npy_intp NpyIter_GetIterSize \ + (NpyIter *); +NPY_NO_EXPORT void NpyIter_GetIterIndexRange \ + (NpyIter *, npy_intp *, npy_intp *); +NPY_NO_EXPORT npy_intp NpyIter_GetIterIndex \ + (NpyIter *); +NPY_NO_EXPORT int NpyIter_GotoIterIndex \ + (NpyIter *, npy_intp); +NPY_NO_EXPORT npy_bool NpyIter_HasMultiIndex \ + (NpyIter *); +NPY_NO_EXPORT int NpyIter_GetShape \ + (NpyIter *, npy_intp *); +NPY_NO_EXPORT NpyIter_GetMultiIndexFunc * NpyIter_GetGetMultiIndex \ + (NpyIter *, char **); +NPY_NO_EXPORT int NpyIter_GotoMultiIndex \ + (NpyIter *, npy_intp const *); +NPY_NO_EXPORT int NpyIter_RemoveMultiIndex \ + (NpyIter *); +NPY_NO_EXPORT npy_bool NpyIter_HasIndex \ + (NpyIter *); +NPY_NO_EXPORT npy_bool NpyIter_IsBuffered \ + (NpyIter *); +NPY_NO_EXPORT npy_bool NpyIter_IsGrowInner \ + (NpyIter *); +NPY_NO_EXPORT npy_intp NpyIter_GetBufferSize \ + (NpyIter *); +NPY_NO_EXPORT npy_intp * NpyIter_GetIndexPtr \ + (NpyIter *); +NPY_NO_EXPORT int NpyIter_GotoIndex \ + (NpyIter *, npy_intp); +NPY_NO_EXPORT char ** NpyIter_GetDataPtrArray \ + (NpyIter *); +NPY_NO_EXPORT PyArray_Descr ** NpyIter_GetDescrArray \ + (NpyIter *); +NPY_NO_EXPORT PyArrayObject ** NpyIter_GetOperandArray \ + (NpyIter *); +NPY_NO_EXPORT PyArrayObject * NpyIter_GetIterView \ + (NpyIter *, npy_intp); +NPY_NO_EXPORT void NpyIter_GetReadFlags \ + (NpyIter *, char *); +NPY_NO_EXPORT void NpyIter_GetWriteFlags \ + (NpyIter *, char *); +NPY_NO_EXPORT void NpyIter_DebugPrint \ + (NpyIter *); +NPY_NO_EXPORT npy_bool NpyIter_IterationNeedsAPI \ + (NpyIter *); +NPY_NO_EXPORT void NpyIter_GetInnerFixedStrideArray \ + (NpyIter *, npy_intp *); +NPY_NO_EXPORT int NpyIter_RemoveAxis \ + (NpyIter *, int); +NPY_NO_EXPORT npy_intp * NpyIter_GetAxisStrideArray \ + (NpyIter *, int); +NPY_NO_EXPORT npy_bool NpyIter_RequiresBuffering \ + (NpyIter *); +NPY_NO_EXPORT char ** NpyIter_GetInitialDataPtrArray \ + (NpyIter *); +NPY_NO_EXPORT int NpyIter_CreateCompatibleStrides \ + (NpyIter *, npy_intp, npy_intp *); +NPY_NO_EXPORT int PyArray_CastingConverter \ + (PyObject *, NPY_CASTING *); +NPY_NO_EXPORT npy_intp PyArray_CountNonzero \ + (PyArrayObject *); +NPY_NO_EXPORT PyArray_Descr * PyArray_PromoteTypes \ + (PyArray_Descr *, PyArray_Descr *); +NPY_NO_EXPORT PyArray_Descr * PyArray_MinScalarType \ + (PyArrayObject *); +NPY_NO_EXPORT PyArray_Descr * PyArray_ResultType \ + (npy_intp, PyArrayObject *arrs[], npy_intp, PyArray_Descr *descrs[]); +NPY_NO_EXPORT npy_bool PyArray_CanCastArrayTo \ + (PyArrayObject *, PyArray_Descr *, NPY_CASTING); +NPY_NO_EXPORT npy_bool PyArray_CanCastTypeTo \ + (PyArray_Descr *, PyArray_Descr *, NPY_CASTING); +NPY_NO_EXPORT PyArrayObject * PyArray_EinsteinSum \ + (char *, npy_intp, PyArrayObject **, PyArray_Descr *, NPY_ORDER, NPY_CASTING, PyArrayObject *); +NPY_NO_EXPORT NPY_STEALS_REF_TO_ARG(3) PyObject * PyArray_NewLikeArray \ + (PyArrayObject *, NPY_ORDER, PyArray_Descr *, int); +NPY_NO_EXPORT int PyArray_ConvertClipmodeSequence \ + (PyObject *, NPY_CLIPMODE *, int); +NPY_NO_EXPORT PyObject * PyArray_MatrixProduct2 \ + (PyObject *, PyObject *, PyArrayObject*); +NPY_NO_EXPORT npy_bool NpyIter_IsFirstVisit \ + (NpyIter *, int); +NPY_NO_EXPORT NPY_STEALS_REF_TO_ARG(2) int PyArray_SetBaseObject \ + (PyArrayObject *, PyObject *); +NPY_NO_EXPORT void PyArray_CreateSortedStridePerm \ + (int, npy_intp const *, npy_stride_sort_item *); +NPY_NO_EXPORT void PyArray_RemoveAxesInPlace \ + (PyArrayObject *, const npy_bool *); +NPY_NO_EXPORT void PyArray_DebugPrint \ + (PyArrayObject *); +NPY_NO_EXPORT int PyArray_FailUnlessWriteable \ + (PyArrayObject *, const char *); +NPY_NO_EXPORT NPY_STEALS_REF_TO_ARG(2) int PyArray_SetUpdateIfCopyBase \ + (PyArrayObject *, PyArrayObject *); +NPY_NO_EXPORT void * PyDataMem_NEW \ + (size_t); +NPY_NO_EXPORT void PyDataMem_FREE \ + (void *); +NPY_NO_EXPORT void * PyDataMem_RENEW \ + (void *, size_t); +extern NPY_NO_EXPORT NPY_CASTING NPY_DEFAULT_ASSIGN_CASTING; + +NPY_NO_EXPORT int PyArray_Partition \ + (PyArrayObject *, PyArrayObject *, int, NPY_SELECTKIND); +NPY_NO_EXPORT PyObject * PyArray_ArgPartition \ + (PyArrayObject *, PyArrayObject *, int, NPY_SELECTKIND); +NPY_NO_EXPORT int PyArray_SelectkindConverter \ + (PyObject *, NPY_SELECTKIND *); +NPY_NO_EXPORT void * PyDataMem_NEW_ZEROED \ + (size_t, size_t); +NPY_NO_EXPORT int PyArray_CheckAnyScalarExact \ + (PyObject *); +NPY_NO_EXPORT int PyArray_ResolveWritebackIfCopy \ + (PyArrayObject *); +NPY_NO_EXPORT int PyArray_SetWritebackIfCopyBase \ + (PyArrayObject *, PyArrayObject *); +NPY_NO_EXPORT PyObject * PyDataMem_SetHandler \ + (PyObject *); +NPY_NO_EXPORT PyObject * PyDataMem_GetHandler \ + (void); +extern NPY_NO_EXPORT PyObject* PyDataMem_DefaultHandler; + +NPY_NO_EXPORT int NpyDatetime_ConvertDatetime64ToDatetimeStruct \ + (PyArray_DatetimeMetaData *, npy_datetime, npy_datetimestruct *); +NPY_NO_EXPORT int NpyDatetime_ConvertDatetimeStructToDatetime64 \ + (PyArray_DatetimeMetaData *, const npy_datetimestruct *, npy_datetime *); +NPY_NO_EXPORT int NpyDatetime_ConvertPyDateTimeToDatetimeStruct \ + (PyObject *, npy_datetimestruct *, NPY_DATETIMEUNIT *, int); +NPY_NO_EXPORT int NpyDatetime_GetDatetimeISO8601StrLen \ + (int, NPY_DATETIMEUNIT); +NPY_NO_EXPORT int NpyDatetime_MakeISO8601Datetime \ + (npy_datetimestruct *, char *, npy_intp, int, int, NPY_DATETIMEUNIT, int, NPY_CASTING); +NPY_NO_EXPORT int NpyDatetime_ParseISO8601Datetime \ + (char const *, Py_ssize_t, NPY_DATETIMEUNIT, NPY_CASTING, npy_datetimestruct *, NPY_DATETIMEUNIT *, npy_bool *); +NPY_NO_EXPORT int NpyString_load \ + (npy_string_allocator *, const npy_packed_static_string *, npy_static_string *); +NPY_NO_EXPORT int NpyString_pack \ + (npy_string_allocator *, npy_packed_static_string *, const char *, size_t); +NPY_NO_EXPORT int NpyString_pack_null \ + (npy_string_allocator *, npy_packed_static_string *); +NPY_NO_EXPORT npy_string_allocator * NpyString_acquire_allocator \ + (const PyArray_StringDTypeObject *); +NPY_NO_EXPORT void NpyString_acquire_allocators \ + (size_t, PyArray_Descr *const descrs[], npy_string_allocator *allocators[]); +NPY_NO_EXPORT void NpyString_release_allocator \ + (npy_string_allocator *); +NPY_NO_EXPORT void NpyString_release_allocators \ + (size_t, npy_string_allocator *allocators[]); +NPY_NO_EXPORT PyArray_Descr * PyArray_GetDefaultDescr \ + (PyArray_DTypeMeta *); +NPY_NO_EXPORT int PyArrayInitDTypeMeta_FromSpec \ + (PyArray_DTypeMeta *, PyArrayDTypeMeta_Spec *); +NPY_NO_EXPORT PyArray_DTypeMeta * PyArray_CommonDType \ + (PyArray_DTypeMeta *, PyArray_DTypeMeta *); +NPY_NO_EXPORT PyArray_DTypeMeta * PyArray_PromoteDTypeSequence \ + (npy_intp, PyArray_DTypeMeta **); +NPY_NO_EXPORT PyArray_ArrFuncs * _PyDataType_GetArrFuncs \ + (const PyArray_Descr *); + +#else + +#if defined(PY_ARRAY_UNIQUE_SYMBOL) + #define PyArray_API PY_ARRAY_UNIQUE_SYMBOL + #define _NPY_VERSION_CONCAT_HELPER2(x, y) x ## y + #define _NPY_VERSION_CONCAT_HELPER(arg) \ + _NPY_VERSION_CONCAT_HELPER2(arg, PyArray_RUNTIME_VERSION) + #define PyArray_RUNTIME_VERSION \ + _NPY_VERSION_CONCAT_HELPER(PY_ARRAY_UNIQUE_SYMBOL) +#endif + +/* By default do not export API in an .so (was never the case on windows) */ +#ifndef NPY_API_SYMBOL_ATTRIBUTE + #define NPY_API_SYMBOL_ATTRIBUTE NPY_VISIBILITY_HIDDEN +#endif + +#if defined(NO_IMPORT) || defined(NO_IMPORT_ARRAY) +extern NPY_API_SYMBOL_ATTRIBUTE void **PyArray_API; +extern NPY_API_SYMBOL_ATTRIBUTE int PyArray_RUNTIME_VERSION; +#else +#if defined(PY_ARRAY_UNIQUE_SYMBOL) +NPY_API_SYMBOL_ATTRIBUTE void **PyArray_API; +NPY_API_SYMBOL_ATTRIBUTE int PyArray_RUNTIME_VERSION; +#else +static void **PyArray_API = NULL; +static int PyArray_RUNTIME_VERSION = 0; +#endif +#endif + +#define PyArray_GetNDArrayCVersion \ + (*(unsigned int (*)(void)) \ + PyArray_API[0]) +#define PyArray_Type (*(PyTypeObject *)PyArray_API[2]) +#define PyArrayDescr_Type (*(PyTypeObject *)PyArray_API[3]) +#define PyArrayIter_Type (*(PyTypeObject *)PyArray_API[5]) +#define PyArrayMultiIter_Type (*(PyTypeObject *)PyArray_API[6]) +#define NPY_NUMUSERTYPES (*(int *)PyArray_API[7]) +#define PyBoolArrType_Type (*(PyTypeObject *)PyArray_API[8]) +#define _PyArrayScalar_BoolValues ((PyBoolScalarObject *)PyArray_API[9]) +#define PyGenericArrType_Type (*(PyTypeObject *)PyArray_API[10]) +#define PyNumberArrType_Type (*(PyTypeObject *)PyArray_API[11]) +#define PyIntegerArrType_Type (*(PyTypeObject *)PyArray_API[12]) +#define PySignedIntegerArrType_Type (*(PyTypeObject *)PyArray_API[13]) +#define PyUnsignedIntegerArrType_Type (*(PyTypeObject *)PyArray_API[14]) +#define PyInexactArrType_Type (*(PyTypeObject *)PyArray_API[15]) +#define PyFloatingArrType_Type (*(PyTypeObject *)PyArray_API[16]) +#define PyComplexFloatingArrType_Type (*(PyTypeObject *)PyArray_API[17]) +#define PyFlexibleArrType_Type (*(PyTypeObject *)PyArray_API[18]) +#define PyCharacterArrType_Type (*(PyTypeObject *)PyArray_API[19]) +#define PyByteArrType_Type (*(PyTypeObject *)PyArray_API[20]) +#define PyShortArrType_Type (*(PyTypeObject *)PyArray_API[21]) +#define PyIntArrType_Type (*(PyTypeObject *)PyArray_API[22]) +#define PyLongArrType_Type (*(PyTypeObject *)PyArray_API[23]) +#define PyLongLongArrType_Type (*(PyTypeObject *)PyArray_API[24]) +#define PyUByteArrType_Type (*(PyTypeObject *)PyArray_API[25]) +#define PyUShortArrType_Type (*(PyTypeObject *)PyArray_API[26]) +#define PyUIntArrType_Type (*(PyTypeObject *)PyArray_API[27]) +#define PyULongArrType_Type (*(PyTypeObject *)PyArray_API[28]) +#define PyULongLongArrType_Type (*(PyTypeObject *)PyArray_API[29]) +#define PyFloatArrType_Type (*(PyTypeObject *)PyArray_API[30]) +#define PyDoubleArrType_Type (*(PyTypeObject *)PyArray_API[31]) +#define PyLongDoubleArrType_Type (*(PyTypeObject *)PyArray_API[32]) +#define PyCFloatArrType_Type (*(PyTypeObject *)PyArray_API[33]) +#define PyCDoubleArrType_Type (*(PyTypeObject *)PyArray_API[34]) +#define PyCLongDoubleArrType_Type (*(PyTypeObject *)PyArray_API[35]) +#define PyObjectArrType_Type (*(PyTypeObject *)PyArray_API[36]) +#define PyStringArrType_Type (*(PyTypeObject *)PyArray_API[37]) +#define PyUnicodeArrType_Type (*(PyTypeObject *)PyArray_API[38]) +#define PyVoidArrType_Type (*(PyTypeObject *)PyArray_API[39]) +#define PyArray_INCREF \ + (*(int (*)(PyArrayObject *)) \ + PyArray_API[42]) +#define PyArray_XDECREF \ + (*(int (*)(PyArrayObject *)) \ + PyArray_API[43]) +#define PyArray_SetStringFunction \ + (*(void (*)(PyObject *, int)) \ + PyArray_API[44]) +#define PyArray_DescrFromType \ + (*(PyArray_Descr * (*)(int)) \ + PyArray_API[45]) +#define PyArray_TypeObjectFromType \ + (*(PyObject * (*)(int)) \ + PyArray_API[46]) +#define PyArray_Zero \ + (*(char * (*)(PyArrayObject *)) \ + PyArray_API[47]) +#define PyArray_One \ + (*(char * (*)(PyArrayObject *)) \ + PyArray_API[48]) +#define PyArray_CastToType \ + (*(PyObject * (*)(PyArrayObject *, PyArray_Descr *, int)) \ + PyArray_API[49]) +#define PyArray_CopyInto \ + (*(int (*)(PyArrayObject *, PyArrayObject *)) \ + PyArray_API[50]) +#define PyArray_CopyAnyInto \ + (*(int (*)(PyArrayObject *, PyArrayObject *)) \ + PyArray_API[51]) +#define PyArray_CanCastSafely \ + (*(int (*)(int, int)) \ + PyArray_API[52]) +#define PyArray_CanCastTo \ + (*(npy_bool (*)(PyArray_Descr *, PyArray_Descr *)) \ + PyArray_API[53]) +#define PyArray_ObjectType \ + (*(int (*)(PyObject *, int)) \ + PyArray_API[54]) +#define PyArray_DescrFromObject \ + (*(PyArray_Descr * (*)(PyObject *, PyArray_Descr *)) \ + PyArray_API[55]) +#define PyArray_ConvertToCommonType \ + (*(PyArrayObject ** (*)(PyObject *, int *)) \ + PyArray_API[56]) +#define PyArray_DescrFromScalar \ + (*(PyArray_Descr * (*)(PyObject *)) \ + PyArray_API[57]) +#define PyArray_DescrFromTypeObject \ + (*(PyArray_Descr * (*)(PyObject *)) \ + PyArray_API[58]) +#define PyArray_Size \ + (*(npy_intp (*)(PyObject *)) \ + PyArray_API[59]) +#define PyArray_Scalar \ + (*(PyObject * (*)(void *, PyArray_Descr *, PyObject *)) \ + PyArray_API[60]) +#define PyArray_FromScalar \ + (*(PyObject * (*)(PyObject *, PyArray_Descr *)) \ + PyArray_API[61]) +#define PyArray_ScalarAsCtype \ + (*(void (*)(PyObject *, void *)) \ + PyArray_API[62]) +#define PyArray_CastScalarToCtype \ + (*(int (*)(PyObject *, void *, PyArray_Descr *)) \ + PyArray_API[63]) +#define PyArray_CastScalarDirect \ + (*(int (*)(PyObject *, PyArray_Descr *, void *, int)) \ + PyArray_API[64]) + +#if NPY_FEATURE_VERSION >= NPY_2_0_API_VERSION +#define PyArray_Pack \ + (*(int (*)(PyArray_Descr *, void *, PyObject *)) \ + PyArray_API[65]) +#endif +#define PyArray_FromAny \ + (*(PyObject * (*)(PyObject *, PyArray_Descr *, int, int, int, PyObject *)) \ + PyArray_API[69]) +#define PyArray_EnsureArray \ + (*(PyObject * (*)(PyObject *)) \ + PyArray_API[70]) +#define PyArray_EnsureAnyArray \ + (*(PyObject * (*)(PyObject *)) \ + PyArray_API[71]) +#define PyArray_FromFile \ + (*(PyObject * (*)(FILE *, PyArray_Descr *, npy_intp, char *)) \ + PyArray_API[72]) +#define PyArray_FromString \ + (*(PyObject * (*)(char *, npy_intp, PyArray_Descr *, npy_intp, char *)) \ + PyArray_API[73]) +#define PyArray_FromBuffer \ + (*(PyObject * (*)(PyObject *, PyArray_Descr *, npy_intp, npy_intp)) \ + PyArray_API[74]) +#define PyArray_FromIter \ + (*(PyObject * (*)(PyObject *, PyArray_Descr *, npy_intp)) \ + PyArray_API[75]) +#define PyArray_Return \ + (*(PyObject * (*)(PyArrayObject *)) \ + PyArray_API[76]) +#define PyArray_GetField \ + (*(PyObject * (*)(PyArrayObject *, PyArray_Descr *, int)) \ + PyArray_API[77]) +#define PyArray_SetField \ + (*(int (*)(PyArrayObject *, PyArray_Descr *, int, PyObject *)) \ + PyArray_API[78]) +#define PyArray_Byteswap \ + (*(PyObject * (*)(PyArrayObject *, npy_bool)) \ + PyArray_API[79]) +#define PyArray_Resize \ + (*(PyObject * (*)(PyArrayObject *, PyArray_Dims *, int, NPY_ORDER NPY_UNUSED(order))) \ + PyArray_API[80]) +#define PyArray_CopyObject \ + (*(int (*)(PyArrayObject *, PyObject *)) \ + PyArray_API[84]) +#define PyArray_NewCopy \ + (*(PyObject * (*)(PyArrayObject *, NPY_ORDER)) \ + PyArray_API[85]) +#define PyArray_ToList \ + (*(PyObject * (*)(PyArrayObject *)) \ + PyArray_API[86]) +#define PyArray_ToString \ + (*(PyObject * (*)(PyArrayObject *, NPY_ORDER)) \ + PyArray_API[87]) +#define PyArray_ToFile \ + (*(int (*)(PyArrayObject *, FILE *, char *, char *)) \ + PyArray_API[88]) +#define PyArray_Dump \ + (*(int (*)(PyObject *, PyObject *, int)) \ + PyArray_API[89]) +#define PyArray_Dumps \ + (*(PyObject * (*)(PyObject *, int)) \ + PyArray_API[90]) +#define PyArray_ValidType \ + (*(int (*)(int)) \ + PyArray_API[91]) +#define PyArray_UpdateFlags \ + (*(void (*)(PyArrayObject *, int)) \ + PyArray_API[92]) +#define PyArray_New \ + (*(PyObject * (*)(PyTypeObject *, int, npy_intp const *, int, npy_intp const *, void *, int, int, PyObject *)) \ + PyArray_API[93]) +#define PyArray_NewFromDescr \ + (*(PyObject * (*)(PyTypeObject *, PyArray_Descr *, int, npy_intp const *, npy_intp const *, void *, int, PyObject *)) \ + PyArray_API[94]) +#define PyArray_DescrNew \ + (*(PyArray_Descr * (*)(PyArray_Descr *)) \ + PyArray_API[95]) +#define PyArray_DescrNewFromType \ + (*(PyArray_Descr * (*)(int)) \ + PyArray_API[96]) +#define PyArray_GetPriority \ + (*(double (*)(PyObject *, double)) \ + PyArray_API[97]) +#define PyArray_IterNew \ + (*(PyObject * (*)(PyObject *)) \ + PyArray_API[98]) +#define PyArray_MultiIterNew \ + (*(PyObject* (*)(int, ...)) \ + PyArray_API[99]) +#define PyArray_PyIntAsInt \ + (*(int (*)(PyObject *)) \ + PyArray_API[100]) +#define PyArray_PyIntAsIntp \ + (*(npy_intp (*)(PyObject *)) \ + PyArray_API[101]) +#define PyArray_Broadcast \ + (*(int (*)(PyArrayMultiIterObject *)) \ + PyArray_API[102]) +#define PyArray_FillWithScalar \ + (*(int (*)(PyArrayObject *, PyObject *)) \ + PyArray_API[104]) +#define PyArray_CheckStrides \ + (*(npy_bool (*)(int, int, npy_intp, npy_intp, npy_intp const *, npy_intp const *)) \ + PyArray_API[105]) +#define PyArray_DescrNewByteorder \ + (*(PyArray_Descr * (*)(PyArray_Descr *, char)) \ + PyArray_API[106]) +#define PyArray_IterAllButAxis \ + (*(PyObject * (*)(PyObject *, int *)) \ + PyArray_API[107]) +#define PyArray_CheckFromAny \ + (*(PyObject * (*)(PyObject *, PyArray_Descr *, int, int, int, PyObject *)) \ + PyArray_API[108]) +#define PyArray_FromArray \ + (*(PyObject * (*)(PyArrayObject *, PyArray_Descr *, int)) \ + PyArray_API[109]) +#define PyArray_FromInterface \ + (*(PyObject * (*)(PyObject *)) \ + PyArray_API[110]) +#define PyArray_FromStructInterface \ + (*(PyObject * (*)(PyObject *)) \ + PyArray_API[111]) +#define PyArray_FromArrayAttr \ + (*(PyObject * (*)(PyObject *, PyArray_Descr *, PyObject *)) \ + PyArray_API[112]) +#define PyArray_ScalarKind \ + (*(NPY_SCALARKIND (*)(int, PyArrayObject **)) \ + PyArray_API[113]) +#define PyArray_CanCoerceScalar \ + (*(int (*)(int, int, NPY_SCALARKIND)) \ + PyArray_API[114]) +#define PyArray_CanCastScalar \ + (*(npy_bool (*)(PyTypeObject *, PyTypeObject *)) \ + PyArray_API[116]) +#define PyArray_RemoveSmallest \ + (*(int (*)(PyArrayMultiIterObject *)) \ + PyArray_API[118]) +#define PyArray_ElementStrides \ + (*(int (*)(PyObject *)) \ + PyArray_API[119]) +#define PyArray_Item_INCREF \ + (*(void (*)(char *, PyArray_Descr *)) \ + PyArray_API[120]) +#define PyArray_Item_XDECREF \ + (*(void (*)(char *, PyArray_Descr *)) \ + PyArray_API[121]) +#define PyArray_Transpose \ + (*(PyObject * (*)(PyArrayObject *, PyArray_Dims *)) \ + PyArray_API[123]) +#define PyArray_TakeFrom \ + (*(PyObject * (*)(PyArrayObject *, PyObject *, int, PyArrayObject *, NPY_CLIPMODE)) \ + PyArray_API[124]) +#define PyArray_PutTo \ + (*(PyObject * (*)(PyArrayObject *, PyObject*, PyObject *, NPY_CLIPMODE)) \ + PyArray_API[125]) +#define PyArray_PutMask \ + (*(PyObject * (*)(PyArrayObject *, PyObject*, PyObject*)) \ + PyArray_API[126]) +#define PyArray_Repeat \ + (*(PyObject * (*)(PyArrayObject *, PyObject *, int)) \ + PyArray_API[127]) +#define PyArray_Choose \ + (*(PyObject * (*)(PyArrayObject *, PyObject *, PyArrayObject *, NPY_CLIPMODE)) \ + PyArray_API[128]) +#define PyArray_Sort \ + (*(int (*)(PyArrayObject *, int, NPY_SORTKIND)) \ + PyArray_API[129]) +#define PyArray_ArgSort \ + (*(PyObject * (*)(PyArrayObject *, int, NPY_SORTKIND)) \ + PyArray_API[130]) +#define PyArray_SearchSorted \ + (*(PyObject * (*)(PyArrayObject *, PyObject *, NPY_SEARCHSIDE, PyObject *)) \ + PyArray_API[131]) +#define PyArray_ArgMax \ + (*(PyObject * (*)(PyArrayObject *, int, PyArrayObject *)) \ + PyArray_API[132]) +#define PyArray_ArgMin \ + (*(PyObject * (*)(PyArrayObject *, int, PyArrayObject *)) \ + PyArray_API[133]) +#define PyArray_Reshape \ + (*(PyObject * (*)(PyArrayObject *, PyObject *)) \ + PyArray_API[134]) +#define PyArray_Newshape \ + (*(PyObject * (*)(PyArrayObject *, PyArray_Dims *, NPY_ORDER)) \ + PyArray_API[135]) +#define PyArray_Squeeze \ + (*(PyObject * (*)(PyArrayObject *)) \ + PyArray_API[136]) +#define PyArray_View \ + (*(PyObject * (*)(PyArrayObject *, PyArray_Descr *, PyTypeObject *)) \ + PyArray_API[137]) +#define PyArray_SwapAxes \ + (*(PyObject * (*)(PyArrayObject *, int, int)) \ + PyArray_API[138]) +#define PyArray_Max \ + (*(PyObject * (*)(PyArrayObject *, int, PyArrayObject *)) \ + PyArray_API[139]) +#define PyArray_Min \ + (*(PyObject * (*)(PyArrayObject *, int, PyArrayObject *)) \ + PyArray_API[140]) +#define PyArray_Ptp \ + (*(PyObject * (*)(PyArrayObject *, int, PyArrayObject *)) \ + PyArray_API[141]) +#define PyArray_Mean \ + (*(PyObject * (*)(PyArrayObject *, int, int, PyArrayObject *)) \ + PyArray_API[142]) +#define PyArray_Trace \ + (*(PyObject * (*)(PyArrayObject *, int, int, int, int, PyArrayObject *)) \ + PyArray_API[143]) +#define PyArray_Diagonal \ + (*(PyObject * (*)(PyArrayObject *, int, int, int)) \ + PyArray_API[144]) +#define PyArray_Clip \ + (*(PyObject * (*)(PyArrayObject *, PyObject *, PyObject *, PyArrayObject *)) \ + PyArray_API[145]) +#define PyArray_Conjugate \ + (*(PyObject * (*)(PyArrayObject *, PyArrayObject *)) \ + PyArray_API[146]) +#define PyArray_Nonzero \ + (*(PyObject * (*)(PyArrayObject *)) \ + PyArray_API[147]) +#define PyArray_Std \ + (*(PyObject * (*)(PyArrayObject *, int, int, PyArrayObject *, int)) \ + PyArray_API[148]) +#define PyArray_Sum \ + (*(PyObject * (*)(PyArrayObject *, int, int, PyArrayObject *)) \ + PyArray_API[149]) +#define PyArray_CumSum \ + (*(PyObject * (*)(PyArrayObject *, int, int, PyArrayObject *)) \ + PyArray_API[150]) +#define PyArray_Prod \ + (*(PyObject * (*)(PyArrayObject *, int, int, PyArrayObject *)) \ + PyArray_API[151]) +#define PyArray_CumProd \ + (*(PyObject * (*)(PyArrayObject *, int, int, PyArrayObject *)) \ + PyArray_API[152]) +#define PyArray_All \ + (*(PyObject * (*)(PyArrayObject *, int, PyArrayObject *)) \ + PyArray_API[153]) +#define PyArray_Any \ + (*(PyObject * (*)(PyArrayObject *, int, PyArrayObject *)) \ + PyArray_API[154]) +#define PyArray_Compress \ + (*(PyObject * (*)(PyArrayObject *, PyObject *, int, PyArrayObject *)) \ + PyArray_API[155]) +#define PyArray_Flatten \ + (*(PyObject * (*)(PyArrayObject *, NPY_ORDER)) \ + PyArray_API[156]) +#define PyArray_Ravel \ + (*(PyObject * (*)(PyArrayObject *, NPY_ORDER)) \ + PyArray_API[157]) +#define PyArray_MultiplyList \ + (*(npy_intp (*)(npy_intp const *, int)) \ + PyArray_API[158]) +#define PyArray_MultiplyIntList \ + (*(int (*)(int const *, int)) \ + PyArray_API[159]) +#define PyArray_GetPtr \ + (*(void * (*)(PyArrayObject *, npy_intp const*)) \ + PyArray_API[160]) +#define PyArray_CompareLists \ + (*(int (*)(npy_intp const *, npy_intp const *, int)) \ + PyArray_API[161]) +#define PyArray_AsCArray \ + (*(int (*)(PyObject **, void *, npy_intp *, int, PyArray_Descr*)) \ + PyArray_API[162]) +#define PyArray_Free \ + (*(int (*)(PyObject *, void *)) \ + PyArray_API[165]) +#define PyArray_Converter \ + (*(int (*)(PyObject *, PyObject **)) \ + PyArray_API[166]) +#define PyArray_IntpFromSequence \ + (*(int (*)(PyObject *, npy_intp *, int)) \ + PyArray_API[167]) +#define PyArray_Concatenate \ + (*(PyObject * (*)(PyObject *, int)) \ + PyArray_API[168]) +#define PyArray_InnerProduct \ + (*(PyObject * (*)(PyObject *, PyObject *)) \ + PyArray_API[169]) +#define PyArray_MatrixProduct \ + (*(PyObject * (*)(PyObject *, PyObject *)) \ + PyArray_API[170]) +#define PyArray_Correlate \ + (*(PyObject * (*)(PyObject *, PyObject *, int)) \ + PyArray_API[172]) +#define PyArray_DescrConverter \ + (*(int (*)(PyObject *, PyArray_Descr **)) \ + PyArray_API[174]) +#define PyArray_DescrConverter2 \ + (*(int (*)(PyObject *, PyArray_Descr **)) \ + PyArray_API[175]) +#define PyArray_IntpConverter \ + (*(int (*)(PyObject *, PyArray_Dims *)) \ + PyArray_API[176]) +#define PyArray_BufferConverter \ + (*(int (*)(PyObject *, PyArray_Chunk *)) \ + PyArray_API[177]) +#define PyArray_AxisConverter \ + (*(int (*)(PyObject *, int *)) \ + PyArray_API[178]) +#define PyArray_BoolConverter \ + (*(int (*)(PyObject *, npy_bool *)) \ + PyArray_API[179]) +#define PyArray_ByteorderConverter \ + (*(int (*)(PyObject *, char *)) \ + PyArray_API[180]) +#define PyArray_OrderConverter \ + (*(int (*)(PyObject *, NPY_ORDER *)) \ + PyArray_API[181]) +#define PyArray_EquivTypes \ + (*(unsigned char (*)(PyArray_Descr *, PyArray_Descr *)) \ + PyArray_API[182]) +#define PyArray_Zeros \ + (*(PyObject * (*)(int, npy_intp const *, PyArray_Descr *, int)) \ + PyArray_API[183]) +#define PyArray_Empty \ + (*(PyObject * (*)(int, npy_intp const *, PyArray_Descr *, int)) \ + PyArray_API[184]) +#define PyArray_Where \ + (*(PyObject * (*)(PyObject *, PyObject *, PyObject *)) \ + PyArray_API[185]) +#define PyArray_Arange \ + (*(PyObject * (*)(double, double, double, int)) \ + PyArray_API[186]) +#define PyArray_ArangeObj \ + (*(PyObject * (*)(PyObject *, PyObject *, PyObject *, PyArray_Descr *)) \ + PyArray_API[187]) +#define PyArray_SortkindConverter \ + (*(int (*)(PyObject *, NPY_SORTKIND *)) \ + PyArray_API[188]) +#define PyArray_LexSort \ + (*(PyObject * (*)(PyObject *, int)) \ + PyArray_API[189]) +#define PyArray_Round \ + (*(PyObject * (*)(PyArrayObject *, int, PyArrayObject *)) \ + PyArray_API[190]) +#define PyArray_EquivTypenums \ + (*(unsigned char (*)(int, int)) \ + PyArray_API[191]) +#define PyArray_RegisterDataType \ + (*(int (*)(PyArray_DescrProto *)) \ + PyArray_API[192]) +#define PyArray_RegisterCastFunc \ + (*(int (*)(PyArray_Descr *, int, PyArray_VectorUnaryFunc *)) \ + PyArray_API[193]) +#define PyArray_RegisterCanCast \ + (*(int (*)(PyArray_Descr *, int, NPY_SCALARKIND)) \ + PyArray_API[194]) +#define PyArray_InitArrFuncs \ + (*(void (*)(PyArray_ArrFuncs *)) \ + PyArray_API[195]) +#define PyArray_IntTupleFromIntp \ + (*(PyObject * (*)(int, npy_intp const *)) \ + PyArray_API[196]) +#define PyArray_ClipmodeConverter \ + (*(int (*)(PyObject *, NPY_CLIPMODE *)) \ + PyArray_API[198]) +#define PyArray_OutputConverter \ + (*(int (*)(PyObject *, PyArrayObject **)) \ + PyArray_API[199]) +#define PyArray_BroadcastToShape \ + (*(PyObject * (*)(PyObject *, npy_intp *, int)) \ + PyArray_API[200]) +#define PyArray_DescrAlignConverter \ + (*(int (*)(PyObject *, PyArray_Descr **)) \ + PyArray_API[203]) +#define PyArray_DescrAlignConverter2 \ + (*(int (*)(PyObject *, PyArray_Descr **)) \ + PyArray_API[204]) +#define PyArray_SearchsideConverter \ + (*(int (*)(PyObject *, void *)) \ + PyArray_API[205]) +#define PyArray_CheckAxis \ + (*(PyObject * (*)(PyArrayObject *, int *, int)) \ + PyArray_API[206]) +#define PyArray_OverflowMultiplyList \ + (*(npy_intp (*)(npy_intp const *, int)) \ + PyArray_API[207]) +#define PyArray_MultiIterFromObjects \ + (*(PyObject* (*)(PyObject **, int, int, ...)) \ + PyArray_API[209]) +#define PyArray_GetEndianness \ + (*(int (*)(void)) \ + PyArray_API[210]) +#define PyArray_GetNDArrayCFeatureVersion \ + (*(unsigned int (*)(void)) \ + PyArray_API[211]) +#define PyArray_Correlate2 \ + (*(PyObject * (*)(PyObject *, PyObject *, int)) \ + PyArray_API[212]) +#define PyArray_NeighborhoodIterNew \ + (*(PyObject* (*)(PyArrayIterObject *, const npy_intp *, int, PyArrayObject*)) \ + PyArray_API[213]) +#define PyTimeIntegerArrType_Type (*(PyTypeObject *)PyArray_API[214]) +#define PyDatetimeArrType_Type (*(PyTypeObject *)PyArray_API[215]) +#define PyTimedeltaArrType_Type (*(PyTypeObject *)PyArray_API[216]) +#define PyHalfArrType_Type (*(PyTypeObject *)PyArray_API[217]) +#define NpyIter_Type (*(PyTypeObject *)PyArray_API[218]) +#define NpyIter_New \ + (*(NpyIter * (*)(PyArrayObject *, npy_uint32, NPY_ORDER, NPY_CASTING, PyArray_Descr*)) \ + PyArray_API[224]) +#define NpyIter_MultiNew \ + (*(NpyIter * (*)(int, PyArrayObject **, npy_uint32, NPY_ORDER, NPY_CASTING, npy_uint32 *, PyArray_Descr **)) \ + PyArray_API[225]) +#define NpyIter_AdvancedNew \ + (*(NpyIter * (*)(int, PyArrayObject **, npy_uint32, NPY_ORDER, NPY_CASTING, npy_uint32 *, PyArray_Descr **, int, int **, npy_intp *, npy_intp)) \ + PyArray_API[226]) +#define NpyIter_Copy \ + (*(NpyIter * (*)(NpyIter *)) \ + PyArray_API[227]) +#define NpyIter_Deallocate \ + (*(int (*)(NpyIter *)) \ + PyArray_API[228]) +#define NpyIter_HasDelayedBufAlloc \ + (*(npy_bool (*)(NpyIter *)) \ + PyArray_API[229]) +#define NpyIter_HasExternalLoop \ + (*(npy_bool (*)(NpyIter *)) \ + PyArray_API[230]) +#define NpyIter_EnableExternalLoop \ + (*(int (*)(NpyIter *)) \ + PyArray_API[231]) +#define NpyIter_GetInnerStrideArray \ + (*(npy_intp * (*)(NpyIter *)) \ + PyArray_API[232]) +#define NpyIter_GetInnerLoopSizePtr \ + (*(npy_intp * (*)(NpyIter *)) \ + PyArray_API[233]) +#define NpyIter_Reset \ + (*(int (*)(NpyIter *, char **)) \ + PyArray_API[234]) +#define NpyIter_ResetBasePointers \ + (*(int (*)(NpyIter *, char **, char **)) \ + PyArray_API[235]) +#define NpyIter_ResetToIterIndexRange \ + (*(int (*)(NpyIter *, npy_intp, npy_intp, char **)) \ + PyArray_API[236]) +#define NpyIter_GetNDim \ + (*(int (*)(NpyIter *)) \ + PyArray_API[237]) +#define NpyIter_GetNOp \ + (*(int (*)(NpyIter *)) \ + PyArray_API[238]) +#define NpyIter_GetIterNext \ + (*(NpyIter_IterNextFunc * (*)(NpyIter *, char **)) \ + PyArray_API[239]) +#define NpyIter_GetIterSize \ + (*(npy_intp (*)(NpyIter *)) \ + PyArray_API[240]) +#define NpyIter_GetIterIndexRange \ + (*(void (*)(NpyIter *, npy_intp *, npy_intp *)) \ + PyArray_API[241]) +#define NpyIter_GetIterIndex \ + (*(npy_intp (*)(NpyIter *)) \ + PyArray_API[242]) +#define NpyIter_GotoIterIndex \ + (*(int (*)(NpyIter *, npy_intp)) \ + PyArray_API[243]) +#define NpyIter_HasMultiIndex \ + (*(npy_bool (*)(NpyIter *)) \ + PyArray_API[244]) +#define NpyIter_GetShape \ + (*(int (*)(NpyIter *, npy_intp *)) \ + PyArray_API[245]) +#define NpyIter_GetGetMultiIndex \ + (*(NpyIter_GetMultiIndexFunc * (*)(NpyIter *, char **)) \ + PyArray_API[246]) +#define NpyIter_GotoMultiIndex \ + (*(int (*)(NpyIter *, npy_intp const *)) \ + PyArray_API[247]) +#define NpyIter_RemoveMultiIndex \ + (*(int (*)(NpyIter *)) \ + PyArray_API[248]) +#define NpyIter_HasIndex \ + (*(npy_bool (*)(NpyIter *)) \ + PyArray_API[249]) +#define NpyIter_IsBuffered \ + (*(npy_bool (*)(NpyIter *)) \ + PyArray_API[250]) +#define NpyIter_IsGrowInner \ + (*(npy_bool (*)(NpyIter *)) \ + PyArray_API[251]) +#define NpyIter_GetBufferSize \ + (*(npy_intp (*)(NpyIter *)) \ + PyArray_API[252]) +#define NpyIter_GetIndexPtr \ + (*(npy_intp * (*)(NpyIter *)) \ + PyArray_API[253]) +#define NpyIter_GotoIndex \ + (*(int (*)(NpyIter *, npy_intp)) \ + PyArray_API[254]) +#define NpyIter_GetDataPtrArray \ + (*(char ** (*)(NpyIter *)) \ + PyArray_API[255]) +#define NpyIter_GetDescrArray \ + (*(PyArray_Descr ** (*)(NpyIter *)) \ + PyArray_API[256]) +#define NpyIter_GetOperandArray \ + (*(PyArrayObject ** (*)(NpyIter *)) \ + PyArray_API[257]) +#define NpyIter_GetIterView \ + (*(PyArrayObject * (*)(NpyIter *, npy_intp)) \ + PyArray_API[258]) +#define NpyIter_GetReadFlags \ + (*(void (*)(NpyIter *, char *)) \ + PyArray_API[259]) +#define NpyIter_GetWriteFlags \ + (*(void (*)(NpyIter *, char *)) \ + PyArray_API[260]) +#define NpyIter_DebugPrint \ + (*(void (*)(NpyIter *)) \ + PyArray_API[261]) +#define NpyIter_IterationNeedsAPI \ + (*(npy_bool (*)(NpyIter *)) \ + PyArray_API[262]) +#define NpyIter_GetInnerFixedStrideArray \ + (*(void (*)(NpyIter *, npy_intp *)) \ + PyArray_API[263]) +#define NpyIter_RemoveAxis \ + (*(int (*)(NpyIter *, int)) \ + PyArray_API[264]) +#define NpyIter_GetAxisStrideArray \ + (*(npy_intp * (*)(NpyIter *, int)) \ + PyArray_API[265]) +#define NpyIter_RequiresBuffering \ + (*(npy_bool (*)(NpyIter *)) \ + PyArray_API[266]) +#define NpyIter_GetInitialDataPtrArray \ + (*(char ** (*)(NpyIter *)) \ + PyArray_API[267]) +#define NpyIter_CreateCompatibleStrides \ + (*(int (*)(NpyIter *, npy_intp, npy_intp *)) \ + PyArray_API[268]) +#define PyArray_CastingConverter \ + (*(int (*)(PyObject *, NPY_CASTING *)) \ + PyArray_API[269]) +#define PyArray_CountNonzero \ + (*(npy_intp (*)(PyArrayObject *)) \ + PyArray_API[270]) +#define PyArray_PromoteTypes \ + (*(PyArray_Descr * (*)(PyArray_Descr *, PyArray_Descr *)) \ + PyArray_API[271]) +#define PyArray_MinScalarType \ + (*(PyArray_Descr * (*)(PyArrayObject *)) \ + PyArray_API[272]) +#define PyArray_ResultType \ + (*(PyArray_Descr * (*)(npy_intp, PyArrayObject *arrs[], npy_intp, PyArray_Descr *descrs[])) \ + PyArray_API[273]) +#define PyArray_CanCastArrayTo \ + (*(npy_bool (*)(PyArrayObject *, PyArray_Descr *, NPY_CASTING)) \ + PyArray_API[274]) +#define PyArray_CanCastTypeTo \ + (*(npy_bool (*)(PyArray_Descr *, PyArray_Descr *, NPY_CASTING)) \ + PyArray_API[275]) +#define PyArray_EinsteinSum \ + (*(PyArrayObject * (*)(char *, npy_intp, PyArrayObject **, PyArray_Descr *, NPY_ORDER, NPY_CASTING, PyArrayObject *)) \ + PyArray_API[276]) +#define PyArray_NewLikeArray \ + (*(PyObject * (*)(PyArrayObject *, NPY_ORDER, PyArray_Descr *, int)) \ + PyArray_API[277]) +#define PyArray_ConvertClipmodeSequence \ + (*(int (*)(PyObject *, NPY_CLIPMODE *, int)) \ + PyArray_API[279]) +#define PyArray_MatrixProduct2 \ + (*(PyObject * (*)(PyObject *, PyObject *, PyArrayObject*)) \ + PyArray_API[280]) +#define NpyIter_IsFirstVisit \ + (*(npy_bool (*)(NpyIter *, int)) \ + PyArray_API[281]) +#define PyArray_SetBaseObject \ + (*(int (*)(PyArrayObject *, PyObject *)) \ + PyArray_API[282]) +#define PyArray_CreateSortedStridePerm \ + (*(void (*)(int, npy_intp const *, npy_stride_sort_item *)) \ + PyArray_API[283]) +#define PyArray_RemoveAxesInPlace \ + (*(void (*)(PyArrayObject *, const npy_bool *)) \ + PyArray_API[284]) +#define PyArray_DebugPrint \ + (*(void (*)(PyArrayObject *)) \ + PyArray_API[285]) +#define PyArray_FailUnlessWriteable \ + (*(int (*)(PyArrayObject *, const char *)) \ + PyArray_API[286]) +#define PyArray_SetUpdateIfCopyBase \ + (*(int (*)(PyArrayObject *, PyArrayObject *)) \ + PyArray_API[287]) +#define PyDataMem_NEW \ + (*(void * (*)(size_t)) \ + PyArray_API[288]) +#define PyDataMem_FREE \ + (*(void (*)(void *)) \ + PyArray_API[289]) +#define PyDataMem_RENEW \ + (*(void * (*)(void *, size_t)) \ + PyArray_API[290]) +#define NPY_DEFAULT_ASSIGN_CASTING (*(NPY_CASTING *)PyArray_API[292]) +#define PyArray_Partition \ + (*(int (*)(PyArrayObject *, PyArrayObject *, int, NPY_SELECTKIND)) \ + PyArray_API[296]) +#define PyArray_ArgPartition \ + (*(PyObject * (*)(PyArrayObject *, PyArrayObject *, int, NPY_SELECTKIND)) \ + PyArray_API[297]) +#define PyArray_SelectkindConverter \ + (*(int (*)(PyObject *, NPY_SELECTKIND *)) \ + PyArray_API[298]) +#define PyDataMem_NEW_ZEROED \ + (*(void * (*)(size_t, size_t)) \ + PyArray_API[299]) +#define PyArray_CheckAnyScalarExact \ + (*(int (*)(PyObject *)) \ + PyArray_API[300]) +#define PyArray_ResolveWritebackIfCopy \ + (*(int (*)(PyArrayObject *)) \ + PyArray_API[302]) +#define PyArray_SetWritebackIfCopyBase \ + (*(int (*)(PyArrayObject *, PyArrayObject *)) \ + PyArray_API[303]) + +#if NPY_FEATURE_VERSION >= NPY_1_22_API_VERSION +#define PyDataMem_SetHandler \ + (*(PyObject * (*)(PyObject *)) \ + PyArray_API[304]) +#endif + +#if NPY_FEATURE_VERSION >= NPY_1_22_API_VERSION +#define PyDataMem_GetHandler \ + (*(PyObject * (*)(void)) \ + PyArray_API[305]) +#endif +#define PyDataMem_DefaultHandler (*(PyObject* *)PyArray_API[306]) + +#if NPY_FEATURE_VERSION >= NPY_2_0_API_VERSION +#define NpyDatetime_ConvertDatetime64ToDatetimeStruct \ + (*(int (*)(PyArray_DatetimeMetaData *, npy_datetime, npy_datetimestruct *)) \ + PyArray_API[307]) +#endif + +#if NPY_FEATURE_VERSION >= NPY_2_0_API_VERSION +#define NpyDatetime_ConvertDatetimeStructToDatetime64 \ + (*(int (*)(PyArray_DatetimeMetaData *, const npy_datetimestruct *, npy_datetime *)) \ + PyArray_API[308]) +#endif + +#if NPY_FEATURE_VERSION >= NPY_2_0_API_VERSION +#define NpyDatetime_ConvertPyDateTimeToDatetimeStruct \ + (*(int (*)(PyObject *, npy_datetimestruct *, NPY_DATETIMEUNIT *, int)) \ + PyArray_API[309]) +#endif + +#if NPY_FEATURE_VERSION >= NPY_2_0_API_VERSION +#define NpyDatetime_GetDatetimeISO8601StrLen \ + (*(int (*)(int, NPY_DATETIMEUNIT)) \ + PyArray_API[310]) +#endif + +#if NPY_FEATURE_VERSION >= NPY_2_0_API_VERSION +#define NpyDatetime_MakeISO8601Datetime \ + (*(int (*)(npy_datetimestruct *, char *, npy_intp, int, int, NPY_DATETIMEUNIT, int, NPY_CASTING)) \ + PyArray_API[311]) +#endif + +#if NPY_FEATURE_VERSION >= NPY_2_0_API_VERSION +#define NpyDatetime_ParseISO8601Datetime \ + (*(int (*)(char const *, Py_ssize_t, NPY_DATETIMEUNIT, NPY_CASTING, npy_datetimestruct *, NPY_DATETIMEUNIT *, npy_bool *)) \ + PyArray_API[312]) +#endif + +#if NPY_FEATURE_VERSION >= NPY_2_0_API_VERSION +#define NpyString_load \ + (*(int (*)(npy_string_allocator *, const npy_packed_static_string *, npy_static_string *)) \ + PyArray_API[313]) +#endif + +#if NPY_FEATURE_VERSION >= NPY_2_0_API_VERSION +#define NpyString_pack \ + (*(int (*)(npy_string_allocator *, npy_packed_static_string *, const char *, size_t)) \ + PyArray_API[314]) +#endif + +#if NPY_FEATURE_VERSION >= NPY_2_0_API_VERSION +#define NpyString_pack_null \ + (*(int (*)(npy_string_allocator *, npy_packed_static_string *)) \ + PyArray_API[315]) +#endif + +#if NPY_FEATURE_VERSION >= NPY_2_0_API_VERSION +#define NpyString_acquire_allocator \ + (*(npy_string_allocator * (*)(const PyArray_StringDTypeObject *)) \ + PyArray_API[316]) +#endif + +#if NPY_FEATURE_VERSION >= NPY_2_0_API_VERSION +#define NpyString_acquire_allocators \ + (*(void (*)(size_t, PyArray_Descr *const descrs[], npy_string_allocator *allocators[])) \ + PyArray_API[317]) +#endif + +#if NPY_FEATURE_VERSION >= NPY_2_0_API_VERSION +#define NpyString_release_allocator \ + (*(void (*)(npy_string_allocator *)) \ + PyArray_API[318]) +#endif + +#if NPY_FEATURE_VERSION >= NPY_2_0_API_VERSION +#define NpyString_release_allocators \ + (*(void (*)(size_t, npy_string_allocator *allocators[])) \ + PyArray_API[319]) +#endif + +#if NPY_FEATURE_VERSION >= NPY_2_0_API_VERSION +#define PyArray_GetDefaultDescr \ + (*(PyArray_Descr * (*)(PyArray_DTypeMeta *)) \ + PyArray_API[361]) +#endif + +#if NPY_FEATURE_VERSION >= NPY_2_0_API_VERSION +#define PyArrayInitDTypeMeta_FromSpec \ + (*(int (*)(PyArray_DTypeMeta *, PyArrayDTypeMeta_Spec *)) \ + PyArray_API[362]) +#endif + +#if NPY_FEATURE_VERSION >= NPY_2_0_API_VERSION +#define PyArray_CommonDType \ + (*(PyArray_DTypeMeta * (*)(PyArray_DTypeMeta *, PyArray_DTypeMeta *)) \ + PyArray_API[363]) +#endif + +#if NPY_FEATURE_VERSION >= NPY_2_0_API_VERSION +#define PyArray_PromoteDTypeSequence \ + (*(PyArray_DTypeMeta * (*)(npy_intp, PyArray_DTypeMeta **)) \ + PyArray_API[364]) +#endif +#define _PyDataType_GetArrFuncs \ + (*(PyArray_ArrFuncs * (*)(const PyArray_Descr *)) \ + PyArray_API[365]) + +/* + * The DType classes are inconvenient for the Python generation so exposed + * manually in the header below (may be moved). + */ +#include "numpy/_public_dtype_api_table.h" + +#if !defined(NO_IMPORT_ARRAY) && !defined(NO_IMPORT) +static int +_import_array(void) +{ + int st; + PyObject *numpy = PyImport_ImportModule("numpy._core._multiarray_umath"); + if (numpy == NULL && PyErr_ExceptionMatches(PyExc_ModuleNotFoundError)) { + PyErr_Clear(); + numpy = PyImport_ImportModule("numpy.core._multiarray_umath"); + } + + if (numpy == NULL) { + return -1; + } + + PyObject *c_api = PyObject_GetAttrString(numpy, "_ARRAY_API"); + Py_DECREF(numpy); + if (c_api == NULL) { + return -1; + } + + if (!PyCapsule_CheckExact(c_api)) { + PyErr_SetString(PyExc_RuntimeError, "_ARRAY_API is not PyCapsule object"); + Py_DECREF(c_api); + return -1; + } + PyArray_API = (void **)PyCapsule_GetPointer(c_api, NULL); + Py_DECREF(c_api); + if (PyArray_API == NULL) { + PyErr_SetString(PyExc_RuntimeError, "_ARRAY_API is NULL pointer"); + return -1; + } + + /* + * On exceedingly few platforms these sizes may not match, in which case + * We do not support older NumPy versions at all. + */ + if (sizeof(Py_ssize_t) != sizeof(Py_intptr_t) && + PyArray_RUNTIME_VERSION < NPY_2_0_API_VERSION) { + PyErr_Format(PyExc_RuntimeError, + "module compiled against NumPy 2.0 but running on NumPy 1.x. " + "Unfortunately, this is not supported on niche platforms where " + "`sizeof(size_t) != sizeof(inptr_t)`."); + } + /* + * Perform runtime check of C API version. As of now NumPy 2.0 is ABI + * backwards compatible (in the exposed feature subset!) for all practical + * purposes. + */ + if (NPY_VERSION < PyArray_GetNDArrayCVersion()) { + PyErr_Format(PyExc_RuntimeError, "module compiled against "\ + "ABI version 0x%x but this version of numpy is 0x%x", \ + (int) NPY_VERSION, (int) PyArray_GetNDArrayCVersion()); + return -1; + } + PyArray_RUNTIME_VERSION = (int)PyArray_GetNDArrayCFeatureVersion(); + if (NPY_FEATURE_VERSION > PyArray_RUNTIME_VERSION) { + PyErr_Format(PyExc_RuntimeError, + "module was compiled against NumPy C-API version 0x%x " + "(NumPy " NPY_FEATURE_VERSION_STRING ") " + "but the running NumPy has C-API version 0x%x. " + "Check the section C-API incompatibility at the " + "Troubleshooting ImportError section at " + "https://numpy.org/devdocs/user/troubleshooting-importerror.html" + "#c-api-incompatibility " + "for indications on how to solve this problem.", + (int)NPY_FEATURE_VERSION, PyArray_RUNTIME_VERSION); + return -1; + } + + /* + * Perform runtime check of endianness and check it matches the one set by + * the headers (npy_endian.h) as a safeguard + */ + st = PyArray_GetEndianness(); + if (st == NPY_CPU_UNKNOWN_ENDIAN) { + PyErr_SetString(PyExc_RuntimeError, + "FATAL: module compiled as unknown endian"); + return -1; + } +#if NPY_BYTE_ORDER == NPY_BIG_ENDIAN + if (st != NPY_CPU_BIG) { + PyErr_SetString(PyExc_RuntimeError, + "FATAL: module compiled as big endian, but " + "detected different endianness at runtime"); + return -1; + } +#elif NPY_BYTE_ORDER == NPY_LITTLE_ENDIAN + if (st != NPY_CPU_LITTLE) { + PyErr_SetString(PyExc_RuntimeError, + "FATAL: module compiled as little endian, but " + "detected different endianness at runtime"); + return -1; + } +#endif + + return 0; +} + +#define import_array() { \ + if (_import_array() < 0) { \ + PyErr_Print(); \ + PyErr_SetString( \ + PyExc_ImportError, \ + "numpy._core.multiarray failed to import" \ + ); \ + return NULL; \ + } \ +} + +#define import_array1(ret) { \ + if (_import_array() < 0) { \ + PyErr_Print(); \ + PyErr_SetString( \ + PyExc_ImportError, \ + "numpy._core.multiarray failed to import" \ + ); \ + return ret; \ + } \ +} + +#define import_array2(msg, ret) { \ + if (_import_array() < 0) { \ + PyErr_Print(); \ + PyErr_SetString(PyExc_ImportError, msg); \ + return ret; \ + } \ +} + +#endif + +#endif diff --git a/venv/lib/python3.12/site-packages/numpy/_core/include/numpy/__ufunc_api.c b/venv/lib/python3.12/site-packages/numpy/_core/include/numpy/__ufunc_api.c new file mode 100644 index 00000000..10fcbc45 --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/include/numpy/__ufunc_api.c @@ -0,0 +1,54 @@ + +/* These pointers will be stored in the C-object for use in other + extension modules +*/ + +void *PyUFunc_API[] = { + (void *) &PyUFunc_Type, + (void *) PyUFunc_FromFuncAndData, + (void *) PyUFunc_RegisterLoopForType, + NULL, + (void *) PyUFunc_f_f_As_d_d, + (void *) PyUFunc_d_d, + (void *) PyUFunc_f_f, + (void *) PyUFunc_g_g, + (void *) PyUFunc_F_F_As_D_D, + (void *) PyUFunc_F_F, + (void *) PyUFunc_D_D, + (void *) PyUFunc_G_G, + (void *) PyUFunc_O_O, + (void *) PyUFunc_ff_f_As_dd_d, + (void *) PyUFunc_ff_f, + (void *) PyUFunc_dd_d, + (void *) PyUFunc_gg_g, + (void *) PyUFunc_FF_F_As_DD_D, + (void *) PyUFunc_DD_D, + (void *) PyUFunc_FF_F, + (void *) PyUFunc_GG_G, + (void *) PyUFunc_OO_O, + (void *) PyUFunc_O_O_method, + (void *) PyUFunc_OO_O_method, + (void *) PyUFunc_On_Om, + NULL, + NULL, + (void *) PyUFunc_clearfperr, + (void *) PyUFunc_getfperr, + NULL, + (void *) PyUFunc_ReplaceLoopBySignature, + (void *) PyUFunc_FromFuncAndDataAndSignature, + NULL, + (void *) PyUFunc_e_e, + (void *) PyUFunc_e_e_As_f_f, + (void *) PyUFunc_e_e_As_d_d, + (void *) PyUFunc_ee_e, + (void *) PyUFunc_ee_e_As_ff_f, + (void *) PyUFunc_ee_e_As_dd_d, + (void *) PyUFunc_DefaultTypeResolver, + (void *) PyUFunc_ValidateCasting, + (void *) PyUFunc_RegisterLoopForDescr, + (void *) PyUFunc_FromFuncAndDataAndSignatureAndIdentity, + (void *) PyUFunc_AddLoopFromSpec, + (void *) PyUFunc_AddPromoter, + (void *) PyUFunc_AddWrappingLoop, + (void *) PyUFunc_GiveFloatingpointErrors +}; diff --git a/venv/lib/python3.12/site-packages/numpy/_core/include/numpy/__ufunc_api.h b/venv/lib/python3.12/site-packages/numpy/_core/include/numpy/__ufunc_api.h new file mode 100644 index 00000000..df7ded10 --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/include/numpy/__ufunc_api.h @@ -0,0 +1,340 @@ + +#ifdef _UMATHMODULE + +extern NPY_NO_EXPORT PyTypeObject PyUFunc_Type; + +extern NPY_NO_EXPORT PyTypeObject PyUFunc_Type; + +NPY_NO_EXPORT PyObject * PyUFunc_FromFuncAndData \ + (PyUFuncGenericFunction *, void *const *, const char *, int, int, int, int, const char *, const char *, int); +NPY_NO_EXPORT int PyUFunc_RegisterLoopForType \ + (PyUFuncObject *, int, PyUFuncGenericFunction, const int *, void *); +NPY_NO_EXPORT void PyUFunc_f_f_As_d_d \ + (char **, npy_intp const *, npy_intp const *, void *); +NPY_NO_EXPORT void PyUFunc_d_d \ + (char **, npy_intp const *, npy_intp const *, void *); +NPY_NO_EXPORT void PyUFunc_f_f \ + (char **, npy_intp const *, npy_intp const *, void *); +NPY_NO_EXPORT void PyUFunc_g_g \ + (char **, npy_intp const *, npy_intp const *, void *); +NPY_NO_EXPORT void PyUFunc_F_F_As_D_D \ + (char **, npy_intp const *, npy_intp const *, void *); +NPY_NO_EXPORT void PyUFunc_F_F \ + (char **, npy_intp const *, npy_intp const *, void *); +NPY_NO_EXPORT void PyUFunc_D_D \ + (char **, npy_intp const *, npy_intp const *, void *); +NPY_NO_EXPORT void PyUFunc_G_G \ + (char **, npy_intp const *, npy_intp const *, void *); +NPY_NO_EXPORT void PyUFunc_O_O \ + (char **, npy_intp const *, npy_intp const *, void *); +NPY_NO_EXPORT void PyUFunc_ff_f_As_dd_d \ + (char **, npy_intp const *, npy_intp const *, void *); +NPY_NO_EXPORT void PyUFunc_ff_f \ + (char **, npy_intp const *, npy_intp const *, void *); +NPY_NO_EXPORT void PyUFunc_dd_d \ + (char **, npy_intp const *, npy_intp const *, void *); +NPY_NO_EXPORT void PyUFunc_gg_g \ + (char **, npy_intp const *, npy_intp const *, void *); +NPY_NO_EXPORT void PyUFunc_FF_F_As_DD_D \ + (char **, npy_intp const *, npy_intp const *, void *); +NPY_NO_EXPORT void PyUFunc_DD_D \ + (char **, npy_intp const *, npy_intp const *, void *); +NPY_NO_EXPORT void PyUFunc_FF_F \ + (char **, npy_intp const *, npy_intp const *, void *); +NPY_NO_EXPORT void PyUFunc_GG_G \ + (char **, npy_intp const *, npy_intp const *, void *); +NPY_NO_EXPORT void PyUFunc_OO_O \ + (char **, npy_intp const *, npy_intp const *, void *); +NPY_NO_EXPORT void PyUFunc_O_O_method \ + (char **, npy_intp const *, npy_intp const *, void *); +NPY_NO_EXPORT void PyUFunc_OO_O_method \ + (char **, npy_intp const *, npy_intp const *, void *); +NPY_NO_EXPORT void PyUFunc_On_Om \ + (char **, npy_intp const *, npy_intp const *, void *); +NPY_NO_EXPORT void PyUFunc_clearfperr \ + (void); +NPY_NO_EXPORT int PyUFunc_getfperr \ + (void); +NPY_NO_EXPORT int PyUFunc_ReplaceLoopBySignature \ + (PyUFuncObject *, PyUFuncGenericFunction, const int *, PyUFuncGenericFunction *); +NPY_NO_EXPORT PyObject * PyUFunc_FromFuncAndDataAndSignature \ + (PyUFuncGenericFunction *, void *const *, const char *, int, int, int, int, const char *, const char *, int, const char *); +NPY_NO_EXPORT void PyUFunc_e_e \ + (char **, npy_intp const *, npy_intp const *, void *); +NPY_NO_EXPORT void PyUFunc_e_e_As_f_f \ + (char **, npy_intp const *, npy_intp const *, void *); +NPY_NO_EXPORT void PyUFunc_e_e_As_d_d \ + (char **, npy_intp const *, npy_intp const *, void *); +NPY_NO_EXPORT void PyUFunc_ee_e \ + (char **, npy_intp const *, npy_intp const *, void *); +NPY_NO_EXPORT void PyUFunc_ee_e_As_ff_f \ + (char **, npy_intp const *, npy_intp const *, void *); +NPY_NO_EXPORT void PyUFunc_ee_e_As_dd_d \ + (char **, npy_intp const *, npy_intp const *, void *); +NPY_NO_EXPORT int PyUFunc_DefaultTypeResolver \ + (PyUFuncObject *, NPY_CASTING, PyArrayObject **, PyObject *, PyArray_Descr **); +NPY_NO_EXPORT int PyUFunc_ValidateCasting \ + (PyUFuncObject *, NPY_CASTING, PyArrayObject **, PyArray_Descr *const *); +NPY_NO_EXPORT int PyUFunc_RegisterLoopForDescr \ + (PyUFuncObject *, PyArray_Descr *, PyUFuncGenericFunction, PyArray_Descr **, void *); +NPY_NO_EXPORT PyObject * PyUFunc_FromFuncAndDataAndSignatureAndIdentity \ + (PyUFuncGenericFunction *, void *const *, const char *, int, int, int, int, const char *, const char *, const int, const char *, PyObject *); +NPY_NO_EXPORT int PyUFunc_AddLoopFromSpec \ + (PyObject *, PyArrayMethod_Spec *); +NPY_NO_EXPORT int PyUFunc_AddPromoter \ + (PyObject *, PyObject *, PyObject *); +NPY_NO_EXPORT int PyUFunc_AddWrappingLoop \ + (PyObject *, PyArray_DTypeMeta *new_dtypes[], PyArray_DTypeMeta *wrapped_dtypes[], PyArrayMethod_TranslateGivenDescriptors *, PyArrayMethod_TranslateLoopDescriptors *); +NPY_NO_EXPORT int PyUFunc_GiveFloatingpointErrors \ + (const char *, int); + +#else + +#if defined(PY_UFUNC_UNIQUE_SYMBOL) +#define PyUFunc_API PY_UFUNC_UNIQUE_SYMBOL +#endif + +/* By default do not export API in an .so (was never the case on windows) */ +#ifndef NPY_API_SYMBOL_ATTRIBUTE + #define NPY_API_SYMBOL_ATTRIBUTE NPY_VISIBILITY_HIDDEN +#endif + +#if defined(NO_IMPORT) || defined(NO_IMPORT_UFUNC) +extern NPY_API_SYMBOL_ATTRIBUTE void **PyUFunc_API; +#else +#if defined(PY_UFUNC_UNIQUE_SYMBOL) +NPY_API_SYMBOL_ATTRIBUTE void **PyUFunc_API; +#else +static void **PyUFunc_API=NULL; +#endif +#endif + +#define PyUFunc_Type (*(PyTypeObject *)PyUFunc_API[0]) +#define PyUFunc_FromFuncAndData \ + (*(PyObject * (*)(PyUFuncGenericFunction *, void *const *, const char *, int, int, int, int, const char *, const char *, int)) \ + PyUFunc_API[1]) +#define PyUFunc_RegisterLoopForType \ + (*(int (*)(PyUFuncObject *, int, PyUFuncGenericFunction, const int *, void *)) \ + PyUFunc_API[2]) +#define PyUFunc_f_f_As_d_d \ + (*(void (*)(char **, npy_intp const *, npy_intp const *, void *)) \ + PyUFunc_API[4]) +#define PyUFunc_d_d \ + (*(void (*)(char **, npy_intp const *, npy_intp const *, void *)) \ + PyUFunc_API[5]) +#define PyUFunc_f_f \ + (*(void (*)(char **, npy_intp const *, npy_intp const *, void *)) \ + PyUFunc_API[6]) +#define PyUFunc_g_g \ + (*(void (*)(char **, npy_intp const *, npy_intp const *, void *)) \ + PyUFunc_API[7]) +#define PyUFunc_F_F_As_D_D \ + (*(void (*)(char **, npy_intp const *, npy_intp const *, void *)) \ + PyUFunc_API[8]) +#define PyUFunc_F_F \ + (*(void (*)(char **, npy_intp const *, npy_intp const *, void *)) \ + PyUFunc_API[9]) +#define PyUFunc_D_D \ + (*(void (*)(char **, npy_intp const *, npy_intp const *, void *)) \ + PyUFunc_API[10]) +#define PyUFunc_G_G \ + (*(void (*)(char **, npy_intp const *, npy_intp const *, void *)) \ + PyUFunc_API[11]) +#define PyUFunc_O_O \ + (*(void (*)(char **, npy_intp const *, npy_intp const *, void *)) \ + PyUFunc_API[12]) +#define PyUFunc_ff_f_As_dd_d \ + (*(void (*)(char **, npy_intp const *, npy_intp const *, void *)) \ + PyUFunc_API[13]) +#define PyUFunc_ff_f \ + (*(void (*)(char **, npy_intp const *, npy_intp const *, void *)) \ + PyUFunc_API[14]) +#define PyUFunc_dd_d \ + (*(void (*)(char **, npy_intp const *, npy_intp const *, void *)) \ + PyUFunc_API[15]) +#define PyUFunc_gg_g \ + (*(void (*)(char **, npy_intp const *, npy_intp const *, void *)) \ + PyUFunc_API[16]) +#define PyUFunc_FF_F_As_DD_D \ + (*(void (*)(char **, npy_intp const *, npy_intp const *, void *)) \ + PyUFunc_API[17]) +#define PyUFunc_DD_D \ + (*(void (*)(char **, npy_intp const *, npy_intp const *, void *)) \ + PyUFunc_API[18]) +#define PyUFunc_FF_F \ + (*(void (*)(char **, npy_intp const *, npy_intp const *, void *)) \ + PyUFunc_API[19]) +#define PyUFunc_GG_G \ + (*(void (*)(char **, npy_intp const *, npy_intp const *, void *)) \ + PyUFunc_API[20]) +#define PyUFunc_OO_O \ + (*(void (*)(char **, npy_intp const *, npy_intp const *, void *)) \ + PyUFunc_API[21]) +#define PyUFunc_O_O_method \ + (*(void (*)(char **, npy_intp const *, npy_intp const *, void *)) \ + PyUFunc_API[22]) +#define PyUFunc_OO_O_method \ + (*(void (*)(char **, npy_intp const *, npy_intp const *, void *)) \ + PyUFunc_API[23]) +#define PyUFunc_On_Om \ + (*(void (*)(char **, npy_intp const *, npy_intp const *, void *)) \ + PyUFunc_API[24]) +#define PyUFunc_clearfperr \ + (*(void (*)(void)) \ + PyUFunc_API[27]) +#define PyUFunc_getfperr \ + (*(int (*)(void)) \ + PyUFunc_API[28]) +#define PyUFunc_ReplaceLoopBySignature \ + (*(int (*)(PyUFuncObject *, PyUFuncGenericFunction, const int *, PyUFuncGenericFunction *)) \ + PyUFunc_API[30]) +#define PyUFunc_FromFuncAndDataAndSignature \ + (*(PyObject * (*)(PyUFuncGenericFunction *, void *const *, const char *, int, int, int, int, const char *, const char *, int, const char *)) \ + PyUFunc_API[31]) +#define PyUFunc_e_e \ + (*(void (*)(char **, npy_intp const *, npy_intp const *, void *)) \ + PyUFunc_API[33]) +#define PyUFunc_e_e_As_f_f \ + (*(void (*)(char **, npy_intp const *, npy_intp const *, void *)) \ + PyUFunc_API[34]) +#define PyUFunc_e_e_As_d_d \ + (*(void (*)(char **, npy_intp const *, npy_intp const *, void *)) \ + PyUFunc_API[35]) +#define PyUFunc_ee_e \ + (*(void (*)(char **, npy_intp const *, npy_intp const *, void *)) \ + PyUFunc_API[36]) +#define PyUFunc_ee_e_As_ff_f \ + (*(void (*)(char **, npy_intp const *, npy_intp const *, void *)) \ + PyUFunc_API[37]) +#define PyUFunc_ee_e_As_dd_d \ + (*(void (*)(char **, npy_intp const *, npy_intp const *, void *)) \ + PyUFunc_API[38]) +#define PyUFunc_DefaultTypeResolver \ + (*(int (*)(PyUFuncObject *, NPY_CASTING, PyArrayObject **, PyObject *, PyArray_Descr **)) \ + PyUFunc_API[39]) +#define PyUFunc_ValidateCasting \ + (*(int (*)(PyUFuncObject *, NPY_CASTING, PyArrayObject **, PyArray_Descr *const *)) \ + PyUFunc_API[40]) +#define PyUFunc_RegisterLoopForDescr \ + (*(int (*)(PyUFuncObject *, PyArray_Descr *, PyUFuncGenericFunction, PyArray_Descr **, void *)) \ + PyUFunc_API[41]) + +#if NPY_FEATURE_VERSION >= NPY_1_16_API_VERSION +#define PyUFunc_FromFuncAndDataAndSignatureAndIdentity \ + (*(PyObject * (*)(PyUFuncGenericFunction *, void *const *, const char *, int, int, int, int, const char *, const char *, const int, const char *, PyObject *)) \ + PyUFunc_API[42]) +#endif + +#if NPY_FEATURE_VERSION >= NPY_2_0_API_VERSION +#define PyUFunc_AddLoopFromSpec \ + (*(int (*)(PyObject *, PyArrayMethod_Spec *)) \ + PyUFunc_API[43]) +#endif + +#if NPY_FEATURE_VERSION >= NPY_2_0_API_VERSION +#define PyUFunc_AddPromoter \ + (*(int (*)(PyObject *, PyObject *, PyObject *)) \ + PyUFunc_API[44]) +#endif + +#if NPY_FEATURE_VERSION >= NPY_2_0_API_VERSION +#define PyUFunc_AddWrappingLoop \ + (*(int (*)(PyObject *, PyArray_DTypeMeta *new_dtypes[], PyArray_DTypeMeta *wrapped_dtypes[], PyArrayMethod_TranslateGivenDescriptors *, PyArrayMethod_TranslateLoopDescriptors *)) \ + PyUFunc_API[45]) +#endif + +#if NPY_FEATURE_VERSION >= NPY_2_0_API_VERSION +#define PyUFunc_GiveFloatingpointErrors \ + (*(int (*)(const char *, int)) \ + PyUFunc_API[46]) +#endif + +static inline int +_import_umath(void) +{ + PyObject *numpy = PyImport_ImportModule("numpy._core._multiarray_umath"); + if (numpy == NULL && PyErr_ExceptionMatches(PyExc_ModuleNotFoundError)) { + PyErr_Clear(); + numpy = PyImport_ImportModule("numpy.core._multiarray_umath"); + } + + if (numpy == NULL) { + PyErr_SetString(PyExc_ImportError, + "_multiarray_umath failed to import"); + return -1; + } + + PyObject *c_api = PyObject_GetAttrString(numpy, "_UFUNC_API"); + Py_DECREF(numpy); + if (c_api == NULL) { + PyErr_SetString(PyExc_AttributeError, "_UFUNC_API not found"); + return -1; + } + + if (!PyCapsule_CheckExact(c_api)) { + PyErr_SetString(PyExc_RuntimeError, "_UFUNC_API is not PyCapsule object"); + Py_DECREF(c_api); + return -1; + } + PyUFunc_API = (void **)PyCapsule_GetPointer(c_api, NULL); + Py_DECREF(c_api); + if (PyUFunc_API == NULL) { + PyErr_SetString(PyExc_RuntimeError, "_UFUNC_API is NULL pointer"); + return -1; + } + return 0; +} + +#define import_umath() \ + do {\ + UFUNC_NOFPE\ + if (_import_umath() < 0) {\ + PyErr_Print();\ + PyErr_SetString(PyExc_ImportError,\ + "numpy._core.umath failed to import");\ + return NULL;\ + }\ + } while(0) + +#define import_umath1(ret) \ + do {\ + UFUNC_NOFPE\ + if (_import_umath() < 0) {\ + PyErr_Print();\ + PyErr_SetString(PyExc_ImportError,\ + "numpy._core.umath failed to import");\ + return ret;\ + }\ + } while(0) + +#define import_umath2(ret, msg) \ + do {\ + UFUNC_NOFPE\ + if (_import_umath() < 0) {\ + PyErr_Print();\ + PyErr_SetString(PyExc_ImportError, msg);\ + return ret;\ + }\ + } while(0) + +#define import_ufunc() \ + do {\ + UFUNC_NOFPE\ + if (_import_umath() < 0) {\ + PyErr_Print();\ + PyErr_SetString(PyExc_ImportError,\ + "numpy._core.umath failed to import");\ + }\ + } while(0) + + +static inline int +PyUFunc_ImportUFuncAPI() +{ + if (NPY_UNLIKELY(PyUFunc_API == NULL)) { + import_umath1(-1); + } + return 0; +} + +#endif diff --git a/venv/lib/python3.12/site-packages/numpy/_core/include/numpy/_neighborhood_iterator_imp.h b/venv/lib/python3.12/site-packages/numpy/_core/include/numpy/_neighborhood_iterator_imp.h new file mode 100644 index 00000000..b365cb50 --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/include/numpy/_neighborhood_iterator_imp.h @@ -0,0 +1,90 @@ +#ifndef NUMPY_CORE_INCLUDE_NUMPY__NEIGHBORHOOD_IMP_H_ +#error You should not include this header directly +#endif +/* + * Private API (here for inline) + */ +static inline int +_PyArrayNeighborhoodIter_IncrCoord(PyArrayNeighborhoodIterObject* iter); + +/* + * Update to next item of the iterator + * + * Note: this simply increment the coordinates vector, last dimension + * incremented first , i.e, for dimension 3 + * ... + * -1, -1, -1 + * -1, -1, 0 + * -1, -1, 1 + * .... + * -1, 0, -1 + * -1, 0, 0 + * .... + * 0, -1, -1 + * 0, -1, 0 + * .... + */ +#define _UPDATE_COORD_ITER(c) \ + wb = iter->coordinates[c] < iter->bounds[c][1]; \ + if (wb) { \ + iter->coordinates[c] += 1; \ + return 0; \ + } \ + else { \ + iter->coordinates[c] = iter->bounds[c][0]; \ + } + +static inline int +_PyArrayNeighborhoodIter_IncrCoord(PyArrayNeighborhoodIterObject* iter) +{ + npy_intp i, wb; + + for (i = iter->nd - 1; i >= 0; --i) { + _UPDATE_COORD_ITER(i) + } + + return 0; +} + +/* + * Version optimized for 2d arrays, manual loop unrolling + */ +static inline int +_PyArrayNeighborhoodIter_IncrCoord2D(PyArrayNeighborhoodIterObject* iter) +{ + npy_intp wb; + + _UPDATE_COORD_ITER(1) + _UPDATE_COORD_ITER(0) + + return 0; +} +#undef _UPDATE_COORD_ITER + +/* + * Advance to the next neighbour + */ +static inline int +PyArrayNeighborhoodIter_Next(PyArrayNeighborhoodIterObject* iter) +{ + _PyArrayNeighborhoodIter_IncrCoord (iter); + iter->dataptr = iter->translate((PyArrayIterObject*)iter, iter->coordinates); + + return 0; +} + +/* + * Reset functions + */ +static inline int +PyArrayNeighborhoodIter_Reset(PyArrayNeighborhoodIterObject* iter) +{ + npy_intp i; + + for (i = 0; i < iter->nd; ++i) { + iter->coordinates[i] = iter->bounds[i][0]; + } + iter->dataptr = iter->translate((PyArrayIterObject*)iter, iter->coordinates); + + return 0; +} diff --git a/venv/lib/python3.12/site-packages/numpy/_core/include/numpy/_numpyconfig.h b/venv/lib/python3.12/site-packages/numpy/_core/include/numpy/_numpyconfig.h new file mode 100644 index 00000000..b509be3e --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/include/numpy/_numpyconfig.h @@ -0,0 +1,33 @@ +/* #undef NPY_HAVE_ENDIAN_H */ + +#define NPY_SIZEOF_SHORT 2 +#define NPY_SIZEOF_INT 4 +#define NPY_SIZEOF_LONG 8 +#define NPY_SIZEOF_FLOAT 4 +#define NPY_SIZEOF_COMPLEX_FLOAT 8 +#define NPY_SIZEOF_DOUBLE 8 +#define NPY_SIZEOF_COMPLEX_DOUBLE 16 +#define NPY_SIZEOF_LONGDOUBLE 8 +#define NPY_SIZEOF_COMPLEX_LONGDOUBLE 16 +#define NPY_SIZEOF_PY_INTPTR_T 8 +#define NPY_SIZEOF_INTP 8 +#define NPY_SIZEOF_UINTP 8 +#define NPY_SIZEOF_WCHAR_T 4 +#define NPY_SIZEOF_OFF_T 8 +#define NPY_SIZEOF_PY_LONG_LONG 8 +#define NPY_SIZEOF_LONGLONG 8 + +/* + * Defined to 1 or 0. Note that Pyodide hardcodes NPY_NO_SMP (and other defines + * in this header) for better cross-compilation, so don't rename them without a + * good reason. + */ +#define NPY_NO_SMP 0 + +#define NPY_VISIBILITY_HIDDEN __attribute__((visibility("hidden"))) +#define NPY_ABI_VERSION 0x02000000 +#define NPY_API_VERSION 0x00000013 + +#ifndef __STDC_FORMAT_MACROS +#define __STDC_FORMAT_MACROS 1 +#endif diff --git a/venv/lib/python3.12/site-packages/numpy/_core/include/numpy/_public_dtype_api_table.h b/venv/lib/python3.12/site-packages/numpy/_core/include/numpy/_public_dtype_api_table.h new file mode 100644 index 00000000..51f39054 --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/include/numpy/_public_dtype_api_table.h @@ -0,0 +1,86 @@ +/* + * Public exposure of the DType Classes. These are tricky to expose + * via the Python API, so they are exposed through this header for now. + * + * These definitions are only relevant for the public API and we reserve + * the slots 320-360 in the API table generation for this (currently). + * + * TODO: This file should be consolidated with the API table generation + * (although not sure the current generation is worth preserving). + */ +#ifndef NUMPY_CORE_INCLUDE_NUMPY__PUBLIC_DTYPE_API_TABLE_H_ +#define NUMPY_CORE_INCLUDE_NUMPY__PUBLIC_DTYPE_API_TABLE_H_ + +#if !(defined(NPY_INTERNAL_BUILD) && NPY_INTERNAL_BUILD) + +/* All of these require NumPy 2.0 support */ +#if NPY_FEATURE_VERSION >= NPY_2_0_API_VERSION + +/* + * The type of the DType metaclass + */ +#define PyArrayDTypeMeta_Type (*(PyTypeObject *)(PyArray_API + 320)[0]) +/* + * NumPy's builtin DTypes: + */ +#define PyArray_BoolDType (*(PyArray_DTypeMeta *)(PyArray_API + 320)[1]) +/* Integers */ +#define PyArray_ByteDType (*(PyArray_DTypeMeta *)(PyArray_API + 320)[2]) +#define PyArray_UByteDType (*(PyArray_DTypeMeta *)(PyArray_API + 320)[3]) +#define PyArray_ShortDType (*(PyArray_DTypeMeta *)(PyArray_API + 320)[4]) +#define PyArray_UShortDType (*(PyArray_DTypeMeta *)(PyArray_API + 320)[5]) +#define PyArray_IntDType (*(PyArray_DTypeMeta *)(PyArray_API + 320)[6]) +#define PyArray_UIntDType (*(PyArray_DTypeMeta *)(PyArray_API + 320)[7]) +#define PyArray_LongDType (*(PyArray_DTypeMeta *)(PyArray_API + 320)[8]) +#define PyArray_ULongDType (*(PyArray_DTypeMeta *)(PyArray_API + 320)[9]) +#define PyArray_LongLongDType (*(PyArray_DTypeMeta *)(PyArray_API + 320)[10]) +#define PyArray_ULongLongDType (*(PyArray_DTypeMeta *)(PyArray_API + 320)[11]) +/* Integer aliases */ +#define PyArray_Int8DType (*(PyArray_DTypeMeta *)(PyArray_API + 320)[12]) +#define PyArray_UInt8DType (*(PyArray_DTypeMeta *)(PyArray_API + 320)[13]) +#define PyArray_Int16DType (*(PyArray_DTypeMeta *)(PyArray_API + 320)[14]) +#define PyArray_UInt16DType (*(PyArray_DTypeMeta *)(PyArray_API + 320)[15]) +#define PyArray_Int32DType (*(PyArray_DTypeMeta *)(PyArray_API + 320)[16]) +#define PyArray_UInt32DType (*(PyArray_DTypeMeta *)(PyArray_API + 320)[17]) +#define PyArray_Int64DType (*(PyArray_DTypeMeta *)(PyArray_API + 320)[18]) +#define PyArray_UInt64DType (*(PyArray_DTypeMeta *)(PyArray_API + 320)[19]) +#define PyArray_IntpDType (*(PyArray_DTypeMeta *)(PyArray_API + 320)[20]) +#define PyArray_UIntpDType (*(PyArray_DTypeMeta *)(PyArray_API + 320)[21]) +/* Floats */ +#define PyArray_HalfDType (*(PyArray_DTypeMeta *)(PyArray_API + 320)[22]) +#define PyArray_FloatDType (*(PyArray_DTypeMeta *)(PyArray_API + 320)[23]) +#define PyArray_DoubleDType (*(PyArray_DTypeMeta *)(PyArray_API + 320)[24]) +#define PyArray_LongDoubleDType (*(PyArray_DTypeMeta *)(PyArray_API + 320)[25]) +/* Complex */ +#define PyArray_CFloatDType (*(PyArray_DTypeMeta *)(PyArray_API + 320)[26]) +#define PyArray_CDoubleDType (*(PyArray_DTypeMeta *)(PyArray_API + 320)[27]) +#define PyArray_CLongDoubleDType (*(PyArray_DTypeMeta *)(PyArray_API + 320)[28]) +/* String/Bytes */ +#define PyArray_BytesDType (*(PyArray_DTypeMeta *)(PyArray_API + 320)[29]) +#define PyArray_UnicodeDType (*(PyArray_DTypeMeta *)(PyArray_API + 320)[30]) +/* Datetime/Timedelta */ +#define PyArray_DatetimeDType (*(PyArray_DTypeMeta *)(PyArray_API + 320)[31]) +#define PyArray_TimedeltaDType (*(PyArray_DTypeMeta *)(PyArray_API + 320)[32]) +/* Object/Void */ +#define PyArray_ObjectDType (*(PyArray_DTypeMeta *)(PyArray_API + 320)[33]) +#define PyArray_VoidDType (*(PyArray_DTypeMeta *)(PyArray_API + 320)[34]) +/* Python types (used as markers for scalars) */ +#define PyArray_PyLongDType (*(PyArray_DTypeMeta *)(PyArray_API + 320)[35]) +#define PyArray_PyFloatDType (*(PyArray_DTypeMeta *)(PyArray_API + 320)[36]) +#define PyArray_PyComplexDType (*(PyArray_DTypeMeta *)(PyArray_API + 320)[37]) +/* Default integer type */ +#define PyArray_DefaultIntDType (*(PyArray_DTypeMeta *)(PyArray_API + 320)[38]) +/* New non-legacy DTypes follow in the order they were added */ +#define PyArray_StringDType (*(PyArray_DTypeMeta *)(PyArray_API + 320)[39]) + +/* NOTE: offset 40 is free */ + +/* Need to start with a larger offset again for the abstract classes: */ +#define PyArray_IntAbstractDType (*(PyArray_DTypeMeta *)PyArray_API[366]) +#define PyArray_FloatAbstractDType (*(PyArray_DTypeMeta *)PyArray_API[367]) +#define PyArray_ComplexAbstractDType (*(PyArray_DTypeMeta *)PyArray_API[368]) + +#endif /* NPY_FEATURE_VERSION >= NPY_2_0_API_VERSION */ + +#endif /* NPY_INTERNAL_BUILD */ +#endif /* NUMPY_CORE_INCLUDE_NUMPY__PUBLIC_DTYPE_API_TABLE_H_ */ diff --git a/venv/lib/python3.12/site-packages/numpy/_core/include/numpy/arrayobject.h b/venv/lib/python3.12/site-packages/numpy/_core/include/numpy/arrayobject.h new file mode 100644 index 00000000..97d93590 --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/include/numpy/arrayobject.h @@ -0,0 +1,7 @@ +#ifndef NUMPY_CORE_INCLUDE_NUMPY_ARRAYOBJECT_H_ +#define NUMPY_CORE_INCLUDE_NUMPY_ARRAYOBJECT_H_ +#define Py_ARRAYOBJECT_H + +#include "ndarrayobject.h" + +#endif /* NUMPY_CORE_INCLUDE_NUMPY_ARRAYOBJECT_H_ */ diff --git a/venv/lib/python3.12/site-packages/numpy/_core/include/numpy/arrayscalars.h b/venv/lib/python3.12/site-packages/numpy/_core/include/numpy/arrayscalars.h new file mode 100644 index 00000000..ff048061 --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/include/numpy/arrayscalars.h @@ -0,0 +1,196 @@ +#ifndef NUMPY_CORE_INCLUDE_NUMPY_ARRAYSCALARS_H_ +#define NUMPY_CORE_INCLUDE_NUMPY_ARRAYSCALARS_H_ + +#ifndef _MULTIARRAYMODULE +typedef struct { + PyObject_HEAD + npy_bool obval; +} PyBoolScalarObject; +#endif + + +typedef struct { + PyObject_HEAD + signed char obval; +} PyByteScalarObject; + + +typedef struct { + PyObject_HEAD + short obval; +} PyShortScalarObject; + + +typedef struct { + PyObject_HEAD + int obval; +} PyIntScalarObject; + + +typedef struct { + PyObject_HEAD + long obval; +} PyLongScalarObject; + + +typedef struct { + PyObject_HEAD + npy_longlong obval; +} PyLongLongScalarObject; + + +typedef struct { + PyObject_HEAD + unsigned char obval; +} PyUByteScalarObject; + + +typedef struct { + PyObject_HEAD + unsigned short obval; +} PyUShortScalarObject; + + +typedef struct { + PyObject_HEAD + unsigned int obval; +} PyUIntScalarObject; + + +typedef struct { + PyObject_HEAD + unsigned long obval; +} PyULongScalarObject; + + +typedef struct { + PyObject_HEAD + npy_ulonglong obval; +} PyULongLongScalarObject; + + +typedef struct { + PyObject_HEAD + npy_half obval; +} PyHalfScalarObject; + + +typedef struct { + PyObject_HEAD + float obval; +} PyFloatScalarObject; + + +typedef struct { + PyObject_HEAD + double obval; +} PyDoubleScalarObject; + + +typedef struct { + PyObject_HEAD + npy_longdouble obval; +} PyLongDoubleScalarObject; + + +typedef struct { + PyObject_HEAD + npy_cfloat obval; +} PyCFloatScalarObject; + + +typedef struct { + PyObject_HEAD + npy_cdouble obval; +} PyCDoubleScalarObject; + + +typedef struct { + PyObject_HEAD + npy_clongdouble obval; +} PyCLongDoubleScalarObject; + + +typedef struct { + PyObject_HEAD + PyObject * obval; +} PyObjectScalarObject; + +typedef struct { + PyObject_HEAD + npy_datetime obval; + PyArray_DatetimeMetaData obmeta; +} PyDatetimeScalarObject; + +typedef struct { + PyObject_HEAD + npy_timedelta obval; + PyArray_DatetimeMetaData obmeta; +} PyTimedeltaScalarObject; + + +typedef struct { + PyObject_HEAD + char obval; +} PyScalarObject; + +#define PyStringScalarObject PyBytesObject +#ifndef Py_LIMITED_API +typedef struct { + /* note that the PyObject_HEAD macro lives right here */ + PyUnicodeObject base; + Py_UCS4 *obval; + #if NPY_FEATURE_VERSION >= NPY_1_20_API_VERSION + char *buffer_fmt; + #endif +} PyUnicodeScalarObject; +#endif + + +typedef struct { + PyObject_VAR_HEAD + char *obval; +#if defined(NPY_INTERNAL_BUILD) && NPY_INTERNAL_BUILD + /* Internally use the subclass to allow accessing names/fields */ + _PyArray_LegacyDescr *descr; +#else + PyArray_Descr *descr; +#endif + int flags; + PyObject *base; + #if NPY_FEATURE_VERSION >= NPY_1_20_API_VERSION + void *_buffer_info; /* private buffer info, tagged to allow warning */ + #endif +} PyVoidScalarObject; + +/* Macros + PyScalarObject + PyArrType_Type + are defined in ndarrayobject.h +*/ + +#define PyArrayScalar_False ((PyObject *)(&(_PyArrayScalar_BoolValues[0]))) +#define PyArrayScalar_True ((PyObject *)(&(_PyArrayScalar_BoolValues[1]))) +#define PyArrayScalar_FromLong(i) \ + ((PyObject *)(&(_PyArrayScalar_BoolValues[((i)!=0)]))) +#define PyArrayScalar_RETURN_BOOL_FROM_LONG(i) \ + return Py_INCREF(PyArrayScalar_FromLong(i)), \ + PyArrayScalar_FromLong(i) +#define PyArrayScalar_RETURN_FALSE \ + return Py_INCREF(PyArrayScalar_False), \ + PyArrayScalar_False +#define PyArrayScalar_RETURN_TRUE \ + return Py_INCREF(PyArrayScalar_True), \ + PyArrayScalar_True + +#define PyArrayScalar_New(cls) \ + Py##cls##ArrType_Type.tp_alloc(&Py##cls##ArrType_Type, 0) +#ifndef Py_LIMITED_API +/* For the limited API, use PyArray_ScalarAsCtype instead */ +#define PyArrayScalar_VAL(obj, cls) \ + ((Py##cls##ScalarObject *)obj)->obval +#define PyArrayScalar_ASSIGN(obj, cls, val) \ + PyArrayScalar_VAL(obj, cls) = val +#endif + +#endif /* NUMPY_CORE_INCLUDE_NUMPY_ARRAYSCALARS_H_ */ diff --git a/venv/lib/python3.12/site-packages/numpy/_core/include/numpy/dtype_api.h b/venv/lib/python3.12/site-packages/numpy/_core/include/numpy/dtype_api.h new file mode 100644 index 00000000..9dd3effa --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/include/numpy/dtype_api.h @@ -0,0 +1,479 @@ +/* + * The public DType API + */ + +#ifndef NUMPY_CORE_INCLUDE_NUMPY___DTYPE_API_H_ +#define NUMPY_CORE_INCLUDE_NUMPY___DTYPE_API_H_ + +struct PyArrayMethodObject_tag; + +/* + * Largely opaque struct for DType classes (i.e. metaclass instances). + * The internal definition is currently in `ndarraytypes.h` (export is a bit + * more complex because `PyArray_Descr` is a DTypeMeta internally but not + * externally). + */ +#if !(defined(NPY_INTERNAL_BUILD) && NPY_INTERNAL_BUILD) + +#ifndef Py_LIMITED_API + + typedef struct PyArray_DTypeMeta_tag { + PyHeapTypeObject super; + + /* + * Most DTypes will have a singleton default instance, for the + * parametric legacy DTypes (bytes, string, void, datetime) this + * may be a pointer to the *prototype* instance? + */ + PyArray_Descr *singleton; + /* Copy of the legacy DTypes type number, usually invalid. */ + int type_num; + + /* The type object of the scalar instances (may be NULL?) */ + PyTypeObject *scalar_type; + /* + * DType flags to signal legacy, parametric, or + * abstract. But plenty of space for additional information/flags. + */ + npy_uint64 flags; + + /* + * Use indirection in order to allow a fixed size for this struct. + * A stable ABI size makes creating a static DType less painful + * while also ensuring flexibility for all opaque API (with one + * indirection due the pointer lookup). + */ + void *dt_slots; + /* Allow growing (at the moment also beyond this) */ + void *reserved[3]; + } PyArray_DTypeMeta; + +#else + +typedef PyTypeObject PyArray_DTypeMeta; + +#endif /* Py_LIMITED_API */ + +#endif /* not internal build */ + +/* + * ****************************************************** + * ArrayMethod API (Casting and UFuncs) + * ****************************************************** + */ + + +typedef enum { + /* Flag for whether the GIL is required */ + NPY_METH_REQUIRES_PYAPI = 1 << 0, + /* + * Some functions cannot set floating point error flags, this flag + * gives us the option (not requirement) to skip floating point error + * setup/check. No function should set error flags and ignore them + * since it would interfere with chaining operations (e.g. casting). + */ + NPY_METH_NO_FLOATINGPOINT_ERRORS = 1 << 1, + /* Whether the method supports unaligned access (not runtime) */ + NPY_METH_SUPPORTS_UNALIGNED = 1 << 2, + /* + * Used for reductions to allow reordering the operation. At this point + * assume that if set, it also applies to normal operations though! + */ + NPY_METH_IS_REORDERABLE = 1 << 3, + /* + * Private flag for now for *logic* functions. The logical functions + * `logical_or` and `logical_and` can always cast the inputs to booleans + * "safely" (because that is how the cast to bool is defined). + * @seberg: I am not sure this is the best way to handle this, so its + * private for now (also it is very limited anyway). + * There is one "exception". NA aware dtypes cannot cast to bool + * (hopefully), so the `??->?` loop should error even with this flag. + * But a second NA fallback loop will be necessary. + */ + _NPY_METH_FORCE_CAST_INPUTS = 1 << 17, + + /* All flags which can change at runtime */ + NPY_METH_RUNTIME_FLAGS = ( + NPY_METH_REQUIRES_PYAPI | + NPY_METH_NO_FLOATINGPOINT_ERRORS), +} NPY_ARRAYMETHOD_FLAGS; + + +typedef struct PyArrayMethod_Context_tag { + /* The caller, which is typically the original ufunc. May be NULL */ + PyObject *caller; + /* The method "self". Currently an opaque object. */ + struct PyArrayMethodObject_tag *method; + + /* Operand descriptors, filled in by resolve_descriptors */ + PyArray_Descr *const *descriptors; + /* Structure may grow (this is harmless for DType authors) */ +} PyArrayMethod_Context; + + +/* + * The main object for creating a new ArrayMethod. We use the typical `slots` + * mechanism used by the Python limited API (see below for the slot defs). + */ +typedef struct { + const char *name; + int nin, nout; + NPY_CASTING casting; + NPY_ARRAYMETHOD_FLAGS flags; + PyArray_DTypeMeta **dtypes; + PyType_Slot *slots; +} PyArrayMethod_Spec; + + +/* + * ArrayMethod slots + * ----------------- + * + * SLOTS IDs For the ArrayMethod creation, once fully public, IDs are fixed + * but can be deprecated and arbitrarily extended. + */ +#define _NPY_METH_resolve_descriptors_with_scalars 1 +#define NPY_METH_resolve_descriptors 2 +#define NPY_METH_get_loop 3 +#define NPY_METH_get_reduction_initial 4 +/* specific loops for constructions/default get_loop: */ +#define NPY_METH_strided_loop 5 +#define NPY_METH_contiguous_loop 6 +#define NPY_METH_unaligned_strided_loop 7 +#define NPY_METH_unaligned_contiguous_loop 8 +#define NPY_METH_contiguous_indexed_loop 9 +#define _NPY_METH_static_data 10 + + +/* + * The resolve descriptors function, must be able to handle NULL values for + * all output (but not input) `given_descrs` and fill `loop_descrs`. + * Return -1 on error or 0 if the operation is not possible without an error + * set. (This may still be in flux.) + * Otherwise must return the "casting safety", for normal functions, this is + * almost always "safe" (or even "equivalent"?). + * + * `resolve_descriptors` is optional if all output DTypes are non-parametric. + */ +typedef NPY_CASTING (PyArrayMethod_ResolveDescriptors)( + /* "method" is currently opaque (necessary e.g. to wrap Python) */ + struct PyArrayMethodObject_tag *method, + /* DTypes the method was created for */ + PyArray_DTypeMeta *const *dtypes, + /* Input descriptors (instances). Outputs may be NULL. */ + PyArray_Descr *const *given_descrs, + /* Exact loop descriptors to use, must not hold references on error */ + PyArray_Descr **loop_descrs, + npy_intp *view_offset); + + +/* + * Rarely needed, slightly more powerful version of `resolve_descriptors`. + * See also `PyArrayMethod_ResolveDescriptors` for details on shared arguments. + * + * NOTE: This function is private now as it is unclear how and what to pass + * exactly as additional information to allow dealing with the scalars. + * See also gh-24915. + */ +typedef NPY_CASTING (PyArrayMethod_ResolveDescriptorsWithScalar)( + struct PyArrayMethodObject_tag *method, + PyArray_DTypeMeta *const *dtypes, + /* Unlike above, these can have any DType and we may allow NULL. */ + PyArray_Descr *const *given_descrs, + /* + * Input scalars or NULL. Only ever passed for python scalars. + * WARNING: In some cases, a loop may be explicitly selected and the + * value passed is not available (NULL) or does not have the + * expected type. + */ + PyObject *const *input_scalars, + PyArray_Descr **loop_descrs, + npy_intp *view_offset); + + + +typedef int (PyArrayMethod_StridedLoop)(PyArrayMethod_Context *context, + char *const *data, const npy_intp *dimensions, const npy_intp *strides, + NpyAuxData *transferdata); + + +typedef int (PyArrayMethod_GetLoop)( + PyArrayMethod_Context *context, + int aligned, int move_references, + const npy_intp *strides, + PyArrayMethod_StridedLoop **out_loop, + NpyAuxData **out_transferdata, + NPY_ARRAYMETHOD_FLAGS *flags); + +/** + * Query an ArrayMethod for the initial value for use in reduction. + * + * @param context The arraymethod context, mainly to access the descriptors. + * @param reduction_is_empty Whether the reduction is empty. When it is, the + * value returned may differ. In this case it is a "default" value that + * may differ from the "identity" value normally used. For example: + * - `0.0` is the default for `sum([])`. But `-0.0` is the correct + * identity otherwise as it preserves the sign for `sum([-0.0])`. + * - We use no identity for object, but return the default of `0` and `1` + * for the empty `sum([], dtype=object)` and `prod([], dtype=object)`. + * This allows `np.sum(np.array(["a", "b"], dtype=object))` to work. + * - `-inf` or `INT_MIN` for `max` is an identity, but at least `INT_MIN` + * not a good *default* when there are no items. + * @param initial Pointer to initial data to be filled (if possible) + * + * @returns -1, 0, or 1 indicating error, no initial value, and initial being + * successfully filled. Errors must not be given where 0 is correct, NumPy + * may call this even when not strictly necessary. + */ +typedef int (PyArrayMethod_GetReductionInitial)( + PyArrayMethod_Context *context, npy_bool reduction_is_empty, + void *initial); + +/* + * The following functions are only used by the wrapping array method defined + * in umath/wrapping_array_method.c + */ + + +/* + * The function to convert the given descriptors (passed in to + * `resolve_descriptors`) and translates them for the wrapped loop. + * The new descriptors MUST be viewable with the old ones, `NULL` must be + * supported (for outputs) and should normally be forwarded. + * + * The function must clean up on error. + * + * NOTE: We currently assume that this translation gives "viewable" results. + * I.e. there is no additional casting related to the wrapping process. + * In principle that could be supported, but not sure it is useful. + * This currently also means that e.g. alignment must apply identically + * to the new dtypes. + * + * TODO: Due to the fact that `resolve_descriptors` is also used for `can_cast` + * there is no way to "pass out" the result of this function. This means + * it will be called twice for every ufunc call. + * (I am considering including `auxdata` as an "optional" parameter to + * `resolve_descriptors`, so that it can be filled there if not NULL.) + */ +typedef int (PyArrayMethod_TranslateGivenDescriptors)(int nin, int nout, + PyArray_DTypeMeta *const wrapped_dtypes[], + PyArray_Descr *const given_descrs[], PyArray_Descr *new_descrs[]); + +/** + * The function to convert the actual loop descriptors (as returned by the + * original `resolve_descriptors` function) to the ones the output array + * should use. + * This function must return "viewable" types, it must not mutate them in any + * form that would break the inner-loop logic. Does not need to support NULL. + * + * The function must clean up on error. + * + * @param nargs Number of arguments + * @param new_dtypes The DTypes of the output (usually probably not needed) + * @param given_descrs Original given_descrs to the resolver, necessary to + * fetch any information related to the new dtypes from the original. + * @param original_descrs The `loop_descrs` returned by the wrapped loop. + * @param loop_descrs The output descriptors, compatible to `original_descrs`. + * + * @returns 0 on success, -1 on failure. + */ +typedef int (PyArrayMethod_TranslateLoopDescriptors)(int nin, int nout, + PyArray_DTypeMeta *const new_dtypes[], PyArray_Descr *const given_descrs[], + PyArray_Descr *original_descrs[], PyArray_Descr *loop_descrs[]); + + + +/* + * A traverse loop working on a single array. This is similar to the general + * strided-loop function. This is designed for loops that need to visit every + * element of a single array. + * + * Currently this is used for array clearing, via the NPY_DT_get_clear_loop + * API hook, and zero-filling, via the NPY_DT_get_fill_zero_loop API hook. + * These are most useful for handling arrays storing embedded references to + * python objects or heap-allocated data. + * + * The `void *traverse_context` is passed in because we may need to pass in + * Interpreter state or similar in the future, but we don't want to pass in + * a full context (with pointers to dtypes, method, caller which all make + * no sense for a traverse function). + * + * We assume for now that this context can be just passed through in the + * the future (for structured dtypes). + * + */ +typedef int (PyArrayMethod_TraverseLoop)( + void *traverse_context, const PyArray_Descr *descr, char *data, + npy_intp size, npy_intp stride, NpyAuxData *auxdata); + + +/* + * Simplified get_loop function specific to dtype traversal + * + * It should set the flags needed for the traversal loop and set out_loop to the + * loop function, which must be a valid PyArrayMethod_TraverseLoop + * pointer. Currently this is used for zero-filling and clearing arrays storing + * embedded references. + * + */ +typedef int (PyArrayMethod_GetTraverseLoop)( + void *traverse_context, const PyArray_Descr *descr, + int aligned, npy_intp fixed_stride, + PyArrayMethod_TraverseLoop **out_loop, NpyAuxData **out_auxdata, + NPY_ARRAYMETHOD_FLAGS *flags); + + +/* + * Type of the C promoter function, which must be wrapped into a + * PyCapsule with name "numpy._ufunc_promoter". + * + * Note that currently the output dtypes are always NULL unless they are + * also part of the signature. This is an implementation detail and could + * change in the future. However, in general promoters should not have a + * need for output dtypes. + * (There are potential use-cases, these are currently unsupported.) + */ +typedef int (PyArrayMethod_PromoterFunction)(PyObject *ufunc, + PyArray_DTypeMeta *const op_dtypes[], PyArray_DTypeMeta *const signature[], + PyArray_DTypeMeta *new_op_dtypes[]); + +/* + * **************************** + * DTYPE API + * **************************** + */ + +#define NPY_DT_ABSTRACT 1 << 1 +#define NPY_DT_PARAMETRIC 1 << 2 +#define NPY_DT_NUMERIC 1 << 3 + +/* + * These correspond to slots in the NPY_DType_Slots struct and must + * be in the same order as the members of that struct. If new slots + * get added or old slots get removed NPY_NUM_DTYPE_SLOTS must also + * be updated + */ + +#define NPY_DT_discover_descr_from_pyobject 1 +// this slot is considered private because its API hasn't been decided +#define _NPY_DT_is_known_scalar_type 2 +#define NPY_DT_default_descr 3 +#define NPY_DT_common_dtype 4 +#define NPY_DT_common_instance 5 +#define NPY_DT_ensure_canonical 6 +#define NPY_DT_setitem 7 +#define NPY_DT_getitem 8 +#define NPY_DT_get_clear_loop 9 +#define NPY_DT_get_fill_zero_loop 10 +#define NPY_DT_finalize_descr 11 + +// These PyArray_ArrFunc slots will be deprecated and replaced eventually +// getitem and setitem can be defined as a performance optimization; +// by default the user dtypes call `legacy_getitem_using_DType` and +// `legacy_setitem_using_DType`, respectively. This functionality is +// only supported for basic NumPy DTypes. + + +// used to separate dtype slots from arrfuncs slots +// intended only for internal use but defined here for clarity +#define _NPY_DT_ARRFUNCS_OFFSET (1 << 10) + +// Cast is disabled +// #define NPY_DT_PyArray_ArrFuncs_cast 0 + _NPY_DT_ARRFUNCS_OFFSET + +#define NPY_DT_PyArray_ArrFuncs_getitem 1 + _NPY_DT_ARRFUNCS_OFFSET +#define NPY_DT_PyArray_ArrFuncs_setitem 2 + _NPY_DT_ARRFUNCS_OFFSET + +// Copyswap is disabled +// #define NPY_DT_PyArray_ArrFuncs_copyswapn 3 + _NPY_DT_ARRFUNCS_OFFSET +// #define NPY_DT_PyArray_ArrFuncs_copyswap 4 + _NPY_DT_ARRFUNCS_OFFSET +#define NPY_DT_PyArray_ArrFuncs_compare 5 + _NPY_DT_ARRFUNCS_OFFSET +#define NPY_DT_PyArray_ArrFuncs_argmax 6 + _NPY_DT_ARRFUNCS_OFFSET +#define NPY_DT_PyArray_ArrFuncs_dotfunc 7 + _NPY_DT_ARRFUNCS_OFFSET +#define NPY_DT_PyArray_ArrFuncs_scanfunc 8 + _NPY_DT_ARRFUNCS_OFFSET +#define NPY_DT_PyArray_ArrFuncs_fromstr 9 + _NPY_DT_ARRFUNCS_OFFSET +#define NPY_DT_PyArray_ArrFuncs_nonzero 10 + _NPY_DT_ARRFUNCS_OFFSET +#define NPY_DT_PyArray_ArrFuncs_fill 11 + _NPY_DT_ARRFUNCS_OFFSET +#define NPY_DT_PyArray_ArrFuncs_fillwithscalar 12 + _NPY_DT_ARRFUNCS_OFFSET +#define NPY_DT_PyArray_ArrFuncs_sort 13 + _NPY_DT_ARRFUNCS_OFFSET +#define NPY_DT_PyArray_ArrFuncs_argsort 14 + _NPY_DT_ARRFUNCS_OFFSET + +// Casting related slots are disabled. See +// https://github.com/numpy/numpy/pull/23173#discussion_r1101098163 +// #define NPY_DT_PyArray_ArrFuncs_castdict 15 + _NPY_DT_ARRFUNCS_OFFSET +// #define NPY_DT_PyArray_ArrFuncs_scalarkind 16 + _NPY_DT_ARRFUNCS_OFFSET +// #define NPY_DT_PyArray_ArrFuncs_cancastscalarkindto 17 + _NPY_DT_ARRFUNCS_OFFSET +// #define NPY_DT_PyArray_ArrFuncs_cancastto 18 + _NPY_DT_ARRFUNCS_OFFSET + +// These are deprecated in NumPy 1.19, so are disabled here. +// #define NPY_DT_PyArray_ArrFuncs_fastclip 19 + _NPY_DT_ARRFUNCS_OFFSET +// #define NPY_DT_PyArray_ArrFuncs_fastputmask 20 + _NPY_DT_ARRFUNCS_OFFSET +// #define NPY_DT_PyArray_ArrFuncs_fasttake 21 + _NPY_DT_ARRFUNCS_OFFSET +#define NPY_DT_PyArray_ArrFuncs_argmin 22 + _NPY_DT_ARRFUNCS_OFFSET + + +// TODO: These slots probably still need some thought, and/or a way to "grow"? +typedef struct { + PyTypeObject *typeobj; /* type of python scalar or NULL */ + int flags; /* flags, including parametric and abstract */ + /* NULL terminated cast definitions. Use NULL for the newly created DType */ + PyArrayMethod_Spec **casts; + PyType_Slot *slots; + /* Baseclass or NULL (will always subclass `np.dtype`) */ + PyTypeObject *baseclass; +} PyArrayDTypeMeta_Spec; + + +typedef PyArray_Descr *(PyArrayDTypeMeta_DiscoverDescrFromPyobject)( + PyArray_DTypeMeta *cls, PyObject *obj); + +/* + * Before making this public, we should decide whether it should pass + * the type, or allow looking at the object. A possible use-case: + * `np.array(np.array([0]), dtype=np.ndarray)` + * Could consider arrays that are not `dtype=ndarray` "scalars". + */ +typedef int (PyArrayDTypeMeta_IsKnownScalarType)( + PyArray_DTypeMeta *cls, PyTypeObject *obj); + +typedef PyArray_Descr *(PyArrayDTypeMeta_DefaultDescriptor)(PyArray_DTypeMeta *cls); +typedef PyArray_DTypeMeta *(PyArrayDTypeMeta_CommonDType)( + PyArray_DTypeMeta *dtype1, PyArray_DTypeMeta *dtype2); + + +/* + * Convenience utility for getting a reference to the DType metaclass associated + * with a dtype instance. + */ +#define NPY_DTYPE(descr) ((PyArray_DTypeMeta *)Py_TYPE(descr)) + +static inline PyArray_DTypeMeta * +NPY_DT_NewRef(PyArray_DTypeMeta *o) { + Py_INCREF((PyObject *)o); + return o; +} + + +typedef PyArray_Descr *(PyArrayDTypeMeta_CommonInstance)( + PyArray_Descr *dtype1, PyArray_Descr *dtype2); +typedef PyArray_Descr *(PyArrayDTypeMeta_EnsureCanonical)(PyArray_Descr *dtype); +/* + * Returns either a new reference to *dtype* or a new descriptor instance + * initialized with the same parameters as *dtype*. The caller cannot know + * which choice a dtype will make. This function is called just before the + * array buffer is created for a newly created array, it is not called for + * views and the descriptor returned by this function is attached to the array. + */ +typedef PyArray_Descr *(PyArrayDTypeMeta_FinalizeDescriptor)(PyArray_Descr *dtype); + +/* + * TODO: These two functions are currently only used for experimental DType + * API support. Their relation should be "reversed": NumPy should + * always use them internally. + * There are open points about "casting safety" though, e.g. setting + * elements is currently always unsafe. + */ +typedef int(PyArrayDTypeMeta_SetItem)(PyArray_Descr *, PyObject *, char *); +typedef PyObject *(PyArrayDTypeMeta_GetItem)(PyArray_Descr *, char *); + +#endif /* NUMPY_CORE_INCLUDE_NUMPY___DTYPE_API_H_ */ diff --git a/venv/lib/python3.12/site-packages/numpy/_core/include/numpy/halffloat.h b/venv/lib/python3.12/site-packages/numpy/_core/include/numpy/halffloat.h new file mode 100644 index 00000000..95040166 --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/include/numpy/halffloat.h @@ -0,0 +1,70 @@ +#ifndef NUMPY_CORE_INCLUDE_NUMPY_HALFFLOAT_H_ +#define NUMPY_CORE_INCLUDE_NUMPY_HALFFLOAT_H_ + +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* + * Half-precision routines + */ + +/* Conversions */ +float npy_half_to_float(npy_half h); +double npy_half_to_double(npy_half h); +npy_half npy_float_to_half(float f); +npy_half npy_double_to_half(double d); +/* Comparisons */ +int npy_half_eq(npy_half h1, npy_half h2); +int npy_half_ne(npy_half h1, npy_half h2); +int npy_half_le(npy_half h1, npy_half h2); +int npy_half_lt(npy_half h1, npy_half h2); +int npy_half_ge(npy_half h1, npy_half h2); +int npy_half_gt(npy_half h1, npy_half h2); +/* faster *_nonan variants for when you know h1 and h2 are not NaN */ +int npy_half_eq_nonan(npy_half h1, npy_half h2); +int npy_half_lt_nonan(npy_half h1, npy_half h2); +int npy_half_le_nonan(npy_half h1, npy_half h2); +/* Miscellaneous functions */ +int npy_half_iszero(npy_half h); +int npy_half_isnan(npy_half h); +int npy_half_isinf(npy_half h); +int npy_half_isfinite(npy_half h); +int npy_half_signbit(npy_half h); +npy_half npy_half_copysign(npy_half x, npy_half y); +npy_half npy_half_spacing(npy_half h); +npy_half npy_half_nextafter(npy_half x, npy_half y); +npy_half npy_half_divmod(npy_half x, npy_half y, npy_half *modulus); + +/* + * Half-precision constants + */ + +#define NPY_HALF_ZERO (0x0000u) +#define NPY_HALF_PZERO (0x0000u) +#define NPY_HALF_NZERO (0x8000u) +#define NPY_HALF_ONE (0x3c00u) +#define NPY_HALF_NEGONE (0xbc00u) +#define NPY_HALF_PINF (0x7c00u) +#define NPY_HALF_NINF (0xfc00u) +#define NPY_HALF_NAN (0x7e00u) + +#define NPY_MAX_HALF (0x7bffu) + +/* + * Bit-level conversions + */ + +npy_uint16 npy_floatbits_to_halfbits(npy_uint32 f); +npy_uint16 npy_doublebits_to_halfbits(npy_uint64 d); +npy_uint32 npy_halfbits_to_floatbits(npy_uint16 h); +npy_uint64 npy_halfbits_to_doublebits(npy_uint16 h); + +#ifdef __cplusplus +} +#endif + +#endif /* NUMPY_CORE_INCLUDE_NUMPY_HALFFLOAT_H_ */ diff --git a/venv/lib/python3.12/site-packages/numpy/_core/include/numpy/ndarrayobject.h b/venv/lib/python3.12/site-packages/numpy/_core/include/numpy/ndarrayobject.h new file mode 100644 index 00000000..f06bafe5 --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/include/numpy/ndarrayobject.h @@ -0,0 +1,304 @@ +/* + * DON'T INCLUDE THIS DIRECTLY. + */ +#ifndef NUMPY_CORE_INCLUDE_NUMPY_NDARRAYOBJECT_H_ +#define NUMPY_CORE_INCLUDE_NUMPY_NDARRAYOBJECT_H_ + +#ifdef __cplusplus +extern "C" { +#endif + +#include +#include "ndarraytypes.h" +#include "dtype_api.h" + +/* Includes the "function" C-API -- these are all stored in a + list of pointers --- one for each file + The two lists are concatenated into one in multiarray. + + They are available as import_array() +*/ + +#include "__multiarray_api.h" + +/* + * Include any definitions which are defined differently for 1.x and 2.x + * (Symbols only available on 2.x are not there, but rather guarded.) + */ +#include "npy_2_compat.h" + +/* C-API that requires previous API to be defined */ + +#define PyArray_DescrCheck(op) PyObject_TypeCheck(op, &PyArrayDescr_Type) + +#define PyArray_Check(op) PyObject_TypeCheck(op, &PyArray_Type) +#define PyArray_CheckExact(op) (((PyObject*)(op))->ob_type == &PyArray_Type) + +#define PyArray_HasArrayInterfaceType(op, type, context, out) \ + ((((out)=PyArray_FromStructInterface(op)) != Py_NotImplemented) || \ + (((out)=PyArray_FromInterface(op)) != Py_NotImplemented) || \ + (((out)=PyArray_FromArrayAttr(op, type, context)) != \ + Py_NotImplemented)) + +#define PyArray_HasArrayInterface(op, out) \ + PyArray_HasArrayInterfaceType(op, NULL, NULL, out) + +#define PyArray_IsZeroDim(op) (PyArray_Check(op) && \ + (PyArray_NDIM((PyArrayObject *)op) == 0)) + +#define PyArray_IsScalar(obj, cls) \ + (PyObject_TypeCheck(obj, &Py##cls##ArrType_Type)) + +#define PyArray_CheckScalar(m) (PyArray_IsScalar(m, Generic) || \ + PyArray_IsZeroDim(m)) +#define PyArray_IsPythonNumber(obj) \ + (PyFloat_Check(obj) || PyComplex_Check(obj) || \ + PyLong_Check(obj) || PyBool_Check(obj)) +#define PyArray_IsIntegerScalar(obj) (PyLong_Check(obj) \ + || PyArray_IsScalar((obj), Integer)) +#define PyArray_IsPythonScalar(obj) \ + (PyArray_IsPythonNumber(obj) || PyBytes_Check(obj) || \ + PyUnicode_Check(obj)) + +#define PyArray_IsAnyScalar(obj) \ + (PyArray_IsScalar(obj, Generic) || PyArray_IsPythonScalar(obj)) + +#define PyArray_CheckAnyScalar(obj) (PyArray_IsPythonScalar(obj) || \ + PyArray_CheckScalar(obj)) + + +#define PyArray_GETCONTIGUOUS(m) (PyArray_ISCONTIGUOUS(m) ? \ + Py_INCREF(m), (m) : \ + (PyArrayObject *)(PyArray_Copy(m))) + +#define PyArray_SAMESHAPE(a1,a2) ((PyArray_NDIM(a1) == PyArray_NDIM(a2)) && \ + PyArray_CompareLists(PyArray_DIMS(a1), \ + PyArray_DIMS(a2), \ + PyArray_NDIM(a1))) + +#define PyArray_SIZE(m) PyArray_MultiplyList(PyArray_DIMS(m), PyArray_NDIM(m)) +#define PyArray_NBYTES(m) (PyArray_ITEMSIZE(m) * PyArray_SIZE(m)) +#define PyArray_FROM_O(m) PyArray_FromAny(m, NULL, 0, 0, 0, NULL) + +#define PyArray_FROM_OF(m,flags) PyArray_CheckFromAny(m, NULL, 0, 0, flags, \ + NULL) + +#define PyArray_FROM_OT(m,type) PyArray_FromAny(m, \ + PyArray_DescrFromType(type), 0, 0, 0, NULL) + +#define PyArray_FROM_OTF(m, type, flags) \ + PyArray_FromAny(m, PyArray_DescrFromType(type), 0, 0, \ + (((flags) & NPY_ARRAY_ENSURECOPY) ? \ + ((flags) | NPY_ARRAY_DEFAULT) : (flags)), NULL) + +#define PyArray_FROMANY(m, type, min, max, flags) \ + PyArray_FromAny(m, PyArray_DescrFromType(type), min, max, \ + (((flags) & NPY_ARRAY_ENSURECOPY) ? \ + (flags) | NPY_ARRAY_DEFAULT : (flags)), NULL) + +#define PyArray_ZEROS(m, dims, type, is_f_order) \ + PyArray_Zeros(m, dims, PyArray_DescrFromType(type), is_f_order) + +#define PyArray_EMPTY(m, dims, type, is_f_order) \ + PyArray_Empty(m, dims, PyArray_DescrFromType(type), is_f_order) + +#define PyArray_FILLWBYTE(obj, val) memset(PyArray_DATA(obj), val, \ + PyArray_NBYTES(obj)) + +#define PyArray_ContiguousFromAny(op, type, min_depth, max_depth) \ + PyArray_FromAny(op, PyArray_DescrFromType(type), min_depth, \ + max_depth, NPY_ARRAY_DEFAULT, NULL) + +#define PyArray_EquivArrTypes(a1, a2) \ + PyArray_EquivTypes(PyArray_DESCR(a1), PyArray_DESCR(a2)) + +#define PyArray_EquivByteorders(b1, b2) \ + (((b1) == (b2)) || (PyArray_ISNBO(b1) == PyArray_ISNBO(b2))) + +#define PyArray_SimpleNew(nd, dims, typenum) \ + PyArray_New(&PyArray_Type, nd, dims, typenum, NULL, NULL, 0, 0, NULL) + +#define PyArray_SimpleNewFromData(nd, dims, typenum, data) \ + PyArray_New(&PyArray_Type, nd, dims, typenum, NULL, \ + data, 0, NPY_ARRAY_CARRAY, NULL) + +#define PyArray_SimpleNewFromDescr(nd, dims, descr) \ + PyArray_NewFromDescr(&PyArray_Type, descr, nd, dims, \ + NULL, NULL, 0, NULL) + +#define PyArray_ToScalar(data, arr) \ + PyArray_Scalar(data, PyArray_DESCR(arr), (PyObject *)arr) + + +/* These might be faster without the dereferencing of obj + going on inside -- of course an optimizing compiler should + inline the constants inside a for loop making it a moot point +*/ + +#define PyArray_GETPTR1(obj, i) ((void *)(PyArray_BYTES(obj) + \ + (i)*PyArray_STRIDES(obj)[0])) + +#define PyArray_GETPTR2(obj, i, j) ((void *)(PyArray_BYTES(obj) + \ + (i)*PyArray_STRIDES(obj)[0] + \ + (j)*PyArray_STRIDES(obj)[1])) + +#define PyArray_GETPTR3(obj, i, j, k) ((void *)(PyArray_BYTES(obj) + \ + (i)*PyArray_STRIDES(obj)[0] + \ + (j)*PyArray_STRIDES(obj)[1] + \ + (k)*PyArray_STRIDES(obj)[2])) + +#define PyArray_GETPTR4(obj, i, j, k, l) ((void *)(PyArray_BYTES(obj) + \ + (i)*PyArray_STRIDES(obj)[0] + \ + (j)*PyArray_STRIDES(obj)[1] + \ + (k)*PyArray_STRIDES(obj)[2] + \ + (l)*PyArray_STRIDES(obj)[3])) + +static inline void +PyArray_DiscardWritebackIfCopy(PyArrayObject *arr) +{ + PyArrayObject_fields *fa = (PyArrayObject_fields *)arr; + if (fa && fa->base) { + if (fa->flags & NPY_ARRAY_WRITEBACKIFCOPY) { + PyArray_ENABLEFLAGS((PyArrayObject*)fa->base, NPY_ARRAY_WRITEABLE); + Py_DECREF(fa->base); + fa->base = NULL; + PyArray_CLEARFLAGS(arr, NPY_ARRAY_WRITEBACKIFCOPY); + } + } +} + +#define PyArray_DESCR_REPLACE(descr) do { \ + PyArray_Descr *_new_; \ + _new_ = PyArray_DescrNew(descr); \ + Py_XDECREF(descr); \ + descr = _new_; \ + } while(0) + +/* Copy should always return contiguous array */ +#define PyArray_Copy(obj) PyArray_NewCopy(obj, NPY_CORDER) + +#define PyArray_FromObject(op, type, min_depth, max_depth) \ + PyArray_FromAny(op, PyArray_DescrFromType(type), min_depth, \ + max_depth, NPY_ARRAY_BEHAVED | \ + NPY_ARRAY_ENSUREARRAY, NULL) + +#define PyArray_ContiguousFromObject(op, type, min_depth, max_depth) \ + PyArray_FromAny(op, PyArray_DescrFromType(type), min_depth, \ + max_depth, NPY_ARRAY_DEFAULT | \ + NPY_ARRAY_ENSUREARRAY, NULL) + +#define PyArray_CopyFromObject(op, type, min_depth, max_depth) \ + PyArray_FromAny(op, PyArray_DescrFromType(type), min_depth, \ + max_depth, NPY_ARRAY_ENSURECOPY | \ + NPY_ARRAY_DEFAULT | \ + NPY_ARRAY_ENSUREARRAY, NULL) + +#define PyArray_Cast(mp, type_num) \ + PyArray_CastToType(mp, PyArray_DescrFromType(type_num), 0) + +#define PyArray_Take(ap, items, axis) \ + PyArray_TakeFrom(ap, items, axis, NULL, NPY_RAISE) + +#define PyArray_Put(ap, items, values) \ + PyArray_PutTo(ap, items, values, NPY_RAISE) + + +/* + Check to see if this key in the dictionary is the "title" + entry of the tuple (i.e. a duplicate dictionary entry in the fields + dict). +*/ + +static inline int +NPY_TITLE_KEY_check(PyObject *key, PyObject *value) +{ + PyObject *title; + if (PyTuple_Size(value) != 3) { + return 0; + } + title = PyTuple_GetItem(value, 2); + if (key == title) { + return 1; + } +#ifdef PYPY_VERSION + /* + * On PyPy, dictionary keys do not always preserve object identity. + * Fall back to comparison by value. + */ + if (PyUnicode_Check(title) && PyUnicode_Check(key)) { + return PyUnicode_Compare(title, key) == 0 ? 1 : 0; + } +#endif + return 0; +} + +/* Macro, for backward compat with "if NPY_TITLE_KEY(key, value) { ..." */ +#define NPY_TITLE_KEY(key, value) (NPY_TITLE_KEY_check((key), (value))) + +#define DEPRECATE(msg) PyErr_WarnEx(PyExc_DeprecationWarning,msg,1) +#define DEPRECATE_FUTUREWARNING(msg) PyErr_WarnEx(PyExc_FutureWarning,msg,1) + + +/* + * These macros and functions unfortunately require runtime version checks + * that are only defined in `npy_2_compat.h`. For that reasons they cannot be + * part of `ndarraytypes.h` which tries to be self contained. + */ + +static inline npy_intp +PyArray_ITEMSIZE(const PyArrayObject *arr) +{ + return PyDataType_ELSIZE(((PyArrayObject_fields *)arr)->descr); +} + +#define PyDataType_HASFIELDS(obj) (PyDataType_ISLEGACY((PyArray_Descr*)(obj)) && PyDataType_NAMES((PyArray_Descr*)(obj)) != NULL) +#define PyDataType_HASSUBARRAY(dtype) (PyDataType_ISLEGACY(dtype) && PyDataType_SUBARRAY(dtype) != NULL) +#define PyDataType_ISUNSIZED(dtype) ((dtype)->elsize == 0 && \ + !PyDataType_HASFIELDS(dtype)) + +#define PyDataType_FLAGCHK(dtype, flag) \ + ((PyDataType_FLAGS(dtype) & (flag)) == (flag)) + +#define PyDataType_REFCHK(dtype) \ + PyDataType_FLAGCHK(dtype, NPY_ITEM_REFCOUNT) + +#define NPY_BEGIN_THREADS_DESCR(dtype) \ + do {if (!(PyDataType_FLAGCHK((dtype), NPY_NEEDS_PYAPI))) \ + NPY_BEGIN_THREADS;} while (0); + +#define NPY_END_THREADS_DESCR(dtype) \ + do {if (!(PyDataType_FLAGCHK((dtype), NPY_NEEDS_PYAPI))) \ + NPY_END_THREADS; } while (0); + +#if !(defined(NPY_INTERNAL_BUILD) && NPY_INTERNAL_BUILD) +/* The internal copy of this is now defined in `dtypemeta.h` */ +/* + * `PyArray_Scalar` is the same as this function but converts will convert + * most NumPy types to Python scalars. + */ +static inline PyObject * +PyArray_GETITEM(const PyArrayObject *arr, const char *itemptr) +{ + return PyDataType_GetArrFuncs(((PyArrayObject_fields *)arr)->descr)->getitem( + (void *)itemptr, (PyArrayObject *)arr); +} + +/* + * SETITEM should only be used if it is known that the value is a scalar + * and of a type understood by the arrays dtype. + * Use `PyArray_Pack` if the value may be of a different dtype. + */ +static inline int +PyArray_SETITEM(PyArrayObject *arr, char *itemptr, PyObject *v) +{ + return PyDataType_GetArrFuncs(((PyArrayObject_fields *)arr)->descr)->setitem(v, itemptr, arr); +} +#endif /* not internal */ + + +#ifdef __cplusplus +} +#endif + + +#endif /* NUMPY_CORE_INCLUDE_NUMPY_NDARRAYOBJECT_H_ */ diff --git a/venv/lib/python3.12/site-packages/numpy/_core/include/numpy/ndarraytypes.h b/venv/lib/python3.12/site-packages/numpy/_core/include/numpy/ndarraytypes.h new file mode 100644 index 00000000..573f2693 --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/include/numpy/ndarraytypes.h @@ -0,0 +1,1925 @@ +#ifndef NUMPY_CORE_INCLUDE_NUMPY_NDARRAYTYPES_H_ +#define NUMPY_CORE_INCLUDE_NUMPY_NDARRAYTYPES_H_ + +#include "npy_common.h" +#include "npy_endian.h" +#include "npy_cpu.h" +#include "utils.h" + +#define NPY_NO_EXPORT NPY_VISIBILITY_HIDDEN + +/* Always allow threading unless it was explicitly disabled at build time */ +#if !NPY_NO_SMP + #define NPY_ALLOW_THREADS 1 +#else + #define NPY_ALLOW_THREADS 0 +#endif + +#ifndef __has_extension +#define __has_extension(x) 0 +#endif + +/* + * There are several places in the code where an array of dimensions + * is allocated statically. This is the size of that static + * allocation. + * + * The array creation itself could have arbitrary dimensions but all + * the places where static allocation is used would need to be changed + * to dynamic (including inside of several structures) + * + * As of NumPy 2.0, we strongly discourage the downstream use of NPY_MAXDIMS, + * but since auditing everything seems a big ask, define it as 64. + * A future version could: + * - Increase or remove the limit and require recompilation (like 2.0 did) + * - Deprecate or remove the macro but keep the limit (at basically any time) + */ +#define NPY_MAXDIMS 64 +/* We cannot change this as it would break ABI: */ +#define NPY_MAXDIMS_LEGACY_ITERS 32 +/* NPY_MAXARGS is version dependent and defined in npy_2_compat.h */ + +/* Used for Converter Functions "O&" code in ParseTuple */ +#define NPY_FAIL 0 +#define NPY_SUCCEED 1 + + +enum NPY_TYPES { NPY_BOOL=0, + NPY_BYTE, NPY_UBYTE, + NPY_SHORT, NPY_USHORT, + NPY_INT, NPY_UINT, + NPY_LONG, NPY_ULONG, + NPY_LONGLONG, NPY_ULONGLONG, + NPY_FLOAT, NPY_DOUBLE, NPY_LONGDOUBLE, + NPY_CFLOAT, NPY_CDOUBLE, NPY_CLONGDOUBLE, + NPY_OBJECT=17, + NPY_STRING, NPY_UNICODE, + NPY_VOID, + /* + * New 1.6 types appended, may be integrated + * into the above in 2.0. + */ + NPY_DATETIME, NPY_TIMEDELTA, NPY_HALF, + + NPY_CHAR, /* Deprecated, will raise if used */ + + /* The number of *legacy* dtypes */ + NPY_NTYPES_LEGACY=24, + + /* assign a high value to avoid changing this in the + future when new dtypes are added */ + NPY_NOTYPE=25, + + NPY_USERDEF=256, /* leave room for characters */ + + /* The number of types not including the new 1.6 types */ + NPY_NTYPES_ABI_COMPATIBLE=21, + + /* + * New DTypes which do not share the legacy layout + * (added after NumPy 2.0). VSTRING is the first of these + * we may open up a block for user-defined dtypes in the + * future. + */ + NPY_VSTRING=2056, +}; + + +/* basetype array priority */ +#define NPY_PRIORITY 0.0 + +/* default subtype priority */ +#define NPY_SUBTYPE_PRIORITY 1.0 + +/* default scalar priority */ +#define NPY_SCALAR_PRIORITY -1000000.0 + +/* How many floating point types are there (excluding half) */ +#define NPY_NUM_FLOATTYPE 3 + +/* + * These characters correspond to the array type and the struct + * module + */ + +enum NPY_TYPECHAR { + NPY_BOOLLTR = '?', + NPY_BYTELTR = 'b', + NPY_UBYTELTR = 'B', + NPY_SHORTLTR = 'h', + NPY_USHORTLTR = 'H', + NPY_INTLTR = 'i', + NPY_UINTLTR = 'I', + NPY_LONGLTR = 'l', + NPY_ULONGLTR = 'L', + NPY_LONGLONGLTR = 'q', + NPY_ULONGLONGLTR = 'Q', + NPY_HALFLTR = 'e', + NPY_FLOATLTR = 'f', + NPY_DOUBLELTR = 'd', + NPY_LONGDOUBLELTR = 'g', + NPY_CFLOATLTR = 'F', + NPY_CDOUBLELTR = 'D', + NPY_CLONGDOUBLELTR = 'G', + NPY_OBJECTLTR = 'O', + NPY_STRINGLTR = 'S', + NPY_DEPRECATED_STRINGLTR2 = 'a', + NPY_UNICODELTR = 'U', + NPY_VOIDLTR = 'V', + NPY_DATETIMELTR = 'M', + NPY_TIMEDELTALTR = 'm', + NPY_CHARLTR = 'c', + + /* + * New non-legacy DTypes + */ + NPY_VSTRINGLTR = 'T', + + /* + * Note, we removed `NPY_INTPLTR` due to changing its definition + * to 'n', rather than 'p'. On any typical platform this is the + * same integer. 'n' should be used for the `np.intp` with the same + * size as `size_t` while 'p' remains pointer sized. + * + * 'p', 'P', 'n', and 'N' are valid and defined explicitly + * in `arraytypes.c.src`. + */ + + /* + * These are for dtype 'kinds', not dtype 'typecodes' + * as the above are for. + */ + NPY_GENBOOLLTR ='b', + NPY_SIGNEDLTR = 'i', + NPY_UNSIGNEDLTR = 'u', + NPY_FLOATINGLTR = 'f', + NPY_COMPLEXLTR = 'c', + +}; + +/* + * Changing this may break Numpy API compatibility + * due to changing offsets in PyArray_ArrFuncs, so be + * careful. Here we have reused the mergesort slot for + * any kind of stable sort, the actual implementation will + * depend on the data type. + */ +typedef enum { + _NPY_SORT_UNDEFINED=-1, + NPY_QUICKSORT=0, + NPY_HEAPSORT=1, + NPY_MERGESORT=2, + NPY_STABLESORT=2, +} NPY_SORTKIND; +#define NPY_NSORTS (NPY_STABLESORT + 1) + + +typedef enum { + NPY_INTROSELECT=0 +} NPY_SELECTKIND; +#define NPY_NSELECTS (NPY_INTROSELECT + 1) + + +typedef enum { + NPY_SEARCHLEFT=0, + NPY_SEARCHRIGHT=1 +} NPY_SEARCHSIDE; +#define NPY_NSEARCHSIDES (NPY_SEARCHRIGHT + 1) + + +typedef enum { + NPY_NOSCALAR=-1, + NPY_BOOL_SCALAR, + NPY_INTPOS_SCALAR, + NPY_INTNEG_SCALAR, + NPY_FLOAT_SCALAR, + NPY_COMPLEX_SCALAR, + NPY_OBJECT_SCALAR +} NPY_SCALARKIND; +#define NPY_NSCALARKINDS (NPY_OBJECT_SCALAR + 1) + +/* For specifying array memory layout or iteration order */ +typedef enum { + /* Fortran order if inputs are all Fortran, C otherwise */ + NPY_ANYORDER=-1, + /* C order */ + NPY_CORDER=0, + /* Fortran order */ + NPY_FORTRANORDER=1, + /* An order as close to the inputs as possible */ + NPY_KEEPORDER=2 +} NPY_ORDER; + +/* For specifying allowed casting in operations which support it */ +typedef enum { + _NPY_ERROR_OCCURRED_IN_CAST = -1, + /* Only allow identical types */ + NPY_NO_CASTING=0, + /* Allow identical and byte swapped types */ + NPY_EQUIV_CASTING=1, + /* Only allow safe casts */ + NPY_SAFE_CASTING=2, + /* Allow safe casts or casts within the same kind */ + NPY_SAME_KIND_CASTING=3, + /* Allow any casts */ + NPY_UNSAFE_CASTING=4, +} NPY_CASTING; + +typedef enum { + NPY_CLIP=0, + NPY_WRAP=1, + NPY_RAISE=2 +} NPY_CLIPMODE; + +typedef enum { + NPY_VALID=0, + NPY_SAME=1, + NPY_FULL=2 +} NPY_CORRELATEMODE; + +/* The special not-a-time (NaT) value */ +#define NPY_DATETIME_NAT NPY_MIN_INT64 + +/* + * Upper bound on the length of a DATETIME ISO 8601 string + * YEAR: 21 (64-bit year) + * MONTH: 3 + * DAY: 3 + * HOURS: 3 + * MINUTES: 3 + * SECONDS: 3 + * ATTOSECONDS: 1 + 3*6 + * TIMEZONE: 5 + * NULL TERMINATOR: 1 + */ +#define NPY_DATETIME_MAX_ISO8601_STRLEN (21 + 3*5 + 1 + 3*6 + 6 + 1) + +/* The FR in the unit names stands for frequency */ +typedef enum { + /* Force signed enum type, must be -1 for code compatibility */ + NPY_FR_ERROR = -1, /* error or undetermined */ + + /* Start of valid units */ + NPY_FR_Y = 0, /* Years */ + NPY_FR_M = 1, /* Months */ + NPY_FR_W = 2, /* Weeks */ + /* Gap where 1.6 NPY_FR_B (value 3) was */ + NPY_FR_D = 4, /* Days */ + NPY_FR_h = 5, /* hours */ + NPY_FR_m = 6, /* minutes */ + NPY_FR_s = 7, /* seconds */ + NPY_FR_ms = 8, /* milliseconds */ + NPY_FR_us = 9, /* microseconds */ + NPY_FR_ns = 10, /* nanoseconds */ + NPY_FR_ps = 11, /* picoseconds */ + NPY_FR_fs = 12, /* femtoseconds */ + NPY_FR_as = 13, /* attoseconds */ + NPY_FR_GENERIC = 14 /* unbound units, can convert to anything */ +} NPY_DATETIMEUNIT; + +/* + * NOTE: With the NPY_FR_B gap for 1.6 ABI compatibility, NPY_DATETIME_NUMUNITS + * is technically one more than the actual number of units. + */ +#define NPY_DATETIME_NUMUNITS (NPY_FR_GENERIC + 1) +#define NPY_DATETIME_DEFAULTUNIT NPY_FR_GENERIC + +/* + * Business day conventions for mapping invalid business + * days to valid business days. + */ +typedef enum { + /* Go forward in time to the following business day. */ + NPY_BUSDAY_FORWARD, + NPY_BUSDAY_FOLLOWING = NPY_BUSDAY_FORWARD, + /* Go backward in time to the preceding business day. */ + NPY_BUSDAY_BACKWARD, + NPY_BUSDAY_PRECEDING = NPY_BUSDAY_BACKWARD, + /* + * Go forward in time to the following business day, unless it + * crosses a month boundary, in which case go backward + */ + NPY_BUSDAY_MODIFIEDFOLLOWING, + /* + * Go backward in time to the preceding business day, unless it + * crosses a month boundary, in which case go forward. + */ + NPY_BUSDAY_MODIFIEDPRECEDING, + /* Produce a NaT for non-business days. */ + NPY_BUSDAY_NAT, + /* Raise an exception for non-business days. */ + NPY_BUSDAY_RAISE +} NPY_BUSDAY_ROLL; + + +/************************************************************ + * NumPy Auxiliary Data for inner loops, sort functions, etc. + ************************************************************/ + +/* + * When creating an auxiliary data struct, this should always appear + * as the first member, like this: + * + * typedef struct { + * NpyAuxData base; + * double constant; + * } constant_multiplier_aux_data; + */ +typedef struct NpyAuxData_tag NpyAuxData; + +/* Function pointers for freeing or cloning auxiliary data */ +typedef void (NpyAuxData_FreeFunc) (NpyAuxData *); +typedef NpyAuxData *(NpyAuxData_CloneFunc) (NpyAuxData *); + +struct NpyAuxData_tag { + NpyAuxData_FreeFunc *free; + NpyAuxData_CloneFunc *clone; + /* To allow for a bit of expansion without breaking the ABI */ + void *reserved[2]; +}; + +/* Macros to use for freeing and cloning auxiliary data */ +#define NPY_AUXDATA_FREE(auxdata) \ + do { \ + if ((auxdata) != NULL) { \ + (auxdata)->free(auxdata); \ + } \ + } while(0) +#define NPY_AUXDATA_CLONE(auxdata) \ + ((auxdata)->clone(auxdata)) + +#define NPY_ERR(str) fprintf(stderr, #str); fflush(stderr); +#define NPY_ERR2(str) fprintf(stderr, str); fflush(stderr); + +/* +* Macros to define how array, and dimension/strides data is +* allocated. These should be made private +*/ + +#define NPY_USE_PYMEM 1 + + +#if NPY_USE_PYMEM == 1 +/* use the Raw versions which are safe to call with the GIL released */ +#define PyArray_malloc PyMem_RawMalloc +#define PyArray_free PyMem_RawFree +#define PyArray_realloc PyMem_RawRealloc +#else +#define PyArray_malloc malloc +#define PyArray_free free +#define PyArray_realloc realloc +#endif + +/* Dimensions and strides */ +#define PyDimMem_NEW(size) \ + ((npy_intp *)PyArray_malloc(size*sizeof(npy_intp))) + +#define PyDimMem_FREE(ptr) PyArray_free(ptr) + +#define PyDimMem_RENEW(ptr,size) \ + ((npy_intp *)PyArray_realloc(ptr,size*sizeof(npy_intp))) + +/* forward declaration */ +struct _PyArray_Descr; + +/* These must deal with unaligned and swapped data if necessary */ +typedef PyObject * (PyArray_GetItemFunc) (void *, void *); +typedef int (PyArray_SetItemFunc)(PyObject *, void *, void *); + +typedef void (PyArray_CopySwapNFunc)(void *, npy_intp, void *, npy_intp, + npy_intp, int, void *); + +typedef void (PyArray_CopySwapFunc)(void *, void *, int, void *); +typedef npy_bool (PyArray_NonzeroFunc)(void *, void *); + + +/* + * These assume aligned and notswapped data -- a buffer will be used + * before or contiguous data will be obtained + */ + +typedef int (PyArray_CompareFunc)(const void *, const void *, void *); +typedef int (PyArray_ArgFunc)(void*, npy_intp, npy_intp*, void *); + +typedef void (PyArray_DotFunc)(void *, npy_intp, void *, npy_intp, void *, + npy_intp, void *); + +typedef void (PyArray_VectorUnaryFunc)(void *, void *, npy_intp, void *, + void *); + +/* + * XXX the ignore argument should be removed next time the API version + * is bumped. It used to be the separator. + */ +typedef int (PyArray_ScanFunc)(FILE *fp, void *dptr, + char *ignore, struct _PyArray_Descr *); +typedef int (PyArray_FromStrFunc)(char *s, void *dptr, char **endptr, + struct _PyArray_Descr *); + +typedef int (PyArray_FillFunc)(void *, npy_intp, void *); + +typedef int (PyArray_SortFunc)(void *, npy_intp, void *); +typedef int (PyArray_ArgSortFunc)(void *, npy_intp *, npy_intp, void *); + +typedef int (PyArray_FillWithScalarFunc)(void *, npy_intp, void *, void *); + +typedef int (PyArray_ScalarKindFunc)(void *); + +typedef struct { + npy_intp *ptr; + int len; +} PyArray_Dims; + +typedef struct { + /* + * Functions to cast to most other standard types + * Can have some NULL entries. The types + * DATETIME, TIMEDELTA, and HALF go into the castdict + * even though they are built-in. + */ + PyArray_VectorUnaryFunc *cast[NPY_NTYPES_ABI_COMPATIBLE]; + + /* The next four functions *cannot* be NULL */ + + /* + * Functions to get and set items with standard Python types + * -- not array scalars + */ + PyArray_GetItemFunc *getitem; + PyArray_SetItemFunc *setitem; + + /* + * Copy and/or swap data. Memory areas may not overlap + * Use memmove first if they might + */ + PyArray_CopySwapNFunc *copyswapn; + PyArray_CopySwapFunc *copyswap; + + /* + * Function to compare items + * Can be NULL + */ + PyArray_CompareFunc *compare; + + /* + * Function to select largest + * Can be NULL + */ + PyArray_ArgFunc *argmax; + + /* + * Function to compute dot product + * Can be NULL + */ + PyArray_DotFunc *dotfunc; + + /* + * Function to scan an ASCII file and + * place a single value plus possible separator + * Can be NULL + */ + PyArray_ScanFunc *scanfunc; + + /* + * Function to read a single value from a string + * and adjust the pointer; Can be NULL + */ + PyArray_FromStrFunc *fromstr; + + /* + * Function to determine if data is zero or not + * If NULL a default version is + * used at Registration time. + */ + PyArray_NonzeroFunc *nonzero; + + /* + * Used for arange. Should return 0 on success + * and -1 on failure. + * Can be NULL. + */ + PyArray_FillFunc *fill; + + /* + * Function to fill arrays with scalar values + * Can be NULL + */ + PyArray_FillWithScalarFunc *fillwithscalar; + + /* + * Sorting functions + * Can be NULL + */ + PyArray_SortFunc *sort[NPY_NSORTS]; + PyArray_ArgSortFunc *argsort[NPY_NSORTS]; + + /* + * Dictionary of additional casting functions + * PyArray_VectorUnaryFuncs + * which can be populated to support casting + * to other registered types. Can be NULL + */ + PyObject *castdict; + + /* + * Functions useful for generalizing + * the casting rules. + * Can be NULL; + */ + PyArray_ScalarKindFunc *scalarkind; + int **cancastscalarkindto; + int *cancastto; + + void *_unused1; + void *_unused2; + void *_unused3; + + /* + * Function to select smallest + * Can be NULL + */ + PyArray_ArgFunc *argmin; + +} PyArray_ArrFuncs; + + +/* The item must be reference counted when it is inserted or extracted. */ +#define NPY_ITEM_REFCOUNT 0x01 +/* Same as needing REFCOUNT */ +#define NPY_ITEM_HASOBJECT 0x01 +/* Convert to list for pickling */ +#define NPY_LIST_PICKLE 0x02 +/* The item is a POINTER */ +#define NPY_ITEM_IS_POINTER 0x04 +/* memory needs to be initialized for this data-type */ +#define NPY_NEEDS_INIT 0x08 +/* operations need Python C-API so don't give-up thread. */ +#define NPY_NEEDS_PYAPI 0x10 +/* Use f.getitem when extracting elements of this data-type */ +#define NPY_USE_GETITEM 0x20 +/* Use f.setitem when setting creating 0-d array from this data-type.*/ +#define NPY_USE_SETITEM 0x40 +/* A sticky flag specifically for structured arrays */ +#define NPY_ALIGNED_STRUCT 0x80 + +/* + *These are inherited for global data-type if any data-types in the + * field have them + */ +#define NPY_FROM_FIELDS (NPY_NEEDS_INIT | NPY_LIST_PICKLE | \ + NPY_ITEM_REFCOUNT | NPY_NEEDS_PYAPI) + +#define NPY_OBJECT_DTYPE_FLAGS (NPY_LIST_PICKLE | NPY_USE_GETITEM | \ + NPY_ITEM_IS_POINTER | NPY_ITEM_REFCOUNT | \ + NPY_NEEDS_INIT | NPY_NEEDS_PYAPI) + +#if NPY_FEATURE_VERSION >= NPY_2_0_API_VERSION +/* + * Public version of the Descriptor struct as of 2.x + */ +typedef struct _PyArray_Descr { + PyObject_HEAD + /* + * the type object representing an + * instance of this type -- should not + * be two type_numbers with the same type + * object. + */ + PyTypeObject *typeobj; + /* kind for this type */ + char kind; + /* unique-character representing this type */ + char type; + /* + * '>' (big), '<' (little), '|' + * (not-applicable), or '=' (native). + */ + char byteorder; + /* Former flags flags space (unused) to ensure type_num is stable. */ + char _former_flags; + /* number representing this type */ + int type_num; + /* Space for dtype instance specific flags. */ + npy_uint64 flags; + /* element size (itemsize) for this type */ + npy_intp elsize; + /* alignment needed for this type */ + npy_intp alignment; + /* metadata dict or NULL */ + PyObject *metadata; + /* Cached hash value (-1 if not yet computed). */ + npy_hash_t hash; + /* Unused slot (must be initialized to NULL) for future use */ + void *reserved_null[2]; +} PyArray_Descr; + +#else /* 1.x and 2.x compatible version (only shared fields): */ + +typedef struct _PyArray_Descr { + PyObject_HEAD + PyTypeObject *typeobj; + char kind; + char type; + char byteorder; + char _former_flags; + int type_num; +} PyArray_Descr; + +/* To access modified fields, define the full 2.0 struct: */ +typedef struct { + PyObject_HEAD + PyTypeObject *typeobj; + char kind; + char type; + char byteorder; + char _former_flags; + int type_num; + npy_uint64 flags; + npy_intp elsize; + npy_intp alignment; + PyObject *metadata; + npy_hash_t hash; + void *reserved_null[2]; +} _PyArray_DescrNumPy2; + +#endif /* 1.x and 2.x compatible version */ + +/* + * Semi-private struct with additional field of legacy descriptors (must + * check NPY_DT_is_legacy before casting/accessing). The struct is also not + * valid when running on 1.x (i.e. in public API use). + */ +typedef struct { + PyObject_HEAD + PyTypeObject *typeobj; + char kind; + char type; + char byteorder; + char _former_flags; + int type_num; + npy_uint64 flags; + npy_intp elsize; + npy_intp alignment; + PyObject *metadata; + npy_hash_t hash; + void *reserved_null[2]; + struct _arr_descr *subarray; + PyObject *fields; + PyObject *names; + NpyAuxData *c_metadata; +} _PyArray_LegacyDescr; + + +/* + * Umodified PyArray_Descr struct identical to NumPy 1.x. This struct is + * used as a prototype for registering a new legacy DType. + * It is also used to access the fields in user code running on 1.x. + */ +typedef struct { + PyObject_HEAD + PyTypeObject *typeobj; + char kind; + char type; + char byteorder; + char flags; + int type_num; + int elsize; + int alignment; + struct _arr_descr *subarray; + PyObject *fields; + PyObject *names; + PyArray_ArrFuncs *f; + PyObject *metadata; + NpyAuxData *c_metadata; + npy_hash_t hash; +} PyArray_DescrProto; + + +typedef struct _arr_descr { + PyArray_Descr *base; + PyObject *shape; /* a tuple */ +} PyArray_ArrayDescr; + +/* + * Memory handler structure for array data. + */ +/* The declaration of free differs from PyMemAllocatorEx */ +typedef struct { + void *ctx; + void* (*malloc) (void *ctx, size_t size); + void* (*calloc) (void *ctx, size_t nelem, size_t elsize); + void* (*realloc) (void *ctx, void *ptr, size_t new_size); + void (*free) (void *ctx, void *ptr, size_t size); + /* + * This is the end of the version=1 struct. Only add new fields after + * this line + */ +} PyDataMemAllocator; + +typedef struct { + char name[127]; /* multiple of 64 to keep the struct aligned */ + uint8_t version; /* currently 1 */ + PyDataMemAllocator allocator; +} PyDataMem_Handler; + + +/* + * The main array object structure. + * + * It has been recommended to use the inline functions defined below + * (PyArray_DATA and friends) to access fields here for a number of + * releases. Direct access to the members themselves is deprecated. + * To ensure that your code does not use deprecated access, + * #define NPY_NO_DEPRECATED_API NPY_1_7_API_VERSION + * (or NPY_1_8_API_VERSION or higher as required). + */ +/* This struct will be moved to a private header in a future release */ +typedef struct tagPyArrayObject_fields { + PyObject_HEAD + /* Pointer to the raw data buffer */ + char *data; + /* The number of dimensions, also called 'ndim' */ + int nd; + /* The size in each dimension, also called 'shape' */ + npy_intp *dimensions; + /* + * Number of bytes to jump to get to the + * next element in each dimension + */ + npy_intp *strides; + /* + * This object is decref'd upon + * deletion of array. Except in the + * case of WRITEBACKIFCOPY which has + * special handling. + * + * For views it points to the original + * array, collapsed so no chains of + * views occur. + * + * For creation from buffer object it + * points to an object that should be + * decref'd on deletion + * + * For WRITEBACKIFCOPY flag this is an + * array to-be-updated upon calling + * PyArray_ResolveWritebackIfCopy + */ + PyObject *base; + /* Pointer to type structure */ + PyArray_Descr *descr; + /* Flags describing array -- see below */ + int flags; + /* For weak references */ + PyObject *weakreflist; +#if NPY_FEATURE_VERSION >= NPY_1_20_API_VERSION + void *_buffer_info; /* private buffer info, tagged to allow warning */ +#endif + /* + * For malloc/calloc/realloc/free per object + */ +#if NPY_FEATURE_VERSION >= NPY_1_22_API_VERSION + PyObject *mem_handler; +#endif +} PyArrayObject_fields; + +/* + * To hide the implementation details, we only expose + * the Python struct HEAD. + */ +#if !defined(NPY_NO_DEPRECATED_API) || \ + (NPY_NO_DEPRECATED_API < NPY_1_7_API_VERSION) +/* + * Can't put this in npy_deprecated_api.h like the others. + * PyArrayObject field access is deprecated as of NumPy 1.7. + */ +typedef PyArrayObject_fields PyArrayObject; +#else +typedef struct tagPyArrayObject { + PyObject_HEAD +} PyArrayObject; +#endif + +/* + * Removed 2020-Nov-25, NumPy 1.20 + * #define NPY_SIZEOF_PYARRAYOBJECT (sizeof(PyArrayObject_fields)) + * + * The above macro was removed as it gave a false sense of a stable ABI + * with respect to the structures size. If you require a runtime constant, + * you can use `PyArray_Type.tp_basicsize` instead. Otherwise, please + * see the PyArrayObject documentation or ask the NumPy developers for + * information on how to correctly replace the macro in a way that is + * compatible with multiple NumPy versions. + */ + +/* Mirrors buffer object to ptr */ + +typedef struct { + PyObject_HEAD + PyObject *base; + void *ptr; + npy_intp len; + int flags; +} PyArray_Chunk; + +typedef struct { + NPY_DATETIMEUNIT base; + int num; +} PyArray_DatetimeMetaData; + +typedef struct { + NpyAuxData base; + PyArray_DatetimeMetaData meta; +} PyArray_DatetimeDTypeMetaData; + +/* + * This structure contains an exploded view of a date-time value. + * NaT is represented by year == NPY_DATETIME_NAT. + */ +typedef struct { + npy_int64 year; + npy_int32 month, day, hour, min, sec, us, ps, as; +} npy_datetimestruct; + +/* This is not used internally. */ +typedef struct { + npy_int64 day; + npy_int32 sec, us, ps, as; +} npy_timedeltastruct; + +typedef int (PyArray_FinalizeFunc)(PyArrayObject *, PyObject *); + +/* + * Means c-style contiguous (last index varies the fastest). The data + * elements right after each other. + * + * This flag may be requested in constructor functions. + * This flag may be tested for in PyArray_FLAGS(arr). + */ +#define NPY_ARRAY_C_CONTIGUOUS 0x0001 + +/* + * Set if array is a contiguous Fortran array: the first index varies + * the fastest in memory (strides array is reverse of C-contiguous + * array) + * + * This flag may be requested in constructor functions. + * This flag may be tested for in PyArray_FLAGS(arr). + */ +#define NPY_ARRAY_F_CONTIGUOUS 0x0002 + +/* + * Note: all 0-d arrays are C_CONTIGUOUS and F_CONTIGUOUS. If a + * 1-d array is C_CONTIGUOUS it is also F_CONTIGUOUS. Arrays with + * more then one dimension can be C_CONTIGUOUS and F_CONTIGUOUS + * at the same time if they have either zero or one element. + * A higher dimensional array always has the same contiguity flags as + * `array.squeeze()`; dimensions with `array.shape[dimension] == 1` are + * effectively ignored when checking for contiguity. + */ + +/* + * If set, the array owns the data: it will be free'd when the array + * is deleted. + * + * This flag may be tested for in PyArray_FLAGS(arr). + */ +#define NPY_ARRAY_OWNDATA 0x0004 + +/* + * An array never has the next four set; they're only used as parameter + * flags to the various FromAny functions + * + * This flag may be requested in constructor functions. + */ + +/* Cause a cast to occur regardless of whether or not it is safe. */ +#define NPY_ARRAY_FORCECAST 0x0010 + +/* + * Always copy the array. Returned arrays are always CONTIGUOUS, + * ALIGNED, and WRITEABLE. See also: NPY_ARRAY_ENSURENOCOPY = 0x4000. + * + * This flag may be requested in constructor functions. + */ +#define NPY_ARRAY_ENSURECOPY 0x0020 + +/* + * Make sure the returned array is a base-class ndarray + * + * This flag may be requested in constructor functions. + */ +#define NPY_ARRAY_ENSUREARRAY 0x0040 + +/* + * Make sure that the strides are in units of the element size Needed + * for some operations with record-arrays. + * + * This flag may be requested in constructor functions. + */ +#define NPY_ARRAY_ELEMENTSTRIDES 0x0080 + +/* + * Array data is aligned on the appropriate memory address for the type + * stored according to how the compiler would align things (e.g., an + * array of integers (4 bytes each) starts on a memory address that's + * a multiple of 4) + * + * This flag may be requested in constructor functions. + * This flag may be tested for in PyArray_FLAGS(arr). + */ +#define NPY_ARRAY_ALIGNED 0x0100 + +/* + * Array data has the native endianness + * + * This flag may be requested in constructor functions. + */ +#define NPY_ARRAY_NOTSWAPPED 0x0200 + +/* + * Array data is writeable + * + * This flag may be requested in constructor functions. + * This flag may be tested for in PyArray_FLAGS(arr). + */ +#define NPY_ARRAY_WRITEABLE 0x0400 + +/* + * If this flag is set, then base contains a pointer to an array of + * the same size that should be updated with the current contents of + * this array when PyArray_ResolveWritebackIfCopy is called. + * + * This flag may be requested in constructor functions. + * This flag may be tested for in PyArray_FLAGS(arr). + */ +#define NPY_ARRAY_WRITEBACKIFCOPY 0x2000 + +/* + * No copy may be made while converting from an object/array (result is a view) + * + * This flag may be requested in constructor functions. + */ +#define NPY_ARRAY_ENSURENOCOPY 0x4000 + +/* + * NOTE: there are also internal flags defined in multiarray/arrayobject.h, + * which start at bit 31 and work down. + */ + +#define NPY_ARRAY_BEHAVED (NPY_ARRAY_ALIGNED | \ + NPY_ARRAY_WRITEABLE) +#define NPY_ARRAY_BEHAVED_NS (NPY_ARRAY_ALIGNED | \ + NPY_ARRAY_WRITEABLE | \ + NPY_ARRAY_NOTSWAPPED) +#define NPY_ARRAY_CARRAY (NPY_ARRAY_C_CONTIGUOUS | \ + NPY_ARRAY_BEHAVED) +#define NPY_ARRAY_CARRAY_RO (NPY_ARRAY_C_CONTIGUOUS | \ + NPY_ARRAY_ALIGNED) +#define NPY_ARRAY_FARRAY (NPY_ARRAY_F_CONTIGUOUS | \ + NPY_ARRAY_BEHAVED) +#define NPY_ARRAY_FARRAY_RO (NPY_ARRAY_F_CONTIGUOUS | \ + NPY_ARRAY_ALIGNED) +#define NPY_ARRAY_DEFAULT (NPY_ARRAY_CARRAY) +#define NPY_ARRAY_IN_ARRAY (NPY_ARRAY_CARRAY_RO) +#define NPY_ARRAY_OUT_ARRAY (NPY_ARRAY_CARRAY) +#define NPY_ARRAY_INOUT_ARRAY (NPY_ARRAY_CARRAY) +#define NPY_ARRAY_INOUT_ARRAY2 (NPY_ARRAY_CARRAY | \ + NPY_ARRAY_WRITEBACKIFCOPY) +#define NPY_ARRAY_IN_FARRAY (NPY_ARRAY_FARRAY_RO) +#define NPY_ARRAY_OUT_FARRAY (NPY_ARRAY_FARRAY) +#define NPY_ARRAY_INOUT_FARRAY (NPY_ARRAY_FARRAY) +#define NPY_ARRAY_INOUT_FARRAY2 (NPY_ARRAY_FARRAY | \ + NPY_ARRAY_WRITEBACKIFCOPY) + +#define NPY_ARRAY_UPDATE_ALL (NPY_ARRAY_C_CONTIGUOUS | \ + NPY_ARRAY_F_CONTIGUOUS | \ + NPY_ARRAY_ALIGNED) + +/* This flag is for the array interface, not PyArrayObject */ +#define NPY_ARR_HAS_DESCR 0x0800 + + + + +/* + * Size of internal buffers used for alignment Make BUFSIZE a multiple + * of sizeof(npy_cdouble) -- usually 16 so that ufunc buffers are aligned + */ +#define NPY_MIN_BUFSIZE ((int)sizeof(npy_cdouble)) +#define NPY_MAX_BUFSIZE (((int)sizeof(npy_cdouble))*1000000) +#define NPY_BUFSIZE 8192 +/* buffer stress test size: */ +/*#define NPY_BUFSIZE 17*/ + +/* + * C API: consists of Macros and functions. The MACROS are defined + * here. + */ + + +#define PyArray_ISCONTIGUOUS(m) PyArray_CHKFLAGS((m), NPY_ARRAY_C_CONTIGUOUS) +#define PyArray_ISWRITEABLE(m) PyArray_CHKFLAGS((m), NPY_ARRAY_WRITEABLE) +#define PyArray_ISALIGNED(m) PyArray_CHKFLAGS((m), NPY_ARRAY_ALIGNED) + +#define PyArray_IS_C_CONTIGUOUS(m) PyArray_CHKFLAGS((m), NPY_ARRAY_C_CONTIGUOUS) +#define PyArray_IS_F_CONTIGUOUS(m) PyArray_CHKFLAGS((m), NPY_ARRAY_F_CONTIGUOUS) + +/* the variable is used in some places, so always define it */ +#define NPY_BEGIN_THREADS_DEF PyThreadState *_save=NULL; +#if NPY_ALLOW_THREADS +#define NPY_BEGIN_ALLOW_THREADS Py_BEGIN_ALLOW_THREADS +#define NPY_END_ALLOW_THREADS Py_END_ALLOW_THREADS +#define NPY_BEGIN_THREADS do {_save = PyEval_SaveThread();} while (0); +#define NPY_END_THREADS do { if (_save) \ + { PyEval_RestoreThread(_save); _save = NULL;} } while (0); +#define NPY_BEGIN_THREADS_THRESHOLDED(loop_size) do { if ((loop_size) > 500) \ + { _save = PyEval_SaveThread();} } while (0); + + +#define NPY_ALLOW_C_API_DEF PyGILState_STATE __save__; +#define NPY_ALLOW_C_API do {__save__ = PyGILState_Ensure();} while (0); +#define NPY_DISABLE_C_API do {PyGILState_Release(__save__);} while (0); +#else +#define NPY_BEGIN_ALLOW_THREADS +#define NPY_END_ALLOW_THREADS +#define NPY_BEGIN_THREADS +#define NPY_END_THREADS +#define NPY_BEGIN_THREADS_THRESHOLDED(loop_size) +#define NPY_BEGIN_THREADS_DESCR(dtype) +#define NPY_END_THREADS_DESCR(dtype) +#define NPY_ALLOW_C_API_DEF +#define NPY_ALLOW_C_API +#define NPY_DISABLE_C_API +#endif + +/********************************** + * The nditer object, added in 1.6 + **********************************/ + +/* The actual structure of the iterator is an internal detail */ +typedef struct NpyIter_InternalOnly NpyIter; + +/* Iterator function pointers that may be specialized */ +typedef int (NpyIter_IterNextFunc)(NpyIter *iter); +typedef void (NpyIter_GetMultiIndexFunc)(NpyIter *iter, + npy_intp *outcoords); + +/*** Global flags that may be passed to the iterator constructors ***/ + +/* Track an index representing C order */ +#define NPY_ITER_C_INDEX 0x00000001 +/* Track an index representing Fortran order */ +#define NPY_ITER_F_INDEX 0x00000002 +/* Track a multi-index */ +#define NPY_ITER_MULTI_INDEX 0x00000004 +/* User code external to the iterator does the 1-dimensional innermost loop */ +#define NPY_ITER_EXTERNAL_LOOP 0x00000008 +/* Convert all the operands to a common data type */ +#define NPY_ITER_COMMON_DTYPE 0x00000010 +/* Operands may hold references, requiring API access during iteration */ +#define NPY_ITER_REFS_OK 0x00000020 +/* Zero-sized operands should be permitted, iteration checks IterSize for 0 */ +#define NPY_ITER_ZEROSIZE_OK 0x00000040 +/* Permits reductions (size-0 stride with dimension size > 1) */ +#define NPY_ITER_REDUCE_OK 0x00000080 +/* Enables sub-range iteration */ +#define NPY_ITER_RANGED 0x00000100 +/* Enables buffering */ +#define NPY_ITER_BUFFERED 0x00000200 +/* When buffering is enabled, grows the inner loop if possible */ +#define NPY_ITER_GROWINNER 0x00000400 +/* Delay allocation of buffers until first Reset* call */ +#define NPY_ITER_DELAY_BUFALLOC 0x00000800 +/* When NPY_KEEPORDER is specified, disable reversing negative-stride axes */ +#define NPY_ITER_DONT_NEGATE_STRIDES 0x00001000 +/* + * If output operands overlap with other operands (based on heuristics that + * has false positives but no false negatives), make temporary copies to + * eliminate overlap. + */ +#define NPY_ITER_COPY_IF_OVERLAP 0x00002000 + +/*** Per-operand flags that may be passed to the iterator constructors ***/ + +/* The operand will be read from and written to */ +#define NPY_ITER_READWRITE 0x00010000 +/* The operand will only be read from */ +#define NPY_ITER_READONLY 0x00020000 +/* The operand will only be written to */ +#define NPY_ITER_WRITEONLY 0x00040000 +/* The operand's data must be in native byte order */ +#define NPY_ITER_NBO 0x00080000 +/* The operand's data must be aligned */ +#define NPY_ITER_ALIGNED 0x00100000 +/* The operand's data must be contiguous (within the inner loop) */ +#define NPY_ITER_CONTIG 0x00200000 +/* The operand may be copied to satisfy requirements */ +#define NPY_ITER_COPY 0x00400000 +/* The operand may be copied with WRITEBACKIFCOPY to satisfy requirements */ +#define NPY_ITER_UPDATEIFCOPY 0x00800000 +/* Allocate the operand if it is NULL */ +#define NPY_ITER_ALLOCATE 0x01000000 +/* If an operand is allocated, don't use any subtype */ +#define NPY_ITER_NO_SUBTYPE 0x02000000 +/* This is a virtual array slot, operand is NULL but temporary data is there */ +#define NPY_ITER_VIRTUAL 0x04000000 +/* Require that the dimension match the iterator dimensions exactly */ +#define NPY_ITER_NO_BROADCAST 0x08000000 +/* A mask is being used on this array, affects buffer -> array copy */ +#define NPY_ITER_WRITEMASKED 0x10000000 +/* This array is the mask for all WRITEMASKED operands */ +#define NPY_ITER_ARRAYMASK 0x20000000 +/* Assume iterator order data access for COPY_IF_OVERLAP */ +#define NPY_ITER_OVERLAP_ASSUME_ELEMENTWISE 0x40000000 + +#define NPY_ITER_GLOBAL_FLAGS 0x0000ffff +#define NPY_ITER_PER_OP_FLAGS 0xffff0000 + + +/***************************** + * Basic iterator object + *****************************/ + +/* FWD declaration */ +typedef struct PyArrayIterObject_tag PyArrayIterObject; + +/* + * type of the function which translates a set of coordinates to a + * pointer to the data + */ +typedef char* (*npy_iter_get_dataptr_t)( + PyArrayIterObject* iter, const npy_intp*); + +struct PyArrayIterObject_tag { + PyObject_HEAD + int nd_m1; /* number of dimensions - 1 */ + npy_intp index, size; + npy_intp coordinates[NPY_MAXDIMS_LEGACY_ITERS];/* N-dimensional loop */ + npy_intp dims_m1[NPY_MAXDIMS_LEGACY_ITERS]; /* ao->dimensions - 1 */ + npy_intp strides[NPY_MAXDIMS_LEGACY_ITERS]; /* ao->strides or fake */ + npy_intp backstrides[NPY_MAXDIMS_LEGACY_ITERS];/* how far to jump back */ + npy_intp factors[NPY_MAXDIMS_LEGACY_ITERS]; /* shape factors */ + PyArrayObject *ao; + char *dataptr; /* pointer to current item*/ + npy_bool contiguous; + + npy_intp bounds[NPY_MAXDIMS_LEGACY_ITERS][2]; + npy_intp limits[NPY_MAXDIMS_LEGACY_ITERS][2]; + npy_intp limits_sizes[NPY_MAXDIMS_LEGACY_ITERS]; + npy_iter_get_dataptr_t translate; +} ; + + +/* Iterator API */ +#define PyArrayIter_Check(op) PyObject_TypeCheck((op), &PyArrayIter_Type) + +#define _PyAIT(it) ((PyArrayIterObject *)(it)) +#define PyArray_ITER_RESET(it) do { \ + _PyAIT(it)->index = 0; \ + _PyAIT(it)->dataptr = PyArray_BYTES(_PyAIT(it)->ao); \ + memset(_PyAIT(it)->coordinates, 0, \ + (_PyAIT(it)->nd_m1+1)*sizeof(npy_intp)); \ +} while (0) + +#define _PyArray_ITER_NEXT1(it) do { \ + (it)->dataptr += _PyAIT(it)->strides[0]; \ + (it)->coordinates[0]++; \ +} while (0) + +#define _PyArray_ITER_NEXT2(it) do { \ + if ((it)->coordinates[1] < (it)->dims_m1[1]) { \ + (it)->coordinates[1]++; \ + (it)->dataptr += (it)->strides[1]; \ + } \ + else { \ + (it)->coordinates[1] = 0; \ + (it)->coordinates[0]++; \ + (it)->dataptr += (it)->strides[0] - \ + (it)->backstrides[1]; \ + } \ +} while (0) + +#define PyArray_ITER_NEXT(it) do { \ + _PyAIT(it)->index++; \ + if (_PyAIT(it)->nd_m1 == 0) { \ + _PyArray_ITER_NEXT1(_PyAIT(it)); \ + } \ + else if (_PyAIT(it)->contiguous) \ + _PyAIT(it)->dataptr += PyArray_ITEMSIZE(_PyAIT(it)->ao); \ + else if (_PyAIT(it)->nd_m1 == 1) { \ + _PyArray_ITER_NEXT2(_PyAIT(it)); \ + } \ + else { \ + int __npy_i; \ + for (__npy_i=_PyAIT(it)->nd_m1; __npy_i >= 0; __npy_i--) { \ + if (_PyAIT(it)->coordinates[__npy_i] < \ + _PyAIT(it)->dims_m1[__npy_i]) { \ + _PyAIT(it)->coordinates[__npy_i]++; \ + _PyAIT(it)->dataptr += \ + _PyAIT(it)->strides[__npy_i]; \ + break; \ + } \ + else { \ + _PyAIT(it)->coordinates[__npy_i] = 0; \ + _PyAIT(it)->dataptr -= \ + _PyAIT(it)->backstrides[__npy_i]; \ + } \ + } \ + } \ +} while (0) + +#define PyArray_ITER_GOTO(it, destination) do { \ + int __npy_i; \ + _PyAIT(it)->index = 0; \ + _PyAIT(it)->dataptr = PyArray_BYTES(_PyAIT(it)->ao); \ + for (__npy_i = _PyAIT(it)->nd_m1; __npy_i>=0; __npy_i--) { \ + if (destination[__npy_i] < 0) { \ + destination[__npy_i] += \ + _PyAIT(it)->dims_m1[__npy_i]+1; \ + } \ + _PyAIT(it)->dataptr += destination[__npy_i] * \ + _PyAIT(it)->strides[__npy_i]; \ + _PyAIT(it)->coordinates[__npy_i] = \ + destination[__npy_i]; \ + _PyAIT(it)->index += destination[__npy_i] * \ + ( __npy_i==_PyAIT(it)->nd_m1 ? 1 : \ + _PyAIT(it)->dims_m1[__npy_i+1]+1) ; \ + } \ +} while (0) + +#define PyArray_ITER_GOTO1D(it, ind) do { \ + int __npy_i; \ + npy_intp __npy_ind = (npy_intp)(ind); \ + if (__npy_ind < 0) __npy_ind += _PyAIT(it)->size; \ + _PyAIT(it)->index = __npy_ind; \ + if (_PyAIT(it)->nd_m1 == 0) { \ + _PyAIT(it)->dataptr = PyArray_BYTES(_PyAIT(it)->ao) + \ + __npy_ind * _PyAIT(it)->strides[0]; \ + } \ + else if (_PyAIT(it)->contiguous) \ + _PyAIT(it)->dataptr = PyArray_BYTES(_PyAIT(it)->ao) + \ + __npy_ind * PyArray_ITEMSIZE(_PyAIT(it)->ao); \ + else { \ + _PyAIT(it)->dataptr = PyArray_BYTES(_PyAIT(it)->ao); \ + for (__npy_i = 0; __npy_i<=_PyAIT(it)->nd_m1; \ + __npy_i++) { \ + _PyAIT(it)->coordinates[__npy_i] = \ + (__npy_ind / _PyAIT(it)->factors[__npy_i]); \ + _PyAIT(it)->dataptr += \ + (__npy_ind / _PyAIT(it)->factors[__npy_i]) \ + * _PyAIT(it)->strides[__npy_i]; \ + __npy_ind %= _PyAIT(it)->factors[__npy_i]; \ + } \ + } \ +} while (0) + +#define PyArray_ITER_DATA(it) ((void *)(_PyAIT(it)->dataptr)) + +#define PyArray_ITER_NOTDONE(it) (_PyAIT(it)->index < _PyAIT(it)->size) + + +/* + * Any object passed to PyArray_Broadcast must be binary compatible + * with this structure. + */ + +typedef struct { + PyObject_HEAD + int numiter; /* number of iters */ + npy_intp size; /* broadcasted size */ + npy_intp index; /* current index */ + int nd; /* number of dims */ + npy_intp dimensions[NPY_MAXDIMS_LEGACY_ITERS]; /* dimensions */ + /* + * Space for the individual iterators, do not specify size publicly + * to allow changing it more easily. + * One reason is that Cython uses this for checks and only allows + * growing structs (as of Cython 3.0.6). It also allows NPY_MAXARGS + * to be runtime dependent. + */ +#if (defined(NPY_INTERNAL_BUILD) && NPY_INTERNAL_BUILD) + PyArrayIterObject *iters[64]; +#elif defined(__cplusplus) + /* + * C++ doesn't strictly support flexible members and gives compilers + * warnings (pedantic only), so we lie. We can't make it 64 because + * then Cython is unhappy (larger struct at runtime is OK smaller not). + */ + PyArrayIterObject *iters[32]; +#else + PyArrayIterObject *iters[]; +#endif +} PyArrayMultiIterObject; + +#define _PyMIT(m) ((PyArrayMultiIterObject *)(m)) +#define PyArray_MultiIter_RESET(multi) do { \ + int __npy_mi; \ + _PyMIT(multi)->index = 0; \ + for (__npy_mi=0; __npy_mi < _PyMIT(multi)->numiter; __npy_mi++) { \ + PyArray_ITER_RESET(_PyMIT(multi)->iters[__npy_mi]); \ + } \ +} while (0) + +#define PyArray_MultiIter_NEXT(multi) do { \ + int __npy_mi; \ + _PyMIT(multi)->index++; \ + for (__npy_mi=0; __npy_mi < _PyMIT(multi)->numiter; __npy_mi++) { \ + PyArray_ITER_NEXT(_PyMIT(multi)->iters[__npy_mi]); \ + } \ +} while (0) + +#define PyArray_MultiIter_GOTO(multi, dest) do { \ + int __npy_mi; \ + for (__npy_mi=0; __npy_mi < _PyMIT(multi)->numiter; __npy_mi++) { \ + PyArray_ITER_GOTO(_PyMIT(multi)->iters[__npy_mi], dest); \ + } \ + _PyMIT(multi)->index = _PyMIT(multi)->iters[0]->index; \ +} while (0) + +#define PyArray_MultiIter_GOTO1D(multi, ind) do { \ + int __npy_mi; \ + for (__npy_mi=0; __npy_mi < _PyMIT(multi)->numiter; __npy_mi++) { \ + PyArray_ITER_GOTO1D(_PyMIT(multi)->iters[__npy_mi], ind); \ + } \ + _PyMIT(multi)->index = _PyMIT(multi)->iters[0]->index; \ +} while (0) + +#define PyArray_MultiIter_DATA(multi, i) \ + ((void *)(_PyMIT(multi)->iters[i]->dataptr)) + +#define PyArray_MultiIter_NEXTi(multi, i) \ + PyArray_ITER_NEXT(_PyMIT(multi)->iters[i]) + +#define PyArray_MultiIter_NOTDONE(multi) \ + (_PyMIT(multi)->index < _PyMIT(multi)->size) + + +static NPY_INLINE int +PyArray_MultiIter_NUMITER(PyArrayMultiIterObject *multi) +{ + return multi->numiter; +} + + +static NPY_INLINE npy_intp +PyArray_MultiIter_SIZE(PyArrayMultiIterObject *multi) +{ + return multi->size; +} + + +static NPY_INLINE npy_intp +PyArray_MultiIter_INDEX(PyArrayMultiIterObject *multi) +{ + return multi->index; +} + + +static NPY_INLINE int +PyArray_MultiIter_NDIM(PyArrayMultiIterObject *multi) +{ + return multi->nd; +} + + +static NPY_INLINE npy_intp * +PyArray_MultiIter_DIMS(PyArrayMultiIterObject *multi) +{ + return multi->dimensions; +} + + +static NPY_INLINE void ** +PyArray_MultiIter_ITERS(PyArrayMultiIterObject *multi) +{ + return (void**)multi->iters; +} + + +enum { + NPY_NEIGHBORHOOD_ITER_ZERO_PADDING, + NPY_NEIGHBORHOOD_ITER_ONE_PADDING, + NPY_NEIGHBORHOOD_ITER_CONSTANT_PADDING, + NPY_NEIGHBORHOOD_ITER_CIRCULAR_PADDING, + NPY_NEIGHBORHOOD_ITER_MIRROR_PADDING +}; + +typedef struct { + PyObject_HEAD + + /* + * PyArrayIterObject part: keep this in this exact order + */ + int nd_m1; /* number of dimensions - 1 */ + npy_intp index, size; + npy_intp coordinates[NPY_MAXDIMS_LEGACY_ITERS];/* N-dimensional loop */ + npy_intp dims_m1[NPY_MAXDIMS_LEGACY_ITERS]; /* ao->dimensions - 1 */ + npy_intp strides[NPY_MAXDIMS_LEGACY_ITERS]; /* ao->strides or fake */ + npy_intp backstrides[NPY_MAXDIMS_LEGACY_ITERS];/* how far to jump back */ + npy_intp factors[NPY_MAXDIMS_LEGACY_ITERS]; /* shape factors */ + PyArrayObject *ao; + char *dataptr; /* pointer to current item*/ + npy_bool contiguous; + + npy_intp bounds[NPY_MAXDIMS_LEGACY_ITERS][2]; + npy_intp limits[NPY_MAXDIMS_LEGACY_ITERS][2]; + npy_intp limits_sizes[NPY_MAXDIMS_LEGACY_ITERS]; + npy_iter_get_dataptr_t translate; + + /* + * New members + */ + npy_intp nd; + + /* Dimensions is the dimension of the array */ + npy_intp dimensions[NPY_MAXDIMS_LEGACY_ITERS]; + + /* + * Neighborhood points coordinates are computed relatively to the + * point pointed by _internal_iter + */ + PyArrayIterObject* _internal_iter; + /* + * To keep a reference to the representation of the constant value + * for constant padding + */ + char* constant; + + int mode; +} PyArrayNeighborhoodIterObject; + +/* + * Neighborhood iterator API + */ + +/* General: those work for any mode */ +static inline int +PyArrayNeighborhoodIter_Reset(PyArrayNeighborhoodIterObject* iter); +static inline int +PyArrayNeighborhoodIter_Next(PyArrayNeighborhoodIterObject* iter); +#if 0 +static inline int +PyArrayNeighborhoodIter_Next2D(PyArrayNeighborhoodIterObject* iter); +#endif + +/* + * Include inline implementations - functions defined there are not + * considered public API + */ +#define NUMPY_CORE_INCLUDE_NUMPY__NEIGHBORHOOD_IMP_H_ +#include "_neighborhood_iterator_imp.h" +#undef NUMPY_CORE_INCLUDE_NUMPY__NEIGHBORHOOD_IMP_H_ + + + +/* The default array type */ +#define NPY_DEFAULT_TYPE NPY_DOUBLE +/* default integer type defined in npy_2_compat header */ + +/* + * All sorts of useful ways to look into a PyArrayObject. It is recommended + * to use PyArrayObject * objects instead of always casting from PyObject *, + * for improved type checking. + * + * In many cases here the macro versions of the accessors are deprecated, + * but can't be immediately changed to inline functions because the + * preexisting macros accept PyObject * and do automatic casts. Inline + * functions accepting PyArrayObject * provides for some compile-time + * checking of correctness when working with these objects in C. + */ + +#define PyArray_ISONESEGMENT(m) (PyArray_CHKFLAGS(m, NPY_ARRAY_C_CONTIGUOUS) || \ + PyArray_CHKFLAGS(m, NPY_ARRAY_F_CONTIGUOUS)) + +#define PyArray_ISFORTRAN(m) (PyArray_CHKFLAGS(m, NPY_ARRAY_F_CONTIGUOUS) && \ + (!PyArray_CHKFLAGS(m, NPY_ARRAY_C_CONTIGUOUS))) + +#define PyArray_FORTRAN_IF(m) ((PyArray_CHKFLAGS(m, NPY_ARRAY_F_CONTIGUOUS) ? \ + NPY_ARRAY_F_CONTIGUOUS : 0)) + +static inline int +PyArray_NDIM(const PyArrayObject *arr) +{ + return ((PyArrayObject_fields *)arr)->nd; +} + +static inline void * +PyArray_DATA(const PyArrayObject *arr) +{ + return ((PyArrayObject_fields *)arr)->data; +} + +static inline char * +PyArray_BYTES(const PyArrayObject *arr) +{ + return ((PyArrayObject_fields *)arr)->data; +} + +static inline npy_intp * +PyArray_DIMS(const PyArrayObject *arr) +{ + return ((PyArrayObject_fields *)arr)->dimensions; +} + +static inline npy_intp * +PyArray_STRIDES(const PyArrayObject *arr) +{ + return ((PyArrayObject_fields *)arr)->strides; +} + +static inline npy_intp +PyArray_DIM(const PyArrayObject *arr, int idim) +{ + return ((PyArrayObject_fields *)arr)->dimensions[idim]; +} + +static inline npy_intp +PyArray_STRIDE(const PyArrayObject *arr, int istride) +{ + return ((PyArrayObject_fields *)arr)->strides[istride]; +} + +static inline NPY_RETURNS_BORROWED_REF PyObject * +PyArray_BASE(const PyArrayObject *arr) +{ + return ((PyArrayObject_fields *)arr)->base; +} + +static inline NPY_RETURNS_BORROWED_REF PyArray_Descr * +PyArray_DESCR(const PyArrayObject *arr) +{ + return ((PyArrayObject_fields *)arr)->descr; +} + +static inline int +PyArray_FLAGS(const PyArrayObject *arr) +{ + return ((PyArrayObject_fields *)arr)->flags; +} + + +static inline int +PyArray_TYPE(const PyArrayObject *arr) +{ + return ((PyArrayObject_fields *)arr)->descr->type_num; +} + +static inline int +PyArray_CHKFLAGS(const PyArrayObject *arr, int flags) +{ + return (PyArray_FLAGS(arr) & flags) == flags; +} + +static inline PyArray_Descr * +PyArray_DTYPE(const PyArrayObject *arr) +{ + return ((PyArrayObject_fields *)arr)->descr; +} + +static inline npy_intp * +PyArray_SHAPE(const PyArrayObject *arr) +{ + return ((PyArrayObject_fields *)arr)->dimensions; +} + +/* + * Enables the specified array flags. Does no checking, + * assumes you know what you're doing. + */ +static inline void +PyArray_ENABLEFLAGS(PyArrayObject *arr, int flags) +{ + ((PyArrayObject_fields *)arr)->flags |= flags; +} + +/* + * Clears the specified array flags. Does no checking, + * assumes you know what you're doing. + */ +static inline void +PyArray_CLEARFLAGS(PyArrayObject *arr, int flags) +{ + ((PyArrayObject_fields *)arr)->flags &= ~flags; +} + +#if NPY_FEATURE_VERSION >= NPY_1_22_API_VERSION + static inline NPY_RETURNS_BORROWED_REF PyObject * + PyArray_HANDLER(PyArrayObject *arr) + { + return ((PyArrayObject_fields *)arr)->mem_handler; + } +#endif + +#define PyTypeNum_ISBOOL(type) ((type) == NPY_BOOL) + +#define PyTypeNum_ISUNSIGNED(type) (((type) == NPY_UBYTE) || \ + ((type) == NPY_USHORT) || \ + ((type) == NPY_UINT) || \ + ((type) == NPY_ULONG) || \ + ((type) == NPY_ULONGLONG)) + +#define PyTypeNum_ISSIGNED(type) (((type) == NPY_BYTE) || \ + ((type) == NPY_SHORT) || \ + ((type) == NPY_INT) || \ + ((type) == NPY_LONG) || \ + ((type) == NPY_LONGLONG)) + +#define PyTypeNum_ISINTEGER(type) (((type) >= NPY_BYTE) && \ + ((type) <= NPY_ULONGLONG)) + +#define PyTypeNum_ISFLOAT(type) ((((type) >= NPY_FLOAT) && \ + ((type) <= NPY_LONGDOUBLE)) || \ + ((type) == NPY_HALF)) + +#define PyTypeNum_ISNUMBER(type) (((type) <= NPY_CLONGDOUBLE) || \ + ((type) == NPY_HALF)) + +#define PyTypeNum_ISSTRING(type) (((type) == NPY_STRING) || \ + ((type) == NPY_UNICODE)) + +#define PyTypeNum_ISCOMPLEX(type) (((type) >= NPY_CFLOAT) && \ + ((type) <= NPY_CLONGDOUBLE)) + +#define PyTypeNum_ISFLEXIBLE(type) (((type) >=NPY_STRING) && \ + ((type) <=NPY_VOID)) + +#define PyTypeNum_ISDATETIME(type) (((type) >=NPY_DATETIME) && \ + ((type) <=NPY_TIMEDELTA)) + +#define PyTypeNum_ISUSERDEF(type) (((type) >= NPY_USERDEF) && \ + ((type) < NPY_USERDEF+ \ + NPY_NUMUSERTYPES)) + +#define PyTypeNum_ISEXTENDED(type) (PyTypeNum_ISFLEXIBLE(type) || \ + PyTypeNum_ISUSERDEF(type)) + +#define PyTypeNum_ISOBJECT(type) ((type) == NPY_OBJECT) + + +#define PyDataType_ISLEGACY(dtype) ((dtype)->type_num < NPY_VSTRING && ((dtype)->type_num >= 0)) +#define PyDataType_ISBOOL(obj) PyTypeNum_ISBOOL(((PyArray_Descr*)(obj))->type_num) +#define PyDataType_ISUNSIGNED(obj) PyTypeNum_ISUNSIGNED(((PyArray_Descr*)(obj))->type_num) +#define PyDataType_ISSIGNED(obj) PyTypeNum_ISSIGNED(((PyArray_Descr*)(obj))->type_num) +#define PyDataType_ISINTEGER(obj) PyTypeNum_ISINTEGER(((PyArray_Descr*)(obj))->type_num ) +#define PyDataType_ISFLOAT(obj) PyTypeNum_ISFLOAT(((PyArray_Descr*)(obj))->type_num) +#define PyDataType_ISNUMBER(obj) PyTypeNum_ISNUMBER(((PyArray_Descr*)(obj))->type_num) +#define PyDataType_ISSTRING(obj) PyTypeNum_ISSTRING(((PyArray_Descr*)(obj))->type_num) +#define PyDataType_ISCOMPLEX(obj) PyTypeNum_ISCOMPLEX(((PyArray_Descr*)(obj))->type_num) +#define PyDataType_ISFLEXIBLE(obj) PyTypeNum_ISFLEXIBLE(((PyArray_Descr*)(obj))->type_num) +#define PyDataType_ISDATETIME(obj) PyTypeNum_ISDATETIME(((PyArray_Descr*)(obj))->type_num) +#define PyDataType_ISUSERDEF(obj) PyTypeNum_ISUSERDEF(((PyArray_Descr*)(obj))->type_num) +#define PyDataType_ISEXTENDED(obj) PyTypeNum_ISEXTENDED(((PyArray_Descr*)(obj))->type_num) +#define PyDataType_ISOBJECT(obj) PyTypeNum_ISOBJECT(((PyArray_Descr*)(obj))->type_num) +#define PyDataType_MAKEUNSIZED(dtype) ((dtype)->elsize = 0) +/* + * PyDataType_* FLAGS, FLACHK, REFCHK, HASFIELDS, HASSUBARRAY, UNSIZED, + * SUBARRAY, NAMES, FIELDS, C_METADATA, and METADATA require version specific + * lookup and are defined in npy_2_compat.h. + */ + + +#define PyArray_ISBOOL(obj) PyTypeNum_ISBOOL(PyArray_TYPE(obj)) +#define PyArray_ISUNSIGNED(obj) PyTypeNum_ISUNSIGNED(PyArray_TYPE(obj)) +#define PyArray_ISSIGNED(obj) PyTypeNum_ISSIGNED(PyArray_TYPE(obj)) +#define PyArray_ISINTEGER(obj) PyTypeNum_ISINTEGER(PyArray_TYPE(obj)) +#define PyArray_ISFLOAT(obj) PyTypeNum_ISFLOAT(PyArray_TYPE(obj)) +#define PyArray_ISNUMBER(obj) PyTypeNum_ISNUMBER(PyArray_TYPE(obj)) +#define PyArray_ISSTRING(obj) PyTypeNum_ISSTRING(PyArray_TYPE(obj)) +#define PyArray_ISCOMPLEX(obj) PyTypeNum_ISCOMPLEX(PyArray_TYPE(obj)) +#define PyArray_ISFLEXIBLE(obj) PyTypeNum_ISFLEXIBLE(PyArray_TYPE(obj)) +#define PyArray_ISDATETIME(obj) PyTypeNum_ISDATETIME(PyArray_TYPE(obj)) +#define PyArray_ISUSERDEF(obj) PyTypeNum_ISUSERDEF(PyArray_TYPE(obj)) +#define PyArray_ISEXTENDED(obj) PyTypeNum_ISEXTENDED(PyArray_TYPE(obj)) +#define PyArray_ISOBJECT(obj) PyTypeNum_ISOBJECT(PyArray_TYPE(obj)) +#define PyArray_HASFIELDS(obj) PyDataType_HASFIELDS(PyArray_DESCR(obj)) + + /* + * FIXME: This should check for a flag on the data-type that + * states whether or not it is variable length. Because the + * ISFLEXIBLE check is hard-coded to the built-in data-types. + */ +#define PyArray_ISVARIABLE(obj) PyTypeNum_ISFLEXIBLE(PyArray_TYPE(obj)) + +#define PyArray_SAFEALIGNEDCOPY(obj) (PyArray_ISALIGNED(obj) && !PyArray_ISVARIABLE(obj)) + + +#define NPY_LITTLE '<' +#define NPY_BIG '>' +#define NPY_NATIVE '=' +#define NPY_SWAP 's' +#define NPY_IGNORE '|' + +#if NPY_BYTE_ORDER == NPY_BIG_ENDIAN +#define NPY_NATBYTE NPY_BIG +#define NPY_OPPBYTE NPY_LITTLE +#else +#define NPY_NATBYTE NPY_LITTLE +#define NPY_OPPBYTE NPY_BIG +#endif + +#define PyArray_ISNBO(arg) ((arg) != NPY_OPPBYTE) +#define PyArray_IsNativeByteOrder PyArray_ISNBO +#define PyArray_ISNOTSWAPPED(m) PyArray_ISNBO(PyArray_DESCR(m)->byteorder) +#define PyArray_ISBYTESWAPPED(m) (!PyArray_ISNOTSWAPPED(m)) + +#define PyArray_FLAGSWAP(m, flags) (PyArray_CHKFLAGS(m, flags) && \ + PyArray_ISNOTSWAPPED(m)) + +#define PyArray_ISCARRAY(m) PyArray_FLAGSWAP(m, NPY_ARRAY_CARRAY) +#define PyArray_ISCARRAY_RO(m) PyArray_FLAGSWAP(m, NPY_ARRAY_CARRAY_RO) +#define PyArray_ISFARRAY(m) PyArray_FLAGSWAP(m, NPY_ARRAY_FARRAY) +#define PyArray_ISFARRAY_RO(m) PyArray_FLAGSWAP(m, NPY_ARRAY_FARRAY_RO) +#define PyArray_ISBEHAVED(m) PyArray_FLAGSWAP(m, NPY_ARRAY_BEHAVED) +#define PyArray_ISBEHAVED_RO(m) PyArray_FLAGSWAP(m, NPY_ARRAY_ALIGNED) + + +#define PyDataType_ISNOTSWAPPED(d) PyArray_ISNBO(((PyArray_Descr *)(d))->byteorder) +#define PyDataType_ISBYTESWAPPED(d) (!PyDataType_ISNOTSWAPPED(d)) + +/************************************************************ + * A struct used by PyArray_CreateSortedStridePerm, new in 1.7. + ************************************************************/ + +typedef struct { + npy_intp perm, stride; +} npy_stride_sort_item; + +/************************************************************ + * This is the form of the struct that's stored in the + * PyCapsule returned by an array's __array_struct__ attribute. See + * https://docs.scipy.org/doc/numpy/reference/arrays.interface.html for the full + * documentation. + ************************************************************/ +typedef struct { + int two; /* + * contains the integer 2 as a sanity + * check + */ + + int nd; /* number of dimensions */ + + char typekind; /* + * kind in array --- character code of + * typestr + */ + + int itemsize; /* size of each element */ + + int flags; /* + * how should be data interpreted. Valid + * flags are CONTIGUOUS (1), F_CONTIGUOUS (2), + * ALIGNED (0x100), NOTSWAPPED (0x200), and + * WRITEABLE (0x400). ARR_HAS_DESCR (0x800) + * states that arrdescr field is present in + * structure + */ + + npy_intp *shape; /* + * A length-nd array of shape + * information + */ + + npy_intp *strides; /* A length-nd array of stride information */ + + void *data; /* A pointer to the first element of the array */ + + PyObject *descr; /* + * A list of fields or NULL (ignored if flags + * does not have ARR_HAS_DESCR flag set) + */ +} PyArrayInterface; + + +/**************************************** + * NpyString + * + * Types used by the NpyString API. + ****************************************/ + +/* + * A "packed" encoded string. The string data must be accessed by first unpacking the string. + */ +typedef struct npy_packed_static_string npy_packed_static_string; + +/* + * An unpacked read-only view onto the data in a packed string + */ +typedef struct npy_unpacked_static_string { + size_t size; + const char *buf; +} npy_static_string; + +/* + * Handles heap allocations for static strings. + */ +typedef struct npy_string_allocator npy_string_allocator; + +typedef struct { + PyArray_Descr base; + // The object representing a null value + PyObject *na_object; + // Flag indicating whether or not to coerce arbitrary objects to strings + char coerce; + // Flag indicating the na object is NaN-like + char has_nan_na; + // Flag indicating the na object is a string + char has_string_na; + // If nonzero, indicates that this instance is owned by an array already + char array_owned; + // The string data to use when a default string is needed + npy_static_string default_string; + // The name of the missing data object, if any + npy_static_string na_name; + // the allocator should only be directly accessed after + // acquiring the allocator_lock and the lock should + // be released immediately after the allocator is + // no longer needed + npy_string_allocator *allocator; +} PyArray_StringDTypeObject; + +/* + * PyArray_DTypeMeta related definitions. + * + * As of now, this API is preliminary and will be extended as necessary. + */ +#if defined(NPY_INTERNAL_BUILD) && NPY_INTERNAL_BUILD + /* + * The Structures defined in this block are currently considered + * private API and may change without warning! + * Part of this (at least the size) is expected to be public API without + * further modifications. + */ + /* TODO: Make this definition public in the API, as soon as its settled */ + NPY_NO_EXPORT extern PyTypeObject PyArrayDTypeMeta_Type; + + /* + * While NumPy DTypes would not need to be heap types the plan is to + * make DTypes available in Python at which point they will be heap types. + * Since we also wish to add fields to the DType class, this looks like + * a typical instance definition, but with PyHeapTypeObject instead of + * only the PyObject_HEAD. + * This must only be exposed very extremely careful consideration, since + * it is a fairly complex construct which may be better to allow + * refactoring of. + */ + typedef struct { + PyHeapTypeObject super; + + /* + * Most DTypes will have a singleton default instance, for the + * parametric legacy DTypes (bytes, string, void, datetime) this + * may be a pointer to the *prototype* instance? + */ + PyArray_Descr *singleton; + /* Copy of the legacy DTypes type number, usually invalid. */ + int type_num; + + /* The type object of the scalar instances (may be NULL?) */ + PyTypeObject *scalar_type; + /* + * DType flags to signal legacy, parametric, or + * abstract. But plenty of space for additional information/flags. + */ + npy_uint64 flags; + + /* + * Use indirection in order to allow a fixed size for this struct. + * A stable ABI size makes creating a static DType less painful + * while also ensuring flexibility for all opaque API (with one + * indirection due the pointer lookup). + */ + void *dt_slots; + void *reserved[3]; + } PyArray_DTypeMeta; + +#endif /* NPY_INTERNAL_BUILD */ + + +/* + * Use the keyword NPY_DEPRECATED_INCLUDES to ensure that the header files + * npy_*_*_deprecated_api.h are only included from here and nowhere else. + */ +#ifdef NPY_DEPRECATED_INCLUDES +#error "Do not use the reserved keyword NPY_DEPRECATED_INCLUDES." +#endif +#define NPY_DEPRECATED_INCLUDES +#if !defined(NPY_NO_DEPRECATED_API) || \ + (NPY_NO_DEPRECATED_API < NPY_1_7_API_VERSION) +#include "npy_1_7_deprecated_api.h" +#endif +/* + * There is no file npy_1_8_deprecated_api.h since there are no additional + * deprecated API features in NumPy 1.8. + * + * Note to maintainers: insert code like the following in future NumPy + * versions. + * + * #if !defined(NPY_NO_DEPRECATED_API) || \ + * (NPY_NO_DEPRECATED_API < NPY_1_9_API_VERSION) + * #include "npy_1_9_deprecated_api.h" + * #endif + */ +#undef NPY_DEPRECATED_INCLUDES + +#endif /* NUMPY_CORE_INCLUDE_NUMPY_NDARRAYTYPES_H_ */ diff --git a/venv/lib/python3.12/site-packages/numpy/_core/include/numpy/npy_1_7_deprecated_api.h b/venv/lib/python3.12/site-packages/numpy/_core/include/numpy/npy_1_7_deprecated_api.h new file mode 100644 index 00000000..be53cded --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/include/numpy/npy_1_7_deprecated_api.h @@ -0,0 +1,112 @@ +#ifndef NPY_DEPRECATED_INCLUDES +#error "Should never include npy_*_*_deprecated_api directly." +#endif + +#ifndef NUMPY_CORE_INCLUDE_NUMPY_NPY_1_7_DEPRECATED_API_H_ +#define NUMPY_CORE_INCLUDE_NUMPY_NPY_1_7_DEPRECATED_API_H_ + +/* Emit a warning if the user did not specifically request the old API */ +#ifndef NPY_NO_DEPRECATED_API +#if defined(_WIN32) +#define _WARN___STR2__(x) #x +#define _WARN___STR1__(x) _WARN___STR2__(x) +#define _WARN___LOC__ __FILE__ "(" _WARN___STR1__(__LINE__) ") : Warning Msg: " +#pragma message(_WARN___LOC__"Using deprecated NumPy API, disable it with " \ + "#define NPY_NO_DEPRECATED_API NPY_1_7_API_VERSION") +#else +#warning "Using deprecated NumPy API, disable it with " \ + "#define NPY_NO_DEPRECATED_API NPY_1_7_API_VERSION" +#endif +#endif + +/* + * This header exists to collect all dangerous/deprecated NumPy API + * as of NumPy 1.7. + * + * This is an attempt to remove bad API, the proliferation of macros, + * and namespace pollution currently produced by the NumPy headers. + */ + +/* These array flags are deprecated as of NumPy 1.7 */ +#define NPY_CONTIGUOUS NPY_ARRAY_C_CONTIGUOUS +#define NPY_FORTRAN NPY_ARRAY_F_CONTIGUOUS + +/* + * The consistent NPY_ARRAY_* names which don't pollute the NPY_* + * namespace were added in NumPy 1.7. + * + * These versions of the carray flags are deprecated, but + * probably should only be removed after two releases instead of one. + */ +#define NPY_C_CONTIGUOUS NPY_ARRAY_C_CONTIGUOUS +#define NPY_F_CONTIGUOUS NPY_ARRAY_F_CONTIGUOUS +#define NPY_OWNDATA NPY_ARRAY_OWNDATA +#define NPY_FORCECAST NPY_ARRAY_FORCECAST +#define NPY_ENSURECOPY NPY_ARRAY_ENSURECOPY +#define NPY_ENSUREARRAY NPY_ARRAY_ENSUREARRAY +#define NPY_ELEMENTSTRIDES NPY_ARRAY_ELEMENTSTRIDES +#define NPY_ALIGNED NPY_ARRAY_ALIGNED +#define NPY_NOTSWAPPED NPY_ARRAY_NOTSWAPPED +#define NPY_WRITEABLE NPY_ARRAY_WRITEABLE +#define NPY_BEHAVED NPY_ARRAY_BEHAVED +#define NPY_BEHAVED_NS NPY_ARRAY_BEHAVED_NS +#define NPY_CARRAY NPY_ARRAY_CARRAY +#define NPY_CARRAY_RO NPY_ARRAY_CARRAY_RO +#define NPY_FARRAY NPY_ARRAY_FARRAY +#define NPY_FARRAY_RO NPY_ARRAY_FARRAY_RO +#define NPY_DEFAULT NPY_ARRAY_DEFAULT +#define NPY_IN_ARRAY NPY_ARRAY_IN_ARRAY +#define NPY_OUT_ARRAY NPY_ARRAY_OUT_ARRAY +#define NPY_INOUT_ARRAY NPY_ARRAY_INOUT_ARRAY +#define NPY_IN_FARRAY NPY_ARRAY_IN_FARRAY +#define NPY_OUT_FARRAY NPY_ARRAY_OUT_FARRAY +#define NPY_INOUT_FARRAY NPY_ARRAY_INOUT_FARRAY +#define NPY_UPDATE_ALL NPY_ARRAY_UPDATE_ALL + +/* This way of accessing the default type is deprecated as of NumPy 1.7 */ +#define PyArray_DEFAULT NPY_DEFAULT_TYPE + +/* + * Deprecated as of NumPy 1.7, this kind of shortcut doesn't + * belong in the public API. + */ +#define NPY_AO PyArrayObject + +/* + * Deprecated as of NumPy 1.7, an all-lowercase macro doesn't + * belong in the public API. + */ +#define fortran fortran_ + +/* + * Deprecated as of NumPy 1.7, as it is a namespace-polluting + * macro. + */ +#define FORTRAN_IF PyArray_FORTRAN_IF + +/* Deprecated as of NumPy 1.7, datetime64 uses c_metadata instead */ +#define NPY_METADATA_DTSTR "__timeunit__" + +/* + * Deprecated as of NumPy 1.7. + * The reasoning: + * - These are for datetime, but there's no datetime "namespace". + * - They just turn NPY_STR_ into "", which is just + * making something simple be indirected. + */ +#define NPY_STR_Y "Y" +#define NPY_STR_M "M" +#define NPY_STR_W "W" +#define NPY_STR_D "D" +#define NPY_STR_h "h" +#define NPY_STR_m "m" +#define NPY_STR_s "s" +#define NPY_STR_ms "ms" +#define NPY_STR_us "us" +#define NPY_STR_ns "ns" +#define NPY_STR_ps "ps" +#define NPY_STR_fs "fs" +#define NPY_STR_as "as" + + +#endif /* NUMPY_CORE_INCLUDE_NUMPY_NPY_1_7_DEPRECATED_API_H_ */ diff --git a/venv/lib/python3.12/site-packages/numpy/_core/include/numpy/npy_2_compat.h b/venv/lib/python3.12/site-packages/numpy/_core/include/numpy/npy_2_compat.h new file mode 100644 index 00000000..e39e65ae --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/include/numpy/npy_2_compat.h @@ -0,0 +1,249 @@ +/* + * This header file defines relevant features which: + * - Require runtime inspection depending on the NumPy version. + * - May be needed when compiling with an older version of NumPy to allow + * a smooth transition. + * + * As such, it is shipped with NumPy 2.0, but designed to be vendored in full + * or parts by downstream projects. + * + * It must be included after any other includes. `import_array()` must have + * been called in the scope or version dependency will misbehave, even when + * only `PyUFunc_` API is used. + * + * If required complicated defs (with inline functions) should be written as: + * + * #if NPY_FEATURE_VERSION >= NPY_2_0_API_VERSION + * Simple definition when NumPy 2.0 API is guaranteed. + * #else + * static inline definition of a 1.x compatibility shim + * #if NPY_ABI_VERSION < 0x02000000 + * Make 1.x compatibility shim the public API (1.x only branch) + * #else + * Runtime dispatched version (1.x or 2.x) + * #endif + * #endif + * + * An internal build always passes NPY_FEATURE_VERSION >= NPY_2_0_API_VERSION + */ + +#ifndef NUMPY_CORE_INCLUDE_NUMPY_NPY_2_COMPAT_H_ +#define NUMPY_CORE_INCLUDE_NUMPY_NPY_2_COMPAT_H_ + +/* + * New macros for accessing real and complex part of a complex number can be + * found in "npy_2_complexcompat.h". + */ + + +/* + * This header is meant to be included by downstream directly for 1.x compat. + * In that case we need to ensure that users first included the full headers + * and not just `ndarraytypes.h`. + */ + +#ifndef NPY_FEATURE_VERSION + #error "The NumPy 2 compat header requires `import_array()` for which " \ + "the `ndarraytypes.h` header include is not sufficient. Please " \ + "include it after `numpy/ndarrayobject.h` or similar.\n" \ + "To simplify inclusion, you may use `PyArray_ImportNumPy()` " \ + "which is defined in the compat header and is lightweight (can be)." +#endif + +#if NPY_ABI_VERSION < 0x02000000 + /* + * Define 2.0 feature version as it is needed below to decide whether we + * compile for both 1.x and 2.x (defining it guarantees 1.x only). + */ + #define NPY_2_0_API_VERSION 0x00000012 + /* + * If we are compiling with NumPy 1.x, PyArray_RUNTIME_VERSION so we + * pretend the `PyArray_RUNTIME_VERSION` is `NPY_FEATURE_VERSION`. + * This allows downstream to use `PyArray_RUNTIME_VERSION` if they need to. + */ + #define PyArray_RUNTIME_VERSION NPY_FEATURE_VERSION + /* Compiling on NumPy 1.x where these are the same: */ + #define PyArray_DescrProto PyArray_Descr +#endif + + +/* + * Define a better way to call `_import_array()` to simplify backporting as + * we now require imports more often (necessary to make ABI flexible). + */ +#ifdef import_array1 + +static inline int +PyArray_ImportNumPyAPI(void) +{ + if (NPY_UNLIKELY(PyArray_API == NULL)) { + import_array1(-1); + } + return 0; +} + +#endif /* import_array1 */ + + +/* + * NPY_DEFAULT_INT + * + * The default integer has changed, `NPY_DEFAULT_INT` is available at runtime + * for use as type number, e.g. `PyArray_DescrFromType(NPY_DEFAULT_INT)`. + * + * NPY_RAVEL_AXIS + * + * This was introduced in NumPy 2.0 to allow indicating that an axis should be + * raveled in an operation. Before NumPy 2.0, NPY_MAXDIMS was used for this purpose. + * + * NPY_MAXDIMS + * + * A constant indicating the maximum number dimensions allowed when creating + * an ndarray. + * + * NPY_NTYPES_LEGACY + * + * The number of built-in NumPy dtypes. + */ +#if NPY_FEATURE_VERSION >= NPY_2_0_API_VERSION + #define NPY_DEFAULT_INT NPY_INTP + #define NPY_RAVEL_AXIS NPY_MIN_INT + #define NPY_MAXARGS 64 + +#elif NPY_ABI_VERSION < 0x02000000 + #define NPY_DEFAULT_INT NPY_LONG + #define NPY_RAVEL_AXIS 32 + #define NPY_MAXARGS 32 + + /* Aliases of 2.x names to 1.x only equivalent names */ + #define NPY_NTYPES NPY_NTYPES_LEGACY + #define PyArray_DescrProto PyArray_Descr + #define _PyArray_LegacyDescr PyArray_Descr + /* NumPy 2 definition always works, but add it for 1.x only */ + #define PyDataType_ISLEGACY(dtype) (1) +#else + #define NPY_DEFAULT_INT \ + (PyArray_RUNTIME_VERSION >= NPY_2_0_API_VERSION ? NPY_INTP : NPY_LONG) + #define NPY_RAVEL_AXIS \ + (PyArray_RUNTIME_VERSION >= NPY_2_0_API_VERSION ? NPY_MIN_INT : 32) + #define NPY_MAXARGS \ + (PyArray_RUNTIME_VERSION >= NPY_2_0_API_VERSION ? 64 : 32) +#endif + + +/* + * Access inline functions for descriptor fields. Except for the first + * few fields, these needed to be moved (elsize, alignment) for + * additional space. Or they are descriptor specific and are not generally + * available anymore (metadata, c_metadata, subarray, names, fields). + * + * Most of these are defined via the `DESCR_ACCESSOR` macro helper. + */ +#if NPY_FEATURE_VERSION >= NPY_2_0_API_VERSION || NPY_ABI_VERSION < 0x02000000 + /* Compiling for 1.x or 2.x only, direct field access is OK: */ + + static inline void + PyDataType_SET_ELSIZE(PyArray_Descr *dtype, npy_intp size) + { + dtype->elsize = size; + } + + static inline npy_uint64 + PyDataType_FLAGS(const PyArray_Descr *dtype) + { + #if NPY_FEATURE_VERSION >= NPY_2_0_API_VERSION + return dtype->flags; + #else + return (unsigned char)dtype->flags; /* Need unsigned cast on 1.x */ + #endif + } + + #define DESCR_ACCESSOR(FIELD, field, type, legacy_only) \ + static inline type \ + PyDataType_##FIELD(const PyArray_Descr *dtype) { \ + if (legacy_only && !PyDataType_ISLEGACY(dtype)) { \ + return (type)0; \ + } \ + return ((_PyArray_LegacyDescr *)dtype)->field; \ + } +#else /* compiling for both 1.x and 2.x */ + + static inline void + PyDataType_SET_ELSIZE(PyArray_Descr *dtype, npy_intp size) + { + if (PyArray_RUNTIME_VERSION >= NPY_2_0_API_VERSION) { + ((_PyArray_DescrNumPy2 *)dtype)->elsize = size; + } + else { + ((PyArray_DescrProto *)dtype)->elsize = (int)size; + } + } + + static inline npy_uint64 + PyDataType_FLAGS(const PyArray_Descr *dtype) + { + if (PyArray_RUNTIME_VERSION >= NPY_2_0_API_VERSION) { + return ((_PyArray_DescrNumPy2 *)dtype)->flags; + } + else { + return (unsigned char)((PyArray_DescrProto *)dtype)->flags; + } + } + + /* Cast to LegacyDescr always fine but needed when `legacy_only` */ + #define DESCR_ACCESSOR(FIELD, field, type, legacy_only) \ + static inline type \ + PyDataType_##FIELD(const PyArray_Descr *dtype) { \ + if (legacy_only && !PyDataType_ISLEGACY(dtype)) { \ + return (type)0; \ + } \ + if (PyArray_RUNTIME_VERSION >= NPY_2_0_API_VERSION) { \ + return ((_PyArray_LegacyDescr *)dtype)->field; \ + } \ + else { \ + return ((PyArray_DescrProto *)dtype)->field; \ + } \ + } +#endif + +DESCR_ACCESSOR(ELSIZE, elsize, npy_intp, 0) +DESCR_ACCESSOR(ALIGNMENT, alignment, npy_intp, 0) +DESCR_ACCESSOR(METADATA, metadata, PyObject *, 1) +DESCR_ACCESSOR(SUBARRAY, subarray, PyArray_ArrayDescr *, 1) +DESCR_ACCESSOR(NAMES, names, PyObject *, 1) +DESCR_ACCESSOR(FIELDS, fields, PyObject *, 1) +DESCR_ACCESSOR(C_METADATA, c_metadata, NpyAuxData *, 1) + +#undef DESCR_ACCESSOR + + +#if !(defined(NPY_INTERNAL_BUILD) && NPY_INTERNAL_BUILD) +#if NPY_FEATURE_VERSION >= NPY_2_0_API_VERSION + static inline PyArray_ArrFuncs * + PyDataType_GetArrFuncs(const PyArray_Descr *descr) + { + return _PyDataType_GetArrFuncs(descr); + } +#elif NPY_ABI_VERSION < 0x02000000 + static inline PyArray_ArrFuncs * + PyDataType_GetArrFuncs(const PyArray_Descr *descr) + { + return descr->f; + } +#else + static inline PyArray_ArrFuncs * + PyDataType_GetArrFuncs(const PyArray_Descr *descr) + { + if (PyArray_RUNTIME_VERSION >= NPY_2_0_API_VERSION) { + return _PyDataType_GetArrFuncs(descr); + } + else { + return ((PyArray_DescrProto *)descr)->f; + } + } +#endif + + +#endif /* not internal build */ + +#endif /* NUMPY_CORE_INCLUDE_NUMPY_NPY_2_COMPAT_H_ */ diff --git a/venv/lib/python3.12/site-packages/numpy/_core/include/numpy/npy_2_complexcompat.h b/venv/lib/python3.12/site-packages/numpy/_core/include/numpy/npy_2_complexcompat.h new file mode 100644 index 00000000..0b509011 --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/include/numpy/npy_2_complexcompat.h @@ -0,0 +1,28 @@ +/* This header is designed to be copy-pasted into downstream packages, since it provides + a compatibility layer between the old C struct complex types and the new native C99 + complex types. The new macros are in numpy/npy_math.h, which is why it is included here. */ +#ifndef NUMPY_CORE_INCLUDE_NUMPY_NPY_2_COMPLEXCOMPAT_H_ +#define NUMPY_CORE_INCLUDE_NUMPY_NPY_2_COMPLEXCOMPAT_H_ + +#include + +#ifndef NPY_CSETREALF +#define NPY_CSETREALF(c, r) (c)->real = (r) +#endif +#ifndef NPY_CSETIMAGF +#define NPY_CSETIMAGF(c, i) (c)->imag = (i) +#endif +#ifndef NPY_CSETREAL +#define NPY_CSETREAL(c, r) (c)->real = (r) +#endif +#ifndef NPY_CSETIMAG +#define NPY_CSETIMAG(c, i) (c)->imag = (i) +#endif +#ifndef NPY_CSETREALL +#define NPY_CSETREALL(c, r) (c)->real = (r) +#endif +#ifndef NPY_CSETIMAGL +#define NPY_CSETIMAGL(c, i) (c)->imag = (i) +#endif + +#endif diff --git a/venv/lib/python3.12/site-packages/numpy/_core/include/numpy/npy_3kcompat.h b/venv/lib/python3.12/site-packages/numpy/_core/include/numpy/npy_3kcompat.h new file mode 100644 index 00000000..c2bf74fa --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/include/numpy/npy_3kcompat.h @@ -0,0 +1,374 @@ +/* + * This is a convenience header file providing compatibility utilities + * for supporting different minor versions of Python 3. + * It was originally used to support the transition from Python 2, + * hence the "3k" naming. + * + * If you want to use this for your own projects, it's recommended to make a + * copy of it. We don't provide backwards compatibility guarantees. + */ + +#ifndef NUMPY_CORE_INCLUDE_NUMPY_NPY_3KCOMPAT_H_ +#define NUMPY_CORE_INCLUDE_NUMPY_NPY_3KCOMPAT_H_ + +#include +#include + +#include "npy_common.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/* Python13 removes _PyLong_AsInt */ +static inline int +Npy__PyLong_AsInt(PyObject *obj) +{ + int overflow; + long result = PyLong_AsLongAndOverflow(obj, &overflow); + + /* INT_MAX and INT_MIN are defined in Python.h */ + if (overflow || result > INT_MAX || result < INT_MIN) { + /* XXX: could be cute and give a different + message for overflow == -1 */ + PyErr_SetString(PyExc_OverflowError, + "Python int too large to convert to C int"); + return -1; + } + return (int)result; +} + +#if defined _MSC_VER && _MSC_VER >= 1900 + +#include + +/* + * Macros to protect CRT calls against instant termination when passed an + * invalid parameter (https://bugs.python.org/issue23524). + */ +extern _invalid_parameter_handler _Py_silent_invalid_parameter_handler; +#define NPY_BEGIN_SUPPRESS_IPH { _invalid_parameter_handler _Py_old_handler = \ + _set_thread_local_invalid_parameter_handler(_Py_silent_invalid_parameter_handler); +#define NPY_END_SUPPRESS_IPH _set_thread_local_invalid_parameter_handler(_Py_old_handler); } + +#else + +#define NPY_BEGIN_SUPPRESS_IPH +#define NPY_END_SUPPRESS_IPH + +#endif /* _MSC_VER >= 1900 */ + +/* + * PyFile_* compatibility + */ + +/* + * Get a FILE* handle to the file represented by the Python object + */ +static inline FILE* +npy_PyFile_Dup2(PyObject *file, char *mode, npy_off_t *orig_pos) +{ + int fd, fd2, unbuf; + Py_ssize_t fd2_tmp; + PyObject *ret, *os, *io, *io_raw; + npy_off_t pos; + FILE *handle; + + /* Flush first to ensure things end up in the file in the correct order */ + ret = PyObject_CallMethod(file, "flush", ""); + if (ret == NULL) { + return NULL; + } + Py_DECREF(ret); + fd = PyObject_AsFileDescriptor(file); + if (fd == -1) { + return NULL; + } + + /* + * The handle needs to be dup'd because we have to call fclose + * at the end + */ + os = PyImport_ImportModule("os"); + if (os == NULL) { + return NULL; + } + ret = PyObject_CallMethod(os, "dup", "i", fd); + Py_DECREF(os); + if (ret == NULL) { + return NULL; + } + fd2_tmp = PyNumber_AsSsize_t(ret, PyExc_IOError); + Py_DECREF(ret); + if (fd2_tmp == -1 && PyErr_Occurred()) { + return NULL; + } + if (fd2_tmp < INT_MIN || fd2_tmp > INT_MAX) { + PyErr_SetString(PyExc_IOError, + "Getting an 'int' from os.dup() failed"); + return NULL; + } + fd2 = (int)fd2_tmp; + + /* Convert to FILE* handle */ +#ifdef _WIN32 + NPY_BEGIN_SUPPRESS_IPH + handle = _fdopen(fd2, mode); + NPY_END_SUPPRESS_IPH +#else + handle = fdopen(fd2, mode); +#endif + if (handle == NULL) { + PyErr_SetString(PyExc_IOError, + "Getting a FILE* from a Python file object via " + "_fdopen failed. If you built NumPy, you probably " + "linked with the wrong debug/release runtime"); + return NULL; + } + + /* Record the original raw file handle position */ + *orig_pos = npy_ftell(handle); + if (*orig_pos == -1) { + /* The io module is needed to determine if buffering is used */ + io = PyImport_ImportModule("io"); + if (io == NULL) { + fclose(handle); + return NULL; + } + /* File object instances of RawIOBase are unbuffered */ + io_raw = PyObject_GetAttrString(io, "RawIOBase"); + Py_DECREF(io); + if (io_raw == NULL) { + fclose(handle); + return NULL; + } + unbuf = PyObject_IsInstance(file, io_raw); + Py_DECREF(io_raw); + if (unbuf == 1) { + /* Succeed if the IO is unbuffered */ + return handle; + } + else { + PyErr_SetString(PyExc_IOError, "obtaining file position failed"); + fclose(handle); + return NULL; + } + } + + /* Seek raw handle to the Python-side position */ + ret = PyObject_CallMethod(file, "tell", ""); + if (ret == NULL) { + fclose(handle); + return NULL; + } + pos = PyLong_AsLongLong(ret); + Py_DECREF(ret); + if (PyErr_Occurred()) { + fclose(handle); + return NULL; + } + if (npy_fseek(handle, pos, SEEK_SET) == -1) { + PyErr_SetString(PyExc_IOError, "seeking file failed"); + fclose(handle); + return NULL; + } + return handle; +} + +/* + * Close the dup-ed file handle, and seek the Python one to the current position + */ +static inline int +npy_PyFile_DupClose2(PyObject *file, FILE* handle, npy_off_t orig_pos) +{ + int fd, unbuf; + PyObject *ret, *io, *io_raw; + npy_off_t position; + + position = npy_ftell(handle); + + /* Close the FILE* handle */ + fclose(handle); + + /* + * Restore original file handle position, in order to not confuse + * Python-side data structures + */ + fd = PyObject_AsFileDescriptor(file); + if (fd == -1) { + return -1; + } + + if (npy_lseek(fd, orig_pos, SEEK_SET) == -1) { + + /* The io module is needed to determine if buffering is used */ + io = PyImport_ImportModule("io"); + if (io == NULL) { + return -1; + } + /* File object instances of RawIOBase are unbuffered */ + io_raw = PyObject_GetAttrString(io, "RawIOBase"); + Py_DECREF(io); + if (io_raw == NULL) { + return -1; + } + unbuf = PyObject_IsInstance(file, io_raw); + Py_DECREF(io_raw); + if (unbuf == 1) { + /* Succeed if the IO is unbuffered */ + return 0; + } + else { + PyErr_SetString(PyExc_IOError, "seeking file failed"); + return -1; + } + } + + if (position == -1) { + PyErr_SetString(PyExc_IOError, "obtaining file position failed"); + return -1; + } + + /* Seek Python-side handle to the FILE* handle position */ + ret = PyObject_CallMethod(file, "seek", NPY_OFF_T_PYFMT "i", position, 0); + if (ret == NULL) { + return -1; + } + Py_DECREF(ret); + return 0; +} + +static inline PyObject* +npy_PyFile_OpenFile(PyObject *filename, const char *mode) +{ + PyObject *open; + open = PyDict_GetItemString(PyEval_GetBuiltins(), "open"); + if (open == NULL) { + return NULL; + } + return PyObject_CallFunction(open, "Os", filename, mode); +} + +static inline int +npy_PyFile_CloseFile(PyObject *file) +{ + PyObject *ret; + + ret = PyObject_CallMethod(file, "close", NULL); + if (ret == NULL) { + return -1; + } + Py_DECREF(ret); + return 0; +} + +/* This is a copy of _PyErr_ChainExceptions, which + * is no longer exported from Python3.12 + */ +static inline void +npy_PyErr_ChainExceptions(PyObject *exc, PyObject *val, PyObject *tb) +{ + if (exc == NULL) + return; + + if (PyErr_Occurred()) { + PyObject *exc2, *val2, *tb2; + PyErr_Fetch(&exc2, &val2, &tb2); + PyErr_NormalizeException(&exc, &val, &tb); + if (tb != NULL) { + PyException_SetTraceback(val, tb); + Py_DECREF(tb); + } + Py_DECREF(exc); + PyErr_NormalizeException(&exc2, &val2, &tb2); + PyException_SetContext(val2, val); + PyErr_Restore(exc2, val2, tb2); + } + else { + PyErr_Restore(exc, val, tb); + } +} + +/* This is a copy of _PyErr_ChainExceptions, with: + * __cause__ used instead of __context__ + */ +static inline void +npy_PyErr_ChainExceptionsCause(PyObject *exc, PyObject *val, PyObject *tb) +{ + if (exc == NULL) + return; + + if (PyErr_Occurred()) { + PyObject *exc2, *val2, *tb2; + PyErr_Fetch(&exc2, &val2, &tb2); + PyErr_NormalizeException(&exc, &val, &tb); + if (tb != NULL) { + PyException_SetTraceback(val, tb); + Py_DECREF(tb); + } + Py_DECREF(exc); + PyErr_NormalizeException(&exc2, &val2, &tb2); + PyException_SetCause(val2, val); + PyErr_Restore(exc2, val2, tb2); + } + else { + PyErr_Restore(exc, val, tb); + } +} + +/* + * PyCObject functions adapted to PyCapsules. + * + * The main job here is to get rid of the improved error handling + * of PyCapsules. It's a shame... + */ +static inline PyObject * +NpyCapsule_FromVoidPtr(void *ptr, void (*dtor)(PyObject *)) +{ + PyObject *ret = PyCapsule_New(ptr, NULL, dtor); + if (ret == NULL) { + PyErr_Clear(); + } + return ret; +} + +static inline PyObject * +NpyCapsule_FromVoidPtrAndDesc(void *ptr, void* context, void (*dtor)(PyObject *)) +{ + PyObject *ret = NpyCapsule_FromVoidPtr(ptr, dtor); + if (ret != NULL && PyCapsule_SetContext(ret, context) != 0) { + PyErr_Clear(); + Py_DECREF(ret); + ret = NULL; + } + return ret; +} + +static inline void * +NpyCapsule_AsVoidPtr(PyObject *obj) +{ + void *ret = PyCapsule_GetPointer(obj, NULL); + if (ret == NULL) { + PyErr_Clear(); + } + return ret; +} + +static inline void * +NpyCapsule_GetDesc(PyObject *obj) +{ + return PyCapsule_GetContext(obj); +} + +static inline int +NpyCapsule_Check(PyObject *ptr) +{ + return PyCapsule_CheckExact(ptr); +} + +#ifdef __cplusplus +} +#endif + + +#endif /* NUMPY_CORE_INCLUDE_NUMPY_NPY_3KCOMPAT_H_ */ diff --git a/venv/lib/python3.12/site-packages/numpy/_core/include/numpy/npy_common.h b/venv/lib/python3.12/site-packages/numpy/_core/include/numpy/npy_common.h new file mode 100644 index 00000000..79ad8ad7 --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/include/numpy/npy_common.h @@ -0,0 +1,1070 @@ +#ifndef NUMPY_CORE_INCLUDE_NUMPY_NPY_COMMON_H_ +#define NUMPY_CORE_INCLUDE_NUMPY_NPY_COMMON_H_ + +/* need Python.h for npy_intp, npy_uintp */ +#include + +/* numpconfig.h is auto-generated */ +#include "numpyconfig.h" +#ifdef HAVE_NPY_CONFIG_H +#include +#endif + +/* + * using static inline modifiers when defining npy_math functions + * allows the compiler to make optimizations when possible + */ +#ifndef NPY_INLINE_MATH +#if defined(NPY_INTERNAL_BUILD) && NPY_INTERNAL_BUILD + #define NPY_INLINE_MATH 1 +#else + #define NPY_INLINE_MATH 0 +#endif +#endif + +/* + * gcc does not unroll even with -O3 + * use with care, unrolling on modern cpus rarely speeds things up + */ +#ifdef HAVE_ATTRIBUTE_OPTIMIZE_UNROLL_LOOPS +#define NPY_GCC_UNROLL_LOOPS \ + __attribute__((optimize("unroll-loops"))) +#else +#define NPY_GCC_UNROLL_LOOPS +#endif + +/* highest gcc optimization level, enabled autovectorizer */ +#ifdef HAVE_ATTRIBUTE_OPTIMIZE_OPT_3 +#define NPY_GCC_OPT_3 __attribute__((optimize("O3"))) +#else +#define NPY_GCC_OPT_3 +#endif + +/* + * mark an argument (starting from 1) that must not be NULL and is not checked + * DO NOT USE IF FUNCTION CHECKS FOR NULL!! the compiler will remove the check + */ +#ifdef HAVE_ATTRIBUTE_NONNULL +#define NPY_GCC_NONNULL(n) __attribute__((nonnull(n))) +#else +#define NPY_GCC_NONNULL(n) +#endif + +/* + * give a hint to the compiler which branch is more likely or unlikely + * to occur, e.g. rare error cases: + * + * if (NPY_UNLIKELY(failure == 0)) + * return NULL; + * + * the double !! is to cast the expression (e.g. NULL) to a boolean required by + * the intrinsic + */ +#ifdef HAVE___BUILTIN_EXPECT +#define NPY_LIKELY(x) __builtin_expect(!!(x), 1) +#define NPY_UNLIKELY(x) __builtin_expect(!!(x), 0) +#else +#define NPY_LIKELY(x) (x) +#define NPY_UNLIKELY(x) (x) +#endif + +#ifdef HAVE___BUILTIN_PREFETCH +/* unlike _mm_prefetch also works on non-x86 */ +#define NPY_PREFETCH(x, rw, loc) __builtin_prefetch((x), (rw), (loc)) +#else +#ifdef NPY_HAVE_SSE +/* _MM_HINT_ET[01] (rw = 1) unsupported, only available in gcc >= 4.9 */ +#define NPY_PREFETCH(x, rw, loc) _mm_prefetch((x), loc == 0 ? _MM_HINT_NTA : \ + (loc == 1 ? _MM_HINT_T2 : \ + (loc == 2 ? _MM_HINT_T1 : \ + (loc == 3 ? _MM_HINT_T0 : -1)))) +#else +#define NPY_PREFETCH(x, rw,loc) +#endif +#endif + +/* `NPY_INLINE` kept for backwards compatibility; use `inline` instead */ +#if defined(_MSC_VER) && !defined(__clang__) + #define NPY_INLINE __inline +/* clang included here to handle clang-cl on Windows */ +#elif defined(__GNUC__) || defined(__clang__) + #if defined(__STRICT_ANSI__) + #define NPY_INLINE __inline__ + #else + #define NPY_INLINE inline + #endif +#else + #define NPY_INLINE +#endif + +#ifdef _MSC_VER + #define NPY_FINLINE static __forceinline +#elif defined(__GNUC__) + #define NPY_FINLINE static inline __attribute__((always_inline)) +#else + #define NPY_FINLINE static +#endif + +#if defined(_MSC_VER) + #define NPY_NOINLINE static __declspec(noinline) +#elif defined(__GNUC__) || defined(__clang__) + #define NPY_NOINLINE static __attribute__((noinline)) +#else + #define NPY_NOINLINE static +#endif + +#ifdef __cplusplus + #define NPY_TLS thread_local +#elif defined(HAVE_THREAD_LOCAL) + #define NPY_TLS thread_local +#elif defined(HAVE__THREAD_LOCAL) + #define NPY_TLS _Thread_local +#elif defined(HAVE___THREAD) + #define NPY_TLS __thread +#elif defined(HAVE___DECLSPEC_THREAD_) + #define NPY_TLS __declspec(thread) +#else + #define NPY_TLS +#endif + +#ifdef WITH_CPYCHECKER_RETURNS_BORROWED_REF_ATTRIBUTE + #define NPY_RETURNS_BORROWED_REF \ + __attribute__((cpychecker_returns_borrowed_ref)) +#else + #define NPY_RETURNS_BORROWED_REF +#endif + +#ifdef WITH_CPYCHECKER_STEALS_REFERENCE_TO_ARG_ATTRIBUTE + #define NPY_STEALS_REF_TO_ARG(n) \ + __attribute__((cpychecker_steals_reference_to_arg(n))) +#else + #define NPY_STEALS_REF_TO_ARG(n) +#endif + +/* 64 bit file position support, also on win-amd64. Issue gh-2256 */ +#if defined(_MSC_VER) && defined(_WIN64) && (_MSC_VER > 1400) || \ + defined(__MINGW32__) || defined(__MINGW64__) + #include + + #define npy_fseek _fseeki64 + #define npy_ftell _ftelli64 + #define npy_lseek _lseeki64 + #define npy_off_t npy_int64 + + #if NPY_SIZEOF_INT == 8 + #define NPY_OFF_T_PYFMT "i" + #elif NPY_SIZEOF_LONG == 8 + #define NPY_OFF_T_PYFMT "l" + #elif NPY_SIZEOF_LONGLONG == 8 + #define NPY_OFF_T_PYFMT "L" + #else + #error Unsupported size for type off_t + #endif +#else +#ifdef HAVE_FSEEKO + #define npy_fseek fseeko +#else + #define npy_fseek fseek +#endif +#ifdef HAVE_FTELLO + #define npy_ftell ftello +#else + #define npy_ftell ftell +#endif + #include + #ifndef _WIN32 + #include + #endif + #define npy_lseek lseek + #define npy_off_t off_t + + #if NPY_SIZEOF_OFF_T == NPY_SIZEOF_SHORT + #define NPY_OFF_T_PYFMT "h" + #elif NPY_SIZEOF_OFF_T == NPY_SIZEOF_INT + #define NPY_OFF_T_PYFMT "i" + #elif NPY_SIZEOF_OFF_T == NPY_SIZEOF_LONG + #define NPY_OFF_T_PYFMT "l" + #elif NPY_SIZEOF_OFF_T == NPY_SIZEOF_LONGLONG + #define NPY_OFF_T_PYFMT "L" + #else + #error Unsupported size for type off_t + #endif +#endif + +/* enums for detected endianness */ +enum { + NPY_CPU_UNKNOWN_ENDIAN, + NPY_CPU_LITTLE, + NPY_CPU_BIG +}; + +/* + * This is to typedef npy_intp to the appropriate size for Py_ssize_t. + * (Before NumPy 2.0 we used Py_intptr_t and Py_uintptr_t from `pyport.h`.) + */ +typedef Py_ssize_t npy_intp; +typedef size_t npy_uintp; + +/* + * Define sizes that were not defined in numpyconfig.h. + */ +#define NPY_SIZEOF_CHAR 1 +#define NPY_SIZEOF_BYTE 1 +#define NPY_SIZEOF_DATETIME 8 +#define NPY_SIZEOF_TIMEDELTA 8 +#define NPY_SIZEOF_HALF 2 +#define NPY_SIZEOF_CFLOAT NPY_SIZEOF_COMPLEX_FLOAT +#define NPY_SIZEOF_CDOUBLE NPY_SIZEOF_COMPLEX_DOUBLE +#define NPY_SIZEOF_CLONGDOUBLE NPY_SIZEOF_COMPLEX_LONGDOUBLE + +#ifdef constchar +#undef constchar +#endif + +#define NPY_SSIZE_T_PYFMT "n" +#define constchar char + +/* NPY_INTP_FMT Note: + * Unlike the other NPY_*_FMT macros, which are used with PyOS_snprintf, + * NPY_INTP_FMT is used with PyErr_Format and PyUnicode_FromFormat. Those + * functions use different formatting codes that are portably specified + * according to the Python documentation. See issue gh-2388. + */ +#if NPY_SIZEOF_INTP == NPY_SIZEOF_LONG + #define NPY_INTP NPY_LONG + #define NPY_UINTP NPY_ULONG + #define PyIntpArrType_Type PyLongArrType_Type + #define PyUIntpArrType_Type PyULongArrType_Type + #define NPY_MAX_INTP NPY_MAX_LONG + #define NPY_MIN_INTP NPY_MIN_LONG + #define NPY_MAX_UINTP NPY_MAX_ULONG + #define NPY_INTP_FMT "ld" +#elif NPY_SIZEOF_INTP == NPY_SIZEOF_INT + #define NPY_INTP NPY_INT + #define NPY_UINTP NPY_UINT + #define PyIntpArrType_Type PyIntArrType_Type + #define PyUIntpArrType_Type PyUIntArrType_Type + #define NPY_MAX_INTP NPY_MAX_INT + #define NPY_MIN_INTP NPY_MIN_INT + #define NPY_MAX_UINTP NPY_MAX_UINT + #define NPY_INTP_FMT "d" +#elif defined(PY_LONG_LONG) && (NPY_SIZEOF_INTP == NPY_SIZEOF_LONGLONG) + #define NPY_INTP NPY_LONGLONG + #define NPY_UINTP NPY_ULONGLONG + #define PyIntpArrType_Type PyLongLongArrType_Type + #define PyUIntpArrType_Type PyULongLongArrType_Type + #define NPY_MAX_INTP NPY_MAX_LONGLONG + #define NPY_MIN_INTP NPY_MIN_LONGLONG + #define NPY_MAX_UINTP NPY_MAX_ULONGLONG + #define NPY_INTP_FMT "lld" +#else + #error "Failed to correctly define NPY_INTP and NPY_UINTP" +#endif + + +/* + * Some platforms don't define bool, long long, or long double. + * Handle that here. + */ +#define NPY_BYTE_FMT "hhd" +#define NPY_UBYTE_FMT "hhu" +#define NPY_SHORT_FMT "hd" +#define NPY_USHORT_FMT "hu" +#define NPY_INT_FMT "d" +#define NPY_UINT_FMT "u" +#define NPY_LONG_FMT "ld" +#define NPY_ULONG_FMT "lu" +#define NPY_HALF_FMT "g" +#define NPY_FLOAT_FMT "g" +#define NPY_DOUBLE_FMT "g" + + +#ifdef PY_LONG_LONG +typedef PY_LONG_LONG npy_longlong; +typedef unsigned PY_LONG_LONG npy_ulonglong; +# ifdef _MSC_VER +# define NPY_LONGLONG_FMT "I64d" +# define NPY_ULONGLONG_FMT "I64u" +# else +# define NPY_LONGLONG_FMT "lld" +# define NPY_ULONGLONG_FMT "llu" +# endif +# ifdef _MSC_VER +# define NPY_LONGLONG_SUFFIX(x) (x##i64) +# define NPY_ULONGLONG_SUFFIX(x) (x##Ui64) +# else +# define NPY_LONGLONG_SUFFIX(x) (x##LL) +# define NPY_ULONGLONG_SUFFIX(x) (x##ULL) +# endif +#else +typedef long npy_longlong; +typedef unsigned long npy_ulonglong; +# define NPY_LONGLONG_SUFFIX(x) (x##L) +# define NPY_ULONGLONG_SUFFIX(x) (x##UL) +#endif + + +typedef unsigned char npy_bool; +#define NPY_FALSE 0 +#define NPY_TRUE 1 +/* + * `NPY_SIZEOF_LONGDOUBLE` isn't usually equal to sizeof(long double). + * In some certain cases, it may forced to be equal to sizeof(double) + * even against the compiler implementation and the same goes for + * `complex long double`. + * + * Therefore, avoid `long double`, use `npy_longdouble` instead, + * and when it comes to standard math functions make sure of using + * the double version when `NPY_SIZEOF_LONGDOUBLE` == `NPY_SIZEOF_DOUBLE`. + * For example: + * npy_longdouble *ptr, x; + * #if NPY_SIZEOF_LONGDOUBLE == NPY_SIZEOF_DOUBLE + * npy_longdouble r = modf(x, ptr); + * #else + * npy_longdouble r = modfl(x, ptr); + * #endif + * + * See https://github.com/numpy/numpy/issues/20348 + */ +#if NPY_SIZEOF_LONGDOUBLE == NPY_SIZEOF_DOUBLE + #define NPY_LONGDOUBLE_FMT "g" + #define longdouble_t double + typedef double npy_longdouble; +#else + #define NPY_LONGDOUBLE_FMT "Lg" + #define longdouble_t long double + typedef long double npy_longdouble; +#endif + +#ifndef Py_USING_UNICODE +#error Must use Python with unicode enabled. +#endif + + +typedef signed char npy_byte; +typedef unsigned char npy_ubyte; +typedef unsigned short npy_ushort; +typedef unsigned int npy_uint; +typedef unsigned long npy_ulong; + +/* These are for completeness */ +typedef char npy_char; +typedef short npy_short; +typedef int npy_int; +typedef long npy_long; +typedef float npy_float; +typedef double npy_double; + +typedef Py_hash_t npy_hash_t; +#define NPY_SIZEOF_HASH_T NPY_SIZEOF_INTP + +#if defined(__cplusplus) + +typedef struct +{ + double _Val[2]; +} npy_cdouble; + +typedef struct +{ + float _Val[2]; +} npy_cfloat; + +typedef struct +{ + long double _Val[2]; +} npy_clongdouble; + +#else + +#include + + +#if defined(_MSC_VER) && !defined(__INTEL_COMPILER) +typedef _Dcomplex npy_cdouble; +typedef _Fcomplex npy_cfloat; +typedef _Lcomplex npy_clongdouble; +#else /* !defined(_MSC_VER) || defined(__INTEL_COMPILER) */ +typedef double _Complex npy_cdouble; +typedef float _Complex npy_cfloat; +typedef longdouble_t _Complex npy_clongdouble; +#endif + +#endif + +/* + * numarray-style bit-width typedefs + */ +#define NPY_MAX_INT8 127 +#define NPY_MIN_INT8 -128 +#define NPY_MAX_UINT8 255 +#define NPY_MAX_INT16 32767 +#define NPY_MIN_INT16 -32768 +#define NPY_MAX_UINT16 65535 +#define NPY_MAX_INT32 2147483647 +#define NPY_MIN_INT32 (-NPY_MAX_INT32 - 1) +#define NPY_MAX_UINT32 4294967295U +#define NPY_MAX_INT64 NPY_LONGLONG_SUFFIX(9223372036854775807) +#define NPY_MIN_INT64 (-NPY_MAX_INT64 - NPY_LONGLONG_SUFFIX(1)) +#define NPY_MAX_UINT64 NPY_ULONGLONG_SUFFIX(18446744073709551615) +#define NPY_MAX_INT128 NPY_LONGLONG_SUFFIX(85070591730234615865843651857942052864) +#define NPY_MIN_INT128 (-NPY_MAX_INT128 - NPY_LONGLONG_SUFFIX(1)) +#define NPY_MAX_UINT128 NPY_ULONGLONG_SUFFIX(170141183460469231731687303715884105728) +#define NPY_MAX_INT256 NPY_LONGLONG_SUFFIX(57896044618658097711785492504343953926634992332820282019728792003956564819967) +#define NPY_MIN_INT256 (-NPY_MAX_INT256 - NPY_LONGLONG_SUFFIX(1)) +#define NPY_MAX_UINT256 NPY_ULONGLONG_SUFFIX(115792089237316195423570985008687907853269984665640564039457584007913129639935) +#define NPY_MIN_DATETIME NPY_MIN_INT64 +#define NPY_MAX_DATETIME NPY_MAX_INT64 +#define NPY_MIN_TIMEDELTA NPY_MIN_INT64 +#define NPY_MAX_TIMEDELTA NPY_MAX_INT64 + + /* Need to find the number of bits for each type and + make definitions accordingly. + + C states that sizeof(char) == 1 by definition + + So, just using the sizeof keyword won't help. + + It also looks like Python itself uses sizeof(char) quite a + bit, which by definition should be 1 all the time. + + Idea: Make Use of CHAR_BIT which should tell us how many + BITS per CHARACTER + */ + + /* Include platform definitions -- These are in the C89/90 standard */ +#include +#define NPY_MAX_BYTE SCHAR_MAX +#define NPY_MIN_BYTE SCHAR_MIN +#define NPY_MAX_UBYTE UCHAR_MAX +#define NPY_MAX_SHORT SHRT_MAX +#define NPY_MIN_SHORT SHRT_MIN +#define NPY_MAX_USHORT USHRT_MAX +#define NPY_MAX_INT INT_MAX +#ifndef INT_MIN +#define INT_MIN (-INT_MAX - 1) +#endif +#define NPY_MIN_INT INT_MIN +#define NPY_MAX_UINT UINT_MAX +#define NPY_MAX_LONG LONG_MAX +#define NPY_MIN_LONG LONG_MIN +#define NPY_MAX_ULONG ULONG_MAX + +#define NPY_BITSOF_BOOL (sizeof(npy_bool) * CHAR_BIT) +#define NPY_BITSOF_CHAR CHAR_BIT +#define NPY_BITSOF_BYTE (NPY_SIZEOF_BYTE * CHAR_BIT) +#define NPY_BITSOF_SHORT (NPY_SIZEOF_SHORT * CHAR_BIT) +#define NPY_BITSOF_INT (NPY_SIZEOF_INT * CHAR_BIT) +#define NPY_BITSOF_LONG (NPY_SIZEOF_LONG * CHAR_BIT) +#define NPY_BITSOF_LONGLONG (NPY_SIZEOF_LONGLONG * CHAR_BIT) +#define NPY_BITSOF_INTP (NPY_SIZEOF_INTP * CHAR_BIT) +#define NPY_BITSOF_HALF (NPY_SIZEOF_HALF * CHAR_BIT) +#define NPY_BITSOF_FLOAT (NPY_SIZEOF_FLOAT * CHAR_BIT) +#define NPY_BITSOF_DOUBLE (NPY_SIZEOF_DOUBLE * CHAR_BIT) +#define NPY_BITSOF_LONGDOUBLE (NPY_SIZEOF_LONGDOUBLE * CHAR_BIT) +#define NPY_BITSOF_CFLOAT (NPY_SIZEOF_CFLOAT * CHAR_BIT) +#define NPY_BITSOF_CDOUBLE (NPY_SIZEOF_CDOUBLE * CHAR_BIT) +#define NPY_BITSOF_CLONGDOUBLE (NPY_SIZEOF_CLONGDOUBLE * CHAR_BIT) +#define NPY_BITSOF_DATETIME (NPY_SIZEOF_DATETIME * CHAR_BIT) +#define NPY_BITSOF_TIMEDELTA (NPY_SIZEOF_TIMEDELTA * CHAR_BIT) + +#if NPY_BITSOF_LONG == 8 +#define NPY_INT8 NPY_LONG +#define NPY_UINT8 NPY_ULONG + typedef long npy_int8; + typedef unsigned long npy_uint8; +#define PyInt8ScalarObject PyLongScalarObject +#define PyInt8ArrType_Type PyLongArrType_Type +#define PyUInt8ScalarObject PyULongScalarObject +#define PyUInt8ArrType_Type PyULongArrType_Type +#define NPY_INT8_FMT NPY_LONG_FMT +#define NPY_UINT8_FMT NPY_ULONG_FMT +#elif NPY_BITSOF_LONG == 16 +#define NPY_INT16 NPY_LONG +#define NPY_UINT16 NPY_ULONG + typedef long npy_int16; + typedef unsigned long npy_uint16; +#define PyInt16ScalarObject PyLongScalarObject +#define PyInt16ArrType_Type PyLongArrType_Type +#define PyUInt16ScalarObject PyULongScalarObject +#define PyUInt16ArrType_Type PyULongArrType_Type +#define NPY_INT16_FMT NPY_LONG_FMT +#define NPY_UINT16_FMT NPY_ULONG_FMT +#elif NPY_BITSOF_LONG == 32 +#define NPY_INT32 NPY_LONG +#define NPY_UINT32 NPY_ULONG + typedef long npy_int32; + typedef unsigned long npy_uint32; + typedef unsigned long npy_ucs4; +#define PyInt32ScalarObject PyLongScalarObject +#define PyInt32ArrType_Type PyLongArrType_Type +#define PyUInt32ScalarObject PyULongScalarObject +#define PyUInt32ArrType_Type PyULongArrType_Type +#define NPY_INT32_FMT NPY_LONG_FMT +#define NPY_UINT32_FMT NPY_ULONG_FMT +#elif NPY_BITSOF_LONG == 64 +#define NPY_INT64 NPY_LONG +#define NPY_UINT64 NPY_ULONG + typedef long npy_int64; + typedef unsigned long npy_uint64; +#define PyInt64ScalarObject PyLongScalarObject +#define PyInt64ArrType_Type PyLongArrType_Type +#define PyUInt64ScalarObject PyULongScalarObject +#define PyUInt64ArrType_Type PyULongArrType_Type +#define NPY_INT64_FMT NPY_LONG_FMT +#define NPY_UINT64_FMT NPY_ULONG_FMT +#define MyPyLong_FromInt64 PyLong_FromLong +#define MyPyLong_AsInt64 PyLong_AsLong +#elif NPY_BITSOF_LONG == 128 +#define NPY_INT128 NPY_LONG +#define NPY_UINT128 NPY_ULONG + typedef long npy_int128; + typedef unsigned long npy_uint128; +#define PyInt128ScalarObject PyLongScalarObject +#define PyInt128ArrType_Type PyLongArrType_Type +#define PyUInt128ScalarObject PyULongScalarObject +#define PyUInt128ArrType_Type PyULongArrType_Type +#define NPY_INT128_FMT NPY_LONG_FMT +#define NPY_UINT128_FMT NPY_ULONG_FMT +#endif + +#if NPY_BITSOF_LONGLONG == 8 +# ifndef NPY_INT8 +# define NPY_INT8 NPY_LONGLONG +# define NPY_UINT8 NPY_ULONGLONG + typedef npy_longlong npy_int8; + typedef npy_ulonglong npy_uint8; +# define PyInt8ScalarObject PyLongLongScalarObject +# define PyInt8ArrType_Type PyLongLongArrType_Type +# define PyUInt8ScalarObject PyULongLongScalarObject +# define PyUInt8ArrType_Type PyULongLongArrType_Type +#define NPY_INT8_FMT NPY_LONGLONG_FMT +#define NPY_UINT8_FMT NPY_ULONGLONG_FMT +# endif +# define NPY_MAX_LONGLONG NPY_MAX_INT8 +# define NPY_MIN_LONGLONG NPY_MIN_INT8 +# define NPY_MAX_ULONGLONG NPY_MAX_UINT8 +#elif NPY_BITSOF_LONGLONG == 16 +# ifndef NPY_INT16 +# define NPY_INT16 NPY_LONGLONG +# define NPY_UINT16 NPY_ULONGLONG + typedef npy_longlong npy_int16; + typedef npy_ulonglong npy_uint16; +# define PyInt16ScalarObject PyLongLongScalarObject +# define PyInt16ArrType_Type PyLongLongArrType_Type +# define PyUInt16ScalarObject PyULongLongScalarObject +# define PyUInt16ArrType_Type PyULongLongArrType_Type +#define NPY_INT16_FMT NPY_LONGLONG_FMT +#define NPY_UINT16_FMT NPY_ULONGLONG_FMT +# endif +# define NPY_MAX_LONGLONG NPY_MAX_INT16 +# define NPY_MIN_LONGLONG NPY_MIN_INT16 +# define NPY_MAX_ULONGLONG NPY_MAX_UINT16 +#elif NPY_BITSOF_LONGLONG == 32 +# ifndef NPY_INT32 +# define NPY_INT32 NPY_LONGLONG +# define NPY_UINT32 NPY_ULONGLONG + typedef npy_longlong npy_int32; + typedef npy_ulonglong npy_uint32; + typedef npy_ulonglong npy_ucs4; +# define PyInt32ScalarObject PyLongLongScalarObject +# define PyInt32ArrType_Type PyLongLongArrType_Type +# define PyUInt32ScalarObject PyULongLongScalarObject +# define PyUInt32ArrType_Type PyULongLongArrType_Type +#define NPY_INT32_FMT NPY_LONGLONG_FMT +#define NPY_UINT32_FMT NPY_ULONGLONG_FMT +# endif +# define NPY_MAX_LONGLONG NPY_MAX_INT32 +# define NPY_MIN_LONGLONG NPY_MIN_INT32 +# define NPY_MAX_ULONGLONG NPY_MAX_UINT32 +#elif NPY_BITSOF_LONGLONG == 64 +# ifndef NPY_INT64 +# define NPY_INT64 NPY_LONGLONG +# define NPY_UINT64 NPY_ULONGLONG + typedef npy_longlong npy_int64; + typedef npy_ulonglong npy_uint64; +# define PyInt64ScalarObject PyLongLongScalarObject +# define PyInt64ArrType_Type PyLongLongArrType_Type +# define PyUInt64ScalarObject PyULongLongScalarObject +# define PyUInt64ArrType_Type PyULongLongArrType_Type +#define NPY_INT64_FMT NPY_LONGLONG_FMT +#define NPY_UINT64_FMT NPY_ULONGLONG_FMT +# define MyPyLong_FromInt64 PyLong_FromLongLong +# define MyPyLong_AsInt64 PyLong_AsLongLong +# endif +# define NPY_MAX_LONGLONG NPY_MAX_INT64 +# define NPY_MIN_LONGLONG NPY_MIN_INT64 +# define NPY_MAX_ULONGLONG NPY_MAX_UINT64 +#elif NPY_BITSOF_LONGLONG == 128 +# ifndef NPY_INT128 +# define NPY_INT128 NPY_LONGLONG +# define NPY_UINT128 NPY_ULONGLONG + typedef npy_longlong npy_int128; + typedef npy_ulonglong npy_uint128; +# define PyInt128ScalarObject PyLongLongScalarObject +# define PyInt128ArrType_Type PyLongLongArrType_Type +# define PyUInt128ScalarObject PyULongLongScalarObject +# define PyUInt128ArrType_Type PyULongLongArrType_Type +#define NPY_INT128_FMT NPY_LONGLONG_FMT +#define NPY_UINT128_FMT NPY_ULONGLONG_FMT +# endif +# define NPY_MAX_LONGLONG NPY_MAX_INT128 +# define NPY_MIN_LONGLONG NPY_MIN_INT128 +# define NPY_MAX_ULONGLONG NPY_MAX_UINT128 +#elif NPY_BITSOF_LONGLONG == 256 +# define NPY_INT256 NPY_LONGLONG +# define NPY_UINT256 NPY_ULONGLONG + typedef npy_longlong npy_int256; + typedef npy_ulonglong npy_uint256; +# define PyInt256ScalarObject PyLongLongScalarObject +# define PyInt256ArrType_Type PyLongLongArrType_Type +# define PyUInt256ScalarObject PyULongLongScalarObject +# define PyUInt256ArrType_Type PyULongLongArrType_Type +#define NPY_INT256_FMT NPY_LONGLONG_FMT +#define NPY_UINT256_FMT NPY_ULONGLONG_FMT +# define NPY_MAX_LONGLONG NPY_MAX_INT256 +# define NPY_MIN_LONGLONG NPY_MIN_INT256 +# define NPY_MAX_ULONGLONG NPY_MAX_UINT256 +#endif + +#if NPY_BITSOF_INT == 8 +#ifndef NPY_INT8 +#define NPY_INT8 NPY_INT +#define NPY_UINT8 NPY_UINT + typedef int npy_int8; + typedef unsigned int npy_uint8; +# define PyInt8ScalarObject PyIntScalarObject +# define PyInt8ArrType_Type PyIntArrType_Type +# define PyUInt8ScalarObject PyUIntScalarObject +# define PyUInt8ArrType_Type PyUIntArrType_Type +#define NPY_INT8_FMT NPY_INT_FMT +#define NPY_UINT8_FMT NPY_UINT_FMT +#endif +#elif NPY_BITSOF_INT == 16 +#ifndef NPY_INT16 +#define NPY_INT16 NPY_INT +#define NPY_UINT16 NPY_UINT + typedef int npy_int16; + typedef unsigned int npy_uint16; +# define PyInt16ScalarObject PyIntScalarObject +# define PyInt16ArrType_Type PyIntArrType_Type +# define PyUInt16ScalarObject PyIntUScalarObject +# define PyUInt16ArrType_Type PyIntUArrType_Type +#define NPY_INT16_FMT NPY_INT_FMT +#define NPY_UINT16_FMT NPY_UINT_FMT +#endif +#elif NPY_BITSOF_INT == 32 +#ifndef NPY_INT32 +#define NPY_INT32 NPY_INT +#define NPY_UINT32 NPY_UINT + typedef int npy_int32; + typedef unsigned int npy_uint32; + typedef unsigned int npy_ucs4; +# define PyInt32ScalarObject PyIntScalarObject +# define PyInt32ArrType_Type PyIntArrType_Type +# define PyUInt32ScalarObject PyUIntScalarObject +# define PyUInt32ArrType_Type PyUIntArrType_Type +#define NPY_INT32_FMT NPY_INT_FMT +#define NPY_UINT32_FMT NPY_UINT_FMT +#endif +#elif NPY_BITSOF_INT == 64 +#ifndef NPY_INT64 +#define NPY_INT64 NPY_INT +#define NPY_UINT64 NPY_UINT + typedef int npy_int64; + typedef unsigned int npy_uint64; +# define PyInt64ScalarObject PyIntScalarObject +# define PyInt64ArrType_Type PyIntArrType_Type +# define PyUInt64ScalarObject PyUIntScalarObject +# define PyUInt64ArrType_Type PyUIntArrType_Type +#define NPY_INT64_FMT NPY_INT_FMT +#define NPY_UINT64_FMT NPY_UINT_FMT +# define MyPyLong_FromInt64 PyLong_FromLong +# define MyPyLong_AsInt64 PyLong_AsLong +#endif +#elif NPY_BITSOF_INT == 128 +#ifndef NPY_INT128 +#define NPY_INT128 NPY_INT +#define NPY_UINT128 NPY_UINT + typedef int npy_int128; + typedef unsigned int npy_uint128; +# define PyInt128ScalarObject PyIntScalarObject +# define PyInt128ArrType_Type PyIntArrType_Type +# define PyUInt128ScalarObject PyUIntScalarObject +# define PyUInt128ArrType_Type PyUIntArrType_Type +#define NPY_INT128_FMT NPY_INT_FMT +#define NPY_UINT128_FMT NPY_UINT_FMT +#endif +#endif + +#if NPY_BITSOF_SHORT == 8 +#ifndef NPY_INT8 +#define NPY_INT8 NPY_SHORT +#define NPY_UINT8 NPY_USHORT + typedef short npy_int8; + typedef unsigned short npy_uint8; +# define PyInt8ScalarObject PyShortScalarObject +# define PyInt8ArrType_Type PyShortArrType_Type +# define PyUInt8ScalarObject PyUShortScalarObject +# define PyUInt8ArrType_Type PyUShortArrType_Type +#define NPY_INT8_FMT NPY_SHORT_FMT +#define NPY_UINT8_FMT NPY_USHORT_FMT +#endif +#elif NPY_BITSOF_SHORT == 16 +#ifndef NPY_INT16 +#define NPY_INT16 NPY_SHORT +#define NPY_UINT16 NPY_USHORT + typedef short npy_int16; + typedef unsigned short npy_uint16; +# define PyInt16ScalarObject PyShortScalarObject +# define PyInt16ArrType_Type PyShortArrType_Type +# define PyUInt16ScalarObject PyUShortScalarObject +# define PyUInt16ArrType_Type PyUShortArrType_Type +#define NPY_INT16_FMT NPY_SHORT_FMT +#define NPY_UINT16_FMT NPY_USHORT_FMT +#endif +#elif NPY_BITSOF_SHORT == 32 +#ifndef NPY_INT32 +#define NPY_INT32 NPY_SHORT +#define NPY_UINT32 NPY_USHORT + typedef short npy_int32; + typedef unsigned short npy_uint32; + typedef unsigned short npy_ucs4; +# define PyInt32ScalarObject PyShortScalarObject +# define PyInt32ArrType_Type PyShortArrType_Type +# define PyUInt32ScalarObject PyUShortScalarObject +# define PyUInt32ArrType_Type PyUShortArrType_Type +#define NPY_INT32_FMT NPY_SHORT_FMT +#define NPY_UINT32_FMT NPY_USHORT_FMT +#endif +#elif NPY_BITSOF_SHORT == 64 +#ifndef NPY_INT64 +#define NPY_INT64 NPY_SHORT +#define NPY_UINT64 NPY_USHORT + typedef short npy_int64; + typedef unsigned short npy_uint64; +# define PyInt64ScalarObject PyShortScalarObject +# define PyInt64ArrType_Type PyShortArrType_Type +# define PyUInt64ScalarObject PyUShortScalarObject +# define PyUInt64ArrType_Type PyUShortArrType_Type +#define NPY_INT64_FMT NPY_SHORT_FMT +#define NPY_UINT64_FMT NPY_USHORT_FMT +# define MyPyLong_FromInt64 PyLong_FromLong +# define MyPyLong_AsInt64 PyLong_AsLong +#endif +#elif NPY_BITSOF_SHORT == 128 +#ifndef NPY_INT128 +#define NPY_INT128 NPY_SHORT +#define NPY_UINT128 NPY_USHORT + typedef short npy_int128; + typedef unsigned short npy_uint128; +# define PyInt128ScalarObject PyShortScalarObject +# define PyInt128ArrType_Type PyShortArrType_Type +# define PyUInt128ScalarObject PyUShortScalarObject +# define PyUInt128ArrType_Type PyUShortArrType_Type +#define NPY_INT128_FMT NPY_SHORT_FMT +#define NPY_UINT128_FMT NPY_USHORT_FMT +#endif +#endif + + +#if NPY_BITSOF_CHAR == 8 +#ifndef NPY_INT8 +#define NPY_INT8 NPY_BYTE +#define NPY_UINT8 NPY_UBYTE + typedef signed char npy_int8; + typedef unsigned char npy_uint8; +# define PyInt8ScalarObject PyByteScalarObject +# define PyInt8ArrType_Type PyByteArrType_Type +# define PyUInt8ScalarObject PyUByteScalarObject +# define PyUInt8ArrType_Type PyUByteArrType_Type +#define NPY_INT8_FMT NPY_BYTE_FMT +#define NPY_UINT8_FMT NPY_UBYTE_FMT +#endif +#elif NPY_BITSOF_CHAR == 16 +#ifndef NPY_INT16 +#define NPY_INT16 NPY_BYTE +#define NPY_UINT16 NPY_UBYTE + typedef signed char npy_int16; + typedef unsigned char npy_uint16; +# define PyInt16ScalarObject PyByteScalarObject +# define PyInt16ArrType_Type PyByteArrType_Type +# define PyUInt16ScalarObject PyUByteScalarObject +# define PyUInt16ArrType_Type PyUByteArrType_Type +#define NPY_INT16_FMT NPY_BYTE_FMT +#define NPY_UINT16_FMT NPY_UBYTE_FMT +#endif +#elif NPY_BITSOF_CHAR == 32 +#ifndef NPY_INT32 +#define NPY_INT32 NPY_BYTE +#define NPY_UINT32 NPY_UBYTE + typedef signed char npy_int32; + typedef unsigned char npy_uint32; + typedef unsigned char npy_ucs4; +# define PyInt32ScalarObject PyByteScalarObject +# define PyInt32ArrType_Type PyByteArrType_Type +# define PyUInt32ScalarObject PyUByteScalarObject +# define PyUInt32ArrType_Type PyUByteArrType_Type +#define NPY_INT32_FMT NPY_BYTE_FMT +#define NPY_UINT32_FMT NPY_UBYTE_FMT +#endif +#elif NPY_BITSOF_CHAR == 64 +#ifndef NPY_INT64 +#define NPY_INT64 NPY_BYTE +#define NPY_UINT64 NPY_UBYTE + typedef signed char npy_int64; + typedef unsigned char npy_uint64; +# define PyInt64ScalarObject PyByteScalarObject +# define PyInt64ArrType_Type PyByteArrType_Type +# define PyUInt64ScalarObject PyUByteScalarObject +# define PyUInt64ArrType_Type PyUByteArrType_Type +#define NPY_INT64_FMT NPY_BYTE_FMT +#define NPY_UINT64_FMT NPY_UBYTE_FMT +# define MyPyLong_FromInt64 PyLong_FromLong +# define MyPyLong_AsInt64 PyLong_AsLong +#endif +#elif NPY_BITSOF_CHAR == 128 +#ifndef NPY_INT128 +#define NPY_INT128 NPY_BYTE +#define NPY_UINT128 NPY_UBYTE + typedef signed char npy_int128; + typedef unsigned char npy_uint128; +# define PyInt128ScalarObject PyByteScalarObject +# define PyInt128ArrType_Type PyByteArrType_Type +# define PyUInt128ScalarObject PyUByteScalarObject +# define PyUInt128ArrType_Type PyUByteArrType_Type +#define NPY_INT128_FMT NPY_BYTE_FMT +#define NPY_UINT128_FMT NPY_UBYTE_FMT +#endif +#endif + + + +#if NPY_BITSOF_DOUBLE == 32 +#ifndef NPY_FLOAT32 +#define NPY_FLOAT32 NPY_DOUBLE +#define NPY_COMPLEX64 NPY_CDOUBLE + typedef double npy_float32; + typedef npy_cdouble npy_complex64; +# define PyFloat32ScalarObject PyDoubleScalarObject +# define PyComplex64ScalarObject PyCDoubleScalarObject +# define PyFloat32ArrType_Type PyDoubleArrType_Type +# define PyComplex64ArrType_Type PyCDoubleArrType_Type +#define NPY_FLOAT32_FMT NPY_DOUBLE_FMT +#define NPY_COMPLEX64_FMT NPY_CDOUBLE_FMT +#endif +#elif NPY_BITSOF_DOUBLE == 64 +#ifndef NPY_FLOAT64 +#define NPY_FLOAT64 NPY_DOUBLE +#define NPY_COMPLEX128 NPY_CDOUBLE + typedef double npy_float64; + typedef npy_cdouble npy_complex128; +# define PyFloat64ScalarObject PyDoubleScalarObject +# define PyComplex128ScalarObject PyCDoubleScalarObject +# define PyFloat64ArrType_Type PyDoubleArrType_Type +# define PyComplex128ArrType_Type PyCDoubleArrType_Type +#define NPY_FLOAT64_FMT NPY_DOUBLE_FMT +#define NPY_COMPLEX128_FMT NPY_CDOUBLE_FMT +#endif +#elif NPY_BITSOF_DOUBLE == 80 +#ifndef NPY_FLOAT80 +#define NPY_FLOAT80 NPY_DOUBLE +#define NPY_COMPLEX160 NPY_CDOUBLE + typedef double npy_float80; + typedef npy_cdouble npy_complex160; +# define PyFloat80ScalarObject PyDoubleScalarObject +# define PyComplex160ScalarObject PyCDoubleScalarObject +# define PyFloat80ArrType_Type PyDoubleArrType_Type +# define PyComplex160ArrType_Type PyCDoubleArrType_Type +#define NPY_FLOAT80_FMT NPY_DOUBLE_FMT +#define NPY_COMPLEX160_FMT NPY_CDOUBLE_FMT +#endif +#elif NPY_BITSOF_DOUBLE == 96 +#ifndef NPY_FLOAT96 +#define NPY_FLOAT96 NPY_DOUBLE +#define NPY_COMPLEX192 NPY_CDOUBLE + typedef double npy_float96; + typedef npy_cdouble npy_complex192; +# define PyFloat96ScalarObject PyDoubleScalarObject +# define PyComplex192ScalarObject PyCDoubleScalarObject +# define PyFloat96ArrType_Type PyDoubleArrType_Type +# define PyComplex192ArrType_Type PyCDoubleArrType_Type +#define NPY_FLOAT96_FMT NPY_DOUBLE_FMT +#define NPY_COMPLEX192_FMT NPY_CDOUBLE_FMT +#endif +#elif NPY_BITSOF_DOUBLE == 128 +#ifndef NPY_FLOAT128 +#define NPY_FLOAT128 NPY_DOUBLE +#define NPY_COMPLEX256 NPY_CDOUBLE + typedef double npy_float128; + typedef npy_cdouble npy_complex256; +# define PyFloat128ScalarObject PyDoubleScalarObject +# define PyComplex256ScalarObject PyCDoubleScalarObject +# define PyFloat128ArrType_Type PyDoubleArrType_Type +# define PyComplex256ArrType_Type PyCDoubleArrType_Type +#define NPY_FLOAT128_FMT NPY_DOUBLE_FMT +#define NPY_COMPLEX256_FMT NPY_CDOUBLE_FMT +#endif +#endif + + + +#if NPY_BITSOF_FLOAT == 32 +#ifndef NPY_FLOAT32 +#define NPY_FLOAT32 NPY_FLOAT +#define NPY_COMPLEX64 NPY_CFLOAT + typedef float npy_float32; + typedef npy_cfloat npy_complex64; +# define PyFloat32ScalarObject PyFloatScalarObject +# define PyComplex64ScalarObject PyCFloatScalarObject +# define PyFloat32ArrType_Type PyFloatArrType_Type +# define PyComplex64ArrType_Type PyCFloatArrType_Type +#define NPY_FLOAT32_FMT NPY_FLOAT_FMT +#define NPY_COMPLEX64_FMT NPY_CFLOAT_FMT +#endif +#elif NPY_BITSOF_FLOAT == 64 +#ifndef NPY_FLOAT64 +#define NPY_FLOAT64 NPY_FLOAT +#define NPY_COMPLEX128 NPY_CFLOAT + typedef float npy_float64; + typedef npy_cfloat npy_complex128; +# define PyFloat64ScalarObject PyFloatScalarObject +# define PyComplex128ScalarObject PyCFloatScalarObject +# define PyFloat64ArrType_Type PyFloatArrType_Type +# define PyComplex128ArrType_Type PyCFloatArrType_Type +#define NPY_FLOAT64_FMT NPY_FLOAT_FMT +#define NPY_COMPLEX128_FMT NPY_CFLOAT_FMT +#endif +#elif NPY_BITSOF_FLOAT == 80 +#ifndef NPY_FLOAT80 +#define NPY_FLOAT80 NPY_FLOAT +#define NPY_COMPLEX160 NPY_CFLOAT + typedef float npy_float80; + typedef npy_cfloat npy_complex160; +# define PyFloat80ScalarObject PyFloatScalarObject +# define PyComplex160ScalarObject PyCFloatScalarObject +# define PyFloat80ArrType_Type PyFloatArrType_Type +# define PyComplex160ArrType_Type PyCFloatArrType_Type +#define NPY_FLOAT80_FMT NPY_FLOAT_FMT +#define NPY_COMPLEX160_FMT NPY_CFLOAT_FMT +#endif +#elif NPY_BITSOF_FLOAT == 96 +#ifndef NPY_FLOAT96 +#define NPY_FLOAT96 NPY_FLOAT +#define NPY_COMPLEX192 NPY_CFLOAT + typedef float npy_float96; + typedef npy_cfloat npy_complex192; +# define PyFloat96ScalarObject PyFloatScalarObject +# define PyComplex192ScalarObject PyCFloatScalarObject +# define PyFloat96ArrType_Type PyFloatArrType_Type +# define PyComplex192ArrType_Type PyCFloatArrType_Type +#define NPY_FLOAT96_FMT NPY_FLOAT_FMT +#define NPY_COMPLEX192_FMT NPY_CFLOAT_FMT +#endif +#elif NPY_BITSOF_FLOAT == 128 +#ifndef NPY_FLOAT128 +#define NPY_FLOAT128 NPY_FLOAT +#define NPY_COMPLEX256 NPY_CFLOAT + typedef float npy_float128; + typedef npy_cfloat npy_complex256; +# define PyFloat128ScalarObject PyFloatScalarObject +# define PyComplex256ScalarObject PyCFloatScalarObject +# define PyFloat128ArrType_Type PyFloatArrType_Type +# define PyComplex256ArrType_Type PyCFloatArrType_Type +#define NPY_FLOAT128_FMT NPY_FLOAT_FMT +#define NPY_COMPLEX256_FMT NPY_CFLOAT_FMT +#endif +#endif + +/* half/float16 isn't a floating-point type in C */ +#define NPY_FLOAT16 NPY_HALF +typedef npy_uint16 npy_half; +typedef npy_half npy_float16; + +#if NPY_BITSOF_LONGDOUBLE == 32 +#ifndef NPY_FLOAT32 +#define NPY_FLOAT32 NPY_LONGDOUBLE +#define NPY_COMPLEX64 NPY_CLONGDOUBLE + typedef npy_longdouble npy_float32; + typedef npy_clongdouble npy_complex64; +# define PyFloat32ScalarObject PyLongDoubleScalarObject +# define PyComplex64ScalarObject PyCLongDoubleScalarObject +# define PyFloat32ArrType_Type PyLongDoubleArrType_Type +# define PyComplex64ArrType_Type PyCLongDoubleArrType_Type +#define NPY_FLOAT32_FMT NPY_LONGDOUBLE_FMT +#define NPY_COMPLEX64_FMT NPY_CLONGDOUBLE_FMT +#endif +#elif NPY_BITSOF_LONGDOUBLE == 64 +#ifndef NPY_FLOAT64 +#define NPY_FLOAT64 NPY_LONGDOUBLE +#define NPY_COMPLEX128 NPY_CLONGDOUBLE + typedef npy_longdouble npy_float64; + typedef npy_clongdouble npy_complex128; +# define PyFloat64ScalarObject PyLongDoubleScalarObject +# define PyComplex128ScalarObject PyCLongDoubleScalarObject +# define PyFloat64ArrType_Type PyLongDoubleArrType_Type +# define PyComplex128ArrType_Type PyCLongDoubleArrType_Type +#define NPY_FLOAT64_FMT NPY_LONGDOUBLE_FMT +#define NPY_COMPLEX128_FMT NPY_CLONGDOUBLE_FMT +#endif +#elif NPY_BITSOF_LONGDOUBLE == 80 +#ifndef NPY_FLOAT80 +#define NPY_FLOAT80 NPY_LONGDOUBLE +#define NPY_COMPLEX160 NPY_CLONGDOUBLE + typedef npy_longdouble npy_float80; + typedef npy_clongdouble npy_complex160; +# define PyFloat80ScalarObject PyLongDoubleScalarObject +# define PyComplex160ScalarObject PyCLongDoubleScalarObject +# define PyFloat80ArrType_Type PyLongDoubleArrType_Type +# define PyComplex160ArrType_Type PyCLongDoubleArrType_Type +#define NPY_FLOAT80_FMT NPY_LONGDOUBLE_FMT +#define NPY_COMPLEX160_FMT NPY_CLONGDOUBLE_FMT +#endif +#elif NPY_BITSOF_LONGDOUBLE == 96 +#ifndef NPY_FLOAT96 +#define NPY_FLOAT96 NPY_LONGDOUBLE +#define NPY_COMPLEX192 NPY_CLONGDOUBLE + typedef npy_longdouble npy_float96; + typedef npy_clongdouble npy_complex192; +# define PyFloat96ScalarObject PyLongDoubleScalarObject +# define PyComplex192ScalarObject PyCLongDoubleScalarObject +# define PyFloat96ArrType_Type PyLongDoubleArrType_Type +# define PyComplex192ArrType_Type PyCLongDoubleArrType_Type +#define NPY_FLOAT96_FMT NPY_LONGDOUBLE_FMT +#define NPY_COMPLEX192_FMT NPY_CLONGDOUBLE_FMT +#endif +#elif NPY_BITSOF_LONGDOUBLE == 128 +#ifndef NPY_FLOAT128 +#define NPY_FLOAT128 NPY_LONGDOUBLE +#define NPY_COMPLEX256 NPY_CLONGDOUBLE + typedef npy_longdouble npy_float128; + typedef npy_clongdouble npy_complex256; +# define PyFloat128ScalarObject PyLongDoubleScalarObject +# define PyComplex256ScalarObject PyCLongDoubleScalarObject +# define PyFloat128ArrType_Type PyLongDoubleArrType_Type +# define PyComplex256ArrType_Type PyCLongDoubleArrType_Type +#define NPY_FLOAT128_FMT NPY_LONGDOUBLE_FMT +#define NPY_COMPLEX256_FMT NPY_CLONGDOUBLE_FMT +#endif +#elif NPY_BITSOF_LONGDOUBLE == 256 +#define NPY_FLOAT256 NPY_LONGDOUBLE +#define NPY_COMPLEX512 NPY_CLONGDOUBLE + typedef npy_longdouble npy_float256; + typedef npy_clongdouble npy_complex512; +# define PyFloat256ScalarObject PyLongDoubleScalarObject +# define PyComplex512ScalarObject PyCLongDoubleScalarObject +# define PyFloat256ArrType_Type PyLongDoubleArrType_Type +# define PyComplex512ArrType_Type PyCLongDoubleArrType_Type +#define NPY_FLOAT256_FMT NPY_LONGDOUBLE_FMT +#define NPY_COMPLEX512_FMT NPY_CLONGDOUBLE_FMT +#endif + +/* datetime typedefs */ +typedef npy_int64 npy_timedelta; +typedef npy_int64 npy_datetime; +#define NPY_DATETIME_FMT NPY_INT64_FMT +#define NPY_TIMEDELTA_FMT NPY_INT64_FMT + +/* End of typedefs for numarray style bit-width names */ + +#endif /* NUMPY_CORE_INCLUDE_NUMPY_NPY_COMMON_H_ */ diff --git a/venv/lib/python3.12/site-packages/numpy/_core/include/numpy/npy_cpu.h b/venv/lib/python3.12/site-packages/numpy/_core/include/numpy/npy_cpu.h new file mode 100644 index 00000000..a19f8e6b --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/include/numpy/npy_cpu.h @@ -0,0 +1,129 @@ +/* + * This set (target) cpu specific macros: + * - Possible values: + * NPY_CPU_X86 + * NPY_CPU_AMD64 + * NPY_CPU_PPC + * NPY_CPU_PPC64 + * NPY_CPU_PPC64LE + * NPY_CPU_SPARC + * NPY_CPU_S390 + * NPY_CPU_IA64 + * NPY_CPU_HPPA + * NPY_CPU_ALPHA + * NPY_CPU_ARMEL + * NPY_CPU_ARMEB + * NPY_CPU_SH_LE + * NPY_CPU_SH_BE + * NPY_CPU_ARCEL + * NPY_CPU_ARCEB + * NPY_CPU_RISCV64 + * NPY_CPU_LOONGARCH + * NPY_CPU_WASM + */ +#ifndef NUMPY_CORE_INCLUDE_NUMPY_NPY_CPU_H_ +#define NUMPY_CORE_INCLUDE_NUMPY_NPY_CPU_H_ + +#include "numpyconfig.h" + +#if defined( __i386__ ) || defined(i386) || defined(_M_IX86) + /* + * __i386__ is defined by gcc and Intel compiler on Linux, + * _M_IX86 by VS compiler, + * i386 by Sun compilers on opensolaris at least + */ + #define NPY_CPU_X86 +#elif defined(__x86_64__) || defined(__amd64__) || defined(__x86_64) || defined(_M_AMD64) + /* + * both __x86_64__ and __amd64__ are defined by gcc + * __x86_64 defined by sun compiler on opensolaris at least + * _M_AMD64 defined by MS compiler + */ + #define NPY_CPU_AMD64 +#elif defined(__powerpc64__) && defined(__LITTLE_ENDIAN__) + #define NPY_CPU_PPC64LE +#elif defined(__powerpc64__) && defined(__BIG_ENDIAN__) + #define NPY_CPU_PPC64 +#elif defined(__ppc__) || defined(__powerpc__) || defined(_ARCH_PPC) + /* + * __ppc__ is defined by gcc, I remember having seen __powerpc__ once, + * but can't find it ATM + * _ARCH_PPC is used by at least gcc on AIX + * As __powerpc__ and _ARCH_PPC are also defined by PPC64 check + * for those specifically first before defaulting to ppc + */ + #define NPY_CPU_PPC +#elif defined(__sparc__) || defined(__sparc) + /* __sparc__ is defined by gcc and Forte (e.g. Sun) compilers */ + #define NPY_CPU_SPARC +#elif defined(__s390__) + #define NPY_CPU_S390 +#elif defined(__ia64) + #define NPY_CPU_IA64 +#elif defined(__hppa) + #define NPY_CPU_HPPA +#elif defined(__alpha__) + #define NPY_CPU_ALPHA +#elif defined(__arm__) || defined(__aarch64__) || defined(_M_ARM64) + /* _M_ARM64 is defined in MSVC for ARM64 compilation on Windows */ + #if defined(__ARMEB__) || defined(__AARCH64EB__) + #if defined(__ARM_32BIT_STATE) + #define NPY_CPU_ARMEB_AARCH32 + #elif defined(__ARM_64BIT_STATE) + #define NPY_CPU_ARMEB_AARCH64 + #else + #define NPY_CPU_ARMEB + #endif + #elif defined(__ARMEL__) || defined(__AARCH64EL__) || defined(_M_ARM64) + #if defined(__ARM_32BIT_STATE) + #define NPY_CPU_ARMEL_AARCH32 + #elif defined(__ARM_64BIT_STATE) || defined(_M_ARM64) || defined(__AARCH64EL__) + #define NPY_CPU_ARMEL_AARCH64 + #else + #define NPY_CPU_ARMEL + #endif + #else + # error Unknown ARM CPU, please report this to numpy maintainers with \ + information about your platform (OS, CPU and compiler) + #endif +#elif defined(__sh__) && defined(__LITTLE_ENDIAN__) + #define NPY_CPU_SH_LE +#elif defined(__sh__) && defined(__BIG_ENDIAN__) + #define NPY_CPU_SH_BE +#elif defined(__MIPSEL__) + #define NPY_CPU_MIPSEL +#elif defined(__MIPSEB__) + #define NPY_CPU_MIPSEB +#elif defined(__or1k__) + #define NPY_CPU_OR1K +#elif defined(__mc68000__) + #define NPY_CPU_M68K +#elif defined(__arc__) && defined(__LITTLE_ENDIAN__) + #define NPY_CPU_ARCEL +#elif defined(__arc__) && defined(__BIG_ENDIAN__) + #define NPY_CPU_ARCEB +#elif defined(__riscv) && defined(__riscv_xlen) && __riscv_xlen == 64 + #define NPY_CPU_RISCV64 +#elif defined(__loongarch__) + #define NPY_CPU_LOONGARCH +#elif defined(__EMSCRIPTEN__) + /* __EMSCRIPTEN__ is defined by emscripten: an LLVM-to-Web compiler */ + #define NPY_CPU_WASM +#else + #error Unknown CPU, please report this to numpy maintainers with \ + information about your platform (OS, CPU and compiler) +#endif + +/* + * Except for the following architectures, memory access is limited to the natural + * alignment of data types otherwise it may lead to bus error or performance regression. + * For more details about unaligned access, see https://www.kernel.org/doc/Documentation/unaligned-memory-access.txt. +*/ +#if defined(NPY_CPU_X86) || defined(NPY_CPU_AMD64) || defined(__aarch64__) || defined(__powerpc64__) + #define NPY_ALIGNMENT_REQUIRED 0 +#endif +#ifndef NPY_ALIGNMENT_REQUIRED + #define NPY_ALIGNMENT_REQUIRED 1 +#endif + +#endif /* NUMPY_CORE_INCLUDE_NUMPY_NPY_CPU_H_ */ diff --git a/venv/lib/python3.12/site-packages/numpy/_core/include/numpy/npy_endian.h b/venv/lib/python3.12/site-packages/numpy/_core/include/numpy/npy_endian.h new file mode 100644 index 00000000..5e58a7f5 --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/include/numpy/npy_endian.h @@ -0,0 +1,77 @@ +#ifndef NUMPY_CORE_INCLUDE_NUMPY_NPY_ENDIAN_H_ +#define NUMPY_CORE_INCLUDE_NUMPY_NPY_ENDIAN_H_ + +/* + * NPY_BYTE_ORDER is set to the same value as BYTE_ORDER set by glibc in + * endian.h + */ + +#if defined(NPY_HAVE_ENDIAN_H) || defined(NPY_HAVE_SYS_ENDIAN_H) + /* Use endian.h if available */ + + #if defined(NPY_HAVE_ENDIAN_H) + #include + #elif defined(NPY_HAVE_SYS_ENDIAN_H) + #include + #endif + + #if defined(BYTE_ORDER) && defined(BIG_ENDIAN) && defined(LITTLE_ENDIAN) + #define NPY_BYTE_ORDER BYTE_ORDER + #define NPY_LITTLE_ENDIAN LITTLE_ENDIAN + #define NPY_BIG_ENDIAN BIG_ENDIAN + #elif defined(_BYTE_ORDER) && defined(_BIG_ENDIAN) && defined(_LITTLE_ENDIAN) + #define NPY_BYTE_ORDER _BYTE_ORDER + #define NPY_LITTLE_ENDIAN _LITTLE_ENDIAN + #define NPY_BIG_ENDIAN _BIG_ENDIAN + #elif defined(__BYTE_ORDER) && defined(__BIG_ENDIAN) && defined(__LITTLE_ENDIAN) + #define NPY_BYTE_ORDER __BYTE_ORDER + #define NPY_LITTLE_ENDIAN __LITTLE_ENDIAN + #define NPY_BIG_ENDIAN __BIG_ENDIAN + #endif +#endif + +#ifndef NPY_BYTE_ORDER + /* Set endianness info using target CPU */ + #include "npy_cpu.h" + + #define NPY_LITTLE_ENDIAN 1234 + #define NPY_BIG_ENDIAN 4321 + + #if defined(NPY_CPU_X86) \ + || defined(NPY_CPU_AMD64) \ + || defined(NPY_CPU_IA64) \ + || defined(NPY_CPU_ALPHA) \ + || defined(NPY_CPU_ARMEL) \ + || defined(NPY_CPU_ARMEL_AARCH32) \ + || defined(NPY_CPU_ARMEL_AARCH64) \ + || defined(NPY_CPU_SH_LE) \ + || defined(NPY_CPU_MIPSEL) \ + || defined(NPY_CPU_PPC64LE) \ + || defined(NPY_CPU_ARCEL) \ + || defined(NPY_CPU_RISCV64) \ + || defined(NPY_CPU_LOONGARCH) \ + || defined(NPY_CPU_WASM) + #define NPY_BYTE_ORDER NPY_LITTLE_ENDIAN + + #elif defined(NPY_CPU_PPC) \ + || defined(NPY_CPU_SPARC) \ + || defined(NPY_CPU_S390) \ + || defined(NPY_CPU_HPPA) \ + || defined(NPY_CPU_PPC64) \ + || defined(NPY_CPU_ARMEB) \ + || defined(NPY_CPU_ARMEB_AARCH32) \ + || defined(NPY_CPU_ARMEB_AARCH64) \ + || defined(NPY_CPU_SH_BE) \ + || defined(NPY_CPU_MIPSEB) \ + || defined(NPY_CPU_OR1K) \ + || defined(NPY_CPU_M68K) \ + || defined(NPY_CPU_ARCEB) + #define NPY_BYTE_ORDER NPY_BIG_ENDIAN + + #else + #error Unknown CPU: can not set endianness + #endif + +#endif + +#endif /* NUMPY_CORE_INCLUDE_NUMPY_NPY_ENDIAN_H_ */ diff --git a/venv/lib/python3.12/site-packages/numpy/_core/include/numpy/npy_math.h b/venv/lib/python3.12/site-packages/numpy/_core/include/numpy/npy_math.h new file mode 100644 index 00000000..d11df12b --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/include/numpy/npy_math.h @@ -0,0 +1,602 @@ +#ifndef NUMPY_CORE_INCLUDE_NUMPY_NPY_MATH_H_ +#define NUMPY_CORE_INCLUDE_NUMPY_NPY_MATH_H_ + +#include + +#include + +/* By adding static inline specifiers to npy_math function definitions when + appropriate, compiler is given the opportunity to optimize */ +#if NPY_INLINE_MATH +#define NPY_INPLACE static inline +#else +#define NPY_INPLACE +#endif + + +#ifdef __cplusplus +extern "C" { +#endif + +#define PyArray_MAX(a,b) (((a)>(b))?(a):(b)) +#define PyArray_MIN(a,b) (((a)<(b))?(a):(b)) + +/* + * NAN and INFINITY like macros (same behavior as glibc for NAN, same as C99 + * for INFINITY) + * + * XXX: I should test whether INFINITY and NAN are available on the platform + */ +static inline float __npy_inff(void) +{ + const union { npy_uint32 __i; float __f;} __bint = {0x7f800000UL}; + return __bint.__f; +} + +static inline float __npy_nanf(void) +{ + const union { npy_uint32 __i; float __f;} __bint = {0x7fc00000UL}; + return __bint.__f; +} + +static inline float __npy_pzerof(void) +{ + const union { npy_uint32 __i; float __f;} __bint = {0x00000000UL}; + return __bint.__f; +} + +static inline float __npy_nzerof(void) +{ + const union { npy_uint32 __i; float __f;} __bint = {0x80000000UL}; + return __bint.__f; +} + +#define NPY_INFINITYF __npy_inff() +#define NPY_NANF __npy_nanf() +#define NPY_PZEROF __npy_pzerof() +#define NPY_NZEROF __npy_nzerof() + +#define NPY_INFINITY ((npy_double)NPY_INFINITYF) +#define NPY_NAN ((npy_double)NPY_NANF) +#define NPY_PZERO ((npy_double)NPY_PZEROF) +#define NPY_NZERO ((npy_double)NPY_NZEROF) + +#define NPY_INFINITYL ((npy_longdouble)NPY_INFINITYF) +#define NPY_NANL ((npy_longdouble)NPY_NANF) +#define NPY_PZEROL ((npy_longdouble)NPY_PZEROF) +#define NPY_NZEROL ((npy_longdouble)NPY_NZEROF) + +/* + * Useful constants + */ +#define NPY_E 2.718281828459045235360287471352662498 /* e */ +#define NPY_LOG2E 1.442695040888963407359924681001892137 /* log_2 e */ +#define NPY_LOG10E 0.434294481903251827651128918916605082 /* log_10 e */ +#define NPY_LOGE2 0.693147180559945309417232121458176568 /* log_e 2 */ +#define NPY_LOGE10 2.302585092994045684017991454684364208 /* log_e 10 */ +#define NPY_PI 3.141592653589793238462643383279502884 /* pi */ +#define NPY_PI_2 1.570796326794896619231321691639751442 /* pi/2 */ +#define NPY_PI_4 0.785398163397448309615660845819875721 /* pi/4 */ +#define NPY_1_PI 0.318309886183790671537767526745028724 /* 1/pi */ +#define NPY_2_PI 0.636619772367581343075535053490057448 /* 2/pi */ +#define NPY_EULER 0.577215664901532860606512090082402431 /* Euler constant */ +#define NPY_SQRT2 1.414213562373095048801688724209698079 /* sqrt(2) */ +#define NPY_SQRT1_2 0.707106781186547524400844362104849039 /* 1/sqrt(2) */ + +#define NPY_Ef 2.718281828459045235360287471352662498F /* e */ +#define NPY_LOG2Ef 1.442695040888963407359924681001892137F /* log_2 e */ +#define NPY_LOG10Ef 0.434294481903251827651128918916605082F /* log_10 e */ +#define NPY_LOGE2f 0.693147180559945309417232121458176568F /* log_e 2 */ +#define NPY_LOGE10f 2.302585092994045684017991454684364208F /* log_e 10 */ +#define NPY_PIf 3.141592653589793238462643383279502884F /* pi */ +#define NPY_PI_2f 1.570796326794896619231321691639751442F /* pi/2 */ +#define NPY_PI_4f 0.785398163397448309615660845819875721F /* pi/4 */ +#define NPY_1_PIf 0.318309886183790671537767526745028724F /* 1/pi */ +#define NPY_2_PIf 0.636619772367581343075535053490057448F /* 2/pi */ +#define NPY_EULERf 0.577215664901532860606512090082402431F /* Euler constant */ +#define NPY_SQRT2f 1.414213562373095048801688724209698079F /* sqrt(2) */ +#define NPY_SQRT1_2f 0.707106781186547524400844362104849039F /* 1/sqrt(2) */ + +#define NPY_El 2.718281828459045235360287471352662498L /* e */ +#define NPY_LOG2El 1.442695040888963407359924681001892137L /* log_2 e */ +#define NPY_LOG10El 0.434294481903251827651128918916605082L /* log_10 e */ +#define NPY_LOGE2l 0.693147180559945309417232121458176568L /* log_e 2 */ +#define NPY_LOGE10l 2.302585092994045684017991454684364208L /* log_e 10 */ +#define NPY_PIl 3.141592653589793238462643383279502884L /* pi */ +#define NPY_PI_2l 1.570796326794896619231321691639751442L /* pi/2 */ +#define NPY_PI_4l 0.785398163397448309615660845819875721L /* pi/4 */ +#define NPY_1_PIl 0.318309886183790671537767526745028724L /* 1/pi */ +#define NPY_2_PIl 0.636619772367581343075535053490057448L /* 2/pi */ +#define NPY_EULERl 0.577215664901532860606512090082402431L /* Euler constant */ +#define NPY_SQRT2l 1.414213562373095048801688724209698079L /* sqrt(2) */ +#define NPY_SQRT1_2l 0.707106781186547524400844362104849039L /* 1/sqrt(2) */ + +/* + * Integer functions. + */ +NPY_INPLACE npy_uint npy_gcdu(npy_uint a, npy_uint b); +NPY_INPLACE npy_uint npy_lcmu(npy_uint a, npy_uint b); +NPY_INPLACE npy_ulong npy_gcdul(npy_ulong a, npy_ulong b); +NPY_INPLACE npy_ulong npy_lcmul(npy_ulong a, npy_ulong b); +NPY_INPLACE npy_ulonglong npy_gcdull(npy_ulonglong a, npy_ulonglong b); +NPY_INPLACE npy_ulonglong npy_lcmull(npy_ulonglong a, npy_ulonglong b); + +NPY_INPLACE npy_int npy_gcd(npy_int a, npy_int b); +NPY_INPLACE npy_int npy_lcm(npy_int a, npy_int b); +NPY_INPLACE npy_long npy_gcdl(npy_long a, npy_long b); +NPY_INPLACE npy_long npy_lcml(npy_long a, npy_long b); +NPY_INPLACE npy_longlong npy_gcdll(npy_longlong a, npy_longlong b); +NPY_INPLACE npy_longlong npy_lcmll(npy_longlong a, npy_longlong b); + +NPY_INPLACE npy_ubyte npy_rshiftuhh(npy_ubyte a, npy_ubyte b); +NPY_INPLACE npy_ubyte npy_lshiftuhh(npy_ubyte a, npy_ubyte b); +NPY_INPLACE npy_ushort npy_rshiftuh(npy_ushort a, npy_ushort b); +NPY_INPLACE npy_ushort npy_lshiftuh(npy_ushort a, npy_ushort b); +NPY_INPLACE npy_uint npy_rshiftu(npy_uint a, npy_uint b); +NPY_INPLACE npy_uint npy_lshiftu(npy_uint a, npy_uint b); +NPY_INPLACE npy_ulong npy_rshiftul(npy_ulong a, npy_ulong b); +NPY_INPLACE npy_ulong npy_lshiftul(npy_ulong a, npy_ulong b); +NPY_INPLACE npy_ulonglong npy_rshiftull(npy_ulonglong a, npy_ulonglong b); +NPY_INPLACE npy_ulonglong npy_lshiftull(npy_ulonglong a, npy_ulonglong b); + +NPY_INPLACE npy_byte npy_rshifthh(npy_byte a, npy_byte b); +NPY_INPLACE npy_byte npy_lshifthh(npy_byte a, npy_byte b); +NPY_INPLACE npy_short npy_rshifth(npy_short a, npy_short b); +NPY_INPLACE npy_short npy_lshifth(npy_short a, npy_short b); +NPY_INPLACE npy_int npy_rshift(npy_int a, npy_int b); +NPY_INPLACE npy_int npy_lshift(npy_int a, npy_int b); +NPY_INPLACE npy_long npy_rshiftl(npy_long a, npy_long b); +NPY_INPLACE npy_long npy_lshiftl(npy_long a, npy_long b); +NPY_INPLACE npy_longlong npy_rshiftll(npy_longlong a, npy_longlong b); +NPY_INPLACE npy_longlong npy_lshiftll(npy_longlong a, npy_longlong b); + +NPY_INPLACE uint8_t npy_popcountuhh(npy_ubyte a); +NPY_INPLACE uint8_t npy_popcountuh(npy_ushort a); +NPY_INPLACE uint8_t npy_popcountu(npy_uint a); +NPY_INPLACE uint8_t npy_popcountul(npy_ulong a); +NPY_INPLACE uint8_t npy_popcountull(npy_ulonglong a); +NPY_INPLACE uint8_t npy_popcounthh(npy_byte a); +NPY_INPLACE uint8_t npy_popcounth(npy_short a); +NPY_INPLACE uint8_t npy_popcount(npy_int a); +NPY_INPLACE uint8_t npy_popcountl(npy_long a); +NPY_INPLACE uint8_t npy_popcountll(npy_longlong a); + +/* + * C99 double math funcs that need fixups or are blocklist-able + */ +NPY_INPLACE double npy_sin(double x); +NPY_INPLACE double npy_cos(double x); +NPY_INPLACE double npy_tan(double x); +NPY_INPLACE double npy_hypot(double x, double y); +NPY_INPLACE double npy_log2(double x); +NPY_INPLACE double npy_atan2(double x, double y); + +/* Mandatory C99 double math funcs, no blocklisting or fixups */ +/* defined for legacy reasons, should be deprecated at some point */ +#define npy_sinh sinh +#define npy_cosh cosh +#define npy_tanh tanh +#define npy_asin asin +#define npy_acos acos +#define npy_atan atan +#define npy_log log +#define npy_log10 log10 +#define npy_cbrt cbrt +#define npy_fabs fabs +#define npy_ceil ceil +#define npy_fmod fmod +#define npy_floor floor +#define npy_expm1 expm1 +#define npy_log1p log1p +#define npy_acosh acosh +#define npy_asinh asinh +#define npy_atanh atanh +#define npy_rint rint +#define npy_trunc trunc +#define npy_exp2 exp2 +#define npy_frexp frexp +#define npy_ldexp ldexp +#define npy_copysign copysign +#define npy_exp exp +#define npy_sqrt sqrt +#define npy_pow pow +#define npy_modf modf +#define npy_nextafter nextafter + +double npy_spacing(double x); + +/* + * IEEE 754 fpu handling + */ + +/* use builtins to avoid function calls in tight loops + * only available if npy_config.h is available (= numpys own build) */ +#ifdef HAVE___BUILTIN_ISNAN + #define npy_isnan(x) __builtin_isnan(x) +#else + #define npy_isnan(x) isnan(x) +#endif + + +/* only available if npy_config.h is available (= numpys own build) */ +#ifdef HAVE___BUILTIN_ISFINITE + #define npy_isfinite(x) __builtin_isfinite(x) +#else + #define npy_isfinite(x) isfinite((x)) +#endif + +/* only available if npy_config.h is available (= numpys own build) */ +#ifdef HAVE___BUILTIN_ISINF + #define npy_isinf(x) __builtin_isinf(x) +#else + #define npy_isinf(x) isinf((x)) +#endif + +#define npy_signbit(x) signbit((x)) + +/* + * float C99 math funcs that need fixups or are blocklist-able + */ +NPY_INPLACE float npy_sinf(float x); +NPY_INPLACE float npy_cosf(float x); +NPY_INPLACE float npy_tanf(float x); +NPY_INPLACE float npy_expf(float x); +NPY_INPLACE float npy_sqrtf(float x); +NPY_INPLACE float npy_hypotf(float x, float y); +NPY_INPLACE float npy_log2f(float x); +NPY_INPLACE float npy_atan2f(float x, float y); +NPY_INPLACE float npy_powf(float x, float y); +NPY_INPLACE float npy_modff(float x, float* y); + +/* Mandatory C99 float math funcs, no blocklisting or fixups */ +/* defined for legacy reasons, should be deprecated at some point */ + +#define npy_sinhf sinhf +#define npy_coshf coshf +#define npy_tanhf tanhf +#define npy_asinf asinf +#define npy_acosf acosf +#define npy_atanf atanf +#define npy_logf logf +#define npy_log10f log10f +#define npy_cbrtf cbrtf +#define npy_fabsf fabsf +#define npy_ceilf ceilf +#define npy_fmodf fmodf +#define npy_floorf floorf +#define npy_expm1f expm1f +#define npy_log1pf log1pf +#define npy_asinhf asinhf +#define npy_acoshf acoshf +#define npy_atanhf atanhf +#define npy_rintf rintf +#define npy_truncf truncf +#define npy_exp2f exp2f +#define npy_frexpf frexpf +#define npy_ldexpf ldexpf +#define npy_copysignf copysignf +#define npy_nextafterf nextafterf + +float npy_spacingf(float x); + +/* + * long double C99 double math funcs that need fixups or are blocklist-able + */ +NPY_INPLACE npy_longdouble npy_sinl(npy_longdouble x); +NPY_INPLACE npy_longdouble npy_cosl(npy_longdouble x); +NPY_INPLACE npy_longdouble npy_tanl(npy_longdouble x); +NPY_INPLACE npy_longdouble npy_expl(npy_longdouble x); +NPY_INPLACE npy_longdouble npy_sqrtl(npy_longdouble x); +NPY_INPLACE npy_longdouble npy_hypotl(npy_longdouble x, npy_longdouble y); +NPY_INPLACE npy_longdouble npy_log2l(npy_longdouble x); +NPY_INPLACE npy_longdouble npy_atan2l(npy_longdouble x, npy_longdouble y); +NPY_INPLACE npy_longdouble npy_powl(npy_longdouble x, npy_longdouble y); +NPY_INPLACE npy_longdouble npy_modfl(npy_longdouble x, npy_longdouble* y); + +/* Mandatory C99 double math funcs, no blocklisting or fixups */ +/* defined for legacy reasons, should be deprecated at some point */ +#define npy_sinhl sinhl +#define npy_coshl coshl +#define npy_tanhl tanhl +#define npy_fabsl fabsl +#define npy_floorl floorl +#define npy_ceill ceill +#define npy_rintl rintl +#define npy_truncl truncl +#define npy_cbrtl cbrtl +#define npy_log10l log10l +#define npy_logl logl +#define npy_expm1l expm1l +#define npy_asinl asinl +#define npy_acosl acosl +#define npy_atanl atanl +#define npy_asinhl asinhl +#define npy_acoshl acoshl +#define npy_atanhl atanhl +#define npy_log1pl log1pl +#define npy_exp2l exp2l +#define npy_fmodl fmodl +#define npy_frexpl frexpl +#define npy_ldexpl ldexpl +#define npy_copysignl copysignl +#define npy_nextafterl nextafterl + +npy_longdouble npy_spacingl(npy_longdouble x); + +/* + * Non standard functions + */ +NPY_INPLACE double npy_deg2rad(double x); +NPY_INPLACE double npy_rad2deg(double x); +NPY_INPLACE double npy_logaddexp(double x, double y); +NPY_INPLACE double npy_logaddexp2(double x, double y); +NPY_INPLACE double npy_divmod(double x, double y, double *modulus); +NPY_INPLACE double npy_heaviside(double x, double h0); + +NPY_INPLACE float npy_deg2radf(float x); +NPY_INPLACE float npy_rad2degf(float x); +NPY_INPLACE float npy_logaddexpf(float x, float y); +NPY_INPLACE float npy_logaddexp2f(float x, float y); +NPY_INPLACE float npy_divmodf(float x, float y, float *modulus); +NPY_INPLACE float npy_heavisidef(float x, float h0); + +NPY_INPLACE npy_longdouble npy_deg2radl(npy_longdouble x); +NPY_INPLACE npy_longdouble npy_rad2degl(npy_longdouble x); +NPY_INPLACE npy_longdouble npy_logaddexpl(npy_longdouble x, npy_longdouble y); +NPY_INPLACE npy_longdouble npy_logaddexp2l(npy_longdouble x, npy_longdouble y); +NPY_INPLACE npy_longdouble npy_divmodl(npy_longdouble x, npy_longdouble y, + npy_longdouble *modulus); +NPY_INPLACE npy_longdouble npy_heavisidel(npy_longdouble x, npy_longdouble h0); + +#define npy_degrees npy_rad2deg +#define npy_degreesf npy_rad2degf +#define npy_degreesl npy_rad2degl + +#define npy_radians npy_deg2rad +#define npy_radiansf npy_deg2radf +#define npy_radiansl npy_deg2radl + +/* + * Complex declarations + */ + +static inline double npy_creal(const npy_cdouble z) +{ +#if defined(__cplusplus) + return ((double *) &z)[0]; +#else + return creal(z); +#endif +} + +static inline void npy_csetreal(npy_cdouble *z, const double r) +{ + ((double *) z)[0] = r; +} + +static inline double npy_cimag(const npy_cdouble z) +{ +#if defined(__cplusplus) + return ((double *) &z)[1]; +#else + return cimag(z); +#endif +} + +static inline void npy_csetimag(npy_cdouble *z, const double i) +{ + ((double *) z)[1] = i; +} + +static inline float npy_crealf(const npy_cfloat z) +{ +#if defined(__cplusplus) + return ((float *) &z)[0]; +#else + return crealf(z); +#endif +} + +static inline void npy_csetrealf(npy_cfloat *z, const float r) +{ + ((float *) z)[0] = r; +} + +static inline float npy_cimagf(const npy_cfloat z) +{ +#if defined(__cplusplus) + return ((float *) &z)[1]; +#else + return cimagf(z); +#endif +} + +static inline void npy_csetimagf(npy_cfloat *z, const float i) +{ + ((float *) z)[1] = i; +} + +static inline npy_longdouble npy_creall(const npy_clongdouble z) +{ +#if defined(__cplusplus) + return ((longdouble_t *) &z)[0]; +#else + return creall(z); +#endif +} + +static inline void npy_csetreall(npy_clongdouble *z, const longdouble_t r) +{ + ((longdouble_t *) z)[0] = r; +} + +static inline npy_longdouble npy_cimagl(const npy_clongdouble z) +{ +#if defined(__cplusplus) + return ((longdouble_t *) &z)[1]; +#else + return cimagl(z); +#endif +} + +static inline void npy_csetimagl(npy_clongdouble *z, const longdouble_t i) +{ + ((longdouble_t *) z)[1] = i; +} + +#define NPY_CSETREAL(z, r) npy_csetreal(z, r) +#define NPY_CSETIMAG(z, i) npy_csetimag(z, i) +#define NPY_CSETREALF(z, r) npy_csetrealf(z, r) +#define NPY_CSETIMAGF(z, i) npy_csetimagf(z, i) +#define NPY_CSETREALL(z, r) npy_csetreall(z, r) +#define NPY_CSETIMAGL(z, i) npy_csetimagl(z, i) + +static inline npy_cdouble npy_cpack(double x, double y) +{ + npy_cdouble z; + npy_csetreal(&z, x); + npy_csetimag(&z, y); + return z; +} + +static inline npy_cfloat npy_cpackf(float x, float y) +{ + npy_cfloat z; + npy_csetrealf(&z, x); + npy_csetimagf(&z, y); + return z; +} + +static inline npy_clongdouble npy_cpackl(npy_longdouble x, npy_longdouble y) +{ + npy_clongdouble z; + npy_csetreall(&z, x); + npy_csetimagl(&z, y); + return z; +} + +/* + * Double precision complex functions + */ +double npy_cabs(npy_cdouble z); +double npy_carg(npy_cdouble z); + +npy_cdouble npy_cexp(npy_cdouble z); +npy_cdouble npy_clog(npy_cdouble z); +npy_cdouble npy_cpow(npy_cdouble x, npy_cdouble y); + +npy_cdouble npy_csqrt(npy_cdouble z); + +npy_cdouble npy_ccos(npy_cdouble z); +npy_cdouble npy_csin(npy_cdouble z); +npy_cdouble npy_ctan(npy_cdouble z); + +npy_cdouble npy_ccosh(npy_cdouble z); +npy_cdouble npy_csinh(npy_cdouble z); +npy_cdouble npy_ctanh(npy_cdouble z); + +npy_cdouble npy_cacos(npy_cdouble z); +npy_cdouble npy_casin(npy_cdouble z); +npy_cdouble npy_catan(npy_cdouble z); + +npy_cdouble npy_cacosh(npy_cdouble z); +npy_cdouble npy_casinh(npy_cdouble z); +npy_cdouble npy_catanh(npy_cdouble z); + +/* + * Single precision complex functions + */ +float npy_cabsf(npy_cfloat z); +float npy_cargf(npy_cfloat z); + +npy_cfloat npy_cexpf(npy_cfloat z); +npy_cfloat npy_clogf(npy_cfloat z); +npy_cfloat npy_cpowf(npy_cfloat x, npy_cfloat y); + +npy_cfloat npy_csqrtf(npy_cfloat z); + +npy_cfloat npy_ccosf(npy_cfloat z); +npy_cfloat npy_csinf(npy_cfloat z); +npy_cfloat npy_ctanf(npy_cfloat z); + +npy_cfloat npy_ccoshf(npy_cfloat z); +npy_cfloat npy_csinhf(npy_cfloat z); +npy_cfloat npy_ctanhf(npy_cfloat z); + +npy_cfloat npy_cacosf(npy_cfloat z); +npy_cfloat npy_casinf(npy_cfloat z); +npy_cfloat npy_catanf(npy_cfloat z); + +npy_cfloat npy_cacoshf(npy_cfloat z); +npy_cfloat npy_casinhf(npy_cfloat z); +npy_cfloat npy_catanhf(npy_cfloat z); + + +/* + * Extended precision complex functions + */ +npy_longdouble npy_cabsl(npy_clongdouble z); +npy_longdouble npy_cargl(npy_clongdouble z); + +npy_clongdouble npy_cexpl(npy_clongdouble z); +npy_clongdouble npy_clogl(npy_clongdouble z); +npy_clongdouble npy_cpowl(npy_clongdouble x, npy_clongdouble y); + +npy_clongdouble npy_csqrtl(npy_clongdouble z); + +npy_clongdouble npy_ccosl(npy_clongdouble z); +npy_clongdouble npy_csinl(npy_clongdouble z); +npy_clongdouble npy_ctanl(npy_clongdouble z); + +npy_clongdouble npy_ccoshl(npy_clongdouble z); +npy_clongdouble npy_csinhl(npy_clongdouble z); +npy_clongdouble npy_ctanhl(npy_clongdouble z); + +npy_clongdouble npy_cacosl(npy_clongdouble z); +npy_clongdouble npy_casinl(npy_clongdouble z); +npy_clongdouble npy_catanl(npy_clongdouble z); + +npy_clongdouble npy_cacoshl(npy_clongdouble z); +npy_clongdouble npy_casinhl(npy_clongdouble z); +npy_clongdouble npy_catanhl(npy_clongdouble z); + + +/* + * Functions that set the floating point error + * status word. + */ + +/* + * platform-dependent code translates floating point + * status to an integer sum of these values + */ +#define NPY_FPE_DIVIDEBYZERO 1 +#define NPY_FPE_OVERFLOW 2 +#define NPY_FPE_UNDERFLOW 4 +#define NPY_FPE_INVALID 8 + +int npy_clear_floatstatus_barrier(char*); +int npy_get_floatstatus_barrier(char*); +/* + * use caution with these - clang and gcc8.1 are known to reorder calls + * to this form of the function which can defeat the check. The _barrier + * form of the call is preferable, where the argument is + * (char*)&local_variable + */ +int npy_clear_floatstatus(void); +int npy_get_floatstatus(void); + +void npy_set_floatstatus_divbyzero(void); +void npy_set_floatstatus_overflow(void); +void npy_set_floatstatus_underflow(void); +void npy_set_floatstatus_invalid(void); + +#ifdef __cplusplus +} +#endif + +#if NPY_INLINE_MATH +#include "npy_math_internal.h" +#endif + +#endif /* NUMPY_CORE_INCLUDE_NUMPY_NPY_MATH_H_ */ diff --git a/venv/lib/python3.12/site-packages/numpy/_core/include/numpy/npy_no_deprecated_api.h b/venv/lib/python3.12/site-packages/numpy/_core/include/numpy/npy_no_deprecated_api.h new file mode 100644 index 00000000..39658c0b --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/include/numpy/npy_no_deprecated_api.h @@ -0,0 +1,20 @@ +/* + * This include file is provided for inclusion in Cython *.pyd files where + * one would like to define the NPY_NO_DEPRECATED_API macro. It can be + * included by + * + * cdef extern from "npy_no_deprecated_api.h": pass + * + */ +#ifndef NPY_NO_DEPRECATED_API + +/* put this check here since there may be multiple includes in C extensions. */ +#if defined(NUMPY_CORE_INCLUDE_NUMPY_NDARRAYTYPES_H_) || \ + defined(NUMPY_CORE_INCLUDE_NUMPY_NPY_DEPRECATED_API_H) || \ + defined(NUMPY_CORE_INCLUDE_NUMPY_OLD_DEFINES_H_) +#error "npy_no_deprecated_api.h" must be first among numpy includes. +#else +#define NPY_NO_DEPRECATED_API NPY_API_VERSION +#endif + +#endif /* NPY_NO_DEPRECATED_API */ diff --git a/venv/lib/python3.12/site-packages/numpy/_core/include/numpy/npy_os.h b/venv/lib/python3.12/site-packages/numpy/_core/include/numpy/npy_os.h new file mode 100644 index 00000000..0ce5d78b --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/include/numpy/npy_os.h @@ -0,0 +1,42 @@ +#ifndef NUMPY_CORE_INCLUDE_NUMPY_NPY_OS_H_ +#define NUMPY_CORE_INCLUDE_NUMPY_NPY_OS_H_ + +#if defined(linux) || defined(__linux) || defined(__linux__) + #define NPY_OS_LINUX +#elif defined(__FreeBSD__) || defined(__NetBSD__) || \ + defined(__OpenBSD__) || defined(__DragonFly__) + #define NPY_OS_BSD + #ifdef __FreeBSD__ + #define NPY_OS_FREEBSD + #elif defined(__NetBSD__) + #define NPY_OS_NETBSD + #elif defined(__OpenBSD__) + #define NPY_OS_OPENBSD + #elif defined(__DragonFly__) + #define NPY_OS_DRAGONFLY + #endif +#elif defined(sun) || defined(__sun) + #define NPY_OS_SOLARIS +#elif defined(__CYGWIN__) + #define NPY_OS_CYGWIN +/* We are on Windows.*/ +#elif defined(_WIN32) + /* We are using MinGW (64-bit or 32-bit)*/ + #if defined(__MINGW32__) || defined(__MINGW64__) + #define NPY_OS_MINGW + /* Otherwise, if _WIN64 is defined, we are targeting 64-bit Windows*/ + #elif defined(_WIN64) + #define NPY_OS_WIN64 + /* Otherwise assume we are targeting 32-bit Windows*/ + #else + #define NPY_OS_WIN32 + #endif +#elif defined(__APPLE__) + #define NPY_OS_DARWIN +#elif defined(__HAIKU__) + #define NPY_OS_HAIKU +#else + #define NPY_OS_UNKNOWN +#endif + +#endif /* NUMPY_CORE_INCLUDE_NUMPY_NPY_OS_H_ */ diff --git a/venv/lib/python3.12/site-packages/numpy/_core/include/numpy/numpyconfig.h b/venv/lib/python3.12/site-packages/numpy/_core/include/numpy/numpyconfig.h new file mode 100644 index 00000000..46ecade4 --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/include/numpy/numpyconfig.h @@ -0,0 +1,178 @@ +#ifndef NUMPY_CORE_INCLUDE_NUMPY_NPY_NUMPYCONFIG_H_ +#define NUMPY_CORE_INCLUDE_NUMPY_NPY_NUMPYCONFIG_H_ + +#include "_numpyconfig.h" + +/* + * On Mac OS X, because there is only one configuration stage for all the archs + * in universal builds, any macro which depends on the arch needs to be + * hardcoded. + * + * Note that distutils/pip will attempt a universal2 build when Python itself + * is built as universal2, hence this hardcoding is needed even if we do not + * support universal2 wheels anymore (see gh-22796). + * This code block can be removed after we have dropped the setup.py based + * build completely. + */ +#ifdef __APPLE__ + #undef NPY_SIZEOF_LONG + + #ifdef __LP64__ + #define NPY_SIZEOF_LONG 8 + #else + #define NPY_SIZEOF_LONG 4 + #endif + + #undef NPY_SIZEOF_LONGDOUBLE + #undef NPY_SIZEOF_COMPLEX_LONGDOUBLE + #ifdef HAVE_LDOUBLE_IEEE_DOUBLE_LE + #undef HAVE_LDOUBLE_IEEE_DOUBLE_LE + #endif + #ifdef HAVE_LDOUBLE_INTEL_EXTENDED_16_BYTES_LE + #undef HAVE_LDOUBLE_INTEL_EXTENDED_16_BYTES_LE + #endif + + #if defined(__arm64__) + #define NPY_SIZEOF_LONGDOUBLE 8 + #define NPY_SIZEOF_COMPLEX_LONGDOUBLE 16 + #define HAVE_LDOUBLE_IEEE_DOUBLE_LE 1 + #elif defined(__x86_64) + #define NPY_SIZEOF_LONGDOUBLE 16 + #define NPY_SIZEOF_COMPLEX_LONGDOUBLE 32 + #define HAVE_LDOUBLE_INTEL_EXTENDED_16_BYTES_LE 1 + #elif defined (__i386) + #define NPY_SIZEOF_LONGDOUBLE 12 + #define NPY_SIZEOF_COMPLEX_LONGDOUBLE 24 + #elif defined(__ppc__) || defined (__ppc64__) + #define NPY_SIZEOF_LONGDOUBLE 16 + #define NPY_SIZEOF_COMPLEX_LONGDOUBLE 32 + #else + #error "unknown architecture" + #endif +#endif + + +/** + * To help with both NPY_TARGET_VERSION and the NPY_NO_DEPRECATED_API macro, + * we include API version numbers for specific versions of NumPy. + * To exclude all API that was deprecated as of 1.7, add the following before + * #including any NumPy headers: + * #define NPY_NO_DEPRECATED_API NPY_1_7_API_VERSION + * The same is true for NPY_TARGET_VERSION, although NumPy will default to + * a backwards compatible build anyway. + */ +#define NPY_1_7_API_VERSION 0x00000007 +#define NPY_1_8_API_VERSION 0x00000008 +#define NPY_1_9_API_VERSION 0x00000009 +#define NPY_1_10_API_VERSION 0x0000000a +#define NPY_1_11_API_VERSION 0x0000000a +#define NPY_1_12_API_VERSION 0x0000000a +#define NPY_1_13_API_VERSION 0x0000000b +#define NPY_1_14_API_VERSION 0x0000000c +#define NPY_1_15_API_VERSION 0x0000000c +#define NPY_1_16_API_VERSION 0x0000000d +#define NPY_1_17_API_VERSION 0x0000000d +#define NPY_1_18_API_VERSION 0x0000000d +#define NPY_1_19_API_VERSION 0x0000000d +#define NPY_1_20_API_VERSION 0x0000000e +#define NPY_1_21_API_VERSION 0x0000000e +#define NPY_1_22_API_VERSION 0x0000000f +#define NPY_1_23_API_VERSION 0x00000010 +#define NPY_1_24_API_VERSION 0x00000010 +#define NPY_1_25_API_VERSION 0x00000011 +#define NPY_2_0_API_VERSION 0x00000012 +#define NPY_2_1_API_VERSION 0x00000013 + + +/* + * Binary compatibility version number. This number is increased + * whenever the C-API is changed such that binary compatibility is + * broken, i.e. whenever a recompile of extension modules is needed. + */ +#define NPY_VERSION NPY_ABI_VERSION + +/* + * Minor API version we are compiling to be compatible with. The version + * Number is always increased when the API changes via: `NPY_API_VERSION` + * (and should maybe just track the NumPy version). + * + * If we have an internal build, we always target the current version of + * course. + * + * For downstream users, we default to an older version to provide them with + * maximum compatibility by default. Downstream can choose to extend that + * default, or narrow it down if they wish to use newer API. If you adjust + * this, consider the Python version support (example for 1.25.x): + * + * NumPy 1.25.x supports Python: 3.9 3.10 3.11 (3.12) + * NumPy 1.19.x supports Python: 3.6 3.7 3.8 3.9 + * NumPy 1.17.x supports Python: 3.5 3.6 3.7 3.8 + * NumPy 1.15.x supports Python: ... 3.6 3.7 + * + * Users of the stable ABI may wish to target the last Python that is not + * end of life. This would be 3.8 at NumPy 1.25 release time. + * 1.17 as default was the choice of oldest-support-numpy at the time and + * has in practice no limit (compared to 1.19). Even earlier becomes legacy. + */ +#if defined(NPY_INTERNAL_BUILD) && NPY_INTERNAL_BUILD + /* NumPy internal build, always use current version. */ + #define NPY_FEATURE_VERSION NPY_API_VERSION +#elif defined(NPY_TARGET_VERSION) && NPY_TARGET_VERSION + /* user provided a target version, use it */ + #define NPY_FEATURE_VERSION NPY_TARGET_VERSION +#else + /* Use the default (increase when dropping Python 3.10 support) */ + #define NPY_FEATURE_VERSION NPY_1_21_API_VERSION +#endif + +/* Sanity check the (requested) feature version */ +#if NPY_FEATURE_VERSION > NPY_API_VERSION + #error "NPY_TARGET_VERSION higher than NumPy headers!" +#elif NPY_FEATURE_VERSION < NPY_1_15_API_VERSION + /* No support for irrelevant old targets, no need for error, but warn. */ + #ifndef _MSC_VER + #warning "Requested NumPy target lower than supported NumPy 1.15." + #else + #define _WARN___STR2__(x) #x + #define _WARN___STR1__(x) _WARN___STR2__(x) + #define _WARN___LOC__ __FILE__ "(" _WARN___STR1__(__LINE__) ") : Warning Msg: " + #pragma message(_WARN___LOC__"Requested NumPy target lower than supported NumPy 1.15.") + #endif +#endif + +/* + * We define a human readable translation to the Python version of NumPy + * for error messages (and also to allow grepping the binaries for conda). + */ +#if NPY_FEATURE_VERSION == NPY_1_7_API_VERSION + #define NPY_FEATURE_VERSION_STRING "1.7" +#elif NPY_FEATURE_VERSION == NPY_1_8_API_VERSION + #define NPY_FEATURE_VERSION_STRING "1.8" +#elif NPY_FEATURE_VERSION == NPY_1_9_API_VERSION + #define NPY_FEATURE_VERSION_STRING "1.9" +#elif NPY_FEATURE_VERSION == NPY_1_10_API_VERSION /* also 1.11, 1.12 */ + #define NPY_FEATURE_VERSION_STRING "1.10" +#elif NPY_FEATURE_VERSION == NPY_1_13_API_VERSION + #define NPY_FEATURE_VERSION_STRING "1.13" +#elif NPY_FEATURE_VERSION == NPY_1_14_API_VERSION /* also 1.15 */ + #define NPY_FEATURE_VERSION_STRING "1.14" +#elif NPY_FEATURE_VERSION == NPY_1_16_API_VERSION /* also 1.17, 1.18, 1.19 */ + #define NPY_FEATURE_VERSION_STRING "1.16" +#elif NPY_FEATURE_VERSION == NPY_1_20_API_VERSION /* also 1.21 */ + #define NPY_FEATURE_VERSION_STRING "1.20" +#elif NPY_FEATURE_VERSION == NPY_1_22_API_VERSION + #define NPY_FEATURE_VERSION_STRING "1.22" +#elif NPY_FEATURE_VERSION == NPY_1_23_API_VERSION /* also 1.24 */ + #define NPY_FEATURE_VERSION_STRING "1.23" +#elif NPY_FEATURE_VERSION == NPY_1_25_API_VERSION + #define NPY_FEATURE_VERSION_STRING "1.25" +#elif NPY_FEATURE_VERSION == NPY_2_0_API_VERSION + #define NPY_FEATURE_VERSION_STRING "2.0" +#elif NPY_FEATURE_VERSION == NPY_2_1_API_VERSION + #define NPY_FEATURE_VERSION_STRING "2.1" +#else + #error "Missing version string define for new NumPy version." +#endif + + +#endif /* NUMPY_CORE_INCLUDE_NUMPY_NPY_NUMPYCONFIG_H_ */ diff --git a/venv/lib/python3.12/site-packages/numpy/_core/include/numpy/random/LICENSE.txt b/venv/lib/python3.12/site-packages/numpy/_core/include/numpy/random/LICENSE.txt new file mode 100644 index 00000000..d72a7c38 --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/include/numpy/random/LICENSE.txt @@ -0,0 +1,21 @@ + zlib License + ------------ + + Copyright (C) 2010 - 2019 ridiculous_fish, + Copyright (C) 2016 - 2019 Kim Walisch, + + This software is provided 'as-is', without any express or implied + warranty. In no event will the authors be held liable for any damages + arising from the use of this software. + + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it + freely, subject to the following restrictions: + + 1. The origin of this software must not be misrepresented; you must not + claim that you wrote the original software. If you use this software + in a product, an acknowledgment in the product documentation would be + appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be + misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. diff --git a/venv/lib/python3.12/site-packages/numpy/_core/include/numpy/random/bitgen.h b/venv/lib/python3.12/site-packages/numpy/_core/include/numpy/random/bitgen.h new file mode 100644 index 00000000..162dd5c5 --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/include/numpy/random/bitgen.h @@ -0,0 +1,20 @@ +#ifndef NUMPY_CORE_INCLUDE_NUMPY_RANDOM_BITGEN_H_ +#define NUMPY_CORE_INCLUDE_NUMPY_RANDOM_BITGEN_H_ + +#pragma once +#include +#include +#include + +/* Must match the declaration in numpy/random/.pxd */ + +typedef struct bitgen { + void *state; + uint64_t (*next_uint64)(void *st); + uint32_t (*next_uint32)(void *st); + double (*next_double)(void *st); + uint64_t (*next_raw)(void *st); +} bitgen_t; + + +#endif /* NUMPY_CORE_INCLUDE_NUMPY_RANDOM_BITGEN_H_ */ diff --git a/venv/lib/python3.12/site-packages/numpy/_core/include/numpy/random/distributions.h b/venv/lib/python3.12/site-packages/numpy/_core/include/numpy/random/distributions.h new file mode 100644 index 00000000..e7fa4bd0 --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/include/numpy/random/distributions.h @@ -0,0 +1,209 @@ +#ifndef NUMPY_CORE_INCLUDE_NUMPY_RANDOM_DISTRIBUTIONS_H_ +#define NUMPY_CORE_INCLUDE_NUMPY_RANDOM_DISTRIBUTIONS_H_ + +#ifdef __cplusplus +extern "C" { +#endif + +#include +#include "numpy/npy_common.h" +#include +#include +#include + +#include "numpy/npy_math.h" +#include "numpy/random/bitgen.h" + +/* + * RAND_INT_TYPE is used to share integer generators with RandomState which + * used long in place of int64_t. If changing a distribution that uses + * RAND_INT_TYPE, then the original unmodified copy must be retained for + * use in RandomState by copying to the legacy distributions source file. + */ +#ifdef NP_RANDOM_LEGACY +#define RAND_INT_TYPE long +#define RAND_INT_MAX LONG_MAX +#else +#define RAND_INT_TYPE int64_t +#define RAND_INT_MAX INT64_MAX +#endif + +#ifdef _MSC_VER +#define DECLDIR __declspec(dllexport) +#else +#define DECLDIR extern +#endif + +#ifndef MIN +#define MIN(x, y) (((x) < (y)) ? x : y) +#define MAX(x, y) (((x) > (y)) ? x : y) +#endif + +#ifndef M_PI +#define M_PI 3.14159265358979323846264338328 +#endif + +typedef struct s_binomial_t { + int has_binomial; /* !=0: following parameters initialized for binomial */ + double psave; + RAND_INT_TYPE nsave; + double r; + double q; + double fm; + RAND_INT_TYPE m; + double p1; + double xm; + double xl; + double xr; + double c; + double laml; + double lamr; + double p2; + double p3; + double p4; +} binomial_t; + +DECLDIR float random_standard_uniform_f(bitgen_t *bitgen_state); +DECLDIR double random_standard_uniform(bitgen_t *bitgen_state); +DECLDIR void random_standard_uniform_fill(bitgen_t *, npy_intp, double *); +DECLDIR void random_standard_uniform_fill_f(bitgen_t *, npy_intp, float *); + +DECLDIR int64_t random_positive_int64(bitgen_t *bitgen_state); +DECLDIR int32_t random_positive_int32(bitgen_t *bitgen_state); +DECLDIR int64_t random_positive_int(bitgen_t *bitgen_state); +DECLDIR uint64_t random_uint(bitgen_t *bitgen_state); + +DECLDIR double random_standard_exponential(bitgen_t *bitgen_state); +DECLDIR float random_standard_exponential_f(bitgen_t *bitgen_state); +DECLDIR void random_standard_exponential_fill(bitgen_t *, npy_intp, double *); +DECLDIR void random_standard_exponential_fill_f(bitgen_t *, npy_intp, float *); +DECLDIR void random_standard_exponential_inv_fill(bitgen_t *, npy_intp, double *); +DECLDIR void random_standard_exponential_inv_fill_f(bitgen_t *, npy_intp, float *); + +DECLDIR double random_standard_normal(bitgen_t *bitgen_state); +DECLDIR float random_standard_normal_f(bitgen_t *bitgen_state); +DECLDIR void random_standard_normal_fill(bitgen_t *, npy_intp, double *); +DECLDIR void random_standard_normal_fill_f(bitgen_t *, npy_intp, float *); +DECLDIR double random_standard_gamma(bitgen_t *bitgen_state, double shape); +DECLDIR float random_standard_gamma_f(bitgen_t *bitgen_state, float shape); + +DECLDIR double random_normal(bitgen_t *bitgen_state, double loc, double scale); + +DECLDIR double random_gamma(bitgen_t *bitgen_state, double shape, double scale); +DECLDIR float random_gamma_f(bitgen_t *bitgen_state, float shape, float scale); + +DECLDIR double random_exponential(bitgen_t *bitgen_state, double scale); +DECLDIR double random_uniform(bitgen_t *bitgen_state, double lower, double range); +DECLDIR double random_beta(bitgen_t *bitgen_state, double a, double b); +DECLDIR double random_chisquare(bitgen_t *bitgen_state, double df); +DECLDIR double random_f(bitgen_t *bitgen_state, double dfnum, double dfden); +DECLDIR double random_standard_cauchy(bitgen_t *bitgen_state); +DECLDIR double random_pareto(bitgen_t *bitgen_state, double a); +DECLDIR double random_weibull(bitgen_t *bitgen_state, double a); +DECLDIR double random_power(bitgen_t *bitgen_state, double a); +DECLDIR double random_laplace(bitgen_t *bitgen_state, double loc, double scale); +DECLDIR double random_gumbel(bitgen_t *bitgen_state, double loc, double scale); +DECLDIR double random_logistic(bitgen_t *bitgen_state, double loc, double scale); +DECLDIR double random_lognormal(bitgen_t *bitgen_state, double mean, double sigma); +DECLDIR double random_rayleigh(bitgen_t *bitgen_state, double mode); +DECLDIR double random_standard_t(bitgen_t *bitgen_state, double df); +DECLDIR double random_noncentral_chisquare(bitgen_t *bitgen_state, double df, + double nonc); +DECLDIR double random_noncentral_f(bitgen_t *bitgen_state, double dfnum, + double dfden, double nonc); +DECLDIR double random_wald(bitgen_t *bitgen_state, double mean, double scale); +DECLDIR double random_vonmises(bitgen_t *bitgen_state, double mu, double kappa); +DECLDIR double random_triangular(bitgen_t *bitgen_state, double left, double mode, + double right); + +DECLDIR RAND_INT_TYPE random_poisson(bitgen_t *bitgen_state, double lam); +DECLDIR RAND_INT_TYPE random_negative_binomial(bitgen_t *bitgen_state, double n, + double p); + +DECLDIR int64_t random_binomial(bitgen_t *bitgen_state, double p, + int64_t n, binomial_t *binomial); + +DECLDIR int64_t random_logseries(bitgen_t *bitgen_state, double p); +DECLDIR int64_t random_geometric(bitgen_t *bitgen_state, double p); +DECLDIR RAND_INT_TYPE random_geometric_search(bitgen_t *bitgen_state, double p); +DECLDIR RAND_INT_TYPE random_zipf(bitgen_t *bitgen_state, double a); +DECLDIR int64_t random_hypergeometric(bitgen_t *bitgen_state, + int64_t good, int64_t bad, int64_t sample); +DECLDIR uint64_t random_interval(bitgen_t *bitgen_state, uint64_t max); + +/* Generate random uint64 numbers in closed interval [off, off + rng]. */ +DECLDIR uint64_t random_bounded_uint64(bitgen_t *bitgen_state, uint64_t off, + uint64_t rng, uint64_t mask, + bool use_masked); + +/* Generate random uint32 numbers in closed interval [off, off + rng]. */ +DECLDIR uint32_t random_buffered_bounded_uint32(bitgen_t *bitgen_state, + uint32_t off, uint32_t rng, + uint32_t mask, bool use_masked, + int *bcnt, uint32_t *buf); +DECLDIR uint16_t random_buffered_bounded_uint16(bitgen_t *bitgen_state, + uint16_t off, uint16_t rng, + uint16_t mask, bool use_masked, + int *bcnt, uint32_t *buf); +DECLDIR uint8_t random_buffered_bounded_uint8(bitgen_t *bitgen_state, uint8_t off, + uint8_t rng, uint8_t mask, + bool use_masked, int *bcnt, + uint32_t *buf); +DECLDIR npy_bool random_buffered_bounded_bool(bitgen_t *bitgen_state, npy_bool off, + npy_bool rng, npy_bool mask, + bool use_masked, int *bcnt, + uint32_t *buf); + +DECLDIR void random_bounded_uint64_fill(bitgen_t *bitgen_state, uint64_t off, + uint64_t rng, npy_intp cnt, + bool use_masked, uint64_t *out); +DECLDIR void random_bounded_uint32_fill(bitgen_t *bitgen_state, uint32_t off, + uint32_t rng, npy_intp cnt, + bool use_masked, uint32_t *out); +DECLDIR void random_bounded_uint16_fill(bitgen_t *bitgen_state, uint16_t off, + uint16_t rng, npy_intp cnt, + bool use_masked, uint16_t *out); +DECLDIR void random_bounded_uint8_fill(bitgen_t *bitgen_state, uint8_t off, + uint8_t rng, npy_intp cnt, + bool use_masked, uint8_t *out); +DECLDIR void random_bounded_bool_fill(bitgen_t *bitgen_state, npy_bool off, + npy_bool rng, npy_intp cnt, + bool use_masked, npy_bool *out); + +DECLDIR void random_multinomial(bitgen_t *bitgen_state, RAND_INT_TYPE n, RAND_INT_TYPE *mnix, + double *pix, npy_intp d, binomial_t *binomial); + +/* multivariate hypergeometric, "count" method */ +DECLDIR int random_multivariate_hypergeometric_count(bitgen_t *bitgen_state, + int64_t total, + size_t num_colors, int64_t *colors, + int64_t nsample, + size_t num_variates, int64_t *variates); + +/* multivariate hypergeometric, "marginals" method */ +DECLDIR void random_multivariate_hypergeometric_marginals(bitgen_t *bitgen_state, + int64_t total, + size_t num_colors, int64_t *colors, + int64_t nsample, + size_t num_variates, int64_t *variates); + +/* Common to legacy-distributions.c and distributions.c but not exported */ + +RAND_INT_TYPE random_binomial_btpe(bitgen_t *bitgen_state, + RAND_INT_TYPE n, + double p, + binomial_t *binomial); +RAND_INT_TYPE random_binomial_inversion(bitgen_t *bitgen_state, + RAND_INT_TYPE n, + double p, + binomial_t *binomial); +double random_loggam(double x); +static inline double next_double(bitgen_t *bitgen_state) { + return bitgen_state->next_double(bitgen_state->state); +} + +#ifdef __cplusplus +} +#endif + +#endif /* NUMPY_CORE_INCLUDE_NUMPY_RANDOM_DISTRIBUTIONS_H_ */ diff --git a/venv/lib/python3.12/site-packages/numpy/_core/include/numpy/random/libdivide.h b/venv/lib/python3.12/site-packages/numpy/_core/include/numpy/random/libdivide.h new file mode 100644 index 00000000..f4eb8039 --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/include/numpy/random/libdivide.h @@ -0,0 +1,2079 @@ +// libdivide.h - Optimized integer division +// https://libdivide.com +// +// Copyright (C) 2010 - 2019 ridiculous_fish, +// Copyright (C) 2016 - 2019 Kim Walisch, +// +// libdivide is dual-licensed under the Boost or zlib licenses. +// You may use libdivide under the terms of either of these. +// See LICENSE.txt for more details. + +#ifndef NUMPY_CORE_INCLUDE_NUMPY_LIBDIVIDE_LIBDIVIDE_H_ +#define NUMPY_CORE_INCLUDE_NUMPY_LIBDIVIDE_LIBDIVIDE_H_ + +#define LIBDIVIDE_VERSION "3.0" +#define LIBDIVIDE_VERSION_MAJOR 3 +#define LIBDIVIDE_VERSION_MINOR 0 + +#include + +#if defined(__cplusplus) + #include + #include + #include +#else + #include + #include +#endif + +#if defined(LIBDIVIDE_AVX512) + #include +#elif defined(LIBDIVIDE_AVX2) + #include +#elif defined(LIBDIVIDE_SSE2) + #include +#endif + +#if defined(_MSC_VER) + #include + // disable warning C4146: unary minus operator applied + // to unsigned type, result still unsigned + #pragma warning(disable: 4146) + #define LIBDIVIDE_VC +#endif + +#if !defined(__has_builtin) + #define __has_builtin(x) 0 +#endif + +#if defined(__SIZEOF_INT128__) + #define HAS_INT128_T + // clang-cl on Windows does not yet support 128-bit division + #if !(defined(__clang__) && defined(LIBDIVIDE_VC)) + #define HAS_INT128_DIV + #endif +#endif + +#if defined(__x86_64__) || defined(_M_X64) + #define LIBDIVIDE_X86_64 +#endif + +#if defined(__i386__) + #define LIBDIVIDE_i386 +#endif + +#if defined(__GNUC__) || defined(__clang__) + #define LIBDIVIDE_GCC_STYLE_ASM +#endif + +#if defined(__cplusplus) || defined(LIBDIVIDE_VC) + #define LIBDIVIDE_FUNCTION __FUNCTION__ +#else + #define LIBDIVIDE_FUNCTION __func__ +#endif + +#define LIBDIVIDE_ERROR(msg) \ + do { \ + fprintf(stderr, "libdivide.h:%d: %s(): Error: %s\n", \ + __LINE__, LIBDIVIDE_FUNCTION, msg); \ + abort(); \ + } while (0) + +#if defined(LIBDIVIDE_ASSERTIONS_ON) + #define LIBDIVIDE_ASSERT(x) \ + do { \ + if (!(x)) { \ + fprintf(stderr, "libdivide.h:%d: %s(): Assertion failed: %s\n", \ + __LINE__, LIBDIVIDE_FUNCTION, #x); \ + abort(); \ + } \ + } while (0) +#else + #define LIBDIVIDE_ASSERT(x) +#endif + +#ifdef __cplusplus +namespace libdivide { +#endif + +// pack divider structs to prevent compilers from padding. +// This reduces memory usage by up to 43% when using a large +// array of libdivide dividers and improves performance +// by up to 10% because of reduced memory bandwidth. +#pragma pack(push, 1) + +struct libdivide_u32_t { + uint32_t magic; + uint8_t more; +}; + +struct libdivide_s32_t { + int32_t magic; + uint8_t more; +}; + +struct libdivide_u64_t { + uint64_t magic; + uint8_t more; +}; + +struct libdivide_s64_t { + int64_t magic; + uint8_t more; +}; + +struct libdivide_u32_branchfree_t { + uint32_t magic; + uint8_t more; +}; + +struct libdivide_s32_branchfree_t { + int32_t magic; + uint8_t more; +}; + +struct libdivide_u64_branchfree_t { + uint64_t magic; + uint8_t more; +}; + +struct libdivide_s64_branchfree_t { + int64_t magic; + uint8_t more; +}; + +#pragma pack(pop) + +// Explanation of the "more" field: +// +// * Bits 0-5 is the shift value (for shift path or mult path). +// * Bit 6 is the add indicator for mult path. +// * Bit 7 is set if the divisor is negative. We use bit 7 as the negative +// divisor indicator so that we can efficiently use sign extension to +// create a bitmask with all bits set to 1 (if the divisor is negative) +// or 0 (if the divisor is positive). +// +// u32: [0-4] shift value +// [5] ignored +// [6] add indicator +// magic number of 0 indicates shift path +// +// s32: [0-4] shift value +// [5] ignored +// [6] add indicator +// [7] indicates negative divisor +// magic number of 0 indicates shift path +// +// u64: [0-5] shift value +// [6] add indicator +// magic number of 0 indicates shift path +// +// s64: [0-5] shift value +// [6] add indicator +// [7] indicates negative divisor +// magic number of 0 indicates shift path +// +// In s32 and s64 branchfree modes, the magic number is negated according to +// whether the divisor is negated. In branchfree strategy, it is not negated. + +enum { + LIBDIVIDE_32_SHIFT_MASK = 0x1F, + LIBDIVIDE_64_SHIFT_MASK = 0x3F, + LIBDIVIDE_ADD_MARKER = 0x40, + LIBDIVIDE_NEGATIVE_DIVISOR = 0x80 +}; + +static inline struct libdivide_s32_t libdivide_s32_gen(int32_t d); +static inline struct libdivide_u32_t libdivide_u32_gen(uint32_t d); +static inline struct libdivide_s64_t libdivide_s64_gen(int64_t d); +static inline struct libdivide_u64_t libdivide_u64_gen(uint64_t d); + +static inline struct libdivide_s32_branchfree_t libdivide_s32_branchfree_gen(int32_t d); +static inline struct libdivide_u32_branchfree_t libdivide_u32_branchfree_gen(uint32_t d); +static inline struct libdivide_s64_branchfree_t libdivide_s64_branchfree_gen(int64_t d); +static inline struct libdivide_u64_branchfree_t libdivide_u64_branchfree_gen(uint64_t d); + +static inline int32_t libdivide_s32_do(int32_t numer, const struct libdivide_s32_t *denom); +static inline uint32_t libdivide_u32_do(uint32_t numer, const struct libdivide_u32_t *denom); +static inline int64_t libdivide_s64_do(int64_t numer, const struct libdivide_s64_t *denom); +static inline uint64_t libdivide_u64_do(uint64_t numer, const struct libdivide_u64_t *denom); + +static inline int32_t libdivide_s32_branchfree_do(int32_t numer, const struct libdivide_s32_branchfree_t *denom); +static inline uint32_t libdivide_u32_branchfree_do(uint32_t numer, const struct libdivide_u32_branchfree_t *denom); +static inline int64_t libdivide_s64_branchfree_do(int64_t numer, const struct libdivide_s64_branchfree_t *denom); +static inline uint64_t libdivide_u64_branchfree_do(uint64_t numer, const struct libdivide_u64_branchfree_t *denom); + +static inline int32_t libdivide_s32_recover(const struct libdivide_s32_t *denom); +static inline uint32_t libdivide_u32_recover(const struct libdivide_u32_t *denom); +static inline int64_t libdivide_s64_recover(const struct libdivide_s64_t *denom); +static inline uint64_t libdivide_u64_recover(const struct libdivide_u64_t *denom); + +static inline int32_t libdivide_s32_branchfree_recover(const struct libdivide_s32_branchfree_t *denom); +static inline uint32_t libdivide_u32_branchfree_recover(const struct libdivide_u32_branchfree_t *denom); +static inline int64_t libdivide_s64_branchfree_recover(const struct libdivide_s64_branchfree_t *denom); +static inline uint64_t libdivide_u64_branchfree_recover(const struct libdivide_u64_branchfree_t *denom); + +//////// Internal Utility Functions + +static inline uint32_t libdivide_mullhi_u32(uint32_t x, uint32_t y) { + uint64_t xl = x, yl = y; + uint64_t rl = xl * yl; + return (uint32_t)(rl >> 32); +} + +static inline int32_t libdivide_mullhi_s32(int32_t x, int32_t y) { + int64_t xl = x, yl = y; + int64_t rl = xl * yl; + // needs to be arithmetic shift + return (int32_t)(rl >> 32); +} + +static inline uint64_t libdivide_mullhi_u64(uint64_t x, uint64_t y) { +#if defined(LIBDIVIDE_VC) && \ + defined(LIBDIVIDE_X86_64) + return __umulh(x, y); +#elif defined(HAS_INT128_T) + __uint128_t xl = x, yl = y; + __uint128_t rl = xl * yl; + return (uint64_t)(rl >> 64); +#else + // full 128 bits are x0 * y0 + (x0 * y1 << 32) + (x1 * y0 << 32) + (x1 * y1 << 64) + uint32_t mask = 0xFFFFFFFF; + uint32_t x0 = (uint32_t)(x & mask); + uint32_t x1 = (uint32_t)(x >> 32); + uint32_t y0 = (uint32_t)(y & mask); + uint32_t y1 = (uint32_t)(y >> 32); + uint32_t x0y0_hi = libdivide_mullhi_u32(x0, y0); + uint64_t x0y1 = x0 * (uint64_t)y1; + uint64_t x1y0 = x1 * (uint64_t)y0; + uint64_t x1y1 = x1 * (uint64_t)y1; + uint64_t temp = x1y0 + x0y0_hi; + uint64_t temp_lo = temp & mask; + uint64_t temp_hi = temp >> 32; + + return x1y1 + temp_hi + ((temp_lo + x0y1) >> 32); +#endif +} + +static inline int64_t libdivide_mullhi_s64(int64_t x, int64_t y) { +#if defined(LIBDIVIDE_VC) && \ + defined(LIBDIVIDE_X86_64) + return __mulh(x, y); +#elif defined(HAS_INT128_T) + __int128_t xl = x, yl = y; + __int128_t rl = xl * yl; + return (int64_t)(rl >> 64); +#else + // full 128 bits are x0 * y0 + (x0 * y1 << 32) + (x1 * y0 << 32) + (x1 * y1 << 64) + uint32_t mask = 0xFFFFFFFF; + uint32_t x0 = (uint32_t)(x & mask); + uint32_t y0 = (uint32_t)(y & mask); + int32_t x1 = (int32_t)(x >> 32); + int32_t y1 = (int32_t)(y >> 32); + uint32_t x0y0_hi = libdivide_mullhi_u32(x0, y0); + int64_t t = x1 * (int64_t)y0 + x0y0_hi; + int64_t w1 = x0 * (int64_t)y1 + (t & mask); + + return x1 * (int64_t)y1 + (t >> 32) + (w1 >> 32); +#endif +} + +static inline int32_t libdivide_count_leading_zeros32(uint32_t val) { +#if defined(__GNUC__) || \ + __has_builtin(__builtin_clz) + // Fast way to count leading zeros + return __builtin_clz(val); +#elif defined(LIBDIVIDE_VC) + unsigned long result; + if (_BitScanReverse(&result, val)) { + return 31 - result; + } + return 0; +#else + if (val == 0) + return 32; + int32_t result = 8; + uint32_t hi = 0xFFU << 24; + while ((val & hi) == 0) { + hi >>= 8; + result += 8; + } + while (val & hi) { + result -= 1; + hi <<= 1; + } + return result; +#endif +} + +static inline int32_t libdivide_count_leading_zeros64(uint64_t val) { +#if defined(__GNUC__) || \ + __has_builtin(__builtin_clzll) + // Fast way to count leading zeros + return __builtin_clzll(val); +#elif defined(LIBDIVIDE_VC) && defined(_WIN64) + unsigned long result; + if (_BitScanReverse64(&result, val)) { + return 63 - result; + } + return 0; +#else + uint32_t hi = val >> 32; + uint32_t lo = val & 0xFFFFFFFF; + if (hi != 0) return libdivide_count_leading_zeros32(hi); + return 32 + libdivide_count_leading_zeros32(lo); +#endif +} + +// libdivide_64_div_32_to_32: divides a 64-bit uint {u1, u0} by a 32-bit +// uint {v}. The result must fit in 32 bits. +// Returns the quotient directly and the remainder in *r +static inline uint32_t libdivide_64_div_32_to_32(uint32_t u1, uint32_t u0, uint32_t v, uint32_t *r) { +#if (defined(LIBDIVIDE_i386) || defined(LIBDIVIDE_X86_64)) && \ + defined(LIBDIVIDE_GCC_STYLE_ASM) + uint32_t result; + __asm__("divl %[v]" + : "=a"(result), "=d"(*r) + : [v] "r"(v), "a"(u0), "d"(u1) + ); + return result; +#else + uint64_t n = ((uint64_t)u1 << 32) | u0; + uint32_t result = (uint32_t)(n / v); + *r = (uint32_t)(n - result * (uint64_t)v); + return result; +#endif +} + +// libdivide_128_div_64_to_64: divides a 128-bit uint {u1, u0} by a 64-bit +// uint {v}. The result must fit in 64 bits. +// Returns the quotient directly and the remainder in *r +static uint64_t libdivide_128_div_64_to_64(uint64_t u1, uint64_t u0, uint64_t v, uint64_t *r) { +#if defined(LIBDIVIDE_X86_64) && \ + defined(LIBDIVIDE_GCC_STYLE_ASM) + uint64_t result; + __asm__("divq %[v]" + : "=a"(result), "=d"(*r) + : [v] "r"(v), "a"(u0), "d"(u1) + ); + return result; +#elif defined(HAS_INT128_T) && \ + defined(HAS_INT128_DIV) + __uint128_t n = ((__uint128_t)u1 << 64) | u0; + uint64_t result = (uint64_t)(n / v); + *r = (uint64_t)(n - result * (__uint128_t)v); + return result; +#else + // Code taken from Hacker's Delight: + // http://www.hackersdelight.org/HDcode/divlu.c. + // License permits inclusion here per: + // http://www.hackersdelight.org/permissions.htm + + const uint64_t b = (1ULL << 32); // Number base (32 bits) + uint64_t un1, un0; // Norm. dividend LSD's + uint64_t vn1, vn0; // Norm. divisor digits + uint64_t q1, q0; // Quotient digits + uint64_t un64, un21, un10; // Dividend digit pairs + uint64_t rhat; // A remainder + int32_t s; // Shift amount for norm + + // If overflow, set rem. to an impossible value, + // and return the largest possible quotient + if (u1 >= v) { + *r = (uint64_t) -1; + return (uint64_t) -1; + } + + // count leading zeros + s = libdivide_count_leading_zeros64(v); + if (s > 0) { + // Normalize divisor + v = v << s; + un64 = (u1 << s) | (u0 >> (64 - s)); + un10 = u0 << s; // Shift dividend left + } else { + // Avoid undefined behavior of (u0 >> 64). + // The behavior is undefined if the right operand is + // negative, or greater than or equal to the length + // in bits of the promoted left operand. + un64 = u1; + un10 = u0; + } + + // Break divisor up into two 32-bit digits + vn1 = v >> 32; + vn0 = v & 0xFFFFFFFF; + + // Break right half of dividend into two digits + un1 = un10 >> 32; + un0 = un10 & 0xFFFFFFFF; + + // Compute the first quotient digit, q1 + q1 = un64 / vn1; + rhat = un64 - q1 * vn1; + + while (q1 >= b || q1 * vn0 > b * rhat + un1) { + q1 = q1 - 1; + rhat = rhat + vn1; + if (rhat >= b) + break; + } + + // Multiply and subtract + un21 = un64 * b + un1 - q1 * v; + + // Compute the second quotient digit + q0 = un21 / vn1; + rhat = un21 - q0 * vn1; + + while (q0 >= b || q0 * vn0 > b * rhat + un0) { + q0 = q0 - 1; + rhat = rhat + vn1; + if (rhat >= b) + break; + } + + *r = (un21 * b + un0 - q0 * v) >> s; + return q1 * b + q0; +#endif +} + +// Bitshift a u128 in place, left (signed_shift > 0) or right (signed_shift < 0) +static inline void libdivide_u128_shift(uint64_t *u1, uint64_t *u0, int32_t signed_shift) { + if (signed_shift > 0) { + uint32_t shift = signed_shift; + *u1 <<= shift; + *u1 |= *u0 >> (64 - shift); + *u0 <<= shift; + } + else if (signed_shift < 0) { + uint32_t shift = -signed_shift; + *u0 >>= shift; + *u0 |= *u1 << (64 - shift); + *u1 >>= shift; + } +} + +// Computes a 128 / 128 -> 64 bit division, with a 128 bit remainder. +static uint64_t libdivide_128_div_128_to_64(uint64_t u_hi, uint64_t u_lo, uint64_t v_hi, uint64_t v_lo, uint64_t *r_hi, uint64_t *r_lo) { +#if defined(HAS_INT128_T) && \ + defined(HAS_INT128_DIV) + __uint128_t ufull = u_hi; + __uint128_t vfull = v_hi; + ufull = (ufull << 64) | u_lo; + vfull = (vfull << 64) | v_lo; + uint64_t res = (uint64_t)(ufull / vfull); + __uint128_t remainder = ufull - (vfull * res); + *r_lo = (uint64_t)remainder; + *r_hi = (uint64_t)(remainder >> 64); + return res; +#else + // Adapted from "Unsigned Doubleword Division" in Hacker's Delight + // We want to compute u / v + typedef struct { uint64_t hi; uint64_t lo; } u128_t; + u128_t u = {u_hi, u_lo}; + u128_t v = {v_hi, v_lo}; + + if (v.hi == 0) { + // divisor v is a 64 bit value, so we just need one 128/64 division + // Note that we are simpler than Hacker's Delight here, because we know + // the quotient fits in 64 bits whereas Hacker's Delight demands a full + // 128 bit quotient + *r_hi = 0; + return libdivide_128_div_64_to_64(u.hi, u.lo, v.lo, r_lo); + } + // Here v >= 2**64 + // We know that v.hi != 0, so count leading zeros is OK + // We have 0 <= n <= 63 + uint32_t n = libdivide_count_leading_zeros64(v.hi); + + // Normalize the divisor so its MSB is 1 + u128_t v1t = v; + libdivide_u128_shift(&v1t.hi, &v1t.lo, n); + uint64_t v1 = v1t.hi; // i.e. v1 = v1t >> 64 + + // To ensure no overflow + u128_t u1 = u; + libdivide_u128_shift(&u1.hi, &u1.lo, -1); + + // Get quotient from divide unsigned insn. + uint64_t rem_ignored; + uint64_t q1 = libdivide_128_div_64_to_64(u1.hi, u1.lo, v1, &rem_ignored); + + // Undo normalization and division of u by 2. + u128_t q0 = {0, q1}; + libdivide_u128_shift(&q0.hi, &q0.lo, n); + libdivide_u128_shift(&q0.hi, &q0.lo, -63); + + // Make q0 correct or too small by 1 + // Equivalent to `if (q0 != 0) q0 = q0 - 1;` + if (q0.hi != 0 || q0.lo != 0) { + q0.hi -= (q0.lo == 0); // borrow + q0.lo -= 1; + } + + // Now q0 is correct. + // Compute q0 * v as q0v + // = (q0.hi << 64 + q0.lo) * (v.hi << 64 + v.lo) + // = (q0.hi * v.hi << 128) + (q0.hi * v.lo << 64) + + // (q0.lo * v.hi << 64) + q0.lo * v.lo) + // Each term is 128 bit + // High half of full product (upper 128 bits!) are dropped + u128_t q0v = {0, 0}; + q0v.hi = q0.hi*v.lo + q0.lo*v.hi + libdivide_mullhi_u64(q0.lo, v.lo); + q0v.lo = q0.lo*v.lo; + + // Compute u - q0v as u_q0v + // This is the remainder + u128_t u_q0v = u; + u_q0v.hi -= q0v.hi + (u.lo < q0v.lo); // second term is borrow + u_q0v.lo -= q0v.lo; + + // Check if u_q0v >= v + // This checks if our remainder is larger than the divisor + if ((u_q0v.hi > v.hi) || + (u_q0v.hi == v.hi && u_q0v.lo >= v.lo)) { + // Increment q0 + q0.lo += 1; + q0.hi += (q0.lo == 0); // carry + + // Subtract v from remainder + u_q0v.hi -= v.hi + (u_q0v.lo < v.lo); + u_q0v.lo -= v.lo; + } + + *r_hi = u_q0v.hi; + *r_lo = u_q0v.lo; + + LIBDIVIDE_ASSERT(q0.hi == 0); + return q0.lo; +#endif +} + +////////// UINT32 + +static inline struct libdivide_u32_t libdivide_internal_u32_gen(uint32_t d, int branchfree) { + if (d == 0) { + LIBDIVIDE_ERROR("divider must be != 0"); + } + + struct libdivide_u32_t result; + uint32_t floor_log_2_d = 31 - libdivide_count_leading_zeros32(d); + + // Power of 2 + if ((d & (d - 1)) == 0) { + // We need to subtract 1 from the shift value in case of an unsigned + // branchfree divider because there is a hardcoded right shift by 1 + // in its division algorithm. Because of this we also need to add back + // 1 in its recovery algorithm. + result.magic = 0; + result.more = (uint8_t)(floor_log_2_d - (branchfree != 0)); + } else { + uint8_t more; + uint32_t rem, proposed_m; + proposed_m = libdivide_64_div_32_to_32(1U << floor_log_2_d, 0, d, &rem); + + LIBDIVIDE_ASSERT(rem > 0 && rem < d); + const uint32_t e = d - rem; + + // This power works if e < 2**floor_log_2_d. + if (!branchfree && (e < (1U << floor_log_2_d))) { + // This power works + more = floor_log_2_d; + } else { + // We have to use the general 33-bit algorithm. We need to compute + // (2**power) / d. However, we already have (2**(power-1))/d and + // its remainder. By doubling both, and then correcting the + // remainder, we can compute the larger division. + // don't care about overflow here - in fact, we expect it + proposed_m += proposed_m; + const uint32_t twice_rem = rem + rem; + if (twice_rem >= d || twice_rem < rem) proposed_m += 1; + more = floor_log_2_d | LIBDIVIDE_ADD_MARKER; + } + result.magic = 1 + proposed_m; + result.more = more; + // result.more's shift should in general be ceil_log_2_d. But if we + // used the smaller power, we subtract one from the shift because we're + // using the smaller power. If we're using the larger power, we + // subtract one from the shift because it's taken care of by the add + // indicator. So floor_log_2_d happens to be correct in both cases. + } + return result; +} + +struct libdivide_u32_t libdivide_u32_gen(uint32_t d) { + return libdivide_internal_u32_gen(d, 0); +} + +struct libdivide_u32_branchfree_t libdivide_u32_branchfree_gen(uint32_t d) { + if (d == 1) { + LIBDIVIDE_ERROR("branchfree divider must be != 1"); + } + struct libdivide_u32_t tmp = libdivide_internal_u32_gen(d, 1); + struct libdivide_u32_branchfree_t ret = {tmp.magic, (uint8_t)(tmp.more & LIBDIVIDE_32_SHIFT_MASK)}; + return ret; +} + +uint32_t libdivide_u32_do(uint32_t numer, const struct libdivide_u32_t *denom) { + uint8_t more = denom->more; + if (!denom->magic) { + return numer >> more; + } + else { + uint32_t q = libdivide_mullhi_u32(denom->magic, numer); + if (more & LIBDIVIDE_ADD_MARKER) { + uint32_t t = ((numer - q) >> 1) + q; + return t >> (more & LIBDIVIDE_32_SHIFT_MASK); + } + else { + // All upper bits are 0, + // don't need to mask them off. + return q >> more; + } + } +} + +uint32_t libdivide_u32_branchfree_do(uint32_t numer, const struct libdivide_u32_branchfree_t *denom) { + uint32_t q = libdivide_mullhi_u32(denom->magic, numer); + uint32_t t = ((numer - q) >> 1) + q; + return t >> denom->more; +} + +uint32_t libdivide_u32_recover(const struct libdivide_u32_t *denom) { + uint8_t more = denom->more; + uint8_t shift = more & LIBDIVIDE_32_SHIFT_MASK; + + if (!denom->magic) { + return 1U << shift; + } else if (!(more & LIBDIVIDE_ADD_MARKER)) { + // We compute q = n/d = n*m / 2^(32 + shift) + // Therefore we have d = 2^(32 + shift) / m + // We need to ceil it. + // We know d is not a power of 2, so m is not a power of 2, + // so we can just add 1 to the floor + uint32_t hi_dividend = 1U << shift; + uint32_t rem_ignored; + return 1 + libdivide_64_div_32_to_32(hi_dividend, 0, denom->magic, &rem_ignored); + } else { + // Here we wish to compute d = 2^(32+shift+1)/(m+2^32). + // Notice (m + 2^32) is a 33 bit number. Use 64 bit division for now + // Also note that shift may be as high as 31, so shift + 1 will + // overflow. So we have to compute it as 2^(32+shift)/(m+2^32), and + // then double the quotient and remainder. + uint64_t half_n = 1ULL << (32 + shift); + uint64_t d = (1ULL << 32) | denom->magic; + // Note that the quotient is guaranteed <= 32 bits, but the remainder + // may need 33! + uint32_t half_q = (uint32_t)(half_n / d); + uint64_t rem = half_n % d; + // We computed 2^(32+shift)/(m+2^32) + // Need to double it, and then add 1 to the quotient if doubling th + // remainder would increase the quotient. + // Note that rem<<1 cannot overflow, since rem < d and d is 33 bits + uint32_t full_q = half_q + half_q + ((rem<<1) >= d); + + // We rounded down in gen (hence +1) + return full_q + 1; + } +} + +uint32_t libdivide_u32_branchfree_recover(const struct libdivide_u32_branchfree_t *denom) { + uint8_t more = denom->more; + uint8_t shift = more & LIBDIVIDE_32_SHIFT_MASK; + + if (!denom->magic) { + return 1U << (shift + 1); + } else { + // Here we wish to compute d = 2^(32+shift+1)/(m+2^32). + // Notice (m + 2^32) is a 33 bit number. Use 64 bit division for now + // Also note that shift may be as high as 31, so shift + 1 will + // overflow. So we have to compute it as 2^(32+shift)/(m+2^32), and + // then double the quotient and remainder. + uint64_t half_n = 1ULL << (32 + shift); + uint64_t d = (1ULL << 32) | denom->magic; + // Note that the quotient is guaranteed <= 32 bits, but the remainder + // may need 33! + uint32_t half_q = (uint32_t)(half_n / d); + uint64_t rem = half_n % d; + // We computed 2^(32+shift)/(m+2^32) + // Need to double it, and then add 1 to the quotient if doubling th + // remainder would increase the quotient. + // Note that rem<<1 cannot overflow, since rem < d and d is 33 bits + uint32_t full_q = half_q + half_q + ((rem<<1) >= d); + + // We rounded down in gen (hence +1) + return full_q + 1; + } +} + +/////////// UINT64 + +static inline struct libdivide_u64_t libdivide_internal_u64_gen(uint64_t d, int branchfree) { + if (d == 0) { + LIBDIVIDE_ERROR("divider must be != 0"); + } + + struct libdivide_u64_t result; + uint32_t floor_log_2_d = 63 - libdivide_count_leading_zeros64(d); + + // Power of 2 + if ((d & (d - 1)) == 0) { + // We need to subtract 1 from the shift value in case of an unsigned + // branchfree divider because there is a hardcoded right shift by 1 + // in its division algorithm. Because of this we also need to add back + // 1 in its recovery algorithm. + result.magic = 0; + result.more = (uint8_t)(floor_log_2_d - (branchfree != 0)); + } else { + uint64_t proposed_m, rem; + uint8_t more; + // (1 << (64 + floor_log_2_d)) / d + proposed_m = libdivide_128_div_64_to_64(1ULL << floor_log_2_d, 0, d, &rem); + + LIBDIVIDE_ASSERT(rem > 0 && rem < d); + const uint64_t e = d - rem; + + // This power works if e < 2**floor_log_2_d. + if (!branchfree && e < (1ULL << floor_log_2_d)) { + // This power works + more = floor_log_2_d; + } else { + // We have to use the general 65-bit algorithm. We need to compute + // (2**power) / d. However, we already have (2**(power-1))/d and + // its remainder. By doubling both, and then correcting the + // remainder, we can compute the larger division. + // don't care about overflow here - in fact, we expect it + proposed_m += proposed_m; + const uint64_t twice_rem = rem + rem; + if (twice_rem >= d || twice_rem < rem) proposed_m += 1; + more = floor_log_2_d | LIBDIVIDE_ADD_MARKER; + } + result.magic = 1 + proposed_m; + result.more = more; + // result.more's shift should in general be ceil_log_2_d. But if we + // used the smaller power, we subtract one from the shift because we're + // using the smaller power. If we're using the larger power, we + // subtract one from the shift because it's taken care of by the add + // indicator. So floor_log_2_d happens to be correct in both cases, + // which is why we do it outside of the if statement. + } + return result; +} + +struct libdivide_u64_t libdivide_u64_gen(uint64_t d) { + return libdivide_internal_u64_gen(d, 0); +} + +struct libdivide_u64_branchfree_t libdivide_u64_branchfree_gen(uint64_t d) { + if (d == 1) { + LIBDIVIDE_ERROR("branchfree divider must be != 1"); + } + struct libdivide_u64_t tmp = libdivide_internal_u64_gen(d, 1); + struct libdivide_u64_branchfree_t ret = {tmp.magic, (uint8_t)(tmp.more & LIBDIVIDE_64_SHIFT_MASK)}; + return ret; +} + +uint64_t libdivide_u64_do(uint64_t numer, const struct libdivide_u64_t *denom) { + uint8_t more = denom->more; + if (!denom->magic) { + return numer >> more; + } + else { + uint64_t q = libdivide_mullhi_u64(denom->magic, numer); + if (more & LIBDIVIDE_ADD_MARKER) { + uint64_t t = ((numer - q) >> 1) + q; + return t >> (more & LIBDIVIDE_64_SHIFT_MASK); + } + else { + // All upper bits are 0, + // don't need to mask them off. + return q >> more; + } + } +} + +uint64_t libdivide_u64_branchfree_do(uint64_t numer, const struct libdivide_u64_branchfree_t *denom) { + uint64_t q = libdivide_mullhi_u64(denom->magic, numer); + uint64_t t = ((numer - q) >> 1) + q; + return t >> denom->more; +} + +uint64_t libdivide_u64_recover(const struct libdivide_u64_t *denom) { + uint8_t more = denom->more; + uint8_t shift = more & LIBDIVIDE_64_SHIFT_MASK; + + if (!denom->magic) { + return 1ULL << shift; + } else if (!(more & LIBDIVIDE_ADD_MARKER)) { + // We compute q = n/d = n*m / 2^(64 + shift) + // Therefore we have d = 2^(64 + shift) / m + // We need to ceil it. + // We know d is not a power of 2, so m is not a power of 2, + // so we can just add 1 to the floor + uint64_t hi_dividend = 1ULL << shift; + uint64_t rem_ignored; + return 1 + libdivide_128_div_64_to_64(hi_dividend, 0, denom->magic, &rem_ignored); + } else { + // Here we wish to compute d = 2^(64+shift+1)/(m+2^64). + // Notice (m + 2^64) is a 65 bit number. This gets hairy. See + // libdivide_u32_recover for more on what we do here. + // TODO: do something better than 128 bit math + + // Full n is a (potentially) 129 bit value + // half_n is a 128 bit value + // Compute the hi half of half_n. Low half is 0. + uint64_t half_n_hi = 1ULL << shift, half_n_lo = 0; + // d is a 65 bit value. The high bit is always set to 1. + const uint64_t d_hi = 1, d_lo = denom->magic; + // Note that the quotient is guaranteed <= 64 bits, + // but the remainder may need 65! + uint64_t r_hi, r_lo; + uint64_t half_q = libdivide_128_div_128_to_64(half_n_hi, half_n_lo, d_hi, d_lo, &r_hi, &r_lo); + // We computed 2^(64+shift)/(m+2^64) + // Double the remainder ('dr') and check if that is larger than d + // Note that d is a 65 bit value, so r1 is small and so r1 + r1 + // cannot overflow + uint64_t dr_lo = r_lo + r_lo; + uint64_t dr_hi = r_hi + r_hi + (dr_lo < r_lo); // last term is carry + int dr_exceeds_d = (dr_hi > d_hi) || (dr_hi == d_hi && dr_lo >= d_lo); + uint64_t full_q = half_q + half_q + (dr_exceeds_d ? 1 : 0); + return full_q + 1; + } +} + +uint64_t libdivide_u64_branchfree_recover(const struct libdivide_u64_branchfree_t *denom) { + uint8_t more = denom->more; + uint8_t shift = more & LIBDIVIDE_64_SHIFT_MASK; + + if (!denom->magic) { + return 1ULL << (shift + 1); + } else { + // Here we wish to compute d = 2^(64+shift+1)/(m+2^64). + // Notice (m + 2^64) is a 65 bit number. This gets hairy. See + // libdivide_u32_recover for more on what we do here. + // TODO: do something better than 128 bit math + + // Full n is a (potentially) 129 bit value + // half_n is a 128 bit value + // Compute the hi half of half_n. Low half is 0. + uint64_t half_n_hi = 1ULL << shift, half_n_lo = 0; + // d is a 65 bit value. The high bit is always set to 1. + const uint64_t d_hi = 1, d_lo = denom->magic; + // Note that the quotient is guaranteed <= 64 bits, + // but the remainder may need 65! + uint64_t r_hi, r_lo; + uint64_t half_q = libdivide_128_div_128_to_64(half_n_hi, half_n_lo, d_hi, d_lo, &r_hi, &r_lo); + // We computed 2^(64+shift)/(m+2^64) + // Double the remainder ('dr') and check if that is larger than d + // Note that d is a 65 bit value, so r1 is small and so r1 + r1 + // cannot overflow + uint64_t dr_lo = r_lo + r_lo; + uint64_t dr_hi = r_hi + r_hi + (dr_lo < r_lo); // last term is carry + int dr_exceeds_d = (dr_hi > d_hi) || (dr_hi == d_hi && dr_lo >= d_lo); + uint64_t full_q = half_q + half_q + (dr_exceeds_d ? 1 : 0); + return full_q + 1; + } +} + +/////////// SINT32 + +static inline struct libdivide_s32_t libdivide_internal_s32_gen(int32_t d, int branchfree) { + if (d == 0) { + LIBDIVIDE_ERROR("divider must be != 0"); + } + + struct libdivide_s32_t result; + + // If d is a power of 2, or negative a power of 2, we have to use a shift. + // This is especially important because the magic algorithm fails for -1. + // To check if d is a power of 2 or its inverse, it suffices to check + // whether its absolute value has exactly one bit set. This works even for + // INT_MIN, because abs(INT_MIN) == INT_MIN, and INT_MIN has one bit set + // and is a power of 2. + uint32_t ud = (uint32_t)d; + uint32_t absD = (d < 0) ? -ud : ud; + uint32_t floor_log_2_d = 31 - libdivide_count_leading_zeros32(absD); + // check if exactly one bit is set, + // don't care if absD is 0 since that's divide by zero + if ((absD & (absD - 1)) == 0) { + // Branchfree and normal paths are exactly the same + result.magic = 0; + result.more = floor_log_2_d | (d < 0 ? LIBDIVIDE_NEGATIVE_DIVISOR : 0); + } else { + LIBDIVIDE_ASSERT(floor_log_2_d >= 1); + + uint8_t more; + // the dividend here is 2**(floor_log_2_d + 31), so the low 32 bit word + // is 0 and the high word is floor_log_2_d - 1 + uint32_t rem, proposed_m; + proposed_m = libdivide_64_div_32_to_32(1U << (floor_log_2_d - 1), 0, absD, &rem); + const uint32_t e = absD - rem; + + // We are going to start with a power of floor_log_2_d - 1. + // This works if works if e < 2**floor_log_2_d. + if (!branchfree && e < (1U << floor_log_2_d)) { + // This power works + more = floor_log_2_d - 1; + } else { + // We need to go one higher. This should not make proposed_m + // overflow, but it will make it negative when interpreted as an + // int32_t. + proposed_m += proposed_m; + const uint32_t twice_rem = rem + rem; + if (twice_rem >= absD || twice_rem < rem) proposed_m += 1; + more = floor_log_2_d | LIBDIVIDE_ADD_MARKER; + } + + proposed_m += 1; + int32_t magic = (int32_t)proposed_m; + + // Mark if we are negative. Note we only negate the magic number in the + // branchfull case. + if (d < 0) { + more |= LIBDIVIDE_NEGATIVE_DIVISOR; + if (!branchfree) { + magic = -magic; + } + } + + result.more = more; + result.magic = magic; + } + return result; +} + +struct libdivide_s32_t libdivide_s32_gen(int32_t d) { + return libdivide_internal_s32_gen(d, 0); +} + +struct libdivide_s32_branchfree_t libdivide_s32_branchfree_gen(int32_t d) { + struct libdivide_s32_t tmp = libdivide_internal_s32_gen(d, 1); + struct libdivide_s32_branchfree_t result = {tmp.magic, tmp.more}; + return result; +} + +int32_t libdivide_s32_do(int32_t numer, const struct libdivide_s32_t *denom) { + uint8_t more = denom->more; + uint8_t shift = more & LIBDIVIDE_32_SHIFT_MASK; + + if (!denom->magic) { + uint32_t sign = (int8_t)more >> 7; + uint32_t mask = (1U << shift) - 1; + uint32_t uq = numer + ((numer >> 31) & mask); + int32_t q = (int32_t)uq; + q >>= shift; + q = (q ^ sign) - sign; + return q; + } else { + uint32_t uq = (uint32_t)libdivide_mullhi_s32(denom->magic, numer); + if (more & LIBDIVIDE_ADD_MARKER) { + // must be arithmetic shift and then sign extend + int32_t sign = (int8_t)more >> 7; + // q += (more < 0 ? -numer : numer) + // cast required to avoid UB + uq += ((uint32_t)numer ^ sign) - sign; + } + int32_t q = (int32_t)uq; + q >>= shift; + q += (q < 0); + return q; + } +} + +int32_t libdivide_s32_branchfree_do(int32_t numer, const struct libdivide_s32_branchfree_t *denom) { + uint8_t more = denom->more; + uint8_t shift = more & LIBDIVIDE_32_SHIFT_MASK; + // must be arithmetic shift and then sign extend + int32_t sign = (int8_t)more >> 7; + int32_t magic = denom->magic; + int32_t q = libdivide_mullhi_s32(magic, numer); + q += numer; + + // If q is non-negative, we have nothing to do + // If q is negative, we want to add either (2**shift)-1 if d is a power of + // 2, or (2**shift) if it is not a power of 2 + uint32_t is_power_of_2 = (magic == 0); + uint32_t q_sign = (uint32_t)(q >> 31); + q += q_sign & ((1U << shift) - is_power_of_2); + + // Now arithmetic right shift + q >>= shift; + // Negate if needed + q = (q ^ sign) - sign; + + return q; +} + +int32_t libdivide_s32_recover(const struct libdivide_s32_t *denom) { + uint8_t more = denom->more; + uint8_t shift = more & LIBDIVIDE_32_SHIFT_MASK; + if (!denom->magic) { + uint32_t absD = 1U << shift; + if (more & LIBDIVIDE_NEGATIVE_DIVISOR) { + absD = -absD; + } + return (int32_t)absD; + } else { + // Unsigned math is much easier + // We negate the magic number only in the branchfull case, and we don't + // know which case we're in. However we have enough information to + // determine the correct sign of the magic number. The divisor was + // negative if LIBDIVIDE_NEGATIVE_DIVISOR is set. If ADD_MARKER is set, + // the magic number's sign is opposite that of the divisor. + // We want to compute the positive magic number. + int negative_divisor = (more & LIBDIVIDE_NEGATIVE_DIVISOR); + int magic_was_negated = (more & LIBDIVIDE_ADD_MARKER) + ? denom->magic > 0 : denom->magic < 0; + + // Handle the power of 2 case (including branchfree) + if (denom->magic == 0) { + int32_t result = 1U << shift; + return negative_divisor ? -result : result; + } + + uint32_t d = (uint32_t)(magic_was_negated ? -denom->magic : denom->magic); + uint64_t n = 1ULL << (32 + shift); // this shift cannot exceed 30 + uint32_t q = (uint32_t)(n / d); + int32_t result = (int32_t)q; + result += 1; + return negative_divisor ? -result : result; + } +} + +int32_t libdivide_s32_branchfree_recover(const struct libdivide_s32_branchfree_t *denom) { + return libdivide_s32_recover((const struct libdivide_s32_t *)denom); +} + +///////////// SINT64 + +static inline struct libdivide_s64_t libdivide_internal_s64_gen(int64_t d, int branchfree) { + if (d == 0) { + LIBDIVIDE_ERROR("divider must be != 0"); + } + + struct libdivide_s64_t result; + + // If d is a power of 2, or negative a power of 2, we have to use a shift. + // This is especially important because the magic algorithm fails for -1. + // To check if d is a power of 2 or its inverse, it suffices to check + // whether its absolute value has exactly one bit set. This works even for + // INT_MIN, because abs(INT_MIN) == INT_MIN, and INT_MIN has one bit set + // and is a power of 2. + uint64_t ud = (uint64_t)d; + uint64_t absD = (d < 0) ? -ud : ud; + uint32_t floor_log_2_d = 63 - libdivide_count_leading_zeros64(absD); + // check if exactly one bit is set, + // don't care if absD is 0 since that's divide by zero + if ((absD & (absD - 1)) == 0) { + // Branchfree and non-branchfree cases are the same + result.magic = 0; + result.more = floor_log_2_d | (d < 0 ? LIBDIVIDE_NEGATIVE_DIVISOR : 0); + } else { + // the dividend here is 2**(floor_log_2_d + 63), so the low 64 bit word + // is 0 and the high word is floor_log_2_d - 1 + uint8_t more; + uint64_t rem, proposed_m; + proposed_m = libdivide_128_div_64_to_64(1ULL << (floor_log_2_d - 1), 0, absD, &rem); + const uint64_t e = absD - rem; + + // We are going to start with a power of floor_log_2_d - 1. + // This works if works if e < 2**floor_log_2_d. + if (!branchfree && e < (1ULL << floor_log_2_d)) { + // This power works + more = floor_log_2_d - 1; + } else { + // We need to go one higher. This should not make proposed_m + // overflow, but it will make it negative when interpreted as an + // int32_t. + proposed_m += proposed_m; + const uint64_t twice_rem = rem + rem; + if (twice_rem >= absD || twice_rem < rem) proposed_m += 1; + // note that we only set the LIBDIVIDE_NEGATIVE_DIVISOR bit if we + // also set ADD_MARKER this is an annoying optimization that + // enables algorithm #4 to avoid the mask. However we always set it + // in the branchfree case + more = floor_log_2_d | LIBDIVIDE_ADD_MARKER; + } + proposed_m += 1; + int64_t magic = (int64_t)proposed_m; + + // Mark if we are negative + if (d < 0) { + more |= LIBDIVIDE_NEGATIVE_DIVISOR; + if (!branchfree) { + magic = -magic; + } + } + + result.more = more; + result.magic = magic; + } + return result; +} + +struct libdivide_s64_t libdivide_s64_gen(int64_t d) { + return libdivide_internal_s64_gen(d, 0); +} + +struct libdivide_s64_branchfree_t libdivide_s64_branchfree_gen(int64_t d) { + struct libdivide_s64_t tmp = libdivide_internal_s64_gen(d, 1); + struct libdivide_s64_branchfree_t ret = {tmp.magic, tmp.more}; + return ret; +} + +int64_t libdivide_s64_do(int64_t numer, const struct libdivide_s64_t *denom) { + uint8_t more = denom->more; + uint8_t shift = more & LIBDIVIDE_64_SHIFT_MASK; + + if (!denom->magic) { // shift path + uint64_t mask = (1ULL << shift) - 1; + uint64_t uq = numer + ((numer >> 63) & mask); + int64_t q = (int64_t)uq; + q >>= shift; + // must be arithmetic shift and then sign-extend + int64_t sign = (int8_t)more >> 7; + q = (q ^ sign) - sign; + return q; + } else { + uint64_t uq = (uint64_t)libdivide_mullhi_s64(denom->magic, numer); + if (more & LIBDIVIDE_ADD_MARKER) { + // must be arithmetic shift and then sign extend + int64_t sign = (int8_t)more >> 7; + // q += (more < 0 ? -numer : numer) + // cast required to avoid UB + uq += ((uint64_t)numer ^ sign) - sign; + } + int64_t q = (int64_t)uq; + q >>= shift; + q += (q < 0); + return q; + } +} + +int64_t libdivide_s64_branchfree_do(int64_t numer, const struct libdivide_s64_branchfree_t *denom) { + uint8_t more = denom->more; + uint8_t shift = more & LIBDIVIDE_64_SHIFT_MASK; + // must be arithmetic shift and then sign extend + int64_t sign = (int8_t)more >> 7; + int64_t magic = denom->magic; + int64_t q = libdivide_mullhi_s64(magic, numer); + q += numer; + + // If q is non-negative, we have nothing to do. + // If q is negative, we want to add either (2**shift)-1 if d is a power of + // 2, or (2**shift) if it is not a power of 2. + uint64_t is_power_of_2 = (magic == 0); + uint64_t q_sign = (uint64_t)(q >> 63); + q += q_sign & ((1ULL << shift) - is_power_of_2); + + // Arithmetic right shift + q >>= shift; + // Negate if needed + q = (q ^ sign) - sign; + + return q; +} + +int64_t libdivide_s64_recover(const struct libdivide_s64_t *denom) { + uint8_t more = denom->more; + uint8_t shift = more & LIBDIVIDE_64_SHIFT_MASK; + if (denom->magic == 0) { // shift path + uint64_t absD = 1ULL << shift; + if (more & LIBDIVIDE_NEGATIVE_DIVISOR) { + absD = -absD; + } + return (int64_t)absD; + } else { + // Unsigned math is much easier + int negative_divisor = (more & LIBDIVIDE_NEGATIVE_DIVISOR); + int magic_was_negated = (more & LIBDIVIDE_ADD_MARKER) + ? denom->magic > 0 : denom->magic < 0; + + uint64_t d = (uint64_t)(magic_was_negated ? -denom->magic : denom->magic); + uint64_t n_hi = 1ULL << shift, n_lo = 0; + uint64_t rem_ignored; + uint64_t q = libdivide_128_div_64_to_64(n_hi, n_lo, d, &rem_ignored); + int64_t result = (int64_t)(q + 1); + if (negative_divisor) { + result = -result; + } + return result; + } +} + +int64_t libdivide_s64_branchfree_recover(const struct libdivide_s64_branchfree_t *denom) { + return libdivide_s64_recover((const struct libdivide_s64_t *)denom); +} + +#if defined(LIBDIVIDE_AVX512) + +static inline __m512i libdivide_u32_do_vector(__m512i numers, const struct libdivide_u32_t *denom); +static inline __m512i libdivide_s32_do_vector(__m512i numers, const struct libdivide_s32_t *denom); +static inline __m512i libdivide_u64_do_vector(__m512i numers, const struct libdivide_u64_t *denom); +static inline __m512i libdivide_s64_do_vector(__m512i numers, const struct libdivide_s64_t *denom); + +static inline __m512i libdivide_u32_branchfree_do_vector(__m512i numers, const struct libdivide_u32_branchfree_t *denom); +static inline __m512i libdivide_s32_branchfree_do_vector(__m512i numers, const struct libdivide_s32_branchfree_t *denom); +static inline __m512i libdivide_u64_branchfree_do_vector(__m512i numers, const struct libdivide_u64_branchfree_t *denom); +static inline __m512i libdivide_s64_branchfree_do_vector(__m512i numers, const struct libdivide_s64_branchfree_t *denom); + +//////// Internal Utility Functions + +static inline __m512i libdivide_s64_signbits(__m512i v) {; + return _mm512_srai_epi64(v, 63); +} + +static inline __m512i libdivide_s64_shift_right_vector(__m512i v, int amt) { + return _mm512_srai_epi64(v, amt); +} + +// Here, b is assumed to contain one 32-bit value repeated. +static inline __m512i libdivide_mullhi_u32_vector(__m512i a, __m512i b) { + __m512i hi_product_0Z2Z = _mm512_srli_epi64(_mm512_mul_epu32(a, b), 32); + __m512i a1X3X = _mm512_srli_epi64(a, 32); + __m512i mask = _mm512_set_epi32(-1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0); + __m512i hi_product_Z1Z3 = _mm512_and_si512(_mm512_mul_epu32(a1X3X, b), mask); + return _mm512_or_si512(hi_product_0Z2Z, hi_product_Z1Z3); +} + +// b is one 32-bit value repeated. +static inline __m512i libdivide_mullhi_s32_vector(__m512i a, __m512i b) { + __m512i hi_product_0Z2Z = _mm512_srli_epi64(_mm512_mul_epi32(a, b), 32); + __m512i a1X3X = _mm512_srli_epi64(a, 32); + __m512i mask = _mm512_set_epi32(-1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0); + __m512i hi_product_Z1Z3 = _mm512_and_si512(_mm512_mul_epi32(a1X3X, b), mask); + return _mm512_or_si512(hi_product_0Z2Z, hi_product_Z1Z3); +} + +// Here, y is assumed to contain one 64-bit value repeated. +// https://stackoverflow.com/a/28827013 +static inline __m512i libdivide_mullhi_u64_vector(__m512i x, __m512i y) { + __m512i lomask = _mm512_set1_epi64(0xffffffff); + __m512i xh = _mm512_shuffle_epi32(x, (_MM_PERM_ENUM) 0xB1); + __m512i yh = _mm512_shuffle_epi32(y, (_MM_PERM_ENUM) 0xB1); + __m512i w0 = _mm512_mul_epu32(x, y); + __m512i w1 = _mm512_mul_epu32(x, yh); + __m512i w2 = _mm512_mul_epu32(xh, y); + __m512i w3 = _mm512_mul_epu32(xh, yh); + __m512i w0h = _mm512_srli_epi64(w0, 32); + __m512i s1 = _mm512_add_epi64(w1, w0h); + __m512i s1l = _mm512_and_si512(s1, lomask); + __m512i s1h = _mm512_srli_epi64(s1, 32); + __m512i s2 = _mm512_add_epi64(w2, s1l); + __m512i s2h = _mm512_srli_epi64(s2, 32); + __m512i hi = _mm512_add_epi64(w3, s1h); + hi = _mm512_add_epi64(hi, s2h); + + return hi; +} + +// y is one 64-bit value repeated. +static inline __m512i libdivide_mullhi_s64_vector(__m512i x, __m512i y) { + __m512i p = libdivide_mullhi_u64_vector(x, y); + __m512i t1 = _mm512_and_si512(libdivide_s64_signbits(x), y); + __m512i t2 = _mm512_and_si512(libdivide_s64_signbits(y), x); + p = _mm512_sub_epi64(p, t1); + p = _mm512_sub_epi64(p, t2); + return p; +} + +////////// UINT32 + +__m512i libdivide_u32_do_vector(__m512i numers, const struct libdivide_u32_t *denom) { + uint8_t more = denom->more; + if (!denom->magic) { + return _mm512_srli_epi32(numers, more); + } + else { + __m512i q = libdivide_mullhi_u32_vector(numers, _mm512_set1_epi32(denom->magic)); + if (more & LIBDIVIDE_ADD_MARKER) { + // uint32_t t = ((numer - q) >> 1) + q; + // return t >> denom->shift; + uint32_t shift = more & LIBDIVIDE_32_SHIFT_MASK; + __m512i t = _mm512_add_epi32(_mm512_srli_epi32(_mm512_sub_epi32(numers, q), 1), q); + return _mm512_srli_epi32(t, shift); + } + else { + return _mm512_srli_epi32(q, more); + } + } +} + +__m512i libdivide_u32_branchfree_do_vector(__m512i numers, const struct libdivide_u32_branchfree_t *denom) { + __m512i q = libdivide_mullhi_u32_vector(numers, _mm512_set1_epi32(denom->magic)); + __m512i t = _mm512_add_epi32(_mm512_srli_epi32(_mm512_sub_epi32(numers, q), 1), q); + return _mm512_srli_epi32(t, denom->more); +} + +////////// UINT64 + +__m512i libdivide_u64_do_vector(__m512i numers, const struct libdivide_u64_t *denom) { + uint8_t more = denom->more; + if (!denom->magic) { + return _mm512_srli_epi64(numers, more); + } + else { + __m512i q = libdivide_mullhi_u64_vector(numers, _mm512_set1_epi64(denom->magic)); + if (more & LIBDIVIDE_ADD_MARKER) { + // uint32_t t = ((numer - q) >> 1) + q; + // return t >> denom->shift; + uint32_t shift = more & LIBDIVIDE_64_SHIFT_MASK; + __m512i t = _mm512_add_epi64(_mm512_srli_epi64(_mm512_sub_epi64(numers, q), 1), q); + return _mm512_srli_epi64(t, shift); + } + else { + return _mm512_srli_epi64(q, more); + } + } +} + +__m512i libdivide_u64_branchfree_do_vector(__m512i numers, const struct libdivide_u64_branchfree_t *denom) { + __m512i q = libdivide_mullhi_u64_vector(numers, _mm512_set1_epi64(denom->magic)); + __m512i t = _mm512_add_epi64(_mm512_srli_epi64(_mm512_sub_epi64(numers, q), 1), q); + return _mm512_srli_epi64(t, denom->more); +} + +////////// SINT32 + +__m512i libdivide_s32_do_vector(__m512i numers, const struct libdivide_s32_t *denom) { + uint8_t more = denom->more; + if (!denom->magic) { + uint32_t shift = more & LIBDIVIDE_32_SHIFT_MASK; + uint32_t mask = (1U << shift) - 1; + __m512i roundToZeroTweak = _mm512_set1_epi32(mask); + // q = numer + ((numer >> 31) & roundToZeroTweak); + __m512i q = _mm512_add_epi32(numers, _mm512_and_si512(_mm512_srai_epi32(numers, 31), roundToZeroTweak)); + q = _mm512_srai_epi32(q, shift); + __m512i sign = _mm512_set1_epi32((int8_t)more >> 7); + // q = (q ^ sign) - sign; + q = _mm512_sub_epi32(_mm512_xor_si512(q, sign), sign); + return q; + } + else { + __m512i q = libdivide_mullhi_s32_vector(numers, _mm512_set1_epi32(denom->magic)); + if (more & LIBDIVIDE_ADD_MARKER) { + // must be arithmetic shift + __m512i sign = _mm512_set1_epi32((int8_t)more >> 7); + // q += ((numer ^ sign) - sign); + q = _mm512_add_epi32(q, _mm512_sub_epi32(_mm512_xor_si512(numers, sign), sign)); + } + // q >>= shift + q = _mm512_srai_epi32(q, more & LIBDIVIDE_32_SHIFT_MASK); + q = _mm512_add_epi32(q, _mm512_srli_epi32(q, 31)); // q += (q < 0) + return q; + } +} + +__m512i libdivide_s32_branchfree_do_vector(__m512i numers, const struct libdivide_s32_branchfree_t *denom) { + int32_t magic = denom->magic; + uint8_t more = denom->more; + uint8_t shift = more & LIBDIVIDE_32_SHIFT_MASK; + // must be arithmetic shift + __m512i sign = _mm512_set1_epi32((int8_t)more >> 7); + __m512i q = libdivide_mullhi_s32_vector(numers, _mm512_set1_epi32(magic)); + q = _mm512_add_epi32(q, numers); // q += numers + + // If q is non-negative, we have nothing to do + // If q is negative, we want to add either (2**shift)-1 if d is + // a power of 2, or (2**shift) if it is not a power of 2 + uint32_t is_power_of_2 = (magic == 0); + __m512i q_sign = _mm512_srai_epi32(q, 31); // q_sign = q >> 31 + __m512i mask = _mm512_set1_epi32((1U << shift) - is_power_of_2); + q = _mm512_add_epi32(q, _mm512_and_si512(q_sign, mask)); // q = q + (q_sign & mask) + q = _mm512_srai_epi32(q, shift); // q >>= shift + q = _mm512_sub_epi32(_mm512_xor_si512(q, sign), sign); // q = (q ^ sign) - sign + return q; +} + +////////// SINT64 + +__m512i libdivide_s64_do_vector(__m512i numers, const struct libdivide_s64_t *denom) { + uint8_t more = denom->more; + int64_t magic = denom->magic; + if (magic == 0) { // shift path + uint32_t shift = more & LIBDIVIDE_64_SHIFT_MASK; + uint64_t mask = (1ULL << shift) - 1; + __m512i roundToZeroTweak = _mm512_set1_epi64(mask); + // q = numer + ((numer >> 63) & roundToZeroTweak); + __m512i q = _mm512_add_epi64(numers, _mm512_and_si512(libdivide_s64_signbits(numers), roundToZeroTweak)); + q = libdivide_s64_shift_right_vector(q, shift); + __m512i sign = _mm512_set1_epi32((int8_t)more >> 7); + // q = (q ^ sign) - sign; + q = _mm512_sub_epi64(_mm512_xor_si512(q, sign), sign); + return q; + } + else { + __m512i q = libdivide_mullhi_s64_vector(numers, _mm512_set1_epi64(magic)); + if (more & LIBDIVIDE_ADD_MARKER) { + // must be arithmetic shift + __m512i sign = _mm512_set1_epi32((int8_t)more >> 7); + // q += ((numer ^ sign) - sign); + q = _mm512_add_epi64(q, _mm512_sub_epi64(_mm512_xor_si512(numers, sign), sign)); + } + // q >>= denom->mult_path.shift + q = libdivide_s64_shift_right_vector(q, more & LIBDIVIDE_64_SHIFT_MASK); + q = _mm512_add_epi64(q, _mm512_srli_epi64(q, 63)); // q += (q < 0) + return q; + } +} + +__m512i libdivide_s64_branchfree_do_vector(__m512i numers, const struct libdivide_s64_branchfree_t *denom) { + int64_t magic = denom->magic; + uint8_t more = denom->more; + uint8_t shift = more & LIBDIVIDE_64_SHIFT_MASK; + // must be arithmetic shift + __m512i sign = _mm512_set1_epi32((int8_t)more >> 7); + + // libdivide_mullhi_s64(numers, magic); + __m512i q = libdivide_mullhi_s64_vector(numers, _mm512_set1_epi64(magic)); + q = _mm512_add_epi64(q, numers); // q += numers + + // If q is non-negative, we have nothing to do. + // If q is negative, we want to add either (2**shift)-1 if d is + // a power of 2, or (2**shift) if it is not a power of 2. + uint32_t is_power_of_2 = (magic == 0); + __m512i q_sign = libdivide_s64_signbits(q); // q_sign = q >> 63 + __m512i mask = _mm512_set1_epi64((1ULL << shift) - is_power_of_2); + q = _mm512_add_epi64(q, _mm512_and_si512(q_sign, mask)); // q = q + (q_sign & mask) + q = libdivide_s64_shift_right_vector(q, shift); // q >>= shift + q = _mm512_sub_epi64(_mm512_xor_si512(q, sign), sign); // q = (q ^ sign) - sign + return q; +} + +#elif defined(LIBDIVIDE_AVX2) + +static inline __m256i libdivide_u32_do_vector(__m256i numers, const struct libdivide_u32_t *denom); +static inline __m256i libdivide_s32_do_vector(__m256i numers, const struct libdivide_s32_t *denom); +static inline __m256i libdivide_u64_do_vector(__m256i numers, const struct libdivide_u64_t *denom); +static inline __m256i libdivide_s64_do_vector(__m256i numers, const struct libdivide_s64_t *denom); + +static inline __m256i libdivide_u32_branchfree_do_vector(__m256i numers, const struct libdivide_u32_branchfree_t *denom); +static inline __m256i libdivide_s32_branchfree_do_vector(__m256i numers, const struct libdivide_s32_branchfree_t *denom); +static inline __m256i libdivide_u64_branchfree_do_vector(__m256i numers, const struct libdivide_u64_branchfree_t *denom); +static inline __m256i libdivide_s64_branchfree_do_vector(__m256i numers, const struct libdivide_s64_branchfree_t *denom); + +//////// Internal Utility Functions + +// Implementation of _mm256_srai_epi64(v, 63) (from AVX512). +static inline __m256i libdivide_s64_signbits(__m256i v) { + __m256i hiBitsDuped = _mm256_shuffle_epi32(v, _MM_SHUFFLE(3, 3, 1, 1)); + __m256i signBits = _mm256_srai_epi32(hiBitsDuped, 31); + return signBits; +} + +// Implementation of _mm256_srai_epi64 (from AVX512). +static inline __m256i libdivide_s64_shift_right_vector(__m256i v, int amt) { + const int b = 64 - amt; + __m256i m = _mm256_set1_epi64x(1ULL << (b - 1)); + __m256i x = _mm256_srli_epi64(v, amt); + __m256i result = _mm256_sub_epi64(_mm256_xor_si256(x, m), m); + return result; +} + +// Here, b is assumed to contain one 32-bit value repeated. +static inline __m256i libdivide_mullhi_u32_vector(__m256i a, __m256i b) { + __m256i hi_product_0Z2Z = _mm256_srli_epi64(_mm256_mul_epu32(a, b), 32); + __m256i a1X3X = _mm256_srli_epi64(a, 32); + __m256i mask = _mm256_set_epi32(-1, 0, -1, 0, -1, 0, -1, 0); + __m256i hi_product_Z1Z3 = _mm256_and_si256(_mm256_mul_epu32(a1X3X, b), mask); + return _mm256_or_si256(hi_product_0Z2Z, hi_product_Z1Z3); +} + +// b is one 32-bit value repeated. +static inline __m256i libdivide_mullhi_s32_vector(__m256i a, __m256i b) { + __m256i hi_product_0Z2Z = _mm256_srli_epi64(_mm256_mul_epi32(a, b), 32); + __m256i a1X3X = _mm256_srli_epi64(a, 32); + __m256i mask = _mm256_set_epi32(-1, 0, -1, 0, -1, 0, -1, 0); + __m256i hi_product_Z1Z3 = _mm256_and_si256(_mm256_mul_epi32(a1X3X, b), mask); + return _mm256_or_si256(hi_product_0Z2Z, hi_product_Z1Z3); +} + +// Here, y is assumed to contain one 64-bit value repeated. +// https://stackoverflow.com/a/28827013 +static inline __m256i libdivide_mullhi_u64_vector(__m256i x, __m256i y) { + __m256i lomask = _mm256_set1_epi64x(0xffffffff); + __m256i xh = _mm256_shuffle_epi32(x, 0xB1); // x0l, x0h, x1l, x1h + __m256i yh = _mm256_shuffle_epi32(y, 0xB1); // y0l, y0h, y1l, y1h + __m256i w0 = _mm256_mul_epu32(x, y); // x0l*y0l, x1l*y1l + __m256i w1 = _mm256_mul_epu32(x, yh); // x0l*y0h, x1l*y1h + __m256i w2 = _mm256_mul_epu32(xh, y); // x0h*y0l, x1h*y0l + __m256i w3 = _mm256_mul_epu32(xh, yh); // x0h*y0h, x1h*y1h + __m256i w0h = _mm256_srli_epi64(w0, 32); + __m256i s1 = _mm256_add_epi64(w1, w0h); + __m256i s1l = _mm256_and_si256(s1, lomask); + __m256i s1h = _mm256_srli_epi64(s1, 32); + __m256i s2 = _mm256_add_epi64(w2, s1l); + __m256i s2h = _mm256_srli_epi64(s2, 32); + __m256i hi = _mm256_add_epi64(w3, s1h); + hi = _mm256_add_epi64(hi, s2h); + + return hi; +} + +// y is one 64-bit value repeated. +static inline __m256i libdivide_mullhi_s64_vector(__m256i x, __m256i y) { + __m256i p = libdivide_mullhi_u64_vector(x, y); + __m256i t1 = _mm256_and_si256(libdivide_s64_signbits(x), y); + __m256i t2 = _mm256_and_si256(libdivide_s64_signbits(y), x); + p = _mm256_sub_epi64(p, t1); + p = _mm256_sub_epi64(p, t2); + return p; +} + +////////// UINT32 + +__m256i libdivide_u32_do_vector(__m256i numers, const struct libdivide_u32_t *denom) { + uint8_t more = denom->more; + if (!denom->magic) { + return _mm256_srli_epi32(numers, more); + } + else { + __m256i q = libdivide_mullhi_u32_vector(numers, _mm256_set1_epi32(denom->magic)); + if (more & LIBDIVIDE_ADD_MARKER) { + // uint32_t t = ((numer - q) >> 1) + q; + // return t >> denom->shift; + uint32_t shift = more & LIBDIVIDE_32_SHIFT_MASK; + __m256i t = _mm256_add_epi32(_mm256_srli_epi32(_mm256_sub_epi32(numers, q), 1), q); + return _mm256_srli_epi32(t, shift); + } + else { + return _mm256_srli_epi32(q, more); + } + } +} + +__m256i libdivide_u32_branchfree_do_vector(__m256i numers, const struct libdivide_u32_branchfree_t *denom) { + __m256i q = libdivide_mullhi_u32_vector(numers, _mm256_set1_epi32(denom->magic)); + __m256i t = _mm256_add_epi32(_mm256_srli_epi32(_mm256_sub_epi32(numers, q), 1), q); + return _mm256_srli_epi32(t, denom->more); +} + +////////// UINT64 + +__m256i libdivide_u64_do_vector(__m256i numers, const struct libdivide_u64_t *denom) { + uint8_t more = denom->more; + if (!denom->magic) { + return _mm256_srli_epi64(numers, more); + } + else { + __m256i q = libdivide_mullhi_u64_vector(numers, _mm256_set1_epi64x(denom->magic)); + if (more & LIBDIVIDE_ADD_MARKER) { + // uint32_t t = ((numer - q) >> 1) + q; + // return t >> denom->shift; + uint32_t shift = more & LIBDIVIDE_64_SHIFT_MASK; + __m256i t = _mm256_add_epi64(_mm256_srli_epi64(_mm256_sub_epi64(numers, q), 1), q); + return _mm256_srli_epi64(t, shift); + } + else { + return _mm256_srli_epi64(q, more); + } + } +} + +__m256i libdivide_u64_branchfree_do_vector(__m256i numers, const struct libdivide_u64_branchfree_t *denom) { + __m256i q = libdivide_mullhi_u64_vector(numers, _mm256_set1_epi64x(denom->magic)); + __m256i t = _mm256_add_epi64(_mm256_srli_epi64(_mm256_sub_epi64(numers, q), 1), q); + return _mm256_srli_epi64(t, denom->more); +} + +////////// SINT32 + +__m256i libdivide_s32_do_vector(__m256i numers, const struct libdivide_s32_t *denom) { + uint8_t more = denom->more; + if (!denom->magic) { + uint32_t shift = more & LIBDIVIDE_32_SHIFT_MASK; + uint32_t mask = (1U << shift) - 1; + __m256i roundToZeroTweak = _mm256_set1_epi32(mask); + // q = numer + ((numer >> 31) & roundToZeroTweak); + __m256i q = _mm256_add_epi32(numers, _mm256_and_si256(_mm256_srai_epi32(numers, 31), roundToZeroTweak)); + q = _mm256_srai_epi32(q, shift); + __m256i sign = _mm256_set1_epi32((int8_t)more >> 7); + // q = (q ^ sign) - sign; + q = _mm256_sub_epi32(_mm256_xor_si256(q, sign), sign); + return q; + } + else { + __m256i q = libdivide_mullhi_s32_vector(numers, _mm256_set1_epi32(denom->magic)); + if (more & LIBDIVIDE_ADD_MARKER) { + // must be arithmetic shift + __m256i sign = _mm256_set1_epi32((int8_t)more >> 7); + // q += ((numer ^ sign) - sign); + q = _mm256_add_epi32(q, _mm256_sub_epi32(_mm256_xor_si256(numers, sign), sign)); + } + // q >>= shift + q = _mm256_srai_epi32(q, more & LIBDIVIDE_32_SHIFT_MASK); + q = _mm256_add_epi32(q, _mm256_srli_epi32(q, 31)); // q += (q < 0) + return q; + } +} + +__m256i libdivide_s32_branchfree_do_vector(__m256i numers, const struct libdivide_s32_branchfree_t *denom) { + int32_t magic = denom->magic; + uint8_t more = denom->more; + uint8_t shift = more & LIBDIVIDE_32_SHIFT_MASK; + // must be arithmetic shift + __m256i sign = _mm256_set1_epi32((int8_t)more >> 7); + __m256i q = libdivide_mullhi_s32_vector(numers, _mm256_set1_epi32(magic)); + q = _mm256_add_epi32(q, numers); // q += numers + + // If q is non-negative, we have nothing to do + // If q is negative, we want to add either (2**shift)-1 if d is + // a power of 2, or (2**shift) if it is not a power of 2 + uint32_t is_power_of_2 = (magic == 0); + __m256i q_sign = _mm256_srai_epi32(q, 31); // q_sign = q >> 31 + __m256i mask = _mm256_set1_epi32((1U << shift) - is_power_of_2); + q = _mm256_add_epi32(q, _mm256_and_si256(q_sign, mask)); // q = q + (q_sign & mask) + q = _mm256_srai_epi32(q, shift); // q >>= shift + q = _mm256_sub_epi32(_mm256_xor_si256(q, sign), sign); // q = (q ^ sign) - sign + return q; +} + +////////// SINT64 + +__m256i libdivide_s64_do_vector(__m256i numers, const struct libdivide_s64_t *denom) { + uint8_t more = denom->more; + int64_t magic = denom->magic; + if (magic == 0) { // shift path + uint32_t shift = more & LIBDIVIDE_64_SHIFT_MASK; + uint64_t mask = (1ULL << shift) - 1; + __m256i roundToZeroTweak = _mm256_set1_epi64x(mask); + // q = numer + ((numer >> 63) & roundToZeroTweak); + __m256i q = _mm256_add_epi64(numers, _mm256_and_si256(libdivide_s64_signbits(numers), roundToZeroTweak)); + q = libdivide_s64_shift_right_vector(q, shift); + __m256i sign = _mm256_set1_epi32((int8_t)more >> 7); + // q = (q ^ sign) - sign; + q = _mm256_sub_epi64(_mm256_xor_si256(q, sign), sign); + return q; + } + else { + __m256i q = libdivide_mullhi_s64_vector(numers, _mm256_set1_epi64x(magic)); + if (more & LIBDIVIDE_ADD_MARKER) { + // must be arithmetic shift + __m256i sign = _mm256_set1_epi32((int8_t)more >> 7); + // q += ((numer ^ sign) - sign); + q = _mm256_add_epi64(q, _mm256_sub_epi64(_mm256_xor_si256(numers, sign), sign)); + } + // q >>= denom->mult_path.shift + q = libdivide_s64_shift_right_vector(q, more & LIBDIVIDE_64_SHIFT_MASK); + q = _mm256_add_epi64(q, _mm256_srli_epi64(q, 63)); // q += (q < 0) + return q; + } +} + +__m256i libdivide_s64_branchfree_do_vector(__m256i numers, const struct libdivide_s64_branchfree_t *denom) { + int64_t magic = denom->magic; + uint8_t more = denom->more; + uint8_t shift = more & LIBDIVIDE_64_SHIFT_MASK; + // must be arithmetic shift + __m256i sign = _mm256_set1_epi32((int8_t)more >> 7); + + // libdivide_mullhi_s64(numers, magic); + __m256i q = libdivide_mullhi_s64_vector(numers, _mm256_set1_epi64x(magic)); + q = _mm256_add_epi64(q, numers); // q += numers + + // If q is non-negative, we have nothing to do. + // If q is negative, we want to add either (2**shift)-1 if d is + // a power of 2, or (2**shift) if it is not a power of 2. + uint32_t is_power_of_2 = (magic == 0); + __m256i q_sign = libdivide_s64_signbits(q); // q_sign = q >> 63 + __m256i mask = _mm256_set1_epi64x((1ULL << shift) - is_power_of_2); + q = _mm256_add_epi64(q, _mm256_and_si256(q_sign, mask)); // q = q + (q_sign & mask) + q = libdivide_s64_shift_right_vector(q, shift); // q >>= shift + q = _mm256_sub_epi64(_mm256_xor_si256(q, sign), sign); // q = (q ^ sign) - sign + return q; +} + +#elif defined(LIBDIVIDE_SSE2) + +static inline __m128i libdivide_u32_do_vector(__m128i numers, const struct libdivide_u32_t *denom); +static inline __m128i libdivide_s32_do_vector(__m128i numers, const struct libdivide_s32_t *denom); +static inline __m128i libdivide_u64_do_vector(__m128i numers, const struct libdivide_u64_t *denom); +static inline __m128i libdivide_s64_do_vector(__m128i numers, const struct libdivide_s64_t *denom); + +static inline __m128i libdivide_u32_branchfree_do_vector(__m128i numers, const struct libdivide_u32_branchfree_t *denom); +static inline __m128i libdivide_s32_branchfree_do_vector(__m128i numers, const struct libdivide_s32_branchfree_t *denom); +static inline __m128i libdivide_u64_branchfree_do_vector(__m128i numers, const struct libdivide_u64_branchfree_t *denom); +static inline __m128i libdivide_s64_branchfree_do_vector(__m128i numers, const struct libdivide_s64_branchfree_t *denom); + +//////// Internal Utility Functions + +// Implementation of _mm_srai_epi64(v, 63) (from AVX512). +static inline __m128i libdivide_s64_signbits(__m128i v) { + __m128i hiBitsDuped = _mm_shuffle_epi32(v, _MM_SHUFFLE(3, 3, 1, 1)); + __m128i signBits = _mm_srai_epi32(hiBitsDuped, 31); + return signBits; +} + +// Implementation of _mm_srai_epi64 (from AVX512). +static inline __m128i libdivide_s64_shift_right_vector(__m128i v, int amt) { + const int b = 64 - amt; + __m128i m = _mm_set1_epi64x(1ULL << (b - 1)); + __m128i x = _mm_srli_epi64(v, amt); + __m128i result = _mm_sub_epi64(_mm_xor_si128(x, m), m); + return result; +} + +// Here, b is assumed to contain one 32-bit value repeated. +static inline __m128i libdivide_mullhi_u32_vector(__m128i a, __m128i b) { + __m128i hi_product_0Z2Z = _mm_srli_epi64(_mm_mul_epu32(a, b), 32); + __m128i a1X3X = _mm_srli_epi64(a, 32); + __m128i mask = _mm_set_epi32(-1, 0, -1, 0); + __m128i hi_product_Z1Z3 = _mm_and_si128(_mm_mul_epu32(a1X3X, b), mask); + return _mm_or_si128(hi_product_0Z2Z, hi_product_Z1Z3); +} + +// SSE2 does not have a signed multiplication instruction, but we can convert +// unsigned to signed pretty efficiently. Again, b is just a 32 bit value +// repeated four times. +static inline __m128i libdivide_mullhi_s32_vector(__m128i a, __m128i b) { + __m128i p = libdivide_mullhi_u32_vector(a, b); + // t1 = (a >> 31) & y, arithmetic shift + __m128i t1 = _mm_and_si128(_mm_srai_epi32(a, 31), b); + __m128i t2 = _mm_and_si128(_mm_srai_epi32(b, 31), a); + p = _mm_sub_epi32(p, t1); + p = _mm_sub_epi32(p, t2); + return p; +} + +// Here, y is assumed to contain one 64-bit value repeated. +// https://stackoverflow.com/a/28827013 +static inline __m128i libdivide_mullhi_u64_vector(__m128i x, __m128i y) { + __m128i lomask = _mm_set1_epi64x(0xffffffff); + __m128i xh = _mm_shuffle_epi32(x, 0xB1); // x0l, x0h, x1l, x1h + __m128i yh = _mm_shuffle_epi32(y, 0xB1); // y0l, y0h, y1l, y1h + __m128i w0 = _mm_mul_epu32(x, y); // x0l*y0l, x1l*y1l + __m128i w1 = _mm_mul_epu32(x, yh); // x0l*y0h, x1l*y1h + __m128i w2 = _mm_mul_epu32(xh, y); // x0h*y0l, x1h*y0l + __m128i w3 = _mm_mul_epu32(xh, yh); // x0h*y0h, x1h*y1h + __m128i w0h = _mm_srli_epi64(w0, 32); + __m128i s1 = _mm_add_epi64(w1, w0h); + __m128i s1l = _mm_and_si128(s1, lomask); + __m128i s1h = _mm_srli_epi64(s1, 32); + __m128i s2 = _mm_add_epi64(w2, s1l); + __m128i s2h = _mm_srli_epi64(s2, 32); + __m128i hi = _mm_add_epi64(w3, s1h); + hi = _mm_add_epi64(hi, s2h); + + return hi; +} + +// y is one 64-bit value repeated. +static inline __m128i libdivide_mullhi_s64_vector(__m128i x, __m128i y) { + __m128i p = libdivide_mullhi_u64_vector(x, y); + __m128i t1 = _mm_and_si128(libdivide_s64_signbits(x), y); + __m128i t2 = _mm_and_si128(libdivide_s64_signbits(y), x); + p = _mm_sub_epi64(p, t1); + p = _mm_sub_epi64(p, t2); + return p; +} + +////////// UINT32 + +__m128i libdivide_u32_do_vector(__m128i numers, const struct libdivide_u32_t *denom) { + uint8_t more = denom->more; + if (!denom->magic) { + return _mm_srli_epi32(numers, more); + } + else { + __m128i q = libdivide_mullhi_u32_vector(numers, _mm_set1_epi32(denom->magic)); + if (more & LIBDIVIDE_ADD_MARKER) { + // uint32_t t = ((numer - q) >> 1) + q; + // return t >> denom->shift; + uint32_t shift = more & LIBDIVIDE_32_SHIFT_MASK; + __m128i t = _mm_add_epi32(_mm_srli_epi32(_mm_sub_epi32(numers, q), 1), q); + return _mm_srli_epi32(t, shift); + } + else { + return _mm_srli_epi32(q, more); + } + } +} + +__m128i libdivide_u32_branchfree_do_vector(__m128i numers, const struct libdivide_u32_branchfree_t *denom) { + __m128i q = libdivide_mullhi_u32_vector(numers, _mm_set1_epi32(denom->magic)); + __m128i t = _mm_add_epi32(_mm_srli_epi32(_mm_sub_epi32(numers, q), 1), q); + return _mm_srli_epi32(t, denom->more); +} + +////////// UINT64 + +__m128i libdivide_u64_do_vector(__m128i numers, const struct libdivide_u64_t *denom) { + uint8_t more = denom->more; + if (!denom->magic) { + return _mm_srli_epi64(numers, more); + } + else { + __m128i q = libdivide_mullhi_u64_vector(numers, _mm_set1_epi64x(denom->magic)); + if (more & LIBDIVIDE_ADD_MARKER) { + // uint32_t t = ((numer - q) >> 1) + q; + // return t >> denom->shift; + uint32_t shift = more & LIBDIVIDE_64_SHIFT_MASK; + __m128i t = _mm_add_epi64(_mm_srli_epi64(_mm_sub_epi64(numers, q), 1), q); + return _mm_srli_epi64(t, shift); + } + else { + return _mm_srli_epi64(q, more); + } + } +} + +__m128i libdivide_u64_branchfree_do_vector(__m128i numers, const struct libdivide_u64_branchfree_t *denom) { + __m128i q = libdivide_mullhi_u64_vector(numers, _mm_set1_epi64x(denom->magic)); + __m128i t = _mm_add_epi64(_mm_srli_epi64(_mm_sub_epi64(numers, q), 1), q); + return _mm_srli_epi64(t, denom->more); +} + +////////// SINT32 + +__m128i libdivide_s32_do_vector(__m128i numers, const struct libdivide_s32_t *denom) { + uint8_t more = denom->more; + if (!denom->magic) { + uint32_t shift = more & LIBDIVIDE_32_SHIFT_MASK; + uint32_t mask = (1U << shift) - 1; + __m128i roundToZeroTweak = _mm_set1_epi32(mask); + // q = numer + ((numer >> 31) & roundToZeroTweak); + __m128i q = _mm_add_epi32(numers, _mm_and_si128(_mm_srai_epi32(numers, 31), roundToZeroTweak)); + q = _mm_srai_epi32(q, shift); + __m128i sign = _mm_set1_epi32((int8_t)more >> 7); + // q = (q ^ sign) - sign; + q = _mm_sub_epi32(_mm_xor_si128(q, sign), sign); + return q; + } + else { + __m128i q = libdivide_mullhi_s32_vector(numers, _mm_set1_epi32(denom->magic)); + if (more & LIBDIVIDE_ADD_MARKER) { + // must be arithmetic shift + __m128i sign = _mm_set1_epi32((int8_t)more >> 7); + // q += ((numer ^ sign) - sign); + q = _mm_add_epi32(q, _mm_sub_epi32(_mm_xor_si128(numers, sign), sign)); + } + // q >>= shift + q = _mm_srai_epi32(q, more & LIBDIVIDE_32_SHIFT_MASK); + q = _mm_add_epi32(q, _mm_srli_epi32(q, 31)); // q += (q < 0) + return q; + } +} + +__m128i libdivide_s32_branchfree_do_vector(__m128i numers, const struct libdivide_s32_branchfree_t *denom) { + int32_t magic = denom->magic; + uint8_t more = denom->more; + uint8_t shift = more & LIBDIVIDE_32_SHIFT_MASK; + // must be arithmetic shift + __m128i sign = _mm_set1_epi32((int8_t)more >> 7); + __m128i q = libdivide_mullhi_s32_vector(numers, _mm_set1_epi32(magic)); + q = _mm_add_epi32(q, numers); // q += numers + + // If q is non-negative, we have nothing to do + // If q is negative, we want to add either (2**shift)-1 if d is + // a power of 2, or (2**shift) if it is not a power of 2 + uint32_t is_power_of_2 = (magic == 0); + __m128i q_sign = _mm_srai_epi32(q, 31); // q_sign = q >> 31 + __m128i mask = _mm_set1_epi32((1U << shift) - is_power_of_2); + q = _mm_add_epi32(q, _mm_and_si128(q_sign, mask)); // q = q + (q_sign & mask) + q = _mm_srai_epi32(q, shift); // q >>= shift + q = _mm_sub_epi32(_mm_xor_si128(q, sign), sign); // q = (q ^ sign) - sign + return q; +} + +////////// SINT64 + +__m128i libdivide_s64_do_vector(__m128i numers, const struct libdivide_s64_t *denom) { + uint8_t more = denom->more; + int64_t magic = denom->magic; + if (magic == 0) { // shift path + uint32_t shift = more & LIBDIVIDE_64_SHIFT_MASK; + uint64_t mask = (1ULL << shift) - 1; + __m128i roundToZeroTweak = _mm_set1_epi64x(mask); + // q = numer + ((numer >> 63) & roundToZeroTweak); + __m128i q = _mm_add_epi64(numers, _mm_and_si128(libdivide_s64_signbits(numers), roundToZeroTweak)); + q = libdivide_s64_shift_right_vector(q, shift); + __m128i sign = _mm_set1_epi32((int8_t)more >> 7); + // q = (q ^ sign) - sign; + q = _mm_sub_epi64(_mm_xor_si128(q, sign), sign); + return q; + } + else { + __m128i q = libdivide_mullhi_s64_vector(numers, _mm_set1_epi64x(magic)); + if (more & LIBDIVIDE_ADD_MARKER) { + // must be arithmetic shift + __m128i sign = _mm_set1_epi32((int8_t)more >> 7); + // q += ((numer ^ sign) - sign); + q = _mm_add_epi64(q, _mm_sub_epi64(_mm_xor_si128(numers, sign), sign)); + } + // q >>= denom->mult_path.shift + q = libdivide_s64_shift_right_vector(q, more & LIBDIVIDE_64_SHIFT_MASK); + q = _mm_add_epi64(q, _mm_srli_epi64(q, 63)); // q += (q < 0) + return q; + } +} + +__m128i libdivide_s64_branchfree_do_vector(__m128i numers, const struct libdivide_s64_branchfree_t *denom) { + int64_t magic = denom->magic; + uint8_t more = denom->more; + uint8_t shift = more & LIBDIVIDE_64_SHIFT_MASK; + // must be arithmetic shift + __m128i sign = _mm_set1_epi32((int8_t)more >> 7); + + // libdivide_mullhi_s64(numers, magic); + __m128i q = libdivide_mullhi_s64_vector(numers, _mm_set1_epi64x(magic)); + q = _mm_add_epi64(q, numers); // q += numers + + // If q is non-negative, we have nothing to do. + // If q is negative, we want to add either (2**shift)-1 if d is + // a power of 2, or (2**shift) if it is not a power of 2. + uint32_t is_power_of_2 = (magic == 0); + __m128i q_sign = libdivide_s64_signbits(q); // q_sign = q >> 63 + __m128i mask = _mm_set1_epi64x((1ULL << shift) - is_power_of_2); + q = _mm_add_epi64(q, _mm_and_si128(q_sign, mask)); // q = q + (q_sign & mask) + q = libdivide_s64_shift_right_vector(q, shift); // q >>= shift + q = _mm_sub_epi64(_mm_xor_si128(q, sign), sign); // q = (q ^ sign) - sign + return q; +} + +#endif + +/////////// C++ stuff + +#ifdef __cplusplus + +// The C++ divider class is templated on both an integer type +// (like uint64_t) and an algorithm type. +// * BRANCHFULL is the default algorithm type. +// * BRANCHFREE is the branchfree algorithm type. +enum { + BRANCHFULL, + BRANCHFREE +}; + +#if defined(LIBDIVIDE_AVX512) + #define LIBDIVIDE_VECTOR_TYPE __m512i +#elif defined(LIBDIVIDE_AVX2) + #define LIBDIVIDE_VECTOR_TYPE __m256i +#elif defined(LIBDIVIDE_SSE2) + #define LIBDIVIDE_VECTOR_TYPE __m128i +#endif + +#if !defined(LIBDIVIDE_VECTOR_TYPE) + #define LIBDIVIDE_DIVIDE_VECTOR(ALGO) +#else + #define LIBDIVIDE_DIVIDE_VECTOR(ALGO) \ + LIBDIVIDE_VECTOR_TYPE divide(LIBDIVIDE_VECTOR_TYPE n) const { \ + return libdivide_##ALGO##_do_vector(n, &denom); \ + } +#endif + +// The DISPATCHER_GEN() macro generates C++ methods (for the given integer +// and algorithm types) that redirect to libdivide's C API. +#define DISPATCHER_GEN(T, ALGO) \ + libdivide_##ALGO##_t denom; \ + dispatcher() { } \ + dispatcher(T d) \ + : denom(libdivide_##ALGO##_gen(d)) \ + { } \ + T divide(T n) const { \ + return libdivide_##ALGO##_do(n, &denom); \ + } \ + LIBDIVIDE_DIVIDE_VECTOR(ALGO) \ + T recover() const { \ + return libdivide_##ALGO##_recover(&denom); \ + } + +// The dispatcher selects a specific division algorithm for a given +// type and ALGO using partial template specialization. +template struct dispatcher { }; + +template<> struct dispatcher { DISPATCHER_GEN(int32_t, s32) }; +template<> struct dispatcher { DISPATCHER_GEN(int32_t, s32_branchfree) }; +template<> struct dispatcher { DISPATCHER_GEN(uint32_t, u32) }; +template<> struct dispatcher { DISPATCHER_GEN(uint32_t, u32_branchfree) }; +template<> struct dispatcher { DISPATCHER_GEN(int64_t, s64) }; +template<> struct dispatcher { DISPATCHER_GEN(int64_t, s64_branchfree) }; +template<> struct dispatcher { DISPATCHER_GEN(uint64_t, u64) }; +template<> struct dispatcher { DISPATCHER_GEN(uint64_t, u64_branchfree) }; + +// This is the main divider class for use by the user (C++ API). +// The actual division algorithm is selected using the dispatcher struct +// based on the integer and algorithm template parameters. +template +class divider { +public: + // We leave the default constructor empty so that creating + // an array of dividers and then initializing them + // later doesn't slow us down. + divider() { } + + // Constructor that takes the divisor as a parameter + divider(T d) : div(d) { } + + // Divides n by the divisor + T divide(T n) const { + return div.divide(n); + } + + // Recovers the divisor, returns the value that was + // used to initialize this divider object. + T recover() const { + return div.recover(); + } + + bool operator==(const divider& other) const { + return div.denom.magic == other.denom.magic && + div.denom.more == other.denom.more; + } + + bool operator!=(const divider& other) const { + return !(*this == other); + } + +#if defined(LIBDIVIDE_VECTOR_TYPE) + // Treats the vector as packed integer values with the same type as + // the divider (e.g. s32, u32, s64, u64) and divides each of + // them by the divider, returning the packed quotients. + LIBDIVIDE_VECTOR_TYPE divide(LIBDIVIDE_VECTOR_TYPE n) const { + return div.divide(n); + } +#endif + +private: + // Storage for the actual divisor + dispatcher::value, + std::is_signed::value, sizeof(T), ALGO> div; +}; + +// Overload of operator / for scalar division +template +T operator/(T n, const divider& div) { + return div.divide(n); +} + +// Overload of operator /= for scalar division +template +T& operator/=(T& n, const divider& div) { + n = div.divide(n); + return n; +} + +#if defined(LIBDIVIDE_VECTOR_TYPE) + // Overload of operator / for vector division + template + LIBDIVIDE_VECTOR_TYPE operator/(LIBDIVIDE_VECTOR_TYPE n, const divider& div) { + return div.divide(n); + } + // Overload of operator /= for vector division + template + LIBDIVIDE_VECTOR_TYPE& operator/=(LIBDIVIDE_VECTOR_TYPE& n, const divider& div) { + n = div.divide(n); + return n; + } +#endif + +// libdivdie::branchfree_divider +template +using branchfree_divider = divider; + +} // namespace libdivide + +#endif // __cplusplus + +#endif // NUMPY_CORE_INCLUDE_NUMPY_LIBDIVIDE_LIBDIVIDE_H_ diff --git a/venv/lib/python3.12/site-packages/numpy/_core/include/numpy/ufuncobject.h b/venv/lib/python3.12/site-packages/numpy/_core/include/numpy/ufuncobject.h new file mode 100644 index 00000000..ada23626 --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/include/numpy/ufuncobject.h @@ -0,0 +1,345 @@ +#ifndef NUMPY_CORE_INCLUDE_NUMPY_UFUNCOBJECT_H_ +#define NUMPY_CORE_INCLUDE_NUMPY_UFUNCOBJECT_H_ + +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* + * The legacy generic inner loop for a standard element-wise or + * generalized ufunc. + */ +typedef void (*PyUFuncGenericFunction) + (char **args, + npy_intp const *dimensions, + npy_intp const *strides, + void *innerloopdata); + +/* + * The most generic one-dimensional inner loop for + * a masked standard element-wise ufunc. "Masked" here means that it skips + * doing calculations on any items for which the maskptr array has a true + * value. + */ +typedef void (PyUFunc_MaskedStridedInnerLoopFunc)( + char **dataptrs, npy_intp *strides, + char *maskptr, npy_intp mask_stride, + npy_intp count, + NpyAuxData *innerloopdata); + +/* Forward declaration for the type resolver and loop selector typedefs */ +struct _tagPyUFuncObject; + +/* + * Given the operands for calling a ufunc, should determine the + * calculation input and output data types and return an inner loop function. + * This function should validate that the casting rule is being followed, + * and fail if it is not. + * + * For backwards compatibility, the regular type resolution function does not + * support auxiliary data with object semantics. The type resolution call + * which returns a masked generic function returns a standard NpyAuxData + * object, for which the NPY_AUXDATA_FREE and NPY_AUXDATA_CLONE macros + * work. + * + * ufunc: The ufunc object. + * casting: The 'casting' parameter provided to the ufunc. + * operands: An array of length (ufunc->nin + ufunc->nout), + * with the output parameters possibly NULL. + * type_tup: Either NULL, or the type_tup passed to the ufunc. + * out_dtypes: An array which should be populated with new + * references to (ufunc->nin + ufunc->nout) new + * dtypes, one for each input and output. These + * dtypes should all be in native-endian format. + * + * Should return 0 on success, -1 on failure (with exception set), + * or -2 if Py_NotImplemented should be returned. + */ +typedef int (PyUFunc_TypeResolutionFunc)( + struct _tagPyUFuncObject *ufunc, + NPY_CASTING casting, + PyArrayObject **operands, + PyObject *type_tup, + PyArray_Descr **out_dtypes); + +/* + * This is the signature for the functions that may be assigned to the + * `process_core_dims_func` field of the PyUFuncObject structure. + * Implementation of this function is optional. This function is only used + * by generalized ufuncs (i.e. those with the field `core_enabled` set to 1). + * The function is called by the ufunc during the processing of the arguments + * of a call of the ufunc. The function can check the core dimensions of the + * input and output arrays and return -1 with an exception set if any + * requirements are not satisfied. If the caller of the ufunc didn't provide + * output arrays, the core dimensions associated with the output arrays (i.e. + * those that are not also used in input arrays) will have the value -1 in + * `core_dim_sizes`. This function can replace any output core dimensions + * that are -1 with a value that is appropriate for the ufunc. + * + * Parameter Description + * --------------- ------------------------------------------------------ + * ufunc The ufunc object + * core_dim_sizes An array with length `ufunc->core_num_dim_ix`. + * The core dimensions of the arrays passed to the ufunc + * will have been set. If the caller of the ufunc didn't + * provide the output array(s), the output-only core + * dimensions will have the value -1. + * + * The function must not change any element in `core_dim_sizes` that is + * not -1 on input. Doing so will result in incorrect output from the + * ufunc, and could result in a crash of the Python interpreter. + * + * The function must return 0 on success, -1 on failure (with an exception + * set). + */ +typedef int (PyUFunc_ProcessCoreDimsFunc)( + struct _tagPyUFuncObject *ufunc, + npy_intp *core_dim_sizes); + +typedef struct _tagPyUFuncObject { + PyObject_HEAD + /* + * nin: Number of inputs + * nout: Number of outputs + * nargs: Always nin + nout (Why is it stored?) + */ + int nin, nout, nargs; + + /* + * Identity for reduction, any of PyUFunc_One, PyUFunc_Zero + * PyUFunc_MinusOne, PyUFunc_None, PyUFunc_ReorderableNone, + * PyUFunc_IdentityValue. + */ + int identity; + + /* Array of one-dimensional core loops */ + PyUFuncGenericFunction *functions; + /* Array of funcdata that gets passed into the functions */ + void *const *data; + /* The number of elements in 'functions' and 'data' */ + int ntypes; + + /* Used to be unused field 'check_return' */ + int reserved1; + + /* The name of the ufunc */ + const char *name; + + /* Array of type numbers, of size ('nargs' * 'ntypes') */ + const char *types; + + /* Documentation string */ + const char *doc; + + void *ptr; + PyObject *obj; + PyObject *userloops; + + /* generalized ufunc parameters */ + + /* 0 for scalar ufunc; 1 for generalized ufunc */ + int core_enabled; + /* number of distinct dimension names in signature */ + int core_num_dim_ix; + + /* + * dimension indices of input/output argument k are stored in + * core_dim_ixs[core_offsets[k]..core_offsets[k]+core_num_dims[k]-1] + */ + + /* numbers of core dimensions of each argument */ + int *core_num_dims; + /* + * dimension indices in a flatted form; indices + * are in the range of [0,core_num_dim_ix) + */ + int *core_dim_ixs; + /* + * positions of 1st core dimensions of each + * argument in core_dim_ixs, equivalent to cumsum(core_num_dims) + */ + int *core_offsets; + /* signature string for printing purpose */ + char *core_signature; + + /* + * A function which resolves the types and fills an array + * with the dtypes for the inputs and outputs. + */ + PyUFunc_TypeResolutionFunc *type_resolver; + /* Was the legacy loop resolver */ + void *reserved2; + /* + * This was blocked off to be the "new" inner loop selector in 1.7, + * but this was never implemented. (This is also why the above + * selector is called the "legacy" selector.) + */ + #ifndef Py_LIMITED_API + vectorcallfunc vectorcall; + #else + void *vectorcall; + #endif + + /* Was previously the `PyUFunc_MaskedInnerLoopSelectionFunc` */ + void *reserved3; + + /* + * List of flags for each operand when ufunc is called by nditer object. + * These flags will be used in addition to the default flags for each + * operand set by nditer object. + */ + npy_uint32 *op_flags; + + /* + * List of global flags used when ufunc is called by nditer object. + * These flags will be used in addition to the default global flags + * set by nditer object. + */ + npy_uint32 iter_flags; + + /* New in NPY_API_VERSION 0x0000000D and above */ + #if NPY_FEATURE_VERSION >= NPY_1_16_API_VERSION + /* + * for each core_num_dim_ix distinct dimension names, + * the possible "frozen" size (-1 if not frozen). + */ + npy_intp *core_dim_sizes; + + /* + * for each distinct core dimension, a set of UFUNC_CORE_DIM* flags + */ + npy_uint32 *core_dim_flags; + + /* Identity for reduction, when identity == PyUFunc_IdentityValue */ + PyObject *identity_value; + #endif /* NPY_FEATURE_VERSION >= NPY_1_16_API_VERSION */ + + /* New in NPY_API_VERSION 0x0000000F and above */ + #if NPY_FEATURE_VERSION >= NPY_1_22_API_VERSION + /* New private fields related to dispatching */ + void *_dispatch_cache; + /* A PyListObject of `(tuple of DTypes, ArrayMethod/Promoter)` */ + PyObject *_loops; + #endif + #if NPY_FEATURE_VERSION >= NPY_2_1_API_VERSION + /* + * Optional function to process core dimensions of a gufunc. + */ + PyUFunc_ProcessCoreDimsFunc *process_core_dims_func; + #endif +} PyUFuncObject; + +#include "arrayobject.h" +/* Generalized ufunc; 0x0001 reserved for possible use as CORE_ENABLED */ +/* the core dimension's size will be determined by the operands. */ +#define UFUNC_CORE_DIM_SIZE_INFERRED 0x0002 +/* the core dimension may be absent */ +#define UFUNC_CORE_DIM_CAN_IGNORE 0x0004 +/* flags inferred during execution */ +#define UFUNC_CORE_DIM_MISSING 0x00040000 + + +#define UFUNC_OBJ_ISOBJECT 1 +#define UFUNC_OBJ_NEEDS_API 2 + + +#if NPY_ALLOW_THREADS +#define NPY_LOOP_BEGIN_THREADS do {if (!(loop->obj & UFUNC_OBJ_NEEDS_API)) _save = PyEval_SaveThread();} while (0); +#define NPY_LOOP_END_THREADS do {if (!(loop->obj & UFUNC_OBJ_NEEDS_API)) PyEval_RestoreThread(_save);} while (0); +#else +#define NPY_LOOP_BEGIN_THREADS +#define NPY_LOOP_END_THREADS +#endif + +/* + * UFunc has unit of 0, and the order of operations can be reordered + * This case allows reduction with multiple axes at once. + */ +#define PyUFunc_Zero 0 +/* + * UFunc has unit of 1, and the order of operations can be reordered + * This case allows reduction with multiple axes at once. + */ +#define PyUFunc_One 1 +/* + * UFunc has unit of -1, and the order of operations can be reordered + * This case allows reduction with multiple axes at once. Intended for + * bitwise_and reduction. + */ +#define PyUFunc_MinusOne 2 +/* + * UFunc has no unit, and the order of operations cannot be reordered. + * This case does not allow reduction with multiple axes at once. + */ +#define PyUFunc_None -1 +/* + * UFunc has no unit, and the order of operations can be reordered + * This case allows reduction with multiple axes at once. + */ +#define PyUFunc_ReorderableNone -2 +/* + * UFunc unit is an identity_value, and the order of operations can be reordered + * This case allows reduction with multiple axes at once. + */ +#define PyUFunc_IdentityValue -3 + + +#define UFUNC_REDUCE 0 +#define UFUNC_ACCUMULATE 1 +#define UFUNC_REDUCEAT 2 +#define UFUNC_OUTER 3 + + +typedef struct { + int nin; + int nout; + PyObject *callable; +} PyUFunc_PyFuncData; + +/* A linked-list of function information for + user-defined 1-d loops. + */ +typedef struct _loop1d_info { + PyUFuncGenericFunction func; + void *data; + int *arg_types; + struct _loop1d_info *next; + int nargs; + PyArray_Descr **arg_dtypes; +} PyUFunc_Loop1d; + + +#define UFUNC_PYVALS_NAME "UFUNC_PYVALS" + +/* + * THESE MACROS ARE DEPRECATED. + * Use npy_set_floatstatus_* in the npymath library. + */ +#define UFUNC_FPE_DIVIDEBYZERO NPY_FPE_DIVIDEBYZERO +#define UFUNC_FPE_OVERFLOW NPY_FPE_OVERFLOW +#define UFUNC_FPE_UNDERFLOW NPY_FPE_UNDERFLOW +#define UFUNC_FPE_INVALID NPY_FPE_INVALID + +#define generate_divbyzero_error() npy_set_floatstatus_divbyzero() +#define generate_overflow_error() npy_set_floatstatus_overflow() + + /* Make sure it gets defined if it isn't already */ +#ifndef UFUNC_NOFPE +/* Clear the floating point exception default of Borland C++ */ +#if defined(__BORLANDC__) +#define UFUNC_NOFPE _control87(MCW_EM, MCW_EM); +#else +#define UFUNC_NOFPE +#endif +#endif + +#include "__ufunc_api.h" + +#ifdef __cplusplus +} +#endif + +#endif /* NUMPY_CORE_INCLUDE_NUMPY_UFUNCOBJECT_H_ */ diff --git a/venv/lib/python3.12/site-packages/numpy/_core/include/numpy/utils.h b/venv/lib/python3.12/site-packages/numpy/_core/include/numpy/utils.h new file mode 100644 index 00000000..97f06092 --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/include/numpy/utils.h @@ -0,0 +1,37 @@ +#ifndef NUMPY_CORE_INCLUDE_NUMPY_UTILS_H_ +#define NUMPY_CORE_INCLUDE_NUMPY_UTILS_H_ + +#ifndef __COMP_NPY_UNUSED + #if defined(__GNUC__) + #define __COMP_NPY_UNUSED __attribute__ ((__unused__)) + #elif defined(__ICC) + #define __COMP_NPY_UNUSED __attribute__ ((__unused__)) + #elif defined(__clang__) + #define __COMP_NPY_UNUSED __attribute__ ((unused)) + #else + #define __COMP_NPY_UNUSED + #endif +#endif + +#if defined(__GNUC__) || defined(__ICC) || defined(__clang__) + #define NPY_DECL_ALIGNED(x) __attribute__ ((aligned (x))) +#elif defined(_MSC_VER) + #define NPY_DECL_ALIGNED(x) __declspec(align(x)) +#else + #define NPY_DECL_ALIGNED(x) +#endif + +/* Use this to tag a variable as not used. It will remove unused variable + * warning on support platforms (see __COM_NPY_UNUSED) and mangle the variable + * to avoid accidental use */ +#define NPY_UNUSED(x) __NPY_UNUSED_TAGGED ## x __COMP_NPY_UNUSED +#define NPY_EXPAND(x) x + +#define NPY_STRINGIFY(x) #x +#define NPY_TOSTRING(x) NPY_STRINGIFY(x) + +#define NPY_CAT__(a, b) a ## b +#define NPY_CAT_(a, b) NPY_CAT__(a, b) +#define NPY_CAT(a, b) NPY_CAT_(a, b) + +#endif /* NUMPY_CORE_INCLUDE_NUMPY_UTILS_H_ */ diff --git a/venv/lib/python3.12/site-packages/numpy/_core/lib/libnpymath.a b/venv/lib/python3.12/site-packages/numpy/_core/lib/libnpymath.a new file mode 100644 index 00000000..bcea1da0 Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/_core/lib/libnpymath.a differ diff --git a/venv/lib/python3.12/site-packages/numpy/_core/lib/npy-pkg-config/mlib.ini b/venv/lib/python3.12/site-packages/numpy/_core/lib/npy-pkg-config/mlib.ini new file mode 100644 index 00000000..5840f5e1 --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/lib/npy-pkg-config/mlib.ini @@ -0,0 +1,12 @@ +[meta] +Name = mlib +Description = Math library used with this version of numpy +Version = 1.0 + +[default] +Libs=-lm +Cflags= + +[msvc] +Libs=m.lib +Cflags= diff --git a/venv/lib/python3.12/site-packages/numpy/_core/lib/npy-pkg-config/npymath.ini b/venv/lib/python3.12/site-packages/numpy/_core/lib/npy-pkg-config/npymath.ini new file mode 100644 index 00000000..8d879e3f --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/lib/npy-pkg-config/npymath.ini @@ -0,0 +1,20 @@ +[meta] +Name=npymath +Description=Portable, core math library implementing C99 standard +Version=0.1 + +[variables] +pkgname=numpy._core +prefix=${pkgdir} +libdir=${prefix}/lib +includedir=${prefix}/include + +[default] +Libs=-L${libdir} -lnpymath +Cflags=-I${includedir} +Requires=mlib + +[msvc] +Libs=/LIBPATH:${libdir} npymath.lib +Cflags=/INCLUDE:${includedir} +Requires=mlib diff --git a/venv/lib/python3.12/site-packages/numpy/_core/lib/pkgconfig/numpy.pc b/venv/lib/python3.12/site-packages/numpy/_core/lib/pkgconfig/numpy.pc new file mode 100644 index 00000000..4519b05c --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/lib/pkgconfig/numpy.pc @@ -0,0 +1,7 @@ +prefix=${pcfiledir}/../.. +includedir=${prefix}/include + +Name: numpy +Description: NumPy is the fundamental package for scientific computing with Python. +Version: 2.1.3 +Cflags: -I${includedir} diff --git a/venv/lib/python3.12/site-packages/numpy/_core/memmap.py b/venv/lib/python3.12/site-packages/numpy/_core/memmap.py new file mode 100644 index 00000000..268b23db --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/memmap.py @@ -0,0 +1,352 @@ +from contextlib import nullcontext +import operator +import numpy as np +from .._utils import set_module +from .numeric import uint8, ndarray, dtype + +__all__ = ['memmap'] + +dtypedescr = dtype +valid_filemodes = ["r", "c", "r+", "w+"] +writeable_filemodes = ["r+", "w+"] + +mode_equivalents = { + "readonly":"r", + "copyonwrite":"c", + "readwrite":"r+", + "write":"w+" + } + + +@set_module('numpy') +class memmap(ndarray): + """Create a memory-map to an array stored in a *binary* file on disk. + + Memory-mapped files are used for accessing small segments of large files + on disk, without reading the entire file into memory. NumPy's + memmap's are array-like objects. This differs from Python's ``mmap`` + module, which uses file-like objects. + + This subclass of ndarray has some unpleasant interactions with + some operations, because it doesn't quite fit properly as a subclass. + An alternative to using this subclass is to create the ``mmap`` + object yourself, then create an ndarray with ndarray.__new__ directly, + passing the object created in its 'buffer=' parameter. + + This class may at some point be turned into a factory function + which returns a view into an mmap buffer. + + Flush the memmap instance to write the changes to the file. Currently there + is no API to close the underlying ``mmap``. It is tricky to ensure the + resource is actually closed, since it may be shared between different + memmap instances. + + + Parameters + ---------- + filename : str, file-like object, or pathlib.Path instance + The file name or file object to be used as the array data buffer. + dtype : data-type, optional + The data-type used to interpret the file contents. + Default is `uint8`. + mode : {'r+', 'r', 'w+', 'c'}, optional + The file is opened in this mode: + + +------+-------------------------------------------------------------+ + | 'r' | Open existing file for reading only. | + +------+-------------------------------------------------------------+ + | 'r+' | Open existing file for reading and writing. | + +------+-------------------------------------------------------------+ + | 'w+' | Create or overwrite existing file for reading and writing. | + | | If ``mode == 'w+'`` then `shape` must also be specified. | + +------+-------------------------------------------------------------+ + | 'c' | Copy-on-write: assignments affect data in memory, but | + | | changes are not saved to disk. The file on disk is | + | | read-only. | + +------+-------------------------------------------------------------+ + + Default is 'r+'. + offset : int, optional + In the file, array data starts at this offset. Since `offset` is + measured in bytes, it should normally be a multiple of the byte-size + of `dtype`. When ``mode != 'r'``, even positive offsets beyond end of + file are valid; The file will be extended to accommodate the + additional data. By default, ``memmap`` will start at the beginning of + the file, even if ``filename`` is a file pointer ``fp`` and + ``fp.tell() != 0``. + shape : int or sequence of ints, optional + The desired shape of the array. If ``mode == 'r'`` and the number + of remaining bytes after `offset` is not a multiple of the byte-size + of `dtype`, you must specify `shape`. By default, the returned array + will be 1-D with the number of elements determined by file size + and data-type. + + .. versionchanged:: 2.0 + The shape parameter can now be any integer sequence type, previously + types were limited to tuple and int. + + order : {'C', 'F'}, optional + Specify the order of the ndarray memory layout: + :term:`row-major`, C-style or :term:`column-major`, + Fortran-style. This only has an effect if the shape is + greater than 1-D. The default order is 'C'. + + Attributes + ---------- + filename : str or pathlib.Path instance + Path to the mapped file. + offset : int + Offset position in the file. + mode : str + File mode. + + Methods + ------- + flush + Flush any changes in memory to file on disk. + When you delete a memmap object, flush is called first to write + changes to disk. + + + See also + -------- + lib.format.open_memmap : Create or load a memory-mapped ``.npy`` file. + + Notes + ----- + The memmap object can be used anywhere an ndarray is accepted. + Given a memmap ``fp``, ``isinstance(fp, numpy.ndarray)`` returns + ``True``. + + Memory-mapped files cannot be larger than 2GB on 32-bit systems. + + When a memmap causes a file to be created or extended beyond its + current size in the filesystem, the contents of the new part are + unspecified. On systems with POSIX filesystem semantics, the extended + part will be filled with zero bytes. + + Examples + -------- + >>> import numpy as np + >>> data = np.arange(12, dtype='float32') + >>> data.resize((3,4)) + + This example uses a temporary file so that doctest doesn't write + files to your directory. You would use a 'normal' filename. + + >>> from tempfile import mkdtemp + >>> import os.path as path + >>> filename = path.join(mkdtemp(), 'newfile.dat') + + Create a memmap with dtype and shape that matches our data: + + >>> fp = np.memmap(filename, dtype='float32', mode='w+', shape=(3,4)) + >>> fp + memmap([[0., 0., 0., 0.], + [0., 0., 0., 0.], + [0., 0., 0., 0.]], dtype=float32) + + Write data to memmap array: + + >>> fp[:] = data[:] + >>> fp + memmap([[ 0., 1., 2., 3.], + [ 4., 5., 6., 7.], + [ 8., 9., 10., 11.]], dtype=float32) + + >>> fp.filename == path.abspath(filename) + True + + Flushes memory changes to disk in order to read them back + + >>> fp.flush() + + Load the memmap and verify data was stored: + + >>> newfp = np.memmap(filename, dtype='float32', mode='r', shape=(3,4)) + >>> newfp + memmap([[ 0., 1., 2., 3.], + [ 4., 5., 6., 7.], + [ 8., 9., 10., 11.]], dtype=float32) + + Read-only memmap: + + >>> fpr = np.memmap(filename, dtype='float32', mode='r', shape=(3,4)) + >>> fpr.flags.writeable + False + + Copy-on-write memmap: + + >>> fpc = np.memmap(filename, dtype='float32', mode='c', shape=(3,4)) + >>> fpc.flags.writeable + True + + It's possible to assign to copy-on-write array, but values are only + written into the memory copy of the array, and not written to disk: + + >>> fpc + memmap([[ 0., 1., 2., 3.], + [ 4., 5., 6., 7.], + [ 8., 9., 10., 11.]], dtype=float32) + >>> fpc[0,:] = 0 + >>> fpc + memmap([[ 0., 0., 0., 0.], + [ 4., 5., 6., 7.], + [ 8., 9., 10., 11.]], dtype=float32) + + File on disk is unchanged: + + >>> fpr + memmap([[ 0., 1., 2., 3.], + [ 4., 5., 6., 7.], + [ 8., 9., 10., 11.]], dtype=float32) + + Offset into a memmap: + + >>> fpo = np.memmap(filename, dtype='float32', mode='r', offset=16) + >>> fpo + memmap([ 4., 5., 6., 7., 8., 9., 10., 11.], dtype=float32) + + """ + + __array_priority__ = -100.0 + + def __new__(subtype, filename, dtype=uint8, mode='r+', offset=0, + shape=None, order='C'): + # Import here to minimize 'import numpy' overhead + import mmap + import os.path + try: + mode = mode_equivalents[mode] + except KeyError as e: + if mode not in valid_filemodes: + raise ValueError( + "mode must be one of {!r} (got {!r})" + .format(valid_filemodes + list(mode_equivalents.keys()), mode) + ) from None + + if mode == 'w+' and shape is None: + raise ValueError("shape must be given if mode == 'w+'") + + if hasattr(filename, 'read'): + f_ctx = nullcontext(filename) + else: + f_ctx = open( + os.fspath(filename), + ('r' if mode == 'c' else mode)+'b' + ) + + with f_ctx as fid: + fid.seek(0, 2) + flen = fid.tell() + descr = dtypedescr(dtype) + _dbytes = descr.itemsize + + if shape is None: + bytes = flen - offset + if bytes % _dbytes: + raise ValueError("Size of available data is not a " + "multiple of the data-type size.") + size = bytes // _dbytes + shape = (size,) + else: + if type(shape) not in (tuple, list): + try: + shape = [operator.index(shape)] + except TypeError: + pass + shape = tuple(shape) + size = np.intp(1) # avoid default choice of np.int_, which might overflow + for k in shape: + size *= k + + bytes = int(offset + size*_dbytes) + + if mode in ('w+', 'r+') and flen < bytes: + fid.seek(bytes - 1, 0) + fid.write(b'\0') + fid.flush() + + if mode == 'c': + acc = mmap.ACCESS_COPY + elif mode == 'r': + acc = mmap.ACCESS_READ + else: + acc = mmap.ACCESS_WRITE + + start = offset - offset % mmap.ALLOCATIONGRANULARITY + bytes -= start + array_offset = offset - start + mm = mmap.mmap(fid.fileno(), bytes, access=acc, offset=start) + + self = ndarray.__new__(subtype, shape, dtype=descr, buffer=mm, + offset=array_offset, order=order) + self._mmap = mm + self.offset = offset + self.mode = mode + + if isinstance(filename, os.PathLike): + # special case - if we were constructed with a pathlib.path, + # then filename is a path object, not a string + self.filename = filename.resolve() + elif hasattr(fid, "name") and isinstance(fid.name, str): + # py3 returns int for TemporaryFile().name + self.filename = os.path.abspath(fid.name) + # same as memmap copies (e.g. memmap + 1) + else: + self.filename = None + + return self + + def __array_finalize__(self, obj): + if hasattr(obj, '_mmap') and np.may_share_memory(self, obj): + self._mmap = obj._mmap + self.filename = obj.filename + self.offset = obj.offset + self.mode = obj.mode + else: + self._mmap = None + self.filename = None + self.offset = None + self.mode = None + + def flush(self): + """ + Write any changes in the array to the file on disk. + + For further information, see `memmap`. + + Parameters + ---------- + None + + See Also + -------- + memmap + + """ + if self.base is not None and hasattr(self.base, 'flush'): + self.base.flush() + + def __array_wrap__(self, arr, context=None, return_scalar=False): + arr = super().__array_wrap__(arr, context) + + # Return a memmap if a memmap was given as the output of the + # ufunc. Leave the arr class unchanged if self is not a memmap + # to keep original memmap subclasses behavior + if self is arr or type(self) is not memmap: + return arr + + # Return scalar instead of 0d memmap, e.g. for np.sum with + # axis=None (note that subclasses will not reach here) + if return_scalar: + return arr[()] + + # Return ndarray otherwise + return arr.view(np.ndarray) + + def __getitem__(self, index): + res = super().__getitem__(index) + if type(res) is memmap and res._mmap is None: + return res.view(type=ndarray) + return res diff --git a/venv/lib/python3.12/site-packages/numpy/_core/memmap.pyi b/venv/lib/python3.12/site-packages/numpy/_core/memmap.pyi new file mode 100644 index 00000000..03c6b772 --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/memmap.pyi @@ -0,0 +1,3 @@ +from numpy import memmap as memmap + +__all__: list[str] diff --git a/venv/lib/python3.12/site-packages/numpy/_core/multiarray.py b/venv/lib/python3.12/site-packages/numpy/_core/multiarray.py new file mode 100644 index 00000000..e2ca115b --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/multiarray.py @@ -0,0 +1,1772 @@ +""" +Create the numpy._core.multiarray namespace for backward compatibility. +In v1.16 the multiarray and umath c-extension modules were merged into +a single _multiarray_umath extension module. So we replicate the old +namespace by importing from the extension module. + +""" + +import functools +from . import overrides +from . import _multiarray_umath +from ._multiarray_umath import * # noqa: F403 +# These imports are needed for backward compatibility, +# do not change them. issue gh-15518 +# _get_ndarray_c_version is semi-public, on purpose not added to __all__ +from ._multiarray_umath import ( + _flagdict, from_dlpack, _place, _reconstruct, + _vec_string, _ARRAY_API, _monotonicity, _get_ndarray_c_version, + _get_madvise_hugepage, _set_madvise_hugepage, + _get_promotion_state, _set_promotion_state + ) + +__all__ = [ + '_ARRAY_API', 'ALLOW_THREADS', 'BUFSIZE', 'CLIP', 'DATETIMEUNITS', + 'ITEM_HASOBJECT', 'ITEM_IS_POINTER', 'LIST_PICKLE', 'MAXDIMS', + 'MAY_SHARE_BOUNDS', 'MAY_SHARE_EXACT', 'NEEDS_INIT', 'NEEDS_PYAPI', + 'RAISE', 'USE_GETITEM', 'USE_SETITEM', 'WRAP', + '_flagdict', 'from_dlpack', '_place', '_reconstruct', '_vec_string', + '_monotonicity', 'add_docstring', 'arange', 'array', 'asarray', + 'asanyarray', 'ascontiguousarray', 'asfortranarray', 'bincount', + 'broadcast', 'busday_count', 'busday_offset', 'busdaycalendar', 'can_cast', + 'compare_chararrays', 'concatenate', 'copyto', 'correlate', 'correlate2', + 'count_nonzero', 'c_einsum', 'datetime_as_string', 'datetime_data', + 'dot', 'dragon4_positional', 'dragon4_scientific', 'dtype', + 'empty', 'empty_like', 'error', 'flagsobj', 'flatiter', 'format_longfloat', + 'frombuffer', 'fromfile', 'fromiter', 'fromstring', + 'get_handler_name', 'get_handler_version', 'inner', 'interp', + 'interp_complex', 'is_busday', 'lexsort', 'matmul', 'vecdot', + 'may_share_memory', 'min_scalar_type', 'ndarray', 'nditer', 'nested_iters', + 'normalize_axis_index', 'packbits', 'promote_types', 'putmask', + 'ravel_multi_index', 'result_type', 'scalar', 'set_datetimeparse_function', + 'set_typeDict', 'shares_memory', 'typeinfo', + 'unpackbits', 'unravel_index', 'vdot', 'where', 'zeros', + '_get_promotion_state', '_set_promotion_state'] + +# For backward compatibility, make sure pickle imports +# these functions from here +_reconstruct.__module__ = 'numpy._core.multiarray' +scalar.__module__ = 'numpy._core.multiarray' + + +from_dlpack.__module__ = 'numpy' +arange.__module__ = 'numpy' +array.__module__ = 'numpy' +asarray.__module__ = 'numpy' +asanyarray.__module__ = 'numpy' +ascontiguousarray.__module__ = 'numpy' +asfortranarray.__module__ = 'numpy' +datetime_data.__module__ = 'numpy' +empty.__module__ = 'numpy' +frombuffer.__module__ = 'numpy' +fromfile.__module__ = 'numpy' +fromiter.__module__ = 'numpy' +frompyfunc.__module__ = 'numpy' +fromstring.__module__ = 'numpy' +may_share_memory.__module__ = 'numpy' +nested_iters.__module__ = 'numpy' +promote_types.__module__ = 'numpy' +zeros.__module__ = 'numpy' +_get_promotion_state.__module__ = 'numpy' +_set_promotion_state.__module__ = 'numpy' +normalize_axis_index.__module__ = 'numpy.lib.array_utils' + + +# We can't verify dispatcher signatures because NumPy's C functions don't +# support introspection. +array_function_from_c_func_and_dispatcher = functools.partial( + overrides.array_function_from_dispatcher, + module='numpy', docs_from_dispatcher=True, verify=False) + + +@array_function_from_c_func_and_dispatcher(_multiarray_umath.empty_like) +def empty_like( + prototype, dtype=None, order=None, subok=None, shape=None, *, device=None +): + """ + empty_like(prototype, dtype=None, order='K', subok=True, shape=None, *, + device=None) + + Return a new array with the same shape and type as a given array. + + Parameters + ---------- + prototype : array_like + The shape and data-type of `prototype` define these same attributes + of the returned array. + dtype : data-type, optional + Overrides the data type of the result. + + .. versionadded:: 1.6.0 + order : {'C', 'F', 'A', or 'K'}, optional + Overrides the memory layout of the result. 'C' means C-order, + 'F' means F-order, 'A' means 'F' if `prototype` is Fortran + contiguous, 'C' otherwise. 'K' means match the layout of `prototype` + as closely as possible. + + .. versionadded:: 1.6.0 + subok : bool, optional. + If True, then the newly created array will use the sub-class + type of `prototype`, otherwise it will be a base-class array. Defaults + to True. + shape : int or sequence of ints, optional. + Overrides the shape of the result. If order='K' and the number of + dimensions is unchanged, will try to keep order, otherwise, + order='C' is implied. + + .. versionadded:: 1.17.0 + device : str, optional + The device on which to place the created array. Default: None. + For Array-API interoperability only, so must be ``"cpu"`` if passed. + + .. versionadded:: 2.0.0 + + Returns + ------- + out : ndarray + Array of uninitialized (arbitrary) data with the same + shape and type as `prototype`. + + See Also + -------- + ones_like : Return an array of ones with shape and type of input. + zeros_like : Return an array of zeros with shape and type of input. + full_like : Return a new array with shape of input filled with value. + empty : Return a new uninitialized array. + + Notes + ----- + Unlike other array creation functions (e.g. `zeros_like`, `ones_like`, + `full_like`), `empty_like` does not initialize the values of the array, + and may therefore be marginally faster. However, the values stored in the + newly allocated array are arbitrary. For reproducible behavior, be sure + to set each element of the array before reading. + + Examples + -------- + >>> import numpy as np + >>> a = ([1,2,3], [4,5,6]) # a is array-like + >>> np.empty_like(a) + array([[-1073741821, -1073741821, 3], # uninitialized + [ 0, 0, -1073741821]]) + >>> a = np.array([[1., 2., 3.],[4.,5.,6.]]) + >>> np.empty_like(a) + array([[ -2.00000715e+000, 1.48219694e-323, -2.00000572e+000], # uninitialized + [ 4.38791518e-305, -2.00000715e+000, 4.17269252e-309]]) + + """ # NOQA + return (prototype,) + + +@array_function_from_c_func_and_dispatcher(_multiarray_umath.concatenate) +def concatenate(arrays, axis=None, out=None, *, dtype=None, casting=None): + """ + concatenate( + (a1, a2, ...), + axis=0, + out=None, + dtype=None, + casting="same_kind" + ) + + Join a sequence of arrays along an existing axis. + + Parameters + ---------- + a1, a2, ... : sequence of array_like + The arrays must have the same shape, except in the dimension + corresponding to `axis` (the first, by default). + axis : int, optional + The axis along which the arrays will be joined. If axis is None, + arrays are flattened before use. Default is 0. + out : ndarray, optional + If provided, the destination to place the result. The shape must be + correct, matching that of what concatenate would have returned if no + out argument were specified. + dtype : str or dtype + If provided, the destination array will have this dtype. Cannot be + provided together with `out`. + + .. versionadded:: 1.20.0 + + casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional + Controls what kind of data casting may occur. Defaults to 'same_kind'. + For a description of the options, please see :term:`casting`. + + .. versionadded:: 1.20.0 + + Returns + ------- + res : ndarray + The concatenated array. + + See Also + -------- + ma.concatenate : Concatenate function that preserves input masks. + array_split : Split an array into multiple sub-arrays of equal or + near-equal size. + split : Split array into a list of multiple sub-arrays of equal size. + hsplit : Split array into multiple sub-arrays horizontally (column wise). + vsplit : Split array into multiple sub-arrays vertically (row wise). + dsplit : Split array into multiple sub-arrays along the 3rd axis (depth). + stack : Stack a sequence of arrays along a new axis. + block : Assemble arrays from blocks. + hstack : Stack arrays in sequence horizontally (column wise). + vstack : Stack arrays in sequence vertically (row wise). + dstack : Stack arrays in sequence depth wise (along third dimension). + column_stack : Stack 1-D arrays as columns into a 2-D array. + + Notes + ----- + When one or more of the arrays to be concatenated is a MaskedArray, + this function will return a MaskedArray object instead of an ndarray, + but the input masks are *not* preserved. In cases where a MaskedArray + is expected as input, use the ma.concatenate function from the masked + array module instead. + + Examples + -------- + >>> import numpy as np + >>> a = np.array([[1, 2], [3, 4]]) + >>> b = np.array([[5, 6]]) + >>> np.concatenate((a, b), axis=0) + array([[1, 2], + [3, 4], + [5, 6]]) + >>> np.concatenate((a, b.T), axis=1) + array([[1, 2, 5], + [3, 4, 6]]) + >>> np.concatenate((a, b), axis=None) + array([1, 2, 3, 4, 5, 6]) + + This function will not preserve masking of MaskedArray inputs. + + >>> a = np.ma.arange(3) + >>> a[1] = np.ma.masked + >>> b = np.arange(2, 5) + >>> a + masked_array(data=[0, --, 2], + mask=[False, True, False], + fill_value=999999) + >>> b + array([2, 3, 4]) + >>> np.concatenate([a, b]) + masked_array(data=[0, 1, 2, 2, 3, 4], + mask=False, + fill_value=999999) + >>> np.ma.concatenate([a, b]) + masked_array(data=[0, --, 2, 2, 3, 4], + mask=[False, True, False, False, False, False], + fill_value=999999) + + """ + if out is not None: + # optimize for the typical case where only arrays is provided + arrays = list(arrays) + arrays.append(out) + return arrays + + +@array_function_from_c_func_and_dispatcher(_multiarray_umath.inner) +def inner(a, b): + """ + inner(a, b, /) + + Inner product of two arrays. + + Ordinary inner product of vectors for 1-D arrays (without complex + conjugation), in higher dimensions a sum product over the last axes. + + Parameters + ---------- + a, b : array_like + If `a` and `b` are nonscalar, their last dimensions must match. + + Returns + ------- + out : ndarray + If `a` and `b` are both + scalars or both 1-D arrays then a scalar is returned; otherwise + an array is returned. + ``out.shape = (*a.shape[:-1], *b.shape[:-1])`` + + Raises + ------ + ValueError + If both `a` and `b` are nonscalar and their last dimensions have + different sizes. + + See Also + -------- + tensordot : Sum products over arbitrary axes. + dot : Generalised matrix product, using second last dimension of `b`. + einsum : Einstein summation convention. + + Notes + ----- + For vectors (1-D arrays) it computes the ordinary inner-product:: + + np.inner(a, b) = sum(a[:]*b[:]) + + More generally, if ``ndim(a) = r > 0`` and ``ndim(b) = s > 0``:: + + np.inner(a, b) = np.tensordot(a, b, axes=(-1,-1)) + + or explicitly:: + + np.inner(a, b)[i0,...,ir-2,j0,...,js-2] + = sum(a[i0,...,ir-2,:]*b[j0,...,js-2,:]) + + In addition `a` or `b` may be scalars, in which case:: + + np.inner(a,b) = a*b + + Examples + -------- + Ordinary inner product for vectors: + + >>> import numpy as np + >>> a = np.array([1,2,3]) + >>> b = np.array([0,1,0]) + >>> np.inner(a, b) + 2 + + Some multidimensional examples: + + >>> a = np.arange(24).reshape((2,3,4)) + >>> b = np.arange(4) + >>> c = np.inner(a, b) + >>> c.shape + (2, 3) + >>> c + array([[ 14, 38, 62], + [ 86, 110, 134]]) + + >>> a = np.arange(2).reshape((1,1,2)) + >>> b = np.arange(6).reshape((3,2)) + >>> c = np.inner(a, b) + >>> c.shape + (1, 1, 3) + >>> c + array([[[1, 3, 5]]]) + + An example where `b` is a scalar: + + >>> np.inner(np.eye(2), 7) + array([[7., 0.], + [0., 7.]]) + + """ + return (a, b) + + +@array_function_from_c_func_and_dispatcher(_multiarray_umath.where) +def where(condition, x=None, y=None): + """ + where(condition, [x, y], /) + + Return elements chosen from `x` or `y` depending on `condition`. + + .. note:: + When only `condition` is provided, this function is a shorthand for + ``np.asarray(condition).nonzero()``. Using `nonzero` directly should be + preferred, as it behaves correctly for subclasses. The rest of this + documentation covers only the case where all three arguments are + provided. + + Parameters + ---------- + condition : array_like, bool + Where True, yield `x`, otherwise yield `y`. + x, y : array_like + Values from which to choose. `x`, `y` and `condition` need to be + broadcastable to some shape. + + Returns + ------- + out : ndarray + An array with elements from `x` where `condition` is True, and elements + from `y` elsewhere. + + See Also + -------- + choose + nonzero : The function that is called when x and y are omitted + + Notes + ----- + If all the arrays are 1-D, `where` is equivalent to:: + + [xv if c else yv + for c, xv, yv in zip(condition, x, y)] + + Examples + -------- + >>> import numpy as np + >>> a = np.arange(10) + >>> a + array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]) + >>> np.where(a < 5, a, 10*a) + array([ 0, 1, 2, 3, 4, 50, 60, 70, 80, 90]) + + This can be used on multidimensional arrays too: + + >>> np.where([[True, False], [True, True]], + ... [[1, 2], [3, 4]], + ... [[9, 8], [7, 6]]) + array([[1, 8], + [3, 4]]) + + The shapes of x, y, and the condition are broadcast together: + + >>> x, y = np.ogrid[:3, :4] + >>> np.where(x < y, x, 10 + y) # both x and 10+y are broadcast + array([[10, 0, 0, 0], + [10, 11, 1, 1], + [10, 11, 12, 2]]) + + >>> a = np.array([[0, 1, 2], + ... [0, 2, 4], + ... [0, 3, 6]]) + >>> np.where(a < 4, a, -1) # -1 is broadcast + array([[ 0, 1, 2], + [ 0, 2, -1], + [ 0, 3, -1]]) + """ + return (condition, x, y) + + +@array_function_from_c_func_and_dispatcher(_multiarray_umath.lexsort) +def lexsort(keys, axis=None): + """ + lexsort(keys, axis=-1) + + Perform an indirect stable sort using a sequence of keys. + + Given multiple sorting keys, lexsort returns an array of integer indices + that describes the sort order by multiple keys. The last key in the + sequence is used for the primary sort order, ties are broken by the + second-to-last key, and so on. + + Parameters + ---------- + keys : (k, m, n, ...) array-like + The `k` keys to be sorted. The *last* key (e.g, the last + row if `keys` is a 2D array) is the primary sort key. + Each element of `keys` along the zeroth axis must be + an array-like object of the same shape. + axis : int, optional + Axis to be indirectly sorted. By default, sort over the last axis + of each sequence. Separate slices along `axis` sorted over + independently; see last example. + + Returns + ------- + indices : (m, n, ...) ndarray of ints + Array of indices that sort the keys along the specified axis. + + See Also + -------- + argsort : Indirect sort. + ndarray.sort : In-place sort. + sort : Return a sorted copy of an array. + + Examples + -------- + Sort names: first by surname, then by name. + + >>> import numpy as np + >>> surnames = ('Hertz', 'Galilei', 'Hertz') + >>> first_names = ('Heinrich', 'Galileo', 'Gustav') + >>> ind = np.lexsort((first_names, surnames)) + >>> ind + array([1, 2, 0]) + + >>> [surnames[i] + ", " + first_names[i] for i in ind] + ['Galilei, Galileo', 'Hertz, Gustav', 'Hertz, Heinrich'] + + Sort according to two numerical keys, first by elements + of ``a``, then breaking ties according to elements of ``b``: + + >>> a = [1, 5, 1, 4, 3, 4, 4] # First sequence + >>> b = [9, 4, 0, 4, 0, 2, 1] # Second sequence + >>> ind = np.lexsort((b, a)) # Sort by `a`, then by `b` + >>> ind + array([2, 0, 4, 6, 5, 3, 1]) + >>> [(a[i], b[i]) for i in ind] + [(1, 0), (1, 9), (3, 0), (4, 1), (4, 2), (4, 4), (5, 4)] + + Compare against `argsort`, which would sort each key independently. + + >>> np.argsort((b, a), kind='stable') + array([[2, 4, 6, 5, 1, 3, 0], + [0, 2, 4, 3, 5, 6, 1]]) + + To sort lexicographically with `argsort`, we would need to provide a + structured array. + + >>> x = np.array([(ai, bi) for ai, bi in zip(a, b)], + ... dtype = np.dtype([('x', int), ('y', int)])) + >>> np.argsort(x) # or np.argsort(x, order=('x', 'y')) + array([2, 0, 4, 6, 5, 3, 1]) + + The zeroth axis of `keys` always corresponds with the sequence of keys, + so 2D arrays are treated just like other sequences of keys. + + >>> arr = np.asarray([b, a]) + >>> ind2 = np.lexsort(arr) + >>> np.testing.assert_equal(ind2, ind) + + Accordingly, the `axis` parameter refers to an axis of *each* key, not of + the `keys` argument itself. For instance, the array ``arr`` is treated as + a sequence of two 1-D keys, so specifying ``axis=0`` is equivalent to + using the default axis, ``axis=-1``. + + >>> np.testing.assert_equal(np.lexsort(arr, axis=0), + ... np.lexsort(arr, axis=-1)) + + For higher-dimensional arrays, the axis parameter begins to matter. The + resulting array has the same shape as each key, and the values are what + we would expect if `lexsort` were performed on corresponding slices + of the keys independently. For instance, + + >>> x = [[1, 2, 3, 4], + ... [4, 3, 2, 1], + ... [2, 1, 4, 3]] + >>> y = [[2, 2, 1, 1], + ... [1, 2, 1, 2], + ... [1, 1, 2, 1]] + >>> np.lexsort((x, y), axis=1) + array([[2, 3, 0, 1], + [2, 0, 3, 1], + [1, 0, 3, 2]]) + + Each row of the result is what we would expect if we were to perform + `lexsort` on the corresponding row of the keys: + + >>> for i in range(3): + ... print(np.lexsort((x[i], y[i]))) + [2 3 0 1] + [2 0 3 1] + [1 0 3 2] + + """ + if isinstance(keys, tuple): + return keys + else: + return (keys,) + + +@array_function_from_c_func_and_dispatcher(_multiarray_umath.can_cast) +def can_cast(from_, to, casting=None): + """ + can_cast(from_, to, casting='safe') + + Returns True if cast between data types can occur according to the + casting rule. + + Parameters + ---------- + from_ : dtype, dtype specifier, NumPy scalar, or array + Data type, NumPy scalar, or array to cast from. + to : dtype or dtype specifier + Data type to cast to. + casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional + Controls what kind of data casting may occur. + + * 'no' means the data types should not be cast at all. + * 'equiv' means only byte-order changes are allowed. + * 'safe' means only casts which can preserve values are allowed. + * 'same_kind' means only safe casts or casts within a kind, + like float64 to float32, are allowed. + * 'unsafe' means any data conversions may be done. + + Returns + ------- + out : bool + True if cast can occur according to the casting rule. + + Notes + ----- + .. versionchanged:: 1.17.0 + Casting between a simple data type and a structured one is possible only + for "unsafe" casting. Casting to multiple fields is allowed, but + casting from multiple fields is not. + + .. versionchanged:: 1.9.0 + Casting from numeric to string types in 'safe' casting mode requires + that the string dtype length is long enough to store the maximum + integer/float value converted. + + .. versionchanged:: 2.0 + This function does not support Python scalars anymore and does not + apply any value-based logic for 0-D arrays and NumPy scalars. + + See also + -------- + dtype, result_type + + Examples + -------- + Basic examples + + >>> import numpy as np + >>> np.can_cast(np.int32, np.int64) + True + >>> np.can_cast(np.float64, complex) + True + >>> np.can_cast(complex, float) + False + + >>> np.can_cast('i8', 'f8') + True + >>> np.can_cast('i8', 'f4') + False + >>> np.can_cast('i4', 'S4') + False + + """ + return (from_,) + + +@array_function_from_c_func_and_dispatcher(_multiarray_umath.min_scalar_type) +def min_scalar_type(a): + """ + min_scalar_type(a, /) + + For scalar ``a``, returns the data type with the smallest size + and smallest scalar kind which can hold its value. For non-scalar + array ``a``, returns the vector's dtype unmodified. + + Floating point values are not demoted to integers, + and complex values are not demoted to floats. + + Parameters + ---------- + a : scalar or array_like + The value whose minimal data type is to be found. + + Returns + ------- + out : dtype + The minimal data type. + + Notes + ----- + .. versionadded:: 1.6.0 + + See Also + -------- + result_type, promote_types, dtype, can_cast + + Examples + -------- + >>> import numpy as np + >>> np.min_scalar_type(10) + dtype('uint8') + + >>> np.min_scalar_type(-260) + dtype('int16') + + >>> np.min_scalar_type(3.1) + dtype('float16') + + >>> np.min_scalar_type(1e50) + dtype('float64') + + >>> np.min_scalar_type(np.arange(4,dtype='f8')) + dtype('float64') + + """ + return (a,) + + +@array_function_from_c_func_and_dispatcher(_multiarray_umath.result_type) +def result_type(*arrays_and_dtypes): + """ + result_type(*arrays_and_dtypes) + + Returns the type that results from applying the NumPy + type promotion rules to the arguments. + + Type promotion in NumPy works similarly to the rules in languages + like C++, with some slight differences. When both scalars and + arrays are used, the array's type takes precedence and the actual value + of the scalar is taken into account. + + For example, calculating 3*a, where a is an array of 32-bit floats, + intuitively should result in a 32-bit float output. If the 3 is a + 32-bit integer, the NumPy rules indicate it can't convert losslessly + into a 32-bit float, so a 64-bit float should be the result type. + By examining the value of the constant, '3', we see that it fits in + an 8-bit integer, which can be cast losslessly into the 32-bit float. + + Parameters + ---------- + arrays_and_dtypes : list of arrays and dtypes + The operands of some operation whose result type is needed. + + Returns + ------- + out : dtype + The result type. + + See also + -------- + dtype, promote_types, min_scalar_type, can_cast + + Notes + ----- + .. versionadded:: 1.6.0 + + The specific algorithm used is as follows. + + Categories are determined by first checking which of boolean, + integer (int/uint), or floating point (float/complex) the maximum + kind of all the arrays and the scalars are. + + If there are only scalars or the maximum category of the scalars + is higher than the maximum category of the arrays, + the data types are combined with :func:`promote_types` + to produce the return value. + + Otherwise, `min_scalar_type` is called on each scalar, and + the resulting data types are all combined with :func:`promote_types` + to produce the return value. + + The set of int values is not a subset of the uint values for types + with the same number of bits, something not reflected in + :func:`min_scalar_type`, but handled as a special case in `result_type`. + + Examples + -------- + >>> import numpy as np + >>> np.result_type(3, np.arange(7, dtype='i1')) + dtype('int8') + + >>> np.result_type('i4', 'c8') + dtype('complex128') + + >>> np.result_type(3.0, -2) + dtype('float64') + + """ + return arrays_and_dtypes + + +@array_function_from_c_func_and_dispatcher(_multiarray_umath.dot) +def dot(a, b, out=None): + """ + dot(a, b, out=None) + + Dot product of two arrays. Specifically, + + - If both `a` and `b` are 1-D arrays, it is inner product of vectors + (without complex conjugation). + + - If both `a` and `b` are 2-D arrays, it is matrix multiplication, + but using :func:`matmul` or ``a @ b`` is preferred. + + - If either `a` or `b` is 0-D (scalar), it is equivalent to + :func:`multiply` and using ``numpy.multiply(a, b)`` or ``a * b`` is + preferred. + + - If `a` is an N-D array and `b` is a 1-D array, it is a sum product over + the last axis of `a` and `b`. + + - If `a` is an N-D array and `b` is an M-D array (where ``M>=2``), it is a + sum product over the last axis of `a` and the second-to-last axis of + `b`:: + + dot(a, b)[i,j,k,m] = sum(a[i,j,:] * b[k,:,m]) + + It uses an optimized BLAS library when possible (see `numpy.linalg`). + + Parameters + ---------- + a : array_like + First argument. + b : array_like + Second argument. + out : ndarray, optional + Output argument. This must have the exact kind that would be returned + if it was not used. In particular, it must have the right type, must be + C-contiguous, and its dtype must be the dtype that would be returned + for `dot(a,b)`. This is a performance feature. Therefore, if these + conditions are not met, an exception is raised, instead of attempting + to be flexible. + + Returns + ------- + output : ndarray + Returns the dot product of `a` and `b`. If `a` and `b` are both + scalars or both 1-D arrays then a scalar is returned; otherwise + an array is returned. + If `out` is given, then it is returned. + + Raises + ------ + ValueError + If the last dimension of `a` is not the same size as + the second-to-last dimension of `b`. + + See Also + -------- + vdot : Complex-conjugating dot product. + tensordot : Sum products over arbitrary axes. + einsum : Einstein summation convention. + matmul : '@' operator as method with out parameter. + linalg.multi_dot : Chained dot product. + + Examples + -------- + >>> import numpy as np + >>> np.dot(3, 4) + 12 + + Neither argument is complex-conjugated: + + >>> np.dot([2j, 3j], [2j, 3j]) + (-13+0j) + + For 2-D arrays it is the matrix product: + + >>> a = [[1, 0], [0, 1]] + >>> b = [[4, 1], [2, 2]] + >>> np.dot(a, b) + array([[4, 1], + [2, 2]]) + + >>> a = np.arange(3*4*5*6).reshape((3,4,5,6)) + >>> b = np.arange(3*4*5*6)[::-1].reshape((5,4,6,3)) + >>> np.dot(a, b)[2,3,2,1,2,2] + 499128 + >>> sum(a[2,3,2,:] * b[1,2,:,2]) + 499128 + + """ + return (a, b, out) + + +@array_function_from_c_func_and_dispatcher(_multiarray_umath.vdot) +def vdot(a, b): + """ + vdot(a, b, /) + + Return the dot product of two vectors. + + The vdot(`a`, `b`) function handles complex numbers differently than + dot(`a`, `b`). If the first argument is complex the complex conjugate + of the first argument is used for the calculation of the dot product. + + Note that `vdot` handles multidimensional arrays differently than `dot`: + it does *not* perform a matrix product, but flattens input arguments + to 1-D vectors first. Consequently, it should only be used for vectors. + + Parameters + ---------- + a : array_like + If `a` is complex the complex conjugate is taken before calculation + of the dot product. + b : array_like + Second argument to the dot product. + + Returns + ------- + output : ndarray + Dot product of `a` and `b`. Can be an int, float, or + complex depending on the types of `a` and `b`. + + See Also + -------- + dot : Return the dot product without using the complex conjugate of the + first argument. + + Examples + -------- + >>> import numpy as np + >>> a = np.array([1+2j,3+4j]) + >>> b = np.array([5+6j,7+8j]) + >>> np.vdot(a, b) + (70-8j) + >>> np.vdot(b, a) + (70+8j) + + Note that higher-dimensional arrays are flattened! + + >>> a = np.array([[1, 4], [5, 6]]) + >>> b = np.array([[4, 1], [2, 2]]) + >>> np.vdot(a, b) + 30 + >>> np.vdot(b, a) + 30 + >>> 1*4 + 4*1 + 5*2 + 6*2 + 30 + + """ + return (a, b) + + +@array_function_from_c_func_and_dispatcher(_multiarray_umath.bincount) +def bincount(x, weights=None, minlength=None): + """ + bincount(x, /, weights=None, minlength=0) + + Count number of occurrences of each value in array of non-negative ints. + + The number of bins (of size 1) is one larger than the largest value in + `x`. If `minlength` is specified, there will be at least this number + of bins in the output array (though it will be longer if necessary, + depending on the contents of `x`). + Each bin gives the number of occurrences of its index value in `x`. + If `weights` is specified the input array is weighted by it, i.e. if a + value ``n`` is found at position ``i``, ``out[n] += weight[i]`` instead + of ``out[n] += 1``. + + Parameters + ---------- + x : array_like, 1 dimension, nonnegative ints + Input array. + weights : array_like, optional + Weights, array of the same shape as `x`. + minlength : int, optional + A minimum number of bins for the output array. + + .. versionadded:: 1.6.0 + + Returns + ------- + out : ndarray of ints + The result of binning the input array. + The length of `out` is equal to ``np.amax(x)+1``. + + Raises + ------ + ValueError + If the input is not 1-dimensional, or contains elements with negative + values, or if `minlength` is negative. + TypeError + If the type of the input is float or complex. + + See Also + -------- + histogram, digitize, unique + + Examples + -------- + >>> import numpy as np + >>> np.bincount(np.arange(5)) + array([1, 1, 1, 1, 1]) + >>> np.bincount(np.array([0, 1, 1, 3, 2, 1, 7])) + array([1, 3, 1, 1, 0, 0, 0, 1]) + + >>> x = np.array([0, 1, 1, 3, 2, 1, 7, 23]) + >>> np.bincount(x).size == np.amax(x)+1 + True + + The input array needs to be of integer dtype, otherwise a + TypeError is raised: + + >>> np.bincount(np.arange(5, dtype=float)) + Traceback (most recent call last): + ... + TypeError: Cannot cast array data from dtype('float64') to dtype('int64') + according to the rule 'safe' + + A possible use of ``bincount`` is to perform sums over + variable-size chunks of an array, using the ``weights`` keyword. + + >>> w = np.array([0.3, 0.5, 0.2, 0.7, 1., -0.6]) # weights + >>> x = np.array([0, 1, 1, 2, 2, 2]) + >>> np.bincount(x, weights=w) + array([ 0.3, 0.7, 1.1]) + + """ + return (x, weights) + + +@array_function_from_c_func_and_dispatcher(_multiarray_umath.ravel_multi_index) +def ravel_multi_index(multi_index, dims, mode=None, order=None): + """ + ravel_multi_index(multi_index, dims, mode='raise', order='C') + + Converts a tuple of index arrays into an array of flat + indices, applying boundary modes to the multi-index. + + Parameters + ---------- + multi_index : tuple of array_like + A tuple of integer arrays, one array for each dimension. + dims : tuple of ints + The shape of array into which the indices from ``multi_index`` apply. + mode : {'raise', 'wrap', 'clip'}, optional + Specifies how out-of-bounds indices are handled. Can specify + either one mode or a tuple of modes, one mode per index. + + * 'raise' -- raise an error (default) + * 'wrap' -- wrap around + * 'clip' -- clip to the range + + In 'clip' mode, a negative index which would normally + wrap will clip to 0 instead. + order : {'C', 'F'}, optional + Determines whether the multi-index should be viewed as + indexing in row-major (C-style) or column-major + (Fortran-style) order. + + Returns + ------- + raveled_indices : ndarray + An array of indices into the flattened version of an array + of dimensions ``dims``. + + See Also + -------- + unravel_index + + Notes + ----- + .. versionadded:: 1.6.0 + + Examples + -------- + >>> import numpy as np + >>> arr = np.array([[3,6,6],[4,5,1]]) + >>> np.ravel_multi_index(arr, (7,6)) + array([22, 41, 37]) + >>> np.ravel_multi_index(arr, (7,6), order='F') + array([31, 41, 13]) + >>> np.ravel_multi_index(arr, (4,6), mode='clip') + array([22, 23, 19]) + >>> np.ravel_multi_index(arr, (4,4), mode=('clip','wrap')) + array([12, 13, 13]) + + >>> np.ravel_multi_index((3,1,4,1), (6,7,8,9)) + 1621 + """ + return multi_index + + +@array_function_from_c_func_and_dispatcher(_multiarray_umath.unravel_index) +def unravel_index(indices, shape=None, order=None): + """ + unravel_index(indices, shape, order='C') + + Converts a flat index or array of flat indices into a tuple + of coordinate arrays. + + Parameters + ---------- + indices : array_like + An integer array whose elements are indices into the flattened + version of an array of dimensions ``shape``. Before version 1.6.0, + this function accepted just one index value. + shape : tuple of ints + The shape of the array to use for unraveling ``indices``. + + .. versionchanged:: 1.16.0 + Renamed from ``dims`` to ``shape``. + + order : {'C', 'F'}, optional + Determines whether the indices should be viewed as indexing in + row-major (C-style) or column-major (Fortran-style) order. + + .. versionadded:: 1.6.0 + + Returns + ------- + unraveled_coords : tuple of ndarray + Each array in the tuple has the same shape as the ``indices`` + array. + + See Also + -------- + ravel_multi_index + + Examples + -------- + >>> import numpy as np + >>> np.unravel_index([22, 41, 37], (7,6)) + (array([3, 6, 6]), array([4, 5, 1])) + >>> np.unravel_index([31, 41, 13], (7,6), order='F') + (array([3, 6, 6]), array([4, 5, 1])) + + >>> np.unravel_index(1621, (6,7,8,9)) + (3, 1, 4, 1) + + """ + return (indices,) + + +@array_function_from_c_func_and_dispatcher(_multiarray_umath.copyto) +def copyto(dst, src, casting=None, where=None): + """ + copyto(dst, src, casting='same_kind', where=True) + + Copies values from one array to another, broadcasting as necessary. + + Raises a TypeError if the `casting` rule is violated, and if + `where` is provided, it selects which elements to copy. + + .. versionadded:: 1.7.0 + + Parameters + ---------- + dst : ndarray + The array into which values are copied. + src : array_like + The array from which values are copied. + casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional + Controls what kind of data casting may occur when copying. + + * 'no' means the data types should not be cast at all. + * 'equiv' means only byte-order changes are allowed. + * 'safe' means only casts which can preserve values are allowed. + * 'same_kind' means only safe casts or casts within a kind, + like float64 to float32, are allowed. + * 'unsafe' means any data conversions may be done. + where : array_like of bool, optional + A boolean array which is broadcasted to match the dimensions + of `dst`, and selects elements to copy from `src` to `dst` + wherever it contains the value True. + + Examples + -------- + >>> import numpy as np + >>> A = np.array([4, 5, 6]) + >>> B = [1, 2, 3] + >>> np.copyto(A, B) + >>> A + array([1, 2, 3]) + + >>> A = np.array([[1, 2, 3], [4, 5, 6]]) + >>> B = [[4, 5, 6], [7, 8, 9]] + >>> np.copyto(A, B) + >>> A + array([[4, 5, 6], + [7, 8, 9]]) + + """ + return (dst, src, where) + + +@array_function_from_c_func_and_dispatcher(_multiarray_umath.putmask) +def putmask(a, /, mask, values): + """ + putmask(a, mask, values) + + Changes elements of an array based on conditional and input values. + + Sets ``a.flat[n] = values[n]`` for each n where ``mask.flat[n]==True``. + + If `values` is not the same size as `a` and `mask` then it will repeat. + This gives behavior different from ``a[mask] = values``. + + Parameters + ---------- + a : ndarray + Target array. + mask : array_like + Boolean mask array. It has to be the same shape as `a`. + values : array_like + Values to put into `a` where `mask` is True. If `values` is smaller + than `a` it will be repeated. + + See Also + -------- + place, put, take, copyto + + Examples + -------- + >>> import numpy as np + >>> x = np.arange(6).reshape(2, 3) + >>> np.putmask(x, x>2, x**2) + >>> x + array([[ 0, 1, 2], + [ 9, 16, 25]]) + + If `values` is smaller than `a` it is repeated: + + >>> x = np.arange(5) + >>> np.putmask(x, x>1, [-33, -44]) + >>> x + array([ 0, 1, -33, -44, -33]) + + """ + return (a, mask, values) + + +@array_function_from_c_func_and_dispatcher(_multiarray_umath.packbits) +def packbits(a, axis=None, bitorder='big'): + """ + packbits(a, /, axis=None, bitorder='big') + + Packs the elements of a binary-valued array into bits in a uint8 array. + + The result is padded to full bytes by inserting zero bits at the end. + + Parameters + ---------- + a : array_like + An array of integers or booleans whose elements should be packed to + bits. + axis : int, optional + The dimension over which bit-packing is done. + ``None`` implies packing the flattened array. + bitorder : {'big', 'little'}, optional + The order of the input bits. 'big' will mimic bin(val), + ``[0, 0, 0, 0, 0, 0, 1, 1] => 3 = 0b00000011``, 'little' will + reverse the order so ``[1, 1, 0, 0, 0, 0, 0, 0] => 3``. + Defaults to 'big'. + + .. versionadded:: 1.17.0 + + Returns + ------- + packed : ndarray + Array of type uint8 whose elements represent bits corresponding to the + logical (0 or nonzero) value of the input elements. The shape of + `packed` has the same number of dimensions as the input (unless `axis` + is None, in which case the output is 1-D). + + See Also + -------- + unpackbits: Unpacks elements of a uint8 array into a binary-valued output + array. + + Examples + -------- + >>> import numpy as np + >>> a = np.array([[[1,0,1], + ... [0,1,0]], + ... [[1,1,0], + ... [0,0,1]]]) + >>> b = np.packbits(a, axis=-1) + >>> b + array([[[160], + [ 64]], + [[192], + [ 32]]], dtype=uint8) + + Note that in binary 160 = 1010 0000, 64 = 0100 0000, 192 = 1100 0000, + and 32 = 0010 0000. + + """ + return (a,) + + +@array_function_from_c_func_and_dispatcher(_multiarray_umath.unpackbits) +def unpackbits(a, axis=None, count=None, bitorder='big'): + """ + unpackbits(a, /, axis=None, count=None, bitorder='big') + + Unpacks elements of a uint8 array into a binary-valued output array. + + Each element of `a` represents a bit-field that should be unpacked + into a binary-valued output array. The shape of the output array is + either 1-D (if `axis` is ``None``) or the same shape as the input + array with unpacking done along the axis specified. + + Parameters + ---------- + a : ndarray, uint8 type + Input array. + axis : int, optional + The dimension over which bit-unpacking is done. + ``None`` implies unpacking the flattened array. + count : int or None, optional + The number of elements to unpack along `axis`, provided as a way + of undoing the effect of packing a size that is not a multiple + of eight. A non-negative number means to only unpack `count` + bits. A negative number means to trim off that many bits from + the end. ``None`` means to unpack the entire array (the + default). Counts larger than the available number of bits will + add zero padding to the output. Negative counts must not + exceed the available number of bits. + + .. versionadded:: 1.17.0 + + bitorder : {'big', 'little'}, optional + The order of the returned bits. 'big' will mimic bin(val), + ``3 = 0b00000011 => [0, 0, 0, 0, 0, 0, 1, 1]``, 'little' will reverse + the order to ``[1, 1, 0, 0, 0, 0, 0, 0]``. + Defaults to 'big'. + + .. versionadded:: 1.17.0 + + Returns + ------- + unpacked : ndarray, uint8 type + The elements are binary-valued (0 or 1). + + See Also + -------- + packbits : Packs the elements of a binary-valued array into bits in + a uint8 array. + + Examples + -------- + >>> import numpy as np + >>> a = np.array([[2], [7], [23]], dtype=np.uint8) + >>> a + array([[ 2], + [ 7], + [23]], dtype=uint8) + >>> b = np.unpackbits(a, axis=1) + >>> b + array([[0, 0, 0, 0, 0, 0, 1, 0], + [0, 0, 0, 0, 0, 1, 1, 1], + [0, 0, 0, 1, 0, 1, 1, 1]], dtype=uint8) + >>> c = np.unpackbits(a, axis=1, count=-3) + >>> c + array([[0, 0, 0, 0, 0], + [0, 0, 0, 0, 0], + [0, 0, 0, 1, 0]], dtype=uint8) + + >>> p = np.packbits(b, axis=0) + >>> np.unpackbits(p, axis=0) + array([[0, 0, 0, 0, 0, 0, 1, 0], + [0, 0, 0, 0, 0, 1, 1, 1], + [0, 0, 0, 1, 0, 1, 1, 1], + [0, 0, 0, 0, 0, 0, 0, 0], + [0, 0, 0, 0, 0, 0, 0, 0], + [0, 0, 0, 0, 0, 0, 0, 0], + [0, 0, 0, 0, 0, 0, 0, 0], + [0, 0, 0, 0, 0, 0, 0, 0]], dtype=uint8) + >>> np.array_equal(b, np.unpackbits(p, axis=0, count=b.shape[0])) + True + + """ + return (a,) + + +@array_function_from_c_func_and_dispatcher(_multiarray_umath.shares_memory) +def shares_memory(a, b, max_work=None): + """ + shares_memory(a, b, /, max_work=None) + + Determine if two arrays share memory. + + .. warning:: + + This function can be exponentially slow for some inputs, unless + `max_work` is set to zero or a positive integer. + If in doubt, use `numpy.may_share_memory` instead. + + Parameters + ---------- + a, b : ndarray + Input arrays + max_work : int, optional + Effort to spend on solving the overlap problem (maximum number + of candidate solutions to consider). The following special + values are recognized: + + max_work=-1 (default) + The problem is solved exactly. In this case, the function returns + True only if there is an element shared between the arrays. Finding + the exact solution may take extremely long in some cases. + max_work=0 + Only the memory bounds of a and b are checked. + This is equivalent to using ``may_share_memory()``. + + Raises + ------ + numpy.exceptions.TooHardError + Exceeded max_work. + + Returns + ------- + out : bool + + See Also + -------- + may_share_memory + + Examples + -------- + >>> import numpy as np + >>> x = np.array([1, 2, 3, 4]) + >>> np.shares_memory(x, np.array([5, 6, 7])) + False + >>> np.shares_memory(x[::2], x) + True + >>> np.shares_memory(x[::2], x[1::2]) + False + + Checking whether two arrays share memory is NP-complete, and + runtime may increase exponentially in the number of + dimensions. Hence, `max_work` should generally be set to a finite + number, as it is possible to construct examples that take + extremely long to run: + + >>> from numpy.lib.stride_tricks import as_strided + >>> x = np.zeros([192163377], dtype=np.int8) + >>> x1 = as_strided( + ... x, strides=(36674, 61119, 85569), shape=(1049, 1049, 1049)) + >>> x2 = as_strided( + ... x[64023025:], strides=(12223, 12224, 1), shape=(1049, 1049, 1)) + >>> np.shares_memory(x1, x2, max_work=1000) + Traceback (most recent call last): + ... + numpy.exceptions.TooHardError: Exceeded max_work + + Running ``np.shares_memory(x1, x2)`` without `max_work` set takes + around 1 minute for this case. It is possible to find problems + that take still significantly longer. + + """ + return (a, b) + + +@array_function_from_c_func_and_dispatcher(_multiarray_umath.may_share_memory) +def may_share_memory(a, b, max_work=None): + """ + may_share_memory(a, b, /, max_work=None) + + Determine if two arrays might share memory + + A return of True does not necessarily mean that the two arrays + share any element. It just means that they *might*. + + Only the memory bounds of a and b are checked by default. + + Parameters + ---------- + a, b : ndarray + Input arrays + max_work : int, optional + Effort to spend on solving the overlap problem. See + `shares_memory` for details. Default for ``may_share_memory`` + is to do a bounds check. + + Returns + ------- + out : bool + + See Also + -------- + shares_memory + + Examples + -------- + >>> import numpy as np + >>> np.may_share_memory(np.array([1,2]), np.array([5,8,9])) + False + >>> x = np.zeros([3, 4]) + >>> np.may_share_memory(x[:,0], x[:,1]) + True + + """ + return (a, b) + + +@array_function_from_c_func_and_dispatcher(_multiarray_umath.is_busday) +def is_busday(dates, weekmask=None, holidays=None, busdaycal=None, out=None): + """ + is_busday( + dates, + weekmask='1111100', + holidays=None, + busdaycal=None, + out=None + ) + + Calculates which of the given dates are valid days, and which are not. + + .. versionadded:: 1.7.0 + + Parameters + ---------- + dates : array_like of datetime64[D] + The array of dates to process. + weekmask : str or array_like of bool, optional + A seven-element array indicating which of Monday through Sunday are + valid days. May be specified as a length-seven list or array, like + [1,1,1,1,1,0,0]; a length-seven string, like '1111100'; or a string + like "Mon Tue Wed Thu Fri", made up of 3-character abbreviations for + weekdays, optionally separated by white space. Valid abbreviations + are: Mon Tue Wed Thu Fri Sat Sun + holidays : array_like of datetime64[D], optional + An array of dates to consider as invalid dates. They may be + specified in any order, and NaT (not-a-time) dates are ignored. + This list is saved in a normalized form that is suited for + fast calculations of valid days. + busdaycal : busdaycalendar, optional + A `busdaycalendar` object which specifies the valid days. If this + parameter is provided, neither weekmask nor holidays may be + provided. + out : array of bool, optional + If provided, this array is filled with the result. + + Returns + ------- + out : array of bool + An array with the same shape as ``dates``, containing True for + each valid day, and False for each invalid day. + + See Also + -------- + busdaycalendar : An object that specifies a custom set of valid days. + busday_offset : Applies an offset counted in valid days. + busday_count : Counts how many valid days are in a half-open date range. + + Examples + -------- + >>> import numpy as np + >>> # The weekdays are Friday, Saturday, and Monday + ... np.is_busday(['2011-07-01', '2011-07-02', '2011-07-18'], + ... holidays=['2011-07-01', '2011-07-04', '2011-07-17']) + array([False, False, True]) + """ + return (dates, weekmask, holidays, out) + + +@array_function_from_c_func_and_dispatcher(_multiarray_umath.busday_offset) +def busday_offset(dates, offsets, roll=None, weekmask=None, holidays=None, + busdaycal=None, out=None): + """ + busday_offset( + dates, + offsets, + roll='raise', + weekmask='1111100', + holidays=None, + busdaycal=None, + out=None + ) + + First adjusts the date to fall on a valid day according to + the ``roll`` rule, then applies offsets to the given dates + counted in valid days. + + .. versionadded:: 1.7.0 + + Parameters + ---------- + dates : array_like of datetime64[D] + The array of dates to process. + offsets : array_like of int + The array of offsets, which is broadcast with ``dates``. + roll : {'raise', 'nat', 'forward', 'following', 'backward', 'preceding', \ + 'modifiedfollowing', 'modifiedpreceding'}, optional + How to treat dates that do not fall on a valid day. The default + is 'raise'. + + * 'raise' means to raise an exception for an invalid day. + * 'nat' means to return a NaT (not-a-time) for an invalid day. + * 'forward' and 'following' mean to take the first valid day + later in time. + * 'backward' and 'preceding' mean to take the first valid day + earlier in time. + * 'modifiedfollowing' means to take the first valid day + later in time unless it is across a Month boundary, in which + case to take the first valid day earlier in time. + * 'modifiedpreceding' means to take the first valid day + earlier in time unless it is across a Month boundary, in which + case to take the first valid day later in time. + weekmask : str or array_like of bool, optional + A seven-element array indicating which of Monday through Sunday are + valid days. May be specified as a length-seven list or array, like + [1,1,1,1,1,0,0]; a length-seven string, like '1111100'; or a string + like "Mon Tue Wed Thu Fri", made up of 3-character abbreviations for + weekdays, optionally separated by white space. Valid abbreviations + are: Mon Tue Wed Thu Fri Sat Sun + holidays : array_like of datetime64[D], optional + An array of dates to consider as invalid dates. They may be + specified in any order, and NaT (not-a-time) dates are ignored. + This list is saved in a normalized form that is suited for + fast calculations of valid days. + busdaycal : busdaycalendar, optional + A `busdaycalendar` object which specifies the valid days. If this + parameter is provided, neither weekmask nor holidays may be + provided. + out : array of datetime64[D], optional + If provided, this array is filled with the result. + + Returns + ------- + out : array of datetime64[D] + An array with a shape from broadcasting ``dates`` and ``offsets`` + together, containing the dates with offsets applied. + + See Also + -------- + busdaycalendar : An object that specifies a custom set of valid days. + is_busday : Returns a boolean array indicating valid days. + busday_count : Counts how many valid days are in a half-open date range. + + Examples + -------- + >>> import numpy as np + >>> # First business day in October 2011 (not accounting for holidays) + ... np.busday_offset('2011-10', 0, roll='forward') + np.datetime64('2011-10-03') + >>> # Last business day in February 2012 (not accounting for holidays) + ... np.busday_offset('2012-03', -1, roll='forward') + np.datetime64('2012-02-29') + >>> # Third Wednesday in January 2011 + ... np.busday_offset('2011-01', 2, roll='forward', weekmask='Wed') + np.datetime64('2011-01-19') + >>> # 2012 Mother's Day in Canada and the U.S. + ... np.busday_offset('2012-05', 1, roll='forward', weekmask='Sun') + np.datetime64('2012-05-13') + + >>> # First business day on or after a date + ... np.busday_offset('2011-03-20', 0, roll='forward') + np.datetime64('2011-03-21') + >>> np.busday_offset('2011-03-22', 0, roll='forward') + np.datetime64('2011-03-22') + >>> # First business day after a date + ... np.busday_offset('2011-03-20', 1, roll='backward') + np.datetime64('2011-03-21') + >>> np.busday_offset('2011-03-22', 1, roll='backward') + np.datetime64('2011-03-23') + """ + return (dates, offsets, weekmask, holidays, out) + + +@array_function_from_c_func_and_dispatcher(_multiarray_umath.busday_count) +def busday_count(begindates, enddates, weekmask=None, holidays=None, + busdaycal=None, out=None): + """ + busday_count( + begindates, + enddates, + weekmask='1111100', + holidays=[], + busdaycal=None, + out=None + ) + + Counts the number of valid days between `begindates` and + `enddates`, not including the day of `enddates`. + + If ``enddates`` specifies a date value that is earlier than the + corresponding ``begindates`` date value, the count will be negative. + + .. versionadded:: 1.7.0 + + Parameters + ---------- + begindates : array_like of datetime64[D] + The array of the first dates for counting. + enddates : array_like of datetime64[D] + The array of the end dates for counting, which are excluded + from the count themselves. + weekmask : str or array_like of bool, optional + A seven-element array indicating which of Monday through Sunday are + valid days. May be specified as a length-seven list or array, like + [1,1,1,1,1,0,0]; a length-seven string, like '1111100'; or a string + like "Mon Tue Wed Thu Fri", made up of 3-character abbreviations for + weekdays, optionally separated by white space. Valid abbreviations + are: Mon Tue Wed Thu Fri Sat Sun + holidays : array_like of datetime64[D], optional + An array of dates to consider as invalid dates. They may be + specified in any order, and NaT (not-a-time) dates are ignored. + This list is saved in a normalized form that is suited for + fast calculations of valid days. + busdaycal : busdaycalendar, optional + A `busdaycalendar` object which specifies the valid days. If this + parameter is provided, neither weekmask nor holidays may be + provided. + out : array of int, optional + If provided, this array is filled with the result. + + Returns + ------- + out : array of int + An array with a shape from broadcasting ``begindates`` and ``enddates`` + together, containing the number of valid days between + the begin and end dates. + + See Also + -------- + busdaycalendar : An object that specifies a custom set of valid days. + is_busday : Returns a boolean array indicating valid days. + busday_offset : Applies an offset counted in valid days. + + Examples + -------- + >>> import numpy as np + >>> # Number of weekdays in January 2011 + ... np.busday_count('2011-01', '2011-02') + 21 + >>> # Number of weekdays in 2011 + >>> np.busday_count('2011', '2012') + 260 + >>> # Number of Saturdays in 2011 + ... np.busday_count('2011', '2012', weekmask='Sat') + 53 + """ + return (begindates, enddates, weekmask, holidays, out) + + +@array_function_from_c_func_and_dispatcher( + _multiarray_umath.datetime_as_string) +def datetime_as_string(arr, unit=None, timezone=None, casting=None): + """ + datetime_as_string(arr, unit=None, timezone='naive', casting='same_kind') + + Convert an array of datetimes into an array of strings. + + Parameters + ---------- + arr : array_like of datetime64 + The array of UTC timestamps to format. + unit : str + One of None, 'auto', or + a :ref:`datetime unit `. + timezone : {'naive', 'UTC', 'local'} or tzinfo + Timezone information to use when displaying the datetime. If 'UTC', + end with a Z to indicate UTC time. If 'local', convert to the local + timezone first, and suffix with a +-#### timezone offset. If a tzinfo + object, then do as with 'local', but use the specified timezone. + casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'} + Casting to allow when changing between datetime units. + + Returns + ------- + str_arr : ndarray + An array of strings the same shape as `arr`. + + Examples + -------- + >>> import numpy as np + >>> import pytz + >>> d = np.arange('2002-10-27T04:30', 4*60, 60, dtype='M8[m]') + >>> d + array(['2002-10-27T04:30', '2002-10-27T05:30', '2002-10-27T06:30', + '2002-10-27T07:30'], dtype='datetime64[m]') + + Setting the timezone to UTC shows the same information, but with a Z suffix + + >>> np.datetime_as_string(d, timezone='UTC') + array(['2002-10-27T04:30Z', '2002-10-27T05:30Z', '2002-10-27T06:30Z', + '2002-10-27T07:30Z'], dtype='>> np.datetime_as_string(d, timezone=pytz.timezone('US/Eastern')) + array(['2002-10-27T00:30-0400', '2002-10-27T01:30-0400', + '2002-10-27T01:30-0500', '2002-10-27T02:30-0500'], dtype='>> np.datetime_as_string(d, unit='h') + array(['2002-10-27T04', '2002-10-27T05', '2002-10-27T06', '2002-10-27T07'], + dtype='>> np.datetime_as_string(d, unit='s') + array(['2002-10-27T04:30:00', '2002-10-27T05:30:00', '2002-10-27T06:30:00', + '2002-10-27T07:30:00'], dtype='>> np.datetime_as_string(d, unit='h', casting='safe') + Traceback (most recent call last): + ... + TypeError: Cannot create a datetime string as units 'h' from a NumPy + datetime with units 'm' according to the rule 'safe' + """ + return (arr,) diff --git a/venv/lib/python3.12/site-packages/numpy/_core/multiarray.pyi b/venv/lib/python3.12/site-packages/numpy/_core/multiarray.pyi new file mode 100644 index 00000000..dd109301 --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/multiarray.pyi @@ -0,0 +1,1081 @@ +# TODO: Sort out any and all missing functions in this namespace +import builtins +import os +import datetime as dt +from collections.abc import Sequence, Callable, Iterable +from typing import ( + Literal as L, + Any, + overload, + TypeVar, + SupportsIndex, + final, + Final, + Protocol, + ClassVar, +) + +import numpy as np +from numpy import ( + # Re-exports + busdaycalendar as busdaycalendar, + broadcast as broadcast, + dtype as dtype, + ndarray as ndarray, + nditer as nditer, + + # The rest + ufunc, + str_, + uint8, + intp, + int_, + float64, + timedelta64, + datetime64, + generic, + unsignedinteger, + signedinteger, + floating, + complexfloating, + _OrderKACF, + _OrderCF, + _CastingKind, + _ModeKind, + _SupportsBuffer, + _IOProtocol, + _CopyMode, + _NDIterFlagsKind, + _NDIterOpFlagsKind, +) + +from numpy._typing import ( + # Shapes + _ShapeLike, + + # DTypes + DTypeLike, + _DTypeLike, + + # Arrays + NDArray, + ArrayLike, + _ArrayLike, + _SupportsArrayFunc, + _NestedSequence, + _ArrayLikeBool_co, + _ArrayLikeUInt_co, + _ArrayLikeInt_co, + _ArrayLikeFloat_co, + _ArrayLikeComplex_co, + _ArrayLikeTD64_co, + _ArrayLikeDT64_co, + _ArrayLikeObject_co, + _ArrayLikeStr_co, + _ArrayLikeBytes_co, + _ScalarLike_co, + _IntLike_co, + _FloatLike_co, + _TD64Like_co, +) + +_T_co = TypeVar("_T_co", covariant=True) +_T_contra = TypeVar("_T_contra", contravariant=True) +_SCT = TypeVar("_SCT", bound=generic) +_ArrayType = TypeVar("_ArrayType", bound=ndarray[Any, Any]) +_ArrayType_co = TypeVar( + "_ArrayType_co", + bound=ndarray[Any, Any], + covariant=True, +) + +# Valid time units +_UnitKind = L[ + "Y", + "M", + "D", + "h", + "m", + "s", + "ms", + "us", "μs", + "ns", + "ps", + "fs", + "as", +] +_RollKind = L[ # `raise` is deliberately excluded + "nat", + "forward", + "following", + "backward", + "preceding", + "modifiedfollowing", + "modifiedpreceding", +] + +class _SupportsLenAndGetItem(Protocol[_T_contra, _T_co]): + def __len__(self) -> int: ... + def __getitem__(self, key: _T_contra, /) -> _T_co: ... + +class _SupportsArray(Protocol[_ArrayType_co]): + def __array__(self, /) -> _ArrayType_co: ... + +__all__: list[str] + +ALLOW_THREADS: Final[int] # 0 or 1 (system-specific) +BUFSIZE: L[8192] +CLIP: L[0] +WRAP: L[1] +RAISE: L[2] +MAXDIMS: L[32] +MAY_SHARE_BOUNDS: L[0] +MAY_SHARE_EXACT: L[-1] +tracemalloc_domain: L[389047] + +@overload +def empty_like( + prototype: _ArrayType, + dtype: None = ..., + order: _OrderKACF = ..., + subok: bool = ..., + shape: None | _ShapeLike = ..., + *, + device: None | L["cpu"] = ..., +) -> _ArrayType: ... +@overload +def empty_like( + prototype: _ArrayLike[_SCT], + dtype: None = ..., + order: _OrderKACF = ..., + subok: bool = ..., + shape: None | _ShapeLike = ..., + *, + device: None | L["cpu"] = ..., +) -> NDArray[_SCT]: ... +@overload +def empty_like( + prototype: object, + dtype: None = ..., + order: _OrderKACF = ..., + subok: bool = ..., + shape: None | _ShapeLike = ..., + *, + device: None | L["cpu"] = ..., +) -> NDArray[Any]: ... +@overload +def empty_like( + prototype: Any, + dtype: _DTypeLike[_SCT], + order: _OrderKACF = ..., + subok: bool = ..., + shape: None | _ShapeLike = ..., + *, + device: None | L["cpu"] = ..., +) -> NDArray[_SCT]: ... +@overload +def empty_like( + prototype: Any, + dtype: DTypeLike, + order: _OrderKACF = ..., + subok: bool = ..., + shape: None | _ShapeLike = ..., + *, + device: None | L["cpu"] = ..., +) -> NDArray[Any]: ... + +@overload +def array( + object: _ArrayType, + dtype: None = ..., + *, + copy: None | bool | _CopyMode = ..., + order: _OrderKACF = ..., + subok: L[True], + ndmin: int = ..., + like: None | _SupportsArrayFunc = ..., +) -> _ArrayType: ... +@overload +def array( + object: _SupportsArray[_ArrayType], + dtype: None = ..., + *, + copy: None | bool | _CopyMode = ..., + order: _OrderKACF = ..., + subok: L[True], + ndmin: L[0] = ..., + like: None | _SupportsArrayFunc = ..., +) -> _ArrayType: ... +@overload +def array( + object: _ArrayLike[_SCT], + dtype: None = ..., + *, + copy: None | bool | _CopyMode = ..., + order: _OrderKACF = ..., + subok: bool = ..., + ndmin: int = ..., + like: None | _SupportsArrayFunc = ..., +) -> NDArray[_SCT]: ... +@overload +def array( + object: object, + dtype: None = ..., + *, + copy: None | bool | _CopyMode = ..., + order: _OrderKACF = ..., + subok: bool = ..., + ndmin: int = ..., + like: None | _SupportsArrayFunc = ..., +) -> NDArray[Any]: ... +@overload +def array( + object: Any, + dtype: _DTypeLike[_SCT], + *, + copy: None | bool | _CopyMode = ..., + order: _OrderKACF = ..., + subok: bool = ..., + ndmin: int = ..., + like: None | _SupportsArrayFunc = ..., +) -> NDArray[_SCT]: ... +@overload +def array( + object: Any, + dtype: DTypeLike, + *, + copy: None | bool | _CopyMode = ..., + order: _OrderKACF = ..., + subok: bool = ..., + ndmin: int = ..., + like: None | _SupportsArrayFunc = ..., +) -> NDArray[Any]: ... + +@overload +def zeros( + shape: _ShapeLike, + dtype: None = ..., + order: _OrderCF = ..., + *, + device: None | L["cpu"] = ..., + like: None | _SupportsArrayFunc = ..., +) -> NDArray[float64]: ... +@overload +def zeros( + shape: _ShapeLike, + dtype: _DTypeLike[_SCT], + order: _OrderCF = ..., + *, + device: None | L["cpu"] = ..., + like: None | _SupportsArrayFunc = ..., +) -> NDArray[_SCT]: ... +@overload +def zeros( + shape: _ShapeLike, + dtype: DTypeLike, + order: _OrderCF = ..., + *, + device: None | L["cpu"] = ..., + like: None | _SupportsArrayFunc = ..., +) -> NDArray[Any]: ... + +@overload +def empty( + shape: _ShapeLike, + dtype: None = ..., + order: _OrderCF = ..., + *, + device: None | L["cpu"] = ..., + like: None | _SupportsArrayFunc = ..., +) -> NDArray[float64]: ... +@overload +def empty( + shape: _ShapeLike, + dtype: _DTypeLike[_SCT], + order: _OrderCF = ..., + *, + device: None | L["cpu"] = ..., + like: None | _SupportsArrayFunc = ..., +) -> NDArray[_SCT]: ... +@overload +def empty( + shape: _ShapeLike, + dtype: DTypeLike, + order: _OrderCF = ..., + *, + device: None | L["cpu"] = ..., + like: None | _SupportsArrayFunc = ..., +) -> NDArray[Any]: ... + +@overload +def unravel_index( # type: ignore[misc] + indices: _IntLike_co, + shape: _ShapeLike, + order: _OrderCF = ..., +) -> tuple[intp, ...]: ... +@overload +def unravel_index( + indices: _ArrayLikeInt_co, + shape: _ShapeLike, + order: _OrderCF = ..., +) -> tuple[NDArray[intp], ...]: ... + +@overload +def ravel_multi_index( # type: ignore[misc] + multi_index: Sequence[_IntLike_co], + dims: Sequence[SupportsIndex], + mode: _ModeKind | tuple[_ModeKind, ...] = ..., + order: _OrderCF = ..., +) -> intp: ... +@overload +def ravel_multi_index( + multi_index: Sequence[_ArrayLikeInt_co], + dims: Sequence[SupportsIndex], + mode: _ModeKind | tuple[_ModeKind, ...] = ..., + order: _OrderCF = ..., +) -> NDArray[intp]: ... + +# NOTE: Allow any sequence of array-like objects +@overload +def concatenate( # type: ignore[misc] + arrays: _ArrayLike[_SCT], + /, + axis: None | SupportsIndex = ..., + out: None = ..., + *, + dtype: None = ..., + casting: None | _CastingKind = ... +) -> NDArray[_SCT]: ... +@overload +def concatenate( # type: ignore[misc] + arrays: _SupportsLenAndGetItem[int, ArrayLike], + /, + axis: None | SupportsIndex = ..., + out: None = ..., + *, + dtype: None = ..., + casting: None | _CastingKind = ... +) -> NDArray[Any]: ... +@overload +def concatenate( # type: ignore[misc] + arrays: _SupportsLenAndGetItem[int, ArrayLike], + /, + axis: None | SupportsIndex = ..., + out: None = ..., + *, + dtype: _DTypeLike[_SCT], + casting: None | _CastingKind = ... +) -> NDArray[_SCT]: ... +@overload +def concatenate( # type: ignore[misc] + arrays: _SupportsLenAndGetItem[int, ArrayLike], + /, + axis: None | SupportsIndex = ..., + out: None = ..., + *, + dtype: DTypeLike, + casting: None | _CastingKind = ... +) -> NDArray[Any]: ... +@overload +def concatenate( + arrays: _SupportsLenAndGetItem[int, ArrayLike], + /, + axis: None | SupportsIndex = ..., + out: _ArrayType = ..., + *, + dtype: DTypeLike = ..., + casting: None | _CastingKind = ... +) -> _ArrayType: ... + +def inner( + a: ArrayLike, + b: ArrayLike, + /, +) -> Any: ... + +@overload +def where( + condition: ArrayLike, + /, +) -> tuple[NDArray[intp], ...]: ... +@overload +def where( + condition: ArrayLike, + x: ArrayLike, + y: ArrayLike, + /, +) -> NDArray[Any]: ... + +def lexsort( + keys: ArrayLike, + axis: None | SupportsIndex = ..., +) -> Any: ... + +def can_cast( + from_: ArrayLike | DTypeLike, + to: DTypeLike, + casting: None | _CastingKind = ..., +) -> bool: ... + +def min_scalar_type( + a: ArrayLike, /, +) -> dtype[Any]: ... + +def result_type( + *arrays_and_dtypes: ArrayLike | DTypeLike, +) -> dtype[Any]: ... + +@overload +def dot(a: ArrayLike, b: ArrayLike, out: None = ...) -> Any: ... +@overload +def dot(a: ArrayLike, b: ArrayLike, out: _ArrayType) -> _ArrayType: ... + +@overload +def vdot(a: _ArrayLikeBool_co, b: _ArrayLikeBool_co, /) -> np.bool: ... # type: ignore[misc] +@overload +def vdot(a: _ArrayLikeUInt_co, b: _ArrayLikeUInt_co, /) -> unsignedinteger[Any]: ... # type: ignore[misc] +@overload +def vdot(a: _ArrayLikeInt_co, b: _ArrayLikeInt_co, /) -> signedinteger[Any]: ... # type: ignore[misc] +@overload +def vdot(a: _ArrayLikeFloat_co, b: _ArrayLikeFloat_co, /) -> floating[Any]: ... # type: ignore[misc] +@overload +def vdot(a: _ArrayLikeComplex_co, b: _ArrayLikeComplex_co, /) -> complexfloating[Any, Any]: ... # type: ignore[misc] +@overload +def vdot(a: _ArrayLikeTD64_co, b: _ArrayLikeTD64_co, /) -> timedelta64: ... +@overload +def vdot(a: _ArrayLikeObject_co, b: Any, /) -> Any: ... +@overload +def vdot(a: Any, b: _ArrayLikeObject_co, /) -> Any: ... + +def bincount( + x: ArrayLike, + /, + weights: None | ArrayLike = ..., + minlength: SupportsIndex = ..., +) -> NDArray[intp]: ... + +def copyto( + dst: NDArray[Any], + src: ArrayLike, + casting: None | _CastingKind = ..., + where: None | _ArrayLikeBool_co = ..., +) -> None: ... + +def putmask( + a: NDArray[Any], + /, + mask: _ArrayLikeBool_co, + values: ArrayLike, +) -> None: ... + +def packbits( + a: _ArrayLikeInt_co, + /, + axis: None | SupportsIndex = ..., + bitorder: L["big", "little"] = ..., +) -> NDArray[uint8]: ... + +def unpackbits( + a: _ArrayLike[uint8], + /, + axis: None | SupportsIndex = ..., + count: None | SupportsIndex = ..., + bitorder: L["big", "little"] = ..., +) -> NDArray[uint8]: ... + +def shares_memory( + a: object, + b: object, + /, + max_work: None | int = ..., +) -> bool: ... + +def may_share_memory( + a: object, + b: object, + /, + max_work: None | int = ..., +) -> bool: ... + +@overload +def asarray( + a: _ArrayLike[_SCT], + dtype: None = ..., + order: _OrderKACF = ..., + *, + device: None | L["cpu"] = ..., + copy: None | bool = ..., + like: None | _SupportsArrayFunc = ..., +) -> NDArray[_SCT]: ... +@overload +def asarray( + a: object, + dtype: None = ..., + order: _OrderKACF = ..., + *, + device: None | L["cpu"] = ..., + copy: None | bool = ..., + like: None | _SupportsArrayFunc = ..., +) -> NDArray[Any]: ... +@overload +def asarray( + a: Any, + dtype: _DTypeLike[_SCT], + order: _OrderKACF = ..., + *, + device: None | L["cpu"] = ..., + copy: None | bool = ..., + like: None | _SupportsArrayFunc = ..., +) -> NDArray[_SCT]: ... +@overload +def asarray( + a: Any, + dtype: DTypeLike, + order: _OrderKACF = ..., + *, + device: None | L["cpu"] = ..., + copy: None | bool = ..., + like: None | _SupportsArrayFunc = ..., +) -> NDArray[Any]: ... + +@overload +def asanyarray( + a: _ArrayType, # Preserve subclass-information + dtype: None = ..., + order: _OrderKACF = ..., + *, + device: None | L["cpu"] = ..., + copy: None | bool = ..., + like: None | _SupportsArrayFunc = ..., +) -> _ArrayType: ... +@overload +def asanyarray( + a: _ArrayLike[_SCT], + dtype: None = ..., + order: _OrderKACF = ..., + *, + device: None | L["cpu"] = ..., + copy: None | bool = ..., + like: None | _SupportsArrayFunc = ..., +) -> NDArray[_SCT]: ... +@overload +def asanyarray( + a: object, + dtype: None = ..., + order: _OrderKACF = ..., + *, + device: None | L["cpu"] = ..., + copy: None | bool = ..., + like: None | _SupportsArrayFunc = ..., +) -> NDArray[Any]: ... +@overload +def asanyarray( + a: Any, + dtype: _DTypeLike[_SCT], + order: _OrderKACF = ..., + *, + device: None | L["cpu"] = ..., + copy: None | bool = ..., + like: None | _SupportsArrayFunc = ..., +) -> NDArray[_SCT]: ... +@overload +def asanyarray( + a: Any, + dtype: DTypeLike, + order: _OrderKACF = ..., + *, + device: None | L["cpu"] = ..., + copy: None | bool = ..., + like: None | _SupportsArrayFunc = ..., +) -> NDArray[Any]: ... + +@overload +def ascontiguousarray( + a: _ArrayLike[_SCT], + dtype: None = ..., + *, + like: None | _SupportsArrayFunc = ..., +) -> NDArray[_SCT]: ... +@overload +def ascontiguousarray( + a: object, + dtype: None = ..., + *, + like: None | _SupportsArrayFunc = ..., +) -> NDArray[Any]: ... +@overload +def ascontiguousarray( + a: Any, + dtype: _DTypeLike[_SCT], + *, + like: None | _SupportsArrayFunc = ..., +) -> NDArray[_SCT]: ... +@overload +def ascontiguousarray( + a: Any, + dtype: DTypeLike, + *, + like: None | _SupportsArrayFunc = ..., +) -> NDArray[Any]: ... + +@overload +def asfortranarray( + a: _ArrayLike[_SCT], + dtype: None = ..., + *, + like: None | _SupportsArrayFunc = ..., +) -> NDArray[_SCT]: ... +@overload +def asfortranarray( + a: object, + dtype: None = ..., + *, + like: None | _SupportsArrayFunc = ..., +) -> NDArray[Any]: ... +@overload +def asfortranarray( + a: Any, + dtype: _DTypeLike[_SCT], + *, + like: None | _SupportsArrayFunc = ..., +) -> NDArray[_SCT]: ... +@overload +def asfortranarray( + a: Any, + dtype: DTypeLike, + *, + like: None | _SupportsArrayFunc = ..., +) -> NDArray[Any]: ... + +def promote_types(__type1: DTypeLike, __type2: DTypeLike) -> dtype[Any]: ... + +# `sep` is a de facto mandatory argument, as its default value is deprecated +@overload +def fromstring( + string: str | bytes, + dtype: None = ..., + count: SupportsIndex = ..., + *, + sep: str, + like: None | _SupportsArrayFunc = ..., +) -> NDArray[float64]: ... +@overload +def fromstring( + string: str | bytes, + dtype: _DTypeLike[_SCT], + count: SupportsIndex = ..., + *, + sep: str, + like: None | _SupportsArrayFunc = ..., +) -> NDArray[_SCT]: ... +@overload +def fromstring( + string: str | bytes, + dtype: DTypeLike, + count: SupportsIndex = ..., + *, + sep: str, + like: None | _SupportsArrayFunc = ..., +) -> NDArray[Any]: ... + +def frompyfunc( + func: Callable[..., Any], /, + nin: SupportsIndex, + nout: SupportsIndex, + *, + identity: Any = ..., +) -> ufunc: ... + +@overload +def fromfile( + file: str | bytes | os.PathLike[Any] | _IOProtocol, + dtype: None = ..., + count: SupportsIndex = ..., + sep: str = ..., + offset: SupportsIndex = ..., + *, + like: None | _SupportsArrayFunc = ..., +) -> NDArray[float64]: ... +@overload +def fromfile( + file: str | bytes | os.PathLike[Any] | _IOProtocol, + dtype: _DTypeLike[_SCT], + count: SupportsIndex = ..., + sep: str = ..., + offset: SupportsIndex = ..., + *, + like: None | _SupportsArrayFunc = ..., +) -> NDArray[_SCT]: ... +@overload +def fromfile( + file: str | bytes | os.PathLike[Any] | _IOProtocol, + dtype: DTypeLike, + count: SupportsIndex = ..., + sep: str = ..., + offset: SupportsIndex = ..., + *, + like: None | _SupportsArrayFunc = ..., +) -> NDArray[Any]: ... + +@overload +def fromiter( + iter: Iterable[Any], + dtype: _DTypeLike[_SCT], + count: SupportsIndex = ..., + *, + like: None | _SupportsArrayFunc = ..., +) -> NDArray[_SCT]: ... +@overload +def fromiter( + iter: Iterable[Any], + dtype: DTypeLike, + count: SupportsIndex = ..., + *, + like: None | _SupportsArrayFunc = ..., +) -> NDArray[Any]: ... + +@overload +def frombuffer( + buffer: _SupportsBuffer, + dtype: None = ..., + count: SupportsIndex = ..., + offset: SupportsIndex = ..., + *, + like: None | _SupportsArrayFunc = ..., +) -> NDArray[float64]: ... +@overload +def frombuffer( + buffer: _SupportsBuffer, + dtype: _DTypeLike[_SCT], + count: SupportsIndex = ..., + offset: SupportsIndex = ..., + *, + like: None | _SupportsArrayFunc = ..., +) -> NDArray[_SCT]: ... +@overload +def frombuffer( + buffer: _SupportsBuffer, + dtype: DTypeLike, + count: SupportsIndex = ..., + offset: SupportsIndex = ..., + *, + like: None | _SupportsArrayFunc = ..., +) -> NDArray[Any]: ... + +@overload +def arange( # type: ignore[misc] + stop: _IntLike_co, + /, *, + dtype: None = ..., + device: None | L["cpu"] = ..., + like: None | _SupportsArrayFunc = ..., +) -> NDArray[signedinteger[Any]]: ... +@overload +def arange( # type: ignore[misc] + start: _IntLike_co, + stop: _IntLike_co, + step: _IntLike_co = ..., + dtype: None = ..., + *, + device: None | L["cpu"] = ..., + like: None | _SupportsArrayFunc = ..., +) -> NDArray[signedinteger[Any]]: ... +@overload +def arange( # type: ignore[misc] + stop: _FloatLike_co, + /, *, + dtype: None = ..., + device: None | L["cpu"] = ..., + like: None | _SupportsArrayFunc = ..., +) -> NDArray[floating[Any]]: ... +@overload +def arange( # type: ignore[misc] + start: _FloatLike_co, + stop: _FloatLike_co, + step: _FloatLike_co = ..., + dtype: None = ..., + *, + device: None | L["cpu"] = ..., + like: None | _SupportsArrayFunc = ..., +) -> NDArray[floating[Any]]: ... +@overload +def arange( + stop: _TD64Like_co, + /, *, + dtype: None = ..., + device: None | L["cpu"] = ..., + like: None | _SupportsArrayFunc = ..., +) -> NDArray[timedelta64]: ... +@overload +def arange( + start: _TD64Like_co, + stop: _TD64Like_co, + step: _TD64Like_co = ..., + dtype: None = ..., + *, + device: None | L["cpu"] = ..., + like: None | _SupportsArrayFunc = ..., +) -> NDArray[timedelta64]: ... +@overload +def arange( # both start and stop must always be specified for datetime64 + start: datetime64, + stop: datetime64, + step: datetime64 = ..., + dtype: None = ..., + *, + device: None | L["cpu"] = ..., + like: None | _SupportsArrayFunc = ..., +) -> NDArray[datetime64]: ... +@overload +def arange( + stop: Any, + /, *, + dtype: _DTypeLike[_SCT], + device: None | L["cpu"] = ..., + like: None | _SupportsArrayFunc = ..., +) -> NDArray[_SCT]: ... +@overload +def arange( + start: Any, + stop: Any, + step: Any = ..., + dtype: _DTypeLike[_SCT] = ..., + *, + device: None | L["cpu"] = ..., + like: None | _SupportsArrayFunc = ..., +) -> NDArray[_SCT]: ... +@overload +def arange( + stop: Any, /, + *, + dtype: DTypeLike, + device: None | L["cpu"] = ..., + like: None | _SupportsArrayFunc = ..., +) -> NDArray[Any]: ... +@overload +def arange( + start: Any, + stop: Any, + step: Any = ..., + dtype: DTypeLike = ..., + *, + device: None | L["cpu"] = ..., + like: None | _SupportsArrayFunc = ..., +) -> NDArray[Any]: ... + +def datetime_data( + dtype: str | _DTypeLike[datetime64] | _DTypeLike[timedelta64], /, +) -> tuple[str, int]: ... + +# The datetime functions perform unsafe casts to `datetime64[D]`, +# so a lot of different argument types are allowed here + +@overload +def busday_count( # type: ignore[misc] + begindates: _ScalarLike_co | dt.date, + enddates: _ScalarLike_co | dt.date, + weekmask: ArrayLike = ..., + holidays: None | ArrayLike | dt.date | _NestedSequence[dt.date] = ..., + busdaycal: None | busdaycalendar = ..., + out: None = ..., +) -> int_: ... +@overload +def busday_count( # type: ignore[misc] + begindates: ArrayLike | dt.date | _NestedSequence[dt.date], + enddates: ArrayLike | dt.date | _NestedSequence[dt.date], + weekmask: ArrayLike = ..., + holidays: None | ArrayLike | dt.date | _NestedSequence[dt.date] = ..., + busdaycal: None | busdaycalendar = ..., + out: None = ..., +) -> NDArray[int_]: ... +@overload +def busday_count( + begindates: ArrayLike | dt.date | _NestedSequence[dt.date], + enddates: ArrayLike | dt.date | _NestedSequence[dt.date], + weekmask: ArrayLike = ..., + holidays: None | ArrayLike | dt.date | _NestedSequence[dt.date] = ..., + busdaycal: None | busdaycalendar = ..., + out: _ArrayType = ..., +) -> _ArrayType: ... + +# `roll="raise"` is (more or less?) equivalent to `casting="safe"` +@overload +def busday_offset( # type: ignore[misc] + dates: datetime64 | dt.date, + offsets: _TD64Like_co | dt.timedelta, + roll: L["raise"] = ..., + weekmask: ArrayLike = ..., + holidays: None | ArrayLike | dt.date | _NestedSequence[dt.date] = ..., + busdaycal: None | busdaycalendar = ..., + out: None = ..., +) -> datetime64: ... +@overload +def busday_offset( # type: ignore[misc] + dates: _ArrayLike[datetime64] | dt.date | _NestedSequence[dt.date], + offsets: _ArrayLikeTD64_co | dt.timedelta | _NestedSequence[dt.timedelta], + roll: L["raise"] = ..., + weekmask: ArrayLike = ..., + holidays: None | ArrayLike | dt.date | _NestedSequence[dt.date] = ..., + busdaycal: None | busdaycalendar = ..., + out: None = ..., +) -> NDArray[datetime64]: ... +@overload +def busday_offset( # type: ignore[misc] + dates: _ArrayLike[datetime64] | dt.date | _NestedSequence[dt.date], + offsets: _ArrayLikeTD64_co | dt.timedelta | _NestedSequence[dt.timedelta], + roll: L["raise"] = ..., + weekmask: ArrayLike = ..., + holidays: None | ArrayLike | dt.date | _NestedSequence[dt.date] = ..., + busdaycal: None | busdaycalendar = ..., + out: _ArrayType = ..., +) -> _ArrayType: ... +@overload +def busday_offset( # type: ignore[misc] + dates: _ScalarLike_co | dt.date, + offsets: _ScalarLike_co | dt.timedelta, + roll: _RollKind, + weekmask: ArrayLike = ..., + holidays: None | ArrayLike | dt.date | _NestedSequence[dt.date] = ..., + busdaycal: None | busdaycalendar = ..., + out: None = ..., +) -> datetime64: ... +@overload +def busday_offset( # type: ignore[misc] + dates: ArrayLike | dt.date | _NestedSequence[dt.date], + offsets: ArrayLike | dt.timedelta | _NestedSequence[dt.timedelta], + roll: _RollKind, + weekmask: ArrayLike = ..., + holidays: None | ArrayLike | dt.date | _NestedSequence[dt.date] = ..., + busdaycal: None | busdaycalendar = ..., + out: None = ..., +) -> NDArray[datetime64]: ... +@overload +def busday_offset( + dates: ArrayLike | dt.date | _NestedSequence[dt.date], + offsets: ArrayLike | dt.timedelta | _NestedSequence[dt.timedelta], + roll: _RollKind, + weekmask: ArrayLike = ..., + holidays: None | ArrayLike | dt.date | _NestedSequence[dt.date] = ..., + busdaycal: None | busdaycalendar = ..., + out: _ArrayType = ..., +) -> _ArrayType: ... + +@overload +def is_busday( # type: ignore[misc] + dates: _ScalarLike_co | dt.date, + weekmask: ArrayLike = ..., + holidays: None | ArrayLike | dt.date | _NestedSequence[dt.date] = ..., + busdaycal: None | busdaycalendar = ..., + out: None = ..., +) -> np.bool: ... +@overload +def is_busday( # type: ignore[misc] + dates: ArrayLike | _NestedSequence[dt.date], + weekmask: ArrayLike = ..., + holidays: None | ArrayLike | dt.date | _NestedSequence[dt.date] = ..., + busdaycal: None | busdaycalendar = ..., + out: None = ..., +) -> NDArray[np.bool]: ... +@overload +def is_busday( + dates: ArrayLike | _NestedSequence[dt.date], + weekmask: ArrayLike = ..., + holidays: None | ArrayLike | dt.date | _NestedSequence[dt.date] = ..., + busdaycal: None | busdaycalendar = ..., + out: _ArrayType = ..., +) -> _ArrayType: ... + +@overload +def datetime_as_string( # type: ignore[misc] + arr: datetime64 | dt.date, + unit: None | L["auto"] | _UnitKind = ..., + timezone: L["naive", "UTC", "local"] | dt.tzinfo = ..., + casting: _CastingKind = ..., +) -> str_: ... +@overload +def datetime_as_string( + arr: _ArrayLikeDT64_co | _NestedSequence[dt.date], + unit: None | L["auto"] | _UnitKind = ..., + timezone: L["naive", "UTC", "local"] | dt.tzinfo = ..., + casting: _CastingKind = ..., +) -> NDArray[str_]: ... + +@overload +def compare_chararrays( + a1: _ArrayLikeStr_co, + a2: _ArrayLikeStr_co, + cmp: L["<", "<=", "==", ">=", ">", "!="], + rstrip: bool, +) -> NDArray[np.bool]: ... +@overload +def compare_chararrays( + a1: _ArrayLikeBytes_co, + a2: _ArrayLikeBytes_co, + cmp: L["<", "<=", "==", ">=", ">", "!="], + rstrip: bool, +) -> NDArray[np.bool]: ... + +def add_docstring(obj: Callable[..., Any], docstring: str, /) -> None: ... + +_GetItemKeys = L[ + "C", "CONTIGUOUS", "C_CONTIGUOUS", + "F", "FORTRAN", "F_CONTIGUOUS", + "W", "WRITEABLE", + "B", "BEHAVED", + "O", "OWNDATA", + "A", "ALIGNED", + "X", "WRITEBACKIFCOPY", + "CA", "CARRAY", + "FA", "FARRAY", + "FNC", + "FORC", +] +_SetItemKeys = L[ + "A", "ALIGNED", + "W", "WRITEABLE", + "X", "WRITEBACKIFCOPY", +] + +@final +class flagsobj: + __hash__: ClassVar[None] # type: ignore[assignment] + aligned: bool + # NOTE: deprecated + # updateifcopy: bool + writeable: bool + writebackifcopy: bool + @property + def behaved(self) -> bool: ... + @property + def c_contiguous(self) -> bool: ... + @property + def carray(self) -> bool: ... + @property + def contiguous(self) -> bool: ... + @property + def f_contiguous(self) -> bool: ... + @property + def farray(self) -> bool: ... + @property + def fnc(self) -> bool: ... + @property + def forc(self) -> bool: ... + @property + def fortran(self) -> bool: ... + @property + def num(self) -> int: ... + @property + def owndata(self) -> bool: ... + def __getitem__(self, key: _GetItemKeys) -> bool: ... + def __setitem__(self, key: _SetItemKeys, value: bool) -> None: ... + +def nested_iters( + op: ArrayLike | Sequence[ArrayLike], + axes: Sequence[Sequence[SupportsIndex]], + flags: None | Sequence[_NDIterFlagsKind] = ..., + op_flags: None | Sequence[Sequence[_NDIterOpFlagsKind]] = ..., + op_dtypes: DTypeLike | Sequence[DTypeLike] = ..., + order: _OrderKACF = ..., + casting: _CastingKind = ..., + buffersize: SupportsIndex = ..., +) -> tuple[nditer, ...]: ... diff --git a/venv/lib/python3.12/site-packages/numpy/_core/numeric.py b/venv/lib/python3.12/site-packages/numpy/_core/numeric.py new file mode 100644 index 00000000..61518d5a --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/numeric.py @@ -0,0 +1,2729 @@ +import functools +import itertools +import operator +import sys +import warnings +import numbers +import builtins +import math + +import numpy as np +from . import multiarray +from . import numerictypes as nt +from .multiarray import ( + ALLOW_THREADS, BUFSIZE, CLIP, MAXDIMS, MAY_SHARE_BOUNDS, MAY_SHARE_EXACT, + RAISE, WRAP, arange, array, asarray, asanyarray, ascontiguousarray, + asfortranarray, broadcast, can_cast, concatenate, copyto, dot, dtype, + empty, empty_like, flatiter, frombuffer, from_dlpack, fromfile, fromiter, + fromstring, inner, lexsort, matmul, may_share_memory, min_scalar_type, + ndarray, nditer, nested_iters, promote_types, putmask, result_type, + shares_memory, vdot, where, zeros, normalize_axis_index, + _get_promotion_state, _set_promotion_state, vecdot +) + +from . import overrides +from . import umath +from . import shape_base +from .overrides import set_array_function_like_doc, set_module +from .umath import (multiply, invert, sin, PINF, NAN) +from . import numerictypes +from ..exceptions import AxisError +from ._ufunc_config import errstate, _no_nep50_warning + +bitwise_not = invert +ufunc = type(sin) +newaxis = None + +array_function_dispatch = functools.partial( + overrides.array_function_dispatch, module='numpy') + + +__all__ = [ + 'newaxis', 'ndarray', 'flatiter', 'nditer', 'nested_iters', 'ufunc', + 'arange', 'array', 'asarray', 'asanyarray', 'ascontiguousarray', + 'asfortranarray', 'zeros', 'count_nonzero', 'empty', 'broadcast', 'dtype', + 'fromstring', 'fromfile', 'frombuffer', 'from_dlpack', 'where', + 'argwhere', 'copyto', 'concatenate', 'lexsort', 'astype', + 'can_cast', 'promote_types', 'min_scalar_type', + 'result_type', 'isfortran', 'empty_like', 'zeros_like', 'ones_like', + 'correlate', 'convolve', 'inner', 'dot', 'outer', 'vdot', 'roll', + 'rollaxis', 'moveaxis', 'cross', 'tensordot', 'little_endian', + 'fromiter', 'array_equal', 'array_equiv', 'indices', 'fromfunction', + 'isclose', 'isscalar', 'binary_repr', 'base_repr', 'ones', + 'identity', 'allclose', 'putmask', + 'flatnonzero', 'inf', 'nan', 'False_', 'True_', 'bitwise_not', + 'full', 'full_like', 'matmul', 'vecdot', 'shares_memory', + 'may_share_memory', '_get_promotion_state', '_set_promotion_state'] + + +def _zeros_like_dispatcher( + a, dtype=None, order=None, subok=None, shape=None, *, device=None +): + return (a,) + + +@array_function_dispatch(_zeros_like_dispatcher) +def zeros_like( + a, dtype=None, order='K', subok=True, shape=None, *, device=None +): + """ + Return an array of zeros with the same shape and type as a given array. + + Parameters + ---------- + a : array_like + The shape and data-type of `a` define these same attributes of + the returned array. + dtype : data-type, optional + Overrides the data type of the result. + + .. versionadded:: 1.6.0 + order : {'C', 'F', 'A', or 'K'}, optional + Overrides the memory layout of the result. 'C' means C-order, + 'F' means F-order, 'A' means 'F' if `a` is Fortran contiguous, + 'C' otherwise. 'K' means match the layout of `a` as closely + as possible. + + .. versionadded:: 1.6.0 + subok : bool, optional. + If True, then the newly created array will use the sub-class + type of `a`, otherwise it will be a base-class array. Defaults + to True. + shape : int or sequence of ints, optional. + Overrides the shape of the result. If order='K' and the number of + dimensions is unchanged, will try to keep order, otherwise, + order='C' is implied. + + .. versionadded:: 1.17.0 + device : str, optional + The device on which to place the created array. Default: None. + For Array-API interoperability only, so must be ``"cpu"`` if passed. + + .. versionadded:: 2.0.0 + + Returns + ------- + out : ndarray + Array of zeros with the same shape and type as `a`. + + See Also + -------- + empty_like : Return an empty array with shape and type of input. + ones_like : Return an array of ones with shape and type of input. + full_like : Return a new array with shape of input filled with value. + zeros : Return a new array setting values to zero. + + Examples + -------- + >>> import numpy as np + >>> x = np.arange(6) + >>> x = x.reshape((2, 3)) + >>> x + array([[0, 1, 2], + [3, 4, 5]]) + >>> np.zeros_like(x) + array([[0, 0, 0], + [0, 0, 0]]) + + >>> y = np.arange(3, dtype=float) + >>> y + array([0., 1., 2.]) + >>> np.zeros_like(y) + array([0., 0., 0.]) + + """ + res = empty_like( + a, dtype=dtype, order=order, subok=subok, shape=shape, device=device + ) + # needed instead of a 0 to get same result as zeros for string dtypes + z = zeros(1, dtype=res.dtype) + multiarray.copyto(res, z, casting='unsafe') + return res + + +@set_array_function_like_doc +@set_module('numpy') +def ones(shape, dtype=None, order='C', *, device=None, like=None): + """ + Return a new array of given shape and type, filled with ones. + + Parameters + ---------- + shape : int or sequence of ints + Shape of the new array, e.g., ``(2, 3)`` or ``2``. + dtype : data-type, optional + The desired data-type for the array, e.g., `numpy.int8`. Default is + `numpy.float64`. + order : {'C', 'F'}, optional, default: C + Whether to store multi-dimensional data in row-major + (C-style) or column-major (Fortran-style) order in + memory. + device : str, optional + The device on which to place the created array. Default: None. + For Array-API interoperability only, so must be ``"cpu"`` if passed. + + .. versionadded:: 2.0.0 + ${ARRAY_FUNCTION_LIKE} + + .. versionadded:: 1.20.0 + + Returns + ------- + out : ndarray + Array of ones with the given shape, dtype, and order. + + See Also + -------- + ones_like : Return an array of ones with shape and type of input. + empty : Return a new uninitialized array. + zeros : Return a new array setting values to zero. + full : Return a new array of given shape filled with value. + + Examples + -------- + >>> import numpy as np + >>> np.ones(5) + array([1., 1., 1., 1., 1.]) + + >>> np.ones((5,), dtype=int) + array([1, 1, 1, 1, 1]) + + >>> np.ones((2, 1)) + array([[1.], + [1.]]) + + >>> s = (2,2) + >>> np.ones(s) + array([[1., 1.], + [1., 1.]]) + + """ + if like is not None: + return _ones_with_like( + like, shape, dtype=dtype, order=order, device=device + ) + + a = empty(shape, dtype, order, device=device) + multiarray.copyto(a, 1, casting='unsafe') + return a + + +_ones_with_like = array_function_dispatch()(ones) + + +def _ones_like_dispatcher( + a, dtype=None, order=None, subok=None, shape=None, *, device=None +): + return (a,) + + +@array_function_dispatch(_ones_like_dispatcher) +def ones_like( + a, dtype=None, order='K', subok=True, shape=None, *, device=None +): + """ + Return an array of ones with the same shape and type as a given array. + + Parameters + ---------- + a : array_like + The shape and data-type of `a` define these same attributes of + the returned array. + dtype : data-type, optional + Overrides the data type of the result. + + .. versionadded:: 1.6.0 + order : {'C', 'F', 'A', or 'K'}, optional + Overrides the memory layout of the result. 'C' means C-order, + 'F' means F-order, 'A' means 'F' if `a` is Fortran contiguous, + 'C' otherwise. 'K' means match the layout of `a` as closely + as possible. + + .. versionadded:: 1.6.0 + subok : bool, optional. + If True, then the newly created array will use the sub-class + type of `a`, otherwise it will be a base-class array. Defaults + to True. + shape : int or sequence of ints, optional. + Overrides the shape of the result. If order='K' and the number of + dimensions is unchanged, will try to keep order, otherwise, + order='C' is implied. + + .. versionadded:: 1.17.0 + device : str, optional + The device on which to place the created array. Default: None. + For Array-API interoperability only, so must be ``"cpu"`` if passed. + + .. versionadded:: 2.0.0 + + Returns + ------- + out : ndarray + Array of ones with the same shape and type as `a`. + + See Also + -------- + empty_like : Return an empty array with shape and type of input. + zeros_like : Return an array of zeros with shape and type of input. + full_like : Return a new array with shape of input filled with value. + ones : Return a new array setting values to one. + + Examples + -------- + >>> import numpy as np + >>> x = np.arange(6) + >>> x = x.reshape((2, 3)) + >>> x + array([[0, 1, 2], + [3, 4, 5]]) + >>> np.ones_like(x) + array([[1, 1, 1], + [1, 1, 1]]) + + >>> y = np.arange(3, dtype=float) + >>> y + array([0., 1., 2.]) + >>> np.ones_like(y) + array([1., 1., 1.]) + + """ + res = empty_like( + a, dtype=dtype, order=order, subok=subok, shape=shape, device=device + ) + multiarray.copyto(res, 1, casting='unsafe') + return res + + +def _full_dispatcher( + shape, fill_value, dtype=None, order=None, *, device=None, like=None +): + return(like,) + + +@set_array_function_like_doc +@set_module('numpy') +def full(shape, fill_value, dtype=None, order='C', *, device=None, like=None): + """ + Return a new array of given shape and type, filled with `fill_value`. + + Parameters + ---------- + shape : int or sequence of ints + Shape of the new array, e.g., ``(2, 3)`` or ``2``. + fill_value : scalar or array_like + Fill value. + dtype : data-type, optional + The desired data-type for the array The default, None, means + ``np.array(fill_value).dtype``. + order : {'C', 'F'}, optional + Whether to store multidimensional data in C- or Fortran-contiguous + (row- or column-wise) order in memory. + device : str, optional + The device on which to place the created array. Default: None. + For Array-API interoperability only, so must be ``"cpu"`` if passed. + + .. versionadded:: 2.0.0 + ${ARRAY_FUNCTION_LIKE} + + .. versionadded:: 1.20.0 + + Returns + ------- + out : ndarray + Array of `fill_value` with the given shape, dtype, and order. + + See Also + -------- + full_like : Return a new array with shape of input filled with value. + empty : Return a new uninitialized array. + ones : Return a new array setting values to one. + zeros : Return a new array setting values to zero. + + Examples + -------- + >>> import numpy as np + >>> np.full((2, 2), np.inf) + array([[inf, inf], + [inf, inf]]) + >>> np.full((2, 2), 10) + array([[10, 10], + [10, 10]]) + + >>> np.full((2, 2), [1, 2]) + array([[1, 2], + [1, 2]]) + + """ + if like is not None: + return _full_with_like( + like, shape, fill_value, dtype=dtype, order=order, device=device + ) + + if dtype is None: + fill_value = asarray(fill_value) + dtype = fill_value.dtype + a = empty(shape, dtype, order, device=device) + multiarray.copyto(a, fill_value, casting='unsafe') + return a + + +_full_with_like = array_function_dispatch()(full) + + +def _full_like_dispatcher( + a, fill_value, dtype=None, order=None, subok=None, shape=None, + *, device=None +): + return (a,) + + +@array_function_dispatch(_full_like_dispatcher) +def full_like( + a, fill_value, dtype=None, order='K', subok=True, shape=None, + *, device=None +): + """ + Return a full array with the same shape and type as a given array. + + Parameters + ---------- + a : array_like + The shape and data-type of `a` define these same attributes of + the returned array. + fill_value : array_like + Fill value. + dtype : data-type, optional + Overrides the data type of the result. + order : {'C', 'F', 'A', or 'K'}, optional + Overrides the memory layout of the result. 'C' means C-order, + 'F' means F-order, 'A' means 'F' if `a` is Fortran contiguous, + 'C' otherwise. 'K' means match the layout of `a` as closely + as possible. + subok : bool, optional. + If True, then the newly created array will use the sub-class + type of `a`, otherwise it will be a base-class array. Defaults + to True. + shape : int or sequence of ints, optional. + Overrides the shape of the result. If order='K' and the number of + dimensions is unchanged, will try to keep order, otherwise, + order='C' is implied. + + .. versionadded:: 1.17.0 + device : str, optional + The device on which to place the created array. Default: None. + For Array-API interoperability only, so must be ``"cpu"`` if passed. + + .. versionadded:: 2.0.0 + + Returns + ------- + out : ndarray + Array of `fill_value` with the same shape and type as `a`. + + See Also + -------- + empty_like : Return an empty array with shape and type of input. + ones_like : Return an array of ones with shape and type of input. + zeros_like : Return an array of zeros with shape and type of input. + full : Return a new array of given shape filled with value. + + Examples + -------- + >>> import numpy as np + >>> x = np.arange(6, dtype=int) + >>> np.full_like(x, 1) + array([1, 1, 1, 1, 1, 1]) + >>> np.full_like(x, 0.1) + array([0, 0, 0, 0, 0, 0]) + >>> np.full_like(x, 0.1, dtype=np.double) + array([0.1, 0.1, 0.1, 0.1, 0.1, 0.1]) + >>> np.full_like(x, np.nan, dtype=np.double) + array([nan, nan, nan, nan, nan, nan]) + + >>> y = np.arange(6, dtype=np.double) + >>> np.full_like(y, 0.1) + array([0.1, 0.1, 0.1, 0.1, 0.1, 0.1]) + + >>> y = np.zeros([2, 2, 3], dtype=int) + >>> np.full_like(y, [0, 0, 255]) + array([[[ 0, 0, 255], + [ 0, 0, 255]], + [[ 0, 0, 255], + [ 0, 0, 255]]]) + """ + res = empty_like( + a, dtype=dtype, order=order, subok=subok, shape=shape, device=device + ) + multiarray.copyto(res, fill_value, casting='unsafe') + return res + + +def _count_nonzero_dispatcher(a, axis=None, *, keepdims=None): + return (a,) + + +@array_function_dispatch(_count_nonzero_dispatcher) +def count_nonzero(a, axis=None, *, keepdims=False): + """ + Counts the number of non-zero values in the array ``a``. + + The word "non-zero" is in reference to the Python 2.x + built-in method ``__nonzero__()`` (renamed ``__bool__()`` + in Python 3.x) of Python objects that tests an object's + "truthfulness". For example, any number is considered + truthful if it is nonzero, whereas any string is considered + truthful if it is not the empty string. Thus, this function + (recursively) counts how many elements in ``a`` (and in + sub-arrays thereof) have their ``__nonzero__()`` or ``__bool__()`` + method evaluated to ``True``. + + Parameters + ---------- + a : array_like + The array for which to count non-zeros. + axis : int or tuple, optional + Axis or tuple of axes along which to count non-zeros. + Default is None, meaning that non-zeros will be counted + along a flattened version of ``a``. + + .. versionadded:: 1.12.0 + + keepdims : bool, optional + If this is set to True, the axes that are counted are left + in the result as dimensions with size one. With this option, + the result will broadcast correctly against the input array. + + .. versionadded:: 1.19.0 + + Returns + ------- + count : int or array of int + Number of non-zero values in the array along a given axis. + Otherwise, the total number of non-zero values in the array + is returned. + + See Also + -------- + nonzero : Return the coordinates of all the non-zero values. + + Examples + -------- + >>> import numpy as np + >>> np.count_nonzero(np.eye(4)) + 4 + >>> a = np.array([[0, 1, 7, 0], + ... [3, 0, 2, 19]]) + >>> np.count_nonzero(a) + 5 + >>> np.count_nonzero(a, axis=0) + array([1, 1, 2, 1]) + >>> np.count_nonzero(a, axis=1) + array([2, 3]) + >>> np.count_nonzero(a, axis=1, keepdims=True) + array([[2], + [3]]) + """ + if axis is None and not keepdims: + return multiarray.count_nonzero(a) + + a = asanyarray(a) + + # TODO: this works around .astype(bool) not working properly (gh-9847) + if np.issubdtype(a.dtype, np.character): + a_bool = a != a.dtype.type() + else: + a_bool = a.astype(np.bool, copy=False) + + return a_bool.sum(axis=axis, dtype=np.intp, keepdims=keepdims) + + +@set_module('numpy') +def isfortran(a): + """ + Check if the array is Fortran contiguous but *not* C contiguous. + + This function is obsolete. If you only want to check if an array is Fortran + contiguous use ``a.flags.f_contiguous`` instead. + + Parameters + ---------- + a : ndarray + Input array. + + Returns + ------- + isfortran : bool + Returns True if the array is Fortran contiguous but *not* C contiguous. + + + Examples + -------- + + np.array allows to specify whether the array is written in C-contiguous + order (last index varies the fastest), or FORTRAN-contiguous order in + memory (first index varies the fastest). + + >>> import numpy as np + >>> a = np.array([[1, 2, 3], [4, 5, 6]], order='C') + >>> a + array([[1, 2, 3], + [4, 5, 6]]) + >>> np.isfortran(a) + False + + >>> b = np.array([[1, 2, 3], [4, 5, 6]], order='F') + >>> b + array([[1, 2, 3], + [4, 5, 6]]) + >>> np.isfortran(b) + True + + + The transpose of a C-ordered array is a FORTRAN-ordered array. + + >>> a = np.array([[1, 2, 3], [4, 5, 6]], order='C') + >>> a + array([[1, 2, 3], + [4, 5, 6]]) + >>> np.isfortran(a) + False + >>> b = a.T + >>> b + array([[1, 4], + [2, 5], + [3, 6]]) + >>> np.isfortran(b) + True + + C-ordered arrays evaluate as False even if they are also FORTRAN-ordered. + + >>> np.isfortran(np.array([1, 2], order='F')) + False + + """ + return a.flags.fnc + + +def _argwhere_dispatcher(a): + return (a,) + + +@array_function_dispatch(_argwhere_dispatcher) +def argwhere(a): + """ + Find the indices of array elements that are non-zero, grouped by element. + + Parameters + ---------- + a : array_like + Input data. + + Returns + ------- + index_array : (N, a.ndim) ndarray + Indices of elements that are non-zero. Indices are grouped by element. + This array will have shape ``(N, a.ndim)`` where ``N`` is the number of + non-zero items. + + See Also + -------- + where, nonzero + + Notes + ----- + ``np.argwhere(a)`` is almost the same as ``np.transpose(np.nonzero(a))``, + but produces a result of the correct shape for a 0D array. + + The output of ``argwhere`` is not suitable for indexing arrays. + For this purpose use ``nonzero(a)`` instead. + + Examples + -------- + >>> import numpy as np + >>> x = np.arange(6).reshape(2,3) + >>> x + array([[0, 1, 2], + [3, 4, 5]]) + >>> np.argwhere(x>1) + array([[0, 2], + [1, 0], + [1, 1], + [1, 2]]) + + """ + # nonzero does not behave well on 0d, so promote to 1d + if np.ndim(a) == 0: + a = shape_base.atleast_1d(a) + # then remove the added dimension + return argwhere(a)[:, :0] + return transpose(nonzero(a)) + + +def _flatnonzero_dispatcher(a): + return (a,) + + +@array_function_dispatch(_flatnonzero_dispatcher) +def flatnonzero(a): + """ + Return indices that are non-zero in the flattened version of a. + + This is equivalent to ``np.nonzero(np.ravel(a))[0]``. + + Parameters + ---------- + a : array_like + Input data. + + Returns + ------- + res : ndarray + Output array, containing the indices of the elements of ``a.ravel()`` + that are non-zero. + + See Also + -------- + nonzero : Return the indices of the non-zero elements of the input array. + ravel : Return a 1-D array containing the elements of the input array. + + Examples + -------- + >>> import numpy as np + >>> x = np.arange(-2, 3) + >>> x + array([-2, -1, 0, 1, 2]) + >>> np.flatnonzero(x) + array([0, 1, 3, 4]) + + Use the indices of the non-zero elements as an index array to extract + these elements: + + >>> x.ravel()[np.flatnonzero(x)] + array([-2, -1, 1, 2]) + + """ + return np.nonzero(np.ravel(a))[0] + + +def _correlate_dispatcher(a, v, mode=None): + return (a, v) + + +@array_function_dispatch(_correlate_dispatcher) +def correlate(a, v, mode='valid'): + r""" + Cross-correlation of two 1-dimensional sequences. + + This function computes the correlation as generally defined in signal + processing texts [1]_: + + .. math:: c_k = \sum_n a_{n+k} \cdot \overline{v}_n + + with a and v sequences being zero-padded where necessary and + :math:`\overline v` denoting complex conjugation. + + Parameters + ---------- + a, v : array_like + Input sequences. + mode : {'valid', 'same', 'full'}, optional + Refer to the `convolve` docstring. Note that the default + is 'valid', unlike `convolve`, which uses 'full'. + + Returns + ------- + out : ndarray + Discrete cross-correlation of `a` and `v`. + + See Also + -------- + convolve : Discrete, linear convolution of two one-dimensional sequences. + scipy.signal.correlate : uses FFT which has superior performance + on large arrays. + + Notes + ----- + The definition of correlation above is not unique and sometimes + correlation may be defined differently. Another common definition is [1]_: + + .. math:: c'_k = \sum_n a_{n} \cdot \overline{v_{n+k}} + + which is related to :math:`c_k` by :math:`c'_k = c_{-k}`. + + `numpy.correlate` may perform slowly in large arrays (i.e. n = 1e5) + because it does not use the FFT to compute the convolution; in that case, + `scipy.signal.correlate` might be preferable. + + References + ---------- + .. [1] Wikipedia, "Cross-correlation", + https://en.wikipedia.org/wiki/Cross-correlation + + Examples + -------- + >>> import numpy as np + >>> np.correlate([1, 2, 3], [0, 1, 0.5]) + array([3.5]) + >>> np.correlate([1, 2, 3], [0, 1, 0.5], "same") + array([2. , 3.5, 3. ]) + >>> np.correlate([1, 2, 3], [0, 1, 0.5], "full") + array([0.5, 2. , 3.5, 3. , 0. ]) + + Using complex sequences: + + >>> np.correlate([1+1j, 2, 3-1j], [0, 1, 0.5j], 'full') + array([ 0.5-0.5j, 1.0+0.j , 1.5-1.5j, 3.0-1.j , 0.0+0.j ]) + + Note that you get the time reversed, complex conjugated result + (:math:`\overline{c_{-k}}`) when the two input sequences a and v change + places: + + >>> np.correlate([0, 1, 0.5j], [1+1j, 2, 3-1j], 'full') + array([ 0.0+0.j , 3.0+1.j , 1.5+1.5j, 1.0+0.j , 0.5+0.5j]) + + """ + return multiarray.correlate2(a, v, mode) + + +def _convolve_dispatcher(a, v, mode=None): + return (a, v) + + +@array_function_dispatch(_convolve_dispatcher) +def convolve(a, v, mode='full'): + """ + Returns the discrete, linear convolution of two one-dimensional sequences. + + The convolution operator is often seen in signal processing, where it + models the effect of a linear time-invariant system on a signal [1]_. In + probability theory, the sum of two independent random variables is + distributed according to the convolution of their individual + distributions. + + If `v` is longer than `a`, the arrays are swapped before computation. + + Parameters + ---------- + a : (N,) array_like + First one-dimensional input array. + v : (M,) array_like + Second one-dimensional input array. + mode : {'full', 'valid', 'same'}, optional + 'full': + By default, mode is 'full'. This returns the convolution + at each point of overlap, with an output shape of (N+M-1,). At + the end-points of the convolution, the signals do not overlap + completely, and boundary effects may be seen. + + 'same': + Mode 'same' returns output of length ``max(M, N)``. Boundary + effects are still visible. + + 'valid': + Mode 'valid' returns output of length + ``max(M, N) - min(M, N) + 1``. The convolution product is only given + for points where the signals overlap completely. Values outside + the signal boundary have no effect. + + Returns + ------- + out : ndarray + Discrete, linear convolution of `a` and `v`. + + See Also + -------- + scipy.signal.fftconvolve : Convolve two arrays using the Fast Fourier + Transform. + scipy.linalg.toeplitz : Used to construct the convolution operator. + polymul : Polynomial multiplication. Same output as convolve, but also + accepts poly1d objects as input. + + Notes + ----- + The discrete convolution operation is defined as + + .. math:: (a * v)_n = \\sum_{m = -\\infty}^{\\infty} a_m v_{n - m} + + It can be shown that a convolution :math:`x(t) * y(t)` in time/space + is equivalent to the multiplication :math:`X(f) Y(f)` in the Fourier + domain, after appropriate padding (padding is necessary to prevent + circular convolution). Since multiplication is more efficient (faster) + than convolution, the function `scipy.signal.fftconvolve` exploits the + FFT to calculate the convolution of large data-sets. + + References + ---------- + .. [1] Wikipedia, "Convolution", + https://en.wikipedia.org/wiki/Convolution + + Examples + -------- + Note how the convolution operator flips the second array + before "sliding" the two across one another: + + >>> import numpy as np + >>> np.convolve([1, 2, 3], [0, 1, 0.5]) + array([0. , 1. , 2.5, 4. , 1.5]) + + Only return the middle values of the convolution. + Contains boundary effects, where zeros are taken + into account: + + >>> np.convolve([1,2,3],[0,1,0.5], 'same') + array([1. , 2.5, 4. ]) + + The two arrays are of the same length, so there + is only one position where they completely overlap: + + >>> np.convolve([1,2,3],[0,1,0.5], 'valid') + array([2.5]) + + """ + a, v = array(a, copy=None, ndmin=1), array(v, copy=None, ndmin=1) + if (len(v) > len(a)): + a, v = v, a + if len(a) == 0: + raise ValueError('a cannot be empty') + if len(v) == 0: + raise ValueError('v cannot be empty') + return multiarray.correlate(a, v[::-1], mode) + + +def _outer_dispatcher(a, b, out=None): + return (a, b, out) + + +@array_function_dispatch(_outer_dispatcher) +def outer(a, b, out=None): + """ + Compute the outer product of two vectors. + + Given two vectors `a` and `b` of length ``M`` and ``N``, respectively, + the outer product [1]_ is:: + + [[a_0*b_0 a_0*b_1 ... a_0*b_{N-1} ] + [a_1*b_0 . + [ ... . + [a_{M-1}*b_0 a_{M-1}*b_{N-1} ]] + + Parameters + ---------- + a : (M,) array_like + First input vector. Input is flattened if + not already 1-dimensional. + b : (N,) array_like + Second input vector. Input is flattened if + not already 1-dimensional. + out : (M, N) ndarray, optional + A location where the result is stored + + .. versionadded:: 1.9.0 + + Returns + ------- + out : (M, N) ndarray + ``out[i, j] = a[i] * b[j]`` + + See also + -------- + inner + einsum : ``einsum('i,j->ij', a.ravel(), b.ravel())`` is the equivalent. + ufunc.outer : A generalization to dimensions other than 1D and other + operations. ``np.multiply.outer(a.ravel(), b.ravel())`` + is the equivalent. + linalg.outer : An Array API compatible variation of ``np.outer``, + which accepts 1-dimensional inputs only. + tensordot : ``np.tensordot(a.ravel(), b.ravel(), axes=((), ()))`` + is the equivalent. + + References + ---------- + .. [1] G. H. Golub and C. F. Van Loan, *Matrix Computations*, 3rd + ed., Baltimore, MD, Johns Hopkins University Press, 1996, + pg. 8. + + Examples + -------- + Make a (*very* coarse) grid for computing a Mandelbrot set: + + >>> import numpy as np + >>> rl = np.outer(np.ones((5,)), np.linspace(-2, 2, 5)) + >>> rl + array([[-2., -1., 0., 1., 2.], + [-2., -1., 0., 1., 2.], + [-2., -1., 0., 1., 2.], + [-2., -1., 0., 1., 2.], + [-2., -1., 0., 1., 2.]]) + >>> im = np.outer(1j*np.linspace(2, -2, 5), np.ones((5,))) + >>> im + array([[0.+2.j, 0.+2.j, 0.+2.j, 0.+2.j, 0.+2.j], + [0.+1.j, 0.+1.j, 0.+1.j, 0.+1.j, 0.+1.j], + [0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j], + [0.-1.j, 0.-1.j, 0.-1.j, 0.-1.j, 0.-1.j], + [0.-2.j, 0.-2.j, 0.-2.j, 0.-2.j, 0.-2.j]]) + >>> grid = rl + im + >>> grid + array([[-2.+2.j, -1.+2.j, 0.+2.j, 1.+2.j, 2.+2.j], + [-2.+1.j, -1.+1.j, 0.+1.j, 1.+1.j, 2.+1.j], + [-2.+0.j, -1.+0.j, 0.+0.j, 1.+0.j, 2.+0.j], + [-2.-1.j, -1.-1.j, 0.-1.j, 1.-1.j, 2.-1.j], + [-2.-2.j, -1.-2.j, 0.-2.j, 1.-2.j, 2.-2.j]]) + + An example using a "vector" of letters: + + >>> x = np.array(['a', 'b', 'c'], dtype=object) + >>> np.outer(x, [1, 2, 3]) + array([['a', 'aa', 'aaa'], + ['b', 'bb', 'bbb'], + ['c', 'cc', 'ccc']], dtype=object) + + """ + a = asarray(a) + b = asarray(b) + return multiply(a.ravel()[:, newaxis], b.ravel()[newaxis, :], out) + + +def _tensordot_dispatcher(a, b, axes=None): + return (a, b) + + +@array_function_dispatch(_tensordot_dispatcher) +def tensordot(a, b, axes=2): + """ + Compute tensor dot product along specified axes. + + Given two tensors, `a` and `b`, and an array_like object containing + two array_like objects, ``(a_axes, b_axes)``, sum the products of + `a`'s and `b`'s elements (components) over the axes specified by + ``a_axes`` and ``b_axes``. The third argument can be a single non-negative + integer_like scalar, ``N``; if it is such, then the last ``N`` dimensions + of `a` and the first ``N`` dimensions of `b` are summed over. + + Parameters + ---------- + a, b : array_like + Tensors to "dot". + + axes : int or (2,) array_like + * integer_like + If an int N, sum over the last N axes of `a` and the first N axes + of `b` in order. The sizes of the corresponding axes must match. + * (2,) array_like + Or, a list of axes to be summed over, first sequence applying to `a`, + second to `b`. Both elements array_like must be of the same length. + + Returns + ------- + output : ndarray + The tensor dot product of the input. + + See Also + -------- + dot, einsum + + Notes + ----- + Three common use cases are: + + * ``axes = 0`` : tensor product :math:`a\\otimes b` + * ``axes = 1`` : tensor dot product :math:`a\\cdot b` + * ``axes = 2`` : (default) tensor double contraction :math:`a:b` + + When `axes` is a positive integer ``N``, the operation starts with + axis ``-N`` of `a` and axis ``0`` of `b`, and it continues through + axis ``-1`` of `a` and axis ``N-1`` of `b` (inclusive). + + When there is more than one axis to sum over - and they are not the last + (first) axes of `a` (`b`) - the argument `axes` should consist of + two sequences of the same length, with the first axis to sum over given + first in both sequences, the second axis second, and so forth. + + The shape of the result consists of the non-contracted axes of the + first tensor, followed by the non-contracted axes of the second. + + Examples + -------- + A "traditional" example: + + >>> import numpy as np + >>> a = np.arange(60.).reshape(3,4,5) + >>> b = np.arange(24.).reshape(4,3,2) + >>> c = np.tensordot(a,b, axes=([1,0],[0,1])) + >>> c.shape + (5, 2) + >>> c + array([[4400., 4730.], + [4532., 4874.], + [4664., 5018.], + [4796., 5162.], + [4928., 5306.]]) + >>> # A slower but equivalent way of computing the same... + >>> d = np.zeros((5,2)) + >>> for i in range(5): + ... for j in range(2): + ... for k in range(3): + ... for n in range(4): + ... d[i,j] += a[k,n,i] * b[n,k,j] + >>> c == d + array([[ True, True], + [ True, True], + [ True, True], + [ True, True], + [ True, True]]) + + An extended example taking advantage of the overloading of + and \\*: + + >>> a = np.array(range(1, 9)) + >>> a.shape = (2, 2, 2) + >>> A = np.array(('a', 'b', 'c', 'd'), dtype=object) + >>> A.shape = (2, 2) + >>> a; A + array([[[1, 2], + [3, 4]], + [[5, 6], + [7, 8]]]) + array([['a', 'b'], + ['c', 'd']], dtype=object) + + >>> np.tensordot(a, A) # third argument default is 2 for double-contraction + array(['abbcccdddd', 'aaaaabbbbbbcccccccdddddddd'], dtype=object) + + >>> np.tensordot(a, A, 1) + array([[['acc', 'bdd'], + ['aaacccc', 'bbbdddd']], + [['aaaaacccccc', 'bbbbbdddddd'], + ['aaaaaaacccccccc', 'bbbbbbbdddddddd']]], dtype=object) + + >>> np.tensordot(a, A, 0) # tensor product (result too long to incl.) + array([[[[['a', 'b'], + ['c', 'd']], + ... + + >>> np.tensordot(a, A, (0, 1)) + array([[['abbbbb', 'cddddd'], + ['aabbbbbb', 'ccdddddd']], + [['aaabbbbbbb', 'cccddddddd'], + ['aaaabbbbbbbb', 'ccccdddddddd']]], dtype=object) + + >>> np.tensordot(a, A, (2, 1)) + array([[['abb', 'cdd'], + ['aaabbbb', 'cccdddd']], + [['aaaaabbbbbb', 'cccccdddddd'], + ['aaaaaaabbbbbbbb', 'cccccccdddddddd']]], dtype=object) + + >>> np.tensordot(a, A, ((0, 1), (0, 1))) + array(['abbbcccccddddddd', 'aabbbbccccccdddddddd'], dtype=object) + + >>> np.tensordot(a, A, ((2, 1), (1, 0))) + array(['acccbbdddd', 'aaaaacccccccbbbbbbdddddddd'], dtype=object) + + """ + try: + iter(axes) + except Exception: + axes_a = list(range(-axes, 0)) + axes_b = list(range(0, axes)) + else: + axes_a, axes_b = axes + try: + na = len(axes_a) + axes_a = list(axes_a) + except TypeError: + axes_a = [axes_a] + na = 1 + try: + nb = len(axes_b) + axes_b = list(axes_b) + except TypeError: + axes_b = [axes_b] + nb = 1 + + a, b = asarray(a), asarray(b) + as_ = a.shape + nda = a.ndim + bs = b.shape + ndb = b.ndim + equal = True + if na != nb: + equal = False + else: + for k in range(na): + if as_[axes_a[k]] != bs[axes_b[k]]: + equal = False + break + if axes_a[k] < 0: + axes_a[k] += nda + if axes_b[k] < 0: + axes_b[k] += ndb + if not equal: + raise ValueError("shape-mismatch for sum") + + # Move the axes to sum over to the end of "a" + # and to the front of "b" + notin = [k for k in range(nda) if k not in axes_a] + newaxes_a = notin + axes_a + N2 = math.prod(as_[axis] for axis in axes_a) + newshape_a = (math.prod([as_[ax] for ax in notin]), N2) + olda = [as_[axis] for axis in notin] + + notin = [k for k in range(ndb) if k not in axes_b] + newaxes_b = axes_b + notin + N2 = math.prod(bs[axis] for axis in axes_b) + newshape_b = (N2, math.prod([bs[ax] for ax in notin])) + oldb = [bs[axis] for axis in notin] + + at = a.transpose(newaxes_a).reshape(newshape_a) + bt = b.transpose(newaxes_b).reshape(newshape_b) + res = dot(at, bt) + return res.reshape(olda + oldb) + + +def _roll_dispatcher(a, shift, axis=None): + return (a,) + + +@array_function_dispatch(_roll_dispatcher) +def roll(a, shift, axis=None): + """ + Roll array elements along a given axis. + + Elements that roll beyond the last position are re-introduced at + the first. + + Parameters + ---------- + a : array_like + Input array. + shift : int or tuple of ints + The number of places by which elements are shifted. If a tuple, + then `axis` must be a tuple of the same size, and each of the + given axes is shifted by the corresponding number. If an int + while `axis` is a tuple of ints, then the same value is used for + all given axes. + axis : int or tuple of ints, optional + Axis or axes along which elements are shifted. By default, the + array is flattened before shifting, after which the original + shape is restored. + + Returns + ------- + res : ndarray + Output array, with the same shape as `a`. + + See Also + -------- + rollaxis : Roll the specified axis backwards, until it lies in a + given position. + + Notes + ----- + .. versionadded:: 1.12.0 + + Supports rolling over multiple dimensions simultaneously. + + Examples + -------- + >>> import numpy as np + >>> x = np.arange(10) + >>> np.roll(x, 2) + array([8, 9, 0, 1, 2, 3, 4, 5, 6, 7]) + >>> np.roll(x, -2) + array([2, 3, 4, 5, 6, 7, 8, 9, 0, 1]) + + >>> x2 = np.reshape(x, (2, 5)) + >>> x2 + array([[0, 1, 2, 3, 4], + [5, 6, 7, 8, 9]]) + >>> np.roll(x2, 1) + array([[9, 0, 1, 2, 3], + [4, 5, 6, 7, 8]]) + >>> np.roll(x2, -1) + array([[1, 2, 3, 4, 5], + [6, 7, 8, 9, 0]]) + >>> np.roll(x2, 1, axis=0) + array([[5, 6, 7, 8, 9], + [0, 1, 2, 3, 4]]) + >>> np.roll(x2, -1, axis=0) + array([[5, 6, 7, 8, 9], + [0, 1, 2, 3, 4]]) + >>> np.roll(x2, 1, axis=1) + array([[4, 0, 1, 2, 3], + [9, 5, 6, 7, 8]]) + >>> np.roll(x2, -1, axis=1) + array([[1, 2, 3, 4, 0], + [6, 7, 8, 9, 5]]) + >>> np.roll(x2, (1, 1), axis=(1, 0)) + array([[9, 5, 6, 7, 8], + [4, 0, 1, 2, 3]]) + >>> np.roll(x2, (2, 1), axis=(1, 0)) + array([[8, 9, 5, 6, 7], + [3, 4, 0, 1, 2]]) + + """ + a = asanyarray(a) + if axis is None: + return roll(a.ravel(), shift, 0).reshape(a.shape) + + else: + axis = normalize_axis_tuple(axis, a.ndim, allow_duplicate=True) + broadcasted = broadcast(shift, axis) + if broadcasted.ndim > 1: + raise ValueError( + "'shift' and 'axis' should be scalars or 1D sequences") + shifts = {ax: 0 for ax in range(a.ndim)} + for sh, ax in broadcasted: + shifts[ax] += int(sh) + + rolls = [((slice(None), slice(None)),)] * a.ndim + for ax, offset in shifts.items(): + offset %= a.shape[ax] or 1 # If `a` is empty, nothing matters. + if offset: + # (original, result), (original, result) + rolls[ax] = ((slice(None, -offset), slice(offset, None)), + (slice(-offset, None), slice(None, offset))) + + result = empty_like(a) + for indices in itertools.product(*rolls): + arr_index, res_index = zip(*indices) + result[res_index] = a[arr_index] + + return result + + +def _rollaxis_dispatcher(a, axis, start=None): + return (a,) + + +@array_function_dispatch(_rollaxis_dispatcher) +def rollaxis(a, axis, start=0): + """ + Roll the specified axis backwards, until it lies in a given position. + + This function continues to be supported for backward compatibility, but you + should prefer `moveaxis`. The `moveaxis` function was added in NumPy + 1.11. + + Parameters + ---------- + a : ndarray + Input array. + axis : int + The axis to be rolled. The positions of the other axes do not + change relative to one another. + start : int, optional + When ``start <= axis``, the axis is rolled back until it lies in + this position. When ``start > axis``, the axis is rolled until it + lies before this position. The default, 0, results in a "complete" + roll. The following table describes how negative values of ``start`` + are interpreted: + + .. table:: + :align: left + + +-------------------+----------------------+ + | ``start`` | Normalized ``start`` | + +===================+======================+ + | ``-(arr.ndim+1)`` | raise ``AxisError`` | + +-------------------+----------------------+ + | ``-arr.ndim`` | 0 | + +-------------------+----------------------+ + | |vdots| | |vdots| | + +-------------------+----------------------+ + | ``-1`` | ``arr.ndim-1`` | + +-------------------+----------------------+ + | ``0`` | ``0`` | + +-------------------+----------------------+ + | |vdots| | |vdots| | + +-------------------+----------------------+ + | ``arr.ndim`` | ``arr.ndim`` | + +-------------------+----------------------+ + | ``arr.ndim + 1`` | raise ``AxisError`` | + +-------------------+----------------------+ + + .. |vdots| unicode:: U+22EE .. Vertical Ellipsis + + Returns + ------- + res : ndarray + For NumPy >= 1.10.0 a view of `a` is always returned. For earlier + NumPy versions a view of `a` is returned only if the order of the + axes is changed, otherwise the input array is returned. + + See Also + -------- + moveaxis : Move array axes to new positions. + roll : Roll the elements of an array by a number of positions along a + given axis. + + Examples + -------- + >>> import numpy as np + >>> a = np.ones((3,4,5,6)) + >>> np.rollaxis(a, 3, 1).shape + (3, 6, 4, 5) + >>> np.rollaxis(a, 2).shape + (5, 3, 4, 6) + >>> np.rollaxis(a, 1, 4).shape + (3, 5, 6, 4) + + """ + n = a.ndim + axis = normalize_axis_index(axis, n) + if start < 0: + start += n + msg = "'%s' arg requires %d <= %s < %d, but %d was passed in" + if not (0 <= start < n + 1): + raise AxisError(msg % ('start', -n, 'start', n + 1, start)) + if axis < start: + # it's been removed + start -= 1 + if axis == start: + return a[...] + axes = list(range(0, n)) + axes.remove(axis) + axes.insert(start, axis) + return a.transpose(axes) + + +@set_module("numpy.lib.array_utils") +def normalize_axis_tuple(axis, ndim, argname=None, allow_duplicate=False): + """ + Normalizes an axis argument into a tuple of non-negative integer axes. + + This handles shorthands such as ``1`` and converts them to ``(1,)``, + as well as performing the handling of negative indices covered by + `normalize_axis_index`. + + By default, this forbids axes from being specified multiple times. + + Used internally by multi-axis-checking logic. + + .. versionadded:: 1.13.0 + + Parameters + ---------- + axis : int, iterable of int + The un-normalized index or indices of the axis. + ndim : int + The number of dimensions of the array that `axis` should be normalized + against. + argname : str, optional + A prefix to put before the error message, typically the name of the + argument. + allow_duplicate : bool, optional + If False, the default, disallow an axis from being specified twice. + + Returns + ------- + normalized_axes : tuple of int + The normalized axis index, such that `0 <= normalized_axis < ndim` + + Raises + ------ + AxisError + If any axis provided is out of range + ValueError + If an axis is repeated + + See also + -------- + normalize_axis_index : normalizing a single scalar axis + """ + # Optimization to speed-up the most common cases. + if type(axis) not in (tuple, list): + try: + axis = [operator.index(axis)] + except TypeError: + pass + # Going via an iterator directly is slower than via list comprehension. + axis = tuple([normalize_axis_index(ax, ndim, argname) for ax in axis]) + if not allow_duplicate and len(set(axis)) != len(axis): + if argname: + raise ValueError('repeated axis in `{}` argument'.format(argname)) + else: + raise ValueError('repeated axis') + return axis + + +def _moveaxis_dispatcher(a, source, destination): + return (a,) + + +@array_function_dispatch(_moveaxis_dispatcher) +def moveaxis(a, source, destination): + """ + Move axes of an array to new positions. + + Other axes remain in their original order. + + .. versionadded:: 1.11.0 + + Parameters + ---------- + a : np.ndarray + The array whose axes should be reordered. + source : int or sequence of int + Original positions of the axes to move. These must be unique. + destination : int or sequence of int + Destination positions for each of the original axes. These must also be + unique. + + Returns + ------- + result : np.ndarray + Array with moved axes. This array is a view of the input array. + + See Also + -------- + transpose : Permute the dimensions of an array. + swapaxes : Interchange two axes of an array. + + Examples + -------- + >>> import numpy as np + >>> x = np.zeros((3, 4, 5)) + >>> np.moveaxis(x, 0, -1).shape + (4, 5, 3) + >>> np.moveaxis(x, -1, 0).shape + (5, 3, 4) + + These all achieve the same result: + + >>> np.transpose(x).shape + (5, 4, 3) + >>> np.swapaxes(x, 0, -1).shape + (5, 4, 3) + >>> np.moveaxis(x, [0, 1], [-1, -2]).shape + (5, 4, 3) + >>> np.moveaxis(x, [0, 1, 2], [-1, -2, -3]).shape + (5, 4, 3) + + """ + try: + # allow duck-array types if they define transpose + transpose = a.transpose + except AttributeError: + a = asarray(a) + transpose = a.transpose + + source = normalize_axis_tuple(source, a.ndim, 'source') + destination = normalize_axis_tuple(destination, a.ndim, 'destination') + if len(source) != len(destination): + raise ValueError('`source` and `destination` arguments must have ' + 'the same number of elements') + + order = [n for n in range(a.ndim) if n not in source] + + for dest, src in sorted(zip(destination, source)): + order.insert(dest, src) + + result = transpose(order) + return result + + +def _cross_dispatcher(a, b, axisa=None, axisb=None, axisc=None, axis=None): + return (a, b) + + +@array_function_dispatch(_cross_dispatcher) +def cross(a, b, axisa=-1, axisb=-1, axisc=-1, axis=None): + """ + Return the cross product of two (arrays of) vectors. + + The cross product of `a` and `b` in :math:`R^3` is a vector perpendicular + to both `a` and `b`. If `a` and `b` are arrays of vectors, the vectors + are defined by the last axis of `a` and `b` by default, and these axes + can have dimensions 2 or 3. Where the dimension of either `a` or `b` is + 2, the third component of the input vector is assumed to be zero and the + cross product calculated accordingly. In cases where both input vectors + have dimension 2, the z-component of the cross product is returned. + + Parameters + ---------- + a : array_like + Components of the first vector(s). + b : array_like + Components of the second vector(s). + axisa : int, optional + Axis of `a` that defines the vector(s). By default, the last axis. + axisb : int, optional + Axis of `b` that defines the vector(s). By default, the last axis. + axisc : int, optional + Axis of `c` containing the cross product vector(s). Ignored if + both input vectors have dimension 2, as the return is scalar. + By default, the last axis. + axis : int, optional + If defined, the axis of `a`, `b` and `c` that defines the vector(s) + and cross product(s). Overrides `axisa`, `axisb` and `axisc`. + + Returns + ------- + c : ndarray + Vector cross product(s). + + Raises + ------ + ValueError + When the dimension of the vector(s) in `a` and/or `b` does not + equal 2 or 3. + + See Also + -------- + inner : Inner product + outer : Outer product. + linalg.cross : An Array API compatible variation of ``np.cross``, + which accepts (arrays of) 3-element vectors only. + ix_ : Construct index arrays. + + Notes + ----- + .. versionadded:: 1.9.0 + + Supports full broadcasting of the inputs. + + Dimension-2 input arrays were deprecated in 2.0.0. If you do need this + functionality, you can use:: + + def cross2d(x, y): + return x[..., 0] * y[..., 1] - x[..., 1] * y[..., 0] + + Examples + -------- + Vector cross-product. + + >>> import numpy as np + >>> x = [1, 2, 3] + >>> y = [4, 5, 6] + >>> np.cross(x, y) + array([-3, 6, -3]) + + One vector with dimension 2. + + >>> x = [1, 2] + >>> y = [4, 5, 6] + >>> np.cross(x, y) + array([12, -6, -3]) + + Equivalently: + + >>> x = [1, 2, 0] + >>> y = [4, 5, 6] + >>> np.cross(x, y) + array([12, -6, -3]) + + Both vectors with dimension 2. + + >>> x = [1,2] + >>> y = [4,5] + >>> np.cross(x, y) + array(-3) + + Multiple vector cross-products. Note that the direction of the cross + product vector is defined by the *right-hand rule*. + + >>> x = np.array([[1,2,3], [4,5,6]]) + >>> y = np.array([[4,5,6], [1,2,3]]) + >>> np.cross(x, y) + array([[-3, 6, -3], + [ 3, -6, 3]]) + + The orientation of `c` can be changed using the `axisc` keyword. + + >>> np.cross(x, y, axisc=0) + array([[-3, 3], + [ 6, -6], + [-3, 3]]) + + Change the vector definition of `x` and `y` using `axisa` and `axisb`. + + >>> x = np.array([[1,2,3], [4,5,6], [7, 8, 9]]) + >>> y = np.array([[7, 8, 9], [4,5,6], [1,2,3]]) + >>> np.cross(x, y) + array([[ -6, 12, -6], + [ 0, 0, 0], + [ 6, -12, 6]]) + >>> np.cross(x, y, axisa=0, axisb=0) + array([[-24, 48, -24], + [-30, 60, -30], + [-36, 72, -36]]) + + """ + if axis is not None: + axisa, axisb, axisc = (axis,) * 3 + a = asarray(a) + b = asarray(b) + + if (a.ndim < 1) or (b.ndim < 1): + raise ValueError("At least one array has zero dimension") + + # Check axisa and axisb are within bounds + axisa = normalize_axis_index(axisa, a.ndim, msg_prefix='axisa') + axisb = normalize_axis_index(axisb, b.ndim, msg_prefix='axisb') + + # Move working axis to the end of the shape + a = moveaxis(a, axisa, -1) + b = moveaxis(b, axisb, -1) + msg = ("incompatible dimensions for cross product\n" + "(dimension must be 2 or 3)") + if a.shape[-1] not in (2, 3) or b.shape[-1] not in (2, 3): + raise ValueError(msg) + if a.shape[-1] == 2 or b.shape[-1] == 2: + # Deprecated in NumPy 2.0, 2023-09-26 + warnings.warn( + "Arrays of 2-dimensional vectors are deprecated. Use arrays of " + "3-dimensional vectors instead. (deprecated in NumPy 2.0)", + DeprecationWarning, stacklevel=2 + ) + + # Create the output array + shape = broadcast(a[..., 0], b[..., 0]).shape + if a.shape[-1] == 3 or b.shape[-1] == 3: + shape += (3,) + # Check axisc is within bounds + axisc = normalize_axis_index(axisc, len(shape), msg_prefix='axisc') + dtype = promote_types(a.dtype, b.dtype) + cp = empty(shape, dtype) + + # recast arrays as dtype + a = a.astype(dtype) + b = b.astype(dtype) + + # create local aliases for readability + a0 = a[..., 0] + a1 = a[..., 1] + if a.shape[-1] == 3: + a2 = a[..., 2] + b0 = b[..., 0] + b1 = b[..., 1] + if b.shape[-1] == 3: + b2 = b[..., 2] + if cp.ndim != 0 and cp.shape[-1] == 3: + cp0 = cp[..., 0] + cp1 = cp[..., 1] + cp2 = cp[..., 2] + + if a.shape[-1] == 2: + if b.shape[-1] == 2: + # a0 * b1 - a1 * b0 + multiply(a0, b1, out=cp) + cp -= a1 * b0 + return cp + else: + assert b.shape[-1] == 3 + # cp0 = a1 * b2 - 0 (a2 = 0) + # cp1 = 0 - a0 * b2 (a2 = 0) + # cp2 = a0 * b1 - a1 * b0 + multiply(a1, b2, out=cp0) + multiply(a0, b2, out=cp1) + negative(cp1, out=cp1) + multiply(a0, b1, out=cp2) + cp2 -= a1 * b0 + else: + assert a.shape[-1] == 3 + if b.shape[-1] == 3: + # cp0 = a1 * b2 - a2 * b1 + # cp1 = a2 * b0 - a0 * b2 + # cp2 = a0 * b1 - a1 * b0 + multiply(a1, b2, out=cp0) + tmp = array(a2 * b1) + cp0 -= tmp + multiply(a2, b0, out=cp1) + multiply(a0, b2, out=tmp) + cp1 -= tmp + multiply(a0, b1, out=cp2) + multiply(a1, b0, out=tmp) + cp2 -= tmp + else: + assert b.shape[-1] == 2 + # cp0 = 0 - a2 * b1 (b2 = 0) + # cp1 = a2 * b0 - 0 (b2 = 0) + # cp2 = a0 * b1 - a1 * b0 + multiply(a2, b1, out=cp0) + negative(cp0, out=cp0) + multiply(a2, b0, out=cp1) + multiply(a0, b1, out=cp2) + cp2 -= a1 * b0 + + return moveaxis(cp, -1, axisc) + + +little_endian = (sys.byteorder == 'little') + + +@set_module('numpy') +def indices(dimensions, dtype=int, sparse=False): + """ + Return an array representing the indices of a grid. + + Compute an array where the subarrays contain index values 0, 1, ... + varying only along the corresponding axis. + + Parameters + ---------- + dimensions : sequence of ints + The shape of the grid. + dtype : dtype, optional + Data type of the result. + sparse : boolean, optional + Return a sparse representation of the grid instead of a dense + representation. Default is False. + + .. versionadded:: 1.17 + + Returns + ------- + grid : one ndarray or tuple of ndarrays + If sparse is False: + Returns one array of grid indices, + ``grid.shape = (len(dimensions),) + tuple(dimensions)``. + If sparse is True: + Returns a tuple of arrays, with + ``grid[i].shape = (1, ..., 1, dimensions[i], 1, ..., 1)`` with + dimensions[i] in the ith place + + See Also + -------- + mgrid, ogrid, meshgrid + + Notes + ----- + The output shape in the dense case is obtained by prepending the number + of dimensions in front of the tuple of dimensions, i.e. if `dimensions` + is a tuple ``(r0, ..., rN-1)`` of length ``N``, the output shape is + ``(N, r0, ..., rN-1)``. + + The subarrays ``grid[k]`` contains the N-D array of indices along the + ``k-th`` axis. Explicitly:: + + grid[k, i0, i1, ..., iN-1] = ik + + Examples + -------- + >>> import numpy as np + >>> grid = np.indices((2, 3)) + >>> grid.shape + (2, 2, 3) + >>> grid[0] # row indices + array([[0, 0, 0], + [1, 1, 1]]) + >>> grid[1] # column indices + array([[0, 1, 2], + [0, 1, 2]]) + + The indices can be used as an index into an array. + + >>> x = np.arange(20).reshape(5, 4) + >>> row, col = np.indices((2, 3)) + >>> x[row, col] + array([[0, 1, 2], + [4, 5, 6]]) + + Note that it would be more straightforward in the above example to + extract the required elements directly with ``x[:2, :3]``. + + If sparse is set to true, the grid will be returned in a sparse + representation. + + >>> i, j = np.indices((2, 3), sparse=True) + >>> i.shape + (2, 1) + >>> j.shape + (1, 3) + >>> i # row indices + array([[0], + [1]]) + >>> j # column indices + array([[0, 1, 2]]) + + """ + dimensions = tuple(dimensions) + N = len(dimensions) + shape = (1,)*N + if sparse: + res = tuple() + else: + res = empty((N,)+dimensions, dtype=dtype) + for i, dim in enumerate(dimensions): + idx = arange(dim, dtype=dtype).reshape( + shape[:i] + (dim,) + shape[i+1:] + ) + if sparse: + res = res + (idx,) + else: + res[i] = idx + return res + + +@set_array_function_like_doc +@set_module('numpy') +def fromfunction(function, shape, *, dtype=float, like=None, **kwargs): + """ + Construct an array by executing a function over each coordinate. + + The resulting array therefore has a value ``fn(x, y, z)`` at + coordinate ``(x, y, z)``. + + Parameters + ---------- + function : callable + The function is called with N parameters, where N is the rank of + `shape`. Each parameter represents the coordinates of the array + varying along a specific axis. For example, if `shape` + were ``(2, 2)``, then the parameters would be + ``array([[0, 0], [1, 1]])`` and ``array([[0, 1], [0, 1]])`` + shape : (N,) tuple of ints + Shape of the output array, which also determines the shape of + the coordinate arrays passed to `function`. + dtype : data-type, optional + Data-type of the coordinate arrays passed to `function`. + By default, `dtype` is float. + ${ARRAY_FUNCTION_LIKE} + + .. versionadded:: 1.20.0 + + Returns + ------- + fromfunction : any + The result of the call to `function` is passed back directly. + Therefore the shape of `fromfunction` is completely determined by + `function`. If `function` returns a scalar value, the shape of + `fromfunction` would not match the `shape` parameter. + + See Also + -------- + indices, meshgrid + + Notes + ----- + Keywords other than `dtype` and `like` are passed to `function`. + + Examples + -------- + >>> import numpy as np + >>> np.fromfunction(lambda i, j: i, (2, 2), dtype=float) + array([[0., 0.], + [1., 1.]]) + + >>> np.fromfunction(lambda i, j: j, (2, 2), dtype=float) + array([[0., 1.], + [0., 1.]]) + + >>> np.fromfunction(lambda i, j: i == j, (3, 3), dtype=int) + array([[ True, False, False], + [False, True, False], + [False, False, True]]) + + >>> np.fromfunction(lambda i, j: i + j, (3, 3), dtype=int) + array([[0, 1, 2], + [1, 2, 3], + [2, 3, 4]]) + + """ + if like is not None: + return _fromfunction_with_like( + like, function, shape, dtype=dtype, **kwargs) + + args = indices(shape, dtype=dtype) + return function(*args, **kwargs) + + +_fromfunction_with_like = array_function_dispatch()(fromfunction) + + +def _frombuffer(buf, dtype, shape, order): + return frombuffer(buf, dtype=dtype).reshape(shape, order=order) + + +@set_module('numpy') +def isscalar(element): + """ + Returns True if the type of `element` is a scalar type. + + Parameters + ---------- + element : any + Input argument, can be of any type and shape. + + Returns + ------- + val : bool + True if `element` is a scalar type, False if it is not. + + See Also + -------- + ndim : Get the number of dimensions of an array + + Notes + ----- + If you need a stricter way to identify a *numerical* scalar, use + ``isinstance(x, numbers.Number)``, as that returns ``False`` for most + non-numerical elements such as strings. + + In most cases ``np.ndim(x) == 0`` should be used instead of this function, + as that will also return true for 0d arrays. This is how numpy overloads + functions in the style of the ``dx`` arguments to `gradient` and + the ``bins`` argument to `histogram`. Some key differences: + + +------------------------------------+---------------+-------------------+ + | x |``isscalar(x)``|``np.ndim(x) == 0``| + +====================================+===============+===================+ + | PEP 3141 numeric objects | ``True`` | ``True`` | + | (including builtins) | | | + +------------------------------------+---------------+-------------------+ + | builtin string and buffer objects | ``True`` | ``True`` | + +------------------------------------+---------------+-------------------+ + | other builtin objects, like | ``False`` | ``True`` | + | `pathlib.Path`, `Exception`, | | | + | the result of `re.compile` | | | + +------------------------------------+---------------+-------------------+ + | third-party objects like | ``False`` | ``True`` | + | `matplotlib.figure.Figure` | | | + +------------------------------------+---------------+-------------------+ + | zero-dimensional numpy arrays | ``False`` | ``True`` | + +------------------------------------+---------------+-------------------+ + | other numpy arrays | ``False`` | ``False`` | + +------------------------------------+---------------+-------------------+ + | `list`, `tuple`, and other | ``False`` | ``False`` | + | sequence objects | | | + +------------------------------------+---------------+-------------------+ + + Examples + -------- + >>> import numpy as np + + >>> np.isscalar(3.1) + True + + >>> np.isscalar(np.array(3.1)) + False + + >>> np.isscalar([3.1]) + False + + >>> np.isscalar(False) + True + + >>> np.isscalar('numpy') + True + + NumPy supports PEP 3141 numbers: + + >>> from fractions import Fraction + >>> np.isscalar(Fraction(5, 17)) + True + >>> from numbers import Number + >>> np.isscalar(Number()) + True + + """ + return (isinstance(element, generic) + or type(element) in ScalarType + or isinstance(element, numbers.Number)) + + +@set_module('numpy') +def binary_repr(num, width=None): + """ + Return the binary representation of the input number as a string. + + For negative numbers, if width is not given, a minus sign is added to the + front. If width is given, the two's complement of the number is + returned, with respect to that width. + + In a two's-complement system negative numbers are represented by the two's + complement of the absolute value. This is the most common method of + representing signed integers on computers [1]_. A N-bit two's-complement + system can represent every integer in the range + :math:`-2^{N-1}` to :math:`+2^{N-1}-1`. + + Parameters + ---------- + num : int + Only an integer decimal number can be used. + width : int, optional + The length of the returned string if `num` is positive, or the length + of the two's complement if `num` is negative, provided that `width` is + at least a sufficient number of bits for `num` to be represented in + the designated form. If the `width` value is insufficient, an error is + raised. + + Returns + ------- + bin : str + Binary representation of `num` or two's complement of `num`. + + See Also + -------- + base_repr: Return a string representation of a number in the given base + system. + bin: Python's built-in binary representation generator of an integer. + + Notes + ----- + `binary_repr` is equivalent to using `base_repr` with base 2, but about 25x + faster. + + References + ---------- + .. [1] Wikipedia, "Two's complement", + https://en.wikipedia.org/wiki/Two's_complement + + Examples + -------- + >>> import numpy as np + >>> np.binary_repr(3) + '11' + >>> np.binary_repr(-3) + '-11' + >>> np.binary_repr(3, width=4) + '0011' + + The two's complement is returned when the input number is negative and + width is specified: + + >>> np.binary_repr(-3, width=3) + '101' + >>> np.binary_repr(-3, width=5) + '11101' + + """ + def err_if_insufficient(width, binwidth): + if width is not None and width < binwidth: + raise ValueError( + f"Insufficient bit {width=} provided for {binwidth=}" + ) + + # Ensure that num is a Python integer to avoid overflow or unwanted + # casts to floating point. + num = operator.index(num) + + if num == 0: + return '0' * (width or 1) + + elif num > 0: + binary = bin(num)[2:] + binwidth = len(binary) + outwidth = (binwidth if width is None + else builtins.max(binwidth, width)) + err_if_insufficient(width, binwidth) + return binary.zfill(outwidth) + + else: + if width is None: + return '-' + bin(-num)[2:] + + else: + poswidth = len(bin(-num)[2:]) + + # See gh-8679: remove extra digit + # for numbers at boundaries. + if 2**(poswidth - 1) == -num: + poswidth -= 1 + + twocomp = 2**(poswidth + 1) + num + binary = bin(twocomp)[2:] + binwidth = len(binary) + + outwidth = builtins.max(binwidth, width) + err_if_insufficient(width, binwidth) + return '1' * (outwidth - binwidth) + binary + + +@set_module('numpy') +def base_repr(number, base=2, padding=0): + """ + Return a string representation of a number in the given base system. + + Parameters + ---------- + number : int + The value to convert. Positive and negative values are handled. + base : int, optional + Convert `number` to the `base` number system. The valid range is 2-36, + the default value is 2. + padding : int, optional + Number of zeros padded on the left. Default is 0 (no padding). + + Returns + ------- + out : str + String representation of `number` in `base` system. + + See Also + -------- + binary_repr : Faster version of `base_repr` for base 2. + + Examples + -------- + >>> import numpy as np + >>> np.base_repr(5) + '101' + >>> np.base_repr(6, 5) + '11' + >>> np.base_repr(7, base=5, padding=3) + '00012' + + >>> np.base_repr(10, base=16) + 'A' + >>> np.base_repr(32, base=16) + '20' + + """ + digits = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ' + if base > len(digits): + raise ValueError("Bases greater than 36 not handled in base_repr.") + elif base < 2: + raise ValueError("Bases less than 2 not handled in base_repr.") + + num = abs(int(number)) + res = [] + while num: + res.append(digits[num % base]) + num //= base + if padding: + res.append('0' * padding) + if number < 0: + res.append('-') + return ''.join(reversed(res or '0')) + + +# These are all essentially abbreviations +# These might wind up in a special abbreviations module + + +def _maketup(descr, val): + dt = dtype(descr) + # Place val in all scalar tuples: + fields = dt.fields + if fields is None: + return val + else: + res = [_maketup(fields[name][0], val) for name in dt.names] + return tuple(res) + + +@set_array_function_like_doc +@set_module('numpy') +def identity(n, dtype=None, *, like=None): + """ + Return the identity array. + + The identity array is a square array with ones on + the main diagonal. + + Parameters + ---------- + n : int + Number of rows (and columns) in `n` x `n` output. + dtype : data-type, optional + Data-type of the output. Defaults to ``float``. + ${ARRAY_FUNCTION_LIKE} + + .. versionadded:: 1.20.0 + + Returns + ------- + out : ndarray + `n` x `n` array with its main diagonal set to one, + and all other elements 0. + + Examples + -------- + >>> import numpy as np + >>> np.identity(3) + array([[1., 0., 0.], + [0., 1., 0.], + [0., 0., 1.]]) + + """ + if like is not None: + return _identity_with_like(like, n, dtype=dtype) + + from numpy import eye + return eye(n, dtype=dtype, like=like) + + +_identity_with_like = array_function_dispatch()(identity) + + +def _allclose_dispatcher(a, b, rtol=None, atol=None, equal_nan=None): + return (a, b, rtol, atol) + + +@array_function_dispatch(_allclose_dispatcher) +def allclose(a, b, rtol=1.e-5, atol=1.e-8, equal_nan=False): + """ + Returns True if two arrays are element-wise equal within a tolerance. + + The tolerance values are positive, typically very small numbers. The + relative difference (`rtol` * abs(`b`)) and the absolute difference + `atol` are added together to compare against the absolute difference + between `a` and `b`. + + .. warning:: The default `atol` is not appropriate for comparing numbers + with magnitudes much smaller than one (see Notes). + + NaNs are treated as equal if they are in the same place and if + ``equal_nan=True``. Infs are treated as equal if they are in the same + place and of the same sign in both arrays. + + Parameters + ---------- + a, b : array_like + Input arrays to compare. + rtol : array_like + The relative tolerance parameter (see Notes). + atol : array_like + The absolute tolerance parameter (see Notes). + equal_nan : bool + Whether to compare NaN's as equal. If True, NaN's in `a` will be + considered equal to NaN's in `b` in the output array. + + .. versionadded:: 1.10.0 + + Returns + ------- + allclose : bool + Returns True if the two arrays are equal within the given + tolerance; False otherwise. + + See Also + -------- + isclose, all, any, equal + + Notes + ----- + If the following equation is element-wise True, then allclose returns + True.:: + + absolute(a - b) <= (atol + rtol * absolute(b)) + + The above equation is not symmetric in `a` and `b`, so that + ``allclose(a, b)`` might be different from ``allclose(b, a)`` in + some rare cases. + + The default value of `atol` is not appropriate when the reference value + `b` has magnitude smaller than one. For example, it is unlikely that + ``a = 1e-9`` and ``b = 2e-9`` should be considered "close", yet + ``allclose(1e-9, 2e-9)`` is ``True`` with default settings. Be sure + to select `atol` for the use case at hand, especially for defining the + threshold below which a non-zero value in `a` will be considered "close" + to a very small or zero value in `b`. + + The comparison of `a` and `b` uses standard broadcasting, which + means that `a` and `b` need not have the same shape in order for + ``allclose(a, b)`` to evaluate to True. The same is true for + `equal` but not `array_equal`. + + `allclose` is not defined for non-numeric data types. + `bool` is considered a numeric data-type for this purpose. + + Examples + -------- + >>> import numpy as np + >>> np.allclose([1e10,1e-7], [1.00001e10,1e-8]) + False + + >>> np.allclose([1e10,1e-8], [1.00001e10,1e-9]) + True + + >>> np.allclose([1e10,1e-8], [1.0001e10,1e-9]) + False + + >>> np.allclose([1.0, np.nan], [1.0, np.nan]) + False + + >>> np.allclose([1.0, np.nan], [1.0, np.nan], equal_nan=True) + True + + + """ + res = all(isclose(a, b, rtol=rtol, atol=atol, equal_nan=equal_nan)) + return builtins.bool(res) + + +def _isclose_dispatcher(a, b, rtol=None, atol=None, equal_nan=None): + return (a, b, rtol, atol) + + +@array_function_dispatch(_isclose_dispatcher) +def isclose(a, b, rtol=1.e-5, atol=1.e-8, equal_nan=False): + """ + Returns a boolean array where two arrays are element-wise equal within a + tolerance. + + The tolerance values are positive, typically very small numbers. The + relative difference (`rtol` * abs(`b`)) and the absolute difference + `atol` are added together to compare against the absolute difference + between `a` and `b`. + + .. warning:: The default `atol` is not appropriate for comparing numbers + with magnitudes much smaller than one (see Notes). + + Parameters + ---------- + a, b : array_like + Input arrays to compare. + rtol : array_like + The relative tolerance parameter (see Notes). + atol : array_like + The absolute tolerance parameter (see Notes). + equal_nan : bool + Whether to compare NaN's as equal. If True, NaN's in `a` will be + considered equal to NaN's in `b` in the output array. + + Returns + ------- + y : array_like + Returns a boolean array of where `a` and `b` are equal within the + given tolerance. If both `a` and `b` are scalars, returns a single + boolean value. + + See Also + -------- + allclose + math.isclose + + Notes + ----- + .. versionadded:: 1.7.0 + + For finite values, isclose uses the following equation to test whether + two floating point values are equivalent.:: + + absolute(a - b) <= (atol + rtol * absolute(b)) + + Unlike the built-in `math.isclose`, the above equation is not symmetric + in `a` and `b` -- it assumes `b` is the reference value -- so that + `isclose(a, b)` might be different from `isclose(b, a)`. + + The default value of `atol` is not appropriate when the reference value + `b` has magnitude smaller than one. For example, it is unlikely that + ``a = 1e-9`` and ``b = 2e-9`` should be considered "close", yet + ``isclose(1e-9, 2e-9)`` is ``True`` with default settings. Be sure + to select `atol` for the use case at hand, especially for defining the + threshold below which a non-zero value in `a` will be considered "close" + to a very small or zero value in `b`. + + `isclose` is not defined for non-numeric data types. + :class:`bool` is considered a numeric data-type for this purpose. + + Examples + -------- + >>> import numpy as np + >>> np.isclose([1e10,1e-7], [1.00001e10,1e-8]) + array([ True, False]) + + >>> np.isclose([1e10,1e-8], [1.00001e10,1e-9]) + array([ True, True]) + + >>> np.isclose([1e10,1e-8], [1.0001e10,1e-9]) + array([False, True]) + + >>> np.isclose([1.0, np.nan], [1.0, np.nan]) + array([ True, False]) + + >>> np.isclose([1.0, np.nan], [1.0, np.nan], equal_nan=True) + array([ True, True]) + + >>> np.isclose([1e-8, 1e-7], [0.0, 0.0]) + array([ True, False]) + + >>> np.isclose([1e-100, 1e-7], [0.0, 0.0], atol=0.0) + array([False, False]) + + >>> np.isclose([1e-10, 1e-10], [1e-20, 0.0]) + array([ True, True]) + + >>> np.isclose([1e-10, 1e-10], [1e-20, 0.999999e-10], atol=0.0) + array([False, True]) + + """ + # Turn all but python scalars into arrays. + x, y, atol, rtol = ( + a if isinstance(a, (int, float, complex)) else asanyarray(a) + for a in (a, b, atol, rtol)) + + # Make sure y is an inexact type to avoid bad behavior on abs(MIN_INT). + # This will cause casting of x later. Also, make sure to allow subclasses + # (e.g., for numpy.ma). + # NOTE: We explicitly allow timedelta, which used to work. This could + # possibly be deprecated. See also gh-18286. + # timedelta works if `atol` is an integer or also a timedelta. + # Although, the default tolerances are unlikely to be useful + if (dtype := getattr(y, "dtype", None)) is not None and dtype.kind != "m": + dt = multiarray.result_type(y, 1.) + y = asanyarray(y, dtype=dt) + elif isinstance(y, int): + y = float(y) + + with errstate(invalid='ignore'), _no_nep50_warning(): + result = (less_equal(abs(x-y), atol + rtol * abs(y)) + & isfinite(y) + | (x == y)) + if equal_nan: + result |= isnan(x) & isnan(y) + + return result[()] # Flatten 0d arrays to scalars + + +def _array_equal_dispatcher(a1, a2, equal_nan=None): + return (a1, a2) + + +_no_nan_types = { + # should use np.dtype.BoolDType, but as of writing + # that fails the reloading test. + type(dtype(nt.bool)), + type(dtype(nt.int8)), + type(dtype(nt.int16)), + type(dtype(nt.int32)), + type(dtype(nt.int64)), +} + + +def _dtype_cannot_hold_nan(dtype): + return type(dtype) in _no_nan_types + + +@array_function_dispatch(_array_equal_dispatcher) +def array_equal(a1, a2, equal_nan=False): + """ + True if two arrays have the same shape and elements, False otherwise. + + Parameters + ---------- + a1, a2 : array_like + Input arrays. + equal_nan : bool + Whether to compare NaN's as equal. If the dtype of a1 and a2 is + complex, values will be considered equal if either the real or the + imaginary component of a given value is ``nan``. + + .. versionadded:: 1.19.0 + + Returns + ------- + b : bool + Returns True if the arrays are equal. + + See Also + -------- + allclose: Returns True if two arrays are element-wise equal within a + tolerance. + array_equiv: Returns True if input arrays are shape consistent and all + elements equal. + + Examples + -------- + >>> import numpy as np + + >>> np.array_equal([1, 2], [1, 2]) + True + + >>> np.array_equal(np.array([1, 2]), np.array([1, 2])) + True + + >>> np.array_equal([1, 2], [1, 2, 3]) + False + + >>> np.array_equal([1, 2], [1, 4]) + False + + >>> a = np.array([1, np.nan]) + >>> np.array_equal(a, a) + False + + >>> np.array_equal(a, a, equal_nan=True) + True + + When ``equal_nan`` is True, complex values with nan components are + considered equal if either the real *or* the imaginary components are nan. + + >>> a = np.array([1 + 1j]) + >>> b = a.copy() + >>> a.real = np.nan + >>> b.imag = np.nan + >>> np.array_equal(a, b, equal_nan=True) + True + """ + try: + a1, a2 = asarray(a1), asarray(a2) + except Exception: + return False + if a1.shape != a2.shape: + return False + if not equal_nan: + return builtins.bool((asanyarray(a1 == a2)).all()) + + if a1 is a2: + # nan will compare equal so an array will compare equal to itself. + return True + + cannot_have_nan = (_dtype_cannot_hold_nan(a1.dtype) + and _dtype_cannot_hold_nan(a2.dtype)) + if cannot_have_nan: + return builtins.bool(asarray(a1 == a2).all()) + + # Handling NaN values if equal_nan is True + a1nan, a2nan = isnan(a1), isnan(a2) + # NaN's occur at different locations + if not (a1nan == a2nan).all(): + return False + # Shapes of a1, a2 and masks are guaranteed to be consistent by this point + return builtins.bool((a1[~a1nan] == a2[~a1nan]).all()) + + +def _array_equiv_dispatcher(a1, a2): + return (a1, a2) + + +@array_function_dispatch(_array_equiv_dispatcher) +def array_equiv(a1, a2): + """ + Returns True if input arrays are shape consistent and all elements equal. + + Shape consistent means they are either the same shape, or one input array + can be broadcasted to create the same shape as the other one. + + Parameters + ---------- + a1, a2 : array_like + Input arrays. + + Returns + ------- + out : bool + True if equivalent, False otherwise. + + Examples + -------- + >>> import numpy as np + >>> np.array_equiv([1, 2], [1, 2]) + True + >>> np.array_equiv([1, 2], [1, 3]) + False + + Showing the shape equivalence: + + >>> np.array_equiv([1, 2], [[1, 2], [1, 2]]) + True + >>> np.array_equiv([1, 2], [[1, 2, 1, 2], [1, 2, 1, 2]]) + False + + >>> np.array_equiv([1, 2], [[1, 2], [1, 3]]) + False + + """ + try: + a1, a2 = asarray(a1), asarray(a2) + except Exception: + return False + try: + multiarray.broadcast(a1, a2) + except Exception: + return False + + return builtins.bool(asanyarray(a1 == a2).all()) + + +def _astype_dispatcher(x, dtype, /, *, copy=None, device=None): + return (x, dtype) + + +@array_function_dispatch(_astype_dispatcher) +def astype(x, dtype, /, *, copy=True, device=None): + """ + Copies an array to a specified data type. + + This function is an Array API compatible alternative to + `numpy.ndarray.astype`. + + Parameters + ---------- + x : ndarray + Input NumPy array to cast. ``array_likes`` are explicitly not + supported here. + dtype : dtype + Data type of the result. + copy : bool, optional + Specifies whether to copy an array when the specified dtype matches + the data type of the input array ``x``. If ``True``, a newly allocated + array must always be returned. If ``False`` and the specified dtype + matches the data type of the input array, the input array must be + returned; otherwise, a newly allocated array must be returned. + Defaults to ``True``. + device : str, optional + The device on which to place the returned array. Default: None. + For Array-API interoperability only, so must be ``"cpu"`` if passed. + + .. versionadded:: 2.1.0 + + Returns + ------- + out : ndarray + An array having the specified data type. + + See Also + -------- + ndarray.astype + + Examples + -------- + >>> import numpy as np + >>> arr = np.array([1, 2, 3]); arr + array([1, 2, 3]) + >>> np.astype(arr, np.float64) + array([1., 2., 3.]) + + Non-copy case: + + >>> arr = np.array([1, 2, 3]) + >>> arr_noncpy = np.astype(arr, arr.dtype, copy=False) + >>> np.shares_memory(arr, arr_noncpy) + True + + """ + if not (isinstance(x, np.ndarray) or isscalar(x)): + raise TypeError( + "Input should be a NumPy array or scalar. " + f"It is a {type(x)} instead." + ) + if device is not None and device != "cpu": + raise ValueError( + 'Device not understood. Only "cpu" is allowed, but received:' + f' {device}' + ) + return x.astype(dtype, copy=copy) + + +inf = PINF +nan = NAN +False_ = nt.bool(False) +True_ = nt.bool(True) + + +def extend_all(module): + existing = set(__all__) + mall = getattr(module, '__all__') + for a in mall: + if a not in existing: + __all__.append(a) + + +from .umath import * +from .numerictypes import * +from . import fromnumeric +from .fromnumeric import * +from . import arrayprint +from .arrayprint import * +from . import _asarray +from ._asarray import * +from . import _ufunc_config +from ._ufunc_config import * +extend_all(fromnumeric) +extend_all(umath) +extend_all(numerictypes) +extend_all(arrayprint) +extend_all(_asarray) +extend_all(_ufunc_config) diff --git a/venv/lib/python3.12/site-packages/numpy/_core/numeric.pyi b/venv/lib/python3.12/site-packages/numpy/_core/numeric.pyi new file mode 100644 index 00000000..f25c6258 --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/numeric.pyi @@ -0,0 +1,707 @@ +from collections.abc import Callable, Sequence +from typing import ( + Any, + overload, + TypeVar, + Literal as L, + SupportsAbs, + SupportsIndex, + NoReturn, + TypeGuard, +) + +import numpy as np +from numpy import ( + generic, + unsignedinteger, + signedinteger, + floating, + complexfloating, + int_, + intp, + float64, + timedelta64, + object_, + _OrderKACF, + _OrderCF, +) + +from numpy._typing import ( + ArrayLike, + NDArray, + DTypeLike, + _ShapeLike, + _DTypeLike, + _ArrayLike, + _SupportsArrayFunc, + _ScalarLike_co, + _ArrayLikeBool_co, + _ArrayLikeUInt_co, + _ArrayLikeInt_co, + _ArrayLikeFloat_co, + _ArrayLikeComplex_co, + _ArrayLikeTD64_co, + _ArrayLikeObject_co, + _ArrayLikeUnknown, +) + +_T = TypeVar("_T") +_SCT = TypeVar("_SCT", bound=generic) +_ArrayType = TypeVar("_ArrayType", bound=NDArray[Any]) + +_CorrelateMode = L["valid", "same", "full"] + +__all__: list[str] + +@overload +def zeros_like( + a: _ArrayType, + dtype: None = ..., + order: _OrderKACF = ..., + subok: L[True] = ..., + shape: None = ..., + *, + device: None | L["cpu"] = ..., +) -> _ArrayType: ... +@overload +def zeros_like( + a: _ArrayLike[_SCT], + dtype: None = ..., + order: _OrderKACF = ..., + subok: bool = ..., + shape: None | _ShapeLike = ..., + *, + device: None | L["cpu"] = ..., +) -> NDArray[_SCT]: ... +@overload +def zeros_like( + a: object, + dtype: None = ..., + order: _OrderKACF = ..., + subok: bool = ..., + shape: None | _ShapeLike= ..., + *, + device: None | L["cpu"] = ..., +) -> NDArray[Any]: ... +@overload +def zeros_like( + a: Any, + dtype: _DTypeLike[_SCT], + order: _OrderKACF = ..., + subok: bool = ..., + shape: None | _ShapeLike= ..., + *, + device: None | L["cpu"] = ..., +) -> NDArray[_SCT]: ... +@overload +def zeros_like( + a: Any, + dtype: DTypeLike, + order: _OrderKACF = ..., + subok: bool = ..., + shape: None | _ShapeLike= ..., + *, + device: None | L["cpu"] = ..., +) -> NDArray[Any]: ... + +@overload +def ones( + shape: _ShapeLike, + dtype: None = ..., + order: _OrderCF = ..., + *, + device: None | L["cpu"] = ..., + like: _SupportsArrayFunc = ..., +) -> NDArray[float64]: ... +@overload +def ones( + shape: _ShapeLike, + dtype: _DTypeLike[_SCT], + order: _OrderCF = ..., + *, + device: None | L["cpu"] = ..., + like: _SupportsArrayFunc = ..., +) -> NDArray[_SCT]: ... +@overload +def ones( + shape: _ShapeLike, + dtype: DTypeLike, + order: _OrderCF = ..., + *, + device: None | L["cpu"] = ..., + like: _SupportsArrayFunc = ..., +) -> NDArray[Any]: ... + +@overload +def ones_like( + a: _ArrayType, + dtype: None = ..., + order: _OrderKACF = ..., + subok: L[True] = ..., + shape: None = ..., + *, + device: None | L["cpu"] = ..., +) -> _ArrayType: ... +@overload +def ones_like( + a: _ArrayLike[_SCT], + dtype: None = ..., + order: _OrderKACF = ..., + subok: bool = ..., + shape: None | _ShapeLike = ..., + *, + device: None | L["cpu"] = ..., +) -> NDArray[_SCT]: ... +@overload +def ones_like( + a: object, + dtype: None = ..., + order: _OrderKACF = ..., + subok: bool = ..., + shape: None | _ShapeLike= ..., + *, + device: None | L["cpu"] = ..., +) -> NDArray[Any]: ... +@overload +def ones_like( + a: Any, + dtype: _DTypeLike[_SCT], + order: _OrderKACF = ..., + subok: bool = ..., + shape: None | _ShapeLike= ..., + *, + device: None | L["cpu"] = ..., +) -> NDArray[_SCT]: ... +@overload +def ones_like( + a: Any, + dtype: DTypeLike, + order: _OrderKACF = ..., + subok: bool = ..., + shape: None | _ShapeLike= ..., + *, + device: None | L["cpu"] = ..., +) -> NDArray[Any]: ... + +@overload +def full( + shape: _ShapeLike, + fill_value: Any, + dtype: None = ..., + order: _OrderCF = ..., + *, + device: None | L["cpu"] = ..., + like: _SupportsArrayFunc = ..., +) -> NDArray[Any]: ... +@overload +def full( + shape: _ShapeLike, + fill_value: Any, + dtype: _DTypeLike[_SCT], + order: _OrderCF = ..., + *, + device: None | L["cpu"] = ..., + like: _SupportsArrayFunc = ..., +) -> NDArray[_SCT]: ... +@overload +def full( + shape: _ShapeLike, + fill_value: Any, + dtype: DTypeLike, + order: _OrderCF = ..., + *, + device: None | L["cpu"] = ..., + like: _SupportsArrayFunc = ..., +) -> NDArray[Any]: ... + +@overload +def full_like( + a: _ArrayType, + fill_value: Any, + dtype: None = ..., + order: _OrderKACF = ..., + subok: L[True] = ..., + shape: None = ..., + *, + device: None | L["cpu"] = ..., +) -> _ArrayType: ... +@overload +def full_like( + a: _ArrayLike[_SCT], + fill_value: Any, + dtype: None = ..., + order: _OrderKACF = ..., + subok: bool = ..., + shape: None | _ShapeLike = ..., + *, + device: None | L["cpu"] = ..., +) -> NDArray[_SCT]: ... +@overload +def full_like( + a: object, + fill_value: Any, + dtype: None = ..., + order: _OrderKACF = ..., + subok: bool = ..., + shape: None | _ShapeLike= ..., + *, + device: None | L["cpu"] = ..., +) -> NDArray[Any]: ... +@overload +def full_like( + a: Any, + fill_value: Any, + dtype: _DTypeLike[_SCT], + order: _OrderKACF = ..., + subok: bool = ..., + shape: None | _ShapeLike= ..., + *, + device: None | L["cpu"] = ..., +) -> NDArray[_SCT]: ... +@overload +def full_like( + a: Any, + fill_value: Any, + dtype: DTypeLike, + order: _OrderKACF = ..., + subok: bool = ..., + shape: None | _ShapeLike= ..., + *, + device: None | L["cpu"] = ..., +) -> NDArray[Any]: ... + +@overload +def count_nonzero( + a: ArrayLike, + axis: None = ..., + *, + keepdims: L[False] = ..., +) -> int: ... +@overload +def count_nonzero( + a: ArrayLike, + axis: _ShapeLike = ..., + *, + keepdims: bool = ..., +) -> Any: ... # TODO: np.intp or ndarray[np.intp] + +def isfortran(a: NDArray[Any] | generic) -> bool: ... + +def argwhere(a: ArrayLike) -> NDArray[intp]: ... + +def flatnonzero(a: ArrayLike) -> NDArray[intp]: ... + +@overload +def correlate( + a: _ArrayLikeUnknown, + v: _ArrayLikeUnknown, + mode: _CorrelateMode = ..., +) -> NDArray[Any]: ... +@overload +def correlate( + a: _ArrayLikeBool_co, + v: _ArrayLikeBool_co, + mode: _CorrelateMode = ..., +) -> NDArray[np.bool]: ... +@overload +def correlate( + a: _ArrayLikeUInt_co, + v: _ArrayLikeUInt_co, + mode: _CorrelateMode = ..., +) -> NDArray[unsignedinteger[Any]]: ... +@overload +def correlate( + a: _ArrayLikeInt_co, + v: _ArrayLikeInt_co, + mode: _CorrelateMode = ..., +) -> NDArray[signedinteger[Any]]: ... +@overload +def correlate( + a: _ArrayLikeFloat_co, + v: _ArrayLikeFloat_co, + mode: _CorrelateMode = ..., +) -> NDArray[floating[Any]]: ... +@overload +def correlate( + a: _ArrayLikeComplex_co, + v: _ArrayLikeComplex_co, + mode: _CorrelateMode = ..., +) -> NDArray[complexfloating[Any, Any]]: ... +@overload +def correlate( + a: _ArrayLikeTD64_co, + v: _ArrayLikeTD64_co, + mode: _CorrelateMode = ..., +) -> NDArray[timedelta64]: ... +@overload +def correlate( + a: _ArrayLikeObject_co, + v: _ArrayLikeObject_co, + mode: _CorrelateMode = ..., +) -> NDArray[object_]: ... + +@overload +def convolve( + a: _ArrayLikeUnknown, + v: _ArrayLikeUnknown, + mode: _CorrelateMode = ..., +) -> NDArray[Any]: ... +@overload +def convolve( + a: _ArrayLikeBool_co, + v: _ArrayLikeBool_co, + mode: _CorrelateMode = ..., +) -> NDArray[np.bool]: ... +@overload +def convolve( + a: _ArrayLikeUInt_co, + v: _ArrayLikeUInt_co, + mode: _CorrelateMode = ..., +) -> NDArray[unsignedinteger[Any]]: ... +@overload +def convolve( + a: _ArrayLikeInt_co, + v: _ArrayLikeInt_co, + mode: _CorrelateMode = ..., +) -> NDArray[signedinteger[Any]]: ... +@overload +def convolve( + a: _ArrayLikeFloat_co, + v: _ArrayLikeFloat_co, + mode: _CorrelateMode = ..., +) -> NDArray[floating[Any]]: ... +@overload +def convolve( + a: _ArrayLikeComplex_co, + v: _ArrayLikeComplex_co, + mode: _CorrelateMode = ..., +) -> NDArray[complexfloating[Any, Any]]: ... +@overload +def convolve( + a: _ArrayLikeTD64_co, + v: _ArrayLikeTD64_co, + mode: _CorrelateMode = ..., +) -> NDArray[timedelta64]: ... +@overload +def convolve( + a: _ArrayLikeObject_co, + v: _ArrayLikeObject_co, + mode: _CorrelateMode = ..., +) -> NDArray[object_]: ... + +@overload +def outer( + a: _ArrayLikeUnknown, + b: _ArrayLikeUnknown, + out: None = ..., +) -> NDArray[Any]: ... +@overload +def outer( + a: _ArrayLikeBool_co, + b: _ArrayLikeBool_co, + out: None = ..., +) -> NDArray[np.bool]: ... +@overload +def outer( + a: _ArrayLikeUInt_co, + b: _ArrayLikeUInt_co, + out: None = ..., +) -> NDArray[unsignedinteger[Any]]: ... +@overload +def outer( + a: _ArrayLikeInt_co, + b: _ArrayLikeInt_co, + out: None = ..., +) -> NDArray[signedinteger[Any]]: ... +@overload +def outer( + a: _ArrayLikeFloat_co, + b: _ArrayLikeFloat_co, + out: None = ..., +) -> NDArray[floating[Any]]: ... +@overload +def outer( + a: _ArrayLikeComplex_co, + b: _ArrayLikeComplex_co, + out: None = ..., +) -> NDArray[complexfloating[Any, Any]]: ... +@overload +def outer( + a: _ArrayLikeTD64_co, + b: _ArrayLikeTD64_co, + out: None = ..., +) -> NDArray[timedelta64]: ... +@overload +def outer( + a: _ArrayLikeObject_co, + b: _ArrayLikeObject_co, + out: None = ..., +) -> NDArray[object_]: ... +@overload +def outer( + a: _ArrayLikeComplex_co | _ArrayLikeTD64_co | _ArrayLikeObject_co, + b: _ArrayLikeComplex_co | _ArrayLikeTD64_co | _ArrayLikeObject_co, + out: _ArrayType, +) -> _ArrayType: ... + +@overload +def tensordot( + a: _ArrayLikeUnknown, + b: _ArrayLikeUnknown, + axes: int | tuple[_ShapeLike, _ShapeLike] = ..., +) -> NDArray[Any]: ... +@overload +def tensordot( + a: _ArrayLikeBool_co, + b: _ArrayLikeBool_co, + axes: int | tuple[_ShapeLike, _ShapeLike] = ..., +) -> NDArray[np.bool]: ... +@overload +def tensordot( + a: _ArrayLikeUInt_co, + b: _ArrayLikeUInt_co, + axes: int | tuple[_ShapeLike, _ShapeLike] = ..., +) -> NDArray[unsignedinteger[Any]]: ... +@overload +def tensordot( + a: _ArrayLikeInt_co, + b: _ArrayLikeInt_co, + axes: int | tuple[_ShapeLike, _ShapeLike] = ..., +) -> NDArray[signedinteger[Any]]: ... +@overload +def tensordot( + a: _ArrayLikeFloat_co, + b: _ArrayLikeFloat_co, + axes: int | tuple[_ShapeLike, _ShapeLike] = ..., +) -> NDArray[floating[Any]]: ... +@overload +def tensordot( + a: _ArrayLikeComplex_co, + b: _ArrayLikeComplex_co, + axes: int | tuple[_ShapeLike, _ShapeLike] = ..., +) -> NDArray[complexfloating[Any, Any]]: ... +@overload +def tensordot( + a: _ArrayLikeTD64_co, + b: _ArrayLikeTD64_co, + axes: int | tuple[_ShapeLike, _ShapeLike] = ..., +) -> NDArray[timedelta64]: ... +@overload +def tensordot( + a: _ArrayLikeObject_co, + b: _ArrayLikeObject_co, + axes: int | tuple[_ShapeLike, _ShapeLike] = ..., +) -> NDArray[object_]: ... + +@overload +def roll( + a: _ArrayLike[_SCT], + shift: _ShapeLike, + axis: None | _ShapeLike = ..., +) -> NDArray[_SCT]: ... +@overload +def roll( + a: ArrayLike, + shift: _ShapeLike, + axis: None | _ShapeLike = ..., +) -> NDArray[Any]: ... + +def rollaxis( + a: NDArray[_SCT], + axis: int, + start: int = ..., +) -> NDArray[_SCT]: ... + +def moveaxis( + a: NDArray[_SCT], + source: _ShapeLike, + destination: _ShapeLike, +) -> NDArray[_SCT]: ... + +@overload +def cross( + x1: _ArrayLikeUnknown, + x2: _ArrayLikeUnknown, + axisa: int = ..., + axisb: int = ..., + axisc: int = ..., + axis: None | int = ..., +) -> NDArray[Any]: ... +@overload +def cross( + x1: _ArrayLikeBool_co, + x2: _ArrayLikeBool_co, + axisa: int = ..., + axisb: int = ..., + axisc: int = ..., + axis: None | int = ..., +) -> NoReturn: ... +@overload +def cross( + x1: _ArrayLikeUInt_co, + x2: _ArrayLikeUInt_co, + axisa: int = ..., + axisb: int = ..., + axisc: int = ..., + axis: None | int = ..., +) -> NDArray[unsignedinteger[Any]]: ... +@overload +def cross( + x1: _ArrayLikeInt_co, + x2: _ArrayLikeInt_co, + axisa: int = ..., + axisb: int = ..., + axisc: int = ..., + axis: None | int = ..., +) -> NDArray[signedinteger[Any]]: ... +@overload +def cross( + x1: _ArrayLikeFloat_co, + x2: _ArrayLikeFloat_co, + axisa: int = ..., + axisb: int = ..., + axisc: int = ..., + axis: None | int = ..., +) -> NDArray[floating[Any]]: ... +@overload +def cross( + x1: _ArrayLikeComplex_co, + x2: _ArrayLikeComplex_co, + axisa: int = ..., + axisb: int = ..., + axisc: int = ..., + axis: None | int = ..., +) -> NDArray[complexfloating[Any, Any]]: ... +@overload +def cross( + x1: _ArrayLikeObject_co, + x2: _ArrayLikeObject_co, + axisa: int = ..., + axisb: int = ..., + axisc: int = ..., + axis: None | int = ..., +) -> NDArray[object_]: ... + +@overload +def indices( + dimensions: Sequence[int], + dtype: type[int] = ..., + sparse: L[False] = ..., +) -> NDArray[int_]: ... +@overload +def indices( + dimensions: Sequence[int], + dtype: type[int] = ..., + sparse: L[True] = ..., +) -> tuple[NDArray[int_], ...]: ... +@overload +def indices( + dimensions: Sequence[int], + dtype: _DTypeLike[_SCT], + sparse: L[False] = ..., +) -> NDArray[_SCT]: ... +@overload +def indices( + dimensions: Sequence[int], + dtype: _DTypeLike[_SCT], + sparse: L[True], +) -> tuple[NDArray[_SCT], ...]: ... +@overload +def indices( + dimensions: Sequence[int], + dtype: DTypeLike, + sparse: L[False] = ..., +) -> NDArray[Any]: ... +@overload +def indices( + dimensions: Sequence[int], + dtype: DTypeLike, + sparse: L[True], +) -> tuple[NDArray[Any], ...]: ... + +def fromfunction( + function: Callable[..., _T], + shape: Sequence[int], + *, + dtype: DTypeLike = ..., + like: _SupportsArrayFunc = ..., + **kwargs: Any, +) -> _T: ... + +def isscalar(element: object) -> TypeGuard[ + generic | bool | int | float | complex | str | bytes | memoryview +]: ... + +def binary_repr(num: SupportsIndex, width: None | int = ...) -> str: ... + +def base_repr( + number: SupportsAbs[float], + base: float = ..., + padding: SupportsIndex = ..., +) -> str: ... + +@overload +def identity( + n: int, + dtype: None = ..., + *, + like: _SupportsArrayFunc = ..., +) -> NDArray[float64]: ... +@overload +def identity( + n: int, + dtype: _DTypeLike[_SCT], + *, + like: _SupportsArrayFunc = ..., +) -> NDArray[_SCT]: ... +@overload +def identity( + n: int, + dtype: DTypeLike, + *, + like: _SupportsArrayFunc = ..., +) -> NDArray[Any]: ... + +def allclose( + a: ArrayLike, + b: ArrayLike, + rtol: ArrayLike = ..., + atol: ArrayLike = ..., + equal_nan: bool = ..., +) -> bool: ... + +@overload +def isclose( + a: _ScalarLike_co, + b: _ScalarLike_co, + rtol: ArrayLike = ..., + atol: ArrayLike = ..., + equal_nan: bool = ..., +) -> np.bool: ... +@overload +def isclose( + a: ArrayLike, + b: ArrayLike, + rtol: ArrayLike = ..., + atol: ArrayLike = ..., + equal_nan: bool = ..., +) -> NDArray[np.bool]: ... + +def array_equal(a1: ArrayLike, a2: ArrayLike, equal_nan: bool = ...) -> bool: ... + +def array_equiv(a1: ArrayLike, a2: ArrayLike) -> bool: ... + +@overload +def astype( + x: NDArray[Any], + dtype: _DTypeLike[_SCT], + copy: bool = ..., + device: None | L["cpu"] = ..., +) -> NDArray[_SCT]: ... +@overload +def astype( + x: NDArray[Any], + dtype: DTypeLike, + copy: bool = ..., + device: None | L["cpu"] = ..., +) -> NDArray[Any]: ... diff --git a/venv/lib/python3.12/site-packages/numpy/_core/numerictypes.py b/venv/lib/python3.12/site-packages/numpy/_core/numerictypes.py new file mode 100644 index 00000000..d736aecd --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/numerictypes.py @@ -0,0 +1,629 @@ +""" +numerictypes: Define the numeric type objects + +This module is designed so "from numerictypes import \\*" is safe. +Exported symbols include: + + Dictionary with all registered number types (including aliases): + sctypeDict + + Type objects (not all will be available, depends on platform): + see variable sctypes for which ones you have + + Bit-width names + + int8 int16 int32 int64 int128 + uint8 uint16 uint32 uint64 uint128 + float16 float32 float64 float96 float128 float256 + complex32 complex64 complex128 complex192 complex256 complex512 + datetime64 timedelta64 + + c-based names + + bool + + object_ + + void, str_ + + byte, ubyte, + short, ushort + intc, uintc, + intp, uintp, + int_, uint, + longlong, ulonglong, + + single, csingle, + double, cdouble, + longdouble, clongdouble, + + As part of the type-hierarchy: xx -- is bit-width + + generic + +-> bool (kind=b) + +-> number + | +-> integer + | | +-> signedinteger (intxx) (kind=i) + | | | byte + | | | short + | | | intc + | | | intp + | | | int_ + | | | longlong + | | \\-> unsignedinteger (uintxx) (kind=u) + | | ubyte + | | ushort + | | uintc + | | uintp + | | uint + | | ulonglong + | +-> inexact + | +-> floating (floatxx) (kind=f) + | | half + | | single + | | double + | | longdouble + | \\-> complexfloating (complexxx) (kind=c) + | csingle + | cdouble + | clongdouble + +-> flexible + | +-> character + | | bytes_ (kind=S) + | | str_ (kind=U) + | | + | \\-> void (kind=V) + \\-> object_ (not used much) (kind=O) + +""" +import numbers +import warnings + +from . import multiarray as ma +from .multiarray import ( + ndarray, array, dtype, datetime_data, datetime_as_string, + busday_offset, busday_count, is_busday, busdaycalendar + ) +from .._utils import set_module + +# we add more at the bottom +__all__ = [ + 'ScalarType', 'typecodes', 'issubdtype', 'datetime_data', + 'datetime_as_string', 'busday_offset', 'busday_count', + 'is_busday', 'busdaycalendar', 'isdtype' +] + +# we don't need all these imports, but we need to keep them for compatibility +# for users using np._core.numerictypes.UPPER_TABLE +from ._string_helpers import ( + english_lower, english_upper, english_capitalize, LOWER_TABLE, UPPER_TABLE +) + +from ._type_aliases import ( + sctypeDict, allTypes, sctypes +) +from ._dtype import _kind_name + +# we don't export these for import *, but we do want them accessible +# as numerictypes.bool, etc. +from builtins import bool, int, float, complex, object, str, bytes + + +# We use this later +generic = allTypes['generic'] + +genericTypeRank = ['bool', 'int8', 'uint8', 'int16', 'uint16', + 'int32', 'uint32', 'int64', 'uint64', 'int128', + 'uint128', 'float16', + 'float32', 'float64', 'float80', 'float96', 'float128', + 'float256', + 'complex32', 'complex64', 'complex128', 'complex160', + 'complex192', 'complex256', 'complex512', 'object'] + +@set_module('numpy') +def maximum_sctype(t): + """ + Return the scalar type of highest precision of the same kind as the input. + + .. deprecated:: 2.0 + Use an explicit dtype like int64 or float64 instead. + + Parameters + ---------- + t : dtype or dtype specifier + The input data type. This can be a `dtype` object or an object that + is convertible to a `dtype`. + + Returns + ------- + out : dtype + The highest precision data type of the same kind (`dtype.kind`) as `t`. + + See Also + -------- + obj2sctype, mintypecode, sctype2char + dtype + + Examples + -------- + >>> from numpy._core.numerictypes import maximum_sctype + >>> maximum_sctype(int) + + >>> maximum_sctype(np.uint8) + + >>> maximum_sctype(complex) + # may vary + + >>> maximum_sctype(str) + + + >>> maximum_sctype('i2') + + >>> maximum_sctype('f4') + # may vary + + """ + + # Deprecated in NumPy 2.0, 2023-07-11 + warnings.warn( + "`maximum_sctype` is deprecated. Use an explicit dtype like int64 " + "or float64 instead. (deprecated in NumPy 2.0)", + DeprecationWarning, + stacklevel=2 + ) + + g = obj2sctype(t) + if g is None: + return t + t = g + base = _kind_name(dtype(t)) + if base in sctypes: + return sctypes[base][-1] + else: + return t + + +@set_module('numpy') +def issctype(rep): + """ + Determines whether the given object represents a scalar data-type. + + Parameters + ---------- + rep : any + If `rep` is an instance of a scalar dtype, True is returned. If not, + False is returned. + + Returns + ------- + out : bool + Boolean result of check whether `rep` is a scalar dtype. + + See Also + -------- + issubsctype, issubdtype, obj2sctype, sctype2char + + Examples + -------- + >>> from numpy._core.numerictypes import issctype + >>> issctype(np.int32) + True + >>> issctype(list) + False + >>> issctype(1.1) + False + + Strings are also a scalar type: + + >>> issctype(np.dtype('str')) + True + + """ + if not isinstance(rep, (type, dtype)): + return False + try: + res = obj2sctype(rep) + if res and res != object_: + return True + else: + return False + except Exception: + return False + + +@set_module('numpy') +def obj2sctype(rep, default=None): + """ + Return the scalar dtype or NumPy equivalent of Python type of an object. + + Parameters + ---------- + rep : any + The object of which the type is returned. + default : any, optional + If given, this is returned for objects whose types can not be + determined. If not given, None is returned for those objects. + + Returns + ------- + dtype : dtype or Python type + The data type of `rep`. + + See Also + -------- + sctype2char, issctype, issubsctype, issubdtype + + Examples + -------- + >>> from numpy._core.numerictypes import obj2sctype + >>> obj2sctype(np.int32) + + >>> obj2sctype(np.array([1., 2.])) + + >>> obj2sctype(np.array([1.j])) + + + >>> obj2sctype(dict) + + >>> obj2sctype('string') + + >>> obj2sctype(1, default=list) + + + """ + # prevent abstract classes being upcast + if isinstance(rep, type) and issubclass(rep, generic): + return rep + # extract dtype from arrays + if isinstance(rep, ndarray): + return rep.dtype.type + # fall back on dtype to convert + try: + res = dtype(rep) + except Exception: + return default + else: + return res.type + + +@set_module('numpy') +def issubclass_(arg1, arg2): + """ + Determine if a class is a subclass of a second class. + + `issubclass_` is equivalent to the Python built-in ``issubclass``, + except that it returns False instead of raising a TypeError if one + of the arguments is not a class. + + Parameters + ---------- + arg1 : class + Input class. True is returned if `arg1` is a subclass of `arg2`. + arg2 : class or tuple of classes. + Input class. If a tuple of classes, True is returned if `arg1` is a + subclass of any of the tuple elements. + + Returns + ------- + out : bool + Whether `arg1` is a subclass of `arg2` or not. + + See Also + -------- + issubsctype, issubdtype, issctype + + Examples + -------- + >>> np.issubclass_(np.int32, int) + False + >>> np.issubclass_(np.int32, float) + False + >>> np.issubclass_(np.float64, float) + True + + """ + try: + return issubclass(arg1, arg2) + except TypeError: + return False + + +@set_module('numpy') +def issubsctype(arg1, arg2): + """ + Determine if the first argument is a subclass of the second argument. + + Parameters + ---------- + arg1, arg2 : dtype or dtype specifier + Data-types. + + Returns + ------- + out : bool + The result. + + See Also + -------- + issctype, issubdtype, obj2sctype + + Examples + -------- + >>> from numpy._core import issubsctype + >>> issubsctype('S8', str) + False + >>> issubsctype(np.array([1]), int) + True + >>> issubsctype(np.array([1]), float) + False + + """ + return issubclass(obj2sctype(arg1), obj2sctype(arg2)) + + +class _PreprocessDTypeError(Exception): + pass + + +def _preprocess_dtype(dtype): + """ + Preprocess dtype argument by: + 1. fetching type from a data type + 2. verifying that types are built-in NumPy dtypes + """ + if isinstance(dtype, ma.dtype): + dtype = dtype.type + if isinstance(dtype, ndarray) or dtype not in allTypes.values(): + raise _PreprocessDTypeError() + return dtype + + +@set_module('numpy') +def isdtype(dtype, kind): + """ + Determine if a provided dtype is of a specified data type ``kind``. + + This function only supports built-in NumPy's data types. + Third-party dtypes are not yet supported. + + Parameters + ---------- + dtype : dtype + The input dtype. + kind : dtype or str or tuple of dtypes/strs. + dtype or dtype kind. Allowed dtype kinds are: + * ``'bool'`` : boolean kind + * ``'signed integer'`` : signed integer data types + * ``'unsigned integer'`` : unsigned integer data types + * ``'integral'`` : integer data types + * ``'real floating'`` : real-valued floating-point data types + * ``'complex floating'`` : complex floating-point data types + * ``'numeric'`` : numeric data types + + Returns + ------- + out : bool + + See Also + -------- + issubdtype + + Examples + -------- + >>> import numpy as np + >>> np.isdtype(np.float32, np.float64) + False + >>> np.isdtype(np.float32, "real floating") + True + >>> np.isdtype(np.complex128, ("real floating", "complex floating")) + True + + """ + try: + dtype = _preprocess_dtype(dtype) + except _PreprocessDTypeError: + raise TypeError( + "dtype argument must be a NumPy dtype, " + f"but it is a {type(dtype)}." + ) from None + + input_kinds = kind if isinstance(kind, tuple) else (kind,) + + processed_kinds = set() + + for kind in input_kinds: + if kind == "bool": + processed_kinds.add(allTypes["bool"]) + elif kind == "signed integer": + processed_kinds.update(sctypes["int"]) + elif kind == "unsigned integer": + processed_kinds.update(sctypes["uint"]) + elif kind == "integral": + processed_kinds.update(sctypes["int"] + sctypes["uint"]) + elif kind == "real floating": + processed_kinds.update(sctypes["float"]) + elif kind == "complex floating": + processed_kinds.update(sctypes["complex"]) + elif kind == "numeric": + processed_kinds.update( + sctypes["int"] + sctypes["uint"] + + sctypes["float"] + sctypes["complex"] + ) + elif isinstance(kind, str): + raise ValueError( + "kind argument is a string, but" + f" {repr(kind)} is not a known kind name." + ) + else: + try: + kind = _preprocess_dtype(kind) + except _PreprocessDTypeError: + raise TypeError( + "kind argument must be comprised of " + "NumPy dtypes or strings only, " + f"but is a {type(kind)}." + ) from None + processed_kinds.add(kind) + + return dtype in processed_kinds + + +@set_module('numpy') +def issubdtype(arg1, arg2): + r""" + Returns True if first argument is a typecode lower/equal in type hierarchy. + + This is like the builtin :func:`issubclass`, but for `dtype`\ s. + + Parameters + ---------- + arg1, arg2 : dtype_like + `dtype` or object coercible to one + + Returns + ------- + out : bool + + See Also + -------- + :ref:`arrays.scalars` : Overview of the numpy type hierarchy. + + Examples + -------- + `issubdtype` can be used to check the type of arrays: + + >>> ints = np.array([1, 2, 3], dtype=np.int32) + >>> np.issubdtype(ints.dtype, np.integer) + True + >>> np.issubdtype(ints.dtype, np.floating) + False + + >>> floats = np.array([1, 2, 3], dtype=np.float32) + >>> np.issubdtype(floats.dtype, np.integer) + False + >>> np.issubdtype(floats.dtype, np.floating) + True + + Similar types of different sizes are not subdtypes of each other: + + >>> np.issubdtype(np.float64, np.float32) + False + >>> np.issubdtype(np.float32, np.float64) + False + + but both are subtypes of `floating`: + + >>> np.issubdtype(np.float64, np.floating) + True + >>> np.issubdtype(np.float32, np.floating) + True + + For convenience, dtype-like objects are allowed too: + + >>> np.issubdtype('S1', np.bytes_) + True + >>> np.issubdtype('i4', np.signedinteger) + True + + """ + if not issubclass_(arg1, generic): + arg1 = dtype(arg1).type + if not issubclass_(arg2, generic): + arg2 = dtype(arg2).type + + return issubclass(arg1, arg2) + + +@set_module('numpy') +def sctype2char(sctype): + """ + Return the string representation of a scalar dtype. + + Parameters + ---------- + sctype : scalar dtype or object + If a scalar dtype, the corresponding string character is + returned. If an object, `sctype2char` tries to infer its scalar type + and then return the corresponding string character. + + Returns + ------- + typechar : str + The string character corresponding to the scalar type. + + Raises + ------ + ValueError + If `sctype` is an object for which the type can not be inferred. + + See Also + -------- + obj2sctype, issctype, issubsctype, mintypecode + + Examples + -------- + >>> from numpy._core.numerictypes import sctype2char + >>> for sctype in [np.int32, np.double, np.cdouble, np.bytes_, np.ndarray]: + ... print(sctype2char(sctype)) + l # may vary + d + D + S + O + + >>> x = np.array([1., 2-1.j]) + >>> sctype2char(x) + 'D' + >>> sctype2char(list) + 'O' + + """ + sctype = obj2sctype(sctype) + if sctype is None: + raise ValueError("unrecognized type") + if sctype not in sctypeDict.values(): + # for compatibility + raise KeyError(sctype) + return dtype(sctype).char + + +def _scalar_type_key(typ): + """A ``key`` function for `sorted`.""" + dt = dtype(typ) + return (dt.kind.lower(), dt.itemsize) + + +ScalarType = [int, float, complex, bool, bytes, str, memoryview] +ScalarType += sorted(set(sctypeDict.values()), key=_scalar_type_key) +ScalarType = tuple(ScalarType) + + +# Now add the types we've determined to this module +for key in allTypes: + globals()[key] = allTypes[key] + __all__.append(key) + +del key + +typecodes = {'Character': 'c', + 'Integer': 'bhilqnp', + 'UnsignedInteger': 'BHILQNP', + 'Float': 'efdg', + 'Complex': 'FDG', + 'AllInteger': 'bBhHiIlLqQnNpP', + 'AllFloat': 'efdgFDG', + 'Datetime': 'Mm', + 'All': '?bhilqnpBHILQNPefdgFDGSUVOMm'} + +# backwards compatibility --- deprecated name +# Formal deprecation: Numpy 1.20.0, 2020-10-19 (see numpy/__init__.py) +typeDict = sctypeDict + +def _register_types(): + numbers.Integral.register(integer) + numbers.Complex.register(inexact) + numbers.Real.register(floating) + numbers.Number.register(number) + + +_register_types() diff --git a/venv/lib/python3.12/site-packages/numpy/_core/numerictypes.pyi b/venv/lib/python3.12/site-packages/numpy/_core/numerictypes.pyi new file mode 100644 index 00000000..b177dc55 --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/numerictypes.pyi @@ -0,0 +1,99 @@ +from typing import ( + Literal as L, + Any, + TypeVar, + TypedDict, +) + +import numpy as np +from numpy import ( + dtype, + generic, + ubyte, + ushort, + uintc, + ulong, + ulonglong, + byte, + short, + intc, + long, + longlong, + half, + single, + double, + longdouble, + csingle, + cdouble, + clongdouble, + datetime64, + timedelta64, + object_, + str_, + bytes_, + void, +) + +from numpy._core._type_aliases import ( + sctypeDict as sctypeDict, +) + +from numpy._typing import DTypeLike + +_T = TypeVar("_T") +_SCT = TypeVar("_SCT", bound=generic) + +class _TypeCodes(TypedDict): + Character: L['c'] + Integer: L['bhilqnp'] + UnsignedInteger: L['BHILQNP'] + Float: L['efdg'] + Complex: L['FDG'] + AllInteger: L['bBhHiIlLqQnNpP'] + AllFloat: L['efdgFDG'] + Datetime: L['Mm'] + All: L['?bhilqnpBHILQNPefdgFDGSUVOMm'] + +__all__: list[str] + +def isdtype( + dtype: dtype[Any] | type[Any], + kind: DTypeLike | tuple[DTypeLike, ...] +) -> bool: ... + +def issubdtype(arg1: DTypeLike, arg2: DTypeLike) -> bool: ... + +typecodes: _TypeCodes +ScalarType: tuple[ + type[int], + type[float], + type[complex], + type[bool], + type[bytes], + type[str], + type[memoryview], + type[np.bool], + type[csingle], + type[cdouble], + type[clongdouble], + type[half], + type[single], + type[double], + type[longdouble], + type[byte], + type[short], + type[intc], + type[long], + type[longlong], + type[timedelta64], + type[datetime64], + type[object_], + type[bytes_], + type[str_], + type[ubyte], + type[ushort], + type[uintc], + type[ulong], + type[ulonglong], + type[void], +] diff --git a/venv/lib/python3.12/site-packages/numpy/_core/overrides.py b/venv/lib/python3.12/site-packages/numpy/_core/overrides.py new file mode 100644 index 00000000..6bb57c3d --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/overrides.py @@ -0,0 +1,181 @@ +"""Implementation of __array_function__ overrides from NEP-18.""" +import collections +import functools +import os + +from .._utils import set_module +from .._utils._inspect import getargspec +from numpy._core._multiarray_umath import ( + add_docstring, _get_implementing_args, _ArrayFunctionDispatcher) + + +ARRAY_FUNCTIONS = set() + +array_function_like_doc = ( + """like : array_like, optional + Reference object to allow the creation of arrays which are not + NumPy arrays. If an array-like passed in as ``like`` supports + the ``__array_function__`` protocol, the result will be defined + by it. In this case, it ensures the creation of an array object + compatible with that passed in via this argument.""" +) + +def set_array_function_like_doc(public_api): + if public_api.__doc__ is not None: + public_api.__doc__ = public_api.__doc__.replace( + "${ARRAY_FUNCTION_LIKE}", + array_function_like_doc, + ) + return public_api + + +add_docstring( + _ArrayFunctionDispatcher, + """ + Class to wrap functions with checks for __array_function__ overrides. + + All arguments are required, and can only be passed by position. + + Parameters + ---------- + dispatcher : function or None + The dispatcher function that returns a single sequence-like object + of all arguments relevant. It must have the same signature (except + the default values) as the actual implementation. + If ``None``, this is a ``like=`` dispatcher and the + ``_ArrayFunctionDispatcher`` must be called with ``like`` as the + first (additional and positional) argument. + implementation : function + Function that implements the operation on NumPy arrays without + overrides. Arguments passed calling the ``_ArrayFunctionDispatcher`` + will be forwarded to this (and the ``dispatcher``) as if using + ``*args, **kwargs``. + + Attributes + ---------- + _implementation : function + The original implementation passed in. + """) + + +# exposed for testing purposes; used internally by _ArrayFunctionDispatcher +add_docstring( + _get_implementing_args, + """ + Collect arguments on which to call __array_function__. + + Parameters + ---------- + relevant_args : iterable of array-like + Iterable of possibly array-like arguments to check for + __array_function__ methods. + + Returns + ------- + Sequence of arguments with __array_function__ methods, in the order in + which they should be called. + """) + + +ArgSpec = collections.namedtuple('ArgSpec', 'args varargs keywords defaults') + + +def verify_matching_signatures(implementation, dispatcher): + """Verify that a dispatcher function has the right signature.""" + implementation_spec = ArgSpec(*getargspec(implementation)) + dispatcher_spec = ArgSpec(*getargspec(dispatcher)) + + if (implementation_spec.args != dispatcher_spec.args or + implementation_spec.varargs != dispatcher_spec.varargs or + implementation_spec.keywords != dispatcher_spec.keywords or + (bool(implementation_spec.defaults) != + bool(dispatcher_spec.defaults)) or + (implementation_spec.defaults is not None and + len(implementation_spec.defaults) != + len(dispatcher_spec.defaults))): + raise RuntimeError('implementation and dispatcher for %s have ' + 'different function signatures' % implementation) + + if implementation_spec.defaults is not None: + if dispatcher_spec.defaults != (None,) * len(dispatcher_spec.defaults): + raise RuntimeError('dispatcher functions can only use None for ' + 'default argument values') + + +def array_function_dispatch(dispatcher=None, module=None, verify=True, + docs_from_dispatcher=False): + """Decorator for adding dispatch with the __array_function__ protocol. + + See NEP-18 for example usage. + + Parameters + ---------- + dispatcher : callable or None + Function that when called like ``dispatcher(*args, **kwargs)`` with + arguments from the NumPy function call returns an iterable of + array-like arguments to check for ``__array_function__``. + + If `None`, the first argument is used as the single `like=` argument + and not passed on. A function implementing `like=` must call its + dispatcher with `like` as the first non-keyword argument. + module : str, optional + __module__ attribute to set on new function, e.g., ``module='numpy'``. + By default, module is copied from the decorated function. + verify : bool, optional + If True, verify the that the signature of the dispatcher and decorated + function signatures match exactly: all required and optional arguments + should appear in order with the same names, but the default values for + all optional arguments should be ``None``. Only disable verification + if the dispatcher's signature needs to deviate for some particular + reason, e.g., because the function has a signature like + ``func(*args, **kwargs)``. + docs_from_dispatcher : bool, optional + If True, copy docs from the dispatcher function onto the dispatched + function, rather than from the implementation. This is useful for + functions defined in C, which otherwise don't have docstrings. + + Returns + ------- + Function suitable for decorating the implementation of a NumPy function. + + """ + def decorator(implementation): + if verify: + if dispatcher is not None: + verify_matching_signatures(implementation, dispatcher) + else: + # Using __code__ directly similar to verify_matching_signature + co = implementation.__code__ + last_arg = co.co_argcount + co.co_kwonlyargcount - 1 + last_arg = co.co_varnames[last_arg] + if last_arg != "like" or co.co_kwonlyargcount == 0: + raise RuntimeError( + "__array_function__ expects `like=` to be the last " + "argument and a keyword-only argument. " + f"{implementation} does not seem to comply.") + + if docs_from_dispatcher: + add_docstring(implementation, dispatcher.__doc__) + + public_api = _ArrayFunctionDispatcher(dispatcher, implementation) + public_api = functools.wraps(implementation)(public_api) + + if module is not None: + public_api.__module__ = module + + ARRAY_FUNCTIONS.add(public_api) + + return public_api + + return decorator + + +def array_function_from_dispatcher( + implementation, module=None, verify=True, docs_from_dispatcher=True): + """Like array_function_dispatcher, but with function arguments flipped.""" + + def decorator(dispatcher): + return array_function_dispatch( + dispatcher, module, verify=verify, + docs_from_dispatcher=docs_from_dispatcher)(implementation) + return decorator diff --git a/venv/lib/python3.12/site-packages/numpy/_core/printoptions.py b/venv/lib/python3.12/site-packages/numpy/_core/printoptions.py new file mode 100644 index 00000000..7ac93c22 --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/printoptions.py @@ -0,0 +1,32 @@ +""" +Stores and defines the low-level format_options context variable. + +This is defined in its own file outside of the arrayprint module +so we can import it from C while initializing the multiarray +C module during import without introducing circular dependencies. +""" + +import sys +from contextvars import ContextVar + +__all__ = ["format_options"] + +default_format_options_dict = { + "edgeitems": 3, # repr N leading and trailing items of each dimension + "threshold": 1000, # total items > triggers array summarization + "floatmode": "maxprec", + "precision": 8, # precision of floating point representations + "suppress": False, # suppress printing small floating values in exp format + "linewidth": 75, + "nanstr": "nan", + "infstr": "inf", + "sign": "-", + "formatter": None, + # Internally stored as an int to simplify comparisons; converted from/to + # str/False on the way in/out. + 'legacy': sys.maxsize, + 'override_repr': None, +} + +format_options = ContextVar( + "format_options", default=default_format_options_dict.copy()) diff --git a/venv/lib/python3.12/site-packages/numpy/_core/records.py b/venv/lib/python3.12/site-packages/numpy/_core/records.py new file mode 100644 index 00000000..1f92500a --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/records.py @@ -0,0 +1,1091 @@ +""" +This module contains a set of functions for record arrays. +""" +import os +import warnings +from collections import Counter +from contextlib import nullcontext + +from .._utils import set_module +from . import numeric as sb +from . import numerictypes as nt +from .arrayprint import _get_legacy_print_mode + +# All of the functions allow formats to be a dtype +__all__ = [ + 'record', 'recarray', 'format_parser', 'fromarrays', 'fromrecords', + 'fromstring', 'fromfile', 'array', 'find_duplicate', +] + + +ndarray = sb.ndarray + +_byteorderconv = {'b': '>', + 'l': '<', + 'n': '=', + 'B': '>', + 'L': '<', + 'N': '=', + 'S': 's', + 's': 's', + '>': '>', + '<': '<', + '=': '=', + '|': '|', + 'I': '|', + 'i': '|'} + +# formats regular expression +# allows multidimensional spec with a tuple syntax in front +# of the letter code '(2,3)f4' and ' ( 2 , 3 ) f4 ' +# are equally allowed + +numfmt = nt.sctypeDict + + +@set_module('numpy.rec') +def find_duplicate(list): + """Find duplication in a list, return a list of duplicated elements""" + return [ + item + for item, counts in Counter(list).items() + if counts > 1 + ] + + +@set_module('numpy.rec') +class format_parser: + """ + Class to convert formats, names, titles description to a dtype. + + After constructing the format_parser object, the dtype attribute is + the converted data-type: + ``dtype = format_parser(formats, names, titles).dtype`` + + Attributes + ---------- + dtype : dtype + The converted data-type. + + Parameters + ---------- + formats : str or list of str + The format description, either specified as a string with + comma-separated format descriptions in the form ``'f8, i4, S5'``, or + a list of format description strings in the form + ``['f8', 'i4', 'S5']``. + names : str or list/tuple of str + The field names, either specified as a comma-separated string in the + form ``'col1, col2, col3'``, or as a list or tuple of strings in the + form ``['col1', 'col2', 'col3']``. + An empty list can be used, in that case default field names + ('f0', 'f1', ...) are used. + titles : sequence + Sequence of title strings. An empty list can be used to leave titles + out. + aligned : bool, optional + If True, align the fields by padding as the C-compiler would. + Default is False. + byteorder : str, optional + If specified, all the fields will be changed to the + provided byte-order. Otherwise, the default byte-order is + used. For all available string specifiers, see `dtype.newbyteorder`. + + See Also + -------- + numpy.dtype, numpy.typename + + Examples + -------- + >>> import numpy as np + >>> np.rec.format_parser(['>> np.rec.format_parser(['f8', 'i4', 'a5'], ['col1', 'col2', 'col3'], + ... []).dtype + dtype([('col1', '>> np.rec.format_parser([' len(titles): + self._titles += [None] * (self._nfields - len(titles)) + + def _createdtype(self, byteorder): + dtype = sb.dtype({ + 'names': self._names, + 'formats': self._f_formats, + 'offsets': self._offsets, + 'titles': self._titles, + }) + if byteorder is not None: + byteorder = _byteorderconv[byteorder[0]] + dtype = dtype.newbyteorder(byteorder) + + self.dtype = dtype + + +class record(nt.void): + """A data-type scalar that allows field access as attribute lookup. + """ + + # manually set name and module so that this class's type shows up + # as numpy.record when printed + __name__ = 'record' + __module__ = 'numpy' + + def __repr__(self): + if _get_legacy_print_mode() <= 113: + return self.__str__() + return super().__repr__() + + def __str__(self): + if _get_legacy_print_mode() <= 113: + return str(self.item()) + return super().__str__() + + def __getattribute__(self, attr): + if attr in ('setfield', 'getfield', 'dtype'): + return nt.void.__getattribute__(self, attr) + try: + return nt.void.__getattribute__(self, attr) + except AttributeError: + pass + fielddict = nt.void.__getattribute__(self, 'dtype').fields + res = fielddict.get(attr, None) + if res: + obj = self.getfield(*res[:2]) + # if it has fields return a record, + # otherwise return the object + try: + dt = obj.dtype + except AttributeError: + #happens if field is Object type + return obj + if dt.names is not None: + return obj.view((self.__class__, obj.dtype)) + return obj + else: + raise AttributeError("'record' object has no " + "attribute '%s'" % attr) + + def __setattr__(self, attr, val): + if attr in ('setfield', 'getfield', 'dtype'): + raise AttributeError("Cannot set '%s' attribute" % attr) + fielddict = nt.void.__getattribute__(self, 'dtype').fields + res = fielddict.get(attr, None) + if res: + return self.setfield(val, *res[:2]) + else: + if getattr(self, attr, None): + return nt.void.__setattr__(self, attr, val) + else: + raise AttributeError("'record' object has no " + "attribute '%s'" % attr) + + def __getitem__(self, indx): + obj = nt.void.__getitem__(self, indx) + + # copy behavior of record.__getattribute__, + if isinstance(obj, nt.void) and obj.dtype.names is not None: + return obj.view((self.__class__, obj.dtype)) + else: + # return a single element + return obj + + def pprint(self): + """Pretty-print all fields.""" + # pretty-print all fields + names = self.dtype.names + maxlen = max(len(name) for name in names) + fmt = '%% %ds: %%s' % maxlen + rows = [fmt % (name, getattr(self, name)) for name in names] + return "\n".join(rows) + +# The recarray is almost identical to a standard array (which supports +# named fields already) The biggest difference is that it can use +# attribute-lookup to find the fields and it is constructed using +# a record. + +# If byteorder is given it forces a particular byteorder on all +# the fields (and any subfields) + + +@set_module("numpy.rec") +class recarray(ndarray): + """Construct an ndarray that allows field access using attributes. + + Arrays may have a data-types containing fields, analogous + to columns in a spread sheet. An example is ``[(x, int), (y, float)]``, + where each entry in the array is a pair of ``(int, float)``. Normally, + these attributes are accessed using dictionary lookups such as ``arr['x']`` + and ``arr['y']``. Record arrays allow the fields to be accessed as members + of the array, using ``arr.x`` and ``arr.y``. + + Parameters + ---------- + shape : tuple + Shape of output array. + dtype : data-type, optional + The desired data-type. By default, the data-type is determined + from `formats`, `names`, `titles`, `aligned` and `byteorder`. + formats : list of data-types, optional + A list containing the data-types for the different columns, e.g. + ``['i4', 'f8', 'i4']``. `formats` does *not* support the new + convention of using types directly, i.e. ``(int, float, int)``. + Note that `formats` must be a list, not a tuple. + Given that `formats` is somewhat limited, we recommend specifying + `dtype` instead. + names : tuple of str, optional + The name of each column, e.g. ``('x', 'y', 'z')``. + buf : buffer, optional + By default, a new array is created of the given shape and data-type. + If `buf` is specified and is an object exposing the buffer interface, + the array will use the memory from the existing buffer. In this case, + the `offset` and `strides` keywords are available. + + Other Parameters + ---------------- + titles : tuple of str, optional + Aliases for column names. For example, if `names` were + ``('x', 'y', 'z')`` and `titles` is + ``('x_coordinate', 'y_coordinate', 'z_coordinate')``, then + ``arr['x']`` is equivalent to both ``arr.x`` and ``arr.x_coordinate``. + byteorder : {'<', '>', '='}, optional + Byte-order for all fields. + aligned : bool, optional + Align the fields in memory as the C-compiler would. + strides : tuple of ints, optional + Buffer (`buf`) is interpreted according to these strides (strides + define how many bytes each array element, row, column, etc. + occupy in memory). + offset : int, optional + Start reading buffer (`buf`) from this offset onwards. + order : {'C', 'F'}, optional + Row-major (C-style) or column-major (Fortran-style) order. + + Returns + ------- + rec : recarray + Empty array of the given shape and type. + + See Also + -------- + numpy.rec.fromrecords : Construct a record array from data. + numpy.record : fundamental data-type for `recarray`. + numpy.rec.format_parser : determine data-type from formats, names, titles. + + Notes + ----- + This constructor can be compared to ``empty``: it creates a new record + array but does not fill it with data. To create a record array from data, + use one of the following methods: + + 1. Create a standard ndarray and convert it to a record array, + using ``arr.view(np.recarray)`` + 2. Use the `buf` keyword. + 3. Use `np.rec.fromrecords`. + + Examples + -------- + Create an array with two fields, ``x`` and ``y``: + + >>> import numpy as np + >>> x = np.array([(1.0, 2), (3.0, 4)], dtype=[('x', '>> x + array([(1., 2), (3., 4)], dtype=[('x', '>> x['x'] + array([1., 3.]) + + View the array as a record array: + + >>> x = x.view(np.recarray) + + >>> x.x + array([1., 3.]) + + >>> x.y + array([2, 4]) + + Create a new, empty record array: + + >>> np.recarray((2,), + ... dtype=[('x', int), ('y', float), ('z', int)]) #doctest: +SKIP + rec.array([(-1073741821, 1.2249118382103472e-301, 24547520), + (3471280, 1.2134086255804012e-316, 0)], + dtype=[('x', ' 0 or self.shape == (0,): + lst = sb.array2string( + self, separator=', ', prefix=prefix, suffix=',') + else: + # show zero-length shape unless it is (0,) + lst = "[], shape=%s" % (repr(self.shape),) + + lf = '\n'+' '*len(prefix) + if _get_legacy_print_mode() <= 113: + lf = ' ' + lf # trailing space + return fmt % (lst, lf, repr_dtype) + + def field(self, attr, val=None): + if isinstance(attr, int): + names = ndarray.__getattribute__(self, 'dtype').names + attr = names[attr] + + fielddict = ndarray.__getattribute__(self, 'dtype').fields + + res = fielddict[attr][:2] + + if val is None: + obj = self.getfield(*res) + if obj.dtype.names is not None: + return obj + return obj.view(ndarray) + else: + return self.setfield(val, *res) + + +def _deprecate_shape_0_as_None(shape): + if shape == 0: + warnings.warn( + "Passing `shape=0` to have the shape be inferred is deprecated, " + "and in future will be equivalent to `shape=(0,)`. To infer " + "the shape and suppress this warning, pass `shape=None` instead.", + FutureWarning, stacklevel=3) + return None + else: + return shape + + +@set_module("numpy.rec") +def fromarrays(arrayList, dtype=None, shape=None, formats=None, + names=None, titles=None, aligned=False, byteorder=None): + """Create a record array from a (flat) list of arrays + + Parameters + ---------- + arrayList : list or tuple + List of array-like objects (such as lists, tuples, + and ndarrays). + dtype : data-type, optional + valid dtype for all arrays + shape : int or tuple of ints, optional + Shape of the resulting array. If not provided, inferred from + ``arrayList[0]``. + formats, names, titles, aligned, byteorder : + If `dtype` is ``None``, these arguments are passed to + `numpy.rec.format_parser` to construct a dtype. See that function for + detailed documentation. + + Returns + ------- + np.recarray + Record array consisting of given arrayList columns. + + Examples + -------- + >>> x1=np.array([1,2,3,4]) + >>> x2=np.array(['a','dd','xyz','12']) + >>> x3=np.array([1.1,2,3,4]) + >>> r = np.rec.fromarrays([x1,x2,x3],names='a,b,c') + >>> print(r[1]) + (2, 'dd', 2.0) # may vary + >>> x1[1]=34 + >>> r.a + array([1, 2, 3, 4]) + + >>> x1 = np.array([1, 2, 3, 4]) + >>> x2 = np.array(['a', 'dd', 'xyz', '12']) + >>> x3 = np.array([1.1, 2, 3,4]) + >>> r = np.rec.fromarrays( + ... [x1, x2, x3], + ... dtype=np.dtype([('a', np.int32), ('b', 'S3'), ('c', np.float32)])) + >>> r + rec.array([(1, b'a', 1.1), (2, b'dd', 2. ), (3, b'xyz', 3. ), + (4, b'12', 4. )], + dtype=[('a', ' 0: + shape = shape[:-nn] + + _array = recarray(shape, descr) + + # populate the record array (makes a copy) + for k, obj in enumerate(arrayList): + nn = descr[k].ndim + testshape = obj.shape[:obj.ndim - nn] + name = _names[k] + if testshape != shape: + raise ValueError(f'array-shape mismatch in array {k} ("{name}")') + + _array[name] = obj + + return _array + + +@set_module("numpy.rec") +def fromrecords(recList, dtype=None, shape=None, formats=None, names=None, + titles=None, aligned=False, byteorder=None): + """Create a recarray from a list of records in text form. + + Parameters + ---------- + recList : sequence + data in the same field may be heterogeneous - they will be promoted + to the highest data type. + dtype : data-type, optional + valid dtype for all arrays + shape : int or tuple of ints, optional + shape of each array. + formats, names, titles, aligned, byteorder : + If `dtype` is ``None``, these arguments are passed to + `numpy.format_parser` to construct a dtype. See that function for + detailed documentation. + + If both `formats` and `dtype` are None, then this will auto-detect + formats. Use list of tuples rather than list of lists for faster + processing. + + Returns + ------- + np.recarray + record array consisting of given recList rows. + + Examples + -------- + >>> r=np.rec.fromrecords([(456,'dbe',1.2),(2,'de',1.3)], + ... names='col1,col2,col3') + >>> print(r[0]) + (456, 'dbe', 1.2) + >>> r.col1 + array([456, 2]) + >>> r.col2 + array(['dbe', 'de'], dtype='>> import pickle + >>> pickle.loads(pickle.dumps(r)) + rec.array([(456, 'dbe', 1.2), ( 2, 'de', 1.3)], + dtype=[('col1', ' 1: + raise ValueError("Can only deal with 1-d array.") + _array = recarray(shape, descr) + for k in range(_array.size): + _array[k] = tuple(recList[k]) + # list of lists instead of list of tuples ? + # 2018-02-07, 1.14.1 + warnings.warn( + "fromrecords expected a list of tuples, may have received a list " + "of lists instead. In the future that will raise an error", + FutureWarning, stacklevel=2) + return _array + else: + if shape is not None and retval.shape != shape: + retval.shape = shape + + res = retval.view(recarray) + + return res + + +@set_module("numpy.rec") +def fromstring(datastring, dtype=None, shape=None, offset=0, formats=None, + names=None, titles=None, aligned=False, byteorder=None): + r"""Create a record array from binary data + + Note that despite the name of this function it does not accept `str` + instances. + + Parameters + ---------- + datastring : bytes-like + Buffer of binary data + dtype : data-type, optional + Valid dtype for all arrays + shape : int or tuple of ints, optional + Shape of each array. + offset : int, optional + Position in the buffer to start reading from. + formats, names, titles, aligned, byteorder : + If `dtype` is ``None``, these arguments are passed to + `numpy.format_parser` to construct a dtype. See that function for + detailed documentation. + + + Returns + ------- + np.recarray + Record array view into the data in datastring. This will be readonly + if `datastring` is readonly. + + See Also + -------- + numpy.frombuffer + + Examples + -------- + >>> a = b'\x01\x02\x03abc' + >>> np.rec.fromstring(a, dtype='u1,u1,u1,S3') + rec.array([(1, 2, 3, b'abc')], + dtype=[('f0', 'u1'), ('f1', 'u1'), ('f2', 'u1'), ('f3', 'S3')]) + + >>> grades_dtype = [('Name', (np.str_, 10)), ('Marks', np.float64), + ... ('GradeLevel', np.int32)] + >>> grades_array = np.array([('Sam', 33.3, 3), ('Mike', 44.4, 5), + ... ('Aadi', 66.6, 6)], dtype=grades_dtype) + >>> np.rec.fromstring(grades_array.tobytes(), dtype=grades_dtype) + rec.array([('Sam', 33.3, 3), ('Mike', 44.4, 5), ('Aadi', 66.6, 6)], + dtype=[('Name', '>> s = '\x01\x02\x03abc' + >>> np.rec.fromstring(s, dtype='u1,u1,u1,S3') + Traceback (most recent call last): + ... + TypeError: a bytes-like object is required, not 'str' + """ + + if dtype is None and formats is None: + raise TypeError("fromstring() needs a 'dtype' or 'formats' argument") + + if dtype is not None: + descr = sb.dtype(dtype) + else: + descr = format_parser(formats, names, titles, aligned, byteorder).dtype + + itemsize = descr.itemsize + + # NumPy 1.19.0, 2020-01-01 + shape = _deprecate_shape_0_as_None(shape) + + if shape in (None, -1): + shape = (len(datastring) - offset) // itemsize + + _array = recarray(shape, descr, buf=datastring, offset=offset) + return _array + +def get_remaining_size(fd): + pos = fd.tell() + try: + fd.seek(0, 2) + return fd.tell() - pos + finally: + fd.seek(pos, 0) + + +@set_module("numpy.rec") +def fromfile(fd, dtype=None, shape=None, offset=0, formats=None, + names=None, titles=None, aligned=False, byteorder=None): + """Create an array from binary file data + + Parameters + ---------- + fd : str or file type + If file is a string or a path-like object then that file is opened, + else it is assumed to be a file object. The file object must + support random access (i.e. it must have tell and seek methods). + dtype : data-type, optional + valid dtype for all arrays + shape : int or tuple of ints, optional + shape of each array. + offset : int, optional + Position in the file to start reading from. + formats, names, titles, aligned, byteorder : + If `dtype` is ``None``, these arguments are passed to + `numpy.format_parser` to construct a dtype. See that function for + detailed documentation + + Returns + ------- + np.recarray + record array consisting of data enclosed in file. + + Examples + -------- + >>> from tempfile import TemporaryFile + >>> a = np.empty(10,dtype='f8,i4,a5') + >>> a[5] = (0.5,10,'abcde') + >>> + >>> fd=TemporaryFile() + >>> a = a.view(a.dtype.newbyteorder('<')) + >>> a.tofile(fd) + >>> + >>> _ = fd.seek(0) + >>> r=np.rec.fromfile(fd, formats='f8,i4,a5', shape=10, + ... byteorder='<') + >>> print(r[5]) + (0.5, 10, b'abcde') + >>> r.shape + (10,) + """ + + if dtype is None and formats is None: + raise TypeError("fromfile() needs a 'dtype' or 'formats' argument") + + # NumPy 1.19.0, 2020-01-01 + shape = _deprecate_shape_0_as_None(shape) + + if shape is None: + shape = (-1,) + elif isinstance(shape, int): + shape = (shape,) + + if hasattr(fd, 'readinto'): + # GH issue 2504. fd supports io.RawIOBase or io.BufferedIOBase + # interface. Example of fd: gzip, BytesIO, BufferedReader + # file already opened + ctx = nullcontext(fd) + else: + # open file + ctx = open(os.fspath(fd), 'rb') + + with ctx as fd: + if offset > 0: + fd.seek(offset, 1) + size = get_remaining_size(fd) + + if dtype is not None: + descr = sb.dtype(dtype) + else: + descr = format_parser( + formats, names, titles, aligned, byteorder + ).dtype + + itemsize = descr.itemsize + + shapeprod = sb.array(shape).prod(dtype=nt.intp) + shapesize = shapeprod * itemsize + if shapesize < 0: + shape = list(shape) + shape[shape.index(-1)] = size // -shapesize + shape = tuple(shape) + shapeprod = sb.array(shape).prod(dtype=nt.intp) + + nbytes = shapeprod * itemsize + + if nbytes > size: + raise ValueError( + "Not enough bytes left in file for specified " + "shape and type." + ) + + # create the array + _array = recarray(shape, descr) + nbytesread = fd.readinto(_array.data) + if nbytesread != nbytes: + raise OSError("Didn't read as many bytes as expected") + + return _array + + +@set_module("numpy.rec") +def array(obj, dtype=None, shape=None, offset=0, strides=None, formats=None, + names=None, titles=None, aligned=False, byteorder=None, copy=True): + """ + Construct a record array from a wide-variety of objects. + + A general-purpose record array constructor that dispatches to the + appropriate `recarray` creation function based on the inputs (see Notes). + + Parameters + ---------- + obj : any + Input object. See Notes for details on how various input types are + treated. + dtype : data-type, optional + Valid dtype for array. + shape : int or tuple of ints, optional + Shape of each array. + offset : int, optional + Position in the file or buffer to start reading from. + strides : tuple of ints, optional + Buffer (`buf`) is interpreted according to these strides (strides + define how many bytes each array element, row, column, etc. + occupy in memory). + formats, names, titles, aligned, byteorder : + If `dtype` is ``None``, these arguments are passed to + `numpy.format_parser` to construct a dtype. See that function for + detailed documentation. + copy : bool, optional + Whether to copy the input object (True), or to use a reference instead. + This option only applies when the input is an ndarray or recarray. + Defaults to True. + + Returns + ------- + np.recarray + Record array created from the specified object. + + Notes + ----- + If `obj` is ``None``, then call the `~numpy.recarray` constructor. If + `obj` is a string, then call the `fromstring` constructor. If `obj` is a + list or a tuple, then if the first object is an `~numpy.ndarray`, call + `fromarrays`, otherwise call `fromrecords`. If `obj` is a + `~numpy.recarray`, then make a copy of the data in the recarray + (if ``copy=True``) and use the new formats, names, and titles. If `obj` + is a file, then call `fromfile`. Finally, if obj is an `ndarray`, then + return ``obj.view(recarray)``, making a copy of the data if ``copy=True``. + + Examples + -------- + >>> a = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]) + >>> a + array([[1, 2, 3], + [4, 5, 6], + [7, 8, 9]]) + + >>> np.rec.array(a) + rec.array([[1, 2, 3], + [4, 5, 6], + [7, 8, 9]], + dtype=int64) + + >>> b = [(1, 1), (2, 4), (3, 9)] + >>> c = np.rec.array(b, formats = ['i2', 'f2'], names = ('x', 'y')) + >>> c + rec.array([(1, 1.), (2, 4.), (3, 9.)], + dtype=[('x', '>> c.x + array([1, 2, 3], dtype=int16) + + >>> c.y + array([1., 4., 9.], dtype=float16) + + >>> r = np.rec.array(['abc','def'], names=['col1','col2']) + >>> print(r.col1) + abc + + >>> r.col1 + array('abc', dtype='>> r.col2 + array('def', dtype=' object: ... + def tell(self, /) -> int: ... + def readinto(self, buffer: memoryview, /) -> int: ... + +class record(void): + def __getattribute__(self, attr: str) -> Any: ... + def __setattr__(self, attr: str, val: ArrayLike) -> None: ... + def pprint(self) -> str: ... + @overload + def __getitem__(self, key: str | SupportsIndex) -> Any: ... + @overload + def __getitem__(self, key: list[str]) -> record: ... + +class recarray(ndarray[_ShapeType_co, _DType_co]): + # NOTE: While not strictly mandatory, we're demanding here that arguments + # for the `format_parser`- and `dtype`-based dtype constructors are + # mutually exclusive + @overload + def __new__( + subtype, + shape: _ShapeLike, + dtype: None = ..., + buf: None | _SupportsBuffer = ..., + offset: SupportsIndex = ..., + strides: None | _ShapeLike = ..., + *, + formats: DTypeLike, + names: None | str | Sequence[str] = ..., + titles: None | str | Sequence[str] = ..., + byteorder: None | _ByteOrder = ..., + aligned: bool = ..., + order: _OrderKACF = ..., + ) -> recarray[Any, dtype[record]]: ... + @overload + def __new__( + subtype, + shape: _ShapeLike, + dtype: DTypeLike, + buf: None | _SupportsBuffer = ..., + offset: SupportsIndex = ..., + strides: None | _ShapeLike = ..., + formats: None = ..., + names: None = ..., + titles: None = ..., + byteorder: None = ..., + aligned: Literal[False] = ..., + order: _OrderKACF = ..., + ) -> recarray[Any, dtype[Any]]: ... + def __array_finalize__(self, obj: object) -> None: ... + def __getattribute__(self, attr: str) -> Any: ... + def __setattr__(self, attr: str, val: ArrayLike) -> None: ... + @overload + def __getitem__(self, indx: ( + SupportsIndex + | _ArrayLikeInt_co + | tuple[SupportsIndex | _ArrayLikeInt_co, ...] + )) -> Any: ... + @overload + def __getitem__(self: recarray[Any, dtype[void]], indx: ( + None + | slice + | ellipsis + | SupportsIndex + | _ArrayLikeInt_co + | tuple[None | slice | ellipsis | _ArrayLikeInt_co | SupportsIndex, ...] + )) -> recarray[Any, _DType_co]: ... + @overload + def __getitem__(self, indx: ( + None + | slice + | ellipsis + | SupportsIndex + | _ArrayLikeInt_co + | tuple[None | slice | ellipsis | _ArrayLikeInt_co | SupportsIndex, ...] + )) -> ndarray[Any, _DType_co]: ... + @overload + def __getitem__(self, indx: str) -> NDArray[Any]: ... + @overload + def __getitem__(self, indx: list[str]) -> recarray[_ShapeType_co, dtype[record]]: ... + @overload + def field(self, attr: int | str, val: None = ...) -> Any: ... + @overload + def field(self, attr: int | str, val: ArrayLike) -> None: ... + +class format_parser: + dtype: dtype[void] + def __init__( + self, + formats: DTypeLike, + names: None | str | Sequence[str], + titles: None | str | Sequence[str], + aligned: bool = ..., + byteorder: None | _ByteOrder = ..., + ) -> None: ... + +__all__: list[str] + +@overload +def fromarrays( + arrayList: Iterable[ArrayLike], + dtype: DTypeLike = ..., + shape: None | _ShapeLike = ..., + formats: None = ..., + names: None = ..., + titles: None = ..., + aligned: bool = ..., + byteorder: None = ..., +) -> _RecArray[Any]: ... +@overload +def fromarrays( + arrayList: Iterable[ArrayLike], + dtype: None = ..., + shape: None | _ShapeLike = ..., + *, + formats: DTypeLike, + names: None | str | Sequence[str] = ..., + titles: None | str | Sequence[str] = ..., + aligned: bool = ..., + byteorder: None | _ByteOrder = ..., +) -> _RecArray[record]: ... + +@overload +def fromrecords( + recList: _ArrayLikeVoid_co | tuple[Any, ...] | _NestedSequence[tuple[Any, ...]], + dtype: DTypeLike = ..., + shape: None | _ShapeLike = ..., + formats: None = ..., + names: None = ..., + titles: None = ..., + aligned: bool = ..., + byteorder: None = ..., +) -> _RecArray[record]: ... +@overload +def fromrecords( + recList: _ArrayLikeVoid_co | tuple[Any, ...] | _NestedSequence[tuple[Any, ...]], + dtype: None = ..., + shape: None | _ShapeLike = ..., + *, + formats: DTypeLike = ..., + names: None | str | Sequence[str] = ..., + titles: None | str | Sequence[str] = ..., + aligned: bool = ..., + byteorder: None | _ByteOrder = ..., +) -> _RecArray[record]: ... + +@overload +def fromstring( + datastring: _SupportsBuffer, + dtype: DTypeLike, + shape: None | _ShapeLike = ..., + offset: int = ..., + formats: None = ..., + names: None = ..., + titles: None = ..., + aligned: bool = ..., + byteorder: None = ..., +) -> _RecArray[record]: ... +@overload +def fromstring( + datastring: _SupportsBuffer, + dtype: None = ..., + shape: None | _ShapeLike = ..., + offset: int = ..., + *, + formats: DTypeLike, + names: None | str | Sequence[str] = ..., + titles: None | str | Sequence[str] = ..., + aligned: bool = ..., + byteorder: None | _ByteOrder = ..., +) -> _RecArray[record]: ... + +@overload +def fromfile( + fd: str | bytes | os.PathLike[str] | os.PathLike[bytes] | _SupportsReadInto, + dtype: DTypeLike, + shape: None | _ShapeLike = ..., + offset: int = ..., + formats: None = ..., + names: None = ..., + titles: None = ..., + aligned: bool = ..., + byteorder: None = ..., +) -> _RecArray[Any]: ... +@overload +def fromfile( + fd: str | bytes | os.PathLike[str] | os.PathLike[bytes] | _SupportsReadInto, + dtype: None = ..., + shape: None | _ShapeLike = ..., + offset: int = ..., + *, + formats: DTypeLike, + names: None | str | Sequence[str] = ..., + titles: None | str | Sequence[str] = ..., + aligned: bool = ..., + byteorder: None | _ByteOrder = ..., +) -> _RecArray[record]: ... + +@overload +def array( + obj: _SCT | NDArray[_SCT], + dtype: None = ..., + shape: None | _ShapeLike = ..., + offset: int = ..., + formats: None = ..., + names: None = ..., + titles: None = ..., + aligned: bool = ..., + byteorder: None = ..., + copy: bool = ..., +) -> _RecArray[_SCT]: ... +@overload +def array( + obj: ArrayLike, + dtype: DTypeLike, + shape: None | _ShapeLike = ..., + offset: int = ..., + formats: None = ..., + names: None = ..., + titles: None = ..., + aligned: bool = ..., + byteorder: None = ..., + copy: bool = ..., +) -> _RecArray[Any]: ... +@overload +def array( + obj: ArrayLike, + dtype: None = ..., + shape: None | _ShapeLike = ..., + offset: int = ..., + *, + formats: DTypeLike, + names: None | str | Sequence[str] = ..., + titles: None | str | Sequence[str] = ..., + aligned: bool = ..., + byteorder: None | _ByteOrder = ..., + copy: bool = ..., +) -> _RecArray[record]: ... +@overload +def array( + obj: None, + dtype: DTypeLike, + shape: _ShapeLike, + offset: int = ..., + formats: None = ..., + names: None = ..., + titles: None = ..., + aligned: bool = ..., + byteorder: None = ..., + copy: bool = ..., +) -> _RecArray[Any]: ... +@overload +def array( + obj: None, + dtype: None = ..., + *, + shape: _ShapeLike, + offset: int = ..., + formats: DTypeLike, + names: None | str | Sequence[str] = ..., + titles: None | str | Sequence[str] = ..., + aligned: bool = ..., + byteorder: None | _ByteOrder = ..., + copy: bool = ..., +) -> _RecArray[record]: ... +@overload +def array( + obj: _SupportsReadInto, + dtype: DTypeLike, + shape: None | _ShapeLike = ..., + offset: int = ..., + formats: None = ..., + names: None = ..., + titles: None = ..., + aligned: bool = ..., + byteorder: None = ..., + copy: bool = ..., +) -> _RecArray[Any]: ... +@overload +def array( + obj: _SupportsReadInto, + dtype: None = ..., + shape: None | _ShapeLike = ..., + offset: int = ..., + *, + formats: DTypeLike, + names: None | str | Sequence[str] = ..., + titles: None | str | Sequence[str] = ..., + aligned: bool = ..., + byteorder: None | _ByteOrder = ..., + copy: bool = ..., +) -> _RecArray[record]: ... diff --git a/venv/lib/python3.12/site-packages/numpy/_core/shape_base.py b/venv/lib/python3.12/site-packages/numpy/_core/shape_base.py new file mode 100644 index 00000000..ebee4c06 --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/shape_base.py @@ -0,0 +1,1004 @@ +__all__ = ['atleast_1d', 'atleast_2d', 'atleast_3d', 'block', 'hstack', + 'stack', 'unstack', 'vstack'] + +import functools +import itertools +import operator +import warnings + +from . import numeric as _nx +from . import overrides +from .multiarray import array, asanyarray, normalize_axis_index +from . import fromnumeric as _from_nx + +array_function_dispatch = functools.partial( + overrides.array_function_dispatch, module='numpy') + + +def _atleast_1d_dispatcher(*arys): + return arys + + +@array_function_dispatch(_atleast_1d_dispatcher) +def atleast_1d(*arys): + """ + Convert inputs to arrays with at least one dimension. + + Scalar inputs are converted to 1-dimensional arrays, whilst + higher-dimensional inputs are preserved. + + Parameters + ---------- + arys1, arys2, ... : array_like + One or more input arrays. + + Returns + ------- + ret : ndarray + An array, or tuple of arrays, each with ``a.ndim >= 1``. + Copies are made only if necessary. + + See Also + -------- + atleast_2d, atleast_3d + + Examples + -------- + >>> import numpy as np + >>> np.atleast_1d(1.0) + array([1.]) + + >>> x = np.arange(9.0).reshape(3,3) + >>> np.atleast_1d(x) + array([[0., 1., 2.], + [3., 4., 5.], + [6., 7., 8.]]) + >>> np.atleast_1d(x) is x + True + + >>> np.atleast_1d(1, [3, 4]) + (array([1]), array([3, 4])) + + """ + if len(arys) == 1: + result = asanyarray(arys[0]) + if result.ndim == 0: + result = result.reshape(1) + return result + res = [] + for ary in arys: + result = asanyarray(ary) + if result.ndim == 0: + result = result.reshape(1) + res.append(result) + return tuple(res) + + +def _atleast_2d_dispatcher(*arys): + return arys + + +@array_function_dispatch(_atleast_2d_dispatcher) +def atleast_2d(*arys): + """ + View inputs as arrays with at least two dimensions. + + Parameters + ---------- + arys1, arys2, ... : array_like + One or more array-like sequences. Non-array inputs are converted + to arrays. Arrays that already have two or more dimensions are + preserved. + + Returns + ------- + res, res2, ... : ndarray + An array, or tuple of arrays, each with ``a.ndim >= 2``. + Copies are avoided where possible, and views with two or more + dimensions are returned. + + See Also + -------- + atleast_1d, atleast_3d + + Examples + -------- + >>> import numpy as np + >>> np.atleast_2d(3.0) + array([[3.]]) + + >>> x = np.arange(3.0) + >>> np.atleast_2d(x) + array([[0., 1., 2.]]) + >>> np.atleast_2d(x).base is x + True + + >>> np.atleast_2d(1, [1, 2], [[1, 2]]) + (array([[1]]), array([[1, 2]]), array([[1, 2]])) + + """ + res = [] + for ary in arys: + ary = asanyarray(ary) + if ary.ndim == 0: + result = ary.reshape(1, 1) + elif ary.ndim == 1: + result = ary[_nx.newaxis, :] + else: + result = ary + res.append(result) + if len(res) == 1: + return res[0] + else: + return tuple(res) + + +def _atleast_3d_dispatcher(*arys): + return arys + + +@array_function_dispatch(_atleast_3d_dispatcher) +def atleast_3d(*arys): + """ + View inputs as arrays with at least three dimensions. + + Parameters + ---------- + arys1, arys2, ... : array_like + One or more array-like sequences. Non-array inputs are converted to + arrays. Arrays that already have three or more dimensions are + preserved. + + Returns + ------- + res1, res2, ... : ndarray + An array, or tuple of arrays, each with ``a.ndim >= 3``. Copies are + avoided where possible, and views with three or more dimensions are + returned. For example, a 1-D array of shape ``(N,)`` becomes a view + of shape ``(1, N, 1)``, and a 2-D array of shape ``(M, N)`` becomes a + view of shape ``(M, N, 1)``. + + See Also + -------- + atleast_1d, atleast_2d + + Examples + -------- + >>> import numpy as np + >>> np.atleast_3d(3.0) + array([[[3.]]]) + + >>> x = np.arange(3.0) + >>> np.atleast_3d(x).shape + (1, 3, 1) + + >>> x = np.arange(12.0).reshape(4,3) + >>> np.atleast_3d(x).shape + (4, 3, 1) + >>> np.atleast_3d(x).base is x.base # x is a reshape, so not base itself + True + + >>> for arr in np.atleast_3d([1, 2], [[1, 2]], [[[1, 2]]]): + ... print(arr, arr.shape) # doctest: +SKIP + ... + [[[1] + [2]]] (1, 2, 1) + [[[1] + [2]]] (1, 2, 1) + [[[1 2]]] (1, 1, 2) + + """ + res = [] + for ary in arys: + ary = asanyarray(ary) + if ary.ndim == 0: + result = ary.reshape(1, 1, 1) + elif ary.ndim == 1: + result = ary[_nx.newaxis, :, _nx.newaxis] + elif ary.ndim == 2: + result = ary[:, :, _nx.newaxis] + else: + result = ary + res.append(result) + if len(res) == 1: + return res[0] + else: + return tuple(res) + + +def _arrays_for_stack_dispatcher(arrays): + if not hasattr(arrays, "__getitem__"): + raise TypeError('arrays to stack must be passed as a "sequence" type ' + 'such as list or tuple.') + + return tuple(arrays) + + +def _vhstack_dispatcher(tup, *, dtype=None, casting=None): + return _arrays_for_stack_dispatcher(tup) + + +@array_function_dispatch(_vhstack_dispatcher) +def vstack(tup, *, dtype=None, casting="same_kind"): + """ + Stack arrays in sequence vertically (row wise). + + This is equivalent to concatenation along the first axis after 1-D arrays + of shape `(N,)` have been reshaped to `(1,N)`. Rebuilds arrays divided by + `vsplit`. + + This function makes most sense for arrays with up to 3 dimensions. For + instance, for pixel-data with a height (first axis), width (second axis), + and r/g/b channels (third axis). The functions `concatenate`, `stack` and + `block` provide more general stacking and concatenation operations. + + Parameters + ---------- + tup : sequence of ndarrays + The arrays must have the same shape along all but the first axis. + 1-D arrays must have the same length. + + dtype : str or dtype + If provided, the destination array will have this dtype. Cannot be + provided together with `out`. + + .. versionadded:: 1.24 + + casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional + Controls what kind of data casting may occur. Defaults to 'same_kind'. + + .. versionadded:: 1.24 + + Returns + ------- + stacked : ndarray + The array formed by stacking the given arrays, will be at least 2-D. + + See Also + -------- + concatenate : Join a sequence of arrays along an existing axis. + stack : Join a sequence of arrays along a new axis. + block : Assemble an nd-array from nested lists of blocks. + hstack : Stack arrays in sequence horizontally (column wise). + dstack : Stack arrays in sequence depth wise (along third axis). + column_stack : Stack 1-D arrays as columns into a 2-D array. + vsplit : Split an array into multiple sub-arrays vertically (row-wise). + unstack : Split an array into a tuple of sub-arrays along an axis. + + Examples + -------- + >>> import numpy as np + >>> a = np.array([1, 2, 3]) + >>> b = np.array([4, 5, 6]) + >>> np.vstack((a,b)) + array([[1, 2, 3], + [4, 5, 6]]) + + >>> a = np.array([[1], [2], [3]]) + >>> b = np.array([[4], [5], [6]]) + >>> np.vstack((a,b)) + array([[1], + [2], + [3], + [4], + [5], + [6]]) + + """ + arrs = atleast_2d(*tup) + if not isinstance(arrs, tuple): + arrs = (arrs,) + return _nx.concatenate(arrs, 0, dtype=dtype, casting=casting) + + +@array_function_dispatch(_vhstack_dispatcher) +def hstack(tup, *, dtype=None, casting="same_kind"): + """ + Stack arrays in sequence horizontally (column wise). + + This is equivalent to concatenation along the second axis, except for 1-D + arrays where it concatenates along the first axis. Rebuilds arrays divided + by `hsplit`. + + This function makes most sense for arrays with up to 3 dimensions. For + instance, for pixel-data with a height (first axis), width (second axis), + and r/g/b channels (third axis). The functions `concatenate`, `stack` and + `block` provide more general stacking and concatenation operations. + + Parameters + ---------- + tup : sequence of ndarrays + The arrays must have the same shape along all but the second axis, + except 1-D arrays which can be any length. + + dtype : str or dtype + If provided, the destination array will have this dtype. Cannot be + provided together with `out`. + + .. versionadded:: 1.24 + + casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional + Controls what kind of data casting may occur. Defaults to 'same_kind'. + + .. versionadded:: 1.24 + + Returns + ------- + stacked : ndarray + The array formed by stacking the given arrays. + + See Also + -------- + concatenate : Join a sequence of arrays along an existing axis. + stack : Join a sequence of arrays along a new axis. + block : Assemble an nd-array from nested lists of blocks. + vstack : Stack arrays in sequence vertically (row wise). + dstack : Stack arrays in sequence depth wise (along third axis). + column_stack : Stack 1-D arrays as columns into a 2-D array. + hsplit : Split an array into multiple sub-arrays + horizontally (column-wise). + unstack : Split an array into a tuple of sub-arrays along an axis. + + Examples + -------- + >>> import numpy as np + >>> a = np.array((1,2,3)) + >>> b = np.array((4,5,6)) + >>> np.hstack((a,b)) + array([1, 2, 3, 4, 5, 6]) + >>> a = np.array([[1],[2],[3]]) + >>> b = np.array([[4],[5],[6]]) + >>> np.hstack((a,b)) + array([[1, 4], + [2, 5], + [3, 6]]) + + """ + arrs = atleast_1d(*tup) + if not isinstance(arrs, tuple): + arrs = (arrs,) + # As a special case, dimension 0 of 1-dimensional arrays is "horizontal" + if arrs and arrs[0].ndim == 1: + return _nx.concatenate(arrs, 0, dtype=dtype, casting=casting) + else: + return _nx.concatenate(arrs, 1, dtype=dtype, casting=casting) + + +def _stack_dispatcher(arrays, axis=None, out=None, *, + dtype=None, casting=None): + arrays = _arrays_for_stack_dispatcher(arrays) + if out is not None: + # optimize for the typical case where only arrays is provided + arrays = list(arrays) + arrays.append(out) + return arrays + + +@array_function_dispatch(_stack_dispatcher) +def stack(arrays, axis=0, out=None, *, dtype=None, casting="same_kind"): + """ + Join a sequence of arrays along a new axis. + + The ``axis`` parameter specifies the index of the new axis in the + dimensions of the result. For example, if ``axis=0`` it will be the first + dimension and if ``axis=-1`` it will be the last dimension. + + .. versionadded:: 1.10.0 + + Parameters + ---------- + arrays : sequence of array_like + Each array must have the same shape. + + axis : int, optional + The axis in the result array along which the input arrays are stacked. + + out : ndarray, optional + If provided, the destination to place the result. The shape must be + correct, matching that of what stack would have returned if no + out argument were specified. + + dtype : str or dtype + If provided, the destination array will have this dtype. Cannot be + provided together with `out`. + + .. versionadded:: 1.24 + + casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional + Controls what kind of data casting may occur. Defaults to 'same_kind'. + + .. versionadded:: 1.24 + + + Returns + ------- + stacked : ndarray + The stacked array has one more dimension than the input arrays. + + See Also + -------- + concatenate : Join a sequence of arrays along an existing axis. + block : Assemble an nd-array from nested lists of blocks. + split : Split array into a list of multiple sub-arrays of equal size. + unstack : Split an array into a tuple of sub-arrays along an axis. + + Examples + -------- + >>> import numpy as np + >>> rng = np.random.default_rng() + >>> arrays = [rng.normal(size=(3,4)) for _ in range(10)] + >>> np.stack(arrays, axis=0).shape + (10, 3, 4) + + >>> np.stack(arrays, axis=1).shape + (3, 10, 4) + + >>> np.stack(arrays, axis=2).shape + (3, 4, 10) + + >>> a = np.array([1, 2, 3]) + >>> b = np.array([4, 5, 6]) + >>> np.stack((a, b)) + array([[1, 2, 3], + [4, 5, 6]]) + + >>> np.stack((a, b), axis=-1) + array([[1, 4], + [2, 5], + [3, 6]]) + + """ + arrays = [asanyarray(arr) for arr in arrays] + if not arrays: + raise ValueError('need at least one array to stack') + + shapes = {arr.shape for arr in arrays} + if len(shapes) != 1: + raise ValueError('all input arrays must have the same shape') + + result_ndim = arrays[0].ndim + 1 + axis = normalize_axis_index(axis, result_ndim) + + sl = (slice(None),) * axis + (_nx.newaxis,) + expanded_arrays = [arr[sl] for arr in arrays] + return _nx.concatenate(expanded_arrays, axis=axis, out=out, + dtype=dtype, casting=casting) + +def _unstack_dispatcher(x, /, *, axis=None): + return (x,) + +@array_function_dispatch(_unstack_dispatcher) +def unstack(x, /, *, axis=0): + """ + Split an array into a sequence of arrays along the given axis. + + The ``axis`` parameter specifies the dimension along which the array will + be split. For example, if ``axis=0`` (the default) it will be the first + dimension and if ``axis=-1`` it will be the last dimension. + + The result is a tuple of arrays split along ``axis``. + + .. versionadded:: 2.1.0 + + Parameters + ---------- + x : ndarray + The array to be unstacked. + axis : int, optional + Axis along which the array will be split. Default: ``0``. + + Returns + ------- + unstacked : tuple of ndarrays + The unstacked arrays. + + See Also + -------- + stack : Join a sequence of arrays along a new axis. + concatenate : Join a sequence of arrays along an existing axis. + block : Assemble an nd-array from nested lists of blocks. + split : Split array into a list of multiple sub-arrays of equal size. + + Notes + ----- + ``unstack`` serves as the reverse operation of :py:func:`stack`, i.e., + ``stack(unstack(x, axis=axis), axis=axis) == x``. + + This function is equivalent to ``tuple(np.moveaxis(x, axis, 0))``, since + iterating on an array iterates along the first axis. + + Examples + -------- + >>> arr = np.arange(24).reshape((2, 3, 4)) + >>> np.unstack(arr) + (array([[ 0, 1, 2, 3], + [ 4, 5, 6, 7], + [ 8, 9, 10, 11]]), + array([[12, 13, 14, 15], + [16, 17, 18, 19], + [20, 21, 22, 23]])) + >>> np.unstack(arr, axis=1) + (array([[ 0, 1, 2, 3], + [12, 13, 14, 15]]), + array([[ 4, 5, 6, 7], + [16, 17, 18, 19]]), + array([[ 8, 9, 10, 11], + [20, 21, 22, 23]])) + >>> arr2 = np.stack(np.unstack(arr, axis=1), axis=1) + >>> arr2.shape + (2, 3, 4) + >>> np.all(arr == arr2) + np.True_ + + """ + if x.ndim == 0: + raise ValueError("Input array must be at least 1-d.") + return tuple(_nx.moveaxis(x, axis, 0)) + +# Internal functions to eliminate the overhead of repeated dispatch in one of +# the two possible paths inside np.block. +# Use getattr to protect against __array_function__ being disabled. +_size = getattr(_from_nx.size, '__wrapped__', _from_nx.size) +_ndim = getattr(_from_nx.ndim, '__wrapped__', _from_nx.ndim) +_concatenate = getattr(_from_nx.concatenate, + '__wrapped__', _from_nx.concatenate) + + +def _block_format_index(index): + """ + Convert a list of indices ``[0, 1, 2]`` into ``"arrays[0][1][2]"``. + """ + idx_str = ''.join('[{}]'.format(i) for i in index if i is not None) + return 'arrays' + idx_str + + +def _block_check_depths_match(arrays, parent_index=[]): + """ + Recursive function checking that the depths of nested lists in `arrays` + all match. Mismatch raises a ValueError as described in the block + docstring below. + + The entire index (rather than just the depth) needs to be calculated + for each innermost list, in case an error needs to be raised, so that + the index of the offending list can be printed as part of the error. + + Parameters + ---------- + arrays : nested list of arrays + The arrays to check + parent_index : list of int + The full index of `arrays` within the nested lists passed to + `_block_check_depths_match` at the top of the recursion. + + Returns + ------- + first_index : list of int + The full index of an element from the bottom of the nesting in + `arrays`. If any element at the bottom is an empty list, this will + refer to it, and the last index along the empty axis will be None. + max_arr_ndim : int + The maximum of the ndims of the arrays nested in `arrays`. + final_size: int + The number of elements in the final array. This is used the motivate + the choice of algorithm used using benchmarking wisdom. + + """ + if type(arrays) is tuple: + # not strictly necessary, but saves us from: + # - more than one way to do things - no point treating tuples like + # lists + # - horribly confusing behaviour that results when tuples are + # treated like ndarray + raise TypeError( + '{} is a tuple. ' + 'Only lists can be used to arrange blocks, and np.block does ' + 'not allow implicit conversion from tuple to ndarray.'.format( + _block_format_index(parent_index) + ) + ) + elif type(arrays) is list and len(arrays) > 0: + idxs_ndims = (_block_check_depths_match(arr, parent_index + [i]) + for i, arr in enumerate(arrays)) + + first_index, max_arr_ndim, final_size = next(idxs_ndims) + for index, ndim, size in idxs_ndims: + final_size += size + if ndim > max_arr_ndim: + max_arr_ndim = ndim + if len(index) != len(first_index): + raise ValueError( + "List depths are mismatched. First element was at depth " + "{}, but there is an element at depth {} ({})".format( + len(first_index), + len(index), + _block_format_index(index) + ) + ) + # propagate our flag that indicates an empty list at the bottom + if index[-1] is None: + first_index = index + + return first_index, max_arr_ndim, final_size + elif type(arrays) is list and len(arrays) == 0: + # We've 'bottomed out' on an empty list + return parent_index + [None], 0, 0 + else: + # We've 'bottomed out' - arrays is either a scalar or an array + size = _size(arrays) + return parent_index, _ndim(arrays), size + + +def _atleast_nd(a, ndim): + # Ensures `a` has at least `ndim` dimensions by prepending + # ones to `a.shape` as necessary + return array(a, ndmin=ndim, copy=None, subok=True) + + +def _accumulate(values): + return list(itertools.accumulate(values)) + + +def _concatenate_shapes(shapes, axis): + """Given array shapes, return the resulting shape and slices prefixes. + + These help in nested concatenation. + + Returns + ------- + shape: tuple of int + This tuple satisfies:: + + shape, _ = _concatenate_shapes([arr.shape for shape in arrs], axis) + shape == concatenate(arrs, axis).shape + + slice_prefixes: tuple of (slice(start, end), ) + For a list of arrays being concatenated, this returns the slice + in the larger array at axis that needs to be sliced into. + + For example, the following holds:: + + ret = concatenate([a, b, c], axis) + _, (sl_a, sl_b, sl_c) = concatenate_slices([a, b, c], axis) + + ret[(slice(None),) * axis + sl_a] == a + ret[(slice(None),) * axis + sl_b] == b + ret[(slice(None),) * axis + sl_c] == c + + These are called slice prefixes since they are used in the recursive + blocking algorithm to compute the left-most slices during the + recursion. Therefore, they must be prepended to rest of the slice + that was computed deeper in the recursion. + + These are returned as tuples to ensure that they can quickly be added + to existing slice tuple without creating a new tuple every time. + + """ + # Cache a result that will be reused. + shape_at_axis = [shape[axis] for shape in shapes] + + # Take a shape, any shape + first_shape = shapes[0] + first_shape_pre = first_shape[:axis] + first_shape_post = first_shape[axis+1:] + + if any(shape[:axis] != first_shape_pre or + shape[axis+1:] != first_shape_post for shape in shapes): + raise ValueError( + 'Mismatched array shapes in block along axis {}.'.format(axis)) + + shape = (first_shape_pre + (sum(shape_at_axis),) + first_shape[axis+1:]) + + offsets_at_axis = _accumulate(shape_at_axis) + slice_prefixes = [(slice(start, end),) + for start, end in zip([0] + offsets_at_axis, + offsets_at_axis)] + return shape, slice_prefixes + + +def _block_info_recursion(arrays, max_depth, result_ndim, depth=0): + """ + Returns the shape of the final array, along with a list + of slices and a list of arrays that can be used for assignment inside the + new array + + Parameters + ---------- + arrays : nested list of arrays + The arrays to check + max_depth : list of int + The number of nested lists + result_ndim : int + The number of dimensions in thefinal array. + + Returns + ------- + shape : tuple of int + The shape that the final array will take on. + slices: list of tuple of slices + The slices into the full array required for assignment. These are + required to be prepended with ``(Ellipsis, )`` to obtain to correct + final index. + arrays: list of ndarray + The data to assign to each slice of the full array + + """ + if depth < max_depth: + shapes, slices, arrays = zip( + *[_block_info_recursion(arr, max_depth, result_ndim, depth+1) + for arr in arrays]) + + axis = result_ndim - max_depth + depth + shape, slice_prefixes = _concatenate_shapes(shapes, axis) + + # Prepend the slice prefix and flatten the slices + slices = [slice_prefix + the_slice + for slice_prefix, inner_slices in zip(slice_prefixes, slices) + for the_slice in inner_slices] + + # Flatten the array list + arrays = functools.reduce(operator.add, arrays) + + return shape, slices, arrays + else: + # We've 'bottomed out' - arrays is either a scalar or an array + # type(arrays) is not list + # Return the slice and the array inside a list to be consistent with + # the recursive case. + arr = _atleast_nd(arrays, result_ndim) + return arr.shape, [()], [arr] + + +def _block(arrays, max_depth, result_ndim, depth=0): + """ + Internal implementation of block based on repeated concatenation. + `arrays` is the argument passed to + block. `max_depth` is the depth of nested lists within `arrays` and + `result_ndim` is the greatest of the dimensions of the arrays in + `arrays` and the depth of the lists in `arrays` (see block docstring + for details). + """ + if depth < max_depth: + arrs = [_block(arr, max_depth, result_ndim, depth+1) + for arr in arrays] + return _concatenate(arrs, axis=-(max_depth-depth)) + else: + # We've 'bottomed out' - arrays is either a scalar or an array + # type(arrays) is not list + return _atleast_nd(arrays, result_ndim) + + +def _block_dispatcher(arrays): + # Use type(...) is list to match the behavior of np.block(), which special + # cases list specifically rather than allowing for generic iterables or + # tuple. Also, we know that list.__array_function__ will never exist. + if type(arrays) is list: + for subarrays in arrays: + yield from _block_dispatcher(subarrays) + else: + yield arrays + + +@array_function_dispatch(_block_dispatcher) +def block(arrays): + """ + Assemble an nd-array from nested lists of blocks. + + Blocks in the innermost lists are concatenated (see `concatenate`) along + the last dimension (-1), then these are concatenated along the + second-last dimension (-2), and so on until the outermost list is reached. + + Blocks can be of any dimension, but will not be broadcasted using + the normal rules. Instead, leading axes of size 1 are inserted, + to make ``block.ndim`` the same for all blocks. This is primarily useful + for working with scalars, and means that code like ``np.block([v, 1])`` + is valid, where ``v.ndim == 1``. + + When the nested list is two levels deep, this allows block matrices to be + constructed from their components. + + .. versionadded:: 1.13.0 + + Parameters + ---------- + arrays : nested list of array_like or scalars (but not tuples) + If passed a single ndarray or scalar (a nested list of depth 0), this + is returned unmodified (and not copied). + + Elements shapes must match along the appropriate axes (without + broadcasting), but leading 1s will be prepended to the shape as + necessary to make the dimensions match. + + Returns + ------- + block_array : ndarray + The array assembled from the given blocks. + + The dimensionality of the output is equal to the greatest of: + + * the dimensionality of all the inputs + * the depth to which the input list is nested + + Raises + ------ + ValueError + * If list depths are mismatched - for instance, ``[[a, b], c]`` is + illegal, and should be spelt ``[[a, b], [c]]`` + * If lists are empty - for instance, ``[[a, b], []]`` + + See Also + -------- + concatenate : Join a sequence of arrays along an existing axis. + stack : Join a sequence of arrays along a new axis. + vstack : Stack arrays in sequence vertically (row wise). + hstack : Stack arrays in sequence horizontally (column wise). + dstack : Stack arrays in sequence depth wise (along third axis). + column_stack : Stack 1-D arrays as columns into a 2-D array. + vsplit : Split an array into multiple sub-arrays vertically (row-wise). + unstack : Split an array into a tuple of sub-arrays along an axis. + + Notes + ----- + + When called with only scalars, ``np.block`` is equivalent to an ndarray + call. So ``np.block([[1, 2], [3, 4]])`` is equivalent to + ``np.array([[1, 2], [3, 4]])``. + + This function does not enforce that the blocks lie on a fixed grid. + ``np.block([[a, b], [c, d]])`` is not restricted to arrays of the form:: + + AAAbb + AAAbb + cccDD + + But is also allowed to produce, for some ``a, b, c, d``:: + + AAAbb + AAAbb + cDDDD + + Since concatenation happens along the last axis first, `block` is *not* + capable of producing the following directly:: + + AAAbb + cccbb + cccDD + + Matlab's "square bracket stacking", ``[A, B, ...; p, q, ...]``, is + equivalent to ``np.block([[A, B, ...], [p, q, ...]])``. + + Examples + -------- + The most common use of this function is to build a block matrix: + + >>> import numpy as np + >>> A = np.eye(2) * 2 + >>> B = np.eye(3) * 3 + >>> np.block([ + ... [A, np.zeros((2, 3))], + ... [np.ones((3, 2)), B ] + ... ]) + array([[2., 0., 0., 0., 0.], + [0., 2., 0., 0., 0.], + [1., 1., 3., 0., 0.], + [1., 1., 0., 3., 0.], + [1., 1., 0., 0., 3.]]) + + With a list of depth 1, `block` can be used as `hstack`: + + >>> np.block([1, 2, 3]) # hstack([1, 2, 3]) + array([1, 2, 3]) + + >>> a = np.array([1, 2, 3]) + >>> b = np.array([4, 5, 6]) + >>> np.block([a, b, 10]) # hstack([a, b, 10]) + array([ 1, 2, 3, 4, 5, 6, 10]) + + >>> A = np.ones((2, 2), int) + >>> B = 2 * A + >>> np.block([A, B]) # hstack([A, B]) + array([[1, 1, 2, 2], + [1, 1, 2, 2]]) + + With a list of depth 2, `block` can be used in place of `vstack`: + + >>> a = np.array([1, 2, 3]) + >>> b = np.array([4, 5, 6]) + >>> np.block([[a], [b]]) # vstack([a, b]) + array([[1, 2, 3], + [4, 5, 6]]) + + >>> A = np.ones((2, 2), int) + >>> B = 2 * A + >>> np.block([[A], [B]]) # vstack([A, B]) + array([[1, 1], + [1, 1], + [2, 2], + [2, 2]]) + + It can also be used in place of `atleast_1d` and `atleast_2d`: + + >>> a = np.array(0) + >>> b = np.array([1]) + >>> np.block([a]) # atleast_1d(a) + array([0]) + >>> np.block([b]) # atleast_1d(b) + array([1]) + + >>> np.block([[a]]) # atleast_2d(a) + array([[0]]) + >>> np.block([[b]]) # atleast_2d(b) + array([[1]]) + + + """ + arrays, list_ndim, result_ndim, final_size = _block_setup(arrays) + + # It was found through benchmarking that making an array of final size + # around 256x256 was faster by straight concatenation on a + # i7-7700HQ processor and dual channel ram 2400MHz. + # It didn't seem to matter heavily on the dtype used. + # + # A 2D array using repeated concatenation requires 2 copies of the array. + # + # The fastest algorithm will depend on the ratio of CPU power to memory + # speed. + # One can monitor the results of the benchmark + # https://pv.github.io/numpy-bench/#bench_shape_base.Block2D.time_block2d + # to tune this parameter until a C version of the `_block_info_recursion` + # algorithm is implemented which would likely be faster than the python + # version. + if list_ndim * final_size > (2 * 512 * 512): + return _block_slicing(arrays, list_ndim, result_ndim) + else: + return _block_concatenate(arrays, list_ndim, result_ndim) + + +# These helper functions are mostly used for testing. +# They allow us to write tests that directly call `_block_slicing` +# or `_block_concatenate` without blocking large arrays to force the wisdom +# to trigger the desired path. +def _block_setup(arrays): + """ + Returns + (`arrays`, list_ndim, result_ndim, final_size) + """ + bottom_index, arr_ndim, final_size = _block_check_depths_match(arrays) + list_ndim = len(bottom_index) + if bottom_index and bottom_index[-1] is None: + raise ValueError( + 'List at {} cannot be empty'.format( + _block_format_index(bottom_index) + ) + ) + result_ndim = max(arr_ndim, list_ndim) + return arrays, list_ndim, result_ndim, final_size + + +def _block_slicing(arrays, list_ndim, result_ndim): + shape, slices, arrays = _block_info_recursion( + arrays, list_ndim, result_ndim) + dtype = _nx.result_type(*[arr.dtype for arr in arrays]) + + # Test preferring F only in the case that all input arrays are F + F_order = all(arr.flags['F_CONTIGUOUS'] for arr in arrays) + C_order = all(arr.flags['C_CONTIGUOUS'] for arr in arrays) + order = 'F' if F_order and not C_order else 'C' + result = _nx.empty(shape=shape, dtype=dtype, order=order) + # Note: In a c implementation, the function + # PyArray_CreateMultiSortedStridePerm could be used for more advanced + # guessing of the desired order. + + for the_slice, arr in zip(slices, arrays): + result[(Ellipsis,) + the_slice] = arr + return result + + +def _block_concatenate(arrays, list_ndim, result_ndim): + result = _block(arrays, list_ndim, result_ndim) + if list_ndim == 0: + # Catch an edge case where _block returns a view because + # `arrays` is a single numpy array and not a list of numpy arrays. + # This might copy scalars or lists twice, but this isn't a likely + # usecase for those interested in performance + result = result.copy() + return result diff --git a/venv/lib/python3.12/site-packages/numpy/_core/shape_base.pyi b/venv/lib/python3.12/site-packages/numpy/_core/shape_base.pyi new file mode 100644 index 00000000..627dbba0 --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/shape_base.pyi @@ -0,0 +1,138 @@ +from collections.abc import Sequence +from typing import TypeVar, overload, Any, SupportsIndex + +from numpy import generic, _CastingKind +from numpy._typing import ( + NDArray, + ArrayLike, + DTypeLike, + _ArrayLike, + _DTypeLike, +) + +_SCT = TypeVar("_SCT", bound=generic) +_ArrayType = TypeVar("_ArrayType", bound=NDArray[Any]) + +__all__: list[str] + +@overload +def atleast_1d(arys: _ArrayLike[_SCT], /) -> NDArray[_SCT]: ... +@overload +def atleast_1d(arys: ArrayLike, /) -> NDArray[Any]: ... +@overload +def atleast_1d(*arys: ArrayLike) -> tuple[NDArray[Any], ...]: ... + +@overload +def atleast_2d(arys: _ArrayLike[_SCT], /) -> NDArray[_SCT]: ... +@overload +def atleast_2d(arys: ArrayLike, /) -> NDArray[Any]: ... +@overload +def atleast_2d(*arys: ArrayLike) -> tuple[NDArray[Any], ...]: ... + +@overload +def atleast_3d(arys: _ArrayLike[_SCT], /) -> NDArray[_SCT]: ... +@overload +def atleast_3d(arys: ArrayLike, /) -> NDArray[Any]: ... +@overload +def atleast_3d(*arys: ArrayLike) -> tuple[NDArray[Any], ...]: ... + +@overload +def vstack( + tup: Sequence[_ArrayLike[_SCT]], + *, + dtype: None = ..., + casting: _CastingKind = ... +) -> NDArray[_SCT]: ... +@overload +def vstack( + tup: Sequence[ArrayLike], + *, + dtype: _DTypeLike[_SCT], + casting: _CastingKind = ... +) -> NDArray[_SCT]: ... +@overload +def vstack( + tup: Sequence[ArrayLike], + *, + dtype: DTypeLike = ..., + casting: _CastingKind = ... +) -> NDArray[Any]: ... + +@overload +def hstack( + tup: Sequence[_ArrayLike[_SCT]], + *, + dtype: None = ..., + casting: _CastingKind = ... +) -> NDArray[_SCT]: ... +@overload +def hstack( + tup: Sequence[ArrayLike], + *, + dtype: _DTypeLike[_SCT], + casting: _CastingKind = ... +) -> NDArray[_SCT]: ... +@overload +def hstack( + tup: Sequence[ArrayLike], + *, + dtype: DTypeLike = ..., + casting: _CastingKind = ... +) -> NDArray[Any]: ... + +@overload +def stack( + arrays: Sequence[_ArrayLike[_SCT]], + axis: SupportsIndex = ..., + out: None = ..., + *, + dtype: None = ..., + casting: _CastingKind = ... +) -> NDArray[_SCT]: ... +@overload +def stack( + arrays: Sequence[ArrayLike], + axis: SupportsIndex = ..., + out: None = ..., + *, + dtype: _DTypeLike[_SCT], + casting: _CastingKind = ... +) -> NDArray[_SCT]: ... +@overload +def stack( + arrays: Sequence[ArrayLike], + axis: SupportsIndex = ..., + out: None = ..., + *, + dtype: DTypeLike = ..., + casting: _CastingKind = ... +) -> NDArray[Any]: ... +@overload +def stack( + arrays: Sequence[ArrayLike], + axis: SupportsIndex = ..., + out: _ArrayType = ..., + *, + dtype: DTypeLike = ..., + casting: _CastingKind = ... +) -> _ArrayType: ... + +@overload +def unstack( + array: _ArrayLike[_SCT], + /, + *, + axis: int = ..., +) -> tuple[NDArray[_SCT], ...]: ... +@overload +def unstack( + array: ArrayLike, + /, + *, + axis: int = ..., +) -> tuple[NDArray[Any], ...]: ... + +@overload +def block(arrays: _ArrayLike[_SCT]) -> NDArray[_SCT]: ... +@overload +def block(arrays: ArrayLike) -> NDArray[Any]: ... diff --git a/venv/lib/python3.12/site-packages/numpy/_core/strings.py b/venv/lib/python3.12/site-packages/numpy/_core/strings.py new file mode 100644 index 00000000..4f732fdc --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/strings.py @@ -0,0 +1,1592 @@ +""" +This module contains a set of functions for vectorized string +operations. +""" + +import sys +import numpy as np +from numpy import ( + equal, not_equal, less, less_equal, greater, greater_equal, + add, multiply as _multiply_ufunc, +) +from numpy._core.multiarray import _vec_string +from numpy._core.umath import ( + isalpha, + isdigit, + isspace, + isalnum, + islower, + isupper, + istitle, + isdecimal, + isnumeric, + str_len, + find as _find_ufunc, + rfind as _rfind_ufunc, + index as _index_ufunc, + rindex as _rindex_ufunc, + count as _count_ufunc, + startswith as _startswith_ufunc, + endswith as _endswith_ufunc, + _lstrip_whitespace, + _lstrip_chars, + _rstrip_whitespace, + _rstrip_chars, + _strip_whitespace, + _strip_chars, + _replace, + _expandtabs_length, + _expandtabs, + _center, + _ljust, + _rjust, + _zfill, + _partition, + _partition_index, + _rpartition, + _rpartition_index, +) + + +__all__ = [ + # UFuncs + "equal", "not_equal", "less", "less_equal", "greater", "greater_equal", + "add", "multiply", "isalpha", "isdigit", "isspace", "isalnum", "islower", + "isupper", "istitle", "isdecimal", "isnumeric", "str_len", "find", + "rfind", "index", "rindex", "count", "startswith", "endswith", "lstrip", + "rstrip", "strip", "replace", "expandtabs", "center", "ljust", "rjust", + "zfill", "partition", "rpartition", + + # _vec_string - Will gradually become ufuncs as well + "upper", "lower", "swapcase", "capitalize", "title", + + # _vec_string - Will probably not become ufuncs + "mod", "decode", "encode", "translate", + + # Removed from namespace until behavior has been crystallized + # "join", "split", "rsplit", "splitlines", +] + + +MAX = np.iinfo(np.int64).max + + +def _get_num_chars(a): + """ + Helper function that returns the number of characters per field in + a string or unicode array. This is to abstract out the fact that + for a unicode array this is itemsize / 4. + """ + if issubclass(a.dtype.type, np.str_): + return a.itemsize // 4 + return a.itemsize + + +def _to_bytes_or_str_array(result, output_dtype_like): + """ + Helper function to cast a result back into an array + with the appropriate dtype if an object array must be used + as an intermediary. + """ + output_dtype_like = np.asarray(output_dtype_like) + if result.size == 0: + # Calling asarray & tolist in an empty array would result + # in losing shape information + return result.astype(output_dtype_like.dtype) + ret = np.asarray(result.tolist()) + if isinstance(output_dtype_like.dtype, np.dtypes.StringDType): + return ret.astype(type(output_dtype_like.dtype)) + return ret.astype(type(output_dtype_like.dtype)(_get_num_chars(ret))) + + +def _clean_args(*args): + """ + Helper function for delegating arguments to Python string + functions. + + Many of the Python string operations that have optional arguments + do not use 'None' to indicate a default value. In these cases, + we need to remove all None arguments, and those following them. + """ + newargs = [] + for chk in args: + if chk is None: + break + newargs.append(chk) + return newargs + + +def multiply(a, i): + """ + Return (a * i), that is string multiple concatenation, + element-wise. + + Values in ``i`` of less than 0 are treated as 0 (which yields an + empty string). + + Parameters + ---------- + a : array_like, with ``StringDType``, ``bytes_`` or ``str_`` dtype + + i : array_like, with any integer dtype + + Returns + ------- + out : ndarray + Output array of ``StringDType``, ``bytes_`` or ``str_`` dtype, + depending on input types + + Examples + -------- + >>> import numpy as np + >>> a = np.array(["a", "b", "c"]) + >>> np.strings.multiply(a, 3) + array(['aaa', 'bbb', 'ccc'], dtype='>> i = np.array([1, 2, 3]) + >>> np.strings.multiply(a, i) + array(['a', 'bb', 'ccc'], dtype='>> np.strings.multiply(np.array(['a']), i) + array(['a', 'aa', 'aaa'], dtype='>> a = np.array(['a', 'b', 'c', 'd', 'e', 'f']).reshape((2, 3)) + >>> np.strings.multiply(a, 3) + array([['aaa', 'bbb', 'ccc'], + ['ddd', 'eee', 'fff']], dtype='>> np.strings.multiply(a, i) + array([['a', 'bb', 'ccc'], + ['d', 'ee', 'fff']], dtype=' sys.maxsize / np.maximum(i, 1)): + raise MemoryError("repeated string is too long") + + buffersizes = a_len * i + out_dtype = f"{a.dtype.char}{buffersizes.max()}" + out = np.empty_like(a, shape=buffersizes.shape, dtype=out_dtype) + return _multiply_ufunc(a, i, out=out) + + +def mod(a, values): + """ + Return (a % i), that is pre-Python 2.6 string formatting + (interpolation), element-wise for a pair of array_likes of str + or unicode. + + Parameters + ---------- + a : array_like, with `np.bytes_` or `np.str_` dtype + + values : array_like of values + These values will be element-wise interpolated into the string. + + Returns + ------- + out : ndarray + Output array of ``StringDType``, ``bytes_`` or ``str_`` dtype, + depending on input types + + Examples + -------- + >>> import numpy as np + >>> a = np.array(["NumPy is a %s library"]) + >>> np.strings.mod(a, values=["Python"]) + array(['NumPy is a Python library'], dtype='>> a = np.array([b'%d bytes', b'%d bits']) + >>> values = np.array([8, 64]) + >>> np.strings.mod(a, values) + array([b'8 bytes', b'64 bits'], dtype='|S7') + + """ + return _to_bytes_or_str_array( + _vec_string(a, np.object_, '__mod__', (values,)), a) + + +def find(a, sub, start=0, end=None): + """ + For each element, return the lowest index in the string where + substring ``sub`` is found, such that ``sub`` is contained in the + range [``start``, ``end``). + + Parameters + ---------- + a : array_like, with ``StringDType``, ``bytes_`` or ``str_`` dtype + + sub : array_like, with `np.bytes_` or `np.str_` dtype + The substring to search for. + + start, end : array_like, with any integer dtype + The range to look in, interpreted as in slice notation. + + Returns + ------- + y : ndarray + Output array of ints + + See Also + -------- + str.find + + Examples + -------- + >>> import numpy as np + >>> a = np.array(["NumPy is a Python library"]) + >>> np.strings.find(a, "Python") + array([11]) + + """ + end = end if end is not None else MAX + return _find_ufunc(a, sub, start, end) + + +def rfind(a, sub, start=0, end=None): + """ + For each element, return the highest index in the string where + substring ``sub`` is found, such that ``sub`` is contained in the + range [``start``, ``end``). + + Parameters + ---------- + a : array-like, with ``StringDType``, ``bytes_``, or ``str_`` dtype + + sub : array-like, with ``StringDType``, ``bytes_``, or ``str_`` dtype + The substring to search for. + + start, end : array_like, with any integer dtype + The range to look in, interpreted as in slice notation. + + Returns + ------- + y : ndarray + Output array of ints + + See Also + -------- + str.rfind + + Examples + -------- + >>> import numpy as np + >>> a = np.array(["Computer Science"]) + >>> np.strings.rfind(a, "Science", start=0, end=None) + array([9]) + >>> np.strings.rfind(a, "Science", start=0, end=8) + array([-1]) + >>> b = np.array(["Computer Science", "Science"]) + >>> np.strings.rfind(b, "Science", start=0, end=None) + array([9, 0]) + + """ + end = end if end is not None else MAX + return _rfind_ufunc(a, sub, start, end) + + +def index(a, sub, start=0, end=None): + """ + Like `find`, but raises :exc:`ValueError` when the substring is not found. + + Parameters + ---------- + a : array-like, with ``StringDType``, ``bytes_``, or ``str_`` dtype + + sub : array-like, with ``StringDType``, ``bytes_``, or ``str_`` dtype + + start, end : array_like, with any integer dtype, optional + + Returns + ------- + out : ndarray + Output array of ints. + + See Also + -------- + find, str.index + + Examples + -------- + >>> import numpy as np + >>> a = np.array(["Computer Science"]) + >>> np.strings.index(a, "Science", start=0, end=None) + array([9]) + + """ + end = end if end is not None else MAX + return _index_ufunc(a, sub, start, end) + + +def rindex(a, sub, start=0, end=None): + """ + Like `rfind`, but raises :exc:`ValueError` when the substring `sub` is + not found. + + Parameters + ---------- + a : array-like, with `np.bytes_` or `np.str_` dtype + + sub : array-like, with `np.bytes_` or `np.str_` dtype + + start, end : array-like, with any integer dtype, optional + + Returns + ------- + out : ndarray + Output array of ints. + + See Also + -------- + rfind, str.rindex + + Examples + -------- + >>> a = np.array(["Computer Science"]) + >>> np.strings.rindex(a, "Science", start=0, end=None) + array([9]) + + """ + end = end if end is not None else MAX + return _rindex_ufunc(a, sub, start, end) + + +def count(a, sub, start=0, end=None): + """ + Returns an array with the number of non-overlapping occurrences of + substring ``sub`` in the range [``start``, ``end``). + + Parameters + ---------- + a : array-like, with ``StringDType``, ``bytes_``, or ``str_`` dtype + + sub : array-like, with ``StringDType``, ``bytes_``, or ``str_`` dtype + The substring to search for. + + start, end : array_like, with any integer dtype + The range to look in, interpreted as in slice notation. + + Returns + ------- + y : ndarray + Output array of ints + + See Also + -------- + str.count + + Examples + -------- + >>> import numpy as np + >>> c = np.array(['aAaAaA', ' aA ', 'abBABba']) + >>> c + array(['aAaAaA', ' aA ', 'abBABba'], dtype='>> np.strings.count(c, 'A') + array([3, 1, 1]) + >>> np.strings.count(c, 'aA') + array([3, 1, 0]) + >>> np.strings.count(c, 'A', start=1, end=4) + array([2, 1, 1]) + >>> np.strings.count(c, 'A', start=1, end=3) + array([1, 0, 0]) + + """ + end = end if end is not None else MAX + return _count_ufunc(a, sub, start, end) + + +def startswith(a, prefix, start=0, end=None): + """ + Returns a boolean array which is `True` where the string element + in ``a`` starts with ``prefix``, otherwise `False`. + + Parameters + ---------- + a : array-like, with ``StringDType``, ``bytes_``, or ``str_`` dtype + + prefix : array-like, with ``StringDType``, ``bytes_``, or ``str_`` dtype + + start, end : array_like, with any integer dtype + With ``start``, test beginning at that position. With ``end``, + stop comparing at that position. + + Returns + ------- + out : ndarray + Output array of bools + + See Also + -------- + str.startswith + + Examples + -------- + >>> import numpy as np + >>> s = np.array(['foo', 'bar']) + >>> s + array(['foo', 'bar'], dtype='>> np.strings.startswith(s, 'fo') + array([True, False]) + >>> np.strings.startswith(s, 'o', start=1, end=2) + array([True, False]) + + """ + end = end if end is not None else MAX + return _startswith_ufunc(a, prefix, start, end) + + +def endswith(a, suffix, start=0, end=None): + """ + Returns a boolean array which is `True` where the string element + in ``a`` ends with ``suffix``, otherwise `False`. + + Parameters + ---------- + a : array-like, with ``StringDType``, ``bytes_``, or ``str_`` dtype + + suffix : array-like, with ``StringDType``, ``bytes_``, or ``str_`` dtype + + start, end : array_like, with any integer dtype + With ``start``, test beginning at that position. With ``end``, + stop comparing at that position. + + Returns + ------- + out : ndarray + Output array of bools + + See Also + -------- + str.endswith + + Examples + -------- + >>> import numpy as np + >>> s = np.array(['foo', 'bar']) + >>> s + array(['foo', 'bar'], dtype='>> np.strings.endswith(s, 'ar') + array([False, True]) + >>> np.strings.endswith(s, 'a', start=1, end=2) + array([False, True]) + + """ + end = end if end is not None else MAX + return _endswith_ufunc(a, suffix, start, end) + + +def decode(a, encoding=None, errors=None): + r""" + Calls :meth:`bytes.decode` element-wise. + + The set of available codecs comes from the Python standard library, + and may be extended at runtime. For more information, see the + :mod:`codecs` module. + + Parameters + ---------- + a : array_like, with ``bytes_`` dtype + + encoding : str, optional + The name of an encoding + + errors : str, optional + Specifies how to handle encoding errors + + Returns + ------- + out : ndarray + + See Also + -------- + :py:meth:`bytes.decode` + + Notes + ----- + The type of the result will depend on the encoding specified. + + Examples + -------- + >>> import numpy as np + >>> c = np.array([b'\x81\xc1\x81\xc1\x81\xc1', b'@@\x81\xc1@@', + ... b'\x81\x82\xc2\xc1\xc2\x82\x81']) + >>> c + array([b'\x81\xc1\x81\xc1\x81\xc1', b'@@\x81\xc1@@', + b'\x81\x82\xc2\xc1\xc2\x82\x81'], dtype='|S7') + >>> np.strings.decode(c, encoding='cp037') + array(['aAaAaA', ' aA ', 'abBABba'], dtype='>> import numpy as np + >>> a = np.array(['aAaAaA', ' aA ', 'abBABba']) + >>> np.strings.encode(a, encoding='cp037') + array([b'\x81\xc1\x81\xc1\x81\xc1', b'@@\x81\xc1@@', + b'\x81\x82\xc2\xc1\xc2\x82\x81'], dtype='|S7') + + """ + return _to_bytes_or_str_array( + _vec_string(a, np.object_, 'encode', _clean_args(encoding, errors)), + np.bytes_(b'')) + + +def expandtabs(a, tabsize=8): + """ + Return a copy of each string element where all tab characters are + replaced by one or more spaces. + + Calls :meth:`str.expandtabs` element-wise. + + Return a copy of each string element where all tab characters are + replaced by one or more spaces, depending on the current column + and the given `tabsize`. The column number is reset to zero after + each newline occurring in the string. This doesn't understand other + non-printing characters or escape sequences. + + Parameters + ---------- + a : array-like, with ``StringDType``, ``bytes_``, or ``str_`` dtype + Input array + tabsize : int, optional + Replace tabs with `tabsize` number of spaces. If not given defaults + to 8 spaces. + + Returns + ------- + out : ndarray + Output array of ``StringDType``, ``bytes_`` or ``str_`` dtype, + depending on input type + + See Also + -------- + str.expandtabs + + Examples + -------- + >>> import numpy as np + >>> a = np.array(['\t\tHello\tworld']) + >>> np.strings.expandtabs(a, tabsize=4) # doctest: +SKIP + array([' Hello world'], dtype='>> import numpy as np + >>> c = np.array(['a1b2','1b2a','b2a1','2a1b']); c + array(['a1b2', '1b2a', 'b2a1', '2a1b'], dtype='>> np.strings.center(c, width=9) + array([' a1b2 ', ' 1b2a ', ' b2a1 ', ' 2a1b '], dtype='>> np.strings.center(c, width=9, fillchar='*') + array(['***a1b2**', '***1b2a**', '***b2a1**', '***2a1b**'], dtype='>> np.strings.center(c, width=1) + array(['a1b2', '1b2a', 'b2a1', '2a1b'], dtype='>> import numpy as np + >>> c = np.array(['aAaAaA', ' aA ', 'abBABba']) + >>> np.strings.ljust(c, width=3) + array(['aAaAaA', ' aA ', 'abBABba'], dtype='>> np.strings.ljust(c, width=9) + array(['aAaAaA ', ' aA ', 'abBABba '], dtype='>> import numpy as np + >>> a = np.array(['aAaAaA', ' aA ', 'abBABba']) + >>> np.strings.rjust(a, width=3) + array(['aAaAaA', ' aA ', 'abBABba'], dtype='>> np.strings.rjust(a, width=9) + array([' aAaAaA', ' aA ', ' abBABba'], dtype='>> import numpy as np + >>> np.strings.zfill(['1', '-1', '+1'], 3) + array(['001', '-01', '+01'], dtype='>> import numpy as np + >>> c = np.array(['aAaAaA', ' aA ', 'abBABba']) + >>> c + array(['aAaAaA', ' aA ', 'abBABba'], dtype='>> np.strings.lstrip(c, 'a') + array(['AaAaA', ' aA ', 'bBABba'], dtype='>> np.strings.lstrip(c, 'A') # leaves c unchanged + array(['aAaAaA', ' aA ', 'abBABba'], dtype='>> (np.strings.lstrip(c, ' ') == np.strings.lstrip(c, '')).all() + np.False_ + >>> (np.strings.lstrip(c, ' ') == np.strings.lstrip(c)).all() + np.True_ + + """ + if chars is None: + return _lstrip_whitespace(a) + return _lstrip_chars(a, chars) + + +def rstrip(a, chars=None): + """ + For each element in `a`, return a copy with the trailing characters + removed. + + Parameters + ---------- + a : array-like, with ``StringDType``, ``bytes_``, or ``str_`` dtype + chars : scalar with the same dtype as ``a``, optional + The ``chars`` argument is a string specifying the set of + characters to be removed. If ``None``, the ``chars`` + argument defaults to removing whitespace. The ``chars`` argument + is not a prefix or suffix; rather, all combinations of its + values are stripped. + + Returns + ------- + out : ndarray + Output array of ``StringDType``, ``bytes_`` or ``str_`` dtype, + depending on input types + + See Also + -------- + str.rstrip + + Examples + -------- + >>> import numpy as np + >>> c = np.array(['aAaAaA', 'abBABba']) + >>> c + array(['aAaAaA', 'abBABba'], dtype='>> np.strings.rstrip(c, 'a') + array(['aAaAaA', 'abBABb'], dtype='>> np.strings.rstrip(c, 'A') + array(['aAaAa', 'abBABba'], dtype='>> import numpy as np + >>> c = np.array(['aAaAaA', ' aA ', 'abBABba']) + >>> c + array(['aAaAaA', ' aA ', 'abBABba'], dtype='>> np.strings.strip(c) + array(['aAaAaA', 'aA', 'abBABba'], dtype='>> np.strings.strip(c, 'a') + array(['AaAaA', ' aA ', 'bBABb'], dtype='>> np.strings.strip(c, 'A') + array(['aAaAa', ' aA ', 'abBABba'], dtype='>> import numpy as np + >>> c = np.array(['a1b c', '1bca', 'bca1']); c + array(['a1b c', '1bca', 'bca1'], dtype='>> np.strings.upper(c) + array(['A1B C', '1BCA', 'BCA1'], dtype='>> import numpy as np + >>> c = np.array(['A1B C', '1BCA', 'BCA1']); c + array(['A1B C', '1BCA', 'BCA1'], dtype='>> np.strings.lower(c) + array(['a1b c', '1bca', 'bca1'], dtype='>> import numpy as np + >>> c=np.array(['a1B c','1b Ca','b Ca1','cA1b'],'S5'); c + array(['a1B c', '1b Ca', 'b Ca1', 'cA1b'], + dtype='|S5') + >>> np.strings.swapcase(c) + array(['A1b C', '1B cA', 'B cA1', 'Ca1B'], + dtype='|S5') + + """ + a_arr = np.asarray(a) + return _vec_string(a_arr, a_arr.dtype, 'swapcase') + + +def capitalize(a): + """ + Return a copy of ``a`` with only the first character of each element + capitalized. + + Calls :meth:`str.capitalize` element-wise. + + For byte strings, this method is locale-dependent. + + Parameters + ---------- + a : array-like, with ``StringDType``, ``bytes_``, or ``str_`` dtype + Input array of strings to capitalize. + + Returns + ------- + out : ndarray + Output array of ``StringDType``, ``bytes_`` or ``str_`` dtype, + depending on input types + + See Also + -------- + str.capitalize + + Examples + -------- + >>> import numpy as np + >>> c = np.array(['a1b2','1b2a','b2a1','2a1b'],'S4'); c + array(['a1b2', '1b2a', 'b2a1', '2a1b'], + dtype='|S4') + >>> np.strings.capitalize(c) + array(['A1b2', '1b2a', 'B2a1', '2a1b'], + dtype='|S4') + + """ + a_arr = np.asarray(a) + return _vec_string(a_arr, a_arr.dtype, 'capitalize') + + +def title(a): + """ + Return element-wise title cased version of string or unicode. + + Title case words start with uppercase characters, all remaining cased + characters are lowercase. + + Calls :meth:`str.title` element-wise. + + For 8-bit strings, this method is locale-dependent. + + Parameters + ---------- + a : array-like, with ``StringDType``, ``bytes_``, or ``str_`` dtype + Input array. + + Returns + ------- + out : ndarray + Output array of ``StringDType``, ``bytes_`` or ``str_`` dtype, + depending on input types + + See Also + -------- + str.title + + Examples + -------- + >>> import numpy as np + >>> c=np.array(['a1b c','1b ca','b ca1','ca1b'],'S5'); c + array(['a1b c', '1b ca', 'b ca1', 'ca1b'], + dtype='|S5') + >>> np.strings.title(c) + array(['A1B C', '1B Ca', 'B Ca1', 'Ca1B'], + dtype='|S5') + + """ + a_arr = np.asarray(a) + return _vec_string(a_arr, a_arr.dtype, 'title') + + +def replace(a, old, new, count=-1): + """ + For each element in ``a``, return a copy of the string with + occurrences of substring ``old`` replaced by ``new``. + + Parameters + ---------- + a : array_like, with ``bytes_`` or ``str_`` dtype + + old, new : array_like, with ``bytes_`` or ``str_`` dtype + + count : array_like, with ``int_`` dtype + If the optional argument ``count`` is given, only the first + ``count`` occurrences are replaced. + + Returns + ------- + out : ndarray + Output array of ``StringDType``, ``bytes_`` or ``str_`` dtype, + depending on input types + + See Also + -------- + str.replace + + Examples + -------- + >>> import numpy as np + >>> a = np.array(["That is a mango", "Monkeys eat mangos"]) + >>> np.strings.replace(a, 'mango', 'banana') + array(['That is a banana', 'Monkeys eat bananas'], dtype='>> a = np.array(["The dish is fresh", "This is it"]) + >>> np.strings.replace(a, 'is', 'was') + array(['The dwash was fresh', 'Thwas was it'], dtype='>> import numpy as np + >>> np.strings.join('-', 'osd') # doctest: +SKIP + array('o-s-d', dtype='>> np.strings.join(['-', '.'], ['ghc', 'osd']) # doctest: +SKIP + array(['g-h-c', 'o.s.d'], dtype='>> import numpy as np + >>> x = np.array("Numpy is nice!") + >>> np.strings.split(x, " ") # doctest: +SKIP + array(list(['Numpy', 'is', 'nice!']), dtype=object) # doctest: +SKIP + + >>> np.strings.split(x, " ", 1) # doctest: +SKIP + array(list(['Numpy', 'is nice!']), dtype=object) # doctest: +SKIP + + See Also + -------- + str.split, rsplit + + """ + # This will return an array of lists of different sizes, so we + # leave it as an object array + return _vec_string( + a, np.object_, 'split', [sep] + _clean_args(maxsplit)) + + +def _rsplit(a, sep=None, maxsplit=None): + """ + For each element in `a`, return a list of the words in the + string, using `sep` as the delimiter string. + + Calls :meth:`str.rsplit` element-wise. + + Except for splitting from the right, `rsplit` + behaves like `split`. + + Parameters + ---------- + a : array-like, with ``StringDType``, ``bytes_``, or ``str_`` dtype + + sep : str or unicode, optional + If `sep` is not specified or None, any whitespace string + is a separator. + maxsplit : int, optional + If `maxsplit` is given, at most `maxsplit` splits are done, + the rightmost ones. + + Returns + ------- + out : ndarray + Array of list objects + + See Also + -------- + str.rsplit, split + + Examples + -------- + >>> import numpy as np + >>> a = np.array(['aAaAaA', 'abBABba']) + >>> np.strings.rsplit(a, 'A') # doctest: +SKIP + array([list(['a', 'a', 'a', '']), # doctest: +SKIP + list(['abB', 'Bba'])], dtype=object) # doctest: +SKIP + + """ + # This will return an array of lists of different sizes, so we + # leave it as an object array + return _vec_string( + a, np.object_, 'rsplit', [sep] + _clean_args(maxsplit)) + + +def _splitlines(a, keepends=None): + """ + For each element in `a`, return a list of the lines in the + element, breaking at line boundaries. + + Calls :meth:`str.splitlines` element-wise. + + Parameters + ---------- + a : array-like, with ``StringDType``, ``bytes_``, or ``str_`` dtype + + keepends : bool, optional + Line breaks are not included in the resulting list unless + keepends is given and true. + + Returns + ------- + out : ndarray + Array of list objects + + See Also + -------- + str.splitlines + + """ + return _vec_string( + a, np.object_, 'splitlines', _clean_args(keepends)) + + +def partition(a, sep): + """ + Partition each element in ``a`` around ``sep``. + + For each element in ``a``, split the element at the first + occurrence of ``sep``, and return a 3-tuple containing the part + before the separator, the separator itself, and the part after + the separator. If the separator is not found, the first item of + the tuple will contain the whole string, and the second and third + ones will be the empty string. + + Parameters + ---------- + a : array-like, with ``StringDType``, ``bytes_``, or ``str_`` dtype + Input array + sep : array-like, with ``StringDType``, ``bytes_``, or ``str_`` dtype + Separator to split each string element in ``a``. + + Returns + ------- + out : 3-tuple: + - array with ``StringDType``, ``bytes_`` or ``str_`` dtype with the + part before the separator + - array with ``StringDType``, ``bytes_`` or ``str_`` dtype with the + separator + - array with ``StringDType``, ``bytes_`` or ``str_`` dtype with the + part after the separator + + See Also + -------- + str.partition + + Examples + -------- + >>> import numpy as np + >>> x = np.array(["Numpy is nice!"]) + >>> np.strings.partition(x, " ") + (array(['Numpy'], dtype='>> import numpy as np + >>> a = np.array(['aAaAaA', ' aA ', 'abBABba']) + >>> np.strings.rpartition(a, 'A') + (array(['aAaAa', ' a', 'abB'], dtype='>> import numpy as np + >>> a = np.array(['a1b c', '1bca', 'bca1']) + >>> table = a[0].maketrans('abc', '123') + >>> deletechars = ' ' + >>> np.char.translate(a, table, deletechars) + array(['112 3', '1231', '2311'], dtype=' NDArray[np.bool]: ... +@overload +def equal(x1: S_co, x2: S_co) -> NDArray[np.bool]: ... + +@overload +def not_equal(x1: U_co, x2: U_co) -> NDArray[np.bool]: ... +@overload +def not_equal(x1: S_co, x2: S_co) -> NDArray[np.bool]: ... + +@overload +def greater_equal(x1: U_co, x2: U_co) -> NDArray[np.bool]: ... +@overload +def greater_equal(x1: S_co, x2: S_co) -> NDArray[np.bool]: ... + +@overload +def less_equal(x1: U_co, x2: U_co) -> NDArray[np.bool]: ... +@overload +def less_equal(x1: S_co, x2: S_co) -> NDArray[np.bool]: ... + +@overload +def greater(x1: U_co, x2: U_co) -> NDArray[np.bool]: ... +@overload +def greater(x1: S_co, x2: S_co) -> NDArray[np.bool]: ... + +@overload +def less(x1: U_co, x2: U_co) -> NDArray[np.bool]: ... +@overload +def less(x1: S_co, x2: S_co) -> NDArray[np.bool]: ... + +@overload +def add(x1: U_co, x2: U_co) -> NDArray[np.str_]: ... +@overload +def add(x1: S_co, x2: S_co) -> NDArray[np.bytes_]: ... + +@overload +def multiply(a: U_co, i: i_co) -> NDArray[np.str_]: ... +@overload +def multiply(a: S_co, i: i_co) -> NDArray[np.bytes_]: ... + +@overload +def mod(a: U_co, value: Any) -> NDArray[np.str_]: ... +@overload +def mod(a: S_co, value: Any) -> NDArray[np.bytes_]: ... + +def isalpha(x: U_co | S_co) -> NDArray[np.bool]: ... +def isalnum(a: U_co | S_co) -> NDArray[np.bool]: ... +def isdigit(x: U_co | S_co) -> NDArray[np.bool]: ... +def isspace(x: U_co | S_co) -> NDArray[np.bool]: ... +def isdecimal(x: U_co) -> NDArray[np.bool]: ... +def isnumeric(x: U_co) -> NDArray[np.bool]: ... +def islower(a: U_co | S_co) -> NDArray[np.bool]: ... +def istitle(a: U_co | S_co) -> NDArray[np.bool]: ... +def isupper(a: U_co | S_co) -> NDArray[np.bool]: ... + +def str_len(x: U_co | S_co) -> NDArray[np.int_]: ... + +@overload +def find( + a: U_co, + sub: U_co, + start: i_co = ..., + end: i_co | None = ..., +) -> NDArray[np.int_]: ... +@overload +def find( + a: S_co, + sub: S_co, + start: i_co = ..., + end: i_co | None = ..., +) -> NDArray[np.int_]: ... + +@overload +def rfind( + a: U_co, + sub: U_co, + start: i_co = ..., + end: i_co | None = ..., +) -> NDArray[np.int_]: ... +@overload +def rfind( + a: S_co, + sub: S_co, + start: i_co = ..., + end: i_co | None = ..., +) -> NDArray[np.int_]: ... + +@overload +def index( + a: U_co, + sub: U_co, + start: i_co = ..., + end: None | i_co = ..., +) -> NDArray[np.int_]: ... +@overload +def index( + a: S_co, + sub: S_co, + start: i_co = ..., + end: None | i_co = ..., +) -> NDArray[np.int_]: ... + +@overload +def rindex( + a: U_co, + sub: U_co, + start: i_co = ..., + end: None | i_co = ..., +) -> NDArray[np.int_]: ... +@overload +def rindex( + a: S_co, + sub: S_co, + start: i_co = ..., + end: None | i_co = ..., +) -> NDArray[np.int_]: ... + +@overload +def count( + a: U_co, + sub: U_co, + start: i_co = ..., + end: i_co | None = ..., +) -> NDArray[np.int_]: ... +@overload +def count( + a: S_co, + sub: S_co, + start: i_co = ..., + end: i_co | None = ..., +) -> NDArray[np.int_]: ... + +@overload +def startswith( + a: U_co, + prefix: U_co, + start: i_co = ..., + end: i_co | None = ..., +) -> NDArray[np.bool]: ... +@overload +def startswith( + a: S_co, + prefix: S_co, + start: i_co = ..., + end: i_co | None = ..., +) -> NDArray[np.bool]: ... + +@overload +def endswith( + a: U_co, + suffix: U_co, + start: i_co = ..., + end: i_co | None = ..., +) -> NDArray[np.bool]: ... +@overload +def endswith( + a: S_co, + suffix: S_co, + start: i_co = ..., + end: i_co | None = ..., +) -> NDArray[np.bool]: ... + +def decode( + a: S_co, + encoding: None | str = ..., + errors: None | str = ..., +) -> NDArray[np.str_]: ... + +def encode( + a: U_co, + encoding: None | str = ..., + errors: None | str = ..., +) -> NDArray[np.bytes_]: ... + +@overload +def expandtabs(a: U_co, tabsize: i_co = ...) -> NDArray[np.str_]: ... +@overload +def expandtabs(a: S_co, tabsize: i_co = ...) -> NDArray[np.bytes_]: ... + +@overload +def center(a: U_co, width: i_co, fillchar: U_co = ...) -> NDArray[np.str_]: ... +@overload +def center(a: S_co, width: i_co, fillchar: S_co = ...) -> NDArray[np.bytes_]: ... + +@overload +def ljust(a: U_co, width: i_co, fillchar: U_co = ...) -> NDArray[np.str_]: ... +@overload +def ljust(a: S_co, width: i_co, fillchar: S_co = ...) -> NDArray[np.bytes_]: ... + +@overload +def rjust( + a: U_co, + width: i_co, + fillchar: U_co = ..., +) -> NDArray[np.str_]: ... +@overload +def rjust( + a: S_co, + width: i_co, + fillchar: S_co = ..., +) -> NDArray[np.bytes_]: ... + +@overload +def lstrip(a: U_co, chars: None | U_co = ...) -> NDArray[np.str_]: ... +@overload +def lstrip(a: S_co, chars: None | S_co = ...) -> NDArray[np.bytes_]: ... + +@overload +def rstrip(a: U_co, char: None | U_co = ...) -> NDArray[np.str_]: ... +@overload +def rstrip(a: S_co, char: None | S_co = ...) -> NDArray[np.bytes_]: ... + +@overload +def strip(a: U_co, chars: None | U_co = ...) -> NDArray[np.str_]: ... +@overload +def strip(a: S_co, chars: None | S_co = ...) -> NDArray[np.bytes_]: ... + +@overload +def zfill(a: U_co, width: i_co) -> NDArray[np.str_]: ... +@overload +def zfill(a: S_co, width: i_co) -> NDArray[np.bytes_]: ... + +@overload +def upper(a: U_co) -> NDArray[np.str_]: ... +@overload +def upper(a: S_co) -> NDArray[np.bytes_]: ... + +@overload +def lower(a: U_co) -> NDArray[np.str_]: ... +@overload +def lower(a: S_co) -> NDArray[np.bytes_]: ... + +@overload +def swapcase(a: U_co) -> NDArray[np.str_]: ... +@overload +def swapcase(a: S_co) -> NDArray[np.bytes_]: ... + +@overload +def capitalize(a: U_co) -> NDArray[np.str_]: ... +@overload +def capitalize(a: S_co) -> NDArray[np.bytes_]: ... + +@overload +def title(a: U_co) -> NDArray[np.str_]: ... +@overload +def title(a: S_co) -> NDArray[np.bytes_]: ... + +@overload +def replace( + a: U_co, + old: U_co, + new: U_co, + count: i_co = ..., +) -> NDArray[np.str_]: ... +@overload +def replace( + a: S_co, + old: S_co, + new: S_co, + count: i_co = ..., +) -> NDArray[np.bytes_]: ... + +@overload +def join(sep: U_co, seq: U_co) -> NDArray[np.str_]: ... +@overload +def join(sep: S_co, seq: S_co) -> NDArray[np.bytes_]: ... + +@overload +def split( + a: U_co, + sep: None | U_co = ..., + maxsplit: None | i_co = ..., +) -> NDArray[np.object_]: ... +@overload +def split( + a: S_co, + sep: None | S_co = ..., + maxsplit: None | i_co = ..., +) -> NDArray[np.object_]: ... + +@overload +def rsplit( + a: U_co, + sep: None | U_co = ..., + maxsplit: None | i_co = ..., +) -> NDArray[np.object_]: ... +@overload +def rsplit( + a: S_co, + sep: None | S_co = ..., + maxsplit: None | i_co = ..., +) -> NDArray[np.object_]: ... + +@overload +def splitlines(a: U_co, keepends: None | b_co = ...) -> NDArray[np.object_]: ... +@overload +def splitlines(a: S_co, keepends: None | b_co = ...) -> NDArray[np.object_]: ... + +@overload +def partition(a: U_co, sep: U_co) -> NDArray[np.str_]: ... +@overload +def partition(a: S_co, sep: S_co) -> NDArray[np.bytes_]: ... + +@overload +def rpartition(a: U_co, sep: U_co) -> NDArray[np.str_]: ... +@overload +def rpartition(a: S_co, sep: S_co) -> NDArray[np.bytes_]: ... + +@overload +def translate( + a: U_co, + table: U_co, + deletechars: None | U_co = ..., +) -> NDArray[np.str_]: ... +@overload +def translate( + a: S_co, + table: S_co, + deletechars: None | S_co = ..., +) -> NDArray[np.bytes_]: ... diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/_locales.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/_locales.cpython-312.pyc new file mode 100644 index 00000000..ecf4212a Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/_locales.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/_natype.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/_natype.cpython-312.pyc new file mode 100644 index 00000000..a7f13791 Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/_natype.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test__exceptions.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test__exceptions.cpython-312.pyc new file mode 100644 index 00000000..28866972 Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test__exceptions.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_abc.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_abc.cpython-312.pyc new file mode 100644 index 00000000..6af3b5c8 Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_abc.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_api.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_api.cpython-312.pyc new file mode 100644 index 00000000..9f2d4a93 Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_api.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_argparse.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_argparse.cpython-312.pyc new file mode 100644 index 00000000..1dc26a9e Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_argparse.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_array_api_info.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_array_api_info.cpython-312.pyc new file mode 100644 index 00000000..eab5d86a Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_array_api_info.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_array_coercion.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_array_coercion.cpython-312.pyc new file mode 100644 index 00000000..bba0d807 Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_array_coercion.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_array_interface.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_array_interface.cpython-312.pyc new file mode 100644 index 00000000..6eded2f6 Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_array_interface.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_arraymethod.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_arraymethod.cpython-312.pyc new file mode 100644 index 00000000..93b539ed Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_arraymethod.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_arrayobject.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_arrayobject.cpython-312.pyc new file mode 100644 index 00000000..14b9e7de Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_arrayobject.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_arrayprint.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_arrayprint.cpython-312.pyc new file mode 100644 index 00000000..16ef2a32 Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_arrayprint.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_casting_floatingpoint_errors.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_casting_floatingpoint_errors.cpython-312.pyc new file mode 100644 index 00000000..0838246b Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_casting_floatingpoint_errors.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_casting_unittests.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_casting_unittests.cpython-312.pyc new file mode 100644 index 00000000..98be9a5c Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_casting_unittests.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_conversion_utils.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_conversion_utils.cpython-312.pyc new file mode 100644 index 00000000..3cbd55b4 Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_conversion_utils.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_cpu_dispatcher.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_cpu_dispatcher.cpython-312.pyc new file mode 100644 index 00000000..9eae83da Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_cpu_dispatcher.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_cpu_features.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_cpu_features.cpython-312.pyc new file mode 100644 index 00000000..ae614b42 Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_cpu_features.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_custom_dtypes.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_custom_dtypes.cpython-312.pyc new file mode 100644 index 00000000..96e9c796 Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_custom_dtypes.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_cython.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_cython.cpython-312.pyc new file mode 100644 index 00000000..3d666c6a Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_cython.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_datetime.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_datetime.cpython-312.pyc new file mode 100644 index 00000000..f500d2b3 Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_datetime.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_defchararray.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_defchararray.cpython-312.pyc new file mode 100644 index 00000000..e90ace40 Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_defchararray.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_deprecations.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_deprecations.cpython-312.pyc new file mode 100644 index 00000000..d856a113 Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_deprecations.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_dlpack.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_dlpack.cpython-312.pyc new file mode 100644 index 00000000..3c6ec7e7 Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_dlpack.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_dtype.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_dtype.cpython-312.pyc new file mode 100644 index 00000000..adfa031d Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_dtype.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_einsum.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_einsum.cpython-312.pyc new file mode 100644 index 00000000..70187ca4 Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_einsum.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_errstate.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_errstate.cpython-312.pyc new file mode 100644 index 00000000..13817f7d Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_errstate.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_extint128.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_extint128.cpython-312.pyc new file mode 100644 index 00000000..8dbe9e6f Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_extint128.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_function_base.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_function_base.cpython-312.pyc new file mode 100644 index 00000000..e2e7ca3f Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_function_base.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_getlimits.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_getlimits.cpython-312.pyc new file mode 100644 index 00000000..2b05d062 Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_getlimits.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_half.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_half.cpython-312.pyc new file mode 100644 index 00000000..d75799eb Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_half.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_hashtable.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_hashtable.cpython-312.pyc new file mode 100644 index 00000000..d82b8950 Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_hashtable.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_indexerrors.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_indexerrors.cpython-312.pyc new file mode 100644 index 00000000..bce5180d Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_indexerrors.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_indexing.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_indexing.cpython-312.pyc new file mode 100644 index 00000000..450ce25d Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_indexing.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_item_selection.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_item_selection.cpython-312.pyc new file mode 100644 index 00000000..dc7c3088 Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_item_selection.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_limited_api.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_limited_api.cpython-312.pyc new file mode 100644 index 00000000..e5529521 Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_limited_api.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_longdouble.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_longdouble.cpython-312.pyc new file mode 100644 index 00000000..09f86b94 Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_longdouble.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_machar.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_machar.cpython-312.pyc new file mode 100644 index 00000000..a99fc96a Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_machar.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_mem_overlap.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_mem_overlap.cpython-312.pyc new file mode 100644 index 00000000..259097cd Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_mem_overlap.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_mem_policy.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_mem_policy.cpython-312.pyc new file mode 100644 index 00000000..a3158349 Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_mem_policy.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_memmap.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_memmap.cpython-312.pyc new file mode 100644 index 00000000..84f7c7be Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_memmap.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_multiarray.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_multiarray.cpython-312.pyc new file mode 100644 index 00000000..597077b2 Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_multiarray.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_multithreading.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_multithreading.cpython-312.pyc new file mode 100644 index 00000000..6af5f657 Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_multithreading.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_nditer.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_nditer.cpython-312.pyc new file mode 100644 index 00000000..cfb943cc Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_nditer.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_nep50_promotions.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_nep50_promotions.cpython-312.pyc new file mode 100644 index 00000000..3dd4f92d Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_nep50_promotions.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_numeric.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_numeric.cpython-312.pyc new file mode 100644 index 00000000..26fd7c1c Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_numeric.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_numerictypes.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_numerictypes.cpython-312.pyc new file mode 100644 index 00000000..3181bbab Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_numerictypes.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_overrides.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_overrides.cpython-312.pyc new file mode 100644 index 00000000..7a42d7b1 Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_overrides.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_print.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_print.cpython-312.pyc new file mode 100644 index 00000000..9aa7bfa3 Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_print.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_protocols.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_protocols.cpython-312.pyc new file mode 100644 index 00000000..eafd4112 Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_protocols.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_records.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_records.cpython-312.pyc new file mode 100644 index 00000000..ea9a726e Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_records.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_regression.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_regression.cpython-312.pyc new file mode 100644 index 00000000..1d0dda59 Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_regression.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_scalar_ctors.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_scalar_ctors.cpython-312.pyc new file mode 100644 index 00000000..1d69962e Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_scalar_ctors.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_scalar_methods.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_scalar_methods.cpython-312.pyc new file mode 100644 index 00000000..2b2bc43b Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_scalar_methods.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_scalarbuffer.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_scalarbuffer.cpython-312.pyc new file mode 100644 index 00000000..49b14418 Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_scalarbuffer.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_scalarinherit.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_scalarinherit.cpython-312.pyc new file mode 100644 index 00000000..a5e6f086 Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_scalarinherit.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_scalarmath.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_scalarmath.cpython-312.pyc new file mode 100644 index 00000000..e7ef1ce1 Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_scalarmath.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_scalarprint.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_scalarprint.cpython-312.pyc new file mode 100644 index 00000000..2c52b797 Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_scalarprint.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_shape_base.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_shape_base.cpython-312.pyc new file mode 100644 index 00000000..26b04802 Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_shape_base.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_simd.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_simd.cpython-312.pyc new file mode 100644 index 00000000..1c7775d0 Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_simd.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_simd_module.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_simd_module.cpython-312.pyc new file mode 100644 index 00000000..4beedfc4 Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_simd_module.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_stringdtype.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_stringdtype.cpython-312.pyc new file mode 100644 index 00000000..10e0fa9d Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_stringdtype.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_strings.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_strings.cpython-312.pyc new file mode 100644 index 00000000..5ec3cfe8 Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_strings.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_ufunc.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_ufunc.cpython-312.pyc new file mode 100644 index 00000000..4a7d9dc4 Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_ufunc.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_umath.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_umath.cpython-312.pyc new file mode 100644 index 00000000..6f312cee Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_umath.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_umath_accuracy.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_umath_accuracy.cpython-312.pyc new file mode 100644 index 00000000..1068342f Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_umath_accuracy.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_umath_complex.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_umath_complex.cpython-312.pyc new file mode 100644 index 00000000..0041a611 Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_umath_complex.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_unicode.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_unicode.cpython-312.pyc new file mode 100644 index 00000000..8217b4fd Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/_core/tests/__pycache__/test_unicode.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/_locales.py b/venv/lib/python3.12/site-packages/numpy/_core/tests/_locales.py new file mode 100644 index 00000000..b1dc55a9 --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/tests/_locales.py @@ -0,0 +1,74 @@ +"""Provide class for testing in French locale + +""" +import sys +import locale + +import pytest + +__ALL__ = ['CommaDecimalPointLocale'] + + +def find_comma_decimal_point_locale(): + """See if platform has a decimal point as comma locale. + + Find a locale that uses a comma instead of a period as the + decimal point. + + Returns + ------- + old_locale: str + Locale when the function was called. + new_locale: {str, None) + First French locale found, None if none found. + + """ + if sys.platform == 'win32': + locales = ['FRENCH'] + else: + locales = ['fr_FR', 'fr_FR.UTF-8', 'fi_FI', 'fi_FI.UTF-8'] + + old_locale = locale.getlocale(locale.LC_NUMERIC) + new_locale = None + try: + for loc in locales: + try: + locale.setlocale(locale.LC_NUMERIC, loc) + new_locale = loc + break + except locale.Error: + pass + finally: + locale.setlocale(locale.LC_NUMERIC, locale=old_locale) + return old_locale, new_locale + + +class CommaDecimalPointLocale: + """Sets LC_NUMERIC to a locale with comma as decimal point. + + Classes derived from this class have setup and teardown methods that run + tests with locale.LC_NUMERIC set to a locale where commas (',') are used as + the decimal point instead of periods ('.'). On exit the locale is restored + to the initial locale. It also serves as context manager with the same + effect. If no such locale is available, the test is skipped. + + .. versionadded:: 1.15.0 + + """ + (cur_locale, tst_locale) = find_comma_decimal_point_locale() + + def setup_method(self): + if self.tst_locale is None: + pytest.skip("No French locale available") + locale.setlocale(locale.LC_NUMERIC, locale=self.tst_locale) + + def teardown_method(self): + locale.setlocale(locale.LC_NUMERIC, locale=self.cur_locale) + + def __enter__(self): + if self.tst_locale is None: + pytest.skip("No French locale available") + locale.setlocale(locale.LC_NUMERIC, locale=self.tst_locale) + + def __exit__(self, type, value, traceback): + locale.setlocale(locale.LC_NUMERIC, locale=self.cur_locale) diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/_natype.py b/venv/lib/python3.12/site-packages/numpy/_core/tests/_natype.py new file mode 100644 index 00000000..e529e548 --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/tests/_natype.py @@ -0,0 +1,198 @@ +# Vendored implementation of pandas.NA, adapted from pandas/_libs/missing.pyx +# +# This is vendored to avoid adding pandas as a test dependency. + +__all__ = ["pd_NA"] + +import numbers + +import numpy as np + +def _create_binary_propagating_op(name, is_divmod=False): + is_cmp = name.strip("_") in ["eq", "ne", "le", "lt", "ge", "gt"] + + def method(self, other): + if ( + other is pd_NA + or isinstance(other, (str, bytes)) + or isinstance(other, (numbers.Number, np.bool)) + or isinstance(other, np.ndarray) + and not other.shape + ): + # Need the other.shape clause to handle NumPy scalars, + # since we do a setitem on `out` below, which + # won't work for NumPy scalars. + if is_divmod: + return pd_NA, pd_NA + else: + return pd_NA + + elif isinstance(other, np.ndarray): + out = np.empty(other.shape, dtype=object) + out[:] = pd_NA + + if is_divmod: + return out, out.copy() + else: + return out + + elif is_cmp and isinstance(other, (np.datetime64, np.timedelta64)): + return pd_NA + + elif isinstance(other, np.datetime64): + if name in ["__sub__", "__rsub__"]: + return pd_NA + + elif isinstance(other, np.timedelta64): + if name in ["__sub__", "__rsub__", "__add__", "__radd__"]: + return pd_NA + + return NotImplemented + + method.__name__ = name + return method + + +def _create_unary_propagating_op(name: str): + def method(self): + return pd_NA + + method.__name__ = name + return method + + +class NAType: + def __repr__(self) -> str: + return "" + + def __format__(self, format_spec) -> str: + try: + return self.__repr__().__format__(format_spec) + except ValueError: + return self.__repr__() + + def __bool__(self): + raise TypeError("boolean value of NA is ambiguous") + + def __hash__(self): + exponent = 31 if is_32bit else 61 + return 2**exponent - 1 + + def __reduce__(self): + return "pd_NA" + + # Binary arithmetic and comparison ops -> propagate + + __add__ = _create_binary_propagating_op("__add__") + __radd__ = _create_binary_propagating_op("__radd__") + __sub__ = _create_binary_propagating_op("__sub__") + __rsub__ = _create_binary_propagating_op("__rsub__") + __mul__ = _create_binary_propagating_op("__mul__") + __rmul__ = _create_binary_propagating_op("__rmul__") + __matmul__ = _create_binary_propagating_op("__matmul__") + __rmatmul__ = _create_binary_propagating_op("__rmatmul__") + __truediv__ = _create_binary_propagating_op("__truediv__") + __rtruediv__ = _create_binary_propagating_op("__rtruediv__") + __floordiv__ = _create_binary_propagating_op("__floordiv__") + __rfloordiv__ = _create_binary_propagating_op("__rfloordiv__") + __mod__ = _create_binary_propagating_op("__mod__") + __rmod__ = _create_binary_propagating_op("__rmod__") + __divmod__ = _create_binary_propagating_op("__divmod__", is_divmod=True) + __rdivmod__ = _create_binary_propagating_op("__rdivmod__", is_divmod=True) + # __lshift__ and __rshift__ are not implemented + + __eq__ = _create_binary_propagating_op("__eq__") + __ne__ = _create_binary_propagating_op("__ne__") + __le__ = _create_binary_propagating_op("__le__") + __lt__ = _create_binary_propagating_op("__lt__") + __gt__ = _create_binary_propagating_op("__gt__") + __ge__ = _create_binary_propagating_op("__ge__") + + # Unary ops + + __neg__ = _create_unary_propagating_op("__neg__") + __pos__ = _create_unary_propagating_op("__pos__") + __abs__ = _create_unary_propagating_op("__abs__") + __invert__ = _create_unary_propagating_op("__invert__") + + # pow has special + def __pow__(self, other): + if other is pd_NA: + return pd_NA + elif isinstance(other, (numbers.Number, np.bool)): + if other == 0: + # returning positive is correct for +/- 0. + return type(other)(1) + else: + return pd_NA + elif util.is_array(other): + return np.where(other == 0, other.dtype.type(1), pd_NA) + + return NotImplemented + + def __rpow__(self, other): + if other is pd_NA: + return pd_NA + elif isinstance(other, (numbers.Number, np.bool)): + if other == 1: + return other + else: + return pd_NA + elif util.is_array(other): + return np.where(other == 1, other, pd_NA) + return NotImplemented + + # Logical ops using Kleene logic + + def __and__(self, other): + if other is False: + return False + elif other is True or other is pd_NA: + return pd_NA + return NotImplemented + + __rand__ = __and__ + + def __or__(self, other): + if other is True: + return True + elif other is False or other is pd_NA: + return pd_NA + return NotImplemented + + __ror__ = __or__ + + def __xor__(self, other): + if other is False or other is True or other is pd_NA: + return pd_NA + return NotImplemented + + __rxor__ = __xor__ + + __array_priority__ = 1000 + _HANDLED_TYPES = (np.ndarray, numbers.Number, str, np.bool) + + def __array_ufunc__(self, ufunc, method, *inputs, **kwargs): + types = self._HANDLED_TYPES + (NAType,) + for x in inputs: + if not isinstance(x, types): + return NotImplemented + + if method != "__call__": + raise ValueError(f"ufunc method '{method}' not supported for NA") + result = maybe_dispatch_ufunc_to_dunder_op( + self, ufunc, method, *inputs, **kwargs + ) + if result is NotImplemented: + # For a NumPy ufunc that's not a binop, like np.logaddexp + index = [i for i, x in enumerate(inputs) if x is pd_NA][0] + result = np.broadcast_arrays(*inputs)[index] + if result.ndim == 0: + result = result.item() + if ufunc.nout > 1: + result = (pd_NA,) * ufunc.nout + + return result + + +pd_NA = NAType() diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/data/astype_copy.pkl b/venv/lib/python3.12/site-packages/numpy/_core/tests/data/astype_copy.pkl new file mode 100644 index 00000000..7397c978 Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/_core/tests/data/astype_copy.pkl differ diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/data/generate_umath_validation_data.cpp b/venv/lib/python3.12/site-packages/numpy/_core/tests/data/generate_umath_validation_data.cpp new file mode 100644 index 00000000..88ff45e1 --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/tests/data/generate_umath_validation_data.cpp @@ -0,0 +1,170 @@ +#include +#include +#include +#include +#include +#include +#include +#include + +struct ufunc { + std::string name; + double (*f32func)(double); + long double (*f64func)(long double); + float f32ulp; + float f64ulp; +}; + +template +T +RandomFloat(T a, T b) +{ + T random = ((T)rand()) / (T)RAND_MAX; + T diff = b - a; + T r = random * diff; + return a + r; +} + +template +void +append_random_array(std::vector &arr, T min, T max, size_t N) +{ + for (size_t ii = 0; ii < N; ++ii) + arr.emplace_back(RandomFloat(min, max)); +} + +template +std::vector +computeTrueVal(const std::vector &in, T2 (*mathfunc)(T2)) +{ + std::vector out; + for (T1 elem : in) { + T2 elem_d = (T2)elem; + T1 out_elem = (T1)mathfunc(elem_d); + out.emplace_back(out_elem); + } + return out; +} + +/* + * FP range: + * [-inf, -maxflt, -1., -minflt, -minden, 0., minden, minflt, 1., maxflt, inf] + */ + +#define MINDEN std::numeric_limits::denorm_min() +#define MINFLT std::numeric_limits::min() +#define MAXFLT std::numeric_limits::max() +#define INF std::numeric_limits::infinity() +#define qNAN std::numeric_limits::quiet_NaN() +#define sNAN std::numeric_limits::signaling_NaN() + +template +std::vector +generate_input_vector(std::string func) +{ + std::vector input = {MINDEN, -MINDEN, MINFLT, -MINFLT, MAXFLT, + -MAXFLT, INF, -INF, qNAN, sNAN, + -1.0, 1.0, 0.0, -0.0}; + + // [-1.0, 1.0] + if ((func == "arcsin") || (func == "arccos") || (func == "arctanh")) { + append_random_array(input, -1.0, 1.0, 700); + } + // (0.0, INF] + else if ((func == "log2") || (func == "log10")) { + append_random_array(input, 0.0, 1.0, 200); + append_random_array(input, MINDEN, MINFLT, 200); + append_random_array(input, MINFLT, 1.0, 200); + append_random_array(input, 1.0, MAXFLT, 200); + } + // (-1.0, INF] + else if (func == "log1p") { + append_random_array(input, -1.0, 1.0, 200); + append_random_array(input, -MINFLT, -MINDEN, 100); + append_random_array(input, -1.0, -MINFLT, 100); + append_random_array(input, MINDEN, MINFLT, 100); + append_random_array(input, MINFLT, 1.0, 100); + append_random_array(input, 1.0, MAXFLT, 100); + } + // [1.0, INF] + else if (func == "arccosh") { + append_random_array(input, 1.0, 2.0, 400); + append_random_array(input, 2.0, MAXFLT, 300); + } + // [-INF, INF] + else { + append_random_array(input, -1.0, 1.0, 100); + append_random_array(input, MINDEN, MINFLT, 100); + append_random_array(input, -MINFLT, -MINDEN, 100); + append_random_array(input, MINFLT, 1.0, 100); + append_random_array(input, -1.0, -MINFLT, 100); + append_random_array(input, 1.0, MAXFLT, 100); + append_random_array(input, -MAXFLT, -100.0, 100); + } + + std::random_shuffle(input.begin(), input.end()); + return input; +} + +int +main() +{ + srand(42); + std::vector umathfunc = { + {"sin", sin, sin, 1.49, 1.00}, + {"cos", cos, cos, 1.49, 1.00}, + {"tan", tan, tan, 3.91, 1.00}, + {"arcsin", asin, asin, 3.12, 1.00}, + {"arccos", acos, acos, 2.1, 1.00}, + {"arctan", atan, atan, 2.3, 1.00}, + {"sinh", sinh, sinh, 1.55, 1.00}, + {"cosh", cosh, cosh, 2.48, 1.00}, + {"tanh", tanh, tanh, 1.38, 2.00}, + {"arcsinh", asinh, asinh, 1.01, 1.00}, + {"arccosh", acosh, acosh, 1.16, 1.00}, + {"arctanh", atanh, atanh, 1.45, 1.00}, + {"cbrt", cbrt, cbrt, 1.94, 2.00}, + //{"exp",exp,exp,3.76,1.00}, + {"exp2", exp2, exp2, 1.01, 1.00}, + {"expm1", expm1, expm1, 2.62, 1.00}, + //{"log",log,log,1.84,1.00}, + {"log10", log10, log10, 3.5, 1.00}, + {"log1p", log1p, log1p, 1.96, 1.0}, + {"log2", log2, log2, 2.12, 1.00}, + }; + + for (int ii = 0; ii < umathfunc.size(); ++ii) { + // ignore sin/cos + if ((umathfunc[ii].name != "sin") && (umathfunc[ii].name != "cos")) { + std::string fileName = + "umath-validation-set-" + umathfunc[ii].name + ".csv"; + std::ofstream txtOut; + txtOut.open(fileName, std::ofstream::trunc); + txtOut << "dtype,input,output,ulperrortol" << std::endl; + + // Single Precision + auto f32in = generate_input_vector(umathfunc[ii].name); + auto f32out = computeTrueVal(f32in, + umathfunc[ii].f32func); + for (int jj = 0; jj < f32in.size(); ++jj) { + txtOut << "np.float32" << std::hex << ",0x" + << *reinterpret_cast(&f32in[jj]) << ",0x" + << *reinterpret_cast(&f32out[jj]) << "," + << ceil(umathfunc[ii].f32ulp) << std::endl; + } + + // Double Precision + auto f64in = generate_input_vector(umathfunc[ii].name); + auto f64out = computeTrueVal( + f64in, umathfunc[ii].f64func); + for (int jj = 0; jj < f64in.size(); ++jj) { + txtOut << "np.float64" << std::hex << ",0x" + << *reinterpret_cast(&f64in[jj]) << ",0x" + << *reinterpret_cast(&f64out[jj]) << "," + << ceil(umathfunc[ii].f64ulp) << std::endl; + } + txtOut.close(); + } + } + return 0; +} diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/data/recarray_from_file.fits b/venv/lib/python3.12/site-packages/numpy/_core/tests/data/recarray_from_file.fits new file mode 100644 index 00000000..ca48ee85 Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/_core/tests/data/recarray_from_file.fits differ diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/data/umath-validation-set-README.txt b/venv/lib/python3.12/site-packages/numpy/_core/tests/data/umath-validation-set-README.txt new file mode 100644 index 00000000..cfc9e414 --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/tests/data/umath-validation-set-README.txt @@ -0,0 +1,15 @@ +Steps to validate transcendental functions: +1) Add a file 'umath-validation-set-.txt', where ufuncname is name of + the function in NumPy you want to validate +2) The file should contain 4 columns: dtype,input,expected output,ulperror + a. dtype: one of np.float16, np.float32, np.float64 + b. input: floating point input to ufunc in hex. Example: 0x414570a4 + represents 12.340000152587890625 + c. expected output: floating point output for the corresponding input in hex. + This should be computed using a high(er) precision library and then rounded to + same format as the input. + d. ulperror: expected maximum ulp error of the function. This + should be same across all rows of the same dtype. Otherwise, the function is + tested for the maximum ulp error among all entries of that dtype. +3) Add file umath-validation-set-.txt to the test file test_umath_accuracy.py + which will then validate your ufunc. diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/data/umath-validation-set-arccos.csv b/venv/lib/python3.12/site-packages/numpy/_core/tests/data/umath-validation-set-arccos.csv new file mode 100644 index 00000000..82c8595c --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/tests/data/umath-validation-set-arccos.csv @@ -0,0 +1,1429 @@ +dtype,input,output,ulperrortol +np.float32,0xbddd7f50,0x3fd6eec2,3 +np.float32,0xbe32a20c,0x3fdf8182,3 +np.float32,0xbf607c09,0x4028f84f,3 +np.float32,0x3f25d906,0x3f5db544,3 +np.float32,0x3f01cec8,0x3f84febf,3 +np.float32,0x3f1d5c6e,0x3f68a735,3 +np.float32,0xbf0cab89,0x4009c36d,3 +np.float32,0xbf176b40,0x400d0941,3 +np.float32,0x3f3248b2,0x3f4ce6d4,3 +np.float32,0x3f390b48,0x3f434e0d,3 +np.float32,0xbe261698,0x3fddea43,3 +np.float32,0x3f0e1154,0x3f7b848b,3 +np.float32,0xbf379a3c,0x4017b764,3 +np.float32,0xbeda6f2c,0x4000bd62,3 +np.float32,0xbf6a0c3f,0x402e5d5a,3 +np.float32,0x3ef1d700,0x3f8a17b7,3 +np.float32,0xbf6f4f65,0x4031d30d,3 +np.float32,0x3f2c9eee,0x3f54adfd,3 +np.float32,0x3f3cfb18,0x3f3d8a1e,3 +np.float32,0x3ba80800,0x3fc867d2,3 +np.float32,0x3e723b08,0x3faa7e4d,3 +np.float32,0xbf65820f,0x402bb054,3 +np.float32,0xbee64e7a,0x40026410,3 +np.float32,0x3cb15140,0x3fc64a87,3 +np.float32,0x3f193660,0x3f6ddf2a,3 +np.float32,0xbf0e5b52,0x400a44f7,3 +np.float32,0x3ed55f14,0x3f920a4b,3 +np.float32,0x3dd11a80,0x3fbbf85c,3 +np.float32,0xbf4f5c4b,0x4020f4f9,3 +np.float32,0x3f787532,0x3e792e87,3 +np.float32,0x3f40e6ac,0x3f37a74f,3 +np.float32,0x3f1c1318,0x3f6a47b6,3 +np.float32,0xbe3c48d8,0x3fe0bb70,3 +np.float32,0xbe94d4bc,0x3feed08e,3 +np.float32,0xbe5c3688,0x3fe4ce26,3 +np.float32,0xbf6fe026,0x403239cb,3 +np.float32,0x3ea5983c,0x3f9ee7bf,3 +np.float32,0x3f1471e6,0x3f73c5bb,3 +np.float32,0x3f0e2622,0x3f7b6b87,3 +np.float32,0xbf597180,0x40257ad1,3 +np.float32,0xbeb5321c,0x3ff75d34,3 +np.float32,0x3f5afcd2,0x3f0b6012,3 +np.float32,0xbef2ff88,0x40042e14,3 +np.float32,0xbedc747e,0x400104f5,3 +np.float32,0xbee0c2f4,0x40019dfc,3 +np.float32,0xbf152cd8,0x400c57dc,3 +np.float32,0xbf6cf9e2,0x40303bbe,3 +np.float32,0x3ed9cd74,0x3f90d1a1,3 +np.float32,0xbf754406,0x4036767f,3 +np.float32,0x3f59c5c2,0x3f0db42f,3 +np.float32,0x3f2eefd8,0x3f518684,3 +np.float32,0xbf156bf9,0x400c6b49,3 +np.float32,0xbd550790,0x3fcfb8dc,3 +np.float32,0x3ede58fc,0x3f8f8f77,3 +np.float32,0xbf00ac19,0x40063c4b,3 +np.float32,0x3f4d25ba,0x3f24280e,3 +np.float32,0xbe9568be,0x3feef73c,3 +np.float32,0x3f67d154,0x3ee05547,3 +np.float32,0x3f617226,0x3efcb4f4,3 +np.float32,0xbf3ab41a,0x4018d6cc,3 +np.float32,0xbf3186fe,0x401592cd,3 +np.float32,0x3de3ba50,0x3fbacca9,3 +np.float32,0x3e789f98,0x3fa9ab97,3 +np.float32,0x3f016e08,0x3f8536d8,3 +np.float32,0x3e8b618c,0x3fa5c571,3 +np.float32,0x3eff97bc,0x3f8628a9,3 +np.float32,0xbf6729f0,0x402ca32f,3 +np.float32,0xbebec146,0x3ff9eddc,3 +np.float32,0x3ddb2e60,0x3fbb563a,3 +np.float32,0x3caa8e40,0x3fc66595,3 +np.float32,0xbf5973f2,0x40257bfa,3 +np.float32,0xbdd82c70,0x3fd69916,3 +np.float32,0xbedf4c82,0x400169ef,3 +np.float32,0x3ef8f22c,0x3f881184,3 +np.float32,0xbf1d74d4,0x400eedc9,3 +np.float32,0x3f2e10a6,0x3f52b790,3 +np.float32,0xbf08ecc0,0x4008a628,3 +np.float32,0x3ecb7db4,0x3f94be9f,3 +np.float32,0xbf052ded,0x40078bfc,3 +np.float32,0x3f2ee78a,0x3f5191e4,3 +np.float32,0xbf56f4e1,0x40245194,3 +np.float32,0x3f600a3e,0x3f014a25,3 +np.float32,0x3f3836f8,0x3f44808b,3 +np.float32,0x3ecabfbc,0x3f94f25c,3 +np.float32,0x3c70f500,0x3fc72dec,3 +np.float32,0x3f17c444,0x3f6fabf0,3 +np.float32,0xbf4c22a5,0x401f9a09,3 +np.float32,0xbe4205dc,0x3fe1765a,3 +np.float32,0x3ea49138,0x3f9f2d36,3 +np.float32,0xbece0082,0x3ffe106b,3 +np.float32,0xbe387578,0x3fe03eef,3 +np.float32,0xbf2b6466,0x40137a30,3 +np.float32,0xbe9dadb2,0x3ff12204,3 +np.float32,0xbf56b3f2,0x402433bb,3 +np.float32,0xbdf9b4d8,0x3fd8b51f,3 +np.float32,0x3f58a596,0x3f0fd4b4,3 +np.float32,0xbedf5748,0x40016b6e,3 +np.float32,0x3f446442,0x3f32476f,3 +np.float32,0x3f5be886,0x3f099658,3 +np.float32,0x3ea1e44c,0x3f9fe1de,3 +np.float32,0xbf11e9b8,0x400b585f,3 +np.float32,0xbf231f8f,0x4010befb,3 +np.float32,0xbf4395ea,0x401c2dd0,3 +np.float32,0x3e9e7784,0x3fa0c8a6,3 +np.float32,0xbe255184,0x3fddd14c,3 +np.float32,0x3f70d25e,0x3eb13148,3 +np.float32,0x3f220cdc,0x3f62a722,3 +np.float32,0xbd027bf0,0x3fcd23e7,3 +np.float32,0x3e4ef8b8,0x3faf02d2,3 +np.float32,0xbf76fc6b,0x40380728,3 +np.float32,0xbf57e761,0x4024c1cd,3 +np.float32,0x3ed4fc20,0x3f922580,3 +np.float32,0xbf09b64a,0x4008e1db,3 +np.float32,0x3f21ca62,0x3f62fcf5,3 +np.float32,0xbe55f610,0x3fe40170,3 +np.float32,0xbc0def80,0x3fca2bbb,3 +np.float32,0xbebc8764,0x3ff9547b,3 +np.float32,0x3ec1b200,0x3f9766d1,3 +np.float32,0xbf4ee44e,0x4020c1ee,3 +np.float32,0xbea85852,0x3ff3f22a,3 +np.float32,0xbf195c0c,0x400da3d3,3 +np.float32,0xbf754b5d,0x40367ce8,3 +np.float32,0xbdcbfe50,0x3fd5d52b,3 +np.float32,0xbf1adb87,0x400e1be3,3 +np.float32,0xbf6f8491,0x4031f898,3 +np.float32,0xbf6f9ae7,0x4032086e,3 +np.float32,0xbf52b3f0,0x40226790,3 +np.float32,0xbf698452,0x402e09f4,3 +np.float32,0xbf43dc9a,0x401c493a,3 +np.float32,0xbf165f7f,0x400cb664,3 +np.float32,0x3e635468,0x3fac682f,3 +np.float32,0xbe8cf2b6,0x3fecc28a,3 +np.float32,0x7f7fffff,0x7fc00000,3 +np.float32,0xbf4c6513,0x401fb597,3 +np.float32,0xbf02b8f8,0x4006d47e,3 +np.float32,0x3ed3759c,0x3f9290c8,3 +np.float32,0xbf2a7a5f,0x40132b98,3 +np.float32,0xbae65000,0x3fc9496f,3 +np.float32,0x3f65f5ea,0x3ee8ef07,3 +np.float32,0xbe7712fc,0x3fe84106,3 +np.float32,0xbb9ff700,0x3fc9afd2,3 +np.float32,0x3d8d87a0,0x3fc03592,3 +np.float32,0xbefc921c,0x40058c23,3 +np.float32,0xbf286566,0x401279d8,3 +np.float32,0x3f53857e,0x3f192eaf,3 +np.float32,0xbee9b0f4,0x4002dd90,3 +np.float32,0x3f4041f8,0x3f38a14a,3 +np.float32,0x3f54ea96,0x3f16b02d,3 +np.float32,0x3ea50ef8,0x3f9f0c01,3 +np.float32,0xbeaad2dc,0x3ff49a4a,3 +np.float32,0xbec428c8,0x3ffb636f,3 +np.float32,0xbda46178,0x3fd358c7,3 +np.float32,0xbefacfc4,0x40054b7f,3 +np.float32,0xbf7068f9,0x40329c85,3 +np.float32,0x3f70b850,0x3eb1caa7,3 +np.float32,0x7fa00000,0x7fe00000,3 +np.float32,0x80000000,0x3fc90fdb,3 +np.float32,0x3f68d5c8,0x3edb7cf3,3 +np.float32,0x3d9443d0,0x3fbfc98a,3 +np.float32,0xff7fffff,0x7fc00000,3 +np.float32,0xbeee7ba8,0x40038a5e,3 +np.float32,0xbf0aaaba,0x40092a73,3 +np.float32,0x3f36a4e8,0x3f46c0ee,3 +np.float32,0x3ed268e4,0x3f92da82,3 +np.float32,0xbee6002c,0x4002591b,3 +np.float32,0xbe8f2752,0x3fed5576,3 +np.float32,0x3f525912,0x3f1b40e0,3 +np.float32,0xbe8e151e,0x3fed0e16,3 +np.float32,0x1,0x3fc90fdb,3 +np.float32,0x3ee23b84,0x3f8e7ae1,3 +np.float32,0xbf5961ca,0x40257361,3 +np.float32,0x3f6bbca0,0x3ecd14cd,3 +np.float32,0x3e27b230,0x3fb4014d,3 +np.float32,0xbf183bb8,0x400d49fc,3 +np.float32,0x3f57759c,0x3f120b68,3 +np.float32,0xbd6994c0,0x3fd05d84,3 +np.float32,0xbf1dd684,0x400f0cc8,3 +np.float32,0xbececc1c,0x3ffe480a,3 +np.float32,0xbf48855f,0x401e206d,3 +np.float32,0x3f28c922,0x3f59d382,3 +np.float32,0xbf65c094,0x402bd3b0,3 +np.float32,0x3f657d42,0x3eeb11dd,3 +np.float32,0xbed32d4e,0x3fff7b15,3 +np.float32,0xbf31af02,0x4015a0b1,3 +np.float32,0x3d89eb00,0x3fc06f7f,3 +np.float32,0x3dac2830,0x3fbe4a17,3 +np.float32,0x3f7f7cb6,0x3d81a7df,3 +np.float32,0xbedbb570,0x4000ea82,3 +np.float32,0x3db37830,0x3fbdd4a8,3 +np.float32,0xbf376f48,0x4017a7fd,3 +np.float32,0x3f319f12,0x3f4dd2c9,3 +np.float32,0x7fc00000,0x7fc00000,3 +np.float32,0x3f1b4f70,0x3f6b3e31,3 +np.float32,0x3e33c880,0x3fb278d1,3 +np.float32,0x3f2796e0,0x3f5b69bd,3 +np.float32,0x3f4915d6,0x3f2ad4d0,3 +np.float32,0x3e4db120,0x3faf2ca0,3 +np.float32,0x3ef03dd4,0x3f8a8ba9,3 +np.float32,0x3e96ca88,0x3fa2cbf7,3 +np.float32,0xbeb136ce,0x3ff64d2b,3 +np.float32,0xbf2f3938,0x4014c75e,3 +np.float32,0x3f769dde,0x3e8b0d76,3 +np.float32,0x3f67cec8,0x3ee06148,3 +np.float32,0x3f0a1ade,0x3f80204e,3 +np.float32,0x3e4b9718,0x3faf7144,3 +np.float32,0x3cccb480,0x3fc5dcf3,3 +np.float32,0x3caeb740,0x3fc654f0,3 +np.float32,0x3f684e0e,0x3ede0678,3 +np.float32,0x3f0ba93c,0x3f7e6663,3 +np.float32,0xbf12bbc4,0x400b985e,3 +np.float32,0xbf2a8e1a,0x40133235,3 +np.float32,0x3f42029c,0x3f35f5c5,3 +np.float32,0x3eed1728,0x3f8b6f9c,3 +np.float32,0xbe5779ac,0x3fe432fd,3 +np.float32,0x3f6ed8b8,0x3ebc7e4b,3 +np.float32,0x3eea25b0,0x3f8c43c7,3 +np.float32,0x3f1988a4,0x3f6d786b,3 +np.float32,0xbe751674,0x3fe7ff8a,3 +np.float32,0xbe9f7418,0x3ff1997d,3 +np.float32,0x3dca11d0,0x3fbc6979,3 +np.float32,0x3f795226,0x3e6a6cab,3 +np.float32,0xbea780e0,0x3ff3b926,3 +np.float32,0xbed92770,0x4000901e,3 +np.float32,0xbf3e9f8c,0x401a49f8,3 +np.float32,0x3f0f7054,0x3f79ddb2,3 +np.float32,0x3a99d400,0x3fc8e966,3 +np.float32,0xbef082b0,0x4003d3c6,3 +np.float32,0xbf0d0790,0x4009defb,3 +np.float32,0xbf1649da,0x400cafb4,3 +np.float32,0xbea5aca8,0x3ff33d5c,3 +np.float32,0xbf4e1843,0x40206ba1,3 +np.float32,0xbe3d7d5c,0x3fe0e2ad,3 +np.float32,0xbf0e802d,0x400a500e,3 +np.float32,0xbf0de8f0,0x400a2295,3 +np.float32,0xbf3016ba,0x4015137e,3 +np.float32,0x3f36b1ea,0x3f46ae5d,3 +np.float32,0xbd27f170,0x3fce4fc7,3 +np.float32,0x3e96ec54,0x3fa2c31f,3 +np.float32,0x3eb4dfdc,0x3f9ad87d,3 +np.float32,0x3f5cac6c,0x3f0815cc,3 +np.float32,0xbf0489aa,0x40075bf1,3 +np.float32,0x3df010c0,0x3fba05f5,3 +np.float32,0xbf229f4a,0x4010956a,3 +np.float32,0x3f75e474,0x3e905a99,3 +np.float32,0xbcece6a0,0x3fccc397,3 +np.float32,0xbdb41528,0x3fd454e7,3 +np.float32,0x3ec8b2f8,0x3f958118,3 +np.float32,0x3f5eaa70,0x3f041a1d,3 +np.float32,0xbf32e1cc,0x40160b91,3 +np.float32,0xbe8e6026,0x3fed219c,3 +np.float32,0x3e6b3160,0x3fab65e3,3 +np.float32,0x3e6d7460,0x3fab1b81,3 +np.float32,0xbf13fbde,0x400bfa3b,3 +np.float32,0xbe8235ec,0x3fe9f9e3,3 +np.float32,0x3d71c4a0,0x3fc18096,3 +np.float32,0x3eb769d0,0x3f9a2aa0,3 +np.float32,0xbf68cb3b,0x402d99e4,3 +np.float32,0xbd917610,0x3fd22932,3 +np.float32,0x3d3cba60,0x3fc3297f,3 +np.float32,0xbf383cbe,0x4017f1cc,3 +np.float32,0xbeee96d0,0x40038e34,3 +np.float32,0x3ec89cb4,0x3f958725,3 +np.float32,0x3ebf92d8,0x3f97f95f,3 +np.float32,0x3f30f3da,0x3f4ec021,3 +np.float32,0xbd26b560,0x3fce45e4,3 +np.float32,0xbec0eb12,0x3ffa8330,3 +np.float32,0x3f6d592a,0x3ec4a6c1,3 +np.float32,0x3ea6d39c,0x3f9e9463,3 +np.float32,0x3e884184,0x3fa6951e,3 +np.float32,0x3ea566c4,0x3f9ef4d1,3 +np.float32,0x3f0c8f4c,0x3f7d5380,3 +np.float32,0x3f28e1ba,0x3f59b2cb,3 +np.float32,0x3f798538,0x3e66e1c3,3 +np.float32,0xbe2889b8,0x3fde39b8,3 +np.float32,0x3f3da05e,0x3f3c949c,3 +np.float32,0x3f24d700,0x3f5f073e,3 +np.float32,0xbe5b5768,0x3fe4b198,3 +np.float32,0xbed3b03a,0x3fff9f05,3 +np.float32,0x3e8a1c4c,0x3fa619eb,3 +np.float32,0xbf075d24,0x40083030,3 +np.float32,0x3f765648,0x3e8d1f52,3 +np.float32,0xbf70fc5e,0x403308bb,3 +np.float32,0x3f557ae8,0x3f15ab76,3 +np.float32,0x3f02f7ea,0x3f84521c,3 +np.float32,0x3f7ebbde,0x3dcbc5c5,3 +np.float32,0xbefbdfc6,0x40057285,3 +np.float32,0x3ec687ac,0x3f9617d9,3 +np.float32,0x3e4831c8,0x3fafe01b,3 +np.float32,0x3e25cde0,0x3fb43ea8,3 +np.float32,0x3e4f2ab8,0x3faefc70,3 +np.float32,0x3ea60ae4,0x3f9ec973,3 +np.float32,0xbf1ed55f,0x400f5dde,3 +np.float32,0xbf5ad4aa,0x40262479,3 +np.float32,0x3e8b3594,0x3fa5d0de,3 +np.float32,0x3f3a77aa,0x3f413c80,3 +np.float32,0xbf07512b,0x40082ca9,3 +np.float32,0x3f33d990,0x3f4ab5e5,3 +np.float32,0x3f521556,0x3f1bb78f,3 +np.float32,0xbecf6036,0x3ffe7086,3 +np.float32,0x3db91bd0,0x3fbd7a11,3 +np.float32,0x3ef63a74,0x3f88d839,3 +np.float32,0xbf2f1116,0x4014b99c,3 +np.float32,0xbf17fdc0,0x400d36b9,3 +np.float32,0xbe87df2c,0x3feb7117,3 +np.float32,0x80800000,0x3fc90fdb,3 +np.float32,0x3ee24c1c,0x3f8e7641,3 +np.float32,0x3f688dce,0x3edcd644,3 +np.float32,0xbf0f4e1c,0x400a8e1b,3 +np.float32,0x0,0x3fc90fdb,3 +np.float32,0x3f786eba,0x3e7999d4,3 +np.float32,0xbf404f80,0x401aeca8,3 +np.float32,0xbe9ffb6a,0x3ff1bd18,3 +np.float32,0x3f146bfc,0x3f73ccfd,3 +np.float32,0xbe47d630,0x3fe233ee,3 +np.float32,0xbe95847c,0x3feefe7c,3 +np.float32,0xbf135df0,0x400bc9e5,3 +np.float32,0x3ea19f3c,0x3f9ff411,3 +np.float32,0x3f235e20,0x3f60f247,3 +np.float32,0xbec789ec,0x3ffc4def,3 +np.float32,0x3f04b656,0x3f834db6,3 +np.float32,0x3dfaf440,0x3fb95679,3 +np.float32,0xbe4a7f28,0x3fe28abe,3 +np.float32,0x3ed4850c,0x3f92463b,3 +np.float32,0x3ec4ba5c,0x3f9694dd,3 +np.float32,0xbce24ca0,0x3fcc992b,3 +np.float32,0xbf5b7c6e,0x402675a0,3 +np.float32,0xbea3ce2a,0x3ff2bf04,3 +np.float32,0x3db02c60,0x3fbe0998,3 +np.float32,0x3c47b780,0x3fc78069,3 +np.float32,0x3ed33b20,0x3f92a0d5,3 +np.float32,0xbf4556d7,0x401cdcde,3 +np.float32,0xbe1b6e28,0x3fdc90ec,3 +np.float32,0xbf3289b7,0x4015ecd0,3 +np.float32,0x3df3f240,0x3fb9c76d,3 +np.float32,0x3eefa7d0,0x3f8ab61d,3 +np.float32,0xbe945838,0x3feeb006,3 +np.float32,0xbf0b1386,0x400949a3,3 +np.float32,0x3f77e546,0x3e812cc1,3 +np.float32,0x3e804ba0,0x3fa8a480,3 +np.float32,0x3f43dcea,0x3f331a06,3 +np.float32,0x3eb87450,0x3f99e33c,3 +np.float32,0x3e5f4898,0x3facecea,3 +np.float32,0x3f646640,0x3eeff10e,3 +np.float32,0x3f1aa832,0x3f6c1051,3 +np.float32,0xbebf6bfa,0x3ffa1bdc,3 +np.float32,0xbb77f300,0x3fc98bd4,3 +np.float32,0x3f3587fe,0x3f485645,3 +np.float32,0x3ef85f34,0x3f883b8c,3 +np.float32,0x3f50e584,0x3f1dc82c,3 +np.float32,0x3f1d30a8,0x3f68deb0,3 +np.float32,0x3ee75a78,0x3f8d0c86,3 +np.float32,0x3f2c023a,0x3f5581e1,3 +np.float32,0xbf074e34,0x40082bca,3 +np.float32,0xbead71f0,0x3ff54c6d,3 +np.float32,0xbf39ed88,0x40188e69,3 +np.float32,0x3f5d2fe6,0x3f07118b,3 +np.float32,0xbf1f79f8,0x400f9267,3 +np.float32,0x3e900c58,0x3fa48e99,3 +np.float32,0xbf759cb2,0x4036c47b,3 +np.float32,0x3f63329c,0x3ef5359c,3 +np.float32,0xbf5d6755,0x40276709,3 +np.float32,0x3f2ce31c,0x3f54519a,3 +np.float32,0x7f800000,0x7fc00000,3 +np.float32,0x3f1bf50e,0x3f6a6d9a,3 +np.float32,0x3f258334,0x3f5e25d8,3 +np.float32,0xbf661a3f,0x402c06ac,3 +np.float32,0x3d1654c0,0x3fc45cef,3 +np.float32,0xbef14a36,0x4003f009,3 +np.float32,0xbf356051,0x4016ec3a,3 +np.float32,0x3f6ccc42,0x3ec79193,3 +np.float32,0xbf2fe3d6,0x401501f9,3 +np.float32,0x3deedc80,0x3fba195b,3 +np.float32,0x3f2e5a28,0x3f52533e,3 +np.float32,0x3e6b68b8,0x3fab5ec8,3 +np.float32,0x3e458240,0x3fb037b7,3 +np.float32,0xbf24bab0,0x401144cb,3 +np.float32,0x3f600f4c,0x3f013fb2,3 +np.float32,0x3f021a04,0x3f84d316,3 +np.float32,0x3f741732,0x3e9cc948,3 +np.float32,0x3f0788aa,0x3f81a5b0,3 +np.float32,0x3f28802c,0x3f5a347c,3 +np.float32,0x3c9eb400,0x3fc69500,3 +np.float32,0x3e5d11e8,0x3fad357a,3 +np.float32,0x3d921250,0x3fbfecb9,3 +np.float32,0x3f354866,0x3f48b066,3 +np.float32,0xbf72cf43,0x40346d84,3 +np.float32,0x3eecdbb8,0x3f8b805f,3 +np.float32,0xbee585d0,0x400247fd,3 +np.float32,0x3e3607a8,0x3fb22fc6,3 +np.float32,0xbf0cb7d6,0x4009c71c,3 +np.float32,0xbf56b230,0x402432ec,3 +np.float32,0xbf4ced02,0x401fee29,3 +np.float32,0xbf3a325c,0x4018a776,3 +np.float32,0x3ecae8bc,0x3f94e732,3 +np.float32,0xbe48c7e8,0x3fe252bd,3 +np.float32,0xbe175d7c,0x3fdc0d5b,3 +np.float32,0x3ea78dac,0x3f9e632d,3 +np.float32,0xbe7434a8,0x3fe7e279,3 +np.float32,0x3f1f9e02,0x3f65c7b9,3 +np.float32,0xbe150f2c,0x3fdbc2c2,3 +np.float32,0x3ee13480,0x3f8ec423,3 +np.float32,0x3ecb7d54,0x3f94beb9,3 +np.float32,0x3f1cef42,0x3f693181,3 +np.float32,0xbf1ec06a,0x400f5730,3 +np.float32,0xbe112acc,0x3fdb44e8,3 +np.float32,0xbe77b024,0x3fe85545,3 +np.float32,0x3ec86fe0,0x3f959353,3 +np.float32,0x3f36b326,0x3f46ac9a,3 +np.float32,0x3e581a70,0x3fadd829,3 +np.float32,0xbf032c0c,0x4006f5f9,3 +np.float32,0xbf43b1fd,0x401c38b1,3 +np.float32,0x3f3701b4,0x3f463c5c,3 +np.float32,0x3f1a995a,0x3f6c22f1,3 +np.float32,0xbf05de0b,0x4007bf97,3 +np.float32,0x3d4bd960,0x3fc2b063,3 +np.float32,0x3f0e1618,0x3f7b7ed0,3 +np.float32,0x3edfd420,0x3f8f2628,3 +np.float32,0xbf6662fe,0x402c3047,3 +np.float32,0x3ec0690c,0x3f97bf9b,3 +np.float32,0xbeaf4146,0x3ff5c7a0,3 +np.float32,0x3f5e7764,0x3f04816d,3 +np.float32,0xbedd192c,0x40011bc5,3 +np.float32,0x3eb76350,0x3f9a2c5e,3 +np.float32,0xbed8108c,0x400069a5,3 +np.float32,0xbe59f31c,0x3fe48401,3 +np.float32,0xbea3e1e6,0x3ff2c439,3 +np.float32,0x3e26d1f8,0x3fb41db5,3 +np.float32,0x3f3a0a7c,0x3f41dba5,3 +np.float32,0x3ebae068,0x3f993ce4,3 +np.float32,0x3f2d8e30,0x3f536942,3 +np.float32,0xbe838bbe,0x3fea5247,3 +np.float32,0x3ebe4420,0x3f98538f,3 +np.float32,0xbcc59b80,0x3fcc265c,3 +np.float32,0x3eebb5c8,0x3f8bd334,3 +np.float32,0xbafc3400,0x3fc94ee8,3 +np.float32,0xbf63ddc1,0x402ac683,3 +np.float32,0xbeabdf80,0x3ff4e18f,3 +np.float32,0x3ea863f0,0x3f9e2a78,3 +np.float32,0x3f45b292,0x3f303bc1,3 +np.float32,0xbe68aa60,0x3fe666bf,3 +np.float32,0x3eb9de18,0x3f998239,3 +np.float32,0xbf719d85,0x4033815e,3 +np.float32,0x3edef9a8,0x3f8f62db,3 +np.float32,0xbd7781c0,0x3fd0cd1e,3 +np.float32,0x3f0b3b90,0x3f7ee92a,3 +np.float32,0xbe3eb3b4,0x3fe10a27,3 +np.float32,0xbf31a4c4,0x40159d23,3 +np.float32,0x3e929434,0x3fa3e5b0,3 +np.float32,0xbeb1a90e,0x3ff66b9e,3 +np.float32,0xbeba9b5e,0x3ff8d048,3 +np.float32,0xbf272a84,0x4012119e,3 +np.float32,0x3f1ebbd0,0x3f66e889,3 +np.float32,0x3ed3cdc8,0x3f927893,3 +np.float32,0xbf50dfce,0x40219b58,3 +np.float32,0x3f0c02de,0x3f7dfb62,3 +np.float32,0xbf694de3,0x402de8d2,3 +np.float32,0xbeaeb13e,0x3ff5a14f,3 +np.float32,0xbf61aa7a,0x40299702,3 +np.float32,0xbf13d159,0x400bed35,3 +np.float32,0xbeecd034,0x40034e0b,3 +np.float32,0xbe50c2e8,0x3fe35761,3 +np.float32,0x3f714406,0x3eae8e57,3 +np.float32,0xbf1ca486,0x400eabd8,3 +np.float32,0x3f5858cc,0x3f106497,3 +np.float32,0x3f670288,0x3ee41c84,3 +np.float32,0xbf20bd2c,0x400ff9f5,3 +np.float32,0xbe29afd8,0x3fde5eff,3 +np.float32,0xbf635e6a,0x402a80f3,3 +np.float32,0x3e82b7b0,0x3fa80446,3 +np.float32,0x3e982e7c,0x3fa26ece,3 +np.float32,0x3d9f0e00,0x3fbf1c6a,3 +np.float32,0x3e8299b4,0x3fa80c07,3 +np.float32,0xbf0529c1,0x40078ac3,3 +np.float32,0xbf403b8a,0x401ae519,3 +np.float32,0xbe57e09c,0x3fe44027,3 +np.float32,0x3ea1c8f4,0x3f9fe913,3 +np.float32,0xbe216a94,0x3fdd52d0,3 +np.float32,0x3f59c442,0x3f0db709,3 +np.float32,0xbd636260,0x3fd02bdd,3 +np.float32,0xbdbbc788,0x3fd4d08d,3 +np.float32,0x3dd19560,0x3fbbf0a3,3 +np.float32,0x3f060ad4,0x3f828641,3 +np.float32,0x3b102e00,0x3fc8c7c4,3 +np.float32,0x3f42b3b8,0x3f34e5a6,3 +np.float32,0x3f0255ac,0x3f84b071,3 +np.float32,0xbf014898,0x40066996,3 +np.float32,0x3e004dc0,0x3fb8fb51,3 +np.float32,0xbf594ff8,0x40256af2,3 +np.float32,0x3efafddc,0x3f877b80,3 +np.float32,0xbf5f0780,0x40283899,3 +np.float32,0x3ee95e54,0x3f8c7bcc,3 +np.float32,0x3eba2f0c,0x3f996c80,3 +np.float32,0x3f37721c,0x3f459b68,3 +np.float32,0x3e2be780,0x3fb378bf,3 +np.float32,0x3e550270,0x3fae3d69,3 +np.float32,0x3e0f9500,0x3fb70e0a,3 +np.float32,0xbf51974a,0x4021eaf4,3 +np.float32,0x3f393832,0x3f430d05,3 +np.float32,0x3f3df16a,0x3f3c1bd8,3 +np.float32,0xbd662340,0x3fd041ed,3 +np.float32,0x3f7e8418,0x3ddc9fce,3 +np.float32,0xbf392734,0x40184672,3 +np.float32,0x3ee3b278,0x3f8e124e,3 +np.float32,0x3eed4808,0x3f8b61d2,3 +np.float32,0xbf6fccbd,0x40322beb,3 +np.float32,0x3e3ecdd0,0x3fb1123b,3 +np.float32,0x3f4419e0,0x3f32bb45,3 +np.float32,0x3f595e00,0x3f0e7914,3 +np.float32,0xbe8c1486,0x3fec88c6,3 +np.float32,0xbf800000,0x40490fdb,3 +np.float32,0xbdaf5020,0x3fd4084d,3 +np.float32,0xbf407660,0x401afb63,3 +np.float32,0x3f0c3aa8,0x3f7db8b8,3 +np.float32,0xbcdb5980,0x3fcc7d5b,3 +np.float32,0x3f4738d4,0x3f2dd1ed,3 +np.float32,0x3f4d7064,0x3f23ab14,3 +np.float32,0xbeb1d576,0x3ff67774,3 +np.float32,0xbf507166,0x40216bb3,3 +np.float32,0x3e86484c,0x3fa71813,3 +np.float32,0x3f09123e,0x3f80bd35,3 +np.float32,0xbe9abe0e,0x3ff05cb2,3 +np.float32,0x3f3019dc,0x3f4fed21,3 +np.float32,0xbe99e00e,0x3ff0227d,3 +np.float32,0xbf155ec5,0x400c6739,3 +np.float32,0x3f5857ba,0x3f106698,3 +np.float32,0x3edf619c,0x3f8f45fb,3 +np.float32,0xbf5ab76a,0x40261664,3 +np.float32,0x3e54b5a8,0x3fae4738,3 +np.float32,0xbee92772,0x4002ca40,3 +np.float32,0x3f2fd610,0x3f504a7a,3 +np.float32,0xbf38521c,0x4017f97e,3 +np.float32,0xff800000,0x7fc00000,3 +np.float32,0x3e2da348,0x3fb34077,3 +np.float32,0x3f2f85fa,0x3f50b894,3 +np.float32,0x3e88f9c8,0x3fa66551,3 +np.float32,0xbf61e570,0x4029b648,3 +np.float32,0xbeab362c,0x3ff4b4a1,3 +np.float32,0x3ec6c310,0x3f9607bd,3 +np.float32,0x3f0d7bda,0x3f7c3810,3 +np.float32,0xbeba5d36,0x3ff8bf99,3 +np.float32,0x3f4b0554,0x3f27adda,3 +np.float32,0x3f60f5dc,0x3efebfb3,3 +np.float32,0x3f36ce2c,0x3f468603,3 +np.float32,0xbe70afac,0x3fe76e8e,3 +np.float32,0x3f673350,0x3ee339b5,3 +np.float32,0xbe124cf0,0x3fdb698c,3 +np.float32,0xbf1243dc,0x400b73d0,3 +np.float32,0x3f3c8850,0x3f3e3407,3 +np.float32,0x3ea02f24,0x3fa05500,3 +np.float32,0xbeffed34,0x400607db,3 +np.float32,0x3f5c75c2,0x3f08817c,3 +np.float32,0x3f4b2fbe,0x3f27682d,3 +np.float32,0x3ee47c34,0x3f8dd9f9,3 +np.float32,0x3f50d48c,0x3f1de584,3 +np.float32,0x3f12dc5e,0x3f75b628,3 +np.float32,0xbefe7e4a,0x4005d2f4,3 +np.float32,0xbec2e846,0x3ffb0cbc,3 +np.float32,0xbedc3036,0x4000fb80,3 +np.float32,0xbf48aedc,0x401e311f,3 +np.float32,0x3f6e032e,0x3ec11363,3 +np.float32,0xbf60de15,0x40292b72,3 +np.float32,0x3f06585e,0x3f8258ba,3 +np.float32,0x3ef49b98,0x3f894e66,3 +np.float32,0x3cc5fe00,0x3fc5f7cf,3 +np.float32,0xbf7525c5,0x40365c2c,3 +np.float32,0x3f64f9f8,0x3eed5fb2,3 +np.float32,0x3e8849c0,0x3fa692fb,3 +np.float32,0x3e50c878,0x3faec79e,3 +np.float32,0x3ed61530,0x3f91d831,3 +np.float32,0xbf54872e,0x40233724,3 +np.float32,0xbf52ee7f,0x4022815e,3 +np.float32,0xbe708c24,0x3fe769fc,3 +np.float32,0xbf26fc54,0x40120260,3 +np.float32,0x3f226e8a,0x3f6228db,3 +np.float32,0xbef30406,0x40042eb8,3 +np.float32,0x3f5d996c,0x3f063f5f,3 +np.float32,0xbf425f9c,0x401bb618,3 +np.float32,0x3e4bb260,0x3faf6dc9,3 +np.float32,0xbe52d5a4,0x3fe39b29,3 +np.float32,0xbe169cf0,0x3fdbf505,3 +np.float32,0xbedfc422,0x40017a8e,3 +np.float32,0x3d8ffef0,0x3fc00e05,3 +np.float32,0xbf12bdab,0x400b98f2,3 +np.float32,0x3f295d0a,0x3f590e88,3 +np.float32,0x3f49d8e4,0x3f2998aa,3 +np.float32,0xbef914f4,0x40050c12,3 +np.float32,0xbf4ea2b5,0x4020a61e,3 +np.float32,0xbf3a89e5,0x4018c762,3 +np.float32,0x3e8707b4,0x3fa6e67a,3 +np.float32,0x3ac55400,0x3fc8de86,3 +np.float32,0x800000,0x3fc90fdb,3 +np.float32,0xbeb9762c,0x3ff8819b,3 +np.float32,0xbebbe23c,0x3ff92815,3 +np.float32,0xbf598c88,0x402587a1,3 +np.float32,0x3e95d864,0x3fa30b4a,3 +np.float32,0x3f7f6f40,0x3d882486,3 +np.float32,0xbf53658c,0x4022b604,3 +np.float32,0xbf2a35f2,0x401314ad,3 +np.float32,0x3eb14380,0x3f9bcf28,3 +np.float32,0x3f0e0c64,0x3f7b8a7a,3 +np.float32,0x3d349920,0x3fc36a9a,3 +np.float32,0xbec2092c,0x3ffad071,3 +np.float32,0xbe1d08e8,0x3fdcc4e0,3 +np.float32,0xbf008968,0x40063243,3 +np.float32,0xbefad582,0x40054c51,3 +np.float32,0xbe52d010,0x3fe39a72,3 +np.float32,0x3f4afdac,0x3f27ba6b,3 +np.float32,0x3f6c483c,0x3eca4408,3 +np.float32,0xbef3cb68,0x40044b0c,3 +np.float32,0x3e94687c,0x3fa36b6f,3 +np.float32,0xbf64ae5c,0x402b39bb,3 +np.float32,0xbf0022b4,0x40061497,3 +np.float32,0x80000001,0x3fc90fdb,3 +np.float32,0x3f25bcd0,0x3f5dda4b,3 +np.float32,0x3ed91b40,0x3f9102d7,3 +np.float32,0x3f800000,0x0,3 +np.float32,0xbebc6aca,0x3ff94cca,3 +np.float32,0x3f239e9a,0x3f609e7d,3 +np.float32,0xbf7312be,0x4034a305,3 +np.float32,0x3efd16d0,0x3f86e148,3 +np.float32,0x3f52753a,0x3f1b0f72,3 +np.float32,0xbde58960,0x3fd7702c,3 +np.float32,0x3ef88580,0x3f883099,3 +np.float32,0x3eebaefc,0x3f8bd51e,3 +np.float32,0x3e877d2c,0x3fa6c807,3 +np.float32,0x3f1a0324,0x3f6cdf32,3 +np.float32,0xbedfe20a,0x40017eb6,3 +np.float32,0x3f205a3c,0x3f64d69d,3 +np.float32,0xbeed5b7c,0x400361b0,3 +np.float32,0xbf69ba10,0x402e2ad0,3 +np.float32,0x3c4fe200,0x3fc77014,3 +np.float32,0x3f043310,0x3f839a69,3 +np.float32,0xbeaf359a,0x3ff5c485,3 +np.float32,0x3db3f110,0x3fbdcd12,3 +np.float32,0x3e24af88,0x3fb462ed,3 +np.float32,0xbf34e858,0x4016c1c8,3 +np.float32,0x3f3334f2,0x3f4b9cd0,3 +np.float32,0xbf145882,0x400c16a2,3 +np.float32,0xbf541c38,0x40230748,3 +np.float32,0x3eba7e10,0x3f99574b,3 +np.float32,0xbe34c6e0,0x3fdfc731,3 +np.float32,0xbe957abe,0x3feefbf0,3 +np.float32,0xbf595a59,0x40256fdb,3 +np.float32,0xbdedc7b8,0x3fd7f4f0,3 +np.float32,0xbf627c02,0x402a06a9,3 +np.float32,0x3f339b78,0x3f4b0d18,3 +np.float32,0xbf2df6d2,0x40145929,3 +np.float32,0x3f617726,0x3efc9fd8,3 +np.float32,0xbee3a8fc,0x40020561,3 +np.float32,0x3efe9f68,0x3f867043,3 +np.float32,0xbf2c3e76,0x4013c3ba,3 +np.float32,0xbf218f28,0x40103d84,3 +np.float32,0xbf1ea847,0x400f4f7f,3 +np.float32,0x3ded9160,0x3fba2e31,3 +np.float32,0x3bce1b00,0x3fc841bf,3 +np.float32,0xbe90566e,0x3feda46a,3 +np.float32,0xbf5ea2ba,0x4028056b,3 +np.float32,0x3f538e62,0x3f191ee6,3 +np.float32,0xbf59e054,0x4025af74,3 +np.float32,0xbe8c98ba,0x3fecab24,3 +np.float32,0x3ee7bdb0,0x3f8cf0b7,3 +np.float32,0xbf2eb828,0x40149b2b,3 +np.float32,0xbe5eb904,0x3fe52068,3 +np.float32,0xbf16b422,0x400cd08d,3 +np.float32,0x3f1ab9b4,0x3f6bfa58,3 +np.float32,0x3dc23040,0x3fbce82a,3 +np.float32,0xbf29d9e7,0x4012f5e5,3 +np.float32,0xbf38f30a,0x40183393,3 +np.float32,0x3e88e798,0x3fa66a09,3 +np.float32,0x3f1d07e6,0x3f69124f,3 +np.float32,0xbe1d3d34,0x3fdccb7e,3 +np.float32,0xbf1715be,0x400ceec2,3 +np.float32,0x3f7a0eac,0x3e5d11f7,3 +np.float32,0xbe764924,0x3fe82707,3 +np.float32,0xbf01a1f8,0x4006837c,3 +np.float32,0x3f2be730,0x3f55a661,3 +np.float32,0xbf7bb070,0x403d4ce5,3 +np.float32,0xbd602110,0x3fd011c9,3 +np.float32,0x3f5d080c,0x3f07609d,3 +np.float32,0xbda20400,0x3fd332d1,3 +np.float32,0x3f1c62da,0x3f69e308,3 +np.float32,0xbf2c6916,0x4013d223,3 +np.float32,0xbf44f8fd,0x401cb816,3 +np.float32,0x3f4da392,0x3f235539,3 +np.float32,0x3e9e8aa0,0x3fa0c3a0,3 +np.float32,0x3e9633c4,0x3fa2f366,3 +np.float32,0xbf0422ab,0x40073ddd,3 +np.float32,0x3f518386,0x3f1cb603,3 +np.float32,0x3f24307a,0x3f5fe096,3 +np.float32,0xbdfb4220,0x3fd8ce24,3 +np.float32,0x3f179d28,0x3f6fdc7d,3 +np.float32,0xbecc2df0,0x3ffd911e,3 +np.float32,0x3f3dff0c,0x3f3c0782,3 +np.float32,0xbf58c4d8,0x4025295b,3 +np.float32,0xbdcf8438,0x3fd60dd3,3 +np.float32,0xbeeaf1b2,0x40030aa7,3 +np.float32,0xbf298a28,0x4012db45,3 +np.float32,0x3f6c4dec,0x3eca2678,3 +np.float32,0x3f4d1ac8,0x3f243a59,3 +np.float32,0x3f62cdfa,0x3ef6e8f8,3 +np.float32,0xbee8acce,0x4002b909,3 +np.float32,0xbd5f2af0,0x3fd00a15,3 +np.float32,0x3f5fde8e,0x3f01a453,3 +np.float32,0x3e95233c,0x3fa33aa4,3 +np.float32,0x3ecd2a60,0x3f9449be,3 +np.float32,0x3f10aa86,0x3f78619d,3 +np.float32,0x3f3888e8,0x3f440a70,3 +np.float32,0x3eeb5bfc,0x3f8bec7d,3 +np.float32,0xbe12d654,0x3fdb7ae6,3 +np.float32,0x3eca3110,0x3f951931,3 +np.float32,0xbe2d1b7c,0x3fdece05,3 +np.float32,0xbf29e9db,0x4012fb3a,3 +np.float32,0xbf0c50b8,0x4009a845,3 +np.float32,0xbed9f0e4,0x4000abef,3 +np.float64,0x3fd078ec5ba0f1d8,0x3ff4f7c00595a4d3,1 +np.float64,0xbfdbc39743b7872e,0x400027f85bce43b2,1 +np.float64,0xbfacd2707c39a4e0,0x3ffa08ae1075d766,1 +np.float64,0xbfc956890f32ad14,0x3ffc52308e7285fd,1 +np.float64,0xbf939c2298273840,0x3ff9706d18e6ea6b,1 +np.float64,0xbfe0d7048961ae09,0x4000fff4406bd395,1 +np.float64,0xbfe9d19b86f3a337,0x4004139bc683a69f,1 +np.float64,0x3fd35c7f90a6b900,0x3ff437220e9123f8,1 +np.float64,0x3fdddca171bbb944,0x3ff15da61e61ec08,1 +np.float64,0x3feb300de9f6601c,0x3fe1c6fadb68cdca,1 +np.float64,0xbfef1815327e302a,0x400739808fc6f964,1 +np.float64,0xbfe332d78e6665af,0x4001b6c4ef922f7c,1 +np.float64,0xbfedbf4dfb7b7e9c,0x40061cefed62a58b,1 +np.float64,0xbfd8dcc7e3b1b990,0x3fff84307713c2c3,1 +np.float64,0xbfedaf161c7b5e2c,0x400612027c1b2b25,1 +np.float64,0xbfed9bde897b37bd,0x4006053f05bd7d26,1 +np.float64,0xbfe081ebc26103d8,0x4000e70755eb66e0,1 +np.float64,0xbfe0366f9c606cdf,0x4000d11212f29afd,1 +np.float64,0xbfc7c115212f822c,0x3ffc1e8c9d58f7db,1 +np.float64,0x3fd8dd9a78b1bb34,0x3ff2bf8d0f4c9376,1 +np.float64,0xbfe54eff466a9dfe,0x4002655950b611f4,1 +np.float64,0xbfe4aad987e955b3,0x40022efb19882518,1 +np.float64,0x3f70231ca0204600,0x3ff911d834e7abf4,1 +np.float64,0x3fede01d047bc03a,0x3fd773cecbd8561b,1 +np.float64,0xbfd6a00d48ad401a,0x3ffee9fd7051633f,1 +np.float64,0x3fd44f3d50a89e7c,0x3ff3f74dd0fc9c91,1 +np.float64,0x3fe540f0d0ea81e2,0x3feb055a7c7d43d6,1 +np.float64,0xbf3ba2e200374800,0x3ff923b582650c6c,1 +np.float64,0x3fe93b2d3f72765a,0x3fe532fa15331072,1 +np.float64,0x3fee8ce5a17d19cc,0x3fd35666eefbe336,1 +np.float64,0x3fe55d5f8feabac0,0x3feadf3dcfe251d4,1 +np.float64,0xbfd1d2ede8a3a5dc,0x3ffda600041ac884,1 +np.float64,0xbfee41186e7c8231,0x40067a625cc6f64d,1 +np.float64,0x3fe521a8b9ea4352,0x3feb2f1a6c8084e5,1 +np.float64,0x3fc65378ef2ca6f0,0x3ff653dfe81ee9f2,1 +np.float64,0x3fdaba0fbcb57420,0x3ff23d630995c6ba,1 +np.float64,0xbfe6b7441d6d6e88,0x4002e182539a2994,1 +np.float64,0x3fda00b6dcb4016c,0x3ff2703d516f28e7,1 +np.float64,0xbfe8699f01f0d33e,0x400382326920ea9e,1 +np.float64,0xbfef5889367eb112,0x4007832af5983793,1 +np.float64,0x3fefb57c8aff6afa,0x3fc14700ab38dcef,1 +np.float64,0xbfda0dfdaab41bfc,0x3fffd75b6fd497f6,1 +np.float64,0xbfb059c36620b388,0x3ffa27c528b97a42,1 +np.float64,0xbfdd450ab1ba8a16,0x40005dcac6ab50fd,1 +np.float64,0xbfe54d6156ea9ac2,0x400264ce9f3f0fb9,1 +np.float64,0xbfe076e94760edd2,0x4000e3d1374884da,1 +np.float64,0xbfc063286720c650,0x3ffb2fd1d6bff0ef,1 +np.float64,0xbfe24680f2e48d02,0x40016ddfbb5bcc0e,1 +np.float64,0xbfdc9351d2b926a4,0x400044e3756fb765,1 +np.float64,0x3fefb173d8ff62e8,0x3fc1bd5626f80850,1 +np.float64,0x3fe77c117a6ef822,0x3fe7e57089bad2ec,1 +np.float64,0xbfddbcebf7bb79d8,0x40006eadb60406b3,1 +np.float64,0xbfecf6625ff9ecc5,0x40059e6c6961a6db,1 +np.float64,0x3fdc8950b8b912a0,0x3ff1bcfb2e27795b,1 +np.float64,0xbfeb2fa517765f4a,0x4004b00aee3e6888,1 +np.float64,0x3fd0efc88da1df90,0x3ff4d8f7cbd8248a,1 +np.float64,0xbfe6641a2becc834,0x4002c43362c1bd0f,1 +np.float64,0xbfe28aec0fe515d8,0x400182c91d4df039,1 +np.float64,0xbfd5ede8d0abdbd2,0x3ffeba7baef05ae8,1 +np.float64,0xbfbd99702a3b32e0,0x3ffafca21c1053f1,1 +np.float64,0x3f96f043f82de080,0x3ff8c6384d5eb610,1 +np.float64,0xbfe5badbc9eb75b8,0x400289c8cd5873d1,1 +np.float64,0x3fe5c6bf95eb8d80,0x3fea5093e9a3e43e,1 +np.float64,0x3fb1955486232ab0,0x3ff8086d4c3e71d5,1 +np.float64,0xbfea145f397428be,0x4004302237a35871,1 +np.float64,0xbfdabe685db57cd0,0x400003e2e29725fb,1 +np.float64,0xbfefc79758ff8f2f,0x400831814e23bfc8,1 +np.float64,0x3fd7edb66cafdb6c,0x3ff3006c5123bfaf,1 +np.float64,0xbfeaf7644bf5eec8,0x400495a7963ce4ed,1 +np.float64,0x3fdf838d78bf071c,0x3ff0e527eed73800,1 +np.float64,0xbfd1a0165ba3402c,0x3ffd98c5ab76d375,1 +np.float64,0x3fd75b67a9aeb6d0,0x3ff327c8d80b17cf,1 +np.float64,0x3fc2aa9647255530,0x3ff6ca854b157df1,1 +np.float64,0xbfe0957fd4612b00,0x4000ecbf3932becd,1 +np.float64,0x3fda1792c0b42f24,0x3ff269fbb2360487,1 +np.float64,0x3fd480706ca900e0,0x3ff3ea53a6aa3ae8,1 +np.float64,0xbfd0780ed9a0f01e,0x3ffd4bfd544c7d47,1 +np.float64,0x3feeec0cd77dd81a,0x3fd0a8a241fdb441,1 +np.float64,0x3fcfa933e93f5268,0x3ff5223478621a6b,1 +np.float64,0x3fdad2481fb5a490,0x3ff236b86c6b2b49,1 +np.float64,0x3fe03b129de07626,0x3ff09f21fb868451,1 +np.float64,0xbfc01212cd202424,0x3ffb259a07159ae9,1 +np.float64,0x3febdb912df7b722,0x3fe0768e20dac8c9,1 +np.float64,0xbfbf2148763e4290,0x3ffb154c361ce5bf,1 +np.float64,0xbfb1a7eb1e234fd8,0x3ffa3cb37ac4a176,1 +np.float64,0xbfe26ad1ec64d5a4,0x400178f480ecce8d,1 +np.float64,0x3fe6d1cd1b6da39a,0x3fe8dc20ec4dad3b,1 +np.float64,0xbfede0e53dfbc1ca,0x4006340d3bdd7c97,1 +np.float64,0xbfe8fd1bd9f1fa38,0x4003bc3477f93f40,1 +np.float64,0xbfe329d0f26653a2,0x4001b3f345af5648,1 +np.float64,0xbfe4bb20eee97642,0x40023451404d6d08,1 +np.float64,0x3fb574832e2ae900,0x3ff7ca4bed0c7110,1 +np.float64,0xbfdf3c098fbe7814,0x4000a525bb72d659,1 +np.float64,0x3fa453e6d428a7c0,0x3ff87f512bb9b0c6,1 +np.float64,0x3faaec888435d920,0x3ff84a7d9e4def63,1 +np.float64,0xbfcdc240df3b8480,0x3ffce30ece754e7f,1 +np.float64,0xbf8c3220f0386440,0x3ff95a600ae6e157,1 +np.float64,0x3fe806076c700c0e,0x3fe71784a96c76eb,1 +np.float64,0x3fedf9b0e17bf362,0x3fd6e35fc0a7b6c3,1 +np.float64,0xbfe1b48422636908,0x400141bd8ed251bc,1 +np.float64,0xbfe82e2817705c50,0x40036b5a5556d021,1 +np.float64,0xbfc8ef8ff931df20,0x3ffc450ffae7ce58,1 +np.float64,0xbfe919fa94f233f5,0x4003c7cce4697fe8,1 +np.float64,0xbfc3ace4a72759c8,0x3ffb9a197bb22651,1 +np.float64,0x3fe479f71ee8f3ee,0x3fec0bd2f59097aa,1 +np.float64,0xbfeeb54a967d6a95,0x4006da12c83649c5,1 +np.float64,0x3fe5e74ea8ebce9e,0x3fea2407cef0f08c,1 +np.float64,0x3fb382baf2270570,0x3ff7e98213b921ba,1 +np.float64,0xbfdd86fd3cbb0dfa,0x40006712952ddbcf,1 +np.float64,0xbfd250eb52a4a1d6,0x3ffdc6d56253b1cd,1 +np.float64,0x3fea30c4ed74618a,0x3fe3962deba4f30e,1 +np.float64,0x3fc895963d312b30,0x3ff60a5d52fcbccc,1 +np.float64,0x3fe9cc4f6273989e,0x3fe442740942c80f,1 +np.float64,0xbfe8769f5cf0ed3f,0x4003873b4cb5bfce,1 +np.float64,0xbfe382f3726705e7,0x4001cfeb3204d110,1 +np.float64,0x3fbfe9a9163fd350,0x3ff7220bd2b97c8f,1 +np.float64,0xbfca6162bb34c2c4,0x3ffc743f939358f1,1 +np.float64,0x3fe127a014e24f40,0x3ff0147c4bafbc39,1 +np.float64,0x3fee9cdd2a7d39ba,0x3fd2e9ef45ab122f,1 +np.float64,0x3fa9ffb97c33ff80,0x3ff851e69fa3542c,1 +np.float64,0x3fd378f393a6f1e8,0x3ff42faafa77de56,1 +np.float64,0xbfe4df1e1669be3c,0x400240284df1c321,1 +np.float64,0x3fed0ed79bfa1db0,0x3fdba89060aa96fb,1 +np.float64,0x3fdef2ee52bde5dc,0x3ff10e942244f4f1,1 +np.float64,0xbfdab38f3ab5671e,0x40000264d8d5b49b,1 +np.float64,0x3fbe95a96e3d2b50,0x3ff73774cb59ce2d,1 +np.float64,0xbfe945653af28aca,0x4003d9657bf129c2,1 +np.float64,0xbfb18f3f2a231e80,0x3ffa3b27cba23f50,1 +np.float64,0xbfef50bf22fea17e,0x40077998a850082c,1 +np.float64,0xbfc52b8c212a5718,0x3ffbca8d6560a2da,1 +np.float64,0x7ff8000000000000,0x7ff8000000000000,1 +np.float64,0x3fc1e3a02d23c740,0x3ff6e3a5fcac12a4,1 +np.float64,0xbfeb5e4ea5f6bc9d,0x4004c65abef9426f,1 +np.float64,0xbfe425b132684b62,0x400203c29608b00d,1 +np.float64,0xbfbfa1c19e3f4380,0x3ffb1d6367711158,1 +np.float64,0x3fbba2776e3744f0,0x3ff766f6df586fad,1 +np.float64,0xbfb5d0951e2ba128,0x3ffa7f712480b25e,1 +np.float64,0xbfe949fdab7293fb,0x4003db4530a18507,1 +np.float64,0xbfcf13519b3e26a4,0x3ffd0e6f0a6c38ee,1 +np.float64,0x3f91e6d72823cdc0,0x3ff8da5f08909b6e,1 +np.float64,0x3f78a2e360314600,0x3ff909586727caef,1 +np.float64,0xbfe1ae7e8fe35cfd,0x40013fef082caaa3,1 +np.float64,0x3fe97a6dd1f2f4dc,0x3fe4cb4b99863478,1 +np.float64,0xbfcc1e1e69383c3c,0x3ffcad250a949843,1 +np.float64,0x3faccb797c399700,0x3ff83b8066b49330,1 +np.float64,0x3fe7a2647a6f44c8,0x3fe7acceae6ec425,1 +np.float64,0xbfec3bfcf0f877fa,0x4005366af5a7175b,1 +np.float64,0xbfe2310b94646217,0x400167588fceb228,1 +np.float64,0x3feb167372762ce6,0x3fe1f74c0288fad8,1 +np.float64,0xbfb722b4ee2e4568,0x3ffa94a81b94dfca,1 +np.float64,0x3fc58da9712b1b50,0x3ff66cf8f072aa14,1 +np.float64,0xbfe7fff9d6effff4,0x400359d01b8141de,1 +np.float64,0xbfd56691c5aacd24,0x3ffe9686697797e8,1 +np.float64,0x3fe3ab0557e7560a,0x3fed1593959ef8e8,1 +np.float64,0x3fdd458995ba8b14,0x3ff1883d6f22a322,1 +np.float64,0x3fe7bbed2cef77da,0x3fe786d618094cda,1 +np.float64,0x3fa31a30c4263460,0x3ff88920b936fd79,1 +np.float64,0x8010000000000000,0x3ff921fb54442d18,1 +np.float64,0xbfdc5effbdb8be00,0x40003d95fe0dff11,1 +np.float64,0x3febfdad7e77fb5a,0x3fe030b5297dbbdd,1 +np.float64,0x3fe4f3f3b2e9e7e8,0x3feb6bc59eeb2be2,1 +np.float64,0xbfe44469fd6888d4,0x40020daa5488f97a,1 +np.float64,0xbfe19fddb0e33fbc,0x40013b8c902b167b,1 +np.float64,0x3fa36ad17c26d5a0,0x3ff8869b3e828134,1 +np.float64,0x3fcf23e6c93e47d0,0x3ff5336491a65d1e,1 +np.float64,0xffefffffffffffff,0x7ff8000000000000,1 +np.float64,0xbfe375f4cee6ebea,0x4001cbd2ba42e8b5,1 +np.float64,0xbfaef1215c3de240,0x3ffa19ab02081189,1 +np.float64,0xbfec39c59c78738b,0x4005353dc38e3d78,1 +np.float64,0x7ff4000000000000,0x7ffc000000000000,1 +np.float64,0xbfec09bb7b781377,0x40051c0a5754cb3a,1 +np.float64,0x3fe8301f2870603e,0x3fe6d783c5ef0944,1 +np.float64,0xbfed418c987a8319,0x4005cbae1b8693d1,1 +np.float64,0xbfdc16e7adb82dd0,0x4000338b634eaf03,1 +np.float64,0x3fd5d361bdaba6c4,0x3ff390899300a54c,1 +np.float64,0xbff0000000000000,0x400921fb54442d18,1 +np.float64,0x3fd5946232ab28c4,0x3ff3a14767813f29,1 +np.float64,0x3fe833e5fef067cc,0x3fe6d1be720edf2d,1 +np.float64,0x3fedf746a67bee8e,0x3fd6f127fdcadb7b,1 +np.float64,0x3fd90353d3b206a8,0x3ff2b54f7d369ba9,1 +np.float64,0x3fec4b4b72f89696,0x3fdf1b38d2e93532,1 +np.float64,0xbfe9c67596f38ceb,0x40040ee5f524ce03,1 +np.float64,0x3fd350d91aa6a1b4,0x3ff43a303c0da27f,1 +np.float64,0x3fd062603ba0c4c0,0x3ff4fd9514b935d8,1 +np.float64,0xbfe24c075f64980e,0x40016f8e9f2663b3,1 +np.float64,0x3fdaa546eeb54a8c,0x3ff2431a88fef1d5,1 +np.float64,0x3fe92b8151f25702,0x3fe54c67e005cbf9,1 +np.float64,0xbfe1be8b8a637d17,0x400144c078f67c6e,1 +np.float64,0xbfe468a1d7e8d144,0x40021964b118cbf4,1 +np.float64,0xbfdc6de4fab8dbca,0x40003fa9e27893d8,1 +np.float64,0xbfe3c2788ae784f1,0x4001e407ba3aa956,1 +np.float64,0xbfe2bf1542e57e2a,0x400192d4a9072016,1 +np.float64,0xbfe6982f4c6d305e,0x4002d681b1991bbb,1 +np.float64,0x3fdbceb1c4b79d64,0x3ff1f0f117b9d354,1 +np.float64,0x3fdb3705e7b66e0c,0x3ff21af01ca27ace,1 +np.float64,0x3fe3e6358ee7cc6c,0x3fecca4585053983,1 +np.float64,0xbfe16d6a9a62dad5,0x40012c7988aee247,1 +np.float64,0xbfce66e4413ccdc8,0x3ffcf83b08043a0c,1 +np.float64,0xbfeb6cd46876d9a9,0x4004cd61733bfb79,1 +np.float64,0xbfdb1cdd64b639ba,0x400010e6cf087cb7,1 +np.float64,0xbfe09e4e30e13c9c,0x4000ef5277c47721,1 +np.float64,0xbfee88dd127d11ba,0x4006b3cd443643ac,1 +np.float64,0xbf911e06c8223c00,0x3ff966744064fb05,1 +np.float64,0xbfe8f22bc471e458,0x4003b7d5513af295,1 +np.float64,0x3fe3d7329567ae66,0x3fecdd6c241f83ee,1 +np.float64,0x3fc8a9404b315280,0x3ff607dc175edf3f,1 +np.float64,0x3fe7eb80ad6fd702,0x3fe73f8fdb3e6a6c,1 +np.float64,0x3fef0931e37e1264,0x3fcf7fde80a3c5ab,1 +np.float64,0x3fe2ed3c3fe5da78,0x3fee038334cd1860,1 +np.float64,0x3fe251fdb8e4a3fc,0x3feec26dc636ac31,1 +np.float64,0x3feb239436764728,0x3fe1de9462455da7,1 +np.float64,0xbfe63fd7eeec7fb0,0x4002b78cfa3d2fa6,1 +np.float64,0x3fdd639cb5bac738,0x3ff17fc7d92b3eee,1 +np.float64,0x3fd0a7a13fa14f44,0x3ff4eba95c559c84,1 +np.float64,0x3fe804362d70086c,0x3fe71a44cd91ffa4,1 +np.float64,0xbfe0fecf6e61fd9f,0x40010bac8edbdc4f,1 +np.float64,0x3fcb74acfd36e958,0x3ff5ac84437f1b7c,1 +np.float64,0x3fe55053e1eaa0a8,0x3feaf0bf76304c30,1 +np.float64,0x3fc06b508d20d6a0,0x3ff7131da17f3902,1 +np.float64,0x3fdd78750fbaf0ec,0x3ff179e97fbf7f65,1 +np.float64,0x3fe44cb946689972,0x3fec46859b5da6be,1 +np.float64,0xbfeb165a7ff62cb5,0x4004a41c9cc9589e,1 +np.float64,0x3fe01ffb2b603ff6,0x3ff0aed52bf1c3c1,1 +np.float64,0x3f983c60a83078c0,0x3ff8c107805715ab,1 +np.float64,0x3fd8b5ff13b16c00,0x3ff2ca4a837a476a,1 +np.float64,0x3fc80510a1300a20,0x3ff61cc3b4af470b,1 +np.float64,0xbfd3935b06a726b6,0x3ffe1b3a2066f473,1 +np.float64,0xbfdd4a1f31ba943e,0x40005e81979ed445,1 +np.float64,0xbfa76afdd42ed600,0x3ff9dd63ffba72d2,1 +np.float64,0x3fe7e06d496fc0da,0x3fe7503773566707,1 +np.float64,0xbfea5fbfe874bf80,0x40045106af6c538f,1 +np.float64,0x3fee000c487c0018,0x3fd6bef1f8779d88,1 +np.float64,0xbfb39f4ee2273ea0,0x3ffa5c3f2b3888ab,1 +np.float64,0x3feb9247b0772490,0x3fe1092d2905efce,1 +np.float64,0x3fdaa39b4cb54738,0x3ff243901da0da17,1 +np.float64,0x3fcd5b2b493ab658,0x3ff56e262e65b67d,1 +np.float64,0x3fcf82512f3f04a0,0x3ff52738847c55f2,1 +np.float64,0x3fe2af5e0c655ebc,0x3fee4ffab0c82348,1 +np.float64,0xbfec0055d0f800ac,0x4005172d325933e8,1 +np.float64,0x3fe71da9336e3b52,0x3fe86f2e12f6e303,1 +np.float64,0x3fbefab0723df560,0x3ff731188ac716ec,1 +np.float64,0xbfe11dca28623b94,0x400114d3d4ad370d,1 +np.float64,0x3fbcbda8ca397b50,0x3ff755281078abd4,1 +np.float64,0x3fe687c7126d0f8e,0x3fe945099a7855cc,1 +np.float64,0xbfecde510579bca2,0x400590606e244591,1 +np.float64,0xbfd72de681ae5bce,0x3fff0ff797ad1755,1 +np.float64,0xbfe7c0f7386f81ee,0x40034226e0805309,1 +np.float64,0x3fd8d55619b1aaac,0x3ff2c1cb3267b14e,1 +np.float64,0x3fecd7a2ad79af46,0x3fdcabbffeaa279e,1 +np.float64,0x3fee7fb1a8fcff64,0x3fd3ae620286fe19,1 +np.float64,0xbfc5f3a3592be748,0x3ffbe3ed204d9842,1 +np.float64,0x3fec9e5527793caa,0x3fddb00bc8687e4b,1 +np.float64,0x3fc35dc70f26bb90,0x3ff6b3ded7191e33,1 +np.float64,0x3fda91c07ab52380,0x3ff24878848fec8f,1 +np.float64,0xbfe12cde1fe259bc,0x4001194ab99d5134,1 +np.float64,0xbfd35ab736a6b56e,0x3ffe0c5ce8356d16,1 +np.float64,0x3fc9c94123339280,0x3ff5e3239f3ad795,1 +np.float64,0xbfe72f54926e5ea9,0x40030c95d1d02b56,1 +np.float64,0xbfee283186fc5063,0x40066786bd0feb79,1 +np.float64,0xbfe7b383f56f6708,0x40033d23ef0e903d,1 +np.float64,0x3fd6037327ac06e8,0x3ff383bf2f311ddb,1 +np.float64,0x3fe0e344b561c68a,0x3ff03cd90fd4ba65,1 +np.float64,0xbfef0ff54b7e1feb,0x400730fa5fce381e,1 +np.float64,0x3fd269929da4d324,0x3ff476b230136d32,1 +np.float64,0xbfbc5fb9f638bf70,0x3ffae8e63a4e3234,1 +np.float64,0xbfe2e8bc84e5d179,0x40019fb5874f4310,1 +np.float64,0xbfd7017413ae02e8,0x3fff040d843c1531,1 +np.float64,0x3fefd362fa7fa6c6,0x3fbababc3ddbb21d,1 +np.float64,0x3fecb62ed3f96c5e,0x3fdd44ba77ccff94,1 +np.float64,0xbfb16fad5222df58,0x3ffa392d7f02b522,1 +np.float64,0x3fbcf4abc639e950,0x3ff751b23c40e27f,1 +np.float64,0x3fe128adbce2515c,0x3ff013dc91db04b5,1 +np.float64,0x3fa5dd9d842bbb40,0x3ff87300c88d512f,1 +np.float64,0xbfe61efcaf6c3dfa,0x4002ac27117f87c9,1 +np.float64,0x3feffe1233fffc24,0x3f9638d3796a4954,1 +np.float64,0xbfe78548b66f0a92,0x40032c0447b7bfe2,1 +np.float64,0x3fe7bd38416f7a70,0x3fe784e86d6546b6,1 +np.float64,0x3fe0d6bc5961ad78,0x3ff0443899e747ac,1 +np.float64,0xbfd0bb6e47a176dc,0x3ffd5d6dff390d41,1 +np.float64,0xbfec1d16b8f83a2e,0x40052620378d3b78,1 +np.float64,0x3fe9bbec20f377d8,0x3fe45e167c7a3871,1 +np.float64,0xbfeed81d9dfdb03b,0x4006f9dec2db7310,1 +np.float64,0xbfe1e35179e3c6a3,0x40014fd1b1186ac0,1 +np.float64,0xbfc9c7e605338fcc,0x3ffc60a6bd1a7126,1 +np.float64,0x3feec92810fd9250,0x3fd1afde414ab338,1 +np.float64,0xbfeb9f1d90773e3b,0x4004e606b773f5b0,1 +np.float64,0x3fcbabdf6b3757c0,0x3ff5a573866404af,1 +np.float64,0x3fe9f4e1fff3e9c4,0x3fe3fd7b6712dd7b,1 +np.float64,0xbfe6c0175ded802e,0x4002e4a4dc12f3fe,1 +np.float64,0xbfeefc96f37df92e,0x40071d367cd721ff,1 +np.float64,0xbfeaab58dc7556b2,0x400472ce37e31e50,1 +np.float64,0xbfc62668772c4cd0,0x3ffbea5e6c92010a,1 +np.float64,0x3fafe055fc3fc0a0,0x3ff822ce6502519a,1 +np.float64,0x3fd7b648ffaf6c90,0x3ff30f5a42f11418,1 +np.float64,0xbfe934fe827269fd,0x4003d2b9fed9e6ad,1 +np.float64,0xbfe6d691f2edad24,0x4002eca6a4b1797b,1 +np.float64,0x3fc7e62ced2fcc58,0x3ff620b1f44398b7,1 +np.float64,0xbfc89be9f33137d4,0x3ffc3a67a497f59c,1 +np.float64,0xbfe7793d536ef27a,0x40032794bf14dd64,1 +np.float64,0x3fde55a02dbcab40,0x3ff13b5f82d223e4,1 +np.float64,0xbfc8eabd7b31d57c,0x3ffc4472a81cb6d0,1 +np.float64,0x3fddcb5468bb96a8,0x3ff162899c381f2e,1 +np.float64,0xbfec7554d8f8eaaa,0x40055550e18ec463,1 +np.float64,0x3fd0b6e8b6a16dd0,0x3ff4e7b4781a50e3,1 +np.float64,0x3fedaae01b7b55c0,0x3fd8964916cdf53d,1 +np.float64,0x3fe0870f8a610e20,0x3ff072e7db95c2a2,1 +np.float64,0xbfec3e3ce2787c7a,0x4005379d0f6be873,1 +np.float64,0xbfe65502586caa04,0x4002beecff89147f,1 +np.float64,0xbfe0df39a961be74,0x4001025e36d1c061,1 +np.float64,0xbfb5d8edbe2bb1d8,0x3ffa7ff72b7d6a2b,1 +np.float64,0xbfde89574bbd12ae,0x40008ba4cd74544d,1 +np.float64,0xbfe72938f0ee5272,0x40030a5efd1acb6d,1 +np.float64,0xbfcd500d133aa01c,0x3ffcd462f9104689,1 +np.float64,0x3fe0350766606a0e,0x3ff0a2a3664e2c14,1 +np.float64,0xbfc892fb573125f8,0x3ffc3944641cc69d,1 +np.float64,0xbfba7dc7c634fb90,0x3ffaca9a6a0ffe61,1 +np.float64,0xbfeac94478759289,0x40048068a8b83e45,1 +np.float64,0xbfe8f60c1af1ec18,0x4003b961995b6e51,1 +np.float64,0x3fea1c0817743810,0x3fe3ba28c1643cf7,1 +np.float64,0xbfe42a0fefe85420,0x4002052aadd77f01,1 +np.float64,0x3fd2c61c56a58c38,0x3ff45e84cb9a7fa9,1 +np.float64,0xbfd83fb7cdb07f70,0x3fff59ab4790074c,1 +np.float64,0x3fd95e630fb2bcc8,0x3ff29c8bee1335ad,1 +np.float64,0x3feee88f387dd11e,0x3fd0c3ad3ded4094,1 +np.float64,0x3fe061291160c252,0x3ff0890010199bbc,1 +np.float64,0xbfdc7db3b5b8fb68,0x400041dea3759443,1 +np.float64,0x3fee23b320fc4766,0x3fd5ee73d7aa5c56,1 +np.float64,0xbfdc25c590b84b8c,0x4000359cf98a00b4,1 +np.float64,0xbfd63cbfd2ac7980,0x3ffecf7b9cf99b3c,1 +np.float64,0xbfbeb3c29a3d6788,0x3ffb0e66ecc0fc3b,1 +np.float64,0xbfd2f57fd6a5eb00,0x3ffdf1d7c79e1532,1 +np.float64,0xbfab3eda9c367db0,0x3ff9fc0c875f42e9,1 +np.float64,0xbfe12df1c6e25be4,0x4001199c673e698c,1 +np.float64,0x3fef8ab23a7f1564,0x3fc5aff358c59f1c,1 +np.float64,0x3fe562f50feac5ea,0x3fead7bce205f7d9,1 +np.float64,0x3fdc41adbeb8835c,0x3ff1d0f71341b8f2,1 +np.float64,0x3fe2748967e4e912,0x3fee9837f970ff9e,1 +np.float64,0xbfdaa89d57b5513a,0x400000e3889ba4cf,1 +np.float64,0x3fdf2a137dbe5428,0x3ff0fecfbecbbf86,1 +np.float64,0xbfea1fdcd2f43fba,0x4004351974b32163,1 +np.float64,0xbfe34a93a3e69528,0x4001be323946a3e0,1 +np.float64,0x3fe929bacff25376,0x3fe54f47bd7f4cf2,1 +np.float64,0xbfd667fbd6accff8,0x3ffedb04032b3a1a,1 +np.float64,0xbfeb695796f6d2af,0x4004cbb08ec6f525,1 +np.float64,0x3fd204df2ea409c0,0x3ff490f51e6670f5,1 +np.float64,0xbfd89a2757b1344e,0x3fff722127b988c4,1 +np.float64,0xbfd0787187a0f0e4,0x3ffd4c16dbe94f32,1 +np.float64,0x3fd44239bfa88474,0x3ff3fabbfb24b1fa,1 +np.float64,0xbfeb0b3489f61669,0x40049ee33d811d33,1 +np.float64,0x3fdcf04eaab9e09c,0x3ff1a02a29996c4e,1 +np.float64,0x3fd4c51e4fa98a3c,0x3ff3d8302c68fc9a,1 +np.float64,0x3fd1346645a268cc,0x3ff4c72b4970ecaf,1 +np.float64,0x3fd6a89d09ad513c,0x3ff357af6520afac,1 +np.float64,0xbfba0f469a341e90,0x3ffac3a8f41bed23,1 +np.float64,0xbfe13f8ddce27f1c,0x40011ed557719fd6,1 +np.float64,0x3fd43e5e26a87cbc,0x3ff3fbc040fc30dc,1 +np.float64,0x3fe838125a707024,0x3fe6cb5c987248f3,1 +np.float64,0x3fe128c30c625186,0x3ff013cff238dd1b,1 +np.float64,0xbfcd4718833a8e30,0x3ffcd33c96bde6f9,1 +np.float64,0x3fe43fcd08e87f9a,0x3fec573997456ec1,1 +np.float64,0xbfe9a29104734522,0x4003ffd502a1b57f,1 +np.float64,0xbfe4709d7968e13b,0x40021bfc5cd55af4,1 +np.float64,0x3fd21c3925a43874,0x3ff48adf48556cbb,1 +np.float64,0x3fe9a521b2734a44,0x3fe4844fc054e839,1 +np.float64,0xbfdfa6a912bf4d52,0x4000b4730ad8521e,1 +np.float64,0x3fe3740702e6e80e,0x3fed5b106283b6ed,1 +np.float64,0x3fd0a3aa36a14754,0x3ff4ecb02a5e3f49,1 +np.float64,0x3fdcb903d0b97208,0x3ff1afa5d692c5b9,1 +np.float64,0xbfe7d67839efacf0,0x40034a3146abf6f2,1 +np.float64,0x3f9981c6d8330380,0x3ff8bbf1853d7b90,1 +np.float64,0xbfe9d4191673a832,0x400414a9ab453c5d,1 +np.float64,0x3fef0a1e5c7e143c,0x3fcf70b02a54c415,1 +np.float64,0xbfd996dee6b32dbe,0x3fffb6cf707ad8e4,1 +np.float64,0x3fe19bef17e337de,0x3fef9e70d4fcedae,1 +np.float64,0x3fe34a59716694b2,0x3fed8f6d5cfba474,1 +np.float64,0x3fdf27e27cbe4fc4,0x3ff0ff70500e0c7c,1 +np.float64,0xbfe19df87fe33bf1,0x40013afb401de24c,1 +np.float64,0xbfbdfd97ba3bfb30,0x3ffb02ef8c225e57,1 +np.float64,0xbfe3d3417267a683,0x4001e95ed240b0f8,1 +np.float64,0x3fe566498b6acc94,0x3fead342957d4910,1 +np.float64,0x3ff0000000000000,0x0,1 +np.float64,0x3feb329bd8766538,0x3fe1c2225aafe3b4,1 +np.float64,0xbfc19ca703233950,0x3ffb575b5df057b9,1 +np.float64,0x3fe755027d6eaa04,0x3fe81eb99c262e00,1 +np.float64,0xbfe6c2b8306d8570,0x4002e594199f9eec,1 +np.float64,0x3fd69438e6ad2870,0x3ff35d2275ae891d,1 +np.float64,0x3fda3e7285b47ce4,0x3ff25f5573dd47ae,1 +np.float64,0x3fe7928a166f2514,0x3fe7c4490ef4b9a9,1 +np.float64,0xbfd4eb71b9a9d6e4,0x3ffe75e8ccb74be1,1 +np.float64,0xbfcc3a07f1387410,0x3ffcb0b8af914a5b,1 +np.float64,0xbfe6e80225edd004,0x4002f2e26eae8999,1 +np.float64,0xbfb347728a268ee8,0x3ffa56bd526a12db,1 +np.float64,0x3fe5140ead6a281e,0x3feb4132c9140a1c,1 +np.float64,0xbfc147f125228fe4,0x3ffb4cab18b9050f,1 +np.float64,0xbfcb9145b537228c,0x3ffc9b1b6227a8c9,1 +np.float64,0xbfda84ef4bb509de,0x3ffff7f8a674e17d,1 +np.float64,0x3fd2eb6bbfa5d6d8,0x3ff454c225529d7e,1 +np.float64,0x3fe18c95f1e3192c,0x3fefb0cf0efba75a,1 +np.float64,0x3fe78606efef0c0e,0x3fe7d6c3a092d64c,1 +np.float64,0x3fbad5119a35aa20,0x3ff773dffe3ce660,1 +np.float64,0x3fd0cf5903a19eb4,0x3ff4e15fd21fdb42,1 +np.float64,0xbfd85ce90bb0b9d2,0x3fff618ee848e974,1 +np.float64,0x3fe90e11b9f21c24,0x3fe57be62f606f4a,1 +np.float64,0x3fd7a2040faf4408,0x3ff314ce85457ec2,1 +np.float64,0xbfd73fba69ae7f74,0x3fff14bff3504811,1 +np.float64,0x3fa04b4bd42096a0,0x3ff89f9b52f521a2,1 +np.float64,0xbfd7219ce5ae433a,0x3fff0cac0b45cc18,1 +np.float64,0xbfe0cf4661e19e8d,0x4000fdadb14e3c22,1 +np.float64,0x3fd07469fea0e8d4,0x3ff4f8eaa9b2394a,1 +np.float64,0x3f9b05c5d8360b80,0x3ff8b5e10672db5c,1 +np.float64,0x3fe4c25b916984b8,0x3febad29bd0e25e2,1 +np.float64,0xbfde8b4891bd1692,0x40008beb88d5c409,1 +np.float64,0xbfe199a7efe33350,0x400139b089aee21c,1 +np.float64,0x3fecdad25cf9b5a4,0x3fdc9d062867e8c3,1 +np.float64,0xbfe979b277f2f365,0x4003eedb061e25a4,1 +np.float64,0x3fc8c7311f318e60,0x3ff6040b9aeaad9d,1 +np.float64,0x3fd2b605b8a56c0c,0x3ff462b9a955c224,1 +np.float64,0x3fc073b6ad20e770,0x3ff7120e9f2fd63c,1 +np.float64,0xbfec60ede678c1dc,0x40054a3863e24dc2,1 +np.float64,0x3fe225171be44a2e,0x3feef910dca420ea,1 +np.float64,0xbfd7529762aea52e,0x3fff19d00661f650,1 +np.float64,0xbfd781783daf02f0,0x3fff2667b90be461,1 +np.float64,0x3fe3f6ec6d67edd8,0x3fecb4e814a2e33a,1 +np.float64,0x3fece6702df9cce0,0x3fdc6719d92a50d2,1 +np.float64,0xbfb5c602ce2b8c08,0x3ffa7ec761ba856a,1 +np.float64,0xbfd61f0153ac3e02,0x3ffec78e3b1a6c4d,1 +np.float64,0xbfec3462b2f868c5,0x400532630bbd7050,1 +np.float64,0xbfdd248485ba490a,0x400059391c07c1bb,1 +np.float64,0xbfd424921fa84924,0x3ffe416a85d1dcdf,1 +np.float64,0x3fbb23a932364750,0x3ff76eef79209f7f,1 +np.float64,0x3fca248b0f344918,0x3ff5d77c5c1b4e5e,1 +np.float64,0xbfe69af4a4ed35ea,0x4002d77c2e4fbd4e,1 +np.float64,0x3fdafe3cdcb5fc78,0x3ff22a9be6efbbf2,1 +np.float64,0xbfebba3377f77467,0x4004f3836e1fe71a,1 +np.float64,0xbfe650fae06ca1f6,0x4002bd851406377c,1 +np.float64,0x3fda630007b4c600,0x3ff2554f1832bd94,1 +np.float64,0xbfda8107d9b50210,0x3ffff6e6209659f3,1 +np.float64,0x3fea759a02f4eb34,0x3fe31d1a632c9aae,1 +np.float64,0x3fbf88149e3f1030,0x3ff728313aa12ccb,1 +np.float64,0x3f7196d2a0232e00,0x3ff910647e1914c1,1 +np.float64,0x3feeae51d17d5ca4,0x3fd2709698d31f6f,1 +np.float64,0xbfd73cd663ae79ac,0x3fff13f96300b55a,1 +np.float64,0x3fd4fc5f06a9f8c0,0x3ff3c99359854b97,1 +np.float64,0x3fb29f5d6e253ec0,0x3ff7f7c20e396b20,1 +np.float64,0xbfd757c82aaeaf90,0x3fff1b34c6141e98,1 +np.float64,0x3fc56fd4cf2adfa8,0x3ff670c145122909,1 +np.float64,0x3fc609a2f52c1348,0x3ff65d3ef3cade2c,1 +np.float64,0xbfe1de631163bcc6,0x40014e5528fadb73,1 +np.float64,0xbfe7eb4a726fd695,0x40035202f49d95c4,1 +np.float64,0xbfc9223771324470,0x3ffc4b84d5e263b9,1 +np.float64,0x3fee91a8a87d2352,0x3fd3364befde8de6,1 +np.float64,0x3fbc9784fe392f10,0x3ff7578e29f6a1b2,1 +np.float64,0xbfec627c2c78c4f8,0x40054b0ff2cb9c55,1 +np.float64,0xbfb8b406a6316810,0x3ffaadd97062fb8c,1 +np.float64,0xbfecf98384f9f307,0x4005a043d9110d79,1 +np.float64,0xbfe5834bab6b0698,0x400276f114aebee4,1 +np.float64,0xbfd90f391eb21e72,0x3fff91e26a8f48f3,1 +np.float64,0xbfee288ce2fc511a,0x400667cb09aa04b3,1 +np.float64,0x3fd5aa5e32ab54bc,0x3ff39b7080a52214,1 +np.float64,0xbfee7ef907fcfdf2,0x4006ab96a8eba4c5,1 +np.float64,0x3fd6097973ac12f4,0x3ff3822486978bd1,1 +np.float64,0xbfe02d14b8e05a2a,0x4000ce5be53047b1,1 +np.float64,0xbf9c629a6838c540,0x3ff993897728c3f9,1 +np.float64,0xbfee2024667c4049,0x40066188782fb1f0,1 +np.float64,0xbfa42a88fc285510,0x3ff9c35a4bbce104,1 +np.float64,0x3fa407af5c280f60,0x3ff881b360d8eea1,1 +np.float64,0x3fed0ba42cfa1748,0x3fdbb7d55609175f,1 +np.float64,0xbfdd0b5844ba16b0,0x400055b0bb59ebb2,1 +np.float64,0x3fd88d97e6b11b30,0x3ff2d53c1ecb8f8c,1 +np.float64,0xbfeb7a915ef6f523,0x4004d410812eb84c,1 +np.float64,0xbfb5f979ca2bf2f0,0x3ffa8201d73cd4ca,1 +np.float64,0x3fb3b65dd6276cc0,0x3ff7e64576199505,1 +np.float64,0x3fcd47a7793a8f50,0x3ff570a7b672f160,1 +np.float64,0xbfa41dd30c283ba0,0x3ff9c2f488127eb3,1 +np.float64,0x3fe4b1ea1f6963d4,0x3febc2bed7760427,1 +np.float64,0xbfdd0f81d2ba1f04,0x400056463724b768,1 +np.float64,0x3fd15d93f7a2bb28,0x3ff4bc7a24eacfd7,1 +np.float64,0xbfe3213af8e64276,0x4001b14579dfded3,1 +np.float64,0x3fd90dfbeab21bf8,0x3ff2b26a6c2c3bb3,1 +np.float64,0xbfd02d54bca05aaa,0x3ffd38ab3886b203,1 +np.float64,0x3fc218dcad2431b8,0x3ff6dced56d5b417,1 +np.float64,0x3fea5edf71f4bdbe,0x3fe3455ee09f27e6,1 +np.float64,0x3fa74319042e8640,0x3ff867d224545438,1 +np.float64,0x3fd970ad92b2e15c,0x3ff2979084815dc1,1 +np.float64,0x3fce0a4bf73c1498,0x3ff557a4df32df3e,1 +np.float64,0x3fef5c8e10feb91c,0x3fc99ca0eeaaebe4,1 +np.float64,0xbfedae997ffb5d33,0x400611af18f407ab,1 +np.float64,0xbfbcf07d6239e0f8,0x3ffaf201177a2d36,1 +np.float64,0xbfc3c52541278a4c,0x3ffb9d2af0408e4a,1 +np.float64,0x3fe4ef44e4e9de8a,0x3feb71f7331255e5,1 +np.float64,0xbfccd9f5f539b3ec,0x3ffcc53a99339592,1 +np.float64,0xbfda32c745b4658e,0x3fffe16e8727ef89,1 +np.float64,0xbfef54932a7ea926,0x40077e4605e61ca1,1 +np.float64,0x3fe9d4ae3573a95c,0x3fe4344a069a3fd0,1 +np.float64,0x3fda567e73b4acfc,0x3ff258bd77a663c7,1 +np.float64,0xbfd5bcac5eab7958,0x3ffead6379c19c52,1 +np.float64,0xbfee5e56f97cbcae,0x40069131fc54018d,1 +np.float64,0x3fc2d4413925a880,0x3ff6c54163816298,1 +np.float64,0xbfe9ddf6e873bbee,0x400418d8c722f7c5,1 +np.float64,0x3fdaf2a683b5e54c,0x3ff22dcda599d69c,1 +np.float64,0xbfca69789f34d2f0,0x3ffc7547ff10b1a6,1 +np.float64,0x3fed076f62fa0ede,0x3fdbcbda03c1d72a,1 +np.float64,0xbfcb38326f367064,0x3ffc8fb55dadeae5,1 +np.float64,0x3fe1938705e3270e,0x3fefa88130c5adda,1 +np.float64,0x3feaffae3b75ff5c,0x3fe221e3da537c7e,1 +np.float64,0x3fefc94acb7f9296,0x3fbd9a360ace67b4,1 +np.float64,0xbfe8bddeb0f17bbe,0x4003a316685c767e,1 +np.float64,0x3fbe10fbee3c21f0,0x3ff73fceb10650f5,1 +np.float64,0x3fde9126c1bd224c,0x3ff12a742f734d0a,1 +np.float64,0xbfe9686c91f2d0d9,0x4003e7bc6ee77906,1 +np.float64,0xbfb1ba4892237490,0x3ffa3dda064c2509,1 +np.float64,0xbfe2879100e50f22,0x400181c1a5b16f0f,1 +np.float64,0x3fd1cd40b6a39a80,0x3ff49f70e3064e95,1 +np.float64,0xbfc965869132cb0c,0x3ffc5419f3b43701,1 +np.float64,0x3fea7a6f2874f4de,0x3fe31480fb2dd862,1 +np.float64,0x3fc3bc56892778b0,0x3ff6a7e8fa0e8b0e,1 +np.float64,0x3fec1ed451f83da8,0x3fdfd78e564b8ad7,1 +np.float64,0x3feb77d16df6efa2,0x3fe13d083344e45e,1 +np.float64,0xbfe822e7c67045d0,0x400367104a830cf6,1 +np.float64,0x8000000000000001,0x3ff921fb54442d18,1 +np.float64,0xbfd4900918a92012,0x3ffe5dc0e19737b4,1 +np.float64,0x3fed184187fa3084,0x3fdb7b7a39f234f4,1 +np.float64,0x3fecef846179df08,0x3fdc3cb2228c3682,1 +np.float64,0xbfe2d2aed165a55e,0x400198e21c5b861b,1 +np.float64,0x7ff0000000000000,0x7ff8000000000000,1 +np.float64,0xbfee9409a07d2813,0x4006bd358232d073,1 +np.float64,0xbfecedc2baf9db86,0x4005995df566fc21,1 +np.float64,0x3fe6d857396db0ae,0x3fe8d2cb8794aa99,1 +np.float64,0xbf9a579e7834af40,0x3ff98b5cc8021e1c,1 +np.float64,0x3fc664fefb2cca00,0x3ff651a664ccf8fa,1 +np.float64,0xbfe8a7aa0e714f54,0x40039a5b4df938a0,1 +np.float64,0xbfdf27d380be4fa8,0x4000a241074dbae6,1 +np.float64,0x3fe00ddf55e01bbe,0x3ff0b94eb1ea1851,1 +np.float64,0x3feb47edbff68fdc,0x3fe199822d075959,1 +np.float64,0x3fb4993822293270,0x3ff7d80c838186d0,1 +np.float64,0xbfca2cd1473459a4,0x3ffc6d88c8de3d0d,1 +np.float64,0xbfea7d9c7674fb39,0x40045e4559e9e52d,1 +np.float64,0x3fe0dce425e1b9c8,0x3ff04099cab23289,1 +np.float64,0x3fd6bb7e97ad76fc,0x3ff352a30434499c,1 +np.float64,0x3fd4a4f16da949e4,0x3ff3e0b07432c9aa,1 +np.float64,0x8000000000000000,0x3ff921fb54442d18,1 +np.float64,0x3fe688f5b56d11ec,0x3fe9435f63264375,1 +np.float64,0xbfdf5a427ebeb484,0x4000a97a6c5d4abc,1 +np.float64,0xbfd1f3483fa3e690,0x3ffdae6c8a299383,1 +np.float64,0xbfeac920db759242,0x4004805862be51ec,1 +np.float64,0x3fef5bc711feb78e,0x3fc9ac40fba5b93b,1 +np.float64,0x3fe4bd9e12e97b3c,0x3febb363c787d381,1 +np.float64,0x3fef6a59ab7ed4b4,0x3fc880f1324eafce,1 +np.float64,0x3fc07a362120f470,0x3ff7113cf2c672b3,1 +np.float64,0xbfe4d6dbe2e9adb8,0x40023d6f6bea44b7,1 +np.float64,0xbfec2d6a15785ad4,0x40052eb425cc37a2,1 +np.float64,0x3fc90dae05321b60,0x3ff5fb10015d2934,1 +np.float64,0xbfa9239f74324740,0x3ff9eb2d057068ea,1 +np.float64,0xbfeb4fc8baf69f92,0x4004bf5e17fb08a4,1 +np.float64,0x0,0x3ff921fb54442d18,1 +np.float64,0x3faaf1884c35e320,0x3ff84a5591dbe1f3,1 +np.float64,0xbfed842561fb084b,0x4005f5c0a19116ce,1 +np.float64,0xbfc64850c32c90a0,0x3ffbeeac2ee70f9a,1 +np.float64,0x3fd7d879f5afb0f4,0x3ff306254c453436,1 +np.float64,0xbfdabaa586b5754c,0x4000035e6ac83a2b,1 +np.float64,0xbfebfeefa977fddf,0x4005167446fb9faf,1 +np.float64,0xbfe9383462727069,0x4003d407aa6a1577,1 +np.float64,0x3fe108dfb6e211c0,0x3ff026ac924b281d,1 +np.float64,0xbf85096df02a12c0,0x3ff94c0e60a22ede,1 +np.float64,0xbfe3121cd566243a,0x4001ac8f90db5882,1 +np.float64,0xbfd227f62aa44fec,0x3ffdbc26bb175dcc,1 +np.float64,0x3fd931af2cb26360,0x3ff2a8b62dfe003c,1 +np.float64,0xbfd9b794e3b36f2a,0x3fffbfbc89ec013d,1 +np.float64,0x3fc89b2e6f313660,0x3ff609a6e67f15f2,1 +np.float64,0x3fc0b14a8f216298,0x3ff70a4b6905aad2,1 +np.float64,0xbfeda11a657b4235,0x400608b3f9fff574,1 +np.float64,0xbfed2ee9ec7a5dd4,0x4005c040b7c02390,1 +np.float64,0xbfef7819d8fef034,0x4007ac6bf75cf09d,1 +np.float64,0xbfcc4720fb388e40,0x3ffcb2666a00b336,1 +np.float64,0xbfe05dec4be0bbd8,0x4000dc8a25ca3760,1 +np.float64,0x3fb093416e212680,0x3ff81897b6d8b374,1 +np.float64,0xbfc6ab89332d5714,0x3ffbfb4559d143e7,1 +np.float64,0x3fc51948512a3290,0x3ff67bb9df662c0a,1 +np.float64,0x3fed4d94177a9b28,0x3fda76c92f0c0132,1 +np.float64,0x3fdd195fbeba32c0,0x3ff194a5586dd18e,1 +np.float64,0x3fe3f82799e7f050,0x3fecb354c2faf55c,1 +np.float64,0x3fecac2169f95842,0x3fdd7222296cb7a7,1 +np.float64,0x3fe3d3f36fe7a7e6,0x3fece18f45e30dd7,1 +np.float64,0x3fe31ff63d663fec,0x3fedc46c77d30c6a,1 +np.float64,0xbfe3120c83e62419,0x4001ac8a7c4aa742,1 +np.float64,0x3fe7c1a7976f8350,0x3fe77e4a9307c9f8,1 +np.float64,0x3fe226fe9de44dfe,0x3feef6c0f3cb00fa,1 +np.float64,0x3fd5c933baab9268,0x3ff3933e8a37de42,1 +np.float64,0x3feaa98496f5530a,0x3fe2c003832ebf21,1 +np.float64,0xbfc6f80a2f2df014,0x3ffc04fd54cb1317,1 +np.float64,0x3fde5e18d0bcbc30,0x3ff138f7b32a2ca3,1 +np.float64,0xbfe30c8dd566191c,0x4001aad4af935a78,1 +np.float64,0x3fbe8d196e3d1a30,0x3ff737fec8149ecc,1 +np.float64,0x3feaee6731f5dcce,0x3fe241fa42cce22d,1 +np.float64,0x3fef9cc46cff3988,0x3fc3f17b708dbdbb,1 +np.float64,0xbfdb181bdeb63038,0x4000103ecf405602,1 +np.float64,0xbfc58de0ed2b1bc0,0x3ffbd704c14e15cd,1 +np.float64,0xbfee05d5507c0bab,0x40064e480faba6d8,1 +np.float64,0x3fe27d0ffa64fa20,0x3fee8dc71ef79f2c,1 +np.float64,0xbfe4f7ad4c69ef5a,0x400248456cd09a07,1 +np.float64,0xbfe4843e91e9087d,0x4002225f3e139c84,1 +np.float64,0x3fe7158b9c6e2b18,0x3fe87ae845c5ba96,1 +np.float64,0xbfea64316074c863,0x400452fd2bc23a44,1 +np.float64,0xbfc9f3ae4133e75c,0x3ffc663d482afa42,1 +np.float64,0xbfd5e18513abc30a,0x3ffeb72fc76d7071,1 +np.float64,0xbfd52f6438aa5ec8,0x3ffe87e5b18041e5,1 +np.float64,0xbfea970650f52e0d,0x400469a4a6758154,1 +np.float64,0xbfe44321b7e88644,0x40020d404a2141b1,1 +np.float64,0x3fdf5a39bbbeb474,0x3ff0f10453059dbd,1 +np.float64,0xbfa1d4069423a810,0x3ff9b0a2eacd2ce2,1 +np.float64,0xbfc36d16a326da2c,0x3ffb92077d41d26a,1 +np.float64,0x1,0x3ff921fb54442d18,1 +np.float64,0x3feb232a79764654,0x3fe1df5beeb249d0,1 +np.float64,0xbfed2003d5fa4008,0x4005b737c2727583,1 +np.float64,0x3fd5b093a3ab6128,0x3ff399ca2db1d96d,1 +np.float64,0x3fca692c3d34d258,0x3ff5ceb86b79223e,1 +np.float64,0x3fd6bbdf89ad77c0,0x3ff3528916df652d,1 +np.float64,0xbfefdadd46ffb5bb,0x40085ee735e19f19,1 +np.float64,0x3feb69fb2676d3f6,0x3fe157ee0c15691e,1 +np.float64,0x3fe44c931f689926,0x3fec46b6f5e3f265,1 +np.float64,0xbfc43ddbcb287bb8,0x3ffbac71d268d74d,1 +np.float64,0x3fe6e16d43edc2da,0x3fe8c5cf0f0daa66,1 +np.float64,0x3fe489efc76913e0,0x3febf704ca1ac2a6,1 +np.float64,0xbfe590aadceb2156,0x40027b764205cf78,1 +np.float64,0xbf782e8aa0305d00,0x3ff93a29e81928ab,1 +np.float64,0x3fedcb80cffb9702,0x3fd7e5d1f98a418b,1 +np.float64,0x3fe075858060eb0c,0x3ff07d23ab46b60f,1 +np.float64,0x3fe62a68296c54d0,0x3fe9c77f7068043b,1 +np.float64,0x3feff16a3c7fe2d4,0x3fae8e8a739cc67a,1 +np.float64,0xbfd6ed93e3addb28,0x3ffefebab206fa99,1 +np.float64,0x3fe40d8ccf681b1a,0x3fec97e9cd29966d,1 +np.float64,0x3fd6408210ac8104,0x3ff3737a7d374107,1 +np.float64,0x3fec8023b8f90048,0x3fde35ebfb2b3afd,1 +np.float64,0xbfe13babd4627758,0x40011dae5c07c56b,1 +np.float64,0xbfd2183e61a4307c,0x3ffdb80dd747cfbe,1 +np.float64,0x3feae8eb1d75d1d6,0x3fe24c1f6e42ae77,1 +np.float64,0xbfea559b9c74ab37,0x40044c8e5e123b20,1 +np.float64,0xbfd12c9d57a2593a,0x3ffd7ac6222f561c,1 +np.float64,0x3fe32eb697e65d6e,0x3fedb202693875b6,1 +np.float64,0xbfde0808c3bc1012,0x4000794bd8616ea3,1 +np.float64,0x3fe14958a06292b2,0x3ff0007b40ac648a,1 +np.float64,0x3fe3d388a6e7a712,0x3fece21751a6dd7c,1 +np.float64,0x3fe7ad7897ef5af2,0x3fe79c5b3da302a7,1 +np.float64,0x3fec75527e78eaa4,0x3fde655de0cf0508,1 +np.float64,0x3fea920d4c75241a,0x3fe2ea48f031d908,1 +np.float64,0x7fefffffffffffff,0x7ff8000000000000,1 +np.float64,0xbfc17a68cb22f4d0,0x3ffb530925f41aa0,1 +np.float64,0xbfe1c93166e39263,0x400147f3cb435dec,1 +np.float64,0x3feb97c402f72f88,0x3fe0fe5b561bf869,1 +np.float64,0x3fb58ff5162b1ff0,0x3ff7c8933fa969dc,1 +np.float64,0x3fe68e2beded1c58,0x3fe93c075283703b,1 +np.float64,0xbf94564cc828aca0,0x3ff97355e5ee35db,1 +np.float64,0x3fd31061c9a620c4,0x3ff44b150ec96998,1 +np.float64,0xbfc7d0c89f2fa190,0x3ffc208bf4eddc4d,1 +np.float64,0x3fe5736f1d6ae6de,0x3feac18f84992d1e,1 +np.float64,0x3fdb62e480b6c5c8,0x3ff20ecfdc4afe7c,1 +np.float64,0xbfc417228b282e44,0x3ffba78afea35979,1 +np.float64,0x3f8f5ba1303eb780,0x3ff8e343714630ff,1 +np.float64,0x3fe8e99126f1d322,0x3fe5b6511d4c0798,1 +np.float64,0xbfe2ec08a1e5d812,0x4001a0bb28a85875,1 +np.float64,0x3fea3b46cf74768e,0x3fe383dceaa74296,1 +np.float64,0xbfe008b5ed60116c,0x4000c3d62c275d40,1 +np.float64,0xbfcd9f8a4b3b3f14,0x3ffcde98d6484202,1 +np.float64,0xbfdb5fb112b6bf62,0x40001a22137ef1c9,1 +np.float64,0xbfe9079565f20f2b,0x4003c0670c92e401,1 +np.float64,0xbfce250dc53c4a1c,0x3ffcefc2b3dc3332,1 +np.float64,0x3fe9ba85d373750c,0x3fe4607131b28773,1 +np.float64,0x10000000000000,0x3ff921fb54442d18,1 +np.float64,0xbfeb9ef42c773de8,0x4004e5f239203ad8,1 +np.float64,0xbfd6bf457dad7e8a,0x3ffef2563d87b18d,1 +np.float64,0x3fe4de9aa5e9bd36,0x3feb87f97defb04a,1 +np.float64,0x3fedb4f67cfb69ec,0x3fd8603c465bffac,1 +np.float64,0x3fe7b6d9506f6db2,0x3fe78e670c7bdb67,1 +np.float64,0x3fe071717460e2e2,0x3ff07f84472d9cc5,1 +np.float64,0xbfed2e79dbfa5cf4,0x4005bffc6f9ad24f,1 +np.float64,0x3febb8adc377715c,0x3fe0bcebfbd45900,1 +np.float64,0xbfee2cffd87c5a00,0x40066b20a037c478,1 +np.float64,0x3fef7e358d7efc6c,0x3fc6d0ba71a542a8,1 +np.float64,0xbfef027eef7e04fe,0x400723291cb00a7a,1 +np.float64,0x3fac96da34392dc0,0x3ff83d260a936c6a,1 +np.float64,0x3fe9dba94a73b752,0x3fe428736b94885e,1 +np.float64,0x3fed37581efa6eb0,0x3fdae49dcadf1d90,1 +np.float64,0xbfe6e61037edcc20,0x4002f23031b8d522,1 +np.float64,0xbfdea7204dbd4e40,0x40008fe1f37918b7,1 +np.float64,0x3feb9f8edb773f1e,0x3fe0eef20bd4387b,1 +np.float64,0x3feeb0b6ed7d616e,0x3fd25fb3b7a525d6,1 +np.float64,0xbfd7ce9061af9d20,0x3fff3b25d531aa2b,1 +np.float64,0xbfc806b509300d6c,0x3ffc2768743a8360,1 +np.float64,0xbfa283882c250710,0x3ff9b61fda28914a,1 +np.float64,0x3fdec70050bd8e00,0x3ff11b1d769b578f,1 +np.float64,0xbfc858a44930b148,0x3ffc31d6758b4721,1 +np.float64,0x3fdc321150b86424,0x3ff1d5504c3c91e4,1 +np.float64,0x3fd9416870b282d0,0x3ff2a46f3a850f5b,1 +np.float64,0x3fdd756968baead4,0x3ff17ac510a5573f,1 +np.float64,0xbfedfd632cfbfac6,0x400648345a2f89b0,1 +np.float64,0x3fd6874285ad0e84,0x3ff36098ebff763f,1 +np.float64,0x3fe6daacc9edb55a,0x3fe8cf75fae1e35f,1 +np.float64,0x3fe53f19766a7e32,0x3feb07d0e97cd55b,1 +np.float64,0x3fd13cc36ca27988,0x3ff4c4ff801b1faa,1 +np.float64,0x3fe4f21cbce9e43a,0x3feb6e34a72ef529,1 +np.float64,0xbfc21c1cc9243838,0x3ffb67726394ca89,1 +np.float64,0x3fe947a3f2728f48,0x3fe51eae4660e23c,1 +np.float64,0xbfce78cd653cf19c,0x3ffcfa89194b3f5e,1 +np.float64,0x3fe756f049eeade0,0x3fe81be7f2d399e2,1 +np.float64,0xbfcc727cf138e4f8,0x3ffcb7f547841bb0,1 +np.float64,0xbfc2d8d58f25b1ac,0x3ffb7f496cc72458,1 +np.float64,0xbfcfd0e4653fa1c8,0x3ffd26e1309bc80b,1 +np.float64,0xbfe2126c106424d8,0x40015e0e01db6a4a,1 +np.float64,0x3fe580e4306b01c8,0x3feaaf683ce51aa5,1 +np.float64,0x3fcea8a1b93d5140,0x3ff543456c0d28c7,1 +np.float64,0xfff0000000000000,0x7ff8000000000000,1 +np.float64,0xbfd9d5da72b3abb4,0x3fffc8013113f968,1 +np.float64,0xbfe1fdfcea63fbfa,0x400157def2e4808d,1 +np.float64,0xbfc0022e0720045c,0x3ffb239963e7cbf2,1 diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/data/umath-validation-set-arccosh.csv b/venv/lib/python3.12/site-packages/numpy/_core/tests/data/umath-validation-set-arccosh.csv new file mode 100644 index 00000000..1b3eda48 --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/tests/data/umath-validation-set-arccosh.csv @@ -0,0 +1,1429 @@ +dtype,input,output,ulperrortol +np.float32,0x3f83203f,0x3e61d9d6,2 +np.float32,0x3f98dea1,0x3f1d1af6,2 +np.float32,0x7fa00000,0x7fe00000,2 +np.float32,0x7eba99af,0x42b0d032,2 +np.float32,0x3fc95a13,0x3f833650,2 +np.float32,0x3fce9a45,0x3f8771e1,2 +np.float32,0x3fc1bd96,0x3f797811,2 +np.float32,0x7eba2391,0x42b0ceed,2 +np.float32,0x7d4e8f15,0x42acdb8c,2 +np.float32,0x3feca42e,0x3f9cc88e,2 +np.float32,0x7e2b314e,0x42af412e,2 +np.float32,0x7f7fffff,0x42b2d4fc,2 +np.float32,0x3f803687,0x3d6c4380,2 +np.float32,0x3fa0edbd,0x3f33e706,2 +np.float32,0x3faa8074,0x3f4b3d3c,2 +np.float32,0x3fa0c49e,0x3f337af3,2 +np.float32,0x3f8c9ec4,0x3ee18812,2 +np.float32,0x7efef78e,0x42b17006,2 +np.float32,0x3fc75720,0x3f818aa4,2 +np.float32,0x7f52d4c8,0x42b27198,2 +np.float32,0x3f88f21e,0x3ebe52b0,2 +np.float32,0x3ff7a042,0x3fa3a07a,2 +np.float32,0x7f52115c,0x42b26fbd,2 +np.float32,0x3fc6bf6f,0x3f810b42,2 +np.float32,0x3fd105d0,0x3f895649,2 +np.float32,0x3fee7c2a,0x3f9df66e,2 +np.float32,0x7f0ff9a5,0x42b1ae4f,2 +np.float32,0x7e81f075,0x42b016e7,2 +np.float32,0x3fa57d65,0x3f3f70c6,2 +np.float32,0x80800000,0xffc00000,2 +np.float32,0x7da239f5,0x42adc2bf,2 +np.float32,0x3f9e432c,0x3f2cbd80,2 +np.float32,0x3ff2839b,0x3fa07ee4,2 +np.float32,0x3fec8aef,0x3f9cb850,2 +np.float32,0x7d325893,0x42ac905b,2 +np.float32,0x3fa27431,0x3f37dade,2 +np.float32,0x3fce7408,0x3f8753ae,2 +np.float32,0x3fde6684,0x3f93353f,2 +np.float32,0x3feb9a3e,0x3f9c1cff,2 +np.float32,0x7deb34bb,0x42ae80f0,2 +np.float32,0x3fed9300,0x3f9d61b7,2 +np.float32,0x7f35e253,0x42b225fb,2 +np.float32,0x7e6db57f,0x42afe93f,2 +np.float32,0x3fa41f08,0x3f3c10bc,2 +np.float32,0x3fb0d4da,0x3f590de3,2 +np.float32,0x3fb5c690,0x3f632351,2 +np.float32,0x3fcde9ce,0x3f86e638,2 +np.float32,0x3f809c7b,0x3dc81161,2 +np.float32,0x3fd77291,0x3f8e3226,2 +np.float32,0x3fc21a06,0x3f7a1a82,2 +np.float32,0x3fba177e,0x3f6b8139,2 +np.float32,0x7f370dff,0x42b22944,2 +np.float32,0x3fe5bfcc,0x3f9841c1,2 +np.float32,0x3feb0caa,0x3f9bc139,2 +np.float32,0x7f4fe5c3,0x42b26a6c,2 +np.float32,0x7f1e1419,0x42b1de28,2 +np.float32,0x7f5e3c96,0x42b28c92,2 +np.float32,0x3f8cd313,0x3ee3521e,2 +np.float32,0x3fa97824,0x3f48e049,2 +np.float32,0x7d8ca281,0x42ad799e,2 +np.float32,0x3f96b51b,0x3f165193,2 +np.float32,0x3f81328a,0x3e0bf504,2 +np.float32,0x3ff60bf3,0x3fa2ab45,2 +np.float32,0x3ff9b629,0x3fa4e107,2 +np.float32,0x3fecacfc,0x3f9cce37,2 +np.float32,0x3fba8804,0x3f6c5600,2 +np.float32,0x3f81f752,0x3e333fdd,2 +np.float32,0x3fb5b262,0x3f62fb46,2 +np.float32,0x3fa21bc0,0x3f36f7e6,2 +np.float32,0x3fbc87bb,0x3f7011dc,2 +np.float32,0x3fe18b32,0x3f9565ae,2 +np.float32,0x7dfb6dd5,0x42aea316,2 +np.float32,0x3fb7c602,0x3f670ee3,2 +np.float32,0x7efeb6a2,0x42b16f84,2 +np.float32,0x3fa56180,0x3f3f2ca4,2 +np.float32,0x3f8dcaff,0x3eeb9ac0,2 +np.float32,0x7e876238,0x42b02beb,2 +np.float32,0x7f0bb67d,0x42b19eec,2 +np.float32,0x3faca01c,0x3f4fffa5,2 +np.float32,0x3fdb57ee,0x3f9108b8,2 +np.float32,0x3fe3bade,0x3f96e4b7,2 +np.float32,0x7f7aa2dd,0x42b2ca25,2 +np.float32,0x3fed92ec,0x3f9d61aa,2 +np.float32,0x7eb789b1,0x42b0c7b9,2 +np.float32,0x7f7f16e4,0x42b2d329,2 +np.float32,0x3fb6647e,0x3f645b84,2 +np.float32,0x3f99335e,0x3f1e1d96,2 +np.float32,0x7e690a11,0x42afdf17,2 +np.float32,0x7dff2f95,0x42aeaaae,2 +np.float32,0x7f70adfd,0x42b2b564,2 +np.float32,0x3fe92252,0x3f9a80fe,2 +np.float32,0x3fef54ce,0x3f9e7fe5,2 +np.float32,0x3ff24eaa,0x3fa05df9,2 +np.float32,0x7f04565a,0x42b18328,2 +np.float32,0x3fcb8b80,0x3f85007f,2 +np.float32,0x3fcd4d0a,0x3f866983,2 +np.float32,0x3fbe7d82,0x3f73a911,2 +np.float32,0x3f8a7a8a,0x3ecdc8f6,2 +np.float32,0x3f912441,0x3f030d56,2 +np.float32,0x3f9b29d6,0x3f23f663,2 +np.float32,0x3fab7f36,0x3f4d7c6c,2 +np.float32,0x7dfedafc,0x42aeaa04,2 +np.float32,0x3fe190c0,0x3f956982,2 +np.float32,0x3f927515,0x3f07e0bb,2 +np.float32,0x3ff6442a,0x3fa2cd7e,2 +np.float32,0x7f6656d0,0x42b29ee8,2 +np.float32,0x3fe29aa0,0x3f96201f,2 +np.float32,0x3fa4a247,0x3f3d5687,2 +np.float32,0x3fa1cf19,0x3f363226,2 +np.float32,0x3fc20037,0x3f79ed36,2 +np.float32,0x7cc1241a,0x42ab5645,2 +np.float32,0x3fafd540,0x3f56f25a,2 +np.float32,0x7e5b3f5f,0x42afbfdb,2 +np.float32,0x7f48de5f,0x42b258d0,2 +np.float32,0x3fce1ca0,0x3f870e85,2 +np.float32,0x7ee40bb2,0x42b136e4,2 +np.float32,0x7ecdb133,0x42b10212,2 +np.float32,0x3f9f181c,0x3f2f02ca,2 +np.float32,0x3f936cbf,0x3f0b4f63,2 +np.float32,0x3fa4f8ea,0x3f3e2c2f,2 +np.float32,0x3fcc03e2,0x3f8561ac,2 +np.float32,0x3fb801f2,0x3f67831b,2 +np.float32,0x7e141dad,0x42aef70c,2 +np.float32,0x3fe8c04e,0x3f9a4087,2 +np.float32,0x3f8548d5,0x3e929f37,2 +np.float32,0x7f148d7d,0x42b1be56,2 +np.float32,0x3fd2c9a2,0x3f8ab1ed,2 +np.float32,0x7eb374fd,0x42b0bc36,2 +np.float32,0x7f296d36,0x42b201a7,2 +np.float32,0x3ff138e2,0x3f9fb09d,2 +np.float32,0x3ff42898,0x3fa18347,2 +np.float32,0x7da8c5e1,0x42add700,2 +np.float32,0x7dcf72c4,0x42ae40a4,2 +np.float32,0x7ea571fc,0x42b09296,2 +np.float32,0x3fc0953d,0x3f776ba3,2 +np.float32,0x7f1773dd,0x42b1c83c,2 +np.float32,0x7ef53b68,0x42b15c17,2 +np.float32,0x3f85d69f,0x3e9a0f3a,2 +np.float32,0x7e8b9a05,0x42b03ba0,2 +np.float32,0x3ff07d20,0x3f9f3ad2,2 +np.float32,0x7e8da32c,0x42b0430a,2 +np.float32,0x7ef96004,0x42b164ab,2 +np.float32,0x3fdfaa62,0x3f941837,2 +np.float32,0x7f0057c5,0x42b17377,2 +np.float32,0x3fb2663f,0x3f5c5065,2 +np.float32,0x3fd3d8c3,0x3f8b8055,2 +np.float32,0x1,0xffc00000,2 +np.float32,0x3fd536c1,0x3f8c8862,2 +np.float32,0x3f91b953,0x3f053619,2 +np.float32,0x3fb3305c,0x3f5deee1,2 +np.float32,0x7ecd86b9,0x42b101a8,2 +np.float32,0x3fbf71c5,0x3f75624d,2 +np.float32,0x3ff5f0f4,0x3fa29ad2,2 +np.float32,0x3fe50389,0x3f97c328,2 +np.float32,0x3fa325a1,0x3f399e69,2 +np.float32,0x3fe4397a,0x3f973a9f,2 +np.float32,0x3f8684c6,0x3ea2b784,2 +np.float32,0x7f25ae00,0x42b1f634,2 +np.float32,0x3ff7cbf7,0x3fa3badb,2 +np.float32,0x7f73f0e0,0x42b2bc48,2 +np.float32,0x3fc88b70,0x3f828b92,2 +np.float32,0x3fb01c16,0x3f578886,2 +np.float32,0x7e557623,0x42afb229,2 +np.float32,0x3fcbcd5b,0x3f8535b4,2 +np.float32,0x7f7157e4,0x42b2b6cd,2 +np.float32,0x7f51d9d4,0x42b26f36,2 +np.float32,0x7f331a3b,0x42b21e17,2 +np.float32,0x7f777fb5,0x42b2c3b2,2 +np.float32,0x3f832001,0x3e61d11f,2 +np.float32,0x7f2cd055,0x42b20bca,2 +np.float32,0x3f89831f,0x3ec42f76,2 +np.float32,0x7f21da33,0x42b1ea3d,2 +np.float32,0x3f99e416,0x3f20330a,2 +np.float32,0x7f2c8ea1,0x42b20b07,2 +np.float32,0x7f462c98,0x42b251e6,2 +np.float32,0x7f4fdb3f,0x42b26a52,2 +np.float32,0x3fcc1338,0x3f856e07,2 +np.float32,0x3f823673,0x3e3e20da,2 +np.float32,0x7dbfe89d,0x42ae18c6,2 +np.float32,0x3fc9b04c,0x3f837d38,2 +np.float32,0x7dba3213,0x42ae094d,2 +np.float32,0x7ec5a483,0x42b0eda1,2 +np.float32,0x3fbc4d14,0x3f6fa543,2 +np.float32,0x3fc85ce2,0x3f8264f1,2 +np.float32,0x7f77c816,0x42b2c447,2 +np.float32,0x3f9c9281,0x3f280492,2 +np.float32,0x7f49b3e2,0x42b25aef,2 +np.float32,0x3fa7e4da,0x3f45347c,2 +np.float32,0x7e0c9df5,0x42aedc72,2 +np.float32,0x7f21fd1a,0x42b1eaab,2 +np.float32,0x7f7c63ad,0x42b2cdb6,2 +np.float32,0x7f4eb80a,0x42b26783,2 +np.float32,0x7e98038c,0x42b0673c,2 +np.float32,0x7e89ba08,0x42b034b4,2 +np.float32,0x3ffc06ba,0x3fa64094,2 +np.float32,0x3fae63f6,0x3f53db36,2 +np.float32,0x3fbc2d30,0x3f6f6a1c,2 +np.float32,0x7de0e5e5,0x42ae69fe,2 +np.float32,0x7e09ed18,0x42aed28d,2 +np.float32,0x3fea78f8,0x3f9b6129,2 +np.float32,0x7dfe0bcc,0x42aea863,2 +np.float32,0x7ee21d03,0x42b13289,2 +np.float32,0x3fcc3aed,0x3f858dfc,2 +np.float32,0x3fe6b3ba,0x3f98e4ea,2 +np.float32,0x3f90f25f,0x3f025225,2 +np.float32,0x7f1bcaf4,0x42b1d6b3,2 +np.float32,0x3f83ac81,0x3e74c20e,2 +np.float32,0x3f98681d,0x3f1bae16,2 +np.float32,0x3fe1f2d9,0x3f95ad08,2 +np.float32,0x3fa279d7,0x3f37e951,2 +np.float32,0x3feb922a,0x3f9c17c4,2 +np.float32,0x7f1c72e8,0x42b1d8da,2 +np.float32,0x3fea156b,0x3f9b2038,2 +np.float32,0x3fed6bda,0x3f9d48aa,2 +np.float32,0x3fa86142,0x3f46589c,2 +np.float32,0x3ff16bc2,0x3f9fd072,2 +np.float32,0x3fbebf65,0x3f74207b,2 +np.float32,0x7e7b78b5,0x42b00610,2 +np.float32,0x3ff51ab8,0x3fa217f0,2 +np.float32,0x3f8361bb,0x3e6adf07,2 +np.float32,0x7edbceed,0x42b1240e,2 +np.float32,0x7f10e2c0,0x42b1b18a,2 +np.float32,0x3fa7bc58,0x3f44d4ef,2 +np.float32,0x3f813bde,0x3e0e1138,2 +np.float32,0x7f30d5b9,0x42b21791,2 +np.float32,0x3fb4f450,0x3f61806a,2 +np.float32,0x7eee02c4,0x42b14cca,2 +np.float32,0x7ec74b62,0x42b0f1e4,2 +np.float32,0x3ff96bca,0x3fa4b498,2 +np.float32,0x7f50e304,0x42b26cda,2 +np.float32,0x7eb14c57,0x42b0b603,2 +np.float32,0x7c3f0733,0x42a9edbf,2 +np.float32,0x7ea57acb,0x42b092b1,2 +np.float32,0x7f2788dc,0x42b1fbe7,2 +np.float32,0x3fa39f14,0x3f3ad09b,2 +np.float32,0x3fc3a7e0,0x3f7ccfa0,2 +np.float32,0x3fe70a73,0x3f991eb0,2 +np.float32,0x7f4831f7,0x42b25718,2 +np.float32,0x3fe947d0,0x3f9a999c,2 +np.float32,0x7ef2b1c7,0x42b156c4,2 +np.float32,0x3fede0ea,0x3f9d937f,2 +np.float32,0x3f9fef8e,0x3f314637,2 +np.float32,0x3fc313c5,0x3f7bcebd,2 +np.float32,0x7ee99337,0x42b14328,2 +np.float32,0x7eb9042e,0x42b0cbd5,2 +np.float32,0x3fc9d3dc,0x3f839a69,2 +np.float32,0x3fb2c018,0x3f5d091d,2 +np.float32,0x3fcc4e8f,0x3f859dc5,2 +np.float32,0x3fa9363b,0x3f484819,2 +np.float32,0x7f72ce2e,0x42b2b9e4,2 +np.float32,0x7e639326,0x42afd2f1,2 +np.float32,0x7f4595d3,0x42b25060,2 +np.float32,0x7f6d0ac4,0x42b2ad97,2 +np.float32,0x7f1bda0d,0x42b1d6e5,2 +np.float32,0x3fd85ffd,0x3f8ee0ed,2 +np.float32,0x3f91d53f,0x3f059c8e,2 +np.float32,0x7d06e103,0x42ac0155,2 +np.float32,0x3fb83126,0x3f67de6e,2 +np.float32,0x7d81ce1f,0x42ad5097,2 +np.float32,0x7f79cb3b,0x42b2c86b,2 +np.float32,0x7f800000,0x7f800000,2 +np.float32,0x3fdbfffd,0x3f918137,2 +np.float32,0x7f4ecb1c,0x42b267b2,2 +np.float32,0x3fc2c122,0x3f7b3ed3,2 +np.float32,0x7f415854,0x42b24544,2 +np.float32,0x7e3d988b,0x42af7575,2 +np.float32,0x3f83ca99,0x3e789fcb,2 +np.float32,0x7f274f70,0x42b1fb38,2 +np.float32,0x7f0d20e6,0x42b1a416,2 +np.float32,0x3fdf3a1d,0x3f93c9c1,2 +np.float32,0x7efaa13e,0x42b1673d,2 +np.float32,0x3fb20b15,0x3f5b9434,2 +np.float32,0x3f86af9f,0x3ea4c664,2 +np.float32,0x3fe4fcb0,0x3f97be8a,2 +np.float32,0x3f920683,0x3f065085,2 +np.float32,0x3fa4b278,0x3f3d7e8b,2 +np.float32,0x3f8077a8,0x3daef77f,2 +np.float32,0x7e865be4,0x42b02807,2 +np.float32,0x3fcea7e2,0x3f877c9f,2 +np.float32,0x7e7e9db1,0x42b00c6d,2 +np.float32,0x3f9819aa,0x3f1aba7e,2 +np.float32,0x7f2b6c4b,0x42b207a7,2 +np.float32,0x7ef85e3e,0x42b16299,2 +np.float32,0x3fbd8290,0x3f71df8b,2 +np.float32,0x3fbbb615,0x3f6e8c8c,2 +np.float32,0x7f1bc7f5,0x42b1d6a9,2 +np.float32,0x3fbb4fea,0x3f6dcdad,2 +np.float32,0x3fb67e09,0x3f648dd1,2 +np.float32,0x3fc83495,0x3f824374,2 +np.float32,0x3fe52980,0x3f97dcbc,2 +np.float32,0x3f87d893,0x3eb25d7c,2 +np.float32,0x3fdb805a,0x3f9125c0,2 +np.float32,0x3fb33f0f,0x3f5e0ce1,2 +np.float32,0x3facc524,0x3f50516b,2 +np.float32,0x3ff40484,0x3fa16d0e,2 +np.float32,0x3ff078bf,0x3f9f3811,2 +np.float32,0x7f736747,0x42b2bb27,2 +np.float32,0x7f55768b,0x42b277f3,2 +np.float32,0x80000001,0xffc00000,2 +np.float32,0x7f6463d1,0x42b29a8e,2 +np.float32,0x3f8f8b59,0x3ef9d792,2 +np.float32,0x3f8a6f4d,0x3ecd5bf4,2 +np.float32,0x3fe958d9,0x3f9aa4ca,2 +np.float32,0x7f1e2ce2,0x42b1de78,2 +np.float32,0x3fb8584a,0x3f682a05,2 +np.float32,0x7dea3dc6,0x42ae7ed5,2 +np.float32,0x7f53a815,0x42b27399,2 +np.float32,0x7e0cf986,0x42aeddbf,2 +np.float32,0x7f3afb71,0x42b23422,2 +np.float32,0x3fd87d6e,0x3f8ef685,2 +np.float32,0x3ffcaa46,0x3fa6a0d7,2 +np.float32,0x7eecd276,0x42b14a3a,2 +np.float32,0x3ffc30b4,0x3fa65951,2 +np.float32,0x7e9c85e2,0x42b07634,2 +np.float32,0x3f95d862,0x3f1383de,2 +np.float32,0x7ef21410,0x42b15577,2 +np.float32,0x3fbfa1b5,0x3f75b86e,2 +np.float32,0x3fd6d90f,0x3f8dc086,2 +np.float32,0x0,0xffc00000,2 +np.float32,0x7e885dcd,0x42b02f9f,2 +np.float32,0x3fb3e057,0x3f5f54bf,2 +np.float32,0x7f40afdd,0x42b24385,2 +np.float32,0x3fb795c2,0x3f66b120,2 +np.float32,0x3fba7c11,0x3f6c3f73,2 +np.float32,0x3ffef620,0x3fa7f828,2 +np.float32,0x7d430508,0x42acbe1e,2 +np.float32,0x3f8d2892,0x3ee6369f,2 +np.float32,0x3fbea139,0x3f73e9d5,2 +np.float32,0x3ffaa928,0x3fa571b9,2 +np.float32,0x7fc00000,0x7fc00000,2 +np.float32,0x7f16f9ce,0x42b1c69f,2 +np.float32,0x3fa8f753,0x3f47b657,2 +np.float32,0x3fd48a63,0x3f8c06ac,2 +np.float32,0x7f13419e,0x42b1b9d9,2 +np.float32,0x3fdf1526,0x3f93afde,2 +np.float32,0x3f903c8b,0x3eff3be8,2 +np.float32,0x7f085323,0x42b1925b,2 +np.float32,0x7cdbe309,0x42ab98ac,2 +np.float32,0x3fba2cfd,0x3f6ba9f1,2 +np.float32,0x7f5a805d,0x42b283e4,2 +np.float32,0x7f6753dd,0x42b2a119,2 +np.float32,0x3fed9f02,0x3f9d6964,2 +np.float32,0x3f96422c,0x3f14ddba,2 +np.float32,0x7f22f2a9,0x42b1edb1,2 +np.float32,0x3fe3fcfd,0x3f97119d,2 +np.float32,0x7e018ad0,0x42aeb271,2 +np.float32,0x7db896f5,0x42ae04de,2 +np.float32,0x7e55c795,0x42afb2ec,2 +np.float32,0x7f58ef8d,0x42b28036,2 +np.float32,0x7f24a16a,0x42b1f2f3,2 +np.float32,0x3fcf714c,0x3f881b09,2 +np.float32,0x3fcdd056,0x3f86d200,2 +np.float32,0x7f02fad0,0x42b17de0,2 +np.float32,0x7eeab877,0x42b145a9,2 +np.float32,0x3fd6029d,0x3f8d20f7,2 +np.float32,0x3fd4f8cd,0x3f8c59d6,2 +np.float32,0x3fb29d4a,0x3f5cc1a5,2 +np.float32,0x3fb11e2d,0x3f59a77a,2 +np.float32,0x7eded576,0x42b12b0e,2 +np.float32,0x7f26c2a5,0x42b1f988,2 +np.float32,0x3fb6165b,0x3f63c151,2 +np.float32,0x7f3bca47,0x42b23657,2 +np.float32,0x7d8c93bf,0x42ad7968,2 +np.float32,0x3f8ede02,0x3ef47176,2 +np.float32,0x3fbef762,0x3f7485b9,2 +np.float32,0x7f1419af,0x42b1bcc6,2 +np.float32,0x7d9e8c79,0x42adb701,2 +np.float32,0x3fa26336,0x3f37af63,2 +np.float32,0x7f5f5590,0x42b28f18,2 +np.float32,0x3fddc93a,0x3f92c651,2 +np.float32,0x3ff0a5fc,0x3f9f547f,2 +np.float32,0x3fb2f6b8,0x3f5d790e,2 +np.float32,0x3ffe59a4,0x3fa79d2c,2 +np.float32,0x7e4df848,0x42af9fde,2 +np.float32,0x3fb0ab3b,0x3f58b678,2 +np.float32,0x7ea54d47,0x42b09225,2 +np.float32,0x3fdd6404,0x3f927eb2,2 +np.float32,0x3f846dc0,0x3e864caa,2 +np.float32,0x7d046aee,0x42abf7e7,2 +np.float32,0x7f7c5a05,0x42b2cda3,2 +np.float32,0x3faf6126,0x3f55fb21,2 +np.float32,0x7f36a910,0x42b22829,2 +np.float32,0x3fdc7b36,0x3f91d938,2 +np.float32,0x3fff443e,0x3fa82577,2 +np.float32,0x7ee7154a,0x42b13daa,2 +np.float32,0x3f944742,0x3f0e435c,2 +np.float32,0x7f5b510a,0x42b285cc,2 +np.float32,0x3f9bc940,0x3f25c4d2,2 +np.float32,0x3fee4782,0x3f9dd4ea,2 +np.float32,0x3fcfc2dd,0x3f885aea,2 +np.float32,0x7eab65cf,0x42b0a4af,2 +np.float32,0x3f9cf908,0x3f292689,2 +np.float32,0x7ed35501,0x42b10feb,2 +np.float32,0x7dabb70a,0x42addfd9,2 +np.float32,0x7f348919,0x42b2222b,2 +np.float32,0x3fb137d4,0x3f59dd17,2 +np.float32,0x7e7b36c9,0x42b0058a,2 +np.float32,0x7e351fa4,0x42af5e0d,2 +np.float32,0x3f973c0c,0x3f18011e,2 +np.float32,0xff800000,0xffc00000,2 +np.float32,0x3f9b0a4b,0x3f239a33,2 +np.float32,0x3f87c4cf,0x3eb17e7e,2 +np.float32,0x7ef67760,0x42b15eaa,2 +np.float32,0x3fc4d2c8,0x3f7ed20f,2 +np.float32,0x7e940dac,0x42b059b8,2 +np.float32,0x7f6e6a52,0x42b2b08d,2 +np.float32,0x3f838752,0x3e6fe4b2,2 +np.float32,0x3fd8f046,0x3f8f4a94,2 +np.float32,0x3fa82112,0x3f45c223,2 +np.float32,0x3fd49b16,0x3f8c1345,2 +np.float32,0x7f02a941,0x42b17ca1,2 +np.float32,0x3f8a9d2c,0x3ecf1768,2 +np.float32,0x7c9372e3,0x42aacc0f,2 +np.float32,0x3fd260b3,0x3f8a619a,2 +np.float32,0x3f8a1b88,0x3eca27cb,2 +np.float32,0x7d25d510,0x42ac6b1c,2 +np.float32,0x7ef5a578,0x42b15cf5,2 +np.float32,0x3fe6625d,0x3f98ae9a,2 +np.float32,0x3ff53240,0x3fa22658,2 +np.float32,0x3f8bb2e6,0x3ed944cf,2 +np.float32,0x7f4679b1,0x42b252ad,2 +np.float32,0x3fa8db30,0x3f4774fc,2 +np.float32,0x7ee5fafd,0x42b13b37,2 +np.float32,0x3fc405e0,0x3f7d71fb,2 +np.float32,0x3f9303cd,0x3f09ddfd,2 +np.float32,0x7f486e67,0x42b257b2,2 +np.float32,0x7e73f12b,0x42aff680,2 +np.float32,0x3fe80f8b,0x3f99cbe4,2 +np.float32,0x3f84200a,0x3e81a3f3,2 +np.float32,0x3fa14e5c,0x3f34e3ce,2 +np.float32,0x3fda22ec,0x3f9029bb,2 +np.float32,0x3f801772,0x3d1aef98,2 +np.float32,0x7eaa1428,0x42b0a0bb,2 +np.float32,0x3feae0b3,0x3f9ba4aa,2 +np.float32,0x7ea439b4,0x42b08ecc,2 +np.float32,0x3fa28b1c,0x3f381579,2 +np.float32,0x7e8af247,0x42b03937,2 +np.float32,0x3fd19216,0x3f89c2b7,2 +np.float32,0x7f6ea033,0x42b2b100,2 +np.float32,0x3fad4fbf,0x3f518224,2 +np.float32,0x3febd940,0x3f9c45bd,2 +np.float32,0x7f4643a3,0x42b25221,2 +np.float32,0x7ec34478,0x42b0e771,2 +np.float32,0x7f18c83b,0x42b1ccb5,2 +np.float32,0x3fc665ad,0x3f80bf94,2 +np.float32,0x3ff0a999,0x3f9f56c4,2 +np.float32,0x3faf1cd2,0x3f5568fe,2 +np.float32,0x7ecd9dc6,0x42b101e1,2 +np.float32,0x3faad282,0x3f4bf754,2 +np.float32,0x3ff905a0,0x3fa47771,2 +np.float32,0x7f596481,0x42b28149,2 +np.float32,0x7f1cb31f,0x42b1d9ac,2 +np.float32,0x7e266719,0x42af32a6,2 +np.float32,0x7eccce06,0x42b0ffdb,2 +np.float32,0x3f9b6f71,0x3f24c102,2 +np.float32,0x3f80e4ba,0x3df1d6bc,2 +np.float32,0x3f843d51,0x3e836a60,2 +np.float32,0x7f70bd88,0x42b2b585,2 +np.float32,0x3fe4cc96,0x3f979e18,2 +np.float32,0x3ff737c7,0x3fa36151,2 +np.float32,0x3ff1197e,0x3f9f9cf4,2 +np.float32,0x7f08e190,0x42b19471,2 +np.float32,0x3ff1542e,0x3f9fc1b2,2 +np.float32,0x3ff6673c,0x3fa2e2d2,2 +np.float32,0xbf800000,0xffc00000,2 +np.float32,0x7e3f9ba7,0x42af7add,2 +np.float32,0x7f658ff6,0x42b29d2d,2 +np.float32,0x3f93441c,0x3f0ac0d9,2 +np.float32,0x7f526a74,0x42b27096,2 +np.float32,0x7f5b00c8,0x42b28511,2 +np.float32,0x3ff212f8,0x3fa038cf,2 +np.float32,0x7e0bd60d,0x42aed998,2 +np.float32,0x7f71ef7f,0x42b2b80e,2 +np.float32,0x7f7a897e,0x42b2c9f1,2 +np.float32,0x7e8b76a6,0x42b03b1e,2 +np.float32,0x7efa0da3,0x42b1660f,2 +np.float32,0x3fce9166,0x3f876ae0,2 +np.float32,0x3fc4163d,0x3f7d8e30,2 +np.float32,0x3fdb3784,0x3f90f16b,2 +np.float32,0x7c5f177b,0x42aa3d30,2 +np.float32,0x3fc6276d,0x3f808af5,2 +np.float32,0x7bac9cc2,0x42a856f4,2 +np.float32,0x3fe5876f,0x3f981bea,2 +np.float32,0x3fef60e3,0x3f9e878a,2 +np.float32,0x3fb23cd8,0x3f5bfb06,2 +np.float32,0x3fe114e2,0x3f951402,2 +np.float32,0x7ca8ef04,0x42ab11b4,2 +np.float32,0x7d93c2ad,0x42ad92ec,2 +np.float32,0x3fe5bb8a,0x3f983ee6,2 +np.float32,0x7f0182fd,0x42b1781b,2 +np.float32,0x7da63bb2,0x42adcf3d,2 +np.float32,0x3fac46b7,0x3f4f399e,2 +np.float32,0x7f7a5d8f,0x42b2c997,2 +np.float32,0x7f76572e,0x42b2c14b,2 +np.float32,0x7f42d53e,0x42b24931,2 +np.float32,0x7f7ffd00,0x42b2d4f6,2 +np.float32,0x3fc346c3,0x3f7c2756,2 +np.float32,0x7f1f6ae3,0x42b1e27a,2 +np.float32,0x3f87fb56,0x3eb3e2ee,2 +np.float32,0x3fed17a2,0x3f9d12b4,2 +np.float32,0x7f5ea903,0x42b28d8c,2 +np.float32,0x3f967f82,0x3f15a4ab,2 +np.float32,0x7d3b540c,0x42aca984,2 +np.float32,0x7f56711a,0x42b27a4a,2 +np.float32,0x7f122223,0x42b1b5ee,2 +np.float32,0x3fd6fa34,0x3f8dd919,2 +np.float32,0x3fadd62e,0x3f52a7b3,2 +np.float32,0x3fb7bf0c,0x3f67015f,2 +np.float32,0x7edf4ba7,0x42b12c1d,2 +np.float32,0x7e33cc65,0x42af5a4b,2 +np.float32,0x3fa6be17,0x3f427831,2 +np.float32,0x3fa07aa8,0x3f32b7d4,2 +np.float32,0x3fa4a3af,0x3f3d5a01,2 +np.float32,0x3fdbb267,0x3f9149a8,2 +np.float32,0x7ed45e25,0x42b1126c,2 +np.float32,0x3fe3f432,0x3f970ba6,2 +np.float32,0x7f752080,0x42b2bec3,2 +np.float32,0x3f872747,0x3eaa62ea,2 +np.float32,0x7e52175d,0x42afaa03,2 +np.float32,0x3fdc766c,0x3f91d5ce,2 +np.float32,0x7ecd6841,0x42b1015c,2 +np.float32,0x7f3d6c40,0x42b23ac6,2 +np.float32,0x3fb80c14,0x3f6796b9,2 +np.float32,0x3ff6ad56,0x3fa30d68,2 +np.float32,0x3fda44c3,0x3f90423e,2 +np.float32,0x3fdcba0c,0x3f9205fc,2 +np.float32,0x7e14a720,0x42aef8e6,2 +np.float32,0x3fe9e489,0x3f9b0047,2 +np.float32,0x7e69f933,0x42afe123,2 +np.float32,0x3ff3ee6d,0x3fa15f71,2 +np.float32,0x3f8538cd,0x3e91c1a7,2 +np.float32,0x3fdc3f07,0x3f91ae46,2 +np.float32,0x3fba2ef0,0x3f6bada2,2 +np.float32,0x7da64cd8,0x42adcf71,2 +np.float32,0x3fc34bd2,0x3f7c301d,2 +np.float32,0x3fa273aa,0x3f37d984,2 +np.float32,0x3ff0338c,0x3f9f0c86,2 +np.float32,0x7ed62cef,0x42b116c3,2 +np.float32,0x3f911e7e,0x3f02f7c6,2 +np.float32,0x7c8514c9,0x42aa9792,2 +np.float32,0x3fea2a74,0x3f9b2df5,2 +np.float32,0x3fe036f8,0x3f947a25,2 +np.float32,0x7c5654bf,0x42aa28ad,2 +np.float32,0x3fd9e423,0x3f8ffc32,2 +np.float32,0x7eec0439,0x42b1487b,2 +np.float32,0x3fc580f4,0x3f7ffb62,2 +np.float32,0x3fb0e316,0x3f592bbe,2 +np.float32,0x7c4cfb7d,0x42aa11d8,2 +np.float32,0x3faf9704,0x3f566e00,2 +np.float32,0x3fa7cf8a,0x3f45023d,2 +np.float32,0x7f7b724d,0x42b2cbcc,2 +np.float32,0x7f05bfe3,0x42b18897,2 +np.float32,0x3f90bde3,0x3f018bf3,2 +np.float32,0x7c565479,0x42aa28ad,2 +np.float32,0x3f94b517,0x3f0fb8e5,2 +np.float32,0x3fd6aadd,0x3f8d9e3c,2 +np.float32,0x7f09b37c,0x42b1977f,2 +np.float32,0x7f2b45ea,0x42b20734,2 +np.float32,0x3ff1d15e,0x3fa00fe9,2 +np.float32,0x3f99bce6,0x3f1fbd6c,2 +np.float32,0x7ecd1f76,0x42b100a7,2 +np.float32,0x7f443e2b,0x42b24ce2,2 +np.float32,0x7da7d6a5,0x42add428,2 +np.float32,0x7ebe0193,0x42b0d975,2 +np.float32,0x7ee13c43,0x42b1308b,2 +np.float32,0x3f8adf1b,0x3ed18e0c,2 +np.float32,0x7f76ce65,0x42b2c242,2 +np.float32,0x7e34f43d,0x42af5d92,2 +np.float32,0x7f306b76,0x42b2165d,2 +np.float32,0x7e1fd07f,0x42af1df7,2 +np.float32,0x3fab9a41,0x3f4db909,2 +np.float32,0x3fc23d1a,0x3f7a5803,2 +np.float32,0x3f8b7403,0x3ed70245,2 +np.float32,0x3f8c4dd6,0x3edebbae,2 +np.float32,0x3fe5f411,0x3f9864cd,2 +np.float32,0x3f88128b,0x3eb4e508,2 +np.float32,0x3fcb09de,0x3f84976f,2 +np.float32,0x7f32f2f5,0x42b21da6,2 +np.float32,0x3fe75610,0x3f9950f6,2 +np.float32,0x3f993edf,0x3f1e408d,2 +np.float32,0x3fc4a9d7,0x3f7e8be9,2 +np.float32,0x7f74551a,0x42b2bd1a,2 +np.float32,0x7de87129,0x42ae7ae2,2 +np.float32,0x7f18bbbd,0x42b1cc8c,2 +np.float32,0x7e7e1dd4,0x42b00b6c,2 +np.float32,0x3ff6e55b,0x3fa32f64,2 +np.float32,0x3fa634c8,0x3f412df3,2 +np.float32,0x3fd0fb7c,0x3f894e49,2 +np.float32,0x3ff4f6a6,0x3fa201d7,2 +np.float32,0x7f69d418,0x42b2a69a,2 +np.float32,0x7cb9632d,0x42ab414a,2 +np.float32,0x3fc57d36,0x3f7ff503,2 +np.float32,0x7e9e2ed7,0x42b07b9b,2 +np.float32,0x7f2e6868,0x42b2107d,2 +np.float32,0x3fa3169a,0x3f39785d,2 +np.float32,0x7f03cde0,0x42b18117,2 +np.float32,0x7f6d75d2,0x42b2ae7f,2 +np.float32,0x3ff483f2,0x3fa1bb75,2 +np.float32,0x7f1b39f7,0x42b1d4d6,2 +np.float32,0x3f8c7a7d,0x3ee0481e,2 +np.float32,0x3f989095,0x3f1c2b19,2 +np.float32,0x3fa4cbfd,0x3f3dbd87,2 +np.float32,0x7f75b00f,0x42b2bfef,2 +np.float32,0x3f940724,0x3f0d6756,2 +np.float32,0x7f5e5a1a,0x42b28cd6,2 +np.float32,0x800000,0xffc00000,2 +np.float32,0x7edd1d29,0x42b12716,2 +np.float32,0x3fa3e9e4,0x3f3b8c16,2 +np.float32,0x7e46d70e,0x42af8dd5,2 +np.float32,0x3f824745,0x3e40ec1e,2 +np.float32,0x3fd67623,0x3f8d770a,2 +np.float32,0x3fe9a6f3,0x3f9ad7fa,2 +np.float32,0x3fdda67c,0x3f92adc1,2 +np.float32,0x7ccb6c9a,0x42ab70d4,2 +np.float32,0x3ffd364a,0x3fa6f2fe,2 +np.float32,0x7e02424c,0x42aeb545,2 +np.float32,0x3fb6d2f2,0x3f6534a1,2 +np.float32,0x3fe1fe26,0x3f95b4cc,2 +np.float32,0x7e93ac57,0x42b05867,2 +np.float32,0x7f7b3433,0x42b2cb4d,2 +np.float32,0x3fb76803,0x3f66580d,2 +np.float32,0x3f9af881,0x3f23661b,2 +np.float32,0x3fd58062,0x3f8cbf98,2 +np.float32,0x80000000,0xffc00000,2 +np.float32,0x7f1af8f4,0x42b1d3ff,2 +np.float32,0x3fe66bba,0x3f98b4dc,2 +np.float32,0x7f6bd7bf,0x42b2aaff,2 +np.float32,0x3f84f79a,0x3e8e2e49,2 +np.float32,0x7e475b06,0x42af8f28,2 +np.float32,0x3faff89b,0x3f573d5e,2 +np.float32,0x7de5aa77,0x42ae74bb,2 +np.float32,0x3f8e9e42,0x3ef26cd2,2 +np.float32,0x3fb1cec3,0x3f5b1740,2 +np.float32,0x3f8890d6,0x3eba4821,2 +np.float32,0x3f9b39e9,0x3f242547,2 +np.float32,0x3fc895a4,0x3f829407,2 +np.float32,0x7f77943c,0x42b2c3dc,2 +np.float32,0x7f390d58,0x42b22ed2,2 +np.float32,0x3fe7e160,0x3f99ad58,2 +np.float32,0x3f93d2a0,0x3f0cb205,2 +np.float32,0x7f29499b,0x42b2013c,2 +np.float32,0x3f8c11b2,0x3edca10f,2 +np.float32,0x7e898ef8,0x42b03413,2 +np.float32,0x3fdff942,0x3f944f34,2 +np.float32,0x7f3d602f,0x42b23aa5,2 +np.float32,0x3f8a50f3,0x3ecc345b,2 +np.float32,0x3fa1f86d,0x3f369ce4,2 +np.float32,0x3f97ad95,0x3f19681d,2 +np.float32,0x3ffad1e0,0x3fa589e5,2 +np.float32,0x3fa70590,0x3f432311,2 +np.float32,0x7e6840cb,0x42afdd5c,2 +np.float32,0x3fd4036d,0x3f8ba0aa,2 +np.float32,0x7f7cc953,0x42b2ce84,2 +np.float32,0x7f228e1e,0x42b1ec74,2 +np.float32,0x7e37a866,0x42af652a,2 +np.float32,0x3fda22d0,0x3f9029a7,2 +np.float32,0x7f736bff,0x42b2bb31,2 +np.float32,0x3f9833b6,0x3f1b0b8e,2 +np.float32,0x7f466001,0x42b2526a,2 +np.float32,0xff7fffff,0xffc00000,2 +np.float32,0x7dd62bcd,0x42ae50f8,2 +np.float32,0x7f1d2bfe,0x42b1db36,2 +np.float32,0x7ecffe9e,0x42b107c5,2 +np.float32,0x7ebefe0a,0x42b0dc1b,2 +np.float32,0x7f45c63d,0x42b250dd,2 +np.float32,0x7f601af0,0x42b290db,2 +np.float32,0x3fcbb88a,0x3f8524e5,2 +np.float32,0x7ede55ff,0x42b129e8,2 +np.float32,0x7ea5dd5a,0x42b093e2,2 +np.float32,0x3ff53857,0x3fa22a12,2 +np.float32,0x3f8dbd6a,0x3eeb28a4,2 +np.float32,0x3fd1b467,0x3f89dd2c,2 +np.float32,0x3fe0423f,0x3f9481fc,2 +np.float32,0x3f84b421,0x3e8a6174,2 +np.float32,0x7f4efc97,0x42b2682c,2 +np.float32,0x7f601b33,0x42b290dc,2 +np.float32,0x3f94f240,0x3f108719,2 +np.float32,0x7decd251,0x42ae8471,2 +np.float32,0x3fdc457c,0x3f91b2e2,2 +np.float32,0x3f92a966,0x3f089c5a,2 +np.float32,0x3fc9732f,0x3f834afc,2 +np.float32,0x3f97948f,0x3f19194e,2 +np.float32,0x7f0824a1,0x42b191ac,2 +np.float32,0x7f0365a5,0x42b17f81,2 +np.float32,0x3f800000,0x0,2 +np.float32,0x7f0054c6,0x42b1736b,2 +np.float32,0x3fe86544,0x3f9a0484,2 +np.float32,0x7e95f844,0x42b0604e,2 +np.float32,0x3fce8602,0x3f8761e2,2 +np.float32,0x3fc726c8,0x3f81621d,2 +np.float32,0x3fcf6b03,0x3f88161b,2 +np.float32,0x3fceb843,0x3f87898a,2 +np.float32,0x3fe2f8b2,0x3f966071,2 +np.float32,0x7f3c8e7f,0x42b2386d,2 +np.float32,0x3fcee13a,0x3f87a9d2,2 +np.float32,0x3fc4df27,0x3f7ee73c,2 +np.float32,0x3ffde486,0x3fa758e3,2 +np.float32,0x3fa91be0,0x3f480b17,2 +np.float32,0x7f2a5a7d,0x42b20472,2 +np.float32,0x7e278d80,0x42af362d,2 +np.float32,0x3f96d091,0x3f16a9d5,2 +np.float32,0x7e925225,0x42b053b2,2 +np.float32,0x7f7ef83a,0x42b2d2ec,2 +np.float32,0x7eb4923a,0x42b0bf61,2 +np.float32,0x7e98bf19,0x42b069b3,2 +np.float32,0x3fac93a2,0x3f4fe410,2 +np.float32,0x7f46389c,0x42b25205,2 +np.float32,0x3f9fd447,0x3f30fd54,2 +np.float32,0x3fef42d4,0x3f9e7483,2 +np.float32,0x7f482174,0x42b256ed,2 +np.float32,0x3f97aedb,0x3f196c1e,2 +np.float32,0x7f764edd,0x42b2c13a,2 +np.float32,0x3f9117b5,0x3f02de5c,2 +np.float32,0x3fc7984e,0x3f81c12d,2 +np.float64,0x3ff1e2cb7463c597,0x3fdec6caf39e0c0e,1 +np.float64,0x3ffe4f89789c9f13,0x3ff40f4b1da0f3e9,1 +np.float64,0x7f6a5c9ac034b935,0x408605e51703c145,1 +np.float64,0x7fdcb6ece3b96dd9,0x40862d6521e16d60,1 +np.float64,0x3ff6563e182cac7c,0x3feb9d8210f3fa88,1 +np.float64,0x7fde32025f3c6404,0x40862dcc1d1a9b7f,1 +np.float64,0x7fd755ed35aeabd9,0x40862bbc5522b779,1 +np.float64,0x3ff5c81f4bcb903e,0x3fea71f10b954ea3,1 +np.float64,0x3fffe805d35fd00c,0x3ff50463a1ba2938,1 +np.float64,0x7fd045a1c1a08b43,0x408628d9f431f2f5,1 +np.float64,0x3ff49f7dd9893efc,0x3fe7c6736e17ea8e,1 +np.float64,0x7fccfbc1fd39f783,0x408627eca79acf51,1 +np.float64,0x3ff1af0a00035e14,0x3fdd1c0e7d5706ea,1 +np.float64,0x7fe7bd17162f7a2d,0x4086316af683502b,1 +np.float64,0x3ff0941b8d012837,0x3fd128d274065ac0,1 +np.float64,0x3ffa0c5d98b418bb,0x3ff11af9c8edd17f,1 +np.float64,0x3ffad9733355b2e6,0x3ff1b6d1307acb42,1 +np.float64,0x3ffabb2a33d57654,0x3ff1a0442b034e50,1 +np.float64,0x3ff36118b0c6c231,0x3fe472b7dfb23516,1 +np.float64,0x3ff2441d3664883a,0x3fe0d61145608f0c,1 +np.float64,0x7fe039862d20730b,0x40862e5f8ed752d3,1 +np.float64,0x7fb1dde24023bbc4,0x40861e824cdb0664,1 +np.float64,0x7face6335839cc66,0x40861ccf90a26e16,1 +np.float64,0x3ffb5d0e1af6ba1c,0x3ff2170f6f42fafe,1 +np.float64,0x3ff5c2c6a50b858d,0x3fea665aabf04407,1 +np.float64,0x3ffabb409db57681,0x3ff1a054ea32bfc3,1 +np.float64,0x3ff1e054e983c0aa,0x3fdeb30c17286cb6,1 +np.float64,0x7fe467f73268cfed,0x4086303529e52e9b,1 +np.float64,0x7fe0e86bf961d0d7,0x40862eb40788b04a,1 +np.float64,0x3ffb743542f6e86a,0x3ff227b4ea5acee0,1 +np.float64,0x3ff2de6826e5bcd0,0x3fe2e31fcde0a96c,1 +np.float64,0x7fd6b27ccfad64f9,0x40862b8385697c31,1 +np.float64,0x7fe0918e8d21231c,0x40862e8a82d9517a,1 +np.float64,0x7fd0ca0395a19406,0x4086291a0696ed33,1 +np.float64,0x3ffb042496960849,0x3ff1d658c928abfc,1 +np.float64,0x3ffcd0409799a081,0x3ff31877df0cb245,1 +np.float64,0x7fe429bd06685379,0x4086301c9f259934,1 +np.float64,0x3ff933076092660f,0x3ff06d2e5f4d9ab7,1 +np.float64,0x7feaefcb28f5df95,0x4086326dccf88e6f,1 +np.float64,0x7fb5f2c1f82be583,0x40862027ac02a39d,1 +np.float64,0x3ffb5d9e3bd6bb3c,0x3ff21777501d097e,1 +np.float64,0x10000000000000,0xfff8000000000000,1 +np.float64,0x3ff70361596e06c3,0x3fecf675ceda7e19,1 +np.float64,0x3ff71a21b5ee3444,0x3fed224fa048d9a9,1 +np.float64,0x3ffb102b86762057,0x3ff1df2cc9390518,1 +np.float64,0x7feaaeb35c355d66,0x4086325a60704a90,1 +np.float64,0x7fd9a3d0a93347a0,0x40862c7d300fc076,1 +np.float64,0x7fabcf159c379e2a,0x40861c80cdbbff27,1 +np.float64,0x7fd1c066ec2380cd,0x4086298c3006fee6,1 +np.float64,0x3ff3d5ae2d67ab5c,0x3fe5bc16447428db,1 +np.float64,0x3ff4b76add696ed6,0x3fe800f5bbf21376,1 +np.float64,0x3ff60d89ee0c1b14,0x3feb063fdebe1a68,1 +np.float64,0x7f1d2648003a4c8f,0x4085eaf9238af95a,1 +np.float64,0x7fe8b45f6df168be,0x408631bca5abf6d6,1 +np.float64,0x7fe9ea5308f3d4a5,0x4086321ea2bd3af9,1 +np.float64,0x7fcb6ba5a636d74a,0x4086277b208075ed,1 +np.float64,0x3ff621cfd74c43a0,0x3feb30d59baf5919,1 +np.float64,0x3ff7bc8ca0af7919,0x3fee524da8032896,1 +np.float64,0x7fda22dd0c3445b9,0x40862ca47326d063,1 +np.float64,0x7fd02ed4b2a05da8,0x408628ceb6919421,1 +np.float64,0x3ffe64309fdcc861,0x3ff41c1b18940709,1 +np.float64,0x3ffee4042abdc808,0x3ff46a6005bccb41,1 +np.float64,0x3ff078145b00f029,0x3fceeb3d6bfae0eb,1 +np.float64,0x7fda20fd20b441f9,0x40862ca3e03b990b,1 +np.float64,0x3ffa9e9e9af53d3d,0x3ff18ade3cbee789,1 +np.float64,0x3ff0a1062501420c,0x3fd1e32de6d18c0d,1 +np.float64,0x3ff3bdf118477be2,0x3fe57ad89b7fdf8b,1 +np.float64,0x3ff101c0d5c20382,0x3fd6965d3539be47,1 +np.float64,0x7feba3b53b774769,0x408632a28c7aca4d,1 +np.float64,0x3ff598db5d4b31b7,0x3fea0aa65c0b421a,1 +np.float64,0x3ff5fdfbb72bfbf8,0x3feae55accde4a5e,1 +np.float64,0x7fe5bae53aab75c9,0x408630b5e7a5b92a,1 +np.float64,0x3ff8f668afd1ecd2,0x3ff03af686666c9c,1 +np.float64,0x3ff5ba72dd2b74e6,0x3fea5441f223c093,1 +np.float64,0x3ff8498147109302,0x3fef4e45d501601d,1 +np.float64,0x7feddcfa5efbb9f4,0x4086334106a6e76b,1 +np.float64,0x7fd1a30200234603,0x4086297ee5cc562c,1 +np.float64,0x3ffffa8ee07ff51e,0x3ff50f1dc46f1303,1 +np.float64,0x7fef7ed00ebefd9f,0x408633ae01dabe52,1 +np.float64,0x3ffb6e062276dc0c,0x3ff22344c58c2016,1 +np.float64,0x7fcf2b59943e56b2,0x4086288190dd5eeb,1 +np.float64,0x3ffa589f9254b13f,0x3ff155cc081eee0b,1 +np.float64,0x3ff05415ca60a82c,0x3fc9e45565baef0a,1 +np.float64,0x7feb34bed576697d,0x408632822d5a178c,1 +np.float64,0x3ff3993845c73270,0x3fe51423baf246c3,1 +np.float64,0x3ff88367aaf106d0,0x3fefb2d9ca9f1192,1 +np.float64,0x7fef364304fe6c85,0x4086339b7ed82997,1 +np.float64,0x7fcba2c317374585,0x4086278b24e42934,1 +np.float64,0x3ff1aef885e35df1,0x3fdd1b79f55b20c0,1 +np.float64,0x7fe19367886326ce,0x40862f035f867445,1 +np.float64,0x3ff3c8295e279053,0x3fe5970aa670d32e,1 +np.float64,0x3ff6edda164ddbb4,0x3feccca9eb59d6b9,1 +np.float64,0x7fdeaea940bd5d52,0x40862dece02d151b,1 +np.float64,0x7fea9d6324353ac5,0x408632552ddf0d4f,1 +np.float64,0x7fe60e39e66c1c73,0x408630d45b1ad0c4,1 +np.float64,0x7fde06325abc0c64,0x40862dc07910038c,1 +np.float64,0x7f9ec89d303d9139,0x408617c55ea4c576,1 +np.float64,0x3ff9801930530032,0x3ff0abe5be046051,1 +np.float64,0x3ff4d5859689ab0b,0x3fe849a7f7a19fa3,1 +np.float64,0x3ff38afbc48715f8,0x3fe4ebb7710cbab9,1 +np.float64,0x3ffd88a0e77b1142,0x3ff3916964407e21,1 +np.float64,0x1,0xfff8000000000000,1 +np.float64,0x3ff5db59e58bb6b4,0x3fea9b6b5ccc116f,1 +np.float64,0x3ffd4b05b15a960c,0x3ff369792f661a90,1 +np.float64,0x7fdcebc4fb39d789,0x40862d73cd623378,1 +np.float64,0x3ff5b56f944b6adf,0x3fea4955d6b06ca3,1 +np.float64,0x7fd4e4abf2a9c957,0x40862ad9e9da3c61,1 +np.float64,0x7fe08e0d6aa11c1a,0x40862e88d17ef277,1 +np.float64,0x3ff0dfc97da1bf93,0x3fd50f9004136d8f,1 +np.float64,0x7fdec38eaebd871c,0x40862df2511e26b4,1 +np.float64,0x7ff8000000000000,0x7ff8000000000000,1 +np.float64,0x3ff21865504430cb,0x3fe033fe3cf3947a,1 +np.float64,0x7fdc139708b8272d,0x40862d371cfbad03,1 +np.float64,0x7fe1fe3be3a3fc77,0x40862f336e3ba63a,1 +np.float64,0x7fd9fa2493b3f448,0x40862c97f2960be9,1 +np.float64,0x3ff0a027db414050,0x3fd1d6e54a707c87,1 +np.float64,0x3ff568b16f4ad163,0x3fe99f5c6d7b6e18,1 +np.float64,0x3ffe2f82877c5f05,0x3ff3fb54bd0da753,1 +np.float64,0x7fbaf5778435eaee,0x408621ccc9e2c1be,1 +np.float64,0x7fc5aaf8362b55ef,0x40862598e7072a49,1 +np.float64,0x7fe0ebfdd4a1d7fb,0x40862eb5b7bf99d5,1 +np.float64,0x7fd8efeb5931dfd6,0x40862c444636f408,1 +np.float64,0x3ff361a308c6c346,0x3fe4744cae63e6df,1 +np.float64,0x7fef287d39be50f9,0x40863397f65c807e,1 +np.float64,0x7fe72c4a14ae5893,0x4086313992e52082,1 +np.float64,0x3ffd1be44cba37c8,0x3ff34a9a45239eb9,1 +np.float64,0x3ff50369c18a06d4,0x3fe8b69319f091f1,1 +np.float64,0x3ffb333c25766678,0x3ff1f8c78eeb28f1,1 +np.float64,0x7fe12050416240a0,0x40862ece4e2f2f24,1 +np.float64,0x7fe348f5526691ea,0x40862fc16fbe7b6c,1 +np.float64,0x3ff343cc4d068799,0x3fe41c2a30cab7d2,1 +np.float64,0x7fd1b0daaa2361b4,0x408629852b3104ff,1 +np.float64,0x3ff6a41f37ad483e,0x3fec3b36ee6c6d4a,1 +np.float64,0x3ffad9439435b287,0x3ff1b6add9a1b3d7,1 +np.float64,0x7fbeb9a2f23d7345,0x408622d89ac1eaba,1 +np.float64,0x3ffab3d39fb567a7,0x3ff19ac75b4427f3,1 +np.float64,0x3ff890003ed12000,0x3fefc8844471c6ad,1 +np.float64,0x3ffc9f595e593eb2,0x3ff2f7a8699f06d8,1 +np.float64,0x7fe2224ef6e4449d,0x40862f43684a154a,1 +np.float64,0x3ffa67ba08d4cf74,0x3ff161525778df99,1 +np.float64,0x7fe87e24b570fc48,0x408631ab02b159fb,1 +np.float64,0x7fd6e99be92dd337,0x40862b96dba73685,1 +np.float64,0x7fe90f39fdf21e73,0x408631d9dbd36c1e,1 +np.float64,0x3ffb7806abd6f00e,0x3ff22a719b0f4c46,1 +np.float64,0x3ffa511ba3d4a238,0x3ff1500c124f6e17,1 +np.float64,0x3ff5d7a569abaf4b,0x3fea937391c280e8,1 +np.float64,0x7fc4279d20284f39,0x40862504a5cdcb96,1 +np.float64,0x3ffe8791b1fd0f24,0x3ff431f1ed7eaba0,1 +np.float64,0x7fe3b2f5276765e9,0x40862fecf15e2535,1 +np.float64,0x7feeab0e7abd561c,0x408633778044cfbc,1 +np.float64,0x7fdba88531375109,0x40862d1860306d7a,1 +np.float64,0x7fe7b19b3def6335,0x4086316716d6890b,1 +np.float64,0x3ff9e9437413d287,0x3ff0ff89431c748c,1 +np.float64,0x3ff960716a52c0e3,0x3ff092498028f802,1 +np.float64,0x3ff271bf56a4e37f,0x3fe1786fc8dd775d,1 +np.float64,0x3fff2a6578be54cb,0x3ff494bbe303eeb5,1 +np.float64,0x3ffd842eb5fb085e,0x3ff38e8b7ba42bc5,1 +np.float64,0x3ff91600e5d22c02,0x3ff0553c6a6b3d93,1 +np.float64,0x3ff9153f45f22a7e,0x3ff0549c0eaecf95,1 +np.float64,0x7fe0ab319da15662,0x40862e96da3b19f9,1 +np.float64,0x3ff06acd1f60d59a,0x3fcd2aca543d2772,1 +np.float64,0x3ffb3e7a54d67cf4,0x3ff200f288cd391b,1 +np.float64,0x3ffd01356f1a026b,0x3ff339003462a56c,1 +np.float64,0x3ffacd35def59a6c,0x3ff1adb8d32b3ec0,1 +np.float64,0x3ff6f953264df2a6,0x3fece2f992948d6e,1 +np.float64,0x3ff0fa91f5a1f524,0x3fd64609a28f1590,1 +np.float64,0x7fd1b7610ca36ec1,0x408629881e03dc7d,1 +np.float64,0x3ff4317fb7c86300,0x3fe6b086ed265887,1 +np.float64,0x3ff3856198070ac3,0x3fe4dbb6bc88b9e3,1 +np.float64,0x7fed7fc4573aff88,0x40863327e7013a81,1 +np.float64,0x3ffe53cbbf5ca798,0x3ff411f07a29b1f4,1 +np.float64,0x3ff092195b012433,0x3fd10b1c0b4b14fe,1 +np.float64,0x3ff1a3171163462e,0x3fdcb5c301d5d40d,1 +np.float64,0x3ffa1401f1742804,0x3ff120eb319e9faa,1 +np.float64,0x7fd352f6f426a5ed,0x40862a3a048feb6d,1 +np.float64,0x7fd4ee246fa9dc48,0x40862add895d808f,1 +np.float64,0x3ff0675cfa00ceba,0x3fccb2222c5493ca,1 +np.float64,0x3ffe5cb38f3cb967,0x3ff417773483d161,1 +np.float64,0x7fe11469ea2228d3,0x40862ec8bd3e497f,1 +np.float64,0x3fff13cba67e2798,0x3ff4872fe2c26104,1 +np.float64,0x3ffb73d3d316e7a8,0x3ff2276f08612ea2,1 +np.float64,0x7febfb70f237f6e1,0x408632bbc9450721,1 +np.float64,0x3ff84a0d87b0941b,0x3fef4f3b707e3145,1 +np.float64,0x7fd71fd5082e3fa9,0x40862ba9b4091172,1 +np.float64,0x3ff560737d8ac0e7,0x3fe98cc9c9ba2f61,1 +np.float64,0x3ff46a266ae8d44d,0x3fe74190e5234822,1 +np.float64,0x7fe8cc9225719923,0x408631c477db9708,1 +np.float64,0x3ff871de5930e3bc,0x3fef948f7d00fbef,1 +np.float64,0x3ffd0bc7895a178f,0x3ff33ffc18357721,1 +np.float64,0x3ff66099f9ccc134,0x3febb2bc775b4720,1 +np.float64,0x7fe91f1be9723e37,0x408631deec3a5c9e,1 +np.float64,0x7fd60462f12c08c5,0x40862b4537e1c1c6,1 +np.float64,0x3ff053100ba0a620,0x3fc9bc0c21e2284f,1 +np.float64,0x7fd864c611b0c98b,0x40862c1724506255,1 +np.float64,0x7fd191decb2323bd,0x408629771bfb68cc,1 +np.float64,0x3ff792a1656f2543,0x3fee054f2e135fcf,1 +np.float64,0x7fd03625cea06c4b,0x408628d253b840e3,1 +np.float64,0x7fc3967716272ced,0x408624ca35451042,1 +np.float64,0x7fe6636cb32cc6d8,0x408630f3073a22a7,1 +np.float64,0x3ffc2d3976585a73,0x3ff2a9d4c0dae607,1 +np.float64,0x3fffd10ee79fa21e,0x3ff4f70db69888be,1 +np.float64,0x3ff1d4fcae23a9f9,0x3fde57675007b23c,1 +np.float64,0x3ffa5da19e14bb43,0x3ff1599f74d1c113,1 +np.float64,0x3ff7f4eb0d6fe9d6,0x3feeb85189659e99,1 +np.float64,0x7fbcca44d8399489,0x408622536234f7c1,1 +np.float64,0x7fef5f97ec3ebf2f,0x408633a60fdde0d7,1 +np.float64,0x7fde4a66da3c94cd,0x40862dd290ebc184,1 +np.float64,0x3ff072957a40e52b,0x3fce34d913d87613,1 +np.float64,0x3ff2bc4c9dc57899,0x3fe27497e6ebe27d,1 +np.float64,0x7fd7d152b4afa2a4,0x40862be63469eecd,1 +np.float64,0x3ff957d768f2afaf,0x3ff08b4ad8062a73,1 +np.float64,0x7fe4bc5f45a978be,0x40863055fd66e4eb,1 +np.float64,0x7fc90de345321bc6,0x408626c24ce7e370,1 +np.float64,0x3ff2d7a37d85af47,0x3fe2cd6a40b544a0,1 +np.float64,0x7fe536ea1f6a6dd3,0x40863084bade76a3,1 +np.float64,0x3fff970c9cdf2e19,0x3ff4d524572356dd,1 +np.float64,0x3ffe173ae63c2e76,0x3ff3ec1ee35ad28c,1 +np.float64,0x3ff714025cce2805,0x3fed168aedff4a2b,1 +np.float64,0x7fce7b414c3cf682,0x40862853dcdd19d4,1 +np.float64,0x3ff019623f2032c4,0x3fbc7c602df0bbaf,1 +np.float64,0x3ff72f57fd0e5eb0,0x3fed4ae75f697432,1 +np.float64,0x3ff283778e8506ef,0x3fe1b5c5725b0dfd,1 +np.float64,0x3ff685a29aed0b45,0x3febfdfdedd581e2,1 +np.float64,0x3ff942d24fb285a4,0x3ff07a224c3ecfaf,1 +np.float64,0x3ff2e4a9f465c954,0x3fe2f71905399e8f,1 +np.float64,0x7fdfa1c7fa3f438f,0x40862e2b4e06f098,1 +np.float64,0x3ff49b59c26936b4,0x3fe7bc41c8c1e59d,1 +np.float64,0x3ff2102d3704205a,0x3fe014bf7e28924e,1 +np.float64,0x3ff88de3b8311bc8,0x3fefc4e3e0a15a89,1 +np.float64,0x7fea5ba25374b744,0x40863241519c9b66,1 +np.float64,0x3fffe5df637fcbbf,0x3ff5032488f570f9,1 +np.float64,0x7fe67cfefe6cf9fd,0x408630fc25333cb4,1 +np.float64,0x3ff090bf2b01217e,0x3fd0f6fcf1092b4a,1 +np.float64,0x7fecd75bc5f9aeb7,0x408632f9b6c2e013,1 +np.float64,0x7fe15df38c62bbe6,0x40862eeae5ac944b,1 +np.float64,0x3ff4757875a8eaf1,0x3fe75e0eafbe28ce,1 +np.float64,0x7fecca8a51b99514,0x408632f627c23923,1 +np.float64,0x3ff91ca529d2394a,0x3ff05abb327fd1ca,1 +np.float64,0x3ffb962993b72c53,0x3ff23ff831717579,1 +np.float64,0x3ffd548a2c7aa914,0x3ff36fac7f56d716,1 +np.float64,0x7fbafb5cb035f6b8,0x408621ce898a02fb,1 +np.float64,0x3ff1d86daca3b0db,0x3fde73536c29218c,1 +np.float64,0x7fa8d0f8f431a1f1,0x40861b97a03c3a18,1 +np.float64,0x3ff44f1067489e21,0x3fe6fcbd8144ab2a,1 +np.float64,0x7fec062b07380c55,0x408632bed9c6ce85,1 +np.float64,0x3ff7e11e0fcfc23c,0x3fee94ada7efaac4,1 +np.float64,0x7fe77505c1aeea0b,0x4086315287dda0ba,1 +np.float64,0x7fc465af2728cb5d,0x4086251d236107f7,1 +np.float64,0x3ffe811c4a7d0238,0x3ff42df7e8b6cf2d,1 +np.float64,0x7fe05a471260b48d,0x40862e6fa502738b,1 +np.float64,0x7fec32cd9778659a,0x408632cb8d98c5a3,1 +np.float64,0x7fd203a220a40743,0x408629aa43b010c0,1 +np.float64,0x7fed71f7d17ae3ef,0x4086332428207101,1 +np.float64,0x3ff3918999e72313,0x3fe4fe5e8991402f,1 +np.float64,0x3ff3ecae38c7d95c,0x3fe5fa787d887981,1 +np.float64,0x7fd65345b82ca68a,0x40862b61aed8c64e,1 +np.float64,0x3ff1efdd01c3dfba,0x3fdf2eae36139204,1 +np.float64,0x3ffba9344f375268,0x3ff24d7fdcfc313b,1 +np.float64,0x7fd0469b35208d35,0x408628da6ed24bdd,1 +np.float64,0x7fe525782daa4aef,0x4086307e240c8b30,1 +np.float64,0x3ff8e473d371c8e8,0x3ff02beebd4171c7,1 +np.float64,0x3ff59a43898b3487,0x3fea0dc0a6acea0a,1 +np.float64,0x7fef50c7263ea18d,0x408633a247d7cd42,1 +np.float64,0x7fe8b5a301f16b45,0x408631bd0e71c855,1 +np.float64,0x3ff209369de4126d,0x3fdff4264334446b,1 +np.float64,0x3ffbe2ff4437c5fe,0x3ff2763b356814c7,1 +np.float64,0x3ff55938156ab270,0x3fe97c70514f91bf,1 +np.float64,0x3fff5d8bf81ebb18,0x3ff4b333b230672a,1 +np.float64,0x3ff16a317bc2d463,0x3fdab84e7faa468f,1 +np.float64,0x3ff7e64f8dafcc9f,0x3fee9e0bd57e9566,1 +np.float64,0x7fef4dc065be9b80,0x408633a181e25abb,1 +np.float64,0x3ff64a24a62c9449,0x3feb849ced76437e,1 +np.float64,0x7fc3cb85ef27970b,0x408624dfc39c8f74,1 +np.float64,0x7fec2162a77842c4,0x408632c69b0d43b6,1 +np.float64,0x7feccee6dc399dcd,0x408632f75de98c46,1 +np.float64,0x7faff4f5f43fe9eb,0x40861d9d89be14c9,1 +np.float64,0x7fee82df60fd05be,0x4086336cfdeb7317,1 +np.float64,0x3ffe54588d9ca8b1,0x3ff41247eb2f75ca,1 +np.float64,0x3ffe5615b55cac2c,0x3ff4135c4eb11620,1 +np.float64,0x3ffdaf9a6a1b5f35,0x3ff3aa70e50d1692,1 +np.float64,0x3ff69c045f4d3809,0x3fec2b00734e2cde,1 +np.float64,0x7fd049239aa09246,0x408628dbad6dd995,1 +np.float64,0x3ff2acbe8465597d,0x3fe24138652195e1,1 +np.float64,0x3ffb288302365106,0x3ff1f0f86ca7e5d1,1 +np.float64,0x3fff6fe8d87edfd2,0x3ff4be136acf53c5,1 +np.float64,0x3ffc87c8bfb90f92,0x3ff2e7bbd65867cb,1 +np.float64,0x3ff173327ca2e665,0x3fdb0b945abb00d7,1 +np.float64,0x3ff9a5cf7a134b9f,0x3ff0ca2450f07c78,1 +np.float64,0x7faf782b043ef055,0x40861d7e0e9b35ef,1 +np.float64,0x3ffa0874975410e9,0x3ff117ee3dc8f5ba,1 +np.float64,0x7fc710fc7f2e21f8,0x40862618fed167fb,1 +np.float64,0x7feb73f4c876e7e9,0x40863294ae3ac1eb,1 +np.float64,0x8000000000000000,0xfff8000000000000,1 +np.float64,0x7fb46615c028cc2b,0x40861f91bade4dad,1 +np.float64,0x7fc26b064624d60c,0x4086244c1b76c938,1 +np.float64,0x3ff06ab9fa40d574,0x3fcd282fd971d1b4,1 +np.float64,0x3ff61da7410c3b4e,0x3feb28201031af02,1 +np.float64,0x3ffec7ba1b9d8f74,0x3ff459342511f952,1 +np.float64,0x7ff4000000000000,0x7ffc000000000000,1 +np.float64,0x7fe5d570422baae0,0x408630bfa75008c9,1 +np.float64,0x3ffa895832f512b0,0x3ff17ad41555dccb,1 +np.float64,0x7fd343ac21a68757,0x40862a33ad59947a,1 +np.float64,0x3ffc1eeb37383dd6,0x3ff29ff29e55a006,1 +np.float64,0x7fee3c5c507c78b8,0x4086335a6b768090,1 +np.float64,0x7fe96d774a32daee,0x408631f7b9937e36,1 +np.float64,0x7fb878362430f06b,0x40862106603497b6,1 +np.float64,0x7fec0a79c03814f3,0x408632c01479905e,1 +np.float64,0x3ffa2f143c145e28,0x3ff135e25d902e1a,1 +np.float64,0x3ff14ccff80299a0,0x3fd9a0cd3397b14c,1 +np.float64,0x3ff97980dcb2f302,0x3ff0a6942a8133ab,1 +np.float64,0x3ff872e2d1f0e5c6,0x3fef96526eb2f756,1 +np.float64,0x7fdf1c9b46be3936,0x40862e0957fee329,1 +np.float64,0x7fcab6525d356ca4,0x408627458791f029,1 +np.float64,0x3ff964e74a52c9ce,0x3ff095e8845d523c,1 +np.float64,0x3ffb3aa23c967544,0x3ff1fe282d897c13,1 +np.float64,0x7fdd8a36afbb146c,0x40862d9f2b05f61b,1 +np.float64,0x3ffea39f42fd473e,0x3ff4432a48176399,1 +np.float64,0x7fea614f68b4c29e,0x408632430a750385,1 +np.float64,0x7feeafb86abd5f70,0x40863378b79f70cf,1 +np.float64,0x3ff80bc94eb01792,0x3feee138e9d626bd,1 +np.float64,0x7fcaca74743594e8,0x4086274b8ce4d1e1,1 +np.float64,0x3ff8b14815316290,0x3ff000b3526c8321,1 +np.float64,0x7fc698eb5f2d31d6,0x408625eeec86cd2b,1 +np.float64,0x7fe15429a3e2a852,0x40862ee6621205b8,1 +np.float64,0x7fee37f81b7c6fef,0x4086335941ed80dd,1 +np.float64,0x3ff8097ab3f012f6,0x3feedd1bafc3196e,1 +np.float64,0x7fe7c889ceaf9113,0x4086316ed13f2394,1 +np.float64,0x7fceca94513d9528,0x4086286893a06824,1 +np.float64,0x3ff593a103cb2742,0x3fe9ff1af4f63cc9,1 +np.float64,0x7fee237d24bc46f9,0x40863353d4142c87,1 +np.float64,0x3ffbf71e4777ee3c,0x3ff2844c0ed9f4d9,1 +np.float64,0x3ff490c65c09218d,0x3fe7a2216d9f69fd,1 +np.float64,0x3fff5ceaf1feb9d6,0x3ff4b2d430a90110,1 +np.float64,0x3ff55baecceab75e,0x3fe98203980666c4,1 +np.float64,0x3ff511bc306a2378,0x3fe8d81ce7be7b50,1 +np.float64,0x3ff38f83dcc71f08,0x3fe4f89f130d5f87,1 +np.float64,0x3ff73a3676ee746d,0x3fed5f98a65107ee,1 +np.float64,0x7fc27e50c824fca1,0x408624547828bc49,1 +np.float64,0xfff0000000000000,0xfff8000000000000,1 +np.float64,0x3fff38959ebe712b,0x3ff49d362c7ba16a,1 +np.float64,0x3ffad6d23a75ada4,0x3ff1b4dda6394ed0,1 +np.float64,0x3ffe77c6c2dcef8e,0x3ff4283698835ecb,1 +np.float64,0x3fff5feb413ebfd6,0x3ff4b49bcbdb3aa9,1 +np.float64,0x3ff0d30aa161a615,0x3fd4751bcdd7d727,1 +np.float64,0x3ff51e07e00a3c10,0x3fe8f4bd1408d694,1 +np.float64,0x8010000000000000,0xfff8000000000000,1 +np.float64,0x7fd231d2fe2463a5,0x408629beaceafcba,1 +np.float64,0x3fff6b4aee1ed696,0x3ff4bb58544bf8eb,1 +np.float64,0x3ff91fcd2f323f9a,0x3ff05d56e33db6b3,1 +np.float64,0x3ff3b889ab477113,0x3fe56bdeab74cce5,1 +np.float64,0x3ff99bfe30d337fc,0x3ff0c24bbf265561,1 +np.float64,0x3ffbe9e5eaf7d3cc,0x3ff27b0fe60f827a,1 +np.float64,0x7fd65678e92cacf1,0x40862b62d44fe8b6,1 +np.float64,0x7fd9cc477233988e,0x40862c89c638ee48,1 +np.float64,0x3ffc123c72d82479,0x3ff297294d05cbc0,1 +np.float64,0x3ff58abad58b1576,0x3fe9eb65da2a867a,1 +np.float64,0x7fe534887b2a6910,0x40863083d4ec2877,1 +np.float64,0x7fe1d3dcb123a7b8,0x40862f208116c55e,1 +np.float64,0x7fd4d570dba9aae1,0x40862ad412c413cd,1 +np.float64,0x3fffce7d3fdf9cfa,0x3ff4f58f02451928,1 +np.float64,0x3ffa76901c74ed20,0x3ff16c9a5851539c,1 +np.float64,0x7fdd88ffa23b11fe,0x40862d9ed6c6f426,1 +np.float64,0x3ff09fdbb9e13fb7,0x3fd1d2ae4fcbf713,1 +np.float64,0x7fe64567772c8ace,0x408630e845dbc290,1 +np.float64,0x7fb1a849ba235092,0x40861e6a291535b2,1 +np.float64,0x3ffaddb105f5bb62,0x3ff1b9f68f4c419b,1 +np.float64,0x7fd2fc3d5025f87a,0x40862a15cbc1df75,1 +np.float64,0x7fdea7d872bd4fb0,0x40862deb190b2c50,1 +np.float64,0x7fd50ea97eaa1d52,0x40862ae9edc4c812,1 +np.float64,0x3fff659c245ecb38,0x3ff4b7fb18b31aea,1 +np.float64,0x3ff3f1fbb7c7e3f7,0x3fe608bd9d76268c,1 +np.float64,0x3ff76869d9aed0d4,0x3fedb6c23d3a317b,1 +np.float64,0x7fedd4efe93ba9df,0x4086333edeecaa43,1 +np.float64,0x3ff9a5bd4eb34b7a,0x3ff0ca15d02bc960,1 +np.float64,0x3ffd9359cc5b26b4,0x3ff39850cb1a6b6c,1 +np.float64,0x7fe912d0427225a0,0x408631db00e46272,1 +np.float64,0x3ffb3802fe567006,0x3ff1fc4093646465,1 +np.float64,0x3ff02cc38a205987,0x3fc2e8182802a07b,1 +np.float64,0x3ffda953dd1b52a8,0x3ff3a66c504cf207,1 +np.float64,0x7fe0a487e4a1490f,0x40862e93a6f20152,1 +np.float64,0x7fed265ed1fa4cbd,0x4086330f838ae431,1 +np.float64,0x7fd0000114200001,0x408628b76ec48b5c,1 +np.float64,0x3ff2c262786584c5,0x3fe288860d354b0f,1 +np.float64,0x8000000000000001,0xfff8000000000000,1 +np.float64,0x3ffdae9f075b5d3e,0x3ff3a9d006ae55c1,1 +np.float64,0x3ffb69c72156d38e,0x3ff22037cbb85e5b,1 +np.float64,0x7feeae255f7d5c4a,0x408633784e89bc05,1 +np.float64,0x7feb13927c362724,0x408632786630c55d,1 +np.float64,0x7fef49e072be93c0,0x408633a08451d476,1 +np.float64,0x3fff23d6337e47ac,0x3ff490ceb6e634ae,1 +np.float64,0x3ffba82cf8f7505a,0x3ff24cc51c73234d,1 +np.float64,0x7fe948719ef290e2,0x408631ec0b36476e,1 +np.float64,0x3ff41926c5e8324e,0x3fe670e14bbda8cd,1 +np.float64,0x3ff91f09c1523e14,0x3ff05cb5731878da,1 +np.float64,0x3ff6ae6afccd5cd6,0x3fec4fbeca764086,1 +np.float64,0x3ff927f7e0f24ff0,0x3ff06413eeb8eb1e,1 +np.float64,0x3ff19dd2b9e33ba5,0x3fdc882f97994600,1 +np.float64,0x7fe8e502c5b1ca05,0x408631cc56526fff,1 +np.float64,0x7feb49f70fb693ed,0x4086328868486fcd,1 +np.float64,0x3ffd942d535b285a,0x3ff398d8d89f52ca,1 +np.float64,0x7fc3b9c5c627738b,0x408624d893e692ca,1 +np.float64,0x7fea0780ff340f01,0x408632279fa46704,1 +np.float64,0x7fe4c90066a99200,0x4086305adb47a598,1 +np.float64,0x7fdb209113364121,0x40862cf0ab64fd7d,1 +np.float64,0x3ff38617e5470c30,0x3fe4ddc0413b524f,1 +np.float64,0x7fea1b5b803436b6,0x4086322db767f091,1 +np.float64,0x7fe2004898e40090,0x40862f3457795dc5,1 +np.float64,0x3ff3c4360ac7886c,0x3fe58c29843a4c75,1 +np.float64,0x3ff504bc168a0978,0x3fe8b9ada7f698e6,1 +np.float64,0x3ffd3e936fda7d27,0x3ff3615912c5b4ac,1 +np.float64,0x3ffbdc52fb97b8a6,0x3ff2718dae5f1f2b,1 +np.float64,0x3fffef6d84ffdedb,0x3ff508adbc8556cf,1 +np.float64,0x3ff23b65272476ca,0x3fe0b646ed2579eb,1 +np.float64,0x7fe4633068a8c660,0x408630334a4b7ff7,1 +np.float64,0x3ff769b754aed36f,0x3fedb932af0223f9,1 +np.float64,0x7fe7482d92ee905a,0x408631432de1b057,1 +np.float64,0x3ff5dd682aabbad0,0x3fea9fd5e506a86d,1 +np.float64,0x7fd68399a2ad0732,0x40862b72ed89805d,1 +np.float64,0x3ffad7acc3d5af5a,0x3ff1b57fe632c948,1 +np.float64,0x3ffc68e43698d1c8,0x3ff2d2be6f758761,1 +np.float64,0x3ff4e517fbc9ca30,0x3fe86eddf5e63a58,1 +np.float64,0x3ff34c63c56698c8,0x3fe435b74ccd6a13,1 +np.float64,0x7fea9456c17528ad,0x4086325275237015,1 +np.float64,0x7fee6573f2fccae7,0x4086336543760346,1 +np.float64,0x7fd5496fb9aa92de,0x40862b0023235667,1 +np.float64,0x7ff0000000000000,0x7ff0000000000000,1 +np.float64,0x3ffb70e31256e1c6,0x3ff22552f54b13e0,1 +np.float64,0x3ff66a33988cd467,0x3febc656da46a1ca,1 +np.float64,0x3fff0af2eb1e15e6,0x3ff481dec325f5c8,1 +np.float64,0x3ff6a0233d0d4046,0x3fec33400958eda1,1 +np.float64,0x7fdb11e2d5b623c5,0x40862cec55e405f9,1 +np.float64,0x3ffb8a015ad71402,0x3ff2374d7b563a72,1 +np.float64,0x3ff1807d8ce300fb,0x3fdb849e4bce8335,1 +np.float64,0x3ffefd535e3dfaa6,0x3ff479aaac6ffe79,1 +np.float64,0x3ff701e23a6e03c4,0x3fecf39072d96fc7,1 +np.float64,0x3ff4ac809f895901,0x3fe7e6598f2335a5,1 +np.float64,0x3ff0309f26a0613e,0x3fc3b3f4b2783690,1 +np.float64,0x3ff241dd0ce483ba,0x3fe0cde2cb639144,1 +np.float64,0x3ffabce63fb579cc,0x3ff1a18fe2a2da59,1 +np.float64,0x3ffd84b967db0973,0x3ff38ee4f240645d,1 +np.float64,0x7fc3f88b9a27f116,0x408624f1e10cdf3f,1 +np.float64,0x7fe1d5fd5923abfa,0x40862f2175714a3a,1 +np.float64,0x7fe487b145690f62,0x4086304190700183,1 +np.float64,0x7fe7997feaef32ff,0x4086315eeefdddd2,1 +np.float64,0x3ff8f853b671f0a8,0x3ff03c907353a8da,1 +np.float64,0x7fca4c23b5349846,0x408627257ace5778,1 +np.float64,0x7fe0c9bf3a21937d,0x40862ea576c3ea43,1 +np.float64,0x7fc442b389288566,0x4086250f5f126ec9,1 +np.float64,0x7fc6d382ed2da705,0x40862603900431b0,1 +np.float64,0x7fe40b069068160c,0x4086301066468124,1 +np.float64,0x3ff7f62a146fec54,0x3feeba8dfc4363fe,1 +np.float64,0x3ff721e8e94e43d2,0x3fed313a6755d34f,1 +np.float64,0x7fe579feaf2af3fc,0x4086309ddefb6112,1 +np.float64,0x3ffe2c6bde5c58d8,0x3ff3f9665dc9a16e,1 +np.float64,0x7fcf9998ed3f3331,0x4086289dab274788,1 +np.float64,0x7fdb03af2236075d,0x40862ce82252e490,1 +np.float64,0x7fe72799392e4f31,0x40863137f428ee71,1 +np.float64,0x7f9f2190603e4320,0x408617dc5b3b3c3c,1 +np.float64,0x3ff69c56d52d38ae,0x3fec2ba59fe938b2,1 +np.float64,0x7fdcde27bf39bc4e,0x40862d70086cd06d,1 +np.float64,0x3ff654d6b8eca9ae,0x3feb9aa0107609a6,1 +np.float64,0x7fdf69d967bed3b2,0x40862e1d1c2b94c2,1 +np.float64,0xffefffffffffffff,0xfff8000000000000,1 +np.float64,0x7fedfd073f3bfa0d,0x40863349980c2c8b,1 +np.float64,0x7f7c1856803830ac,0x40860bf312b458c7,1 +np.float64,0x7fe9553f1bb2aa7d,0x408631f0173eadd5,1 +np.float64,0x3ff6e92efc2dd25e,0x3fecc38f98e7e1a7,1 +np.float64,0x7fe9719ac532e335,0x408631f906cd79c3,1 +np.float64,0x3ff60e56ae4c1cad,0x3feb07ef8637ec7e,1 +np.float64,0x3ff0d0803501a100,0x3fd455c0af195a9c,1 +np.float64,0x7fe75248a3eea490,0x40863146a614aec1,1 +np.float64,0x7fdff61ead3fec3c,0x40862e408643d7aa,1 +np.float64,0x7fed4ac7a4fa958e,0x408633197b5cf6ea,1 +np.float64,0x7fe58d44562b1a88,0x408630a5098d1bbc,1 +np.float64,0x7fd89dcdb1b13b9a,0x40862c29c2979288,1 +np.float64,0x3ff205deda240bbe,0x3fdfda67c84fd3a8,1 +np.float64,0x7fdf84c15abf0982,0x40862e23f361923d,1 +np.float64,0x3ffe012b3afc0256,0x3ff3de3dfa5f47ce,1 +np.float64,0x3ffe2f3512dc5e6a,0x3ff3fb245206398e,1 +np.float64,0x7fed6174c2bac2e9,0x4086331faa699617,1 +np.float64,0x3ff1f30f8783e61f,0x3fdf47e06f2c40d1,1 +np.float64,0x3ff590da9eab21b5,0x3fe9f8f7b4baf3c2,1 +np.float64,0x3ffb3ca1eb967944,0x3ff1ff9baf66d704,1 +np.float64,0x7fe50ba9a5aa1752,0x408630745ab7fd3c,1 +np.float64,0x3ff43743a4a86e87,0x3fe6bf7ae80b1dda,1 +np.float64,0x3ff47e1a24e8fc34,0x3fe773acca44c7d6,1 +np.float64,0x3ff589ede9eb13dc,0x3fe9e99f28fab3a4,1 +np.float64,0x3ff72f2cbf8e5e5a,0x3fed4a94e7edbf24,1 +np.float64,0x3ffa4f9bbc549f38,0x3ff14ee60aea45d3,1 +np.float64,0x3ff975dae732ebb6,0x3ff0a3a1fbd7284a,1 +np.float64,0x7fbcf14ee039e29d,0x4086225e33f3793e,1 +np.float64,0x3ff10e027f621c05,0x3fd71cce2452b4e0,1 +np.float64,0x3ff33ea193067d43,0x3fe40cbac4daaddc,1 +np.float64,0x7fbef8f2263df1e3,0x408622e905c8e1b4,1 +np.float64,0x3fff7f5bfe3efeb8,0x3ff4c732e83df253,1 +np.float64,0x3ff5700a6b4ae015,0x3fe9afdd7b8b82b0,1 +np.float64,0x3ffd5099da5aa134,0x3ff36d1bf26e55bf,1 +np.float64,0x3ffed8e0f89db1c2,0x3ff4639ff065107a,1 +np.float64,0x3fff9d0c463f3a18,0x3ff4d8a9f297cf52,1 +np.float64,0x3ff23db5b2e47b6b,0x3fe0bebdd48f961a,1 +np.float64,0x3ff042bff1e08580,0x3fc713bf24cc60ef,1 +np.float64,0x7feb4fe97a769fd2,0x4086328a26675646,1 +np.float64,0x3ffeafbfeedd5f80,0x3ff44a955a553b1c,1 +np.float64,0x3ff83fb524507f6a,0x3fef3d1729ae0976,1 +np.float64,0x3ff1992294433245,0x3fdc5f5ce53dd197,1 +np.float64,0x7fe89fe629b13fcb,0x408631b601a83867,1 +np.float64,0x7fe53e4d74aa7c9a,0x40863087839b52f1,1 +np.float64,0x3ff113713e6226e2,0x3fd757631ca7cd09,1 +np.float64,0x7fd4a0b7a629416e,0x40862abfba27a09b,1 +np.float64,0x3ff184c6e2a3098e,0x3fdbab2e3966ae57,1 +np.float64,0x3ffafbbf77f5f77f,0x3ff1d02bb331d9f9,1 +np.float64,0x3ffc6099a358c134,0x3ff2cd16941613d1,1 +np.float64,0x3ffb7c441ef6f888,0x3ff22d7b12e31432,1 +np.float64,0x3ff625ba5eec4b75,0x3feb39060e55fb79,1 +np.float64,0x7fde879acbbd0f35,0x40862de2aab4d72d,1 +np.float64,0x7f930aed982615da,0x408613edb6df8528,1 +np.float64,0x7fa4b82dac29705a,0x40861a261c0a9aae,1 +np.float64,0x7fced5c16b3dab82,0x4086286b7a73e611,1 +np.float64,0x7fe133749d2266e8,0x40862ed73a41b112,1 +np.float64,0x3ff2d8146ea5b029,0x3fe2ced55dbf997d,1 +np.float64,0x3ff60dac77ac1b59,0x3feb0688b0e54c7b,1 +np.float64,0x3ff275d9b024ebb3,0x3fe186b87258b834,1 +np.float64,0x3ff533e6500a67cd,0x3fe92746c8b50ddd,1 +np.float64,0x7fe370896666e112,0x40862fd1ca144736,1 +np.float64,0x7fee7695357ced29,0x40863369c459420e,1 +np.float64,0x7fd1e0528023c0a4,0x4086299a85caffd0,1 +np.float64,0x7fd05c7b24a0b8f5,0x408628e52824386f,1 +np.float64,0x3ff11dcc3b023b98,0x3fd7c56c8cef1be1,1 +np.float64,0x7fc9d9fae933b3f5,0x408627027404bc5f,1 +np.float64,0x7fe2359981246b32,0x40862f4be675e90d,1 +np.float64,0x3ffb10a949962152,0x3ff1df88f83b8cde,1 +np.float64,0x3ffa65b53654cb6a,0x3ff15fc8956ccc87,1 +np.float64,0x3ff0000000000000,0x0,1 +np.float64,0x7fad97ef703b2fde,0x40861d002f3d02da,1 +np.float64,0x3ff57aaf93aaf55f,0x3fe9c7b01f194edb,1 +np.float64,0x7fe9ecd73f33d9ad,0x4086321f69917205,1 +np.float64,0x3ff0dcb79c61b96f,0x3fd4eac86a7a9c38,1 +np.float64,0x7fee9c12ffbd3825,0x4086337396cd706d,1 +np.float64,0x3ff52c40af4a5881,0x3fe915a8a7de8f00,1 +np.float64,0x3ffbcfff59779ffe,0x3ff268e523fe8dda,1 +np.float64,0x7fe014cb4b602996,0x40862e4d5de42a03,1 +np.float64,0x7fae2370e83c46e1,0x40861d258dd5b3ee,1 +np.float64,0x7fe9e33602f3c66b,0x4086321c704ac2bb,1 +np.float64,0x3ff648acd74c915a,0x3feb8195ca53bcaa,1 +np.float64,0x7fe385f507670be9,0x40862fda95ebaf44,1 +np.float64,0x3ffb0e382c361c70,0x3ff1ddbea963e0a7,1 +np.float64,0x3ff47d6b6ae8fad7,0x3fe771f80ad37cd2,1 +np.float64,0x3ffca7d538f94faa,0x3ff2fd5f62e851ac,1 +np.float64,0x3ff83e949c107d29,0x3fef3b1c5bbac99b,1 +np.float64,0x7fc6fb933a2df725,0x408626118e51a286,1 +np.float64,0x7fe43a1454e87428,0x4086302318512d9b,1 +np.float64,0x7fe51fe32aaa3fc5,0x4086307c07271348,1 +np.float64,0x3ff35e563966bcac,0x3fe46aa2856ef85f,1 +np.float64,0x3ff84dd4e4909baa,0x3fef55d86d1d5c2e,1 +np.float64,0x7febe3d84077c7b0,0x408632b507686f03,1 +np.float64,0x3ff6aca2e32d5946,0x3fec4c32a2368ee3,1 +np.float64,0x7fe7070e3e6e0e1b,0x4086312caddb0454,1 +np.float64,0x7fd3657f2aa6cafd,0x40862a41acf47e70,1 +np.float64,0x3ff61534456c2a68,0x3feb1663900af13b,1 +np.float64,0x3ff8bc556eb178ab,0x3ff00a16b5403f88,1 +np.float64,0x3ffa7782e3f4ef06,0x3ff16d529c94a438,1 +np.float64,0x7fc15785ed22af0b,0x408623d0cd94fb86,1 +np.float64,0x3ff2e3eeb6e5c7dd,0x3fe2f4c4876d3edf,1 +np.float64,0x3ff2e4e17e85c9c3,0x3fe2f7c9e437b22e,1 +np.float64,0x7feb3aaf67f6755e,0x40863283ec4a0d76,1 +np.float64,0x7fe89efcf7313df9,0x408631b5b5e41263,1 +np.float64,0x3ffcc6fad4f98df6,0x3ff31245778dff6d,1 +np.float64,0x3ff356114466ac22,0x3fe45253d040a024,1 +np.float64,0x3ff81c70d2d038e2,0x3feefed71ebac776,1 +np.float64,0x7fdb75c96136eb92,0x40862d09a603f03e,1 +np.float64,0x3ff340f91b8681f2,0x3fe413bb6e6d4a54,1 +np.float64,0x3fff906079df20c1,0x3ff4d13869d16bc7,1 +np.float64,0x3ff226a42d644d48,0x3fe0698d316f1ac0,1 +np.float64,0x3ff948abc3b29158,0x3ff07eeb0b3c81ba,1 +np.float64,0x3ffc25df1fb84bbe,0x3ff2a4c13ad4edad,1 +np.float64,0x7fe07ea3b960fd46,0x40862e815b4cf43d,1 +np.float64,0x3ff497d3dae92fa8,0x3fe7b3917bf10311,1 +np.float64,0x7fea561db1f4ac3a,0x4086323fa4aef2a9,1 +np.float64,0x7fd1b49051236920,0x40862986d8759ce5,1 +np.float64,0x7f7ba3bd6037477a,0x40860bd19997fd90,1 +np.float64,0x3ff01126dd00224e,0x3fb76b67938dfb11,1 +np.float64,0x3ff29e1105053c22,0x3fe2102a4c5fa102,1 +np.float64,0x3ff9de2a6553bc55,0x3ff0f6cfe4dea30e,1 +np.float64,0x7fc558e7d42ab1cf,0x4086257a608fc055,1 +np.float64,0x3ff79830a74f3061,0x3fee0f93db153d65,1 +np.float64,0x7fe2661648e4cc2c,0x40862f6117a71eb2,1 +np.float64,0x3ff140cf4262819e,0x3fd92aefedae1ab4,1 +np.float64,0x3ff5f36251abe6c5,0x3feaced481ceaee3,1 +np.float64,0x7fc80911d5301223,0x4086266d4757f768,1 +np.float64,0x3ff9079a6c320f35,0x3ff04949d21ebe1e,1 +np.float64,0x3ffde8d2e09bd1a6,0x3ff3cedca8a5db5d,1 +np.float64,0x3ffadd1de375ba3c,0x3ff1b989790e8d93,1 +np.float64,0x3ffdbc40ee1b7882,0x3ff3b286b1c7da57,1 +np.float64,0x3ff8ff514771fea2,0x3ff04264add00971,1 +np.float64,0x7fefd7d0e63fafa1,0x408633c47d9f7ae4,1 +np.float64,0x3ffc47798c588ef3,0x3ff2bbe441fa783a,1 +np.float64,0x7fe6ebc55b6dd78a,0x408631232d9abf31,1 +np.float64,0xbff0000000000000,0xfff8000000000000,1 +np.float64,0x7fd378e4afa6f1c8,0x40862a49a8f98cb4,1 +np.float64,0x0,0xfff8000000000000,1 +np.float64,0x3ffe88ed7efd11db,0x3ff432c7ecb95492,1 +np.float64,0x3ff4f5509289eaa1,0x3fe8955a11656323,1 +np.float64,0x7fda255b41344ab6,0x40862ca53676a23e,1 +np.float64,0x3ffebe85b9bd7d0c,0x3ff453992cd55dea,1 +np.float64,0x3ff5d6180b8bac30,0x3fea901c2160c3bc,1 +np.float64,0x3ffcdfb8fcf9bf72,0x3ff322c83b3bc735,1 +np.float64,0x3ff3c91c26679238,0x3fe599a652b7cf59,1 +np.float64,0x7fc389f7a62713ee,0x408624c518edef93,1 +np.float64,0x3ffe1245ba1c248c,0x3ff3e901b2c4a47a,1 +np.float64,0x7fe1e76e95e3cedc,0x40862f29446f9eff,1 +np.float64,0x3ff02ae4f92055ca,0x3fc28221abd63daa,1 +np.float64,0x7fbf648a143ec913,0x40862304a0619d03,1 +np.float64,0x3ff2be7ef8657cfe,0x3fe27bcc6c97522e,1 +np.float64,0x3ffa7595e514eb2c,0x3ff16bdc64249ad1,1 +np.float64,0x3ff4ee130049dc26,0x3fe884354cbad8c9,1 +np.float64,0x3ff19211fc232424,0x3fdc2160bf3eae40,1 +np.float64,0x3ffec215aedd842c,0x3ff455c4cdd50c32,1 +np.float64,0x7fe7cb50ffaf96a1,0x4086316fc06a53af,1 +np.float64,0x3fffa679161f4cf2,0x3ff4de30ba7ac5b8,1 +np.float64,0x7fdcb459763968b2,0x40862d646a21011d,1 +np.float64,0x3ff9f338d6d3e672,0x3ff1075835d8f64e,1 +np.float64,0x3ff8de3319d1bc66,0x3ff026ae858c0458,1 +np.float64,0x7fee0199d33c0333,0x4086334ad03ac683,1 +np.float64,0x3ffc06076c380c0f,0x3ff28eaec3814faa,1 +np.float64,0x3ffe9e2e235d3c5c,0x3ff43fd4d2191a7f,1 +np.float64,0x3ffd93b06adb2761,0x3ff398888239cde8,1 +np.float64,0x7fefe4b71cffc96d,0x408633c7ba971b92,1 +np.float64,0x7fb2940352252806,0x40861ed244bcfed6,1 +np.float64,0x3ffba4647e3748c9,0x3ff24a15f02e11b9,1 +np.float64,0x7fd2d9543725b2a7,0x40862a0708446596,1 +np.float64,0x7fc04997f120932f,0x4086235055d35251,1 +np.float64,0x3ff6d14313ada286,0x3fec94b177f5d3fc,1 +np.float64,0x3ff279fc8684f3f9,0x3fe19511c3e5b9a8,1 +np.float64,0x3ff42f4609085e8c,0x3fe6aabe526ce2bc,1 +np.float64,0x7fc1c6c62a238d8b,0x408624037de7f6ec,1 +np.float64,0x7fe31ff4b8e63fe8,0x40862fb05b40fd16,1 +np.float64,0x7fd2a8825fa55104,0x408629f234d460d6,1 +np.float64,0x3ffe8c1d725d183b,0x3ff434bdc444143f,1 +np.float64,0x3ff0e9dc3e21d3b8,0x3fd58676e2c13fc9,1 +np.float64,0x3ffed03172fda063,0x3ff45e59f7aa6c8b,1 +np.float64,0x7fd74621962e8c42,0x40862bb6e90d66f8,1 +np.float64,0x3ff1faa29663f545,0x3fdf833a2c5efde1,1 +np.float64,0x7fda02834db40506,0x40862c9a860d6747,1 +np.float64,0x7f709b2fc021365f,0x408607be328eb3eb,1 +np.float64,0x7fec0d58aa381ab0,0x408632c0e61a1af6,1 +np.float64,0x3ff524d1720a49a3,0x3fe90479968d40fd,1 +np.float64,0x7fd64cb3b32c9966,0x40862b5f53c4b0b4,1 +np.float64,0x3ff9593e3ed2b27c,0x3ff08c6eea5f6e8b,1 +np.float64,0x3ff7de8b1f6fbd16,0x3fee9007abcfdf7b,1 +np.float64,0x7fe8d816d6b1b02d,0x408631c82e38a894,1 +np.float64,0x7fd726bbe22e4d77,0x40862bac16ee8d52,1 +np.float64,0x7fa70b07d42e160f,0x40861affcc4265e2,1 +np.float64,0x7fe18b4091e31680,0x40862effa8bce66f,1 +np.float64,0x3ff830253010604a,0x3fef21b2eaa75758,1 +np.float64,0x3fffcade407f95bc,0x3ff4f3734b24c419,1 +np.float64,0x3ff8c17cecb182fa,0x3ff00e75152d7bda,1 +np.float64,0x7fdad9b9d035b373,0x40862cdbabb793ba,1 +np.float64,0x3ff9f9e154f3f3c2,0x3ff10c8dfdbd2510,1 +np.float64,0x3ff465e162e8cbc3,0x3fe736c751c75b73,1 +np.float64,0x3ff9b4cd8493699b,0x3ff0d616235544b8,1 +np.float64,0x7fe557c4a56aaf88,0x4086309114ed12d9,1 +np.float64,0x7fe5999133eb3321,0x408630a9991a9b54,1 +np.float64,0x7fe7c9009e2f9200,0x4086316ef9359a47,1 +np.float64,0x3ff8545cabd0a8ba,0x3fef6141f1030c36,1 +np.float64,0x3ffa1f1712943e2e,0x3ff129849d492ce3,1 +np.float64,0x7fea803a14750073,0x4086324c652c276c,1 +np.float64,0x3ff5b6f97fcb6df3,0x3fea4cb0b97b18e9,1 +np.float64,0x7fc2efdfc425dfbf,0x40862485036a5c6e,1 +np.float64,0x7fe2c78e5be58f1c,0x40862f8b0a5e7baf,1 +np.float64,0x7fe80d7fff301aff,0x40863185e234060a,1 +np.float64,0x3ffd895d457b12ba,0x3ff391e2cac7a3f8,1 +np.float64,0x3ff44c9764a8992f,0x3fe6f6690396c232,1 +np.float64,0x3ff731688b8e62d1,0x3fed4ed70fac3839,1 +np.float64,0x3ff060200460c040,0x3fcbad4a07d97f0e,1 +np.float64,0x3ffbd2f70a17a5ee,0x3ff26afb46ade929,1 +np.float64,0x7febe9e841f7d3d0,0x408632b6c465ddd9,1 +np.float64,0x3ff2532f8be4a65f,0x3fe10c6cd8d64cf4,1 +np.float64,0x7fefffffffffffff,0x408633ce8fb9f87e,1 +np.float64,0x3ff3a1ae3a47435c,0x3fe52c00210cc459,1 +np.float64,0x7fe9c34ae6b38695,0x408632128d150149,1 +np.float64,0x3fff311029fe6220,0x3ff498b852f30bff,1 +np.float64,0x3ffd4485a1ba890c,0x3ff3653b6fa701cd,1 +np.float64,0x7fd52718b1aa4e30,0x40862af330d9c68c,1 +np.float64,0x3ff10b695a4216d3,0x3fd7009294e367b7,1 +np.float64,0x3ffdf73de59bee7c,0x3ff3d7fa96d2c1ae,1 +np.float64,0x3ff2f1c75965e38f,0x3fe320aaff3db882,1 +np.float64,0x3ff2a56a5a854ad5,0x3fe228cc4ad7e7a5,1 +np.float64,0x7fe60cd1cf6c19a3,0x408630d3d87a04b3,1 +np.float64,0x3ff89fa65c113f4c,0x3fefe3543773180c,1 +np.float64,0x3ffd253130ba4a62,0x3ff350b76ba692a0,1 +np.float64,0x7feaad7051f55ae0,0x40863259ff932d62,1 +np.float64,0x7fd9cc37cf33986f,0x40862c89c15f963b,1 +np.float64,0x3ff8c08de771811c,0x3ff00daa9c17acd7,1 +np.float64,0x7fea58b25d34b164,0x408632406d54cc6f,1 +np.float64,0x7fe5f161fd2be2c3,0x408630c9ddf272a5,1 +np.float64,0x3ff5840dbf8b081c,0x3fe9dc9117b4cbc7,1 +np.float64,0x3ff3fd762307faec,0x3fe6277cd530c640,1 +np.float64,0x3ff9095c98b212b9,0x3ff04abff170ac24,1 +np.float64,0x7feaac66017558cb,0x40863259afb4f8ce,1 +np.float64,0x7fd78f96bcaf1f2c,0x40862bd00175fdf9,1 +np.float64,0x3ffaca27e0959450,0x3ff1ab72b8f8633e,1 +np.float64,0x3ffb7f18cb96fe32,0x3ff22f81bcb8907b,1 +np.float64,0x3ffcce48d1199c92,0x3ff317276f62c0b2,1 +np.float64,0x3ffcb9a7f3797350,0x3ff30958e0d6a34d,1 +np.float64,0x7fda569ef6b4ad3d,0x40862cb43b33275a,1 +np.float64,0x7fde9f0893bd3e10,0x40862de8cc036283,1 +np.float64,0x3ff428be3928517c,0x3fe699bb5ab58904,1 +np.float64,0x7fa4d3344029a668,0x40861a3084989291,1 +np.float64,0x3ff03607bd006c0f,0x3fc4c4840cf35f48,1 +np.float64,0x3ff2b1335c056267,0x3fe25000846b75a2,1 +np.float64,0x7fe0cb8bd8e19717,0x40862ea65237d496,1 +np.float64,0x3fff4b1b7b9e9637,0x3ff4a83fb08e7b24,1 +np.float64,0x7fe7526140aea4c2,0x40863146ae86069c,1 +np.float64,0x7fbfcfb7c23f9f6f,0x4086231fc246ede5,1 diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/data/umath-validation-set-arcsin.csv b/venv/lib/python3.12/site-packages/numpy/_core/tests/data/umath-validation-set-arcsin.csv new file mode 100644 index 00000000..75d57072 --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/tests/data/umath-validation-set-arcsin.csv @@ -0,0 +1,1429 @@ +dtype,input,output,ulperrortol +np.float32,0xbe7d3a7c,0xbe7fe217,4 +np.float32,0x3dc102f0,0x3dc14c60,4 +np.float32,0xbe119c28,0xbe121aef,4 +np.float32,0xbe51cd68,0xbe534c75,4 +np.float32,0x3c04a300,0x3c04a35f,4 +np.float32,0xbf4f0b62,0xbf712a69,4 +np.float32,0x3ef61a5c,0x3f005cf6,4 +np.float32,0xbf13024c,0xbf1c97df,4 +np.float32,0x3e93b580,0x3e95d6b5,4 +np.float32,0x3e44e7b8,0x3e4623a5,4 +np.float32,0xbe35df20,0xbe36d773,4 +np.float32,0x3eecd2c0,0x3ef633cf,4 +np.float32,0x3f2772ba,0x3f36862a,4 +np.float32,0x3e211ea8,0x3e21cac5,4 +np.float32,0x3e3b3d90,0x3e3c4cc6,4 +np.float32,0x3f37c962,0x3f4d018c,4 +np.float32,0x3e92ad88,0x3e94c31a,4 +np.float32,0x3f356ffc,0x3f49a766,4 +np.float32,0x3f487ba2,0x3f665254,4 +np.float32,0x3f061c46,0x3f0d27ae,4 +np.float32,0xbee340a2,0xbeeb7722,4 +np.float32,0xbe85aede,0xbe874026,4 +np.float32,0x3f34cf9a,0x3f48c474,4 +np.float32,0x3e29a690,0x3e2a6fbd,4 +np.float32,0xbeb29428,0xbeb669d1,4 +np.float32,0xbe606d40,0xbe624370,4 +np.float32,0x3dae6860,0x3dae9e85,4 +np.float32,0xbf04872b,0xbf0b4d25,4 +np.float32,0x3f2080e2,0x3f2d7ab0,4 +np.float32,0xbec77dcc,0xbecceb27,4 +np.float32,0x3e0dda10,0x3e0e4f38,4 +np.float32,0xbefaf970,0xbf03262c,4 +np.float32,0x3f576a0c,0x3f7ffee6,4 +np.float32,0x3f222382,0x3f2f95d6,4 +np.float32,0x7fc00000,0x7fc00000,4 +np.float32,0x3e41c468,0x3e42f14e,4 +np.float32,0xbf2f64dd,0xbf4139a8,4 +np.float32,0xbf60ef90,0xbf895956,4 +np.float32,0xbf67c855,0xbf90eff0,4 +np.float32,0xbed35aee,0xbed9df00,4 +np.float32,0xbf2c7d92,0xbf3d448f,4 +np.float32,0x3f7b1604,0x3faff122,4 +np.float32,0xbf7c758b,0xbfb3bf87,4 +np.float32,0x3ecda1c8,0x3ed39acf,4 +np.float32,0x3f3af8ae,0x3f519fcb,4 +np.float32,0xbf16e6a3,0xbf2160fd,4 +np.float32,0x3f0c97d2,0x3f14d668,4 +np.float32,0x3f0a8060,0x3f1257b9,4 +np.float32,0x3f27905a,0x3f36ad57,4 +np.float32,0x3eeaeba4,0x3ef40efe,4 +np.float32,0x3e58dde0,0x3e5a8580,4 +np.float32,0xbf0cabe2,0xbf14ee6b,4 +np.float32,0xbe805ca8,0xbe81bf03,4 +np.float32,0x3f5462ba,0x3f7a7b85,4 +np.float32,0xbee235d0,0xbeea4d8b,4 +np.float32,0xbe880cb0,0xbe89b426,4 +np.float32,0x80000001,0x80000001,4 +np.float32,0x3f208c00,0x3f2d88f6,4 +np.float32,0xbf34f3d2,0xbf48f7a2,4 +np.float32,0x3f629428,0x3f8b1763,4 +np.float32,0xbf52a900,0xbf776b4a,4 +np.float32,0xbd17f8d0,0xbd1801be,4 +np.float32,0xbef7cada,0xbf0153d1,4 +np.float32,0x3f7d3b90,0x3fb63967,4 +np.float32,0xbd6a20b0,0xbd6a4160,4 +np.float32,0x3f740496,0x3fa1beb7,4 +np.float32,0x3ed8762c,0x3edf7dd9,4 +np.float32,0x3f53b066,0x3f793d42,4 +np.float32,0xbe9de718,0xbea084f9,4 +np.float32,0x3ea3ae90,0x3ea69b4b,4 +np.float32,0x3f1b8f00,0x3f273183,4 +np.float32,0x3f5cd6ac,0x3f852ead,4 +np.float32,0x3f29d510,0x3f39b169,4 +np.float32,0x3ee2a934,0x3eeace33,4 +np.float32,0x3eecac94,0x3ef608c2,4 +np.float32,0xbea915e2,0xbeac5203,4 +np.float32,0xbd316e90,0xbd317cc8,4 +np.float32,0xbf70b495,0xbf9c97b6,4 +np.float32,0xbe80d976,0xbe823ff3,4 +np.float32,0x3e9205f8,0x3e94143f,4 +np.float32,0x3f49247e,0x3f676296,4 +np.float32,0x3d9030c0,0x3d904f50,4 +np.float32,0x3e4df058,0x3e4f5a5c,4 +np.float32,0xbe1fd360,0xbe207b58,4 +np.float32,0xbf69dc7c,0xbf937006,4 +np.float32,0x3f36babe,0x3f4b7df3,4 +np.float32,0xbe8c9758,0xbe8e6bb7,4 +np.float32,0xbf4de72d,0xbf6f3c20,4 +np.float32,0xbecdad68,0xbed3a780,4 +np.float32,0xbf73e2cf,0xbfa18702,4 +np.float32,0xbece16a8,0xbed41a75,4 +np.float32,0x3f618a96,0x3f89fc6d,4 +np.float32,0xbf325853,0xbf454ea9,4 +np.float32,0x3f138568,0x3f1d3828,4 +np.float32,0xbf56a6e9,0xbf7e9748,4 +np.float32,0x3ef5d594,0x3f0035bf,4 +np.float32,0xbf408220,0xbf59dfaa,4 +np.float32,0xbed120e6,0xbed76dd5,4 +np.float32,0xbf6dbda5,0xbf986cee,4 +np.float32,0x3f744a38,0x3fa23282,4 +np.float32,0xbe4b56d8,0xbe4cb329,4 +np.float32,0x3f54c5f2,0x3f7b2d97,4 +np.float32,0xbd8b1c90,0xbd8b3801,4 +np.float32,0x3ee19a48,0x3ee9a03b,4 +np.float32,0x3f48460e,0x3f65fc3d,4 +np.float32,0x3eb541c0,0x3eb9461e,4 +np.float32,0xbea7d098,0xbeaaf98c,4 +np.float32,0xbda99e40,0xbda9d00c,4 +np.float32,0xbefb2ca6,0xbf03438d,4 +np.float32,0x3f4256be,0x3f5cab0b,4 +np.float32,0xbdbdb198,0xbdbdf74d,4 +np.float32,0xbf325b5f,0xbf4552e9,4 +np.float32,0xbf704d1a,0xbf9c00b4,4 +np.float32,0x3ebb1d04,0x3ebf8cf8,4 +np.float32,0xbed03566,0xbed66bf1,4 +np.float32,0x3e8fcee8,0x3e91c501,4 +np.float32,0xbf2e1eec,0xbf3f7b9d,4 +np.float32,0x3f33c4d2,0x3f474cac,4 +np.float32,0x3f598ef4,0x3f8201b4,4 +np.float32,0x3e09bb30,0x3e0a2660,4 +np.float32,0x3ed4e228,0x3edb8cdb,4 +np.float32,0x3eb7a190,0x3ebbd0a1,4 +np.float32,0xbd9ae630,0xbd9b0c18,4 +np.float32,0x3f43020e,0x3f5db2d7,4 +np.float32,0xbec06ac0,0xbec542d4,4 +np.float32,0x3f3dfde0,0x3f561674,4 +np.float32,0xbf64084a,0xbf8cabe6,4 +np.float32,0xbd6f95b0,0xbd6fb8b7,4 +np.float32,0x3f268640,0x3f354e2d,4 +np.float32,0xbe72b4bc,0xbe7509b2,4 +np.float32,0xbf3414fa,0xbf47bd5a,4 +np.float32,0xbf375218,0xbf4c566b,4 +np.float32,0x3f203c1a,0x3f2d2273,4 +np.float32,0xbd503530,0xbd504c2b,4 +np.float32,0xbc45e540,0xbc45e67b,4 +np.float32,0xbf175c4f,0xbf21f2c6,4 +np.float32,0x3f7432a6,0x3fa20b2b,4 +np.float32,0xbf43367f,0xbf5e03d8,4 +np.float32,0x3eb3997c,0x3eb780c4,4 +np.float32,0x3e5574c8,0x3e570878,4 +np.float32,0xbf04b57b,0xbf0b8349,4 +np.float32,0x3f6216d8,0x3f8a914b,4 +np.float32,0xbf57a237,0xbf80337d,4 +np.float32,0xbee1403a,0xbee93bee,4 +np.float32,0xbeaf9b9a,0xbeb33f3b,4 +np.float32,0xbf109374,0xbf19a223,4 +np.float32,0xbeae6824,0xbeb1f810,4 +np.float32,0xbcff9320,0xbcff9dbe,4 +np.float32,0x3ed205c0,0x3ed868a9,4 +np.float32,0x3d897c30,0x3d8996ad,4 +np.float32,0xbf2899d2,0xbf380d4c,4 +np.float32,0xbf54cb0b,0xbf7b36c2,4 +np.float32,0x3ea8e8ec,0x3eac2262,4 +np.float32,0x3ef5e1a0,0x3f003c9d,4 +np.float32,0xbf00c81e,0xbf06f1e2,4 +np.float32,0xbf346775,0xbf483181,4 +np.float32,0x3f7a4fe4,0x3fae077c,4 +np.float32,0x3f00776e,0x3f06948f,4 +np.float32,0xbe0a3078,0xbe0a9cbc,4 +np.float32,0xbeba0b06,0xbebe66be,4 +np.float32,0xbdff4e38,0xbdfff8b2,4 +np.float32,0xbe927f70,0xbe9492ff,4 +np.float32,0x3ebb07e0,0x3ebf7642,4 +np.float32,0x3ebcf8e0,0x3ec18c95,4 +np.float32,0x3f49bdfc,0x3f685b51,4 +np.float32,0x3cbc29c0,0x3cbc2dfd,4 +np.float32,0xbe9e951a,0xbea13bf1,4 +np.float32,0xbe8c237c,0xbe8df33d,4 +np.float32,0x3e17f198,0x3e1881c4,4 +np.float32,0xbd0b5220,0xbd0b5902,4 +np.float32,0xbf34c4a2,0xbf48b4f5,4 +np.float32,0xbedaa814,0xbee1ea94,4 +np.float32,0x3ebf5d6c,0x3ec42053,4 +np.float32,0x3cd04b40,0x3cd050ff,4 +np.float32,0xbec33fe0,0xbec85244,4 +np.float32,0xbf00b27a,0xbf06d8d8,4 +np.float32,0x3f15d7be,0x3f201243,4 +np.float32,0xbe3debd0,0xbe3f06f7,4 +np.float32,0xbea81704,0xbeab4418,4 +np.float32,0x1,0x1,4 +np.float32,0x3f49e6ba,0x3f689d8b,4 +np.float32,0x3f351030,0x3f491fc0,4 +np.float32,0x3e607de8,0x3e625482,4 +np.float32,0xbe8dbbe4,0xbe8f9c0e,4 +np.float32,0x3edbf350,0x3ee35924,4 +np.float32,0xbf0c84c4,0xbf14bf9c,4 +np.float32,0x3eb218b0,0x3eb5e61a,4 +np.float32,0x3e466dd0,0x3e47b138,4 +np.float32,0xbe8ece94,0xbe90ba01,4 +np.float32,0xbe82ec2a,0xbe84649a,4 +np.float32,0xbf7e1f10,0xbfb98b9e,4 +np.float32,0xbf2d00ea,0xbf3df688,4 +np.float32,0x3db7cdd0,0x3db80d36,4 +np.float32,0xbe388b98,0xbe398f25,4 +np.float32,0xbd86cb40,0xbd86e436,4 +np.float32,0x7f7fffff,0x7fc00000,4 +np.float32,0x3f472a60,0x3f6436c6,4 +np.float32,0xbf5b2c1d,0xbf838d87,4 +np.float32,0x3f0409ea,0x3f0abad8,4 +np.float32,0x3f47dd0e,0x3f6553f0,4 +np.float32,0x3e3eab00,0x3e3fc98a,4 +np.float32,0xbf7c2a7f,0xbfb2e19b,4 +np.float32,0xbeda0048,0xbee13112,4 +np.float32,0x3f46600a,0x3f62f5b2,4 +np.float32,0x3f45aef4,0x3f61de43,4 +np.float32,0x3dd40a50,0x3dd46bc4,4 +np.float32,0xbf6cdd0b,0xbf974191,4 +np.float32,0x3f78de4c,0x3faac725,4 +np.float32,0x3f3c39a4,0x3f53777f,4 +np.float32,0xbe2a30ec,0xbe2afc0b,4 +np.float32,0xbf3c0ef0,0xbf533887,4 +np.float32,0x3ecb6548,0x3ed12a53,4 +np.float32,0x3eb994e8,0x3ebde7fc,4 +np.float32,0x3d4c1ee0,0x3d4c3487,4 +np.float32,0xbf52cb6d,0xbf77a7eb,4 +np.float32,0x3eb905d4,0x3ebd4e80,4 +np.float32,0x3e712428,0x3e736d72,4 +np.float32,0xbf79ee6e,0xbfad22be,4 +np.float32,0x3de6f8b0,0x3de776c1,4 +np.float32,0x3e9b2898,0x3e9da325,4 +np.float32,0x3ea09b20,0x3ea35d20,4 +np.float32,0x3d0ea9a0,0x3d0eb103,4 +np.float32,0xbd911500,0xbd913423,4 +np.float32,0x3e004618,0x3e009c97,4 +np.float32,0x3f5e0e5a,0x3f86654c,4 +np.float32,0x3f2e6300,0x3f3fd88b,4 +np.float32,0x3e0cf5d0,0x3e0d68c3,4 +np.float32,0x3d6a16c0,0x3d6a376c,4 +np.float32,0x3f7174aa,0x3f9db53c,4 +np.float32,0xbe04bba0,0xbe051b81,4 +np.float32,0xbe6fdcb4,0xbe721c92,4 +np.float32,0x3f4379f0,0x3f5e6c31,4 +np.float32,0xbf680098,0xbf913257,4 +np.float32,0xbf3c31ca,0xbf536bea,4 +np.float32,0x3f59db58,0x3f824a4e,4 +np.float32,0xbf3ffc84,0xbf591554,4 +np.float32,0x3d1d5160,0x3d1d5b48,4 +np.float32,0x3f6c64ae,0x3f96a3da,4 +np.float32,0xbf1b49fd,0xbf26daaa,4 +np.float32,0x3ec80be0,0x3ecd8576,4 +np.float32,0x3f3becc0,0x3f530629,4 +np.float32,0xbea93890,0xbeac76c1,4 +np.float32,0x3f5b3acc,0x3f839bbd,4 +np.float32,0xbf5d6818,0xbf85bef9,4 +np.float32,0x3f794266,0x3fab9fa6,4 +np.float32,0xbee8eb7c,0xbef1cf3b,4 +np.float32,0xbf360a06,0xbf4a821e,4 +np.float32,0x3f441cf6,0x3f5f693d,4 +np.float32,0x3e60de40,0x3e62b742,4 +np.float32,0xbebb3d7e,0xbebfafdc,4 +np.float32,0x3e56a3a0,0x3e583e28,4 +np.float32,0x3f375bfe,0x3f4c6499,4 +np.float32,0xbf384d7d,0xbf4dbf9a,4 +np.float32,0x3efb03a4,0x3f032c06,4 +np.float32,0x3f1d5d10,0x3f29794d,4 +np.float32,0xbe25f7dc,0xbe26b41d,4 +np.float32,0x3f6d2f88,0x3f97aebb,4 +np.float32,0xbe9fa100,0xbea255cb,4 +np.float32,0xbf21dafa,0xbf2f382a,4 +np.float32,0x3d3870e0,0x3d3880d9,4 +np.float32,0x3eeaf00c,0x3ef413f4,4 +np.float32,0xbc884ea0,0xbc88503c,4 +np.float32,0xbf7dbdad,0xbfb80b6d,4 +np.float32,0xbf4eb713,0xbf709b46,4 +np.float32,0xbf1c0ad4,0xbf27cd92,4 +np.float32,0x3f323088,0x3f451737,4 +np.float32,0x3e405d88,0x3e4183e1,4 +np.float32,0x3d7ad580,0x3d7afdb4,4 +np.float32,0xbf207338,0xbf2d6927,4 +np.float32,0xbecf7948,0xbed59e1a,4 +np.float32,0x3f16ff94,0x3f217fde,4 +np.float32,0xbdf19588,0xbdf225dd,4 +np.float32,0xbf4d9654,0xbf6eb442,4 +np.float32,0xbf390b9b,0xbf4ed220,4 +np.float32,0xbe155a74,0xbe15e354,4 +np.float32,0x3f519e4c,0x3f759850,4 +np.float32,0xbee3f08c,0xbeec3b84,4 +np.float32,0xbf478be7,0xbf64d23b,4 +np.float32,0xbefdee50,0xbf04d92a,4 +np.float32,0x3e8def78,0x3e8fd1bc,4 +np.float32,0x3e3df2a8,0x3e3f0dee,4 +np.float32,0xbf413e22,0xbf5afd97,4 +np.float32,0xbf1b8bc4,0xbf272d71,4 +np.float32,0xbf31e5be,0xbf44af22,4 +np.float32,0x3de7e080,0x3de86010,4 +np.float32,0xbf5ddf7e,0xbf863645,4 +np.float32,0x3f3eba6a,0x3f57306e,4 +np.float32,0xff7fffff,0x7fc00000,4 +np.float32,0x3ec22d5c,0x3ec72973,4 +np.float32,0x80800000,0x80800000,4 +np.float32,0x3f032e0c,0x3f09ba82,4 +np.float32,0x3d74bd60,0x3d74e2b7,4 +np.float32,0xbea0d61e,0xbea39b42,4 +np.float32,0xbefdfa78,0xbf04e02a,4 +np.float32,0x3e5cb220,0x3e5e70ec,4 +np.float32,0xbe239e54,0xbe2452a4,4 +np.float32,0x3f452738,0x3f61090e,4 +np.float32,0x3e99a2e0,0x3e9c0a66,4 +np.float32,0x3e4394d8,0x3e44ca5f,4 +np.float32,0x3f4472e2,0x3f5fef14,4 +np.float32,0xbf46bc70,0xbf638814,4 +np.float32,0xbf0b910f,0xbf139c7a,4 +np.float32,0x3f36b4a6,0x3f4b753f,4 +np.float32,0x3e0bf478,0x3e0c64f6,4 +np.float32,0x3ce02480,0x3ce02ba9,4 +np.float32,0xbd904b10,0xbd9069b1,4 +np.float32,0xbf7f5d72,0xbfc00b70,4 +np.float32,0x3f62127e,0x3f8a8ca8,4 +np.float32,0xbf320253,0xbf44d6e4,4 +np.float32,0x3f2507be,0x3f335833,4 +np.float32,0x3f299284,0x3f395887,4 +np.float32,0xbd8211b0,0xbd82281d,4 +np.float32,0xbd3374c0,0xbd338376,4 +np.float32,0x3f36c56a,0x3f4b8d30,4 +np.float32,0xbf51f704,0xbf76331f,4 +np.float32,0xbe9871ca,0xbe9acab2,4 +np.float32,0xbe818d8c,0xbe82fa0f,4 +np.float32,0x3f08b958,0x3f103c18,4 +np.float32,0x3f22559a,0x3f2fd698,4 +np.float32,0xbf11f388,0xbf1b4db8,4 +np.float32,0x3ebe1990,0x3ec2c359,4 +np.float32,0xbe75ab38,0xbe7816b6,4 +np.float32,0x3e96102c,0x3e984c99,4 +np.float32,0xbe80d9d2,0xbe824052,4 +np.float32,0x3ef47588,0x3efeda7f,4 +np.float32,0xbe45e524,0xbe4725ea,4 +np.float32,0x3f7f9e7a,0x3fc213ff,4 +np.float32,0x3f1d3c36,0x3f294faa,4 +np.float32,0xbf3c58db,0xbf53a591,4 +np.float32,0x3f0d3d20,0x3f159c69,4 +np.float32,0x3f744be6,0x3fa23552,4 +np.float32,0x3f2e0cea,0x3f3f630e,4 +np.float32,0x3e193c10,0x3e19cff7,4 +np.float32,0xbf4150ac,0xbf5b19dd,4 +np.float32,0xbf145f72,0xbf1e4355,4 +np.float32,0xbb76cc00,0xbb76cc26,4 +np.float32,0x3f756780,0x3fa41b3e,4 +np.float32,0x3ea9b868,0x3eacfe3c,4 +np.float32,0x3d07c920,0x3d07cf7f,4 +np.float32,0xbf2263d4,0xbf2fe8ff,4 +np.float32,0x3e53b3f8,0x3e553daa,4 +np.float32,0xbf785be8,0xbfa9b5ba,4 +np.float32,0x3f324f7a,0x3f454254,4 +np.float32,0xbf2188f2,0xbf2ece5b,4 +np.float32,0xbe33781c,0xbe3466a2,4 +np.float32,0xbd3cf120,0xbd3d024c,4 +np.float32,0x3f06b18a,0x3f0dd70f,4 +np.float32,0x3f40d63e,0x3f5a5f6a,4 +np.float32,0x3f752340,0x3fa3a41e,4 +np.float32,0xbe1cf1c0,0xbe1d90bc,4 +np.float32,0xbf02d948,0xbf0957d7,4 +np.float32,0x3f73bed0,0x3fa14bf7,4 +np.float32,0x3d914920,0x3d916864,4 +np.float32,0x7fa00000,0x7fe00000,4 +np.float32,0xbe67a5d8,0xbe69aba7,4 +np.float32,0x3f689c4a,0x3f91eb9f,4 +np.float32,0xbf196e00,0xbf248601,4 +np.float32,0xbf50dacb,0xbf7444fe,4 +np.float32,0x3f628b86,0x3f8b0e1e,4 +np.float32,0x3f6ee2f2,0x3f99fe7f,4 +np.float32,0x3ee5df40,0x3eee6492,4 +np.float32,0x3f501746,0x3f72f41b,4 +np.float32,0xbf1f0f18,0xbf2ba164,4 +np.float32,0xbf1a8bfd,0xbf25ec01,4 +np.float32,0xbd4926f0,0xbd493ba9,4 +np.float32,0xbf4e364f,0xbf6fc17b,4 +np.float32,0x3e50c578,0x3e523ed4,4 +np.float32,0x3f65bf10,0x3f8e95ce,4 +np.float32,0xbe8d75a2,0xbe8f52f2,4 +np.float32,0xbf3f557e,0xbf581962,4 +np.float32,0xbeff2bfc,0xbf05903a,4 +np.float32,0x3f5e8bde,0x3f86e3d8,4 +np.float32,0xbf7a0012,0xbfad4b9b,4 +np.float32,0x3edefce0,0x3ee6b790,4 +np.float32,0xbf0003de,0xbf060f09,4 +np.float32,0x3efc4650,0x3f03e548,4 +np.float32,0x3f4582e4,0x3f6198f5,4 +np.float32,0x3f10086c,0x3f18f9d0,4 +np.float32,0x3f1cd304,0x3f28ca77,4 +np.float32,0x3f683366,0x3f916e8d,4 +np.float32,0xbed49392,0xbedb3675,4 +np.float32,0xbf6fe5f6,0xbf9b6c0e,4 +np.float32,0xbf59b416,0xbf8224f6,4 +np.float32,0x3d20c960,0x3d20d3f4,4 +np.float32,0x3f6b00d6,0x3f94dbe7,4 +np.float32,0x3f6c26ae,0x3f965352,4 +np.float32,0xbf370ea6,0xbf4bf5dd,4 +np.float32,0x3dfe7230,0x3dff1af1,4 +np.float32,0xbefc21a8,0xbf03d038,4 +np.float32,0x3f16a990,0x3f21156a,4 +np.float32,0xbef8ac0c,0xbf01d48f,4 +np.float32,0x3f170de8,0x3f21919d,4 +np.float32,0x3db9ef80,0x3dba3122,4 +np.float32,0x3d696400,0x3d698461,4 +np.float32,0x3f007aa2,0x3f069843,4 +np.float32,0x3f22827c,0x3f3010a9,4 +np.float32,0x3f3650dc,0x3f4ae6f1,4 +np.float32,0xbf1d8037,0xbf29a5e1,4 +np.float32,0xbf08fdc4,0xbf108d0e,4 +np.float32,0xbd8df350,0xbd8e1079,4 +np.float32,0xbf36bb32,0xbf4b7e98,4 +np.float32,0x3f2e3756,0x3f3f9ced,4 +np.float32,0x3d5a6f20,0x3d5a89aa,4 +np.float32,0x3f55d568,0x3f7d1889,4 +np.float32,0x3e1ed110,0x3e1f75d9,4 +np.float32,0x3e7386b8,0x3e75e1dc,4 +np.float32,0x3f48ea0e,0x3f670434,4 +np.float32,0x3e921fb0,0x3e942f14,4 +np.float32,0xbf0d4d0b,0xbf15af7f,4 +np.float32,0x3f179ed2,0x3f224549,4 +np.float32,0xbf3a328e,0xbf507e6d,4 +np.float32,0xbf74591a,0xbfa24b6e,4 +np.float32,0x3ec7d1c4,0x3ecd4657,4 +np.float32,0xbf6ecbed,0xbf99de85,4 +np.float32,0x3db0bd00,0x3db0f559,4 +np.float32,0x7f800000,0x7fc00000,4 +np.float32,0x3e0373b8,0x3e03d0d6,4 +np.float32,0xbf439784,0xbf5e9a04,4 +np.float32,0xbef97a9e,0xbf024ac6,4 +np.float32,0x3e4d71a8,0x3e4ed90a,4 +np.float32,0xbf14d868,0xbf1ed7e3,4 +np.float32,0xbf776870,0xbfa7ce37,4 +np.float32,0xbe32a500,0xbe339038,4 +np.float32,0xbf326d8a,0xbf456c3d,4 +np.float32,0xbe9b758c,0xbe9df3e7,4 +np.float32,0x3d9515a0,0x3d95376a,4 +np.float32,0x3e3f7320,0x3e40953e,4 +np.float32,0xbee57e7e,0xbeedf84f,4 +np.float32,0x3e821e94,0x3e838ffd,4 +np.float32,0x3f74beaa,0x3fa2f721,4 +np.float32,0xbe9b7672,0xbe9df4d9,4 +np.float32,0x3f4041fc,0x3f597e71,4 +np.float32,0xbe9ea7c4,0xbea14f92,4 +np.float32,0xbf800000,0xbfc90fdb,4 +np.float32,0x3e04fb90,0x3e055bfd,4 +np.float32,0xbf14d3d6,0xbf1ed245,4 +np.float32,0xbe84ebec,0xbe86763e,4 +np.float32,0x3f08e568,0x3f107039,4 +np.float32,0x3d8dc9e0,0x3d8de6ef,4 +np.float32,0x3ea4549c,0x3ea74a94,4 +np.float32,0xbebd2806,0xbec1bf51,4 +np.float32,0x3f311a26,0x3f439498,4 +np.float32,0xbf3d2222,0xbf54cf7e,4 +np.float32,0x3e00c500,0x3e011c81,4 +np.float32,0xbe35ed1c,0xbe36e5a9,4 +np.float32,0xbd4ec020,0xbd4ed6a0,4 +np.float32,0x3e1eb088,0x3e1f54eb,4 +np.float32,0x3cf94840,0x3cf9521a,4 +np.float32,0xbf010c5d,0xbf0740e0,4 +np.float32,0xbf3bd63b,0xbf52e502,4 +np.float32,0x3f233f30,0x3f310542,4 +np.float32,0x3ea24128,0x3ea519d7,4 +np.float32,0x3f478b38,0x3f64d124,4 +np.float32,0x3f1e0c6c,0x3f2a57ec,4 +np.float32,0xbf3ad294,0xbf51680a,4 +np.float32,0x3ede0554,0x3ee5a4b4,4 +np.float32,0x3e451a98,0x3e46577d,4 +np.float32,0x3f520164,0x3f764542,4 +np.float32,0x0,0x0,4 +np.float32,0xbd056cd0,0xbd0572db,4 +np.float32,0xbf58b018,0xbf812f5e,4 +np.float32,0x3e036eb0,0x3e03cbc3,4 +np.float32,0x3d1377a0,0x3d137fc9,4 +np.float32,0xbf692d3a,0xbf929a2c,4 +np.float32,0xbec60fb8,0xbecb5dea,4 +np.float32,0x3ed23340,0x3ed89a8e,4 +np.float32,0x3c87f040,0x3c87f1d9,4 +np.float32,0x3dac62f0,0x3dac9737,4 +np.float32,0xbed97c16,0xbee09f02,4 +np.float32,0xbf2d5f3c,0xbf3e769c,4 +np.float32,0xbc3b7c40,0xbc3b7d4c,4 +np.float32,0x3ed998ec,0x3ee0bedd,4 +np.float32,0x3dd86630,0x3dd8cdcb,4 +np.float32,0x3e8b4304,0x3e8d09ea,4 +np.float32,0x3f51e6b0,0x3f761697,4 +np.float32,0x3ec51f24,0x3eca5923,4 +np.float32,0xbf647430,0xbf8d2307,4 +np.float32,0x3f253d9c,0x3f339eb2,4 +np.float32,0x3dc969d0,0x3dc9bd4b,4 +np.float32,0xbc2f1300,0xbc2f13da,4 +np.float32,0xbf170007,0xbf21806d,4 +np.float32,0x3f757d10,0x3fa4412e,4 +np.float32,0xbe7864ac,0xbe7ae564,4 +np.float32,0x3f2ffe90,0x3f420cfb,4 +np.float32,0xbe576138,0xbe590012,4 +np.float32,0xbf517a21,0xbf755959,4 +np.float32,0xbf159cfe,0xbf1fc9d5,4 +np.float32,0xbf638b2a,0xbf8c22cf,4 +np.float32,0xff800000,0x7fc00000,4 +np.float32,0x3ed19ca0,0x3ed7f569,4 +np.float32,0x3f7c4460,0x3fb32d26,4 +np.float32,0x3ebfae6c,0x3ec477ab,4 +np.float32,0x3dd452d0,0x3dd4b4a8,4 +np.float32,0x3f471482,0x3f6413fb,4 +np.float32,0xbf49d704,0xbf6883fe,4 +np.float32,0xbd42c4e0,0xbd42d7af,4 +np.float32,0xbeb02994,0xbeb3d668,4 +np.float32,0x3f4d1fd8,0x3f6dedd2,4 +np.float32,0x3efb591c,0x3f035d11,4 +np.float32,0x80000000,0x80000000,4 +np.float32,0xbf50f782,0xbf7476ad,4 +np.float32,0x3d7232c0,0x3d7256f0,4 +np.float32,0x3f649460,0x3f8d46bb,4 +np.float32,0x3f5561bc,0x3f7c46a9,4 +np.float32,0x3e64f6a0,0x3e66ea5d,4 +np.float32,0x3e5b0470,0x3e5cb8f9,4 +np.float32,0xbe9b6b2c,0xbe9de904,4 +np.float32,0x3f6c33f4,0x3f966486,4 +np.float32,0x3f5cee54,0x3f854613,4 +np.float32,0x3ed3e044,0x3eda716e,4 +np.float32,0xbf3cac7f,0xbf542131,4 +np.float32,0x3c723500,0x3c723742,4 +np.float32,0x3de59900,0x3de614d3,4 +np.float32,0xbdf292f8,0xbdf32517,4 +np.float32,0x3f05c8b2,0x3f0cc59b,4 +np.float32,0xbf1ab182,0xbf261b14,4 +np.float32,0xbda396f0,0xbda3c39a,4 +np.float32,0xbf270ed0,0xbf360231,4 +np.float32,0x3f2063e6,0x3f2d557e,4 +np.float32,0x3c550280,0x3c550409,4 +np.float32,0xbe103b48,0xbe10b679,4 +np.float32,0xbebae390,0xbebf4f40,4 +np.float32,0x3f3bc868,0x3f52d0aa,4 +np.float32,0xbd62f880,0xbd631647,4 +np.float32,0xbe7a38f4,0xbe7cc833,4 +np.float32,0x3f09d796,0x3f118f39,4 +np.float32,0xbf5fa558,0xbf8802d0,4 +np.float32,0x3f111cc8,0x3f1a48b0,4 +np.float32,0x3e831958,0x3e849356,4 +np.float32,0xbf614dbd,0xbf89bc3b,4 +np.float32,0xbd521510,0xbd522cac,4 +np.float32,0x3f05af22,0x3f0ca7a0,4 +np.float32,0xbf1ac60e,0xbf2634df,4 +np.float32,0xbf6bd05e,0xbf95e3fe,4 +np.float32,0xbd1fa6e0,0xbd1fb13b,4 +np.float32,0xbeb82f7a,0xbebc68b1,4 +np.float32,0xbd92aaf8,0xbd92cb23,4 +np.float32,0xbe073a54,0xbe079fbf,4 +np.float32,0xbf198655,0xbf24a468,4 +np.float32,0x3f62f6d8,0x3f8b81ba,4 +np.float32,0x3eef4310,0x3ef8f4f9,4 +np.float32,0x3e8988e0,0x3e8b3eae,4 +np.float32,0xbf3ddba5,0xbf55e367,4 +np.float32,0x3dc6d2e0,0x3dc7232b,4 +np.float32,0xbf31040e,0xbf437601,4 +np.float32,0x3f1bb74a,0x3f276442,4 +np.float32,0xbf0075d2,0xbf0692b3,4 +np.float32,0xbf606ce0,0xbf88d0ff,4 +np.float32,0xbf083856,0xbf0fa39d,4 +np.float32,0xbdb25b20,0xbdb2950a,4 +np.float32,0xbeb86860,0xbebca5ae,4 +np.float32,0x3de83160,0x3de8b176,4 +np.float32,0xbf33a98f,0xbf472664,4 +np.float32,0x3e7795f8,0x3e7a1058,4 +np.float32,0x3e0ca6f8,0x3e0d192a,4 +np.float32,0xbf1aef60,0xbf2668c3,4 +np.float32,0xbda53b58,0xbda5695e,4 +np.float32,0xbf178096,0xbf221fc5,4 +np.float32,0xbf0a4159,0xbf120ccf,4 +np.float32,0x3f7bca36,0x3fb1d0df,4 +np.float32,0xbef94360,0xbf022b26,4 +np.float32,0xbef16f36,0xbefb6ad6,4 +np.float32,0x3f53a7e6,0x3f792e25,4 +np.float32,0xbf7c536f,0xbfb35993,4 +np.float32,0xbe84aaa0,0xbe8632a2,4 +np.float32,0x3ecb3998,0x3ed0fab9,4 +np.float32,0x3f539304,0x3f79090a,4 +np.float32,0xbf3c7816,0xbf53d3b3,4 +np.float32,0xbe7a387c,0xbe7cc7b7,4 +np.float32,0x3f7000e4,0x3f9b92b1,4 +np.float32,0x3e08fd70,0x3e0966e5,4 +np.float32,0x3db97ba0,0x3db9bcc8,4 +np.float32,0xbee99056,0xbef2886a,4 +np.float32,0xbf0668da,0xbf0d819e,4 +np.float32,0x3e58a408,0x3e5a4a51,4 +np.float32,0x3f3440b8,0x3f47faed,4 +np.float32,0xbf19a2ce,0xbf24c7ff,4 +np.float32,0xbe75e990,0xbe7856ee,4 +np.float32,0x3f3c865c,0x3f53e8cb,4 +np.float32,0x3e5e03d0,0x3e5fcac9,4 +np.float32,0x3edb8e34,0x3ee2e932,4 +np.float32,0xbf7e1f5f,0xbfb98ce4,4 +np.float32,0xbf7372ff,0xbfa0d0ae,4 +np.float32,0xbf3ee850,0xbf577548,4 +np.float32,0x3ef19658,0x3efb9737,4 +np.float32,0xbe8088de,0xbe81ecaf,4 +np.float32,0x800000,0x800000,4 +np.float32,0xbde39dd8,0xbde4167a,4 +np.float32,0xbf065d7a,0xbf0d7441,4 +np.float32,0xbde52c78,0xbde5a79b,4 +np.float32,0xbe3a28c0,0xbe3b333e,4 +np.float32,0x3f6e8b3c,0x3f998516,4 +np.float32,0x3f3485c2,0x3f485c39,4 +np.float32,0x3e6f2c68,0x3e71673e,4 +np.float32,0xbe4ec9cc,0xbe50385e,4 +np.float32,0xbf1c3bb0,0xbf280b39,4 +np.float32,0x3ec8ea18,0x3ece76f7,4 +np.float32,0x3e26b5f8,0x3e2774c9,4 +np.float32,0x3e1e4a38,0x3e1eed5c,4 +np.float32,0xbee7a106,0xbef05c6b,4 +np.float32,0xbf305928,0xbf4289d8,4 +np.float32,0x3f0c431c,0x3f147118,4 +np.float32,0xbe57ba6c,0xbe595b52,4 +np.float32,0x3eabc9cc,0x3eaf2fc7,4 +np.float32,0xbef1ed24,0xbefbf9ae,4 +np.float32,0xbf61b576,0xbf8a29cc,4 +np.float32,0x3e9c1ff4,0x3e9ea6cb,4 +np.float32,0x3f6c53b2,0x3f968dbe,4 +np.float32,0x3e2d1b80,0x3e2df156,4 +np.float32,0x3e9f2f70,0x3ea1de4a,4 +np.float32,0xbf5861ee,0xbf80e61a,4 +np.float32,0x3f429144,0x3f5d0505,4 +np.float32,0x3e235cc8,0x3e24103e,4 +np.float32,0xbf354879,0xbf496f6a,4 +np.float32,0xbf20a146,0xbf2da447,4 +np.float32,0x3e8d8968,0x3e8f6785,4 +np.float32,0x3f3fbc94,0x3f58b4c1,4 +np.float32,0x3f2c5f50,0x3f3d1b9f,4 +np.float32,0x3f7bf0f8,0x3fb23d23,4 +np.float32,0xbf218282,0xbf2ec60f,4 +np.float32,0x3f2545aa,0x3f33a93e,4 +np.float32,0xbf4b17be,0xbf6a9018,4 +np.float32,0xbb9df700,0xbb9df728,4 +np.float32,0x3f685d54,0x3f91a06c,4 +np.float32,0x3efdfe2c,0x3f04e24c,4 +np.float32,0x3ef1c5a0,0x3efbccd9,4 +np.float32,0xbf41d731,0xbf5be76e,4 +np.float32,0x3ebd1360,0x3ec1a919,4 +np.float32,0xbf706bd4,0xbf9c2d58,4 +np.float32,0x3ea525e4,0x3ea8279d,4 +np.float32,0xbe51f1b0,0xbe537186,4 +np.float32,0x3f5e8cf6,0x3f86e4f4,4 +np.float32,0xbdad2520,0xbdad5a19,4 +np.float32,0xbf5c5704,0xbf84b0e5,4 +np.float32,0x3f47b54e,0x3f65145e,4 +np.float32,0x3eb4fc78,0x3eb8fc0c,4 +np.float32,0x3dca1450,0x3dca68a1,4 +np.float32,0x3eb02a74,0x3eb3d757,4 +np.float32,0x3f74ae6a,0x3fa2db75,4 +np.float32,0x3f800000,0x3fc90fdb,4 +np.float32,0xbdb46a00,0xbdb4a5f2,4 +np.float32,0xbe9f2ba6,0xbea1da4e,4 +np.float32,0x3f0afa70,0x3f12e8f7,4 +np.float32,0xbf677b20,0xbf909547,4 +np.float32,0x3eff9188,0x3f05cacf,4 +np.float32,0x3f720562,0x3f9e911b,4 +np.float32,0xbf7180d8,0xbf9dc794,4 +np.float32,0xbee7d076,0xbef0919d,4 +np.float32,0x3f0432ce,0x3f0aea95,4 +np.float32,0x3f3bc4c8,0x3f52cb54,4 +np.float32,0xbea72f30,0xbeaa4ebe,4 +np.float32,0x3e90ed00,0x3e92ef33,4 +np.float32,0xbda63670,0xbda6654a,4 +np.float32,0xbf5a6f85,0xbf82d7e0,4 +np.float32,0x3e6e8808,0x3e70be34,4 +np.float32,0xbf4f3822,0xbf71768f,4 +np.float32,0x3e5c8a68,0x3e5e483f,4 +np.float32,0xbf0669d4,0xbf0d82c4,4 +np.float32,0xbf79f77c,0xbfad37b0,4 +np.float32,0x3f25c82c,0x3f345453,4 +np.float32,0x3f1b2948,0x3f26b188,4 +np.float32,0x3ef7e288,0x3f016159,4 +np.float32,0x3c274280,0x3c27433e,4 +np.float32,0xbf4c8fa0,0xbf6cfd5e,4 +np.float32,0x3ea4ccb4,0x3ea7c966,4 +np.float32,0xbf7b157e,0xbfafefca,4 +np.float32,0xbee4c2b0,0xbeed264d,4 +np.float32,0xbc1fd640,0xbc1fd6e6,4 +np.float32,0x3e892308,0x3e8ad4f6,4 +np.float32,0xbf3f69c7,0xbf5837ed,4 +np.float32,0x3ec879e8,0x3ecdfd05,4 +np.float32,0x3f07a8c6,0x3f0efa30,4 +np.float32,0x3f67b880,0x3f90dd4d,4 +np.float32,0x3e8a11c8,0x3e8bccd5,4 +np.float32,0x3f7df6fc,0x3fb8e935,4 +np.float32,0xbef3e498,0xbefe3599,4 +np.float32,0xbf18ad7d,0xbf2395d8,4 +np.float32,0x3f2bce74,0x3f3c57f5,4 +np.float32,0xbf38086e,0xbf4d5c2e,4 +np.float32,0x3f772d7a,0x3fa75c35,4 +np.float32,0xbf3b6e24,0xbf524c00,4 +np.float32,0xbdd39108,0xbdd3f1d4,4 +np.float32,0xbf691f6b,0xbf928974,4 +np.float32,0x3f146188,0x3f1e45e4,4 +np.float32,0xbf56045b,0xbf7d6e03,4 +np.float32,0xbf4b2ee4,0xbf6ab622,4 +np.float32,0xbf3fa3f6,0xbf588f9d,4 +np.float32,0x3f127bb0,0x3f1bf398,4 +np.float32,0x3ed858a0,0x3edf5d3e,4 +np.float32,0xbd6de3b0,0xbd6e05fa,4 +np.float32,0xbecc662c,0xbed24261,4 +np.float32,0xbd6791d0,0xbd67b170,4 +np.float32,0xbf146016,0xbf1e441e,4 +np.float32,0xbf61f04c,0xbf8a6841,4 +np.float32,0xbe7f16d0,0xbe80e6e7,4 +np.float32,0xbebf93e6,0xbec45b10,4 +np.float32,0xbe8a59fc,0xbe8c17d1,4 +np.float32,0xbebc7a0c,0xbec10426,4 +np.float32,0xbf2a682e,0xbf3a7649,4 +np.float32,0xbe18d0cc,0xbe19637b,4 +np.float32,0x3d7f5100,0x3d7f7b66,4 +np.float32,0xbf10f5fa,0xbf1a1998,4 +np.float32,0x3f25e956,0x3f347fdc,4 +np.float32,0x3e6e8658,0x3e70bc78,4 +np.float32,0x3f21a5de,0x3f2ef3a5,4 +np.float32,0xbf4e71d4,0xbf702607,4 +np.float32,0xbf49d6b6,0xbf688380,4 +np.float32,0xbdb729c0,0xbdb7687c,4 +np.float32,0xbf63e1f4,0xbf8c81c7,4 +np.float32,0x3dda6cb0,0x3ddad73e,4 +np.float32,0x3ee1bc40,0x3ee9c612,4 +np.float32,0x3ebdb5f8,0x3ec2581b,4 +np.float32,0x3f7d9576,0x3fb77646,4 +np.float32,0x3e087140,0x3e08d971,4 +np.float64,0xbfdba523cfb74a48,0xbfdc960ddd9c0506,1 +np.float64,0x3fb51773622a2ee0,0x3fb51d93f77089d5,1 +np.float64,0x3fc839f6d33073f0,0x3fc85f9a47dfe8e6,1 +np.float64,0xbfecba2d82f9745b,0xbff1d55416c6c993,1 +np.float64,0x3fd520fe47aa41fc,0x3fd58867f1179634,1 +np.float64,0x3fe1b369c56366d4,0x3fe2c1ac9dd2c45a,1 +np.float64,0xbfec25a7cd784b50,0xbff133417389b12d,1 +np.float64,0xbfd286342ea50c68,0xbfd2cb0bca22e66d,1 +np.float64,0x3fd5f6fe5eabedfc,0x3fd66bad16680d08,1 +np.float64,0xbfe863a87570c751,0xbfebbb9b637eb6dc,1 +np.float64,0x3fc97f5b4d32feb8,0x3fc9ab5066d8eaec,1 +np.float64,0xbfcb667af936ccf4,0xbfcb9d3017047a1d,1 +np.float64,0xbfd1b7b9afa36f74,0xbfd1f3c175706154,1 +np.float64,0x3fef97385b7f2e70,0x3ff6922a1a6c709f,1 +np.float64,0xbfd13e4205a27c84,0xbfd1757c993cdb74,1 +np.float64,0xbfd18d88aca31b12,0xbfd1c7dd75068f7d,1 +np.float64,0x3fe040ce0f60819c,0x3fe10c59d2a27089,1 +np.float64,0xbfddc7deddbb8fbe,0xbfdef9de5baecdda,1 +np.float64,0xbfcf6e96193edd2c,0xbfcfc1bb7396b9a3,1 +np.float64,0x3fd544f494aa89e8,0x3fd5ae850e2b37dd,1 +np.float64,0x3fe15b381fe2b670,0x3fe25841c7bfe2af,1 +np.float64,0xbfde793420bcf268,0xbfdfc2ddc7b4a341,1 +np.float64,0x3fd0d5db30a1abb8,0x3fd1092cef4aa4fb,1 +np.float64,0x3fe386a08c670d42,0x3fe50059bbf7f491,1 +np.float64,0xbfe0aae3a96155c8,0xbfe1880ef13e95ce,1 +np.float64,0xbfe80eeb03f01dd6,0xbfeb39e9f107e944,1 +np.float64,0xbfd531af3caa635e,0xbfd59a178f17552a,1 +np.float64,0x3fcced14ab39da28,0x3fcd2d9a806337ef,1 +np.float64,0xbfdb4c71bcb698e4,0xbfdc33d9d9daf708,1 +np.float64,0xbfde7375ecbce6ec,0xbfdfbc5611bc48ff,1 +np.float64,0x3fecc5707a798ae0,0x3ff1e2268d778017,1 +np.float64,0x3fe8f210a1f1e422,0x3fec9b3349a5baa2,1 +np.float64,0x3fe357f9b8e6aff4,0x3fe4c5a0b89a9228,1 +np.float64,0xbfe0f863b761f0c8,0xbfe1e3283494c3d4,1 +np.float64,0x3fd017c395a02f88,0x3fd044761f2f4a66,1 +np.float64,0x3febeb4746f7d68e,0x3ff0f6b955e7feb6,1 +np.float64,0xbfbdaaeeae3b55e0,0xbfbdbc0950109261,1 +np.float64,0xbfea013095f40261,0xbfee5b8fe8ad8593,1 +np.float64,0xbfe9f87b7973f0f7,0xbfee4ca3a8438d72,1 +np.float64,0x3fd37f77cfa6fef0,0x3fd3d018c825f057,1 +np.float64,0x3fb0799cee20f340,0x3fb07c879e7cb63f,1 +np.float64,0xbfdcfd581cb9fab0,0xbfde15e35314b52d,1 +np.float64,0xbfd49781b8a92f04,0xbfd4f6fa1516fefc,1 +np.float64,0x3fb3fcb6d627f970,0x3fb401ed44a713a8,1 +np.float64,0x3fd5737ef8aae6fc,0x3fd5dfe42d4416c7,1 +np.float64,0x7ff4000000000000,0x7ffc000000000000,1 +np.float64,0xbfe56ae780ead5cf,0xbfe776ea5721b900,1 +np.float64,0x3fd4567786a8acf0,0x3fd4b255421c161a,1 +np.float64,0x3fef6fb58cfedf6c,0x3ff62012dfcf0a33,1 +np.float64,0xbfd1dbcd3da3b79a,0xbfd2194fd628f74d,1 +np.float64,0x3fd9350016b26a00,0x3fd9e8b01eb023e9,1 +np.float64,0xbfe4fb3a69e9f675,0xbfe6e1d2c9eca56c,1 +np.float64,0x3fe9fe0f73f3fc1e,0x3fee5631cfd39772,1 +np.float64,0xbfd51c1bc6aa3838,0xbfd5833b3bd53543,1 +np.float64,0x3fc64158e12c82b0,0x3fc65e7352f237d7,1 +np.float64,0x3fd0d8ee1ba1b1dc,0x3fd10c5c99a16f0e,1 +np.float64,0x3fd5554e15aaaa9c,0x3fd5bfdb9ec9e873,1 +np.float64,0x3fe61ce209ec39c4,0x3fe869bc4c28437d,1 +np.float64,0xbfe4e42c8c69c859,0xbfe6c356dac7e2db,1 +np.float64,0xbfe157021062ae04,0xbfe2533ed39f4212,1 +np.float64,0x3fe844066cf0880c,0x3feb8aea0b7bd0a4,1 +np.float64,0x3fe55016586aa02c,0x3fe752e4b2a67b9f,1 +np.float64,0x3fdabce619b579cc,0x3fdb95809bc789d9,1 +np.float64,0x3fee03bae37c0776,0x3ff3778ba38ca882,1 +np.float64,0xbfeb2f5844f65eb0,0xbff03dd1b767d3c8,1 +np.float64,0x3fedcfdbaffb9fb8,0x3ff32e81d0639164,1 +np.float64,0x3fe06fc63ee0df8c,0x3fe142fc27f92eaf,1 +np.float64,0x3fe7ce90fd6f9d22,0x3fead8f832bbbf5d,1 +np.float64,0xbfbc0015ce380028,0xbfbc0e7470e06e86,1 +np.float64,0xbfe9b3de90f367bd,0xbfedd857931dfc6b,1 +np.float64,0xbfcb588f5936b120,0xbfcb8ef0124a4f21,1 +np.float64,0x3f8d376a503a6f00,0x3f8d37ab43e7988d,1 +np.float64,0xbfdb123a40b62474,0xbfdbf38b6cf5db92,1 +np.float64,0xbfee7da6be7cfb4e,0xbff433042cd9d5eb,1 +np.float64,0xbfc4c9e01b2993c0,0xbfc4e18dbafe37ef,1 +np.float64,0x3fedd42faffba860,0x3ff334790cd18a19,1 +np.float64,0x3fe9cdf772f39bee,0x3fee044f87b856ab,1 +np.float64,0x3fe0245881e048b2,0x3fe0eb5a1f739c8d,1 +np.float64,0xbfe4712bd9e8e258,0xbfe62cb3d82034aa,1 +np.float64,0x3fe9a16b46f342d6,0x3fedb972b2542551,1 +np.float64,0xbfe57ab4536af568,0xbfe78c34b03569c2,1 +np.float64,0x3fb6d6ceb22dada0,0x3fb6de976964d6dd,1 +np.float64,0x3fc3ac23a3275848,0x3fc3c02de53919b8,1 +np.float64,0xbfccb531e7396a64,0xbfccf43ec69f6281,1 +np.float64,0xbfd2f07fc8a5e100,0xbfd33a35a8c41b62,1 +np.float64,0xbfe3e5dd04e7cbba,0xbfe57940157c27ba,1 +np.float64,0x3feefe40757dfc80,0x3ff51bc72b846af6,1 +np.float64,0x8000000000000001,0x8000000000000001,1 +np.float64,0x3fecb7b766796f6e,0x3ff1d28972a0fc7e,1 +np.float64,0xbfea1bf1357437e2,0xbfee89a6532bfd71,1 +np.float64,0xbfca3983b7347308,0xbfca696463b791ef,1 +np.float64,0x10000000000000,0x10000000000000,1 +np.float64,0xbf886b45d030d680,0xbf886b6bbc04314b,1 +np.float64,0x3fd5224bb5aa4498,0x3fd589c92e82218f,1 +np.float64,0xbfec799874f8f331,0xbff18d5158b8e640,1 +np.float64,0xbf88124410302480,0xbf88126863350a16,1 +np.float64,0xbfe37feaaa66ffd6,0xbfe4f7e24382e79d,1 +np.float64,0x3fd777eca1aeefd8,0x3fd8076ead6d55dc,1 +np.float64,0x3fecaaeb3af955d6,0x3ff1c4159fa3e965,1 +np.float64,0xbfeb81e4e6f703ca,0xbff08d4e4c77fada,1 +np.float64,0xbfd7d0a0edafa142,0xbfd866e37010312e,1 +np.float64,0x3feda48c00fb4918,0x3ff2f3fd33c36307,1 +np.float64,0x3feb87ecc4770fda,0x3ff09336e490deda,1 +np.float64,0xbfefd78ad27faf16,0xbff78abbafb50ac1,1 +np.float64,0x3fe58e918c6b1d24,0x3fe7a70b38cbf016,1 +np.float64,0x3fda163b95b42c78,0x3fdade86b88ba4ee,1 +np.float64,0x3fe8fc1aaf71f836,0x3fecab3f93b59df5,1 +np.float64,0xbf8de56f903bcac0,0xbf8de5b527cec797,1 +np.float64,0xbfec112db2f8225b,0xbff11dd648de706f,1 +np.float64,0x3fc3214713264290,0x3fc333b1c862f7d0,1 +np.float64,0xbfeb5e5836f6bcb0,0xbff06ac364b49177,1 +np.float64,0x3fc23d9777247b30,0x3fc24d8ae3bcb615,1 +np.float64,0xbfdf0eed65be1dda,0xbfe036cea9b9dfb6,1 +np.float64,0xbfb2d5c85a25ab90,0xbfb2da24bb409ff3,1 +np.float64,0xbfecdda0c3f9bb42,0xbff1fdf94fc6e89e,1 +np.float64,0x3fdfe79154bfcf24,0x3fe0b338e0476a9d,1 +np.float64,0xbfd712ac6bae2558,0xbfd79abde21f287b,1 +np.float64,0x3fea3f148a747e2a,0x3feec6bed9d4fa04,1 +np.float64,0x3fd4879e4ca90f3c,0x3fd4e632fa4e2edd,1 +np.float64,0x3fe9137a9e7226f6,0x3fecd0c441088d6a,1 +np.float64,0xbfc75bf4ef2eb7e8,0xbfc77da8347d742d,1 +np.float64,0xbfd94090a0b28122,0xbfd9f5458816ed5a,1 +np.float64,0x3fde439cbcbc8738,0x3fdf85fbf496b61f,1 +np.float64,0xbfe18bacdce3175a,0xbfe29210e01237f7,1 +np.float64,0xbfd58ec413ab1d88,0xbfd5fcd838f0a934,1 +np.float64,0xbfeae5af2d75cb5e,0xbfeff1de1b4a06be,1 +np.float64,0x3fb64d1a162c9a30,0x3fb65458fb831354,1 +np.float64,0x3fc18b1e15231640,0x3fc1994c6ffd7a6a,1 +np.float64,0xbfd7b881bcaf7104,0xbfd84ce89a9ee8c7,1 +np.float64,0x3feb916a40f722d4,0x3ff09c8aa851d7c4,1 +np.float64,0x3fdab5fbb5b56bf8,0x3fdb8de43961bbde,1 +np.float64,0x3fe4f35402e9e6a8,0x3fe6d75dc5082894,1 +np.float64,0x3fe2fdb2e5e5fb66,0x3fe454e32a5d2182,1 +np.float64,0x3fe8607195f0c0e4,0x3febb6a4c3bf6a5c,1 +np.float64,0x3fd543ca9aaa8794,0x3fd5ad49203ae572,1 +np.float64,0x3fe8e05ca1f1c0ba,0x3fec7eff123dcc58,1 +np.float64,0x3fe298b6ca65316e,0x3fe3d81d2927c4dd,1 +np.float64,0x3fcfecea733fd9d8,0x3fd0220f1d0faf78,1 +np.float64,0xbfe2e739f065ce74,0xbfe439004e73772a,1 +np.float64,0xbfd1ae6b82a35cd8,0xbfd1ea129a5ee756,1 +np.float64,0xbfeb7edff576fdc0,0xbff08a5a638b8a8b,1 +np.float64,0x3fe5b645ff6b6c8c,0x3fe7dcee1faefe3f,1 +np.float64,0xbfd478427ba8f084,0xbfd4d5fc7c239e60,1 +np.float64,0xbfe39904e3e7320a,0xbfe517972b30b1e5,1 +np.float64,0xbfd3b75b6ba76eb6,0xbfd40acf20a6e074,1 +np.float64,0x3fd596267aab2c4c,0x3fd604b01faeaf75,1 +np.float64,0x3fe134463762688c,0x3fe229fc36784a72,1 +np.float64,0x3fd25dadf7a4bb5c,0x3fd2a0b9e04ea060,1 +np.float64,0xbfc05d3e0b20ba7c,0xbfc068bd2bb9966f,1 +np.float64,0x3f8cf517b039ea00,0x3f8cf556ed74b163,1 +np.float64,0x3fda87361cb50e6c,0x3fdb5a75af897e7f,1 +np.float64,0x3fe53e1926ea7c32,0x3fe73acf01b8ff31,1 +np.float64,0x3fe2e94857e5d290,0x3fe43b8cc820f9c7,1 +np.float64,0x3fd81fe6acb03fcc,0x3fd8bc623c0068cf,1 +np.float64,0xbfddf662c3bbecc6,0xbfdf2e76dc90786e,1 +np.float64,0x3fece174fbf9c2ea,0x3ff2026a1a889580,1 +np.float64,0xbfdc83c5b8b9078c,0xbfdd8dcf6ee3b7da,1 +np.float64,0x3feaf5448f75ea8a,0x3ff0075b108bcd0d,1 +np.float64,0xbfebf32f7ef7e65f,0xbff0fed42aaa826a,1 +np.float64,0x3fe389e5e8e713cc,0x3fe5047ade055ccb,1 +np.float64,0x3f635cdcc026ba00,0x3f635cddeea082ce,1 +np.float64,0x3fae580f543cb020,0x3fae5c9d5108a796,1 +np.float64,0x3fec9fafce793f60,0x3ff1b77bec654f00,1 +np.float64,0x3fb19d226e233a40,0x3fb1a0b32531f7ee,1 +np.float64,0xbfdf9a71e7bf34e4,0xbfe086cef88626c7,1 +np.float64,0x8010000000000000,0x8010000000000000,1 +np.float64,0xbfef170ba2fe2e17,0xbff54ed4675f5b8a,1 +np.float64,0xbfcc6e2f8f38dc60,0xbfccab65fc34d183,1 +np.float64,0x3fee756c4bfcead8,0x3ff4258782c137e6,1 +np.float64,0xbfd461c218a8c384,0xbfd4be3e391f0ff4,1 +np.float64,0xbfe3b64686e76c8d,0xbfe53caa16d6c90f,1 +np.float64,0xbfc1c65d8d238cbc,0xbfc1d51e58f82403,1 +np.float64,0x3fe6e06c63edc0d8,0x3fe97cb832eeb6a2,1 +np.float64,0xbfc9fc20b933f840,0xbfca2ab004312d85,1 +np.float64,0xbfe29aa6df65354e,0xbfe3da7ecf3ba466,1 +np.float64,0x3fea4df7d1749bf0,0x3feee0d448bd4746,1 +np.float64,0xbfedec6161fbd8c3,0xbff3563e1d943aa2,1 +np.float64,0x3fdb6f0437b6de08,0x3fdc5a1888b1213d,1 +np.float64,0xbfe270cbd3e4e198,0xbfe3a72ac27a0b0c,1 +np.float64,0xbfdfff8068bfff00,0xbfe0c1088e3b8983,1 +np.float64,0xbfd28edbe6a51db8,0xbfd2d416c8ed363e,1 +np.float64,0xbfb4e35f9229c6c0,0xbfb4e9531d2a737f,1 +np.float64,0xbfee6727e97cce50,0xbff40e7717576e46,1 +np.float64,0xbfddb5fbddbb6bf8,0xbfdee5aad78f5361,1 +np.float64,0xbfdf9d3e9dbf3a7e,0xbfe0886b191f2957,1 +np.float64,0x3fa57e77042afce0,0x3fa5801518ea9342,1 +np.float64,0x3f95c4e4882b89c0,0x3f95c55003c8e714,1 +np.float64,0x3fd9b10f61b36220,0x3fda6fe5d635a8aa,1 +np.float64,0xbfe2973411652e68,0xbfe3d641fe9885fd,1 +np.float64,0xbfee87bd5a7d0f7b,0xbff443bea81b3fff,1 +np.float64,0x3f9ea064c83d40c0,0x3f9ea19025085b2f,1 +np.float64,0xbfe4b823dfe97048,0xbfe689623d30dc75,1 +np.float64,0xbfa06a326c20d460,0xbfa06aeacbcd3eb8,1 +np.float64,0x3fe1e5c4c1e3cb8a,0x3fe2fe44b822f20e,1 +np.float64,0x3f99dafaa833b600,0x3f99dbaec10a1a0a,1 +np.float64,0xbfed7cb3877af967,0xbff2bfe9e556aaf9,1 +np.float64,0x3fd604f2e2ac09e4,0x3fd67a89408ce6ba,1 +np.float64,0x3fec57b60f78af6c,0x3ff16881f46d60f7,1 +np.float64,0xbfea2e3a17745c74,0xbfeea95c7190fd42,1 +np.float64,0xbfd60a7c37ac14f8,0xbfd6806ed642de35,1 +np.float64,0xbfe544b9726a8973,0xbfe743ac399d81d7,1 +np.float64,0xbfd13520faa26a42,0xbfd16c02034a8fe0,1 +np.float64,0xbfea9ea59ff53d4b,0xbfef70538ee12e00,1 +np.float64,0x3fd66633f8accc68,0x3fd6e23c13ab0e9e,1 +np.float64,0xbfe4071bd3e80e38,0xbfe5a3c9ba897d81,1 +np.float64,0xbfbe1659fa3c2cb0,0xbfbe2831d4fed196,1 +np.float64,0xbfd3312777a6624e,0xbfd37df09b9baeba,1 +np.float64,0x3fd13997caa27330,0x3fd170a4900c8907,1 +np.float64,0xbfe7cbc235ef9784,0xbfead4c4d6cbf129,1 +np.float64,0xbfe1456571628acb,0xbfe23e4ec768c8e2,1 +np.float64,0xbfedf1a044fbe340,0xbff35da96773e176,1 +np.float64,0x3fce38b1553c7160,0x3fce8270709774f9,1 +np.float64,0xbfecb01761f9602f,0xbff1c9e9d382f1f8,1 +np.float64,0xbfe0a03560e1406b,0xbfe17b8d5a1ca662,1 +np.float64,0x3fe50f37cbea1e70,0x3fe6fc55e1ae7da6,1 +np.float64,0xbfe12d64a0625aca,0xbfe221d3a7834e43,1 +np.float64,0xbf6fb288403f6500,0xbf6fb28d6f389db6,1 +np.float64,0x3fda831765b50630,0x3fdb55eecae58ca9,1 +np.float64,0x3fe1a0fe4c6341fc,0x3fe2ab9564304425,1 +np.float64,0xbfef2678a77e4cf1,0xbff56ff42b2797bb,1 +np.float64,0xbfab269c1c364d40,0xbfab29df1cd48779,1 +np.float64,0x3fe8ec82a271d906,0x3fec92567d7a6675,1 +np.float64,0xbfc235115f246a24,0xbfc244ee567682ea,1 +np.float64,0x3feef5bf8d7deb80,0x3ff50ad4875ee9bd,1 +np.float64,0x3fe768b5486ed16a,0x3fea421356160e65,1 +np.float64,0xbfd4255684a84aae,0xbfd47e8baf7ec7f6,1 +np.float64,0x3fc7f67f2b2fed00,0x3fc81ae83cf92dd5,1 +np.float64,0x3fe9b1b19a736364,0x3fedd4b0e24ee741,1 +np.float64,0x3fb27eb9e624fd70,0x3fb282dacd89ce28,1 +np.float64,0xbfd490b710a9216e,0xbfd4efcdeb213458,1 +np.float64,0xbfd1347b2ca268f6,0xbfd16b55dece2d38,1 +np.float64,0x3fc6a5668d2d4ad0,0x3fc6c41452c0c087,1 +np.float64,0xbfca7b209f34f640,0xbfcaac710486f6bd,1 +np.float64,0x3fc23a1a47247438,0x3fc24a047fd4c27a,1 +np.float64,0x3fdb1413a8b62828,0x3fdbf595e2d994bc,1 +np.float64,0xbfea69b396f4d367,0xbfef11bdd2b0709a,1 +np.float64,0x3fd14c9958a29934,0x3fd1846161b10422,1 +np.float64,0xbfe205f44be40be8,0xbfe325283aa3c6a8,1 +np.float64,0x3fecd03c9ef9a07a,0x3ff1ee85aaf52a01,1 +np.float64,0x3fe34281d7e68504,0x3fe4aab63e6de816,1 +np.float64,0xbfe120e2376241c4,0xbfe213023ab03939,1 +np.float64,0xbfe951edc4f2a3dc,0xbfed3615e38576f8,1 +np.float64,0x3fe5a2286f6b4450,0x3fe7c196e0ec10ed,1 +np.float64,0xbfed7a3e1f7af47c,0xbff2bcc0793555d2,1 +np.float64,0x3fe050274960a04e,0x3fe11e2e256ea5cc,1 +np.float64,0xbfcfa71f653f4e40,0xbfcffc11483d6a06,1 +np.float64,0x3f6ead2e403d5a00,0x3f6ead32f314c052,1 +np.float64,0x3fe3a2a026674540,0x3fe523bfe085f6ec,1 +np.float64,0xbfe294a62e65294c,0xbfe3d31ebd0b4ca2,1 +np.float64,0xbfb4894d06291298,0xbfb48ef4b8e256b8,1 +np.float64,0xbfc0c042c1218084,0xbfc0cc98ac2767c4,1 +np.float64,0xbfc6a32cb52d4658,0xbfc6c1d1597ed06b,1 +np.float64,0xbfd30f7777a61eee,0xbfd35aa39fee34eb,1 +np.float64,0x3fe7fc2c2eeff858,0x3feb1d8a558b5537,1 +np.float64,0x7fefffffffffffff,0x7ff8000000000000,1 +np.float64,0xbfdadf917bb5bf22,0xbfdbbbae9a9f67a0,1 +np.float64,0xbfcf0395e13e072c,0xbfcf5366015f7362,1 +np.float64,0xbfe8644c9170c899,0xbfebbc98e74a227d,1 +np.float64,0x3fc3b2d8e52765b0,0x3fc3c6f7d44cffaa,1 +np.float64,0x3fc57407b92ae810,0x3fc58e12ccdd47a1,1 +np.float64,0x3fd56a560daad4ac,0x3fd5d62b8dfcc058,1 +np.float64,0x3fd595deefab2bbc,0x3fd6046420b2f79b,1 +np.float64,0xbfd5360f50aa6c1e,0xbfd59ebaacd815b8,1 +np.float64,0x3fdfb6aababf6d54,0x3fe0970b8aac9f61,1 +np.float64,0x3ff0000000000000,0x3ff921fb54442d18,1 +np.float64,0xbfeb3a8958f67513,0xbff04872e8278c79,1 +np.float64,0x3f9e1ea6683c3d40,0x3f9e1fc326186705,1 +np.float64,0x3fe6b6d5986d6dac,0x3fe94175bd60b19d,1 +np.float64,0xbfee4d90b77c9b21,0xbff3e60e9134edc2,1 +np.float64,0x3fd806ce0cb00d9c,0x3fd8a14c4855a8f5,1 +np.float64,0x3fd54acc75aa9598,0x3fd5b4b72fcbb5df,1 +np.float64,0xbfe59761f16b2ec4,0xbfe7b2fa5d0244ac,1 +np.float64,0xbfcd4fa3513a9f48,0xbfcd92d0814a5383,1 +np.float64,0xbfdc827523b904ea,0xbfdd8c577b53053c,1 +np.float64,0xbfd4bb7f34a976fe,0xbfd51d00d9a99360,1 +np.float64,0xbfe818bc87f03179,0xbfeb48d1ea0199c5,1 +np.float64,0xbfa8a2e15c3145c0,0xbfa8a5510ba0e45c,1 +np.float64,0xbfb6d15f422da2c0,0xbfb6d922689da015,1 +np.float64,0x3fcd04eaab3a09d8,0x3fcd46131746ef08,1 +np.float64,0x3fcfb5cfbb3f6ba0,0x3fd0059d308237f3,1 +np.float64,0x3fe8dcf609f1b9ec,0x3fec7997973010b6,1 +np.float64,0xbfdf1834d7be306a,0xbfe03c1d4e2b48f0,1 +np.float64,0x3fee82ae50fd055c,0x3ff43b545066fe1a,1 +np.float64,0xbfde039c08bc0738,0xbfdf3d6ed4d2ee5c,1 +np.float64,0x3fec07389bf80e72,0x3ff1137ed0acd161,1 +np.float64,0xbfef44c010fe8980,0xbff5b488ad22a4c5,1 +np.float64,0x3f76e722e02dce00,0x3f76e72ab2759d88,1 +np.float64,0xbfcaa9e6053553cc,0xbfcadc41125fca93,1 +np.float64,0x3fed6088147ac110,0x3ff29c06c4ef35fc,1 +np.float64,0x3fd32bd836a657b0,0x3fd3785fdb75909f,1 +np.float64,0xbfeedbb1d97db764,0xbff4d87f6c82a93c,1 +np.float64,0xbfe40f31d5e81e64,0xbfe5ae292cf258a2,1 +np.float64,0x7ff8000000000000,0x7ff8000000000000,1 +np.float64,0xbfeb2b25bc76564c,0xbff039d81388550c,1 +np.float64,0x3fec5008fa78a012,0x3ff1604195801da3,1 +np.float64,0x3fce2d4f293c5aa0,0x3fce76b99c2db4da,1 +np.float64,0xbfdc435412b886a8,0xbfdd45e7b7813f1e,1 +np.float64,0x3fdf2c9d06be593c,0x3fe047cb03c141b6,1 +np.float64,0x3fddefc61ebbdf8c,0x3fdf26fb8fad9fae,1 +np.float64,0x3fab50218436a040,0x3fab537395eaf3bb,1 +np.float64,0xbfd5b95a8fab72b6,0xbfd62a191a59343a,1 +np.float64,0x3fdbf803b4b7f008,0x3fdcf211578e98c3,1 +np.float64,0xbfec8c255979184b,0xbff1a1bee108ed30,1 +np.float64,0x3fe33cdaffe679b6,0x3fe4a3a318cd994f,1 +np.float64,0x3fd8cf585cb19eb0,0x3fd97a408bf3c38c,1 +np.float64,0x3fe919dde07233bc,0x3fecdb0ea13a2455,1 +np.float64,0xbfd5ba35e4ab746c,0xbfd62b024805542d,1 +np.float64,0x3fd2f933e7a5f268,0x3fd343527565e97c,1 +np.float64,0xbfe5b9f8ddeb73f2,0xbfe7e1f772c3e438,1 +np.float64,0x3fe843cd92f0879c,0x3feb8a92d68eae3e,1 +np.float64,0xbfd096b234a12d64,0xbfd0c7beca2c6605,1 +np.float64,0xbfef3363da7e66c8,0xbff58c98dde6c27c,1 +np.float64,0x3fd51b01ddaa3604,0x3fd582109d89ead1,1 +np.float64,0x3fea0f10ff741e22,0x3fee736c2d2a2067,1 +np.float64,0x3fc276e7b724edd0,0x3fc28774520bc6d4,1 +np.float64,0xbfef9abc9f7f3579,0xbff69d49762b1889,1 +np.float64,0x3fe1539ec0e2a73e,0x3fe24f370b7687d0,1 +np.float64,0x3fad72350c3ae460,0x3fad765e7766682a,1 +np.float64,0x3fa289a47c251340,0x3fa28aae12f41646,1 +np.float64,0xbfe5c488e5eb8912,0xbfe7f05d7e7dcddb,1 +np.float64,0xbfc22ef1d7245de4,0xbfc23ebeb990a1b8,1 +np.float64,0x3fe59a0b80eb3418,0x3fe7b695fdcba1de,1 +np.float64,0xbfe9cad619f395ac,0xbfedff0514d91e2c,1 +np.float64,0x3fc8bc74eb3178e8,0x3fc8e48cb22da666,1 +np.float64,0xbfc5389a3f2a7134,0xbfc551cd6febc544,1 +np.float64,0x3fce82feb33d0600,0x3fceceecce2467ef,1 +np.float64,0x3fda346791b468d0,0x3fdaff95154a4ca6,1 +np.float64,0x3fd04501fea08a04,0x3fd073397b32607e,1 +np.float64,0xbfb6be498a2d7c90,0xbfb6c5f93aeb0e57,1 +np.float64,0x3fe1f030dd63e062,0x3fe30ad8fb97cce0,1 +np.float64,0xbfee3fb36dfc7f67,0xbff3d0a5e380b86f,1 +np.float64,0xbfa876773c30ecf0,0xbfa878d9d3df6a3f,1 +np.float64,0x3fdb58296eb6b054,0x3fdc40ceffb17f82,1 +np.float64,0xbfea16b5d8742d6c,0xbfee809b99fd6adc,1 +np.float64,0xbfdc5062b6b8a0c6,0xbfdd547623275fdb,1 +np.float64,0x3fef6db242fedb64,0x3ff61ab4cdaef467,1 +np.float64,0xbfc9f778f933eef0,0xbfca25eef1088167,1 +np.float64,0xbfd22063eba440c8,0xbfd260c8766c69cf,1 +np.float64,0x3fdd2379f2ba46f4,0x3fde40b025cb1ffa,1 +np.float64,0xbfea967af2f52cf6,0xbfef61a178774636,1 +np.float64,0x3fe4f5b49fe9eb6a,0x3fe6da8311a5520e,1 +np.float64,0x3feccde17b799bc2,0x3ff1ebd0ea228b71,1 +np.float64,0x3fe1bb76506376ec,0x3fe2cb56fca01840,1 +np.float64,0xbfef94e583ff29cb,0xbff68aeab8ba75a2,1 +np.float64,0x3fed024a55fa0494,0x3ff228ea5d456e9d,1 +np.float64,0xbfe877b2a8f0ef65,0xbfebdaa1a4712459,1 +np.float64,0x3fef687a8d7ed0f6,0x3ff60cf5fef8d448,1 +np.float64,0xbfeeb2dc8afd65b9,0xbff48dda6a906cd6,1 +np.float64,0x3fdb2e28aeb65c50,0x3fdc12620655eb7a,1 +np.float64,0x3fedc1863afb830c,0x3ff31ae823315e83,1 +np.float64,0xbfe6b1bb546d6376,0xbfe93a38163e3a59,1 +np.float64,0x3fe479c78468f390,0x3fe637e5c0fc5730,1 +np.float64,0x3fbad1fade35a3f0,0x3fbade9a43ca05cf,1 +np.float64,0xbfe2d1c563e5a38b,0xbfe41e712785900c,1 +np.float64,0xbfc08c33ed211868,0xbfc09817a752d500,1 +np.float64,0xbfecce0935f99c12,0xbff1ebfe84524037,1 +np.float64,0x3fce4ef0e73c9de0,0x3fce995638a3dc48,1 +np.float64,0xbfd2fb2343a5f646,0xbfd345592517ca18,1 +np.float64,0x3fd848f7cdb091f0,0x3fd8e8bee5f7b49a,1 +np.float64,0x3fe532b7d2ea6570,0x3fe72b9ac747926a,1 +np.float64,0x3fd616aadcac2d54,0x3fd68d692c5cad42,1 +np.float64,0x3fd7720eb3aee41c,0x3fd801206a0e1e43,1 +np.float64,0x3fee835a35fd06b4,0x3ff43c7175eb7a54,1 +np.float64,0xbfe2e8f70b65d1ee,0xbfe43b2800a947a7,1 +np.float64,0xbfed38f45d7a71e9,0xbff26acd6bde7174,1 +np.float64,0xbfc0c62661218c4c,0xbfc0d28964d66120,1 +np.float64,0x3fe97940bef2f282,0x3fed76b986a74ee3,1 +np.float64,0x3fc96f7dc532def8,0x3fc99b20044c8fcf,1 +np.float64,0xbfd60201eeac0404,0xbfd677675efaaedc,1 +np.float64,0x3fe63c0867ec7810,0x3fe894f060200140,1 +np.float64,0xbfef6144b37ec289,0xbff5fa589a515ba8,1 +np.float64,0xbfde2da0c8bc5b42,0xbfdf6d0b59e3232a,1 +np.float64,0xbfd7401612ae802c,0xbfd7cb74ddd413b9,1 +np.float64,0x3fe41c012de83802,0x3fe5be9d87da3f82,1 +np.float64,0x3fdf501609bea02c,0x3fe05c1d96a2270b,1 +np.float64,0x3fcf9fa1233f3f40,0x3fcff45598e72f07,1 +np.float64,0x3fd4e3895ea9c714,0x3fd547580d8392a2,1 +np.float64,0x3fe1e8ff5fe3d1fe,0x3fe3022a0b86a2ab,1 +np.float64,0xbfe0aa55956154ab,0xbfe18768823da589,1 +np.float64,0x3fb2a0aa26254150,0x3fb2a4e1faff1c93,1 +np.float64,0x3fd3823417a70468,0x3fd3d2f808dbb167,1 +np.float64,0xbfaed323643da640,0xbfaed7e9bef69811,1 +np.float64,0x3fe661e8c4ecc3d2,0x3fe8c9c535f43c16,1 +np.float64,0xbfa429777c2852f0,0xbfa42acd38ba02a6,1 +np.float64,0x3fb5993ea22b3280,0x3fb59fd353e47397,1 +np.float64,0x3fee62d21efcc5a4,0x3ff40788f9278ade,1 +np.float64,0xbf813fb810227f80,0xbf813fc56d8f3c53,1 +np.float64,0x3fd56205deaac40c,0x3fd5cd59671ef193,1 +np.float64,0x3fd31a4de5a6349c,0x3fd365fe401b66e8,1 +np.float64,0xbfec7cc7a478f98f,0xbff190cf69703ca4,1 +np.float64,0xbf755881a02ab100,0xbf755887f52e7794,1 +np.float64,0x3fdd1c92e6ba3924,0x3fde38efb4e8605c,1 +np.float64,0x3fdf49da80be93b4,0x3fe0588af8dd4a34,1 +np.float64,0x3fe1fcdbf2e3f9b8,0x3fe31a27b9d273f2,1 +np.float64,0x3fe2a0f18be541e4,0x3fe3e23b159ce20f,1 +np.float64,0xbfed0f1561fa1e2b,0xbff23820fc0a54ca,1 +np.float64,0x3fe34a006c669400,0x3fe4b419b9ed2b83,1 +np.float64,0xbfd51be430aa37c8,0xbfd583005a4d62e7,1 +np.float64,0x3fe5ec4e336bd89c,0x3fe826caad6b0f65,1 +np.float64,0xbfdad71b1fb5ae36,0xbfdbb25bef8b53d8,1 +np.float64,0xbfe8eac2d871d586,0xbfec8f8cac7952f9,1 +np.float64,0xbfe1d5aef663ab5e,0xbfe2eae14b7ccdfd,1 +np.float64,0x3fec11d3157823a6,0x3ff11e8279506753,1 +np.float64,0xbfe67ff1166cffe2,0xbfe8f3e61c1dfd32,1 +np.float64,0xbfd101eecda203de,0xbfd136e0e9557022,1 +np.float64,0x3fde6c9e5cbcd93c,0x3fdfb48ee7efe134,1 +np.float64,0x3fec3ede9c787dbe,0x3ff14dead1e5cc1c,1 +np.float64,0x3fe7a022086f4044,0x3fea93ce2980b161,1 +np.float64,0xbfc3b2b1b7276564,0xbfc3c6d02d60bb21,1 +np.float64,0x7ff0000000000000,0x7ff8000000000000,1 +np.float64,0x3fe60b5647ec16ac,0x3fe8517ef0544b40,1 +np.float64,0xbfd20ab654a4156c,0xbfd24a2f1b8e4932,1 +np.float64,0xbfe4aa1e2f69543c,0xbfe677005cbd2646,1 +np.float64,0xbfc831cc0b306398,0xbfc8574910d0b86d,1 +np.float64,0xbfc3143495262868,0xbfc3267961b79198,1 +np.float64,0x3fc14d64c1229ac8,0x3fc15afea90a319d,1 +np.float64,0x3fc0a5a207214b48,0x3fc0b1bd2f15c1b0,1 +np.float64,0xbfc0b8351521706c,0xbfc0c4792672d6db,1 +np.float64,0xbfdc383600b8706c,0xbfdd398429e163bd,1 +np.float64,0x3fd9e17321b3c2e8,0x3fdaa4c4d140a622,1 +np.float64,0xbfd44f079ea89e10,0xbfd4aa7d6deff4ab,1 +np.float64,0xbfc3de52a927bca4,0xbfc3f2f8f65f4c3f,1 +np.float64,0x3fe7779d566eef3a,0x3fea57f8592dbaad,1 +np.float64,0xbfe309039e661207,0xbfe462f47f9a64e5,1 +np.float64,0x3fd8e06d08b1c0dc,0x3fd98cc946e440a6,1 +np.float64,0x3fdde66c9ebbccd8,0x3fdf1c68009a8dc1,1 +np.float64,0x3fd4369c6ba86d38,0x3fd490bf460a69e4,1 +np.float64,0xbfe132252fe2644a,0xbfe22775e109cc2e,1 +np.float64,0x3fee15483c7c2a90,0x3ff39111de89036f,1 +np.float64,0xbfc1d5ee8123abdc,0xbfc1e4d66c6871a5,1 +np.float64,0x3fc851c52b30a388,0x3fc877d93fb4ae1a,1 +np.float64,0x3fdaade707b55bd0,0x3fdb85001661fffe,1 +np.float64,0xbfe79fb7f96f3f70,0xbfea9330ec27ac10,1 +np.float64,0xbfe8b0f725f161ee,0xbfec3411c0e4517a,1 +np.float64,0xbfea79f5f374f3ec,0xbfef2e9dd9270488,1 +np.float64,0x3fe0b5fe5b616bfc,0x3fe19512a36a4534,1 +np.float64,0xbfad7c622c3af8c0,0xbfad808fea96a804,1 +np.float64,0xbfe3e24dbce7c49c,0xbfe574b4c1ea9818,1 +np.float64,0xbfe80b038af01607,0xbfeb33fec279576a,1 +np.float64,0xbfef69e2ea7ed3c6,0xbff610a5593a18bc,1 +np.float64,0x3fdcc0bb39b98178,0x3fddd1f8c9a46430,1 +np.float64,0xbfba39976a347330,0xbfba4563bb5369a4,1 +np.float64,0xbfebf9768ef7f2ed,0xbff10548ab725f74,1 +np.float64,0xbfec21c066f84381,0xbff12f2803ba052f,1 +np.float64,0xbfca216a6b3442d4,0xbfca50c5e1e5748e,1 +np.float64,0x3fd5e40da4abc81c,0x3fd65783f9a22946,1 +np.float64,0x3fc235ca17246b98,0x3fc245a8f453173f,1 +np.float64,0x3fecb5b867796b70,0x3ff1d046a0bfda69,1 +np.float64,0x3fcb457fef368b00,0x3fcb7b6daa8165a7,1 +np.float64,0xbfa5ed6f7c2bdae0,0xbfa5ef27244e2e42,1 +np.float64,0x3fecf618a1f9ec32,0x3ff21a86cc104542,1 +np.float64,0x3fe9d95413f3b2a8,0x3fee178dcafa11fc,1 +np.float64,0xbfe93a5357f274a7,0xbfed0f9a565da84a,1 +np.float64,0xbfeb9e45ff773c8c,0xbff0a93cab8e258d,1 +np.float64,0x3fcbd9d0bd37b3a0,0x3fcc134e87cae241,1 +np.float64,0x3fe55d4db76aba9c,0x3fe764a0e028475a,1 +np.float64,0xbfc8a6fc71314df8,0xbfc8ceaafbfc59a7,1 +np.float64,0x3fe0615fa660c2c0,0x3fe1323611c4cbc2,1 +np.float64,0x3fb965558632cab0,0x3fb9700b84de20ab,1 +np.float64,0x8000000000000000,0x8000000000000000,1 +np.float64,0x3fe76776c6eeceee,0x3fea40403e24a9f1,1 +np.float64,0x3fe3b7f672676fec,0x3fe53ece71a1a1b1,1 +np.float64,0xbfa9b82ba4337050,0xbfa9baf15394ca64,1 +np.float64,0xbfe31faf49663f5e,0xbfe47f31b1ca73dc,1 +np.float64,0xbfcc4c6beb3898d8,0xbfcc88c5f814b2c1,1 +np.float64,0x3fd481530aa902a8,0x3fd4df8df03bc155,1 +np.float64,0x3fd47593b8a8eb28,0x3fd4d327ab78a1a8,1 +np.float64,0x3fd70e6ccbae1cd8,0x3fd7962fe8b63d46,1 +np.float64,0x3fd25191f7a4a324,0x3fd2941623c88e02,1 +np.float64,0x3fd0603ef0a0c07c,0x3fd08f64e97588dc,1 +np.float64,0xbfc653bae52ca774,0xbfc6711e5e0d8ea9,1 +np.float64,0xbfd11db8fea23b72,0xbfd153b63c6e8812,1 +np.float64,0xbfea9bde25f537bc,0xbfef6b52268e139a,1 +np.float64,0x1,0x1,1 +np.float64,0xbfefd3806d7fa701,0xbff776dcef9583ca,1 +np.float64,0xbfe0fb8cfde1f71a,0xbfe1e6e2e774a8f8,1 +np.float64,0x3fea384534f4708a,0x3feebadaa389be0d,1 +np.float64,0x3feff761c97feec4,0x3ff866157b9d072d,1 +np.float64,0x3fe7131ccb6e263a,0x3fe9c58b4389f505,1 +np.float64,0x3fe9084f7872109e,0x3fecbed0355dbc8f,1 +np.float64,0x3f708e89e0211d00,0x3f708e8cd4946b9e,1 +np.float64,0xbfe39185f067230c,0xbfe50e1cd178244d,1 +np.float64,0x3fd67cc1a9acf984,0x3fd6fa514784b48c,1 +np.float64,0xbfecaef005f95de0,0xbff1c89c9c3ef94a,1 +np.float64,0xbfe12eec81e25dd9,0xbfe223a4285bba9a,1 +np.float64,0x3fbe7f9faa3cff40,0x3fbe92363525068d,1 +np.float64,0xbfe1950b2b632a16,0xbfe29d45fc1e4ce9,1 +np.float64,0x3fe45049e6e8a094,0x3fe6020de759e383,1 +np.float64,0x3fe4d10c8969a21a,0x3fe6aa1fe42cbeb9,1 +np.float64,0xbfe9d04658f3a08d,0xbfee08370a0dbf0c,1 +np.float64,0x3fe14fb314e29f66,0x3fe24a8d73663521,1 +np.float64,0xbfef4abfe4fe9580,0xbff5c2c1ff1250ca,1 +np.float64,0xbfe6162b366c2c56,0xbfe86073ac3c6243,1 +np.float64,0x3feffe781e7ffcf0,0x3ff8d2cbedd6a1b5,1 +np.float64,0xbff0000000000000,0xbff921fb54442d18,1 +np.float64,0x3fc1dc45ad23b888,0x3fc1eb3d9bddda58,1 +np.float64,0xbfe793f6fcef27ee,0xbfea81c93d65aa64,1 +np.float64,0x3fdef6d2bbbdeda4,0x3fe029079d42efb5,1 +np.float64,0xbfdf0ac479be1588,0xbfe0346dbc95963f,1 +np.float64,0xbfd33927d7a67250,0xbfd38653f90a5b73,1 +np.float64,0xbfe248b072e49161,0xbfe37631ef6572e1,1 +np.float64,0xbfc8ceb6af319d6c,0xbfc8f7288657f471,1 +np.float64,0x3fdd7277fcbae4f0,0x3fde99886e6766ef,1 +np.float64,0xbfe0d30c6561a619,0xbfe1b72f90bf53d6,1 +np.float64,0xbfcb0fe07d361fc0,0xbfcb448e2eae9542,1 +np.float64,0xbfe351f57fe6a3eb,0xbfe4be13eef250f2,1 +np.float64,0x3fe85ec02cf0bd80,0x3febb407e2e52e4c,1 +np.float64,0x3fc8bc59b53178b0,0x3fc8e470f65800ec,1 +np.float64,0xbfd278d447a4f1a8,0xbfd2bd133c9c0620,1 +np.float64,0x3feda5cfd87b4ba0,0x3ff2f5ab4324f43f,1 +np.float64,0xbfd2b32a36a56654,0xbfd2fa09c36afd34,1 +np.float64,0xbfed4a81cb7a9504,0xbff28077a4f4fff4,1 +np.float64,0x3fdf079bf9be0f38,0x3fe0329f7fb13f54,1 +np.float64,0x3fd14097f6a28130,0x3fd177e9834ec23f,1 +np.float64,0xbfaeab11843d5620,0xbfaeafc5531eb6b5,1 +np.float64,0xbfac3f8c14387f20,0xbfac433893d53360,1 +np.float64,0xbfc139d7ed2273b0,0xbfc14743adbbe660,1 +np.float64,0x3fe78cb02cef1960,0x3fea7707f76edba9,1 +np.float64,0x3fefe16b41ffc2d6,0x3ff7bff36a7aa7b8,1 +np.float64,0x3fec5260d378a4c2,0x3ff162c588b0da38,1 +np.float64,0x3fedb146f17b628e,0x3ff304f90d3a15d1,1 +np.float64,0x3fd1fd45f7a3fa8c,0x3fd23c2dc3929e20,1 +np.float64,0x3fe0898a5ee11314,0x3fe1610c63e726eb,1 +np.float64,0x3fe7719946eee332,0x3fea4f205eecb59f,1 +np.float64,0x3fe955218972aa44,0x3fed3b530c1f7651,1 +np.float64,0x3fe0ccbf4461997e,0x3fe1afc7b4587836,1 +np.float64,0xbfe9204314f24086,0xbfece5605780e346,1 +np.float64,0xbfe552017feaa403,0xbfe755773cbd74d5,1 +np.float64,0x3fd8ce4b32b19c98,0x3fd9791c8dd44eae,1 +np.float64,0x3fef89acd9ff135a,0x3ff668f78adf7ced,1 +np.float64,0x3fc9d713ad33ae28,0x3fca04da6c293bbd,1 +np.float64,0xbfe22d9c4de45b38,0xbfe3553effadcf92,1 +np.float64,0x3fa5cda38c2b9b40,0x3fa5cf53c5787482,1 +np.float64,0x3fa878ebdc30f1e0,0x3fa87b4f2bf1d4c3,1 +np.float64,0x3fe8030353700606,0x3feb27e196928789,1 +np.float64,0x3fb50607222a0c10,0x3fb50c188ce391e6,1 +np.float64,0x3fd9ba4ab4b37494,0x3fda79fa8bd40f45,1 +np.float64,0x3fb564598e2ac8b0,0x3fb56abe42d1ba13,1 +np.float64,0xbfd1177c83a22efa,0xbfd14d3d7ef30cc4,1 +np.float64,0xbfd952cec7b2a59e,0xbfda09215d17c0ac,1 +np.float64,0x3fe1d8066663b00c,0x3fe2edb35770b8dd,1 +np.float64,0xbfc89427a3312850,0xbfc8bb7a7c389497,1 +np.float64,0xbfe86ebfd3f0dd80,0xbfebccc2ba0f506c,1 +np.float64,0x3fc390578b2720b0,0x3fc3a40cb7f5f728,1 +np.float64,0xbfd122f9b8a245f4,0xbfd15929dc57a897,1 +np.float64,0x3f8d0636d03a0c80,0x3f8d06767de576df,1 +np.float64,0xbfe4b55d8b696abb,0xbfe685be537a9637,1 +np.float64,0xbfdfd51cf9bfaa3a,0xbfe0a894fcff0c76,1 +np.float64,0xbfd37c1f52a6f83e,0xbfd3cc9593c37aad,1 +np.float64,0x3fd0e8283ea1d050,0x3fd11c25c800785a,1 +np.float64,0x3fd3160784a62c10,0x3fd36183a6c2880c,1 +np.float64,0x3fd4c66e57a98cdc,0x3fd5288fe3394eff,1 +np.float64,0x3fee2f7e3afc5efc,0x3ff3b8063eb30cdc,1 +np.float64,0xbfe526773a6a4cee,0xbfe71b4364215b18,1 +np.float64,0x3fea01181e740230,0x3fee5b65eccfd130,1 +np.float64,0xbfe51c03f76a3808,0xbfe70d5919d37587,1 +np.float64,0x3fd97e1375b2fc28,0x3fda3845da40b22b,1 +np.float64,0x3fd5c14a14ab8294,0x3fd632890d07ed03,1 +np.float64,0xbfec9b474279368e,0xbff1b28f50584fe3,1 +np.float64,0x3fe0139ca860273a,0x3fe0d7fc377f001c,1 +np.float64,0x3fdb080c9db61018,0x3fdbe85056358fa0,1 +np.float64,0xbfdd72ceb1bae59e,0xbfde99ea171661eb,1 +np.float64,0xbfe64e934fec9d26,0xbfe8aec2ef24be63,1 +np.float64,0x3fd1036a93a206d4,0x3fd1386adabe01bd,1 +np.float64,0x3febc9d4a5f793aa,0x3ff0d4c069f1e67d,1 +np.float64,0xbfe547a16fea8f43,0xbfe747902fe6fb4d,1 +np.float64,0x3fc289b0f9251360,0x3fc29a709de6bdd9,1 +np.float64,0xbfe694494a6d2892,0xbfe9108f3dc133e2,1 +np.float64,0x3fd827dfe4b04fc0,0x3fd8c4fe40532b91,1 +np.float64,0xbfe8b89418f17128,0xbfec400c5a334b2e,1 +np.float64,0x3fed5605147aac0a,0x3ff28ed1f612814a,1 +np.float64,0xbfed36af31fa6d5e,0xbff26804e1f71af0,1 +np.float64,0x3fdbb01c02b76038,0x3fdca2381558bbf0,1 +np.float64,0x3fe2a951666552a2,0x3fe3ec88f780f9e6,1 +np.float64,0x3fe662defbecc5be,0x3fe8cb1dbfca98ab,1 +np.float64,0x3fd098b1b3a13164,0x3fd0c9d064e4eaf2,1 +np.float64,0x3fefa10edeff421e,0x3ff6b1c6187b18a8,1 +np.float64,0xbfec4feb7a789fd7,0xbff16021ef37a219,1 +np.float64,0x3fd8e415bbb1c82c,0x3fd990c1f8b786bd,1 +np.float64,0xbfead5a09275ab41,0xbfefd44fab5b4f6e,1 +np.float64,0xbfe8666c16f0ccd8,0xbfebbfe0c9f2a9ae,1 +np.float64,0x3fdc962132b92c44,0x3fdda2525a6f406c,1 +np.float64,0xbfe2037f03e406fe,0xbfe3222ec2a3449e,1 +np.float64,0xbfec82c27e790585,0xbff197626ea9df1e,1 +np.float64,0x3fd2b4e03ca569c0,0x3fd2fbd3c7fda23e,1 +np.float64,0xbfe9b0dee5f361be,0xbfedd34f6d3dfe8a,1 +np.float64,0x3feef45cd17de8ba,0x3ff508180687b591,1 +np.float64,0x3f82c39bf0258700,0x3f82c3ad24c3b3f1,1 +np.float64,0xbfca848cfd350918,0xbfcab612ce258546,1 +np.float64,0x3fd6442aaaac8854,0x3fd6bdea54016e48,1 +np.float64,0x3fe550799e6aa0f4,0x3fe75369c9ea5b1e,1 +np.float64,0xbfe0e9d5a361d3ac,0xbfe1d20011139d89,1 +np.float64,0x3fbfc9ff1e3f9400,0x3fbfdf0ea6885c80,1 +np.float64,0xbfa187e8b4230fd0,0xbfa188c95072092e,1 +np.float64,0x3fcd28c9533a5190,0x3fcd6ae879c21b47,1 +np.float64,0x3fc6227ec52c4500,0x3fc63f1fbb441d29,1 +np.float64,0x3fe9b7a2ed736f46,0x3feddeab49b2d176,1 +np.float64,0x3fd4aee93da95dd4,0x3fd50fb3b71e0339,1 +np.float64,0xbfe164dacf62c9b6,0xbfe263bb2f7dd5d9,1 +np.float64,0x3fec62e525f8c5ca,0x3ff17496416d9921,1 +np.float64,0x3fdd363ee0ba6c7c,0x3fde55c6a49a5f86,1 +np.float64,0x3fe65cbf75ecb97e,0x3fe8c28d31ff3ebd,1 +np.float64,0xbfe76d27ca6eda50,0xbfea4899e3661425,1 +np.float64,0xbfc305738d260ae8,0xbfc3178dcfc9d30f,1 +np.float64,0xbfd3aa2a54a75454,0xbfd3fcf1e1ce8328,1 +np.float64,0x3fd1609fc9a2c140,0x3fd1992efa539b9f,1 +np.float64,0xbfac1291bc382520,0xbfac162cc7334b4d,1 +np.float64,0xbfedb461ea7b68c4,0xbff309247850455d,1 +np.float64,0xbfe8d2adf8f1a55c,0xbfec6947be90ba92,1 +np.float64,0xbfd7128965ae2512,0xbfd79a9855bcfc5a,1 +np.float64,0x3fe8deb09471bd62,0x3fec7c56b3aee531,1 +np.float64,0xbfe5f4d329ebe9a6,0xbfe8327ea8189af8,1 +np.float64,0xbfd3b46ac9a768d6,0xbfd407b80b12ff17,1 +np.float64,0x3fec899d7cf9133a,0x3ff19ef26baca36f,1 +np.float64,0xbfec192fd5783260,0xbff126306e507fd0,1 +np.float64,0x3fe945bdaef28b7c,0x3fed222f787310bf,1 +np.float64,0xbfeff9635d7ff2c7,0xbff87d6773f318eb,1 +np.float64,0xbfd604b81cac0970,0xbfd67a4aa852559a,1 +np.float64,0x3fcd1cc9d53a3990,0x3fcd5e962e237c24,1 +np.float64,0xbfed77b0fffaef62,0xbff2b97a1c9b6483,1 +np.float64,0xbfc9c69325338d28,0xbfc9f401500402fb,1 +np.float64,0xbfdf97e246bf2fc4,0xbfe0855601ea9db3,1 +np.float64,0x3fc7e6304f2fcc60,0x3fc80a4e718504cd,1 +np.float64,0x3fec3b599e7876b4,0x3ff14a2d1b9c68e6,1 +np.float64,0xbfe98618e1f30c32,0xbfed8bfbb31c394a,1 +np.float64,0xbfe59b3c0feb3678,0xbfe7b832d6df81de,1 +np.float64,0xbfe54ce2fe6a99c6,0xbfe74e9a85be4116,1 +np.float64,0x3fc9db49cb33b690,0x3fca092737ef500a,1 +np.float64,0xbfb4a922ae295248,0xbfb4aee4e39078a9,1 +np.float64,0xbfd0e542e0a1ca86,0xbfd11925208d66af,1 +np.float64,0x3fd70543f2ae0a88,0x3fd78c5e9238a3ee,1 +np.float64,0x3fd67f7a7facfef4,0x3fd6fd3998df8545,1 +np.float64,0xbfe40b643d6816c8,0xbfe5a947e427f298,1 +np.float64,0xbfcd85f69b3b0bec,0xbfcdcaa24b75f1a3,1 +np.float64,0x3fec705fb4f8e0c0,0x3ff1833c82163ee2,1 +np.float64,0x3fb37650ea26eca0,0x3fb37b20c16fb717,1 +np.float64,0x3fe5ebfa55ebd7f4,0x3fe826578d716e70,1 +np.float64,0x3fe991dfe5f323c0,0x3fed9f8a4bf1f588,1 +np.float64,0xbfd658bd0aacb17a,0xbfd6d3dd06e54900,1 +np.float64,0xbfc24860252490c0,0xbfc258701a0b9290,1 +np.float64,0xbfefb8d763ff71af,0xbff705b6ea4a569d,1 +np.float64,0x3fb8fcb4ae31f970,0x3fb906e809e7899f,1 +np.float64,0x3fce6343cb3cc688,0x3fceae41d1629625,1 +np.float64,0xbfd43d5a11a87ab4,0xbfd497da25687e07,1 +np.float64,0xbfe9568851f2ad11,0xbfed3d9e5fe83a76,1 +np.float64,0x3fe1b66153e36cc2,0x3fe2c53c7e016271,1 +np.float64,0x3fef27452bfe4e8a,0x3ff571b3486ed416,1 +np.float64,0x3fca87c0a7350f80,0x3fcab958a7bb82d4,1 +np.float64,0xbfd8776a8fb0eed6,0xbfd91afaf2f50edf,1 +np.float64,0x3fe9522a76f2a454,0x3fed3679264e1525,1 +np.float64,0x3fea14ff2cf429fe,0x3fee7da6431cc316,1 +np.float64,0x3fe970618bf2e0c4,0x3fed68154d54dd97,1 +np.float64,0x3fd3410cfca68218,0x3fd38e9b21792240,1 +np.float64,0xbf6a8070c0350100,0xbf6a8073c7c34517,1 +np.float64,0xbfbe449de23c8938,0xbfbe56c8e5e4d98b,1 +np.float64,0x3fedbc92e27b7926,0x3ff314313216d8e6,1 +np.float64,0xbfe3be4706677c8e,0xbfe546d3ceb85aea,1 +np.float64,0x3fe30cd6d76619ae,0x3fe467b6f2664a8d,1 +np.float64,0x3fd7d69b21afad38,0x3fd86d54284d05ad,1 +np.float64,0xbfe501001fea0200,0xbfe6e978afcff4d9,1 +np.float64,0xbfe44ba3d8e89748,0xbfe5fc0a31cd1e3e,1 +np.float64,0x3fec52f7c078a5f0,0x3ff16367acb209b2,1 +np.float64,0xbfcb19efcb3633e0,0xbfcb4ed9235a7d47,1 +np.float64,0xbfab86796c370cf0,0xbfab89df7bf15710,1 +np.float64,0xbfb962feda32c600,0xbfb96db1e1679c98,1 +np.float64,0x3fe0dd14e861ba2a,0x3fe1c2fc72810567,1 +np.float64,0x3fe41bcc6de83798,0x3fe5be59b7f9003b,1 +np.float64,0x3fc82f4c4f305e98,0x3fc854bd9798939f,1 +np.float64,0xbfcd143a613a2874,0xbfcd55cbd1619d84,1 +np.float64,0xbfd52da61baa5b4c,0xbfd595d0b3543439,1 +np.float64,0xbfb71b4a8e2e3698,0xbfb7235a4ab8432f,1 +np.float64,0xbfec141a19782834,0xbff120e1e39fc856,1 +np.float64,0xbfdba9319db75264,0xbfdc9a8ca2578bb2,1 +np.float64,0xbfbce5d74639cbb0,0xbfbcf5a4878cfa51,1 +np.float64,0x3fde67f7b3bccff0,0x3fdfaf45a9f843ad,1 +np.float64,0xbfe12d87bc625b10,0xbfe221fd4476eb71,1 +np.float64,0x3fe35b8f6be6b71e,0x3fe4ca20f65179e1,1 +np.float64,0xbfdbada1d3b75b44,0xbfdc9f78b19f93d1,1 +np.float64,0xbfc60159c52c02b4,0xbfc61d79b879f598,1 +np.float64,0x3fd6b81c38ad7038,0x3fd739c27bfa16d8,1 +np.float64,0xbfd646a253ac8d44,0xbfd6c08c19612bbb,1 +np.float64,0xbfe6babef0ed757e,0xbfe94703d0bfa311,1 +np.float64,0xbfed5671f1faace4,0xbff28f5a3f3683d0,1 +np.float64,0x3fc01d1e85203a40,0x3fc02817ec0dfd38,1 +np.float64,0xbfe9188a61f23115,0xbfecd8eb5da84223,1 +np.float64,0x3fdca3bab9b94774,0x3fddb1868660c239,1 +np.float64,0xbfa255750c24aaf0,0xbfa25675f7b36343,1 +np.float64,0x3fb3602db626c060,0x3fb364ed2d5b2876,1 +np.float64,0xbfd30a14bda6142a,0xbfd354ff703b8862,1 +np.float64,0xbfe1cfe381639fc7,0xbfe2e3e720b968c8,1 +np.float64,0xbfd2af6a4fa55ed4,0xbfd2f61e190bcd1f,1 +np.float64,0xbfe93c50937278a1,0xbfed12d64bb10d73,1 +np.float64,0x3fddd8bc44bbb178,0x3fdf0ced7f9005cc,1 +np.float64,0x3fdb2bc73cb65790,0x3fdc0fc0e18e425e,1 +np.float64,0xbfd073f6aba0e7ee,0xbfd0a3cb5468a961,1 +np.float64,0x3fed4bad7b7a975a,0x3ff281ebeb75e414,1 +np.float64,0xbfdc75b50bb8eb6a,0xbfdd7e1a7631cb22,1 +np.float64,0x3fd458a90fa8b154,0x3fd4b4a5817248ce,1 +np.float64,0x3feead5db57d5abc,0x3ff484286fab55ff,1 +np.float64,0x3fb3894382271280,0x3fb38e217b4e7905,1 +np.float64,0xffefffffffffffff,0x7ff8000000000000,1 +np.float64,0xbfe428212ae85042,0xbfe5ce36f226bea8,1 +np.float64,0xbfc08b39f7211674,0xbfc0971b93ebc7ad,1 +np.float64,0xbfc2e7cf5525cfa0,0xbfc2f994eb72b623,1 +np.float64,0xbfdb0d85afb61b0c,0xbfdbee5a2de3c5db,1 +np.float64,0xfff0000000000000,0x7ff8000000000000,1 +np.float64,0xbfd0d36af7a1a6d6,0xbfd106a5f05ef6ff,1 +np.float64,0xbfc333d0912667a0,0xbfc3467162b7289a,1 +np.float64,0x3fcdababc53b5758,0x3fcdf16458c20fa8,1 +np.float64,0x3fd0821b38a10438,0x3fd0b26e3e0b9185,1 +np.float64,0x0,0x0,1 +np.float64,0x3feb7f70edf6fee2,0x3ff08ae81854bf20,1 +np.float64,0x3fe6e075716dc0ea,0x3fe97cc5254be6ff,1 +np.float64,0x3fea13b682f4276e,0x3fee7b6f18073b5b,1 diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/data/umath-validation-set-arcsinh.csv b/venv/lib/python3.12/site-packages/numpy/_core/tests/data/umath-validation-set-arcsinh.csv new file mode 100644 index 00000000..9eedb1a1 --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/tests/data/umath-validation-set-arcsinh.csv @@ -0,0 +1,1429 @@ +dtype,input,output,ulperrortol +np.float32,0xbf24142a,0xbf1a85ef,2 +np.float32,0x3e71cf91,0x3e6f9e37,2 +np.float32,0xe52a7,0xe52a7,2 +np.float32,0x3ef1e074,0x3ee9add9,2 +np.float32,0x806160ac,0x806160ac,2 +np.float32,0x7e2d59a2,0x42af4798,2 +np.float32,0xbf32cac9,0xbf26bf96,2 +np.float32,0x3f081701,0x3f026142,2 +np.float32,0x3f23cc88,0x3f1a499c,2 +np.float32,0xbf090d94,0xbf033ad0,2 +np.float32,0x803af2fc,0x803af2fc,2 +np.float32,0x807eb17e,0x807eb17e,2 +np.float32,0x5c0d8e,0x5c0d8e,2 +np.float32,0x3f7b79d2,0x3f5e6b1d,2 +np.float32,0x806feeae,0x806feeae,2 +np.float32,0x3e4b423a,0x3e49f274,2 +np.float32,0x3f49e5ac,0x3f394a41,2 +np.float32,0x3f18cd4e,0x3f10ef35,2 +np.float32,0xbed75734,0xbed17322,2 +np.float32,0x7f591151,0x42b28085,2 +np.float32,0xfefe9da6,0xc2b16f51,2 +np.float32,0xfeac90fc,0xc2b0a82a,2 +np.float32,0x805c198e,0x805c198e,2 +np.float32,0x7f66d6df,0x42b2a004,2 +np.float32,0x505438,0x505438,2 +np.float32,0xbf39a209,0xbf2c5255,2 +np.float32,0x7fa00000,0x7fe00000,2 +np.float32,0xc84cb,0xc84cb,2 +np.float32,0x7f07d6f5,0x42b19088,2 +np.float32,0x79d7e4,0x79d7e4,2 +np.float32,0xff32f6a0,0xc2b21db1,2 +np.float32,0x7c005c05,0x42a9222e,2 +np.float32,0x3ec449aa,0x3ebfc5ae,2 +np.float32,0x800ec323,0x800ec323,2 +np.float32,0xff1c904c,0xc2b1d93a,2 +np.float32,0x7f4eca52,0x42b267b0,2 +np.float32,0x3ee06540,0x3ed9c514,2 +np.float32,0x6aab4,0x6aab4,2 +np.float32,0x3e298d8c,0x3e28c99e,2 +np.float32,0xbf38d162,0xbf2ba94a,2 +np.float32,0x2d9083,0x2d9083,2 +np.float32,0x7eae5032,0x42b0ad52,2 +np.float32,0x3ead5b3c,0x3eaa3443,2 +np.float32,0x806fef66,0x806fef66,2 +np.float32,0x3f5b614e,0x3f46ca71,2 +np.float32,0xbf4c906a,0xbf3b60fc,2 +np.float32,0x8049453e,0x8049453e,2 +np.float32,0x3d305220,0x3d304432,2 +np.float32,0x2e1a89,0x2e1a89,2 +np.float32,0xbf4e74ec,0xbf3cdacf,2 +np.float32,0x807a827a,0x807a827a,2 +np.float32,0x80070745,0x80070745,2 +np.float32,0xbe1ba2fc,0xbe1b0b28,2 +np.float32,0xbe5131d0,0xbe4fc421,2 +np.float32,0x5bfd98,0x5bfd98,2 +np.float32,0xbd8e1a48,0xbd8dfd27,2 +np.float32,0x8006c160,0x8006c160,2 +np.float32,0x346490,0x346490,2 +np.float32,0xbdbdf060,0xbdbdaaf0,2 +np.float32,0x3ea9d0c4,0x3ea6d8c7,2 +np.float32,0xbf2aaa28,0xbf200916,2 +np.float32,0xbf160c26,0xbf0e9047,2 +np.float32,0x80081fd4,0x80081fd4,2 +np.float32,0x7db44283,0x42adf8b6,2 +np.float32,0xbf1983f8,0xbf118bf5,2 +np.float32,0x2c4a35,0x2c4a35,2 +np.float32,0x6165a7,0x6165a7,2 +np.float32,0xbe776b44,0xbe75129f,2 +np.float32,0xfe81841a,0xc2b0153b,2 +np.float32,0xbf7d1b2f,0xbf5f9461,2 +np.float32,0x80602d36,0x80602d36,2 +np.float32,0xfe8d5046,0xc2b041dd,2 +np.float32,0xfe5037bc,0xc2afa56d,2 +np.float32,0x4bbea6,0x4bbea6,2 +np.float32,0xfea039de,0xc2b0822d,2 +np.float32,0x7ea627a4,0x42b094c7,2 +np.float32,0x3f556198,0x3f423591,2 +np.float32,0xfedbae04,0xc2b123c1,2 +np.float32,0xbe30432c,0xbe2f6744,2 +np.float32,0x80202c77,0x80202c77,2 +np.float32,0xff335cc1,0xc2b21ed5,2 +np.float32,0x3e1e1ebe,0x3e1d7f95,2 +np.float32,0x8021c9c0,0x8021c9c0,2 +np.float32,0x7dc978,0x7dc978,2 +np.float32,0xff6cfabc,0xc2b2ad75,2 +np.float32,0x7f2bd542,0x42b208e0,2 +np.float32,0x53bf33,0x53bf33,2 +np.float32,0x804e04bb,0x804e04bb,2 +np.float32,0x3f30d2f9,0x3f2521ca,2 +np.float32,0x3dfde876,0x3dfd4316,2 +np.float32,0x46f8b1,0x46f8b1,2 +np.float32,0xbd5f9e20,0xbd5f81ba,2 +np.float32,0x807d6a22,0x807d6a22,2 +np.float32,0xff3881da,0xc2b22d50,2 +np.float32,0x1b1cb5,0x1b1cb5,2 +np.float32,0x3f75f2d0,0x3f5a7435,2 +np.float32,0xfee39c1a,0xc2b135e9,2 +np.float32,0x7f79f14a,0x42b2c8b9,2 +np.float32,0x8000e2d1,0x8000e2d1,2 +np.float32,0xab779,0xab779,2 +np.float32,0xbede6690,0xbed7f102,2 +np.float32,0x76e20d,0x76e20d,2 +np.float32,0x3ed714cb,0x3ed135e9,2 +np.float32,0xbeaa6f44,0xbea76f31,2 +np.float32,0x7f7dc8b1,0x42b2d089,2 +np.float32,0x108cb2,0x108cb2,2 +np.float32,0x7d37ba82,0x42ac9f94,2 +np.float32,0x3f31d068,0x3f25f221,2 +np.float32,0x8010a331,0x8010a331,2 +np.float32,0x3f2fdc7c,0x3f2456cd,2 +np.float32,0x7f7a9a67,0x42b2ca13,2 +np.float32,0x3f2acb31,0x3f202492,2 +np.float32,0x7f54fa94,0x42b276c9,2 +np.float32,0x3ebf8a70,0x3ebb553c,2 +np.float32,0x7f75b1a7,0x42b2bff2,2 +np.float32,0x7daebe07,0x42ade8cc,2 +np.float32,0xbd3a3ef0,0xbd3a2e86,2 +np.float32,0x8078ec9e,0x8078ec9e,2 +np.float32,0x3eda206a,0x3ed403ec,2 +np.float32,0x3f7248f2,0x3f57cd77,2 +np.float32,0x805d55ba,0x805d55ba,2 +np.float32,0xff30dc3e,0xc2b217a3,2 +np.float32,0xbe12b27c,0xbe123333,2 +np.float32,0xbf6ed9cf,0xbf554cd0,2 +np.float32,0xbed9eb5c,0xbed3d31c,2 +np.float32,0xbf1c9aea,0xbf14307b,2 +np.float32,0x3f540ac4,0x3f412de2,2 +np.float32,0x800333ac,0x800333ac,2 +np.float32,0x3f74cdb4,0x3f59a09a,2 +np.float32,0xbf41dc41,0xbf32ee6f,2 +np.float32,0xff2c7804,0xc2b20ac4,2 +np.float32,0x514493,0x514493,2 +np.float32,0xbddf1220,0xbddea1cf,2 +np.float32,0xfeaf74de,0xc2b0b0ab,2 +np.float32,0xfe5dfb30,0xc2afc633,2 +np.float32,0xbf4785c4,0xbf376bdb,2 +np.float32,0x80191cd3,0x80191cd3,2 +np.float32,0xfe44f708,0xc2af88fb,2 +np.float32,0x3d4cd8a0,0x3d4cc2ca,2 +np.float32,0x7f572eff,0x42b27c0f,2 +np.float32,0x8031bacb,0x8031bacb,2 +np.float32,0x7f2ea684,0x42b21133,2 +np.float32,0xbea1976a,0xbe9f05bb,2 +np.float32,0x3d677b41,0x3d675bc1,2 +np.float32,0x3f61bf24,0x3f4b9870,2 +np.float32,0x7ef55ddf,0x42b15c5f,2 +np.float32,0x3eabcb20,0x3ea8b91c,2 +np.float32,0xff73d9ec,0xc2b2bc18,2 +np.float32,0x77b9f5,0x77b9f5,2 +np.float32,0x4c6c6c,0x4c6c6c,2 +np.float32,0x7ed09c94,0x42b10949,2 +np.float32,0xdeeec,0xdeeec,2 +np.float32,0x7eac5858,0x42b0a782,2 +np.float32,0x7e190658,0x42af07bd,2 +np.float32,0xbe3c8980,0xbe3b7ce2,2 +np.float32,0x8059e86e,0x8059e86e,2 +np.float32,0xff201836,0xc2b1e4a5,2 +np.float32,0xbeac109c,0xbea8fafb,2 +np.float32,0x7edd1e2b,0x42b12718,2 +np.float32,0x639cd8,0x639cd8,2 +np.float32,0x3f5e4cae,0x3f490059,2 +np.float32,0x3d84c185,0x3d84a9c4,2 +np.float32,0xbe8c1130,0xbe8a605b,2 +np.float32,0x80000000,0x80000000,2 +np.float32,0x3f1da5e4,0x3f151404,2 +np.float32,0x7f75a873,0x42b2bfdf,2 +np.float32,0xbd873540,0xbd871c28,2 +np.float32,0xbe8e5e10,0xbe8c9808,2 +np.float32,0x7f004bf2,0x42b17347,2 +np.float32,0x800000,0x800000,2 +np.float32,0xbf6d6b79,0xbf544095,2 +np.float32,0x7ed7b563,0x42b11a6a,2 +np.float32,0x80693745,0x80693745,2 +np.float32,0x3ee0f608,0x3eda49a8,2 +np.float32,0xfe1285a4,0xc2aef181,2 +np.float32,0x72d946,0x72d946,2 +np.float32,0x6a0dca,0x6a0dca,2 +np.float32,0x3f5c9df6,0x3f47ba99,2 +np.float32,0xff002af6,0xc2b172c4,2 +np.float32,0x3f4ac98f,0x3f39fd0a,2 +np.float32,0x8066acf7,0x8066acf7,2 +np.float32,0xbcaa4e60,0xbcaa4b3c,2 +np.float32,0x80162813,0x80162813,2 +np.float32,0xff34b318,0xc2b222a2,2 +np.float32,0x7f1ce33c,0x42b1da49,2 +np.float32,0x3f0e55ab,0x3f07ddb0,2 +np.float32,0x7c75d996,0x42aa6eec,2 +np.float32,0xbf221bc6,0xbf18dc89,2 +np.float32,0x3f5a1a4c,0x3f45d1d4,2 +np.float32,0x7f2451b8,0x42b1f1fb,2 +np.float32,0x3ec55ca0,0x3ec0c655,2 +np.float32,0x3f752dc2,0x3f59e600,2 +np.float32,0xbe33f638,0xbe330c4d,2 +np.float32,0x3e2a9148,0x3e29c9d8,2 +np.float32,0x3f3362a1,0x3f273c01,2 +np.float32,0x5f83b3,0x5f83b3,2 +np.float32,0x3e362488,0x3e353216,2 +np.float32,0x140bcf,0x140bcf,2 +np.float32,0x7e3e96df,0x42af7822,2 +np.float32,0xbebc7082,0xbeb86ce6,2 +np.float32,0xbe92a92e,0xbe90b9d2,2 +np.float32,0xff3d8afc,0xc2b23b19,2 +np.float32,0x804125e3,0x804125e3,2 +np.float32,0x3f3675d1,0x3f29bedb,2 +np.float32,0xff70bb09,0xc2b2b57f,2 +np.float32,0x3f29681c,0x3f1efcd2,2 +np.float32,0xbdc70380,0xbdc6b3a8,2 +np.float32,0x54e0dd,0x54e0dd,2 +np.float32,0x3d545de0,0x3d54458c,2 +np.float32,0x7f800000,0x7f800000,2 +np.float32,0x8014a4c2,0x8014a4c2,2 +np.float32,0xbe93f58a,0xbe91f938,2 +np.float32,0x17de33,0x17de33,2 +np.float32,0xfefb679a,0xc2b168d2,2 +np.float32,0xbf23423e,0xbf19d511,2 +np.float32,0x7e893fa1,0x42b032ec,2 +np.float32,0x3f44fe2d,0x3f356bda,2 +np.float32,0xbebb2e78,0xbeb73e8f,2 +np.float32,0x3f5632e0,0x3f42d633,2 +np.float32,0x3ddd8698,0x3ddd1896,2 +np.float32,0x80164ea7,0x80164ea7,2 +np.float32,0x80087b37,0x80087b37,2 +np.float32,0xbf06ab1e,0xbf011f95,2 +np.float32,0x3db95524,0x3db9149f,2 +np.float32,0x7aa1fbb3,0x42a570a1,2 +np.float32,0xbd84fc48,0xbd84e467,2 +np.float32,0x3d65c6f5,0x3d65a826,2 +np.float32,0xfe987800,0xc2b068c4,2 +np.float32,0x7ec59532,0x42b0ed7a,2 +np.float32,0x3ea0232c,0x3e9da29a,2 +np.float32,0x80292a08,0x80292a08,2 +np.float32,0x734cfe,0x734cfe,2 +np.float32,0x3f3b6d63,0x3f2dc596,2 +np.float32,0x3f27bcc1,0x3f1d97e6,2 +np.float32,0xfe1da554,0xc2af16f9,2 +np.float32,0x7c91f5,0x7c91f5,2 +np.float32,0xfe4e78cc,0xc2afa11e,2 +np.float32,0x7e4b4e08,0x42af9933,2 +np.float32,0xfe0949ec,0xc2aed02e,2 +np.float32,0x7e2f057f,0x42af4c81,2 +np.float32,0xbf200ae0,0xbf171ce1,2 +np.float32,0x3ebcc244,0x3eb8b99e,2 +np.float32,0xbf68f58d,0xbf50f7aa,2 +np.float32,0x4420b1,0x4420b1,2 +np.float32,0x3f5b61bf,0x3f46cac7,2 +np.float32,0x3fec78,0x3fec78,2 +np.float32,0x7f4183c8,0x42b245b7,2 +np.float32,0xbf10587c,0xbf099ee2,2 +np.float32,0x0,0x0,2 +np.float32,0x7ec84dc3,0x42b0f47a,2 +np.float32,0x3f5fbd7b,0x3f4a166d,2 +np.float32,0xbd884eb8,0xbd883502,2 +np.float32,0xfe3f10a4,0xc2af7969,2 +np.float32,0xff3f4920,0xc2b23fc9,2 +np.float32,0x8013900f,0x8013900f,2 +np.float32,0x8003529d,0x8003529d,2 +np.float32,0xbf032384,0xbefbfb3c,2 +np.float32,0xff418c7c,0xc2b245ce,2 +np.float32,0xbec0aad0,0xbebc633b,2 +np.float32,0xfdbff178,0xc2ae18de,2 +np.float32,0x68ab15,0x68ab15,2 +np.float32,0xbdfc4a88,0xbdfba848,2 +np.float32,0xbf5adec6,0xbf466747,2 +np.float32,0x807d5dcc,0x807d5dcc,2 +np.float32,0x61d144,0x61d144,2 +np.float32,0x807e3a03,0x807e3a03,2 +np.float32,0x1872f2,0x1872f2,2 +np.float32,0x7f2a272c,0x42b203d8,2 +np.float32,0xfe7f8314,0xc2b00e3a,2 +np.float32,0xbe42aeac,0xbe418737,2 +np.float32,0x8024b614,0x8024b614,2 +np.float32,0xbe41b6b8,0xbe40939a,2 +np.float32,0xa765c,0xa765c,2 +np.float32,0x7ea74f4b,0x42b09853,2 +np.float32,0x7f7ef631,0x42b2d2e7,2 +np.float32,0x7eaef5e6,0x42b0af38,2 +np.float32,0xff733d85,0xc2b2bacf,2 +np.float32,0x537ac0,0x537ac0,2 +np.float32,0xbeca4790,0xbec55b1d,2 +np.float32,0x80117314,0x80117314,2 +np.float32,0xfe958536,0xc2b05ec5,2 +np.float32,0x8066ecc2,0x8066ecc2,2 +np.float32,0xbf56baf3,0xbf433e82,2 +np.float32,0x1f7fd7,0x1f7fd7,2 +np.float32,0x3e942104,0x3e9222fc,2 +np.float32,0xfeaffe82,0xc2b0b23c,2 +np.float32,0xfe0e02b0,0xc2aee17e,2 +np.float32,0xbf800000,0xbf61a1b3,2 +np.float32,0x800b7e49,0x800b7e49,2 +np.float32,0x6c514f,0x6c514f,2 +np.float32,0xff800000,0xff800000,2 +np.float32,0x7f7d9a45,0x42b2d02b,2 +np.float32,0x800c9c69,0x800c9c69,2 +np.float32,0x274b14,0x274b14,2 +np.float32,0xbf4b22b0,0xbf3a42e2,2 +np.float32,0x63e5ae,0x63e5ae,2 +np.float32,0xbe18facc,0xbe186a90,2 +np.float32,0x7e137351,0x42aef4bd,2 +np.float32,0x80518ffd,0x80518ffd,2 +np.float32,0xbf0a8ffc,0xbf048f0d,2 +np.float32,0x841d,0x841d,2 +np.float32,0x7edfdc9e,0x42b12d69,2 +np.float32,0xfd1092b0,0xc2ac24de,2 +np.float32,0x7e2c9bdf,0x42af4566,2 +np.float32,0x7f7fffff,0x42b2d4fc,2 +np.float32,0x3f4954a6,0x3f38d853,2 +np.float32,0xbe83efd2,0xbe8284c3,2 +np.float32,0x800e8e02,0x800e8e02,2 +np.float32,0x78ad39,0x78ad39,2 +np.float32,0x7eb0f967,0x42b0b514,2 +np.float32,0xbe39aa94,0xbe38a9ee,2 +np.float32,0x80194e7b,0x80194e7b,2 +np.float32,0x3cf3a340,0x3cf39a0f,2 +np.float32,0x3ed3117a,0x3ecd8173,2 +np.float32,0x7f530b11,0x42b2721c,2 +np.float32,0xff756ba2,0xc2b2bf60,2 +np.float32,0x15ea25,0x15ea25,2 +np.float32,0x803cbb64,0x803cbb64,2 +np.float32,0x3f34722d,0x3f281a2c,2 +np.float32,0x3ddd88e0,0x3ddd1adb,2 +np.float32,0x3f54244c,0x3f41418b,2 +np.float32,0x3e0adb98,0x3e0a6f8b,2 +np.float32,0x80800000,0x80800000,2 +np.float32,0x58902b,0x58902b,2 +np.float32,0xfe3b50b8,0xc2af6f43,2 +np.float32,0xfe0846d0,0xc2aecc64,2 +np.float32,0xbe0299d0,0xbe023fd4,2 +np.float32,0x18dde6,0x18dde6,2 +np.float32,0x8039fe8b,0x8039fe8b,2 +np.float32,0x8015d179,0x8015d179,2 +np.float32,0x3f551322,0x3f41f947,2 +np.float32,0x2ab387,0x2ab387,2 +np.float32,0xbf7e311e,0xbf6059d0,2 +np.float32,0xbdba58a8,0xbdba1713,2 +np.float32,0xbf1d008a,0xbf148724,2 +np.float32,0xbf6b9c97,0xbf52ec98,2 +np.float32,0x802acf04,0x802acf04,2 +np.float32,0x1,0x1,2 +np.float32,0xbe9e16d6,0xbe9bade3,2 +np.float32,0xbf048a14,0xbefe78c7,2 +np.float32,0x7e432ad3,0x42af8449,2 +np.float32,0xbdcc7fe0,0xbdcc2944,2 +np.float32,0x6dfc27,0x6dfc27,2 +np.float32,0xfef6eed8,0xc2b15fa1,2 +np.float32,0xbeeff6e8,0xbee7f2e4,2 +np.float32,0x7e3a6ca8,0x42af6cd2,2 +np.float32,0xff2c82e8,0xc2b20ae4,2 +np.float32,0x3e9f8d74,0x3e9d13b0,2 +np.float32,0x7ea36191,0x42b08c29,2 +np.float32,0x7f734bed,0x42b2baed,2 +np.float32,0x7f2df96d,0x42b20f37,2 +np.float32,0x5036fd,0x5036fd,2 +np.float32,0x806eab38,0x806eab38,2 +np.float32,0xbe9db90e,0xbe9b5446,2 +np.float32,0xfeef6fac,0xc2b14fd9,2 +np.float32,0xc2bf7,0xc2bf7,2 +np.float32,0xff53ec3d,0xc2b2743d,2 +np.float32,0x7e837637,0x42b01cde,2 +np.float32,0xbefb5934,0xbef23662,2 +np.float32,0x3f6cec80,0x3f53e371,2 +np.float32,0x3e86e7de,0x3e85643f,2 +np.float32,0x3f09cb42,0x3f03e1ef,2 +np.float32,0xbec3d236,0xbebf5620,2 +np.float32,0xfedef246,0xc2b12b50,2 +np.float32,0xbf08d6a8,0xbf030a62,2 +np.float32,0x8036cbf9,0x8036cbf9,2 +np.float32,0x3f74d3e3,0x3f59a512,2 +np.float32,0x6a600c,0x6a600c,2 +np.float32,0xfd1295b0,0xc2ac2bf1,2 +np.float32,0xbeb61142,0xbeb26efa,2 +np.float32,0x80216556,0x80216556,2 +np.float32,0xbf1fa0f6,0xbf16c30a,2 +np.float32,0x3e0af8e1,0x3e0a8c90,2 +np.float32,0x80434709,0x80434709,2 +np.float32,0x49efd9,0x49efd9,2 +np.float32,0x7f7cce6c,0x42b2ce8f,2 +np.float32,0x6e5450,0x6e5450,2 +np.float32,0x7f0fc115,0x42b1ad86,2 +np.float32,0x632db0,0x632db0,2 +np.float32,0x3f6f4c2a,0x3f55a064,2 +np.float32,0x7ec4f273,0x42b0ebd3,2 +np.float32,0x61ae1e,0x61ae1e,2 +np.float32,0x5f47c4,0x5f47c4,2 +np.float32,0xbf3c8f62,0xbf2eaf54,2 +np.float32,0xfca38900,0xc2ab0113,2 +np.float32,0x3ec89d52,0x3ec3ce78,2 +np.float32,0xbe0e3f70,0xbe0dcb53,2 +np.float32,0x805d3156,0x805d3156,2 +np.float32,0x3eee33f8,0x3ee65a4e,2 +np.float32,0xbeda7e9a,0xbed45a90,2 +np.float32,0x7e2fac7b,0x42af4e69,2 +np.float32,0x7efd0e28,0x42b16c2c,2 +np.float32,0x3f0c7b17,0x3f063e46,2 +np.float32,0xbf395bec,0xbf2c198f,2 +np.float32,0xfdf1c3f8,0xc2ae8f05,2 +np.float32,0xbe11f4e4,0xbe117783,2 +np.float32,0x7eddc901,0x42b128a3,2 +np.float32,0x3f4bad09,0x3f3aaf33,2 +np.float32,0xfefb5d76,0xc2b168bd,2 +np.float32,0x3ed3a4cf,0x3ece09a3,2 +np.float32,0x7ec582e4,0x42b0ed4a,2 +np.float32,0x3dc2268a,0x3dc1dc64,2 +np.float32,0x3ef9b17c,0x3ef0b9c9,2 +np.float32,0x2748ac,0x2748ac,2 +np.float32,0xfed6a602,0xc2b117e4,2 +np.float32,0xbefc9c36,0xbef35832,2 +np.float32,0x7e0476,0x7e0476,2 +np.float32,0x804be1a0,0x804be1a0,2 +np.float32,0xbefbc1c2,0xbef2943a,2 +np.float32,0xbd4698f0,0xbd46850a,2 +np.float32,0x688627,0x688627,2 +np.float32,0x3f7f7685,0x3f61406f,2 +np.float32,0x827fb,0x827fb,2 +np.float32,0x3f503264,0x3f3e34fd,2 +np.float32,0x7f5458d1,0x42b27543,2 +np.float32,0x800ac01f,0x800ac01f,2 +np.float32,0x6188dd,0x6188dd,2 +np.float32,0x806ac0ba,0x806ac0ba,2 +np.float32,0xbe14493c,0xbe13c5cc,2 +np.float32,0x3f77542c,0x3f5b72ae,2 +np.float32,0xfeaacab6,0xc2b0a2df,2 +np.float32,0x7f2893d5,0x42b1ff15,2 +np.float32,0x66b528,0x66b528,2 +np.float32,0xbf653e24,0xbf4e3573,2 +np.float32,0x801a2853,0x801a2853,2 +np.float32,0x3f3d8c98,0x3f2f7b04,2 +np.float32,0xfdffbad8,0xc2aeabc5,2 +np.float32,0x3dd50f,0x3dd50f,2 +np.float32,0x3f325a4c,0x3f266353,2 +np.float32,0xfcc48ec0,0xc2ab5f3f,2 +np.float32,0x3e6f5b9a,0x3e6d3ae5,2 +np.float32,0x3dbcd62b,0x3dbc91ee,2 +np.float32,0xbf7458d9,0xbf594c1c,2 +np.float32,0xff5adb24,0xc2b284b9,2 +np.float32,0x807b246d,0x807b246d,2 +np.float32,0x3f800000,0x3f61a1b3,2 +np.float32,0x231a28,0x231a28,2 +np.float32,0xbdc66258,0xbdc61341,2 +np.float32,0x3c84b4b4,0x3c84b338,2 +np.float32,0xbf215894,0xbf183783,2 +np.float32,0xff4ee298,0xc2b267ec,2 +np.float32,0x801ef52e,0x801ef52e,2 +np.float32,0x1040b0,0x1040b0,2 +np.float32,0xff545582,0xc2b2753b,2 +np.float32,0x3f3b9dda,0x3f2decaf,2 +np.float32,0x730f99,0x730f99,2 +np.float32,0xff7fffff,0xc2b2d4fc,2 +np.float32,0xff24cc5e,0xc2b1f379,2 +np.float32,0xbe9b456a,0xbe98fc0b,2 +np.float32,0x188fb,0x188fb,2 +np.float32,0x3f5c7ce2,0x3f47a18a,2 +np.float32,0x7fc00000,0x7fc00000,2 +np.float32,0x806ea4da,0x806ea4da,2 +np.float32,0xfe810570,0xc2b01345,2 +np.float32,0x8036af89,0x8036af89,2 +np.float32,0x8043cec6,0x8043cec6,2 +np.float32,0x80342bb3,0x80342bb3,2 +np.float32,0x1a2bd4,0x1a2bd4,2 +np.float32,0x3f6248c2,0x3f4bff9a,2 +np.float32,0x8024eb35,0x8024eb35,2 +np.float32,0x7ea55872,0x42b09247,2 +np.float32,0x806d6e56,0x806d6e56,2 +np.float32,0x25c21a,0x25c21a,2 +np.float32,0x3f4e95f3,0x3f3cf483,2 +np.float32,0x15ca38,0x15ca38,2 +np.float32,0x803f01b2,0x803f01b2,2 +np.float32,0xbe731634,0xbe70dc10,2 +np.float32,0x3e80cee4,0x3e7ef933,2 +np.float32,0x3ef6dda5,0x3eee2e7b,2 +np.float32,0x3f3dfdc2,0x3f2fd5ed,2 +np.float32,0xff0492a7,0xc2b18411,2 +np.float32,0xbf1d0adf,0xbf148ff3,2 +np.float32,0xfcf75460,0xc2abd4e3,2 +np.float32,0x3f46fca6,0x3f36ffa6,2 +np.float32,0xbe63b5c0,0xbe61dfb3,2 +np.float32,0xff019bec,0xc2b1787d,2 +np.float32,0x801f14a9,0x801f14a9,2 +np.float32,0x3f176cfa,0x3f0fc051,2 +np.float32,0x3f69d976,0x3f51a015,2 +np.float32,0x3f4917cb,0x3f38a87a,2 +np.float32,0x3b2a0bea,0x3b2a0bdd,2 +np.float32,0xbf41d857,0xbf32eb50,2 +np.float32,0xbf08841a,0xbf02c18f,2 +np.float32,0x7ec86f14,0x42b0f4d0,2 +np.float32,0xbf7d15d1,0xbf5f9090,2 +np.float32,0xbd080550,0xbd07feea,2 +np.float32,0xbf6f1bef,0xbf557d26,2 +np.float32,0xfebc282c,0xc2b0d473,2 +np.float32,0x3e68d2f5,0x3e66dd03,2 +np.float32,0x3f3ed8fe,0x3f3085d5,2 +np.float32,0xff2f78ae,0xc2b2139a,2 +np.float32,0xff647a70,0xc2b29ac1,2 +np.float32,0xfd0859a0,0xc2ac06e2,2 +np.float32,0x3ea578a8,0x3ea2b7e1,2 +np.float32,0x6c58c6,0x6c58c6,2 +np.float32,0xff23f26a,0xc2b1f0d2,2 +np.float32,0x800902a4,0x800902a4,2 +np.float32,0xfe8ba64e,0xc2b03bcd,2 +np.float32,0x3f091143,0x3f033e0f,2 +np.float32,0x8017c4bd,0x8017c4bd,2 +np.float32,0xbf708fd4,0xbf568c8c,2 +np.float32,0x3be1d8,0x3be1d8,2 +np.float32,0x80091f07,0x80091f07,2 +np.float32,0x68eabe,0x68eabe,2 +np.float32,0xfe9ab2c8,0xc2b07033,2 +np.float32,0x3eabe752,0x3ea8d3d7,2 +np.float32,0xbf7adcb2,0xbf5dfaf5,2 +np.float32,0x801ecc01,0x801ecc01,2 +np.float32,0xbf5570a9,0xbf424123,2 +np.float32,0x3e89eecd,0x3e88510e,2 +np.float32,0xfeb2feee,0xc2b0bae4,2 +np.float32,0xbeb25ec2,0xbeaef22b,2 +np.float32,0x201e49,0x201e49,2 +np.float32,0x800a35f6,0x800a35f6,2 +np.float32,0xbf02d449,0xbefb6e2a,2 +np.float32,0x3f062bea,0x3f00aef6,2 +np.float32,0x7f5219ff,0x42b26fd2,2 +np.float32,0xbd4561d0,0xbd454e47,2 +np.float32,0x3f6c4789,0x3f536a4b,2 +np.float32,0x7f58b06d,0x42b27fa1,2 +np.float32,0x7f132f39,0x42b1b999,2 +np.float32,0x3e05dcb4,0x3e057bd8,2 +np.float32,0x7f526045,0x42b2707d,2 +np.float32,0x3f6117d0,0x3f4b1adb,2 +np.float32,0xbf21f47d,0xbf18bb57,2 +np.float32,0x1a26d6,0x1a26d6,2 +np.float32,0x46b114,0x46b114,2 +np.float32,0x3eb24518,0x3eaed9ef,2 +np.float32,0xfe2139c8,0xc2af2278,2 +np.float32,0xbf7c36fb,0xbf5ef1f6,2 +np.float32,0x3f193834,0x3f114af7,2 +np.float32,0xff3ea650,0xc2b23e14,2 +np.float32,0xfeeb3bca,0xc2b146c7,2 +np.float32,0x7e8b8ca0,0x42b03b6f,2 +np.float32,0x3eed903d,0x3ee5c5d2,2 +np.float32,0xbdc73740,0xbdc6e72a,2 +np.float32,0x7e500307,0x42afa4ec,2 +np.float32,0xe003c,0xe003c,2 +np.float32,0x3e612bb4,0x3e5f64fd,2 +np.float32,0xfd81e248,0xc2ad50e6,2 +np.float32,0x766a4f,0x766a4f,2 +np.float32,0x3e8708c9,0x3e858414,2 +np.float32,0xbf206c58,0xbf176f7f,2 +np.float32,0x7e93aeb0,0x42b0586f,2 +np.float32,0xfd9d36b8,0xc2adb2ad,2 +np.float32,0xff1f4e0e,0xc2b1e21d,2 +np.float32,0x3f22bd5a,0x3f1964f8,2 +np.float32,0x7f6a517a,0x42b2a7ad,2 +np.float32,0xff6ca773,0xc2b2acc1,2 +np.float32,0x7f6bf453,0x42b2ab3d,2 +np.float32,0x3edfdd64,0x3ed9489f,2 +np.float32,0xbeafc5ba,0xbeac7daa,2 +np.float32,0x7d862039,0x42ad615b,2 +np.float32,0xbe9d2002,0xbe9ac1fc,2 +np.float32,0xbdcc54c0,0xbdcbfe5b,2 +np.float32,0xbf1bc0aa,0xbf13762a,2 +np.float32,0xbf4679ce,0xbf36984b,2 +np.float32,0x3ef45696,0x3eebe713,2 +np.float32,0xff6eb999,0xc2b2b137,2 +np.float32,0xbe4b2e4c,0xbe49dee8,2 +np.float32,0x3f498951,0x3f3901b7,2 +np.float32,0xbe9692f4,0xbe947be1,2 +np.float32,0xbf44ce26,0xbf3545c8,2 +np.float32,0x805787a8,0x805787a8,2 +np.float32,0xbf342650,0xbf27dc26,2 +np.float32,0x3edafbf0,0x3ed4cdd2,2 +np.float32,0x3f6fb858,0x3f55ef63,2 +np.float32,0xff227d0a,0xc2b1ec3f,2 +np.float32,0xfeb9a202,0xc2b0cd89,2 +np.float32,0x7f5b12c1,0x42b2853b,2 +np.float32,0x584578,0x584578,2 +np.float32,0x7ec0b76f,0x42b0e0b5,2 +np.float32,0x3f57f54b,0x3f442f10,2 +np.float32,0x7eef3620,0x42b14f5d,2 +np.float32,0x4525b5,0x4525b5,2 +np.float32,0x801bd407,0x801bd407,2 +np.float32,0xbed1f166,0xbecc7703,2 +np.float32,0x3f57e732,0x3f442449,2 +np.float32,0x80767cd5,0x80767cd5,2 +np.float32,0xbef1a7d2,0xbee97aa3,2 +np.float32,0x3dd5b1af,0x3dd54ee6,2 +np.float32,0x960c,0x960c,2 +np.float32,0x7c392d41,0x42a9ddd1,2 +np.float32,0x3f5c9a34,0x3f47b7c1,2 +np.float32,0x3f5cecee,0x3f47f667,2 +np.float32,0xbee482ce,0xbedd8899,2 +np.float32,0x8066ba7e,0x8066ba7e,2 +np.float32,0x7ed76127,0x42b119a2,2 +np.float32,0x805ca40b,0x805ca40b,2 +np.float32,0x7f5ed5d1,0x42b28df3,2 +np.float32,0xfe9e1b1e,0xc2b07b5b,2 +np.float32,0x3f0201a2,0x3ef9f6c4,2 +np.float32,0xbf2e6430,0xbf232039,2 +np.float32,0x80326b4d,0x80326b4d,2 +np.float32,0x3f11dc7c,0x3f0af06e,2 +np.float32,0xbe89c42e,0xbe8827e6,2 +np.float32,0x3f3c69f8,0x3f2e9133,2 +np.float32,0x806326a9,0x806326a9,2 +np.float32,0x3f1c5286,0x3f13f2b6,2 +np.float32,0xff5c0ead,0xc2b28786,2 +np.float32,0xff32b952,0xc2b21d01,2 +np.float32,0x7dd27c4e,0x42ae4815,2 +np.float32,0xbf7a6816,0xbf5da7a2,2 +np.float32,0xfeac72f8,0xc2b0a7d1,2 +np.float32,0x335ad7,0x335ad7,2 +np.float32,0xbe682da4,0xbe663bcc,2 +np.float32,0x3f2df244,0x3f22c208,2 +np.float32,0x80686e8e,0x80686e8e,2 +np.float32,0x7f50120f,0x42b26ad9,2 +np.float32,0x3dbc596a,0x3dbc15b3,2 +np.float32,0xbf4f2868,0xbf3d666d,2 +np.float32,0x80000001,0x80000001,2 +np.float32,0xff66c059,0xc2b29fd2,2 +np.float32,0xfe8bbcaa,0xc2b03c1f,2 +np.float32,0x3ece6a51,0x3ec93271,2 +np.float32,0x7f06cd26,0x42b18c9a,2 +np.float32,0x7e41e6dc,0x42af80f5,2 +np.float32,0x7d878334,0x42ad669f,2 +np.float32,0xfe8c5c4c,0xc2b03e67,2 +np.float32,0x337a05,0x337a05,2 +np.float32,0x3e63801d,0x3e61ab58,2 +np.float32,0x62c315,0x62c315,2 +np.float32,0x802aa888,0x802aa888,2 +np.float32,0x80038b43,0x80038b43,2 +np.float32,0xff5c1271,0xc2b2878f,2 +np.float32,0xff4184a5,0xc2b245b9,2 +np.float32,0x7ef58f4b,0x42b15cc6,2 +np.float32,0x7f42d8ac,0x42b2493a,2 +np.float32,0x806609f2,0x806609f2,2 +np.float32,0x801e763b,0x801e763b,2 +np.float32,0x7f2bc073,0x42b208a2,2 +np.float32,0x801d7d7f,0x801d7d7f,2 +np.float32,0x7d415dc1,0x42acb9c2,2 +np.float32,0xbf624ff9,0xbf4c0502,2 +np.float32,0xbf603afd,0xbf4a74e2,2 +np.float32,0x8007fe42,0x8007fe42,2 +np.float32,0x800456db,0x800456db,2 +np.float32,0x620871,0x620871,2 +np.float32,0x3e9c6c1e,0x3e9a15fa,2 +np.float32,0x4245d,0x4245d,2 +np.float32,0x8035bde9,0x8035bde9,2 +np.float32,0xbf597418,0xbf45533c,2 +np.float32,0x3c730f80,0x3c730d38,2 +np.float32,0x3f7cd8ed,0x3f5f6540,2 +np.float32,0x807e49c3,0x807e49c3,2 +np.float32,0x3d6584c0,0x3d65660c,2 +np.float32,0xff42a744,0xc2b248b8,2 +np.float32,0xfedc6f56,0xc2b12583,2 +np.float32,0x806263a4,0x806263a4,2 +np.float32,0x175a17,0x175a17,2 +np.float32,0x3f1e8537,0x3f15d208,2 +np.float32,0x4055b5,0x4055b5,2 +np.float32,0x438aa6,0x438aa6,2 +np.float32,0x8038507f,0x8038507f,2 +np.float32,0xbed75348,0xbed16f85,2 +np.float32,0x7f07b7d6,0x42b19012,2 +np.float32,0xfe8b9d30,0xc2b03bac,2 +np.float32,0x805c501c,0x805c501c,2 +np.float32,0x3ef22b1d,0x3ee9f159,2 +np.float32,0x802b6759,0x802b6759,2 +np.float32,0x45281a,0x45281a,2 +np.float32,0xbf7e9970,0xbf60a3cf,2 +np.float32,0xbf14d152,0xbf0d8062,2 +np.float32,0x3d9ff950,0x3d9fcfc8,2 +np.float32,0x7865d9,0x7865d9,2 +np.float32,0xbee67fa4,0xbedf58eb,2 +np.float32,0x7dc822d1,0x42ae2e44,2 +np.float32,0x3f3af0fe,0x3f2d612c,2 +np.float32,0xbefea106,0xbef5274e,2 +np.float32,0xbf758a3f,0xbf5a28c5,2 +np.float32,0xbf331bdd,0xbf270209,2 +np.float32,0x7f51c901,0x42b26f0d,2 +np.float32,0x3f67c33b,0x3f5014d8,2 +np.float32,0xbbc9d980,0xbbc9d92c,2 +np.float32,0xbc407540,0xbc40741e,2 +np.float32,0x7eed9a3c,0x42b14be9,2 +np.float32,0x1be0fe,0x1be0fe,2 +np.float32,0xbf6b4913,0xbf52af1f,2 +np.float32,0xbda8eba8,0xbda8bac6,2 +np.float32,0x8004bcea,0x8004bcea,2 +np.float32,0xff6f6afe,0xc2b2b2b3,2 +np.float32,0xbf205810,0xbf175e50,2 +np.float32,0x80651944,0x80651944,2 +np.float32,0xbec73016,0xbec27a3f,2 +np.float32,0x5701b9,0x5701b9,2 +np.float32,0xbf1062ce,0xbf09a7df,2 +np.float32,0x3e0306ae,0x3e02abd1,2 +np.float32,0x7bfc62,0x7bfc62,2 +np.float32,0xbf48dd3c,0xbf387a6b,2 +np.float32,0x8009573e,0x8009573e,2 +np.float32,0x660a2c,0x660a2c,2 +np.float32,0xff2280da,0xc2b1ec4b,2 +np.float32,0xbf7034fe,0xbf564a54,2 +np.float32,0xbeeb448e,0xbee3b045,2 +np.float32,0xff4e949c,0xc2b2672b,2 +np.float32,0xbf3c4486,0xbf2e7309,2 +np.float32,0x7eb086d8,0x42b0b3c8,2 +np.float32,0x7eac8aca,0x42b0a817,2 +np.float32,0xfd3d2d60,0xc2acae8b,2 +np.float32,0xbf363226,0xbf2987bd,2 +np.float32,0x7f02e524,0x42b17d8c,2 +np.float32,0x8049a148,0x8049a148,2 +np.float32,0x147202,0x147202,2 +np.float32,0x8031d3f6,0x8031d3f6,2 +np.float32,0xfe78bf68,0xc2b0007d,2 +np.float32,0x7ebd16d0,0x42b0d6fb,2 +np.float32,0xbdaed2e8,0xbdae9cbb,2 +np.float32,0x802833ae,0x802833ae,2 +np.float32,0x7f62adf6,0x42b296b5,2 +np.float32,0xff2841c0,0xc2b1fe1b,2 +np.float32,0xbeb2c47e,0xbeaf523b,2 +np.float32,0x7e42a36e,0x42af82e6,2 +np.float32,0x41ea29,0x41ea29,2 +np.float32,0xbcaaa800,0xbcaaa4d7,2 +np.float64,0x3fed71f27ebae3e5,0x3fea5c6095012ca6,1 +np.float64,0x224dc392449b9,0x224dc392449b9,1 +np.float64,0x3fdf897a7d3f12f5,0x3fde620339360992,1 +np.float64,0xbfe1f99a5123f334,0xbfe124a57cfaf556,1 +np.float64,0xbfd9725c3bb2e4b8,0xbfd8d1e3f75110c7,1 +np.float64,0x3fe38977546712ee,0x3fe27d9d37f4b91f,1 +np.float64,0xbfc36c29e526d854,0xbfc3594743ee45c4,1 +np.float64,0xbfe5cbec332b97d8,0xbfe4638802316849,1 +np.float64,0x2ff35efe5fe6d,0x2ff35efe5fe6d,1 +np.float64,0x7fd3f828e227f051,0x40862a7d4a40b1e0,1 +np.float64,0xffd06fc11620df82,0xc08628ee8f1bf6c8,1 +np.float64,0x3fe5321bf4aa6438,0x3fe3e3d9fa453199,1 +np.float64,0xffd07a323ca0f464,0xc08628f3a2930f8c,1 +np.float64,0x3fdf7abe7abef57c,0x3fde54cb193d49cb,1 +np.float64,0x40941f1881285,0x40941f1881285,1 +np.float64,0xffef18defc7e31bd,0xc0863393f2c9f061,1 +np.float64,0xbfe379f871e6f3f1,0xbfe270620cb68347,1 +np.float64,0xffec829848f90530,0xc08632e210edaa2b,1 +np.float64,0x80070c00574e1801,0x80070c00574e1801,1 +np.float64,0xffce7654b23ceca8,0xc086285291e89975,1 +np.float64,0x7fc9932daa33265a,0x408626ec6cc2b807,1 +np.float64,0x355ee98c6abde,0x355ee98c6abde,1 +np.float64,0x3fac54962c38a920,0x3fac50e40b6c19f2,1 +np.float64,0x800857984af0af31,0x800857984af0af31,1 +np.float64,0x7fea6a3d55f4d47a,0x40863245bf39f179,1 +np.float64,0x3fdb8fab33371f56,0x3fdac5ffc9e1c347,1 +np.float64,0x800a887a7bf510f5,0x800a887a7bf510f5,1 +np.float64,0xbfbdbda3c63b7b48,0xbfbdac9dd5a2d3e8,1 +np.float64,0xbfd4a2457b29448a,0xbfd44acb3b316d6d,1 +np.float64,0x7fd5329a502a6534,0x40862af789b528b5,1 +np.float64,0x3fd96a7bceb2d4f8,0x3fd8ca92104d6cd6,1 +np.float64,0x3fde6a0cd6bcd41a,0x3fdd5f4b85abf749,1 +np.float64,0xbfc7faaff32ff560,0xbfc7d7560b8c4a52,1 +np.float64,0x7fec381b2f787035,0x408632cd0e9c095c,1 +np.float64,0x1fc2eb543f85e,0x1fc2eb543f85e,1 +np.float64,0x7ac6000af58c1,0x7ac6000af58c1,1 +np.float64,0xffe060a87920c150,0xc0862e72c37d5a4e,1 +np.float64,0xbfb7d8c89e2fb190,0xbfb7cffd3c3f8e3a,1 +np.float64,0x3fd91033deb22068,0x3fd87695b067aa1e,1 +np.float64,0x3fec1aff01b835fe,0x3fe95d5cbd729af7,1 +np.float64,0x7fb97f69ec32fed3,0x4086215aaae5c697,1 +np.float64,0x7feaf1e4e5f5e3c9,0x4086326e6ca6a2bb,1 +np.float64,0x800537e44d0a6fc9,0x800537e44d0a6fc9,1 +np.float64,0x800b2a0d0d36541a,0x800b2a0d0d36541a,1 +np.float64,0x3fe2193846e43270,0x3fe140308550138e,1 +np.float64,0x5e2a0a32bc542,0x5e2a0a32bc542,1 +np.float64,0xffe5888b09eb1116,0xc08630a348783aa3,1 +np.float64,0xbfceb9b5033d736c,0xbfce701049c10435,1 +np.float64,0x7fe5d68589abad0a,0x408630c00ce63f23,1 +np.float64,0x8009b5457ff36a8b,0x8009b5457ff36a8b,1 +np.float64,0xbfb5518c2e2aa318,0xbfb54b42638ca718,1 +np.float64,0x3f9c58469838b080,0x3f9c575974fbcd7b,1 +np.float64,0x3fe8db4b4731b697,0x3fe6dc9231587966,1 +np.float64,0x8007d0f77f4fa1f0,0x8007d0f77f4fa1f0,1 +np.float64,0x7fe79eef542f3dde,0x40863160c673c67f,1 +np.float64,0xffbdc0b6163b8170,0xc0862296be4bf032,1 +np.float64,0x3fbb8d3312371a66,0x3fbb7fa76fb4cf8d,1 +np.float64,0xffd8a0eedbb141de,0xc0862c2ac6e512f0,1 +np.float64,0x7fee99d8d87d33b1,0x4086337301c4c8df,1 +np.float64,0xffe7479b552e8f36,0xc0863142fba0f0ec,1 +np.float64,0xffedf8ef4abbf1de,0xc08633488068fe69,1 +np.float64,0x895c4d9f12b8a,0x895c4d9f12b8a,1 +np.float64,0x29b4caf05369a,0x29b4caf05369a,1 +np.float64,0xbfefb90d657f721b,0xbfec01efa2425b35,1 +np.float64,0xde07c3bdbc0f9,0xde07c3bdbc0f9,1 +np.float64,0x7feae9fd02f5d3f9,0x4086326c1368ed5a,1 +np.float64,0x3feab792da756f26,0x3fe84f6e15338ed7,1 +np.float64,0xbfeff8ed72fff1db,0xbfec2f35da06daaf,1 +np.float64,0x8004b2c132896583,0x8004b2c132896583,1 +np.float64,0xbf9fcb00103f9600,0xbf9fc9b1751c569e,1 +np.float64,0x4182b72e83058,0x4182b72e83058,1 +np.float64,0x90820d812105,0x90820d812105,1 +np.float64,0xbfdec9a0ba3d9342,0xbfddb585df607ce1,1 +np.float64,0x7fdc0a69a03814d2,0x40862d347f201b63,1 +np.float64,0xbfef0708937e0e11,0xbfeb82d27f8ea97f,1 +np.float64,0xffda57e4ddb4afca,0xc0862cb49e2e0c4c,1 +np.float64,0xbfa30b9af4261730,0xbfa30a7b4a633060,1 +np.float64,0x7feb57fcc4b6aff9,0x4086328c83957a0b,1 +np.float64,0x7fe6759153eceb22,0x408630f980433963,1 +np.float64,0x7fdd3278c8ba64f1,0x40862d87445243e9,1 +np.float64,0xd3b8e6b9a771d,0xd3b8e6b9a771d,1 +np.float64,0x6267dc88c4cfc,0x6267dc88c4cfc,1 +np.float64,0x7fedd3cf00bba79d,0x4086333e91712ff5,1 +np.float64,0xffbe512ce03ca258,0xc08622bd39314cea,1 +np.float64,0xbfe71742ca6e2e86,0xbfe572ccbf2d010d,1 +np.float64,0x8002fb048c65f60a,0x8002fb048c65f60a,1 +np.float64,0x800d9d9ddf7b3b3c,0x800d9d9ddf7b3b3c,1 +np.float64,0xbfeaf6230df5ec46,0xbfe87f5d751ec3d5,1 +np.float64,0xbfe69973a42d32e8,0xbfe50c680f7002fe,1 +np.float64,0x3fe309cf87e613a0,0x3fe21048714ce1ac,1 +np.float64,0x800435d17a286ba4,0x800435d17a286ba4,1 +np.float64,0x7fefffffffffffff,0x408633ce8fb9f87e,1 +np.float64,0x3fe36ade1766d5bc,0x3fe26379fb285dde,1 +np.float64,0x3f98d8d94831b1c0,0x3f98d839885dc527,1 +np.float64,0xbfd08f7ae5211ef6,0xbfd0618ab5293e1e,1 +np.float64,0xbfcf630bd53ec618,0xbfcf14a0cd20704d,1 +np.float64,0xbfe58f0ca6eb1e1a,0xbfe4312225df8e28,1 +np.float64,0xffef4f6406be9ec7,0xc08633a1ed1d27e5,1 +np.float64,0x7fe10120b3e20240,0x40862ebfaf94e6e8,1 +np.float64,0xffe96c52fbb2d8a5,0xc08631f75d9a59a0,1 +np.float64,0xbfe448a333e89146,0xbfe31fee44c3ec43,1 +np.float64,0x80045ff4e788bfeb,0x80045ff4e788bfeb,1 +np.float64,0x7fefaa2f823f545e,0x408633b8fea29524,1 +np.float64,0xffea6b8bf234d717,0xc0863246248e5960,1 +np.float64,0xbfdb085d80b610bc,0xbfda498b15b43eec,1 +np.float64,0xbfd5e12da3abc25c,0xbfd57970e2b8aecc,1 +np.float64,0x3fcc84928a390925,0x3fcc497c417a89f3,1 +np.float64,0xbfdcb713bf396e28,0xbfdbd46c5e731fd9,1 +np.float64,0xffdf50c0453ea180,0xc0862e16b5562f25,1 +np.float64,0x800342c2f7268587,0x800342c2f7268587,1 +np.float64,0x7feb8b6d743716da,0x4086329b8248de2c,1 +np.float64,0x800a9b18b4953632,0x800a9b18b4953632,1 +np.float64,0xffedaf0d12fb5e19,0xc0863334af82de1a,1 +np.float64,0x800aebda4ab5d7b5,0x800aebda4ab5d7b5,1 +np.float64,0xbfa9f5848433eb10,0xbfa9f2ac7ac065d4,1 +np.float64,0x3fea375928f46eb2,0x3fe7ec9f10eeac7d,1 +np.float64,0x3fd6c213fead8428,0x3fd64dcc1eff5f1b,1 +np.float64,0xbfa0476f44208ee0,0xbfa046bb986007ac,1 +np.float64,0x6c8e18aed91c4,0x6c8e18aed91c4,1 +np.float64,0x8000000000000001,0x8000000000000001,1 +np.float64,0x7fea86b5ba350d6a,0x4086324e59f13027,1 +np.float64,0x2316c3b0462d9,0x2316c3b0462d9,1 +np.float64,0x3fec4e3281389c65,0x3fe983c5c9d65940,1 +np.float64,0x3fbb87c47f772,0x3fbb87c47f772,1 +np.float64,0x8004af00fdc95e03,0x8004af00fdc95e03,1 +np.float64,0xbfd316db9ba62db8,0xbfd2d12765b9d155,1 +np.float64,0x3fec1a7a99f834f6,0x3fe95cf941889b3d,1 +np.float64,0x3feff7e1477fefc3,0x3fec2e782392d4b9,1 +np.float64,0xbfc683ea042d07d4,0xbfc66698cfa5026e,1 +np.float64,0x3fdbc8aaa9b79154,0x3fdafa50e6fc3fff,1 +np.float64,0xfb3b630ff676d,0xfb3b630ff676d,1 +np.float64,0x7fe715ef8eae2bde,0x40863131d794b41f,1 +np.float64,0x7fefa06c11bf40d7,0x408633b686c7996a,1 +np.float64,0x80002a40f5205483,0x80002a40f5205483,1 +np.float64,0x7fe95f3c74b2be78,0x408631f33e37bf76,1 +np.float64,0x3fb2977b32252ef0,0x3fb2934eaf5a4be8,1 +np.float64,0x3fc0f3dbc821e7b8,0x3fc0e745288c84c3,1 +np.float64,0x3fda98da56b531b5,0x3fd9e2b19447dacc,1 +np.float64,0x3f95b9d5202b73aa,0x3f95b96a53282949,1 +np.float64,0x3fdc1ace7738359d,0x3fdb4597d31df7ff,1 +np.float64,0xffeac5bb2e358b76,0xc0863261452ab66c,1 +np.float64,0xbfefb1b78f7f636f,0xbfebfcb9be100ced,1 +np.float64,0xf5c9e191eb93c,0xf5c9e191eb93c,1 +np.float64,0x3fe83a977630752f,0x3fe65d0df90ff6ef,1 +np.float64,0x3fc317515d262ea0,0x3fc3056072b719f0,1 +np.float64,0x7fe2dcfab225b9f4,0x40862f94257c28a2,1 +np.float64,0xca2b115794562,0xca2b115794562,1 +np.float64,0x3fd495301aa92a60,0x3fd43e57108761d5,1 +np.float64,0x800ccc4293199885,0x800ccc4293199885,1 +np.float64,0xc8d3173d91a63,0xc8d3173d91a63,1 +np.float64,0xbf2541bb7e4a8,0xbf2541bb7e4a8,1 +np.float64,0xbfe9a330df334662,0xbfe779816573f5be,1 +np.float64,0xffd5e4c8252bc990,0xc0862b39b3ca5d72,1 +np.float64,0x3fe90f3a53721e75,0x3fe70585ae09531d,1 +np.float64,0xbfe2b5ddc7a56bbc,0xbfe1c7fa91a675ed,1 +np.float64,0xbf981a0360303400,0xbf9819719345073a,1 +np.float64,0x19174b0e322ea,0x19174b0e322ea,1 +np.float64,0xbfd2f71a1725ee34,0xbfd2b2b6f7cd10b1,1 +np.float64,0x80056e83236add07,0x80056e83236add07,1 +np.float64,0x7fe4bc41d9697883,0x40863055f20ce0cb,1 +np.float64,0xffe76e06c46edc0d,0xc086315024b25559,1 +np.float64,0x3fe3c4f0f96789e2,0x3fe2b04b584609bf,1 +np.float64,0x3fe6cfc533ed9f8a,0x3fe538b4d784d5ee,1 +np.float64,0x7fd234a640a4694c,0x408629bfead4f0b2,1 +np.float64,0x3fdbc49c9ab78939,0x3fdaf698a83d08e2,1 +np.float64,0x3fe4c5336ee98a66,0x3fe388c6ddb60e0a,1 +np.float64,0xf4b9497be9729,0xf4b9497be9729,1 +np.float64,0x3fb312be12262580,0x3fb30e3c847c1d16,1 +np.float64,0x3fe9554218f2aa84,0x3fe73c8b311c7a98,1 +np.float64,0xff899816a0333040,0xc08610bfb2cd8559,1 +np.float64,0x8006008ad52c0116,0x8006008ad52c0116,1 +np.float64,0x3fd7d47be4afa8f8,0x3fd74fa71ec17fd0,1 +np.float64,0x8010000000000000,0x8010000000000000,1 +np.float64,0xdf2a9943be553,0xdf2a9943be553,1 +np.float64,0xbfeb86bf1eb70d7e,0xbfe8ed797580ba5c,1 +np.float64,0x800e2c0c28bc5818,0x800e2c0c28bc5818,1 +np.float64,0xbfe2be65d4657ccc,0xbfe1cf578dec2323,1 +np.float64,0xbfedea3a5afbd475,0xbfeab490bf05e585,1 +np.float64,0xbfe04b1583a0962b,0xbfdf523dfd7be25c,1 +np.float64,0x75929bb4eb254,0x75929bb4eb254,1 +np.float64,0x3fd7b4968caf692d,0x3fd731c0938ff97c,1 +np.float64,0x60bd8fd2c17b3,0x60bd8fd2c17b3,1 +np.float64,0xbfdaf15e70b5e2bc,0xbfda345a95ce18fe,1 +np.float64,0x7fdd7c35c2baf86b,0x40862d9b5f40c6b2,1 +np.float64,0x7feeb4d2ab7d69a4,0x4086337a0c0dffaf,1 +np.float64,0xffe65b5a1decb6b4,0xc08630f024420efb,1 +np.float64,0x7feb272b30764e55,0x4086327e2e553aa2,1 +np.float64,0x3fd27513e8a4ea28,0x3fd235ea49670f6a,1 +np.float64,0x3fe6541a6aeca834,0x3fe4d3a5b69fd1b6,1 +np.float64,0xbfe0c6ca0f618d94,0xbfe017058259efdb,1 +np.float64,0x7fc1bf07b7237e0e,0x4086240000fa5a52,1 +np.float64,0x7fe96af9c0f2d5f3,0x408631f6f0f4faa2,1 +np.float64,0x3fe0728be7a0e518,0x3fdf9881a5869de9,1 +np.float64,0xffe8ea4441b1d488,0xc08631ce0685ae7e,1 +np.float64,0xffd0b973f02172e8,0xc08629121e7fdf85,1 +np.float64,0xffe37b907a26f720,0xc0862fd6529401a0,1 +np.float64,0x3fe0ee826461dd05,0x3fe03a2a424a1b40,1 +np.float64,0xbfe8073c92300e79,0xbfe6340cbd179ac1,1 +np.float64,0x800768383f8ed071,0x800768383f8ed071,1 +np.float64,0x8002e467c7c5c8d0,0x8002e467c7c5c8d0,1 +np.float64,0xbfd8d53ea5b1aa7e,0xbfd83fa7243289d7,1 +np.float64,0xffebefce2bb7df9c,0xc08632b874f4f8dc,1 +np.float64,0xffe3be9eb9277d3d,0xc0862ff1ac70ad0b,1 +np.float64,0xffe2f8a82e65f150,0xc0862f9fd9e77d86,1 +np.float64,0xbfa01d151c203a30,0xbfa01c66dc13a70a,1 +np.float64,0x800877062d30ee0d,0x800877062d30ee0d,1 +np.float64,0xaade16a755bc3,0xaade16a755bc3,1 +np.float64,0xbfeb1abc70363579,0xbfe89b52c3b003aa,1 +np.float64,0x80097d0b2ad2fa17,0x80097d0b2ad2fa17,1 +np.float64,0x8001499907429333,0x8001499907429333,1 +np.float64,0x3fe8db2aaf71b656,0x3fe6dc7873f1b235,1 +np.float64,0x5cfeadc4b9fd6,0x5cfeadc4b9fd6,1 +np.float64,0xff3f77d1fe7ef,0xff3f77d1fe7ef,1 +np.float64,0xffeecd56f9bd9aad,0xc08633806cb1163d,1 +np.float64,0xbf96f3ca582de7a0,0xbf96f34c6b8e1c85,1 +np.float64,0x7ed6b44afdad7,0x7ed6b44afdad7,1 +np.float64,0x80071808da4e3012,0x80071808da4e3012,1 +np.float64,0x3feb8aee2bf715dc,0x3fe8f0a55516615c,1 +np.float64,0x800038f62e2071ed,0x800038f62e2071ed,1 +np.float64,0x3fb13f9af2227f30,0x3fb13c456ced8e08,1 +np.float64,0xffd584d1812b09a4,0xc0862b165558ec0c,1 +np.float64,0x800b20c30fb64186,0x800b20c30fb64186,1 +np.float64,0x80024f9646e49f2d,0x80024f9646e49f2d,1 +np.float64,0xffefffffffffffff,0xc08633ce8fb9f87e,1 +np.float64,0x3fdddbcb5bbbb797,0x3fdcde981111f650,1 +np.float64,0xffed14077f3a280e,0xc086330a795ad634,1 +np.float64,0x800fec2da7ffd85b,0x800fec2da7ffd85b,1 +np.float64,0x3fe8205ffc7040c0,0x3fe6482318d217f9,1 +np.float64,0x3013e5226027d,0x3013e5226027d,1 +np.float64,0xffe4e5aad469cb55,0xc0863065dc2fb4e3,1 +np.float64,0x5cb0f7b2b9620,0x5cb0f7b2b9620,1 +np.float64,0xbfeb4537d2768a70,0xbfe8bbb2c1d3bff9,1 +np.float64,0xbfd859e297b0b3c6,0xbfd7cc807948bf9d,1 +np.float64,0x71f00b8ce3e02,0x71f00b8ce3e02,1 +np.float64,0xf5c1b875eb837,0xf5c1b875eb837,1 +np.float64,0xa0f35c8141e8,0xa0f35c8141e8,1 +np.float64,0xffe24860b42490c1,0xc0862f54222f616e,1 +np.float64,0xffcd9ae8583b35d0,0xc08628181e643a42,1 +np.float64,0x7fe9b710c7736e21,0x4086320ec033490f,1 +np.float64,0x3fd2b9ca1d257394,0x3fd277e631f0c0b3,1 +np.float64,0x23559bfc46ab4,0x23559bfc46ab4,1 +np.float64,0x8002adf75e455bef,0x8002adf75e455bef,1 +np.float64,0xbfefa4d75cbf49af,0xbfebf392e51d6a1a,1 +np.float64,0xffcfef263e3fde4c,0xc08628b336adb611,1 +np.float64,0x80061acaa8ec3596,0x80061acaa8ec3596,1 +np.float64,0x7fc1b33be0236677,0x408623faaddcc17e,1 +np.float64,0x7fe3a84083675080,0x40862fe8972e41e1,1 +np.float64,0xbfe756c1276ead82,0xbfe5a6318b061e1b,1 +np.float64,0xbfae4b71b43c96e0,0xbfae46ed0b6203a4,1 +np.float64,0x800421c6d0a8438e,0x800421c6d0a8438e,1 +np.float64,0x8009ad56fe335aae,0x8009ad56fe335aae,1 +np.float64,0xbfe71afc976e35f9,0xbfe575d21f3d7193,1 +np.float64,0x7fec0bbe4c38177c,0x408632c0710f1d8a,1 +np.float64,0x750e1daeea1c4,0x750e1daeea1c4,1 +np.float64,0x800501d4240a03a9,0x800501d4240a03a9,1 +np.float64,0x800794955cef292b,0x800794955cef292b,1 +np.float64,0x3fdf8a87f5bf1510,0x3fde62f4f00cfa19,1 +np.float64,0xbfebebdbc7f7d7b8,0xbfe939e51ba1340c,1 +np.float64,0xbfe3a16217a742c4,0xbfe292039dd08a71,1 +np.float64,0x3fed6cd04c3ad9a1,0x3fea58995973f74b,1 +np.float64,0xffcad8787335b0f0,0xc086274fbb35dd37,1 +np.float64,0x3fcb178e3d362f1c,0x3fcae4c9f3e6dddc,1 +np.float64,0xbfcadc669435b8cc,0xbfcaaae7cf075420,1 +np.float64,0x7fe0e3906321c720,0x40862eb1bacc5c43,1 +np.float64,0xff8ad5edb035abc0,0xc0861120b6404d0b,1 +np.float64,0x3fe175a21562eb44,0x3fe0b13120a46549,1 +np.float64,0xbfeb4c4a5f769895,0xbfe8c1147f1c9d8f,1 +np.float64,0x7fca22f4e63445e9,0x40862718e9b4094e,1 +np.float64,0x3fe4269d0c684d3a,0x3fe3032aa2015c53,1 +np.float64,0x3fef551c09beaa38,0x3febbabe03f49c83,1 +np.float64,0xffd843df9fb087c0,0xc0862c0c52d5e5d9,1 +np.float64,0x7fc497e2ca292fc5,0x40862530bbd9fcc7,1 +np.float64,0x3fee02919efc0523,0x3feac655588a4acd,1 +np.float64,0x7fed1e52c0fa3ca5,0x4086330d4ddd8a2c,1 +np.float64,0xba04d4ef7409b,0xba04d4ef7409b,1 +np.float64,0x3fee22d0937c45a2,0x3feaddd4ca66b447,1 +np.float64,0xffeb2558cf764ab1,0xc086327da4e84053,1 +np.float64,0xbfe103d987e207b3,0xbfe04d04818ad1ff,1 +np.float64,0x3f9fd7fed03faffe,0x3f9fd6ae9a45be84,1 +np.float64,0x800a53ec4c34a7d9,0x800a53ec4c34a7d9,1 +np.float64,0xbfe2feb17f65fd63,0xbfe206b9d33a78a2,1 +np.float64,0x989bdd613139,0x989bdd613139,1 +np.float64,0xbfdd0ad3fb3a15a8,0xbfdc20c32a530741,1 +np.float64,0xbfc4222163284444,0xbfc40d1c612784b5,1 +np.float64,0xc30cf5c78619f,0xc30cf5c78619f,1 +np.float64,0x3fe913bd6732277b,0x3fe70912f76bad71,1 +np.float64,0x98f175f531e2f,0x98f175f531e2f,1 +np.float64,0x3fed8c1f717b183f,0x3fea6f9fb3af3423,1 +np.float64,0x7fee46b085bc8d60,0x4086335d269eb7e9,1 +np.float64,0x8007480f564e901f,0x8007480f564e901f,1 +np.float64,0xc9b96e179372e,0xc9b96e179372e,1 +np.float64,0x3fe44deac4289bd6,0x3fe32463a74a69e7,1 +np.float64,0x80021d6c5c243ad9,0x80021d6c5c243ad9,1 +np.float64,0xbfebc805a6f7900b,0xbfe91edcf65a1c19,1 +np.float64,0x80044748adc88e92,0x80044748adc88e92,1 +np.float64,0x4007ee44800fe,0x4007ee44800fe,1 +np.float64,0xbfe24307a4648610,0xbfe1648ad5c47b6f,1 +np.float64,0xbfee6d3a93fcda75,0xbfeb13e1a3196e78,1 +np.float64,0x3fe49a287f293451,0x3fe364a11b9f0068,1 +np.float64,0x80052b37ceaa5670,0x80052b37ceaa5670,1 +np.float64,0xbfd42be893a857d2,0xbfd3da05dac7c286,1 +np.float64,0xffb4bbe4ac2977c8,0xc0861fb31bda6956,1 +np.float64,0xbfc732a4142e6548,0xbfc7129a4eafa399,1 +np.float64,0x7fd0696791a0d2ce,0x408628eb7756cb9c,1 +np.float64,0x3fe46c8f8d68d91f,0x3fe33e3df16187c1,1 +np.float64,0x3fe3a28f1ce7451e,0x3fe293043238d08c,1 +np.float64,0xffedc4eb723b89d6,0xc086333a92258c15,1 +np.float64,0x8000d15b4c41a2b7,0x8000d15b4c41a2b7,1 +np.float64,0xffeb73450236e689,0xc08632947b0148ab,1 +np.float64,0xffe68cf4722d19e8,0xc0863101d08d77bd,1 +np.float64,0x800c70eb4698e1d7,0x800c70eb4698e1d7,1 +np.float64,0xffa94387ff529,0xffa94387ff529,1 +np.float64,0x7fe3835d996706ba,0x40862fd985ff8e7d,1 +np.float64,0x3fe55e476feabc8e,0x3fe408a15594ec52,1 +np.float64,0xffc69672222d2ce4,0xc08625ee0c4c0f6a,1 +np.float64,0xbf9d900b883b2020,0xbf9d8efe811d36df,1 +np.float64,0xbfdb9b9755b7372e,0xbfdad0f2aa2cb110,1 +np.float64,0xffeade6073b5bcc0,0xc08632689f17a25d,1 +np.float64,0xffd1d6a6baa3ad4e,0xc086299630a93a7b,1 +np.float64,0x7fd05ba25620b744,0x408628e4be1ef845,1 +np.float64,0xbfc7d422d52fa844,0xbfc7b170a61531bf,1 +np.float64,0x3fd5196797aa32d0,0x3fd4bc0f0e7d8e1d,1 +np.float64,0x617594a4c2eb3,0x617594a4c2eb3,1 +np.float64,0x7fd779bc4caef378,0x40862bc89271b882,1 +np.float64,0xffd2fb262ba5f64c,0xc0862a15561e9524,1 +np.float64,0x72fd661ae5fad,0x72fd661ae5fad,1 +np.float64,0x3fecf441f339e884,0x3fe9ff880d584f64,1 +np.float64,0x7fc3a8968827512c,0x408624d198b05c61,1 +np.float64,0x3fe7a25c56ef44b9,0x3fe5e32509a7c32d,1 +np.float64,0x7fd117d514222fa9,0x4086293ec640d5f2,1 +np.float64,0x3fe37dfe5ee6fbfc,0x3fe273d1bcaa1ef0,1 +np.float64,0xbfed4cd19d7a99a3,0xbfea41064cba4c8b,1 +np.float64,0x8003ff12aaa7fe26,0x8003ff12aaa7fe26,1 +np.float64,0x3fcbc3d1193787a2,0x3fcb8d39e3e88264,1 +np.float64,0xe9ba1a91d3744,0xe9ba1a91d3744,1 +np.float64,0x8002ab71998556e4,0x8002ab71998556e4,1 +np.float64,0x800110057922200c,0x800110057922200c,1 +np.float64,0xbfe3b7af19a76f5e,0xbfe2a502fc0a2882,1 +np.float64,0x7fd9de9d5e33bd3a,0x40862c8f73cccabf,1 +np.float64,0xbfba0f0a86341e18,0xbfba0392f44c2771,1 +np.float64,0x8000000000000000,0x8000000000000000,1 +np.float64,0x7fe5d162e96ba2c5,0x408630be2b15e01b,1 +np.float64,0x800b7f0eac76fe1e,0x800b7f0eac76fe1e,1 +np.float64,0xff98bed150317da0,0xc086160633164f5f,1 +np.float64,0x3fef91fd70ff23fb,0x3febe629709d0ae7,1 +np.float64,0x7fe5bea7f16b7d4f,0x408630b749f445e9,1 +np.float64,0xbfe3dc428467b885,0xbfe2c41ea93fab07,1 +np.float64,0xbfeba1fbfcf743f8,0xbfe9021b52851bb9,1 +np.float64,0x7fd2fb2108a5f641,0x40862a1553f45830,1 +np.float64,0x7feb8199a4370332,0x40863298a7169dad,1 +np.float64,0x800f97ff8d7f2fff,0x800f97ff8d7f2fff,1 +np.float64,0x3fd5e20b6b2bc417,0x3fd57a42bd1c0993,1 +np.float64,0x8006b4072dad680f,0x8006b4072dad680f,1 +np.float64,0x605dccf2c0bba,0x605dccf2c0bba,1 +np.float64,0x3fc705ed142e0bda,0x3fc6e69971d86f73,1 +np.float64,0xffd2ba1aad257436,0xc08629f9bc918f8b,1 +np.float64,0x8002954e23c52a9d,0x8002954e23c52a9d,1 +np.float64,0xbfecc65da7798cbb,0xbfe9dd745be18562,1 +np.float64,0x7fc66110482cc220,0x408625db0db57ef8,1 +np.float64,0x3fcd09446d3a1289,0x3fcccaf2dd0a41ea,1 +np.float64,0x3febe7095437ce13,0x3fe93642d1e73b2a,1 +np.float64,0x8004773c7da8ee7a,0x8004773c7da8ee7a,1 +np.float64,0x8001833241230665,0x8001833241230665,1 +np.float64,0x3fe6a262db6d44c6,0x3fe513b3dab5adce,1 +np.float64,0xe6282cc1cc506,0xe6282cc1cc506,1 +np.float64,0x800b9d8553973b0b,0x800b9d8553973b0b,1 +np.float64,0x3fdfbe0c7b3f7c19,0x3fde912375d867a8,1 +np.float64,0x7fd5ac11ebab5823,0x40862b24dfc6d08e,1 +np.float64,0x800e4b7cb1fc96f9,0x800e4b7cb1fc96f9,1 +np.float64,0x3fe14706da628e0e,0x3fe0883aec2a917a,1 +np.float64,0x7fc963f97532c7f2,0x408626dd9b0cafe1,1 +np.float64,0xbfe9c250b5b384a2,0xbfe791c5eabcb05d,1 +np.float64,0x3fe8d16e6c71a2dd,0x3fe6d4c7a33a0bf4,1 +np.float64,0x3fe474ae4628e95d,0x3fe34515c93f4733,1 +np.float64,0x3fbf3257ee3e64b0,0x3fbf1eb530e126ea,1 +np.float64,0x8005f089b3abe114,0x8005f089b3abe114,1 +np.float64,0x3fece07bccf9c0f8,0x3fe9f0dc228124d5,1 +np.float64,0xbfc52521632a4a44,0xbfc50ccebdf59c2c,1 +np.float64,0x7fdf53beb13ea77c,0x40862e177918195e,1 +np.float64,0x8003d9f6ad07b3ee,0x8003d9f6ad07b3ee,1 +np.float64,0xffeacf96bbb59f2d,0xc086326436b38b1a,1 +np.float64,0xdccaea29b995e,0xdccaea29b995e,1 +np.float64,0x5948d21eb291b,0x5948d21eb291b,1 +np.float64,0x10000000000000,0x10000000000000,1 +np.float64,0x7fef6d2c543eda58,0x408633a98593cdf5,1 +np.float64,0x7feda454f47b48a9,0x40863331cb6dc9f7,1 +np.float64,0x3fdd377cecba6ef8,0x3fdc4968f74a9c83,1 +np.float64,0x800644096d4c8814,0x800644096d4c8814,1 +np.float64,0xbfe33ca15ae67942,0xbfe23be5de832bd8,1 +np.float64,0xffce9582bd3d2b04,0xc086285abdf9bf9d,1 +np.float64,0x3fe6621e86acc43d,0x3fe4df231bfa93e1,1 +np.float64,0xee7d19e9dcfa3,0xee7d19e9dcfa3,1 +np.float64,0x800be5997277cb33,0x800be5997277cb33,1 +np.float64,0x82069041040e,0x82069041040e,1 +np.float64,0x800d6efdc19addfc,0x800d6efdc19addfc,1 +np.float64,0x7fb27770ee24eee1,0x40861ec5ed91b839,1 +np.float64,0x3fd506064caa0c0d,0x3fd4a9a66353fefd,1 +np.float64,0xbfeca9b36bf95367,0xbfe9c81f03ba37b8,1 +np.float64,0xffeab1b7bab5636f,0xc086325b47f61f2b,1 +np.float64,0xffc99f5b2e333eb8,0xc08626f03b08b412,1 +np.float64,0x3fbf1a71bc3e34e3,0x3fbf06fbcaa5de58,1 +np.float64,0x3fe75015736ea02b,0x3fe5a0cd8d763d8d,1 +np.float64,0xffe6a7442fad4e88,0xc086310b20addba4,1 +np.float64,0x3fe5d62ff86bac60,0x3fe46c033195bf28,1 +np.float64,0x7fd0b1f0362163df,0x4086290e857dc1be,1 +np.float64,0xbe0353737c06b,0xbe0353737c06b,1 +np.float64,0x7fec912d8739225a,0x408632e627704635,1 +np.float64,0xded8ba2fbdb18,0xded8ba2fbdb18,1 +np.float64,0x7fec0b53fdf816a7,0x408632c052bc1bd2,1 +np.float64,0x7fe9640d12b2c819,0x408631f4c2ba54d8,1 +np.float64,0x800be714eeb7ce2a,0x800be714eeb7ce2a,1 +np.float64,0xbfcf444a793e8894,0xbfcef6c126b54853,1 +np.float64,0xffeb20cf1bf6419e,0xc086327c4e6ffe80,1 +np.float64,0xc07de22180fd,0xc07de22180fd,1 +np.float64,0xffed129d387a253a,0xc086330a15ad0adb,1 +np.float64,0x3fd9e94fedb3d2a0,0x3fd94049924706a8,1 +np.float64,0x7fe6ba488c2d7490,0x40863111d51e7861,1 +np.float64,0xbfebbdf25db77be5,0xbfe91740ad7ba521,1 +np.float64,0x7fbc6c3c4838d878,0x40862239160cb613,1 +np.float64,0xbfefa82ecebf505e,0xbfebf5f31957dffd,1 +np.float64,0x800bebeb7ad7d7d7,0x800bebeb7ad7d7d7,1 +np.float64,0x7fecccc6f8f9998d,0x408632f6c6da8aac,1 +np.float64,0xcbe4926197ca,0xcbe4926197ca,1 +np.float64,0x2c5d9fd858bb5,0x2c5d9fd858bb5,1 +np.float64,0xbfe9fb021073f604,0xbfe7bddc61f1151a,1 +np.float64,0xbfebb18572f7630b,0xbfe90ddc5002313f,1 +np.float64,0x13bb0d3227763,0x13bb0d3227763,1 +np.float64,0x3feefa5e5cbdf4bd,0x3feb79b9e8ce16bf,1 +np.float64,0x3fc97f086132fe10,0x3fc9549fc8e15ecb,1 +np.float64,0xffe70887c06e110f,0xc086312d30fd31cf,1 +np.float64,0xa00c113540182,0xa00c113540182,1 +np.float64,0x800950984772a131,0x800950984772a131,1 +np.float64,0x1,0x1,1 +np.float64,0x3fd83b4026b07680,0x3fd7afdc659d9a34,1 +np.float64,0xbfe32348fbe64692,0xbfe226292a706a1a,1 +np.float64,0x800b894dcc77129c,0x800b894dcc77129c,1 +np.float64,0xeb2ca419d6595,0xeb2ca419d6595,1 +np.float64,0xbff0000000000000,0xbfec34366179d427,1 +np.float64,0x3feb269e99f64d3d,0x3fe8a4634b927a21,1 +np.float64,0xbfe83149d7706294,0xbfe655a2b245254e,1 +np.float64,0xbfe6eef3ca6ddde8,0xbfe5521310e24d16,1 +np.float64,0x3fea89a4b7b51349,0x3fe82c1fc69edcec,1 +np.float64,0x800f2a8bf17e5518,0x800f2a8bf17e5518,1 +np.float64,0x800f71fac29ee3f6,0x800f71fac29ee3f6,1 +np.float64,0xe7cb31f1cf966,0xe7cb31f1cf966,1 +np.float64,0x3b0f8752761f2,0x3b0f8752761f2,1 +np.float64,0x3fea27dea3744fbd,0x3fe7e0a4705476b2,1 +np.float64,0xbfa97c019c32f800,0xbfa97950c1257b92,1 +np.float64,0xffeff13647ffe26c,0xc08633cadc7105ed,1 +np.float64,0x3feee162353dc2c4,0x3feb67c2da0fbce8,1 +np.float64,0x80088c0807911810,0x80088c0807911810,1 +np.float64,0x3fe936ab1db26d56,0x3fe72489bc69719d,1 +np.float64,0xa2f84bd545f0a,0xa2f84bd545f0a,1 +np.float64,0xbfed445ed27a88be,0xbfea3acac0aaf482,1 +np.float64,0x800faf3e69df5e7d,0x800faf3e69df5e7d,1 +np.float64,0x3fc145a330228b46,0x3fc13853f11b1c90,1 +np.float64,0xbfe25ec5abe4bd8c,0xbfe17c9e9b486f07,1 +np.float64,0x3fe119b160e23363,0x3fe0604b10178966,1 +np.float64,0x7fe0cbf2836197e4,0x40862ea6831e5f4a,1 +np.float64,0x3fe75dd3b4eebba8,0x3fe5abe80fd628fb,1 +np.float64,0x3f7c391000387220,0x3f7c39015d8f3a36,1 +np.float64,0x899d9cad133b4,0x899d9cad133b4,1 +np.float64,0x3fe5f0e34febe1c6,0x3fe4820cefe138fc,1 +np.float64,0x7fe060dfdba0c1bf,0x40862e72de8afcd0,1 +np.float64,0xbfae42f7103c85f0,0xbfae3e7630819c60,1 +np.float64,0x35f1f2c06be5,0x35f1f2c06be5,1 +np.float64,0xffc5194d362a329c,0xc086256266c8b7ad,1 +np.float64,0xbfda034f1b34069e,0xbfd95860a44c43ad,1 +np.float64,0x32bcebca6579e,0x32bcebca6579e,1 +np.float64,0xbfd1751ebca2ea3e,0xbfd13f79f45bf75c,1 +np.float64,0x3fee4fa1e5bc9f44,0x3feafe69e0d6c1c7,1 +np.float64,0x7f9c03cd5038079a,0x4086170459172900,1 +np.float64,0x7fc5fb6d6d2bf6da,0x408625b6651cfc73,1 +np.float64,0x7ff8000000000000,0x7ff8000000000000,1 +np.float64,0xffd1a8162ca3502c,0xc0862981333931ad,1 +np.float64,0x7fc415c198282b82,0x408624fd8c155d1b,1 +np.float64,0xffda37fbe7b46ff8,0xc0862caae7865c43,1 +np.float64,0xbfef4312257e8624,0xbfebadd89f3ee31c,1 +np.float64,0xbfec45e1fd788bc4,0xbfe97d8b14db6274,1 +np.float64,0xbfe6fdcfd26dfba0,0xbfe55e25b770d00a,1 +np.float64,0x7feb66d424f6cda7,0x40863290d9ff7ea2,1 +np.float64,0x8b08a29916115,0x8b08a29916115,1 +np.float64,0xffe12ca25c625944,0xc0862ed40d769f72,1 +np.float64,0x7ff4000000000000,0x7ffc000000000000,1 +np.float64,0x804925e100925,0x804925e100925,1 +np.float64,0xcebf3e019d9,0xcebf3e019d9,1 +np.float64,0xbfd5d75d4aabaeba,0xbfd57027671dedf7,1 +np.float64,0x800b829ecd37053e,0x800b829ecd37053e,1 +np.float64,0x800b1205daf6240c,0x800b1205daf6240c,1 +np.float64,0x3fdf7e9889befd31,0x3fde583fdff406c3,1 +np.float64,0x7ff0000000000000,0x7ff0000000000000,1 +np.float64,0x3fdc09760d3812ec,0x3fdb35b55c8090c6,1 +np.float64,0x800c4d99e4f89b34,0x800c4d99e4f89b34,1 +np.float64,0xffbaa6772e354cf0,0xc08621b535badb2f,1 +np.float64,0xbfc91188fd322310,0xbfc8e933b5d25ea7,1 +np.float64,0xffc1b947f4237290,0xc08623fd69164251,1 +np.float64,0x3fc6ab3b252d5678,0x3fc68d50bbac106d,1 +np.float64,0xffac8eb968391d70,0xc0861cb734833355,1 +np.float64,0xffe29a35c365346b,0xc0862f77a1aed6d8,1 +np.float64,0x3fde14b9543c2973,0x3fdd122697779015,1 +np.float64,0xbf10f5400021e000,0xbf10f53fffef1383,1 +np.float64,0xffe0831aa3e10635,0xc0862e838553d0ca,1 +np.float64,0x3fccbadbcf3975b8,0x3fcc7e768d0154ec,1 +np.float64,0x3fe092ef66e125df,0x3fdfd212a7116c9b,1 +np.float64,0xbfd727f039ae4fe0,0xbfd6adad040b2334,1 +np.float64,0xbfe4223b93a84477,0xbfe2ff7587364db4,1 +np.float64,0x3f4e5c3a003cb874,0x3f4e5c39b75c70f7,1 +np.float64,0x800e76b1a87ced63,0x800e76b1a87ced63,1 +np.float64,0x3fed2b7368fa56e7,0x3fea2863b9131b8c,1 +np.float64,0xffadb76ec43b6ee0,0xc0861d08ae79f20c,1 +np.float64,0x800b6a0cd1f6d41a,0x800b6a0cd1f6d41a,1 +np.float64,0xffee6aa943fcd552,0xc0863366a24250d5,1 +np.float64,0xbfe68cbc4e6d1978,0xbfe502040591aa5b,1 +np.float64,0xff859a38002b3480,0xc0860f64726235cc,1 +np.float64,0x3474d13e68e9b,0x3474d13e68e9b,1 +np.float64,0xffc11d49f6223a94,0xc08623b5c2df9712,1 +np.float64,0x800d82d019bb05a0,0x800d82d019bb05a0,1 +np.float64,0xbfe2af0192255e03,0xbfe1c20e38106388,1 +np.float64,0x3fe97d13c032fa28,0x3fe75bba11a65f86,1 +np.float64,0x7fcd457e133a8afb,0x40862800e80f5863,1 +np.float64,0x9d7254cf3ae4b,0x9d7254cf3ae4b,1 +np.float64,0x8003047675a608ee,0x8003047675a608ee,1 +np.float64,0x3fead6cd7d75ad9a,0x3fe8676138e5ff93,1 +np.float64,0x3fea6ee3b0f4ddc7,0x3fe817838a2bcbe3,1 +np.float64,0x3feed0edea7da1dc,0x3feb5bea3cb12fe2,1 +np.float64,0x88003fe510008,0x88003fe510008,1 +np.float64,0x3fe64cadc56c995c,0x3fe4cd8ead87fc79,1 +np.float64,0xaae30c5955c62,0xaae30c5955c62,1 +np.float64,0x7fc8c97cae3192f8,0x408626ac579f4fc5,1 +np.float64,0xbfc2bc0e8b25781c,0xbfc2ab188fdab7dc,1 +np.float64,0xc8f8e5e791f1d,0xc8f8e5e791f1d,1 +np.float64,0x3fecfaa5d6f9f54c,0x3fea0444dabe5a15,1 +np.float64,0xbfeb93740ff726e8,0xbfe8f71a9ab13baf,1 +np.float64,0xffd951236c32a246,0xc0862c633a4661eb,1 +np.float64,0x3fddbc5fcd3b78c0,0x3fdcc21c1a0a9246,1 +np.float64,0xbfd242443da48488,0xbfd20512d91f7924,1 +np.float64,0x2a3689b2546d2,0x2a3689b2546d2,1 +np.float64,0xffe24c67382498ce,0xc0862f55e4ea6283,1 +np.float64,0x800cbfce22197f9c,0x800cbfce22197f9c,1 +np.float64,0x8002269428044d29,0x8002269428044d29,1 +np.float64,0x7fd44babbd289756,0x40862a9e79b51c3b,1 +np.float64,0x3feea056a27d40ad,0x3feb38dcddb682f0,1 +np.float64,0xffeca8174b39502e,0xc08632ec8f88a5b2,1 +np.float64,0x7fbe0853a03c10a6,0x408622a9e8d53a9e,1 +np.float64,0xbfa9704b2432e090,0xbfa96d9dfc8c0cc2,1 +np.float64,0x800bda28fab7b452,0x800bda28fab7b452,1 +np.float64,0xbfb0ffa2f621ff48,0xbfb0fc71f405e82a,1 +np.float64,0xbfe66c04216cd808,0xbfe4e73ea3b58cf6,1 +np.float64,0x3fe336ea5d266dd5,0x3fe236ffcf078c62,1 +np.float64,0xbfe7729ae6aee536,0xbfe5bcad4b8ac62d,1 +np.float64,0x558cfc96ab1a0,0x558cfc96ab1a0,1 +np.float64,0xbfe7d792aaefaf26,0xbfe60de1b8f0279d,1 +np.float64,0xffd19ef6bda33dee,0xc086297d0ffee3c7,1 +np.float64,0x666b3ab4ccd68,0x666b3ab4ccd68,1 +np.float64,0xffa3d89e3c27b140,0xc08619cdeb2c1e49,1 +np.float64,0xbfb1728f7f62f,0xbfb1728f7f62f,1 +np.float64,0x3fc76319f32ec634,0x3fc74247bd005e20,1 +np.float64,0xbfbf1caee23e3960,0xbfbf0934c13d70e2,1 +np.float64,0x7fe79626f32f2c4d,0x4086315dcc68a5cb,1 +np.float64,0xffee78c4603cf188,0xc086336a572c05c2,1 +np.float64,0x3fce546eda3ca8de,0x3fce0d8d737fd31d,1 +np.float64,0xa223644d4446d,0xa223644d4446d,1 +np.float64,0x3fecea878b79d510,0x3fe9f850d50973f6,1 +np.float64,0x3fc20e0ea1241c1d,0x3fc1fedda87c5e75,1 +np.float64,0xffd1c5a99ca38b54,0xc086298e8e94cd47,1 +np.float64,0x7feb2c299d765852,0x4086327fa6db2808,1 +np.float64,0xcaf9d09595f3a,0xcaf9d09595f3a,1 +np.float64,0xbfe293bf21e5277e,0xbfe1aa7f6ac274ef,1 +np.float64,0xbfbaa3c8ce354790,0xbfba97891df19c01,1 +np.float64,0x3faf5784543eaf09,0x3faf5283acc7d71d,1 +np.float64,0x7fc014f8f62029f1,0x40862336531c662d,1 +np.float64,0xbfe0d9ac2d61b358,0xbfe027bce36699ca,1 +np.float64,0x8003e112ff27c227,0x8003e112ff27c227,1 +np.float64,0xffec0d4151381a82,0xc08632c0df718dd0,1 +np.float64,0x7fa2156fb0242ade,0x4086190f7587d708,1 +np.float64,0xd698358dad307,0xd698358dad307,1 +np.float64,0xbfed8d1b0efb1a36,0xbfea70588ef9ba18,1 +np.float64,0xbfd2cae6a92595ce,0xbfd28851e2185dee,1 +np.float64,0xffe7a36764ef46ce,0xc086316249c9287a,1 +np.float64,0xbfdb8ad8e5b715b2,0xbfdac19213c14315,1 +np.float64,0x3b5dba6076bc,0x3b5dba6076bc,1 +np.float64,0x800e6e8347bcdd07,0x800e6e8347bcdd07,1 +np.float64,0x800bea9f3fb7d53f,0x800bea9f3fb7d53f,1 +np.float64,0x7fb6d0e5fc2da1cb,0x4086207714c4ab85,1 +np.float64,0x0,0x0,1 +np.float64,0xbfe2aa1e1465543c,0xbfe1bdd550ef2966,1 +np.float64,0x7fd3f6a47fa7ed48,0x40862a7caea33055,1 +np.float64,0x800094e292c129c6,0x800094e292c129c6,1 +np.float64,0x800e1500ecbc2a02,0x800e1500ecbc2a02,1 +np.float64,0xbfd8ff6f97b1fee0,0xbfd866f84346ecdc,1 +np.float64,0x681457d0d028c,0x681457d0d028c,1 +np.float64,0x3feed0b5987da16b,0x3feb5bc1ab424984,1 +np.float64,0x3fdbcb34cdb79668,0x3fdafca540f32c06,1 +np.float64,0xbfdc9eacdcb93d5a,0xbfdbbe274aa8aeb0,1 +np.float64,0xffe6e35d526dc6ba,0xc08631203df38ed2,1 +np.float64,0x3fcac1cc65358398,0x3fca90de41889613,1 +np.float64,0xbfebf07a55b7e0f5,0xbfe93d6007db0c67,1 +np.float64,0xbfd7a7b1e7af4f64,0xbfd725a9081c22cb,1 +np.float64,0x800232bd7de4657c,0x800232bd7de4657c,1 +np.float64,0x7fb1dae43c23b5c7,0x40861e80f5c0a64e,1 +np.float64,0x8013ded70027c,0x8013ded70027c,1 +np.float64,0x7fc4373a59286e74,0x4086250ad60575d0,1 +np.float64,0xbfe9980fd6733020,0xbfe770d1352d0ed3,1 +np.float64,0x8008a66b8dd14cd7,0x8008a66b8dd14cd7,1 +np.float64,0xbfaebc67f83d78d0,0xbfaeb7b015848478,1 +np.float64,0xffd0c52762218a4e,0xc0862917b564afc6,1 +np.float64,0xbfd503860aaa070c,0xbfd4a74618441561,1 +np.float64,0x5bdacabcb7b5a,0x5bdacabcb7b5a,1 +np.float64,0xf3623cffe6c48,0xf3623cffe6c48,1 +np.float64,0x7fe16c6c7ea2d8d8,0x40862ef18d90201f,1 +np.float64,0x3ff0000000000000,0x3fec34366179d427,1 +np.float64,0x7fe19cbc84233978,0x40862f079dcbc169,1 +np.float64,0x3fcfd3d6933fa7ad,0x3fcf822187907f6b,1 +np.float64,0x8007d65d672facbc,0x8007d65d672facbc,1 +np.float64,0xffca6115aa34c22c,0xc086272bd7728750,1 +np.float64,0xbfe77ab1556ef562,0xbfe5c332fb55b66e,1 +np.float64,0x8001ed797c23daf4,0x8001ed797c23daf4,1 +np.float64,0x7fdd3d16cb3a7a2d,0x40862d8a2c869281,1 +np.float64,0x75f36beaebe6e,0x75f36beaebe6e,1 +np.float64,0xffda3c2798b47850,0xc0862cac2d3435df,1 +np.float64,0xbfa37cc3c426f980,0xbfa37b8f9d3ec4b7,1 +np.float64,0x80030ea8bd061d52,0x80030ea8bd061d52,1 +np.float64,0xffe41f7617683eec,0xc08630188a3e135e,1 +np.float64,0x800e40590dfc80b2,0x800e40590dfc80b2,1 +np.float64,0x3fea950d80f52a1c,0x3fe834e74481e66f,1 +np.float64,0xffec95e39a792bc6,0xc08632e779150084,1 +np.float64,0xbfd54310ecaa8622,0xbfd4e39c4d767002,1 +np.float64,0xffd40c9971a81932,0xc0862a85764eb2f4,1 +np.float64,0xb0a2230761445,0xb0a2230761445,1 +np.float64,0x80092973661252e7,0x80092973661252e7,1 +np.float64,0x7fb13b030a227605,0x40861e380aeb5549,1 +np.float64,0x3fbd5d8db23abb1b,0x3fbd4d2a0b94af36,1 +np.float64,0xbfd6cb8567ad970a,0xbfd656b19ab8fa61,1 +np.float64,0xbfe7c0fd346f81fa,0xbfe5fbc28807c794,1 +np.float64,0xffd586579eab0cb0,0xc0862b16e65c0754,1 +np.float64,0x8000e52da461ca5c,0x8000e52da461ca5c,1 +np.float64,0x3fc69d17112d3a2e,0x3fc67f63fe1fea1c,1 +np.float64,0x3fd36ba892a6d750,0x3fd3225be1fa87af,1 +np.float64,0x7fe2850598e50a0a,0x40862f6e7fcd6c1a,1 +np.float64,0x80074a4dacce949c,0x80074a4dacce949c,1 +np.float64,0x3fe25eea4d64bdd5,0x3fe17cbe5fefbd4e,1 +np.float64,0xbfe250c08be4a181,0xbfe17074c520e5de,1 +np.float64,0x8000f5665481eacd,0x8000f5665481eacd,1 +np.float64,0x7fdb3172f83662e5,0x40862cf5a46764f1,1 +np.float64,0x7fd8ed82d631db05,0x40862c4380658afa,1 +np.float64,0xffec5163feb8a2c7,0xc08632d4366aab06,1 +np.float64,0x800ff14ac6ffe296,0x800ff14ac6ffe296,1 +np.float64,0xbfc7cc7aea2f98f4,0xbfc7a9e9cb38f023,1 +np.float64,0xbfd50cdfc32a19c0,0xbfd4b0282b452fb2,1 +np.float64,0xbfec256d75b84adb,0xbfe965328c1860b2,1 +np.float64,0xffe860c4cdb0c189,0xc08631a164b7059a,1 +np.float64,0xbfe23de164247bc3,0xbfe16011bffa4651,1 +np.float64,0xcc96b39d992d7,0xcc96b39d992d7,1 +np.float64,0xbfec43acf938875a,0xbfe97be3a13b50c3,1 +np.float64,0xc4f587bb89eb1,0xc4f587bb89eb1,1 +np.float64,0xbfcd971d9a3b2e3c,0xbfcd5537ad15dab4,1 +np.float64,0xffcaf00d8035e01c,0xc0862756bf2cdf8f,1 +np.float64,0x8008c26f93f184e0,0x8008c26f93f184e0,1 +np.float64,0xfff0000000000000,0xfff0000000000000,1 +np.float64,0xbfd13552c3a26aa6,0xbfd101e5e252eb7b,1 +np.float64,0x7fe497235e292e46,0x4086304792fb423a,1 +np.float64,0x7fd6dc0192adb802,0x40862b921a5e935d,1 +np.float64,0xf16d49a1e2da9,0xf16d49a1e2da9,1 +np.float64,0xffef6b1b71bed636,0xc08633a8feed0178,1 +np.float64,0x7fe15ec62f62bd8b,0x40862eeb46b193dc,1 +np.float64,0x3fef4369ec7e86d4,0x3febae1768be52cc,1 +np.float64,0x4f84e8e89f09e,0x4f84e8e89f09e,1 +np.float64,0xbfe19e71ade33ce4,0xbfe0d4fad05e0ebc,1 +np.float64,0xbfe7e1df1defc3be,0xbfe616233e15b3d0,1 +np.float64,0x7fe9349afdb26935,0x408631e5c1c5c6cd,1 +np.float64,0xff90c35ac82186c0,0xc08612e896a06467,1 +np.float64,0xbfe88bf8807117f1,0xbfe69dc786464422,1 +np.float64,0x3feaf9ff6475f3fe,0x3fe8825132410d18,1 +np.float64,0x9ff487a33fe91,0x9ff487a33fe91,1 +np.float64,0x7fedb30159bb6602,0x40863335c0419322,1 +np.float64,0x800bddf6ed77bbee,0x800bddf6ed77bbee,1 +np.float64,0x3fd919df133233be,0x3fd87f963b9584ce,1 +np.float64,0x7fd64da3b52c9b46,0x40862b5fa9dd3b6d,1 +np.float64,0xbfce288db43c511c,0xbfcde2d953407ae8,1 +np.float64,0x3fe88bc72771178e,0x3fe69da05e9e9b4e,1 +np.float64,0x800feafe259fd5fc,0x800feafe259fd5fc,1 +np.float64,0x3febbbff4a7777ff,0x3fe915c78f6a280f,1 +np.float64,0xbfefbde4417f7bc9,0xbfec055f4fb2cd21,1 +np.float64,0xf13ca103e2794,0xf13ca103e2794,1 +np.float64,0x3fe6423884ec8471,0x3fe4c4f97eaa876a,1 +np.float64,0x800ca01c8cb94039,0x800ca01c8cb94039,1 +np.float64,0x3fbc5073f638a0e0,0x3fbc41c163ac0001,1 +np.float64,0xbfda0d83cfb41b08,0xbfd961d4cacc82cf,1 +np.float64,0x800f37b8f17e6f72,0x800f37b8f17e6f72,1 +np.float64,0x7fe0b08cd7216119,0x40862e996becb771,1 +np.float64,0xffd4222a40a84454,0xc0862a8e0c984917,1 +np.float64,0x7feb3df98ff67bf2,0x40863284e3a86ee6,1 +np.float64,0x8001d5d291e3aba6,0x8001d5d291e3aba6,1 +np.float64,0xbfd3c21629a7842c,0xbfd3750095a5894a,1 +np.float64,0xbfd069eb48a0d3d6,0xbfd03d2b1c2ae9db,1 +np.float64,0xffeb1be2973637c4,0xc086327ada954662,1 +np.float64,0x3fc659f97e2cb3f3,0x3fc63d497a451f10,1 +np.float64,0xbfeb624bc776c498,0xbfe8d1cf7c0626ca,1 +np.float64,0xffeedf26e23dbe4d,0xc08633850baab425,1 +np.float64,0xffe70da48a6e1b48,0xc086312ef75d5036,1 +np.float64,0x2b4f4830569ea,0x2b4f4830569ea,1 +np.float64,0xffe82e7fcfb05cff,0xc0863190d4771f75,1 +np.float64,0x3fcc2c1fd5385840,0x3fcbf3211ddc5123,1 +np.float64,0x7fe22ced5a6459da,0x40862f481629ee6a,1 +np.float64,0x7fe13d2895e27a50,0x40862edbbc411899,1 +np.float64,0x3fd54c4280aa9884,0x3fd4ec55a946c5d7,1 +np.float64,0xffd75b8e01aeb71c,0xc0862bbe42d76e5e,1 +np.float64,0x7f1d5376fe3ab,0x7f1d5376fe3ab,1 +np.float64,0x3fe6ec6c902dd8d9,0x3fe55004f35192bd,1 +np.float64,0x5634504aac68b,0x5634504aac68b,1 +np.float64,0x3feedb0d83bdb61b,0x3feb633467467ce6,1 +np.float64,0x3fddb1c0dcbb6380,0x3fdcb87a02daf1fa,1 +np.float64,0xbfa832da443065b0,0xbfa8308c70257209,1 +np.float64,0x87a9836b0f531,0x87a9836b0f531,1 diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/data/umath-validation-set-arctan.csv b/venv/lib/python3.12/site-packages/numpy/_core/tests/data/umath-validation-set-arctan.csv new file mode 100644 index 00000000..c03e144a --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/tests/data/umath-validation-set-arctan.csv @@ -0,0 +1,1429 @@ +dtype,input,output,ulperrortol +np.float32,0x3f338252,0x3f1c8d9c,3 +np.float32,0x7e569df2,0x3fc90fdb,3 +np.float32,0xbf347e25,0xbf1d361f,3 +np.float32,0xbf0a654e,0xbefdbfd2,3 +np.float32,0x8070968e,0x8070968e,3 +np.float32,0x803cfb27,0x803cfb27,3 +np.float32,0x8024362e,0x8024362e,3 +np.float32,0xfd55dca0,0xbfc90fdb,3 +np.float32,0x592b82,0x592b82,3 +np.float32,0x802eb8e1,0x802eb8e1,3 +np.float32,0xbc5fef40,0xbc5febae,3 +np.float32,0x3f1f6ce8,0x3f0e967c,3 +np.float32,0x20bedc,0x20bedc,3 +np.float32,0xbf058860,0xbef629c7,3 +np.float32,0x311504,0x311504,3 +np.float32,0xbd23f560,0xbd23defa,3 +np.float32,0x800ff4e8,0x800ff4e8,3 +np.float32,0x355009,0x355009,3 +np.float32,0x3f7be42e,0x3f46fdb3,3 +np.float32,0xbf225f7c,0xbf10b364,3 +np.float32,0x8074fa9e,0x8074fa9e,3 +np.float32,0xbea4b418,0xbe9f59ce,3 +np.float32,0xbe909c14,0xbe8cf045,3 +np.float32,0x80026bee,0x80026bee,3 +np.float32,0x3d789c20,0x3d784e25,3 +np.float32,0x7f56a4ba,0x3fc90fdb,3 +np.float32,0xbf70d141,0xbf413db7,3 +np.float32,0xbf2c4886,0xbf17a505,3 +np.float32,0x7e2993bf,0x3fc90fdb,3 +np.float32,0xbe2c8a30,0xbe2aef28,3 +np.float32,0x803f82d9,0x803f82d9,3 +np.float32,0x3f062fbc,0x3ef730a1,3 +np.float32,0x3f349ee0,0x3f1d4bfa,3 +np.float32,0x3eccfb69,0x3ec2f9e8,3 +np.float32,0x7e8a85dd,0x3fc90fdb,3 +np.float32,0x25331,0x25331,3 +np.float32,0x464f19,0x464f19,3 +np.float32,0x8035c818,0x8035c818,3 +np.float32,0x802e5799,0x802e5799,3 +np.float32,0x64e1c0,0x64e1c0,3 +np.float32,0x701cc2,0x701cc2,3 +np.float32,0x265c57,0x265c57,3 +np.float32,0x807a053f,0x807a053f,3 +np.float32,0x3bd2c412,0x3bd2c354,3 +np.float32,0xff28f1c8,0xbfc90fdb,3 +np.float32,0x7f08f08b,0x3fc90fdb,3 +np.float32,0x800c50e4,0x800c50e4,3 +np.float32,0x369674,0x369674,3 +np.float32,0xbf5b7db3,0xbf3571bf,3 +np.float32,0x7edcf5e2,0x3fc90fdb,3 +np.float32,0x800e5d4b,0x800e5d4b,3 +np.float32,0x80722554,0x80722554,3 +np.float32,0x693f33,0x693f33,3 +np.float32,0x800844e4,0x800844e4,3 +np.float32,0xbf111b82,0xbf0402ec,3 +np.float32,0x7df9c9ac,0x3fc90fdb,3 +np.float32,0xbf6619a6,0xbf3b6f57,3 +np.float32,0x8002fafe,0x8002fafe,3 +np.float32,0xfe1e67f8,0xbfc90fdb,3 +np.float32,0x3f7f4bf8,0x3f48b5b7,3 +np.float32,0x7f017b20,0x3fc90fdb,3 +np.float32,0x2d9b07,0x2d9b07,3 +np.float32,0x803aa174,0x803aa174,3 +np.float32,0x7d530336,0x3fc90fdb,3 +np.float32,0x80662195,0x80662195,3 +np.float32,0xfd5ebcf0,0xbfc90fdb,3 +np.float32,0xbe7b8dcc,0xbe76ab59,3 +np.float32,0x7f2bacaf,0x3fc90fdb,3 +np.float32,0x3f194fc4,0x3f0a229e,3 +np.float32,0x7ee21cdf,0x3fc90fdb,3 +np.float32,0x3f5a17fc,0x3f34a307,3 +np.float32,0x7f100c58,0x3fc90fdb,3 +np.float32,0x7e9128f5,0x3fc90fdb,3 +np.float32,0xbf2107c6,0xbf0fbdb4,3 +np.float32,0xbd29c800,0xbd29af22,3 +np.float32,0xbf5af499,0xbf3522a6,3 +np.float32,0x801bde44,0x801bde44,3 +np.float32,0xfeb4761a,0xbfc90fdb,3 +np.float32,0x3d88aa1b,0x3d887650,3 +np.float32,0x7eba5e0b,0x3fc90fdb,3 +np.float32,0x803906bd,0x803906bd,3 +np.float32,0x80101512,0x80101512,3 +np.float32,0x7e898f83,0x3fc90fdb,3 +np.float32,0x806406d3,0x806406d3,3 +np.float32,0x7ed20fc0,0x3fc90fdb,3 +np.float32,0x20827d,0x20827d,3 +np.float32,0x3f361359,0x3f1e43fe,3 +np.float32,0xfe4ef8d8,0xbfc90fdb,3 +np.float32,0x805e7d2d,0x805e7d2d,3 +np.float32,0xbe4316b0,0xbe40c745,3 +np.float32,0xbf0a1c06,0xbefd4e5a,3 +np.float32,0x3e202860,0x3e1edee1,3 +np.float32,0xbeb32a2c,0xbeac5899,3 +np.float32,0xfe528838,0xbfc90fdb,3 +np.float32,0x2f73e2,0x2f73e2,3 +np.float32,0xbe16e010,0xbe15cc27,3 +np.float32,0x3f50d6c5,0x3f2f2d75,3 +np.float32,0xbe88a6a2,0xbe8589c7,3 +np.float32,0x3ee36060,0x3ed5fb36,3 +np.float32,0x6c978b,0x6c978b,3 +np.float32,0x7f1b735f,0x3fc90fdb,3 +np.float32,0x3dad8256,0x3dad1885,3 +np.float32,0x807f5094,0x807f5094,3 +np.float32,0x65c358,0x65c358,3 +np.float32,0xff315ce4,0xbfc90fdb,3 +np.float32,0x7411a6,0x7411a6,3 +np.float32,0x80757b04,0x80757b04,3 +np.float32,0x3eec73a6,0x3edd82f4,3 +np.float32,0xfe9f69e8,0xbfc90fdb,3 +np.float32,0x801f4fa8,0x801f4fa8,3 +np.float32,0xbf6f2fae,0xbf405f79,3 +np.float32,0xfea206b6,0xbfc90fdb,3 +np.float32,0x3f257301,0x3f12e1ee,3 +np.float32,0x7ea6a506,0x3fc90fdb,3 +np.float32,0x80800000,0x80800000,3 +np.float32,0xff735c2d,0xbfc90fdb,3 +np.float32,0x80197f95,0x80197f95,3 +np.float32,0x7f4a354f,0x3fc90fdb,3 +np.float32,0xff320c00,0xbfc90fdb,3 +np.float32,0x3f2659de,0x3f138484,3 +np.float32,0xbe5451bc,0xbe515a52,3 +np.float32,0x3f6e228c,0x3f3fcf7c,3 +np.float32,0x66855a,0x66855a,3 +np.float32,0x8034b3a3,0x8034b3a3,3 +np.float32,0xbe21a2fc,0xbe20505d,3 +np.float32,0x7f79e2dc,0x3fc90fdb,3 +np.float32,0xbe19a8e0,0xbe18858c,3 +np.float32,0x10802c,0x10802c,3 +np.float32,0xfeee579e,0xbfc90fdb,3 +np.float32,0x3f3292c8,0x3f1becc0,3 +np.float32,0xbf595a71,0xbf34350a,3 +np.float32,0xbf7c3373,0xbf4725f4,3 +np.float32,0xbdd30938,0xbdd24b36,3 +np.float32,0x153a17,0x153a17,3 +np.float32,0x807282a0,0x807282a0,3 +np.float32,0xfe817322,0xbfc90fdb,3 +np.float32,0x3f1b3628,0x3f0b8771,3 +np.float32,0x41be8f,0x41be8f,3 +np.float32,0x7f4a8343,0x3fc90fdb,3 +np.float32,0x3dc4ea2b,0x3dc44fae,3 +np.float32,0x802aac25,0x802aac25,3 +np.float32,0xbf20e1d7,0xbf0fa284,3 +np.float32,0xfd91a1b0,0xbfc90fdb,3 +np.float32,0x3f0d5476,0x3f012265,3 +np.float32,0x21c916,0x21c916,3 +np.float32,0x807df399,0x807df399,3 +np.float32,0x7e207b4c,0x3fc90fdb,3 +np.float32,0x8055f8ff,0x8055f8ff,3 +np.float32,0x7edf3b01,0x3fc90fdb,3 +np.float32,0x803a8df3,0x803a8df3,3 +np.float32,0x3ce3b002,0x3ce3a101,3 +np.float32,0x3f62dd54,0x3f39a248,3 +np.float32,0xff33ae10,0xbfc90fdb,3 +np.float32,0x7e3de69d,0x3fc90fdb,3 +np.float32,0x8024581e,0x8024581e,3 +np.float32,0xbf4ac99d,0xbf2b807a,3 +np.float32,0x3f157d19,0x3f074d8c,3 +np.float32,0xfed383f4,0xbfc90fdb,3 +np.float32,0xbf5a39fa,0xbf34b6b8,3 +np.float32,0x800d757d,0x800d757d,3 +np.float32,0x807d606b,0x807d606b,3 +np.float32,0x3e828f89,0x3e7fac2d,3 +np.float32,0x7a6604,0x7a6604,3 +np.float32,0x7dc7e72b,0x3fc90fdb,3 +np.float32,0x80144146,0x80144146,3 +np.float32,0x7c2eed69,0x3fc90fdb,3 +np.float32,0x3f5b4d8c,0x3f3555fc,3 +np.float32,0xfd8b7778,0xbfc90fdb,3 +np.float32,0xfc9d9140,0xbfc90fdb,3 +np.float32,0xbea265d4,0xbe9d4232,3 +np.float32,0xbe9344d0,0xbe8f65da,3 +np.float32,0x3f71f19a,0x3f41d65b,3 +np.float32,0x804a3f59,0x804a3f59,3 +np.float32,0x3e596290,0x3e563476,3 +np.float32,0x3e994ee4,0x3e94f546,3 +np.float32,0xbc103e00,0xbc103d0c,3 +np.float32,0xbf1cd896,0xbf0cb889,3 +np.float32,0x7f52b080,0x3fc90fdb,3 +np.float32,0xff584452,0xbfc90fdb,3 +np.float32,0x58b26b,0x58b26b,3 +np.float32,0x3f23cd4c,0x3f11b799,3 +np.float32,0x707d7,0x707d7,3 +np.float32,0xff732cff,0xbfc90fdb,3 +np.float32,0x3e41c2a6,0x3e3f7f0f,3 +np.float32,0xbf7058e9,0xbf40fdcf,3 +np.float32,0x7dca9857,0x3fc90fdb,3 +np.float32,0x7f0eb44b,0x3fc90fdb,3 +np.float32,0x8000405c,0x8000405c,3 +np.float32,0x4916ab,0x4916ab,3 +np.float32,0x4811a8,0x4811a8,3 +np.float32,0x3d69bf,0x3d69bf,3 +np.float32,0xfeadcf1e,0xbfc90fdb,3 +np.float32,0x3e08dbbf,0x3e080d58,3 +np.float32,0xff031f88,0xbfc90fdb,3 +np.float32,0xbe09cab8,0xbe08f818,3 +np.float32,0x21d7cd,0x21d7cd,3 +np.float32,0x3f23230d,0x3f113ea9,3 +np.float32,0x7e8a48d4,0x3fc90fdb,3 +np.float32,0x413869,0x413869,3 +np.float32,0x7e832990,0x3fc90fdb,3 +np.float32,0x800f5c09,0x800f5c09,3 +np.float32,0x7f5893b6,0x3fc90fdb,3 +np.float32,0x7f06b5b1,0x3fc90fdb,3 +np.float32,0xbe1cbee8,0xbe1b89d6,3 +np.float32,0xbf279f14,0xbf1468a8,3 +np.float32,0xfea86060,0xbfc90fdb,3 +np.float32,0x3e828174,0x3e7f91bb,3 +np.float32,0xff682c82,0xbfc90fdb,3 +np.float32,0x4e20f3,0x4e20f3,3 +np.float32,0x7f17d7e9,0x3fc90fdb,3 +np.float32,0x80671f92,0x80671f92,3 +np.float32,0x7f6dd100,0x3fc90fdb,3 +np.float32,0x3f219a4d,0x3f102695,3 +np.float32,0x803c9808,0x803c9808,3 +np.float32,0x3c432ada,0x3c43287d,3 +np.float32,0xbd3db450,0xbd3d91a2,3 +np.float32,0x3baac135,0x3baac0d0,3 +np.float32,0xff7fffe1,0xbfc90fdb,3 +np.float32,0xfe38a6f4,0xbfc90fdb,3 +np.float32,0x3dfb0a04,0x3df9cb04,3 +np.float32,0x800b05c2,0x800b05c2,3 +np.float32,0x644163,0x644163,3 +np.float32,0xff03a025,0xbfc90fdb,3 +np.float32,0x3f7d506c,0x3f47b641,3 +np.float32,0xff0e682a,0xbfc90fdb,3 +np.float32,0x3e09b7b0,0x3e08e567,3 +np.float32,0x7f72a216,0x3fc90fdb,3 +np.float32,0x7f800000,0x3fc90fdb,3 +np.float32,0x8050a281,0x8050a281,3 +np.float32,0x7edafa2f,0x3fc90fdb,3 +np.float32,0x3f4e0df6,0x3f2d7f2f,3 +np.float32,0xbf6728e0,0xbf3c050f,3 +np.float32,0x3e904ce4,0x3e8ca6eb,3 +np.float32,0x0,0x0,3 +np.float32,0xfd215070,0xbfc90fdb,3 +np.float32,0x7e406b15,0x3fc90fdb,3 +np.float32,0xbf2803c9,0xbf14af18,3 +np.float32,0x5950c8,0x5950c8,3 +np.float32,0xbeddcec8,0xbed14faa,3 +np.float32,0xbec6457e,0xbebd2aa5,3 +np.float32,0xbf42843c,0xbf2656db,3 +np.float32,0x3ee9cba8,0x3edb5163,3 +np.float32,0xbe30c954,0xbe2f0f90,3 +np.float32,0xbeee6b44,0xbedf216f,3 +np.float32,0xbe35d818,0xbe33f7cd,3 +np.float32,0xbe47c630,0xbe454bc6,3 +np.float32,0x801b146f,0x801b146f,3 +np.float32,0x7f6788da,0x3fc90fdb,3 +np.float32,0x3eaef088,0x3ea8927d,3 +np.float32,0x3eb5983e,0x3eae81fc,3 +np.float32,0x40b51d,0x40b51d,3 +np.float32,0xfebddd04,0xbfc90fdb,3 +np.float32,0x3e591aee,0x3e55efea,3 +np.float32,0xbe2b6b48,0xbe29d81f,3 +np.float32,0xff4a8826,0xbfc90fdb,3 +np.float32,0x3e791df0,0x3e745eac,3 +np.float32,0x7c8f681f,0x3fc90fdb,3 +np.float32,0xfe7a15c4,0xbfc90fdb,3 +np.float32,0x3c8963,0x3c8963,3 +np.float32,0x3f0afa0a,0x3efea5cc,3 +np.float32,0xbf0d2680,0xbf00ff29,3 +np.float32,0x3dc306b0,0x3dc27096,3 +np.float32,0x7f4cf105,0x3fc90fdb,3 +np.float32,0xbe196060,0xbe183ea4,3 +np.float32,0x5caf1c,0x5caf1c,3 +np.float32,0x801f2852,0x801f2852,3 +np.float32,0xbe01aa0c,0xbe00fa53,3 +np.float32,0x3f0cfd32,0x3f00df7a,3 +np.float32,0x7d82038e,0x3fc90fdb,3 +np.float32,0x7f7b927f,0x3fc90fdb,3 +np.float32,0xbe93b2e4,0xbe8fcb7f,3 +np.float32,0x1ffe8c,0x1ffe8c,3 +np.float32,0x3faaf6,0x3faaf6,3 +np.float32,0x3e32b1b8,0x3e30e9ab,3 +np.float32,0x802953c0,0x802953c0,3 +np.float32,0xfe5d9844,0xbfc90fdb,3 +np.float32,0x3e1a59d0,0x3e193292,3 +np.float32,0x801c6edc,0x801c6edc,3 +np.float32,0x1ecf41,0x1ecf41,3 +np.float32,0xfe56b09c,0xbfc90fdb,3 +np.float32,0x7e878351,0x3fc90fdb,3 +np.float32,0x3f401e2c,0x3f24cfcb,3 +np.float32,0xbf204a40,0xbf0f35bb,3 +np.float32,0x3e155a98,0x3e144ee1,3 +np.float32,0xbf34f929,0xbf1d8838,3 +np.float32,0x801bbf70,0x801bbf70,3 +np.float32,0x7e7c9730,0x3fc90fdb,3 +np.float32,0x7cc23432,0x3fc90fdb,3 +np.float32,0xbf351638,0xbf1d9b97,3 +np.float32,0x80152094,0x80152094,3 +np.float32,0x3f2d731c,0x3f187219,3 +np.float32,0x804ab0b7,0x804ab0b7,3 +np.float32,0x37d6db,0x37d6db,3 +np.float32,0xbf3ccc56,0xbf22acbf,3 +np.float32,0x3e546f8c,0x3e5176e7,3 +np.float32,0xbe90e87e,0xbe8d3707,3 +np.float32,0x48256c,0x48256c,3 +np.float32,0x7e2468d0,0x3fc90fdb,3 +np.float32,0x807af47e,0x807af47e,3 +np.float32,0x3ed4b221,0x3ec996f0,3 +np.float32,0x3d3b1956,0x3d3af811,3 +np.float32,0xbe69d93c,0xbe65e7f0,3 +np.float32,0xff03ff14,0xbfc90fdb,3 +np.float32,0x801e79dc,0x801e79dc,3 +np.float32,0x3f467c53,0x3f28d63d,3 +np.float32,0x3eab6baa,0x3ea56a1c,3 +np.float32,0xbf15519c,0xbf072d1c,3 +np.float32,0x7f0bd8e8,0x3fc90fdb,3 +np.float32,0xbe1e0d1c,0xbe1cd053,3 +np.float32,0x8016edab,0x8016edab,3 +np.float32,0x7ecaa09b,0x3fc90fdb,3 +np.float32,0x3f72e6d9,0x3f4257a8,3 +np.float32,0xbefe787e,0xbeec29a4,3 +np.float32,0xbee989e8,0xbedb1af9,3 +np.float32,0xbe662db0,0xbe626a45,3 +np.float32,0x495bf7,0x495bf7,3 +np.float32,0x26c379,0x26c379,3 +np.float32,0x7f54d41a,0x3fc90fdb,3 +np.float32,0x801e7dd9,0x801e7dd9,3 +np.float32,0x80000000,0x80000000,3 +np.float32,0xfa3d3000,0xbfc90fdb,3 +np.float32,0xfa3cb800,0xbfc90fdb,3 +np.float32,0x264894,0x264894,3 +np.float32,0xff6de011,0xbfc90fdb,3 +np.float32,0x7e9045b2,0x3fc90fdb,3 +np.float32,0x3f2253a8,0x3f10aaf4,3 +np.float32,0xbd462bf0,0xbd460469,3 +np.float32,0x7f1796af,0x3fc90fdb,3 +np.float32,0x3e718858,0x3e6d3279,3 +np.float32,0xff437d7e,0xbfc90fdb,3 +np.float32,0x805ae7cb,0x805ae7cb,3 +np.float32,0x807e32e9,0x807e32e9,3 +np.float32,0x3ee0bafc,0x3ed3c453,3 +np.float32,0xbf721dee,0xbf41edc3,3 +np.float32,0xfec9f792,0xbfc90fdb,3 +np.float32,0x7f050720,0x3fc90fdb,3 +np.float32,0x182261,0x182261,3 +np.float32,0x3e39e678,0x3e37e5be,3 +np.float32,0x7e096e4b,0x3fc90fdb,3 +np.float32,0x103715,0x103715,3 +np.float32,0x3f7e7741,0x3f484ae4,3 +np.float32,0x3e29aea5,0x3e28277c,3 +np.float32,0x58c183,0x58c183,3 +np.float32,0xff72fdb2,0xbfc90fdb,3 +np.float32,0xbd9a9420,0xbd9a493c,3 +np.float32,0x7f1e07e7,0x3fc90fdb,3 +np.float32,0xff79f522,0xbfc90fdb,3 +np.float32,0x7c7d0e96,0x3fc90fdb,3 +np.float32,0xbeba9e8e,0xbeb2f504,3 +np.float32,0xfd880a80,0xbfc90fdb,3 +np.float32,0xff7f2a33,0xbfc90fdb,3 +np.float32,0x3e861ae0,0x3e83289c,3 +np.float32,0x7f0161c1,0x3fc90fdb,3 +np.float32,0xfe844ff8,0xbfc90fdb,3 +np.float32,0xbebf4b98,0xbeb7128e,3 +np.float32,0x652bee,0x652bee,3 +np.float32,0xff188a4b,0xbfc90fdb,3 +np.float32,0xbf800000,0xbf490fdb,3 +np.float32,0x80418711,0x80418711,3 +np.float32,0xbeb712d4,0xbeafd1f6,3 +np.float32,0xbf7cee28,0xbf478491,3 +np.float32,0xfe66c59c,0xbfc90fdb,3 +np.float32,0x4166a2,0x4166a2,3 +np.float32,0x3dfa1a2c,0x3df8deb5,3 +np.float32,0xbdbfbcb8,0xbdbf2e0f,3 +np.float32,0xfe60ef70,0xbfc90fdb,3 +np.float32,0xfe009444,0xbfc90fdb,3 +np.float32,0xfeb27aa0,0xbfc90fdb,3 +np.float32,0xbe99f7bc,0xbe95902b,3 +np.float32,0x8043d28d,0x8043d28d,3 +np.float32,0xfe5328c4,0xbfc90fdb,3 +np.float32,0x8017b27e,0x8017b27e,3 +np.float32,0x3ef1d2cf,0x3ee1ebd7,3 +np.float32,0x805ddd90,0x805ddd90,3 +np.float32,0xbf424263,0xbf262d17,3 +np.float32,0xfc99dde0,0xbfc90fdb,3 +np.float32,0xbf7ec13b,0xbf487015,3 +np.float32,0xbef727ea,0xbee64377,3 +np.float32,0xff15ce95,0xbfc90fdb,3 +np.float32,0x1fbba4,0x1fbba4,3 +np.float32,0x3f3b2368,0x3f2198a9,3 +np.float32,0xfefda26e,0xbfc90fdb,3 +np.float32,0x801519ad,0x801519ad,3 +np.float32,0x80473fa2,0x80473fa2,3 +np.float32,0x7e7a8bc1,0x3fc90fdb,3 +np.float32,0x3e8a9289,0x3e87548a,3 +np.float32,0x3ed68987,0x3ecb2872,3 +np.float32,0x805bca66,0x805bca66,3 +np.float32,0x8079c4e3,0x8079c4e3,3 +np.float32,0x3a2510,0x3a2510,3 +np.float32,0x7eedc598,0x3fc90fdb,3 +np.float32,0x80681956,0x80681956,3 +np.float32,0xff64c778,0xbfc90fdb,3 +np.float32,0x806bbc46,0x806bbc46,3 +np.float32,0x433643,0x433643,3 +np.float32,0x705b92,0x705b92,3 +np.float32,0xff359392,0xbfc90fdb,3 +np.float32,0xbee78672,0xbed96fa7,3 +np.float32,0x3e21717b,0x3e202010,3 +np.float32,0xfea13c34,0xbfc90fdb,3 +np.float32,0x2c8895,0x2c8895,3 +np.float32,0x3ed33290,0x3ec84f7c,3 +np.float32,0x3e63031e,0x3e5f662e,3 +np.float32,0x7e30907b,0x3fc90fdb,3 +np.float32,0xbe293708,0xbe27b310,3 +np.float32,0x3ed93738,0x3ecd6ea3,3 +np.float32,0x9db7e,0x9db7e,3 +np.float32,0x3f7cd1b8,0x3f47762c,3 +np.float32,0x3eb5143c,0x3eae0cb0,3 +np.float32,0xbe69b234,0xbe65c2d7,3 +np.float32,0x3f6e74de,0x3f3ffb97,3 +np.float32,0x5d0559,0x5d0559,3 +np.float32,0x3e1e8c30,0x3e1d4c70,3 +np.float32,0xbf2d1878,0xbf1833ef,3 +np.float32,0xff2adf82,0xbfc90fdb,3 +np.float32,0x8012e2c1,0x8012e2c1,3 +np.float32,0x7f031be3,0x3fc90fdb,3 +np.float32,0x805ff94e,0x805ff94e,3 +np.float32,0x3e9d5b27,0x3e98aa31,3 +np.float32,0x3f56d5cf,0x3f32bc9e,3 +np.float32,0x3eaa0412,0x3ea4267f,3 +np.float32,0xbe899ea4,0xbe86712f,3 +np.float32,0x800f2f48,0x800f2f48,3 +np.float32,0x3f1c2269,0x3f0c33ea,3 +np.float32,0x3f4a5f64,0x3f2b3f28,3 +np.float32,0x80739318,0x80739318,3 +np.float32,0x806e9b47,0x806e9b47,3 +np.float32,0x3c8cd300,0x3c8ccf73,3 +np.float32,0x7f39a39d,0x3fc90fdb,3 +np.float32,0x3ec95d61,0x3ebfd9dc,3 +np.float32,0xff351ff8,0xbfc90fdb,3 +np.float32,0xff3a8f58,0xbfc90fdb,3 +np.float32,0x7f313ec0,0x3fc90fdb,3 +np.float32,0x803aed13,0x803aed13,3 +np.float32,0x7f771d9b,0x3fc90fdb,3 +np.float32,0x8045a6d6,0x8045a6d6,3 +np.float32,0xbc85f280,0xbc85ef72,3 +np.float32,0x7e9c68f5,0x3fc90fdb,3 +np.float32,0xbf0f9379,0xbf02d975,3 +np.float32,0x7e97bcb1,0x3fc90fdb,3 +np.float32,0x804a07d5,0x804a07d5,3 +np.float32,0x802e6117,0x802e6117,3 +np.float32,0x7ed5e388,0x3fc90fdb,3 +np.float32,0x80750455,0x80750455,3 +np.float32,0xff4a8325,0xbfc90fdb,3 +np.float32,0xbedb6866,0xbecf497c,3 +np.float32,0x52ea3b,0x52ea3b,3 +np.float32,0xff773172,0xbfc90fdb,3 +np.float32,0xbeaa8ff0,0xbea4a46e,3 +np.float32,0x7eef2058,0x3fc90fdb,3 +np.float32,0x3f712472,0x3f4169d3,3 +np.float32,0xff6c8608,0xbfc90fdb,3 +np.float32,0xbf6eaa41,0xbf40182a,3 +np.float32,0x3eb03c24,0x3ea9bb34,3 +np.float32,0xfe118cd4,0xbfc90fdb,3 +np.float32,0x3e5b03b0,0x3e57c378,3 +np.float32,0x7f34d92d,0x3fc90fdb,3 +np.float32,0x806c3418,0x806c3418,3 +np.float32,0x7f3074e3,0x3fc90fdb,3 +np.float32,0x8002df02,0x8002df02,3 +np.float32,0x3f6df63a,0x3f3fb7b7,3 +np.float32,0xfd2b4100,0xbfc90fdb,3 +np.float32,0x80363d5c,0x80363d5c,3 +np.float32,0xbeac1f98,0xbea60bd6,3 +np.float32,0xff7fffff,0xbfc90fdb,3 +np.float32,0x80045097,0x80045097,3 +np.float32,0xfe011100,0xbfc90fdb,3 +np.float32,0x80739ef5,0x80739ef5,3 +np.float32,0xff3976ed,0xbfc90fdb,3 +np.float32,0xbe18e3a0,0xbe17c49e,3 +np.float32,0xbe289294,0xbe2712f6,3 +np.float32,0x3f1d41e7,0x3f0d050e,3 +np.float32,0x39364a,0x39364a,3 +np.float32,0x8072b77e,0x8072b77e,3 +np.float32,0x3f7cfec0,0x3f478cf6,3 +np.float32,0x2f68f6,0x2f68f6,3 +np.float32,0xbf031fb8,0xbef25c84,3 +np.float32,0xbf0b842c,0xbeff7afc,3 +np.float32,0x3f081e7e,0x3efa3676,3 +np.float32,0x7f7fffff,0x3fc90fdb,3 +np.float32,0xff15da0e,0xbfc90fdb,3 +np.float32,0x3d2001b2,0x3d1fece1,3 +np.float32,0x7f76efef,0x3fc90fdb,3 +np.float32,0x3f2405dd,0x3f11dfb7,3 +np.float32,0xa0319,0xa0319,3 +np.float32,0x3e23d2bd,0x3e227255,3 +np.float32,0xbd4d4c50,0xbd4d205e,3 +np.float32,0x382344,0x382344,3 +np.float32,0x21bbf,0x21bbf,3 +np.float32,0xbf209e82,0xbf0f7239,3 +np.float32,0xff03bf9f,0xbfc90fdb,3 +np.float32,0x7b1789,0x7b1789,3 +np.float32,0xff314944,0xbfc90fdb,3 +np.float32,0x1a63eb,0x1a63eb,3 +np.float32,0x803dc983,0x803dc983,3 +np.float32,0x3f0ff558,0x3f0323dc,3 +np.float32,0x3f544f2c,0x3f313f58,3 +np.float32,0xff032948,0xbfc90fdb,3 +np.float32,0x7f4933cc,0x3fc90fdb,3 +np.float32,0x7f14c5ed,0x3fc90fdb,3 +np.float32,0x803aeebf,0x803aeebf,3 +np.float32,0xbf0d4c0f,0xbf011bf5,3 +np.float32,0xbeaf8de2,0xbea91f57,3 +np.float32,0xff3ae030,0xbfc90fdb,3 +np.float32,0xbb362d00,0xbb362ce1,3 +np.float32,0x3d1f79e0,0x3d1f6544,3 +np.float32,0x3f56e9d9,0x3f32c860,3 +np.float32,0x3f723e5e,0x3f41fee2,3 +np.float32,0x4c0179,0x4c0179,3 +np.float32,0xfee36132,0xbfc90fdb,3 +np.float32,0x619ae6,0x619ae6,3 +np.float32,0xfde5d670,0xbfc90fdb,3 +np.float32,0xff079ac5,0xbfc90fdb,3 +np.float32,0x3e974fbd,0x3e931fae,3 +np.float32,0x8020ae6b,0x8020ae6b,3 +np.float32,0x6b5af1,0x6b5af1,3 +np.float32,0xbeb57cd6,0xbeae69a3,3 +np.float32,0x806e7eb2,0x806e7eb2,3 +np.float32,0x7e666edb,0x3fc90fdb,3 +np.float32,0xbf458c18,0xbf283ff0,3 +np.float32,0x3e50518e,0x3e4d8399,3 +np.float32,0x3e9ce224,0x3e983b98,3 +np.float32,0x3e6bc067,0x3e67b6c6,3 +np.float32,0x13783d,0x13783d,3 +np.float32,0xff3d518c,0xbfc90fdb,3 +np.float32,0xfeba5968,0xbfc90fdb,3 +np.float32,0xbf0b9f76,0xbeffa50f,3 +np.float32,0xfe174900,0xbfc90fdb,3 +np.float32,0x3f38bb0a,0x3f200527,3 +np.float32,0x7e94a77d,0x3fc90fdb,3 +np.float32,0x29d776,0x29d776,3 +np.float32,0xbf4e058d,0xbf2d7a15,3 +np.float32,0xbd94abc8,0xbd946923,3 +np.float32,0xbee62db0,0xbed85124,3 +np.float32,0x800000,0x800000,3 +np.float32,0xbef1df7e,0xbee1f636,3 +np.float32,0xbcf3cd20,0xbcf3bab5,3 +np.float32,0x80007b05,0x80007b05,3 +np.float32,0x3d9b3f2e,0x3d9af351,3 +np.float32,0xbf714a68,0xbf417dee,3 +np.float32,0xbf2a2d37,0xbf163069,3 +np.float32,0x8055104f,0x8055104f,3 +np.float32,0x7f5c40d7,0x3fc90fdb,3 +np.float32,0x1,0x1,3 +np.float32,0xff35f3a6,0xbfc90fdb,3 +np.float32,0xd9c7c,0xd9c7c,3 +np.float32,0xbf440cfc,0xbf274f22,3 +np.float32,0x8050ac43,0x8050ac43,3 +np.float32,0x63ee16,0x63ee16,3 +np.float32,0x7d90419b,0x3fc90fdb,3 +np.float32,0xfee22198,0xbfc90fdb,3 +np.float32,0xc2ead,0xc2ead,3 +np.float32,0x7f5cd6a6,0x3fc90fdb,3 +np.float32,0x3f6fab7e,0x3f40a184,3 +np.float32,0x3ecf998c,0x3ec53a73,3 +np.float32,0x7e5271f0,0x3fc90fdb,3 +np.float32,0x67c016,0x67c016,3 +np.float32,0x2189c8,0x2189c8,3 +np.float32,0x27d892,0x27d892,3 +np.float32,0x3f0d02c4,0x3f00e3c0,3 +np.float32,0xbf69ebca,0xbf3d8862,3 +np.float32,0x3e60c0d6,0x3e5d3ebb,3 +np.float32,0x3f45206c,0x3f27fc66,3 +np.float32,0xbf6b47dc,0xbf3e4592,3 +np.float32,0xfe9be2e2,0xbfc90fdb,3 +np.float32,0x7fa00000,0x7fe00000,3 +np.float32,0xff271562,0xbfc90fdb,3 +np.float32,0x3e2e5270,0x3e2caaaf,3 +np.float32,0x80222934,0x80222934,3 +np.float32,0xbd01d220,0xbd01c701,3 +np.float32,0x223aa0,0x223aa0,3 +np.float32,0x3f4b5a7e,0x3f2bd967,3 +np.float32,0x3f217d85,0x3f101200,3 +np.float32,0xbf57663a,0xbf331144,3 +np.float32,0x3f219862,0x3f102536,3 +np.float32,0x28a28c,0x28a28c,3 +np.float32,0xbf3f55f4,0xbf244f86,3 +np.float32,0xbf3de287,0xbf236092,3 +np.float32,0xbf1c1ce2,0xbf0c2fe3,3 +np.float32,0x80000001,0x80000001,3 +np.float32,0x3db695d0,0x3db61a90,3 +np.float32,0x6c39bf,0x6c39bf,3 +np.float32,0x7e33a12f,0x3fc90fdb,3 +np.float32,0x67623a,0x67623a,3 +np.float32,0x3e45dc54,0x3e4373b6,3 +np.float32,0x7f62fa68,0x3fc90fdb,3 +np.float32,0x3f0e1d01,0x3f01bbe5,3 +np.float32,0x3f13dc69,0x3f0615f5,3 +np.float32,0x246703,0x246703,3 +np.float32,0xbf1055b5,0xbf036d07,3 +np.float32,0x7f46d3d0,0x3fc90fdb,3 +np.float32,0x3d2b8086,0x3d2b66e5,3 +np.float32,0xbf03be44,0xbef35776,3 +np.float32,0x3f800000,0x3f490fdb,3 +np.float32,0xbec8d226,0xbebf613d,3 +np.float32,0x3d8faf00,0x3d8f72d4,3 +np.float32,0x170c4e,0x170c4e,3 +np.float32,0xff14c0f0,0xbfc90fdb,3 +np.float32,0xff16245d,0xbfc90fdb,3 +np.float32,0x7f44ce6d,0x3fc90fdb,3 +np.float32,0xbe8175d8,0xbe7d9aeb,3 +np.float32,0x3df7a4a1,0x3df67254,3 +np.float32,0xfe2cc46c,0xbfc90fdb,3 +np.float32,0x3f284e63,0x3f14e335,3 +np.float32,0x7e46e5d6,0x3fc90fdb,3 +np.float32,0x397be4,0x397be4,3 +np.float32,0xbf2560bc,0xbf12d50b,3 +np.float32,0x3ed9b8c1,0x3ecddc60,3 +np.float32,0xfec18c5a,0xbfc90fdb,3 +np.float32,0x64894d,0x64894d,3 +np.float32,0x36a65d,0x36a65d,3 +np.float32,0x804ffcd7,0x804ffcd7,3 +np.float32,0x800f79e4,0x800f79e4,3 +np.float32,0x5d45ac,0x5d45ac,3 +np.float32,0x6cdda0,0x6cdda0,3 +np.float32,0xbf7f2077,0xbf489fe5,3 +np.float32,0xbf152f78,0xbf0713a1,3 +np.float32,0x807bf344,0x807bf344,3 +np.float32,0x3f775023,0x3f44a4d8,3 +np.float32,0xbf3edf67,0xbf240365,3 +np.float32,0x7eed729c,0x3fc90fdb,3 +np.float32,0x14cc29,0x14cc29,3 +np.float32,0x7edd7b6b,0x3fc90fdb,3 +np.float32,0xbf3c6e2c,0xbf226fb7,3 +np.float32,0x51b9ad,0x51b9ad,3 +np.float32,0x3f617ee8,0x3f38dd7c,3 +np.float32,0xff800000,0xbfc90fdb,3 +np.float32,0x7f440ea0,0x3fc90fdb,3 +np.float32,0x3e639893,0x3e5ff49e,3 +np.float32,0xbd791bb0,0xbd78cd3c,3 +np.float32,0x8059fcbc,0x8059fcbc,3 +np.float32,0xbf7d1214,0xbf4796bd,3 +np.float32,0x3ef368fa,0x3ee33788,3 +np.float32,0xbecec0f4,0xbec48055,3 +np.float32,0xbc83d940,0xbc83d656,3 +np.float32,0xbce01220,0xbce003d4,3 +np.float32,0x803192a5,0x803192a5,3 +np.float32,0xbe40e0c0,0xbe3ea4f0,3 +np.float32,0xfb692600,0xbfc90fdb,3 +np.float32,0x3f1bec65,0x3f0c0c88,3 +np.float32,0x7f042798,0x3fc90fdb,3 +np.float32,0xbe047374,0xbe03b83b,3 +np.float32,0x7f7c6630,0x3fc90fdb,3 +np.float32,0x7f58dae3,0x3fc90fdb,3 +np.float32,0x80691c92,0x80691c92,3 +np.float32,0x7dbe76,0x7dbe76,3 +np.float32,0xbf231384,0xbf11339d,3 +np.float32,0xbef4acf8,0xbee43f8b,3 +np.float32,0x3ee9f9d0,0x3edb7793,3 +np.float32,0x3f0064f6,0x3eee04a8,3 +np.float32,0x313732,0x313732,3 +np.float32,0xfd58cf80,0xbfc90fdb,3 +np.float32,0x3f7a2bc9,0x3f461d30,3 +np.float32,0x7f7681af,0x3fc90fdb,3 +np.float32,0x7f504211,0x3fc90fdb,3 +np.float32,0xfeae0c00,0xbfc90fdb,3 +np.float32,0xbee14396,0xbed436d1,3 +np.float32,0x7fc00000,0x7fc00000,3 +np.float32,0x693406,0x693406,3 +np.float32,0x3eb4a679,0x3eadab1b,3 +np.float32,0x550505,0x550505,3 +np.float32,0xfd493d10,0xbfc90fdb,3 +np.float32,0x3f4fc907,0x3f2e8b2c,3 +np.float32,0x80799aa4,0x80799aa4,3 +np.float32,0xff1ea89b,0xbfc90fdb,3 +np.float32,0xff424510,0xbfc90fdb,3 +np.float32,0x7f68d026,0x3fc90fdb,3 +np.float32,0xbea230ca,0xbe9d1200,3 +np.float32,0x7ea585da,0x3fc90fdb,3 +np.float32,0x3f3db211,0x3f23414c,3 +np.float32,0xfea4d964,0xbfc90fdb,3 +np.float32,0xbf17fe18,0xbf092984,3 +np.float32,0x7cc8a2,0x7cc8a2,3 +np.float32,0xff0330ba,0xbfc90fdb,3 +np.float32,0x3f769835,0x3f444592,3 +np.float32,0xeb0ac,0xeb0ac,3 +np.float32,0x7f7e45de,0x3fc90fdb,3 +np.float32,0xbdb510a8,0xbdb49873,3 +np.float32,0x3ebf900b,0x3eb74e9c,3 +np.float32,0xbf21bbce,0xbf103e89,3 +np.float32,0xbf3f4682,0xbf24459d,3 +np.float32,0x7eb6e9c8,0x3fc90fdb,3 +np.float32,0xbf42532d,0xbf2637be,3 +np.float32,0xbd3b2600,0xbd3b04b4,3 +np.float32,0x3f1fa9aa,0x3f0ec23e,3 +np.float32,0x7ed6a0f1,0x3fc90fdb,3 +np.float32,0xff4759a1,0xbfc90fdb,3 +np.float32,0x6d26e3,0x6d26e3,3 +np.float32,0xfe1108e0,0xbfc90fdb,3 +np.float32,0xfdf76900,0xbfc90fdb,3 +np.float32,0xfec66f22,0xbfc90fdb,3 +np.float32,0xbf3d097f,0xbf22d458,3 +np.float32,0x3d85be25,0x3d858d99,3 +np.float32,0x7f36739f,0x3fc90fdb,3 +np.float32,0x7bc0a304,0x3fc90fdb,3 +np.float32,0xff48dd90,0xbfc90fdb,3 +np.float32,0x48cab0,0x48cab0,3 +np.float32,0x3ed3943c,0x3ec8a2ef,3 +np.float32,0xbf61488e,0xbf38bede,3 +np.float32,0x3f543df5,0x3f313525,3 +np.float32,0x5cf2ca,0x5cf2ca,3 +np.float32,0x572686,0x572686,3 +np.float32,0x80369c7c,0x80369c7c,3 +np.float32,0xbd2c1d20,0xbd2c0338,3 +np.float32,0x3e255428,0x3e23ea0b,3 +np.float32,0xbeba9ee0,0xbeb2f54c,3 +np.float32,0x8015c165,0x8015c165,3 +np.float32,0x3d31f488,0x3d31d7e6,3 +np.float32,0x3f68591c,0x3f3cac43,3 +np.float32,0xf5ed5,0xf5ed5,3 +np.float32,0xbf3b1d34,0xbf21949e,3 +np.float32,0x1f0343,0x1f0343,3 +np.float32,0x3f0e52b5,0x3f01e4ef,3 +np.float32,0x7f57c596,0x3fc90fdb,3 +np.float64,0x7fd8e333ddb1c667,0x3ff921fb54442d18,1 +np.float64,0x800bcc9cdad7993a,0x800bcc9cdad7993a,1 +np.float64,0x3fcd6f81df3adf00,0x3fcceebbafc5d55e,1 +np.float64,0x3fed7338a57ae671,0x3fe7ce3e5811fc0a,1 +np.float64,0x7fe64994fcac9329,0x3ff921fb54442d18,1 +np.float64,0xfa5a6345f4b4d,0xfa5a6345f4b4d,1 +np.float64,0xe9dcd865d3b9b,0xe9dcd865d3b9b,1 +np.float64,0x7fea6cffabf4d9fe,0x3ff921fb54442d18,1 +np.float64,0xa9e1de6153c3c,0xa9e1de6153c3c,1 +np.float64,0xab6bdc5356d7c,0xab6bdc5356d7c,1 +np.float64,0x80062864a02c50ca,0x80062864a02c50ca,1 +np.float64,0xbfdac03aa7b58076,0xbfd9569f3230128d,1 +np.float64,0xbfe61b77752c36ef,0xbfe3588f51b8be8f,1 +np.float64,0x800bc854c8d790aa,0x800bc854c8d790aa,1 +np.float64,0x3feed1a2da3da346,0x3fe887f9b8ea031f,1 +np.float64,0x3fe910d3697221a7,0x3fe54365a53d840e,1 +np.float64,0x7fe7ab4944ef5692,0x3ff921fb54442d18,1 +np.float64,0x3fa462f1a028c5e3,0x3fa460303a6a4e69,1 +np.float64,0x800794f1a3af29e4,0x800794f1a3af29e4,1 +np.float64,0x3fee6fe7fafcdfd0,0x3fe854f863816d55,1 +np.float64,0x8000000000000000,0x8000000000000000,1 +np.float64,0x7f336472fe66d,0x7f336472fe66d,1 +np.float64,0xffb1623ac822c478,0xbff921fb54442d18,1 +np.float64,0x3fbacd68ce359ad2,0x3fbab480b3638846,1 +np.float64,0xffd5c02706ab804e,0xbff921fb54442d18,1 +np.float64,0xbfd4daf03d29b5e0,0xbfd42928f069c062,1 +np.float64,0x800c6e85dbd8dd0c,0x800c6e85dbd8dd0c,1 +np.float64,0x800e3599c5bc6b34,0x800e3599c5bc6b34,1 +np.float64,0x2c0d654c581ad,0x2c0d654c581ad,1 +np.float64,0xbfdd3eb13fba7d62,0xbfdb6e8143302de7,1 +np.float64,0x800b60cb8776c197,0x800b60cb8776c197,1 +np.float64,0x80089819ad113034,0x80089819ad113034,1 +np.float64,0x29fe721453fcf,0x29fe721453fcf,1 +np.float64,0x3fe8722f4df0e45f,0x3fe4e026d9eadb4d,1 +np.float64,0xffd1fbcd01a3f79a,0xbff921fb54442d18,1 +np.float64,0x7fc74e1e982e9c3c,0x3ff921fb54442d18,1 +np.float64,0x800c09d3d15813a8,0x800c09d3d15813a8,1 +np.float64,0xbfeee4578b3dc8af,0xbfe891ab3d6c3ce4,1 +np.float64,0xffdd01a6f33a034e,0xbff921fb54442d18,1 +np.float64,0x7fcc130480382608,0x3ff921fb54442d18,1 +np.float64,0xffcbb6bd1d376d7c,0xbff921fb54442d18,1 +np.float64,0xc068a53780d15,0xc068a53780d15,1 +np.float64,0xbfc974f15532e9e4,0xbfc92100b355f3e7,1 +np.float64,0x3fe6da79442db4f3,0x3fe3d87393b082e7,1 +np.float64,0xd9d9be4db3b38,0xd9d9be4db3b38,1 +np.float64,0x5ea50a20bd4a2,0x5ea50a20bd4a2,1 +np.float64,0xbfe5597f7d2ab2ff,0xbfe2d3ccc544b52b,1 +np.float64,0x80019364e4e326cb,0x80019364e4e326cb,1 +np.float64,0x3fed2902c3fa5206,0x3fe7a5e1df07e5c1,1 +np.float64,0xbfa7b72b5c2f6e50,0xbfa7b2d545b3cc1f,1 +np.float64,0xffdb60dd43b6c1ba,0xbff921fb54442d18,1 +np.float64,0x81a65d8b034cc,0x81a65d8b034cc,1 +np.float64,0x8000c30385818608,0x8000c30385818608,1 +np.float64,0x6022f5f4c045f,0x6022f5f4c045f,1 +np.float64,0x8007a2bb810f4578,0x8007a2bb810f4578,1 +np.float64,0x7fdc68893238d111,0x3ff921fb54442d18,1 +np.float64,0x7fd443454ea8868a,0x3ff921fb54442d18,1 +np.float64,0xffe6b04209ed6084,0xbff921fb54442d18,1 +np.float64,0x7fcd9733d13b2e67,0x3ff921fb54442d18,1 +np.float64,0xf5ee80a9ebdd0,0xf5ee80a9ebdd0,1 +np.float64,0x3fe3788e8de6f11e,0x3fe17dec7e6843a0,1 +np.float64,0x3fee36f62f7c6dec,0x3fe836f832515b43,1 +np.float64,0xf6cb49aded969,0xf6cb49aded969,1 +np.float64,0x3fd2b15ea4a562bc,0x3fd22fdc09920e67,1 +np.float64,0x7fccf6aef139ed5d,0x3ff921fb54442d18,1 +np.float64,0x3fd396b8ce272d72,0x3fd3026118857bd4,1 +np.float64,0x7fe53d3c80ea7a78,0x3ff921fb54442d18,1 +np.float64,0x3feae88fc4f5d120,0x3fe65fb04b18ef7a,1 +np.float64,0x3fedc643747b8c86,0x3fe7fafa6c20e25a,1 +np.float64,0xffdb2dc0df365b82,0xbff921fb54442d18,1 +np.float64,0xbfa2af3658255e70,0xbfa2ad17348f4253,1 +np.float64,0x3f8aa77b30354ef6,0x3f8aa71892336a69,1 +np.float64,0xbfdd1b1efbba363e,0xbfdb510dcd186820,1 +np.float64,0x800f50d99c5ea1b3,0x800f50d99c5ea1b3,1 +np.float64,0xff6ed602403dac00,0xbff921fb54442d18,1 +np.float64,0x800477d71aa8efaf,0x800477d71aa8efaf,1 +np.float64,0xbfe729a9e86e5354,0xbfe40ca78d9eefcf,1 +np.float64,0x3fd81ab2d4303566,0x3fd70d7e3937ea22,1 +np.float64,0xb617cbab6c2fa,0xb617cbab6c2fa,1 +np.float64,0x7fefffffffffffff,0x3ff921fb54442d18,1 +np.float64,0xffa40933ac281260,0xbff921fb54442d18,1 +np.float64,0xbfe1ede621e3dbcc,0xbfe057bb2b341ced,1 +np.float64,0xbfec700f03b8e01e,0xbfe73fb190bc722e,1 +np.float64,0x6e28af02dc517,0x6e28af02dc517,1 +np.float64,0x3fe37ad37ae6f5a7,0x3fe17f94674818a9,1 +np.float64,0x8000cbdeeae197bf,0x8000cbdeeae197bf,1 +np.float64,0x3fe8fd1f01f1fa3e,0x3fe5372bbec5d72c,1 +np.float64,0x3f8f9229103f2452,0x3f8f918531894256,1 +np.float64,0x800536858e0a6d0c,0x800536858e0a6d0c,1 +np.float64,0x7fe82bb4f9f05769,0x3ff921fb54442d18,1 +np.float64,0xffc1c2fb592385f8,0xbff921fb54442d18,1 +np.float64,0x7f924ddfc0249bbf,0x3ff921fb54442d18,1 +np.float64,0xffd5e125c52bc24c,0xbff921fb54442d18,1 +np.float64,0xbfef0d8738be1b0e,0xbfe8a6ef17b16c10,1 +np.float64,0x3fc9c8875233910f,0x3fc9715e708503cb,1 +np.float64,0xbfe2d926f4e5b24e,0xbfe108956e61cbb3,1 +np.float64,0x7fd61c496dac3892,0x3ff921fb54442d18,1 +np.float64,0x7fed545c6b7aa8b8,0x3ff921fb54442d18,1 +np.float64,0x8003746fea86e8e1,0x8003746fea86e8e1,1 +np.float64,0x3fdf515e75bea2bd,0x3fdd201a5585caa3,1 +np.float64,0xffda87c8ee350f92,0xbff921fb54442d18,1 +np.float64,0xffc675d8e22cebb0,0xbff921fb54442d18,1 +np.float64,0xffcdc173433b82e8,0xbff921fb54442d18,1 +np.float64,0xffed9df1517b3be2,0xbff921fb54442d18,1 +np.float64,0x3fd6a2eec72d45de,0x3fd5c1f1d7dcddcf,1 +np.float64,0xffec116a66f822d4,0xbff921fb54442d18,1 +np.float64,0x8007c2a2458f8545,0x8007c2a2458f8545,1 +np.float64,0x3fe4ee80d969dd02,0x3fe2895076094668,1 +np.float64,0x3fe3cae7116795ce,0x3fe1b9c07e0d03a7,1 +np.float64,0xbfd81bf8d8b037f2,0xbfd70e9bbbb4ca57,1 +np.float64,0x800c88ccd1f9119a,0x800c88ccd1f9119a,1 +np.float64,0xffdab2aee2b5655e,0xbff921fb54442d18,1 +np.float64,0x3fe743d227ee87a4,0x3fe41dcaef186d96,1 +np.float64,0x3fb060fd0220c1fa,0x3fb05b47f56ebbb4,1 +np.float64,0xbfd3f03772a7e06e,0xbfd3541522377291,1 +np.float64,0x190a5ae03216,0x190a5ae03216,1 +np.float64,0x3fe48c71916918e4,0x3fe24442f45b3183,1 +np.float64,0x800862470590c48e,0x800862470590c48e,1 +np.float64,0x7fd3ced89d279db0,0x3ff921fb54442d18,1 +np.float64,0x3feb3d9b4ab67b37,0x3fe69140cf2623f7,1 +np.float64,0xbc3f296b787e5,0xbc3f296b787e5,1 +np.float64,0xbfed6b905dfad721,0xbfe7ca1881a8c0fd,1 +np.float64,0xbfe621c2aaac4386,0xbfe35cd1969a82db,1 +np.float64,0x8009e7b17593cf63,0x8009e7b17593cf63,1 +np.float64,0x80045f580ca8beb1,0x80045f580ca8beb1,1 +np.float64,0xbfea2e177e745c2f,0xbfe5f13971633339,1 +np.float64,0x3fee655787fccab0,0x3fe84f6b98b6de26,1 +np.float64,0x3fc9cde92f339bd0,0x3fc9768a88b2c97c,1 +np.float64,0x3fc819c3b3303388,0x3fc7d25e1526e731,1 +np.float64,0x3fd3e848d2a7d090,0x3fd34cd9e6af558f,1 +np.float64,0x3fe19dacac633b5a,0x3fe01a6b4d27adc2,1 +np.float64,0x800b190da316321c,0x800b190da316321c,1 +np.float64,0xd5c69711ab8d3,0xd5c69711ab8d3,1 +np.float64,0xbfdc31bed7b8637e,0xbfda8ea3c1309d6d,1 +np.float64,0xbfd02ba007a05740,0xbfcfad86f0d756dc,1 +np.float64,0x3fe874473d70e88e,0x3fe4e1793cd82123,1 +np.float64,0xffb465585c28cab0,0xbff921fb54442d18,1 +np.float64,0xbfb5d8e13e2bb1c0,0xbfb5cb5c7807fc4d,1 +np.float64,0xffe80f933bf01f26,0xbff921fb54442d18,1 +np.float64,0x7feea783f5fd4f07,0x3ff921fb54442d18,1 +np.float64,0xbfae6665f43cccd0,0xbfae5d45b0a6f90a,1 +np.float64,0x800bd6ef5a77addf,0x800bd6ef5a77addf,1 +np.float64,0x800d145babda28b8,0x800d145babda28b8,1 +np.float64,0x39de155473bc3,0x39de155473bc3,1 +np.float64,0x3fefbd6bb1ff7ad8,0x3fe9008e73a3296e,1 +np.float64,0x3fc40bca3d281798,0x3fc3e2710e167007,1 +np.float64,0x3fcae0918335c120,0x3fca7e09e704a678,1 +np.float64,0x51287fbea2511,0x51287fbea2511,1 +np.float64,0x7fa6bc33a82d7866,0x3ff921fb54442d18,1 +np.float64,0xe72a2bebce546,0xe72a2bebce546,1 +np.float64,0x3fe1c8fd686391fa,0x3fe03b9622aeb4e3,1 +np.float64,0x3fe2a73ac3654e76,0x3fe0e36bc1ee4ac4,1 +np.float64,0x59895218b312b,0x59895218b312b,1 +np.float64,0xc6dc25c78db85,0xc6dc25c78db85,1 +np.float64,0xbfc06cfac520d9f4,0xbfc0561f85d2c907,1 +np.float64,0xbfea912dc4f5225c,0xbfe62c3b1c01c793,1 +np.float64,0x3fb78ce89a2f19d0,0x3fb77bfcb65a67d3,1 +np.float64,0xbfece5cdea39cb9c,0xbfe78103d24099e5,1 +np.float64,0x30d3054e61a61,0x30d3054e61a61,1 +np.float64,0xbfd3fe26fba7fc4e,0xbfd360c8447c4f7a,1 +np.float64,0x800956072a92ac0f,0x800956072a92ac0f,1 +np.float64,0x7fe639b3b6ec7366,0x3ff921fb54442d18,1 +np.float64,0x800ee30240bdc605,0x800ee30240bdc605,1 +np.float64,0x7fef6af0d2bed5e1,0x3ff921fb54442d18,1 +np.float64,0xffefce8725ff9d0d,0xbff921fb54442d18,1 +np.float64,0x3fe2e311da65c624,0x3fe10ff1623089dc,1 +np.float64,0xbfe7e5cbe56fcb98,0xbfe486c3daeda67c,1 +np.float64,0x80095bc14472b783,0x80095bc14472b783,1 +np.float64,0xffef0cb4553e1968,0xbff921fb54442d18,1 +np.float64,0xe3e60567c7cc1,0xe3e60567c7cc1,1 +np.float64,0xffde919f06bd233e,0xbff921fb54442d18,1 +np.float64,0x3fe3f9632e27f2c6,0x3fe1db49ebd21c4e,1 +np.float64,0x9dee9a233bdd4,0x9dee9a233bdd4,1 +np.float64,0xbfe3bb0602e7760c,0xbfe1ae41b6d4c488,1 +np.float64,0x3fc46945a128d288,0x3fc43da54c6c6a2a,1 +np.float64,0x7fdef149ac3de292,0x3ff921fb54442d18,1 +np.float64,0x800a96c76d752d8f,0x800a96c76d752d8f,1 +np.float64,0x3f971a32382e3464,0x3f9719316b9e9baf,1 +np.float64,0x7fe97bcf15b2f79d,0x3ff921fb54442d18,1 +np.float64,0x7fea894558f5128a,0x3ff921fb54442d18,1 +np.float64,0x3fc9e3be1933c780,0x3fc98b847c3923eb,1 +np.float64,0x3f7accac40359959,0x3f7acc9330741b64,1 +np.float64,0xa80c136950183,0xa80c136950183,1 +np.float64,0x3fe408732b2810e6,0x3fe1e61e7cbc8824,1 +np.float64,0xffa775bc042eeb80,0xbff921fb54442d18,1 +np.float64,0x3fbf04bd223e0980,0x3fbede37b8fc697e,1 +np.float64,0x7fd999b34c333366,0x3ff921fb54442d18,1 +np.float64,0xe72146dfce429,0xe72146dfce429,1 +np.float64,0x4f511ee49ea24,0x4f511ee49ea24,1 +np.float64,0xffb3e6e58827cdc8,0xbff921fb54442d18,1 +np.float64,0x3fd1f180cfa3e300,0x3fd17e85b2871de2,1 +np.float64,0x97c8e45b2f91d,0x97c8e45b2f91d,1 +np.float64,0xbfeeb20e88fd641d,0xbfe8778f878440bf,1 +np.float64,0xbfe1fc6dee23f8dc,0xbfe062c815a93cde,1 +np.float64,0xab4bf71f5697f,0xab4bf71f5697f,1 +np.float64,0xa9675a2952cec,0xa9675a2952cec,1 +np.float64,0xbfef3ea4a33e7d49,0xbfe8c02743ebc1b6,1 +np.float64,0x3fe22a2eafa4545d,0x3fe08577afca52a9,1 +np.float64,0x3fe8a08daaf1411c,0x3fe4fd5a34f05305,1 +np.float64,0xbfc6cda77b2d9b50,0xbfc6910bcfa0cf4f,1 +np.float64,0x3fec398394387307,0x3fe7211dd5276500,1 +np.float64,0x3fe36c95c626d92c,0x3fe1752e5aa2357b,1 +np.float64,0xffd8b9e7073173ce,0xbff921fb54442d18,1 +np.float64,0xffe19f043ae33e08,0xbff921fb54442d18,1 +np.float64,0x800e3640709c6c81,0x800e3640709c6c81,1 +np.float64,0x3fe7d6c20aafad84,0x3fe47d1a3307d9c8,1 +np.float64,0x80093fd63b727fad,0x80093fd63b727fad,1 +np.float64,0xffe1a671a4634ce3,0xbff921fb54442d18,1 +np.float64,0xbfe53a6b386a74d6,0xbfe2be41859cb10d,1 +np.float64,0xbfed149a097a2934,0xbfe79ab7e3e93c1c,1 +np.float64,0x7fc2769a5724ed34,0x3ff921fb54442d18,1 +np.float64,0xffd01e4e99a03c9e,0xbff921fb54442d18,1 +np.float64,0xa61f38434c3e7,0xa61f38434c3e7,1 +np.float64,0x800ad4ac5195a959,0x800ad4ac5195a959,1 +np.float64,0x7ff8000000000000,0x7ff8000000000000,1 +np.float64,0x80034a45b6c6948c,0x80034a45b6c6948c,1 +np.float64,0x6350b218c6a17,0x6350b218c6a17,1 +np.float64,0xfff0000000000000,0xbff921fb54442d18,1 +np.float64,0x3fe363e759e6c7cf,0x3fe16ed58d80f9ce,1 +np.float64,0xffe3b98e59e7731c,0xbff921fb54442d18,1 +np.float64,0x3fdbf7b40337ef68,0x3fda5df7ad3c80f9,1 +np.float64,0xbfe9cdf784739bef,0xbfe5b74f346ef93d,1 +np.float64,0xbfc321bea326437c,0xbfc2fdc0d4ff7561,1 +np.float64,0xbfe40f77d2a81ef0,0xbfe1eb28c4ae4dde,1 +np.float64,0x7fe071806960e300,0x3ff921fb54442d18,1 +np.float64,0x7fd269006ea4d200,0x3ff921fb54442d18,1 +np.float64,0x80017a56e0e2f4af,0x80017a56e0e2f4af,1 +np.float64,0x8004b4ea09a969d5,0x8004b4ea09a969d5,1 +np.float64,0xbfedbb01e63b7604,0xbfe7f4f0e84297df,1 +np.float64,0x3fe44454826888a9,0x3fe210ff6d005706,1 +np.float64,0xbfe0e77e6ea1cefd,0xbfdf1a977da33402,1 +np.float64,0xbfed6d4c8c3ada99,0xbfe7cb0932093f60,1 +np.float64,0x1d74cb9e3ae9a,0x1d74cb9e3ae9a,1 +np.float64,0x80082a785d1054f1,0x80082a785d1054f1,1 +np.float64,0x3fe58393266b0726,0x3fe2f0d8e91d4887,1 +np.float64,0xffe4028899680510,0xbff921fb54442d18,1 +np.float64,0x783a2e5af0746,0x783a2e5af0746,1 +np.float64,0x7fcdce88e73b9d11,0x3ff921fb54442d18,1 +np.float64,0x3fc58672a72b0ce5,0x3fc5535e090e56e2,1 +np.float64,0x800889c839b11391,0x800889c839b11391,1 +np.float64,0xffe5e05c466bc0b8,0xbff921fb54442d18,1 +np.float64,0xbfcbef6ebe37dedc,0xbfcb810752468f49,1 +np.float64,0xffe9408563b2810a,0xbff921fb54442d18,1 +np.float64,0xbfee4738367c8e70,0xbfe83f8e5dd7602f,1 +np.float64,0xbfe4aeb587295d6b,0xbfe25c7a0c76a454,1 +np.float64,0xffc9aea0a7335d40,0xbff921fb54442d18,1 +np.float64,0xe1e02199c3c04,0xe1e02199c3c04,1 +np.float64,0xbfbd9400783b2800,0xbfbd729345d1d14f,1 +np.float64,0x7a5418bcf4a84,0x7a5418bcf4a84,1 +np.float64,0x3fdc1c2fa5b83860,0x3fda7c935965ae72,1 +np.float64,0x80076a9f58ced53f,0x80076a9f58ced53f,1 +np.float64,0x3fedc4bf957b897f,0x3fe7fa2a83148f1c,1 +np.float64,0x800981b8a9d30372,0x800981b8a9d30372,1 +np.float64,0xffe1082311621046,0xbff921fb54442d18,1 +np.float64,0xe0091f89c0124,0xe0091f89c0124,1 +np.float64,0xbfce8d674f3d1ad0,0xbfcdfdbf2ddaa0ca,1 +np.float64,0x800516e72eaa2dcf,0x800516e72eaa2dcf,1 +np.float64,0xffe61ee64c6c3dcc,0xbff921fb54442d18,1 +np.float64,0x7fed2683cafa4d07,0x3ff921fb54442d18,1 +np.float64,0xffd4faf27729f5e4,0xbff921fb54442d18,1 +np.float64,0x7fe308fa842611f4,0x3ff921fb54442d18,1 +np.float64,0x3fc612a62b2c2550,0x3fc5db9ddbd4e159,1 +np.float64,0xbfe5b01e766b603d,0xbfe30f72a875e988,1 +np.float64,0x3fc2dd8b9a25bb17,0x3fc2bb06246b9f78,1 +np.float64,0x8170908102e12,0x8170908102e12,1 +np.float64,0x800c1c8a8a583915,0x800c1c8a8a583915,1 +np.float64,0xffe5d91e8b6bb23c,0xbff921fb54442d18,1 +np.float64,0xffd140adee22815c,0xbff921fb54442d18,1 +np.float64,0xbfe2f1f5f8e5e3ec,0xbfe11afa5d749952,1 +np.float64,0xbfed6d1d587ada3b,0xbfe7caef9ecf7651,1 +np.float64,0x3fe9b85e67f370bd,0x3fe5aa3474768982,1 +np.float64,0x7fdc8932edb91265,0x3ff921fb54442d18,1 +np.float64,0x7fd136bc54a26d78,0x3ff921fb54442d18,1 +np.float64,0x800a1ea12a343d43,0x800a1ea12a343d43,1 +np.float64,0x3fec6a5c1b78d4b8,0x3fe73c82235c3f8f,1 +np.float64,0x800fbf6a00df7ed4,0x800fbf6a00df7ed4,1 +np.float64,0xbfd0e6e0cda1cdc2,0xbfd0864bf8cad294,1 +np.float64,0x3fc716df482e2dbf,0x3fc6d7fbfd4a8470,1 +np.float64,0xbfe75990936eb321,0xbfe42bffec3fa0d7,1 +np.float64,0x3fd58e54a02b1ca9,0x3fd4cace1107a5cc,1 +np.float64,0xbfc9c04136338084,0xbfc9696ad2591d54,1 +np.float64,0xdd1f0147ba3e0,0xdd1f0147ba3e0,1 +np.float64,0x5c86a940b90e,0x5c86a940b90e,1 +np.float64,0xbfecae3b8e795c77,0xbfe7624d4988c612,1 +np.float64,0xffd0370595206e0c,0xbff921fb54442d18,1 +np.float64,0xbfdc26d443384da8,0xbfda857ecd33ba9f,1 +np.float64,0xbfd1c849d9a39094,0xbfd15849449cc378,1 +np.float64,0xffee04acdb3c0959,0xbff921fb54442d18,1 +np.float64,0xbfded1056dbda20a,0xbfdcb83b30e1528c,1 +np.float64,0x7fb7b826622f704c,0x3ff921fb54442d18,1 +np.float64,0xbfee4df8ae7c9bf1,0xbfe8431df9dfd05d,1 +np.float64,0x7fe7f3670e2fe6cd,0x3ff921fb54442d18,1 +np.float64,0x8008ac9ae0d15936,0x8008ac9ae0d15936,1 +np.float64,0x800dce9f3b3b9d3f,0x800dce9f3b3b9d3f,1 +np.float64,0x7fbb19db203633b5,0x3ff921fb54442d18,1 +np.float64,0x3fe56c7f302ad8fe,0x3fe2e0eec3ad45fd,1 +np.float64,0x7fe82c05c570580b,0x3ff921fb54442d18,1 +np.float64,0xc0552b7780aa6,0xc0552b7780aa6,1 +np.float64,0x39d40e3073a83,0x39d40e3073a83,1 +np.float64,0x3fd8db54d731b6aa,0x3fd7b589b3ee9b20,1 +np.float64,0xffcdd355233ba6ac,0xbff921fb54442d18,1 +np.float64,0x3fbe97b3a43d2f67,0x3fbe72bca9be0348,1 +np.float64,0xbff0000000000000,0xbfe921fb54442d18,1 +np.float64,0xbfb4f55e6229eac0,0xbfb4e96df18a75a7,1 +np.float64,0xbfc66399ba2cc734,0xbfc62a3298bd96fc,1 +np.float64,0x3fd00988bb201311,0x3fcf6d67a9374c38,1 +np.float64,0x7fe471867d28e30c,0x3ff921fb54442d18,1 +np.float64,0xbfe38e0e64271c1d,0xbfe18d9888b7523b,1 +np.float64,0x8009dc127573b825,0x8009dc127573b825,1 +np.float64,0x800047bde4608f7d,0x800047bde4608f7d,1 +np.float64,0xffeede42c77dbc85,0xbff921fb54442d18,1 +np.float64,0xd8cf6d13b19ee,0xd8cf6d13b19ee,1 +np.float64,0xbfd08fb302a11f66,0xbfd034b1f8235e23,1 +np.float64,0x7fdb404c0b368097,0x3ff921fb54442d18,1 +np.float64,0xbfd6ba0438ad7408,0xbfd5d673e3276ec1,1 +np.float64,0xffd9568027b2ad00,0xbff921fb54442d18,1 +np.float64,0xbfb313b73e262770,0xbfb30ab4acb4fa67,1 +np.float64,0xbfe2dc1a15e5b834,0xbfe10ac5f8f3acd3,1 +np.float64,0xbfee426bf4bc84d8,0xbfe83d061df91edd,1 +np.float64,0xd9142c2fb2286,0xd9142c2fb2286,1 +np.float64,0x7feb0d11dff61a23,0x3ff921fb54442d18,1 +np.float64,0x800fea5b509fd4b7,0x800fea5b509fd4b7,1 +np.float64,0x3fe1a8818da35103,0x3fe022ba1bdf366e,1 +np.float64,0x8010000000000000,0x8010000000000000,1 +np.float64,0xbfd8fc6de6b1f8dc,0xbfd7d24726ed8dcc,1 +np.float64,0xf4b3dc2de967c,0xf4b3dc2de967c,1 +np.float64,0x8af0409b15e08,0x8af0409b15e08,1 +np.float64,0x3fb21e6934243cd2,0x3fb216b065f8709a,1 +np.float64,0x3fc53069392a60d2,0x3fc4ffa931211fb9,1 +np.float64,0xffc955812c32ab04,0xbff921fb54442d18,1 +np.float64,0xbfe3de42b1a7bc86,0xbfe1c7bd1324de75,1 +np.float64,0x1dc149a03b82a,0x1dc149a03b82a,1 +np.float64,0x8001bc5a24a378b5,0x8001bc5a24a378b5,1 +np.float64,0x3da14c407b44,0x3da14c407b44,1 +np.float64,0x80025e8da924bd1c,0x80025e8da924bd1c,1 +np.float64,0xbfcb0141c9360284,0xbfca9d572ea5e1f3,1 +np.float64,0xc90036fd92007,0xc90036fd92007,1 +np.float64,0x138312c427063,0x138312c427063,1 +np.float64,0x800dda3a963bb475,0x800dda3a963bb475,1 +np.float64,0x3fe9339934f26732,0x3fe558e723291f78,1 +np.float64,0xbfea8357027506ae,0xbfe6240826faaf48,1 +np.float64,0x7fe04735cae08e6b,0x3ff921fb54442d18,1 +np.float64,0x3fe29aca3c653594,0x3fe0da214c8bc6a4,1 +np.float64,0x3fbe1f09a03c3e13,0x3fbdfbbefef0155b,1 +np.float64,0x816ee4ad02ddd,0x816ee4ad02ddd,1 +np.float64,0xffddd1b31d3ba366,0xbff921fb54442d18,1 +np.float64,0x3fe2e01e0625c03c,0x3fe10dc0bd6677c2,1 +np.float64,0x3fec6bcf1978d79e,0x3fe73d518cddeb7c,1 +np.float64,0x7fe01aaaf8603555,0x3ff921fb54442d18,1 +np.float64,0xdf300cc5be602,0xdf300cc5be602,1 +np.float64,0xbfe71c01a36e3804,0xbfe403af80ce47b8,1 +np.float64,0xffa5be00ac2b7c00,0xbff921fb54442d18,1 +np.float64,0xbfda9ba711b5374e,0xbfd93775e3ac6bda,1 +np.float64,0xbfe56d8a27eadb14,0xbfe2e1a7185e8e6d,1 +np.float64,0x800f1bc937be3792,0x800f1bc937be3792,1 +np.float64,0x800a61d93c74c3b3,0x800a61d93c74c3b3,1 +np.float64,0x7fe71a52fcae34a5,0x3ff921fb54442d18,1 +np.float64,0x7fb4aef256295de4,0x3ff921fb54442d18,1 +np.float64,0x3fe6c1e861ed83d1,0x3fe3c828f281a7ef,1 +np.float64,0x3fba128402342508,0x3fb9fb94cf141860,1 +np.float64,0x3fee55a7ecfcab50,0x3fe8472a9af893ee,1 +np.float64,0x3fe586f31b2b0de6,0x3fe2f32bce9e91bc,1 +np.float64,0xbfbb1d1442363a28,0xbfbb034c7729d5f2,1 +np.float64,0xc78b4d3f8f16a,0xc78b4d3f8f16a,1 +np.float64,0x7fdbc277d4b784ef,0x3ff921fb54442d18,1 +np.float64,0xbfa728ca2c2e5190,0xbfa724c04e73ccbd,1 +np.float64,0x7fefc7b2143f8f63,0x3ff921fb54442d18,1 +np.float64,0x3fd153a3dda2a748,0x3fd0ebccd33a4dca,1 +np.float64,0xbfe18a6eace314de,0xbfe00ba32ec89d30,1 +np.float64,0x7feef518537dea30,0x3ff921fb54442d18,1 +np.float64,0x8005f007cd4be010,0x8005f007cd4be010,1 +np.float64,0x7fd890b840b12170,0x3ff921fb54442d18,1 +np.float64,0x7feed0582ebda0af,0x3ff921fb54442d18,1 +np.float64,0x1013f53220280,0x1013f53220280,1 +np.float64,0xbfe77273986ee4e7,0xbfe43c375a8bf6de,1 +np.float64,0x7fe3ab8918675711,0x3ff921fb54442d18,1 +np.float64,0xbfc6ad515b2d5aa4,0xbfc671b2f7f86624,1 +np.float64,0x7fcd86231d3b0c45,0x3ff921fb54442d18,1 +np.float64,0xffe2523299a4a464,0xbff921fb54442d18,1 +np.float64,0x7fcadc5a1b35b8b3,0x3ff921fb54442d18,1 +np.float64,0x3fe5e020c4ebc042,0x3fe330418eec75bd,1 +np.float64,0x7fe332a9dc266553,0x3ff921fb54442d18,1 +np.float64,0xfa11dc21f425,0xfa11dc21f425,1 +np.float64,0xbec800177d900,0xbec800177d900,1 +np.float64,0x3fcadd057835ba0b,0x3fca7aa42face8bc,1 +np.float64,0xbfe6b9a206ad7344,0xbfe3c2a9719803de,1 +np.float64,0x3fbb4250b63684a0,0x3fbb281e9cefc519,1 +np.float64,0x7fef8787517f0f0e,0x3ff921fb54442d18,1 +np.float64,0x8001315c2d6262b9,0x8001315c2d6262b9,1 +np.float64,0xbfd94e3cf2b29c7a,0xbfd819257d36f56c,1 +np.float64,0xf1f325abe3e65,0xf1f325abe3e65,1 +np.float64,0x7fd6c07079ad80e0,0x3ff921fb54442d18,1 +np.float64,0x7fe328b075a65160,0x3ff921fb54442d18,1 +np.float64,0x7fe7998f812f331e,0x3ff921fb54442d18,1 +np.float64,0xffe026bb65604d76,0xbff921fb54442d18,1 +np.float64,0xffd6c06de8ad80dc,0xbff921fb54442d18,1 +np.float64,0x3fcd5a37bf3ab46f,0x3fccda82935d98ce,1 +np.float64,0xffc3e5a45227cb48,0xbff921fb54442d18,1 +np.float64,0x3febf7dd8177efbc,0x3fe6fc0bb999883e,1 +np.float64,0x7fd7047ea92e08fc,0x3ff921fb54442d18,1 +np.float64,0x35b3fc406b680,0x35b3fc406b680,1 +np.float64,0x7fd52e97632a5d2e,0x3ff921fb54442d18,1 +np.float64,0x3fd464d401a8c9a8,0x3fd3be2967fc97c3,1 +np.float64,0x800e815b2ebd02b6,0x800e815b2ebd02b6,1 +np.float64,0x3fca8428af350850,0x3fca257b466b8970,1 +np.float64,0x8007b7526f6f6ea6,0x8007b7526f6f6ea6,1 +np.float64,0x82f60a8f05ec2,0x82f60a8f05ec2,1 +np.float64,0x3fb71a5d0a2e34c0,0x3fb70a629ef8e2a2,1 +np.float64,0x7fc8570c7d30ae18,0x3ff921fb54442d18,1 +np.float64,0x7fe5528e77eaa51c,0x3ff921fb54442d18,1 +np.float64,0xffc20dbbf1241b78,0xbff921fb54442d18,1 +np.float64,0xeb13368fd6267,0xeb13368fd6267,1 +np.float64,0x7fe7d529056faa51,0x3ff921fb54442d18,1 +np.float64,0x3fecd02eabf9a05d,0x3fe77516f0ba1ac4,1 +np.float64,0x800fcba6a09f974d,0x800fcba6a09f974d,1 +np.float64,0x7fe7e8e015afd1bf,0x3ff921fb54442d18,1 +np.float64,0xbfd271a382a4e348,0xbfd1f513a191c595,1 +np.float64,0x9f1014013e21,0x9f1014013e21,1 +np.float64,0x3fc05da47f20bb49,0x3fc04708a13a3a47,1 +np.float64,0x3fe0f427dda1e850,0x3fdf2e60ba8678b9,1 +np.float64,0xbfecb29fa539653f,0xbfe764bc791c45dd,1 +np.float64,0x45881ec68b104,0x45881ec68b104,1 +np.float64,0x8000000000000001,0x8000000000000001,1 +np.float64,0x3fe9c67ee1338cfe,0x3fe5b2c7b3df6ce8,1 +np.float64,0x7fedb8fef6bb71fd,0x3ff921fb54442d18,1 +np.float64,0x3fe54f6aaaea9ed6,0x3fe2ccd1df2abaa9,1 +np.float64,0x7feff58a1bbfeb13,0x3ff921fb54442d18,1 +np.float64,0x7fe3b62827276c4f,0x3ff921fb54442d18,1 +np.float64,0x3fe5feb682ebfd6d,0x3fe345105bc6d980,1 +np.float64,0x3fe49f38d9693e72,0x3fe2518b2824757f,1 +np.float64,0x8006bfd27c6d7fa6,0x8006bfd27c6d7fa6,1 +np.float64,0x3fc13409e2226814,0x3fc119ce0c01a5a2,1 +np.float64,0x95f8c7212bf19,0x95f8c7212bf19,1 +np.float64,0x3fd9f0fa6133e1f5,0x3fd8a567515edecf,1 +np.float64,0x3fef95cbe5ff2b98,0x3fe8ec88c768ba0b,1 +np.float64,0x3fbed28bba3da510,0x3fbeacbf136e51c2,1 +np.float64,0xbfd3987aeca730f6,0xbfd303fca58e3e60,1 +np.float64,0xbfed0f90cbfa1f22,0xbfe797f59249410d,1 +np.float64,0xffe55d8cbf2abb19,0xbff921fb54442d18,1 +np.float64,0x3feb4d9fc6769b40,0x3fe69a88131a1f1f,1 +np.float64,0x80085569acd0aad4,0x80085569acd0aad4,1 +np.float64,0x20557a6e40ab0,0x20557a6e40ab0,1 +np.float64,0x3fead2fd5df5a5fb,0x3fe653091f33b27f,1 +np.float64,0x3fe7b9983eaf7330,0x3fe46a50c4b5235e,1 +np.float64,0xffdad237ffb5a470,0xbff921fb54442d18,1 +np.float64,0xbfe5cc39a4eb9874,0xbfe322ad3a903f93,1 +np.float64,0x800ad6eecb35adde,0x800ad6eecb35adde,1 +np.float64,0xffec620f6438c41e,0xbff921fb54442d18,1 +np.float64,0xbfe5ef29122bde52,0xbfe33a7dfcc255e2,1 +np.float64,0x3fd451e7d0a8a3d0,0x3fd3acfa4939af10,1 +np.float64,0x8003ea93c127d528,0x8003ea93c127d528,1 +np.float64,0x800b48d37c9691a7,0x800b48d37c9691a7,1 +np.float64,0x3fe7e202acafc405,0x3fe484558246069b,1 +np.float64,0x80070c9b686e1938,0x80070c9b686e1938,1 +np.float64,0xbfda90bbc6352178,0xbfd92e25fcd12288,1 +np.float64,0x800e1ffebb1c3ffe,0x800e1ffebb1c3ffe,1 +np.float64,0x3ff0000000000000,0x3fe921fb54442d18,1 +np.float64,0xffd8cfdd46319fba,0xbff921fb54442d18,1 +np.float64,0x7fd8cd4182319a82,0x3ff921fb54442d18,1 +np.float64,0x3fed8bb778bb176f,0x3fe7db7c77c4c694,1 +np.float64,0x3fc74a70302e94e0,0x3fc709e95d6defec,1 +np.float64,0x3fe87269d070e4d4,0x3fe4e04bcc4a2137,1 +np.float64,0x7fb48223f6290447,0x3ff921fb54442d18,1 +np.float64,0xffe8ec444b71d888,0xbff921fb54442d18,1 +np.float64,0x7fde17d280bc2fa4,0x3ff921fb54442d18,1 +np.float64,0x3fd1cbde01a397bc,0x3fd15b9bb7b3147b,1 +np.float64,0x800883a64451074d,0x800883a64451074d,1 +np.float64,0x7fe3160a3f262c13,0x3ff921fb54442d18,1 +np.float64,0xbfe051d4d9a0a3aa,0xbfde2ecf14dc75fb,1 +np.float64,0xbfd89de689b13bce,0xbfd780176d1a28a3,1 +np.float64,0x3fecde2bf779bc58,0x3fe77ccf10bdd8e2,1 +np.float64,0xffe75774dc6eaee9,0xbff921fb54442d18,1 +np.float64,0x7fe834414d706882,0x3ff921fb54442d18,1 +np.float64,0x1,0x1,1 +np.float64,0xbfea5e4e4a74bc9c,0xbfe60e0601711835,1 +np.float64,0xffec248d4cb8491a,0xbff921fb54442d18,1 +np.float64,0xffd9942c2c332858,0xbff921fb54442d18,1 +np.float64,0xa9db36a553b67,0xa9db36a553b67,1 +np.float64,0x7fec630718b8c60d,0x3ff921fb54442d18,1 +np.float64,0xbfd062188f20c432,0xbfd009ecd652be89,1 +np.float64,0x8001b84e3023709d,0x8001b84e3023709d,1 +np.float64,0xbfe9e26d7cb3c4db,0xbfe5c3b157ecf668,1 +np.float64,0xbfef66ddf33ecdbc,0xbfe8d4b1f6410a24,1 +np.float64,0x3fd8d7109431ae21,0x3fd7b1d4860719a2,1 +np.float64,0xffee0f53107c1ea5,0xbff921fb54442d18,1 +np.float64,0x80000b4fd60016a0,0x80000b4fd60016a0,1 +np.float64,0xbfd99ff6e5333fee,0xbfd85fb3cbdaa049,1 +np.float64,0xbfe9cfd268339fa5,0xbfe5b86ef021a1b1,1 +np.float64,0xe32eace1c65d6,0xe32eace1c65d6,1 +np.float64,0xffc81f6627303ecc,0xbff921fb54442d18,1 +np.float64,0x7fe98dadde331b5b,0x3ff921fb54442d18,1 +np.float64,0xbfbcebd11e39d7a0,0xbfbccc8ec47883c7,1 +np.float64,0x7fe164880f22c90f,0x3ff921fb54442d18,1 +np.float64,0x800467c0cae8cf82,0x800467c0cae8cf82,1 +np.float64,0x800071e4b140e3ca,0x800071e4b140e3ca,1 +np.float64,0xbfc87a7eae30f4fc,0xbfc82fbc55bb0f24,1 +np.float64,0xffb2e0e23225c1c8,0xbff921fb54442d18,1 +np.float64,0x20ef338041df,0x20ef338041df,1 +np.float64,0x7fe6de71ca6dbce3,0x3ff921fb54442d18,1 +np.float64,0x5d1fa026ba3f5,0x5d1fa026ba3f5,1 +np.float64,0xffd112a9ce222554,0xbff921fb54442d18,1 +np.float64,0x3fb351f66626a3ed,0x3fb3489ab578c452,1 +np.float64,0x7fef7b2bd3bef657,0x3ff921fb54442d18,1 +np.float64,0xffe144f5d4e289eb,0xbff921fb54442d18,1 +np.float64,0xffd63a6750ac74ce,0xbff921fb54442d18,1 +np.float64,0x7fd2d8bb25a5b175,0x3ff921fb54442d18,1 +np.float64,0x3fec5920a078b242,0x3fe732dcffcf6521,1 +np.float64,0x80009a8b7f813518,0x80009a8b7f813518,1 +np.float64,0x3fdea220893d4441,0x3fdc921edf6bf3d8,1 +np.float64,0x8006cee2208d9dc5,0x8006cee2208d9dc5,1 +np.float64,0xdd0b0081ba17,0xdd0b0081ba17,1 +np.float64,0x7ff4000000000000,0x7ffc000000000000,1 +np.float64,0xbfdac33955358672,0xbfd9592bce7daf1f,1 +np.float64,0x7fe8301d7170603a,0x3ff921fb54442d18,1 +np.float64,0xbfc1d34d8523a69c,0xbfc1b62449af9684,1 +np.float64,0x800c62239458c447,0x800c62239458c447,1 +np.float64,0xffd398c009a73180,0xbff921fb54442d18,1 +np.float64,0xbfe0c6d9ee218db4,0xbfdee777557f4401,1 +np.float64,0x3feccdd373799ba7,0x3fe773c9c2263f89,1 +np.float64,0xbfd21898bda43132,0xbfd1a2be8545fcc5,1 +np.float64,0x3fd77019b62ee033,0x3fd67793cabdf267,1 +np.float64,0x7fa609cad42c1395,0x3ff921fb54442d18,1 +np.float64,0x7fb4eaea5a29d5d4,0x3ff921fb54442d18,1 +np.float64,0x3fc570dc9a2ae1b9,0x3fc53e5f6218a799,1 +np.float64,0x800344ae8466895e,0x800344ae8466895e,1 +np.float64,0xbfc7c985252f930c,0xbfc784d60fa27bac,1 +np.float64,0xffaa2929fc345250,0xbff921fb54442d18,1 +np.float64,0xffe63e5ee9ac7cbe,0xbff921fb54442d18,1 +np.float64,0x73f0280ce7e06,0x73f0280ce7e06,1 +np.float64,0xffc525f8822a4bf0,0xbff921fb54442d18,1 +np.float64,0x7fd744d00aae899f,0x3ff921fb54442d18,1 +np.float64,0xbfe0fe590761fcb2,0xbfdf3e493e8b1f32,1 +np.float64,0xfae04ae7f5c0a,0xfae04ae7f5c0a,1 +np.float64,0xef821939df043,0xef821939df043,1 +np.float64,0x7fef6135843ec26a,0x3ff921fb54442d18,1 +np.float64,0xbfebf34dcbf7e69c,0xbfe6f97588a8f911,1 +np.float64,0xbfeec0b498fd8169,0xbfe87f2eceeead12,1 +np.float64,0x7fb67161b42ce2c2,0x3ff921fb54442d18,1 +np.float64,0x3fdcfd998639fb33,0x3fdb38934927c096,1 +np.float64,0xffda5960bc34b2c2,0xbff921fb54442d18,1 +np.float64,0xbfe11f8c71223f19,0xbfdf71fe770c96ab,1 +np.float64,0x3fe4ac1bab695838,0x3fe25aa4517b8322,1 +np.float64,0x3f730458a02608b1,0x3f73044fabb5e999,1 +np.float64,0x3fdb14ffcdb62a00,0x3fd99ea6c241a3ed,1 +np.float64,0xbfc93208cd326410,0xbfc8e09d78b6d4db,1 +np.float64,0x19e734dc33ce8,0x19e734dc33ce8,1 +np.float64,0x3fe5e98428abd308,0x3fe336a6a085eb55,1 +np.float64,0x7fec672a1378ce53,0x3ff921fb54442d18,1 +np.float64,0x800f8bd8d4ff17b2,0x800f8bd8d4ff17b2,1 +np.float64,0xbfe5a12e4e6b425c,0xbfe30533f99d5d06,1 +np.float64,0x75a34cb0eb46a,0x75a34cb0eb46a,1 +np.float64,0x7fe1d21d16a3a439,0x3ff921fb54442d18,1 +np.float64,0x7ff0000000000000,0x3ff921fb54442d18,1 +np.float64,0xffe0f50db261ea1b,0xbff921fb54442d18,1 +np.float64,0xbfd9dc22feb3b846,0xbfd8937ec965a501,1 +np.float64,0x8009d68e48d3ad1d,0x8009d68e48d3ad1d,1 +np.float64,0xbfe2eba620e5d74c,0xbfe1164d7d273c60,1 +np.float64,0x992efa09325e0,0x992efa09325e0,1 +np.float64,0x3fdab640ea356c82,0x3fd94e20cab88db2,1 +np.float64,0x69a6f04ad34df,0x69a6f04ad34df,1 +np.float64,0x3fe397df25272fbe,0x3fe194bd1a3a6192,1 +np.float64,0xebcce9fdd799d,0xebcce9fdd799d,1 +np.float64,0x3fbb49490c369292,0x3fbb2f02eccc497d,1 +np.float64,0xffd871f980b0e3f4,0xbff921fb54442d18,1 +np.float64,0x800348f6966691ee,0x800348f6966691ee,1 +np.float64,0xbfebc270a7f784e1,0xbfe6dda8d0d80f26,1 +np.float64,0xffd6d559b1adaab4,0xbff921fb54442d18,1 +np.float64,0x3fec3635c0b86c6c,0x3fe71f420256e43e,1 +np.float64,0x7fbc82ad7039055a,0x3ff921fb54442d18,1 +np.float64,0x7f873050602e60a0,0x3ff921fb54442d18,1 +np.float64,0x3fca44b8c3348970,0x3fc9e8a1a1a2d96e,1 +np.float64,0x3fe0fc308fe1f861,0x3fdf3aeb469ea225,1 +np.float64,0x7fefc27de8bf84fb,0x3ff921fb54442d18,1 +np.float64,0x8005f3f3916be7e8,0x8005f3f3916be7e8,1 +np.float64,0xbfd4278c7c284f18,0xbfd38678988873b6,1 +np.float64,0x435eafc486bd7,0x435eafc486bd7,1 +np.float64,0xbfd01f5199203ea4,0xbfcf96631f2108a3,1 +np.float64,0xffd5ee9185abdd24,0xbff921fb54442d18,1 +np.float64,0xffedb363257b66c5,0xbff921fb54442d18,1 +np.float64,0x800d68e6e11ad1ce,0x800d68e6e11ad1ce,1 +np.float64,0xbfcf687f8e3ed100,0xbfceccb771b0d39a,1 +np.float64,0x7feb3b9ef2f6773d,0x3ff921fb54442d18,1 +np.float64,0x3fe15ec5ca62bd8c,0x3fdfd3fab9d96f81,1 +np.float64,0x10000000000000,0x10000000000000,1 +np.float64,0xd2386f81a470e,0xd2386f81a470e,1 +np.float64,0xb9feed4573fde,0xb9feed4573fde,1 +np.float64,0x3fe7ed25c9efda4c,0x3fe48b7b72db4014,1 +np.float64,0xbfe01478726028f1,0xbfddcd1f5a2efc59,1 +np.float64,0x9946d02f328da,0x9946d02f328da,1 +np.float64,0xbfe3bb67f06776d0,0xbfe1ae88aa81c5a6,1 +np.float64,0xbfd3fd8a4c27fb14,0xbfd3603982e3b78d,1 +np.float64,0xffd5c3ab912b8758,0xbff921fb54442d18,1 +np.float64,0xffd5f502b12bea06,0xbff921fb54442d18,1 +np.float64,0xbfc64981ec2c9304,0xbfc610e0382b1fa6,1 +np.float64,0xffec42e3413885c6,0xbff921fb54442d18,1 +np.float64,0x80084eb4ed109d6a,0x80084eb4ed109d6a,1 +np.float64,0xbfd17cac9fa2f95a,0xbfd112020588a4b3,1 +np.float64,0xbfd06c1359a0d826,0xbfd0134a28aa9a66,1 +np.float64,0x7fdc3d7c03b87af7,0x3ff921fb54442d18,1 +np.float64,0x7bdf5aaaf7bec,0x7bdf5aaaf7bec,1 +np.float64,0xbfee3cd966fc79b3,0xbfe83a14bc07ac3b,1 +np.float64,0x7fec910da3f9221a,0x3ff921fb54442d18,1 +np.float64,0xffb4ea667029d4d0,0xbff921fb54442d18,1 +np.float64,0x800103d7cce207b0,0x800103d7cce207b0,1 +np.float64,0x7fbb229a6c364534,0x3ff921fb54442d18,1 +np.float64,0x0,0x0,1 +np.float64,0xffd8fccd0331f99a,0xbff921fb54442d18,1 +np.float64,0xbfd0784ae1a0f096,0xbfd01ebff62e39ad,1 +np.float64,0xbfed2ec9b3ba5d93,0xbfe7a9099410bc76,1 +np.float64,0x800690b8d16d2172,0x800690b8d16d2172,1 +np.float64,0x7fc061b26520c364,0x3ff921fb54442d18,1 +np.float64,0x8007ec47054fd88f,0x8007ec47054fd88f,1 +np.float64,0x775546b6eeaa9,0x775546b6eeaa9,1 +np.float64,0x8005e00fb56bc020,0x8005e00fb56bc020,1 +np.float64,0xbfe510f8d0ea21f2,0xbfe2a16862b5a37f,1 +np.float64,0xffd87a6bf3b0f4d8,0xbff921fb54442d18,1 +np.float64,0x800906e3d0520dc8,0x800906e3d0520dc8,1 +np.float64,0x2296f000452f,0x2296f000452f,1 +np.float64,0xbfe3189fa2e63140,0xbfe1378c0e005be4,1 +np.float64,0xb4d2447f69a49,0xb4d2447f69a49,1 +np.float64,0xffd056a24a20ad44,0xbff921fb54442d18,1 +np.float64,0xbfe3b23fe4e76480,0xbfe1a7e5840fcbeb,1 +np.float64,0x80018ee270831dc6,0x80018ee270831dc6,1 +np.float64,0x800df89f245bf13e,0x800df89f245bf13e,1 +np.float64,0x3fee1409d7bc2814,0x3fe824779d133232,1 +np.float64,0xbfef8d81667f1b03,0xbfe8e85523620368,1 +np.float64,0xffd8a6519b314ca4,0xbff921fb54442d18,1 +np.float64,0x7fc7bc86f32f790d,0x3ff921fb54442d18,1 +np.float64,0xffea6159e674c2b3,0xbff921fb54442d18,1 +np.float64,0x3fe153c3fba2a788,0x3fdfc2f74769d300,1 +np.float64,0xffc4261ef3284c3c,0xbff921fb54442d18,1 +np.float64,0x7fe8a8961ff1512b,0x3ff921fb54442d18,1 +np.float64,0xbfe3fb1fd167f640,0xbfe1dc89dcb7ecdf,1 +np.float64,0x3fd88577c2b10af0,0x3fd76acc09660704,1 +np.float64,0x3fe128ec27e251d8,0x3fdf808fc7ebcd8f,1 +np.float64,0xbfed6ca7c4fad950,0xbfe7caafe9a3e213,1 +np.float64,0xbf9a3912b8347220,0xbf9a379b3349352e,1 +np.float64,0xbfd724d7bcae49b0,0xbfd6351efa2a5fc5,1 +np.float64,0xbfed59700a7ab2e0,0xbfe7c043014c694c,1 +np.float64,0x8002ad435bc55a87,0x8002ad435bc55a87,1 +np.float64,0xffe46ed345a8dda6,0xbff921fb54442d18,1 +np.float64,0x7fd2f1d1d825e3a3,0x3ff921fb54442d18,1 +np.float64,0xbfea0265e23404cc,0xbfe5d6fb3fd30464,1 +np.float64,0xbfd17e049122fc0a,0xbfd113421078bbae,1 +np.float64,0xffea03b986b40772,0xbff921fb54442d18,1 +np.float64,0x800b55331a16aa67,0x800b55331a16aa67,1 +np.float64,0xbfc6fcafbf2df960,0xbfc6be9ecd0ebc1f,1 +np.float64,0xd6a36017ad46c,0xd6a36017ad46c,1 +np.float64,0xbfe9ba86dfb3750e,0xbfe5ab840cb0ef86,1 +np.float64,0x75c4a108eb895,0x75c4a108eb895,1 +np.float64,0x8008d6bc8051ad79,0x8008d6bc8051ad79,1 +np.float64,0xbfd3dc5984a7b8b4,0xbfd341f78e0528ec,1 +np.float64,0xffe1cbb01aa39760,0xbff921fb54442d18,1 +np.float64,0x3fc7e292f52fc526,0x3fc79d0ce9365767,1 +np.float64,0xbfcbeae2bd37d5c4,0xbfcb7cb034f82467,1 +np.float64,0x8000f0c62e21e18d,0x8000f0c62e21e18d,1 +np.float64,0xbfe23d8bc6247b18,0xbfe09418ee35c3c7,1 +np.float64,0x717394bae2e73,0x717394bae2e73,1 +np.float64,0xffa2ef1cc425de40,0xbff921fb54442d18,1 +np.float64,0x3fd938c229b27184,0x3fd806900735c99d,1 +np.float64,0x800bf3ec8a77e7d9,0x800bf3ec8a77e7d9,1 +np.float64,0xffeef41dd57de83b,0xbff921fb54442d18,1 +np.float64,0x8008df97e5b1bf30,0x8008df97e5b1bf30,1 +np.float64,0xffe9ab9d0db35739,0xbff921fb54442d18,1 +np.float64,0x99ff391333fe7,0x99ff391333fe7,1 +np.float64,0x3fb864b4a630c969,0x3fb851e883ea2cf9,1 +np.float64,0x22c1230a45825,0x22c1230a45825,1 +np.float64,0xff2336fbfe467,0xff2336fbfe467,1 +np.float64,0xbfd488f4cea911ea,0xbfd3def0490f5414,1 +np.float64,0x3fa379c78426f38f,0x3fa377607370800b,1 +np.float64,0xbfb0873302210e68,0xbfb08155b78dfd53,1 +np.float64,0xbfdf9ff7c2bf3ff0,0xbfdd5f658e357ad2,1 +np.float64,0x800978719192f0e4,0x800978719192f0e4,1 +np.float64,0xbfba8759ea350eb0,0xbfba6f325013b9e5,1 +np.float64,0xbfdd3e6b06ba7cd6,0xbfdb6e472b6091b0,1 +np.float64,0x7fe0c334a7a18668,0x3ff921fb54442d18,1 +np.float64,0xbfeb971feb772e40,0xbfe6c4e0f61404d1,1 +np.float64,0x3fe2a50968e54a13,0x3fe0e1c8b8d96e85,1 +np.float64,0x800fa9c5515f538b,0x800fa9c5515f538b,1 +np.float64,0x800f8532fbbf0a66,0x800f8532fbbf0a66,1 +np.float64,0x167d6f1e2cfaf,0x167d6f1e2cfaf,1 +np.float64,0xffee88e769fd11ce,0xbff921fb54442d18,1 +np.float64,0xbfeecc8529fd990a,0xbfe885520cdad8ea,1 +np.float64,0xffefffffffffffff,0xbff921fb54442d18,1 +np.float64,0xbfef6a566afed4ad,0xbfe8d6767b4c4235,1 +np.float64,0xffec12415af82482,0xbff921fb54442d18,1 +np.float64,0x3678a20a6cf15,0x3678a20a6cf15,1 +np.float64,0xffe468d54ee8d1aa,0xbff921fb54442d18,1 +np.float64,0x800ad6006795ac01,0x800ad6006795ac01,1 +np.float64,0x8001d5b61063ab6d,0x8001d5b61063ab6d,1 +np.float64,0x800dfcd1863bf9a3,0x800dfcd1863bf9a3,1 +np.float64,0xc9fbff6f93f80,0xc9fbff6f93f80,1 +np.float64,0xffe55c20f9eab842,0xbff921fb54442d18,1 +np.float64,0xbfcb596b6536b2d8,0xbfcaf1b339c5c615,1 +np.float64,0xbfe092689ea124d1,0xbfde94fa58946e51,1 +np.float64,0x3fe9ec733af3d8e6,0x3fe5c9bf5dee2623,1 +np.float64,0x3fe30f3d83261e7b,0x3fe1309fd6620e03,1 +np.float64,0xffd31d7f84263b00,0xbff921fb54442d18,1 +np.float64,0xbfe88d2d3e711a5a,0xbfe4f12b5a136178,1 +np.float64,0xffc81e4ce1303c98,0xbff921fb54442d18,1 +np.float64,0xffe5b96ebfab72dd,0xbff921fb54442d18,1 +np.float64,0x512f0502a25e1,0x512f0502a25e1,1 +np.float64,0x7fa3a376982746ec,0x3ff921fb54442d18,1 +np.float64,0x80005b5f2f60b6bf,0x80005b5f2f60b6bf,1 +np.float64,0xc337cc69866fa,0xc337cc69866fa,1 +np.float64,0x3fe7719c4caee339,0x3fe43bab42b19e64,1 +np.float64,0x7fde7ec1d93cfd83,0x3ff921fb54442d18,1 +np.float64,0x3fd2f38f3825e71e,0x3fd26cc7b1dd0acb,1 +np.float64,0x7fce298b993c5316,0x3ff921fb54442d18,1 +np.float64,0x56ae3b2cad5c8,0x56ae3b2cad5c8,1 +np.float64,0x3fe9299f2bf2533e,0x3fe552bddd999e72,1 +np.float64,0x7feff3a4823fe748,0x3ff921fb54442d18,1 +np.float64,0xbfd05c670aa0b8ce,0xbfd00494d78e9e97,1 +np.float64,0xffe745323eae8a64,0xbff921fb54442d18,1 diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/data/umath-validation-set-arctanh.csv b/venv/lib/python3.12/site-packages/numpy/_core/tests/data/umath-validation-set-arctanh.csv new file mode 100644 index 00000000..68ecaab3 --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/tests/data/umath-validation-set-arctanh.csv @@ -0,0 +1,1429 @@ +dtype,input,output,ulperrortol +np.float32,0x3ee82930,0x3efa60fd,2 +np.float32,0x3f0aa640,0x3f1b3e13,2 +np.float32,0x3ec1a21c,0x3ecbbf8d,2 +np.float32,0x3cdb1740,0x3cdb24a1,2 +np.float32,0xbf28b6f3,0xbf4a86ac,2 +np.float32,0xbe490dcc,0xbe4bb2eb,2 +np.float32,0x80000001,0x80000001,2 +np.float32,0xbf44f9dd,0xbf826ce1,2 +np.float32,0xbf1d66c4,0xbf37786b,2 +np.float32,0x3f0ad26a,0x3f1b7c9b,2 +np.float32,0x3f7b6c54,0x4016aab0,2 +np.float32,0xbf715bb8,0xbfe1a0bc,2 +np.float32,0xbee8a562,0xbefafd6a,2 +np.float32,0x3db94d00,0x3db9cf16,2 +np.float32,0x3ee2970c,0x3ef368b3,2 +np.float32,0x3f3f8614,0x3f77fdca,2 +np.float32,0xbf1fb5f0,0xbf3b3789,2 +np.float32,0x3f798dc0,0x400b96bb,2 +np.float32,0x3e975d64,0x3e9c0573,2 +np.float32,0xbe3f1908,0xbe415d1f,2 +np.float32,0x3f2cea38,0x3f52192e,2 +np.float32,0x3e82f1ac,0x3e85eaa1,2 +np.float32,0x3eab6b30,0x3eb24acd,2 +np.float32,0xbe9bb90c,0xbea0cf5f,2 +np.float32,0xbf43e847,0xbf81202f,2 +np.float32,0xbd232fa0,0xbd2345c0,2 +np.float32,0xbbabbc00,0xbbabbc67,2 +np.float32,0xbf0b2975,0xbf1bf808,2 +np.float32,0xbef5ab0a,0xbf05d305,2 +np.float32,0x3f2cad16,0x3f51a8e2,2 +np.float32,0xbef75940,0xbf06eb08,2 +np.float32,0xbf0c1216,0xbf1d4325,2 +np.float32,0x3e7bdc08,0x3e8090c2,2 +np.float32,0x3da14e10,0x3da1a3c5,2 +np.float32,0x3f627412,0x3fb2bf21,2 +np.float32,0xbd6d08c0,0xbd6d4ca0,2 +np.float32,0x3f3e2368,0x3f74df8b,2 +np.float32,0xbe0df104,0xbe0edc77,2 +np.float32,0x3e8a265c,0x3e8da833,2 +np.float32,0xbdccdbb0,0xbdcd8ba8,2 +np.float32,0x3eb080c4,0x3eb80a44,2 +np.float32,0x3e627800,0x3e6645fe,2 +np.float32,0xbd8be0b0,0xbd8c1886,2 +np.float32,0xbf3282ac,0xbf5cae8c,2 +np.float32,0xbe515910,0xbe545707,2 +np.float32,0xbf2e64ac,0xbf54d637,2 +np.float32,0x3e0fc230,0x3e10b6de,2 +np.float32,0x3eb13ca0,0x3eb8df94,2 +np.float32,0x3f07a3ca,0x3f170572,2 +np.float32,0x3f2c7026,0x3f513935,2 +np.float32,0x3f3c4ec8,0x3f70d67c,2 +np.float32,0xbee9cce8,0xbefc724f,2 +np.float32,0xbe53ca60,0xbe56e3f3,2 +np.float32,0x3dd9e9a0,0x3ddabd98,2 +np.float32,0x3f38b8d4,0x3f69319b,2 +np.float32,0xbe176dc4,0xbe188c1d,2 +np.float32,0xbf322f2e,0xbf5c0c51,2 +np.float32,0xbe9b8676,0xbea097a2,2 +np.float32,0xbca44280,0xbca44823,2 +np.float32,0xbe2b0248,0xbe2ca036,2 +np.float32,0x3d101e80,0x3d102dbd,2 +np.float32,0xbf4eb610,0xbf8f526d,2 +np.float32,0xbec32a50,0xbecd89d1,2 +np.float32,0x3d549100,0x3d54c1ee,2 +np.float32,0x3f78e55e,0x40087025,2 +np.float32,0x3e592798,0x3e5c802d,2 +np.float32,0x3de045d0,0x3de12cfb,2 +np.float32,0xbdad28e0,0xbdad92f7,2 +np.float32,0x3e9a69e0,0x3e9f5e59,2 +np.float32,0x3e809778,0x3e836716,2 +np.float32,0xbf3278d9,0xbf5c9b6d,2 +np.float32,0x3f39fa00,0x3f6bd4a5,2 +np.float32,0xbec8143c,0xbed34ffa,2 +np.float32,0x3ddb7f40,0x3ddc57e6,2 +np.float32,0x3f0e8342,0x3f20c634,2 +np.float32,0x3f353dda,0x3f6213a4,2 +np.float32,0xbe96b400,0xbe9b4bea,2 +np.float32,0x3e626580,0x3e66328a,2 +np.float32,0xbde091c8,0xbde179df,2 +np.float32,0x3eb47b5c,0x3ebc91ca,2 +np.float32,0xbf282182,0xbf497f2f,2 +np.float32,0x3ea9f64c,0x3eb0a748,2 +np.float32,0x3f28dd4e,0x3f4aca86,2 +np.float32,0xbf71de18,0xbfe3f587,2 +np.float32,0x7fa00000,0x7fe00000,2 +np.float32,0xbf6696a6,0xbfbcf11a,2 +np.float32,0xbc853ae0,0xbc853de2,2 +np.float32,0xbeced246,0xbedb51b8,2 +np.float32,0x3f3472a4,0x3f607e00,2 +np.float32,0xbee90124,0xbefb7117,2 +np.float32,0x3eb45b90,0x3ebc6d7c,2 +np.float32,0xbe53ead0,0xbe5705d6,2 +np.float32,0x3f630c80,0x3fb420e2,2 +np.float32,0xbf408cd0,0xbf7a56a2,2 +np.float32,0x3dda4ed0,0x3ddb23f1,2 +np.float32,0xbf37ae88,0xbf67096b,2 +np.float32,0xbdd48c28,0xbdd550c9,2 +np.float32,0xbf5745b0,0xbf9cb4a4,2 +np.float32,0xbf44e6fc,0xbf8255c1,2 +np.float32,0x3f5c8e6a,0x3fa65020,2 +np.float32,0xbea45fe8,0xbeaa6630,2 +np.float32,0x3f08bdee,0x3f188ef5,2 +np.float32,0x3ec77e74,0x3ed29f4b,2 +np.float32,0xbf1a1d3c,0xbf324029,2 +np.float32,0x3cad7340,0x3cad79e3,2 +np.float32,0xbf4fac2e,0xbf90b72a,2 +np.float32,0x3f58516e,0x3f9e8330,2 +np.float32,0x3f442008,0x3f816391,2 +np.float32,0xbf6e0c6c,0xbfd42854,2 +np.float32,0xbf266f7a,0xbf4689b2,2 +np.float32,0x3eb7e2f0,0x3ec077ba,2 +np.float32,0xbf320fd0,0xbf5bcf83,2 +np.float32,0xbf6a76b9,0xbfc80a11,2 +np.float32,0xbf2a91b4,0xbf4dd526,2 +np.float32,0x3f176e30,0x3f2e150e,2 +np.float32,0xbdcccad0,0xbdcd7a9c,2 +np.float32,0x3f60a8a4,0x3faebbf7,2 +np.float32,0x3d9706f0,0x3d974d40,2 +np.float32,0x3ef3cd34,0x3f049d58,2 +np.float32,0xbf73c615,0xbfed79fe,2 +np.float32,0x3df1b170,0x3df2d31b,2 +np.float32,0x3f632a46,0x3fb466c7,2 +np.float32,0xbf3ea18e,0xbf75f9ce,2 +np.float32,0xbf3ea05c,0xbf75f71f,2 +np.float32,0xbdd76750,0xbdd83403,2 +np.float32,0xbca830c0,0xbca836cd,2 +np.float32,0x3f1d4162,0x3f373c59,2 +np.float32,0x3c115700,0x3c1157fa,2 +np.float32,0x3dae8ab0,0x3daef758,2 +np.float32,0xbcad5020,0xbcad56bf,2 +np.float32,0x3ee299c4,0x3ef36c15,2 +np.float32,0xbf7f566c,0xc054c3bd,2 +np.float32,0x3f0cc698,0x3f1e4557,2 +np.float32,0xbe75c648,0xbe7aaa04,2 +np.float32,0x3ea29238,0x3ea86417,2 +np.float32,0x3f09d9c0,0x3f1a1d61,2 +np.float32,0x3f67275c,0x3fbe74b3,2 +np.float32,0x3e1a4e18,0x3e1b7d3a,2 +np.float32,0xbef6e3fc,0xbf069e98,2 +np.float32,0xbf6038ac,0xbfadc9fd,2 +np.float32,0xbe46bdd4,0xbe494b7f,2 +np.float32,0xbf4df1f4,0xbf8e3a98,2 +np.float32,0x3d094dc0,0x3d095aed,2 +np.float32,0x3f44c7d2,0x3f822fa3,2 +np.float32,0xbea30816,0xbea8e737,2 +np.float32,0xbe3c27c4,0xbe3e511b,2 +np.float32,0x3f3bb47c,0x3f6f8789,2 +np.float32,0xbe423760,0xbe4498c3,2 +np.float32,0x3ece1a74,0x3eda7634,2 +np.float32,0x3f14d1f6,0x3f2a1a89,2 +np.float32,0xbf4d9e8f,0xbf8dc4c1,2 +np.float32,0xbe92968e,0xbe96cd7f,2 +np.float32,0x3e99e6c0,0x3e9ece26,2 +np.float32,0xbf397361,0xbf6ab878,2 +np.float32,0xbf4fcea4,0xbf90e99f,2 +np.float32,0x3de37640,0x3de46779,2 +np.float32,0x3eb1b604,0x3eb9698c,2 +np.float32,0xbf52d0a2,0xbf957361,2 +np.float32,0xbe20435c,0xbe21975a,2 +np.float32,0x3f437a58,0x3f809bf1,2 +np.float32,0x3f27d1cc,0x3f48f335,2 +np.float32,0x3f7d4ff2,0x4027d1e2,2 +np.float32,0xbef732e4,0xbf06d205,2 +np.float32,0x3f4a0ae6,0x3f88e18e,2 +np.float32,0x3f800000,0x7f800000,2 +np.float32,0x3e3e56a0,0x3e4093ba,2 +np.float32,0xbed2fcfa,0xbee0517d,2 +np.float32,0xbe0e0114,0xbe0eecd7,2 +np.float32,0xbe808574,0xbe8353db,2 +np.float32,0x3f572e2a,0x3f9c8c86,2 +np.float32,0x80800000,0x80800000,2 +np.float32,0x3f3f3c82,0x3f775703,2 +np.float32,0xbf6e2482,0xbfd4818b,2 +np.float32,0xbf3943b0,0xbf6a5439,2 +np.float32,0x3f6e42ac,0x3fd4f1ea,2 +np.float32,0x3eb676c4,0x3ebed619,2 +np.float32,0xbe5e56c4,0xbe61ef6c,2 +np.float32,0x3eea200c,0x3efcdb65,2 +np.float32,0x3e3d2c78,0x3e3f5ef8,2 +np.float32,0xbdfd8fb0,0xbdfede71,2 +np.float32,0xbee69c8a,0xbef86e89,2 +np.float32,0x3e9efca0,0x3ea46a1c,2 +np.float32,0x3e4c2498,0x3e4ee9ee,2 +np.float32,0xbf3cc93c,0xbf71e21d,2 +np.float32,0x3ee0d77c,0x3ef13d2b,2 +np.float32,0xbefbcd2a,0xbf09d6a3,2 +np.float32,0x3f6dbe5c,0x3fd30a3e,2 +np.float32,0x3dae63e0,0x3daed03f,2 +np.float32,0xbd5001e0,0xbd502fb9,2 +np.float32,0x3f59632a,0x3fa067c8,2 +np.float32,0x3f0d355a,0x3f1ee452,2 +np.float32,0x3f2cbe5c,0x3f51c896,2 +np.float32,0x3c5e6e80,0x3c5e7200,2 +np.float32,0xbe8ac49c,0xbe8e52f0,2 +np.float32,0x3f54e576,0x3f98c0e6,2 +np.float32,0xbeaa0762,0xbeb0ba7c,2 +np.float32,0x3ec81e88,0x3ed35c21,2 +np.float32,0x3f5a6738,0x3fa23fb6,2 +np.float32,0xbf24a682,0xbf43784a,2 +np.float32,0x1,0x1,2 +np.float32,0x3ee6bc24,0x3ef89630,2 +np.float32,0x3f19444a,0x3f30ecf5,2 +np.float32,0x3ec1fc70,0x3ecc28fc,2 +np.float32,0xbf706e14,0xbfdd92fb,2 +np.float32,0x3eccb630,0x3ed8cd98,2 +np.float32,0xbcdf7aa0,0xbcdf88d3,2 +np.float32,0xbe450da8,0xbe478a8e,2 +np.float32,0x3ec9c210,0x3ed54c0b,2 +np.float32,0xbf3b86ca,0xbf6f24d1,2 +np.float32,0x3edcc7a0,0x3eec3a5c,2 +np.float32,0x3f075d5c,0x3f16a39a,2 +np.float32,0xbf5719ce,0xbf9c69de,2 +np.float32,0x3f62cb22,0x3fb3885a,2 +np.float32,0x3f639216,0x3fb55c93,2 +np.float32,0xbf473ee7,0xbf85413a,2 +np.float32,0xbf01b66c,0xbf0eea86,2 +np.float32,0x3e872d80,0x3e8a74f8,2 +np.float32,0xbf60957e,0xbfae925c,2 +np.float32,0xbf6847b2,0xbfc1929b,2 +np.float32,0x3f78bb94,0x4007b363,2 +np.float32,0xbf47efdb,0xbf8622db,2 +np.float32,0xbe1f2308,0xbe206fd6,2 +np.float32,0xbf414926,0xbf7c0a7e,2 +np.float32,0x3eecc268,0x3f00194d,2 +np.float32,0x3eb086d0,0x3eb81120,2 +np.float32,0xbef1af80,0xbf033ff5,2 +np.float32,0xbf454e56,0xbf82d4aa,2 +np.float32,0x3e622560,0x3e65ef20,2 +np.float32,0x3f50d2b2,0x3f926a83,2 +np.float32,0x3eb2c45c,0x3eba9d2c,2 +np.float32,0x3e42d1a0,0x3e4538c9,2 +np.float32,0xbf24cc5c,0xbf43b8e3,2 +np.float32,0x3e8c6464,0x3e90141a,2 +np.float32,0xbf3abff2,0xbf6d79c5,2 +np.float32,0xbec8f2e6,0xbed456fa,2 +np.float32,0xbf787b38,0xc00698b4,2 +np.float32,0xbf58d5cd,0xbf9f6c03,2 +np.float32,0x3df4ee20,0x3df61ba8,2 +np.float32,0xbf34581e,0xbf604951,2 +np.float32,0xbeba5cf4,0xbec35119,2 +np.float32,0xbf76c22d,0xbfffc51c,2 +np.float32,0x3ef63b2c,0x3f0630b4,2 +np.float32,0x3eeadb64,0x3efdc877,2 +np.float32,0x3dfd8c70,0x3dfedb24,2 +np.float32,0x3f441600,0x3f81576d,2 +np.float32,0x3f23a0d8,0x3f41bbf6,2 +np.float32,0x3cb84d40,0x3cb85536,2 +np.float32,0xbf25cb5c,0xbf456e38,2 +np.float32,0xbc108540,0xbc108636,2 +np.float32,0xbc5b9140,0xbc5b949e,2 +np.float32,0xbf62ff40,0xbfb401dd,2 +np.float32,0x3e8e0710,0x3e91d93e,2 +np.float32,0x3f1b6ae0,0x3f344dfd,2 +np.float32,0xbf4dbbbe,0xbf8dedea,2 +np.float32,0x3f1a5fb2,0x3f32a880,2 +np.float32,0xbe56bd00,0xbe59f8cb,2 +np.float32,0xbf490a5c,0xbf87902d,2 +np.float32,0xbf513072,0xbf92f717,2 +np.float32,0x3e73ee28,0x3e78b542,2 +np.float32,0x3f0a4c7a,0x3f1abf2c,2 +np.float32,0x3e10d5c8,0x3e11d00b,2 +np.float32,0xbf771aac,0xc001207e,2 +np.float32,0x3efe2f54,0x3f0b6a46,2 +np.float32,0xbea5f3ea,0xbeac291f,2 +np.float32,0xbf1a73e8,0xbf32c845,2 +np.float32,0x3ebcc82c,0x3ec61c4f,2 +np.float32,0xbf24f492,0xbf43fd9a,2 +np.float32,0x3ecbd908,0x3ed7c691,2 +np.float32,0x3f461c5e,0x3f83d3f0,2 +np.float32,0x3eed0524,0x3f0043c1,2 +np.float32,0x3d06e840,0x3d06f4bf,2 +np.float32,0x3eb6c974,0x3ebf34d7,2 +np.float32,0xbf1c85e1,0xbf36100f,2 +np.float32,0x3ed697d0,0x3ee4ad04,2 +np.float32,0x3eab0484,0x3eb1d733,2 +np.float32,0xbf3b02f2,0xbf6e0935,2 +np.float32,0xbeeab154,0xbefd9334,2 +np.float32,0xbf695372,0xbfc49881,2 +np.float32,0x3e8aaa7c,0x3e8e36be,2 +np.float32,0xbf208754,0xbf3c8f7b,2 +np.float32,0xbe0dbf28,0xbe0ea9a1,2 +np.float32,0x3ca780c0,0x3ca786ba,2 +np.float32,0xbeb320b4,0xbebb065e,2 +np.float32,0x3f13c698,0x3f288821,2 +np.float32,0xbe8cbbec,0xbe9072c4,2 +np.float32,0x3f1ed534,0x3f39c8df,2 +np.float32,0x3e1ca450,0x3e1de190,2 +np.float32,0x3f54be1c,0x3f988134,2 +np.float32,0x3f34e4ee,0x3f6161b4,2 +np.float32,0xbf7e6913,0xc038b246,2 +np.float32,0x3d3c3f20,0x3d3c6119,2 +np.float32,0x3ca9dc80,0x3ca9e2bc,2 +np.float32,0xbf577ea2,0xbf9d161a,2 +np.float32,0xbedb22c8,0xbeea3644,2 +np.float32,0x3f22a044,0x3f400bfa,2 +np.float32,0xbe214b8c,0xbe22a637,2 +np.float32,0x3e8cd300,0x3e908bbc,2 +np.float32,0xbec4d214,0xbecf7a58,2 +np.float32,0x3e9399a4,0x3e97e7e4,2 +np.float32,0xbee6a1a2,0xbef874ed,2 +np.float32,0xbf323742,0xbf5c1bfd,2 +np.float32,0x3f48b882,0x3f8725ac,2 +np.float32,0xbf4d4dba,0xbf8d532e,2 +np.float32,0xbf59640a,0xbfa0695a,2 +np.float32,0xbf2ad562,0xbf4e4f03,2 +np.float32,0x3e317d98,0x3e334d03,2 +np.float32,0xbf6a5b71,0xbfc7b5a2,2 +np.float32,0x3e87b434,0x3e8b05cf,2 +np.float32,0xbf1c344c,0xbf358dee,2 +np.float32,0x3e449428,0x3e470c65,2 +np.float32,0xbf2c0f2f,0xbf508808,2 +np.float32,0xbec5b5ac,0xbed0859c,2 +np.float32,0xbf4aa956,0xbf89b4b1,2 +np.float32,0x3f6dd374,0x3fd35717,2 +np.float32,0x3f45f76c,0x3f83a5ef,2 +np.float32,0xbed1fba8,0xbedf1bd5,2 +np.float32,0xbd26b2d0,0xbd26ca66,2 +np.float32,0xbe9817c2,0xbe9cd1c3,2 +np.float32,0x3e725988,0x3e770875,2 +np.float32,0xbf1a8ded,0xbf32f132,2 +np.float32,0xbe695860,0xbe6d83d3,2 +np.float32,0x3d8cecd0,0x3d8d25ea,2 +np.float32,0x3f574706,0x3f9cb6ec,2 +np.float32,0xbf5c5a1f,0xbfa5eaf3,2 +np.float32,0x3e7a7c88,0x3e7fab83,2 +np.float32,0xff800000,0xffc00000,2 +np.float32,0x3f66396a,0x3fbbfbb0,2 +np.float32,0x3ed6e588,0x3ee50b53,2 +np.float32,0xbb56d500,0xbb56d532,2 +np.float32,0x3ebd23fc,0x3ec6869a,2 +np.float32,0xbf70d490,0xbfdf4af5,2 +np.float32,0x3e514f88,0x3e544d15,2 +np.float32,0x3e660f98,0x3e6a0dac,2 +np.float32,0xbf034da1,0xbf1110bb,2 +np.float32,0xbf60d9be,0xbfaf2714,2 +np.float32,0x3df67b10,0x3df7ae64,2 +np.float32,0xbeeedc0a,0xbf017010,2 +np.float32,0xbe149224,0xbe15a072,2 +np.float32,0x3f455084,0x3f82d759,2 +np.float32,0x3f210f9e,0x3f3d7093,2 +np.float32,0xbeaea3e0,0xbeb5edd3,2 +np.float32,0x3e0724b0,0x3e07efad,2 +np.float32,0x3f09a784,0x3f19d6ac,2 +np.float32,0xbf044340,0xbf125ee8,2 +np.float32,0xbf71adc9,0xbfe315fe,2 +np.float32,0x3efd3870,0x3f0ac6a8,2 +np.float32,0xbf53c7a6,0xbf96f6df,2 +np.float32,0xbf3cf784,0xbf7247af,2 +np.float32,0x3e0ce9e0,0x3e0dd035,2 +np.float32,0xbd3051a0,0xbd306d89,2 +np.float32,0x3ecab804,0x3ed66f77,2 +np.float32,0x3e984350,0x3e9d0189,2 +np.float32,0x3edd1c00,0x3eeca20b,2 +np.float32,0xbe8e22a0,0xbe91f71b,2 +np.float32,0x3ebebc18,0x3ec85fd6,2 +np.float32,0xba275c00,0xba275c01,2 +np.float32,0x3f1d8190,0x3f37a385,2 +np.float32,0x3f17343e,0x3f2dbbfe,2 +np.float32,0x3caa8000,0x3caa864e,2 +np.float32,0x3e7a7308,0x3e7fa168,2 +np.float32,0x3f7359a6,0x3feb3e1a,2 +np.float32,0xbf7ad15a,0xc012a743,2 +np.float32,0xbf122efb,0xbf262812,2 +np.float32,0xbf03ba04,0xbf11a3fa,2 +np.float32,0x3ed7a90c,0x3ee5f8d4,2 +np.float32,0xbe23e318,0xbe254eed,2 +np.float32,0xbe2866f4,0xbe29f20a,2 +np.float32,0xbeaedff2,0xbeb631d0,2 +np.float32,0x0,0x0,2 +np.float32,0x3ef2a034,0x3f03dafd,2 +np.float32,0x3f35806c,0x3f62994e,2 +np.float32,0xbf655e19,0xbfb9c718,2 +np.float32,0x3f5d54ce,0x3fa7d4f4,2 +np.float32,0x3f33e64a,0x3f5f67e3,2 +np.float32,0x3ebf4010,0x3ec8f923,2 +np.float32,0xbe050dc8,0xbe05cf70,2 +np.float32,0x3f61693e,0x3fb063b0,2 +np.float32,0xbd94ac00,0xbd94ef12,2 +np.float32,0x3e9de008,0x3ea32f61,2 +np.float32,0xbe3d042c,0xbe3f3540,2 +np.float32,0x3e8fdfc0,0x3e93d9e4,2 +np.float32,0x3f28bc48,0x3f4a9019,2 +np.float32,0x3edea928,0x3eee8b09,2 +np.float32,0xbf05f673,0xbf14b362,2 +np.float32,0xbf360730,0xbf63a914,2 +np.float32,0xbe3fb454,0xbe41fe0a,2 +np.float32,0x3f6d99a8,0x3fd28552,2 +np.float32,0xbf3ae866,0xbf6dd052,2 +np.float32,0x3f5b1164,0x3fa37aec,2 +np.float32,0xbf64a451,0xbfb7f61b,2 +np.float32,0xbdd79bd0,0xbdd86919,2 +np.float32,0x3e89fc00,0x3e8d7a85,2 +np.float32,0x3f4bf690,0x3f8b77ea,2 +np.float32,0x3cbdf280,0x3cbdfb38,2 +np.float32,0x3f138f98,0x3f2835b4,2 +np.float32,0xbe33967c,0xbe3576bc,2 +np.float32,0xbf298164,0xbf4bedda,2 +np.float32,0x3e9955cc,0x3e9e2edb,2 +np.float32,0xbf79b383,0xc00c56c0,2 +np.float32,0x3ea0834c,0x3ea61aea,2 +np.float32,0xbf511184,0xbf92c89a,2 +np.float32,0x3f4d9fba,0x3f8dc666,2 +np.float32,0x3f3387c2,0x3f5ead80,2 +np.float32,0x3e3f7360,0x3e41babb,2 +np.float32,0xbf3cc4d6,0xbf71d879,2 +np.float32,0x3f2e4402,0x3f54994e,2 +np.float32,0x3e6a7118,0x3e6eabff,2 +np.float32,0xbf05d83e,0xbf1489cc,2 +np.float32,0xbdce4fd8,0xbdcf039a,2 +np.float32,0xbf03e2f4,0xbf11dbaf,2 +np.float32,0x3f1ea0a0,0x3f397375,2 +np.float32,0x3f7aff54,0x4013cb1b,2 +np.float32,0x3f5ef158,0x3fab1801,2 +np.float32,0xbe33bcc8,0xbe359e40,2 +np.float32,0xbf04dd0e,0xbf133111,2 +np.float32,0xbf14f887,0xbf2a54d1,2 +np.float32,0x3f75c37a,0x3ff9196e,2 +np.float32,0x3f35c3c8,0x3f6320f2,2 +np.float32,0x3f53bb94,0x3f96e3c3,2 +np.float32,0x3f4d473e,0x3f8d4a19,2 +np.float32,0xbdfe19e0,0xbdff6ac9,2 +np.float32,0xbf7f0cc4,0xc049342d,2 +np.float32,0xbdbfc778,0xbdc057bb,2 +np.float32,0xbf7575b7,0xbff73067,2 +np.float32,0xbe9df488,0xbea34609,2 +np.float32,0xbefbd3c6,0xbf09daff,2 +np.float32,0x3f19962c,0x3f316cbd,2 +np.float32,0x3f7acec6,0x40129732,2 +np.float32,0xbf5db7de,0xbfa89a21,2 +np.float32,0x3f62f444,0x3fb3e830,2 +np.float32,0xbf522adb,0xbf94737f,2 +np.float32,0xbef6ceb2,0xbf0690ba,2 +np.float32,0xbf57c41e,0xbf9d8db0,2 +np.float32,0x3eb3360c,0x3ebb1eb0,2 +np.float32,0x3f29327e,0x3f4b618e,2 +np.float32,0xbf08d099,0xbf18a916,2 +np.float32,0x3ea21014,0x3ea7d369,2 +np.float32,0x3f39e516,0x3f6ba861,2 +np.float32,0x3e7c4f28,0x3e80ce08,2 +np.float32,0xbec5a7f8,0xbed07582,2 +np.float32,0xbf0b1b46,0xbf1be3e7,2 +np.float32,0xbef0e0ec,0xbf02bb2e,2 +np.float32,0x3d835a30,0x3d838869,2 +np.float32,0x3f08aa40,0x3f18736e,2 +np.float32,0x3eb0e4c8,0x3eb87bcd,2 +np.float32,0x3eb3821c,0x3ebb7564,2 +np.float32,0xbe3a7320,0xbe3c8d5a,2 +np.float32,0x3e43f8c0,0x3e466b10,2 +np.float32,0x3e914288,0x3e955b69,2 +np.float32,0x3ec7d800,0x3ed308e7,2 +np.float32,0x3e603df8,0x3e63eef2,2 +np.float32,0x3f225cac,0x3f3f9ac6,2 +np.float32,0x3e3db8f0,0x3e3ff06b,2 +np.float32,0x3f358d78,0x3f62b38c,2 +np.float32,0xbed9bd64,0xbee88158,2 +np.float32,0x800000,0x800000,2 +np.float32,0x3f1adfce,0x3f337230,2 +np.float32,0xbefdc346,0xbf0b229d,2 +np.float32,0xbf091018,0xbf190208,2 +np.float32,0xbf800000,0xff800000,2 +np.float32,0x3f27c2c4,0x3f48d8db,2 +np.float32,0x3ef59c80,0x3f05c993,2 +np.float32,0x3e18a340,0x3e19c893,2 +np.float32,0x3f209610,0x3f3ca7c5,2 +np.float32,0x3f69cc22,0x3fc60087,2 +np.float32,0xbf66cf07,0xbfbd8721,2 +np.float32,0xbf768098,0xbffdfcc4,2 +np.float32,0x3df27a40,0x3df39ec4,2 +np.float32,0x3daf5bd0,0x3dafca02,2 +np.float32,0x3f53f2be,0x3f973b41,2 +np.float32,0xbf7edcbc,0xc0436ce3,2 +np.float32,0xbdf61db8,0xbdf74fae,2 +np.float32,0x3e2c9328,0x3e2e3cb2,2 +np.float32,0x3f1a4570,0x3f327f41,2 +np.float32,0xbf766306,0xbffd32f1,2 +np.float32,0xbf468b9d,0xbf845f0f,2 +np.float32,0x3e398970,0x3e3b9bb1,2 +np.float32,0xbbefa900,0xbbefaa18,2 +np.float32,0xbf54c989,0xbf9893ad,2 +np.float32,0x3f262cf6,0x3f46169d,2 +np.float32,0x3f638a8a,0x3fb54a98,2 +np.float32,0xbeb36c78,0xbebb5cb8,2 +np.float32,0xbeac4d42,0xbeb34993,2 +np.float32,0x3f1d1942,0x3f36fbf2,2 +np.float32,0xbf5d49ba,0xbfa7bf07,2 +np.float32,0xbf182b5c,0xbf2f38d0,2 +np.float32,0x3f41a742,0x3f7ce5ef,2 +np.float32,0x3f0b9a6c,0x3f1c9898,2 +np.float32,0x3e847494,0x3e8788f3,2 +np.float32,0xbde41608,0xbde50941,2 +np.float32,0x3f693944,0x3fc44b5a,2 +np.float32,0x3f0386b2,0x3f115e37,2 +np.float32,0x3f3a08b0,0x3f6bf3c1,2 +np.float32,0xbf78ee64,0xc0089977,2 +np.float32,0xbf013a11,0xbf0e436e,2 +np.float32,0x3f00668e,0x3f0d2836,2 +np.float32,0x3e6d9850,0x3e720081,2 +np.float32,0x3eacf578,0x3eb4075d,2 +np.float32,0x3f18aef8,0x3f3004b4,2 +np.float32,0x3de342f0,0x3de43385,2 +np.float32,0x3e56cee8,0x3e5a0b85,2 +np.float32,0xbf287912,0xbf4a1966,2 +np.float32,0x3e92c948,0x3e9704c2,2 +np.float32,0x3c07d080,0x3c07d14c,2 +np.float32,0xbe90f6a0,0xbe9508e0,2 +np.float32,0x3e8b4f28,0x3e8ee884,2 +np.float32,0xbf35b56c,0xbf6303ff,2 +np.float32,0xbef512b8,0xbf057027,2 +np.float32,0x3e36c630,0x3e38c0cd,2 +np.float32,0x3f0b3ca8,0x3f1c134a,2 +np.float32,0x3e4cd610,0x3e4fa2c5,2 +np.float32,0xbf5a8372,0xbfa273a3,2 +np.float32,0xbecaad3c,0xbed662ae,2 +np.float32,0xbec372d2,0xbecddeac,2 +np.float32,0x3f6fb2b2,0x3fda8a22,2 +np.float32,0x3f365f28,0x3f645b5a,2 +np.float32,0xbecd00fa,0xbed926a4,2 +np.float32,0xbebafa32,0xbec40672,2 +np.float32,0xbf235b73,0xbf4146c4,2 +np.float32,0x3f7a4658,0x400f6e2c,2 +np.float32,0x3f35e824,0x3f636a54,2 +np.float32,0x3cb87640,0x3cb87e3c,2 +np.float32,0xbf296288,0xbf4bb6ee,2 +np.float32,0x7f800000,0xffc00000,2 +np.float32,0xbf4de86e,0xbf8e2d1a,2 +np.float32,0xbf4ace12,0xbf89e5f3,2 +np.float32,0x3d65a300,0x3d65e0b5,2 +np.float32,0xbe10c534,0xbe11bf21,2 +np.float32,0xbeba3c1c,0xbec32b3e,2 +np.float32,0x3e87eaf8,0x3e8b40b8,2 +np.float32,0x3d5c3bc0,0x3d5c722d,2 +np.float32,0x3e8c14b8,0x3e8fbdf8,2 +np.float32,0xbf06c6f0,0xbf15d327,2 +np.float32,0xbe0f1e30,0xbe100f96,2 +np.float32,0xbee244b0,0xbef30251,2 +np.float32,0x3f2a21b0,0x3f4d0c1d,2 +np.float32,0xbf5f7f81,0xbfac408e,2 +np.float32,0xbe3dba2c,0xbe3ff1b2,2 +np.float32,0x3f3ffc22,0x3f790abf,2 +np.float32,0x3edc3dac,0x3eeb90fd,2 +np.float32,0x7f7fffff,0xffc00000,2 +np.float32,0x3ecfaaac,0x3edc5485,2 +np.float32,0x3f0affbe,0x3f1bbcd9,2 +np.float32,0x3f5f2264,0x3fab7dca,2 +np.float32,0x3f37394c,0x3f66186c,2 +np.float32,0xbe6b2f6c,0xbe6f74e3,2 +np.float32,0x3f284772,0x3f49c1f1,2 +np.float32,0xbdf27bc8,0xbdf3a051,2 +np.float32,0xbc8b14e0,0xbc8b184c,2 +np.float32,0x3f6a867c,0x3fc83b07,2 +np.float32,0x3f1ec876,0x3f39b429,2 +np.float32,0x3f6fd9a8,0x3fdb28d6,2 +np.float32,0xbf473cca,0xbf853e8c,2 +np.float32,0x3e23eff8,0x3e255c23,2 +np.float32,0x3ebefdfc,0x3ec8ac5d,2 +np.float32,0x3f6c8c22,0x3fced2b1,2 +np.float32,0x3f168388,0x3f2cad44,2 +np.float32,0xbece2410,0xbeda81ac,2 +np.float32,0x3f5532f0,0x3f993eea,2 +np.float32,0x3ef1938c,0x3f032dfa,2 +np.float32,0xbef05268,0xbf025fba,2 +np.float32,0x3f552e4a,0x3f993754,2 +np.float32,0x3e9ed068,0x3ea4392d,2 +np.float32,0xbe1a0c24,0xbe1b39be,2 +np.float32,0xbf2623aa,0xbf46068c,2 +np.float32,0xbe1cc300,0xbe1e00fc,2 +np.float32,0xbe9c0576,0xbea12397,2 +np.float32,0xbd827338,0xbd82a07e,2 +np.float32,0x3f0fc31a,0x3f229786,2 +np.float32,0x3e577810,0x3e5abc7d,2 +np.float32,0x3e0e1cb8,0x3e0f0906,2 +np.float32,0x3e84d344,0x3e87ee73,2 +np.float32,0xbf39c45e,0xbf6b6337,2 +np.float32,0x3edfb25c,0x3eefd273,2 +np.float32,0x3e016398,0x3e021596,2 +np.float32,0xbefeb1be,0xbf0bc0de,2 +np.float32,0x3f37e104,0x3f677196,2 +np.float32,0x3f545316,0x3f97d500,2 +np.float32,0xbefc165a,0xbf0a06ed,2 +np.float32,0xbf0923e6,0xbf191dcd,2 +np.float32,0xbf386508,0xbf68831f,2 +np.float32,0xbf3d4630,0xbf72f4e1,2 +np.float32,0x3f3dbe82,0x3f73ff13,2 +np.float32,0xbf703de4,0xbfdcc7e2,2 +np.float32,0xbf531482,0xbf95dd1a,2 +np.float32,0xbf0af1b6,0xbf1ba8f4,2 +np.float32,0xbec8fd9c,0xbed463a4,2 +np.float32,0xbe230320,0xbe24691a,2 +np.float32,0xbf7de541,0xc02faf38,2 +np.float32,0x3efd2360,0x3f0ab8b7,2 +np.float32,0x3db7f350,0x3db87291,2 +np.float32,0x3e74c510,0x3e799924,2 +np.float32,0x3da549c0,0x3da5a5fc,2 +np.float32,0x3e8a3bc4,0x3e8dbf4a,2 +np.float32,0xbf69f086,0xbfc66e84,2 +np.float32,0x3f323f8e,0x3f5c2c17,2 +np.float32,0x3ec0ae3c,0x3ecaa334,2 +np.float32,0xbebe8966,0xbec824fc,2 +np.float32,0x3f34691e,0x3f606b13,2 +np.float32,0x3f13790e,0x3f2813f5,2 +np.float32,0xbf61c027,0xbfb12618,2 +np.float32,0x3e90c690,0x3e94d4a1,2 +np.float32,0xbefce8f0,0xbf0a920e,2 +np.float32,0xbf5c0e8a,0xbfa559a7,2 +np.float32,0x3f374f60,0x3f6645b6,2 +np.float32,0x3f25f6fa,0x3f45b967,2 +np.float32,0x3f2421aa,0x3f42963a,2 +np.float32,0x3ebfa328,0x3ec96c57,2 +np.float32,0x3e3bef28,0x3e3e1685,2 +np.float32,0x3ea3fa3c,0x3ea9f4dd,2 +np.float32,0x3f362b8e,0x3f63f2b2,2 +np.float32,0xbedcef18,0xbeec6ada,2 +np.float32,0xbdd29c88,0xbdd35bd0,2 +np.float32,0x3f261aea,0x3f45f76f,2 +np.float32,0xbe62c470,0xbe66965e,2 +np.float32,0x7fc00000,0x7fc00000,2 +np.float32,0xbee991aa,0xbefc277b,2 +np.float32,0xbf571960,0xbf9c6923,2 +np.float32,0xbe6fb410,0xbe743b41,2 +np.float32,0x3eb1bed0,0x3eb9738d,2 +np.float32,0x80000000,0x80000000,2 +np.float32,0x3eddcbe4,0x3eed7a69,2 +np.float32,0xbf2a81ba,0xbf4db86d,2 +np.float32,0x3f74da54,0x3ff38737,2 +np.float32,0xbeb6bff4,0xbebf29f4,2 +np.float32,0x3f445752,0x3f81a698,2 +np.float32,0x3ed081b4,0x3edd5618,2 +np.float32,0xbee73802,0xbef931b4,2 +np.float32,0xbd13f2a0,0xbd14031c,2 +np.float32,0xbb4d1200,0xbb4d122c,2 +np.float32,0xbee8777a,0xbefac393,2 +np.float32,0x3f42047c,0x3f7dc06c,2 +np.float32,0xbd089270,0xbd089f67,2 +np.float32,0xbf628c16,0xbfb2f66b,2 +np.float32,0x3e72e098,0x3e77978d,2 +np.float32,0x3ed967cc,0x3ee818e4,2 +np.float32,0x3e284c80,0x3e29d6d9,2 +np.float32,0x3f74e8ba,0x3ff3dbef,2 +np.float32,0x3f013e86,0x3f0e4969,2 +np.float32,0xbf610d4f,0xbfaf983c,2 +np.float32,0xbf3c8d36,0xbf715eba,2 +np.float32,0xbedbc756,0xbeeaffdb,2 +np.float32,0x3e143ec8,0x3e154b4c,2 +np.float32,0xbe1c9808,0xbe1dd4fc,2 +np.float32,0xbe887a1e,0xbe8bdac5,2 +np.float32,0xbe85c4bc,0xbe88f17a,2 +np.float32,0x3f35967e,0x3f62c5b4,2 +np.float32,0x3ea2c4a4,0x3ea89c2d,2 +np.float32,0xbc8703c0,0xbc8706e1,2 +np.float32,0xbf13d52c,0xbf289dff,2 +np.float32,0xbf63bb56,0xbfb5bf29,2 +np.float32,0xbf61c5ef,0xbfb13319,2 +np.float32,0xbf128410,0xbf26a675,2 +np.float32,0x3f03fcf2,0x3f11ff13,2 +np.float32,0xbe49c924,0xbe4c75cd,2 +np.float32,0xbf211a9c,0xbf3d82c5,2 +np.float32,0x3f7e9d52,0x403d1b42,2 +np.float32,0x3edfefd4,0x3ef01e71,2 +np.float32,0x3ebc5bd8,0x3ec59efb,2 +np.float32,0x3d7b02e0,0x3d7b537f,2 +np.float32,0xbf1163ba,0xbf24fb43,2 +np.float32,0x3f5072f2,0x3f91dbf1,2 +np.float32,0xbee700ce,0xbef8ec60,2 +np.float32,0x3f534168,0x3f962359,2 +np.float32,0x3e6d6c40,0x3e71d1ef,2 +np.float32,0x3def9d70,0x3df0b7a8,2 +np.float32,0x3e89cf80,0x3e8d4a8a,2 +np.float32,0xbf687ca7,0xbfc2290f,2 +np.float32,0x3f35e134,0x3f635c51,2 +np.float32,0x3e59eef8,0x3e5d50fa,2 +np.float32,0xbf65c9e1,0xbfbada61,2 +np.float32,0xbf759292,0xbff7e43d,2 +np.float32,0x3f4635a0,0x3f83f372,2 +np.float32,0x3f29baaa,0x3f4c53f1,2 +np.float32,0x3f6b15a6,0x3fc9fe04,2 +np.float32,0x3edabc88,0x3ee9b922,2 +np.float32,0x3ef382e0,0x3f046d4d,2 +np.float32,0xbe351310,0xbe36ff7f,2 +np.float32,0xbf05c935,0xbf14751c,2 +np.float32,0xbf0e7c50,0xbf20bc24,2 +np.float32,0xbf69bc94,0xbfc5d1b8,2 +np.float32,0xbed41aca,0xbee1aa23,2 +np.float32,0x3f518c08,0x3f938162,2 +np.float32,0xbf3d7974,0xbf73661a,2 +np.float32,0x3f1951a6,0x3f3101c9,2 +np.float32,0xbeb3f436,0xbebbf787,2 +np.float32,0xbf77a190,0xc0031d43,2 +np.float32,0x3eb5b3cc,0x3ebdf6e7,2 +np.float32,0xbed534b4,0xbee2fed2,2 +np.float32,0xbe53e1b8,0xbe56fc56,2 +np.float32,0x3f679e20,0x3fbfb91c,2 +np.float32,0xff7fffff,0xffc00000,2 +np.float32,0xbf7b9bcb,0xc0180073,2 +np.float32,0xbf5635e8,0xbf9aea15,2 +np.float32,0xbe5a3318,0xbe5d9856,2 +np.float32,0xbe003284,0xbe00df9a,2 +np.float32,0x3eb119a4,0x3eb8b7d6,2 +np.float32,0xbf3bccf8,0xbf6fbc84,2 +np.float32,0x3f36f600,0x3f658ea8,2 +np.float32,0x3f1ea834,0x3f397fc2,2 +np.float32,0xbe7cfb54,0xbe8129b3,2 +np.float32,0xbe9b3746,0xbea0406a,2 +np.float32,0x3edc0f90,0x3eeb586c,2 +np.float32,0x3e1842e8,0x3e19660c,2 +np.float32,0xbd8f10b0,0xbd8f4c70,2 +np.float32,0xbf064aca,0xbf1527a2,2 +np.float32,0x3e632e58,0x3e6705be,2 +np.float32,0xbef28ba4,0xbf03cdbb,2 +np.float32,0x3f27b21e,0x3f48bbaf,2 +np.float32,0xbe6f30d4,0xbe73b06e,2 +np.float32,0x3f3e6cb0,0x3f75834b,2 +np.float32,0xbf264aa5,0xbf4649f0,2 +np.float32,0xbf690775,0xbfc3b978,2 +np.float32,0xbf3e4a38,0xbf753632,2 +np.float64,0x3fe12bbe8c62577e,0x3fe32de8e5f961b0,1 +np.float64,0x3fc9b8909b337120,0x3fca1366da00efff,1 +np.float64,0x3feaee4245f5dc84,0x3ff3a011ea0432f3,1 +np.float64,0xbfe892c000f12580,0xbff03e5adaed6f0c,1 +np.float64,0xbf9be8de4837d1c0,0xbf9beaa367756bd1,1 +np.float64,0x3fe632e58fec65cc,0x3feb5ccc5114ca38,1 +np.float64,0x3fe78a0ef7ef141e,0x3fee1b4521d8eb6c,1 +np.float64,0x3feec27a65fd84f4,0x3fff643c8318e81e,1 +np.float64,0x3fbed6efce3dade0,0x3fbefd76cff00111,1 +np.float64,0xbfe3a05fab6740c0,0xbfe6db078aeeb0ca,1 +np.float64,0x3fdca11a56b94234,0x3fdece9e6eacff1b,1 +np.float64,0x3fe0fb15aae1f62c,0x3fe2e9e095ec2089,1 +np.float64,0x3fede12abf7bc256,0x3ffafd0ff4142807,1 +np.float64,0x3feb919edcf7233e,0x3ff4c9aa0bc2432f,1 +np.float64,0x3fd39633b5a72c68,0x3fd43c2e6d5f441c,1 +np.float64,0x3fd9efcbfeb3df98,0x3fdb83f03e58f91c,1 +np.float64,0x3fe2867a36650cf4,0x3fe525858c8ce72e,1 +np.float64,0x3fdacbb8f3b59770,0x3fdc8cd431b6e3ff,1 +np.float64,0x3fcc120503382408,0x3fcc88a8fa43e1c6,1 +np.float64,0xbfd99ff4eab33fea,0xbfdb24a20ae3687d,1 +np.float64,0xbfe8caf0157195e0,0xbff083b8dd0941d3,1 +np.float64,0x3fddc9bf92bb9380,0x3fe022aac0f761d5,1 +np.float64,0x3fe2dbb66e65b76c,0x3fe5a6e7caf3f1f2,1 +np.float64,0x3fe95f5c4a72beb8,0x3ff1444697e96138,1 +np.float64,0xbfc6b163d92d62c8,0xbfc6ef6e006658a1,1 +np.float64,0x3fdf1b2616be364c,0x3fe0fcbd2848c9e8,1 +np.float64,0xbfdca1ccf7b9439a,0xbfdecf7dc0eaa663,1 +np.float64,0x3fe078d6a260f1ae,0x3fe236a7c66ef6c2,1 +np.float64,0x3fdf471bb9be8e38,0x3fe11990ec74e704,1 +np.float64,0xbfe417626be82ec5,0xbfe79c9aa5ed2e2f,1 +np.float64,0xbfeb9cf5677739eb,0xbff4dfc24c012c90,1 +np.float64,0x3f8d9142b03b2280,0x3f8d91c9559d4779,1 +np.float64,0x3fb052c67220a590,0x3fb05873c90d1cd6,1 +np.float64,0x3fd742e2c7ae85c4,0x3fd860128947d15d,1 +np.float64,0x3fec2e2a2bf85c54,0x3ff60eb554bb8d71,1 +np.float64,0xbfeb2b8bc8f65718,0xbff40b734679497a,1 +np.float64,0x3fe25f8e0d64bf1c,0x3fe4eb381d077803,1 +np.float64,0x3fe56426256ac84c,0x3fe9dafbe79370f0,1 +np.float64,0x3feecc1e5d7d983c,0x3fffa49bedc7aa25,1 +np.float64,0xbfc88ce94b3119d4,0xbfc8dbba0fdee2d2,1 +np.float64,0xbfabcf51ac379ea0,0xbfabd6552aa63da3,1 +np.float64,0xbfccc8b849399170,0xbfcd48d6ff057a4d,1 +np.float64,0x3fd2f831e8a5f064,0x3fd38e67b0dda905,1 +np.float64,0x3fcafdcd6135fb98,0x3fcb670ae2ef4d36,1 +np.float64,0x3feda6042efb4c08,0x3ffa219442ac4ea5,1 +np.float64,0x3fed382b157a7056,0x3ff8bc01bc6d10bc,1 +np.float64,0x3fed858a50fb0b14,0x3ff9b1c05cb6cc0f,1 +np.float64,0x3fcc3960653872c0,0x3fccb2045373a3d1,1 +np.float64,0xbfec5177e478a2f0,0xbff65eb4557d94eb,1 +np.float64,0x3feafe0d5e75fc1a,0x3ff3bb4a260a0dcb,1 +np.float64,0x3fe08bc87ee11790,0x3fe25078aac99d31,1 +np.float64,0xffefffffffffffff,0xfff8000000000000,1 +np.float64,0x3f79985ce0333100,0x3f799872b591d1cb,1 +np.float64,0xbfd4001cf9a8003a,0xbfd4b14b9035b94f,1 +np.float64,0x3fe54a17e6ea9430,0x3fe9ac0f18682343,1 +np.float64,0xbfb4e07fea29c100,0xbfb4ec6520dd0689,1 +np.float64,0xbfed2b6659fa56cd,0xbff895ed57dc1450,1 +np.float64,0xbfe81fc8b5f03f92,0xbfef6b95e72a7a7c,1 +np.float64,0xbfe6aced16ed59da,0xbfec4ce131ee3704,1 +np.float64,0xbfe599f30ceb33e6,0xbfea3d07c1cd78e2,1 +np.float64,0xbfe0ff278b61fe4f,0xbfe2ef8b5efa89ed,1 +np.float64,0xbfe3e9406467d281,0xbfe750e43e841736,1 +np.float64,0x3fcc6b52cf38d6a8,0x3fcce688f4fb2cf1,1 +np.float64,0xbfc890e8133121d0,0xbfc8dfdfee72d258,1 +np.float64,0x3fe46e81dbe8dd04,0x3fe82e09783811a8,1 +np.float64,0x3fd94455e5b288ac,0x3fdab7cef2de0b1f,1 +np.float64,0xbfe82151fff042a4,0xbfef6f254c9696ca,1 +np.float64,0x3fcee1ac1d3dc358,0x3fcf80a6ed07070a,1 +np.float64,0x3fcce8f90939d1f0,0x3fcd6ad18d34f8b5,1 +np.float64,0x3fd6afe56fad5fcc,0x3fd7b7567526b1fb,1 +np.float64,0x3fb1a77092234ee0,0x3fb1ae9fe0d176fc,1 +np.float64,0xbfeb758b0d76eb16,0xbff493d105652edc,1 +np.float64,0xbfb857c24e30af88,0xbfb86aa4da3be53f,1 +np.float64,0x3fe89064eff120ca,0x3ff03b7c5b3339a8,1 +np.float64,0xbfc1bd2fef237a60,0xbfc1da99893473ed,1 +np.float64,0xbfe5ad6e2eeb5adc,0xbfea60ed181b5c05,1 +np.float64,0x3fd5a66358ab4cc8,0x3fd6899e640aeb1f,1 +np.float64,0xbfe198e832e331d0,0xbfe3c8c9496d0de5,1 +np.float64,0xbfdaa5c0d7b54b82,0xbfdc5ed7d3c5ce49,1 +np.float64,0x3fcceccb6939d998,0x3fcd6ed88c2dd3a5,1 +np.float64,0xbfe44413eae88828,0xbfe7e6cd32b34046,1 +np.float64,0xbfc7cbeccf2f97d8,0xbfc8139a2626edae,1 +np.float64,0x3fbf31e4fa3e63d0,0x3fbf59c6e863255e,1 +np.float64,0x3fdf03fa05be07f4,0x3fe0ed953f7989ad,1 +np.float64,0x3fe7f4eaceefe9d6,0x3fef092ca7e2ac39,1 +np.float64,0xbfc084e9d92109d4,0xbfc09ca10fd6aaea,1 +np.float64,0xbf88cfbf70319f80,0xbf88d00effa6d897,1 +np.float64,0x7ff4000000000000,0x7ffc000000000000,1 +np.float64,0xbfa0176e9c202ee0,0xbfa018ca0a6ceef3,1 +np.float64,0xbfd88d0815b11a10,0xbfd9dfc6c6bcbe4e,1 +np.float64,0x3fe89f7730713eee,0x3ff04de52fb536f3,1 +np.float64,0xbfedc9707bfb92e1,0xbffaa25fcf9dd6da,1 +np.float64,0x3fe936d1a6726da4,0x3ff10e40c2d94bc9,1 +np.float64,0x3fdb64aec7b6c95c,0x3fdd473177317b3f,1 +np.float64,0xbfee4f9aaefc9f35,0xbffcdd212667003c,1 +np.float64,0x3fe3730067e6e600,0x3fe692b0a0babf5f,1 +np.float64,0xbfc257e58924afcc,0xbfc27871f8c218d7,1 +np.float64,0x3fe62db12dec5b62,0x3feb52c61b97d9f6,1 +np.float64,0xbfe3ff491367fe92,0xbfe774f1b3a96fd6,1 +np.float64,0x3fea43255274864a,0x3ff28b0c4b7b8d21,1 +np.float64,0xbfea37923c746f24,0xbff27962159f2072,1 +np.float64,0x3fcd0ac3c73a1588,0x3fcd8e6f8de41755,1 +np.float64,0xbfdccafde6b995fc,0xbfdf030fea8a0630,1 +np.float64,0x3fdba35268b746a4,0x3fdd94094f6f50c1,1 +np.float64,0x3fc68ea1d92d1d40,0x3fc6cb8d07cbb0e4,1 +np.float64,0xbfb88b1f6e311640,0xbfb89e7af4e58778,1 +np.float64,0xbfedc7cadffb8f96,0xbffa9c3766227956,1 +np.float64,0x3fe7928d3eef251a,0x3fee2dcf2ac7961b,1 +np.float64,0xbfeff42ede7fe85e,0xc00cef6b0f1e8323,1 +np.float64,0xbfebf07fa477e0ff,0xbff5893f99e15236,1 +np.float64,0x3fe3002ab9660056,0x3fe5defba550c583,1 +np.float64,0x3feb8f4307f71e86,0x3ff4c517ec8d6de9,1 +np.float64,0x3fd3c16f49a782e0,0x3fd46becaacf74da,1 +np.float64,0x3fc7613df12ec278,0x3fc7a52b2a3c3368,1 +np.float64,0xbfe33af560e675eb,0xbfe63a6528ff1587,1 +np.float64,0xbfde86495abd0c92,0xbfe09bd7ba05b461,1 +np.float64,0x3fe1e7fb4ee3cff6,0x3fe43b04311c0ab6,1 +np.float64,0xbfc528b6bd2a516c,0xbfc55ae0a0c184c8,1 +np.float64,0xbfd81025beb0204c,0xbfd94dd72d804613,1 +np.float64,0x10000000000000,0x10000000000000,1 +np.float64,0x3fc1151c47222a38,0x3fc12f5aad80a6bf,1 +np.float64,0x3feafa136775f426,0x3ff3b46854da0b3a,1 +np.float64,0x3fed2da0747a5b40,0x3ff89c85b658459e,1 +np.float64,0x3fda2a4b51b45498,0x3fdbca0d908ddbbd,1 +np.float64,0xbfd04cf518a099ea,0xbfd0aae0033b9e4c,1 +np.float64,0xbfb9065586320ca8,0xbfb91adb7e31f322,1 +np.float64,0xbfd830b428b06168,0xbfd973ca3c484d8d,1 +np.float64,0x3fc952f7ed32a5f0,0x3fc9a9994561fc1a,1 +np.float64,0xbfeb06c83c760d90,0xbff3ca77b326df20,1 +np.float64,0xbfeb1c98ac763931,0xbff3f0d0900f6149,1 +np.float64,0x3fdf061dbebe0c3c,0x3fe0eefb32b48d17,1 +np.float64,0xbf9acbaf28359760,0xbf9acd4024be9fec,1 +np.float64,0x3fec0adde2f815bc,0x3ff5c1628423794d,1 +np.float64,0xbfc4bc750d2978ec,0xbfc4eba43f590b94,1 +np.float64,0x3fdbe47878b7c8f0,0x3fdde44a2b500d73,1 +np.float64,0x3fe160d18162c1a4,0x3fe378cff08f18f0,1 +np.float64,0x3fc3b58dfd276b18,0x3fc3de01d3802de9,1 +np.float64,0x3fa860343430c060,0x3fa864ecd07ec962,1 +np.float64,0x3fcaebfb4b35d7f8,0x3fcb546512d1b4c7,1 +np.float64,0x3fe3fda558e7fb4a,0x3fe772412e5776de,1 +np.float64,0xbfe8169f2c702d3e,0xbfef5666c9a10f6d,1 +np.float64,0x3feda78e9efb4f1e,0x3ffa270712ded769,1 +np.float64,0xbfda483161b49062,0xbfdbedfbf2e850ba,1 +np.float64,0x3fd7407cf3ae80f8,0x3fd85d4f52622743,1 +np.float64,0xbfd63de4d4ac7bca,0xbfd73550a33e3c32,1 +np.float64,0xbfd9c30b90b38618,0xbfdb4e7695c856f3,1 +np.float64,0x3fcd70c00b3ae180,0x3fcdfa0969e0a119,1 +np.float64,0x3feb4f127f769e24,0x3ff44bf42514e0f4,1 +np.float64,0xbfec1db44af83b69,0xbff5ea54aed1f8e9,1 +np.float64,0x3fd68ff051ad1fe0,0x3fd792d0ed6d6122,1 +np.float64,0x3fe0a048a5614092,0x3fe26c80a826b2a2,1 +np.float64,0x3fd59f3742ab3e70,0x3fd6818563fcaf80,1 +np.float64,0x3fca26ecf9344dd8,0x3fca867ceb5d7ba8,1 +np.float64,0x3fdc1d547ab83aa8,0x3fde2a9cea866484,1 +np.float64,0xbfc78df6312f1bec,0xbfc7d3719b698a39,1 +np.float64,0x3fe754e72b6ea9ce,0x3feda89ea844a2e5,1 +np.float64,0x3fe740c1a4ee8184,0x3fed7dc56ec0c425,1 +np.float64,0x3fe77566a9eeeace,0x3fedee6f408df6de,1 +np.float64,0xbfbbf5bf8e37eb80,0xbfbc126a223781b4,1 +np.float64,0xbfe0acb297615965,0xbfe27d86681ca2b5,1 +np.float64,0xbfc20a0487241408,0xbfc228f5f7d52ce8,1 +np.float64,0xfff0000000000000,0xfff8000000000000,1 +np.float64,0x3fef98a4dbff314a,0x40043cfb60bd46fa,1 +np.float64,0x3fd059102ca0b220,0x3fd0b7d2be6d7822,1 +np.float64,0x3fe89f18a1f13e32,0x3ff04d714bbbf400,1 +np.float64,0x3fd45b6275a8b6c4,0x3fd516a44a276a4b,1 +np.float64,0xbfe04463e86088c8,0xbfe1ef9dfc9f9a53,1 +np.float64,0xbfe086e279610dc5,0xbfe249c9c1040a13,1 +np.float64,0x3f89c9b110339380,0x3f89ca0a641454b5,1 +np.float64,0xbfb5f5b4322beb68,0xbfb6038dc3fd1516,1 +np.float64,0x3fe6eae76f6dd5ce,0x3feccabae04d5c14,1 +np.float64,0x3fa9ef6c9c33dee0,0x3fa9f51c9a8c8a2f,1 +np.float64,0xbfe171b45f62e368,0xbfe390ccc4c01bf6,1 +np.float64,0x3fb2999442253330,0x3fb2a1fc006804b5,1 +np.float64,0x3fd124bf04a24980,0x3fd1927abb92472d,1 +np.float64,0xbfe6e05938edc0b2,0xbfecb519ba78114f,1 +np.float64,0x3fed466ee6fa8cde,0x3ff8e75405b50490,1 +np.float64,0xbfb999aa92333358,0xbfb9afa4f19f80a2,1 +np.float64,0xbfe98969ed7312d4,0xbff17d887b0303e7,1 +np.float64,0x3fe782843e6f0508,0x3fee0adbeebe3486,1 +np.float64,0xbfe232fcc26465fa,0xbfe4a90a68d46040,1 +np.float64,0x3fd190a90fa32154,0x3fd206f56ffcdca2,1 +np.float64,0xbfc4f8b75929f170,0xbfc5298b2d4e7740,1 +np.float64,0xbfba3a63d63474c8,0xbfba520835c2fdc2,1 +np.float64,0xbfb7708eea2ee120,0xbfb781695ec17846,1 +np.float64,0x3fed9fb7a5fb3f70,0x3ffa0b717bcd1609,1 +np.float64,0xbfc1b158cd2362b0,0xbfc1ce87345f3473,1 +np.float64,0x3f963478082c6900,0x3f96355c3000953b,1 +np.float64,0x3fc5050e532a0a20,0x3fc536397f38f616,1 +np.float64,0x3fe239f9eee473f4,0x3fe4b360da3b2faa,1 +np.float64,0xbfd66bd80eacd7b0,0xbfd769a29fd784c0,1 +np.float64,0x3fc57cdad52af9b8,0x3fc5b16b937f5f72,1 +np.float64,0xbfd3c36a0aa786d4,0xbfd46e1cd0b4eddc,1 +np.float64,0x3feff433487fe866,0x400cf0ea1def3161,1 +np.float64,0xbfed5577807aaaef,0xbff915e8f6bfdf22,1 +np.float64,0xbfca0dd3eb341ba8,0xbfca6c4d11836cb6,1 +np.float64,0x7ff8000000000000,0x7ff8000000000000,1 +np.float64,0xbf974deaa82e9be0,0xbf974ef26a3130d1,1 +np.float64,0xbfe7f425e1efe84c,0xbfef076cb00d649d,1 +np.float64,0xbfe4413605e8826c,0xbfe7e20448b8a4b1,1 +np.float64,0xbfdfad202cbf5a40,0xbfe15cd9eb2be707,1 +np.float64,0xbfe43261ee6864c4,0xbfe7c952c951fe33,1 +np.float64,0xbfec141225782824,0xbff5d54d33861d98,1 +np.float64,0x3fd0f47abaa1e8f4,0x3fd15e8691a7f1c2,1 +np.float64,0x3fd378f0baa6f1e0,0x3fd41bea4a599081,1 +np.float64,0xbfb52523462a4a48,0xbfb5317fa7f436e2,1 +np.float64,0x3fcb30797d3660f0,0x3fcb9c174ea401ff,1 +np.float64,0xbfd48480dea90902,0xbfd5446e02c8b329,1 +np.float64,0xbfee4ae3ab7c95c7,0xbffcc650340ba274,1 +np.float64,0xbfeab086d075610e,0xbff3387f4e83ae26,1 +np.float64,0x3fa17cddf422f9c0,0x3fa17e9bf1b25736,1 +np.float64,0xbfe3064536e60c8a,0xbfe5e86aa5244319,1 +np.float64,0x3feb2882c5765106,0x3ff40604c7d97d44,1 +np.float64,0xbfa6923ff42d2480,0xbfa695ff57b2fc3f,1 +np.float64,0xbfa8bdbdcc317b80,0xbfa8c2ada0d94aa7,1 +np.float64,0x3fe7f16b8e6fe2d8,0x3fef013948c391a6,1 +np.float64,0x3fe4e7169f69ce2e,0x3fe8fceef835050a,1 +np.float64,0x3fed877638fb0eec,0x3ff9b83694127959,1 +np.float64,0xbfe0cc9ecf61993e,0xbfe2a978234cbde5,1 +np.float64,0xbfe977e79672efcf,0xbff16589ea494a38,1 +np.float64,0xbfe240130ae48026,0xbfe4bc69113e0d7f,1 +np.float64,0x3feb1e9b70763d36,0x3ff3f4615938a491,1 +np.float64,0xbfdf197dfcbe32fc,0xbfe0fba78a0fc816,1 +np.float64,0xbfee0f8543fc1f0a,0xbffbb9d9a4ee5387,1 +np.float64,0x3fe88d2191f11a44,0x3ff037843b5b6313,1 +np.float64,0xbfd11bb850a23770,0xbfd188c1cef40007,1 +np.float64,0xbfa1b36e9c2366e0,0xbfa1b53d1d8a8bc4,1 +np.float64,0xbfea2d70d9f45ae2,0xbff26a0629e36b3e,1 +np.float64,0xbfd9188703b2310e,0xbfda83f9ddc18348,1 +np.float64,0xbfee194894fc3291,0xbffbe3c83b61e7cb,1 +np.float64,0xbfe093b4a9e1276a,0xbfe25b4ad6f8f83d,1 +np.float64,0x3fea031489f4062a,0x3ff22accc000082e,1 +np.float64,0xbfc6c0827b2d8104,0xbfc6ff0a94326381,1 +np.float64,0x3fef5cd340feb9a6,0x4002659c5a1b34af,1 +np.float64,0x8010000000000000,0x8010000000000000,1 +np.float64,0x3fd97cb533b2f96c,0x3fdafab28aaae8e3,1 +np.float64,0x3fe2123334642466,0x3fe478bd83a8ce02,1 +np.float64,0xbfd9a69637b34d2c,0xbfdb2c87c6b6fb8c,1 +np.float64,0x3fc58def7f2b1be0,0x3fc5c2ff724a9f61,1 +np.float64,0xbfedd5da1f7babb4,0xbffad15949b7fb22,1 +np.float64,0x3fe90e92a0721d26,0x3ff0d9b64323efb8,1 +np.float64,0x3fd34b9442a69728,0x3fd3e9f8fe80654e,1 +np.float64,0xbfc5f509ab2bea14,0xbfc62d2ad325c59f,1 +np.float64,0x3feb245634f648ac,0x3ff3fe91a46acbe1,1 +np.float64,0x3fd101e539a203cc,0x3fd16cf52ae6d203,1 +np.float64,0xbfc51e9ba72a3d38,0xbfc5507d00521ba3,1 +np.float64,0x3fe5fe1683ebfc2e,0x3feaf7dd8b1f92b0,1 +np.float64,0x3fc362e59126c5c8,0x3fc389601814170b,1 +np.float64,0x3fea34dbd77469b8,0x3ff27542eb721e7e,1 +np.float64,0xbfc13ed241227da4,0xbfc159d42c0a35a9,1 +np.float64,0xbfe6df118cedbe23,0xbfecb27bb5d3f784,1 +np.float64,0x3fd92895f6b2512c,0x3fda96f5f94b625e,1 +np.float64,0xbfe7ea3aa76fd476,0xbfeef0e93939086e,1 +np.float64,0xbfc855498330aa94,0xbfc8a1ff690c9533,1 +np.float64,0x3fd9f27b3ab3e4f8,0x3fdb8726979afc3b,1 +np.float64,0x3fc65d52232cbaa8,0x3fc698ac4367afba,1 +np.float64,0x3fd1271dd0a24e3c,0x3fd195087649d54e,1 +np.float64,0xbfe983445df30689,0xbff175158b773b90,1 +np.float64,0xbfe0d9b13261b362,0xbfe2bb8908fc9e6e,1 +np.float64,0x3fd7671f2aaece40,0x3fd889dccbf21629,1 +np.float64,0x3fe748aebfee915e,0x3fed8e970d94c17d,1 +np.float64,0x3fea756e4e74eadc,0x3ff2d947ef3a54f4,1 +np.float64,0x3fde22311cbc4464,0x3fe05b4ce9df1fdd,1 +np.float64,0x3fe2b55ec1e56abe,0x3fe56c6849e3985a,1 +np.float64,0x3fed7b47437af68e,0x3ff98f8e82de99a0,1 +np.float64,0x3fec8184b179030a,0x3ff6d03aaf0135ba,1 +np.float64,0x3fc9ea825533d508,0x3fca4776d7190e71,1 +np.float64,0xbfe8ddd58b71bbab,0xbff09b770ed7bc9a,1 +np.float64,0xbfed41741bfa82e8,0xbff8d81c2a9fc615,1 +np.float64,0x3fe0a73888e14e72,0x3fe27602ad9a3726,1 +np.float64,0xbfe9d0a565f3a14b,0xbff1e1897b628f66,1 +np.float64,0x3fda12b381b42568,0x3fdbadbec22fbd5a,1 +np.float64,0x3fef0081187e0102,0x4000949eff8313c2,1 +np.float64,0x3fef6942b67ed286,0x4002b7913eb1ee76,1 +np.float64,0x3fda10f882b421f0,0x3fdbababa2d6659d,1 +np.float64,0x3fe5828971eb0512,0x3fea122b5088315a,1 +np.float64,0x3fe9d4b53ff3a96a,0x3ff1e75c148bda01,1 +np.float64,0x3fe95d246bf2ba48,0x3ff1414a61a136ec,1 +np.float64,0x3f9e575eb83caec0,0x3f9e59a4f17179e3,1 +np.float64,0x3fdb0a20b5b61440,0x3fdcd8a56178a17f,1 +np.float64,0xbfdef425e3bde84c,0xbfe0e33eeacf3861,1 +np.float64,0x3fd6afcf6bad5fa0,0x3fd7b73d47288347,1 +np.float64,0x3fe89256367124ac,0x3ff03dd9f36ce40e,1 +np.float64,0x3fe7e560fcefcac2,0x3feee5ef8688b60b,1 +np.float64,0x3fedef55e1fbdeac,0x3ffb350ee1df986b,1 +np.float64,0xbfe44b926de89725,0xbfe7f3539910c41f,1 +np.float64,0x3fc58310f32b0620,0x3fc5b7cfdba15bd0,1 +np.float64,0x3f736d256026da00,0x3f736d2eebe91a90,1 +np.float64,0x3feb012d2076025a,0x3ff3c0b5d21a7259,1 +np.float64,0xbfe466a6c468cd4e,0xbfe820c9c197601f,1 +np.float64,0x3fe1aba8aa635752,0x3fe3e3b73920f64c,1 +np.float64,0x3fe5597c336ab2f8,0x3fe9c7bc4b765b15,1 +np.float64,0x3fe1004ac5e20096,0x3fe2f12116e99821,1 +np.float64,0x3fecbc67477978ce,0x3ff76377434dbdad,1 +np.float64,0x3fe0e64515e1cc8a,0x3fe2ccf5447c1579,1 +np.float64,0x3febcfa874f79f50,0x3ff54528f0822144,1 +np.float64,0x3fc36915ed26d228,0x3fc38fb5b28d3f72,1 +np.float64,0xbfe01213e5e02428,0xbfe1ac0e1e7418f1,1 +np.float64,0x3fcd97875b3b2f10,0x3fce22fe3fc98702,1 +np.float64,0xbfe30383c5e60708,0xbfe5e427e62cc957,1 +np.float64,0xbfde339bf9bc6738,0xbfe0667f337924f5,1 +np.float64,0xbfda7c1c49b4f838,0xbfdc2c8801ce654a,1 +np.float64,0x3fb6b3489e2d6690,0x3fb6c29650387b92,1 +np.float64,0xbfe1fd4d76e3fa9b,0xbfe45a1f60077678,1 +np.float64,0xbf67c5e0402f8c00,0xbf67c5e49fce115a,1 +np.float64,0xbfd4f9aa2da9f354,0xbfd5c759603d0b9b,1 +np.float64,0x3fe83c227bf07844,0x3fefada9f1bd7fa9,1 +np.float64,0xbf97f717982fee20,0xbf97f836701a8cd5,1 +np.float64,0x3fe9688a2472d114,0x3ff150aa575e7d51,1 +np.float64,0xbfc5a9779d2b52f0,0xbfc5df56509c48b1,1 +np.float64,0xbfe958d5f472b1ac,0xbff13b813f9bee20,1 +np.float64,0xbfd7b3b944af6772,0xbfd8e276c2b2920f,1 +np.float64,0x3fed10198e7a2034,0x3ff8469c817572f0,1 +np.float64,0xbfeeecc4517dd989,0xc000472b1f858be3,1 +np.float64,0xbfdbcce47eb799c8,0xbfddc734aa67812b,1 +np.float64,0xbfd013ee24a027dc,0xbfd06df3089384ca,1 +np.float64,0xbfd215f2bfa42be6,0xbfd29774ffe26a74,1 +np.float64,0x3fdfd0ae67bfa15c,0x3fe1746e3a963a9f,1 +np.float64,0xbfc84aa10b309544,0xbfc896f0d25b723a,1 +np.float64,0xbfcd0c627d3a18c4,0xbfcd9024c73747a9,1 +np.float64,0x3fd87df6dbb0fbec,0x3fd9ce1dde757f31,1 +np.float64,0xbfdad85e05b5b0bc,0xbfdc9c2addb6ce47,1 +np.float64,0xbfee4f8977fc9f13,0xbffcdccd68e514b3,1 +np.float64,0x3fa5c290542b8520,0x3fa5c5ebdf09ca70,1 +np.float64,0xbfd7e401d2afc804,0xbfd91a7e4eb5a026,1 +np.float64,0xbfe33ff73b667fee,0xbfe6423cc6eb07d7,1 +np.float64,0x3fdfb7d6c4bf6fac,0x3fe163f2e8175177,1 +np.float64,0xbfd515d69eaa2bae,0xbfd5e6eedd6a1598,1 +np.float64,0x3fb322232e264440,0x3fb32b49d91c3cbe,1 +np.float64,0xbfe20ac39e641587,0xbfe46dd4b3803f19,1 +np.float64,0x3fe282dc18e505b8,0x3fe520152120c297,1 +np.float64,0xbfc905a4cd320b48,0xbfc95929b74865fb,1 +np.float64,0x3fe0ae3b83615c78,0x3fe27fa1dafc825b,1 +np.float64,0xbfc1bfed0f237fdc,0xbfc1dd6466225cdf,1 +np.float64,0xbfeca4d47d7949a9,0xbff72761a34fb682,1 +np.float64,0xbfe8cf8c48f19f18,0xbff0897ebc003626,1 +np.float64,0xbfe1aaf0a36355e2,0xbfe3e2ae7b17a286,1 +np.float64,0x3fe2ca442e659488,0x3fe58c3a2fb4f14a,1 +np.float64,0xbfda3c2deeb4785c,0xbfdbdf89fe96a243,1 +np.float64,0xbfdc12bfecb82580,0xbfde1d81dea3c221,1 +np.float64,0xbfe2d6d877e5adb1,0xbfe59f73e22c1fc7,1 +np.float64,0x3fe5f930636bf260,0x3feaee96a462e4de,1 +np.float64,0x3fcf3c0ea53e7820,0x3fcfe0b0f92be7e9,1 +np.float64,0xbfa5bb90f42b7720,0xbfa5bee9424004cc,1 +np.float64,0xbfe2fb3a3265f674,0xbfe5d75b988bb279,1 +np.float64,0x3fcaec7aab35d8f8,0x3fcb54ea582fff6f,1 +np.float64,0xbfd8d3228db1a646,0xbfda322297747fbc,1 +np.float64,0x3fedd2e0ad7ba5c2,0x3ffac6002b65c424,1 +np.float64,0xbfd9edeca2b3dbda,0xbfdb81b2b7785e33,1 +np.float64,0xbfef5febb17ebfd7,0xc002796b15950960,1 +np.float64,0x3fde22f787bc45f0,0x3fe05bcc624b9ba2,1 +np.float64,0xbfc716a4ab2e2d48,0xbfc758073839dd44,1 +np.float64,0xbf9bed852837db00,0xbf9bef4b2a3f3bdc,1 +np.float64,0x3fef8f88507f1f10,0x4003e5e566444571,1 +np.float64,0xbfdc1bbed6b8377e,0xbfde28a64e174e60,1 +np.float64,0x3fe02d30eae05a62,0x3fe1d064ec027cd3,1 +np.float64,0x3fd9dbb500b3b76c,0x3fdb6bea40162279,1 +np.float64,0x3fe353ff1d66a7fe,0x3fe661b3358c925e,1 +np.float64,0x3fac3ebfb4387d80,0x3fac4618effff2b0,1 +np.float64,0x3fe63cf0ba6c79e2,0x3feb7030cff5f434,1 +np.float64,0x3fd0e915f8a1d22c,0x3fd152464597b510,1 +np.float64,0xbfd36987cda6d310,0xbfd40af049d7621e,1 +np.float64,0xbfdc5b4dc7b8b69c,0xbfde7790a35da2bc,1 +np.float64,0x3feee7ff4a7dcffe,0x40003545989e07c7,1 +np.float64,0xbfeb2c8308765906,0xbff40d2e6469249e,1 +np.float64,0x3fe535a894ea6b52,0x3fe98781648550d0,1 +np.float64,0xbfef168eb9fe2d1d,0xc000f274ed3cd312,1 +np.float64,0x3fc3e2d98927c5b0,0x3fc40c6991b8900c,1 +np.float64,0xbfcd8fe3e73b1fc8,0xbfce1aec7f9b7f7d,1 +np.float64,0xbfd55d8c3aaabb18,0xbfd6378132ee4892,1 +np.float64,0xbfe424a66168494d,0xbfe7b289d72c98b3,1 +np.float64,0x3fd81af13eb035e4,0x3fd95a6a9696ab45,1 +np.float64,0xbfe3016722e602ce,0xbfe5e0e46db228cd,1 +np.float64,0x3fe9a20beff34418,0x3ff19faca17fc468,1 +np.float64,0xbfe2124bc7e42498,0xbfe478e19927e723,1 +np.float64,0x3fd96f8622b2df0c,0x3fdaeb08da6b08ae,1 +np.float64,0x3fecd6796579acf2,0x3ff7a7d02159e181,1 +np.float64,0x3fe60015df6c002c,0x3feafba6f2682a61,1 +np.float64,0x3fc7181cf72e3038,0x3fc7598c2cc3c3b4,1 +np.float64,0xbfce6e2e0b3cdc5c,0xbfcf0621b3e37115,1 +np.float64,0xbfe52a829e6a5505,0xbfe973a785980af9,1 +np.float64,0x3fed4bbac37a9776,0x3ff8f7a0e68a2bbe,1 +np.float64,0x3fabdfaacc37bf60,0x3fabe6bab42bd246,1 +np.float64,0xbfcd9598cb3b2b30,0xbfce20f3c4c2c261,1 +np.float64,0x3fd717d859ae2fb0,0x3fd82e88eca09ab1,1 +np.float64,0x3fe28ccb18e51996,0x3fe52f071d2694fd,1 +np.float64,0xbfe43f064ae87e0c,0xbfe7de5eab36b5b9,1 +np.float64,0x7fefffffffffffff,0xfff8000000000000,1 +np.float64,0xbfb39b045a273608,0xbfb3a4dd3395fdd5,1 +np.float64,0xbfb3358bae266b18,0xbfb33ece5e95970a,1 +np.float64,0xbfeeafb6717d5f6d,0xbffeec3f9695b575,1 +np.float64,0xbfe7a321afef4644,0xbfee522dd80f41f4,1 +np.float64,0x3fe3a17e5be742fc,0x3fe6dcd32af51e92,1 +np.float64,0xbfc61694bd2c2d28,0xbfc64fbbd835f6e7,1 +np.float64,0xbfd795906faf2b20,0xbfd8bf89b370655c,1 +np.float64,0xbfe4b39b59e96736,0xbfe8a3c5c645b6e3,1 +np.float64,0x3fd310af3ba62160,0x3fd3a9442e825e1c,1 +np.float64,0xbfd45198a6a8a332,0xbfd50bc10311a0a3,1 +np.float64,0x3fd0017eaaa002fc,0x3fd05a472a837999,1 +np.float64,0xbfea974d98752e9b,0xbff30f67f1835183,1 +np.float64,0xbf978f60582f1ec0,0xbf979070e1c2b59d,1 +np.float64,0x3fe1c715d4e38e2c,0x3fe40b479e1241a2,1 +np.float64,0xbfccb965cd3972cc,0xbfcd38b40c4a352d,1 +np.float64,0xbfd9897048b312e0,0xbfdb09d55624c2a3,1 +np.float64,0x3fe7f5de4befebbc,0x3fef0b56be259f9c,1 +np.float64,0x3fcc6c6d4338d8d8,0x3fcce7b20ed68a78,1 +np.float64,0xbfe63884046c7108,0xbfeb67a3b945c3ee,1 +np.float64,0xbfce64e2ad3cc9c4,0xbfcefc47fae2e81f,1 +np.float64,0x3fefeb57b27fd6b0,0x400ab2eac6321cfb,1 +np.float64,0x3fe679627e6cf2c4,0x3febe6451b6ee0c4,1 +np.float64,0x3fc5f710172bee20,0x3fc62f40f85cb040,1 +np.float64,0x3fc34975e52692e8,0x3fc36f58588c7fa2,1 +np.float64,0x3fe8a3784cf146f0,0x3ff052ced9bb9406,1 +np.float64,0x3fd11a607ca234c0,0x3fd1874f876233fe,1 +np.float64,0x3fb2d653f625aca0,0x3fb2df0f4c9633f3,1 +np.float64,0x3fe555f39eeaabe8,0x3fe9c15ee962a28c,1 +np.float64,0xbfea297e3bf452fc,0xbff264107117f709,1 +np.float64,0x3fe1581cdde2b03a,0x3fe36c79acedf99c,1 +np.float64,0x3fd4567063a8ace0,0x3fd51123dbd9106f,1 +np.float64,0x3fa3883aec271080,0x3fa38aa86ec71218,1 +np.float64,0x3fe40e5d7de81cba,0x3fe78dbb9b568850,1 +np.float64,0xbfe9a2f7347345ee,0xbff1a0f4faa05041,1 +np.float64,0x3f9eef03a83dde00,0x3f9ef16caa0c1478,1 +np.float64,0xbfcb4641d1368c84,0xbfcbb2e7ff8c266d,1 +np.float64,0xbfa8403b2c308070,0xbfa844e148b735b7,1 +np.float64,0xbfe1875cd6e30eba,0xbfe3afadc08369f5,1 +np.float64,0xbfdd3c3d26ba787a,0xbfdf919b3e296766,1 +np.float64,0x3fcd6c4c853ad898,0x3fcdf55647b518b8,1 +np.float64,0xbfe360a173e6c143,0xbfe6759eb3a08cf2,1 +np.float64,0x3fe5a13147eb4262,0x3fea4a5a060f5adb,1 +np.float64,0x3feb3cdd7af679ba,0x3ff42aae0cf61234,1 +np.float64,0x3fe5205128ea40a2,0x3fe9618f3d0c54af,1 +np.float64,0x3fce35343f3c6a68,0x3fcec9c4e612b050,1 +np.float64,0xbfc345724d268ae4,0xbfc36b3ce6338e6a,1 +np.float64,0x3fedc4fc0e7b89f8,0x3ffa91c1d775c1f7,1 +np.float64,0x3fe41fbf21683f7e,0x3fe7aa6c174a0e65,1 +np.float64,0xbfc7a1a5d32f434c,0xbfc7e7d27a4c5241,1 +np.float64,0x3fd3e33eaca7c67c,0x3fd4915264441e2f,1 +np.float64,0x3feb3f02f6f67e06,0x3ff42e942249e596,1 +np.float64,0x3fdb75fcb0b6ebf8,0x3fdd5c63f98b6275,1 +np.float64,0x3fd6476603ac8ecc,0x3fd74020b164cf38,1 +np.float64,0x3fed535372faa6a6,0x3ff90f3791821841,1 +np.float64,0x3fe8648ead70c91e,0x3ff006a62befd7ed,1 +np.float64,0x3fd0f90760a1f210,0x3fd1636b39bb1525,1 +np.float64,0xbfca052443340a48,0xbfca633d6e777ae0,1 +np.float64,0xbfa6a5e3342d4bc0,0xbfa6a9ac6a488f5f,1 +np.float64,0x3fd5598038aab300,0x3fd632f35c0c3d52,1 +np.float64,0xbfdf66218fbecc44,0xbfe12df83b19f300,1 +np.float64,0x3fe78e15b56f1c2c,0x3fee240d12489cd1,1 +np.float64,0x3fe3d6a7b3e7ad50,0x3fe7329dcf7401e2,1 +np.float64,0xbfddb8e97bbb71d2,0xbfe017ed6d55a673,1 +np.float64,0xbfd57afd55aaf5fa,0xbfd658a9607c3370,1 +np.float64,0xbfdba4c9abb74994,0xbfdd95d69e5e8814,1 +np.float64,0xbfe71d8090ee3b01,0xbfed3390be6d2eef,1 +np.float64,0xbfc738ac0f2e7158,0xbfc77b3553b7c026,1 +np.float64,0x3f873656302e6c80,0x3f873697556ae011,1 +np.float64,0x3fe559491d6ab292,0x3fe9c7603b12c608,1 +np.float64,0xbfe262776864c4ef,0xbfe4ef905dda8599,1 +np.float64,0x3fe59d8917eb3b12,0x3fea439f44b7573f,1 +np.float64,0xbfd4b5afb5a96b60,0xbfd57b4e3df4dbc8,1 +np.float64,0x3fe81158447022b0,0x3fef4a3cea3eb6a9,1 +np.float64,0xbfeb023441f60468,0xbff3c27f0fc1a4dc,1 +np.float64,0x3fefb212eaff6426,0x40055fc6d949cf44,1 +np.float64,0xbfe1300ac1e26016,0xbfe333f297a1260e,1 +np.float64,0xbfeae0a2f575c146,0xbff388d58c380b8c,1 +np.float64,0xbfeddd8e55fbbb1d,0xbffaef045b2e21d9,1 +np.float64,0x3fec7c6c1d78f8d8,0x3ff6c3ebb019a8e5,1 +np.float64,0xbfe27e071f64fc0e,0xbfe518d2ff630f33,1 +np.float64,0x8000000000000001,0x8000000000000001,1 +np.float64,0x3fc5872abf2b0e58,0x3fc5bc083105db76,1 +np.float64,0x3fe65114baeca22a,0x3feb9745b82ef15a,1 +np.float64,0xbfc783abe52f0758,0xbfc7c8cb23f93e79,1 +np.float64,0x3fe4b7a5dd696f4c,0x3fe8aab9d492f0ca,1 +np.float64,0xbf91a8e8a82351e0,0xbf91a95b6ae806f1,1 +np.float64,0xbfee482eb77c905d,0xbffcb952830e715a,1 +np.float64,0x3fba0eee2a341de0,0x3fba261d495e3a1b,1 +np.float64,0xbfeb8876ae7710ed,0xbff4b7f7f4343506,1 +np.float64,0xbfe4d29e46e9a53c,0xbfe8d9547a601ba7,1 +np.float64,0xbfe12413b8e24828,0xbfe3232656541d10,1 +np.float64,0x3fc0bd8f61217b20,0x3fc0d63f937f0aa4,1 +np.float64,0xbfd3debafda7bd76,0xbfd48c534e5329e4,1 +np.float64,0x3fc0f92de921f258,0x3fc112eb7d47349b,1 +np.float64,0xbfe576b95f6aed72,0xbfe9fca859239b3c,1 +np.float64,0x3fd10e520da21ca4,0x3fd17a546e4152f7,1 +np.float64,0x3fcef917eb3df230,0x3fcf998677a8fa8f,1 +np.float64,0x3fdfcf863abf9f0c,0x3fe173a98af1cb13,1 +np.float64,0x3fc28c4b4f251898,0x3fc2adf43792e917,1 +np.float64,0x3fceb837ad3d7070,0x3fcf54a63b7d8c5c,1 +np.float64,0x3fc0140a05202818,0x3fc029e4f75330cb,1 +np.float64,0xbfd76c3362aed866,0xbfd88fb9e790b4e8,1 +np.float64,0xbfe475300868ea60,0xbfe8395334623e1f,1 +np.float64,0x3fea70b9b4f4e174,0x3ff2d1dad92173ba,1 +np.float64,0xbfe2edbd4965db7a,0xbfe5c29449a9365d,1 +np.float64,0xbfddf86f66bbf0de,0xbfe0408439cada9b,1 +np.float64,0xbfb443cdfa288798,0xbfb44eae796ad3ea,1 +np.float64,0xbf96a8a0482d5140,0xbf96a992b6ef073b,1 +np.float64,0xbfd279db2fa4f3b6,0xbfd3043db6acbd9e,1 +np.float64,0x3fe5d99088ebb322,0x3feab30be14e1605,1 +np.float64,0xbfe1a917abe35230,0xbfe3e0063d0f5f63,1 +np.float64,0x3fc77272f52ee4e8,0x3fc7b6f8ab6f4591,1 +np.float64,0x3fd6b62146ad6c44,0x3fd7be77eef8390a,1 +np.float64,0xbfe39fd9bc673fb4,0xbfe6da30dc4eadde,1 +np.float64,0x3fe35545c066aa8c,0x3fe663b5873e4d4b,1 +np.float64,0xbfcbbeffb3377e00,0xbfcc317edf7f6992,1 +np.float64,0xbfe28a58366514b0,0xbfe52b5734579ffa,1 +np.float64,0xbfbf0c87023e1910,0xbfbf33d970a0dfa5,1 +np.float64,0xbfd31144cba6228a,0xbfd3a9e84f9168f9,1 +np.float64,0xbfe5c044056b8088,0xbfea83d607c1a88a,1 +np.float64,0x3fdaabdf18b557c0,0x3fdc663ee8eddc83,1 +np.float64,0xbfeb883006f71060,0xbff4b76feff615be,1 +np.float64,0xbfebaef41d775de8,0xbff5034111440754,1 +np.float64,0x3fd9b6eb3bb36dd8,0x3fdb3fff5071dacf,1 +np.float64,0x3fe4e33c45e9c678,0x3fe8f637779ddedf,1 +np.float64,0x3fe52213a06a4428,0x3fe964adeff5c14e,1 +np.float64,0x3fe799254cef324a,0x3fee3c3ecfd3cdc5,1 +np.float64,0x3fd0533f35a0a680,0x3fd0b19a003469d3,1 +np.float64,0x3fec7ef5c7f8fdec,0x3ff6ca0abe055048,1 +np.float64,0xbfd1b5da82a36bb6,0xbfd22f357acbee79,1 +np.float64,0xbfd8f9c652b1f38c,0xbfda5faacbce9cf9,1 +np.float64,0x3fc8fc818b31f900,0x3fc94fa9a6aa53c8,1 +np.float64,0x3fcf42cc613e8598,0x3fcfe7dc128f33f2,1 +np.float64,0x3fd393a995a72754,0x3fd4396127b19305,1 +np.float64,0x3fec7b7df9f8f6fc,0x3ff6c1ae51753ef2,1 +np.float64,0x3fc07f175b20fe30,0x3fc096b55c11568c,1 +np.float64,0xbf979170082f22e0,0xbf979280d9555f44,1 +np.float64,0xbfb9d110c633a220,0xbfb9e79ba19b3c4a,1 +np.float64,0x3fedcd7d417b9afa,0x3ffab19734e86d58,1 +np.float64,0xbfec116f27f822de,0xbff5cf9425cb415b,1 +np.float64,0xbfec4fa0bef89f42,0xbff65a771982c920,1 +np.float64,0x3f94d4452829a880,0x3f94d501789ad11c,1 +np.float64,0xbfefe5ede27fcbdc,0xc009c440d3c2a4ce,1 +np.float64,0xbfe7e5f7b5efcbf0,0xbfeee74449aee1db,1 +np.float64,0xbfeb71dc8976e3b9,0xbff48cd84ea54ed2,1 +np.float64,0xbfe4cdb65f699b6c,0xbfe8d0d3bce901ef,1 +np.float64,0x3fb78ef1ee2f1de0,0x3fb7a00e7d183c48,1 +np.float64,0x3fb681864a2d0310,0x3fb6906fe64b4cd7,1 +np.float64,0xbfd2ad3b31a55a76,0xbfd33c57b5985399,1 +np.float64,0x3fdcdaaa95b9b554,0x3fdf16b99628db1e,1 +np.float64,0x3fa4780b7428f020,0x3fa47ad6ce9b8081,1 +np.float64,0x3fc546b0ad2a8d60,0x3fc579b361b3b18f,1 +np.float64,0x3feaf98dd6f5f31c,0x3ff3b38189c3539c,1 +np.float64,0x3feb0b2eca76165e,0x3ff3d22797083f9a,1 +np.float64,0xbfdc02ae3ab8055c,0xbfde099ecb5dbacf,1 +np.float64,0x3fd248bf17a49180,0x3fd2ceb77b346d1d,1 +np.float64,0x3fe349d666e693ac,0x3fe651b9933a8853,1 +np.float64,0xbfca526fc534a4e0,0xbfcab3e83f0d9b93,1 +np.float64,0x3fc156421722ac88,0x3fc171b38826563b,1 +np.float64,0xbfe4244569e8488b,0xbfe7b1e93e7d4f92,1 +np.float64,0x3fe010faabe021f6,0x3fe1aa961338886d,1 +np.float64,0xbfc52dacb72a5b58,0xbfc55ffa50eba380,1 +np.float64,0x8000000000000000,0x8000000000000000,1 +np.float64,0x3fea1d4865f43a90,0x3ff251b839eb4817,1 +np.float64,0xbfa0f65c8421ecc0,0xbfa0f7f37c91be01,1 +np.float64,0x3fcab29c0b356538,0x3fcb1863edbee184,1 +np.float64,0x3fe7949162ef2922,0x3fee323821958b88,1 +np.float64,0x3fdaf9288ab5f250,0x3fdcc400190a4839,1 +np.float64,0xbfe13ece6be27d9d,0xbfe348ba07553179,1 +np.float64,0x3f8a0c4fd0341880,0x3f8a0cabdf710185,1 +np.float64,0x3fdd0442a2ba0884,0x3fdf4b016c4da452,1 +np.float64,0xbfaf06d2343e0da0,0xbfaf1090b1600422,1 +np.float64,0xbfd3b65225a76ca4,0xbfd45fa49ae76cca,1 +np.float64,0x3fef5d75fefebaec,0x400269a5e7c11891,1 +np.float64,0xbfe048e35ce091c6,0xbfe1f5af45dd64f8,1 +np.float64,0xbfe27d4599e4fa8b,0xbfe517b07843d04c,1 +np.float64,0xbfe6f2a637ede54c,0xbfecdaa730462576,1 +np.float64,0x3fc63fbb752c7f78,0x3fc67a2854974109,1 +np.float64,0x3fedda6bfbfbb4d8,0x3ffae2e6131f3475,1 +np.float64,0x3fe7a6f5286f4dea,0x3fee5a9b1ef46016,1 +np.float64,0xbfd4ea8bcea9d518,0xbfd5b66ab7e5cf00,1 +np.float64,0x3fdc116568b822cc,0x3fde1bd4d0d9fd6c,1 +np.float64,0x3fdc45cb1bb88b98,0x3fde5cd1d2751032,1 +np.float64,0x3feabd932f757b26,0x3ff34e06e56a62a1,1 +np.float64,0xbfae5dbe0c3cbb80,0xbfae66e062ac0d65,1 +np.float64,0xbfdb385a00b670b4,0xbfdd10fedf3a58a7,1 +np.float64,0xbfebb14755f7628f,0xbff507e123a2b47c,1 +np.float64,0x3fe6de2fdfedbc60,0x3fecb0ae6e131da2,1 +np.float64,0xbfd86de640b0dbcc,0xbfd9bb4dbf0bf6af,1 +np.float64,0x3fe39e86d9e73d0e,0x3fe6d811c858d5d9,1 +np.float64,0x7ff0000000000000,0xfff8000000000000,1 +np.float64,0x3fa8101684302020,0x3fa814a12176e937,1 +np.float64,0x3fefdd5ad37fbab6,0x4008a08c0b76fbb5,1 +np.float64,0x3fe645c727ec8b8e,0x3feb814ebc470940,1 +np.float64,0x3fe3ba79dce774f4,0x3fe70500db564cb6,1 +np.float64,0xbfe0e5a254e1cb44,0xbfe2cc13940c6d9a,1 +np.float64,0x3fe2cac62465958c,0x3fe58d008c5e31f8,1 +np.float64,0xbfd3ffb531a7ff6a,0xbfd4b0d88cff2040,1 +np.float64,0x3fe0929104612522,0x3fe259bc42dce788,1 +np.float64,0x1,0x1,1 +np.float64,0xbfe7db77e6efb6f0,0xbfeecf93e8a61cb3,1 +np.float64,0xbfe37e9559e6fd2a,0xbfe6a514e29cb7aa,1 +np.float64,0xbfc53a843f2a7508,0xbfc56d2e9ad8b716,1 +np.float64,0xbfedb04485fb6089,0xbffa4615d4334ec3,1 +np.float64,0xbfc44349b1288694,0xbfc46f484b6f1cd6,1 +np.float64,0xbfe265188264ca31,0xbfe4f37d61cd9e17,1 +np.float64,0xbfd030351da0606a,0xbfd08c2537287ee1,1 +np.float64,0x3fd8fb131db1f628,0x3fda613363ca601e,1 +np.float64,0xbff0000000000000,0xfff0000000000000,1 +np.float64,0xbfe48d9a60691b35,0xbfe862c02d8fec1e,1 +np.float64,0x3fd185e050a30bc0,0x3fd1fb4c614ddb07,1 +np.float64,0xbfe4a5807e694b01,0xbfe88b8ff2d6caa7,1 +np.float64,0xbfc934d7ad3269b0,0xbfc98a405d25a666,1 +np.float64,0xbfea0e3c62741c79,0xbff23b4bd3a7b15d,1 +np.float64,0x3fe7244071ee4880,0x3fed41b27ba6bb22,1 +np.float64,0xbfd419f81ba833f0,0xbfd4cdf71b4533a3,1 +np.float64,0xbfe1e73a34e3ce74,0xbfe439eb15fa6baf,1 +np.float64,0x3fcdd9a63f3bb350,0x3fce68e1c401eff0,1 +np.float64,0x3fd1b5960ba36b2c,0x3fd22eeb566f1976,1 +np.float64,0x3fe9ad18e0735a32,0x3ff1af23c534260d,1 +np.float64,0xbfd537918aaa6f24,0xbfd60ccc8df0962b,1 +np.float64,0x3fcba3d3c73747a8,0x3fcc14fd5e5c49ad,1 +np.float64,0x3fd367e3c0a6cfc8,0x3fd40921b14e288e,1 +np.float64,0x3fe94303c6f28608,0x3ff11e62db2db6ac,1 +np.float64,0xbfcc5f77fd38bef0,0xbfccda110c087519,1 +np.float64,0xbfd63b74d7ac76ea,0xbfd7328af9f37402,1 +np.float64,0xbfe5321289ea6425,0xbfe9811ce96609ad,1 +np.float64,0xbfde910879bd2210,0xbfe0a2cd0ed1d368,1 +np.float64,0xbfcc9d9bad393b38,0xbfcd1b722a0b1371,1 +np.float64,0xbfe6dd39e16dba74,0xbfecaeb7c8c069f6,1 +np.float64,0xbfe98316eff3062e,0xbff174d7347d48bf,1 +np.float64,0xbfda88f8d1b511f2,0xbfdc3c0e75dad903,1 +np.float64,0x3fd400d8c2a801b0,0x3fd4b21bacff1f5d,1 +np.float64,0xbfe1ed335863da66,0xbfe4429e45e99779,1 +np.float64,0xbf3423a200284800,0xbf3423a20acb0342,1 +np.float64,0xbfe97bc59672f78b,0xbff16ad1adc44a33,1 +np.float64,0xbfeeca60d7fd94c2,0xbfff98d7f18f7728,1 +np.float64,0x3fd1eb13b2a3d628,0x3fd268e6ff4d56ce,1 +np.float64,0xbfa5594c242ab2a0,0xbfa55c77d6740a39,1 +np.float64,0x3fe72662006e4cc4,0x3fed462a9dedbfee,1 +np.float64,0x3fef4bb221fe9764,0x4001fe4f4cdfedb2,1 +np.float64,0xbfe938d417f271a8,0xbff110e78724ca2b,1 +np.float64,0xbfcc29ab2f385358,0xbfcca182140ef541,1 +np.float64,0x3fe18cd42c6319a8,0x3fe3b77e018165e7,1 +np.float64,0xbfec6c5cae78d8b9,0xbff69d8e01309b48,1 +np.float64,0xbfd5723da7aae47c,0xbfd64ecde17da471,1 +np.float64,0xbfe3096722e612ce,0xbfe5ed43634f37ff,1 +np.float64,0xbfdacaceb1b5959e,0xbfdc8bb826bbed39,1 +np.float64,0x3fc59a57cb2b34b0,0x3fc5cfc4a7c9bac8,1 +np.float64,0x3f84adce10295b80,0x3f84adfc1f1f6e97,1 +np.float64,0x3fdd5b28bbbab650,0x3fdfb8b906d77df4,1 +np.float64,0x3fdebf94c6bd7f28,0x3fe0c10188e1bc7c,1 +np.float64,0x3fdb30c612b6618c,0x3fdd07bf18597821,1 +np.float64,0x3fe7eeb3176fdd66,0x3feefb0be694b855,1 +np.float64,0x0,0x0,1 +np.float64,0xbfe10057e9e200b0,0xbfe2f13365e5b1c9,1 +np.float64,0xbfeb61a82376c350,0xbff46e665d3a60f5,1 +np.float64,0xbfe7f54aec6fea96,0xbfef0a0759f726dc,1 +np.float64,0xbfe4f6da3de9edb4,0xbfe9187d85bd1ab5,1 +np.float64,0xbfeb8be1b3f717c4,0xbff4be8efaab2e75,1 +np.float64,0x3fed40bc31fa8178,0x3ff8d5ec4a7f3e9b,1 +np.float64,0xbfe40f8711681f0e,0xbfe78fa5c62b191b,1 +np.float64,0x3fd1034d94a2069c,0x3fd16e78e9efb85b,1 +np.float64,0x3fc74db15b2e9b60,0x3fc790f26e894098,1 +np.float64,0x3fd912a88cb22550,0x3fda7d0ab3b21308,1 +np.float64,0x3fd8948a3bb12914,0x3fd9e8950c7874c8,1 +np.float64,0xbfa7ada5242f5b50,0xbfa7b1f8db50c104,1 +np.float64,0x3feeb2e1c27d65c4,0x3fff000b7d09c9b7,1 +np.float64,0x3fe9d46cbbf3a8da,0x3ff1e6f405265a6e,1 +np.float64,0xbfe2480b77e49017,0xbfe4c83b9b37bf0c,1 +np.float64,0x3fe950ea9372a1d6,0x3ff130e62468bf2c,1 +np.float64,0x3fefa7272a7f4e4e,0x4004d8c9bf31ab58,1 +np.float64,0xbfe7309209ee6124,0xbfed5b94acef917a,1 +np.float64,0x3fd05e8c64a0bd18,0x3fd0bdb11e0903c6,1 +np.float64,0x3fd9236043b246c0,0x3fda90ccbe4bab1e,1 +np.float64,0xbfdc3d6805b87ad0,0xbfde5266e17154c3,1 +np.float64,0x3fe5e6bad76bcd76,0x3feacbc306c63445,1 +np.float64,0x3ff0000000000000,0x7ff0000000000000,1 +np.float64,0xbfde3d7390bc7ae8,0xbfe06cd480bd0196,1 +np.float64,0xbfd3e2e3c0a7c5c8,0xbfd490edc0a45e26,1 +np.float64,0x3fe39871d76730e4,0x3fe6ce54d1719953,1 +np.float64,0x3fdff00ebcbfe01c,0x3fe1894b6655a6d0,1 +np.float64,0x3f91b7ad58236f40,0x3f91b8213bcb8b0b,1 +np.float64,0xbfd99f48f7b33e92,0xbfdb23d544f62591,1 +np.float64,0x3fae3512cc3c6a20,0x3fae3e10939fd7b5,1 +np.float64,0x3fcc4cf3db3899e8,0x3fccc698a15176d6,1 +np.float64,0xbfd0927e39a124fc,0xbfd0f5522e2bc030,1 +np.float64,0x3fcee859633dd0b0,0x3fcf87bdef7a1e82,1 +np.float64,0xbfe2a8b69565516d,0xbfe5593437b6659a,1 +np.float64,0x3fecf61e20f9ec3c,0x3ff7fda16b0209d4,1 +np.float64,0xbfbf37571e3e6eb0,0xbfbf5f4e1379a64c,1 +np.float64,0xbfd54e1b75aa9c36,0xbfd626223b68971a,1 +np.float64,0x3fe1035a56e206b4,0x3fe2f5651ca0f4b0,1 +np.float64,0x3fe4992989e93254,0x3fe876751afa70dc,1 +np.float64,0x3fc8c313d3318628,0x3fc913faf15d1562,1 +np.float64,0x3f99f6ba8833ed80,0x3f99f8274fb94828,1 +np.float64,0xbfd4a58af0a94b16,0xbfd56947c276e04f,1 +np.float64,0x3fc66f8c872cdf18,0x3fc6ab7a14372a73,1 +np.float64,0x3fc41eee0d283de0,0x3fc449ff1ff0e7a6,1 +np.float64,0x3fefd04d287fa09a,0x4007585010cfa9b0,1 +np.float64,0x3fce9e746f3d3ce8,0x3fcf39514bbe5070,1 +np.float64,0xbfe8056f72700adf,0xbfef2ee2c13e67ba,1 +np.float64,0x3fdd6b1ec0bad63c,0x3fdfccf2ba144fa8,1 +np.float64,0x3fd92ee432b25dc8,0x3fda9e6b96b2b142,1 +np.float64,0xbfc4d18f9529a320,0xbfc50150fb4de0cc,1 +np.float64,0xbfe09939a7613274,0xbfe262d703c317af,1 +np.float64,0xbfd130b132a26162,0xbfd19f5a00ae29c4,1 +np.float64,0x3fa06e21d420dc40,0x3fa06f93aba415fb,1 +np.float64,0x3fc5c48fbd2b8920,0x3fc5fb3bfad3bf55,1 +np.float64,0xbfdfa2bacbbf4576,0xbfe155f839825308,1 +np.float64,0x3fe3e1fa0f67c3f4,0x3fe745081dd4fd03,1 +np.float64,0x3fdae58289b5cb04,0x3fdcac1f6789130a,1 +np.float64,0xbf8ed3ba103da780,0xbf8ed452a9cc1442,1 +np.float64,0xbfec06b46f780d69,0xbff5b86f30d70908,1 +np.float64,0xbfe990c13b732182,0xbff187a90ae611f8,1 +np.float64,0xbfdd46c738ba8d8e,0xbfdf9eee0a113230,1 +np.float64,0x3fe08b83f3611708,0x3fe2501b1c77035c,1 +np.float64,0xbfd501b65baa036c,0xbfd5d05de3fceac8,1 +np.float64,0xbfcf4fa21f3e9f44,0xbfcff5829582c0b6,1 +np.float64,0xbfefbc0bfbff7818,0xc005eca1a2c56b38,1 +np.float64,0xbfe1ba6959e374d2,0xbfe3f8f88d128ce5,1 +np.float64,0xbfd4e74ee3a9ce9e,0xbfd5b2cabeb45e6c,1 +np.float64,0xbfe77c38eaeef872,0xbfedfd332d6f1c75,1 +np.float64,0x3fa9b5e4fc336bc0,0x3fa9bb6f6b80b4af,1 +np.float64,0xbfecba63917974c7,0xbff75e44df7f8e81,1 +np.float64,0x3fd6cf17b2ad9e30,0x3fd7db0b93b7f2b5,1 diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/data/umath-validation-set-cbrt.csv b/venv/lib/python3.12/site-packages/numpy/_core/tests/data/umath-validation-set-cbrt.csv new file mode 100644 index 00000000..ad141cb4 --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/tests/data/umath-validation-set-cbrt.csv @@ -0,0 +1,1429 @@ +dtype,input,output,ulperrortol +np.float32,0x3ee7054c,0x3f4459ea,2 +np.float32,0x7d1e2489,0x54095925,2 +np.float32,0x7ee5edf5,0x549b992b,2 +np.float32,0x380607,0x2a425e72,2 +np.float32,0x34a8f3,0x2a3e6603,2 +np.float32,0x3eee2844,0x3f465a45,2 +np.float32,0x59e49c,0x2a638d0a,2 +np.float32,0xbf72c77a,0xbf7b83d4,2 +np.float32,0x7f2517b4,0x54af8bf0,2 +np.float32,0x80068a69,0xa9bdfe8b,2 +np.float32,0xbe8e3578,0xbf270775,2 +np.float32,0xbe4224dc,0xbf131119,2 +np.float32,0xbe0053b8,0xbf001be2,2 +np.float32,0x70e8d,0x29c2ddc5,2 +np.float32,0xff63f7b5,0xd4c37b7f,2 +np.float32,0x3f00bbed,0x3f4b9335,2 +np.float32,0x3f135f4e,0x3f54f5d4,2 +np.float32,0xbe13a488,0xbf063d13,2 +np.float32,0x3f14ec78,0x3f55b478,2 +np.float32,0x7ec35cfb,0x54935fbf,2 +np.float32,0x7d41c589,0x5412f904,2 +np.float32,0x3ef8a16e,0x3f4937f7,2 +np.float32,0x3f5d8464,0x3f73f279,2 +np.float32,0xbeec85ac,0xbf45e5cb,2 +np.float32,0x7f11f722,0x54a87cb1,2 +np.float32,0x8032c085,0xaa3c1219,2 +np.float32,0x80544bac,0xaa5eb9f2,2 +np.float32,0x3e944a10,0x3f296065,2 +np.float32,0xbf29fe50,0xbf5f5796,2 +np.float32,0x7e204d8d,0x545b03d5,2 +np.float32,0xfe1d0254,0xd4598127,2 +np.float32,0x80523129,0xaa5cdba9,2 +np.float32,0x806315fa,0xaa6b0eaf,2 +np.float32,0x3ed3d2a4,0x3f3ec117,2 +np.float32,0x7ee15007,0x549a8cc0,2 +np.float32,0x801ffb5e,0xaa213d4f,2 +np.float32,0x807f9f4a,0xaa7fbf76,2 +np.float32,0xbe45e854,0xbf1402d3,2 +np.float32,0x3d9e2e70,0x3eda0b64,2 +np.float32,0x51f404,0x2a5ca4d7,2 +np.float32,0xbe26a8b0,0xbf0bc54d,2 +np.float32,0x22c99a,0x2a25d2a7,2 +np.float32,0xbf71248b,0xbf7af2d5,2 +np.float32,0x7219fe,0x2a76608e,2 +np.float32,0x7f16fd7d,0x54aa6610,2 +np.float32,0x80716faa,0xaa75e5b9,2 +np.float32,0xbe24f9a4,0xbf0b4c65,2 +np.float32,0x800000,0x2a800000,2 +np.float32,0x80747456,0xaa780f27,2 +np.float32,0x68f9e8,0x2a6fa035,2 +np.float32,0x3f6a297e,0x3f7880d8,2 +np.float32,0x3f28b973,0x3f5ec8f6,2 +np.float32,0x7f58c577,0x54c03a70,2 +np.float32,0x804befcc,0xaa571b4f,2 +np.float32,0x3e2be027,0x3f0d36cf,2 +np.float32,0xfe7e80a4,0xd47f7ff7,2 +np.float32,0xfe9d444a,0xd489181b,2 +np.float32,0x3db3e790,0x3ee399d6,2 +np.float32,0xbf154c3e,0xbf55e23e,2 +np.float32,0x3d1096b7,0x3ea7f4aa,2 +np.float32,0x7fc00000,0x7fc00000,2 +np.float32,0x804e2521,0xaa592c06,2 +np.float32,0xbeda2f00,0xbf40a513,2 +np.float32,0x3f191788,0x3f57ae30,2 +np.float32,0x3ed24ade,0x3f3e4b34,2 +np.float32,0x807fadb4,0xaa7fc917,2 +np.float32,0xbe0a06dc,0xbf034234,2 +np.float32,0x3f250bba,0x3f5d276d,2 +np.float32,0x7e948b00,0x548682c8,2 +np.float32,0xfe65ecdc,0xd476fed2,2 +np.float32,0x6fdbdd,0x2a74c095,2 +np.float32,0x800112de,0xa9500fa6,2 +np.float32,0xfe63225c,0xd475fdee,2 +np.float32,0x7f3d9acd,0x54b7d648,2 +np.float32,0xfc46f480,0xd3bacf87,2 +np.float32,0xfe5deaac,0xd47417ff,2 +np.float32,0x60ce53,0x2a693d93,2 +np.float32,0x6a6e2f,0x2a70ba2c,2 +np.float32,0x7f43f0f1,0x54b9dcd0,2 +np.float32,0xbf6170c9,0xbf756104,2 +np.float32,0xbe5c9f74,0xbf197852,2 +np.float32,0xff1502b0,0xd4a9a693,2 +np.float32,0x8064f6af,0xaa6c886e,2 +np.float32,0xbf380564,0xbf6552e5,2 +np.float32,0xfeb9b7dc,0xd490e85f,2 +np.float32,0x7f34f941,0x54b5010d,2 +np.float32,0xbe9d4ca0,0xbf2cbd5f,2 +np.float32,0x3f6e43d2,0x3f79f240,2 +np.float32,0xbdad0530,0xbee0a8f2,2 +np.float32,0x3da18459,0x3edb9105,2 +np.float32,0xfd968340,0xd42a3808,2 +np.float32,0x3ea03e64,0x3f2dcf96,2 +np.float32,0x801d2f5b,0xaa1c6525,2 +np.float32,0xbf47d92d,0xbf6bb7e9,2 +np.float32,0x55a6b9,0x2a5fe9fb,2 +np.float32,0x77a7c2,0x2a7a4fb8,2 +np.float32,0xfebbc16e,0xd4916f88,2 +np.float32,0x3f5d3d6e,0x3f73d86a,2 +np.float32,0xfccd2b60,0xd3edcacb,2 +np.float32,0xbd026460,0xbea244b0,2 +np.float32,0x3e55bd,0x2a4968e4,2 +np.float32,0xbe7b5708,0xbf20490d,2 +np.float32,0xfe413cf4,0xd469171f,2 +np.float32,0x7710e3,0x2a79e657,2 +np.float32,0xfc932520,0xd3d4d9ca,2 +np.float32,0xbf764a1b,0xbf7cb8aa,2 +np.float32,0x6b1923,0x2a713aca,2 +np.float32,0xfe4dcd04,0xd46e092d,2 +np.float32,0xff3085ac,0xd4b381f8,2 +np.float32,0x3f72c438,0x3f7b82b4,2 +np.float32,0xbf6f0c6e,0xbf7a3852,2 +np.float32,0x801d2b1b,0xaa1c5d8d,2 +np.float32,0x3e9db91e,0x3f2ce50d,2 +np.float32,0x3f684f9d,0x3f77d8c5,2 +np.float32,0x7dc784,0x2a7e82cc,2 +np.float32,0x7d2c88e9,0x540d64f8,2 +np.float32,0x807fb708,0xaa7fcf51,2 +np.float32,0x8003c49a,0xa99e16e0,2 +np.float32,0x3ee4f5b8,0x3f43c3ff,2 +np.float32,0xfe992c5e,0xd487e4ec,2 +np.float32,0x4b4dfa,0x2a568216,2 +np.float32,0x3d374c80,0x3eb5c6a8,2 +np.float32,0xbd3a4700,0xbeb6c15c,2 +np.float32,0xbf13cb80,0xbf5529e5,2 +np.float32,0xbe7306d4,0xbf1e7f91,2 +np.float32,0xbf800000,0xbf800000,2 +np.float32,0xbea42efe,0xbf2f394e,2 +np.float32,0x3e1981d0,0x3f07fe2c,2 +np.float32,0x3f17ea1d,0x3f572047,2 +np.float32,0x7dc1e0,0x2a7e7efe,2 +np.float32,0x80169c08,0xaa0fa320,2 +np.float32,0x3f3e1972,0x3f67d248,2 +np.float32,0xfe5d3c88,0xd473d815,2 +np.float32,0xbf677448,0xbf778aac,2 +np.float32,0x7e799b7d,0x547dd9e4,2 +np.float32,0x3f00bb2c,0x3f4b92cf,2 +np.float32,0xbeb29f9c,0xbf343798,2 +np.float32,0xbd6b7830,0xbec59a86,2 +np.float32,0x807a524a,0xaa7c282a,2 +np.float32,0xbe0a7a04,0xbf0366ab,2 +np.float32,0x80237470,0xaa26e061,2 +np.float32,0x3ccbc0f6,0x3e95744f,2 +np.float32,0x3edec6bc,0x3f41fcb6,2 +np.float32,0x3f635198,0x3f760efa,2 +np.float32,0x800eca4f,0xa9f960d8,2 +np.float32,0x3f800000,0x3f800000,2 +np.float32,0xff4eeb9e,0xd4bd456a,2 +np.float32,0x56f4e,0x29b29e70,2 +np.float32,0xff5383a0,0xd4bea95c,2 +np.float32,0x3f4c3a77,0x3f6d6d94,2 +np.float32,0x3f6c324a,0x3f79388c,2 +np.float32,0xbebdc092,0xbf37e27c,2 +np.float32,0xff258956,0xd4afb42e,2 +np.float32,0xdc78c,0x29f39012,2 +np.float32,0xbf2db06a,0xbf60f2f5,2 +np.float32,0xbe3c5808,0xbf119660,2 +np.float32,0xbf1ba866,0xbf58e0f4,2 +np.float32,0x80377640,0xaa41b79d,2 +np.float32,0x4fdc4d,0x2a5abfea,2 +np.float32,0x7f5e7560,0x54c1e516,2 +np.float32,0xfeb4d3f2,0xd48f9fde,2 +np.float32,0x3f12a622,0x3f549c7d,2 +np.float32,0x7f737ed7,0x54c7d2dc,2 +np.float32,0xa0ddc,0x29db456d,2 +np.float32,0xfe006740,0xd44b6689,2 +np.float32,0x3f17dfd4,0x3f571b6c,2 +np.float32,0x67546e,0x2a6e5dd1,2 +np.float32,0xff0d0f11,0xd4a693e2,2 +np.float32,0xbd170090,0xbeaa6738,2 +np.float32,0x5274a0,0x2a5d1806,2 +np.float32,0x3e154fe0,0x3f06be1a,2 +np.float32,0x7ddb302e,0x5440f0a7,2 +np.float32,0x3f579d10,0x3f71c2af,2 +np.float32,0xff2bc5bb,0xd4b1e20c,2 +np.float32,0xfee8fa6a,0xd49c4872,2 +np.float32,0xbea551b0,0xbf2fa07b,2 +np.float32,0xfeabc75c,0xd48d3004,2 +np.float32,0x7f50a5a8,0x54bdcbd1,2 +np.float32,0x50354b,0x2a5b110d,2 +np.float32,0x7d139f13,0x54063b6b,2 +np.float32,0xbeee1b08,0xbf465699,2 +np.float32,0xfe5e1650,0xd47427fe,2 +np.float32,0x7f7fffff,0x54cb2ff5,2 +np.float32,0xbf52ede8,0xbf6fff35,2 +np.float32,0x804bba81,0xaa56e8f1,2 +np.float32,0x6609e2,0x2a6d5e94,2 +np.float32,0x692621,0x2a6fc1d6,2 +np.float32,0xbf288bb6,0xbf5eb4d3,2 +np.float32,0x804f28c4,0xaa5a1b82,2 +np.float32,0xbdaad2a8,0xbedfb46e,2 +np.float32,0x5e04f8,0x2a66fb13,2 +np.float32,0x804c10da,0xaa573a81,2 +np.float32,0xbe412764,0xbf12d0fd,2 +np.float32,0x801c35cc,0xaa1aa250,2 +np.float32,0x6364d4,0x2a6b4cf9,2 +np.float32,0xbf6d3cea,0xbf79962f,2 +np.float32,0x7e5a9935,0x5472defb,2 +np.float32,0xbe73a38c,0xbf1ea19c,2 +np.float32,0xbd35e950,0xbeb550f2,2 +np.float32,0x46cc16,0x2a5223d6,2 +np.float32,0x3f005288,0x3f4b5b97,2 +np.float32,0x8034e8b7,0xaa3eb2be,2 +np.float32,0xbea775fc,0xbf3061cf,2 +np.float32,0xea0e9,0x29f87751,2 +np.float32,0xbf38faaf,0xbf65b89d,2 +np.float32,0xbedf3184,0xbf421bb0,2 +np.float32,0xbe04250c,0xbf015def,2 +np.float32,0x7f56dae8,0x54bfa901,2 +np.float32,0xfebe3e04,0xd492132e,2 +np.float32,0x3e4dc326,0x3f15f19e,2 +np.float32,0x803da197,0xaa48a621,2 +np.float32,0x7eeb35aa,0x549cc7c6,2 +np.float32,0xfebb3eb6,0xd4914dc0,2 +np.float32,0xfed17478,0xd496d5e2,2 +np.float32,0x80243694,0xaa280ed2,2 +np.float32,0x8017e666,0xaa1251d3,2 +np.float32,0xbf07e942,0xbf4f4a3e,2 +np.float32,0xbf578fa6,0xbf71bdab,2 +np.float32,0x7ed8d80f,0x549896b6,2 +np.float32,0x3f2277ae,0x3f5bff11,2 +np.float32,0x7e6f195b,0x547a3cd4,2 +np.float32,0xbf441559,0xbf6a3a91,2 +np.float32,0x7f1fb427,0x54ad9d8d,2 +np.float32,0x71695f,0x2a75e12d,2 +np.float32,0xbd859588,0xbece19a1,2 +np.float32,0x7f5702fc,0x54bfb4eb,2 +np.float32,0x3f040008,0x3f4d4842,2 +np.float32,0x3de00ca5,0x3ef4df89,2 +np.float32,0x3eeabb03,0x3f45658c,2 +np.float32,0x3dfe5e65,0x3eff7480,2 +np.float32,0x1,0x26a14518,2 +np.float32,0x8065e400,0xaa6d4130,2 +np.float32,0xff50e1bb,0xd4bdde07,2 +np.float32,0xbe88635a,0xbf24b7e9,2 +np.float32,0x3f46bfab,0x3f6b4908,2 +np.float32,0xbd85c3c8,0xbece3168,2 +np.float32,0xbe633f64,0xbf1afdb1,2 +np.float32,0xff2c7706,0xd4b21f2a,2 +np.float32,0xbf02816c,0xbf4c812a,2 +np.float32,0x80653aeb,0xaa6cbdab,2 +np.float32,0x3eef1d10,0x3f469e24,2 +np.float32,0x3d9944bf,0x3ed7c36a,2 +np.float32,0x1b03d4,0x2a186b2b,2 +np.float32,0x3f251b7c,0x3f5d2e76,2 +np.float32,0x3edebab0,0x3f41f937,2 +np.float32,0xfefc2148,0xd4a073ff,2 +np.float32,0x7448ee,0x2a77f051,2 +np.float32,0x3bb8a400,0x3e3637ee,2 +np.float32,0x57df36,0x2a61d527,2 +np.float32,0xfd8b9098,0xd425fccb,2 +np.float32,0x7f67627e,0x54c4744d,2 +np.float32,0x801165d7,0xaa039fba,2 +np.float32,0x53aae5,0x2a5e2bfd,2 +np.float32,0x8014012b,0xaa09e4f1,2 +np.float32,0x3f7a2d53,0x3f7e0b4b,2 +np.float32,0x3f5fb700,0x3f74c052,2 +np.float32,0x7f192a06,0x54ab366c,2 +np.float32,0x3f569611,0x3f71603b,2 +np.float32,0x25e2dc,0x2a2a9b65,2 +np.float32,0x8036465e,0xaa405342,2 +np.float32,0x804118e1,0xaa4c5785,2 +np.float32,0xbef08d3e,0xbf4703e1,2 +np.float32,0x3447e2,0x2a3df0be,2 +np.float32,0xbf2a350b,0xbf5f6f8c,2 +np.float32,0xbec87e3e,0xbf3b4a73,2 +np.float32,0xbe99a4a8,0xbf2b6412,2 +np.float32,0x2ea2ae,0x2a36d77e,2 +np.float32,0xfcb69600,0xd3e4b9e3,2 +np.float32,0x717700,0x2a75eb06,2 +np.float32,0xbf4e81ce,0xbf6e4ecc,2 +np.float32,0xbe2021ac,0xbf09ebee,2 +np.float32,0xfef94eee,0xd49fda31,2 +np.float32,0x8563e,0x29ce0015,2 +np.float32,0x7f5d0ca5,0x54c17c0f,2 +np.float32,0x3f16459a,0x3f56590f,2 +np.float32,0xbe12f7bc,0xbf0608a0,2 +np.float32,0x3f10fd3d,0x3f53ce5f,2 +np.float32,0x3ca5e1b0,0x3e8b8d96,2 +np.float32,0xbe5288e0,0xbf17181f,2 +np.float32,0xbf7360f6,0xbf7bb8c9,2 +np.float32,0x7e989d33,0x5487ba88,2 +np.float32,0x3ea7b5dc,0x3f307839,2 +np.float32,0x7e8da0c9,0x548463f0,2 +np.float32,0xfeaf7888,0xd48e3122,2 +np.float32,0x7d90402d,0x5427d321,2 +np.float32,0x72e309,0x2a76f0ee,2 +np.float32,0xbe1faa34,0xbf09c998,2 +np.float32,0xbf2b1652,0xbf5fd1f4,2 +np.float32,0x8051eb0c,0xaa5c9cca,2 +np.float32,0x7edf02bf,0x549a058e,2 +np.float32,0x7fa00000,0x7fe00000,2 +np.float32,0x3f67f873,0x3f77b9c1,2 +np.float32,0x3f276b63,0x3f5e358c,2 +np.float32,0x7eeb4bf2,0x549cccb9,2 +np.float32,0x3bfa2c,0x2a46d675,2 +np.float32,0x3e133c50,0x3f061d75,2 +np.float32,0x3ca302c0,0x3e8abe4a,2 +np.float32,0x802e152e,0xaa361dd5,2 +np.float32,0x3f504810,0x3f6efd0a,2 +np.float32,0xbf43e0b5,0xbf6a2599,2 +np.float32,0x80800000,0xaa800000,2 +np.float32,0x3f1c0980,0x3f590e03,2 +np.float32,0xbf0084f6,0xbf4b7638,2 +np.float32,0xfee72d32,0xd49be10d,2 +np.float32,0x3f3c00ed,0x3f66f763,2 +np.float32,0x80511e81,0xaa5be492,2 +np.float32,0xfdd1b8a0,0xd43e1f0d,2 +np.float32,0x7d877474,0x54245785,2 +np.float32,0x7f110bfe,0x54a82207,2 +np.float32,0xff800000,0xff800000,2 +np.float32,0x6b6a2,0x29bfa706,2 +np.float32,0xbf5bdfd9,0xbf7357b7,2 +np.float32,0x8025bfa3,0xaa2a6676,2 +np.float32,0x3a3581,0x2a44dd3a,2 +np.float32,0x542c2a,0x2a5e9e2f,2 +np.float32,0xbe1d5650,0xbf091d57,2 +np.float32,0x3e97760d,0x3f2a935e,2 +np.float32,0x7f5dcde2,0x54c1b460,2 +np.float32,0x800bde1e,0xa9e7bbaf,2 +np.float32,0x3e6b9e61,0x3f1cdf07,2 +np.float32,0x7d46c003,0x54143884,2 +np.float32,0x80073fbb,0xa9c49e67,2 +np.float32,0x503c23,0x2a5b1748,2 +np.float32,0x7eb7b070,0x549060c8,2 +np.float32,0xe9d8f,0x29f86456,2 +np.float32,0xbeedd4f0,0xbf464320,2 +np.float32,0x3f40d5d6,0x3f68eda1,2 +np.float32,0xff201f28,0xd4adc44b,2 +np.float32,0xbdf61e98,0xbefca9c7,2 +np.float32,0x3e8a0dc9,0x3f2562e3,2 +np.float32,0xbc0c0c80,0xbe515f61,2 +np.float32,0x2b3c15,0x2a3248e3,2 +np.float32,0x42a7bb,0x2a4df592,2 +np.float32,0x7f337947,0x54b480af,2 +np.float32,0xfec21db4,0xd4930f4b,2 +np.float32,0x7f4fdbf3,0x54bd8e94,2 +np.float32,0x1e2253,0x2a1e1286,2 +np.float32,0x800c4c80,0xa9ea819e,2 +np.float32,0x7e96f5b7,0x54873c88,2 +np.float32,0x7ce4e131,0x53f69ed4,2 +np.float32,0xbead8372,0xbf327b63,2 +np.float32,0x3e15ca7e,0x3f06e2f3,2 +np.float32,0xbf63e17b,0xbf7642da,2 +np.float32,0xff5bdbdb,0xd4c122f9,2 +np.float32,0x3f44411e,0x3f6a4bfd,2 +np.float32,0xfd007da0,0xd40029d2,2 +np.float32,0xbe940168,0xbf2944b7,2 +np.float32,0x80000000,0x80000000,2 +np.float32,0x3d28e356,0x3eb0e1b8,2 +np.float32,0x3eb9fcd8,0x3f36a918,2 +np.float32,0x4f6410,0x2a5a51eb,2 +np.float32,0xbdf18e30,0xbefb1775,2 +np.float32,0x32edbd,0x2a3c49e3,2 +np.float32,0x801f70a5,0xaa2052da,2 +np.float32,0x8045a045,0xaa50f98c,2 +np.float32,0xbdd6cb00,0xbef17412,2 +np.float32,0x3f118f2c,0x3f541557,2 +np.float32,0xbe65c378,0xbf1b8f95,2 +np.float32,0xfd9a9060,0xd42bbb8b,2 +np.float32,0x3f04244f,0x3f4d5b0f,2 +np.float32,0xff05214b,0xd4a3656f,2 +np.float32,0xfe342cd0,0xd463b706,2 +np.float32,0x3f3409a8,0x3f63a836,2 +np.float32,0x80205db2,0xaa21e1e5,2 +np.float32,0xbf37c982,0xbf653a03,2 +np.float32,0x3f36ce8f,0x3f64d17e,2 +np.float32,0x36ffda,0x2a412d61,2 +np.float32,0xff569752,0xd4bf94e6,2 +np.float32,0x802fdb0f,0xaa386c3a,2 +np.float32,0x7ec55a87,0x5493df71,2 +np.float32,0x7f2234c7,0x54ae847e,2 +np.float32,0xbf02df76,0xbf4cb23d,2 +np.float32,0x3d68731a,0x3ec4c156,2 +np.float32,0x8146,0x2921cd8e,2 +np.float32,0x80119364,0xaa041235,2 +np.float32,0xfe6c1c00,0xd47930b5,2 +np.float32,0x8070da44,0xaa757996,2 +np.float32,0xfefbf50c,0xd4a06a9d,2 +np.float32,0xbf01b6a8,0xbf4c170a,2 +np.float32,0x110702,0x2a02aedb,2 +np.float32,0xbf063cd4,0xbf4e6f87,2 +np.float32,0x3f1ff178,0x3f5ad9dd,2 +np.float32,0xbf76dcd4,0xbf7cead0,2 +np.float32,0x80527281,0xaa5d1620,2 +np.float32,0xfea96df8,0xd48c8a7f,2 +np.float32,0x68db02,0x2a6f88b0,2 +np.float32,0x62d971,0x2a6adec7,2 +np.float32,0x3e816fe0,0x3f21df04,2 +np.float32,0x3f586379,0x3f720cc0,2 +np.float32,0x804a3718,0xaa5577ff,2 +np.float32,0x2e2506,0x2a3632b2,2 +np.float32,0x3f297d,0x2a4a4bf3,2 +np.float32,0xbe37aba8,0xbf105f88,2 +np.float32,0xbf18b264,0xbf577ea7,2 +np.float32,0x7f50d02d,0x54bdd8b5,2 +np.float32,0xfee296dc,0xd49ad757,2 +np.float32,0x7ec5137e,0x5493cdb1,2 +np.float32,0x3f4811f4,0x3f6bce3a,2 +np.float32,0xfdff32a0,0xd44af991,2 +np.float32,0x3f6ef140,0x3f7a2ed6,2 +np.float32,0x250838,0x2a2950b5,2 +np.float32,0x25c28e,0x2a2a6ada,2 +np.float32,0xbe875e50,0xbf244e90,2 +np.float32,0x3e3bdff8,0x3f11776a,2 +np.float32,0x3e9fe493,0x3f2daf17,2 +np.float32,0x804d8599,0xaa5897d9,2 +np.float32,0x3f0533da,0x3f4de759,2 +np.float32,0xbe63023c,0xbf1aefc8,2 +np.float32,0x80636e5e,0xaa6b547f,2 +np.float32,0xff112958,0xd4a82d5d,2 +np.float32,0x3e924112,0x3f28991f,2 +np.float32,0xbe996ffc,0xbf2b507a,2 +np.float32,0x802a7cda,0xaa314081,2 +np.float32,0x8022b524,0xaa25b21e,2 +np.float32,0x3f0808c8,0x3f4f5a43,2 +np.float32,0xbef0ec2a,0xbf471e0b,2 +np.float32,0xff4c2345,0xd4bc6b3c,2 +np.float32,0x25ccc8,0x2a2a7a3b,2 +np.float32,0x7f4467d6,0x54ba0260,2 +np.float32,0x7f506539,0x54bdb846,2 +np.float32,0x412ab4,0x2a4c6a2a,2 +np.float32,0x80672c4a,0xaa6e3ef0,2 +np.float32,0xbddfb7f8,0xbef4c0ac,2 +np.float32,0xbf250bb9,0xbf5d276c,2 +np.float32,0x807dca65,0xaa7e84bd,2 +np.float32,0xbf63b8e0,0xbf763438,2 +np.float32,0xbeed1b0c,0xbf460f6b,2 +np.float32,0x8021594f,0xaa238136,2 +np.float32,0xbebc74c8,0xbf377710,2 +np.float32,0x3e9f8e3b,0x3f2d8fce,2 +np.float32,0x7f50ca09,0x54bdd6d8,2 +np.float32,0x805797c1,0xaa6197df,2 +np.float32,0x3de198f9,0x3ef56f98,2 +np.float32,0xf154d,0x29fb0392,2 +np.float32,0xff7fffff,0xd4cb2ff5,2 +np.float32,0xfed22fa8,0xd49702c4,2 +np.float32,0xbf733736,0xbf7baa64,2 +np.float32,0xbf206a8a,0xbf5b1108,2 +np.float32,0xbca49680,0xbe8b3078,2 +np.float32,0xfecba794,0xd4956e1a,2 +np.float32,0x80126582,0xaa061886,2 +np.float32,0xfee5cc82,0xd49b919f,2 +np.float32,0xbf7ad6ae,0xbf7e4491,2 +np.float32,0x7ea88c81,0x548c4c0c,2 +np.float32,0xbf493a0d,0xbf6c4255,2 +np.float32,0xbf06dda0,0xbf4ec1d4,2 +np.float32,0xff3f6e84,0xd4b86cf6,2 +np.float32,0x3e4fe093,0x3f1674b0,2 +np.float32,0x8048ad60,0xaa53fbde,2 +np.float32,0x7ebb7112,0x54915ac5,2 +np.float32,0x5bd191,0x2a652a0d,2 +np.float32,0xfe3121d0,0xd4626cfb,2 +np.float32,0x7e4421c6,0x546a3f83,2 +np.float32,0x19975b,0x2a15b14f,2 +np.float32,0x801c8087,0xaa1b2a64,2 +np.float32,0xfdf6e950,0xd448c0f6,2 +np.float32,0x74e711,0x2a786083,2 +np.float32,0xbf2b2f2e,0xbf5fdccb,2 +np.float32,0x7ed19ece,0x5496e00b,2 +np.float32,0x7f6f8322,0x54c6ba63,2 +np.float32,0x3e90316d,0x3f27cd69,2 +np.float32,0x7ecb42ce,0x54955571,2 +np.float32,0x3f6d49be,0x3f799aaf,2 +np.float32,0x8053d327,0xaa5e4f9a,2 +np.float32,0x7ebd7361,0x5491df3e,2 +np.float32,0xfdb6eed0,0xd435a7aa,2 +np.float32,0x7f3e79f4,0x54b81e4b,2 +np.float32,0xfe83afa6,0xd4813794,2 +np.float32,0x37c443,0x2a421246,2 +np.float32,0xff075a10,0xd4a44cd8,2 +np.float32,0x3ebc5fe0,0x3f377047,2 +np.float32,0x739694,0x2a77714e,2 +np.float32,0xfe832946,0xd4810b91,2 +np.float32,0x7f2638e6,0x54aff235,2 +np.float32,0xfe87f7a6,0xd4829a3f,2 +np.float32,0x3f50f3f8,0x3f6f3eb8,2 +np.float32,0x3eafa3d0,0x3f333548,2 +np.float32,0xbec26ee6,0xbf39626f,2 +np.float32,0x7e6f924f,0x547a66ff,2 +np.float32,0x7f0baa46,0x54a606f8,2 +np.float32,0xbf6dfc49,0xbf79d939,2 +np.float32,0x7f005709,0x54a1699d,2 +np.float32,0x7ee3d7ef,0x549b2057,2 +np.float32,0x803709a4,0xaa4138d7,2 +np.float32,0x3f7bf49a,0x3f7ea509,2 +np.float32,0x509db7,0x2a5b6ff5,2 +np.float32,0x7eb1b0d4,0x548ec9ff,2 +np.float32,0x7eb996ec,0x5490dfce,2 +np.float32,0xbf1fcbaa,0xbf5ac89e,2 +np.float32,0x3e2c9a98,0x3f0d69cc,2 +np.float32,0x3ea77994,0x3f306312,2 +np.float32,0x3f3cbfe4,0x3f67457c,2 +np.float32,0x8422a,0x29cd5a30,2 +np.float32,0xbd974558,0xbed6d264,2 +np.float32,0xfecee77a,0xd496387f,2 +np.float32,0x3f51876b,0x3f6f76f1,2 +np.float32,0x3b1a25,0x2a45ddad,2 +np.float32,0xfe9912f0,0xd487dd67,2 +np.float32,0x3f3ab13d,0x3f666d99,2 +np.float32,0xbf35565a,0xbf64341b,2 +np.float32,0x7d4e84aa,0x54162091,2 +np.float32,0x4c2570,0x2a574dea,2 +np.float32,0x7e82dca6,0x5480f26b,2 +np.float32,0x7f5503e7,0x54bf1c8d,2 +np.float32,0xbeb85034,0xbf361c59,2 +np.float32,0x80460a69,0xaa516387,2 +np.float32,0x805fbbab,0xaa68602c,2 +np.float32,0x7d4b4c1b,0x541557b8,2 +np.float32,0xbefa9a0a,0xbf49bfbc,2 +np.float32,0x3dbd233f,0x3ee76e09,2 +np.float32,0x58b6df,0x2a628d50,2 +np.float32,0xfcdcc180,0xd3f3aad9,2 +np.float32,0x423a37,0x2a4d8487,2 +np.float32,0xbed8b32a,0xbf403507,2 +np.float32,0x3f68e85d,0x3f780f0b,2 +np.float32,0x7ee13c4b,0x549a883d,2 +np.float32,0xff2ed4c5,0xd4b2eec1,2 +np.float32,0xbf54dadc,0xbf70b99a,2 +np.float32,0x3f78b0af,0x3f7d8a32,2 +np.float32,0x3f377372,0x3f651635,2 +np.float32,0xfdaa6178,0xd43166bc,2 +np.float32,0x8060c337,0xaa6934a6,2 +np.float32,0x7ec752c2,0x54945cf6,2 +np.float32,0xbd01a760,0xbea1f624,2 +np.float32,0x6f6599,0x2a746a35,2 +np.float32,0x3f6315b0,0x3f75f95b,2 +np.float32,0x7f2baf32,0x54b1da44,2 +np.float32,0x3e400353,0x3f1286d8,2 +np.float32,0x40d3bf,0x2a4c0f15,2 +np.float32,0x7f733aca,0x54c7c03d,2 +np.float32,0x7e5c5407,0x5473828b,2 +np.float32,0x80191703,0xaa14b56a,2 +np.float32,0xbf4fc144,0xbf6ec970,2 +np.float32,0xbf1137a7,0xbf53eacd,2 +np.float32,0x80575410,0xaa615db3,2 +np.float32,0xbd0911d0,0xbea4fe07,2 +np.float32,0x3e98534a,0x3f2ae643,2 +np.float32,0x3f3b089a,0x3f669185,2 +np.float32,0x4fc752,0x2a5aacc1,2 +np.float32,0xbef44ddc,0xbf480b6e,2 +np.float32,0x80464217,0xaa519af4,2 +np.float32,0x80445fae,0xaa4fb6de,2 +np.float32,0x80771cf4,0xaa79eec8,2 +np.float32,0xfd9182e8,0xd4284fed,2 +np.float32,0xff0a5d16,0xd4a58288,2 +np.float32,0x3f33e169,0x3f63973e,2 +np.float32,0x8021a247,0xaa23f820,2 +np.float32,0xbf362522,0xbf648ab8,2 +np.float32,0x3f457cd7,0x3f6ac95e,2 +np.float32,0xbcadf400,0xbe8dc7e2,2 +np.float32,0x80237210,0xaa26dca7,2 +np.float32,0xbf1293c9,0xbf54939f,2 +np.float32,0xbc5e73c0,0xbe744a37,2 +np.float32,0x3c03f980,0x3e4d44df,2 +np.float32,0x7da46f,0x2a7e6b20,2 +np.float32,0x5d4570,0x2a665dd0,2 +np.float32,0x3e93fbac,0x3f294287,2 +np.float32,0x7e6808fd,0x5477bfa4,2 +np.float32,0xff5aa9a6,0xd4c0c925,2 +np.float32,0xbf5206ba,0xbf6fa767,2 +np.float32,0xbf6e513e,0xbf79f6f1,2 +np.float32,0x3ed01c0f,0x3f3da20f,2 +np.float32,0xff47d93d,0xd4bb1704,2 +np.float32,0x7f466cfd,0x54baa514,2 +np.float32,0x665e10,0x2a6d9fc8,2 +np.float32,0x804d0629,0xaa5820e8,2 +np.float32,0x7e0beaa0,0x54514e7e,2 +np.float32,0xbf7fcb6c,0xbf7fee78,2 +np.float32,0x3f6c5b03,0x3f7946dd,2 +np.float32,0x3e941504,0x3f294c30,2 +np.float32,0xbf2749ad,0xbf5e26a1,2 +np.float32,0xfec2a00a,0xd493302d,2 +np.float32,0x3f15a358,0x3f560bce,2 +np.float32,0x3f15c4e7,0x3f561bcd,2 +np.float32,0xfedc8692,0xd499728c,2 +np.float32,0x7e8f6902,0x5484f180,2 +np.float32,0x7f663d62,0x54c42136,2 +np.float32,0x8027ea62,0xaa2d99b4,2 +np.float32,0x3f3d093d,0x3f67636d,2 +np.float32,0x7f118c33,0x54a85382,2 +np.float32,0x803e866a,0xaa499d43,2 +np.float32,0x80053632,0xa9b02407,2 +np.float32,0xbf36dd66,0xbf64d7af,2 +np.float32,0xbf560358,0xbf71292b,2 +np.float32,0x139a8,0x29596bc0,2 +np.float32,0xbe04f75c,0xbf01a26c,2 +np.float32,0xfe1c3268,0xd45920fa,2 +np.float32,0x7ec77f72,0x5494680c,2 +np.float32,0xbedde724,0xbf41bbba,2 +np.float32,0x3e81dbe0,0x3f220bfd,2 +np.float32,0x800373ac,0xa99989d4,2 +np.float32,0x3f7f859a,0x3f7fd72d,2 +np.float32,0x3eb9dc7e,0x3f369e80,2 +np.float32,0xff5f8eb7,0xd4c236b1,2 +np.float32,0xff1c03cb,0xd4ac44ac,2 +np.float32,0x18cfe1,0x2a14285b,2 +np.float32,0x7f21b075,0x54ae54fd,2 +np.float32,0xff490bd8,0xd4bb7680,2 +np.float32,0xbf15dc22,0xbf5626de,2 +np.float32,0xfe1d5a10,0xd459a9a3,2 +np.float32,0x750544,0x2a7875e4,2 +np.float32,0x8023d5df,0xaa2778b3,2 +np.float32,0x3e42aa08,0x3f1332b2,2 +np.float32,0x3ecaa751,0x3f3bf60d,2 +np.float32,0x0,0x0,2 +np.float32,0x80416da6,0xaa4cb011,2 +np.float32,0x3f4ea9ae,0x3f6e5e22,2 +np.float32,0x2113f4,0x2a230f8e,2 +np.float32,0x3f35c2e6,0x3f64619a,2 +np.float32,0xbf50db8a,0xbf6f3564,2 +np.float32,0xff4d5cea,0xd4bccb8a,2 +np.float32,0x7ee54420,0x549b72d2,2 +np.float32,0x64ee68,0x2a6c81f7,2 +np.float32,0x5330da,0x2a5dbfc2,2 +np.float32,0x80047f88,0xa9a7b467,2 +np.float32,0xbda01078,0xbedae800,2 +np.float32,0xfe96d05a,0xd487315f,2 +np.float32,0x8003cc10,0xa99e7ef4,2 +np.float32,0x8007b4ac,0xa9c8aa3d,2 +np.float32,0x5d4bcf,0x2a66630e,2 +np.float32,0xfdd0c0b0,0xd43dd403,2 +np.float32,0xbf7a1d82,0xbf7e05f0,2 +np.float32,0x74ca33,0x2a784c0f,2 +np.float32,0x804f45e5,0xaa5a3640,2 +np.float32,0x7e6d16aa,0x547988c4,2 +np.float32,0x807d5762,0xaa7e3714,2 +np.float32,0xfecf93d0,0xd4966229,2 +np.float32,0xfecbd25c,0xd4957890,2 +np.float32,0xff7db31c,0xd4ca93b0,2 +np.float32,0x3dac9e18,0x3ee07c4a,2 +np.float32,0xbf4b2d28,0xbf6d0509,2 +np.float32,0xbd4f4c50,0xbebd62e0,2 +np.float32,0xbd2eac40,0xbeb2e0ee,2 +np.float32,0x3d01b69b,0x3ea1fc7b,2 +np.float32,0x7ec63902,0x549416ed,2 +np.float32,0xfcc47700,0xd3ea616d,2 +np.float32,0xbf5ddec2,0xbf7413a1,2 +np.float32,0xff6a6110,0xd4c54c52,2 +np.float32,0xfdfae2a0,0xd449d335,2 +np.float32,0x7e54868c,0x547099cd,2 +np.float32,0x802b5b88,0xaa327413,2 +np.float32,0x80440e72,0xaa4f647a,2 +np.float32,0x3e313c94,0x3f0eaad5,2 +np.float32,0x3ebb492a,0x3f3715a2,2 +np.float32,0xbef56286,0xbf4856d5,2 +np.float32,0x3f0154ba,0x3f4be3a0,2 +np.float32,0xff2df86c,0xd4b2a376,2 +np.float32,0x3ef6a850,0x3f48af57,2 +np.float32,0x3d8d33e1,0x3ed1f22d,2 +np.float32,0x4dd9b9,0x2a58e615,2 +np.float32,0x7f1caf83,0x54ac83c9,2 +np.float32,0xbf7286b3,0xbf7b6d73,2 +np.float32,0x80064f88,0xa9bbbd9f,2 +np.float32,0xbf1f55fa,0xbf5a92db,2 +np.float32,0x546a81,0x2a5ed516,2 +np.float32,0xbe912880,0xbf282d0a,2 +np.float32,0x5df587,0x2a66ee6e,2 +np.float32,0x801f706c,0xaa205279,2 +np.float32,0x58cb6d,0x2a629ece,2 +np.float32,0xfe754f8c,0xd47c62da,2 +np.float32,0xbefb6f4c,0xbf49f8e7,2 +np.float32,0x80000001,0xa6a14518,2 +np.float32,0xbf067837,0xbf4e8df4,2 +np.float32,0x3e8e715c,0x3f271ee4,2 +np.float32,0x8009de9b,0xa9d9ebc8,2 +np.float32,0xbf371ff1,0xbf64f36e,2 +np.float32,0x7f5ce661,0x54c170e4,2 +np.float32,0x3f3c47d1,0x3f671467,2 +np.float32,0xfea5e5a6,0xd48b8eb2,2 +np.float32,0xff62b17f,0xd4c31e15,2 +np.float32,0xff315932,0xd4b3c98f,2 +np.float32,0xbf1c3ca8,0xbf5925b9,2 +np.float32,0x7f800000,0x7f800000,2 +np.float32,0xfdf20868,0xd4476c3b,2 +np.float32,0x5b790e,0x2a64e052,2 +np.float32,0x3f5ddf4e,0x3f7413d4,2 +np.float32,0x7f1a3182,0x54ab9861,2 +np.float32,0x3f4b906e,0x3f6d2b9d,2 +np.float32,0x7ebac760,0x54912edb,2 +np.float32,0x7f626d3f,0x54c30a7e,2 +np.float32,0x3e27b058,0x3f0c0edc,2 +np.float32,0x8041e69c,0xaa4d2de8,2 +np.float32,0x3f42cee0,0x3f69b84a,2 +np.float32,0x7ec5fe83,0x5494085b,2 +np.float32,0x9d3e6,0x29d99cde,2 +np.float32,0x3edc50c0,0x3f41452d,2 +np.float32,0xbf2c463a,0xbf60562c,2 +np.float32,0x800bfa33,0xa9e871e8,2 +np.float32,0x7c9f2c,0x2a7dba4d,2 +np.float32,0x7f2ef9fd,0x54b2fb73,2 +np.float32,0x80741847,0xaa77cdb9,2 +np.float32,0x7e9c462a,0x5488ce1b,2 +np.float32,0x3ea47ec1,0x3f2f55a9,2 +np.float32,0x7f311c43,0x54b3b4f5,2 +np.float32,0x3d8f4c73,0x3ed2facd,2 +np.float32,0x806d7bd2,0xaa7301ef,2 +np.float32,0xbf633d24,0xbf760799,2 +np.float32,0xff4f9a3f,0xd4bd7a99,2 +np.float32,0x3f6021ca,0x3f74e73d,2 +np.float32,0x7e447015,0x546a5eac,2 +np.float32,0x6bff3c,0x2a71e711,2 +np.float32,0xe9c9f,0x29f85f06,2 +np.float32,0x8009fe14,0xa9dad277,2 +np.float32,0x807cf79c,0xaa7df644,2 +np.float32,0xff440e1b,0xd4b9e608,2 +np.float32,0xbddf9a50,0xbef4b5db,2 +np.float32,0x7f3b1c39,0x54b706fc,2 +np.float32,0x3c7471a0,0x3e7c16a7,2 +np.float32,0x8065b02b,0xaa6d18ee,2 +np.float32,0x7f63a3b2,0x54c36379,2 +np.float32,0xbe9c9d92,0xbf2c7d33,2 +np.float32,0x3d93aad3,0x3ed51a2e,2 +np.float32,0xbf41b040,0xbf694571,2 +np.float32,0x80396b9e,0xaa43f899,2 +np.float64,0x800fa025695f404b,0xaaa4000ff64bb00c,2 +np.float64,0xbfecc00198f98003,0xbfeee0b623fbd94b,2 +np.float64,0x7f9eeb60b03dd6c0,0x55291bf8554bb303,2 +np.float64,0x3fba74485634e890,0x3fde08710bdb148d,2 +np.float64,0xbfdd9a75193b34ea,0xbfe8bf711660a2f5,2 +np.float64,0xbfcf92e17a3f25c4,0xbfe4119eda6f3773,2 +np.float64,0xbfe359e2ba66b3c6,0xbfeb0f7ae97ea142,2 +np.float64,0x20791a5640f24,0x2a9441f13d262bed,2 +np.float64,0x3fe455fbfae8abf8,0x3feb830d63e1022c,2 +np.float64,0xbd112b7b7a226,0x2aa238c097ec269a,2 +np.float64,0x93349ba126694,0x2aa0c363cd74465a,2 +np.float64,0x20300cd440602,0x2a9432b4f4081209,2 +np.float64,0x3fdcfae677b9f5cc,0x3fe892a9ee56fe8d,2 +np.float64,0xbfefaae3f7bf55c8,0xbfefe388066132c4,2 +np.float64,0x1a7d6eb634faf,0x2a92ed9851d29ab5,2 +np.float64,0x7fd5308d39aa6119,0x553be444e30326c6,2 +np.float64,0xff811c7390223900,0xd5205cb404952fa7,2 +np.float64,0x80083d24aff07a4a,0xaaa0285cf764d898,2 +np.float64,0x800633810ccc6703,0xaa9d65341419586b,2 +np.float64,0x800ff456223fe8ac,0xaaa423bbcc24dff1,2 +np.float64,0x7fde5c99aebcb932,0x553f71be7d6d9daa,2 +np.float64,0x3fed961c4b3b2c39,0x3fef2ca146270cac,2 +np.float64,0x7fe744d30c6e89a5,0x554220a4cdc78e62,2 +np.float64,0x3fd8f527c7b1ea50,0x3fe76101085be1cb,2 +np.float64,0xbfc96a14b232d428,0xbfe2ab1a8962606c,2 +np.float64,0xffe85f540cf0bea7,0xd54268dff964519a,2 +np.float64,0x800e3be0fe7c77c2,0xaaa3634efd7f020b,2 +np.float64,0x3feb90d032f721a0,0x3fee72a4579e8b12,2 +np.float64,0xffe05674aaa0ace9,0xd5401c9e3fb4abcf,2 +np.float64,0x3fefc2e32c3f85c6,0x3fefeb940924bf42,2 +np.float64,0xbfecfd89e9f9fb14,0xbfeef6addf73ee49,2 +np.float64,0xf5862717eb0c5,0x2aa3e1428780382d,2 +np.float64,0xffc3003b32260078,0xd53558f92202dcdb,2 +np.float64,0x3feb4c152c36982a,0x3fee5940f7da0825,2 +np.float64,0x3fe7147b002e28f6,0x3fecb2948f46d1e3,2 +np.float64,0x7fe00ad9b4a015b2,0x5540039d15e1da54,2 +np.float64,0x8010000000000000,0xaaa428a2f98d728b,2 +np.float64,0xbfd3a41bfea74838,0xbfe595ab45b1be91,2 +np.float64,0x7fdbfd6e5537fadc,0x553e9a6e1107b8d0,2 +np.float64,0x800151d9d9a2a3b4,0xaa918cd8fb63f40f,2 +np.float64,0x7fe6828401ad0507,0x5541eda05dcd1fcf,2 +np.float64,0x3fdae1e7a1b5c3d0,0x3fe7f711e72ecc35,2 +np.float64,0x7fdf4936133e926b,0x553fc29c8d5edea3,2 +np.float64,0x80079de12d4f3bc3,0xaa9f7b06a9286da4,2 +np.float64,0x3fe1261cade24c39,0x3fe9fe09488e417a,2 +np.float64,0xbfc20dce21241b9c,0xbfe0a842fb207a28,2 +np.float64,0x3fe3285dfa2650bc,0x3feaf85215f59ef9,2 +np.float64,0x7fe42b93aea85726,0x554148c3c3bb35e3,2 +np.float64,0xffe6c74e7f6d8e9c,0xd541ffd13fa36dbd,2 +np.float64,0x3fe73ea139ee7d42,0x3fecc402242ab7d3,2 +np.float64,0xffbd4b46be3a9690,0xd53392de917c72e4,2 +np.float64,0x800caed8df395db2,0xaaa2a811a02e6be4,2 +np.float64,0x800aacdb6c9559b7,0xaaa19d6fbc8feebf,2 +np.float64,0x839fb4eb073f7,0x2aa0264b98327c12,2 +np.float64,0xffd0157ba9a02af8,0xd5397157a11c0d05,2 +np.float64,0x7fddc8ff173b91fd,0x553f3e7663fb2ac7,2 +np.float64,0x67b365facf66d,0x2a9dd4d838b0d853,2 +np.float64,0xffe12e7fc7225cff,0xd5406272a83a8e1b,2 +np.float64,0x7fea5b19a034b632,0x5542e567658b3e36,2 +np.float64,0x124989d824932,0x2a90ba8dc7a39532,2 +np.float64,0xffe12ef098225de0,0xd54062968450a078,2 +np.float64,0x3fea2f44a3f45e8a,0x3fedee3c461f4716,2 +np.float64,0x3fe6b033e66d6068,0x3fec88c8035e06b1,2 +np.float64,0x3fe928a2ccf25146,0x3fed88d4cde7a700,2 +np.float64,0x3feead27e97d5a50,0x3fef8d7537d82e60,2 +np.float64,0x8003ab80b6875702,0xaa98adfedd7715a9,2 +np.float64,0x45a405828b481,0x2a9a1fa99a4eff1e,2 +np.float64,0x8002ddebad85bbd8,0xaa96babfda4e0031,2 +np.float64,0x3fc278c32824f186,0x3fe0c8e7c979fbd5,2 +np.float64,0x2e10fffc5c221,0x2a96c30a766d06fa,2 +np.float64,0xffd6ba8c2ead7518,0xd53c8d1d92bc2788,2 +np.float64,0xbfeb5ec3a036bd87,0xbfee602bbf0a0d01,2 +np.float64,0x3fed5bd58f7ab7ab,0x3fef181bf591a4a7,2 +np.float64,0x7feb5274a5b6a4e8,0x55431fcf81876218,2 +np.float64,0xaf8fd6cf5f1fb,0x2aa1c6edbb1e2aaf,2 +np.float64,0x7fece718f179ce31,0x55437c74efb90933,2 +np.float64,0xbfa3c42d0c278860,0xbfd5a16407c77e73,2 +np.float64,0x800b5cff0576b9fe,0xaaa1fc4ecb0dec4f,2 +np.float64,0x800be89ae557d136,0xaaa244d115fc0963,2 +np.float64,0x800d2578f5ba4af2,0xaaa2e18a3a3fc134,2 +np.float64,0x80090ff93e321ff3,0xaaa0add578e3cc3c,2 +np.float64,0x28c5a240518c,0x2a81587cccd7e202,2 +np.float64,0x7fec066929780cd1,0x55434971435d1069,2 +np.float64,0x7fc84d4d15309a99,0x55372c204515694f,2 +np.float64,0xffe070a75de0e14e,0xd54025365046dad2,2 +np.float64,0x7fe5b27cc36b64f9,0x5541b5b822f0b6ca,2 +np.float64,0x3fdea35ac8bd46b6,0x3fe9086a0fb792c2,2 +np.float64,0xbfe79996f7af332e,0xbfece9571d37a5b3,2 +np.float64,0xffdfb47f943f6900,0xd53fe6c14c3366db,2 +np.float64,0xc015cf63802ba,0x2aa2517164d075f4,2 +np.float64,0x7feba98948375312,0x5543340b5b1f1181,2 +np.float64,0x8008678e6550cf1d,0xaaa043e7cea90da5,2 +np.float64,0x3fb11b92fa223726,0x3fd9f8b53be4d90b,2 +np.float64,0x7fc9b18cf0336319,0x55379b42da882047,2 +np.float64,0xbfe5043e736a087d,0xbfebd0c67db7a8e3,2 +np.float64,0x7fde88546a3d10a8,0x553f80cfe5bcf5fe,2 +np.float64,0x8006a6c82dcd4d91,0xaa9e171d182ba049,2 +np.float64,0xbfa0f707ac21ee10,0xbfd48e5d3faa1699,2 +np.float64,0xbfe7716bffaee2d8,0xbfecd8e6abfb8964,2 +np.float64,0x9511ccab2a23a,0x2aa0d56d748f0313,2 +np.float64,0x8003ddb9b847bb74,0xaa991ca06fd9d308,2 +np.float64,0x80030710fac60e23,0xaa9725845ac95fe8,2 +np.float64,0xffece5bbaeb9cb76,0xd5437c2670f894f4,2 +np.float64,0x3fd9be5c72b37cb9,0x3fe79f2e932a5708,2 +np.float64,0x1f050cca3e0a3,0x2a93f36499fe5228,2 +np.float64,0x3fd5422becaa8458,0x3fe6295d6150df58,2 +np.float64,0xffd72c050e2e580a,0xd53cbc52d73b495f,2 +np.float64,0xbfe66d5235ecdaa4,0xbfec6ca27e60bf23,2 +np.float64,0x17ac49a42f58a,0x2a923b5b757087a0,2 +np.float64,0xffd39edc40273db8,0xd53b2f7bb99b96bf,2 +np.float64,0x7fde6cf009bcd9df,0x553f77614eb30d75,2 +np.float64,0x80042b4c3fa85699,0xaa99c05fbdd057db,2 +np.float64,0xbfde5547f8bcaa90,0xbfe8f3147d67a940,2 +np.float64,0xbfdd02f9bf3a05f4,0xbfe894f2048aa3fe,2 +np.float64,0xbfa20ec82c241d90,0xbfd4fd02ee55aac7,2 +np.float64,0x8002f670f8c5ece3,0xaa96fad7e53dd479,2 +np.float64,0x80059f24d7eb3e4a,0xaa9c7312dae0d7bc,2 +np.float64,0x7fe6ae7423ad5ce7,0x5541f9430be53062,2 +np.float64,0xe135ea79c26be,0x2aa350d8f8c526e1,2 +np.float64,0x3fec188ce4f8311a,0x3feea44d21c23f68,2 +np.float64,0x800355688286aad2,0xaa97e6ca51eb8357,2 +np.float64,0xa2d6530b45acb,0x2aa15635bbd366e8,2 +np.float64,0x600e0150c01c1,0x2a9d1456ea6c239c,2 +np.float64,0x8009c30863338611,0xaaa118f94b188bcf,2 +np.float64,0x3fe7e4c0dfefc982,0x3fed07e8480b8c07,2 +np.float64,0xbfddac6407bb58c8,0xbfe8c46f63a50225,2 +np.float64,0xbc85e977790bd,0x2aa2344636ed713d,2 +np.float64,0xfff0000000000000,0xfff0000000000000,2 +np.float64,0xffcd1570303a2ae0,0xd5389a27d5148701,2 +np.float64,0xbf937334d026e660,0xbfd113762e4e29a7,2 +np.float64,0x3fdbfdaa9b37fb55,0x3fe84a425fdff7df,2 +np.float64,0xffc10800f5221000,0xd5349535ffe12030,2 +np.float64,0xaf40f3755e81f,0x2aa1c443af16cd27,2 +np.float64,0x800f7da34f7efb47,0xaaa3f14bf25fc89f,2 +np.float64,0xffe4a60125a94c02,0xd5416b764a294128,2 +np.float64,0xbf8e25aa903c4b40,0xbfcf5ebc275b4789,2 +np.float64,0x3fca681bbb34d038,0x3fe2e882bcaee320,2 +np.float64,0xbfd0f3c9c1a1e794,0xbfe48d0df7b47572,2 +np.float64,0xffeb99b49d373368,0xd5433060dc641910,2 +np.float64,0x3fe554fb916aa9f8,0x3febf437cf30bd67,2 +np.float64,0x80079518d0af2a32,0xaa9f6ee87044745a,2 +np.float64,0x5e01a8a0bc036,0x2a9cdf0badf222c3,2 +np.float64,0xbfea9831b3f53064,0xbfee1601ee953ab3,2 +np.float64,0xbfc369d1a826d3a4,0xbfe110b675c311e0,2 +np.float64,0xa82e640d505cd,0x2aa1863d4e523b9c,2 +np.float64,0x3fe506d70a2a0dae,0x3febd1eba3aa83fa,2 +np.float64,0xcbacba7197598,0x2aa2adeb9927f1f2,2 +np.float64,0xc112d6038225b,0x2aa25978f12038b0,2 +np.float64,0xffa7f5f44c2febf0,0xd52d0ede02d4e18b,2 +np.float64,0x8006f218e34de433,0xaa9e870cf373b4eb,2 +np.float64,0xffe6d9a5d06db34b,0xd54204a4adc608c7,2 +np.float64,0x7fe717210eae2e41,0x554214bf3e2b5228,2 +np.float64,0xbfdd4b45cdba968c,0xbfe8a94c7f225f8e,2 +np.float64,0x883356571066b,0x2aa055ab0b2a8833,2 +np.float64,0x3fe307fc02a60ff8,0x3feae9175053288f,2 +np.float64,0x3fefa985f77f530c,0x3fefe31289446615,2 +np.float64,0x8005698a98aad316,0xaa9c17814ff7d630,2 +np.float64,0x3fea77333c74ee66,0x3fee098ba70e10fd,2 +np.float64,0xbfd1d00b0023a016,0xbfe4e497fd1cbea1,2 +np.float64,0x80009b0c39813619,0xaa8b130a6909cc3f,2 +np.float64,0x3fdbeb896fb7d714,0x3fe84502ba5437f8,2 +np.float64,0x3fb6e7e3562dcfc7,0x3fdca00d35c389ad,2 +np.float64,0xb2d46ebf65a8e,0x2aa1e2fe158d0838,2 +np.float64,0xbfd5453266aa8a64,0xbfe62a6a74c8ef6e,2 +np.float64,0x7fe993aa07732753,0x5542b5438bf31cb7,2 +np.float64,0xbfda5a098cb4b414,0xbfe7ce6d4d606203,2 +np.float64,0xbfe40c3ce068187a,0xbfeb61a32c57a6d0,2 +np.float64,0x3fcf17671d3e2ed0,0x3fe3f753170ab686,2 +np.float64,0xbfe4f814b6e9f02a,0xbfebcb67c60b7b08,2 +np.float64,0x800efedf59fdfdbf,0xaaa3ba4ed44ad45a,2 +np.float64,0x800420b556e8416b,0xaa99aa7fb14edeab,2 +np.float64,0xbf6e4ae6403c9600,0xbfc3cb2b29923989,2 +np.float64,0x3fda5c760a34b8ec,0x3fe7cf2821c52391,2 +np.float64,0x7f898faac0331f55,0x5522b44a01408188,2 +np.float64,0x3fd55af4b7aab5e9,0x3fe631f6d19503b3,2 +np.float64,0xbfa30a255c261450,0xbfd55caf0826361d,2 +np.float64,0x7fdfb801343f7001,0x553fe7ee50b9199a,2 +np.float64,0x7fa89ee91c313dd1,0x552d528ca2a4d659,2 +np.float64,0xffea72921d34e524,0xd542eb01af2e470d,2 +np.float64,0x3feddf0f33fbbe1e,0x3fef462b67fc0a91,2 +np.float64,0x3fe36700b566ce01,0x3feb1596caa8eff7,2 +np.float64,0x7fe6284a25ac5093,0x5541d58be3956601,2 +np.float64,0xffda16f7c8b42df0,0xd53de4f722485205,2 +np.float64,0x7f9355b94026ab72,0x552578cdeb41d2ca,2 +np.float64,0xffd3a9b022275360,0xd53b347b02dcea21,2 +np.float64,0x3fcb7f4f4a36fe9f,0x3fe32a40e9f6c1aa,2 +np.float64,0x7fdb958836372b0f,0x553e746103f92111,2 +np.float64,0x3fd37761c0a6eec4,0x3fe5853c5654027e,2 +np.float64,0x3fe449f1a2e893e4,0x3feb7d9e4eacc356,2 +np.float64,0x80077dfbef0efbf9,0xaa9f4ed788d2fadd,2 +np.float64,0x4823aa7890476,0x2a9a6eb4b653bad5,2 +np.float64,0xbfede01a373bc034,0xbfef468895fbcd29,2 +np.float64,0xbfe2bac5f125758c,0xbfeac4811c4dd66f,2 +np.float64,0x3fec10373af8206e,0x3feea14529e0f178,2 +np.float64,0x3fe305e30ca60bc6,0x3feae81a2f9d0302,2 +np.float64,0xa9668c5f52cd2,0x2aa1910e3a8f2113,2 +np.float64,0xbfd98b1717b3162e,0xbfe78f75995335d2,2 +np.float64,0x800fa649c35f4c94,0xaaa402ae79026a8f,2 +np.float64,0xbfb07dacf620fb58,0xbfd9a7d33d93a30f,2 +np.float64,0x80015812f382b027,0xaa91a843e9c85c0e,2 +np.float64,0x3fc687d96c2d0fb3,0x3fe1ef0ac16319c5,2 +np.float64,0xbfecad2ecd795a5e,0xbfeed9f786697af0,2 +np.float64,0x1608c1242c119,0x2a91cd11e9b4ccd2,2 +np.float64,0x6df775e8dbeef,0x2a9e6ba8c71130eb,2 +np.float64,0xffe96e9332b2dd26,0xd542ac342d06299b,2 +np.float64,0x7fecb6a3b8396d46,0x5543718af8162472,2 +np.float64,0x800d379f893a6f3f,0xaaa2ea36bbcb9308,2 +np.float64,0x3f924cdb202499b6,0x3fd0bb90af8d1f79,2 +np.float64,0x0,0x0,2 +np.float64,0x7feaf3b365f5e766,0x5543099a160e2427,2 +np.float64,0x3fea169ed0742d3e,0x3fede4d526e404f8,2 +np.float64,0x7feaf5f2f775ebe5,0x55430a2196c5f35a,2 +np.float64,0xbfc80d4429301a88,0xbfe2541f2ddd3334,2 +np.float64,0xffc75203b32ea408,0xd536db2837068689,2 +np.float64,0xffed2850e63a50a1,0xd5438b1217b72b8a,2 +np.float64,0x7fc16b0e7f22d61c,0x5534bcd0bfddb6f0,2 +np.float64,0x7feee8ed09fdd1d9,0x5543ed5b3ca483ab,2 +np.float64,0x7fb6c7ee662d8fdc,0x5531fffb5d46dafb,2 +np.float64,0x3fd77cebf8aef9d8,0x3fe6e9242e2bd29d,2 +np.float64,0x3f81c33f70238680,0x3fca4c7f3c9848f7,2 +np.float64,0x3fd59fea92ab3fd5,0x3fe649c1558cadd5,2 +np.float64,0xffeba82d4bf7505a,0xd54333bad387f7bd,2 +np.float64,0xffd37630e1a6ec62,0xd53b1ca62818c670,2 +np.float64,0xffec2c1e70b8583c,0xd5435213dcd27c22,2 +np.float64,0x7fec206971f840d2,0x55434f6660a8ae41,2 +np.float64,0x3fed2964adba52c9,0x3fef0642fe72e894,2 +np.float64,0xffd08e30d6211c62,0xd539b060e0ae02da,2 +np.float64,0x3e5f976c7cbf4,0x2a992e6ff991a122,2 +np.float64,0xffe6eee761adddce,0xd5420a393c67182f,2 +np.float64,0xbfe8ec9a31f1d934,0xbfed714426f58147,2 +np.float64,0x7fefffffffffffff,0x554428a2f98d728b,2 +np.float64,0x3fb3ae8b2c275d16,0x3fdb36b81b18a546,2 +np.float64,0x800f73df4dfee7bf,0xaaa3ed1a3e2cf49c,2 +np.float64,0xffd0c8873b21910e,0xd539ce6a3eab5dfd,2 +np.float64,0x3facd6c49439ad80,0x3fd8886f46335df1,2 +np.float64,0x3935859c726b2,0x2a98775f6438dbb1,2 +np.float64,0x7feed879fbfdb0f3,0x5543e9d1ac239469,2 +np.float64,0xbfe84dd990f09bb3,0xbfed323af09543b1,2 +np.float64,0xbfe767cc5a6ecf98,0xbfecd4f39aedbacb,2 +np.float64,0xffd8bd91d5b17b24,0xd53d5eb3734a2609,2 +np.float64,0xbfe13edeb2a27dbe,0xbfea0a856f0b9656,2 +np.float64,0xd933dd53b267c,0x2aa3158784e428c9,2 +np.float64,0xbfef6fef987edfdf,0xbfefcfb1c160462b,2 +np.float64,0x8009eeda4893ddb5,0xaaa13268a41045b1,2 +np.float64,0xab48c7a156919,0x2aa1a1a9c124c87d,2 +np.float64,0xa997931d532f3,0x2aa192bfe5b7bbb4,2 +np.float64,0xffe39ce8b1e739d1,0xd5411fa1c5c2cbd8,2 +np.float64,0x7e7ac2f6fcf59,0x2a9fdf6f263a9e9f,2 +np.float64,0xbfee1e35a6fc3c6b,0xbfef5c25d32b4047,2 +np.float64,0xffe5589c626ab138,0xd5419d220cc9a6da,2 +np.float64,0x7fe12509bf224a12,0x55405f7036dc5932,2 +np.float64,0xa6f15ba94de2c,0x2aa17b3367b1fc1b,2 +np.float64,0x3fca8adbfa3515b8,0x3fe2f0ca775749e5,2 +np.float64,0xbfcb03aa21360754,0xbfe30d5b90ca41f7,2 +np.float64,0x3fefafb2da7f5f66,0x3fefe5251aead4e7,2 +np.float64,0xffd90a59d23214b4,0xd53d7cf63a644f0e,2 +np.float64,0x3fba499988349333,0x3fddf84154fab7e5,2 +np.float64,0x800a76a0bc54ed42,0xaaa17f68cf67f2fa,2 +np.float64,0x3fea33d15bb467a3,0x3fedeff7f445b2ff,2 +np.float64,0x8005d9b0726bb362,0xaa9cd48624afeca9,2 +np.float64,0x7febf42e9a77e85c,0x55434541d8073376,2 +np.float64,0xbfedfc4469bbf889,0xbfef505989f7ee7d,2 +np.float64,0x8001211f1422423f,0xaa90a9889d865349,2 +np.float64,0x800e852f7fdd0a5f,0xaaa3845f11917f8e,2 +np.float64,0xffefd613c87fac27,0xd5441fd17ec669b4,2 +np.float64,0x7fed2a74543a54e8,0x55438b8c637da8b8,2 +np.float64,0xb83d50ff707aa,0x2aa210b4fc11e4b2,2 +np.float64,0x10000000000000,0x2aa428a2f98d728b,2 +np.float64,0x474ad9208e97,0x2a84e5a31530368a,2 +np.float64,0xffd0c5498ea18a94,0xd539ccc0e5cb425e,2 +np.float64,0x8001a8e9c82351d4,0xaa92f1aee6ca5b7c,2 +np.float64,0xd28db1e5a51b6,0x2aa2e328c0788f4a,2 +np.float64,0x3bf734ac77ee7,0x2a98da65c014b761,2 +np.float64,0x3fe56e17c96adc30,0x3febff2b6b829b7a,2 +np.float64,0x7783113eef063,0x2a9f46c3f09eb42c,2 +np.float64,0x3fd69d4e42ad3a9d,0x3fe69f83a21679f4,2 +np.float64,0x3fd34f4841a69e90,0x3fe5766b3c771616,2 +np.float64,0x3febb49895b76931,0x3fee7fcb603416c9,2 +np.float64,0x7fe8d6cb55f1ad96,0x554286c3b3bf4313,2 +np.float64,0xbfe67c6ba36cf8d8,0xbfec730218f2e284,2 +np.float64,0xffef9d97723f3b2e,0xd54413e38b6c29be,2 +np.float64,0x12d8cd2a25b1b,0x2a90e5ccd37b8563,2 +np.float64,0x81fe019103fc0,0x2aa01524155e73c5,2 +np.float64,0x7fe95d546f72baa8,0x5542a7fabfd425ff,2 +np.float64,0x800e742f1f9ce85e,0xaaa37cbe09e1f874,2 +np.float64,0xffd96bd3a732d7a8,0xd53da3086071264a,2 +np.float64,0x4ef2691e9de4e,0x2a9b3d316047fd6d,2 +np.float64,0x1a91684c3522e,0x2a92f25913c213de,2 +np.float64,0x3d5151b87aa2b,0x2a9909dbd9a44a84,2 +np.float64,0x800d9049435b2093,0xaaa31424e32d94a2,2 +np.float64,0xffe5b25fcc2b64bf,0xd541b5b0416b40b5,2 +np.float64,0xffe0eb784c21d6f0,0xd5404d083c3d6bc6,2 +np.float64,0x8007ceefbf0f9de0,0xaa9fbe0d739368b4,2 +np.float64,0xb78529416f0b,0x2a8ca3b29b5b3f18,2 +np.float64,0x7fba61130034c225,0x5532e6d4ca0f2918,2 +np.float64,0x3fba8d67ae351acf,0x3fde11efd6239b09,2 +np.float64,0x3fe7f24c576fe498,0x3fed0d63947a854d,2 +np.float64,0x2bb58dec576b3,0x2a965de7fca12aff,2 +np.float64,0xbfe86ceec4f0d9de,0xbfed3ea7f1d084e2,2 +np.float64,0x7fd1a7f7bca34fee,0x553a3f01b67fad2a,2 +np.float64,0x3fd9a43acfb34874,0x3fe7972dc5d8dfd6,2 +np.float64,0x7fd9861acdb30c35,0x553dad3b1bbb3b4d,2 +np.float64,0xffecc0c388398186,0xd54373d3b903deec,2 +np.float64,0x3fa6f86e9c2df0e0,0x3fd6bdbe40fcf710,2 +np.float64,0x800ddd99815bbb33,0xaaa33820d2f889bb,2 +np.float64,0x7fe087089b610e10,0x55402c868348a6d3,2 +np.float64,0x3fdf43d249be87a5,0x3fe933d29fbf7c23,2 +np.float64,0x7fe4f734c7a9ee69,0x5541822e56c40725,2 +np.float64,0x3feb39a9d3b67354,0x3fee526bf1f69f0e,2 +np.float64,0x3fe61454a0ec28a9,0x3fec46d7c36f7566,2 +np.float64,0xbfeafaa0a375f541,0xbfee3af2e49d457a,2 +np.float64,0x3fda7378e1b4e6f0,0x3fe7d613a3f92c40,2 +np.float64,0xe3e31c5fc7c64,0x2aa3645c12e26171,2 +np.float64,0xbfe97a556df2f4ab,0xbfeda8aa84cf3544,2 +np.float64,0xff612f9c80225f00,0xd514a51e5a2a8a97,2 +np.float64,0x800c51c8a0f8a391,0xaaa279fe7d40b50b,2 +np.float64,0xffd6f9d2312df3a4,0xd53ca783a5f8d110,2 +np.float64,0xbfead48bd7f5a918,0xbfee2cb2f89c5e57,2 +np.float64,0x800f5949e89eb294,0xaaa3e1a67a10cfef,2 +np.float64,0x800faf292b7f5e52,0xaaa40675e0c96cfd,2 +np.float64,0xbfedc238453b8470,0xbfef3c179d2d0209,2 +np.float64,0x3feb0443c5760888,0x3fee3e8bf29089c2,2 +np.float64,0xb26f69e164ded,0x2aa1df9f3dd7d765,2 +np.float64,0x3fcacdc053359b80,0x3fe300a67765b667,2 +np.float64,0x3fe8b274647164e8,0x3fed5a4cd4da8155,2 +np.float64,0x291e6782523ce,0x2a95ea7ac1b13a68,2 +np.float64,0xbfc4fc094e29f814,0xbfe1838671fc8513,2 +np.float64,0x3fbf1301f23e2600,0x3fdfb03a6f13e597,2 +np.float64,0xffeb36554ab66caa,0xd543193d8181e4f9,2 +np.float64,0xbfd969a52db2d34a,0xbfe78528ae61f16d,2 +np.float64,0x800cccd04d3999a1,0xaaa2b6b7a2d2d2d6,2 +np.float64,0x808eb4cb011d7,0x2aa005effecb2b4a,2 +np.float64,0x7fe839b3f9b07367,0x55425f61e344cd6d,2 +np.float64,0xbfeb25b6ed764b6e,0xbfee4b0234fee365,2 +np.float64,0xffefffffffffffff,0xd54428a2f98d728b,2 +np.float64,0xbfe01305da60260c,0xbfe9700b784af7e9,2 +np.float64,0xffcbf36b0a37e6d8,0xd538474b1d74ffe1,2 +np.float64,0xffaeebe3e83dd7c0,0xd52fa2e8dabf7209,2 +np.float64,0xbfd9913bf0b32278,0xbfe7915907aab13c,2 +np.float64,0xbfe7d125d9efa24c,0xbfecfff563177706,2 +np.float64,0xbfee98d23cbd31a4,0xbfef867ae393e446,2 +np.float64,0x3fe30efb67e61df6,0x3feaec6344633d11,2 +np.float64,0x1,0x2990000000000000,2 +np.float64,0x7fd5524fd3aaa49f,0x553bf30d18ab877e,2 +np.float64,0xc98b403f93168,0x2aa29d2fadb13c07,2 +np.float64,0xffe57080046ae100,0xd541a3b1b687360e,2 +np.float64,0x7fe20bade5e4175b,0x5540a79b94294f40,2 +np.float64,0x3fe155400a22aa80,0x3fea15c45f5b5837,2 +np.float64,0x7fe428dc8f6851b8,0x554147fd2ce93cc1,2 +np.float64,0xffefb77eb67f6efc,0xd544195dcaff4980,2 +np.float64,0x3fe49e733b293ce6,0x3feba394b833452a,2 +np.float64,0x38e01e3e71c05,0x2a986b2c955bad21,2 +np.float64,0x7fe735eb376e6bd5,0x55421cc51290d92d,2 +np.float64,0xbfd81d8644b03b0c,0xbfe71ce6d6fbd51a,2 +np.float64,0x8009a32325134647,0xaaa10645d0e6b0d7,2 +np.float64,0x56031ab8ac064,0x2a9c074be40b1f80,2 +np.float64,0xff8989aa30331340,0xd522b2d319a0ac6e,2 +np.float64,0xbfd6c183082d8306,0xbfe6ab8ffb3a8293,2 +np.float64,0x7ff8000000000000,0x7ff8000000000000,2 +np.float64,0xbfe17b68b1e2f6d2,0xbfea28dac8e0c457,2 +np.float64,0x3fbb50e42236a1c8,0x3fde5b090d51e3bd,2 +np.float64,0xffc2bb7cbf2576f8,0xd5353f1b3571c17f,2 +np.float64,0xbfe7576bca6eaed8,0xbfecce388241f47c,2 +np.float64,0x3fe7b52b04ef6a56,0x3fecf495bef99e7e,2 +np.float64,0xffe5511af82aa236,0xd5419b11524e8350,2 +np.float64,0xbfe66d5edf2cdabe,0xbfec6ca7d7b5be8c,2 +np.float64,0xc84a0ba790942,0x2aa29346f16a2cb4,2 +np.float64,0x6db5e7a0db6be,0x2a9e659c0e8244a0,2 +np.float64,0x7fef8f7b647f1ef6,0x554410e67af75d27,2 +np.float64,0xbfe2b4ada7e5695c,0xbfeac1997ec5a064,2 +np.float64,0xbfe99372e03326e6,0xbfedb2662b287543,2 +np.float64,0x3fa45d352428ba6a,0x3fd5d8a895423abb,2 +np.float64,0x3fa029695c2052d3,0x3fd439f858998886,2 +np.float64,0xffe0a9bd3261537a,0xd54037d0cd8bfcda,2 +np.float64,0xbfef83e09a7f07c1,0xbfefd66a4070ce73,2 +np.float64,0x7fee3dcc31fc7b97,0x5543c8503869407e,2 +np.float64,0xffbd16f1603a2de0,0xd533872fa5be978b,2 +np.float64,0xbfe8173141b02e62,0xbfed1c478614c6f4,2 +np.float64,0xbfef57aa277eaf54,0xbfefc77fdab27771,2 +np.float64,0x7fe883a02f31073f,0x554271ff0e3208da,2 +np.float64,0xe3adb63bc75b7,0x2aa362d833d0e41c,2 +np.float64,0x8001c430bac38862,0xaa93575026d26510,2 +np.float64,0x12fb347225f67,0x2a90f00eb9edb3fe,2 +np.float64,0x3fe53f83cbaa7f08,0x3febead40de452c2,2 +np.float64,0xbfe7f67227efece4,0xbfed0f10e32ad220,2 +np.float64,0xb8c5b45d718b7,0x2aa2152912cda86d,2 +np.float64,0x3fd23bb734a4776e,0x3fe50e5d3008c095,2 +np.float64,0x8001fd558ee3faac,0xaa941faa1f7ed450,2 +np.float64,0xffe6bbeda9ed77db,0xd541fcd185a63afa,2 +np.float64,0x4361d79086c3c,0x2a99d692237c30b7,2 +np.float64,0xbfd012f004a025e0,0xbfe43093e290fd0d,2 +np.float64,0xffe1d8850423b10a,0xd54097cf79d8d01e,2 +np.float64,0x3fccf4df7939e9bf,0x3fe37f8cf8be6436,2 +np.float64,0x8000546bc6c0a8d8,0xaa861bb3588556f2,2 +np.float64,0xbfecb4d6ba7969ae,0xbfeedcb6239135fe,2 +np.float64,0xbfaeb425cc3d6850,0xbfd90cfc103bb896,2 +np.float64,0x800ec037ec7d8070,0xaaa39eae8bde9774,2 +np.float64,0xbfeeaf863dfd5f0c,0xbfef8e4514772a8a,2 +np.float64,0xffec67c6c4b8cf8d,0xd5435fad89f900cf,2 +np.float64,0x3fda4498da348932,0x3fe7c7f6b3f84048,2 +np.float64,0xbfd05fd3dea0bfa8,0xbfe4509265a9b65f,2 +np.float64,0x3fe42cc713a8598e,0x3feb706ba9cd533c,2 +np.float64,0xec22d4d7d845b,0x2aa39f8cccb9711c,2 +np.float64,0x7fda30606c3460c0,0x553deea865065196,2 +np.float64,0xbfd58cba8bab1976,0xbfe64327ce32d611,2 +np.float64,0xadd521c75baa4,0x2aa1b7efce201a98,2 +np.float64,0x7fed43c1027a8781,0x55439131832b6429,2 +np.float64,0x800bee278fb7dc4f,0xaaa247a71e776db4,2 +np.float64,0xbfe9be5dd2737cbc,0xbfedc2f9501755b0,2 +np.float64,0x8003f4854447e90b,0xaa994d9b5372b13b,2 +np.float64,0xbfe5d0f867eba1f1,0xbfec29f8dd8b33a4,2 +np.float64,0x3fd79102d5af2206,0x3fe6efaa7a1efddb,2 +np.float64,0xbfeae783c835cf08,0xbfee33cdb4a44e81,2 +np.float64,0x3fcf1713e83e2e28,0x3fe3f7414753ddfb,2 +np.float64,0xffe5ab3cff2b567a,0xd541b3bf0213274a,2 +np.float64,0x7fe0fc65d8a1f8cb,0x554052761ac96386,2 +np.float64,0x7e81292efd026,0x2a9fdff8c01ae86f,2 +np.float64,0x80091176039222ec,0xaaa0aebf0565dfa6,2 +np.float64,0x800d2bf5ab5a57ec,0xaaa2e4a4c31e7e29,2 +np.float64,0xffd1912ea923225e,0xd53a33b2856726ab,2 +np.float64,0x800869918ed0d323,0xaaa0453408e1295d,2 +np.float64,0xffba0898fa341130,0xd532d19b202a9646,2 +np.float64,0xbfe09fac29613f58,0xbfe9b9687b5811a1,2 +np.float64,0xbfbd4ae82e3a95d0,0xbfdf1220f6f0fdfa,2 +np.float64,0xffea11d27bb423a4,0xd542d3d3e1522474,2 +np.float64,0xbfe6b05705ad60ae,0xbfec88d6bcab2683,2 +np.float64,0x3fe624a3f2ec4948,0x3fec4dcc78ddf871,2 +np.float64,0x53483018a6907,0x2a9bba8f92006b69,2 +np.float64,0xbfec0a6eeb7814de,0xbfee9f2a741248d7,2 +np.float64,0x3fe8c8ce6371919d,0x3fed63250c643482,2 +np.float64,0xbfe26b0ef964d61e,0xbfea9e511db83437,2 +np.float64,0xffa0408784208110,0xd52987f62c369ae9,2 +np.float64,0xffc153abc322a758,0xd534b384b5c5fe63,2 +np.float64,0xbfbdce88a63b9d10,0xbfdf4065ef0b01d4,2 +np.float64,0xffed4a4136fa9482,0xd54392a450f8b0af,2 +np.float64,0x8007aa18748f5432,0xaa9f8bd2226d4299,2 +np.float64,0xbfdab4d3e8b569a8,0xbfe7e9a5402540e5,2 +np.float64,0x7fe68914f92d1229,0x5541ef5e78fa35de,2 +np.float64,0x800a538bb1b4a718,0xaaa16bc487711295,2 +np.float64,0xffe02edbc8605db7,0xd5400f8f713df890,2 +np.float64,0xffe8968053712d00,0xd54276b9cc7f460a,2 +np.float64,0x800a4ce211d499c5,0xaaa1680491deb40c,2 +np.float64,0x3f988080f8310102,0x3fd2713691e99329,2 +np.float64,0xf64e42a7ec9c9,0x2aa3e6a7af780878,2 +np.float64,0xff73cc7100279900,0xd51b4478c3409618,2 +np.float64,0x71e6722ce3ccf,0x2a9ec76ddf296ce0,2 +np.float64,0x8006ca16ab0d942e,0xaa9e4bfd862af570,2 +np.float64,0x8000000000000000,0x8000000000000000,2 +np.float64,0xbfed373e02ba6e7c,0xbfef0b2b7bb767b3,2 +np.float64,0xa6cb0f694d962,0x2aa179dd16b0242b,2 +np.float64,0x7fec14626cf828c4,0x55434ca55b7c85d5,2 +np.float64,0x3fcda404513b4808,0x3fe3a68e8d977752,2 +np.float64,0xbfeb94995f772933,0xbfee74091d288b81,2 +np.float64,0x3fce2299a13c4530,0x3fe3c2603f28d23b,2 +np.float64,0xffd07f4534a0fe8a,0xd539a8a6ebc5a603,2 +np.float64,0x7fdb1c651e3638c9,0x553e478a6385c86b,2 +np.float64,0x3fec758336f8eb06,0x3feec5f3b92c8b28,2 +np.float64,0x796fc87cf2dfa,0x2a9f7184a4ad8c49,2 +np.float64,0x3fef9ba866ff3750,0x3fefde6a446fc2cd,2 +np.float64,0x964d26c72c9a5,0x2aa0e143f1820179,2 +np.float64,0xbfef6af750bed5ef,0xbfefce04870a97bd,2 +np.float64,0x3fe2f3961aa5e72c,0x3feadf769321a3ff,2 +np.float64,0xbfd6b706e9ad6e0e,0xbfe6a8141c5c3b5d,2 +np.float64,0x7fe0ecc40a21d987,0x55404d72c2b46a82,2 +np.float64,0xbfe560d19deac1a3,0xbfebf962681a42a4,2 +np.float64,0xbfea37170ab46e2e,0xbfedf136ee9df02b,2 +np.float64,0xbfebf78947b7ef12,0xbfee9847ef160257,2 +np.float64,0x800551f8312aa3f1,0xaa9bee7d3aa5491b,2 +np.float64,0xffed2513897a4a26,0xd5438a58c4ae28ec,2 +np.float64,0x7fd962d75cb2c5ae,0x553d9f8a0c2016f3,2 +np.float64,0x3fefdd8512bfbb0a,0x3feff47d8da7424d,2 +np.float64,0xbfefa5b43bff4b68,0xbfefe1ca42867af0,2 +np.float64,0xbfc8a2853531450c,0xbfe279bb7b965729,2 +np.float64,0x800c8843bc391088,0xaaa2951344e7b29b,2 +np.float64,0x7fe22587bae44b0e,0x5540af8bb58cfe86,2 +np.float64,0xbfe159fae822b3f6,0xbfea182394eafd8d,2 +np.float64,0xbfe6fdfd50edfbfa,0xbfeca93f2a3597d0,2 +np.float64,0xbfe5cd5afaeb9ab6,0xbfec286a8ce0470f,2 +np.float64,0xbfc84bb97f309774,0xbfe263ef0f8f1f6e,2 +np.float64,0x7fd9c1e548b383ca,0x553dc4556874ecb9,2 +np.float64,0x7fda43d33bb487a5,0x553df60f61532fc0,2 +np.float64,0xbfe774bd25eee97a,0xbfecda42e8578c1f,2 +np.float64,0x800df1f5ab9be3ec,0xaaa34184712e69db,2 +np.float64,0xbff0000000000000,0xbff0000000000000,2 +np.float64,0x3fe14ec21b629d84,0x3fea128244215713,2 +np.float64,0x7fc1ce7843239cf0,0x5534e3fa8285b7b8,2 +np.float64,0xbfe922b204724564,0xbfed86818687d649,2 +np.float64,0x3fc58924fb2b1248,0x3fe1aa715ff6ebbf,2 +np.float64,0x8008b637e4d16c70,0xaaa0760b53abcf46,2 +np.float64,0xffbf55bd4c3eab78,0xd53404a23091a842,2 +np.float64,0x9f6b4a753ed6a,0x2aa136ef9fef9596,2 +np.float64,0xbfd11da7f8a23b50,0xbfe49deb493710d8,2 +np.float64,0x800a2f07fcd45e10,0xaaa157237c98b4f6,2 +np.float64,0x3fdd4defa4ba9bdf,0x3fe8aa0bcf895f4f,2 +np.float64,0x7fe9b0ab05f36155,0x5542bc5335414473,2 +np.float64,0x3fe89c97de313930,0x3fed51a1189b8982,2 +np.float64,0x3fdd45c8773a8b91,0x3fe8a7c2096fbf5a,2 +np.float64,0xbfeb6f64daf6deca,0xbfee665167ef43ad,2 +np.float64,0xffdf9da1c4bf3b44,0xd53fdf141944a983,2 +np.float64,0x3fde092ed0bc125c,0x3fe8de25bfbfc2db,2 +np.float64,0xbfcb21f96b3643f4,0xbfe3147904c258cf,2 +np.float64,0x800c9c934f993927,0xaaa29f17c43f021b,2 +np.float64,0x9b91814d37230,0x2aa11329e59bf6b0,2 +np.float64,0x3fe28a7e0b6514fc,0x3feaad6d23e2eadd,2 +np.float64,0xffecf38395f9e706,0xd5437f3ee1cd61e4,2 +np.float64,0x3fcade92a935bd25,0x3fe3049f4c1da1d0,2 +np.float64,0x800ab25d95d564bc,0xaaa1a076d7c66e04,2 +np.float64,0xffc0989e1e21313c,0xd53467f3b8158298,2 +np.float64,0x3fd81523eeb02a48,0x3fe71a38d2da8a82,2 +np.float64,0x7fe5b9dd402b73ba,0x5541b7b9b8631010,2 +np.float64,0x2c160d94582c3,0x2a966e51b503a3d1,2 +np.float64,0x2c416ffa5882f,0x2a9675aaef8b29c4,2 +np.float64,0x7fefe2ff01bfc5fd,0x55442289faf22b86,2 +np.float64,0xbfd469bf5d28d37e,0xbfe5dd239ffdc7eb,2 +np.float64,0xbfdd56f3eabaade8,0xbfe8ac93244ca17b,2 +np.float64,0xbfe057b89160af71,0xbfe9941557340bb3,2 +np.float64,0x800c50e140b8a1c3,0xaaa2798ace9097ee,2 +np.float64,0xbfda5a8984b4b514,0xbfe7ce93d65a56b0,2 +np.float64,0xbfcd6458323ac8b0,0xbfe39872514127bf,2 +np.float64,0x3fefb1f5ebff63ec,0x3fefe5e761b49b89,2 +np.float64,0x3fea3abc1df47578,0x3fedf29a1c997863,2 +np.float64,0x7fcb4a528e3694a4,0x553815f169667213,2 +np.float64,0x8c77da7b18efc,0x2aa080e52bdedb54,2 +np.float64,0x800e5dde4c5cbbbd,0xaaa372b16fd8b1ad,2 +np.float64,0x3fd2976038a52ec0,0x3fe5316b4f79fdbc,2 +np.float64,0x69413a0ed2828,0x2a9dfacd9cb44286,2 +np.float64,0xbfebbac0bdb77582,0xbfee820d9288b631,2 +np.float64,0x1a12aa7c34256,0x2a92d407e073bbfe,2 +np.float64,0xbfc41a27c3283450,0xbfe143c8665b0d3c,2 +np.float64,0xffe4faa41369f548,0xd54183230e0ce613,2 +np.float64,0xbfdeae81f23d5d04,0xbfe90b734bf35b68,2 +np.float64,0x3fc984ba58330975,0x3fe2b19e9052008e,2 +np.float64,0x7fe6e51b8d2dca36,0x554207a74ae2bb39,2 +np.float64,0x80081a58a81034b2,0xaaa0117d4aff11c8,2 +np.float64,0x7fde3fddfe3c7fbb,0x553f67d0082acc67,2 +np.float64,0x3fac7c999038f933,0x3fd86ec2f5dc3aa4,2 +np.float64,0x7fa26b4c4c24d698,0x552a9e6ea8545c18,2 +np.float64,0x3fdacd06e6b59a0e,0x3fe7f0dc0e8f9c6d,2 +np.float64,0x80064b62cbec96c6,0xaa9d8ac0506fdd05,2 +np.float64,0xb858116170b1,0x2a8caea703d9ccc8,2 +np.float64,0xbfe8d94ccef1b29a,0xbfed69a8782cbf3d,2 +np.float64,0x8005607d6a6ac0fc,0xaa9c07cf8620b037,2 +np.float64,0xbfe66a52daacd4a6,0xbfec6b5e403e6864,2 +np.float64,0x7fc398c2e0273185,0x5535918245894606,2 +np.float64,0x74b2d7dce965c,0x2a9f077020defdbc,2 +np.float64,0x7fe8f7a4d9b1ef49,0x55428eeae210e8eb,2 +np.float64,0x80027deddc84fbdc,0xaa95b11ff9089745,2 +np.float64,0xffeba2a94e774552,0xd5433273f6568902,2 +np.float64,0x80002f8259405f05,0xaa8240b68d7b9dc4,2 +np.float64,0xbfdf0d84883e1b0a,0xbfe92532c69c5802,2 +np.float64,0xbfcdfa7b6b3bf4f8,0xbfe3b997a84d0914,2 +np.float64,0x800c18b04e183161,0xaaa25d46d60b15c6,2 +np.float64,0xffeaf1e37c35e3c6,0xd543092cd929ac19,2 +np.float64,0xbfc5aa07752b5410,0xbfe1b36ab5ec741f,2 +np.float64,0x3fe5c491d1eb8924,0x3fec24a1c3f6a178,2 +np.float64,0xbfeb736937f6e6d2,0xbfee67cd296e6fa9,2 +np.float64,0xffec3d5718787aad,0xd5435602e1a2cc43,2 +np.float64,0x7fe71e1da86e3c3a,0x55421691ead882cb,2 +np.float64,0x3fdd6ed0c93adda2,0x3fe8b341d066c43c,2 +np.float64,0x7fbe3d7a203c7af3,0x5533c83e53283430,2 +np.float64,0x3fdc20cb56384197,0x3fe854676360aba9,2 +np.float64,0xb7a1ac636f436,0x2aa20b9d40d66e78,2 +np.float64,0x3fb1491bb8229237,0x3fda0fabad1738ee,2 +np.float64,0xbfdf9c0ce73f381a,0xbfe94b716dbe35ee,2 +np.float64,0xbfbd4f0ad23a9e18,0xbfdf1397329a2dce,2 +np.float64,0xbfe4e0caac69c196,0xbfebc119b8a181cd,2 +np.float64,0x5753641aaea6d,0x2a9c2ba3e92b0cd2,2 +np.float64,0x72bb814ae5771,0x2a9eda92fada66de,2 +np.float64,0x57ed8f5aafdb3,0x2a9c3c2e1d42e609,2 +np.float64,0xffec33359c38666a,0xd54353b2acd0daf1,2 +np.float64,0x3fa5fe6e8c2bfce0,0x3fd66a0b3bf2720a,2 +np.float64,0xffe2dc8d7ca5b91a,0xd540e6ebc097d601,2 +np.float64,0x7fd99d260eb33a4b,0x553db626c9c75f78,2 +np.float64,0xbfe2dd73e425bae8,0xbfead4fc4b93a727,2 +np.float64,0xdcd4a583b9a95,0x2aa33094c9a17ad7,2 +np.float64,0x7fb0af6422215ec7,0x553039a606e8e64f,2 +np.float64,0x7fdfab6227bf56c3,0x553fe3b26164aeda,2 +np.float64,0x1e4d265e3c9a6,0x2a93cba8a1a8ae6d,2 +np.float64,0xbfdc7d097238fa12,0xbfe86ee2f24fd473,2 +np.float64,0x7fe5d35d29eba6b9,0x5541bea5878bce2b,2 +np.float64,0xffcb886a903710d4,0xd53828281710aab5,2 +np.float64,0xffe058c7ffe0b190,0xd5401d61e9a7cbcf,2 +np.float64,0x3ff0000000000000,0x3ff0000000000000,2 +np.float64,0xffd5b1c1132b6382,0xd53c1c839c098340,2 +np.float64,0x3fe2e7956725cf2b,0x3fead9c907b9d041,2 +np.float64,0x800a8ee293951dc6,0xaaa18ce3f079f118,2 +np.float64,0x7febcd3085b79a60,0x55433c47e1f822ad,2 +np.float64,0x3feb0e14cd761c2a,0x3fee423542102546,2 +np.float64,0x3fb45e6d0628bcda,0x3fdb86db67d0c992,2 +np.float64,0x7fa836e740306dce,0x552d2907cb8118b2,2 +np.float64,0x3fd15ba25b22b745,0x3fe4b6b018409d78,2 +np.float64,0xbfb59980ce2b3300,0xbfdc1206274cb51d,2 +np.float64,0x3fdef1b87fbde371,0x3fe91dafc62124a1,2 +np.float64,0x7fed37a4337a6f47,0x55438e7e0b50ae37,2 +np.float64,0xffe6c87633ad90ec,0xd542001f216ab448,2 +np.float64,0x8008d2548ab1a4a9,0xaaa087ad272d8e17,2 +np.float64,0xbfd1d6744da3ace8,0xbfe4e71965adda74,2 +np.float64,0xbfb27f751224fee8,0xbfdaa82132775406,2 +np.float64,0x3fe2b336ae65666d,0x3feac0e6b13ec2d2,2 +np.float64,0xffc6bac2262d7584,0xd536a951a2eecb49,2 +np.float64,0x7fdb661321b6cc25,0x553e62dfd7fcd3f3,2 +np.float64,0xffe83567d5706acf,0xd5425e4bb5027568,2 +np.float64,0xbf7f0693e03e0d00,0xbfc9235314d53f82,2 +np.float64,0x3feb32b218766564,0x3fee4fd5847f3722,2 +np.float64,0x3fec25d33df84ba6,0x3feea91fcd4aebab,2 +np.float64,0x7fe17abecb22f57d,0x55407a8ba661207c,2 +np.float64,0xbfe5674b1eeace96,0xbfebfc351708dc70,2 +np.float64,0xbfe51a2d2f6a345a,0xbfebda702c9d302a,2 +np.float64,0x3fec05584af80ab0,0x3fee9d502a7bf54d,2 +np.float64,0xffda8871dcb510e4,0xd53e10105f0365b5,2 +np.float64,0xbfc279c31824f388,0xbfe0c9354d871484,2 +np.float64,0x1cbed61e397dc,0x2a937364712cd518,2 +np.float64,0x800787d198af0fa4,0xaa9f5c847affa1d2,2 +np.float64,0x80079f6d65af3edc,0xaa9f7d2863368bbd,2 +np.float64,0xb942f1e97285e,0x2aa2193e0c513b7f,2 +np.float64,0x7fe9078263320f04,0x554292d85dee2c18,2 +np.float64,0xbfe4de0761a9bc0f,0xbfebbfe04116b829,2 +np.float64,0xbfdbe6f3fc37cde8,0xbfe843aea59a0749,2 +np.float64,0xffcb6c0de136d81c,0xd5381fd9c525b813,2 +np.float64,0x9b6bda9336d7c,0x2aa111c924c35386,2 +np.float64,0x3fe17eece422fdda,0x3fea2a9bacd78607,2 +np.float64,0xd8011c49b0024,0x2aa30c87574fc0c6,2 +np.float64,0xbfc0a08b3f214118,0xbfe034d48f0d8dc0,2 +np.float64,0x3fd60adb1eac15b8,0x3fe66e42e4e7e6b5,2 +np.float64,0x80011d68ea023ad3,0xaa909733befbb962,2 +np.float64,0xffb35ac32426b588,0xd5310c4be1c37270,2 +np.float64,0x3fee8b56c9bd16ae,0x3fef81d8d15f6939,2 +np.float64,0x3fdc10a45e382149,0x3fe84fbe4cf11e68,2 +np.float64,0xbfc85dc45e30bb88,0xbfe2687b5518abde,2 +np.float64,0x3fd53b85212a770a,0x3fe6270d6d920d0f,2 +np.float64,0x800fc158927f82b1,0xaaa40e303239586f,2 +np.float64,0x11af5e98235ed,0x2a908b04a790083f,2 +np.float64,0xbfe2a097afe54130,0xbfeab80269eece99,2 +np.float64,0xbfd74ac588ae958c,0xbfe6d8ca3828d0b8,2 +np.float64,0xffea18ab2ef43156,0xd542d579ab31df1e,2 +np.float64,0xbfecda7058f9b4e1,0xbfeeea29c33b7913,2 +np.float64,0x3fc4ac56ed2958b0,0x3fe16d3e2bd7806d,2 +np.float64,0x3feccc898cb99913,0x3feee531f217dcfa,2 +np.float64,0xffeb3a64c5b674c9,0xd5431a30a41f0905,2 +np.float64,0x3fe5a7ee212b4fdc,0x3fec1844af9076fc,2 +np.float64,0x80080fdb52301fb7,0xaaa00a8b4274db67,2 +np.float64,0x800b3e7e47d67cfd,0xaaa1ec2876959852,2 +np.float64,0x80063fb8ee2c7f73,0xaa9d7875c9f20d6f,2 +np.float64,0x7fdacf80d0b59f01,0x553e2acede4c62a8,2 +np.float64,0x401e9b24803d4,0x2a996a0a75d0e093,2 +np.float64,0x3fe6c29505ed852a,0x3fec907a6d8c10af,2 +np.float64,0x8005c04ee2cb809f,0xaa9caa9813faef46,2 +np.float64,0xbfe1360f21e26c1e,0xbfea06155d6985b6,2 +np.float64,0xffc70606682e0c0c,0xd536c239b9d4be0a,2 +np.float64,0x800e639afefcc736,0xaaa37547d0229a26,2 +np.float64,0x3fe5589290aab125,0x3febf5c925c4e6db,2 +np.float64,0x8003b59330276b27,0xaa98c47e44524335,2 +np.float64,0x800d67ec22dacfd8,0xaaa301251b6a730a,2 +np.float64,0x7fdaeb5025b5d69f,0x553e35397dfe87eb,2 +np.float64,0x3fdae32a24b5c654,0x3fe7f771bc108f6c,2 +np.float64,0xffe6c1fc93ad83f8,0xd541fe6a6a716756,2 +np.float64,0xbfd7b9c1d32f7384,0xbfe6fcdae563d638,2 +np.float64,0x800e1bea06fc37d4,0xaaa354c0bf61449c,2 +np.float64,0xbfd78f097aaf1e12,0xbfe6ef068329bdf4,2 +np.float64,0x7fea6a400874d47f,0x5542e905978ad722,2 +np.float64,0x8008b4377cb1686f,0xaaa074c87eee29f9,2 +np.float64,0x8002f3fb8d45e7f8,0xaa96f47ac539b614,2 +np.float64,0xbfcf2b3fd13e5680,0xbfe3fb91c0cc66ad,2 +np.float64,0xffecca2f5279945e,0xd54375f361075927,2 +np.float64,0x7ff0000000000000,0x7ff0000000000000,2 +np.float64,0x7f84d5a5a029ab4a,0x552178d1d4e8640e,2 +np.float64,0x3fea8a4b64351497,0x3fee10c332440eb2,2 +np.float64,0x800fe01ac1dfc036,0xaaa41b34d91a4bee,2 +np.float64,0x3fc0b3d8872167b1,0x3fe03b178d354f8d,2 +np.float64,0x5ee8b0acbdd17,0x2a9cf69f2e317729,2 +np.float64,0x8006ef0407adde09,0xaa9e82888f3dd83e,2 +np.float64,0x7fdbb08a07b76113,0x553e7e4e35b938b9,2 +np.float64,0x49663f9c92cc9,0x2a9a95e0affe5108,2 +np.float64,0x7fd9b87e79b370fc,0x553dc0b5cff3dc7d,2 +np.float64,0xbfd86ae657b0d5cc,0xbfe73584d02bdd2b,2 +np.float64,0x3fd4d4a13729a942,0x3fe6030a962aaaf8,2 +np.float64,0x7fcc246bcb3848d7,0x5538557309449bba,2 +np.float64,0xbfdc86a7d5b90d50,0xbfe871a2983c2a29,2 +np.float64,0xd2a6e995a54dd,0x2aa2e3e9c0fdd6c0,2 +np.float64,0x3f92eb447825d680,0x3fd0eb4fd2ba16d2,2 +np.float64,0x800d4001697a8003,0xaaa2ee358661b75c,2 +np.float64,0x3fd3705fd1a6e0c0,0x3fe582a6f321d7d6,2 +np.float64,0xbfcfdf51533fbea4,0xbfe421c3bdd9f2a3,2 +np.float64,0x3fe268e87964d1d1,0x3fea9d47e08aad8a,2 +np.float64,0x24b8901e49713,0x2a951adeefe7b31b,2 +np.float64,0x3fedb35d687b66bb,0x3fef36e440850bf8,2 +np.float64,0x3fb7ab5cbe2f56c0,0x3fdcf097380721c6,2 +np.float64,0x3f8c4eaa10389d54,0x3fceb7ecb605b73b,2 +np.float64,0xbfed831ed6fb063e,0xbfef25f462a336f1,2 +np.float64,0x7fd8c52112318a41,0x553d61b0ee609f58,2 +np.float64,0xbfe71c4ff76e38a0,0xbfecb5d32e789771,2 +np.float64,0xbfe35fb7b166bf70,0xbfeb12328e75ee6b,2 +np.float64,0x458e1a3a8b1c4,0x2a9a1cebadc81342,2 +np.float64,0x8003c1b3ad478368,0xaa98df5ed060b28c,2 +np.float64,0x7ff4000000000000,0x7ffc000000000000,2 +np.float64,0x7fe17098c162e131,0x5540775a9a3a104f,2 +np.float64,0xbfd95cb71732b96e,0xbfe7812acf7ea511,2 +np.float64,0x8000000000000001,0xa990000000000000,2 +np.float64,0xbfde0e7d9ebc1cfc,0xbfe8df9ca9e49a5b,2 +np.float64,0xffef4f67143e9ecd,0xd5440348a6a2f231,2 +np.float64,0x7fe37d23c826fa47,0x5541165de17caa03,2 +np.float64,0xbfcc0e5f85381cc0,0xbfe34b44b0deefe9,2 +np.float64,0x3fe858f1c470b1e4,0x3fed36ab90557d89,2 +np.float64,0x800e857278fd0ae5,0xaaa3847d13220545,2 +np.float64,0x3febd31a66f7a635,0x3fee8af90e66b043,2 +np.float64,0x7fd3fde1b127fbc2,0x553b5b186a49b968,2 +np.float64,0x3fd3dabb8b27b577,0x3fe5a99b446bed26,2 +np.float64,0xffeb4500f1768a01,0xd5431cab828e254a,2 +np.float64,0xffccca8fc6399520,0xd53884f8b505e79e,2 +np.float64,0xffeee9406b7dd280,0xd543ed6d27a1a899,2 +np.float64,0xffecdde0f0f9bbc1,0xd5437a6258b14092,2 +np.float64,0xe6b54005cd6a8,0x2aa378c25938dfda,2 +np.float64,0x7fe610f1022c21e1,0x5541cf460b972925,2 +np.float64,0xbfe5a170ec6b42e2,0xbfec1576081e3232,2 diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/data/umath-validation-set-cos.csv b/venv/lib/python3.12/site-packages/numpy/_core/tests/data/umath-validation-set-cos.csv new file mode 100644 index 00000000..258ae48c --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/tests/data/umath-validation-set-cos.csv @@ -0,0 +1,1375 @@ +dtype,input,output,ulperrortol +## +ve denormals ## +np.float32,0x004b4716,0x3f800000,2 +np.float32,0x007b2490,0x3f800000,2 +np.float32,0x007c99fa,0x3f800000,2 +np.float32,0x00734a0c,0x3f800000,2 +np.float32,0x0070de24,0x3f800000,2 +np.float32,0x007fffff,0x3f800000,2 +np.float32,0x00000001,0x3f800000,2 +## -ve denormals ## +np.float32,0x80495d65,0x3f800000,2 +np.float32,0x806894f6,0x3f800000,2 +np.float32,0x80555a76,0x3f800000,2 +np.float32,0x804e1fb8,0x3f800000,2 +np.float32,0x80687de9,0x3f800000,2 +np.float32,0x807fffff,0x3f800000,2 +np.float32,0x80000001,0x3f800000,2 +## +/-0.0f, +/-FLT_MIN +/-FLT_MAX ## +np.float32,0x00000000,0x3f800000,2 +np.float32,0x80000000,0x3f800000,2 +np.float32,0x00800000,0x3f800000,2 +np.float32,0x80800000,0x3f800000,2 +## 1.00f + 0x00000001 ## +np.float32,0x3f800000,0x3f0a5140,2 +np.float32,0x3f800001,0x3f0a513f,2 +np.float32,0x3f800002,0x3f0a513d,2 +np.float32,0xc090a8b0,0xbe4332ce,2 +np.float32,0x41ce3184,0x3f4d1de1,2 +np.float32,0xc1d85848,0xbeaa8980,2 +np.float32,0x402b8820,0xbf653aa3,2 +np.float32,0x42b4e454,0xbf4a338b,2 +np.float32,0x42a67a60,0x3c58202e,2 +np.float32,0x41d92388,0xbed987c7,2 +np.float32,0x422dd66c,0x3f5dcab3,2 +np.float32,0xc28f5be6,0xbf5688d8,2 +np.float32,0x41ab2674,0xbf53aa3b,2 +np.float32,0x3f490fdb,0x3f3504f3,2 +np.float32,0xbf490fdb,0x3f3504f3,2 +np.float32,0x3fc90fdb,0xb33bbd2e,2 +np.float32,0xbfc90fdb,0xb33bbd2e,2 +np.float32,0x40490fdb,0xbf800000,2 +np.float32,0xc0490fdb,0xbf800000,2 +np.float32,0x3fc90fdb,0xb33bbd2e,2 +np.float32,0xbfc90fdb,0xb33bbd2e,2 +np.float32,0x40490fdb,0xbf800000,2 +np.float32,0xc0490fdb,0xbf800000,2 +np.float32,0x40c90fdb,0x3f800000,2 +np.float32,0xc0c90fdb,0x3f800000,2 +np.float32,0x4016cbe4,0xbf3504f3,2 +np.float32,0xc016cbe4,0xbf3504f3,2 +np.float32,0x4096cbe4,0x324cde2e,2 +np.float32,0xc096cbe4,0x324cde2e,2 +np.float32,0x4116cbe4,0xbf800000,2 +np.float32,0xc116cbe4,0xbf800000,2 +np.float32,0x40490fdb,0xbf800000,2 +np.float32,0xc0490fdb,0xbf800000,2 +np.float32,0x40c90fdb,0x3f800000,2 +np.float32,0xc0c90fdb,0x3f800000,2 +np.float32,0x41490fdb,0x3f800000,2 +np.float32,0xc1490fdb,0x3f800000,2 +np.float32,0x407b53d2,0xbf3504f1,2 +np.float32,0xc07b53d2,0xbf3504f1,2 +np.float32,0x40fb53d2,0xb4b5563d,2 +np.float32,0xc0fb53d2,0xb4b5563d,2 +np.float32,0x417b53d2,0xbf800000,2 +np.float32,0xc17b53d2,0xbf800000,2 +np.float32,0x4096cbe4,0x324cde2e,2 +np.float32,0xc096cbe4,0x324cde2e,2 +np.float32,0x4116cbe4,0xbf800000,2 +np.float32,0xc116cbe4,0xbf800000,2 +np.float32,0x4196cbe4,0x3f800000,2 +np.float32,0xc196cbe4,0x3f800000,2 +np.float32,0x40afede0,0x3f3504f7,2 +np.float32,0xc0afede0,0x3f3504f7,2 +np.float32,0x412fede0,0x353222c4,2 +np.float32,0xc12fede0,0x353222c4,2 +np.float32,0x41afede0,0xbf800000,2 +np.float32,0xc1afede0,0xbf800000,2 +np.float32,0x40c90fdb,0x3f800000,2 +np.float32,0xc0c90fdb,0x3f800000,2 +np.float32,0x41490fdb,0x3f800000,2 +np.float32,0xc1490fdb,0x3f800000,2 +np.float32,0x41c90fdb,0x3f800000,2 +np.float32,0xc1c90fdb,0x3f800000,2 +np.float32,0x40e231d6,0x3f3504f3,2 +np.float32,0xc0e231d6,0x3f3504f3,2 +np.float32,0x416231d6,0xb319a6a2,2 +np.float32,0xc16231d6,0xb319a6a2,2 +np.float32,0x41e231d6,0xbf800000,2 +np.float32,0xc1e231d6,0xbf800000,2 +np.float32,0x40fb53d2,0xb4b5563d,2 +np.float32,0xc0fb53d2,0xb4b5563d,2 +np.float32,0x417b53d2,0xbf800000,2 +np.float32,0xc17b53d2,0xbf800000,2 +np.float32,0x41fb53d2,0x3f800000,2 +np.float32,0xc1fb53d2,0x3f800000,2 +np.float32,0x410a3ae7,0xbf3504fb,2 +np.float32,0xc10a3ae7,0xbf3504fb,2 +np.float32,0x418a3ae7,0x35b08908,2 +np.float32,0xc18a3ae7,0x35b08908,2 +np.float32,0x420a3ae7,0xbf800000,2 +np.float32,0xc20a3ae7,0xbf800000,2 +np.float32,0x4116cbe4,0xbf800000,2 +np.float32,0xc116cbe4,0xbf800000,2 +np.float32,0x4196cbe4,0x3f800000,2 +np.float32,0xc196cbe4,0x3f800000,2 +np.float32,0x4216cbe4,0x3f800000,2 +np.float32,0xc216cbe4,0x3f800000,2 +np.float32,0x41235ce2,0xbf3504ef,2 +np.float32,0xc1235ce2,0xbf3504ef,2 +np.float32,0x41a35ce2,0xb53889b6,2 +np.float32,0xc1a35ce2,0xb53889b6,2 +np.float32,0x42235ce2,0xbf800000,2 +np.float32,0xc2235ce2,0xbf800000,2 +np.float32,0x412fede0,0x353222c4,2 +np.float32,0xc12fede0,0x353222c4,2 +np.float32,0x41afede0,0xbf800000,2 +np.float32,0xc1afede0,0xbf800000,2 +np.float32,0x422fede0,0x3f800000,2 +np.float32,0xc22fede0,0x3f800000,2 +np.float32,0x413c7edd,0x3f3504f4,2 +np.float32,0xc13c7edd,0x3f3504f4,2 +np.float32,0x41bc7edd,0x33800add,2 +np.float32,0xc1bc7edd,0x33800add,2 +np.float32,0x423c7edd,0xbf800000,2 +np.float32,0xc23c7edd,0xbf800000,2 +np.float32,0x41490fdb,0x3f800000,2 +np.float32,0xc1490fdb,0x3f800000,2 +np.float32,0x41c90fdb,0x3f800000,2 +np.float32,0xc1c90fdb,0x3f800000,2 +np.float32,0x42490fdb,0x3f800000,2 +np.float32,0xc2490fdb,0x3f800000,2 +np.float32,0x4155a0d9,0x3f3504eb,2 +np.float32,0xc155a0d9,0x3f3504eb,2 +np.float32,0x41d5a0d9,0xb5b3bc81,2 +np.float32,0xc1d5a0d9,0xb5b3bc81,2 +np.float32,0x4255a0d9,0xbf800000,2 +np.float32,0xc255a0d9,0xbf800000,2 +np.float32,0x416231d6,0xb319a6a2,2 +np.float32,0xc16231d6,0xb319a6a2,2 +np.float32,0x41e231d6,0xbf800000,2 +np.float32,0xc1e231d6,0xbf800000,2 +np.float32,0x426231d6,0x3f800000,2 +np.float32,0xc26231d6,0x3f800000,2 +np.float32,0x416ec2d4,0xbf3504f7,2 +np.float32,0xc16ec2d4,0xbf3504f7,2 +np.float32,0x41eec2d4,0x353ef0a7,2 +np.float32,0xc1eec2d4,0x353ef0a7,2 +np.float32,0x426ec2d4,0xbf800000,2 +np.float32,0xc26ec2d4,0xbf800000,2 +np.float32,0x417b53d2,0xbf800000,2 +np.float32,0xc17b53d2,0xbf800000,2 +np.float32,0x41fb53d2,0x3f800000,2 +np.float32,0xc1fb53d2,0x3f800000,2 +np.float32,0x427b53d2,0x3f800000,2 +np.float32,0xc27b53d2,0x3f800000,2 +np.float32,0x4183f268,0xbf3504e7,2 +np.float32,0xc183f268,0xbf3504e7,2 +np.float32,0x4203f268,0xb6059a13,2 +np.float32,0xc203f268,0xb6059a13,2 +np.float32,0x4283f268,0xbf800000,2 +np.float32,0xc283f268,0xbf800000,2 +np.float32,0x418a3ae7,0x35b08908,2 +np.float32,0xc18a3ae7,0x35b08908,2 +np.float32,0x420a3ae7,0xbf800000,2 +np.float32,0xc20a3ae7,0xbf800000,2 +np.float32,0x428a3ae7,0x3f800000,2 +np.float32,0xc28a3ae7,0x3f800000,2 +np.float32,0x41908365,0x3f3504f0,2 +np.float32,0xc1908365,0x3f3504f0,2 +np.float32,0x42108365,0xb512200d,2 +np.float32,0xc2108365,0xb512200d,2 +np.float32,0x42908365,0xbf800000,2 +np.float32,0xc2908365,0xbf800000,2 +np.float32,0x4196cbe4,0x3f800000,2 +np.float32,0xc196cbe4,0x3f800000,2 +np.float32,0x4216cbe4,0x3f800000,2 +np.float32,0xc216cbe4,0x3f800000,2 +np.float32,0x4296cbe4,0x3f800000,2 +np.float32,0xc296cbe4,0x3f800000,2 +np.float32,0x419d1463,0x3f3504ef,2 +np.float32,0xc19d1463,0x3f3504ef,2 +np.float32,0x421d1463,0xb5455799,2 +np.float32,0xc21d1463,0xb5455799,2 +np.float32,0x429d1463,0xbf800000,2 +np.float32,0xc29d1463,0xbf800000,2 +np.float32,0x41a35ce2,0xb53889b6,2 +np.float32,0xc1a35ce2,0xb53889b6,2 +np.float32,0x42235ce2,0xbf800000,2 +np.float32,0xc2235ce2,0xbf800000,2 +np.float32,0x42a35ce2,0x3f800000,2 +np.float32,0xc2a35ce2,0x3f800000,2 +np.float32,0x41a9a561,0xbf3504ff,2 +np.float32,0xc1a9a561,0xbf3504ff,2 +np.float32,0x4229a561,0x360733d0,2 +np.float32,0xc229a561,0x360733d0,2 +np.float32,0x42a9a561,0xbf800000,2 +np.float32,0xc2a9a561,0xbf800000,2 +np.float32,0x41afede0,0xbf800000,2 +np.float32,0xc1afede0,0xbf800000,2 +np.float32,0x422fede0,0x3f800000,2 +np.float32,0xc22fede0,0x3f800000,2 +np.float32,0x42afede0,0x3f800000,2 +np.float32,0xc2afede0,0x3f800000,2 +np.float32,0x41b6365e,0xbf3504f6,2 +np.float32,0xc1b6365e,0xbf3504f6,2 +np.float32,0x4236365e,0x350bb91c,2 +np.float32,0xc236365e,0x350bb91c,2 +np.float32,0x42b6365e,0xbf800000,2 +np.float32,0xc2b6365e,0xbf800000,2 +np.float32,0x41bc7edd,0x33800add,2 +np.float32,0xc1bc7edd,0x33800add,2 +np.float32,0x423c7edd,0xbf800000,2 +np.float32,0xc23c7edd,0xbf800000,2 +np.float32,0x42bc7edd,0x3f800000,2 +np.float32,0xc2bc7edd,0x3f800000,2 +np.float32,0x41c2c75c,0x3f3504f8,2 +np.float32,0xc1c2c75c,0x3f3504f8,2 +np.float32,0x4242c75c,0x354bbe8a,2 +np.float32,0xc242c75c,0x354bbe8a,2 +np.float32,0x42c2c75c,0xbf800000,2 +np.float32,0xc2c2c75c,0xbf800000,2 +np.float32,0x41c90fdb,0x3f800000,2 +np.float32,0xc1c90fdb,0x3f800000,2 +np.float32,0x42490fdb,0x3f800000,2 +np.float32,0xc2490fdb,0x3f800000,2 +np.float32,0x42c90fdb,0x3f800000,2 +np.float32,0xc2c90fdb,0x3f800000,2 +np.float32,0x41cf585a,0x3f3504e7,2 +np.float32,0xc1cf585a,0x3f3504e7,2 +np.float32,0x424f585a,0xb608cd8c,2 +np.float32,0xc24f585a,0xb608cd8c,2 +np.float32,0x42cf585a,0xbf800000,2 +np.float32,0xc2cf585a,0xbf800000,2 +np.float32,0x41d5a0d9,0xb5b3bc81,2 +np.float32,0xc1d5a0d9,0xb5b3bc81,2 +np.float32,0x4255a0d9,0xbf800000,2 +np.float32,0xc255a0d9,0xbf800000,2 +np.float32,0x42d5a0d9,0x3f800000,2 +np.float32,0xc2d5a0d9,0x3f800000,2 +np.float32,0x41dbe958,0xbf350507,2 +np.float32,0xc1dbe958,0xbf350507,2 +np.float32,0x425be958,0x365eab75,2 +np.float32,0xc25be958,0x365eab75,2 +np.float32,0x42dbe958,0xbf800000,2 +np.float32,0xc2dbe958,0xbf800000,2 +np.float32,0x41e231d6,0xbf800000,2 +np.float32,0xc1e231d6,0xbf800000,2 +np.float32,0x426231d6,0x3f800000,2 +np.float32,0xc26231d6,0x3f800000,2 +np.float32,0x42e231d6,0x3f800000,2 +np.float32,0xc2e231d6,0x3f800000,2 +np.float32,0x41e87a55,0xbf3504ef,2 +np.float32,0xc1e87a55,0xbf3504ef,2 +np.float32,0x42687a55,0xb552257b,2 +np.float32,0xc2687a55,0xb552257b,2 +np.float32,0x42e87a55,0xbf800000,2 +np.float32,0xc2e87a55,0xbf800000,2 +np.float32,0x41eec2d4,0x353ef0a7,2 +np.float32,0xc1eec2d4,0x353ef0a7,2 +np.float32,0x426ec2d4,0xbf800000,2 +np.float32,0xc26ec2d4,0xbf800000,2 +np.float32,0x42eec2d4,0x3f800000,2 +np.float32,0xc2eec2d4,0x3f800000,2 +np.float32,0x41f50b53,0x3f3504ff,2 +np.float32,0xc1f50b53,0x3f3504ff,2 +np.float32,0x42750b53,0x360a6748,2 +np.float32,0xc2750b53,0x360a6748,2 +np.float32,0x42f50b53,0xbf800000,2 +np.float32,0xc2f50b53,0xbf800000,2 +np.float32,0x41fb53d2,0x3f800000,2 +np.float32,0xc1fb53d2,0x3f800000,2 +np.float32,0x427b53d2,0x3f800000,2 +np.float32,0xc27b53d2,0x3f800000,2 +np.float32,0x42fb53d2,0x3f800000,2 +np.float32,0xc2fb53d2,0x3f800000,2 +np.float32,0x4200ce28,0x3f3504f6,2 +np.float32,0xc200ce28,0x3f3504f6,2 +np.float32,0x4280ce28,0x34fdd672,2 +np.float32,0xc280ce28,0x34fdd672,2 +np.float32,0x4300ce28,0xbf800000,2 +np.float32,0xc300ce28,0xbf800000,2 +np.float32,0x4203f268,0xb6059a13,2 +np.float32,0xc203f268,0xb6059a13,2 +np.float32,0x4283f268,0xbf800000,2 +np.float32,0xc283f268,0xbf800000,2 +np.float32,0x4303f268,0x3f800000,2 +np.float32,0xc303f268,0x3f800000,2 +np.float32,0x420716a7,0xbf3504f8,2 +np.float32,0xc20716a7,0xbf3504f8,2 +np.float32,0x428716a7,0x35588c6d,2 +np.float32,0xc28716a7,0x35588c6d,2 +np.float32,0x430716a7,0xbf800000,2 +np.float32,0xc30716a7,0xbf800000,2 +np.float32,0x420a3ae7,0xbf800000,2 +np.float32,0xc20a3ae7,0xbf800000,2 +np.float32,0x428a3ae7,0x3f800000,2 +np.float32,0xc28a3ae7,0x3f800000,2 +np.float32,0x430a3ae7,0x3f800000,2 +np.float32,0xc30a3ae7,0x3f800000,2 +np.float32,0x420d5f26,0xbf3504e7,2 +np.float32,0xc20d5f26,0xbf3504e7,2 +np.float32,0x428d5f26,0xb60c0105,2 +np.float32,0xc28d5f26,0xb60c0105,2 +np.float32,0x430d5f26,0xbf800000,2 +np.float32,0xc30d5f26,0xbf800000,2 +np.float32,0x42108365,0xb512200d,2 +np.float32,0xc2108365,0xb512200d,2 +np.float32,0x42908365,0xbf800000,2 +np.float32,0xc2908365,0xbf800000,2 +np.float32,0x43108365,0x3f800000,2 +np.float32,0xc3108365,0x3f800000,2 +np.float32,0x4213a7a5,0x3f350507,2 +np.float32,0xc213a7a5,0x3f350507,2 +np.float32,0x4293a7a5,0x3661deee,2 +np.float32,0xc293a7a5,0x3661deee,2 +np.float32,0x4313a7a5,0xbf800000,2 +np.float32,0xc313a7a5,0xbf800000,2 +np.float32,0x4216cbe4,0x3f800000,2 +np.float32,0xc216cbe4,0x3f800000,2 +np.float32,0x4296cbe4,0x3f800000,2 +np.float32,0xc296cbe4,0x3f800000,2 +np.float32,0x4316cbe4,0x3f800000,2 +np.float32,0xc316cbe4,0x3f800000,2 +np.float32,0x4219f024,0x3f3504d8,2 +np.float32,0xc219f024,0x3f3504d8,2 +np.float32,0x4299f024,0xb69bde6c,2 +np.float32,0xc299f024,0xb69bde6c,2 +np.float32,0x4319f024,0xbf800000,2 +np.float32,0xc319f024,0xbf800000,2 +np.float32,0x421d1463,0xb5455799,2 +np.float32,0xc21d1463,0xb5455799,2 +np.float32,0x429d1463,0xbf800000,2 +np.float32,0xc29d1463,0xbf800000,2 +np.float32,0x431d1463,0x3f800000,2 +np.float32,0xc31d1463,0x3f800000,2 +np.float32,0x422038a3,0xbf350516,2 +np.float32,0xc22038a3,0xbf350516,2 +np.float32,0x42a038a3,0x36c6cd61,2 +np.float32,0xc2a038a3,0x36c6cd61,2 +np.float32,0x432038a3,0xbf800000,2 +np.float32,0xc32038a3,0xbf800000,2 +np.float32,0x42235ce2,0xbf800000,2 +np.float32,0xc2235ce2,0xbf800000,2 +np.float32,0x42a35ce2,0x3f800000,2 +np.float32,0xc2a35ce2,0x3f800000,2 +np.float32,0x43235ce2,0x3f800000,2 +np.float32,0xc3235ce2,0x3f800000,2 +np.float32,0x42268121,0xbf3504f6,2 +np.float32,0xc2268121,0xbf3504f6,2 +np.float32,0x42a68121,0x34e43aac,2 +np.float32,0xc2a68121,0x34e43aac,2 +np.float32,0x43268121,0xbf800000,2 +np.float32,0xc3268121,0xbf800000,2 +np.float32,0x4229a561,0x360733d0,2 +np.float32,0xc229a561,0x360733d0,2 +np.float32,0x42a9a561,0xbf800000,2 +np.float32,0xc2a9a561,0xbf800000,2 +np.float32,0x4329a561,0x3f800000,2 +np.float32,0xc329a561,0x3f800000,2 +np.float32,0x422cc9a0,0x3f3504f8,2 +np.float32,0xc22cc9a0,0x3f3504f8,2 +np.float32,0x42acc9a0,0x35655a50,2 +np.float32,0xc2acc9a0,0x35655a50,2 +np.float32,0x432cc9a0,0xbf800000,2 +np.float32,0xc32cc9a0,0xbf800000,2 +np.float32,0x422fede0,0x3f800000,2 +np.float32,0xc22fede0,0x3f800000,2 +np.float32,0x42afede0,0x3f800000,2 +np.float32,0xc2afede0,0x3f800000,2 +np.float32,0x432fede0,0x3f800000,2 +np.float32,0xc32fede0,0x3f800000,2 +np.float32,0x4233121f,0x3f3504e7,2 +np.float32,0xc233121f,0x3f3504e7,2 +np.float32,0x42b3121f,0xb60f347d,2 +np.float32,0xc2b3121f,0xb60f347d,2 +np.float32,0x4333121f,0xbf800000,2 +np.float32,0xc333121f,0xbf800000,2 +np.float32,0x4236365e,0x350bb91c,2 +np.float32,0xc236365e,0x350bb91c,2 +np.float32,0x42b6365e,0xbf800000,2 +np.float32,0xc2b6365e,0xbf800000,2 +np.float32,0x4336365e,0x3f800000,2 +np.float32,0xc336365e,0x3f800000,2 +np.float32,0x42395a9e,0xbf350507,2 +np.float32,0xc2395a9e,0xbf350507,2 +np.float32,0x42b95a9e,0x36651267,2 +np.float32,0xc2b95a9e,0x36651267,2 +np.float32,0x43395a9e,0xbf800000,2 +np.float32,0xc3395a9e,0xbf800000,2 +np.float32,0x423c7edd,0xbf800000,2 +np.float32,0xc23c7edd,0xbf800000,2 +np.float32,0x42bc7edd,0x3f800000,2 +np.float32,0xc2bc7edd,0x3f800000,2 +np.float32,0x433c7edd,0x3f800000,2 +np.float32,0xc33c7edd,0x3f800000,2 +np.float32,0x423fa31d,0xbf3504d7,2 +np.float32,0xc23fa31d,0xbf3504d7,2 +np.float32,0x42bfa31d,0xb69d7828,2 +np.float32,0xc2bfa31d,0xb69d7828,2 +np.float32,0x433fa31d,0xbf800000,2 +np.float32,0xc33fa31d,0xbf800000,2 +np.float32,0x4242c75c,0x354bbe8a,2 +np.float32,0xc242c75c,0x354bbe8a,2 +np.float32,0x42c2c75c,0xbf800000,2 +np.float32,0xc2c2c75c,0xbf800000,2 +np.float32,0x4342c75c,0x3f800000,2 +np.float32,0xc342c75c,0x3f800000,2 +np.float32,0x4245eb9c,0x3f350517,2 +np.float32,0xc245eb9c,0x3f350517,2 +np.float32,0x42c5eb9c,0x36c8671d,2 +np.float32,0xc2c5eb9c,0x36c8671d,2 +np.float32,0x4345eb9c,0xbf800000,2 +np.float32,0xc345eb9c,0xbf800000,2 +np.float32,0x42490fdb,0x3f800000,2 +np.float32,0xc2490fdb,0x3f800000,2 +np.float32,0x42c90fdb,0x3f800000,2 +np.float32,0xc2c90fdb,0x3f800000,2 +np.float32,0x43490fdb,0x3f800000,2 +np.float32,0xc3490fdb,0x3f800000,2 +np.float32,0x424c341a,0x3f3504f5,2 +np.float32,0xc24c341a,0x3f3504f5,2 +np.float32,0x42cc341a,0x34ca9ee6,2 +np.float32,0xc2cc341a,0x34ca9ee6,2 +np.float32,0x434c341a,0xbf800000,2 +np.float32,0xc34c341a,0xbf800000,2 +np.float32,0x424f585a,0xb608cd8c,2 +np.float32,0xc24f585a,0xb608cd8c,2 +np.float32,0x42cf585a,0xbf800000,2 +np.float32,0xc2cf585a,0xbf800000,2 +np.float32,0x434f585a,0x3f800000,2 +np.float32,0xc34f585a,0x3f800000,2 +np.float32,0x42527c99,0xbf3504f9,2 +np.float32,0xc2527c99,0xbf3504f9,2 +np.float32,0x42d27c99,0x35722833,2 +np.float32,0xc2d27c99,0x35722833,2 +np.float32,0x43527c99,0xbf800000,2 +np.float32,0xc3527c99,0xbf800000,2 +np.float32,0x4255a0d9,0xbf800000,2 +np.float32,0xc255a0d9,0xbf800000,2 +np.float32,0x42d5a0d9,0x3f800000,2 +np.float32,0xc2d5a0d9,0x3f800000,2 +np.float32,0x4355a0d9,0x3f800000,2 +np.float32,0xc355a0d9,0x3f800000,2 +np.float32,0x4258c518,0xbf3504e6,2 +np.float32,0xc258c518,0xbf3504e6,2 +np.float32,0x42d8c518,0xb61267f6,2 +np.float32,0xc2d8c518,0xb61267f6,2 +np.float32,0x4358c518,0xbf800000,2 +np.float32,0xc358c518,0xbf800000,2 +np.float32,0x425be958,0x365eab75,2 +np.float32,0xc25be958,0x365eab75,2 +np.float32,0x42dbe958,0xbf800000,2 +np.float32,0xc2dbe958,0xbf800000,2 +np.float32,0x435be958,0x3f800000,2 +np.float32,0xc35be958,0x3f800000,2 +np.float32,0x425f0d97,0x3f350508,2 +np.float32,0xc25f0d97,0x3f350508,2 +np.float32,0x42df0d97,0x366845e0,2 +np.float32,0xc2df0d97,0x366845e0,2 +np.float32,0x435f0d97,0xbf800000,2 +np.float32,0xc35f0d97,0xbf800000,2 +np.float32,0x426231d6,0x3f800000,2 +np.float32,0xc26231d6,0x3f800000,2 +np.float32,0x42e231d6,0x3f800000,2 +np.float32,0xc2e231d6,0x3f800000,2 +np.float32,0x436231d6,0x3f800000,2 +np.float32,0xc36231d6,0x3f800000,2 +np.float32,0x42655616,0x3f3504d7,2 +np.float32,0xc2655616,0x3f3504d7,2 +np.float32,0x42e55616,0xb69f11e5,2 +np.float32,0xc2e55616,0xb69f11e5,2 +np.float32,0x43655616,0xbf800000,2 +np.float32,0xc3655616,0xbf800000,2 +np.float32,0x42687a55,0xb552257b,2 +np.float32,0xc2687a55,0xb552257b,2 +np.float32,0x42e87a55,0xbf800000,2 +np.float32,0xc2e87a55,0xbf800000,2 +np.float32,0x43687a55,0x3f800000,2 +np.float32,0xc3687a55,0x3f800000,2 +np.float32,0x426b9e95,0xbf350517,2 +np.float32,0xc26b9e95,0xbf350517,2 +np.float32,0x42eb9e95,0x36ca00d9,2 +np.float32,0xc2eb9e95,0x36ca00d9,2 +np.float32,0x436b9e95,0xbf800000,2 +np.float32,0xc36b9e95,0xbf800000,2 +np.float32,0x426ec2d4,0xbf800000,2 +np.float32,0xc26ec2d4,0xbf800000,2 +np.float32,0x42eec2d4,0x3f800000,2 +np.float32,0xc2eec2d4,0x3f800000,2 +np.float32,0x436ec2d4,0x3f800000,2 +np.float32,0xc36ec2d4,0x3f800000,2 +np.float32,0x4271e713,0xbf3504f5,2 +np.float32,0xc271e713,0xbf3504f5,2 +np.float32,0x42f1e713,0x34b10321,2 +np.float32,0xc2f1e713,0x34b10321,2 +np.float32,0x4371e713,0xbf800000,2 +np.float32,0xc371e713,0xbf800000,2 +np.float32,0x42750b53,0x360a6748,2 +np.float32,0xc2750b53,0x360a6748,2 +np.float32,0x42f50b53,0xbf800000,2 +np.float32,0xc2f50b53,0xbf800000,2 +np.float32,0x43750b53,0x3f800000,2 +np.float32,0xc3750b53,0x3f800000,2 +np.float32,0x42782f92,0x3f3504f9,2 +np.float32,0xc2782f92,0x3f3504f9,2 +np.float32,0x42f82f92,0x357ef616,2 +np.float32,0xc2f82f92,0x357ef616,2 +np.float32,0x43782f92,0xbf800000,2 +np.float32,0xc3782f92,0xbf800000,2 +np.float32,0x427b53d2,0x3f800000,2 +np.float32,0xc27b53d2,0x3f800000,2 +np.float32,0x42fb53d2,0x3f800000,2 +np.float32,0xc2fb53d2,0x3f800000,2 +np.float32,0x437b53d2,0x3f800000,2 +np.float32,0xc37b53d2,0x3f800000,2 +np.float32,0x427e7811,0x3f3504e6,2 +np.float32,0xc27e7811,0x3f3504e6,2 +np.float32,0x42fe7811,0xb6159b6f,2 +np.float32,0xc2fe7811,0xb6159b6f,2 +np.float32,0x437e7811,0xbf800000,2 +np.float32,0xc37e7811,0xbf800000,2 +np.float32,0x4280ce28,0x34fdd672,2 +np.float32,0xc280ce28,0x34fdd672,2 +np.float32,0x4300ce28,0xbf800000,2 +np.float32,0xc300ce28,0xbf800000,2 +np.float32,0x4380ce28,0x3f800000,2 +np.float32,0xc380ce28,0x3f800000,2 +np.float32,0x42826048,0xbf350508,2 +np.float32,0xc2826048,0xbf350508,2 +np.float32,0x43026048,0x366b7958,2 +np.float32,0xc3026048,0x366b7958,2 +np.float32,0x43826048,0xbf800000,2 +np.float32,0xc3826048,0xbf800000,2 +np.float32,0x4283f268,0xbf800000,2 +np.float32,0xc283f268,0xbf800000,2 +np.float32,0x4303f268,0x3f800000,2 +np.float32,0xc303f268,0x3f800000,2 +np.float32,0x4383f268,0x3f800000,2 +np.float32,0xc383f268,0x3f800000,2 +np.float32,0x42858487,0xbf350504,2 +np.float32,0xc2858487,0xbf350504,2 +np.float32,0x43058487,0x363ea8be,2 +np.float32,0xc3058487,0x363ea8be,2 +np.float32,0x43858487,0xbf800000,2 +np.float32,0xc3858487,0xbf800000,2 +np.float32,0x428716a7,0x35588c6d,2 +np.float32,0xc28716a7,0x35588c6d,2 +np.float32,0x430716a7,0xbf800000,2 +np.float32,0xc30716a7,0xbf800000,2 +np.float32,0x438716a7,0x3f800000,2 +np.float32,0xc38716a7,0x3f800000,2 +np.float32,0x4288a8c7,0x3f350517,2 +np.float32,0xc288a8c7,0x3f350517,2 +np.float32,0x4308a8c7,0x36cb9a96,2 +np.float32,0xc308a8c7,0x36cb9a96,2 +np.float32,0x4388a8c7,0xbf800000,2 +np.float32,0xc388a8c7,0xbf800000,2 +np.float32,0x428a3ae7,0x3f800000,2 +np.float32,0xc28a3ae7,0x3f800000,2 +np.float32,0x430a3ae7,0x3f800000,2 +np.float32,0xc30a3ae7,0x3f800000,2 +np.float32,0x438a3ae7,0x3f800000,2 +np.float32,0xc38a3ae7,0x3f800000,2 +np.float32,0x428bcd06,0x3f3504f5,2 +np.float32,0xc28bcd06,0x3f3504f5,2 +np.float32,0x430bcd06,0x3497675b,2 +np.float32,0xc30bcd06,0x3497675b,2 +np.float32,0x438bcd06,0xbf800000,2 +np.float32,0xc38bcd06,0xbf800000,2 +np.float32,0x428d5f26,0xb60c0105,2 +np.float32,0xc28d5f26,0xb60c0105,2 +np.float32,0x430d5f26,0xbf800000,2 +np.float32,0xc30d5f26,0xbf800000,2 +np.float32,0x438d5f26,0x3f800000,2 +np.float32,0xc38d5f26,0x3f800000,2 +np.float32,0x428ef146,0xbf350526,2 +np.float32,0xc28ef146,0xbf350526,2 +np.float32,0x430ef146,0x3710bc40,2 +np.float32,0xc30ef146,0x3710bc40,2 +np.float32,0x438ef146,0xbf800000,2 +np.float32,0xc38ef146,0xbf800000,2 +np.float32,0x42908365,0xbf800000,2 +np.float32,0xc2908365,0xbf800000,2 +np.float32,0x43108365,0x3f800000,2 +np.float32,0xc3108365,0x3f800000,2 +np.float32,0x43908365,0x3f800000,2 +np.float32,0xc3908365,0x3f800000,2 +np.float32,0x42921585,0xbf3504e6,2 +np.float32,0xc2921585,0xbf3504e6,2 +np.float32,0x43121585,0xb618cee8,2 +np.float32,0xc3121585,0xb618cee8,2 +np.float32,0x43921585,0xbf800000,2 +np.float32,0xc3921585,0xbf800000,2 +np.float32,0x4293a7a5,0x3661deee,2 +np.float32,0xc293a7a5,0x3661deee,2 +np.float32,0x4313a7a5,0xbf800000,2 +np.float32,0xc313a7a5,0xbf800000,2 +np.float32,0x4393a7a5,0x3f800000,2 +np.float32,0xc393a7a5,0x3f800000,2 +np.float32,0x429539c5,0x3f350536,2 +np.float32,0xc29539c5,0x3f350536,2 +np.float32,0x431539c5,0x373bab34,2 +np.float32,0xc31539c5,0x373bab34,2 +np.float32,0x439539c5,0xbf800000,2 +np.float32,0xc39539c5,0xbf800000,2 +np.float32,0x4296cbe4,0x3f800000,2 +np.float32,0xc296cbe4,0x3f800000,2 +np.float32,0x4316cbe4,0x3f800000,2 +np.float32,0xc316cbe4,0x3f800000,2 +np.float32,0x4396cbe4,0x3f800000,2 +np.float32,0xc396cbe4,0x3f800000,2 +np.float32,0x42985e04,0x3f3504d7,2 +np.float32,0xc2985e04,0x3f3504d7,2 +np.float32,0x43185e04,0xb6a2455d,2 +np.float32,0xc3185e04,0xb6a2455d,2 +np.float32,0x43985e04,0xbf800000,2 +np.float32,0xc3985e04,0xbf800000,2 +np.float32,0x4299f024,0xb69bde6c,2 +np.float32,0xc299f024,0xb69bde6c,2 +np.float32,0x4319f024,0xbf800000,2 +np.float32,0xc319f024,0xbf800000,2 +np.float32,0x4399f024,0x3f800000,2 +np.float32,0xc399f024,0x3f800000,2 +np.float32,0x429b8243,0xbf3504ea,2 +np.float32,0xc29b8243,0xbf3504ea,2 +np.float32,0x431b8243,0xb5cb2eb8,2 +np.float32,0xc31b8243,0xb5cb2eb8,2 +np.float32,0x439b8243,0xbf800000,2 +np.float32,0xc39b8243,0xbf800000,2 +np.float32,0x435b2047,0x3f3504c1,2 +np.float32,0x42a038a2,0xb5e4ca7e,2 +np.float32,0x432038a2,0xbf800000,2 +np.float32,0x4345eb9b,0xbf800000,2 +np.float32,0x42c5eb9b,0xb5de638c,2 +np.float32,0x42eb9e94,0xb5d7fc9b,2 +np.float32,0x4350ea79,0x3631dadb,2 +np.float32,0x42dbe957,0xbf800000,2 +np.float32,0x425be957,0xb505522a,2 +np.float32,0x435be957,0x3f800000,2 +np.float32,0x46027eb2,0x3e7d94c9,2 +np.float32,0x4477baed,0xbe7f1824,2 +np.float32,0x454b8024,0x3e7f5268,2 +np.float32,0x455d2c09,0x3e7f40cb,2 +np.float32,0x4768d3de,0xba14b4af,2 +np.float32,0x46c1e7cd,0x3e7fb102,2 +np.float32,0x44a52949,0xbe7dc9d5,2 +np.float32,0x4454633a,0x3e7dbc7d,2 +np.float32,0x4689810b,0x3e7eb02b,2 +np.float32,0x473473cd,0xbe7eef6f,2 +np.float32,0x44a5193f,0x3e7e1b1f,2 +np.float32,0x46004b36,0x3e7dac59,2 +np.float32,0x467f604b,0x3d7ffd3a,2 +np.float32,0x45ea1805,0x3dffd2e0,2 +np.float32,0x457b6af3,0x3dff7831,2 +np.float32,0x44996159,0xbe7d85f4,2 +np.float32,0x47883553,0xbb80584e,2 +np.float32,0x44e19f0c,0xbdffcfe6,2 +np.float32,0x472b3bf6,0xbe7f7a82,2 +np.float32,0x4600bb4e,0x3a135e33,2 +np.float32,0x449f4556,0x3e7e42e5,2 +np.float32,0x474e9420,0x3dff77b2,2 +np.float32,0x45cbdb23,0x3dff7240,2 +np.float32,0x44222747,0x3dffb039,2 +np.float32,0x4772e419,0xbdff74b8,2 +np.float64,0x1,0x3ff0000000000000,1 +np.float64,0x8000000000000001,0x3ff0000000000000,1 +np.float64,0x10000000000000,0x3ff0000000000000,1 +np.float64,0x8010000000000000,0x3ff0000000000000,1 +np.float64,0x7fefffffffffffff,0xbfefffe62ecfab75,1 +np.float64,0xffefffffffffffff,0xbfefffe62ecfab75,1 +np.float64,0x7ff0000000000000,0xfff8000000000000,1 +np.float64,0xfff0000000000000,0xfff8000000000000,1 +np.float64,0x7ff8000000000000,0x7ff8000000000000,1 +np.float64,0x7ff4000000000000,0x7ffc000000000000,1 +np.float64,0xbfc28bd9dd2517b4,0x3fefaa28ba13a702,1 +np.float64,0x3fb673c62e2ce790,0x3fefe083847a717f,1 +np.float64,0xbfe3e1dac7e7c3b6,0x3fea0500ba099f3a,1 +np.float64,0xbfbe462caa3c8c58,0x3fefc6c8b9c1c87c,1 +np.float64,0xbfb9353576326a68,0x3fefd8513e50e6b1,1 +np.float64,0xbfc05e798520bcf4,0x3fefbd1ad81cf089,1 +np.float64,0xbfe3ca3be2e79478,0x3fea12b995ea6574,1 +np.float64,0xbfde875d46bd0eba,0x3fec6d888662a824,1 +np.float64,0x3fafc4e02c3f89c0,0x3feff03c34bffd69,1 +np.float64,0xbf98855848310ac0,0x3feffda6c1588bdb,1 +np.float64,0x3fe66c51186cd8a2,0x3fe875c61c630ecb,1 +np.float64,0xbfedff1c3b7bfe38,0x3fe2f0c8c9e8fa39,1 +np.float64,0x3fd6082267ac1044,0x3fee1f6023695050,1 +np.float64,0xbfe78449b06f0894,0x3fe7bda2b223850e,1 +np.float64,0x3feedb8e63fdb71c,0x3fe23d5dfd2dd33f,1 +np.float64,0xbfc0a9de3d2153bc,0x3fefbaadf5e5285e,1 +np.float64,0x3fc04c67432098d0,0x3fefbdae07b7de8d,1 +np.float64,0xbfeeef84c4fddf0a,0x3fe22cf37f309d88,1 +np.float64,0x3fc04bb025209760,0x3fefbdb3d7d34ecf,1 +np.float64,0x3fd6b84d48ad709c,0x3fee013403da6e2a,1 +np.float64,0x3fec1ae25d7835c4,0x3fe46e62195cf274,1 +np.float64,0xbfdc6fdf9bb8dfc0,0x3fece48dc78bbb2e,1 +np.float64,0x3fb4db2c9229b660,0x3fefe4d42f79bf49,1 +np.float64,0xbfc0ed698521dad4,0x3fefb8785ea658c9,1 +np.float64,0xbfee82772b7d04ee,0x3fe2864a80efe8e9,1 +np.float64,0x3fd575b664aaeb6c,0x3fee37c669a12879,1 +np.float64,0x3fe4afb1c5e95f64,0x3fe98b177194439c,1 +np.float64,0x3fd93962f9b272c4,0x3fed8bef61876294,1 +np.float64,0x3fd97ae025b2f5c0,0x3fed7f4cfbf4d300,1 +np.float64,0xbfd9afdb1bb35fb6,0x3fed74fdc44dabb1,1 +np.float64,0x3f8ae65e3035cc80,0x3fefff4b1a0ea62b,1 +np.float64,0xbfe7e58664efcb0d,0x3fe77c02a1cbb670,1 +np.float64,0x3fe5f68b37ebed16,0x3fe8c10f849a5d4d,1 +np.float64,0x3fd9137d61b226fc,0x3fed9330eb4815a1,1 +np.float64,0x3fc146d019228da0,0x3fefb57e2d4d52f8,1 +np.float64,0xbfda6036edb4c06e,0x3fed521b2b578679,1 +np.float64,0xbfe78ddfb0ef1bc0,0x3fe7b734319a77e4,1 +np.float64,0x3fe0877823610ef0,0x3febd33a993dd786,1 +np.float64,0x3fbc61af2e38c360,0x3fefcdb4f889756d,1 +np.float64,0x3fd4dcdca4a9b9b8,0x3fee50962ffea5ae,1 +np.float64,0xbfe03cb29f607965,0x3febf7dbf640a75a,1 +np.float64,0xbfc81de407303bc8,0x3fef6f066cef64bc,1 +np.float64,0x3fd8dea42db1bd48,0x3fed9d3e00dbe0b3,1 +np.float64,0x3feac75e94f58ebe,0x3fe56f1f47f97896,1 +np.float64,0x3fb3a1ea6e2743d0,0x3fefe7ec1247cdaa,1 +np.float64,0x3fd695c0f4ad2b80,0x3fee0730bd40883d,1 +np.float64,0xbfd2c631f5a58c64,0x3feea20cbd1105d7,1 +np.float64,0xbfe978a8e1f2f152,0x3fe663014d40ad7a,1 +np.float64,0x3fd8b6b76ab16d70,0x3feda4c879aacc19,1 +np.float64,0x3feaafd30e755fa6,0x3fe5809514c28453,1 +np.float64,0x3fe1e37dc263c6fc,0x3feb20f9ad1f3f5c,1 +np.float64,0x3fd0ec7c24a1d8f8,0x3feee34048f43b75,1 +np.float64,0xbfe3881cbf67103a,0x3fea38d7886e6f53,1 +np.float64,0xbfd7023957ae0472,0x3fedf4471c765a1c,1 +np.float64,0xbfebc51c4ef78a38,0x3fe4b01c424e297b,1 +np.float64,0xbfe20a93eae41528,0x3feb0c2aa321d2e0,1 +np.float64,0x3fef39be867e737e,0x3fe1efaba9164d27,1 +np.float64,0x3fe8ea9576f1d52a,0x3fe6c7a8826ce1be,1 +np.float64,0x3fea921d91f5243c,0x3fe5968c6cf78963,1 +np.float64,0x3fd7ee5d31afdcbc,0x3fedc9f19d43fe61,1 +np.float64,0xbfe3ed581767dab0,0x3fe9fe4ee2f2b1cd,1 +np.float64,0xbfc40923d5281248,0x3fef9bd8ee9f6e68,1 +np.float64,0x3fe411a834682350,0x3fe9e9103854f057,1 +np.float64,0xbfedf6ccdf7bed9a,0x3fe2f77ad6543246,1 +np.float64,0xbfe8788a44f0f114,0x3fe7172f3aa0c742,1 +np.float64,0xbfce728f173ce520,0x3fef1954083bea04,1 +np.float64,0xbfd64dd0acac9ba2,0x3fee138c3293c246,1 +np.float64,0xbfe00669f5600cd4,0x3fec121443945350,1 +np.float64,0xbfe7152ba2ee2a58,0x3fe8079465d09846,1 +np.float64,0x3fe8654d8f70ca9c,0x3fe7247c94f09596,1 +np.float64,0x3fea68045cf4d008,0x3fe5b58cfe81a243,1 +np.float64,0xbfcd4779073a8ef4,0x3fef2a9d78153fa5,1 +np.float64,0xbfdb4456e5b688ae,0x3fed23b11614203f,1 +np.float64,0x3fcb5d59cd36bab0,0x3fef45818216a515,1 +np.float64,0xbfd914ff5ab229fe,0x3fed92e73746fea8,1 +np.float64,0x3fe4d211db69a424,0x3fe97653f433d15f,1 +np.float64,0xbfdbbb9224b77724,0x3fed0adb593dde80,1 +np.float64,0x3fd424ceafa8499c,0x3fee6d9124795d33,1 +np.float64,0x3feb5968f976b2d2,0x3fe501d116efbf54,1 +np.float64,0x3fee7d92a2fcfb26,0x3fe28a479b6a9dcf,1 +np.float64,0x3fc308e9972611d0,0x3fefa595f4df0c89,1 +np.float64,0x3fda79cd77b4f39c,0x3fed4cf8e69ba1f8,1 +np.float64,0x3fcbcf42d5379e88,0x3fef3f6a6a77c187,1 +np.float64,0x3fe13a1da662743c,0x3feb79504faea888,1 +np.float64,0xbfee4435f07c886c,0x3fe2b8ea98d2fc29,1 +np.float64,0x3fd65d68ccacbad0,0x3fee10e1ac7ada89,1 +np.float64,0x3fef2f89bb7e5f14,0x3fe1f81e882cc3f4,1 +np.float64,0xbfef0a7769fe14ef,0x3fe216bf384fc646,1 +np.float64,0x3fc065277320ca50,0x3fefbce44835c193,1 +np.float64,0x3fe9c1a74d73834e,0x3fe62e9ee0c2f2bf,1 +np.float64,0x3fd9d96e5db3b2dc,0x3fed6cd88eb51f6a,1 +np.float64,0x3fe02bf1c56057e4,0x3febfffc24b5a7ba,1 +np.float64,0xbfd6814350ad0286,0x3fee0ab9ad318b84,1 +np.float64,0x3f9fcbec583f97c0,0x3feffc0d0f1d8e75,1 +np.float64,0x3fe23524e5e46a4a,0x3feaf55372949a06,1 +np.float64,0xbfbdc95f6a3b92c0,0x3fefc89c21d44995,1 +np.float64,0x3fe961bb9cf2c378,0x3fe6735d6e1cca58,1 +np.float64,0xbfe8f1c370f1e387,0x3fe6c29d1be8bee9,1 +np.float64,0x3fd880d43ab101a8,0x3fedaee3c7ccfc96,1 +np.float64,0xbfedb37005fb66e0,0x3fe32d91ef2e3bd3,1 +np.float64,0xfdce287bfb9c5,0x3ff0000000000000,1 +np.float64,0x9aa1b9e735437,0x3ff0000000000000,1 +np.float64,0x6beac6e0d7d59,0x3ff0000000000000,1 +np.float64,0x47457aae8e8b0,0x3ff0000000000000,1 +np.float64,0x35ff13b46bfe3,0x3ff0000000000000,1 +np.float64,0xb9c0c82b73819,0x3ff0000000000000,1 +np.float64,0x1a8dc21a351b9,0x3ff0000000000000,1 +np.float64,0x7e87ef6afd0ff,0x3ff0000000000000,1 +np.float64,0x620a6588c414d,0x3ff0000000000000,1 +np.float64,0x7f366000fe6e,0x3ff0000000000000,1 +np.float64,0x787e39f4f0fc8,0x3ff0000000000000,1 +np.float64,0xf5134f1fea26a,0x3ff0000000000000,1 +np.float64,0xbce700ef79ce0,0x3ff0000000000000,1 +np.float64,0x144d7cc8289b1,0x3ff0000000000000,1 +np.float64,0xb9fbc5b973f79,0x3ff0000000000000,1 +np.float64,0xc3d6292d87ac5,0x3ff0000000000000,1 +np.float64,0xc1084e618210a,0x3ff0000000000000,1 +np.float64,0xb6b9eca56d73e,0x3ff0000000000000,1 +np.float64,0xc7ac4b858f58a,0x3ff0000000000000,1 +np.float64,0x516d75d2a2daf,0x3ff0000000000000,1 +np.float64,0x9dc089d93b811,0x3ff0000000000000,1 +np.float64,0x7b5f2840f6be6,0x3ff0000000000000,1 +np.float64,0x121d3ce8243a9,0x3ff0000000000000,1 +np.float64,0xf0be0337e17c1,0x3ff0000000000000,1 +np.float64,0xff58a5cbfeb15,0x3ff0000000000000,1 +np.float64,0xdaf1d07fb5e3a,0x3ff0000000000000,1 +np.float64,0x61d95382c3b2b,0x3ff0000000000000,1 +np.float64,0xe4df943fc9bf3,0x3ff0000000000000,1 +np.float64,0xf72ac2bdee559,0x3ff0000000000000,1 +np.float64,0x12dafbf625b60,0x3ff0000000000000,1 +np.float64,0xee11d427dc23b,0x3ff0000000000000,1 +np.float64,0xf4f8eb37e9f1e,0x3ff0000000000000,1 +np.float64,0xad7cb5df5af97,0x3ff0000000000000,1 +np.float64,0x59fc9b06b3f94,0x3ff0000000000000,1 +np.float64,0x3c3e65e4787ce,0x3ff0000000000000,1 +np.float64,0xe37bc993c6f79,0x3ff0000000000000,1 +np.float64,0x13bd6330277ad,0x3ff0000000000000,1 +np.float64,0x56cc2800ad986,0x3ff0000000000000,1 +np.float64,0x6203b8fcc4078,0x3ff0000000000000,1 +np.float64,0x75c7c8b8eb8fa,0x3ff0000000000000,1 +np.float64,0x5ebf8e00bd7f2,0x3ff0000000000000,1 +np.float64,0xda81f2f1b503f,0x3ff0000000000000,1 +np.float64,0x6adb17d6d5b64,0x3ff0000000000000,1 +np.float64,0x1ba68eee374d3,0x3ff0000000000000,1 +np.float64,0xeecf6fbbdd9ee,0x3ff0000000000000,1 +np.float64,0x24d6dd8e49add,0x3ff0000000000000,1 +np.float64,0xdf7cb81bbef97,0x3ff0000000000000,1 +np.float64,0xafd7be1b5faf8,0x3ff0000000000000,1 +np.float64,0xdb90ca35b721a,0x3ff0000000000000,1 +np.float64,0xa72903a14e521,0x3ff0000000000000,1 +np.float64,0x14533ee028a7,0x3ff0000000000000,1 +np.float64,0x7951540cf2a2b,0x3ff0000000000000,1 +np.float64,0x22882be045106,0x3ff0000000000000,1 +np.float64,0x136270d626c4f,0x3ff0000000000000,1 +np.float64,0x6a0f5744d41ec,0x3ff0000000000000,1 +np.float64,0x21e0d1aa43c1b,0x3ff0000000000000,1 +np.float64,0xee544155dca88,0x3ff0000000000000,1 +np.float64,0xcbe8aac797d16,0x3ff0000000000000,1 +np.float64,0x6c065e80d80e,0x3ff0000000000000,1 +np.float64,0xe57f0411cafe1,0x3ff0000000000000,1 +np.float64,0xdec3a6bdbd875,0x3ff0000000000000,1 +np.float64,0xf4d23a0fe9a48,0x3ff0000000000000,1 +np.float64,0xda77ef47b4efe,0x3ff0000000000000,1 +np.float64,0x8c405c9b1880c,0x3ff0000000000000,1 +np.float64,0x4eced5149d9db,0x3ff0000000000000,1 +np.float64,0x16b6552c2d6cc,0x3ff0000000000000,1 +np.float64,0x6fbc262cdf785,0x3ff0000000000000,1 +np.float64,0x628c3844c5188,0x3ff0000000000000,1 +np.float64,0x6d827d2cdb050,0x3ff0000000000000,1 +np.float64,0xd1bfdf29a37fc,0x3ff0000000000000,1 +np.float64,0xd85400fdb0a80,0x3ff0000000000000,1 +np.float64,0xcc420b2d98842,0x3ff0000000000000,1 +np.float64,0xac41d21b5883b,0x3ff0000000000000,1 +np.float64,0x432f18d4865e4,0x3ff0000000000000,1 +np.float64,0xe7e89a1bcfd14,0x3ff0000000000000,1 +np.float64,0x9b1141d536228,0x3ff0000000000000,1 +np.float64,0x6805f662d00bf,0x3ff0000000000000,1 +np.float64,0xc76552358ecab,0x3ff0000000000000,1 +np.float64,0x4ae8ffee95d21,0x3ff0000000000000,1 +np.float64,0x4396c096872d9,0x3ff0000000000000,1 +np.float64,0x6e8e55d4dd1cb,0x3ff0000000000000,1 +np.float64,0x4c2e33dc985c7,0x3ff0000000000000,1 +np.float64,0xbce814a579d03,0x3ff0000000000000,1 +np.float64,0x911681b5222d0,0x3ff0000000000000,1 +np.float64,0x5f90a4b2bf215,0x3ff0000000000000,1 +np.float64,0x26f76be84deee,0x3ff0000000000000,1 +np.float64,0xb2f7536165eeb,0x3ff0000000000000,1 +np.float64,0x4de4e6089bc9d,0x3ff0000000000000,1 +np.float64,0xf2e016afe5c03,0x3ff0000000000000,1 +np.float64,0xb9b7b949736f7,0x3ff0000000000000,1 +np.float64,0x3363ea1866c7e,0x3ff0000000000000,1 +np.float64,0xd1a3bd6ba3478,0x3ff0000000000000,1 +np.float64,0xae89f3595d13f,0x3ff0000000000000,1 +np.float64,0xddbd9601bb7c,0x3ff0000000000000,1 +np.float64,0x5de41a06bbc84,0x3ff0000000000000,1 +np.float64,0xfd58c86dfab19,0x3ff0000000000000,1 +np.float64,0x24922e8c49247,0x3ff0000000000000,1 +np.float64,0xcda040339b408,0x3ff0000000000000,1 +np.float64,0x5fe500b2bfca1,0x3ff0000000000000,1 +np.float64,0x9214abb924296,0x3ff0000000000000,1 +np.float64,0x800609fe0a2c13fd,0x3ff0000000000000,1 +np.float64,0x800c7c6fe518f8e0,0x3ff0000000000000,1 +np.float64,0x800a1a9491b4352a,0x3ff0000000000000,1 +np.float64,0x800b45e0e8968bc2,0x3ff0000000000000,1 +np.float64,0x8008497e57d092fd,0x3ff0000000000000,1 +np.float64,0x800b9c0af0173816,0x3ff0000000000000,1 +np.float64,0x800194cccb43299a,0x3ff0000000000000,1 +np.float64,0x8001c91ef183923f,0x3ff0000000000000,1 +np.float64,0x800f25b5ccde4b6c,0x3ff0000000000000,1 +np.float64,0x800ce63ccc79cc7a,0x3ff0000000000000,1 +np.float64,0x800d8fb2e83b1f66,0x3ff0000000000000,1 +np.float64,0x80083cd06f7079a1,0x3ff0000000000000,1 +np.float64,0x800823598e9046b3,0x3ff0000000000000,1 +np.float64,0x8001c1319de38264,0x3ff0000000000000,1 +np.float64,0x800f2b68543e56d1,0x3ff0000000000000,1 +np.float64,0x80022a4f4364549f,0x3ff0000000000000,1 +np.float64,0x800f51badf7ea376,0x3ff0000000000000,1 +np.float64,0x8003fbf31e27f7e7,0x3ff0000000000000,1 +np.float64,0x800d4c00e2fa9802,0x3ff0000000000000,1 +np.float64,0x800023b974804774,0x3ff0000000000000,1 +np.float64,0x800860778990c0ef,0x3ff0000000000000,1 +np.float64,0x800a15c241542b85,0x3ff0000000000000,1 +np.float64,0x8003097d9dc612fc,0x3ff0000000000000,1 +np.float64,0x800d77d8541aefb1,0x3ff0000000000000,1 +np.float64,0x80093804ab52700a,0x3ff0000000000000,1 +np.float64,0x800d2b3bfd7a5678,0x3ff0000000000000,1 +np.float64,0x800da24bcd5b4498,0x3ff0000000000000,1 +np.float64,0x8006eee1c28dddc4,0x3ff0000000000000,1 +np.float64,0x80005137fa40a271,0x3ff0000000000000,1 +np.float64,0x8007a3fbc22f47f8,0x3ff0000000000000,1 +np.float64,0x800dcd97071b9b2e,0x3ff0000000000000,1 +np.float64,0x80065b36048cb66d,0x3ff0000000000000,1 +np.float64,0x8004206ba72840d8,0x3ff0000000000000,1 +np.float64,0x8007e82b98cfd058,0x3ff0000000000000,1 +np.float64,0x8001a116ed23422f,0x3ff0000000000000,1 +np.float64,0x800c69e9ff18d3d4,0x3ff0000000000000,1 +np.float64,0x8003843688e7086e,0x3ff0000000000000,1 +np.float64,0x800335e3b8866bc8,0x3ff0000000000000,1 +np.float64,0x800e3308f0bc6612,0x3ff0000000000000,1 +np.float64,0x8002a9ec55c553d9,0x3ff0000000000000,1 +np.float64,0x80001c2084e03842,0x3ff0000000000000,1 +np.float64,0x800bc2bbd8d78578,0x3ff0000000000000,1 +np.float64,0x800ae6bcc555cd7a,0x3ff0000000000000,1 +np.float64,0x80083f7a13907ef5,0x3ff0000000000000,1 +np.float64,0x800d83ed76db07db,0x3ff0000000000000,1 +np.float64,0x800a12251974244b,0x3ff0000000000000,1 +np.float64,0x800a69c95714d393,0x3ff0000000000000,1 +np.float64,0x800cd5a85639ab51,0x3ff0000000000000,1 +np.float64,0x800e0e1837bc1c31,0x3ff0000000000000,1 +np.float64,0x8007b5ca39ef6b95,0x3ff0000000000000,1 +np.float64,0x800cf961cad9f2c4,0x3ff0000000000000,1 +np.float64,0x80066e8fc14cdd20,0x3ff0000000000000,1 +np.float64,0x8001cb8c7b43971a,0x3ff0000000000000,1 +np.float64,0x800002df68a005c0,0x3ff0000000000000,1 +np.float64,0x8003e6681567ccd1,0x3ff0000000000000,1 +np.float64,0x800b039126b60723,0x3ff0000000000000,1 +np.float64,0x800d2e1b663a5c37,0x3ff0000000000000,1 +np.float64,0x800188b3e2a31169,0x3ff0000000000000,1 +np.float64,0x8001f272e943e4e7,0x3ff0000000000000,1 +np.float64,0x800d7f53607afea7,0x3ff0000000000000,1 +np.float64,0x80092cafa4f25960,0x3ff0000000000000,1 +np.float64,0x800fc009f07f8014,0x3ff0000000000000,1 +np.float64,0x8003da896507b514,0x3ff0000000000000,1 +np.float64,0x800d4d1b4c3a9a37,0x3ff0000000000000,1 +np.float64,0x8007a835894f506c,0x3ff0000000000000,1 +np.float64,0x80057ba0522af741,0x3ff0000000000000,1 +np.float64,0x8009b7054b336e0b,0x3ff0000000000000,1 +np.float64,0x800b2c6c125658d9,0x3ff0000000000000,1 +np.float64,0x8008b1840ad16308,0x3ff0000000000000,1 +np.float64,0x8007ea0e3befd41d,0x3ff0000000000000,1 +np.float64,0x800dd658683bacb1,0x3ff0000000000000,1 +np.float64,0x8008cda48fd19b49,0x3ff0000000000000,1 +np.float64,0x8003acca14c75995,0x3ff0000000000000,1 +np.float64,0x8008bd152d717a2b,0x3ff0000000000000,1 +np.float64,0x80010d1ea3621a3e,0x3ff0000000000000,1 +np.float64,0x800130b78b826170,0x3ff0000000000000,1 +np.float64,0x8002cf3a46e59e75,0x3ff0000000000000,1 +np.float64,0x800b76e7fa76edd0,0x3ff0000000000000,1 +np.float64,0x800e065fe1dc0cc0,0x3ff0000000000000,1 +np.float64,0x8000dd527ea1baa6,0x3ff0000000000000,1 +np.float64,0x80032cb234665965,0x3ff0000000000000,1 +np.float64,0x800affc1acb5ff84,0x3ff0000000000000,1 +np.float64,0x80074be23fee97c5,0x3ff0000000000000,1 +np.float64,0x8004f83eafc9f07e,0x3ff0000000000000,1 +np.float64,0x800b02a115560543,0x3ff0000000000000,1 +np.float64,0x800b324a55766495,0x3ff0000000000000,1 +np.float64,0x800ffbcfd69ff7a0,0x3ff0000000000000,1 +np.float64,0x800830bc7b906179,0x3ff0000000000000,1 +np.float64,0x800cbafe383975fd,0x3ff0000000000000,1 +np.float64,0x8001ee42bfe3dc86,0x3ff0000000000000,1 +np.float64,0x8005b00fdc0b6020,0x3ff0000000000000,1 +np.float64,0x8005e7addd0bcf5c,0x3ff0000000000000,1 +np.float64,0x8001ae4cb0635c9a,0x3ff0000000000000,1 +np.float64,0x80098a9941131533,0x3ff0000000000000,1 +np.float64,0x800334c929466993,0x3ff0000000000000,1 +np.float64,0x8009568239d2ad05,0x3ff0000000000000,1 +np.float64,0x800f0639935e0c73,0x3ff0000000000000,1 +np.float64,0x800cebce7499d79d,0x3ff0000000000000,1 +np.float64,0x800482ee4c2905dd,0x3ff0000000000000,1 +np.float64,0x8007b7bd9e2f6f7c,0x3ff0000000000000,1 +np.float64,0x3fe654469f2ca88d,0x3fe8853f6c01ffb3,1 +np.float64,0x3feb4d7297369ae5,0x3fe50ad5bb621408,1 +np.float64,0x3feef53ba43dea77,0x3fe2283f356f8658,1 +np.float64,0x3fddf564eabbeaca,0x3fec8ec0e0dead9c,1 +np.float64,0x3fd3a69078274d21,0x3fee80e05c320000,1 +np.float64,0x3fecdafe5d39b5fd,0x3fe3d91a5d440fd9,1 +np.float64,0x3fd93286bc32650d,0x3fed8d40696cd10e,1 +np.float64,0x3fc0d34eb821a69d,0x3fefb954023d4284,1 +np.float64,0x3fc7b4b9a02f6973,0x3fef73e8739787ce,1 +np.float64,0x3fe08c839a611907,0x3febd0bc6f5641cd,1 +np.float64,0x3fb3d1758627a2eb,0x3fefe776f6183f96,1 +np.float64,0x3fef93c9ff3f2794,0x3fe1a4d2f622627d,1 +np.float64,0x3fea8d0041351a01,0x3fe59a52a1c78c9e,1 +np.float64,0x3fe3e26a30e7c4d4,0x3fea04ad3e0bbf8d,1 +np.float64,0x3fe5a34c9f6b4699,0x3fe8f57c5ccd1eab,1 +np.float64,0x3fc21ef859243df1,0x3fefae0b68a3a2e7,1 +np.float64,0x3fed7dd585fafbab,0x3fe35860041e5b0d,1 +np.float64,0x3fe5abacf22b575a,0x3fe8f03d8b6ef0f2,1 +np.float64,0x3fe426451f284c8a,0x3fe9dcf21f13205b,1 +np.float64,0x3fc01f6456203ec9,0x3fefbf19e2a8e522,1 +np.float64,0x3fe1cf2772239e4f,0x3feb2bbd645c7697,1 +np.float64,0x3fd18c4ace231896,0x3feecdfdd086c110,1 +np.float64,0x3fe8387d5b7070fb,0x3fe74358f2ec4910,1 +np.float64,0x3fdce51c2239ca38,0x3feccb2ae5459632,1 +np.float64,0x3fe5b0f2e4eb61e6,0x3fe8ecef4dbe4277,1 +np.float64,0x3fe1ceeb08a39dd6,0x3feb2bdd4dcfb3df,1 +np.float64,0x3febc5899d778b13,0x3fe4afc8dd8ad228,1 +np.float64,0x3fe7a47fbe2f48ff,0x3fe7a7fd9b352ea5,1 +np.float64,0x3fe7f74e1fafee9c,0x3fe76feb2755b247,1 +np.float64,0x3fe2bfad04e57f5a,0x3feaa9b46adddaeb,1 +np.float64,0x3fd06a090320d412,0x3feef40c334f8fba,1 +np.float64,0x3fdc97297d392e53,0x3fecdc16a3e22fcb,1 +np.float64,0x3fdc1a3f3838347e,0x3fecf6db2769d404,1 +np.float64,0x3fcca90096395201,0x3fef338156fcd218,1 +np.float64,0x3fed464733fa8c8e,0x3fe38483f0465d91,1 +np.float64,0x3fe7e067d82fc0d0,0x3fe77f7c8c9de896,1 +np.float64,0x3fc014fa0b2029f4,0x3fefbf6d84c933f8,1 +np.float64,0x3fd3bf1524277e2a,0x3fee7d2997b74dec,1 +np.float64,0x3fec153b86782a77,0x3fe472bb5497bb2a,1 +np.float64,0x3fd3e4d9d5a7c9b4,0x3fee776842691902,1 +np.float64,0x3fea6c0e2c74d81c,0x3fe5b2954cb458d9,1 +np.float64,0x3fee8f6a373d1ed4,0x3fe27bb9e348125b,1 +np.float64,0x3fd30c6dd42618dc,0x3fee97d2cab2b0bc,1 +np.float64,0x3fe4f90e6d69f21d,0x3fe95ea3dd4007f2,1 +np.float64,0x3fe271d467e4e3a9,0x3fead470d6d4008b,1 +np.float64,0x3fef2983897e5307,0x3fe1fd1a4debe33b,1 +np.float64,0x3fe980cc83b30199,0x3fe65d2fb8a0eb46,1 +np.float64,0x3fdfdf53db3fbea8,0x3fec1cf95b2a1cc7,1 +np.float64,0x3fe4d5307ba9aa61,0x3fe974701b4156cb,1 +np.float64,0x3fdb4e2345b69c47,0x3fed21aa6c146512,1 +np.float64,0x3fe3f7830327ef06,0x3fe9f85f6c88c2a8,1 +np.float64,0x3fca915fb63522bf,0x3fef502b73a52ecf,1 +np.float64,0x3fe66d3709ecda6e,0x3fe87531d7372d7a,1 +np.float64,0x3fd86000bcb0c001,0x3fedb5018dd684ca,1 +np.float64,0x3fe516e5feea2dcc,0x3fe94c68b111404e,1 +np.float64,0x3fd83c53dd3078a8,0x3fedbb9e5dd9e165,1 +np.float64,0x3fedfeeb673bfdd7,0x3fe2f0f0253c5d5d,1 +np.float64,0x3fe0dc6f9c21b8df,0x3feba8e2452410c2,1 +np.float64,0x3fbe154d643c2a9b,0x3fefc780a9357457,1 +np.float64,0x3fe5f63986abec73,0x3fe8c1434951a40a,1 +np.float64,0x3fbce0e50839c1ca,0x3fefcbeeaa27de75,1 +np.float64,0x3fd7ef5c5c2fdeb9,0x3fedc9c3022495b3,1 +np.float64,0x3fc1073914220e72,0x3fefb79de80fc0fd,1 +np.float64,0x3fe1a93c3d235278,0x3feb3fb21f86ac67,1 +np.float64,0x3fe321ee53e643dd,0x3fea72e2999f1e22,1 +np.float64,0x3fa881578c3102af,0x3feff69e6e51e0d6,1 +np.float64,0x3fd313482a262690,0x3fee96d161199495,1 +np.float64,0x3fe7272cd6ae4e5a,0x3fe7fbacbd0d8f43,1 +np.float64,0x3fd6cf4015ad9e80,0x3fedfd3513d544b8,1 +np.float64,0x3fc67b7e6d2cf6fd,0x3fef81f5c16923a4,1 +np.float64,0x3fa1999c14233338,0x3feffb2913a14184,1 +np.float64,0x3fc74eb8dd2e9d72,0x3fef78909a138e3c,1 +np.float64,0x3fc0b9274921724f,0x3fefba2ebd5f3e1c,1 +np.float64,0x3fd53fa156aa7f43,0x3fee40a18e952e88,1 +np.float64,0x3feaccbca4b59979,0x3fe56b22b33eb713,1 +np.float64,0x3fe6a01e3a2d403c,0x3fe8543fbd820ecc,1 +np.float64,0x3fd392a869a72551,0x3fee83e0ffe0e8de,1 +np.float64,0x3fe44d8928689b12,0x3fe9c5bf3c8fffdb,1 +np.float64,0x3fca3f209f347e41,0x3fef5461b6fa0924,1 +np.float64,0x3fee9e84b07d3d09,0x3fe26f638f733549,1 +np.float64,0x3faf49acb03e9359,0x3feff0b583cd8c48,1 +np.float64,0x3fea874b2af50e96,0x3fe59e882fa6febf,1 +np.float64,0x3fc50b72772a16e5,0x3fef918777dc41be,1 +np.float64,0x3fe861d1d4f0c3a4,0x3fe726e44d9d42c2,1 +np.float64,0x3fcadd2e2535ba5c,0x3fef4c3e2b56da38,1 +np.float64,0x3fea59c29cb4b385,0x3fe5c0043e586439,1 +np.float64,0x3fc1ffef0d23ffde,0x3fefaf22be452d13,1 +np.float64,0x3fc2d8dbc125b1b8,0x3fefa75b646d8e4e,1 +np.float64,0x3fd66c6471acd8c9,0x3fee0e5038b895c0,1 +np.float64,0x3fd0854adfa10a96,0x3feef0945bcc5c99,1 +np.float64,0x3feaac7076f558e1,0x3fe58316c23a82ad,1 +np.float64,0x3fdda49db3bb493b,0x3feca0e347c0ad6f,1 +np.float64,0x3fe43a539de874a7,0x3fe9d11d722d4822,1 +np.float64,0x3feeee3ebbfddc7d,0x3fe22dffd251e9af,1 +np.float64,0x3f8ee2c5b03dc58b,0x3fefff11855a7b6c,1 +np.float64,0x3fcd7107c63ae210,0x3fef2840bb55ca52,1 +np.float64,0x3f8d950d203b2a1a,0x3fefff253a08e40e,1 +np.float64,0x3fd40a5e57a814bd,0x3fee71a633c761fc,1 +np.float64,0x3fee836ec83d06de,0x3fe28580975be2fd,1 +np.float64,0x3fd7bbe87f2f77d1,0x3fedd31f661890cc,1 +np.float64,0xbfe05bf138a0b7e2,0x3febe8a000d96e47,1 +np.float64,0xbf88bddd90317bc0,0x3fefff66f6e2ff26,1 +np.float64,0xbfdc9cbb12393976,0x3fecdae2982335db,1 +np.float64,0xbfd85b4eccb0b69e,0x3fedb5e0dd87f702,1 +np.float64,0xbfe5c326cb2b864e,0x3fe8e180f525fa12,1 +np.float64,0xbfe381a0e4a70342,0x3fea3c8e5e3ab78e,1 +np.float64,0xbfe58d892c2b1b12,0x3fe9031551617aed,1 +np.float64,0xbfd7f3a52cafe74a,0x3fedc8fa97edd080,1 +np.float64,0xbfef3417bc7e682f,0x3fe1f45989f6a009,1 +np.float64,0xbfddfb8208bbf704,0x3fec8d5fa9970773,1 +np.float64,0xbfdab69bcc356d38,0x3fed40b2f6c347c6,1 +np.float64,0xbfed3f7cf17a7efa,0x3fe389e4ff4d9235,1 +np.float64,0xbfe47675d9a8ecec,0x3fe9ad6829a69e94,1 +np.float64,0xbfd030e2902061c6,0x3feefb3f811e024f,1 +np.float64,0xbfc376ac7226ed58,0x3fefa1798712b37e,1 +np.float64,0xbfdb7e54a0b6fcaa,0x3fed17a974c4bc28,1 +np.float64,0xbfdb7d5d5736faba,0x3fed17dcf31a8d84,1 +np.float64,0xbf876bd6502ed7c0,0x3fefff76dce6232c,1 +np.float64,0xbfd211e6c02423ce,0x3feebba41f0a1764,1 +np.float64,0xbfb443e3962887c8,0x3fefe658953629d4,1 +np.float64,0xbfe81b09e9b03614,0x3fe757882e4fdbae,1 +np.float64,0xbfdcb905d2b9720c,0x3fecd4c22cfe84e5,1 +np.float64,0xbfe3b62d99276c5b,0x3fea1e5520b3098d,1 +np.float64,0xbfbf05b25c3e0b68,0x3fefc3ecc04bca8e,1 +np.float64,0xbfdedc885b3db910,0x3fec59e22feb49f3,1 +np.float64,0xbfe33aa282667545,0x3fea64f2d55ec471,1 +np.float64,0xbfec84745a3908e9,0x3fe41cb3214e7044,1 +np.float64,0xbfddefdff1bbdfc0,0x3fec8fff88d4d0ec,1 +np.float64,0xbfd26ae6aca4d5ce,0x3feeaf208c7fedf6,1 +np.float64,0xbfee010591fc020b,0x3fe2ef3e57211a5e,1 +np.float64,0xbfb8cfddca319fb8,0x3fefd98d8f7918ed,1 +np.float64,0xbfe991648f3322c9,0x3fe6514e54670bae,1 +np.float64,0xbfee63fd087cc7fa,0x3fe29f1bfa3297cc,1 +np.float64,0xbfe1685942a2d0b2,0x3feb617f5f839eee,1 +np.float64,0xbfc6fc2fd62df860,0x3fef7c4698fd58cf,1 +np.float64,0xbfe42723d3a84e48,0x3fe9dc6ef7243e90,1 +np.float64,0xbfc3a7e89d274fd0,0x3fef9f99e3314e77,1 +np.float64,0xbfeb4c9521f6992a,0x3fe50b7c919bc6d8,1 +np.float64,0xbf707b34e020f680,0x3fefffef05e30264,1 +np.float64,0xbfc078478e20f090,0x3fefbc479305d5aa,1 +np.float64,0xbfd494ac4ca92958,0x3fee5c11f1cd8269,1 +np.float64,0xbfdaf888a035f112,0x3fed3346ae600469,1 +np.float64,0xbfa5d8ed502bb1e0,0x3feff88b0f262609,1 +np.float64,0xbfeec0cbfffd8198,0x3fe253543b2371cb,1 +np.float64,0xbfe594b5986b296b,0x3fe8fe9b39fb3940,1 +np.float64,0xbfc8ece7c631d9d0,0x3fef652bd0611ac7,1 +np.float64,0xbfd8ffeca0b1ffda,0x3fed96ebdf9b65cb,1 +np.float64,0xbfba9b221e353648,0x3fefd3cc21e2f15c,1 +np.float64,0xbfca63a52c34c74c,0x3fef52848eb9ed3b,1 +np.float64,0xbfe588e9b06b11d4,0x3fe905f7403e8881,1 +np.float64,0xbfc76f82db2edf04,0x3fef77138fe9bbc2,1 +np.float64,0xbfeeb3f334bd67e6,0x3fe25ddadb1096d6,1 +np.float64,0xbfbf2b64ce3e56c8,0x3fefc35a9555f6df,1 +np.float64,0xbfe9920e4ff3241c,0x3fe650d4ab8f5c42,1 +np.float64,0xbfb4a54c02294a98,0x3fefe55fc85ae5e9,1 +np.float64,0xbfe353b0c766a762,0x3fea56c02d17e4b7,1 +np.float64,0xbfd99961a4b332c4,0x3fed795fcd00dbf9,1 +np.float64,0xbfef191ddabe323c,0x3fe20aa79524f636,1 +np.float64,0xbfb25d060224ba10,0x3fefeaeee5cc8c0b,1 +np.float64,0xbfe6022428ec0448,0x3fe8b9b46e776194,1 +np.float64,0xbfed1a236cba3447,0x3fe3a76bee0d9861,1 +np.float64,0xbfc59671e72b2ce4,0x3fef8bc4daef6f14,1 +np.float64,0xbfdf2711703e4e22,0x3fec4886a8c9ceb5,1 +np.float64,0xbfeb7e207536fc41,0x3fe4e610c783f168,1 +np.float64,0xbfe6cdf5bcad9bec,0x3fe8365f8a59bc81,1 +np.float64,0xbfe55294adaaa52a,0x3fe927b0af5ccd09,1 +np.float64,0xbfdf4a88913e9512,0x3fec4036df58ba74,1 +np.float64,0xbfebb7efe4376fe0,0x3fe4ba276006992d,1 +np.float64,0xbfe09f29cfa13e54,0x3febc77f4f9c95e7,1 +np.float64,0xbfdf8c75653f18ea,0x3fec30ac924e4f46,1 +np.float64,0xbfefd601c7ffac04,0x3fe16d6f21bcb9c1,1 +np.float64,0xbfeae97ff5f5d300,0x3fe555bb5b87efe9,1 +np.float64,0xbfed427f02fa84fe,0x3fe387830db093bc,1 +np.float64,0xbfa33909cc267210,0x3feffa3a1bcb50dd,1 +np.float64,0xbfe9aa4bf5f35498,0x3fe63f6e98f6aa0f,1 +np.float64,0xbfe2d7349b25ae69,0x3fea9caa7c331e7e,1 +np.float64,0xbfcdbb2a3a3b7654,0x3fef2401c9659e4b,1 +np.float64,0xbfc8a90919315214,0x3fef686fe7fc0513,1 +np.float64,0xbfe62a98df2c5532,0x3fe89ff22a02cc6b,1 +np.float64,0xbfdc0f67b3b81ed0,0x3fecf928b637798f,1 +np.float64,0xbfebb32bf6f76658,0x3fe4bdc893c09698,1 +np.float64,0xbfec067996380cf3,0x3fe47e132741db97,1 +np.float64,0xbfd9774e1d32ee9c,0x3fed7ffe1e87c434,1 +np.float64,0xbfef989890bf3131,0x3fe1a0d025c80cf4,1 +np.float64,0xbfe59887e62b3110,0x3fe8fc382a3d4197,1 +np.float64,0xbfdea0a11e3d4142,0x3fec67b987e236ec,1 +np.float64,0xbfe2ec495825d892,0x3fea90efb231602d,1 +np.float64,0xbfb329c5c2265388,0x3fefe90f1b8209c3,1 +np.float64,0xbfdcd2dcd339a5ba,0x3feccf24c60b1478,1 +np.float64,0xbfe537ea18aa6fd4,0x3fe938237e217fe0,1 +np.float64,0xbfe8675ce170ceba,0x3fe723105925ce3a,1 +np.float64,0xbfd70723acae0e48,0x3fedf369ac070e65,1 +np.float64,0xbfea9d8692b53b0d,0x3fe58e1ee42e3fdb,1 +np.float64,0xbfcfeb96653fd72c,0x3fef029770033bdc,1 +np.float64,0xbfcc06c92d380d94,0x3fef3c69797d9b0a,1 +np.float64,0xbfe16b7c4f62d6f8,0x3feb5fdf9f0a9a07,1 +np.float64,0xbfed4d7a473a9af4,0x3fe37ecee27b1eb7,1 +np.float64,0xbfe6a6f6942d4ded,0x3fe84fccdf762b19,1 +np.float64,0xbfda46d867348db0,0x3fed572d928fa657,1 +np.float64,0xbfdbd9482db7b290,0x3fed049b5f907b52,1 +np.float64,0x7fe992ceb933259c,0xbfeb15af92aad70e,1 +np.float64,0x7fe3069204a60d23,0xbfe5eeff454240e9,1 +np.float64,0x7fe729dbf32e53b7,0xbfefe0528a330e4c,1 +np.float64,0x7fec504fb638a09e,0x3fd288e95dbedf65,1 +np.float64,0x7fe1d30167a3a602,0xbfeffc41f946fd02,1 +np.float64,0x7fed7f8ffd3aff1f,0x3fefe68ec604a19d,1 +np.float64,0x7fd2f23635a5e46b,0x3fea63032efbb447,1 +np.float64,0x7fd4c86db1a990da,0x3fdf6b9f7888db5d,1 +np.float64,0x7fe7554db6eeaa9a,0x3fe1b41476861bb0,1 +np.float64,0x7fe34e823ba69d03,0x3fefc435532e6294,1 +np.float64,0x7fec5c82fef8b905,0x3fef8f0c6473034f,1 +np.float64,0x7feba221bff74442,0xbfea95b81eb19b47,1 +np.float64,0x7fe74808a5ae9010,0xbfd3aa322917c3e5,1 +np.float64,0x7fdf41b7e0be836f,0x3fd14283c7147282,1 +np.float64,0x7fec09892f381311,0x3fe5240376ae484b,1 +np.float64,0x7faaf80bf435f017,0x3fe20227fa811423,1 +np.float64,0x7f8422d8402845b0,0x3fe911714593b8a0,1 +np.float64,0x7fd23a7fada474fe,0x3feff9f40aa37e9c,1 +np.float64,0x7fef4a4806fe948f,0x3fec6eca89cb4a62,1 +np.float64,0x7fe1e71cf763ce39,0xbfea6ac63f9ba457,1 +np.float64,0x7fe3e555be27caaa,0xbfe75b305d0dbbfd,1 +np.float64,0x7fcb8bac96371758,0xbfe8b126077f9d4c,1 +np.float64,0x7fc98e2c84331c58,0x3fef9092eb0bc85a,1 +np.float64,0x7fe947cf2b728f9d,0xbfebfff2c5b7d198,1 +np.float64,0x7feee8058c3dd00a,0xbfef21ebaae2eb17,1 +np.float64,0x7fef61d8d5bec3b1,0xbfdf1a032fb1c864,1 +np.float64,0x7fcf714b6f3ee296,0x3fe6fc89a8084098,1 +np.float64,0x7fa9a8b44c335168,0xbfeb16c149cea943,1 +np.float64,0x7fd175c482a2eb88,0xbfef64d341e73f88,1 +np.float64,0x7feab8e6a87571cc,0x3feb10069c397464,1 +np.float64,0x7fe3ade72de75bcd,0x3fd1753e333d5790,1 +np.float64,0x7fb26d87d224db0f,0xbfe753d36b18f4ca,1 +np.float64,0x7fdb7ef159b6fde2,0x3fe5c0a6044d3607,1 +np.float64,0x7fd5af86422b5f0c,0x3fe77193c95f6484,1 +np.float64,0x7fee9e00b07d3c00,0x3fe864d494596845,1 +np.float64,0x7fef927a147f24f3,0xbfe673b14715693d,1 +np.float64,0x7fd0aea63c215d4b,0xbfeff435f119fce9,1 +np.float64,0x7fd02e3796a05c6e,0x3fe4f7e3706e9a3d,1 +np.float64,0x7fd3ed61da27dac3,0xbfefef2f057f168c,1 +np.float64,0x7fefaca0d4ff5941,0x3fd3e8ad205cd4ab,1 +np.float64,0x7feb659e06f6cb3b,0x3fd64d803203e027,1 +np.float64,0x7fc94ccfaf32999e,0x3fee04922209369a,1 +np.float64,0x7feb4ec294f69d84,0xbfd102763a056c89,1 +np.float64,0x7fe2ada6ac655b4c,0x3fef4f6792aa6093,1 +np.float64,0x7fe5f40fdc2be81f,0xbfb4a6327186eee8,1 +np.float64,0x7fe7584bc3eeb097,0xbfd685b8ff94651d,1 +np.float64,0x7fe45d276be8ba4e,0x3fee53b13f7e442f,1 +np.float64,0x7fe6449b3d6c8935,0xbfe7e08bafa75251,1 +np.float64,0x7f8d62e6b03ac5cc,0x3fe73d30762f38fd,1 +np.float64,0x7fe3a76f72a74ede,0xbfeb48a28bc60968,1 +np.float64,0x7fd057706920aee0,0x3fdece8fa06f626c,1 +np.float64,0x7fe45ae158e8b5c2,0x3fe7a70f47b4d349,1 +np.float64,0x7fea8a5a983514b4,0x3fefb053d5f9ddd7,1 +np.float64,0x7fdd1e86ab3a3d0c,0x3fe3cded1b93816b,1 +np.float64,0x7fdb456108b68ac1,0xbfe37574c0b9bf8f,1 +np.float64,0x7fe972602432e4bf,0x3fef9a26e65ec01c,1 +np.float64,0x7fdbe2385637c470,0x3fed541df57969e1,1 +np.float64,0x7fe57f03602afe06,0x3fbd90f595cbbd94,1 +np.float64,0x7feb0ceb68f619d6,0xbfeae9cb8ee5261f,1 +np.float64,0x7fe6abfe6c6d57fc,0xbfef40a6edaca26f,1 +np.float64,0x7fe037ea08606fd3,0xbfda817d75858597,1 +np.float64,0x7fdd75a52dbaeb49,0x3feef2a0d91d6aa1,1 +np.float64,0x7fe8f9af66b1f35e,0xbfedfceef2a3bfc9,1 +np.float64,0x7fedf762b53beec4,0x3fd8b4f21ef69ee3,1 +np.float64,0x7fe99295b7f3252a,0x3feffc24d970383e,1 +np.float64,0x7fe797b0172f2f5f,0x3fee089aa56f7ce8,1 +np.float64,0x7fed89dcc97b13b9,0xbfcfa2bb0c3ea41f,1 +np.float64,0x7fae9e8d5c3d3d1a,0xbfe512ffe16c6b08,1 +np.float64,0x7fefaecbe27f5d97,0x3fbfc718a5e972f1,1 +np.float64,0x7fce0236d93c046d,0xbfa9b7cd790db256,1 +np.float64,0x7fa9689aac32d134,0x3feced501946628a,1 +np.float64,0x7feb1469e93628d3,0x3fef2a988e7673ed,1 +np.float64,0x7fdba78344b74f06,0xbfe092e78965b30c,1 +np.float64,0x7fece54c3fb9ca97,0x3fd3cfd184bed2e6,1 +np.float64,0x7fdb84212b370841,0xbfe25ebf2db6ee55,1 +np.float64,0x7fbe3e8bf23c7d17,0x3fe2ee72df573345,1 +np.float64,0x7fe43d9803687b2f,0xbfed2eff6a9e66a0,1 +np.float64,0x7fb0f9c00a21f37f,0x3feff70f3276fdb7,1 +np.float64,0x7fea0c6cbbb418d8,0xbfefa612494798b2,1 +np.float64,0x7fe4b3239e296646,0xbfe74dd959af8cdc,1 +np.float64,0x7fe5c6a773eb8d4e,0xbfd06944048f8d2b,1 +np.float64,0x7fb1c1278223824e,0xbfeb533a34655bde,1 +np.float64,0x7fd21c09ee243813,0xbfe921ccbc9255c3,1 +np.float64,0x7fe051020c20a203,0x3fbd519d700c1f2f,1 +np.float64,0x7fe0c76845e18ed0,0x3fefb9595191a31b,1 +np.float64,0x7fe6b0b57b6d616a,0xbf8c59a8ba5fcd9a,1 +np.float64,0x7fd386c460270d88,0x3fe8ffea5d1a5c46,1 +np.float64,0x7feeb884713d7108,0x3fee9b2247ef6c0d,1 +np.float64,0x7fd85f71b6b0bee2,0xbfefc30ec3e28f07,1 +np.float64,0x7fc341366426826c,0x3fd4234d35386d3b,1 +np.float64,0x7fe56482dd6ac905,0x3fe7189de6a50668,1 +np.float64,0x7fec67a2e3f8cf45,0xbfef86d0b940f37f,1 +np.float64,0x7fe38b202fe7163f,0x3feb90b75caa2030,1 +np.float64,0x7fdcbc64883978c8,0x3fed4f758fbf64d4,1 +np.float64,0x7fea5f0598f4be0a,0x3fdd503a417b3d4d,1 +np.float64,0x7fda3b6bcf3476d7,0x3fea6e9af3f7f9f5,1 +np.float64,0x7fc7d7896c2faf12,0x3fda2bebc36a2363,1 +np.float64,0x7fe7e8e2626fd1c4,0xbfe7d5e390c4cc3f,1 +np.float64,0x7fde0f3d7abc1e7a,0xbfede7a0ecfa3606,1 +np.float64,0x7fc692b8f52d2571,0x3feff0cd7ab6f61b,1 +np.float64,0xff92d1fce825a400,0xbfc921c36fc014fa,1 +np.float64,0xffdec3af2fbd875e,0xbfed6a77e6a0364e,1 +np.float64,0xffef46e7d9be8dcf,0xbfed7d39476f7e27,1 +np.float64,0xffe2c2ce4525859c,0x3fe1757261316bc9,1 +np.float64,0xffe27c8b5864f916,0xbfefe017c0d43457,1 +np.float64,0xffe184d7442309ae,0x3fa1fb8c49dba596,1 +np.float64,0xffddf5f98d3bebf4,0x3fee4f8eaa5f847e,1 +np.float64,0xffee3ef354fc7de6,0xbfebfd60fa51b2ba,1 +np.float64,0xffdecb3e85bd967e,0x3fbfad2667a8b468,1 +np.float64,0xffe4ee900b29dd20,0xbfdc02dc626f91cd,1 +np.float64,0xffd3179f6da62f3e,0xbfe2cfe442511776,1 +np.float64,0xffe99ef7cef33def,0x3f50994542a7f303,1 +np.float64,0xffe2b66b1ae56cd6,0xbfefe3e066eb6329,1 +np.float64,0xff8f72aff03ee540,0x3fe9c46224cf5003,1 +np.float64,0xffd29beb85a537d8,0x3fefcb0b6166be71,1 +np.float64,0xffaef02d4c3de060,0xbfef5fb71028fc72,1 +np.float64,0xffd39a2a89273456,0x3fe6d4b183205dca,1 +np.float64,0xffef8a9392ff1526,0x3fedb99fbf402468,1 +np.float64,0xffb9b3f31e3367e8,0x3fee1005270fcf80,1 +np.float64,0xffed9d5c693b3ab8,0x3fd110f4b02365d5,1 +np.float64,0xffeaba45f9f5748b,0x3fe499e0a6f4afb2,1 +np.float64,0xffdba3f70d3747ee,0xbfca0c30493ae519,1 +np.float64,0xffa35b985426b730,0xbfdb625df56bcf45,1 +np.float64,0xffccbc9728397930,0x3fc53cbc59020704,1 +np.float64,0xffef73c942bee792,0xbfdc647a7a5e08be,1 +np.float64,0xffcb5acfb236b5a0,0x3feeb4ec038c39fc,1 +np.float64,0xffea116fe2b422df,0x3fefe03b6ae0b435,1 +np.float64,0xffe97de6e7b2fbcd,0xbfd2025698fab9eb,1 +np.float64,0xffdddba314bbb746,0x3fd31f0fdb8f93be,1 +np.float64,0xffd613a24a2c2744,0xbfebbb1efae884b3,1 +np.float64,0xffe3d938aa67b271,0xbfc2099cead3d3be,1 +np.float64,0xffdf08c2e33e1186,0xbfefd236839b900d,1 +np.float64,0xffea6ba8bd34d751,0x3fe8dfc032114719,1 +np.float64,0xffe3202083e64040,0x3fed513b81432a22,1 +np.float64,0xffb2397db62472f8,0xbfee7d7fe1c3f76c,1 +np.float64,0xffd9d0682ab3a0d0,0x3fe0bcf9e531ad79,1 +np.float64,0xffc293df202527c0,0xbfe58d0bdece5e64,1 +np.float64,0xffe1422c7da28458,0xbf81bd72595f2341,1 +np.float64,0xffd64e4ed4ac9c9e,0x3fa4334cc011c703,1 +np.float64,0xffe40a970ae8152e,0x3fead3d258b55b7d,1 +np.float64,0xffc8c2f2223185e4,0xbfef685f07c8b9fd,1 +np.float64,0xffe4b2f7216965ee,0x3fe3861d3d896a83,1 +np.float64,0xffdb531db3b6a63c,0x3fe18cb8332dd59d,1 +np.float64,0xffe8e727a3b1ce4e,0xbfe57b15abb677b9,1 +np.float64,0xffe530c1e12a6184,0xbfb973ea5535e48f,1 +np.float64,0xffe6f7849cedef08,0x3fd39a37ec5af4b6,1 +np.float64,0xffead62a78b5ac54,0x3fe69b3f6c7aa24b,1 +np.float64,0xffeefdd725fdfbad,0xbfc08a456111fdd5,1 +np.float64,0xffe682182fed0430,0x3fecc7c1292761d2,1 +np.float64,0xffee0ca8dcbc1951,0x3fef6cc361ef2c19,1 +np.float64,0xffec9b338f393666,0x3fefa9ab8e0471b5,1 +np.float64,0xffe13c5e29a278bc,0xbfef8da74ad83398,1 +np.float64,0xffd7bd48c62f7a92,0x3fe3468cd4ac9d34,1 +np.float64,0xffedd0ed14bba1d9,0xbfd563a83477077b,1 +np.float64,0xffe86b83f3f0d707,0x3fe9eb3c658e4b2d,1 +np.float64,0xffd6a4db4bad49b6,0xbfc7e11276166e17,1 +np.float64,0xffc29e8404253d08,0x3fd35971961c789f,1 +np.float64,0xffe27cf3d664f9e7,0xbfeca0f73c72f810,1 +np.float64,0xffc34152352682a4,0x3fef384e564c002c,1 +np.float64,0xffe395728ba72ae4,0x3f8fe18c2de86eba,1 +np.float64,0xffed86c4fbbb0d89,0x3fef709db881c672,1 +np.float64,0xffe8a98d37f1531a,0x3fd4879c8f73c3dc,1 +np.float64,0xffb8ce9fea319d40,0xbfb853c8fe46b08d,1 +np.float64,0xffe7f26db8efe4db,0xbfec1cfd3e5c2ac1,1 +np.float64,0xffd7935b77af26b6,0x3fb7368c89b2a460,1 +np.float64,0xffc5840ed02b081c,0x3fd92220b56631f3,1 +np.float64,0xffc36a873926d510,0x3fa84d61baf61811,1 +np.float64,0xffe06ea583e0dd4a,0x3feb647e348b9e39,1 +np.float64,0xffe6a33031ed4660,0xbfe096b851dc1a0a,1 +np.float64,0xffe001c938e00392,0x3fe4eece77623e7a,1 +np.float64,0xffc1e4f23b23c9e4,0xbfdb9bb1f83f6ac4,1 +np.float64,0xffecd3ecbab9a7d9,0x3fbafb1f800f177d,1 +np.float64,0xffc2d3016825a604,0xbfef650e8b0d6afb,1 +np.float64,0xffe222cb68e44596,0x3fde3690e44de5bd,1 +np.float64,0xffe5bb145e2b7628,0x3fedbb98e23c9dc1,1 +np.float64,0xffe9e5823b73cb04,0xbfee41661016c03c,1 +np.float64,0xffd234a00ba46940,0x3fda0312cda580c2,1 +np.float64,0xffe0913ed6e1227d,0xbfed508bb529bd23,1 +np.float64,0xffe8e3596171c6b2,0xbfdc33e1c1d0310e,1 +np.float64,0xffef9c6835ff38cf,0x3fea8ce6d27dfba3,1 +np.float64,0xffdd3bcf66ba779e,0x3fe50523d2b6470e,1 +np.float64,0xffe57e8cf06afd1a,0xbfee600933347247,1 +np.float64,0xffe0d8c65fa1b18c,0x3fe75091f93d5e4c,1 +np.float64,0xffea7c8c16b4f918,0x3fee681724795198,1 +np.float64,0xffe34f7a05269ef4,0xbfe3c3e179676f13,1 +np.float64,0xffd28894a6a5112a,0xbfe5d1027aee615d,1 +np.float64,0xffc73be6f22e77cc,0x3fe469bbc08b472a,1 +np.float64,0xffe7f71b066fee36,0x3fe7ed136c8fdfaa,1 +np.float64,0xffebc13e29f7827c,0x3fefcdc6e677d314,1 +np.float64,0xffd53e9c942a7d3a,0x3fea5a02c7341749,1 +np.float64,0xffd7191b23ae3236,0x3fea419b66023443,1 +np.float64,0xffe9480325b29006,0xbfefeaff5fa38cd5,1 +np.float64,0xffba46dc0e348db8,0xbfefa54f4de28eba,1 +np.float64,0xffdd4cc31eba9986,0x3fe60bb41fe1c4da,1 +np.float64,0xffe13a70dea274e1,0xbfaa9192f7bd6c9b,1 +np.float64,0xffde25127bbc4a24,0x3f7c75f45e29be7d,1 +np.float64,0xffe4076543a80eca,0x3fea5aad50d2f687,1 +np.float64,0xffe61512acec2a25,0xbfefffeb67401649,1 +np.float64,0xffef812ec1ff025d,0xbfe919c7c073c766,1 +np.float64,0xffd5552aeaaaaa56,0x3fc89d38ab047396,1 diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/data/umath-validation-set-cosh.csv b/venv/lib/python3.12/site-packages/numpy/_core/tests/data/umath-validation-set-cosh.csv new file mode 100644 index 00000000..af14d847 --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/tests/data/umath-validation-set-cosh.csv @@ -0,0 +1,1429 @@ +dtype,input,output,ulperrortol +np.float32,0xfe0ac238,0x7f800000,3 +np.float32,0xbf553b86,0x3faf079b,3 +np.float32,0xff4457da,0x7f800000,3 +np.float32,0xff7253f3,0x7f800000,3 +np.float32,0x5a5802,0x3f800000,3 +np.float32,0x3db03413,0x3f80795b,3 +np.float32,0x7f6795c9,0x7f800000,3 +np.float32,0x805b9142,0x3f800000,3 +np.float32,0xfeea581a,0x7f800000,3 +np.float32,0x3f7e2dba,0x3fc472f6,3 +np.float32,0x3d9c4d74,0x3f805f7a,3 +np.float32,0x7f18c665,0x7f800000,3 +np.float32,0x7f003e23,0x7f800000,3 +np.float32,0x3d936fa0,0x3f8054f3,3 +np.float32,0x3f32034f,0x3fa0368e,3 +np.float32,0xff087604,0x7f800000,3 +np.float32,0x380a5,0x3f800000,3 +np.float32,0x3f59694e,0x3fb10077,3 +np.float32,0x3e63e648,0x3f832ee4,3 +np.float32,0x80712f42,0x3f800000,3 +np.float32,0x3e169908,0x3f816302,3 +np.float32,0x3f2d766e,0x3f9e8692,3 +np.float32,0x3d6412e0,0x3f8032d0,3 +np.float32,0xbde689e8,0x3f80cfd4,3 +np.float32,0x483e2e,0x3f800000,3 +np.float32,0xff1ba2d0,0x7f800000,3 +np.float32,0x80136bff,0x3f800000,3 +np.float32,0x3f72534c,0x3fbdc1d4,3 +np.float32,0x3e9eb381,0x3f8632c6,3 +np.float32,0x3e142892,0x3f815795,3 +np.float32,0x0,0x3f800000,3 +np.float32,0x2f2528,0x3f800000,3 +np.float32,0x7f38be13,0x7f800000,3 +np.float32,0xfeee6896,0x7f800000,3 +np.float32,0x7f09095d,0x7f800000,3 +np.float32,0xbe94d,0x3f800000,3 +np.float32,0xbedcf8d4,0x3f8c1b74,3 +np.float32,0xbf694c02,0x3fb8ef07,3 +np.float32,0x3e2261f8,0x3f819cde,3 +np.float32,0xbf01d3ce,0x3f90d0e0,3 +np.float32,0xbeb7b3a2,0x3f8853de,3 +np.float32,0x8046de7b,0x3f800000,3 +np.float32,0xbcb45ea0,0x3f8007f1,3 +np.float32,0x3eef14af,0x3f8e35dd,3 +np.float32,0xbf047316,0x3f91846e,3 +np.float32,0x801cef45,0x3f800000,3 +np.float32,0x3e9ad891,0x3f85e609,3 +np.float32,0xff20e9cf,0x7f800000,3 +np.float32,0x80068434,0x3f800000,3 +np.float32,0xbe253020,0x3f81ab49,3 +np.float32,0x3f13f4b8,0x3f95fac9,3 +np.float32,0x804accd1,0x3f800000,3 +np.float32,0x3dee3e10,0x3f80ddf7,3 +np.float32,0xbe6c4690,0x3f836c29,3 +np.float32,0xff30d431,0x7f800000,3 +np.float32,0xbec82416,0x3f89e791,3 +np.float32,0x3f30bbcb,0x3f9fbbcc,3 +np.float32,0x3f5620a2,0x3faf72b8,3 +np.float32,0x807a8130,0x3f800000,3 +np.float32,0x3e3cb02d,0x3f822de0,3 +np.float32,0xff4839ac,0x7f800000,3 +np.float32,0x800a3e9c,0x3f800000,3 +np.float32,0x3dffd65b,0x3f810002,3 +np.float32,0xbf2b1492,0x3f9da987,3 +np.float32,0xbf21602c,0x3f9a48fe,3 +np.float32,0x512531,0x3f800000,3 +np.float32,0x24b99a,0x3f800000,3 +np.float32,0xbf53e345,0x3fae67b1,3 +np.float32,0xff2126ec,0x7f800000,3 +np.float32,0x7e79b49d,0x7f800000,3 +np.float32,0x3ea3cf04,0x3f869b6f,3 +np.float32,0x7f270059,0x7f800000,3 +np.float32,0x3f625b2f,0x3fb561e1,3 +np.float32,0xbf59947e,0x3fb11519,3 +np.float32,0xfe0d1c64,0x7f800000,3 +np.float32,0xbf3f3eae,0x3fa568e2,3 +np.float32,0x7c04d1,0x3f800000,3 +np.float32,0x7e66bd,0x3f800000,3 +np.float32,0x8011880d,0x3f800000,3 +np.float32,0x3f302f07,0x3f9f8759,3 +np.float32,0x4e3375,0x3f800000,3 +np.float32,0xfe67a134,0x7f800000,3 +np.float32,0xff670249,0x7f800000,3 +np.float32,0x7e19f27d,0x7f800000,3 +np.float32,0xbf36ce12,0x3fa20b81,3 +np.float32,0xbe6bcfc4,0x3f8368b5,3 +np.float32,0x76fcba,0x3f800000,3 +np.float32,0x7f30abaf,0x7f800000,3 +np.float32,0x3f4c1f6d,0x3faae43c,3 +np.float32,0x7f61f44a,0x7f800000,3 +np.float32,0xbf4bb3c9,0x3faab4af,3 +np.float32,0xbda15ee0,0x3f8065c6,3 +np.float32,0xfbb4e800,0x7f800000,3 +np.float32,0x7fa00000,0x7fe00000,3 +np.float32,0x80568501,0x3f800000,3 +np.float32,0xfeb285e4,0x7f800000,3 +np.float32,0x804423a7,0x3f800000,3 +np.float32,0x7e6c0f21,0x7f800000,3 +np.float32,0x7f136b3c,0x7f800000,3 +np.float32,0x3f2d08e6,0x3f9e5e9c,3 +np.float32,0xbf6b454e,0x3fb9f7e6,3 +np.float32,0x3e6bceb0,0x3f8368ad,3 +np.float32,0xff1ad16a,0x7f800000,3 +np.float32,0x7cce1a04,0x7f800000,3 +np.float32,0xff7bcf95,0x7f800000,3 +np.float32,0x8049788d,0x3f800000,3 +np.float32,0x7ec45918,0x7f800000,3 +np.float32,0xff7fffff,0x7f800000,3 +np.float32,0x8039a1a0,0x3f800000,3 +np.float32,0x7e90cd72,0x7f800000,3 +np.float32,0xbf7dfd53,0x3fc456cc,3 +np.float32,0x3eeeb664,0x3f8e2a76,3 +np.float32,0x8055ef9b,0x3f800000,3 +np.float32,0x7ee06ddd,0x7f800000,3 +np.float32,0xba2cc000,0x3f800002,3 +np.float32,0x806da632,0x3f800000,3 +np.float32,0x7ecfaaf5,0x7f800000,3 +np.float32,0x3ddd12e6,0x3f80bf19,3 +np.float32,0xbf754394,0x3fbf60b1,3 +np.float32,0x6f3f19,0x3f800000,3 +np.float32,0x800a9af0,0x3f800000,3 +np.float32,0xfeef13ea,0x7f800000,3 +np.float32,0x7f74841f,0x7f800000,3 +np.float32,0xbeb9a2f0,0x3f888181,3 +np.float32,0x77cbb,0x3f800000,3 +np.float32,0xbf587f84,0x3fb0911b,3 +np.float32,0x210ba5,0x3f800000,3 +np.float32,0x3ee60a28,0x3f8d2367,3 +np.float32,0xbe3731ac,0x3f820dc7,3 +np.float32,0xbee8cfee,0x3f8d765e,3 +np.float32,0x7b2ef179,0x7f800000,3 +np.float32,0xfe81377c,0x7f800000,3 +np.float32,0x6ac98c,0x3f800000,3 +np.float32,0x3f51f144,0x3fad8288,3 +np.float32,0x80785750,0x3f800000,3 +np.float32,0x3f46615a,0x3fa864ff,3 +np.float32,0xbf35ac9e,0x3fa19b8e,3 +np.float32,0x7f0982ac,0x7f800000,3 +np.float32,0x1b2610,0x3f800000,3 +np.float32,0x3ed8bb25,0x3f8ba3df,3 +np.float32,0xbeb41bac,0x3f88006d,3 +np.float32,0xff48e89d,0x7f800000,3 +np.float32,0x3ed0ab8c,0x3f8ac755,3 +np.float32,0xbe64671c,0x3f833282,3 +np.float32,0x64bce4,0x3f800000,3 +np.float32,0x284f79,0x3f800000,3 +np.float32,0x7e09faa7,0x7f800000,3 +np.float32,0x4376c1,0x3f800000,3 +np.float32,0x805ca8c0,0x3f800000,3 +np.float32,0xff0859d5,0x7f800000,3 +np.float32,0xbed2f3b2,0x3f8b04dd,3 +np.float32,0x8045bd0c,0x3f800000,3 +np.float32,0x3f0e6216,0x3f94503f,3 +np.float32,0x3f41e3ae,0x3fa68035,3 +np.float32,0x80088ccc,0x3f800000,3 +np.float32,0x3f37fc19,0x3fa2812f,3 +np.float32,0x71c87d,0x3f800000,3 +np.float32,0x8024f4b2,0x3f800000,3 +np.float32,0xff78dd88,0x7f800000,3 +np.float32,0xbda66c90,0x3f806c40,3 +np.float32,0x7f33ef0d,0x7f800000,3 +np.float32,0x46a343,0x3f800000,3 +np.float32,0xff1dce38,0x7f800000,3 +np.float32,0x1b935d,0x3f800000,3 +np.float32,0x3ebec598,0x3f88fd0e,3 +np.float32,0xff115530,0x7f800000,3 +np.float32,0x803916aa,0x3f800000,3 +np.float32,0xff60a3e2,0x7f800000,3 +np.float32,0x3b8ddd48,0x3f80004f,3 +np.float32,0x3f761b6e,0x3fbfd8ea,3 +np.float32,0xbdf55b88,0x3f80eb70,3 +np.float32,0x37374,0x3f800000,3 +np.float32,0x3de150e0,0x3f80c682,3 +np.float32,0x3f343278,0x3fa10a83,3 +np.float32,0xbe9baefa,0x3f85f68b,3 +np.float32,0x3d8d43,0x3f800000,3 +np.float32,0x3e80994b,0x3f840f0c,3 +np.float32,0xbe573c6c,0x3f82d685,3 +np.float32,0x805b83b4,0x3f800000,3 +np.float32,0x683d88,0x3f800000,3 +np.float32,0x692465,0x3f800000,3 +np.float32,0xbdc345f8,0x3f809511,3 +np.float32,0x3f7c1c5a,0x3fc3406f,3 +np.float32,0xbf40bef3,0x3fa606df,3 +np.float32,0xff1e25b9,0x7f800000,3 +np.float32,0x3e4481e0,0x3f825d37,3 +np.float32,0x75d188,0x3f800000,3 +np.float32,0x3ea53cec,0x3f86b956,3 +np.float32,0xff105a54,0x7f800000,3 +np.float32,0x7f800000,0x7f800000,3 +np.float32,0x7f11f0b0,0x7f800000,3 +np.float32,0xbf58a57d,0x3fb0a328,3 +np.float32,0xbdd11e38,0x3f80aaf8,3 +np.float32,0xbea94adc,0x3f870fa0,3 +np.float32,0x3e9dd780,0x3f862180,3 +np.float32,0xff1786b9,0x7f800000,3 +np.float32,0xfec46aa2,0x7f800000,3 +np.float32,0x7f4300c1,0x7f800000,3 +np.float32,0x29ba2b,0x3f800000,3 +np.float32,0x3f4112e2,0x3fa62993,3 +np.float32,0xbe6c9224,0x3f836e5d,3 +np.float32,0x7f0e42a3,0x7f800000,3 +np.float32,0xff6390ad,0x7f800000,3 +np.float32,0x3f54e374,0x3faede94,3 +np.float32,0x7f2642a2,0x7f800000,3 +np.float32,0x7f46b2be,0x7f800000,3 +np.float32,0xfe59095c,0x7f800000,3 +np.float32,0x7146a0,0x3f800000,3 +np.float32,0x3f07763d,0x3f925786,3 +np.float32,0x3d172780,0x3f801651,3 +np.float32,0xff66f1c5,0x7f800000,3 +np.float32,0xff025349,0x7f800000,3 +np.float32,0x6ce99d,0x3f800000,3 +np.float32,0xbf7e4f50,0x3fc48685,3 +np.float32,0xbeff8ca2,0x3f904708,3 +np.float32,0x3e6c8,0x3f800000,3 +np.float32,0x7f7153dc,0x7f800000,3 +np.float32,0xbedcf612,0x3f8c1b26,3 +np.float32,0xbbc2f180,0x3f800094,3 +np.float32,0xbf397399,0x3fa314b8,3 +np.float32,0x6c6e35,0x3f800000,3 +np.float32,0x7f50a88b,0x7f800000,3 +np.float32,0xfe84093e,0x7f800000,3 +np.float32,0x3f737b9d,0x3fbe6478,3 +np.float32,0x7f6a5340,0x7f800000,3 +np.float32,0xbde83c20,0x3f80d2e7,3 +np.float32,0xff769ce9,0x7f800000,3 +np.float32,0xfdd33c30,0x7f800000,3 +np.float32,0xbc95cb60,0x3f80057a,3 +np.float32,0x8007a40d,0x3f800000,3 +np.float32,0x3f55d90c,0x3faf5132,3 +np.float32,0x80282082,0x3f800000,3 +np.float32,0xbf43b1f2,0x3fa7418c,3 +np.float32,0x3f1dc7cb,0x3f991731,3 +np.float32,0xbd4346a0,0x3f80253f,3 +np.float32,0xbf5aa82a,0x3fb19946,3 +np.float32,0x3f4b8c22,0x3faaa333,3 +np.float32,0x3d13468c,0x3f80152f,3 +np.float32,0x7db77097,0x7f800000,3 +np.float32,0x4a00df,0x3f800000,3 +np.float32,0xbedea5e0,0x3f8c4b64,3 +np.float32,0x80482543,0x3f800000,3 +np.float32,0xbef344fe,0x3f8eb8dd,3 +np.float32,0x7ebd4044,0x7f800000,3 +np.float32,0xbf512c0e,0x3fad287e,3 +np.float32,0x3db28cce,0x3f807c9c,3 +np.float32,0xbd0f5ae0,0x3f801412,3 +np.float32,0xfe7ed9ac,0x7f800000,3 +np.float32,0x3eb1aa82,0x3f87c8b4,3 +np.float32,0xfef1679e,0x7f800000,3 +np.float32,0xff3629f2,0x7f800000,3 +np.float32,0xff3562b4,0x7f800000,3 +np.float32,0x3dcafe1d,0x3f80a118,3 +np.float32,0xfedf242a,0x7f800000,3 +np.float32,0xbf43102a,0x3fa6fda4,3 +np.float32,0x8028834e,0x3f800000,3 +np.float32,0x805c8513,0x3f800000,3 +np.float32,0x3f59306a,0x3fb0e550,3 +np.float32,0x3eda2c9c,0x3f8bcc4a,3 +np.float32,0x80023524,0x3f800000,3 +np.float32,0x7ef72879,0x7f800000,3 +np.float32,0x661c8a,0x3f800000,3 +np.float32,0xfec3ba6c,0x7f800000,3 +np.float32,0x805aaca6,0x3f800000,3 +np.float32,0xff5c1f13,0x7f800000,3 +np.float32,0x3f6ab3f4,0x3fb9ab6b,3 +np.float32,0x3f014896,0x3f90ac20,3 +np.float32,0x3f030584,0x3f91222a,3 +np.float32,0xbf74853d,0x3fbef71d,3 +np.float32,0xbf534ee0,0x3fae2323,3 +np.float32,0x2c90c3,0x3f800000,3 +np.float32,0x7f62ad25,0x7f800000,3 +np.float32,0x1c8847,0x3f800000,3 +np.float32,0x7e2a8d43,0x7f800000,3 +np.float32,0x807a09cd,0x3f800000,3 +np.float32,0x413871,0x3f800000,3 +np.float32,0x80063692,0x3f800000,3 +np.float32,0x3edaf29b,0x3f8be211,3 +np.float32,0xbf64a7ab,0x3fb68b2d,3 +np.float32,0xfe56a720,0x7f800000,3 +np.float32,0xbf54a8d4,0x3faec350,3 +np.float32,0x3ecbaef7,0x3f8a4350,3 +np.float32,0x3f413714,0x3fa63890,3 +np.float32,0x7d3aa8,0x3f800000,3 +np.float32,0xbea9a13c,0x3f8716e7,3 +np.float32,0x7ef7553e,0x7f800000,3 +np.float32,0x8056f29f,0x3f800000,3 +np.float32,0xff1f7ffe,0x7f800000,3 +np.float32,0x3f41953b,0x3fa65f9c,3 +np.float32,0x3daa2f,0x3f800000,3 +np.float32,0xff0893e4,0x7f800000,3 +np.float32,0xbefc7ec6,0x3f8fe207,3 +np.float32,0xbb026800,0x3f800011,3 +np.float32,0x341e4f,0x3f800000,3 +np.float32,0x3e7b708a,0x3f83e0d1,3 +np.float32,0xa18cb,0x3f800000,3 +np.float32,0x7e290239,0x7f800000,3 +np.float32,0xbf4254f2,0x3fa6af62,3 +np.float32,0x80000000,0x3f800000,3 +np.float32,0x3f0a6c,0x3f800000,3 +np.float32,0xbec44d28,0x3f898609,3 +np.float32,0xf841f,0x3f800000,3 +np.float32,0x7f01a693,0x7f800000,3 +np.float32,0x8053340b,0x3f800000,3 +np.float32,0xfd4e7990,0x7f800000,3 +np.float32,0xbf782f1f,0x3fc10356,3 +np.float32,0xbe962118,0x3f858acc,3 +np.float32,0xfe8cd702,0x7f800000,3 +np.float32,0x7ecd986f,0x7f800000,3 +np.float32,0x3ebe775f,0x3f88f59b,3 +np.float32,0x8065524f,0x3f800000,3 +np.float32,0x3ede7fc4,0x3f8c471e,3 +np.float32,0x7f5e15ea,0x7f800000,3 +np.float32,0xbe871ada,0x3f847b78,3 +np.float32,0x3f21958b,0x3f9a5af7,3 +np.float32,0x3f64d480,0x3fb6a1fa,3 +np.float32,0xff18b0e9,0x7f800000,3 +np.float32,0xbf0840dd,0x3f928fd9,3 +np.float32,0x80104f5d,0x3f800000,3 +np.float32,0x643b94,0x3f800000,3 +np.float32,0xbc560a80,0x3f8002cc,3 +np.float32,0x3f5c75d6,0x3fb2786e,3 +np.float32,0x7f365fc9,0x7f800000,3 +np.float32,0x54e965,0x3f800000,3 +np.float32,0x6dcd4d,0x3f800000,3 +np.float32,0x3f2057a0,0x3f99f04d,3 +np.float32,0x272fa3,0x3f800000,3 +np.float32,0xff423dc9,0x7f800000,3 +np.float32,0x80273463,0x3f800000,3 +np.float32,0xfe21cc78,0x7f800000,3 +np.float32,0x7fc00000,0x7fc00000,3 +np.float32,0x802feb65,0x3f800000,3 +np.float32,0x3dc733d0,0x3f809b21,3 +np.float32,0x65d56b,0x3f800000,3 +np.float32,0x80351d8e,0x3f800000,3 +np.float32,0xbf244247,0x3f9b43dd,3 +np.float32,0x7f328e7e,0x7f800000,3 +np.float32,0x7f4d9712,0x7f800000,3 +np.float32,0x2c505d,0x3f800000,3 +np.float32,0xbf232ebe,0x3f9ae5a0,3 +np.float32,0x804a363a,0x3f800000,3 +np.float32,0x80417102,0x3f800000,3 +np.float32,0xbf48b170,0x3fa963d4,3 +np.float32,0x7ea3e3b6,0x7f800000,3 +np.float32,0xbf41415b,0x3fa63cd2,3 +np.float32,0xfe3af7c8,0x7f800000,3 +np.float32,0x7f478010,0x7f800000,3 +np.float32,0x80143113,0x3f800000,3 +np.float32,0x3f7626a7,0x3fbfdf2e,3 +np.float32,0xfea20b0a,0x7f800000,3 +np.float32,0x80144d64,0x3f800000,3 +np.float32,0x7db9ba47,0x7f800000,3 +np.float32,0x7f7fffff,0x7f800000,3 +np.float32,0xbe410834,0x3f8247ef,3 +np.float32,0x14a7af,0x3f800000,3 +np.float32,0x7eaebf9e,0x7f800000,3 +np.float32,0xff800000,0x7f800000,3 +np.float32,0x3f0a7d8e,0x3f9330fd,3 +np.float32,0x3ef780,0x3f800000,3 +np.float32,0x3f62253e,0x3fb546d1,3 +np.float32,0x3f4cbeac,0x3fab2acc,3 +np.float32,0x25db1,0x3f800000,3 +np.float32,0x65c54a,0x3f800000,3 +np.float32,0x800f0645,0x3f800000,3 +np.float32,0x3ed28c78,0x3f8af9f0,3 +np.float32,0x8040c6ce,0x3f800000,3 +np.float32,0x5e4e9a,0x3f800000,3 +np.float32,0xbd3fd2b0,0x3f8023f1,3 +np.float32,0xbf5d2d3f,0x3fb2d1b6,3 +np.float32,0x7ead999f,0x7f800000,3 +np.float32,0xbf30dc86,0x3f9fc805,3 +np.float32,0xff2b0a62,0x7f800000,3 +np.float32,0x3d5180e9,0x3f802adf,3 +np.float32,0x3f62716f,0x3fb56d0d,3 +np.float32,0x7e82ae9c,0x7f800000,3 +np.float32,0xfe2d4bdc,0x7f800000,3 +np.float32,0x805cc7d4,0x3f800000,3 +np.float32,0xfb50f700,0x7f800000,3 +np.float32,0xff57b684,0x7f800000,3 +np.float32,0x80344f01,0x3f800000,3 +np.float32,0x7f2af372,0x7f800000,3 +np.float32,0xfeab6204,0x7f800000,3 +np.float32,0x30b251,0x3f800000,3 +np.float32,0x3eed8cc4,0x3f8e0698,3 +np.float32,0x7eeb1c6a,0x7f800000,3 +np.float32,0x3f17ece6,0x3f9735b0,3 +np.float32,0x21e985,0x3f800000,3 +np.float32,0x3f3a7df3,0x3fa37e34,3 +np.float32,0x802a14a2,0x3f800000,3 +np.float32,0x807d4d5b,0x3f800000,3 +np.float32,0x7f6093ce,0x7f800000,3 +np.float32,0x3f800000,0x3fc583ab,3 +np.float32,0x3da2c26e,0x3f806789,3 +np.float32,0xfe05f278,0x7f800000,3 +np.float32,0x800000,0x3f800000,3 +np.float32,0xbee63342,0x3f8d282e,3 +np.float32,0xbf225586,0x3f9a9bd4,3 +np.float32,0xbed60e86,0x3f8b59ba,3 +np.float32,0xbec99484,0x3f8a0ca3,3 +np.float32,0x3e967c71,0x3f859199,3 +np.float32,0x7f26ab62,0x7f800000,3 +np.float32,0xca7f4,0x3f800000,3 +np.float32,0xbf543790,0x3fae8ebc,3 +np.float32,0x3e4c1ed9,0x3f828d2d,3 +np.float32,0xbdf37f88,0x3f80e7e1,3 +np.float32,0xff0cc44e,0x7f800000,3 +np.float32,0x5dea48,0x3f800000,3 +np.float32,0x31023c,0x3f800000,3 +np.float32,0x3ea10733,0x3f866208,3 +np.float32,0x3e11e6f2,0x3f814d2e,3 +np.float32,0x80641960,0x3f800000,3 +np.float32,0x3ef779a8,0x3f8f3edb,3 +np.float32,0x3f2a5062,0x3f9d632a,3 +np.float32,0x2b7d34,0x3f800000,3 +np.float32,0x3eeb95c5,0x3f8dca67,3 +np.float32,0x805c1357,0x3f800000,3 +np.float32,0x3db3a79d,0x3f807e29,3 +np.float32,0xfded1900,0x7f800000,3 +np.float32,0x45f362,0x3f800000,3 +np.float32,0x451f38,0x3f800000,3 +np.float32,0x801d3ae5,0x3f800000,3 +np.float32,0x458d45,0x3f800000,3 +np.float32,0xfda9d298,0x7f800000,3 +np.float32,0x467439,0x3f800000,3 +np.float32,0x7f66554a,0x7f800000,3 +np.float32,0xfef2375a,0x7f800000,3 +np.float32,0xbf33fc47,0x3fa0f5d7,3 +np.float32,0x3f75ba69,0x3fbfa2d0,3 +np.float32,0xfeb625b2,0x7f800000,3 +np.float32,0x8066b371,0x3f800000,3 +np.float32,0x3f5cb4e9,0x3fb29718,3 +np.float32,0x7f3b6a58,0x7f800000,3 +np.float32,0x7f6b35ea,0x7f800000,3 +np.float32,0xbf6ee555,0x3fbbe5be,3 +np.float32,0x3d836e21,0x3f804380,3 +np.float32,0xff43cd0c,0x7f800000,3 +np.float32,0xff55c1fa,0x7f800000,3 +np.float32,0xbf0dfccc,0x3f9432a6,3 +np.float32,0x3ed92121,0x3f8baf00,3 +np.float32,0x80068cc1,0x3f800000,3 +np.float32,0xff0103f9,0x7f800000,3 +np.float32,0x7e51b175,0x7f800000,3 +np.float32,0x8012f214,0x3f800000,3 +np.float32,0x62d298,0x3f800000,3 +np.float32,0xbf3e1525,0x3fa4ef8d,3 +np.float32,0x806b4882,0x3f800000,3 +np.float32,0xbf38c146,0x3fa2ce7c,3 +np.float32,0xbed59c30,0x3f8b4d70,3 +np.float32,0x3d1910c0,0x3f8016e2,3 +np.float32,0x7f33d55b,0x7f800000,3 +np.float32,0x7f5800e3,0x7f800000,3 +np.float32,0x5b2c5d,0x3f800000,3 +np.float32,0x807be750,0x3f800000,3 +np.float32,0x7eb297c1,0x7f800000,3 +np.float32,0x7dafee62,0x7f800000,3 +np.float32,0x7d9e23f0,0x7f800000,3 +np.float32,0x3e580537,0x3f82dbd8,3 +np.float32,0xbf800000,0x3fc583ab,3 +np.float32,0x7f40f880,0x7f800000,3 +np.float32,0x775ad3,0x3f800000,3 +np.float32,0xbedacd36,0x3f8bddf3,3 +np.float32,0x2138f6,0x3f800000,3 +np.float32,0x52c3b7,0x3f800000,3 +np.float32,0x8041cfdd,0x3f800000,3 +np.float32,0x7bf16791,0x7f800000,3 +np.float32,0xbe95869c,0x3f857f55,3 +np.float32,0xbf199796,0x3f97bcaf,3 +np.float32,0x3ef8da38,0x3f8f6b45,3 +np.float32,0x803f3648,0x3f800000,3 +np.float32,0x80026fd2,0x3f800000,3 +np.float32,0x7eb3ac26,0x7f800000,3 +np.float32,0x3e49921b,0x3f827ce8,3 +np.float32,0xbf689aed,0x3fb892de,3 +np.float32,0x3f253509,0x3f9b9779,3 +np.float32,0xff17894a,0x7f800000,3 +np.float32,0x3cd12639,0x3f800aae,3 +np.float32,0x1db14b,0x3f800000,3 +np.float32,0x39a0bf,0x3f800000,3 +np.float32,0xfdfe1d08,0x7f800000,3 +np.float32,0xff416cd2,0x7f800000,3 +np.float32,0x8070d818,0x3f800000,3 +np.float32,0x3e516e12,0x3f82afb8,3 +np.float32,0x80536651,0x3f800000,3 +np.float32,0xbf2903d2,0x3f9cecb7,3 +np.float32,0x3e896ae4,0x3f84a353,3 +np.float32,0xbd6ba2c0,0x3f80363d,3 +np.float32,0x80126d3e,0x3f800000,3 +np.float32,0xfd9d43d0,0x7f800000,3 +np.float32,0x7b56b6,0x3f800000,3 +np.float32,0xff04718e,0x7f800000,3 +np.float32,0x31440f,0x3f800000,3 +np.float32,0xbf7a1313,0x3fc215c9,3 +np.float32,0x7f43d6a0,0x7f800000,3 +np.float32,0x3f566503,0x3faf92cc,3 +np.float32,0xbf39eb0e,0x3fa343f1,3 +np.float32,0xbe35fd70,0x3f8206df,3 +np.float32,0x800c36ac,0x3f800000,3 +np.float32,0x60d061,0x3f800000,3 +np.float32,0x80453e12,0x3f800000,3 +np.float32,0xfe17c36c,0x7f800000,3 +np.float32,0x3d8c72,0x3f800000,3 +np.float32,0xfe8e9134,0x7f800000,3 +np.float32,0xff5d89de,0x7f800000,3 +np.float32,0x7f45020e,0x7f800000,3 +np.float32,0x3f28225e,0x3f9c9d01,3 +np.float32,0xbf3b6900,0x3fa3dbdd,3 +np.float32,0x80349023,0x3f800000,3 +np.float32,0xbf14d780,0x3f964042,3 +np.float32,0x3f56b5d2,0x3fafb8c3,3 +np.float32,0x800c639c,0x3f800000,3 +np.float32,0x7f7a19c8,0x7f800000,3 +np.float32,0xbf7a0815,0x3fc20f86,3 +np.float32,0xbec55926,0x3f89a06e,3 +np.float32,0x4b2cd2,0x3f800000,3 +np.float32,0xbf271eb2,0x3f9c41c8,3 +np.float32,0xff26e168,0x7f800000,3 +np.float32,0x800166b2,0x3f800000,3 +np.float32,0xbde97e38,0x3f80d532,3 +np.float32,0xbf1f93ec,0x3f99af1a,3 +np.float32,0x7f2896ed,0x7f800000,3 +np.float32,0x3da7d96d,0x3f806e1d,3 +np.float32,0x802b7237,0x3f800000,3 +np.float32,0xfdca6bc0,0x7f800000,3 +np.float32,0xbed2e300,0x3f8b0318,3 +np.float32,0x8079d9e8,0x3f800000,3 +np.float32,0x3f388c81,0x3fa2b9c2,3 +np.float32,0x3ed2607c,0x3f8af54a,3 +np.float32,0xff287de6,0x7f800000,3 +np.float32,0x3f55ed89,0x3faf5ac9,3 +np.float32,0x7f5b6af7,0x7f800000,3 +np.float32,0xbeb24730,0x3f87d698,3 +np.float32,0x1,0x3f800000,3 +np.float32,0x3f3a2350,0x3fa35a3b,3 +np.float32,0x8013b422,0x3f800000,3 +np.float32,0x3e9a6560,0x3f85dd35,3 +np.float32,0x80510631,0x3f800000,3 +np.float32,0xfeae39d6,0x7f800000,3 +np.float32,0x7eb437ad,0x7f800000,3 +np.float32,0x8047545b,0x3f800000,3 +np.float32,0x806a1c71,0x3f800000,3 +np.float32,0xbe5543f0,0x3f82c93b,3 +np.float32,0x40e8d,0x3f800000,3 +np.float32,0x63d18b,0x3f800000,3 +np.float32,0x1fa1ea,0x3f800000,3 +np.float32,0x801944e0,0x3f800000,3 +np.float32,0xbf4c7ac6,0x3fab0cae,3 +np.float32,0x7f2679d4,0x7f800000,3 +np.float32,0x3f0102fc,0x3f9099d0,3 +np.float32,0x7e44bdc1,0x7f800000,3 +np.float32,0xbf2072f6,0x3f99f970,3 +np.float32,0x5c7d38,0x3f800000,3 +np.float32,0x30a2e6,0x3f800000,3 +np.float32,0x805b9ca3,0x3f800000,3 +np.float32,0x7cc24ad5,0x7f800000,3 +np.float32,0x3f4f7920,0x3fac6357,3 +np.float32,0x111d62,0x3f800000,3 +np.float32,0xbf4de40a,0x3fabad77,3 +np.float32,0x805d0354,0x3f800000,3 +np.float32,0xbb3d2b00,0x3f800023,3 +np.float32,0x3ef229e7,0x3f8e960b,3 +np.float32,0x3f15754e,0x3f9670e0,3 +np.float32,0xbf689c6b,0x3fb893a5,3 +np.float32,0xbf3796c6,0x3fa2599b,3 +np.float32,0xbe95303c,0x3f8578f2,3 +np.float32,0xfee330de,0x7f800000,3 +np.float32,0xff0d9705,0x7f800000,3 +np.float32,0xbeb0ebd0,0x3f87b7dd,3 +np.float32,0xbf4d5a13,0x3fab6fe7,3 +np.float32,0x80142f5a,0x3f800000,3 +np.float32,0x7e01a87b,0x7f800000,3 +np.float32,0xbe45e5ec,0x3f8265d7,3 +np.float32,0x7f4ac255,0x7f800000,3 +np.float32,0x3ebf6a60,0x3f890ccb,3 +np.float32,0x7f771e16,0x7f800000,3 +np.float32,0x3f41834e,0x3fa6582b,3 +np.float32,0x3f7f6f98,0x3fc52ef0,3 +np.float32,0x7e4ad775,0x7f800000,3 +np.float32,0x3eb39991,0x3f87f4c4,3 +np.float32,0x1e3f4,0x3f800000,3 +np.float32,0x7e84ba19,0x7f800000,3 +np.float32,0x80640be4,0x3f800000,3 +np.float32,0x3f459fc8,0x3fa81272,3 +np.float32,0x3f554ed0,0x3faf109b,3 +np.float32,0x3c6617,0x3f800000,3 +np.float32,0x7f441158,0x7f800000,3 +np.float32,0x7f66e6d8,0x7f800000,3 +np.float32,0x7f565152,0x7f800000,3 +np.float32,0x7f16d550,0x7f800000,3 +np.float32,0xbd4f1950,0x3f8029e5,3 +np.float32,0xcf722,0x3f800000,3 +np.float32,0x3f37d6fd,0x3fa272ad,3 +np.float32,0xff7324ea,0x7f800000,3 +np.float32,0x804bc246,0x3f800000,3 +np.float32,0x7f099ef8,0x7f800000,3 +np.float32,0x5f838b,0x3f800000,3 +np.float32,0x80523534,0x3f800000,3 +np.float32,0x3f595e84,0x3fb0fb50,3 +np.float32,0xfdef8ac8,0x7f800000,3 +np.float32,0x3d9a07,0x3f800000,3 +np.float32,0x410f61,0x3f800000,3 +np.float32,0xbf715dbb,0x3fbd3bcb,3 +np.float32,0xbedd4734,0x3f8c242f,3 +np.float32,0x7e86739a,0x7f800000,3 +np.float32,0x3e81f144,0x3f8424fe,3 +np.float32,0x7f6342d1,0x7f800000,3 +np.float32,0xff6919a3,0x7f800000,3 +np.float32,0xff051878,0x7f800000,3 +np.float32,0x800ba28f,0x3f800000,3 +np.float32,0xfefab3d8,0x7f800000,3 +np.float32,0xff612a84,0x7f800000,3 +np.float32,0x800cd5ab,0x3f800000,3 +np.float32,0x802a07ae,0x3f800000,3 +np.float32,0xfef6ee3a,0x7f800000,3 +np.float32,0x8037e896,0x3f800000,3 +np.float32,0x3ef2d86f,0x3f8eab7d,3 +np.float32,0x3eafe53d,0x3f87a0cb,3 +np.float32,0xba591c00,0x3f800003,3 +np.float32,0x3e9ed028,0x3f863508,3 +np.float32,0x4a12a8,0x3f800000,3 +np.float32,0xbee55c84,0x3f8d0f45,3 +np.float32,0x8038a8d3,0x3f800000,3 +np.float32,0xff055243,0x7f800000,3 +np.float32,0xbf659067,0x3fb701ca,3 +np.float32,0xbee36a86,0x3f8cd5e0,3 +np.float32,0x7f1d74c1,0x7f800000,3 +np.float32,0xbf7657df,0x3fbffaad,3 +np.float32,0x7e37ee34,0x7f800000,3 +np.float32,0xff04bc74,0x7f800000,3 +np.float32,0x806d194e,0x3f800000,3 +np.float32,0x7f5596c3,0x7f800000,3 +np.float32,0xbe09d268,0x3f81293e,3 +np.float32,0x79ff75,0x3f800000,3 +np.float32,0xbf55479c,0x3faf0d3e,3 +np.float32,0xbe5428ec,0x3f82c1d4,3 +np.float32,0x3f624134,0x3fb554d7,3 +np.float32,0x2ccb8a,0x3f800000,3 +np.float32,0xfc082040,0x7f800000,3 +np.float32,0xff315467,0x7f800000,3 +np.float32,0x3e6ea2d2,0x3f837dd5,3 +np.float32,0x8020fdd1,0x3f800000,3 +np.float32,0x7f0416a1,0x7f800000,3 +np.float32,0x710a1b,0x3f800000,3 +np.float32,0x3dfcd050,0x3f80f9fc,3 +np.float32,0xfe995e96,0x7f800000,3 +np.float32,0x3f020d00,0x3f90e006,3 +np.float32,0x8064263e,0x3f800000,3 +np.float32,0xfcee4160,0x7f800000,3 +np.float32,0x801b3a18,0x3f800000,3 +np.float32,0x3f62c984,0x3fb59955,3 +np.float32,0x806e8355,0x3f800000,3 +np.float32,0x7e94f65d,0x7f800000,3 +np.float32,0x1173de,0x3f800000,3 +np.float32,0x3e3ff3b7,0x3f824166,3 +np.float32,0x803b4aea,0x3f800000,3 +np.float32,0x804c5bcc,0x3f800000,3 +np.float32,0x509fe5,0x3f800000,3 +np.float32,0xbf33b5ee,0x3fa0db0b,3 +np.float32,0x3f2ac15c,0x3f9d8ba4,3 +np.float32,0x7f2c54f8,0x7f800000,3 +np.float32,0x7f33d933,0x7f800000,3 +np.float32,0xbf09b2b4,0x3f92f795,3 +np.float32,0x805db8d6,0x3f800000,3 +np.float32,0x6d6e66,0x3f800000,3 +np.float32,0x3ddfea92,0x3f80c40c,3 +np.float32,0xfda719b8,0x7f800000,3 +np.float32,0x5d657f,0x3f800000,3 +np.float32,0xbf005ba3,0x3f906df6,3 +np.float32,0xbf45e606,0x3fa8305c,3 +np.float32,0x5e9fd1,0x3f800000,3 +np.float32,0x8079dc45,0x3f800000,3 +np.float32,0x7e9c40e3,0x7f800000,3 +np.float32,0x6bd5f6,0x3f800000,3 +np.float32,0xbea14a0e,0x3f866761,3 +np.float32,0x7e7323f3,0x7f800000,3 +np.float32,0x7f0c0a79,0x7f800000,3 +np.float32,0xbf7d7aeb,0x3fc40b0f,3 +np.float32,0x437588,0x3f800000,3 +np.float32,0xbf356376,0x3fa17f63,3 +np.float32,0x7f129921,0x7f800000,3 +np.float32,0x7f47a52e,0x7f800000,3 +np.float32,0xba8cb400,0x3f800005,3 +np.float32,0x802284e0,0x3f800000,3 +np.float32,0xbe820f56,0x3f8426ec,3 +np.float32,0x7f2ef6cf,0x7f800000,3 +np.float32,0xbf70a090,0x3fbcd501,3 +np.float32,0xbf173fea,0x3f96ff6d,3 +np.float32,0x3e19c489,0x3f817224,3 +np.float32,0x7f429b30,0x7f800000,3 +np.float32,0xbdae4118,0x3f8076af,3 +np.float32,0x3e70ad30,0x3f838d41,3 +np.float32,0x335fed,0x3f800000,3 +np.float32,0xff5359cf,0x7f800000,3 +np.float32,0xbf17e42b,0x3f9732f1,3 +np.float32,0xff3a950b,0x7f800000,3 +np.float32,0xbcca70c0,0x3f800a02,3 +np.float32,0x3f2cda62,0x3f9e4dad,3 +np.float32,0x3f50c185,0x3facf805,3 +np.float32,0x80000001,0x3f800000,3 +np.float32,0x807b86d2,0x3f800000,3 +np.float32,0x8010c2cf,0x3f800000,3 +np.float32,0x3f130fb8,0x3f95b519,3 +np.float32,0x807dc546,0x3f800000,3 +np.float32,0xbee20740,0x3f8cad3f,3 +np.float32,0x80800000,0x3f800000,3 +np.float32,0x3cbd90c0,0x3f8008c6,3 +np.float32,0x3e693488,0x3f835571,3 +np.float32,0xbe70cd44,0x3f838e35,3 +np.float32,0xbe348dc8,0x3f81feb1,3 +np.float32,0x3f31ea90,0x3fa02d3f,3 +np.float32,0xfcd7e180,0x7f800000,3 +np.float32,0xbe30a75c,0x3f81e8d0,3 +np.float32,0x3e552c5a,0x3f82c89d,3 +np.float32,0xff513f74,0x7f800000,3 +np.float32,0xbdb16248,0x3f807afd,3 +np.float64,0x7fbbf954e437f2a9,0x7ff0000000000000,1 +np.float64,0x581bbf0cb0379,0x3ff0000000000000,1 +np.float64,0x7ff8000000000000,0x7ff8000000000000,1 +np.float64,0xffb959a2a632b348,0x7ff0000000000000,1 +np.float64,0xbfdbd6baebb7ad76,0x3ff189a5ca25a6e1,1 +np.float64,0xbfd094ec9aa129da,0x3ff08a3f6b918065,1 +np.float64,0x3fe236753f646cea,0x3ff2a982660b8b43,1 +np.float64,0xbfe537fadfaa6ff6,0x3ff3a5f1c49c31bf,1 +np.float64,0xbfe31fa7dc663f50,0x3ff2f175374aef0e,1 +np.float64,0x3fc4b6569f296cb0,0x3ff035bde801bb53,1 +np.float64,0x800ce3c00f99c780,0x3ff0000000000000,1 +np.float64,0xbfebcde33e779bc6,0x3ff66de82cd30fc5,1 +np.float64,0x800dc09d3b7b813b,0x3ff0000000000000,1 +np.float64,0x80067d4c450cfa99,0x3ff0000000000000,1 +np.float64,0x1f6ade203ed7,0x3ff0000000000000,1 +np.float64,0xbfd4e311eca9c624,0x3ff0dc1383d6c3db,1 +np.float64,0x800649b3a54c9368,0x3ff0000000000000,1 +np.float64,0xcc14d1ab9829a,0x3ff0000000000000,1 +np.float64,0x3fc290c5bb25218b,0x3ff02b290f46dd6d,1 +np.float64,0x3fe78eb8376f1d70,0x3ff488f3bc259537,1 +np.float64,0xffc60f58e82c1eb0,0x7ff0000000000000,1 +np.float64,0x3fd35666ad26accd,0x3ff0bc6573da6bcd,1 +np.float64,0x7fc20257a62404ae,0x7ff0000000000000,1 +np.float64,0x80076d842e0edb09,0x3ff0000000000000,1 +np.float64,0x3fd8e44b08b1c898,0x3ff139b9a1f8428e,1 +np.float64,0x7fd6f6fc7a2dedf8,0x7ff0000000000000,1 +np.float64,0x3fa01b9f0820373e,0x3ff00206f8ad0f1b,1 +np.float64,0x69ed190ed3da4,0x3ff0000000000000,1 +np.float64,0xbfd997eb34b32fd6,0x3ff14be65a5db4a0,1 +np.float64,0x7feada2d0935b459,0x7ff0000000000000,1 +np.float64,0xbf80987120213100,0x3ff000226d29a9fc,1 +np.float64,0xbfef203e37fe407c,0x3ff82f51f04e8821,1 +np.float64,0xffe3dcf91fa7b9f2,0x7ff0000000000000,1 +np.float64,0x9a367283346cf,0x3ff0000000000000,1 +np.float64,0x800feb09f7bfd614,0x3ff0000000000000,1 +np.float64,0xbfe0319f9520633f,0x3ff217c5205c403f,1 +np.float64,0xbfa91eabd4323d50,0x3ff004ee4347f627,1 +np.float64,0x3fd19cbf7d23397f,0x3ff09c13e8e43571,1 +np.float64,0xffeb8945f0b7128b,0x7ff0000000000000,1 +np.float64,0x800a0eb4f2141d6a,0x3ff0000000000000,1 +np.float64,0xffe83e7312f07ce6,0x7ff0000000000000,1 +np.float64,0xffca53fee834a7fc,0x7ff0000000000000,1 +np.float64,0x800881cbf1710398,0x3ff0000000000000,1 +np.float64,0x80003e6abbe07cd6,0x3ff0000000000000,1 +np.float64,0xbfef6a998afed533,0x3ff859b7852d1b4d,1 +np.float64,0x3fd4eb7577a9d6eb,0x3ff0dcc601261aab,1 +np.float64,0xbfc9c12811338250,0x3ff05331268b05c8,1 +np.float64,0x7fddf84e5e3bf09c,0x7ff0000000000000,1 +np.float64,0xbfd4d6fbbc29adf8,0x3ff0db12db19d187,1 +np.float64,0x80077892bfaef126,0x3ff0000000000000,1 +np.float64,0xffae9d49543d3a90,0x7ff0000000000000,1 +np.float64,0xbfd8bef219317de4,0x3ff136034e5d2f1b,1 +np.float64,0xffe89c74ddb138e9,0x7ff0000000000000,1 +np.float64,0x8003b6bbb7e76d78,0x3ff0000000000000,1 +np.float64,0x315a4e8462b4b,0x3ff0000000000000,1 +np.float64,0x800ee616edddcc2e,0x3ff0000000000000,1 +np.float64,0xdfb27f97bf650,0x3ff0000000000000,1 +np.float64,0x8004723dc328e47c,0x3ff0000000000000,1 +np.float64,0xbfe529500daa52a0,0x3ff3a0b9b33fc84c,1 +np.float64,0xbfe4e46a7ce9c8d5,0x3ff3886ce0f92612,1 +np.float64,0xbf52003680240000,0x3ff00000a203d61a,1 +np.float64,0xffd3400458268008,0x7ff0000000000000,1 +np.float64,0x80076deb444edbd7,0x3ff0000000000000,1 +np.float64,0xa612f6c14c27,0x3ff0000000000000,1 +np.float64,0xbfd41c74c9a838ea,0x3ff0cbe61e16aecf,1 +np.float64,0x43f464a887e8d,0x3ff0000000000000,1 +np.float64,0x800976e748b2edcf,0x3ff0000000000000,1 +np.float64,0xffc79d6ba12f3ad8,0x7ff0000000000000,1 +np.float64,0xffd6dbcb022db796,0x7ff0000000000000,1 +np.float64,0xffd6a9672a2d52ce,0x7ff0000000000000,1 +np.float64,0x3fe95dcfa632bb9f,0x3ff54bbad2ee919e,1 +np.float64,0x3febadd2e1375ba6,0x3ff65e336c47c018,1 +np.float64,0x7fd47c37d828f86f,0x7ff0000000000000,1 +np.float64,0xbfd4ea59e0a9d4b4,0x3ff0dcae6af3e443,1 +np.float64,0x2c112afc58226,0x3ff0000000000000,1 +np.float64,0x8008122bced02458,0x3ff0000000000000,1 +np.float64,0x7fe7105ab3ee20b4,0x7ff0000000000000,1 +np.float64,0x80089634df312c6a,0x3ff0000000000000,1 +np.float64,0x68e9fbc8d1d40,0x3ff0000000000000,1 +np.float64,0xbfec1e1032f83c20,0x3ff69590b9f18ea8,1 +np.float64,0xbfedf181623be303,0x3ff787ef48935dc6,1 +np.float64,0xffe8600457f0c008,0x7ff0000000000000,1 +np.float64,0x7a841ec6f5084,0x3ff0000000000000,1 +np.float64,0x459a572e8b34c,0x3ff0000000000000,1 +np.float64,0x3fe8a232bef14465,0x3ff4fac1780f731e,1 +np.float64,0x3fcb37597d366eb3,0x3ff05cf08ab14ebd,1 +np.float64,0xbfb0261d00204c38,0x3ff00826fb86ca8a,1 +np.float64,0x3fc6e7a6dd2dcf4e,0x3ff041c1222ffa79,1 +np.float64,0xee65dd03dccbc,0x3ff0000000000000,1 +np.float64,0xffe26fdc23e4dfb8,0x7ff0000000000000,1 +np.float64,0x7fe8d6c8cab1ad91,0x7ff0000000000000,1 +np.float64,0xbfeb64bf2676c97e,0x3ff63abb8607828c,1 +np.float64,0x3fd28417b425082f,0x3ff0ac9eb22a732b,1 +np.float64,0xbfd26835b3a4d06c,0x3ff0aa94c48fb6d2,1 +np.float64,0xffec617a01b8c2f3,0x7ff0000000000000,1 +np.float64,0xe1bfff01c3800,0x3ff0000000000000,1 +np.float64,0x3fd4def913a9bdf4,0x3ff0dbbc7271046f,1 +np.float64,0x94f4c17129e98,0x3ff0000000000000,1 +np.float64,0x8009b2eaa33365d6,0x3ff0000000000000,1 +np.float64,0x3fd9633b41b2c678,0x3ff1468388bdfb65,1 +np.float64,0xffe0ae5c80e15cb8,0x7ff0000000000000,1 +np.float64,0x7fdfc35996bf86b2,0x7ff0000000000000,1 +np.float64,0x3fcfc5bdc23f8b7c,0x3ff07ed5caa4545c,1 +np.float64,0xd48b4907a9169,0x3ff0000000000000,1 +np.float64,0xbfe0a2cc52614598,0x3ff2361665895d95,1 +np.float64,0xbfe9068f90720d1f,0x3ff525b82491a1a5,1 +np.float64,0x4238b9208472,0x3ff0000000000000,1 +np.float64,0x800e6b2bf69cd658,0x3ff0000000000000,1 +np.float64,0x7fb638b6ae2c716c,0x7ff0000000000000,1 +np.float64,0x7fe267641764cec7,0x7ff0000000000000,1 +np.float64,0xffc0933d3521267c,0x7ff0000000000000,1 +np.float64,0x7fddfdfb533bfbf6,0x7ff0000000000000,1 +np.float64,0xced2a8e99da55,0x3ff0000000000000,1 +np.float64,0x2a80d5165501b,0x3ff0000000000000,1 +np.float64,0xbfeead2ab63d5a55,0x3ff7eeb5cbcfdcab,1 +np.float64,0x80097f6f92f2fee0,0x3ff0000000000000,1 +np.float64,0x3fee1f29b77c3e54,0x3ff7a0a58c13df62,1 +np.float64,0x3f9d06b8383a0d70,0x3ff001a54a2d8cf8,1 +np.float64,0xbfc8b41d3f31683c,0x3ff04c85379dd6b0,1 +np.float64,0xffd2a04c1e254098,0x7ff0000000000000,1 +np.float64,0xbfb71c01e02e3800,0x3ff010b34220e838,1 +np.float64,0xbfe69249ef6d2494,0x3ff425e48d1e938b,1 +np.float64,0xffefffffffffffff,0x7ff0000000000000,1 +np.float64,0x3feb1d52fbf63aa6,0x3ff618813ae922d7,1 +np.float64,0x7fb8d1a77e31a34e,0x7ff0000000000000,1 +np.float64,0xffc3cfc4ed279f88,0x7ff0000000000000,1 +np.float64,0x2164b9fc42c98,0x3ff0000000000000,1 +np.float64,0x3fbb868cee370d1a,0x3ff017b31b0d4d27,1 +np.float64,0x3fcd6dea583adbd5,0x3ff06cbd16bf44a0,1 +np.float64,0xbfecd041d479a084,0x3ff6efb25f61012d,1 +np.float64,0xbfb0552e6e20aa60,0x3ff00856ca83834a,1 +np.float64,0xe6293cbfcc528,0x3ff0000000000000,1 +np.float64,0x7fba58394034b072,0x7ff0000000000000,1 +np.float64,0x33bc96d467794,0x3ff0000000000000,1 +np.float64,0xffe90ea86bf21d50,0x7ff0000000000000,1 +np.float64,0xbfc626ea6d2c4dd4,0x3ff03d7e01ec3849,1 +np.float64,0x65b56fe4cb6af,0x3ff0000000000000,1 +np.float64,0x3fea409fb7f4813f,0x3ff5b171deab0ebd,1 +np.float64,0x3fe849c1df709384,0x3ff4d59063ff98c4,1 +np.float64,0x169073082d20f,0x3ff0000000000000,1 +np.float64,0xcc8b6add9916e,0x3ff0000000000000,1 +np.float64,0xbfef3d78d5fe7af2,0x3ff83fecc26abeea,1 +np.float64,0x3fe8c65a4a718cb4,0x3ff50a23bfeac7df,1 +np.float64,0x3fde9fa5c8bd3f4c,0x3ff1ddeb12b9d623,1 +np.float64,0xffe2af536da55ea6,0x7ff0000000000000,1 +np.float64,0x800186d0b0c30da2,0x3ff0000000000000,1 +np.float64,0x3fe9ba3c1d737478,0x3ff574ab2bf3a560,1 +np.float64,0xbfe1489c46a29138,0x3ff2641d36b30e21,1 +np.float64,0xbfe4b6b7c0e96d70,0x3ff37880ac8b0540,1 +np.float64,0x800e66ad82fccd5b,0x3ff0000000000000,1 +np.float64,0x7ff0000000000000,0x7ff0000000000000,1 +np.float64,0x7febb0fd477761fa,0x7ff0000000000000,1 +np.float64,0xbfdc433f2eb8867e,0x3ff195ec2a6cce27,1 +np.float64,0x3fe12c5a172258b4,0x3ff25c225b8a34bb,1 +np.float64,0xbfef6f116c3ede23,0x3ff85c47eaed49a0,1 +np.float64,0x800af6f60f35edec,0x3ff0000000000000,1 +np.float64,0xffe567999a2acf32,0x7ff0000000000000,1 +np.float64,0xbfc5ac5ae72b58b4,0x3ff03adb50ec04f3,1 +np.float64,0x3fea1b57e23436b0,0x3ff5a06f98541767,1 +np.float64,0x7fcc3e36fb387c6d,0x7ff0000000000000,1 +np.float64,0x8000c8dc698191ba,0x3ff0000000000000,1 +np.float64,0x3fee5085ed7ca10c,0x3ff7bb92f61245b8,1 +np.float64,0x7fbb9f803a373eff,0x7ff0000000000000,1 +np.float64,0xbfe1e5e806e3cbd0,0x3ff2918f2d773007,1 +np.float64,0x8008f8c3f3b1f188,0x3ff0000000000000,1 +np.float64,0x7fe53df515ea7be9,0x7ff0000000000000,1 +np.float64,0x7fdbb87fb3b770fe,0x7ff0000000000000,1 +np.float64,0x3fefcc0f50ff981f,0x3ff89210a6a04e6b,1 +np.float64,0x3fe33f87d0267f10,0x3ff2fb989ea4f2bc,1 +np.float64,0x1173992022e8,0x3ff0000000000000,1 +np.float64,0x3fef534632bea68c,0x3ff84c5ca9713ff9,1 +np.float64,0x3fc5991d552b3238,0x3ff03a72bfdb6e5f,1 +np.float64,0x3fdad90dc1b5b21c,0x3ff16db868180034,1 +np.float64,0xffe20b8078e41700,0x7ff0000000000000,1 +np.float64,0x7fdf409a82be8134,0x7ff0000000000000,1 +np.float64,0x3fccb7e691396fcd,0x3ff06786b6ccdbcb,1 +np.float64,0xffe416e0b7282dc1,0x7ff0000000000000,1 +np.float64,0xffe3a8a981275152,0x7ff0000000000000,1 +np.float64,0x3fd9c8bd31b3917c,0x3ff150ee6f5f692f,1 +np.float64,0xffeab6fef6356dfd,0x7ff0000000000000,1 +np.float64,0x3fe9c5e3faf38bc8,0x3ff579e18c9bd548,1 +np.float64,0x800b173e44762e7d,0x3ff0000000000000,1 +np.float64,0xffe2719db764e33b,0x7ff0000000000000,1 +np.float64,0x3fd1fcf31223f9e6,0x3ff0a2da7ad99856,1 +np.float64,0x80082c4afcd05896,0x3ff0000000000000,1 +np.float64,0xa56e5e4b4adcc,0x3ff0000000000000,1 +np.float64,0xffbbbddab2377bb8,0x7ff0000000000000,1 +np.float64,0x3b3927c076726,0x3ff0000000000000,1 +np.float64,0x3fec03fd58f807fb,0x3ff6889b8a774728,1 +np.float64,0xbfaa891fb4351240,0x3ff00580987bd914,1 +np.float64,0x7fb4800c4a290018,0x7ff0000000000000,1 +np.float64,0xffbb5d2b6036ba58,0x7ff0000000000000,1 +np.float64,0x7fd6608076acc100,0x7ff0000000000000,1 +np.float64,0x31267e4c624d1,0x3ff0000000000000,1 +np.float64,0x33272266664e5,0x3ff0000000000000,1 +np.float64,0x47bb37f28f768,0x3ff0000000000000,1 +np.float64,0x3fe134bb4ee26977,0x3ff25e7ea647a928,1 +np.float64,0xbfe2b5f42ba56be8,0x3ff2d05cbdc7344b,1 +np.float64,0xbfe0e013fd61c028,0x3ff246dfce572914,1 +np.float64,0x7fecedcda4f9db9a,0x7ff0000000000000,1 +np.float64,0x8001816c2da302d9,0x3ff0000000000000,1 +np.float64,0xffced8b65b3db16c,0x7ff0000000000000,1 +np.float64,0xffdc1d4a0b383a94,0x7ff0000000000000,1 +np.float64,0x7fe94e7339f29ce5,0x7ff0000000000000,1 +np.float64,0x33fb846667f71,0x3ff0000000000000,1 +np.float64,0x800a1380e9542702,0x3ff0000000000000,1 +np.float64,0x800b74eaa776e9d6,0x3ff0000000000000,1 +np.float64,0x5681784aad030,0x3ff0000000000000,1 +np.float64,0xbfee0eb7917c1d6f,0x3ff797b949f7f6b4,1 +np.float64,0xffe4ec5fd2a9d8bf,0x7ff0000000000000,1 +np.float64,0xbfcd7401dd3ae804,0x3ff06cea52c792c0,1 +np.float64,0x800587563beb0ead,0x3ff0000000000000,1 +np.float64,0x3fc15c6f3322b8de,0x3ff025bbd030166d,1 +np.float64,0x7feb6b4caf76d698,0x7ff0000000000000,1 +np.float64,0x7fe136ef82a26dde,0x7ff0000000000000,1 +np.float64,0xf592dac3eb25c,0x3ff0000000000000,1 +np.float64,0x7fd300baf6a60175,0x7ff0000000000000,1 +np.float64,0x7fc880de9e3101bc,0x7ff0000000000000,1 +np.float64,0x7fe7a1aa5caf4354,0x7ff0000000000000,1 +np.float64,0x2f9b8e0e5f373,0x3ff0000000000000,1 +np.float64,0xffcc9071993920e4,0x7ff0000000000000,1 +np.float64,0x8009e151b313c2a4,0x3ff0000000000000,1 +np.float64,0xbfd46e2d18a8dc5a,0x3ff0d27a7b37c1ae,1 +np.float64,0x3fe65c7961acb8f3,0x3ff4116946062a4c,1 +np.float64,0x7fd31b371626366d,0x7ff0000000000000,1 +np.float64,0x98dc924d31b93,0x3ff0000000000000,1 +np.float64,0x268bef364d17f,0x3ff0000000000000,1 +np.float64,0x7fd883ba56310774,0x7ff0000000000000,1 +np.float64,0x3fc53f01a32a7e03,0x3ff0388dea9cd63e,1 +np.float64,0xffe1ea8c0563d518,0x7ff0000000000000,1 +np.float64,0x3fd0bf0e63a17e1d,0x3ff08d0577f5ffa6,1 +np.float64,0x7fef42418f7e8482,0x7ff0000000000000,1 +np.float64,0x8000bccd38c1799b,0x3ff0000000000000,1 +np.float64,0xbfe6c48766ed890f,0x3ff43936fa4048c8,1 +np.float64,0xbfb2a38f3a254720,0x3ff00adc7f7b2822,1 +np.float64,0x3fd5262b2eaa4c56,0x3ff0e1af492c08f5,1 +np.float64,0x80065b4691ecb68e,0x3ff0000000000000,1 +np.float64,0xfb6b9e9ff6d74,0x3ff0000000000000,1 +np.float64,0x8006c71e6ecd8e3e,0x3ff0000000000000,1 +np.float64,0x3fd0a3e43ca147c8,0x3ff08b3ad7b42485,1 +np.float64,0xbfc82d8607305b0c,0x3ff04949d6733ef6,1 +np.float64,0xde048c61bc092,0x3ff0000000000000,1 +np.float64,0xffcf73e0fa3ee7c0,0x7ff0000000000000,1 +np.float64,0xbfe8639d7830c73b,0x3ff4e05f97948376,1 +np.float64,0x8010000000000000,0x3ff0000000000000,1 +np.float64,0x67f01a2acfe04,0x3ff0000000000000,1 +np.float64,0x3fe222e803e445d0,0x3ff2a3a75e5f29d8,1 +np.float64,0xffef84c6387f098b,0x7ff0000000000000,1 +np.float64,0x3fe5969c1e6b2d38,0x3ff3c80130462bb2,1 +np.float64,0x8009f56953d3ead3,0x3ff0000000000000,1 +np.float64,0x3fe05c9b6360b937,0x3ff2232e1cba5617,1 +np.float64,0x3fd8888d63b1111b,0x3ff130a5b788d52f,1 +np.float64,0xffe3a9e6f26753ce,0x7ff0000000000000,1 +np.float64,0x800e2aaa287c5554,0x3ff0000000000000,1 +np.float64,0x3fea8d6c82351ad9,0x3ff5d4d8cde9a11d,1 +np.float64,0x7feef700723dee00,0x7ff0000000000000,1 +np.float64,0x3fa5cb77242b96e0,0x3ff003b62b3e50f1,1 +np.float64,0x7fb68f0a862d1e14,0x7ff0000000000000,1 +np.float64,0x7fb97ee83432fdcf,0x7ff0000000000000,1 +np.float64,0x7fd74a78632e94f0,0x7ff0000000000000,1 +np.float64,0x7fcfe577713fcaee,0x7ff0000000000000,1 +np.float64,0xffe192ee5ea325dc,0x7ff0000000000000,1 +np.float64,0x477d6ae48efae,0x3ff0000000000000,1 +np.float64,0xffe34d5237669aa4,0x7ff0000000000000,1 +np.float64,0x7fe3ce8395a79d06,0x7ff0000000000000,1 +np.float64,0x80019c01ffa33805,0x3ff0000000000000,1 +np.float64,0x74b5b56ce96b7,0x3ff0000000000000,1 +np.float64,0x7fe05ecdeda0bd9b,0x7ff0000000000000,1 +np.float64,0xffe9693eb232d27d,0x7ff0000000000000,1 +np.float64,0xffd2be2c7da57c58,0x7ff0000000000000,1 +np.float64,0x800dbd5cbc1b7aba,0x3ff0000000000000,1 +np.float64,0xbfa36105d426c210,0x3ff002ef2e3a87f7,1 +np.float64,0x800b2d69fb765ad4,0x3ff0000000000000,1 +np.float64,0xbfdb81c9a9370394,0x3ff1802d409cbf7a,1 +np.float64,0x7fd481d014a9039f,0x7ff0000000000000,1 +np.float64,0xffe66c3c1fecd878,0x7ff0000000000000,1 +np.float64,0x3fc55865192ab0c8,0x3ff03915b51e8839,1 +np.float64,0xd6a78987ad4f1,0x3ff0000000000000,1 +np.float64,0x800c6cc80d58d990,0x3ff0000000000000,1 +np.float64,0x979435a12f29,0x3ff0000000000000,1 +np.float64,0xbfbd971e7a3b2e40,0x3ff01b647e45f5a6,1 +np.float64,0x80067565bfeceacc,0x3ff0000000000000,1 +np.float64,0x8001ad689ce35ad2,0x3ff0000000000000,1 +np.float64,0x7fa43253dc2864a7,0x7ff0000000000000,1 +np.float64,0xbfe3dda307e7bb46,0x3ff32ef99a2efe1d,1 +np.float64,0x3fe5d7b395ebaf68,0x3ff3dfd33cdc8ef4,1 +np.float64,0xd94cc9c3b2999,0x3ff0000000000000,1 +np.float64,0x3fee5a513fbcb4a2,0x3ff7c0f17b876ce5,1 +np.float64,0xffe27761fa64eec4,0x7ff0000000000000,1 +np.float64,0x3feb788119b6f102,0x3ff64446f67f4efa,1 +np.float64,0xbfed6e10dffadc22,0x3ff741d5ef610ca0,1 +np.float64,0x7fe73cf98b2e79f2,0x7ff0000000000000,1 +np.float64,0x7847d09af08fb,0x3ff0000000000000,1 +np.float64,0x29ded2da53bdb,0x3ff0000000000000,1 +np.float64,0xbfe51c1ec1aa383e,0x3ff39c0b7cf832e2,1 +np.float64,0xbfeafd5e65f5fabd,0x3ff609548a787f57,1 +np.float64,0x3fd872a26fb0e545,0x3ff12e7fbd95505c,1 +np.float64,0x7fed6b7c1b7ad6f7,0x7ff0000000000000,1 +np.float64,0xffe7ba9ec16f753d,0x7ff0000000000000,1 +np.float64,0x7f89b322f0336645,0x7ff0000000000000,1 +np.float64,0xbfad1677383a2cf0,0x3ff0069ca67e7baa,1 +np.float64,0x3fe0906d04a120da,0x3ff2311b04b7bfef,1 +np.float64,0xffe4b3c9d4296793,0x7ff0000000000000,1 +np.float64,0xbfe476bb0ce8ed76,0x3ff36277d2921a74,1 +np.float64,0x7fc35655cf26acab,0x7ff0000000000000,1 +np.float64,0x7fe9980f0373301d,0x7ff0000000000000,1 +np.float64,0x9e6e04cb3cdc1,0x3ff0000000000000,1 +np.float64,0x800b89e0afb713c2,0x3ff0000000000000,1 +np.float64,0x800bd951a3f7b2a4,0x3ff0000000000000,1 +np.float64,0x29644a9e52c8a,0x3ff0000000000000,1 +np.float64,0x3fe1be2843637c51,0x3ff285e90d8387e4,1 +np.float64,0x7fa233cce4246799,0x7ff0000000000000,1 +np.float64,0xbfcfb7bc2d3f6f78,0x3ff07e657de3e2ed,1 +np.float64,0xffd7c953e7af92a8,0x7ff0000000000000,1 +np.float64,0xbfc5bbaf772b7760,0x3ff03b2ee4febb1e,1 +np.float64,0x8007b7315a6f6e63,0x3ff0000000000000,1 +np.float64,0xbfe906d902320db2,0x3ff525d7e16acfe0,1 +np.float64,0x3fde33d8553c67b1,0x3ff1d09faa19aa53,1 +np.float64,0x61fe76a0c3fcf,0x3ff0000000000000,1 +np.float64,0xa75e355b4ebc7,0x3ff0000000000000,1 +np.float64,0x3fc9e6d86033cdb1,0x3ff05426299c7064,1 +np.float64,0x7fd83f489eb07e90,0x7ff0000000000000,1 +np.float64,0x8000000000000001,0x3ff0000000000000,1 +np.float64,0x80014434ae62886a,0x3ff0000000000000,1 +np.float64,0xbfe21af9686435f3,0x3ff2a149338bdefe,1 +np.float64,0x9354e6cd26a9d,0x3ff0000000000000,1 +np.float64,0xb42b95f768573,0x3ff0000000000000,1 +np.float64,0xbfecb4481bb96890,0x3ff6e15d269dd651,1 +np.float64,0x3f97842ae82f0840,0x3ff0011485156f28,1 +np.float64,0xffdef63d90bdec7c,0x7ff0000000000000,1 +np.float64,0x7fe511a8d36a2351,0x7ff0000000000000,1 +np.float64,0xbf8cb638a0396c80,0x3ff000670c318fb6,1 +np.float64,0x3fe467e1f668cfc4,0x3ff35d65f93ccac6,1 +np.float64,0xbfce7d88f03cfb10,0x3ff074c22475fe5b,1 +np.float64,0x6d0a4994da14a,0x3ff0000000000000,1 +np.float64,0xbfb3072580260e48,0x3ff00b51d3913e9f,1 +np.float64,0x8008fcde36b1f9bd,0x3ff0000000000000,1 +np.float64,0x3fd984df66b309c0,0x3ff149f29125eca4,1 +np.float64,0xffee2a10fe7c5421,0x7ff0000000000000,1 +np.float64,0x80039168ace722d2,0x3ff0000000000000,1 +np.float64,0xffda604379b4c086,0x7ff0000000000000,1 +np.float64,0xffdc6a405bb8d480,0x7ff0000000000000,1 +np.float64,0x3fe62888b26c5111,0x3ff3fdda754c4372,1 +np.float64,0x8008b452cb5168a6,0x3ff0000000000000,1 +np.float64,0x6165d540c2cbb,0x3ff0000000000000,1 +np.float64,0xbfee0c04d17c180a,0x3ff796431c64bcbe,1 +np.float64,0x800609b8448c1371,0x3ff0000000000000,1 +np.float64,0x800fc3fca59f87f9,0x3ff0000000000000,1 +np.float64,0x77f64848efeca,0x3ff0000000000000,1 +np.float64,0x8007cf522d8f9ea5,0x3ff0000000000000,1 +np.float64,0xbfe9fb0b93f3f617,0x3ff591cb0052e22c,1 +np.float64,0x7fd569d5f0aad3ab,0x7ff0000000000000,1 +np.float64,0x7fe5cf489d6b9e90,0x7ff0000000000000,1 +np.float64,0x7fd6e193e92dc327,0x7ff0000000000000,1 +np.float64,0xf78988a5ef131,0x3ff0000000000000,1 +np.float64,0x3fe8f97562b1f2eb,0x3ff5201080fbc12d,1 +np.float64,0x7febfd69d7b7fad3,0x7ff0000000000000,1 +np.float64,0xffc07b5c1720f6b8,0x7ff0000000000000,1 +np.float64,0xbfd966926832cd24,0x3ff146da9adf492e,1 +np.float64,0x7fef5bd9edfeb7b3,0x7ff0000000000000,1 +np.float64,0xbfd2afbc96255f7a,0x3ff0afd601febf44,1 +np.float64,0x7fdd4ea6293a9d4b,0x7ff0000000000000,1 +np.float64,0xbfe8a1e916b143d2,0x3ff4faa23c2793e5,1 +np.float64,0x800188fcd8c311fa,0x3ff0000000000000,1 +np.float64,0xbfe30803f1661008,0x3ff2e9fc729baaee,1 +np.float64,0x7fefffffffffffff,0x7ff0000000000000,1 +np.float64,0x3fd287bec3250f7e,0x3ff0ace34d3102f6,1 +np.float64,0x1f0ee9443e1de,0x3ff0000000000000,1 +np.float64,0xbfd92f73da325ee8,0x3ff14143e4fa2c5a,1 +np.float64,0x3fed7c9bdffaf938,0x3ff74984168734d3,1 +np.float64,0x8002c4d1696589a4,0x3ff0000000000000,1 +np.float64,0xfe03011bfc060,0x3ff0000000000000,1 +np.float64,0x7f7a391e6034723c,0x7ff0000000000000,1 +np.float64,0xffd6fd46f82dfa8e,0x7ff0000000000000,1 +np.float64,0xbfd7520a742ea414,0x3ff112f1ba5d4f91,1 +np.float64,0x8009389d8812713b,0x3ff0000000000000,1 +np.float64,0x7fefb846aaff708c,0x7ff0000000000000,1 +np.float64,0x3fd98a0983331413,0x3ff14a79efb8adbf,1 +np.float64,0xbfd897158db12e2c,0x3ff132137902cf3e,1 +np.float64,0xffc4048d5928091c,0x7ff0000000000000,1 +np.float64,0x80036ae46046d5ca,0x3ff0000000000000,1 +np.float64,0x7faba7ed3c374fd9,0x7ff0000000000000,1 +np.float64,0xbfec4265e1f884cc,0x3ff6a7b8602422c9,1 +np.float64,0xaa195e0b5432c,0x3ff0000000000000,1 +np.float64,0x3feac15d317582ba,0x3ff5ed115758145f,1 +np.float64,0x6c13a5bcd8275,0x3ff0000000000000,1 +np.float64,0xbfed20b8883a4171,0x3ff7194dbd0dc988,1 +np.float64,0x800cde65c899bccc,0x3ff0000000000000,1 +np.float64,0x7c72912af8e53,0x3ff0000000000000,1 +np.float64,0x3fe49d2bb4e93a57,0x3ff36fab3aba15d4,1 +np.float64,0xbfd598fa02ab31f4,0x3ff0eb72fc472025,1 +np.float64,0x8007a191712f4324,0x3ff0000000000000,1 +np.float64,0xbfdeb14872bd6290,0x3ff1e01ca83f35fd,1 +np.float64,0xbfe1da46b3e3b48e,0x3ff28e23ad2f5615,1 +np.float64,0x800a2f348e745e69,0x3ff0000000000000,1 +np.float64,0xbfee66928afccd25,0x3ff7c7ac7dbb3273,1 +np.float64,0xffd78a0a2b2f1414,0x7ff0000000000000,1 +np.float64,0x7fc5fa80b82bf500,0x7ff0000000000000,1 +np.float64,0x800e6d7260dcdae5,0x3ff0000000000000,1 +np.float64,0xbfd6cff2aaad9fe6,0x3ff106f78ee61642,1 +np.float64,0x7fe1041d1d220839,0x7ff0000000000000,1 +np.float64,0xbfdf75586cbeeab0,0x3ff1f8dbaa7e57f0,1 +np.float64,0xffdcaae410b955c8,0x7ff0000000000000,1 +np.float64,0x800fe5e0d1ffcbc2,0x3ff0000000000000,1 +np.float64,0x800d7999527af333,0x3ff0000000000000,1 +np.float64,0xbfe62c233bac5846,0x3ff3ff34220a204c,1 +np.float64,0x7fe99bbff8f3377f,0x7ff0000000000000,1 +np.float64,0x7feeaf471d3d5e8d,0x7ff0000000000000,1 +np.float64,0xd5904ff5ab20a,0x3ff0000000000000,1 +np.float64,0x3fd07aae3320f55c,0x3ff08888c227c968,1 +np.float64,0x7fea82b8dff50571,0x7ff0000000000000,1 +np.float64,0xffef2db9057e5b71,0x7ff0000000000000,1 +np.float64,0xbfe2077fef640f00,0x3ff29b7dd0d39d36,1 +np.float64,0xbfe09a4d7c61349b,0x3ff233c7e88881f4,1 +np.float64,0x3fda50c4cbb4a188,0x3ff15f28a71deee7,1 +np.float64,0x7fe7d9ee6b2fb3dc,0x7ff0000000000000,1 +np.float64,0x3febbf6faeb77edf,0x3ff666d13682ea93,1 +np.float64,0xc401a32988035,0x3ff0000000000000,1 +np.float64,0xbfeab30aa8f56615,0x3ff5e65dcc6603f8,1 +np.float64,0x92c8cea32591a,0x3ff0000000000000,1 +np.float64,0xbff0000000000000,0x3ff8b07551d9f550,1 +np.float64,0xbfbddfb4dc3bbf68,0x3ff01bebaec38faa,1 +np.float64,0xbfd8de3e2a31bc7c,0x3ff1391f4830d20b,1 +np.float64,0xffc83a8f8a307520,0x7ff0000000000000,1 +np.float64,0x3fee026ef53c04de,0x3ff7911337085827,1 +np.float64,0x7fbaf380b235e700,0x7ff0000000000000,1 +np.float64,0xffe5b89fa62b713f,0x7ff0000000000000,1 +np.float64,0xbfdc1ff54ab83fea,0x3ff191e8c0b60bb2,1 +np.float64,0x6ae3534cd5c6b,0x3ff0000000000000,1 +np.float64,0xbfea87e558750fcb,0x3ff5d24846013794,1 +np.float64,0xffe0f467bee1e8cf,0x7ff0000000000000,1 +np.float64,0x7fee3b0dc7bc761b,0x7ff0000000000000,1 +np.float64,0x3fed87521afb0ea4,0x3ff74f2f5cd36a5c,1 +np.float64,0x7b3c9882f6794,0x3ff0000000000000,1 +np.float64,0x7fdd1a62243a34c3,0x7ff0000000000000,1 +np.float64,0x800f1dc88d3e3b91,0x3ff0000000000000,1 +np.float64,0x7fc3213cfa264279,0x7ff0000000000000,1 +np.float64,0x3fe40e0f3d681c1e,0x3ff33f135e9d5ded,1 +np.float64,0x7febf14e51f7e29c,0x7ff0000000000000,1 +np.float64,0xffe96c630c72d8c5,0x7ff0000000000000,1 +np.float64,0x7fdd82fbe7bb05f7,0x7ff0000000000000,1 +np.float64,0xbf9a6a0b1034d420,0x3ff0015ce009f7d8,1 +np.float64,0xbfceb4f8153d69f0,0x3ff0766e3ecc77df,1 +np.float64,0x3fd9de31e633bc64,0x3ff15327b794a16e,1 +np.float64,0x3faa902a30352054,0x3ff00583848d1969,1 +np.float64,0x0,0x3ff0000000000000,1 +np.float64,0x3fbe3459c43c68b4,0x3ff01c8af6710ef6,1 +np.float64,0xbfa8df010031be00,0x3ff004d5632dc9f5,1 +np.float64,0x7fbcf6cf2a39ed9d,0x7ff0000000000000,1 +np.float64,0xffe4236202a846c4,0x7ff0000000000000,1 +np.float64,0x3fd35ed52e26bdaa,0x3ff0bd0b231f11f7,1 +np.float64,0x7fe7a2df532f45be,0x7ff0000000000000,1 +np.float64,0xffe32f8315665f06,0x7ff0000000000000,1 +np.float64,0x7fe1a69f03e34d3d,0x7ff0000000000000,1 +np.float64,0x7fa5542b742aa856,0x7ff0000000000000,1 +np.float64,0x3fe84e9f8ef09d3f,0x3ff4d79816359765,1 +np.float64,0x29076fe6520ef,0x3ff0000000000000,1 +np.float64,0xffd70894f7ae112a,0x7ff0000000000000,1 +np.float64,0x800188edcbe311dc,0x3ff0000000000000,1 +np.float64,0x3fe2c7acda258f5a,0x3ff2d5dad4617703,1 +np.float64,0x3f775d41a02ebb00,0x3ff000110f212445,1 +np.float64,0x7fe8a084d1714109,0x7ff0000000000000,1 +np.float64,0x3fe31562d8a62ac6,0x3ff2ee35055741cd,1 +np.float64,0xbfd195d4d1a32baa,0x3ff09b98a50c151b,1 +np.float64,0xffaae9ff0c35d400,0x7ff0000000000000,1 +np.float64,0xff819866502330c0,0x7ff0000000000000,1 +np.float64,0x7fddc64815bb8c8f,0x7ff0000000000000,1 +np.float64,0xbfd442b428288568,0x3ff0cef70aa73ae6,1 +np.float64,0x8002e7625aa5cec5,0x3ff0000000000000,1 +np.float64,0x7fe8d4f70e71a9ed,0x7ff0000000000000,1 +np.float64,0xbfc3bd015f277a04,0x3ff030cbf16f29d9,1 +np.float64,0x3fd315d5baa62bab,0x3ff0b77a551a5335,1 +np.float64,0x7fa638b4642c7168,0x7ff0000000000000,1 +np.float64,0x3fdea8b795bd516f,0x3ff1df0bb70cdb79,1 +np.float64,0xbfd78754762f0ea8,0x3ff117ee0f29abed,1 +np.float64,0x8009f6a37633ed47,0x3ff0000000000000,1 +np.float64,0x3fea1daf75343b5f,0x3ff5a1804789bf13,1 +np.float64,0x3fd044b6c0a0896e,0x3ff0850b7297d02f,1 +np.float64,0x8003547a9c86a8f6,0x3ff0000000000000,1 +np.float64,0x3fa6c2cd782d859b,0x3ff0040c4ac8f44a,1 +np.float64,0x3fe225baaae44b76,0x3ff2a47f5e1f5e85,1 +np.float64,0x8000000000000000,0x3ff0000000000000,1 +np.float64,0x3fcb53da8736a7b8,0x3ff05db45af470ac,1 +np.float64,0x80079f8f140f3f1f,0x3ff0000000000000,1 +np.float64,0xbfcd1d7e2b3a3afc,0x3ff06a6b6845d05f,1 +np.float64,0x96df93672dbf3,0x3ff0000000000000,1 +np.float64,0xdef86e43bdf0e,0x3ff0000000000000,1 +np.float64,0xbfec05a09db80b41,0x3ff6896b768eea08,1 +np.float64,0x7fe3ff91d267ff23,0x7ff0000000000000,1 +np.float64,0xffea3eaa07347d53,0x7ff0000000000000,1 +np.float64,0xbfebde1cc1f7bc3a,0x3ff675e34ac2afc2,1 +np.float64,0x629bcde8c537a,0x3ff0000000000000,1 +np.float64,0xbfdde4fcff3bc9fa,0x3ff1c7061d21f0fe,1 +np.float64,0x3fee60fd003cc1fa,0x3ff7c49af3878a51,1 +np.float64,0x3fe5c92ac32b9256,0x3ff3da7a7929588b,1 +np.float64,0xbfe249c78f64938f,0x3ff2af52a06f1a50,1 +np.float64,0xbfc6de9dbe2dbd3c,0x3ff0418d284ee29f,1 +np.float64,0xffc8ef094631de14,0x7ff0000000000000,1 +np.float64,0x3fdef05f423de0bf,0x3ff1e800caba8ab5,1 +np.float64,0xffc1090731221210,0x7ff0000000000000,1 +np.float64,0xbfedec9b5fbbd937,0x3ff7854b6792a24a,1 +np.float64,0xbfb873507630e6a0,0x3ff012b23b3b7a67,1 +np.float64,0xbfe3cd6692679acd,0x3ff3299d6936ec4b,1 +np.float64,0xbfb107c890220f90,0x3ff0091122162472,1 +np.float64,0xbfe4e6ee48e9cddc,0x3ff3894e5a5e70a6,1 +np.float64,0xffe6fa3413edf468,0x7ff0000000000000,1 +np.float64,0x3fe2faf79b65f5ef,0x3ff2e5e11fae8b54,1 +np.float64,0xbfdfeb8df9bfd71c,0x3ff208189691b15f,1 +np.float64,0x75d2d03ceba5b,0x3ff0000000000000,1 +np.float64,0x3feb48c182b69183,0x3ff62d4462eba6cb,1 +np.float64,0xffcda9f7ff3b53f0,0x7ff0000000000000,1 +np.float64,0x7fcafbdcbd35f7b8,0x7ff0000000000000,1 +np.float64,0xbfd1895523a312aa,0x3ff09aba642a78d9,1 +np.float64,0x3fe3129c3f662538,0x3ff2ed546bbfafcf,1 +np.float64,0x3fb444dee02889be,0x3ff00cd86273b964,1 +np.float64,0xbf73b32d7ee77,0x3ff0000000000000,1 +np.float64,0x3fae19904c3c3321,0x3ff00714865c498a,1 +np.float64,0x7fefbfaef5bf7f5d,0x7ff0000000000000,1 +np.float64,0x8000dc3816e1b871,0x3ff0000000000000,1 +np.float64,0x8003f957ba47f2b0,0x3ff0000000000000,1 +np.float64,0xbfe3563c7ea6ac79,0x3ff302dcebc92856,1 +np.float64,0xbfdc80fbae3901f8,0x3ff19cfe73e58092,1 +np.float64,0x8009223b04524476,0x3ff0000000000000,1 +np.float64,0x3fd95f431c32be86,0x3ff1461c21cb03f0,1 +np.float64,0x7ff4000000000000,0x7ffc000000000000,1 +np.float64,0xbfe7c12ed3ef825e,0x3ff49d59c265efcd,1 +np.float64,0x10000000000000,0x3ff0000000000000,1 +np.float64,0x7fc5e2632f2bc4c5,0x7ff0000000000000,1 +np.float64,0xffd8f6b4c7b1ed6a,0x7ff0000000000000,1 +np.float64,0x80034b93d4069728,0x3ff0000000000000,1 +np.float64,0xffdf5d4c1dbeba98,0x7ff0000000000000,1 +np.float64,0x800bc63d70178c7b,0x3ff0000000000000,1 +np.float64,0xbfeba31ea0f7463d,0x3ff658fa27073d2b,1 +np.float64,0xbfeebeede97d7ddc,0x3ff7f89a8e80dec4,1 +np.float64,0x7feb0f1f91361e3e,0x7ff0000000000000,1 +np.float64,0xffec3158d0b862b1,0x7ff0000000000000,1 +np.float64,0x3fde51cbfbbca398,0x3ff1d44c2ff15b3d,1 +np.float64,0xd58fb2b3ab1f7,0x3ff0000000000000,1 +np.float64,0x80028b9e32e5173d,0x3ff0000000000000,1 +np.float64,0x7fea77a56c74ef4a,0x7ff0000000000000,1 +np.float64,0x3fdaabbd4a35577b,0x3ff168d82edf2fe0,1 +np.float64,0xbfe69c39cc2d3874,0x3ff429b2f4cdb362,1 +np.float64,0x3b78f5d876f20,0x3ff0000000000000,1 +np.float64,0x7fa47d116428fa22,0x7ff0000000000000,1 +np.float64,0xbfe4118b0ce82316,0x3ff3403d989f780f,1 +np.float64,0x800482e793c905d0,0x3ff0000000000000,1 +np.float64,0xbfe48e5728e91cae,0x3ff36a9020bf9d20,1 +np.float64,0x7fe078ba8860f174,0x7ff0000000000000,1 +np.float64,0x3fd80843e5b01088,0x3ff1242f401e67da,1 +np.float64,0x3feb1f6965f63ed3,0x3ff6197fc590e143,1 +np.float64,0xffa41946d8283290,0x7ff0000000000000,1 +np.float64,0xffe30de129661bc2,0x7ff0000000000000,1 +np.float64,0x3fec9c8e1ab9391c,0x3ff6d542ea2f49b4,1 +np.float64,0x3fdc3e4490387c89,0x3ff1955ae18cac37,1 +np.float64,0xffef49d9c77e93b3,0x7ff0000000000000,1 +np.float64,0xfff0000000000000,0x7ff0000000000000,1 +np.float64,0x3fe0442455608849,0x3ff21cab90067d5c,1 +np.float64,0xbfed86aebd3b0d5e,0x3ff74ed8d4b75f50,1 +np.float64,0xffe4600d2b28c01a,0x7ff0000000000000,1 +np.float64,0x7fc1e8ccff23d199,0x7ff0000000000000,1 +np.float64,0x8008d49b0091a936,0x3ff0000000000000,1 +np.float64,0xbfe4139df028273c,0x3ff340ef3c86227c,1 +np.float64,0xbfe9ab4542b3568a,0x3ff56dfe32061247,1 +np.float64,0xbfd76dd365aedba6,0x3ff11589bab5fe71,1 +np.float64,0x3fd42cf829a859f0,0x3ff0cd3844bb0e11,1 +np.float64,0x7fd077cf2e20ef9d,0x7ff0000000000000,1 +np.float64,0x3fd7505760aea0b0,0x3ff112c937b3f088,1 +np.float64,0x1f93341a3f267,0x3ff0000000000000,1 +np.float64,0x7fe3c3c1b0678782,0x7ff0000000000000,1 +np.float64,0x800f85cec97f0b9e,0x3ff0000000000000,1 +np.float64,0xd93ab121b2756,0x3ff0000000000000,1 +np.float64,0xbfef8066fd7f00ce,0x3ff8663ed7d15189,1 +np.float64,0xffe31dd4af663ba9,0x7ff0000000000000,1 +np.float64,0xbfd7ff05a6affe0c,0x3ff1234c09bb686d,1 +np.float64,0xbfe718c31fee3186,0x3ff45a0c2d0ef7b0,1 +np.float64,0x800484bf33e9097f,0x3ff0000000000000,1 +np.float64,0xffd409dad02813b6,0x7ff0000000000000,1 +np.float64,0x3fe59679896b2cf4,0x3ff3c7f49e4fbbd3,1 +np.float64,0xbfd830c54d30618a,0x3ff1281729861390,1 +np.float64,0x1d4fc81c3a9fa,0x3ff0000000000000,1 +np.float64,0x3fd334e4272669c8,0x3ff0b9d5d82894f0,1 +np.float64,0xffc827e65c304fcc,0x7ff0000000000000,1 +np.float64,0xffe2d1814aa5a302,0x7ff0000000000000,1 +np.float64,0xffd7b5b8d32f6b72,0x7ff0000000000000,1 +np.float64,0xbfdbc9f077b793e0,0x3ff18836b9106ad0,1 +np.float64,0x7fc724c2082e4983,0x7ff0000000000000,1 +np.float64,0x3fa39ed72c273da0,0x3ff00302051ce17e,1 +np.float64,0xbfe3c4c209678984,0x3ff326c4fd16b5cd,1 +np.float64,0x7fe91f6d00f23ed9,0x7ff0000000000000,1 +np.float64,0x8004ee93fea9dd29,0x3ff0000000000000,1 +np.float64,0xbfe7c32d0eaf865a,0x3ff49e290ed2ca0e,1 +np.float64,0x800ea996b29d532d,0x3ff0000000000000,1 +np.float64,0x2df9ec1c5bf3e,0x3ff0000000000000,1 +np.float64,0xabb175df5762f,0x3ff0000000000000,1 +np.float64,0xffe3fc9c8e27f938,0x7ff0000000000000,1 +np.float64,0x7fb358a62826b14b,0x7ff0000000000000,1 +np.float64,0x800aedcccaf5db9a,0x3ff0000000000000,1 +np.float64,0xffca530c5234a618,0x7ff0000000000000,1 +np.float64,0x40f91e9681f24,0x3ff0000000000000,1 +np.float64,0x80098f4572f31e8b,0x3ff0000000000000,1 +np.float64,0xbfdc58c21fb8b184,0x3ff1986115f8fe92,1 +np.float64,0xbfebeafd40b7d5fa,0x3ff67c3cf34036e3,1 +np.float64,0x7fd108861a22110b,0x7ff0000000000000,1 +np.float64,0xff8e499ae03c9340,0x7ff0000000000000,1 +np.float64,0xbfd2f58caa25eb1a,0x3ff0b50b1bffafdf,1 +np.float64,0x3fa040c9bc208193,0x3ff002105e95aefa,1 +np.float64,0xbfd2ebc0a5a5d782,0x3ff0b44ed5a11584,1 +np.float64,0xffe237bc93a46f78,0x7ff0000000000000,1 +np.float64,0x3fd557c5eeaaaf8c,0x3ff0e5e0a575e1ba,1 +np.float64,0x7abb419ef5769,0x3ff0000000000000,1 +np.float64,0xffefa1fe353f43fb,0x7ff0000000000000,1 +np.float64,0x3fa6f80ba02df017,0x3ff0041f51fa0d76,1 +np.float64,0xbfdce79488b9cf2a,0x3ff1a8e32877beb4,1 +np.float64,0x2285f3e4450bf,0x3ff0000000000000,1 +np.float64,0x3bf7eb7277efe,0x3ff0000000000000,1 +np.float64,0xbfd5925fd3ab24c0,0x3ff0eae1c2ac2e78,1 +np.float64,0xbfed6325227ac64a,0x3ff73c14a2ad5bfe,1 +np.float64,0x8000429c02408539,0x3ff0000000000000,1 +np.float64,0xb67c21e76cf84,0x3ff0000000000000,1 +np.float64,0x3fec3d3462f87a69,0x3ff6a51e4c027eb7,1 +np.float64,0x3feae69cbcf5cd3a,0x3ff5fe9387314afd,1 +np.float64,0x7fd0c9a0ec219341,0x7ff0000000000000,1 +np.float64,0x8004adb7f6295b71,0x3ff0000000000000,1 +np.float64,0xffd61fe8bb2c3fd2,0x7ff0000000000000,1 +np.float64,0xffe7fb3834aff670,0x7ff0000000000000,1 +np.float64,0x7fd1eef163a3dde2,0x7ff0000000000000,1 +np.float64,0x2e84547a5d08b,0x3ff0000000000000,1 +np.float64,0x8002d8875ee5b10f,0x3ff0000000000000,1 +np.float64,0x3fe1d1c5f763a38c,0x3ff28ba524fb6de8,1 +np.float64,0x8001dea0bc43bd42,0x3ff0000000000000,1 +np.float64,0xfecfad91fd9f6,0x3ff0000000000000,1 +np.float64,0xffed7965fa3af2cb,0x7ff0000000000000,1 +np.float64,0xbfe6102ccc2c205a,0x3ff3f4c082506686,1 +np.float64,0x3feff75b777feeb6,0x3ff8ab6222578e0c,1 +np.float64,0x3fb8a97bd43152f8,0x3ff013057f0a9d89,1 +np.float64,0xffe234b5e964696c,0x7ff0000000000000,1 +np.float64,0x984d9137309b2,0x3ff0000000000000,1 +np.float64,0xbfe42e9230e85d24,0x3ff349fb7d1a7560,1 +np.float64,0xbfecc8b249f99165,0x3ff6ebd0fea0ea72,1 +np.float64,0x8000840910410813,0x3ff0000000000000,1 +np.float64,0xbfd81db9e7303b74,0x3ff126402d3539ec,1 +np.float64,0x800548eb7fea91d8,0x3ff0000000000000,1 +np.float64,0xbfe4679ad0e8cf36,0x3ff35d4db89296a3,1 +np.float64,0x3fd4c55b5a298ab7,0x3ff0d99da31081f9,1 +np.float64,0xbfa8f5b38c31eb60,0x3ff004de3a23b32d,1 +np.float64,0x80005d348e80ba6a,0x3ff0000000000000,1 +np.float64,0x800c348d6118691b,0x3ff0000000000000,1 +np.float64,0xffd6b88f84ad7120,0x7ff0000000000000,1 +np.float64,0x3fc1aaaa82235555,0x3ff027136afd08e0,1 +np.float64,0x7fca7d081b34fa0f,0x7ff0000000000000,1 +np.float64,0x1,0x3ff0000000000000,1 +np.float64,0xbfdc810d1139021a,0x3ff19d007408cfe3,1 +np.float64,0xbfe5dce05f2bb9c0,0x3ff3e1bb9234617b,1 +np.float64,0xffecfe2c32b9fc58,0x7ff0000000000000,1 +np.float64,0x95b2891b2b651,0x3ff0000000000000,1 +np.float64,0x8000b60c6c616c1a,0x3ff0000000000000,1 +np.float64,0x4944f0889289f,0x3ff0000000000000,1 +np.float64,0x3fe6e508696dca10,0x3ff445d1b94863e9,1 +np.float64,0xbfe63355d0ec66ac,0x3ff401e74f16d16f,1 +np.float64,0xbfe9b9595af372b3,0x3ff57445e1b4d670,1 +np.float64,0x800e16f7313c2dee,0x3ff0000000000000,1 +np.float64,0xffe898f5f0b131eb,0x7ff0000000000000,1 +np.float64,0x3fe91ac651f2358d,0x3ff52e787c21c004,1 +np.float64,0x7fbfaac6783f558c,0x7ff0000000000000,1 +np.float64,0xd8ef3dfbb1de8,0x3ff0000000000000,1 +np.float64,0xbfc58c13a52b1828,0x3ff03a2c19d65019,1 +np.float64,0xbfbde55e8a3bcac0,0x3ff01bf648a3e0a7,1 +np.float64,0xffc3034930260694,0x7ff0000000000000,1 +np.float64,0xea77a64dd4ef5,0x3ff0000000000000,1 +np.float64,0x800cfe7e7739fcfd,0x3ff0000000000000,1 +np.float64,0x4960f31a92c1f,0x3ff0000000000000,1 +np.float64,0x3fd9552c94b2aa58,0x3ff14515a29add09,1 +np.float64,0xffe8b3244c316648,0x7ff0000000000000,1 +np.float64,0x3fe8201e6a70403d,0x3ff4c444fa679cce,1 +np.float64,0xffe9ab7c20f356f8,0x7ff0000000000000,1 +np.float64,0x3fed8bba5f7b1774,0x3ff751853c4c95c5,1 +np.float64,0x8007639cb76ec73a,0x3ff0000000000000,1 +np.float64,0xbfe396db89672db7,0x3ff317bfd1d6fa8c,1 +np.float64,0xbfeb42f888f685f1,0x3ff62a7e0eee56b1,1 +np.float64,0x3fe894827c712904,0x3ff4f4f561d9ea13,1 +np.float64,0xb66b3caf6cd68,0x3ff0000000000000,1 +np.float64,0x800f8907fdbf1210,0x3ff0000000000000,1 +np.float64,0x7fe9b0cddb73619b,0x7ff0000000000000,1 +np.float64,0xbfda70c0e634e182,0x3ff1628c6fdffc53,1 +np.float64,0x3fe0b5f534a16bea,0x3ff23b4ed4c2b48e,1 +np.float64,0xbfe8eee93671ddd2,0x3ff51b85b3c50ae4,1 +np.float64,0xbfe8c22627f1844c,0x3ff50858787a3bfe,1 +np.float64,0x37bb83c86f771,0x3ff0000000000000,1 +np.float64,0xffb7827ffe2f0500,0x7ff0000000000000,1 +np.float64,0x64317940c864,0x3ff0000000000000,1 +np.float64,0x800430ecee6861db,0x3ff0000000000000,1 +np.float64,0x3fa4291fbc285240,0x3ff0032d0204f6dd,1 +np.float64,0xffec69f76af8d3ee,0x7ff0000000000000,1 +np.float64,0x3ff0000000000000,0x3ff8b07551d9f550,1 +np.float64,0x3fc4cf3c42299e79,0x3ff0363fb1d3c254,1 +np.float64,0x7fe0223a77e04474,0x7ff0000000000000,1 +np.float64,0x800a3d4fa4347aa0,0x3ff0000000000000,1 +np.float64,0x3fdd273f94ba4e7f,0x3ff1b05b686e6879,1 +np.float64,0x3feca79052f94f20,0x3ff6dadedfa283aa,1 +np.float64,0x5e7f6f80bcfef,0x3ff0000000000000,1 +np.float64,0xbfef035892fe06b1,0x3ff81efb39cbeba2,1 +np.float64,0x3fee6c08e07cd812,0x3ff7caad952860a1,1 +np.float64,0xffeda715877b4e2a,0x7ff0000000000000,1 +np.float64,0x800580286b0b0052,0x3ff0000000000000,1 +np.float64,0x800703a73fee074f,0x3ff0000000000000,1 +np.float64,0xbfccf96a6639f2d4,0x3ff0696330a60832,1 +np.float64,0x7feb408442368108,0x7ff0000000000000,1 +np.float64,0x3fedc87a46fb90f5,0x3ff771e3635649a9,1 +np.float64,0x3fd8297b773052f7,0x3ff12762bc0cea76,1 +np.float64,0x3fee41bb03fc8376,0x3ff7b37b2da48ab4,1 +np.float64,0xbfe2b05a226560b4,0x3ff2cea17ae7c528,1 +np.float64,0xbfd2e92cf2a5d25a,0x3ff0b41d605ced61,1 +np.float64,0x4817f03a902ff,0x3ff0000000000000,1 +np.float64,0x8c9d4f0d193aa,0x3ff0000000000000,1 diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/data/umath-validation-set-exp.csv b/venv/lib/python3.12/site-packages/numpy/_core/tests/data/umath-validation-set-exp.csv new file mode 100644 index 00000000..7c5ef3b3 --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/tests/data/umath-validation-set-exp.csv @@ -0,0 +1,412 @@ +dtype,input,output,ulperrortol +## +ve denormals ## +np.float32,0x004b4716,0x3f800000,3 +np.float32,0x007b2490,0x3f800000,3 +np.float32,0x007c99fa,0x3f800000,3 +np.float32,0x00734a0c,0x3f800000,3 +np.float32,0x0070de24,0x3f800000,3 +np.float32,0x00495d65,0x3f800000,3 +np.float32,0x006894f6,0x3f800000,3 +np.float32,0x00555a76,0x3f800000,3 +np.float32,0x004e1fb8,0x3f800000,3 +np.float32,0x00687de9,0x3f800000,3 +## -ve denormals ## +np.float32,0x805b59af,0x3f800000,3 +np.float32,0x807ed8ed,0x3f800000,3 +np.float32,0x807142ad,0x3f800000,3 +np.float32,0x80772002,0x3f800000,3 +np.float32,0x8062abcb,0x3f800000,3 +np.float32,0x8045e31c,0x3f800000,3 +np.float32,0x805f01c2,0x3f800000,3 +np.float32,0x80506432,0x3f800000,3 +np.float32,0x8060089d,0x3f800000,3 +np.float32,0x8071292f,0x3f800000,3 +## floats that output a denormal ## +np.float32,0xc2cf3fc1,0x00000001,3 +np.float32,0xc2c79726,0x00000021,3 +np.float32,0xc2cb295d,0x00000005,3 +np.float32,0xc2b49e6b,0x00068c4c,3 +np.float32,0xc2ca8116,0x00000008,3 +np.float32,0xc2c23f82,0x000001d7,3 +np.float32,0xc2cb69c0,0x00000005,3 +np.float32,0xc2cc1f4d,0x00000003,3 +np.float32,0xc2ae094e,0x00affc4c,3 +np.float32,0xc2c86c44,0x00000015,3 +## random floats between -87.0f and 88.0f ## +np.float32,0x4030d7e0,0x417d9a05,3 +np.float32,0x426f60e8,0x6aa1be2c,3 +np.float32,0x41a1b220,0x4e0efc11,3 +np.float32,0xc20cc722,0x26159da7,3 +np.float32,0x41c492bc,0x512ec79d,3 +np.float32,0x40980210,0x42e73a0e,3 +np.float32,0xbf1f7b80,0x3f094de3,3 +np.float32,0x42a678a4,0x7b87a383,3 +np.float32,0xc20f3cfd,0x25a1c304,3 +np.float32,0x423ff34c,0x6216467f,3 +np.float32,0x00000000,0x3f800000,3 +## floats that cause an overflow ## +np.float32,0x7f06d8c1,0x7f800000,3 +np.float32,0x7f451912,0x7f800000,3 +np.float32,0x7ecceac3,0x7f800000,3 +np.float32,0x7f643b45,0x7f800000,3 +np.float32,0x7e910ea0,0x7f800000,3 +np.float32,0x7eb4756b,0x7f800000,3 +np.float32,0x7f4ec708,0x7f800000,3 +np.float32,0x7f6b4551,0x7f800000,3 +np.float32,0x7d8edbda,0x7f800000,3 +np.float32,0x7f730718,0x7f800000,3 +np.float32,0x42b17217,0x7f7fff84,3 +np.float32,0x42b17218,0x7f800000,3 +np.float32,0x42b17219,0x7f800000,3 +np.float32,0xfef2b0bc,0x00000000,3 +np.float32,0xff69f83e,0x00000000,3 +np.float32,0xff4ecb12,0x00000000,3 +np.float32,0xfeac6d86,0x00000000,3 +np.float32,0xfde0cdb8,0x00000000,3 +np.float32,0xff26aef4,0x00000000,3 +np.float32,0xff6f9277,0x00000000,3 +np.float32,0xff7adfc4,0x00000000,3 +np.float32,0xff0ad40e,0x00000000,3 +np.float32,0xff6fd8f3,0x00000000,3 +np.float32,0xc2cff1b4,0x00000001,3 +np.float32,0xc2cff1b5,0x00000000,3 +np.float32,0xc2cff1b6,0x00000000,3 +np.float32,0x7f800000,0x7f800000,3 +np.float32,0xff800000,0x00000000,3 +np.float32,0x4292f27c,0x7480000a,3 +np.float32,0x42a920be,0x7c7fff94,3 +np.float32,0x41c214c9,0x50ffffd9,3 +np.float32,0x41abe686,0x4effffd9,3 +np.float32,0x4287db5a,0x707fffd3,3 +np.float32,0x41902cbb,0x4c800078,3 +np.float32,0x42609466,0x67ffffeb,3 +np.float32,0x41a65af5,0x4e7fffd1,3 +np.float32,0x417f13ff,0x4affffc9,3 +np.float32,0x426d0e6c,0x6a3504f2,3 +np.float32,0x41bc8934,0x507fff51,3 +np.float32,0x42a7bdde,0x7c0000d6,3 +np.float32,0x4120cf66,0x46b504f6,3 +np.float32,0x4244da8f,0x62ffff1a,3 +np.float32,0x41a0cf69,0x4e000034,3 +np.float32,0x41cd2bec,0x52000005,3 +np.float32,0x42893e41,0x7100009e,3 +np.float32,0x41b437e1,0x4fb50502,3 +np.float32,0x41d8430f,0x5300001d,3 +np.float32,0x4244da92,0x62ffffda,3 +np.float32,0x41a0cf63,0x4dffffa9,3 +np.float32,0x3eb17218,0x3fb504f3,3 +np.float32,0x428729e8,0x703504dc,3 +np.float32,0x41a0cf67,0x4e000014,3 +np.float32,0x4252b77d,0x65800011,3 +np.float32,0x41902cb9,0x4c800058,3 +np.float32,0x42a0cf67,0x79800052,3 +np.float32,0x4152b77b,0x48ffffe9,3 +np.float32,0x41265af3,0x46ffffc8,3 +np.float32,0x42187e0b,0x5affff9a,3 +np.float32,0xc0d2b77c,0x3ab504f6,3 +np.float32,0xc283b2ac,0x10000072,3 +np.float32,0xc1cff1b4,0x2cb504f5,3 +np.float32,0xc05dce9e,0x3d000000,3 +np.float32,0xc28ec9d2,0x0bfffea5,3 +np.float32,0xc23c893a,0x1d7fffde,3 +np.float32,0xc2a920c0,0x027fff6c,3 +np.float32,0xc1f9886f,0x2900002b,3 +np.float32,0xc2c42920,0x000000b5,3 +np.float32,0xc2893e41,0x0dfffec5,3 +np.float32,0xc2c4da93,0x00000080,3 +np.float32,0xc17f1401,0x3400000c,3 +np.float32,0xc1902cb6,0x327fffaf,3 +np.float32,0xc27c4e3b,0x11ffffc5,3 +np.float32,0xc268e5c5,0x157ffe9d,3 +np.float32,0xc2b4e953,0x0005a826,3 +np.float32,0xc287db5a,0x0e800016,3 +np.float32,0xc207db5a,0x2700000b,3 +np.float32,0xc2b2d4fe,0x000ffff1,3 +np.float32,0xc268e5c0,0x157fffdd,3 +np.float32,0xc22920bd,0x2100003b,3 +np.float32,0xc2902caf,0x0b80011e,3 +np.float32,0xc1902cba,0x327fff2f,3 +np.float32,0xc2ca6625,0x00000008,3 +np.float32,0xc280ece8,0x10fffeb5,3 +np.float32,0xc2918f94,0x0b0000ea,3 +np.float32,0xc29b43d5,0x077ffffc,3 +np.float32,0xc1e61ff7,0x2ab504f5,3 +np.float32,0xc2867878,0x0effff15,3 +np.float32,0xc2a2324a,0x04fffff4,3 +#float64 +## near zero ## +np.float64,0x8000000000000000,0x3ff0000000000000,1 +np.float64,0x8010000000000000,0x3ff0000000000000,1 +np.float64,0x8000000000000001,0x3ff0000000000000,1 +np.float64,0x8360000000000000,0x3ff0000000000000,1 +np.float64,0x9a70000000000000,0x3ff0000000000000,1 +np.float64,0xb9b0000000000000,0x3ff0000000000000,1 +np.float64,0xb810000000000000,0x3ff0000000000000,1 +np.float64,0xbc30000000000000,0x3ff0000000000000,1 +np.float64,0xb6a0000000000000,0x3ff0000000000000,1 +np.float64,0x0000000000000000,0x3ff0000000000000,1 +np.float64,0x0010000000000000,0x3ff0000000000000,1 +np.float64,0x0000000000000001,0x3ff0000000000000,1 +np.float64,0x0360000000000000,0x3ff0000000000000,1 +np.float64,0x1a70000000000000,0x3ff0000000000000,1 +np.float64,0x3c30000000000000,0x3ff0000000000000,1 +np.float64,0x36a0000000000000,0x3ff0000000000000,1 +np.float64,0x39b0000000000000,0x3ff0000000000000,1 +np.float64,0x3810000000000000,0x3ff0000000000000,1 +## underflow ## +np.float64,0xc0c6276800000000,0x0000000000000000,1 +np.float64,0xc0c62d918ce2421d,0x0000000000000000,1 +np.float64,0xc0c62d918ce2421e,0x0000000000000000,1 +np.float64,0xc0c62d91a0000000,0x0000000000000000,1 +np.float64,0xc0c62d9180000000,0x0000000000000000,1 +np.float64,0xc0c62dea45ee3e06,0x0000000000000000,1 +np.float64,0xc0c62dea45ee3e07,0x0000000000000000,1 +np.float64,0xc0c62dea40000000,0x0000000000000000,1 +np.float64,0xc0c62dea60000000,0x0000000000000000,1 +np.float64,0xc0875f1120000000,0x0000000000000000,1 +np.float64,0xc0875f113c30b1c8,0x0000000000000000,1 +np.float64,0xc0875f1140000000,0x0000000000000000,1 +np.float64,0xc093480000000000,0x0000000000000000,1 +np.float64,0xffefffffffffffff,0x0000000000000000,1 +np.float64,0xc7efffffe0000000,0x0000000000000000,1 +## overflow ## +np.float64,0x40862e52fefa39ef,0x7ff0000000000000,1 +np.float64,0x40872e42fefa39ef,0x7ff0000000000000,1 +## +/- INF, +/- NAN ## +np.float64,0x7ff0000000000000,0x7ff0000000000000,1 +np.float64,0xfff0000000000000,0x0000000000000000,1 +np.float64,0x7ff8000000000000,0x7ff8000000000000,1 +np.float64,0xfff8000000000000,0xfff8000000000000,1 +## output denormal ## +np.float64,0xc087438520000000,0x0000000000000001,1 +np.float64,0xc08743853f2f4461,0x0000000000000001,1 +np.float64,0xc08743853f2f4460,0x0000000000000001,1 +np.float64,0xc087438540000000,0x0000000000000001,1 +## between -745.13321910 and 709.78271289 ## +np.float64,0xbff760cd14774bd9,0x3fcdb14ced00ceb6,1 +np.float64,0xbff760cd20000000,0x3fcdb14cd7993879,1 +np.float64,0xbff760cd00000000,0x3fcdb14d12fbd264,1 +np.float64,0xc07f1cf360000000,0x130c1b369af14fda,1 +np.float64,0xbeb0000000000000,0x3feffffe00001000,1 +np.float64,0xbd70000000000000,0x3fefffffffffe000,1 +np.float64,0xc084fd46e5c84952,0x0360000000000139,1 +np.float64,0xc084fd46e5c84953,0x035ffffffffffe71,1 +np.float64,0xc084fd46e0000000,0x0360000b9096d32c,1 +np.float64,0xc084fd4700000000,0x035fff9721d12104,1 +np.float64,0xc086232bc0000000,0x0010003af5e64635,1 +np.float64,0xc086232bdd7abcd2,0x001000000000007c,1 +np.float64,0xc086232bdd7abcd3,0x000ffffffffffe7c,1 +np.float64,0xc086232be0000000,0x000ffffaf57a6fc9,1 +np.float64,0xc086233920000000,0x000fe590e3b45eb0,1 +np.float64,0xc086233938000000,0x000fe56133493c57,1 +np.float64,0xc086233940000000,0x000fe5514deffbbc,1 +np.float64,0xc086234c98000000,0x000fbf1024c32ccb,1 +np.float64,0xc086234ca0000000,0x000fbf0065bae78d,1 +np.float64,0xc086234c80000000,0x000fbf3f623a7724,1 +np.float64,0xc086234ec0000000,0x000fbad237c846f9,1 +np.float64,0xc086234ec8000000,0x000fbac27cfdec97,1 +np.float64,0xc086234ee0000000,0x000fba934cfd3dc2,1 +np.float64,0xc086234ef0000000,0x000fba73d7f618d9,1 +np.float64,0xc086234f00000000,0x000fba54632dddc0,1 +np.float64,0xc0862356e0000000,0x000faae0945b761a,1 +np.float64,0xc0862356f0000000,0x000faac13eb9a310,1 +np.float64,0xc086235700000000,0x000faaa1e9567b0a,1 +np.float64,0xc086236020000000,0x000f98cd75c11ed7,1 +np.float64,0xc086236ca0000000,0x000f8081b4d93f89,1 +np.float64,0xc086236cb0000000,0x000f8062b3f4d6c5,1 +np.float64,0xc086236cc0000000,0x000f8043b34e6f8c,1 +np.float64,0xc086238d98000000,0x000f41220d9b0d2c,1 +np.float64,0xc086238da0000000,0x000f4112cc80a01f,1 +np.float64,0xc086238d80000000,0x000f414fd145db5b,1 +np.float64,0xc08624fd00000000,0x000cbfce8ea1e6c4,1 +np.float64,0xc086256080000000,0x000c250747fcd46e,1 +np.float64,0xc08626c480000000,0x000a34f4bd975193,1 +np.float64,0xbf50000000000000,0x3feff800ffeaac00,1 +np.float64,0xbe10000000000000,0x3fefffffff800000,1 +np.float64,0xbcd0000000000000,0x3feffffffffffff8,1 +np.float64,0xc055d589e0000000,0x38100004bf94f63e,1 +np.float64,0xc055d58a00000000,0x380ffff97f292ce8,1 +np.float64,0xbfd962d900000000,0x3fe585a4b00110e1,1 +np.float64,0x3ff4bed280000000,0x400d411e7a58a303,1 +np.float64,0x3fff0b3620000000,0x401bd7737ffffcf3,1 +np.float64,0x3ff0000000000000,0x4005bf0a8b145769,1 +np.float64,0x3eb0000000000000,0x3ff0000100000800,1 +np.float64,0x3d70000000000000,0x3ff0000000001000,1 +np.float64,0x40862e42e0000000,0x7fefff841808287f,1 +np.float64,0x40862e42fefa39ef,0x7fefffffffffff2a,1 +np.float64,0x40862e0000000000,0x7feef85a11e73f2d,1 +np.float64,0x4000000000000000,0x401d8e64b8d4ddae,1 +np.float64,0x4009242920000000,0x40372a52c383a488,1 +np.float64,0x4049000000000000,0x44719103e4080b45,1 +np.float64,0x4008000000000000,0x403415e5bf6fb106,1 +np.float64,0x3f50000000000000,0x3ff00400800aab55,1 +np.float64,0x3e10000000000000,0x3ff0000000400000,1 +np.float64,0x3cd0000000000000,0x3ff0000000000004,1 +np.float64,0x40562e40a0000000,0x47effed088821c3f,1 +np.float64,0x40562e42e0000000,0x47effff082e6c7ff,1 +np.float64,0x40562e4300000000,0x47f00000417184b8,1 +np.float64,0x3fe8000000000000,0x4000ef9db467dcf8,1 +np.float64,0x402b12e8d4f33589,0x412718f68c71a6fe,1 +np.float64,0x402b12e8d4f3358a,0x412718f68c71a70a,1 +np.float64,0x402b12e8c0000000,0x412718f59a7f472e,1 +np.float64,0x402b12e8e0000000,0x412718f70c0eac62,1 +##use 1th entry +np.float64,0x40631659AE147CB4,0x4db3a95025a4890f,1 +np.float64,0xC061B87D2E85A4E2,0x332640c8e2de2c51,1 +np.float64,0x405A4A50BE243AF4,0x496a45e4b7f0339a,1 +np.float64,0xC0839898B98EC5C6,0x0764027828830df4,1 +#use 2th entry +np.float64,0xC072428C44B6537C,0x2596ade838b96f3e,1 +np.float64,0xC053057C5E1AE9BF,0x3912c8fad18fdadf,1 +np.float64,0x407E89C78328BAA3,0x6bfe35d5b9a1a194,1 +np.float64,0x4083501B6DD87112,0x77a855503a38924e,1 +#use 3th entry +np.float64,0x40832C6195F24540,0x7741e73c80e5eb2f,1 +np.float64,0xC083D4CD557C2EC9,0x06b61727c2d2508e,1 +np.float64,0x400C48F5F67C99BD,0x404128820f02b92e,1 +np.float64,0x4056E36D9B2DF26A,0x4830f52ff34a8242,1 +#use 4th entry +np.float64,0x4080FF700D8CBD06,0x70fa70df9bc30f20,1 +np.float64,0x406C276D39E53328,0x543eb8e20a8f4741,1 +np.float64,0xC070D6159BBD8716,0x27a4a0548c904a75,1 +np.float64,0xC052EBCF8ED61F83,0x391c0e92368d15e4,1 +#use 5th entry +np.float64,0xC061F892A8AC5FBE,0x32f807a89efd3869,1 +np.float64,0x4021D885D2DBA085,0x40bd4dc86d3e3270,1 +np.float64,0x40767AEEEE7D4FCF,0x605e22851ee2afb7,1 +np.float64,0xC0757C5D75D08C80,0x20f0751599b992a2,1 +#use 6th entry +np.float64,0x405ACF7A284C4CE3,0x499a4e0b7a27027c,1 +np.float64,0xC085A6C9E80D7AF5,0x0175914009d62ec2,1 +np.float64,0xC07E4C02F86F1DAE,0x1439269b29a9231e,1 +np.float64,0x4080D80F9691CC87,0x7088a6cdafb041de,1 +#use 7th entry +np.float64,0x407FDFD84FBA0AC1,0x6deb1ae6f9bc4767,1 +np.float64,0x40630C06A1A2213D,0x4dac7a9d51a838b7,1 +np.float64,0x40685FDB30BB8B4F,0x5183f5cc2cac9e79,1 +np.float64,0x408045A2208F77F4,0x6ee299e08e2aa2f0,1 +#use 8th entry +np.float64,0xC08104E391F5078B,0x0ed397b7cbfbd230,1 +np.float64,0xC031501CAEFAE395,0x3e6040fd1ea35085,1 +np.float64,0xC079229124F6247C,0x1babf4f923306b1e,1 +np.float64,0x407FB65F44600435,0x6db03beaf2512b8a,1 +#use 9th entry +np.float64,0xC07EDEE8E8E8A5AC,0x136536cec9cbef48,1 +np.float64,0x4072BB4086099A14,0x5af4d3c3008b56cc,1 +np.float64,0x4050442A2EC42CB4,0x45cd393bd8fad357,1 +np.float64,0xC06AC28FB3D419B4,0x2ca1b9d3437df85f,1 +#use 10th entry +np.float64,0x40567FC6F0A68076,0x480c977fd5f3122e,1 +np.float64,0x40620A2F7EDA59BB,0x4cf278e96f4ce4d7,1 +np.float64,0xC085044707CD557C,0x034aad6c968a045a,1 +np.float64,0xC07374EA5AC516AA,0x23dd6afdc03e83d5,1 +#use 11th entry +np.float64,0x4073CC95332619C1,0x5c804b1498bbaa54,1 +np.float64,0xC0799FEBBE257F31,0x1af6a954c43b87d2,1 +np.float64,0x408159F19EA424F6,0x7200858efcbfc84d,1 +np.float64,0x404A81F6F24C0792,0x44b664a07ce5bbfa,1 +#use 12th entry +np.float64,0x40295FF1EFB9A741,0x4113c0e74c52d7b0,1 +np.float64,0x4073975F4CC411DA,0x5c32be40b4fec2c1,1 +np.float64,0x406E9DE52E82A77E,0x56049c9a3f1ae089,1 +np.float64,0x40748C2F52560ED9,0x5d93bc14fd4cd23b,1 +#use 13th entry +np.float64,0x4062A553CDC4D04C,0x4d6266bfde301318,1 +np.float64,0xC079EC1D63598AB7,0x1a88cb184dab224c,1 +np.float64,0xC0725C1CB3167427,0x25725b46f8a081f6,1 +np.float64,0x407888771D9B45F9,0x6353b1ec6bd7ce80,1 +#use 14th entry +np.float64,0xC082CBA03AA89807,0x09b383723831ce56,1 +np.float64,0xC083A8961BB67DD7,0x0735b118d5275552,1 +np.float64,0xC076BC6ECA12E7E3,0x1f2222679eaef615,1 +np.float64,0xC072752503AA1A5B,0x254eb832242c77e1,1 +#use 15th entry +np.float64,0xC058800792125DEC,0x371882372a0b48d4,1 +np.float64,0x4082909FD863E81C,0x7580d5f386920142,1 +np.float64,0xC071616F8FB534F9,0x26dbe20ef64a412b,1 +np.float64,0x406D1AB571CAA747,0x54ee0d55cb38ac20,1 +#use 16th entry +np.float64,0x406956428B7DAD09,0x52358682c271237f,1 +np.float64,0xC07EFC2D9D17B621,0x133b3e77c27a4d45,1 +np.float64,0xC08469BAC5BA3CCA,0x050863e5f42cc52f,1 +np.float64,0x407189D9626386A5,0x593cb1c0b3b5c1d3,1 +#use 17th entry +np.float64,0x4077E652E3DEB8C6,0x6269a10dcbd3c752,1 +np.float64,0x407674C97DB06878,0x605485dcc2426ec2,1 +np.float64,0xC07CE9969CF4268D,0x16386cf8996669f2,1 +np.float64,0x40780EE32D5847C4,0x62a436bd1abe108d,1 +#use 18th entry +np.float64,0x4076C3AA5E1E8DA1,0x60c62f56a5e72e24,1 +np.float64,0xC0730AFC7239B9BE,0x24758ead095cec1e,1 +np.float64,0xC085CC2B9C420DDB,0x0109cdaa2e5694c1,1 +np.float64,0x406D0765CB6D7AA4,0x54e06f8dd91bd945,1 +#use 19th entry +np.float64,0xC082D011F3B495E7,0x09a6647661d279c2,1 +np.float64,0xC072826AF8F6AFBC,0x253acd3cd224507e,1 +np.float64,0x404EB9C4810CEA09,0x457933dbf07e8133,1 +np.float64,0x408284FBC97C58CE,0x755f6eb234aa4b98,1 +#use 20th entry +np.float64,0x40856008CF6EDC63,0x7d9c0b3c03f4f73c,1 +np.float64,0xC077CB2E9F013B17,0x1d9b3d3a166a55db,1 +np.float64,0xC0479CA3C20AD057,0x3bad40e081555b99,1 +np.float64,0x40844CD31107332A,0x7a821d70aea478e2,1 +#use 21th entry +np.float64,0xC07C8FCC0BFCC844,0x16ba1cc8c539d19b,1 +np.float64,0xC085C4E9A3ABA488,0x011ff675ba1a2217,1 +np.float64,0x4074D538B32966E5,0x5dfd9d78043c6ad9,1 +np.float64,0xC0630CA16902AD46,0x3231a446074cede6,1 +#use 22th entry +np.float64,0xC06C826733D7D0B7,0x2b5f1078314d41e1,1 +np.float64,0xC0520DF55B2B907F,0x396c13a6ce8e833e,1 +np.float64,0xC080712072B0F437,0x107eae02d11d98ea,1 +np.float64,0x40528A6150E19EFB,0x469fdabda02228c5,1 +#use 23th entry +np.float64,0xC07B1D74B6586451,0x18d1253883ae3b48,1 +np.float64,0x4045AFD7867DAEC0,0x43d7d634fc4c5d98,1 +np.float64,0xC07A08B91F9ED3E2,0x1a60973e6397fc37,1 +np.float64,0x407B3ECF0AE21C8C,0x673e03e9d98d7235,1 +#use 24th entry +np.float64,0xC078AEB6F30CEABF,0x1c530b93ab54a1b3,1 +np.float64,0x4084495006A41672,0x7a775b6dc7e63064,1 +np.float64,0x40830B1C0EBF95DD,0x76e1e6eed77cfb89,1 +np.float64,0x407D93E8F33D8470,0x6a9adbc9e1e4f1e5,1 +#use 25th entry +np.float64,0x4066B11A09EFD9E8,0x504dd528065c28a7,1 +np.float64,0x408545823723AEEB,0x7d504a9b1844f594,1 +np.float64,0xC068C711F2CA3362,0x2e104f3496ea118e,1 +np.float64,0x407F317FCC3CA873,0x6cf0732c9948ebf4,1 +#use 26th entry +np.float64,0x407AFB3EBA2ED50F,0x66dc28a129c868d5,1 +np.float64,0xC075377037708ADE,0x21531a329f3d793e,1 +np.float64,0xC07C30066A1F3246,0x174448baa16ded2b,1 +np.float64,0xC06689A75DE2ABD3,0x2fad70662fae230b,1 +#use 27th entry +np.float64,0x4081514E9FCCF1E0,0x71e673b9efd15f44,1 +np.float64,0xC0762C710AF68460,0x1ff1ed7d8947fe43,1 +np.float64,0xC0468102FF70D9C4,0x3be0c3a8ff3419a3,1 +np.float64,0xC07EA4CEEF02A83E,0x13b908f085102c61,1 +#use 28th entry +np.float64,0xC06290B04AE823C4,0x328a83da3c2e3351,1 +np.float64,0xC0770EB1D1C395FB,0x1eab281c1f1db5fe,1 +np.float64,0xC06F5D4D838A5BAE,0x29500ea32fb474ea,1 +np.float64,0x40723B3133B54C5D,0x5a3c82c7c3a2b848,1 +#use 29th entry +np.float64,0x4085E6454CE3B4AA,0x7f20319b9638d06a,1 +np.float64,0x408389F2A0585D4B,0x7850667c58aab3d0,1 +np.float64,0xC0382798F9C8AE69,0x3dc1c79fe8739d6d,1 +np.float64,0xC08299D827608418,0x0a4335f76cdbaeb5,1 +#use 30th entry +np.float64,0xC06F3DED43301BF1,0x2965670ae46750a8,1 +np.float64,0xC070CAF6BDD577D9,0x27b4aa4ffdd29981,1 +np.float64,0x4078529AD4B2D9F2,0x6305c12755d5e0a6,1 +np.float64,0xC055B14E75A31B96,0x381c2eda6d111e5d,1 +#use 31th entry +np.float64,0x407B13EE414FA931,0x6700772c7544564d,1 +np.float64,0x407EAFDE9DE3EC54,0x6c346a0e49724a3c,1 +np.float64,0xC08362F398B9530D,0x07ffeddbadf980cb,1 +np.float64,0x407E865CDD9EEB86,0x6bf866cac5e0d126,1 +#use 32th entry +np.float64,0x407FB62DBC794C86,0x6db009f708ac62cb,1 +np.float64,0xC063D0BAA68CDDDE,0x31a3b2a51ce50430,1 +np.float64,0xC05E7706A2231394,0x34f24bead6fab5c9,1 +np.float64,0x4083E3A06FDE444E,0x79527b7a386d1937,1 diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/data/umath-validation-set-exp2.csv b/venv/lib/python3.12/site-packages/numpy/_core/tests/data/umath-validation-set-exp2.csv new file mode 100644 index 00000000..4e0a63e8 --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/tests/data/umath-validation-set-exp2.csv @@ -0,0 +1,1429 @@ +dtype,input,output,ulperrortol +np.float32,0xbdfe94b0,0x3f6adda6,2 +np.float32,0x3f20f8f8,0x3fc5ec69,2 +np.float32,0x7040b5,0x3f800000,2 +np.float32,0x30ec5,0x3f800000,2 +np.float32,0x3eb63070,0x3fa3ce29,2 +np.float32,0xff4dda3d,0x0,2 +np.float32,0x805b832f,0x3f800000,2 +np.float32,0x3e883fb7,0x3f99ed8c,2 +np.float32,0x3f14d71f,0x3fbf8708,2 +np.float32,0xff7b1e55,0x0,2 +np.float32,0xbf691ac6,0x3f082fa2,2 +np.float32,0x7ee3e6ab,0x7f800000,2 +np.float32,0xbec6e2b4,0x3f439248,2 +np.float32,0xbf5f5ec2,0x3f0bd2c0,2 +np.float32,0x8025cc2c,0x3f800000,2 +np.float32,0x7e0d7672,0x7f800000,2 +np.float32,0xff4bbc5c,0x0,2 +np.float32,0xbd94fb30,0x3f73696b,2 +np.float32,0x6cc079,0x3f800000,2 +np.float32,0x803cf080,0x3f800000,2 +np.float32,0x71d418,0x3f800000,2 +np.float32,0xbf24a442,0x3f23ec1e,2 +np.float32,0xbe6c9510,0x3f5a1e1d,2 +np.float32,0xbe8fb284,0x3f52be38,2 +np.float32,0x7ea64754,0x7f800000,2 +np.float32,0x7fc00000,0x7fc00000,2 +np.float32,0x80620cfd,0x3f800000,2 +np.float32,0x3f3e20e8,0x3fd62e72,2 +np.float32,0x3f384600,0x3fd2d00e,2 +np.float32,0xff362150,0x0,2 +np.float32,0xbf349fa8,0x3f1cfaef,2 +np.float32,0xbf776cf2,0x3f0301a6,2 +np.float32,0x8021fc60,0x3f800000,2 +np.float32,0xbdb75280,0x3f70995c,2 +np.float32,0x7e9363a6,0x7f800000,2 +np.float32,0x7e728422,0x7f800000,2 +np.float32,0xfe91edc2,0x0,2 +np.float32,0x3f5f438c,0x3fea491d,2 +np.float32,0x3f2afae9,0x3fcb5c1f,2 +np.float32,0xbef8e766,0x3f36c448,2 +np.float32,0xba522c00,0x3f7fdb97,2 +np.float32,0xff18ee8c,0x0,2 +np.float32,0xbee8c5f4,0x3f3acd44,2 +np.float32,0x3e790448,0x3f97802c,2 +np.float32,0x3e8c9541,0x3f9ad571,2 +np.float32,0xbf03fa9f,0x3f331460,2 +np.float32,0x801ee053,0x3f800000,2 +np.float32,0xbf773230,0x3f03167f,2 +np.float32,0x356fd9,0x3f800000,2 +np.float32,0x8009cd88,0x3f800000,2 +np.float32,0x7f2bac51,0x7f800000,2 +np.float32,0x4d9eeb,0x3f800000,2 +np.float32,0x3133,0x3f800000,2 +np.float32,0x7f4290e0,0x7f800000,2 +np.float32,0xbf5e6523,0x3f0c3161,2 +np.float32,0x3f19182e,0x3fc1bf10,2 +np.float32,0x7e1248bb,0x7f800000,2 +np.float32,0xff5f7aae,0x0,2 +np.float32,0x7e8557b5,0x7f800000,2 +np.float32,0x26fc7f,0x3f800000,2 +np.float32,0x80397d61,0x3f800000,2 +np.float32,0x3cb1825d,0x3f81efe0,2 +np.float32,0x3ed808d0,0x3fab7c45,2 +np.float32,0xbf6f668a,0x3f05e259,2 +np.float32,0x3e3c7802,0x3f916abd,2 +np.float32,0xbd5ac5a0,0x3f76b21b,2 +np.float32,0x805aa6c9,0x3f800000,2 +np.float32,0xbe4d6f68,0x3f5ec3e1,2 +np.float32,0x3f3108b2,0x3fceb87f,2 +np.float32,0x3ec385cc,0x3fa6c9fb,2 +np.float32,0xbe9fc1ce,0x3f4e35e8,2 +np.float32,0x43b68,0x3f800000,2 +np.float32,0x3ef0cdcc,0x3fb15557,2 +np.float32,0x3e3f729b,0x3f91b5e1,2 +np.float32,0x7f52a4df,0x7f800000,2 +np.float32,0xbf56da96,0x3f0f15b9,2 +np.float32,0xbf161d2b,0x3f2a7faf,2 +np.float32,0x3e8df763,0x3f9b1fbe,2 +np.float32,0xff4f0780,0x0,2 +np.float32,0x8048f594,0x3f800000,2 +np.float32,0x3e62bb1d,0x3f953b7e,2 +np.float32,0xfe58e764,0x0,2 +np.float32,0x3dd2c922,0x3f897718,2 +np.float32,0x7fa00000,0x7fe00000,2 +np.float32,0xff07b4b2,0x0,2 +np.float32,0x7f6231a0,0x7f800000,2 +np.float32,0xb8d1d,0x3f800000,2 +np.float32,0x3ee01d24,0x3fad5f16,2 +np.float32,0xbf43f59f,0x3f169869,2 +np.float32,0x801f5257,0x3f800000,2 +np.float32,0x803c15d8,0x3f800000,2 +np.float32,0x3f171a08,0x3fc0b42a,2 +np.float32,0x127aef,0x3f800000,2 +np.float32,0xfd1c6,0x3f800000,2 +np.float32,0x3f1ed13e,0x3fc4c59a,2 +np.float32,0x57fd4f,0x3f800000,2 +np.float32,0x6e8c61,0x3f800000,2 +np.float32,0x804019ab,0x3f800000,2 +np.float32,0x3ef4e5c6,0x3fb251a1,2 +np.float32,0x5044c3,0x3f800000,2 +np.float32,0x3f04460f,0x3fb7204b,2 +np.float32,0x7e326b47,0x7f800000,2 +np.float32,0x800a7e4c,0x3f800000,2 +np.float32,0xbf47ec82,0x3f14fccc,2 +np.float32,0xbedb1b3e,0x3f3e4a4d,2 +np.float32,0x3f741d86,0x3ff7e4b0,2 +np.float32,0xbe249d20,0x3f6501a6,2 +np.float32,0xbf2ea152,0x3f1f8c68,2 +np.float32,0x3ec6dbcc,0x3fa78b3f,2 +np.float32,0x7ebd9bb4,0x7f800000,2 +np.float32,0x3f61b574,0x3febd77a,2 +np.float32,0x3f3dfb2b,0x3fd61891,2 +np.float32,0x3c7d95,0x3f800000,2 +np.float32,0x8071e840,0x3f800000,2 +np.float32,0x15c6fe,0x3f800000,2 +np.float32,0xbf096601,0x3f307893,2 +np.float32,0x7f5c2ef9,0x7f800000,2 +np.float32,0xbe79f750,0x3f582689,2 +np.float32,0x1eb692,0x3f800000,2 +np.float32,0xbd8024f0,0x3f75226d,2 +np.float32,0xbf5a8be8,0x3f0da950,2 +np.float32,0xbf4d28f3,0x3f12e3e1,2 +np.float32,0x7f800000,0x7f800000,2 +np.float32,0xfea8a758,0x0,2 +np.float32,0x8075d2cf,0x3f800000,2 +np.float32,0xfd99af58,0x0,2 +np.float32,0x9e6a,0x3f800000,2 +np.float32,0x2fa19f,0x3f800000,2 +np.float32,0x3e9f4206,0x3f9ecc56,2 +np.float32,0xbee0b666,0x3f3cd9fc,2 +np.float32,0xbec558c4,0x3f43fab1,2 +np.float32,0x7e9a77df,0x7f800000,2 +np.float32,0xff3a9694,0x0,2 +np.float32,0x3f3b3708,0x3fd47f9a,2 +np.float32,0x807cd6d4,0x3f800000,2 +np.float32,0x804aa422,0x3f800000,2 +np.float32,0xfead7a70,0x0,2 +np.float32,0x3f08c610,0x3fb95efe,2 +np.float32,0xff390126,0x0,2 +np.float32,0x5d2d47,0x3f800000,2 +np.float32,0x8006849c,0x3f800000,2 +np.float32,0x654f6e,0x3f800000,2 +np.float32,0xff478a16,0x0,2 +np.float32,0x3f480b0c,0x3fdc024c,2 +np.float32,0xbc3b96c0,0x3f7df9f4,2 +np.float32,0xbcc96460,0x3f7bacb5,2 +np.float32,0x7f349f30,0x7f800000,2 +np.float32,0xbe08fa98,0x3f6954a1,2 +np.float32,0x4f3a13,0x3f800000,2 +np.float32,0x7f6a5ab4,0x7f800000,2 +np.float32,0x7eb85247,0x7f800000,2 +np.float32,0xbf287246,0x3f223e08,2 +np.float32,0x801584d0,0x3f800000,2 +np.float32,0x7ec25371,0x7f800000,2 +np.float32,0x3f002165,0x3fb51552,2 +np.float32,0x3e1108a8,0x3f8d3429,2 +np.float32,0x4f0f88,0x3f800000,2 +np.float32,0x7f67c1ce,0x7f800000,2 +np.float32,0xbf4348f8,0x3f16dedf,2 +np.float32,0xbe292b64,0x3f644d24,2 +np.float32,0xbf2bfa36,0x3f20b2d6,2 +np.float32,0xbf2a6e58,0x3f215f71,2 +np.float32,0x3e97d5d3,0x3f9d35df,2 +np.float32,0x31f597,0x3f800000,2 +np.float32,0x100544,0x3f800000,2 +np.float32,0x10a197,0x3f800000,2 +np.float32,0x3f44df50,0x3fda20d2,2 +np.float32,0x59916d,0x3f800000,2 +np.float32,0x707472,0x3f800000,2 +np.float32,0x8054194e,0x3f800000,2 +np.float32,0x80627b01,0x3f800000,2 +np.float32,0x7f4d5a5b,0x7f800000,2 +np.float32,0xbcecad00,0x3f7aeca5,2 +np.float32,0xff69c541,0x0,2 +np.float32,0xbe164e20,0x3f673c3a,2 +np.float32,0x3dd321de,0x3f897b39,2 +np.float32,0x3c9c4900,0x3f81b431,2 +np.float32,0x7f0efae3,0x7f800000,2 +np.float32,0xbf1b3ee6,0x3f282567,2 +np.float32,0x3ee858ac,0x3faf5083,2 +np.float32,0x3f0e6a39,0x3fbc3965,2 +np.float32,0x7f0c06d8,0x7f800000,2 +np.float32,0x801dd236,0x3f800000,2 +np.float32,0x564245,0x3f800000,2 +np.float32,0x7e99d3ad,0x7f800000,2 +np.float32,0xff3b0164,0x0,2 +np.float32,0x3f386f18,0x3fd2e785,2 +np.float32,0x7f603c39,0x7f800000,2 +np.float32,0x3cbd9b00,0x3f8211f0,2 +np.float32,0x2178e2,0x3f800000,2 +np.float32,0x5db226,0x3f800000,2 +np.float32,0xfec78d62,0x0,2 +np.float32,0x7f40bc1e,0x7f800000,2 +np.float32,0x80325064,0x3f800000,2 +np.float32,0x3f6068dc,0x3feb0377,2 +np.float32,0xfe8b95c6,0x0,2 +np.float32,0xbe496894,0x3f5f5f87,2 +np.float32,0xbf18722a,0x3f296cf4,2 +np.float32,0x332d0e,0x3f800000,2 +np.float32,0x3f6329dc,0x3fecc5c0,2 +np.float32,0x807d1802,0x3f800000,2 +np.float32,0x3e8afcee,0x3f9a7ff1,2 +np.float32,0x26a0a7,0x3f800000,2 +np.float32,0x7f13085d,0x7f800000,2 +np.float32,0x68d547,0x3f800000,2 +np.float32,0x7e9b04ae,0x7f800000,2 +np.float32,0x3f3ecdfe,0x3fd692ea,2 +np.float32,0x805256f4,0x3f800000,2 +np.float32,0x3f312dc8,0x3fcecd42,2 +np.float32,0x23ca15,0x3f800000,2 +np.float32,0x3f53c455,0x3fe31ad6,2 +np.float32,0xbf21186c,0x3f2580fd,2 +np.float32,0x803b9bb1,0x3f800000,2 +np.float32,0xff6ae1fc,0x0,2 +np.float32,0x2103cf,0x3f800000,2 +np.float32,0xbedcec6c,0x3f3dd29d,2 +np.float32,0x7f520afa,0x7f800000,2 +np.float32,0x7e8b44f2,0x7f800000,2 +np.float32,0xfef7f6ce,0x0,2 +np.float32,0xbd5e7c30,0x3f768a6f,2 +np.float32,0xfeb36848,0x0,2 +np.float32,0xff49effb,0x0,2 +np.float32,0xbec207c0,0x3f44dc74,2 +np.float32,0x3e91147f,0x3f9bc77f,2 +np.float32,0xfe784cd4,0x0,2 +np.float32,0xfd1a7250,0x0,2 +np.float32,0xff3b3f48,0x0,2 +np.float32,0x3f685db5,0x3ff0219f,2 +np.float32,0x3f370976,0x3fd21bae,2 +np.float32,0xfed4cc20,0x0,2 +np.float32,0xbf41e337,0x3f17714a,2 +np.float32,0xbf4e8638,0x3f12593a,2 +np.float32,0x3edaf0f1,0x3fac295e,2 +np.float32,0x803cbb4f,0x3f800000,2 +np.float32,0x7f492043,0x7f800000,2 +np.float32,0x2cabcf,0x3f800000,2 +np.float32,0x17f8ac,0x3f800000,2 +np.float32,0x3e846478,0x3f99205a,2 +np.float32,0x76948f,0x3f800000,2 +np.float32,0x1,0x3f800000,2 +np.float32,0x7ea6419e,0x7f800000,2 +np.float32,0xa5315,0x3f800000,2 +np.float32,0xff3a8e32,0x0,2 +np.float32,0xbe5714e8,0x3f5d50b7,2 +np.float32,0xfeadf960,0x0,2 +np.float32,0x3ebbd1a8,0x3fa50efc,2 +np.float32,0x7f31dce7,0x7f800000,2 +np.float32,0x80314999,0x3f800000,2 +np.float32,0x8017f41b,0x3f800000,2 +np.float32,0x7ed6d051,0x7f800000,2 +np.float32,0x7f525688,0x7f800000,2 +np.float32,0x7f7fffff,0x7f800000,2 +np.float32,0x3e8b0461,0x3f9a8180,2 +np.float32,0x3d9fe46e,0x3f871e1f,2 +np.float32,0x5e6d8f,0x3f800000,2 +np.float32,0xbf09ae55,0x3f305608,2 +np.float32,0xfe7028c4,0x0,2 +np.float32,0x7f3ade56,0x7f800000,2 +np.float32,0xff4c9ef9,0x0,2 +np.float32,0x7e3199cf,0x7f800000,2 +np.float32,0x8048652f,0x3f800000,2 +np.float32,0x805e1237,0x3f800000,2 +np.float32,0x189ed8,0x3f800000,2 +np.float32,0xbea7c094,0x3f4bfd98,2 +np.float32,0xbf2f109c,0x3f1f5c5c,2 +np.float32,0xbf0e7f4c,0x3f2e0d2c,2 +np.float32,0x8005981f,0x3f800000,2 +np.float32,0xbf762005,0x3f0377f3,2 +np.float32,0xbf0f60ab,0x3f2da317,2 +np.float32,0xbf4aa3e7,0x3f13e54e,2 +np.float32,0xbf348fd2,0x3f1d01aa,2 +np.float32,0x3e530b50,0x3f93a7fb,2 +np.float32,0xbf0b05a4,0x3f2fb26a,2 +np.float32,0x3eea416c,0x3fafc4aa,2 +np.float32,0x805ad04d,0x3f800000,2 +np.float32,0xbf6328d8,0x3f0a655e,2 +np.float32,0x3f7347b9,0x3ff75558,2 +np.float32,0xfda3ca68,0x0,2 +np.float32,0x80497d21,0x3f800000,2 +np.float32,0x3e740452,0x3f96fd22,2 +np.float32,0x3e528e57,0x3f939b7e,2 +np.float32,0x3e9e19fa,0x3f9e8cbd,2 +np.float32,0x8078060b,0x3f800000,2 +np.float32,0x3f3fea7a,0x3fd73872,2 +np.float32,0xfcfa30a0,0x0,2 +np.float32,0x7f4eb4bf,0x7f800000,2 +np.float32,0x3f712618,0x3ff5e900,2 +np.float32,0xbf668f0e,0x3f0920c6,2 +np.float32,0x3f3001e9,0x3fce259d,2 +np.float32,0xbe9b6fac,0x3f4f6b9c,2 +np.float32,0xbf61fcf3,0x3f0ad5ec,2 +np.float32,0xff08a55c,0x0,2 +np.float32,0x3e805014,0x3f984872,2 +np.float32,0x6ce04c,0x3f800000,2 +np.float32,0x7f7cbc07,0x7f800000,2 +np.float32,0x3c87dc,0x3f800000,2 +np.float32,0x3f2ee498,0x3fcd869a,2 +np.float32,0x4b1116,0x3f800000,2 +np.float32,0x3d382d06,0x3f840d5f,2 +np.float32,0xff7de21e,0x0,2 +np.float32,0x3f2f1d6d,0x3fcda63c,2 +np.float32,0xbf1c1618,0x3f27c38a,2 +np.float32,0xff4264b1,0x0,2 +np.float32,0x8026e5e7,0x3f800000,2 +np.float32,0xbe6fa180,0x3f59ab02,2 +np.float32,0xbe923c02,0x3f52053b,2 +np.float32,0xff3aa453,0x0,2 +np.float32,0x3f77a7ac,0x3ffa47d0,2 +np.float32,0xbed15f36,0x3f40d08a,2 +np.float32,0xa62d,0x3f800000,2 +np.float32,0xbf342038,0x3f1d3123,2 +np.float32,0x7f2f7f80,0x7f800000,2 +np.float32,0x7f2b6fc1,0x7f800000,2 +np.float32,0xff323540,0x0,2 +np.float32,0x3f1a2b6e,0x3fc24faa,2 +np.float32,0x800cc1d2,0x3f800000,2 +np.float32,0xff38fa01,0x0,2 +np.float32,0x80800000,0x3f800000,2 +np.float32,0xbf3d22e0,0x3f196745,2 +np.float32,0x7f40fd62,0x7f800000,2 +np.float32,0x7e1785c7,0x7f800000,2 +np.float32,0x807408c4,0x3f800000,2 +np.float32,0xbf300192,0x3f1ef485,2 +np.float32,0x351e3d,0x3f800000,2 +np.float32,0x7f5ab736,0x7f800000,2 +np.float32,0x2f1696,0x3f800000,2 +np.float32,0x806ac5d7,0x3f800000,2 +np.float32,0x42ec59,0x3f800000,2 +np.float32,0x7f79f52d,0x7f800000,2 +np.float32,0x44ad28,0x3f800000,2 +np.float32,0xbf49dc9c,0x3f143532,2 +np.float32,0x3f6c1f1f,0x3ff295e7,2 +np.float32,0x1589b3,0x3f800000,2 +np.float32,0x3f49b44e,0x3fdd0031,2 +np.float32,0x7f5942c9,0x7f800000,2 +np.float32,0x3f2dab28,0x3fccd877,2 +np.float32,0xff7fffff,0x0,2 +np.float32,0x80578eb2,0x3f800000,2 +np.float32,0x3f39ba67,0x3fd3a50b,2 +np.float32,0x8020340d,0x3f800000,2 +np.float32,0xbf6025b2,0x3f0b8783,2 +np.float32,0x8015ccfe,0x3f800000,2 +np.float32,0x3f6b9762,0x3ff23cd0,2 +np.float32,0xfeeb0c86,0x0,2 +np.float32,0x802779bc,0x3f800000,2 +np.float32,0xbf32bf64,0x3f1dc796,2 +np.float32,0xbf577eb6,0x3f0ed631,2 +np.float32,0x0,0x3f800000,2 +np.float32,0xfe99de6c,0x0,2 +np.float32,0x7a4e53,0x3f800000,2 +np.float32,0x1a15d3,0x3f800000,2 +np.float32,0x8035fe16,0x3f800000,2 +np.float32,0x3e845784,0x3f991dab,2 +np.float32,0x43d688,0x3f800000,2 +np.float32,0xbd447cc0,0x3f77a0b7,2 +np.float32,0x3f83fa,0x3f800000,2 +np.float32,0x3f141df2,0x3fbf2719,2 +np.float32,0x805c586a,0x3f800000,2 +np.float32,0x14c47e,0x3f800000,2 +np.float32,0x3d3bed00,0x3f8422d4,2 +np.float32,0x7f6f4ecd,0x7f800000,2 +np.float32,0x3f0a5e5a,0x3fba2c5c,2 +np.float32,0x523ecf,0x3f800000,2 +np.float32,0xbef4a6e8,0x3f37d262,2 +np.float32,0xff54eb58,0x0,2 +np.float32,0xff3fc875,0x0,2 +np.float32,0x8067c392,0x3f800000,2 +np.float32,0xfedae910,0x0,2 +np.float32,0x80595979,0x3f800000,2 +np.float32,0x3ee87d1d,0x3faf5929,2 +np.float32,0x7f5bad33,0x7f800000,2 +np.float32,0xbf45b868,0x3f15e109,2 +np.float32,0x3ef2277d,0x3fb1a868,2 +np.float32,0x3ca5a950,0x3f81ce8c,2 +np.float32,0x3e70f4e6,0x3f96ad25,2 +np.float32,0xfe3515bc,0x0,2 +np.float32,0xfe4af088,0x0,2 +np.float32,0xff3c78b2,0x0,2 +np.float32,0x7f50f51a,0x7f800000,2 +np.float32,0x3e3a232a,0x3f913009,2 +np.float32,0x7dfec6ff,0x7f800000,2 +np.float32,0x3e1bbaec,0x3f8e3ad6,2 +np.float32,0xbd658fa0,0x3f763ee7,2 +np.float32,0xfe958684,0x0,2 +np.float32,0x503670,0x3f800000,2 +np.float32,0x3f800000,0x40000000,2 +np.float32,0x1bbec6,0x3f800000,2 +np.float32,0xbea7bb7c,0x3f4bff00,2 +np.float32,0xff3a24a2,0x0,2 +np.float32,0xbf416240,0x3f17a635,2 +np.float32,0xbf800000,0x3f000000,2 +np.float32,0xff0c965c,0x0,2 +np.float32,0x80000000,0x3f800000,2 +np.float32,0xbec2c69a,0x3f44a99e,2 +np.float32,0x5b68d4,0x3f800000,2 +np.float32,0xb9a93000,0x3f7ff158,2 +np.float32,0x3d5a0dd8,0x3f84cfbc,2 +np.float32,0xbeaf7a28,0x3f49de4e,2 +np.float32,0x3ee83555,0x3faf4820,2 +np.float32,0xfd320330,0x0,2 +np.float32,0xe1af2,0x3f800000,2 +np.float32,0x7cf28caf,0x7f800000,2 +np.float32,0x80781009,0x3f800000,2 +np.float32,0xbf1e0baf,0x3f26e04d,2 +np.float32,0x7edb05b1,0x7f800000,2 +np.float32,0x3de004,0x3f800000,2 +np.float32,0xff436af6,0x0,2 +np.float32,0x802a9408,0x3f800000,2 +np.float32,0x7ed82205,0x7f800000,2 +np.float32,0x3e3f8212,0x3f91b767,2 +np.float32,0x16a2b2,0x3f800000,2 +np.float32,0xff1e5af3,0x0,2 +np.float32,0xbf1c860c,0x3f2790b7,2 +np.float32,0x3f3bc5da,0x3fd4d1d6,2 +np.float32,0x7f5f7085,0x7f800000,2 +np.float32,0x7f68e409,0x7f800000,2 +np.float32,0x7f4b3388,0x7f800000,2 +np.float32,0x7ecaf440,0x7f800000,2 +np.float32,0x80078785,0x3f800000,2 +np.float32,0x3ebd800d,0x3fa56f45,2 +np.float32,0xbe39a140,0x3f61c58e,2 +np.float32,0x803b587e,0x3f800000,2 +np.float32,0xbeaaa418,0x3f4b31c4,2 +np.float32,0xff7e2b9f,0x0,2 +np.float32,0xff5180a3,0x0,2 +np.float32,0xbf291394,0x3f21f73c,2 +np.float32,0x7f7b9698,0x7f800000,2 +np.float32,0x4218da,0x3f800000,2 +np.float32,0x7f135262,0x7f800000,2 +np.float32,0x804c10e8,0x3f800000,2 +np.float32,0xbf1c2a54,0x3f27ba5a,2 +np.float32,0x7f41fd32,0x7f800000,2 +np.float32,0x3e5cc464,0x3f94a195,2 +np.float32,0xff7a2fa7,0x0,2 +np.float32,0x3e05dc30,0x3f8c23c9,2 +np.float32,0x7f206d99,0x7f800000,2 +np.float32,0xbe9ae520,0x3f4f9287,2 +np.float32,0xfe4f4d58,0x0,2 +np.float32,0xbf44db42,0x3f163ae3,2 +np.float32,0x3f65ac48,0x3fee6300,2 +np.float32,0x3ebfaf36,0x3fa5ecb0,2 +np.float32,0x3f466719,0x3fdb08b0,2 +np.float32,0x80000001,0x3f800000,2 +np.float32,0xff4b3c7b,0x0,2 +np.float32,0x3df44374,0x3f8b0819,2 +np.float32,0xfea4b540,0x0,2 +np.float32,0x7f358e3d,0x7f800000,2 +np.float32,0x801f5e63,0x3f800000,2 +np.float32,0x804ae77e,0x3f800000,2 +np.float32,0xdbb5,0x3f800000,2 +np.float32,0x7f0a7e3b,0x7f800000,2 +np.float32,0xbe4152e4,0x3f609953,2 +np.float32,0x4b9579,0x3f800000,2 +np.float32,0x3ece0bd4,0x3fa92ea5,2 +np.float32,0x7e499d9a,0x7f800000,2 +np.float32,0x80637d8a,0x3f800000,2 +np.float32,0x3e50a425,0x3f936a8b,2 +np.float32,0xbf0e8cb0,0x3f2e06dd,2 +np.float32,0x802763e2,0x3f800000,2 +np.float32,0xff73041b,0x0,2 +np.float32,0xfea466da,0x0,2 +np.float32,0x80064c73,0x3f800000,2 +np.float32,0xbef29222,0x3f385728,2 +np.float32,0x8029c215,0x3f800000,2 +np.float32,0xbd3994e0,0x3f7815d1,2 +np.float32,0xbe6ac9e4,0x3f5a61f3,2 +np.float32,0x804b58b0,0x3f800000,2 +np.float32,0xbdb83be0,0x3f70865c,2 +np.float32,0x7ee18da2,0x7f800000,2 +np.float32,0xfd4ca010,0x0,2 +np.float32,0x807c668b,0x3f800000,2 +np.float32,0xbd40ed90,0x3f77c6e9,2 +np.float32,0x7efc6881,0x7f800000,2 +np.float32,0xfe633bfc,0x0,2 +np.float32,0x803ce363,0x3f800000,2 +np.float32,0x7ecba81e,0x7f800000,2 +np.float32,0xfdcb2378,0x0,2 +np.float32,0xbebc5524,0x3f4662b2,2 +np.float32,0xfaa30000,0x0,2 +np.float32,0x805d451b,0x3f800000,2 +np.float32,0xbee85600,0x3f3ae996,2 +np.float32,0xfefb0a54,0x0,2 +np.float32,0xbdfc6690,0x3f6b0a08,2 +np.float32,0x58a57,0x3f800000,2 +np.float32,0x3b41b7,0x3f800000,2 +np.float32,0x7c99812d,0x7f800000,2 +np.float32,0xbd3ae740,0x3f78079d,2 +np.float32,0xbf4a48a7,0x3f1409dd,2 +np.float32,0xfdeaad58,0x0,2 +np.float32,0xbe9aa65a,0x3f4fa42c,2 +np.float32,0x3f79d78c,0x3ffbc458,2 +np.float32,0x805e7389,0x3f800000,2 +np.float32,0x7ebb3612,0x7f800000,2 +np.float32,0x2e27dc,0x3f800000,2 +np.float32,0x80726dec,0x3f800000,2 +np.float32,0xfe8fb738,0x0,2 +np.float32,0xff1ff3bd,0x0,2 +np.float32,0x7f5264a2,0x7f800000,2 +np.float32,0x3f5a6893,0x3fe739ca,2 +np.float32,0xbec4029c,0x3f44558d,2 +np.float32,0xbef65cfa,0x3f37657e,2 +np.float32,0x63aba1,0x3f800000,2 +np.float32,0xfbb6e200,0x0,2 +np.float32,0xbf3466fc,0x3f1d1307,2 +np.float32,0x3f258844,0x3fc861d7,2 +np.float32,0xbf5f29a7,0x3f0be6dc,2 +np.float32,0x802b51cd,0x3f800000,2 +np.float32,0xbe9094dc,0x3f527dae,2 +np.float32,0xfec2e68c,0x0,2 +np.float32,0x807b38bd,0x3f800000,2 +np.float32,0xbf594662,0x3f0e2663,2 +np.float32,0x7cbcf747,0x7f800000,2 +np.float32,0xbe4b88f0,0x3f5f0d47,2 +np.float32,0x3c53c4,0x3f800000,2 +np.float32,0xbe883562,0x3f54e3f7,2 +np.float32,0xbf1efaf0,0x3f267456,2 +np.float32,0x3e22cd3e,0x3f8ee98b,2 +np.float32,0x80434875,0x3f800000,2 +np.float32,0xbf000b44,0x3f34ff6e,2 +np.float32,0x7f311c3a,0x7f800000,2 +np.float32,0x802f7f3f,0x3f800000,2 +np.float32,0x805155fe,0x3f800000,2 +np.float32,0x7f5d7485,0x7f800000,2 +np.float32,0x80119197,0x3f800000,2 +np.float32,0x3f445b8b,0x3fd9d30d,2 +np.float32,0xbf638eb3,0x3f0a3f38,2 +np.float32,0x402410,0x3f800000,2 +np.float32,0xbc578a40,0x3f7dad1d,2 +np.float32,0xbeecbf8a,0x3f39cc9e,2 +np.float32,0x7f2935a4,0x7f800000,2 +np.float32,0x3f570fea,0x3fe523e2,2 +np.float32,0xbf06bffa,0x3f31bdb6,2 +np.float32,0xbf2afdfd,0x3f2120ba,2 +np.float32,0x7f76f7ab,0x7f800000,2 +np.float32,0xfee2d1e8,0x0,2 +np.float32,0x800b026d,0x3f800000,2 +np.float32,0xff0eda75,0x0,2 +np.float32,0x3d4c,0x3f800000,2 +np.float32,0xbed538a2,0x3f3fcffb,2 +np.float32,0x3f73f4f9,0x3ff7c979,2 +np.float32,0x2aa9fc,0x3f800000,2 +np.float32,0x806a45b3,0x3f800000,2 +np.float32,0xff770d35,0x0,2 +np.float32,0x7e999be3,0x7f800000,2 +np.float32,0x80741128,0x3f800000,2 +np.float32,0xff6aac34,0x0,2 +np.float32,0x470f74,0x3f800000,2 +np.float32,0xff423b7b,0x0,2 +np.float32,0x17dfdd,0x3f800000,2 +np.float32,0x7f029e12,0x7f800000,2 +np.float32,0x803fcb9d,0x3f800000,2 +np.float32,0x3f3dc3,0x3f800000,2 +np.float32,0x7f3a27bc,0x7f800000,2 +np.float32,0x3e473108,0x3f9279ec,2 +np.float32,0x7f4add5d,0x7f800000,2 +np.float32,0xfd9736e0,0x0,2 +np.float32,0x805f1df2,0x3f800000,2 +np.float32,0x6c49c1,0x3f800000,2 +np.float32,0x7ec733c7,0x7f800000,2 +np.float32,0x804c1abf,0x3f800000,2 +np.float32,0x3de2e887,0x3f8a37a5,2 +np.float32,0x3f51630a,0x3fe1a561,2 +np.float32,0x3de686a8,0x3f8a62ff,2 +np.float32,0xbedb3538,0x3f3e439c,2 +np.float32,0xbf3aa892,0x3f1a6f9e,2 +np.float32,0x7ee5fb32,0x7f800000,2 +np.float32,0x7e916c9b,0x7f800000,2 +np.float32,0x3f033f1c,0x3fb69e19,2 +np.float32,0x25324b,0x3f800000,2 +np.float32,0x3f348d1d,0x3fd0b2e2,2 +np.float32,0x3f5797e8,0x3fe57851,2 +np.float32,0xbf69c316,0x3f07f1a0,2 +np.float32,0xbe8b7fb0,0x3f53f1bf,2 +np.float32,0xbdbbc190,0x3f703d00,2 +np.float32,0xff6c4fc0,0x0,2 +np.float32,0x7f29fcbe,0x7f800000,2 +np.float32,0x3f678d19,0x3fef9a23,2 +np.float32,0x73d140,0x3f800000,2 +np.float32,0x3e25bdd2,0x3f8f326b,2 +np.float32,0xbeb775ec,0x3f47b2c6,2 +np.float32,0xff451c4d,0x0,2 +np.float32,0x8072c466,0x3f800000,2 +np.float32,0x3f65e836,0x3fee89b2,2 +np.float32,0x52ca7a,0x3f800000,2 +np.float32,0x62cfed,0x3f800000,2 +np.float32,0xbf583dd0,0x3f0e8c5c,2 +np.float32,0xbf683842,0x3f088342,2 +np.float32,0x3f1a7828,0x3fc2780c,2 +np.float32,0x800ea979,0x3f800000,2 +np.float32,0xbeb9133c,0x3f474328,2 +np.float32,0x3ef09fc7,0x3fb14a4b,2 +np.float32,0x7ebbcb75,0x7f800000,2 +np.float32,0xff316c0e,0x0,2 +np.float32,0x805b84e3,0x3f800000,2 +np.float32,0x3d6a55e0,0x3f852d8a,2 +np.float32,0x3e755788,0x3f971fd1,2 +np.float32,0x3ee7aacb,0x3faf2743,2 +np.float32,0x7f714039,0x7f800000,2 +np.float32,0xff70bad8,0x0,2 +np.float32,0xbe0b74c8,0x3f68f08c,2 +np.float32,0xbf6cb170,0x3f06de86,2 +np.float32,0x7ec1fbff,0x7f800000,2 +np.float32,0x8014b1f6,0x3f800000,2 +np.float32,0xfe8b45fe,0x0,2 +np.float32,0x6e2220,0x3f800000,2 +np.float32,0x3ed1777d,0x3fa9f7ab,2 +np.float32,0xff48e467,0x0,2 +np.float32,0xff76c5aa,0x0,2 +np.float32,0x3e9bd330,0x3f9e0fd7,2 +np.float32,0x3f17de4f,0x3fc11aae,2 +np.float32,0x7eeaa2fd,0x7f800000,2 +np.float32,0xbf572746,0x3f0ef806,2 +np.float32,0x7e235554,0x7f800000,2 +np.float32,0xfe24fc1c,0x0,2 +np.float32,0x7daf71ad,0x7f800000,2 +np.float32,0x800d4a6b,0x3f800000,2 +np.float32,0xbf6fc31d,0x3f05c0ce,2 +np.float32,0x1c4d93,0x3f800000,2 +np.float32,0x7ee9200c,0x7f800000,2 +np.float32,0x3f54b4da,0x3fe3aeec,2 +np.float32,0x2b37b1,0x3f800000,2 +np.float32,0x3f7468bd,0x3ff81731,2 +np.float32,0x3f2850ea,0x3fc9e5f4,2 +np.float32,0xbe0d47ac,0x3f68a6f9,2 +np.float32,0x314877,0x3f800000,2 +np.float32,0x802700c3,0x3f800000,2 +np.float32,0x7e2c915f,0x7f800000,2 +np.float32,0x800d0059,0x3f800000,2 +np.float32,0x3f7f3c25,0x3fff7862,2 +np.float32,0xff735d31,0x0,2 +np.float32,0xff7e339e,0x0,2 +np.float32,0xbef96cf0,0x3f36a340,2 +np.float32,0x3db6ea21,0x3f882cb2,2 +np.float32,0x67cb3d,0x3f800000,2 +np.float32,0x801f349d,0x3f800000,2 +np.float32,0x3f1390ec,0x3fbede29,2 +np.float32,0x7f13644a,0x7f800000,2 +np.float32,0x804a369b,0x3f800000,2 +np.float32,0x80262666,0x3f800000,2 +np.float32,0x7e850fbc,0x7f800000,2 +np.float32,0x18b002,0x3f800000,2 +np.float32,0x8051f1ed,0x3f800000,2 +np.float32,0x3eba48f6,0x3fa4b753,2 +np.float32,0xbf3f4130,0x3f1886a9,2 +np.float32,0xbedac006,0x3f3e61cf,2 +np.float32,0xbf097c70,0x3f306ddc,2 +np.float32,0x4aba6d,0x3f800000,2 +np.float32,0x580078,0x3f800000,2 +np.float32,0x3f64d82e,0x3fedda40,2 +np.float32,0x7f781fd6,0x7f800000,2 +np.float32,0x6aff3d,0x3f800000,2 +np.float32,0xff25e074,0x0,2 +np.float32,0x7ea9ec89,0x7f800000,2 +np.float32,0xbf63b816,0x3f0a2fbb,2 +np.float32,0x133f07,0x3f800000,2 +np.float32,0xff800000,0x0,2 +np.float32,0x8013dde7,0x3f800000,2 +np.float32,0xff770b95,0x0,2 +np.float32,0x806154e8,0x3f800000,2 +np.float32,0x3f1e7bce,0x3fc4981a,2 +np.float32,0xff262c78,0x0,2 +np.float32,0x3f59a652,0x3fe6c04c,2 +np.float32,0x7f220166,0x7f800000,2 +np.float32,0x7eb24939,0x7f800000,2 +np.float32,0xbed58bb0,0x3f3fba6a,2 +np.float32,0x3c2ad000,0x3f80eda7,2 +np.float32,0x2adb2e,0x3f800000,2 +np.float32,0xfe8b213e,0x0,2 +np.float32,0xbf2e0c1e,0x3f1fccea,2 +np.float32,0x7e1716be,0x7f800000,2 +np.float32,0x80184e73,0x3f800000,2 +np.float32,0xbf254743,0x3f23a3d5,2 +np.float32,0x8063a722,0x3f800000,2 +np.float32,0xbe50adf0,0x3f5e46c7,2 +np.float32,0x3f614158,0x3feb8d60,2 +np.float32,0x8014bbc8,0x3f800000,2 +np.float32,0x283bc7,0x3f800000,2 +np.float32,0x3ffb5c,0x3f800000,2 +np.float32,0xfe8de6bc,0x0,2 +np.float32,0xbea6e086,0x3f4c3b82,2 +np.float32,0xfee64b92,0x0,2 +np.float32,0x506c1a,0x3f800000,2 +np.float32,0xff342af8,0x0,2 +np.float32,0x6b6f4c,0x3f800000,2 +np.float32,0xfeb42b1e,0x0,2 +np.float32,0x3e49384a,0x3f92ad71,2 +np.float32,0x152d08,0x3f800000,2 +np.float32,0x804c8f09,0x3f800000,2 +np.float32,0xff5e927d,0x0,2 +np.float32,0x6374da,0x3f800000,2 +np.float32,0x3f48f011,0x3fdc8ae4,2 +np.float32,0xbf446a30,0x3f1668e8,2 +np.float32,0x3ee77073,0x3faf196e,2 +np.float32,0xff4caa40,0x0,2 +np.float32,0x7efc9363,0x7f800000,2 +np.float32,0xbf706dcc,0x3f05830d,2 +np.float32,0xfe29c7e8,0x0,2 +np.float32,0x803cfe58,0x3f800000,2 +np.float32,0x3ec34c7c,0x3fa6bd0a,2 +np.float32,0x3eb85b62,0x3fa44968,2 +np.float32,0xfda1b9d8,0x0,2 +np.float32,0x802932cd,0x3f800000,2 +np.float32,0xbf5cde78,0x3f0cc5fa,2 +np.float32,0x3f31bf44,0x3fcf1ec8,2 +np.float32,0x803a0882,0x3f800000,2 +np.float32,0x800000,0x3f800000,2 +np.float32,0x3f54110e,0x3fe34a08,2 +np.float32,0x80645ea9,0x3f800000,2 +np.float32,0xbd8c1070,0x3f7425c3,2 +np.float32,0x801a006a,0x3f800000,2 +np.float32,0x7f5d161e,0x7f800000,2 +np.float32,0x805b5df3,0x3f800000,2 +np.float32,0xbf71a7c0,0x3f0511be,2 +np.float32,0xbe9a55c0,0x3f4fbad6,2 +np.float64,0xde7e2fd9bcfc6,0x3ff0000000000000,1 +np.float64,0xbfd8cd88eb319b12,0x3fe876349efbfa2b,1 +np.float64,0x3fe4fa13ace9f428,0x3ff933fbb117d196,1 +np.float64,0x475b3d048eb68,0x3ff0000000000000,1 +np.float64,0x7fef39ed07be73d9,0x7ff0000000000000,1 +np.float64,0x80026b84d904d70a,0x3ff0000000000000,1 +np.float64,0xebd60627d7ac1,0x3ff0000000000000,1 +np.float64,0xbfd7cbefdbaf97e0,0x3fe8bad30f6cf8e1,1 +np.float64,0x7fc17c605a22f8c0,0x7ff0000000000000,1 +np.float64,0x8cdac05119b58,0x3ff0000000000000,1 +np.float64,0x3fc45cd60a28b9ac,0x3ff1dd8028ec3f41,1 +np.float64,0x7fef4fce137e9f9b,0x7ff0000000000000,1 +np.float64,0xe5a2b819cb457,0x3ff0000000000000,1 +np.float64,0xe3bcfd4dc77a0,0x3ff0000000000000,1 +np.float64,0x68f0b670d1e17,0x3ff0000000000000,1 +np.float64,0xae69a6455cd35,0x3ff0000000000000,1 +np.float64,0xffe7007a0c6e00f4,0x0,1 +np.float64,0x59fc57a8b3f8c,0x3ff0000000000000,1 +np.float64,0xbfeee429c0bdc854,0x3fe0638fa62bed9f,1 +np.float64,0x80030bb6e206176f,0x3ff0000000000000,1 +np.float64,0x8006967a36ad2cf5,0x3ff0000000000000,1 +np.float64,0x3fe128176a22502f,0x3ff73393301e5dc8,1 +np.float64,0x218de20c431bd,0x3ff0000000000000,1 +np.float64,0x3fe7dbc48aafb789,0x3ffad38989b5955c,1 +np.float64,0xffda1ef411343de8,0x0,1 +np.float64,0xc6b392838d673,0x3ff0000000000000,1 +np.float64,0x7fe6d080c1ada101,0x7ff0000000000000,1 +np.float64,0xbfed36dd67fa6dbb,0x3fe0fec342c4ee89,1 +np.float64,0x3fee2bb6a3fc576e,0x3ffec1c149f1f092,1 +np.float64,0xbfd1f785eb23ef0c,0x3fea576eb01233cb,1 +np.float64,0x7fdad29a1f35a533,0x7ff0000000000000,1 +np.float64,0xffe8928c4fb12518,0x0,1 +np.float64,0x7fb123160022462b,0x7ff0000000000000,1 +np.float64,0x8007ab56cfaf56ae,0x3ff0000000000000,1 +np.float64,0x7fda342d6634685a,0x7ff0000000000000,1 +np.float64,0xbfe3b7e42c676fc8,0x3fe4e05cf8685b8a,1 +np.float64,0xffa708be7c2e1180,0x0,1 +np.float64,0xbfe8ffbece31ff7e,0x3fe29eb84077a34a,1 +np.float64,0xbf91002008220040,0x3fefa245058f05cb,1 +np.float64,0x8000281f0ee0503f,0x3ff0000000000000,1 +np.float64,0x8005617adc2ac2f6,0x3ff0000000000000,1 +np.float64,0x7fa84fec60309fd8,0x7ff0000000000000,1 +np.float64,0x8d00c0231a018,0x3ff0000000000000,1 +np.float64,0xbfdfe52ca63fca5a,0x3fe6a7324cc00d57,1 +np.float64,0x7fcc81073d39020d,0x7ff0000000000000,1 +np.float64,0x800134ff5a6269ff,0x3ff0000000000000,1 +np.float64,0xffc7fff98d2ffff4,0x0,1 +np.float64,0x8000925ce50124bb,0x3ff0000000000000,1 +np.float64,0xffe2530c66a4a618,0x0,1 +np.float64,0x7fc99070673320e0,0x7ff0000000000000,1 +np.float64,0xbfddd5c1f13bab84,0x3fe72a0c80f8df39,1 +np.float64,0x3fe1c220fee38442,0x3ff7817ec66aa55b,1 +np.float64,0x3fb9a1e1043343c2,0x3ff1265e575e6404,1 +np.float64,0xffef72e0833ee5c0,0x0,1 +np.float64,0x3fe710c0416e2181,0x3ffa5e93588aaa69,1 +np.float64,0xbfd8d23cbab1a47a,0x3fe874f5b9d99885,1 +np.float64,0x7fe9628ebd72c51c,0x7ff0000000000000,1 +np.float64,0xdd5fa611babf5,0x3ff0000000000000,1 +np.float64,0x8002bafac86575f6,0x3ff0000000000000,1 +np.float64,0x68acea44d159e,0x3ff0000000000000,1 +np.float64,0xffd776695eaeecd2,0x0,1 +np.float64,0x80059b59bb4b36b4,0x3ff0000000000000,1 +np.float64,0xbdcdd2af7b9bb,0x3ff0000000000000,1 +np.float64,0x8002b432ee856867,0x3ff0000000000000,1 +np.float64,0xcbc72f09978e6,0x3ff0000000000000,1 +np.float64,0xbfee8f4bf6fd1e98,0x3fe081cc0318b170,1 +np.float64,0xffc6e2892d2dc514,0x0,1 +np.float64,0x7feb682e4db6d05c,0x7ff0000000000000,1 +np.float64,0x8004b70a04296e15,0x3ff0000000000000,1 +np.float64,0x42408a4284812,0x3ff0000000000000,1 +np.float64,0xbfe9b8b197f37163,0x3fe254b4c003ce0a,1 +np.float64,0x3fcaadf5f5355bec,0x3ff27ca7876a8d20,1 +np.float64,0xfff0000000000000,0x0,1 +np.float64,0x7fea8376d33506ed,0x7ff0000000000000,1 +np.float64,0xffef73c2d63ee785,0x0,1 +np.float64,0xffe68b2bae2d1657,0x0,1 +np.float64,0x3fd8339cb2306739,0x3ff4cb774d616f90,1 +np.float64,0xbfc6d1db4d2da3b8,0x3fec47bb873a309c,1 +np.float64,0x7fe858016230b002,0x7ff0000000000000,1 +np.float64,0x7fe74cb99d2e9972,0x7ff0000000000000,1 +np.float64,0xffec2e96dc385d2d,0x0,1 +np.float64,0xb762a9876ec55,0x3ff0000000000000,1 +np.float64,0x3feca230c5794462,0x3ffdbfe62a572f52,1 +np.float64,0xbfb5ebad3a2bd758,0x3fee27eed86dcc39,1 +np.float64,0x471c705a8e38f,0x3ff0000000000000,1 +np.float64,0x7fc79bb5cf2f376b,0x7ff0000000000000,1 +np.float64,0xbfe53d6164ea7ac3,0x3fe4331b3beb73bd,1 +np.float64,0xbfe375a3f766eb48,0x3fe4fe67edb516e6,1 +np.float64,0x3fe1c7686ca38ed1,0x3ff7842f04770ba9,1 +np.float64,0x242e74dc485cf,0x3ff0000000000000,1 +np.float64,0x8009c06ab71380d6,0x3ff0000000000000,1 +np.float64,0x3fd08505efa10a0c,0x3ff3227b735b956d,1 +np.float64,0xffe3dfcecda7bf9d,0x0,1 +np.float64,0x8001f079bbc3e0f4,0x3ff0000000000000,1 +np.float64,0x3fddc706b6bb8e0c,0x3ff616d927987363,1 +np.float64,0xbfd151373ea2a26e,0x3fea870ba53ec126,1 +np.float64,0x7fe89533bfb12a66,0x7ff0000000000000,1 +np.float64,0xffed302cbc3a6059,0x0,1 +np.float64,0x3fd871cc28b0e398,0x3ff4d97d58c16ae2,1 +np.float64,0x7fbe9239683d2472,0x7ff0000000000000,1 +np.float64,0x848a445909149,0x3ff0000000000000,1 +np.float64,0x8007b104ce2f620a,0x3ff0000000000000,1 +np.float64,0x7fc2cd6259259ac4,0x7ff0000000000000,1 +np.float64,0xbfeadb640df5b6c8,0x3fe1e2b068de10af,1 +np.float64,0x800033b2f1a06767,0x3ff0000000000000,1 +np.float64,0x7fe54e5b7caa9cb6,0x7ff0000000000000,1 +np.float64,0x4f928f209f26,0x3ff0000000000000,1 +np.float64,0x8003c3dc6f2787ba,0x3ff0000000000000,1 +np.float64,0xbfd55a59daaab4b4,0x3fe9649d57b32b5d,1 +np.float64,0xffe3e2968d67c52c,0x0,1 +np.float64,0x80087434d550e86a,0x3ff0000000000000,1 +np.float64,0xffdde800083bd000,0x0,1 +np.float64,0xffe291f0542523e0,0x0,1 +np.float64,0xbfe1419bc3e28338,0x3fe6051d4f95a34a,1 +np.float64,0x3fd9d00ee1b3a01e,0x3ff5292bb8d5f753,1 +np.float64,0x3fdb720b60b6e417,0x3ff589d133625374,1 +np.float64,0xbfe3e21f0967c43e,0x3fe4cd4d02e3ef9a,1 +np.float64,0x7fd7e27f3dafc4fd,0x7ff0000000000000,1 +np.float64,0x3fd1cc2620a3984c,0x3ff366befbc38e3e,1 +np.float64,0x3fe78d05436f1a0b,0x3ffaa5ee4ea54b79,1 +np.float64,0x7e2acc84fc55a,0x3ff0000000000000,1 +np.float64,0x800ffb861c5ff70c,0x3ff0000000000000,1 +np.float64,0xffb2b0db1a2561b8,0x0,1 +np.float64,0xbfe80c2363701847,0x3fe301fdfe789576,1 +np.float64,0x7fe383c1c3e70783,0x7ff0000000000000,1 +np.float64,0xbfeefc02e6fdf806,0x3fe05b1a8528bf6c,1 +np.float64,0xbfe42c9268285925,0x3fe4abdc14793cb8,1 +np.float64,0x1,0x3ff0000000000000,1 +np.float64,0xa71c7ce94e390,0x3ff0000000000000,1 +np.float64,0x800ed4e6777da9cd,0x3ff0000000000000,1 +np.float64,0x3fde11b35d3c2367,0x3ff628bdc6dd1b78,1 +np.float64,0x3fef3964dbfe72ca,0x3fff777cae357608,1 +np.float64,0x3fefe369b7ffc6d4,0x3fffec357be508a3,1 +np.float64,0xbfdef1855f3de30a,0x3fe6e348c58e3fed,1 +np.float64,0x3fee0e2bc13c1c58,0x3ffeae1909c1b973,1 +np.float64,0xbfd31554ffa62aaa,0x3fea06628b2f048a,1 +np.float64,0x800dc56bcc7b8ad8,0x3ff0000000000000,1 +np.float64,0x7fbba01b8e374036,0x7ff0000000000000,1 +np.float64,0x7fd9737a92b2e6f4,0x7ff0000000000000,1 +np.float64,0x3feeae0fac3d5c1f,0x3fff1913705f1f07,1 +np.float64,0x3fdcc64fcdb98ca0,0x3ff5d9c3e5862972,1 +np.float64,0x3fdad9f83db5b3f0,0x3ff56674e81c1bd1,1 +np.float64,0x32b8797065710,0x3ff0000000000000,1 +np.float64,0x3fd20deae6241bd6,0x3ff37495bc057394,1 +np.float64,0x7fc899f0763133e0,0x7ff0000000000000,1 +np.float64,0x80045805fc08b00d,0x3ff0000000000000,1 +np.float64,0xbfcd8304cb3b0608,0x3feb4611f1eaa30c,1 +np.float64,0x3fd632a2fcac6544,0x3ff4592e1ea14fb0,1 +np.float64,0xffeeb066007d60cb,0x0,1 +np.float64,0x800bb12a42b76255,0x3ff0000000000000,1 +np.float64,0xbfe060fe1760c1fc,0x3fe6714640ab2574,1 +np.float64,0x80067ed737acfdaf,0x3ff0000000000000,1 +np.float64,0x3fd5ec3211abd864,0x3ff449adea82e73e,1 +np.float64,0x7fc4b2fdc22965fb,0x7ff0000000000000,1 +np.float64,0xff656afd002ad600,0x0,1 +np.float64,0xffeadefcdcb5bdf9,0x0,1 +np.float64,0x80052f18610a5e32,0x3ff0000000000000,1 +np.float64,0xbfd5b75c78ab6eb8,0x3fe94b15e0f39194,1 +np.float64,0xa4d3de2b49a7c,0x3ff0000000000000,1 +np.float64,0xbfe321c93de64392,0x3fe524ac7bbee401,1 +np.float64,0x3feb32f5def665ec,0x3ffcd6e4e5f9c271,1 +np.float64,0x7fe6b07e4ced60fc,0x7ff0000000000000,1 +np.float64,0x3fe013bb2de02776,0x3ff6aa4c32ab5ba4,1 +np.float64,0xbfeadd81d375bb04,0x3fe1e1de89b4aebf,1 +np.float64,0xffece7678079cece,0x0,1 +np.float64,0x3fe3d87b8467b0f8,0x3ff897cf22505e4d,1 +np.float64,0xffc4e3a05129c740,0x0,1 +np.float64,0xbfddee6b03bbdcd6,0x3fe723dd83ab49bd,1 +np.float64,0x3fcc4e2672389c4d,0x3ff2a680db769116,1 +np.float64,0x3fd8ed221ab1da44,0x3ff4f569aec8b850,1 +np.float64,0x80000a3538a0146b,0x3ff0000000000000,1 +np.float64,0x8004832eb109065e,0x3ff0000000000000,1 +np.float64,0xffdca83c60395078,0x0,1 +np.float64,0xffef551cda3eaa39,0x0,1 +np.float64,0x800fd95dd65fb2bc,0x3ff0000000000000,1 +np.float64,0x3ff0000000000000,0x4000000000000000,1 +np.float64,0xbfc06f5c4f20deb8,0x3fed466c17305ad8,1 +np.float64,0xbfeb01b5f476036c,0x3fe1d3de0f4211f4,1 +np.float64,0xbfdb2b9284365726,0x3fe7d7b02f790b05,1 +np.float64,0xff76ba83202d7500,0x0,1 +np.float64,0x3fd3f1c59ea7e38c,0x3ff3db96b3a0aaad,1 +np.float64,0x8b99ff6d17340,0x3ff0000000000000,1 +np.float64,0xbfeb383aa0f67075,0x3fe1bedcf2531c08,1 +np.float64,0x3fe321e35fa643c7,0x3ff83749a5d686ee,1 +np.float64,0xbfd863eb2130c7d6,0x3fe8923fcc39bac7,1 +np.float64,0x9e71dd333ce3c,0x3ff0000000000000,1 +np.float64,0x9542962b2a853,0x3ff0000000000000,1 +np.float64,0xba2c963b74593,0x3ff0000000000000,1 +np.float64,0x80019f4d0ca33e9b,0x3ff0000000000000,1 +np.float64,0xffde3e39a73c7c74,0x0,1 +np.float64,0x800258ae02c4b15d,0x3ff0000000000000,1 +np.float64,0xbfd99a535a3334a6,0x3fe8402f3a0662a5,1 +np.float64,0xe6c62143cd8c4,0x3ff0000000000000,1 +np.float64,0x7fbcc828f0399051,0x7ff0000000000000,1 +np.float64,0xbfe42e3596285c6b,0x3fe4ab2066d66071,1 +np.float64,0xffe2ee42d365dc85,0x0,1 +np.float64,0x3fe1f98abea3f315,0x3ff79dc68002a80b,1 +np.float64,0x7fd7225891ae44b0,0x7ff0000000000000,1 +np.float64,0x477177408ee30,0x3ff0000000000000,1 +np.float64,0xbfe16a7e2162d4fc,0x3fe5f1a5c745385d,1 +np.float64,0xbf98aaee283155e0,0x3fef785952e9c089,1 +np.float64,0x7fd7c14a8daf8294,0x7ff0000000000000,1 +np.float64,0xf7e7713defcee,0x3ff0000000000000,1 +np.float64,0x800769aa11aed355,0x3ff0000000000000,1 +np.float64,0xbfed30385e3a6071,0x3fe10135a3bd9ae6,1 +np.float64,0x3fe6dd7205edbae4,0x3ffa4155899efd70,1 +np.float64,0x800d705d26bae0ba,0x3ff0000000000000,1 +np.float64,0xa443ac1f48876,0x3ff0000000000000,1 +np.float64,0xbfec8cfec43919fe,0x3fe13dbf966e6633,1 +np.float64,0x7fd246efaa248dde,0x7ff0000000000000,1 +np.float64,0x800f2ad14afe55a3,0x3ff0000000000000,1 +np.float64,0x800487a894c90f52,0x3ff0000000000000,1 +np.float64,0x80014c4f19e2989f,0x3ff0000000000000,1 +np.float64,0x3fc11f265f223e4d,0x3ff18def05c971e5,1 +np.float64,0xffeb6d565776daac,0x0,1 +np.float64,0x7fd5ca5df8ab94bb,0x7ff0000000000000,1 +np.float64,0xbfe33de4fde67bca,0x3fe517d0e212cd1c,1 +np.float64,0xbfd1c738e5a38e72,0x3fea6539e9491693,1 +np.float64,0xbfec1d8c33b83b18,0x3fe16790fbca0c65,1 +np.float64,0xbfeecb464b7d968d,0x3fe06c67e2aefa55,1 +np.float64,0xbfd621dbf1ac43b8,0x3fe92dfa32d93846,1 +np.float64,0x80069a02860d3406,0x3ff0000000000000,1 +np.float64,0xbfe84f650e309eca,0x3fe2e661300f1975,1 +np.float64,0x7fc1d2cec523a59d,0x7ff0000000000000,1 +np.float64,0x3fd7706d79aee0db,0x3ff49fb033353dfe,1 +np.float64,0xffd94ba458329748,0x0,1 +np.float64,0x7fea98ba1a753173,0x7ff0000000000000,1 +np.float64,0xbfe756ba092ead74,0x3fe34d428d1857bc,1 +np.float64,0xffecfbd836b9f7b0,0x0,1 +np.float64,0x3fd211fbe5a423f8,0x3ff375711a3641e0,1 +np.float64,0x7fee24f7793c49ee,0x7ff0000000000000,1 +np.float64,0x7fe6a098886d4130,0x7ff0000000000000,1 +np.float64,0xbfd4ade909a95bd2,0x3fe99436524db1f4,1 +np.float64,0xbfeb704e6476e09d,0x3fe1a95be4a21bc6,1 +np.float64,0xffefc0f6627f81ec,0x0,1 +np.float64,0x7feff3f896ffe7f0,0x7ff0000000000000,1 +np.float64,0xa3f74edb47eea,0x3ff0000000000000,1 +np.float64,0xbfe0a551cf214aa4,0x3fe65027a7ff42e3,1 +np.float64,0x3fe164b23622c964,0x3ff7521c6225f51d,1 +np.float64,0x7fc258752324b0e9,0x7ff0000000000000,1 +np.float64,0x4739b3348e737,0x3ff0000000000000,1 +np.float64,0xb0392b1d60726,0x3ff0000000000000,1 +np.float64,0x7fe26f42e5e4de85,0x7ff0000000000000,1 +np.float64,0x8004601f87e8c040,0x3ff0000000000000,1 +np.float64,0xffe92ce37b3259c6,0x0,1 +np.float64,0x3fe620da3a6c41b4,0x3ff9d6ee3d005466,1 +np.float64,0x3fd850cfa2b0a1a0,0x3ff4d20bd249d411,1 +np.float64,0xffdcdfdfb5b9bfc0,0x0,1 +np.float64,0x800390297d672054,0x3ff0000000000000,1 +np.float64,0x3fde5864f6bcb0ca,0x3ff639bb9321f5ef,1 +np.float64,0x3fee484cec7c909a,0x3ffed4d2c6274219,1 +np.float64,0x7fe9b9a064b37340,0x7ff0000000000000,1 +np.float64,0xffe50028b8aa0051,0x0,1 +np.float64,0x3fe37774ade6eee9,0x3ff864558498a9a8,1 +np.float64,0x7fef83c724bf078d,0x7ff0000000000000,1 +np.float64,0xbfeb58450fb6b08a,0x3fe1b290556be73d,1 +np.float64,0x7fd7161475ae2c28,0x7ff0000000000000,1 +np.float64,0x3fece09621f9c12c,0x3ffde836a583bbdd,1 +np.float64,0x3fd045790ea08af2,0x3ff31554778fd4e2,1 +np.float64,0xbfe7c7dd6cef8fbb,0x3fe31e2eeda857fc,1 +np.float64,0xffe9632f5372c65e,0x0,1 +np.float64,0x800d4f3a703a9e75,0x3ff0000000000000,1 +np.float64,0xffea880e4df5101c,0x0,1 +np.float64,0xbfeb7edc4ff6fdb8,0x3fe1a3cb5dc33594,1 +np.float64,0xbfcaae4bab355c98,0x3febb1ee65e16b58,1 +np.float64,0xbfde598a19bcb314,0x3fe709145eafaaf8,1 +np.float64,0x3feefb6d78fdf6db,0x3fff4d5c8c68e39a,1 +np.float64,0x13efc75427dfa,0x3ff0000000000000,1 +np.float64,0xffe26f65c064decb,0x0,1 +np.float64,0xbfed5c1addfab836,0x3fe0f1133bd2189a,1 +np.float64,0x7fe7a7cf756f4f9e,0x7ff0000000000000,1 +np.float64,0xffc681702e2d02e0,0x0,1 +np.float64,0x8003d6ab5067ad57,0x3ff0000000000000,1 +np.float64,0xffa695f1342d2be0,0x0,1 +np.float64,0xbfcf8857db3f10b0,0x3feafa14da8c29a4,1 +np.float64,0xbfe8ca06be71940e,0x3fe2b46f6d2c64b4,1 +np.float64,0x3451c74468a3a,0x3ff0000000000000,1 +np.float64,0x3fde47d5f6bc8fac,0x3ff635bf8e024716,1 +np.float64,0xffda159d5db42b3a,0x0,1 +np.float64,0x7fef9fecaa3f3fd8,0x7ff0000000000000,1 +np.float64,0x3fd4e745e3a9ce8c,0x3ff410a9cb6fd8bf,1 +np.float64,0xffef57019b3eae02,0x0,1 +np.float64,0xbfe6604f4f6cc09e,0x3fe3b55de43c626d,1 +np.float64,0xffe066a424a0cd48,0x0,1 +np.float64,0x3fd547de85aa8fbc,0x3ff425b2a7a16675,1 +np.float64,0xffb3c69280278d28,0x0,1 +np.float64,0xffebe0b759f7c16e,0x0,1 +np.float64,0x3fefc84106ff9082,0x3fffd973687337d8,1 +np.float64,0x501c42a4a0389,0x3ff0000000000000,1 +np.float64,0x7feb45d13eb68ba1,0x7ff0000000000000,1 +np.float64,0xbfb16a8c2e22d518,0x3fee86a9c0f9291a,1 +np.float64,0x3be327b877c66,0x3ff0000000000000,1 +np.float64,0x7fe4a58220694b03,0x7ff0000000000000,1 +np.float64,0x3fe0286220a050c4,0x3ff6b472157ab8f2,1 +np.float64,0x3fc9381825327030,0x3ff2575fbea2bf5d,1 +np.float64,0xbfd1af7ee8a35efe,0x3fea6c032cf7e669,1 +np.float64,0xbfea9b0f39b5361e,0x3fe1fbae14b40b4d,1 +np.float64,0x39efe4aa73dfd,0x3ff0000000000000,1 +np.float64,0xffeb06fdc8360dfb,0x0,1 +np.float64,0xbfda481e72b4903c,0x3fe812b4b08d4884,1 +np.float64,0xbfd414ba5ba82974,0x3fe9bec9474bdfe6,1 +np.float64,0x7fe707177b6e0e2e,0x7ff0000000000000,1 +np.float64,0x8000000000000001,0x3ff0000000000000,1 +np.float64,0xbfede6a75bbbcd4f,0x3fe0be874cccd399,1 +np.float64,0x8006cdb577cd9b6c,0x3ff0000000000000,1 +np.float64,0x800051374f20a26f,0x3ff0000000000000,1 +np.float64,0x3fe5cba8c96b9752,0x3ff9a76b3adcc122,1 +np.float64,0xbfee3933487c7267,0x3fe0a0b190f9609a,1 +np.float64,0x3fd574b8d8aae970,0x3ff42f7e83de1af9,1 +np.float64,0xba5db72b74bb7,0x3ff0000000000000,1 +np.float64,0x3fa9bf512c337ea0,0x3ff0914a7f743a94,1 +np.float64,0xffe8cb736c3196e6,0x0,1 +np.float64,0x3761b2f06ec37,0x3ff0000000000000,1 +np.float64,0x8b4d4433169a9,0x3ff0000000000000,1 +np.float64,0x800f0245503e048b,0x3ff0000000000000,1 +np.float64,0x7fb20d54ac241aa8,0x7ff0000000000000,1 +np.float64,0x3fdf26666b3e4ccd,0x3ff66b8995142017,1 +np.float64,0xbfcbf2a83737e550,0x3feb8173a7b9d6b5,1 +np.float64,0x3fd31572a0a62ae5,0x3ff3ac6c94313dcd,1 +np.float64,0x7fb6c2807a2d8500,0x7ff0000000000000,1 +np.float64,0x800799758f2f32ec,0x3ff0000000000000,1 +np.float64,0xe72f1f6bce5e4,0x3ff0000000000000,1 +np.float64,0x3fe0e0f223a1c1e4,0x3ff70fed5b761673,1 +np.float64,0x3fe6d4f133eda9e2,0x3ffa3c8000c169eb,1 +np.float64,0xbfe1ccc3d8639988,0x3fe5c32148bedbda,1 +np.float64,0x3fea71c53574e38a,0x3ffc5f31201fe9be,1 +np.float64,0x9e0323eb3c065,0x3ff0000000000000,1 +np.float64,0x8005cc79a5cb98f4,0x3ff0000000000000,1 +np.float64,0x1dace1f83b59d,0x3ff0000000000000,1 +np.float64,0x10000000000000,0x3ff0000000000000,1 +np.float64,0xbfdef50830bdea10,0x3fe6e269fc17ebef,1 +np.float64,0x8010000000000000,0x3ff0000000000000,1 +np.float64,0xbfdfa82192bf5044,0x3fe6b6313ee0a095,1 +np.float64,0x3fd9398fe2b27320,0x3ff506ca2093c060,1 +np.float64,0x8002721fe664e441,0x3ff0000000000000,1 +np.float64,0x800c04166ad8082d,0x3ff0000000000000,1 +np.float64,0xffec3918b3387230,0x0,1 +np.float64,0x3fec62d5dfb8c5ac,0x3ffd972ea4a54b32,1 +np.float64,0x3fe7e42a0b6fc854,0x3ffad86b0443181d,1 +np.float64,0x3fc0aff5f3215fec,0x3ff1836058d4d210,1 +np.float64,0xbf82ff68a025fec0,0x3fefcb7f06862dce,1 +np.float64,0xae2e35195c5c7,0x3ff0000000000000,1 +np.float64,0x3fece3bddf79c77c,0x3ffdea41fb1ba8fa,1 +np.float64,0xbfa97b947832f730,0x3feeea34ebedbbd2,1 +np.float64,0xbfdfb1b1ce3f6364,0x3fe6b3d72871335c,1 +np.float64,0xbfe61a4f24ac349e,0x3fe3d356bf991b06,1 +np.float64,0x7fe23117a5e4622e,0x7ff0000000000000,1 +np.float64,0x800552a8cccaa552,0x3ff0000000000000,1 +np.float64,0x625b4d0ac4b6a,0x3ff0000000000000,1 +np.float64,0x3f86cf15702d9e00,0x3ff01fbe0381676d,1 +np.float64,0x800d7d1b685afa37,0x3ff0000000000000,1 +np.float64,0x3fe2cb6e40a596dd,0x3ff80a1a562f7fc9,1 +np.float64,0x3fe756eb8e2eadd7,0x3ffa86c638aad07d,1 +np.float64,0x800dc9a5513b934b,0x3ff0000000000000,1 +np.float64,0xbfbbdd118a37ba20,0x3fedacb4624f3cee,1 +np.float64,0x800de01f8efbc03f,0x3ff0000000000000,1 +np.float64,0x800da1a3fe9b4348,0x3ff0000000000000,1 +np.float64,0xbf87d8c7602fb180,0x3fefbe2614998ab6,1 +np.float64,0xbfdfff6141bffec2,0x3fe6a0c54d9f1bc8,1 +np.float64,0xee8fbba5dd1f8,0x3ff0000000000000,1 +np.float64,0x3fe79dc93e6f3b92,0x3ffaaf9d7d955b2c,1 +np.float64,0xffedd4b3d07ba967,0x0,1 +np.float64,0x800905dfc1720bc0,0x3ff0000000000000,1 +np.float64,0x3fd9e483b8b3c907,0x3ff52ddc6c950e7f,1 +np.float64,0xe34ffefdc6a00,0x3ff0000000000000,1 +np.float64,0x2168e62242d1e,0x3ff0000000000000,1 +np.float64,0x800349950e26932b,0x3ff0000000000000,1 +np.float64,0x7fc50da8532a1b50,0x7ff0000000000000,1 +np.float64,0xae1a4d115c34a,0x3ff0000000000000,1 +np.float64,0xa020f0b74041e,0x3ff0000000000000,1 +np.float64,0x3fd2aa2f77a5545f,0x3ff3959f09519a25,1 +np.float64,0x3fbfefc3223fdf86,0x3ff171f3df2d408b,1 +np.float64,0xbfea9fc340b53f86,0x3fe1f9d92b712654,1 +np.float64,0xffe9b920a5337240,0x0,1 +np.float64,0xbfe2eb0265e5d605,0x3fe53dd195782de3,1 +np.float64,0x7fb932c70e32658d,0x7ff0000000000000,1 +np.float64,0x3fda816bfcb502d8,0x3ff551f8d5c84c82,1 +np.float64,0x3fed68cbe9fad198,0x3ffe40f6692d5693,1 +np.float64,0x32df077665be2,0x3ff0000000000000,1 +np.float64,0x7fdc9c2f3539385d,0x7ff0000000000000,1 +np.float64,0x7fe71091a2ee2122,0x7ff0000000000000,1 +np.float64,0xbfe68106c46d020e,0x3fe3a76b56024c2c,1 +np.float64,0xffcf0572823e0ae4,0x0,1 +np.float64,0xbfeeab341fbd5668,0x3fe077d496941cda,1 +np.float64,0x7fe7ada0d2af5b41,0x7ff0000000000000,1 +np.float64,0xffacdef2a439bde0,0x0,1 +np.float64,0x3fe4200f3128401e,0x3ff8be0ddf30fd1e,1 +np.float64,0xffd9022a69320454,0x0,1 +np.float64,0xbfe8e06914f1c0d2,0x3fe2ab5fe7fffb5a,1 +np.float64,0x3fc4b976602972ed,0x3ff1e6786fa7a890,1 +np.float64,0xbfd784c105af0982,0x3fe8cdeb1cdbd57e,1 +np.float64,0x7feb20a20eb64143,0x7ff0000000000000,1 +np.float64,0xbfc87dd83630fbb0,0x3fec067c1e7e6983,1 +np.float64,0x7fe5400cbe6a8018,0x7ff0000000000000,1 +np.float64,0xbfb4a1f5e22943e8,0x3fee42e6c81559a9,1 +np.float64,0x3fe967c575f2cf8a,0x3ffbbd8bc0d5c50d,1 +np.float64,0xbfeb059cf4760b3a,0x3fe1d25c592c4dab,1 +np.float64,0xbfeef536d5bdea6e,0x3fe05d832c15c64a,1 +np.float64,0x3fa90b3f6432167f,0x3ff08d410dd732cc,1 +np.float64,0xbfeaff265e75fe4d,0x3fe1d4db3fb3208d,1 +np.float64,0x6d93d688db27b,0x3ff0000000000000,1 +np.float64,0x800ab9b4ea55736a,0x3ff0000000000000,1 +np.float64,0x3fd444b39d288967,0x3ff3ed749d48d444,1 +np.float64,0xbfd5f2c0d0abe582,0x3fe93ad6124d88e7,1 +np.float64,0x3fea8fd915f51fb2,0x3ffc71b32cb92d60,1 +np.float64,0xbfd23d6491a47aca,0x3fea43875709b0f0,1 +np.float64,0xffe76f75ce6edeeb,0x0,1 +np.float64,0x1f5670da3eacf,0x3ff0000000000000,1 +np.float64,0x8000d89c9621b13a,0x3ff0000000000000,1 +np.float64,0x3fedb51c52bb6a39,0x3ffe732279c228ff,1 +np.float64,0x7f99215ac83242b5,0x7ff0000000000000,1 +np.float64,0x742a6864e854e,0x3ff0000000000000,1 +np.float64,0xbfe02fb340205f66,0x3fe689495f9164e3,1 +np.float64,0x7fef4c12b0fe9824,0x7ff0000000000000,1 +np.float64,0x3fd40e17c2a81c30,0x3ff3e1aee8ed972f,1 +np.float64,0x7fdcd264e939a4c9,0x7ff0000000000000,1 +np.float64,0x3fdb675838b6ceb0,0x3ff587526241c550,1 +np.float64,0x3fdf1a4081be3480,0x3ff66896a18c2385,1 +np.float64,0xbfea5082b874a106,0x3fe218cf8f11be13,1 +np.float64,0xffe1a0ebf7e341d8,0x0,1 +np.float64,0x3fed0a2222ba1444,0x3ffe032ce928ae7d,1 +np.float64,0xffeae036da75c06d,0x0,1 +np.float64,0x5b05fc8ab60c0,0x3ff0000000000000,1 +np.float64,0x7fd8aae5f03155cb,0x7ff0000000000000,1 +np.float64,0xbfd0b4d9fda169b4,0x3feab41e58b6ccb7,1 +np.float64,0xffdcaffa57395ff4,0x0,1 +np.float64,0xbfcbf1455437e28c,0x3feb81a884182c5d,1 +np.float64,0x3f9d6700b83ace01,0x3ff0525657db35d4,1 +np.float64,0x4fd5b0b29fab7,0x3ff0000000000000,1 +np.float64,0x3fe9af2df5b35e5c,0x3ffbe895684df916,1 +np.float64,0x800dfd41f9dbfa84,0x3ff0000000000000,1 +np.float64,0xbf2a30457e546,0x3ff0000000000000,1 +np.float64,0x7fc6be37182d7c6d,0x7ff0000000000000,1 +np.float64,0x800e0f9788dc1f2f,0x3ff0000000000000,1 +np.float64,0x8006890c704d121a,0x3ff0000000000000,1 +np.float64,0xffecb1a7cbb9634f,0x0,1 +np.float64,0xffb35c330426b868,0x0,1 +np.float64,0x7fe8f2ba8a71e574,0x7ff0000000000000,1 +np.float64,0xf3ccff8fe79a0,0x3ff0000000000000,1 +np.float64,0x3fdf19a84e3e3351,0x3ff66871b17474c1,1 +np.float64,0x80049a662d0934cd,0x3ff0000000000000,1 +np.float64,0xdf5bb4bbbeb77,0x3ff0000000000000,1 +np.float64,0x8005eca030cbd941,0x3ff0000000000000,1 +np.float64,0xffe5f239586be472,0x0,1 +np.float64,0xbfc4526a0728a4d4,0x3fecaa52fbf5345e,1 +np.float64,0xbfe8f1ecda31e3da,0x3fe2a44c080848b3,1 +np.float64,0x3feebd32f4bd7a66,0x3fff234788938c3e,1 +np.float64,0xffd6ca04e9ad940a,0x0,1 +np.float64,0x7ff0000000000000,0x7ff0000000000000,1 +np.float64,0xbfd4c560a9a98ac2,0x3fe98db6d97442fc,1 +np.float64,0x8005723471cae46a,0x3ff0000000000000,1 +np.float64,0xbfeb278299764f05,0x3fe1c54b48f8ba4b,1 +np.float64,0x8007907b376f20f7,0x3ff0000000000000,1 +np.float64,0x7fe9c2fd01b385f9,0x7ff0000000000000,1 +np.float64,0x7fdaa37368b546e6,0x7ff0000000000000,1 +np.float64,0xbfe6d0f3786da1e7,0x3fe38582271cada7,1 +np.float64,0xbfea9b77823536ef,0x3fe1fb8575cd1b7d,1 +np.float64,0xbfe90ac38bf21587,0x3fe29a471b47a2e8,1 +np.float64,0xbfe9c51844738a30,0x3fe24fc8de03ea84,1 +np.float64,0x3fe45a9013a8b520,0x3ff8dd7c80f1cf75,1 +np.float64,0xbfe5780551eaf00a,0x3fe419832a6a4c56,1 +np.float64,0xffefffffffffffff,0x0,1 +np.float64,0x7fe3778c84a6ef18,0x7ff0000000000000,1 +np.float64,0xbfdc8a60413914c0,0x3fe77dc55b85028f,1 +np.float64,0xef47ae2fde8f6,0x3ff0000000000000,1 +np.float64,0x8001269fa4c24d40,0x3ff0000000000000,1 +np.float64,0x3fe9d2d39e73a5a7,0x3ffbfe2a66c4148e,1 +np.float64,0xffee61f528fcc3e9,0x0,1 +np.float64,0x3fe8a259ab7144b3,0x3ffb47e797a34bd2,1 +np.float64,0x3f906d610820dac0,0x3ff02dccda8e1a75,1 +np.float64,0x3fe70739f32e0e74,0x3ffa59232f4fcd07,1 +np.float64,0x3fe6b7f5e6ad6fec,0x3ffa2c0cc54f2c16,1 +np.float64,0x95a91a792b524,0x3ff0000000000000,1 +np.float64,0xbfedf6fcf57bedfa,0x3fe0b89bb40081cc,1 +np.float64,0xbfa4d2de9c29a5c0,0x3fef1c485678d657,1 +np.float64,0x3fe130470d22608e,0x3ff737b0be409a38,1 +np.float64,0x3fcf8035423f006b,0x3ff2f9d7c3c6a302,1 +np.float64,0xffe5995a3eab32b4,0x0,1 +np.float64,0xffca68c63034d18c,0x0,1 +np.float64,0xff9d53af903aa760,0x0,1 +np.float64,0x800563f1de6ac7e4,0x3ff0000000000000,1 +np.float64,0x7fce284fa63c509e,0x7ff0000000000000,1 +np.float64,0x7fb2a3959a25472a,0x7ff0000000000000,1 +np.float64,0x7fdbe2652f37c4c9,0x7ff0000000000000,1 +np.float64,0x800d705bbc1ae0b8,0x3ff0000000000000,1 +np.float64,0x7fd9bd2347b37a46,0x7ff0000000000000,1 +np.float64,0x3fcac3c0fb358782,0x3ff27ed62d6c8221,1 +np.float64,0x800110691ec220d3,0x3ff0000000000000,1 +np.float64,0x3fef79a8157ef350,0x3fffa368513eb909,1 +np.float64,0x7fe8bd2f0e317a5d,0x7ff0000000000000,1 +np.float64,0x7fd3040e60a6081c,0x7ff0000000000000,1 +np.float64,0xffea50723234a0e4,0x0,1 +np.float64,0xbfe6220054ac4400,0x3fe3d00961238a93,1 +np.float64,0x3f9eddd8c83dbbc0,0x3ff0567b0c73005a,1 +np.float64,0xbfa4a062c42940c0,0x3fef1e68badde324,1 +np.float64,0xbfd077ad4720ef5a,0x3feac5d577581d07,1 +np.float64,0x7fdfd4b025bfa95f,0x7ff0000000000000,1 +np.float64,0xd00d3cf3a01a8,0x3ff0000000000000,1 +np.float64,0x7fe3010427260207,0x7ff0000000000000,1 +np.float64,0x22ea196645d44,0x3ff0000000000000,1 +np.float64,0x7fd747e8cd2e8fd1,0x7ff0000000000000,1 +np.float64,0xd50665e7aa0cd,0x3ff0000000000000,1 +np.float64,0x7fe1da580ae3b4af,0x7ff0000000000000,1 +np.float64,0xffeb218ecfb6431d,0x0,1 +np.float64,0xbf887d0dd030fa00,0x3fefbc6252c8b354,1 +np.float64,0x3fcaa31067354621,0x3ff27b904c07e07f,1 +np.float64,0x7fe698cc4ded3198,0x7ff0000000000000,1 +np.float64,0x1c40191a38804,0x3ff0000000000000,1 +np.float64,0x80086fd20e30dfa4,0x3ff0000000000000,1 +np.float64,0x7fed34d5eaba69ab,0x7ff0000000000000,1 +np.float64,0xffd00b52622016a4,0x0,1 +np.float64,0x3f80abcdb021579b,0x3ff0172d27945851,1 +np.float64,0x3fe614cfd66c29a0,0x3ff9d031e1839191,1 +np.float64,0x80021d71c8843ae4,0x3ff0000000000000,1 +np.float64,0x800bc2adc657855c,0x3ff0000000000000,1 +np.float64,0x6b9fec1cd73fe,0x3ff0000000000000,1 +np.float64,0xffd9093b5f321276,0x0,1 +np.float64,0x800d3c6c77fa78d9,0x3ff0000000000000,1 +np.float64,0xffe80fc1cbf01f83,0x0,1 +np.float64,0xffbffbaf2a3ff760,0x0,1 +np.float64,0x3fea1ed29eb43da5,0x3ffc2c64ec0e17a3,1 +np.float64,0x7ff4000000000000,0x7ffc000000000000,1 +np.float64,0x3fd944a052328941,0x3ff5094f4c43ecca,1 +np.float64,0x800b1f9416163f29,0x3ff0000000000000,1 +np.float64,0x800f06bf33de0d7e,0x3ff0000000000000,1 +np.float64,0xbfdbf0d226b7e1a4,0x3fe7a4f73793d95b,1 +np.float64,0xffe7306c30ae60d8,0x0,1 +np.float64,0x7fe991accfb32359,0x7ff0000000000000,1 +np.float64,0x3fcc0040d2380082,0x3ff29ea47e4f07d4,1 +np.float64,0x7fefffffffffffff,0x7ff0000000000000,1 +np.float64,0x0,0x3ff0000000000000,1 +np.float64,0x3fe1423f7be2847e,0x3ff740bc1d3b20f8,1 +np.float64,0xbfeae3a3cab5c748,0x3fe1df7e936f8504,1 +np.float64,0x800b2da7d6165b50,0x3ff0000000000000,1 +np.float64,0x800b2404fcd6480a,0x3ff0000000000000,1 +np.float64,0x6fcbcf88df97b,0x3ff0000000000000,1 +np.float64,0xa248c0e14492,0x3ff0000000000000,1 +np.float64,0xffd255776824aaee,0x0,1 +np.float64,0x80057b3effeaf67f,0x3ff0000000000000,1 +np.float64,0x3feb0b07d7761610,0x3ffcbdfe1be5a594,1 +np.float64,0x924e1019249c2,0x3ff0000000000000,1 +np.float64,0x80074307e80e8611,0x3ff0000000000000,1 +np.float64,0xffb207fa46240ff8,0x0,1 +np.float64,0x95ac388d2b587,0x3ff0000000000000,1 +np.float64,0xbff0000000000000,0x3fe0000000000000,1 +np.float64,0x3fd38b6a492716d5,0x3ff3c59f62b5add5,1 +np.float64,0x7fe49362c3e926c5,0x7ff0000000000000,1 +np.float64,0x7fe842889db08510,0x7ff0000000000000,1 +np.float64,0xbfba6003e834c008,0x3fedcb620a2d9856,1 +np.float64,0xffe7e782bd6fcf05,0x0,1 +np.float64,0x7fd9b93d9433727a,0x7ff0000000000000,1 +np.float64,0x7fc8fcb61d31f96b,0x7ff0000000000000,1 +np.float64,0xbfef9be8db3f37d2,0x3fe022d603b81dc2,1 +np.float64,0x6f4fc766de9fa,0x3ff0000000000000,1 +np.float64,0xbfe93016f132602e,0x3fe28b42d782d949,1 +np.float64,0x3fe10e52b8e21ca5,0x3ff726a38b0bb895,1 +np.float64,0x3fbbba0ae6377416,0x3ff13f56084a9da3,1 +np.float64,0x3fe09e42ece13c86,0x3ff6eeb57e775e24,1 +np.float64,0x800942e39fb285c8,0x3ff0000000000000,1 +np.float64,0xffe5964370eb2c86,0x0,1 +np.float64,0x3fde479f32bc8f3e,0x3ff635b2619ba53a,1 +np.float64,0x3fe826e187f04dc3,0x3ffaff52b79c3a08,1 +np.float64,0x3febcbf1eab797e4,0x3ffd37152e5e2598,1 +np.float64,0x3fa0816a202102d4,0x3ff05c8e6a8b00d5,1 +np.float64,0xbd005ccb7a00c,0x3ff0000000000000,1 +np.float64,0x44c12fdc89827,0x3ff0000000000000,1 +np.float64,0xffc8fdffa431fc00,0x0,1 +np.float64,0xffeb4f5a87b69eb4,0x0,1 +np.float64,0xbfb07e7f8420fd00,0x3fee9a32924fe6a0,1 +np.float64,0xbfbd9d1bb63b3a38,0x3fed88ca81e5771c,1 +np.float64,0x8008682a74f0d055,0x3ff0000000000000,1 +np.float64,0x3fdeedbc7b3ddb79,0x3ff65dcb7c55f4dc,1 +np.float64,0x8009e889c613d114,0x3ff0000000000000,1 +np.float64,0x3faea831f43d5064,0x3ff0ad935e890e49,1 +np.float64,0xf0af1703e15e3,0x3ff0000000000000,1 +np.float64,0xffec06c4a5f80d88,0x0,1 +np.float64,0x53a1cc0ca743a,0x3ff0000000000000,1 +np.float64,0x7fd10c9eea22193d,0x7ff0000000000000,1 +np.float64,0xbfd48a6bf0a914d8,0x3fe99e0d109f2bac,1 +np.float64,0x3fd6dfe931adbfd4,0x3ff47f81c2dfc5d3,1 +np.float64,0x3fed20e86b7a41d0,0x3ffe11fecc7bc686,1 +np.float64,0xbfea586818b4b0d0,0x3fe215b7747d5cb8,1 +np.float64,0xbfd4ad3e20295a7c,0x3fe99465ab8c3275,1 +np.float64,0x3fd6619ee4acc33e,0x3ff4638b7b80c08a,1 +np.float64,0x3fdf6fcb63bedf97,0x3ff67d62fd3d560c,1 +np.float64,0x800a9191e7152324,0x3ff0000000000000,1 +np.float64,0x3fd2ff3c0da5fe78,0x3ff3a7b17e892a28,1 +np.float64,0x8003dbf1f327b7e5,0x3ff0000000000000,1 +np.float64,0xffea6b89a934d712,0x0,1 +np.float64,0x7fcfb879043f70f1,0x7ff0000000000000,1 +np.float64,0xea6a84dbd4d51,0x3ff0000000000000,1 +np.float64,0x800ec97a815d92f5,0x3ff0000000000000,1 +np.float64,0xffe304c3a8660987,0x0,1 +np.float64,0xbfefe24dd3ffc49c,0x3fe00a4e065be96d,1 +np.float64,0xffd3cc8c00a79918,0x0,1 +np.float64,0x95be8b7b2b7d2,0x3ff0000000000000,1 +np.float64,0x7fe20570cba40ae1,0x7ff0000000000000,1 +np.float64,0x7f97a06da02f40da,0x7ff0000000000000,1 +np.float64,0xffe702b9522e0572,0x0,1 +np.float64,0x3fada2d8543b45b1,0x3ff0a7adc4201e08,1 +np.float64,0x235e6acc46bce,0x3ff0000000000000,1 +np.float64,0x3fea6bc28ef4d786,0x3ffc5b7fc68fddac,1 +np.float64,0xffdbc9f505b793ea,0x0,1 +np.float64,0xffe98b137ff31626,0x0,1 +np.float64,0x800e26c6721c4d8d,0x3ff0000000000000,1 +np.float64,0x80080de445301bc9,0x3ff0000000000000,1 +np.float64,0x37e504a86fca1,0x3ff0000000000000,1 +np.float64,0x8002f5f60325ebed,0x3ff0000000000000,1 +np.float64,0x5c8772feb90ef,0x3ff0000000000000,1 +np.float64,0xbfe021abb4604358,0x3fe69023a51d22b8,1 +np.float64,0x3fde744f8fbce8a0,0x3ff64074dc84edd7,1 +np.float64,0xbfdd92899f3b2514,0x3fe73aefd9701858,1 +np.float64,0x7fc1ad5c51235ab8,0x7ff0000000000000,1 +np.float64,0xaae2f98955c5f,0x3ff0000000000000,1 +np.float64,0x7f9123d5782247aa,0x7ff0000000000000,1 +np.float64,0xbfe3f8e94b67f1d2,0x3fe4c30ab28e9cb7,1 +np.float64,0x7fdaba8b4cb57516,0x7ff0000000000000,1 +np.float64,0x7fefc85cfeff90b9,0x7ff0000000000000,1 +np.float64,0xffb83b4f523076a0,0x0,1 +np.float64,0xbfe888a68c71114d,0x3fe2ceff17c203d1,1 +np.float64,0x800de1dac4bbc3b6,0x3ff0000000000000,1 +np.float64,0xbfe4f27f09e9e4fe,0x3fe453f9af407eac,1 +np.float64,0xffe3d2713467a4e2,0x0,1 +np.float64,0xbfebaab840375570,0x3fe1931131b98842,1 +np.float64,0x93892a1b27126,0x3ff0000000000000,1 +np.float64,0x1e8e7f983d1d1,0x3ff0000000000000,1 +np.float64,0x3fecc950627992a0,0x3ffdd926f036add0,1 +np.float64,0xbfd41dfb1aa83bf6,0x3fe9bc34ece35b94,1 +np.float64,0x800aebfc6555d7f9,0x3ff0000000000000,1 +np.float64,0x7fe33ba52ca67749,0x7ff0000000000000,1 +np.float64,0xffe57c9b3feaf936,0x0,1 +np.float64,0x3fdd12464fba248c,0x3ff5ebc5598e6bd0,1 +np.float64,0xffe06d7f0fe0dafe,0x0,1 +np.float64,0x800e55b7fe9cab70,0x3ff0000000000000,1 +np.float64,0x3fd33803c8267008,0x3ff3b3cb78b2d642,1 +np.float64,0xe9cab8a1d3957,0x3ff0000000000000,1 +np.float64,0x3fb38ac166271580,0x3ff0de906947c0f0,1 +np.float64,0xbfd67aa552acf54a,0x3fe915cf64a389fd,1 +np.float64,0x1db96daa3b72f,0x3ff0000000000000,1 +np.float64,0xbfee9f08f4fd3e12,0x3fe07c2c615add3c,1 +np.float64,0xf14f6d65e29ee,0x3ff0000000000000,1 +np.float64,0x800bce089e179c12,0x3ff0000000000000,1 +np.float64,0xffc42dcc37285b98,0x0,1 +np.float64,0x7fd5f37063abe6e0,0x7ff0000000000000,1 +np.float64,0xbfd943c2cbb28786,0x3fe856f6452ec753,1 +np.float64,0x8ddfbc091bbf8,0x3ff0000000000000,1 +np.float64,0xbfe153491e22a692,0x3fe5fcb075dbbd5d,1 +np.float64,0xffe7933999ef2672,0x0,1 +np.float64,0x7ff8000000000000,0x7ff8000000000000,1 +np.float64,0x8000000000000000,0x3ff0000000000000,1 +np.float64,0xbfe9154580b22a8b,0x3fe2960bac3a8220,1 +np.float64,0x800dc6dda21b8dbb,0x3ff0000000000000,1 +np.float64,0xbfb26225a824c448,0x3fee7239a457df81,1 +np.float64,0xbfd7b68c83af6d1a,0x3fe8c08e351ab468,1 +np.float64,0xffde01f7213c03ee,0x0,1 +np.float64,0x3fe54cbe0faa997c,0x3ff9614527191d72,1 +np.float64,0xbfd6bec3732d7d86,0x3fe90354909493de,1 +np.float64,0xbfef3c85bd7e790b,0x3fe0444f8c489ca6,1 +np.float64,0x899501b7132a0,0x3ff0000000000000,1 +np.float64,0xbfe17a456462f48b,0x3fe5ea2719a9a84b,1 +np.float64,0xffe34003b8668007,0x0,1 +np.float64,0x7feff6a3633fed46,0x7ff0000000000000,1 +np.float64,0x3fba597ecc34b2fe,0x3ff12ee72e4de474,1 +np.float64,0x4084c7b68109a,0x3ff0000000000000,1 +np.float64,0x3fad23bf4c3a4780,0x3ff0a4d06193ff6d,1 +np.float64,0xffd0fe2707a1fc4e,0x0,1 +np.float64,0xb96cb43f72d97,0x3ff0000000000000,1 +np.float64,0x7fc4d684d829ad09,0x7ff0000000000000,1 +np.float64,0x7fdc349226b86923,0x7ff0000000000000,1 +np.float64,0x7fd82851cd3050a3,0x7ff0000000000000,1 +np.float64,0x800cde0041b9bc01,0x3ff0000000000000,1 +np.float64,0x4e8caa1e9d196,0x3ff0000000000000,1 +np.float64,0xbfed06a6d2fa0d4e,0x3fe1108c3682b05a,1 +np.float64,0xffe8908122312102,0x0,1 +np.float64,0xffe56ed6d9aaddad,0x0,1 +np.float64,0x3fedd6db00fbadb6,0x3ffe896c68c4b26e,1 +np.float64,0x3fde31f9b4bc63f4,0x3ff6307e08f8b6ba,1 +np.float64,0x6bb963c2d772d,0x3ff0000000000000,1 +np.float64,0x787b7142f0f6f,0x3ff0000000000000,1 +np.float64,0x3fe6e4147c6dc829,0x3ffa451bbdece240,1 +np.float64,0x8003857401470ae9,0x3ff0000000000000,1 +np.float64,0xbfeae82c3c75d058,0x3fe1ddbd66e65aab,1 +np.float64,0x7fe174707c62e8e0,0x7ff0000000000000,1 +np.float64,0x80008d2545e11a4b,0x3ff0000000000000,1 +np.float64,0xbfecc2dce17985ba,0x3fe129ad4325985a,1 +np.float64,0xbfe1fa1daf63f43c,0x3fe5adcb0731a44b,1 +np.float64,0x7fcf2530203e4a5f,0x7ff0000000000000,1 +np.float64,0xbfea5cefe874b9e0,0x3fe213f134b61f4a,1 +np.float64,0x800103729f2206e6,0x3ff0000000000000,1 +np.float64,0xbfe8442ff7708860,0x3fe2eaf850faa169,1 +np.float64,0x8006c78e19ed8f1d,0x3ff0000000000000,1 +np.float64,0x3fc259589c24b2b1,0x3ff1abe6a4d28816,1 +np.float64,0xffed02b7b5ba056e,0x0,1 +np.float64,0xbfce0aa4fe3c1548,0x3feb32115d92103e,1 +np.float64,0x7fec06e78bf80dce,0x7ff0000000000000,1 +np.float64,0xbfe0960bbc612c18,0x3fe6578ab29b70d4,1 +np.float64,0x3fee45841cbc8b08,0x3ffed2f6ca808ad3,1 +np.float64,0xbfeb0f8ebef61f1e,0x3fe1ce86003044cd,1 +np.float64,0x8002c357358586af,0x3ff0000000000000,1 +np.float64,0x3fe9aa10cc735422,0x3ffbe57e294ce68b,1 +np.float64,0x800256c0a544ad82,0x3ff0000000000000,1 +np.float64,0x4de6e1449bcdd,0x3ff0000000000000,1 +np.float64,0x65e9bc9ccbd38,0x3ff0000000000000,1 +np.float64,0xbfe53b0fa9aa7620,0x3fe4341f0aa29bbc,1 +np.float64,0xbfcdd94cd13bb298,0x3feb3956acd2e2dd,1 +np.float64,0x8004a49b65a94938,0x3ff0000000000000,1 +np.float64,0x800d3d05deba7a0c,0x3ff0000000000000,1 +np.float64,0x3fe4e05bce69c0b8,0x3ff925f55602a7e0,1 +np.float64,0xffe391e3256723c6,0x0,1 +np.float64,0xbfe92f0f37b25e1e,0x3fe28bacc76ae753,1 +np.float64,0x3f990238d8320472,0x3ff045edd36e2d62,1 +np.float64,0xffed8d15307b1a2a,0x0,1 +np.float64,0x3fee82e01afd05c0,0x3ffefc09e8b9c2b7,1 +np.float64,0xffb2d94b2225b298,0x0,1 diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/data/umath-validation-set-expm1.csv b/venv/lib/python3.12/site-packages/numpy/_core/tests/data/umath-validation-set-expm1.csv new file mode 100644 index 00000000..dcbc7cd9 --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/tests/data/umath-validation-set-expm1.csv @@ -0,0 +1,1429 @@ +dtype,input,output,ulperrortol +np.float32,0x80606724,0x80606724,3 +np.float32,0xbf16790f,0xbee38e14,3 +np.float32,0xbf1778a1,0xbee4a97f,3 +np.float32,0x7d4fc610,0x7f800000,3 +np.float32,0xbec30a20,0xbea230d5,3 +np.float32,0x3eae8a36,0x3ecffac5,3 +np.float32,0xbf1f08f1,0xbeece93c,3 +np.float32,0x80374376,0x80374376,3 +np.float32,0x3f2e04ca,0x3f793115,3 +np.float32,0x7e2c7e36,0x7f800000,3 +np.float32,0xbf686cae,0xbf18bcf0,3 +np.float32,0xbf5518cd,0xbf10a3da,3 +np.float32,0x807e233c,0x807e233c,3 +np.float32,0x7f4edd54,0x7f800000,3 +np.float32,0x7ed70088,0x7f800000,3 +np.float32,0x801675da,0x801675da,3 +np.float32,0x806735d5,0x806735d5,3 +np.float32,0xfe635fec,0xbf800000,3 +np.float32,0xfed88a0a,0xbf800000,3 +np.float32,0xff52c052,0xbf800000,3 +np.float32,0x7fc00000,0x7fc00000,3 +np.float32,0xff4f65f9,0xbf800000,3 +np.float32,0xfe0f6c20,0xbf800000,3 +np.float32,0x80322b30,0x80322b30,3 +np.float32,0xfb757000,0xbf800000,3 +np.float32,0x3c81e0,0x3c81e0,3 +np.float32,0x79d56a,0x79d56a,3 +np.float32,0x8029d7af,0x8029d7af,3 +np.float32,0x8058a593,0x8058a593,3 +np.float32,0x3f3a13c7,0x3f88c75c,3 +np.float32,0x2a6b05,0x2a6b05,3 +np.float32,0xbd64c960,0xbd5e83ae,3 +np.float32,0x80471052,0x80471052,3 +np.float32,0xbe5dd950,0xbe47766c,3 +np.float32,0xfd8f88f0,0xbf800000,3 +np.float32,0x75a4b7,0x75a4b7,3 +np.float32,0x3f726f2e,0x3fc9fb7d,3 +np.float32,0x3ed6795c,0x3f053115,3 +np.float32,0x17d7f5,0x17d7f5,3 +np.float32,0xbf4cf19b,0xbf0d094f,3 +np.float32,0x3e0ec532,0x3e1933c6,3 +np.float32,0xff084016,0xbf800000,3 +np.float32,0x800829aa,0x800829aa,3 +np.float32,0x806d7302,0x806d7302,3 +np.float32,0x7f59d9da,0x7f800000,3 +np.float32,0x15f8b9,0x15f8b9,3 +np.float32,0x803befb3,0x803befb3,3 +np.float32,0x525043,0x525043,3 +np.float32,0x51a647,0x51a647,3 +np.float32,0xbf1cfce4,0xbeeab3d9,3 +np.float32,0x3f1f27a4,0x3f5cb1d2,3 +np.float32,0xbebc3a04,0xbe9d8142,3 +np.float32,0xbeea548c,0xbebc07e5,3 +np.float32,0x3f47401c,0x3f96c2a3,3 +np.float32,0x806b1ea3,0x806b1ea3,3 +np.float32,0x3ea56bb8,0x3ec3450c,3 +np.float32,0x3f7b4963,0x3fd597b5,3 +np.float32,0x7f051fa0,0x7f800000,3 +np.float32,0x1d411c,0x1d411c,3 +np.float32,0xff0b6a35,0xbf800000,3 +np.float32,0xbead63c0,0xbe9314f7,3 +np.float32,0x3738be,0x3738be,3 +np.float32,0x3f138cc8,0x3f479155,3 +np.float32,0x800a539f,0x800a539f,3 +np.float32,0x801b0ebd,0x801b0ebd,3 +np.float32,0x318fcd,0x318fcd,3 +np.float32,0x3ed67556,0x3f052e06,3 +np.float32,0x702886,0x702886,3 +np.float32,0x80000001,0x80000001,3 +np.float32,0x70a174,0x70a174,3 +np.float32,0x4f9c66,0x4f9c66,3 +np.float32,0x3e3e1927,0x3e50e351,3 +np.float32,0x7eac9a4d,0x7f800000,3 +np.float32,0x4b7407,0x4b7407,3 +np.float32,0x7f5bd2fd,0x7f800000,3 +np.float32,0x3eaafc58,0x3ecaffbd,3 +np.float32,0xbc989360,0xbc9729e2,3 +np.float32,0x3f470e5c,0x3f968c7b,3 +np.float32,0x4c5672,0x4c5672,3 +np.float32,0xff2b2ee2,0xbf800000,3 +np.float32,0xbf28a104,0xbef7079b,3 +np.float32,0x2c6175,0x2c6175,3 +np.float32,0x3d7e4fb0,0x3d832f9f,3 +np.float32,0x763276,0x763276,3 +np.float32,0x3cf364,0x3cf364,3 +np.float32,0xbf7ace75,0xbf1fe48c,3 +np.float32,0xff19e858,0xbf800000,3 +np.float32,0x80504c70,0x80504c70,3 +np.float32,0xff390210,0xbf800000,3 +np.float32,0x8046a743,0x8046a743,3 +np.float32,0x80000000,0x80000000,3 +np.float32,0x806c51da,0x806c51da,3 +np.float32,0x806ab38f,0x806ab38f,3 +np.float32,0x3f3de863,0x3f8cc538,3 +np.float32,0x7f6d45bb,0x7f800000,3 +np.float32,0xfd16ec60,0xbf800000,3 +np.float32,0x80513cba,0x80513cba,3 +np.float32,0xbf68996b,0xbf18cefa,3 +np.float32,0xfe039f2c,0xbf800000,3 +np.float32,0x3f013207,0x3f280c55,3 +np.float32,0x7ef4bc07,0x7f800000,3 +np.float32,0xbe8b65ac,0xbe741069,3 +np.float32,0xbf7a8186,0xbf1fc7a6,3 +np.float32,0x802532e5,0x802532e5,3 +np.float32,0x32c7df,0x32c7df,3 +np.float32,0x3ce4dceb,0x3ce81701,3 +np.float32,0xfe801118,0xbf800000,3 +np.float32,0x3d905f20,0x3d9594fb,3 +np.float32,0xbe11ed28,0xbe080168,3 +np.float32,0x59e773,0x59e773,3 +np.float32,0x3e9a2547,0x3eb3dd57,3 +np.float32,0x7ecb7c67,0x7f800000,3 +np.float32,0x7f69a67e,0x7f800000,3 +np.float32,0xff121e11,0xbf800000,3 +np.float32,0x3f7917cb,0x3fd2ad8c,3 +np.float32,0xbf1a7da8,0xbee7fc0c,3 +np.float32,0x3f077e66,0x3f329c40,3 +np.float32,0x3ce8e040,0x3cec37b3,3 +np.float32,0xbf3f0b8e,0xbf069f4d,3 +np.float32,0x3f52f194,0x3fa3c9d6,3 +np.float32,0xbf0e7422,0xbeda80f2,3 +np.float32,0xfd67e230,0xbf800000,3 +np.float32,0xff14d9a9,0xbf800000,3 +np.float32,0x3f3546e3,0x3f83dc2b,3 +np.float32,0x3e152e3a,0x3e20983d,3 +np.float32,0x4a89a3,0x4a89a3,3 +np.float32,0x63217,0x63217,3 +np.float32,0xbeb9e2a8,0xbe9be153,3 +np.float32,0x7e9fa049,0x7f800000,3 +np.float32,0x7f58110c,0x7f800000,3 +np.float32,0x3e88290c,0x3e9bfba9,3 +np.float32,0xbf2cb206,0xbefb3494,3 +np.float32,0xff5880c4,0xbf800000,3 +np.float32,0x7ecff3ac,0x7f800000,3 +np.float32,0x3f4b3de6,0x3f9b23fd,3 +np.float32,0xbebd2048,0xbe9e208c,3 +np.float32,0xff08f7a2,0xbf800000,3 +np.float32,0xff473330,0xbf800000,3 +np.float32,0x1,0x1,3 +np.float32,0xbf5dc239,0xbf14584b,3 +np.float32,0x458e3f,0x458e3f,3 +np.float32,0xbdb8a650,0xbdb091f8,3 +np.float32,0xff336ffc,0xbf800000,3 +np.float32,0x3c60bd00,0x3c624966,3 +np.float32,0xbe16a4f8,0xbe0c1664,3 +np.float32,0x3f214246,0x3f60a0f0,3 +np.float32,0x7fa00000,0x7fe00000,3 +np.float32,0x7e08737e,0x7f800000,3 +np.float32,0x3f70574c,0x3fc74b8e,3 +np.float32,0xbed5745c,0xbeae8c77,3 +np.float32,0x361752,0x361752,3 +np.float32,0x3eb276d6,0x3ed584ea,3 +np.float32,0x3f03fc1e,0x3f2cb1a5,3 +np.float32,0x3fafd1,0x3fafd1,3 +np.float32,0x7e50d74c,0x7f800000,3 +np.float32,0x3eeca5,0x3eeca5,3 +np.float32,0x5dc963,0x5dc963,3 +np.float32,0x7f0e63ae,0x7f800000,3 +np.float32,0x8021745f,0x8021745f,3 +np.float32,0xbf5881a9,0xbf121d07,3 +np.float32,0x7dadc7fd,0x7f800000,3 +np.float32,0xbf2c0798,0xbefa86bb,3 +np.float32,0x3e635f50,0x3e7e97a9,3 +np.float32,0xbf2053fa,0xbeee4c0e,3 +np.float32,0x3e8eee2b,0x3ea4dfcc,3 +np.float32,0xfc8a03c0,0xbf800000,3 +np.float32,0xfd9e4948,0xbf800000,3 +np.float32,0x801e817e,0x801e817e,3 +np.float32,0xbf603a27,0xbf1560c3,3 +np.float32,0x7f729809,0x7f800000,3 +np.float32,0x3f5a1864,0x3fac0e04,3 +np.float32,0x3e7648b8,0x3e8b3677,3 +np.float32,0x3edade24,0x3f088bc1,3 +np.float32,0x65e16e,0x65e16e,3 +np.float32,0x3f24aa50,0x3f671117,3 +np.float32,0x803cb1d0,0x803cb1d0,3 +np.float32,0xbe7b1858,0xbe5eadcc,3 +np.float32,0xbf19bb27,0xbee726fb,3 +np.float32,0xfd1f6e60,0xbf800000,3 +np.float32,0xfeb0de60,0xbf800000,3 +np.float32,0xff511a52,0xbf800000,3 +np.float32,0xff7757f7,0xbf800000,3 +np.float32,0x463ff5,0x463ff5,3 +np.float32,0x3f770d12,0x3fcffcc2,3 +np.float32,0xbf208562,0xbeee80dc,3 +np.float32,0x6df204,0x6df204,3 +np.float32,0xbf62d24f,0xbf1673fb,3 +np.float32,0x3dfcf210,0x3e069d5f,3 +np.float32,0xbef26002,0xbec114d7,3 +np.float32,0x7f800000,0x7f800000,3 +np.float32,0x7f30fb85,0x7f800000,3 +np.float32,0x7ee5dfef,0x7f800000,3 +np.float32,0x3f317829,0x3f800611,3 +np.float32,0x3f4b0bbd,0x3f9aec88,3 +np.float32,0x7edf708c,0x7f800000,3 +np.float32,0xff071260,0xbf800000,3 +np.float32,0x3e7b8c30,0x3e8e9198,3 +np.float32,0x3f33778b,0x3f82077f,3 +np.float32,0x3e8cd11d,0x3ea215fd,3 +np.float32,0x8004483d,0x8004483d,3 +np.float32,0x801633e3,0x801633e3,3 +np.float32,0x7e76eb15,0x7f800000,3 +np.float32,0x3c1571,0x3c1571,3 +np.float32,0x7de3de52,0x7f800000,3 +np.float32,0x804ae906,0x804ae906,3 +np.float32,0x7f3a2616,0x7f800000,3 +np.float32,0xff7fffff,0xbf800000,3 +np.float32,0xff5d17e4,0xbf800000,3 +np.float32,0xbeaa6704,0xbe90f252,3 +np.float32,0x7e6a43af,0x7f800000,3 +np.float32,0x2a0f35,0x2a0f35,3 +np.float32,0xfd8fece0,0xbf800000,3 +np.float32,0xfeef2e2a,0xbf800000,3 +np.float32,0xff800000,0xbf800000,3 +np.float32,0xbeefcc52,0xbebf78e4,3 +np.float32,0x3db6c490,0x3dbf2bd5,3 +np.float32,0x8290f,0x8290f,3 +np.float32,0xbeace648,0xbe92bb7f,3 +np.float32,0x801fea79,0x801fea79,3 +np.float32,0x3ea6c230,0x3ec51ebf,3 +np.float32,0x3e5f2ca3,0x3e795c8a,3 +np.float32,0x3eb6f634,0x3edbeb9f,3 +np.float32,0xff790b45,0xbf800000,3 +np.float32,0x3d82e240,0x3d872816,3 +np.float32,0x3f0d6a57,0x3f3cc7db,3 +np.float32,0x7f08531a,0x7f800000,3 +np.float32,0x702b6d,0x702b6d,3 +np.float32,0x7d3a3c38,0x7f800000,3 +np.float32,0x3d0a7fb3,0x3d0cddf3,3 +np.float32,0xff28084c,0xbf800000,3 +np.float32,0xfeee8804,0xbf800000,3 +np.float32,0x804094eb,0x804094eb,3 +np.float32,0x7acb39,0x7acb39,3 +np.float32,0x3f01c07a,0x3f28f88c,3 +np.float32,0x3e05c500,0x3e0ee674,3 +np.float32,0xbe6f7c38,0xbe558ac1,3 +np.float32,0x803b1f4b,0x803b1f4b,3 +np.float32,0xbf76561f,0xbf1e332b,3 +np.float32,0xff30d368,0xbf800000,3 +np.float32,0x7e2e1f38,0x7f800000,3 +np.float32,0x3ee085b8,0x3f0ce7c0,3 +np.float32,0x8064c4a7,0x8064c4a7,3 +np.float32,0xa7c1d,0xa7c1d,3 +np.float32,0x3f27498a,0x3f6c14bc,3 +np.float32,0x137ca,0x137ca,3 +np.float32,0x3d0a5c60,0x3d0cb969,3 +np.float32,0x80765f1f,0x80765f1f,3 +np.float32,0x80230a71,0x80230a71,3 +np.float32,0x3f321ed2,0x3f80acf4,3 +np.float32,0x7d61e7f4,0x7f800000,3 +np.float32,0xbf39f7f2,0xbf0430f7,3 +np.float32,0xbe2503f8,0xbe1867e8,3 +np.float32,0x29333d,0x29333d,3 +np.float32,0x7edc5a0e,0x7f800000,3 +np.float32,0xbe81a8a2,0xbe651663,3 +np.float32,0x7f76ab6d,0x7f800000,3 +np.float32,0x7f46111f,0x7f800000,3 +np.float32,0xff0fc888,0xbf800000,3 +np.float32,0x805ece89,0x805ece89,3 +np.float32,0xc390b,0xc390b,3 +np.float32,0xff64bdee,0xbf800000,3 +np.float32,0x3dd07e4e,0x3ddb79bd,3 +np.float32,0xfecc1f10,0xbf800000,3 +np.float32,0x803f5177,0x803f5177,3 +np.float32,0x802a24d2,0x802a24d2,3 +np.float32,0x7f27d0cc,0x7f800000,3 +np.float32,0x3ef57c98,0x3f1d7e88,3 +np.float32,0x7b848d,0x7b848d,3 +np.float32,0x7f7fffff,0x7f800000,3 +np.float32,0xfe889c46,0xbf800000,3 +np.float32,0xff2d6dc5,0xbf800000,3 +np.float32,0x3f53a186,0x3fa492a6,3 +np.float32,0xbf239c94,0xbef1c90c,3 +np.float32,0xff7c0f4e,0xbf800000,3 +np.float32,0x3e7c69a9,0x3e8f1f3a,3 +np.float32,0xbf47c9e9,0xbf0ab2a9,3 +np.float32,0xbc1eaf00,0xbc1deae9,3 +np.float32,0x3f4a6d39,0x3f9a3d8e,3 +np.float32,0x3f677930,0x3fbc26eb,3 +np.float32,0x3f45eea1,0x3f955418,3 +np.float32,0x7f61a1f8,0x7f800000,3 +np.float32,0xff58c7c6,0xbf800000,3 +np.float32,0x80239801,0x80239801,3 +np.float32,0xff56e616,0xbf800000,3 +np.float32,0xff62052c,0xbf800000,3 +np.float32,0x8009b615,0x8009b615,3 +np.float32,0x293d6b,0x293d6b,3 +np.float32,0xfe9e585c,0xbf800000,3 +np.float32,0x7f58ff4b,0x7f800000,3 +np.float32,0x10937c,0x10937c,3 +np.float32,0x7f5cc13f,0x7f800000,3 +np.float32,0x110c5d,0x110c5d,3 +np.float32,0x805e51fc,0x805e51fc,3 +np.float32,0xbedcf70a,0xbeb3766c,3 +np.float32,0x3f4d5e42,0x3f9d8091,3 +np.float32,0xff5925a0,0xbf800000,3 +np.float32,0x7e87cafa,0x7f800000,3 +np.float32,0xbf6474b2,0xbf171fee,3 +np.float32,0x4b39b2,0x4b39b2,3 +np.float32,0x8020cc28,0x8020cc28,3 +np.float32,0xff004ed8,0xbf800000,3 +np.float32,0xbf204cf5,0xbeee448d,3 +np.float32,0x3e30cf10,0x3e40fdb1,3 +np.float32,0x80202bee,0x80202bee,3 +np.float32,0xbf55a985,0xbf10e2bc,3 +np.float32,0xbe297dd8,0xbe1c351c,3 +np.float32,0x5780d9,0x5780d9,3 +np.float32,0x7ef729fa,0x7f800000,3 +np.float32,0x8039a3b5,0x8039a3b5,3 +np.float32,0x7cdd3f,0x7cdd3f,3 +np.float32,0x7ef0145a,0x7f800000,3 +np.float32,0x807ad7ae,0x807ad7ae,3 +np.float32,0x7f6c2643,0x7f800000,3 +np.float32,0xbec56124,0xbea3c929,3 +np.float32,0x512c3b,0x512c3b,3 +np.float32,0xbed3effe,0xbead8c1e,3 +np.float32,0x7f5e0a4d,0x7f800000,3 +np.float32,0x3f315316,0x3f7fc200,3 +np.float32,0x7eca5727,0x7f800000,3 +np.float32,0x7f4834f3,0x7f800000,3 +np.float32,0x8004af6d,0x8004af6d,3 +np.float32,0x3f223ca4,0x3f6277e3,3 +np.float32,0x7eea4fdd,0x7f800000,3 +np.float32,0x3e7143e8,0x3e880763,3 +np.float32,0xbf737008,0xbf1d160e,3 +np.float32,0xfc408b00,0xbf800000,3 +np.float32,0x803912ca,0x803912ca,3 +np.float32,0x7db31f4e,0x7f800000,3 +np.float32,0xff578b54,0xbf800000,3 +np.float32,0x3f068ec4,0x3f31062b,3 +np.float32,0x35f64f,0x35f64f,3 +np.float32,0x80437df4,0x80437df4,3 +np.float32,0x568059,0x568059,3 +np.float32,0x8005f8ba,0x8005f8ba,3 +np.float32,0x6824ad,0x6824ad,3 +np.float32,0xff3fdf30,0xbf800000,3 +np.float32,0xbf6f7682,0xbf1b89d6,3 +np.float32,0x3dcea8a0,0x3dd971f5,3 +np.float32,0x3ee32a62,0x3f0ef5a9,3 +np.float32,0xbf735bcd,0xbf1d0e3d,3 +np.float32,0x7e8c7c28,0x7f800000,3 +np.float32,0x3ed552bc,0x3f045161,3 +np.float32,0xfed90a8a,0xbf800000,3 +np.float32,0xbe454368,0xbe336d2a,3 +np.float32,0xbf171d26,0xbee4442d,3 +np.float32,0x80652bf9,0x80652bf9,3 +np.float32,0xbdbaaa20,0xbdb26914,3 +np.float32,0x3f56063d,0x3fa7522e,3 +np.float32,0x3d3d4fd3,0x3d41c13f,3 +np.float32,0x80456040,0x80456040,3 +np.float32,0x3dc15586,0x3dcac0ef,3 +np.float32,0x7f753060,0x7f800000,3 +np.float32,0x7f7d8039,0x7f800000,3 +np.float32,0xfdebf280,0xbf800000,3 +np.float32,0xbf1892c3,0xbee5e116,3 +np.float32,0xbf0f1468,0xbedb3878,3 +np.float32,0x40d85c,0x40d85c,3 +np.float32,0x3f93dd,0x3f93dd,3 +np.float32,0xbf5730fd,0xbf118c24,3 +np.float32,0xfe17aa44,0xbf800000,3 +np.float32,0x3dc0baf4,0x3dca1716,3 +np.float32,0xbf3433d8,0xbf015efb,3 +np.float32,0x1c59f5,0x1c59f5,3 +np.float32,0x802b1540,0x802b1540,3 +np.float32,0xbe47df6c,0xbe35936e,3 +np.float32,0xbe8e7070,0xbe78af32,3 +np.float32,0xfe7057f4,0xbf800000,3 +np.float32,0x80668b69,0x80668b69,3 +np.float32,0xbe677810,0xbe4f2c2d,3 +np.float32,0xbe7a2f1c,0xbe5df733,3 +np.float32,0xfeb79e3c,0xbf800000,3 +np.float32,0xbeb6e320,0xbe99c9e8,3 +np.float32,0xfea188f2,0xbf800000,3 +np.float32,0x7dcaeb15,0x7f800000,3 +np.float32,0x1be567,0x1be567,3 +np.float32,0xbf4041cc,0xbf07320d,3 +np.float32,0x3f721aa7,0x3fc98e9a,3 +np.float32,0x7f5aa835,0x7f800000,3 +np.float32,0x15180e,0x15180e,3 +np.float32,0x3f73d739,0x3fcbccdb,3 +np.float32,0xbeecd380,0xbebd9b36,3 +np.float32,0x3f2caec7,0x3f768fea,3 +np.float32,0xbeaf65f2,0xbe9482bb,3 +np.float32,0xfe6aa384,0xbf800000,3 +np.float32,0xbf4f2c0a,0xbf0e085e,3 +np.float32,0xbf2b5907,0xbef9d431,3 +np.float32,0x3e855e0d,0x3e985960,3 +np.float32,0x8056cc64,0x8056cc64,3 +np.float32,0xff746bb5,0xbf800000,3 +np.float32,0x3e0332f6,0x3e0bf986,3 +np.float32,0xff637720,0xbf800000,3 +np.float32,0xbf330676,0xbf00c990,3 +np.float32,0x3ec449a1,0x3eef3862,3 +np.float32,0x766541,0x766541,3 +np.float32,0xfe2edf6c,0xbf800000,3 +np.float32,0xbebb28ca,0xbe9cc3e2,3 +np.float32,0x3f16c930,0x3f4d5ce4,3 +np.float32,0x7f1a9a4a,0x7f800000,3 +np.float32,0x3e9ba1,0x3e9ba1,3 +np.float32,0xbf73d5f6,0xbf1d3d69,3 +np.float32,0xfdc8a8b0,0xbf800000,3 +np.float32,0x50f051,0x50f051,3 +np.float32,0xff0add02,0xbf800000,3 +np.float32,0x1e50bf,0x1e50bf,3 +np.float32,0x3f04d287,0x3f2e1948,3 +np.float32,0x7f1e50,0x7f1e50,3 +np.float32,0x2affb3,0x2affb3,3 +np.float32,0x80039f07,0x80039f07,3 +np.float32,0x804ba79e,0x804ba79e,3 +np.float32,0x7b5a8eed,0x7f800000,3 +np.float32,0x3e1a8b28,0x3e26d0a7,3 +np.float32,0x3ea95f29,0x3ec8bfa4,3 +np.float32,0x7e09fa55,0x7f800000,3 +np.float32,0x7eacb1b3,0x7f800000,3 +np.float32,0x3e8ad7c0,0x3e9f7dec,3 +np.float32,0x7e0e997c,0x7f800000,3 +np.float32,0x3f4422b4,0x3f936398,3 +np.float32,0x806bd222,0x806bd222,3 +np.float32,0x677ae6,0x677ae6,3 +np.float32,0x62cf68,0x62cf68,3 +np.float32,0x7e4e594e,0x7f800000,3 +np.float32,0x80445fd1,0x80445fd1,3 +np.float32,0xff3a0d04,0xbf800000,3 +np.float32,0x8052b256,0x8052b256,3 +np.float32,0x3cb34440,0x3cb53e11,3 +np.float32,0xbf0e3865,0xbeda3c6d,3 +np.float32,0x3f49f5df,0x3f99ba17,3 +np.float32,0xbed75a22,0xbeafcc09,3 +np.float32,0xbf7aec64,0xbf1fefc8,3 +np.float32,0x7f35a62d,0x7f800000,3 +np.float32,0xbf787b03,0xbf1f03fc,3 +np.float32,0x8006a62a,0x8006a62a,3 +np.float32,0x3f6419e7,0x3fb803c7,3 +np.float32,0x3ecea2e5,0x3efe8f01,3 +np.float32,0x80603577,0x80603577,3 +np.float32,0xff73198c,0xbf800000,3 +np.float32,0x7def110a,0x7f800000,3 +np.float32,0x544efd,0x544efd,3 +np.float32,0x3f052340,0x3f2ea0fc,3 +np.float32,0xff306666,0xbf800000,3 +np.float32,0xbf800000,0xbf21d2a7,3 +np.float32,0xbed3e150,0xbead826a,3 +np.float32,0x3f430c99,0x3f92390f,3 +np.float32,0xbf4bffa4,0xbf0c9c73,3 +np.float32,0xfd97a710,0xbf800000,3 +np.float32,0x3cadf0fe,0x3cafcd1a,3 +np.float32,0x807af7b4,0x807af7b4,3 +np.float32,0xbc508600,0xbc4f33bc,3 +np.float32,0x7f3e0ec7,0x7f800000,3 +np.float32,0xbe51334c,0xbe3d36f7,3 +np.float32,0xfe7b7fb4,0xbf800000,3 +np.float32,0xfed9c45e,0xbf800000,3 +np.float32,0x3da024eb,0x3da6926a,3 +np.float32,0x7eed9e76,0x7f800000,3 +np.float32,0xbf2b8f1f,0xbefa0b91,3 +np.float32,0x3f2b9286,0x3f746318,3 +np.float32,0xfe8af49c,0xbf800000,3 +np.float32,0x9c4f7,0x9c4f7,3 +np.float32,0x801d7543,0x801d7543,3 +np.float32,0xbf66474a,0xbf17de66,3 +np.float32,0xbf562155,0xbf1116b1,3 +np.float32,0x46a8de,0x46a8de,3 +np.float32,0x8053fe6b,0x8053fe6b,3 +np.float32,0xbf6ee842,0xbf1b51f3,3 +np.float32,0xbf6ad78e,0xbf19b565,3 +np.float32,0xbf012574,0xbecad7ff,3 +np.float32,0x748364,0x748364,3 +np.float32,0x8073f59b,0x8073f59b,3 +np.float32,0xff526825,0xbf800000,3 +np.float32,0xfeb02dc4,0xbf800000,3 +np.float32,0x8033eb1c,0x8033eb1c,3 +np.float32,0x3f3685ea,0x3f8520cc,3 +np.float32,0x7f657902,0x7f800000,3 +np.float32,0xbf75eac4,0xbf1e0a1f,3 +np.float32,0xfe67f384,0xbf800000,3 +np.float32,0x3f56d3cc,0x3fa83faf,3 +np.float32,0x44a4ce,0x44a4ce,3 +np.float32,0x1dc4b3,0x1dc4b3,3 +np.float32,0x4fb3b2,0x4fb3b2,3 +np.float32,0xbea904a4,0xbe8ff3ed,3 +np.float32,0x7e668f16,0x7f800000,3 +np.float32,0x7f538378,0x7f800000,3 +np.float32,0x80541709,0x80541709,3 +np.float32,0x80228040,0x80228040,3 +np.float32,0x7ef9694e,0x7f800000,3 +np.float32,0x3f5fca9b,0x3fb2ce54,3 +np.float32,0xbe9c43c2,0xbe86ab84,3 +np.float32,0xfecee000,0xbf800000,3 +np.float32,0x5a65c2,0x5a65c2,3 +np.float32,0x3f736572,0x3fcb3985,3 +np.float32,0xbf2a03f7,0xbef87600,3 +np.float32,0xfe96b488,0xbf800000,3 +np.float32,0xfedd8800,0xbf800000,3 +np.float32,0x80411804,0x80411804,3 +np.float32,0x7edcb0a6,0x7f800000,3 +np.float32,0x2bb882,0x2bb882,3 +np.float32,0x3f800000,0x3fdbf0a9,3 +np.float32,0x764b27,0x764b27,3 +np.float32,0x7e92035d,0x7f800000,3 +np.float32,0x3e80facb,0x3e92ae1d,3 +np.float32,0x8040b81a,0x8040b81a,3 +np.float32,0x7f487fe4,0x7f800000,3 +np.float32,0xbc641780,0xbc6282ed,3 +np.float32,0x804b0bb9,0x804b0bb9,3 +np.float32,0x7d0b7c39,0x7f800000,3 +np.float32,0xff072080,0xbf800000,3 +np.float32,0xbed7aff8,0xbeb00462,3 +np.float32,0x35e247,0x35e247,3 +np.float32,0xbf7edd19,0xbf216766,3 +np.float32,0x8004a539,0x8004a539,3 +np.float32,0xfdfc1790,0xbf800000,3 +np.float32,0x8037a841,0x8037a841,3 +np.float32,0xfed0a8a8,0xbf800000,3 +np.float32,0x7f1f1697,0x7f800000,3 +np.float32,0x3f2ccc6e,0x3f76ca23,3 +np.float32,0x35eada,0x35eada,3 +np.float32,0xff111f42,0xbf800000,3 +np.float32,0x3ee1ab7f,0x3f0dcbbe,3 +np.float32,0xbf6e89ee,0xbf1b2cd4,3 +np.float32,0x3f58611c,0x3faa0cdc,3 +np.float32,0x1ac6a6,0x1ac6a6,3 +np.float32,0xbf1286fa,0xbedf2312,3 +np.float32,0x7e451137,0x7f800000,3 +np.float32,0xbe92c326,0xbe7f3405,3 +np.float32,0x3f2fdd16,0x3f7cd87b,3 +np.float32,0xbe5c0ea0,0xbe4604c2,3 +np.float32,0xbdb29968,0xbdab0883,3 +np.float32,0x3964,0x3964,3 +np.float32,0x3f0dc236,0x3f3d60a0,3 +np.float32,0x7c3faf06,0x7f800000,3 +np.float32,0xbef41f7a,0xbec22b16,3 +np.float32,0x3f4c0289,0x3f9bfdcc,3 +np.float32,0x806084e9,0x806084e9,3 +np.float32,0x3ed1d8dd,0x3f01b0c1,3 +np.float32,0x806d8d8b,0x806d8d8b,3 +np.float32,0x3f052180,0x3f2e9e0a,3 +np.float32,0x803d85d5,0x803d85d5,3 +np.float32,0x3e0afd70,0x3e14dd48,3 +np.float32,0x2fbc63,0x2fbc63,3 +np.float32,0x2e436f,0x2e436f,3 +np.float32,0xbf7b19e6,0xbf2000da,3 +np.float32,0x3f34022e,0x3f829362,3 +np.float32,0x3d2b40e0,0x3d2ee246,3 +np.float32,0x3f5298b4,0x3fa3649b,3 +np.float32,0xbdb01328,0xbda8b7de,3 +np.float32,0x7f693c81,0x7f800000,3 +np.float32,0xbeb1abc0,0xbe961edc,3 +np.float32,0x801d9b5d,0x801d9b5d,3 +np.float32,0x80628668,0x80628668,3 +np.float32,0x800f57dd,0x800f57dd,3 +np.float32,0x8017c94f,0x8017c94f,3 +np.float32,0xbf16f5f4,0xbee418b8,3 +np.float32,0x3e686476,0x3e827022,3 +np.float32,0xbf256796,0xbef3abd9,3 +np.float32,0x7f1b4485,0x7f800000,3 +np.float32,0xbea0b3cc,0xbe89ed21,3 +np.float32,0xfee08b2e,0xbf800000,3 +np.float32,0x523cb4,0x523cb4,3 +np.float32,0x3daf2cb2,0x3db6e273,3 +np.float32,0xbd531c40,0xbd4dc323,3 +np.float32,0x80078fe5,0x80078fe5,3 +np.float32,0x80800000,0x80800000,3 +np.float32,0x3f232438,0x3f642d1a,3 +np.float32,0x3ec29446,0x3eecb7c0,3 +np.float32,0x3dbcd2a4,0x3dc5cd1d,3 +np.float32,0x7f045b0d,0x7f800000,3 +np.float32,0x7f22e6d1,0x7f800000,3 +np.float32,0xbf5d3430,0xbf141c80,3 +np.float32,0xbe03ec70,0xbdf78ee6,3 +np.float32,0x3e93ec9a,0x3eab822f,3 +np.float32,0x7f3b9262,0x7f800000,3 +np.float32,0x65ac6a,0x65ac6a,3 +np.float32,0x3db9a8,0x3db9a8,3 +np.float32,0xbf37ab59,0xbf031306,3 +np.float32,0x33c40e,0x33c40e,3 +np.float32,0x7f7a478f,0x7f800000,3 +np.float32,0xbe8532d0,0xbe6a906f,3 +np.float32,0x801c081d,0x801c081d,3 +np.float32,0xbe4212a0,0xbe30ca73,3 +np.float32,0xff0b603e,0xbf800000,3 +np.float32,0x4554dc,0x4554dc,3 +np.float32,0x3dd324be,0x3dde695e,3 +np.float32,0x3f224c44,0x3f629557,3 +np.float32,0x8003cd79,0x8003cd79,3 +np.float32,0xbf31351c,0xbeffc2fd,3 +np.float32,0x8034603a,0x8034603a,3 +np.float32,0xbf6fcb70,0xbf1bab24,3 +np.float32,0x804eb67e,0x804eb67e,3 +np.float32,0xff05c00e,0xbf800000,3 +np.float32,0x3eb5b36f,0x3eda1ec7,3 +np.float32,0x3f1ed7f9,0x3f5c1d90,3 +np.float32,0x3f052d8a,0x3f2eb24b,3 +np.float32,0x5ddf51,0x5ddf51,3 +np.float32,0x7e50c11c,0x7f800000,3 +np.float32,0xff74f55a,0xbf800000,3 +np.float32,0x4322d,0x4322d,3 +np.float32,0x3f16f8a9,0x3f4db27a,3 +np.float32,0x3f4f23d6,0x3f9f7c2c,3 +np.float32,0xbf706c1e,0xbf1bea0a,3 +np.float32,0x3f2cbd52,0x3f76ac77,3 +np.float32,0xf3043,0xf3043,3 +np.float32,0xfee79de0,0xbf800000,3 +np.float32,0x7e942f69,0x7f800000,3 +np.float32,0x180139,0x180139,3 +np.float32,0xff69c678,0xbf800000,3 +np.float32,0x3f46773f,0x3f95e840,3 +np.float32,0x804aae1c,0x804aae1c,3 +np.float32,0x3eb383b4,0x3ed7024c,3 +np.float32,0x8032624e,0x8032624e,3 +np.float32,0xbd0a0f80,0xbd07c27d,3 +np.float32,0xbf1c9b98,0xbeea4a61,3 +np.float32,0x7f370999,0x7f800000,3 +np.float32,0x801931f9,0x801931f9,3 +np.float32,0x3f6f45ce,0x3fc5eea0,3 +np.float32,0xff0ab4cc,0xbf800000,3 +np.float32,0x4c043d,0x4c043d,3 +np.float32,0x8002a599,0x8002a599,3 +np.float32,0xbc4a6080,0xbc4921d7,3 +np.float32,0x3f008d14,0x3f26fb72,3 +np.float32,0x7f48b3d9,0x7f800000,3 +np.float32,0x7cb2ec7e,0x7f800000,3 +np.float32,0xbf1338bd,0xbedfeb61,3 +np.float32,0x0,0x0,3 +np.float32,0xbf2f5b64,0xbefde71c,3 +np.float32,0xbe422974,0xbe30dd56,3 +np.float32,0x3f776be8,0x3fd07950,3 +np.float32,0xbf3e97a1,0xbf06684a,3 +np.float32,0x7d28cb26,0x7f800000,3 +np.float32,0x801618d2,0x801618d2,3 +np.float32,0x807e4f83,0x807e4f83,3 +np.float32,0x8006b07d,0x8006b07d,3 +np.float32,0xfea1c042,0xbf800000,3 +np.float32,0xff24ef74,0xbf800000,3 +np.float32,0xfef7ab16,0xbf800000,3 +np.float32,0x70b771,0x70b771,3 +np.float32,0x7daeb64e,0x7f800000,3 +np.float32,0xbe66e378,0xbe4eb59c,3 +np.float32,0xbead1534,0xbe92dcf7,3 +np.float32,0x7e6769b8,0x7f800000,3 +np.float32,0x7ecd0890,0x7f800000,3 +np.float32,0xbe7380d8,0xbe58b747,3 +np.float32,0x3efa6f2f,0x3f218265,3 +np.float32,0x3f59dada,0x3fabc5eb,3 +np.float32,0xff0f2d20,0xbf800000,3 +np.float32,0x8060210e,0x8060210e,3 +np.float32,0x3ef681e8,0x3f1e51c8,3 +np.float32,0x77a6dd,0x77a6dd,3 +np.float32,0xbebfdd0e,0xbea00399,3 +np.float32,0xfe889b72,0xbf800000,3 +np.float32,0x8049ed2c,0x8049ed2c,3 +np.float32,0x3b089dc4,0x3b08c23e,3 +np.float32,0xbf13c7c4,0xbee08c28,3 +np.float32,0x3efa13b9,0x3f2137d7,3 +np.float32,0x3e9385dc,0x3eaaf914,3 +np.float32,0x7e0e6a43,0x7f800000,3 +np.float32,0x7df6d63f,0x7f800000,3 +np.float32,0x3f3efead,0x3f8dea03,3 +np.float32,0xff52548c,0xbf800000,3 +np.float32,0x803ff9d8,0x803ff9d8,3 +np.float32,0x3c825823,0x3c836303,3 +np.float32,0xfc9e97a0,0xbf800000,3 +np.float32,0xfe644f48,0xbf800000,3 +np.float32,0x802f5017,0x802f5017,3 +np.float32,0x3d5753b9,0x3d5d1661,3 +np.float32,0x7f2a55d2,0x7f800000,3 +np.float32,0x7f4dabfe,0x7f800000,3 +np.float32,0x3f49492a,0x3f98fc47,3 +np.float32,0x3f4d1589,0x3f9d2f82,3 +np.float32,0xff016208,0xbf800000,3 +np.float32,0xbf571cb7,0xbf118365,3 +np.float32,0xbf1ef297,0xbeecd136,3 +np.float32,0x36266b,0x36266b,3 +np.float32,0xbed07b0e,0xbeab4129,3 +np.float32,0x7f553365,0x7f800000,3 +np.float32,0xfe9bb8c6,0xbf800000,3 +np.float32,0xbeb497d6,0xbe982e19,3 +np.float32,0xbf27af6c,0xbef60d16,3 +np.float32,0x55cf51,0x55cf51,3 +np.float32,0x3eab1db0,0x3ecb2e4f,3 +np.float32,0x3e777603,0x3e8bf62f,3 +np.float32,0x7f10e374,0x7f800000,3 +np.float32,0xbf1f6480,0xbeed4b8d,3 +np.float32,0x40479d,0x40479d,3 +np.float32,0x156259,0x156259,3 +np.float32,0x3d852e30,0x3d899b2d,3 +np.float32,0x80014ff3,0x80014ff3,3 +np.float32,0xbd812fa8,0xbd7a645c,3 +np.float32,0x800ab780,0x800ab780,3 +np.float32,0x3ea02ff4,0x3ebc13bd,3 +np.float32,0x7e858b8e,0x7f800000,3 +np.float32,0x75d63b,0x75d63b,3 +np.float32,0xbeb15c94,0xbe95e6e3,3 +np.float32,0x3da0cee0,0x3da74a39,3 +np.float32,0xff21c01c,0xbf800000,3 +np.float32,0x8049b5eb,0x8049b5eb,3 +np.float32,0x80177ab0,0x80177ab0,3 +np.float32,0xff137a50,0xbf800000,3 +np.float32,0x3f7febba,0x3fdbd51c,3 +np.float32,0x8041e4dd,0x8041e4dd,3 +np.float32,0x99b8c,0x99b8c,3 +np.float32,0x5621ba,0x5621ba,3 +np.float32,0x14b534,0x14b534,3 +np.float32,0xbe2eb3a8,0xbe209c95,3 +np.float32,0x7e510c28,0x7f800000,3 +np.float32,0x804ec2f2,0x804ec2f2,3 +np.float32,0x3f662406,0x3fba82b0,3 +np.float32,0x800000,0x800000,3 +np.float32,0x3f3120d6,0x3f7f5d96,3 +np.float32,0x7f179b8e,0x7f800000,3 +np.float32,0x7f65278e,0x7f800000,3 +np.float32,0xfeb50f52,0xbf800000,3 +np.float32,0x7f051bd1,0x7f800000,3 +np.float32,0x7ea0558d,0x7f800000,3 +np.float32,0xbd0a96c0,0xbd08453f,3 +np.float64,0xee82da5ddd05c,0xee82da5ddd05c,1 +np.float64,0x800c3a22d7f87446,0x800c3a22d7f87446,1 +np.float64,0xbfd34b20eaa69642,0xbfd0a825e7688d3e,1 +np.float64,0x3fd6a0f2492d41e5,0x3fdb253b906057b3,1 +np.float64,0xbfda13d8783427b0,0xbfd56b1d76684332,1 +np.float64,0xbfe50b5a99ea16b5,0xbfded7dd82c6f746,1 +np.float64,0x3f82468fc0248d20,0x3f825b7fa9378ee9,1 +np.float64,0x7ff0000000000000,0x7ff0000000000000,1 +np.float64,0x856e50290adca,0x856e50290adca,1 +np.float64,0x7fde55a5fa3cab4b,0x7ff0000000000000,1 +np.float64,0x7fcf2c8dd93e591b,0x7ff0000000000000,1 +np.float64,0x8001b3a0e3236743,0x8001b3a0e3236743,1 +np.float64,0x8000fdb14821fb63,0x8000fdb14821fb63,1 +np.float64,0xbfe3645e08e6c8bc,0xbfdd161362a5e9ef,1 +np.float64,0x7feb34d28b3669a4,0x7ff0000000000000,1 +np.float64,0x80099dd810933bb1,0x80099dd810933bb1,1 +np.float64,0xbfedbcc1097b7982,0xbfe35d86414d53dc,1 +np.float64,0x7fdc406fbdb880de,0x7ff0000000000000,1 +np.float64,0x800c4bf85ab897f1,0x800c4bf85ab897f1,1 +np.float64,0x3fd8f7b0e0b1ef60,0x3fde89b497ae20d8,1 +np.float64,0xffe4fced5c69f9da,0xbff0000000000000,1 +np.float64,0xbfe54d421fea9a84,0xbfdf1be0cbfbfcba,1 +np.float64,0x800af72f3535ee5f,0x800af72f3535ee5f,1 +np.float64,0x3fe24e6570e49ccb,0x3fe8b3a86d970411,1 +np.float64,0xbfdd7b22d0baf646,0xbfd79fac2e4f7558,1 +np.float64,0xbfe6a7654c6d4eca,0xbfe03c1f13f3b409,1 +np.float64,0x3fe2c3eb662587d7,0x3fe98566e625d4f5,1 +np.float64,0x3b1ef71e763e0,0x3b1ef71e763e0,1 +np.float64,0xffed03c6baba078d,0xbff0000000000000,1 +np.float64,0x3febac19d0b75834,0x3ff5fdacc9d51bcd,1 +np.float64,0x800635d6794c6bae,0x800635d6794c6bae,1 +np.float64,0xbfe8cafc827195f9,0xbfe1411438608ae1,1 +np.float64,0x7feeb616a83d6c2c,0x7ff0000000000000,1 +np.float64,0x3fd52d62a2aa5ac5,0x3fd91a07a7f18f44,1 +np.float64,0x80036996b8a6d32e,0x80036996b8a6d32e,1 +np.float64,0x2b1945965632a,0x2b1945965632a,1 +np.float64,0xbfecb5e8c9796bd2,0xbfe2f40fca276aa2,1 +np.float64,0x3fe8669ed4f0cd3e,0x3ff24c89fc9cdbff,1 +np.float64,0x71e9f65ee3d3f,0x71e9f65ee3d3f,1 +np.float64,0xbfd5ab262bab564c,0xbfd261ae108ef79e,1 +np.float64,0xbfe7091342ee1226,0xbfe06bf5622d75f6,1 +np.float64,0x49e888d093d12,0x49e888d093d12,1 +np.float64,0x2272f3dc44e5f,0x2272f3dc44e5f,1 +np.float64,0x7fe98736e0b30e6d,0x7ff0000000000000,1 +np.float64,0x30fa9cde61f54,0x30fa9cde61f54,1 +np.float64,0x7fdc163fc0382c7f,0x7ff0000000000000,1 +np.float64,0xffb40d04ee281a08,0xbff0000000000000,1 +np.float64,0xffe624617f2c48c2,0xbff0000000000000,1 +np.float64,0x3febb582bd376b05,0x3ff608da584d1716,1 +np.float64,0xfc30a5a5f8615,0xfc30a5a5f8615,1 +np.float64,0x3fef202efd7e405e,0x3ffa52009319b069,1 +np.float64,0x8004d0259829a04c,0x8004d0259829a04c,1 +np.float64,0x800622dc71ec45ba,0x800622dc71ec45ba,1 +np.float64,0xffefffffffffffff,0xbff0000000000000,1 +np.float64,0x800e89113c9d1223,0x800e89113c9d1223,1 +np.float64,0x7fba7fde3034ffbb,0x7ff0000000000000,1 +np.float64,0xbfeea31e807d463d,0xbfe3b7369b725915,1 +np.float64,0x3feb7c9589f6f92c,0x3ff5c56cf71b0dff,1 +np.float64,0x3fd52d3b59aa5a77,0x3fd919d0f683fd07,1 +np.float64,0x800de90a43fbd215,0x800de90a43fbd215,1 +np.float64,0x3fe7eb35a9efd66b,0x3ff1c940dbfc6ef9,1 +np.float64,0xbda0adcb7b416,0xbda0adcb7b416,1 +np.float64,0x7fc5753e3a2aea7b,0x7ff0000000000000,1 +np.float64,0xffdd101d103a203a,0xbff0000000000000,1 +np.float64,0x7fcb54f56836a9ea,0x7ff0000000000000,1 +np.float64,0xbfd61c8d6eac391a,0xbfd2b23bc0a2cef4,1 +np.float64,0x3feef55de37deabc,0x3ffa198639a0161d,1 +np.float64,0x7fe4ffbfaea9ff7e,0x7ff0000000000000,1 +np.float64,0x9d1071873a20e,0x9d1071873a20e,1 +np.float64,0x3fef1ecb863e3d97,0x3ffa502a81e09cfc,1 +np.float64,0xad2da12b5a5b4,0xad2da12b5a5b4,1 +np.float64,0xffe614b74c6c296e,0xbff0000000000000,1 +np.float64,0xffe60d3f286c1a7e,0xbff0000000000000,1 +np.float64,0x7fda7d91f4b4fb23,0x7ff0000000000000,1 +np.float64,0x800023f266a047e6,0x800023f266a047e6,1 +np.float64,0x7fdf5f9ad23ebf35,0x7ff0000000000000,1 +np.float64,0x3fa7459f002e8b3e,0x3fa7cf178dcf0af6,1 +np.float64,0x3fe9938d61f3271b,0x3ff39516a13caec3,1 +np.float64,0xbfd59314c3ab262a,0xbfd250830f73efd2,1 +np.float64,0xbfc7e193f72fc328,0xbfc5c924339dd7a8,1 +np.float64,0x7fec1965f17832cb,0x7ff0000000000000,1 +np.float64,0xbfd932908eb26522,0xbfd4d4312d272580,1 +np.float64,0xbfdf2d08e2be5a12,0xbfd8add1413b0b1b,1 +np.float64,0x7fdcf7cc74b9ef98,0x7ff0000000000000,1 +np.float64,0x7fc79300912f2600,0x7ff0000000000000,1 +np.float64,0xffd4bd8f23297b1e,0xbff0000000000000,1 +np.float64,0x41869ce0830e,0x41869ce0830e,1 +np.float64,0x3fe5dcec91ebb9da,0x3fef5e213598cbd4,1 +np.float64,0x800815d9c2902bb4,0x800815d9c2902bb4,1 +np.float64,0x800ba1a4b877434a,0x800ba1a4b877434a,1 +np.float64,0x80069d7bdc4d3af8,0x80069d7bdc4d3af8,1 +np.float64,0xcf00d4339e01b,0xcf00d4339e01b,1 +np.float64,0x80072b71bd4e56e4,0x80072b71bd4e56e4,1 +np.float64,0x80059ca6fbab394f,0x80059ca6fbab394f,1 +np.float64,0x3fe522fc092a45f8,0x3fedf212682bf894,1 +np.float64,0x7fe17f384ea2fe70,0x7ff0000000000000,1 +np.float64,0x0,0x0,1 +np.float64,0x3f72bb4c20257698,0x3f72c64766b52069,1 +np.float64,0x7fbc97c940392f92,0x7ff0000000000000,1 +np.float64,0xffc5904ebd2b209c,0xbff0000000000000,1 +np.float64,0xbfe34fb55b669f6a,0xbfdcff81dd30a49d,1 +np.float64,0x8007ccda006f99b5,0x8007ccda006f99b5,1 +np.float64,0x3fee50e4c8fca1ca,0x3ff9434c7750ad0f,1 +np.float64,0x7fee7b07c67cf60f,0x7ff0000000000000,1 +np.float64,0x3fdcce4a5a399c95,0x3fe230c83f28218a,1 +np.float64,0x7fee5187b37ca30e,0x7ff0000000000000,1 +np.float64,0x3fc48f6a97291ed8,0x3fc64db6200a9833,1 +np.float64,0xc7fec3498ffd9,0xc7fec3498ffd9,1 +np.float64,0x800769c59d2ed38c,0x800769c59d2ed38c,1 +np.float64,0xffe69ede782d3dbc,0xbff0000000000000,1 +np.float64,0x3fecd9770979b2ee,0x3ff76a1f2f0f08f2,1 +np.float64,0x5aa358a8b546c,0x5aa358a8b546c,1 +np.float64,0xbfe795a0506f2b40,0xbfe0afcc52c0166b,1 +np.float64,0xffd4ada1e8a95b44,0xbff0000000000000,1 +np.float64,0xffcac1dc213583b8,0xbff0000000000000,1 +np.float64,0xffe393c15fa72782,0xbff0000000000000,1 +np.float64,0xbfcd6a3c113ad478,0xbfca47a2157b9cdd,1 +np.float64,0xffedde20647bbc40,0xbff0000000000000,1 +np.float64,0x3fd0d011b1a1a024,0x3fd33a57945559f4,1 +np.float64,0x3fef27e29f7e4fc6,0x3ffa5c314e0e3d69,1 +np.float64,0xffe96ff71f72dfee,0xbff0000000000000,1 +np.float64,0xffe762414f2ec482,0xbff0000000000000,1 +np.float64,0x3fc2dcfd3d25b9fa,0x3fc452f41682a12e,1 +np.float64,0xbfbdb125b63b6248,0xbfbc08e6553296d4,1 +np.float64,0x7b915740f724,0x7b915740f724,1 +np.float64,0x60b502b2c16a1,0x60b502b2c16a1,1 +np.float64,0xbfeb38b0be367162,0xbfe254f6782cfc47,1 +np.float64,0x800dc39a3edb8735,0x800dc39a3edb8735,1 +np.float64,0x3fea4fb433349f68,0x3ff468b97cf699f5,1 +np.float64,0xbfd49967962932d0,0xbfd19ceb41ff4cd0,1 +np.float64,0xbfebf75cd377eeba,0xbfe2a576bdbccccc,1 +np.float64,0xbfb653d65c2ca7b0,0xbfb561ab8fcb3f26,1 +np.float64,0xffe3f34b8727e696,0xbff0000000000000,1 +np.float64,0x3fdd798064baf301,0x3fe2b7c130a6fc63,1 +np.float64,0x3febe027e6b7c050,0x3ff63bac1b22e12d,1 +np.float64,0x7fcaa371af3546e2,0x7ff0000000000000,1 +np.float64,0xbfe6ee980a2ddd30,0xbfe05f0bc5dc80d2,1 +np.float64,0xc559c33f8ab39,0xc559c33f8ab39,1 +np.float64,0x84542c2b08a86,0x84542c2b08a86,1 +np.float64,0xbfe5645e046ac8bc,0xbfdf3398dc3cc1bd,1 +np.float64,0x3fee8c48ae7d1892,0x3ff9902899480526,1 +np.float64,0x3fb706471c2e0c8e,0x3fb817787aace8db,1 +np.float64,0x7fefe78f91ffcf1e,0x7ff0000000000000,1 +np.float64,0xbfcf6d560b3edaac,0xbfcbddc72a2130df,1 +np.float64,0x7fd282bfd925057f,0x7ff0000000000000,1 +np.float64,0x3fb973dbee32e7b8,0x3fbac2c87cbd0215,1 +np.float64,0x3fd1ce38ff239c72,0x3fd4876de5164420,1 +np.float64,0x8008ac2e3c31585d,0x8008ac2e3c31585d,1 +np.float64,0x3fa05e06dc20bc00,0x3fa0a1b7de904dce,1 +np.float64,0x7fd925f215324be3,0x7ff0000000000000,1 +np.float64,0x3f949d95d0293b2c,0x3f94d31197d51874,1 +np.float64,0xffdded9e67bbdb3c,0xbff0000000000000,1 +np.float64,0x3fed390dcfba721c,0x3ff7e08c7a709240,1 +np.float64,0x7fe6e62300adcc45,0x7ff0000000000000,1 +np.float64,0xbfd779bc312ef378,0xbfd3a6cb64bb0181,1 +np.float64,0x3fe43e9877287d31,0x3fec3e100ef935fd,1 +np.float64,0x210b68e44216e,0x210b68e44216e,1 +np.float64,0x3fcdffc1e73bff84,0x3fd0e729d02ec539,1 +np.float64,0xcea10c0f9d422,0xcea10c0f9d422,1 +np.float64,0x7feb97a82d772f4f,0x7ff0000000000000,1 +np.float64,0x9b4b4d953696a,0x9b4b4d953696a,1 +np.float64,0x3fd1bd8e95237b1d,0x3fd4716dd34cf828,1 +np.float64,0x800fc273841f84e7,0x800fc273841f84e7,1 +np.float64,0xbfd2aef167255de2,0xbfd0340f30d82f18,1 +np.float64,0x800d021a551a0435,0x800d021a551a0435,1 +np.float64,0xffebf934a8b7f268,0xbff0000000000000,1 +np.float64,0x3fd819849fb03308,0x3fdd43bca0aac749,1 +np.float64,0x7ff8000000000000,0x7ff8000000000000,1 +np.float64,0x27c34b064f86a,0x27c34b064f86a,1 +np.float64,0x7fef4f5a373e9eb3,0x7ff0000000000000,1 +np.float64,0x7fd92fccce325f99,0x7ff0000000000000,1 +np.float64,0x800520869d6a410e,0x800520869d6a410e,1 +np.float64,0x3fccbcaddf397958,0x3fd01bf6b0c4d97f,1 +np.float64,0x80039ebfc4273d80,0x80039ebfc4273d80,1 +np.float64,0xbfed1f0b3c7a3e16,0xbfe31ea6e4c69141,1 +np.float64,0x7fee1bb7c4bc376f,0x7ff0000000000000,1 +np.float64,0xbfa8bee1d8317dc0,0xbfa8283b7dbf95a9,1 +np.float64,0x3fe797db606f2fb6,0x3ff171b1c2bc8fe5,1 +np.float64,0xbfee2ecfdbbc5da0,0xbfe38a3f0a43d14e,1 +np.float64,0x3fe815c7f1302b90,0x3ff1f65165c45d71,1 +np.float64,0xbfbb265c94364cb8,0xbfb9c27ec61a9a1d,1 +np.float64,0x3fcf1cab5d3e3957,0x3fd19c07444642f9,1 +np.float64,0xbfe6ae753f6d5cea,0xbfe03f99666dbe17,1 +np.float64,0xbfd18a2a73a31454,0xbfceaee204aca016,1 +np.float64,0x3fb8a1dffc3143c0,0x3fb9db38341ab1a3,1 +np.float64,0x7fd2a0376025406e,0x7ff0000000000000,1 +np.float64,0x7fe718c0e3ae3181,0x7ff0000000000000,1 +np.float64,0x3fb264d42424c9a8,0x3fb3121f071d4db4,1 +np.float64,0xd27190a7a4e32,0xd27190a7a4e32,1 +np.float64,0xbfe467668c68cecd,0xbfde2c4616738d5e,1 +np.float64,0x800ab9a2b9357346,0x800ab9a2b9357346,1 +np.float64,0x7fcbd108d537a211,0x7ff0000000000000,1 +np.float64,0x3fb79bba6e2f3770,0x3fb8bb2c140d3445,1 +np.float64,0xffefa7165e3f4e2c,0xbff0000000000000,1 +np.float64,0x7fb40185a428030a,0x7ff0000000000000,1 +np.float64,0xbfe9e3d58e73c7ab,0xbfe1c04d51c83d69,1 +np.float64,0x7fef5b97b17eb72e,0x7ff0000000000000,1 +np.float64,0x800a2957683452af,0x800a2957683452af,1 +np.float64,0x800f54f1925ea9e3,0x800f54f1925ea9e3,1 +np.float64,0xeffa4e77dff4a,0xeffa4e77dff4a,1 +np.float64,0xffbe501aa03ca038,0xbff0000000000000,1 +np.float64,0x8006c651bced8ca4,0x8006c651bced8ca4,1 +np.float64,0x3fe159faff22b3f6,0x3fe708f78efbdbed,1 +np.float64,0x800e7d59a31cfab3,0x800e7d59a31cfab3,1 +np.float64,0x3fe6ac2f272d585e,0x3ff07ee5305385c3,1 +np.float64,0x7fd014c054202980,0x7ff0000000000000,1 +np.float64,0xbfe4800b11e90016,0xbfde4648c6f29ce5,1 +np.float64,0xbfe6738470ece709,0xbfe0227b5b42b713,1 +np.float64,0x3fed052add3a0a56,0x3ff7a01819e65c6e,1 +np.float64,0xffe03106f120620e,0xbff0000000000000,1 +np.float64,0x7fe11df4d4e23be9,0x7ff0000000000000,1 +np.float64,0xbfcea25d7b3d44bc,0xbfcb3e808e7ce852,1 +np.float64,0xd0807b03a1010,0xd0807b03a1010,1 +np.float64,0x8004eda4fec9db4b,0x8004eda4fec9db4b,1 +np.float64,0x3fceb5c98d3d6b90,0x3fd15a894b15dd9f,1 +np.float64,0xbfee27228afc4e45,0xbfe38741702f3c0b,1 +np.float64,0xbfe606278c6c0c4f,0xbfdfd7cb6093652d,1 +np.float64,0xbfd66f59bc2cdeb4,0xbfd2ecb2297f6afc,1 +np.float64,0x4aee390095dc8,0x4aee390095dc8,1 +np.float64,0xbfe391355d67226a,0xbfdd46ddc0997014,1 +np.float64,0xffd27765e7a4eecc,0xbff0000000000000,1 +np.float64,0xbfe795e20a2f2bc4,0xbfe0afebc66c4dbd,1 +np.float64,0x7fc9a62e81334c5c,0x7ff0000000000000,1 +np.float64,0xffe4e57e52a9cafc,0xbff0000000000000,1 +np.float64,0x7fac326c8c3864d8,0x7ff0000000000000,1 +np.float64,0x3fe8675f6370cebf,0x3ff24d5863029c15,1 +np.float64,0x7fcf4745e73e8e8b,0x7ff0000000000000,1 +np.float64,0x7fcc9aec9f3935d8,0x7ff0000000000000,1 +np.float64,0x3fec2e8fcab85d20,0x3ff699ccd0b2fed6,1 +np.float64,0x3fd110a968222153,0x3fd38e81a88c2d13,1 +np.float64,0xffb3a68532274d08,0xbff0000000000000,1 +np.float64,0xf0e562bbe1cad,0xf0e562bbe1cad,1 +np.float64,0xbfe815b9e5f02b74,0xbfe0ec9f5023aebc,1 +np.float64,0xbf5151d88022a400,0xbf514f80c465feea,1 +np.float64,0x2547e3144a8fd,0x2547e3144a8fd,1 +np.float64,0x3fedcc0c28fb9818,0x3ff899612fbeb4c5,1 +np.float64,0x3fdc3d1c0f387a38,0x3fe1bf6e2d39bd75,1 +np.float64,0x7fe544dbe62a89b7,0x7ff0000000000000,1 +np.float64,0x8001500e48e2a01d,0x8001500e48e2a01d,1 +np.float64,0xbfed3b2b09fa7656,0xbfe329f3e7bada64,1 +np.float64,0xbfe76a943aeed528,0xbfe09b24e3aa3f79,1 +np.float64,0x3fe944330e328866,0x3ff33d472dee70c5,1 +np.float64,0x8004bbbd6cc9777c,0x8004bbbd6cc9777c,1 +np.float64,0xbfe28133fb650268,0xbfdc1ac230ac4ef5,1 +np.float64,0xc1370af7826e2,0xc1370af7826e2,1 +np.float64,0x7fcfa47f5f3f48fe,0x7ff0000000000000,1 +np.float64,0xbfa3002a04260050,0xbfa2a703a538b54e,1 +np.float64,0xffef44f3903e89e6,0xbff0000000000000,1 +np.float64,0xc32cce298659a,0xc32cce298659a,1 +np.float64,0x7b477cc2f68f0,0x7b477cc2f68f0,1 +np.float64,0x40a7f4ec814ff,0x40a7f4ec814ff,1 +np.float64,0xffee38edf67c71db,0xbff0000000000000,1 +np.float64,0x3fe23f6f1ce47ede,0x3fe8992b8bb03499,1 +np.float64,0x7fc8edfe7f31dbfc,0x7ff0000000000000,1 +np.float64,0x800bb8e6fb3771ce,0x800bb8e6fb3771ce,1 +np.float64,0xbfe11d364ee23a6c,0xbfda82a0c2ef9e46,1 +np.float64,0xbfeb993cb4b7327a,0xbfe27df565da85dc,1 +np.float64,0x10000000000000,0x10000000000000,1 +np.float64,0x3fc1f997d723f330,0x3fc34c5cff060af1,1 +np.float64,0x6e326fa0dc64f,0x6e326fa0dc64f,1 +np.float64,0x800fa30c2c5f4618,0x800fa30c2c5f4618,1 +np.float64,0x7fed16ad603a2d5a,0x7ff0000000000000,1 +np.float64,0x9411cf172823a,0x9411cf172823a,1 +np.float64,0xffece51d4cb9ca3a,0xbff0000000000000,1 +np.float64,0x3fdda3d1453b47a3,0x3fe2d954f7849890,1 +np.float64,0xffd58330172b0660,0xbff0000000000000,1 +np.float64,0xbfc6962ae52d2c54,0xbfc4b4bdf0069f17,1 +np.float64,0xbfb4010a8e280218,0xbfb33e1236f7efa0,1 +np.float64,0x7fd0444909208891,0x7ff0000000000000,1 +np.float64,0xbfe027a24de04f44,0xbfd95e9064101e7c,1 +np.float64,0xa6f3f3214de9,0xa6f3f3214de9,1 +np.float64,0xbfe112eb0fe225d6,0xbfda768f7cbdf346,1 +np.float64,0xbfe99e90d4b33d22,0xbfe1a153e45a382a,1 +np.float64,0xffecb34f8e79669e,0xbff0000000000000,1 +np.float64,0xbfdf32c9653e6592,0xbfd8b159caf5633d,1 +np.float64,0x3fe9519829b2a330,0x3ff34c0a8152e20f,1 +np.float64,0xffd08ec8a7a11d92,0xbff0000000000000,1 +np.float64,0xffd19b71b6a336e4,0xbff0000000000000,1 +np.float64,0x7feda6b9377b4d71,0x7ff0000000000000,1 +np.float64,0x800fda2956bfb453,0x800fda2956bfb453,1 +np.float64,0x3fe54f601bea9ec0,0x3fee483cb03cbde4,1 +np.float64,0xbfe2a8ad5ee5515a,0xbfdc46ee7a10bf0d,1 +np.float64,0xbfd336c8bd266d92,0xbfd09916d432274a,1 +np.float64,0xfff0000000000000,0xbff0000000000000,1 +np.float64,0x3fd9a811a9b35024,0x3fdf8fa68cc048e3,1 +np.float64,0x3fe078c68520f18d,0x3fe58aecc1f9649b,1 +np.float64,0xbfc6d5aa3a2dab54,0xbfc4e9ea84f3d73c,1 +np.float64,0xf9682007f2d04,0xf9682007f2d04,1 +np.float64,0x3fee54523dbca8a4,0x3ff947b826de81f4,1 +np.float64,0x80461e5d008c4,0x80461e5d008c4,1 +np.float64,0x3fdd6d12d5bada26,0x3fe2ade8dee2fa02,1 +np.float64,0x3fcd5f0dfd3abe18,0x3fd081d6cd25731d,1 +np.float64,0x7fa36475c826c8eb,0x7ff0000000000000,1 +np.float64,0xbfdf3ce052be79c0,0xbfd8b78baccfb908,1 +np.float64,0x7fcd890dd13b121b,0x7ff0000000000000,1 +np.float64,0x8000000000000001,0x8000000000000001,1 +np.float64,0x800ec0f4281d81e8,0x800ec0f4281d81e8,1 +np.float64,0xbfba960116352c00,0xbfb94085424496d9,1 +np.float64,0x3fdddedc9bbbbdb8,0x3fe30853fe4ef5ce,1 +np.float64,0x238092a847013,0x238092a847013,1 +np.float64,0xbfe38d4803271a90,0xbfdd429a955c46af,1 +np.float64,0xbfd4c9067329920c,0xbfd1bf6255ed91a4,1 +np.float64,0xbfbee213923dc428,0xbfbd17ce1bda6088,1 +np.float64,0xffd5a2d337ab45a6,0xbff0000000000000,1 +np.float64,0x7fe21bfcf82437f9,0x7ff0000000000000,1 +np.float64,0x3fe2a2714da544e3,0x3fe949594a74ea25,1 +np.float64,0x800e05cf8ebc0b9f,0x800e05cf8ebc0b9f,1 +np.float64,0x559a1526ab343,0x559a1526ab343,1 +np.float64,0xffe6a1b7906d436e,0xbff0000000000000,1 +np.float64,0xffef27d6253e4fab,0xbff0000000000000,1 +np.float64,0xbfe0f90ab0a1f216,0xbfda5828a1edde48,1 +np.float64,0x9675d2ab2cebb,0x9675d2ab2cebb,1 +np.float64,0xffee0f7eecfc1efd,0xbff0000000000000,1 +np.float64,0x2ec005625d801,0x2ec005625d801,1 +np.float64,0x7fde35ff14bc6bfd,0x7ff0000000000000,1 +np.float64,0xffe03f36d9e07e6d,0xbff0000000000000,1 +np.float64,0x7fe09ff7c4213fef,0x7ff0000000000000,1 +np.float64,0xffeac29dd1b5853b,0xbff0000000000000,1 +np.float64,0x3fb63120aa2c6241,0x3fb72ea3de98a853,1 +np.float64,0xffd079eb84a0f3d8,0xbff0000000000000,1 +np.float64,0xbfd3c2cc75a78598,0xbfd1005996880b3f,1 +np.float64,0x7fb80507ee300a0f,0x7ff0000000000000,1 +np.float64,0xffe8006105f000c1,0xbff0000000000000,1 +np.float64,0x8009138b0ab22716,0x8009138b0ab22716,1 +np.float64,0xbfd6dfb40b2dbf68,0xbfd33b8e4008e3b0,1 +np.float64,0xbfe7c2cf9bef859f,0xbfe0c55c807460df,1 +np.float64,0xbfe75fe4da6ebfca,0xbfe09600256d3b81,1 +np.float64,0xffd662fc73acc5f8,0xbff0000000000000,1 +np.float64,0x20b99dbc41735,0x20b99dbc41735,1 +np.float64,0x3fe10b38ade21671,0x3fe68229a9bbeefc,1 +np.float64,0x3743b99c6e878,0x3743b99c6e878,1 +np.float64,0xff9eb5ed903d6be0,0xbff0000000000000,1 +np.float64,0x3ff0000000000000,0x3ffb7e151628aed3,1 +np.float64,0xffb9e0569e33c0b0,0xbff0000000000000,1 +np.float64,0x7fd39c804fa73900,0x7ff0000000000000,1 +np.float64,0x3fe881ef67f103df,0x3ff269dd704b7129,1 +np.float64,0x1b6eb40236dd7,0x1b6eb40236dd7,1 +np.float64,0xbfe734ea432e69d4,0xbfe0813e6355d02f,1 +np.float64,0xffcf48f3743e91e8,0xbff0000000000000,1 +np.float64,0xffed10bcf6fa2179,0xbff0000000000000,1 +np.float64,0x3fef07723b7e0ee4,0x3ffa3156123f3c15,1 +np.float64,0xffe45c704aa8b8e0,0xbff0000000000000,1 +np.float64,0xb7b818d96f703,0xb7b818d96f703,1 +np.float64,0x42fcc04085f99,0x42fcc04085f99,1 +np.float64,0xbfda7ced01b4f9da,0xbfd5b0ce1e5524ae,1 +np.float64,0xbfe1e5963d63cb2c,0xbfdb6a87b6c09185,1 +np.float64,0x7fdfa18003bf42ff,0x7ff0000000000000,1 +np.float64,0xbfe3790a43e6f214,0xbfdd2c9a38b4f089,1 +np.float64,0xffe0ff5b9ae1feb6,0xbff0000000000000,1 +np.float64,0x80085a7d3110b4fb,0x80085a7d3110b4fb,1 +np.float64,0xffd6bfa6622d7f4c,0xbff0000000000000,1 +np.float64,0xbfef5ddc7cfebbb9,0xbfe3fe170521593e,1 +np.float64,0x3fc21773fa242ee8,0x3fc36ebda1f91a72,1 +np.float64,0x7fc04d98da209b31,0x7ff0000000000000,1 +np.float64,0xbfeba3b535b7476a,0xbfe282602e3c322e,1 +np.float64,0xffd41fb5c1a83f6c,0xbff0000000000000,1 +np.float64,0xf87d206df0fa4,0xf87d206df0fa4,1 +np.float64,0x800060946fc0c12a,0x800060946fc0c12a,1 +np.float64,0x3fe69d5f166d3abe,0x3ff06fdddcf4ca93,1 +np.float64,0x7fe9b5793b336af1,0x7ff0000000000000,1 +np.float64,0x7fe0dd4143e1ba82,0x7ff0000000000000,1 +np.float64,0xbfa8eaea3c31d5d0,0xbfa8522e397da3bd,1 +np.float64,0x119f0078233e1,0x119f0078233e1,1 +np.float64,0xbfd78a207aaf1440,0xbfd3b225bbf2ab4f,1 +np.float64,0xc66a6d4d8cd4e,0xc66a6d4d8cd4e,1 +np.float64,0xe7fc4b57cff8a,0xe7fc4b57cff8a,1 +np.float64,0x800883e8091107d0,0x800883e8091107d0,1 +np.float64,0x3fa6520c842ca419,0x3fa6d06e1041743a,1 +np.float64,0x3fa563182c2ac630,0x3fa5d70e27a84c97,1 +np.float64,0xe6a30b61cd462,0xe6a30b61cd462,1 +np.float64,0x3fee85dac37d0bb6,0x3ff987cfa41a9778,1 +np.float64,0x3fe8f621db71ec44,0x3ff2e7b768a2e9d0,1 +np.float64,0x800f231d861e463b,0x800f231d861e463b,1 +np.float64,0xbfe22eb07c645d61,0xbfdbbdbb853ab4c6,1 +np.float64,0x7fd2dda2dea5bb45,0x7ff0000000000000,1 +np.float64,0xbfd09b79a0a136f4,0xbfcd4147606ffd27,1 +np.float64,0xca039cc394074,0xca039cc394074,1 +np.float64,0x8000000000000000,0x8000000000000000,1 +np.float64,0xcb34575d9668b,0xcb34575d9668b,1 +np.float64,0x3fea62c1f3f4c584,0x3ff47e6dc67ec89f,1 +np.float64,0x7fe544c8606a8990,0x7ff0000000000000,1 +np.float64,0xffe0a980c4615301,0xbff0000000000000,1 +np.float64,0x3fdd67d5f8bacfac,0x3fe2a9c3421830f1,1 +np.float64,0xffe41d3dda283a7b,0xbff0000000000000,1 +np.float64,0xffeed59e5ffdab3c,0xbff0000000000000,1 +np.float64,0xffeeae8326fd5d05,0xbff0000000000000,1 +np.float64,0x800d70b4fa7ae16a,0x800d70b4fa7ae16a,1 +np.float64,0xffec932e6839265c,0xbff0000000000000,1 +np.float64,0xee30b185dc616,0xee30b185dc616,1 +np.float64,0x7fc3cf4397279e86,0x7ff0000000000000,1 +np.float64,0xbfeab34f1875669e,0xbfe21b868229de7d,1 +np.float64,0xf45f5f7de8bec,0xf45f5f7de8bec,1 +np.float64,0x3fad2c4b203a5896,0x3fae0528b568f3cf,1 +np.float64,0xbfe2479543e48f2a,0xbfdbd9e57cf64028,1 +np.float64,0x3fd41a1473283429,0x3fd79df2bc60debb,1 +np.float64,0x3febb5155ef76a2a,0x3ff608585afd698b,1 +np.float64,0xffe21f5303e43ea6,0xbff0000000000000,1 +np.float64,0x7fe9ef390833de71,0x7ff0000000000000,1 +np.float64,0xffe8ee873d71dd0e,0xbff0000000000000,1 +np.float64,0x7fd7cbc55e2f978a,0x7ff0000000000000,1 +np.float64,0x80081f9080d03f21,0x80081f9080d03f21,1 +np.float64,0x7fecbafc8b3975f8,0x7ff0000000000000,1 +np.float64,0x800b6c4b0b16d896,0x800b6c4b0b16d896,1 +np.float64,0xbfaa0fc2d4341f80,0xbfa968cdf32b98ad,1 +np.float64,0x3fec79fe4078f3fc,0x3ff6f5361a4a5d93,1 +np.float64,0xbfb14b79de2296f0,0xbfb0b93b75ecec11,1 +np.float64,0x800009d084c013a2,0x800009d084c013a2,1 +np.float64,0x4a4cdfe29499d,0x4a4cdfe29499d,1 +np.float64,0xbfe721c2d56e4386,0xbfe077f541987d76,1 +np.float64,0x3e5f539e7cbeb,0x3e5f539e7cbeb,1 +np.float64,0x3fd23f044c247e09,0x3fd51ceafcdd64aa,1 +np.float64,0x3fc70785b02e0f0b,0x3fc93b2a37eb342a,1 +np.float64,0xbfe7ab4ec7af569e,0xbfe0ba28eecbf6b0,1 +np.float64,0x800c1d4134583a83,0x800c1d4134583a83,1 +np.float64,0xffd9a73070334e60,0xbff0000000000000,1 +np.float64,0x68a4bf24d1499,0x68a4bf24d1499,1 +np.float64,0x7feba9d9507753b2,0x7ff0000000000000,1 +np.float64,0xbfe9d747db73ae90,0xbfe1bab53d932010,1 +np.float64,0x800a9a4aed953496,0x800a9a4aed953496,1 +np.float64,0xffcb89b0ad371360,0xbff0000000000000,1 +np.float64,0xbfc62388b82c4710,0xbfc4547be442a38c,1 +np.float64,0x800a006d187400db,0x800a006d187400db,1 +np.float64,0x3fcef2fbd33de5f8,0x3fd18177b2150148,1 +np.float64,0x8000b74e3da16e9d,0x8000b74e3da16e9d,1 +np.float64,0x25be536e4b7cb,0x25be536e4b7cb,1 +np.float64,0x3fa86e189430dc31,0x3fa905b4684c9f01,1 +np.float64,0xa7584b114eb0a,0xa7584b114eb0a,1 +np.float64,0x800331133c866227,0x800331133c866227,1 +np.float64,0x3fb52b48142a5690,0x3fb611a6f6e7c664,1 +np.float64,0x3fe825797cf04af2,0x3ff206fd60e98116,1 +np.float64,0x3fd0bec4e5217d8a,0x3fd323db3ffd59b2,1 +np.float64,0x907b43a120f7,0x907b43a120f7,1 +np.float64,0x3fed31eb1d3a63d6,0x3ff7d7a91c6930a4,1 +np.float64,0x7f97a13d782f427a,0x7ff0000000000000,1 +np.float64,0xffc7121a702e2434,0xbff0000000000000,1 +np.float64,0xbfe8bb4cbbf1769a,0xbfe139d7f46f1fb1,1 +np.float64,0xbfe3593cc5a6b27a,0xbfdd09ec91d6cd48,1 +np.float64,0x7fcff218ff9ff,0x7fcff218ff9ff,1 +np.float64,0x3fe73651d4ae6ca4,0x3ff10c5c1d21d127,1 +np.float64,0x80054e396eaa9c74,0x80054e396eaa9c74,1 +np.float64,0x3fe527d5f9aa4fac,0x3fedfb7743db9b53,1 +np.float64,0x7fec6f28c5f8de51,0x7ff0000000000000,1 +np.float64,0x3fcd2bbff53a5780,0x3fd061987416b49b,1 +np.float64,0xffd1f0046423e008,0xbff0000000000000,1 +np.float64,0x80034d97fac69b31,0x80034d97fac69b31,1 +np.float64,0x3faa803f14350080,0x3fab32e3f8073be4,1 +np.float64,0x3fcf8da0163f1b40,0x3fd1e42ba2354c8e,1 +np.float64,0x3fd573c2632ae785,0x3fd97c37609d18d7,1 +np.float64,0x7f922960482452c0,0x7ff0000000000000,1 +np.float64,0x800ebd0c5d3d7a19,0x800ebd0c5d3d7a19,1 +np.float64,0xbfee63b7807cc76f,0xbfe39ec7981035db,1 +np.float64,0xffdc023f8e380480,0xbff0000000000000,1 +np.float64,0x3fe3ffa02c67ff40,0x3febc7f8b900ceba,1 +np.float64,0x36c508b86d8a2,0x36c508b86d8a2,1 +np.float64,0x3fc9fbb0f133f760,0x3fcccee9f6ba801c,1 +np.float64,0x3fd75c1d5faeb83b,0x3fdc3150f9eff99e,1 +np.float64,0x3fe9a8d907b351b2,0x3ff3accc78a31df8,1 +np.float64,0x3fdd8fdcafbb1fb8,0x3fe2c97c97757994,1 +np.float64,0x3fb10c34ca22186a,0x3fb1a0cc42c76b86,1 +np.float64,0xbff0000000000000,0xbfe43a54e4e98864,1 +np.float64,0xffd046aefda08d5e,0xbff0000000000000,1 +np.float64,0x80067989758cf314,0x80067989758cf314,1 +np.float64,0x3fee9d77763d3aef,0x3ff9a67ff0841ba5,1 +np.float64,0xffe4d3cbf8e9a798,0xbff0000000000000,1 +np.float64,0x800f9cab273f3956,0x800f9cab273f3956,1 +np.float64,0x800a5c84f9f4b90a,0x800a5c84f9f4b90a,1 +np.float64,0x4fd377009fa8,0x4fd377009fa8,1 +np.float64,0xbfe7ba26af6f744e,0xbfe0c13ce45d6f95,1 +np.float64,0x609c8a86c1392,0x609c8a86c1392,1 +np.float64,0x7fe4d0296ea9a052,0x7ff0000000000000,1 +np.float64,0x59847bccb3090,0x59847bccb3090,1 +np.float64,0xbfdf944157bf2882,0xbfd8ed092bacad43,1 +np.float64,0xbfe7560a632eac15,0xbfe091405ec34973,1 +np.float64,0x3fea0699f4340d34,0x3ff415eb72089230,1 +np.float64,0x800a5533f374aa68,0x800a5533f374aa68,1 +np.float64,0xbf8e8cdb103d19c0,0xbf8e52cffcb83774,1 +np.float64,0x3fe87d9e52f0fb3d,0x3ff2653952344b81,1 +np.float64,0x7fca3950f73472a1,0x7ff0000000000000,1 +np.float64,0xffd5d1068aaba20e,0xbff0000000000000,1 +np.float64,0x3fd1a5f169a34be4,0x3fd4524b6ef17f91,1 +np.float64,0x3fdc4b95a8b8972c,0x3fe1caafd8652bf7,1 +np.float64,0x3fe333f65a6667ed,0x3fea502fb1f8a578,1 +np.float64,0xbfc117aaac222f54,0xbfc00018a4b84b6e,1 +np.float64,0x7fecf2efdf39e5df,0x7ff0000000000000,1 +np.float64,0x4e99d83e9d33c,0x4e99d83e9d33c,1 +np.float64,0x800d18937bda3127,0x800d18937bda3127,1 +np.float64,0x3fd6c67778ad8cef,0x3fdb5aba70a3ea9e,1 +np.float64,0x3fdbb71770b76e2f,0x3fe157ae8da20bc5,1 +np.float64,0xbfe9faf6ebf3f5ee,0xbfe1ca963d83f17f,1 +np.float64,0x80038850ac0710a2,0x80038850ac0710a2,1 +np.float64,0x8006beb72f8d7d6f,0x8006beb72f8d7d6f,1 +np.float64,0x3feead67bffd5acf,0x3ff9bb43e8b15e2f,1 +np.float64,0xbfd1174b89222e98,0xbfcdff9972799907,1 +np.float64,0x7fee2c077cfc580e,0x7ff0000000000000,1 +np.float64,0xbfbdbd904e3b7b20,0xbfbc13f4916ed466,1 +np.float64,0xffee47b8fe3c8f71,0xbff0000000000000,1 +np.float64,0xffd161884222c310,0xbff0000000000000,1 +np.float64,0xbfd42f27c4a85e50,0xbfd14fa8d67ba5ee,1 +np.float64,0x7fefffffffffffff,0x7ff0000000000000,1 +np.float64,0x8008151791b02a30,0x8008151791b02a30,1 +np.float64,0xbfba79029234f208,0xbfb926616cf41755,1 +np.float64,0x8004c486be29890e,0x8004c486be29890e,1 +np.float64,0x7fe5325a252a64b3,0x7ff0000000000000,1 +np.float64,0x5a880f04b5103,0x5a880f04b5103,1 +np.float64,0xbfe6f4b7702de96f,0xbfe06209002dd72c,1 +np.float64,0xbfdf8b3739bf166e,0xbfd8e783efe3c30f,1 +np.float64,0xbfe32571c8e64ae4,0xbfdcd128b9aa49a1,1 +np.float64,0xbfe97c98c172f932,0xbfe1920ac0fc040f,1 +np.float64,0x3fd0b513a2a16a28,0x3fd31744e3a1bf0a,1 +np.float64,0xffe3ab70832756e0,0xbff0000000000000,1 +np.float64,0x80030f055ce61e0b,0x80030f055ce61e0b,1 +np.float64,0xffd5f3b21b2be764,0xbff0000000000000,1 +np.float64,0x800c1f2d6c783e5b,0x800c1f2d6c783e5b,1 +np.float64,0x80075f4f148ebe9f,0x80075f4f148ebe9f,1 +np.float64,0xbfa5a046f42b4090,0xbfa52cfbf8992256,1 +np.float64,0xffd6702583ace04c,0xbff0000000000000,1 +np.float64,0x800dc0a5cf1b814c,0x800dc0a5cf1b814c,1 +np.float64,0x14f2203a29e45,0x14f2203a29e45,1 +np.float64,0x800421a40ee84349,0x800421a40ee84349,1 +np.float64,0xbfea7c279df4f84f,0xbfe2037fff3ed877,1 +np.float64,0xbfe9b41ddcf3683c,0xbfe1aafe18a44bf8,1 +np.float64,0xffe7b037022f606e,0xbff0000000000000,1 +np.float64,0x800bafb648775f6d,0x800bafb648775f6d,1 +np.float64,0x800b81681d5702d1,0x800b81681d5702d1,1 +np.float64,0x3fe29f8dc8653f1c,0x3fe9442da1c32c6b,1 +np.float64,0xffef9a05dc7f340b,0xbff0000000000000,1 +np.float64,0x800c8c65a65918cb,0x800c8c65a65918cb,1 +np.float64,0xffe99df0d5f33be1,0xbff0000000000000,1 +np.float64,0x9afeb22535fd7,0x9afeb22535fd7,1 +np.float64,0x7fc620dd822c41ba,0x7ff0000000000000,1 +np.float64,0x29c2cdf25385b,0x29c2cdf25385b,1 +np.float64,0x2d92284e5b246,0x2d92284e5b246,1 +np.float64,0xffc794aa942f2954,0xbff0000000000000,1 +np.float64,0xbfe7ed907eafdb21,0xbfe0d9a7b1442497,1 +np.float64,0xbfd4e0d4aea9c1aa,0xbfd1d09366dba2a7,1 +np.float64,0xa70412c34e083,0xa70412c34e083,1 +np.float64,0x41dc0ee083b9,0x41dc0ee083b9,1 +np.float64,0x8000ece20da1d9c5,0x8000ece20da1d9c5,1 +np.float64,0x3fdf3dae103e7b5c,0x3fe42314bf826bc5,1 +np.float64,0x3fe972533c72e4a6,0x3ff3703761e70f04,1 +np.float64,0xffba1d2b82343a58,0xbff0000000000000,1 +np.float64,0xe0086c83c010e,0xe0086c83c010e,1 +np.float64,0x3fe6fb0dde6df61c,0x3ff0cf5fae01aa08,1 +np.float64,0x3fcfaf057e3f5e0b,0x3fd1f98c1fd20139,1 +np.float64,0xbfdca19d9239433c,0xbfd7158745192ca9,1 +np.float64,0xffb17f394e22fe70,0xbff0000000000000,1 +np.float64,0x7fe40f05c7681e0b,0x7ff0000000000000,1 +np.float64,0x800b3c575d5678af,0x800b3c575d5678af,1 +np.float64,0x7fa4ab20ac295640,0x7ff0000000000000,1 +np.float64,0xbfd2fff4f6a5ffea,0xbfd07069bb50e1a6,1 +np.float64,0xbfef81b9147f0372,0xbfe40b845a749787,1 +np.float64,0x7fd7400e54ae801c,0x7ff0000000000000,1 +np.float64,0x3fd4401a17a88034,0x3fd7d20fb76a4f3d,1 +np.float64,0xbfd3e907fd27d210,0xbfd11c64b7577fc5,1 +np.float64,0x7fe34bed9ae697da,0x7ff0000000000000,1 +np.float64,0x80039119c0472234,0x80039119c0472234,1 +np.float64,0xbfe2e36ac565c6d6,0xbfdc88454ee997b3,1 +np.float64,0xbfec57204478ae40,0xbfe2cd3183de1d2d,1 +np.float64,0x7fed7e2a12fafc53,0x7ff0000000000000,1 +np.float64,0x7fd5c5fa7d2b8bf4,0x7ff0000000000000,1 +np.float64,0x3fdcf368d6b9e6d0,0x3fe24decce1ebd35,1 +np.float64,0xbfe0ebfcf2e1d7fa,0xbfda48c9247ae8cf,1 +np.float64,0xbfe10dbea2e21b7e,0xbfda707d68b59674,1 +np.float64,0xbfdf201b6ebe4036,0xbfd8a5df27742fdf,1 +np.float64,0xffe16555be62caab,0xbff0000000000000,1 +np.float64,0xffc23a5db22474bc,0xbff0000000000000,1 +np.float64,0xffe1cbb3f8a39768,0xbff0000000000000,1 +np.float64,0x8007b823be0f7048,0x8007b823be0f7048,1 +np.float64,0xbfa5d1f3042ba3e0,0xbfa55c97cd77bf6e,1 +np.float64,0xbfe316a074662d41,0xbfdcc0da4e7334d0,1 +np.float64,0xbfdfab2bf2bf5658,0xbfd8fb046b88b51f,1 +np.float64,0xfacc9dabf5994,0xfacc9dabf5994,1 +np.float64,0xffe7e420a4efc841,0xbff0000000000000,1 +np.float64,0x800bb986cd57730e,0x800bb986cd57730e,1 +np.float64,0xbfe314fa38e629f4,0xbfdcbf09302c3bf5,1 +np.float64,0x7fc56b17772ad62e,0x7ff0000000000000,1 +np.float64,0x8006a87d54ad50fb,0x8006a87d54ad50fb,1 +np.float64,0xbfe6633e4a6cc67c,0xbfe01a67c3b3ff32,1 +np.float64,0x3fe0ff56eb21feae,0x3fe66df01defb0fb,1 +np.float64,0xffc369cfc126d3a0,0xbff0000000000000,1 +np.float64,0x7fe8775d9a30eeba,0x7ff0000000000000,1 +np.float64,0x3fb53db13e2a7b60,0x3fb625a7279cdac3,1 +np.float64,0xffee76e7e6fcedcf,0xbff0000000000000,1 +np.float64,0xb45595b568ab3,0xb45595b568ab3,1 +np.float64,0xffa09a1d50213440,0xbff0000000000000,1 +np.float64,0x7d11dc16fa23c,0x7d11dc16fa23c,1 +np.float64,0x7fd4cc2928299851,0x7ff0000000000000,1 +np.float64,0x6a30e0ead461d,0x6a30e0ead461d,1 +np.float64,0x7fd3ee735a27dce6,0x7ff0000000000000,1 +np.float64,0x8008d7084b31ae11,0x8008d7084b31ae11,1 +np.float64,0x3fe469353fe8d26a,0x3fec8e7e2df38590,1 +np.float64,0x3fcecef2743d9de5,0x3fd16a888b715dfd,1 +np.float64,0x460130d68c027,0x460130d68c027,1 +np.float64,0xbfd76510c62eca22,0xbfd398766b741d6e,1 +np.float64,0x800ec88c2a5d9118,0x800ec88c2a5d9118,1 +np.float64,0x3fac969c6c392d40,0x3fad66ca6a1e583c,1 +np.float64,0x3fe5c616bf6b8c2e,0x3fef30f931e8dde5,1 +np.float64,0xb4cb6cd56996e,0xb4cb6cd56996e,1 +np.float64,0xffc3eacf8827d5a0,0xbff0000000000000,1 +np.float64,0x3fe1ceaf60e39d5f,0x3fe7d31e0a627cf9,1 +np.float64,0xffea69b42ff4d368,0xbff0000000000000,1 +np.float64,0x800ff8aef99ff15e,0x800ff8aef99ff15e,1 +np.float64,0x6c3953f0d872b,0x6c3953f0d872b,1 +np.float64,0x8007ca5a0d0f94b5,0x8007ca5a0d0f94b5,1 +np.float64,0x800993ce3ad3279d,0x800993ce3ad3279d,1 +np.float64,0x3fe5a4d1516b49a2,0x3feeef67b22ac65b,1 +np.float64,0x8003d7512a67aea3,0x8003d7512a67aea3,1 +np.float64,0x33864430670c9,0x33864430670c9,1 +np.float64,0xbfdbf477e3b7e8f0,0xbfd6a63f1b36f424,1 +np.float64,0x3fb5da92582bb525,0x3fb6d04ef1a1d31a,1 +np.float64,0xe38aae71c7156,0xe38aae71c7156,1 +np.float64,0x3fcaf5590a35eab2,0x3fce01ed6eb6188e,1 +np.float64,0x800deba9b05bd754,0x800deba9b05bd754,1 +np.float64,0x7fee0cde287c19bb,0x7ff0000000000000,1 +np.float64,0xbfe0c2ae70e1855d,0xbfda17fa64d84fcf,1 +np.float64,0x518618faa30c4,0x518618faa30c4,1 +np.float64,0xbfeb4c49b8769894,0xbfe25d52cd7e529f,1 +np.float64,0xbfeb3aa21b367544,0xbfe255cae1df4cfd,1 +np.float64,0xffd23f1c5d247e38,0xbff0000000000000,1 +np.float64,0xff9a75132034ea20,0xbff0000000000000,1 +np.float64,0xbfef9d96307f3b2c,0xbfe415e8b6ce0e50,1 +np.float64,0x8004046f2f0808df,0x8004046f2f0808df,1 +np.float64,0x3fe15871aea2b0e3,0x3fe706532ea5c770,1 +np.float64,0x7fd86b1576b0d62a,0x7ff0000000000000,1 +np.float64,0xbfc240a5c724814c,0xbfc102c7971ca455,1 +np.float64,0xffd8ea670bb1d4ce,0xbff0000000000000,1 +np.float64,0xbfeb1ddd1ff63bba,0xbfe2497c4e27bb8e,1 +np.float64,0x3fcd47e0a33a8fc1,0x3fd0734444150d83,1 +np.float64,0xe00b6a65c016e,0xe00b6a65c016e,1 +np.float64,0xbfc7d582142fab04,0xbfc5bf1fbe755a4c,1 +np.float64,0x8cc91ca11993,0x8cc91ca11993,1 +np.float64,0x7fdbc530e3b78a61,0x7ff0000000000000,1 +np.float64,0x7fee437522bc86e9,0x7ff0000000000000,1 +np.float64,0xffe9e09ae2b3c135,0xbff0000000000000,1 +np.float64,0x8002841cada5083a,0x8002841cada5083a,1 +np.float64,0x3fd6b485f8ad690c,0x3fdb412135932699,1 +np.float64,0x80070e8d0b0e1d1b,0x80070e8d0b0e1d1b,1 +np.float64,0x7fed5df165babbe2,0x7ff0000000000000,1 +np.float64,0x7ff4000000000000,0x7ffc000000000000,1 +np.float64,0x7fe99d08cd333a11,0x7ff0000000000000,1 +np.float64,0xdfff4201bfff,0xdfff4201bfff,1 +np.float64,0x800ccf7aaf999ef6,0x800ccf7aaf999ef6,1 +np.float64,0x3fddb05aad3b60b5,0x3fe2e34bdd1dd9d5,1 +np.float64,0xbfe5e1c60e6bc38c,0xbfdfb3275cc1675f,1 +np.float64,0x8004fe674269fccf,0x8004fe674269fccf,1 +np.float64,0x7fe9280363325006,0x7ff0000000000000,1 +np.float64,0xf605b9f1ec0b7,0xf605b9f1ec0b7,1 +np.float64,0x800c7c214018f843,0x800c7c214018f843,1 +np.float64,0x7fd97eb6b9b2fd6c,0x7ff0000000000000,1 +np.float64,0x7fd03f8fb6207f1e,0x7ff0000000000000,1 +np.float64,0x7fc526b64d2a4d6c,0x7ff0000000000000,1 +np.float64,0xbfef1a7c42fe34f9,0xbfe3e4b4399e0fcf,1 +np.float64,0xffdde10a2fbbc214,0xbff0000000000000,1 +np.float64,0xbfdd274f72ba4e9e,0xbfd76aa73788863c,1 +np.float64,0xbfecf7f77af9efef,0xbfe30ee2ae03fed1,1 +np.float64,0xffde709322bce126,0xbff0000000000000,1 +np.float64,0x268b5dac4d16d,0x268b5dac4d16d,1 +np.float64,0x8005c099606b8134,0x8005c099606b8134,1 +np.float64,0xffcf54c1593ea984,0xbff0000000000000,1 +np.float64,0xbfee9b8ebabd371d,0xbfe3b44f2663139d,1 +np.float64,0x3faf0330643e0661,0x3faff88fab74b447,1 +np.float64,0x7fe1c6011be38c01,0x7ff0000000000000,1 +np.float64,0xbfe9d58053b3ab01,0xbfe1b9ea12242485,1 +np.float64,0xbfe15a80fee2b502,0xbfdaca2aa7d1231a,1 +np.float64,0x7fe0d766d8a1aecd,0x7ff0000000000000,1 +np.float64,0x800f65e6a21ecbcd,0x800f65e6a21ecbcd,1 +np.float64,0x7fc85e45a530bc8a,0x7ff0000000000000,1 +np.float64,0x3fcc240e5438481d,0x3fcf7954fc080ac3,1 +np.float64,0xffddd49da2bba93c,0xbff0000000000000,1 +np.float64,0x1376f36c26edf,0x1376f36c26edf,1 +np.float64,0x3feffb7af17ff6f6,0x3ffb77f0ead2f881,1 +np.float64,0x3fd9354ea9b26a9d,0x3fdee4e4c8db8239,1 +np.float64,0xffdf7beed4bef7de,0xbff0000000000000,1 +np.float64,0xbfdef256ecbde4ae,0xbfd889b0e213a019,1 +np.float64,0x800d78bd1e7af17a,0x800d78bd1e7af17a,1 +np.float64,0xb66d66276cdad,0xb66d66276cdad,1 +np.float64,0x7fd8f51138b1ea21,0x7ff0000000000000,1 +np.float64,0xffe8c9c302b19385,0xbff0000000000000,1 +np.float64,0x8000be4cf5417c9b,0x8000be4cf5417c9b,1 +np.float64,0xbfe2293a25645274,0xbfdbb78a8c547c68,1 +np.float64,0xce8392c19d08,0xce8392c19d08,1 +np.float64,0xbfe075736b60eae7,0xbfd9bc0f6e34a283,1 +np.float64,0xbfe8d6fe6a71adfd,0xbfe1469ba80b4915,1 +np.float64,0xffe0c7993fa18f32,0xbff0000000000000,1 +np.float64,0x3fce5210fd3ca422,0x3fd11b40a1270a95,1 +np.float64,0x6c0534a8d80a7,0x6c0534a8d80a7,1 +np.float64,0x23c1823647831,0x23c1823647831,1 +np.float64,0x3fc901253732024a,0x3fcb9d264accb07c,1 +np.float64,0x3fe42b8997685714,0x3fec1a39e207b6e4,1 +np.float64,0x3fec4fd00fb89fa0,0x3ff6c1fdd0c262c8,1 +np.float64,0x8007b333caaf6668,0x8007b333caaf6668,1 +np.float64,0x800f9275141f24ea,0x800f9275141f24ea,1 +np.float64,0xffbba361a23746c0,0xbff0000000000000,1 +np.float64,0xbfee4effa9fc9dff,0xbfe396c11d0cd524,1 +np.float64,0x3e47e84c7c8fe,0x3e47e84c7c8fe,1 +np.float64,0x3fe80eb7b1301d6f,0x3ff1eed318a00153,1 +np.float64,0x7fd3f4c5b4a7e98a,0x7ff0000000000000,1 +np.float64,0x158abab02b158,0x158abab02b158,1 +np.float64,0x1,0x1,1 +np.float64,0x1f1797883e2f4,0x1f1797883e2f4,1 +np.float64,0x3feec055d03d80ac,0x3ff9d3fb0394de33,1 +np.float64,0x8010000000000000,0x8010000000000000,1 +np.float64,0xbfd070860ea0e10c,0xbfccfeec2828efef,1 +np.float64,0x80015c8b3e82b917,0x80015c8b3e82b917,1 +np.float64,0xffef9956d9ff32ad,0xbff0000000000000,1 +np.float64,0x7fe7f087dd2fe10f,0x7ff0000000000000,1 +np.float64,0x8002e7718665cee4,0x8002e7718665cee4,1 +np.float64,0x3fdfb9adb2bf735c,0x3fe4887a86214c1e,1 +np.float64,0xffc7747dfb2ee8fc,0xbff0000000000000,1 +np.float64,0x3fec309bb5386137,0x3ff69c44e1738547,1 +np.float64,0xffdbe2bf9ab7c580,0xbff0000000000000,1 +np.float64,0xbfe6a274daed44ea,0xbfe039aff2be9d48,1 +np.float64,0x7fd5a4e4efab49c9,0x7ff0000000000000,1 +np.float64,0xffbe6aaeb03cd560,0xbff0000000000000,1 diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/data/umath-validation-set-log.csv b/venv/lib/python3.12/site-packages/numpy/_core/tests/data/umath-validation-set-log.csv new file mode 100644 index 00000000..b8f6b087 --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/tests/data/umath-validation-set-log.csv @@ -0,0 +1,271 @@ +dtype,input,output,ulperrortol +## +ve denormals ## +np.float32,0x004b4716,0xc2afbc1b,4 +np.float32,0x007b2490,0xc2aec01e,4 +np.float32,0x007c99fa,0xc2aeba17,4 +np.float32,0x00734a0c,0xc2aee1dc,4 +np.float32,0x0070de24,0xc2aeecba,4 +np.float32,0x007fffff,0xc2aeac50,4 +np.float32,0x00000001,0xc2ce8ed0,4 +## -ve denormals ## +np.float32,0x80495d65,0xffc00000,4 +np.float32,0x806894f6,0xffc00000,4 +np.float32,0x80555a76,0xffc00000,4 +np.float32,0x804e1fb8,0xffc00000,4 +np.float32,0x80687de9,0xffc00000,4 +np.float32,0x807fffff,0xffc00000,4 +np.float32,0x80000001,0xffc00000,4 +## +/-0.0f, +/-FLT_MIN +/-FLT_MAX ## +np.float32,0x00000000,0xff800000,4 +np.float32,0x80000000,0xff800000,4 +np.float32,0x7f7fffff,0x42b17218,4 +np.float32,0x80800000,0xffc00000,4 +np.float32,0xff7fffff,0xffc00000,4 +## 1.00f + 0x00000001 ## +np.float32,0x3f800000,0x00000000,4 +np.float32,0x3f800001,0x33ffffff,4 +np.float32,0x3f800002,0x347ffffe,4 +np.float32,0x3f7fffff,0xb3800000,4 +np.float32,0x3f7ffffe,0xb4000000,4 +np.float32,0x3f7ffffd,0xb4400001,4 +np.float32,0x402df853,0x3f7ffffe,4 +np.float32,0x402df854,0x3f7fffff,4 +np.float32,0x402df855,0x3f800000,4 +np.float32,0x402df856,0x3f800001,4 +np.float32,0x3ebc5ab0,0xbf800001,4 +np.float32,0x3ebc5ab1,0xbf800000,4 +np.float32,0x3ebc5ab2,0xbf800000,4 +np.float32,0x3ebc5ab3,0xbf7ffffe,4 +np.float32,0x423ef575,0x407768ab,4 +np.float32,0x427b8c61,0x408485dd,4 +np.float32,0x4211e9ee,0x406630b0,4 +np.float32,0x424d5c41,0x407c0fed,4 +np.float32,0x42be722a,0x4091cc91,4 +np.float32,0x42b73d30,0x4090908b,4 +np.float32,0x427e48e2,0x4084de7f,4 +np.float32,0x428f759b,0x4088bba3,4 +np.float32,0x41629069,0x4029a0cc,4 +np.float32,0x4272c99d,0x40836379,4 +np.float32,0x4d1b7458,0x4197463d,4 +np.float32,0x4f10c594,0x41ace2b2,4 +np.float32,0x4ea397c2,0x41a85171,4 +np.float32,0x4fefa9d1,0x41b6769c,4 +np.float32,0x4ebac6ab,0x41a960dc,4 +np.float32,0x4f6efb42,0x41b0e535,4 +np.float32,0x4e9ab8e7,0x41a7df44,4 +np.float32,0x4e81b5d1,0x41a67625,4 +np.float32,0x5014d9f2,0x41b832bd,4 +np.float32,0x4f02175c,0x41ac07b8,4 +np.float32,0x7f034f89,0x42b01c47,4 +np.float32,0x7f56d00e,0x42b11849,4 +np.float32,0x7f1cd5f6,0x42b0773a,4 +np.float32,0x7e979174,0x42af02d7,4 +np.float32,0x7f23369f,0x42b08ba2,4 +np.float32,0x7f0637ae,0x42b0277d,4 +np.float32,0x7efcb6e8,0x42b00897,4 +np.float32,0x7f7907c8,0x42b163f6,4 +np.float32,0x7e95c4c2,0x42aefcba,4 +np.float32,0x7f4577b2,0x42b0ed2d,4 +np.float32,0x3f49c92e,0xbe73ae84,4 +np.float32,0x3f4a23d1,0xbe71e2f8,4 +np.float32,0x3f4abb67,0xbe6ee430,4 +np.float32,0x3f48169a,0xbe7c5532,4 +np.float32,0x3f47f5fa,0xbe7cfc37,4 +np.float32,0x3f488309,0xbe7a2ad8,4 +np.float32,0x3f479df4,0xbe7ebf5f,4 +np.float32,0x3f47cfff,0xbe7dbec9,4 +np.float32,0x3f496704,0xbe75a125,4 +np.float32,0x3f478ee8,0xbe7f0c92,4 +np.float32,0x3f4a763b,0xbe7041ce,4 +np.float32,0x3f47a108,0xbe7eaf94,4 +np.float32,0x3f48136c,0xbe7c6578,4 +np.float32,0x3f481c17,0xbe7c391c,4 +np.float32,0x3f47cd28,0xbe7dcd56,4 +np.float32,0x3f478be8,0xbe7f1bf7,4 +np.float32,0x3f4c1f8e,0xbe67e367,4 +np.float32,0x3f489b0c,0xbe79b03f,4 +np.float32,0x3f4934cf,0xbe76a08a,4 +np.float32,0x3f4954df,0xbe75fd6a,4 +np.float32,0x3f47a3f5,0xbe7ea093,4 +np.float32,0x3f4ba4fc,0xbe6a4b02,4 +np.float32,0x3f47a0e1,0xbe7eb05c,4 +np.float32,0x3f48c30a,0xbe78e42f,4 +np.float32,0x3f48cab8,0xbe78bd05,4 +np.float32,0x3f4b0569,0xbe6d6ea4,4 +np.float32,0x3f47de32,0xbe7d7607,4 +np.float32,0x3f477328,0xbe7f9b00,4 +np.float32,0x3f496dab,0xbe757f52,4 +np.float32,0x3f47662c,0xbe7fddac,4 +np.float32,0x3f48ddd8,0xbe785b80,4 +np.float32,0x3f481866,0xbe7c4bff,4 +np.float32,0x3f48b119,0xbe793fb6,4 +np.float32,0x3f48c7e8,0xbe78cb5c,4 +np.float32,0x3f4985f6,0xbe7503da,4 +np.float32,0x3f483fdf,0xbe7b8212,4 +np.float32,0x3f4b1c76,0xbe6cfa67,4 +np.float32,0x3f480b2e,0xbe7c8fa8,4 +np.float32,0x3f48745f,0xbe7a75bf,4 +np.float32,0x3f485bda,0xbe7af308,4 +np.float32,0x3f47a660,0xbe7e942c,4 +np.float32,0x3f47d4d5,0xbe7da600,4 +np.float32,0x3f4b0a26,0xbe6d56be,4 +np.float32,0x3f4a4883,0xbe712924,4 +np.float32,0x3f4769e7,0xbe7fca84,4 +np.float32,0x3f499702,0xbe74ad3f,4 +np.float32,0x3f494ab1,0xbe763131,4 +np.float32,0x3f476b69,0xbe7fc2c6,4 +np.float32,0x3f4884e8,0xbe7a214a,4 +np.float32,0x3f486945,0xbe7aae76,4 +#float64 +## +ve denormal ## +np.float64,0x0000000000000001,0xc0874385446d71c3,1 +np.float64,0x0001000000000000,0xc086395a2079b70c,1 +np.float64,0x000fffffffffffff,0xc086232bdd7abcd2,1 +np.float64,0x0007ad63e2168cb6,0xc086290bc0b2980f,1 +## -ve denormal ## +np.float64,0x8000000000000001,0xfff8000000000001,1 +np.float64,0x8001000000000000,0xfff8000000000001,1 +np.float64,0x800fffffffffffff,0xfff8000000000001,1 +np.float64,0x8007ad63e2168cb6,0xfff8000000000001,1 +## +/-0.0f, MAX, MIN## +np.float64,0x0000000000000000,0xfff0000000000000,1 +np.float64,0x8000000000000000,0xfff0000000000000,1 +np.float64,0x7fefffffffffffff,0x40862e42fefa39ef,1 +np.float64,0xffefffffffffffff,0xfff8000000000001,1 +## near 1.0f ## +np.float64,0x3ff0000000000000,0x0000000000000000,1 +np.float64,0x3fe8000000000000,0xbfd269621134db92,1 +np.float64,0x3ff0000000000001,0x3cafffffffffffff,1 +np.float64,0x3ff0000020000000,0x3e7fffffe000002b,1 +np.float64,0x3ff0000000000001,0x3cafffffffffffff,1 +np.float64,0x3fefffffe0000000,0xbe70000008000005,1 +np.float64,0x3fefffffffffffff,0xbca0000000000000,1 +## random numbers ## +np.float64,0x02500186f3d9da56,0xc0855b8abf135773,1 +np.float64,0x09200815a3951173,0xc082ff1ad7131bdc,1 +np.float64,0x0da029623b0243d4,0xc0816fc994695bb5,1 +np.float64,0x48703b8ac483a382,0x40579213a313490b,1 +np.float64,0x09207b74c87c9860,0xc082fee20ff349ef,1 +np.float64,0x62c077698e8df947,0x407821c996d110f0,1 +np.float64,0x2350b45e87c3cfb0,0xc073d6b16b51d072,1 +np.float64,0x3990a23f9ff2b623,0xc051aa60eadd8c61,1 +np.float64,0x0d011386a116c348,0xc081a6cc7ea3b8fb,1 +np.float64,0x1fe0f0303ebe273a,0xc0763870b78a81ca,1 +np.float64,0x0cd1260121d387da,0xc081b7668d61a9d1,1 +np.float64,0x1e6135a8f581d422,0xc077425ac10f08c2,1 +np.float64,0x622168db5fe52d30,0x4077b3c669b9fadb,1 +np.float64,0x69f188e1ec6d1718,0x407d1e2f18c63889,1 +np.float64,0x3aa1bf1d9c4dd1a3,0xc04d682e24bde479,1 +np.float64,0x6c81c4011ce4f683,0x407ee5190e8a8e6a,1 +np.float64,0x2191fa55aa5a5095,0xc0750c0c318b5e2d,1 +np.float64,0x32a1f602a32bf360,0xc06270caa493fc17,1 +np.float64,0x16023c90ba93249b,0xc07d0f88e0801638,1 +np.float64,0x1c525fe6d71fa9ff,0xc078af49c66a5d63,1 +np.float64,0x1a927675815d65b7,0xc079e5bdd7fe376e,1 +np.float64,0x41227b8fe70da028,0x402aa0c9f9a84c71,1 +np.float64,0x4962bb6e853fe87d,0x405a34aa04c83747,1 +np.float64,0x23d2cda00b26b5a4,0xc0737c13a06d00ea,1 +np.float64,0x2d13083fd62987fa,0xc06a25055aeb474e,1 +np.float64,0x10e31e4c9b4579a1,0xc0804e181929418e,1 +np.float64,0x26d3247d556a86a9,0xc0716774171da7e8,1 +np.float64,0x6603379398d0d4ac,0x407a64f51f8a887b,1 +np.float64,0x02d38af17d9442ba,0xc0852d955ac9dd68,1 +np.float64,0x6a2382b4818dd967,0x407d4129d688e5d4,1 +np.float64,0x2ee3c403c79b3934,0xc067a091fefaf8b6,1 +np.float64,0x6493a699acdbf1a4,0x4079663c8602bfc5,1 +np.float64,0x1c8413c4f0de3100,0xc0788c99697059b6,1 +np.float64,0x4573f1ed350d9622,0x404e9bd1e4c08920,1 +np.float64,0x2f34265c9200b69c,0xc067310cfea4e986,1 +np.float64,0x19b43e65fa22029b,0xc07a7f8877de22d6,1 +np.float64,0x0af48ab7925ed6bc,0xc0825c4fbc0e5ade,1 +np.float64,0x4fa49699cad82542,0x4065c76d2a318235,1 +np.float64,0x7204a15e56ade492,0x40815bb87484dffb,1 +np.float64,0x4734aa08a230982d,0x40542a4bf7a361a9,1 +np.float64,0x1ae4ed296c2fd749,0xc079ac4921f20abb,1 +np.float64,0x472514ea4370289c,0x4053ff372bd8f18f,1 +np.float64,0x53a54b3f73820430,0x406b5411fc5f2e33,1 +np.float64,0x64754de5a15684fa,0x407951592e99a5ab,1 +np.float64,0x69358e279868a7c3,0x407c9c671a882c31,1 +np.float64,0x284579ec61215945,0xc0706688e55f0927,1 +np.float64,0x68b5c58806447adc,0x407c43d6f4eff760,1 +np.float64,0x1945a83f98b0e65d,0xc07acc15eeb032cc,1 +np.float64,0x0fc5eb98a16578bf,0xc080b0d02eddca0e,1 +np.float64,0x6a75e208f5784250,0x407d7a7383bf8f05,1 +np.float64,0x0fe63a029c47645d,0xc080a59ca1e98866,1 +np.float64,0x37963ac53f065510,0xc057236281f7bdb6,1 +np.float64,0x135661bb07067ff7,0xc07ee924930c21e4,1 +np.float64,0x4b4699469d458422,0x405f73843756e887,1 +np.float64,0x1a66d73e4bf4881b,0xc07a039ba1c63adf,1 +np.float64,0x12a6b9b119a7da59,0xc07f62e49c6431f3,1 +np.float64,0x24c719aa8fd1bdb5,0xc072d26da4bf84d3,1 +np.float64,0x0fa6ff524ffef314,0xc080bb8514662e77,1 +np.float64,0x1db751d66fdd4a9a,0xc077b77cb50d7c92,1 +np.float64,0x4947374c516da82c,0x4059e9acfc7105bf,1 +np.float64,0x1b1771ab98f3afc8,0xc07989326b8e1f66,1 +np.float64,0x25e78805baac8070,0xc0720a818e6ef080,1 +np.float64,0x4bd7a148225d3687,0x406082d004ea3ee7,1 +np.float64,0x53d7d6b2bbbda00a,0x406b9a398967cbd5,1 +np.float64,0x6997fb9f4e1c685f,0x407ce0a703413eba,1 +np.float64,0x069802c2ff71b951,0xc083df39bf7acddc,1 +np.float64,0x4d683ac9890f66d8,0x4062ae21d8c2acf0,1 +np.float64,0x5a2825863ec14f4c,0x40722d718d549552,1 +np.float64,0x0398799a88f4db80,0xc084e93dab8e2158,1 +np.float64,0x5ed87a8b77e135a5,0x40756d7051777b33,1 +np.float64,0x5828cd6d79b9bede,0x4070cafb22fc6ca1,1 +np.float64,0x7b18ba2a5ec6f068,0x408481386b3ed6fe,1 +np.float64,0x4938fd60922198fe,0x4059c206b762ea7e,1 +np.float64,0x31b8f44fcdd1a46e,0xc063b2faa8b6434e,1 +np.float64,0x5729341c0d918464,0x407019cac0c4a7d7,1 +np.float64,0x13595e9228ee878e,0xc07ee7235a7d8088,1 +np.float64,0x17698b0dc9dd4135,0xc07c1627e3a5ad5f,1 +np.float64,0x63b977c283abb0cc,0x4078cf1ec6ed65be,1 +np.float64,0x7349cc0d4dc16943,0x4081cc697ce4cb53,1 +np.float64,0x4e49a80b732fb28d,0x4063e67e3c5cbe90,1 +np.float64,0x07ba14b848a8ae02,0xc0837ac032a094e0,1 +np.float64,0x3da9f17b691bfddc,0xc03929c25366acda,1 +np.float64,0x02ea39aa6c3ac007,0xc08525af6f21e1c4,1 +np.float64,0x3a6a42f04ed9563d,0xc04e98e825dca46b,1 +np.float64,0x1afa877cd7900be7,0xc0799d6648cb34a9,1 +np.float64,0x58ea986649e052c6,0x4071512e939ad790,1 +np.float64,0x691abbc04647f536,0x407c89aaae0fcb83,1 +np.float64,0x43aabc5063e6f284,0x4044b45d18106fd2,1 +np.float64,0x488b003c893e0bea,0x4057df012a2dafbe,1 +np.float64,0x77eb076ed67caee5,0x40836720de94769e,1 +np.float64,0x5c1b46974aba46f4,0x40738731ba256007,1 +np.float64,0x1a5b29ecb5d3c261,0xc07a0becc77040d6,1 +np.float64,0x5d8b6ccf868c6032,0x4074865c1865e2db,1 +np.float64,0x4cfb6690b4aaf5af,0x406216cd8c7e8ddb,1 +np.float64,0x76cbd8eb5c5fc39e,0x4083038dc66d682b,1 +np.float64,0x28bbd1fec5012814,0xc07014c2dd1b9711,1 +np.float64,0x33dc1b3a4fd6bf7a,0xc060bd0756e07d8a,1 +np.float64,0x52bbe89b37de99f3,0x406a10041aa7d343,1 +np.float64,0x07bc479d15eb2dd3,0xc0837a1a6e3a3b61,1 +np.float64,0x18fc5275711a901d,0xc07aff3e9d62bc93,1 +np.float64,0x114c9758e247dc71,0xc080299a7cf15b05,1 +np.float64,0x25ac8f6d60755148,0xc07233c4c0c511d4,1 +np.float64,0x260cae2bb9e9fd7e,0xc071f128c7e82eac,1 +np.float64,0x572ccdfe0241de82,0x40701bedc84bb504,1 +np.float64,0x0ddcef6c8d41f5ee,0xc0815a7e16d07084,1 +np.float64,0x6dad1d59c988af68,0x407fb4a0bc0142b1,1 +np.float64,0x025d200580d8b6d1,0xc08556c0bc32b1b2,1 +np.float64,0x7aad344b6aa74c18,0x40845bbc453f22be,1 +np.float64,0x5b5d9d6ad9d14429,0x4073036d2d21f382,1 +np.float64,0x49cd8d8dcdf19954,0x405b5c034f5c7353,1 +np.float64,0x63edb9483335c1e6,0x4078f2dd21378786,1 +np.float64,0x7b1dd64c9d2c26bd,0x408482b922017bc9,1 +np.float64,0x782e13e0b574be5f,0x40837e2a0090a5ad,1 +np.float64,0x592dfe18b9d6db2f,0x40717f777fbcb1ec,1 +np.float64,0x654e3232ac60d72c,0x4079e71a95a70446,1 +np.float64,0x7b8e42ad22091456,0x4084a9a6f1e61722,1 +np.float64,0x570e88dfd5860ae6,0x407006ae6c0d137a,1 +np.float64,0x294e98346cb98ef1,0xc06f5edaac12bd44,1 +np.float64,0x1adeaa4ab792e642,0xc079b1431d5e2633,1 +np.float64,0x7b6ead3377529ac8,0x40849eabc8c7683c,1 +np.float64,0x2b8eedae8a9b2928,0xc06c400054deef11,1 +np.float64,0x65defb45b2dcf660,0x407a4b53f181c05a,1 +np.float64,0x1baf582d475e7701,0xc07920bcad4a502c,1 +np.float64,0x461f39cf05a0f15a,0x405126368f984fa1,1 +np.float64,0x7e5f6f5dcfff005b,0x4085a37d610439b4,1 +np.float64,0x136f66e4d09bd662,0xc07ed8a2719f2511,1 +np.float64,0x65afd8983fb6ca1f,0x407a2a7f48bf7fc1,1 +np.float64,0x572fa7f95ed22319,0x40701d706cf82e6f,1 diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/data/umath-validation-set-log10.csv b/venv/lib/python3.12/site-packages/numpy/_core/tests/data/umath-validation-set-log10.csv new file mode 100644 index 00000000..c7657773 --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/tests/data/umath-validation-set-log10.csv @@ -0,0 +1,1629 @@ +dtype,input,output,ulperrortol +np.float32,0x3f6fd5c8,0xbce80e8e,4 +np.float32,0x3ea4ab17,0xbefc3deb,4 +np.float32,0x3e87a133,0xbf13b0b7,4 +np.float32,0x3f0d9069,0xbe83bb19,4 +np.float32,0x3f7b9269,0xbbf84f47,4 +np.float32,0x3f7a9ffa,0xbc16fd97,4 +np.float32,0x7f535d34,0x4219cb66,4 +np.float32,0x3e79ad7c,0xbf1ce857,4 +np.float32,0x7e8bfd3b,0x4217dfe9,4 +np.float32,0x3f2d2ee9,0xbe2dcec6,4 +np.float32,0x572e04,0xc21862e4,4 +np.float32,0x7f36f8,0xc217bad5,4 +np.float32,0x3f7982fb,0xbc36aaed,4 +np.float32,0x45b019,0xc218c67c,4 +np.float32,0x3f521c46,0xbdafb3e3,4 +np.float32,0x80000001,0x7fc00000,4 +np.float32,0x3f336c81,0xbe1e107f,4 +np.float32,0x3eac92d7,0xbef1d0bb,4 +np.float32,0x47bdfc,0xc218b990,4 +np.float32,0x7f2d94c8,0x421973d1,4 +np.float32,0x7d53ff8d,0x4214fbb6,4 +np.float32,0x3f581e4e,0xbd96a079,4 +np.float32,0x7ddaf20d,0x42163e4e,4 +np.float32,0x3f341d3c,0xbe1c5b4c,4 +np.float32,0x7ef04ba9,0x4218d032,4 +np.float32,0x620ed2,0xc2182e99,4 +np.float32,0x507850,0xc2188682,4 +np.float32,0x7d08f9,0xc217c284,4 +np.float32,0x7f0cf2aa,0x42191734,4 +np.float32,0x3f109a17,0xbe7e04fe,4 +np.float32,0x7f426152,0x4219a625,4 +np.float32,0x7f32d5a3,0x42198113,4 +np.float32,0x2e14b2,0xc2197e6f,4 +np.float32,0x3a5acd,0xc219156a,4 +np.float32,0x50a565,0xc2188589,4 +np.float32,0x5b751c,0xc2184d97,4 +np.float32,0x7e4149f6,0x42173b22,4 +np.float32,0x3dc34bf9,0xbf82a42a,4 +np.float32,0x3d12bc28,0xbfb910d6,4 +np.float32,0x7ebd2584,0x421865c1,4 +np.float32,0x7f6b3375,0x4219faeb,4 +np.float32,0x7fa00000,0x7fe00000,4 +np.float32,0x3f35fe7d,0xbe17bd33,4 +np.float32,0x7db45c87,0x4215e818,4 +np.float32,0x3efff366,0xbe9a2b8d,4 +np.float32,0x3eb331d0,0xbee971a3,4 +np.float32,0x3f259d5f,0xbe41ae2e,4 +np.float32,0x3eab85ec,0xbef32c4a,4 +np.float32,0x7f194b8a,0x42193c8c,4 +np.float32,0x3f11a614,0xbe7acfc7,4 +np.float32,0x5b17,0xc221f16b,4 +np.float32,0x3f33dadc,0xbe1cff4d,4 +np.float32,0x3cda1506,0xbfc9920f,4 +np.float32,0x3f6856f1,0xbd2c8290,4 +np.float32,0x7f3357fb,0x42198257,4 +np.float32,0x7f56f329,0x4219d2e1,4 +np.float32,0x3ef84108,0xbea0f595,4 +np.float32,0x3f72340f,0xbcc51916,4 +np.float32,0x3daf28,0xc218fcbd,4 +np.float32,0x131035,0xc21b06f4,4 +np.float32,0x3f275c3b,0xbe3d0487,4 +np.float32,0x3ef06130,0xbea82069,4 +np.float32,0x3f57f3b0,0xbd974fef,4 +np.float32,0x7f6c4a78,0x4219fcfa,4 +np.float32,0x7e8421d0,0x4217c639,4 +np.float32,0x3f17a479,0xbe68e08e,4 +np.float32,0x7f03774e,0x4218f83b,4 +np.float32,0x441a33,0xc218d0b8,4 +np.float32,0x539158,0xc21875b6,4 +np.float32,0x3e8fcc75,0xbf0d3018,4 +np.float32,0x7ef74130,0x4218dce4,4 +np.float32,0x3ea6f4fa,0xbef92c38,4 +np.float32,0x7f3948ab,0x421990d5,4 +np.float32,0x7db6f8f5,0x4215ee7c,4 +np.float32,0x3ee44a2f,0xbeb399e5,4 +np.float32,0x156c59,0xc21ad30d,4 +np.float32,0x3f21ee53,0xbe4baf16,4 +np.float32,0x3f2c08f4,0xbe30c424,4 +np.float32,0x3f49885c,0xbdd4c6a9,4 +np.float32,0x3eae0b9c,0xbeefed54,4 +np.float32,0x1b5c1f,0xc21a6646,4 +np.float32,0x3e7330e2,0xbf1fd592,4 +np.float32,0x3ebbeb4c,0xbededf82,4 +np.float32,0x427154,0xc218dbb1,4 +np.float32,0x3f6b8b4b,0xbd142498,4 +np.float32,0x8e769,0xc21c5981,4 +np.float32,0x3e9db557,0xbf02ec1c,4 +np.float32,0x3f001bef,0xbe99f019,4 +np.float32,0x3e58b48c,0xbf2ca77a,4 +np.float32,0x3d46c16b,0xbfa8327c,4 +np.float32,0x7eeeb305,0x4218cd3b,4 +np.float32,0x3e3f163d,0xbf3aa446,4 +np.float32,0x3f66c872,0xbd3877d9,4 +np.float32,0x7f7162f8,0x421a0677,4 +np.float32,0x3edca3bc,0xbebb2e28,4 +np.float32,0x3dc1055b,0xbf834afa,4 +np.float32,0x12b16f,0xc21b0fad,4 +np.float32,0x3f733898,0xbcb62e16,4 +np.float32,0x3e617af8,0xbf283db0,4 +np.float32,0x7e86577a,0x4217cd99,4 +np.float32,0x3f0ba3c7,0xbe86c633,4 +np.float32,0x3f4cad25,0xbdc70247,4 +np.float32,0xb6cdf,0xc21bea9f,4 +np.float32,0x3f42971a,0xbdf3f49e,4 +np.float32,0x3e6ccad2,0xbf22cc78,4 +np.float32,0x7f2121b2,0x421952b8,4 +np.float32,0x3f6d3f55,0xbd075366,4 +np.float32,0x3f524f,0xc218f117,4 +np.float32,0x3e95b5d9,0xbf08b56a,4 +np.float32,0x7f6ae47d,0x4219fa56,4 +np.float32,0x267539,0xc219ceda,4 +np.float32,0x3ef72f6d,0xbea1eb2e,4 +np.float32,0x2100b2,0xc21a12e2,4 +np.float32,0x3d9777d1,0xbf90c4e7,4 +np.float32,0x44c6f5,0xc218cc56,4 +np.float32,0x7f2a613d,0x42196b8a,4 +np.float32,0x390a25,0xc2191f8d,4 +np.float32,0x3f1de5ad,0xbe56e703,4 +np.float32,0x2f59ce,0xc2197258,4 +np.float32,0x7f3b12a1,0x4219951b,4 +np.float32,0x3ecb66d4,0xbecd44ca,4 +np.float32,0x7e74ff,0xc217bd7d,4 +np.float32,0x7ed83f78,0x4218a14d,4 +np.float32,0x685994,0xc21812f1,4 +np.float32,0xbf800000,0x7fc00000,4 +np.float32,0x736f47,0xc217e60b,4 +np.float32,0x7f09c371,0x42190d0a,4 +np.float32,0x3f7ca51d,0xbbbbbce0,4 +np.float32,0x7f4b4d3b,0x4219ba1a,4 +np.float32,0x3f6c4471,0xbd0eb076,4 +np.float32,0xd944e,0xc21b9dcf,4 +np.float32,0x7cb06ffc,0x421375cd,4 +np.float32,0x586187,0xc2185cce,4 +np.float32,0x3f3cbf5b,0xbe078911,4 +np.float32,0x3f30b504,0xbe24d983,4 +np.float32,0x3f0a16ba,0xbe8941fd,4 +np.float32,0x5c43b0,0xc21849af,4 +np.float32,0x3dad74f6,0xbf893bd5,4 +np.float32,0x3c586958,0xbff087a6,4 +np.float32,0x3e8307a8,0xbf1786ba,4 +np.float32,0x7dcd1776,0x4216213d,4 +np.float32,0x3f44d107,0xbde9d662,4 +np.float32,0x3e2e6823,0xbf44cbec,4 +np.float32,0x3d87ea27,0xbf96caca,4 +np.float32,0x3e0c715b,0xbf5ce07e,4 +np.float32,0x7ec9cd5a,0x4218828e,4 +np.float32,0x3e26c0b4,0xbf49c93e,4 +np.float32,0x75b94e,0xc217dd50,4 +np.float32,0x3df7b9f5,0xbf6ad7f4,4 +np.float32,0x0,0xff800000,4 +np.float32,0x3f284795,0xbe3a94da,4 +np.float32,0x7ee49092,0x4218b9f0,4 +np.float32,0x7f4c20e0,0x4219bbe8,4 +np.float32,0x3efbbce8,0xbe9ddc4b,4 +np.float32,0x12274a,0xc21b1cb4,4 +np.float32,0x5fa1b1,0xc21839be,4 +np.float32,0x7f0b210e,0x4219116d,4 +np.float32,0x3f67092a,0xbd368545,4 +np.float32,0x3d572721,0xbfa3ca5b,4 +np.float32,0x3f7913ce,0xbc431028,4 +np.float32,0x3b0613,0xc2191059,4 +np.float32,0x3e1d16c0,0xbf506c6f,4 +np.float32,0xab130,0xc21c081d,4 +np.float32,0x3e23ac97,0xbf4bdb9d,4 +np.float32,0x7ef52368,0x4218d911,4 +np.float32,0x7f38e686,0x42198fe9,4 +np.float32,0x3f106a21,0xbe7e9897,4 +np.float32,0x3ecef8d5,0xbec96644,4 +np.float32,0x3ec37e02,0xbed61683,4 +np.float32,0x3efbd063,0xbe9dcb17,4 +np.float32,0x3f318fe3,0xbe22b402,4 +np.float32,0x7e5e5228,0x4217795d,4 +np.float32,0x72a046,0xc217e92c,4 +np.float32,0x7f6f970b,0x421a0324,4 +np.float32,0x3ed871b4,0xbebf72fb,4 +np.float32,0x7a2eaa,0xc217ccc8,4 +np.float32,0x3e819655,0xbf18c1d7,4 +np.float32,0x80800000,0x7fc00000,4 +np.float32,0x7eab0719,0x421838f9,4 +np.float32,0x7f0763cb,0x4219054f,4 +np.float32,0x3f191672,0xbe64a8af,4 +np.float32,0x7d4327,0xc217c1b6,4 +np.float32,0x3f724ba6,0xbcc3bea3,4 +np.float32,0x60fe06,0xc2183375,4 +np.float32,0x48cd59,0xc218b30b,4 +np.float32,0x3f7fec2b,0xb909d3f3,4 +np.float32,0x1c7bb9,0xc21a5460,4 +np.float32,0x24d8a8,0xc219e1e4,4 +np.float32,0x3e727c52,0xbf20283c,4 +np.float32,0x4bc460,0xc218a14a,4 +np.float32,0x63e313,0xc2182661,4 +np.float32,0x7f625581,0x4219e9d4,4 +np.float32,0x3eeb3e77,0xbeacedc0,4 +np.float32,0x7ef27a47,0x4218d437,4 +np.float32,0x27105a,0xc219c7e6,4 +np.float32,0x22a10b,0xc219fd7d,4 +np.float32,0x3f41e907,0xbdf711ab,4 +np.float32,0x7c1fbf95,0x4212155b,4 +np.float32,0x7e5acceb,0x42177244,4 +np.float32,0x3e0892fa,0xbf5ffb83,4 +np.float32,0x3ea0e51d,0xbf00b2c0,4 +np.float32,0x3e56fc29,0xbf2d8a51,4 +np.float32,0x7ee724ed,0x4218beed,4 +np.float32,0x7ebf142b,0x42186a46,4 +np.float32,0x7f6cf35c,0x4219fe37,4 +np.float32,0x3f11abf7,0xbe7abdcd,4 +np.float32,0x588d7a,0xc2185bf1,4 +np.float32,0x3f6e81d2,0xbcfbcf97,4 +np.float32,0x3f1b6be8,0xbe5dee2b,4 +np.float32,0x7f3815e0,0x42198df2,4 +np.float32,0x3f5bfc88,0xbd86d93d,4 +np.float32,0x3f3775d0,0xbe142bbc,4 +np.float32,0x78a958,0xc217d25a,4 +np.float32,0x2ff7c3,0xc2196c96,4 +np.float32,0x4b9c0,0xc21d733c,4 +np.float32,0x3ec025af,0xbed9ecf3,4 +np.float32,0x6443f0,0xc21824b3,4 +np.float32,0x3f754e28,0xbc97d299,4 +np.float32,0x3eaa91d3,0xbef4699d,4 +np.float32,0x3e5f2837,0xbf296478,4 +np.float32,0xe5676,0xc21b85a4,4 +np.float32,0x3f6859f2,0xbd2c6b90,4 +np.float32,0x3f68686b,0xbd2bfcc6,4 +np.float32,0x4b39b8,0xc218a47b,4 +np.float32,0x630ac4,0xc2182a28,4 +np.float32,0x160980,0xc21ac67d,4 +np.float32,0x3ed91c4d,0xbebec3fd,4 +np.float32,0x7ec27b0d,0x4218721f,4 +np.float32,0x3f3c0a5f,0xbe09344b,4 +np.float32,0x3dbff9c1,0xbf839841,4 +np.float32,0x7f0e8ea7,0x42191c40,4 +np.float32,0x3f36b162,0xbe1608e4,4 +np.float32,0x228bb3,0xc219fe90,4 +np.float32,0x2fdd30,0xc2196d8c,4 +np.float32,0x3e8fce8e,0xbf0d2e79,4 +np.float32,0x3f36acc7,0xbe16141a,4 +np.float32,0x7f44b51c,0x4219ab70,4 +np.float32,0x3ec3371c,0xbed66736,4 +np.float32,0x4388a2,0xc218d473,4 +np.float32,0x3f5aa6c3,0xbd8c4344,4 +np.float32,0x7f09fce4,0x42190dc3,4 +np.float32,0x7ed7854a,0x42189fce,4 +np.float32,0x7f4da83a,0x4219bf3a,4 +np.float32,0x3db8da28,0xbf85b25a,4 +np.float32,0x7f449686,0x4219ab2b,4 +np.float32,0x2eb25,0xc21e498c,4 +np.float32,0x3f2bcc08,0xbe3161bd,4 +np.float32,0x36c923,0xc219317b,4 +np.float32,0x3d52a866,0xbfa4f6d2,4 +np.float32,0x3f7d6688,0xbb913e4e,4 +np.float32,0x3f5a6ba4,0xbd8d33e3,4 +np.float32,0x719740,0xc217ed35,4 +np.float32,0x78a472,0xc217d26c,4 +np.float32,0x7ee33d0c,0x4218b759,4 +np.float32,0x7f668c1d,0x4219f208,4 +np.float32,0x3e29c600,0xbf47ca46,4 +np.float32,0x3f3cefc3,0xbe071712,4 +np.float32,0x3e224ebd,0xbf4cca41,4 +np.float32,0x7f1417be,0x42192d31,4 +np.float32,0x7f29d7d5,0x42196a23,4 +np.float32,0x3338ce,0xc2194f65,4 +np.float32,0x2a7897,0xc219a2b6,4 +np.float32,0x3d6bc3d8,0xbf9eb468,4 +np.float32,0x3f6bd7bf,0xbd11e392,4 +np.float32,0x7f6d26bf,0x4219fe98,4 +np.float32,0x3f52d378,0xbdacadb5,4 +np.float32,0x3efac453,0xbe9eb84a,4 +np.float32,0x3f692eb7,0xbd261184,4 +np.float32,0x3f6a0bb5,0xbd1f7ec1,4 +np.float32,0x3f037a49,0xbe942aa8,4 +np.float32,0x3f465bd4,0xbde2e530,4 +np.float32,0x7ef0f47b,0x4218d16a,4 +np.float32,0x637127,0xc218285e,4 +np.float32,0x3f41e511,0xbdf723d7,4 +np.float32,0x7f800000,0x7f800000,4 +np.float32,0x3f3342d5,0xbe1e77d5,4 +np.float32,0x7f57cfe6,0x4219d4a9,4 +np.float32,0x3e4358ed,0xbf3830a7,4 +np.float32,0x3ce25f15,0xbfc77f2b,4 +np.float32,0x7ed057e7,0x421890be,4 +np.float32,0x7ce154d9,0x4213e295,4 +np.float32,0x3ee91984,0xbeaef703,4 +np.float32,0x7e4e919c,0x421758af,4 +np.float32,0x6830e7,0xc218139e,4 +np.float32,0x3f12f08e,0xbe76e328,4 +np.float32,0x7f0a7a32,0x42190f56,4 +np.float32,0x7f38e,0xc21c8bd3,4 +np.float32,0x3e01def9,0xbf6593e3,4 +np.float32,0x3f5c8c6d,0xbd849432,4 +np.float32,0x3eed8747,0xbeaac7a3,4 +np.float32,0x3cadaa0e,0xbfd63b21,4 +np.float32,0x3f7532a9,0xbc996178,4 +np.float32,0x31f3ac,0xc2195a8f,4 +np.float32,0x3f0e0f97,0xbe82f3af,4 +np.float32,0x3f2a1f35,0xbe35bd3f,4 +np.float32,0x3f4547b2,0xbde7bebd,4 +np.float32,0x3f7988a6,0xbc36094c,4 +np.float32,0x74464c,0xc217e2d2,4 +np.float32,0x7f7518be,0x421a0d3f,4 +np.float32,0x7e97fa0a,0x42180473,4 +np.float32,0x584e3a,0xc2185d2f,4 +np.float32,0x3e7291f3,0xbf201e52,4 +np.float32,0xc0a05,0xc21bd359,4 +np.float32,0x3a3177,0xc21916a6,4 +np.float32,0x4f417f,0xc2188d45,4 +np.float32,0x263fce,0xc219d145,4 +np.float32,0x7e1d58,0xc217beb1,4 +np.float32,0x7f056af3,0x4218fec9,4 +np.float32,0x3f21c181,0xbe4c2a3f,4 +np.float32,0x7eca4956,0x4218839f,4 +np.float32,0x3e58afa8,0xbf2ca9fd,4 +np.float32,0x3f40d583,0xbdfc04ef,4 +np.float32,0x7f432fbb,0x4219a7fc,4 +np.float32,0x43aaa4,0xc218d393,4 +np.float32,0x7f2c9b62,0x42197150,4 +np.float32,0x5c3876,0xc21849e5,4 +np.float32,0x7f2034e8,0x42195029,4 +np.float32,0x7e5be772,0x42177481,4 +np.float32,0x80000000,0xff800000,4 +np.float32,0x3f5be03b,0xbd874bb0,4 +np.float32,0x3e32494f,0xbf4259be,4 +np.float32,0x3e1f4671,0xbf4ee30b,4 +np.float32,0x4606cc,0xc218c454,4 +np.float32,0x425cbc,0xc218dc3b,4 +np.float32,0x7dd9b8bf,0x42163bd0,4 +np.float32,0x3f0465d0,0xbe929db7,4 +np.float32,0x3f735077,0xbcb4d0fa,4 +np.float32,0x4d6a43,0xc21897b8,4 +np.float32,0x3e27d600,0xbf4910f5,4 +np.float32,0x3f06e0cc,0xbe8e7d24,4 +np.float32,0x3f3fd064,0xbe005e45,4 +np.float32,0x176f1,0xc21f7c2d,4 +np.float32,0x3eb64e6f,0xbee59d9c,4 +np.float32,0x7f0f075d,0x42191db8,4 +np.float32,0x3f718cbe,0xbcceb621,4 +np.float32,0x3ead7bda,0xbef0a54a,4 +np.float32,0x7f77c1a8,0x421a120c,4 +np.float32,0x3f6a79c5,0xbd1c3afd,4 +np.float32,0x3e992d1f,0xbf062a02,4 +np.float32,0x3e6f6335,0xbf219639,4 +np.float32,0x7f6d9a3e,0x4219ff70,4 +np.float32,0x557ed1,0xc2186b91,4 +np.float32,0x3f13a456,0xbe74c457,4 +np.float32,0x15c2dc,0xc21acc17,4 +np.float32,0x71f36f,0xc217ebcc,4 +np.float32,0x748dea,0xc217e1c1,4 +np.float32,0x7f0f32e0,0x42191e3f,4 +np.float32,0x5b1da8,0xc2184f41,4 +np.float32,0x3d865d3a,0xbf976e11,4 +np.float32,0x3f800000,0x0,4 +np.float32,0x7f67b56d,0x4219f444,4 +np.float32,0x6266a1,0xc2182d0c,4 +np.float32,0x3ec9c5e4,0xbecf0e6b,4 +np.float32,0x6a6a0e,0xc2180a3b,4 +np.float32,0x7e9db6fd,0x421814ef,4 +np.float32,0x3e7458f7,0xbf1f4e88,4 +np.float32,0x3ead8016,0xbef09fdc,4 +np.float32,0x3e263d1c,0xbf4a211e,4 +np.float32,0x7f6b3329,0x4219faeb,4 +np.float32,0x800000,0xc217b818,4 +np.float32,0x3f0654c7,0xbe8f6471,4 +np.float32,0x3f281b71,0xbe3b0990,4 +np.float32,0x7c4c8e,0xc217c524,4 +np.float32,0x7d113a87,0x4214537d,4 +np.float32,0x734b5f,0xc217e696,4 +np.float32,0x7f079d05,0x4219060b,4 +np.float32,0x3ee830b1,0xbeafd58b,4 +np.float32,0x3f1c3b8b,0xbe5b9d96,4 +np.float32,0x3f2bf0c6,0xbe3102aa,4 +np.float32,0x7ddffe22,0x42164871,4 +np.float32,0x3f1e58b4,0xbe55a37f,4 +np.float32,0x5f3edf,0xc2183b8a,4 +np.float32,0x7f1fb6ec,0x42194eca,4 +np.float32,0x3f78718e,0xbc55311e,4 +np.float32,0x3e574b7d,0xbf2d6152,4 +np.float32,0x7eab27c6,0x4218394e,4 +np.float32,0x7f34603c,0x421984e5,4 +np.float32,0x3f3a8b57,0xbe0cc1ca,4 +np.float32,0x3f744181,0xbca7134e,4 +np.float32,0x3f7e3bc4,0xbb45156b,4 +np.float32,0x93ab4,0xc21c498b,4 +np.float32,0x7ed5541e,0x42189b42,4 +np.float32,0x6bf8ec,0xc21803c4,4 +np.float32,0x757395,0xc217de58,4 +np.float32,0x7f177214,0x42193726,4 +np.float32,0x59935f,0xc21856d6,4 +np.float32,0x2cd9ba,0xc2198a78,4 +np.float32,0x3ef6fd5c,0xbea2183c,4 +np.float32,0x3ebb6c63,0xbedf75e0,4 +np.float32,0x7f43272c,0x4219a7e9,4 +np.float32,0x7f42e67d,0x4219a755,4 +np.float32,0x3f3f744f,0xbe0133f6,4 +np.float32,0x7f5fddaa,0x4219e4f4,4 +np.float32,0x3dc9874f,0xbf80e529,4 +np.float32,0x3f2efe64,0xbe292ec8,4 +np.float32,0x3e0406a6,0xbf63bf7c,4 +np.float32,0x3cdbb0aa,0xbfc92984,4 +np.float32,0x3e6597e7,0xbf263b30,4 +np.float32,0x3f0c1153,0xbe861807,4 +np.float32,0x7fce16,0xc217b8c6,4 +np.float32,0x3f5f4e5f,0xbd730dc6,4 +np.float32,0x3ed41ffa,0xbec3ee69,4 +np.float32,0x3f216c78,0xbe4d1446,4 +np.float32,0x3f123ed7,0xbe78fe4b,4 +np.float32,0x7f7e0ca9,0x421a1d34,4 +np.float32,0x7e318af4,0x42171558,4 +np.float32,0x7f1e1659,0x42194a3d,4 +np.float32,0x34d12a,0xc21941c2,4 +np.float32,0x3d9566ad,0xbf918870,4 +np.float32,0x3e799a47,0xbf1cf0e5,4 +np.float32,0x3e89dd6f,0xbf11df76,4 +np.float32,0x32f0d3,0xc21951d8,4 +np.float32,0x7e89d17e,0x4217d8f6,4 +np.float32,0x1f3b38,0xc21a2b6b,4 +np.float32,0x7ee9e060,0x4218c427,4 +np.float32,0x31a673,0xc2195d41,4 +np.float32,0x5180f1,0xc21880d5,4 +np.float32,0x3cd36f,0xc21902f8,4 +np.float32,0x3bb63004,0xc01050cb,4 +np.float32,0x3e8ee9d1,0xbf0ddfde,4 +np.float32,0x3d2a7da3,0xbfb0b970,4 +np.float32,0x3ea58107,0xbefb1dc3,4 +np.float32,0x7f6760b0,0x4219f3a2,4 +np.float32,0x7f7f9e08,0x421a1ff0,4 +np.float32,0x37e7f1,0xc219287b,4 +np.float32,0x3ef7eb53,0xbea14267,4 +np.float32,0x3e2eb581,0xbf449aa5,4 +np.float32,0x3da7671c,0xbf8b3568,4 +np.float32,0x7af36f7b,0x420f33ee,4 +np.float32,0x3eb3602c,0xbee93823,4 +np.float32,0x3f68bcff,0xbd2975de,4 +np.float32,0x3ea7cefb,0xbef80a9d,4 +np.float32,0x3f329689,0xbe202414,4 +np.float32,0x7f0c7c80,0x421915be,4 +np.float32,0x7f4739b8,0x4219b118,4 +np.float32,0x73af58,0xc217e515,4 +np.float32,0x7f13eb2a,0x42192cab,4 +np.float32,0x30f2d9,0xc2196395,4 +np.float32,0x7ea7066c,0x42182e71,4 +np.float32,0x669fec,0xc2181a5b,4 +np.float32,0x3f7d6876,0xbb90d1ef,4 +np.float32,0x3f08a4ef,0xbe8b9897,4 +np.float32,0x7f2a906c,0x42196c05,4 +np.float32,0x3ed3ca42,0xbec44856,4 +np.float32,0x9d27,0xc220fee2,4 +np.float32,0x3e4508a1,0xbf373c03,4 +np.float32,0x3e41f8de,0xbf38f9bb,4 +np.float32,0x3e912714,0xbf0c255b,4 +np.float32,0xff800000,0x7fc00000,4 +np.float32,0x7eefd13d,0x4218cf4f,4 +np.float32,0x3f491674,0xbdd6bded,4 +np.float32,0x3ef49512,0xbea445c9,4 +np.float32,0x3f045b79,0xbe92af15,4 +np.float32,0x3ef6c412,0xbea24bd5,4 +np.float32,0x3e6f3c28,0xbf21a85d,4 +np.float32,0x3ef71839,0xbea2000e,4 +np.float32,0x1,0xc23369f4,4 +np.float32,0x3e3fcfe4,0xbf3a3876,4 +np.float32,0x3e9d7a65,0xbf0315b2,4 +np.float32,0x20b7c4,0xc21a16bd,4 +np.float32,0x7f707b10,0x421a04cb,4 +np.float32,0x7fc00000,0x7fc00000,4 +np.float32,0x3f285ebd,0xbe3a57ac,4 +np.float32,0x74c9ea,0xc217e0dc,4 +np.float32,0x3f6501f2,0xbd4634ab,4 +np.float32,0x3f248959,0xbe4495cc,4 +np.float32,0x7e915ff0,0x4217f0b3,4 +np.float32,0x7edbb910,0x4218a864,4 +np.float32,0x3f7042dd,0xbce1bddb,4 +np.float32,0x6f08c9,0xc217f754,4 +np.float32,0x7f423993,0x4219a5ca,4 +np.float32,0x3f125704,0xbe78b4cd,4 +np.float32,0x7ef7f5ae,0x4218de28,4 +np.float32,0x3f2dd940,0xbe2c1a33,4 +np.float32,0x3f1ca78e,0xbe5a6a8b,4 +np.float32,0x244863,0xc219e8be,4 +np.float32,0x3f2614fe,0xbe406d6b,4 +np.float32,0x3e75e7a3,0xbf1e99b5,4 +np.float32,0x2bdd6e,0xc2199459,4 +np.float32,0x7e49e279,0x42174e7b,4 +np.float32,0x3e3bb09a,0xbf3ca2cd,4 +np.float32,0x649f06,0xc2182320,4 +np.float32,0x7f4a44e1,0x4219b7d6,4 +np.float32,0x400473,0xc218ec3a,4 +np.float32,0x3edb19ad,0xbebcbcad,4 +np.float32,0x3d8ee956,0xbf94006c,4 +np.float32,0x7e91c603,0x4217f1eb,4 +np.float32,0x221384,0xc21a04a6,4 +np.float32,0x7f7dd660,0x421a1cd5,4 +np.float32,0x7ef34609,0x4218d5ac,4 +np.float32,0x7f5ed529,0x4219e2e5,4 +np.float32,0x7f1bf685,0x42194438,4 +np.float32,0x3cdd094a,0xbfc8d294,4 +np.float32,0x7e87fc8e,0x4217d303,4 +np.float32,0x7f53d971,0x4219cc6b,4 +np.float32,0xabc8b,0xc21c0646,4 +np.float32,0x7f5011e6,0x4219c46a,4 +np.float32,0x7e460638,0x421745e5,4 +np.float32,0xa8126,0xc21c0ffd,4 +np.float32,0x3eec2a66,0xbeac0f2d,4 +np.float32,0x3f3a1213,0xbe0de340,4 +np.float32,0x7f5908db,0x4219d72c,4 +np.float32,0x7e0ad3c5,0x4216a7f3,4 +np.float32,0x3f2de40e,0xbe2bfe90,4 +np.float32,0x3d0463c5,0xbfbec8e4,4 +np.float32,0x7c7cde0b,0x4212e19a,4 +np.float32,0x74c24f,0xc217e0f9,4 +np.float32,0x3f14b4cb,0xbe71929b,4 +np.float32,0x3e94e192,0xbf09537f,4 +np.float32,0x3eebde71,0xbeac56bd,4 +np.float32,0x3f65e413,0xbd3f5b8a,4 +np.float32,0x7e109199,0x4216b9f9,4 +np.float32,0x3f22f5d0,0xbe48ddc0,4 +np.float32,0x3e22d3bc,0xbf4c6f4d,4 +np.float32,0x3f7a812f,0xbc1a680b,4 +np.float32,0x3f67f361,0xbd2f7d7c,4 +np.float32,0x3f1caa63,0xbe5a6281,4 +np.float32,0x3f306fde,0xbe2587ab,4 +np.float32,0x3e8df9d3,0xbf0e9b2f,4 +np.float32,0x3eaaccc4,0xbef41cd4,4 +np.float32,0x7f3f65ec,0x42199f45,4 +np.float32,0x3dc706e0,0xbf8196ec,4 +np.float32,0x3e14eaba,0xbf565cf6,4 +np.float32,0xcc60,0xc2208a09,4 +np.float32,0x358447,0xc2193be7,4 +np.float32,0x3dcecade,0xbf7eec70,4 +np.float32,0x3f20b4f8,0xbe4f0ef0,4 +np.float32,0x7e7c979f,0x4217b222,4 +np.float32,0x7f2387b9,0x4219594a,4 +np.float32,0x3f6f6e5c,0xbcee0e05,4 +np.float32,0x7f19ad81,0x42193da8,4 +np.float32,0x5635e1,0xc21867dd,4 +np.float32,0x4c5e97,0xc2189dc4,4 +np.float32,0x7f35f97f,0x421988d1,4 +np.float32,0x7f685224,0x4219f571,4 +np.float32,0x3eca0616,0xbecec7b8,4 +np.float32,0x3f436d0d,0xbdf024ca,4 +np.float32,0x12a97d,0xc21b106a,4 +np.float32,0x7f0fdc93,0x4219204d,4 +np.float32,0x3debfb42,0xbf703e65,4 +np.float32,0x3c6c54d2,0xbfeba291,4 +np.float32,0x7e5d7491,0x421777a1,4 +np.float32,0x3f4bd2f0,0xbdcab87d,4 +np.float32,0x3f7517f4,0xbc9ae510,4 +np.float32,0x3f71a59a,0xbccd480d,4 +np.float32,0x3f514653,0xbdb33f61,4 +np.float32,0x3f4e6ea4,0xbdbf694b,4 +np.float32,0x3eadadec,0xbef06526,4 +np.float32,0x3f3b41c1,0xbe0b0fbf,4 +np.float32,0xc35a,0xc2209e1e,4 +np.float32,0x384982,0xc2192575,4 +np.float32,0x3464c3,0xc2194556,4 +np.float32,0x7f5e20d9,0x4219e17d,4 +np.float32,0x3ea18b62,0xbf004016,4 +np.float32,0x63a02b,0xc218278c,4 +np.float32,0x7ef547ba,0x4218d953,4 +np.float32,0x3f2496fb,0xbe4470f4,4 +np.float32,0x7ea0c8c6,0x42181d81,4 +np.float32,0x3f42ba60,0xbdf35372,4 +np.float32,0x7e40d9,0xc217be34,4 +np.float32,0x3e95883b,0xbf08d750,4 +np.float32,0x3e0cddf3,0xbf5c8aa8,4 +np.float32,0x3f2305d5,0xbe48b20a,4 +np.float32,0x7f0d0941,0x4219177b,4 +np.float32,0x3f7b98d3,0xbbf6e477,4 +np.float32,0x3f687cdc,0xbd2b6057,4 +np.float32,0x3f42ce91,0xbdf2f73d,4 +np.float32,0x3ee00fc0,0xbeb7c217,4 +np.float32,0x7f3d483a,0x42199a53,4 +np.float32,0x3e1e08eb,0xbf4fc18d,4 +np.float32,0x7e202ff5,0x4216e798,4 +np.float32,0x582898,0xc2185ded,4 +np.float32,0x3e3552b1,0xbf40790c,4 +np.float32,0x3d3f7c87,0xbfaa44b6,4 +np.float32,0x669d8e,0xc2181a65,4 +np.float32,0x3f0e21b4,0xbe82d757,4 +np.float32,0x686f95,0xc2181293,4 +np.float32,0x3f48367f,0xbdda9ead,4 +np.float32,0x3dc27802,0xbf82e0a0,4 +np.float32,0x3f6ac40c,0xbd1a07d4,4 +np.float32,0x3bba6d,0xc2190b12,4 +np.float32,0x3ec7b6b0,0xbed15665,4 +np.float32,0x3f1f9ca4,0xbe521955,4 +np.float32,0x3ef2f147,0xbea5c4b8,4 +np.float32,0x7c65f769,0x4212b762,4 +np.float32,0x7e98e162,0x42180716,4 +np.float32,0x3f0f0c09,0xbe8169ea,4 +np.float32,0x3d67f03b,0xbf9f9d48,4 +np.float32,0x7f3751e4,0x42198c18,4 +np.float32,0x7f1fac61,0x42194ead,4 +np.float32,0x3e9b698b,0xbf048d89,4 +np.float32,0x7e66507b,0x42178913,4 +np.float32,0x7f5cb680,0x4219dea5,4 +np.float32,0x234700,0xc219f53e,4 +np.float32,0x3d9984ad,0xbf900591,4 +np.float32,0x3f33a3f2,0xbe1d872a,4 +np.float32,0x3eaf52b6,0xbeee4cf4,4 +np.float32,0x7f078930,0x421905ca,4 +np.float32,0x3f083b39,0xbe8c44df,4 +np.float32,0x3e3823f8,0xbf3ec231,4 +np.float32,0x3eef6f5d,0xbea9008c,4 +np.float32,0x6145e1,0xc218322c,4 +np.float32,0x16d9ae,0xc21ab65f,4 +np.float32,0x7e543376,0x421764a5,4 +np.float32,0x3ef77ccb,0xbea1a5a0,4 +np.float32,0x3f4a443f,0xbdd18af5,4 +np.float32,0x8f209,0xc21c5770,4 +np.float32,0x3ecac126,0xbecdfa33,4 +np.float32,0x3e8662f9,0xbf14b6c7,4 +np.float32,0x23759a,0xc219f2f4,4 +np.float32,0xf256d,0xc21b6d3f,4 +np.float32,0x3f579f93,0xbd98aaa2,4 +np.float32,0x3ed4cc8e,0xbec339cb,4 +np.float32,0x3ed25400,0xbec5d2a1,4 +np.float32,0x3ed6f8ba,0xbec0f795,4 +np.float32,0x7f36efd9,0x42198b2a,4 +np.float32,0x7f5169dd,0x4219c746,4 +np.float32,0x7de18a20,0x42164b80,4 +np.float32,0x3e8de526,0xbf0eab61,4 +np.float32,0x3de0cbcd,0xbf75a47e,4 +np.float32,0xe265f,0xc21b8b82,4 +np.float32,0x3df3cdbd,0xbf6c9e40,4 +np.float32,0x3f38a25a,0xbe115589,4 +np.float32,0x7f01f2c0,0x4218f311,4 +np.float32,0x3da7d5f4,0xbf8b10a5,4 +np.float32,0x4d4fe8,0xc2189850,4 +np.float32,0x3cc96d9d,0xbfcdfc8d,4 +np.float32,0x259a88,0xc219d8d7,4 +np.float32,0x7f1d5102,0x42194810,4 +np.float32,0x7e17ca91,0x4216cfa7,4 +np.float32,0x3f73d110,0xbcad7a8f,4 +np.float32,0x3f009383,0xbe9920ed,4 +np.float32,0x7e22af,0xc217be9f,4 +np.float32,0x3f7de2ce,0xbb6c0394,4 +np.float32,0x3edd0cd2,0xbebac45a,4 +np.float32,0x3ec9b5c1,0xbecf2035,4 +np.float32,0x3168c5,0xc2195f6b,4 +np.float32,0x3e935522,0xbf0a7d18,4 +np.float32,0x3e494077,0xbf34e120,4 +np.float32,0x3f52ed06,0xbdac41ec,4 +np.float32,0x3f73d51e,0xbcad3f65,4 +np.float32,0x3f03d453,0xbe939295,4 +np.float32,0x7ef4ee68,0x4218d8b1,4 +np.float32,0x3ed0e2,0xc218f4a7,4 +np.float32,0x4efab8,0xc2188ed3,4 +np.float32,0x3dbd5632,0xbf845d3b,4 +np.float32,0x7eecad4f,0x4218c972,4 +np.float32,0x9d636,0xc21c2d32,4 +np.float32,0x3e5f3b6b,0xbf295ae7,4 +np.float32,0x7f4932df,0x4219b57a,4 +np.float32,0x4b59b5,0xc218a3be,4 +np.float32,0x3e5de97f,0xbf2a03b4,4 +np.float32,0x3f1c479d,0xbe5b7b3c,4 +np.float32,0x3f42e7e4,0xbdf283a5,4 +np.float32,0x2445,0xc2238af2,4 +np.float32,0x7aa71b43,0x420e8c9e,4 +np.float32,0x3ede6e4e,0xbeb961e1,4 +np.float32,0x7f05dd3b,0x42190045,4 +np.float32,0x3ef5b55c,0xbea3404b,4 +np.float32,0x7f738624,0x421a0a62,4 +np.float32,0x3e7d50a1,0xbf1b4cb4,4 +np.float32,0x3f44cc4a,0xbde9ebcc,4 +np.float32,0x7e1a7b0b,0x4216d777,4 +np.float32,0x3f1d9868,0xbe57c0da,4 +np.float32,0x1ebee2,0xc21a3263,4 +np.float32,0x31685f,0xc2195f6e,4 +np.float32,0x368a8e,0xc2193379,4 +np.float32,0xa9847,0xc21c0c2e,4 +np.float32,0x3bd3b3,0xc2190a56,4 +np.float32,0x3961e4,0xc2191ce3,4 +np.float32,0x7e13a243,0x4216c34e,4 +np.float32,0x7f7b1790,0x421a17ff,4 +np.float32,0x3e55f020,0xbf2e1545,4 +np.float32,0x3f513861,0xbdb37aa8,4 +np.float32,0x3dd9e754,0xbf791ad2,4 +np.float32,0x5e8d86,0xc2183ec9,4 +np.float32,0x26b796,0xc219cbdd,4 +np.float32,0x429daa,0xc218da89,4 +np.float32,0x3f477caa,0xbdddd9ba,4 +np.float32,0x3f0e5114,0xbe828d45,4 +np.float32,0x3f54f362,0xbda3c286,4 +np.float32,0x6eac1c,0xc217f8c8,4 +np.float32,0x3f04c479,0xbe91fef5,4 +np.float32,0x3e993765,0xbf06228e,4 +np.float32,0x3eafd99f,0xbeeda21b,4 +np.float32,0x3f2a759e,0xbe34db96,4 +np.float32,0x3f05adfb,0xbe907937,4 +np.float32,0x3f6e2dfc,0xbd005980,4 +np.float32,0x3f2f2daa,0xbe28b6b5,4 +np.float32,0x15e746,0xc21ac931,4 +np.float32,0x7d34ca26,0x4214b4e5,4 +np.float32,0x7ebd175c,0x4218659f,4 +np.float32,0x7f1ed26b,0x42194c4c,4 +np.float32,0x2588b,0xc21eaab0,4 +np.float32,0x3f0065e3,0xbe996fe2,4 +np.float32,0x3f610376,0xbd658122,4 +np.float32,0x451995,0xc218ca41,4 +np.float32,0x70e083,0xc217f002,4 +np.float32,0x7e19821a,0x4216d4a8,4 +np.float32,0x3e7cd9a0,0xbf1b80fb,4 +np.float32,0x7f1a8f18,0x42194033,4 +np.float32,0x3f008fee,0xbe99271f,4 +np.float32,0xff7fffff,0x7fc00000,4 +np.float32,0x7f31d826,0x42197e9b,4 +np.float32,0x3f18cf12,0xbe657838,4 +np.float32,0x3e5c1bc7,0xbf2aebf9,4 +np.float32,0x3e3d3993,0xbf3bbaf8,4 +np.float32,0x68457a,0xc2181347,4 +np.float32,0x7ddf7561,0x42164761,4 +np.float32,0x7f47341b,0x4219b10c,4 +np.float32,0x4d3ecd,0xc21898b2,4 +np.float32,0x7f43dee8,0x4219a98b,4 +np.float32,0x3f0def7c,0xbe8325f5,4 +np.float32,0x3d5a551f,0xbfa2f994,4 +np.float32,0x7ed26602,0x4218951b,4 +np.float32,0x3ee7fa5b,0xbeb0099a,4 +np.float32,0x7ef74ea8,0x4218dcfc,4 +np.float32,0x6a3bb2,0xc2180afd,4 +np.float32,0x7f4c1e6e,0x4219bbe3,4 +np.float32,0x3e26f625,0xbf49a5a2,4 +np.float32,0xb8482,0xc21be70b,4 +np.float32,0x3f32f077,0xbe1f445b,4 +np.float32,0x7dd694b6,0x4216355a,4 +np.float32,0x7f3d62fd,0x42199a92,4 +np.float32,0x3f48e41a,0xbdd79cbf,4 +np.float32,0x338fc3,0xc2194c75,4 +np.float32,0x3e8355f0,0xbf174462,4 +np.float32,0x7f487e83,0x4219b3eb,4 +np.float32,0x2227f7,0xc21a039b,4 +np.float32,0x7e4383dd,0x4217403a,4 +np.float32,0x52d28b,0xc21879b2,4 +np.float32,0x12472c,0xc21b19a9,4 +np.float32,0x353530,0xc2193e7b,4 +np.float32,0x3f4e4728,0xbdc0137a,4 +np.float32,0x3bf169,0xc2190979,4 +np.float32,0x3eb3ee2e,0xbee8885f,4 +np.float32,0x3f03e3c0,0xbe937892,4 +np.float32,0x3c9f8408,0xbfdaf47f,4 +np.float32,0x40e792,0xc218e61b,4 +np.float32,0x5a6b29,0xc21852ab,4 +np.float32,0x7f268b83,0x4219616a,4 +np.float32,0x3ee25997,0xbeb57fa7,4 +np.float32,0x3f175324,0xbe69cf53,4 +np.float32,0x3f781d91,0xbc5e9827,4 +np.float32,0x7dba5210,0x4215f68c,4 +np.float32,0x7f1e66,0xc217bb2b,4 +np.float32,0x7f7fffff,0x421a209b,4 +np.float32,0x3f646202,0xbd4b10b8,4 +np.float32,0x575248,0xc218622b,4 +np.float32,0x7c67faa1,0x4212bb42,4 +np.float32,0x7f1683f2,0x42193469,4 +np.float32,0x1a3864,0xc21a7931,4 +np.float32,0x7f30ad75,0x42197bae,4 +np.float32,0x7f1c9d05,0x42194612,4 +np.float32,0x3e791795,0xbf1d2b2c,4 +np.float32,0x7e9ebc19,0x421817cd,4 +np.float32,0x4999b7,0xc218ae31,4 +np.float32,0x3d130e2c,0xbfb8f1cc,4 +np.float32,0x3f7e436f,0xbb41bb07,4 +np.float32,0x3ee00241,0xbeb7cf7d,4 +np.float32,0x7e496181,0x42174d5f,4 +np.float32,0x7efe58be,0x4218e978,4 +np.float32,0x3f5e5b0c,0xbd7aa43f,4 +np.float32,0x7ee4c6ab,0x4218ba59,4 +np.float32,0x3f6da8c6,0xbd043d7e,4 +np.float32,0x3e3e6e0f,0xbf3b064b,4 +np.float32,0x3f0143b3,0xbe97f10a,4 +np.float32,0x79170f,0xc217d0c6,4 +np.float32,0x517645,0xc218810f,4 +np.float32,0x3f1f9960,0xbe52226e,4 +np.float32,0x2a8df9,0xc219a1d6,4 +np.float32,0x2300a6,0xc219f8b8,4 +np.float32,0x3ee31355,0xbeb4c97a,4 +np.float32,0x3f20b05f,0xbe4f1ba9,4 +np.float32,0x3ee64249,0xbeb1b0ff,4 +np.float32,0x3a94b7,0xc21913b2,4 +np.float32,0x7ef7ef43,0x4218de1d,4 +np.float32,0x3f1abb5d,0xbe5fe872,4 +np.float32,0x7f65360b,0x4219ef72,4 +np.float32,0x3d315d,0xc219004c,4 +np.float32,0x3f26bbc4,0xbe3eafb9,4 +np.float32,0x3ee8c6e9,0xbeaf45de,4 +np.float32,0x7e5f1452,0x42177ae1,4 +np.float32,0x3f32e777,0xbe1f5aba,4 +np.float32,0x4d39a1,0xc21898d0,4 +np.float32,0x3e59ad15,0xbf2c2841,4 +np.float32,0x3f4be746,0xbdca5fc4,4 +np.float32,0x72e4fd,0xc217e821,4 +np.float32,0x1af0b8,0xc21a6d25,4 +np.float32,0x3f311147,0xbe23f18d,4 +np.float32,0x3f1ecebb,0xbe545880,4 +np.float32,0x7e90d293,0x4217ef02,4 +np.float32,0x3e3b366a,0xbf3ceb46,4 +np.float32,0x3f133239,0xbe761c96,4 +np.float32,0x7541ab,0xc217df15,4 +np.float32,0x3d8c8275,0xbf94f1a1,4 +np.float32,0x483b92,0xc218b689,4 +np.float32,0x3eb0dbed,0xbeec5c6b,4 +np.float32,0x3f00c676,0xbe98c8e2,4 +np.float32,0x3f445ac2,0xbdebed7c,4 +np.float32,0x3d2af4,0xc219007a,4 +np.float32,0x7f196ee1,0x42193cf2,4 +np.float32,0x290c94,0xc219b1db,4 +np.float32,0x3f5dbdc9,0xbd7f9019,4 +np.float32,0x3e80c62e,0xbf1974fc,4 +np.float32,0x3ec9ed2c,0xbecee326,4 +np.float32,0x7f469d60,0x4219afbb,4 +np.float32,0x3f698413,0xbd2386ce,4 +np.float32,0x42163f,0xc218de14,4 +np.float32,0x67a554,0xc21815f4,4 +np.float32,0x3f4bff74,0xbdc9f651,4 +np.float32,0x16a743,0xc21aba39,4 +np.float32,0x2eb8b0,0xc219784b,4 +np.float32,0x3eed9be1,0xbeaab45b,4 +np.float64,0x7fe0d76873e1aed0,0x40733f9d783bad7a,1 +np.float64,0x3fe22626bb244c4d,0xbfcf86a59864eea2,1 +np.float64,0x7f874113d02e8227,0x407324f54c4015b8,1 +np.float64,0x3fe40a46a9e8148d,0xbfca0411f533fcb9,1 +np.float64,0x3fd03932eea07266,0xbfe312bc9cf5649e,1 +np.float64,0x7fee5d2a1b3cba53,0x407343b5f56367a0,1 +np.float64,0x3feb7bda4a76f7b5,0xbfb0ea2c6edc784a,1 +np.float64,0x3fd6cd831a2d9b06,0xbfdcaf2e1a5faf51,1 +np.float64,0x98324e273064a,0xc0733e0e4c6d11c6,1 +np.float64,0x7fe1dd63b363bac6,0x4073400667c405c3,1 +np.float64,0x3fec5971f178b2e4,0xbfaaef32a7d94563,1 +np.float64,0x17abc07e2f579,0xc0734afca4da721e,1 +np.float64,0x3feec6ab5cfd8d57,0xbf9157f3545a8235,1 +np.float64,0x3fe3ae9622a75d2c,0xbfcb04b5ad254581,1 +np.float64,0x7fea73d854b4e7b0,0x407342c0a548f4c5,1 +np.float64,0x7fe29babf4653757,0x4073404eeb5fe714,1 +np.float64,0x7fd3a55d85a74aba,0x40733bde72e86c27,1 +np.float64,0x3fe83ce305f079c6,0xbfbee3511e85e0f1,1 +np.float64,0x3fd72087ea2e4110,0xbfdc4ab30802d7c2,1 +np.float64,0x7feb54ddab76a9ba,0x407342facb6f3ede,1 +np.float64,0xc57e34a18afd,0xc0734f82ec815baa,1 +np.float64,0x7a8cb97ef5198,0xc0733f8fb3777a67,1 +np.float64,0x7fe801032c300205,0x40734213dbe4eda9,1 +np.float64,0x3aefb1f475df7,0xc07344a5f08a0584,1 +np.float64,0x7fee85f1dd3d0be3,0x407343bf4441c2a7,1 +np.float64,0x3fdc7f1055b8fe21,0xbfd67d300630e893,1 +np.float64,0xe8ecddb3d1d9c,0xc0733b194f18f466,1 +np.float64,0x3fdf2b23c73e5648,0xbfd3ff6872c1f887,1 +np.float64,0x3fdba4aef2b7495e,0xbfd7557205e18b7b,1 +np.float64,0x3fe2ac34c6e5586a,0xbfcdf1dac69bfa08,1 +np.float64,0x3fc9852628330a4c,0xbfe66914f0fb9b0a,1 +np.float64,0x7fda211acf344235,0x40733dd9c2177aeb,1 +np.float64,0x3fe9420eb432841d,0xbfba4dd969a32575,1 +np.float64,0xb2f9d1ed65f3a,0xc0733cedfb6527ff,1 +np.float64,0x3fe9768a68f2ed15,0xbfb967c39c35c435,1 +np.float64,0x7fe8268462b04d08,0x4073421eaed32734,1 +np.float64,0x3fcf331f063e663e,0xbfe39e2f4b427ca9,1 +np.float64,0x7fd4eb9e2b29d73b,0x40733c4e4141418d,1 +np.float64,0x7fd2bba658a5774c,0x40733b89cd53d5b1,1 +np.float64,0x3fdfdf04913fbe09,0xbfd360c7fd9d251b,1 +np.float64,0x3fca5bfd0534b7fa,0xbfe5f5f844b2b20c,1 +np.float64,0x3feacd5032f59aa0,0xbfb3b5234ba8bf7b,1 +np.float64,0x7fe9241cec724839,0x4073426631362cec,1 +np.float64,0x3fe57aca20eaf594,0xbfc628e3ac2c6387,1 +np.float64,0x3fec6553ca38caa8,0xbfaa921368d3b222,1 +np.float64,0x3fe1e9676563d2cf,0xbfd020f866ba9b24,1 +np.float64,0x3fd5590667aab20d,0xbfde8458af5a4fd6,1 +np.float64,0x3fdf7528f43eea52,0xbfd3bdb438d6ba5e,1 +np.float64,0xb8dddc5571bbc,0xc0733cb4601e5bb2,1 +np.float64,0xe6d4e1fbcda9c,0xc0733b295ef4a4ba,1 +np.float64,0x3fe7019d962e033b,0xbfc257c0a6e8de16,1 +np.float64,0x3f94ef585029deb1,0xbffb07e5dfb0e936,1 +np.float64,0x7fc863b08030c760,0x4073388e28d7b354,1 +np.float64,0xf684443bed089,0xc0733ab46cfbff9a,1 +np.float64,0x7fe00e901d201d1f,0x40733f489c05a0f0,1 +np.float64,0x9e5c0a273cb82,0xc0733dc7af797e19,1 +np.float64,0x7fe49734f0692e69,0x4073410303680df0,1 +np.float64,0x7fb7b584442f6b08,0x4073338acff72502,1 +np.float64,0x3f99984c30333098,0xbff9a2642a6ed8cc,1 +np.float64,0x7fea2fcda8745f9a,0x407342aeae7f5e64,1 +np.float64,0xe580caadcb01a,0xc0733b33a3639217,1 +np.float64,0x1899ab3831336,0xc0734ab823729417,1 +np.float64,0x39bd4c76737aa,0xc07344ca6fac6d21,1 +np.float64,0xd755b2dbaeab7,0xc0733ba4fe19f2cc,1 +np.float64,0x3f952bebf82a57d8,0xbffaf3e7749c2512,1 +np.float64,0x3fe62ee5d72c5dcc,0xbfc45e3cb5baad08,1 +np.float64,0xb1264a7d624ca,0xc0733d003a1d0a66,1 +np.float64,0x3fc4bd1bcd297a38,0xbfe94b3058345c46,1 +np.float64,0x7fc5758bb32aeb16,0x407337aa7805497f,1 +np.float64,0x3fb0edcaf421db96,0xbff2dfb09c405294,1 +np.float64,0x3fd240fceaa481fa,0xbfe16f356bb36134,1 +np.float64,0x38c0c62a7181a,0xc07344e916d1e9b7,1 +np.float64,0x3fe98f2b3bf31e56,0xbfb8fc6eb622a820,1 +np.float64,0x3fe2bdf99c257bf3,0xbfcdbd0dbbae4d0b,1 +np.float64,0xce4b390d9c967,0xc0733bf14ada3134,1 +np.float64,0x3fd2ad607ba55ac1,0xbfe11da15167b37b,1 +np.float64,0x3fd8154f11b02a9e,0xbfdb2a6fabb9a026,1 +np.float64,0xf37849fde6f09,0xc0733aca8c64344c,1 +np.float64,0x3fcbae43b2375c87,0xbfe547f267c8e570,1 +np.float64,0x3fcd46fd7d3a8dfb,0xbfe48070f7232929,1 +np.float64,0x7fcdd245273ba489,0x407339f3d907b101,1 +np.float64,0x3fac75cd0838eb9a,0xbff4149d177b057b,1 +np.float64,0x7fe8ff3fd7f1fe7f,0x4073425bf968ba6f,1 +np.float64,0x7febadaa4df75b54,0x407343113a91f0e9,1 +np.float64,0x7fd5e4649c2bc8c8,0x40733c9f0620b065,1 +np.float64,0x903429812069,0xc07351b255e27887,1 +np.float64,0x3fe1d8c51c63b18a,0xbfd03ad448c1f1ee,1 +np.float64,0x3fe573ea646ae7d5,0xbfc63ab0bfd0e601,1 +np.float64,0x3f83b3f3c02767e8,0xc00022677e310649,1 +np.float64,0x7fd15d1582a2ba2a,0x40733b02c469c1d6,1 +np.float64,0x3fe63d3dabec7a7b,0xbfc43a56ee97b27e,1 +np.float64,0x7fe3a452fb2748a5,0x407340af1973c228,1 +np.float64,0x3fafac6b303f58d6,0xbff35651703ae9f2,1 +np.float64,0x513ddd24a27bc,0xc073426af96aaebb,1 +np.float64,0x3fef152246be2a45,0xbf89df79d7719282,1 +np.float64,0x3fe8c923e9f19248,0xbfbc67228e8db5f6,1 +np.float64,0x3fd6e2325fadc465,0xbfdc9602fb0b950f,1 +np.float64,0x3fe9616815f2c2d0,0xbfb9c4311a3b415b,1 +np.float64,0x2fe4e4005fc9d,0xc0734616fe294395,1 +np.float64,0x3fbceb02dc39d606,0xbfee4e68f1c7886f,1 +np.float64,0x7fe35e843d66bd07,0x407340963b066ad6,1 +np.float64,0x7fecd6c648f9ad8c,0x4073435a4c176e94,1 +np.float64,0x7fcbd72bf437ae57,0x4073397994b85665,1 +np.float64,0x3feff6443b3fec88,0xbf40eb380d5318ae,1 +np.float64,0x7fb9373cf6326e79,0x407333f869edef08,1 +np.float64,0x63790d9cc6f22,0xc0734102d4793cda,1 +np.float64,0x3f9de6efe83bcde0,0xbff88db6f0a6b56e,1 +np.float64,0xe00f2dc1c01f,0xc0734ea26ab84ff2,1 +np.float64,0xd7a9aa8baf536,0xc0733ba248fa33ab,1 +np.float64,0x3fee0089ea7c0114,0xbf9cab936ac31c4b,1 +np.float64,0x3fdec0d51cbd81aa,0xbfd45ed8878c5860,1 +np.float64,0x7fe91bf5e9f237eb,0x40734263f005081d,1 +np.float64,0x34ea7d1e69d50,0xc07345659dde7444,1 +np.float64,0x7fe67321a3ace642,0x4073419cc8130d95,1 +np.float64,0x9d1aeb2f3a35e,0xc0733dd5d506425c,1 +np.float64,0x7fbb01df003603bd,0x4073347282f1391d,1 +np.float64,0x42b945b285729,0xc07343c92d1bbef9,1 +np.float64,0x7fc92799b8324f32,0x407338c51e3f0733,1 +np.float64,0x3fe119c19b223383,0xbfd16ab707f65686,1 +np.float64,0x3fc9f9ac5333f359,0xbfe62a2f91ec0dff,1 +np.float64,0x3fd820d5a8b041ab,0xbfdb1d2586fe7b18,1 +np.float64,0x10000000000000,0xc0733a7146f72a42,1 +np.float64,0x3fe7e1543eafc2a8,0xbfc045362889592d,1 +np.float64,0xcbc0e1819783,0xc0734f4b68e05b1c,1 +np.float64,0xeb57e411d6afd,0xc0733b06efec001a,1 +np.float64,0xa9b74b47536ea,0xc0733d4c7bd06ddc,1 +np.float64,0x3fe56d4022eada80,0xbfc64bf8c7e3dd59,1 +np.float64,0x3fd445ca27288b94,0xbfdff40aecd0f882,1 +np.float64,0x3fe5af1cf5ab5e3a,0xbfc5a21d83699a04,1 +np.float64,0x7fed3431eb7a6863,0x40734370aa6131e1,1 +np.float64,0x3fd878dea1b0f1bd,0xbfdab8730dc00517,1 +np.float64,0x7ff8000000000000,0x7ff8000000000000,1 +np.float64,0x3feba9fcc1f753fa,0xbfb03027dcecbf65,1 +np.float64,0x7fca4feed6349fdd,0x4073391526327eb0,1 +np.float64,0x3fe7748ddbaee91c,0xbfc144b438218065,1 +np.float64,0x3fb5fbd94c2bf7b3,0xbff10ee6342c21a0,1 +np.float64,0x3feb603b97f6c077,0xbfb15a1f99d6d25e,1 +np.float64,0x3fe2e6fc8ce5cdf9,0xbfcd43edd7f3b4e6,1 +np.float64,0x7feb2b31f7765663,0x407342f02b306688,1 +np.float64,0x3fe290e2282521c4,0xbfce436deb8dbcf3,1 +np.float64,0x3fe3d5adf9e7ab5c,0xbfca96b8aa55d942,1 +np.float64,0x691899f2d2314,0xc07340a1026897c8,1 +np.float64,0x7fe468b008e8d15f,0x407340f33eadc628,1 +np.float64,0x3fb3a4c416274988,0xbff1d71da539a56e,1 +np.float64,0x3fe2442b29e48856,0xbfcf2b0037322661,1 +np.float64,0x3f376fbc7e6ef,0xc073442939a84643,1 +np.float64,0x3fe7c78d65ef8f1b,0xbfc08157cff411de,1 +np.float64,0xd4f27acba9e50,0xc0733bb8d38daa50,1 +np.float64,0x5198919ea3313,0xc07342633ba7cbea,1 +np.float64,0x7fd09f66f0a13ecd,0x40733ab5310b4385,1 +np.float64,0x3fdfe5531dbfcaa6,0xbfd35b487c7e739f,1 +np.float64,0x3fc4b0fecc2961fe,0xbfe95350c38c1640,1 +np.float64,0x7fd5ae21962b5c42,0x40733c8db78b7250,1 +np.float64,0x3fa4a8fcd42951fa,0xbff64e62fe602b72,1 +np.float64,0x7fc8e0e25831c1c4,0x407338b179b91223,1 +np.float64,0x7fdde1df6f3bc3be,0x40733ec87f9f027e,1 +np.float64,0x3fd8b9ad86b1735b,0xbfda6f385532c41b,1 +np.float64,0x3fd9f20ee933e41e,0xbfd91872fd858597,1 +np.float64,0x7feb35332df66a65,0x407342f2b9c715f0,1 +np.float64,0x7fe783dc7eaf07b8,0x407341ef41873706,1 +np.float64,0x7fceee929f3ddd24,0x40733a34e3c660fd,1 +np.float64,0x985b58d730b6b,0xc0733e0c6cfbb6f8,1 +np.float64,0x3fef4bb55cfe976b,0xbf83cb246c6f2a78,1 +np.float64,0x3fe218014f243003,0xbfcfb20ac683e1f6,1 +np.float64,0x7fe43b9fbea8773e,0x407340e3d5d5d29e,1 +np.float64,0x7fe148c74c62918e,0x40733fcba4367b8b,1 +np.float64,0x3feea4ad083d495a,0xbf93443917f3c991,1 +np.float64,0x8bcf6311179ed,0xc0733ea54d59dd31,1 +np.float64,0xf4b7a2dbe96f5,0xc0733ac175182401,1 +np.float64,0x543338baa8668,0xc073422b59165fe4,1 +np.float64,0x3fdb467317368ce6,0xbfd7b4d515929635,1 +np.float64,0x7fe3bbbc89e77778,0x407340b75cdf3de7,1 +np.float64,0x7fe693377aad266e,0x407341a6af60a0f1,1 +np.float64,0x3fc66210502cc421,0xbfe83bb940610a24,1 +np.float64,0x7fa75638982eac70,0x40732e9da476b816,1 +np.float64,0x3fe0d72a4761ae55,0xbfd1d7c82c479fab,1 +np.float64,0x97dec0dd2fbd8,0xc0733e121e072804,1 +np.float64,0x3fef33ec8c7e67d9,0xbf86701be6be8df1,1 +np.float64,0x7fcfca9b423f9536,0x40733a65a51efb94,1 +np.float64,0x9f2215633e443,0xc0733dbf043de9ed,1 +np.float64,0x2469373e48d28,0xc07347fe9e904b77,1 +np.float64,0x7fecc2e18cb985c2,0x407343557f58dfa2,1 +np.float64,0x3fde4acbfdbc9598,0xbfd4ca559e575e74,1 +np.float64,0x3fd6b11cf1ad623a,0xbfdcd1e17ef36114,1 +np.float64,0x3fc19ec494233d89,0xbfeb8ef228e8826a,1 +np.float64,0x4c89ee389913e,0xc07342d50c904f61,1 +np.float64,0x88c2046f11841,0xc0733ecc91369431,1 +np.float64,0x7fc88c13fd311827,0x40733899a125b392,1 +np.float64,0x3fcebd893a3d7b12,0xbfe3d2f35ab93765,1 +np.float64,0x3feb582a1476b054,0xbfb17ae8ec6a0465,1 +np.float64,0x7fd4369e5da86d3c,0x40733c1118b8cd67,1 +np.float64,0x3fda013fc1340280,0xbfd90831b85e98b2,1 +np.float64,0x7fed33d73fba67ad,0x4073437094ce1bd9,1 +np.float64,0x3fed3191053a6322,0xbfa468cc26a8f685,1 +np.float64,0x3fc04ed51c209daa,0xbfeca24a6f093bca,1 +np.float64,0x3fee4ac8763c9591,0xbf986458abbb90b5,1 +np.float64,0xa2d39dd145a74,0xc0733d9633651fbc,1 +np.float64,0x3fe7d9f86f2fb3f1,0xbfc0565a0b059f1c,1 +np.float64,0x3fe3250144e64a03,0xbfcc8eb2b9ae494b,1 +np.float64,0x7fe2b29507a56529,0x4073405774492075,1 +np.float64,0x7fdcdfcbe2b9bf97,0x40733e8b736b1bd8,1 +np.float64,0x3fc832730f3064e6,0xbfe7267ac9b2e7c3,1 +np.float64,0x3fc7e912e52fd226,0xbfe750dfc0aeae57,1 +np.float64,0x7fc960472f32c08d,0x407338d4b4cb3957,1 +np.float64,0x3fbdf182ea3be306,0xbfedd27150283ffb,1 +np.float64,0x3fd1e9359823d26b,0xbfe1b2ac7fd25f8d,1 +np.float64,0x7fbcf75f6039eebe,0x407334ef13eb16f8,1 +np.float64,0x3fe5a3c910eb4792,0xbfc5bf2f57c5d643,1 +np.float64,0x3fcf4f2a6e3e9e55,0xbfe391b6f065c4b8,1 +np.float64,0x3fee067873fc0cf1,0xbf9c53af0373fc0e,1 +np.float64,0xd3f08b85a7e12,0xc0733bc14357e686,1 +np.float64,0x7ff0000000000000,0x7ff0000000000000,1 +np.float64,0x3fc8635f6430c6bf,0xbfe70a7dc77749a7,1 +np.float64,0x3fe3ff5c52a7feb9,0xbfca22617c6636d5,1 +np.float64,0x3fbbae91fa375d24,0xbfeee9d4c300543f,1 +np.float64,0xe3f71b59c7ee4,0xc0733b3f99187375,1 +np.float64,0x7fca93d3be3527a6,0x40733926fd48ecd6,1 +np.float64,0x3fcd29f7223a53ee,0xbfe48e3edf32fe57,1 +np.float64,0x7fdc4ef6f8389ded,0x40733e68401cf2a6,1 +np.float64,0xe009bc81c014,0xc0734ea295ee3e5b,1 +np.float64,0x61f56c78c3eae,0xc073411e1dbd7c54,1 +np.float64,0x3fde131928bc2632,0xbfd4fda024f6927c,1 +np.float64,0x3fb21ee530243dca,0xbff266aaf0358129,1 +np.float64,0x7feaac82a4f55904,0x407342cf7809d9f9,1 +np.float64,0x3fe66ab177ecd563,0xbfc3c92d4d522819,1 +np.float64,0xfe9f9c2bfd3f4,0xc0733a7ade3a88a7,1 +np.float64,0x7fd0c5217c218a42,0x40733ac4e4c6dfa5,1 +np.float64,0x430f4ae6861ea,0xc07343c03d8a9442,1 +np.float64,0x494bff2a92981,0xc073432209d2fd16,1 +np.float64,0x3f8860e9d030c1d4,0xbffeca059ebf5e89,1 +np.float64,0x3fe43732dc286e66,0xbfc98800388bad2e,1 +np.float64,0x6443b60ec8877,0xc07340f4bab11827,1 +np.float64,0x3feda9be6d7b537d,0xbfa0dcb9a6914069,1 +np.float64,0x3fc5ceb6772b9d6d,0xbfe89868c881db70,1 +np.float64,0x3fbdf153023be2a6,0xbfedd2878c3b4949,1 +np.float64,0x7fe8f6b8e8f1ed71,0x407342599a30b273,1 +np.float64,0x3fea6fbdb8b4df7b,0xbfb53bf66f71ee96,1 +np.float64,0xc7ac3dbb8f588,0xc0733c2b525b7963,1 +np.float64,0x3fef3a91f77e7524,0xbf85b2bd3adbbe31,1 +np.float64,0x3f887cb97030f973,0xbffec21ccbb5d22a,1 +np.float64,0x8b2f1c9f165e4,0xc0733ead49300951,1 +np.float64,0x2c1cb32058397,0xc07346a951bd8d2b,1 +np.float64,0x3fe057edd620afdc,0xbfd2acf1881b7e99,1 +np.float64,0x7f82e9530025d2a5,0x4073238591dd52ce,1 +np.float64,0x3fe4e03dff69c07c,0xbfc7be96c5c006fc,1 +np.float64,0x52727b4aa4e50,0xc0734250c58ebbc1,1 +np.float64,0x3f99a62160334c43,0xbff99ea3ca09d8f9,1 +np.float64,0x3fd5314b4faa6297,0xbfdeb843daf01e03,1 +np.float64,0x3fefde89e13fbd14,0xbf5d1facb7a1e9de,1 +np.float64,0x7fb460f1a228c1e2,0x4073327d8cbc5f86,1 +np.float64,0xeb93efb3d727e,0xc0733b052a4990e4,1 +np.float64,0x3fe884baecf10976,0xbfbd9ba9cfe23713,1 +np.float64,0x7fefffffffffffff,0x40734413509f79ff,1 +np.float64,0x149dc7c6293ba,0xc0734bf26b1df025,1 +np.float64,0x64188f88c8313,0xc07340f7b8e6f4b5,1 +np.float64,0x3fdfac314abf5863,0xbfd38d3e9dba1b0e,1 +np.float64,0x3fd72052a42e40a5,0xbfdc4af30ee0b245,1 +np.float64,0x7fdd951f743b2a3e,0x40733eb68fafa838,1 +np.float64,0x65a2dd5acb45c,0xc07340dc8ed625e1,1 +np.float64,0x7fe89a79997134f2,0x4073423fbceb1cbe,1 +np.float64,0x3fe70a000d6e1400,0xbfc24381e09d02f7,1 +np.float64,0x3fe2cec160259d83,0xbfcd8b5e92354129,1 +np.float64,0x3feb9ef77a773def,0xbfb05c7b2ee6f388,1 +np.float64,0xe0d66689c1acd,0xc0733b582c779620,1 +np.float64,0x3fee86bd0ffd0d7a,0xbf94f7870502c325,1 +np.float64,0x186afc6230d60,0xc0734ac55fb66d5d,1 +np.float64,0xc0631f4b80c64,0xc0733c6d7149d373,1 +np.float64,0x3fdad1b87735a371,0xbfd82cca73ec663b,1 +np.float64,0x7fe7f6d313efeda5,0x40734210e84576ab,1 +np.float64,0x7fd7b7fce6af6ff9,0x40733d2d92ffdaaf,1 +np.float64,0x3fe6f35a28ade6b4,0xbfc27a4239b540c3,1 +np.float64,0x7fdb0b834eb61706,0x40733e17073a61f3,1 +np.float64,0x82f4661105e8d,0xc0733f19b34adeed,1 +np.float64,0x3fc77230112ee460,0xbfe796a7603c0d16,1 +np.float64,0x8000000000000000,0xfff0000000000000,1 +np.float64,0x7fb8317bc63062f7,0x407333aec761a739,1 +np.float64,0x7fd165609a22cac0,0x40733b061541ff15,1 +np.float64,0x3fed394768fa728f,0xbfa42e1596e1faf6,1 +np.float64,0x7febab693d7756d1,0x40734310a9ac828e,1 +np.float64,0x7fe809a69230134c,0x407342165b9acb69,1 +np.float64,0x3fc091d38f2123a7,0xbfec69a70fc23548,1 +np.float64,0x3fb2a8f5dc2551ec,0xbff2327f2641dd0d,1 +np.float64,0x7fc60b6fe02c16df,0x407337da5adc342c,1 +np.float64,0x3fefa53c3bbf4a78,0xbf73d1be15b73b00,1 +np.float64,0x7fee09c1717c1382,0x407343a2c479e1cb,1 +np.float64,0x8000000000000001,0x7ff8000000000000,1 +np.float64,0x3fede0b2733bc165,0xbf9e848ac2ecf604,1 +np.float64,0x3fee2ac331bc5586,0xbf9a3b699b721c9a,1 +np.float64,0x3fd4db12d829b626,0xbfdf2a413d1e453a,1 +np.float64,0x7fe605230dec0a45,0x4073417a67db06be,1 +np.float64,0x3fe378b2bf26f165,0xbfcb9dbb2b6d6832,1 +np.float64,0xc1d4c1ab83a98,0xc0733c60244cadbf,1 +np.float64,0x3feb15500e762aa0,0xbfb28c071d5efc22,1 +np.float64,0x3fe36225a626c44b,0xbfcbde4259e9047e,1 +np.float64,0x3fe7c586a72f8b0d,0xbfc08614b13ed4b2,1 +np.float64,0x7fb0f2d8cc21e5b1,0x40733135b2c7dd99,1 +np.float64,0x5957f3feb2aff,0xc07341c1df75638c,1 +np.float64,0x3fca4851bd3490a3,0xbfe6005ae5279485,1 +np.float64,0x824217d904843,0xc0733f232fd58f0f,1 +np.float64,0x4f9332269f267,0xc073428fd8e9cb32,1 +np.float64,0x3fea6f087374de11,0xbfb53ef0d03918b2,1 +np.float64,0x3fd9409ab4328135,0xbfd9d9231381e2b8,1 +np.float64,0x3fdba03b00374076,0xbfd759ec94a7ab5b,1 +np.float64,0x3fe0ce3766619c6f,0xbfd1e6912582ccf0,1 +np.float64,0x3fabd45ddc37a8bc,0xbff43c78d3188423,1 +np.float64,0x3fc3cadd592795bb,0xbfe9f1576c9b2c79,1 +np.float64,0x3fe10df049621be1,0xbfd17df2f2c28022,1 +np.float64,0x945b5d1328b6c,0xc0733e3bc06f1e75,1 +np.float64,0x7fc1c3742b2386e7,0x4073365a403d1051,1 +np.float64,0x7fdc957138b92ae1,0x40733e7977717586,1 +np.float64,0x7f943fa1a0287f42,0x407328d01de143f5,1 +np.float64,0x3fec9631c4392c64,0xbfa914b176d8f9d2,1 +np.float64,0x3fd8e7c008b1cf80,0xbfda3b9d9b6da8f4,1 +np.float64,0x7222f9fee4460,0xc073400e371516cc,1 +np.float64,0x3fe890e43eb121c8,0xbfbd64921462e823,1 +np.float64,0x3fcfd7fe2a3faffc,0xbfe3557e2f207800,1 +np.float64,0x3fed5dd1c1babba4,0xbfa318bb20db64e6,1 +np.float64,0x3fe6aa34c66d546a,0xbfc32c8a8991c11e,1 +np.float64,0x8ca79801196,0xc0736522bd5adf6a,1 +np.float64,0x3feb274079364e81,0xbfb2427b24b0ca20,1 +np.float64,0x7fe04927e4a0924f,0x40733f61c96f7f89,1 +np.float64,0x7c05f656f80bf,0xc0733f7a70555b4e,1 +np.float64,0x7fe97819eff2f033,0x4073427d4169b0f8,1 +np.float64,0x9def86e33bdf1,0xc0733dcc740b7175,1 +np.float64,0x7fedd1ef3f3ba3dd,0x40734395ceab8238,1 +np.float64,0x77bed86cef7dc,0xc0733fb8e0e9bf73,1 +np.float64,0x9274b41b24e97,0xc0733e52b16dff71,1 +np.float64,0x8010000000000000,0x7ff8000000000000,1 +np.float64,0x9c977855392ef,0xc0733ddba7d421d9,1 +np.float64,0xfb4560a3f68ac,0xc0733a9271e6a118,1 +np.float64,0xa67d9f394cfb4,0xc0733d6e9d58cc94,1 +np.float64,0x3fbfa766b03f4ecd,0xbfed0cccfecfc900,1 +np.float64,0x3fe177417522ee83,0xbfd0d45803bff01a,1 +np.float64,0x7fe85e077bb0bc0e,0x4073422e957a4aa3,1 +np.float64,0x7feeb0a6883d614c,0x407343c8f6568f7c,1 +np.float64,0xbab82edb75706,0xc0733ca2a2b20094,1 +np.float64,0xfadb44bdf5b69,0xc0733a9561b7ec04,1 +np.float64,0x3fefb9b82b3f7370,0xbf6ea776b2dcc3a9,1 +np.float64,0x7fe080ba8a610174,0x40733f795779b220,1 +np.float64,0x3f87faa1c02ff544,0xbffee76acafc92b7,1 +np.float64,0x7fed474108fa8e81,0x4073437531d4313e,1 +np.float64,0x3fdb7b229336f645,0xbfd77f583a4a067f,1 +np.float64,0x256dbf0c4adb9,0xc07347cd94e6fa81,1 +np.float64,0x3fd034ae25a0695c,0xbfe3169c15decdac,1 +np.float64,0x3a72177274e44,0xc07344b4cf7d68cd,1 +np.float64,0x7fa2522d5c24a45a,0x40732cef2f793470,1 +np.float64,0x3fb052bdde20a57c,0xbff3207fd413c848,1 +np.float64,0x3fdccfecbbb99fd9,0xbfd62ec04a1a687a,1 +np.float64,0x3fd403ac53280759,0xbfe027a31df2c8cc,1 +np.float64,0x3fab708e4036e11d,0xbff45591df4f2e8b,1 +np.float64,0x7fcfc001993f8002,0x40733a63539acf9d,1 +np.float64,0x3fd2b295dfa5652c,0xbfe119c1b476c536,1 +np.float64,0x7fe8061262b00c24,0x4073421552ae4538,1 +np.float64,0xffefffffffffffff,0x7ff8000000000000,1 +np.float64,0x7fed52093ffaa411,0x40734377c072a7e8,1 +np.float64,0xf3df902fe7bf2,0xc0733ac79a75ff7a,1 +np.float64,0x7fe13d382e227a6f,0x40733fc6fd0486bd,1 +np.float64,0x3621d5086c43b,0xc073453d31effbcd,1 +np.float64,0x3ff0000000000000,0x0,1 +np.float64,0x3fdaffea27b5ffd4,0xbfd7fd139dc1c2c5,1 +np.float64,0x7fea6536dc34ca6d,0x407342bccc564fdd,1 +np.float64,0x7fd478f00c28f1df,0x40733c27c0072fde,1 +np.float64,0x7fa72ef0502e5de0,0x40732e91e83db75c,1 +np.float64,0x7fd302970626052d,0x40733ba3ec6775f6,1 +np.float64,0x7fbb57ab0036af55,0x407334887348e613,1 +np.float64,0x3fda0ff722b41fee,0xbfd8f87b77930330,1 +np.float64,0x1e983ce23d309,0xc073493438f57e61,1 +np.float64,0x7fc90de97c321bd2,0x407338be01ffd4bd,1 +np.float64,0x7fe074b09c20e960,0x40733f7443f0dbe1,1 +np.float64,0x3fed5dec9fbabbd9,0xbfa317efb1fe8a95,1 +np.float64,0x7fdb877632b70eeb,0x40733e3697c88ba8,1 +np.float64,0x7fe4fb0067e9f600,0x40734124604b99e8,1 +np.float64,0x7fd447dc96288fb8,0x40733c1703ab2cce,1 +np.float64,0x3feb2d1e64f65a3d,0xbfb22a781df61c05,1 +np.float64,0xb6c8e6676d91d,0xc0733cc8859a0b91,1 +np.float64,0x3fdc3c2418387848,0xbfd6bec3a3c3cdb5,1 +np.float64,0x3fdecb9ccdbd973a,0xbfd4551c05721a8e,1 +np.float64,0x3feb1100e7762202,0xbfb29db911fe6768,1 +np.float64,0x3fe0444bc2a08898,0xbfd2ce69582e78c1,1 +np.float64,0x7fda403218b48063,0x40733de201d8340c,1 +np.float64,0x3fdc70421238e084,0xbfd68ba4bd48322b,1 +np.float64,0x3fe06e747c60dce9,0xbfd286bcac34a981,1 +np.float64,0x7fc1931d9623263a,0x407336473da54de4,1 +np.float64,0x229914da45323,0xc073485979ff141c,1 +np.float64,0x3fe142f92da285f2,0xbfd1280909992cb6,1 +np.float64,0xf1d02fa9e3a06,0xc0733ad6b19d71a0,1 +np.float64,0x3fb1fe9b0023fd36,0xbff27317d8252c16,1 +np.float64,0x3fa544b9242a8972,0xbff61ac38569bcfc,1 +np.float64,0x3feeb129d4fd6254,0xbf928f23ad20c1ee,1 +np.float64,0xa2510b7f44a22,0xc0733d9bc81ea0a1,1 +np.float64,0x3fca75694d34ead3,0xbfe5e8975b3646c2,1 +np.float64,0x7fece10621b9c20b,0x4073435cc3dd9a1b,1 +np.float64,0x7fe98a57d3b314af,0x4073428239b6a135,1 +np.float64,0x3fe259c62a64b38c,0xbfcee96682a0f355,1 +np.float64,0x3feaaa9b9d755537,0xbfb445779f3359af,1 +np.float64,0xdaadecfdb55be,0xc0733b899338432a,1 +np.float64,0x3fed00eae4fa01d6,0xbfa5dc8d77be5991,1 +np.float64,0x7fcc96c773392d8e,0x407339a8c5cd786e,1 +np.float64,0x3fef7b8b203ef716,0xbf7cff655ecb6424,1 +np.float64,0x7fd4008113a80101,0x40733bfe6552acb7,1 +np.float64,0x7fe99ff035b33fdf,0x407342881753ee2e,1 +np.float64,0x3ee031e87dc07,0xc0734432d736e492,1 +np.float64,0x3fddfe390f3bfc72,0xbfd510f1d9ec3e36,1 +np.float64,0x3fd9ddce74b3bb9d,0xbfd92e2d75a061bb,1 +np.float64,0x7fe5f742edebee85,0x40734176058e3a77,1 +np.float64,0x3fdb04185b360831,0xbfd7f8c63aa5e1c4,1 +np.float64,0xea2b0f43d4562,0xc0733b0fd77c8118,1 +np.float64,0x7fc3f4973527e92d,0x407337293bbb22c4,1 +np.float64,0x3fb9adfb38335bf6,0xbfeff4f3ea85821a,1 +np.float64,0x87fb98750ff73,0xc0733ed6ad83c269,1 +np.float64,0x3fe005721a200ae4,0xbfd33a9f1ebfb0ac,1 +np.float64,0xd9e04fe7b3c0a,0xc0733b901ee257f3,1 +np.float64,0x2c39102658723,0xc07346a4db63bf55,1 +np.float64,0x3f7dc28e003b851c,0xc0011c1d1233d948,1 +np.float64,0x3430fd3868620,0xc073457e24e0b70d,1 +np.float64,0xbff0000000000000,0x7ff8000000000000,1 +np.float64,0x3fd23e45e0247c8c,0xbfe17146bcf87b57,1 +np.float64,0x6599df3ecb33d,0xc07340dd2c41644c,1 +np.float64,0x3fdf074f31be0e9e,0xbfd41f6e9dbb68a5,1 +np.float64,0x7fdd6233f3bac467,0x40733eaa8f674b72,1 +np.float64,0x7fe03e8481607d08,0x40733f5d3df3b087,1 +np.float64,0x3fcc3b79f13876f4,0xbfe501bf3b379b77,1 +np.float64,0xe5d97ae3cbb30,0xc0733b30f47cbd12,1 +np.float64,0x8acbc4a115979,0xc0733eb240a4d2c6,1 +np.float64,0x3fedbdbc48bb7b79,0xbfa0470fd70c4359,1 +np.float64,0x3fde1611103c2c22,0xbfd4fae1fa8e7e5e,1 +np.float64,0x3fe09478bd2128f1,0xbfd246b7e85711dc,1 +np.float64,0x3fd6dfe8f3adbfd2,0xbfdc98ca2f32c1ad,1 +np.float64,0x72ccf274e599f,0xc0734003e5b0da63,1 +np.float64,0xe27c7265c4f8f,0xc0733b4b2d808566,1 +np.float64,0x7fee3161703c62c2,0x407343abe90f5649,1 +np.float64,0xf54fb5c1eaa0,0xc0734e01384fcf78,1 +np.float64,0xcde5924d9bcb3,0xc0733bf4b83c66c2,1 +np.float64,0x3fc46fdbe528dfb8,0xbfe97f55ef5e9683,1 +np.float64,0x7fe513528a2a26a4,0x4073412c69baceca,1 +np.float64,0x3fd29eca4aa53d95,0xbfe128801cd33ed0,1 +np.float64,0x7febb21718b7642d,0x4073431256def857,1 +np.float64,0x3fcab536c0356a6e,0xbfe5c73c59f41578,1 +np.float64,0x7fc7e9f0d82fd3e1,0x4073386b213e5dfe,1 +np.float64,0xb5b121276b624,0xc0733cd33083941c,1 +np.float64,0x7e0dd9bcfc1bc,0xc0733f5d8bf35050,1 +np.float64,0x3fd1c75106238ea2,0xbfe1cd11cccda0f4,1 +np.float64,0x9f060e673e0c2,0xc0733dc03da71909,1 +np.float64,0x7fd915a2f3322b45,0x40733d912af07189,1 +np.float64,0x3fd8cbae4431975d,0xbfda5b02ca661139,1 +np.float64,0x3fde8b411f3d1682,0xbfd48f6f710a53b6,1 +np.float64,0x3fc17a780622f4f0,0xbfebabb10c55255f,1 +np.float64,0x3fde5cbe5f3cb97d,0xbfd4b9e2e0101fb1,1 +np.float64,0x7fd859036530b206,0x40733d5c2252ff81,1 +np.float64,0xb0f5040f61ea1,0xc0733d02292f527b,1 +np.float64,0x3fde5c49ae3cb893,0xbfd4ba4db3ce2cf3,1 +np.float64,0x3fecc4518df988a3,0xbfa7af0bfc98bc65,1 +np.float64,0x3feffee03cbffdc0,0xbf0f3ede6ca7d695,1 +np.float64,0xbc5eac9b78bd6,0xc0733c92fb51c8ae,1 +np.float64,0x3fe2bb4ef765769e,0xbfcdc4f70a65dadc,1 +np.float64,0x5089443ca1129,0xc073427a7d0cde4a,1 +np.float64,0x3fd0d6e29121adc5,0xbfe28e28ece1db86,1 +np.float64,0xbe171e397c2e4,0xc0733c82cede5d02,1 +np.float64,0x4ede27be9dbc6,0xc073429fba1a4af1,1 +np.float64,0x3fe2aff3af655fe7,0xbfcde6b52a8ed3c1,1 +np.float64,0x7fd85ca295b0b944,0x40733d5d2adcccf1,1 +np.float64,0x24919bba49234,0xc07347f6ed704a6f,1 +np.float64,0x7fd74bc1eeae9783,0x40733d0d94a89011,1 +np.float64,0x3fc1cd12cb239a26,0xbfeb6a9c25c2a11d,1 +np.float64,0x3fdafbc0ac35f781,0xbfd8015ccf1f1b51,1 +np.float64,0x3fee01327c3c0265,0xbf9ca1d0d762dc18,1 +np.float64,0x3fe65bd7702cb7af,0xbfc3ee0de5c36b8d,1 +np.float64,0x7349c82ee693a,0xc0733ffc5b6eccf2,1 +np.float64,0x3fdc5906f738b20e,0xbfd6a26288eb5933,1 +np.float64,0x1,0xc07434e6420f4374,1 +np.float64,0x3fb966128a32cc25,0xbff00e0aa7273838,1 +np.float64,0x3fd501ff9a2a03ff,0xbfdef69133482121,1 +np.float64,0x194d4f3c329ab,0xc0734a861b44cfbe,1 +np.float64,0x3fec5d34f8f8ba6a,0xbfaad1b31510e70b,1 +np.float64,0x1635e4c22c6be,0xc0734b6dec650943,1 +np.float64,0x3fead2f8edb5a5f2,0xbfb39dac30a962cf,1 +np.float64,0x3f7dfa4ce03bf49a,0xc00115a112141aa7,1 +np.float64,0x3fef6827223ed04e,0xbf80a42c9edebfe9,1 +np.float64,0xe771f303cee3f,0xc0733b24a6269fe4,1 +np.float64,0x1160ccc622c1b,0xc0734d22604eacb9,1 +np.float64,0x3fc485cd08290b9a,0xbfe970723008c8c9,1 +np.float64,0x7fef99c518bf3389,0x407343fcf9ed202f,1 +np.float64,0x7fd8c1447a318288,0x40733d79a440b44d,1 +np.float64,0xaf219f955e434,0xc0733d149c13f440,1 +np.float64,0xcf45f6239e8bf,0xc0733be8ddda045d,1 +np.float64,0x7599394aeb328,0xc0733fd90fdbb0ea,1 +np.float64,0xc7f6390f8fec7,0xc0733c28bfbc66a3,1 +np.float64,0x3fd39ae96c2735d3,0xbfe0712274a8742b,1 +np.float64,0xa4d6c18f49ad8,0xc0733d805a0528f7,1 +np.float64,0x7fd9ea78d7b3d4f1,0x40733dcb2b74802a,1 +np.float64,0x3fecd251cb39a4a4,0xbfa742ed41d4ae57,1 +np.float64,0x7fed7a07cd7af40f,0x407343813476027e,1 +np.float64,0x3fd328ae7f26515d,0xbfe0c30b56a83c64,1 +np.float64,0x7fc937ff7a326ffe,0x407338c9a45b9140,1 +np.float64,0x3fcf1d31143e3a62,0xbfe3a7f760fbd6a8,1 +np.float64,0x7fb911dcbc3223b8,0x407333ee158cccc7,1 +np.float64,0x3fd352fc83a6a5f9,0xbfe0a47d2f74d283,1 +np.float64,0x7fd310753fa620e9,0x40733ba8fc4300dd,1 +np.float64,0x3febd64b4577ac97,0xbfaefd4a79f95c4b,1 +np.float64,0x6a6961a4d4d2d,0xc073408ae1687943,1 +np.float64,0x3fe4ba73d16974e8,0xbfc8239341b9e457,1 +np.float64,0x3fed8e7cac3b1cf9,0xbfa1a96a0cc5fcdc,1 +np.float64,0x7fd505ec04aa0bd7,0x40733c56f86e3531,1 +np.float64,0x3fdf166e9abe2cdd,0xbfd411e5f8569d70,1 +np.float64,0x7fe1bc6434e378c7,0x40733ff9861bdabb,1 +np.float64,0x3fd3b0b175a76163,0xbfe061ba5703f3c8,1 +np.float64,0x7fed75d7ffbaebaf,0x4073438037ba6f19,1 +np.float64,0x5a9e109cb53c3,0xc07341a8b04819c8,1 +np.float64,0x3fe14786b4e28f0d,0xbfd120b541bb880e,1 +np.float64,0x3fed4948573a9291,0xbfa3b471ff91614b,1 +np.float64,0x66aac5d8cd559,0xc07340ca9b18af46,1 +np.float64,0x3fdb48efd23691e0,0xbfd7b24c5694838b,1 +np.float64,0x7fe6da7d1eadb4f9,0x407341bc7d1fae43,1 +np.float64,0x7feb702cf336e059,0x40734301b96cc3c0,1 +np.float64,0x3fd1e60987a3cc13,0xbfe1b522cfcc3d0e,1 +np.float64,0x3feca57f50794aff,0xbfa89dc90625d39c,1 +np.float64,0x7fdc46dc56b88db8,0x40733e664294a0f9,1 +np.float64,0x8dc8fd811b920,0xc0733e8c5955df06,1 +np.float64,0xf01634abe02c7,0xc0733ae370a76d0c,1 +np.float64,0x3fc6f8d8ab2df1b1,0xbfe7df5093829464,1 +np.float64,0xda3d7597b47af,0xc0733b8d2702727a,1 +np.float64,0x7feefd53227dfaa5,0x407343da3d04db28,1 +np.float64,0x3fe2fbca3525f794,0xbfcd06e134417c08,1 +np.float64,0x7fd36d3ce226da79,0x40733bca7c322df1,1 +np.float64,0x7fec37e00b786fbf,0x4073433397b48a5b,1 +np.float64,0x3fbf133f163e267e,0xbfed4e72f1362a77,1 +np.float64,0x3fc11efbb9223df7,0xbfebf53002a561fe,1 +np.float64,0x3fc89c0e5431381d,0xbfe6ea562364bf81,1 +np.float64,0x3f9cd45da839a8bb,0xbff8ceb14669ee4b,1 +np.float64,0x23dc8fa647b93,0xc0734819aaa9b0ee,1 +np.float64,0x3fe829110d305222,0xbfbf3e60c45e2399,1 +np.float64,0x7fed8144e57b0289,0x40734382e917a02a,1 +np.float64,0x7fe033fbf7a067f7,0x40733f58bb00b20f,1 +np.float64,0xe3807f45c7010,0xc0733b43379415d1,1 +np.float64,0x3fd708fb342e11f6,0xbfdc670ef9793782,1 +np.float64,0x3fe88c924b311925,0xbfbd78210d9e7164,1 +np.float64,0x3fe0a2a7c7614550,0xbfd22efaf0472c4a,1 +np.float64,0x7fe3a37501a746e9,0x407340aecaeade41,1 +np.float64,0x3fd05077ec20a0f0,0xbfe2fedbf07a5302,1 +np.float64,0x7fd33bf61da677eb,0x40733bb8c58912aa,1 +np.float64,0x3feb29bdae76537b,0xbfb2384a8f61b5f9,1 +np.float64,0x3fec0fc14ff81f83,0xbfad3423e7ade174,1 +np.float64,0x3fd0f8b1a1a1f163,0xbfe2725dd4ccea8b,1 +np.float64,0x3fe382d26a6705a5,0xbfcb80dba4218bdf,1 +np.float64,0x3fa873f2cc30e7e6,0xbff522911cb34279,1 +np.float64,0x7fed7fd7377affad,0x4073438292f6829b,1 +np.float64,0x3feeacd8067d59b0,0xbf92cdbeda94b35e,1 +np.float64,0x7fe464d62228c9ab,0x407340f1eee19aa9,1 +np.float64,0xe997648bd32ed,0xc0733b143aa0fad3,1 +np.float64,0x7fea4869f13490d3,0x407342b5333b54f7,1 +np.float64,0x935b871926b71,0xc0733e47c6683319,1 +np.float64,0x28a9d0c05155,0xc0735a7e3532af83,1 +np.float64,0x79026548f204d,0xc0733fa6339ffa2f,1 +np.float64,0x3fdb1daaabb63b55,0xbfd7de839c240ace,1 +np.float64,0x3fc0db73b421b6e7,0xbfec2c6e36c4f416,1 +np.float64,0xb8b50ac1716b,0xc0734ff9fc60ebce,1 +np.float64,0x7fdf13e0c6be27c1,0x40733f0e44f69437,1 +np.float64,0x3fcd0cb97b3a1973,0xbfe49c34ff531273,1 +np.float64,0x3fcbac034b375807,0xbfe54913d73f180d,1 +np.float64,0x3fe091d2a2e123a5,0xbfd24b290a9218de,1 +np.float64,0xede43627dbc87,0xc0733af3c7c7f716,1 +np.float64,0x7fc037e7ed206fcf,0x407335b85fb0fedb,1 +np.float64,0x3fce7ae4c63cf5ca,0xbfe3f1350fe03f28,1 +np.float64,0x7fcdd862263bb0c3,0x407339f5458bb20e,1 +np.float64,0x4d7adf709af5d,0xc07342bf4edfadb2,1 +np.float64,0xdc6c03f3b8d81,0xc0733b7b74d6a635,1 +np.float64,0x3fe72ae0a4ee55c1,0xbfc1f4665608b21f,1 +np.float64,0xcd62f19d9ac5e,0xc0733bf92235e4d8,1 +np.float64,0xe3a7b8fdc74f7,0xc0733b4204f8e166,1 +np.float64,0x3fdafd35adb5fa6b,0xbfd7ffdca0753b36,1 +np.float64,0x3fa023e8702047d1,0xbff8059150ea1464,1 +np.float64,0x99ff336933fe7,0xc0733df961197517,1 +np.float64,0x7feeb365b9bd66ca,0x407343c995864091,1 +np.float64,0x7fe449b49f689368,0x407340e8aa3369e3,1 +np.float64,0x7faf5843043eb085,0x407330aa700136ca,1 +np.float64,0x3fd47b2922a8f652,0xbfdfab3de86f09ee,1 +np.float64,0x7fd9fc3248b3f864,0x40733dcfea6f9b3e,1 +np.float64,0xe20b0d8dc4162,0xc0733b4ea8fe7b3f,1 +np.float64,0x7feff8e0e23ff1c1,0x40734411c490ed70,1 +np.float64,0x7fa58382d02b0705,0x40732e0cf28e14fe,1 +np.float64,0xb8ad9a1b715b4,0xc0733cb630b8f2d4,1 +np.float64,0xe90abcf1d2158,0xc0733b186b04eeee,1 +np.float64,0x7fd6aa6f32ad54dd,0x40733cdccc636604,1 +np.float64,0x3fd8f84eedb1f09e,0xbfda292909a5298a,1 +np.float64,0x7fecd6b1d9f9ad63,0x4073435a472b05b5,1 +np.float64,0x3fd9f47604b3e8ec,0xbfd915e028cbf4a6,1 +np.float64,0x3fd20d9398241b27,0xbfe19691363dd508,1 +np.float64,0x3fe5ed09bbabda13,0xbfc5043dfc9c8081,1 +np.float64,0x7fbe5265363ca4c9,0x407335406f8e4fac,1 +np.float64,0xac2878af5850f,0xc0733d3311be9786,1 +np.float64,0xac2074555840f,0xc0733d3364970018,1 +np.float64,0x3fcd49b96b3a9373,0xbfe47f24c8181d9c,1 +np.float64,0x3fd10caca6a21959,0xbfe2620ae5594f9a,1 +np.float64,0xec5b87e9d8b71,0xc0733aff499e72ca,1 +np.float64,0x9d5e9fad3abd4,0xc0733dd2d70eeb4a,1 +np.float64,0x7fe3d3a24227a744,0x407340bfc2072fdb,1 +np.float64,0x3fc5f7a77c2bef4f,0xbfe87e69d502d784,1 +np.float64,0x33161a66662c4,0xc07345a436308244,1 +np.float64,0xa27acdc744f5a,0xc0733d99feb3d8ea,1 +np.float64,0x3fe2d9301565b260,0xbfcd6c914e204437,1 +np.float64,0x7fd5d111e12ba223,0x40733c98e14a6fd0,1 +np.float64,0x6c3387bed8672,0xc073406d3648171a,1 +np.float64,0x24d89fe849b15,0xc07347e97bec008c,1 +np.float64,0x3fefd763677faec7,0xbf61ae69caa9cad9,1 +np.float64,0x7fe0a4684ba148d0,0x40733f884d32c464,1 +np.float64,0x3fd5c3c939ab8792,0xbfddfaaefc1c7fca,1 +np.float64,0x3fec9b87a6b9370f,0xbfa8eb34efcc6b9b,1 +np.float64,0x3feb062431f60c48,0xbfb2ca6036698877,1 +np.float64,0x3fef97f6633f2fed,0xbf76bc742860a340,1 +np.float64,0x74477490e88ef,0xc0733fed220986bc,1 +np.float64,0x3fe4bea67ce97d4d,0xbfc818525292b0f6,1 +np.float64,0x3fc6add3a92d5ba7,0xbfe80cfdc9a90bda,1 +np.float64,0x847c9ce308f94,0xc0733f05026f5965,1 +np.float64,0x7fea53fd2eb4a7f9,0x407342b841fc4723,1 +np.float64,0x3fc55a16fc2ab42e,0xbfe8e3849130da34,1 +np.float64,0x3fbdf7d07c3befa1,0xbfedcf84b9c6c161,1 +np.float64,0x3fe5fb25aa6bf64b,0xbfc4e083ff96b116,1 +np.float64,0x61c776a8c38ef,0xc0734121611d84d7,1 +np.float64,0x3fec413164f88263,0xbfabadbd05131546,1 +np.float64,0x9bf06fe137e0e,0xc0733de315469ee0,1 +np.float64,0x2075eefc40ebf,0xc07348cae84de924,1 +np.float64,0x3fdd42e0143a85c0,0xbfd5c0b6f60b3cea,1 +np.float64,0xdbb1ab45b7636,0xc0733b8157329daf,1 +np.float64,0x3feac6d56bf58dab,0xbfb3d00771b28621,1 +np.float64,0x7fb2dc825025b904,0x407331f3e950751a,1 +np.float64,0x3fecea6efd79d4de,0xbfa689309cc0e3fe,1 +np.float64,0x3fd83abec7b0757e,0xbfdaff5c674a9c59,1 +np.float64,0x3fd396f7c0272df0,0xbfe073ee75c414ba,1 +np.float64,0x3fe10036c162006e,0xbfd1945a38342ae1,1 +np.float64,0x3fd5bbded52b77be,0xbfde04cca40d4156,1 +np.float64,0x3fe870945ab0e129,0xbfbdf72f0e6206fa,1 +np.float64,0x3fef72fddcbee5fc,0xbf7ee2dba88b1bad,1 +np.float64,0x4e111aa09c224,0xc07342b1e2b29643,1 +np.float64,0x3fd926d8b5b24db1,0xbfd9f58b78d6b061,1 +np.float64,0x3fc55679172aacf2,0xbfe8e5df687842e2,1 +np.float64,0x7f5f1749803e2e92,0x40731886e16cfc4d,1 +np.float64,0x7fea082b53b41056,0x407342a42227700e,1 +np.float64,0x3fece1d1d039c3a4,0xbfa6cb780988a469,1 +np.float64,0x3b2721d8764e5,0xc073449f6a5a4832,1 +np.float64,0x365cb7006cba,0xc0735879ba5f0b6e,1 +np.float64,0x7ff4000000000000,0x7ffc000000000000,1 +np.float64,0x7fe606ce92ac0d9c,0x4073417aeebe97e8,1 +np.float64,0x3fe237b544a46f6b,0xbfcf50f8f76d7df9,1 +np.float64,0x3fe7265e5eee4cbd,0xbfc1ff39089ec8d0,1 +np.float64,0x7fe2bb3c5ea57678,0x4073405aaad81cf2,1 +np.float64,0x3fd811df84b023bf,0xbfdb2e670ea8d8de,1 +np.float64,0x3f6a0efd00341dfa,0xc003fac1ae831241,1 +np.float64,0x3fd0d214afa1a429,0xbfe2922080a91c72,1 +np.float64,0x3feca6a350b94d47,0xbfa894eea3a96809,1 +np.float64,0x7fe23e5c76247cb8,0x4073402bbaaf71c7,1 +np.float64,0x3fe739a1fdae7344,0xbfc1d109f66efb5d,1 +np.float64,0x3fdf4b8e283e971c,0xbfd3e28f46169cc5,1 +np.float64,0x38f2535271e4b,0xc07344e3085219fa,1 +np.float64,0x7fd263a0f9a4c741,0x40733b68d945dae0,1 +np.float64,0x7fdd941863bb2830,0x40733eb651e3dca9,1 +np.float64,0xace7279159ce5,0xc0733d2b63b5947e,1 +np.float64,0x7fe34670b2268ce0,0x4073408d92770cb5,1 +np.float64,0x7fd11fa6dfa23f4d,0x40733aea02e76ea3,1 +np.float64,0x3fe6d9cbca6db398,0xbfc2b84b5c8c7eab,1 +np.float64,0x3fd69a0274ad3405,0xbfdcee3c7e52c463,1 +np.float64,0x3feb5af671f6b5ed,0xbfb16f88d739477f,1 +np.float64,0x3feea400163d4800,0xbf934e071c64fd0b,1 +np.float64,0x3fefd6bcf17fad7a,0xbf61f711c392b119,1 +np.float64,0x3fe148d43da291a8,0xbfd11e9cd3f91cd3,1 +np.float64,0x7fedf1308b7be260,0x4073439d135656da,1 +np.float64,0x3fe614c99c6c2993,0xbfc49fd1984dfd6d,1 +np.float64,0xd6e8d4e5add1b,0xc0733ba88256026e,1 +np.float64,0xfff0000000000000,0x7ff8000000000000,1 +np.float64,0x3fb530b5562a616b,0xbff1504bcc5c8f73,1 +np.float64,0xb7da68396fb4d,0xc0733cbe2790f52e,1 +np.float64,0x7fad78e26c3af1c4,0x4073303cdbfb0a15,1 +np.float64,0x7fee5698447cad30,0x407343b474573a8b,1 +np.float64,0x3fd488325c291065,0xbfdf999296d901e7,1 +np.float64,0x2669283a4cd26,0xc073479f823109a4,1 +np.float64,0x7fef3b090afe7611,0x407343e805a3b264,1 +np.float64,0x7fe8b96ae0f172d5,0x4073424874a342ab,1 +np.float64,0x7fef409f56fe813e,0x407343e943c3cd44,1 +np.float64,0x3fed28073dfa500e,0xbfa4b17e4cd31a3a,1 +np.float64,0x7f87ecc4802fd988,0x40732527e027b24b,1 +np.float64,0x3fdda24da0bb449b,0xbfd566a43ac035af,1 +np.float64,0x179fc9e62f3fa,0xc0734b0028c80fc1,1 +np.float64,0x3fef85b0927f0b61,0xbf7ac27565d5ab4f,1 +np.float64,0x5631501aac62b,0xc0734201be12c5d4,1 +np.float64,0x3fd782e424af05c8,0xbfdbd57544f8a7c3,1 +np.float64,0x3fe603a9a6ac0753,0xbfc4caff04dc3caf,1 +np.float64,0x7fbd5225163aa449,0x40733504b88f0a56,1 +np.float64,0x3fecd27506b9a4ea,0xbfa741dd70e6b08c,1 +np.float64,0x9c99603b3932c,0xc0733ddb922dc5db,1 +np.float64,0x3fbeb57f1a3d6afe,0xbfed789ff217aa08,1 +np.float64,0x3fef9c0f85bf381f,0xbf75d5c3d6cb281a,1 +np.float64,0x3fde4afb613c95f7,0xbfd4ca2a231c9005,1 +np.float64,0x396233d472c47,0xc07344d56ee70631,1 +np.float64,0x3fb31ea1c6263d44,0xbff207356152138d,1 +np.float64,0x3fe50bdf78aa17bf,0xbfc74ae0cbffb735,1 +np.float64,0xef74c701dee99,0xc0733ae81e4bb443,1 +np.float64,0x9a3e13a1347c3,0xc0733df68b60afc7,1 +np.float64,0x33ba4f886774b,0xc073458e03f0c13e,1 +np.float64,0x3fe8ba0e9931741d,0xbfbcaadf974e8f64,1 +np.float64,0x3fe090a4cd61214a,0xbfd24d236cf365d6,1 +np.float64,0x7fd87d992930fb31,0x40733d668b73b820,1 +np.float64,0x3fe6422b296c8456,0xbfc42e070b695d01,1 +np.float64,0x3febe9334677d267,0xbfae667864606cfe,1 +np.float64,0x771a3ce4ee348,0xc0733fc274d12c97,1 +np.float64,0x3fe0413542e0826b,0xbfd2d3b08fb5b8a6,1 +np.float64,0x3fd00870ea2010e2,0xbfe33cc04cbd42e0,1 +np.float64,0x3fe74fb817ae9f70,0xbfc19c45dbf919e1,1 +np.float64,0x40382fa08071,0xc07357514ced5577,1 +np.float64,0xa14968474292d,0xc0733da71a990f3a,1 +np.float64,0x5487c740a90fa,0xc0734224622d5801,1 +np.float64,0x3fed7d8d14fafb1a,0xbfa228f7ecc2ac03,1 +np.float64,0x3fe39bb485e73769,0xbfcb3a235a722960,1 +np.float64,0x3fd01090b2202121,0xbfe335b752589a22,1 +np.float64,0x3fd21a3e7da4347d,0xbfe18cd435a7c582,1 +np.float64,0x3fe7fa855a2ff50b,0xbfc00ab0665709fe,1 +np.float64,0x3fedc0d4577b81a9,0xbfa02fef3ff553fc,1 +np.float64,0x3fe99d4906333a92,0xbfb8bf18220e5e8e,1 +np.float64,0x3fd944ee3c3289dc,0xbfd9d46071675e73,1 +np.float64,0x3fe3ed8d52e7db1b,0xbfca53f8d4aef484,1 +np.float64,0x7fe748623a6e90c3,0x407341dd97c9dd79,1 +np.float64,0x3fea1b4b98343697,0xbfb6a1560a56927f,1 +np.float64,0xe1215715c242b,0xc0733b55dbf1f0a8,1 +np.float64,0x3fd0d5bccca1ab7a,0xbfe28f1b66d7a470,1 +np.float64,0x881a962710353,0xc0733ed51848a30d,1 +np.float64,0x3fcf022afe3e0456,0xbfe3b40eabf24501,1 +np.float64,0x3fdf1ac6bbbe358d,0xbfd40e03e888288d,1 +np.float64,0x3fa51a5eac2a34bd,0xbff628a7c34d51b3,1 +np.float64,0x3fdbaf408d375e81,0xbfd74ad39d97c92a,1 +np.float64,0x3fcd2418ea3a4832,0xbfe4910b009d8b11,1 +np.float64,0x3fc7b3062a2f660c,0xbfe7706dc47993e1,1 +np.float64,0x7fb8232218304643,0x407333aaa7041a9f,1 +np.float64,0x7fd5f186362be30b,0x40733ca32fdf9cc6,1 +np.float64,0x3fe57ef1d6aafde4,0xbfc61e23d00210c7,1 +np.float64,0x7c6830baf8d07,0xc0733f74f19e9dad,1 +np.float64,0xcacbfd5595980,0xc0733c0fb49edca7,1 +np.float64,0x3fdfdeac873fbd59,0xbfd36114c56bed03,1 +np.float64,0x3fd31f0889263e11,0xbfe0ca0cc1250169,1 +np.float64,0x3fe839fbe47073f8,0xbfbef0a2abc3d63f,1 +np.float64,0x3fc36af57e26d5eb,0xbfea3553f38770b7,1 +np.float64,0x3fe73dbc44ee7b79,0xbfc1c738f8fa6b3d,1 +np.float64,0x3fd3760e4da6ec1d,0xbfe08b5b609d11e5,1 +np.float64,0x3fee1cfa297c39f4,0xbf9b06d081bc9d5b,1 +np.float64,0xdfb01561bf61,0xc0734ea55e559888,1 +np.float64,0x687bd01cd0f7b,0xc07340ab67fe1816,1 +np.float64,0x3fefc88f4cbf911f,0xbf6828c359cf19dc,1 +np.float64,0x8ad34adb15a6a,0xc0733eb1e03811e5,1 +np.float64,0x3fe2b49c12e56938,0xbfcdd8dbdbc0ce59,1 +np.float64,0x6e05037adc0a1,0xc073404f91261635,1 +np.float64,0x3fe2fd737fe5fae7,0xbfcd020407ef4d78,1 +np.float64,0x3fd0f3c0dc21e782,0xbfe2766a1ab02eae,1 +np.float64,0x28564d9850acb,0xc073474875f87c5e,1 +np.float64,0x3fe4758015a8eb00,0xbfc8ddb45134a1bd,1 +np.float64,0x7fe7f19306efe325,0x4073420f626141a7,1 +np.float64,0x7fd27f34c0a4fe69,0x40733b733d2a5b50,1 +np.float64,0x92c2366325847,0xc0733e4f04f8195a,1 +np.float64,0x3fc21f8441243f09,0xbfeb2ad23bc1ab0b,1 +np.float64,0x3fc721d3e42e43a8,0xbfe7c69bb47b40c2,1 +np.float64,0x3fe2f11a1625e234,0xbfcd26363b9c36c3,1 +np.float64,0x3fdcb585acb96b0b,0xbfd648446237cb55,1 +np.float64,0x3fd4060bf2280c18,0xbfe025fd4c8a658b,1 +np.float64,0x7fb8ae2750315c4e,0x407333d23b025d08,1 +np.float64,0x3fe3a03119a74062,0xbfcb2d6c91b38552,1 +np.float64,0x7fdd2af92bba55f1,0x40733e9d737e16e6,1 +np.float64,0x3fe50b05862a160b,0xbfc74d20815fe36b,1 +np.float64,0x164409f82c882,0xc0734b6980e19c03,1 +np.float64,0x3fe4093712a8126e,0xbfca070367fda5e3,1 +np.float64,0xae3049935c609,0xc0733d1e3608797b,1 +np.float64,0x3fd71df4b4ae3be9,0xbfdc4dcb7637600d,1 +np.float64,0x7fca01e8023403cf,0x407339006c521c49,1 +np.float64,0x3fb0c5c43e218b88,0xbff2f03211c63f25,1 +np.float64,0x3fee757af83ceaf6,0xbf95f33a6e56b454,1 +np.float64,0x3f865f1f402cbe3f,0xbfff62d9c9072bd7,1 +np.float64,0x89864e95130ca,0xc0733ec29f1e32c6,1 +np.float64,0x3fe51482bcea2905,0xbfc73414ddc8f1b7,1 +np.float64,0x7fd802f8fa3005f1,0x40733d43684e460a,1 +np.float64,0x3fbeb86ca63d70d9,0xbfed774ccca9b8f5,1 +np.float64,0x3fb355dcc826abba,0xbff1f33f9339e7a3,1 +np.float64,0x3fe506c61eaa0d8c,0xbfc7585a3f7565a6,1 +np.float64,0x7fe393f25ba727e4,0x407340a94bcea73b,1 +np.float64,0xf66f532decdeb,0xc0733ab5041feb0f,1 +np.float64,0x3fe26e872be4dd0e,0xbfceaaab466f32e0,1 +np.float64,0x3fefd9e290bfb3c5,0xbf60977d24496295,1 +np.float64,0x7fe19c5f692338be,0x40733fecef53ad95,1 +np.float64,0x3fe80365ab3006cb,0xbfbfec4090ef76ec,1 +np.float64,0x3fe88ab39eb11567,0xbfbd8099388d054d,1 +np.float64,0x3fe68fb09fad1f61,0xbfc36db9de38c2c0,1 +np.float64,0x3fe9051883b20a31,0xbfbb5b75b8cb8f24,1 +np.float64,0x3fd4708683a8e10d,0xbfdfb9b085dd8a83,1 +np.float64,0x3fe00ac11a601582,0xbfd3316af3e43500,1 +np.float64,0xd16af30ba2d5f,0xc0733bd68e8252f9,1 +np.float64,0x3fb97d654632facb,0xbff007ac1257f575,1 +np.float64,0x7fd637c10fac6f81,0x40733cb949d76546,1 +np.float64,0x7fed2cab6dba5956,0x4073436edfc3764e,1 +np.float64,0x3fed04afbbba095f,0xbfa5bfaa5074b7f4,1 +np.float64,0x0,0xfff0000000000000,1 +np.float64,0x389a1dc671345,0xc07344edd4206338,1 +np.float64,0x3fbc9ba25a393745,0xbfee74c34f49b921,1 +np.float64,0x3feee749947dce93,0xbf8f032d9cf6b5ae,1 +np.float64,0xedc4cf89db89a,0xc0733af4b2a57920,1 +np.float64,0x3fe41629eba82c54,0xbfc9e321faf79e1c,1 +np.float64,0x3feb0bcbf7b61798,0xbfb2b31e5d952869,1 +np.float64,0xad60654b5ac0d,0xc0733d26860df676,1 +np.float64,0x3fe154e1ff22a9c4,0xbfd10b416e58c867,1 +np.float64,0x7fb20e9c8a241d38,0x407331a66453b8bc,1 +np.float64,0x7fcbbaaf7d37755e,0x4073397274f28008,1 +np.float64,0x187d0fbc30fa3,0xc0734ac03cc98cc9,1 +np.float64,0x7fd153afeaa2a75f,0x40733aff00b4311d,1 +np.float64,0x3fe05310a5e0a621,0xbfd2b5386aeecaac,1 +np.float64,0x7fea863b2b750c75,0x407342c57807f700,1 +np.float64,0x3fed5f0c633abe19,0xbfa30f6cfbc4bf94,1 +np.float64,0xf227c8b3e44f9,0xc0733ad42daaec9f,1 +np.float64,0x3fe956524772aca5,0xbfb9f4cabed7081d,1 +np.float64,0xefd11af7dfa24,0xc0733ae570ed2552,1 +np.float64,0x1690fff02d221,0xc0734b51a56c2980,1 +np.float64,0x7fd2e547a825ca8e,0x40733b992d6d9635,1 diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/data/umath-validation-set-log1p.csv b/venv/lib/python3.12/site-packages/numpy/_core/tests/data/umath-validation-set-log1p.csv new file mode 100644 index 00000000..094e052a --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/tests/data/umath-validation-set-log1p.csv @@ -0,0 +1,1429 @@ +dtype,input,output,ulperrortol +np.float32,0x3e10aca8,0x3e075347,2 +np.float32,0x3f776e66,0x3f2d2003,2 +np.float32,0xbf34e8ce,0xbf9cfd5c,2 +np.float32,0xbf0260ee,0xbf363f69,2 +np.float32,0x3ed285e8,0x3eb05870,2 +np.float32,0x262b88,0x262b88,2 +np.float32,0x3eeffd6c,0x3ec4cfdb,2 +np.float32,0x3ee86808,0x3ebf9f54,2 +np.float32,0x3f36eba8,0x3f0a0524,2 +np.float32,0xbf1c047a,0xbf70afc7,2 +np.float32,0x3ead2916,0x3e952902,2 +np.float32,0x61c9c9,0x61c9c9,2 +np.float32,0xff7fffff,0xffc00000,2 +np.float32,0x7f64ee52,0x42b138e0,2 +np.float32,0x7ed00b1e,0x42afa4ff,2 +np.float32,0x3db53340,0x3dada0b2,2 +np.float32,0x3e6b0a4a,0x3e5397a4,2 +np.float32,0x7ed5d64f,0x42afb310,2 +np.float32,0xbf12bc5f,0xbf59f5ee,2 +np.float32,0xbda12710,0xbda7d8b5,2 +np.float32,0xbe2e89d8,0xbe3f5a9f,2 +np.float32,0x3f5bee75,0x3f1ebea4,2 +np.float32,0x9317a,0x9317a,2 +np.float32,0x7ee00130,0x42afcad8,2 +np.float32,0x7ef0d16d,0x42afefe7,2 +np.float32,0xbec7463a,0xbefc6a44,2 +np.float32,0xbf760ecc,0xc04fe59c,2 +np.float32,0xbecacb3c,0xbf011ae3,2 +np.float32,0x3ead92be,0x3e9577f0,2 +np.float32,0xbf41510d,0xbfb41b3a,2 +np.float32,0x7f71d489,0x42b154f1,2 +np.float32,0x8023bcd5,0x8023bcd5,2 +np.float32,0x801d33d8,0x801d33d8,2 +np.float32,0x3f3f545d,0x3f0ee0d4,2 +np.float32,0xbf700682,0xc0318c25,2 +np.float32,0xbe54e990,0xbe6eb0a3,2 +np.float32,0x7f0289bf,0x42b01941,2 +np.float32,0xbd61ac90,0xbd682113,2 +np.float32,0xbf2ff310,0xbf94cd6f,2 +np.float32,0x7f10064a,0x42b04b98,2 +np.float32,0x804d0d6d,0x804d0d6d,2 +np.float32,0x80317b0a,0x80317b0a,2 +np.float32,0xbddfef18,0xbded2640,2 +np.float32,0x3f00c9ab,0x3ed0a5bd,2 +np.float32,0x7f04b905,0x42b021c1,2 +np.float32,0x7fc00000,0x7fc00000,2 +np.float32,0x6524c4,0x6524c4,2 +np.float32,0x3da08ae0,0x3d9a8f88,2 +np.float32,0x293ea9,0x293ea9,2 +np.float32,0x71499e,0x71499e,2 +np.float32,0xbf14f54d,0xbf5f38a5,2 +np.float32,0x806e60f5,0x806e60f5,2 +np.float32,0x3f5f34bb,0x3f207fff,2 +np.float32,0x80513427,0x80513427,2 +np.float32,0x7f379670,0x42b0c7dc,2 +np.float32,0x3efba888,0x3eccb20b,2 +np.float32,0x3eeadd1b,0x3ec14f4b,2 +np.float32,0x7ec5a27f,0x42af8ab8,2 +np.float32,0x3f2afe4e,0x3f02f7a2,2 +np.float32,0x5591c8,0x5591c8,2 +np.float32,0x3dbb7240,0x3db35bab,2 +np.float32,0x805b911b,0x805b911b,2 +np.float32,0x800000,0x800000,2 +np.float32,0x7e784c04,0x42ae9cab,2 +np.float32,0x7ebaae14,0x42af6d86,2 +np.float32,0xbec84f7a,0xbefe1d42,2 +np.float32,0x7cea8281,0x42aa56bf,2 +np.float32,0xbf542cf6,0xbfe1eb1b,2 +np.float32,0xbf6bfb13,0xc0231a5b,2 +np.float32,0x7d6eeaef,0x42abc32c,2 +np.float32,0xbf062f6b,0xbf3e2000,2 +np.float32,0x8073d8e9,0x8073d8e9,2 +np.float32,0xbea4db14,0xbec6f485,2 +np.float32,0x7d7e8d62,0x42abe3a0,2 +np.float32,0x7e8fc34e,0x42aee7c6,2 +np.float32,0x7dcbb0c3,0x42acd464,2 +np.float32,0x7e123c,0x7e123c,2 +np.float32,0x3d77af62,0x3d707c34,2 +np.float32,0x498cc8,0x498cc8,2 +np.float32,0x7f4e2206,0x42b1032a,2 +np.float32,0x3f734e0a,0x3f2b04a1,2 +np.float32,0x8053a9d0,0x8053a9d0,2 +np.float32,0xbe8a67e0,0xbea15be9,2 +np.float32,0xbf78e0ea,0xc065409e,2 +np.float32,0x352bdd,0x352bdd,2 +np.float32,0x3ee42be7,0x3ebcb38a,2 +np.float32,0x7f482d10,0x42b0f427,2 +np.float32,0xbf23155e,0xbf81b993,2 +np.float32,0x594920,0x594920,2 +np.float32,0x63f53f,0x63f53f,2 +np.float32,0x363592,0x363592,2 +np.float32,0x7dafbb78,0x42ac88cc,2 +np.float32,0x7f69516c,0x42b14298,2 +np.float32,0x3e1d5be2,0x3e126131,2 +np.float32,0x410c23,0x410c23,2 +np.float32,0x7ec9563c,0x42af9439,2 +np.float32,0xbedd3a0e,0xbf10d705,2 +np.float32,0x7f7c4f1f,0x42b16aa8,2 +np.float32,0xbe99b34e,0xbeb6c2d3,2 +np.float32,0x6cdc84,0x6cdc84,2 +np.float32,0x5b3bbe,0x5b3bbe,2 +np.float32,0x252178,0x252178,2 +np.float32,0x7d531865,0x42ab83c8,2 +np.float32,0xbf565b44,0xbfe873bf,2 +np.float32,0x5977ce,0x5977ce,2 +np.float32,0x588a58,0x588a58,2 +np.float32,0x3eae7054,0x3e961d51,2 +np.float32,0x725049,0x725049,2 +np.float32,0x7f2b9386,0x42b0a538,2 +np.float32,0xbe674714,0xbe831245,2 +np.float32,0x8044f0d8,0x8044f0d8,2 +np.float32,0x800a3c21,0x800a3c21,2 +np.float32,0x807b275b,0x807b275b,2 +np.float32,0xbf2463b6,0xbf83896e,2 +np.float32,0x801cca42,0x801cca42,2 +np.float32,0xbf28f2d0,0xbf8a121a,2 +np.float32,0x3f4168c2,0x3f1010ce,2 +np.float32,0x6f91a1,0x6f91a1,2 +np.float32,0xbf2b9eeb,0xbf8e0fc5,2 +np.float32,0xbea4c858,0xbec6d8e4,2 +np.float32,0xbf7abba0,0xc0788e88,2 +np.float32,0x802f18f7,0x802f18f7,2 +np.float32,0xbf7f6c75,0xc0c3145c,2 +np.float32,0xbe988210,0xbeb50f5e,2 +np.float32,0xbf219b7e,0xbf7f6a3b,2 +np.float32,0x7f800000,0x7f800000,2 +np.float32,0x7f7fffff,0x42b17218,2 +np.float32,0xbdca8d90,0xbdd5487e,2 +np.float32,0xbef683b0,0xbf2821b0,2 +np.float32,0x8043e648,0x8043e648,2 +np.float32,0xbf4319a4,0xbfb7cd1b,2 +np.float32,0x62c2b2,0x62c2b2,2 +np.float32,0xbf479ccd,0xbfc1a7b1,2 +np.float32,0x806c8a32,0x806c8a32,2 +np.float32,0x7f004447,0x42b01045,2 +np.float32,0x3f737d36,0x3f2b1ccf,2 +np.float32,0x3ee71f24,0x3ebebced,2 +np.float32,0x3ea0b6b4,0x3e8bc606,2 +np.float32,0x358fd7,0x358fd7,2 +np.float32,0xbe69780c,0xbe847d17,2 +np.float32,0x7f6bed18,0x42b14849,2 +np.float32,0xbf6a5113,0xc01dfe1d,2 +np.float32,0xbf255693,0xbf84de88,2 +np.float32,0x7f34acac,0x42b0bfac,2 +np.float32,0xbe8a3b6a,0xbea11efe,2 +np.float32,0x3f470d84,0x3f1342ab,2 +np.float32,0xbf2cbde3,0xbf8fc602,2 +np.float32,0x47c103,0x47c103,2 +np.float32,0xe3c94,0xe3c94,2 +np.float32,0xbec07afa,0xbef1693a,2 +np.float32,0x6a9cfe,0x6a9cfe,2 +np.float32,0xbe4339e0,0xbe5899da,2 +np.float32,0x7ea9bf1e,0x42af3cd6,2 +np.float32,0x3f6378b4,0x3f22c4c4,2 +np.float32,0xbd989ff0,0xbd9e9c77,2 +np.float32,0xbe6f2f50,0xbe88343d,2 +np.float32,0x3f7f2ac5,0x3f310764,2 +np.float32,0x3f256704,0x3eff2fb2,2 +np.float32,0x80786aca,0x80786aca,2 +np.float32,0x65d02f,0x65d02f,2 +np.float32,0x50d1c3,0x50d1c3,2 +np.float32,0x3f4a9d76,0x3f1541b4,2 +np.float32,0x802cf491,0x802cf491,2 +np.float32,0x3e935cec,0x3e81829b,2 +np.float32,0x3e2ad478,0x3e1dfd81,2 +np.float32,0xbf107cbd,0xbf54bef2,2 +np.float32,0xbf58c02e,0xbff007fe,2 +np.float32,0x80090808,0x80090808,2 +np.float32,0x805d1f66,0x805d1f66,2 +np.float32,0x6aec95,0x6aec95,2 +np.float32,0xbee3fc6e,0xbf16dc73,2 +np.float32,0x7f63314b,0x42b134f9,2 +np.float32,0x550443,0x550443,2 +np.float32,0xbefa8174,0xbf2c026e,2 +np.float32,0x3f7fb380,0x3f314bd5,2 +np.float32,0x80171f2c,0x80171f2c,2 +np.float32,0x3f2f56ae,0x3f058f2d,2 +np.float32,0x3eacaecb,0x3e94cd97,2 +np.float32,0xbe0c4f0c,0xbe16e69d,2 +np.float32,0x3f48e4cb,0x3f144b42,2 +np.float32,0x7f03efe2,0x42b01eb7,2 +np.float32,0xbf1019ac,0xbf53dbe9,2 +np.float32,0x3e958524,0x3e832eb5,2 +np.float32,0xbf1b23c6,0xbf6e72f2,2 +np.float32,0x12c554,0x12c554,2 +np.float32,0x7dee588c,0x42ad24d6,2 +np.float32,0xbe8c216c,0xbea3ba70,2 +np.float32,0x804553cb,0x804553cb,2 +np.float32,0xbe446324,0xbe5a0966,2 +np.float32,0xbef7150a,0xbf28adff,2 +np.float32,0xbf087282,0xbf42ec6e,2 +np.float32,0x3eeef15c,0x3ec41937,2 +np.float32,0x61bbd2,0x61bbd2,2 +np.float32,0x3e51b28d,0x3e3ec538,2 +np.float32,0x57e869,0x57e869,2 +np.float32,0x7e5e7711,0x42ae646c,2 +np.float32,0x8050b173,0x8050b173,2 +np.float32,0xbf63c90c,0xc00d2438,2 +np.float32,0xbeba774c,0xbee7dcf8,2 +np.float32,0x8016faac,0x8016faac,2 +np.float32,0xbe8b448c,0xbea28aaf,2 +np.float32,0x3e8cd448,0x3e78d29e,2 +np.float32,0x80484e02,0x80484e02,2 +np.float32,0x3f63ba68,0x3f22e78c,2 +np.float32,0x2e87bb,0x2e87bb,2 +np.float32,0x230496,0x230496,2 +np.float32,0x1327b2,0x1327b2,2 +np.float32,0xbf046c56,0xbf3a72d2,2 +np.float32,0x3ecefe60,0x3eadd69a,2 +np.float32,0x49c56e,0x49c56e,2 +np.float32,0x3df22d60,0x3de4e550,2 +np.float32,0x3f67c19d,0x3f250707,2 +np.float32,0x3f20eb9c,0x3ef9b624,2 +np.float32,0x3f05ca75,0x3ed742fa,2 +np.float32,0xbe8514f8,0xbe9a1d45,2 +np.float32,0x8070a003,0x8070a003,2 +np.float32,0x7e49650e,0x42ae317a,2 +np.float32,0x3de16ce9,0x3dd5dc3e,2 +np.float32,0xbf4ae952,0xbfc95f1f,2 +np.float32,0xbe44dd84,0xbe5aa0db,2 +np.float32,0x803c3bc0,0x803c3bc0,2 +np.float32,0x3eebb9e8,0x3ec1e692,2 +np.float32,0x80588275,0x80588275,2 +np.float32,0xbea1e69a,0xbec29d86,2 +np.float32,0x3f7b4bf8,0x3f2f154c,2 +np.float32,0x7eb47ecc,0x42af5c46,2 +np.float32,0x3d441e00,0x3d3f911a,2 +np.float32,0x7f54d40e,0x42b11388,2 +np.float32,0xbf47f17e,0xbfc26882,2 +np.float32,0x3ea7da57,0x3e912db4,2 +np.float32,0x3f59cc7b,0x3f1d984e,2 +np.float32,0x570e08,0x570e08,2 +np.float32,0x3e99560c,0x3e8620a2,2 +np.float32,0x3ecfbd14,0x3eae5e55,2 +np.float32,0x7e86be08,0x42aec698,2 +np.float32,0x3f10f28a,0x3ee5b5d3,2 +np.float32,0x7f228722,0x42b0897a,2 +np.float32,0x3f4b979b,0x3f15cd30,2 +np.float32,0xbf134283,0xbf5b30f9,2 +np.float32,0x3f2ae16a,0x3f02e64f,2 +np.float32,0x3e98e158,0x3e85c6cc,2 +np.float32,0x7ec39f27,0x42af857a,2 +np.float32,0x3effedb0,0x3ecf8cea,2 +np.float32,0xbd545620,0xbd5a09c1,2 +np.float32,0x503a28,0x503a28,2 +np.float32,0x3f712744,0x3f29e9a1,2 +np.float32,0x3edc6194,0x3eb748b1,2 +np.float32,0xbf4ec1e5,0xbfd2ff5f,2 +np.float32,0x3f46669e,0x3f12e4b5,2 +np.float32,0xabad3,0xabad3,2 +np.float32,0x80000000,0x80000000,2 +np.float32,0x803f2e6d,0x803f2e6d,2 +np.float32,0xbf431542,0xbfb7c3e6,2 +np.float32,0x3f6f2d53,0x3f28e496,2 +np.float32,0x546bd8,0x546bd8,2 +np.float32,0x25c80a,0x25c80a,2 +np.float32,0x3e50883c,0x3e3dcd7e,2 +np.float32,0xbf5fa2ba,0xc0045c14,2 +np.float32,0x80271c07,0x80271c07,2 +np.float32,0x8043755d,0x8043755d,2 +np.float32,0xbf3c5cea,0xbfaa5ee9,2 +np.float32,0x3f2fea38,0x3f05e6af,2 +np.float32,0x6da3dc,0x6da3dc,2 +np.float32,0xbf095945,0xbf44dc70,2 +np.float32,0xbe33d584,0xbe45c1f5,2 +np.float32,0x7eb41b2e,0x42af5b2b,2 +np.float32,0xbf0feb74,0xbf537242,2 +np.float32,0xbe96225a,0xbeb1b0b1,2 +np.float32,0x3f63b95f,0x3f22e700,2 +np.float32,0x0,0x0,2 +np.float32,0x3e20b0cc,0x3e154374,2 +np.float32,0xbf79880c,0xc06b6801,2 +np.float32,0xbea690b6,0xbec97b93,2 +np.float32,0xbf3e11ca,0xbfada449,2 +np.float32,0x7e7e6292,0x42aea912,2 +np.float32,0x3e793350,0x3e5f0b7b,2 +np.float32,0x802e7183,0x802e7183,2 +np.float32,0x3f1b3695,0x3ef2a788,2 +np.float32,0x801efa20,0x801efa20,2 +np.float32,0x3f1ec43a,0x3ef70f42,2 +np.float32,0xbf12c5ed,0xbf5a0c52,2 +np.float32,0x8005e99c,0x8005e99c,2 +np.float32,0xbf79f5e7,0xc06fcca5,2 +np.float32,0x3ecbaf50,0x3eab7a03,2 +np.float32,0x46b0fd,0x46b0fd,2 +np.float32,0x3edb9023,0x3eb6b631,2 +np.float32,0x7f24bc41,0x42b09063,2 +np.float32,0xbd8d9328,0xbd92b4c6,2 +np.float32,0x3f2c5d7f,0x3f03c9d9,2 +np.float32,0x807bebc9,0x807bebc9,2 +np.float32,0x7f797a99,0x42b164e2,2 +np.float32,0x756e3c,0x756e3c,2 +np.float32,0x80416f8a,0x80416f8a,2 +np.float32,0x3e0d512a,0x3e04611a,2 +np.float32,0x3f7be3e6,0x3f2f61ec,2 +np.float32,0x80075c41,0x80075c41,2 +np.float32,0xbe850294,0xbe9a046c,2 +np.float32,0x684679,0x684679,2 +np.float32,0x3eb393c4,0x3e99eed2,2 +np.float32,0x3f4177c6,0x3f10195b,2 +np.float32,0x3dd1f402,0x3dc7dfe5,2 +np.float32,0x3ef484d4,0x3ec7e2e1,2 +np.float32,0x53eb8f,0x53eb8f,2 +np.float32,0x7f072cb6,0x42b02b20,2 +np.float32,0xbf1b6b55,0xbf6f28d4,2 +np.float32,0xbd8a98d8,0xbd8f827d,2 +np.float32,0x3eafb418,0x3e970e96,2 +np.float32,0x6555af,0x6555af,2 +np.float32,0x7dd5118e,0x42aceb6f,2 +np.float32,0x800a13f7,0x800a13f7,2 +np.float32,0x331a9d,0x331a9d,2 +np.float32,0x8063773f,0x8063773f,2 +np.float32,0x3e95e068,0x3e837553,2 +np.float32,0x80654b32,0x80654b32,2 +np.float32,0x3dabe0e0,0x3da50bb3,2 +np.float32,0xbf6283c3,0xc00a5280,2 +np.float32,0x80751cc5,0x80751cc5,2 +np.float32,0x3f668eb6,0x3f2465c0,2 +np.float32,0x3e13c058,0x3e0a048c,2 +np.float32,0x77780c,0x77780c,2 +np.float32,0x3f7d6e48,0x3f302868,2 +np.float32,0x7e31f9e3,0x42adf22f,2 +np.float32,0x246c7b,0x246c7b,2 +np.float32,0xbe915bf0,0xbeaafa6c,2 +np.float32,0xbf800000,0xff800000,2 +np.float32,0x3f698f42,0x3f25f8e0,2 +np.float32,0x7e698885,0x42ae7d48,2 +np.float32,0x3f5bbd42,0x3f1ea42c,2 +np.float32,0x5b8444,0x5b8444,2 +np.float32,0xbf6065f6,0xc005e2c6,2 +np.float32,0xbeb95036,0xbee60dad,2 +np.float32,0xbf44f846,0xbfbbcade,2 +np.float32,0xc96e5,0xc96e5,2 +np.float32,0xbf213e90,0xbf7e6eae,2 +np.float32,0xbeb309cc,0xbedc4fe6,2 +np.float32,0xbe781cf4,0xbe8e0fe6,2 +np.float32,0x7f0cf0db,0x42b04083,2 +np.float32,0xbf7b6143,0xc08078f9,2 +np.float32,0x80526fc6,0x80526fc6,2 +np.float32,0x3f092bf3,0x3edbaeec,2 +np.float32,0x3ecdf154,0x3ead16df,2 +np.float32,0x2fe85b,0x2fe85b,2 +np.float32,0xbf5100a0,0xbfd8f871,2 +np.float32,0xbec09d40,0xbef1a028,2 +np.float32,0x5e6a85,0x5e6a85,2 +np.float32,0xbec0e2a0,0xbef20f6b,2 +np.float32,0x3f72e788,0x3f2ad00d,2 +np.float32,0x880a6,0x880a6,2 +np.float32,0x3d9e90bf,0x3d98b9fc,2 +np.float32,0x15cf25,0x15cf25,2 +np.float32,0x10171b,0x10171b,2 +np.float32,0x805cf1aa,0x805cf1aa,2 +np.float32,0x3f19bd36,0x3ef0d0d2,2 +np.float32,0x3ebe2bda,0x3ea1b774,2 +np.float32,0xbecd8192,0xbf035c49,2 +np.float32,0x3e2ce508,0x3e1fc21b,2 +np.float32,0x290f,0x290f,2 +np.float32,0x803b679f,0x803b679f,2 +np.float32,0x1,0x1,2 +np.float32,0x807a9c76,0x807a9c76,2 +np.float32,0xbf65fced,0xc01257f8,2 +np.float32,0x3f783414,0x3f2d8475,2 +np.float32,0x3f2d9d92,0x3f0488da,2 +np.float32,0xbddb5798,0xbde80018,2 +np.float32,0x3e91afb8,0x3e8034e7,2 +np.float32,0xbf1b775a,0xbf6f476d,2 +np.float32,0xbf73a32c,0xc041f3ba,2 +np.float32,0xbea39364,0xbec5121b,2 +np.float32,0x80375b94,0x80375b94,2 +np.float32,0x3f331252,0x3f07c3e9,2 +np.float32,0xbf285774,0xbf892e74,2 +np.float32,0x3e699bb8,0x3e526d55,2 +np.float32,0x3f08208a,0x3eda523a,2 +np.float32,0xbf42fb4a,0xbfb78d60,2 +np.float32,0x8029c894,0x8029c894,2 +np.float32,0x3e926c0c,0x3e80c76e,2 +np.float32,0x801e4715,0x801e4715,2 +np.float32,0x3e4b36d8,0x3e395ffd,2 +np.float32,0x8041556b,0x8041556b,2 +np.float32,0xbf2d99ba,0xbf9119bd,2 +np.float32,0x3ed83ea8,0x3eb46250,2 +np.float32,0xbe94a280,0xbeaf92b4,2 +np.float32,0x7f4c7a64,0x42b0ff0a,2 +np.float32,0x806d4022,0x806d4022,2 +np.float32,0xbed382f8,0xbf086d26,2 +np.float32,0x1846fe,0x1846fe,2 +np.float32,0xbe702558,0xbe88d4d8,2 +np.float32,0xbe650ee0,0xbe81a3cc,2 +np.float32,0x3ee9d088,0x3ec0970c,2 +np.float32,0x7f6d4498,0x42b14b30,2 +np.float32,0xbef9f9e6,0xbf2b7ddb,2 +np.float32,0xbf70c384,0xc0349370,2 +np.float32,0xbeff9e9e,0xbf3110c8,2 +np.float32,0xbef06372,0xbf224aa9,2 +np.float32,0xbf15a692,0xbf60e1fa,2 +np.float32,0x8058c117,0x8058c117,2 +np.float32,0xbd9f74b8,0xbda6017b,2 +np.float32,0x801bf130,0x801bf130,2 +np.float32,0x805da84c,0x805da84c,2 +np.float32,0xff800000,0xffc00000,2 +np.float32,0xbeb01de2,0xbed7d6d6,2 +np.float32,0x8077de08,0x8077de08,2 +np.float32,0x3e327668,0x3e2482c1,2 +np.float32,0xbe7add88,0xbe8fe1ab,2 +np.float32,0x805a3c2e,0x805a3c2e,2 +np.float32,0x80326a73,0x80326a73,2 +np.float32,0x800b8a34,0x800b8a34,2 +np.float32,0x8048c83a,0x8048c83a,2 +np.float32,0xbf3799d6,0xbfa1a975,2 +np.float32,0x807649c7,0x807649c7,2 +np.float32,0x3dfdbf90,0x3def3798,2 +np.float32,0xbf1b538a,0xbf6eec4c,2 +np.float32,0xbf1e5989,0xbf76baa0,2 +np.float32,0xc7a80,0xc7a80,2 +np.float32,0x8001be54,0x8001be54,2 +np.float32,0x3f435bbc,0x3f112c6d,2 +np.float32,0xbeabcff8,0xbed151d1,2 +np.float32,0x7de20c78,0x42ad09b7,2 +np.float32,0x3f0e6d2e,0x3ee27b1e,2 +np.float32,0xbf0cb352,0xbf4c3267,2 +np.float32,0x7f6ec06f,0x42b14e61,2 +np.float32,0x7f6fa8ef,0x42b15053,2 +np.float32,0xbf3d2a6a,0xbfabe623,2 +np.float32,0x7f077a4c,0x42b02c46,2 +np.float32,0xbf2a68dc,0xbf8c3cc4,2 +np.float32,0x802a5dbe,0x802a5dbe,2 +np.float32,0x807f631c,0x807f631c,2 +np.float32,0x3dc9b8,0x3dc9b8,2 +np.float32,0x3ebdc1b7,0x3ea16a0a,2 +np.float32,0x7ef29dab,0x42aff3b5,2 +np.float32,0x3e8ab1cc,0x3e757806,2 +np.float32,0x3f27e88e,0x3f011c6d,2 +np.float32,0x3cfd1455,0x3cf93fb5,2 +np.float32,0x7f7eebf5,0x42b16fef,2 +np.float32,0x3c9b2140,0x3c99ade9,2 +np.float32,0x7e928601,0x42aef183,2 +np.float32,0xbd7d2db0,0xbd82abae,2 +np.float32,0x3e6f0df3,0x3e56da20,2 +np.float32,0x7d36a2fc,0x42ab39a3,2 +np.float32,0xbf49d3a2,0xbfc6c859,2 +np.float32,0x7ee541d3,0x42afd6b6,2 +np.float32,0x80753dc0,0x80753dc0,2 +np.float32,0x3f4ce486,0x3f16865d,2 +np.float32,0x39e701,0x39e701,2 +np.float32,0x3f3d9ede,0x3f0de5fa,2 +np.float32,0x7fafb2,0x7fafb2,2 +np.float32,0x3e013fdc,0x3df37090,2 +np.float32,0x807b6a2c,0x807b6a2c,2 +np.float32,0xbe86800a,0xbe9c08c7,2 +np.float32,0x7f40f080,0x42b0e14d,2 +np.float32,0x7eef5afe,0x42afecc8,2 +np.float32,0x7ec30052,0x42af83da,2 +np.float32,0x3eacf768,0x3e9503e1,2 +np.float32,0x7f13ef0e,0x42b0594e,2 +np.float32,0x80419f4a,0x80419f4a,2 +np.float32,0xbf485932,0xbfc3562a,2 +np.float32,0xbe8a24d6,0xbea10011,2 +np.float32,0xbda791c0,0xbdaed2bc,2 +np.float32,0x3e9b5169,0x3e87a67d,2 +np.float32,0x807dd882,0x807dd882,2 +np.float32,0x7f40170e,0x42b0df0a,2 +np.float32,0x7f02f7f9,0x42b01af1,2 +np.float32,0x3ea38bf9,0x3e8decde,2 +np.float32,0x3e2e7ce8,0x3e211ed4,2 +np.float32,0x70a7a6,0x70a7a6,2 +np.float32,0x7d978592,0x42ac3ce7,2 +np.float32,0x804d12d0,0x804d12d0,2 +np.float32,0x80165dc8,0x80165dc8,2 +np.float32,0x80000001,0x80000001,2 +np.float32,0x3e325da0,0x3e246da6,2 +np.float32,0xbe063bb8,0xbe0fe281,2 +np.float32,0x160b8,0x160b8,2 +np.float32,0xbe5687a4,0xbe70bbef,2 +np.float32,0x7f11ab34,0x42b05168,2 +np.float32,0xc955c,0xc955c,2 +np.float32,0xbea0003a,0xbebfd826,2 +np.float32,0x3f7fbdd9,0x3f315102,2 +np.float32,0xbe61aefc,0xbe7ef121,2 +np.float32,0xbf1b9873,0xbf6f9bc3,2 +np.float32,0x3a6d14,0x3a6d14,2 +np.float32,0xbf1ad3b4,0xbf6da808,2 +np.float32,0x3ed2dd24,0x3eb0963d,2 +np.float32,0xbe81a4ca,0xbe957d52,2 +np.float32,0x7f1be3e9,0x42b07421,2 +np.float32,0x7f5ce943,0x42b1269e,2 +np.float32,0x7eebcbdf,0x42afe51d,2 +np.float32,0x807181b5,0x807181b5,2 +np.float32,0xbecb03ba,0xbf0149ad,2 +np.float32,0x42edb8,0x42edb8,2 +np.float32,0xbf3aeec8,0xbfa7b13f,2 +np.float32,0xbd0c4f00,0xbd0ec4a0,2 +np.float32,0x3e48d260,0x3e376070,2 +np.float32,0x1a9731,0x1a9731,2 +np.float32,0x7f323be4,0x42b0b8b5,2 +np.float32,0x1a327f,0x1a327f,2 +np.float32,0x17f1fc,0x17f1fc,2 +np.float32,0xbf2f4f9b,0xbf93c91a,2 +np.float32,0x3ede8934,0x3eb8c9c3,2 +np.float32,0xbf56aaac,0xbfe968bb,2 +np.float32,0x3e22cb5a,0x3e17148c,2 +np.float32,0x7d9def,0x7d9def,2 +np.float32,0x8045b963,0x8045b963,2 +np.float32,0x77404f,0x77404f,2 +np.float32,0x7e2c9efb,0x42ade28b,2 +np.float32,0x8058ad89,0x8058ad89,2 +np.float32,0x7f4139,0x7f4139,2 +np.float32,0x8020e12a,0x8020e12a,2 +np.float32,0x800c9daa,0x800c9daa,2 +np.float32,0x7f2c5ac5,0x42b0a789,2 +np.float32,0x3f04a47b,0x3ed5c043,2 +np.float32,0x804692d5,0x804692d5,2 +np.float32,0xbf6e7fa4,0xc02bb493,2 +np.float32,0x80330756,0x80330756,2 +np.float32,0x7f3e29ad,0x42b0d9e1,2 +np.float32,0xbebf689a,0xbeefb24d,2 +np.float32,0x3f29a86c,0x3f022a56,2 +np.float32,0x3e3bd1c0,0x3e2c72b3,2 +np.float32,0x3f78f2e8,0x3f2de546,2 +np.float32,0x3f3709be,0x3f0a16af,2 +np.float32,0x3e11f150,0x3e086f97,2 +np.float32,0xbf5867ad,0xbfeee8a0,2 +np.float32,0xbebfb328,0xbef0296c,2 +np.float32,0x2f7f15,0x2f7f15,2 +np.float32,0x805cfe84,0x805cfe84,2 +np.float32,0xbf504e01,0xbfd71589,2 +np.float32,0x3ee0903c,0x3eba330c,2 +np.float32,0xbd838990,0xbd87f399,2 +np.float32,0x3f14444e,0x3ee9ee7d,2 +np.float32,0x7e352583,0x42adfb3a,2 +np.float32,0x7e76f824,0x42ae99ec,2 +np.float32,0x3f772d00,0x3f2cfebf,2 +np.float32,0x801f7763,0x801f7763,2 +np.float32,0x3f760bf5,0x3f2c6b87,2 +np.float32,0xbf0bb696,0xbf4a03a5,2 +np.float32,0x3f175d2c,0x3eedd6d2,2 +np.float32,0xbf5723f8,0xbfeae288,2 +np.float32,0x24de0a,0x24de0a,2 +np.float32,0x3cd73f80,0x3cd47801,2 +np.float32,0x7f013305,0x42b013fa,2 +np.float32,0x3e3ad425,0x3e2b9c50,2 +np.float32,0x7d3d16,0x7d3d16,2 +np.float32,0x3ef49738,0x3ec7ef54,2 +np.float32,0x3f5b8612,0x3f1e8678,2 +np.float32,0x7f0eeb5c,0x42b047a7,2 +np.float32,0x7e9d7cb0,0x42af1675,2 +np.float32,0xbdd1cfb0,0xbddd5aa0,2 +np.float32,0xbf645dba,0xc00e78fe,2 +np.float32,0x3f511174,0x3f18d56c,2 +np.float32,0x3d91ad00,0x3d8cba62,2 +np.float32,0x805298da,0x805298da,2 +np.float32,0xbedb6af4,0xbf0f4090,2 +np.float32,0x3d23b1ba,0x3d208205,2 +np.float32,0xbea5783e,0xbec7dc87,2 +np.float32,0x79d191,0x79d191,2 +np.float32,0x3e894413,0x3e7337da,2 +np.float32,0x80800000,0x80800000,2 +np.float32,0xbf34a8d3,0xbf9c907b,2 +np.float32,0x3bae779a,0x3bae011f,2 +np.float32,0x8049284d,0x8049284d,2 +np.float32,0x3eb42cc4,0x3e9a600b,2 +np.float32,0x3da1e2d0,0x3d9bce5f,2 +np.float32,0x3f364b8a,0x3f09a7af,2 +np.float32,0x3d930b10,0x3d8e0118,2 +np.float32,0x8061f8d7,0x8061f8d7,2 +np.float32,0x3f473213,0x3f13573b,2 +np.float32,0x3f1e2a38,0x3ef65102,2 +np.float32,0x8068f7d9,0x8068f7d9,2 +np.float32,0x3f181ef8,0x3eeeca2c,2 +np.float32,0x3eeb6168,0x3ec1a9f5,2 +np.float32,0xc2db6,0xc2db6,2 +np.float32,0x3ef7b578,0x3eca0a69,2 +np.float32,0xbf5b5a84,0xbff8d075,2 +np.float32,0x7f479d5f,0x42b0f2b7,2 +np.float32,0x3e6f3c24,0x3e56ff92,2 +np.float32,0x3f45543a,0x3f1249f0,2 +np.float32,0xbea7c1fa,0xbecb40d2,2 +np.float32,0x7de082,0x7de082,2 +np.float32,0x383729,0x383729,2 +np.float32,0xbd91cb90,0xbd973eb3,2 +np.float32,0x7f320218,0x42b0b80f,2 +np.float32,0x5547f2,0x5547f2,2 +np.float32,0x291fe4,0x291fe4,2 +np.float32,0xbe078ba0,0xbe11655f,2 +np.float32,0x7e0c0658,0x42ad7764,2 +np.float32,0x7e129a2b,0x42ad8ee5,2 +np.float32,0x3f7c96d4,0x3f2fbc0c,2 +np.float32,0x3f800000,0x3f317218,2 +np.float32,0x7f131754,0x42b05662,2 +np.float32,0x15f833,0x15f833,2 +np.float32,0x80392ced,0x80392ced,2 +np.float32,0x3f7c141a,0x3f2f7a36,2 +np.float32,0xbf71c03f,0xc038dcfd,2 +np.float32,0xbe14fb2c,0xbe20fff3,2 +np.float32,0xbee0bac6,0xbf13f14c,2 +np.float32,0x801a32dd,0x801a32dd,2 +np.float32,0x8e12d,0x8e12d,2 +np.float32,0x3f48c606,0x3f143a04,2 +np.float32,0x7f418af5,0x42b0e2e6,2 +np.float32,0x3f1f2918,0x3ef78bb7,2 +np.float32,0x11141b,0x11141b,2 +np.float32,0x3e9fc9e8,0x3e8b11ad,2 +np.float32,0xbea5447a,0xbec79010,2 +np.float32,0xbe31d904,0xbe4359db,2 +np.float32,0x80184667,0x80184667,2 +np.float32,0xbf00503c,0xbf3212c2,2 +np.float32,0x3e0328cf,0x3df6d425,2 +np.float32,0x7ee8e1b7,0x42afdebe,2 +np.float32,0xbef95e24,0xbf2ae5db,2 +np.float32,0x7f3e4eed,0x42b0da45,2 +np.float32,0x3f43ee85,0x3f117fa0,2 +np.float32,0xbcfa2ac0,0xbcfe10fe,2 +np.float32,0x80162774,0x80162774,2 +np.float32,0x372e8b,0x372e8b,2 +np.float32,0x3f263802,0x3f0016b0,2 +np.float32,0x8008725f,0x8008725f,2 +np.float32,0x800beb40,0x800beb40,2 +np.float32,0xbe93308e,0xbead8a77,2 +np.float32,0x3d8a4240,0x3d85cab8,2 +np.float32,0x80179de0,0x80179de0,2 +np.float32,0x7f4a98f2,0x42b0fa4f,2 +np.float32,0x3f0d214e,0x3ee0cff1,2 +np.float32,0x80536c2c,0x80536c2c,2 +np.float32,0x7e7038ed,0x42ae8bbe,2 +np.float32,0x7f345af9,0x42b0bec4,2 +np.float32,0xbf243219,0xbf83442f,2 +np.float32,0x7e0d5555,0x42ad7c27,2 +np.float32,0x762e95,0x762e95,2 +np.float32,0x7ebf4548,0x42af79f6,2 +np.float32,0x8079639e,0x8079639e,2 +np.float32,0x3ef925c0,0x3ecb0260,2 +np.float32,0x3f708695,0x3f2996d6,2 +np.float32,0xfca9f,0xfca9f,2 +np.float32,0x8060dbf4,0x8060dbf4,2 +np.float32,0x4c8840,0x4c8840,2 +np.float32,0xbea922ee,0xbecd4ed5,2 +np.float32,0xbf4f28a9,0xbfd40b98,2 +np.float32,0xbe25ad48,0xbe34ba1b,2 +np.float32,0x3f2fb254,0x3f05c58c,2 +np.float32,0x3f73bcc2,0x3f2b3d5f,2 +np.float32,0xbf479a07,0xbfc1a165,2 +np.float32,0xbeb9a808,0xbee69763,2 +np.float32,0x7eb16a65,0x42af5376,2 +np.float32,0xbeb3e442,0xbedda042,2 +np.float32,0x3d8f439c,0x3d8a79ac,2 +np.float32,0x80347516,0x80347516,2 +np.float32,0x3e8a0c5d,0x3e74738c,2 +np.float32,0xbf0383a4,0xbf389289,2 +np.float32,0x806be8f5,0x806be8f5,2 +np.float32,0x8023f0c5,0x8023f0c5,2 +np.float32,0x2060e9,0x2060e9,2 +np.float32,0xbf759eba,0xc04d239f,2 +np.float32,0x3d84cc5a,0x3d80ab96,2 +np.float32,0xbf57746b,0xbfebdf87,2 +np.float32,0x3e418417,0x3e31401f,2 +np.float32,0xaecce,0xaecce,2 +np.float32,0x3cd1766f,0x3cced45c,2 +np.float32,0x53724a,0x53724a,2 +np.float32,0x3f773710,0x3f2d03de,2 +np.float32,0x8013d040,0x8013d040,2 +np.float32,0x4d0eb2,0x4d0eb2,2 +np.float32,0x8014364a,0x8014364a,2 +np.float32,0x7f3c56c9,0x42b0d4f2,2 +np.float32,0x3eee1e1c,0x3ec3891a,2 +np.float32,0xbdda3eb8,0xbde6c5a0,2 +np.float32,0x26ef4a,0x26ef4a,2 +np.float32,0x7ed3370c,0x42afacbf,2 +np.float32,0xbf06e31b,0xbf3f9ab7,2 +np.float32,0xbe3185f0,0xbe42f556,2 +np.float32,0x3dcf9abe,0x3dc5be41,2 +np.float32,0xbf3696d9,0xbf9fe2bd,2 +np.float32,0x3e68ee50,0x3e51e01a,2 +np.float32,0x3f3d4cc2,0x3f0db6ca,2 +np.float32,0x7fa00000,0x7fe00000,2 +np.float32,0xbf03070c,0xbf3792d0,2 +np.float32,0x3ea79e6c,0x3e910092,2 +np.float32,0xbf1a393a,0xbf6c2251,2 +np.float32,0x3f41eb0e,0x3f105afc,2 +np.float32,0x3ceadb2f,0x3ce78d79,2 +np.float32,0xbf5dc105,0xc000be2c,2 +np.float32,0x7ebb5a0e,0x42af6f5c,2 +np.float32,0xbf7c44eb,0xc0875058,2 +np.float32,0x6aaaf4,0x6aaaf4,2 +np.float32,0x807d8f23,0x807d8f23,2 +np.float32,0xbee6b142,0xbf194fef,2 +np.float32,0xbe83f256,0xbe989526,2 +np.float32,0x7d588e,0x7d588e,2 +np.float32,0x7cc80131,0x42aa0542,2 +np.float32,0x3e0ab198,0x3e02124f,2 +np.float32,0xbf6e64db,0xc02b52eb,2 +np.float32,0x3d238b56,0x3d205d1b,2 +np.float32,0xbeb408e2,0xbeddd8bc,2 +np.float32,0x3f78340d,0x3f2d8471,2 +np.float32,0x806162a3,0x806162a3,2 +np.float32,0x804e484f,0x804e484f,2 +np.float32,0xbeb8c576,0xbee53466,2 +np.float32,0x807aab15,0x807aab15,2 +np.float32,0x3f523e20,0x3f197ab8,2 +np.float32,0xbf009190,0xbf3295de,2 +np.float32,0x3df43da5,0x3de6bd82,2 +np.float32,0x7f639aea,0x42b135e6,2 +np.float32,0x3f1e638a,0x3ef697da,2 +np.float32,0xbf4884de,0xbfc3bac3,2 +np.float32,0xbe9336b6,0xbead931b,2 +np.float32,0x6daf7f,0x6daf7f,2 +np.float32,0xbf1fc152,0xbf7a70b1,2 +np.float32,0x3f103720,0x3ee4c649,2 +np.float32,0x3eeaa227,0x3ec126df,2 +np.float32,0x7f7ea945,0x42b16f69,2 +np.float32,0x3d3cd800,0x3d389ead,2 +np.float32,0x3f3d7268,0x3f0dcc6e,2 +np.float32,0xbf3c1b41,0xbfa9e2e3,2 +np.float32,0x3ecf3818,0x3eadffb2,2 +np.float32,0x3f1af312,0x3ef25372,2 +np.float32,0x48fae4,0x48fae4,2 +np.float64,0x7fedaa1ee4fb543d,0x40862da7ca7c308e,1 +np.float64,0x8007d2d810efa5b1,0x8007d2d810efa5b1,1 +np.float64,0x3fc385e069270bc0,0x3fc22b8884cf2c3b,1 +np.float64,0x68ed4130d1da9,0x68ed4130d1da9,1 +np.float64,0x8008e93e58d1d27d,0x8008e93e58d1d27d,1 +np.float64,0xbfd3d62852a7ac50,0xbfd7be3a7ad1af02,1 +np.float64,0xbfc1fa0ba923f418,0xbfc35f0f19447df7,1 +np.float64,0xbfe01b8cec20371a,0xbfe6658c7e6c8e50,1 +np.float64,0xbfeda81a147b5034,0xc004e9c94f2b91c1,1 +np.float64,0xbfe1c36a97e386d5,0xbfe9ead4d6beaa92,1 +np.float64,0x3fe50be51f2a17ca,0x3fe02c8067d9e5c5,1 +np.float64,0x3febed4d3337da9a,0x3fe413956466134f,1 +np.float64,0x80068ea59ced1d4c,0x80068ea59ced1d4c,1 +np.float64,0x3febe77d5877cefb,0x3fe4107ac088bc71,1 +np.float64,0x800ae77617d5ceed,0x800ae77617d5ceed,1 +np.float64,0x3fd0546b60a0a8d7,0x3fcd16c2e995ab23,1 +np.float64,0xbfe33e1476667c29,0xbfed6d7faec4db2f,1 +np.float64,0x3fe9d2fd51b3a5fb,0x3fe2eef834310219,1 +np.float64,0x8004249878284932,0x8004249878284932,1 +np.float64,0xbfd5b485c72b690c,0xbfda828ccc6a7a5c,1 +np.float64,0x7fcd6e6b6b3adcd6,0x408622807f04768e,1 +np.float64,0x3fd7f9c32caff386,0x3fd45d024514b8da,1 +np.float64,0x7f87eb9d702fd73a,0x40860aa99fcff27f,1 +np.float64,0xbfc5d1f6fb2ba3ec,0xbfc7ec367cb3fecc,1 +np.float64,0x8008316a44d062d5,0x8008316a44d062d5,1 +np.float64,0xbfd54e4358aa9c86,0xbfd9e889d2998a4a,1 +np.float64,0xda65facdb4cc0,0xda65facdb4cc0,1 +np.float64,0x3fc5b4f6f32b69f0,0x3fc40d13aa8e248b,1 +np.float64,0x3fd825a5d5b04b4c,0x3fd47ce73e04d3ff,1 +np.float64,0x7ac9d56ef593b,0x7ac9d56ef593b,1 +np.float64,0xbfd0a51977214a32,0xbfd34702071428be,1 +np.float64,0x3fd21f620b243ec4,0x3fcfea0c02193640,1 +np.float64,0x3fe6fb3f1b2df67e,0x3fe151ffb18c983b,1 +np.float64,0x700de022e01bd,0x700de022e01bd,1 +np.float64,0xbfbb76b81236ed70,0xbfbd0d31deea1ec7,1 +np.float64,0x3fecfc3856f9f870,0x3fe4a2fcadf221e0,1 +np.float64,0x3fede286517bc50c,0x3fe51af2fbd6ef63,1 +np.float64,0x7fdc8da96c391b52,0x408627ce09cfef2b,1 +np.float64,0x8000edfcfb81dbfb,0x8000edfcfb81dbfb,1 +np.float64,0x8009ebc42af3d789,0x8009ebc42af3d789,1 +np.float64,0x7fd658aaf8acb155,0x408625d80cd1ccc9,1 +np.float64,0x3feea584a37d4b09,0x3fe57f29a73729cd,1 +np.float64,0x4cfe494699fca,0x4cfe494699fca,1 +np.float64,0xbfe9d96460b3b2c9,0xbffa62ecfa026c77,1 +np.float64,0x7fdb3852c3b670a5,0x4086276c191dc9b1,1 +np.float64,0xbfe4d1fc9ee9a3f9,0xbff0d37ce37cf479,1 +np.float64,0xffefffffffffffff,0xfff8000000000000,1 +np.float64,0xbfd1c43d7fa3887a,0xbfd4cfbefb5f2c43,1 +np.float64,0x3fec4a8e0d78951c,0x3fe4453a82ca2570,1 +np.float64,0x7fafed74583fdae8,0x4086181017b8dac9,1 +np.float64,0x80076c4ebcced89e,0x80076c4ebcced89e,1 +np.float64,0x8001a9aa7b235356,0x8001a9aa7b235356,1 +np.float64,0x121260fe2424d,0x121260fe2424d,1 +np.float64,0x3fddd028e3bba052,0x3fd87998c4c43c5b,1 +np.float64,0x800ed1cf4a9da39f,0x800ed1cf4a9da39f,1 +np.float64,0xbfef2e63d7fe5cc8,0xc00d53480b16971b,1 +np.float64,0xbfedde3309fbbc66,0xc005ab55b7a7c127,1 +np.float64,0x3fda3e1e85b47c3d,0x3fd5fddafd8d6729,1 +np.float64,0x8007c6443c6f8c89,0x8007c6443c6f8c89,1 +np.float64,0xbfe101705f2202e0,0xbfe8420817665121,1 +np.float64,0x7fe0bff3c1e17fe7,0x4086291539c56d80,1 +np.float64,0x7fe6001dab6c003a,0x40862b43aa7cb060,1 +np.float64,0x7fbdecf7de3bd9ef,0x40861d170b1c51a5,1 +np.float64,0xbfc0fd508c21faa0,0xbfc23a5876e99fa3,1 +np.float64,0xbfcf6eb14f3edd64,0xbfd208cbf742c8ea,1 +np.float64,0x3f6d40ea403a81d5,0x3f6d33934ab8e799,1 +np.float64,0x7fc32600b6264c00,0x40861f10302357e0,1 +np.float64,0x3fd05870baa0b0e0,0x3fcd1d2af420fac7,1 +np.float64,0x80051d5120aa3aa3,0x80051d5120aa3aa3,1 +np.float64,0x3fdb783fcfb6f080,0x3fd6db229658c083,1 +np.float64,0x3fe0b61199e16c24,0x3fdae41e277be2eb,1 +np.float64,0x3daf62167b5ed,0x3daf62167b5ed,1 +np.float64,0xbfec3c53b6f878a7,0xc0011f0ce7a78a2a,1 +np.float64,0x800fc905161f920a,0x800fc905161f920a,1 +np.float64,0x3fdc7b9cc138f73a,0x3fd78f9c2360e661,1 +np.float64,0x7fe4079e97a80f3c,0x40862a83795f2443,1 +np.float64,0x8010000000000000,0x8010000000000000,1 +np.float64,0x7fe6da5345adb4a6,0x40862b9183c1e4b0,1 +np.float64,0xbfd0a76667214ecc,0xbfd34a1e0c1f6186,1 +np.float64,0x37fb0b906ff62,0x37fb0b906ff62,1 +np.float64,0x7fe170e59fa2e1ca,0x408629680a55e5c5,1 +np.float64,0x3fea900c77752019,0x3fe356eec75aa345,1 +np.float64,0x3fc575c63a2aeb8c,0x3fc3d701167d76b5,1 +np.float64,0x3fe8b45da87168bc,0x3fe24ecbb778fd44,1 +np.float64,0xbfcb990ab5373214,0xbfcf1596c076813c,1 +np.float64,0xf146fdfbe28e0,0xf146fdfbe28e0,1 +np.float64,0x8001fcd474c3f9aa,0x8001fcd474c3f9aa,1 +np.float64,0xbfe9b555eeb36aac,0xbffa0630c3bb485b,1 +np.float64,0x800f950be83f2a18,0x800f950be83f2a18,1 +np.float64,0x7feb0e03ab761c06,0x40862ceb30e36887,1 +np.float64,0x7fca51bd4a34a37a,0x4086219b9dfd35c9,1 +np.float64,0xbfdc27c34cb84f86,0xbfe28ccde8d6bc08,1 +np.float64,0x80009ce1714139c4,0x80009ce1714139c4,1 +np.float64,0x8005290fb1ea5220,0x8005290fb1ea5220,1 +np.float64,0xbfee81e6473d03cd,0xc00885972ca1699b,1 +np.float64,0x7fcfb11a373f6233,0x408623180b8f75d9,1 +np.float64,0xbfcb9c4bfd373898,0xbfcf19bd25881928,1 +np.float64,0x7feaec5885f5d8b0,0x40862ce136050e6c,1 +np.float64,0x8009e17a4a53c2f5,0x8009e17a4a53c2f5,1 +np.float64,0xbfe1cceb9e6399d7,0xbfea0038bd3def20,1 +np.float64,0x8009170bd7122e18,0x8009170bd7122e18,1 +np.float64,0xb2b6f7f1656df,0xb2b6f7f1656df,1 +np.float64,0x3fc75bfd1f2eb7f8,0x3fc574c858332265,1 +np.float64,0x3fa24c06ec249800,0x3fa1fa462ffcb8ec,1 +np.float64,0xaa9a4d2d5534a,0xaa9a4d2d5534a,1 +np.float64,0xbfd7b76208af6ec4,0xbfdda0c3200dcc9f,1 +np.float64,0x7f8cbab73039756d,0x40860c20cba57a94,1 +np.float64,0x3fdbcf9f48b79f3f,0x3fd71827a60e8b6d,1 +np.float64,0xbfdd60f71a3ac1ee,0xbfe3a94bc8cf134d,1 +np.float64,0xb9253589724a7,0xb9253589724a7,1 +np.float64,0xbfcf28e37e3e51c8,0xbfd1da9977b741e3,1 +np.float64,0x80011457f7e228b1,0x80011457f7e228b1,1 +np.float64,0x7fec33df737867be,0x40862d404a897122,1 +np.float64,0xae55f8f95cabf,0xae55f8f95cabf,1 +np.float64,0xbfc1ab9397235728,0xbfc303e5533d4a5f,1 +np.float64,0x7fef0f84b3be1f08,0x40862e05f9ba7118,1 +np.float64,0x7fdc94f328b929e5,0x408627d01449d825,1 +np.float64,0x3fee1b598c7c36b3,0x3fe53847be166834,1 +np.float64,0x3fee8326f37d064e,0x3fe56d96f3fbcf43,1 +np.float64,0x3fe7b18a83ef6316,0x3fe1bb6a6d48c675,1 +np.float64,0x3fe5db969c6bb72e,0x3fe0a8d7d151996c,1 +np.float64,0x3e3391d27c673,0x3e3391d27c673,1 +np.float64,0x3fe79a46d76f348e,0x3fe1ae09a96ea628,1 +np.float64,0x7ff4000000000000,0x7ffc000000000000,1 +np.float64,0x7fe57d6505aafac9,0x40862b13925547f1,1 +np.float64,0x3fc433371d28666e,0x3fc2c196a764c47b,1 +np.float64,0x8008dbf69cd1b7ee,0x8008dbf69cd1b7ee,1 +np.float64,0xbfe744f459ee89e8,0xbff4c847ad3ee152,1 +np.float64,0x80098aa245331545,0x80098aa245331545,1 +np.float64,0x6747112ece8e3,0x6747112ece8e3,1 +np.float64,0x5d342a40ba69,0x5d342a40ba69,1 +np.float64,0xf7a17739ef42f,0xf7a17739ef42f,1 +np.float64,0x3fe1b34a9d236695,0x3fdc2d7c4e2c347a,1 +np.float64,0x7fb53bf5ec2a77eb,0x40861a585ec8f7ff,1 +np.float64,0xbfe6256f1cec4ade,0xbff2d89a36be65ae,1 +np.float64,0xb783bc9b6f078,0xb783bc9b6f078,1 +np.float64,0xbfedf74a3bfbee94,0xc0060bb6f2bc11ef,1 +np.float64,0x3fda2a5eccb454be,0x3fd5efd7f18b8e81,1 +np.float64,0xbfb3838ab2270718,0xbfb44c337fbca3c3,1 +np.float64,0x3fb4ac6dc22958e0,0x3fb3e194ca01a502,1 +np.float64,0x76c11aaaed824,0x76c11aaaed824,1 +np.float64,0x80025bb1af04b764,0x80025bb1af04b764,1 +np.float64,0x3fdc02740ab804e8,0x3fd73b8cd6f95f19,1 +np.float64,0x3fe71856f5ee30ae,0x3fe162e9fafb4428,1 +np.float64,0x800236f332646de7,0x800236f332646de7,1 +np.float64,0x7fe13fd9d2e27fb3,0x408629516b42a317,1 +np.float64,0x7fdf6bbd34bed779,0x40862892069d805c,1 +np.float64,0x3fd4727beba8e4f8,0x3fd1be5b48d9e282,1 +np.float64,0x800e0fac9e5c1f59,0x800e0fac9e5c1f59,1 +np.float64,0xfb54423ff6a89,0xfb54423ff6a89,1 +np.float64,0x800fbf7ed47f7efe,0x800fbf7ed47f7efe,1 +np.float64,0x3fe9d41fa2f3a840,0x3fe2ef98dc1fd463,1 +np.float64,0x800d733e805ae67d,0x800d733e805ae67d,1 +np.float64,0x3feebe4c46fd7c98,0x3fe58bcf7f47264e,1 +np.float64,0x7fe1ab77b5e356ee,0x40862982bb3dce34,1 +np.float64,0xbfdddac05abbb580,0xbfe41aa45f72d5a2,1 +np.float64,0x3fe14219dee28434,0x3fdb9b137d1f1220,1 +np.float64,0x3fe25d3d5a24ba7b,0x3fdd06e1cf32d35a,1 +np.float64,0x8000fa4fbe81f4a0,0x8000fa4fbe81f4a0,1 +np.float64,0x3fe303e23e6607c4,0x3fddd94982efa9f1,1 +np.float64,0x3fe89cf5d83139ec,0x3fe24193a2e12f75,1 +np.float64,0x3fe9b36ef87366de,0x3fe2dd7cdc25a4a5,1 +np.float64,0xbfdb8b38f8371672,0xbfe2023ba7e002bb,1 +np.float64,0xafc354955f86b,0xafc354955f86b,1 +np.float64,0xbfe2f3d49e65e7a9,0xbfecb557a94123d3,1 +np.float64,0x800496617c092cc4,0x800496617c092cc4,1 +np.float64,0x32db0cfa65b62,0x32db0cfa65b62,1 +np.float64,0xbfd893bfa2b12780,0xbfdf02a8c1e545aa,1 +np.float64,0x7fd5ac927d2b5924,0x408625997e7c1f9b,1 +np.float64,0x3fde9defb8bd3be0,0x3fd9056190986349,1 +np.float64,0x80030cfeb54619fe,0x80030cfeb54619fe,1 +np.float64,0x3fcba85b273750b8,0x3fc90a5ca976594f,1 +np.float64,0x3fe98f6f5cf31edf,0x3fe2c97fcb4eca25,1 +np.float64,0x3fe33dbf90667b80,0x3fde21b83321b993,1 +np.float64,0x3fe4686636e8d0cc,0x3fdf928cdca751b3,1 +np.float64,0x80018ade6ce315be,0x80018ade6ce315be,1 +np.float64,0x7fa9af70c8335ee1,0x408616528cd5a906,1 +np.float64,0x3fbeb460aa3d68c0,0x3fbcff96b00a2193,1 +np.float64,0x7fa82c869830590c,0x408615d6598d9368,1 +np.float64,0xd08c0e6fa1182,0xd08c0e6fa1182,1 +np.float64,0x3fef4eb750fe9d6f,0x3fe5d522fd4e7f64,1 +np.float64,0xbfc586f5492b0dec,0xbfc791eaae92aad1,1 +np.float64,0x7fede64ac7bbcc95,0x40862db7f444fa7b,1 +np.float64,0x3fe540003d6a8000,0x3fe04bdfc2916a0b,1 +np.float64,0x8009417fe6f28300,0x8009417fe6f28300,1 +np.float64,0x3fe6959cf16d2b3a,0x3fe116a1ce01887b,1 +np.float64,0x3fb0a40036214800,0x3fb01f447778219a,1 +np.float64,0x3feff26e91ffe4dd,0x3fe627798fc859a7,1 +np.float64,0x7fed8e46cd7b1c8d,0x40862da044a1d102,1 +np.float64,0x7fec4eb774f89d6e,0x40862d47e43edb53,1 +np.float64,0x3fe800e5e07001cc,0x3fe1e8e2b9105fc2,1 +np.float64,0x800f4eb2f9be9d66,0x800f4eb2f9be9d66,1 +np.float64,0x800611659bcc22cc,0x800611659bcc22cc,1 +np.float64,0x3fd66e65d2acdccc,0x3fd33ad63a5e1000,1 +np.float64,0x800a9085b7f5210c,0x800a9085b7f5210c,1 +np.float64,0x7fdf933a3fbf2673,0x4086289c0e292f2b,1 +np.float64,0x1cd1ba7a39a38,0x1cd1ba7a39a38,1 +np.float64,0xbfefd0b10fffa162,0xc0149ded900ed851,1 +np.float64,0xbfe8c63485b18c69,0xbff7cf3078b1574f,1 +np.float64,0x3fecde56ca79bcae,0x3fe4934afbd7dda9,1 +np.float64,0x8006cd6888cd9ad2,0x8006cd6888cd9ad2,1 +np.float64,0x3fd7a391c2af4724,0x3fd41e2f74df2329,1 +np.float64,0x3fe6a8ad58ed515a,0x3fe121ccfb28e6f5,1 +np.float64,0x7fe18a80dd631501,0x40862973c09086b9,1 +np.float64,0xbf74fd6d8029fb00,0xbf750b3e368ebe6b,1 +np.float64,0x3fdd35e93dba6bd4,0x3fd810071faaffad,1 +np.float64,0x3feb0d8f57361b1f,0x3fe39b3abdef8b7a,1 +np.float64,0xbfd5ec7288abd8e6,0xbfdad764df0d2ca1,1 +np.float64,0x7fdc848272b90904,0x408627cb78f3fb9e,1 +np.float64,0x800ed3eda91da7db,0x800ed3eda91da7db,1 +np.float64,0x3fefac64857f58c9,0x3fe60459dbaad1ba,1 +np.float64,0x3fd1df7a5ba3bef4,0x3fcf864a39b926ff,1 +np.float64,0xfe26ca4bfc4da,0xfe26ca4bfc4da,1 +np.float64,0xbfd1099f8da21340,0xbfd3cf6e6efe934b,1 +np.float64,0xbfe15de9a7a2bbd4,0xbfe909cc895f8795,1 +np.float64,0x3fe89714ed712e2a,0x3fe23e40d31242a4,1 +np.float64,0x800387113e470e23,0x800387113e470e23,1 +np.float64,0x3fe4f80730e9f00e,0x3fe0208219314cf1,1 +np.float64,0x2f95a97c5f2b6,0x2f95a97c5f2b6,1 +np.float64,0x800ea7cdd87d4f9c,0x800ea7cdd87d4f9c,1 +np.float64,0xbf64b967c0297300,0xbf64c020a145b7a5,1 +np.float64,0xbfc5a91a342b5234,0xbfc7bafd77a61d81,1 +np.float64,0xbfe2226fe76444e0,0xbfeac33eb1d1b398,1 +np.float64,0x3fc6aaa8d42d5552,0x3fc4de79f5c68cd4,1 +np.float64,0x3fe54fd4c1ea9faa,0x3fe05561a9a5922b,1 +np.float64,0x80029c1f75653840,0x80029c1f75653840,1 +np.float64,0xbfcb4a84a2369508,0xbfceb1a23bac3995,1 +np.float64,0x80010abeff02157f,0x80010abeff02157f,1 +np.float64,0x7f92d12cf825a259,0x40860e49bde3a5b6,1 +np.float64,0x800933e7027267ce,0x800933e7027267ce,1 +np.float64,0x3fc022b12e204562,0x3fbe64acc53ed887,1 +np.float64,0xbfe35f938de6bf27,0xbfedc1f3e443c016,1 +np.float64,0x1f8d9bae3f1b4,0x1f8d9bae3f1b4,1 +np.float64,0x3fe552f22ceaa5e4,0x3fe057404072350f,1 +np.float64,0xbfa73753442e6ea0,0xbfa7c24a100190f1,1 +np.float64,0x7fb3e2982827c52f,0x408619d1efa676b6,1 +np.float64,0xbfd80cb7a5301970,0xbfde28e65f344f33,1 +np.float64,0xbfcde835973bd06c,0xbfd10806fba46c8f,1 +np.float64,0xbfd4e3c749a9c78e,0xbfd949aff65de39c,1 +np.float64,0x3fcb4b9d6f36973b,0x3fc8be02ad6dc0d3,1 +np.float64,0x1a63000034c7,0x1a63000034c7,1 +np.float64,0x7fdc9c751e3938e9,0x408627d22df71959,1 +np.float64,0x3fd74f3f712e9e7f,0x3fd3e07df0c37ec1,1 +np.float64,0xbfceab74d33d56e8,0xbfd187e99bf82903,1 +np.float64,0x7ff0000000000000,0x7ff0000000000000,1 +np.float64,0xbfb2cca466259948,0xbfb3868208e8de30,1 +np.float64,0x800204688b8408d2,0x800204688b8408d2,1 +np.float64,0x3e4547407c8aa,0x3e4547407c8aa,1 +np.float64,0xbfe4668846e8cd10,0xbff03c85189f3818,1 +np.float64,0x800dd350245ba6a0,0x800dd350245ba6a0,1 +np.float64,0xbfbc13c160382780,0xbfbdbd56ce996d16,1 +np.float64,0x7fe25a628a24b4c4,0x408629d06eb2d64d,1 +np.float64,0x3fd19dabbc233b57,0x3fcf1f3ed1d34c8c,1 +np.float64,0x547e20faa8fc5,0x547e20faa8fc5,1 +np.float64,0xbfe19392c6232726,0xbfe97ffe4f303335,1 +np.float64,0x3f87f9f6702ff400,0x3f87d64fb471bb04,1 +np.float64,0x9dfc52db3bf8b,0x9dfc52db3bf8b,1 +np.float64,0x800e1f5a9adc3eb5,0x800e1f5a9adc3eb5,1 +np.float64,0xbfddbd09c8bb7a14,0xbfe3fed7d7cffc70,1 +np.float64,0xbfeda71af87b4e36,0xc004e6631c514544,1 +np.float64,0xbfdbfcfe1bb7f9fc,0xbfe266b5d4a56265,1 +np.float64,0x3fe4ee78cd69dcf2,0x3fe01abba4e81fc9,1 +np.float64,0x800f13b820de2770,0x800f13b820de2770,1 +np.float64,0x3f861e09702c3c00,0x3f85ffae83b02c4f,1 +np.float64,0xbfc0972479212e48,0xbfc1c4bf70b30cbc,1 +np.float64,0x7fef057ef57e0afd,0x40862e036479f6a9,1 +np.float64,0x8bdbabe517b76,0x8bdbabe517b76,1 +np.float64,0xbfec495417f892a8,0xc0013ade88746d18,1 +np.float64,0x3fec680ab3f8d015,0x3fe454dd304b560d,1 +np.float64,0xbfae7ce60c3cf9d0,0xbfaf6eef15bbe56b,1 +np.float64,0x3fec314124786282,0x3fe437ca06294f5a,1 +np.float64,0x7fd5ed05b82bda0a,0x408625b125518e58,1 +np.float64,0x3feac9f02f3593e0,0x3fe3768104dd5cb7,1 +np.float64,0x0,0x0,1 +np.float64,0xbfddd2abd5bba558,0xbfe41312b8ea20de,1 +np.float64,0xbfedf9558c7bf2ab,0xc00613c53e0bb33a,1 +np.float64,0x3fef245ffefe48c0,0x3fe5bfb4dfe3b7a5,1 +np.float64,0x7fe178604922f0c0,0x4086296b77d5eaef,1 +np.float64,0x10000000000000,0x10000000000000,1 +np.float64,0x7fed026766ba04ce,0x40862d7a0dc45643,1 +np.float64,0xbfde27d8c3bc4fb2,0xbfe46336b6447697,1 +np.float64,0x3fe9485d9cb290bb,0x3fe2a1e4b6419423,1 +np.float64,0xbfe27b8a7464f715,0xbfeb9382f5b16f65,1 +np.float64,0x5c34d274b869b,0x5c34d274b869b,1 +np.float64,0xbfeee0b7453dc16f,0xc00acdb46459b6e6,1 +np.float64,0x7fe3dfb4d4e7bf69,0x40862a73785fdf12,1 +np.float64,0xb4635eef68c6c,0xb4635eef68c6c,1 +np.float64,0xbfe522a2c82a4546,0xbff148912a59a1d6,1 +np.float64,0x8009ba38a9737472,0x8009ba38a9737472,1 +np.float64,0xbfc056ff3820ae00,0xbfc17b2205fa180d,1 +np.float64,0x7fe1c8b8a0239170,0x4086298feeee6133,1 +np.float64,0x3fe2d2c6b9e5a58e,0x3fdd9b907471031b,1 +np.float64,0x3fa0a161bc2142c0,0x3fa05db36f6a073b,1 +np.float64,0x3fdef4268ebde84c,0x3fd93f980794d1e7,1 +np.float64,0x800ecd9fe2fd9b40,0x800ecd9fe2fd9b40,1 +np.float64,0xbfc9fbd45e33f7a8,0xbfcd0afc47c340f6,1 +np.float64,0x3fe8c3035b718606,0x3fe2570eb65551a1,1 +np.float64,0xbfe78c4ad2ef1896,0xbff54d25b3328742,1 +np.float64,0x8006f5dcf8adebbb,0x8006f5dcf8adebbb,1 +np.float64,0x800301dca2a603ba,0x800301dca2a603ba,1 +np.float64,0xad4289e55a851,0xad4289e55a851,1 +np.float64,0x80037764f9e6eecb,0x80037764f9e6eecb,1 +np.float64,0xbfe73575b26e6aec,0xbff4abfb5e985c62,1 +np.float64,0xbfc6cb91652d9724,0xbfc91a8001b33ec2,1 +np.float64,0xbfe3a918ffe75232,0xbfee7e6e4fd34c53,1 +np.float64,0x9bc84e2b3790a,0x9bc84e2b3790a,1 +np.float64,0x7fdeec303cbdd85f,0x408628714a49d996,1 +np.float64,0x3fe1d1dcb763a3ba,0x3fdc54ce060dc7f4,1 +np.float64,0x8008ae6432b15cc9,0x8008ae6432b15cc9,1 +np.float64,0x3fd8022fa2b00460,0x3fd46322bf02a609,1 +np.float64,0xbfc55b64472ab6c8,0xbfc75d9568f462e0,1 +np.float64,0xbfe8b165437162ca,0xbff7a15e2ead645f,1 +np.float64,0x7f759330feeb3,0x7f759330feeb3,1 +np.float64,0xbfd504f68eaa09ee,0xbfd97b06c01d7473,1 +np.float64,0x54702d5aa8e06,0x54702d5aa8e06,1 +np.float64,0xbfed1779337a2ef2,0xc0032f7109ef5a51,1 +np.float64,0xe248bd4dc4918,0xe248bd4dc4918,1 +np.float64,0xbfd8c59150318b22,0xbfdf53bca6ca8b1e,1 +np.float64,0xbfe3b9d942e773b2,0xbfeea9fcad277ba7,1 +np.float64,0x800934ec127269d9,0x800934ec127269d9,1 +np.float64,0xbfbb7f535a36fea8,0xbfbd16d61b6c52b8,1 +np.float64,0xccb185a199631,0xccb185a199631,1 +np.float64,0x3fe3dda76fe7bb4e,0x3fdee83bc6094301,1 +np.float64,0xbfe0c902f5e19206,0xbfe7ca7c0e888006,1 +np.float64,0xbfefeed08cbfdda1,0xc018aadc483c8724,1 +np.float64,0x7fd0c05c52a180b8,0x40862389daf64aac,1 +np.float64,0xbfd28e3323a51c66,0xbfd5e9ba278fb685,1 +np.float64,0xbef4103b7de82,0xbef4103b7de82,1 +np.float64,0x3fe7661fd12ecc40,0x3fe18ff7dfb696e2,1 +np.float64,0x3fddd5f2f0bbabe4,0x3fd87d8bb6719c3b,1 +np.float64,0x800b3914cfd6722a,0x800b3914cfd6722a,1 +np.float64,0xf3f09a97e7e14,0xf3f09a97e7e14,1 +np.float64,0x7f97092b502e1256,0x40860fe8054cf54e,1 +np.float64,0xbfdbec7917b7d8f2,0xbfe2580b4b792c79,1 +np.float64,0x7fe7ff215aaffe42,0x40862bf5887fa062,1 +np.float64,0x80080186e570030e,0x80080186e570030e,1 +np.float64,0xbfc27f05e624fe0c,0xbfc3fa214be4adc4,1 +np.float64,0x3fe4481be1689038,0x3fdf6b11e9c4ca72,1 +np.float64,0x3fd642cc9cac8598,0x3fd31a857fe70227,1 +np.float64,0xbef8782d7df0f,0xbef8782d7df0f,1 +np.float64,0x8003077dc2e60efc,0x8003077dc2e60efc,1 +np.float64,0x80083eb5a2507d6c,0x80083eb5a2507d6c,1 +np.float64,0x800e8d1eb77d1a3e,0x800e8d1eb77d1a3e,1 +np.float64,0xbfc7737cd22ee6f8,0xbfc9e7716f03f1fc,1 +np.float64,0xbfe9a2b4ddf3456a,0xbff9d71664a8fc78,1 +np.float64,0x7fe67c7d322cf8f9,0x40862b7066465194,1 +np.float64,0x3fec080ce2b8101a,0x3fe421dac225be46,1 +np.float64,0xbfe6d27beb6da4f8,0xbff3fbb1add521f7,1 +np.float64,0x3fdd4f96ceba9f2e,0x3fd821a638986dbe,1 +np.float64,0x3fbd89f1303b13e2,0x3fbbf49223a9d002,1 +np.float64,0xbfe94e2b9d329c57,0xbff907e549c534f5,1 +np.float64,0x3fe2f2cc51e5e599,0x3fddc3d6b4a834a1,1 +np.float64,0xfdcb5b49fb96c,0xfdcb5b49fb96c,1 +np.float64,0xbfea7108fa74e212,0xbffc01b392f4897b,1 +np.float64,0x3fd38baef7a7175c,0x3fd10e7fd3b958dd,1 +np.float64,0x3fa75bf9cc2eb800,0x3fa6d792ecdedb8e,1 +np.float64,0x7fd19fd20aa33fa3,0x408623f1e2cd04c3,1 +np.float64,0x3fd62c708dac58e0,0x3fd309ec7818d16e,1 +np.float64,0x3fdf489047be9120,0x3fd978640617c758,1 +np.float64,0x1,0x1,1 +np.float64,0xbfe21e7c3ea43cf8,0xbfeaba21320697d3,1 +np.float64,0xbfd3649047a6c920,0xbfd71a6f14223744,1 +np.float64,0xbfd68ca68c2d194e,0xbfdbcce6784e5d44,1 +np.float64,0x3fdb26b0ea364d62,0x3fd6a1f86f64ff74,1 +np.float64,0xbfd843821cb08704,0xbfde80e90805ab3f,1 +np.float64,0x3fd508a27aaa1144,0x3fd22fc203a7b9d8,1 +np.float64,0xbfdb951c7eb72a38,0xbfe20aeaec13699b,1 +np.float64,0x3fef556ba57eaad7,0x3fe5d8865cce0a6d,1 +np.float64,0x3fd0d224b3a1a448,0x3fcdde7be5d7e21e,1 +np.float64,0x8007ff272baffe4f,0x8007ff272baffe4f,1 +np.float64,0x3fe1c7bddf638f7c,0x3fdc47cc6cf2f5cd,1 +np.float64,0x7ff8000000000000,0x7ff8000000000000,1 +np.float64,0x2016d560402f,0x2016d560402f,1 +np.float64,0xbfcca10be9394218,0xbfd033f36b94fc54,1 +np.float64,0xbfdb833628b7066c,0xbfe1fb344b840c70,1 +np.float64,0x3fd8529cb3b0a539,0x3fd49d847fe77218,1 +np.float64,0xbfc0b0ebab2161d8,0xbfc1e260c60ffd1b,1 +np.float64,0xbfea8b9a79f51735,0xbffc4ee6be8a0fa2,1 +np.float64,0x7feca8fab7f951f4,0x40862d613e454646,1 +np.float64,0x7fd8c52d82318a5a,0x408626aaf37423a3,1 +np.float64,0xbfe364ad4526c95a,0xbfedcee39bc93ff5,1 +np.float64,0x800b78161256f02d,0x800b78161256f02d,1 +np.float64,0xbfd55f0153aabe02,0xbfda01a78f72d494,1 +np.float64,0x800315a5f0662b4d,0x800315a5f0662b4d,1 +np.float64,0x7fe4c0dca02981b8,0x40862acc27e4819f,1 +np.float64,0x8009825c703304b9,0x8009825c703304b9,1 +np.float64,0x3fe6e94e1cadd29c,0x3fe1478ccc634f49,1 +np.float64,0x7fe622d8586c45b0,0x40862b504177827e,1 +np.float64,0x3fe4458600688b0c,0x3fdf67e79a84b953,1 +np.float64,0xbfdd75d8a1baebb2,0xbfe3bc9e6ca1bbb5,1 +np.float64,0x3fde789c6bbcf138,0x3fd8ec1d435531b3,1 +np.float64,0x3fe7052b94ee0a58,0x3fe157c5c4418dc1,1 +np.float64,0x7fef31652abe62c9,0x40862e0eaeabcfc0,1 +np.float64,0x3fe279691ee4f2d2,0x3fdd2aa41eb43cd4,1 +np.float64,0xbfd533fa95aa67f6,0xbfd9c12f516d29d7,1 +np.float64,0x3fe6d057f96da0b0,0x3fe138fd96693a6a,1 +np.float64,0x800bad984f775b31,0x800bad984f775b31,1 +np.float64,0x7fdd6fdba4badfb6,0x4086280c73d8ef97,1 +np.float64,0x7fe9b5c0eef36b81,0x40862c82c6f57a53,1 +np.float64,0x8000bc02ece17807,0x8000bc02ece17807,1 +np.float64,0xbff0000000000000,0xfff0000000000000,1 +np.float64,0xbfed430be3fa8618,0xc003aaf338c75b3c,1 +np.float64,0x3fee17b759fc2f6f,0x3fe53668696bf48b,1 +np.float64,0x3f8d4cf9d03a9a00,0x3f8d17d2f532afdc,1 +np.float64,0x8005d6257b8bac4c,0x8005d6257b8bac4c,1 +np.float64,0xbfd17a6df9a2f4dc,0xbfd469e3848adc6e,1 +np.float64,0xb28a293965145,0xb28a293965145,1 +np.float64,0xbfe7d011e42fa024,0xbff5cf818998c8ec,1 +np.float64,0xbfe74f0f136e9e1e,0xbff4dad6ebb0443c,1 +np.float64,0x800f249fc9be4940,0x800f249fc9be4940,1 +np.float64,0x2542f8fe4a860,0x2542f8fe4a860,1 +np.float64,0xc48d40cd891a8,0xc48d40cd891a8,1 +np.float64,0x3fe4e64bc8e9cc98,0x3fe015c9eb3caa53,1 +np.float64,0x3fd33881eca67104,0x3fd0cea886be2457,1 +np.float64,0xbfd01748fba02e92,0xbfd28875959e6901,1 +np.float64,0x7fb7ab01f22f5603,0x40861b369927bf53,1 +np.float64,0xbfe340274ce6804e,0xbfed72b39f0ebb24,1 +np.float64,0x7fc16c0c3422d817,0x40861e4eaf1a286c,1 +np.float64,0x3fc26944a324d288,0x3fc133a77b356ac4,1 +np.float64,0xa149d7134293b,0xa149d7134293b,1 +np.float64,0x800837382d106e71,0x800837382d106e71,1 +np.float64,0x797d1740f2fa4,0x797d1740f2fa4,1 +np.float64,0xc3f15b7787e2c,0xc3f15b7787e2c,1 +np.float64,0x80cad1b90195a,0x80cad1b90195a,1 +np.float64,0x3fdd8f1142bb1e23,0x3fd84d21490d1ce6,1 +np.float64,0xbfbde6c9123bcd90,0xbfbfcc030a86836a,1 +np.float64,0x8007f77e032feefd,0x8007f77e032feefd,1 +np.float64,0x3fe74fed1c6e9fda,0x3fe18322cf19cb61,1 +np.float64,0xbfd8a40bbcb14818,0xbfdf1d23520ba74b,1 +np.float64,0xbfeb7a0e6076f41d,0xbfff4ddfb926efa5,1 +np.float64,0xbfcb8c5f663718c0,0xbfcf0570f702bda9,1 +np.float64,0xf668cd97ecd1a,0xf668cd97ecd1a,1 +np.float64,0xbfe92accf572559a,0xbff8b4393878ffdb,1 +np.float64,0xbfeaa955567552ab,0xbffca70c7d73eee5,1 +np.float64,0xbfe083a14f610742,0xbfe739d84bc35077,1 +np.float64,0x78290568f0521,0x78290568f0521,1 +np.float64,0x3fe94bae2372975c,0x3fe2a3beac5c9858,1 +np.float64,0x3fca4fbab9349f78,0x3fc7edbca2492acb,1 +np.float64,0x8000000000000000,0x8000000000000000,1 +np.float64,0x7fb9eb505433d6a0,0x40861bf0adedb74d,1 +np.float64,0x7fdc66f72a38cded,0x408627c32aeecf0f,1 +np.float64,0x2e8e6f445d1cf,0x2e8e6f445d1cf,1 +np.float64,0xbfec43195af88633,0xc0012d7e3f91b7e8,1 +np.float64,0x7fcdb971e93b72e3,0x40862294c9e3a7bc,1 +np.float64,0x800cabc461195789,0x800cabc461195789,1 +np.float64,0x2c79709c58f2f,0x2c79709c58f2f,1 +np.float64,0x8005d772d3cbaee6,0x8005d772d3cbaee6,1 +np.float64,0x3fe84d8c03709b18,0x3fe21490ce3673dd,1 +np.float64,0x7fe5578adc2aaf15,0x40862b056e8437d4,1 +np.float64,0xbf91298c58225320,0xbf914ec86c32d11f,1 +np.float64,0xc7ed2b6d8fda6,0xc7ed2b6d8fda6,1 +np.float64,0x2761404c4ec29,0x2761404c4ec29,1 +np.float64,0x3fbad3c48835a789,0x3fb9833c02385305,1 +np.float64,0x3fa46fee5428dfe0,0x3fa40a357fb24c23,1 +np.float64,0xbfe3900c6fe72019,0xbfee3dba29dd9d43,1 +np.float64,0x3fe7a9e41a6f53c8,0x3fe1b704dfb9884b,1 +np.float64,0xbfe74a7a1eee94f4,0xbff4d269cacb1f29,1 +np.float64,0xbfee609c72fcc139,0xc007da8499d34123,1 +np.float64,0x3fef2d5fc23e5ac0,0x3fe5c44414e59cb4,1 +np.float64,0xbfd7bdc0402f7b80,0xbfddaae1e7bb78fb,1 +np.float64,0xd71ee01dae3dc,0xd71ee01dae3dc,1 +np.float64,0x3fe98cbcdef3197a,0x3fe2c7ffe33c4541,1 +np.float64,0x8000f8dbb3a1f1b8,0x8000f8dbb3a1f1b8,1 +np.float64,0x3fe3e98ad567d316,0x3fdef6e58058313f,1 +np.float64,0x41ad0bfc835a2,0x41ad0bfc835a2,1 +np.float64,0x7fdcc2dc0d3985b7,0x408627dce39f77af,1 +np.float64,0xbfe47b980de8f730,0xbff059acdccd6e2b,1 +np.float64,0xbfef49b6577e936d,0xc00e714f46b2ccc1,1 +np.float64,0x3fac31816c386300,0x3fab71cb92b0db8f,1 +np.float64,0x3fe59097e76b2130,0x3fe07c299fd1127c,1 +np.float64,0xbfecf0df5cf9e1bf,0xc002c7ebdd65039c,1 +np.float64,0x3fd2b7d0b6a56fa1,0x3fd06b638990ae02,1 +np.float64,0xbfeb68deecf6d1be,0xbfff1187e042d3e4,1 +np.float64,0x3fd44a9771a8952f,0x3fd1a01867c5e302,1 +np.float64,0xf79a9dedef354,0xf79a9dedef354,1 +np.float64,0x800c25a170d84b43,0x800c25a170d84b43,1 +np.float64,0x3ff0000000000000,0x3fe62e42fefa39ef,1 +np.float64,0x3fbff4f7623fe9f0,0x3fbe1d3878f4c417,1 +np.float64,0xd284c845a5099,0xd284c845a5099,1 +np.float64,0xbfe3c7815f678f02,0xbfeecdab5ca2e651,1 +np.float64,0x3fc19c934e233927,0x3fc08036104b1f23,1 +np.float64,0x800b6096de16c12e,0x800b6096de16c12e,1 +np.float64,0xbfe962a67e32c54d,0xbff9392313a112a1,1 +np.float64,0x2b9d0116573a1,0x2b9d0116573a1,1 +np.float64,0x3fcab269ed3564d4,0x3fc83f7e1c3095b7,1 +np.float64,0x3fc8c78d86318f1b,0x3fc6a6cde5696f99,1 +np.float64,0xd5b1e9b5ab63d,0xd5b1e9b5ab63d,1 +np.float64,0xbfed802a47fb0054,0xc00465cad3b5b0ef,1 +np.float64,0xbfd73aaf08ae755e,0xbfdcdbd62b8af271,1 +np.float64,0xbfd4f13c0229e278,0xbfd95dacff79e570,1 +np.float64,0xbfe9622808f2c450,0xbff937f13c397e8d,1 +np.float64,0xbfeddfa62efbbf4c,0xc005b0c835eed829,1 +np.float64,0x3fd65663d4acacc8,0x3fd3290cd0e675dc,1 +np.float64,0x8005e890f1abd123,0x8005e890f1abd123,1 +np.float64,0xbfe924919fb24923,0xbff8a5a827a28756,1 +np.float64,0x3fe8cdf490719be9,0x3fe25d39535e8366,1 +np.float64,0x7fc229e6ff2453cd,0x40861ea40ef87a5a,1 +np.float64,0x3fe5cf53ceeb9ea8,0x3fe0a18e0b65f27e,1 +np.float64,0xa79cf6fb4f39f,0xa79cf6fb4f39f,1 +np.float64,0x7fddbb3c0f3b7677,0x40862820d5edf310,1 +np.float64,0x3e1011de7c203,0x3e1011de7c203,1 +np.float64,0x3fc0b59a83216b38,0x3fbf6916510ff411,1 +np.float64,0x8647f98d0c8ff,0x8647f98d0c8ff,1 +np.float64,0x8005dad33ecbb5a7,0x8005dad33ecbb5a7,1 +np.float64,0x8a80d0631501a,0x8a80d0631501a,1 +np.float64,0xbfe18f7d6ee31efb,0xbfe976f06713afc1,1 +np.float64,0xbfe06eaed560dd5e,0xbfe70eac696933e6,1 +np.float64,0xbfed8ef93c7b1df2,0xc00495bfa3195b53,1 +np.float64,0x3febe9c24677d385,0x3fe411b10db16c42,1 +np.float64,0x7fd5d80c1fabb017,0x408625a97a7787ba,1 +np.float64,0x3fca79b59334f368,0x3fc8108a521341dc,1 +np.float64,0xbfccf8db4339f1b8,0xbfd06c9a5424aadb,1 +np.float64,0xbfea5ac5a574b58b,0xbffbc21d1405d840,1 +np.float64,0x800ce2bf4b19c57f,0x800ce2bf4b19c57f,1 +np.float64,0xbfe8df896d31bf13,0xbff807ab38ac41ab,1 +np.float64,0x3feab83da9f5707c,0x3fe36cdd827c0eff,1 +np.float64,0x3fee717683bce2ed,0x3fe564879171719b,1 +np.float64,0x80025e5577c4bcac,0x80025e5577c4bcac,1 +np.float64,0x3fe3e5378e67ca70,0x3fdef1902c5d1efd,1 +np.float64,0x3fa014bb7c202980,0x3f9faacf9238d499,1 +np.float64,0x3fddbf5e16bb7ebc,0x3fd86e2311cb0f6d,1 +np.float64,0x3fd24e50e6a49ca0,0x3fd0198f04f82186,1 +np.float64,0x656b5214cad6b,0x656b5214cad6b,1 +np.float64,0x8b0a4bfd1614a,0x8b0a4bfd1614a,1 +np.float64,0xbfeeb6bd9e7d6d7b,0xc009b669285e319e,1 +np.float64,0x8000000000000001,0x8000000000000001,1 +np.float64,0xbfe719feceee33fe,0xbff47a4c8cbf0cca,1 +np.float64,0xbfd14fa8c8a29f52,0xbfd42f27b1aced39,1 +np.float64,0x7fec9dcb80f93b96,0x40862d5e1e70bbb9,1 +np.float64,0x7fecacb826f9596f,0x40862d6249746915,1 +np.float64,0x973459f52e68b,0x973459f52e68b,1 +np.float64,0x7f40a59e00214b3b,0x4085f194f45f82b1,1 +np.float64,0x7fc5dbaec32bb75d,0x4086201f3e7065d9,1 +np.float64,0x82d0801305a10,0x82d0801305a10,1 +np.float64,0x7fec81c0f4790381,0x40862d5643c0fc85,1 +np.float64,0xbfe2d81e9ee5b03d,0xbfec71a8e864ea40,1 +np.float64,0x6c545c9ad8a8c,0x6c545c9ad8a8c,1 +np.float64,0x3f9be95a5037d2b5,0x3f9b89b48ac8f5d8,1 +np.float64,0x8000cae9702195d4,0x8000cae9702195d4,1 +np.float64,0xbfd375f45126ebe8,0xbfd733677e54a80d,1 +np.float64,0x3fd29a5b81a534b7,0x3fd05494bf200278,1 +np.float64,0xfff0000000000000,0xfff8000000000000,1 +np.float64,0x7fca8fc195351f82,0x408621ae61aa6c13,1 +np.float64,0x1b28e2ae3651d,0x1b28e2ae3651d,1 +np.float64,0x3fe7fdbd14effb7a,0x3fe1e714884b46a8,1 +np.float64,0x3fdf1ce068be39c0,0x3fd95b054e0fad3d,1 +np.float64,0x3fe79f9a636f3f34,0x3fe1b11a40c00b3e,1 +np.float64,0x3fe60eb7036c1d6e,0x3fe0c72a02176874,1 +np.float64,0x229da17e453b5,0x229da17e453b5,1 +np.float64,0x3fc1a921b5235240,0x3fc08b3f35e47fb1,1 +np.float64,0xbb92d2af7725b,0xbb92d2af7725b,1 +np.float64,0x3fe4110cb1e8221a,0x3fdf2787de6c73f7,1 +np.float64,0xbfbc87771a390ef0,0xbfbe3f6e95622363,1 +np.float64,0xbfe74025dfee804c,0xbff4bf7b1895e697,1 +np.float64,0x964eb6592c9d7,0x964eb6592c9d7,1 +np.float64,0x3f951689b82a2d00,0x3f94dfb38d746fdf,1 +np.float64,0x800356271be6ac4f,0x800356271be6ac4f,1 +np.float64,0x7fefffffffffffff,0x40862e42fefa39ef,1 +np.float64,0xbfed5ce250fab9c5,0xc003f7ddfeb94345,1 +np.float64,0x3fec3d5dc1387abc,0x3fe43e39c02d86f4,1 +np.float64,0x3999897e73332,0x3999897e73332,1 +np.float64,0xbfdcb57744b96aee,0xbfe30c4b98f3d088,1 +np.float64,0x7f961fb0b82c3f60,0x40860f9549c3a380,1 +np.float64,0x67d6efcacfadf,0x67d6efcacfadf,1 +np.float64,0x8002c9498f859294,0x8002c9498f859294,1 +np.float64,0xbfa3033800260670,0xbfa35fe3bf43e188,1 +np.float64,0xbfeab2fc157565f8,0xbffcc413c486b4eb,1 +np.float64,0x3fe25e62f364bcc6,0x3fdd0856e19e3430,1 +np.float64,0x7fb2f42dda25e85b,0x4086196fb34a65fd,1 +np.float64,0x3fe0f1a5af61e34c,0x3fdb3235a1786efb,1 +np.float64,0x800a340ca1f4681a,0x800a340ca1f4681a,1 +np.float64,0x7c20b9def8418,0x7c20b9def8418,1 +np.float64,0xdf0842a1be109,0xdf0842a1be109,1 +np.float64,0x3fe9f22cc2f3e45a,0x3fe300359b842bf0,1 +np.float64,0x3fe389ed73e713da,0x3fde809780fe4432,1 +np.float64,0x9500fb932a020,0x9500fb932a020,1 +np.float64,0x3fd8a21ffdb14440,0x3fd4d70862345d86,1 +np.float64,0x800d99c15cbb3383,0x800d99c15cbb3383,1 +np.float64,0x3fd96c98c932d932,0x3fd568959c9b028f,1 +np.float64,0x7fc228483a24508f,0x40861ea358420976,1 +np.float64,0x7fc6737bef2ce6f7,0x408620560ffc6a98,1 +np.float64,0xbfb2c27cee2584f8,0xbfb37b8cc7774b5f,1 +np.float64,0xbfd18409f9230814,0xbfd4771d1a9a24fb,1 +np.float64,0x3fb53cb3f42a7968,0x3fb466f06f88044b,1 +np.float64,0x3fef61d0187ec3a0,0x3fe5dec8a9d13dd9,1 +np.float64,0x3fe59a6ffd2b34e0,0x3fe0820a99c6143d,1 +np.float64,0x3fce18aff43c3160,0x3fcb07c7b523f0d1,1 +np.float64,0xbfb1319a62226338,0xbfb1cc62f31b2b40,1 +np.float64,0xa00cce6d4019a,0xa00cce6d4019a,1 +np.float64,0x80068ae8e0ed15d3,0x80068ae8e0ed15d3,1 +np.float64,0x3fecef353239de6a,0x3fe49c280adc607b,1 +np.float64,0x3fdf1a7fb0be34ff,0x3fd9596bafe2d766,1 +np.float64,0x3feb5e12eeb6bc26,0x3fe3c6be3ede8d07,1 +np.float64,0x3fdeff5cd43dfeba,0x3fd947262ec96b05,1 +np.float64,0x3f995e75e832bd00,0x3f990f511f4c7f1c,1 +np.float64,0xbfeb5b3ed0b6b67e,0xbffee24fc0fc2881,1 +np.float64,0x7fb82aad0a305559,0x40861b614d901182,1 +np.float64,0xbfe5c3a4926b8749,0xbff23cd0ad144fe6,1 +np.float64,0x3fef47da373e8fb4,0x3fe5d1aaa4031993,1 +np.float64,0x7fc6a8c3872d5186,0x40862068f5ca84be,1 +np.float64,0x7fc0c2276221844e,0x40861dff2566d001,1 +np.float64,0x7fc9ce7d28339cf9,0x40862173541f84d1,1 +np.float64,0x3fce2c34933c5869,0x3fcb179428ad241d,1 +np.float64,0xbfcf864c293f0c98,0xbfd21872c4821cfc,1 +np.float64,0x3fc51fd1f82a3fa4,0x3fc38d4f1685c166,1 +np.float64,0xbfe2707b70a4e0f7,0xbfeb795fbd5bb444,1 +np.float64,0x46629b568cc54,0x46629b568cc54,1 +np.float64,0x7fe5f821f32bf043,0x40862b40c2cdea3f,1 +np.float64,0x3fedd2c9457ba592,0x3fe512ce92394526,1 +np.float64,0x7fe6dcb8ceadb971,0x40862b925a7dc05d,1 +np.float64,0x3fd1b983b4a37307,0x3fcf4ae2545cf64e,1 +np.float64,0xbfe1c93104639262,0xbfe9f7d28e4c0c82,1 +np.float64,0x995ebc2932bd8,0x995ebc2932bd8,1 +np.float64,0x800a4c3ee614987e,0x800a4c3ee614987e,1 +np.float64,0x3fbb58766e36b0f0,0x3fb9fb3b9810ec16,1 +np.float64,0xbfe36d636666dac7,0xbfede5080f69053c,1 +np.float64,0x3f4feee1003fddc2,0x3f4feae5f05443d1,1 +np.float64,0x3fed0b772ffa16ee,0x3fe4aafb924903c6,1 +np.float64,0x800bb3faef3767f6,0x800bb3faef3767f6,1 +np.float64,0x3fe285cda5e50b9c,0x3fdd3a58df06c427,1 +np.float64,0x7feb9d560bb73aab,0x40862d152362bb94,1 +np.float64,0x3fecd1f447f9a3e9,0x3fe48cc78288cb3f,1 +np.float64,0x3fca927b0c3524f6,0x3fc8250f49ba28df,1 +np.float64,0x7fcc19944e383328,0x40862221b02fcf43,1 +np.float64,0xbfd8ddf41db1bbe8,0xbfdf7b92073ff2fd,1 +np.float64,0x80006fe736e0dfcf,0x80006fe736e0dfcf,1 +np.float64,0x800bbeb66d577d6d,0x800bbeb66d577d6d,1 +np.float64,0xbfe4329353e86526,0xbfefeaf19ab92b42,1 +np.float64,0x2fad72805f5af,0x2fad72805f5af,1 +np.float64,0x3fe1b827aa637050,0x3fdc33bf46012c0d,1 +np.float64,0x3fc3f3f8e227e7f2,0x3fc28aeb86d65278,1 +np.float64,0x3fec018933780312,0x3fe41e619aa4285c,1 +np.float64,0xbfd92428e0b24852,0xbfdfeecb08d154df,1 +np.float64,0x2d7046845ae0a,0x2d7046845ae0a,1 +np.float64,0x7fde7fd2233cffa3,0x408628550f8a948f,1 +np.float64,0x8000a32cd241465a,0x8000a32cd241465a,1 +np.float64,0x8004267a45084cf5,0x8004267a45084cf5,1 +np.float64,0xbfe6b422556d6844,0xbff3c71f67661e6e,1 +np.float64,0x3fe3a37d922746fb,0x3fdea04e04d6195c,1 +np.float64,0xbfddcc54b53b98aa,0xbfe40d2389cdb848,1 +np.float64,0x3fe18b4b92a31697,0x3fdbf9e68cbf5794,1 +np.float64,0x7fc9c5b2ee338b65,0x408621709a17a47a,1 +np.float64,0x1ebd1ce03d7b,0x1ebd1ce03d7b,1 +np.float64,0x8008a6fc39d14df9,0x8008a6fc39d14df9,1 +np.float64,0x3fec11384c782270,0x3fe426bdaedd2965,1 +np.float64,0x3fefc28344ff8507,0x3fe60f75d34fc3d2,1 +np.float64,0xc35f379786be7,0xc35f379786be7,1 +np.float64,0x3feef51f4a7dea3e,0x3fe5a7b95d7786b5,1 +np.float64,0x3fec9b9f0379373e,0x3fe4702477abbb63,1 +np.float64,0x3fde94f8cdbd29f0,0x3fd8ff50f7df0a6f,1 +np.float64,0xbfed32d1cdfa65a4,0xc0037c1470f6f979,1 +np.float64,0x800d3ba44f5a7749,0x800d3ba44f5a7749,1 +np.float64,0x3fe3c56c8fe78ad9,0x3fdeca4eb9bb8918,1 +np.float64,0xbfe7c97242ef92e4,0xbff5c2950dfd6f69,1 +np.float64,0xbd9440057b288,0xbd9440057b288,1 +np.float64,0x7feb2fc111f65f81,0x40862cf524bd2001,1 +np.float64,0x800a431e2df4863d,0x800a431e2df4863d,1 +np.float64,0x80038a3b79e71478,0x80038a3b79e71478,1 +np.float64,0x80000c93d4601928,0x80000c93d4601928,1 +np.float64,0x7fe9fec022f3fd7f,0x40862c995db8ada0,1 +np.float64,0x3fead0129c35a025,0x3fe379d7a92c8f79,1 +np.float64,0x3fdd8cbaf7bb1974,0x3fd84b87ff0c26c7,1 +np.float64,0x3fe8fb7c60b1f6f9,0x3fe276d5339e7135,1 +np.float64,0x85a255e10b44b,0x85a255e10b44b,1 +np.float64,0xbfe507c23fea0f84,0xbff1212d2260022a,1 +np.float64,0x3fc5487c7b2a90f9,0x3fc3b03222d3d148,1 +np.float64,0x7fec0bdcb8f817b8,0x40862d34e8fd11e7,1 +np.float64,0xbfc5f34b4f2be698,0xbfc8146a899c7a0c,1 +np.float64,0xbfa2a49c14254940,0xbfa2fdab2eae3826,1 +np.float64,0x800ec52f15dd8a5e,0x800ec52f15dd8a5e,1 +np.float64,0xbfe3ba4b12a77496,0xbfeeab256b3e9422,1 +np.float64,0x80034d6c7ba69ada,0x80034d6c7ba69ada,1 +np.float64,0x7fd394d4202729a7,0x408624c98a216742,1 +np.float64,0xbfd4493a38289274,0xbfd865d67af2de91,1 +np.float64,0xe47d6203c8fad,0xe47d6203c8fad,1 +np.float64,0x98eb4e4b31d6a,0x98eb4e4b31d6a,1 +np.float64,0x4507fb128a100,0x4507fb128a100,1 +np.float64,0xbfc77032e42ee064,0xbfc9e36ab747a14d,1 +np.float64,0xa1f8a03b43f14,0xa1f8a03b43f14,1 +np.float64,0xbfc3d4da8527a9b4,0xbfc58c27af2476b0,1 +np.float64,0x3fc0eb7d6921d6fb,0x3fbfc858a077ed61,1 +np.float64,0x7fddb2e9403b65d2,0x4086281e98443709,1 +np.float64,0xbfa7ea62942fd4c0,0xbfa87dfd06b05d2a,1 +np.float64,0xbfe7d5c5426fab8a,0xbff5daa969c6d9e5,1 +np.float64,0x3fbf7cba0c3ef974,0x3fbdb23cd8fe875b,1 +np.float64,0x7fe92021eb324043,0x40862c53aee8b154,1 +np.float64,0x7fefbaa1827f7542,0x40862e3194737072,1 +np.float64,0x3fc6f82c402df059,0x3fc520432cbc533f,1 +np.float64,0x7fb37679a826ecf2,0x408619a5f857e27f,1 +np.float64,0x79ec1528f3d83,0x79ec1528f3d83,1 +np.float64,0x3fbefe1d0c3dfc3a,0x3fbd41650ba2c893,1 +np.float64,0x3fc3e5e11827cbc2,0x3fc27eb9b47c9c42,1 +np.float64,0x16aed1922d5db,0x16aed1922d5db,1 +np.float64,0x800124f7e58249f1,0x800124f7e58249f1,1 +np.float64,0x8004f7d12489efa3,0x8004f7d12489efa3,1 +np.float64,0x3fef80b8e27f0172,0x3fe5ee5fd43322c6,1 +np.float64,0xbfe7740c88eee819,0xbff51f823c8da14d,1 +np.float64,0xbfe6e1f1f6edc3e4,0xbff416bcb1302e7c,1 +np.float64,0x8001a2c4a7e3458a,0x8001a2c4a7e3458a,1 +np.float64,0x3fe861e155f0c3c2,0x3fe2201d3000c329,1 +np.float64,0x3fd00a101a201420,0x3fcca01087dbd728,1 +np.float64,0x7fdf0eb1133e1d61,0x4086287a327839b8,1 +np.float64,0x95e3ffdb2bc80,0x95e3ffdb2bc80,1 +np.float64,0x3fd87a1e8230f43d,0x3fd4ba1eb9be1270,1 +np.float64,0x3fedc4792afb88f2,0x3fe50b6529080f73,1 +np.float64,0x7fc9e81fa833d03e,0x4086217b428cc6ff,1 +np.float64,0xbfd21f1ba5a43e38,0xbfd54e048b988e09,1 +np.float64,0xbfbf52af5a3ea560,0xbfc0b4ab3b81fafc,1 +np.float64,0x7fe475f8e268ebf1,0x40862aaf14fee029,1 +np.float64,0x3fcf56899f3ead10,0x3fcc081de28ae9cf,1 +np.float64,0x917d407122fa8,0x917d407122fa8,1 +np.float64,0x22e23e3245c49,0x22e23e3245c49,1 +np.float64,0xbfeec2814f3d8503,0xc00a00ecca27b426,1 +np.float64,0xbfd97fee1c32ffdc,0xbfe04351dfe306ec,1 diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/data/umath-validation-set-log2.csv b/venv/lib/python3.12/site-packages/numpy/_core/tests/data/umath-validation-set-log2.csv new file mode 100644 index 00000000..26921ef1 --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/tests/data/umath-validation-set-log2.csv @@ -0,0 +1,1629 @@ +dtype,input,output,ulperrortol +np.float32,0x80000000,0xff800000,3 +np.float32,0x7f12870a,0x42fe63db,3 +np.float32,0x3ef29cf5,0xbf89eb12,3 +np.float32,0x3d6ba8fb,0xc083d26c,3 +np.float32,0x3d9907e8,0xc06f8230,3 +np.float32,0x4ee592,0xc2fd656e,3 +np.float32,0x58d8b1,0xc2fd0db3,3 +np.float32,0x7ba103,0xc2fc19aa,3 +np.float32,0x7f52e90e,0x42ff70e4,3 +np.float32,0x7fcb15,0xc2fc0132,3 +np.float32,0x7cb7129f,0x42f50855,3 +np.float32,0x9faba,0xc301ae59,3 +np.float32,0x7f300a,0xc2fc04b4,3 +np.float32,0x3f0bf047,0xbf5f10cb,3 +np.float32,0x2fb1fb,0xc2fed934,3 +np.float32,0x3eedb0d1,0xbf8db417,3 +np.float32,0x3d7a0b40,0xc0811638,3 +np.float32,0x2e0bac,0xc2fef334,3 +np.float32,0x6278c1,0xc2fcc1b9,3 +np.float32,0x7f61ab2e,0x42ffa2d9,3 +np.float32,0x8fe7c,0xc301d4be,3 +np.float32,0x3f25e6ee,0xbf203536,3 +np.float32,0x7efc78f0,0x42fdf5c0,3 +np.float32,0x6d7304,0xc2fc73a7,3 +np.float32,0x7f1a472a,0x42fe89ed,3 +np.float32,0x7dd029a6,0x42f96734,3 +np.float32,0x3e9b9327,0xbfdbf8f7,3 +np.float32,0x3f4eefc1,0xbe9d2942,3 +np.float32,0x7f5b9b64,0x42ff8ebc,3 +np.float32,0x3e458ee1,0xc017ed6e,3 +np.float32,0x3f7b766b,0xbcd35acf,3 +np.float32,0x3e616070,0xc00bc378,3 +np.float32,0x7f20e633,0x42fea8f8,3 +np.float32,0x3ee3b461,0xbf95a126,3 +np.float32,0x7e7722ba,0x42fbe5f8,3 +np.float32,0x3f0873d7,0xbf6861fa,3 +np.float32,0x7b4cb2,0xc2fc1ba3,3 +np.float32,0x3f0b6b02,0xbf60712e,3 +np.float32,0x9bff4,0xc301b6f2,3 +np.float32,0x3f07be25,0xbf6a4f0c,3 +np.float32,0x3ef10e57,0xbf8b1b75,3 +np.float32,0x46ad75,0xc2fdb6b1,3 +np.float32,0x3f7bc542,0xbcc4e3a9,3 +np.float32,0x3f6673d4,0xbe1b509c,3 +np.float32,0x7f19fe59,0x42fe8890,3 +np.float32,0x7f800000,0x7f800000,3 +np.float32,0x7f2fe696,0x42feead0,3 +np.float32,0x3dc9432d,0xc0563655,3 +np.float32,0x3ee47623,0xbf950446,3 +np.float32,0x3f1f8817,0xbf2eab51,3 +np.float32,0x7f220ec5,0x42feae44,3 +np.float32,0x2325e3,0xc2ffbab1,3 +np.float32,0x29dfc8,0xc2ff395a,3 +np.float32,0x7f524950,0x42ff6eb3,3 +np.float32,0x3e2234e0,0xc02a21c8,3 +np.float32,0x7f1c6f5a,0x42fe942f,3 +np.float32,0x3b6a61,0xc2fe36e7,3 +np.float32,0x3f1df90e,0xbf324ba9,3 +np.float32,0xb57f0,0xc3017f07,3 +np.float32,0x7d0eba,0xc2fc112e,3 +np.float32,0x403aa9,0xc2fdfd5c,3 +np.float32,0x3e74ecc7,0xc004155f,3 +np.float32,0x17509c,0xc30074f2,3 +np.float32,0x7f62196b,0x42ffa442,3 +np.float32,0x3ecef9a9,0xbfa7417a,3 +np.float32,0x7f14b158,0x42fe6eb1,3 +np.float32,0x3ede12be,0xbf9a40fe,3 +np.float32,0x42cfaa,0xc2fde03f,3 +np.float32,0x3f407b0f,0xbed2a6f5,3 +np.float32,0x7f7fffff,0x43000000,3 +np.float32,0x5467c6,0xc2fd3394,3 +np.float32,0x7ea6b80f,0x42fcc336,3 +np.float32,0x3f21e7b2,0xbf293704,3 +np.float32,0x3dc7e9eb,0xc056d542,3 +np.float32,0x7f3e6e67,0x42ff2571,3 +np.float32,0x3e3e809d,0xc01b4911,3 +np.float32,0x3f800000,0x0,3 +np.float32,0x3d8fd238,0xc0753d52,3 +np.float32,0x3f74aa65,0xbd85cd0e,3 +np.float32,0x7ec30305,0x42fd36ff,3 +np.float32,0x3e97bb93,0xbfe0971d,3 +np.float32,0x3e109d9c,0xc034bb1b,3 +np.float32,0x3f4a0b67,0xbeaed537,3 +np.float32,0x3f25a7aa,0xbf20c228,3 +np.float32,0x3ebc05eb,0xbfb8fd6b,3 +np.float32,0x3eebe749,0xbf8f18e5,3 +np.float32,0x3e9dc479,0xbfd96356,3 +np.float32,0x7f245200,0x42feb882,3 +np.float32,0x1573a8,0xc30093b5,3 +np.float32,0x3e66c4b9,0xc00994a6,3 +np.float32,0x3e73bffc,0xc0048709,3 +np.float32,0x3dfef8e5,0xc0405f16,3 +np.float32,0x403750,0xc2fdfd83,3 +np.float32,0x3ebedf17,0xbfb636a4,3 +np.float32,0x15cae6,0xc3008de2,3 +np.float32,0x3edf4d4e,0xbf993c24,3 +np.float32,0x3f7cc41e,0xbc963fb3,3 +np.float32,0x3e9e12a4,0xbfd907ee,3 +np.float32,0x7ded7b59,0x42f9c889,3 +np.float32,0x7f034878,0x42fe12b5,3 +np.float32,0x7ddce43f,0x42f9930b,3 +np.float32,0x3d82b257,0xc07e1333,3 +np.float32,0x3dae89c1,0xc0635dd4,3 +np.float32,0x6b1d00,0xc2fc8396,3 +np.float32,0x449a5a,0xc2fdccb3,3 +np.float32,0x4e89d2,0xc2fd68cb,3 +np.float32,0x7e1ae83f,0x42fa8cef,3 +np.float32,0x7e4bb22c,0x42fb572e,3 +np.float32,0x3de308ea,0xc04b1634,3 +np.float32,0x7f238c7a,0x42feb508,3 +np.float32,0x3f6c62a3,0xbdeb86f3,3 +np.float32,0x3e58cba6,0xc00f5908,3 +np.float32,0x7f7dd91f,0x42fff9c4,3 +np.float32,0x3d989376,0xc06fc88d,3 +np.float32,0x3dd013c5,0xc0532339,3 +np.float32,0x4b17e6,0xc2fd89ed,3 +np.float32,0x7f67f287,0x42ffb71e,3 +np.float32,0x3f69365e,0xbe09ba3c,3 +np.float32,0x3e4b8b21,0xc0152bf1,3 +np.float32,0x3a75b,0xc3032171,3 +np.float32,0x7f303676,0x42feec1f,3 +np.float32,0x7f6570e5,0x42ffaf18,3 +np.float32,0x3f5ed61e,0xbe4cf676,3 +np.float32,0x3e9b22f9,0xbfdc7e4f,3 +np.float32,0x2c095e,0xc2ff1428,3 +np.float32,0x3f1b17c1,0xbf391754,3 +np.float32,0x422dc6,0xc2fde746,3 +np.float32,0x3f677c8d,0xbe14b365,3 +np.float32,0x3ef85d0c,0xbf8597a9,3 +np.float32,0x3ecaaa6b,0xbfab2430,3 +np.float32,0x3f0607d1,0xbf6eff3d,3 +np.float32,0x3f011fdb,0xbf7cc50d,3 +np.float32,0x6ed7c1,0xc2fc6a4e,3 +np.float32,0x7ec2d1a2,0x42fd3644,3 +np.float32,0x3f75b7fe,0xbd7238a2,3 +np.float32,0x3ef2d146,0xbf89c344,3 +np.float32,0x7ec2cd27,0x42fd3633,3 +np.float32,0x7ee1e55a,0x42fda397,3 +np.float32,0x7f464d6a,0x42ff435c,3 +np.float32,0x7f469a93,0x42ff447b,3 +np.float32,0x7ece752f,0x42fd6121,3 +np.float32,0x2ed878,0xc2fee67b,3 +np.float32,0x75b23,0xc3021eff,3 +np.float32,0x3e0f4be4,0xc03593b8,3 +np.float32,0x2778e1,0xc2ff64fc,3 +np.float32,0x5fe2b7,0xc2fcd561,3 +np.float32,0x19b8a9,0xc30050ab,3 +np.float32,0x7df303e5,0x42f9d98d,3 +np.float32,0x608b8d,0xc2fcd051,3 +np.float32,0x588f46,0xc2fd1017,3 +np.float32,0x3eec6a11,0xbf8eb2a1,3 +np.float32,0x3f714121,0xbdaf4906,3 +np.float32,0x7f4f7b9e,0x42ff64c9,3 +np.float32,0x3c271606,0xc0d3b29c,3 +np.float32,0x3f002fe0,0xbf7f75f6,3 +np.float32,0x7efa4798,0x42fdef4f,3 +np.float32,0x3f61a865,0xbe3a601a,3 +np.float32,0x7e8087aa,0x42fc030d,3 +np.float32,0x3f70f0c7,0xbdb321ba,3 +np.float32,0x5db898,0xc2fce63f,3 +np.float32,0x7a965f,0xc2fc1fea,3 +np.float32,0x7f68b112,0x42ffb97c,3 +np.float32,0x7ef0ed3d,0x42fdd32d,3 +np.float32,0x7f3156a1,0x42fef0d3,3 +np.float32,0x3f1d405f,0xbf33fc6e,3 +np.float32,0x3e3494cf,0xc0203945,3 +np.float32,0x6018de,0xc2fcd3c1,3 +np.float32,0x623e49,0xc2fcc370,3 +np.float32,0x3ea29f0f,0xbfd3cad4,3 +np.float32,0xa514,0xc305a20c,3 +np.float32,0x3e1b2ab1,0xc02e3a8f,3 +np.float32,0x3f450b6f,0xbec1578f,3 +np.float32,0x7eb12908,0x42fcf015,3 +np.float32,0x3f10b720,0xbf52ab48,3 +np.float32,0x3e0a93,0xc2fe16f6,3 +np.float32,0x93845,0xc301cb96,3 +np.float32,0x7f4e9ce3,0x42ff61af,3 +np.float32,0x3f6d4296,0xbde09ceb,3 +np.float32,0x6ddede,0xc2fc70d0,3 +np.float32,0x3f4fb6fd,0xbe9a636d,3 +np.float32,0x3f6d08de,0xbde36c0b,3 +np.float32,0x3f56f057,0xbe8122ad,3 +np.float32,0x334e95,0xc2fea349,3 +np.float32,0x7efadbcd,0x42fdf104,3 +np.float32,0x3db02e88,0xc0628046,3 +np.float32,0x3f3309d1,0xbf041066,3 +np.float32,0x2d8722,0xc2fefb8f,3 +np.float32,0x7e926cac,0x42fc6356,3 +np.float32,0x3e3674ab,0xc01f452e,3 +np.float32,0x1b46ce,0xc3003afc,3 +np.float32,0x3f06a338,0xbf6d53fc,3 +np.float32,0x1b1ba7,0xc3003d46,3 +np.float32,0x319dfb,0xc2febc06,3 +np.float32,0x3e2f126a,0xc02315a5,3 +np.float32,0x3f40fe65,0xbed0af9e,3 +np.float32,0x3f1d842f,0xbf335d4b,3 +np.float32,0x3d044e4f,0xc09e78f8,3 +np.float32,0x7f272674,0x42fec51f,3 +np.float32,0x3cda6d8f,0xc0a753db,3 +np.float32,0x3eb92f12,0xbfbbccbb,3 +np.float32,0x7e4318f4,0x42fb3752,3 +np.float32,0x3c5890,0xc2fe2b6d,3 +np.float32,0x3d1993c9,0xc09796f8,3 +np.float32,0x7f18ef24,0x42fe8377,3 +np.float32,0x3e30c3a0,0xc0223244,3 +np.float32,0x3f27cd27,0xbf1c00ef,3 +np.float32,0x3f150957,0xbf47cd6c,3 +np.float32,0x7e7178a3,0x42fbd4d8,3 +np.float32,0x3f298db8,0xbf182ac3,3 +np.float32,0x7cb3be,0xc2fc1348,3 +np.float32,0x3ef64266,0xbf8729de,3 +np.float32,0x3eeb06ce,0xbf8fc8f2,3 +np.float32,0x3f406e36,0xbed2d845,3 +np.float32,0x7f1e1bd3,0x42fe9c0b,3 +np.float32,0x478dcc,0xc2fdad97,3 +np.float32,0x7f7937b5,0x42ffec2b,3 +np.float32,0x3f20f350,0xbf2b6624,3 +np.float32,0x7f13661a,0x42fe683c,3 +np.float32,0x208177,0xc2fff46b,3 +np.float32,0x263cfb,0xc2ff7c72,3 +np.float32,0x7f0bd28c,0x42fe4141,3 +np.float32,0x7230d8,0xc2fc5453,3 +np.float32,0x3f261bbf,0xbf1fbfb4,3 +np.float32,0x737b56,0xc2fc4c05,3 +np.float32,0x3ef88f33,0xbf857263,3 +np.float32,0x7e036464,0x42fa1352,3 +np.float32,0x4b5c4f,0xc2fd874d,3 +np.float32,0x3f77984d,0xbd454596,3 +np.float32,0x3f674202,0xbe162932,3 +np.float32,0x3e7157d9,0xc0057197,3 +np.float32,0x3f3f21da,0xbed7d861,3 +np.float32,0x7f1fb40f,0x42fea375,3 +np.float32,0x7ef0157f,0x42fdd096,3 +np.float32,0x3f71e88d,0xbda74962,3 +np.float32,0x3f174855,0xbf424728,3 +np.float32,0x3f3fdd2c,0xbed505d5,3 +np.float32,0x7b95d1,0xc2fc19ed,3 +np.float32,0x7f23f4e5,0x42feb6df,3 +np.float32,0x7d741925,0x42f7dcd6,3 +np.float32,0x60f81d,0xc2fccd14,3 +np.float32,0x3f17d267,0xbf40f6ae,3 +np.float32,0x3f036fc8,0xbf7636f8,3 +np.float32,0x167653,0xc30082b5,3 +np.float32,0x256d05,0xc2ff8c4f,3 +np.float32,0x3eccc63d,0xbfa93adb,3 +np.float32,0x7f6c91ea,0x42ffc5b2,3 +np.float32,0x2ee52a,0xc2fee5b3,3 +np.float32,0x3dc3579e,0xc058f80d,3 +np.float32,0x4c7170,0xc2fd7cc4,3 +np.float32,0x7f737f20,0x42ffdb03,3 +np.float32,0x3f2f9dbf,0xbf0b3119,3 +np.float32,0x3f4d0c54,0xbea3eec5,3 +np.float32,0x7e380862,0x42fb0c32,3 +np.float32,0x5d637f,0xc2fce8df,3 +np.float32,0x3f0aa623,0xbf627c27,3 +np.float32,0x3e4d5896,0xc0145b88,3 +np.float32,0x3f6cacdc,0xbde7e7ca,3 +np.float32,0x63a2c3,0xc2fcb90a,3 +np.float32,0x6c138c,0xc2fc7cfa,3 +np.float32,0x2063c,0xc303fb88,3 +np.float32,0x7e9e5a3e,0x42fc9d2f,3 +np.float32,0x56ec64,0xc2fd1ddd,3 +np.float32,0x7f1d6a35,0x42fe98cc,3 +np.float32,0x73dc96,0xc2fc4998,3 +np.float32,0x3e5d74e5,0xc00d6238,3 +np.float32,0x7f033cbb,0x42fe1273,3 +np.float32,0x3f5143fc,0xbe94e4e7,3 +np.float32,0x1d56d9,0xc3002010,3 +np.float32,0x2bf3e4,0xc2ff1591,3 +np.float32,0x3f2a6ef1,0xbf164170,3 +np.float32,0x3f33238b,0xbf03db58,3 +np.float32,0x22780e,0xc2ffc91a,3 +np.float32,0x7f00b873,0x42fe0425,3 +np.float32,0x3f7f6145,0xbb654706,3 +np.float32,0x7fc00000,0x7fc00000,3 +np.float32,0x63895a,0xc2fcb9c7,3 +np.float32,0x18a1b2,0xc30060a8,3 +np.float32,0x7e43c6a6,0x42fb39e3,3 +np.float32,0x78676e,0xc2fc2d30,3 +np.float32,0x3f16d839,0xbf435940,3 +np.float32,0x7eff78ba,0x42fdfe79,3 +np.float32,0x3f2e152c,0xbf0e6e54,3 +np.float32,0x3db20ced,0xc06186e1,3 +np.float32,0x3f0cd1d8,0xbf5cbf57,3 +np.float32,0x3fd7a8,0xc2fe01d2,3 +np.float32,0x3ebb075e,0xbfb9f816,3 +np.float32,0x7f94ef,0xc2fc026b,3 +np.float32,0x3d80ba0e,0xc07f7a2b,3 +np.float32,0x7f227e15,0x42feb03f,3 +np.float32,0x792264bf,0x42e6afcc,3 +np.float32,0x7f501576,0x42ff66ec,3 +np.float32,0x223629,0xc2ffcea3,3 +np.float32,0x40a79e,0xc2fdf87b,3 +np.float32,0x449483,0xc2fdccf2,3 +np.float32,0x3f4fa978,0xbe9a9382,3 +np.float32,0x7f148c53,0x42fe6df9,3 +np.float32,0x3ec98b3c,0xbfac2a98,3 +np.float32,0x3e4da320,0xc0143a0a,3 +np.float32,0x3d1d94bb,0xc09666d0,3 +np.float32,0x3c8e624e,0xc0bb155b,3 +np.float32,0x66a9af,0xc2fca2ef,3 +np.float32,0x3ec76ed7,0xbfae1c57,3 +np.float32,0x3f4b52f3,0xbeaa2b81,3 +np.float32,0x7e99bbb5,0x42fc8750,3 +np.float32,0x3f69a46b,0xbe0701be,3 +np.float32,0x3f775400,0xbd4ba495,3 +np.float32,0x131e56,0xc300be3c,3 +np.float32,0x3f30abb4,0xbf08fb10,3 +np.float32,0x7f7e528c,0x42fffb25,3 +np.float32,0x3eb89515,0xbfbc668a,3 +np.float32,0x7e9191b6,0x42fc5f02,3 +np.float32,0x7e80c7e9,0x42fc047e,3 +np.float32,0x3f77ef58,0xbd3d2995,3 +np.float32,0x7ddb1f8a,0x42f98d1b,3 +np.float32,0x7ebc6c4f,0x42fd1d9c,3 +np.float32,0x3f6638e0,0xbe1ccab8,3 +np.float32,0x7f4c45,0xc2fc0410,3 +np.float32,0x3e7d8aad,0xc000e414,3 +np.float32,0x3f4d148b,0xbea3d12e,3 +np.float32,0x3e98c45c,0xbfdf55f4,3 +np.float32,0x3d754c78,0xc081f8a9,3 +np.float32,0x17e4cf,0xc3006be3,3 +np.float32,0x7eb65814,0x42fd0563,3 +np.float32,0x3f65e0d8,0xbe1f0008,3 +np.float32,0x3e99541f,0xbfdea87e,3 +np.float32,0x3f3cb80e,0xbee13b27,3 +np.float32,0x3e99f0c0,0xbfddec3b,3 +np.float32,0x3f43903e,0xbec6ea66,3 +np.float32,0x7e211cd4,0x42faa9f2,3 +np.float32,0x824af,0xc301f971,3 +np.float32,0x3e16a56e,0xc030f56c,3 +np.float32,0x542b3b,0xc2fd35a6,3 +np.float32,0x3eeea2d1,0xbf8cf873,3 +np.float32,0x232e93,0xc2ffb9fa,3 +np.float32,0x3e8c52b9,0xbfef06aa,3 +np.float32,0x7f69c7e3,0x42ffbcef,3 +np.float32,0x3f573e43,0xbe801714,3 +np.float32,0x43b009,0xc2fdd69f,3 +np.float32,0x3ee571ab,0xbf943966,3 +np.float32,0x3ee3d5d8,0xbf958604,3 +np.float32,0x338b12,0xc2fe9fe4,3 +np.float32,0x29cb1f,0xc2ff3ac6,3 +np.float32,0x3f0892b4,0xbf680e7a,3 +np.float32,0x3e8c4f7f,0xbfef0ae9,3 +np.float32,0x7c9d3963,0x42f497e6,3 +np.float32,0x3f26ba84,0xbf1e5f59,3 +np.float32,0x3dd0acc0,0xc052df6f,3 +np.float32,0x3e43fbda,0xc018aa8c,3 +np.float32,0x3ec4fd0f,0xbfb0635d,3 +np.float32,0x3f52c8c6,0xbe8f8d85,3 +np.float32,0x3f5fdc5d,0xbe462fdb,3 +np.float32,0x3f461920,0xbebd6743,3 +np.float32,0x6161ff,0xc2fcc9ef,3 +np.float32,0x7f7ed306,0x42fffc9a,3 +np.float32,0x3d212263,0xc0955f46,3 +np.float32,0x3eca5826,0xbfab6f36,3 +np.float32,0x7d6317ac,0x42f7a77e,3 +np.float32,0x3eb02063,0xbfc50f60,3 +np.float32,0x7f71a6f8,0x42ffd565,3 +np.float32,0x1a3efe,0xc3004935,3 +np.float32,0x3dc599c9,0xc057e856,3 +np.float32,0x3f3e1301,0xbedbf205,3 +np.float32,0xf17d4,0xc301158d,3 +np.float32,0x3f615f84,0xbe3c3d85,3 +np.float32,0x3de63be1,0xc049cb77,3 +np.float32,0x3e8d2f51,0xbfede541,3 +np.float32,0x3a5cdd,0xc2fe441c,3 +np.float32,0x3f443ec0,0xbec4586a,3 +np.float32,0x3eacbd00,0xbfc8a5ad,3 +np.float32,0x3f600f6a,0xbe44df1b,3 +np.float32,0x5f77a6,0xc2fcd89c,3 +np.float32,0x476706,0xc2fdaf28,3 +np.float32,0x2f469,0xc3036fde,3 +np.float32,0x7dc4ba24,0x42f93d77,3 +np.float32,0x3e2d6080,0xc023fb9b,3 +np.float32,0x7e8d7135,0x42fc49c3,3 +np.float32,0x3f589065,0xbe77247b,3 +np.float32,0x3f59e210,0xbe6e2c05,3 +np.float32,0x7f51d388,0x42ff6d15,3 +np.float32,0x7d9a5fda,0x42f88a63,3 +np.float32,0x3e67d5bc,0xc00927ab,3 +np.float32,0x61d72c,0xc2fcc679,3 +np.float32,0x3ef3351d,0xbf897766,3 +np.float32,0x1,0xc3150000,3 +np.float32,0x7f653429,0x42ffae54,3 +np.float32,0x7e1ad3e5,0x42fa8c8e,3 +np.float32,0x3f4ca01d,0xbea57500,3 +np.float32,0x3f7606db,0xbd6ad13e,3 +np.float32,0x7ec4a27d,0x42fd3d1f,3 +np.float32,0x3efe4fd5,0xbf8138c7,3 +np.float32,0x77c2f1,0xc2fc3124,3 +np.float32,0x7e4d3251,0x42fb5c9a,3 +np.float32,0x3f543ac7,0xbe8a8154,3 +np.float32,0x7c3dbe29,0x42f322c4,3 +np.float32,0x408e01,0xc2fdf9a0,3 +np.float32,0x45069b,0xc2fdc829,3 +np.float32,0x3d7ecab7,0xc08037e8,3 +np.float32,0xf8c22,0xc3010a99,3 +np.float32,0x7f69af63,0x42ffbca2,3 +np.float32,0x7ec7d228,0x42fd48fe,3 +np.float32,0xff800000,0xffc00000,3 +np.float32,0xdd7c5,0xc301357c,3 +np.float32,0x143f38,0xc300a90e,3 +np.float32,0x7e65c176,0x42fbb01b,3 +np.float32,0x2c1a9e,0xc2ff1307,3 +np.float32,0x7f6e9224,0x42ffcbeb,3 +np.float32,0x3d32ab39,0xc0909a77,3 +np.float32,0x3e150b42,0xc031f22b,3 +np.float32,0x1f84b4,0xc300059a,3 +np.float32,0x3f71ce21,0xbda88c2a,3 +np.float32,0x2625c4,0xc2ff7e33,3 +np.float32,0x3dd0b293,0xc052dcdc,3 +np.float32,0x625c11,0xc2fcc290,3 +np.float32,0x3f610297,0xbe3e9f24,3 +np.float32,0x7ebdd5e5,0x42fd2320,3 +np.float32,0x3e883458,0xbff486ff,3 +np.float32,0x782313,0xc2fc2ed4,3 +np.float32,0x7f39c843,0x42ff132f,3 +np.float32,0x7f326aa7,0x42fef54d,3 +np.float32,0x4d2c71,0xc2fd75be,3 +np.float32,0x3f55747c,0xbe86409e,3 +np.float32,0x7f7f0867,0x42fffd34,3 +np.float32,0x321316,0xc2feb53f,3 +np.float32,0x3e1b37ed,0xc02e32b0,3 +np.float32,0x80edf,0xc301fd54,3 +np.float32,0x3f0b08ad,0xbf617607,3 +np.float32,0x7f3f4174,0x42ff28a2,3 +np.float32,0x3d79306d,0xc0813eb0,3 +np.float32,0x3f5f657a,0xbe49413d,3 +np.float32,0x3f56c63a,0xbe81b376,3 +np.float32,0x7f667123,0x42ffb24f,3 +np.float32,0x3f71021b,0xbdb24d43,3 +np.float32,0x7f434ab1,0x42ff380f,3 +np.float32,0x3dcae496,0xc055779c,3 +np.float32,0x3f5a7d88,0xbe6a0f5b,3 +np.float32,0x3cdf5c32,0xc0a64bf5,3 +np.float32,0x3e56222c,0xc0107d11,3 +np.float32,0x561a3a,0xc2fd24df,3 +np.float32,0x7ddd953c,0x42f9955a,3 +np.float32,0x7e35d839,0x42fb035c,3 +np.float32,0x3ec1816c,0xbfb3aeb2,3 +np.float32,0x7c87cfcd,0x42f42bc2,3 +np.float32,0xd9cd,0xc3053baf,3 +np.float32,0x3f388234,0xbef1e5b7,3 +np.float32,0x3edfcaca,0xbf98d47b,3 +np.float32,0x3ef28852,0xbf89fac8,3 +np.float32,0x7f7525df,0x42ffe001,3 +np.float32,0x7f6c33ef,0x42ffc48c,3 +np.float32,0x3ea4a881,0xbfd17e61,3 +np.float32,0x3f3e379f,0xbedb63c6,3 +np.float32,0x3f0524c1,0xbf717301,3 +np.float32,0x3db3e7f0,0xc06091d3,3 +np.float32,0x800000,0xc2fc0000,3 +np.float32,0x3f2f2897,0xbf0c27ce,3 +np.float32,0x7eb1776d,0x42fcf15c,3 +np.float32,0x3f039018,0xbf75dc37,3 +np.float32,0x3c4055,0xc2fe2c96,3 +np.float32,0x3f603653,0xbe43dea5,3 +np.float32,0x7f700d24,0x42ffd07c,3 +np.float32,0x3f4741a3,0xbeb918dc,3 +np.float32,0x3f5fe959,0xbe45da2d,3 +np.float32,0x3f3e4401,0xbedb33b1,3 +np.float32,0x7f0705ff,0x42fe2775,3 +np.float32,0x3ea85662,0xbfcd69b0,3 +np.float32,0x3f15f49f,0xbf458829,3 +np.float32,0x3f17c50e,0xbf411728,3 +np.float32,0x3e483f60,0xc016add2,3 +np.float32,0x3f1ab9e5,0xbf39f71b,3 +np.float32,0x3de0b6fb,0xc04c08fe,3 +np.float32,0x7e671225,0x42fbb452,3 +np.float32,0x80800000,0xffc00000,3 +np.float32,0xe2df3,0xc3012c9d,3 +np.float32,0x3ede1e3c,0xbf9a3770,3 +np.float32,0x3df2ffde,0xc044cfec,3 +np.float32,0x3eed8da5,0xbf8dcf6c,3 +np.float32,0x3ead15c3,0xbfc846e1,3 +np.float32,0x7ef3750a,0x42fddae4,3 +np.float32,0x7e6ab7c0,0x42fbbfe4,3 +np.float32,0x7ea4bbe5,0x42fcba5d,3 +np.float32,0x3f227706,0xbf27f0a1,3 +np.float32,0x3ef39bfd,0xbf89295a,3 +np.float32,0x3f289a20,0xbf1a3edd,3 +np.float32,0x7f225f82,0x42feafb4,3 +np.float32,0x768963,0xc2fc38bc,3 +np.float32,0x3f493c00,0xbeb1ccfc,3 +np.float32,0x3f4e7249,0xbe9ee9a7,3 +np.float32,0x1d0c3a,0xc30023c0,3 +np.float32,0x7f3c5f78,0x42ff1d6a,3 +np.float32,0xff7fffff,0xffc00000,3 +np.float32,0x3ee7896a,0xbf928c2a,3 +np.float32,0x3e788479,0xc002bd2e,3 +np.float32,0x3ee4df17,0xbf94af84,3 +np.float32,0x5e06d7,0xc2fce3d7,3 +np.float32,0x3d7b2776,0xc080e1dc,3 +np.float32,0x3e3d39d3,0xc01be7fd,3 +np.float32,0x7c81dece,0x42f40ab7,3 +np.float32,0x3f7d2085,0xbc856255,3 +np.float32,0x7f7f6627,0x42fffe44,3 +np.float32,0x7f5f2e94,0x42ff9aaa,3 +np.float32,0x7f5835f2,0x42ff8339,3 +np.float32,0x3f6a0e32,0xbe046580,3 +np.float32,0x7e16f586,0x42fa79dd,3 +np.float32,0x3f04a2f2,0xbf72dbc5,3 +np.float32,0x3f35e334,0xbefc7740,3 +np.float32,0x3f0d056e,0xbf5c3824,3 +np.float32,0x7ebeb95e,0x42fd2693,3 +np.float32,0x3c6192,0xc2fe2aff,3 +np.float32,0x3e892b4f,0xbff33958,3 +np.float32,0x3f61d694,0xbe3931df,3 +np.float32,0x29d183,0xc2ff3a56,3 +np.float32,0x7f0b0598,0x42fe3d04,3 +np.float32,0x7f743b28,0x42ffdd3d,3 +np.float32,0x3a2ed6,0xc2fe4663,3 +np.float32,0x3e27403a,0xc0274de8,3 +np.float32,0x3f58ee78,0xbe74a349,3 +np.float32,0x3eaa4b,0xc2fe0f92,3 +np.float32,0x3ecb613b,0xbfaa7de8,3 +np.float32,0x7f637d81,0x42ffa8c9,3 +np.float32,0x3f026e96,0xbf790c73,3 +np.float32,0x386cdf,0xc2fe5d0c,3 +np.float32,0x35abd1,0xc2fe8202,3 +np.float32,0x3eac3cd1,0xbfc92ee8,3 +np.float32,0x3f567869,0xbe82bf47,3 +np.float32,0x3f65c643,0xbe1faae6,3 +np.float32,0x7f5422b9,0x42ff752b,3 +np.float32,0x7c26e9,0xc2fc168c,3 +np.float32,0x7eff5cfd,0x42fdfe29,3 +np.float32,0x3f728e7f,0xbd9f6142,3 +np.float32,0x3f10fd43,0xbf51f874,3 +np.float32,0x7e7ada08,0x42fbf0fe,3 +np.float32,0x3e82a611,0xbffc37be,3 +np.float32,0xbf800000,0xffc00000,3 +np.float32,0x3dbe2e12,0xc05b711c,3 +np.float32,0x7e768fa9,0x42fbe440,3 +np.float32,0x5e44e8,0xc2fce1f0,3 +np.float32,0x7f25071a,0x42febbae,3 +np.float32,0x3f54db5e,0xbe885339,3 +np.float32,0x3f0f2c26,0xbf56a0b8,3 +np.float32,0x22f9a7,0xc2ffbe55,3 +np.float32,0x7ed63dcb,0x42fd7c77,3 +np.float32,0x7ea4fae2,0x42fcbb78,3 +np.float32,0x3f1d7766,0xbf337b47,3 +np.float32,0x7f16d59f,0x42fe7941,3 +np.float32,0x3f3a1bb6,0xbeeb855c,3 +np.float32,0x3ef57128,0xbf87c709,3 +np.float32,0xb24ff,0xc3018591,3 +np.float32,0x3ef99e27,0xbf84a983,3 +np.float32,0x3eac2ccf,0xbfc94013,3 +np.float32,0x3e9d3e1e,0xbfda00dc,3 +np.float32,0x718213,0xc2fc58c1,3 +np.float32,0x7edbf509,0x42fd8fea,3 +np.float32,0x70c7f1,0xc2fc5d80,3 +np.float32,0x3f7012f5,0xbdbdc6cd,3 +np.float32,0x12cba,0xc304c487,3 +np.float32,0x7f5d445d,0x42ff944c,3 +np.float32,0x7f3e30bd,0x42ff2481,3 +np.float32,0x63b110,0xc2fcb8a0,3 +np.float32,0x3f39f728,0xbeec1680,3 +np.float32,0x3f5bea58,0xbe6074b1,3 +np.float32,0x3f350749,0xbefff679,3 +np.float32,0x3e91ab2c,0xbfe81f3e,3 +np.float32,0x7ec53fe0,0x42fd3f6d,3 +np.float32,0x3f6cbbdc,0xbde72c8e,3 +np.float32,0x3f4df49f,0xbea0abcf,3 +np.float32,0x3e9c9638,0xbfdac674,3 +np.float32,0x7f3b82ec,0x42ff1a07,3 +np.float32,0x7f612a09,0x42ffa132,3 +np.float32,0x7ea26650,0x42fcafd3,3 +np.float32,0x3a615138,0xc122f26d,3 +np.float32,0x3f1108bd,0xbf51db39,3 +np.float32,0x6f80f6,0xc2fc65ea,3 +np.float32,0x3f7cb578,0xbc98ecb1,3 +np.float32,0x7f54d31a,0x42ff7790,3 +np.float32,0x196868,0xc3005532,3 +np.float32,0x3f01ee0a,0xbf7a7925,3 +np.float32,0x3e184013,0xc02ffb11,3 +np.float32,0xadde3,0xc3018ee3,3 +np.float32,0x252a91,0xc2ff9173,3 +np.float32,0x3f0382c2,0xbf7601a9,3 +np.float32,0x6d818c,0xc2fc7345,3 +np.float32,0x3bfbfd,0xc2fe2fdd,3 +np.float32,0x7f3cad19,0x42ff1e9a,3 +np.float32,0x4169a7,0xc2fdefdf,3 +np.float32,0x3f615d96,0xbe3c4a2b,3 +np.float32,0x3f036480,0xbf7656ac,3 +np.float32,0x7f5fbda3,0x42ff9c83,3 +np.float32,0x3d202d,0xc2fe21f1,3 +np.float32,0x3d0f5e5d,0xc09ac3e9,3 +np.float32,0x3f0fff6e,0xbf548142,3 +np.float32,0x7f11ed32,0x42fe60d2,3 +np.float32,0x3e6f856b,0xc00624b6,3 +np.float32,0x7f7c4dd7,0x42fff542,3 +np.float32,0x3e76fb86,0xc0034fa0,3 +np.float32,0x3e8a0d6e,0xbff209e7,3 +np.float32,0x3eacad19,0xbfc8b6ad,3 +np.float32,0xa7776,0xc3019cbe,3 +np.float32,0x3dc84d74,0xc056a754,3 +np.float32,0x3efb8052,0xbf834626,3 +np.float32,0x3f0e55fc,0xbf58cacc,3 +np.float32,0x7e0e71e3,0x42fa4efb,3 +np.float32,0x3ed5a800,0xbfa1639c,3 +np.float32,0x3f33335b,0xbf03babf,3 +np.float32,0x38cad7,0xc2fe5842,3 +np.float32,0x3bc21256,0xc0ecc927,3 +np.float32,0x3f09522d,0xbf660a19,3 +np.float32,0xcbd5d,0xc3015428,3 +np.float32,0x492752,0xc2fd9d42,3 +np.float32,0x3f2b9b32,0xbf13b904,3 +np.float32,0x6544ac,0xc2fcad09,3 +np.float32,0x52eb12,0xc2fd40b5,3 +np.float32,0x3f66a7c0,0xbe1a03e8,3 +np.float32,0x7ab289,0xc2fc1f41,3 +np.float32,0x62af5e,0xc2fcc020,3 +np.float32,0x7f73e9cf,0x42ffdc46,3 +np.float32,0x3e5eca,0xc2fe130e,3 +np.float32,0x3e3a10f4,0xc01d7602,3 +np.float32,0x3f04db46,0xbf723f0d,3 +np.float32,0x18fc4a,0xc3005b63,3 +np.float32,0x525bcb,0xc2fd45b6,3 +np.float32,0x3f6b9108,0xbdf5c769,3 +np.float32,0x3e992e8c,0xbfded5c5,3 +np.float32,0x7efea647,0x42fdfc18,3 +np.float32,0x7e8371db,0x42fc139e,3 +np.float32,0x3f397cfb,0xbeedfc69,3 +np.float32,0x7e46d233,0x42fb454a,3 +np.float32,0x7d5281ad,0x42f76f79,3 +np.float32,0x7f4c1878,0x42ff58a1,3 +np.float32,0x3e96ca5e,0xbfe1bd97,3 +np.float32,0x6a2743,0xc2fc8a3d,3 +np.float32,0x7f688781,0x42ffb8f8,3 +np.float32,0x7814b7,0xc2fc2f2d,3 +np.float32,0x3f2ffdc9,0xbf0a6756,3 +np.float32,0x3f766fa8,0xbd60fe24,3 +np.float32,0x4dc64e,0xc2fd7003,3 +np.float32,0x3a296f,0xc2fe46a8,3 +np.float32,0x3f2af942,0xbf15162e,3 +np.float32,0x7f702c32,0x42ffd0dc,3 +np.float32,0x7e61e318,0x42fba390,3 +np.float32,0x7f7d3bdb,0x42fff7fa,3 +np.float32,0x3ee87f3f,0xbf91c881,3 +np.float32,0x2bbc28,0xc2ff193c,3 +np.float32,0x3e01f918,0xc03e966e,3 +np.float32,0x7f0b39f4,0x42fe3e1a,3 +np.float32,0x3eaa4d64,0xbfcb4516,3 +np.float32,0x3e53901e,0xc0119a88,3 +np.float32,0x603cb,0xc3026957,3 +np.float32,0x7e81f926,0x42fc0b4d,3 +np.float32,0x5dab7c,0xc2fce6a6,3 +np.float32,0x3f46fefd,0xbeba1018,3 +np.float32,0x648448,0xc2fcb28a,3 +np.float32,0x3ec49470,0xbfb0c58b,3 +np.float32,0x3e8a5393,0xbff1ac2b,3 +np.float32,0x3f27ccfc,0xbf1c014e,3 +np.float32,0x3ed886e6,0xbf9eeca8,3 +np.float32,0x7cfbe06e,0x42f5f401,3 +np.float32,0x3f5aa7ba,0xbe68f229,3 +np.float32,0x9500d,0xc301c7e3,3 +np.float32,0x3f4861,0xc2fe0853,3 +np.float32,0x3e5ae104,0xc00e76f5,3 +np.float32,0x71253a,0xc2fc5b1e,3 +np.float32,0xcf7b8,0xc3014d9c,3 +np.float32,0x7f7edd2d,0x42fffcb7,3 +np.float32,0x3e9039ee,0xbfe9f5ab,3 +np.float32,0x2fd54e,0xc2fed712,3 +np.float32,0x3f600752,0xbe45147a,3 +np.float32,0x3f4da8f6,0xbea1bb5c,3 +np.float32,0x3f2d34a9,0xbf104bd9,3 +np.float32,0x3e1e66dd,0xc02c52d2,3 +np.float32,0x798276,0xc2fc2670,3 +np.float32,0xd55e2,0xc3014347,3 +np.float32,0x80000001,0xffc00000,3 +np.float32,0x3e7a5ead,0xc0020da6,3 +np.float32,0x7ec4c744,0x42fd3da9,3 +np.float32,0x597e00,0xc2fd085a,3 +np.float32,0x3dff6bf4,0xc0403575,3 +np.float32,0x5d6f1a,0xc2fce883,3 +np.float32,0x7e21faff,0x42faadea,3 +np.float32,0x3e570fea,0xc01016c6,3 +np.float32,0x28e6b6,0xc2ff4ab7,3 +np.float32,0x7e77062d,0x42fbe5a3,3 +np.float32,0x74cac4,0xc2fc43b0,3 +np.float32,0x3f707273,0xbdb93078,3 +np.float32,0x228e96,0xc2ffc737,3 +np.float32,0x686ac1,0xc2fc966b,3 +np.float32,0x3d76400d,0xc081cae8,3 +np.float32,0x3e9f502f,0xbfd7966b,3 +np.float32,0x3f6bc656,0xbdf32b1f,3 +np.float32,0x3edb828b,0xbf9c65d4,3 +np.float32,0x6c6e56,0xc2fc7a8e,3 +np.float32,0x3f04552e,0xbf73b48f,3 +np.float32,0x3f39cb69,0xbeecc457,3 +np.float32,0x7f681c44,0x42ffb7a3,3 +np.float32,0x7f5b44ee,0x42ff8d99,3 +np.float32,0x3e71430a,0xc005798d,3 +np.float32,0x3edcfde3,0xbf9b27c6,3 +np.float32,0x3f616a5a,0xbe3bf67f,3 +np.float32,0x3f523936,0xbe918548,3 +np.float32,0x3f39ce3a,0xbeecb925,3 +np.float32,0x3eac589a,0xbfc91120,3 +np.float32,0x7efc8d3d,0x42fdf5fc,3 +np.float32,0x5704b0,0xc2fd1d0f,3 +np.float32,0x7e7972e9,0x42fbecda,3 +np.float32,0x3eb0811c,0xbfc4aa13,3 +np.float32,0x7f1efcbb,0x42fea023,3 +np.float32,0x3e0b9e32,0xc037fa6b,3 +np.float32,0x7eef6a48,0x42fdce87,3 +np.float32,0x3cc0a373,0xc0ad20c0,3 +np.float32,0x3f2a75bb,0xbf1632ba,3 +np.float32,0x0,0xff800000,3 +np.float32,0x7ecdb6f4,0x42fd5e77,3 +np.float32,0x7f2e2dfd,0x42fee38d,3 +np.float32,0x3ee17f6e,0xbf976d8c,3 +np.float32,0x3f51e7ee,0xbe92a319,3 +np.float32,0x3f06942f,0xbf6d7d3c,3 +np.float32,0x3f7ba528,0xbccac6f1,3 +np.float32,0x3f413787,0xbecfd513,3 +np.float32,0x3e085e48,0xc03a2716,3 +np.float32,0x7e4c5e0e,0x42fb599c,3 +np.float32,0x306f76,0xc2fecdd4,3 +np.float32,0x7f5c2203,0x42ff9081,3 +np.float32,0x3d5355b4,0xc088da05,3 +np.float32,0x9a2a,0xc305bb4f,3 +np.float32,0x3db93a1f,0xc05de0db,3 +np.float32,0x4e50c6,0xc2fd6ae4,3 +np.float32,0x7ec4afed,0x42fd3d51,3 +np.float32,0x3a8f27,0xc2fe41a0,3 +np.float32,0x7f213caf,0x42feaa84,3 +np.float32,0x7e7b5f00,0x42fbf286,3 +np.float32,0x7e367194,0x42fb05ca,3 +np.float32,0x7f56e6de,0x42ff7ebd,3 +np.float32,0x3ed7383e,0xbfa00aef,3 +np.float32,0x7e844752,0x42fc184a,3 +np.float32,0x15157,0xc3049a19,3 +np.float32,0x3f78cd92,0xbd28824a,3 +np.float32,0x7ecddb16,0x42fd5ef9,3 +np.float32,0x3e479f16,0xc016f7d8,3 +np.float32,0x3f5cb418,0xbe5b2bd3,3 +np.float32,0x7c0934cb,0x42f2334e,3 +np.float32,0x3ebe5505,0xbfb6bc69,3 +np.float32,0x3eb1335a,0xbfc3eff5,3 +np.float32,0x3f2488a3,0xbf234444,3 +np.float32,0x642906,0xc2fcb52a,3 +np.float32,0x3da635fa,0xc067e15a,3 +np.float32,0x7e0d80db,0x42fa4a15,3 +np.float32,0x4f0b9d,0xc2fd640a,3 +np.float32,0x7e083806,0x42fa2df8,3 +np.float32,0x7f77f8c6,0x42ffe877,3 +np.float32,0x3e7bb46a,0xc0018ff5,3 +np.float32,0x3f06eb2e,0xbf6c8eca,3 +np.float32,0x7eae8f7c,0x42fce52a,3 +np.float32,0x3de481a0,0xc04a7d7f,3 +np.float32,0x3eed4311,0xbf8e096f,3 +np.float32,0x3f7b0300,0xbce8903d,3 +np.float32,0x3811b,0xc30330dd,3 +np.float32,0x3eb6f8e1,0xbfbe04bc,3 +np.float32,0x3ec35210,0xbfb1f55a,3 +np.float32,0x3d386916,0xc08f24a5,3 +np.float32,0x3f1fa197,0xbf2e704d,3 +np.float32,0x7f2020a5,0x42fea56a,3 +np.float32,0x7e1ea53f,0x42fa9e8c,3 +np.float32,0x3f148903,0xbf490bf9,3 +np.float32,0x3f2f56a0,0xbf0bc6c9,3 +np.float32,0x7da9fc,0xc2fc0d9b,3 +np.float32,0x3d802134,0xc07fe810,3 +np.float32,0x3f6cb927,0xbde74e57,3 +np.float32,0x7e05b125,0x42fa2023,3 +np.float32,0x3f3307f9,0xbf041433,3 +np.float32,0x5666bf,0xc2fd2250,3 +np.float32,0x3f51c93b,0xbe930f28,3 +np.float32,0x3eb5dcfe,0xbfbf241e,3 +np.float32,0xb2773,0xc301853f,3 +np.float32,0x7f4dee96,0x42ff5f3f,3 +np.float32,0x3e3f5c33,0xc01adee1,3 +np.float32,0x3f2ed29a,0xbf0cdd4a,3 +np.float32,0x3e3c01ef,0xc01c80ab,3 +np.float32,0x3ec2236e,0xbfb31458,3 +np.float32,0x7e841dc4,0x42fc1761,3 +np.float32,0x3df2cd8e,0xc044e30c,3 +np.float32,0x3f010901,0xbf7d0670,3 +np.float32,0x3c05ceaa,0xc0ddf39b,3 +np.float32,0x3f517226,0xbe944206,3 +np.float32,0x3f23c83d,0xbf24f522,3 +np.float32,0x7fc9da,0xc2fc0139,3 +np.float32,0x7f1bde53,0x42fe9181,3 +np.float32,0x3ea3786c,0xbfd2d4a5,3 +np.float32,0x3e83a71b,0xbffacdd2,3 +np.float32,0x3f6f0d4f,0xbdca61d5,3 +np.float32,0x7f5ab613,0x42ff8bb7,3 +np.float32,0x3ab1ec,0xc2fe3fea,3 +np.float32,0x4fbf58,0xc2fd5d82,3 +np.float32,0x3dea141b,0xc0484403,3 +np.float32,0x7d86ad3b,0x42f8258f,3 +np.float32,0x7f345315,0x42fefd29,3 +np.float32,0x3f3752fe,0xbef6a780,3 +np.float32,0x64830d,0xc2fcb293,3 +np.float32,0x3d9dc1eb,0xc06cb32a,3 +np.float32,0x3f2f935a,0xbf0b46f6,3 +np.float32,0xb90a4,0xc30177e3,3 +np.float32,0x4111dd,0xc2fdf3c1,3 +np.float32,0x3d4cd078,0xc08a4c68,3 +np.float32,0x3e95c3f1,0xbfe30011,3 +np.float32,0x3ec9f356,0xbfabcb4e,3 +np.float32,0x1b90d5,0xc3003717,3 +np.float32,0xee70f,0xc3011a3e,3 +np.float32,0x7fa00000,0x7fe00000,3 +np.float32,0x3f74cdb6,0xbd8422af,3 +np.float32,0x3d9b56fe,0xc06e2037,3 +np.float32,0x3f1853df,0xbf3fbc40,3 +np.float32,0x7d86a011,0x42f82547,3 +np.float32,0x3dff9629,0xc0402634,3 +np.float32,0x46f8c9,0xc2fdb39f,3 +np.float32,0x3e9b410b,0xbfdc5a87,3 +np.float32,0x3f5aed42,0xbe671cac,3 +np.float32,0x3b739886,0xc101257f,3 +np.float64,0x3fe2f58d6565eb1b,0xbfe82a641138e19a,1 +np.float64,0x3fee7f0642fcfe0d,0xbfb1c702f6974932,1 +np.float64,0x25b71f244b6e5,0xc090030d3b3c5d2b,1 +np.float64,0x8c9cc8e1193b,0xc0900b752a678fa8,1 +np.float64,0x3fd329b5d326536c,0xbffbd607f6db945c,1 +np.float64,0x3fb5109b3a2a2136,0xc00cd36bd15dfb18,1 +np.float64,0x3fd5393ae12a7276,0xbff97a7e4a157154,1 +np.float64,0x3fd374d1b926e9a3,0xbffb7c3e1a3a7ed3,1 +np.float64,0x3fe2c7f4e2658fea,0xbfe899f15ca78fcb,1 +np.float64,0x7fe3d6b81ee7ad6f,0x408ffa7b63d407ee,1 +np.float64,0x3fe086d097e10da1,0xbfee81456ce8dd03,1 +np.float64,0x7fd374a64ca6e94c,0x408ff241c7306d39,1 +np.float64,0x3fc0709a5b20e135,0xc007afdede31b29c,1 +np.float64,0x3fd4218f4b28431f,0xbffab2c696966e2d,1 +np.float64,0x143134c828628,0xc09006a8372c4d8a,1 +np.float64,0x3f8bd0aa0037a154,0xc018cf0e8b9c3107,1 +np.float64,0x7fe0ce905ee19d20,0x408ff8915e71bd67,1 +np.float64,0x3fda0f5f32b41ebe,0xbff4bd5e0869e820,1 +np.float64,0x7fe9ae63d0b35cc7,0x408ffd760ca4f292,1 +np.float64,0x3fe75abd9eeeb57b,0xbfdd1476fc8b3089,1 +np.float64,0x786c3110f0d87,0xc08ff8b44cedbeea,1 +np.float64,0x22c5fe80458d,0xc09013853591c2f2,1 +np.float64,0x3fdc250797384a0f,0xbff2f6a02c961f0b,1 +np.float64,0x3fa2b367b02566cf,0xc013199238485054,1 +np.float64,0x3fd26a910ca4d522,0xbffcc0e2089b1c0c,1 +np.float64,0x8068d3b300d1b,0xc08ff7f690210aac,1 +np.float64,0x3fe663bfa9ecc77f,0xbfe07cd95a43a5ce,1 +np.float64,0x3fd0ddb07321bb61,0xbffec886665e895e,1 +np.float64,0x3f91c730b0238e61,0xc0176452badc8d22,1 +np.float64,0x4dd10d309ba22,0xc08ffdbe738b1d8d,1 +np.float64,0x7fe322afa4a6455e,0x408ffa10c038f9de,1 +np.float64,0x7fdf7f7c42befef8,0x408ff7d147ddaad5,1 +np.float64,0x7fd673f386ace7e6,0x408ff3e920d00eef,1 +np.float64,0x3feaebfcadb5d7f9,0xbfcfe8ec27083478,1 +np.float64,0x3fdc6dc23738db84,0xbff2bb46794f07b8,1 +np.float64,0xcd8819599b103,0xc08ff288c5b2cf0f,1 +np.float64,0xfda00e77fb402,0xc08ff01b895d2236,1 +np.float64,0x840b02ff08161,0xc08ff7a41e41114c,1 +np.float64,0x3fbdce3a383b9c74,0xc008d1e61903a289,1 +np.float64,0x3fd24ed3c4a49da8,0xbffce3c12136b6d3,1 +np.float64,0x3fe8d0834131a107,0xbfd77b194e7051d4,1 +np.float64,0x3fdd0cb11aba1962,0xbff23b9dbd554455,1 +np.float64,0x1a32d97e3465c,0xc090052781a37271,1 +np.float64,0x3fdb09d2b1b613a5,0xbff3e396b862bd83,1 +np.float64,0x3fe04c848aa09909,0xbfef2540dd90103a,1 +np.float64,0x3fce0c48613c1891,0xc000b9f76877d744,1 +np.float64,0x3fc37109a226e213,0xc005c05d8b2b9a2f,1 +np.float64,0x81cf3837039e7,0xc08ff7d686517dff,1 +np.float64,0xd9342c29b2686,0xc08ff1e591c9a895,1 +np.float64,0x7fec731b0638e635,0x408ffea4884550a9,1 +np.float64,0x3fba0fc138341f82,0xc00a5e839b085f64,1 +np.float64,0x7fdda893b03b5126,0x408ff71f7c5a2797,1 +np.float64,0xd2a4bb03a5498,0xc08ff2402f7a907c,1 +np.float64,0x3fea61fb0d34c3f6,0xbfd1d293fbe76183,1 +np.float64,0x3fed5cf486fab9e9,0xbfbfc2e01a7ffff1,1 +np.float64,0x3fcbabc2bf375785,0xc001ad7750c9dbdf,1 +np.float64,0x3fdb5fff53b6bfff,0xbff39a7973a0c6a5,1 +np.float64,0x7feef05a00bde0b3,0x408fff9c5cbc8651,1 +np.float64,0xb1cf24f1639e5,0xc08ff434de10fffb,1 +np.float64,0x3fa583989c2b0731,0xc0124a8a3bbf18ce,1 +np.float64,0x7feae90bf9f5d217,0x408ffe002e7bbbea,1 +np.float64,0x3fe9ef41c4b3de84,0xbfd367878ae4528e,1 +np.float64,0x9be24ce337c4a,0xc08ff5b9b1c31cf9,1 +np.float64,0x3fe916894cb22d13,0xbfd677f915d58503,1 +np.float64,0x3fec1bab20f83756,0xbfc7f2777aabe8ee,1 +np.float64,0x3feaabf2873557e5,0xbfd0d11f28341233,1 +np.float64,0x3fd4d3c3b529a787,0xbff9e9e47acc8ca9,1 +np.float64,0x3fe4cfe96c699fd3,0xbfe3dc53fa739169,1 +np.float64,0xccfdb97399fb7,0xc08ff2908d893400,1 +np.float64,0x3fec7598be78eb31,0xbfc5a750f8f3441a,1 +np.float64,0x355be5fc6ab7e,0xc090010ca315b50b,1 +np.float64,0x3fba9f9074353f21,0xc00a1f80eaf5e581,1 +np.float64,0x7fdcaff189395fe2,0x408ff6bd1c5b90d9,1 +np.float64,0x3fd94d3b64b29a77,0xbff56be1b43d25f3,1 +np.float64,0x4e5f29949cbe6,0xc08ffda972da1d73,1 +np.float64,0x3fe654e2d9aca9c6,0xbfe09b88dcd8f15d,1 +np.float64,0x7fdc130190b82602,0x408ff67d496c1a27,1 +np.float64,0x3fbcd4701e39a8e0,0xc009343e36627e80,1 +np.float64,0x7fdaa4d38f3549a6,0x408ff5e2c6d8678f,1 +np.float64,0x3febe95e5237d2bd,0xbfc93e16d453fe3a,1 +np.float64,0x9ef5ca553deba,0xc08ff57ff4f7883d,1 +np.float64,0x7fe878e91170f1d1,0x408ffce795868fc8,1 +np.float64,0x3fe63dff466c7bff,0xbfe0caf2b79c9e5f,1 +np.float64,0x6561446ccac29,0xc08ffab0e383834c,1 +np.float64,0x30c6c2ae618d9,0xc09001914b30381b,1 +np.float64,0x7ff0000000000000,0x7ff0000000000000,1 +np.float64,0x3fe5c9daf1ab93b6,0xbfe1be81baf4dbdb,1 +np.float64,0x3fe0a03e24a1407c,0xbfee3a73c4c0e8f8,1 +np.float64,0xff2a2cf3fe546,0xc08ff009a7e6e782,1 +np.float64,0x7fcf0332213e0663,0x408fefa36235e210,1 +np.float64,0x3fb612affc2c2560,0xc00c494be9c8c33b,1 +np.float64,0x3fd2b259702564b3,0xbffc67967f077e75,1 +np.float64,0x7fcb63685d36c6d0,0x408fee343343f913,1 +np.float64,0x3fe369f1d5a6d3e4,0xbfe71251139939ad,1 +np.float64,0x3fdd17c618ba2f8c,0xbff232d11c986251,1 +np.float64,0x3f92cc8040259901,0xc01711d8e06b52ee,1 +np.float64,0x69a81dc2d3504,0xc08ffa36cdaf1141,1 +np.float64,0x3fea0fad99b41f5b,0xbfd2f4625a652645,1 +np.float64,0xd1cd5799a39ab,0xc08ff24c02b90d26,1 +np.float64,0x324e59ce649cc,0xc0900163ad091c76,1 +np.float64,0x3fc3d460a227a8c1,0xc00585f903dc7a7f,1 +np.float64,0xa7185ec74e30c,0xc08ff4ec7d65ccd9,1 +np.float64,0x3fa254eaac24a9d5,0xc01337053963321a,1 +np.float64,0x3feaeb112435d622,0xbfcfef3be17f81f6,1 +np.float64,0x60144c3ac028a,0xc08ffb4f8eb94595,1 +np.float64,0x7fa4d2ec6829a5d8,0x408fdb0a9670ab83,1 +np.float64,0x3fed1372f97a26e6,0xbfc1b1fe50d48a55,1 +np.float64,0x3fd5ade5972b5bcb,0xbff8fcf28f525031,1 +np.float64,0x7fe72e335bee5c66,0x408ffc4759236437,1 +np.float64,0x7fdfafab143f5f55,0x408ff7e2e22a8129,1 +np.float64,0x3fe90d0db9321a1b,0xbfd69ae5fe10eb9e,1 +np.float64,0x7fe20a59072414b1,0x408ff962a2492484,1 +np.float64,0x3fed853690bb0a6d,0xbfbdc9dc5f199d2b,1 +np.float64,0x3fd709d469ae13a9,0xbff795a218deb700,1 +np.float64,0x3fe21c35f5e4386c,0xbfea47d71789329b,1 +np.float64,0x9ea5ec053d4be,0xc08ff585c2f6b7a3,1 +np.float64,0x3fc0580f9e20b01f,0xc007c1268f49d037,1 +np.float64,0xd99127abb3225,0xc08ff1e0a1ff339d,1 +np.float64,0x3fdc8c9bbfb91937,0xbff2a2478354effb,1 +np.float64,0x3fe15fc6b162bf8d,0xbfec323ac358e008,1 +np.float64,0xffefffffffffffff,0x7ff8000000000000,1 +np.float64,0x3fee341afb3c6836,0xbfb556b6faee9a84,1 +np.float64,0x3fe4b64c56296c99,0xbfe4154835ad2afe,1 +np.float64,0x85de22810bbc5,0xc08ff77b914fe5b5,1 +np.float64,0x3fd22c72e3a458e6,0xbffd0f4269d20bb9,1 +np.float64,0xc090e5218123,0xc09009a4a65a8a8f,1 +np.float64,0x7fd9641692b2c82c,0x408ff5547782bdfc,1 +np.float64,0x3fd9b9cb28b37396,0xbff509a8fb59a9f1,1 +np.float64,0x3fcd2726f93a4e4e,0xc001135059a22117,1 +np.float64,0x3fa4b493d4296928,0xc0128323c7a55f4a,1 +np.float64,0x47455e788e8ac,0xc08ffec2101c1e82,1 +np.float64,0x3fe0d7e2e261afc6,0xbfeda0f1e2d0f4bd,1 +np.float64,0x3fe860fc5b70c1f9,0xbfd91dc42eaf72c2,1 +np.float64,0xa5d7805b4baf0,0xc08ff502bc819ff6,1 +np.float64,0xd83395b1b0673,0xc08ff1f33c3f94c2,1 +np.float64,0x3f865972e02cb2e6,0xc01a1243651565c8,1 +np.float64,0x52fc6952a5f8e,0xc08ffd006b158179,1 +np.float64,0x7fecac6c793958d8,0x408ffebbb1c09a70,1 +np.float64,0x7fe621ff606c43fe,0x408ffbbeb2b1473a,1 +np.float64,0x3fdb9f3f9db73e7f,0xbff365610c52bda7,1 +np.float64,0x7feab92992757252,0x408ffdeb92a04813,1 +np.float64,0xcc46c79f988d9,0xc08ff29adf03fb7c,1 +np.float64,0x3fe3156a03262ad4,0xbfe7dd0f598781c7,1 +np.float64,0x3fc00e3a61201c75,0xc007f5c121a87302,1 +np.float64,0x3fdce8e9f739d1d4,0xbff2581d41ef50ef,1 +np.float64,0x0,0xfff0000000000000,1 +np.float64,0x7d373ac4fa6e8,0xc08ff840fa8beaec,1 +np.float64,0x3fee41e0653c83c1,0xbfb4ae786f2a0d54,1 +np.float64,0x3ff0000000000000,0x0,1 +np.float64,0x7feca6fff9794dff,0x408ffeb982a70556,1 +np.float64,0x7fc532716d2a64e2,0x408feb3f0f6c095b,1 +np.float64,0x3fe4ec2954a9d853,0xbfe39dd44aa5a040,1 +np.float64,0x7fd3321d52a6643a,0x408ff21a0ab9cd85,1 +np.float64,0x7fd8f1b2dfb1e365,0x408ff52001fa7922,1 +np.float64,0x3fee5e58cabcbcb2,0xbfb3539734a24d8b,1 +np.float64,0x3feebf6e7dfd7edd,0xbfad7c648f025102,1 +np.float64,0x6008026ec0101,0xc08ffb5108b54a93,1 +np.float64,0x3fea06f5e2340dec,0xbfd3134a48283360,1 +np.float64,0x41cad13c8395b,0xc08fffae654b2426,1 +np.float64,0x7fedb5c9353b6b91,0x408fff249f1f32b6,1 +np.float64,0xe00c5af9c018c,0xc08ff189e68c655f,1 +np.float64,0x7feac398ddf58731,0x408ffdf01374de9f,1 +np.float64,0x3fed21127c7a4225,0xbfc15b8cf55628fa,1 +np.float64,0x3fd3446711a688ce,0xbffbb5f7252a9fa3,1 +np.float64,0x7fe75fa07a6ebf40,0x408ffc5fdb096018,1 +np.float64,0x3feeb1618cbd62c3,0xbfaece3bd0863070,1 +np.float64,0x7f5226e180244dc2,0x408fb174d506e52f,1 +np.float64,0x3fcd67deca3acfbe,0xc000f9cd7a490749,1 +np.float64,0xdc6f30efb8de6,0xc08ff1b9f2a22d2e,1 +np.float64,0x9c14931338293,0xc08ff5b5f975ec5d,1 +np.float64,0x7fe93e802df27cff,0x408ffd4354eba0e0,1 +np.float64,0x3feb92ae5077255d,0xbfcb7f2084e44dbb,1 +np.float64,0xd78dbfddaf1b8,0xc08ff1fc19fa5a13,1 +np.float64,0x7fe14c301fa2985f,0x408ff8e666cb6592,1 +np.float64,0xbda3d8b77b47b,0xc08ff37689f4b2e5,1 +np.float64,0x8a42953b14853,0xc08ff71c2db3b8cf,1 +np.float64,0x7fe4ca7e186994fb,0x408ffb05e94254a7,1 +np.float64,0x7fe92ffc5e325ff8,0x408ffd3cb0265b12,1 +np.float64,0x91b262912364d,0xc08ff681619be214,1 +np.float64,0x33fe2b0667fc6,0xc0900132f3fab55e,1 +np.float64,0x3fde10e9183c21d2,0xbff17060fb4416c7,1 +np.float64,0xb6b811cb6d702,0xc08ff3e46303b541,1 +np.float64,0x3fe4a7bda0a94f7b,0xbfe435c6481cd0e3,1 +np.float64,0x7fd9fe6057b3fcc0,0x408ff599c79a822c,1 +np.float64,0x3fef44bf917e897f,0xbfa11484e351a6e9,1 +np.float64,0x3fe57d701daafae0,0xbfe2618ab40fc01b,1 +np.float64,0x7fe52d2adbaa5a55,0x408ffb3c2fb1c99d,1 +np.float64,0xb432f66d6865f,0xc08ff40d6b4084fe,1 +np.float64,0xbff0000000000000,0x7ff8000000000000,1 +np.float64,0x7fecd2292bf9a451,0x408ffecad860de6f,1 +np.float64,0x3fddd2ae153ba55c,0xbff1a059adaca33e,1 +np.float64,0x3fee55d6e5bcabae,0xbfb3bb1c6179d820,1 +np.float64,0x7fc1d0085623a010,0x408fe93d16ada7a7,1 +np.float64,0x829b000105360,0xc08ff7c47629a68f,1 +np.float64,0x7fe1e0257523c04a,0x408ff94782cf0717,1 +np.float64,0x7fd652f9ad2ca5f2,0x408ff3d820ec892e,1 +np.float64,0x3fef2246203e448c,0xbfa444ab6209d8cd,1 +np.float64,0x3fec6c0ae178d816,0xbfc5e559ebd4e790,1 +np.float64,0x3fe6ddfee92dbbfe,0xbfdf06dd7d3fa7a8,1 +np.float64,0x3fb7fbcbea2ff798,0xc00b5404d859d148,1 +np.float64,0x7feb9a154d37342a,0x408ffe4b26c29e55,1 +np.float64,0x3fe4db717aa9b6e3,0xbfe3c2c6b3ef13bc,1 +np.float64,0x3fbae17dda35c2fc,0xc00a030f7f4b37e7,1 +np.float64,0x7fd632b9082c6571,0x408ff3c76826ef19,1 +np.float64,0x7fc4184a15283093,0x408feaa14adf00be,1 +np.float64,0x3fe052d19920a5a3,0xbfef136b5df81a3e,1 +np.float64,0x7fe38b872b67170d,0x408ffa4f51aafc86,1 +np.float64,0x3fef9842d03f3086,0xbf92d3d2a21d4be2,1 +np.float64,0x9cea662139d4d,0xc08ff5a634810daa,1 +np.float64,0x3fe35f0855e6be11,0xbfe72c4b564e62aa,1 +np.float64,0x3fecee3d3779dc7a,0xbfc29ee942f8729e,1 +np.float64,0x3fe7903fd72f2080,0xbfdc41db9b5f4048,1 +np.float64,0xb958889572b11,0xc08ff3ba366cf84b,1 +np.float64,0x3fcb3a67c53674d0,0xc001dd21081ad1ea,1 +np.float64,0xe3b1b53fc7637,0xc08ff15a3505e1ce,1 +np.float64,0xe5954ae9cb2aa,0xc08ff141cbbf0ae4,1 +np.float64,0x3fe394af74e7295f,0xbfe6ad1d13f206e8,1 +np.float64,0x7fe21dd704643bad,0x408ff96f13f80c1a,1 +np.float64,0x3fd23a7cf02474fa,0xbffcfd7454117a05,1 +np.float64,0x7fe257515e24aea2,0x408ff99378764d52,1 +np.float64,0x7fe4c5d0a6e98ba0,0x408ffb03503cf939,1 +np.float64,0x3fadc2c1603b8583,0xc0106b2c17550e3a,1 +np.float64,0x3fc0f7f02421efe0,0xc007525ac446864c,1 +np.float64,0x3feaf0b27275e165,0xbfcfc8a03eaa32ad,1 +np.float64,0x5ce7503cb9ceb,0xc08ffbb2de365fa8,1 +np.float64,0x2a0014f654003,0xc090026e41761a0d,1 +np.float64,0x7fe2c848a8e59090,0x408ff9d9b723ee89,1 +np.float64,0x7f66f54bc02dea97,0x408fbc2ae0ec5623,1 +np.float64,0xa35a890146b6,0xc0900a97b358ddbd,1 +np.float64,0x7fee267ded7c4cfb,0x408fff501560c9f5,1 +np.float64,0x3fe07c328520f865,0xbfee9ef7c3435b58,1 +np.float64,0x3fe67122cf6ce246,0xbfe06147001932ba,1 +np.float64,0x3fdacc8925359912,0xbff41824cece219e,1 +np.float64,0xffa3047fff461,0xc08ff00431ec9be3,1 +np.float64,0x3e1af43e7c35f,0xc090002c6573d29b,1 +np.float64,0x86fa94590df53,0xc08ff7632525ed92,1 +np.float64,0x7fec4c76227898eb,0x408ffe94d032c657,1 +np.float64,0x7fe2274ce1e44e99,0x408ff975194cfdff,1 +np.float64,0x7fe670e1b4ace1c2,0x408ffbe78cc451de,1 +np.float64,0x7fe853871db0a70d,0x408ffcd5e6a6ff47,1 +np.float64,0x3fcbf265db37e4cc,0xc0019026336e1176,1 +np.float64,0x3fef033cef3e067a,0xbfa726712eaae7f0,1 +np.float64,0x5d74973abae94,0xc08ffba15e6bb992,1 +np.float64,0x7fdd9c99b6bb3932,0x408ff71ad24a7ae0,1 +np.float64,0xbdc8e09b7b91c,0xc08ff3744939e9a3,1 +np.float64,0xdbfcff71b7fa0,0xc08ff1bfeecc9dfb,1 +np.float64,0xf9b38cf5f3672,0xc08ff0499af34a43,1 +np.float64,0x3fea820aa6b50415,0xbfd162a38e1927b1,1 +np.float64,0x3fe67f59a12cfeb3,0xbfe04412adca49dc,1 +np.float64,0x3feb301d9c76603b,0xbfce17e6edeb92d5,1 +np.float64,0x828ce00b0519c,0xc08ff7c5b5c57cde,1 +np.float64,0x4f935e229f26c,0xc08ffd7c67c1c54f,1 +np.float64,0x7fcd139e023a273b,0x408feee4f12ff11e,1 +np.float64,0x666a9944ccd54,0xc08ffa92d5e5cd64,1 +np.float64,0x3fe792f0fa6f25e2,0xbfdc374fda28f470,1 +np.float64,0xe996029bd32c1,0xc08ff10eb9b47a11,1 +np.float64,0x3fe7b0dd1eef61ba,0xbfdbc2676dc77db0,1 +np.float64,0x7fd3ec0127a7d801,0x408ff287bf47e27d,1 +np.float64,0x3fe793a8ea6f2752,0xbfdc347f7717e48d,1 +np.float64,0x7fdb89d15e3713a2,0x408ff64457a13ea2,1 +np.float64,0x3fe35b3cbbe6b679,0xbfe73557c8321b70,1 +np.float64,0x66573c94ccae8,0xc08ffa9504af7eb5,1 +np.float64,0x3fc620a2302c4144,0xc00442036b944a67,1 +np.float64,0x49b2fe0693660,0xc08ffe5f131c3c7e,1 +np.float64,0x7fda936cdfb526d9,0x408ff5db3ab3f701,1 +np.float64,0xc774ceef8ee9a,0xc08ff2e16d082fa1,1 +np.float64,0x4da9f8a09b55,0xc0900ee2206d0c88,1 +np.float64,0x3fe2ca5d5ae594bb,0xbfe89406611a5f1a,1 +np.float64,0x7fe0832497e10648,0x408ff85d1de6056e,1 +np.float64,0x3fe6a9e3222d53c6,0xbfdfda35a9bc2de1,1 +np.float64,0x3fed3d92c8ba7b26,0xbfc0a73620db8b98,1 +np.float64,0x3fdd2ec093ba5d81,0xbff2209cf78ce3f1,1 +np.float64,0x62fcb968c5f98,0xc08ffaf775a593c7,1 +np.float64,0xfcfb019ff9f60,0xc08ff0230e95bd16,1 +np.float64,0x3fd7a63e8f2f4c7d,0xbff6faf4fff7dbe0,1 +np.float64,0x3fef23b0ec3e4762,0xbfa4230cb176f917,1 +np.float64,0x340d1e6a681a5,0xc09001314b68a0a2,1 +np.float64,0x7fc0b85ba02170b6,0x408fe8821487b802,1 +np.float64,0x7fe9976e84f32edc,0x408ffd6bb6aaf467,1 +np.float64,0x329a0e9e65343,0xc090015b044e3270,1 +np.float64,0x3fea4928d3f49252,0xbfd2299b05546eab,1 +np.float64,0x3f188c70003118e0,0xc02ac3ce23bc5d5a,1 +np.float64,0x3fecce5020b99ca0,0xbfc36b23153d5f50,1 +np.float64,0x3fe203873e24070e,0xbfea86edb3690830,1 +np.float64,0x3fe02d9eaa205b3d,0xbfef7d18c54a76d2,1 +np.float64,0xef7537ebdeea7,0xc08ff0c55e9d89e7,1 +np.float64,0x3fedf7572efbeeae,0xbfb840af357cf07c,1 +np.float64,0xd1a97a61a354,0xc0900926fdfb96cc,1 +np.float64,0x7fe6a0daeced41b5,0x408ffc001edf1407,1 +np.float64,0x3fe5063625aa0c6c,0xbfe3647cfb949d62,1 +np.float64,0x7fe9b28d31736519,0x408ffd77eb4a922b,1 +np.float64,0x7feea90d033d5219,0x408fff81a4bbff62,1 +np.float64,0x3fe9494d17f2929a,0xbfd5bde02eb5287a,1 +np.float64,0x7feee17a8cbdc2f4,0x408fff96cf0dc16a,1 +np.float64,0xb2ad18ef655a3,0xc08ff4267eda8af8,1 +np.float64,0x3fad3b52683a76a5,0xc01085ab75b797ce,1 +np.float64,0x2300a65846016,0xc090037b81ce9500,1 +np.float64,0x3feb1041f9b62084,0xbfcef0c87d8b3249,1 +np.float64,0x3fdd887d3e3b10fa,0xbff1da0e1ede6db2,1 +np.float64,0x3fd3e410eb27c822,0xbffaf9b5fc9cc8cc,1 +np.float64,0x3fe0aa53e3e154a8,0xbfee1e7b5c486578,1 +np.float64,0x7fe33e389aa67c70,0x408ffa214fe50961,1 +np.float64,0x3fd27e3a43a4fc75,0xbffca84a79e8adeb,1 +np.float64,0x3fb309e0082613c0,0xc00dfe407b77a508,1 +np.float64,0x7feaf2ed8cf5e5da,0x408ffe046a9d1ba9,1 +np.float64,0x1e76167a3cec4,0xc0900448cd35ec67,1 +np.float64,0x3fe0a18e1721431c,0xbfee36cf1165a0d4,1 +np.float64,0x3fa73b78c02e76f2,0xc011d9069823b172,1 +np.float64,0x3fef6d48287eda90,0xbf9ab2d08722c101,1 +np.float64,0x8fdf0da31fbe2,0xc08ff6a6a2accaa1,1 +np.float64,0x3fc3638db826c71b,0xc005c86191688826,1 +np.float64,0xaa9c09c555381,0xc08ff4aefe1d9473,1 +np.float64,0x7fccb0f4523961e8,0x408feebd84773f23,1 +np.float64,0xede75dcfdbcec,0xc08ff0d89ba887d1,1 +np.float64,0x7f8a051520340a29,0x408fcd9cc17f0d95,1 +np.float64,0x3fef5ca2babeb945,0xbf9dc221f3618e6a,1 +np.float64,0x7fea0ff4bcf41fe8,0x408ffda193359f22,1 +np.float64,0x7fe05c53fd20b8a7,0x408ff841dc7123e8,1 +np.float64,0x3fc625664b2c4acd,0xc0043f8749b9a1d8,1 +np.float64,0x7fed58f98f7ab1f2,0x408fff00585f48c2,1 +np.float64,0x3fb3e5e51427cbca,0xc00d7bcb6528cafe,1 +np.float64,0x3fe728bd3d6e517a,0xbfdddafa72bd0f60,1 +np.float64,0x3fe3f005dd27e00c,0xbfe5d7b3ec93bca0,1 +np.float64,0x3fd74fbd1a2e9f7a,0xbff750001b63ce81,1 +np.float64,0x3fd3af6d85a75edb,0xbffb371d678d11b4,1 +np.float64,0x7fa690ad8c2d215a,0x408fdbf7db9c7640,1 +np.float64,0x3fbdfd38e23bfa72,0xc008bfc1c5c9b89e,1 +np.float64,0x3fe2374684a46e8d,0xbfea030c4595dfba,1 +np.float64,0x7fc0806c372100d7,0x408fe85b36fee334,1 +np.float64,0x3fef3ac47b7e7589,0xbfa2007195c5213f,1 +np.float64,0x3fb55473922aa8e7,0xc00cae7af8230e0c,1 +np.float64,0x7fe018dc152031b7,0x408ff811e0d712fa,1 +np.float64,0x3fe3b3fca56767f9,0xbfe6638ae2c99c62,1 +np.float64,0x7fac79818c38f302,0x408fdea720b39c3c,1 +np.float64,0x7fefffffffffffff,0x4090000000000000,1 +np.float64,0xd2b290cba5652,0xc08ff23f6d7152a6,1 +np.float64,0x7fc5848eb52b091c,0x408feb6b6f8b77d0,1 +np.float64,0xf399f62de733f,0xc08ff092ae319ad8,1 +np.float64,0x7fdec56c12bd8ad7,0x408ff78c4ddbc667,1 +np.float64,0x3fca640f1e34c81e,0xc0023969c5cbfa4c,1 +np.float64,0x3fd55225db2aa44c,0xbff95f7442a2189e,1 +np.float64,0x7fefa009a97f4012,0x408fffdd2f42ef9f,1 +np.float64,0x4a3b70609478,0xc0900f24e449bc3d,1 +np.float64,0x7fe3738b1ba6e715,0x408ffa411f2cb5e7,1 +np.float64,0x7fe5e53f0b6bca7d,0x408ffb9ed8d95cea,1 +np.float64,0x3fe274dd24a4e9ba,0xbfe967fb114b2a83,1 +np.float64,0x3fcbc58b8c378b17,0xc001a2bb1e158bcc,1 +np.float64,0x3fefc2c0043f8580,0xbf862c9b464dcf38,1 +np.float64,0xc2c4fafd858a0,0xc08ff327aecc409b,1 +np.float64,0x3fd8bc39a9b17873,0xbff5f1ad46e5a51c,1 +np.float64,0x3fdf341656be682d,0xbff094f41e7cb4c4,1 +np.float64,0x3fef8495c13f092c,0xbf966cf6313bae4c,1 +np.float64,0x3fe14e0f05229c1e,0xbfec6166f26b7161,1 +np.float64,0x3fed42d3b2ba85a7,0xbfc0860b773d35d8,1 +np.float64,0x7fd92bbac5b25775,0x408ff53abcb3fe0c,1 +np.float64,0xb1635b6f62c6c,0xc08ff43bdf47accf,1 +np.float64,0x4a3a2dbc94746,0xc08ffe49fabddb36,1 +np.float64,0x87d831290fb06,0xc08ff750419dc6fb,1 +np.float64,0x3fec4713f7f88e28,0xbfc6d6217c9f5cf9,1 +np.float64,0x7fed43ba2d3a8773,0x408ffef7fa2fc303,1 +np.float64,0x7fd1ec5b56a3d8b6,0x408ff14f62615f1e,1 +np.float64,0x3fee534b6c7ca697,0xbfb3da1951aa3e68,1 +np.float64,0x3febb564c2b76aca,0xbfca9737062e55e7,1 +np.float64,0x943e6b0f287ce,0xc08ff64e2d09335c,1 +np.float64,0xf177d957e2efb,0xc08ff0acab2999fa,1 +np.float64,0x7fb5b881a82b7102,0x408fe3872b4fde5e,1 +np.float64,0x3fdb2b4a97b65695,0xbff3c715c91359bc,1 +np.float64,0x3fac0a17e4381430,0xc010c330967309fb,1 +np.float64,0x7fd8057990b00af2,0x408ff4b0a287a348,1 +np.float64,0x1f9026a23f206,0xc09004144f3a19dd,1 +np.float64,0x3fdb2977243652ee,0xbff3c8a2fd05803d,1 +np.float64,0x3fe0f6e74b21edcf,0xbfed4c3bb956bae0,1 +np.float64,0xde9cc3bbbd399,0xc08ff19ce5c1e762,1 +np.float64,0x3fe72ce106ae59c2,0xbfddca7ab14ceba2,1 +np.float64,0x3fa8ee14e031dc2a,0xc01170d54ca88e86,1 +np.float64,0x3fe0b09bbb216137,0xbfee0d189a95b877,1 +np.float64,0x7fdfdcb157bfb962,0x408ff7f33cf2afea,1 +np.float64,0x3fef84d5f53f09ac,0xbf966134e2a154f4,1 +np.float64,0x3fea0e0b1bb41c16,0xbfd2fa2d36637d19,1 +np.float64,0x1ab76fd6356ef,0xc090050a9616ffbd,1 +np.float64,0x7fd0ccf79a2199ee,0x408ff09045af2dee,1 +np.float64,0x7fea929345f52526,0x408ffddadc322b07,1 +np.float64,0x3fe9ef629cf3dec5,0xbfd367129c166838,1 +np.float64,0x3feedf0ea2fdbe1d,0xbfaa862afca44c00,1 +np.float64,0x7fce725f723ce4be,0x408fef6cfd2769a8,1 +np.float64,0x7fe4313b3ca86275,0x408ffaaf9557ef8c,1 +np.float64,0xe2d46463c5a8d,0xc08ff165725c6b08,1 +np.float64,0x7fbacb4ace359695,0x408fe5f3647bd0d5,1 +np.float64,0x3fbafd009635fa01,0xc009f745a7a5c5d5,1 +np.float64,0x3fe3cea66ce79d4d,0xbfe6253b895e2838,1 +np.float64,0x7feaa71484354e28,0x408ffde3c0bad2a6,1 +np.float64,0x3fd755b8b42eab71,0xbff74a1444c6e654,1 +np.float64,0x3fc313e2172627c4,0xc005f830e77940c3,1 +np.float64,0x12d699a225ad4,0xc090070ec00f2338,1 +np.float64,0x3fa975fe8432ebfd,0xc01151b3da48b3f9,1 +np.float64,0x7fdce3103b39c61f,0x408ff6d19b3326fa,1 +np.float64,0x7fd341cbba268396,0x408ff2237490fdca,1 +np.float64,0x3fd8405885b080b1,0xbff6666d8802a7d5,1 +np.float64,0x3fe0f0cca3a1e199,0xbfed5cdb3e600791,1 +np.float64,0x7fbd56680c3aaccf,0x408fe6ff55bf378d,1 +np.float64,0x3f939c4f3027389e,0xc016d364dd6313fb,1 +np.float64,0x3fe9e87fac73d0ff,0xbfd37f9a2be4fe38,1 +np.float64,0x7fc93c6a883278d4,0x408fed4260e614f1,1 +np.float64,0x7fa88c0ff031181f,0x408fdcf09a46bd3a,1 +np.float64,0xd5487f99aa910,0xc08ff21b6390ab3b,1 +np.float64,0x3fe34acc96e69599,0xbfe75c9d290428fb,1 +np.float64,0x3fd17f5964a2feb3,0xbffdef50b524137b,1 +np.float64,0xe23dec0dc47be,0xc08ff16d1ce61dcb,1 +np.float64,0x3fec8bd64fb917ad,0xbfc5173941614b8f,1 +np.float64,0x3fc81d97d7303b30,0xc00343ccb791401d,1 +np.float64,0x7fe79ad18e2f35a2,0x408ffc7cf0ab0f2a,1 +np.float64,0x3f96306b402c60d7,0xc0161ce54754cac1,1 +np.float64,0xfb09fc97f6140,0xc08ff039d1d30123,1 +np.float64,0x3fec9c4afa793896,0xbfc4ace43ee46079,1 +np.float64,0x3f9262dac824c5b6,0xc01732a3a7eeb598,1 +np.float64,0x3fa5cd33f42b9a68,0xc01236ed4d315a3a,1 +np.float64,0x3fe7bb336caf7667,0xbfdb9a268a82e267,1 +np.float64,0xc6c338f98d867,0xc08ff2ebb8475bbc,1 +np.float64,0x3fd50714482a0e29,0xbff9b14a9f84f2c2,1 +np.float64,0xfff0000000000000,0x7ff8000000000000,1 +np.float64,0x3fde2cd0f93c59a2,0xbff15afe35a43a37,1 +np.float64,0xf1719cb9e2e34,0xc08ff0acf77b06d3,1 +np.float64,0xfd3caaf9fa796,0xc08ff020101771bd,1 +np.float64,0x7f750d63a02a1ac6,0x408fc32ad0caa362,1 +np.float64,0x7fcc50f4e238a1e9,0x408fee96a5622f1a,1 +np.float64,0x421d1da0843a4,0xc08fff9ffe62d869,1 +np.float64,0x3fd9e17023b3c2e0,0xbff4e631d687ee8e,1 +np.float64,0x3fe4999a09693334,0xbfe4556b3734c215,1 +np.float64,0xd619ef03ac33e,0xc08ff21013c85529,1 +np.float64,0x3fc4da522229b4a4,0xc004f150b2c573aa,1 +np.float64,0x3feb04b053b60961,0xbfcf3fc9e00ebc40,1 +np.float64,0x3fbedec5ea3dbd8c,0xc0086a33dc22fab5,1 +np.float64,0x7fec3b217ab87642,0x408ffe8dbc8ca041,1 +np.float64,0xdb257d33b64b0,0xc08ff1cb42d3c182,1 +np.float64,0x7fa2d92ec025b25d,0x408fd9e414d11cb0,1 +np.float64,0x3fa425c550284b8b,0xc012ab7cbf83be12,1 +np.float64,0x10b4869021692,0xc09007c0487d648a,1 +np.float64,0x7f97918c902f2318,0x408fd47867806574,1 +np.float64,0x3fe4f91238e9f224,0xbfe38160b4e99919,1 +np.float64,0x3fc2b1af6125635f,0xc00634343bc58461,1 +np.float64,0x3fc2a98071255301,0xc0063942bc8301be,1 +np.float64,0x3fe4cfc585299f8b,0xbfe3dca39f114f34,1 +np.float64,0x3fd1ea75b3a3d4eb,0xbffd63acd02c5406,1 +np.float64,0x3fd6bf48492d7e91,0xbff7e0cd249f80f9,1 +np.float64,0x76643d36ecc88,0xc08ff8e68f13b38c,1 +np.float64,0x7feeabab3e7d5755,0x408fff82a0fd4501,1 +np.float64,0x46c0d4a68d81b,0xc08ffed79abaddc9,1 +np.float64,0x3fd088d57ca111ab,0xbfff3dd0ed7128ea,1 +np.float64,0x3fed25887cba4b11,0xbfc13f47639bd645,1 +np.float64,0x7fd90984b4b21308,0x408ff52b022c7fb4,1 +np.float64,0x3fe6ef31daadde64,0xbfdec185760cbf21,1 +np.float64,0x3fe48dbe83291b7d,0xbfe47005b99920bd,1 +np.float64,0x3fdce8422f39d084,0xbff258a33a96cc8e,1 +np.float64,0xb8ecdef771d9c,0xc08ff3c0eca61b10,1 +np.float64,0x3fe9bbf9a03377f3,0xbfd41ecfdcc336b9,1 +np.float64,0x7fe2565339a4aca5,0x408ff992d8851eaf,1 +np.float64,0x3fe1693e3822d27c,0xbfec1919da2ca697,1 +np.float64,0x3fd3680488a6d009,0xbffb8b7330275947,1 +np.float64,0x7fbe4f3d2c3c9e79,0x408fe75fa3f4e600,1 +np.float64,0x7fd4cfef3ca99fdd,0x408ff308ee3ab50f,1 +np.float64,0x3fd9c9a51cb3934a,0xbff4fb7440055ce6,1 +np.float64,0x3fe08a9640a1152d,0xbfee76bd1bfbf5c2,1 +np.float64,0x3fef012c41fe0259,0xbfa757a2da7f9707,1 +np.float64,0x3fee653fe2fcca80,0xbfb2ffae0c95025c,1 +np.float64,0x7fd0776933a0eed1,0x408ff054e7b43d41,1 +np.float64,0x4c94e5c09929d,0xc08ffdedb7f49e5e,1 +np.float64,0xca3e3d17947c8,0xc08ff2b86dce2f7a,1 +np.float64,0x3fb528e1342a51c2,0xc00cc626c8e2d9ba,1 +np.float64,0xd774df81aee9c,0xc08ff1fd6f0a7548,1 +np.float64,0x3fc47a9b6128f537,0xc00526c577b80849,1 +np.float64,0x3fe29a6f6a6534df,0xbfe90a5f83644911,1 +np.float64,0x3fecda4f59f9b49f,0xbfc31e4a80c4cbb6,1 +np.float64,0x7fe51d44f5aa3a89,0x408ffb3382437426,1 +np.float64,0x3fd677fc412ceff9,0xbff82999086977e7,1 +np.float64,0x3fe2a3c7e7254790,0xbfe8f33415cdba9d,1 +np.float64,0x3fe6d8d1dc6db1a4,0xbfdf1bc61bc24dff,1 +np.float64,0x7febb32d8ef7665a,0x408ffe55a043ded1,1 +np.float64,0x60677860c0d0,0xc0900da2caa7d571,1 +np.float64,0x7390c2e0e7219,0xc08ff92df18bb5d2,1 +np.float64,0x3fca53711b34a6e2,0xc00240b07a9b529b,1 +np.float64,0x7fe7ce6dd8ef9cdb,0x408ffc961164ead9,1 +np.float64,0x7fc0c9de0d2193bb,0x408fe88e245767f6,1 +np.float64,0xc0ee217981dc4,0xc08ff343b77ea770,1 +np.float64,0x72bd4668e57a9,0xc08ff94323fd74fc,1 +np.float64,0x7fd6970e252d2e1b,0x408ff3fb1e2fead2,1 +np.float64,0x7fdcb61040396c20,0x408ff6bf926bc98f,1 +np.float64,0xda4faa25b49f6,0xc08ff1d68b3877f0,1 +np.float64,0x3feb344749f6688f,0xbfcdfba2d66c72c5,1 +np.float64,0x3fe2aa4284e55485,0xbfe8e32ae0683f57,1 +np.float64,0x3f8e8fcfd03d1fa0,0xc01843efb2129908,1 +np.float64,0x8000000000000000,0xfff0000000000000,1 +np.float64,0x3fd8e01155b1c023,0xbff5d0529dae9515,1 +np.float64,0x3fe8033f3370067e,0xbfda837c80b87e7c,1 +np.float64,0x7fc5bf831e2b7f05,0x408feb8ae3b039a0,1 +np.float64,0x3fd8dcdf5331b9bf,0xbff5d349e1ed422a,1 +np.float64,0x3fe58b4e302b169c,0xbfe243c9cbccde44,1 +np.float64,0x3fea8a2e47b5145d,0xbfd1464e37221894,1 +np.float64,0x75cd1e88eb9a4,0xc08ff8f553ef0475,1 +np.float64,0x7fcfc876e23f90ed,0x408fefebe6cc95e6,1 +np.float64,0x7f51aceb002359d5,0x408fb1263f9003fb,1 +np.float64,0x7fc2a1b877254370,0x408fe9c1ec52f8b9,1 +np.float64,0x7fd495810e292b01,0x408ff2e859414d31,1 +np.float64,0x7fd72048632e4090,0x408ff440690cebdb,1 +np.float64,0x7fd7aafaffaf6,0xc08ff803a390779f,1 +np.float64,0x7fe18067d4a300cf,0x408ff9090a02693f,1 +np.float64,0x3fdc1080f8b82102,0xbff3077bf44a89bd,1 +np.float64,0x3fc34a462f26948c,0xc005d777b3cdf139,1 +np.float64,0x3fe21e4a1fe43c94,0xbfea428acfbc6ea9,1 +np.float64,0x1f0d79083e1b0,0xc090042c65a7abf2,1 +np.float64,0x3fe8d0d15931a1a3,0xbfd779f6bbd4db78,1 +np.float64,0x3fe74578022e8af0,0xbfdd68b6c15e9f5e,1 +np.float64,0x50995dd0a132c,0xc08ffd56a5c8accf,1 +np.float64,0x3f9a6342b034c685,0xc0151ce1973c62bd,1 +np.float64,0x3f30856a00210ad4,0xc027e852f4d1fcbc,1 +np.float64,0x3febcf7646b79eed,0xbfc9e9cc9d12425c,1 +np.float64,0x8010000000000000,0x7ff8000000000000,1 +np.float64,0x3fdf520c02bea418,0xbff07ed5013f3062,1 +np.float64,0x3fe5433ecbea867e,0xbfe2df38968b6d14,1 +np.float64,0x3fb933a84e326751,0xc00ac1a144ad26c5,1 +np.float64,0x7b6d72c2f6daf,0xc08ff86b7a67f962,1 +np.float64,0xaef5dae75debc,0xc08ff46496bb2932,1 +np.float64,0x522d869aa45b1,0xc08ffd1d55281e98,1 +np.float64,0xa2462b05448c6,0xc08ff542fe0ac5fd,1 +np.float64,0x3fe2b71dd6e56e3c,0xbfe8c3690cf15415,1 +np.float64,0x3fe5778231aaef04,0xbfe26e495d09b783,1 +np.float64,0x3fe9b8d564f371ab,0xbfd42a161132970d,1 +np.float64,0x3f89ebc34033d787,0xc019373f90bfc7f1,1 +np.float64,0x3fe438ddc6e871bc,0xbfe53039341b0a93,1 +np.float64,0x873c75250e78f,0xc08ff75d8478dccd,1 +np.float64,0x807134cb00e27,0xc08ff7f5cf59c57a,1 +np.float64,0x3fac459878388b31,0xc010b6fe803bcdc2,1 +np.float64,0xca9dc7eb953b9,0xc08ff2b2fb480784,1 +np.float64,0x7feb38587bb670b0,0x408ffe21ff6d521e,1 +np.float64,0x7fd70e9b782e1d36,0x408ff437936b393a,1 +np.float64,0x3fa4037bbc2806f7,0xc012b55744c65ab2,1 +np.float64,0x3fd3d4637427a8c7,0xbffb0beebf4311ef,1 +np.float64,0x7fdabbda5db577b4,0x408ff5ecbc0d4428,1 +np.float64,0x7fda9be0a2b537c0,0x408ff5dee5d03d5a,1 +np.float64,0x7fe9c74396338e86,0x408ffd813506a18a,1 +np.float64,0x3fd058243e20b048,0xbfff822ffd8a7f21,1 +np.float64,0x3fe6aa6ca9ed54d9,0xbfdfd805629ff49e,1 +np.float64,0x3fd91431d5322864,0xbff5a025eea8c78b,1 +np.float64,0x7fe4d7f02329afdf,0x408ffb0d5d9b7878,1 +np.float64,0x3fe2954a12252a94,0xbfe917266e3e22d5,1 +np.float64,0x3fb25f7c8224bef9,0xc00e6764c81b3718,1 +np.float64,0x3fda4bddeeb497bc,0xbff4880638908c81,1 +np.float64,0x55dfd12eabbfb,0xc08ffc9b54ff4002,1 +np.float64,0x3fe8f399e031e734,0xbfd6f8e5c4dcd93f,1 +np.float64,0x3fd954a24832a945,0xbff56521f4707a06,1 +np.float64,0x3fdea911f2bd5224,0xbff0fcb2d0c2b2e2,1 +np.float64,0x3fe6b4ff8a2d69ff,0xbfdfacfc85cafeab,1 +np.float64,0x3fc7fa02042ff404,0xc00354e13b0767ad,1 +np.float64,0x3fe955088c72aa11,0xbfd593130f29949e,1 +np.float64,0xd7e74ec1afcea,0xc08ff1f74f61721c,1 +np.float64,0x3fe9d69c1ab3ad38,0xbfd3bf710a337e06,1 +np.float64,0x3fd85669a2b0acd3,0xbff65176143ccc1e,1 +np.float64,0x3fea99b285353365,0xbfd11062744783f2,1 +np.float64,0x3fe2c79f80a58f3f,0xbfe89ac33f990289,1 +np.float64,0x3f8332ba30266574,0xc01af2cb7b635783,1 +np.float64,0x30d0150061a1,0xc090119030f74c5d,1 +np.float64,0x3fdbf4cb06b7e996,0xbff31e5207aaa754,1 +np.float64,0x3fe6b56c216d6ad8,0xbfdfab42fb2941c5,1 +np.float64,0x7fc4dc239829b846,0x408feb0fb0e13fbe,1 +np.float64,0x3fd0ab85ef21570c,0xbfff0d95d6c7a35c,1 +np.float64,0x7fe13d75e5e27aeb,0x408ff8dc8efa476b,1 +np.float64,0x3fece3b832f9c770,0xbfc2e21b165d583f,1 +np.float64,0x3fe3a279c4e744f4,0xbfe68ca4fbb55dbf,1 +np.float64,0x3feb64659ef6c8cb,0xbfccb6204b6bf724,1 +np.float64,0x2279a6bc44f36,0xc0900391eeeb3e7c,1 +np.float64,0xb88046d571009,0xc08ff3c7b5b45300,1 +np.float64,0x7ff4000000000000,0x7ffc000000000000,1 +np.float64,0x3fe49af059a935e1,0xbfe4526c294f248f,1 +np.float64,0xa3e5508147cc,0xc0900a92ce5924b1,1 +np.float64,0x7fc56def3d2adbdd,0x408feb5f46c360e8,1 +np.float64,0x7fd99f3574333e6a,0x408ff56f3807987c,1 +np.float64,0x3fdc38d56fb871ab,0xbff2e667cad8f36a,1 +np.float64,0xd0b03507a1607,0xc08ff25bbcf8aa9d,1 +np.float64,0xc493f9078927f,0xc08ff30c5fa4e759,1 +np.float64,0x3fc86ddbcb30dbb8,0xc0031da1fcb56d75,1 +np.float64,0x7fe75dc395aebb86,0x408ffc5eef841491,1 +np.float64,0x1647618a2c8ed,0xc0900616ef9479c1,1 +np.float64,0xdf144763be289,0xc08ff196b527f3c9,1 +np.float64,0x3fe0b29da6a1653b,0xbfee078b5f4d7744,1 +np.float64,0x3feb055852b60ab1,0xbfcf3b4db5779a7a,1 +np.float64,0x3fe8bc1625f1782c,0xbfd7c739ade904bc,1 +np.float64,0x7fd19bfb8ea337f6,0x408ff11b2b55699c,1 +np.float64,0x3fed1d80d1ba3b02,0xbfc1722e8d3ce094,1 +np.float64,0x2d9c65925b38e,0xc09001f46bcd3bc5,1 +np.float64,0x7fed6f4d857ade9a,0x408fff091cf6a3b4,1 +np.float64,0x3fd070cd6ba0e19b,0xbfff5f7609ca29e8,1 +np.float64,0x7fea3508b8f46a10,0x408ffdb1f30bd6be,1 +np.float64,0x508b897ca1172,0xc08ffd58a0eb3583,1 +np.float64,0x7feba367b07746ce,0x408ffe4f0bf4bd4e,1 +np.float64,0x3fefebd5c4bfd7ac,0xbf6d20b4fcf21b69,1 +np.float64,0x3fd8ef07b8b1de0f,0xbff5c2745c0795a5,1 +np.float64,0x3fd38ed518271daa,0xbffb5d75f00f6900,1 +np.float64,0x6de0fecedbc20,0xc08ff9c307bbc647,1 +np.float64,0xafc0ffc35f820,0xc08ff45737e5d6b4,1 +np.float64,0x7fd282097ca50412,0x408ff1ae3b27bf3b,1 +np.float64,0x3fe2f2d50b65e5aa,0xbfe831042e6a1e99,1 +np.float64,0x3faa437bac3486f7,0xc01123d8d962205a,1 +np.float64,0x3feea54434fd4a88,0xbfaff202cc456647,1 +np.float64,0x3fc9e65b8633ccb7,0xc00270e77ffd19da,1 +np.float64,0x7fee15af61fc2b5e,0x408fff49a49154a3,1 +np.float64,0x7fefe670a73fcce0,0x408ffff6c44c1005,1 +np.float64,0x3fc0832d0f21065a,0xc007a2dc2f25384a,1 +np.float64,0x3fecfc96bcb9f92d,0xbfc24367c3912620,1 +np.float64,0x3feb705682b6e0ad,0xbfcc65b1bb16f9c5,1 +np.float64,0x3fe185c4f9630b8a,0xbfebcdb401af67a4,1 +np.float64,0x3fb0a5a9f6214b54,0xc00f8ada2566a047,1 +np.float64,0x7fe2908cdda52119,0x408ff9b744861fb1,1 +np.float64,0x7fee776e183ceedb,0x408fff6ee7c2f86e,1 +np.float64,0x3fce1d608f3c3ac1,0xc000b3685d006474,1 +np.float64,0x7fecf92aa339f254,0x408ffeda6c998267,1 +np.float64,0xce13cb519c27a,0xc08ff280f02882a9,1 +np.float64,0x1,0xc090c80000000000,1 +np.float64,0x3fe485a8afa90b51,0xbfe4823265d5a50a,1 +np.float64,0x3feea60908bd4c12,0xbfafdf7ad7fe203f,1 +np.float64,0x3fd2253033a44a60,0xbffd187d0ec8d5b9,1 +np.float64,0x435338fc86a68,0xc08fff6a591059dd,1 +np.float64,0x7fce8763a73d0ec6,0x408fef74f1e715ff,1 +np.float64,0x3fbe5ddb783cbbb7,0xc0089acc5afa794b,1 +np.float64,0x7fe4cf19ada99e32,0x408ffb0877ca302b,1 +np.float64,0x3fe94c9ea1b2993d,0xbfd5b1c2e867b911,1 +np.float64,0x3fe75541c72eaa84,0xbfdd2a27aa117699,1 +np.float64,0x8000000000000001,0x7ff8000000000000,1 +np.float64,0x7fdbec7f2c37d8fd,0x408ff66d69a7f818,1 +np.float64,0x8ef10d091de22,0xc08ff6b9ca5094f8,1 +np.float64,0x3fea69025b74d205,0xbfd1b9fe2c252c70,1 +np.float64,0x562376d0ac46f,0xc08ffc924111cd31,1 +np.float64,0x8e8097ab1d013,0xc08ff6c2e2706f67,1 +np.float64,0x3fca6803ed34d008,0xc00237aef808825b,1 +np.float64,0x7fe8fe9067b1fd20,0x408ffd25f459a7d1,1 +np.float64,0x3f918e8c7f233,0xc0900009fe011d54,1 +np.float64,0x3fdfe773833fcee7,0xbff011bc1af87bb9,1 +np.float64,0xefffef6fdfffe,0xc08ff0beb0f09eb0,1 +np.float64,0x7fe64610282c8c1f,0x408ffbd17209db18,1 +np.float64,0xe66be8c1ccd7d,0xc08ff13706c056e1,1 +np.float64,0x2837e570506fd,0xc09002ae4dae0c1a,1 +np.float64,0x3febe3a081f7c741,0xbfc964171f2a5a47,1 +np.float64,0x3fe21ed09a243da1,0xbfea41342d29c3ff,1 +np.float64,0x3fe1596c8162b2d9,0xbfec431eee30823a,1 +np.float64,0x8f2b9a131e574,0xc08ff6b51104ed4e,1 +np.float64,0x3fe88ed179711da3,0xbfd870d08a4a4b0c,1 +np.float64,0x34159bc2682b4,0xc09001305a885f94,1 +np.float64,0x1ed31e543da65,0xc0900437481577f8,1 +np.float64,0x3feafbe9de75f7d4,0xbfcf7bcdbacf1c61,1 +np.float64,0xfb16fb27f62e0,0xc08ff03938e682a2,1 +np.float64,0x3fe5cd5ba7eb9ab7,0xbfe1b7165771af3c,1 +np.float64,0x7fe72905e76e520b,0x408ffc44c4e7e80c,1 +np.float64,0x7fb7136e2e2e26db,0x408fe439fd383fb7,1 +np.float64,0x8fa585e11f4c,0xc0900b55a08a486b,1 +np.float64,0x7fed985ce47b30b9,0x408fff192b596821,1 +np.float64,0x3feaaf0869755e11,0xbfd0c671571b3764,1 +np.float64,0x3fa40fd4ec281faa,0xc012b1c8dc0b9e5f,1 +np.float64,0x7fda2a70993454e0,0x408ff5ad47b0c68a,1 +np.float64,0x3fe5f7e931abefd2,0xbfe15d52b3605abf,1 +np.float64,0x3fe9fc6d3533f8da,0xbfd338b06a790994,1 +np.float64,0x3fe060649420c0c9,0xbfeeed1756111891,1 +np.float64,0x3fce8435e33d086c,0xc0008c41cea9ed40,1 +np.float64,0x7ff8000000000000,0x7ff8000000000000,1 +np.float64,0x617820aec2f05,0xc08ffb251e9af0f0,1 +np.float64,0x7fcc4ab6ee38956d,0x408fee9419c8f77d,1 +np.float64,0x7fdefda2fc3dfb45,0x408ff7a15063bc05,1 +np.float64,0x7fe5138ccaaa2719,0x408ffb2e30f3a46e,1 +np.float64,0x3fe3817a836702f5,0xbfe6da7c2b25e35a,1 +np.float64,0x3fb8a7dafa314fb6,0xc00b025bc0784ebe,1 +np.float64,0x349dc420693d,0xc09011215825d2c8,1 +np.float64,0x6b0e504ad61cb,0xc08ffa0fee9c5cd6,1 +np.float64,0x273987644e732,0xc09002d34294ed79,1 +np.float64,0x3fc0bd8a6e217b15,0xc0077a5828b4d2f5,1 +np.float64,0x758b48c4eb16a,0xc08ff8fbc8fbe46a,1 +np.float64,0x3fc8a9a52631534a,0xc00301854ec0ef81,1 +np.float64,0x7fe79d29a76f3a52,0x408ffc7e1607a4c1,1 +np.float64,0x3fd7d3ebce2fa7d8,0xbff6ce8a94aebcda,1 +np.float64,0x7fd1cb68a52396d0,0x408ff13a17533b2b,1 +np.float64,0x7fda514a5d34a294,0x408ff5be5e081578,1 +np.float64,0x3fc40b4382281687,0xc0056632c8067228,1 +np.float64,0x7feff1208c3fe240,0x408ffffaa180fa0d,1 +np.float64,0x8f58739f1eb0f,0xc08ff6b17402689d,1 +np.float64,0x1fdbe9a23fb7e,0xc090040685b2d24f,1 +np.float64,0xcb1d0e87963a2,0xc08ff2abbd903b82,1 +np.float64,0x3fc45a6a1a28b4d4,0xc00538f86c4aeaee,1 +np.float64,0x3fe61885b1ac310b,0xbfe118fd2251d2ec,1 +np.float64,0x3fedf584c8fbeb0a,0xbfb8572433ff67a9,1 +np.float64,0x7fb0bddd1a217bb9,0x408fe085e0d621db,1 +np.float64,0x72d8d3e0e5b3,0xc0900ca02f68c7a1,1 +np.float64,0x5cca6ff6b994f,0xc08ffbb6751fda01,1 +np.float64,0x7fe3197839a632ef,0x408ffa0b2fccfb68,1 +np.float64,0x3fcce4d9c139c9b4,0xc0012dae05baa91b,1 +np.float64,0x3fe76d00f62eda02,0xbfdccc5f12799be1,1 +np.float64,0x3fc53c22f72a7846,0xc004bbaa9cbc7958,1 +np.float64,0x7fdda02f1ebb405d,0x408ff71c37c71659,1 +np.float64,0x3fe0844eaba1089d,0xbfee884722762583,1 +np.float64,0x3febb438dc776872,0xbfca9f05e1c691f1,1 +np.float64,0x3fdf4170cdbe82e2,0xbff08b1561c8d848,1 +np.float64,0x3fce1b8d6f3c371b,0xc000b41b69507671,1 +np.float64,0x8370e60706e1d,0xc08ff7b19ea0b4ca,1 +np.float64,0x7fa5bf92382b7f23,0x408fdb8aebb3df87,1 +np.float64,0x7fe4a59979a94b32,0x408ffaf15c1358cd,1 +np.float64,0x3faa66086034cc11,0xc0111c466b7835d6,1 +np.float64,0x7fb7a958262f52af,0x408fe48408b1e093,1 +np.float64,0x3fdaacc5f635598c,0xbff43390d06b5614,1 +np.float64,0x3fd2825b9e2504b7,0xbffca3234264f109,1 +np.float64,0x3fcede160a3dbc2c,0xc0006a759e29060c,1 +np.float64,0x7fd3b19603a7632b,0x408ff265b528371c,1 +np.float64,0x7fcf8a86ea3f150d,0x408fefd552e7f3b2,1 +np.float64,0xedbcc0f7db798,0xc08ff0daad12096b,1 +np.float64,0xf1e1683de3c2d,0xc08ff0a7a0a37e00,1 +np.float64,0xb6ebd9bf6dd7b,0xc08ff3e11e28378d,1 +np.float64,0x3fec8090d6f90122,0xbfc56031b72194cc,1 +np.float64,0x3fd3e10e37a7c21c,0xbffafd34a3ebc933,1 +np.float64,0x7fbb1c96aa36392c,0x408fe616347b3342,1 +np.float64,0x3fe2f3996f25e733,0xbfe82f25bc5d1bbd,1 +np.float64,0x7fe8709da870e13a,0x408ffce3ab6ce59a,1 +np.float64,0x7fea3233d1b46467,0x408ffdb0b3bbc6de,1 +np.float64,0x65fa4112cbf49,0xc08ffa9f85eb72b9,1 +np.float64,0x3fca2cae9f34595d,0xc00251bb275afb87,1 +np.float64,0x8135fd9f026c0,0xc08ff7e42e14dce7,1 +np.float64,0x7fe0a6f057e14de0,0x408ff876081a4bfe,1 +np.float64,0x10000000000000,0xc08ff00000000000,1 +np.float64,0x3fe1fd506263faa1,0xbfea96dd8c543b72,1 +np.float64,0xa5532c554aa66,0xc08ff50bf5bfc66d,1 +np.float64,0xc239d00b8473a,0xc08ff32ff0ea3f92,1 +np.float64,0x7fdb5314e336a629,0x408ff62d4ff60d82,1 +np.float64,0x3fe5f506e2abea0e,0xbfe16362a4682120,1 +np.float64,0x3fa20c60202418c0,0xc0134e08d82608b6,1 +np.float64,0x7fe03864b22070c8,0x408ff82866d65e9a,1 +np.float64,0x3fe72cf5656e59eb,0xbfddca298969effa,1 +np.float64,0x5c295386b852b,0xc08ffbca90b136c9,1 +np.float64,0x7fd71e5020ae3c9f,0x408ff43f6d58eb7c,1 +np.float64,0x3fd1905a842320b5,0xbffdd8ecd288159c,1 +np.float64,0x3fe6bddb256d7bb6,0xbfdf88fee1a820bb,1 +np.float64,0xe061b967c0c37,0xc08ff18581951561,1 +np.float64,0x3fe534f65cea69ed,0xbfe2fe45fe7d3040,1 +np.float64,0xdc7dae07b8fb6,0xc08ff1b93074ea76,1 +np.float64,0x3fd0425082a084a1,0xbfffa11838b21633,1 +np.float64,0xba723fc974e48,0xc08ff3a8b8d01c58,1 +np.float64,0x3fce42ffc73c8600,0xc000a5062678406e,1 +np.float64,0x3f2e6d3c7e5ce,0xc090001304cfd1c7,1 +np.float64,0x3fd4b2e5f7a965cc,0xbffa0e6e6bae0a68,1 +np.float64,0x3fe6db1d18edb63a,0xbfdf128158ee92d9,1 +np.float64,0x7fe4e5792f29caf1,0x408ffb14d9dbf133,1 +np.float64,0x3fc11cdf992239bf,0xc00739569619cd77,1 +np.float64,0x3fc05ea11220bd42,0xc007bc841b48a890,1 +np.float64,0x4bd592d497ab3,0xc08ffe0ab1c962e2,1 +np.float64,0x280068fc5000e,0xc09002b64955e865,1 +np.float64,0x7fe2f2637065e4c6,0x408ff9f379c1253a,1 +np.float64,0x3fefc38467ff8709,0xbf85e53e64b9a424,1 +np.float64,0x2d78ec5a5af1e,0xc09001f8ea8601e0,1 +np.float64,0x7feeef2b957dde56,0x408fff9bebe995f7,1 +np.float64,0x2639baf44c738,0xc09002f9618d623b,1 +np.float64,0x3fc562964d2ac52d,0xc004a6d76959ef78,1 +np.float64,0x3fe21b071fe4360e,0xbfea4adb2cd96ade,1 +np.float64,0x7fe56aa6802ad54c,0x408ffb5d81d1a898,1 +np.float64,0x4296b452852d7,0xc08fff8ad7fbcbe1,1 +np.float64,0x7fe3fac4ff27f589,0x408ffa9049eec479,1 +np.float64,0x7fe7a83e6caf507c,0x408ffc837f436604,1 +np.float64,0x3fc4ac5b872958b7,0xc0050add72381ac3,1 +np.float64,0x3fd6d697c02dad30,0xbff7c931a3eefb01,1 +np.float64,0x3f61e391c023c724,0xc021ad91e754f94b,1 +np.float64,0x10817f9c21031,0xc09007d20434d7bc,1 +np.float64,0x3fdb9c4c4cb73899,0xbff367d8615c5ece,1 +np.float64,0x3fe26ead6b64dd5b,0xbfe977771def5989,1 +np.float64,0x3fc43ea5c3287d4c,0xc00548c2163ae631,1 +np.float64,0x3fe05bd8bba0b7b1,0xbfeef9ea0db91abc,1 +np.float64,0x3feac78369358f07,0xbfd071e2b0aeab39,1 +np.float64,0x7fe254922ca4a923,0x408ff991bdd4e5d3,1 +np.float64,0x3fe5a2f5842b45eb,0xbfe21135c9a71666,1 +np.float64,0x3fd5daf98c2bb5f3,0xbff8cd24f7c07003,1 +np.float64,0x3fcb2a1384365427,0xc001e40f0d04299a,1 +np.float64,0x3fe073974360e72f,0xbfeeb7183a9930b7,1 +np.float64,0xcf3440819e688,0xc08ff270d3a71001,1 +np.float64,0x3fd35656cda6acae,0xbffba083fba4939d,1 +np.float64,0x7fe6c59b4ded8b36,0x408ffc12ce725425,1 +np.float64,0x3fba896f943512df,0xc00a291cb6947701,1 +np.float64,0x7fe54917e86a922f,0x408ffb4b5e0fb848,1 +np.float64,0x7fed2a3f51ba547e,0x408ffeede945a948,1 +np.float64,0x3fdc72bd5038e57b,0xbff2b73b7e93e209,1 +np.float64,0x7fefdb3f9f3fb67e,0x408ffff2b702a768,1 +np.float64,0x3fb0184430203088,0xc00fee8c1351763c,1 +np.float64,0x7d6c3668fad87,0xc08ff83c195f2cca,1 +np.float64,0x3fd5aa254aab544b,0xbff900f16365991b,1 +np.float64,0x3f963daab02c7b55,0xc0161974495b1b71,1 +np.float64,0x3fa7a9c5982f538b,0xc011bde0f6052a89,1 +np.float64,0xb3a5a74b674b5,0xc08ff4167bc97c81,1 +np.float64,0x7fad0c14503a1828,0x408fdee1f2d56cd7,1 +np.float64,0x43e0e9d887c1e,0xc08fff522837b13b,1 +np.float64,0x3fe513b20aea2764,0xbfe346ea994100e6,1 +np.float64,0x7fe4e10393e9c206,0x408ffb12630f6a06,1 +np.float64,0x68b286e2d1651,0xc08ffa51c0d795d4,1 +np.float64,0x7fe8de453331bc89,0x408ffd17012b75ac,1 +np.float64,0x1b3d77d4367b0,0xc09004edea60aa36,1 +np.float64,0x3fd351cbc326a398,0xbffba5f0f4d5fdba,1 +np.float64,0x3fd264951b24c92a,0xbffcc8636788b9bf,1 +np.float64,0xd2465761a48cb,0xc08ff2455c9c53e5,1 +np.float64,0x7fe46a0ef028d41d,0x408ffacfe32c6f5d,1 +np.float64,0x3fafd8ac4c3fb159,0xc010071bf33195d0,1 +np.float64,0x902aec5d2055e,0xc08ff6a08e28aabc,1 +np.float64,0x3fcea61bb03d4c37,0xc0007f76e509b657,1 +np.float64,0x7fe8d90f9571b21e,0x408ffd1495f952e7,1 +np.float64,0x7fa650c9442ca192,0x408fdbd6ff22fdd8,1 +np.float64,0x3fe8ecfdf171d9fc,0xbfd7115df40e8580,1 +np.float64,0x7fd4e6fe7f29cdfc,0x408ff315b0dae183,1 +np.float64,0x77df4c52efbea,0xc08ff8c1d5c1df33,1 +np.float64,0xe200b0cfc4016,0xc08ff1703cfb8e79,1 +np.float64,0x3fe230ea7e2461d5,0xbfea132d2385160e,1 +np.float64,0x7fd1f7ced723ef9d,0x408ff156bfbf92a4,1 +np.float64,0x3fea762818f4ec50,0xbfd18c12a88e5f79,1 +np.float64,0x7feea4ba7c7d4974,0x408fff8004164054,1 +np.float64,0x833ec605067d9,0xc08ff7b606383841,1 +np.float64,0x7fd0c2d7fea185af,0x408ff0894f3a0cf4,1 +np.float64,0x3fe1d7d61d23afac,0xbfeaf76fee875d3e,1 +np.float64,0x65adecb0cb5be,0xc08ffaa82cb09d68,1 diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/data/umath-validation-set-sin.csv b/venv/lib/python3.12/site-packages/numpy/_core/tests/data/umath-validation-set-sin.csv new file mode 100644 index 00000000..03e76ffc --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/tests/data/umath-validation-set-sin.csv @@ -0,0 +1,1370 @@ +dtype,input,output,ulperrortol +## +ve denormals ## +np.float32,0x004b4716,0x004b4716,2 +np.float32,0x007b2490,0x007b2490,2 +np.float32,0x007c99fa,0x007c99fa,2 +np.float32,0x00734a0c,0x00734a0c,2 +np.float32,0x0070de24,0x0070de24,2 +np.float32,0x007fffff,0x007fffff,2 +np.float32,0x00000001,0x00000001,2 +## -ve denormals ## +np.float32,0x80495d65,0x80495d65,2 +np.float32,0x806894f6,0x806894f6,2 +np.float32,0x80555a76,0x80555a76,2 +np.float32,0x804e1fb8,0x804e1fb8,2 +np.float32,0x80687de9,0x80687de9,2 +np.float32,0x807fffff,0x807fffff,2 +np.float32,0x80000001,0x80000001,2 +## +/-0.0f, +/-FLT_MIN +/-FLT_MAX ## +np.float32,0x00000000,0x00000000,2 +np.float32,0x80000000,0x80000000,2 +np.float32,0x00800000,0x00800000,2 +np.float32,0x80800000,0x80800000,2 +## 1.00f ## +np.float32,0x3f800000,0x3f576aa4,2 +np.float32,0x3f800001,0x3f576aa6,2 +np.float32,0x3f800002,0x3f576aa7,2 +np.float32,0xc090a8b0,0x3f7b4e48,2 +np.float32,0x41ce3184,0x3f192d43,2 +np.float32,0xc1d85848,0xbf7161cb,2 +np.float32,0x402b8820,0x3ee3f29f,2 +np.float32,0x42b4e454,0x3f1d0151,2 +np.float32,0x42a67a60,0x3f7ffa4c,2 +np.float32,0x41d92388,0x3f67beef,2 +np.float32,0x422dd66c,0xbeffb0c1,2 +np.float32,0xc28f5be6,0xbf0bae79,2 +np.float32,0x41ab2674,0x3f0ffe2b,2 +np.float32,0x3f490fdb,0x3f3504f3,2 +np.float32,0xbf490fdb,0xbf3504f3,2 +np.float32,0x3fc90fdb,0x3f800000,2 +np.float32,0xbfc90fdb,0xbf800000,2 +np.float32,0x40490fdb,0xb3bbbd2e,2 +np.float32,0xc0490fdb,0x33bbbd2e,2 +np.float32,0x3fc90fdb,0x3f800000,2 +np.float32,0xbfc90fdb,0xbf800000,2 +np.float32,0x40490fdb,0xb3bbbd2e,2 +np.float32,0xc0490fdb,0x33bbbd2e,2 +np.float32,0x40c90fdb,0x343bbd2e,2 +np.float32,0xc0c90fdb,0xb43bbd2e,2 +np.float32,0x4016cbe4,0x3f3504f3,2 +np.float32,0xc016cbe4,0xbf3504f3,2 +np.float32,0x4096cbe4,0xbf800000,2 +np.float32,0xc096cbe4,0x3f800000,2 +np.float32,0x4116cbe4,0xb2ccde2e,2 +np.float32,0xc116cbe4,0x32ccde2e,2 +np.float32,0x40490fdb,0xb3bbbd2e,2 +np.float32,0xc0490fdb,0x33bbbd2e,2 +np.float32,0x40c90fdb,0x343bbd2e,2 +np.float32,0xc0c90fdb,0xb43bbd2e,2 +np.float32,0x41490fdb,0x34bbbd2e,2 +np.float32,0xc1490fdb,0xb4bbbd2e,2 +np.float32,0x407b53d2,0xbf3504f5,2 +np.float32,0xc07b53d2,0x3f3504f5,2 +np.float32,0x40fb53d2,0x3f800000,2 +np.float32,0xc0fb53d2,0xbf800000,2 +np.float32,0x417b53d2,0xb535563d,2 +np.float32,0xc17b53d2,0x3535563d,2 +np.float32,0x4096cbe4,0xbf800000,2 +np.float32,0xc096cbe4,0x3f800000,2 +np.float32,0x4116cbe4,0xb2ccde2e,2 +np.float32,0xc116cbe4,0x32ccde2e,2 +np.float32,0x4196cbe4,0x334cde2e,2 +np.float32,0xc196cbe4,0xb34cde2e,2 +np.float32,0x40afede0,0xbf3504ef,2 +np.float32,0xc0afede0,0x3f3504ef,2 +np.float32,0x412fede0,0xbf800000,2 +np.float32,0xc12fede0,0x3f800000,2 +np.float32,0x41afede0,0xb5b222c4,2 +np.float32,0xc1afede0,0x35b222c4,2 +np.float32,0x40c90fdb,0x343bbd2e,2 +np.float32,0xc0c90fdb,0xb43bbd2e,2 +np.float32,0x41490fdb,0x34bbbd2e,2 +np.float32,0xc1490fdb,0xb4bbbd2e,2 +np.float32,0x41c90fdb,0x353bbd2e,2 +np.float32,0xc1c90fdb,0xb53bbd2e,2 +np.float32,0x40e231d6,0x3f3504f3,2 +np.float32,0xc0e231d6,0xbf3504f3,2 +np.float32,0x416231d6,0x3f800000,2 +np.float32,0xc16231d6,0xbf800000,2 +np.float32,0x41e231d6,0xb399a6a2,2 +np.float32,0xc1e231d6,0x3399a6a2,2 +np.float32,0x40fb53d2,0x3f800000,2 +np.float32,0xc0fb53d2,0xbf800000,2 +np.float32,0x417b53d2,0xb535563d,2 +np.float32,0xc17b53d2,0x3535563d,2 +np.float32,0x41fb53d2,0x35b5563d,2 +np.float32,0xc1fb53d2,0xb5b5563d,2 +np.float32,0x410a3ae7,0x3f3504eb,2 +np.float32,0xc10a3ae7,0xbf3504eb,2 +np.float32,0x418a3ae7,0xbf800000,2 +np.float32,0xc18a3ae7,0x3f800000,2 +np.float32,0x420a3ae7,0xb6308908,2 +np.float32,0xc20a3ae7,0x36308908,2 +np.float32,0x4116cbe4,0xb2ccde2e,2 +np.float32,0xc116cbe4,0x32ccde2e,2 +np.float32,0x4196cbe4,0x334cde2e,2 +np.float32,0xc196cbe4,0xb34cde2e,2 +np.float32,0x4216cbe4,0x33ccde2e,2 +np.float32,0xc216cbe4,0xb3ccde2e,2 +np.float32,0x41235ce2,0xbf3504f7,2 +np.float32,0xc1235ce2,0x3f3504f7,2 +np.float32,0x41a35ce2,0x3f800000,2 +np.float32,0xc1a35ce2,0xbf800000,2 +np.float32,0x42235ce2,0xb5b889b6,2 +np.float32,0xc2235ce2,0x35b889b6,2 +np.float32,0x412fede0,0xbf800000,2 +np.float32,0xc12fede0,0x3f800000,2 +np.float32,0x41afede0,0xb5b222c4,2 +np.float32,0xc1afede0,0x35b222c4,2 +np.float32,0x422fede0,0x363222c4,2 +np.float32,0xc22fede0,0xb63222c4,2 +np.float32,0x413c7edd,0xbf3504f3,2 +np.float32,0xc13c7edd,0x3f3504f3,2 +np.float32,0x41bc7edd,0xbf800000,2 +np.float32,0xc1bc7edd,0x3f800000,2 +np.float32,0x423c7edd,0xb4000add,2 +np.float32,0xc23c7edd,0x34000add,2 +np.float32,0x41490fdb,0x34bbbd2e,2 +np.float32,0xc1490fdb,0xb4bbbd2e,2 +np.float32,0x41c90fdb,0x353bbd2e,2 +np.float32,0xc1c90fdb,0xb53bbd2e,2 +np.float32,0x42490fdb,0x35bbbd2e,2 +np.float32,0xc2490fdb,0xb5bbbd2e,2 +np.float32,0x4155a0d9,0x3f3504fb,2 +np.float32,0xc155a0d9,0xbf3504fb,2 +np.float32,0x41d5a0d9,0x3f800000,2 +np.float32,0xc1d5a0d9,0xbf800000,2 +np.float32,0x4255a0d9,0xb633bc81,2 +np.float32,0xc255a0d9,0x3633bc81,2 +np.float32,0x416231d6,0x3f800000,2 +np.float32,0xc16231d6,0xbf800000,2 +np.float32,0x41e231d6,0xb399a6a2,2 +np.float32,0xc1e231d6,0x3399a6a2,2 +np.float32,0x426231d6,0x3419a6a2,2 +np.float32,0xc26231d6,0xb419a6a2,2 +np.float32,0x416ec2d4,0x3f3504ef,2 +np.float32,0xc16ec2d4,0xbf3504ef,2 +np.float32,0x41eec2d4,0xbf800000,2 +np.float32,0xc1eec2d4,0x3f800000,2 +np.float32,0x426ec2d4,0xb5bef0a7,2 +np.float32,0xc26ec2d4,0x35bef0a7,2 +np.float32,0x417b53d2,0xb535563d,2 +np.float32,0xc17b53d2,0x3535563d,2 +np.float32,0x41fb53d2,0x35b5563d,2 +np.float32,0xc1fb53d2,0xb5b5563d,2 +np.float32,0x427b53d2,0x3635563d,2 +np.float32,0xc27b53d2,0xb635563d,2 +np.float32,0x4183f268,0xbf3504ff,2 +np.float32,0xc183f268,0x3f3504ff,2 +np.float32,0x4203f268,0x3f800000,2 +np.float32,0xc203f268,0xbf800000,2 +np.float32,0x4283f268,0xb6859a13,2 +np.float32,0xc283f268,0x36859a13,2 +np.float32,0x418a3ae7,0xbf800000,2 +np.float32,0xc18a3ae7,0x3f800000,2 +np.float32,0x420a3ae7,0xb6308908,2 +np.float32,0xc20a3ae7,0x36308908,2 +np.float32,0x428a3ae7,0x36b08908,2 +np.float32,0xc28a3ae7,0xb6b08908,2 +np.float32,0x41908365,0xbf3504f6,2 +np.float32,0xc1908365,0x3f3504f6,2 +np.float32,0x42108365,0xbf800000,2 +np.float32,0xc2108365,0x3f800000,2 +np.float32,0x42908365,0x3592200d,2 +np.float32,0xc2908365,0xb592200d,2 +np.float32,0x4196cbe4,0x334cde2e,2 +np.float32,0xc196cbe4,0xb34cde2e,2 +np.float32,0x4216cbe4,0x33ccde2e,2 +np.float32,0xc216cbe4,0xb3ccde2e,2 +np.float32,0x4296cbe4,0x344cde2e,2 +np.float32,0xc296cbe4,0xb44cde2e,2 +np.float32,0x419d1463,0x3f3504f8,2 +np.float32,0xc19d1463,0xbf3504f8,2 +np.float32,0x421d1463,0x3f800000,2 +np.float32,0xc21d1463,0xbf800000,2 +np.float32,0x429d1463,0xb5c55799,2 +np.float32,0xc29d1463,0x35c55799,2 +np.float32,0x41a35ce2,0x3f800000,2 +np.float32,0xc1a35ce2,0xbf800000,2 +np.float32,0x42235ce2,0xb5b889b6,2 +np.float32,0xc2235ce2,0x35b889b6,2 +np.float32,0x42a35ce2,0x363889b6,2 +np.float32,0xc2a35ce2,0xb63889b6,2 +np.float32,0x41a9a561,0x3f3504e7,2 +np.float32,0xc1a9a561,0xbf3504e7,2 +np.float32,0x4229a561,0xbf800000,2 +np.float32,0xc229a561,0x3f800000,2 +np.float32,0x42a9a561,0xb68733d0,2 +np.float32,0xc2a9a561,0x368733d0,2 +np.float32,0x41afede0,0xb5b222c4,2 +np.float32,0xc1afede0,0x35b222c4,2 +np.float32,0x422fede0,0x363222c4,2 +np.float32,0xc22fede0,0xb63222c4,2 +np.float32,0x42afede0,0x36b222c4,2 +np.float32,0xc2afede0,0xb6b222c4,2 +np.float32,0x41b6365e,0xbf3504f0,2 +np.float32,0xc1b6365e,0x3f3504f0,2 +np.float32,0x4236365e,0x3f800000,2 +np.float32,0xc236365e,0xbf800000,2 +np.float32,0x42b6365e,0x358bb91c,2 +np.float32,0xc2b6365e,0xb58bb91c,2 +np.float32,0x41bc7edd,0xbf800000,2 +np.float32,0xc1bc7edd,0x3f800000,2 +np.float32,0x423c7edd,0xb4000add,2 +np.float32,0xc23c7edd,0x34000add,2 +np.float32,0x42bc7edd,0x34800add,2 +np.float32,0xc2bc7edd,0xb4800add,2 +np.float32,0x41c2c75c,0xbf3504ef,2 +np.float32,0xc1c2c75c,0x3f3504ef,2 +np.float32,0x4242c75c,0xbf800000,2 +np.float32,0xc242c75c,0x3f800000,2 +np.float32,0x42c2c75c,0xb5cbbe8a,2 +np.float32,0xc2c2c75c,0x35cbbe8a,2 +np.float32,0x41c90fdb,0x353bbd2e,2 +np.float32,0xc1c90fdb,0xb53bbd2e,2 +np.float32,0x42490fdb,0x35bbbd2e,2 +np.float32,0xc2490fdb,0xb5bbbd2e,2 +np.float32,0x42c90fdb,0x363bbd2e,2 +np.float32,0xc2c90fdb,0xb63bbd2e,2 +np.float32,0x41cf585a,0x3f3504ff,2 +np.float32,0xc1cf585a,0xbf3504ff,2 +np.float32,0x424f585a,0x3f800000,2 +np.float32,0xc24f585a,0xbf800000,2 +np.float32,0x42cf585a,0xb688cd8c,2 +np.float32,0xc2cf585a,0x3688cd8c,2 +np.float32,0x41d5a0d9,0x3f800000,2 +np.float32,0xc1d5a0d9,0xbf800000,2 +np.float32,0x4255a0d9,0xb633bc81,2 +np.float32,0xc255a0d9,0x3633bc81,2 +np.float32,0x42d5a0d9,0x36b3bc81,2 +np.float32,0xc2d5a0d9,0xb6b3bc81,2 +np.float32,0x41dbe958,0x3f3504e0,2 +np.float32,0xc1dbe958,0xbf3504e0,2 +np.float32,0x425be958,0xbf800000,2 +np.float32,0xc25be958,0x3f800000,2 +np.float32,0x42dbe958,0xb6deab75,2 +np.float32,0xc2dbe958,0x36deab75,2 +np.float32,0x41e231d6,0xb399a6a2,2 +np.float32,0xc1e231d6,0x3399a6a2,2 +np.float32,0x426231d6,0x3419a6a2,2 +np.float32,0xc26231d6,0xb419a6a2,2 +np.float32,0x42e231d6,0x3499a6a2,2 +np.float32,0xc2e231d6,0xb499a6a2,2 +np.float32,0x41e87a55,0xbf3504f8,2 +np.float32,0xc1e87a55,0x3f3504f8,2 +np.float32,0x42687a55,0x3f800000,2 +np.float32,0xc2687a55,0xbf800000,2 +np.float32,0x42e87a55,0xb5d2257b,2 +np.float32,0xc2e87a55,0x35d2257b,2 +np.float32,0x41eec2d4,0xbf800000,2 +np.float32,0xc1eec2d4,0x3f800000,2 +np.float32,0x426ec2d4,0xb5bef0a7,2 +np.float32,0xc26ec2d4,0x35bef0a7,2 +np.float32,0x42eec2d4,0x363ef0a7,2 +np.float32,0xc2eec2d4,0xb63ef0a7,2 +np.float32,0x41f50b53,0xbf3504e7,2 +np.float32,0xc1f50b53,0x3f3504e7,2 +np.float32,0x42750b53,0xbf800000,2 +np.float32,0xc2750b53,0x3f800000,2 +np.float32,0x42f50b53,0xb68a6748,2 +np.float32,0xc2f50b53,0x368a6748,2 +np.float32,0x41fb53d2,0x35b5563d,2 +np.float32,0xc1fb53d2,0xb5b5563d,2 +np.float32,0x427b53d2,0x3635563d,2 +np.float32,0xc27b53d2,0xb635563d,2 +np.float32,0x42fb53d2,0x36b5563d,2 +np.float32,0xc2fb53d2,0xb6b5563d,2 +np.float32,0x4200ce28,0x3f3504f0,2 +np.float32,0xc200ce28,0xbf3504f0,2 +np.float32,0x4280ce28,0x3f800000,2 +np.float32,0xc280ce28,0xbf800000,2 +np.float32,0x4300ce28,0x357dd672,2 +np.float32,0xc300ce28,0xb57dd672,2 +np.float32,0x4203f268,0x3f800000,2 +np.float32,0xc203f268,0xbf800000,2 +np.float32,0x4283f268,0xb6859a13,2 +np.float32,0xc283f268,0x36859a13,2 +np.float32,0x4303f268,0x37059a13,2 +np.float32,0xc303f268,0xb7059a13,2 +np.float32,0x420716a7,0x3f3504ee,2 +np.float32,0xc20716a7,0xbf3504ee,2 +np.float32,0x428716a7,0xbf800000,2 +np.float32,0xc28716a7,0x3f800000,2 +np.float32,0x430716a7,0xb5d88c6d,2 +np.float32,0xc30716a7,0x35d88c6d,2 +np.float32,0x420a3ae7,0xb6308908,2 +np.float32,0xc20a3ae7,0x36308908,2 +np.float32,0x428a3ae7,0x36b08908,2 +np.float32,0xc28a3ae7,0xb6b08908,2 +np.float32,0x430a3ae7,0x37308908,2 +np.float32,0xc30a3ae7,0xb7308908,2 +np.float32,0x420d5f26,0xbf350500,2 +np.float32,0xc20d5f26,0x3f350500,2 +np.float32,0x428d5f26,0x3f800000,2 +np.float32,0xc28d5f26,0xbf800000,2 +np.float32,0x430d5f26,0xb68c0105,2 +np.float32,0xc30d5f26,0x368c0105,2 +np.float32,0x42108365,0xbf800000,2 +np.float32,0xc2108365,0x3f800000,2 +np.float32,0x42908365,0x3592200d,2 +np.float32,0xc2908365,0xb592200d,2 +np.float32,0x43108365,0xb612200d,2 +np.float32,0xc3108365,0x3612200d,2 +np.float32,0x4213a7a5,0xbf3504df,2 +np.float32,0xc213a7a5,0x3f3504df,2 +np.float32,0x4293a7a5,0xbf800000,2 +np.float32,0xc293a7a5,0x3f800000,2 +np.float32,0x4313a7a5,0xb6e1deee,2 +np.float32,0xc313a7a5,0x36e1deee,2 +np.float32,0x4216cbe4,0x33ccde2e,2 +np.float32,0xc216cbe4,0xb3ccde2e,2 +np.float32,0x4296cbe4,0x344cde2e,2 +np.float32,0xc296cbe4,0xb44cde2e,2 +np.float32,0x4316cbe4,0x34ccde2e,2 +np.float32,0xc316cbe4,0xb4ccde2e,2 +np.float32,0x4219f024,0x3f35050f,2 +np.float32,0xc219f024,0xbf35050f,2 +np.float32,0x4299f024,0x3f800000,2 +np.float32,0xc299f024,0xbf800000,2 +np.float32,0x4319f024,0xb71bde6c,2 +np.float32,0xc319f024,0x371bde6c,2 +np.float32,0x421d1463,0x3f800000,2 +np.float32,0xc21d1463,0xbf800000,2 +np.float32,0x429d1463,0xb5c55799,2 +np.float32,0xc29d1463,0x35c55799,2 +np.float32,0x431d1463,0x36455799,2 +np.float32,0xc31d1463,0xb6455799,2 +np.float32,0x422038a3,0x3f3504d0,2 +np.float32,0xc22038a3,0xbf3504d0,2 +np.float32,0x42a038a3,0xbf800000,2 +np.float32,0xc2a038a3,0x3f800000,2 +np.float32,0x432038a3,0xb746cd61,2 +np.float32,0xc32038a3,0x3746cd61,2 +np.float32,0x42235ce2,0xb5b889b6,2 +np.float32,0xc2235ce2,0x35b889b6,2 +np.float32,0x42a35ce2,0x363889b6,2 +np.float32,0xc2a35ce2,0xb63889b6,2 +np.float32,0x43235ce2,0x36b889b6,2 +np.float32,0xc3235ce2,0xb6b889b6,2 +np.float32,0x42268121,0xbf3504f1,2 +np.float32,0xc2268121,0x3f3504f1,2 +np.float32,0x42a68121,0x3f800000,2 +np.float32,0xc2a68121,0xbf800000,2 +np.float32,0x43268121,0x35643aac,2 +np.float32,0xc3268121,0xb5643aac,2 +np.float32,0x4229a561,0xbf800000,2 +np.float32,0xc229a561,0x3f800000,2 +np.float32,0x42a9a561,0xb68733d0,2 +np.float32,0xc2a9a561,0x368733d0,2 +np.float32,0x4329a561,0x370733d0,2 +np.float32,0xc329a561,0xb70733d0,2 +np.float32,0x422cc9a0,0xbf3504ee,2 +np.float32,0xc22cc9a0,0x3f3504ee,2 +np.float32,0x42acc9a0,0xbf800000,2 +np.float32,0xc2acc9a0,0x3f800000,2 +np.float32,0x432cc9a0,0xb5e55a50,2 +np.float32,0xc32cc9a0,0x35e55a50,2 +np.float32,0x422fede0,0x363222c4,2 +np.float32,0xc22fede0,0xb63222c4,2 +np.float32,0x42afede0,0x36b222c4,2 +np.float32,0xc2afede0,0xb6b222c4,2 +np.float32,0x432fede0,0x373222c4,2 +np.float32,0xc32fede0,0xb73222c4,2 +np.float32,0x4233121f,0x3f350500,2 +np.float32,0xc233121f,0xbf350500,2 +np.float32,0x42b3121f,0x3f800000,2 +np.float32,0xc2b3121f,0xbf800000,2 +np.float32,0x4333121f,0xb68f347d,2 +np.float32,0xc333121f,0x368f347d,2 +np.float32,0x4236365e,0x3f800000,2 +np.float32,0xc236365e,0xbf800000,2 +np.float32,0x42b6365e,0x358bb91c,2 +np.float32,0xc2b6365e,0xb58bb91c,2 +np.float32,0x4336365e,0xb60bb91c,2 +np.float32,0xc336365e,0x360bb91c,2 +np.float32,0x42395a9e,0x3f3504df,2 +np.float32,0xc2395a9e,0xbf3504df,2 +np.float32,0x42b95a9e,0xbf800000,2 +np.float32,0xc2b95a9e,0x3f800000,2 +np.float32,0x43395a9e,0xb6e51267,2 +np.float32,0xc3395a9e,0x36e51267,2 +np.float32,0x423c7edd,0xb4000add,2 +np.float32,0xc23c7edd,0x34000add,2 +np.float32,0x42bc7edd,0x34800add,2 +np.float32,0xc2bc7edd,0xb4800add,2 +np.float32,0x433c7edd,0x35000add,2 +np.float32,0xc33c7edd,0xb5000add,2 +np.float32,0x423fa31d,0xbf35050f,2 +np.float32,0xc23fa31d,0x3f35050f,2 +np.float32,0x42bfa31d,0x3f800000,2 +np.float32,0xc2bfa31d,0xbf800000,2 +np.float32,0x433fa31d,0xb71d7828,2 +np.float32,0xc33fa31d,0x371d7828,2 +np.float32,0x4242c75c,0xbf800000,2 +np.float32,0xc242c75c,0x3f800000,2 +np.float32,0x42c2c75c,0xb5cbbe8a,2 +np.float32,0xc2c2c75c,0x35cbbe8a,2 +np.float32,0x4342c75c,0x364bbe8a,2 +np.float32,0xc342c75c,0xb64bbe8a,2 +np.float32,0x4245eb9c,0xbf3504d0,2 +np.float32,0xc245eb9c,0x3f3504d0,2 +np.float32,0x42c5eb9c,0xbf800000,2 +np.float32,0xc2c5eb9c,0x3f800000,2 +np.float32,0x4345eb9c,0xb748671d,2 +np.float32,0xc345eb9c,0x3748671d,2 +np.float32,0x42490fdb,0x35bbbd2e,2 +np.float32,0xc2490fdb,0xb5bbbd2e,2 +np.float32,0x42c90fdb,0x363bbd2e,2 +np.float32,0xc2c90fdb,0xb63bbd2e,2 +np.float32,0x43490fdb,0x36bbbd2e,2 +np.float32,0xc3490fdb,0xb6bbbd2e,2 +np.float32,0x424c341a,0x3f3504f1,2 +np.float32,0xc24c341a,0xbf3504f1,2 +np.float32,0x42cc341a,0x3f800000,2 +np.float32,0xc2cc341a,0xbf800000,2 +np.float32,0x434c341a,0x354a9ee6,2 +np.float32,0xc34c341a,0xb54a9ee6,2 +np.float32,0x424f585a,0x3f800000,2 +np.float32,0xc24f585a,0xbf800000,2 +np.float32,0x42cf585a,0xb688cd8c,2 +np.float32,0xc2cf585a,0x3688cd8c,2 +np.float32,0x434f585a,0x3708cd8c,2 +np.float32,0xc34f585a,0xb708cd8c,2 +np.float32,0x42527c99,0x3f3504ee,2 +np.float32,0xc2527c99,0xbf3504ee,2 +np.float32,0x42d27c99,0xbf800000,2 +np.float32,0xc2d27c99,0x3f800000,2 +np.float32,0x43527c99,0xb5f22833,2 +np.float32,0xc3527c99,0x35f22833,2 +np.float32,0x4255a0d9,0xb633bc81,2 +np.float32,0xc255a0d9,0x3633bc81,2 +np.float32,0x42d5a0d9,0x36b3bc81,2 +np.float32,0xc2d5a0d9,0xb6b3bc81,2 +np.float32,0x4355a0d9,0x3733bc81,2 +np.float32,0xc355a0d9,0xb733bc81,2 +np.float32,0x4258c518,0xbf350500,2 +np.float32,0xc258c518,0x3f350500,2 +np.float32,0x42d8c518,0x3f800000,2 +np.float32,0xc2d8c518,0xbf800000,2 +np.float32,0x4358c518,0xb69267f6,2 +np.float32,0xc358c518,0x369267f6,2 +np.float32,0x425be958,0xbf800000,2 +np.float32,0xc25be958,0x3f800000,2 +np.float32,0x42dbe958,0xb6deab75,2 +np.float32,0xc2dbe958,0x36deab75,2 +np.float32,0x435be958,0x375eab75,2 +np.float32,0xc35be958,0xb75eab75,2 +np.float32,0x425f0d97,0xbf3504df,2 +np.float32,0xc25f0d97,0x3f3504df,2 +np.float32,0x42df0d97,0xbf800000,2 +np.float32,0xc2df0d97,0x3f800000,2 +np.float32,0x435f0d97,0xb6e845e0,2 +np.float32,0xc35f0d97,0x36e845e0,2 +np.float32,0x426231d6,0x3419a6a2,2 +np.float32,0xc26231d6,0xb419a6a2,2 +np.float32,0x42e231d6,0x3499a6a2,2 +np.float32,0xc2e231d6,0xb499a6a2,2 +np.float32,0x436231d6,0x3519a6a2,2 +np.float32,0xc36231d6,0xb519a6a2,2 +np.float32,0x42655616,0x3f35050f,2 +np.float32,0xc2655616,0xbf35050f,2 +np.float32,0x42e55616,0x3f800000,2 +np.float32,0xc2e55616,0xbf800000,2 +np.float32,0x43655616,0xb71f11e5,2 +np.float32,0xc3655616,0x371f11e5,2 +np.float32,0x42687a55,0x3f800000,2 +np.float32,0xc2687a55,0xbf800000,2 +np.float32,0x42e87a55,0xb5d2257b,2 +np.float32,0xc2e87a55,0x35d2257b,2 +np.float32,0x43687a55,0x3652257b,2 +np.float32,0xc3687a55,0xb652257b,2 +np.float32,0x426b9e95,0x3f3504cf,2 +np.float32,0xc26b9e95,0xbf3504cf,2 +np.float32,0x42eb9e95,0xbf800000,2 +np.float32,0xc2eb9e95,0x3f800000,2 +np.float32,0x436b9e95,0xb74a00d9,2 +np.float32,0xc36b9e95,0x374a00d9,2 +np.float32,0x426ec2d4,0xb5bef0a7,2 +np.float32,0xc26ec2d4,0x35bef0a7,2 +np.float32,0x42eec2d4,0x363ef0a7,2 +np.float32,0xc2eec2d4,0xb63ef0a7,2 +np.float32,0x436ec2d4,0x36bef0a7,2 +np.float32,0xc36ec2d4,0xb6bef0a7,2 +np.float32,0x4271e713,0xbf3504f1,2 +np.float32,0xc271e713,0x3f3504f1,2 +np.float32,0x42f1e713,0x3f800000,2 +np.float32,0xc2f1e713,0xbf800000,2 +np.float32,0x4371e713,0x35310321,2 +np.float32,0xc371e713,0xb5310321,2 +np.float32,0x42750b53,0xbf800000,2 +np.float32,0xc2750b53,0x3f800000,2 +np.float32,0x42f50b53,0xb68a6748,2 +np.float32,0xc2f50b53,0x368a6748,2 +np.float32,0x43750b53,0x370a6748,2 +np.float32,0xc3750b53,0xb70a6748,2 +np.float32,0x42782f92,0xbf3504ee,2 +np.float32,0xc2782f92,0x3f3504ee,2 +np.float32,0x42f82f92,0xbf800000,2 +np.float32,0xc2f82f92,0x3f800000,2 +np.float32,0x43782f92,0xb5fef616,2 +np.float32,0xc3782f92,0x35fef616,2 +np.float32,0x427b53d2,0x3635563d,2 +np.float32,0xc27b53d2,0xb635563d,2 +np.float32,0x42fb53d2,0x36b5563d,2 +np.float32,0xc2fb53d2,0xb6b5563d,2 +np.float32,0x437b53d2,0x3735563d,2 +np.float32,0xc37b53d2,0xb735563d,2 +np.float32,0x427e7811,0x3f350500,2 +np.float32,0xc27e7811,0xbf350500,2 +np.float32,0x42fe7811,0x3f800000,2 +np.float32,0xc2fe7811,0xbf800000,2 +np.float32,0x437e7811,0xb6959b6f,2 +np.float32,0xc37e7811,0x36959b6f,2 +np.float32,0x4280ce28,0x3f800000,2 +np.float32,0xc280ce28,0xbf800000,2 +np.float32,0x4300ce28,0x357dd672,2 +np.float32,0xc300ce28,0xb57dd672,2 +np.float32,0x4380ce28,0xb5fdd672,2 +np.float32,0xc380ce28,0x35fdd672,2 +np.float32,0x42826048,0x3f3504de,2 +np.float32,0xc2826048,0xbf3504de,2 +np.float32,0x43026048,0xbf800000,2 +np.float32,0xc3026048,0x3f800000,2 +np.float32,0x43826048,0xb6eb7958,2 +np.float32,0xc3826048,0x36eb7958,2 +np.float32,0x4283f268,0xb6859a13,2 +np.float32,0xc283f268,0x36859a13,2 +np.float32,0x4303f268,0x37059a13,2 +np.float32,0xc303f268,0xb7059a13,2 +np.float32,0x4383f268,0x37859a13,2 +np.float32,0xc383f268,0xb7859a13,2 +np.float32,0x42858487,0xbf3504e2,2 +np.float32,0xc2858487,0x3f3504e2,2 +np.float32,0x43058487,0x3f800000,2 +np.float32,0xc3058487,0xbf800000,2 +np.float32,0x43858487,0x36bea8be,2 +np.float32,0xc3858487,0xb6bea8be,2 +np.float32,0x428716a7,0xbf800000,2 +np.float32,0xc28716a7,0x3f800000,2 +np.float32,0x430716a7,0xb5d88c6d,2 +np.float32,0xc30716a7,0x35d88c6d,2 +np.float32,0x438716a7,0x36588c6d,2 +np.float32,0xc38716a7,0xb6588c6d,2 +np.float32,0x4288a8c7,0xbf3504cf,2 +np.float32,0xc288a8c7,0x3f3504cf,2 +np.float32,0x4308a8c7,0xbf800000,2 +np.float32,0xc308a8c7,0x3f800000,2 +np.float32,0x4388a8c7,0xb74b9a96,2 +np.float32,0xc388a8c7,0x374b9a96,2 +np.float32,0x428a3ae7,0x36b08908,2 +np.float32,0xc28a3ae7,0xb6b08908,2 +np.float32,0x430a3ae7,0x37308908,2 +np.float32,0xc30a3ae7,0xb7308908,2 +np.float32,0x438a3ae7,0x37b08908,2 +np.float32,0xc38a3ae7,0xb7b08908,2 +np.float32,0x428bcd06,0x3f3504f2,2 +np.float32,0xc28bcd06,0xbf3504f2,2 +np.float32,0x430bcd06,0x3f800000,2 +np.float32,0xc30bcd06,0xbf800000,2 +np.float32,0x438bcd06,0x3517675b,2 +np.float32,0xc38bcd06,0xb517675b,2 +np.float32,0x428d5f26,0x3f800000,2 +np.float32,0xc28d5f26,0xbf800000,2 +np.float32,0x430d5f26,0xb68c0105,2 +np.float32,0xc30d5f26,0x368c0105,2 +np.float32,0x438d5f26,0x370c0105,2 +np.float32,0xc38d5f26,0xb70c0105,2 +np.float32,0x428ef146,0x3f3504c0,2 +np.float32,0xc28ef146,0xbf3504c0,2 +np.float32,0x430ef146,0xbf800000,2 +np.float32,0xc30ef146,0x3f800000,2 +np.float32,0x438ef146,0xb790bc40,2 +np.float32,0xc38ef146,0x3790bc40,2 +np.float32,0x42908365,0x3592200d,2 +np.float32,0xc2908365,0xb592200d,2 +np.float32,0x43108365,0xb612200d,2 +np.float32,0xc3108365,0x3612200d,2 +np.float32,0x43908365,0xb692200d,2 +np.float32,0xc3908365,0x3692200d,2 +np.float32,0x42921585,0xbf350501,2 +np.float32,0xc2921585,0x3f350501,2 +np.float32,0x43121585,0x3f800000,2 +np.float32,0xc3121585,0xbf800000,2 +np.float32,0x43921585,0xb698cee8,2 +np.float32,0xc3921585,0x3698cee8,2 +np.float32,0x4293a7a5,0xbf800000,2 +np.float32,0xc293a7a5,0x3f800000,2 +np.float32,0x4313a7a5,0xb6e1deee,2 +np.float32,0xc313a7a5,0x36e1deee,2 +np.float32,0x4393a7a5,0x3761deee,2 +np.float32,0xc393a7a5,0xb761deee,2 +np.float32,0x429539c5,0xbf3504b1,2 +np.float32,0xc29539c5,0x3f3504b1,2 +np.float32,0x431539c5,0xbf800000,2 +np.float32,0xc31539c5,0x3f800000,2 +np.float32,0x439539c5,0xb7bbab34,2 +np.float32,0xc39539c5,0x37bbab34,2 +np.float32,0x4296cbe4,0x344cde2e,2 +np.float32,0xc296cbe4,0xb44cde2e,2 +np.float32,0x4316cbe4,0x34ccde2e,2 +np.float32,0xc316cbe4,0xb4ccde2e,2 +np.float32,0x4396cbe4,0x354cde2e,2 +np.float32,0xc396cbe4,0xb54cde2e,2 +np.float32,0x42985e04,0x3f350510,2 +np.float32,0xc2985e04,0xbf350510,2 +np.float32,0x43185e04,0x3f800000,2 +np.float32,0xc3185e04,0xbf800000,2 +np.float32,0x43985e04,0xb722455d,2 +np.float32,0xc3985e04,0x3722455d,2 +np.float32,0x4299f024,0x3f800000,2 +np.float32,0xc299f024,0xbf800000,2 +np.float32,0x4319f024,0xb71bde6c,2 +np.float32,0xc319f024,0x371bde6c,2 +np.float32,0x4399f024,0x379bde6c,2 +np.float32,0xc399f024,0xb79bde6c,2 +np.float32,0x429b8243,0x3f3504fc,2 +np.float32,0xc29b8243,0xbf3504fc,2 +np.float32,0x431b8243,0xbf800000,2 +np.float32,0xc31b8243,0x3f800000,2 +np.float32,0x439b8243,0x364b2eb8,2 +np.float32,0xc39b8243,0xb64b2eb8,2 +np.float32,0x435b2047,0xbf350525,2 +np.float32,0x42a038a2,0xbf800000,2 +np.float32,0x432038a2,0x3664ca7e,2 +np.float32,0x4345eb9b,0x365e638c,2 +np.float32,0x42c5eb9b,0xbf800000,2 +np.float32,0x42eb9e94,0xbf800000,2 +np.float32,0x4350ea79,0x3f800000,2 +np.float32,0x42dbe957,0x3585522a,2 +np.float32,0x425be957,0xbf800000,2 +np.float32,0x435be957,0xb605522a,2 +np.float32,0x476362a2,0xbd7ff911,2 +np.float32,0x464c99a4,0x3e7f4d41,2 +np.float32,0x4471f73d,0x3e7fe1b0,2 +np.float32,0x445a6752,0x3e7ef367,2 +np.float32,0x474fa400,0x3e7f9fcd,2 +np.float32,0x45c1e72f,0xbe7fc7af,2 +np.float32,0x4558c91d,0x3e7e9f31,2 +np.float32,0x43784f94,0xbdff6654,2 +np.float32,0x466e8500,0xbe7ea0a3,2 +np.float32,0x468e1c25,0x3e7e22fb,2 +np.float32,0x44ea6cfc,0x3dff70c3,2 +np.float32,0x4605126c,0x3e7f89ef,2 +np.float32,0x4788b3c6,0xbb87d853,2 +np.float32,0x4531b042,0x3dffd163,2 +np.float32,0x43f1f71d,0x3dfff387,2 +np.float32,0x462c3fa5,0xbd7fe13d,2 +np.float32,0x441c5354,0xbdff76b4,2 +np.float32,0x44908b69,0x3e7dcf0d,2 +np.float32,0x478813ad,0xbe7e9d80,2 +np.float32,0x441c4351,0x3dff937b,2 +np.float64,0x1,0x1,1 +np.float64,0x8000000000000001,0x8000000000000001,1 +np.float64,0x10000000000000,0x10000000000000,1 +np.float64,0x8010000000000000,0x8010000000000000,1 +np.float64,0x7fefffffffffffff,0x3f7452fc98b34e97,1 +np.float64,0xffefffffffffffff,0xbf7452fc98b34e97,1 +np.float64,0x7ff0000000000000,0xfff8000000000000,1 +np.float64,0xfff0000000000000,0xfff8000000000000,1 +np.float64,0x7ff8000000000000,0x7ff8000000000000,1 +np.float64,0x7ff4000000000000,0x7ffc000000000000,1 +np.float64,0xbfda51b226b4a364,0xbfd9956328ff876c,1 +np.float64,0xbfb4a65aee294cb8,0xbfb4a09fd744f8a5,1 +np.float64,0xbfd73b914fae7722,0xbfd6b9cce55af379,1 +np.float64,0xbfd90c12b4b21826,0xbfd869a3867b51c2,1 +np.float64,0x3fe649bb3d6c9376,0x3fe48778d9b48a21,1 +np.float64,0xbfd5944532ab288a,0xbfd52c30e1951b42,1 +np.float64,0x3fb150c45222a190,0x3fb14d633eb8275d,1 +np.float64,0x3fe4a6ffa9e94e00,0x3fe33f8a95c33299,1 +np.float64,0x3fe8d2157171a42a,0x3fe667d904ac95a6,1 +np.float64,0xbfa889f52c3113f0,0xbfa8878d90a23fa5,1 +np.float64,0x3feb3234bef6646a,0x3fe809d541d9017a,1 +np.float64,0x3fc6de266f2dbc50,0x3fc6bf0ee80a0d86,1 +np.float64,0x3fe8455368f08aa6,0x3fe6028254338ed5,1 +np.float64,0xbfe5576079eaaec1,0xbfe3cb4a8f6bc3f5,1 +np.float64,0xbfe9f822ff73f046,0xbfe7360d7d5cb887,1 +np.float64,0xbfb1960e7e232c20,0xbfb1928438258602,1 +np.float64,0xbfca75938d34eb28,0xbfca4570979bf2fa,1 +np.float64,0x3fd767dd15aecfbc,0x3fd6e33039018bab,1 +np.float64,0xbfe987750ef30eea,0xbfe6e7ed30ce77f0,1 +np.float64,0xbfe87f95a1f0ff2b,0xbfe62ca7e928bb2a,1 +np.float64,0xbfd2465301a48ca6,0xbfd2070245775d76,1 +np.float64,0xbfb1306ed22260e0,0xbfb12d2088eaa4f9,1 +np.float64,0xbfd8089010b01120,0xbfd778f9db77f2f3,1 +np.float64,0x3fbf9cf4ee3f39f0,0x3fbf88674fde1ca2,1 +np.float64,0x3fe6d8468a6db08e,0x3fe4f403f38b7bec,1 +np.float64,0xbfd9e5deefb3cbbe,0xbfd932692c722351,1 +np.float64,0x3fd1584d55a2b09c,0x3fd122253eeecc2e,1 +np.float64,0x3fe857979cf0af30,0x3fe60fc12b5ba8db,1 +np.float64,0x3fe3644149e6c882,0x3fe239f47013cfe6,1 +np.float64,0xbfe22ea62be45d4c,0xbfe13834c17d56fe,1 +np.float64,0xbfe8d93e1df1b27c,0xbfe66cf4ee467fd2,1 +np.float64,0xbfe9c497c9f38930,0xbfe7127417da4204,1 +np.float64,0x3fd6791cecacf238,0x3fd6039ccb5a7fde,1 +np.float64,0xbfc1dc1b1523b838,0xbfc1cd48edd9ae19,1 +np.float64,0xbfc92a8491325508,0xbfc901176e0158a5,1 +np.float64,0x3fa8649b3430c940,0x3fa8623e82d9504f,1 +np.float64,0x3fe0bed6a1617dae,0x3fdffbb307fb1abe,1 +np.float64,0x3febdf7765f7beee,0x3fe87ad01a89b74a,1 +np.float64,0xbfd3a56d46a74ada,0xbfd356cf41bf83cd,1 +np.float64,0x3fd321d824a643b0,0x3fd2d93846a224b3,1 +np.float64,0xbfc6a49fb52d4940,0xbfc686704906e7d3,1 +np.float64,0xbfdd4103c9ba8208,0xbfdc3ef0c03615b4,1 +np.float64,0xbfe0b78a51e16f14,0xbfdfef0d9ffc38b5,1 +np.float64,0xbfdac7a908b58f52,0xbfda0158956ceecf,1 +np.float64,0xbfbfbf12f23f7e28,0xbfbfaa428989258c,1 +np.float64,0xbfd55f5aa2aabeb6,0xbfd4fa39de65f33a,1 +np.float64,0x3fe06969abe0d2d4,0x3fdf6744fafdd9cf,1 +np.float64,0x3fe56ab8be6ad572,0x3fe3da7a1986d543,1 +np.float64,0xbfeefbbec67df77e,0xbfea5d426132f4aa,1 +np.float64,0x3fe6e1f49cedc3ea,0x3fe4fb53f3d8e3d5,1 +np.float64,0x3feceb231c79d646,0x3fe923d3efa55414,1 +np.float64,0xbfd03dd08ea07ba2,0xbfd011549aa1998a,1 +np.float64,0xbfd688327aad1064,0xbfd611c61b56adbe,1 +np.float64,0xbfde3249d8bc6494,0xbfdd16a7237a39d5,1 +np.float64,0x3febd4b65677a96c,0x3fe873e1a401ef03,1 +np.float64,0xbfe46bd2b368d7a6,0xbfe31023c2467749,1 +np.float64,0x3fbf9f5cde3f3ec0,0x3fbf8aca8ec53c45,1 +np.float64,0x3fc20374032406e8,0x3fc1f43f1f2f4d5e,1 +np.float64,0xbfec143b16f82876,0xbfe89caa42582381,1 +np.float64,0xbfd14fa635a29f4c,0xbfd119ced11da669,1 +np.float64,0x3fe25236d4e4a46e,0x3fe156242d644b7a,1 +np.float64,0xbfe4ed793469daf2,0xbfe377a88928fd77,1 +np.float64,0xbfb363572626c6b0,0xbfb35e98d8fe87ae,1 +np.float64,0xbfb389d5aa2713a8,0xbfb384fae55565a7,1 +np.float64,0x3fca6e001934dc00,0x3fca3e0661eaca84,1 +np.float64,0x3fe748f3f76e91e8,0x3fe548ab2168aea6,1 +np.float64,0x3fef150efdfe2a1e,0x3fea6b92d74f60d3,1 +np.float64,0xbfd14b52b1a296a6,0xbfd115a387c0fa93,1 +np.float64,0x3fe3286b5ce650d6,0x3fe208a6469a7527,1 +np.float64,0xbfd57b4f4baaf69e,0xbfd514a12a9f7ab0,1 +np.float64,0xbfef14bd467e297b,0xbfea6b64bbfd42ce,1 +np.float64,0xbfe280bc90650179,0xbfe17d2c49955dba,1 +np.float64,0x3fca8759d7350eb0,0x3fca56d5c17bbc14,1 +np.float64,0xbfdf988f30bf311e,0xbfde53f96f69b05f,1 +np.float64,0x3f6b6eeb4036de00,0x3f6b6ee7e3f86f9a,1 +np.float64,0xbfed560be8faac18,0xbfe9656c5cf973d8,1 +np.float64,0x3fc6102c592c2058,0x3fc5f43efad5396d,1 +np.float64,0xbfdef64ed2bdec9e,0xbfddc4b7fbd45aea,1 +np.float64,0x3fe814acd570295a,0x3fe5df183d543bfe,1 +np.float64,0x3fca21313f344260,0x3fc9f2d47f64fbe2,1 +np.float64,0xbfe89932cc713266,0xbfe63f186a2f60ce,1 +np.float64,0x3fe4ffcff169ffa0,0x3fe386336115ee21,1 +np.float64,0x3fee6964087cd2c8,0x3fea093d31e2c2c5,1 +np.float64,0xbfbeea604e3dd4c0,0xbfbed72734852669,1 +np.float64,0xbfea1954fb7432aa,0xbfe74cdad8720032,1 +np.float64,0x3fea3e1a5ef47c34,0x3fe765ffba65a11d,1 +np.float64,0x3fcedb850b3db708,0x3fce8f39d92f00ba,1 +np.float64,0x3fd3b52d41a76a5c,0x3fd365d22b0003f9,1 +np.float64,0xbfa4108a0c282110,0xbfa40f397fcd844f,1 +np.float64,0x3fd7454c57ae8a98,0x3fd6c2e5542c6c83,1 +np.float64,0xbfeecd3c7a7d9a79,0xbfea42ca943a1695,1 +np.float64,0xbfdddda397bbbb48,0xbfdccb27283d4c4c,1 +np.float64,0x3fe6b52cf76d6a5a,0x3fe4d96ff32925ff,1 +np.float64,0xbfa39a75ec2734f0,0xbfa3993c0da84f87,1 +np.float64,0x3fdd3fe6fdba7fcc,0x3fdc3df12fe9e525,1 +np.float64,0xbfb57a98162af530,0xbfb5742525d5fbe2,1 +np.float64,0xbfd3e166cfa7c2ce,0xbfd38ff2891be9b0,1 +np.float64,0x3fdb6a04f9b6d408,0x3fda955e5018e9dc,1 +np.float64,0x3fe4ab03a4e95608,0x3fe342bfa76e1aa8,1 +np.float64,0xbfe6c8480b6d9090,0xbfe4e7eaa935b3f5,1 +np.float64,0xbdd6b5a17bae,0xbdd6b5a17bae,1 +np.float64,0xd6591979acb23,0xd6591979acb23,1 +np.float64,0x5adbed90b5b7e,0x5adbed90b5b7e,1 +np.float64,0xa664c5314cc99,0xa664c5314cc99,1 +np.float64,0x1727fb162e500,0x1727fb162e500,1 +np.float64,0xdb49a93db6935,0xdb49a93db6935,1 +np.float64,0xb10c958d62193,0xb10c958d62193,1 +np.float64,0xad38276f5a705,0xad38276f5a705,1 +np.float64,0x1d5d0b983aba2,0x1d5d0b983aba2,1 +np.float64,0x915f48e122be9,0x915f48e122be9,1 +np.float64,0x475958ae8eb2c,0x475958ae8eb2c,1 +np.float64,0x3af8406675f09,0x3af8406675f09,1 +np.float64,0x655e88a4cabd2,0x655e88a4cabd2,1 +np.float64,0x40fee8ce81fde,0x40fee8ce81fde,1 +np.float64,0xab83103f57062,0xab83103f57062,1 +np.float64,0x7cf934b8f9f27,0x7cf934b8f9f27,1 +np.float64,0x29f7524853eeb,0x29f7524853eeb,1 +np.float64,0x4a5e954894bd3,0x4a5e954894bd3,1 +np.float64,0x24638f3a48c73,0x24638f3a48c73,1 +np.float64,0xa4f32fc749e66,0xa4f32fc749e66,1 +np.float64,0xf8e92df7f1d26,0xf8e92df7f1d26,1 +np.float64,0x292e9d50525d4,0x292e9d50525d4,1 +np.float64,0xe937e897d26fd,0xe937e897d26fd,1 +np.float64,0xd3bde1d5a77bc,0xd3bde1d5a77bc,1 +np.float64,0xa447ffd548900,0xa447ffd548900,1 +np.float64,0xa3b7b691476f7,0xa3b7b691476f7,1 +np.float64,0x490095c892013,0x490095c892013,1 +np.float64,0xfc853235f90a7,0xfc853235f90a7,1 +np.float64,0x5a8bc082b5179,0x5a8bc082b5179,1 +np.float64,0x1baca45a37595,0x1baca45a37595,1 +np.float64,0x2164120842c83,0x2164120842c83,1 +np.float64,0x66692bdeccd26,0x66692bdeccd26,1 +np.float64,0xf205bdd3e40b8,0xf205bdd3e40b8,1 +np.float64,0x7c3fff98f8801,0x7c3fff98f8801,1 +np.float64,0xccdf10e199bf,0xccdf10e199bf,1 +np.float64,0x92db8e8125b8,0x92db8e8125b8,1 +np.float64,0x5789a8d6af136,0x5789a8d6af136,1 +np.float64,0xbdda869d7bb51,0xbdda869d7bb51,1 +np.float64,0xb665e0596ccbc,0xb665e0596ccbc,1 +np.float64,0x74e6b46ee9cd7,0x74e6b46ee9cd7,1 +np.float64,0x4f39cf7c9e73b,0x4f39cf7c9e73b,1 +np.float64,0xfdbf3907fb7e7,0xfdbf3907fb7e7,1 +np.float64,0xafdef4d55fbdf,0xafdef4d55fbdf,1 +np.float64,0xb49858236930b,0xb49858236930b,1 +np.float64,0x3ebe21d47d7c5,0x3ebe21d47d7c5,1 +np.float64,0x5b620512b6c41,0x5b620512b6c41,1 +np.float64,0x31918cda63232,0x31918cda63232,1 +np.float64,0x68b5741ed16af,0x68b5741ed16af,1 +np.float64,0xa5c09a5b4b814,0xa5c09a5b4b814,1 +np.float64,0x55f51c14abea4,0x55f51c14abea4,1 +np.float64,0xda8a3e41b515,0xda8a3e41b515,1 +np.float64,0x9ea9c8513d539,0x9ea9c8513d539,1 +np.float64,0x7f23b964fe478,0x7f23b964fe478,1 +np.float64,0xf6e08c7bedc12,0xf6e08c7bedc12,1 +np.float64,0x7267aa24e4cf6,0x7267aa24e4cf6,1 +np.float64,0x236bb93a46d78,0x236bb93a46d78,1 +np.float64,0x9a98430b35309,0x9a98430b35309,1 +np.float64,0xbb683fef76d08,0xbb683fef76d08,1 +np.float64,0x1ff0eb6e3fe1e,0x1ff0eb6e3fe1e,1 +np.float64,0xf524038fea481,0xf524038fea481,1 +np.float64,0xd714e449ae29d,0xd714e449ae29d,1 +np.float64,0x4154fd7682aa0,0x4154fd7682aa0,1 +np.float64,0x5b8d2f6cb71a7,0x5b8d2f6cb71a7,1 +np.float64,0xc91aa21d92355,0xc91aa21d92355,1 +np.float64,0xbd94fd117b2a0,0xbd94fd117b2a0,1 +np.float64,0x685b207ad0b65,0x685b207ad0b65,1 +np.float64,0xd2485b05a490c,0xd2485b05a490c,1 +np.float64,0x151ea5e62a3d6,0x151ea5e62a3d6,1 +np.float64,0x2635a7164c6b6,0x2635a7164c6b6,1 +np.float64,0x88ae3b5d115c8,0x88ae3b5d115c8,1 +np.float64,0x8a055a55140ac,0x8a055a55140ac,1 +np.float64,0x756f7694eadef,0x756f7694eadef,1 +np.float64,0x866d74630cdaf,0x866d74630cdaf,1 +np.float64,0x39e44f2873c8b,0x39e44f2873c8b,1 +np.float64,0x2a07ceb6540fb,0x2a07ceb6540fb,1 +np.float64,0xc52b96398a573,0xc52b96398a573,1 +np.float64,0x9546543b2a8cb,0x9546543b2a8cb,1 +np.float64,0x5b995b90b732c,0x5b995b90b732c,1 +np.float64,0x2de10a565bc22,0x2de10a565bc22,1 +np.float64,0x3b06ee94760df,0x3b06ee94760df,1 +np.float64,0xb18e77a5631cf,0xb18e77a5631cf,1 +np.float64,0x3b89ae3a77137,0x3b89ae3a77137,1 +np.float64,0xd9b0b6e5b3617,0xd9b0b6e5b3617,1 +np.float64,0x30b2310861647,0x30b2310861647,1 +np.float64,0x326a3ab464d48,0x326a3ab464d48,1 +np.float64,0x4c18610a9830d,0x4c18610a9830d,1 +np.float64,0x541dea42a83be,0x541dea42a83be,1 +np.float64,0xcd027dbf9a050,0xcd027dbf9a050,1 +np.float64,0x780a0f80f015,0x780a0f80f015,1 +np.float64,0x740ed5b2e81db,0x740ed5b2e81db,1 +np.float64,0xc226814d844d0,0xc226814d844d0,1 +np.float64,0xde958541bd2b1,0xde958541bd2b1,1 +np.float64,0xb563d3296ac7b,0xb563d3296ac7b,1 +np.float64,0x1db3b0b83b677,0x1db3b0b83b677,1 +np.float64,0xa7b0275d4f605,0xa7b0275d4f605,1 +np.float64,0x72f8d038e5f1b,0x72f8d038e5f1b,1 +np.float64,0x860ed1350c1da,0x860ed1350c1da,1 +np.float64,0x79f88262f3f11,0x79f88262f3f11,1 +np.float64,0x8817761f102ef,0x8817761f102ef,1 +np.float64,0xac44784b5888f,0xac44784b5888f,1 +np.float64,0x800fd594241fab28,0x800fd594241fab28,1 +np.float64,0x800ede32f8ddbc66,0x800ede32f8ddbc66,1 +np.float64,0x800de4c1121bc982,0x800de4c1121bc982,1 +np.float64,0x80076ebcddcedd7a,0x80076ebcddcedd7a,1 +np.float64,0x800b3fee06567fdc,0x800b3fee06567fdc,1 +np.float64,0x800b444426b68889,0x800b444426b68889,1 +np.float64,0x800b1c037a563807,0x800b1c037a563807,1 +np.float64,0x8001eb88c2a3d712,0x8001eb88c2a3d712,1 +np.float64,0x80058aae6dab155e,0x80058aae6dab155e,1 +np.float64,0x80083df2d4f07be6,0x80083df2d4f07be6,1 +np.float64,0x800e3b19d97c7634,0x800e3b19d97c7634,1 +np.float64,0x800a71c6f374e38e,0x800a71c6f374e38e,1 +np.float64,0x80048557f1490ab1,0x80048557f1490ab1,1 +np.float64,0x8000a00e6b01401e,0x8000a00e6b01401e,1 +np.float64,0x800766a3e2cecd49,0x800766a3e2cecd49,1 +np.float64,0x80015eb44602bd69,0x80015eb44602bd69,1 +np.float64,0x800bde885a77bd11,0x800bde885a77bd11,1 +np.float64,0x800224c53ea4498b,0x800224c53ea4498b,1 +np.float64,0x80048e8c6a291d1a,0x80048e8c6a291d1a,1 +np.float64,0x800b667e4af6ccfd,0x800b667e4af6ccfd,1 +np.float64,0x800ae3d7e395c7b0,0x800ae3d7e395c7b0,1 +np.float64,0x80086c245550d849,0x80086c245550d849,1 +np.float64,0x800d7d25f6fafa4c,0x800d7d25f6fafa4c,1 +np.float64,0x800f8d9ab0ff1b35,0x800f8d9ab0ff1b35,1 +np.float64,0x800690e949cd21d3,0x800690e949cd21d3,1 +np.float64,0x8003022381060448,0x8003022381060448,1 +np.float64,0x80085e0dad70bc1c,0x80085e0dad70bc1c,1 +np.float64,0x800e2ffc369c5ff9,0x800e2ffc369c5ff9,1 +np.float64,0x800b629b5af6c537,0x800b629b5af6c537,1 +np.float64,0x800fdc964b7fb92d,0x800fdc964b7fb92d,1 +np.float64,0x80036bb4b1c6d76a,0x80036bb4b1c6d76a,1 +np.float64,0x800b382f7f16705f,0x800b382f7f16705f,1 +np.float64,0x800ebac9445d7593,0x800ebac9445d7593,1 +np.float64,0x80015075c3e2a0ec,0x80015075c3e2a0ec,1 +np.float64,0x8002a6ec5ce54dd9,0x8002a6ec5ce54dd9,1 +np.float64,0x8009fab74a93f56f,0x8009fab74a93f56f,1 +np.float64,0x800c94b9ea992974,0x800c94b9ea992974,1 +np.float64,0x800dc2efd75b85e0,0x800dc2efd75b85e0,1 +np.float64,0x800be6400d57cc80,0x800be6400d57cc80,1 +np.float64,0x80021f6858443ed1,0x80021f6858443ed1,1 +np.float64,0x800600e2ac4c01c6,0x800600e2ac4c01c6,1 +np.float64,0x800a2159e6b442b4,0x800a2159e6b442b4,1 +np.float64,0x800c912f4bb9225f,0x800c912f4bb9225f,1 +np.float64,0x800a863a9db50c76,0x800a863a9db50c76,1 +np.float64,0x800ac16851d582d1,0x800ac16851d582d1,1 +np.float64,0x8003f7d32e87efa7,0x8003f7d32e87efa7,1 +np.float64,0x800be4eee3d7c9de,0x800be4eee3d7c9de,1 +np.float64,0x80069ff0ac4d3fe2,0x80069ff0ac4d3fe2,1 +np.float64,0x80061c986d4c3932,0x80061c986d4c3932,1 +np.float64,0x8000737b4de0e6f7,0x8000737b4de0e6f7,1 +np.float64,0x8002066ef7440cdf,0x8002066ef7440cdf,1 +np.float64,0x8001007050c200e1,0x8001007050c200e1,1 +np.float64,0x8008df9fa351bf40,0x8008df9fa351bf40,1 +np.float64,0x800f8394ee5f072a,0x800f8394ee5f072a,1 +np.float64,0x80008e0b01c11c17,0x80008e0b01c11c17,1 +np.float64,0x800f7088ed3ee112,0x800f7088ed3ee112,1 +np.float64,0x800285b86f650b72,0x800285b86f650b72,1 +np.float64,0x8008ec18af51d832,0x8008ec18af51d832,1 +np.float64,0x800da08523bb410a,0x800da08523bb410a,1 +np.float64,0x800de853ca7bd0a8,0x800de853ca7bd0a8,1 +np.float64,0x8008c8aefad1915e,0x8008c8aefad1915e,1 +np.float64,0x80010c39d5821874,0x80010c39d5821874,1 +np.float64,0x8009208349724107,0x8009208349724107,1 +np.float64,0x800783783f0f06f1,0x800783783f0f06f1,1 +np.float64,0x80025caf9984b960,0x80025caf9984b960,1 +np.float64,0x800bc76fa6778ee0,0x800bc76fa6778ee0,1 +np.float64,0x80017e2f89a2fc60,0x80017e2f89a2fc60,1 +np.float64,0x800ef169843de2d3,0x800ef169843de2d3,1 +np.float64,0x80098a5f7db314bf,0x80098a5f7db314bf,1 +np.float64,0x800d646f971ac8df,0x800d646f971ac8df,1 +np.float64,0x800110d1dc6221a4,0x800110d1dc6221a4,1 +np.float64,0x800f8b422a1f1684,0x800f8b422a1f1684,1 +np.float64,0x800785c97dcf0b94,0x800785c97dcf0b94,1 +np.float64,0x800da201283b4403,0x800da201283b4403,1 +np.float64,0x800a117cc7b422fa,0x800a117cc7b422fa,1 +np.float64,0x80024731cfa48e64,0x80024731cfa48e64,1 +np.float64,0x800199d456c333a9,0x800199d456c333a9,1 +np.float64,0x8005f66bab8becd8,0x8005f66bab8becd8,1 +np.float64,0x8008e7227c11ce45,0x8008e7227c11ce45,1 +np.float64,0x8007b66cc42f6cda,0x8007b66cc42f6cda,1 +np.float64,0x800669e6f98cd3cf,0x800669e6f98cd3cf,1 +np.float64,0x800aed917375db23,0x800aed917375db23,1 +np.float64,0x8008b6dd15116dbb,0x8008b6dd15116dbb,1 +np.float64,0x800f49869cfe930d,0x800f49869cfe930d,1 +np.float64,0x800a712661b4e24d,0x800a712661b4e24d,1 +np.float64,0x800944e816f289d1,0x800944e816f289d1,1 +np.float64,0x800eba0f8a1d741f,0x800eba0f8a1d741f,1 +np.float64,0x800cf6ded139edbe,0x800cf6ded139edbe,1 +np.float64,0x80023100c6246202,0x80023100c6246202,1 +np.float64,0x800c5a94add8b52a,0x800c5a94add8b52a,1 +np.float64,0x800adf329b95be66,0x800adf329b95be66,1 +np.float64,0x800af9afc115f360,0x800af9afc115f360,1 +np.float64,0x800d66ce837acd9d,0x800d66ce837acd9d,1 +np.float64,0x8003ffb5e507ff6d,0x8003ffb5e507ff6d,1 +np.float64,0x80027d280024fa51,0x80027d280024fa51,1 +np.float64,0x800fc37e1d1f86fc,0x800fc37e1d1f86fc,1 +np.float64,0x800fc7258b9f8e4b,0x800fc7258b9f8e4b,1 +np.float64,0x8003fb5789e7f6b0,0x8003fb5789e7f6b0,1 +np.float64,0x800eb4e7a13d69cf,0x800eb4e7a13d69cf,1 +np.float64,0x800951850952a30a,0x800951850952a30a,1 +np.float64,0x3fed4071be3a80e3,0x3fe95842074431df,1 +np.float64,0x3f8d2341203a4682,0x3f8d2300b453bd9f,1 +np.float64,0x3fdc8ce332b919c6,0x3fdb9cdf1440c28f,1 +np.float64,0x3fdc69bd84b8d37b,0x3fdb7d25c8166b7b,1 +np.float64,0x3fc4c22ad0298456,0x3fc4aae73e231b4f,1 +np.float64,0x3fea237809f446f0,0x3fe753cc6ca96193,1 +np.float64,0x3fd34cf6462699ed,0x3fd30268909bb47e,1 +np.float64,0x3fafce20643f9c41,0x3fafc8e41a240e35,1 +np.float64,0x3fdc6d416538da83,0x3fdb805262292863,1 +np.float64,0x3fe7d8362aefb06c,0x3fe5b2ce659db7fd,1 +np.float64,0x3fe290087de52011,0x3fe189f9a3eb123d,1 +np.float64,0x3fa62d2bf82c5a58,0x3fa62b65958ca2b8,1 +np.float64,0x3fafd134403fa269,0x3fafcbf670f8a6f3,1 +np.float64,0x3fa224e53c2449ca,0x3fa223ec5de1631b,1 +np.float64,0x3fb67e2c2c2cfc58,0x3fb676c445fb70a0,1 +np.float64,0x3fda358d01346b1a,0x3fd97b9441666eb2,1 +np.float64,0x3fdd30fc4bba61f9,0x3fdc308da423778d,1 +np.float64,0x3fc56e99c52add34,0x3fc5550004492621,1 +np.float64,0x3fe32d08de265a12,0x3fe20c761a73cec2,1 +np.float64,0x3fd46cf932a8d9f2,0x3fd414a7f3db03df,1 +np.float64,0x3fd94cfa2b3299f4,0x3fd8a5961b3e4bdd,1 +np.float64,0x3fed6ea3a6fadd47,0x3fe9745b2f6c9204,1 +np.float64,0x3fe4431d1768863a,0x3fe2ef61d0481de0,1 +np.float64,0x3fe1d8e00ea3b1c0,0x3fe0efab5050ee78,1 +np.float64,0x3fe56f37dcaade70,0x3fe3de00b0f392e0,1 +np.float64,0x3fde919a2dbd2334,0x3fdd6b6d2dcf2396,1 +np.float64,0x3fe251e3d4a4a3c8,0x3fe155de69605d60,1 +np.float64,0x3fe5e0ecc5abc1da,0x3fe436a5de5516cf,1 +np.float64,0x3fcd48780c3a90f0,0x3fcd073fa907ba9b,1 +np.float64,0x3fe4e8149229d029,0x3fe37360801d5b66,1 +np.float64,0x3fb9ef159633de2b,0x3fb9e3bc05a15d1d,1 +np.float64,0x3fc24a3f0424947e,0x3fc23a5432ca0e7c,1 +np.float64,0x3fe55ca196aab943,0x3fe3cf6b3143435a,1 +np.float64,0x3fe184544c2308a9,0x3fe0a7b49fa80aec,1 +np.float64,0x3fe2c76e83658edd,0x3fe1b8355c1ea771,1 +np.float64,0x3fea8d2c4ab51a59,0x3fe79ba85aabc099,1 +np.float64,0x3fd74f98abae9f31,0x3fd6cc85005d0593,1 +np.float64,0x3fec6de9a678dbd3,0x3fe8d59a1d23cdd1,1 +np.float64,0x3fec8a0e50f9141d,0x3fe8e7500f6f6a00,1 +np.float64,0x3fe9de6d08b3bcda,0x3fe7245319508767,1 +np.float64,0x3fe4461fd1688c40,0x3fe2f1cf0b93aba6,1 +np.float64,0x3fde342d9d3c685b,0x3fdd185609d5719d,1 +np.float64,0x3feb413fc8368280,0x3fe813c091d2519a,1 +np.float64,0x3fe64333156c8666,0x3fe48275b9a6a358,1 +np.float64,0x3fe03c65226078ca,0x3fdf18b26786be35,1 +np.float64,0x3fee11054dbc220b,0x3fe9d579a1cfa7ad,1 +np.float64,0x3fbaefccae35df99,0x3fbae314fef7c7ea,1 +np.float64,0x3feed4e3487da9c7,0x3fea4729241c8811,1 +np.float64,0x3fbb655df836cabc,0x3fbb57fcf9a097be,1 +np.float64,0x3fe68b0273ed1605,0x3fe4b96109afdf76,1 +np.float64,0x3fd216bfc3242d80,0x3fd1d957363f6a43,1 +np.float64,0x3fe01328d4a02652,0x3fded083bbf94aba,1 +np.float64,0x3fe3f9a61ae7f34c,0x3fe2b3f701b79028,1 +np.float64,0x3fed4e7cf8fa9cfa,0x3fe960d27084fb40,1 +np.float64,0x3faec08e343d811c,0x3faebbd2aa07ac1f,1 +np.float64,0x3fd2d1bbeea5a378,0x3fd28c9aefcf48ad,1 +np.float64,0x3fd92e941fb25d28,0x3fd889857f88410d,1 +np.float64,0x3fe43decb7e87bd9,0x3fe2eb32b4ee4667,1 +np.float64,0x3fef49cabcfe9395,0x3fea892f9a233f76,1 +np.float64,0x3fe3e96812e7d2d0,0x3fe2a6c6b45dd6ee,1 +np.float64,0x3fd24c0293a49805,0x3fd20c76d54473cb,1 +np.float64,0x3fb43d6b7e287ad7,0x3fb438060772795a,1 +np.float64,0x3fe87bf7d3f0f7f0,0x3fe62a0c47411c62,1 +np.float64,0x3fee82a2e07d0546,0x3fea17e27e752b7b,1 +np.float64,0x3fe40c01bbe81803,0x3fe2c2d9483f44d8,1 +np.float64,0x3fd686ccae2d0d99,0x3fd610763fb61097,1 +np.float64,0x3fe90fcf2af21f9e,0x3fe693c12df59ba9,1 +np.float64,0x3fefb3ce11ff679c,0x3feac3dd4787529d,1 +np.float64,0x3fcec53ff63d8a80,0x3fce79992af00c58,1 +np.float64,0x3fe599dd7bab33bb,0x3fe3ff5da7575d85,1 +np.float64,0x3fe9923b1a732476,0x3fe6ef71d13db456,1 +np.float64,0x3febf76fcef7eee0,0x3fe88a3952e11373,1 +np.float64,0x3fc2cfd128259fa2,0x3fc2be7fd47fd811,1 +np.float64,0x3fe4d37ae269a6f6,0x3fe36300d45e3745,1 +np.float64,0x3fe23aa2e4247546,0x3fe1424e172f756f,1 +np.float64,0x3fe4f0596ca9e0b3,0x3fe379f0c49de7ef,1 +np.float64,0x3fe2e4802fe5c900,0x3fe1d062a8812601,1 +np.float64,0x3fe5989c79eb3139,0x3fe3fe6308552dec,1 +np.float64,0x3fe3c53cb4e78a79,0x3fe28956e573aca4,1 +np.float64,0x3fe6512beeeca258,0x3fe48d2d5ece979f,1 +np.float64,0x3fd8473ddb308e7c,0x3fd7b33e38adc6ad,1 +np.float64,0x3fecd09c9679a139,0x3fe91361fa0c5bcb,1 +np.float64,0x3fc991530e3322a6,0x3fc965e2c514a9e9,1 +np.float64,0x3f6d4508403a8a11,0x3f6d45042b68acc5,1 +np.float64,0x3fea1f198f743e33,0x3fe750ce918d9330,1 +np.float64,0x3fd0a0bb4da14177,0x3fd07100f9c71e1c,1 +np.float64,0x3fd30c45ffa6188c,0x3fd2c499f9961f66,1 +np.float64,0x3fcad98e7c35b31d,0x3fcaa74293cbc52e,1 +np.float64,0x3fec8e4a5eb91c95,0x3fe8e9f898d118db,1 +np.float64,0x3fd19fdb79233fb7,0x3fd1670c00febd24,1 +np.float64,0x3fea9fcbb1f53f97,0x3fe7a836b29c4075,1 +np.float64,0x3fc6d12ea12da25d,0x3fc6b24bd2f89f59,1 +np.float64,0x3fd6af3658ad5e6d,0x3fd636613e08df3f,1 +np.float64,0x3fe31bc385a63787,0x3fe1fe3081621213,1 +np.float64,0x3fc0dbba2221b774,0x3fc0cf42c9313dba,1 +np.float64,0x3fef639ce87ec73a,0x3fea9795454f1036,1 +np.float64,0x3fee5f29dcbcbe54,0x3fea0349b288f355,1 +np.float64,0x3fed46bdb37a8d7b,0x3fe95c199f5aa569,1 +np.float64,0x3fef176afa3e2ed6,0x3fea6ce78b2aa3aa,1 +np.float64,0x3fc841e7683083cf,0x3fc81cccb84848cc,1 +np.float64,0xbfda3ec9a2347d94,0xbfd9840d180e9de3,1 +np.float64,0xbfcd5967ae3ab2d0,0xbfcd17be13142bb9,1 +np.float64,0xbfedf816573bf02d,0xbfe9c6bb06476c60,1 +np.float64,0xbfd0d6e10e21adc2,0xbfd0a54f99d2f3dc,1 +np.float64,0xbfe282df096505be,0xbfe17ef5e2e80760,1 +np.float64,0xbfd77ae6e62ef5ce,0xbfd6f4f6b603ad8a,1 +np.float64,0xbfe37b171aa6f62e,0xbfe24cb4b2d0ade4,1 +np.float64,0xbfef9e5ed9bf3cbe,0xbfeab817b41000bd,1 +np.float64,0xbfe624d6f96c49ae,0xbfe46b1e9c9aff86,1 +np.float64,0xbfefb5da65ff6bb5,0xbfeac4fc9c982772,1 +np.float64,0xbfd29a65d52534cc,0xbfd2579df8ff87b9,1 +np.float64,0xbfd40270172804e0,0xbfd3af6471104aef,1 +np.float64,0xbfb729ee7a2e53e0,0xbfb721d7dbd2705e,1 +np.float64,0xbfb746f1382e8de0,0xbfb73ebc1207f8e3,1 +np.float64,0xbfd3c7e606a78fcc,0xbfd377a8aa1b0dd9,1 +np.float64,0xbfd18c4880231892,0xbfd1543506584ad5,1 +np.float64,0xbfea988080753101,0xbfe7a34cba0d0fa1,1 +np.float64,0xbf877400e02ee800,0xbf8773df47fa7e35,1 +np.float64,0xbfb07e050820fc08,0xbfb07b198d4a52c9,1 +np.float64,0xbfee0a3621fc146c,0xbfe9d1745a05ba77,1 +np.float64,0xbfe78de246ef1bc4,0xbfe57bf2baab91c8,1 +np.float64,0xbfcdbfd3bd3b7fa8,0xbfcd7b728a955a06,1 +np.float64,0xbfe855ea79b0abd5,0xbfe60e8a4a17b921,1 +np.float64,0xbfd86c8e3530d91c,0xbfd7d5e36c918dc1,1 +np.float64,0xbfe4543169e8a863,0xbfe2fd23d42f552e,1 +np.float64,0xbfe41efbf1283df8,0xbfe2d235a2faed1a,1 +np.float64,0xbfd9a55464b34aa8,0xbfd8f7083f7281e5,1 +np.float64,0xbfe5f5078d6bea0f,0xbfe44637d910c270,1 +np.float64,0xbfe6d83e3dedb07c,0xbfe4f3fdadd10552,1 +np.float64,0xbfdb767e70b6ecfc,0xbfdaa0b6c17f3fb1,1 +np.float64,0xbfdfc91b663f9236,0xbfde7eb0dfbeaa26,1 +np.float64,0xbfbfbd18783f7a30,0xbfbfa84bf2fa1c8d,1 +np.float64,0xbfe51199242a2332,0xbfe39447dbe066ae,1 +np.float64,0xbfdbb94814b77290,0xbfdadd63bd796972,1 +np.float64,0xbfd8c6272cb18c4e,0xbfd828f2d9e8607e,1 +np.float64,0xbfce51e0b63ca3c0,0xbfce097ee908083a,1 +np.float64,0xbfe99a177d73342f,0xbfe6f4ec776a57ae,1 +np.float64,0xbfefde2ab0ffbc55,0xbfeadafdcbf54733,1 +np.float64,0xbfcccb5c1c3996b8,0xbfcc8d586a73d126,1 +np.float64,0xbfdf7ddcedbefbba,0xbfde3c749a906de7,1 +np.float64,0xbfef940516ff280a,0xbfeab26429e89f4b,1 +np.float64,0xbfe08009f1e10014,0xbfdf8eab352997eb,1 +np.float64,0xbfe9c02682b3804d,0xbfe70f5fd05f79ee,1 +np.float64,0xbfb3ca1732279430,0xbfb3c50bec5b453a,1 +np.float64,0xbfe368e81926d1d0,0xbfe23dc704d0887c,1 +np.float64,0xbfbd20cc2e3a4198,0xbfbd10b7e6d81c6c,1 +np.float64,0xbfd67ece4d2cfd9c,0xbfd608f527dcc5e7,1 +np.float64,0xbfdc02d1333805a2,0xbfdb20104454b79f,1 +np.float64,0xbfc007a626200f4c,0xbfbff9dc9dc70193,1 +np.float64,0xbfda9e4f8fb53ca0,0xbfd9db8af35dc630,1 +np.float64,0xbfd8173d77302e7a,0xbfd786a0cf3e2914,1 +np.float64,0xbfeb8fcbd0b71f98,0xbfe84734debc10fb,1 +np.float64,0xbfe4bf1cb7697e3a,0xbfe352c891113f29,1 +np.float64,0xbfc18624d5230c48,0xbfc178248e863b64,1 +np.float64,0xbfcf184bac3e3098,0xbfceca3b19be1ebe,1 +np.float64,0xbfd2269c42a44d38,0xbfd1e8920d72b694,1 +np.float64,0xbfe8808526b1010a,0xbfe62d5497292495,1 +np.float64,0xbfe498bd1da9317a,0xbfe334245eadea93,1 +np.float64,0xbfef0855aebe10ab,0xbfea6462f29aeaf9,1 +np.float64,0xbfdeb186c93d630e,0xbfdd87c37943c602,1 +np.float64,0xbfb29fe2ae253fc8,0xbfb29bae3c87efe4,1 +np.float64,0xbfddd9c6c3bbb38e,0xbfdcc7b400bf384b,1 +np.float64,0xbfe3506673e6a0cd,0xbfe2299f26295553,1 +np.float64,0xbfe765957a2ecb2b,0xbfe55e03cf22edab,1 +np.float64,0xbfecc9876c79930f,0xbfe90efaf15b6207,1 +np.float64,0xbfefb37a0a7f66f4,0xbfeac3af3898e7c2,1 +np.float64,0xbfeefa0da7bdf41b,0xbfea5c4cde53c1c3,1 +np.float64,0xbfe6639ee9ecc73e,0xbfe49b4e28a72482,1 +np.float64,0xbfef91a4bb7f2349,0xbfeab114ac9e25dd,1 +np.float64,0xbfc8b392bb316724,0xbfc88c657f4441a3,1 +np.float64,0xbfc88a358231146c,0xbfc863cb900970fe,1 +np.float64,0xbfef25a9d23e4b54,0xbfea74eda432aabe,1 +np.float64,0xbfe6aceea0ed59de,0xbfe4d32e54a3fd01,1 +np.float64,0xbfefe2b3e37fc568,0xbfeadd74f4605835,1 +np.float64,0xbfa9eecb8833dd90,0xbfa9ebf4f4cb2591,1 +np.float64,0xbfd42bad7428575a,0xbfd3d69de8e52d0a,1 +np.float64,0xbfbc366b4a386cd8,0xbfbc27ceee8f3019,1 +np.float64,0xbfd9bca7be337950,0xbfd90c80e6204e57,1 +np.float64,0xbfe8173f53f02e7f,0xbfe5e0f8d8ed329c,1 +np.float64,0xbfce22dbcb3c45b8,0xbfcddbc8159b63af,1 +np.float64,0xbfea2d7ba7345af7,0xbfe75aa62ad5b80a,1 +np.float64,0xbfc08b783e2116f0,0xbfc07faf8d501558,1 +np.float64,0xbfb8c4161c318830,0xbfb8ba33950748ec,1 +np.float64,0xbfddd930bcbbb262,0xbfdcc72dffdf51bb,1 +np.float64,0xbfd108ce8a22119e,0xbfd0d5801e7698bd,1 +np.float64,0xbfd5bd2b5dab7a56,0xbfd552c52c468c76,1 +np.float64,0xbfe7ffe67fefffcd,0xbfe5cfe96e35e6e5,1 +np.float64,0xbfa04ec6bc209d90,0xbfa04e120a2c25cc,1 +np.float64,0xbfef7752cc7eeea6,0xbfeaa28715addc4f,1 +np.float64,0xbfe7083c2eae1078,0xbfe5182bf8ddfc8e,1 +np.float64,0xbfe05dafd0a0bb60,0xbfdf52d397cfe5f6,1 +np.float64,0xbfacb4f2243969e0,0xbfacb118991ea235,1 +np.float64,0xbfc7d47e422fa8fc,0xbfc7b1504714a4fd,1 +np.float64,0xbfbd70b2243ae168,0xbfbd60182efb61de,1 +np.float64,0xbfe930e49cb261c9,0xbfe6ab272b3f9cfc,1 +np.float64,0xbfb5f537e62bea70,0xbfb5ee540dcdc635,1 +np.float64,0xbfbb0c8278361908,0xbfbaffa1f7642a87,1 +np.float64,0xbfe82af2447055e4,0xbfe5ef54ca8db9e8,1 +np.float64,0xbfe92245e6f2448c,0xbfe6a0d32168040b,1 +np.float64,0xbfb799a8522f3350,0xbfb7911a7ada3640,1 +np.float64,0x7faa8290c8350521,0x3fe5916f67209cd6,1 +np.float64,0x7f976597082ecb2d,0x3fcf94dce396bd37,1 +np.float64,0x7fede721237bce41,0x3fe3e7b1575b005f,1 +np.float64,0x7fd5f674d72bece9,0x3fe3210628eba199,1 +np.float64,0x7f9b0f1aa0361e34,0x3feffd34d15d1da7,1 +np.float64,0x7fec48346ab89068,0x3fe93dd84253d9a2,1 +np.float64,0x7f9cac76283958eb,0xbfec4cd999653868,1 +np.float64,0x7fed51ab6bbaa356,0x3fecc27fb5f37bca,1 +np.float64,0x7fded3c116bda781,0xbfda473efee47cf1,1 +np.float64,0x7fd19c48baa33890,0xbfe25700cbfc0326,1 +np.float64,0x7fe5c8f478ab91e8,0xbfee4ab6d84806be,1 +np.float64,0x7fe53c64e46a78c9,0x3fee19c3f227f4e1,1 +np.float64,0x7fc2ad1936255a31,0xbfe56db9b877f807,1 +np.float64,0x7fe2b071b52560e2,0xbfce3990a8d390a9,1 +np.float64,0x7fc93f3217327e63,0xbfd1f6d7ef838d2b,1 +np.float64,0x7fec26df08784dbd,0x3fd5397be41c93d9,1 +np.float64,0x7fcf4770183e8edf,0x3fe6354f5a785016,1 +np.float64,0x7fdc9fcc0bb93f97,0xbfeeeae952e8267d,1 +np.float64,0x7feb21f29c7643e4,0x3fec20122e33f1bf,1 +np.float64,0x7fd0b51273216a24,0x3fefb09f8daba00b,1 +np.float64,0x7fe747a9d76e8f53,0x3feb46a3232842a4,1 +np.float64,0x7fd58885972b110a,0xbfce5ea57c186221,1 +np.float64,0x7fca3ce85c3479d0,0x3fef93a24548e8ca,1 +np.float64,0x7fe1528a46a2a514,0xbfb54bb578d9da91,1 +np.float64,0x7fcc58b21b38b163,0x3feffb5b741ffc2d,1 +np.float64,0x7fdabcaaf5357955,0x3fecbf855db524d1,1 +np.float64,0x7fdd27c6933a4f8c,0xbfef2f41bb80144b,1 +np.float64,0x7fbda4e1be3b49c2,0x3fdb9b33f84f5381,1 +np.float64,0x7fe53363362a66c5,0x3fe4daff3a6a4ed0,1 +np.float64,0x7fe5719d62eae33a,0xbfef761d98f625d5,1 +np.float64,0x7f982ce5a83059ca,0x3fd0b27c3365f0a8,1 +np.float64,0x7fe6db8c42edb718,0x3fe786f4b1fe11a6,1 +np.float64,0x7fe62cca1b2c5993,0x3fd425b6c4c9714a,1 +np.float64,0x7feea88850bd5110,0xbfd7bbb432017175,1 +np.float64,0x7fad6c6ae43ad8d5,0x3fe82e49098bc6de,1 +np.float64,0x7fe70542f02e0a85,0x3fec3017960b4822,1 +np.float64,0x7feaf0bcbb35e178,0xbfc3aac74dd322d5,1 +np.float64,0x7fb5e152fe2bc2a5,0x3fd4b27a4720614c,1 +np.float64,0x7fe456ee5be8addc,0xbfe9e15ab5cff229,1 +np.float64,0x7fd4b53a8d296a74,0xbfefff450f503326,1 +np.float64,0x7fd7149d7a2e293a,0x3fef4ef0a9009096,1 +np.float64,0x7fd43fc5a8a87f8a,0x3fe0c929fee9dce7,1 +np.float64,0x7fef97022aff2e03,0x3fd4ea52a813da20,1 +np.float64,0x7fe035950ae06b29,0x3fef4e125394fb05,1 +np.float64,0x7fecd0548979a0a8,0x3fe89d226244037b,1 +np.float64,0x7fc79b3ac22f3675,0xbfee9c9cf78c8270,1 +np.float64,0x7fd8b8e8263171cf,0x3fe8e24437961db0,1 +np.float64,0x7fc288c23e251183,0xbfbaf8eca50986ca,1 +np.float64,0x7fe436b4b6686d68,0xbfecd661741931c4,1 +np.float64,0x7fcdf99abe3bf334,0x3feaa75c90830b92,1 +np.float64,0x7fd9f9739233f2e6,0xbfebbfcb301b0da5,1 +np.float64,0x7fd6fcbd1b2df979,0xbfccf2c77cb65f56,1 +np.float64,0x7fe242a97b248552,0xbfe5b0f13bcbabc8,1 +np.float64,0x7fe38bf3e06717e7,0x3fbc8fa9004d2668,1 +np.float64,0x7fecd0e8d479a1d1,0xbfe886a6b4f73a4a,1 +np.float64,0x7fe958d60232b1ab,0xbfeb7c4cf0cee2dd,1 +np.float64,0x7f9d492b583a9256,0xbfebe975d00221cb,1 +np.float64,0x7fd6c9983bad932f,0xbfefe817621a31f6,1 +np.float64,0x7fed0d7239fa1ae3,0x3feac7e1b6455b4b,1 +np.float64,0x7fe61dac90ec3b58,0x3fef845b9efe8421,1 +np.float64,0x7f9acd3010359a5f,0xbfe460d376200130,1 +np.float64,0x7fedced9673b9db2,0xbfeeaf23445e1944,1 +np.float64,0x7fd9f271a733e4e2,0xbfd41544535ecb78,1 +np.float64,0x7fe703339bee0666,0x3fef93334626b56c,1 +np.float64,0x7fec7761b7b8eec2,0xbfe6da9179e8e714,1 +np.float64,0x7fdd9fff043b3ffd,0xbfc0761dfb8d94f9,1 +np.float64,0x7fdc10ed17b821d9,0x3fe1481e2a26c77f,1 +np.float64,0x7fe7681e72aed03c,0x3fefff94a6d47c84,1 +np.float64,0x7fe18c29e1e31853,0x3fe86ebd2fd89456,1 +np.float64,0x7fb2fb273c25f64d,0xbfefc136f57e06de,1 +np.float64,0x7fac2bbb90385776,0x3fe25d8e3cdae7e3,1 +np.float64,0x7fed16789efa2cf0,0x3fe94555091fdfd9,1 +np.float64,0x7fd8fe8f7831fd1e,0xbfed58d520361902,1 +np.float64,0x7fa59bde3c2b37bb,0x3fef585391c077ff,1 +np.float64,0x7fda981b53353036,0x3fde02ca08737b5f,1 +np.float64,0x7fd29f388aa53e70,0xbfe04f5499246df2,1 +np.float64,0x7fcd0232513a0464,0xbfd9737f2f565829,1 +np.float64,0x7fe9a881bcf35102,0xbfe079cf285b35dd,1 +np.float64,0x7fdbe399a9b7c732,0x3fe965bc4220f340,1 +np.float64,0x7feb77414af6ee82,0xbfb7df2fcd491f55,1 +np.float64,0x7fa26e86c424dd0d,0xbfea474c3d65b9be,1 +np.float64,0x7feaee869e35dd0c,0xbfd7b333a888cd14,1 +np.float64,0x7fcbd67f6137acfe,0xbfe15a7a15dfcee6,1 +np.float64,0x7fe36991e766d323,0xbfeb288077c4ed9f,1 +np.float64,0x7fdcf4f4fcb9e9e9,0xbfea331ef7a75e7b,1 +np.float64,0x7fbe3445643c688a,0x3fedf21b94ae8e37,1 +np.float64,0x7fd984cfd2b3099f,0x3fc0d3ade71c395e,1 +np.float64,0x7fdec987b23d930e,0x3fe4af5e48f6c26e,1 +np.float64,0x7fde56a9953cad52,0x3fc8e7762cefb8b0,1 +np.float64,0x7fd39fb446273f68,0xbfe6c3443208f44d,1 +np.float64,0x7fc609c1a72c1382,0x3fe884e639571baa,1 +np.float64,0x7fe001be4b20037c,0xbfed0d90cbcb6010,1 +np.float64,0x7fce7ace283cf59b,0xbfd0303792e51f49,1 +np.float64,0x7fe27ba93da4f751,0x3fe548b5ce740d71,1 +np.float64,0x7fcc13c79b38278e,0xbfe2e14f5b64a1e9,1 +np.float64,0x7fc058550620b0a9,0x3fe44bb55ebd0590,1 +np.float64,0x7fa4ba8bf8297517,0x3fee59b39f9d08c4,1 +np.float64,0x7fe50d6872ea1ad0,0xbfea1eaa2d059e13,1 +np.float64,0x7feb7e33b476fc66,0xbfeff28a4424dd3e,1 +np.float64,0x7fe2d7d2a165afa4,0xbfdbaff0ba1ea460,1 +np.float64,0xffd126654b224cca,0xbfef0cd3031fb97c,1 +np.float64,0xffb5f884942bf108,0x3fe0de589bea2e4c,1 +np.float64,0xffe011b4bfe02369,0xbfe805a0edf1e1f2,1 +np.float64,0xffec13eae9b827d5,0x3fb5f30347d78447,1 +np.float64,0xffa6552ae82caa50,0x3fb1ecee60135f2f,1 +np.float64,0xffb62d38b02c5a70,0x3fbd35903148fd12,1 +np.float64,0xffe2c44ea425889d,0xbfd7616547f99a7d,1 +np.float64,0xffea24c61a74498c,0x3fef4a1b15ae9005,1 +np.float64,0xffd23a4ab2a47496,0x3fe933bfaa569ae9,1 +np.float64,0xffc34a073d269410,0xbfeec0f510bb7474,1 +np.float64,0xffeead84cfbd5b09,0x3feb2d635e5a78bd,1 +np.float64,0xffcfd8f3b43fb1e8,0xbfdd59625801771b,1 +np.float64,0xffd3c7f662a78fec,0x3f9cf3209edfbc4e,1 +np.float64,0xffe7b7e4f72f6fca,0xbfefdcff4925632c,1 +np.float64,0xffe48cab05e91956,0x3fe6b41217948423,1 +np.float64,0xffeb6980b336d301,0xbfca5de148f69324,1 +np.float64,0xffe3f15c4aa7e2b8,0xbfeb18efae892081,1 +np.float64,0xffcf290c713e5218,0x3fefe6f1a513ed26,1 +np.float64,0xffd80979b43012f4,0xbfde6c8df91af976,1 +np.float64,0xffc3181e0026303c,0x3fe7448f681def38,1 +np.float64,0xffedfa68f97bf4d1,0xbfeca6efb802d109,1 +np.float64,0xffca0931c0341264,0x3fe31b9f073b08cd,1 +np.float64,0xffe4c44934e98892,0x3feda393a2e8a0f7,1 +np.float64,0xffe65bb56f2cb76a,0xbfeffaf638a4b73e,1 +np.float64,0xffe406a332a80d46,0x3fe8151dadb853c1,1 +np.float64,0xffdb7eae9c36fd5e,0xbfeff89abf5ab16e,1 +np.float64,0xffe245a02da48b40,0x3fef1fb43e85f4b8,1 +np.float64,0xffe2bafa732575f4,0x3fcbab115c6fd86e,1 +np.float64,0xffe8b1eedb7163dd,0x3feff263df6f6b12,1 +np.float64,0xffe6c76c796d8ed8,0xbfe61a8668511293,1 +np.float64,0xffefe327d1ffc64f,0xbfd9b92887a84827,1 +np.float64,0xffa452180c28a430,0xbfa9b9e578a4e52f,1 +np.float64,0xffe9867d0bf30cf9,0xbfca577867588408,1 +np.float64,0xffdfe9b923bfd372,0x3fdab5c15f085c2d,1 +np.float64,0xffed590c6abab218,0xbfd7e7b6c5a120e6,1 +np.float64,0xffeaebcfbab5d79f,0x3fed58be8a9e2c3b,1 +np.float64,0xffe2ba83a8257507,0x3fe6c42a4ac1d4d9,1 +np.float64,0xffe01d5b0ee03ab6,0xbfe5dad6c9247db7,1 +np.float64,0xffe51095d52a212b,0x3fef822cebc32d8e,1 +np.float64,0xffebd7a901b7af51,0xbfe5e63f3e3b1185,1 +np.float64,0xffe4efdcde29dfb9,0xbfe811294dfa758f,1 +np.float64,0xffe3be1aa4a77c35,0x3fdd8dcfcd409bb1,1 +np.float64,0xffbe6f2f763cde60,0x3fd13766e43bd622,1 +np.float64,0xffeed3d80fbda7af,0x3fec10a23c1b7a4a,1 +np.float64,0xffd6ebff37add7fe,0xbfe6177411607c86,1 +np.float64,0xffe85a90f4b0b521,0x3fc09fdd66c8fde9,1 +np.float64,0xffea3d58c2b47ab1,0x3feb5bd4a04b3562,1 +np.float64,0xffef675be6beceb7,0x3fecd840683d1044,1 +np.float64,0xff726a088024d400,0x3feff2b4f47b5214,1 +np.float64,0xffc90856733210ac,0xbfe3c6ffbf6840a5,1 +np.float64,0xffc0b58d9a216b1c,0xbfe10314267d0611,1 +np.float64,0xffee1f3d0abc3e79,0xbfd12ea7efea9067,1 +np.float64,0xffd988c41a331188,0x3febe83802d8a32e,1 +np.float64,0xffe8f1ac9bb1e358,0xbfdbf5fa7e84f2f2,1 +np.float64,0xffe47af279e8f5e4,0x3fef11e339e5fa78,1 +np.float64,0xff9960a7f832c140,0xbfa150363f8ec5b2,1 +np.float64,0xffcac40fa7358820,0xbfec3d5847a3df1d,1 +np.float64,0xffcb024a9d360494,0xbfd060fa31fd6b6a,1 +np.float64,0xffe385ffb3270bff,0xbfee6859e8dcd9e8,1 +np.float64,0xffef62f2c53ec5e5,0x3fe0a71ffddfc718,1 +np.float64,0xffed87ff20fb0ffd,0xbfe661db7c4098e3,1 +np.float64,0xffe369278526d24e,0x3fd64d89a41822fc,1 +np.float64,0xff950288c02a0520,0x3fe1df91d1ad7d5c,1 +np.float64,0xffe70e7c2cee1cf8,0x3fc9fece08df2fd8,1 +np.float64,0xffbaf020b635e040,0xbfc68c43ff9911a7,1 +np.float64,0xffee0120b0fc0240,0x3f9f792e17b490b0,1 +np.float64,0xffe1fa4be7a3f498,0xbfef4b18ab4b319e,1 +np.float64,0xffe61887bf2c310f,0x3fe846714826cb32,1 +np.float64,0xffdc3cf77f3879ee,0x3fe033b948a36125,1 +np.float64,0xffcc2b86f238570c,0xbfefdcceac3f220f,1 +np.float64,0xffe1f030c0a3e061,0x3fef502a808c359a,1 +np.float64,0xffb872c4ee30e588,0x3fef66ed8d3e6175,1 +np.float64,0xffeac8fc617591f8,0xbfe5d8448602aac9,1 +np.float64,0xffe5be16afab7c2d,0x3fee75ccde3cd14d,1 +np.float64,0xffae230ad83c4610,0xbfe49bbe6074d459,1 +np.float64,0xffc8fbeff531f7e0,0x3f77201e0c927f97,1 +np.float64,0xffdc314f48b8629e,0x3fef810dfc5db118,1 +np.float64,0xffec1f8970783f12,0x3fe15567102e042a,1 +np.float64,0xffc6995f902d32c0,0xbfecd5d2eedf342c,1 +np.float64,0xffdc7af76b38f5ee,0xbfd6e754476ab320,1 +np.float64,0xffb30cf8682619f0,0x3fd5ac3dfc4048d0,1 +np.float64,0xffd3a77695a74eee,0xbfefb5d6889e36e9,1 +np.float64,0xffd8b971803172e4,0xbfeb7f62f0b6c70b,1 +np.float64,0xffde4c0234bc9804,0xbfed50ba9e16d5e0,1 +np.float64,0xffb62b3f342c5680,0xbfeabc0de4069b84,1 +np.float64,0xff9af5674035eac0,0xbfed6c198b6b1bd8,1 +np.float64,0xffdfe20cb43fc41a,0x3fb11f8238f66306,1 +np.float64,0xffd2ecd7a0a5d9b0,0xbfec17ef1a62b1e3,1 +np.float64,0xffce60f7863cc1f0,0x3fe6dbcad3e3a006,1 +np.float64,0xffbbb8306a377060,0xbfbfd0fbef485c4c,1 +np.float64,0xffd1b2bd2b23657a,0xbfda3e046d987b99,1 +np.float64,0xffc480f4092901e8,0xbfeeff0427f6897b,1 +np.float64,0xffe6e02d926dc05a,0xbfcd59552778890b,1 +np.float64,0xffd302e5b7a605cc,0xbfee7c08641366b0,1 +np.float64,0xffec2eb92f785d72,0xbfef5c9c7f771050,1 +np.float64,0xffea3e31a9747c62,0xbfc49cd54755faf0,1 +np.float64,0xffce0a4e333c149c,0x3feeb9a6d0db4aee,1 +np.float64,0xffdc520a2db8a414,0x3fefc7b72613dcd0,1 +np.float64,0xffe056b968a0ad72,0xbfe47a9fe1f827fb,1 +np.float64,0xffe5a10f4cab421e,0x3fec2b1f74b73dec,1 diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/data/umath-validation-set-sinh.csv b/venv/lib/python3.12/site-packages/numpy/_core/tests/data/umath-validation-set-sinh.csv new file mode 100644 index 00000000..1ef7b6e7 --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/tests/data/umath-validation-set-sinh.csv @@ -0,0 +1,1429 @@ +dtype,input,output,ulperrortol +np.float32,0xfee27582,0xff800000,2 +np.float32,0xff19f092,0xff800000,2 +np.float32,0xbf393576,0xbf49cb31,2 +np.float32,0x8020fdea,0x8020fdea,2 +np.float32,0x455f4e,0x455f4e,2 +np.float32,0xff718c35,0xff800000,2 +np.float32,0x3f3215e3,0x3f40cce5,2 +np.float32,0x19e833,0x19e833,2 +np.float32,0xff2dcd49,0xff800000,2 +np.float32,0x7e8f6c95,0x7f800000,2 +np.float32,0xbf159dac,0xbf1e47a5,2 +np.float32,0x100d3d,0x100d3d,2 +np.float32,0xff673441,0xff800000,2 +np.float32,0x80275355,0x80275355,2 +np.float32,0x4812d0,0x4812d0,2 +np.float32,0x8072b956,0x8072b956,2 +np.float32,0xff3bb918,0xff800000,2 +np.float32,0x0,0x0,2 +np.float32,0xfe327798,0xff800000,2 +np.float32,0x41d4e2,0x41d4e2,2 +np.float32,0xfe34b1b8,0xff800000,2 +np.float32,0x80199f72,0x80199f72,2 +np.float32,0x807242ce,0x807242ce,2 +np.float32,0x3ef4202d,0x3efd7b48,2 +np.float32,0x763529,0x763529,2 +np.float32,0x4f6662,0x4f6662,2 +np.float32,0x3f18efe9,0x3f2232b5,2 +np.float32,0x80701846,0x80701846,2 +np.float32,0x3f599948,0x3f74c393,2 +np.float32,0x5a3d69,0x5a3d69,2 +np.float32,0xbf4a7e65,0xbf6047a3,2 +np.float32,0xff0d4c82,0xff800000,2 +np.float32,0x7a74db,0x7a74db,2 +np.float32,0x803388e6,0x803388e6,2 +np.float32,0x7f4430bb,0x7f800000,2 +np.float32,0x14c5b1,0x14c5b1,2 +np.float32,0xfa113400,0xff800000,2 +np.float32,0x7f4b3209,0x7f800000,2 +np.float32,0x8038d88c,0x8038d88c,2 +np.float32,0xbef2f9de,0xbefc330b,2 +np.float32,0xbe147b38,0xbe15008f,2 +np.float32,0x2b61e6,0x2b61e6,2 +np.float32,0x80000001,0x80000001,2 +np.float32,0x8060456c,0x8060456c,2 +np.float32,0x3f30fa82,0x3f3f6a99,2 +np.float32,0xfd1f0220,0xff800000,2 +np.float32,0xbf2b7555,0xbf389151,2 +np.float32,0xff100b7a,0xff800000,2 +np.float32,0x70d3cd,0x70d3cd,2 +np.float32,0x2a8d4a,0x2a8d4a,2 +np.float32,0xbf7b733f,0xbf92f05f,2 +np.float32,0x3f7106dc,0x3f8b1fc6,2 +np.float32,0x3f39da7a,0x3f4a9d79,2 +np.float32,0x3f5dd73f,0x3f7aaab5,2 +np.float32,0xbe8c8754,0xbe8e4cba,2 +np.float32,0xbf6c74c9,0xbf87c556,2 +np.float32,0x800efbbb,0x800efbbb,2 +np.float32,0xff054ab5,0xff800000,2 +np.float32,0x800b4b46,0x800b4b46,2 +np.float32,0xff77fd74,0xff800000,2 +np.float32,0x257d0,0x257d0,2 +np.float32,0x7caa0c,0x7caa0c,2 +np.float32,0x8025d24d,0x8025d24d,2 +np.float32,0x3d9f1b60,0x3d9f445c,2 +np.float32,0xbe3bf6e8,0xbe3d0595,2 +np.float32,0x54bb93,0x54bb93,2 +np.float32,0xbf3e6a45,0xbf507716,2 +np.float32,0x3f4bb26e,0x3f61e1cd,2 +np.float32,0x3f698edc,0x3f85aac5,2 +np.float32,0xff7bd0ef,0xff800000,2 +np.float32,0xbed07b68,0xbed64a8e,2 +np.float32,0xbf237c72,0xbf2ed3d2,2 +np.float32,0x27b0fa,0x27b0fa,2 +np.float32,0x3f7606d1,0x3f8ed7d6,2 +np.float32,0x790dc0,0x790dc0,2 +np.float32,0x7f68f3ac,0x7f800000,2 +np.float32,0xbed39288,0xbed9a52f,2 +np.float32,0x3f6f8266,0x3f8a0187,2 +np.float32,0x3fbdca,0x3fbdca,2 +np.float32,0xbf7c3e5d,0xbf938b2c,2 +np.float32,0x802321a8,0x802321a8,2 +np.float32,0x3eecab66,0x3ef53031,2 +np.float32,0x62b324,0x62b324,2 +np.float32,0x3f13afac,0x3f1c03fe,2 +np.float32,0xff315ad7,0xff800000,2 +np.float32,0xbf1fac0d,0xbf2a3a63,2 +np.float32,0xbf543984,0xbf6d61d6,2 +np.float32,0x71a212,0x71a212,2 +np.float32,0x114fbe,0x114fbe,2 +np.float32,0x3f5b6ff2,0x3f77505f,2 +np.float32,0xff6ff89e,0xff800000,2 +np.float32,0xff4527a1,0xff800000,2 +np.float32,0x22cb3,0x22cb3,2 +np.float32,0x7f53bb6b,0x7f800000,2 +np.float32,0xff3d2dea,0xff800000,2 +np.float32,0xfd21dac0,0xff800000,2 +np.float32,0xfc486140,0xff800000,2 +np.float32,0x7e2b693a,0x7f800000,2 +np.float32,0x8022a9fb,0x8022a9fb,2 +np.float32,0x80765de0,0x80765de0,2 +np.float32,0x13d299,0x13d299,2 +np.float32,0x7ee53713,0x7f800000,2 +np.float32,0xbde1c770,0xbde23c96,2 +np.float32,0xbd473fc0,0xbd4753de,2 +np.float32,0x3f1cb455,0x3f26acf3,2 +np.float32,0x683e49,0x683e49,2 +np.float32,0x3ed5a9fc,0x3edbeb79,2 +np.float32,0x3f4fe3f6,0x3f67814f,2 +np.float32,0x802a2bce,0x802a2bce,2 +np.float32,0x7e951b4c,0x7f800000,2 +np.float32,0xbe6eb260,0xbe70dd44,2 +np.float32,0xbe3daca8,0xbe3ec2cb,2 +np.float32,0xbe9c38b2,0xbe9ea822,2 +np.float32,0xff2e29dc,0xff800000,2 +np.float32,0x7f62c7cc,0x7f800000,2 +np.float32,0xbf6799a4,0xbf84416c,2 +np.float32,0xbe30a7f0,0xbe318898,2 +np.float32,0xc83d9,0xc83d9,2 +np.float32,0x3f05abf4,0x3f0bd447,2 +np.float32,0x7e9b018a,0x7f800000,2 +np.float32,0xbf0ed72e,0xbf165e5b,2 +np.float32,0x8011ac8c,0x8011ac8c,2 +np.float32,0xbeb7c706,0xbebbbfcb,2 +np.float32,0x803637f9,0x803637f9,2 +np.float32,0xfe787cc8,0xff800000,2 +np.float32,0x3f533d4b,0x3f6c0a50,2 +np.float32,0x3f5c0f1c,0x3f782dde,2 +np.float32,0x3f301f36,0x3f3e590d,2 +np.float32,0x2dc929,0x2dc929,2 +np.float32,0xff15018a,0xff800000,2 +np.float32,0x3f4d0c56,0x3f63afeb,2 +np.float32,0xbf7a2ae3,0xbf91f6e4,2 +np.float32,0xbe771b84,0xbe798346,2 +np.float32,0x80800000,0x80800000,2 +np.float32,0x7f5689ba,0x7f800000,2 +np.float32,0x3f1c3177,0x3f2610df,2 +np.float32,0x3f1b9664,0x3f255825,2 +np.float32,0x3f7e5066,0x3f9520d4,2 +np.float32,0xbf1935f8,0xbf2285ab,2 +np.float32,0x3f096cc7,0x3f101ef9,2 +np.float32,0x8030c180,0x8030c180,2 +np.float32,0x6627ed,0x6627ed,2 +np.float32,0x454595,0x454595,2 +np.float32,0x7de66a33,0x7f800000,2 +np.float32,0xbf800000,0xbf966cfe,2 +np.float32,0xbf35c0a8,0xbf456939,2 +np.float32,0x3f6a6266,0x3f8643e0,2 +np.float32,0x3f0cbcee,0x3f13ef6a,2 +np.float32,0x7efd1e58,0x7f800000,2 +np.float32,0xfe9a74c6,0xff800000,2 +np.float32,0x807ebe6c,0x807ebe6c,2 +np.float32,0x80656736,0x80656736,2 +np.float32,0x800e0608,0x800e0608,2 +np.float32,0xbf30e39a,0xbf3f4e00,2 +np.float32,0x802015fd,0x802015fd,2 +np.float32,0x3e3ce26d,0x3e3df519,2 +np.float32,0x7ec142ac,0x7f800000,2 +np.float32,0xbf68c9ce,0xbf851c78,2 +np.float32,0xfede8356,0xff800000,2 +np.float32,0xbf1507ce,0xbf1d978d,2 +np.float32,0x3e53914c,0x3e551374,2 +np.float32,0x7f3e1c14,0x7f800000,2 +np.float32,0x8070d2ba,0x8070d2ba,2 +np.float32,0xbf4eb793,0xbf65ecee,2 +np.float32,0x7365a6,0x7365a6,2 +np.float32,0x8045cba2,0x8045cba2,2 +np.float32,0x7e4af521,0x7f800000,2 +np.float32,0xbf228625,0xbf2da9e1,2 +np.float32,0x7ee0536c,0x7f800000,2 +np.float32,0x3e126607,0x3e12e5d5,2 +np.float32,0x80311d92,0x80311d92,2 +np.float32,0xbf386b8b,0xbf48ca54,2 +np.float32,0x7f800000,0x7f800000,2 +np.float32,0x8049ec7a,0x8049ec7a,2 +np.float32,0xbf1dfde4,0xbf2836be,2 +np.float32,0x7e719a8c,0x7f800000,2 +np.float32,0x3eb9c856,0x3ebde2e6,2 +np.float32,0xfe3efda8,0xff800000,2 +np.float32,0xbe89d60c,0xbe8b81d1,2 +np.float32,0x3eaad338,0x3eae0317,2 +np.float32,0x7f4e5217,0x7f800000,2 +np.float32,0x3e9d0f40,0x3e9f88ce,2 +np.float32,0xbe026708,0xbe02c155,2 +np.float32,0x5fc22f,0x5fc22f,2 +np.float32,0x1c4572,0x1c4572,2 +np.float32,0xbed89d96,0xbedf22c5,2 +np.float32,0xbf3debee,0xbf4fd441,2 +np.float32,0xbf465520,0xbf5ac6e5,2 +np.float32,0x3f797081,0x3f9169b3,2 +np.float32,0xbf250734,0xbf30b2aa,2 +np.float32,0x7f5068e9,0x7f800000,2 +np.float32,0x3f1b814e,0x3f253f0c,2 +np.float32,0xbf27c5d3,0xbf340b05,2 +np.float32,0x3f1b78ae,0x3f2534c8,2 +np.float32,0x8059b51a,0x8059b51a,2 +np.float32,0x8059f182,0x8059f182,2 +np.float32,0xbf1bb36e,0xbf257ab8,2 +np.float32,0x41ac35,0x41ac35,2 +np.float32,0x68f41f,0x68f41f,2 +np.float32,0xbea504dc,0xbea7e40f,2 +np.float32,0x1,0x1,2 +np.float32,0x3e96b5b0,0x3e98e542,2 +np.float32,0x7f7fffff,0x7f800000,2 +np.float32,0x3c557a80,0x3c557c0c,2 +np.float32,0x800ca3ec,0x800ca3ec,2 +np.float32,0x8077d4aa,0x8077d4aa,2 +np.float32,0x3f000af0,0x3f0572d6,2 +np.float32,0x3e0434dd,0x3e0492f8,2 +np.float32,0x7d1a710a,0x7f800000,2 +np.float32,0x3f70f996,0x3f8b15f8,2 +np.float32,0x8033391d,0x8033391d,2 +np.float32,0x11927c,0x11927c,2 +np.float32,0x7f7784be,0x7f800000,2 +np.float32,0x7acb22af,0x7f800000,2 +np.float32,0x7e8b153c,0x7f800000,2 +np.float32,0x66d402,0x66d402,2 +np.float32,0xfed6e7b0,0xff800000,2 +np.float32,0x7f6872d3,0x7f800000,2 +np.float32,0x1bd49c,0x1bd49c,2 +np.float32,0xfdc4f1b8,0xff800000,2 +np.float32,0xbed8a466,0xbedf2a33,2 +np.float32,0x7ee789,0x7ee789,2 +np.float32,0xbece94b4,0xbed43b52,2 +np.float32,0x3cf3f734,0x3cf4006f,2 +np.float32,0x7e44aa00,0x7f800000,2 +np.float32,0x7f19e99c,0x7f800000,2 +np.float32,0x806ff1bc,0x806ff1bc,2 +np.float32,0x80296934,0x80296934,2 +np.float32,0x7f463363,0x7f800000,2 +np.float32,0xbf212ac3,0xbf2c06bb,2 +np.float32,0x3dc63778,0x3dc686ba,2 +np.float32,0x7f1b4328,0x7f800000,2 +np.float32,0x6311f6,0x6311f6,2 +np.float32,0xbf6b6fb6,0xbf870751,2 +np.float32,0xbf2c44cf,0xbf399155,2 +np.float32,0x3e7a67bc,0x3e7ce887,2 +np.float32,0x7f57c5f7,0x7f800000,2 +np.float32,0x7f2bb4ff,0x7f800000,2 +np.float32,0xbe9d448e,0xbe9fc0a4,2 +np.float32,0xbf4840f0,0xbf5d4f6b,2 +np.float32,0x7f1e1176,0x7f800000,2 +np.float32,0xff76638e,0xff800000,2 +np.float32,0xff055555,0xff800000,2 +np.float32,0x3f32b82b,0x3f419834,2 +np.float32,0xff363aa8,0xff800000,2 +np.float32,0x7f737fd0,0x7f800000,2 +np.float32,0x3da5d798,0x3da60602,2 +np.float32,0x3f1cc126,0x3f26bc3e,2 +np.float32,0x7eb07541,0x7f800000,2 +np.float32,0x3f7b2ff2,0x3f92bd2a,2 +np.float32,0x474f7,0x474f7,2 +np.float32,0x7fc00000,0x7fc00000,2 +np.float32,0xff2b0a4e,0xff800000,2 +np.float32,0xfeb24f16,0xff800000,2 +np.float32,0x2cb9fc,0x2cb9fc,2 +np.float32,0x67189d,0x67189d,2 +np.float32,0x8033d854,0x8033d854,2 +np.float32,0xbe85e94c,0xbe87717a,2 +np.float32,0x80767c6c,0x80767c6c,2 +np.float32,0x7ea84d65,0x7f800000,2 +np.float32,0x3f024bc7,0x3f07fead,2 +np.float32,0xbdcb0100,0xbdcb5625,2 +np.float32,0x3f160a9e,0x3f1ec7c9,2 +np.float32,0xff1734c8,0xff800000,2 +np.float32,0x7f424d5e,0x7f800000,2 +np.float32,0xbf75b215,0xbf8e9862,2 +np.float32,0x3f262a42,0x3f3214c4,2 +np.float32,0xbf4cfb53,0xbf639927,2 +np.float32,0x3f4ac8b8,0x3f60aa7c,2 +np.float32,0x3e90e593,0x3e92d6b3,2 +np.float32,0xbf66bccf,0xbf83a2d8,2 +np.float32,0x7d3d851a,0x7f800000,2 +np.float32,0x7bac783c,0x7f800000,2 +np.float32,0x8001c626,0x8001c626,2 +np.float32,0xbdffd480,0xbe003f7b,2 +np.float32,0x7f6680bf,0x7f800000,2 +np.float32,0xbecf448e,0xbed4f9bb,2 +np.float32,0x584c7,0x584c7,2 +np.float32,0x3f3e8ea0,0x3f50a5fb,2 +np.float32,0xbf5a5f04,0xbf75d56e,2 +np.float32,0x8065ae47,0x8065ae47,2 +np.float32,0xbf48dce3,0xbf5e1dba,2 +np.float32,0xbe8dae2e,0xbe8f7ed8,2 +np.float32,0x3f7ca6ab,0x3f93dace,2 +np.float32,0x4c3e81,0x4c3e81,2 +np.float32,0x80000000,0x80000000,2 +np.float32,0x3ee1f7d9,0x3ee96033,2 +np.float32,0x80588c6f,0x80588c6f,2 +np.float32,0x5ba34e,0x5ba34e,2 +np.float32,0x80095d28,0x80095d28,2 +np.float32,0xbe7ba198,0xbe7e2bdd,2 +np.float32,0xbe0bdcb4,0xbe0c4c22,2 +np.float32,0x1776f7,0x1776f7,2 +np.float32,0x80328b2a,0x80328b2a,2 +np.float32,0x3e978d37,0x3e99c63e,2 +np.float32,0x7ed50906,0x7f800000,2 +np.float32,0x3f776a54,0x3f8fe2bd,2 +np.float32,0xbed624c4,0xbedc7120,2 +np.float32,0x7f0b6a31,0x7f800000,2 +np.float32,0x7eb13913,0x7f800000,2 +np.float32,0xbe733684,0xbe758190,2 +np.float32,0x80016474,0x80016474,2 +np.float32,0x7a51ee,0x7a51ee,2 +np.float32,0x3f6cb91e,0x3f87f729,2 +np.float32,0xbd99b050,0xbd99d540,2 +np.float32,0x7c6e3cba,0x7f800000,2 +np.float32,0xbf00179a,0xbf05811e,2 +np.float32,0x3e609b29,0x3e626954,2 +np.float32,0xff3fd71a,0xff800000,2 +np.float32,0x5d8c2,0x5d8c2,2 +np.float32,0x7ee93662,0x7f800000,2 +np.float32,0x4b0b31,0x4b0b31,2 +np.float32,0x3ec243b7,0x3ec6f594,2 +np.float32,0x804d60f1,0x804d60f1,2 +np.float32,0xbf0cb784,0xbf13e929,2 +np.float32,0x3f13b74d,0x3f1c0cee,2 +np.float32,0xfe37cb64,0xff800000,2 +np.float32,0x1a88,0x1a88,2 +np.float32,0x3e22a472,0x3e2353ba,2 +np.float32,0x7f07d6a0,0x7f800000,2 +np.float32,0x3f78f435,0x3f910bb5,2 +np.float32,0x555a4a,0x555a4a,2 +np.float32,0x3e306c1f,0x3e314be3,2 +np.float32,0x8005877c,0x8005877c,2 +np.float32,0x4df389,0x4df389,2 +np.float32,0x8069ffc7,0x8069ffc7,2 +np.float32,0x3f328f24,0x3f4164c6,2 +np.float32,0x53a31b,0x53a31b,2 +np.float32,0xbe4d6768,0xbe4ec8be,2 +np.float32,0x7fa00000,0x7fe00000,2 +np.float32,0x3f484c1b,0x3f5d5e2f,2 +np.float32,0x8038be05,0x8038be05,2 +np.float32,0x58ac0f,0x58ac0f,2 +np.float32,0x7ed7fb72,0x7f800000,2 +np.float32,0x5a22e1,0x5a22e1,2 +np.float32,0xbebb7394,0xbebfaad6,2 +np.float32,0xbda98160,0xbda9b2ef,2 +np.float32,0x7f3e5c42,0x7f800000,2 +np.float32,0xfed204ae,0xff800000,2 +np.float32,0xbf5ef782,0xbf7c3ec5,2 +np.float32,0xbef7a0a8,0xbf00b292,2 +np.float32,0xfee6e176,0xff800000,2 +np.float32,0xfe121140,0xff800000,2 +np.float32,0xfe9e13be,0xff800000,2 +np.float32,0xbf3c98b1,0xbf4e2003,2 +np.float32,0x77520d,0x77520d,2 +np.float32,0xf17b2,0xf17b2,2 +np.float32,0x724d2f,0x724d2f,2 +np.float32,0x7eb326f5,0x7f800000,2 +np.float32,0x3edd6bf2,0x3ee4636e,2 +np.float32,0x350f57,0x350f57,2 +np.float32,0xff7d4435,0xff800000,2 +np.float32,0x802b2b9d,0x802b2b9d,2 +np.float32,0xbf7fbeee,0xbf963acf,2 +np.float32,0x804f3100,0x804f3100,2 +np.float32,0x7c594a71,0x7f800000,2 +np.float32,0x3ef49340,0x3efdfbb6,2 +np.float32,0x2e0659,0x2e0659,2 +np.float32,0x8006d5fe,0x8006d5fe,2 +np.float32,0xfd2a00b0,0xff800000,2 +np.float32,0xbee1c016,0xbee922ed,2 +np.float32,0x3e3b7de8,0x3e3c8a8b,2 +np.float32,0x805e6bba,0x805e6bba,2 +np.float32,0x1a7da2,0x1a7da2,2 +np.float32,0x6caba4,0x6caba4,2 +np.float32,0x802f7eab,0x802f7eab,2 +np.float32,0xff68b16b,0xff800000,2 +np.float32,0x8064f5e5,0x8064f5e5,2 +np.float32,0x2e39b4,0x2e39b4,2 +np.float32,0x800000,0x800000,2 +np.float32,0xfd0334c0,0xff800000,2 +np.float32,0x3e952fc4,0x3e974e7e,2 +np.float32,0x80057d33,0x80057d33,2 +np.float32,0x3ed3ddc4,0x3ed9f6f1,2 +np.float32,0x3f74ce18,0x3f8dedf4,2 +np.float32,0xff6bb7c0,0xff800000,2 +np.float32,0xff43bc21,0xff800000,2 +np.float32,0x80207570,0x80207570,2 +np.float32,0x7e1dda75,0x7f800000,2 +np.float32,0x3efe335c,0x3f0462ff,2 +np.float32,0xbf252c0c,0xbf30df70,2 +np.float32,0x3ef4b8e3,0x3efe25ba,2 +np.float32,0x7c33938d,0x7f800000,2 +np.float32,0x3eb1593c,0x3eb4ea95,2 +np.float32,0xfe1d0068,0xff800000,2 +np.float32,0xbf10da9b,0xbf18b551,2 +np.float32,0xfeb65748,0xff800000,2 +np.float32,0xfe8c6014,0xff800000,2 +np.float32,0x3f0503e2,0x3f0b14e3,2 +np.float32,0xfe5e5248,0xff800000,2 +np.float32,0xbd10afa0,0xbd10b754,2 +np.float32,0xff64b609,0xff800000,2 +np.float32,0xbf674a96,0xbf84089c,2 +np.float32,0x7f5d200d,0x7f800000,2 +np.float32,0x3cf44900,0x3cf45245,2 +np.float32,0x8044445a,0x8044445a,2 +np.float32,0xff35b676,0xff800000,2 +np.float32,0x806452cd,0x806452cd,2 +np.float32,0xbf2930fb,0xbf35c7b4,2 +np.float32,0x7e500617,0x7f800000,2 +np.float32,0x543719,0x543719,2 +np.float32,0x3ed11068,0x3ed6ec1d,2 +np.float32,0xbd8db068,0xbd8dcd59,2 +np.float32,0x3ede62c8,0x3ee571d0,2 +np.float32,0xbf00a410,0xbf061f9c,2 +np.float32,0xbf44fa39,0xbf58ff5b,2 +np.float32,0x3f1c3114,0x3f261069,2 +np.float32,0xbdea6210,0xbdeae521,2 +np.float32,0x80059f6d,0x80059f6d,2 +np.float32,0xbdba15f8,0xbdba578c,2 +np.float32,0x6d8a61,0x6d8a61,2 +np.float32,0x6f5428,0x6f5428,2 +np.float32,0x18d0e,0x18d0e,2 +np.float32,0x50e131,0x50e131,2 +np.float32,0x3f2f52be,0x3f3d5a7e,2 +np.float32,0x7399d8,0x7399d8,2 +np.float32,0x106524,0x106524,2 +np.float32,0x7ebf1c53,0x7f800000,2 +np.float32,0x80276458,0x80276458,2 +np.float32,0x3ebbde67,0x3ec01ceb,2 +np.float32,0x80144d9d,0x80144d9d,2 +np.float32,0x8017ea6b,0x8017ea6b,2 +np.float32,0xff38f201,0xff800000,2 +np.float32,0x7f2daa82,0x7f800000,2 +np.float32,0x3f3cb7c7,0x3f4e47ed,2 +np.float32,0x7f08c779,0x7f800000,2 +np.float32,0xbecc907a,0xbed20cec,2 +np.float32,0x7d440002,0x7f800000,2 +np.float32,0xbd410d80,0xbd411fcd,2 +np.float32,0x3d63ae07,0x3d63cc0c,2 +np.float32,0x805a9c13,0x805a9c13,2 +np.float32,0x803bdcdc,0x803bdcdc,2 +np.float32,0xbe88b354,0xbe8a5497,2 +np.float32,0x3f4eaf43,0x3f65e1c2,2 +np.float32,0x3f15e5b8,0x3f1e9c60,2 +np.float32,0x3e8a870c,0x3e8c394e,2 +np.float32,0x7e113de9,0x7f800000,2 +np.float32,0x7ee5ba41,0x7f800000,2 +np.float32,0xbe73d178,0xbe7620eb,2 +np.float32,0xfe972e6a,0xff800000,2 +np.float32,0xbf65567d,0xbf82a25a,2 +np.float32,0x3f38247e,0x3f487010,2 +np.float32,0xbece1c62,0xbed3b918,2 +np.float32,0x442c8d,0x442c8d,2 +np.float32,0x2dc52,0x2dc52,2 +np.float32,0x802ed923,0x802ed923,2 +np.float32,0x788cf8,0x788cf8,2 +np.float32,0x8024888e,0x8024888e,2 +np.float32,0x3f789bde,0x3f90c8fc,2 +np.float32,0x3f5de620,0x3f7abf88,2 +np.float32,0x3f0ffc45,0x3f17b2a7,2 +np.float32,0xbf709678,0xbf8accd4,2 +np.float32,0x12181f,0x12181f,2 +np.float32,0xfe54bbe4,0xff800000,2 +np.float32,0x7f1daba0,0x7f800000,2 +np.float32,0xbf6226df,0xbf805e3c,2 +np.float32,0xbd120610,0xbd120dfb,2 +np.float32,0x7f75e951,0x7f800000,2 +np.float32,0x80068048,0x80068048,2 +np.float32,0x45f04a,0x45f04a,2 +np.float32,0xff4c4f58,0xff800000,2 +np.float32,0x311604,0x311604,2 +np.float32,0x805e809c,0x805e809c,2 +np.float32,0x3d1d62c0,0x3d1d6caa,2 +np.float32,0x7f14ccf9,0x7f800000,2 +np.float32,0xff10017c,0xff800000,2 +np.float32,0xbf43ec48,0xbf579df4,2 +np.float32,0xff64da57,0xff800000,2 +np.float32,0x7f0622c5,0x7f800000,2 +np.float32,0x7f5460cd,0x7f800000,2 +np.float32,0xff0ef1c6,0xff800000,2 +np.float32,0xbece1146,0xbed3ad13,2 +np.float32,0x3f4d457f,0x3f63fc70,2 +np.float32,0xbdc1da28,0xbdc2244b,2 +np.float32,0xbe46d3f4,0xbe481463,2 +np.float32,0xff36b3d6,0xff800000,2 +np.float32,0xbec2e76c,0xbec7a540,2 +np.float32,0x8078fb81,0x8078fb81,2 +np.float32,0x7ec819cb,0x7f800000,2 +np.float32,0x39c4d,0x39c4d,2 +np.float32,0xbe8cddc2,0xbe8ea670,2 +np.float32,0xbf36dffb,0xbf46d48b,2 +np.float32,0xbf2302a3,0xbf2e4065,2 +np.float32,0x3e7b34a2,0x3e7dbb9a,2 +np.float32,0x3e3d87e1,0x3e3e9d62,2 +np.float32,0x7f3c94b1,0x7f800000,2 +np.float32,0x80455a85,0x80455a85,2 +np.float32,0xfd875568,0xff800000,2 +np.float32,0xbf618103,0xbf7fd1c8,2 +np.float32,0xbe332e3c,0xbe3418ac,2 +np.float32,0x80736b79,0x80736b79,2 +np.float32,0x3f705d9a,0x3f8aa2e6,2 +np.float32,0xbf3a36d2,0xbf4b134b,2 +np.float32,0xfddc55c0,0xff800000,2 +np.float32,0x805606fd,0x805606fd,2 +np.float32,0x3f4f0bc4,0x3f665e25,2 +np.float32,0xfebe7494,0xff800000,2 +np.float32,0xff0c541b,0xff800000,2 +np.float32,0xff0b8e7f,0xff800000,2 +np.float32,0xbcc51640,0xbcc51b1e,2 +np.float32,0x7ec1c4d0,0x7f800000,2 +np.float32,0xfc5c8e00,0xff800000,2 +np.float32,0x7f48d682,0x7f800000,2 +np.float32,0x7d5c7d8d,0x7f800000,2 +np.float32,0x8052ed03,0x8052ed03,2 +np.float32,0x7d4db058,0x7f800000,2 +np.float32,0xff3a65ee,0xff800000,2 +np.float32,0x806eeb93,0x806eeb93,2 +np.float32,0x803f9733,0x803f9733,2 +np.float32,0xbf2d1388,0xbf3a90e3,2 +np.float32,0x68e260,0x68e260,2 +np.float32,0x3e47a69f,0x3e48eb0e,2 +np.float32,0x3f0c4623,0x3f136646,2 +np.float32,0x3f37a831,0x3f47d249,2 +np.float32,0xff153a0c,0xff800000,2 +np.float32,0x2e8086,0x2e8086,2 +np.float32,0xc3f5e,0xc3f5e,2 +np.float32,0x7f31dc14,0x7f800000,2 +np.float32,0xfee37d68,0xff800000,2 +np.float32,0x711d4,0x711d4,2 +np.float32,0x7ede2ce4,0x7f800000,2 +np.float32,0xbf5d76d0,0xbf7a23d0,2 +np.float32,0xbe2b9eb4,0xbe2c6cac,2 +np.float32,0x2b14d7,0x2b14d7,2 +np.float32,0x3ea1db72,0x3ea4910e,2 +np.float32,0x7f3f03f7,0x7f800000,2 +np.float32,0x92de5,0x92de5,2 +np.float32,0x80322e1b,0x80322e1b,2 +np.float32,0xbf5eb214,0xbf7bdd55,2 +np.float32,0xbf21bf87,0xbf2cba14,2 +np.float32,0xbf5d4b78,0xbf79e73a,2 +np.float32,0xbc302840,0xbc30291e,2 +np.float32,0xfee567c6,0xff800000,2 +np.float32,0x7f70ee14,0x7f800000,2 +np.float32,0x7e5c4b33,0x7f800000,2 +np.float32,0x3f1e7b64,0x3f28ccfd,2 +np.float32,0xbf6309f7,0xbf80ff3e,2 +np.float32,0x1c2fe3,0x1c2fe3,2 +np.float32,0x8e78d,0x8e78d,2 +np.float32,0x7f2fce73,0x7f800000,2 +np.float32,0x7f25f690,0x7f800000,2 +np.float32,0x8074cba5,0x8074cba5,2 +np.float32,0x16975f,0x16975f,2 +np.float32,0x8012cf5c,0x8012cf5c,2 +np.float32,0x7da72138,0x7f800000,2 +np.float32,0xbf563f35,0xbf7025be,2 +np.float32,0x3f69d3f5,0x3f85dcbe,2 +np.float32,0xbf15c148,0xbf1e7184,2 +np.float32,0xbe7a077c,0xbe7c8564,2 +np.float32,0x3ebb6ef1,0x3ebfa5e3,2 +np.float32,0xbe41fde4,0xbe43277b,2 +np.float32,0x7f10b479,0x7f800000,2 +np.float32,0x3e021ace,0x3e02747d,2 +np.float32,0x3e93d984,0x3e95e9be,2 +np.float32,0xfe17e924,0xff800000,2 +np.float32,0xfe21a7cc,0xff800000,2 +np.float32,0x8019b660,0x8019b660,2 +np.float32,0x7e954631,0x7f800000,2 +np.float32,0x7e7330d1,0x7f800000,2 +np.float32,0xbe007d98,0xbe00d3fb,2 +np.float32,0x3ef3870e,0x3efcd077,2 +np.float32,0x7f5bbde8,0x7f800000,2 +np.float32,0x14a5b3,0x14a5b3,2 +np.float32,0x3e84d23f,0x3e8650e8,2 +np.float32,0x80763017,0x80763017,2 +np.float32,0xfe871f36,0xff800000,2 +np.float32,0x7ed43150,0x7f800000,2 +np.float32,0x3cc44547,0x3cc44a16,2 +np.float32,0x3ef0c0fa,0x3ef9b97d,2 +np.float32,0xbede9944,0xbee5ad86,2 +np.float32,0xbf10f0b2,0xbf18cf0a,2 +np.float32,0x3ecdaa78,0x3ed33dd9,2 +np.float32,0x3f7cc058,0x3f93ee6b,2 +np.float32,0x2d952f,0x2d952f,2 +np.float32,0x3f2cf2de,0x3f3a687a,2 +np.float32,0x8029b33c,0x8029b33c,2 +np.float32,0xbf22c737,0xbf2df888,2 +np.float32,0xff53c84a,0xff800000,2 +np.float32,0x40a509,0x40a509,2 +np.float32,0x56abce,0x56abce,2 +np.float32,0xff7fffff,0xff800000,2 +np.float32,0xbf3e67f6,0xbf50741c,2 +np.float32,0xfde67580,0xff800000,2 +np.float32,0x3f103e9b,0x3f17ffc7,2 +np.float32,0x3f3f7232,0x3f51cbe2,2 +np.float32,0x803e6d78,0x803e6d78,2 +np.float32,0x3a61da,0x3a61da,2 +np.float32,0xbc04de80,0xbc04dedf,2 +np.float32,0x7f1e7c52,0x7f800000,2 +np.float32,0x8058ee88,0x8058ee88,2 +np.float32,0x806dd660,0x806dd660,2 +np.float32,0x7e4af9,0x7e4af9,2 +np.float32,0x80702d27,0x80702d27,2 +np.float32,0x802cdad1,0x802cdad1,2 +np.float32,0x3e9b5c23,0x3e9dc149,2 +np.float32,0x7f076e89,0x7f800000,2 +np.float32,0x7f129d68,0x7f800000,2 +np.float32,0x7f6f0b0a,0x7f800000,2 +np.float32,0x7eafafb5,0x7f800000,2 +np.float32,0xbf2ef2ca,0xbf3ce332,2 +np.float32,0xff34c000,0xff800000,2 +np.float32,0x7f559274,0x7f800000,2 +np.float32,0xfed08556,0xff800000,2 +np.float32,0xbf014621,0xbf06d6ad,2 +np.float32,0xff23086a,0xff800000,2 +np.float32,0x6cb33f,0x6cb33f,2 +np.float32,0xfe6e3ffc,0xff800000,2 +np.float32,0x3e6bbec0,0x3e6dd546,2 +np.float32,0x8036afa6,0x8036afa6,2 +np.float32,0xff800000,0xff800000,2 +np.float32,0x3e0ed05c,0x3e0f46ff,2 +np.float32,0x3ec9215c,0x3ece57e6,2 +np.float32,0xbf449fa4,0xbf5888aa,2 +np.float32,0xff2c6640,0xff800000,2 +np.float32,0x7f08f4a7,0x7f800000,2 +np.float32,0xbf4f63e5,0xbf66d4c1,2 +np.float32,0x3f800000,0x3f966cfe,2 +np.float32,0xfe86c7d2,0xff800000,2 +np.float32,0x3f63f969,0x3f81a970,2 +np.float32,0xbd7022d0,0xbd704609,2 +np.float32,0xbead906c,0xbeb0e853,2 +np.float32,0x7ef149ee,0x7f800000,2 +np.float32,0xff0b9ff7,0xff800000,2 +np.float32,0x3f38380d,0x3f4888e7,2 +np.float32,0x3ef3a3e2,0x3efcf09e,2 +np.float32,0xff616477,0xff800000,2 +np.float32,0x3f3f83e4,0x3f51e2c3,2 +np.float32,0xbf79963c,0xbf918642,2 +np.float32,0x801416f4,0x801416f4,2 +np.float32,0xff75ce6d,0xff800000,2 +np.float32,0xbdbf3588,0xbdbf7cad,2 +np.float32,0xbe6ea938,0xbe70d3dc,2 +np.float32,0x8066f977,0x8066f977,2 +np.float32,0x3f5b5362,0x3f7728aa,2 +np.float32,0xbf72052c,0xbf8bdbd8,2 +np.float32,0xbe21ed74,0xbe229a6f,2 +np.float32,0x8062d19c,0x8062d19c,2 +np.float32,0x3ed8d01f,0x3edf59e6,2 +np.float32,0x803ed42b,0x803ed42b,2 +np.float32,0xbe099a64,0xbe0a0481,2 +np.float32,0xbe173eb4,0xbe17cba2,2 +np.float32,0xbebdcf02,0xbec22faf,2 +np.float32,0x7e3ff29e,0x7f800000,2 +np.float32,0x367c92,0x367c92,2 +np.float32,0xbf5c9db8,0xbf78f4a4,2 +np.float32,0xff0b49ea,0xff800000,2 +np.float32,0x3f4f9bc4,0x3f672001,2 +np.float32,0x85d4a,0x85d4a,2 +np.float32,0x80643e33,0x80643e33,2 +np.float32,0x8013aabd,0x8013aabd,2 +np.float32,0xff6997c3,0xff800000,2 +np.float32,0x3f4dd43c,0x3f64bbb6,2 +np.float32,0xff13bbb9,0xff800000,2 +np.float32,0x3f34efa2,0x3f446187,2 +np.float32,0x3e4b2f10,0x3e4c850d,2 +np.float32,0xfef695c6,0xff800000,2 +np.float32,0x7f7e0057,0x7f800000,2 +np.float32,0x3f6e1b9c,0x3f88fa40,2 +np.float32,0x806e46cf,0x806e46cf,2 +np.float32,0x3f15a88a,0x3f1e546c,2 +np.float32,0xbd2de7d0,0xbd2df530,2 +np.float32,0xbf63cae0,0xbf818854,2 +np.float32,0xbdc3e1a0,0xbdc42e1e,2 +np.float32,0xbf11a038,0xbf199b98,2 +np.float32,0xbec13706,0xbec5d56b,2 +np.float32,0x3f1c5f54,0x3f26478d,2 +np.float32,0x3e9ea97e,0x3ea136b4,2 +np.float32,0xfeb5a508,0xff800000,2 +np.float32,0x7f4698f4,0x7f800000,2 +np.float32,0xff51ee2c,0xff800000,2 +np.float32,0xff5994df,0xff800000,2 +np.float32,0x4b9fb9,0x4b9fb9,2 +np.float32,0xfda10d98,0xff800000,2 +np.float32,0x525555,0x525555,2 +np.float32,0x7ed571ef,0x7f800000,2 +np.float32,0xbf600d18,0xbf7dc50c,2 +np.float32,0x3ec674ca,0x3ecb768b,2 +np.float32,0x3cb69115,0x3cb694f3,2 +np.float32,0x7eac75f2,0x7f800000,2 +np.float32,0x804d4d75,0x804d4d75,2 +np.float32,0xfed5292e,0xff800000,2 +np.float32,0x800ed06a,0x800ed06a,2 +np.float32,0xfec37584,0xff800000,2 +np.float32,0x3ef96ac7,0x3f01b326,2 +np.float32,0x42f743,0x42f743,2 +np.float32,0x3f56f442,0x3f711e39,2 +np.float32,0xbf7ea726,0xbf956375,2 +np.float32,0x806c7202,0x806c7202,2 +np.float32,0xbd8ee980,0xbd8f0733,2 +np.float32,0xbdf2e930,0xbdf37b18,2 +np.float32,0x3f103910,0x3f17f955,2 +np.float32,0xff123e8f,0xff800000,2 +np.float32,0x806e4b5d,0x806e4b5d,2 +np.float32,0xbf4f3bfc,0xbf669f07,2 +np.float32,0xbf070c16,0xbf0d6609,2 +np.float32,0xff00e0ba,0xff800000,2 +np.float32,0xff49d828,0xff800000,2 +np.float32,0x7e47f04a,0x7f800000,2 +np.float32,0x7e984dac,0x7f800000,2 +np.float32,0x3f77473c,0x3f8fc858,2 +np.float32,0x3f017439,0x3f070ac8,2 +np.float32,0x118417,0x118417,2 +np.float32,0xbcf7a2c0,0xbcf7ac68,2 +np.float32,0xfee46fee,0xff800000,2 +np.float32,0x3e42a648,0x3e43d2e9,2 +np.float32,0x80131916,0x80131916,2 +np.float32,0x806209d3,0x806209d3,2 +np.float32,0x807c1f12,0x807c1f12,2 +np.float32,0x2f3696,0x2f3696,2 +np.float32,0xff28722b,0xff800000,2 +np.float32,0x7f1416a1,0x7f800000,2 +np.float32,0x8054e7a1,0x8054e7a1,2 +np.float32,0xbddc39a0,0xbddca656,2 +np.float32,0x7dc60175,0x7f800000,2 +np.float64,0x7fd0ae584da15cb0,0x7ff0000000000000,1 +np.float64,0x7fd41d68e5283ad1,0x7ff0000000000000,1 +np.float64,0x7fe93073bb7260e6,0x7ff0000000000000,1 +np.float64,0x3fb4fd19d229fa34,0x3fb5031f57dbac0f,1 +np.float64,0x85609ce10ac2,0x85609ce10ac2,1 +np.float64,0xbfd7aa12ccaf5426,0xbfd8351003a320e2,1 +np.float64,0x8004487c9b4890fa,0x8004487c9b4890fa,1 +np.float64,0x7fe7584cfd2eb099,0x7ff0000000000000,1 +np.float64,0x800ea8edc6dd51dc,0x800ea8edc6dd51dc,1 +np.float64,0x3fe0924aa5a12495,0x3fe15276e271c6dc,1 +np.float64,0x3feb1abf6d36357f,0x3fee76b4d3d06964,1 +np.float64,0x3fa8c14534318280,0x3fa8c3bd5ce5923c,1 +np.float64,0x800b9f5915d73eb3,0x800b9f5915d73eb3,1 +np.float64,0xffc05aaa7820b554,0xfff0000000000000,1 +np.float64,0x800157eda8c2afdc,0x800157eda8c2afdc,1 +np.float64,0xffe8d90042b1b200,0xfff0000000000000,1 +np.float64,0x3feda02ea93b405d,0x3ff1057e61d08d59,1 +np.float64,0xffd03b7361a076e6,0xfff0000000000000,1 +np.float64,0x3fe1a8ecd7e351da,0x3fe291eda9080847,1 +np.float64,0xffc5bfdff82b7fc0,0xfff0000000000000,1 +np.float64,0xbfe6fb3d386df67a,0xbfe9022c05df0565,1 +np.float64,0x7fefffffffffffff,0x7ff0000000000000,1 +np.float64,0x7fa10c340c221867,0x7ff0000000000000,1 +np.float64,0x3fe55cbf1daab97e,0x3fe6fc1648258b75,1 +np.float64,0xbfddeb5f60bbd6be,0xbfdf056d4fb5825f,1 +np.float64,0xffddb1a8213b6350,0xfff0000000000000,1 +np.float64,0xbfb20545e4240a88,0xbfb2091579375176,1 +np.float64,0x3f735ded2026bbda,0x3f735df1dad4ee3a,1 +np.float64,0xbfd1eb91efa3d724,0xbfd227c044dead61,1 +np.float64,0xffd737c588ae6f8c,0xfff0000000000000,1 +np.float64,0x3fc46818ec28d032,0x3fc47e416c4237a6,1 +np.float64,0x0,0x0,1 +np.float64,0xffb632097a2c6410,0xfff0000000000000,1 +np.float64,0xbfcb5ae84b36b5d0,0xbfcb905613af55b8,1 +np.float64,0xbfe7b926402f724c,0xbfe9f4f0be6aacc3,1 +np.float64,0x80081840b3f03082,0x80081840b3f03082,1 +np.float64,0x3fe767a656eecf4d,0x3fe98c53b4779de7,1 +np.float64,0x8005834c088b0699,0x8005834c088b0699,1 +np.float64,0x80074e92658e9d26,0x80074e92658e9d26,1 +np.float64,0x80045d60c268bac2,0x80045d60c268bac2,1 +np.float64,0xffb9aecfe8335da0,0xfff0000000000000,1 +np.float64,0x7fcad3e1cd35a7c3,0x7ff0000000000000,1 +np.float64,0xbf881853d03030c0,0xbf8818783e28fc87,1 +np.float64,0xe18c6d23c318e,0xe18c6d23c318e,1 +np.float64,0x7fcb367b8f366cf6,0x7ff0000000000000,1 +np.float64,0x5c13436cb8269,0x5c13436cb8269,1 +np.float64,0xffe5399938aa7332,0xfff0000000000000,1 +np.float64,0xbfdc45dbc3b88bb8,0xbfdd33958222c27e,1 +np.float64,0xbfd714691bae28d2,0xbfd7954edbef810b,1 +np.float64,0xbfdf18b02b3e3160,0xbfe02ad13634c651,1 +np.float64,0x8003e6f276e7cde6,0x8003e6f276e7cde6,1 +np.float64,0x3febb6b412776d68,0x3fef4f753def31f9,1 +np.float64,0x7fe016a3b4a02d46,0x7ff0000000000000,1 +np.float64,0x3fdc899ac7b91336,0x3fdd7e1cee1cdfc8,1 +np.float64,0x800219271e24324f,0x800219271e24324f,1 +np.float64,0x1529d93e2a53c,0x1529d93e2a53c,1 +np.float64,0x800d5bc827fab790,0x800d5bc827fab790,1 +np.float64,0x3e1495107c293,0x3e1495107c293,1 +np.float64,0x3fe89da0f2b13b42,0x3feb1dc1f3015ad7,1 +np.float64,0x800ba8c17b975183,0x800ba8c17b975183,1 +np.float64,0x8002dacf0265b59f,0x8002dacf0265b59f,1 +np.float64,0xffe6d0a4cc2da149,0xfff0000000000000,1 +np.float64,0x3fdf23fe82be47fc,0x3fe03126d8e2b309,1 +np.float64,0xffe41b1f1c28363e,0xfff0000000000000,1 +np.float64,0xbfd635c634ac6b8c,0xbfd6a8966da6adaa,1 +np.float64,0x800755bc08eeab79,0x800755bc08eeab79,1 +np.float64,0x800ba4c47c374989,0x800ba4c47c374989,1 +np.float64,0x7fec9f7649793eec,0x7ff0000000000000,1 +np.float64,0x7fdbf45738b7e8ad,0x7ff0000000000000,1 +np.float64,0x3f5597f07eab4,0x3f5597f07eab4,1 +np.float64,0xbfbf4599183e8b30,0xbfbf5985d8c65097,1 +np.float64,0xbf5b200580364000,0xbf5b2006501b21ae,1 +np.float64,0x7f91868370230d06,0x7ff0000000000000,1 +np.float64,0x3838e2a67071d,0x3838e2a67071d,1 +np.float64,0xffefe3ff5d3fc7fe,0xfff0000000000000,1 +np.float64,0xffe66b26d06cd64d,0xfff0000000000000,1 +np.float64,0xbfd830a571b0614a,0xbfd8c526927c742c,1 +np.float64,0x7fe8442122f08841,0x7ff0000000000000,1 +np.float64,0x800efa8c637df519,0x800efa8c637df519,1 +np.float64,0xf0026835e004d,0xf0026835e004d,1 +np.float64,0xffb11beefe2237e0,0xfff0000000000000,1 +np.float64,0x3fef9bbb327f3776,0x3ff2809f10641c32,1 +np.float64,0x350595306a0b3,0x350595306a0b3,1 +np.float64,0xf7f6538befecb,0xf7f6538befecb,1 +np.float64,0xffe36379c4a6c6f3,0xfff0000000000000,1 +np.float64,0x28b1d82e5163c,0x28b1d82e5163c,1 +np.float64,0x70a3d804e147c,0x70a3d804e147c,1 +np.float64,0xffd96c1bc9b2d838,0xfff0000000000000,1 +np.float64,0xffce8e00893d1c00,0xfff0000000000000,1 +np.float64,0x800f2bdcb25e57b9,0x800f2bdcb25e57b9,1 +np.float64,0xbfe0d9c63361b38c,0xbfe1a3eb02192b76,1 +np.float64,0xbfdc7b8711b8f70e,0xbfdd6e9db3a01e51,1 +np.float64,0x99e22ec133c46,0x99e22ec133c46,1 +np.float64,0xffeaef6ddab5dedb,0xfff0000000000000,1 +np.float64,0x7fe89c22c0f13845,0x7ff0000000000000,1 +np.float64,0x8002d5207de5aa42,0x8002d5207de5aa42,1 +np.float64,0x3fd1b13353236267,0x3fd1eb1b9345dfca,1 +np.float64,0x800ccae0a41995c1,0x800ccae0a41995c1,1 +np.float64,0x3fdbdaba38b7b574,0x3fdcbdfcbca37ce6,1 +np.float64,0x5b06d12cb60db,0x5b06d12cb60db,1 +np.float64,0xffd52262752a44c4,0xfff0000000000000,1 +np.float64,0x5a17f050b42ff,0x5a17f050b42ff,1 +np.float64,0x3d24205e7a485,0x3d24205e7a485,1 +np.float64,0x7fbed4dec63da9bd,0x7ff0000000000000,1 +np.float64,0xbfe56e9776aadd2f,0xbfe71212863c284f,1 +np.float64,0x7fea0bc952341792,0x7ff0000000000000,1 +np.float64,0x800f692d139ed25a,0x800f692d139ed25a,1 +np.float64,0xffdb63feab36c7fe,0xfff0000000000000,1 +np.float64,0x3fe1c2297fe38452,0x3fe2af21293c9571,1 +np.float64,0x7fede384747bc708,0x7ff0000000000000,1 +np.float64,0x800440169288802e,0x800440169288802e,1 +np.float64,0xffe3241eeb26483e,0xfff0000000000000,1 +np.float64,0xffe28f3879651e70,0xfff0000000000000,1 +np.float64,0xa435cbc1486d,0xa435cbc1486d,1 +np.float64,0x7fe55e08db6abc11,0x7ff0000000000000,1 +np.float64,0x1405e624280be,0x1405e624280be,1 +np.float64,0x3fd861bdf0b0c37c,0x3fd8f9d2e33e45e5,1 +np.float64,0x3feeb67cdc3d6cfa,0x3ff1d337d81d1c14,1 +np.float64,0x3fd159a10e22b342,0x3fd1903be7c2ea0c,1 +np.float64,0x3fd84626bc308c4d,0x3fd8dc373645e65b,1 +np.float64,0xffd3da81d9a7b504,0xfff0000000000000,1 +np.float64,0xbfd4a768b8294ed2,0xbfd503aa7c240051,1 +np.float64,0x3fe3059f2a660b3e,0x3fe42983e0c6bb2e,1 +np.float64,0x3fe3b8353827706a,0x3fe4fdd635c7269b,1 +np.float64,0xbfe4af0399695e07,0xbfe6277d9002b46c,1 +np.float64,0xbfd7e18a92afc316,0xbfd87066b54c4fe6,1 +np.float64,0x800432bcab48657a,0x800432bcab48657a,1 +np.float64,0x80033d609d267ac2,0x80033d609d267ac2,1 +np.float64,0x7fef5f758e7ebeea,0x7ff0000000000000,1 +np.float64,0xbfed7833dbfaf068,0xbff0e85bf45a5ebc,1 +np.float64,0x3fe2283985a45073,0x3fe325b0a9099c74,1 +np.float64,0xe820b4b3d0417,0xe820b4b3d0417,1 +np.float64,0x8003ecb72aa7d96f,0x8003ecb72aa7d96f,1 +np.float64,0xbfeab2c755b5658f,0xbfede7c83e92a625,1 +np.float64,0xbfc7b287f72f6510,0xbfc7d53ef2ffe9dc,1 +np.float64,0xffd9a41d0f33483a,0xfff0000000000000,1 +np.float64,0x3fd3a5b6e3a74b6c,0x3fd3f516f39a4725,1 +np.float64,0x800bc72091578e42,0x800bc72091578e42,1 +np.float64,0x800ff405ce9fe80c,0x800ff405ce9fe80c,1 +np.float64,0x57918600af24,0x57918600af24,1 +np.float64,0x2a5be7fa54b7e,0x2a5be7fa54b7e,1 +np.float64,0xbfdca7886bb94f10,0xbfdd9f142b5b43e4,1 +np.float64,0xbfe216993ee42d32,0xbfe3112936590995,1 +np.float64,0xbfe06bd9cf20d7b4,0xbfe126cd353ab42f,1 +np.float64,0x8003e6c31827cd87,0x8003e6c31827cd87,1 +np.float64,0x8005f37d810be6fc,0x8005f37d810be6fc,1 +np.float64,0x800715b081ae2b62,0x800715b081ae2b62,1 +np.float64,0x3fef94c35bff2986,0x3ff27b4bed2f4051,1 +np.float64,0x6f5798e0deb0,0x6f5798e0deb0,1 +np.float64,0x3fcef1f05c3de3e1,0x3fcf3f557550598f,1 +np.float64,0xbf9a91c400352380,0xbf9a92876273b85c,1 +np.float64,0x3fc9143f7f322880,0x3fc93d678c05d26b,1 +np.float64,0x78ad847af15b1,0x78ad847af15b1,1 +np.float64,0x8000fdc088c1fb82,0x8000fdc088c1fb82,1 +np.float64,0x800200fd304401fb,0x800200fd304401fb,1 +np.float64,0x7fb8ab09dc315613,0x7ff0000000000000,1 +np.float64,0x3fe949771b7292ee,0x3fec00891c3fc5a2,1 +np.float64,0xbfc54cae0e2a995c,0xbfc565e0f3d0e3af,1 +np.float64,0xffd546161e2a8c2c,0xfff0000000000000,1 +np.float64,0x800fe1d1279fc3a2,0x800fe1d1279fc3a2,1 +np.float64,0x3fd9c45301b388a8,0x3fda77fa1f4c79bf,1 +np.float64,0x7fe10ff238221fe3,0x7ff0000000000000,1 +np.float64,0xbfbc2181ae384300,0xbfbc3002229155c4,1 +np.float64,0xbfe7bbfae4ef77f6,0xbfe9f895e91f468d,1 +np.float64,0x800d3d994f7a7b33,0x800d3d994f7a7b33,1 +np.float64,0xffe6e15a896dc2b4,0xfff0000000000000,1 +np.float64,0x800e6b6c8abcd6d9,0x800e6b6c8abcd6d9,1 +np.float64,0xbfd862c938b0c592,0xbfd8faf1cdcb09db,1 +np.float64,0xffe2411f8464823e,0xfff0000000000000,1 +np.float64,0xffd0b32efaa1665e,0xfff0000000000000,1 +np.float64,0x3ac4ace475896,0x3ac4ace475896,1 +np.float64,0xf9c3a7ebf3875,0xf9c3a7ebf3875,1 +np.float64,0xdb998ba5b7332,0xdb998ba5b7332,1 +np.float64,0xbfe438a14fe87142,0xbfe5981751e4c5cd,1 +np.float64,0xbfbcf48cbc39e918,0xbfbd045d60e65d3a,1 +np.float64,0x7fde499615bc932b,0x7ff0000000000000,1 +np.float64,0x800bba269057744e,0x800bba269057744e,1 +np.float64,0x3fc9bb1ba3337638,0x3fc9e78fdb6799c1,1 +np.float64,0xffd9f974fbb3f2ea,0xfff0000000000000,1 +np.float64,0x7fcf1ad1693e35a2,0x7ff0000000000000,1 +np.float64,0x7fe5dcedd32bb9db,0x7ff0000000000000,1 +np.float64,0xeb06500bd60ca,0xeb06500bd60ca,1 +np.float64,0x7fd73e7b592e7cf6,0x7ff0000000000000,1 +np.float64,0xbfe9d91ae873b236,0xbfecc08482849bcd,1 +np.float64,0xffc85338b730a670,0xfff0000000000000,1 +np.float64,0x7fbba41eee37483d,0x7ff0000000000000,1 +np.float64,0x3fed5624fb7aac4a,0x3ff0cf9f0de1fd54,1 +np.float64,0xffe566d80d6acdb0,0xfff0000000000000,1 +np.float64,0x3fd4477884a88ef1,0x3fd49ec7acdd25a0,1 +np.float64,0x3fcb98c5fd37318c,0x3fcbcfa20e2c2712,1 +np.float64,0xffdeba71d5bd74e4,0xfff0000000000000,1 +np.float64,0x8001edc59dc3db8c,0x8001edc59dc3db8c,1 +np.float64,0x3fe6b09e896d613e,0x3fe8a3bb541ec0e3,1 +np.float64,0x3fe8694b4970d296,0x3fead94d271d05cf,1 +np.float64,0xb52c27bf6a585,0xb52c27bf6a585,1 +np.float64,0x7fcb0a21d9361443,0x7ff0000000000000,1 +np.float64,0xbfd9efc68cb3df8e,0xbfdaa7058c0ccbd1,1 +np.float64,0x8007cd170fef9a2f,0x8007cd170fef9a2f,1 +np.float64,0x3fe83325e770664c,0x3fea92c55c9d567e,1 +np.float64,0x800bd0085537a011,0x800bd0085537a011,1 +np.float64,0xffe05b9e7820b73c,0xfff0000000000000,1 +np.float64,0x3fea4ce4347499c8,0x3fed5cea9fdc541b,1 +np.float64,0x7fe08aae1921155b,0x7ff0000000000000,1 +np.float64,0x3fe7a5e7deef4bd0,0x3fe9dc2e20cfb61c,1 +np.float64,0xbfe0ccc8e6e19992,0xbfe195175f32ee3f,1 +np.float64,0xbfe8649717f0c92e,0xbfead3298974dcf0,1 +np.float64,0x7fed6c5308bad8a5,0x7ff0000000000000,1 +np.float64,0xffdbd8c7af37b190,0xfff0000000000000,1 +np.float64,0xbfb2bc4d06257898,0xbfb2c09569912839,1 +np.float64,0x3fc62eca512c5d95,0x3fc64b4251bce8f9,1 +np.float64,0xbfcae2ddbd35c5bc,0xbfcb15971fc61312,1 +np.float64,0x18d26ce831a4f,0x18d26ce831a4f,1 +np.float64,0x7fe38b279267164e,0x7ff0000000000000,1 +np.float64,0x97e1d9ab2fc3b,0x97e1d9ab2fc3b,1 +np.float64,0xbfee8e4785fd1c8f,0xbff1b52d16807627,1 +np.float64,0xbfb189b4a6231368,0xbfb18d37e83860ee,1 +np.float64,0xffd435761ea86aec,0xfff0000000000000,1 +np.float64,0x3fe6c48ebced891e,0x3fe8bcea189c3867,1 +np.float64,0x7fdadd3678b5ba6c,0x7ff0000000000000,1 +np.float64,0x7fea8f15b7b51e2a,0x7ff0000000000000,1 +np.float64,0xbff0000000000000,0xbff2cd9fc44eb982,1 +np.float64,0x80004c071120980f,0x80004c071120980f,1 +np.float64,0x8005367adfea6cf6,0x8005367adfea6cf6,1 +np.float64,0x3fbdc9139a3b9220,0x3fbdda4aba667ce5,1 +np.float64,0x7fed5ee3ad7abdc6,0x7ff0000000000000,1 +np.float64,0x51563fb2a2ac9,0x51563fb2a2ac9,1 +np.float64,0xbfba7d26ce34fa50,0xbfba894229c50ea1,1 +np.float64,0x6c10db36d821c,0x6c10db36d821c,1 +np.float64,0xbfbdaec0d03b5d80,0xbfbdbfca6ede64f4,1 +np.float64,0x800a1cbe7414397d,0x800a1cbe7414397d,1 +np.float64,0x800ae6e7f2d5cdd0,0x800ae6e7f2d5cdd0,1 +np.float64,0x3fea63d3fef4c7a8,0x3fed7c1356688ddc,1 +np.float64,0xbfde1e3a88bc3c76,0xbfdf3dfb09cc2260,1 +np.float64,0xbfd082d75a2105ae,0xbfd0b1e28c84877b,1 +np.float64,0x7fea1e5e85f43cbc,0x7ff0000000000000,1 +np.float64,0xffe2237a1a6446f4,0xfff0000000000000,1 +np.float64,0x3fd1e2be8523c57d,0x3fd21e93dfd1bbc4,1 +np.float64,0x3fd1acd428a359a8,0x3fd1e6916a42bc3a,1 +np.float64,0x61a152f0c342b,0x61a152f0c342b,1 +np.float64,0xbfc61a6b902c34d8,0xbfc6369557690ba0,1 +np.float64,0x7fd1a84b1f235095,0x7ff0000000000000,1 +np.float64,0x1c5cc7e638b9a,0x1c5cc7e638b9a,1 +np.float64,0x8008039755f0072f,0x8008039755f0072f,1 +np.float64,0x80097532d6f2ea66,0x80097532d6f2ea66,1 +np.float64,0xbfc6d979a12db2f4,0xbfc6f89777c53f8f,1 +np.float64,0x8004293ab1085276,0x8004293ab1085276,1 +np.float64,0x3fc2af5c21255eb8,0x3fc2c05dc0652554,1 +np.float64,0xbfd9a5ab87b34b58,0xbfda56d1076abc98,1 +np.float64,0xbfebd360ba77a6c2,0xbfef779fd6595f9b,1 +np.float64,0xffd5313c43aa6278,0xfff0000000000000,1 +np.float64,0xbfe994a262b32945,0xbfec64b969852ed5,1 +np.float64,0x3fce01a52e3c034a,0x3fce48324eb29c31,1 +np.float64,0x56bd74b2ad7af,0x56bd74b2ad7af,1 +np.float64,0xb84093ff70813,0xb84093ff70813,1 +np.float64,0x7fe776df946eedbe,0x7ff0000000000000,1 +np.float64,0xbfe294ac2e652958,0xbfe3a480938afa26,1 +np.float64,0x7fe741b4d0ee8369,0x7ff0000000000000,1 +np.float64,0x800b7e8a1056fd15,0x800b7e8a1056fd15,1 +np.float64,0x7fd28f1269251e24,0x7ff0000000000000,1 +np.float64,0x8009d4492e73a893,0x8009d4492e73a893,1 +np.float64,0x3fe3f27fca67e500,0x3fe543aff825e244,1 +np.float64,0x3fd12447e5a24890,0x3fd158efe43c0452,1 +np.float64,0xbfd58df0f2ab1be2,0xbfd5f6d908e3ebce,1 +np.float64,0xffc0a8e4642151c8,0xfff0000000000000,1 +np.float64,0xbfedb197787b632f,0xbff112367ec9d3e7,1 +np.float64,0xffdde07a7f3bc0f4,0xfff0000000000000,1 +np.float64,0x3fe91f3e5b723e7d,0x3febc886a1d48364,1 +np.float64,0x3fe50415236a082a,0x3fe68f43a5468d8c,1 +np.float64,0xd9a0c875b3419,0xd9a0c875b3419,1 +np.float64,0xbfee04ccf4bc099a,0xbff14f4740a114cf,1 +np.float64,0xbfd2bcc6a125798e,0xbfd30198b1e7d7ed,1 +np.float64,0xbfeb3c16f8f6782e,0xbfeea4ce47d09f58,1 +np.float64,0xffd3ba19e4a77434,0xfff0000000000000,1 +np.float64,0x8010000000000000,0x8010000000000000,1 +np.float64,0x3fdef0a642bde14d,0x3fe0146677b3a488,1 +np.float64,0x3fdc3dd0a2b87ba0,0x3fdd2abe65651487,1 +np.float64,0x3fdbb1fd47b763fb,0x3fdc915a2fd19f4b,1 +np.float64,0x7fbaa375e63546eb,0x7ff0000000000000,1 +np.float64,0x433ef8ee867e0,0x433ef8ee867e0,1 +np.float64,0xf5345475ea68b,0xf5345475ea68b,1 +np.float64,0xa126419b424c8,0xa126419b424c8,1 +np.float64,0x3fe0057248200ae5,0x3fe0b2f488339709,1 +np.float64,0xffc5e3b82f2bc770,0xfff0000000000000,1 +np.float64,0xffb215c910242b90,0xfff0000000000000,1 +np.float64,0xbfeba4ae0837495c,0xbfef3642e4b54aac,1 +np.float64,0xffbb187ebe363100,0xfff0000000000000,1 +np.float64,0x3fe4c6a496a98d49,0x3fe64440cdf06aab,1 +np.float64,0x800767a28f6ecf46,0x800767a28f6ecf46,1 +np.float64,0x3fdbed63b1b7dac8,0x3fdcd27318c0b683,1 +np.float64,0x80006d8339e0db07,0x80006d8339e0db07,1 +np.float64,0x8000b504f0416a0b,0x8000b504f0416a0b,1 +np.float64,0xbfe88055bfb100ac,0xbfeaf767bd2767b9,1 +np.float64,0x3fefe503317fca06,0x3ff2b8d4057240c8,1 +np.float64,0x7fe307538b660ea6,0x7ff0000000000000,1 +np.float64,0x944963c12892d,0x944963c12892d,1 +np.float64,0xbfd2c20b38a58416,0xbfd30717900f8233,1 +np.float64,0x7feed04e3e3da09b,0x7ff0000000000000,1 +np.float64,0x3fe639619cac72c3,0x3fe80de7b8560a8d,1 +np.float64,0x3fde066c66bc0cd9,0x3fdf237fb759a652,1 +np.float64,0xbfc56b22b52ad644,0xbfc584c267a47ebd,1 +np.float64,0x3fc710d5b12e21ab,0x3fc730d817ba0d0c,1 +np.float64,0x3fee1dfc347c3bf8,0x3ff161d9c3e15f68,1 +np.float64,0x3fde400954bc8013,0x3fdf639e5cc9e7a9,1 +np.float64,0x56e701f8adce1,0x56e701f8adce1,1 +np.float64,0xbfe33bbc89e67779,0xbfe46996b39381fe,1 +np.float64,0x7fec89e2f87913c5,0x7ff0000000000000,1 +np.float64,0xbfdad58b40b5ab16,0xbfdba098cc0ad5d3,1 +np.float64,0x3fe99c76a13338ed,0x3fec6f31bae613e7,1 +np.float64,0x3fe4242a29a84854,0x3fe57f6b45e5c0ef,1 +np.float64,0xbfe79d3199ef3a63,0xbfe9d0fb96c846ba,1 +np.float64,0x7ff8000000000000,0x7ff8000000000000,1 +np.float64,0xbfeb35a6cf766b4e,0xbfee9be4e7e943f7,1 +np.float64,0x3e047f267c091,0x3e047f267c091,1 +np.float64,0x4bf1376a97e28,0x4bf1376a97e28,1 +np.float64,0x800ef419685de833,0x800ef419685de833,1 +np.float64,0x3fe0efa61a21df4c,0x3fe1bce98baf2f0f,1 +np.float64,0x3fcc13c4d738278a,0x3fcc4d8c778bcaf7,1 +np.float64,0x800f1d291afe3a52,0x800f1d291afe3a52,1 +np.float64,0x3fd3f10e6da7e21d,0x3fd444106761ea1d,1 +np.float64,0x800706d6d76e0dae,0x800706d6d76e0dae,1 +np.float64,0xffa1ffbc9023ff80,0xfff0000000000000,1 +np.float64,0xbfe098f26d6131e5,0xbfe15a08a5f3eac0,1 +np.float64,0x3fe984f9cc7309f4,0x3fec4fcdbdb1cb9b,1 +np.float64,0x7fd7c2f1eaaf85e3,0x7ff0000000000000,1 +np.float64,0x800a8adb64f515b7,0x800a8adb64f515b7,1 +np.float64,0x80060d3ffc8c1a81,0x80060d3ffc8c1a81,1 +np.float64,0xbfec37e4aef86fc9,0xbff0029a6a1d61e2,1 +np.float64,0x800b21bcfcf6437a,0x800b21bcfcf6437a,1 +np.float64,0xbfc08facc1211f58,0xbfc09b8380ea8032,1 +np.float64,0xffebb4b52577696a,0xfff0000000000000,1 +np.float64,0x800b08096df61013,0x800b08096df61013,1 +np.float64,0x8000000000000000,0x8000000000000000,1 +np.float64,0xffd2f0c9c8a5e194,0xfff0000000000000,1 +np.float64,0xffe78b2299af1644,0xfff0000000000000,1 +np.float64,0x7fd0444794a0888e,0x7ff0000000000000,1 +np.float64,0x307c47b460f8a,0x307c47b460f8a,1 +np.float64,0xffe6b4c851ad6990,0xfff0000000000000,1 +np.float64,0xffe1877224a30ee4,0xfff0000000000000,1 +np.float64,0x48d7b5c091af7,0x48d7b5c091af7,1 +np.float64,0xbfa1dc6b1c23b8d0,0xbfa1dd5889e1b7da,1 +np.float64,0x3fe5004737ea008e,0x3fe68a9c310b08c1,1 +np.float64,0x7fec5f0742b8be0e,0x7ff0000000000000,1 +np.float64,0x3fd0a86285a150c5,0x3fd0d8b238d557fa,1 +np.float64,0x7fed60380efac06f,0x7ff0000000000000,1 +np.float64,0xeeca74dfdd94f,0xeeca74dfdd94f,1 +np.float64,0x3fda05aaa8b40b54,0x3fdabebdbf405e84,1 +np.float64,0x800e530ceb1ca61a,0x800e530ceb1ca61a,1 +np.float64,0x800b3866379670cd,0x800b3866379670cd,1 +np.float64,0xffedb3e7fa3b67cf,0xfff0000000000000,1 +np.float64,0xffdfa4c0713f4980,0xfff0000000000000,1 +np.float64,0x7fe4679e0728cf3b,0x7ff0000000000000,1 +np.float64,0xffe978611ef2f0c2,0xfff0000000000000,1 +np.float64,0x7fc9f4601f33e8bf,0x7ff0000000000000,1 +np.float64,0x3fd4942de6a9285c,0x3fd4ef6e089357dd,1 +np.float64,0x3faafe064435fc00,0x3fab0139cd6564dc,1 +np.float64,0x800d145a519a28b5,0x800d145a519a28b5,1 +np.float64,0xbfd82636f2304c6e,0xbfd8b9f75ddd2f02,1 +np.float64,0xbfdf2e975e3e5d2e,0xbfe037174280788c,1 +np.float64,0x7fd7051d7c2e0a3a,0x7ff0000000000000,1 +np.float64,0x8007933d452f267b,0x8007933d452f267b,1 +np.float64,0xb2043beb64088,0xb2043beb64088,1 +np.float64,0x3febfd9708f7fb2e,0x3fefb2ef090f18d2,1 +np.float64,0xffd9bc6bc83378d8,0xfff0000000000000,1 +np.float64,0xc10f9fd3821f4,0xc10f9fd3821f4,1 +np.float64,0x3fe3c83413a79068,0x3fe510fa1dd8edf7,1 +np.float64,0x3fbe26ccda3c4da0,0x3fbe38a892279975,1 +np.float64,0x3fcc1873103830e6,0x3fcc5257a6ae168d,1 +np.float64,0xe7e000e9cfc00,0xe7e000e9cfc00,1 +np.float64,0xffda73852bb4e70a,0xfff0000000000000,1 +np.float64,0xbfe831be19f0637c,0xbfea90f1b34da3e5,1 +np.float64,0xbfeb568f3076ad1e,0xbfeec97eebfde862,1 +np.float64,0x510a6ad0a214e,0x510a6ad0a214e,1 +np.float64,0x3fe6ba7e35ed74fc,0x3fe8b032a9a28c6a,1 +np.float64,0xffeb5cdcff76b9b9,0xfff0000000000000,1 +np.float64,0x4f0a23e89e145,0x4f0a23e89e145,1 +np.float64,0x446ec20288dd9,0x446ec20288dd9,1 +np.float64,0x7fe2521b02e4a435,0x7ff0000000000000,1 +np.float64,0x8001cd2969e39a54,0x8001cd2969e39a54,1 +np.float64,0x3fdfe90600bfd20c,0x3fe09fdcca10001c,1 +np.float64,0x7fd660c5762cc18a,0x7ff0000000000000,1 +np.float64,0xbfb11b23aa223648,0xbfb11e661949b377,1 +np.float64,0x800e025285fc04a5,0x800e025285fc04a5,1 +np.float64,0xffb180bb18230178,0xfff0000000000000,1 +np.float64,0xaaf590df55eb2,0xaaf590df55eb2,1 +np.float64,0xbfe8637d9df0c6fb,0xbfead1ba429462ec,1 +np.float64,0x7fd2577866a4aef0,0x7ff0000000000000,1 +np.float64,0xbfcfb2ab5a3f6558,0xbfd002ee87f272b9,1 +np.float64,0x7fdd64ae2f3ac95b,0x7ff0000000000000,1 +np.float64,0xffd1a502c9234a06,0xfff0000000000000,1 +np.float64,0x7fc4be4b60297c96,0x7ff0000000000000,1 +np.float64,0xbfb46b712a28d6e0,0xbfb470fca9919172,1 +np.float64,0xffdef913033df226,0xfff0000000000000,1 +np.float64,0x3fd94a3545b2946b,0x3fd9f40431ce9f9c,1 +np.float64,0x7fef88a0b6ff1140,0x7ff0000000000000,1 +np.float64,0xbfbcc81876399030,0xbfbcd7a0ab6cb388,1 +np.float64,0x800a4acfdd9495a0,0x800a4acfdd9495a0,1 +np.float64,0xffe270b3d5e4e167,0xfff0000000000000,1 +np.float64,0xbfd23f601e247ec0,0xbfd27eeca50a49eb,1 +np.float64,0x7fec6e796a78dcf2,0x7ff0000000000000,1 +np.float64,0x3fb85e0c9630bc19,0x3fb867791ccd6c72,1 +np.float64,0x7fe49fc424a93f87,0x7ff0000000000000,1 +np.float64,0xbfe75a99fbaeb534,0xbfe97ba37663de4c,1 +np.float64,0xffe85011b630a023,0xfff0000000000000,1 +np.float64,0xffe5962e492b2c5c,0xfff0000000000000,1 +np.float64,0x6f36ed4cde6de,0x6f36ed4cde6de,1 +np.float64,0x3feb72170af6e42e,0x3feeefbe6f1a2084,1 +np.float64,0x80014d8d60629b1c,0x80014d8d60629b1c,1 +np.float64,0xbfe0eb40d321d682,0xbfe1b7e31f252bf1,1 +np.float64,0x31fe305663fc7,0x31fe305663fc7,1 +np.float64,0x3fd2cd6381a59ac7,0x3fd312edc9868a4d,1 +np.float64,0xffcf0720793e0e40,0xfff0000000000000,1 +np.float64,0xbfeef1ef133de3de,0xbff1ffd5e1a3b648,1 +np.float64,0xbfd01c787aa038f0,0xbfd0482be3158a01,1 +np.float64,0x3fda3607c5b46c10,0x3fdaf3301e217301,1 +np.float64,0xffda9a9911b53532,0xfff0000000000000,1 +np.float64,0x3fc0b37c392166f8,0x3fc0bfa076f3c43e,1 +np.float64,0xbfe06591c760cb24,0xbfe11fad179ea12c,1 +np.float64,0x8006e369c20dc6d4,0x8006e369c20dc6d4,1 +np.float64,0x3fdf2912a8be5224,0x3fe033ff74b92f4d,1 +np.float64,0xffc0feb07821fd60,0xfff0000000000000,1 +np.float64,0xa4b938c949727,0xa4b938c949727,1 +np.float64,0x8008fe676571fccf,0x8008fe676571fccf,1 +np.float64,0xbfdda68459bb4d08,0xbfdeb8faab34fcbc,1 +np.float64,0xbfda18b419343168,0xbfdad360ca52ec7c,1 +np.float64,0x3febcbae35b7975c,0x3fef6cd51c9ebc15,1 +np.float64,0x3fbec615f63d8c30,0x3fbed912ba729926,1 +np.float64,0x7f99a831c8335063,0x7ff0000000000000,1 +np.float64,0x3fe663e8826cc7d1,0x3fe84330bd9aada8,1 +np.float64,0x70a9f9e6e1540,0x70a9f9e6e1540,1 +np.float64,0x8a13a5db14275,0x8a13a5db14275,1 +np.float64,0x7fc4330a3b286613,0x7ff0000000000000,1 +np.float64,0xbfe580c6136b018c,0xbfe728806cc7a99a,1 +np.float64,0x8000000000000001,0x8000000000000001,1 +np.float64,0xffec079d5df80f3a,0xfff0000000000000,1 +np.float64,0x8e1173c31c22f,0x8e1173c31c22f,1 +np.float64,0x3fe088456d21108b,0x3fe14712ca414103,1 +np.float64,0x3fe1b76f73636edf,0x3fe2a2b658557112,1 +np.float64,0xbfd4a1dd162943ba,0xbfd4fdd45cae8fb8,1 +np.float64,0x7fd60b46c8ac168d,0x7ff0000000000000,1 +np.float64,0xffe36cc3b166d987,0xfff0000000000000,1 +np.float64,0x3fdc2ae0cfb855c0,0x3fdd15f026773151,1 +np.float64,0xbfc41aa203283544,0xbfc42fd1b145fdd5,1 +np.float64,0xffed90c55fbb218a,0xfff0000000000000,1 +np.float64,0x3fe67e3a9aecfc75,0x3fe86440db65b4f6,1 +np.float64,0x7fd12dbeaba25b7c,0x7ff0000000000000,1 +np.float64,0xbfe1267c0de24cf8,0xbfe1fbb611bdf1e9,1 +np.float64,0x22e5619645cad,0x22e5619645cad,1 +np.float64,0x7fe327c72ea64f8d,0x7ff0000000000000,1 +np.float64,0x7fd2c3f545a587ea,0x7ff0000000000000,1 +np.float64,0x7fc7b689372f6d11,0x7ff0000000000000,1 +np.float64,0xc5e140bd8bc28,0xc5e140bd8bc28,1 +np.float64,0x3fccb3627a3966c5,0x3fccf11b44fa4102,1 +np.float64,0xbfd2cf725c259ee4,0xbfd315138d0e5dca,1 +np.float64,0x10000000000000,0x10000000000000,1 +np.float64,0xbfd3dfa8b627bf52,0xbfd431d17b235477,1 +np.float64,0xbfb82124e6304248,0xbfb82a4b6d9c2663,1 +np.float64,0x3fdcd590d9b9ab22,0x3fddd1d548806347,1 +np.float64,0x7fdee0cd1b3dc199,0x7ff0000000000000,1 +np.float64,0x8004ebfc60a9d7fa,0x8004ebfc60a9d7fa,1 +np.float64,0x3fe8eb818b71d704,0x3feb842679806108,1 +np.float64,0xffdd5e8fe63abd20,0xfff0000000000000,1 +np.float64,0xbfe3efcbd9e7df98,0xbfe54071436645ee,1 +np.float64,0x3fd5102557aa204b,0x3fd57203d31a05b8,1 +np.float64,0x3fe6318af7ec6316,0x3fe8041a177cbf96,1 +np.float64,0x3fdf3cecdabe79da,0x3fe03f2084ffbc78,1 +np.float64,0x7fe0ab6673a156cc,0x7ff0000000000000,1 +np.float64,0x800037d5c6c06fac,0x800037d5c6c06fac,1 +np.float64,0xffce58b86a3cb170,0xfff0000000000000,1 +np.float64,0xbfe3455d6ce68abb,0xbfe475034cecb2b8,1 +np.float64,0x991b663d3236d,0x991b663d3236d,1 +np.float64,0x3fda82d37c3505a7,0x3fdb46973da05c12,1 +np.float64,0x3f9b736fa036e6df,0x3f9b74471c234411,1 +np.float64,0x8001c96525e392cb,0x8001c96525e392cb,1 +np.float64,0x7ff0000000000000,0x7ff0000000000000,1 +np.float64,0xbfaf59122c3eb220,0xbfaf5e15f8b272b0,1 +np.float64,0xbf9aa7d288354fa0,0xbf9aa897d2a40cb5,1 +np.float64,0x8004a43428694869,0x8004a43428694869,1 +np.float64,0x7feead476dbd5a8e,0x7ff0000000000000,1 +np.float64,0xffca150f81342a20,0xfff0000000000000,1 +np.float64,0x80047ec3bc88fd88,0x80047ec3bc88fd88,1 +np.float64,0xbfee3e5b123c7cb6,0xbff179c8b8334278,1 +np.float64,0x3fd172359f22e46b,0x3fd1a9ba6b1420a1,1 +np.float64,0x3fe8e5e242f1cbc5,0x3feb7cbcaefc4d5c,1 +np.float64,0x8007fb059a6ff60c,0x8007fb059a6ff60c,1 +np.float64,0xe3899e71c7134,0xe3899e71c7134,1 +np.float64,0x7fe3b98326a77305,0x7ff0000000000000,1 +np.float64,0x7fec4e206cb89c40,0x7ff0000000000000,1 +np.float64,0xbfa3b012c4276020,0xbfa3b150c13b3cc5,1 +np.float64,0xffefffffffffffff,0xfff0000000000000,1 +np.float64,0xffe28a5b9aa514b6,0xfff0000000000000,1 +np.float64,0xbfd76a6cc2aed4da,0xbfd7f10f4d04e7f6,1 +np.float64,0xbc2b1c0178564,0xbc2b1c0178564,1 +np.float64,0x6d9d444adb3a9,0x6d9d444adb3a9,1 +np.float64,0xbfdcadd368395ba6,0xbfdda6037b5c429c,1 +np.float64,0x3fe11891fde23124,0x3fe1ebc1c204b14b,1 +np.float64,0x3fdd66c3eebacd88,0x3fde72526b5304c4,1 +np.float64,0xbfe79d85612f3b0b,0xbfe9d1673bd1f6d6,1 +np.float64,0x3fed60abdabac158,0x3ff0d7426b3800a2,1 +np.float64,0xbfb0ffa54021ff48,0xbfb102d81073a9f0,1 +np.float64,0xd2452af5a48a6,0xd2452af5a48a6,1 +np.float64,0xf4b835c1e971,0xf4b835c1e971,1 +np.float64,0x7e269cdafc4d4,0x7e269cdafc4d4,1 +np.float64,0x800097a21d812f45,0x800097a21d812f45,1 +np.float64,0x3fdfcc85e8bf990c,0x3fe08fcf770fd456,1 +np.float64,0xd8d53155b1aa6,0xd8d53155b1aa6,1 +np.float64,0x7fb8ed658831daca,0x7ff0000000000000,1 +np.float64,0xbfec865415b90ca8,0xbff03a4584d719f9,1 +np.float64,0xffd8cda62a319b4c,0xfff0000000000000,1 +np.float64,0x273598d84e6b4,0x273598d84e6b4,1 +np.float64,0x7fd566b5c32acd6b,0x7ff0000000000000,1 +np.float64,0xff61d9d48023b400,0xfff0000000000000,1 +np.float64,0xbfec5c3bf4f8b878,0xbff01c594243337c,1 +np.float64,0x7fd1be0561a37c0a,0x7ff0000000000000,1 +np.float64,0xffeaee3271b5dc64,0xfff0000000000000,1 +np.float64,0x800c0e1931b81c33,0x800c0e1931b81c33,1 +np.float64,0xbfad1171583a22e0,0xbfad1570e5c466d2,1 +np.float64,0x7fd783b0fe2f0761,0x7ff0000000000000,1 +np.float64,0x7fc39903e6273207,0x7ff0000000000000,1 +np.float64,0xffe00003c5600007,0xfff0000000000000,1 +np.float64,0x35a7b9c06b50,0x35a7b9c06b50,1 +np.float64,0x7fee441a22bc8833,0x7ff0000000000000,1 +np.float64,0xff6e47fbc03c9000,0xfff0000000000000,1 +np.float64,0xbfd3c3c9c8a78794,0xbfd41499b1912534,1 +np.float64,0x82c9c87f05939,0x82c9c87f05939,1 +np.float64,0xbfedeb0fe4fbd620,0xbff13c573ce9d3d0,1 +np.float64,0x2b79298656f26,0x2b79298656f26,1 +np.float64,0xbf5ee44f003dc800,0xbf5ee4503353c0ba,1 +np.float64,0xbfe1dd264e63ba4c,0xbfe2ce68116c7bf6,1 +np.float64,0x3fece10b7579c217,0x3ff07b21b11799c6,1 +np.float64,0x3fba47143a348e28,0x3fba52e601adf24c,1 +np.float64,0xffe9816e7a7302dc,0xfff0000000000000,1 +np.float64,0x8009a8047fd35009,0x8009a8047fd35009,1 +np.float64,0x800ac28e4e95851d,0x800ac28e4e95851d,1 +np.float64,0x80093facf4f27f5a,0x80093facf4f27f5a,1 +np.float64,0x3ff0000000000000,0x3ff2cd9fc44eb982,1 +np.float64,0x3fe76a9857eed530,0x3fe99018a5895a4f,1 +np.float64,0xbfd13c59a3a278b4,0xbfd171e133df0b16,1 +np.float64,0x7feb43bc83368778,0x7ff0000000000000,1 +np.float64,0xbfe2970c5fa52e18,0xbfe3a74a434c6efe,1 +np.float64,0xffd091c380212388,0xfff0000000000000,1 +np.float64,0x3febb3b9d2f76774,0x3fef4b4af2bd8580,1 +np.float64,0x7fec66787ef8ccf0,0x7ff0000000000000,1 +np.float64,0xbf935e185826bc40,0xbf935e640557a354,1 +np.float64,0x979df1552f3be,0x979df1552f3be,1 +np.float64,0x7fc096ee73212ddc,0x7ff0000000000000,1 +np.float64,0xbfe9de88faf3bd12,0xbfecc7d1ae691d1b,1 +np.float64,0x7fdc733f06b8e67d,0x7ff0000000000000,1 +np.float64,0xffd71be1a0ae37c4,0xfff0000000000000,1 +np.float64,0xb50dabd36a1b6,0xb50dabd36a1b6,1 +np.float64,0x7fce3d94d63c7b29,0x7ff0000000000000,1 +np.float64,0x7fbaf95e4435f2bc,0x7ff0000000000000,1 +np.float64,0x81a32a6f03466,0x81a32a6f03466,1 +np.float64,0xa99b5b4d5336c,0xa99b5b4d5336c,1 +np.float64,0x7f97c1eeb82f83dc,0x7ff0000000000000,1 +np.float64,0x3fe761636d6ec2c6,0x3fe98451160d2ffb,1 +np.float64,0xbfe3224ef5e6449e,0xbfe44b73eeadac52,1 +np.float64,0x7fde6feb0dbcdfd5,0x7ff0000000000000,1 +np.float64,0xbfee87f9ca7d0ff4,0xbff1b079e9d7f706,1 +np.float64,0x3fe46f4c9828de99,0x3fe5da2ab9609ea5,1 +np.float64,0xffb92fe882325fd0,0xfff0000000000000,1 +np.float64,0x80054bc63cea978d,0x80054bc63cea978d,1 +np.float64,0x3d988bea7b312,0x3d988bea7b312,1 +np.float64,0x3fe6468e1d6c8d1c,0x3fe81e64d37d39a8,1 +np.float64,0x3fd68eefc22d1de0,0x3fd7074264faeead,1 +np.float64,0xffb218a074243140,0xfff0000000000000,1 +np.float64,0x3fdbcb3b6cb79678,0x3fdcad011de40b7d,1 +np.float64,0x7fe3c161772782c2,0x7ff0000000000000,1 +np.float64,0x25575c904aaec,0x25575c904aaec,1 +np.float64,0x800fa43a8f5f4875,0x800fa43a8f5f4875,1 +np.float64,0x3fe41fc9e1e83f94,0x3fe57a25dd1a37f1,1 +np.float64,0x3fd895f4a7b12be9,0x3fd931e7b721a08a,1 +np.float64,0xce31469f9c629,0xce31469f9c629,1 +np.float64,0xffea0f55ca341eab,0xfff0000000000000,1 +np.float64,0xffe831c9ba306393,0xfff0000000000000,1 +np.float64,0x7fe2056f03a40add,0x7ff0000000000000,1 +np.float64,0x7fd6b075e02d60eb,0x7ff0000000000000,1 +np.float64,0x3fdfbef4273f7de8,0x3fe0882c1f59efc0,1 +np.float64,0x8005b9e094ab73c2,0x8005b9e094ab73c2,1 +np.float64,0x3fea881ac6351036,0x3fedad7a319b887c,1 +np.float64,0xbfe2c61c7ee58c39,0xbfe3de9a99d8a9c6,1 +np.float64,0x30b0d3786161b,0x30b0d3786161b,1 +np.float64,0x3fa51d56a02a3aad,0x3fa51edee2d2ecef,1 +np.float64,0x79745732f2e8c,0x79745732f2e8c,1 +np.float64,0x800d55b4907aab69,0x800d55b4907aab69,1 +np.float64,0xbfbe8fcf0a3d1fa0,0xbfbea267fbb5bfdf,1 +np.float64,0xbfd04e2756a09c4e,0xbfd07b74d079f9a2,1 +np.float64,0x3fc65170552ca2e1,0x3fc66e6eb00c82ed,1 +np.float64,0xbfb0674b8020ce98,0xbfb06a2b4771b64c,1 +np.float64,0x2059975840b34,0x2059975840b34,1 +np.float64,0x33d1385467a28,0x33d1385467a28,1 +np.float64,0x3fea41b74ff4836f,0x3fed4dc1a09e53cc,1 +np.float64,0xbfe8e08c9d71c119,0xbfeb75b4c59a6bec,1 +np.float64,0x7fdbbf14d6377e29,0x7ff0000000000000,1 +np.float64,0x3fcd8b71513b16e0,0x3fcdcec80174f9ad,1 +np.float64,0x5c50bc94b8a18,0x5c50bc94b8a18,1 +np.float64,0x969a18f52d343,0x969a18f52d343,1 +np.float64,0x3fd7ae44462f5c89,0x3fd8398bc34e395c,1 +np.float64,0xffdd0f8617ba1f0c,0xfff0000000000000,1 +np.float64,0xfff0000000000000,0xfff0000000000000,1 +np.float64,0xbfe2f9badb65f376,0xbfe41b771320ece8,1 +np.float64,0x3fd140bc7fa29,0x3fd140bc7fa29,1 +np.float64,0xbfe14523b5628a48,0xbfe21ee850972043,1 +np.float64,0x3feedd0336bdba06,0x3ff1f01afc1f3a06,1 +np.float64,0x800de423ad7bc848,0x800de423ad7bc848,1 +np.float64,0x4cef857c99df1,0x4cef857c99df1,1 +np.float64,0xbfea55e0e374abc2,0xbfed691e41d648dd,1 +np.float64,0x3fe70d7a18ae1af4,0x3fe91955a34d8094,1 +np.float64,0xbfc62fc3032c5f88,0xbfc64c3ec25decb8,1 +np.float64,0x3fc915abb5322b58,0x3fc93edac5cc73fe,1 +np.float64,0x69aaff66d3561,0x69aaff66d3561,1 +np.float64,0x5c6a90f2b8d53,0x5c6a90f2b8d53,1 +np.float64,0x3fefe30dc1bfc61c,0x3ff2b752257bdacd,1 +np.float64,0x3fef15db15fe2bb6,0x3ff21aea05601396,1 +np.float64,0xbfe353e5ac66a7cc,0xbfe48644e6553d1a,1 +np.float64,0x3fe6d30cffada61a,0x3fe8cf3e4c61ddac,1 +np.float64,0x7fb7857eb62f0afc,0x7ff0000000000000,1 +np.float64,0xbfdd9b53d23b36a8,0xbfdeac91a7af1340,1 +np.float64,0x3fd1456357228ac7,0x3fd17b3f7d39b27a,1 +np.float64,0x3fb57d10ae2afa21,0x3fb5838702b806f4,1 +np.float64,0x800c59c96c98b393,0x800c59c96c98b393,1 +np.float64,0x7fc1f2413823e481,0x7ff0000000000000,1 +np.float64,0xbfa3983624273070,0xbfa3996fa26c419a,1 +np.float64,0x7fb28874ae2510e8,0x7ff0000000000000,1 +np.float64,0x3fe826d02a304da0,0x3fea82bec50bc0b6,1 +np.float64,0x8008d6f0d3d1ade2,0x8008d6f0d3d1ade2,1 +np.float64,0xffe7c970ca2f92e1,0xfff0000000000000,1 +np.float64,0x7fcf42bcaa3e8578,0x7ff0000000000000,1 +np.float64,0x7fda1ab517343569,0x7ff0000000000000,1 +np.float64,0xbfe7926a65ef24d5,0xbfe9c323dd890d5b,1 +np.float64,0xbfcaf6282d35ec50,0xbfcb294f36a0a33d,1 +np.float64,0x800ca49df8d9493c,0x800ca49df8d9493c,1 +np.float64,0xffea18d26af431a4,0xfff0000000000000,1 +np.float64,0x3fb72f276e2e5e50,0x3fb7374539fd1221,1 +np.float64,0xffa6b613842d6c20,0xfff0000000000000,1 +np.float64,0xbfeb3c7263f678e5,0xbfeea54cdb60b54c,1 +np.float64,0x3fc976d2ba32eda5,0x3fc9a1e83a058de4,1 +np.float64,0xbfe4acd4b0e959aa,0xbfe624d5d4f9b9a6,1 +np.float64,0x7fca410a0f348213,0x7ff0000000000000,1 +np.float64,0xbfde368f77bc6d1e,0xbfdf5910c8c8bcb0,1 +np.float64,0xbfed7412937ae825,0xbff0e55afc428453,1 +np.float64,0xffef6b7b607ed6f6,0xfff0000000000000,1 +np.float64,0xbfb936f17e326de0,0xbfb941629a53c694,1 +np.float64,0x800dbb0c469b7619,0x800dbb0c469b7619,1 +np.float64,0x800f68b0581ed161,0x800f68b0581ed161,1 +np.float64,0x3fe25b2aad64b656,0x3fe361266fa9c5eb,1 +np.float64,0xbfb87e445a30fc88,0xbfb887d676910c3f,1 +np.float64,0x6e6ba9b6dcd76,0x6e6ba9b6dcd76,1 +np.float64,0x3fad27ce583a4f9d,0x3fad2bd72782ffdb,1 +np.float64,0xbfec0bc5d638178c,0xbfefc6e8c8f9095f,1 +np.float64,0x7fcba4a296374944,0x7ff0000000000000,1 +np.float64,0x8004ca237cc99448,0x8004ca237cc99448,1 +np.float64,0xffe85b8c3270b718,0xfff0000000000000,1 +np.float64,0x7fe7ee3eddafdc7d,0x7ff0000000000000,1 +np.float64,0xffd275967ca4eb2c,0xfff0000000000000,1 +np.float64,0xbfa95bc3a032b780,0xbfa95e6b288ecf43,1 +np.float64,0x3fc9e3214b33c643,0x3fca10667e7e7ff4,1 +np.float64,0x8001b89c5d837139,0x8001b89c5d837139,1 +np.float64,0xbf8807dfc0300fc0,0xbf880803e3badfbd,1 +np.float64,0x800aca94b895952a,0x800aca94b895952a,1 +np.float64,0x7fd79534a02f2a68,0x7ff0000000000000,1 +np.float64,0x3fe1b81179e37023,0x3fe2a371d8cc26f0,1 +np.float64,0x800699539d6d32a8,0x800699539d6d32a8,1 +np.float64,0xffe51dfbb3aa3bf7,0xfff0000000000000,1 +np.float64,0xbfdfb775abbf6eec,0xbfe083f48be2f98f,1 +np.float64,0x3fe87979d7b0f2f4,0x3feaee701d959079,1 +np.float64,0x3fd8e4e6a731c9cd,0x3fd986d29f25f982,1 +np.float64,0x3fe3dadaaf67b5b6,0x3fe527520fb02920,1 +np.float64,0x8003c2262bc7844d,0x8003c2262bc7844d,1 +np.float64,0x800c930add392616,0x800c930add392616,1 +np.float64,0xffb7a152a22f42a8,0xfff0000000000000,1 +np.float64,0x80028fe03dc51fc1,0x80028fe03dc51fc1,1 +np.float64,0xffe32ae60c6655cc,0xfff0000000000000,1 +np.float64,0x3fea3527e4746a50,0x3fed3cbbf47f18eb,1 +np.float64,0x800a53059e14a60c,0x800a53059e14a60c,1 +np.float64,0xbfd79e3b202f3c76,0xbfd828672381207b,1 +np.float64,0xffeed7e2eb7dafc5,0xfff0000000000000,1 +np.float64,0x3fec51ed6778a3db,0x3ff01509e34df61d,1 +np.float64,0xbfd84bc577b0978a,0xbfd8e23ec55e42e8,1 +np.float64,0x2483aff849077,0x2483aff849077,1 +np.float64,0x6f57883adeaf2,0x6f57883adeaf2,1 +np.float64,0xffd3fd74d927faea,0xfff0000000000000,1 +np.float64,0x7fca49ec773493d8,0x7ff0000000000000,1 +np.float64,0x7fd08fe2e8211fc5,0x7ff0000000000000,1 +np.float64,0x800852086db0a411,0x800852086db0a411,1 +np.float64,0x3fe5b1f2c9eb63e6,0x3fe7654f511bafc6,1 +np.float64,0xbfe01e2a58e03c54,0xbfe0cedb68f021e6,1 +np.float64,0x800988421d331085,0x800988421d331085,1 +np.float64,0xffd5038b18aa0716,0xfff0000000000000,1 +np.float64,0x8002c9264c85924d,0x8002c9264c85924d,1 +np.float64,0x3fd21ca302243946,0x3fd25ac653a71aab,1 +np.float64,0xbfea60d6e6f4c1ae,0xbfed78031d9dfa2b,1 +np.float64,0xffef97b6263f2f6b,0xfff0000000000000,1 +np.float64,0xbfd524732faa48e6,0xbfd5876ecc415dcc,1 +np.float64,0x660387e8cc072,0x660387e8cc072,1 +np.float64,0x7fcfc108a33f8210,0x7ff0000000000000,1 +np.float64,0x7febe5b0f877cb61,0x7ff0000000000000,1 +np.float64,0xbfa55fdfac2abfc0,0xbfa56176991851a8,1 +np.float64,0x25250f4c4a4a3,0x25250f4c4a4a3,1 +np.float64,0xffe2f6a2f2a5ed46,0xfff0000000000000,1 +np.float64,0x7fa754fcc02ea9f9,0x7ff0000000000000,1 +np.float64,0x3febd19dea37a33c,0x3fef75279f75d3b8,1 +np.float64,0xc5ed55218bdab,0xc5ed55218bdab,1 +np.float64,0x3fe72ff6b3ee5fed,0x3fe945388b979882,1 +np.float64,0xbfe16b854e22d70a,0xbfe24b10fc0dff14,1 +np.float64,0xffb22cbe10245980,0xfff0000000000000,1 +np.float64,0xa54246b54a849,0xa54246b54a849,1 +np.float64,0x3fe7f4cda76fe99c,0x3fea41edc74888b6,1 +np.float64,0x1,0x1,1 +np.float64,0x800d84acce9b095a,0x800d84acce9b095a,1 +np.float64,0xb0eef04761dde,0xb0eef04761dde,1 +np.float64,0x7ff4000000000000,0x7ffc000000000000,1 +np.float64,0xffecaf1dbb795e3b,0xfff0000000000000,1 +np.float64,0x90dbab8d21b76,0x90dbab8d21b76,1 +np.float64,0x3fe79584a9ef2b09,0x3fe9c71fa9e40eb5,1 diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/data/umath-validation-set-tan.csv b/venv/lib/python3.12/site-packages/numpy/_core/tests/data/umath-validation-set-tan.csv new file mode 100644 index 00000000..ac97624e --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/tests/data/umath-validation-set-tan.csv @@ -0,0 +1,1429 @@ +dtype,input,output,ulperrortol +np.float32,0xfd97ece0,0xc11186e9,4 +np.float32,0x8013bb34,0x8013bb34,4 +np.float32,0x316389,0x316389,4 +np.float32,0x7f7fffff,0xbf1c9eca,4 +np.float32,0x3f7674bb,0x3fb7e450,4 +np.float32,0x80800000,0x80800000,4 +np.float32,0x7f5995e8,0xbf94106c,4 +np.float32,0x74527,0x74527,4 +np.float32,0x7f08caea,0xbeceddb6,4 +np.float32,0x2d49b2,0x2d49b2,4 +np.float32,0x3f74e5e4,0x3fb58695,4 +np.float32,0x3f3fcd51,0x3f6e1e81,4 +np.float32,0xbf4f3608,0xbf864d3d,4 +np.float32,0xbed974a0,0xbee78c70,4 +np.float32,0xff5f483c,0x3ecf3cb2,4 +np.float32,0x7f4532f4,0xc0b96f7b,4 +np.float32,0x3f0a4f7c,0x3f198cc0,4 +np.float32,0x210193,0x210193,4 +np.float32,0xfeebad7a,0xbf92eba8,4 +np.float32,0xfed29f74,0xc134cab6,4 +np.float32,0x803433a0,0x803433a0,4 +np.float32,0x64eb46,0x64eb46,4 +np.float32,0xbf54ef22,0xbf8c757b,4 +np.float32,0x3f3d5fdd,0x3f69a17b,4 +np.float32,0x80000001,0x80000001,4 +np.float32,0x800a837a,0x800a837a,4 +np.float32,0x6ff0be,0x6ff0be,4 +np.float32,0xfe8f1186,0x3f518820,4 +np.float32,0x804963e5,0x804963e5,4 +np.float32,0xfebaa59a,0x3fa1dbb0,4 +np.float32,0x637970,0x637970,4 +np.float32,0x3e722a6b,0x3e76c89a,4 +np.float32,0xff2b0478,0xbddccb5f,4 +np.float32,0xbf7bd85b,0xbfc06821,4 +np.float32,0x3ec33600,0x3ecd4126,4 +np.float32,0x3e0a43b9,0x3e0b1c69,4 +np.float32,0x7f7511b6,0xbe427083,4 +np.float32,0x3f28c114,0x3f465a73,4 +np.float32,0x3f179e1c,0x3f2c3e7c,4 +np.float32,0x7b2963,0x7b2963,4 +np.float32,0x3f423d06,0x3f72b442,4 +np.float32,0x3f5a24c6,0x3f925508,4 +np.float32,0xff18c834,0xbf79b5c8,4 +np.float32,0x3f401ece,0x3f6eb6ac,4 +np.float32,0x7b8a3013,0xbffab968,4 +np.float32,0x80091ff0,0x80091ff0,4 +np.float32,0x3f389c51,0x3f610b47,4 +np.float32,0x5ea174,0x5ea174,4 +np.float32,0x807a9eb2,0x807a9eb2,4 +np.float32,0x806ce61e,0x806ce61e,4 +np.float32,0xbe956acc,0xbe99cefc,4 +np.float32,0x7e60e247,0xbf5e64a5,4 +np.float32,0x7f398e24,0x404d12ed,4 +np.float32,0x3d9049f8,0x3d908735,4 +np.float32,0x7db17ffc,0xbf5b3d87,4 +np.float32,0xff453f78,0xc0239c9f,4 +np.float32,0x3f024aac,0x3f0ed802,4 +np.float32,0xbe781c30,0xbe7d1508,4 +np.float32,0x3f77962a,0x3fb9a28e,4 +np.float32,0xff7fffff,0x3f1c9eca,4 +np.float32,0x3f7152e3,0x3fb03f9d,4 +np.float32,0xff7cb167,0x3f9ce831,4 +np.float32,0x3e763e30,0x3e7b1a10,4 +np.float32,0xbf126527,0xbf24c253,4 +np.float32,0x803f6660,0x803f6660,4 +np.float32,0xbf79de38,0xbfbd38b1,4 +np.float32,0x8046c2f0,0x8046c2f0,4 +np.float32,0x6dc74e,0x6dc74e,4 +np.float32,0xbec9c45e,0xbed4e768,4 +np.float32,0x3f0eedb6,0x3f1fe610,4 +np.float32,0x7e031999,0xbcc13026,4 +np.float32,0x7efc2fd7,0x41e4b284,4 +np.float32,0xbeab7454,0xbeb22a1b,4 +np.float32,0x805ee67b,0x805ee67b,4 +np.float32,0x7f76e58e,0xc2436659,4 +np.float32,0xbe62b024,0xbe667718,4 +np.float32,0x3eea0808,0x3efbd182,4 +np.float32,0xbf7fd00c,0xbfc70719,4 +np.float32,0x7f27b640,0xbf0d97e0,4 +np.float32,0x3f1b58a4,0x3f31b6f4,4 +np.float32,0x252a9f,0x252a9f,4 +np.float32,0x7f65f95a,0xbead5de3,4 +np.float32,0xfc6ea780,0x42d15801,4 +np.float32,0x7eac4c52,0xc0682424,4 +np.float32,0xbe8a3f5a,0xbe8db54d,4 +np.float32,0xbf1644e2,0xbf2a4abd,4 +np.float32,0x3fc96a,0x3fc96a,4 +np.float32,0x7f38c0e4,0x3cc04af8,4 +np.float32,0x3f623d75,0x3f9c065d,4 +np.float32,0x3ee6a51a,0x3ef7a058,4 +np.float32,0x3dd11020,0x3dd1cacf,4 +np.float32,0xb6918,0xb6918,4 +np.float32,0xfdd7a540,0x3f22f081,4 +np.float32,0x80798563,0x80798563,4 +np.float32,0x3e9a8b7a,0x3e9f6a7e,4 +np.float32,0xbea515d4,0xbeab0df5,4 +np.float32,0xbea9b9f4,0xbeb03abe,4 +np.float32,0xbf11a5fa,0xbf23b478,4 +np.float32,0xfd6cadf0,0xbfa2a878,4 +np.float32,0xbf6edd07,0xbfacbb78,4 +np.float32,0xff5c5328,0x3e2d1552,4 +np.float32,0xbea2f788,0xbea8b3f5,4 +np.float32,0x802efaeb,0x802efaeb,4 +np.float32,0xff1c85e5,0x41f8560e,4 +np.float32,0x3f53b123,0x3f8b18e1,4 +np.float32,0xff798c4a,0x4092e66f,4 +np.float32,0x7f2e6fe7,0xbdcbd58f,4 +np.float32,0xfe8a8196,0x3fd7fc56,4 +np.float32,0x5e7ad4,0x5e7ad4,4 +np.float32,0xbf23a02d,0xbf3e4533,4 +np.float32,0x3f31c55c,0x3f5531bf,4 +np.float32,0x80331be3,0x80331be3,4 +np.float32,0x8056960a,0x8056960a,4 +np.float32,0xff1c06ae,0xbfd26992,4 +np.float32,0xbe0cc4b0,0xbe0da96c,4 +np.float32,0x7e925ad5,0xbf8dba54,4 +np.float32,0x2c8cec,0x2c8cec,4 +np.float32,0x8011951e,0x8011951e,4 +np.float32,0x3f2caf84,0x3f4cb89f,4 +np.float32,0xbd32c220,0xbd32df33,4 +np.float32,0xbec358d6,0xbecd6996,4 +np.float32,0x3f6e4930,0x3fabeb92,4 +np.float32,0xbf6a3afd,0xbfa65a3a,4 +np.float32,0x80067764,0x80067764,4 +np.float32,0x3d8df1,0x3d8df1,4 +np.float32,0x7ee51cf2,0x409e4061,4 +np.float32,0x435f5d,0x435f5d,4 +np.float32,0xbf5b17f7,0xbf936ebe,4 +np.float32,0x3ecaacb5,0x3ed5f81f,4 +np.float32,0x807b0aa5,0x807b0aa5,4 +np.float32,0x52b40b,0x52b40b,4 +np.float32,0x146a97,0x146a97,4 +np.float32,0x7f42b952,0xbfdcb413,4 +np.float32,0xbf1a1af2,0xbf2fe1bb,4 +np.float32,0x3f312034,0x3f541aa2,4 +np.float32,0x3f281d60,0x3f4554f9,4 +np.float32,0x50e451,0x50e451,4 +np.float32,0xbe45838c,0xbe480016,4 +np.float32,0xff7d0aeb,0x3eb0746e,4 +np.float32,0x7f32a489,0xbf96af6d,4 +np.float32,0xbf1b4e27,0xbf31a769,4 +np.float32,0x3f242936,0x3f3f1a44,4 +np.float32,0xbf7482ff,0xbfb4f201,4 +np.float32,0x4bda38,0x4bda38,4 +np.float32,0xbf022208,0xbf0ea2bb,4 +np.float32,0x7d08ca95,0xbe904602,4 +np.float32,0x7ed2f356,0xc02b55ad,4 +np.float32,0xbf131204,0xbf25b734,4 +np.float32,0xff3464b4,0x3fb23706,4 +np.float32,0x5a97cf,0x5a97cf,4 +np.float32,0xbe52db70,0xbe55e388,4 +np.float32,0x3f52934f,0x3f89e2aa,4 +np.float32,0xfeea866a,0x40a2b33f,4 +np.float32,0x80333925,0x80333925,4 +np.float32,0xfef5d13e,0xc00139ec,4 +np.float32,0x3f4750ab,0x3f7c87ad,4 +np.float32,0x3e41bfdd,0x3e44185a,4 +np.float32,0xbf5b0572,0xbf935935,4 +np.float32,0xbe93c9da,0xbe9808d8,4 +np.float32,0x7f501f33,0xc0f9973c,4 +np.float32,0x800af035,0x800af035,4 +np.float32,0x3f29faf8,0x3f4852a8,4 +np.float32,0xbe1e4c20,0xbe1f920c,4 +np.float32,0xbf7e8616,0xbfc4d79d,4 +np.float32,0x43ffbf,0x43ffbf,4 +np.float32,0x7f28e8a9,0xbfa1ac24,4 +np.float32,0xbf1f9f92,0xbf3820bc,4 +np.float32,0x3f07e004,0x3f1641c4,4 +np.float32,0x3ef7ea7f,0x3f06a64a,4 +np.float32,0x7e013101,0x3f6080e6,4 +np.float32,0x7f122a4f,0xbf0a796f,4 +np.float32,0xfe096960,0x3ed7273a,4 +np.float32,0x3f06abf1,0x3f14a4b2,4 +np.float32,0x3e50ded3,0x3e53d0f1,4 +np.float32,0x7f50b346,0x3eabb536,4 +np.float32,0xff5adb0f,0xbd441972,4 +np.float32,0xbecefe46,0xbedb0f66,4 +np.float32,0x7da70bd4,0xbec66273,4 +np.float32,0x169811,0x169811,4 +np.float32,0xbee4dfee,0xbef5721a,4 +np.float32,0x3efbeae3,0x3f0936e6,4 +np.float32,0x8031bd61,0x8031bd61,4 +np.float32,0x8048e443,0x8048e443,4 +np.float32,0xff209aa6,0xbeb364cb,4 +np.float32,0xff477499,0x3c1b0041,4 +np.float32,0x803fe929,0x803fe929,4 +np.float32,0x3f70158b,0x3fae7725,4 +np.float32,0x7f795723,0x3e8e850a,4 +np.float32,0x3cba99,0x3cba99,4 +np.float32,0x80588d2a,0x80588d2a,4 +np.float32,0x805d1f05,0x805d1f05,4 +np.float32,0xff4ac09a,0xbefe614d,4 +np.float32,0x804af084,0x804af084,4 +np.float32,0x7c64ae63,0xc1a8b563,4 +np.float32,0x8078d793,0x8078d793,4 +np.float32,0x7f3e2436,0xbf8bf9d3,4 +np.float32,0x7ccec1,0x7ccec1,4 +np.float32,0xbf6462c7,0xbf9eb830,4 +np.float32,0x3f1002ca,0x3f216843,4 +np.float32,0xfe878ca6,0x409e73a5,4 +np.float32,0x3bd841d9,0x3bd842a7,4 +np.float32,0x7d406f41,0xbd9dcfa3,4 +np.float32,0x7c6d6,0x7c6d6,4 +np.float32,0x3f4ef360,0x3f86074b,4 +np.float32,0x805f534a,0x805f534a,4 +np.float32,0x1,0x1,4 +np.float32,0x3f739ee2,0x3fb39db2,4 +np.float32,0x3d0c2352,0x3d0c3153,4 +np.float32,0xfe8a4f2c,0x3edd8add,4 +np.float32,0x3e52eaa0,0x3e55f362,4 +np.float32,0x7bde9758,0xbf5ba5cf,4 +np.float32,0xff422654,0xbf41e487,4 +np.float32,0x385e5b,0x385e5b,4 +np.float32,0x5751dd,0x5751dd,4 +np.float32,0xff6c671c,0xc03e2d6d,4 +np.float32,0x1458be,0x1458be,4 +np.float32,0x80153d4d,0x80153d4d,4 +np.float32,0x7efd2adb,0x3e25458f,4 +np.float32,0xbe161880,0xbe172e12,4 +np.float32,0x7ecea1aa,0x40a66d79,4 +np.float32,0xbf5b02a2,0xbf9355f0,4 +np.float32,0x15d9ab,0x15d9ab,4 +np.float32,0x2dc7c7,0x2dc7c7,4 +np.float32,0xfebbf81a,0x4193f6e6,4 +np.float32,0xfe8e3594,0xc00a6695,4 +np.float32,0x185aa8,0x185aa8,4 +np.float32,0x3daea156,0x3daf0e00,4 +np.float32,0x3e071688,0x3e07e08e,4 +np.float32,0x802db9e6,0x802db9e6,4 +np.float32,0x7f7be2c4,0x3f1363dd,4 +np.float32,0x7eba3f5e,0xc13eb497,4 +np.float32,0x3de04a00,0x3de130a9,4 +np.float32,0xbf1022bc,0xbf2194eb,4 +np.float32,0xbf5b547e,0xbf93b53b,4 +np.float32,0x3e867bd6,0x3e89aa10,4 +np.float32,0xbea5eb5c,0xbeabfb73,4 +np.float32,0x7f1efae9,0x3ffca038,4 +np.float32,0xff5d0344,0xbe55dbbb,4 +np.float32,0x805167e7,0x805167e7,4 +np.float32,0xbdb3a020,0xbdb41667,4 +np.float32,0xbedea6b4,0xbeedd5fd,4 +np.float32,0x8053b45c,0x8053b45c,4 +np.float32,0x7ed370e9,0x3d90eba5,4 +np.float32,0xbefcd7da,0xbf09cf91,4 +np.float32,0x78b9ac,0x78b9ac,4 +np.float32,0xbf2f6dc0,0xbf5141ef,4 +np.float32,0x802d3a7b,0x802d3a7b,4 +np.float32,0xfd45d120,0x3fec31cc,4 +np.float32,0xbf7e7020,0xbfc4b2af,4 +np.float32,0xf04da,0xf04da,4 +np.float32,0xbe9819d4,0xbe9cbd35,4 +np.float32,0x8075ab35,0x8075ab35,4 +np.float32,0xbf052fdc,0xbf12aa2c,4 +np.float32,0x3f1530d0,0x3f28bd9f,4 +np.float32,0x80791881,0x80791881,4 +np.float32,0x67f309,0x67f309,4 +np.float32,0x3f12f16a,0x3f2588f5,4 +np.float32,0x3ecdac47,0x3ed97ff8,4 +np.float32,0xbf297fb7,0xbf478c39,4 +np.float32,0x8069fa80,0x8069fa80,4 +np.float32,0x807f940e,0x807f940e,4 +np.float32,0xbf648dc8,0xbf9eeecb,4 +np.float32,0x3de873b0,0x3de9748d,4 +np.float32,0x3f1aa645,0x3f30af1f,4 +np.float32,0xff227a62,0x3d8283cc,4 +np.float32,0xbf37187d,0xbf5e5f4c,4 +np.float32,0x803b1b1f,0x803b1b1f,4 +np.float32,0x3f58142a,0x3f8ff8da,4 +np.float32,0x8004339e,0x8004339e,4 +np.float32,0xbf0f5654,0xbf2077a4,4 +np.float32,0x3f17e509,0x3f2ca598,4 +np.float32,0x3f800000,0x3fc75923,4 +np.float32,0xfdf79980,0x42f13047,4 +np.float32,0x7f111381,0x3f13c4c9,4 +np.float32,0xbea40c70,0xbea9e724,4 +np.float32,0x110520,0x110520,4 +np.float32,0x60490d,0x60490d,4 +np.float32,0x3f6703ec,0x3fa21951,4 +np.float32,0xbf098256,0xbf187652,4 +np.float32,0x658951,0x658951,4 +np.float32,0x3f53bf16,0x3f8b2818,4 +np.float32,0xff451811,0xc0026068,4 +np.float32,0x80777ee0,0x80777ee0,4 +np.float32,0x3e4fcc19,0x3e52b286,4 +np.float32,0x7f387ee0,0x3ce93eb6,4 +np.float32,0xff51181f,0xbfca3ee4,4 +np.float32,0xbf5655ae,0xbf8e0304,4 +np.float32,0xff2f1dcd,0x40025471,4 +np.float32,0x7f6e58e5,0xbe9930d5,4 +np.float32,0x7adf11,0x7adf11,4 +np.float32,0xbe9a2bc2,0xbe9f0185,4 +np.float32,0x8065d3a0,0x8065d3a0,4 +np.float32,0x3ed6e826,0x3ee47c45,4 +np.float32,0x80598ea0,0x80598ea0,4 +np.float32,0x7f10b90a,0x40437bd0,4 +np.float32,0x27b447,0x27b447,4 +np.float32,0x7ecd861c,0x3fce250f,4 +np.float32,0x0,0x0,4 +np.float32,0xbeba82d6,0xbec3394c,4 +np.float32,0xbf4958b0,0xbf8048ea,4 +np.float32,0x7c643e,0x7c643e,4 +np.float32,0x580770,0x580770,4 +np.float32,0x805bf54a,0x805bf54a,4 +np.float32,0x7f1f3cee,0xbe1a54d6,4 +np.float32,0xfefefdea,0x3fa84576,4 +np.float32,0x7f007b7a,0x3e8a6d25,4 +np.float32,0xbf177959,0xbf2c0919,4 +np.float32,0xbf30fda0,0xbf53e058,4 +np.float32,0x3f0576be,0x3f130861,4 +np.float32,0x3f49380e,0x3f80283a,4 +np.float32,0xebc56,0xebc56,4 +np.float32,0x654e3b,0x654e3b,4 +np.float32,0x14a4d8,0x14a4d8,4 +np.float32,0xff69b3cb,0xbf822a88,4 +np.float32,0xbe9b6c1c,0xbea06109,4 +np.float32,0xbefddd7e,0xbf0a787b,4 +np.float32,0x4c4ebb,0x4c4ebb,4 +np.float32,0x7d0a74,0x7d0a74,4 +np.float32,0xbebb5f80,0xbec43635,4 +np.float32,0x7ee79723,0xc1c7f3f3,4 +np.float32,0x7f2be4c7,0xbfa6c693,4 +np.float32,0x805bc7d5,0x805bc7d5,4 +np.float32,0x8042f12c,0x8042f12c,4 +np.float32,0x3ef91be8,0x3f07697b,4 +np.float32,0x3cf37ac0,0x3cf38d1c,4 +np.float32,0x800000,0x800000,4 +np.float32,0xbe1ebf4c,0xbe200806,4 +np.float32,0x7f380862,0xbeb512e8,4 +np.float32,0xbe320064,0xbe33d0fc,4 +np.float32,0xff300b0c,0xbfadb805,4 +np.float32,0x308a06,0x308a06,4 +np.float32,0xbf084f6e,0xbf16d7b6,4 +np.float32,0xff47cab6,0x3f892b65,4 +np.float32,0xbed99f4a,0xbee7bfd5,4 +np.float32,0xff7d74c0,0x3ee88c9a,4 +np.float32,0x3c3d23,0x3c3d23,4 +np.float32,0x8074bde8,0x8074bde8,4 +np.float32,0x80042164,0x80042164,4 +np.float32,0x3e97c92a,0x3e9c6500,4 +np.float32,0x3b80e0,0x3b80e0,4 +np.float32,0xbf16646a,0xbf2a783d,4 +np.float32,0x7f3b4cb1,0xc01339be,4 +np.float32,0xbf31f36e,0xbf557fd0,4 +np.float32,0x7f540618,0xbe5f6fc1,4 +np.float32,0x7eee47d0,0x40a27e94,4 +np.float32,0x7f12f389,0xbebed654,4 +np.float32,0x56cff5,0x56cff5,4 +np.float32,0x8056032b,0x8056032b,4 +np.float32,0x3ed34e40,0x3ee02e38,4 +np.float32,0x7d51a908,0xbf19a90e,4 +np.float32,0x80000000,0x80000000,4 +np.float32,0xfdf73fd0,0xbf0f8cad,4 +np.float32,0x7ee4fe6d,0xbf1ea7e4,4 +np.float32,0x1f15ba,0x1f15ba,4 +np.float32,0xd18c3,0xd18c3,4 +np.float32,0x80797705,0x80797705,4 +np.float32,0x7ef07091,0x3f2f3b9a,4 +np.float32,0x7f552f41,0x3faf608c,4 +np.float32,0x3f779977,0x3fb9a7ad,4 +np.float32,0xfe1a7a50,0xbdadc4d1,4 +np.float32,0xbf449cf0,0xbf7740db,4 +np.float32,0xbe44e620,0xbe475cad,4 +np.float32,0x3f63a098,0x3f9dc2b5,4 +np.float32,0xfed40a12,0x4164533a,4 +np.float32,0x7a2bbb,0x7a2bbb,4 +np.float32,0xff7f7b9e,0xbeee8740,4 +np.float32,0x7ee27f8b,0x4233f53b,4 +np.float32,0xbf044c06,0xbf117c28,4 +np.float32,0xbeffde54,0xbf0bc49f,4 +np.float32,0xfeaef2e8,0x3ff258fe,4 +np.float32,0x527451,0x527451,4 +np.float32,0xbcef8d00,0xbcef9e7c,4 +np.float32,0xbf0e20c0,0xbf1ec9b2,4 +np.float32,0x8024afda,0x8024afda,4 +np.float32,0x7ef6cb3e,0x422cad0b,4 +np.float32,0x3c120,0x3c120,4 +np.float32,0xbf125c8f,0xbf24b62c,4 +np.float32,0x7e770a93,0x402c9d86,4 +np.float32,0xbd30a4e0,0xbd30c0ee,4 +np.float32,0xbf4d3388,0xbf843530,4 +np.float32,0x3f529072,0x3f89df92,4 +np.float32,0xff0270b1,0xbf81be9a,4 +np.float32,0x5e07e7,0x5e07e7,4 +np.float32,0x7bec32,0x7bec32,4 +np.float32,0x7fc00000,0x7fc00000,4 +np.float32,0x3e3ba5e0,0x3e3dc6e9,4 +np.float32,0x3ecb62d4,0x3ed6ce2c,4 +np.float32,0x3eb3dde8,0x3ebba68f,4 +np.float32,0x8063f952,0x8063f952,4 +np.float32,0x7f204aeb,0x3e88614e,4 +np.float32,0xbeae1ddc,0xbeb5278e,4 +np.float32,0x6829e9,0x6829e9,4 +np.float32,0xbf361a99,0xbf5ca354,4 +np.float32,0xbf24fbe6,0xbf406326,4 +np.float32,0x3f329d41,0x3f56a061,4 +np.float32,0xfed6d666,0x3e8f71a5,4 +np.float32,0x337f92,0x337f92,4 +np.float32,0xbe1c4970,0xbe1d8305,4 +np.float32,0xbe6b7e18,0xbe6fbbde,4 +np.float32,0x3f2267b9,0x3f3c61da,4 +np.float32,0xbee1ee94,0xbef1d628,4 +np.float32,0x7ecffc1a,0x3f02987e,4 +np.float32,0xbe9b1306,0xbe9fff3b,4 +np.float32,0xbeffacae,0xbf0ba468,4 +np.float32,0x7f800000,0xffc00000,4 +np.float32,0xfefc9aa8,0xc19de2a3,4 +np.float32,0x7d7185bb,0xbf9090ec,4 +np.float32,0x7edfbafd,0x3fe9352f,4 +np.float32,0x4ef2ec,0x4ef2ec,4 +np.float32,0x7f4cab2e,0xbff4e5dd,4 +np.float32,0xff3b1788,0x3e3c22e9,4 +np.float32,0x4e15ee,0x4e15ee,4 +np.float32,0xbf5451e6,0xbf8bc8a7,4 +np.float32,0x3f7f6d2e,0x3fc65e8b,4 +np.float32,0xbf1d9184,0xbf35071b,4 +np.float32,0xbf3a81cf,0xbf646d9b,4 +np.float32,0xbe71acc4,0xbe7643ab,4 +np.float32,0x528b7d,0x528b7d,4 +np.float32,0x2cb1d0,0x2cb1d0,4 +np.float32,0x3f324bf8,0x3f56161a,4 +np.float32,0x80709a21,0x80709a21,4 +np.float32,0x4bc448,0x4bc448,4 +np.float32,0x3e8bd600,0x3e8f6b7a,4 +np.float32,0xbeb97d30,0xbec20dd6,4 +np.float32,0x2a5669,0x2a5669,4 +np.float32,0x805f2689,0x805f2689,4 +np.float32,0xfe569f50,0x3fc51952,4 +np.float32,0x1de44c,0x1de44c,4 +np.float32,0x3ec7036c,0x3ed1ae67,4 +np.float32,0x8052b8e5,0x8052b8e5,4 +np.float32,0xff740a6b,0x3f4981a8,4 +np.float32,0xfee9bb70,0xc05e23be,4 +np.float32,0xff4e12c9,0x4002b4ad,4 +np.float32,0x803de0c2,0x803de0c2,4 +np.float32,0xbf433a07,0xbf74966f,4 +np.float32,0x803e60ca,0x803e60ca,4 +np.float32,0xbf19ee98,0xbf2fa07a,4 +np.float32,0x92929,0x92929,4 +np.float32,0x7f709c27,0x4257ba2d,4 +np.float32,0x803167c6,0x803167c6,4 +np.float32,0xbf095ead,0xbf184607,4 +np.float32,0x617060,0x617060,4 +np.float32,0x2d85b3,0x2d85b3,4 +np.float32,0x53d20b,0x53d20b,4 +np.float32,0x3e046838,0x3e052666,4 +np.float32,0xbe7c5fdc,0xbe80ce4b,4 +np.float32,0x3d18d060,0x3d18e289,4 +np.float32,0x804dc031,0x804dc031,4 +np.float32,0x3f224166,0x3f3c26cd,4 +np.float32,0x7d683e3c,0xbea24f25,4 +np.float32,0xbf3a92aa,0xbf648be4,4 +np.float32,0x8072670b,0x8072670b,4 +np.float32,0xbe281aec,0xbe29a1bc,4 +np.float32,0x7f09d918,0xc0942490,4 +np.float32,0x7ca9fd07,0x4018b990,4 +np.float32,0x7d36ac5d,0x3cf57184,4 +np.float32,0x8039b62f,0x8039b62f,4 +np.float32,0x6cad7b,0x6cad7b,4 +np.float32,0x3c0fd9ab,0x3c0fda9d,4 +np.float32,0x80299883,0x80299883,4 +np.float32,0x3c2d0e3e,0x3c2d0fe4,4 +np.float32,0x8002cf62,0x8002cf62,4 +np.float32,0x801dde97,0x801dde97,4 +np.float32,0x80411856,0x80411856,4 +np.float32,0x6ebce8,0x6ebce8,4 +np.float32,0x7b7d1a,0x7b7d1a,4 +np.float32,0x8031d3de,0x8031d3de,4 +np.float32,0x8005c4ab,0x8005c4ab,4 +np.float32,0xbf7dd803,0xbfc3b3ef,4 +np.float32,0x8017ae60,0x8017ae60,4 +np.float32,0xfe9316ce,0xbfe0544a,4 +np.float32,0x3f136bfe,0x3f2636ff,4 +np.float32,0x3df87b80,0x3df9b57d,4 +np.float32,0xff44c356,0xbf11c7ad,4 +np.float32,0x4914ae,0x4914ae,4 +np.float32,0x80524c21,0x80524c21,4 +np.float32,0x805c7dc8,0x805c7dc8,4 +np.float32,0xfed3c0aa,0xbff0c0ab,4 +np.float32,0x7eb2bfbb,0xbf4600bc,4 +np.float32,0xfec8df84,0x3f5bd350,4 +np.float32,0x3e5431a4,0x3e5748c3,4 +np.float32,0xbee6a3a0,0xbef79e86,4 +np.float32,0xbf6cc9b2,0xbfa9d61a,4 +np.float32,0x3f132bd5,0x3f25dbd9,4 +np.float32,0x7e6d2e48,0x3f9d025b,4 +np.float32,0x3edf430c,0x3eee942d,4 +np.float32,0x3f0d1b8a,0x3f1d60e1,4 +np.float32,0xbdf2f688,0xbdf41bfb,4 +np.float32,0xbe47a284,0xbe4a33ff,4 +np.float32,0x3eaa9fbc,0x3eb13be7,4 +np.float32,0xfe98d45e,0x3eb84517,4 +np.float32,0x7efc23b3,0x3dcc1c99,4 +np.float32,0x3ca36242,0x3ca367ce,4 +np.float32,0x3f76a944,0x3fb834e3,4 +np.float32,0xbf45207c,0xbf783f9b,4 +np.float32,0x3e7c1220,0x3e80a4f8,4 +np.float32,0x3f018200,0x3f0dd14e,4 +np.float32,0x3f53cdde,0x3f8b3839,4 +np.float32,0xbdbacb58,0xbdbb5063,4 +np.float32,0x804af68d,0x804af68d,4 +np.float32,0x3e2c12fc,0x3e2db65b,4 +np.float32,0x3f039433,0x3f10895a,4 +np.float32,0x7ef5193d,0x3f4115f7,4 +np.float32,0x8030afbe,0x8030afbe,4 +np.float32,0x3f06fa2a,0x3f150d5d,4 +np.float32,0x3f124442,0x3f2493d2,4 +np.float32,0xbeb5b792,0xbebdc090,4 +np.float32,0xbedc90a4,0xbeeb4de9,4 +np.float32,0x3f3ff8,0x3f3ff8,4 +np.float32,0x3ee75bc5,0x3ef881e4,4 +np.float32,0xfe80e3de,0xbf5cd535,4 +np.float32,0xf52eb,0xf52eb,4 +np.float32,0x80660ee8,0x80660ee8,4 +np.float32,0x3e173a58,0x3e185648,4 +np.float32,0xfe49520c,0xbf728d7c,4 +np.float32,0xbecbb8ec,0xbed73373,4 +np.float32,0xbf027ae0,0xbf0f173e,4 +np.float32,0xbcab6740,0xbcab6da8,4 +np.float32,0xbf2a15e2,0xbf487e11,4 +np.float32,0x3b781b,0x3b781b,4 +np.float32,0x44f559,0x44f559,4 +np.float32,0xff6a0ca6,0xc174d7c3,4 +np.float32,0x6460ef,0x6460ef,4 +np.float32,0xfe58009c,0x3ee2bb30,4 +np.float32,0xfec3c038,0x3e30d617,4 +np.float32,0x7f0687c0,0xbf62c820,4 +np.float32,0xbf44655e,0xbf76d589,4 +np.float32,0xbf42968c,0xbf735e78,4 +np.float32,0x80385503,0x80385503,4 +np.float32,0xbea7e3a2,0xbeae2d59,4 +np.float32,0x3dd0b770,0x3dd17131,4 +np.float32,0xbf4bc185,0xbf82b907,4 +np.float32,0xfefd7d64,0xbee05650,4 +np.float32,0xfaac3c00,0xbff23bc9,4 +np.float32,0xbf562f0d,0xbf8dd7f4,4 +np.float32,0x7fa00000,0x7fe00000,4 +np.float32,0x3e01bdb8,0x3e027098,4 +np.float32,0x3e2868ab,0x3e29f19e,4 +np.float32,0xfec55f2e,0x3f39f304,4 +np.float32,0xed4e,0xed4e,4 +np.float32,0x3e2b7330,0x3e2d11fa,4 +np.float32,0x7f738542,0x40cbbe16,4 +np.float32,0x3f123521,0x3f247e71,4 +np.float32,0x73572c,0x73572c,4 +np.float32,0x804936c8,0x804936c8,4 +np.float32,0x803b80d8,0x803b80d8,4 +np.float32,0x7f566c57,0xbee2855a,4 +np.float32,0xff0e3bd8,0xbff0543f,4 +np.float32,0x7d2b2fe7,0xbf94ba4c,4 +np.float32,0xbf0da470,0xbf1e1dc2,4 +np.float32,0xbd276500,0xbd277ce0,4 +np.float32,0xfcd15dc0,0x403ccc2a,4 +np.float32,0x80071e59,0x80071e59,4 +np.float32,0xbe9b0c34,0xbe9ff7be,4 +np.float32,0x3f4f9069,0x3f86ac50,4 +np.float32,0x80042a95,0x80042a95,4 +np.float32,0x7de28e39,0x3bc9b7f4,4 +np.float32,0xbf641935,0xbf9e5af8,4 +np.float32,0x8034f068,0x8034f068,4 +np.float32,0xff33a3d2,0xbf408e75,4 +np.float32,0xbcc51540,0xbcc51efc,4 +np.float32,0xff6d1ddf,0x3ef58f0e,4 +np.float32,0xbf64dfc4,0xbf9f5725,4 +np.float32,0xff068a06,0x3eea8987,4 +np.float32,0xff01c0af,0x3f24cdfe,4 +np.float32,0x3f4def7e,0x3f84f802,4 +np.float32,0xbf1b4ae7,0xbf31a299,4 +np.float32,0x8077df2d,0x8077df2d,4 +np.float32,0x3f0155c5,0x3f0d9785,4 +np.float32,0x5a54b2,0x5a54b2,4 +np.float32,0x7f271f9e,0x3efb2ef3,4 +np.float32,0xbf0ff2ec,0xbf215217,4 +np.float32,0x7f500130,0xbf8a7fdd,4 +np.float32,0xfed9891c,0xbf65c872,4 +np.float32,0xfecbfaae,0x403bdbc2,4 +np.float32,0x3f3a5aba,0x3f642772,4 +np.float32,0x7ebc681e,0xbd8df059,4 +np.float32,0xfe05e400,0xbfe35d74,4 +np.float32,0xbf295ace,0xbf4750ea,4 +np.float32,0x7ea055b2,0x3f62d6be,4 +np.float32,0xbd00b520,0xbd00bff9,4 +np.float32,0xbf7677aa,0xbfb7e8cf,4 +np.float32,0x3e83f788,0x3e86f816,4 +np.float32,0x801f6710,0x801f6710,4 +np.float32,0x801133cc,0x801133cc,4 +np.float32,0x41da2a,0x41da2a,4 +np.float32,0xff1622fd,0x3f023650,4 +np.float32,0x806c7a72,0x806c7a72,4 +np.float32,0x3f10779c,0x3f220bb4,4 +np.float32,0xbf08cf94,0xbf17848d,4 +np.float32,0xbecb55b4,0xbed6bebd,4 +np.float32,0xbf0a1528,0xbf193d7b,4 +np.float32,0x806a16bd,0x806a16bd,4 +np.float32,0xc222a,0xc222a,4 +np.float32,0x3930de,0x3930de,4 +np.float32,0x3f5c3588,0x3f94bca2,4 +np.float32,0x1215ad,0x1215ad,4 +np.float32,0x3ed15030,0x3eddcf67,4 +np.float32,0x7da83b2e,0x3fce0d39,4 +np.float32,0x32b0a8,0x32b0a8,4 +np.float32,0x805aed6b,0x805aed6b,4 +np.float32,0x3ef8e02f,0x3f074346,4 +np.float32,0xbdeb6780,0xbdec7250,4 +np.float32,0x3f6e3cec,0x3fabda61,4 +np.float32,0xfefd467a,0x3ef7821a,4 +np.float32,0xfef090fe,0x3bb752a2,4 +np.float32,0x8019c538,0x8019c538,4 +np.float32,0x3e8cf284,0x3e909e81,4 +np.float32,0xbe6c6618,0xbe70b0a2,4 +np.float32,0x7f50a539,0x3f367be1,4 +np.float32,0x8019fe2f,0x8019fe2f,4 +np.float32,0x800c3f48,0x800c3f48,4 +np.float32,0xfd054cc0,0xc0f52802,4 +np.float32,0x3d0cca20,0x3d0cd853,4 +np.float32,0xbf4a7c44,0xbf816e74,4 +np.float32,0x3f46fc40,0x3f7be153,4 +np.float32,0x807c5849,0x807c5849,4 +np.float32,0xd7e41,0xd7e41,4 +np.float32,0x70589b,0x70589b,4 +np.float32,0x80357b95,0x80357b95,4 +np.float32,0x3de239f0,0x3de326a5,4 +np.float32,0x800b08e3,0x800b08e3,4 +np.float32,0x807ec946,0x807ec946,4 +np.float32,0x3e2e4b83,0x3e2fff76,4 +np.float32,0x3f198e0f,0x3f2f12a6,4 +np.float32,0xbecb1aca,0xbed67979,4 +np.float32,0x80134082,0x80134082,4 +np.float32,0x3f3a269f,0x3f63ca05,4 +np.float32,0x3f1381e4,0x3f265622,4 +np.float32,0xff293080,0xbf10be6f,4 +np.float32,0xff800000,0xffc00000,4 +np.float32,0x37d196,0x37d196,4 +np.float32,0x7e57eea7,0x3e7d8138,4 +np.float32,0x804b1dae,0x804b1dae,4 +np.float32,0x7d9508f9,0xc1075b35,4 +np.float32,0x3f7bf468,0x3fc095e0,4 +np.float32,0x55472c,0x55472c,4 +np.float32,0x3ecdcd86,0x3ed9a738,4 +np.float32,0x3ed9be0f,0x3ee7e4e9,4 +np.float32,0x3e7e0ddb,0x3e81b2fe,4 +np.float32,0x7ee6c1d3,0x3f850634,4 +np.float32,0x800f6fad,0x800f6fad,4 +np.float32,0xfefb3bd6,0xbff68ecc,4 +np.float32,0x8013d6e2,0x8013d6e2,4 +np.float32,0x3f3a2cb6,0x3f63d4ee,4 +np.float32,0xff383c84,0x3e7854bb,4 +np.float32,0x3f21946e,0x3f3b1cea,4 +np.float32,0xff322ea2,0x3fb22f31,4 +np.float32,0x8065a024,0x8065a024,4 +np.float32,0x7f395e30,0xbefe0de1,4 +np.float32,0x5b52db,0x5b52db,4 +np.float32,0x7f7caea7,0x3dac8ded,4 +np.float32,0xbf0431f8,0xbf1159b2,4 +np.float32,0x7f15b25b,0xc02a3833,4 +np.float32,0x80131abc,0x80131abc,4 +np.float32,0x7e829d81,0xbeb2e93d,4 +np.float32,0x3f2c64d7,0x3f4c3e4d,4 +np.float32,0x7f228d48,0xc1518c74,4 +np.float32,0xfc3c6f40,0xbf00d585,4 +np.float32,0x7f754f0f,0x3e2152f5,4 +np.float32,0xff65d32b,0xbe8bd56c,4 +np.float32,0xfea6b8c0,0x41608655,4 +np.float32,0x3f7d4b05,0x3fc2c96a,4 +np.float32,0x3f463230,0x3f7a54da,4 +np.float32,0x805117bb,0x805117bb,4 +np.float32,0xbf2ad4f7,0xbf49b30e,4 +np.float32,0x3eaa01ff,0x3eb08b56,4 +np.float32,0xff7a02bb,0x3f095f73,4 +np.float32,0x759176,0x759176,4 +np.float32,0x803c18d5,0x803c18d5,4 +np.float32,0xbe0722d8,0xbe07ed16,4 +np.float32,0x3f4b4a99,0x3f823fc6,4 +np.float32,0x3f7d0451,0x3fc25463,4 +np.float32,0xfee31e40,0xbfb41091,4 +np.float32,0xbf733d2c,0xbfb30cf1,4 +np.float32,0x7ed81015,0x417c380c,4 +np.float32,0x7daafc3e,0xbe2a37ed,4 +np.float32,0x3e44f82b,0x3e476f67,4 +np.float32,0x7c8d99,0x7c8d99,4 +np.float32,0x3f7aec5a,0x3fbee991,4 +np.float32,0xff09fd55,0x3e0709d3,4 +np.float32,0xff4ba4df,0x4173c01f,4 +np.float32,0x3f43d944,0x3f75c7bd,4 +np.float32,0xff6a9106,0x40a10eff,4 +np.float32,0x3bc8341c,0x3bc834bf,4 +np.float32,0x3eea82,0x3eea82,4 +np.float32,0xfea36a3c,0x435729b2,4 +np.float32,0x7dcc1fb0,0x3e330053,4 +np.float32,0x3f616ae6,0x3f9b01ae,4 +np.float32,0x8030963f,0x8030963f,4 +np.float32,0x10d1e2,0x10d1e2,4 +np.float32,0xfeb9a8a6,0x40e6daac,4 +np.float32,0xbe1aba00,0xbe1bea3a,4 +np.float32,0x3cb6b4ea,0x3cb6bcac,4 +np.float32,0x3d8b0b64,0x3d8b422f,4 +np.float32,0x7b6894,0x7b6894,4 +np.float32,0x3e89dcde,0x3e8d4b4b,4 +np.float32,0x3f12b952,0x3f253974,4 +np.float32,0x1c316c,0x1c316c,4 +np.float32,0x7e2da535,0x3f95fe6b,4 +np.float32,0x3ae9a494,0x3ae9a4a4,4 +np.float32,0xbc5f5500,0xbc5f588b,4 +np.float32,0x3e7850fc,0x3e7d4d0e,4 +np.float32,0xbf800000,0xbfc75923,4 +np.float32,0x3e652d69,0x3e691502,4 +np.float32,0xbf6bdd26,0xbfa89129,4 +np.float32,0x3f441cfc,0x3f764a02,4 +np.float32,0x7f5445ff,0xc0906191,4 +np.float32,0x807b2ee3,0x807b2ee3,4 +np.float32,0xbeb6cab8,0xbebef9c0,4 +np.float32,0xff737277,0xbf327011,4 +np.float32,0xfc832aa0,0x402fd52e,4 +np.float32,0xbf0c7538,0xbf1c7c0f,4 +np.float32,0x7e1301c7,0xbf0ee63e,4 +np.float64,0xbfe0ef7df7a1defc,0xbfe2b76a8d8aeb35,1 +np.float64,0x7fdd9c2eae3b385c,0xbfc00d6885485039,1 +np.float64,0xbfb484c710290990,0xbfb4900e0a527555,1 +np.float64,0x7fe73e5d6cee7cba,0x3fefbf70a56b60d3,1 +np.float64,0x800a110aa8d42216,0x800a110aa8d42216,1 +np.float64,0xffedd4f3f3bba9e7,0xbff076f8c4124919,1 +np.float64,0x800093407f812682,0x800093407f812682,1 +np.float64,0x800a23150e54462a,0x800a23150e54462a,1 +np.float64,0xbfb1076864220ed0,0xbfb10dd95a74b733,1 +np.float64,0x3fed1f8b37fa3f16,0x3ff496100985211f,1 +np.float64,0x3fdf762f84beec5f,0x3fe1223eb04a17e0,1 +np.float64,0x53fd4e0aa7faa,0x53fd4e0aa7faa,1 +np.float64,0x3fdbd283bdb7a507,0x3fddb7ec9856a546,1 +np.float64,0xbfe43f449d687e89,0xbfe77724a0d3072b,1 +np.float64,0x618b73bcc316f,0x618b73bcc316f,1 +np.float64,0x67759424ceeb3,0x67759424ceeb3,1 +np.float64,0xbfe4b6f7d9a96df0,0xbfe831371f3bd7a8,1 +np.float64,0x800a531b8b74a637,0x800a531b8b74a637,1 +np.float64,0xffeeffd5c37dffab,0x3fea140cbc2c3726,1 +np.float64,0x3fe648e2002c91c4,0x3feac1b8816f972a,1 +np.float64,0x800f16242a1e2c48,0x800f16242a1e2c48,1 +np.float64,0xffeeff8e1dbdff1b,0xc000b555f117dce7,1 +np.float64,0x3fdf1cf73fbe39f0,0x3fe0e9032401135b,1 +np.float64,0x7fe19c388b633870,0x3fd5271b69317d5b,1 +np.float64,0x918f226d231e5,0x918f226d231e5,1 +np.float64,0x4cc19ab499834,0x4cc19ab499834,1 +np.float64,0xbd3121d57a624,0xbd3121d57a624,1 +np.float64,0xbfd145d334a28ba6,0xbfd1b468866124d6,1 +np.float64,0x8bdbf41517b7f,0x8bdbf41517b7f,1 +np.float64,0x3fd1b8cb3ea37198,0x3fd2306b13396cae,1 +np.float64,0xbfd632a959ac6552,0xbfd7220fcfb5ef78,1 +np.float64,0x1cdaafc639b57,0x1cdaafc639b57,1 +np.float64,0x3febdcce1577b99c,0x3ff2fe076195a2bc,1 +np.float64,0x7fca6e945934dd28,0x3ff43040df7024e8,1 +np.float64,0x3fbe08e78e3c11cf,0x3fbe2c60e6b48f75,1 +np.float64,0x7fc1ed0d0523da19,0x3ff55f8dcad9440f,1 +np.float64,0xbfdc729b8cb8e538,0xbfde7b6e15dd60c4,1 +np.float64,0x3fd219404f243281,0x3fd298d7b3546531,1 +np.float64,0x3fe715c3f56e2b88,0x3fec255b5a59456e,1 +np.float64,0x7fe8b88e74b1711c,0x3ff60efd2c81d13d,1 +np.float64,0xa1d2b9fd43a57,0xa1d2b9fd43a57,1 +np.float64,0xffc1818223230304,0xbfb85c6c1e8018e7,1 +np.float64,0x3fde38ac8b3c7159,0x3fe0580c7e228576,1 +np.float64,0x8008faf7b491f5f0,0x8008faf7b491f5f0,1 +np.float64,0xffe7a1d751af43ae,0xbf7114cd7bbcd981,1 +np.float64,0xffec2db1b4b85b62,0xbff5cae759667f83,1 +np.float64,0x7fefce1ae27f9c35,0x3ff4b8b88f4876cf,1 +np.float64,0x7fd1ff56a523feac,0xbff342ce192f14dd,1 +np.float64,0x80026b3e3f84d67d,0x80026b3e3f84d67d,1 +np.float64,0xffedee5879bbdcb0,0xc02fae11508b2be0,1 +np.float64,0x8003c0dc822781ba,0x8003c0dc822781ba,1 +np.float64,0xffe38a79eca714f4,0xc008aa23b7a63980,1 +np.float64,0xbfda70411eb4e082,0xbfdc0d7e29c89010,1 +np.float64,0x800a5e34f574bc6a,0x800a5e34f574bc6a,1 +np.float64,0x3fc19fac6e233f59,0x3fc1bc66ac0d73d4,1 +np.float64,0x3a8a61ea7514d,0x3a8a61ea7514d,1 +np.float64,0x3fb57b536e2af6a0,0x3fb588451f72f44c,1 +np.float64,0x7fd68c6d082d18d9,0xc032ac926b665c9a,1 +np.float64,0xd5b87cfdab710,0xd5b87cfdab710,1 +np.float64,0xfe80b20bfd017,0xfe80b20bfd017,1 +np.float64,0x3fef8781e37f0f04,0x3ff8215fe2c1315a,1 +np.float64,0xffedddbb9c3bbb76,0x3fd959b82258a32a,1 +np.float64,0x3fc7d41f382fa83e,0x3fc81b94c3a091ba,1 +np.float64,0xffc3275dcf264ebc,0x3fb2b3d4985c6078,1 +np.float64,0x7fe34d2b7ba69a56,0x40001f3618e3c7c9,1 +np.float64,0x3fd64ae35fac95c7,0x3fd73d77e0b730f8,1 +np.float64,0x800e53bf6b3ca77f,0x800e53bf6b3ca77f,1 +np.float64,0xbfddf7c9083bef92,0xbfe02f392744d2d1,1 +np.float64,0x1c237cc038471,0x1c237cc038471,1 +np.float64,0x3fe4172beea82e58,0x3fe739b4bf16bc7e,1 +np.float64,0xfa950523f52a1,0xfa950523f52a1,1 +np.float64,0xffc839a2c5307344,0xbff70ff8a3c9247f,1 +np.float64,0x264f828c4c9f1,0x264f828c4c9f1,1 +np.float64,0x148a650a2914e,0x148a650a2914e,1 +np.float64,0x3fe8d255c0b1a4ac,0x3fef623c3ea8d6e3,1 +np.float64,0x800f4fbb28be9f76,0x800f4fbb28be9f76,1 +np.float64,0x7fdca57bcfb94af7,0x3ff51207563fb6cb,1 +np.float64,0x3fe4944107692882,0x3fe7fad593235364,1 +np.float64,0x800119b4f1a2336b,0x800119b4f1a2336b,1 +np.float64,0xbfe734075e6e680e,0xbfec5b35381069f2,1 +np.float64,0xffeb3c00db767801,0xbfbbd7d22df7b4b3,1 +np.float64,0xbfe95c658cb2b8cb,0xbff03ad5e0bc888a,1 +np.float64,0xffeefeb58fbdfd6a,0xbfd5c9264deb0e11,1 +np.float64,0x7fccc80fde39901f,0xc012c60f914f3ca2,1 +np.float64,0x3fe5da289c2bb451,0x3fea07ad00a0ca63,1 +np.float64,0x800e364b0a5c6c96,0x800e364b0a5c6c96,1 +np.float64,0x3fcf9ea7d23f3d50,0x3fd023b72e8c9dcf,1 +np.float64,0x800a475cfc948eba,0x800a475cfc948eba,1 +np.float64,0xffd4e0d757a9c1ae,0xbfa89d573352e011,1 +np.float64,0xbfd4dbec8229b7da,0xbfd5a165f12c7c40,1 +np.float64,0xffe307ab51260f56,0x3fe6b1639da58c3f,1 +np.float64,0xbfe6955a546d2ab4,0xbfeb44ae2183fee9,1 +np.float64,0xbfca1f18f5343e30,0xbfca7d804ccccdf4,1 +np.float64,0xe9f4dfebd3e9c,0xe9f4dfebd3e9c,1 +np.float64,0xfff0000000000000,0xfff8000000000000,1 +np.float64,0x8008e69c0fb1cd38,0x8008e69c0fb1cd38,1 +np.float64,0xbfead1ccf975a39a,0xbff1c84b3db8ca93,1 +np.float64,0x25a982424b531,0x25a982424b531,1 +np.float64,0x8010000000000000,0x8010000000000000,1 +np.float64,0x80056204ea0ac40b,0x80056204ea0ac40b,1 +np.float64,0x800d1442d07a2886,0x800d1442d07a2886,1 +np.float64,0xbfaef3dadc3de7b0,0xbfaefd85ae6205f0,1 +np.float64,0x7fe969ce4b32d39c,0xbff3c4364fc6778f,1 +np.float64,0x7fe418bac0a83175,0x402167d16b1efe0b,1 +np.float64,0x3fd7c82a25af9054,0x3fd8f0c701315672,1 +np.float64,0x80013782a7826f06,0x80013782a7826f06,1 +np.float64,0x7fc031c7ee20638f,0x400747ab705e6904,1 +np.float64,0x3fe8cf327ff19e65,0x3fef5c14f8aafa89,1 +np.float64,0xbfe331a416a66348,0xbfe5e2290a098dd4,1 +np.float64,0x800607b2116c0f65,0x800607b2116c0f65,1 +np.float64,0x7fb40448f0280891,0xbfd43d4f0ffa1d64,1 +np.float64,0x7fefffffffffffff,0xbf74530cfe729484,1 +np.float64,0x3fe39b5444a736a9,0x3fe67eaa0b6acf27,1 +np.float64,0x3fee4733c4fc8e68,0x3ff631eabeef9696,1 +np.float64,0xbfec840f3b79081e,0xbff3cc8563ab2e74,1 +np.float64,0xbfc8f6854c31ed0c,0xbfc948caacb3bba0,1 +np.float64,0xffbcf754a639eea8,0xbfc88d17cad3992b,1 +np.float64,0x8000bd3163417a64,0x8000bd3163417a64,1 +np.float64,0x3fe766d0eaeecda2,0x3fecb660882f7024,1 +np.float64,0xb6cc30156d986,0xb6cc30156d986,1 +np.float64,0xffc0161f9f202c40,0x3fe19bdefe5cf8b1,1 +np.float64,0xffe1e462caa3c8c5,0x3fe392c47feea17b,1 +np.float64,0x30a36a566146e,0x30a36a566146e,1 +np.float64,0x3fa996f580332deb,0x3fa99c6b4f2abebe,1 +np.float64,0x3fba71716e34e2e0,0x3fba899f35edba1d,1 +np.float64,0xbfe8f7e5e971efcc,0xbfefac431a0e3d55,1 +np.float64,0xf48f1803e91e3,0xf48f1803e91e3,1 +np.float64,0x7fe3edc0a127db80,0xc03d1a579a5d74a8,1 +np.float64,0xffeba82056375040,0x3fdfd701308700db,1 +np.float64,0xbfeb5a924cf6b524,0xbff2640de7cd107f,1 +np.float64,0xfa4cd1a9f499a,0xfa4cd1a9f499a,1 +np.float64,0x800de1be7b9bc37d,0x800de1be7b9bc37d,1 +np.float64,0xffd44e56ad289cae,0x3fdf4b8085db9b67,1 +np.float64,0xbfe4fb3aea69f676,0xbfe89d2cc46fcc50,1 +np.float64,0xbfe596495d6b2c92,0xbfe997a589a1f632,1 +np.float64,0x6f55a2b8deab5,0x6f55a2b8deab5,1 +np.float64,0x7fe72dc4712e5b88,0x4039c4586b28c2bc,1 +np.float64,0x89348bd712692,0x89348bd712692,1 +np.float64,0xffe062156120c42a,0x4005f0580973bc77,1 +np.float64,0xbfeabc714d7578e2,0xbff1b07e2fa57dc0,1 +np.float64,0x8003a56b3e874ad7,0x8003a56b3e874ad7,1 +np.float64,0x800eeadfb85dd5c0,0x800eeadfb85dd5c0,1 +np.float64,0x46d77a4c8daf0,0x46d77a4c8daf0,1 +np.float64,0x8000c06e7dc180de,0x8000c06e7dc180de,1 +np.float64,0x3fe428d211e851a4,0x3fe754b1c00a89bc,1 +np.float64,0xc5be11818b7c2,0xc5be11818b7c2,1 +np.float64,0x7fefc244893f8488,0x401133dc54f52de5,1 +np.float64,0x3fde30eee93c61de,0x3fe0532b827543a6,1 +np.float64,0xbfd447f48b288fea,0xbfd4fd0654f90718,1 +np.float64,0xbfde98dc7b3d31b8,0xbfe094df12f84a06,1 +np.float64,0x3fed2c1a1dfa5834,0x3ff4a6c4f3470a65,1 +np.float64,0xbfe992165073242d,0xbff071ab039c9177,1 +np.float64,0x3fd0145d1b2028ba,0x3fd06d3867b703dc,1 +np.float64,0x3fe179457362f28b,0x3fe3722f1d045fda,1 +np.float64,0x800e28964fbc512d,0x800e28964fbc512d,1 +np.float64,0x8004a5d785294bb0,0x8004a5d785294bb0,1 +np.float64,0xbfd652f2272ca5e4,0xbfd7469713125120,1 +np.float64,0x7fe61f49036c3e91,0xbf9b6ccdf2d87e70,1 +np.float64,0xffb7d47dd02fa8f8,0xc004449a82320b13,1 +np.float64,0x3feb82f996b705f3,0x3ff29336c738a4c5,1 +np.float64,0x3fbb7fceea36ffa0,0x3fbb9b02c8ad7f93,1 +np.float64,0x80004519fb208a35,0x80004519fb208a35,1 +np.float64,0xbfe0539114e0a722,0xbfe1e86dc5aa039c,1 +np.float64,0x0,0x0,1 +np.float64,0xbfe99d1125f33a22,0xbff07cf8ec04300f,1 +np.float64,0xffd4fbeecc29f7de,0x3ffab76775a8455f,1 +np.float64,0xbfbf1c618e3e38c0,0xbfbf43d2764a8333,1 +np.float64,0x800cae02a9d95c06,0x800cae02a9d95c06,1 +np.float64,0x3febc47d3bf788fa,0x3ff2e0d7cf8ef509,1 +np.float64,0x3fef838f767f071f,0x3ff81aeac309bca0,1 +np.float64,0xbfd5e70716abce0e,0xbfd6ccb033ef7a35,1 +np.float64,0x3f9116fa60222df5,0x3f9117625f008e0b,1 +np.float64,0xffe02b1e5f20563c,0xbfe6b2ec293520b7,1 +np.float64,0xbf9b5aec3036b5e0,0xbf9b5c96c4c7f951,1 +np.float64,0xfdb0169bfb603,0xfdb0169bfb603,1 +np.float64,0x7fcdd1d51c3ba3a9,0x401f0e12fa0b7570,1 +np.float64,0xbfd088103fa11020,0xbfd0e8c4a333ffb2,1 +np.float64,0x3fe22df82ee45bf0,0x3fe46d03a7c14de2,1 +np.float64,0xbfd57b0c28aaf618,0xbfd65349a6191de5,1 +np.float64,0x3fe0a42f50a1485f,0x3fe252e26775d9a4,1 +np.float64,0x800fab4e363f569c,0x800fab4e363f569c,1 +np.float64,0xffe9f0ed63f3e1da,0xbfe278c341b171d5,1 +np.float64,0x7fe26c244664d848,0xbfb325269dad1996,1 +np.float64,0xffe830410bf06081,0xc00181a39f606e96,1 +np.float64,0x800c548a0c78a914,0x800c548a0c78a914,1 +np.float64,0x800f94761ebf28ec,0x800f94761ebf28ec,1 +np.float64,0x3fe5984845eb3091,0x3fe99aeb653c666d,1 +np.float64,0x7fe93e5bf8f27cb7,0xc010d159fa27396a,1 +np.float64,0xffefffffffffffff,0x3f74530cfe729484,1 +np.float64,0x4c83f1269907f,0x4c83f1269907f,1 +np.float64,0x3fde0065a8bc00cc,0x3fe034a1cdf026d4,1 +np.float64,0x800743810d6e8703,0x800743810d6e8703,1 +np.float64,0x80040662d5280cc6,0x80040662d5280cc6,1 +np.float64,0x3fed20b2c5ba4166,0x3ff497988519d7aa,1 +np.float64,0xffe8fa15e5f1f42b,0x3fff82ca76d797b4,1 +np.float64,0xbb72e22f76e5d,0xbb72e22f76e5d,1 +np.float64,0x7fc18ffa7c231ff4,0xbff4b8b4c3315026,1 +np.float64,0xbfe8d1ac44f1a358,0xbfef60efc4f821e3,1 +np.float64,0x3fd38c1fe8271840,0x3fd42dc37ff7262b,1 +np.float64,0xe577bee5caef8,0xe577bee5caef8,1 +np.float64,0xbff0000000000000,0xbff8eb245cbee3a6,1 +np.float64,0xffcb3a9dd436753c,0x3fcd1a3aff1c3fc7,1 +np.float64,0x7fe44bf2172897e3,0x3ff60bfe82a379f4,1 +np.float64,0x8009203823924071,0x8009203823924071,1 +np.float64,0x7fef8e0abc7f1c14,0x3fe90e4962d47ce5,1 +np.float64,0xffda50004434a000,0x3fb50dee03e1418b,1 +np.float64,0x7fe2ff276ea5fe4e,0xc0355b7d2a0a8d9d,1 +np.float64,0x3fd0711ba5a0e238,0x3fd0d03823d2d259,1 +np.float64,0xe7625b03cec4c,0xe7625b03cec4c,1 +np.float64,0xbfd492c8d7a92592,0xbfd55006cde8d300,1 +np.float64,0x8001fee99f23fdd4,0x8001fee99f23fdd4,1 +np.float64,0x7ff4000000000000,0x7ffc000000000000,1 +np.float64,0xfa15df97f42bc,0xfa15df97f42bc,1 +np.float64,0xbfec3fdca9787fb9,0xbff377164b13c7a9,1 +np.float64,0xbcec10e579d82,0xbcec10e579d82,1 +np.float64,0xbfc3b4e2132769c4,0xbfc3dd1fcc7150a6,1 +np.float64,0x80045b149ee8b62a,0x80045b149ee8b62a,1 +np.float64,0xffe044554c2088aa,0xbff741436d558785,1 +np.float64,0xffcc65f09f38cbe0,0xc0172b4adc2d317d,1 +np.float64,0xf68b2d3bed166,0xf68b2d3bed166,1 +np.float64,0x7fc7f44c572fe898,0x3fec69f3b1eca790,1 +np.float64,0x3fac51f61438a3ec,0x3fac595d34156002,1 +np.float64,0xbfeaa9f256f553e5,0xbff19bfdf5984326,1 +np.float64,0x800e4742149c8e84,0x800e4742149c8e84,1 +np.float64,0xbfc493df132927c0,0xbfc4c1ba4268ead9,1 +np.float64,0xbfbf0c56383e18b0,0xbfbf3389fcf50c72,1 +np.float64,0xbf978a0e082f1420,0xbf978b1dd1da3d3c,1 +np.float64,0xbfe04375356086ea,0xbfe1d34c57314dd1,1 +np.float64,0x3feaeeb29b75dd65,0x3ff1e8b772374979,1 +np.float64,0xbfe15e42c3a2bc86,0xbfe34d45d56c5c15,1 +np.float64,0x3fe507429a6a0e85,0x3fe8b058176b3225,1 +np.float64,0x3feee2b26c3dc565,0x3ff71b73203de921,1 +np.float64,0xbfd496577aa92cae,0xbfd553fa7fe15a5f,1 +np.float64,0x7fe2c10953e58212,0x3fc8ead6a0d14bbf,1 +np.float64,0x800035b77aa06b70,0x800035b77aa06b70,1 +np.float64,0x2329201e46525,0x2329201e46525,1 +np.float64,0xbfe6225c9a6c44b9,0xbfea80861590fa02,1 +np.float64,0xbfd6925030ad24a0,0xbfd78e70b1c2215d,1 +np.float64,0xbfd82225c4b0444c,0xbfd958a60f845b39,1 +np.float64,0xbb03d8a17609,0xbb03d8a17609,1 +np.float64,0x7fc33967b12672ce,0x40001e00c9af4002,1 +np.float64,0xff9373c6d026e780,0xbff308654a459d3d,1 +np.float64,0x3feab1f9c5f563f4,0x3ff1a4e0fd2f093d,1 +np.float64,0xbf993ef768327de0,0xbf994046b64e308b,1 +np.float64,0xffb87382fc30e708,0xbfde0accb83c891b,1 +np.float64,0x800bb3a118176743,0x800bb3a118176743,1 +np.float64,0x800c810250d90205,0x800c810250d90205,1 +np.float64,0xbfd2c4eb9ba589d8,0xbfd3539508b4a4a8,1 +np.float64,0xbee1f5437dc3f,0xbee1f5437dc3f,1 +np.float64,0x3fc07aeab520f5d8,0x3fc0926272f9d8e2,1 +np.float64,0xbfe23747a3246e90,0xbfe47a20a6e98687,1 +np.float64,0x3fde1296debc252c,0x3fe0401143ff6b5c,1 +np.float64,0xbfcec8c2f73d9184,0xbfcf644e25ed3b74,1 +np.float64,0xff9314f2c82629e0,0x40559a0f9099dfd1,1 +np.float64,0xbfe27487afa4e910,0xbfe4d0e01200bde6,1 +np.float64,0xffb3d6637627acc8,0x3fe326d4b1e1834f,1 +np.float64,0xffe6f84d642df09a,0x3fc73fa9f57c3acb,1 +np.float64,0xffe67cf76fecf9ee,0xc01cf48c97937ef9,1 +np.float64,0x7fdc73fc12b8e7f7,0xbfcfcecde9331104,1 +np.float64,0xffdcf8789239f0f2,0x3fe345e3b8e28776,1 +np.float64,0x800a70af5314e15f,0x800a70af5314e15f,1 +np.float64,0xffc862300730c460,0x3fc4e9ea813beca7,1 +np.float64,0xbfcc6961bd38d2c4,0xbfcce33bfa6c6bd1,1 +np.float64,0xbfc9b76bbf336ed8,0xbfca117456ac37e5,1 +np.float64,0x7fb86e829430dd04,0x400a5bd7a18e302d,1 +np.float64,0x7fb9813ef833027d,0xbfe5a6494f143625,1 +np.float64,0x8005085e2c2a10bd,0x8005085e2c2a10bd,1 +np.float64,0xffe5af099d6b5e12,0x40369bbe31e03e06,1 +np.float64,0xffde03b1fd3c0764,0x3ff061120aa1f52a,1 +np.float64,0x7fa4eb6cdc29d6d9,0x3fe9defbe9010322,1 +np.float64,0x800803f4b11007ea,0x800803f4b11007ea,1 +np.float64,0x7febd50f6df7aa1e,0xbffcf540ccf220dd,1 +np.float64,0x7fed454f08fa8a9d,0xbffc2a8b81079403,1 +np.float64,0xbfed7e8c69bafd19,0xbff5161e51ba6634,1 +np.float64,0xffef92e78eff25ce,0xbffefeecddae0ad3,1 +np.float64,0x7fe5b9b413ab7367,0xbfc681ba29704176,1 +np.float64,0x29284e805252,0x29284e805252,1 +np.float64,0xffed3955bcfa72ab,0xbfc695acb5f468de,1 +np.float64,0x3fe464ee1ca8c9dc,0x3fe7b140ce50fdca,1 +np.float64,0xffe522ae4bea455c,0x3feb957c146e66ef,1 +np.float64,0x8000000000000000,0x8000000000000000,1 +np.float64,0x3fd0c353a2a186a8,0x3fd1283aaa43a411,1 +np.float64,0x3fdb30a749b6614f,0x3fdcf40df006ed10,1 +np.float64,0x800109213cc21243,0x800109213cc21243,1 +np.float64,0xbfe72aa0c5ee5542,0xbfec4a713f513bc5,1 +np.float64,0x800865344ad0ca69,0x800865344ad0ca69,1 +np.float64,0x7feb7df60eb6fbeb,0x3fb1df06a67aa22f,1 +np.float64,0x3fe83a5dd93074bc,0x3fee3d63cda72636,1 +np.float64,0xbfde70e548bce1ca,0xbfe07b8e19c9dac6,1 +np.float64,0xbfeea38d537d471b,0xbff6bb18c230c0be,1 +np.float64,0x3fefeebbc47fdd78,0x3ff8cdaa53b7c7b4,1 +np.float64,0x7fe6512e20eca25b,0xbff623cee44a22b5,1 +np.float64,0xf8fa5ca3f1f4c,0xf8fa5ca3f1f4c,1 +np.float64,0x7fd12d00ed225a01,0xbfe90d518ea61faf,1 +np.float64,0x80027db43504fb69,0x80027db43504fb69,1 +np.float64,0xffc10a01aa221404,0x3fcc2065b3d0157b,1 +np.float64,0xbfef8286e87f050e,0xbff8193a54449b59,1 +np.float64,0xbfc73178092e62f0,0xbfc7735072ba4593,1 +np.float64,0x3fc859d70630b3ae,0x3fc8a626522af1c0,1 +np.float64,0x3fe4654c4268ca99,0x3fe7b1d2913eda1a,1 +np.float64,0xbfce93cd843d279c,0xbfcf2c2ef16a0957,1 +np.float64,0xffbcaa16d4395430,0xbfd511ced032d784,1 +np.float64,0xbfe91f980e723f30,0xbfeffb39cf8c7746,1 +np.float64,0x800556fb6f0aadf8,0x800556fb6f0aadf8,1 +np.float64,0xffd009cde520139c,0x3fe4fa83b1e93d28,1 +np.float64,0x7febc0675e3780ce,0x3feb53930c004dae,1 +np.float64,0xbfe7f975bdeff2ec,0xbfedc36e6729b010,1 +np.float64,0x45aff57c8b5ff,0x45aff57c8b5ff,1 +np.float64,0xbfec7ebd0138fd7a,0xbff3c5cab680aae0,1 +np.float64,0x8009448003b28900,0x8009448003b28900,1 +np.float64,0x3fca4b992d349732,0x3fcaabebcc86aa9c,1 +np.float64,0x3fca069161340d20,0x3fca63ecc742ff3a,1 +np.float64,0x80063bc80bec7791,0x80063bc80bec7791,1 +np.float64,0xbfe1764bffe2ec98,0xbfe36e1cb30cec94,1 +np.float64,0xffd0dba72f21b74e,0x3fb1834964d57ef6,1 +np.float64,0xbfe31848fc263092,0xbfe5bd066445cbc3,1 +np.float64,0xbfd1fb227323f644,0xbfd278334e27f02d,1 +np.float64,0xffdc59069fb8b20e,0xbfdfc363f559ea2c,1 +np.float64,0x3fdea52a52bd4a55,0x3fe09cada4e5344c,1 +np.float64,0x3f715e55a022bd00,0x3f715e5c72a2809e,1 +np.float64,0x1d1ac6023a35a,0x1d1ac6023a35a,1 +np.float64,0x7feacc71627598e2,0x400486b82121da19,1 +np.float64,0xa0287fa340510,0xa0287fa340510,1 +np.float64,0xffe352c5abe6a58b,0xc002623346060543,1 +np.float64,0x7fed577a23baaef3,0x3fda19bc8fa3b21f,1 +np.float64,0x3fde8dd5263d1baa,0x3fe08de0fedf7029,1 +np.float64,0x3feddd3be2bbba78,0x3ff599b2f3e018cc,1 +np.float64,0xc7a009f58f401,0xc7a009f58f401,1 +np.float64,0xbfef03d5a4fe07ab,0xbff74ee08681f47b,1 +np.float64,0x7fe2cf60eea59ec1,0x3fe905fb44f8cc60,1 +np.float64,0xbfe498fcab6931fa,0xbfe8023a6ff8becf,1 +np.float64,0xbfef7142acfee285,0xbff7fd196133a595,1 +np.float64,0xd214ffdba42a0,0xd214ffdba42a0,1 +np.float64,0x8006de7d78cdbcfc,0x8006de7d78cdbcfc,1 +np.float64,0xb247d34f648fb,0xb247d34f648fb,1 +np.float64,0xbfdd5bece6bab7da,0xbfdf9ba63ca2c5b2,1 +np.float64,0x7fe874650af0e8c9,0x3fe74204e122c10f,1 +np.float64,0x800768c49baed18a,0x800768c49baed18a,1 +np.float64,0x3fb4c0a192298140,0x3fb4cc4c8aa43300,1 +np.float64,0xbfa740531c2e80a0,0xbfa7446b7c74ae8e,1 +np.float64,0x7fe10d6edf221add,0x3fedbcd2eae26657,1 +np.float64,0xbfe9175d0f722eba,0xbfefeaca7f32c6e3,1 +np.float64,0x953e11d32a7c2,0x953e11d32a7c2,1 +np.float64,0x80032df90c465bf3,0x80032df90c465bf3,1 +np.float64,0xffec5b799638b6f2,0xbfe95cd2c69be12c,1 +np.float64,0xffe0c3cfa9a1879f,0x3fe20b99b0c108ce,1 +np.float64,0x3fb610d8e22c21b2,0x3fb61ee0d6c16df8,1 +np.float64,0xffe16bb39962d766,0xc016d370381b6b42,1 +np.float64,0xbfdc72edb238e5dc,0xbfde7bd2de10717a,1 +np.float64,0xffed52dee3baa5bd,0xc01994c08899129a,1 +np.float64,0xffa92aab08325550,0xbff2b881ce363cbd,1 +np.float64,0x7fe028282de0504f,0xc0157ff96c69a9c7,1 +np.float64,0xbfdb2151bf3642a4,0xbfdce196fcc35857,1 +np.float64,0x3fcffbd13c3ff7a2,0x3fd0554b5f0371ac,1 +np.float64,0x800d206bff1a40d8,0x800d206bff1a40d8,1 +np.float64,0x458f818c8b1f1,0x458f818c8b1f1,1 +np.float64,0x800a7b56a234f6ae,0x800a7b56a234f6ae,1 +np.float64,0xffe3d86161e7b0c2,0xbff58d0dbde9f188,1 +np.float64,0xe8ed82e3d1db1,0xe8ed82e3d1db1,1 +np.float64,0x3fe234e0176469c0,0x3fe476bd36b96a75,1 +np.float64,0xbfc7cb9c132f9738,0xbfc812c46e185e0b,1 +np.float64,0xbfeba116c1f7422e,0xbff2b6b7563ad854,1 +np.float64,0x7fe7041de62e083b,0x3f5d2b42aca47274,1 +np.float64,0xbfcf60f4ff3ec1e8,0xbfd002eb83406436,1 +np.float64,0xbfc06067a520c0d0,0xbfc0776e5839ecda,1 +np.float64,0x4384965a87093,0x4384965a87093,1 +np.float64,0xd2ed9d01a5db4,0xd2ed9d01a5db4,1 +np.float64,0x3fbea88cb63d5119,0x3fbece49cc34a379,1 +np.float64,0x3fe7e982ebefd306,0x3feda5bd4c435d43,1 +np.float64,0xffdb60a3e036c148,0xbfcb7ed21e7a8f49,1 +np.float64,0x7fdba9231eb75245,0xbfd750cab1536398,1 +np.float64,0x800d593534dab26b,0x800d593534dab26b,1 +np.float64,0xffdf15fb683e2bf6,0x3fb3aaea23357f06,1 +np.float64,0xbfd6f8a2e5adf146,0xbfd802e509d67c67,1 +np.float64,0x3feeaa31513d5463,0x3ff6c52147dc053c,1 +np.float64,0xf2f6dfd3e5edc,0xf2f6dfd3e5edc,1 +np.float64,0x7fd58d8279ab1b04,0x403243f23d02af2a,1 +np.float64,0x8000000000000001,0x8000000000000001,1 +np.float64,0x3fdffb8e0ebff71c,0x3fe1786cb0a6b0f3,1 +np.float64,0xc999826b93331,0xc999826b93331,1 +np.float64,0xffc4966f19292ce0,0x3ff0836c75c56cc7,1 +np.float64,0x7fef95a4b2ff2b48,0xbfbbe2c27c78154f,1 +np.float64,0xb8f1307f71e26,0xb8f1307f71e26,1 +np.float64,0x3fe807bc7eb00f79,0x3fedde19f2d3c42d,1 +np.float64,0x5e4b6580bc98,0x5e4b6580bc98,1 +np.float64,0xffe19353576326a6,0xc0278c51fee07d36,1 +np.float64,0xbfb0ca6f3e2194e0,0xbfb0d09be673fa72,1 +np.float64,0x3fea724211b4e484,0x3ff15ee06f0a0a13,1 +np.float64,0xbfda21e1c4b443c4,0xbfdbb041f3c86832,1 +np.float64,0x8008082b24901057,0x8008082b24901057,1 +np.float64,0xbfd031aa4ea06354,0xbfd08c77729634bb,1 +np.float64,0xbfc407e153280fc4,0xbfc432275711df5f,1 +np.float64,0xbb4fa4b5769f5,0xbb4fa4b5769f5,1 +np.float64,0x7fed6d1daffada3a,0xc037a14bc7b41fab,1 +np.float64,0xffeee589943dcb12,0x3ff2abfe47037778,1 +np.float64,0x301379d260270,0x301379d260270,1 +np.float64,0xbfec2fefc2b85fe0,0xbff36362c0363e06,1 +np.float64,0xbfe0b1c82e216390,0xbfe264f503f7c22c,1 +np.float64,0xbfea2bce78f4579d,0xbff112d6f07935ea,1 +np.float64,0x18508ef230a13,0x18508ef230a13,1 +np.float64,0x800667a74d6ccf4f,0x800667a74d6ccf4f,1 +np.float64,0x79ce5c8cf39cc,0x79ce5c8cf39cc,1 +np.float64,0x3feda61c8efb4c39,0x3ff54c9ade076f54,1 +np.float64,0x3fe27e06b0e4fc0d,0x3fe4de665c1dc3ca,1 +np.float64,0xbfd15fea2722bfd4,0xbfd1d081c55813b0,1 +np.float64,0xbfe5222c4cea4458,0xbfe8db62deb7d2ad,1 +np.float64,0xbfe8a16c33b142d8,0xbfef02d5831592a8,1 +np.float64,0x3fdb60e7c4b6c1d0,0x3fdd2e4265c4c3b6,1 +np.float64,0x800076d62b60edad,0x800076d62b60edad,1 +np.float64,0xbfec8f1527791e2a,0xbff3da7ed3641e8d,1 +np.float64,0x2af03bfe55e08,0x2af03bfe55e08,1 +np.float64,0xa862ee0950c5e,0xa862ee0950c5e,1 +np.float64,0x7fea5a7c1eb4b4f7,0xbffa6f07d28ef211,1 +np.float64,0x90e118fb21c23,0x90e118fb21c23,1 +np.float64,0xbfead0721bf5a0e4,0xbff1c6c7a771a128,1 +np.float64,0x3f63f4a4c027e94a,0x3f63f4a75665da67,1 +np.float64,0x3fece0efa579c1e0,0x3ff443bec52f021e,1 +np.float64,0xbfdbe743b737ce88,0xbfddd129bff89c15,1 +np.float64,0x3fd48c9b8fa91938,0x3fd5492a630a8cb5,1 +np.float64,0x3ff0000000000000,0x3ff8eb245cbee3a6,1 +np.float64,0xbfd51ea33baa3d46,0xbfd5ebd5dc710204,1 +np.float64,0x3fcfbab0183f7560,0x3fd032a054580b00,1 +np.float64,0x8007abce13cf579d,0x8007abce13cf579d,1 +np.float64,0xbfef0f4723be1e8e,0xbff760c7008e8913,1 +np.float64,0x8006340f524c681f,0x8006340f524c681f,1 +np.float64,0x87b7d7010f71,0x87b7d7010f71,1 +np.float64,0x3fe9422da9b2845b,0x3ff02052e6148c45,1 +np.float64,0x7fddd259b93ba4b2,0xc000731aa33d84b6,1 +np.float64,0x3fe0156d12202ada,0x3fe1972ba309cb29,1 +np.float64,0x8004f1264b89e24d,0x8004f1264b89e24d,1 +np.float64,0x3fececdcacb9d9b9,0x3ff4534d5861f731,1 +np.float64,0x3fd1790ab822f215,0x3fd1eb97b1bb6fb4,1 +np.float64,0xffce5d11863cba24,0xbfcb4f38c17210da,1 +np.float64,0x800a30c32a546187,0x800a30c32a546187,1 +np.float64,0x3fa58cc61c2b198c,0x3fa59008add7233e,1 +np.float64,0xbfe0ac77d62158f0,0xbfe25de3dba0bc4a,1 +np.float64,0xeb8c5753d718b,0xeb8c5753d718b,1 +np.float64,0x3fee5438dafca872,0x3ff644fef7e7adb5,1 +np.float64,0x3faad1eb2c35a3e0,0x3faad83499f94057,1 +np.float64,0x3fe39152c46722a6,0x3fe66fba0b96ab6e,1 +np.float64,0xffd6fd17712dfa2e,0xc010d697d1ab8731,1 +np.float64,0x5214a888a4296,0x5214a888a4296,1 +np.float64,0x8000127a5da024f5,0x8000127a5da024f5,1 +np.float64,0x7feb3a366cb6746c,0x3fbe49bd8d5f213a,1 +np.float64,0xca479501948f3,0xca479501948f3,1 +np.float64,0x7fe7c799ce6f8f33,0xbfd796cd98dc620c,1 +np.float64,0xffe20bcf30a4179e,0xbff8ca5453fa088f,1 +np.float64,0x3fe624638a6c48c7,0x3fea83f123832c3c,1 +np.float64,0xbfe5f1377c6be26f,0xbfea2e143a2d522c,1 +np.float64,0x7fd193f9f8a327f3,0xbfb04ee2602574d4,1 +np.float64,0xbfe7419d2fee833a,0xbfec737f140d363d,1 +np.float64,0x1,0x1,1 +np.float64,0x7fe2ac246c655848,0x3fd14fee3237727a,1 +np.float64,0xa459b42948b37,0xa459b42948b37,1 +np.float64,0x3fb26155ae24c2ab,0x3fb2696fc446d4c6,1 +np.float64,0xbfdd7b332e3af666,0xbfdfc296c21f1aa8,1 +np.float64,0xbfe00dbda4a01b7c,0xbfe18d2b060f0506,1 +np.float64,0x8003bb22d3e77646,0x8003bb22d3e77646,1 +np.float64,0x3fee21b0a57c4361,0x3ff5fb6a21dc911c,1 +np.float64,0x80ca69270194d,0x80ca69270194d,1 +np.float64,0xbfd6d80350adb006,0xbfd7ddb501edbde0,1 +np.float64,0xd2f8b801a5f2,0xd2f8b801a5f2,1 +np.float64,0xbfe856b3f170ad68,0xbfee7334fdc49296,1 +np.float64,0x3fed5c1b20bab836,0x3ff4e73ee5d5c7f3,1 +np.float64,0xbfd58085a5ab010c,0xbfd6596ddc381ffa,1 +np.float64,0x3fe4f0134b29e027,0x3fe88b70602fbd21,1 +np.float64,0xffc9098fdc321320,0x4011c334a74a92cf,1 +np.float64,0x794749bef28ea,0x794749bef28ea,1 +np.float64,0xbfc86b547f30d6a8,0xbfc8b84a4fafe0af,1 +np.float64,0x7fe1356b9da26ad6,0x3fd270bca208d899,1 +np.float64,0x7fca0ef1aa341de2,0xbff851044c0734fa,1 +np.float64,0x80064cb8b62c9972,0x80064cb8b62c9972,1 +np.float64,0xffd3a09a83a74136,0x3ffb66dae0accdf5,1 +np.float64,0x800e301aa15c6035,0x800e301aa15c6035,1 +np.float64,0x800e51f323bca3e6,0x800e51f323bca3e6,1 +np.float64,0x7ff0000000000000,0xfff8000000000000,1 +np.float64,0x800c4278c87884f2,0x800c4278c87884f2,1 +np.float64,0xbfe8481649f0902c,0xbfee576772695096,1 +np.float64,0xffe2344e3fa4689c,0x3fb10442ec0888de,1 +np.float64,0xbfeada313d75b462,0xbff1d1aee3fab3a9,1 +np.float64,0x8009ddfb1333bbf7,0x8009ddfb1333bbf7,1 +np.float64,0x7fed3314c93a6629,0x3ff7a9b12dc1cd37,1 +np.float64,0x3fd55c26da2ab84e,0x3fd630a7b8aac78a,1 +np.float64,0x800cdb5203f9b6a4,0x800cdb5203f9b6a4,1 +np.float64,0xffd04a875da0950e,0x4009a13810ab121d,1 +np.float64,0x800f1acb527e3597,0x800f1acb527e3597,1 +np.float64,0xbf9519bf282a3380,0xbf951a82e9b955ff,1 +np.float64,0x3fcd7a42fa3af486,0x3fce028f3c51072d,1 +np.float64,0xbfdd3e21b73a7c44,0xbfdf769f2ff2480b,1 +np.float64,0xffd4361e2aa86c3c,0xbfc211ce8e9f792c,1 +np.float64,0x7fccf97f6939f2fe,0xbff8464bad830f06,1 +np.float64,0x800ce47fb939c900,0x800ce47fb939c900,1 +np.float64,0xffe9e51df173ca3b,0xbfceaf990d652c4e,1 +np.float64,0x3fe05bba5b20b775,0x3fe1f326e4455442,1 +np.float64,0x800a29b4b134536a,0x800a29b4b134536a,1 +np.float64,0xe6f794b7cdef3,0xe6f794b7cdef3,1 +np.float64,0xffb5b688ce2b6d10,0x3ff924bb97ae2f6d,1 +np.float64,0x7fa74105d82e820b,0x3fd49643aaa9eee4,1 +np.float64,0x80020d15f7a41a2d,0x80020d15f7a41a2d,1 +np.float64,0x3fd6a983d5ad5308,0x3fd7a8cc8835b5b8,1 +np.float64,0x7fcd9798f03b2f31,0x3fc534c2f7bf4721,1 +np.float64,0xffdd31873a3a630e,0xbfe3171fcdffb3f7,1 +np.float64,0x80075183234ea307,0x80075183234ea307,1 +np.float64,0x82f3132505e63,0x82f3132505e63,1 +np.float64,0x3febfd9cb837fb39,0x3ff325bbf812515d,1 +np.float64,0xbfb4630fda28c620,0xbfb46e1f802ec278,1 +np.float64,0x3feeed7c89fddafa,0x3ff72c20ce5a9ee4,1 +np.float64,0x7fd3dcb3c127b967,0x40123d27ec9ec31d,1 +np.float64,0xbfe923450c72468a,0xbff00149c5742725,1 +np.float64,0x7fdef7f91abdeff1,0xbfe02ceb21f7923d,1 +np.float64,0x7fdd70d28fbae1a4,0xbfefcc5c9d10cdfd,1 +np.float64,0x800ca445a8d9488c,0x800ca445a8d9488c,1 +np.float64,0x7fec2754e1f84ea9,0x40173f6c1c97f825,1 +np.float64,0x7fcbca31f7379463,0x401e26bd2667075b,1 +np.float64,0x8003fa1d0847f43b,0x8003fa1d0847f43b,1 +np.float64,0xffe95cf85932b9f0,0xc01308e60278aa11,1 +np.float64,0x8009c53948f38a73,0x8009c53948f38a73,1 +np.float64,0x3fdcca9226b99524,0x3fdee7a008f75d41,1 +np.float64,0xbfe9ee241f33dc48,0xbff0d16bfff6c8e9,1 +np.float64,0xbfb3365058266ca0,0xbfb33f9176ebb51d,1 +np.float64,0x7fa98e10f4331c21,0x3fdee04ffd31314e,1 +np.float64,0xbfe1a11aea634236,0xbfe3a8e3d84fda38,1 +np.float64,0xbfd8df051131be0a,0xbfda342805d1948b,1 +np.float64,0x3d49a2407a935,0x3d49a2407a935,1 +np.float64,0xfc51eefff8a3e,0xfc51eefff8a3e,1 +np.float64,0xda63950bb4c73,0xda63950bb4c73,1 +np.float64,0x80050f3d4fea1e7b,0x80050f3d4fea1e7b,1 +np.float64,0x3fcdbd6e453b7ae0,0x3fce497478c28e77,1 +np.float64,0x7ebd4932fd7aa,0x7ebd4932fd7aa,1 +np.float64,0x7fa3904eac27209c,0xc0015f3125efc151,1 +np.float64,0x7fc59f956b2b3f2a,0xc00c012e7a2c281f,1 +np.float64,0xbfd436d716a86dae,0xbfd4ea13533a942b,1 +np.float64,0x9347ae3d268f6,0x9347ae3d268f6,1 +np.float64,0xffd001764d2002ec,0xbffab3462e515623,1 +np.float64,0x3fe6f406662de80d,0x3febe9bac3954999,1 +np.float64,0x3f943ecaf8287d96,0x3f943f77dee5e77f,1 +np.float64,0x3fd6250efcac4a1c,0x3fd712afa947d56f,1 +np.float64,0xbfe849ff777093ff,0xbfee5b089d03391f,1 +np.float64,0xffd3b8ef8f2771e0,0x4000463ff7f29214,1 +np.float64,0xbfc3bae9252775d4,0xbfc3e34c133f1933,1 +np.float64,0xbfea93943df52728,0xbff18355e4fc341d,1 +np.float64,0x3fc4d922ad29b245,0x3fc508d66869ef29,1 +np.float64,0x4329694a8652e,0x4329694a8652e,1 +np.float64,0x8834f1a71069e,0x8834f1a71069e,1 +np.float64,0xe0e5be8dc1cb8,0xe0e5be8dc1cb8,1 +np.float64,0x7fef4d103afe9a1f,0xc0047b88b94554fe,1 +np.float64,0x3fe9b57af4f36af6,0x3ff0963831d51c3f,1 +np.float64,0x3fe081e2fa6103c6,0x3fe22572e41be655,1 +np.float64,0x3fd78cf7b42f19ef,0x3fd8acafa1ad776a,1 +np.float64,0x7fbffd58d43ffab1,0x3fb16092c7de6036,1 +np.float64,0xbfe1e8bfae23d180,0xbfe40c1c6277dd52,1 +np.float64,0x800a9f59fb153eb4,0x800a9f59fb153eb4,1 +np.float64,0xffebe14e33b7c29c,0x3fe0ec532f4deedd,1 +np.float64,0xffc36ca00426d940,0xc000806a712d6e83,1 +np.float64,0xbfcc2be82d3857d0,0xbfcca2a7d372ec64,1 +np.float64,0x800c03b908780772,0x800c03b908780772,1 +np.float64,0xf315a64be62b5,0xf315a64be62b5,1 +np.float64,0xbfe644043cec8808,0xbfeab974d3dc6d80,1 +np.float64,0x3fedb7de3cbb6fbc,0x3ff56549a5acd324,1 +np.float64,0xbfb1a875522350e8,0xbfb1afa41dee338d,1 +np.float64,0xffee8d4a407d1a94,0x3fead1749a636ff6,1 +np.float64,0x8004061c13080c39,0x8004061c13080c39,1 +np.float64,0x3fe650ae7feca15c,0x3feacefb8bc25f64,1 +np.float64,0x3fda8340e6b50682,0x3fdc24275cab1df8,1 +np.float64,0x8009084344321087,0x8009084344321087,1 +np.float64,0x7fdd19cb823a3396,0xbfd1d8fb35d89e3f,1 +np.float64,0xbfe893172571262e,0xbfeee716b592b93c,1 +np.float64,0x8ff5acc11fec,0x8ff5acc11fec,1 +np.float64,0xbfdca0c57cb9418a,0xbfdeb42465a1b59e,1 +np.float64,0xffd77bd2a3aef7a6,0x4012cd69e85b82d8,1 +np.float64,0xbfe6ea78982dd4f1,0xbfebd8ec61fb9e1f,1 +np.float64,0x7fe14b1d80a2963a,0xc02241642102cf71,1 +np.float64,0x3fe712bf286e257e,0x3fec20012329a7fb,1 +np.float64,0x7fcb6fa4d636df49,0x400b899d14a886b3,1 +np.float64,0x3fb82cb39a305960,0x3fb83f29c5f0822e,1 +np.float64,0x7fed694c8b3ad298,0xbfe2724373c69808,1 +np.float64,0xbfcd21229f3a4244,0xbfcda497fc3e1245,1 +np.float64,0x564d3770ac9a8,0x564d3770ac9a8,1 +np.float64,0xf4409e13e8814,0xf4409e13e8814,1 +np.float64,0x80068dca9a8d1b96,0x80068dca9a8d1b96,1 +np.float64,0xbfe13f82afe27f06,0xbfe3236ddded353f,1 +np.float64,0x80023f8114647f03,0x80023f8114647f03,1 +np.float64,0xeafba7dfd5f75,0xeafba7dfd5f75,1 +np.float64,0x3feca74ddeb94e9c,0x3ff3f95dcce5a227,1 +np.float64,0x10000000000000,0x10000000000000,1 +np.float64,0xbfebdb4141f7b682,0xbff2fc29823ac64a,1 +np.float64,0xbfcd75ee2f3aebdc,0xbfcdfdfd87cc6a29,1 +np.float64,0x7fc010cda420219a,0x3fae4ca2cf1f2657,1 +np.float64,0x1a90209e35205,0x1a90209e35205,1 +np.float64,0x8008057d01900afa,0x8008057d01900afa,1 +np.float64,0x3f9cb5f280396be5,0x3f9cb7dfb4e4be4e,1 +np.float64,0xffe1bbb60b63776c,0xc00011b1ffcb2561,1 +np.float64,0xffda883f6fb5107e,0x4044238ef4e2a198,1 +np.float64,0x3fc07c0b4a20f817,0x3fc09387de9eebcf,1 +np.float64,0x8003a9ebc0c753d8,0x8003a9ebc0c753d8,1 +np.float64,0x1d7fd5923affc,0x1d7fd5923affc,1 +np.float64,0xbfe9cd8cf9b39b1a,0xbff0af43e567ba4a,1 +np.float64,0x11285cb42250c,0x11285cb42250c,1 +np.float64,0xffe81ae1ccb035c3,0xbfe038be7eb563a6,1 +np.float64,0xbfe56473b1eac8e8,0xbfe94654d8ab9e75,1 +np.float64,0x3fee904619fd208c,0x3ff69e198152fe17,1 +np.float64,0xbfeeb9a2cbfd7346,0xbff6dc8d96da78cd,1 +np.float64,0x8006cdfa59ed9bf5,0x8006cdfa59ed9bf5,1 +np.float64,0x8008f2366d31e46d,0x8008f2366d31e46d,1 +np.float64,0x8008d5f91e31abf3,0x8008d5f91e31abf3,1 +np.float64,0x3fe85886f8b0b10e,0x3fee76af16f5a126,1 +np.float64,0x3fefb9b2b73f7365,0x3ff8745128fa3e3b,1 +np.float64,0x7fdf3e721f3e7ce3,0xbfb19381541ca2a8,1 +np.float64,0x3fd2768c41a4ed18,0x3fd2fe2f85a3f3a6,1 +np.float64,0xbfcabe3c6a357c78,0xbfcb239fb88bc260,1 +np.float64,0xffdffb6a3dbff6d4,0xbff7af4759fd557c,1 +np.float64,0x800817f75f302fef,0x800817f75f302fef,1 +np.float64,0xbfe6a1d1762d43a3,0xbfeb5a399a095ef3,1 +np.float64,0x7fd6f32f912de65e,0x40016dedc51aabd0,1 +np.float64,0x3fc6cb26652d964d,0x3fc7099f047d924a,1 +np.float64,0x3fe8b975d67172ec,0x3fef31946123c0e7,1 +np.float64,0xffe44a09d1e89413,0x3fdee9e5eac6e540,1 +np.float64,0xbfece76d4cb9cedb,0xbff44c34849d07ba,1 +np.float64,0x7feb76027036ec04,0x3fe08595a5e263ac,1 +np.float64,0xffe194f591a329ea,0x3fbe5bd626400a70,1 +np.float64,0xbfc170698122e0d4,0xbfc18c3de8b63565,1 +np.float64,0x3fc82b2c0f305658,0x3fc875c3b5fbcd08,1 +np.float64,0x3fd5015634aa02ac,0x3fd5cb1df07213c3,1 +np.float64,0x7fe640884b6c8110,0xbff66255a420abb5,1 +np.float64,0x5a245206b448b,0x5a245206b448b,1 +np.float64,0xffe9d9fa2f73b3f4,0xc0272b0dd34ab9bf,1 +np.float64,0x3fd990e8aab321d0,0x3fdb04cd3a29bcc3,1 +np.float64,0xde9dda8bbd3bc,0xde9dda8bbd3bc,1 +np.float64,0xbfe81b32b4703666,0xbfee029937fa9f5a,1 +np.float64,0xbfe68116886d022d,0xbfeb21c62081cb73,1 +np.float64,0x3fb8da191231b432,0x3fb8ee28c71507d3,1 +np.float64,0x3fb111395a222273,0x3fb117b57de3dea4,1 +np.float64,0xffbafadc6a35f5b8,0x3ffcc6d2370297b9,1 +np.float64,0x8002ca475b05948f,0x8002ca475b05948f,1 +np.float64,0xbfeafef57875fdeb,0xbff1fb1315676f24,1 +np.float64,0x7fcda427d73b484f,0xbff9f70212694d17,1 +np.float64,0xffe2517b3ba4a2f6,0xc029ca6707305bf4,1 +np.float64,0x7fc5ee156b2bdc2a,0xbff8384b59e9056e,1 +np.float64,0xbfec22af3278455e,0xbff3530fe25816b4,1 +np.float64,0x6b5a8c2cd6b52,0x6b5a8c2cd6b52,1 +np.float64,0xffdaf6c4b935ed8a,0x4002f00ce58affcf,1 +np.float64,0x800a41813c748303,0x800a41813c748303,1 +np.float64,0xbfd09a1269213424,0xbfd0fc0a0c5de8eb,1 +np.float64,0x7fa2cb74d42596e9,0x3fc3d40e000fa69d,1 +np.float64,0x7ff8000000000000,0x7ff8000000000000,1 +np.float64,0x3fbfbf8ed63f7f1e,0x3fbfe97bcad9f53a,1 +np.float64,0x7fe0ebba65a1d774,0x401b0f17b28618df,1 +np.float64,0x3fd02c3a25a05874,0x3fd086aa55b19c9c,1 +np.float64,0xec628f95d8c52,0xec628f95d8c52,1 +np.float64,0x3fd319329fa63264,0x3fd3afb04e0dec63,1 +np.float64,0x180e0ade301c2,0x180e0ade301c2,1 +np.float64,0xbfe8d78324f1af06,0xbfef6c66153064ee,1 +np.float64,0xffb89fa200313f48,0xbfeb96ff2d9358dc,1 +np.float64,0x7fe6abcf86ed579e,0xc0269f4de86365ec,1 +np.float64,0x7fdff8cd65bff19a,0xbfd0f7c6b9052c9a,1 +np.float64,0xbfd2e3a53d25c74a,0xbfd37520cda5f6b2,1 +np.float64,0x7fe844b096708960,0x3ff696a6182e5a7a,1 +np.float64,0x7fdce0c7a3b9c18e,0x3fd42875d69ed379,1 +np.float64,0xffba5a91cc34b520,0x4001b571e8991951,1 +np.float64,0xffe78fe4a6ef1fc9,0x3ff4507b31f5b3bc,1 +np.float64,0xbfd7047493ae08ea,0xbfd810618a53fffb,1 +np.float64,0xc6559def8cab4,0xc6559def8cab4,1 +np.float64,0x3fe75d67a76ebacf,0x3feca56817de65e4,1 +np.float64,0xffd24adbd6a495b8,0xc012c491addf2df5,1 +np.float64,0x7fed35e28dba6bc4,0x403a0fa555ff7ec6,1 +np.float64,0x80078c4afa0f1897,0x80078c4afa0f1897,1 +np.float64,0xa6ec39114dd87,0xa6ec39114dd87,1 +np.float64,0x7fb1bd33ba237a66,0x4010092bb6810fd4,1 +np.float64,0x800ecf215edd9e43,0x800ecf215edd9e43,1 +np.float64,0x3fb7c169242f82d2,0x3fb7d2ed30c462e6,1 +np.float64,0xbf71b46d60236900,0xbf71b4749a10c112,1 +np.float64,0x800d7851787af0a3,0x800d7851787af0a3,1 +np.float64,0x3fcb4a45e7369488,0x3fcbb61701a1bcec,1 +np.float64,0x3fd4e3682429c6d0,0x3fd5a9bcb916eb94,1 +np.float64,0x800497564c292ead,0x800497564c292ead,1 +np.float64,0xbfca3737a1346e70,0xbfca96a86ae5d687,1 +np.float64,0x19aa87e03356,0x19aa87e03356,1 +np.float64,0xffb2593fe624b280,0xc05fedb99b467ced,1 +np.float64,0xbfdd8748fbbb0e92,0xbfdfd1a7df17252c,1 +np.float64,0x8004c7afc7098f60,0x8004c7afc7098f60,1 +np.float64,0x7fde48b2bf3c9164,0xbfe36ef1158ed420,1 +np.float64,0xbfec8e0eb0f91c1d,0xbff3d9319705a602,1 +np.float64,0xffea1be204f437c3,0xc0144f67298c3e6f,1 +np.float64,0x7fdb906b593720d6,0xbfce99233396eda7,1 +np.float64,0x3fef0f114ffe1e22,0x3ff76072a258a51b,1 +np.float64,0x3fe3e284c8e7c50a,0x3fe6e9b05e17c999,1 +np.float64,0xbfbda9eef23b53e0,0xbfbdcc1abb443597,1 +np.float64,0x3feb6454d4f6c8aa,0x3ff26f65a85baba4,1 +np.float64,0x3fea317439f462e8,0x3ff118e2187ef33f,1 +np.float64,0x376ad0646ed5b,0x376ad0646ed5b,1 +np.float64,0x7fdd461a1c3a8c33,0x3f7ba20fb79e785f,1 +np.float64,0xebc520a3d78a4,0xebc520a3d78a4,1 +np.float64,0x3fca90fe53352200,0x3fcaf45c7fae234d,1 +np.float64,0xbfe80dd1de701ba4,0xbfede97e12cde9de,1 +np.float64,0x3fd242b00ea48560,0x3fd2c5cf9bf69a31,1 +np.float64,0x7fe46c057828d80a,0xbfe2f76837488f94,1 +np.float64,0x3fc162bea322c580,0x3fc17e517c958867,1 +np.float64,0xffebf0452ff7e08a,0x3ffc3fd95c257b54,1 +np.float64,0xffd88043c6310088,0x4008b05598d0d95f,1 +np.float64,0x800d8c49da5b1894,0x800d8c49da5b1894,1 +np.float64,0xbfed33b487ba6769,0xbff4b0ea941f8a6a,1 +np.float64,0x16b881e22d711,0x16b881e22d711,1 +np.float64,0x288bae0051177,0x288bae0051177,1 +np.float64,0xffc83a0fe8307420,0x4006eff03da17f86,1 +np.float64,0x3fc7868b252f0d18,0x3fc7cb4954290324,1 +np.float64,0xbfe195514b232aa2,0xbfe398aae6c8ed76,1 +np.float64,0x800c001ae7f80036,0x800c001ae7f80036,1 +np.float64,0x7feb82abe7370557,0xbff1e13fe6fad23c,1 +np.float64,0xffecf609cdf9ec13,0xc0112aa1805ae59e,1 +np.float64,0xffddd654f63bacaa,0x3fe46cce899f710d,1 +np.float64,0x3fe2163138642c62,0x3fe44b9c760acd4c,1 +np.float64,0x4e570dc09cae2,0x4e570dc09cae2,1 +np.float64,0x7fe9e8d091f3d1a0,0xc000fe20f8e9a4b5,1 +np.float64,0x7fe60042952c0084,0x3fd0aa740f394c2a,1 diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/data/umath-validation-set-tanh.csv b/venv/lib/python3.12/site-packages/numpy/_core/tests/data/umath-validation-set-tanh.csv new file mode 100644 index 00000000..9e3ddc60 --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/tests/data/umath-validation-set-tanh.csv @@ -0,0 +1,1429 @@ +dtype,input,output,ulperrortol +np.float32,0xbe26ebb0,0xbe25752f,2 +np.float32,0xbe22ecc0,0xbe219054,2 +np.float32,0x8010a6b3,0x8010a6b3,2 +np.float32,0x3135da,0x3135da,2 +np.float32,0xbe982afc,0xbe93d727,2 +np.float32,0x16a51f,0x16a51f,2 +np.float32,0x491e56,0x491e56,2 +np.float32,0x4bf7ca,0x4bf7ca,2 +np.float32,0x3eebc21c,0x3edc65b2,2 +np.float32,0x80155c94,0x80155c94,2 +np.float32,0x3e14f626,0x3e13eb6a,2 +np.float32,0x801a238f,0x801a238f,2 +np.float32,0xbde33a80,0xbde24cf9,2 +np.float32,0xbef8439c,0xbee67a51,2 +np.float32,0x7f60d0a5,0x3f800000,2 +np.float32,0x190ee3,0x190ee3,2 +np.float32,0x80759113,0x80759113,2 +np.float32,0x800afa9f,0x800afa9f,2 +np.float32,0x7110cf,0x7110cf,2 +np.float32,0x3cf709f0,0x3cf6f6c6,2 +np.float32,0x3ef58da4,0x3ee44fa7,2 +np.float32,0xbf220ff2,0xbf0f662c,2 +np.float32,0xfd888078,0xbf800000,2 +np.float32,0xbe324734,0xbe307f9b,2 +np.float32,0x3eb5cb4f,0x3eae8560,2 +np.float32,0xbf7e7d02,0xbf425493,2 +np.float32,0x3ddcdcf0,0x3ddc02c2,2 +np.float32,0x8026d27a,0x8026d27a,2 +np.float32,0x3d4c0fb1,0x3d4be484,2 +np.float32,0xbf27d2c9,0xbf134d7c,2 +np.float32,0x8029ff80,0x8029ff80,2 +np.float32,0x7f046d2c,0x3f800000,2 +np.float32,0x13f94b,0x13f94b,2 +np.float32,0x7f4ff922,0x3f800000,2 +np.float32,0x3f4ea2ed,0x3f2b03e4,2 +np.float32,0x3e7211f0,0x3e6da8cf,2 +np.float32,0x7f39d0cf,0x3f800000,2 +np.float32,0xfee57fc6,0xbf800000,2 +np.float32,0xff6fb326,0xbf800000,2 +np.float32,0xff800000,0xbf800000,2 +np.float32,0x3f0437a4,0x3ef32fcd,2 +np.float32,0xff546d1e,0xbf800000,2 +np.float32,0x3eb5645b,0x3eae2a5c,2 +np.float32,0x3f08a6e5,0x3ef9ff8f,2 +np.float32,0x80800000,0x80800000,2 +np.float32,0x7f3413da,0x3f800000,2 +np.float32,0xfd760140,0xbf800000,2 +np.float32,0x7f3ad24a,0x3f800000,2 +np.float32,0xbf56e812,0xbf2f7f14,2 +np.float32,0xbece0338,0xbec3920a,2 +np.float32,0xbeede54a,0xbede22ae,2 +np.float32,0x7eaeb215,0x3f800000,2 +np.float32,0x3c213c00,0x3c213aab,2 +np.float32,0x7eaac217,0x3f800000,2 +np.float32,0xbf2f740e,0xbf1851a6,2 +np.float32,0x7f6ca5b8,0x3f800000,2 +np.float32,0xff42ce95,0xbf800000,2 +np.float32,0x802e4189,0x802e4189,2 +np.float32,0x80000001,0x80000001,2 +np.float32,0xbf31f298,0xbf19ebbe,2 +np.float32,0x3dcb0e6c,0x3dca64c1,2 +np.float32,0xbf29599c,0xbf145204,2 +np.float32,0x2e33f2,0x2e33f2,2 +np.float32,0x1c11e7,0x1c11e7,2 +np.float32,0x3f3b188d,0x3f1fa302,2 +np.float32,0x113300,0x113300,2 +np.float32,0x8054589e,0x8054589e,2 +np.float32,0x2a9e69,0x2a9e69,2 +np.float32,0xff513af7,0xbf800000,2 +np.float32,0x7f2e987a,0x3f800000,2 +np.float32,0x807cd426,0x807cd426,2 +np.float32,0x7f0dc4e4,0x3f800000,2 +np.float32,0x7e7c0d56,0x3f800000,2 +np.float32,0x5cb076,0x5cb076,2 +np.float32,0x80576426,0x80576426,2 +np.float32,0xff616222,0xbf800000,2 +np.float32,0xbf7accb5,0xbf40c005,2 +np.float32,0xfe4118c8,0xbf800000,2 +np.float32,0x804b9327,0x804b9327,2 +np.float32,0x3ed2b428,0x3ec79026,2 +np.float32,0x3f4a048f,0x3f286d41,2 +np.float32,0x800000,0x800000,2 +np.float32,0x7efceb9f,0x3f800000,2 +np.float32,0xbf5fe2d3,0xbf34246f,2 +np.float32,0x807e086a,0x807e086a,2 +np.float32,0x7ef5e856,0x3f800000,2 +np.float32,0xfc546f00,0xbf800000,2 +np.float32,0x3a65b890,0x3a65b88c,2 +np.float32,0x800cfa70,0x800cfa70,2 +np.float32,0x80672ea7,0x80672ea7,2 +np.float32,0x3f2bf3f2,0x3f160a12,2 +np.float32,0xbf0ab67e,0xbefd2004,2 +np.float32,0x3f2a0bb4,0x3f14c824,2 +np.float32,0xbeff5374,0xbeec12d7,2 +np.float32,0xbf221b58,0xbf0f6dff,2 +np.float32,0x7cc1f3,0x7cc1f3,2 +np.float32,0x7f234e3c,0x3f800000,2 +np.float32,0x3f60ff10,0x3f34b37d,2 +np.float32,0xbdd957f0,0xbdd887fe,2 +np.float32,0x801ce048,0x801ce048,2 +np.float32,0x7f3a8f76,0x3f800000,2 +np.float32,0xfdd13d08,0xbf800000,2 +np.float32,0x3e9af4a4,0x3e966445,2 +np.float32,0x1e55f3,0x1e55f3,2 +np.float32,0x327905,0x327905,2 +np.float32,0xbf03cf0b,0xbef28dad,2 +np.float32,0x3f0223d3,0x3eeff4f4,2 +np.float32,0xfdd96ff8,0xbf800000,2 +np.float32,0x428db8,0x428db8,2 +np.float32,0xbd74a200,0xbd7457a5,2 +np.float32,0x2a63a3,0x2a63a3,2 +np.float32,0x7e8aa9d7,0x3f800000,2 +np.float32,0x7f50b810,0x3f800000,2 +np.float32,0xbce5ec80,0xbce5dd0d,2 +np.float32,0x54711,0x54711,2 +np.float32,0x8074212a,0x8074212a,2 +np.float32,0xbf13d0ec,0xbf0551b5,2 +np.float32,0x80217f89,0x80217f89,2 +np.float32,0x3f300824,0x3f18b12f,2 +np.float32,0x7d252462,0x3f800000,2 +np.float32,0x807a154c,0x807a154c,2 +np.float32,0x8064d4b9,0x8064d4b9,2 +np.float32,0x804543b4,0x804543b4,2 +np.float32,0x4c269e,0x4c269e,2 +np.float32,0xff39823b,0xbf800000,2 +np.float32,0x3f5040b1,0x3f2be80b,2 +np.float32,0xbf7028c1,0xbf3bfee5,2 +np.float32,0x3e94eb78,0x3e90db93,2 +np.float32,0x3ccc1b40,0x3ccc1071,2 +np.float32,0xbe8796f0,0xbe8481a1,2 +np.float32,0xfc767bc0,0xbf800000,2 +np.float32,0xbdd81ed0,0xbdd75259,2 +np.float32,0xbed31bfc,0xbec7e82d,2 +np.float32,0xbf350a9e,0xbf1be1c6,2 +np.float32,0x33d41f,0x33d41f,2 +np.float32,0x3f73e076,0x3f3db0b5,2 +np.float32,0x3f800000,0x3f42f7d6,2 +np.float32,0xfee27c14,0xbf800000,2 +np.float32,0x7f6e4388,0x3f800000,2 +np.float32,0x4ea19b,0x4ea19b,2 +np.float32,0xff2d75f2,0xbf800000,2 +np.float32,0x7ee225ca,0x3f800000,2 +np.float32,0x3f31cb4b,0x3f19d2a4,2 +np.float32,0x80554a9d,0x80554a9d,2 +np.float32,0x3f4d57fa,0x3f2a4c03,2 +np.float32,0x3eac6a88,0x3ea62e72,2 +np.float32,0x773520,0x773520,2 +np.float32,0x8079c20a,0x8079c20a,2 +np.float32,0xfeb1eb94,0xbf800000,2 +np.float32,0xfe8d81c0,0xbf800000,2 +np.float32,0xfeed6902,0xbf800000,2 +np.float32,0x8066bb65,0x8066bb65,2 +np.float32,0x7f800000,0x3f800000,2 +np.float32,0x1,0x1,2 +np.float32,0x3f2c66a4,0x3f16554a,2 +np.float32,0x3cd231,0x3cd231,2 +np.float32,0x3e932a64,0x3e8f3e0c,2 +np.float32,0xbf3ab1c3,0xbf1f6420,2 +np.float32,0xbc902b20,0xbc902751,2 +np.float32,0x7dac0a5b,0x3f800000,2 +np.float32,0x3f2b7e06,0x3f15bc93,2 +np.float32,0x75de0,0x75de0,2 +np.float32,0x8020b7bc,0x8020b7bc,2 +np.float32,0x3f257cda,0x3f11bb6b,2 +np.float32,0x807480e5,0x807480e5,2 +np.float32,0xfe00d758,0xbf800000,2 +np.float32,0xbd9b54e0,0xbd9b08cd,2 +np.float32,0x4dfbe3,0x4dfbe3,2 +np.float32,0xff645788,0xbf800000,2 +np.float32,0xbe92c80a,0xbe8ee360,2 +np.float32,0x3eb9b400,0x3eb1f77c,2 +np.float32,0xff20b69c,0xbf800000,2 +np.float32,0x623c28,0x623c28,2 +np.float32,0xff235748,0xbf800000,2 +np.float32,0xbf3bbc56,0xbf2006f3,2 +np.float32,0x7e6f78b1,0x3f800000,2 +np.float32,0x7e1584e9,0x3f800000,2 +np.float32,0xff463423,0xbf800000,2 +np.float32,0x8002861e,0x8002861e,2 +np.float32,0xbf0491d8,0xbef3bb6a,2 +np.float32,0x7ea3bc17,0x3f800000,2 +np.float32,0xbedde7ea,0xbed0fb49,2 +np.float32,0xbf4bac48,0xbf295c8b,2 +np.float32,0xff28e276,0xbf800000,2 +np.float32,0x7e8f3bf5,0x3f800000,2 +np.float32,0xbf0a4a73,0xbefc7c9d,2 +np.float32,0x7ec5bd96,0x3f800000,2 +np.float32,0xbf4c22e8,0xbf299f2c,2 +np.float32,0x3e3970a0,0x3e377064,2 +np.float32,0x3ecb1118,0x3ec10c88,2 +np.float32,0xff548a7a,0xbf800000,2 +np.float32,0xfe8ec550,0xbf800000,2 +np.float32,0x3e158985,0x3e147bb2,2 +np.float32,0x7eb79ad7,0x3f800000,2 +np.float32,0xbe811384,0xbe7cd1ab,2 +np.float32,0xbdc4b9e8,0xbdc41f94,2 +np.float32,0xe0fd5,0xe0fd5,2 +np.float32,0x3f2485f2,0x3f11142b,2 +np.float32,0xfdd3c3d8,0xbf800000,2 +np.float32,0xfe8458e6,0xbf800000,2 +np.float32,0x3f06e398,0x3ef74dd8,2 +np.float32,0xff4752cf,0xbf800000,2 +np.float32,0x6998e3,0x6998e3,2 +np.float32,0x626751,0x626751,2 +np.float32,0x806631d6,0x806631d6,2 +np.float32,0xbf0c3cf4,0xbeff6c54,2 +np.float32,0x802860f8,0x802860f8,2 +np.float32,0xff2952cb,0xbf800000,2 +np.float32,0xff31d40b,0xbf800000,2 +np.float32,0x7c389473,0x3f800000,2 +np.float32,0x3dcd2f1b,0x3dcc8010,2 +np.float32,0x3d70c29f,0x3d707bbc,2 +np.float32,0x3f6bd386,0x3f39f979,2 +np.float32,0x1efec9,0x1efec9,2 +np.float32,0x3f675518,0x3f37d338,2 +np.float32,0x5fdbe3,0x5fdbe3,2 +np.float32,0x5d684e,0x5d684e,2 +np.float32,0xbedfe748,0xbed2a4c7,2 +np.float32,0x3f0cb07a,0x3f000cdc,2 +np.float32,0xbf77151e,0xbf3f1f5d,2 +np.float32,0x7f038ea0,0x3f800000,2 +np.float32,0x3ea91be9,0x3ea3376f,2 +np.float32,0xbdf20738,0xbdf0e861,2 +np.float32,0x807ea380,0x807ea380,2 +np.float32,0x2760ca,0x2760ca,2 +np.float32,0x7f20a544,0x3f800000,2 +np.float32,0x76ed83,0x76ed83,2 +np.float32,0x15a441,0x15a441,2 +np.float32,0x74c76d,0x74c76d,2 +np.float32,0xff3d5c2a,0xbf800000,2 +np.float32,0x7f6a76a6,0x3f800000,2 +np.float32,0x3eb87067,0x3eb0dabe,2 +np.float32,0xbf515cfa,0xbf2c83af,2 +np.float32,0xbdececc0,0xbdebdf9d,2 +np.float32,0x7f51b7c2,0x3f800000,2 +np.float32,0x3eb867ac,0x3eb0d30d,2 +np.float32,0xff50fd84,0xbf800000,2 +np.float32,0x806945e9,0x806945e9,2 +np.float32,0x298eed,0x298eed,2 +np.float32,0x441f53,0x441f53,2 +np.float32,0x8066d4b0,0x8066d4b0,2 +np.float32,0x3f6a479c,0x3f393dae,2 +np.float32,0xbf6ce2a7,0xbf3a7921,2 +np.float32,0x8064c3cf,0x8064c3cf,2 +np.float32,0xbf2d8146,0xbf170dfd,2 +np.float32,0x3b0e82,0x3b0e82,2 +np.float32,0xbea97574,0xbea387dc,2 +np.float32,0x67ad15,0x67ad15,2 +np.float32,0xbf68478f,0xbf38485a,2 +np.float32,0xff6f593b,0xbf800000,2 +np.float32,0xbeda26f2,0xbecdd806,2 +np.float32,0xbd216d50,0xbd2157ee,2 +np.float32,0x7a8544db,0x3f800000,2 +np.float32,0x801df20b,0x801df20b,2 +np.float32,0xbe14ba24,0xbe13b0a8,2 +np.float32,0xfdc6d8a8,0xbf800000,2 +np.float32,0x1d6b49,0x1d6b49,2 +np.float32,0x7f5ff1b8,0x3f800000,2 +np.float32,0x3f75e032,0x3f3e9625,2 +np.float32,0x7f2c5687,0x3f800000,2 +np.float32,0x3d95fb6c,0x3d95b6ee,2 +np.float32,0xbea515e4,0xbe9f97c8,2 +np.float32,0x7f2b2cd7,0x3f800000,2 +np.float32,0x3f076f7a,0x3ef8241e,2 +np.float32,0x5178ca,0x5178ca,2 +np.float32,0xbeb5976a,0xbeae5781,2 +np.float32,0x3e3c3563,0x3e3a1e13,2 +np.float32,0xbd208530,0xbd20702a,2 +np.float32,0x3eb03b04,0x3ea995ef,2 +np.float32,0x17fb9c,0x17fb9c,2 +np.float32,0xfca68e40,0xbf800000,2 +np.float32,0xbf5e7433,0xbf336a9f,2 +np.float32,0xff5b8d3d,0xbf800000,2 +np.float32,0x8003121d,0x8003121d,2 +np.float32,0xbe6dd344,0xbe69a3b0,2 +np.float32,0x67cc4,0x67cc4,2 +np.float32,0x9b01d,0x9b01d,2 +np.float32,0x127c13,0x127c13,2 +np.float32,0xfea5e3d6,0xbf800000,2 +np.float32,0xbdf5c610,0xbdf499c1,2 +np.float32,0x3aff4c00,0x3aff4beb,2 +np.float32,0x3b00afd0,0x3b00afc5,2 +np.float32,0x479618,0x479618,2 +np.float32,0x801cbd05,0x801cbd05,2 +np.float32,0x3ec9249f,0x3ebf6579,2 +np.float32,0x3535c4,0x3535c4,2 +np.float32,0xbeb4f662,0xbeadc915,2 +np.float32,0x8006fda6,0x8006fda6,2 +np.float32,0xbf4f3097,0xbf2b5239,2 +np.float32,0xbf3cb9a8,0xbf20a0e9,2 +np.float32,0x32ced0,0x32ced0,2 +np.float32,0x7ea34e76,0x3f800000,2 +np.float32,0x80063046,0x80063046,2 +np.float32,0x80727e8b,0x80727e8b,2 +np.float32,0xfd6b5780,0xbf800000,2 +np.float32,0x80109815,0x80109815,2 +np.float32,0xfdcc8a78,0xbf800000,2 +np.float32,0x81562,0x81562,2 +np.float32,0x803dfacc,0x803dfacc,2 +np.float32,0xbe204318,0xbe1ef75f,2 +np.float32,0xbf745d34,0xbf3de8e2,2 +np.float32,0xff13fdcc,0xbf800000,2 +np.float32,0x7f75ba8c,0x3f800000,2 +np.float32,0x806c04b4,0x806c04b4,2 +np.float32,0x3ec61ca6,0x3ebcc877,2 +np.float32,0xbeaea984,0xbea8301f,2 +np.float32,0xbf4dcd0e,0xbf2a8d34,2 +np.float32,0x802a01d3,0x802a01d3,2 +np.float32,0xbf747be5,0xbf3df6ad,2 +np.float32,0xbf75cbd2,0xbf3e8d0f,2 +np.float32,0x7db86576,0x3f800000,2 +np.float32,0xff49a2c3,0xbf800000,2 +np.float32,0xbedc5314,0xbecfa978,2 +np.float32,0x8078877b,0x8078877b,2 +np.float32,0xbead4824,0xbea6f499,2 +np.float32,0xbf3926e3,0xbf1e716c,2 +np.float32,0x807f4a1c,0x807f4a1c,2 +np.float32,0x7f2cd8fd,0x3f800000,2 +np.float32,0x806cfcca,0x806cfcca,2 +np.float32,0xff1aa048,0xbf800000,2 +np.float32,0x7eb9ea08,0x3f800000,2 +np.float32,0xbf1034bc,0xbf02ab3a,2 +np.float32,0xbd087830,0xbd086b44,2 +np.float32,0x7e071034,0x3f800000,2 +np.float32,0xbefcc9de,0xbeea122f,2 +np.float32,0x80796d7a,0x80796d7a,2 +np.float32,0x33ce46,0x33ce46,2 +np.float32,0x8074a783,0x8074a783,2 +np.float32,0xbe95a56a,0xbe918691,2 +np.float32,0xbf2ff3f4,0xbf18a42d,2 +np.float32,0x1633e9,0x1633e9,2 +np.float32,0x7f0f104b,0x3f800000,2 +np.float32,0xbf800000,0xbf42f7d6,2 +np.float32,0x3d2cd6,0x3d2cd6,2 +np.float32,0xfed43e16,0xbf800000,2 +np.float32,0x3ee6faec,0x3ed87d2c,2 +np.float32,0x3f2c32d0,0x3f163352,2 +np.float32,0xff4290c0,0xbf800000,2 +np.float32,0xbf66500e,0xbf37546a,2 +np.float32,0x7dfb8fe3,0x3f800000,2 +np.float32,0x3f20ba5d,0x3f0e7b16,2 +np.float32,0xff30c7ae,0xbf800000,2 +np.float32,0x1728a4,0x1728a4,2 +np.float32,0x340d82,0x340d82,2 +np.float32,0xff7870b7,0xbf800000,2 +np.float32,0xbeac6ac4,0xbea62ea7,2 +np.float32,0xbef936fc,0xbee73c36,2 +np.float32,0x3ec7e12c,0x3ebe4ef8,2 +np.float32,0x80673488,0x80673488,2 +np.float32,0xfdf14c90,0xbf800000,2 +np.float32,0x3f182568,0x3f08726e,2 +np.float32,0x7ed7dcd0,0x3f800000,2 +np.float32,0x3de4da34,0x3de3e790,2 +np.float32,0xff7fffff,0xbf800000,2 +np.float32,0x4ff90c,0x4ff90c,2 +np.float32,0x3efb0d1c,0x3ee8b1d6,2 +np.float32,0xbf66e952,0xbf379ef4,2 +np.float32,0xba9dc,0xba9dc,2 +np.float32,0xff67c766,0xbf800000,2 +np.float32,0x7f1ffc29,0x3f800000,2 +np.float32,0x3f51c906,0x3f2cbe99,2 +np.float32,0x3f2e5792,0x3f179968,2 +np.float32,0x3ecb9750,0x3ec17fa0,2 +np.float32,0x7f3fcefc,0x3f800000,2 +np.float32,0xbe4e30fc,0xbe4b72f9,2 +np.float32,0x7e9bc4ce,0x3f800000,2 +np.float32,0x7e70aa1f,0x3f800000,2 +np.float32,0x14c6e9,0x14c6e9,2 +np.float32,0xbcf327c0,0xbcf3157a,2 +np.float32,0xff1fd204,0xbf800000,2 +np.float32,0x7d934a03,0x3f800000,2 +np.float32,0x8028bf1e,0x8028bf1e,2 +np.float32,0x7f0800b7,0x3f800000,2 +np.float32,0xfe04825c,0xbf800000,2 +np.float32,0x807210ac,0x807210ac,2 +np.float32,0x3f7faf7c,0x3f42d5fd,2 +np.float32,0x3e04a543,0x3e03e899,2 +np.float32,0x3e98ea15,0x3e94863e,2 +np.float32,0x3d2a2e48,0x3d2a153b,2 +np.float32,0x7fa00000,0x7fe00000,2 +np.float32,0x20a488,0x20a488,2 +np.float32,0x3f6ba86a,0x3f39e51a,2 +np.float32,0x0,0x0,2 +np.float32,0x3e892ddd,0x3e85fcfe,2 +np.float32,0x3e2da627,0x3e2c00e0,2 +np.float32,0xff000a50,0xbf800000,2 +np.float32,0x3eb749f4,0x3eafd739,2 +np.float32,0x8024c0ae,0x8024c0ae,2 +np.float32,0xfc8f3b40,0xbf800000,2 +np.float32,0xbf685fc7,0xbf385405,2 +np.float32,0x3f1510e6,0x3f063a4f,2 +np.float32,0x3f68e8ad,0x3f3895d8,2 +np.float32,0x3dba8608,0x3dba0271,2 +np.float32,0xbf16ea10,0xbf079017,2 +np.float32,0xb3928,0xb3928,2 +np.float32,0xfe447c00,0xbf800000,2 +np.float32,0x3db9cd57,0x3db94b45,2 +np.float32,0x803b66b0,0x803b66b0,2 +np.float32,0x805b5e02,0x805b5e02,2 +np.float32,0x7ec93f61,0x3f800000,2 +np.float32,0x8005a126,0x8005a126,2 +np.float32,0x6d8888,0x6d8888,2 +np.float32,0x3e21b7de,0x3e206314,2 +np.float32,0xbec9c31e,0xbebfedc2,2 +np.float32,0xbea88aa8,0xbea2b4e5,2 +np.float32,0x3d8fc310,0x3d8f86bb,2 +np.float32,0xbf3cc68a,0xbf20a8b8,2 +np.float32,0x432690,0x432690,2 +np.float32,0xbe51d514,0xbe4ef1a3,2 +np.float32,0xbcda6d20,0xbcda5fe1,2 +np.float32,0xfe24e458,0xbf800000,2 +np.float32,0xfedc8c14,0xbf800000,2 +np.float32,0x7f7e9bd4,0x3f800000,2 +np.float32,0x3ebcc880,0x3eb4ab44,2 +np.float32,0xbe0aa490,0xbe09cd44,2 +np.float32,0x3dc9158c,0x3dc870c3,2 +np.float32,0x3e5c319e,0x3e58dc90,2 +np.float32,0x1d4527,0x1d4527,2 +np.float32,0x2dbf5,0x2dbf5,2 +np.float32,0xbf1f121f,0xbf0d5534,2 +np.float32,0x7e3e9ab5,0x3f800000,2 +np.float32,0x7f74b5c1,0x3f800000,2 +np.float32,0xbf6321ba,0xbf35c42b,2 +np.float32,0xbe5c7488,0xbe591c79,2 +np.float32,0x7e7b02cd,0x3f800000,2 +np.float32,0xfe7cbfa4,0xbf800000,2 +np.float32,0xbeace360,0xbea69a86,2 +np.float32,0x7e149b00,0x3f800000,2 +np.float32,0xbf61a700,0xbf35079a,2 +np.float32,0x7eb592a7,0x3f800000,2 +np.float32,0x3f2105e6,0x3f0eaf30,2 +np.float32,0xfd997a88,0xbf800000,2 +np.float32,0xff5d093b,0xbf800000,2 +np.float32,0x63aede,0x63aede,2 +np.float32,0x6907ee,0x6907ee,2 +np.float32,0xbf7578ee,0xbf3e680f,2 +np.float32,0xfea971e8,0xbf800000,2 +np.float32,0x3f21d0f5,0x3f0f3aed,2 +np.float32,0x3a50e2,0x3a50e2,2 +np.float32,0x7f0f5b1e,0x3f800000,2 +np.float32,0x805b9765,0x805b9765,2 +np.float32,0xbe764ab8,0xbe71a664,2 +np.float32,0x3eafac7f,0x3ea91701,2 +np.float32,0x807f4130,0x807f4130,2 +np.float32,0x7c5f31,0x7c5f31,2 +np.float32,0xbdbe0e30,0xbdbd8300,2 +np.float32,0x7ecfe4e0,0x3f800000,2 +np.float32,0xff7cb628,0xbf800000,2 +np.float32,0xff1842bc,0xbf800000,2 +np.float32,0xfd4163c0,0xbf800000,2 +np.float32,0x800e11f7,0x800e11f7,2 +np.float32,0x7f3adec8,0x3f800000,2 +np.float32,0x7f597514,0x3f800000,2 +np.float32,0xbe986e14,0xbe9414a4,2 +np.float32,0x800fa9d7,0x800fa9d7,2 +np.float32,0xff5b79c4,0xbf800000,2 +np.float32,0x80070565,0x80070565,2 +np.float32,0xbee5628e,0xbed72d60,2 +np.float32,0x3f438ef2,0x3f24b3ca,2 +np.float32,0xcda91,0xcda91,2 +np.float32,0x7e64151a,0x3f800000,2 +np.float32,0xbe95d584,0xbe91b2c7,2 +np.float32,0x8022c2a1,0x8022c2a1,2 +np.float32,0x7e7097bf,0x3f800000,2 +np.float32,0x80139035,0x80139035,2 +np.float32,0x804de2cb,0x804de2cb,2 +np.float32,0xfde5d178,0xbf800000,2 +np.float32,0x6d238,0x6d238,2 +np.float32,0x807abedc,0x807abedc,2 +np.float32,0x3f450a12,0x3f259129,2 +np.float32,0x3ef1c120,0x3ee141f2,2 +np.float32,0xfeb64dae,0xbf800000,2 +np.float32,0x8001732c,0x8001732c,2 +np.float32,0x3f76062e,0x3f3ea711,2 +np.float32,0x3eddd550,0x3ed0ebc8,2 +np.float32,0xff5ca1d4,0xbf800000,2 +np.float32,0xbf49dc5e,0xbf285673,2 +np.float32,0x7e9e5438,0x3f800000,2 +np.float32,0x7e83625e,0x3f800000,2 +np.float32,0x3f5dc41c,0x3f3310da,2 +np.float32,0x3f583efa,0x3f30342f,2 +np.float32,0xbe26bf88,0xbe254a2d,2 +np.float32,0xff1e0beb,0xbf800000,2 +np.float32,0xbe2244c8,0xbe20ec86,2 +np.float32,0xff0b1630,0xbf800000,2 +np.float32,0xff338dd6,0xbf800000,2 +np.float32,0x3eafc22c,0x3ea92a51,2 +np.float32,0x800ea07f,0x800ea07f,2 +np.float32,0x3f46f006,0x3f26aa7e,2 +np.float32,0x3e5f57cd,0x3e5bde16,2 +np.float32,0xbf1b2d8e,0xbf0a9a93,2 +np.float32,0xfeacdbe0,0xbf800000,2 +np.float32,0x7e5ea4bc,0x3f800000,2 +np.float32,0xbf51cbe2,0xbf2cc027,2 +np.float32,0x8073644c,0x8073644c,2 +np.float32,0xff2d6bfe,0xbf800000,2 +np.float32,0x3f65f0f6,0x3f37260a,2 +np.float32,0xff4b37a6,0xbf800000,2 +np.float32,0x712df7,0x712df7,2 +np.float32,0x7f71ef17,0x3f800000,2 +np.float32,0x8042245c,0x8042245c,2 +np.float32,0x3e5dde7b,0x3e5a760d,2 +np.float32,0x8069317d,0x8069317d,2 +np.float32,0x807932dd,0x807932dd,2 +np.float32,0x802f847e,0x802f847e,2 +np.float32,0x7e9300,0x7e9300,2 +np.float32,0x8040b4ab,0x8040b4ab,2 +np.float32,0xff76ef8e,0xbf800000,2 +np.float32,0x4aae3a,0x4aae3a,2 +np.float32,0x8058de73,0x8058de73,2 +np.float32,0x7e4d58c0,0x3f800000,2 +np.float32,0x3d811b30,0x3d80ef79,2 +np.float32,0x7ec952cc,0x3f800000,2 +np.float32,0xfe162b1c,0xbf800000,2 +np.float32,0x3f0f1187,0x3f01d367,2 +np.float32,0xbf2f3458,0xbf182878,2 +np.float32,0x5ceb14,0x5ceb14,2 +np.float32,0xbec29476,0xbeb9b939,2 +np.float32,0x3e71f943,0x3e6d9176,2 +np.float32,0x3ededefc,0x3ed1c909,2 +np.float32,0x805df6ac,0x805df6ac,2 +np.float32,0x3e5ae2c8,0x3e579ca8,2 +np.float32,0x3f6ad2c3,0x3f397fdf,2 +np.float32,0x7d5f94d3,0x3f800000,2 +np.float32,0xbeec7fe4,0xbedd0037,2 +np.float32,0x3f645304,0x3f365b0d,2 +np.float32,0xbf69a087,0xbf38edef,2 +np.float32,0x8025102e,0x8025102e,2 +np.float32,0x800db486,0x800db486,2 +np.float32,0x4df6c7,0x4df6c7,2 +np.float32,0x806d8cdd,0x806d8cdd,2 +np.float32,0x7f0c78cc,0x3f800000,2 +np.float32,0x7e1cf70b,0x3f800000,2 +np.float32,0x3e0ae570,0x3e0a0cf7,2 +np.float32,0x80176ef8,0x80176ef8,2 +np.float32,0x3f38b60c,0x3f1e2bbb,2 +np.float32,0x3d3071e0,0x3d3055f5,2 +np.float32,0x3ebfcfdd,0x3eb750a9,2 +np.float32,0xfe2cdec0,0xbf800000,2 +np.float32,0x7eeb2eed,0x3f800000,2 +np.float32,0x8026c904,0x8026c904,2 +np.float32,0xbec79bde,0xbebe133a,2 +np.float32,0xbf7dfab6,0xbf421d47,2 +np.float32,0x805b3cfd,0x805b3cfd,2 +np.float32,0xfdfcfb68,0xbf800000,2 +np.float32,0xbd537ec0,0xbd534eaf,2 +np.float32,0x52ce73,0x52ce73,2 +np.float32,0xfeac6ea6,0xbf800000,2 +np.float32,0x3f2c2990,0x3f162d41,2 +np.float32,0x3e3354e0,0x3e318539,2 +np.float32,0x802db22b,0x802db22b,2 +np.float32,0x7f0faa83,0x3f800000,2 +np.float32,0x7f10e161,0x3f800000,2 +np.float32,0x7f165c60,0x3f800000,2 +np.float32,0xbf5a756f,0xbf315c82,2 +np.float32,0x7f5a4b68,0x3f800000,2 +np.float32,0xbd77fbf0,0xbd77ae7c,2 +np.float32,0x65d83c,0x65d83c,2 +np.float32,0x3e5f28,0x3e5f28,2 +np.float32,0x8040ec92,0x8040ec92,2 +np.float32,0xbf2b41a6,0xbf1594d5,2 +np.float32,0x7f2f88f1,0x3f800000,2 +np.float32,0xfdb64ab8,0xbf800000,2 +np.float32,0xbf7a3ff1,0xbf4082f5,2 +np.float32,0x1948fc,0x1948fc,2 +np.float32,0x802c1039,0x802c1039,2 +np.float32,0x80119274,0x80119274,2 +np.float32,0x7e885d7b,0x3f800000,2 +np.float32,0xfaf6a,0xfaf6a,2 +np.float32,0x3eba28c4,0x3eb25e1d,2 +np.float32,0x3e4df370,0x3e4b37da,2 +np.float32,0xbf19eff6,0xbf09b97d,2 +np.float32,0xbeddd3c6,0xbed0ea7f,2 +np.float32,0xff6fc971,0xbf800000,2 +np.float32,0x7e93de29,0x3f800000,2 +np.float32,0x3eb12332,0x3eaa6485,2 +np.float32,0x3eb7c6e4,0x3eb04563,2 +np.float32,0x4a67ee,0x4a67ee,2 +np.float32,0xff1cafde,0xbf800000,2 +np.float32,0x3f5e2812,0x3f3343da,2 +np.float32,0x3f060e04,0x3ef605d4,2 +np.float32,0x3e9027d8,0x3e8c76a6,2 +np.float32,0xe2d33,0xe2d33,2 +np.float32,0xff4c94fc,0xbf800000,2 +np.float32,0xbf574908,0xbf2fb26b,2 +np.float32,0xbf786c08,0xbf3fb68e,2 +np.float32,0x8011ecab,0x8011ecab,2 +np.float32,0xbf061c6a,0xbef61bfa,2 +np.float32,0x7eea5f9d,0x3f800000,2 +np.float32,0x3ea2e19c,0x3e9d99a5,2 +np.float32,0x8071550c,0x8071550c,2 +np.float32,0x41c70b,0x41c70b,2 +np.float32,0x80291fc8,0x80291fc8,2 +np.float32,0x43b1ec,0x43b1ec,2 +np.float32,0x32f5a,0x32f5a,2 +np.float32,0xbe9310ec,0xbe8f2692,2 +np.float32,0x7f75f6bf,0x3f800000,2 +np.float32,0x3e6642a6,0x3e6274d2,2 +np.float32,0x3ecb88e0,0x3ec1733f,2 +np.float32,0x804011b6,0x804011b6,2 +np.float32,0x80629cca,0x80629cca,2 +np.float32,0x8016b914,0x8016b914,2 +np.float32,0xbdd05fc0,0xbdcfa870,2 +np.float32,0x807b824d,0x807b824d,2 +np.float32,0xfeec2576,0xbf800000,2 +np.float32,0xbf54bf22,0xbf2e584c,2 +np.float32,0xbf185eb0,0xbf089b6b,2 +np.float32,0xfbc09480,0xbf800000,2 +np.float32,0x3f413054,0x3f234e25,2 +np.float32,0x7e9e32b8,0x3f800000,2 +np.float32,0x266296,0x266296,2 +np.float32,0x460284,0x460284,2 +np.float32,0x3eb0b056,0x3ea9fe5a,2 +np.float32,0x1a7be5,0x1a7be5,2 +np.float32,0x7f099895,0x3f800000,2 +np.float32,0x3f3614f0,0x3f1c88ef,2 +np.float32,0x7e757dc2,0x3f800000,2 +np.float32,0x801fc91e,0x801fc91e,2 +np.float32,0x3f5ce37d,0x3f329ddb,2 +np.float32,0x3e664d70,0x3e627f15,2 +np.float32,0xbf38ed78,0xbf1e4dfa,2 +np.float32,0xbf5c563d,0xbf325543,2 +np.float32,0xbe91cc54,0xbe8dfb24,2 +np.float32,0x3d767fbe,0x3d7633ac,2 +np.float32,0xbf6aeb40,0xbf398b7f,2 +np.float32,0x7f40508b,0x3f800000,2 +np.float32,0x2650df,0x2650df,2 +np.float32,0xbe8cea3c,0xbe897628,2 +np.float32,0x80515af8,0x80515af8,2 +np.float32,0x7f423986,0x3f800000,2 +np.float32,0xbdf250e8,0xbdf1310c,2 +np.float32,0xfe89288a,0xbf800000,2 +np.float32,0x397b3b,0x397b3b,2 +np.float32,0x7e5e91b0,0x3f800000,2 +np.float32,0x6866e2,0x6866e2,2 +np.float32,0x7f4d8877,0x3f800000,2 +np.float32,0x3e6c4a21,0x3e682ee3,2 +np.float32,0xfc3d5980,0xbf800000,2 +np.float32,0x7eae2cd0,0x3f800000,2 +np.float32,0xbf241222,0xbf10c579,2 +np.float32,0xfebc02de,0xbf800000,2 +np.float32,0xff6e0645,0xbf800000,2 +np.float32,0x802030b6,0x802030b6,2 +np.float32,0x7ef9a441,0x3f800000,2 +np.float32,0x3fcf9f,0x3fcf9f,2 +np.float32,0xbf0ccf13,0xbf0023cc,2 +np.float32,0xfefee688,0xbf800000,2 +np.float32,0xbf6c8e0c,0xbf3a5160,2 +np.float32,0xfe749c28,0xbf800000,2 +np.float32,0x7f7fffff,0x3f800000,2 +np.float32,0x58c1a0,0x58c1a0,2 +np.float32,0x3f2de0a1,0x3f174c17,2 +np.float32,0xbf5f7138,0xbf33eb03,2 +np.float32,0x3da15270,0x3da0fd3c,2 +np.float32,0x3da66560,0x3da607e4,2 +np.float32,0xbf306f9a,0xbf18f3c6,2 +np.float32,0x3e81a4de,0x3e7de293,2 +np.float32,0xbebb5fb8,0xbeb36f1a,2 +np.float32,0x14bf64,0x14bf64,2 +np.float32,0xbeac46c6,0xbea60e73,2 +np.float32,0xbdcdf210,0xbdcd4111,2 +np.float32,0x3f7e3cd9,0x3f42395e,2 +np.float32,0xbc4be640,0xbc4be38e,2 +np.float32,0xff5f53b4,0xbf800000,2 +np.float32,0xbf1315ae,0xbf04c90b,2 +np.float32,0x80000000,0x80000000,2 +np.float32,0xbf6a4149,0xbf393aaa,2 +np.float32,0x3f66b8ee,0x3f378772,2 +np.float32,0xff29293e,0xbf800000,2 +np.float32,0xbcc989c0,0xbcc97f58,2 +np.float32,0xbd9a1b70,0xbd99d125,2 +np.float32,0xfef353cc,0xbf800000,2 +np.float32,0xbdc30cf0,0xbdc27683,2 +np.float32,0xfdfd6768,0xbf800000,2 +np.float32,0x7ebac44c,0x3f800000,2 +np.float32,0xff453cd6,0xbf800000,2 +np.float32,0x3ef07720,0x3ee03787,2 +np.float32,0x80219c14,0x80219c14,2 +np.float32,0x805553a8,0x805553a8,2 +np.float32,0x80703928,0x80703928,2 +np.float32,0xff16d3a7,0xbf800000,2 +np.float32,0x3f1472bc,0x3f05c77b,2 +np.float32,0x3eeea37a,0x3edebcf9,2 +np.float32,0x3db801e6,0x3db7838d,2 +np.float32,0x800870d2,0x800870d2,2 +np.float32,0xbea1172c,0xbe9bfa32,2 +np.float32,0x3f1f5e7c,0x3f0d8a42,2 +np.float32,0x123cdb,0x123cdb,2 +np.float32,0x7f6e6b06,0x3f800000,2 +np.float32,0x3ed80573,0x3ecc0def,2 +np.float32,0xfea31b82,0xbf800000,2 +np.float32,0x6744e0,0x6744e0,2 +np.float32,0x695e8b,0x695e8b,2 +np.float32,0xbee3888a,0xbed5a67d,2 +np.float32,0x7f64bc2a,0x3f800000,2 +np.float32,0x7f204244,0x3f800000,2 +np.float32,0x7f647102,0x3f800000,2 +np.float32,0x3dd8ebc0,0x3dd81d03,2 +np.float32,0x801e7ab1,0x801e7ab1,2 +np.float32,0x7d034b56,0x3f800000,2 +np.float32,0x7fc00000,0x7fc00000,2 +np.float32,0x80194193,0x80194193,2 +np.float32,0xfe31c8d4,0xbf800000,2 +np.float32,0x7fc0c4,0x7fc0c4,2 +np.float32,0xd95bf,0xd95bf,2 +np.float32,0x7e4f991d,0x3f800000,2 +np.float32,0x7fc563,0x7fc563,2 +np.float32,0xbe3fcccc,0xbe3d968a,2 +np.float32,0xfdaaa1c8,0xbf800000,2 +np.float32,0xbf48e449,0xbf27c949,2 +np.float32,0x3eb6c584,0x3eaf625e,2 +np.float32,0xbea35a74,0xbe9e0702,2 +np.float32,0x3eeab47a,0x3edb89d5,2 +np.float32,0xbed99556,0xbecd5de5,2 +np.float64,0xbfb94a81e0329500,0xbfb935867ba761fe,2 +np.float64,0xbfec132f1678265e,0xbfe6900eb097abc3,2 +np.float64,0x5685ea72ad0be,0x5685ea72ad0be,2 +np.float64,0xbfd74d3169ae9a62,0xbfd652e09b9daf32,2 +np.float64,0xbfe28df53d651bea,0xbfe0b8a7f50ab433,2 +np.float64,0x0,0x0,2 +np.float64,0xbfed912738bb224e,0xbfe749e3732831ae,2 +np.float64,0x7fcc6faed838df5d,0x3ff0000000000000,2 +np.float64,0xbfe95fe9a432bfd3,0xbfe51f6349919910,2 +np.float64,0xbfc4d5900b29ab20,0xbfc4a6f496179b8b,2 +np.float64,0xbfcd6025033ac04c,0xbfccded7b34b49b0,2 +np.float64,0xbfdfa655b43f4cac,0xbfdd4ca1e5bb9db8,2 +np.float64,0xe7ea5c7fcfd4c,0xe7ea5c7fcfd4c,2 +np.float64,0xffa5449ca42a8940,0xbff0000000000000,2 +np.float64,0xffe63294c1ac6529,0xbff0000000000000,2 +np.float64,0x7feb9cbae7f73975,0x3ff0000000000000,2 +np.float64,0x800eb07c3e3d60f9,0x800eb07c3e3d60f9,2 +np.float64,0x3fc95777e932aef0,0x3fc9040391e20c00,2 +np.float64,0x800736052dee6c0b,0x800736052dee6c0b,2 +np.float64,0x3fe9ae4afd335c96,0x3fe54b569bab45c7,2 +np.float64,0x7fee4c94217c9927,0x3ff0000000000000,2 +np.float64,0x80094b594bd296b3,0x80094b594bd296b3,2 +np.float64,0xffe5adbcee6b5b7a,0xbff0000000000000,2 +np.float64,0x3fecb8eab47971d5,0x3fe6e236be6f27e9,2 +np.float64,0x44956914892ae,0x44956914892ae,2 +np.float64,0xbfe3bd18ef677a32,0xbfe190bf1e07200c,2 +np.float64,0x800104e5b46209cc,0x800104e5b46209cc,2 +np.float64,0x8008fbcecf71f79e,0x8008fbcecf71f79e,2 +np.float64,0x800f0a46a0be148d,0x800f0a46a0be148d,2 +np.float64,0x7fe657a0702caf40,0x3ff0000000000000,2 +np.float64,0xffd3ff1a9027fe36,0xbff0000000000000,2 +np.float64,0x3fe78bc87bef1790,0x3fe40d2e63aaf029,2 +np.float64,0x7feeabdc4c7d57b8,0x3ff0000000000000,2 +np.float64,0xbfabd28d8437a520,0xbfabcb8ce03a0e56,2 +np.float64,0xbfddc3a133bb8742,0xbfdbc9fdb2594451,2 +np.float64,0x7fec911565b9222a,0x3ff0000000000000,2 +np.float64,0x71302604e2605,0x71302604e2605,2 +np.float64,0xee919d2bdd234,0xee919d2bdd234,2 +np.float64,0xbfc04fcff3209fa0,0xbfc0395a739a2ce4,2 +np.float64,0xffe4668a36e8cd14,0xbff0000000000000,2 +np.float64,0xbfeeafeebefd5fde,0xbfe7cd5f3d61a3ec,2 +np.float64,0x7fddb34219bb6683,0x3ff0000000000000,2 +np.float64,0xbfd2cac6cba5958e,0xbfd24520abb2ff36,2 +np.float64,0xbfb857e49630afc8,0xbfb8452d5064dec2,2 +np.float64,0x3fd2dbf90b25b7f2,0x3fd254eaf48484c2,2 +np.float64,0x800af65c94f5ecba,0x800af65c94f5ecba,2 +np.float64,0xa0eef4bf41ddf,0xa0eef4bf41ddf,2 +np.float64,0xffd8e0a4adb1c14a,0xbff0000000000000,2 +np.float64,0xffe858f6e870b1ed,0xbff0000000000000,2 +np.float64,0x3f94c2c308298580,0x3f94c208a4bb006d,2 +np.float64,0xffb45f0d7428be18,0xbff0000000000000,2 +np.float64,0x800ed4f43dbda9e9,0x800ed4f43dbda9e9,2 +np.float64,0x8002dd697e85bad4,0x8002dd697e85bad4,2 +np.float64,0x787ceab2f0f9e,0x787ceab2f0f9e,2 +np.float64,0xbfdff5fcc2bfebfa,0xbfdd8b736b128589,2 +np.float64,0x7fdb2b4294365684,0x3ff0000000000000,2 +np.float64,0xffe711e5e92e23cc,0xbff0000000000000,2 +np.float64,0x800b1c93f1163928,0x800b1c93f1163928,2 +np.float64,0x7fc524d2f22a49a5,0x3ff0000000000000,2 +np.float64,0x7fc88013b5310026,0x3ff0000000000000,2 +np.float64,0x3fe1a910c5e35222,0x3fe00fd779ebaa2a,2 +np.float64,0xbfb57ec9ca2afd90,0xbfb571e47ecb9335,2 +np.float64,0x7fd7594b20aeb295,0x3ff0000000000000,2 +np.float64,0x7fba4641ca348c83,0x3ff0000000000000,2 +np.float64,0xffe61393706c2726,0xbff0000000000000,2 +np.float64,0x7fd54f3c7baa9e78,0x3ff0000000000000,2 +np.float64,0xffe65ffb12ecbff6,0xbff0000000000000,2 +np.float64,0xbfba3b0376347608,0xbfba239cbbbd1b11,2 +np.float64,0x800200886d640112,0x800200886d640112,2 +np.float64,0xbfecf0ba4679e174,0xbfe6fd59de44a3ec,2 +np.float64,0xffe5c57e122b8afc,0xbff0000000000000,2 +np.float64,0x7fdaad0143355a02,0x3ff0000000000000,2 +np.float64,0x46ab32c08d567,0x46ab32c08d567,2 +np.float64,0x7ff8000000000000,0x7ff8000000000000,2 +np.float64,0xbfda7980fdb4f302,0xbfd90fa9c8066109,2 +np.float64,0x3fe237703c646ee0,0x3fe07969f8d8805a,2 +np.float64,0x8000e9fcfc21d3fb,0x8000e9fcfc21d3fb,2 +np.float64,0xbfdfe6e958bfcdd2,0xbfdd7f952fe87770,2 +np.float64,0xbd7baf217af8,0xbd7baf217af8,2 +np.float64,0xbfceba9e4b3d753c,0xbfce26e54359869a,2 +np.float64,0xb95a2caf72b46,0xb95a2caf72b46,2 +np.float64,0x3fb407e25a280fc5,0x3fb3fd71e457b628,2 +np.float64,0xa1da09d943b41,0xa1da09d943b41,2 +np.float64,0xbfe9c7271cf38e4e,0xbfe559296b471738,2 +np.float64,0x3fefae6170ff5cc3,0x3fe83c70ba82f0e1,2 +np.float64,0x7fe7375348ae6ea6,0x3ff0000000000000,2 +np.float64,0xffe18c9cc6e31939,0xbff0000000000000,2 +np.float64,0x800483d13a6907a3,0x800483d13a6907a3,2 +np.float64,0x7fe772a18caee542,0x3ff0000000000000,2 +np.float64,0xffefff64e7bffec9,0xbff0000000000000,2 +np.float64,0x7fcffc31113ff861,0x3ff0000000000000,2 +np.float64,0x3fd91e067e323c0d,0x3fd7e70bf365a7b3,2 +np.float64,0xb0a6673d614cd,0xb0a6673d614cd,2 +np.float64,0xffef9a297e3f3452,0xbff0000000000000,2 +np.float64,0xffe87cc15e70f982,0xbff0000000000000,2 +np.float64,0xffefd6ad8e7fad5a,0xbff0000000000000,2 +np.float64,0x7fe3aaa3a8a75546,0x3ff0000000000000,2 +np.float64,0xddab0341bb561,0xddab0341bb561,2 +np.float64,0x3fe996d6d7332dae,0x3fe53e3ed5be2922,2 +np.float64,0x3fdbe66a18b7ccd4,0x3fda41e6053c1512,2 +np.float64,0x8914775d1228f,0x8914775d1228f,2 +np.float64,0x3fe44621d4688c44,0x3fe1ef9c7225f8bd,2 +np.float64,0xffab29a2a4365340,0xbff0000000000000,2 +np.float64,0xffc8d4a0c431a940,0xbff0000000000000,2 +np.float64,0xbfd426e085284dc2,0xbfd382e2a9617b87,2 +np.float64,0xbfd3b0a525a7614a,0xbfd3176856faccf1,2 +np.float64,0x80036dedcb06dbdc,0x80036dedcb06dbdc,2 +np.float64,0x3feb13823b762704,0x3fe60ca3facdb696,2 +np.float64,0x3fd7246b7bae48d8,0x3fd62f08afded155,2 +np.float64,0x1,0x1,2 +np.float64,0x3fe8ade4b9715bc9,0x3fe4b97cc1387d27,2 +np.float64,0x3fdf2dbec53e5b7e,0x3fdcecfeee33de95,2 +np.float64,0x3fe4292bf9685258,0x3fe1dbb5a6704090,2 +np.float64,0xbfd21acbb8243598,0xbfd1a2ff42174cae,2 +np.float64,0xdd0d2d01ba1a6,0xdd0d2d01ba1a6,2 +np.float64,0x3fa3f3d2f427e7a0,0x3fa3f13d6f101555,2 +np.float64,0x7fdabf4aceb57e95,0x3ff0000000000000,2 +np.float64,0xd4d9e39ba9b3d,0xd4d9e39ba9b3d,2 +np.float64,0xffec773396f8ee66,0xbff0000000000000,2 +np.float64,0x3fa88cc79031198f,0x3fa887f7ade722ba,2 +np.float64,0xffe63a92066c7524,0xbff0000000000000,2 +np.float64,0xbfcf514e2e3ea29c,0xbfceb510e99aaa19,2 +np.float64,0x9d78c19d3af18,0x9d78c19d3af18,2 +np.float64,0x7fdd748bfbbae917,0x3ff0000000000000,2 +np.float64,0xffb3594c4626b298,0xbff0000000000000,2 +np.float64,0x80068ce5b32d19cc,0x80068ce5b32d19cc,2 +np.float64,0x3fec63d60e78c7ac,0x3fe6b85536e44217,2 +np.float64,0x80080bad4dd0175b,0x80080bad4dd0175b,2 +np.float64,0xbfec6807baf8d010,0xbfe6ba69740f9687,2 +np.float64,0x7fedbae0bbfb75c0,0x3ff0000000000000,2 +np.float64,0x8001cb7aa3c396f6,0x8001cb7aa3c396f6,2 +np.float64,0x7fe1f1f03563e3df,0x3ff0000000000000,2 +np.float64,0x7fd83d3978307a72,0x3ff0000000000000,2 +np.float64,0xbfc05ffe9d20bffc,0xbfc049464e3f0af2,2 +np.float64,0xfe6e053ffcdc1,0xfe6e053ffcdc1,2 +np.float64,0xbfd3bdf39d277be8,0xbfd32386edf12726,2 +np.float64,0x800f41b27bde8365,0x800f41b27bde8365,2 +np.float64,0xbfe2c98390e59307,0xbfe0e3c9260fe798,2 +np.float64,0xffdd6206bcbac40e,0xbff0000000000000,2 +np.float64,0x67f35ef4cfe6c,0x67f35ef4cfe6c,2 +np.float64,0x800337e02ae66fc1,0x800337e02ae66fc1,2 +np.float64,0x3fe0ff70afe1fee1,0x3fdf1f46434330df,2 +np.float64,0x3fd7e0a1df2fc144,0x3fd6d3f82c8031e4,2 +np.float64,0x8008da5cd1b1b4ba,0x8008da5cd1b1b4ba,2 +np.float64,0x80065ec9e4ccbd95,0x80065ec9e4ccbd95,2 +np.float64,0x3fe1d1e559a3a3cb,0x3fe02e4f146aa1ab,2 +np.float64,0x7feb7d2f0836fa5d,0x3ff0000000000000,2 +np.float64,0xbfcb33ce9736679c,0xbfcaccd431b205bb,2 +np.float64,0x800e6d0adf5cda16,0x800e6d0adf5cda16,2 +np.float64,0x7fe46f272ca8de4d,0x3ff0000000000000,2 +np.float64,0x4fdfc73e9fbfa,0x4fdfc73e9fbfa,2 +np.float64,0x800958a13112b143,0x800958a13112b143,2 +np.float64,0xbfea01f877f403f1,0xbfe579a541594247,2 +np.float64,0xeefaf599ddf5f,0xeefaf599ddf5f,2 +np.float64,0x80038766c5e70ece,0x80038766c5e70ece,2 +np.float64,0x7fd31bc28ba63784,0x3ff0000000000000,2 +np.float64,0xbfe4df77eee9bef0,0xbfe257abe7083b77,2 +np.float64,0x7fe6790c78acf218,0x3ff0000000000000,2 +np.float64,0xffe7c66884af8cd0,0xbff0000000000000,2 +np.float64,0x800115e36f422bc8,0x800115e36f422bc8,2 +np.float64,0x3fc601945d2c0329,0x3fc5cab917bb20bc,2 +np.float64,0x3fd6ac9546ad592b,0x3fd5c55437ec3508,2 +np.float64,0xa7bd59294f7ab,0xa7bd59294f7ab,2 +np.float64,0x8005c26c8b8b84da,0x8005c26c8b8b84da,2 +np.float64,0x8257501704aea,0x8257501704aea,2 +np.float64,0x5b12aae0b6256,0x5b12aae0b6256,2 +np.float64,0x800232fe02c465fd,0x800232fe02c465fd,2 +np.float64,0x800dae28f85b5c52,0x800dae28f85b5c52,2 +np.float64,0x3fdade1ac135bc36,0x3fd964a2000ace25,2 +np.float64,0x3fed72ca04fae594,0x3fe73b9170d809f9,2 +np.float64,0x7fc6397e2b2c72fb,0x3ff0000000000000,2 +np.float64,0x3fe1f5296d23ea53,0x3fe048802d17621e,2 +np.float64,0xffe05544b920aa89,0xbff0000000000000,2 +np.float64,0xbfdb2e1588365c2c,0xbfd9a7e4113c713e,2 +np.float64,0xbfed6a06fa3ad40e,0xbfe7376be60535f8,2 +np.float64,0xbfe31dcaf5e63b96,0xbfe120417c46cac1,2 +np.float64,0xbfb7ed67ae2fdad0,0xbfb7dba14af33b00,2 +np.float64,0xffd32bb7eb265770,0xbff0000000000000,2 +np.float64,0x80039877b04730f0,0x80039877b04730f0,2 +np.float64,0x3f832e5630265cac,0x3f832e316f47f218,2 +np.float64,0xffe7fa7f732ff4fe,0xbff0000000000000,2 +np.float64,0x9649b87f2c937,0x9649b87f2c937,2 +np.float64,0xffaee447183dc890,0xbff0000000000000,2 +np.float64,0x7fe4e02dd869c05b,0x3ff0000000000000,2 +np.float64,0x3fe1d35e7463a6bd,0x3fe02f67bd21e86e,2 +np.float64,0xffe57f40fe2afe82,0xbff0000000000000,2 +np.float64,0xbfea1362b93426c6,0xbfe5833421dba8fc,2 +np.float64,0xffe9c689fe338d13,0xbff0000000000000,2 +np.float64,0xffc592dd102b25bc,0xbff0000000000000,2 +np.float64,0x3fd283c7aba5078f,0x3fd203d61d1398c3,2 +np.float64,0x8001d6820243ad05,0x8001d6820243ad05,2 +np.float64,0x3fe0ad5991e15ab4,0x3fdea14ef0d47fbd,2 +np.float64,0x3fe3916f2ee722de,0x3fe1722684a9ffb1,2 +np.float64,0xffef9e54e03f3ca9,0xbff0000000000000,2 +np.float64,0x7fe864faebb0c9f5,0x3ff0000000000000,2 +np.float64,0xbfed3587c3fa6b10,0xbfe71e7112df8a68,2 +np.float64,0xbfdd9efc643b3df8,0xbfdbac3a16caf208,2 +np.float64,0xbfd5ac08feab5812,0xbfd4e14575a6e41b,2 +np.float64,0xffda90fae6b521f6,0xbff0000000000000,2 +np.float64,0x8001380ecf22701e,0x8001380ecf22701e,2 +np.float64,0x7fed266fa5fa4cde,0x3ff0000000000000,2 +np.float64,0xffec6c0ac3b8d815,0xbff0000000000000,2 +np.float64,0x3fe7de43c32fbc88,0x3fe43ef62821a5a6,2 +np.float64,0x800bf4ffc357ea00,0x800bf4ffc357ea00,2 +np.float64,0x3fe125c975624b93,0x3fdf59b2de3eff5d,2 +np.float64,0x8004714c1028e299,0x8004714c1028e299,2 +np.float64,0x3fef1bfbf5fe37f8,0x3fe7fd2ba1b63c8a,2 +np.float64,0x800cae15c3195c2c,0x800cae15c3195c2c,2 +np.float64,0x7fde708e083ce11b,0x3ff0000000000000,2 +np.float64,0x7fbcee5df639dcbb,0x3ff0000000000000,2 +np.float64,0x800b1467141628cf,0x800b1467141628cf,2 +np.float64,0x3fe525e0d36a4bc2,0x3fe286b6e59e30f5,2 +np.float64,0xffe987f8b8330ff1,0xbff0000000000000,2 +np.float64,0x7e0a8284fc151,0x7e0a8284fc151,2 +np.float64,0x8006f982442df305,0x8006f982442df305,2 +np.float64,0xbfd75a3cb62eb47a,0xbfd65e54cee981c9,2 +np.float64,0x258e91104b1d3,0x258e91104b1d3,2 +np.float64,0xbfecd0056779a00b,0xbfe6ed7ae97fff1b,2 +np.float64,0x7fc3a4f9122749f1,0x3ff0000000000000,2 +np.float64,0x6e2b1024dc563,0x6e2b1024dc563,2 +np.float64,0x800d575ad4daaeb6,0x800d575ad4daaeb6,2 +np.float64,0xbfceafb1073d5f64,0xbfce1c93023d8414,2 +np.float64,0xffe895cb5f312b96,0xbff0000000000000,2 +np.float64,0x7fe7811ed4ef023d,0x3ff0000000000000,2 +np.float64,0xbfd93f952f327f2a,0xbfd803e6b5576b99,2 +np.float64,0xffdd883a3fbb1074,0xbff0000000000000,2 +np.float64,0x7fee5624eefcac49,0x3ff0000000000000,2 +np.float64,0xbfe264bb2624c976,0xbfe09a9b7cc896e7,2 +np.float64,0xffef14b417be2967,0xbff0000000000000,2 +np.float64,0xbfecbd0d94397a1b,0xbfe6e43bef852d9f,2 +np.float64,0xbfe20d9e4ba41b3c,0xbfe05a98e05846d9,2 +np.float64,0x10000000000000,0x10000000000000,2 +np.float64,0x7fefde93f7bfbd27,0x3ff0000000000000,2 +np.float64,0x80076b9e232ed73d,0x80076b9e232ed73d,2 +np.float64,0xbfe80df52c701bea,0xbfe45b754b433792,2 +np.float64,0x7fe3b5a637676b4b,0x3ff0000000000000,2 +np.float64,0x2c81d14c5903b,0x2c81d14c5903b,2 +np.float64,0x80038945c767128c,0x80038945c767128c,2 +np.float64,0xffeebaf544bd75ea,0xbff0000000000000,2 +np.float64,0xffdb1867d2b630d0,0xbff0000000000000,2 +np.float64,0x3fe3376eaee66ede,0x3fe13285579763d8,2 +np.float64,0xffddf65ca43becba,0xbff0000000000000,2 +np.float64,0xffec8e3e04791c7b,0xbff0000000000000,2 +np.float64,0x80064f4bde2c9e98,0x80064f4bde2c9e98,2 +np.float64,0x7fe534a085ea6940,0x3ff0000000000000,2 +np.float64,0xbfcbabe31d3757c8,0xbfcb3f8e70adf7e7,2 +np.float64,0xbfe45ca11e28b942,0xbfe1ff04515ef809,2 +np.float64,0x65f4df02cbe9d,0x65f4df02cbe9d,2 +np.float64,0xb08b0cbb61162,0xb08b0cbb61162,2 +np.float64,0x3feae2e8b975c5d1,0x3fe5f302b5e8eda2,2 +np.float64,0x7fcf277ff93e4eff,0x3ff0000000000000,2 +np.float64,0x80010999c4821334,0x80010999c4821334,2 +np.float64,0xbfd7f65911afecb2,0xbfd6e6e9cd098f8b,2 +np.float64,0x800e0560ec3c0ac2,0x800e0560ec3c0ac2,2 +np.float64,0x7fec4152ba3882a4,0x3ff0000000000000,2 +np.float64,0xbfb5c77cd42b8ef8,0xbfb5ba1336084908,2 +np.float64,0x457ff1b68afff,0x457ff1b68afff,2 +np.float64,0x5323ec56a647e,0x5323ec56a647e,2 +np.float64,0xbfeed16cf8bda2da,0xbfe7dc49fc9ae549,2 +np.float64,0xffe8446106b088c1,0xbff0000000000000,2 +np.float64,0xffb93cd13c3279a0,0xbff0000000000000,2 +np.float64,0x7fe515c2aeea2b84,0x3ff0000000000000,2 +np.float64,0x80099df83f933bf1,0x80099df83f933bf1,2 +np.float64,0x7fb3a375562746ea,0x3ff0000000000000,2 +np.float64,0x7fcd7efa243afdf3,0x3ff0000000000000,2 +np.float64,0xffe40cddb12819bb,0xbff0000000000000,2 +np.float64,0x8008b68eecd16d1e,0x8008b68eecd16d1e,2 +np.float64,0x2aec688055d8e,0x2aec688055d8e,2 +np.float64,0xffe23750bc646ea1,0xbff0000000000000,2 +np.float64,0x5adacf60b5b7,0x5adacf60b5b7,2 +np.float64,0x7fefb29b1cbf6535,0x3ff0000000000000,2 +np.float64,0xbfeadbf90175b7f2,0xbfe5ef55e2194794,2 +np.float64,0xeaad2885d55a5,0xeaad2885d55a5,2 +np.float64,0xffd7939fba2f2740,0xbff0000000000000,2 +np.float64,0x3fd187ea3aa30fd4,0x3fd11af023472386,2 +np.float64,0xbf6eb579c03d6b00,0xbf6eb57052f47019,2 +np.float64,0x3fefb67b3bff6cf6,0x3fe83fe4499969ac,2 +np.float64,0xbfe5183aacea3076,0xbfe27da1aa0b61a0,2 +np.float64,0xbfb83e47a2307c90,0xbfb82bcb0e12db42,2 +np.float64,0x80088849b1b11094,0x80088849b1b11094,2 +np.float64,0x800ceeed7399dddb,0x800ceeed7399dddb,2 +np.float64,0x80097cd90892f9b2,0x80097cd90892f9b2,2 +np.float64,0x7ec73feefd8e9,0x7ec73feefd8e9,2 +np.float64,0x7fe3291de5a6523b,0x3ff0000000000000,2 +np.float64,0xbfd537086daa6e10,0xbfd4787af5f60653,2 +np.float64,0x800e8ed4455d1da9,0x800e8ed4455d1da9,2 +np.float64,0x800ef8d19cbdf1a3,0x800ef8d19cbdf1a3,2 +np.float64,0x800dc4fa3a5b89f5,0x800dc4fa3a5b89f5,2 +np.float64,0xaa8b85cd55171,0xaa8b85cd55171,2 +np.float64,0xffd67a5f40acf4be,0xbff0000000000000,2 +np.float64,0xbfb7496db22e92d8,0xbfb7390a48130861,2 +np.float64,0x3fd86a8e7ab0d51d,0x3fd74bfba0f72616,2 +np.float64,0xffb7f5b7fc2feb70,0xbff0000000000000,2 +np.float64,0xbfea0960a7f412c1,0xbfe57db6d0ff4191,2 +np.float64,0x375f4fc26ebeb,0x375f4fc26ebeb,2 +np.float64,0x800c537e70b8a6fd,0x800c537e70b8a6fd,2 +np.float64,0x800b3f4506d67e8a,0x800b3f4506d67e8a,2 +np.float64,0x7fe61f2d592c3e5a,0x3ff0000000000000,2 +np.float64,0xffefffffffffffff,0xbff0000000000000,2 +np.float64,0x8005d0bb84eba178,0x8005d0bb84eba178,2 +np.float64,0x800c78b0ec18f162,0x800c78b0ec18f162,2 +np.float64,0xbfc42cccfb285998,0xbfc4027392f66b0d,2 +np.float64,0x3fd8fdc73fb1fb8e,0x3fd7cb46f928153f,2 +np.float64,0x800c71754298e2eb,0x800c71754298e2eb,2 +np.float64,0x3fe4aa7a96a954f5,0x3fe233f5d3bc1352,2 +np.float64,0x7fd53841f6aa7083,0x3ff0000000000000,2 +np.float64,0x3fd0a887b8a15110,0x3fd04ac3b9c0d1ca,2 +np.float64,0x8007b8e164cf71c4,0x8007b8e164cf71c4,2 +np.float64,0xbfddc35c66bb86b8,0xbfdbc9c5dddfb014,2 +np.float64,0x6a3756fed46eb,0x6a3756fed46eb,2 +np.float64,0xffd3dcd05527b9a0,0xbff0000000000000,2 +np.float64,0xbfd7dc75632fb8ea,0xbfd6d0538b340a98,2 +np.float64,0x17501f822ea05,0x17501f822ea05,2 +np.float64,0xbfe1f98b99a3f317,0xbfe04bbf8f8b6cb3,2 +np.float64,0x66ea65d2cdd4d,0x66ea65d2cdd4d,2 +np.float64,0xbfd12241e2224484,0xbfd0bc62f46ea5e1,2 +np.float64,0x3fed6e6fb3fadcdf,0x3fe7398249097285,2 +np.float64,0x3fe0b5ebeba16bd8,0x3fdeae84b3000a47,2 +np.float64,0x66d1bce8cda38,0x66d1bce8cda38,2 +np.float64,0x3fdd728db3bae51b,0x3fdb880f28c52713,2 +np.float64,0xffb45dbe5228bb80,0xbff0000000000000,2 +np.float64,0x1ff8990c3ff14,0x1ff8990c3ff14,2 +np.float64,0x800a68e8f294d1d2,0x800a68e8f294d1d2,2 +np.float64,0xbfe4d08b84a9a117,0xbfe24da40bff6be7,2 +np.float64,0x3fe0177f0ee02efe,0x3fddb83c5971df51,2 +np.float64,0xffc56893692ad128,0xbff0000000000000,2 +np.float64,0x51b44f6aa368b,0x51b44f6aa368b,2 +np.float64,0x2258ff4e44b21,0x2258ff4e44b21,2 +np.float64,0x3fe913649e7226c9,0x3fe4f3f119530f53,2 +np.float64,0xffe3767df766ecfc,0xbff0000000000000,2 +np.float64,0xbfe62ae12fec55c2,0xbfe33108f1f22a94,2 +np.float64,0x7fb6a6308e2d4c60,0x3ff0000000000000,2 +np.float64,0xbfe00f2085e01e41,0xbfddab19b6fc77d1,2 +np.float64,0x3fb66447dc2cc890,0x3fb655b4f46844f0,2 +np.float64,0x3fd80238f6b00470,0x3fd6f143be1617d6,2 +np.float64,0xbfd05bfeb3a0b7fe,0xbfd0031ab3455e15,2 +np.float64,0xffc3a50351274a08,0xbff0000000000000,2 +np.float64,0xffd8f4241cb1e848,0xbff0000000000000,2 +np.float64,0xbfca72a88c34e550,0xbfca13ebe85f2aca,2 +np.float64,0x3fd47d683ba8fad0,0x3fd3d13f1176ed8c,2 +np.float64,0x3fb6418e642c831d,0x3fb6333ebe479ff2,2 +np.float64,0x800fde8e023fbd1c,0x800fde8e023fbd1c,2 +np.float64,0x8001fb01e323f605,0x8001fb01e323f605,2 +np.float64,0x3febb21ff9f76440,0x3fe65ed788d52fee,2 +np.float64,0x3fe47553ffe8eaa8,0x3fe20fe01f853603,2 +np.float64,0x7fca20b3f9344167,0x3ff0000000000000,2 +np.float64,0x3fe704f4ec6e09ea,0x3fe3ba7277201805,2 +np.float64,0xf864359df0c87,0xf864359df0c87,2 +np.float64,0x4d96b01c9b2d7,0x4d96b01c9b2d7,2 +np.float64,0x3fe8a09fe9f14140,0x3fe4b1c6a2d2e095,2 +np.float64,0xffc46c61b228d8c4,0xbff0000000000000,2 +np.float64,0x3fe680a837ed0150,0x3fe3679d6eeb6485,2 +np.float64,0xbfecedc20f39db84,0xbfe6fbe9ee978bf6,2 +np.float64,0x3fb2314eae24629d,0x3fb2297ba6d55d2d,2 +np.float64,0x3fe9f0b8e7b3e172,0x3fe57026eae36db3,2 +np.float64,0x80097a132ed2f427,0x80097a132ed2f427,2 +np.float64,0x800ae5a41955cb49,0x800ae5a41955cb49,2 +np.float64,0xbfd7527279aea4e4,0xbfd6577de356e1bd,2 +np.float64,0x3fe27d3e01e4fa7c,0x3fe0ac7dd96f9179,2 +np.float64,0x7fedd8cb01bbb195,0x3ff0000000000000,2 +np.float64,0x78f8695af1f0e,0x78f8695af1f0e,2 +np.float64,0x800d2d0e927a5a1d,0x800d2d0e927a5a1d,2 +np.float64,0xffe74b46fb2e968e,0xbff0000000000000,2 +np.float64,0xbfdd12d4c8ba25aa,0xbfdb39dae49e1c10,2 +np.float64,0xbfd6c14710ad828e,0xbfd5d79ef5a8d921,2 +np.float64,0x921f4e55243ea,0x921f4e55243ea,2 +np.float64,0x800b4e4c80969c99,0x800b4e4c80969c99,2 +np.float64,0x7fe08c6ab7e118d4,0x3ff0000000000000,2 +np.float64,0xbfed290014fa5200,0xbfe71871f7e859ed,2 +np.float64,0x8008c1d5c59183ac,0x8008c1d5c59183ac,2 +np.float64,0x3fd339e68c2673cd,0x3fd2aaff3f165a9d,2 +np.float64,0xbfdd20d8113a41b0,0xbfdb4553ea2cb2fb,2 +np.float64,0x3fe52a25deea544c,0x3fe2898d5bf4442c,2 +np.float64,0x498602d4930c1,0x498602d4930c1,2 +np.float64,0x3fd8c450113188a0,0x3fd799b0b2a6c43c,2 +np.float64,0xbfd72bc2f2ae5786,0xbfd6357e15ba7f70,2 +np.float64,0xbfd076188ea0ec32,0xbfd01b8fce44d1af,2 +np.float64,0x9aace1713559c,0x9aace1713559c,2 +np.float64,0x8008a730e8914e62,0x8008a730e8914e62,2 +np.float64,0x7fe9e9a3d833d347,0x3ff0000000000000,2 +np.float64,0x800d3a0d69da741b,0x800d3a0d69da741b,2 +np.float64,0xbfe3e28a29e7c514,0xbfe1aad7643a2d19,2 +np.float64,0x7fe9894c71331298,0x3ff0000000000000,2 +np.float64,0xbfe7c6acb5ef8d5a,0xbfe430c9e258ce62,2 +np.float64,0xffb5a520a62b4a40,0xbff0000000000000,2 +np.float64,0x7fc02109ae204212,0x3ff0000000000000,2 +np.float64,0xb5c58f196b8b2,0xb5c58f196b8b2,2 +np.float64,0x3feb4ee82e769dd0,0x3fe62bae9a39d8b1,2 +np.float64,0x3fec5c3cf278b87a,0x3fe6b49000f12441,2 +np.float64,0x81f64b8103eca,0x81f64b8103eca,2 +np.float64,0xbfeab00d73f5601b,0xbfe5d7f755ab73d9,2 +np.float64,0x3fd016bf28a02d7e,0x3fcf843ea23bcd3c,2 +np.float64,0xbfa1db617423b6c0,0xbfa1d9872ddeb5a8,2 +np.float64,0x3fe83c879d70790f,0x3fe4771502d8f012,2 +np.float64,0x6b267586d64cf,0x6b267586d64cf,2 +np.float64,0x3fc91b6d3f3236d8,0x3fc8ca3eb4da25a9,2 +np.float64,0x7fd4e3f8f3a9c7f1,0x3ff0000000000000,2 +np.float64,0x800a75899214eb14,0x800a75899214eb14,2 +np.float64,0x7fdb1f2e07b63e5b,0x3ff0000000000000,2 +np.float64,0xffe7805a11ef00b4,0xbff0000000000000,2 +np.float64,0x3fc8e1b88a31c371,0x3fc892af45330818,2 +np.float64,0xbfe809fe447013fc,0xbfe45918f07da4d9,2 +np.float64,0xbfeb9d7f2ab73afe,0xbfe65446bfddc792,2 +np.float64,0x3fb47f0a5c28fe15,0x3fb473db9113e880,2 +np.float64,0x800a17ae3cb42f5d,0x800a17ae3cb42f5d,2 +np.float64,0xf5540945eaa81,0xf5540945eaa81,2 +np.float64,0xbfe577fc26aaeff8,0xbfe2bcfbf2cf69ff,2 +np.float64,0xbfb99b3e06333680,0xbfb98577b88e0515,2 +np.float64,0x7fd9290391b25206,0x3ff0000000000000,2 +np.float64,0x7fe1aa62ffa354c5,0x3ff0000000000000,2 +np.float64,0x7b0189a0f604,0x7b0189a0f604,2 +np.float64,0x3f9000ed602001db,0x3f900097fe168105,2 +np.float64,0x3fd576128d2aec25,0x3fd4b1002c92286f,2 +np.float64,0xffecc98ece79931d,0xbff0000000000000,2 +np.float64,0x800a1736c7f42e6e,0x800a1736c7f42e6e,2 +np.float64,0xbfed947548bb28eb,0xbfe74b71479ae739,2 +np.float64,0xa45c032148b9,0xa45c032148b9,2 +np.float64,0xbfc13d011c227a04,0xbfc1228447de5e9f,2 +np.float64,0xffed8baa6ebb1754,0xbff0000000000000,2 +np.float64,0x800ea2de243d45bc,0x800ea2de243d45bc,2 +np.float64,0x8001396be52272d9,0x8001396be52272d9,2 +np.float64,0xd018d1cda031a,0xd018d1cda031a,2 +np.float64,0x7fe1fece1fe3fd9b,0x3ff0000000000000,2 +np.float64,0x8009ac484c135891,0x8009ac484c135891,2 +np.float64,0x3fc560ad132ac15a,0x3fc52e5a9479f08e,2 +np.float64,0x3fd6f80ebe2df01d,0x3fd607f70ce8e3f4,2 +np.float64,0xbfd3e69e82a7cd3e,0xbfd34887c2a40699,2 +np.float64,0x3fe232d9baa465b3,0x3fe0760a822ada0c,2 +np.float64,0x3fe769bbc6eed378,0x3fe3f872680f6631,2 +np.float64,0xffe63dbd952c7b7a,0xbff0000000000000,2 +np.float64,0x4e0c00da9c181,0x4e0c00da9c181,2 +np.float64,0xffeae4d89735c9b0,0xbff0000000000000,2 +np.float64,0x3fe030bcbb606179,0x3fdddfc66660bfce,2 +np.float64,0x7fe35ca40d66b947,0x3ff0000000000000,2 +np.float64,0xbfd45bd66628b7ac,0xbfd3b2e04bfe7866,2 +np.float64,0x3fd1f0be2323e17c,0x3fd17c1c340d7a48,2 +np.float64,0x3fd7123b6cae2478,0x3fd61f0675aa9ae1,2 +np.float64,0xbfe918a377723147,0xbfe4f6efe66f5714,2 +np.float64,0x7fc400356f28006a,0x3ff0000000000000,2 +np.float64,0x7fd2dead70a5bd5a,0x3ff0000000000000,2 +np.float64,0xffe9c28f81f3851e,0xbff0000000000000,2 +np.float64,0x3fd09b1ec7a1363e,0x3fd03e3894320140,2 +np.float64,0x7fe6e80c646dd018,0x3ff0000000000000,2 +np.float64,0x7fec3760a4786ec0,0x3ff0000000000000,2 +np.float64,0x309eb6ee613d8,0x309eb6ee613d8,2 +np.float64,0x800731cb0ece6397,0x800731cb0ece6397,2 +np.float64,0xbfdb0c553db618aa,0xbfd98b8a4680ee60,2 +np.float64,0x3fd603a52eac074c,0x3fd52f6b53de7455,2 +np.float64,0x9ecb821b3d971,0x9ecb821b3d971,2 +np.float64,0x3feb7d64dc36faca,0x3fe643c2754bb7f4,2 +np.float64,0xffeb94825ef72904,0xbff0000000000000,2 +np.float64,0x24267418484cf,0x24267418484cf,2 +np.float64,0xbfa6b2fbac2d65f0,0xbfa6af2dca5bfa6f,2 +np.float64,0x8010000000000000,0x8010000000000000,2 +np.float64,0xffe6873978ed0e72,0xbff0000000000000,2 +np.float64,0x800447934ba88f27,0x800447934ba88f27,2 +np.float64,0x3fef305f09fe60be,0x3fe806156b8ca47c,2 +np.float64,0xffd441c697a8838e,0xbff0000000000000,2 +np.float64,0xbfa7684f6c2ed0a0,0xbfa764238d34830c,2 +np.float64,0xffb2c976142592f0,0xbff0000000000000,2 +np.float64,0xbfcc9d1585393a2c,0xbfcc25756bcbca1f,2 +np.float64,0xbfd477bb1ba8ef76,0xbfd3cc1d2114e77e,2 +np.float64,0xbfed1559983a2ab3,0xbfe70f03afd994ee,2 +np.float64,0xbfeb51139036a227,0xbfe62ccf56bc7fff,2 +np.float64,0x7d802890fb006,0x7d802890fb006,2 +np.float64,0x800e00af777c015f,0x800e00af777c015f,2 +np.float64,0x800647ce128c8f9d,0x800647ce128c8f9d,2 +np.float64,0x800a26da91d44db6,0x800a26da91d44db6,2 +np.float64,0x3fdc727eddb8e4fe,0x3fdab5fd9db630b3,2 +np.float64,0x7fd06def2ba0dbdd,0x3ff0000000000000,2 +np.float64,0xffe23678c4a46cf1,0xbff0000000000000,2 +np.float64,0xbfe7198e42ee331c,0xbfe3c7326c9c7553,2 +np.float64,0xffae465f3c3c8cc0,0xbff0000000000000,2 +np.float64,0xff9aea7c5035d500,0xbff0000000000000,2 +np.float64,0xbfeae49c0f35c938,0xbfe5f3e9326cb08b,2 +np.float64,0x3f9a16f300342de6,0x3f9a1581212be50f,2 +np.float64,0x8d99e2c31b33d,0x8d99e2c31b33d,2 +np.float64,0xffd58af253ab15e4,0xbff0000000000000,2 +np.float64,0xbfd205cd25a40b9a,0xbfd18f97155f8b25,2 +np.float64,0xbfebe839bbf7d074,0xbfe67a6024e8fefe,2 +np.float64,0xbfe4fb3595a9f66b,0xbfe26a42f99819ea,2 +np.float64,0x800e867c739d0cf9,0x800e867c739d0cf9,2 +np.float64,0x8bc4274f17885,0x8bc4274f17885,2 +np.float64,0xaec8914b5d912,0xaec8914b5d912,2 +np.float64,0x7fd1d64473a3ac88,0x3ff0000000000000,2 +np.float64,0xbfe6d6f69cedaded,0xbfe39dd61bc7e23e,2 +np.float64,0x7fed05039d7a0a06,0x3ff0000000000000,2 +np.float64,0xbfc40eab0f281d58,0xbfc3e50d14b79265,2 +np.float64,0x45179aec8a2f4,0x45179aec8a2f4,2 +np.float64,0xbfe717e362ee2fc7,0xbfe3c62a95b07d13,2 +np.float64,0xbfe5b8df0d6b71be,0xbfe2e76c7ec5013d,2 +np.float64,0x5c67ba6eb8cf8,0x5c67ba6eb8cf8,2 +np.float64,0xbfda72ce4cb4e59c,0xbfd909fdc7ecfe20,2 +np.float64,0x7fdf59a1e2beb343,0x3ff0000000000000,2 +np.float64,0xc4f7897f89ef1,0xc4f7897f89ef1,2 +np.float64,0x8fcd0a351f9a2,0x8fcd0a351f9a2,2 +np.float64,0x3fb161761022c2ec,0x3fb15aa31c464de2,2 +np.float64,0x8008a985be71530c,0x8008a985be71530c,2 +np.float64,0x3fca4ddb5e349bb7,0x3fc9f0a3b60e49c6,2 +np.float64,0x7fcc10a2d9382145,0x3ff0000000000000,2 +np.float64,0x78902b3af1206,0x78902b3af1206,2 +np.float64,0x7fe1e2765f23c4ec,0x3ff0000000000000,2 +np.float64,0xc1d288cf83a51,0xc1d288cf83a51,2 +np.float64,0x7fe8af692bb15ed1,0x3ff0000000000000,2 +np.float64,0x80057d90fb8afb23,0x80057d90fb8afb23,2 +np.float64,0x3fdc136b8fb826d8,0x3fda6749582b2115,2 +np.float64,0x800ec8ea477d91d5,0x800ec8ea477d91d5,2 +np.float64,0x4c0f4796981ea,0x4c0f4796981ea,2 +np.float64,0xec34c4a5d8699,0xec34c4a5d8699,2 +np.float64,0x7fce343dfb3c687b,0x3ff0000000000000,2 +np.float64,0xbfc95a98a332b530,0xbfc90705b2cc2fec,2 +np.float64,0x800d118e1dba231c,0x800d118e1dba231c,2 +np.float64,0x3fd354f310a6a9e8,0x3fd2c3bb90054154,2 +np.float64,0xbfdac0d4fab581aa,0xbfd94bf37424928e,2 +np.float64,0x3fe7f5391fefea72,0x3fe44cb49d51985b,2 +np.float64,0xd4c3c329a9879,0xd4c3c329a9879,2 +np.float64,0x3fc53977692a72f0,0x3fc50835d85c9ed1,2 +np.float64,0xbfd6989538ad312a,0xbfd5b3a2c08511fe,2 +np.float64,0xbfe329f2906653e5,0xbfe128ec1525a1c0,2 +np.float64,0x7ff0000000000000,0x3ff0000000000000,2 +np.float64,0xbfea57c90974af92,0xbfe5a87b04aa3116,2 +np.float64,0x7fdfba94043f7527,0x3ff0000000000000,2 +np.float64,0x3feedabddafdb57c,0x3fe7e06c0661978d,2 +np.float64,0x4bd9f3b697b3f,0x4bd9f3b697b3f,2 +np.float64,0x3fdd15bbfc3a2b78,0x3fdb3c3b8d070f7e,2 +np.float64,0x3fbd89ccd23b13a0,0x3fbd686b825cff80,2 +np.float64,0x7ff4000000000000,0x7ffc000000000000,2 +np.float64,0x3f9baa8928375512,0x3f9ba8d01ddd5300,2 +np.float64,0x4a3ebdf2947d8,0x4a3ebdf2947d8,2 +np.float64,0x3fe698d5c06d31ac,0x3fe376dff48312c8,2 +np.float64,0xffd5323df12a647c,0xbff0000000000000,2 +np.float64,0xffea7f111174fe22,0xbff0000000000000,2 +np.float64,0x3feb4656a9b68cad,0x3fe627392eb2156f,2 +np.float64,0x7fc1260e9c224c1c,0x3ff0000000000000,2 +np.float64,0x80056e45e5eadc8d,0x80056e45e5eadc8d,2 +np.float64,0x7fd0958ef6a12b1d,0x3ff0000000000000,2 +np.float64,0x8001f85664e3f0ae,0x8001f85664e3f0ae,2 +np.float64,0x3fe553853beaa70a,0x3fe2a4f5e7c83558,2 +np.float64,0xbfeb33ce6276679d,0xbfe61d8ec9e5ff8c,2 +np.float64,0xbfd1b24e21a3649c,0xbfd14245df6065e9,2 +np.float64,0x3fe286fc40650df9,0x3fe0b395c8059429,2 +np.float64,0xffed378058fa6f00,0xbff0000000000000,2 +np.float64,0xbfd0c4a2d7a18946,0xbfd06509a434d6a0,2 +np.float64,0xbfea31d581f463ab,0xbfe593d976139f94,2 +np.float64,0xbfe0705c85e0e0b9,0xbfde42efa978eb0c,2 +np.float64,0xe4c4c339c9899,0xe4c4c339c9899,2 +np.float64,0x3fd68befa9ad17df,0x3fd5a870b3f1f83e,2 +np.float64,0x8000000000000001,0x8000000000000001,2 +np.float64,0x3fe294256965284b,0x3fe0bd271e22d86b,2 +np.float64,0x8005327a862a64f6,0x8005327a862a64f6,2 +np.float64,0xbfdb8155ce3702ac,0xbfd9ed9ef97920f8,2 +np.float64,0xbff0000000000000,0xbfe85efab514f394,2 +np.float64,0xffe66988f1ecd312,0xbff0000000000000,2 +np.float64,0x3fb178a85e22f150,0x3fb171b9fbf95f1d,2 +np.float64,0x7f829b900025371f,0x3ff0000000000000,2 +np.float64,0x8000000000000000,0x8000000000000000,2 +np.float64,0x8006cb77f60d96f1,0x8006cb77f60d96f1,2 +np.float64,0x3fe0c5d53aa18baa,0x3fdec7012ab92b42,2 +np.float64,0x77266426ee4cd,0x77266426ee4cd,2 +np.float64,0xbfec95f468392be9,0xbfe6d11428f60136,2 +np.float64,0x3fedbf532dfb7ea6,0x3fe75f8436dd1d58,2 +np.float64,0x8002fadd3f85f5bb,0x8002fadd3f85f5bb,2 +np.float64,0xbfefebaa8d3fd755,0xbfe8566c6aa90fba,2 +np.float64,0xffc7dd2b712fba58,0xbff0000000000000,2 +np.float64,0x7fe5d3a6e8aba74d,0x3ff0000000000000,2 +np.float64,0x2da061525b40d,0x2da061525b40d,2 +np.float64,0x7fcb9b9953373732,0x3ff0000000000000,2 +np.float64,0x2ca2f6fc59460,0x2ca2f6fc59460,2 +np.float64,0xffeb84b05af70960,0xbff0000000000000,2 +np.float64,0xffe551e86c6aa3d0,0xbff0000000000000,2 +np.float64,0xbfdb311311366226,0xbfd9aa6688faafb9,2 +np.float64,0xbfd4f3875629e70e,0xbfd43bcd73534c66,2 +np.float64,0x7fe95666f932accd,0x3ff0000000000000,2 +np.float64,0x3fc73dfb482e7bf7,0x3fc6fd70c20ebf60,2 +np.float64,0x800cd9e40939b3c8,0x800cd9e40939b3c8,2 +np.float64,0x3fb0c9fa422193f0,0x3fb0c3d38879a2ac,2 +np.float64,0xffd59a38372b3470,0xbff0000000000000,2 +np.float64,0x3fa8320ef4306420,0x3fa82d739e937d35,2 +np.float64,0x3fd517f16caa2fe4,0x3fd45c8de1e93b37,2 +np.float64,0xaed921655db24,0xaed921655db24,2 +np.float64,0x93478fb9268f2,0x93478fb9268f2,2 +np.float64,0x1615e28a2c2bd,0x1615e28a2c2bd,2 +np.float64,0xbfead23010f5a460,0xbfe5ea24d5d8f820,2 +np.float64,0x774a6070ee94d,0x774a6070ee94d,2 +np.float64,0x3fdf5874bd3eb0e9,0x3fdd0ef121dd915c,2 +np.float64,0x8004b25f53a964bf,0x8004b25f53a964bf,2 +np.float64,0xbfddacdd2ebb59ba,0xbfdbb78198fab36b,2 +np.float64,0x8008a3acf271475a,0x8008a3acf271475a,2 +np.float64,0xbfdb537c8736a6fa,0xbfd9c741038bb8f0,2 +np.float64,0xbfe56a133f6ad426,0xbfe2b3d5b8d259a1,2 +np.float64,0xffda1db531343b6a,0xbff0000000000000,2 +np.float64,0x3fcbe05f3a37c0be,0x3fcb71a54a64ddfb,2 +np.float64,0x7fe1ccaa7da39954,0x3ff0000000000000,2 +np.float64,0x3faeadd8343d5bb0,0x3faea475608860e6,2 +np.float64,0x3fe662ba1c2cc574,0x3fe354a6176e90df,2 +np.float64,0xffe4d49f4e69a93e,0xbff0000000000000,2 +np.float64,0xbfeadbc424f5b788,0xbfe5ef39dbe66343,2 +np.float64,0x99cf66f1339ed,0x99cf66f1339ed,2 +np.float64,0x33af77a2675f0,0x33af77a2675f0,2 +np.float64,0x7fec7b32ecf8f665,0x3ff0000000000000,2 +np.float64,0xffef3e44993e7c88,0xbff0000000000000,2 +np.float64,0xffe8f8ceac31f19c,0xbff0000000000000,2 +np.float64,0x7fe0d15b6da1a2b6,0x3ff0000000000000,2 +np.float64,0x4ba795c2974f3,0x4ba795c2974f3,2 +np.float64,0x3fe361aa37a6c354,0x3fe15079021d6b15,2 +np.float64,0xffe709714f6e12e2,0xbff0000000000000,2 +np.float64,0xffe7ea6a872fd4d4,0xbff0000000000000,2 +np.float64,0xffdb9441c8b72884,0xbff0000000000000,2 +np.float64,0xffd5e11ae9abc236,0xbff0000000000000,2 +np.float64,0xffe092a08b612540,0xbff0000000000000,2 +np.float64,0x3fe1f27e1ca3e4fc,0x3fe04685b5131207,2 +np.float64,0xbfe71ce1bdee39c4,0xbfe3c940809a7081,2 +np.float64,0xffe8c3aa68318754,0xbff0000000000000,2 +np.float64,0x800d4e2919da9c52,0x800d4e2919da9c52,2 +np.float64,0x7fe6c8bca76d9178,0x3ff0000000000000,2 +np.float64,0x7fced8751e3db0e9,0x3ff0000000000000,2 +np.float64,0xd61d0c8bac3a2,0xd61d0c8bac3a2,2 +np.float64,0x3fec57732938aee6,0x3fe6b22f15f38352,2 +np.float64,0xff9251cc7024a3a0,0xbff0000000000000,2 +np.float64,0xf4a68cb9e94d2,0xf4a68cb9e94d2,2 +np.float64,0x3feed76703bdaece,0x3fe7def0fc9a080c,2 +np.float64,0xbfe8971ff7712e40,0xbfe4ac3eb8ebff07,2 +np.float64,0x3fe4825f682904bf,0x3fe218c1952fe67d,2 +np.float64,0xbfd60f7698ac1eee,0xbfd539f0979b4b0c,2 +np.float64,0x3fcf0845993e1088,0x3fce7032f7180144,2 +np.float64,0x7fc83443f3306887,0x3ff0000000000000,2 +np.float64,0x3fe93123ae726247,0x3fe504e4fc437e89,2 +np.float64,0x3fbf9eb8363f3d70,0x3fbf75cdfa6828d5,2 +np.float64,0xbf8b45e5d0368bc0,0xbf8b457c29dfe1a9,2 +np.float64,0x8006c2853d0d850b,0x8006c2853d0d850b,2 +np.float64,0xffef26e25ffe4dc4,0xbff0000000000000,2 +np.float64,0x7fefffffffffffff,0x3ff0000000000000,2 +np.float64,0xbfde98f2c2bd31e6,0xbfdc761bfab1c4cb,2 +np.float64,0xffb725e6222e4bd0,0xbff0000000000000,2 +np.float64,0x800c63ead5d8c7d6,0x800c63ead5d8c7d6,2 +np.float64,0x3fea087e95f410fd,0x3fe57d3ab440706c,2 +np.float64,0xbfdf9f8a603f3f14,0xbfdd4742d77dfa57,2 +np.float64,0xfff0000000000000,0xbff0000000000000,2 +np.float64,0xbfcdc0841d3b8108,0xbfcd3a401debba9a,2 +np.float64,0x800f0c8f4f7e191f,0x800f0c8f4f7e191f,2 +np.float64,0x800ba6e75fd74dcf,0x800ba6e75fd74dcf,2 +np.float64,0x7fee4927e8bc924f,0x3ff0000000000000,2 +np.float64,0x3fadf141903be283,0x3fade8878d9d3551,2 +np.float64,0x3efb1a267df64,0x3efb1a267df64,2 +np.float64,0xffebf55f22b7eabe,0xbff0000000000000,2 +np.float64,0x7fbe8045663d008a,0x3ff0000000000000,2 +np.float64,0x3fefc0129f7f8026,0x3fe843f8b7d6cf38,2 +np.float64,0xbfe846b420f08d68,0xbfe47d1709e43937,2 +np.float64,0x7fe8e87043f1d0e0,0x3ff0000000000000,2 +np.float64,0x3fcfb718453f6e31,0x3fcf14ecee7b32b4,2 +np.float64,0x7fe4306b71a860d6,0x3ff0000000000000,2 +np.float64,0x7fee08459f7c108a,0x3ff0000000000000,2 +np.float64,0x3fed705165fae0a3,0x3fe73a66369c5700,2 +np.float64,0x7fd0e63f4da1cc7e,0x3ff0000000000000,2 +np.float64,0xffd1a40c2ea34818,0xbff0000000000000,2 +np.float64,0xbfa369795c26d2f0,0xbfa36718218d46b3,2 +np.float64,0xef70b9f5dee17,0xef70b9f5dee17,2 +np.float64,0x3fb50a0a6e2a1410,0x3fb4fdf27724560a,2 +np.float64,0x7fe30a0f6166141e,0x3ff0000000000000,2 +np.float64,0xbfd7b3ca7daf6794,0xbfd6accb81032b2d,2 +np.float64,0x3fc21dceb3243b9d,0x3fc1ff15d5d277a3,2 +np.float64,0x3fe483e445a907c9,0x3fe219ca0e269552,2 +np.float64,0x3fb2b1e2a22563c0,0x3fb2a96554900eaf,2 +np.float64,0x4b1ff6409641,0x4b1ff6409641,2 +np.float64,0xbfd92eabc9b25d58,0xbfd7f55d7776d64e,2 +np.float64,0x8003b8604c8770c1,0x8003b8604c8770c1,2 +np.float64,0x800d20a9df1a4154,0x800d20a9df1a4154,2 +np.float64,0xecf8a535d9f15,0xecf8a535d9f15,2 +np.float64,0x3fe92d15bab25a2b,0x3fe50296aa15ae85,2 +np.float64,0x800239c205a47385,0x800239c205a47385,2 +np.float64,0x3fc48664a9290cc8,0x3fc459d126320ef6,2 +np.float64,0x3fe7620625eec40c,0x3fe3f3bcbee3e8c6,2 +np.float64,0x3fd242ff4ca48600,0x3fd1c81ed7a971c8,2 +np.float64,0xbfe39bafcfa73760,0xbfe17959c7a279db,2 +np.float64,0x7fdcd2567239a4ac,0x3ff0000000000000,2 +np.float64,0x3fe5f2f292ebe5e6,0x3fe30d12f05e2752,2 +np.float64,0x7fda3819d1347033,0x3ff0000000000000,2 +np.float64,0xffca5b4d4334b69c,0xbff0000000000000,2 +np.float64,0xb8a2b7cd71457,0xb8a2b7cd71457,2 +np.float64,0x3fee689603fcd12c,0x3fe7ad4ace26d6dd,2 +np.float64,0x7fe26541a564ca82,0x3ff0000000000000,2 +np.float64,0x3fe6912ee66d225e,0x3fe3720d242c4d82,2 +np.float64,0xffe6580c75ecb018,0xbff0000000000000,2 +np.float64,0x7fe01a3370603466,0x3ff0000000000000,2 +np.float64,0xffe84e3f84b09c7e,0xbff0000000000000,2 +np.float64,0x3ff0000000000000,0x3fe85efab514f394,2 +np.float64,0x3fe214d4266429a8,0x3fe05fec03a3c247,2 +np.float64,0x3fd00aec5da015d8,0x3fcf6e070ad4ad62,2 +np.float64,0x800aac8631f5590d,0x800aac8631f5590d,2 +np.float64,0xbfe7c4f5f76f89ec,0xbfe42fc1c57b4a13,2 +np.float64,0xaf146c7d5e28e,0xaf146c7d5e28e,2 +np.float64,0xbfe57188b66ae312,0xbfe2b8be4615ef75,2 +np.float64,0xffef8cb8e1ff1971,0xbff0000000000000,2 +np.float64,0x8001daf8aa63b5f2,0x8001daf8aa63b5f2,2 +np.float64,0x3fdddcc339bbb986,0x3fdbde5f3783538b,2 +np.float64,0xdd8c92c3bb193,0xdd8c92c3bb193,2 +np.float64,0xbfe861a148f0c342,0xbfe48cf1d228a336,2 +np.float64,0xffe260a32e24c146,0xbff0000000000000,2 +np.float64,0x1f7474b43ee8f,0x1f7474b43ee8f,2 +np.float64,0x3fe81dbd89703b7c,0x3fe464d78df92b7b,2 +np.float64,0x7fed0101177a0201,0x3ff0000000000000,2 +np.float64,0x7fd8b419a8316832,0x3ff0000000000000,2 +np.float64,0x3fe93debccf27bd8,0x3fe50c27727917f0,2 +np.float64,0xe5ead05bcbd5a,0xe5ead05bcbd5a,2 +np.float64,0xbfebbbc4cff7778a,0xbfe663c4ca003bbf,2 +np.float64,0xbfea343eb474687e,0xbfe59529f73ea151,2 +np.float64,0x3fbe74a5963ce94b,0x3fbe50123ed05d8d,2 +np.float64,0x3fd31d3a5d263a75,0x3fd290c026cb38a5,2 +np.float64,0xbfd79908acaf3212,0xbfd695620e31c3c6,2 +np.float64,0xbfc26a350324d46c,0xbfc249f335f3e465,2 +np.float64,0xbfac38d5583871b0,0xbfac31866d12a45e,2 +np.float64,0x3fe40cea672819d5,0x3fe1c83754e72c92,2 +np.float64,0xbfa74770642e8ee0,0xbfa74355fcf67332,2 +np.float64,0x7fc60942d32c1285,0x3ff0000000000000,2 diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/examples/cython/__pycache__/setup.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/_core/tests/examples/cython/__pycache__/setup.cpython-312.pyc new file mode 100644 index 00000000..67a45e94 Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/_core/tests/examples/cython/__pycache__/setup.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/examples/cython/checks.pyx b/venv/lib/python3.12/site-packages/numpy/_core/tests/examples/cython/checks.pyx new file mode 100644 index 00000000..c0bb1f3f --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/tests/examples/cython/checks.pyx @@ -0,0 +1,268 @@ +#cython: language_level=3 + +""" +Functions in this module give python-space wrappers for cython functions +exposed in numpy/__init__.pxd, so they can be tested in test_cython.py +""" +cimport numpy as cnp +cnp.import_array() + + +def is_td64(obj): + return cnp.is_timedelta64_object(obj) + + +def is_dt64(obj): + return cnp.is_datetime64_object(obj) + + +def get_dt64_value(obj): + return cnp.get_datetime64_value(obj) + + +def get_td64_value(obj): + return cnp.get_timedelta64_value(obj) + + +def get_dt64_unit(obj): + return cnp.get_datetime64_unit(obj) + + +def is_integer(obj): + return isinstance(obj, (cnp.integer, int)) + + +def get_datetime_iso_8601_strlen(): + return cnp.get_datetime_iso_8601_strlen(0, cnp.NPY_FR_ns) + + +def convert_datetime64_to_datetimestruct(): + cdef: + cnp.npy_datetimestruct dts + cnp.PyArray_DatetimeMetaData meta + cnp.int64_t value = 1647374515260292 + # i.e. (time.time() * 10**6) at 2022-03-15 20:01:55.260292 UTC + + meta.base = cnp.NPY_FR_us + meta.num = 1 + cnp.convert_datetime64_to_datetimestruct(&meta, value, &dts) + return dts + + +def make_iso_8601_datetime(dt: "datetime"): + cdef: + cnp.npy_datetimestruct dts + char result[36] # 36 corresponds to NPY_FR_s passed below + int local = 0 + int utc = 0 + int tzoffset = 0 + + dts.year = dt.year + dts.month = dt.month + dts.day = dt.day + dts.hour = dt.hour + dts.min = dt.minute + dts.sec = dt.second + dts.us = dt.microsecond + dts.ps = dts.as = 0 + + cnp.make_iso_8601_datetime( + &dts, + result, + sizeof(result), + local, + utc, + cnp.NPY_FR_s, + tzoffset, + cnp.NPY_NO_CASTING, + ) + return result + + +cdef cnp.broadcast multiiter_from_broadcast_obj(object bcast): + cdef dict iter_map = { + 1: cnp.PyArray_MultiIterNew1, + 2: cnp.PyArray_MultiIterNew2, + 3: cnp.PyArray_MultiIterNew3, + 4: cnp.PyArray_MultiIterNew4, + 5: cnp.PyArray_MultiIterNew5, + } + arrays = [x.base for x in bcast.iters] + cdef cnp.broadcast result = iter_map[len(arrays)](*arrays) + return result + + +def get_multiiter_size(bcast: "broadcast"): + cdef cnp.broadcast multi = multiiter_from_broadcast_obj(bcast) + return multi.size + + +def get_multiiter_number_of_dims(bcast: "broadcast"): + cdef cnp.broadcast multi = multiiter_from_broadcast_obj(bcast) + return multi.nd + + +def get_multiiter_current_index(bcast: "broadcast"): + cdef cnp.broadcast multi = multiiter_from_broadcast_obj(bcast) + return multi.index + + +def get_multiiter_num_of_iterators(bcast: "broadcast"): + cdef cnp.broadcast multi = multiiter_from_broadcast_obj(bcast) + return multi.numiter + + +def get_multiiter_shape(bcast: "broadcast"): + cdef cnp.broadcast multi = multiiter_from_broadcast_obj(bcast) + return tuple([multi.dimensions[i] for i in range(bcast.nd)]) + + +def get_multiiter_iters(bcast: "broadcast"): + cdef cnp.broadcast multi = multiiter_from_broadcast_obj(bcast) + return tuple([multi.iters[i] for i in range(bcast.numiter)]) + + +def get_default_integer(): + if cnp.NPY_DEFAULT_INT == cnp.NPY_LONG: + return cnp.dtype("long") + if cnp.NPY_DEFAULT_INT == cnp.NPY_INTP: + return cnp.dtype("intp") + return None + +def get_ravel_axis(): + return cnp.NPY_RAVEL_AXIS + + +def conv_intp(cnp.intp_t val): + return val + + +def get_dtype_flags(cnp.dtype dtype): + return dtype.flags + + +cdef cnp.NpyIter* npyiter_from_nditer_obj(object it): + """A function to create a NpyIter struct from a nditer object. + + This function is only meant for testing purposes and only extracts the + necessary info from nditer to test the functionality of NpyIter methods + """ + cdef: + cnp.NpyIter* cit + cnp.PyArray_Descr* op_dtypes[3] + cnp.npy_uint32 op_flags[3] + cnp.PyArrayObject* ops[3] + cnp.npy_uint32 flags = 0 + + if it.has_index: + flags |= cnp.NPY_ITER_C_INDEX + if it.has_delayed_bufalloc: + flags |= cnp.NPY_ITER_BUFFERED | cnp.NPY_ITER_DELAY_BUFALLOC + if it.has_multi_index: + flags |= cnp.NPY_ITER_MULTI_INDEX + + # one of READWRITE, READONLY and WRTIEONLY at the minimum must be specified for op_flags + for i in range(it.nop): + op_flags[i] = cnp.NPY_ITER_READONLY + + for i in range(it.nop): + op_dtypes[i] = cnp.PyArray_DESCR(it.operands[i]) + ops[i] = it.operands[i] + + cit = cnp.NpyIter_MultiNew(it.nop, &ops[0], flags, cnp.NPY_KEEPORDER, + cnp.NPY_NO_CASTING, &op_flags[0], + NULL) + return cit + + +def get_npyiter_size(it: "nditer"): + cdef cnp.NpyIter* cit = npyiter_from_nditer_obj(it) + result = cnp.NpyIter_GetIterSize(cit) + cnp.NpyIter_Deallocate(cit) + return result + + +def get_npyiter_ndim(it: "nditer"): + cdef cnp.NpyIter* cit = npyiter_from_nditer_obj(it) + result = cnp.NpyIter_GetNDim(cit) + cnp.NpyIter_Deallocate(cit) + return result + + +def get_npyiter_nop(it: "nditer"): + cdef cnp.NpyIter* cit = npyiter_from_nditer_obj(it) + result = cnp.NpyIter_GetNOp(cit) + cnp.NpyIter_Deallocate(cit) + return result + + +def get_npyiter_operands(it: "nditer"): + cdef cnp.NpyIter* cit = npyiter_from_nditer_obj(it) + try: + arr = cnp.NpyIter_GetOperandArray(cit) + return tuple([arr[i] for i in range(it.nop)]) + finally: + cnp.NpyIter_Deallocate(cit) + + +def get_npyiter_itviews(it: "nditer"): + cdef cnp.NpyIter* cit = npyiter_from_nditer_obj(it) + result = tuple([cnp.NpyIter_GetIterView(cit, i) for i in range(it.nop)]) + cnp.NpyIter_Deallocate(cit) + return result + + +def get_npyiter_dtypes(it: "nditer"): + cdef cnp.NpyIter* cit = npyiter_from_nditer_obj(it) + try: + arr = cnp.NpyIter_GetDescrArray(cit) + return tuple([arr[i] for i in range(it.nop)]) + finally: + cnp.NpyIter_Deallocate(cit) + + +def npyiter_has_delayed_bufalloc(it: "nditer"): + cdef cnp.NpyIter* cit = npyiter_from_nditer_obj(it) + result = cnp.NpyIter_HasDelayedBufAlloc(cit) + cnp.NpyIter_Deallocate(cit) + return result + + +def npyiter_has_index(it: "nditer"): + cdef cnp.NpyIter* cit = npyiter_from_nditer_obj(it) + result = cnp.NpyIter_HasIndex(cit) + cnp.NpyIter_Deallocate(cit) + return result + + +def npyiter_has_multi_index(it: "nditer"): + cdef cnp.NpyIter* cit = npyiter_from_nditer_obj(it) + result = cnp.NpyIter_HasMultiIndex(cit) + cnp.NpyIter_Deallocate(cit) + return result + + +def npyiter_has_finished(it: "nditer"): + cdef cnp.NpyIter* cit + try: + cit = npyiter_from_nditer_obj(it) + cnp.NpyIter_GotoIterIndex(cit, it.index) + return not (cnp.NpyIter_GetIterIndex(cit) < cnp.NpyIter_GetIterSize(cit)) + finally: + cnp.NpyIter_Deallocate(cit) + +def compile_fillwithbyte(): + # Regression test for gh-25878, mostly checks it compiles. + cdef cnp.npy_intp dims[2] + dims = (1, 2) + pos = cnp.PyArray_ZEROS(2, dims, cnp.NPY_UINT8, 0) + cnp.PyArray_FILLWBYTE(pos, 1) + return pos + +def inc2_cfloat_struct(cnp.ndarray[cnp.cfloat_t] arr): + # This works since we compile in C mode, it will fail in cpp mode + arr[1].real += 1 + arr[1].imag += 1 + # This works in both modes + arr[1].real = arr[1].real + 1 + arr[1].imag = arr[1].imag + 1 diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/examples/cython/meson.build b/venv/lib/python3.12/site-packages/numpy/_core/tests/examples/cython/meson.build new file mode 100644 index 00000000..8362c339 --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/tests/examples/cython/meson.build @@ -0,0 +1,43 @@ +project('checks', 'c', 'cython') + +py = import('python').find_installation(pure: false) + +cc = meson.get_compiler('c') +cy = meson.get_compiler('cython') + +# Keep synced with pyproject.toml +if not cy.version().version_compare('>=3.0.6') + error('tests requires Cython >= 3.0.6') +endif + +cython_args = [] +if cy.version().version_compare('>=3.1.0') + cython_args += ['-Xfreethreading_compatible=True'] +endif + +npy_include_path = run_command(py, [ + '-c', + 'import os; os.chdir(".."); import numpy; print(os.path.abspath(numpy.get_include()))' + ], check: true).stdout().strip() + +npy_path = run_command(py, [ + '-c', + 'import os; os.chdir(".."); import numpy; print(os.path.dirname(numpy.__file__).removesuffix("numpy"))' + ], check: true).stdout().strip() + +# TODO: This is a hack due to gh-25135, where cython may not find the right +# __init__.pyd file. +add_project_arguments('-I', npy_path, language : 'cython') + +py.extension_module( + 'checks', + 'checks.pyx', + install: false, + c_args: [ + '-DNPY_NO_DEPRECATED_API=0', # Cython still uses old NumPy C API + # Require 1.25+ to test datetime additions + '-DNPY_TARGET_VERSION=NPY_2_0_API_VERSION', + ], + include_directories: [npy_include_path], + cython_args: cython_args, +) diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/examples/cython/setup.py b/venv/lib/python3.12/site-packages/numpy/_core/tests/examples/cython/setup.py new file mode 100644 index 00000000..1bf02770 --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/tests/examples/cython/setup.py @@ -0,0 +1,37 @@ +""" +Provide python-space access to the functions exposed in numpy/__init__.pxd +for testing. +""" + +import Cython +import numpy as np +from numpy._utils import _pep440 +from distutils.core import setup +from Cython.Build import cythonize +from setuptools.extension import Extension +import os + +macros = [ + ("NPY_NO_DEPRECATED_API", 0), + # Require 1.25+ to test datetime additions + ("NPY_TARGET_VERSION", "NPY_2_0_API_VERSION"), +] + +checks = Extension( + "checks", + sources=[os.path.join('.', "checks.pyx")], + include_dirs=[np.get_include()], + define_macros=macros, +) + +extensions = [checks] + +compiler_directives = {} +if _pep440.parse(Cython.__version__) >= _pep440.parse("3.1.0a0"): + compiler_directives['freethreading_compatible'] = True + +setup( + ext_modules=cythonize( + extensions, + compiler_directives=compiler_directives) +) diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/examples/limited_api/__pycache__/setup.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/_core/tests/examples/limited_api/__pycache__/setup.cpython-312.pyc new file mode 100644 index 00000000..4f68209a Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/_core/tests/examples/limited_api/__pycache__/setup.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/examples/limited_api/limited_api1.c b/venv/lib/python3.12/site-packages/numpy/_core/tests/examples/limited_api/limited_api1.c new file mode 100644 index 00000000..3dbf5698 --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/tests/examples/limited_api/limited_api1.c @@ -0,0 +1,17 @@ +#define Py_LIMITED_API 0x03060000 + +#include +#include +#include + +static PyModuleDef moduledef = { + .m_base = PyModuleDef_HEAD_INIT, + .m_name = "limited_api1" +}; + +PyMODINIT_FUNC PyInit_limited_api1(void) +{ + import_array(); + import_umath(); + return PyModule_Create(&moduledef); +} diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/examples/limited_api/limited_api2.pyx b/venv/lib/python3.12/site-packages/numpy/_core/tests/examples/limited_api/limited_api2.pyx new file mode 100644 index 00000000..327d5b03 --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/tests/examples/limited_api/limited_api2.pyx @@ -0,0 +1,11 @@ +#cython: language_level=3 + +""" +Make sure cython can compile in limited API mode (see meson.build) +""" + +cdef extern from "numpy/arrayobject.h": + pass +cdef extern from "numpy/arrayscalars.h": + pass + diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/examples/limited_api/limited_api_latest.c b/venv/lib/python3.12/site-packages/numpy/_core/tests/examples/limited_api/limited_api_latest.c new file mode 100644 index 00000000..13668f2f --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/tests/examples/limited_api/limited_api_latest.c @@ -0,0 +1,19 @@ +#if Py_LIMITED_API != PY_VERSION_HEX & 0xffff0000 + # error "Py_LIMITED_API not defined to Python major+minor version" +#endif + +#include +#include +#include + +static PyModuleDef moduledef = { + .m_base = PyModuleDef_HEAD_INIT, + .m_name = "limited_api_latest" +}; + +PyMODINIT_FUNC PyInit_limited_api_latest(void) +{ + import_array(); + import_umath(); + return PyModule_Create(&moduledef); +} diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/examples/limited_api/meson.build b/venv/lib/python3.12/site-packages/numpy/_core/tests/examples/limited_api/meson.build new file mode 100644 index 00000000..65287d86 --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/tests/examples/limited_api/meson.build @@ -0,0 +1,59 @@ +project('checks', 'c', 'cython') + +py = import('python').find_installation(pure: false) + +cc = meson.get_compiler('c') +cy = meson.get_compiler('cython') + +# Keep synced with pyproject.toml +if not cy.version().version_compare('>=3.0.6') + error('tests requires Cython >= 3.0.6') +endif + +npy_include_path = run_command(py, [ + '-c', + 'import os; os.chdir(".."); import numpy; print(os.path.abspath(numpy.get_include()))' + ], check: true).stdout().strip() + +npy_path = run_command(py, [ + '-c', + 'import os; os.chdir(".."); import numpy; print(os.path.dirname(numpy.__file__).removesuffix("numpy"))' + ], check: true).stdout().strip() + +# TODO: This is a hack due to https://github.com/cython/cython/issues/5820, +# where cython may not find the right __init__.pyd file. +add_project_arguments('-I', npy_path, language : 'cython') + +py.extension_module( + 'limited_api1', + 'limited_api1.c', + c_args: [ + '-DNPY_NO_DEPRECATED_API=NPY_1_21_API_VERSION', + ], + include_directories: [npy_include_path], + limited_api: '3.6', +) + +py.extension_module( + 'limited_api_latest', + 'limited_api_latest.c', + c_args: [ + '-DNPY_NO_DEPRECATED_API=NPY_1_21_API_VERSION', + ], + include_directories: [npy_include_path], + limited_api: py.language_version(), +) + +py.extension_module( + 'limited_api2', + 'limited_api2.pyx', + install: false, + c_args: [ + '-DNPY_NO_DEPRECATED_API=0', + # Require 1.25+ to test datetime additions + '-DNPY_TARGET_VERSION=NPY_2_0_API_VERSION', + '-DCYTHON_LIMITED_API=1', + ], + include_directories: [npy_include_path], + limited_api: '3.7', +) diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/examples/limited_api/setup.py b/venv/lib/python3.12/site-packages/numpy/_core/tests/examples/limited_api/setup.py new file mode 100644 index 00000000..18747dc8 --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/tests/examples/limited_api/setup.py @@ -0,0 +1,22 @@ +""" +Build an example package using the limited Python C API. +""" + +import numpy as np +from setuptools import setup, Extension +import os + +macros = [("NPY_NO_DEPRECATED_API", 0), ("Py_LIMITED_API", "0x03060000")] + +limited_api = Extension( + "limited_api", + sources=[os.path.join('.', "limited_api.c")], + include_dirs=[np.get_include()], + define_macros=macros, +) + +extensions = [limited_api] + +setup( + ext_modules=extensions +) diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/test__exceptions.py b/venv/lib/python3.12/site-packages/numpy/_core/tests/test__exceptions.py new file mode 100644 index 00000000..fe792c8e --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/tests/test__exceptions.py @@ -0,0 +1,89 @@ +""" +Tests of the ._exceptions module. Primarily for exercising the __str__ methods. +""" + +import pickle + +import pytest +import numpy as np +from numpy.exceptions import AxisError + +_ArrayMemoryError = np._core._exceptions._ArrayMemoryError +_UFuncNoLoopError = np._core._exceptions._UFuncNoLoopError + +class TestArrayMemoryError: + def test_pickling(self): + """ Test that _ArrayMemoryError can be pickled """ + error = _ArrayMemoryError((1023,), np.dtype(np.uint8)) + res = pickle.loads(pickle.dumps(error)) + assert res._total_size == error._total_size + + def test_str(self): + e = _ArrayMemoryError((1023,), np.dtype(np.uint8)) + str(e) # not crashing is enough + + # testing these properties is easier than testing the full string repr + def test__size_to_string(self): + """ Test e._size_to_string """ + f = _ArrayMemoryError._size_to_string + Ki = 1024 + assert f(0) == '0 bytes' + assert f(1) == '1 bytes' + assert f(1023) == '1023 bytes' + assert f(Ki) == '1.00 KiB' + assert f(Ki+1) == '1.00 KiB' + assert f(10*Ki) == '10.0 KiB' + assert f(int(999.4*Ki)) == '999. KiB' + assert f(int(1023.4*Ki)) == '1023. KiB' + assert f(int(1023.5*Ki)) == '1.00 MiB' + assert f(Ki*Ki) == '1.00 MiB' + + # 1023.9999 Mib should round to 1 GiB + assert f(int(Ki*Ki*Ki*0.9999)) == '1.00 GiB' + assert f(Ki*Ki*Ki*Ki*Ki*Ki) == '1.00 EiB' + # larger than sys.maxsize, adding larger prefixes isn't going to help + # anyway. + assert f(Ki*Ki*Ki*Ki*Ki*Ki*123456) == '123456. EiB' + + def test__total_size(self): + """ Test e._total_size """ + e = _ArrayMemoryError((1,), np.dtype(np.uint8)) + assert e._total_size == 1 + + e = _ArrayMemoryError((2, 4), np.dtype((np.uint64, 16))) + assert e._total_size == 1024 + + +class TestUFuncNoLoopError: + def test_pickling(self): + """ Test that _UFuncNoLoopError can be pickled """ + assert isinstance(pickle.dumps(_UFuncNoLoopError), bytes) + + +@pytest.mark.parametrize("args", [ + (2, 1, None), + (2, 1, "test_prefix"), + ("test message",), +]) +class TestAxisError: + def test_attr(self, args): + """Validate attribute types.""" + exc = AxisError(*args) + if len(args) == 1: + assert exc.axis is None + assert exc.ndim is None + else: + axis, ndim, *_ = args + assert exc.axis == axis + assert exc.ndim == ndim + + def test_pickling(self, args): + """Test that `AxisError` can be pickled.""" + exc = AxisError(*args) + exc2 = pickle.loads(pickle.dumps(exc)) + + assert type(exc) is type(exc2) + for name in ("axis", "ndim", "args"): + attr1 = getattr(exc, name) + attr2 = getattr(exc2, name) + assert attr1 == attr2, name diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/test_abc.py b/venv/lib/python3.12/site-packages/numpy/_core/tests/test_abc.py new file mode 100644 index 00000000..f7ab6b63 --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/tests/test_abc.py @@ -0,0 +1,54 @@ +from numpy.testing import assert_ + +import numbers + +import numpy as np +from numpy._core.numerictypes import sctypes + +class TestABC: + def test_abstract(self): + assert_(issubclass(np.number, numbers.Number)) + + assert_(issubclass(np.inexact, numbers.Complex)) + assert_(issubclass(np.complexfloating, numbers.Complex)) + assert_(issubclass(np.floating, numbers.Real)) + + assert_(issubclass(np.integer, numbers.Integral)) + assert_(issubclass(np.signedinteger, numbers.Integral)) + assert_(issubclass(np.unsignedinteger, numbers.Integral)) + + def test_floats(self): + for t in sctypes['float']: + assert_(isinstance(t(), numbers.Real), + f"{t.__name__} is not instance of Real") + assert_(issubclass(t, numbers.Real), + f"{t.__name__} is not subclass of Real") + assert_(not isinstance(t(), numbers.Rational), + f"{t.__name__} is instance of Rational") + assert_(not issubclass(t, numbers.Rational), + f"{t.__name__} is subclass of Rational") + + def test_complex(self): + for t in sctypes['complex']: + assert_(isinstance(t(), numbers.Complex), + f"{t.__name__} is not instance of Complex") + assert_(issubclass(t, numbers.Complex), + f"{t.__name__} is not subclass of Complex") + assert_(not isinstance(t(), numbers.Real), + f"{t.__name__} is instance of Real") + assert_(not issubclass(t, numbers.Real), + f"{t.__name__} is subclass of Real") + + def test_int(self): + for t in sctypes['int']: + assert_(isinstance(t(), numbers.Integral), + f"{t.__name__} is not instance of Integral") + assert_(issubclass(t, numbers.Integral), + f"{t.__name__} is not subclass of Integral") + + def test_uint(self): + for t in sctypes['uint']: + assert_(isinstance(t(), numbers.Integral), + f"{t.__name__} is not instance of Integral") + assert_(issubclass(t, numbers.Integral), + f"{t.__name__} is not subclass of Integral") diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/test_api.py b/venv/lib/python3.12/site-packages/numpy/_core/tests/test_api.py new file mode 100644 index 00000000..1ac7a49b --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/tests/test_api.py @@ -0,0 +1,616 @@ +import sys + +import numpy as np +import numpy._core.umath as ncu +from numpy._core._rational_tests import rational +import pytest +from numpy.testing import ( + assert_, assert_equal, assert_array_equal, assert_raises, assert_warns, + HAS_REFCOUNT + ) + + +def test_array_array(): + tobj = type(object) + ones11 = np.ones((1, 1), np.float64) + tndarray = type(ones11) + # Test is_ndarray + assert_equal(np.array(ones11, dtype=np.float64), ones11) + if HAS_REFCOUNT: + old_refcount = sys.getrefcount(tndarray) + np.array(ones11) + assert_equal(old_refcount, sys.getrefcount(tndarray)) + + # test None + assert_equal(np.array(None, dtype=np.float64), + np.array(np.nan, dtype=np.float64)) + if HAS_REFCOUNT: + old_refcount = sys.getrefcount(tobj) + np.array(None, dtype=np.float64) + assert_equal(old_refcount, sys.getrefcount(tobj)) + + # test scalar + assert_equal(np.array(1.0, dtype=np.float64), + np.ones((), dtype=np.float64)) + if HAS_REFCOUNT: + old_refcount = sys.getrefcount(np.float64) + np.array(np.array(1.0, dtype=np.float64), dtype=np.float64) + assert_equal(old_refcount, sys.getrefcount(np.float64)) + + # test string + S2 = np.dtype((bytes, 2)) + S3 = np.dtype((bytes, 3)) + S5 = np.dtype((bytes, 5)) + assert_equal(np.array(b"1.0", dtype=np.float64), + np.ones((), dtype=np.float64)) + assert_equal(np.array(b"1.0").dtype, S3) + assert_equal(np.array(b"1.0", dtype=bytes).dtype, S3) + assert_equal(np.array(b"1.0", dtype=S2), np.array(b"1.")) + assert_equal(np.array(b"1", dtype=S5), np.ones((), dtype=S5)) + + # test string + U2 = np.dtype((str, 2)) + U3 = np.dtype((str, 3)) + U5 = np.dtype((str, 5)) + assert_equal(np.array("1.0", dtype=np.float64), + np.ones((), dtype=np.float64)) + assert_equal(np.array("1.0").dtype, U3) + assert_equal(np.array("1.0", dtype=str).dtype, U3) + assert_equal(np.array("1.0", dtype=U2), np.array(str("1."))) + assert_equal(np.array("1", dtype=U5), np.ones((), dtype=U5)) + + builtins = getattr(__builtins__, '__dict__', __builtins__) + assert_(hasattr(builtins, 'get')) + + # test memoryview + dat = np.array(memoryview(b'1.0'), dtype=np.float64) + assert_equal(dat, [49.0, 46.0, 48.0]) + assert_(dat.dtype.type is np.float64) + + dat = np.array(memoryview(b'1.0')) + assert_equal(dat, [49, 46, 48]) + assert_(dat.dtype.type is np.uint8) + + # test array interface + a = np.array(100.0, dtype=np.float64) + o = type("o", (object,), + dict(__array_interface__=a.__array_interface__)) + assert_equal(np.array(o, dtype=np.float64), a) + + # test array_struct interface + a = np.array([(1, 4.0, 'Hello'), (2, 6.0, 'World')], + dtype=[('f0', int), ('f1', float), ('f2', str)]) + o = type("o", (object,), + dict(__array_struct__=a.__array_struct__)) + ## wasn't what I expected... is np.array(o) supposed to equal a ? + ## instead we get a array([...], dtype=">V18") + assert_equal(bytes(np.array(o).data), bytes(a.data)) + + # test array + def custom__array__(self, dtype=None, copy=None): + return np.array(100.0, dtype=dtype, copy=copy) + + o = type("o", (object,), dict(__array__=custom__array__))() + assert_equal(np.array(o, dtype=np.float64), np.array(100.0, np.float64)) + + # test recursion + nested = 1.5 + for i in range(ncu.MAXDIMS): + nested = [nested] + + # no error + np.array(nested) + + # Exceeds recursion limit + assert_raises(ValueError, np.array, [nested], dtype=np.float64) + + # Try with lists... + # float32 + assert_equal(np.array([None] * 10, dtype=np.float32), + np.full((10,), np.nan, dtype=np.float32)) + assert_equal(np.array([[None]] * 10, dtype=np.float32), + np.full((10, 1), np.nan, dtype=np.float32)) + assert_equal(np.array([[None] * 10], dtype=np.float32), + np.full((1, 10), np.nan, dtype=np.float32)) + assert_equal(np.array([[None] * 10] * 10, dtype=np.float32), + np.full((10, 10), np.nan, dtype=np.float32)) + # float64 + assert_equal(np.array([None] * 10, dtype=np.float64), + np.full((10,), np.nan, dtype=np.float64)) + assert_equal(np.array([[None]] * 10, dtype=np.float64), + np.full((10, 1), np.nan, dtype=np.float64)) + assert_equal(np.array([[None] * 10], dtype=np.float64), + np.full((1, 10), np.nan, dtype=np.float64)) + assert_equal(np.array([[None] * 10] * 10, dtype=np.float64), + np.full((10, 10), np.nan, dtype=np.float64)) + + assert_equal(np.array([1.0] * 10, dtype=np.float64), + np.ones((10,), dtype=np.float64)) + assert_equal(np.array([[1.0]] * 10, dtype=np.float64), + np.ones((10, 1), dtype=np.float64)) + assert_equal(np.array([[1.0] * 10], dtype=np.float64), + np.ones((1, 10), dtype=np.float64)) + assert_equal(np.array([[1.0] * 10] * 10, dtype=np.float64), + np.ones((10, 10), dtype=np.float64)) + + # Try with tuples + assert_equal(np.array((None,) * 10, dtype=np.float64), + np.full((10,), np.nan, dtype=np.float64)) + assert_equal(np.array([(None,)] * 10, dtype=np.float64), + np.full((10, 1), np.nan, dtype=np.float64)) + assert_equal(np.array([(None,) * 10], dtype=np.float64), + np.full((1, 10), np.nan, dtype=np.float64)) + assert_equal(np.array([(None,) * 10] * 10, dtype=np.float64), + np.full((10, 10), np.nan, dtype=np.float64)) + + assert_equal(np.array((1.0,) * 10, dtype=np.float64), + np.ones((10,), dtype=np.float64)) + assert_equal(np.array([(1.0,)] * 10, dtype=np.float64), + np.ones((10, 1), dtype=np.float64)) + assert_equal(np.array([(1.0,) * 10], dtype=np.float64), + np.ones((1, 10), dtype=np.float64)) + assert_equal(np.array([(1.0,) * 10] * 10, dtype=np.float64), + np.ones((10, 10), dtype=np.float64)) + +@pytest.mark.parametrize("array", [True, False]) +def test_array_impossible_casts(array): + # All builtin types can be forcibly cast, at least theoretically, + # but user dtypes cannot necessarily. + rt = rational(1, 2) + if array: + rt = np.array(rt) + with assert_raises(TypeError): + np.array(rt, dtype="M8") + + +def test_array_astype(): + a = np.arange(6, dtype='f4').reshape(2, 3) + # Default behavior: allows unsafe casts, keeps memory layout, + # always copies. + b = a.astype('i4') + assert_equal(a, b) + assert_equal(b.dtype, np.dtype('i4')) + assert_equal(a.strides, b.strides) + b = a.T.astype('i4') + assert_equal(a.T, b) + assert_equal(b.dtype, np.dtype('i4')) + assert_equal(a.T.strides, b.strides) + b = a.astype('f4') + assert_equal(a, b) + assert_(not (a is b)) + + # copy=False parameter skips a copy + b = a.astype('f4', copy=False) + assert_(a is b) + + # order parameter allows overriding of the memory layout, + # forcing a copy if the layout is wrong + b = a.astype('f4', order='F', copy=False) + assert_equal(a, b) + assert_(not (a is b)) + assert_(b.flags.f_contiguous) + + b = a.astype('f4', order='C', copy=False) + assert_equal(a, b) + assert_(a is b) + assert_(b.flags.c_contiguous) + + # casting parameter allows catching bad casts + b = a.astype('c8', casting='safe') + assert_equal(a, b) + assert_equal(b.dtype, np.dtype('c8')) + + assert_raises(TypeError, a.astype, 'i4', casting='safe') + + # subok=False passes through a non-subclassed array + b = a.astype('f4', subok=0, copy=False) + assert_(a is b) + + class MyNDArray(np.ndarray): + pass + + a = np.array([[0, 1, 2], [3, 4, 5]], dtype='f4').view(MyNDArray) + + # subok=True passes through a subclass + b = a.astype('f4', subok=True, copy=False) + assert_(a is b) + + # subok=True is default, and creates a subtype on a cast + b = a.astype('i4', copy=False) + assert_equal(a, b) + assert_equal(type(b), MyNDArray) + + # subok=False never returns a subclass + b = a.astype('f4', subok=False, copy=False) + assert_equal(a, b) + assert_(not (a is b)) + assert_(type(b) is not MyNDArray) + + # Make sure converting from string object to fixed length string + # does not truncate. + a = np.array([b'a'*100], dtype='O') + b = a.astype('S') + assert_equal(a, b) + assert_equal(b.dtype, np.dtype('S100')) + a = np.array(['a'*100], dtype='O') + b = a.astype('U') + assert_equal(a, b) + assert_equal(b.dtype, np.dtype('U100')) + + # Same test as above but for strings shorter than 64 characters + a = np.array([b'a'*10], dtype='O') + b = a.astype('S') + assert_equal(a, b) + assert_equal(b.dtype, np.dtype('S10')) + a = np.array(['a'*10], dtype='O') + b = a.astype('U') + assert_equal(a, b) + assert_equal(b.dtype, np.dtype('U10')) + + a = np.array(123456789012345678901234567890, dtype='O').astype('S') + assert_array_equal(a, np.array(b'1234567890' * 3, dtype='S30')) + a = np.array(123456789012345678901234567890, dtype='O').astype('U') + assert_array_equal(a, np.array('1234567890' * 3, dtype='U30')) + + a = np.array([123456789012345678901234567890], dtype='O').astype('S') + assert_array_equal(a, np.array(b'1234567890' * 3, dtype='S30')) + a = np.array([123456789012345678901234567890], dtype='O').astype('U') + assert_array_equal(a, np.array('1234567890' * 3, dtype='U30')) + + a = np.array(123456789012345678901234567890, dtype='S') + assert_array_equal(a, np.array(b'1234567890' * 3, dtype='S30')) + a = np.array(123456789012345678901234567890, dtype='U') + assert_array_equal(a, np.array('1234567890' * 3, dtype='U30')) + + a = np.array('a\u0140', dtype='U') + b = np.ndarray(buffer=a, dtype='uint32', shape=2) + assert_(b.size == 2) + + a = np.array([1000], dtype='i4') + assert_raises(TypeError, a.astype, 'S1', casting='safe') + + a = np.array(1000, dtype='i4') + assert_raises(TypeError, a.astype, 'U1', casting='safe') + + # gh-24023 + assert_raises(TypeError, a.astype) + +@pytest.mark.parametrize("dt", ["S", "U"]) +def test_array_astype_to_string_discovery_empty(dt): + # See also gh-19085 + arr = np.array([""], dtype=object) + # Note, the itemsize is the `0 -> 1` logic, which should change. + # The important part the test is rather that it does not error. + assert arr.astype(dt).dtype.itemsize == np.dtype(f"{dt}1").itemsize + + # check the same thing for `np.can_cast` (since it accepts arrays) + assert np.can_cast(arr, dt, casting="unsafe") + assert not np.can_cast(arr, dt, casting="same_kind") + # as well as for the object as a descriptor: + assert np.can_cast("O", dt, casting="unsafe") + +@pytest.mark.parametrize("dt", ["d", "f", "S13", "U32"]) +def test_array_astype_to_void(dt): + dt = np.dtype(dt) + arr = np.array([], dtype=dt) + assert arr.astype("V").dtype.itemsize == dt.itemsize + +def test_object_array_astype_to_void(): + # This is different to `test_array_astype_to_void` as object arrays + # are inspected. The default void is "V8" (8 is the length of double) + arr = np.array([], dtype="O").astype("V") + assert arr.dtype == "V8" + +@pytest.mark.parametrize("t", + np._core.sctypes['uint'] + + np._core.sctypes['int'] + + np._core.sctypes['float'] +) +def test_array_astype_warning(t): + # test ComplexWarning when casting from complex to float or int + a = np.array(10, dtype=np.complex128) + assert_warns(np.exceptions.ComplexWarning, a.astype, t) + +@pytest.mark.parametrize(["dtype", "out_dtype"], + [(np.bytes_, np.bool), + (np.str_, np.bool), + (np.dtype("S10,S9"), np.dtype("?,?")), + # The following also checks unaligned unicode access: + (np.dtype("S7,U9"), np.dtype("?,?"))]) +def test_string_to_boolean_cast(dtype, out_dtype): + # Only the last two (empty) strings are falsy (the `\0` is stripped): + arr = np.array( + ["10", "10\0\0\0", "0\0\0", "0", "False", " ", "", "\0"], + dtype=dtype) + expected = np.array( + [True, True, True, True, True, True, False, False], + dtype=out_dtype) + assert_array_equal(arr.astype(out_dtype), expected) + # As it's similar, check that nonzero behaves the same (structs are + # nonzero if all entries are) + assert_array_equal(np.nonzero(arr), np.nonzero(expected)) + +@pytest.mark.parametrize("str_type", [str, bytes, np.str_]) +@pytest.mark.parametrize("scalar_type", + [np.complex64, np.complex128, np.clongdouble]) +def test_string_to_complex_cast(str_type, scalar_type): + value = scalar_type(b"1+3j") + assert scalar_type(value) == 1+3j + assert np.array([value], dtype=object).astype(scalar_type)[()] == 1+3j + assert np.array(value).astype(scalar_type)[()] == 1+3j + arr = np.zeros(1, dtype=scalar_type) + arr[0] = value + assert arr[0] == 1+3j + +@pytest.mark.parametrize("dtype", np.typecodes["AllFloat"]) +def test_none_to_nan_cast(dtype): + # Note that at the time of writing this test, the scalar constructors + # reject None + arr = np.zeros(1, dtype=dtype) + arr[0] = None + assert np.isnan(arr)[0] + assert np.isnan(np.array(None, dtype=dtype))[()] + assert np.isnan(np.array([None], dtype=dtype))[0] + assert np.isnan(np.array(None).astype(dtype))[()] + +def test_copyto_fromscalar(): + a = np.arange(6, dtype='f4').reshape(2, 3) + + # Simple copy + np.copyto(a, 1.5) + assert_equal(a, 1.5) + np.copyto(a.T, 2.5) + assert_equal(a, 2.5) + + # Where-masked copy + mask = np.array([[0, 1, 0], [0, 0, 1]], dtype='?') + np.copyto(a, 3.5, where=mask) + assert_equal(a, [[2.5, 3.5, 2.5], [2.5, 2.5, 3.5]]) + mask = np.array([[0, 1], [1, 1], [1, 0]], dtype='?') + np.copyto(a.T, 4.5, where=mask) + assert_equal(a, [[2.5, 4.5, 4.5], [4.5, 4.5, 3.5]]) + +def test_copyto(): + a = np.arange(6, dtype='i4').reshape(2, 3) + + # Simple copy + np.copyto(a, [[3, 1, 5], [6, 2, 1]]) + assert_equal(a, [[3, 1, 5], [6, 2, 1]]) + + # Overlapping copy should work + np.copyto(a[:, :2], a[::-1, 1::-1]) + assert_equal(a, [[2, 6, 5], [1, 3, 1]]) + + # Defaults to 'same_kind' casting + assert_raises(TypeError, np.copyto, a, 1.5) + + # Force a copy with 'unsafe' casting, truncating 1.5 to 1 + np.copyto(a, 1.5, casting='unsafe') + assert_equal(a, 1) + + # Copying with a mask + np.copyto(a, 3, where=[True, False, True]) + assert_equal(a, [[3, 1, 3], [3, 1, 3]]) + + # Casting rule still applies with a mask + assert_raises(TypeError, np.copyto, a, 3.5, where=[True, False, True]) + + # Lists of integer 0's and 1's is ok too + np.copyto(a, 4.0, casting='unsafe', where=[[0, 1, 1], [1, 0, 0]]) + assert_equal(a, [[3, 4, 4], [4, 1, 3]]) + + # Overlapping copy with mask should work + np.copyto(a[:, :2], a[::-1, 1::-1], where=[[0, 1], [1, 1]]) + assert_equal(a, [[3, 4, 4], [4, 3, 3]]) + + # 'dst' must be an array + assert_raises(TypeError, np.copyto, [1, 2, 3], [2, 3, 4]) + + +def test_copyto_cast_safety(): + with pytest.raises(TypeError): + np.copyto(np.arange(3), 3., casting="safe") + + # Can put integer and float scalars safely (and equiv): + np.copyto(np.arange(3), 3, casting="equiv") + np.copyto(np.arange(3.), 3., casting="equiv") + # And also with less precision safely: + np.copyto(np.arange(3, dtype="uint8"), 3, casting="safe") + np.copyto(np.arange(3., dtype="float32"), 3., casting="safe") + + # But not equiv: + with pytest.raises(TypeError): + np.copyto(np.arange(3, dtype="uint8"), 3, casting="equiv") + + with pytest.raises(TypeError): + np.copyto(np.arange(3., dtype="float32"), 3., casting="equiv") + + # As a special thing, object is equiv currently: + np.copyto(np.arange(3, dtype=object), 3, casting="equiv") + + # The following raises an overflow error/gives a warning but not + # type error (due to casting), though: + with pytest.raises(OverflowError): + np.copyto(np.arange(3), 2**80, casting="safe") + + with pytest.warns(RuntimeWarning): + np.copyto(np.arange(3, dtype=np.float32), 2e300, casting="safe") + + +def test_copyto_permut(): + # test explicit overflow case + pad = 500 + l = [True] * pad + [True, True, True, True] + r = np.zeros(len(l)-pad) + d = np.ones(len(l)-pad) + mask = np.array(l)[pad:] + np.copyto(r, d, where=mask[::-1]) + + # test all permutation of possible masks, 9 should be sufficient for + # current 4 byte unrolled code + power = 9 + d = np.ones(power) + for i in range(2**power): + r = np.zeros(power) + l = [(i & x) != 0 for x in range(power)] + mask = np.array(l) + np.copyto(r, d, where=mask) + assert_array_equal(r == 1, l) + assert_equal(r.sum(), sum(l)) + + r = np.zeros(power) + np.copyto(r, d, where=mask[::-1]) + assert_array_equal(r == 1, l[::-1]) + assert_equal(r.sum(), sum(l)) + + r = np.zeros(power) + np.copyto(r[::2], d[::2], where=mask[::2]) + assert_array_equal(r[::2] == 1, l[::2]) + assert_equal(r[::2].sum(), sum(l[::2])) + + r = np.zeros(power) + np.copyto(r[::2], d[::2], where=mask[::-2]) + assert_array_equal(r[::2] == 1, l[::-2]) + assert_equal(r[::2].sum(), sum(l[::-2])) + + for c in [0xFF, 0x7F, 0x02, 0x10]: + r = np.zeros(power) + mask = np.array(l) + imask = np.array(l).view(np.uint8) + imask[mask != 0] = c + np.copyto(r, d, where=mask) + assert_array_equal(r == 1, l) + assert_equal(r.sum(), sum(l)) + + r = np.zeros(power) + np.copyto(r, d, where=True) + assert_equal(r.sum(), r.size) + r = np.ones(power) + d = np.zeros(power) + np.copyto(r, d, where=False) + assert_equal(r.sum(), r.size) + +def test_copy_order(): + a = np.arange(24).reshape(2, 1, 3, 4) + b = a.copy(order='F') + c = np.arange(24).reshape(2, 1, 4, 3).swapaxes(2, 3) + + def check_copy_result(x, y, ccontig, fcontig, strides=False): + assert_(not (x is y)) + assert_equal(x, y) + assert_equal(res.flags.c_contiguous, ccontig) + assert_equal(res.flags.f_contiguous, fcontig) + + # Validate the initial state of a, b, and c + assert_(a.flags.c_contiguous) + assert_(not a.flags.f_contiguous) + assert_(not b.flags.c_contiguous) + assert_(b.flags.f_contiguous) + assert_(not c.flags.c_contiguous) + assert_(not c.flags.f_contiguous) + + # Copy with order='C' + res = a.copy(order='C') + check_copy_result(res, a, ccontig=True, fcontig=False, strides=True) + res = b.copy(order='C') + check_copy_result(res, b, ccontig=True, fcontig=False, strides=False) + res = c.copy(order='C') + check_copy_result(res, c, ccontig=True, fcontig=False, strides=False) + res = np.copy(a, order='C') + check_copy_result(res, a, ccontig=True, fcontig=False, strides=True) + res = np.copy(b, order='C') + check_copy_result(res, b, ccontig=True, fcontig=False, strides=False) + res = np.copy(c, order='C') + check_copy_result(res, c, ccontig=True, fcontig=False, strides=False) + + # Copy with order='F' + res = a.copy(order='F') + check_copy_result(res, a, ccontig=False, fcontig=True, strides=False) + res = b.copy(order='F') + check_copy_result(res, b, ccontig=False, fcontig=True, strides=True) + res = c.copy(order='F') + check_copy_result(res, c, ccontig=False, fcontig=True, strides=False) + res = np.copy(a, order='F') + check_copy_result(res, a, ccontig=False, fcontig=True, strides=False) + res = np.copy(b, order='F') + check_copy_result(res, b, ccontig=False, fcontig=True, strides=True) + res = np.copy(c, order='F') + check_copy_result(res, c, ccontig=False, fcontig=True, strides=False) + + # Copy with order='K' + res = a.copy(order='K') + check_copy_result(res, a, ccontig=True, fcontig=False, strides=True) + res = b.copy(order='K') + check_copy_result(res, b, ccontig=False, fcontig=True, strides=True) + res = c.copy(order='K') + check_copy_result(res, c, ccontig=False, fcontig=False, strides=True) + res = np.copy(a, order='K') + check_copy_result(res, a, ccontig=True, fcontig=False, strides=True) + res = np.copy(b, order='K') + check_copy_result(res, b, ccontig=False, fcontig=True, strides=True) + res = np.copy(c, order='K') + check_copy_result(res, c, ccontig=False, fcontig=False, strides=True) + +def test_contiguous_flags(): + a = np.ones((4, 4, 1))[::2,:,:] + a.strides = a.strides[:2] + (-123,) + b = np.ones((2, 2, 1, 2, 2)).swapaxes(3, 4) + + def check_contig(a, ccontig, fcontig): + assert_(a.flags.c_contiguous == ccontig) + assert_(a.flags.f_contiguous == fcontig) + + # Check if new arrays are correct: + check_contig(a, False, False) + check_contig(b, False, False) + check_contig(np.empty((2, 2, 0, 2, 2)), True, True) + check_contig(np.array([[[1], [2]]], order='F'), True, True) + check_contig(np.empty((2, 2)), True, False) + check_contig(np.empty((2, 2), order='F'), False, True) + + # Check that np.array creates correct contiguous flags: + check_contig(np.array(a, copy=None), False, False) + check_contig(np.array(a, copy=None, order='C'), True, False) + check_contig(np.array(a, ndmin=4, copy=None, order='F'), False, True) + + # Check slicing update of flags and : + check_contig(a[0], True, True) + check_contig(a[None, ::4, ..., None], True, True) + check_contig(b[0, 0, ...], False, True) + check_contig(b[:, :, 0:0, :, :], True, True) + + # Test ravel and squeeze. + check_contig(a.ravel(), True, True) + check_contig(np.ones((1, 3, 1)).squeeze(), True, True) + +def test_broadcast_arrays(): + # Test user defined dtypes + a = np.array([(1, 2, 3)], dtype='u4,u4,u4') + b = np.array([(1, 2, 3), (4, 5, 6), (7, 8, 9)], dtype='u4,u4,u4') + result = np.broadcast_arrays(a, b) + assert_equal(result[0], np.array([(1, 2, 3), (1, 2, 3), (1, 2, 3)], dtype='u4,u4,u4')) + assert_equal(result[1], np.array([(1, 2, 3), (4, 5, 6), (7, 8, 9)], dtype='u4,u4,u4')) + +@pytest.mark.parametrize(["shape", "fill_value", "expected_output"], + [((2, 2), [5.0, 6.0], np.array([[5.0, 6.0], [5.0, 6.0]])), + ((3, 2), [1.0, 2.0], np.array([[1.0, 2.0], [1.0, 2.0], [1.0, 2.0]]))]) +def test_full_from_list(shape, fill_value, expected_output): + output = np.full(shape, fill_value) + assert_equal(output, expected_output) + +def test_astype_copyflag(): + # test the various copyflag options + arr = np.arange(10, dtype=np.intp) + + res_true = arr.astype(np.intp, copy=True) + assert not np.shares_memory(arr, res_true) + + res_false = arr.astype(np.intp, copy=False) + assert np.shares_memory(arr, res_false) + + res_false_float = arr.astype(np.float64, copy=False) + assert not np.shares_memory(arr, res_false_float) + + # _CopyMode enum isn't allowed + assert_raises(ValueError, arr.astype, np.float64, + copy=np._CopyMode.NEVER) diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/test_argparse.py b/venv/lib/python3.12/site-packages/numpy/_core/tests/test_argparse.py new file mode 100644 index 00000000..ededced3 --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/tests/test_argparse.py @@ -0,0 +1,90 @@ +""" +Tests for the private NumPy argument parsing functionality. +They mainly exists to ensure good test coverage without having to try the +weirder cases on actual numpy functions but test them in one place. + +The test function is defined in C to be equivalent to (errors may not always +match exactly, and could be adjusted): + + def func(arg1, /, arg2, *, arg3): + i = integer(arg1) # reproducing the 'i' parsing in Python. + return None +""" + +import threading + +import pytest + +import numpy as np +from numpy._core._multiarray_tests import ( + argparse_example_function as func, + threaded_argparse_example_function as thread_func, +) +from numpy.testing import IS_WASM + + +@pytest.mark.skipif(IS_WASM, reason="wasm doesn't have support for threads") +def test_thread_safe_argparse_cache(): + b = threading.Barrier(8) + + def call_thread_func(): + b.wait() + thread_func(arg1=3, arg2=None) + + tasks = [threading.Thread(target=call_thread_func) for _ in range(8)] + [t.start() for t in tasks] + [t.join() for t in tasks] + + +def test_invalid_integers(): + with pytest.raises(TypeError, + match="integer argument expected, got float"): + func(1.) + with pytest.raises(OverflowError): + func(2**100) + + +def test_missing_arguments(): + with pytest.raises(TypeError, + match="missing required positional argument 0"): + func() + with pytest.raises(TypeError, + match="missing required positional argument 0"): + func(arg2=1, arg3=4) + with pytest.raises(TypeError, + match=r"missing required argument \'arg2\' \(pos 1\)"): + func(1, arg3=5) + + +def test_too_many_positional(): + # the second argument is positional but can be passed as keyword. + with pytest.raises(TypeError, + match="takes from 2 to 3 positional arguments but 4 were given"): + func(1, 2, 3, 4) + + +def test_multiple_values(): + with pytest.raises(TypeError, + match=r"given by name \('arg2'\) and position \(position 1\)"): + func(1, 2, arg2=3) + + +def test_string_fallbacks(): + # We can (currently?) use numpy strings to test the "slow" fallbacks + # that should normally not be taken due to string interning. + arg2 = np.str_("arg2") + missing_arg = np.str_("missing_arg") + func(1, **{arg2: 3}) + with pytest.raises(TypeError, + match="got an unexpected keyword argument 'missing_arg'"): + func(2, **{missing_arg: 3}) + + +def test_too_many_arguments_method_forwarding(): + # Not directly related to the standard argument parsing, but we sometimes + # forward methods to Python: arr.mean() calls np._core._methods._mean() + # This adds code coverage for this `npy_forward_method`. + arr = np.arange(3) + args = range(1000) + with pytest.raises(TypeError): + arr.mean(*args) diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/test_array_api_info.py b/venv/lib/python3.12/site-packages/numpy/_core/tests/test_array_api_info.py new file mode 100644 index 00000000..154b3837 --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/tests/test_array_api_info.py @@ -0,0 +1,112 @@ +import numpy as np +import pytest + +info = np.__array_namespace_info__() + + +def test_capabilities(): + caps = info.capabilities() + assert caps["boolean indexing"] == True + assert caps["data-dependent shapes"] == True + + # This will be added in the 2024.12 release of the array API standard. + + # assert caps["max rank"] == 64 + # np.zeros((1,)*64) + # with pytest.raises(ValueError): + # np.zeros((1,)*65) + + +def test_default_device(): + assert info.default_device() == "cpu" == np.asarray(0).device + + +def test_default_dtypes(): + dtypes = info.default_dtypes() + assert dtypes["real floating"] == np.float64 == np.asarray(0.0).dtype + assert dtypes["complex floating"] == np.complex128 == \ + np.asarray(0.0j).dtype + assert dtypes["integral"] == np.intp == np.asarray(0).dtype + assert dtypes["indexing"] == np.intp == np.argmax(np.zeros(10)).dtype + + with pytest.raises(ValueError, match="Device not understood"): + info.default_dtypes(device="gpu") + + +def test_dtypes_all(): + dtypes = info.dtypes() + assert dtypes == { + "bool": np.bool_, + "int8": np.int8, + "int16": np.int16, + "int32": np.int32, + "int64": np.int64, + "uint8": np.uint8, + "uint16": np.uint16, + "uint32": np.uint32, + "uint64": np.uint64, + "float32": np.float32, + "float64": np.float64, + "complex64": np.complex64, + "complex128": np.complex128, + } + + +dtype_categories = { + "bool": {"bool": np.bool_}, + "signed integer": { + "int8": np.int8, + "int16": np.int16, + "int32": np.int32, + "int64": np.int64, + }, + "unsigned integer": { + "uint8": np.uint8, + "uint16": np.uint16, + "uint32": np.uint32, + "uint64": np.uint64, + }, + "integral": ("signed integer", "unsigned integer"), + "real floating": {"float32": np.float32, "float64": np.float64}, + "complex floating": {"complex64": np.complex64, "complex128": + np.complex128}, + "numeric": ("integral", "real floating", "complex floating"), +} + + +@pytest.mark.parametrize("kind", dtype_categories) +def test_dtypes_kind(kind): + expected = dtype_categories[kind] + if isinstance(expected, tuple): + assert info.dtypes(kind=kind) == info.dtypes(kind=expected) + else: + assert info.dtypes(kind=kind) == expected + + +def test_dtypes_tuple(): + dtypes = info.dtypes(kind=("bool", "integral")) + assert dtypes == { + "bool": np.bool_, + "int8": np.int8, + "int16": np.int16, + "int32": np.int32, + "int64": np.int64, + "uint8": np.uint8, + "uint16": np.uint16, + "uint32": np.uint32, + "uint64": np.uint64, + } + + +def test_dtypes_invalid_kind(): + with pytest.raises(ValueError, match="unsupported kind"): + info.dtypes(kind="invalid") + + +def test_dtypes_invalid_device(): + with pytest.raises(ValueError, match="Device not understood"): + info.dtypes(device="gpu") + + +def test_devices(): + assert info.devices() == ["cpu"] diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/test_array_coercion.py b/venv/lib/python3.12/site-packages/numpy/_core/tests/test_array_coercion.py new file mode 100644 index 00000000..c2172d40 --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/tests/test_array_coercion.py @@ -0,0 +1,911 @@ +""" +Tests for array coercion, mainly through testing `np.array` results directly. +Note that other such tests exist, e.g., in `test_api.py` and many corner-cases +are tested (sometimes indirectly) elsewhere. +""" + +from itertools import permutations, product + +import pytest +from pytest import param + +import numpy as np +import numpy._core._multiarray_umath as ncu +from numpy._core._rational_tests import rational + +from numpy.testing import ( + assert_array_equal, assert_warns, IS_PYPY) + + +def arraylikes(): + """ + Generator for functions converting an array into various array-likes. + If full is True (default) it includes array-likes not capable of handling + all dtypes. + """ + # base array: + def ndarray(a): + return a + + yield param(ndarray, id="ndarray") + + # subclass: + class MyArr(np.ndarray): + pass + + def subclass(a): + return a.view(MyArr) + + yield subclass + + class _SequenceLike: + # Older NumPy versions, sometimes cared whether a protocol array was + # also _SequenceLike. This shouldn't matter, but keep it for now + # for __array__ and not the others. + def __len__(self): + raise TypeError + + def __getitem__(self): + raise TypeError + + # Array-interface + class ArrayDunder(_SequenceLike): + def __init__(self, a): + self.a = a + + def __array__(self, dtype=None, copy=None): + if dtype is None: + return self.a + return self.a.astype(dtype) + + yield param(ArrayDunder, id="__array__") + + # memory-view + yield param(memoryview, id="memoryview") + + # Array-interface + class ArrayInterface: + def __init__(self, a): + self.a = a # need to hold on to keep interface valid + self.__array_interface__ = a.__array_interface__ + + yield param(ArrayInterface, id="__array_interface__") + + # Array-Struct + class ArrayStruct: + def __init__(self, a): + self.a = a # need to hold on to keep struct valid + self.__array_struct__ = a.__array_struct__ + + yield param(ArrayStruct, id="__array_struct__") + + +def scalar_instances(times=True, extended_precision=True, user_dtype=True): + # Hard-coded list of scalar instances. + # Floats: + yield param(np.sqrt(np.float16(5)), id="float16") + yield param(np.sqrt(np.float32(5)), id="float32") + yield param(np.sqrt(np.float64(5)), id="float64") + if extended_precision: + yield param(np.sqrt(np.longdouble(5)), id="longdouble") + + # Complex: + yield param(np.sqrt(np.complex64(2+3j)), id="complex64") + yield param(np.sqrt(np.complex128(2+3j)), id="complex128") + if extended_precision: + yield param(np.sqrt(np.clongdouble(2+3j)), id="clongdouble") + + # Bool: + # XFAIL: Bool should be added, but has some bad properties when it + # comes to strings, see also gh-9875 + # yield param(np.bool(0), id="bool") + + # Integers: + yield param(np.int8(2), id="int8") + yield param(np.int16(2), id="int16") + yield param(np.int32(2), id="int32") + yield param(np.int64(2), id="int64") + + yield param(np.uint8(2), id="uint8") + yield param(np.uint16(2), id="uint16") + yield param(np.uint32(2), id="uint32") + yield param(np.uint64(2), id="uint64") + + # Rational: + if user_dtype: + yield param(rational(1, 2), id="rational") + + # Cannot create a structured void scalar directly: + structured = np.array([(1, 3)], "i,i")[0] + assert isinstance(structured, np.void) + assert structured.dtype == np.dtype("i,i") + yield param(structured, id="structured") + + if times: + # Datetimes and timedelta + yield param(np.timedelta64(2), id="timedelta64[generic]") + yield param(np.timedelta64(23, "s"), id="timedelta64[s]") + yield param(np.timedelta64("NaT", "s"), id="timedelta64[s](NaT)") + + yield param(np.datetime64("NaT"), id="datetime64[generic](NaT)") + yield param(np.datetime64("2020-06-07 12:43", "ms"), id="datetime64[ms]") + + # Strings and unstructured void: + yield param(np.bytes_(b"1234"), id="bytes") + yield param(np.str_("2345"), id="unicode") + yield param(np.void(b"4321"), id="unstructured_void") + + +def is_parametric_dtype(dtype): + """Returns True if the dtype is a parametric legacy dtype (itemsize + is 0, or a datetime without units) + """ + if dtype.itemsize == 0: + return True + if issubclass(dtype.type, (np.datetime64, np.timedelta64)): + if dtype.name.endswith("64"): + # Generic time units + return True + return False + + +class TestStringDiscovery: + @pytest.mark.parametrize("obj", + [object(), 1.2, 10**43, None, "string"], + ids=["object", "1.2", "10**43", "None", "string"]) + def test_basic_stringlength(self, obj): + length = len(str(obj)) + expected = np.dtype(f"S{length}") + + assert np.array(obj, dtype="S").dtype == expected + assert np.array([obj], dtype="S").dtype == expected + + # A nested array is also discovered correctly + arr = np.array(obj, dtype="O") + assert np.array(arr, dtype="S").dtype == expected + # Also if we use the dtype class + assert np.array(arr, dtype=type(expected)).dtype == expected + # Check that .astype() behaves identical + assert arr.astype("S").dtype == expected + # The DType class is accepted by `.astype()` + assert arr.astype(type(np.dtype("S"))).dtype == expected + + @pytest.mark.parametrize("obj", + [object(), 1.2, 10**43, None, "string"], + ids=["object", "1.2", "10**43", "None", "string"]) + def test_nested_arrays_stringlength(self, obj): + length = len(str(obj)) + expected = np.dtype(f"S{length}") + arr = np.array(obj, dtype="O") + assert np.array([arr, arr], dtype="S").dtype == expected + + @pytest.mark.parametrize("arraylike", arraylikes()) + def test_unpack_first_level(self, arraylike): + # We unpack exactly one level of array likes + obj = np.array([None]) + obj[0] = np.array(1.2) + # the length of the included item, not of the float dtype + length = len(str(obj[0])) + expected = np.dtype(f"S{length}") + + obj = arraylike(obj) + # casting to string usually calls str(obj) + arr = np.array([obj], dtype="S") + assert arr.shape == (1, 1) + assert arr.dtype == expected + + +class TestScalarDiscovery: + def test_void_special_case(self): + # Void dtypes with structures discover tuples as elements + arr = np.array((1, 2, 3), dtype="i,i,i") + assert arr.shape == () + arr = np.array([(1, 2, 3)], dtype="i,i,i") + assert arr.shape == (1,) + + def test_char_special_case(self): + arr = np.array("string", dtype="c") + assert arr.shape == (6,) + assert arr.dtype.char == "c" + arr = np.array(["string"], dtype="c") + assert arr.shape == (1, 6) + assert arr.dtype.char == "c" + + def test_char_special_case_deep(self): + # Check that the character special case errors correctly if the + # array is too deep: + nested = ["string"] # 2 dimensions (due to string being sequence) + for i in range(ncu.MAXDIMS - 2): + nested = [nested] + + arr = np.array(nested, dtype='c') + assert arr.shape == (1,) * (ncu.MAXDIMS - 1) + (6,) + with pytest.raises(ValueError): + np.array([nested], dtype="c") + + def test_unknown_object(self): + arr = np.array(object()) + assert arr.shape == () + assert arr.dtype == np.dtype("O") + + @pytest.mark.parametrize("scalar", scalar_instances()) + def test_scalar(self, scalar): + arr = np.array(scalar) + assert arr.shape == () + assert arr.dtype == scalar.dtype + + arr = np.array([[scalar, scalar]]) + assert arr.shape == (1, 2) + assert arr.dtype == scalar.dtype + + # Additionally to string this test also runs into a corner case + # with datetime promotion (the difference is the promotion order). + @pytest.mark.filterwarnings("ignore:Promotion of numbers:FutureWarning") + def test_scalar_promotion(self): + for sc1, sc2 in product(scalar_instances(), scalar_instances()): + sc1, sc2 = sc1.values[0], sc2.values[0] + # test all combinations: + try: + arr = np.array([sc1, sc2]) + except (TypeError, ValueError): + # The promotion between two times can fail + # XFAIL (ValueError): Some object casts are currently undefined + continue + assert arr.shape == (2,) + try: + dt1, dt2 = sc1.dtype, sc2.dtype + expected_dtype = np.promote_types(dt1, dt2) + assert arr.dtype == expected_dtype + except TypeError as e: + # Will currently always go to object dtype + assert arr.dtype == np.dtype("O") + + @pytest.mark.parametrize("scalar", scalar_instances()) + def test_scalar_coercion(self, scalar): + # This tests various scalar coercion paths, mainly for the numerical + # types. It includes some paths not directly related to `np.array`. + if isinstance(scalar, np.inexact): + # Ensure we have a full-precision number if available + scalar = type(scalar)((scalar * 2)**0.5) + + if type(scalar) is rational: + # Rational generally fails due to a missing cast. In the future + # object casts should automatically be defined based on `setitem`. + pytest.xfail("Rational to object cast is undefined currently.") + + # Use casting from object: + arr = np.array(scalar, dtype=object).astype(scalar.dtype) + + # Test various ways to create an array containing this scalar: + arr1 = np.array(scalar).reshape(1) + arr2 = np.array([scalar]) + arr3 = np.empty(1, dtype=scalar.dtype) + arr3[0] = scalar + arr4 = np.empty(1, dtype=scalar.dtype) + arr4[:] = [scalar] + # All of these methods should yield the same results + assert_array_equal(arr, arr1) + assert_array_equal(arr, arr2) + assert_array_equal(arr, arr3) + assert_array_equal(arr, arr4) + + @pytest.mark.xfail(IS_PYPY, reason="`int(np.complex128(3))` fails on PyPy") + @pytest.mark.filterwarnings("ignore::numpy.exceptions.ComplexWarning") + @pytest.mark.parametrize("cast_to", scalar_instances()) + def test_scalar_coercion_same_as_cast_and_assignment(self, cast_to): + """ + Test that in most cases: + * `np.array(scalar, dtype=dtype)` + * `np.empty((), dtype=dtype)[()] = scalar` + * `np.array(scalar).astype(dtype)` + should behave the same. The only exceptions are parametric dtypes + (mainly datetime/timedelta without unit) and void without fields. + """ + dtype = cast_to.dtype # use to parametrize only the target dtype + + for scalar in scalar_instances(times=False): + scalar = scalar.values[0] + + if dtype.type == np.void: + if scalar.dtype.fields is not None and dtype.fields is None: + # Here, coercion to "V6" works, but the cast fails. + # Since the types are identical, SETITEM takes care of + # this, but has different rules than the cast. + with pytest.raises(TypeError): + np.array(scalar).astype(dtype) + np.array(scalar, dtype=dtype) + np.array([scalar], dtype=dtype) + continue + + # The main test, we first try to use casting and if it succeeds + # continue below testing that things are the same, otherwise + # test that the alternative paths at least also fail. + try: + cast = np.array(scalar).astype(dtype) + except (TypeError, ValueError, RuntimeError): + # coercion should also raise (error type may change) + with pytest.raises(Exception): + np.array(scalar, dtype=dtype) + + if (isinstance(scalar, rational) and + np.issubdtype(dtype, np.signedinteger)): + return + + with pytest.raises(Exception): + np.array([scalar], dtype=dtype) + # assignment should also raise + res = np.zeros((), dtype=dtype) + with pytest.raises(Exception): + res[()] = scalar + + return + + # Non error path: + arr = np.array(scalar, dtype=dtype) + assert_array_equal(arr, cast) + # assignment behaves the same + ass = np.zeros((), dtype=dtype) + ass[()] = scalar + assert_array_equal(ass, cast) + + @pytest.mark.parametrize("pyscalar", [10, 10.32, 10.14j, 10**100]) + def test_pyscalar_subclasses(self, pyscalar): + """NumPy arrays are read/write which means that anything but invariant + behaviour is on thin ice. However, we currently are happy to discover + subclasses of Python float, int, complex the same as the base classes. + This should potentially be deprecated. + """ + class MyScalar(type(pyscalar)): + pass + + res = np.array(MyScalar(pyscalar)) + expected = np.array(pyscalar) + assert_array_equal(res, expected) + + @pytest.mark.parametrize("dtype_char", np.typecodes["All"]) + def test_default_dtype_instance(self, dtype_char): + if dtype_char in "SU": + dtype = np.dtype(dtype_char + "1") + elif dtype_char == "V": + # Legacy behaviour was to use V8. The reason was float64 being the + # default dtype and that having 8 bytes. + dtype = np.dtype("V8") + else: + dtype = np.dtype(dtype_char) + + discovered_dtype, _ = ncu._discover_array_parameters([], type(dtype)) + + assert discovered_dtype == dtype + assert discovered_dtype.itemsize == dtype.itemsize + + @pytest.mark.parametrize("dtype", np.typecodes["Integer"]) + @pytest.mark.parametrize(["scalar", "error"], + [(np.float64(np.nan), ValueError), + (np.array(-1).astype(np.ulonglong)[()], OverflowError)]) + def test_scalar_to_int_coerce_does_not_cast(self, dtype, scalar, error): + """ + Signed integers are currently different in that they do not cast other + NumPy scalar, but instead use scalar.__int__(). The hardcoded + exception to this rule is `np.array(scalar, dtype=integer)`. + """ + dtype = np.dtype(dtype) + + # This is a special case using casting logic. It warns for the NaN + # but allows the cast (giving undefined behaviour). + with np.errstate(invalid="ignore"): + coerced = np.array(scalar, dtype=dtype) + cast = np.array(scalar).astype(dtype) + assert_array_equal(coerced, cast) + + # However these fail: + with pytest.raises(error): + np.array([scalar], dtype=dtype) + with pytest.raises(error): + cast[()] = scalar + + +class TestTimeScalars: + @pytest.mark.parametrize("dtype", [np.int64, np.float32]) + @pytest.mark.parametrize("scalar", + [param(np.timedelta64("NaT", "s"), id="timedelta64[s](NaT)"), + param(np.timedelta64(123, "s"), id="timedelta64[s]"), + param(np.datetime64("NaT", "generic"), id="datetime64[generic](NaT)"), + param(np.datetime64(1, "D"), id="datetime64[D]")],) + def test_coercion_basic(self, dtype, scalar): + # Note the `[scalar]` is there because np.array(scalar) uses stricter + # `scalar.__int__()` rules for backward compatibility right now. + arr = np.array(scalar, dtype=dtype) + cast = np.array(scalar).astype(dtype) + assert_array_equal(arr, cast) + + ass = np.ones((), dtype=dtype) + if issubclass(dtype, np.integer): + with pytest.raises(TypeError): + # raises, as would np.array([scalar], dtype=dtype), this is + # conversion from times, but behaviour of integers. + ass[()] = scalar + else: + ass[()] = scalar + assert_array_equal(ass, cast) + + @pytest.mark.parametrize("dtype", [np.int64, np.float32]) + @pytest.mark.parametrize("scalar", + [param(np.timedelta64(123, "ns"), id="timedelta64[ns]"), + param(np.timedelta64(12, "generic"), id="timedelta64[generic]")]) + def test_coercion_timedelta_convert_to_number(self, dtype, scalar): + # Only "ns" and "generic" timedeltas can be converted to numbers + # so these are slightly special. + arr = np.array(scalar, dtype=dtype) + cast = np.array(scalar).astype(dtype) + ass = np.ones((), dtype=dtype) + ass[()] = scalar # raises, as would np.array([scalar], dtype=dtype) + + assert_array_equal(arr, cast) + assert_array_equal(cast, cast) + + @pytest.mark.parametrize("dtype", ["S6", "U6"]) + @pytest.mark.parametrize(["val", "unit"], + [param(123, "s", id="[s]"), param(123, "D", id="[D]")]) + def test_coercion_assignment_datetime(self, val, unit, dtype): + # String from datetime64 assignment is currently special cased to + # never use casting. This is because casting will error in this + # case, and traditionally in most cases the behaviour is maintained + # like this. (`np.array(scalar, dtype="U6")` would have failed before) + # TODO: This discrepancy _should_ be resolved, either by relaxing the + # cast, or by deprecating the first part. + scalar = np.datetime64(val, unit) + dtype = np.dtype(dtype) + cut_string = dtype.type(str(scalar)[:6]) + + arr = np.array(scalar, dtype=dtype) + assert arr[()] == cut_string + ass = np.ones((), dtype=dtype) + ass[()] = scalar + assert ass[()] == cut_string + + with pytest.raises(RuntimeError): + # However, unlike the above assignment using `str(scalar)[:6]` + # due to being handled by the string DType and not be casting + # the explicit cast fails: + np.array(scalar).astype(dtype) + + + @pytest.mark.parametrize(["val", "unit"], + [param(123, "s", id="[s]"), param(123, "D", id="[D]")]) + def test_coercion_assignment_timedelta(self, val, unit): + scalar = np.timedelta64(val, unit) + + # Unlike datetime64, timedelta allows the unsafe cast: + np.array(scalar, dtype="S6") + cast = np.array(scalar).astype("S6") + ass = np.ones((), dtype="S6") + ass[()] = scalar + expected = scalar.astype("S")[:6] + assert cast[()] == expected + assert ass[()] == expected + +class TestNested: + def test_nested_simple(self): + initial = [1.2] + nested = initial + for i in range(ncu.MAXDIMS - 1): + nested = [nested] + + arr = np.array(nested, dtype="float64") + assert arr.shape == (1,) * ncu.MAXDIMS + with pytest.raises(ValueError): + np.array([nested], dtype="float64") + + with pytest.raises(ValueError, match=".*would exceed the maximum"): + np.array([nested]) # user must ask for `object` explicitly + + arr = np.array([nested], dtype=object) + assert arr.dtype == np.dtype("O") + assert arr.shape == (1,) * ncu.MAXDIMS + assert arr.item() is initial + + def test_pathological_self_containing(self): + # Test that this also works for two nested sequences + l = [] + l.append(l) + arr = np.array([l, l, l], dtype=object) + assert arr.shape == (3,) + (1,) * (ncu.MAXDIMS - 1) + + # Also check a ragged case: + arr = np.array([l, [None], l], dtype=object) + assert arr.shape == (3, 1) + + @pytest.mark.parametrize("arraylike", arraylikes()) + def test_nested_arraylikes(self, arraylike): + # We try storing an array like into an array, but the array-like + # will have too many dimensions. This means the shape discovery + # decides that the array-like must be treated as an object (a special + # case of ragged discovery). The result will be an array with one + # dimension less than the maximum dimensions, and the array being + # assigned to it (which does work for object or if `float(arraylike)` + # works). + initial = arraylike(np.ones((1, 1))) + + nested = initial + for i in range(ncu.MAXDIMS - 1): + nested = [nested] + + with pytest.raises(ValueError, match=".*would exceed the maximum"): + # It will refuse to assign the array into + np.array(nested, dtype="float64") + + # If this is object, we end up assigning a (1, 1) array into (1,) + # (due to running out of dimensions), this is currently supported but + # a special case which is not ideal. + arr = np.array(nested, dtype=object) + assert arr.shape == (1,) * ncu.MAXDIMS + assert arr.item() == np.array(initial).item() + + @pytest.mark.parametrize("arraylike", arraylikes()) + def test_uneven_depth_ragged(self, arraylike): + arr = np.arange(4).reshape((2, 2)) + arr = arraylike(arr) + + # Array is ragged in the second dimension already: + out = np.array([arr, [arr]], dtype=object) + assert out.shape == (2,) + assert out[0] is arr + assert type(out[1]) is list + + # Array is ragged in the third dimension: + with pytest.raises(ValueError): + # This is a broadcast error during assignment, because + # the array shape would be (2, 2, 2) but `arr[0, 0] = arr` fails. + np.array([arr, [arr, arr]], dtype=object) + + def test_empty_sequence(self): + arr = np.array([[], [1], [[1]]], dtype=object) + assert arr.shape == (3,) + + # The empty sequence stops further dimension discovery, so the + # result shape will be (0,) which leads to an error during: + with pytest.raises(ValueError): + np.array([[], np.empty((0, 1))], dtype=object) + + def test_array_of_different_depths(self): + # When multiple arrays (or array-likes) are included in a + # sequences and have different depth, we currently discover + # as many dimensions as they share. (see also gh-17224) + arr = np.zeros((3, 2)) + mismatch_first_dim = np.zeros((1, 2)) + mismatch_second_dim = np.zeros((3, 3)) + + dtype, shape = ncu._discover_array_parameters( + [arr, mismatch_second_dim], dtype=np.dtype("O")) + assert shape == (2, 3) + + dtype, shape = ncu._discover_array_parameters( + [arr, mismatch_first_dim], dtype=np.dtype("O")) + assert shape == (2,) + # The second case is currently supported because the arrays + # can be stored as objects: + res = np.asarray([arr, mismatch_first_dim], dtype=np.dtype("O")) + assert res[0] is arr + assert res[1] is mismatch_first_dim + + +class TestBadSequences: + # These are tests for bad objects passed into `np.array`, in general + # these have undefined behaviour. In the old code they partially worked + # when now they will fail. We could (and maybe should) create a copy + # of all sequences to be safe against bad-actors. + + def test_growing_list(self): + # List to coerce, `mylist` will append to it during coercion + obj = [] + class mylist(list): + def __len__(self): + obj.append([1, 2]) + return super().__len__() + + obj.append(mylist([1, 2])) + + with pytest.raises(RuntimeError): + np.array(obj) + + # Note: We do not test a shrinking list. These do very evil things + # and the only way to fix them would be to copy all sequences. + # (which may be a real option in the future). + + def test_mutated_list(self): + # List to coerce, `mylist` will mutate the first element + obj = [] + class mylist(list): + def __len__(self): + obj[0] = [2, 3] # replace with a different list. + return super().__len__() + + obj.append([2, 3]) + obj.append(mylist([1, 2])) + # Does not crash: + np.array(obj) + + def test_replace_0d_array(self): + # List to coerce, `mylist` will mutate the first element + obj = [] + class baditem: + def __len__(self): + obj[0][0] = 2 # replace with a different list. + raise ValueError("not actually a sequence!") + + def __getitem__(self): + pass + + # Runs into a corner case in the new code, the `array(2)` is cached + # so replacing it invalidates the cache. + obj.append([np.array(2), baditem()]) + with pytest.raises(RuntimeError): + np.array(obj) + + +class TestArrayLikes: + @pytest.mark.parametrize("arraylike", arraylikes()) + def test_0d_object_special_case(self, arraylike): + arr = np.array(0.) + obj = arraylike(arr) + # A single array-like is always converted: + res = np.array(obj, dtype=object) + assert_array_equal(arr, res) + + # But a single 0-D nested array-like never: + res = np.array([obj], dtype=object) + assert res[0] is obj + + @pytest.mark.parametrize("arraylike", arraylikes()) + @pytest.mark.parametrize("arr", [np.array(0.), np.arange(4)]) + def test_object_assignment_special_case(self, arraylike, arr): + obj = arraylike(arr) + empty = np.arange(1, dtype=object) + empty[:] = [obj] + assert empty[0] is obj + + def test_0d_generic_special_case(self): + class ArraySubclass(np.ndarray): + def __float__(self): + raise TypeError("e.g. quantities raise on this") + + arr = np.array(0.) + obj = arr.view(ArraySubclass) + res = np.array(obj) + # The subclass is simply cast: + assert_array_equal(arr, res) + + # If the 0-D array-like is included, __float__ is currently + # guaranteed to be used. We may want to change that, quantities + # and masked arrays half make use of this. + with pytest.raises(TypeError): + np.array([obj]) + + # The same holds for memoryview: + obj = memoryview(arr) + res = np.array(obj) + assert_array_equal(arr, res) + with pytest.raises(ValueError): + # The error type does not matter much here. + np.array([obj]) + + def test_arraylike_classes(self): + # The classes of array-likes should generally be acceptable to be + # stored inside a numpy (object) array. This tests all of the + # special attributes (since all are checked during coercion). + arr = np.array(np.int64) + assert arr[()] is np.int64 + arr = np.array([np.int64]) + assert arr[0] is np.int64 + + # This also works for properties/unbound methods: + class ArrayLike: + @property + def __array_interface__(self): + pass + + @property + def __array_struct__(self): + pass + + def __array__(self, dtype=None, copy=None): + pass + + arr = np.array(ArrayLike) + assert arr[()] is ArrayLike + arr = np.array([ArrayLike]) + assert arr[0] is ArrayLike + + @pytest.mark.skipif( + np.dtype(np.intp).itemsize < 8, reason="Needs 64bit platform") + def test_too_large_array_error_paths(self): + """Test the error paths, including for memory leaks""" + arr = np.array(0, dtype="uint8") + # Guarantees that a contiguous copy won't work: + arr = np.broadcast_to(arr, 2**62) + + for i in range(5): + # repeat, to ensure caching cannot have an effect: + with pytest.raises(MemoryError): + np.array(arr) + with pytest.raises(MemoryError): + np.array([arr]) + + @pytest.mark.parametrize("attribute", + ["__array_interface__", "__array__", "__array_struct__"]) + @pytest.mark.parametrize("error", [RecursionError, MemoryError]) + def test_bad_array_like_attributes(self, attribute, error): + # RecursionError and MemoryError are considered fatal. All errors + # (except AttributeError) should probably be raised in the future, + # but shapely made use of it, so it will require a deprecation. + + class BadInterface: + def __getattr__(self, attr): + if attr == attribute: + raise error + super().__getattr__(attr) + + with pytest.raises(error): + np.array(BadInterface()) + + @pytest.mark.parametrize("error", [RecursionError, MemoryError]) + def test_bad_array_like_bad_length(self, error): + # RecursionError and MemoryError are considered "critical" in + # sequences. We could expand this more generally though. (NumPy 1.20) + class BadSequence: + def __len__(self): + raise error + def __getitem__(self): + # must have getitem to be a Sequence + return 1 + + with pytest.raises(error): + np.array(BadSequence()) + + def test_array_interface_descr_optional(self): + # The descr should be optional regresion test for gh-27249 + arr = np.ones(10, dtype="V10") + iface = arr.__array_interface__ + iface.pop("descr") + + class MyClass: + __array_interface__ = iface + + assert_array_equal(np.asarray(MyClass), arr) + + +class TestAsArray: + """Test expected behaviors of ``asarray``.""" + + def test_dtype_identity(self): + """Confirm the intended behavior for *dtype* kwarg. + + The result of ``asarray()`` should have the dtype provided through the + keyword argument, when used. This forces unique array handles to be + produced for unique np.dtype objects, but (for equivalent dtypes), the + underlying data (the base object) is shared with the original array + object. + + Ref https://github.com/numpy/numpy/issues/1468 + """ + int_array = np.array([1, 2, 3], dtype='i') + assert np.asarray(int_array) is int_array + + # The character code resolves to the singleton dtype object provided + # by the numpy package. + assert np.asarray(int_array, dtype='i') is int_array + + # Derive a dtype from n.dtype('i'), but add a metadata object to force + # the dtype to be distinct. + unequal_type = np.dtype('i', metadata={'spam': True}) + annotated_int_array = np.asarray(int_array, dtype=unequal_type) + assert annotated_int_array is not int_array + assert annotated_int_array.base is int_array + # Create an equivalent descriptor with a new and distinct dtype + # instance. + equivalent_requirement = np.dtype('i', metadata={'spam': True}) + annotated_int_array_alt = np.asarray(annotated_int_array, + dtype=equivalent_requirement) + assert unequal_type == equivalent_requirement + assert unequal_type is not equivalent_requirement + assert annotated_int_array_alt is not annotated_int_array + assert annotated_int_array_alt.dtype is equivalent_requirement + + # Check the same logic for a pair of C types whose equivalence may vary + # between computing environments. + # Find an equivalent pair. + integer_type_codes = ('i', 'l', 'q') + integer_dtypes = [np.dtype(code) for code in integer_type_codes] + typeA = None + typeB = None + for typeA, typeB in permutations(integer_dtypes, r=2): + if typeA == typeB: + assert typeA is not typeB + break + assert isinstance(typeA, np.dtype) and isinstance(typeB, np.dtype) + + # These ``asarray()`` calls may produce a new view or a copy, + # but never the same object. + long_int_array = np.asarray(int_array, dtype='l') + long_long_int_array = np.asarray(int_array, dtype='q') + assert long_int_array is not int_array + assert long_long_int_array is not int_array + assert np.asarray(long_int_array, dtype='q') is not long_int_array + array_a = np.asarray(int_array, dtype=typeA) + assert typeA == typeB + assert typeA is not typeB + assert array_a.dtype is typeA + assert array_a is not np.asarray(array_a, dtype=typeB) + assert np.asarray(array_a, dtype=typeB).dtype is typeB + assert array_a is np.asarray(array_a, dtype=typeB).base + + +class TestSpecialAttributeLookupFailure: + # An exception was raised while fetching the attribute + + class WeirdArrayLike: + @property + def __array__(self, dtype=None, copy=None): + raise RuntimeError("oops!") + + class WeirdArrayInterface: + @property + def __array_interface__(self): + raise RuntimeError("oops!") + + def test_deprecated(self): + with pytest.raises(RuntimeError): + np.array(self.WeirdArrayLike()) + with pytest.raises(RuntimeError): + np.array(self.WeirdArrayInterface()) + + +def test_subarray_from_array_construction(): + # Arrays are more complex, since they "broadcast" on success: + arr = np.array([1, 2]) + + res = arr.astype("2i") + assert_array_equal(res, [[1, 1], [2, 2]]) + + res = np.array(arr, dtype="(2,)i") + + assert_array_equal(res, [[1, 1], [2, 2]]) + + res = np.array([[(1,), (2,)], arr], dtype="2i") + assert_array_equal(res, [[[1, 1], [2, 2]], [[1, 1], [2, 2]]]) + + # Also try a multi-dimensional example: + arr = np.arange(5 * 2).reshape(5, 2) + expected = np.broadcast_to(arr[:, :, np.newaxis, np.newaxis], (5, 2, 2, 2)) + + res = arr.astype("(2,2)f") + assert_array_equal(res, expected) + + res = np.array(arr, dtype="(2,2)f") + assert_array_equal(res, expected) + + +def test_empty_string(): + # Empty strings are unfortunately often converted to S1 and we need to + # make sure we are filling the S1 and not the (possibly) detected S0 + # result. This should likely just return S0 and if not maybe the decision + # to return S1 should be moved. + res = np.array([""] * 10, dtype="S") + assert_array_equal(res, np.array("\0", "S1")) + assert res.dtype == "S1" + + arr = np.array([""] * 10, dtype=object) + + res = arr.astype("S") + assert_array_equal(res, b"") + assert res.dtype == "S1" + + res = np.array(arr, dtype="S") + assert_array_equal(res, b"") + # TODO: This is arguably weird/wrong, but seems old: + assert res.dtype == f"S{np.dtype('O').itemsize}" + + res = np.array([[""] * 10, arr], dtype="S") + assert_array_equal(res, b"") + assert res.shape == (2, 10) + assert res.dtype == "S1" diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/test_array_interface.py b/venv/lib/python3.12/site-packages/numpy/_core/tests/test_array_interface.py new file mode 100644 index 00000000..ae719568 --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/tests/test_array_interface.py @@ -0,0 +1,219 @@ +import sys +import pytest +import numpy as np +from numpy.testing import extbuild, IS_WASM, IS_EDITABLE + + +@pytest.fixture +def get_module(tmp_path): + """ Some codes to generate data and manage temporary buffers use when + sharing with numpy via the array interface protocol. + """ + if sys.platform.startswith('cygwin'): + pytest.skip('link fails on cygwin') + if IS_WASM: + pytest.skip("Can't build module inside Wasm") + if IS_EDITABLE: + pytest.skip("Can't build module for editable install") + + prologue = ''' + #include + #define NPY_NO_DEPRECATED_API NPY_1_7_API_VERSION + #include + #include + #include + + NPY_NO_EXPORT + void delete_array_struct(PyObject *cap) { + + /* get the array interface structure */ + PyArrayInterface *inter = (PyArrayInterface*) + PyCapsule_GetPointer(cap, NULL); + + /* get the buffer by which data was shared */ + double *ptr = (double*)PyCapsule_GetContext(cap); + + /* for the purposes of the regression test set the elements + to nan */ + for (npy_intp i = 0; i < inter->shape[0]; ++i) + ptr[i] = nan(""); + + /* free the shared buffer */ + free(ptr); + + /* free the array interface structure */ + free(inter->shape); + free(inter); + + fprintf(stderr, "delete_array_struct\\ncap = %ld inter = %ld" + " ptr = %ld\\n", (long)cap, (long)inter, (long)ptr); + } + ''' + + functions = [ + ("new_array_struct", "METH_VARARGS", """ + + long long n_elem = 0; + double value = 0.0; + + if (!PyArg_ParseTuple(args, "Ld", &n_elem, &value)) { + Py_RETURN_NONE; + } + + /* allocate and initialize the data to share with numpy */ + long long n_bytes = n_elem*sizeof(double); + double *data = (double*)malloc(n_bytes); + + if (!data) { + PyErr_Format(PyExc_MemoryError, + "Failed to malloc %lld bytes", n_bytes); + + Py_RETURN_NONE; + } + + for (long long i = 0; i < n_elem; ++i) { + data[i] = value; + } + + /* calculate the shape and stride */ + int nd = 1; + + npy_intp *ss = (npy_intp*)malloc(2*nd*sizeof(npy_intp)); + npy_intp *shape = ss; + npy_intp *stride = ss + nd; + + shape[0] = n_elem; + stride[0] = sizeof(double); + + /* construct the array interface */ + PyArrayInterface *inter = (PyArrayInterface*) + malloc(sizeof(PyArrayInterface)); + + memset(inter, 0, sizeof(PyArrayInterface)); + + inter->two = 2; + inter->nd = nd; + inter->typekind = 'f'; + inter->itemsize = sizeof(double); + inter->shape = shape; + inter->strides = stride; + inter->data = data; + inter->flags = NPY_ARRAY_WRITEABLE | NPY_ARRAY_NOTSWAPPED | + NPY_ARRAY_ALIGNED | NPY_ARRAY_C_CONTIGUOUS; + + /* package into a capsule */ + PyObject *cap = PyCapsule_New(inter, NULL, delete_array_struct); + + /* save the pointer to the data */ + PyCapsule_SetContext(cap, data); + + fprintf(stderr, "new_array_struct\\ncap = %ld inter = %ld" + " ptr = %ld\\n", (long)cap, (long)inter, (long)data); + + return cap; + """) + ] + + more_init = "import_array();" + + try: + import array_interface_testing + return array_interface_testing + except ImportError: + pass + + # if it does not exist, build and load it + return extbuild.build_and_import_extension('array_interface_testing', + functions, + prologue=prologue, + include_dirs=[np.get_include()], + build_dir=tmp_path, + more_init=more_init) + + +@pytest.mark.slow +def test_cstruct(get_module): + + class data_source: + """ + This class is for testing the timing of the PyCapsule destructor + invoked when numpy release its reference to the shared data as part of + the numpy array interface protocol. If the PyCapsule destructor is + called early the shared data is freed and invalid memory accesses will + occur. + """ + + def __init__(self, size, value): + self.size = size + self.value = value + + @property + def __array_struct__(self): + return get_module.new_array_struct(self.size, self.value) + + # write to the same stream as the C code + stderr = sys.__stderr__ + + # used to validate the shared data. + expected_value = -3.1415 + multiplier = -10000.0 + + # create some data to share with numpy via the array interface + # assign the data an expected value. + stderr.write(' ---- create an object to share data ---- \n') + buf = data_source(256, expected_value) + stderr.write(' ---- OK!\n\n') + + # share the data + stderr.write(' ---- share data via the array interface protocol ---- \n') + arr = np.array(buf, copy=False) + stderr.write('arr.__array_interface___ = %s\n' % ( + str(arr.__array_interface__))) + stderr.write('arr.base = %s\n' % (str(arr.base))) + stderr.write(' ---- OK!\n\n') + + # release the source of the shared data. this will not release the data + # that was shared with numpy, that is done in the PyCapsule destructor. + stderr.write(' ---- destroy the object that shared data ---- \n') + buf = None + stderr.write(' ---- OK!\n\n') + + # check that we got the expected data. If the PyCapsule destructor we + # defined was prematurely called then this test will fail because our + # destructor sets the elements of the array to NaN before free'ing the + # buffer. Reading the values here may also cause a SEGV + assert np.allclose(arr, expected_value) + + # read the data. If the PyCapsule destructor we defined was prematurely + # called then reading the values here may cause a SEGV and will be reported + # as invalid reads by valgrind + stderr.write(' ---- read shared data ---- \n') + stderr.write('arr = %s\n' % (str(arr))) + stderr.write(' ---- OK!\n\n') + + # write to the shared buffer. If the shared data was prematurely deleted + # this will may cause a SEGV and valgrind will report invalid writes + stderr.write(' ---- modify shared data ---- \n') + arr *= multiplier + expected_value *= multiplier + stderr.write('arr.__array_interface___ = %s\n' % ( + str(arr.__array_interface__))) + stderr.write('arr.base = %s\n' % (str(arr.base))) + stderr.write(' ---- OK!\n\n') + + # read the data. If the shared data was prematurely deleted this + # will may cause a SEGV and valgrind will report invalid reads + stderr.write(' ---- read modified shared data ---- \n') + stderr.write('arr = %s\n' % (str(arr))) + stderr.write(' ---- OK!\n\n') + + # check that we got the expected data. If the PyCapsule destructor we + # defined was prematurely called then this test will fail because our + # destructor sets the elements of the array to NaN before free'ing the + # buffer. Reading the values here may also cause a SEGV + assert np.allclose(arr, expected_value) + + # free the shared data, the PyCapsule destructor should run here + stderr.write(' ---- free shared data ---- \n') + arr = None + stderr.write(' ---- OK!\n\n') diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/test_arraymethod.py b/venv/lib/python3.12/site-packages/numpy/_core/tests/test_arraymethod.py new file mode 100644 index 00000000..f10d9b98 --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/tests/test_arraymethod.py @@ -0,0 +1,87 @@ +""" +This file tests the generic aspects of ArrayMethod. At the time of writing +this is private API, but when added, public API may be added here. +""" + +from __future__ import annotations + +import sys +import types +from typing import Any + +import pytest + +import numpy as np +from numpy._core._multiarray_umath import _get_castingimpl as get_castingimpl + + +class TestResolveDescriptors: + # Test mainly error paths of the resolve_descriptors function, + # note that the `casting_unittests` tests exercise this non-error paths. + + # Casting implementations are the main/only current user: + method = get_castingimpl(type(np.dtype("d")), type(np.dtype("f"))) + + @pytest.mark.parametrize("args", [ + (True,), # Not a tuple. + ((None,)), # Too few elements + ((None, None, None),), # Too many + ((None, None),), # Input dtype is None, which is invalid. + ((np.dtype("d"), True),), # Output dtype is not a dtype + ((np.dtype("f"), None),), # Input dtype does not match method + ]) + def test_invalid_arguments(self, args): + with pytest.raises(TypeError): + self.method._resolve_descriptors(*args) + + +class TestSimpleStridedCall: + # Test mainly error paths of the resolve_descriptors function, + # note that the `casting_unittests` tests exercise this non-error paths. + + # Casting implementations are the main/only current user: + method = get_castingimpl(type(np.dtype("d")), type(np.dtype("f"))) + + @pytest.mark.parametrize(["args", "error"], [ + ((True,), TypeError), # Not a tuple + (((None,),), TypeError), # Too few elements + ((None, None), TypeError), # Inputs are not arrays. + (((None, None, None),), TypeError), # Too many + (((np.arange(3), np.arange(3)),), TypeError), # Incorrect dtypes + (((np.ones(3, dtype=">d"), np.ones(3, dtype=" None: + """Test `ndarray.__class_getitem__`.""" + alias = cls[Any, Any] + assert isinstance(alias, types.GenericAlias) + assert alias.__origin__ is cls + + @pytest.mark.parametrize("arg_len", range(4)) + def test_subscript_tup(self, cls: type[np.ndarray], arg_len: int) -> None: + arg_tup = (Any,) * arg_len + if arg_len in (1, 2): + assert cls[arg_tup] + else: + match = f"Too {'few' if arg_len == 0 else 'many'} arguments" + with pytest.raises(TypeError, match=match): + cls[arg_tup] diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/test_arrayobject.py b/venv/lib/python3.12/site-packages/numpy/_core/tests/test_arrayobject.py new file mode 100644 index 00000000..ccab929b --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/tests/test_arrayobject.py @@ -0,0 +1,33 @@ +import pytest + +import numpy as np +from numpy.testing import assert_array_equal + + +def test_matrix_transpose_raises_error_for_1d(): + msg = "matrix transpose with ndim < 2 is undefined" + arr = np.arange(48) + with pytest.raises(ValueError, match=msg): + arr.mT + + +def test_matrix_transpose_equals_transpose_2d(): + arr = np.arange(48).reshape((6, 8)) + assert_array_equal(arr.T, arr.mT) + + +ARRAY_SHAPES_TO_TEST = ( + (5, 2), + (5, 2, 3), + (5, 2, 3, 4), +) + + +@pytest.mark.parametrize("shape", ARRAY_SHAPES_TO_TEST) +def test_matrix_transpose_equals_swapaxes(shape): + num_of_axes = len(shape) + vec = np.arange(shape[-1]) + arr = np.broadcast_to(vec, shape) + tgt = np.swapaxes(arr, num_of_axes - 2, num_of_axes - 1) + mT = arr.mT + assert_array_equal(tgt, mT) diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/test_arrayprint.py b/venv/lib/python3.12/site-packages/numpy/_core/tests/test_arrayprint.py new file mode 100644 index 00000000..e2305c97 --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/tests/test_arrayprint.py @@ -0,0 +1,1260 @@ +import sys +import gc +from hypothesis import given +from hypothesis.extra import numpy as hynp +import pytest + +import numpy as np +from numpy.testing import ( + assert_, assert_equal, assert_raises, assert_warns, HAS_REFCOUNT, + assert_raises_regex, IS_WASM + ) +from numpy.testing._private.utils import run_threaded +from numpy._core.arrayprint import _typelessdata +import textwrap + +class TestArrayRepr: + def test_nan_inf(self): + x = np.array([np.nan, np.inf]) + assert_equal(repr(x), 'array([nan, inf])') + + def test_subclass(self): + class sub(np.ndarray): pass + + # one dimensional + x1d = np.array([1, 2]).view(sub) + assert_equal(repr(x1d), 'sub([1, 2])') + + # two dimensional + x2d = np.array([[1, 2], [3, 4]]).view(sub) + assert_equal(repr(x2d), + 'sub([[1, 2],\n' + ' [3, 4]])') + + # two dimensional with flexible dtype + xstruct = np.ones((2,2), dtype=[('a', ' 1) + y = sub(None) + x[()] = y + y[()] = x + assert_equal(repr(x), + 'sub(sub(sub(..., dtype=object), dtype=object), dtype=object)') + assert_equal(str(x), '...') + x[()] = 0 # resolve circular references for garbage collector + + # nested 0d-subclass-object + x = sub(None) + x[()] = sub(None) + assert_equal(repr(x), 'sub(sub(None, dtype=object), dtype=object)') + assert_equal(str(x), 'None') + + # gh-10663 + class DuckCounter(np.ndarray): + def __getitem__(self, item): + result = super().__getitem__(item) + if not isinstance(result, DuckCounter): + result = result[...].view(DuckCounter) + return result + + def to_string(self): + return {0: 'zero', 1: 'one', 2: 'two'}.get(self.item(), 'many') + + def __str__(self): + if self.shape == (): + return self.to_string() + else: + fmt = {'all': lambda x: x.to_string()} + return np.array2string(self, formatter=fmt) + + dc = np.arange(5).view(DuckCounter) + assert_equal(str(dc), "[zero one two many many]") + assert_equal(str(dc[0]), "zero") + + def test_self_containing(self): + arr0d = np.array(None) + arr0d[()] = arr0d + assert_equal(repr(arr0d), + 'array(array(..., dtype=object), dtype=object)') + arr0d[()] = 0 # resolve recursion for garbage collector + + arr1d = np.array([None, None]) + arr1d[1] = arr1d + assert_equal(repr(arr1d), + 'array([None, array(..., dtype=object)], dtype=object)') + arr1d[1] = 0 # resolve recursion for garbage collector + + first = np.array(None) + second = np.array(None) + first[()] = second + second[()] = first + assert_equal(repr(first), + 'array(array(array(..., dtype=object), dtype=object), dtype=object)') + first[()] = 0 # resolve circular references for garbage collector + + def test_containing_list(self): + # printing square brackets directly would be ambiguuous + arr1d = np.array([None, None]) + arr1d[0] = [1, 2] + arr1d[1] = [3] + assert_equal(repr(arr1d), + 'array([list([1, 2]), list([3])], dtype=object)') + + def test_void_scalar_recursion(self): + # gh-9345 + repr(np.void(b'test')) # RecursionError ? + + def test_fieldless_structured(self): + # gh-10366 + no_fields = np.dtype([]) + arr_no_fields = np.empty(4, dtype=no_fields) + assert_equal(repr(arr_no_fields), 'array([(), (), (), ()], dtype=[])') + + +class TestComplexArray: + def test_str(self): + rvals = [0, 1, -1, np.inf, -np.inf, np.nan] + cvals = [complex(rp, ip) for rp in rvals for ip in rvals] + dtypes = [np.complex64, np.cdouble, np.clongdouble] + actual = [str(np.array([c], dt)) for c in cvals for dt in dtypes] + wanted = [ + '[0.+0.j]', '[0.+0.j]', '[0.+0.j]', + '[0.+1.j]', '[0.+1.j]', '[0.+1.j]', + '[0.-1.j]', '[0.-1.j]', '[0.-1.j]', + '[0.+infj]', '[0.+infj]', '[0.+infj]', + '[0.-infj]', '[0.-infj]', '[0.-infj]', + '[0.+nanj]', '[0.+nanj]', '[0.+nanj]', + '[1.+0.j]', '[1.+0.j]', '[1.+0.j]', + '[1.+1.j]', '[1.+1.j]', '[1.+1.j]', + '[1.-1.j]', '[1.-1.j]', '[1.-1.j]', + '[1.+infj]', '[1.+infj]', '[1.+infj]', + '[1.-infj]', '[1.-infj]', '[1.-infj]', + '[1.+nanj]', '[1.+nanj]', '[1.+nanj]', + '[-1.+0.j]', '[-1.+0.j]', '[-1.+0.j]', + '[-1.+1.j]', '[-1.+1.j]', '[-1.+1.j]', + '[-1.-1.j]', '[-1.-1.j]', '[-1.-1.j]', + '[-1.+infj]', '[-1.+infj]', '[-1.+infj]', + '[-1.-infj]', '[-1.-infj]', '[-1.-infj]', + '[-1.+nanj]', '[-1.+nanj]', '[-1.+nanj]', + '[inf+0.j]', '[inf+0.j]', '[inf+0.j]', + '[inf+1.j]', '[inf+1.j]', '[inf+1.j]', + '[inf-1.j]', '[inf-1.j]', '[inf-1.j]', + '[inf+infj]', '[inf+infj]', '[inf+infj]', + '[inf-infj]', '[inf-infj]', '[inf-infj]', + '[inf+nanj]', '[inf+nanj]', '[inf+nanj]', + '[-inf+0.j]', '[-inf+0.j]', '[-inf+0.j]', + '[-inf+1.j]', '[-inf+1.j]', '[-inf+1.j]', + '[-inf-1.j]', '[-inf-1.j]', '[-inf-1.j]', + '[-inf+infj]', '[-inf+infj]', '[-inf+infj]', + '[-inf-infj]', '[-inf-infj]', '[-inf-infj]', + '[-inf+nanj]', '[-inf+nanj]', '[-inf+nanj]', + '[nan+0.j]', '[nan+0.j]', '[nan+0.j]', + '[nan+1.j]', '[nan+1.j]', '[nan+1.j]', + '[nan-1.j]', '[nan-1.j]', '[nan-1.j]', + '[nan+infj]', '[nan+infj]', '[nan+infj]', + '[nan-infj]', '[nan-infj]', '[nan-infj]', + '[nan+nanj]', '[nan+nanj]', '[nan+nanj]'] + + for res, val in zip(actual, wanted): + assert_equal(res, val) + +class TestArray2String: + def test_basic(self): + """Basic test of array2string.""" + a = np.arange(3) + assert_(np.array2string(a) == '[0 1 2]') + assert_(np.array2string(a, max_line_width=4, legacy='1.13') == '[0 1\n 2]') + assert_(np.array2string(a, max_line_width=4) == '[0\n 1\n 2]') + + def test_unexpected_kwarg(self): + # ensure than an appropriate TypeError + # is raised when array2string receives + # an unexpected kwarg + + with assert_raises_regex(TypeError, 'nonsense'): + np.array2string(np.array([1, 2, 3]), + nonsense=None) + + def test_format_function(self): + """Test custom format function for each element in array.""" + def _format_function(x): + if np.abs(x) < 1: + return '.' + elif np.abs(x) < 2: + return 'o' + else: + return 'O' + + x = np.arange(3) + x_hex = "[0x0 0x1 0x2]" + x_oct = "[0o0 0o1 0o2]" + assert_(np.array2string(x, formatter={'all':_format_function}) == + "[. o O]") + assert_(np.array2string(x, formatter={'int_kind':_format_function}) == + "[. o O]") + assert_(np.array2string(x, formatter={'all':lambda x: "%.4f" % x}) == + "[0.0000 1.0000 2.0000]") + assert_equal(np.array2string(x, formatter={'int':lambda x: hex(x)}), + x_hex) + assert_equal(np.array2string(x, formatter={'int':lambda x: oct(x)}), + x_oct) + + x = np.arange(3.) + assert_(np.array2string(x, formatter={'float_kind':lambda x: "%.2f" % x}) == + "[0.00 1.00 2.00]") + assert_(np.array2string(x, formatter={'float':lambda x: "%.2f" % x}) == + "[0.00 1.00 2.00]") + + s = np.array(['abc', 'def']) + assert_(np.array2string(s, formatter={'numpystr':lambda s: s*2}) == + '[abcabc defdef]') + + def test_structure_format_mixed(self): + dt = np.dtype([('name', np.str_, 16), ('grades', np.float64, (2,))]) + x = np.array([('Sarah', (8.0, 7.0)), ('John', (6.0, 7.0))], dtype=dt) + assert_equal(np.array2string(x), + "[('Sarah', [8., 7.]) ('John', [6., 7.])]") + + np.set_printoptions(legacy='1.13') + try: + # for issue #5692 + A = np.zeros(shape=10, dtype=[("A", "M8[s]")]) + A[5:].fill(np.datetime64('NaT')) + assert_equal( + np.array2string(A), + textwrap.dedent("""\ + [('1970-01-01T00:00:00',) ('1970-01-01T00:00:00',) ('1970-01-01T00:00:00',) + ('1970-01-01T00:00:00',) ('1970-01-01T00:00:00',) ('NaT',) ('NaT',) + ('NaT',) ('NaT',) ('NaT',)]""") + ) + finally: + np.set_printoptions(legacy=False) + + # same again, but with non-legacy behavior + assert_equal( + np.array2string(A), + textwrap.dedent("""\ + [('1970-01-01T00:00:00',) ('1970-01-01T00:00:00',) + ('1970-01-01T00:00:00',) ('1970-01-01T00:00:00',) + ('1970-01-01T00:00:00',) ( 'NaT',) + ( 'NaT',) ( 'NaT',) + ( 'NaT',) ( 'NaT',)]""") + ) + + # and again, with timedeltas + A = np.full(10, 123456, dtype=[("A", "m8[s]")]) + A[5:].fill(np.datetime64('NaT')) + assert_equal( + np.array2string(A), + textwrap.dedent("""\ + [(123456,) (123456,) (123456,) (123456,) (123456,) ( 'NaT',) ( 'NaT',) + ( 'NaT',) ( 'NaT',) ( 'NaT',)]""") + ) + + def test_structure_format_int(self): + # See #8160 + struct_int = np.array([([1, -1],), ([123, 1],)], + dtype=[('B', 'i4', 2)]) + assert_equal(np.array2string(struct_int), + "[([ 1, -1],) ([123, 1],)]") + struct_2dint = np.array([([[0, 1], [2, 3]],), ([[12, 0], [0, 0]],)], + dtype=[('B', 'i4', (2, 2))]) + assert_equal(np.array2string(struct_2dint), + "[([[ 0, 1], [ 2, 3]],) ([[12, 0], [ 0, 0]],)]") + + def test_structure_format_float(self): + # See #8172 + array_scalar = np.array( + (1., 2.1234567890123456789, 3.), dtype=('f8,f8,f8')) + assert_equal(np.array2string(array_scalar), "(1., 2.12345679, 3.)") + + def test_unstructured_void_repr(self): + a = np.array([27, 91, 50, 75, 7, 65, 10, 8, + 27, 91, 51, 49,109, 82,101,100], dtype='u1').view('V8') + assert_equal(repr(a[0]), + r"np.void(b'\x1B\x5B\x32\x4B\x07\x41\x0A\x08')") + assert_equal(str(a[0]), r"b'\x1B\x5B\x32\x4B\x07\x41\x0A\x08'") + assert_equal(repr(a), + r"array([b'\x1B\x5B\x32\x4B\x07\x41\x0A\x08'," "\n" + r" b'\x1B\x5B\x33\x31\x6D\x52\x65\x64'], dtype='|V8')") + + assert_equal(eval(repr(a), vars(np)), a) + assert_equal(eval(repr(a[0]), dict(np=np)), a[0]) + + def test_edgeitems_kwarg(self): + # previously the global print options would be taken over the kwarg + arr = np.zeros(3, int) + assert_equal( + np.array2string(arr, edgeitems=1, threshold=0), + "[0 ... 0]" + ) + + def test_summarize_1d(self): + A = np.arange(1001) + strA = '[ 0 1 2 ... 998 999 1000]' + assert_equal(str(A), strA) + + reprA = 'array([ 0, 1, 2, ..., 998, 999, 1000])' + assert_equal(repr(A), reprA) + + def test_summarize_2d(self): + A = np.arange(1002).reshape(2, 501) + strA = '[[ 0 1 2 ... 498 499 500]\n' \ + ' [ 501 502 503 ... 999 1000 1001]]' + assert_equal(str(A), strA) + + reprA = 'array([[ 0, 1, 2, ..., 498, 499, 500],\n' \ + ' [ 501, 502, 503, ..., 999, 1000, 1001]])' + assert_equal(repr(A), reprA) + + def test_summarize_structure(self): + A = (np.arange(2002, dtype="i8", (2, 1001))]) + strB = "[([[1, 1, 1, ..., 1, 1, 1], [1, 1, 1, ..., 1, 1, 1]],)]" + assert_equal(str(B), strB) + + reprB = ( + "array([([[1, 1, 1, ..., 1, 1, 1], [1, 1, 1, ..., 1, 1, 1]],)],\n" + " dtype=[('i', '>i8', (2, 1001))])" + ) + assert_equal(repr(B), reprB) + + C = (np.arange(22, dtype=" 1: + # if the type is >1 byte, the non-native endian version + # must show endianness. + assert non_native_repr != native_repr + assert f"dtype='{non_native_dtype.byteorder}" in non_native_repr + + def test_linewidth_repr(self): + a = np.full(7, fill_value=2) + np.set_printoptions(linewidth=17) + assert_equal( + repr(a), + textwrap.dedent("""\ + array([2, 2, 2, + 2, 2, 2, + 2])""") + ) + np.set_printoptions(linewidth=17, legacy='1.13') + assert_equal( + repr(a), + textwrap.dedent("""\ + array([2, 2, 2, + 2, 2, 2, 2])""") + ) + + a = np.full(8, fill_value=2) + + np.set_printoptions(linewidth=18, legacy=False) + assert_equal( + repr(a), + textwrap.dedent("""\ + array([2, 2, 2, + 2, 2, 2, + 2, 2])""") + ) + + np.set_printoptions(linewidth=18, legacy='1.13') + assert_equal( + repr(a), + textwrap.dedent("""\ + array([2, 2, 2, 2, + 2, 2, 2, 2])""") + ) + + def test_linewidth_str(self): + a = np.full(18, fill_value=2) + np.set_printoptions(linewidth=18) + assert_equal( + str(a), + textwrap.dedent("""\ + [2 2 2 2 2 2 2 2 + 2 2 2 2 2 2 2 2 + 2 2]""") + ) + np.set_printoptions(linewidth=18, legacy='1.13') + assert_equal( + str(a), + textwrap.dedent("""\ + [2 2 2 2 2 2 2 2 2 + 2 2 2 2 2 2 2 2 2]""") + ) + + def test_edgeitems(self): + np.set_printoptions(edgeitems=1, threshold=1) + a = np.arange(27).reshape((3, 3, 3)) + assert_equal( + repr(a), + textwrap.dedent("""\ + array([[[ 0, ..., 2], + ..., + [ 6, ..., 8]], + + ..., + + [[18, ..., 20], + ..., + [24, ..., 26]]])""") + ) + + b = np.zeros((3, 3, 1, 1)) + assert_equal( + repr(b), + textwrap.dedent("""\ + array([[[[0.]], + + ..., + + [[0.]]], + + + ..., + + + [[[0.]], + + ..., + + [[0.]]]])""") + ) + + # 1.13 had extra trailing spaces, and was missing newlines + np.set_printoptions(legacy='1.13') + + assert_equal( + repr(a), + textwrap.dedent("""\ + array([[[ 0, ..., 2], + ..., + [ 6, ..., 8]], + + ..., + [[18, ..., 20], + ..., + [24, ..., 26]]])""") + ) + + assert_equal( + repr(b), + textwrap.dedent("""\ + array([[[[ 0.]], + + ..., + [[ 0.]]], + + + ..., + [[[ 0.]], + + ..., + [[ 0.]]]])""") + ) + + def test_edgeitems_structured(self): + np.set_printoptions(edgeitems=1, threshold=1) + A = np.arange(5*2*3, dtype="f4')])"), + (np.void(b'a'), r"void(b'\x61')", r"np.void(b'\x61')"), + ]) +def test_scalar_repr_special(scalar, legacy_repr, representation): + # Test NEP 51 scalar repr (and legacy option) for numeric types + assert repr(scalar) == representation + + with np.printoptions(legacy="1.25"): + assert repr(scalar) == legacy_repr + +def test_scalar_void_float_str(): + # Note that based on this currently we do not print the same as a tuple + # would, since the tuple would include the repr() inside for floats, but + # we do not do that. + scalar = np.void((1.0, 2.0), dtype=[('f0', 'f4')]) + assert str(scalar) == "(1.0, 2.0)" + +@pytest.mark.skipif(IS_WASM, reason="wasm doesn't support asyncio") +@pytest.mark.skipif(sys.version_info < (3, 11), + reason="asyncio.barrier was added in Python 3.11") +def test_printoptions_asyncio_safe(): + asyncio = pytest.importorskip("asyncio") + + b = asyncio.Barrier(2) + + async def legacy_113(): + np.set_printoptions(legacy='1.13', precision=12) + await b.wait() + po = np.get_printoptions() + assert po['legacy'] == '1.13' + assert po['precision'] == 12 + orig_linewidth = po['linewidth'] + with np.printoptions(linewidth=34, legacy='1.21'): + po = np.get_printoptions() + assert po['legacy'] == '1.21' + assert po['precision'] == 12 + assert po['linewidth'] == 34 + po = np.get_printoptions() + assert po['linewidth'] == orig_linewidth + assert po['legacy'] == '1.13' + assert po['precision'] == 12 + + async def legacy_125(): + np.set_printoptions(legacy='1.25', precision=7) + await b.wait() + po = np.get_printoptions() + assert po['legacy'] == '1.25' + assert po['precision'] == 7 + orig_linewidth = po['linewidth'] + with np.printoptions(linewidth=6, legacy='1.13'): + po = np.get_printoptions() + assert po['legacy'] == '1.13' + assert po['precision'] == 7 + assert po['linewidth'] == 6 + po = np.get_printoptions() + assert po['linewidth'] == orig_linewidth + assert po['legacy'] == '1.25' + assert po['precision'] == 7 + + async def main(): + await asyncio.gather(legacy_125(), legacy_125()) + + loop = asyncio.new_event_loop() + asyncio.run(main()) + loop.close() + +@pytest.mark.skipif(IS_WASM, reason="wasm doesn't support threads") +def test_multithreaded_array_printing(): + # the dragon4 implementation uses a static scratch space for performance + # reasons this test makes sure it is set up in a thread-safe manner + + run_threaded(TestPrintOptions().test_floatmode, 500) diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/test_casting_floatingpoint_errors.py b/venv/lib/python3.12/site-packages/numpy/_core/tests/test_casting_floatingpoint_errors.py new file mode 100644 index 00000000..d448b94d --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/tests/test_casting_floatingpoint_errors.py @@ -0,0 +1,154 @@ +import pytest +from pytest import param +from numpy.testing import IS_WASM +import numpy as np + + +def values_and_dtypes(): + """ + Generate value+dtype pairs that generate floating point errors during + casts. The invalid casts to integers will generate "invalid" value + warnings, the float casts all generate "overflow". + + (The Python int/float paths don't need to get tested in all the same + situations, but it does not hurt.) + """ + # Casting to float16: + yield param(70000, "float16", id="int-to-f2") + yield param("70000", "float16", id="str-to-f2") + yield param(70000.0, "float16", id="float-to-f2") + yield param(np.longdouble(70000.), "float16", id="longdouble-to-f2") + yield param(np.float64(70000.), "float16", id="double-to-f2") + yield param(np.float32(70000.), "float16", id="float-to-f2") + # Casting to float32: + yield param(10**100, "float32", id="int-to-f4") + yield param(1e100, "float32", id="float-to-f2") + yield param(np.longdouble(1e300), "float32", id="longdouble-to-f2") + yield param(np.float64(1e300), "float32", id="double-to-f2") + # Casting to float64: + # If longdouble is double-double, its max can be rounded down to the double + # max. So we correct the double spacing (a bit weird, admittedly): + max_ld = np.finfo(np.longdouble).max + spacing = np.spacing(np.nextafter(np.finfo("f8").max, 0)) + if max_ld - spacing > np.finfo("f8").max: + yield param(np.finfo(np.longdouble).max, "float64", + id="longdouble-to-f8") + + # Cast to complex32: + yield param(2e300, "complex64", id="float-to-c8") + yield param(2e300+0j, "complex64", id="complex-to-c8") + yield param(2e300j, "complex64", id="complex-to-c8") + yield param(np.longdouble(2e300), "complex64", id="longdouble-to-c8") + + # Invalid float to integer casts: + with np.errstate(over="ignore"): + for to_dt in np.typecodes["AllInteger"]: + for value in [np.inf, np.nan]: + for from_dt in np.typecodes["AllFloat"]: + from_dt = np.dtype(from_dt) + from_val = from_dt.type(value) + + yield param(from_val, to_dt, id=f"{from_val}-to-{to_dt}") + + +def check_operations(dtype, value): + """ + There are many dedicated paths in NumPy which cast and should check for + floating point errors which occurred during those casts. + """ + if dtype.kind != 'i': + # These assignments use the stricter setitem logic: + def assignment(): + arr = np.empty(3, dtype=dtype) + arr[0] = value + + yield assignment + + def fill(): + arr = np.empty(3, dtype=dtype) + arr.fill(value) + + yield fill + + def copyto_scalar(): + arr = np.empty(3, dtype=dtype) + np.copyto(arr, value, casting="unsafe") + + yield copyto_scalar + + def copyto(): + arr = np.empty(3, dtype=dtype) + np.copyto(arr, np.array([value, value, value]), casting="unsafe") + + yield copyto + + def copyto_scalar_masked(): + arr = np.empty(3, dtype=dtype) + np.copyto(arr, value, casting="unsafe", + where=[True, False, True]) + + yield copyto_scalar_masked + + def copyto_masked(): + arr = np.empty(3, dtype=dtype) + np.copyto(arr, np.array([value, value, value]), casting="unsafe", + where=[True, False, True]) + + yield copyto_masked + + def direct_cast(): + np.array([value, value, value]).astype(dtype) + + yield direct_cast + + def direct_cast_nd_strided(): + arr = np.full((5, 5, 5), fill_value=value)[:, ::2, :] + arr.astype(dtype) + + yield direct_cast_nd_strided + + def boolean_array_assignment(): + arr = np.empty(3, dtype=dtype) + arr[[True, False, True]] = np.array([value, value]) + + yield boolean_array_assignment + + def integer_array_assignment(): + arr = np.empty(3, dtype=dtype) + values = np.array([value, value]) + + arr[[0, 1]] = values + + yield integer_array_assignment + + def integer_array_assignment_with_subspace(): + arr = np.empty((5, 3), dtype=dtype) + values = np.array([value, value, value]) + + arr[[0, 2]] = values + + yield integer_array_assignment_with_subspace + + def flat_assignment(): + arr = np.empty((3,), dtype=dtype) + values = np.array([value, value, value]) + arr.flat[:] = values + + yield flat_assignment + +@pytest.mark.skipif(IS_WASM, reason="no wasm fp exception support") +@pytest.mark.parametrize(["value", "dtype"], values_and_dtypes()) +@pytest.mark.filterwarnings("ignore::numpy.exceptions.ComplexWarning") +def test_floatingpoint_errors_casting(dtype, value): + dtype = np.dtype(dtype) + for operation in check_operations(dtype, value): + dtype = np.dtype(dtype) + + match = "invalid" if dtype.kind in 'iu' else "overflow" + with pytest.warns(RuntimeWarning, match=match): + operation() + + with np.errstate(all="raise"): + with pytest.raises(FloatingPointError, match=match): + operation() + diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/test_casting_unittests.py b/venv/lib/python3.12/site-packages/numpy/_core/tests/test_casting_unittests.py new file mode 100644 index 00000000..087d12a0 --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/tests/test_casting_unittests.py @@ -0,0 +1,818 @@ +""" +The tests exercise the casting machinery in a more low-level manner. +The reason is mostly to test a new implementation of the casting machinery. + +Unlike most tests in NumPy, these are closer to unit-tests rather +than integration tests. +""" + +import pytest +import textwrap +import enum +import random +import ctypes + +import numpy as np +from numpy.lib.stride_tricks import as_strided + +from numpy.testing import assert_array_equal +from numpy._core._multiarray_umath import _get_castingimpl as get_castingimpl + + +# Simple skips object, parametric and long double (unsupported by struct) +simple_dtypes = "?bhilqBHILQefdFD" +if np.dtype("l").itemsize != np.dtype("q").itemsize: + # Remove l and L, the table was generated with 64bit linux in mind. + simple_dtypes = simple_dtypes.replace("l", "").replace("L", "") +simple_dtypes = [type(np.dtype(c)) for c in simple_dtypes] + + +def simple_dtype_instances(): + for dtype_class in simple_dtypes: + dt = dtype_class() + yield pytest.param(dt, id=str(dt)) + if dt.byteorder != "|": + dt = dt.newbyteorder() + yield pytest.param(dt, id=str(dt)) + + +def get_expected_stringlength(dtype): + """Returns the string length when casting the basic dtypes to strings. + """ + if dtype == np.bool: + return 5 + if dtype.kind in "iu": + if dtype.itemsize == 1: + length = 3 + elif dtype.itemsize == 2: + length = 5 + elif dtype.itemsize == 4: + length = 10 + elif dtype.itemsize == 8: + length = 20 + else: + raise AssertionError(f"did not find expected length for {dtype}") + + if dtype.kind == "i": + length += 1 # adds one character for the sign + + return length + + # Note: Can't do dtype comparison for longdouble on windows + if dtype.char == "g": + return 48 + elif dtype.char == "G": + return 48 * 2 + elif dtype.kind == "f": + return 32 # also for half apparently. + elif dtype.kind == "c": + return 32 * 2 + + raise AssertionError(f"did not find expected length for {dtype}") + + +class Casting(enum.IntEnum): + no = 0 + equiv = 1 + safe = 2 + same_kind = 3 + unsafe = 4 + + +def _get_cancast_table(): + table = textwrap.dedent(""" + X ? b h i l q B H I L Q e f d g F D G S U V O M m + ? # = = = = = = = = = = = = = = = = = = = = = . = + b . # = = = = . . . . . = = = = = = = = = = = . = + h . ~ # = = = . . . . . ~ = = = = = = = = = = . = + i . ~ ~ # = = . . . . . ~ ~ = = ~ = = = = = = . = + l . ~ ~ ~ # # . . . . . ~ ~ = = ~ = = = = = = . = + q . ~ ~ ~ # # . . . . . ~ ~ = = ~ = = = = = = . = + B . ~ = = = = # = = = = = = = = = = = = = = = . = + H . ~ ~ = = = ~ # = = = ~ = = = = = = = = = = . = + I . ~ ~ ~ = = ~ ~ # = = ~ ~ = = ~ = = = = = = . = + L . ~ ~ ~ ~ ~ ~ ~ ~ # # ~ ~ = = ~ = = = = = = . ~ + Q . ~ ~ ~ ~ ~ ~ ~ ~ # # ~ ~ = = ~ = = = = = = . ~ + e . . . . . . . . . . . # = = = = = = = = = = . . + f . . . . . . . . . . . ~ # = = = = = = = = = . . + d . . . . . . . . . . . ~ ~ # = ~ = = = = = = . . + g . . . . . . . . . . . ~ ~ ~ # ~ ~ = = = = = . . + F . . . . . . . . . . . . . . . # = = = = = = . . + D . . . . . . . . . . . . . . . ~ # = = = = = . . + G . . . . . . . . . . . . . . . ~ ~ # = = = = . . + S . . . . . . . . . . . . . . . . . . # = = = . . + U . . . . . . . . . . . . . . . . . . . # = = . . + V . . . . . . . . . . . . . . . . . . . . # = . . + O . . . . . . . . . . . . . . . . . . . . = # . . + M . . . . . . . . . . . . . . . . . . . . = = # . + m . . . . . . . . . . . . . . . . . . . . = = . # + """).strip().split("\n") + dtypes = [type(np.dtype(c)) for c in table[0][2::2]] + + convert_cast = {".": Casting.unsafe, "~": Casting.same_kind, + "=": Casting.safe, "#": Casting.equiv, + " ": -1} + + cancast = {} + for from_dt, row in zip(dtypes, table[1:]): + cancast[from_dt] = {} + for to_dt, c in zip(dtypes, row[2::2]): + cancast[from_dt][to_dt] = convert_cast[c] + + return cancast + +CAST_TABLE = _get_cancast_table() + + +class TestChanges: + """ + These test cases exercise some behaviour changes + """ + @pytest.mark.parametrize("string", ["S", "U"]) + @pytest.mark.parametrize("floating", ["e", "f", "d", "g"]) + def test_float_to_string(self, floating, string): + assert np.can_cast(floating, string) + # 100 is long enough to hold any formatted floating + assert np.can_cast(floating, f"{string}100") + + def test_to_void(self): + # But in general, we do consider these safe: + assert np.can_cast("d", "V") + assert np.can_cast("S20", "V") + + # Do not consider it a safe cast if the void is too smaller: + assert not np.can_cast("d", "V1") + assert not np.can_cast("S20", "V1") + assert not np.can_cast("U1", "V1") + # Structured to unstructured is just like any other: + assert np.can_cast("d,i", "V", casting="same_kind") + # Unstructured void to unstructured is actually no cast at all: + assert np.can_cast("V3", "V", casting="no") + assert np.can_cast("V0", "V", casting="no") + + +class TestCasting: + size = 1500 # Best larger than NPY_LOWLEVEL_BUFFER_BLOCKSIZE * itemsize + + def get_data(self, dtype1, dtype2): + if dtype2 is None or dtype1.itemsize >= dtype2.itemsize: + length = self.size // dtype1.itemsize + else: + length = self.size // dtype2.itemsize + + # Assume that the base array is well enough aligned for all inputs. + arr1 = np.empty(length, dtype=dtype1) + assert arr1.flags.c_contiguous + assert arr1.flags.aligned + + values = [random.randrange(-128, 128) for _ in range(length)] + + for i, value in enumerate(values): + # Use item assignment to ensure this is not using casting: + if value < 0 and dtype1.kind == "u": + # Manually rollover unsigned integers (-1 -> int.max) + value = value + np.iinfo(dtype1).max + 1 + arr1[i] = value + + if dtype2 is None: + if dtype1.char == "?": + values = [bool(v) for v in values] + return arr1, values + + if dtype2.char == "?": + values = [bool(v) for v in values] + + arr2 = np.empty(length, dtype=dtype2) + assert arr2.flags.c_contiguous + assert arr2.flags.aligned + + for i, value in enumerate(values): + # Use item assignment to ensure this is not using casting: + if value < 0 and dtype2.kind == "u": + # Manually rollover unsigned integers (-1 -> int.max) + value = value + np.iinfo(dtype2).max + 1 + arr2[i] = value + + return arr1, arr2, values + + def get_data_variation(self, arr1, arr2, aligned=True, contig=True): + """ + Returns a copy of arr1 that may be non-contiguous or unaligned, and a + matching array for arr2 (although not a copy). + """ + if contig: + stride1 = arr1.dtype.itemsize + stride2 = arr2.dtype.itemsize + elif aligned: + stride1 = 2 * arr1.dtype.itemsize + stride2 = 2 * arr2.dtype.itemsize + else: + stride1 = arr1.dtype.itemsize + 1 + stride2 = arr2.dtype.itemsize + 1 + + max_size1 = len(arr1) * 3 * arr1.dtype.itemsize + 1 + max_size2 = len(arr2) * 3 * arr2.dtype.itemsize + 1 + from_bytes = np.zeros(max_size1, dtype=np.uint8) + to_bytes = np.zeros(max_size2, dtype=np.uint8) + + # Sanity check that the above is large enough: + assert stride1 * len(arr1) <= from_bytes.nbytes + assert stride2 * len(arr2) <= to_bytes.nbytes + + if aligned: + new1 = as_strided(from_bytes[:-1].view(arr1.dtype), + arr1.shape, (stride1,)) + new2 = as_strided(to_bytes[:-1].view(arr2.dtype), + arr2.shape, (stride2,)) + else: + new1 = as_strided(from_bytes[1:].view(arr1.dtype), + arr1.shape, (stride1,)) + new2 = as_strided(to_bytes[1:].view(arr2.dtype), + arr2.shape, (stride2,)) + + new1[...] = arr1 + + if not contig: + # Ensure we did not overwrite bytes that should not be written: + offset = arr1.dtype.itemsize if aligned else 0 + buf = from_bytes[offset::stride1].tobytes() + assert buf.count(b"\0") == len(buf) + + if contig: + assert new1.flags.c_contiguous + assert new2.flags.c_contiguous + else: + assert not new1.flags.c_contiguous + assert not new2.flags.c_contiguous + + if aligned: + assert new1.flags.aligned + assert new2.flags.aligned + else: + assert not new1.flags.aligned or new1.dtype.alignment == 1 + assert not new2.flags.aligned or new2.dtype.alignment == 1 + + return new1, new2 + + @pytest.mark.parametrize("from_Dt", simple_dtypes) + def test_simple_cancast(self, from_Dt): + for to_Dt in simple_dtypes: + cast = get_castingimpl(from_Dt, to_Dt) + + for from_dt in [from_Dt(), from_Dt().newbyteorder()]: + default = cast._resolve_descriptors((from_dt, None))[1][1] + assert default == to_Dt() + del default + + for to_dt in [to_Dt(), to_Dt().newbyteorder()]: + casting, (from_res, to_res), view_off = ( + cast._resolve_descriptors((from_dt, to_dt))) + assert(type(from_res) == from_Dt) + assert(type(to_res) == to_Dt) + if view_off is not None: + # If a view is acceptable, this is "no" casting + # and byte order must be matching. + assert casting == Casting.no + # The above table lists this as "equivalent" + assert Casting.equiv == CAST_TABLE[from_Dt][to_Dt] + # Note that to_res may not be the same as from_dt + assert from_res.isnative == to_res.isnative + else: + if from_Dt == to_Dt: + # Note that to_res may not be the same as from_dt + assert from_res.isnative != to_res.isnative + assert casting == CAST_TABLE[from_Dt][to_Dt] + + if from_Dt is to_Dt: + assert(from_dt is from_res) + assert(to_dt is to_res) + + @pytest.mark.filterwarnings("ignore::numpy.exceptions.ComplexWarning") + @pytest.mark.parametrize("from_dt", simple_dtype_instances()) + def test_simple_direct_casts(self, from_dt): + """ + This test checks numeric direct casts for dtypes supported also by the + struct module (plus complex). It tries to be test a wide range of + inputs, but skips over possibly undefined behaviour (e.g. int rollover). + Longdouble and CLongdouble are tested, but only using double precision. + + If this test creates issues, it should possibly just be simplified + or even removed (checking whether unaligned/non-contiguous casts give + the same results is useful, though). + """ + for to_dt in simple_dtype_instances(): + to_dt = to_dt.values[0] + cast = get_castingimpl(type(from_dt), type(to_dt)) + + casting, (from_res, to_res), view_off = cast._resolve_descriptors( + (from_dt, to_dt)) + + if from_res is not from_dt or to_res is not to_dt: + # Do not test this case, it is handled in multiple steps, + # each of which should is tested individually. + return + + safe = casting <= Casting.safe + del from_res, to_res, casting + + arr1, arr2, values = self.get_data(from_dt, to_dt) + + cast._simple_strided_call((arr1, arr2)) + + # Check via python list + assert arr2.tolist() == values + + # Check that the same results are achieved for strided loops + arr1_o, arr2_o = self.get_data_variation(arr1, arr2, True, False) + cast._simple_strided_call((arr1_o, arr2_o)) + + assert_array_equal(arr2_o, arr2) + assert arr2_o.tobytes() == arr2.tobytes() + + # Check if alignment makes a difference, but only if supported + # and only if the alignment can be wrong + if ((from_dt.alignment == 1 and to_dt.alignment == 1) or + not cast._supports_unaligned): + return + + arr1_o, arr2_o = self.get_data_variation(arr1, arr2, False, True) + cast._simple_strided_call((arr1_o, arr2_o)) + + assert_array_equal(arr2_o, arr2) + assert arr2_o.tobytes() == arr2.tobytes() + + arr1_o, arr2_o = self.get_data_variation(arr1, arr2, False, False) + cast._simple_strided_call((arr1_o, arr2_o)) + + assert_array_equal(arr2_o, arr2) + assert arr2_o.tobytes() == arr2.tobytes() + + del arr1_o, arr2_o, cast + + @pytest.mark.parametrize("from_Dt", simple_dtypes) + def test_numeric_to_times(self, from_Dt): + # We currently only implement contiguous loops, so only need to + # test those. + from_dt = from_Dt() + + time_dtypes = [np.dtype("M8"), np.dtype("M8[ms]"), np.dtype("M8[4D]"), + np.dtype("m8"), np.dtype("m8[ms]"), np.dtype("m8[4D]")] + for time_dt in time_dtypes: + cast = get_castingimpl(type(from_dt), type(time_dt)) + + casting, (from_res, to_res), view_off = cast._resolve_descriptors( + (from_dt, time_dt)) + + assert from_res is from_dt + assert to_res is time_dt + del from_res, to_res + + assert casting & CAST_TABLE[from_Dt][type(time_dt)] + assert view_off is None + + int64_dt = np.dtype(np.int64) + arr1, arr2, values = self.get_data(from_dt, int64_dt) + arr2 = arr2.view(time_dt) + arr2[...] = np.datetime64("NaT") + + if time_dt == np.dtype("M8"): + # This is a bit of a strange path, and could probably be removed + arr1[-1] = 0 # ensure at least one value is not NaT + + # The cast currently succeeds, but the values are invalid: + cast._simple_strided_call((arr1, arr2)) + with pytest.raises(ValueError): + str(arr2[-1]) # e.g. conversion to string fails + return + + cast._simple_strided_call((arr1, arr2)) + + assert [int(v) for v in arr2.tolist()] == values + + # Check that the same results are achieved for strided loops + arr1_o, arr2_o = self.get_data_variation(arr1, arr2, True, False) + cast._simple_strided_call((arr1_o, arr2_o)) + + assert_array_equal(arr2_o, arr2) + assert arr2_o.tobytes() == arr2.tobytes() + + @pytest.mark.parametrize( + ["from_dt", "to_dt", "expected_casting", "expected_view_off", + "nom", "denom"], + [("M8[ns]", None, Casting.no, 0, 1, 1), + (str(np.dtype("M8[ns]").newbyteorder()), None, + Casting.equiv, None, 1, 1), + ("M8", "M8[ms]", Casting.safe, 0, 1, 1), + # should be invalid cast: + ("M8[ms]", "M8", Casting.unsafe, None, 1, 1), + ("M8[5ms]", "M8[5ms]", Casting.no, 0, 1, 1), + ("M8[ns]", "M8[ms]", Casting.same_kind, None, 1, 10**6), + ("M8[ms]", "M8[ns]", Casting.safe, None, 10**6, 1), + ("M8[ms]", "M8[7ms]", Casting.same_kind, None, 1, 7), + ("M8[4D]", "M8[1M]", Casting.same_kind, None, None, + # give full values based on NumPy 1.19.x + [-2**63, 0, -1, 1314, -1315, 564442610]), + ("m8[ns]", None, Casting.no, 0, 1, 1), + (str(np.dtype("m8[ns]").newbyteorder()), None, + Casting.equiv, None, 1, 1), + ("m8", "m8[ms]", Casting.safe, 0, 1, 1), + # should be invalid cast: + ("m8[ms]", "m8", Casting.unsafe, None, 1, 1), + ("m8[5ms]", "m8[5ms]", Casting.no, 0, 1, 1), + ("m8[ns]", "m8[ms]", Casting.same_kind, None, 1, 10**6), + ("m8[ms]", "m8[ns]", Casting.safe, None, 10**6, 1), + ("m8[ms]", "m8[7ms]", Casting.same_kind, None, 1, 7), + ("m8[4D]", "m8[1M]", Casting.unsafe, None, None, + # give full values based on NumPy 1.19.x + [-2**63, 0, 0, 1314, -1315, 564442610])]) + def test_time_to_time(self, from_dt, to_dt, + expected_casting, expected_view_off, + nom, denom): + from_dt = np.dtype(from_dt) + if to_dt is not None: + to_dt = np.dtype(to_dt) + + # Test a few values for casting (results generated with NumPy 1.19) + values = np.array([-2**63, 1, 2**63-1, 10000, -10000, 2**32]) + values = values.astype(np.dtype("int64").newbyteorder(from_dt.byteorder)) + assert values.dtype.byteorder == from_dt.byteorder + assert np.isnat(values.view(from_dt)[0]) + + DType = type(from_dt) + cast = get_castingimpl(DType, DType) + casting, (from_res, to_res), view_off = cast._resolve_descriptors( + (from_dt, to_dt)) + assert from_res is from_dt + assert to_res is to_dt or to_dt is None + assert casting == expected_casting + assert view_off == expected_view_off + + if nom is not None: + expected_out = (values * nom // denom).view(to_res) + expected_out[0] = "NaT" + else: + expected_out = np.empty_like(values) + expected_out[...] = denom + expected_out = expected_out.view(to_dt) + + orig_arr = values.view(from_dt) + orig_out = np.empty_like(expected_out) + + if casting == Casting.unsafe and (to_dt == "m8" or to_dt == "M8"): + # Casting from non-generic to generic units is an error and should + # probably be reported as an invalid cast earlier. + with pytest.raises(ValueError): + cast._simple_strided_call((orig_arr, orig_out)) + return + + for aligned in [True, True]: + for contig in [True, True]: + arr, out = self.get_data_variation( + orig_arr, orig_out, aligned, contig) + out[...] = 0 + cast._simple_strided_call((arr, out)) + assert_array_equal(out.view("int64"), expected_out.view("int64")) + + def string_with_modified_length(self, dtype, change_length): + fact = 1 if dtype.char == "S" else 4 + length = dtype.itemsize // fact + change_length + return np.dtype(f"{dtype.byteorder}{dtype.char}{length}") + + @pytest.mark.parametrize("other_DT", simple_dtypes) + @pytest.mark.parametrize("string_char", ["S", "U"]) + def test_string_cancast(self, other_DT, string_char): + fact = 1 if string_char == "S" else 4 + + string_DT = type(np.dtype(string_char)) + cast = get_castingimpl(other_DT, string_DT) + + other_dt = other_DT() + expected_length = get_expected_stringlength(other_dt) + string_dt = np.dtype(f"{string_char}{expected_length}") + + safety, (res_other_dt, res_dt), view_off = cast._resolve_descriptors( + (other_dt, None)) + assert res_dt.itemsize == expected_length * fact + assert safety == Casting.safe # we consider to string casts "safe" + assert view_off is None + assert isinstance(res_dt, string_DT) + + # These casts currently implement changing the string length, so + # check the cast-safety for too long/fixed string lengths: + for change_length in [-1, 0, 1]: + if change_length >= 0: + expected_safety = Casting.safe + else: + expected_safety = Casting.same_kind + + to_dt = self.string_with_modified_length(string_dt, change_length) + safety, (_, res_dt), view_off = cast._resolve_descriptors( + (other_dt, to_dt)) + assert res_dt is to_dt + assert safety == expected_safety + assert view_off is None + + # The opposite direction is always considered unsafe: + cast = get_castingimpl(string_DT, other_DT) + + safety, _, view_off = cast._resolve_descriptors((string_dt, other_dt)) + assert safety == Casting.unsafe + assert view_off is None + + cast = get_castingimpl(string_DT, other_DT) + safety, (_, res_dt), view_off = cast._resolve_descriptors( + (string_dt, None)) + assert safety == Casting.unsafe + assert view_off is None + assert other_dt is res_dt # returns the singleton for simple dtypes + + @pytest.mark.parametrize("string_char", ["S", "U"]) + @pytest.mark.parametrize("other_dt", simple_dtype_instances()) + def test_simple_string_casts_roundtrip(self, other_dt, string_char): + """ + Tests casts from and to string by checking the roundtripping property. + + The test also covers some string to string casts (but not all). + + If this test creates issues, it should possibly just be simplified + or even removed (checking whether unaligned/non-contiguous casts give + the same results is useful, though). + """ + string_DT = type(np.dtype(string_char)) + + cast = get_castingimpl(type(other_dt), string_DT) + cast_back = get_castingimpl(string_DT, type(other_dt)) + _, (res_other_dt, string_dt), _ = cast._resolve_descriptors( + (other_dt, None)) + + if res_other_dt is not other_dt: + # do not support non-native byteorder, skip test in that case + assert other_dt.byteorder != res_other_dt.byteorder + return + + orig_arr, values = self.get_data(other_dt, None) + str_arr = np.zeros(len(orig_arr), dtype=string_dt) + string_dt_short = self.string_with_modified_length(string_dt, -1) + str_arr_short = np.zeros(len(orig_arr), dtype=string_dt_short) + string_dt_long = self.string_with_modified_length(string_dt, 1) + str_arr_long = np.zeros(len(orig_arr), dtype=string_dt_long) + + assert not cast._supports_unaligned # if support is added, should test + assert not cast_back._supports_unaligned + + for contig in [True, False]: + other_arr, str_arr = self.get_data_variation( + orig_arr, str_arr, True, contig) + _, str_arr_short = self.get_data_variation( + orig_arr, str_arr_short.copy(), True, contig) + _, str_arr_long = self.get_data_variation( + orig_arr, str_arr_long, True, contig) + + cast._simple_strided_call((other_arr, str_arr)) + + cast._simple_strided_call((other_arr, str_arr_short)) + assert_array_equal(str_arr.astype(string_dt_short), str_arr_short) + + cast._simple_strided_call((other_arr, str_arr_long)) + assert_array_equal(str_arr, str_arr_long) + + if other_dt.kind == "b": + # Booleans do not roundtrip + continue + + other_arr[...] = 0 + cast_back._simple_strided_call((str_arr, other_arr)) + assert_array_equal(orig_arr, other_arr) + + other_arr[...] = 0 + cast_back._simple_strided_call((str_arr_long, other_arr)) + assert_array_equal(orig_arr, other_arr) + + @pytest.mark.parametrize("other_dt", ["S8", "U8"]) + @pytest.mark.parametrize("string_char", ["S", "U"]) + def test_string_to_string_cancast(self, other_dt, string_char): + other_dt = np.dtype(other_dt) + + fact = 1 if string_char == "S" else 4 + div = 1 if other_dt.char == "S" else 4 + + string_DT = type(np.dtype(string_char)) + cast = get_castingimpl(type(other_dt), string_DT) + + expected_length = other_dt.itemsize // div + string_dt = np.dtype(f"{string_char}{expected_length}") + + safety, (res_other_dt, res_dt), view_off = cast._resolve_descriptors( + (other_dt, None)) + assert res_dt.itemsize == expected_length * fact + assert isinstance(res_dt, string_DT) + + expected_view_off = None + if other_dt.char == string_char: + if other_dt.isnative: + expected_safety = Casting.no + expected_view_off = 0 + else: + expected_safety = Casting.equiv + elif string_char == "U": + expected_safety = Casting.safe + else: + expected_safety = Casting.unsafe + + assert view_off == expected_view_off + assert expected_safety == safety + + for change_length in [-1, 0, 1]: + to_dt = self.string_with_modified_length(string_dt, change_length) + safety, (_, res_dt), view_off = cast._resolve_descriptors( + (other_dt, to_dt)) + + assert res_dt is to_dt + if change_length <= 0: + assert view_off == expected_view_off + else: + assert view_off is None + if expected_safety == Casting.unsafe: + assert safety == expected_safety + elif change_length < 0: + assert safety == Casting.same_kind + elif change_length == 0: + assert safety == expected_safety + elif change_length > 0: + assert safety == Casting.safe + + @pytest.mark.parametrize("order1", [">", "<"]) + @pytest.mark.parametrize("order2", [">", "<"]) + def test_unicode_byteswapped_cast(self, order1, order2): + # Very specific tests (not using the castingimpl directly) + # that tests unicode bytedwaps including for unaligned array data. + dtype1 = np.dtype(f"{order1}U30") + dtype2 = np.dtype(f"{order2}U30") + data1 = np.empty(30 * 4 + 1, dtype=np.uint8)[1:].view(dtype1) + data2 = np.empty(30 * 4 + 1, dtype=np.uint8)[1:].view(dtype2) + if dtype1.alignment != 1: + # alignment should always be >1, but skip the check if not + assert not data1.flags.aligned + assert not data2.flags.aligned + + element = "this is a ünicode string‽" + data1[()] = element + # Test both `data1` and `data1.copy()` (which should be aligned) + for data in [data1, data1.copy()]: + data2[...] = data1 + assert data2[()] == element + assert data2.copy()[()] == element + + def test_void_to_string_special_case(self): + # Cover a small special case in void to string casting that could + # probably just as well be turned into an error (compare + # `test_object_to_parametric_internal_error` below). + assert np.array([], dtype="V5").astype("S").dtype.itemsize == 5 + assert np.array([], dtype="V5").astype("U").dtype.itemsize == 4 * 5 + + def test_object_to_parametric_internal_error(self): + # We reject casting from object to a parametric type, without + # figuring out the correct instance first. + object_dtype = type(np.dtype(object)) + other_dtype = type(np.dtype(str)) + cast = get_castingimpl(object_dtype, other_dtype) + with pytest.raises(TypeError, + match="casting from object to the parametric DType"): + cast._resolve_descriptors((np.dtype("O"), None)) + + @pytest.mark.parametrize("dtype", simple_dtype_instances()) + def test_object_and_simple_resolution(self, dtype): + # Simple test to exercise the cast when no instance is specified + object_dtype = type(np.dtype(object)) + cast = get_castingimpl(object_dtype, type(dtype)) + + safety, (_, res_dt), view_off = cast._resolve_descriptors( + (np.dtype("O"), dtype)) + assert safety == Casting.unsafe + assert view_off is None + assert res_dt is dtype + + safety, (_, res_dt), view_off = cast._resolve_descriptors( + (np.dtype("O"), None)) + assert safety == Casting.unsafe + assert view_off is None + assert res_dt == dtype.newbyteorder("=") + + @pytest.mark.parametrize("dtype", simple_dtype_instances()) + def test_simple_to_object_resolution(self, dtype): + # Simple test to exercise the cast when no instance is specified + object_dtype = type(np.dtype(object)) + cast = get_castingimpl(type(dtype), object_dtype) + + safety, (_, res_dt), view_off = cast._resolve_descriptors( + (dtype, None)) + assert safety == Casting.safe + assert view_off is None + assert res_dt is np.dtype("O") + + @pytest.mark.parametrize("casting", ["no", "unsafe"]) + def test_void_and_structured_with_subarray(self, casting): + # test case corresponding to gh-19325 + dtype = np.dtype([("foo", " casts may succeed or fail, but a NULL'ed array must + # behave the same as one filled with None's. + arr_normal = np.array([None] * 5) + arr_NULLs = np.empty_like(arr_normal) + ctypes.memset(arr_NULLs.ctypes.data, 0, arr_NULLs.nbytes) + # If the check fails (maybe it should) the test would lose its purpose: + assert arr_NULLs.tobytes() == b"\x00" * arr_NULLs.nbytes + + try: + expected = arr_normal.astype(dtype) + except TypeError: + with pytest.raises(TypeError): + arr_NULLs.astype(dtype), + else: + assert_array_equal(expected, arr_NULLs.astype(dtype)) + + @pytest.mark.parametrize("dtype", + np.typecodes["AllInteger"] + np.typecodes["AllFloat"]) + def test_nonstandard_bool_to_other(self, dtype): + # simple test for casting bool_ to numeric types, which should not + # expose the detail that NumPy bools can sometimes take values other + # than 0 and 1. See also gh-19514. + nonstandard_bools = np.array([0, 3, -7], dtype=np.int8).view(bool) + res = nonstandard_bools.astype(dtype) + expected = [0, 1, 1] + assert_array_equal(res, expected) + diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/test_conversion_utils.py b/venv/lib/python3.12/site-packages/numpy/_core/tests/test_conversion_utils.py new file mode 100644 index 00000000..51676320 --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/tests/test_conversion_utils.py @@ -0,0 +1,209 @@ +""" +Tests for numpy/_core/src/multiarray/conversion_utils.c +""" +import re +import sys + +import pytest + +import numpy as np +import numpy._core._multiarray_tests as mt +from numpy._core.multiarray import CLIP, WRAP, RAISE +from numpy.testing import assert_warns, IS_PYPY + + +class StringConverterTestCase: + allow_bytes = True + case_insensitive = True + exact_match = False + warn = True + + def _check_value_error(self, val): + pattern = r'\(got {}\)'.format(re.escape(repr(val))) + with pytest.raises(ValueError, match=pattern) as exc: + self.conv(val) + + def _check_conv_assert_warn(self, val, expected): + if self.warn: + with assert_warns(DeprecationWarning) as exc: + assert self.conv(val) == expected + else: + assert self.conv(val) == expected + + def _check(self, val, expected): + """Takes valid non-deprecated inputs for converters, + runs converters on inputs, checks correctness of outputs, + warnings and errors""" + assert self.conv(val) == expected + + if self.allow_bytes: + assert self.conv(val.encode('ascii')) == expected + else: + with pytest.raises(TypeError): + self.conv(val.encode('ascii')) + + if len(val) != 1: + if self.exact_match: + self._check_value_error(val[:1]) + self._check_value_error(val + '\0') + else: + self._check_conv_assert_warn(val[:1], expected) + + if self.case_insensitive: + if val != val.lower(): + self._check_conv_assert_warn(val.lower(), expected) + if val != val.upper(): + self._check_conv_assert_warn(val.upper(), expected) + else: + if val != val.lower(): + self._check_value_error(val.lower()) + if val != val.upper(): + self._check_value_error(val.upper()) + + def test_wrong_type(self): + # common cases which apply to all the below + with pytest.raises(TypeError): + self.conv({}) + with pytest.raises(TypeError): + self.conv([]) + + def test_wrong_value(self): + # nonsense strings + self._check_value_error('') + self._check_value_error('\N{greek small letter pi}') + + if self.allow_bytes: + self._check_value_error(b'') + # bytes which can't be converted to strings via utf8 + self._check_value_error(b"\xFF") + if self.exact_match: + self._check_value_error("there's no way this is supported") + + +class TestByteorderConverter(StringConverterTestCase): + """ Tests of PyArray_ByteorderConverter """ + conv = mt.run_byteorder_converter + warn = False + + def test_valid(self): + for s in ['big', '>']: + self._check(s, 'NPY_BIG') + for s in ['little', '<']: + self._check(s, 'NPY_LITTLE') + for s in ['native', '=']: + self._check(s, 'NPY_NATIVE') + for s in ['ignore', '|']: + self._check(s, 'NPY_IGNORE') + for s in ['swap']: + self._check(s, 'NPY_SWAP') + + +class TestSortkindConverter(StringConverterTestCase): + """ Tests of PyArray_SortkindConverter """ + conv = mt.run_sortkind_converter + warn = False + + def test_valid(self): + self._check('quicksort', 'NPY_QUICKSORT') + self._check('heapsort', 'NPY_HEAPSORT') + self._check('mergesort', 'NPY_STABLESORT') # alias + self._check('stable', 'NPY_STABLESORT') + + +class TestSelectkindConverter(StringConverterTestCase): + """ Tests of PyArray_SelectkindConverter """ + conv = mt.run_selectkind_converter + case_insensitive = False + exact_match = True + + def test_valid(self): + self._check('introselect', 'NPY_INTROSELECT') + + +class TestSearchsideConverter(StringConverterTestCase): + """ Tests of PyArray_SearchsideConverter """ + conv = mt.run_searchside_converter + def test_valid(self): + self._check('left', 'NPY_SEARCHLEFT') + self._check('right', 'NPY_SEARCHRIGHT') + + +class TestOrderConverter(StringConverterTestCase): + """ Tests of PyArray_OrderConverter """ + conv = mt.run_order_converter + warn = False + + def test_valid(self): + self._check('c', 'NPY_CORDER') + self._check('f', 'NPY_FORTRANORDER') + self._check('a', 'NPY_ANYORDER') + self._check('k', 'NPY_KEEPORDER') + + def test_flatten_invalid_order(self): + # invalid after gh-14596 + with pytest.raises(ValueError): + self.conv('Z') + for order in [False, True, 0, 8]: + with pytest.raises(TypeError): + self.conv(order) + + +class TestClipmodeConverter(StringConverterTestCase): + """ Tests of PyArray_ClipmodeConverter """ + conv = mt.run_clipmode_converter + def test_valid(self): + self._check('clip', 'NPY_CLIP') + self._check('wrap', 'NPY_WRAP') + self._check('raise', 'NPY_RAISE') + + # integer values allowed here + assert self.conv(CLIP) == 'NPY_CLIP' + assert self.conv(WRAP) == 'NPY_WRAP' + assert self.conv(RAISE) == 'NPY_RAISE' + + +class TestCastingConverter(StringConverterTestCase): + """ Tests of PyArray_CastingConverter """ + conv = mt.run_casting_converter + case_insensitive = False + exact_match = True + + def test_valid(self): + self._check("no", "NPY_NO_CASTING") + self._check("equiv", "NPY_EQUIV_CASTING") + self._check("safe", "NPY_SAFE_CASTING") + self._check("same_kind", "NPY_SAME_KIND_CASTING") + self._check("unsafe", "NPY_UNSAFE_CASTING") + + +class TestIntpConverter: + """ Tests of PyArray_IntpConverter """ + conv = mt.run_intp_converter + + def test_basic(self): + assert self.conv(1) == (1,) + assert self.conv((1, 2)) == (1, 2) + assert self.conv([1, 2]) == (1, 2) + assert self.conv(()) == () + + def test_none(self): + # once the warning expires, this will raise TypeError + with pytest.warns(DeprecationWarning): + assert self.conv(None) == () + + @pytest.mark.skipif(IS_PYPY and sys.implementation.version <= (7, 3, 8), + reason="PyPy bug in error formatting") + def test_float(self): + with pytest.raises(TypeError): + self.conv(1.0) + with pytest.raises(TypeError): + self.conv([1, 1.0]) + + def test_too_large(self): + with pytest.raises(ValueError): + self.conv(2**64) + + def test_too_many_dims(self): + assert self.conv([1]*64) == (1,)*64 + with pytest.raises(ValueError): + self.conv([1]*65) diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/test_cpu_dispatcher.py b/venv/lib/python3.12/site-packages/numpy/_core/tests/test_cpu_dispatcher.py new file mode 100644 index 00000000..959725ea --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/tests/test_cpu_dispatcher.py @@ -0,0 +1,45 @@ +from numpy._core._multiarray_umath import ( + __cpu_features__, __cpu_baseline__, __cpu_dispatch__ +) +from numpy._core import _umath_tests +from numpy.testing import assert_equal + +def test_dispatcher(): + """ + Testing the utilities of the CPU dispatcher + """ + targets = ( + "SSE2", "SSE41", "AVX2", + "VSX", "VSX2", "VSX3", + "NEON", "ASIMD", "ASIMDHP", + "VX", "VXE" + ) + highest_sfx = "" # no suffix for the baseline + all_sfx = [] + for feature in reversed(targets): + # skip baseline features, by the default `CCompilerOpt` do not generate separated objects + # for the baseline, just one object combined all of them via 'baseline' option + # within the configuration statements. + if feature in __cpu_baseline__: + continue + # check compiler and running machine support + if feature not in __cpu_dispatch__ or not __cpu_features__[feature]: + continue + + if not highest_sfx: + highest_sfx = "_" + feature + all_sfx.append("func" + "_" + feature) + + test = _umath_tests.test_dispatch() + assert_equal(test["func"], "func" + highest_sfx) + assert_equal(test["var"], "var" + highest_sfx) + + if highest_sfx: + assert_equal(test["func_xb"], "func" + highest_sfx) + assert_equal(test["var_xb"], "var" + highest_sfx) + else: + assert_equal(test["func_xb"], "nobase") + assert_equal(test["var_xb"], "nobase") + + all_sfx.append("func") # add the baseline + assert_equal(test["all"], all_sfx) diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/test_cpu_features.py b/venv/lib/python3.12/site-packages/numpy/_core/tests/test_cpu_features.py new file mode 100644 index 00000000..35d81005 --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/tests/test_cpu_features.py @@ -0,0 +1,414 @@ +import sys, platform, re, pytest +from numpy._core._multiarray_umath import ( + __cpu_features__, + __cpu_baseline__, + __cpu_dispatch__, +) +import numpy as np +import subprocess +import pathlib +import os +import re + +def assert_features_equal(actual, desired, fname): + __tracebackhide__ = True # Hide traceback for py.test + actual, desired = str(actual), str(desired) + if actual == desired: + return + detected = str(__cpu_features__).replace("'", "") + try: + with open("/proc/cpuinfo") as fd: + cpuinfo = fd.read(2048) + except Exception as err: + cpuinfo = str(err) + + try: + import subprocess + auxv = subprocess.check_output(['/bin/true'], env=dict(LD_SHOW_AUXV="1")) + auxv = auxv.decode() + except Exception as err: + auxv = str(err) + + import textwrap + error_report = textwrap.indent( +""" +########################################### +### Extra debugging information +########################################### +------------------------------------------- +--- NumPy Detections +------------------------------------------- +%s +------------------------------------------- +--- SYS / CPUINFO +------------------------------------------- +%s.... +------------------------------------------- +--- SYS / AUXV +------------------------------------------- +%s +""" % (detected, cpuinfo, auxv), prefix='\r') + + raise AssertionError(( + "Failure Detection\n" + " NAME: '%s'\n" + " ACTUAL: %s\n" + " DESIRED: %s\n" + "%s" + ) % (fname, actual, desired, error_report)) + +def _text_to_list(txt): + out = txt.strip("][\n").replace("'", "").split(', ') + return None if out[0] == "" else out + +class AbstractTest: + features = [] + features_groups = {} + features_map = {} + features_flags = set() + + def load_flags(self): + # a hook + pass + def test_features(self): + self.load_flags() + for gname, features in self.features_groups.items(): + test_features = [self.cpu_have(f) for f in features] + assert_features_equal(__cpu_features__.get(gname), all(test_features), gname) + + for feature_name in self.features: + cpu_have = self.cpu_have(feature_name) + npy_have = __cpu_features__.get(feature_name) + assert_features_equal(npy_have, cpu_have, feature_name) + + def cpu_have(self, feature_name): + map_names = self.features_map.get(feature_name, feature_name) + if isinstance(map_names, str): + return map_names in self.features_flags + return any(f in self.features_flags for f in map_names) + + def load_flags_cpuinfo(self, magic_key): + self.features_flags = self.get_cpuinfo_item(magic_key) + + def get_cpuinfo_item(self, magic_key): + values = set() + with open('/proc/cpuinfo') as fd: + for line in fd: + if not line.startswith(magic_key): + continue + flags_value = [s.strip() for s in line.split(':', 1)] + if len(flags_value) == 2: + values = values.union(flags_value[1].upper().split()) + return values + + def load_flags_auxv(self): + auxv = subprocess.check_output(['/bin/true'], env=dict(LD_SHOW_AUXV="1")) + for at in auxv.split(b'\n'): + if not at.startswith(b"AT_HWCAP"): + continue + hwcap_value = [s.strip() for s in at.split(b':', 1)] + if len(hwcap_value) == 2: + self.features_flags = self.features_flags.union( + hwcap_value[1].upper().decode().split() + ) + +@pytest.mark.skipif( + sys.platform == 'emscripten', + reason= ( + "The subprocess module is not available on WASM platforms and" + " therefore this test class cannot be properly executed." + ), +) +class TestEnvPrivation: + cwd = pathlib.Path(__file__).parent.resolve() + env = os.environ.copy() + _enable = os.environ.pop('NPY_ENABLE_CPU_FEATURES', None) + _disable = os.environ.pop('NPY_DISABLE_CPU_FEATURES', None) + SUBPROCESS_ARGS = dict(cwd=cwd, capture_output=True, text=True, check=True) + unavailable_feats = [ + feat for feat in __cpu_dispatch__ if not __cpu_features__[feat] + ] + UNAVAILABLE_FEAT = ( + None if len(unavailable_feats) == 0 + else unavailable_feats[0] + ) + BASELINE_FEAT = None if len(__cpu_baseline__) == 0 else __cpu_baseline__[0] + SCRIPT = """ +def main(): + from numpy._core._multiarray_umath import ( + __cpu_features__, + __cpu_dispatch__ + ) + + detected = [feat for feat in __cpu_dispatch__ if __cpu_features__[feat]] + print(detected) + +if __name__ == "__main__": + main() + """ + + @pytest.fixture(autouse=True) + def setup_class(self, tmp_path_factory): + file = tmp_path_factory.mktemp("runtime_test_script") + file /= "_runtime_detect.py" + file.write_text(self.SCRIPT) + self.file = file + return + + def _run(self): + return subprocess.run( + [sys.executable, self.file], + env=self.env, + **self.SUBPROCESS_ARGS, + ) + + # Helper function mimicking pytest.raises for subprocess call + def _expect_error( + self, + msg, + err_type, + no_error_msg="Failed to generate error" + ): + try: + self._run() + except subprocess.CalledProcessError as e: + assertion_message = f"Expected: {msg}\nGot: {e.stderr}" + assert re.search(msg, e.stderr), assertion_message + + assertion_message = ( + f"Expected error of type: {err_type}; see full " + f"error:\n{e.stderr}" + ) + assert re.search(err_type, e.stderr), assertion_message + else: + assert False, no_error_msg + + def setup_method(self): + """Ensure that the environment is reset""" + self.env = os.environ.copy() + return + + def test_runtime_feature_selection(self): + """ + Ensure that when selecting `NPY_ENABLE_CPU_FEATURES`, only the + features exactly specified are dispatched. + """ + + # Capture runtime-enabled features + out = self._run() + non_baseline_features = _text_to_list(out.stdout) + + if non_baseline_features is None: + pytest.skip( + "No dispatchable features outside of baseline detected." + ) + feature = non_baseline_features[0] + + # Capture runtime-enabled features when `NPY_ENABLE_CPU_FEATURES` is + # specified + self.env['NPY_ENABLE_CPU_FEATURES'] = feature + out = self._run() + enabled_features = _text_to_list(out.stdout) + + # Ensure that only one feature is enabled, and it is exactly the one + # specified by `NPY_ENABLE_CPU_FEATURES` + assert set(enabled_features) == {feature} + + if len(non_baseline_features) < 2: + pytest.skip("Only one non-baseline feature detected.") + # Capture runtime-enabled features when `NPY_ENABLE_CPU_FEATURES` is + # specified + self.env['NPY_ENABLE_CPU_FEATURES'] = ",".join(non_baseline_features) + out = self._run() + enabled_features = _text_to_list(out.stdout) + + # Ensure that both features are enabled, and they are exactly the ones + # specified by `NPY_ENABLE_CPU_FEATURES` + assert set(enabled_features) == set(non_baseline_features) + return + + @pytest.mark.parametrize("enabled, disabled", + [ + ("feature", "feature"), + ("feature", "same"), + ]) + def test_both_enable_disable_set(self, enabled, disabled): + """ + Ensure that when both environment variables are set then an + ImportError is thrown + """ + self.env['NPY_ENABLE_CPU_FEATURES'] = enabled + self.env['NPY_DISABLE_CPU_FEATURES'] = disabled + msg = "Both NPY_DISABLE_CPU_FEATURES and NPY_ENABLE_CPU_FEATURES" + err_type = "ImportError" + self._expect_error(msg, err_type) + + @pytest.mark.skipif( + not __cpu_dispatch__, + reason=( + "NPY_*_CPU_FEATURES only parsed if " + "`__cpu_dispatch__` is non-empty" + ) + ) + @pytest.mark.parametrize("action", ["ENABLE", "DISABLE"]) + def test_variable_too_long(self, action): + """ + Test that an error is thrown if the environment variables are too long + to be processed. Current limit is 1024, but this may change later. + """ + MAX_VAR_LENGTH = 1024 + # Actual length is MAX_VAR_LENGTH + 1 due to null-termination + self.env[f'NPY_{action}_CPU_FEATURES'] = "t" * MAX_VAR_LENGTH + msg = ( + f"Length of environment variable 'NPY_{action}_CPU_FEATURES' is " + f"{MAX_VAR_LENGTH + 1}, only {MAX_VAR_LENGTH} accepted" + ) + err_type = "RuntimeError" + self._expect_error(msg, err_type) + + @pytest.mark.skipif( + not __cpu_dispatch__, + reason=( + "NPY_*_CPU_FEATURES only parsed if " + "`__cpu_dispatch__` is non-empty" + ) + ) + def test_impossible_feature_disable(self): + """ + Test that a RuntimeError is thrown if an impossible feature-disabling + request is made. This includes disabling a baseline feature. + """ + + if self.BASELINE_FEAT is None: + pytest.skip("There are no unavailable features to test with") + bad_feature = self.BASELINE_FEAT + self.env['NPY_DISABLE_CPU_FEATURES'] = bad_feature + msg = ( + f"You cannot disable CPU feature '{bad_feature}', since it is " + "part of the baseline optimizations" + ) + err_type = "RuntimeError" + self._expect_error(msg, err_type) + + def test_impossible_feature_enable(self): + """ + Test that a RuntimeError is thrown if an impossible feature-enabling + request is made. This includes enabling a feature not supported by the + machine, or disabling a baseline optimization. + """ + + if self.UNAVAILABLE_FEAT is None: + pytest.skip("There are no unavailable features to test with") + bad_feature = self.UNAVAILABLE_FEAT + self.env['NPY_ENABLE_CPU_FEATURES'] = bad_feature + msg = ( + f"You cannot enable CPU features \\({bad_feature}\\), since " + "they are not supported by your machine." + ) + err_type = "RuntimeError" + self._expect_error(msg, err_type) + + # Ensure that it fails even when providing garbage in addition + feats = f"{bad_feature}, Foobar" + self.env['NPY_ENABLE_CPU_FEATURES'] = feats + msg = ( + f"You cannot enable CPU features \\({bad_feature}\\), since they " + "are not supported by your machine." + ) + self._expect_error(msg, err_type) + + if self.BASELINE_FEAT is not None: + # Ensure that only the bad feature gets reported + feats = f"{bad_feature}, {self.BASELINE_FEAT}" + self.env['NPY_ENABLE_CPU_FEATURES'] = feats + msg = ( + f"You cannot enable CPU features \\({bad_feature}\\), since " + "they are not supported by your machine." + ) + self._expect_error(msg, err_type) + +is_linux = sys.platform.startswith('linux') +is_cygwin = sys.platform.startswith('cygwin') +machine = platform.machine() +is_x86 = re.match("^(amd64|x86|i386|i686)", machine, re.IGNORECASE) +@pytest.mark.skipif( + not (is_linux or is_cygwin) or not is_x86, reason="Only for Linux and x86" +) +class Test_X86_Features(AbstractTest): + features = [ + "MMX", "SSE", "SSE2", "SSE3", "SSSE3", "SSE41", "POPCNT", "SSE42", + "AVX", "F16C", "XOP", "FMA4", "FMA3", "AVX2", "AVX512F", "AVX512CD", + "AVX512ER", "AVX512PF", "AVX5124FMAPS", "AVX5124VNNIW", "AVX512VPOPCNTDQ", + "AVX512VL", "AVX512BW", "AVX512DQ", "AVX512VNNI", "AVX512IFMA", + "AVX512VBMI", "AVX512VBMI2", "AVX512BITALG", "AVX512FP16", + ] + features_groups = dict( + AVX512_KNL = ["AVX512F", "AVX512CD", "AVX512ER", "AVX512PF"], + AVX512_KNM = ["AVX512F", "AVX512CD", "AVX512ER", "AVX512PF", "AVX5124FMAPS", + "AVX5124VNNIW", "AVX512VPOPCNTDQ"], + AVX512_SKX = ["AVX512F", "AVX512CD", "AVX512BW", "AVX512DQ", "AVX512VL"], + AVX512_CLX = ["AVX512F", "AVX512CD", "AVX512BW", "AVX512DQ", "AVX512VL", "AVX512VNNI"], + AVX512_CNL = ["AVX512F", "AVX512CD", "AVX512BW", "AVX512DQ", "AVX512VL", "AVX512IFMA", + "AVX512VBMI"], + AVX512_ICL = ["AVX512F", "AVX512CD", "AVX512BW", "AVX512DQ", "AVX512VL", "AVX512IFMA", + "AVX512VBMI", "AVX512VNNI", "AVX512VBMI2", "AVX512BITALG", "AVX512VPOPCNTDQ"], + AVX512_SPR = ["AVX512F", "AVX512CD", "AVX512BW", "AVX512DQ", + "AVX512VL", "AVX512IFMA", "AVX512VBMI", "AVX512VNNI", + "AVX512VBMI2", "AVX512BITALG", "AVX512VPOPCNTDQ", + "AVX512FP16"], + ) + features_map = dict( + SSE3="PNI", SSE41="SSE4_1", SSE42="SSE4_2", FMA3="FMA", + AVX512VNNI="AVX512_VNNI", AVX512BITALG="AVX512_BITALG", AVX512VBMI2="AVX512_VBMI2", + AVX5124FMAPS="AVX512_4FMAPS", AVX5124VNNIW="AVX512_4VNNIW", AVX512VPOPCNTDQ="AVX512_VPOPCNTDQ", + AVX512FP16="AVX512_FP16", + ) + def load_flags(self): + self.load_flags_cpuinfo("flags") + +is_power = re.match("^(powerpc|ppc)64", machine, re.IGNORECASE) +@pytest.mark.skipif(not is_linux or not is_power, reason="Only for Linux and Power") +class Test_POWER_Features(AbstractTest): + features = ["VSX", "VSX2", "VSX3", "VSX4"] + features_map = dict(VSX2="ARCH_2_07", VSX3="ARCH_3_00", VSX4="ARCH_3_1") + + def load_flags(self): + self.load_flags_auxv() + + +is_zarch = re.match("^(s390x)", machine, re.IGNORECASE) +@pytest.mark.skipif(not is_linux or not is_zarch, + reason="Only for Linux and IBM Z") +class Test_ZARCH_Features(AbstractTest): + features = ["VX", "VXE", "VXE2"] + + def load_flags(self): + self.load_flags_auxv() + + +is_arm = re.match("^(arm|aarch64)", machine, re.IGNORECASE) +@pytest.mark.skipif(not is_linux or not is_arm, reason="Only for Linux and ARM") +class Test_ARM_Features(AbstractTest): + features = [ + "SVE", "NEON", "ASIMD", "FPHP", "ASIMDHP", "ASIMDDP", "ASIMDFHM" + ] + features_groups = dict( + NEON_FP16 = ["NEON", "HALF"], + NEON_VFPV4 = ["NEON", "VFPV4"], + ) + def load_flags(self): + self.load_flags_cpuinfo("Features") + arch = self.get_cpuinfo_item("CPU architecture") + # in case of mounting virtual filesystem of aarch64 kernel + is_rootfs_v8 = int('0'+next(iter(arch))) > 7 if arch else 0 + if re.match("^(aarch64|AARCH64)", machine) or is_rootfs_v8: + self.features_map = dict( + NEON="ASIMD", HALF="ASIMD", VFPV4="ASIMD" + ) + else: + self.features_map = dict( + # ELF auxiliary vector and /proc/cpuinfo on Linux kernel(armv8 aarch32) + # doesn't provide information about ASIMD, so we assume that ASIMD is supported + # if the kernel reports any one of the following ARM8 features. + ASIMD=("AES", "SHA1", "SHA2", "PMULL", "CRC32") + ) diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/test_custom_dtypes.py b/venv/lib/python3.12/site-packages/numpy/_core/tests/test_custom_dtypes.py new file mode 100644 index 00000000..e8acb450 --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/tests/test_custom_dtypes.py @@ -0,0 +1,312 @@ +import sys +from tempfile import NamedTemporaryFile + +import pytest + +import numpy as np +from numpy.testing import assert_array_equal +from numpy._core._multiarray_umath import ( + _discover_array_parameters as discover_array_params, _get_sfloat_dtype) + + +SF = _get_sfloat_dtype() + + +class TestSFloat: + def _get_array(self, scaling, aligned=True): + if not aligned: + a = np.empty(3*8 + 1, dtype=np.uint8)[1:] + a = a.view(np.float64) + a[:] = [1., 2., 3.] + else: + a = np.array([1., 2., 3.]) + + a *= 1./scaling # the casting code also uses the reciprocal. + return a.view(SF(scaling)) + + def test_sfloat_rescaled(self): + sf = SF(1.) + sf2 = sf.scaled_by(2.) + assert sf2.get_scaling() == 2. + sf6 = sf2.scaled_by(3.) + assert sf6.get_scaling() == 6. + + def test_class_discovery(self): + # This does not test much, since we always discover the scaling as 1. + # But most of NumPy (when writing) does not understand DType classes + dt, _ = discover_array_params([1., 2., 3.], dtype=SF) + assert dt == SF(1.) + + @pytest.mark.parametrize("scaling", [1., -1., 2.]) + def test_scaled_float_from_floats(self, scaling): + a = np.array([1., 2., 3.], dtype=SF(scaling)) + + assert a.dtype.get_scaling() == scaling + assert_array_equal(scaling * a.view(np.float64), [1., 2., 3.]) + + def test_repr(self): + # Check the repr, mainly to cover the code paths: + assert repr(SF(scaling=1.)) == "_ScaledFloatTestDType(scaling=1.0)" + + def test_dtype_name(self): + assert SF(1.).name == "_ScaledFloatTestDType64" + + def test_sfloat_structured_dtype_printing(self): + dt = np.dtype([("id", int), ("value", SF(0.5))]) + # repr of structured dtypes need special handling because the + # implementation bypasses the object repr + assert "('value', '_ScaledFloatTestDType64')" in repr(dt) + + @pytest.mark.parametrize("scaling", [1., -1., 2.]) + def test_sfloat_from_float(self, scaling): + a = np.array([1., 2., 3.]).astype(dtype=SF(scaling)) + + assert a.dtype.get_scaling() == scaling + assert_array_equal(scaling * a.view(np.float64), [1., 2., 3.]) + + @pytest.mark.parametrize("aligned", [True, False]) + @pytest.mark.parametrize("scaling", [1., -1., 2.]) + def test_sfloat_getitem(self, aligned, scaling): + a = self._get_array(1., aligned) + assert a.tolist() == [1., 2., 3.] + + @pytest.mark.parametrize("aligned", [True, False]) + def test_sfloat_casts(self, aligned): + a = self._get_array(1., aligned) + + assert np.can_cast(a, SF(-1.), casting="equiv") + assert not np.can_cast(a, SF(-1.), casting="no") + na = a.astype(SF(-1.)) + assert_array_equal(-1 * na.view(np.float64), a.view(np.float64)) + + assert np.can_cast(a, SF(2.), casting="same_kind") + assert not np.can_cast(a, SF(2.), casting="safe") + a2 = a.astype(SF(2.)) + assert_array_equal(2 * a2.view(np.float64), a.view(np.float64)) + + @pytest.mark.parametrize("aligned", [True, False]) + def test_sfloat_cast_internal_errors(self, aligned): + a = self._get_array(2e300, aligned) + + with pytest.raises(TypeError, + match="error raised inside the core-loop: non-finite factor!"): + a.astype(SF(2e-300)) + + def test_sfloat_promotion(self): + assert np.result_type(SF(2.), SF(3.)) == SF(3.) + assert np.result_type(SF(3.), SF(2.)) == SF(3.) + # Float64 -> SF(1.) and then promotes normally, so both of this work: + assert np.result_type(SF(3.), np.float64) == SF(3.) + assert np.result_type(np.float64, SF(0.5)) == SF(1.) + + # Test an undefined promotion: + with pytest.raises(TypeError): + np.result_type(SF(1.), np.int64) + + def test_basic_multiply(self): + a = self._get_array(2.) + b = self._get_array(4.) + + res = a * b + # multiplies dtype scaling and content separately: + assert res.dtype.get_scaling() == 8. + expected_view = a.view(np.float64) * b.view(np.float64) + assert_array_equal(res.view(np.float64), expected_view) + + def test_possible_and_impossible_reduce(self): + # For reductions to work, the first and last operand must have the + # same dtype. For this parametric DType that is not necessarily true. + a = self._get_array(2.) + # Addition reductin works (as of writing requires to pass initial + # because setting a scaled-float from the default `0` fails). + res = np.add.reduce(a, initial=0.) + assert res == a.astype(np.float64).sum() + + # But each multiplication changes the factor, so a reduction is not + # possible (the relaxed version of the old refusal to handle any + # flexible dtype). + with pytest.raises(TypeError, + match="the resolved dtypes are not compatible"): + np.multiply.reduce(a) + + def test_basic_ufunc_at(self): + float_a = np.array([1., 2., 3.]) + b = self._get_array(2.) + + float_b = b.view(np.float64).copy() + np.multiply.at(float_b, [1, 1, 1], float_a) + np.multiply.at(b, [1, 1, 1], float_a) + + assert_array_equal(b.view(np.float64), float_b) + + def test_basic_multiply_promotion(self): + float_a = np.array([1., 2., 3.]) + b = self._get_array(2.) + + res1 = float_a * b + res2 = b * float_a + + # one factor is one, so we get the factor of b: + assert res1.dtype == res2.dtype == b.dtype + expected_view = float_a * b.view(np.float64) + assert_array_equal(res1.view(np.float64), expected_view) + assert_array_equal(res2.view(np.float64), expected_view) + + # Check that promotion works when `out` is used: + np.multiply(b, float_a, out=res2) + with pytest.raises(TypeError): + # The promoter accepts this (maybe it should not), but the SFloat + # result cannot be cast to integer: + np.multiply(b, float_a, out=np.arange(3)) + + def test_basic_addition(self): + a = self._get_array(2.) + b = self._get_array(4.) + + res = a + b + # addition uses the type promotion rules for the result: + assert res.dtype == np.result_type(a.dtype, b.dtype) + expected_view = (a.astype(res.dtype).view(np.float64) + + b.astype(res.dtype).view(np.float64)) + assert_array_equal(res.view(np.float64), expected_view) + + def test_addition_cast_safety(self): + """The addition method is special for the scaled float, because it + includes the "cast" between different factors, thus cast-safety + is influenced by the implementation. + """ + a = self._get_array(2.) + b = self._get_array(-2.) + c = self._get_array(3.) + + # sign change is "equiv": + np.add(a, b, casting="equiv") + with pytest.raises(TypeError): + np.add(a, b, casting="no") + + # Different factor is "same_kind" (default) so check that "safe" fails + with pytest.raises(TypeError): + np.add(a, c, casting="safe") + + # Check that casting the output fails also (done by the ufunc here) + with pytest.raises(TypeError): + np.add(a, a, out=c, casting="safe") + + @pytest.mark.parametrize("ufunc", + [np.logical_and, np.logical_or, np.logical_xor]) + def test_logical_ufuncs_casts_to_bool(self, ufunc): + a = self._get_array(2.) + a[0] = 0. # make sure first element is considered False. + + float_equiv = a.astype(float) + expected = ufunc(float_equiv, float_equiv) + res = ufunc(a, a) + assert_array_equal(res, expected) + + # also check that the same works for reductions: + expected = ufunc.reduce(float_equiv) + res = ufunc.reduce(a) + assert_array_equal(res, expected) + + # The output casting does not match the bool, bool -> bool loop: + with pytest.raises(TypeError): + ufunc(a, a, out=np.empty(a.shape, dtype=int), casting="equiv") + + def test_wrapped_and_wrapped_reductions(self): + a = self._get_array(2.) + float_equiv = a.astype(float) + + expected = np.hypot(float_equiv, float_equiv) + res = np.hypot(a, a) + assert res.dtype == a.dtype + res_float = res.view(np.float64) * 2 + assert_array_equal(res_float, expected) + + # Also check reduction (keepdims, due to incorrect getitem) + res = np.hypot.reduce(a, keepdims=True) + assert res.dtype == a.dtype + expected = np.hypot.reduce(float_equiv, keepdims=True) + assert res.view(np.float64) * 2 == expected + + def test_astype_class(self): + # Very simple test that we accept `.astype()` also on the class. + # ScaledFloat always returns the default descriptor, but it does + # check the relevant code paths. + arr = np.array([1., 2., 3.], dtype=object) + + res = arr.astype(SF) # passing the class class + expected = arr.astype(SF(1.)) # above will have discovered 1. scaling + assert_array_equal(res.view(np.float64), expected.view(np.float64)) + + def test_creation_class(self): + # passing in a dtype class should return + # the default descriptor + arr1 = np.array([1., 2., 3.], dtype=SF) + assert arr1.dtype == SF(1.) + arr2 = np.array([1., 2., 3.], dtype=SF(1.)) + assert_array_equal(arr1.view(np.float64), arr2.view(np.float64)) + assert arr1.dtype == arr2.dtype + + assert np.empty(3, dtype=SF).dtype == SF(1.) + assert np.empty_like(arr1, dtype=SF).dtype == SF(1.) + assert np.zeros(3, dtype=SF).dtype == SF(1.) + assert np.zeros_like(arr1, dtype=SF).dtype == SF(1.) + + def test_np_save_load(self): + # this monkeypatch is needed because pickle + # uses the repr of a type to reconstruct it + np._ScaledFloatTestDType = SF + + arr = np.array([1.0, 2.0, 3.0], dtype=SF(1.0)) + + # adapted from RoundtripTest.roundtrip in np.save tests + with NamedTemporaryFile("wb", delete=False, suffix=".npz") as f: + with pytest.warns(UserWarning) as record: + np.savez(f.name, arr) + + assert len(record) == 1 + + with np.load(f.name, allow_pickle=True) as data: + larr = data["arr_0"] + assert_array_equal(arr.view(np.float64), larr.view(np.float64)) + assert larr.dtype == arr.dtype == SF(1.0) + + del np._ScaledFloatTestDType + + def test_flatiter(self): + arr = np.array([1.0, 2.0, 3.0], dtype=SF(1.0)) + + for i, val in enumerate(arr.flat): + assert arr[i] == val + + @pytest.mark.parametrize( + "index", [ + [1, 2], ..., slice(None, 2, None), + np.array([True, True, False]), np.array([0, 1]) + ], ids=["int_list", "ellipsis", "slice", "bool_array", "int_array"]) + def test_flatiter_index(self, index): + arr = np.array([1.0, 2.0, 3.0], dtype=SF(1.0)) + np.testing.assert_array_equal( + arr[index].view(np.float64), arr.flat[index].view(np.float64)) + + arr2 = arr.copy() + arr[index] = 5.0 + arr2.flat[index] = 5.0 + np.testing.assert_array_equal( + arr.view(np.float64), arr2.view(np.float64)) + +def test_type_pickle(): + # can't actually unpickle, but we can pickle (if in namespace) + import pickle + + np._ScaledFloatTestDType = SF + + s = pickle.dumps(SF) + res = pickle.loads(s) + assert res is SF + + del np._ScaledFloatTestDType + + +def test_is_numeric(): + assert SF._is_numeric diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/test_cython.py b/venv/lib/python3.12/site-packages/numpy/_core/tests/test_cython.py new file mode 100644 index 00000000..71c1a457 --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/tests/test_cython.py @@ -0,0 +1,302 @@ +from datetime import datetime +import os +import shutil +import subprocess +import sys +import time +import pytest + +import numpy as np +from numpy.testing import assert_array_equal, IS_WASM, IS_EDITABLE + +# This import is copied from random.tests.test_extending +try: + import cython + from Cython.Compiler.Version import version as cython_version +except ImportError: + cython = None +else: + from numpy._utils import _pep440 + + # Note: keep in sync with the one in pyproject.toml + required_version = "3.0.6" + if _pep440.parse(cython_version) < _pep440.Version(required_version): + # too old or wrong cython, skip the test + cython = None + +pytestmark = pytest.mark.skipif(cython is None, reason="requires cython") + + +if IS_EDITABLE: + pytest.skip( + "Editable install doesn't support tests with a compile step", + allow_module_level=True + ) + + +@pytest.fixture(scope='module') +def install_temp(tmpdir_factory): + # Based in part on test_cython from random.tests.test_extending + if IS_WASM: + pytest.skip("No subprocess") + + srcdir = os.path.join(os.path.dirname(__file__), 'examples', 'cython') + build_dir = tmpdir_factory.mktemp("cython_test") / "build" + os.makedirs(build_dir, exist_ok=True) + # Ensure we use the correct Python interpreter even when `meson` is + # installed in a different Python environment (see gh-24956) + native_file = str(build_dir / 'interpreter-native-file.ini') + with open(native_file, 'w') as f: + f.write("[binaries]\n") + f.write(f"python = '{sys.executable}'") + + try: + subprocess.check_call(["meson", "--version"]) + except FileNotFoundError: + pytest.skip("No usable 'meson' found") + if sys.platform == "win32": + subprocess.check_call(["meson", "setup", + "--buildtype=release", + "--vsenv", "--native-file", native_file, + str(srcdir)], + cwd=build_dir, + ) + else: + subprocess.check_call(["meson", "setup", + "--native-file", native_file, str(srcdir)], + cwd=build_dir + ) + try: + subprocess.check_call(["meson", "compile", "-vv"], cwd=build_dir) + except subprocess.CalledProcessError: + print("----------------") + print("meson build failed when doing") + print(f"'meson setup --native-file {native_file} {srcdir}'") + print(f"'meson compile -vv'") + print(f"in {build_dir}") + print("----------------") + raise + + sys.path.append(str(build_dir)) + + +def test_is_timedelta64_object(install_temp): + import checks + + assert checks.is_td64(np.timedelta64(1234)) + assert checks.is_td64(np.timedelta64(1234, "ns")) + assert checks.is_td64(np.timedelta64("NaT", "ns")) + + assert not checks.is_td64(1) + assert not checks.is_td64(None) + assert not checks.is_td64("foo") + assert not checks.is_td64(np.datetime64("now", "s")) + + +def test_is_datetime64_object(install_temp): + import checks + + assert checks.is_dt64(np.datetime64(1234, "ns")) + assert checks.is_dt64(np.datetime64("NaT", "ns")) + + assert not checks.is_dt64(1) + assert not checks.is_dt64(None) + assert not checks.is_dt64("foo") + assert not checks.is_dt64(np.timedelta64(1234)) + + +def test_get_datetime64_value(install_temp): + import checks + + dt64 = np.datetime64("2016-01-01", "ns") + + result = checks.get_dt64_value(dt64) + expected = dt64.view("i8") + + assert result == expected + + +def test_get_timedelta64_value(install_temp): + import checks + + td64 = np.timedelta64(12345, "h") + + result = checks.get_td64_value(td64) + expected = td64.view("i8") + + assert result == expected + + +def test_get_datetime64_unit(install_temp): + import checks + + dt64 = np.datetime64("2016-01-01", "ns") + result = checks.get_dt64_unit(dt64) + expected = 10 + assert result == expected + + td64 = np.timedelta64(12345, "h") + result = checks.get_dt64_unit(td64) + expected = 5 + assert result == expected + + +def test_abstract_scalars(install_temp): + import checks + + assert checks.is_integer(1) + assert checks.is_integer(np.int8(1)) + assert checks.is_integer(np.uint64(1)) + +def test_default_int(install_temp): + import checks + + assert checks.get_default_integer() is np.dtype(int) + + +def test_ravel_axis(install_temp): + import checks + + assert checks.get_ravel_axis() == np.iinfo("intc").min + + +def test_convert_datetime64_to_datetimestruct(install_temp): + # GH#21199 + import checks + + res = checks.convert_datetime64_to_datetimestruct() + + exp = { + "year": 2022, + "month": 3, + "day": 15, + "hour": 20, + "min": 1, + "sec": 55, + "us": 260292, + "ps": 0, + "as": 0, + } + + assert res == exp + + +class TestDatetimeStrings: + def test_make_iso_8601_datetime(self, install_temp): + # GH#21199 + import checks + dt = datetime(2016, 6, 2, 10, 45, 19) + # uses NPY_FR_s + result = checks.make_iso_8601_datetime(dt) + assert result == b"2016-06-02T10:45:19" + + def test_get_datetime_iso_8601_strlen(self, install_temp): + # GH#21199 + import checks + # uses NPY_FR_ns + res = checks.get_datetime_iso_8601_strlen() + assert res == 48 + + +@pytest.mark.parametrize( + "arrays", + [ + [np.random.rand(2)], + [np.random.rand(2), np.random.rand(3, 1)], + [np.random.rand(2), np.random.rand(2, 3, 2), np.random.rand(1, 3, 2)], + [np.random.rand(2, 1)] * 4 + [np.random.rand(1, 1, 1)], + ] +) +def test_multiiter_fields(install_temp, arrays): + import checks + bcast = np.broadcast(*arrays) + + assert bcast.ndim == checks.get_multiiter_number_of_dims(bcast) + assert bcast.size == checks.get_multiiter_size(bcast) + assert bcast.numiter == checks.get_multiiter_num_of_iterators(bcast) + assert bcast.shape == checks.get_multiiter_shape(bcast) + assert bcast.index == checks.get_multiiter_current_index(bcast) + assert all( + [ + x.base is y.base + for x, y in zip(bcast.iters, checks.get_multiiter_iters(bcast)) + ] + ) + + +def test_dtype_flags(install_temp): + import checks + dtype = np.dtype("i,O") # dtype with somewhat interesting flags + assert dtype.flags == checks.get_dtype_flags(dtype) + + +def test_conv_intp(install_temp): + import checks + + class myint: + def __int__(self): + return 3 + + # These conversion passes via `__int__`, not `__index__`: + assert checks.conv_intp(3.) == 3 + assert checks.conv_intp(myint()) == 3 + + +def test_npyiter_api(install_temp): + import checks + arr = np.random.rand(3, 2) + + it = np.nditer(arr) + assert checks.get_npyiter_size(it) == it.itersize == np.prod(arr.shape) + assert checks.get_npyiter_ndim(it) == it.ndim == 1 + assert checks.npyiter_has_index(it) == it.has_index == False + + it = np.nditer(arr, flags=["c_index"]) + assert checks.npyiter_has_index(it) == it.has_index == True + assert ( + checks.npyiter_has_delayed_bufalloc(it) + == it.has_delayed_bufalloc + == False + ) + + it = np.nditer(arr, flags=["buffered", "delay_bufalloc"]) + assert ( + checks.npyiter_has_delayed_bufalloc(it) + == it.has_delayed_bufalloc + == True + ) + + it = np.nditer(arr, flags=["multi_index"]) + assert checks.get_npyiter_size(it) == it.itersize == np.prod(arr.shape) + assert checks.npyiter_has_multi_index(it) == it.has_multi_index == True + assert checks.get_npyiter_ndim(it) == it.ndim == 2 + + arr2 = np.random.rand(2, 1, 2) + it = np.nditer([arr, arr2]) + assert checks.get_npyiter_nop(it) == it.nop == 2 + assert checks.get_npyiter_size(it) == it.itersize == 12 + assert checks.get_npyiter_ndim(it) == it.ndim == 3 + assert all( + x is y for x, y in zip(checks.get_npyiter_operands(it), it.operands) + ) + assert all( + [ + np.allclose(x, y) + for x, y in zip(checks.get_npyiter_itviews(it), it.itviews) + ] + ) + + +def test_fillwithbytes(install_temp): + import checks + + arr = checks.compile_fillwithbyte() + assert_array_equal(arr, np.ones((1, 2))) + + +def test_complex(install_temp): + from checks import inc2_cfloat_struct + + arr = np.array([0, 10+10j], dtype="F") + inc2_cfloat_struct(arr) + assert arr[1] == (12 + 12j) diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/test_datetime.py b/venv/lib/python3.12/site-packages/numpy/_core/tests/test_datetime.py new file mode 100644 index 00000000..70a29479 --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/tests/test_datetime.py @@ -0,0 +1,2596 @@ +import datetime +import pickle + +import pytest + +import numpy +import numpy as np +from numpy.testing import ( + IS_WASM, + assert_, assert_equal, assert_raises, assert_warns, suppress_warnings, + assert_raises_regex, assert_array_equal, + ) + +# Use pytz to test out various time zones if available +try: + from pytz import timezone as tz + _has_pytz = True +except ImportError: + _has_pytz = False + +try: + RecursionError +except NameError: + RecursionError = RuntimeError # python < 3.5 + + +class TestDateTime: + + def test_string(self): + msg = "no explicit representation of timezones available for " \ + "np.datetime64" + with pytest.warns(UserWarning, match=msg): + np.datetime64('2000-01-01T00+01') + + def test_datetime(self): + msg = "no explicit representation of timezones available for " \ + "np.datetime64" + with pytest.warns(UserWarning, match=msg): + t0 = np.datetime64('2023-06-09T12:18:40Z', 'ns') + + t0 = np.datetime64('2023-06-09T12:18:40', 'ns') + + def test_datetime_dtype_creation(self): + for unit in ['Y', 'M', 'W', 'D', + 'h', 'm', 's', 'ms', 'us', + 'μs', # alias for us + 'ns', 'ps', 'fs', 'as']: + dt1 = np.dtype('M8[750%s]' % unit) + assert_(dt1 == np.dtype('datetime64[750%s]' % unit)) + dt2 = np.dtype('m8[%s]' % unit) + assert_(dt2 == np.dtype('timedelta64[%s]' % unit)) + + # Generic units shouldn't add [] to the end + assert_equal(str(np.dtype("M8")), "datetime64") + + # Should be possible to specify the endianness + assert_equal(np.dtype("=M8"), np.dtype("M8")) + assert_equal(np.dtype("=M8[s]"), np.dtype("M8[s]")) + assert_(np.dtype(">M8") == np.dtype("M8") or + np.dtype("M8[D]") == np.dtype("M8[D]") or + np.dtype("M8") != np.dtype("m8") == np.dtype("m8") or + np.dtype("m8[D]") == np.dtype("m8[D]") or + np.dtype("m8") != np.dtype(" Scalars + assert_equal(np.datetime64(b, '[s]'), np.datetime64('NaT', '[s]')) + assert_equal(np.datetime64(b, '[ms]'), np.datetime64('NaT', '[ms]')) + assert_equal(np.datetime64(b, '[M]'), np.datetime64('NaT', '[M]')) + assert_equal(np.datetime64(b, '[Y]'), np.datetime64('NaT', '[Y]')) + assert_equal(np.datetime64(b, '[W]'), np.datetime64('NaT', '[W]')) + + # Arrays -> Scalars + assert_equal(np.datetime64(a, '[s]'), np.datetime64('NaT', '[s]')) + assert_equal(np.datetime64(a, '[ms]'), np.datetime64('NaT', '[ms]')) + assert_equal(np.datetime64(a, '[M]'), np.datetime64('NaT', '[M]')) + assert_equal(np.datetime64(a, '[Y]'), np.datetime64('NaT', '[Y]')) + assert_equal(np.datetime64(a, '[W]'), np.datetime64('NaT', '[W]')) + + # NaN -> NaT + nan = np.array([np.nan] * 8 + [0]) + fnan = nan.astype('f') + lnan = nan.astype('g') + cnan = nan.astype('D') + cfnan = nan.astype('F') + clnan = nan.astype('G') + hnan = nan.astype(np.half) + + nat = np.array([np.datetime64('NaT')] * 8 + [np.datetime64(0, 'D')]) + assert_equal(nan.astype('M8[ns]'), nat) + assert_equal(fnan.astype('M8[ns]'), nat) + assert_equal(lnan.astype('M8[ns]'), nat) + assert_equal(cnan.astype('M8[ns]'), nat) + assert_equal(cfnan.astype('M8[ns]'), nat) + assert_equal(clnan.astype('M8[ns]'), nat) + assert_equal(hnan.astype('M8[ns]'), nat) + + nat = np.array([np.timedelta64('NaT')] * 8 + [np.timedelta64(0)]) + assert_equal(nan.astype('timedelta64[ns]'), nat) + assert_equal(fnan.astype('timedelta64[ns]'), nat) + assert_equal(lnan.astype('timedelta64[ns]'), nat) + assert_equal(cnan.astype('timedelta64[ns]'), nat) + assert_equal(cfnan.astype('timedelta64[ns]'), nat) + assert_equal(clnan.astype('timedelta64[ns]'), nat) + assert_equal(hnan.astype('timedelta64[ns]'), nat) + + def test_days_creation(self): + assert_equal(np.array('1599', dtype='M8[D]').astype('i8'), + (1600-1970)*365 - (1972-1600)/4 + 3 - 365) + assert_equal(np.array('1600', dtype='M8[D]').astype('i8'), + (1600-1970)*365 - (1972-1600)/4 + 3) + assert_equal(np.array('1601', dtype='M8[D]').astype('i8'), + (1600-1970)*365 - (1972-1600)/4 + 3 + 366) + assert_equal(np.array('1900', dtype='M8[D]').astype('i8'), + (1900-1970)*365 - (1970-1900)//4) + assert_equal(np.array('1901', dtype='M8[D]').astype('i8'), + (1900-1970)*365 - (1970-1900)//4 + 365) + assert_equal(np.array('1967', dtype='M8[D]').astype('i8'), -3*365 - 1) + assert_equal(np.array('1968', dtype='M8[D]').astype('i8'), -2*365 - 1) + assert_equal(np.array('1969', dtype='M8[D]').astype('i8'), -1*365) + assert_equal(np.array('1970', dtype='M8[D]').astype('i8'), 0*365) + assert_equal(np.array('1971', dtype='M8[D]').astype('i8'), 1*365) + assert_equal(np.array('1972', dtype='M8[D]').astype('i8'), 2*365) + assert_equal(np.array('1973', dtype='M8[D]').astype('i8'), 3*365 + 1) + assert_equal(np.array('1974', dtype='M8[D]').astype('i8'), 4*365 + 1) + assert_equal(np.array('2000', dtype='M8[D]').astype('i8'), + (2000 - 1970)*365 + (2000 - 1972)//4) + assert_equal(np.array('2001', dtype='M8[D]').astype('i8'), + (2000 - 1970)*365 + (2000 - 1972)//4 + 366) + assert_equal(np.array('2400', dtype='M8[D]').astype('i8'), + (2400 - 1970)*365 + (2400 - 1972)//4 - 3) + assert_equal(np.array('2401', dtype='M8[D]').astype('i8'), + (2400 - 1970)*365 + (2400 - 1972)//4 - 3 + 366) + + assert_equal(np.array('1600-02-29', dtype='M8[D]').astype('i8'), + (1600-1970)*365 - (1972-1600)//4 + 3 + 31 + 28) + assert_equal(np.array('1600-03-01', dtype='M8[D]').astype('i8'), + (1600-1970)*365 - (1972-1600)//4 + 3 + 31 + 29) + assert_equal(np.array('2000-02-29', dtype='M8[D]').astype('i8'), + (2000 - 1970)*365 + (2000 - 1972)//4 + 31 + 28) + assert_equal(np.array('2000-03-01', dtype='M8[D]').astype('i8'), + (2000 - 1970)*365 + (2000 - 1972)//4 + 31 + 29) + assert_equal(np.array('2001-03-22', dtype='M8[D]').astype('i8'), + (2000 - 1970)*365 + (2000 - 1972)//4 + 366 + 31 + 28 + 21) + + def test_days_to_pydate(self): + assert_equal(np.array('1599', dtype='M8[D]').astype('O'), + datetime.date(1599, 1, 1)) + assert_equal(np.array('1600', dtype='M8[D]').astype('O'), + datetime.date(1600, 1, 1)) + assert_equal(np.array('1601', dtype='M8[D]').astype('O'), + datetime.date(1601, 1, 1)) + assert_equal(np.array('1900', dtype='M8[D]').astype('O'), + datetime.date(1900, 1, 1)) + assert_equal(np.array('1901', dtype='M8[D]').astype('O'), + datetime.date(1901, 1, 1)) + assert_equal(np.array('2000', dtype='M8[D]').astype('O'), + datetime.date(2000, 1, 1)) + assert_equal(np.array('2001', dtype='M8[D]').astype('O'), + datetime.date(2001, 1, 1)) + assert_equal(np.array('1600-02-29', dtype='M8[D]').astype('O'), + datetime.date(1600, 2, 29)) + assert_equal(np.array('1600-03-01', dtype='M8[D]').astype('O'), + datetime.date(1600, 3, 1)) + assert_equal(np.array('2001-03-22', dtype='M8[D]').astype('O'), + datetime.date(2001, 3, 22)) + + def test_dtype_comparison(self): + assert_(not (np.dtype('M8[us]') == np.dtype('M8[ms]'))) + assert_(np.dtype('M8[us]') != np.dtype('M8[ms]')) + assert_(np.dtype('M8[2D]') != np.dtype('M8[D]')) + assert_(np.dtype('M8[D]') != np.dtype('M8[2D]')) + + def test_pydatetime_creation(self): + a = np.array(['1960-03-12', datetime.date(1960, 3, 12)], dtype='M8[D]') + assert_equal(a[0], a[1]) + a = np.array(['1999-12-31', datetime.date(1999, 12, 31)], dtype='M8[D]') + assert_equal(a[0], a[1]) + a = np.array(['2000-01-01', datetime.date(2000, 1, 1)], dtype='M8[D]') + assert_equal(a[0], a[1]) + # Will fail if the date changes during the exact right moment + a = np.array(['today', datetime.date.today()], dtype='M8[D]') + assert_equal(a[0], a[1]) + # datetime.datetime.now() returns local time, not UTC + #a = np.array(['now', datetime.datetime.now()], dtype='M8[s]') + #assert_equal(a[0], a[1]) + + # we can give a datetime.date time units + assert_equal(np.array(datetime.date(1960, 3, 12), dtype='M8[s]'), + np.array(np.datetime64('1960-03-12T00:00:00'))) + + def test_datetime_string_conversion(self): + a = ['2011-03-16', '1920-01-01', '2013-05-19'] + str_a = np.array(a, dtype='S') + uni_a = np.array(a, dtype='U') + dt_a = np.array(a, dtype='M') + + # String to datetime + assert_equal(dt_a, str_a.astype('M')) + assert_equal(dt_a.dtype, str_a.astype('M').dtype) + dt_b = np.empty_like(dt_a) + dt_b[...] = str_a + assert_equal(dt_a, dt_b) + + # Datetime to string + assert_equal(str_a, dt_a.astype('S0')) + str_b = np.empty_like(str_a) + str_b[...] = dt_a + assert_equal(str_a, str_b) + + # Unicode to datetime + assert_equal(dt_a, uni_a.astype('M')) + assert_equal(dt_a.dtype, uni_a.astype('M').dtype) + dt_b = np.empty_like(dt_a) + dt_b[...] = uni_a + assert_equal(dt_a, dt_b) + + # Datetime to unicode + assert_equal(uni_a, dt_a.astype('U')) + uni_b = np.empty_like(uni_a) + uni_b[...] = dt_a + assert_equal(uni_a, uni_b) + + # Datetime to long string - gh-9712 + assert_equal(str_a, dt_a.astype((np.bytes_, 128))) + str_b = np.empty(str_a.shape, dtype=(np.bytes_, 128)) + str_b[...] = dt_a + assert_equal(str_a, str_b) + + @pytest.mark.parametrize("time_dtype", ["m8[D]", "M8[Y]"]) + def test_time_byteswapping(self, time_dtype): + times = np.array(["2017", "NaT"], dtype=time_dtype) + times_swapped = times.astype(times.dtype.newbyteorder()) + assert_array_equal(times, times_swapped) + + unswapped = times_swapped.view(np.dtype("int64").newbyteorder()) + assert_array_equal(unswapped, times.view(np.int64)) + + @pytest.mark.parametrize(["time1", "time2"], + [("M8[s]", "M8[D]"), ("m8[s]", "m8[ns]")]) + def test_time_byteswapped_cast(self, time1, time2): + dtype1 = np.dtype(time1) + dtype2 = np.dtype(time2) + times = np.array(["2017", "NaT"], dtype=dtype1) + expected = times.astype(dtype2) + + # Test that every byte-swapping combination also returns the same + # results (previous tests check that this comparison works fine). + res = times.astype(dtype1.newbyteorder()).astype(dtype2) + assert_array_equal(res, expected) + res = times.astype(dtype2.newbyteorder()) + assert_array_equal(res, expected) + res = times.astype(dtype1.newbyteorder()).astype(dtype2.newbyteorder()) + assert_array_equal(res, expected) + + @pytest.mark.parametrize("time_dtype", ["m8[D]", "M8[Y]"]) + @pytest.mark.parametrize("str_dtype", ["U", "S"]) + def test_datetime_conversions_byteorders(self, str_dtype, time_dtype): + times = np.array(["2017", "NaT"], dtype=time_dtype) + # Unfortunately, timedelta does not roundtrip: + from_strings = np.array(["2017", "NaT"], dtype=str_dtype) + to_strings = times.astype(str_dtype) # assume this is correct + + # Check that conversion from times to string works if src is swapped: + times_swapped = times.astype(times.dtype.newbyteorder()) + res = times_swapped.astype(str_dtype) + assert_array_equal(res, to_strings) + # And also if both are swapped: + res = times_swapped.astype(to_strings.dtype.newbyteorder()) + assert_array_equal(res, to_strings) + # only destination is swapped: + res = times.astype(to_strings.dtype.newbyteorder()) + assert_array_equal(res, to_strings) + + # Check that conversion from string to times works if src is swapped: + from_strings_swapped = from_strings.astype( + from_strings.dtype.newbyteorder()) + res = from_strings_swapped.astype(time_dtype) + assert_array_equal(res, times) + # And if both are swapped: + res = from_strings_swapped.astype(times.dtype.newbyteorder()) + assert_array_equal(res, times) + # Only destination is swapped: + res = from_strings.astype(times.dtype.newbyteorder()) + assert_array_equal(res, times) + + def test_datetime_array_str(self): + a = np.array(['2011-03-16', '1920-01-01', '2013-05-19'], dtype='M') + assert_equal(str(a), "['2011-03-16' '1920-01-01' '2013-05-19']") + + a = np.array(['2011-03-16T13:55', '1920-01-01T03:12'], dtype='M') + assert_equal(np.array2string(a, separator=', ', + formatter={'datetime': lambda x: + "'%s'" % np.datetime_as_string(x, timezone='UTC')}), + "['2011-03-16T13:55Z', '1920-01-01T03:12Z']") + + # Check that one NaT doesn't corrupt subsequent entries + a = np.array(['2010', 'NaT', '2030']).astype('M') + assert_equal(str(a), "['2010' 'NaT' '2030']") + + def test_timedelta_array_str(self): + a = np.array([-1, 0, 100], dtype='m') + assert_equal(str(a), "[ -1 0 100]") + a = np.array(['NaT', 'NaT'], dtype='m') + assert_equal(str(a), "['NaT' 'NaT']") + # Check right-alignment with NaTs + a = np.array([-1, 'NaT', 0], dtype='m') + assert_equal(str(a), "[ -1 'NaT' 0]") + a = np.array([-1, 'NaT', 1234567], dtype='m') + assert_equal(str(a), "[ -1 'NaT' 1234567]") + + # Test with other byteorder: + a = np.array([-1, 'NaT', 1234567], dtype='>m') + assert_equal(str(a), "[ -1 'NaT' 1234567]") + a = np.array([-1, 'NaT', 1234567], dtype=''\np4\nNNNI-1\nI-1\nI0\n((dp5\n(S'us'\np6\n" + \ + b"I1\nI1\nI1\ntp7\ntp8\ntp9\nb." + assert_equal(pickle.loads(pkl), np.dtype('>M8[us]')) + + def test_setstate(self): + "Verify that datetime dtype __setstate__ can handle bad arguments" + dt = np.dtype('>M8[us]') + assert_raises(ValueError, dt.__setstate__, (4, '>', None, None, None, -1, -1, 0, 1)) + assert_(dt.__reduce__()[2] == np.dtype('>M8[us]').__reduce__()[2]) + assert_raises(TypeError, dt.__setstate__, (4, '>', None, None, None, -1, -1, 0, ({}, 'xxx'))) + assert_(dt.__reduce__()[2] == np.dtype('>M8[us]').__reduce__()[2]) + + def test_dtype_promotion(self): + # datetime datetime computes the metadata gcd + # timedelta timedelta computes the metadata gcd + for mM in ['m', 'M']: + assert_equal( + np.promote_types(np.dtype(mM+'8[2Y]'), np.dtype(mM+'8[2Y]')), + np.dtype(mM+'8[2Y]')) + assert_equal( + np.promote_types(np.dtype(mM+'8[12Y]'), np.dtype(mM+'8[15Y]')), + np.dtype(mM+'8[3Y]')) + assert_equal( + np.promote_types(np.dtype(mM+'8[62M]'), np.dtype(mM+'8[24M]')), + np.dtype(mM+'8[2M]')) + assert_equal( + np.promote_types(np.dtype(mM+'8[1W]'), np.dtype(mM+'8[2D]')), + np.dtype(mM+'8[1D]')) + assert_equal( + np.promote_types(np.dtype(mM+'8[W]'), np.dtype(mM+'8[13s]')), + np.dtype(mM+'8[s]')) + assert_equal( + np.promote_types(np.dtype(mM+'8[13W]'), np.dtype(mM+'8[49s]')), + np.dtype(mM+'8[7s]')) + # timedelta timedelta raises when there is no reasonable gcd + assert_raises(TypeError, np.promote_types, + np.dtype('m8[Y]'), np.dtype('m8[D]')) + assert_raises(TypeError, np.promote_types, + np.dtype('m8[M]'), np.dtype('m8[W]')) + # timedelta and float cannot be safely cast with each other + assert_raises(TypeError, np.promote_types, "float32", "m8") + assert_raises(TypeError, np.promote_types, "m8", "float32") + assert_raises(TypeError, np.promote_types, "uint64", "m8") + assert_raises(TypeError, np.promote_types, "m8", "uint64") + + # timedelta timedelta may overflow with big unit ranges + assert_raises(OverflowError, np.promote_types, + np.dtype('m8[W]'), np.dtype('m8[fs]')) + assert_raises(OverflowError, np.promote_types, + np.dtype('m8[s]'), np.dtype('m8[as]')) + + def test_cast_overflow(self): + # gh-4486 + def cast(): + numpy.datetime64("1971-01-01 00:00:00.000000000000000").astype("datetime64[%s]', + 'timedelta64[%s]']) + def test_isfinite_isinf_isnan_units(self, unit, dstr): + '''check isfinite, isinf, isnan for all units of M, m dtypes + ''' + arr_val = [123, -321, "NaT"] + arr = np.array(arr_val, dtype= dstr % unit) + pos = np.array([True, True, False]) + neg = np.array([False, False, True]) + false = np.array([False, False, False]) + assert_equal(np.isfinite(arr), pos) + assert_equal(np.isinf(arr), false) + assert_equal(np.isnan(arr), neg) + + def test_assert_equal(self): + assert_raises(AssertionError, assert_equal, + np.datetime64('nat'), np.timedelta64('nat')) + + def test_corecursive_input(self): + # construct a co-recursive list + a, b = [], [] + a.append(b) + b.append(a) + obj_arr = np.array([None]) + obj_arr[0] = a + + # At some point this caused a stack overflow (gh-11154). Now raises + # ValueError since the nested list cannot be converted to a datetime. + assert_raises(ValueError, obj_arr.astype, 'M8') + assert_raises(ValueError, obj_arr.astype, 'm8') + + @pytest.mark.parametrize("shape", [(), (1,)]) + def test_discovery_from_object_array(self, shape): + arr = np.array("2020-10-10", dtype=object).reshape(shape) + res = np.array("2020-10-10", dtype="M8").reshape(shape) + assert res.dtype == np.dtype("M8[D]") + assert_equal(arr.astype("M8"), res) + arr[...] = np.bytes_("2020-10-10") # try a numpy string type + assert_equal(arr.astype("M8"), res) + arr = arr.astype("S") + assert_equal(arr.astype("S").astype("M8"), res) + + @pytest.mark.parametrize("time_unit", [ + "Y", "M", "W", "D", "h", "m", "s", "ms", "us", "ns", "ps", "fs", "as", + # compound units + "10D", "2M", + ]) + def test_limit_symmetry(self, time_unit): + """ + Dates should have symmetric limits around the unix epoch at +/-np.int64 + """ + epoch = np.datetime64(0, time_unit) + latest = np.datetime64(np.iinfo(np.int64).max, time_unit) + earliest = np.datetime64(-np.iinfo(np.int64).max, time_unit) + + # above should not have overflowed + assert earliest < epoch < latest + + @pytest.mark.parametrize("time_unit", [ + "Y", "M", + pytest.param("W", marks=pytest.mark.xfail(reason="gh-13197")), + "D", "h", "m", + "s", "ms", "us", "ns", "ps", "fs", "as", + pytest.param("10D", marks=pytest.mark.xfail(reason="similar to gh-13197")), + ]) + @pytest.mark.parametrize("sign", [-1, 1]) + def test_limit_str_roundtrip(self, time_unit, sign): + """ + Limits should roundtrip when converted to strings. + + This tests the conversion to and from npy_datetimestruct. + """ + # TODO: add absolute (gold standard) time span limit strings + limit = np.datetime64(np.iinfo(np.int64).max * sign, time_unit) + + # Convert to string and back. Explicit unit needed since the day and + # week reprs are not distinguishable. + limit_via_str = np.datetime64(str(limit), time_unit) + assert limit_via_str == limit + + +class TestDateTimeData: + + def test_basic(self): + a = np.array(['1980-03-23'], dtype=np.datetime64) + assert_equal(np.datetime_data(a.dtype), ('D', 1)) + + def test_bytes(self): + # byte units are converted to unicode + dt = np.datetime64('2000', (b'ms', 5)) + assert np.datetime_data(dt.dtype) == ('ms', 5) + + dt = np.datetime64('2000', b'5ms') + assert np.datetime_data(dt.dtype) == ('ms', 5) + + def test_non_ascii(self): + # μs is normalized to μ + dt = np.datetime64('2000', ('μs', 5)) + assert np.datetime_data(dt.dtype) == ('us', 5) + + dt = np.datetime64('2000', '5μs') + assert np.datetime_data(dt.dtype) == ('us', 5) + + +def test_comparisons_return_not_implemented(): + # GH#17017 + + class custom: + __array_priority__ = 10000 + + obj = custom() + + dt = np.datetime64('2000', 'ns') + td = dt - dt + + for item in [dt, td]: + assert item.__eq__(obj) is NotImplemented + assert item.__ne__(obj) is NotImplemented + assert item.__le__(obj) is NotImplemented + assert item.__lt__(obj) is NotImplemented + assert item.__ge__(obj) is NotImplemented + assert item.__gt__(obj) is NotImplemented diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/test_defchararray.py b/venv/lib/python3.12/site-packages/numpy/_core/tests/test_defchararray.py new file mode 100644 index 00000000..6b688ab4 --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/tests/test_defchararray.py @@ -0,0 +1,822 @@ +import pytest + +import numpy as np +from numpy._core.multiarray import _vec_string +from numpy.testing import ( + assert_, assert_equal, assert_array_equal, assert_raises, + assert_raises_regex + ) + +kw_unicode_true = {'unicode': True} # make 2to3 work properly +kw_unicode_false = {'unicode': False} + +class TestBasic: + def test_from_object_array(self): + A = np.array([['abc', 2], + ['long ', '0123456789']], dtype='O') + B = np.char.array(A) + assert_equal(B.dtype.itemsize, 10) + assert_array_equal(B, [[b'abc', b'2'], + [b'long', b'0123456789']]) + + def test_from_object_array_unicode(self): + A = np.array([['abc', 'Sigma \u03a3'], + ['long ', '0123456789']], dtype='O') + assert_raises(ValueError, np.char.array, (A,)) + B = np.char.array(A, **kw_unicode_true) + assert_equal(B.dtype.itemsize, 10 * np.array('a', 'U').dtype.itemsize) + assert_array_equal(B, [['abc', 'Sigma \u03a3'], + ['long', '0123456789']]) + + def test_from_string_array(self): + A = np.array([[b'abc', b'foo'], + [b'long ', b'0123456789']]) + assert_equal(A.dtype.type, np.bytes_) + B = np.char.array(A) + assert_array_equal(B, A) + assert_equal(B.dtype, A.dtype) + assert_equal(B.shape, A.shape) + B[0, 0] = 'changed' + assert_(B[0, 0] != A[0, 0]) + C = np.char.asarray(A) + assert_array_equal(C, A) + assert_equal(C.dtype, A.dtype) + C[0, 0] = 'changed again' + assert_(C[0, 0] != B[0, 0]) + assert_(C[0, 0] == A[0, 0]) + + def test_from_unicode_array(self): + A = np.array([['abc', 'Sigma \u03a3'], + ['long ', '0123456789']]) + assert_equal(A.dtype.type, np.str_) + B = np.char.array(A) + assert_array_equal(B, A) + assert_equal(B.dtype, A.dtype) + assert_equal(B.shape, A.shape) + B = np.char.array(A, **kw_unicode_true) + assert_array_equal(B, A) + assert_equal(B.dtype, A.dtype) + assert_equal(B.shape, A.shape) + + def fail(): + np.char.array(A, **kw_unicode_false) + + assert_raises(UnicodeEncodeError, fail) + + def test_unicode_upconvert(self): + A = np.char.array(['abc']) + B = np.char.array(['\u03a3']) + assert_(issubclass((A + B).dtype.type, np.str_)) + + def test_from_string(self): + A = np.char.array(b'abc') + assert_equal(len(A), 1) + assert_equal(len(A[0]), 3) + assert_(issubclass(A.dtype.type, np.bytes_)) + + def test_from_unicode(self): + A = np.char.array('\u03a3') + assert_equal(len(A), 1) + assert_equal(len(A[0]), 1) + assert_equal(A.itemsize, 4) + assert_(issubclass(A.dtype.type, np.str_)) + +class TestVecString: + def test_non_existent_method(self): + + def fail(): + _vec_string('a', np.bytes_, 'bogus') + + assert_raises(AttributeError, fail) + + def test_non_string_array(self): + + def fail(): + _vec_string(1, np.bytes_, 'strip') + + assert_raises(TypeError, fail) + + def test_invalid_args_tuple(self): + + def fail(): + _vec_string(['a'], np.bytes_, 'strip', 1) + + assert_raises(TypeError, fail) + + def test_invalid_type_descr(self): + + def fail(): + _vec_string(['a'], 'BOGUS', 'strip') + + assert_raises(TypeError, fail) + + def test_invalid_function_args(self): + + def fail(): + _vec_string(['a'], np.bytes_, 'strip', (1,)) + + assert_raises(TypeError, fail) + + def test_invalid_result_type(self): + + def fail(): + _vec_string(['a'], np.int_, 'strip') + + assert_raises(TypeError, fail) + + def test_broadcast_error(self): + + def fail(): + _vec_string([['abc', 'def']], np.int_, 'find', (['a', 'd', 'j'],)) + + assert_raises(ValueError, fail) + + +class TestWhitespace: + def setup_method(self): + self.A = np.array([['abc ', '123 '], + ['789 ', 'xyz ']]).view(np.char.chararray) + self.B = np.array([['abc', '123'], + ['789', 'xyz']]).view(np.char.chararray) + + def test1(self): + assert_(np.all(self.A == self.B)) + assert_(np.all(self.A >= self.B)) + assert_(np.all(self.A <= self.B)) + assert_(not np.any(self.A > self.B)) + assert_(not np.any(self.A < self.B)) + assert_(not np.any(self.A != self.B)) + +class TestChar: + def setup_method(self): + self.A = np.array('abc1', dtype='c').view(np.char.chararray) + + def test_it(self): + assert_equal(self.A.shape, (4,)) + assert_equal(self.A.upper()[:2].tobytes(), b'AB') + +class TestComparisons: + def setup_method(self): + self.A = np.array([['abc', 'abcc', '123'], + ['789', 'abc', 'xyz']]).view(np.char.chararray) + self.B = np.array([['efg', 'efg', '123 '], + ['051', 'efgg', 'tuv']]).view(np.char.chararray) + + def test_not_equal(self): + assert_array_equal((self.A != self.B), + [[True, True, False], [True, True, True]]) + + def test_equal(self): + assert_array_equal((self.A == self.B), + [[False, False, True], [False, False, False]]) + + def test_greater_equal(self): + assert_array_equal((self.A >= self.B), + [[False, False, True], [True, False, True]]) + + def test_less_equal(self): + assert_array_equal((self.A <= self.B), + [[True, True, True], [False, True, False]]) + + def test_greater(self): + assert_array_equal((self.A > self.B), + [[False, False, False], [True, False, True]]) + + def test_less(self): + assert_array_equal((self.A < self.B), + [[True, True, False], [False, True, False]]) + + def test_type(self): + out1 = np.char.equal(self.A, self.B) + out2 = np.char.equal('a', 'a') + assert_(isinstance(out1, np.ndarray)) + assert_(isinstance(out2, np.ndarray)) + +class TestComparisonsMixed1(TestComparisons): + """Ticket #1276""" + + def setup_method(self): + TestComparisons.setup_method(self) + self.B = np.array( + [['efg', 'efg', '123 '], + ['051', 'efgg', 'tuv']], np.str_).view(np.char.chararray) + +class TestComparisonsMixed2(TestComparisons): + """Ticket #1276""" + + def setup_method(self): + TestComparisons.setup_method(self) + self.A = np.array( + [['abc', 'abcc', '123'], + ['789', 'abc', 'xyz']], np.str_).view(np.char.chararray) + +class TestInformation: + def setup_method(self): + self.A = np.array([[' abc ', ''], + ['12345', 'MixedCase'], + ['123 \t 345 \0 ', 'UPPER']]) \ + .view(np.char.chararray) + self.B = np.array([[' \u03a3 ', ''], + ['12345', 'MixedCase'], + ['123 \t 345 \0 ', 'UPPER']]) \ + .view(np.char.chararray) + # Array with longer strings, > MEMCHR_CUT_OFF in code. + self.C = (np.array(['ABCDEFGHIJKLMNOPQRSTUVWXYZ', + '01234567890123456789012345']) + .view(np.char.chararray)) + + def test_len(self): + assert_(issubclass(np.char.str_len(self.A).dtype.type, np.integer)) + assert_array_equal(np.char.str_len(self.A), [[5, 0], [5, 9], [12, 5]]) + assert_array_equal(np.char.str_len(self.B), [[3, 0], [5, 9], [12, 5]]) + + def test_count(self): + assert_(issubclass(self.A.count('').dtype.type, np.integer)) + assert_array_equal(self.A.count('a'), [[1, 0], [0, 1], [0, 0]]) + assert_array_equal(self.A.count('123'), [[0, 0], [1, 0], [1, 0]]) + # Python doesn't seem to like counting NULL characters + # assert_array_equal(self.A.count('\0'), [[0, 0], [0, 0], [1, 0]]) + assert_array_equal(self.A.count('a', 0, 2), [[1, 0], [0, 0], [0, 0]]) + assert_array_equal(self.B.count('a'), [[0, 0], [0, 1], [0, 0]]) + assert_array_equal(self.B.count('123'), [[0, 0], [1, 0], [1, 0]]) + # assert_array_equal(self.B.count('\0'), [[0, 0], [0, 0], [1, 0]]) + + def test_endswith(self): + assert_(issubclass(self.A.endswith('').dtype.type, np.bool)) + assert_array_equal(self.A.endswith(' '), [[1, 0], [0, 0], [1, 0]]) + assert_array_equal(self.A.endswith('3', 0, 3), [[0, 0], [1, 0], [1, 0]]) + + def fail(): + self.A.endswith('3', 'fdjk') + + assert_raises(TypeError, fail) + + @pytest.mark.parametrize( + "dtype, encode", + [("U", str), + ("S", lambda x: x.encode('ascii')), + ]) + def test_find(self, dtype, encode): + A = self.A.astype(dtype) + assert_(issubclass(A.find(encode('a')).dtype.type, np.integer)) + assert_array_equal(A.find(encode('a')), + [[1, -1], [-1, 6], [-1, -1]]) + assert_array_equal(A.find(encode('3')), + [[-1, -1], [2, -1], [2, -1]]) + assert_array_equal(A.find(encode('a'), 0, 2), + [[1, -1], [-1, -1], [-1, -1]]) + assert_array_equal(A.find([encode('1'), encode('P')]), + [[-1, -1], [0, -1], [0, 1]]) + C = self.C.astype(dtype) + assert_array_equal(C.find(encode('M')), [12, -1]) + + def test_index(self): + + def fail(): + self.A.index('a') + + assert_raises(ValueError, fail) + assert_(np.char.index('abcba', 'b') == 1) + assert_(issubclass(np.char.index('abcba', 'b').dtype.type, np.integer)) + + def test_isalnum(self): + assert_(issubclass(self.A.isalnum().dtype.type, np.bool)) + assert_array_equal(self.A.isalnum(), [[False, False], [True, True], [False, True]]) + + def test_isalpha(self): + assert_(issubclass(self.A.isalpha().dtype.type, np.bool)) + assert_array_equal(self.A.isalpha(), [[False, False], [False, True], [False, True]]) + + def test_isdigit(self): + assert_(issubclass(self.A.isdigit().dtype.type, np.bool)) + assert_array_equal(self.A.isdigit(), [[False, False], [True, False], [False, False]]) + + def test_islower(self): + assert_(issubclass(self.A.islower().dtype.type, np.bool)) + assert_array_equal(self.A.islower(), [[True, False], [False, False], [False, False]]) + + def test_isspace(self): + assert_(issubclass(self.A.isspace().dtype.type, np.bool)) + assert_array_equal(self.A.isspace(), [[False, False], [False, False], [False, False]]) + + def test_istitle(self): + assert_(issubclass(self.A.istitle().dtype.type, np.bool)) + assert_array_equal(self.A.istitle(), [[False, False], [False, False], [False, False]]) + + def test_isupper(self): + assert_(issubclass(self.A.isupper().dtype.type, np.bool)) + assert_array_equal(self.A.isupper(), [[False, False], [False, False], [False, True]]) + + def test_rfind(self): + assert_(issubclass(self.A.rfind('a').dtype.type, np.integer)) + assert_array_equal(self.A.rfind('a'), [[1, -1], [-1, 6], [-1, -1]]) + assert_array_equal(self.A.rfind('3'), [[-1, -1], [2, -1], [6, -1]]) + assert_array_equal(self.A.rfind('a', 0, 2), [[1, -1], [-1, -1], [-1, -1]]) + assert_array_equal(self.A.rfind(['1', 'P']), [[-1, -1], [0, -1], [0, 2]]) + + def test_rindex(self): + + def fail(): + self.A.rindex('a') + + assert_raises(ValueError, fail) + assert_(np.char.rindex('abcba', 'b') == 3) + assert_(issubclass(np.char.rindex('abcba', 'b').dtype.type, np.integer)) + + def test_startswith(self): + assert_(issubclass(self.A.startswith('').dtype.type, np.bool)) + assert_array_equal(self.A.startswith(' '), [[1, 0], [0, 0], [0, 0]]) + assert_array_equal(self.A.startswith('1', 0, 3), [[0, 0], [1, 0], [1, 0]]) + + def fail(): + self.A.startswith('3', 'fdjk') + + assert_raises(TypeError, fail) + + +class TestMethods: + def setup_method(self): + self.A = np.array([[' abc ', ''], + ['12345', 'MixedCase'], + ['123 \t 345 \0 ', 'UPPER']], + dtype='S').view(np.char.chararray) + self.B = np.array([[' \u03a3 ', ''], + ['12345', 'MixedCase'], + ['123 \t 345 \0 ', 'UPPER']]).view( + np.char.chararray) + + def test_capitalize(self): + tgt = [[b' abc ', b''], + [b'12345', b'Mixedcase'], + [b'123 \t 345 \0 ', b'Upper']] + assert_(issubclass(self.A.capitalize().dtype.type, np.bytes_)) + assert_array_equal(self.A.capitalize(), tgt) + + tgt = [[' \u03c3 ', ''], + ['12345', 'Mixedcase'], + ['123 \t 345 \0 ', 'Upper']] + assert_(issubclass(self.B.capitalize().dtype.type, np.str_)) + assert_array_equal(self.B.capitalize(), tgt) + + def test_center(self): + assert_(issubclass(self.A.center(10).dtype.type, np.bytes_)) + C = self.A.center([10, 20]) + assert_array_equal(np.char.str_len(C), [[10, 20], [10, 20], [12, 20]]) + + C = self.A.center(20, b'#') + assert_(np.all(C.startswith(b'#'))) + assert_(np.all(C.endswith(b'#'))) + + C = np.char.center(b'FOO', [[10, 20], [15, 8]]) + tgt = [[b' FOO ', b' FOO '], + [b' FOO ', b' FOO ']] + assert_(issubclass(C.dtype.type, np.bytes_)) + assert_array_equal(C, tgt) + + def test_decode(self): + A = np.char.array([b'\\u03a3']) + assert_(A.decode('unicode-escape')[0] == '\u03a3') + + def test_encode(self): + B = self.B.encode('unicode_escape') + assert_(B[0][0] == str(' \\u03a3 ').encode('latin1')) + + def test_expandtabs(self): + T = self.A.expandtabs() + assert_(T[2, 0] == b'123 345 \0') + + def test_join(self): + # NOTE: list(b'123') == [49, 50, 51] + # so that b','.join(b'123') results to an error on Py3 + A0 = self.A.decode('ascii') + + A = np.char.join([',', '#'], A0) + assert_(issubclass(A.dtype.type, np.str_)) + tgt = np.array([[' ,a,b,c, ', ''], + ['1,2,3,4,5', 'M#i#x#e#d#C#a#s#e'], + ['1,2,3, ,\t, ,3,4,5, ,\x00, ', 'U#P#P#E#R']]) + assert_array_equal(np.char.join([',', '#'], A0), tgt) + + def test_ljust(self): + assert_(issubclass(self.A.ljust(10).dtype.type, np.bytes_)) + + C = self.A.ljust([10, 20]) + assert_array_equal(np.char.str_len(C), [[10, 20], [10, 20], [12, 20]]) + + C = self.A.ljust(20, b'#') + assert_array_equal(C.startswith(b'#'), [ + [False, True], [False, False], [False, False]]) + assert_(np.all(C.endswith(b'#'))) + + C = np.char.ljust(b'FOO', [[10, 20], [15, 8]]) + tgt = [[b'FOO ', b'FOO '], + [b'FOO ', b'FOO ']] + assert_(issubclass(C.dtype.type, np.bytes_)) + assert_array_equal(C, tgt) + + def test_lower(self): + tgt = [[b' abc ', b''], + [b'12345', b'mixedcase'], + [b'123 \t 345 \0 ', b'upper']] + assert_(issubclass(self.A.lower().dtype.type, np.bytes_)) + assert_array_equal(self.A.lower(), tgt) + + tgt = [[' \u03c3 ', ''], + ['12345', 'mixedcase'], + ['123 \t 345 \0 ', 'upper']] + assert_(issubclass(self.B.lower().dtype.type, np.str_)) + assert_array_equal(self.B.lower(), tgt) + + def test_lstrip(self): + tgt = [[b'abc ', b''], + [b'12345', b'MixedCase'], + [b'123 \t 345 \0 ', b'UPPER']] + assert_(issubclass(self.A.lstrip().dtype.type, np.bytes_)) + assert_array_equal(self.A.lstrip(), tgt) + + tgt = [[b' abc', b''], + [b'2345', b'ixedCase'], + [b'23 \t 345 \x00', b'UPPER']] + assert_array_equal(self.A.lstrip([b'1', b'M']), tgt) + + tgt = [['\u03a3 ', ''], + ['12345', 'MixedCase'], + ['123 \t 345 \0 ', 'UPPER']] + assert_(issubclass(self.B.lstrip().dtype.type, np.str_)) + assert_array_equal(self.B.lstrip(), tgt) + + def test_partition(self): + P = self.A.partition([b'3', b'M']) + tgt = [[(b' abc ', b'', b''), (b'', b'', b'')], + [(b'12', b'3', b'45'), (b'', b'M', b'ixedCase')], + [(b'12', b'3', b' \t 345 \0 '), (b'UPPER', b'', b'')]] + assert_(issubclass(P.dtype.type, np.bytes_)) + assert_array_equal(P, tgt) + + def test_replace(self): + R = self.A.replace([b'3', b'a'], + [b'##########', b'@']) + tgt = [[b' abc ', b''], + [b'12##########45', b'MixedC@se'], + [b'12########## \t ##########45 \x00 ', b'UPPER']] + assert_(issubclass(R.dtype.type, np.bytes_)) + assert_array_equal(R, tgt) + # Test special cases that should just return the input array, + # since replacements are not possible or do nothing. + S1 = self.A.replace(b'A very long byte string, longer than A', b'') + assert_array_equal(S1, self.A) + S2 = self.A.replace(b'', b'') + assert_array_equal(S2, self.A) + S3 = self.A.replace(b'3', b'3') + assert_array_equal(S3, self.A) + S4 = self.A.replace(b'3', b'', count=0) + assert_array_equal(S4, self.A) + + def test_replace_count_and_size(self): + a = np.array(['0123456789' * i for i in range(4)] + ).view(np.char.chararray) + r1 = a.replace('5', 'ABCDE') + assert r1.dtype.itemsize == (3*10 + 3*4) * 4 + assert_array_equal(r1, np.array(['01234ABCDE6789' * i + for i in range(4)])) + r2 = a.replace('5', 'ABCDE', count=1) + assert r2.dtype.itemsize == (3*10 + 4) * 4 + r3 = a.replace('5', 'ABCDE', count=0) + assert r3.dtype.itemsize == a.dtype.itemsize + assert_array_equal(r3, a) + # Negative values mean to replace all. + r4 = a.replace('5', 'ABCDE', count=-1) + assert r4.dtype.itemsize == (3*10 + 3*4) * 4 + assert_array_equal(r4, r1) + # We can do count on an element-by-element basis. + r5 = a.replace('5', 'ABCDE', count=[-1, -1, -1, 1]) + assert r5.dtype.itemsize == (3*10 + 4) * 4 + assert_array_equal(r5, np.array( + ['01234ABCDE6789' * i for i in range(3)] + + ['01234ABCDE6789' + '0123456789' * 2])) + + def test_replace_broadcasting(self): + a = np.array('0,0,0').view(np.char.chararray) + r1 = a.replace('0', '1', count=np.arange(3)) + assert r1.dtype == a.dtype + assert_array_equal(r1, np.array(['0,0,0', '1,0,0', '1,1,0'])) + r2 = a.replace('0', [['1'], ['2']], count=np.arange(1, 4)) + assert_array_equal(r2, np.array([['1,0,0', '1,1,0', '1,1,1'], + ['2,0,0', '2,2,0', '2,2,2']])) + r3 = a.replace(['0', '0,0', '0,0,0'], 'X') + assert_array_equal(r3, np.array(['X,X,X', 'X,0', 'X'])) + + def test_rjust(self): + assert_(issubclass(self.A.rjust(10).dtype.type, np.bytes_)) + + C = self.A.rjust([10, 20]) + assert_array_equal(np.char.str_len(C), [[10, 20], [10, 20], [12, 20]]) + + C = self.A.rjust(20, b'#') + assert_(np.all(C.startswith(b'#'))) + assert_array_equal(C.endswith(b'#'), + [[False, True], [False, False], [False, False]]) + + C = np.char.rjust(b'FOO', [[10, 20], [15, 8]]) + tgt = [[b' FOO', b' FOO'], + [b' FOO', b' FOO']] + assert_(issubclass(C.dtype.type, np.bytes_)) + assert_array_equal(C, tgt) + + def test_rpartition(self): + P = self.A.rpartition([b'3', b'M']) + tgt = [[(b'', b'', b' abc '), (b'', b'', b'')], + [(b'12', b'3', b'45'), (b'', b'M', b'ixedCase')], + [(b'123 \t ', b'3', b'45 \0 '), (b'', b'', b'UPPER')]] + assert_(issubclass(P.dtype.type, np.bytes_)) + assert_array_equal(P, tgt) + + def test_rsplit(self): + A = self.A.rsplit(b'3') + tgt = [[[b' abc '], [b'']], + [[b'12', b'45'], [b'MixedCase']], + [[b'12', b' \t ', b'45 \x00 '], [b'UPPER']]] + assert_(issubclass(A.dtype.type, np.object_)) + assert_equal(A.tolist(), tgt) + + def test_rstrip(self): + assert_(issubclass(self.A.rstrip().dtype.type, np.bytes_)) + + tgt = [[b' abc', b''], + [b'12345', b'MixedCase'], + [b'123 \t 345', b'UPPER']] + assert_array_equal(self.A.rstrip(), tgt) + + tgt = [[b' abc ', b''], + [b'1234', b'MixedCase'], + [b'123 \t 345 \x00', b'UPP'] + ] + assert_array_equal(self.A.rstrip([b'5', b'ER']), tgt) + + tgt = [[' \u03a3', ''], + ['12345', 'MixedCase'], + ['123 \t 345', 'UPPER']] + assert_(issubclass(self.B.rstrip().dtype.type, np.str_)) + assert_array_equal(self.B.rstrip(), tgt) + + def test_strip(self): + tgt = [[b'abc', b''], + [b'12345', b'MixedCase'], + [b'123 \t 345', b'UPPER']] + assert_(issubclass(self.A.strip().dtype.type, np.bytes_)) + assert_array_equal(self.A.strip(), tgt) + + tgt = [[b' abc ', b''], + [b'234', b'ixedCas'], + [b'23 \t 345 \x00', b'UPP']] + assert_array_equal(self.A.strip([b'15', b'EReM']), tgt) + + tgt = [['\u03a3', ''], + ['12345', 'MixedCase'], + ['123 \t 345', 'UPPER']] + assert_(issubclass(self.B.strip().dtype.type, np.str_)) + assert_array_equal(self.B.strip(), tgt) + + def test_split(self): + A = self.A.split(b'3') + tgt = [ + [[b' abc '], [b'']], + [[b'12', b'45'], [b'MixedCase']], + [[b'12', b' \t ', b'45 \x00 '], [b'UPPER']]] + assert_(issubclass(A.dtype.type, np.object_)) + assert_equal(A.tolist(), tgt) + + def test_splitlines(self): + A = np.char.array(['abc\nfds\nwer']).splitlines() + assert_(issubclass(A.dtype.type, np.object_)) + assert_(A.shape == (1,)) + assert_(len(A[0]) == 3) + + def test_swapcase(self): + tgt = [[b' ABC ', b''], + [b'12345', b'mIXEDcASE'], + [b'123 \t 345 \0 ', b'upper']] + assert_(issubclass(self.A.swapcase().dtype.type, np.bytes_)) + assert_array_equal(self.A.swapcase(), tgt) + + tgt = [[' \u03c3 ', ''], + ['12345', 'mIXEDcASE'], + ['123 \t 345 \0 ', 'upper']] + assert_(issubclass(self.B.swapcase().dtype.type, np.str_)) + assert_array_equal(self.B.swapcase(), tgt) + + def test_title(self): + tgt = [[b' Abc ', b''], + [b'12345', b'Mixedcase'], + [b'123 \t 345 \0 ', b'Upper']] + assert_(issubclass(self.A.title().dtype.type, np.bytes_)) + assert_array_equal(self.A.title(), tgt) + + tgt = [[' \u03a3 ', ''], + ['12345', 'Mixedcase'], + ['123 \t 345 \0 ', 'Upper']] + assert_(issubclass(self.B.title().dtype.type, np.str_)) + assert_array_equal(self.B.title(), tgt) + + def test_upper(self): + tgt = [[b' ABC ', b''], + [b'12345', b'MIXEDCASE'], + [b'123 \t 345 \0 ', b'UPPER']] + assert_(issubclass(self.A.upper().dtype.type, np.bytes_)) + assert_array_equal(self.A.upper(), tgt) + + tgt = [[' \u03a3 ', ''], + ['12345', 'MIXEDCASE'], + ['123 \t 345 \0 ', 'UPPER']] + assert_(issubclass(self.B.upper().dtype.type, np.str_)) + assert_array_equal(self.B.upper(), tgt) + + def test_isnumeric(self): + + def fail(): + self.A.isnumeric() + + assert_raises(TypeError, fail) + assert_(issubclass(self.B.isnumeric().dtype.type, np.bool)) + assert_array_equal(self.B.isnumeric(), [ + [False, False], [True, False], [False, False]]) + + def test_isdecimal(self): + + def fail(): + self.A.isdecimal() + + assert_raises(TypeError, fail) + assert_(issubclass(self.B.isdecimal().dtype.type, np.bool)) + assert_array_equal(self.B.isdecimal(), [ + [False, False], [True, False], [False, False]]) + + +class TestOperations: + def setup_method(self): + self.A = np.array([['abc', '123'], + ['789', 'xyz']]).view(np.char.chararray) + self.B = np.array([['efg', '456'], + ['051', 'tuv']]).view(np.char.chararray) + + def test_add(self): + AB = np.array([['abcefg', '123456'], + ['789051', 'xyztuv']]).view(np.char.chararray) + assert_array_equal(AB, (self.A + self.B)) + assert_(len((self.A + self.B)[0][0]) == 6) + + def test_radd(self): + QA = np.array([['qabc', 'q123'], + ['q789', 'qxyz']]).view(np.char.chararray) + assert_array_equal(QA, ('q' + self.A)) + + def test_mul(self): + A = self.A + for r in (2, 3, 5, 7, 197): + Ar = np.array([[A[0, 0]*r, A[0, 1]*r], + [A[1, 0]*r, A[1, 1]*r]]).view(np.char.chararray) + + assert_array_equal(Ar, (self.A * r)) + + for ob in [object(), 'qrs']: + with assert_raises_regex(ValueError, + 'Can only multiply by integers'): + A*ob + + def test_rmul(self): + A = self.A + for r in (2, 3, 5, 7, 197): + Ar = np.array([[A[0, 0]*r, A[0, 1]*r], + [A[1, 0]*r, A[1, 1]*r]]).view(np.char.chararray) + assert_array_equal(Ar, (r * self.A)) + + for ob in [object(), 'qrs']: + with assert_raises_regex(ValueError, + 'Can only multiply by integers'): + ob * A + + def test_mod(self): + """Ticket #856""" + F = np.array([['%d', '%f'], ['%s', '%r']]).view(np.char.chararray) + C = np.array([[3, 7], [19, 1]], dtype=np.int64) + FC = np.array([['3', '7.000000'], + ['19', 'np.int64(1)']]).view(np.char.chararray) + assert_array_equal(FC, F % C) + + A = np.array([['%.3f', '%d'], ['%s', '%r']]).view(np.char.chararray) + A1 = np.array([['1.000', '1'], + ['1', repr(np.array(1)[()])]]).view(np.char.chararray) + assert_array_equal(A1, (A % 1)) + + A2 = np.array([['1.000', '2'], + ['3', repr(np.array(4)[()])]]).view(np.char.chararray) + assert_array_equal(A2, (A % [[1, 2], [3, 4]])) + + def test_rmod(self): + assert_(("%s" % self.A) == str(self.A)) + assert_(("%r" % self.A) == repr(self.A)) + + for ob in [42, object()]: + with assert_raises_regex( + TypeError, "unsupported operand type.* and 'chararray'"): + ob % self.A + + def test_slice(self): + """Regression test for https://github.com/numpy/numpy/issues/5982""" + + arr = np.array([['abc ', 'def '], ['geh ', 'ijk ']], + dtype='S4').view(np.char.chararray) + sl1 = arr[:] + assert_array_equal(sl1, arr) + assert_(sl1.base is arr) + assert_(sl1.base.base is arr.base) + + sl2 = arr[:, :] + assert_array_equal(sl2, arr) + assert_(sl2.base is arr) + assert_(sl2.base.base is arr.base) + + assert_(arr[0, 0] == b'abc') + + @pytest.mark.parametrize('data', [['plate', ' ', 'shrimp'], + [b'retro', b' ', b'encabulator']]) + def test_getitem_length_zero_item(self, data): + # Regression test for gh-26375. + a = np.char.array(data) + # a.dtype.type() will be an empty string or bytes instance. + # The equality test will fail if a[1] has the wrong type + # or does not have length 0. + assert_equal(a[1], a.dtype.type()) + + +class TestMethodsEmptyArray: + def setup_method(self): + self.U = np.array([], dtype='U') + self.S = np.array([], dtype='S') + + def test_encode(self): + res = np.char.encode(self.U) + assert_array_equal(res, []) + assert_(res.dtype.char == 'S') + + def test_decode(self): + res = np.char.decode(self.S) + assert_array_equal(res, []) + assert_(res.dtype.char == 'U') + + def test_decode_with_reshape(self): + res = np.char.decode(self.S.reshape((1, 0, 1))) + assert_(res.shape == (1, 0, 1)) + + +class TestMethodsScalarValues: + def test_mod(self): + A = np.array([[' abc ', ''], + ['12345', 'MixedCase'], + ['123 \t 345 \0 ', 'UPPER']], dtype='S') + tgt = [[b'123 abc ', b'123'], + [b'12312345', b'123MixedCase'], + [b'123123 \t 345 \0 ', b'123UPPER']] + assert_array_equal(np.char.mod(b"123%s", A), tgt) + + def test_decode(self): + bytestring = b'\x81\xc1\x81\xc1\x81\xc1' + assert_equal(np.char.decode(bytestring, encoding='cp037'), + 'aAaAaA') + + def test_encode(self): + unicode = 'aAaAaA' + assert_equal(np.char.encode(unicode, encoding='cp037'), + b'\x81\xc1\x81\xc1\x81\xc1') + + def test_expandtabs(self): + s = "\tone level of indentation\n\t\ttwo levels of indentation" + assert_equal( + np.char.expandtabs(s, tabsize=2), + " one level of indentation\n two levels of indentation" + ) + + def test_join(self): + seps = np.array(['-', '_']) + assert_array_equal(np.char.join(seps, 'hello'), + ['h-e-l-l-o', 'h_e_l_l_o']) + + def test_partition(self): + assert_equal(np.char.partition('This string', ' '), + ['This', ' ', 'string']) + + def test_rpartition(self): + assert_equal(np.char.rpartition('This string here', ' '), + ['This string', ' ', 'here']) + + def test_replace(self): + assert_equal(np.char.replace('Python is good', 'good', 'great'), + 'Python is great') + + +def test_empty_indexing(): + """Regression test for ticket 1948.""" + # Check that indexing a chararray with an empty list/array returns an + # empty chararray instead of a chararray with a single empty string in it. + s = np.char.chararray((4,)) + assert_(s[[]].size == 0) diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/test_deprecations.py b/venv/lib/python3.12/site-packages/numpy/_core/tests/test_deprecations.py new file mode 100644 index 00000000..33431fae --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/tests/test_deprecations.py @@ -0,0 +1,750 @@ +""" +Tests related to deprecation warnings. Also a convenient place +to document how deprecations should eventually be turned into errors. + +""" +import datetime +import operator +import warnings +import pytest +import tempfile +import re +import sys + +import numpy as np +from numpy.testing import ( + assert_raises, assert_warns, assert_, assert_array_equal, SkipTest, + KnownFailureException, break_cycles, temppath + ) + +from numpy._core._multiarray_tests import fromstring_null_term_c_api + +try: + import pytz + _has_pytz = True +except ImportError: + _has_pytz = False + + +class _DeprecationTestCase: + # Just as warning: warnings uses re.match, so the start of this message + # must match. + message = '' + warning_cls = DeprecationWarning + + def setup_method(self): + self.warn_ctx = warnings.catch_warnings(record=True) + self.log = self.warn_ctx.__enter__() + + # Do *not* ignore other DeprecationWarnings. Ignoring warnings + # can give very confusing results because of + # https://bugs.python.org/issue4180 and it is probably simplest to + # try to keep the tests cleanly giving only the right warning type. + # (While checking them set to "error" those are ignored anyway) + # We still have them show up, because otherwise they would be raised + warnings.filterwarnings("always", category=self.warning_cls) + warnings.filterwarnings("always", message=self.message, + category=self.warning_cls) + + def teardown_method(self): + self.warn_ctx.__exit__() + + def assert_deprecated(self, function, num=1, ignore_others=False, + function_fails=False, + exceptions=np._NoValue, + args=(), kwargs={}): + """Test if DeprecationWarnings are given and raised. + + This first checks if the function when called gives `num` + DeprecationWarnings, after that it tries to raise these + DeprecationWarnings and compares them with `exceptions`. + The exceptions can be different for cases where this code path + is simply not anticipated and the exception is replaced. + + Parameters + ---------- + function : callable + The function to test + num : int + Number of DeprecationWarnings to expect. This should normally be 1. + ignore_others : bool + Whether warnings of the wrong type should be ignored (note that + the message is not checked) + function_fails : bool + If the function would normally fail, setting this will check for + warnings inside a try/except block. + exceptions : Exception or tuple of Exceptions + Exception to expect when turning the warnings into an error. + The default checks for DeprecationWarnings. If exceptions is + empty the function is expected to run successfully. + args : tuple + Arguments for `function` + kwargs : dict + Keyword arguments for `function` + """ + __tracebackhide__ = True # Hide traceback for py.test + + # reset the log + self.log[:] = [] + + if exceptions is np._NoValue: + exceptions = (self.warning_cls,) + + try: + function(*args, **kwargs) + except (Exception if function_fails else tuple()): + pass + + # just in case, clear the registry + num_found = 0 + for warning in self.log: + if warning.category is self.warning_cls: + num_found += 1 + elif not ignore_others: + raise AssertionError( + "expected %s but got: %s" % + (self.warning_cls.__name__, warning.category)) + if num is not None and num_found != num: + msg = "%i warnings found but %i expected." % (len(self.log), num) + lst = [str(w) for w in self.log] + raise AssertionError("\n".join([msg] + lst)) + + with warnings.catch_warnings(): + warnings.filterwarnings("error", message=self.message, + category=self.warning_cls) + try: + function(*args, **kwargs) + if exceptions != tuple(): + raise AssertionError( + "No error raised during function call") + except exceptions: + if exceptions == tuple(): + raise AssertionError( + "Error raised during function call") + + def assert_not_deprecated(self, function, args=(), kwargs={}): + """Test that warnings are not raised. + + This is just a shorthand for: + + self.assert_deprecated(function, num=0, ignore_others=True, + exceptions=tuple(), args=args, kwargs=kwargs) + """ + self.assert_deprecated(function, num=0, ignore_others=True, + exceptions=tuple(), args=args, kwargs=kwargs) + + +class _VisibleDeprecationTestCase(_DeprecationTestCase): + warning_cls = np.exceptions.VisibleDeprecationWarning + + +class TestDTypeAttributeIsDTypeDeprecation(_DeprecationTestCase): + # Deprecated 2021-01-05, NumPy 1.21 + message = r".*`.dtype` attribute" + + def test_deprecation_dtype_attribute_is_dtype(self): + class dt: + dtype = "f8" + + class vdt(np.void): + dtype = "f,f" + + self.assert_deprecated(lambda: np.dtype(dt)) + self.assert_deprecated(lambda: np.dtype(dt())) + self.assert_deprecated(lambda: np.dtype(vdt)) + self.assert_deprecated(lambda: np.dtype(vdt(1))) + + +class TestTestDeprecated: + def test_assert_deprecated(self): + test_case_instance = _DeprecationTestCase() + test_case_instance.setup_method() + assert_raises(AssertionError, + test_case_instance.assert_deprecated, + lambda: None) + + def foo(): + warnings.warn("foo", category=DeprecationWarning, stacklevel=2) + + test_case_instance.assert_deprecated(foo) + test_case_instance.teardown_method() + + +class TestNonNumericConjugate(_DeprecationTestCase): + """ + Deprecate no-op behavior of ndarray.conjugate on non-numeric dtypes, + which conflicts with the error behavior of np.conjugate. + """ + def test_conjugate(self): + for a in np.array(5), np.array(5j): + self.assert_not_deprecated(a.conjugate) + for a in (np.array('s'), np.array('2016', 'M'), + np.array((1, 2), [('a', int), ('b', int)])): + self.assert_deprecated(a.conjugate) + + +class TestDatetimeEvent(_DeprecationTestCase): + # 2017-08-11, 1.14.0 + def test_3_tuple(self): + for cls in (np.datetime64, np.timedelta64): + # two valid uses - (unit, num) and (unit, num, den, None) + self.assert_not_deprecated(cls, args=(1, ('ms', 2))) + self.assert_not_deprecated(cls, args=(1, ('ms', 2, 1, None))) + + # trying to use the event argument, removed in 1.7.0, is deprecated + # it used to be a uint8 + self.assert_deprecated(cls, args=(1, ('ms', 2, 'event'))) + self.assert_deprecated(cls, args=(1, ('ms', 2, 63))) + self.assert_deprecated(cls, args=(1, ('ms', 2, 1, 'event'))) + self.assert_deprecated(cls, args=(1, ('ms', 2, 1, 63))) + + +class TestTruthTestingEmptyArrays(_DeprecationTestCase): + # 2017-09-25, 1.14.0 + message = '.*truth value of an empty array is ambiguous.*' + + def test_1d(self): + self.assert_deprecated(bool, args=(np.array([]),)) + + def test_2d(self): + self.assert_deprecated(bool, args=(np.zeros((1, 0)),)) + self.assert_deprecated(bool, args=(np.zeros((0, 1)),)) + self.assert_deprecated(bool, args=(np.zeros((0, 0)),)) + + +class TestBincount(_DeprecationTestCase): + # 2017-06-01, 1.14.0 + def test_bincount_minlength(self): + self.assert_deprecated(lambda: np.bincount([1, 2, 3], minlength=None)) + + # 2024-07-29, 2.1.0 + @pytest.mark.parametrize('badlist', [[0.5, 1.2, 1.5], + ['0', '1', '1']]) + def test_bincount_bad_list(self, badlist): + self.assert_deprecated(lambda: np.bincount(badlist)) + + +class TestGeneratorSum(_DeprecationTestCase): + # 2018-02-25, 1.15.0 + def test_generator_sum(self): + self.assert_deprecated(np.sum, args=((i for i in range(5)),)) + + +class TestFromstring(_DeprecationTestCase): + # 2017-10-19, 1.14 + def test_fromstring(self): + self.assert_deprecated(np.fromstring, args=('\x00'*80,)) + + +class TestFromStringAndFileInvalidData(_DeprecationTestCase): + # 2019-06-08, 1.17.0 + # Tests should be moved to real tests when deprecation is done. + message = "string or file could not be read to its end" + + @pytest.mark.parametrize("invalid_str", [",invalid_data", "invalid_sep"]) + def test_deprecate_unparsable_data_file(self, invalid_str): + x = np.array([1.51, 2, 3.51, 4], dtype=float) + + with tempfile.TemporaryFile(mode="w") as f: + x.tofile(f, sep=',', format='%.2f') + f.write(invalid_str) + + f.seek(0) + self.assert_deprecated(lambda: np.fromfile(f, sep=",")) + f.seek(0) + self.assert_deprecated(lambda: np.fromfile(f, sep=",", count=5)) + # Should not raise: + with warnings.catch_warnings(): + warnings.simplefilter("error", DeprecationWarning) + f.seek(0) + res = np.fromfile(f, sep=",", count=4) + assert_array_equal(res, x) + + @pytest.mark.parametrize("invalid_str", [",invalid_data", "invalid_sep"]) + def test_deprecate_unparsable_string(self, invalid_str): + x = np.array([1.51, 2, 3.51, 4], dtype=float) + x_str = "1.51,2,3.51,4{}".format(invalid_str) + + self.assert_deprecated(lambda: np.fromstring(x_str, sep=",")) + self.assert_deprecated(lambda: np.fromstring(x_str, sep=",", count=5)) + + # The C-level API can use not fixed size, but 0 terminated strings, + # so test that as well: + bytestr = x_str.encode("ascii") + self.assert_deprecated(lambda: fromstring_null_term_c_api(bytestr)) + + with assert_warns(DeprecationWarning): + # this is slightly strange, in that fromstring leaves data + # potentially uninitialized (would be good to error when all is + # read, but count is larger then actual data maybe). + res = np.fromstring(x_str, sep=",", count=5) + assert_array_equal(res[:-1], x) + + with warnings.catch_warnings(): + warnings.simplefilter("error", DeprecationWarning) + + # Should not raise: + res = np.fromstring(x_str, sep=",", count=4) + assert_array_equal(res, x) + + +class TestToString(_DeprecationTestCase): + # 2020-03-06 1.19.0 + message = re.escape("tostring() is deprecated. Use tobytes() instead.") + + def test_tostring(self): + arr = np.array(list(b"test\xFF"), dtype=np.uint8) + self.assert_deprecated(arr.tostring) + + def test_tostring_matches_tobytes(self): + arr = np.array(list(b"test\xFF"), dtype=np.uint8) + b = arr.tobytes() + with assert_warns(DeprecationWarning): + s = arr.tostring() + assert s == b + + +class TestDTypeCoercion(_DeprecationTestCase): + # 2020-02-06 1.19.0 + message = "Converting .* to a dtype .*is deprecated" + deprecated_types = [ + # The builtin scalar super types: + np.generic, np.flexible, np.number, + np.inexact, np.floating, np.complexfloating, + np.integer, np.unsignedinteger, np.signedinteger, + # character is a deprecated S1 special case: + np.character, + ] + + def test_dtype_coercion(self): + for scalar_type in self.deprecated_types: + self.assert_deprecated(np.dtype, args=(scalar_type,)) + + def test_array_construction(self): + for scalar_type in self.deprecated_types: + self.assert_deprecated(np.array, args=([], scalar_type,)) + + def test_not_deprecated(self): + # All specific types are not deprecated: + for group in np._core.sctypes.values(): + for scalar_type in group: + self.assert_not_deprecated(np.dtype, args=(scalar_type,)) + + for scalar_type in [type, dict, list, tuple]: + # Typical python types are coerced to object currently: + self.assert_not_deprecated(np.dtype, args=(scalar_type,)) + + +class BuiltInRoundComplexDType(_DeprecationTestCase): + # 2020-03-31 1.19.0 + deprecated_types = [np.csingle, np.cdouble, np.clongdouble] + not_deprecated_types = [ + np.int8, np.int16, np.int32, np.int64, + np.uint8, np.uint16, np.uint32, np.uint64, + np.float16, np.float32, np.float64, + ] + + def test_deprecated(self): + for scalar_type in self.deprecated_types: + scalar = scalar_type(0) + self.assert_deprecated(round, args=(scalar,)) + self.assert_deprecated(round, args=(scalar, 0)) + self.assert_deprecated(round, args=(scalar,), kwargs={'ndigits': 0}) + + def test_not_deprecated(self): + for scalar_type in self.not_deprecated_types: + scalar = scalar_type(0) + self.assert_not_deprecated(round, args=(scalar,)) + self.assert_not_deprecated(round, args=(scalar, 0)) + self.assert_not_deprecated(round, args=(scalar,), kwargs={'ndigits': 0}) + + +class TestIncorrectAdvancedIndexWithEmptyResult(_DeprecationTestCase): + # 2020-05-27, NumPy 1.20.0 + message = "Out of bound index found. This was previously ignored.*" + + @pytest.mark.parametrize("index", [([3, 0],), ([0, 0], [3, 0])]) + def test_empty_subspace(self, index): + # Test for both a single and two/multiple advanced indices. These + # This will raise an IndexError in the future. + arr = np.ones((2, 2, 0)) + self.assert_deprecated(arr.__getitem__, args=(index,)) + self.assert_deprecated(arr.__setitem__, args=(index, 0.)) + + # for this array, the subspace is only empty after applying the slice + arr2 = np.ones((2, 2, 1)) + index2 = (slice(0, 0),) + index + self.assert_deprecated(arr2.__getitem__, args=(index2,)) + self.assert_deprecated(arr2.__setitem__, args=(index2, 0.)) + + def test_empty_index_broadcast_not_deprecated(self): + arr = np.ones((2, 2, 2)) + + index = ([[3], [2]], []) # broadcast to an empty result. + self.assert_not_deprecated(arr.__getitem__, args=(index,)) + self.assert_not_deprecated(arr.__setitem__, + args=(index, np.empty((2, 0, 2)))) + + +class TestNonExactMatchDeprecation(_DeprecationTestCase): + # 2020-04-22 + def test_non_exact_match(self): + arr = np.array([[3, 6, 6], [4, 5, 1]]) + # misspelt mode check + self.assert_deprecated(lambda: np.ravel_multi_index(arr, (7, 6), mode='Cilp')) + # using completely different word with first character as R + self.assert_deprecated(lambda: np.searchsorted(arr[0], 4, side='Random')) + + +class TestMatrixInOuter(_DeprecationTestCase): + # 2020-05-13 NumPy 1.20.0 + message = (r"add.outer\(\) was passed a numpy matrix as " + r"(first|second) argument.") + + def test_deprecated(self): + arr = np.array([1, 2, 3]) + m = np.array([1, 2, 3]).view(np.matrix) + self.assert_deprecated(np.add.outer, args=(m, m), num=2) + self.assert_deprecated(np.add.outer, args=(arr, m)) + self.assert_deprecated(np.add.outer, args=(m, arr)) + self.assert_not_deprecated(np.add.outer, args=(arr, arr)) + + +class FlatteningConcatenateUnsafeCast(_DeprecationTestCase): + # NumPy 1.20, 2020-09-03 + message = "concatenate with `axis=None` will use same-kind casting" + + def test_deprecated(self): + self.assert_deprecated(np.concatenate, + args=(([0.], [1.]),), + kwargs=dict(axis=None, out=np.empty(2, dtype=np.int64))) + + def test_not_deprecated(self): + self.assert_not_deprecated(np.concatenate, + args=(([0.], [1.]),), + kwargs={'axis': None, 'out': np.empty(2, dtype=np.int64), + 'casting': "unsafe"}) + + with assert_raises(TypeError): + # Tests should notice if the deprecation warning is given first... + np.concatenate(([0.], [1.]), out=np.empty(2, dtype=np.int64), + casting="same_kind") + + +class TestDeprecatedUnpickleObjectScalar(_DeprecationTestCase): + # Deprecated 2020-11-24, NumPy 1.20 + """ + Technically, it should be impossible to create numpy object scalars, + but there was an unpickle path that would in theory allow it. That + path is invalid and must lead to the warning. + """ + message = "Unpickling a scalar with object dtype is deprecated." + + def test_deprecated(self): + ctor = np._core.multiarray.scalar + self.assert_deprecated(lambda: ctor(np.dtype("O"), 1)) + + +class TestSingleElementSignature(_DeprecationTestCase): + # Deprecated 2021-04-01, NumPy 1.21 + message = r"The use of a length 1" + + def test_deprecated(self): + self.assert_deprecated(lambda: np.add(1, 2, signature="d")) + self.assert_deprecated(lambda: np.add(1, 2, sig=(np.dtype("l"),))) + + +class TestCtypesGetter(_DeprecationTestCase): + # Deprecated 2021-05-18, Numpy 1.21.0 + warning_cls = DeprecationWarning + ctypes = np.array([1]).ctypes + + @pytest.mark.parametrize( + "name", ["get_data", "get_shape", "get_strides", "get_as_parameter"] + ) + def test_deprecated(self, name: str) -> None: + func = getattr(self.ctypes, name) + self.assert_deprecated(lambda: func()) + + @pytest.mark.parametrize( + "name", ["data", "shape", "strides", "_as_parameter_"] + ) + def test_not_deprecated(self, name: str) -> None: + self.assert_not_deprecated(lambda: getattr(self.ctypes, name)) + + +PARTITION_DICT = { + "partition method": np.arange(10).partition, + "argpartition method": np.arange(10).argpartition, + "partition function": lambda kth: np.partition(np.arange(10), kth), + "argpartition function": lambda kth: np.argpartition(np.arange(10), kth), +} + + +@pytest.mark.parametrize("func", PARTITION_DICT.values(), ids=PARTITION_DICT) +class TestPartitionBoolIndex(_DeprecationTestCase): + # Deprecated 2021-09-29, NumPy 1.22 + warning_cls = DeprecationWarning + message = "Passing booleans as partition index is deprecated" + + def test_deprecated(self, func): + self.assert_deprecated(lambda: func(True)) + self.assert_deprecated(lambda: func([False, True])) + + def test_not_deprecated(self, func): + self.assert_not_deprecated(lambda: func(1)) + self.assert_not_deprecated(lambda: func([0, 1])) + + +class TestMachAr(_DeprecationTestCase): + # Deprecated 2022-11-22, NumPy 1.25 + warning_cls = DeprecationWarning + + def test_deprecated_module(self): + self.assert_deprecated(lambda: getattr(np._core, "MachAr")) + + +class TestQuantileInterpolationDeprecation(_DeprecationTestCase): + # Deprecated 2021-11-08, NumPy 1.22 + @pytest.mark.parametrize("func", + [np.percentile, np.quantile, np.nanpercentile, np.nanquantile]) + def test_deprecated(self, func): + self.assert_deprecated( + lambda: func([0., 1.], 0., interpolation="linear")) + self.assert_deprecated( + lambda: func([0., 1.], 0., interpolation="nearest")) + + @pytest.mark.parametrize("func", + [np.percentile, np.quantile, np.nanpercentile, np.nanquantile]) + def test_both_passed(self, func): + with warnings.catch_warnings(): + # catch the DeprecationWarning so that it does not raise: + warnings.simplefilter("always", DeprecationWarning) + with pytest.raises(TypeError): + func([0., 1.], 0., interpolation="nearest", method="nearest") + + +class TestArrayFinalizeNone(_DeprecationTestCase): + message = "Setting __array_finalize__ = None" + + def test_use_none_is_deprecated(self): + # Deprecated way that ndarray itself showed nothing needs finalizing. + class NoFinalize(np.ndarray): + __array_finalize__ = None + + self.assert_deprecated(lambda: np.array(1).view(NoFinalize)) + + +class TestLoadtxtParseIntsViaFloat(_DeprecationTestCase): + # Deprecated 2022-07-03, NumPy 1.23 + # This test can be removed without replacement after the deprecation. + # The tests: + # * numpy/lib/tests/test_loadtxt.py::test_integer_signs + # * lib/tests/test_loadtxt.py::test_implicit_cast_float_to_int_fails + # Have a warning filter that needs to be removed. + message = r"loadtxt\(\): Parsing an integer via a float is deprecated.*" + + @pytest.mark.parametrize("dtype", np.typecodes["AllInteger"]) + def test_deprecated_warning(self, dtype): + with pytest.warns(DeprecationWarning, match=self.message): + np.loadtxt(["10.5"], dtype=dtype) + + @pytest.mark.parametrize("dtype", np.typecodes["AllInteger"]) + def test_deprecated_raised(self, dtype): + # The DeprecationWarning is chained when raised, so test manually: + with warnings.catch_warnings(): + warnings.simplefilter("error", DeprecationWarning) + try: + np.loadtxt(["10.5"], dtype=dtype) + except ValueError as e: + assert isinstance(e.__cause__, DeprecationWarning) + + +class TestScalarConversion(_DeprecationTestCase): + # 2023-01-02, 1.25.0 + def test_float_conversion(self): + self.assert_deprecated(float, args=(np.array([3.14]),)) + + def test_behaviour(self): + b = np.array([[3.14]]) + c = np.zeros(5) + with pytest.warns(DeprecationWarning): + c[0] = b + + +class TestPyIntConversion(_DeprecationTestCase): + message = r".*stop allowing conversion of out-of-bound.*" + + @pytest.mark.parametrize("dtype", np.typecodes["AllInteger"]) + def test_deprecated_scalar(self, dtype): + dtype = np.dtype(dtype) + info = np.iinfo(dtype) + + # Cover the most common creation paths (all end up in the + # same place): + def scalar(value, dtype): + dtype.type(value) + + def assign(value, dtype): + arr = np.array([0, 0, 0], dtype=dtype) + arr[2] = value + + def create(value, dtype): + np.array([value], dtype=dtype) + + for creation_func in [scalar, assign, create]: + try: + self.assert_deprecated( + lambda: creation_func(info.min - 1, dtype)) + except OverflowError: + pass # OverflowErrors always happened also before and are OK. + + try: + self.assert_deprecated( + lambda: creation_func(info.max + 1, dtype)) + except OverflowError: + pass # OverflowErrors always happened also before and are OK. + + +@pytest.mark.parametrize("name", ["str", "bytes", "object"]) +def test_future_scalar_attributes(name): + # FutureWarning added 2022-11-17, NumPy 1.24, + assert name not in dir(np) # we may want to not add them + with pytest.warns(FutureWarning, + match=f"In the future .*{name}"): + assert not hasattr(np, name) + + # Unfortunately, they are currently still valid via `np.dtype()` + np.dtype(name) + name in np._core.sctypeDict + + +# Ignore the above future attribute warning for this test. +@pytest.mark.filterwarnings("ignore:In the future:FutureWarning") +class TestRemovedGlobals: + # Removed 2023-01-12, NumPy 1.24.0 + # Not a deprecation, but the large error was added to aid those who missed + # the previous deprecation, and should be removed similarly to one + # (or faster). + @pytest.mark.parametrize("name", + ["object", "float", "complex", "str", "int"]) + def test_attributeerror_includes_info(self, name): + msg = f".*\n`np.{name}` was a deprecated alias for the builtin" + with pytest.raises(AttributeError, match=msg): + getattr(np, name) + + +class TestDeprecatedFinfo(_DeprecationTestCase): + # Deprecated in NumPy 1.25, 2023-01-16 + def test_deprecated_none(self): + self.assert_deprecated(np.finfo, args=(None,)) + + +class TestMathAlias(_DeprecationTestCase): + def test_deprecated_np_lib_math(self): + self.assert_deprecated(lambda: np.lib.math) + + +class TestLibImports(_DeprecationTestCase): + # Deprecated in Numpy 1.26.0, 2023-09 + def test_lib_functions_deprecation_call(self): + from numpy.lib._utils_impl import safe_eval + from numpy.lib._npyio_impl import recfromcsv, recfromtxt + from numpy.lib._function_base_impl import disp + from numpy.lib._shape_base_impl import get_array_wrap + from numpy._core.numerictypes import maximum_sctype + from numpy.lib.tests.test_io import TextIO + from numpy import in1d, row_stack, trapz + + self.assert_deprecated(lambda: safe_eval("None")) + + data_gen = lambda: TextIO('A,B\n0,1\n2,3') + kwargs = dict(delimiter=",", missing_values="N/A", names=True) + self.assert_deprecated(lambda: recfromcsv(data_gen())) + self.assert_deprecated(lambda: recfromtxt(data_gen(), **kwargs)) + + self.assert_deprecated(lambda: disp("test")) + self.assert_deprecated(lambda: get_array_wrap()) + self.assert_deprecated(lambda: maximum_sctype(int)) + + self.assert_deprecated(lambda: in1d([1], [1])) + self.assert_deprecated(lambda: row_stack([[]])) + self.assert_deprecated(lambda: trapz([1], [1])) + self.assert_deprecated(lambda: np.chararray) + + +class TestDeprecatedDTypeAliases(_DeprecationTestCase): + + def _check_for_warning(self, func): + with warnings.catch_warnings(record=True) as caught_warnings: + func() + assert len(caught_warnings) == 1 + w = caught_warnings[0] + assert w.category is DeprecationWarning + assert "alias 'a' was deprecated in NumPy 2.0" in str(w.message) + + def test_a_dtype_alias(self): + for dtype in ["a", "a10"]: + f = lambda: np.dtype(dtype) + self._check_for_warning(f) + self.assert_deprecated(f) + f = lambda: np.array(["hello", "world"]).astype("a10") + self._check_for_warning(f) + self.assert_deprecated(f) + + +class TestDeprecatedArrayWrap(_DeprecationTestCase): + message = "__array_wrap__.*" + + def test_deprecated(self): + class Test1: + def __array__(self, dtype=None, copy=None): + return np.arange(4) + + def __array_wrap__(self, arr, context=None): + self.called = True + return 'pass context' + + class Test2(Test1): + def __array_wrap__(self, arr): + self.called = True + return 'pass' + + test1 = Test1() + test2 = Test2() + self.assert_deprecated(lambda: np.negative(test1)) + assert test1.called + self.assert_deprecated(lambda: np.negative(test2)) + assert test2.called + + + +class TestDeprecatedDTypeParenthesizedRepeatCount(_DeprecationTestCase): + message = "Passing in a parenthesized single number" + + @pytest.mark.parametrize("string", ["(2)i,", "(3)3S,", "f,(2)f"]) + def test_parenthesized_repeat_count(self, string): + self.assert_deprecated(np.dtype, args=(string,)) + + +class TestDeprecatedSaveFixImports(_DeprecationTestCase): + # Deprecated in Numpy 2.1, 2024-05 + message = "The 'fix_imports' flag is deprecated and has no effect." + + def test_deprecated(self): + with temppath(suffix='.npy') as path: + sample_args = (path, np.array(np.zeros((1024, 10)))) + self.assert_not_deprecated(np.save, args=sample_args) + self.assert_deprecated(np.save, args=sample_args, + kwargs={'fix_imports': True}) + self.assert_deprecated(np.save, args=sample_args, + kwargs={'fix_imports': False}) + for allow_pickle in [True, False]: + self.assert_not_deprecated(np.save, args=sample_args, + kwargs={'allow_pickle': allow_pickle}) + self.assert_deprecated(np.save, args=sample_args, + kwargs={'allow_pickle': allow_pickle, + 'fix_imports': True}) + self.assert_deprecated(np.save, args=sample_args, + kwargs={'allow_pickle': allow_pickle, + 'fix_imports': False}) diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/test_dlpack.py b/venv/lib/python3.12/site-packages/numpy/_core/tests/test_dlpack.py new file mode 100644 index 00000000..d9205912 --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/tests/test_dlpack.py @@ -0,0 +1,178 @@ +import sys +import pytest + +import numpy as np +from numpy.testing import assert_array_equal, IS_PYPY + + +def new_and_old_dlpack(): + yield np.arange(5) + + class OldDLPack(np.ndarray): + # Support only the "old" version + def __dlpack__(self, stream=None): + return super().__dlpack__(stream=None) + + yield np.arange(5).view(OldDLPack) + + +class TestDLPack: + @pytest.mark.skipif(IS_PYPY, reason="PyPy can't get refcounts.") + @pytest.mark.parametrize("max_version", [(0, 0), None, (1, 0), (100, 3)]) + def test_dunder_dlpack_refcount(self, max_version): + x = np.arange(5) + y = x.__dlpack__(max_version=max_version) + assert sys.getrefcount(x) == 3 + del y + assert sys.getrefcount(x) == 2 + + def test_dunder_dlpack_stream(self): + x = np.arange(5) + x.__dlpack__(stream=None) + + with pytest.raises(RuntimeError): + x.__dlpack__(stream=1) + + def test_dunder_dlpack_copy(self): + # Checks the argument parsing of __dlpack__ explicitly. + # Honoring the flag is tested in the from_dlpack round-tripping test. + x = np.arange(5) + x.__dlpack__(copy=True) + x.__dlpack__(copy=None) + x.__dlpack__(copy=False) + + with pytest.raises(ValueError): + # NOTE: The copy converter should be stricter, but not just here. + x.__dlpack__(copy=np.array([1, 2, 3])) + + def test_strides_not_multiple_of_itemsize(self): + dt = np.dtype([('int', np.int32), ('char', np.int8)]) + y = np.zeros((5,), dtype=dt) + z = y['int'] + + with pytest.raises(BufferError): + np.from_dlpack(z) + + @pytest.mark.skipif(IS_PYPY, reason="PyPy can't get refcounts.") + @pytest.mark.parametrize("arr", new_and_old_dlpack()) + def test_from_dlpack_refcount(self, arr): + arr = arr.copy() + y = np.from_dlpack(arr) + assert sys.getrefcount(arr) == 3 + del y + assert sys.getrefcount(arr) == 2 + + @pytest.mark.parametrize("dtype", [ + np.bool, + np.int8, np.int16, np.int32, np.int64, + np.uint8, np.uint16, np.uint32, np.uint64, + np.float16, np.float32, np.float64, + np.complex64, np.complex128 + ]) + @pytest.mark.parametrize("arr", new_and_old_dlpack()) + def test_dtype_passthrough(self, arr, dtype): + x = arr.astype(dtype) + y = np.from_dlpack(x) + + assert y.dtype == x.dtype + assert_array_equal(x, y) + + def test_invalid_dtype(self): + x = np.asarray(np.datetime64('2021-05-27')) + + with pytest.raises(BufferError): + np.from_dlpack(x) + + def test_invalid_byte_swapping(self): + dt = np.dtype('=i8').newbyteorder() + x = np.arange(5, dtype=dt) + + with pytest.raises(BufferError): + np.from_dlpack(x) + + def test_non_contiguous(self): + x = np.arange(25).reshape((5, 5)) + + y1 = x[0] + assert_array_equal(y1, np.from_dlpack(y1)) + + y2 = x[:, 0] + assert_array_equal(y2, np.from_dlpack(y2)) + + y3 = x[1, :] + assert_array_equal(y3, np.from_dlpack(y3)) + + y4 = x[1] + assert_array_equal(y4, np.from_dlpack(y4)) + + y5 = np.diagonal(x).copy() + assert_array_equal(y5, np.from_dlpack(y5)) + + @pytest.mark.parametrize("ndim", range(33)) + def test_higher_dims(self, ndim): + shape = (1,) * ndim + x = np.zeros(shape, dtype=np.float64) + + assert shape == np.from_dlpack(x).shape + + def test_dlpack_device(self): + x = np.arange(5) + assert x.__dlpack_device__() == (1, 0) + y = np.from_dlpack(x) + assert y.__dlpack_device__() == (1, 0) + z = y[::2] + assert z.__dlpack_device__() == (1, 0) + + def dlpack_deleter_exception(self, max_version): + x = np.arange(5) + _ = x.__dlpack__(max_version=max_version) + raise RuntimeError + + @pytest.mark.parametrize("max_version", [None, (1, 0)]) + def test_dlpack_destructor_exception(self, max_version): + with pytest.raises(RuntimeError): + self.dlpack_deleter_exception(max_version=max_version) + + def test_readonly(self): + x = np.arange(5) + x.flags.writeable = False + # Raises without max_version + with pytest.raises(BufferError): + x.__dlpack__() + + # But works fine if we try with version + y = np.from_dlpack(x) + assert not y.flags.writeable + + def test_ndim0(self): + x = np.array(1.0) + y = np.from_dlpack(x) + assert_array_equal(x, y) + + def test_size1dims_arrays(self): + x = np.ndarray(dtype='f8', shape=(10, 5, 1), strides=(8, 80, 4), + buffer=np.ones(1000, dtype=np.uint8), order='F') + y = np.from_dlpack(x) + assert_array_equal(x, y) + + def test_copy(self): + x = np.arange(5) + + y = np.from_dlpack(x) + assert np.may_share_memory(x, y) + y = np.from_dlpack(x, copy=False) + assert np.may_share_memory(x, y) + y = np.from_dlpack(x, copy=True) + assert not np.may_share_memory(x, y) + + def test_device(self): + x = np.arange(5) + # requesting (1, 0), i.e. CPU device works in both calls: + x.__dlpack__(dl_device=(1, 0)) + np.from_dlpack(x, device="cpu") + np.from_dlpack(x, device=None) + + with pytest.raises(ValueError): + x.__dlpack__(dl_device=(10, 0)) + with pytest.raises(ValueError): + np.from_dlpack(x, device="gpu") diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/test_dtype.py b/venv/lib/python3.12/site-packages/numpy/_core/tests/test_dtype.py new file mode 100644 index 00000000..86918395 --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/tests/test_dtype.py @@ -0,0 +1,1983 @@ +import sys +import operator +import pytest +import ctypes +import gc +import types +from typing import Any +import pickle + +import numpy as np +import numpy.dtypes +from numpy._core._rational_tests import rational +from numpy._core._multiarray_tests import create_custom_field_dtype +from numpy.testing import ( + assert_, assert_equal, assert_array_equal, assert_raises, HAS_REFCOUNT, + IS_PYSTON, _OLD_PROMOTION) +from itertools import permutations +import random + +import hypothesis +from hypothesis.extra import numpy as hynp + + + +def assert_dtype_equal(a, b): + assert_equal(a, b) + assert_equal(hash(a), hash(b), + "two equivalent types do not hash to the same value !") + +def assert_dtype_not_equal(a, b): + assert_(a != b) + assert_(hash(a) != hash(b), + "two different types hash to the same value !") + +class TestBuiltin: + @pytest.mark.parametrize('t', [int, float, complex, np.int32, str, object]) + def test_run(self, t): + """Only test hash runs at all.""" + dt = np.dtype(t) + hash(dt) + + @pytest.mark.parametrize('t', [int, float]) + def test_dtype(self, t): + # Make sure equivalent byte order char hash the same (e.g. < and = on + # little endian) + dt = np.dtype(t) + dt2 = dt.newbyteorder("<") + dt3 = dt.newbyteorder(">") + if dt == dt2: + assert_(dt.byteorder != dt2.byteorder, "bogus test") + assert_dtype_equal(dt, dt2) + else: + assert_(dt.byteorder != dt3.byteorder, "bogus test") + assert_dtype_equal(dt, dt3) + + def test_equivalent_dtype_hashing(self): + # Make sure equivalent dtypes with different type num hash equal + uintp = np.dtype(np.uintp) + if uintp.itemsize == 4: + left = uintp + right = np.dtype(np.uint32) + else: + left = uintp + right = np.dtype(np.ulonglong) + assert_(left == right) + assert_(hash(left) == hash(right)) + + def test_invalid_types(self): + # Make sure invalid type strings raise an error + + assert_raises(TypeError, np.dtype, 'O3') + assert_raises(TypeError, np.dtype, 'O5') + assert_raises(TypeError, np.dtype, 'O7') + assert_raises(TypeError, np.dtype, 'b3') + assert_raises(TypeError, np.dtype, 'h4') + assert_raises(TypeError, np.dtype, 'I5') + assert_raises(TypeError, np.dtype, 'e3') + assert_raises(TypeError, np.dtype, 'f5') + + if np.dtype('g').itemsize == 8 or np.dtype('g').itemsize == 16: + assert_raises(TypeError, np.dtype, 'g12') + elif np.dtype('g').itemsize == 12: + assert_raises(TypeError, np.dtype, 'g16') + + if np.dtype('l').itemsize == 8: + assert_raises(TypeError, np.dtype, 'l4') + assert_raises(TypeError, np.dtype, 'L4') + else: + assert_raises(TypeError, np.dtype, 'l8') + assert_raises(TypeError, np.dtype, 'L8') + + if np.dtype('q').itemsize == 8: + assert_raises(TypeError, np.dtype, 'q4') + assert_raises(TypeError, np.dtype, 'Q4') + else: + assert_raises(TypeError, np.dtype, 'q8') + assert_raises(TypeError, np.dtype, 'Q8') + + # Make sure negative-sized dtype raises an error + assert_raises(TypeError, np.dtype, 'S-1') + assert_raises(TypeError, np.dtype, 'U-1') + assert_raises(TypeError, np.dtype, 'V-1') + + def test_richcompare_invalid_dtype_equality(self): + # Make sure objects that cannot be converted to valid + # dtypes results in False/True when compared to valid dtypes. + # Here 7 cannot be converted to dtype. No exceptions should be raised + + assert not np.dtype(np.int32) == 7, "dtype richcompare failed for ==" + assert np.dtype(np.int32) != 7, "dtype richcompare failed for !=" + + @pytest.mark.parametrize( + 'operation', + [operator.le, operator.lt, operator.ge, operator.gt]) + def test_richcompare_invalid_dtype_comparison(self, operation): + # Make sure TypeError is raised for comparison operators + # for invalid dtypes. Here 7 is an invalid dtype. + + with pytest.raises(TypeError): + operation(np.dtype(np.int32), 7) + + @pytest.mark.parametrize("dtype", + ['Bool', 'Bytes0', 'Complex32', 'Complex64', + 'Datetime64', 'Float16', 'Float32', 'Float64', + 'Int8', 'Int16', 'Int32', 'Int64', + 'Object0', 'Str0', 'Timedelta64', + 'UInt8', 'UInt16', 'Uint32', 'UInt32', + 'Uint64', 'UInt64', 'Void0', + "Float128", "Complex128"]) + def test_numeric_style_types_are_invalid(self, dtype): + with assert_raises(TypeError): + np.dtype(dtype) + + def test_expired_dtypes_with_bad_bytesize(self): + match: str = r".*removed in NumPy 2.0.*" + with pytest.raises(TypeError, match=match): + np.dtype("int0") + with pytest.raises(TypeError, match=match): + np.dtype("uint0") + with pytest.raises(TypeError, match=match): + np.dtype("bool8") + with pytest.raises(TypeError, match=match): + np.dtype("bytes0") + with pytest.raises(TypeError, match=match): + np.dtype("str0") + with pytest.raises(TypeError, match=match): + np.dtype("object0") + with pytest.raises(TypeError, match=match): + np.dtype("void0") + + @pytest.mark.parametrize( + 'value', + ['m8', 'M8', 'datetime64', 'timedelta64', + 'i4, (2,3)f8, f4', 'S3, 3u8, (3,4)S10', + '>f', '= (3, 12), + reason="Python 3.12 has immortal refcounts, this test will no longer " + "work. See gh-23986" +) +@pytest.mark.skipif(not HAS_REFCOUNT, reason="Python lacks refcounts") +class TestStructuredObjectRefcounting: + """These tests cover various uses of complicated structured types which + include objects and thus require reference counting. + """ + @pytest.mark.parametrize(['dt', 'pat', 'count', 'singleton'], + iter_struct_object_dtypes()) + @pytest.mark.parametrize(["creation_func", "creation_obj"], [ + pytest.param(np.empty, None, + # None is probably used for too many things + marks=pytest.mark.skip("unreliable due to python's behaviour")), + (np.ones, 1), + (np.zeros, 0)]) + def test_structured_object_create_delete(self, dt, pat, count, singleton, + creation_func, creation_obj): + """Structured object reference counting in creation and deletion""" + # The test assumes that 0, 1, and None are singletons. + gc.collect() + before = sys.getrefcount(creation_obj) + arr = creation_func(3, dt) + + now = sys.getrefcount(creation_obj) + assert now - before == count * 3 + del arr + now = sys.getrefcount(creation_obj) + assert now == before + + @pytest.mark.parametrize(['dt', 'pat', 'count', 'singleton'], + iter_struct_object_dtypes()) + def test_structured_object_item_setting(self, dt, pat, count, singleton): + """Structured object reference counting for simple item setting""" + one = 1 + + gc.collect() + before = sys.getrefcount(singleton) + arr = np.array([pat] * 3, dt) + assert sys.getrefcount(singleton) - before == count * 3 + # Fill with `1` and check that it was replaced correctly: + before2 = sys.getrefcount(one) + arr[...] = one + after2 = sys.getrefcount(one) + assert after2 - before2 == count * 3 + del arr + gc.collect() + assert sys.getrefcount(one) == before2 + assert sys.getrefcount(singleton) == before + + @pytest.mark.parametrize(['dt', 'pat', 'count', 'singleton'], + iter_struct_object_dtypes()) + @pytest.mark.parametrize( + ['shape', 'index', 'items_changed'], + [((3,), ([0, 2],), 2), + ((3, 2), ([0, 2], slice(None)), 4), + ((3, 2), ([0, 2], [1]), 2), + ((3,), ([True, False, True]), 2)]) + def test_structured_object_indexing(self, shape, index, items_changed, + dt, pat, count, singleton): + """Structured object reference counting for advanced indexing.""" + # Use two small negative values (should be singletons, but less likely + # to run into race-conditions). This failed in some threaded envs + # When using 0 and 1. If it fails again, should remove all explicit + # checks, and rely on `pytest-leaks` reference count checker only. + val0 = -4 + val1 = -5 + + arr = np.full(shape, val0, dt) + + gc.collect() + before_val0 = sys.getrefcount(val0) + before_val1 = sys.getrefcount(val1) + # Test item getting: + part = arr[index] + after_val0 = sys.getrefcount(val0) + assert after_val0 - before_val0 == count * items_changed + del part + # Test item setting: + arr[index] = val1 + gc.collect() + after_val0 = sys.getrefcount(val0) + after_val1 = sys.getrefcount(val1) + assert before_val0 - after_val0 == count * items_changed + assert after_val1 - before_val1 == count * items_changed + + @pytest.mark.parametrize(['dt', 'pat', 'count', 'singleton'], + iter_struct_object_dtypes()) + def test_structured_object_take_and_repeat(self, dt, pat, count, singleton): + """Structured object reference counting for specialized functions. + The older functions such as take and repeat use different code paths + then item setting (when writing this). + """ + indices = [0, 1] + + arr = np.array([pat] * 3, dt) + gc.collect() + before = sys.getrefcount(singleton) + res = arr.take(indices) + after = sys.getrefcount(singleton) + assert after - before == count * 2 + new = res.repeat(10) + gc.collect() + after_repeat = sys.getrefcount(singleton) + assert after_repeat - after == count * 2 * 10 + + +class TestStructuredDtypeSparseFields: + """Tests subarray fields which contain sparse dtypes so that + not all memory is used by the dtype work. Such dtype's should + leave the underlying memory unchanged. + """ + dtype = np.dtype([('a', {'names':['aa', 'ab'], 'formats':['f', 'f'], + 'offsets':[0, 4]}, (2, 3))]) + sparse_dtype = np.dtype([('a', {'names':['ab'], 'formats':['f'], + 'offsets':[4]}, (2, 3))]) + + def test_sparse_field_assignment(self): + arr = np.zeros(3, self.dtype) + sparse_arr = arr.view(self.sparse_dtype) + + sparse_arr[...] = np.finfo(np.float32).max + # dtype is reduced when accessing the field, so shape is (3, 2, 3): + assert_array_equal(arr["a"]["aa"], np.zeros((3, 2, 3))) + + def test_sparse_field_assignment_fancy(self): + # Fancy assignment goes to the copyswap function for complex types: + arr = np.zeros(3, self.dtype) + sparse_arr = arr.view(self.sparse_dtype) + + sparse_arr[[0, 1, 2]] = np.finfo(np.float32).max + # dtype is reduced when accessing the field, so shape is (3, 2, 3): + assert_array_equal(arr["a"]["aa"], np.zeros((3, 2, 3))) + + +class TestMonsterType: + """Test deeply nested subtypes.""" + + def test1(self): + simple1 = np.dtype({'names': ['r', 'b'], 'formats': ['u1', 'u1'], + 'titles': ['Red pixel', 'Blue pixel']}) + a = np.dtype([('yo', int), ('ye', simple1), + ('yi', np.dtype((int, (3, 2))))]) + b = np.dtype([('yo', int), ('ye', simple1), + ('yi', np.dtype((int, (3, 2))))]) + assert_dtype_equal(a, b) + + c = np.dtype([('yo', int), ('ye', simple1), + ('yi', np.dtype((a, (3, 2))))]) + d = np.dtype([('yo', int), ('ye', simple1), + ('yi', np.dtype((a, (3, 2))))]) + assert_dtype_equal(c, d) + + @pytest.mark.skipif(IS_PYSTON, reason="Pyston disables recursion checking") + def test_list_recursion(self): + l = list() + l.append(('f', l)) + with pytest.raises(RecursionError): + np.dtype(l) + + @pytest.mark.skipif(IS_PYSTON, reason="Pyston disables recursion checking") + def test_tuple_recursion(self): + d = np.int32 + for i in range(100000): + d = (d, (1,)) + with pytest.raises(RecursionError): + np.dtype(d) + + @pytest.mark.skipif(IS_PYSTON, reason="Pyston disables recursion checking") + def test_dict_recursion(self): + d = dict(names=['self'], formats=[None], offsets=[0]) + d['formats'][0] = d + with pytest.raises(RecursionError): + np.dtype(d) + + +class TestMetadata: + def test_no_metadata(self): + d = np.dtype(int) + assert_(d.metadata is None) + + def test_metadata_takes_dict(self): + d = np.dtype(int, metadata={'datum': 1}) + assert_(d.metadata == {'datum': 1}) + + def test_metadata_rejects_nondict(self): + assert_raises(TypeError, np.dtype, int, metadata='datum') + assert_raises(TypeError, np.dtype, int, metadata=1) + assert_raises(TypeError, np.dtype, int, metadata=None) + + def test_nested_metadata(self): + d = np.dtype([('a', np.dtype(int, metadata={'datum': 1}))]) + assert_(d['a'].metadata == {'datum': 1}) + + def test_base_metadata_copied(self): + d = np.dtype((np.void, np.dtype('i4,i4', metadata={'datum': 1}))) + assert_(d.metadata == {'datum': 1}) + +class TestString: + def test_complex_dtype_str(self): + dt = np.dtype([('top', [('tiles', ('>f4', (64, 64)), (1,)), + ('rtile', '>f4', (64, 36))], (3,)), + ('bottom', [('bleft', ('>f4', (8, 64)), (1,)), + ('bright', '>f4', (8, 36))])]) + assert_equal(str(dt), + "[('top', [('tiles', ('>f4', (64, 64)), (1,)), " + "('rtile', '>f4', (64, 36))], (3,)), " + "('bottom', [('bleft', ('>f4', (8, 64)), (1,)), " + "('bright', '>f4', (8, 36))])]") + + # If the sticky aligned flag is set to True, it makes the + # str() function use a dict representation with an 'aligned' flag + dt = np.dtype([('top', [('tiles', ('>f4', (64, 64)), (1,)), + ('rtile', '>f4', (64, 36))], + (3,)), + ('bottom', [('bleft', ('>f4', (8, 64)), (1,)), + ('bright', '>f4', (8, 36))])], + align=True) + assert_equal(str(dt), + "{'names': ['top', 'bottom']," + " 'formats': [([('tiles', ('>f4', (64, 64)), (1,)), " + "('rtile', '>f4', (64, 36))], (3,)), " + "[('bleft', ('>f4', (8, 64)), (1,)), " + "('bright', '>f4', (8, 36))]]," + " 'offsets': [0, 76800]," + " 'itemsize': 80000," + " 'aligned': True}") + with np.printoptions(legacy='1.21'): + assert_equal(str(dt), + "{'names':['top','bottom'], " + "'formats':[([('tiles', ('>f4', (64, 64)), (1,)), " + "('rtile', '>f4', (64, 36))], (3,))," + "[('bleft', ('>f4', (8, 64)), (1,)), " + "('bright', '>f4', (8, 36))]], " + "'offsets':[0,76800], " + "'itemsize':80000, " + "'aligned':True}") + assert_equal(np.dtype(eval(str(dt))), dt) + + dt = np.dtype({'names': ['r', 'g', 'b'], 'formats': ['u1', 'u1', 'u1'], + 'offsets': [0, 1, 2], + 'titles': ['Red pixel', 'Green pixel', 'Blue pixel']}) + assert_equal(str(dt), + "[(('Red pixel', 'r'), 'u1'), " + "(('Green pixel', 'g'), 'u1'), " + "(('Blue pixel', 'b'), 'u1')]") + + dt = np.dtype({'names': ['rgba', 'r', 'g', 'b'], + 'formats': ['f4', (64, 64)), (1,)), + ('rtile', '>f4', (64, 36))], (3,)), + ('bottom', [('bleft', ('>f4', (8, 64)), (1,)), + ('bright', '>f4', (8, 36))])]) + assert_equal(repr(dt), + "dtype([('top', [('tiles', ('>f4', (64, 64)), (1,)), " + "('rtile', '>f4', (64, 36))], (3,)), " + "('bottom', [('bleft', ('>f4', (8, 64)), (1,)), " + "('bright', '>f4', (8, 36))])])") + + dt = np.dtype({'names': ['r', 'g', 'b'], 'formats': ['u1', 'u1', 'u1'], + 'offsets': [0, 1, 2], + 'titles': ['Red pixel', 'Green pixel', 'Blue pixel']}, + align=True) + assert_equal(repr(dt), + "dtype([(('Red pixel', 'r'), 'u1'), " + "(('Green pixel', 'g'), 'u1'), " + "(('Blue pixel', 'b'), 'u1')], align=True)") + + def test_repr_structured_not_packed(self): + dt = np.dtype({'names': ['rgba', 'r', 'g', 'b'], + 'formats': ['i4") + assert np.result_type(dt).isnative + assert np.result_type(dt).num == dt.num + + # dtype with empty space: + struct_dt = np.dtype(">i4,i1,f4', (2, 1)), ('b', 'u4')]) + self.check(BigEndStruct, expected) + + def test_little_endian_structure_packed(self): + class LittleEndStruct(ctypes.LittleEndianStructure): + _fields_ = [ + ('one', ctypes.c_uint8), + ('two', ctypes.c_uint32) + ] + _pack_ = 1 + expected = np.dtype([('one', 'u1'), ('two', 'B'), + ('b', '>H') + ], align=True) + self.check(PaddedStruct, expected) + + def test_simple_endian_types(self): + self.check(ctypes.c_uint16.__ctype_le__, np.dtype('u2')) + self.check(ctypes.c_uint8.__ctype_le__, np.dtype('u1')) + self.check(ctypes.c_uint8.__ctype_be__, np.dtype('u1')) + + all_types = set(np.typecodes['All']) + all_pairs = permutations(all_types, 2) + + @pytest.mark.parametrize("pair", all_pairs) + def test_pairs(self, pair): + """ + Check that np.dtype('x,y') matches [np.dtype('x'), np.dtype('y')] + Example: np.dtype('d,I') -> dtype([('f0', ' None: + alias = np.dtype[Any] + assert isinstance(alias, types.GenericAlias) + assert alias.__origin__ is np.dtype + + @pytest.mark.parametrize("code", np.typecodes["All"]) + def test_dtype_subclass(self, code: str) -> None: + cls = type(np.dtype(code)) + alias = cls[Any] + assert isinstance(alias, types.GenericAlias) + assert alias.__origin__ is cls + + @pytest.mark.parametrize("arg_len", range(4)) + def test_subscript_tuple(self, arg_len: int) -> None: + arg_tup = (Any,) * arg_len + if arg_len == 1: + assert np.dtype[arg_tup] + else: + with pytest.raises(TypeError): + np.dtype[arg_tup] + + def test_subscript_scalar(self) -> None: + assert np.dtype[Any] + + +def test_result_type_integers_and_unitless_timedelta64(): + # Regression test for gh-20077. The following call of `result_type` + # would cause a seg. fault. + td = np.timedelta64(4) + result = np.result_type(0, td) + assert_dtype_equal(result, td.dtype) + + +def test_creating_dtype_with_dtype_class_errors(): + # Regression test for #25031, calling `np.dtype` with itself segfaulted. + with pytest.raises(TypeError, match="Cannot convert np.dtype into a"): + np.array(np.ones(10), dtype=np.dtype) diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/test_einsum.py b/venv/lib/python3.12/site-packages/numpy/_core/tests/test_einsum.py new file mode 100644 index 00000000..0a97693f --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/tests/test_einsum.py @@ -0,0 +1,1232 @@ +import itertools +import sys +import platform + +import pytest + +import numpy as np +from numpy.testing import ( + assert_, assert_equal, assert_array_equal, assert_almost_equal, + assert_raises, suppress_warnings, assert_raises_regex, assert_allclose + ) + +# Setup for optimize einsum +chars = 'abcdefghij' +sizes = np.array([2, 3, 4, 5, 4, 3, 2, 6, 5, 4, 3]) +global_size_dict = dict(zip(chars, sizes)) + + +class TestEinsum: + @pytest.mark.parametrize("do_opt", [True, False]) + @pytest.mark.parametrize("einsum_fn", [np.einsum, np.einsum_path]) + def test_einsum_errors(self, do_opt, einsum_fn): + # Need enough arguments + assert_raises(ValueError, einsum_fn, optimize=do_opt) + assert_raises(ValueError, einsum_fn, "", optimize=do_opt) + + # subscripts must be a string + assert_raises(TypeError, einsum_fn, 0, 0, optimize=do_opt) + + # issue 4528 revealed a segfault with this call + assert_raises(TypeError, einsum_fn, *(None,)*63, optimize=do_opt) + + # number of operands must match count in subscripts string + assert_raises(ValueError, einsum_fn, "", 0, 0, optimize=do_opt) + assert_raises(ValueError, einsum_fn, ",", 0, [0], [0], + optimize=do_opt) + assert_raises(ValueError, einsum_fn, ",", [0], optimize=do_opt) + + # can't have more subscripts than dimensions in the operand + assert_raises(ValueError, einsum_fn, "i", 0, optimize=do_opt) + assert_raises(ValueError, einsum_fn, "ij", [0, 0], optimize=do_opt) + assert_raises(ValueError, einsum_fn, "...i", 0, optimize=do_opt) + assert_raises(ValueError, einsum_fn, "i...j", [0, 0], optimize=do_opt) + assert_raises(ValueError, einsum_fn, "i...", 0, optimize=do_opt) + assert_raises(ValueError, einsum_fn, "ij...", [0, 0], optimize=do_opt) + + # invalid ellipsis + assert_raises(ValueError, einsum_fn, "i..", [0, 0], optimize=do_opt) + assert_raises(ValueError, einsum_fn, ".i...", [0, 0], optimize=do_opt) + assert_raises(ValueError, einsum_fn, "j->..j", [0, 0], optimize=do_opt) + assert_raises(ValueError, einsum_fn, "j->.j...", [0, 0], + optimize=do_opt) + + # invalid subscript character + assert_raises(ValueError, einsum_fn, "i%...", [0, 0], optimize=do_opt) + assert_raises(ValueError, einsum_fn, "...j$", [0, 0], optimize=do_opt) + assert_raises(ValueError, einsum_fn, "i->&", [0, 0], optimize=do_opt) + + # output subscripts must appear in input + assert_raises(ValueError, einsum_fn, "i->ij", [0, 0], optimize=do_opt) + + # output subscripts may only be specified once + assert_raises(ValueError, einsum_fn, "ij->jij", [[0, 0], [0, 0]], + optimize=do_opt) + + # dimensions must match when being collapsed + assert_raises(ValueError, einsum_fn, "ii", + np.arange(6).reshape(2, 3), optimize=do_opt) + assert_raises(ValueError, einsum_fn, "ii->i", + np.arange(6).reshape(2, 3), optimize=do_opt) + + with assert_raises_regex(ValueError, "'b'"): + # gh-11221 - 'c' erroneously appeared in the error message + a = np.ones((3, 3, 4, 5, 6)) + b = np.ones((3, 4, 5)) + einsum_fn('aabcb,abc', a, b) + + @pytest.mark.parametrize("do_opt", [True, False]) + def test_einsum_specific_errors(self, do_opt): + # out parameter must be an array + assert_raises(TypeError, np.einsum, "", 0, out='test', + optimize=do_opt) + + # order parameter must be a valid order + assert_raises(ValueError, np.einsum, "", 0, order='W', + optimize=do_opt) + + # casting parameter must be a valid casting + assert_raises(ValueError, np.einsum, "", 0, casting='blah', + optimize=do_opt) + + # dtype parameter must be a valid dtype + assert_raises(TypeError, np.einsum, "", 0, dtype='bad_data_type', + optimize=do_opt) + + # other keyword arguments are rejected + assert_raises(TypeError, np.einsum, "", 0, bad_arg=0, optimize=do_opt) + + # broadcasting to new dimensions must be enabled explicitly + assert_raises(ValueError, np.einsum, "i", np.arange(6).reshape(2, 3), + optimize=do_opt) + assert_raises(ValueError, np.einsum, "i->i", [[0, 1], [0, 1]], + out=np.arange(4).reshape(2, 2), optimize=do_opt) + + # Check order kwarg, asanyarray allows 1d to pass through + assert_raises(ValueError, np.einsum, "i->i", + np.arange(6).reshape(-1, 1), optimize=do_opt, order='d') + + def test_einsum_object_errors(self): + # Exceptions created by object arithmetic should + # successfully propagate + + class CustomException(Exception): + pass + + class DestructoBox: + + def __init__(self, value, destruct): + self._val = value + self._destruct = destruct + + def __add__(self, other): + tmp = self._val + other._val + if tmp >= self._destruct: + raise CustomException + else: + self._val = tmp + return self + + def __radd__(self, other): + if other == 0: + return self + else: + return self.__add__(other) + + def __mul__(self, other): + tmp = self._val * other._val + if tmp >= self._destruct: + raise CustomException + else: + self._val = tmp + return self + + def __rmul__(self, other): + if other == 0: + return self + else: + return self.__mul__(other) + + a = np.array([DestructoBox(i, 5) for i in range(1, 10)], + dtype='object').reshape(3, 3) + + # raised from unbuffered_loop_nop1_ndim2 + assert_raises(CustomException, np.einsum, "ij->i", a) + + # raised from unbuffered_loop_nop1_ndim3 + b = np.array([DestructoBox(i, 100) for i in range(0, 27)], + dtype='object').reshape(3, 3, 3) + assert_raises(CustomException, np.einsum, "i...k->...", b) + + # raised from unbuffered_loop_nop2_ndim2 + b = np.array([DestructoBox(i, 55) for i in range(1, 4)], + dtype='object') + assert_raises(CustomException, np.einsum, "ij, j", a, b) + + # raised from unbuffered_loop_nop2_ndim3 + assert_raises(CustomException, np.einsum, "ij, jh", a, a) + + # raised from PyArray_EinsteinSum + assert_raises(CustomException, np.einsum, "ij->", a) + + def test_einsum_views(self): + # pass-through + for do_opt in [True, False]: + a = np.arange(6) + a.shape = (2, 3) + + b = np.einsum("...", a, optimize=do_opt) + assert_(b.base is a) + + b = np.einsum(a, [Ellipsis], optimize=do_opt) + assert_(b.base is a) + + b = np.einsum("ij", a, optimize=do_opt) + assert_(b.base is a) + assert_equal(b, a) + + b = np.einsum(a, [0, 1], optimize=do_opt) + assert_(b.base is a) + assert_equal(b, a) + + # output is writeable whenever input is writeable + b = np.einsum("...", a, optimize=do_opt) + assert_(b.flags['WRITEABLE']) + a.flags['WRITEABLE'] = False + b = np.einsum("...", a, optimize=do_opt) + assert_(not b.flags['WRITEABLE']) + + # transpose + a = np.arange(6) + a.shape = (2, 3) + + b = np.einsum("ji", a, optimize=do_opt) + assert_(b.base is a) + assert_equal(b, a.T) + + b = np.einsum(a, [1, 0], optimize=do_opt) + assert_(b.base is a) + assert_equal(b, a.T) + + # diagonal + a = np.arange(9) + a.shape = (3, 3) + + b = np.einsum("ii->i", a, optimize=do_opt) + assert_(b.base is a) + assert_equal(b, [a[i, i] for i in range(3)]) + + b = np.einsum(a, [0, 0], [0], optimize=do_opt) + assert_(b.base is a) + assert_equal(b, [a[i, i] for i in range(3)]) + + # diagonal with various ways of broadcasting an additional dimension + a = np.arange(27) + a.shape = (3, 3, 3) + + b = np.einsum("...ii->...i", a, optimize=do_opt) + assert_(b.base is a) + assert_equal(b, [[x[i, i] for i in range(3)] for x in a]) + + b = np.einsum(a, [Ellipsis, 0, 0], [Ellipsis, 0], optimize=do_opt) + assert_(b.base is a) + assert_equal(b, [[x[i, i] for i in range(3)] for x in a]) + + b = np.einsum("ii...->...i", a, optimize=do_opt) + assert_(b.base is a) + assert_equal(b, [[x[i, i] for i in range(3)] + for x in a.transpose(2, 0, 1)]) + + b = np.einsum(a, [0, 0, Ellipsis], [Ellipsis, 0], optimize=do_opt) + assert_(b.base is a) + assert_equal(b, [[x[i, i] for i in range(3)] + for x in a.transpose(2, 0, 1)]) + + b = np.einsum("...ii->i...", a, optimize=do_opt) + assert_(b.base is a) + assert_equal(b, [a[:, i, i] for i in range(3)]) + + b = np.einsum(a, [Ellipsis, 0, 0], [0, Ellipsis], optimize=do_opt) + assert_(b.base is a) + assert_equal(b, [a[:, i, i] for i in range(3)]) + + b = np.einsum("jii->ij", a, optimize=do_opt) + assert_(b.base is a) + assert_equal(b, [a[:, i, i] for i in range(3)]) + + b = np.einsum(a, [1, 0, 0], [0, 1], optimize=do_opt) + assert_(b.base is a) + assert_equal(b, [a[:, i, i] for i in range(3)]) + + b = np.einsum("ii...->i...", a, optimize=do_opt) + assert_(b.base is a) + assert_equal(b, [a.transpose(2, 0, 1)[:, i, i] for i in range(3)]) + + b = np.einsum(a, [0, 0, Ellipsis], [0, Ellipsis], optimize=do_opt) + assert_(b.base is a) + assert_equal(b, [a.transpose(2, 0, 1)[:, i, i] for i in range(3)]) + + b = np.einsum("i...i->i...", a, optimize=do_opt) + assert_(b.base is a) + assert_equal(b, [a.transpose(1, 0, 2)[:, i, i] for i in range(3)]) + + b = np.einsum(a, [0, Ellipsis, 0], [0, Ellipsis], optimize=do_opt) + assert_(b.base is a) + assert_equal(b, [a.transpose(1, 0, 2)[:, i, i] for i in range(3)]) + + b = np.einsum("i...i->...i", a, optimize=do_opt) + assert_(b.base is a) + assert_equal(b, [[x[i, i] for i in range(3)] + for x in a.transpose(1, 0, 2)]) + + b = np.einsum(a, [0, Ellipsis, 0], [Ellipsis, 0], optimize=do_opt) + assert_(b.base is a) + assert_equal(b, [[x[i, i] for i in range(3)] + for x in a.transpose(1, 0, 2)]) + + # triple diagonal + a = np.arange(27) + a.shape = (3, 3, 3) + + b = np.einsum("iii->i", a, optimize=do_opt) + assert_(b.base is a) + assert_equal(b, [a[i, i, i] for i in range(3)]) + + b = np.einsum(a, [0, 0, 0], [0], optimize=do_opt) + assert_(b.base is a) + assert_equal(b, [a[i, i, i] for i in range(3)]) + + # swap axes + a = np.arange(24) + a.shape = (2, 3, 4) + + b = np.einsum("ijk->jik", a, optimize=do_opt) + assert_(b.base is a) + assert_equal(b, a.swapaxes(0, 1)) + + b = np.einsum(a, [0, 1, 2], [1, 0, 2], optimize=do_opt) + assert_(b.base is a) + assert_equal(b, a.swapaxes(0, 1)) + + @np._no_nep50_warning() + def check_einsum_sums(self, dtype, do_opt=False): + dtype = np.dtype(dtype) + # Check various sums. Does many sizes to exercise unrolled loops. + + # sum(a, axis=-1) + for n in range(1, 17): + a = np.arange(n, dtype=dtype) + b = np.sum(a, axis=-1) + if hasattr(b, 'astype'): + b = b.astype(dtype) + assert_equal(np.einsum("i->", a, optimize=do_opt), b) + assert_equal(np.einsum(a, [0], [], optimize=do_opt), b) + + for n in range(1, 17): + a = np.arange(2*3*n, dtype=dtype).reshape(2, 3, n) + b = np.sum(a, axis=-1) + if hasattr(b, 'astype'): + b = b.astype(dtype) + assert_equal(np.einsum("...i->...", a, optimize=do_opt), b) + assert_equal(np.einsum(a, [Ellipsis, 0], [Ellipsis], optimize=do_opt), b) + + # sum(a, axis=0) + for n in range(1, 17): + a = np.arange(2*n, dtype=dtype).reshape(2, n) + b = np.sum(a, axis=0) + if hasattr(b, 'astype'): + b = b.astype(dtype) + assert_equal(np.einsum("i...->...", a, optimize=do_opt), b) + assert_equal(np.einsum(a, [0, Ellipsis], [Ellipsis], optimize=do_opt), b) + + for n in range(1, 17): + a = np.arange(2*3*n, dtype=dtype).reshape(2, 3, n) + b = np.sum(a, axis=0) + if hasattr(b, 'astype'): + b = b.astype(dtype) + assert_equal(np.einsum("i...->...", a, optimize=do_opt), b) + assert_equal(np.einsum(a, [0, Ellipsis], [Ellipsis], optimize=do_opt), b) + + # trace(a) + for n in range(1, 17): + a = np.arange(n*n, dtype=dtype).reshape(n, n) + b = np.trace(a) + if hasattr(b, 'astype'): + b = b.astype(dtype) + assert_equal(np.einsum("ii", a, optimize=do_opt), b) + assert_equal(np.einsum(a, [0, 0], optimize=do_opt), b) + + # gh-15961: should accept numpy int64 type in subscript list + np_array = np.asarray([0, 0]) + assert_equal(np.einsum(a, np_array, optimize=do_opt), b) + assert_equal(np.einsum(a, list(np_array), optimize=do_opt), b) + + # multiply(a, b) + assert_equal(np.einsum("..., ...", 3, 4), 12) # scalar case + for n in range(1, 17): + a = np.arange(3 * n, dtype=dtype).reshape(3, n) + b = np.arange(2 * 3 * n, dtype=dtype).reshape(2, 3, n) + assert_equal(np.einsum("..., ...", a, b, optimize=do_opt), + np.multiply(a, b)) + assert_equal(np.einsum(a, [Ellipsis], b, [Ellipsis], optimize=do_opt), + np.multiply(a, b)) + + # inner(a,b) + for n in range(1, 17): + a = np.arange(2 * 3 * n, dtype=dtype).reshape(2, 3, n) + b = np.arange(n, dtype=dtype) + assert_equal(np.einsum("...i, ...i", a, b, optimize=do_opt), np.inner(a, b)) + assert_equal(np.einsum(a, [Ellipsis, 0], b, [Ellipsis, 0], optimize=do_opt), + np.inner(a, b)) + + for n in range(1, 11): + a = np.arange(n * 3 * 2, dtype=dtype).reshape(n, 3, 2) + b = np.arange(n, dtype=dtype) + assert_equal(np.einsum("i..., i...", a, b, optimize=do_opt), + np.inner(a.T, b.T).T) + assert_equal(np.einsum(a, [0, Ellipsis], b, [0, Ellipsis], optimize=do_opt), + np.inner(a.T, b.T).T) + + # outer(a,b) + for n in range(1, 17): + a = np.arange(3, dtype=dtype)+1 + b = np.arange(n, dtype=dtype)+1 + assert_equal(np.einsum("i,j", a, b, optimize=do_opt), + np.outer(a, b)) + assert_equal(np.einsum(a, [0], b, [1], optimize=do_opt), + np.outer(a, b)) + + # Suppress the complex warnings for the 'as f8' tests + with suppress_warnings() as sup: + sup.filter(np.exceptions.ComplexWarning) + + # matvec(a,b) / a.dot(b) where a is matrix, b is vector + for n in range(1, 17): + a = np.arange(4*n, dtype=dtype).reshape(4, n) + b = np.arange(n, dtype=dtype) + assert_equal(np.einsum("ij, j", a, b, optimize=do_opt), + np.dot(a, b)) + assert_equal(np.einsum(a, [0, 1], b, [1], optimize=do_opt), + np.dot(a, b)) + + c = np.arange(4, dtype=dtype) + np.einsum("ij,j", a, b, out=c, + dtype='f8', casting='unsafe', optimize=do_opt) + assert_equal(c, + np.dot(a.astype('f8'), + b.astype('f8')).astype(dtype)) + c[...] = 0 + np.einsum(a, [0, 1], b, [1], out=c, + dtype='f8', casting='unsafe', optimize=do_opt) + assert_equal(c, + np.dot(a.astype('f8'), + b.astype('f8')).astype(dtype)) + + for n in range(1, 17): + a = np.arange(4*n, dtype=dtype).reshape(4, n) + b = np.arange(n, dtype=dtype) + assert_equal(np.einsum("ji,j", a.T, b.T, optimize=do_opt), + np.dot(b.T, a.T)) + assert_equal(np.einsum(a.T, [1, 0], b.T, [1], optimize=do_opt), + np.dot(b.T, a.T)) + + c = np.arange(4, dtype=dtype) + np.einsum("ji,j", a.T, b.T, out=c, + dtype='f8', casting='unsafe', optimize=do_opt) + assert_equal(c, + np.dot(b.T.astype('f8'), + a.T.astype('f8')).astype(dtype)) + c[...] = 0 + np.einsum(a.T, [1, 0], b.T, [1], out=c, + dtype='f8', casting='unsafe', optimize=do_opt) + assert_equal(c, + np.dot(b.T.astype('f8'), + a.T.astype('f8')).astype(dtype)) + + # matmat(a,b) / a.dot(b) where a is matrix, b is matrix + for n in range(1, 17): + if n < 8 or dtype != 'f2': + a = np.arange(4*n, dtype=dtype).reshape(4, n) + b = np.arange(n*6, dtype=dtype).reshape(n, 6) + assert_equal(np.einsum("ij,jk", a, b, optimize=do_opt), + np.dot(a, b)) + assert_equal(np.einsum(a, [0, 1], b, [1, 2], optimize=do_opt), + np.dot(a, b)) + + for n in range(1, 17): + a = np.arange(4*n, dtype=dtype).reshape(4, n) + b = np.arange(n*6, dtype=dtype).reshape(n, 6) + c = np.arange(24, dtype=dtype).reshape(4, 6) + np.einsum("ij,jk", a, b, out=c, dtype='f8', casting='unsafe', + optimize=do_opt) + assert_equal(c, + np.dot(a.astype('f8'), + b.astype('f8')).astype(dtype)) + c[...] = 0 + np.einsum(a, [0, 1], b, [1, 2], out=c, + dtype='f8', casting='unsafe', optimize=do_opt) + assert_equal(c, + np.dot(a.astype('f8'), + b.astype('f8')).astype(dtype)) + + # matrix triple product (note this is not currently an efficient + # way to multiply 3 matrices) + a = np.arange(12, dtype=dtype).reshape(3, 4) + b = np.arange(20, dtype=dtype).reshape(4, 5) + c = np.arange(30, dtype=dtype).reshape(5, 6) + if dtype != 'f2': + assert_equal(np.einsum("ij,jk,kl", a, b, c, optimize=do_opt), + a.dot(b).dot(c)) + assert_equal(np.einsum(a, [0, 1], b, [1, 2], c, [2, 3], + optimize=do_opt), a.dot(b).dot(c)) + + d = np.arange(18, dtype=dtype).reshape(3, 6) + np.einsum("ij,jk,kl", a, b, c, out=d, + dtype='f8', casting='unsafe', optimize=do_opt) + tgt = a.astype('f8').dot(b.astype('f8')) + tgt = tgt.dot(c.astype('f8')).astype(dtype) + assert_equal(d, tgt) + + d[...] = 0 + np.einsum(a, [0, 1], b, [1, 2], c, [2, 3], out=d, + dtype='f8', casting='unsafe', optimize=do_opt) + tgt = a.astype('f8').dot(b.astype('f8')) + tgt = tgt.dot(c.astype('f8')).astype(dtype) + assert_equal(d, tgt) + + # tensordot(a, b) + if np.dtype(dtype) != np.dtype('f2'): + a = np.arange(60, dtype=dtype).reshape(3, 4, 5) + b = np.arange(24, dtype=dtype).reshape(4, 3, 2) + assert_equal(np.einsum("ijk, jil -> kl", a, b), + np.tensordot(a, b, axes=([1, 0], [0, 1]))) + assert_equal(np.einsum(a, [0, 1, 2], b, [1, 0, 3], [2, 3]), + np.tensordot(a, b, axes=([1, 0], [0, 1]))) + + c = np.arange(10, dtype=dtype).reshape(5, 2) + np.einsum("ijk,jil->kl", a, b, out=c, + dtype='f8', casting='unsafe', optimize=do_opt) + assert_equal(c, np.tensordot(a.astype('f8'), b.astype('f8'), + axes=([1, 0], [0, 1])).astype(dtype)) + c[...] = 0 + np.einsum(a, [0, 1, 2], b, [1, 0, 3], [2, 3], out=c, + dtype='f8', casting='unsafe', optimize=do_opt) + assert_equal(c, np.tensordot(a.astype('f8'), b.astype('f8'), + axes=([1, 0], [0, 1])).astype(dtype)) + + # logical_and(logical_and(a!=0, b!=0), c!=0) + neg_val = -2 if dtype.kind != "u" else np.iinfo(dtype).max - 1 + a = np.array([1, 3, neg_val, 0, 12, 13, 0, 1], dtype=dtype) + b = np.array([0, 3.5, 0., neg_val, 0, 1, 3, 12], dtype=dtype) + c = np.array([True, True, False, True, True, False, True, True]) + + assert_equal(np.einsum("i,i,i->i", a, b, c, + dtype='?', casting='unsafe', optimize=do_opt), + np.logical_and(np.logical_and(a != 0, b != 0), c != 0)) + assert_equal(np.einsum(a, [0], b, [0], c, [0], [0], + dtype='?', casting='unsafe'), + np.logical_and(np.logical_and(a != 0, b != 0), c != 0)) + + a = np.arange(9, dtype=dtype) + assert_equal(np.einsum(",i->", 3, a), 3*np.sum(a)) + assert_equal(np.einsum(3, [], a, [0], []), 3*np.sum(a)) + assert_equal(np.einsum("i,->", a, 3), 3*np.sum(a)) + assert_equal(np.einsum(a, [0], 3, [], []), 3*np.sum(a)) + + # Various stride0, contiguous, and SSE aligned variants + for n in range(1, 25): + a = np.arange(n, dtype=dtype) + if np.dtype(dtype).itemsize > 1: + assert_equal(np.einsum("...,...", a, a, optimize=do_opt), + np.multiply(a, a)) + assert_equal(np.einsum("i,i", a, a, optimize=do_opt), np.dot(a, a)) + assert_equal(np.einsum("i,->i", a, 2, optimize=do_opt), 2*a) + assert_equal(np.einsum(",i->i", 2, a, optimize=do_opt), 2*a) + assert_equal(np.einsum("i,->", a, 2, optimize=do_opt), 2*np.sum(a)) + assert_equal(np.einsum(",i->", 2, a, optimize=do_opt), 2*np.sum(a)) + + assert_equal(np.einsum("...,...", a[1:], a[:-1], optimize=do_opt), + np.multiply(a[1:], a[:-1])) + assert_equal(np.einsum("i,i", a[1:], a[:-1], optimize=do_opt), + np.dot(a[1:], a[:-1])) + assert_equal(np.einsum("i,->i", a[1:], 2, optimize=do_opt), 2*a[1:]) + assert_equal(np.einsum(",i->i", 2, a[1:], optimize=do_opt), 2*a[1:]) + assert_equal(np.einsum("i,->", a[1:], 2, optimize=do_opt), + 2*np.sum(a[1:])) + assert_equal(np.einsum(",i->", 2, a[1:], optimize=do_opt), + 2*np.sum(a[1:])) + + # An object array, summed as the data type + a = np.arange(9, dtype=object) + + b = np.einsum("i->", a, dtype=dtype, casting='unsafe') + assert_equal(b, np.sum(a)) + if hasattr(b, "dtype"): + # Can be a python object when dtype is object + assert_equal(b.dtype, np.dtype(dtype)) + + b = np.einsum(a, [0], [], dtype=dtype, casting='unsafe') + assert_equal(b, np.sum(a)) + if hasattr(b, "dtype"): + # Can be a python object when dtype is object + assert_equal(b.dtype, np.dtype(dtype)) + + # A case which was failing (ticket #1885) + p = np.arange(2) + 1 + q = np.arange(4).reshape(2, 2) + 3 + r = np.arange(4).reshape(2, 2) + 7 + assert_equal(np.einsum('z,mz,zm->', p, q, r), 253) + + # singleton dimensions broadcast (gh-10343) + p = np.ones((10,2)) + q = np.ones((1,2)) + assert_array_equal(np.einsum('ij,ij->j', p, q, optimize=True), + np.einsum('ij,ij->j', p, q, optimize=False)) + assert_array_equal(np.einsum('ij,ij->j', p, q, optimize=True), + [10.] * 2) + + # a blas-compatible contraction broadcasting case which was failing + # for optimize=True (ticket #10930) + x = np.array([2., 3.]) + y = np.array([4.]) + assert_array_equal(np.einsum("i, i", x, y, optimize=False), 20.) + assert_array_equal(np.einsum("i, i", x, y, optimize=True), 20.) + + # all-ones array was bypassing bug (ticket #10930) + p = np.ones((1, 5)) / 2 + q = np.ones((5, 5)) / 2 + for optimize in (True, False): + assert_array_equal(np.einsum("...ij,...jk->...ik", p, p, + optimize=optimize), + np.einsum("...ij,...jk->...ik", p, q, + optimize=optimize)) + assert_array_equal(np.einsum("...ij,...jk->...ik", p, q, + optimize=optimize), + np.full((1, 5), 1.25)) + + # Cases which were failing (gh-10899) + x = np.eye(2, dtype=dtype) + y = np.ones(2, dtype=dtype) + assert_array_equal(np.einsum("ji,i->", x, y, optimize=optimize), + [2.]) # contig_contig_outstride0_two + assert_array_equal(np.einsum("i,ij->", y, x, optimize=optimize), + [2.]) # stride0_contig_outstride0_two + assert_array_equal(np.einsum("ij,i->", x, y, optimize=optimize), + [2.]) # contig_stride0_outstride0_two + + def test_einsum_sums_int8(self): + self.check_einsum_sums('i1') + + def test_einsum_sums_uint8(self): + self.check_einsum_sums('u1') + + def test_einsum_sums_int16(self): + self.check_einsum_sums('i2') + + def test_einsum_sums_uint16(self): + self.check_einsum_sums('u2') + + def test_einsum_sums_int32(self): + self.check_einsum_sums('i4') + self.check_einsum_sums('i4', True) + + def test_einsum_sums_uint32(self): + self.check_einsum_sums('u4') + self.check_einsum_sums('u4', True) + + def test_einsum_sums_int64(self): + self.check_einsum_sums('i8') + + def test_einsum_sums_uint64(self): + self.check_einsum_sums('u8') + + def test_einsum_sums_float16(self): + self.check_einsum_sums('f2') + + def test_einsum_sums_float32(self): + self.check_einsum_sums('f4') + + def test_einsum_sums_float64(self): + self.check_einsum_sums('f8') + self.check_einsum_sums('f8', True) + + def test_einsum_sums_longdouble(self): + self.check_einsum_sums(np.longdouble) + + def test_einsum_sums_cfloat64(self): + self.check_einsum_sums('c8') + self.check_einsum_sums('c8', True) + + def test_einsum_sums_cfloat128(self): + self.check_einsum_sums('c16') + + def test_einsum_sums_clongdouble(self): + self.check_einsum_sums(np.clongdouble) + + def test_einsum_sums_object(self): + self.check_einsum_sums('object') + self.check_einsum_sums('object', True) + + def test_einsum_misc(self): + # This call used to crash because of a bug in + # PyArray_AssignZero + a = np.ones((1, 2)) + b = np.ones((2, 2, 1)) + assert_equal(np.einsum('ij...,j...->i...', a, b), [[[2], [2]]]) + assert_equal(np.einsum('ij...,j...->i...', a, b, optimize=True), [[[2], [2]]]) + + # Regression test for issue #10369 (test unicode inputs with Python 2) + assert_equal(np.einsum('ij...,j...->i...', a, b), [[[2], [2]]]) + assert_equal(np.einsum('...i,...i', [1, 2, 3], [2, 3, 4]), 20) + assert_equal(np.einsum('...i,...i', [1, 2, 3], [2, 3, 4], + optimize='greedy'), 20) + + # The iterator had an issue with buffering this reduction + a = np.ones((5, 12, 4, 2, 3), np.int64) + b = np.ones((5, 12, 11), np.int64) + assert_equal(np.einsum('ijklm,ijn,ijn->', a, b, b), + np.einsum('ijklm,ijn->', a, b)) + assert_equal(np.einsum('ijklm,ijn,ijn->', a, b, b, optimize=True), + np.einsum('ijklm,ijn->', a, b, optimize=True)) + + # Issue #2027, was a problem in the contiguous 3-argument + # inner loop implementation + a = np.arange(1, 3) + b = np.arange(1, 5).reshape(2, 2) + c = np.arange(1, 9).reshape(4, 2) + assert_equal(np.einsum('x,yx,zx->xzy', a, b, c), + [[[1, 3], [3, 9], [5, 15], [7, 21]], + [[8, 16], [16, 32], [24, 48], [32, 64]]]) + assert_equal(np.einsum('x,yx,zx->xzy', a, b, c, optimize=True), + [[[1, 3], [3, 9], [5, 15], [7, 21]], + [[8, 16], [16, 32], [24, 48], [32, 64]]]) + + # Ensure explicitly setting out=None does not cause an error + # see issue gh-15776 and issue gh-15256 + assert_equal(np.einsum('i,j', [1], [2], out=None), [[2]]) + + def test_object_loop(self): + + class Mult: + def __mul__(self, other): + return 42 + + objMult = np.array([Mult()]) + objNULL = np.ndarray(buffer = b'\0' * np.intp(0).itemsize, shape=1, dtype=object) + + with pytest.raises(TypeError): + np.einsum("i,j", [1], objNULL) + with pytest.raises(TypeError): + np.einsum("i,j", objNULL, [1]) + assert np.einsum("i,j", objMult, objMult) == 42 + + def test_subscript_range(self): + # Issue #7741, make sure that all letters of Latin alphabet (both uppercase & lowercase) can be used + # when creating a subscript from arrays + a = np.ones((2, 3)) + b = np.ones((3, 4)) + np.einsum(a, [0, 20], b, [20, 2], [0, 2], optimize=False) + np.einsum(a, [0, 27], b, [27, 2], [0, 2], optimize=False) + np.einsum(a, [0, 51], b, [51, 2], [0, 2], optimize=False) + assert_raises(ValueError, lambda: np.einsum(a, [0, 52], b, [52, 2], [0, 2], optimize=False)) + assert_raises(ValueError, lambda: np.einsum(a, [-1, 5], b, [5, 2], [-1, 2], optimize=False)) + + def test_einsum_broadcast(self): + # Issue #2455 change in handling ellipsis + # remove the 'middle broadcast' error + # only use the 'RIGHT' iteration in prepare_op_axes + # adds auto broadcast on left where it belongs + # broadcast on right has to be explicit + # We need to test the optimized parsing as well + + A = np.arange(2 * 3 * 4).reshape(2, 3, 4) + B = np.arange(3) + ref = np.einsum('ijk,j->ijk', A, B, optimize=False) + for opt in [True, False]: + assert_equal(np.einsum('ij...,j...->ij...', A, B, optimize=opt), ref) + assert_equal(np.einsum('ij...,...j->ij...', A, B, optimize=opt), ref) + assert_equal(np.einsum('ij...,j->ij...', A, B, optimize=opt), ref) # used to raise error + + A = np.arange(12).reshape((4, 3)) + B = np.arange(6).reshape((3, 2)) + ref = np.einsum('ik,kj->ij', A, B, optimize=False) + for opt in [True, False]: + assert_equal(np.einsum('ik...,k...->i...', A, B, optimize=opt), ref) + assert_equal(np.einsum('ik...,...kj->i...j', A, B, optimize=opt), ref) + assert_equal(np.einsum('...k,kj', A, B, optimize=opt), ref) # used to raise error + assert_equal(np.einsum('ik,k...->i...', A, B, optimize=opt), ref) # used to raise error + + dims = [2, 3, 4, 5] + a = np.arange(np.prod(dims)).reshape(dims) + v = np.arange(dims[2]) + ref = np.einsum('ijkl,k->ijl', a, v, optimize=False) + for opt in [True, False]: + assert_equal(np.einsum('ijkl,k', a, v, optimize=opt), ref) + assert_equal(np.einsum('...kl,k', a, v, optimize=opt), ref) # used to raise error + assert_equal(np.einsum('...kl,k...', a, v, optimize=opt), ref) + + J, K, M = 160, 160, 120 + A = np.arange(J * K * M).reshape(1, 1, 1, J, K, M) + B = np.arange(J * K * M * 3).reshape(J, K, M, 3) + ref = np.einsum('...lmn,...lmno->...o', A, B, optimize=False) + for opt in [True, False]: + assert_equal(np.einsum('...lmn,lmno->...o', A, B, + optimize=opt), ref) # used to raise error + + def test_einsum_fixedstridebug(self): + # Issue #4485 obscure einsum bug + # This case revealed a bug in nditer where it reported a stride + # as 'fixed' (0) when it was in fact not fixed during processing + # (0 or 4). The reason for the bug was that the check for a fixed + # stride was using the information from the 2D inner loop reuse + # to restrict the iteration dimensions it had to validate to be + # the same, but that 2D inner loop reuse logic is only triggered + # during the buffer copying step, and hence it was invalid to + # rely on those values. The fix is to check all the dimensions + # of the stride in question, which in the test case reveals that + # the stride is not fixed. + # + # NOTE: This test is triggered by the fact that the default buffersize, + # used by einsum, is 8192, and 3*2731 = 8193, is larger than that + # and results in a mismatch between the buffering and the + # striding for operand A. + A = np.arange(2 * 3).reshape(2, 3).astype(np.float32) + B = np.arange(2 * 3 * 2731).reshape(2, 3, 2731).astype(np.int16) + es = np.einsum('cl, cpx->lpx', A, B) + tp = np.tensordot(A, B, axes=(0, 0)) + assert_equal(es, tp) + # The following is the original test case from the bug report, + # made repeatable by changing random arrays to aranges. + A = np.arange(3 * 3).reshape(3, 3).astype(np.float64) + B = np.arange(3 * 3 * 64 * 64).reshape(3, 3, 64, 64).astype(np.float32) + es = np.einsum('cl, cpxy->lpxy', A, B) + tp = np.tensordot(A, B, axes=(0, 0)) + assert_equal(es, tp) + + def test_einsum_fixed_collapsingbug(self): + # Issue #5147. + # The bug only occurred when output argument of einssum was used. + x = np.random.normal(0, 1, (5, 5, 5, 5)) + y1 = np.zeros((5, 5)) + np.einsum('aabb->ab', x, out=y1) + idx = np.arange(5) + y2 = x[idx[:, None], idx[:, None], idx, idx] + assert_equal(y1, y2) + + def test_einsum_failed_on_p9_and_s390x(self): + # Issues gh-14692 and gh-12689 + # Bug with signed vs unsigned char errored on power9 and s390x Linux + tensor = np.random.random_sample((10, 10, 10, 10)) + x = np.einsum('ijij->', tensor) + y = tensor.trace(axis1=0, axis2=2).trace() + assert_allclose(x, y) + + def test_einsum_all_contig_non_contig_output(self): + # Issue gh-5907, tests that the all contiguous special case + # actually checks the contiguity of the output + x = np.ones((5, 5)) + out = np.ones(10)[::2] + correct_base = np.ones(10) + correct_base[::2] = 5 + # Always worked (inner iteration is done with 0-stride): + np.einsum('mi,mi,mi->m', x, x, x, out=out) + assert_array_equal(out.base, correct_base) + # Example 1: + out = np.ones(10)[::2] + np.einsum('im,im,im->m', x, x, x, out=out) + assert_array_equal(out.base, correct_base) + # Example 2, buffering causes x to be contiguous but + # special cases do not catch the operation before: + out = np.ones((2, 2, 2))[..., 0] + correct_base = np.ones((2, 2, 2)) + correct_base[..., 0] = 2 + x = np.ones((2, 2), np.float32) + np.einsum('ij,jk->ik', x, x, out=out) + assert_array_equal(out.base, correct_base) + + @pytest.mark.parametrize("dtype", + np.typecodes["AllFloat"] + np.typecodes["AllInteger"]) + def test_different_paths(self, dtype): + # Test originally added to cover broken float16 path: gh-20305 + # Likely most are covered elsewhere, at least partially. + dtype = np.dtype(dtype) + # Simple test, designed to exercise most specialized code paths, + # note the +0.5 for floats. This makes sure we use a float value + # where the results must be exact. + arr = (np.arange(7) + 0.5).astype(dtype) + scalar = np.array(2, dtype=dtype) + + # contig -> scalar: + res = np.einsum('i->', arr) + assert res == arr.sum() + # contig, contig -> contig: + res = np.einsum('i,i->i', arr, arr) + assert_array_equal(res, arr * arr) + # noncontig, noncontig -> contig: + res = np.einsum('i,i->i', arr.repeat(2)[::2], arr.repeat(2)[::2]) + assert_array_equal(res, arr * arr) + # contig + contig -> scalar + assert np.einsum('i,i->', arr, arr) == (arr * arr).sum() + # contig + scalar -> contig (with out) + out = np.ones(7, dtype=dtype) + res = np.einsum('i,->i', arr, dtype.type(2), out=out) + assert_array_equal(res, arr * dtype.type(2)) + # scalar + contig -> contig (with out) + res = np.einsum(',i->i', scalar, arr) + assert_array_equal(res, arr * dtype.type(2)) + # scalar + contig -> scalar + res = np.einsum(',i->', scalar, arr) + # Use einsum to compare to not have difference due to sum round-offs: + assert res == np.einsum('i->', scalar * arr) + # contig + scalar -> scalar + res = np.einsum('i,->', arr, scalar) + # Use einsum to compare to not have difference due to sum round-offs: + assert res == np.einsum('i->', scalar * arr) + # contig + contig + contig -> scalar + arr = np.array([0.5, 0.5, 0.25, 4.5, 3.], dtype=dtype) + res = np.einsum('i,i,i->', arr, arr, arr) + assert_array_equal(res, (arr * arr * arr).sum()) + # four arrays: + res = np.einsum('i,i,i,i->', arr, arr, arr, arr) + assert_array_equal(res, (arr * arr * arr * arr).sum()) + + def test_small_boolean_arrays(self): + # See gh-5946. + # Use array of True embedded in False. + a = np.zeros((16, 1, 1), dtype=np.bool)[:2] + a[...] = True + out = np.zeros((16, 1, 1), dtype=np.bool)[:2] + tgt = np.ones((2, 1, 1), dtype=np.bool) + res = np.einsum('...ij,...jk->...ik', a, a, out=out) + assert_equal(res, tgt) + + def test_out_is_res(self): + a = np.arange(9).reshape(3, 3) + res = np.einsum('...ij,...jk->...ik', a, a, out=a) + assert res is a + + def optimize_compare(self, subscripts, operands=None): + # Tests all paths of the optimization function against + # conventional einsum + if operands is None: + args = [subscripts] + terms = subscripts.split('->')[0].split(',') + for term in terms: + dims = [global_size_dict[x] for x in term] + args.append(np.random.rand(*dims)) + else: + args = [subscripts] + operands + + noopt = np.einsum(*args, optimize=False) + opt = np.einsum(*args, optimize='greedy') + assert_almost_equal(opt, noopt) + opt = np.einsum(*args, optimize='optimal') + assert_almost_equal(opt, noopt) + + def test_hadamard_like_products(self): + # Hadamard outer products + self.optimize_compare('a,ab,abc->abc') + self.optimize_compare('a,b,ab->ab') + + def test_index_transformations(self): + # Simple index transformation cases + self.optimize_compare('ea,fb,gc,hd,abcd->efgh') + self.optimize_compare('ea,fb,abcd,gc,hd->efgh') + self.optimize_compare('abcd,ea,fb,gc,hd->efgh') + + def test_complex(self): + # Long test cases + self.optimize_compare('acdf,jbje,gihb,hfac,gfac,gifabc,hfac') + self.optimize_compare('acdf,jbje,gihb,hfac,gfac,gifabc,hfac') + self.optimize_compare('cd,bdhe,aidb,hgca,gc,hgibcd,hgac') + self.optimize_compare('abhe,hidj,jgba,hiab,gab') + self.optimize_compare('bde,cdh,agdb,hica,ibd,hgicd,hiac') + self.optimize_compare('chd,bde,agbc,hiad,hgc,hgi,hiad') + self.optimize_compare('chd,bde,agbc,hiad,bdi,cgh,agdb') + self.optimize_compare('bdhe,acad,hiab,agac,hibd') + + def test_collapse(self): + # Inner products + self.optimize_compare('ab,ab,c->') + self.optimize_compare('ab,ab,c->c') + self.optimize_compare('ab,ab,cd,cd->') + self.optimize_compare('ab,ab,cd,cd->ac') + self.optimize_compare('ab,ab,cd,cd->cd') + self.optimize_compare('ab,ab,cd,cd,ef,ef->') + + def test_expand(self): + # Outer products + self.optimize_compare('ab,cd,ef->abcdef') + self.optimize_compare('ab,cd,ef->acdf') + self.optimize_compare('ab,cd,de->abcde') + self.optimize_compare('ab,cd,de->be') + self.optimize_compare('ab,bcd,cd->abcd') + self.optimize_compare('ab,bcd,cd->abd') + + def test_edge_cases(self): + # Difficult edge cases for optimization + self.optimize_compare('eb,cb,fb->cef') + self.optimize_compare('dd,fb,be,cdb->cef') + self.optimize_compare('bca,cdb,dbf,afc->') + self.optimize_compare('dcc,fce,ea,dbf->ab') + self.optimize_compare('fdf,cdd,ccd,afe->ae') + self.optimize_compare('abcd,ad') + self.optimize_compare('ed,fcd,ff,bcf->be') + self.optimize_compare('baa,dcf,af,cde->be') + self.optimize_compare('bd,db,eac->ace') + self.optimize_compare('fff,fae,bef,def->abd') + self.optimize_compare('efc,dbc,acf,fd->abe') + self.optimize_compare('ba,ac,da->bcd') + + def test_inner_product(self): + # Inner products + self.optimize_compare('ab,ab') + self.optimize_compare('ab,ba') + self.optimize_compare('abc,abc') + self.optimize_compare('abc,bac') + self.optimize_compare('abc,cba') + + def test_random_cases(self): + # Randomly built test cases + self.optimize_compare('aab,fa,df,ecc->bde') + self.optimize_compare('ecb,fef,bad,ed->ac') + self.optimize_compare('bcf,bbb,fbf,fc->') + self.optimize_compare('bb,ff,be->e') + self.optimize_compare('bcb,bb,fc,fff->') + self.optimize_compare('fbb,dfd,fc,fc->') + self.optimize_compare('afd,ba,cc,dc->bf') + self.optimize_compare('adb,bc,fa,cfc->d') + self.optimize_compare('bbd,bda,fc,db->acf') + self.optimize_compare('dba,ead,cad->bce') + self.optimize_compare('aef,fbc,dca->bde') + + def test_combined_views_mapping(self): + # gh-10792 + a = np.arange(9).reshape(1, 1, 3, 1, 3) + b = np.einsum('bbcdc->d', a) + assert_equal(b, [12]) + + def test_broadcasting_dot_cases(self): + # Ensures broadcasting cases are not mistaken for GEMM + + a = np.random.rand(1, 5, 4) + b = np.random.rand(4, 6) + c = np.random.rand(5, 6) + d = np.random.rand(10) + + self.optimize_compare('ijk,kl,jl', operands=[a, b, c]) + self.optimize_compare('ijk,kl,jl,i->i', operands=[a, b, c, d]) + + e = np.random.rand(1, 1, 5, 4) + f = np.random.rand(7, 7) + self.optimize_compare('abjk,kl,jl', operands=[e, b, c]) + self.optimize_compare('abjk,kl,jl,ab->ab', operands=[e, b, c, f]) + + # Edge case found in gh-11308 + g = np.arange(64).reshape(2, 4, 8) + self.optimize_compare('obk,ijk->ioj', operands=[g, g]) + + def test_output_order(self): + # Ensure output order is respected for optimize cases, the below + # conraction should yield a reshaped tensor view + # gh-16415 + + a = np.ones((2, 3, 5), order='F') + b = np.ones((4, 3), order='F') + + for opt in [True, False]: + tmp = np.einsum('...ft,mf->...mt', a, b, order='a', optimize=opt) + assert_(tmp.flags.f_contiguous) + + tmp = np.einsum('...ft,mf->...mt', a, b, order='f', optimize=opt) + assert_(tmp.flags.f_contiguous) + + tmp = np.einsum('...ft,mf->...mt', a, b, order='c', optimize=opt) + assert_(tmp.flags.c_contiguous) + + tmp = np.einsum('...ft,mf->...mt', a, b, order='k', optimize=opt) + assert_(tmp.flags.c_contiguous is False) + assert_(tmp.flags.f_contiguous is False) + + tmp = np.einsum('...ft,mf->...mt', a, b, optimize=opt) + assert_(tmp.flags.c_contiguous is False) + assert_(tmp.flags.f_contiguous is False) + + c = np.ones((4, 3), order='C') + for opt in [True, False]: + tmp = np.einsum('...ft,mf->...mt', a, c, order='a', optimize=opt) + assert_(tmp.flags.c_contiguous) + + d = np.ones((2, 3, 5), order='C') + for opt in [True, False]: + tmp = np.einsum('...ft,mf->...mt', d, c, order='a', optimize=opt) + assert_(tmp.flags.c_contiguous) + +class TestEinsumPath: + def build_operands(self, string, size_dict=global_size_dict): + + # Builds views based off initial operands + operands = [string] + terms = string.split('->')[0].split(',') + for term in terms: + dims = [size_dict[x] for x in term] + operands.append(np.random.rand(*dims)) + + return operands + + def assert_path_equal(self, comp, benchmark): + # Checks if list of tuples are equivalent + ret = (len(comp) == len(benchmark)) + assert_(ret) + for pos in range(len(comp) - 1): + ret &= isinstance(comp[pos + 1], tuple) + ret &= (comp[pos + 1] == benchmark[pos + 1]) + assert_(ret) + + def test_memory_contraints(self): + # Ensure memory constraints are satisfied + + outer_test = self.build_operands('a,b,c->abc') + + path, path_str = np.einsum_path(*outer_test, optimize=('greedy', 0)) + self.assert_path_equal(path, ['einsum_path', (0, 1, 2)]) + + path, path_str = np.einsum_path(*outer_test, optimize=('optimal', 0)) + self.assert_path_equal(path, ['einsum_path', (0, 1, 2)]) + + long_test = self.build_operands('acdf,jbje,gihb,hfac') + path, path_str = np.einsum_path(*long_test, optimize=('greedy', 0)) + self.assert_path_equal(path, ['einsum_path', (0, 1, 2, 3)]) + + path, path_str = np.einsum_path(*long_test, optimize=('optimal', 0)) + self.assert_path_equal(path, ['einsum_path', (0, 1, 2, 3)]) + + def test_long_paths(self): + # Long complex cases + + # Long test 1 + long_test1 = self.build_operands('acdf,jbje,gihb,hfac,gfac,gifabc,hfac') + path, path_str = np.einsum_path(*long_test1, optimize='greedy') + self.assert_path_equal(path, ['einsum_path', + (3, 6), (3, 4), (2, 4), (2, 3), (0, 2), (0, 1)]) + + path, path_str = np.einsum_path(*long_test1, optimize='optimal') + self.assert_path_equal(path, ['einsum_path', + (3, 6), (3, 4), (2, 4), (2, 3), (0, 2), (0, 1)]) + + # Long test 2 + long_test2 = self.build_operands('chd,bde,agbc,hiad,bdi,cgh,agdb') + path, path_str = np.einsum_path(*long_test2, optimize='greedy') + self.assert_path_equal(path, ['einsum_path', + (3, 4), (0, 3), (3, 4), (1, 3), (1, 2), (0, 1)]) + + path, path_str = np.einsum_path(*long_test2, optimize='optimal') + self.assert_path_equal(path, ['einsum_path', + (0, 5), (1, 4), (3, 4), (1, 3), (1, 2), (0, 1)]) + + def test_edge_paths(self): + # Difficult edge cases + + # Edge test1 + edge_test1 = self.build_operands('eb,cb,fb->cef') + path, path_str = np.einsum_path(*edge_test1, optimize='greedy') + self.assert_path_equal(path, ['einsum_path', (0, 2), (0, 1)]) + + path, path_str = np.einsum_path(*edge_test1, optimize='optimal') + self.assert_path_equal(path, ['einsum_path', (0, 2), (0, 1)]) + + # Edge test2 + edge_test2 = self.build_operands('dd,fb,be,cdb->cef') + path, path_str = np.einsum_path(*edge_test2, optimize='greedy') + self.assert_path_equal(path, ['einsum_path', (0, 3), (0, 1), (0, 1)]) + + path, path_str = np.einsum_path(*edge_test2, optimize='optimal') + self.assert_path_equal(path, ['einsum_path', (0, 3), (0, 1), (0, 1)]) + + # Edge test3 + edge_test3 = self.build_operands('bca,cdb,dbf,afc->') + path, path_str = np.einsum_path(*edge_test3, optimize='greedy') + self.assert_path_equal(path, ['einsum_path', (1, 2), (0, 2), (0, 1)]) + + path, path_str = np.einsum_path(*edge_test3, optimize='optimal') + self.assert_path_equal(path, ['einsum_path', (1, 2), (0, 2), (0, 1)]) + + # Edge test4 + edge_test4 = self.build_operands('dcc,fce,ea,dbf->ab') + path, path_str = np.einsum_path(*edge_test4, optimize='greedy') + self.assert_path_equal(path, ['einsum_path', (1, 2), (0, 1), (0, 1)]) + + path, path_str = np.einsum_path(*edge_test4, optimize='optimal') + self.assert_path_equal(path, ['einsum_path', (1, 2), (0, 2), (0, 1)]) + + # Edge test5 + edge_test4 = self.build_operands('a,ac,ab,ad,cd,bd,bc->', + size_dict={"a": 20, "b": 20, "c": 20, "d": 20}) + path, path_str = np.einsum_path(*edge_test4, optimize='greedy') + self.assert_path_equal(path, ['einsum_path', (0, 1), (0, 1, 2, 3, 4, 5)]) + + path, path_str = np.einsum_path(*edge_test4, optimize='optimal') + self.assert_path_equal(path, ['einsum_path', (0, 1), (0, 1, 2, 3, 4, 5)]) + + def test_path_type_input(self): + # Test explicit path handling + path_test = self.build_operands('dcc,fce,ea,dbf->ab') + + path, path_str = np.einsum_path(*path_test, optimize=False) + self.assert_path_equal(path, ['einsum_path', (0, 1, 2, 3)]) + + path, path_str = np.einsum_path(*path_test, optimize=True) + self.assert_path_equal(path, ['einsum_path', (1, 2), (0, 1), (0, 1)]) + + exp_path = ['einsum_path', (0, 2), (0, 2), (0, 1)] + path, path_str = np.einsum_path(*path_test, optimize=exp_path) + self.assert_path_equal(path, exp_path) + + # Double check einsum works on the input path + noopt = np.einsum(*path_test, optimize=False) + opt = np.einsum(*path_test, optimize=exp_path) + assert_almost_equal(noopt, opt) + + def test_path_type_input_internal_trace(self): + #gh-20962 + path_test = self.build_operands('cab,cdd->ab') + exp_path = ['einsum_path', (1,), (0, 1)] + + path, path_str = np.einsum_path(*path_test, optimize=exp_path) + self.assert_path_equal(path, exp_path) + + # Double check einsum works on the input path + noopt = np.einsum(*path_test, optimize=False) + opt = np.einsum(*path_test, optimize=exp_path) + assert_almost_equal(noopt, opt) + + def test_path_type_input_invalid(self): + path_test = self.build_operands('ab,bc,cd,de->ae') + exp_path = ['einsum_path', (2, 3), (0, 1)] + assert_raises(RuntimeError, np.einsum, *path_test, optimize=exp_path) + assert_raises( + RuntimeError, np.einsum_path, *path_test, optimize=exp_path) + + path_test = self.build_operands('a,a,a->a') + exp_path = ['einsum_path', (1,), (0, 1)] + assert_raises(RuntimeError, np.einsum, *path_test, optimize=exp_path) + assert_raises( + RuntimeError, np.einsum_path, *path_test, optimize=exp_path) + + def test_spaces(self): + #gh-10794 + arr = np.array([[1]]) + for sp in itertools.product(['', ' '], repeat=4): + # no error for any spacing + np.einsum('{}...a{}->{}...a{}'.format(*sp), arr) + +def test_overlap(): + a = np.arange(9, dtype=int).reshape(3, 3) + b = np.arange(9, dtype=int).reshape(3, 3) + d = np.dot(a, b) + # sanity check + c = np.einsum('ij,jk->ik', a, b) + assert_equal(c, d) + #gh-10080, out overlaps one of the operands + c = np.einsum('ij,jk->ik', a, b, out=b) + assert_equal(c, d) diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/test_errstate.py b/venv/lib/python3.12/site-packages/numpy/_core/tests/test_errstate.py new file mode 100644 index 00000000..bd6b8b8c --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/tests/test_errstate.py @@ -0,0 +1,129 @@ +import pytest +import sysconfig + +import numpy as np +from numpy.testing import assert_, assert_raises, IS_WASM + +# The floating point emulation on ARM EABI systems lacking a hardware FPU is +# known to be buggy. This is an attempt to identify these hosts. It may not +# catch all possible cases, but it catches the known cases of gh-413 and +# gh-15562. +hosttype = sysconfig.get_config_var('HOST_GNU_TYPE') +arm_softfloat = False if hosttype is None else hosttype.endswith('gnueabi') + +class TestErrstate: + @pytest.mark.skipif(IS_WASM, reason="fp errors don't work in wasm") + @pytest.mark.skipif(arm_softfloat, + reason='platform/cpu issue with FPU (gh-413,-15562)') + def test_invalid(self): + with np.errstate(all='raise', under='ignore'): + a = -np.arange(3) + # This should work + with np.errstate(invalid='ignore'): + np.sqrt(a) + # While this should fail! + with assert_raises(FloatingPointError): + np.sqrt(a) + + @pytest.mark.skipif(IS_WASM, reason="fp errors don't work in wasm") + @pytest.mark.skipif(arm_softfloat, + reason='platform/cpu issue with FPU (gh-15562)') + def test_divide(self): + with np.errstate(all='raise', under='ignore'): + a = -np.arange(3) + # This should work + with np.errstate(divide='ignore'): + a // 0 + # While this should fail! + with assert_raises(FloatingPointError): + a // 0 + # As should this, see gh-15562 + with assert_raises(FloatingPointError): + a // a + + @pytest.mark.skipif(IS_WASM, reason="fp errors don't work in wasm") + @pytest.mark.skipif(arm_softfloat, + reason='platform/cpu issue with FPU (gh-15562)') + def test_errcall(self): + count = 0 + def foo(*args): + nonlocal count + count += 1 + + olderrcall = np.geterrcall() + with np.errstate(call=foo): + assert np.geterrcall() is foo + with np.errstate(call=None): + assert np.geterrcall() is None + assert np.geterrcall() is olderrcall + assert count == 0 + + with np.errstate(call=foo, invalid="call"): + np.array(np.inf) - np.array(np.inf) + + assert count == 1 + + def test_errstate_decorator(self): + @np.errstate(all='ignore') + def foo(): + a = -np.arange(3) + a // 0 + + foo() + + def test_errstate_enter_once(self): + errstate = np.errstate(invalid="warn") + with errstate: + pass + + # The errstate context cannot be entered twice as that would not be + # thread-safe + with pytest.raises(TypeError, + match="Cannot enter `np.errstate` twice"): + with errstate: + pass + + @pytest.mark.skipif(IS_WASM, reason="wasm doesn't support asyncio") + def test_asyncio_safe(self): + # asyncio may not always work, lets assume its fine if missing + # Pyodide/wasm doesn't support it. If this test makes problems, + # it should just be skipped liberally (or run differently). + asyncio = pytest.importorskip("asyncio") + + @np.errstate(invalid="ignore") + def decorated(): + # Decorated non-async function (it is not safe to decorate an + # async one) + assert np.geterr()["invalid"] == "ignore" + + async def func1(): + decorated() + await asyncio.sleep(0.1) + decorated() + + async def func2(): + with np.errstate(invalid="raise"): + assert np.geterr()["invalid"] == "raise" + await asyncio.sleep(0.125) + assert np.geterr()["invalid"] == "raise" + + # for good sport, a third one with yet another state: + async def func3(): + with np.errstate(invalid="print"): + assert np.geterr()["invalid"] == "print" + await asyncio.sleep(0.11) + assert np.geterr()["invalid"] == "print" + + async def main(): + # simply run all three function multiple times: + await asyncio.gather( + func1(), func2(), func3(), func1(), func2(), func3(), + func1(), func2(), func3(), func1(), func2(), func3()) + + loop = asyncio.new_event_loop() + with np.errstate(invalid="warn"): + asyncio.run(main()) + assert np.geterr()["invalid"] == "warn" + + assert np.geterr()["invalid"] == "warn" # the default + loop.close() diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/test_extint128.py b/venv/lib/python3.12/site-packages/numpy/_core/tests/test_extint128.py new file mode 100644 index 00000000..bd97cc20 --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/tests/test_extint128.py @@ -0,0 +1,219 @@ +import itertools +import contextlib +import operator +import pytest + +import numpy as np +import numpy._core._multiarray_tests as mt + +from numpy.testing import assert_raises, assert_equal + + +INT64_MAX = np.iinfo(np.int64).max +INT64_MIN = np.iinfo(np.int64).min +INT64_MID = 2**32 + +# int128 is not two's complement, the sign bit is separate +INT128_MAX = 2**128 - 1 +INT128_MIN = -INT128_MAX +INT128_MID = 2**64 + +INT64_VALUES = ( + [INT64_MIN + j for j in range(20)] + + [INT64_MAX - j for j in range(20)] + + [INT64_MID + j for j in range(-20, 20)] + + [2*INT64_MID + j for j in range(-20, 20)] + + [INT64_MID//2 + j for j in range(-20, 20)] + + list(range(-70, 70)) +) + +INT128_VALUES = ( + [INT128_MIN + j for j in range(20)] + + [INT128_MAX - j for j in range(20)] + + [INT128_MID + j for j in range(-20, 20)] + + [2*INT128_MID + j for j in range(-20, 20)] + + [INT128_MID//2 + j for j in range(-20, 20)] + + list(range(-70, 70)) + + [False] # negative zero +) + +INT64_POS_VALUES = [x for x in INT64_VALUES if x > 0] + + +@contextlib.contextmanager +def exc_iter(*args): + """ + Iterate over Cartesian product of *args, and if an exception is raised, + add information of the current iterate. + """ + + value = [None] + + def iterate(): + for v in itertools.product(*args): + value[0] = v + yield v + + try: + yield iterate() + except Exception: + import traceback + msg = "At: %r\n%s" % (repr(value[0]), + traceback.format_exc()) + raise AssertionError(msg) + + +def test_safe_binop(): + # Test checked arithmetic routines + + ops = [ + (operator.add, 1), + (operator.sub, 2), + (operator.mul, 3) + ] + + with exc_iter(ops, INT64_VALUES, INT64_VALUES) as it: + for xop, a, b in it: + pyop, op = xop + c = pyop(a, b) + + if not (INT64_MIN <= c <= INT64_MAX): + assert_raises(OverflowError, mt.extint_safe_binop, a, b, op) + else: + d = mt.extint_safe_binop(a, b, op) + if c != d: + # assert_equal is slow + assert_equal(d, c) + + +def test_to_128(): + with exc_iter(INT64_VALUES) as it: + for a, in it: + b = mt.extint_to_128(a) + if a != b: + assert_equal(b, a) + + +def test_to_64(): + with exc_iter(INT128_VALUES) as it: + for a, in it: + if not (INT64_MIN <= a <= INT64_MAX): + assert_raises(OverflowError, mt.extint_to_64, a) + else: + b = mt.extint_to_64(a) + if a != b: + assert_equal(b, a) + + +def test_mul_64_64(): + with exc_iter(INT64_VALUES, INT64_VALUES) as it: + for a, b in it: + c = a * b + d = mt.extint_mul_64_64(a, b) + if c != d: + assert_equal(d, c) + + +def test_add_128(): + with exc_iter(INT128_VALUES, INT128_VALUES) as it: + for a, b in it: + c = a + b + if not (INT128_MIN <= c <= INT128_MAX): + assert_raises(OverflowError, mt.extint_add_128, a, b) + else: + d = mt.extint_add_128(a, b) + if c != d: + assert_equal(d, c) + + +def test_sub_128(): + with exc_iter(INT128_VALUES, INT128_VALUES) as it: + for a, b in it: + c = a - b + if not (INT128_MIN <= c <= INT128_MAX): + assert_raises(OverflowError, mt.extint_sub_128, a, b) + else: + d = mt.extint_sub_128(a, b) + if c != d: + assert_equal(d, c) + + +def test_neg_128(): + with exc_iter(INT128_VALUES) as it: + for a, in it: + b = -a + c = mt.extint_neg_128(a) + if b != c: + assert_equal(c, b) + + +def test_shl_128(): + with exc_iter(INT128_VALUES) as it: + for a, in it: + if a < 0: + b = -(((-a) << 1) & (2**128-1)) + else: + b = (a << 1) & (2**128-1) + c = mt.extint_shl_128(a) + if b != c: + assert_equal(c, b) + + +def test_shr_128(): + with exc_iter(INT128_VALUES) as it: + for a, in it: + if a < 0: + b = -((-a) >> 1) + else: + b = a >> 1 + c = mt.extint_shr_128(a) + if b != c: + assert_equal(c, b) + + +def test_gt_128(): + with exc_iter(INT128_VALUES, INT128_VALUES) as it: + for a, b in it: + c = a > b + d = mt.extint_gt_128(a, b) + if c != d: + assert_equal(d, c) + + +@pytest.mark.slow +def test_divmod_128_64(): + with exc_iter(INT128_VALUES, INT64_POS_VALUES) as it: + for a, b in it: + if a >= 0: + c, cr = divmod(a, b) + else: + c, cr = divmod(-a, b) + c = -c + cr = -cr + + d, dr = mt.extint_divmod_128_64(a, b) + + if c != d or d != dr or b*d + dr != a: + assert_equal(d, c) + assert_equal(dr, cr) + assert_equal(b*d + dr, a) + + +def test_floordiv_128_64(): + with exc_iter(INT128_VALUES, INT64_POS_VALUES) as it: + for a, b in it: + c = a // b + d = mt.extint_floordiv_128_64(a, b) + + if c != d: + assert_equal(d, c) + + +def test_ceildiv_128_64(): + with exc_iter(INT128_VALUES, INT64_POS_VALUES) as it: + for a, b in it: + c = (a + b - 1) // b + d = mt.extint_ceildiv_128_64(a, b) + + if c != d: + assert_equal(d, c) diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/test_function_base.py b/venv/lib/python3.12/site-packages/numpy/_core/tests/test_function_base.py new file mode 100644 index 00000000..33394321 --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/tests/test_function_base.py @@ -0,0 +1,482 @@ +import sys + +import pytest + +import numpy as np +from numpy import ( + logspace, linspace, geomspace, dtype, array, arange, isnan, + ndarray, sqrt, nextafter, stack, errstate + ) +from numpy._core import sctypes +from numpy._core.function_base import add_newdoc +from numpy.testing import ( + assert_, assert_equal, assert_raises, assert_array_equal, assert_allclose, + IS_PYPY + ) + + +class PhysicalQuantity(float): + def __new__(cls, value): + return float.__new__(cls, value) + + def __add__(self, x): + assert_(isinstance(x, PhysicalQuantity)) + return PhysicalQuantity(float(x) + float(self)) + __radd__ = __add__ + + def __sub__(self, x): + assert_(isinstance(x, PhysicalQuantity)) + return PhysicalQuantity(float(self) - float(x)) + + def __rsub__(self, x): + assert_(isinstance(x, PhysicalQuantity)) + return PhysicalQuantity(float(x) - float(self)) + + def __mul__(self, x): + return PhysicalQuantity(float(x) * float(self)) + __rmul__ = __mul__ + + def __div__(self, x): + return PhysicalQuantity(float(self) / float(x)) + + def __rdiv__(self, x): + return PhysicalQuantity(float(x) / float(self)) + + +class PhysicalQuantity2(ndarray): + __array_priority__ = 10 + + +class TestLogspace: + + def test_basic(self): + y = logspace(0, 6) + assert_(len(y) == 50) + y = logspace(0, 6, num=100) + assert_(y[-1] == 10 ** 6) + y = logspace(0, 6, endpoint=False) + assert_(y[-1] < 10 ** 6) + y = logspace(0, 6, num=7) + assert_array_equal(y, [1, 10, 100, 1e3, 1e4, 1e5, 1e6]) + + def test_start_stop_array(self): + start = array([0., 1.]) + stop = array([6., 7.]) + t1 = logspace(start, stop, 6) + t2 = stack([logspace(_start, _stop, 6) + for _start, _stop in zip(start, stop)], axis=1) + assert_equal(t1, t2) + t3 = logspace(start, stop[0], 6) + t4 = stack([logspace(_start, stop[0], 6) + for _start in start], axis=1) + assert_equal(t3, t4) + t5 = logspace(start, stop, 6, axis=-1) + assert_equal(t5, t2.T) + + @pytest.mark.parametrize("axis", [0, 1, -1]) + def test_base_array(self, axis: int): + start = 1 + stop = 2 + num = 6 + base = array([1, 2]) + t1 = logspace(start, stop, num=num, base=base, axis=axis) + t2 = stack( + [logspace(start, stop, num=num, base=_base) for _base in base], + axis=(axis + 1) % t1.ndim, + ) + assert_equal(t1, t2) + + @pytest.mark.parametrize("axis", [0, 1, -1]) + def test_stop_base_array(self, axis: int): + start = 1 + stop = array([2, 3]) + num = 6 + base = array([1, 2]) + t1 = logspace(start, stop, num=num, base=base, axis=axis) + t2 = stack( + [logspace(start, _stop, num=num, base=_base) + for _stop, _base in zip(stop, base)], + axis=(axis + 1) % t1.ndim, + ) + assert_equal(t1, t2) + + def test_dtype(self): + y = logspace(0, 6, dtype='float32') + assert_equal(y.dtype, dtype('float32')) + y = logspace(0, 6, dtype='float64') + assert_equal(y.dtype, dtype('float64')) + y = logspace(0, 6, dtype='int32') + assert_equal(y.dtype, dtype('int32')) + + def test_physical_quantities(self): + a = PhysicalQuantity(1.0) + b = PhysicalQuantity(5.0) + assert_equal(logspace(a, b), logspace(1.0, 5.0)) + + def test_subclass(self): + a = array(1).view(PhysicalQuantity2) + b = array(7).view(PhysicalQuantity2) + ls = logspace(a, b) + assert type(ls) is PhysicalQuantity2 + assert_equal(ls, logspace(1.0, 7.0)) + ls = logspace(a, b, 1) + assert type(ls) is PhysicalQuantity2 + assert_equal(ls, logspace(1.0, 7.0, 1)) + + +class TestGeomspace: + + def test_basic(self): + y = geomspace(1, 1e6) + assert_(len(y) == 50) + y = geomspace(1, 1e6, num=100) + assert_(y[-1] == 10 ** 6) + y = geomspace(1, 1e6, endpoint=False) + assert_(y[-1] < 10 ** 6) + y = geomspace(1, 1e6, num=7) + assert_array_equal(y, [1, 10, 100, 1e3, 1e4, 1e5, 1e6]) + + y = geomspace(8, 2, num=3) + assert_allclose(y, [8, 4, 2]) + assert_array_equal(y.imag, 0) + + y = geomspace(-1, -100, num=3) + assert_array_equal(y, [-1, -10, -100]) + assert_array_equal(y.imag, 0) + + y = geomspace(-100, -1, num=3) + assert_array_equal(y, [-100, -10, -1]) + assert_array_equal(y.imag, 0) + + def test_boundaries_match_start_and_stop_exactly(self): + # make sure that the boundaries of the returned array exactly + # equal 'start' and 'stop' - this isn't obvious because + # np.exp(np.log(x)) isn't necessarily exactly equal to x + start = 0.3 + stop = 20.3 + + y = geomspace(start, stop, num=1) + assert_equal(y[0], start) + + y = geomspace(start, stop, num=1, endpoint=False) + assert_equal(y[0], start) + + y = geomspace(start, stop, num=3) + assert_equal(y[0], start) + assert_equal(y[-1], stop) + + y = geomspace(start, stop, num=3, endpoint=False) + assert_equal(y[0], start) + + def test_nan_interior(self): + with errstate(invalid='ignore'): + y = geomspace(-3, 3, num=4) + + assert_equal(y[0], -3.0) + assert_(isnan(y[1:-1]).all()) + assert_equal(y[3], 3.0) + + with errstate(invalid='ignore'): + y = geomspace(-3, 3, num=4, endpoint=False) + + assert_equal(y[0], -3.0) + assert_(isnan(y[1:]).all()) + + def test_complex(self): + # Purely imaginary + y = geomspace(1j, 16j, num=5) + assert_allclose(y, [1j, 2j, 4j, 8j, 16j]) + assert_array_equal(y.real, 0) + + y = geomspace(-4j, -324j, num=5) + assert_allclose(y, [-4j, -12j, -36j, -108j, -324j]) + assert_array_equal(y.real, 0) + + y = geomspace(1+1j, 1000+1000j, num=4) + assert_allclose(y, [1+1j, 10+10j, 100+100j, 1000+1000j]) + + y = geomspace(-1+1j, -1000+1000j, num=4) + assert_allclose(y, [-1+1j, -10+10j, -100+100j, -1000+1000j]) + + # Logarithmic spirals + y = geomspace(-1, 1, num=3, dtype=complex) + assert_allclose(y, [-1, 1j, +1]) + + y = geomspace(0+3j, -3+0j, 3) + assert_allclose(y, [0+3j, -3/sqrt(2)+3j/sqrt(2), -3+0j]) + y = geomspace(0+3j, 3+0j, 3) + assert_allclose(y, [0+3j, 3/sqrt(2)+3j/sqrt(2), 3+0j]) + y = geomspace(-3+0j, 0-3j, 3) + assert_allclose(y, [-3+0j, -3/sqrt(2)-3j/sqrt(2), 0-3j]) + y = geomspace(0+3j, -3+0j, 3) + assert_allclose(y, [0+3j, -3/sqrt(2)+3j/sqrt(2), -3+0j]) + y = geomspace(-2-3j, 5+7j, 7) + assert_allclose(y, [-2-3j, -0.29058977-4.15771027j, + 2.08885354-4.34146838j, 4.58345529-3.16355218j, + 6.41401745-0.55233457j, 6.75707386+3.11795092j, + 5+7j]) + + # Type promotion should prevent the -5 from becoming a NaN + y = geomspace(3j, -5, 2) + assert_allclose(y, [3j, -5]) + y = geomspace(-5, 3j, 2) + assert_allclose(y, [-5, 3j]) + + def test_complex_shortest_path(self): + # test the shortest logarithmic spiral is used, see gh-25644 + x = 1.2 + 3.4j + y = np.exp(1j*(np.pi-.1)) * x + z = np.geomspace(x, y, 5) + expected = np.array([1.2 + 3.4j, -1.47384 + 3.2905616j, + -3.33577588 + 1.36842949j, -3.36011056 - 1.30753855j, + -1.53343861 - 3.26321406j]) + np.testing.assert_array_almost_equal(z, expected) + + + def test_dtype(self): + y = geomspace(1, 1e6, dtype='float32') + assert_equal(y.dtype, dtype('float32')) + y = geomspace(1, 1e6, dtype='float64') + assert_equal(y.dtype, dtype('float64')) + y = geomspace(1, 1e6, dtype='int32') + assert_equal(y.dtype, dtype('int32')) + + # Native types + y = geomspace(1, 1e6, dtype=float) + assert_equal(y.dtype, dtype('float64')) + y = geomspace(1, 1e6, dtype=complex) + assert_equal(y.dtype, dtype('complex128')) + + def test_start_stop_array_scalar(self): + lim1 = array([120, 100], dtype="int8") + lim2 = array([-120, -100], dtype="int8") + lim3 = array([1200, 1000], dtype="uint16") + t1 = geomspace(lim1[0], lim1[1], 5) + t2 = geomspace(lim2[0], lim2[1], 5) + t3 = geomspace(lim3[0], lim3[1], 5) + t4 = geomspace(120.0, 100.0, 5) + t5 = geomspace(-120.0, -100.0, 5) + t6 = geomspace(1200.0, 1000.0, 5) + + # t3 uses float32, t6 uses float64 + assert_allclose(t1, t4, rtol=1e-2) + assert_allclose(t2, t5, rtol=1e-2) + assert_allclose(t3, t6, rtol=1e-5) + + def test_start_stop_array(self): + # Try to use all special cases. + start = array([1.e0, 32., 1j, -4j, 1+1j, -1]) + stop = array([1.e4, 2., 16j, -324j, 10000+10000j, 1]) + t1 = geomspace(start, stop, 5) + t2 = stack([geomspace(_start, _stop, 5) + for _start, _stop in zip(start, stop)], axis=1) + assert_equal(t1, t2) + t3 = geomspace(start, stop[0], 5) + t4 = stack([geomspace(_start, stop[0], 5) + for _start in start], axis=1) + assert_equal(t3, t4) + t5 = geomspace(start, stop, 5, axis=-1) + assert_equal(t5, t2.T) + + def test_physical_quantities(self): + a = PhysicalQuantity(1.0) + b = PhysicalQuantity(5.0) + assert_equal(geomspace(a, b), geomspace(1.0, 5.0)) + + def test_subclass(self): + a = array(1).view(PhysicalQuantity2) + b = array(7).view(PhysicalQuantity2) + gs = geomspace(a, b) + assert type(gs) is PhysicalQuantity2 + assert_equal(gs, geomspace(1.0, 7.0)) + gs = geomspace(a, b, 1) + assert type(gs) is PhysicalQuantity2 + assert_equal(gs, geomspace(1.0, 7.0, 1)) + + def test_bounds(self): + assert_raises(ValueError, geomspace, 0, 10) + assert_raises(ValueError, geomspace, 10, 0) + assert_raises(ValueError, geomspace, 0, 0) + + +class TestLinspace: + + def test_basic(self): + y = linspace(0, 10) + assert_(len(y) == 50) + y = linspace(2, 10, num=100) + assert_(y[-1] == 10) + y = linspace(2, 10, endpoint=False) + assert_(y[-1] < 10) + assert_raises(ValueError, linspace, 0, 10, num=-1) + + def test_corner(self): + y = list(linspace(0, 1, 1)) + assert_(y == [0.0], y) + assert_raises(TypeError, linspace, 0, 1, num=2.5) + + def test_type(self): + t1 = linspace(0, 1, 0).dtype + t2 = linspace(0, 1, 1).dtype + t3 = linspace(0, 1, 2).dtype + assert_equal(t1, t2) + assert_equal(t2, t3) + + def test_dtype(self): + y = linspace(0, 6, dtype='float32') + assert_equal(y.dtype, dtype('float32')) + y = linspace(0, 6, dtype='float64') + assert_equal(y.dtype, dtype('float64')) + y = linspace(0, 6, dtype='int32') + assert_equal(y.dtype, dtype('int32')) + + def test_start_stop_array_scalar(self): + lim1 = array([-120, 100], dtype="int8") + lim2 = array([120, -100], dtype="int8") + lim3 = array([1200, 1000], dtype="uint16") + t1 = linspace(lim1[0], lim1[1], 5) + t2 = linspace(lim2[0], lim2[1], 5) + t3 = linspace(lim3[0], lim3[1], 5) + t4 = linspace(-120.0, 100.0, 5) + t5 = linspace(120.0, -100.0, 5) + t6 = linspace(1200.0, 1000.0, 5) + assert_equal(t1, t4) + assert_equal(t2, t5) + assert_equal(t3, t6) + + def test_start_stop_array(self): + start = array([-120, 120], dtype="int8") + stop = array([100, -100], dtype="int8") + t1 = linspace(start, stop, 5) + t2 = stack([linspace(_start, _stop, 5) + for _start, _stop in zip(start, stop)], axis=1) + assert_equal(t1, t2) + t3 = linspace(start, stop[0], 5) + t4 = stack([linspace(_start, stop[0], 5) + for _start in start], axis=1) + assert_equal(t3, t4) + t5 = linspace(start, stop, 5, axis=-1) + assert_equal(t5, t2.T) + + def test_complex(self): + lim1 = linspace(1 + 2j, 3 + 4j, 5) + t1 = array([1.0+2.j, 1.5+2.5j, 2.0+3j, 2.5+3.5j, 3.0+4j]) + lim2 = linspace(1j, 10, 5) + t2 = array([0.0+1.j, 2.5+0.75j, 5.0+0.5j, 7.5+0.25j, 10.0+0j]) + assert_equal(lim1, t1) + assert_equal(lim2, t2) + + def test_physical_quantities(self): + a = PhysicalQuantity(0.0) + b = PhysicalQuantity(1.0) + assert_equal(linspace(a, b), linspace(0.0, 1.0)) + + def test_subclass(self): + a = array(0).view(PhysicalQuantity2) + b = array(1).view(PhysicalQuantity2) + ls = linspace(a, b) + assert type(ls) is PhysicalQuantity2 + assert_equal(ls, linspace(0.0, 1.0)) + ls = linspace(a, b, 1) + assert type(ls) is PhysicalQuantity2 + assert_equal(ls, linspace(0.0, 1.0, 1)) + + def test_array_interface(self): + # Regression test for https://github.com/numpy/numpy/pull/6659 + # Ensure that start/stop can be objects that implement + # __array_interface__ and are convertible to numeric scalars + + class Arrayish: + """ + A generic object that supports the __array_interface__ and hence + can in principle be converted to a numeric scalar, but is not + otherwise recognized as numeric, but also happens to support + multiplication by floats. + + Data should be an object that implements the buffer interface, + and contains at least 4 bytes. + """ + + def __init__(self, data): + self._data = data + + @property + def __array_interface__(self): + return {'shape': (), 'typestr': ' 300) + assert_(len(np.lib._index_tricks_impl.mgrid.__doc__) > 300) + + @pytest.mark.skipif(sys.flags.optimize == 2, reason="Python running -OO") + def test_errors_are_ignored(self): + prev_doc = np._core.flatiter.index.__doc__ + # nothing changed, but error ignored, this should probably + # give a warning (or even error) in the future. + add_newdoc("numpy._core", "flatiter", ("index", "bad docstring")) + assert prev_doc == np._core.flatiter.index.__doc__ diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/test_getlimits.py b/venv/lib/python3.12/site-packages/numpy/_core/tests/test_getlimits.py new file mode 100644 index 00000000..8378bad1 --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/tests/test_getlimits.py @@ -0,0 +1,194 @@ +""" Test functions for limits module. + +""" +import warnings +import numpy as np +import pytest +from numpy._core import finfo, iinfo +from numpy import half, single, double, longdouble +from numpy.testing import assert_equal, assert_, assert_raises +from numpy._core.getlimits import _discovered_machar, _float_ma + +################################################## + +class TestPythonFloat: + def test_singleton(self): + ftype = finfo(float) + ftype2 = finfo(float) + assert_equal(id(ftype), id(ftype2)) + +class TestHalf: + def test_singleton(self): + ftype = finfo(half) + ftype2 = finfo(half) + assert_equal(id(ftype), id(ftype2)) + +class TestSingle: + def test_singleton(self): + ftype = finfo(single) + ftype2 = finfo(single) + assert_equal(id(ftype), id(ftype2)) + +class TestDouble: + def test_singleton(self): + ftype = finfo(double) + ftype2 = finfo(double) + assert_equal(id(ftype), id(ftype2)) + +class TestLongdouble: + def test_singleton(self): + ftype = finfo(longdouble) + ftype2 = finfo(longdouble) + assert_equal(id(ftype), id(ftype2)) + +def assert_finfo_equal(f1, f2): + # assert two finfo instances have the same attributes + for attr in ('bits', 'eps', 'epsneg', 'iexp', 'machep', + 'max', 'maxexp', 'min', 'minexp', 'negep', 'nexp', + 'nmant', 'precision', 'resolution', 'tiny', + 'smallest_normal', 'smallest_subnormal'): + assert_equal(getattr(f1, attr), getattr(f2, attr), + f'finfo instances {f1} and {f2} differ on {attr}') + +def assert_iinfo_equal(i1, i2): + # assert two iinfo instances have the same attributes + for attr in ('bits', 'min', 'max'): + assert_equal(getattr(i1, attr), getattr(i2, attr), + f'iinfo instances {i1} and {i2} differ on {attr}') + +class TestFinfo: + def test_basic(self): + dts = list(zip(['f2', 'f4', 'f8', 'c8', 'c16'], + [np.float16, np.float32, np.float64, np.complex64, + np.complex128])) + for dt1, dt2 in dts: + assert_finfo_equal(finfo(dt1), finfo(dt2)) + + assert_raises(ValueError, finfo, 'i4') + + def test_regression_gh23108(self): + # np.float32(1.0) and np.float64(1.0) have the same hash and are + # equal under the == operator + f1 = np.finfo(np.float32(1.0)) + f2 = np.finfo(np.float64(1.0)) + assert f1 != f2 + + def test_regression_gh23867(self): + class NonHashableWithDtype: + __hash__ = None + dtype = np.dtype('float32') + + x = NonHashableWithDtype() + assert np.finfo(x) == np.finfo(x.dtype) + + +class TestIinfo: + def test_basic(self): + dts = list(zip(['i1', 'i2', 'i4', 'i8', + 'u1', 'u2', 'u4', 'u8'], + [np.int8, np.int16, np.int32, np.int64, + np.uint8, np.uint16, np.uint32, np.uint64])) + for dt1, dt2 in dts: + assert_iinfo_equal(iinfo(dt1), iinfo(dt2)) + + assert_raises(ValueError, iinfo, 'f4') + + def test_unsigned_max(self): + types = np._core.sctypes['uint'] + for T in types: + with np.errstate(over="ignore"): + max_calculated = T(0) - T(1) + assert_equal(iinfo(T).max, max_calculated) + +class TestRepr: + def test_iinfo_repr(self): + expected = "iinfo(min=-32768, max=32767, dtype=int16)" + assert_equal(repr(np.iinfo(np.int16)), expected) + + def test_finfo_repr(self): + expected = "finfo(resolution=1e-06, min=-3.4028235e+38," + \ + " max=3.4028235e+38, dtype=float32)" + assert_equal(repr(np.finfo(np.float32)), expected) + + +def test_instances(): + # Test the finfo and iinfo results on numeric instances agree with + # the results on the corresponding types + + for c in [int, np.int16, np.int32, np.int64]: + class_iinfo = iinfo(c) + instance_iinfo = iinfo(c(12)) + + assert_iinfo_equal(class_iinfo, instance_iinfo) + + for c in [float, np.float16, np.float32, np.float64]: + class_finfo = finfo(c) + instance_finfo = finfo(c(1.2)) + assert_finfo_equal(class_finfo, instance_finfo) + + with pytest.raises(ValueError): + iinfo(10.) + + with pytest.raises(ValueError): + iinfo('hi') + + with pytest.raises(ValueError): + finfo(np.int64(1)) + + +def assert_ma_equal(discovered, ma_like): + # Check MachAr-like objects same as calculated MachAr instances + for key, value in discovered.__dict__.items(): + assert_equal(value, getattr(ma_like, key)) + if hasattr(value, 'shape'): + assert_equal(value.shape, getattr(ma_like, key).shape) + assert_equal(value.dtype, getattr(ma_like, key).dtype) + + +def test_known_types(): + # Test we are correctly compiling parameters for known types + for ftype, ma_like in ((np.float16, _float_ma[16]), + (np.float32, _float_ma[32]), + (np.float64, _float_ma[64])): + assert_ma_equal(_discovered_machar(ftype), ma_like) + # Suppress warning for broken discovery of double double on PPC + with np.errstate(all='ignore'): + ld_ma = _discovered_machar(np.longdouble) + bytes = np.dtype(np.longdouble).itemsize + if (ld_ma.it, ld_ma.maxexp) == (63, 16384) and bytes in (12, 16): + # 80-bit extended precision + assert_ma_equal(ld_ma, _float_ma[80]) + elif (ld_ma.it, ld_ma.maxexp) == (112, 16384) and bytes == 16: + # IEE 754 128-bit + assert_ma_equal(ld_ma, _float_ma[128]) + + +def test_subnormal_warning(): + """Test that the subnormal is zero warning is not being raised.""" + with np.errstate(all='ignore'): + ld_ma = _discovered_machar(np.longdouble) + bytes = np.dtype(np.longdouble).itemsize + with warnings.catch_warnings(record=True) as w: + warnings.simplefilter('always') + if (ld_ma.it, ld_ma.maxexp) == (63, 16384) and bytes in (12, 16): + # 80-bit extended precision + ld_ma.smallest_subnormal + assert len(w) == 0 + elif (ld_ma.it, ld_ma.maxexp) == (112, 16384) and bytes == 16: + # IEE 754 128-bit + ld_ma.smallest_subnormal + assert len(w) == 0 + else: + # Double double + ld_ma.smallest_subnormal + # This test may fail on some platforms + assert len(w) == 0 + + +def test_plausible_finfo(): + # Assert that finfo returns reasonable results for all types + for ftype in np._core.sctypes['float'] + np._core.sctypes['complex']: + info = np.finfo(ftype) + assert_(info.nmant > 1) + assert_(info.minexp < -1) + assert_(info.maxexp > 1) diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/test_half.py b/venv/lib/python3.12/site-packages/numpy/_core/tests/test_half.py new file mode 100644 index 00000000..fbc1bf6a --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/tests/test_half.py @@ -0,0 +1,572 @@ +import platform +import pytest + +import numpy as np +from numpy import uint16, float16, float32, float64 +from numpy.testing import assert_, assert_equal, _OLD_PROMOTION, IS_WASM + + +def assert_raises_fpe(strmatch, callable, *args, **kwargs): + try: + callable(*args, **kwargs) + except FloatingPointError as exc: + assert_(str(exc).find(strmatch) >= 0, + "Did not raise floating point %s error" % strmatch) + else: + assert_(False, + "Did not raise floating point %s error" % strmatch) + +class TestHalf: + def setup_method(self): + # An array of all possible float16 values + self.all_f16 = np.arange(0x10000, dtype=uint16) + self.all_f16.dtype = float16 + + # NaN value can cause an invalid FP exception if HW is been used + with np.errstate(invalid='ignore'): + self.all_f32 = np.array(self.all_f16, dtype=float32) + self.all_f64 = np.array(self.all_f16, dtype=float64) + + # An array of all non-NaN float16 values, in sorted order + self.nonan_f16 = np.concatenate( + (np.arange(0xfc00, 0x7fff, -1, dtype=uint16), + np.arange(0x0000, 0x7c01, 1, dtype=uint16))) + self.nonan_f16.dtype = float16 + self.nonan_f32 = np.array(self.nonan_f16, dtype=float32) + self.nonan_f64 = np.array(self.nonan_f16, dtype=float64) + + # An array of all finite float16 values, in sorted order + self.finite_f16 = self.nonan_f16[1:-1] + self.finite_f32 = self.nonan_f32[1:-1] + self.finite_f64 = self.nonan_f64[1:-1] + + def test_half_conversions(self): + """Checks that all 16-bit values survive conversion + to/from 32-bit and 64-bit float""" + # Because the underlying routines preserve the NaN bits, every + # value is preserved when converting to/from other floats. + + # Convert from float32 back to float16 + with np.errstate(invalid='ignore'): + b = np.array(self.all_f32, dtype=float16) + # avoid testing NaNs due to differ bits wither Q/SNaNs + b_nn = b == b + assert_equal(self.all_f16[b_nn].view(dtype=uint16), + b[b_nn].view(dtype=uint16)) + + # Convert from float64 back to float16 + with np.errstate(invalid='ignore'): + b = np.array(self.all_f64, dtype=float16) + b_nn = b == b + assert_equal(self.all_f16[b_nn].view(dtype=uint16), + b[b_nn].view(dtype=uint16)) + + # Convert float16 to longdouble and back + # This doesn't necessarily preserve the extra NaN bits, + # so exclude NaNs. + a_ld = np.array(self.nonan_f16, dtype=np.longdouble) + b = np.array(a_ld, dtype=float16) + assert_equal(self.nonan_f16.view(dtype=uint16), + b.view(dtype=uint16)) + + # Check the range for which all integers can be represented + i_int = np.arange(-2048, 2049) + i_f16 = np.array(i_int, dtype=float16) + j = np.array(i_f16, dtype=int) + assert_equal(i_int, j) + + @pytest.mark.parametrize("string_dt", ["S", "U"]) + def test_half_conversion_to_string(self, string_dt): + # Currently uses S/U32 (which is sufficient for float32) + expected_dt = np.dtype(f"{string_dt}32") + assert np.promote_types(np.float16, string_dt) == expected_dt + assert np.promote_types(string_dt, np.float16) == expected_dt + + arr = np.ones(3, dtype=np.float16).astype(string_dt) + assert arr.dtype == expected_dt + + @pytest.mark.parametrize("string_dt", ["S", "U"]) + def test_half_conversion_from_string(self, string_dt): + string = np.array("3.1416", dtype=string_dt) + assert string.astype(np.float16) == np.array(3.1416, dtype=np.float16) + + @pytest.mark.parametrize("offset", [None, "up", "down"]) + @pytest.mark.parametrize("shift", [None, "up", "down"]) + @pytest.mark.parametrize("float_t", [np.float32, np.float64]) + @np._no_nep50_warning() + def test_half_conversion_rounding(self, float_t, shift, offset): + # Assumes that round to even is used during casting. + max_pattern = np.float16(np.finfo(np.float16).max).view(np.uint16) + + # Test all (positive) finite numbers, denormals are most interesting + # however: + f16s_patterns = np.arange(0, max_pattern+1, dtype=np.uint16) + f16s_float = f16s_patterns.view(np.float16).astype(float_t) + + # Shift the values by half a bit up or a down (or do not shift), + if shift == "up": + f16s_float = 0.5 * (f16s_float[:-1] + f16s_float[1:])[1:] + elif shift == "down": + f16s_float = 0.5 * (f16s_float[:-1] + f16s_float[1:])[:-1] + else: + f16s_float = f16s_float[1:-1] + + # Increase the float by a minimal value: + if offset == "up": + f16s_float = np.nextafter(f16s_float, float_t(np.inf)) + elif offset == "down": + f16s_float = np.nextafter(f16s_float, float_t(-np.inf)) + + # Convert back to float16 and its bit pattern: + res_patterns = f16s_float.astype(np.float16).view(np.uint16) + + # The above calculations tries the original values, or the exact + # mid points between the float16 values. It then further offsets them + # by as little as possible. If no offset occurs, "round to even" + # logic will be necessary, an arbitrarily small offset should cause + # normal up/down rounding always. + + # Calculate the expected pattern: + cmp_patterns = f16s_patterns[1:-1].copy() + + if shift == "down" and offset != "up": + shift_pattern = -1 + elif shift == "up" and offset != "down": + shift_pattern = 1 + else: + # There cannot be a shift, either shift is None, so all rounding + # will go back to original, or shift is reduced by offset too much. + shift_pattern = 0 + + # If rounding occurs, is it normal rounding or round to even? + if offset is None: + # Round to even occurs, modify only non-even, cast to allow + (-1) + cmp_patterns[0::2].view(np.int16)[...] += shift_pattern + else: + cmp_patterns.view(np.int16)[...] += shift_pattern + + assert_equal(res_patterns, cmp_patterns) + + @pytest.mark.parametrize(["float_t", "uint_t", "bits"], + [(np.float32, np.uint32, 23), + (np.float64, np.uint64, 52)]) + def test_half_conversion_denormal_round_even(self, float_t, uint_t, bits): + # Test specifically that all bits are considered when deciding + # whether round to even should occur (i.e. no bits are lost at the + # end. Compare also gh-12721. The most bits can get lost for the + # smallest denormal: + smallest_value = np.uint16(1).view(np.float16).astype(float_t) + assert smallest_value == 2**-24 + + # Will be rounded to zero based on round to even rule: + rounded_to_zero = smallest_value / float_t(2) + assert rounded_to_zero.astype(np.float16) == 0 + + # The significand will be all 0 for the float_t, test that we do not + # lose the lower ones of these: + for i in range(bits): + # slightly increasing the value should make it round up: + larger_pattern = rounded_to_zero.view(uint_t) | uint_t(1 << i) + larger_value = larger_pattern.view(float_t) + assert larger_value.astype(np.float16) == smallest_value + + def test_nans_infs(self): + with np.errstate(all='ignore'): + # Check some of the ufuncs + assert_equal(np.isnan(self.all_f16), np.isnan(self.all_f32)) + assert_equal(np.isinf(self.all_f16), np.isinf(self.all_f32)) + assert_equal(np.isfinite(self.all_f16), np.isfinite(self.all_f32)) + assert_equal(np.signbit(self.all_f16), np.signbit(self.all_f32)) + assert_equal(np.spacing(float16(65504)), np.inf) + + # Check comparisons of all values with NaN + nan = float16(np.nan) + + assert_(not (self.all_f16 == nan).any()) + assert_(not (nan == self.all_f16).any()) + + assert_((self.all_f16 != nan).all()) + assert_((nan != self.all_f16).all()) + + assert_(not (self.all_f16 < nan).any()) + assert_(not (nan < self.all_f16).any()) + + assert_(not (self.all_f16 <= nan).any()) + assert_(not (nan <= self.all_f16).any()) + + assert_(not (self.all_f16 > nan).any()) + assert_(not (nan > self.all_f16).any()) + + assert_(not (self.all_f16 >= nan).any()) + assert_(not (nan >= self.all_f16).any()) + + def test_half_values(self): + """Confirms a small number of known half values""" + a = np.array([1.0, -1.0, + 2.0, -2.0, + 0.0999755859375, 0.333251953125, # 1/10, 1/3 + 65504, -65504, # Maximum magnitude + 2.0**(-14), -2.0**(-14), # Minimum normal + 2.0**(-24), -2.0**(-24), # Minimum subnormal + 0, -1/1e1000, # Signed zeros + np.inf, -np.inf]) + b = np.array([0x3c00, 0xbc00, + 0x4000, 0xc000, + 0x2e66, 0x3555, + 0x7bff, 0xfbff, + 0x0400, 0x8400, + 0x0001, 0x8001, + 0x0000, 0x8000, + 0x7c00, 0xfc00], dtype=uint16) + b.dtype = float16 + assert_equal(a, b) + + def test_half_rounding(self): + """Checks that rounding when converting to half is correct""" + a = np.array([2.0**-25 + 2.0**-35, # Rounds to minimum subnormal + 2.0**-25, # Underflows to zero (nearest even mode) + 2.0**-26, # Underflows to zero + 1.0+2.0**-11 + 2.0**-16, # rounds to 1.0+2**(-10) + 1.0+2.0**-11, # rounds to 1.0 (nearest even mode) + 1.0+2.0**-12, # rounds to 1.0 + 65519, # rounds to 65504 + 65520], # rounds to inf + dtype=float64) + rounded = [2.0**-24, + 0.0, + 0.0, + 1.0+2.0**(-10), + 1.0, + 1.0, + 65504, + np.inf] + + # Check float64->float16 rounding + with np.errstate(over="ignore"): + b = np.array(a, dtype=float16) + assert_equal(b, rounded) + + # Check float32->float16 rounding + a = np.array(a, dtype=float32) + with np.errstate(over="ignore"): + b = np.array(a, dtype=float16) + assert_equal(b, rounded) + + def test_half_correctness(self): + """Take every finite float16, and check the casting functions with + a manual conversion.""" + + # Create an array of all finite float16s + a_bits = self.finite_f16.view(dtype=uint16) + + # Convert to 64-bit float manually + a_sgn = (-1.0)**((a_bits & 0x8000) >> 15) + a_exp = np.array((a_bits & 0x7c00) >> 10, dtype=np.int32) - 15 + a_man = (a_bits & 0x03ff) * 2.0**(-10) + # Implicit bit of normalized floats + a_man[a_exp != -15] += 1 + # Denormalized exponent is -14 + a_exp[a_exp == -15] = -14 + + a_manual = a_sgn * a_man * 2.0**a_exp + + a32_fail = np.nonzero(self.finite_f32 != a_manual)[0] + if len(a32_fail) != 0: + bad_index = a32_fail[0] + assert_equal(self.finite_f32, a_manual, + "First non-equal is half value 0x%x -> %g != %g" % + (a_bits[bad_index], + self.finite_f32[bad_index], + a_manual[bad_index])) + + a64_fail = np.nonzero(self.finite_f64 != a_manual)[0] + if len(a64_fail) != 0: + bad_index = a64_fail[0] + assert_equal(self.finite_f64, a_manual, + "First non-equal is half value 0x%x -> %g != %g" % + (a_bits[bad_index], + self.finite_f64[bad_index], + a_manual[bad_index])) + + def test_half_ordering(self): + """Make sure comparisons are working right""" + + # All non-NaN float16 values in reverse order + a = self.nonan_f16[::-1].copy() + + # 32-bit float copy + b = np.array(a, dtype=float32) + + # Should sort the same + a.sort() + b.sort() + assert_equal(a, b) + + # Comparisons should work + assert_((a[:-1] <= a[1:]).all()) + assert_(not (a[:-1] > a[1:]).any()) + assert_((a[1:] >= a[:-1]).all()) + assert_(not (a[1:] < a[:-1]).any()) + # All != except for +/-0 + assert_equal(np.nonzero(a[:-1] < a[1:])[0].size, a.size-2) + assert_equal(np.nonzero(a[1:] > a[:-1])[0].size, a.size-2) + + def test_half_funcs(self): + """Test the various ArrFuncs""" + + # fill + assert_equal(np.arange(10, dtype=float16), + np.arange(10, dtype=float32)) + + # fillwithscalar + a = np.zeros((5,), dtype=float16) + a.fill(1) + assert_equal(a, np.ones((5,), dtype=float16)) + + # nonzero and copyswap + a = np.array([0, 0, -1, -1/1e20, 0, 2.0**-24, 7.629e-6], dtype=float16) + assert_equal(a.nonzero()[0], + [2, 5, 6]) + a = a.byteswap() + a = a.view(a.dtype.newbyteorder()) + assert_equal(a.nonzero()[0], + [2, 5, 6]) + + # dot + a = np.arange(0, 10, 0.5, dtype=float16) + b = np.ones((20,), dtype=float16) + assert_equal(np.dot(a, b), + 95) + + # argmax + a = np.array([0, -np.inf, -2, 0.5, 12.55, 7.3, 2.1, 12.4], dtype=float16) + assert_equal(a.argmax(), + 4) + a = np.array([0, -np.inf, -2, np.inf, 12.55, np.nan, 2.1, 12.4], dtype=float16) + assert_equal(a.argmax(), + 5) + + # getitem + a = np.arange(10, dtype=float16) + for i in range(10): + assert_equal(a.item(i), i) + + def test_spacing_nextafter(self): + """Test np.spacing and np.nextafter""" + # All non-negative finite #'s + a = np.arange(0x7c00, dtype=uint16) + hinf = np.array((np.inf,), dtype=float16) + hnan = np.array((np.nan,), dtype=float16) + a_f16 = a.view(dtype=float16) + + assert_equal(np.spacing(a_f16[:-1]), a_f16[1:]-a_f16[:-1]) + + assert_equal(np.nextafter(a_f16[:-1], hinf), a_f16[1:]) + assert_equal(np.nextafter(a_f16[0], -hinf), -a_f16[1]) + assert_equal(np.nextafter(a_f16[1:], -hinf), a_f16[:-1]) + + assert_equal(np.nextafter(hinf, a_f16), a_f16[-1]) + assert_equal(np.nextafter(-hinf, a_f16), -a_f16[-1]) + + assert_equal(np.nextafter(hinf, hinf), hinf) + assert_equal(np.nextafter(hinf, -hinf), a_f16[-1]) + assert_equal(np.nextafter(-hinf, hinf), -a_f16[-1]) + assert_equal(np.nextafter(-hinf, -hinf), -hinf) + + assert_equal(np.nextafter(a_f16, hnan), hnan[0]) + assert_equal(np.nextafter(hnan, a_f16), hnan[0]) + + assert_equal(np.nextafter(hnan, hnan), hnan) + assert_equal(np.nextafter(hinf, hnan), hnan) + assert_equal(np.nextafter(hnan, hinf), hnan) + + # switch to negatives + a |= 0x8000 + + assert_equal(np.spacing(a_f16[0]), np.spacing(a_f16[1])) + assert_equal(np.spacing(a_f16[1:]), a_f16[:-1]-a_f16[1:]) + + assert_equal(np.nextafter(a_f16[0], hinf), -a_f16[1]) + assert_equal(np.nextafter(a_f16[1:], hinf), a_f16[:-1]) + assert_equal(np.nextafter(a_f16[:-1], -hinf), a_f16[1:]) + + assert_equal(np.nextafter(hinf, a_f16), -a_f16[-1]) + assert_equal(np.nextafter(-hinf, a_f16), a_f16[-1]) + + assert_equal(np.nextafter(a_f16, hnan), hnan[0]) + assert_equal(np.nextafter(hnan, a_f16), hnan[0]) + + def test_half_ufuncs(self): + """Test the various ufuncs""" + + a = np.array([0, 1, 2, 4, 2], dtype=float16) + b = np.array([-2, 5, 1, 4, 3], dtype=float16) + c = np.array([0, -1, -np.inf, np.nan, 6], dtype=float16) + + assert_equal(np.add(a, b), [-2, 6, 3, 8, 5]) + assert_equal(np.subtract(a, b), [2, -4, 1, 0, -1]) + assert_equal(np.multiply(a, b), [0, 5, 2, 16, 6]) + assert_equal(np.divide(a, b), [0, 0.199951171875, 2, 1, 0.66650390625]) + + assert_equal(np.equal(a, b), [False, False, False, True, False]) + assert_equal(np.not_equal(a, b), [True, True, True, False, True]) + assert_equal(np.less(a, b), [False, True, False, False, True]) + assert_equal(np.less_equal(a, b), [False, True, False, True, True]) + assert_equal(np.greater(a, b), [True, False, True, False, False]) + assert_equal(np.greater_equal(a, b), [True, False, True, True, False]) + assert_equal(np.logical_and(a, b), [False, True, True, True, True]) + assert_equal(np.logical_or(a, b), [True, True, True, True, True]) + assert_equal(np.logical_xor(a, b), [True, False, False, False, False]) + assert_equal(np.logical_not(a), [True, False, False, False, False]) + + assert_equal(np.isnan(c), [False, False, False, True, False]) + assert_equal(np.isinf(c), [False, False, True, False, False]) + assert_equal(np.isfinite(c), [True, True, False, False, True]) + assert_equal(np.signbit(b), [True, False, False, False, False]) + + assert_equal(np.copysign(b, a), [2, 5, 1, 4, 3]) + + assert_equal(np.maximum(a, b), [0, 5, 2, 4, 3]) + + x = np.maximum(b, c) + assert_(np.isnan(x[3])) + x[3] = 0 + assert_equal(x, [0, 5, 1, 0, 6]) + + assert_equal(np.minimum(a, b), [-2, 1, 1, 4, 2]) + + x = np.minimum(b, c) + assert_(np.isnan(x[3])) + x[3] = 0 + assert_equal(x, [-2, -1, -np.inf, 0, 3]) + + assert_equal(np.fmax(a, b), [0, 5, 2, 4, 3]) + assert_equal(np.fmax(b, c), [0, 5, 1, 4, 6]) + assert_equal(np.fmin(a, b), [-2, 1, 1, 4, 2]) + assert_equal(np.fmin(b, c), [-2, -1, -np.inf, 4, 3]) + + assert_equal(np.floor_divide(a, b), [0, 0, 2, 1, 0]) + assert_equal(np.remainder(a, b), [0, 1, 0, 0, 2]) + assert_equal(np.divmod(a, b), ([0, 0, 2, 1, 0], [0, 1, 0, 0, 2])) + assert_equal(np.square(b), [4, 25, 1, 16, 9]) + assert_equal(np.reciprocal(b), [-0.5, 0.199951171875, 1, 0.25, 0.333251953125]) + assert_equal(np.ones_like(b), [1, 1, 1, 1, 1]) + assert_equal(np.conjugate(b), b) + assert_equal(np.absolute(b), [2, 5, 1, 4, 3]) + assert_equal(np.negative(b), [2, -5, -1, -4, -3]) + assert_equal(np.positive(b), b) + assert_equal(np.sign(b), [-1, 1, 1, 1, 1]) + assert_equal(np.modf(b), ([0, 0, 0, 0, 0], b)) + assert_equal(np.frexp(b), ([-0.5, 0.625, 0.5, 0.5, 0.75], [2, 3, 1, 3, 2])) + assert_equal(np.ldexp(b, [0, 1, 2, 4, 2]), [-2, 10, 4, 64, 12]) + + @np._no_nep50_warning() + def test_half_coercion(self, weak_promotion): + """Test that half gets coerced properly with the other types""" + a16 = np.array((1,), dtype=float16) + a32 = np.array((1,), dtype=float32) + b16 = float16(1) + b32 = float32(1) + + assert np.power(a16, 2).dtype == float16 + assert np.power(a16, 2.0).dtype == float16 + assert np.power(a16, b16).dtype == float16 + expected_dt = float32 if weak_promotion else float16 + assert np.power(a16, b32).dtype == expected_dt + assert np.power(a16, a16).dtype == float16 + assert np.power(a16, a32).dtype == float32 + + expected_dt = float16 if weak_promotion else float64 + assert np.power(b16, 2).dtype == expected_dt + assert np.power(b16, 2.0).dtype == expected_dt + assert np.power(b16, b16).dtype, float16 + assert np.power(b16, b32).dtype, float32 + assert np.power(b16, a16).dtype, float16 + assert np.power(b16, a32).dtype, float32 + + assert np.power(a32, a16).dtype == float32 + assert np.power(a32, b16).dtype == float32 + expected_dt = float32 if weak_promotion else float16 + assert np.power(b32, a16).dtype == expected_dt + assert np.power(b32, b16).dtype == float32 + + @pytest.mark.skipif(platform.machine() == "armv5tel", + reason="See gh-413.") + @pytest.mark.skipif(IS_WASM, + reason="fp exceptions don't work in wasm.") + def test_half_fpe(self): + with np.errstate(all='raise'): + sx16 = np.array((1e-4,), dtype=float16) + bx16 = np.array((1e4,), dtype=float16) + sy16 = float16(1e-4) + by16 = float16(1e4) + + # Underflow errors + assert_raises_fpe('underflow', lambda a, b:a*b, sx16, sx16) + assert_raises_fpe('underflow', lambda a, b:a*b, sx16, sy16) + assert_raises_fpe('underflow', lambda a, b:a*b, sy16, sx16) + assert_raises_fpe('underflow', lambda a, b:a*b, sy16, sy16) + assert_raises_fpe('underflow', lambda a, b:a/b, sx16, bx16) + assert_raises_fpe('underflow', lambda a, b:a/b, sx16, by16) + assert_raises_fpe('underflow', lambda a, b:a/b, sy16, bx16) + assert_raises_fpe('underflow', lambda a, b:a/b, sy16, by16) + assert_raises_fpe('underflow', lambda a, b:a/b, + float16(2.**-14), float16(2**11)) + assert_raises_fpe('underflow', lambda a, b:a/b, + float16(-2.**-14), float16(2**11)) + assert_raises_fpe('underflow', lambda a, b:a/b, + float16(2.**-14+2**-24), float16(2)) + assert_raises_fpe('underflow', lambda a, b:a/b, + float16(-2.**-14-2**-24), float16(2)) + assert_raises_fpe('underflow', lambda a, b:a/b, + float16(2.**-14+2**-23), float16(4)) + + # Overflow errors + assert_raises_fpe('overflow', lambda a, b:a*b, bx16, bx16) + assert_raises_fpe('overflow', lambda a, b:a*b, bx16, by16) + assert_raises_fpe('overflow', lambda a, b:a*b, by16, bx16) + assert_raises_fpe('overflow', lambda a, b:a*b, by16, by16) + assert_raises_fpe('overflow', lambda a, b:a/b, bx16, sx16) + assert_raises_fpe('overflow', lambda a, b:a/b, bx16, sy16) + assert_raises_fpe('overflow', lambda a, b:a/b, by16, sx16) + assert_raises_fpe('overflow', lambda a, b:a/b, by16, sy16) + assert_raises_fpe('overflow', lambda a, b:a+b, + float16(65504), float16(17)) + assert_raises_fpe('overflow', lambda a, b:a-b, + float16(-65504), float16(17)) + assert_raises_fpe('overflow', np.nextafter, float16(65504), float16(np.inf)) + assert_raises_fpe('overflow', np.nextafter, float16(-65504), float16(-np.inf)) + assert_raises_fpe('overflow', np.spacing, float16(65504)) + + # Invalid value errors + assert_raises_fpe('invalid', np.divide, float16(np.inf), float16(np.inf)) + assert_raises_fpe('invalid', np.spacing, float16(np.inf)) + assert_raises_fpe('invalid', np.spacing, float16(np.nan)) + + # These should not raise + float16(65472)+float16(32) + float16(2**-13)/float16(2) + float16(2**-14)/float16(2**10) + np.spacing(float16(-65504)) + np.nextafter(float16(65504), float16(-np.inf)) + np.nextafter(float16(-65504), float16(np.inf)) + np.nextafter(float16(np.inf), float16(0)) + np.nextafter(float16(-np.inf), float16(0)) + np.nextafter(float16(0), float16(np.nan)) + np.nextafter(float16(np.nan), float16(0)) + float16(2**-14)/float16(2**10) + float16(-2**-14)/float16(2**10) + float16(2**-14+2**-23)/float16(2) + float16(-2**-14-2**-23)/float16(2) + + def test_half_array_interface(self): + """Test that half is compatible with __array_interface__""" + class Dummy: + pass + + a = np.ones((1,), dtype=float16) + b = Dummy() + b.__array_interface__ = a.__array_interface__ + c = np.array(b) + assert_(c.dtype == float16) + assert_equal(a, c) diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/test_hashtable.py b/venv/lib/python3.12/site-packages/numpy/_core/tests/test_hashtable.py new file mode 100644 index 00000000..41da06be --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/tests/test_hashtable.py @@ -0,0 +1,35 @@ +import pytest + +import random +from numpy._core._multiarray_tests import identityhash_tester + + +@pytest.mark.parametrize("key_length", [1, 3, 6]) +@pytest.mark.parametrize("length", [1, 16, 2000]) +def test_identity_hashtable(key_length, length): + # use a 30 object pool for everything (duplicates will happen) + pool = [object() for i in range(20)] + keys_vals = [] + for i in range(length): + keys = tuple(random.choices(pool, k=key_length)) + keys_vals.append((keys, random.choice(pool))) + + dictionary = dict(keys_vals) + + # add a random item at the end: + keys_vals.append(random.choice(keys_vals)) + # the expected one could be different with duplicates: + expected = dictionary[keys_vals[-1][0]] + + res = identityhash_tester(key_length, keys_vals, replace=True) + assert res is expected + + if length == 1: + return + + # add a new item with a key that is already used and a new value, this + # should error if replace is False, see gh-26690 + new_key = (keys_vals[1][0], object()) + keys_vals[0] = new_key + with pytest.raises(RuntimeError): + identityhash_tester(key_length, keys_vals) diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/test_indexerrors.py b/venv/lib/python3.12/site-packages/numpy/_core/tests/test_indexerrors.py new file mode 100644 index 00000000..c1faa955 --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/tests/test_indexerrors.py @@ -0,0 +1,124 @@ +import numpy as np +from numpy.testing import ( + assert_raises, assert_raises_regex, + ) + + +class TestIndexErrors: + '''Tests to exercise indexerrors not covered by other tests.''' + + def test_arraytypes_fasttake(self): + 'take from a 0-length dimension' + x = np.empty((2, 3, 0, 4)) + assert_raises(IndexError, x.take, [0], axis=2) + assert_raises(IndexError, x.take, [1], axis=2) + assert_raises(IndexError, x.take, [0], axis=2, mode='wrap') + assert_raises(IndexError, x.take, [0], axis=2, mode='clip') + + def test_take_from_object(self): + # Check exception taking from object array + d = np.zeros(5, dtype=object) + assert_raises(IndexError, d.take, [6]) + + # Check exception taking from 0-d array + d = np.zeros((5, 0), dtype=object) + assert_raises(IndexError, d.take, [1], axis=1) + assert_raises(IndexError, d.take, [0], axis=1) + assert_raises(IndexError, d.take, [0]) + assert_raises(IndexError, d.take, [0], mode='wrap') + assert_raises(IndexError, d.take, [0], mode='clip') + + def test_multiindex_exceptions(self): + a = np.empty(5, dtype=object) + assert_raises(IndexError, a.item, 20) + a = np.empty((5, 0), dtype=object) + assert_raises(IndexError, a.item, (0, 0)) + + def test_put_exceptions(self): + a = np.zeros((5, 5)) + assert_raises(IndexError, a.put, 100, 0) + a = np.zeros((5, 5), dtype=object) + assert_raises(IndexError, a.put, 100, 0) + a = np.zeros((5, 5, 0)) + assert_raises(IndexError, a.put, 100, 0) + a = np.zeros((5, 5, 0), dtype=object) + assert_raises(IndexError, a.put, 100, 0) + + def test_iterators_exceptions(self): + "cases in iterators.c" + def assign(obj, ind, val): + obj[ind] = val + + a = np.zeros([1, 2, 3]) + assert_raises(IndexError, lambda: a[0, 5, None, 2]) + assert_raises(IndexError, lambda: a[0, 5, 0, 2]) + assert_raises(IndexError, lambda: assign(a, (0, 5, None, 2), 1)) + assert_raises(IndexError, lambda: assign(a, (0, 5, 0, 2), 1)) + + a = np.zeros([1, 0, 3]) + assert_raises(IndexError, lambda: a[0, 0, None, 2]) + assert_raises(IndexError, lambda: assign(a, (0, 0, None, 2), 1)) + + a = np.zeros([1, 2, 3]) + assert_raises(IndexError, lambda: a.flat[10]) + assert_raises(IndexError, lambda: assign(a.flat, 10, 5)) + a = np.zeros([1, 0, 3]) + assert_raises(IndexError, lambda: a.flat[10]) + assert_raises(IndexError, lambda: assign(a.flat, 10, 5)) + + a = np.zeros([1, 2, 3]) + assert_raises(IndexError, lambda: a.flat[np.array(10)]) + assert_raises(IndexError, lambda: assign(a.flat, np.array(10), 5)) + a = np.zeros([1, 0, 3]) + assert_raises(IndexError, lambda: a.flat[np.array(10)]) + assert_raises(IndexError, lambda: assign(a.flat, np.array(10), 5)) + + a = np.zeros([1, 2, 3]) + assert_raises(IndexError, lambda: a.flat[np.array([10])]) + assert_raises(IndexError, lambda: assign(a.flat, np.array([10]), 5)) + a = np.zeros([1, 0, 3]) + assert_raises(IndexError, lambda: a.flat[np.array([10])]) + assert_raises(IndexError, lambda: assign(a.flat, np.array([10]), 5)) + + def test_mapping(self): + "cases from mapping.c" + + def assign(obj, ind, val): + obj[ind] = val + + a = np.zeros((0, 10)) + assert_raises(IndexError, lambda: a[12]) + + a = np.zeros((3, 5)) + assert_raises(IndexError, lambda: a[(10, 20)]) + assert_raises(IndexError, lambda: assign(a, (10, 20), 1)) + a = np.zeros((3, 0)) + assert_raises(IndexError, lambda: a[(1, 0)]) + assert_raises(IndexError, lambda: assign(a, (1, 0), 1)) + + a = np.zeros((10,)) + assert_raises(IndexError, lambda: assign(a, 10, 1)) + a = np.zeros((0,)) + assert_raises(IndexError, lambda: assign(a, 10, 1)) + + a = np.zeros((3, 5)) + assert_raises(IndexError, lambda: a[(1, [1, 20])]) + assert_raises(IndexError, lambda: assign(a, (1, [1, 20]), 1)) + a = np.zeros((3, 0)) + assert_raises(IndexError, lambda: a[(1, [0, 1])]) + assert_raises(IndexError, lambda: assign(a, (1, [0, 1]), 1)) + + def test_mapping_error_message(self): + a = np.zeros((3, 5)) + index = (1, 2, 3, 4, 5) + assert_raises_regex( + IndexError, + "too many indices for array: " + "array is 2-dimensional, but 5 were indexed", + lambda: a[index]) + + def test_methods(self): + "cases from methods.c" + + a = np.zeros((3, 3)) + assert_raises(IndexError, lambda: a.item(100)) diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/test_indexing.py b/venv/lib/python3.12/site-packages/numpy/_core/tests/test_indexing.py new file mode 100644 index 00000000..686caf9c --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/tests/test_indexing.py @@ -0,0 +1,1440 @@ +import sys +import warnings +import functools +import operator + +import pytest + +import numpy as np +from numpy._core._multiarray_tests import array_indexing +from itertools import product +from numpy.exceptions import ComplexWarning, VisibleDeprecationWarning +from numpy.testing import ( + assert_, assert_equal, assert_raises, assert_raises_regex, + assert_array_equal, assert_warns, HAS_REFCOUNT, IS_WASM + ) + + +class TestIndexing: + def test_index_no_floats(self): + a = np.array([[[5]]]) + + assert_raises(IndexError, lambda: a[0.0]) + assert_raises(IndexError, lambda: a[0, 0.0]) + assert_raises(IndexError, lambda: a[0.0, 0]) + assert_raises(IndexError, lambda: a[0.0,:]) + assert_raises(IndexError, lambda: a[:, 0.0]) + assert_raises(IndexError, lambda: a[:, 0.0,:]) + assert_raises(IndexError, lambda: a[0.0,:,:]) + assert_raises(IndexError, lambda: a[0, 0, 0.0]) + assert_raises(IndexError, lambda: a[0.0, 0, 0]) + assert_raises(IndexError, lambda: a[0, 0.0, 0]) + assert_raises(IndexError, lambda: a[-1.4]) + assert_raises(IndexError, lambda: a[0, -1.4]) + assert_raises(IndexError, lambda: a[-1.4, 0]) + assert_raises(IndexError, lambda: a[-1.4,:]) + assert_raises(IndexError, lambda: a[:, -1.4]) + assert_raises(IndexError, lambda: a[:, -1.4,:]) + assert_raises(IndexError, lambda: a[-1.4,:,:]) + assert_raises(IndexError, lambda: a[0, 0, -1.4]) + assert_raises(IndexError, lambda: a[-1.4, 0, 0]) + assert_raises(IndexError, lambda: a[0, -1.4, 0]) + assert_raises(IndexError, lambda: a[0.0:, 0.0]) + assert_raises(IndexError, lambda: a[0.0:, 0.0,:]) + + def test_slicing_no_floats(self): + a = np.array([[5]]) + + # start as float. + assert_raises(TypeError, lambda: a[0.0:]) + assert_raises(TypeError, lambda: a[0:, 0.0:2]) + assert_raises(TypeError, lambda: a[0.0::2, :0]) + assert_raises(TypeError, lambda: a[0.0:1:2,:]) + assert_raises(TypeError, lambda: a[:, 0.0:]) + # stop as float. + assert_raises(TypeError, lambda: a[:0.0]) + assert_raises(TypeError, lambda: a[:0, 1:2.0]) + assert_raises(TypeError, lambda: a[:0.0:2, :0]) + assert_raises(TypeError, lambda: a[:0.0,:]) + assert_raises(TypeError, lambda: a[:, 0:4.0:2]) + # step as float. + assert_raises(TypeError, lambda: a[::1.0]) + assert_raises(TypeError, lambda: a[0:, :2:2.0]) + assert_raises(TypeError, lambda: a[1::4.0, :0]) + assert_raises(TypeError, lambda: a[::5.0,:]) + assert_raises(TypeError, lambda: a[:, 0:4:2.0]) + # mixed. + assert_raises(TypeError, lambda: a[1.0:2:2.0]) + assert_raises(TypeError, lambda: a[1.0::2.0]) + assert_raises(TypeError, lambda: a[0:, :2.0:2.0]) + assert_raises(TypeError, lambda: a[1.0:1:4.0, :0]) + assert_raises(TypeError, lambda: a[1.0:5.0:5.0,:]) + assert_raises(TypeError, lambda: a[:, 0.4:4.0:2.0]) + # should still get the DeprecationWarning if step = 0. + assert_raises(TypeError, lambda: a[::0.0]) + + def test_index_no_array_to_index(self): + # No non-scalar arrays. + a = np.array([[[1]]]) + + assert_raises(TypeError, lambda: a[a:a:a]) + + def test_none_index(self): + # `None` index adds newaxis + a = np.array([1, 2, 3]) + assert_equal(a[None], a[np.newaxis]) + assert_equal(a[None].ndim, a.ndim + 1) + + def test_empty_tuple_index(self): + # Empty tuple index creates a view + a = np.array([1, 2, 3]) + assert_equal(a[()], a) + assert_(a[()].base is a) + a = np.array(0) + assert_(isinstance(a[()], np.int_)) + + def test_void_scalar_empty_tuple(self): + s = np.zeros((), dtype='V4') + assert_equal(s[()].dtype, s.dtype) + assert_equal(s[()], s) + assert_equal(type(s[...]), np.ndarray) + + def test_same_kind_index_casting(self): + # Indexes should be cast with same-kind and not safe, even if that + # is somewhat unsafe. So test various different code paths. + index = np.arange(5) + u_index = index.astype(np.uintp) + arr = np.arange(10) + + assert_array_equal(arr[index], arr[u_index]) + arr[u_index] = np.arange(5) + assert_array_equal(arr, np.arange(10)) + + arr = np.arange(10).reshape(5, 2) + assert_array_equal(arr[index], arr[u_index]) + + arr[u_index] = np.arange(5)[:,None] + assert_array_equal(arr, np.arange(5)[:,None].repeat(2, axis=1)) + + arr = np.arange(25).reshape(5, 5) + assert_array_equal(arr[u_index, u_index], arr[index, index]) + + def test_empty_fancy_index(self): + # Empty list index creates an empty array + # with the same dtype (but with weird shape) + a = np.array([1, 2, 3]) + assert_equal(a[[]], []) + assert_equal(a[[]].dtype, a.dtype) + + b = np.array([], dtype=np.intp) + assert_equal(a[[]], []) + assert_equal(a[[]].dtype, a.dtype) + + b = np.array([]) + assert_raises(IndexError, a.__getitem__, b) + + def test_gh_26542(self): + a = np.array([0, 1, 2]) + idx = np.array([2, 1, 0]) + a[idx] = a + expected = np.array([2, 1, 0]) + assert_equal(a, expected) + + def test_gh_26542_2d(self): + a = np.array([[0, 1, 2]]) + idx_row = np.zeros(3, dtype=int) + idx_col = np.array([2, 1, 0]) + a[idx_row, idx_col] = a + expected = np.array([[2, 1, 0]]) + assert_equal(a, expected) + + def test_gh_26542_index_overlap(self): + arr = np.arange(100) + expected_vals = np.copy(arr[:-10]) + arr[10:] = arr[:-10] + actual_vals = arr[10:] + assert_equal(actual_vals, expected_vals) + + def test_ellipsis_index(self): + a = np.array([[1, 2, 3], + [4, 5, 6], + [7, 8, 9]]) + assert_(a[...] is not a) + assert_equal(a[...], a) + # `a[...]` was `a` in numpy <1.9. + assert_(a[...].base is a) + + # Slicing with ellipsis can skip an + # arbitrary number of dimensions + assert_equal(a[0, ...], a[0]) + assert_equal(a[0, ...], a[0,:]) + assert_equal(a[..., 0], a[:, 0]) + + # Slicing with ellipsis always results + # in an array, not a scalar + assert_equal(a[0, ..., 1], np.array(2)) + + # Assignment with `(Ellipsis,)` on 0-d arrays + b = np.array(1) + b[(Ellipsis,)] = 2 + assert_equal(b, 2) + + def test_single_int_index(self): + # Single integer index selects one row + a = np.array([[1, 2, 3], + [4, 5, 6], + [7, 8, 9]]) + + assert_equal(a[0], [1, 2, 3]) + assert_equal(a[-1], [7, 8, 9]) + + # Index out of bounds produces IndexError + assert_raises(IndexError, a.__getitem__, 1 << 30) + # Index overflow produces IndexError + assert_raises(IndexError, a.__getitem__, 1 << 64) + + def test_single_bool_index(self): + # Single boolean index + a = np.array([[1, 2, 3], + [4, 5, 6], + [7, 8, 9]]) + + assert_equal(a[np.array(True)], a[None]) + assert_equal(a[np.array(False)], a[None][0:0]) + + def test_boolean_shape_mismatch(self): + arr = np.ones((5, 4, 3)) + + index = np.array([True]) + assert_raises(IndexError, arr.__getitem__, index) + + index = np.array([False] * 6) + assert_raises(IndexError, arr.__getitem__, index) + + index = np.zeros((4, 4), dtype=bool) + assert_raises(IndexError, arr.__getitem__, index) + + assert_raises(IndexError, arr.__getitem__, (slice(None), index)) + + def test_boolean_indexing_onedim(self): + # Indexing a 2-dimensional array with + # boolean array of length one + a = np.array([[ 0., 0., 0.]]) + b = np.array([ True], dtype=bool) + assert_equal(a[b], a) + # boolean assignment + a[b] = 1. + assert_equal(a, [[1., 1., 1.]]) + + def test_boolean_assignment_value_mismatch(self): + # A boolean assignment should fail when the shape of the values + # cannot be broadcast to the subscription. (see also gh-3458) + a = np.arange(4) + + def f(a, v): + a[a > -1] = v + + assert_raises(ValueError, f, a, []) + assert_raises(ValueError, f, a, [1, 2, 3]) + assert_raises(ValueError, f, a[:1], [1, 2, 3]) + + def test_boolean_assignment_needs_api(self): + # See also gh-7666 + # This caused a segfault on Python 2 due to the GIL not being + # held when the iterator does not need it, but the transfer function + # does + arr = np.zeros(1000) + indx = np.zeros(1000, dtype=bool) + indx[:100] = True + arr[indx] = np.ones(100, dtype=object) + + expected = np.zeros(1000) + expected[:100] = 1 + assert_array_equal(arr, expected) + + def test_boolean_indexing_twodim(self): + # Indexing a 2-dimensional array with + # 2-dimensional boolean array + a = np.array([[1, 2, 3], + [4, 5, 6], + [7, 8, 9]]) + b = np.array([[ True, False, True], + [False, True, False], + [ True, False, True]]) + assert_equal(a[b], [1, 3, 5, 7, 9]) + assert_equal(a[b[1]], [[4, 5, 6]]) + assert_equal(a[b[0]], a[b[2]]) + + # boolean assignment + a[b] = 0 + assert_equal(a, [[0, 2, 0], + [4, 0, 6], + [0, 8, 0]]) + + def test_boolean_indexing_list(self): + # Regression test for #13715. It's a use-after-free bug which the + # test won't directly catch, but it will show up in valgrind. + a = np.array([1, 2, 3]) + b = [True, False, True] + # Two variants of the test because the first takes a fast path + assert_equal(a[b], [1, 3]) + assert_equal(a[None, b], [[1, 3]]) + + def test_reverse_strides_and_subspace_bufferinit(self): + # This tests that the strides are not reversed for simple and + # subspace fancy indexing. + a = np.ones(5) + b = np.zeros(5, dtype=np.intp)[::-1] + c = np.arange(5)[::-1] + + a[b] = c + # If the strides are not reversed, the 0 in the arange comes last. + assert_equal(a[0], 0) + + # This also tests that the subspace buffer is initialized: + a = np.ones((5, 2)) + c = np.arange(10).reshape(5, 2)[::-1] + a[b, :] = c + assert_equal(a[0], [0, 1]) + + def test_reversed_strides_result_allocation(self): + # Test a bug when calculating the output strides for a result array + # when the subspace size was 1 (and test other cases as well) + a = np.arange(10)[:, None] + i = np.arange(10)[::-1] + assert_array_equal(a[i], a[i.copy('C')]) + + a = np.arange(20).reshape(-1, 2) + + def test_uncontiguous_subspace_assignment(self): + # During development there was a bug activating a skip logic + # based on ndim instead of size. + a = np.full((3, 4, 2), -1) + b = np.full((3, 4, 2), -1) + + a[[0, 1]] = np.arange(2 * 4 * 2).reshape(2, 4, 2).T + b[[0, 1]] = np.arange(2 * 4 * 2).reshape(2, 4, 2).T.copy() + + assert_equal(a, b) + + def test_too_many_fancy_indices_special_case(self): + # Just documents behaviour, this is a small limitation. + a = np.ones((1,) * 64) # 64 is NPY_MAXDIMS + assert_raises(IndexError, a.__getitem__, (np.array([0]),) * 64) + + def test_scalar_array_bool(self): + # NumPy bools can be used as boolean index (python ones as of yet not) + a = np.array(1) + assert_equal(a[np.bool(True)], a[np.array(True)]) + assert_equal(a[np.bool(False)], a[np.array(False)]) + + # After deprecating bools as integers: + #a = np.array([0,1,2]) + #assert_equal(a[True, :], a[None, :]) + #assert_equal(a[:, True], a[:, None]) + # + #assert_(not np.may_share_memory(a, a[True, :])) + + def test_everything_returns_views(self): + # Before `...` would return a itself. + a = np.arange(5) + + assert_(a is not a[()]) + assert_(a is not a[...]) + assert_(a is not a[:]) + + def test_broaderrors_indexing(self): + a = np.zeros((5, 5)) + assert_raises(IndexError, a.__getitem__, ([0, 1], [0, 1, 2])) + assert_raises(IndexError, a.__setitem__, ([0, 1], [0, 1, 2]), 0) + + def test_trivial_fancy_out_of_bounds(self): + a = np.zeros(5) + ind = np.ones(20, dtype=np.intp) + ind[-1] = 10 + assert_raises(IndexError, a.__getitem__, ind) + assert_raises(IndexError, a.__setitem__, ind, 0) + ind = np.ones(20, dtype=np.intp) + ind[0] = 11 + assert_raises(IndexError, a.__getitem__, ind) + assert_raises(IndexError, a.__setitem__, ind, 0) + + def test_trivial_fancy_not_possible(self): + # Test that the fast path for trivial assignment is not incorrectly + # used when the index is not contiguous or 1D, see also gh-11467. + a = np.arange(6) + idx = np.arange(6, dtype=np.intp).reshape(2, 1, 3)[:, :, 0] + assert_array_equal(a[idx], idx) + + # this case must not go into the fast path, note that idx is + # a non-contiuguous none 1D array here. + a[idx] = -1 + res = np.arange(6) + res[0] = -1 + res[3] = -1 + assert_array_equal(a, res) + + def test_nonbaseclass_values(self): + class SubClass(np.ndarray): + def __array_finalize__(self, old): + # Have array finalize do funny things + self.fill(99) + + a = np.zeros((5, 5)) + s = a.copy().view(type=SubClass) + s.fill(1) + + a[[0, 1, 2, 3, 4], :] = s + assert_((a == 1).all()) + + # Subspace is last, so transposing might want to finalize + a[:, [0, 1, 2, 3, 4]] = s + assert_((a == 1).all()) + + a.fill(0) + a[...] = s + assert_((a == 1).all()) + + def test_array_like_values(self): + # Similar to the above test, but use a memoryview instead + a = np.zeros((5, 5)) + s = np.arange(25, dtype=np.float64).reshape(5, 5) + + a[[0, 1, 2, 3, 4], :] = memoryview(s) + assert_array_equal(a, s) + + a[:, [0, 1, 2, 3, 4]] = memoryview(s) + assert_array_equal(a, s) + + a[...] = memoryview(s) + assert_array_equal(a, s) + + def test_subclass_writeable(self): + d = np.rec.array([('NGC1001', 11), ('NGC1002', 1.), ('NGC1003', 1.)], + dtype=[('target', 'S20'), ('V_mag', '>f4')]) + ind = np.array([False, True, True], dtype=bool) + assert_(d[ind].flags.writeable) + ind = np.array([0, 1]) + assert_(d[ind].flags.writeable) + assert_(d[...].flags.writeable) + assert_(d[0].flags.writeable) + + def test_memory_order(self): + # This is not necessary to preserve. Memory layouts for + # more complex indices are not as simple. + a = np.arange(10) + b = np.arange(10).reshape(5,2).T + assert_(a[b].flags.f_contiguous) + + # Takes a different implementation branch: + a = a.reshape(-1, 1) + assert_(a[b, 0].flags.f_contiguous) + + def test_scalar_return_type(self): + # Full scalar indices should return scalars and object + # arrays should not call PyArray_Return on their items + class Zero: + # The most basic valid indexing + def __index__(self): + return 0 + + z = Zero() + + class ArrayLike: + # Simple array, should behave like the array + def __array__(self, dtype=None, copy=None): + return np.array(0) + + a = np.zeros(()) + assert_(isinstance(a[()], np.float64)) + a = np.zeros(1) + assert_(isinstance(a[z], np.float64)) + a = np.zeros((1, 1)) + assert_(isinstance(a[z, np.array(0)], np.float64)) + assert_(isinstance(a[z, ArrayLike()], np.float64)) + + # And object arrays do not call it too often: + b = np.array(0) + a = np.array(0, dtype=object) + a[()] = b + assert_(isinstance(a[()], np.ndarray)) + a = np.array([b, None]) + assert_(isinstance(a[z], np.ndarray)) + a = np.array([[b, None]]) + assert_(isinstance(a[z, np.array(0)], np.ndarray)) + assert_(isinstance(a[z, ArrayLike()], np.ndarray)) + + def test_small_regressions(self): + # Reference count of intp for index checks + a = np.array([0]) + if HAS_REFCOUNT: + refcount = sys.getrefcount(np.dtype(np.intp)) + # item setting always checks indices in separate function: + a[np.array([0], dtype=np.intp)] = 1 + a[np.array([0], dtype=np.uint8)] = 1 + assert_raises(IndexError, a.__setitem__, + np.array([1], dtype=np.intp), 1) + assert_raises(IndexError, a.__setitem__, + np.array([1], dtype=np.uint8), 1) + + if HAS_REFCOUNT: + assert_equal(sys.getrefcount(np.dtype(np.intp)), refcount) + + def test_unaligned(self): + v = (np.zeros(64, dtype=np.int8) + ord('a'))[1:-7] + d = v.view(np.dtype("S8")) + # unaligned source + x = (np.zeros(16, dtype=np.int8) + ord('a'))[1:-7] + x = x.view(np.dtype("S8")) + x[...] = np.array("b" * 8, dtype="S") + b = np.arange(d.size) + #trivial + assert_equal(d[b], d) + d[b] = x + # nontrivial + # unaligned index array + b = np.zeros(d.size + 1).view(np.int8)[1:-(np.intp(0).itemsize - 1)] + b = b.view(np.intp)[:d.size] + b[...] = np.arange(d.size) + assert_equal(d[b.astype(np.int16)], d) + d[b.astype(np.int16)] = x + # boolean + d[b % 2 == 0] + d[b % 2 == 0] = x[::2] + + def test_tuple_subclass(self): + arr = np.ones((5, 5)) + + # A tuple subclass should also be an nd-index + class TupleSubclass(tuple): + pass + index = ([1], [1]) + index = TupleSubclass(index) + assert_(arr[index].shape == (1,)) + # Unlike the non nd-index: + assert_(arr[index,].shape != (1,)) + + def test_broken_sequence_not_nd_index(self): + # See gh-5063: + # If we have an object which claims to be a sequence, but fails + # on item getting, this should not be converted to an nd-index (tuple) + # If this object happens to be a valid index otherwise, it should work + # This object here is very dubious and probably bad though: + class SequenceLike: + def __index__(self): + return 0 + + def __len__(self): + return 1 + + def __getitem__(self, item): + raise IndexError('Not possible') + + arr = np.arange(10) + assert_array_equal(arr[SequenceLike()], arr[SequenceLike(),]) + + # also test that field indexing does not segfault + # for a similar reason, by indexing a structured array + arr = np.zeros((1,), dtype=[('f1', 'i8'), ('f2', 'i8')]) + assert_array_equal(arr[SequenceLike()], arr[SequenceLike(),]) + + def test_indexing_array_weird_strides(self): + # See also gh-6221 + # the shapes used here come from the issue and create the correct + # size for the iterator buffering size. + x = np.ones(10) + x2 = np.ones((10, 2)) + ind = np.arange(10)[:, None, None, None] + ind = np.broadcast_to(ind, (10, 55, 4, 4)) + + # single advanced index case + assert_array_equal(x[ind], x[ind.copy()]) + # higher dimensional advanced index + zind = np.zeros(4, dtype=np.intp) + assert_array_equal(x2[ind, zind], x2[ind.copy(), zind]) + + def test_indexing_array_negative_strides(self): + # From gh-8264, + # core dumps if negative strides are used in iteration + arro = np.zeros((4, 4)) + arr = arro[::-1, ::-1] + + slices = (slice(None), [0, 1, 2, 3]) + arr[slices] = 10 + assert_array_equal(arr, 10.) + + def test_character_assignment(self): + # This is an example a function going through CopyObject which + # used to have an untested special path for scalars + # (the character special dtype case, should be deprecated probably) + arr = np.zeros((1, 5), dtype="c") + arr[0] = np.str_("asdfg") # must assign as a sequence + assert_array_equal(arr[0], np.array("asdfg", dtype="c")) + assert arr[0, 1] == b"s" # make sure not all were set to "a" for both + + @pytest.mark.parametrize("index", + [True, False, np.array([0])]) + @pytest.mark.parametrize("num", [64, 80]) + @pytest.mark.parametrize("original_ndim", [1, 64]) + def test_too_many_advanced_indices(self, index, num, original_ndim): + # These are limitations based on the number of arguments we can process. + # For `num=32` (and all boolean cases), the result is actually define; + # but the use of NpyIter (NPY_MAXARGS) limits it for technical reasons. + arr = np.ones((1,) * original_ndim) + with pytest.raises(IndexError): + arr[(index,) * num] + with pytest.raises(IndexError): + arr[(index,) * num] = 1. + + @pytest.mark.skipif(IS_WASM, reason="no threading") + def test_structured_advanced_indexing(self): + # Test that copyswap(n) used by integer array indexing is threadsafe + # for structured datatypes, see gh-15387. This test can behave randomly. + from concurrent.futures import ThreadPoolExecutor + + # Create a deeply nested dtype to make a failure more likely: + dt = np.dtype([("", "f8")]) + dt = np.dtype([("", dt)] * 2) + dt = np.dtype([("", dt)] * 2) + # The array should be large enough to likely run into threading issues + arr = np.random.uniform(size=(6000, 8)).view(dt)[:, 0] + + rng = np.random.default_rng() + def func(arr): + indx = rng.integers(0, len(arr), size=6000, dtype=np.intp) + arr[indx] + + tpe = ThreadPoolExecutor(max_workers=8) + futures = [tpe.submit(func, arr) for _ in range(10)] + for f in futures: + f.result() + + assert arr.dtype is dt + + def test_nontuple_ndindex(self): + a = np.arange(25).reshape((5, 5)) + assert_equal(a[[0, 1]], np.array([a[0], a[1]])) + assert_equal(a[[0, 1], [0, 1]], np.array([0, 6])) + assert_raises(IndexError, a.__getitem__, [slice(None)]) + + +class TestFieldIndexing: + def test_scalar_return_type(self): + # Field access on an array should return an array, even if it + # is 0-d. + a = np.zeros((), [('a','f8')]) + assert_(isinstance(a['a'], np.ndarray)) + assert_(isinstance(a[['a']], np.ndarray)) + + +class TestBroadcastedAssignments: + def assign(self, a, ind, val): + a[ind] = val + return a + + def test_prepending_ones(self): + a = np.zeros((3, 2)) + + a[...] = np.ones((1, 3, 2)) + # Fancy with subspace with and without transpose + a[[0, 1, 2], :] = np.ones((1, 3, 2)) + a[:, [0, 1]] = np.ones((1, 3, 2)) + # Fancy without subspace (with broadcasting) + a[[[0], [1], [2]], [0, 1]] = np.ones((1, 3, 2)) + + def test_prepend_not_one(self): + assign = self.assign + s_ = np.s_ + a = np.zeros(5) + + # Too large and not only ones. + assert_raises(ValueError, assign, a, s_[...], np.ones((2, 1))) + assert_raises(ValueError, assign, a, s_[[1, 2, 3],], np.ones((2, 1))) + assert_raises(ValueError, assign, a, s_[[[1], [2]],], np.ones((2,2,1))) + + def test_simple_broadcasting_errors(self): + assign = self.assign + s_ = np.s_ + a = np.zeros((5, 1)) + + assert_raises(ValueError, assign, a, s_[...], np.zeros((5, 2))) + assert_raises(ValueError, assign, a, s_[...], np.zeros((5, 0))) + assert_raises(ValueError, assign, a, s_[:, [0]], np.zeros((5, 2))) + assert_raises(ValueError, assign, a, s_[:, [0]], np.zeros((5, 0))) + assert_raises(ValueError, assign, a, s_[[0], :], np.zeros((2, 1))) + + @pytest.mark.parametrize("index", [ + (..., [1, 2], slice(None)), + ([0, 1], ..., 0), + (..., [1, 2], [1, 2])]) + def test_broadcast_error_reports_correct_shape(self, index): + values = np.zeros((100, 100)) # will never broadcast below + + arr = np.zeros((3, 4, 5, 6, 7)) + # We currently report without any spaces (could be changed) + shape_str = str(arr[index].shape).replace(" ", "") + + with pytest.raises(ValueError) as e: + arr[index] = values + + assert str(e.value).endswith(shape_str) + + def test_index_is_larger(self): + # Simple case of fancy index broadcasting of the index. + a = np.zeros((5, 5)) + a[[[0], [1], [2]], [0, 1, 2]] = [2, 3, 4] + + assert_((a[:3, :3] == [2, 3, 4]).all()) + + def test_broadcast_subspace(self): + a = np.zeros((100, 100)) + v = np.arange(100)[:,None] + b = np.arange(100)[::-1] + a[b] = v + assert_((a[::-1] == v).all()) + + +class TestSubclasses: + def test_basic(self): + # Test that indexing in various ways produces SubClass instances, + # and that the base is set up correctly: the original subclass + # instance for views, and a new ndarray for advanced/boolean indexing + # where a copy was made (latter a regression test for gh-11983). + class SubClass(np.ndarray): + pass + + a = np.arange(5) + s = a.view(SubClass) + s_slice = s[:3] + assert_(type(s_slice) is SubClass) + assert_(s_slice.base is s) + assert_array_equal(s_slice, a[:3]) + + s_fancy = s[[0, 1, 2]] + assert_(type(s_fancy) is SubClass) + assert_(s_fancy.base is not s) + assert_(type(s_fancy.base) is np.ndarray) + assert_array_equal(s_fancy, a[[0, 1, 2]]) + assert_array_equal(s_fancy.base, a[[0, 1, 2]]) + + s_bool = s[s > 0] + assert_(type(s_bool) is SubClass) + assert_(s_bool.base is not s) + assert_(type(s_bool.base) is np.ndarray) + assert_array_equal(s_bool, a[a > 0]) + assert_array_equal(s_bool.base, a[a > 0]) + + def test_fancy_on_read_only(self): + # Test that fancy indexing on read-only SubClass does not make a + # read-only copy (gh-14132) + class SubClass(np.ndarray): + pass + + a = np.arange(5) + s = a.view(SubClass) + s.flags.writeable = False + s_fancy = s[[0, 1, 2]] + assert_(s_fancy.flags.writeable) + + + def test_finalize_gets_full_info(self): + # Array finalize should be called on the filled array. + class SubClass(np.ndarray): + def __array_finalize__(self, old): + self.finalize_status = np.array(self) + self.old = old + + s = np.arange(10).view(SubClass) + new_s = s[:3] + assert_array_equal(new_s.finalize_status, new_s) + assert_array_equal(new_s.old, s) + + new_s = s[[0,1,2,3]] + assert_array_equal(new_s.finalize_status, new_s) + assert_array_equal(new_s.old, s) + + new_s = s[s > 0] + assert_array_equal(new_s.finalize_status, new_s) + assert_array_equal(new_s.old, s) + + +class TestFancyIndexingCast: + def test_boolean_index_cast_assign(self): + # Setup the boolean index and float arrays. + shape = (8, 63) + bool_index = np.zeros(shape).astype(bool) + bool_index[0, 1] = True + zero_array = np.zeros(shape) + + # Assigning float is fine. + zero_array[bool_index] = np.array([1]) + assert_equal(zero_array[0, 1], 1) + + # Fancy indexing works, although we get a cast warning. + assert_warns(ComplexWarning, + zero_array.__setitem__, ([0], [1]), np.array([2 + 1j])) + assert_equal(zero_array[0, 1], 2) # No complex part + + # Cast complex to float, throwing away the imaginary portion. + assert_warns(ComplexWarning, + zero_array.__setitem__, bool_index, np.array([1j])) + assert_equal(zero_array[0, 1], 0) + +class TestFancyIndexingEquivalence: + def test_object_assign(self): + # Check that the field and object special case using copyto is active. + # The right hand side cannot be converted to an array here. + a = np.arange(5, dtype=object) + b = a.copy() + a[:3] = [1, (1,2), 3] + b[[0, 1, 2]] = [1, (1,2), 3] + assert_array_equal(a, b) + + # test same for subspace fancy indexing + b = np.arange(5, dtype=object)[None, :] + b[[0], :3] = [[1, (1,2), 3]] + assert_array_equal(a, b[0]) + + # Check that swapping of axes works. + # There was a bug that made the later assignment throw a ValueError + # do to an incorrectly transposed temporary right hand side (gh-5714) + b = b.T + b[:3, [0]] = [[1], [(1,2)], [3]] + assert_array_equal(a, b[:, 0]) + + # Another test for the memory order of the subspace + arr = np.ones((3, 4, 5), dtype=object) + # Equivalent slicing assignment for comparison + cmp_arr = arr.copy() + cmp_arr[:1, ...] = [[[1], [2], [3], [4]]] + arr[[0], ...] = [[[1], [2], [3], [4]]] + assert_array_equal(arr, cmp_arr) + arr = arr.copy('F') + arr[[0], ...] = [[[1], [2], [3], [4]]] + assert_array_equal(arr, cmp_arr) + + def test_cast_equivalence(self): + # Yes, normal slicing uses unsafe casting. + a = np.arange(5) + b = a.copy() + + a[:3] = np.array(['2', '-3', '-1']) + b[[0, 2, 1]] = np.array(['2', '-1', '-3']) + assert_array_equal(a, b) + + # test the same for subspace fancy indexing + b = np.arange(5)[None, :] + b[[0], :3] = np.array([['2', '-3', '-1']]) + assert_array_equal(a, b[0]) + + +class TestMultiIndexingAutomated: + """ + These tests use code to mimic the C-Code indexing for selection. + + NOTE: + + * This still lacks tests for complex item setting. + * If you change behavior of indexing, you might want to modify + these tests to try more combinations. + * Behavior was written to match numpy version 1.8. (though a + first version matched 1.7.) + * Only tuple indices are supported by the mimicking code. + (and tested as of writing this) + * Error types should match most of the time as long as there + is only one error. For multiple errors, what gets raised + will usually not be the same one. They are *not* tested. + + Update 2016-11-30: It is probably not worth maintaining this test + indefinitely and it can be dropped if maintenance becomes a burden. + + """ + + def setup_method(self): + self.a = np.arange(np.prod([3, 1, 5, 6])).reshape(3, 1, 5, 6) + self.b = np.empty((3, 0, 5, 6)) + self.complex_indices = ['skip', Ellipsis, + 0, + # Boolean indices, up to 3-d for some special cases of eating up + # dimensions, also need to test all False + np.array([True, False, False]), + np.array([[True, False], [False, True]]), + np.array([[[False, False], [False, False]]]), + # Some slices: + slice(-5, 5, 2), + slice(1, 1, 100), + slice(4, -1, -2), + slice(None, None, -3), + # Some Fancy indexes: + np.empty((0, 1, 1), dtype=np.intp), # empty and can be broadcast + np.array([0, 1, -2]), + np.array([[2], [0], [1]]), + np.array([[0, -1], [0, 1]], dtype=np.dtype('intp').newbyteorder()), + np.array([2, -1], dtype=np.int8), + np.zeros([1]*31, dtype=int), # trigger too large array. + np.array([0., 1.])] # invalid datatype + # Some simpler indices that still cover a bit more + self.simple_indices = [Ellipsis, None, -1, [1], np.array([True]), + 'skip'] + # Very simple ones to fill the rest: + self.fill_indices = [slice(None, None), 0] + + def _get_multi_index(self, arr, indices): + """Mimic multi dimensional indexing. + + Parameters + ---------- + arr : ndarray + Array to be indexed. + indices : tuple of index objects + + Returns + ------- + out : ndarray + An array equivalent to the indexing operation (but always a copy). + `arr[indices]` should be identical. + no_copy : bool + Whether the indexing operation requires a copy. If this is `True`, + `np.may_share_memory(arr, arr[indices])` should be `True` (with + some exceptions for scalars and possibly 0-d arrays). + + Notes + ----- + While the function may mostly match the errors of normal indexing this + is generally not the case. + """ + in_indices = list(indices) + indices = [] + # if False, this is a fancy or boolean index + no_copy = True + # number of fancy/scalar indexes that are not consecutive + num_fancy = 0 + # number of dimensions indexed by a "fancy" index + fancy_dim = 0 + # NOTE: This is a funny twist (and probably OK to change). + # The boolean array has illegal indexes, but this is + # allowed if the broadcast fancy-indices are 0-sized. + # This variable is to catch that case. + error_unless_broadcast_to_empty = False + + # We need to handle Ellipsis and make arrays from indices, also + # check if this is fancy indexing (set no_copy). + ndim = 0 + ellipsis_pos = None # define here mostly to replace all but first. + for i, indx in enumerate(in_indices): + if indx is None: + continue + if isinstance(indx, np.ndarray) and indx.dtype == bool: + no_copy = False + if indx.ndim == 0: + raise IndexError + # boolean indices can have higher dimensions + ndim += indx.ndim + fancy_dim += indx.ndim + continue + if indx is Ellipsis: + if ellipsis_pos is None: + ellipsis_pos = i + continue # do not increment ndim counter + raise IndexError + if isinstance(indx, slice): + ndim += 1 + continue + if not isinstance(indx, np.ndarray): + # This could be open for changes in numpy. + # numpy should maybe raise an error if casting to intp + # is not safe. It rejects np.array([1., 2.]) but not + # [1., 2.] as index (same for ie. np.take). + # (Note the importance of empty lists if changing this here) + try: + indx = np.array(indx, dtype=np.intp) + except ValueError: + raise IndexError + in_indices[i] = indx + elif indx.dtype.kind != 'b' and indx.dtype.kind != 'i': + raise IndexError('arrays used as indices must be of ' + 'integer (or boolean) type') + if indx.ndim != 0: + no_copy = False + ndim += 1 + fancy_dim += 1 + + if arr.ndim - ndim < 0: + # we can't take more dimensions then we have, not even for 0-d + # arrays. since a[()] makes sense, but not a[(),]. We will + # raise an error later on, unless a broadcasting error occurs + # first. + raise IndexError + + if ndim == 0 and None not in in_indices: + # Well we have no indexes or one Ellipsis. This is legal. + return arr.copy(), no_copy + + if ellipsis_pos is not None: + in_indices[ellipsis_pos:ellipsis_pos+1] = ([slice(None, None)] * + (arr.ndim - ndim)) + + for ax, indx in enumerate(in_indices): + if isinstance(indx, slice): + # convert to an index array + indx = np.arange(*indx.indices(arr.shape[ax])) + indices.append(['s', indx]) + continue + elif indx is None: + # this is like taking a slice with one element from a new axis: + indices.append(['n', np.array([0], dtype=np.intp)]) + arr = arr.reshape(arr.shape[:ax] + (1,) + arr.shape[ax:]) + continue + if isinstance(indx, np.ndarray) and indx.dtype == bool: + if indx.shape != arr.shape[ax:ax+indx.ndim]: + raise IndexError + + try: + flat_indx = np.ravel_multi_index(np.nonzero(indx), + arr.shape[ax:ax+indx.ndim], mode='raise') + except Exception: + error_unless_broadcast_to_empty = True + # fill with 0s instead, and raise error later + flat_indx = np.array([0]*indx.sum(), dtype=np.intp) + # concatenate axis into a single one: + if indx.ndim != 0: + arr = arr.reshape(arr.shape[:ax] + + (np.prod(arr.shape[ax:ax+indx.ndim]),) + + arr.shape[ax+indx.ndim:]) + indx = flat_indx + else: + # This could be changed, a 0-d boolean index can + # make sense (even outside the 0-d indexed array case) + # Note that originally this is could be interpreted as + # integer in the full integer special case. + raise IndexError + else: + # If the index is a singleton, the bounds check is done + # before the broadcasting. This used to be different in <1.9 + if indx.ndim == 0: + if indx >= arr.shape[ax] or indx < -arr.shape[ax]: + raise IndexError + if indx.ndim == 0: + # The index is a scalar. This used to be two fold, but if + # fancy indexing was active, the check was done later, + # possibly after broadcasting it away (1.7. or earlier). + # Now it is always done. + if indx >= arr.shape[ax] or indx < - arr.shape[ax]: + raise IndexError + if (len(indices) > 0 and + indices[-1][0] == 'f' and + ax != ellipsis_pos): + # NOTE: There could still have been a 0-sized Ellipsis + # between them. Checked that with ellipsis_pos. + indices[-1].append(indx) + else: + # We have a fancy index that is not after an existing one. + # NOTE: A 0-d array triggers this as well, while one may + # expect it to not trigger it, since a scalar would not be + # considered fancy indexing. + num_fancy += 1 + indices.append(['f', indx]) + + if num_fancy > 1 and not no_copy: + # We have to flush the fancy indexes left + new_indices = indices[:] + axes = list(range(arr.ndim)) + fancy_axes = [] + new_indices.insert(0, ['f']) + ni = 0 + ai = 0 + for indx in indices: + ni += 1 + if indx[0] == 'f': + new_indices[0].extend(indx[1:]) + del new_indices[ni] + ni -= 1 + for ax in range(ai, ai + len(indx[1:])): + fancy_axes.append(ax) + axes.remove(ax) + ai += len(indx) - 1 # axis we are at + indices = new_indices + # and now we need to transpose arr: + arr = arr.transpose(*(fancy_axes + axes)) + + # We only have one 'f' index now and arr is transposed accordingly. + # Now handle newaxis by reshaping... + ax = 0 + for indx in indices: + if indx[0] == 'f': + if len(indx) == 1: + continue + # First of all, reshape arr to combine fancy axes into one: + orig_shape = arr.shape + orig_slice = orig_shape[ax:ax + len(indx[1:])] + arr = arr.reshape(arr.shape[:ax] + + (np.prod(orig_slice).astype(int),) + + arr.shape[ax + len(indx[1:]):]) + + # Check if broadcasting works + res = np.broadcast(*indx[1:]) + # unfortunately the indices might be out of bounds. So check + # that first, and use mode='wrap' then. However only if + # there are any indices... + if res.size != 0: + if error_unless_broadcast_to_empty: + raise IndexError + for _indx, _size in zip(indx[1:], orig_slice): + if _indx.size == 0: + continue + if np.any(_indx >= _size) or np.any(_indx < -_size): + raise IndexError + if len(indx[1:]) == len(orig_slice): + if np.prod(orig_slice) == 0: + # Work around for a crash or IndexError with 'wrap' + # in some 0-sized cases. + try: + mi = np.ravel_multi_index(indx[1:], orig_slice, + mode='raise') + except Exception: + # This happens with 0-sized orig_slice (sometimes?) + # here it is a ValueError, but indexing gives a: + raise IndexError('invalid index into 0-sized') + else: + mi = np.ravel_multi_index(indx[1:], orig_slice, + mode='wrap') + else: + # Maybe never happens... + raise ValueError + arr = arr.take(mi.ravel(), axis=ax) + try: + arr = arr.reshape(arr.shape[:ax] + + mi.shape + + arr.shape[ax+1:]) + except ValueError: + # too many dimensions, probably + raise IndexError + ax += mi.ndim + continue + + # If we are here, we have a 1D array for take: + arr = arr.take(indx[1], axis=ax) + ax += 1 + + return arr, no_copy + + def _check_multi_index(self, arr, index): + """Check a multi index item getting and simple setting. + + Parameters + ---------- + arr : ndarray + Array to be indexed, must be a reshaped arange. + index : tuple of indexing objects + Index being tested. + """ + # Test item getting + try: + mimic_get, no_copy = self._get_multi_index(arr, index) + except Exception as e: + if HAS_REFCOUNT: + prev_refcount = sys.getrefcount(arr) + assert_raises(type(e), arr.__getitem__, index) + assert_raises(type(e), arr.__setitem__, index, 0) + if HAS_REFCOUNT: + assert_equal(prev_refcount, sys.getrefcount(arr)) + return + + self._compare_index_result(arr, index, mimic_get, no_copy) + + def _check_single_index(self, arr, index): + """Check a single index item getting and simple setting. + + Parameters + ---------- + arr : ndarray + Array to be indexed, must be an arange. + index : indexing object + Index being tested. Must be a single index and not a tuple + of indexing objects (see also `_check_multi_index`). + """ + try: + mimic_get, no_copy = self._get_multi_index(arr, (index,)) + except Exception as e: + if HAS_REFCOUNT: + prev_refcount = sys.getrefcount(arr) + assert_raises(type(e), arr.__getitem__, index) + assert_raises(type(e), arr.__setitem__, index, 0) + if HAS_REFCOUNT: + assert_equal(prev_refcount, sys.getrefcount(arr)) + return + + self._compare_index_result(arr, index, mimic_get, no_copy) + + def _compare_index_result(self, arr, index, mimic_get, no_copy): + """Compare mimicked result to indexing result. + """ + arr = arr.copy() + indexed_arr = arr[index] + assert_array_equal(indexed_arr, mimic_get) + # Check if we got a view, unless its a 0-sized or 0-d array. + # (then its not a view, and that does not matter) + if indexed_arr.size != 0 and indexed_arr.ndim != 0: + assert_(np.may_share_memory(indexed_arr, arr) == no_copy) + # Check reference count of the original array + if HAS_REFCOUNT: + if no_copy: + # refcount increases by one: + assert_equal(sys.getrefcount(arr), 3) + else: + assert_equal(sys.getrefcount(arr), 2) + + # Test non-broadcast setitem: + b = arr.copy() + b[index] = mimic_get + 1000 + if b.size == 0: + return # nothing to compare here... + if no_copy and indexed_arr.ndim != 0: + # change indexed_arr in-place to manipulate original: + indexed_arr += 1000 + assert_array_equal(arr, b) + return + # Use the fact that the array is originally an arange: + arr.flat[indexed_arr.ravel()] += 1000 + assert_array_equal(arr, b) + + def test_boolean(self): + a = np.array(5) + assert_equal(a[np.array(True)], 5) + a[np.array(True)] = 1 + assert_equal(a, 1) + # NOTE: This is different from normal broadcasting, as + # arr[boolean_array] works like in a multi index. Which means + # it is aligned to the left. This is probably correct for + # consistency with arr[boolean_array,] also no broadcasting + # is done at all + self._check_multi_index( + self.a, (np.zeros_like(self.a, dtype=bool),)) + self._check_multi_index( + self.a, (np.zeros_like(self.a, dtype=bool)[..., 0],)) + self._check_multi_index( + self.a, (np.zeros_like(self.a, dtype=bool)[None, ...],)) + + def test_multidim(self): + # Automatically test combinations with complex indexes on 2nd (or 1st) + # spot and the simple ones in one other spot. + with warnings.catch_warnings(): + # This is so that np.array(True) is not accepted in a full integer + # index, when running the file separately. + warnings.filterwarnings('error', '', DeprecationWarning) + warnings.filterwarnings('error', '', VisibleDeprecationWarning) + + def isskip(idx): + return isinstance(idx, str) and idx == "skip" + + for simple_pos in [0, 2, 3]: + tocheck = [self.fill_indices, self.complex_indices, + self.fill_indices, self.fill_indices] + tocheck[simple_pos] = self.simple_indices + for index in product(*tocheck): + index = tuple(i for i in index if not isskip(i)) + self._check_multi_index(self.a, index) + self._check_multi_index(self.b, index) + + # Check very simple item getting: + self._check_multi_index(self.a, (0, 0, 0, 0)) + self._check_multi_index(self.b, (0, 0, 0, 0)) + # Also check (simple cases of) too many indices: + assert_raises(IndexError, self.a.__getitem__, (0, 0, 0, 0, 0)) + assert_raises(IndexError, self.a.__setitem__, (0, 0, 0, 0, 0), 0) + assert_raises(IndexError, self.a.__getitem__, (0, 0, [1], 0, 0)) + assert_raises(IndexError, self.a.__setitem__, (0, 0, [1], 0, 0), 0) + + def test_1d(self): + a = np.arange(10) + for index in self.complex_indices: + self._check_single_index(a, index) + +class TestFloatNonIntegerArgument: + """ + These test that ``TypeError`` is raised when you try to use + non-integers as arguments to for indexing and slicing e.g. ``a[0.0:5]`` + and ``a[0.5]``, or other functions like ``array.reshape(1., -1)``. + + """ + def test_valid_indexing(self): + # These should raise no errors. + a = np.array([[[5]]]) + + a[np.array([0])] + a[[0, 0]] + a[:, [0, 0]] + a[:, 0,:] + a[:,:,:] + + def test_valid_slicing(self): + # These should raise no errors. + a = np.array([[[5]]]) + + a[::] + a[0:] + a[:2] + a[0:2] + a[::2] + a[1::2] + a[:2:2] + a[1:2:2] + + def test_non_integer_argument_errors(self): + a = np.array([[5]]) + + assert_raises(TypeError, np.reshape, a, (1., 1., -1)) + assert_raises(TypeError, np.reshape, a, (np.array(1.), -1)) + assert_raises(TypeError, np.take, a, [0], 1.) + assert_raises(TypeError, np.take, a, [0], np.float64(1.)) + + def test_non_integer_sequence_multiplication(self): + # NumPy scalar sequence multiply should not work with non-integers + def mult(a, b): + return a * b + + assert_raises(TypeError, mult, [1], np.float64(3)) + # following should be OK + mult([1], np.int_(3)) + + def test_reduce_axis_float_index(self): + d = np.zeros((3,3,3)) + assert_raises(TypeError, np.min, d, 0.5) + assert_raises(TypeError, np.min, d, (0.5, 1)) + assert_raises(TypeError, np.min, d, (1, 2.2)) + assert_raises(TypeError, np.min, d, (.2, 1.2)) + + +class TestBooleanIndexing: + # Using a boolean as integer argument/indexing is an error. + def test_bool_as_int_argument_errors(self): + a = np.array([[[1]]]) + + assert_raises(TypeError, np.reshape, a, (True, -1)) + assert_raises(TypeError, np.reshape, a, (np.bool(True), -1)) + # Note that operator.index(np.array(True)) does not work, a boolean + # array is thus also deprecated, but not with the same message: + assert_raises(TypeError, operator.index, np.array(True)) + assert_warns(DeprecationWarning, operator.index, np.True_) + assert_raises(TypeError, np.take, args=(a, [0], False)) + + def test_boolean_indexing_weirdness(self): + # Weird boolean indexing things + a = np.ones((2, 3, 4)) + assert a[False, True, ...].shape == (0, 2, 3, 4) + assert a[True, [0, 1], True, True, [1], [[2]]].shape == (1, 2) + assert_raises(IndexError, lambda: a[False, [0, 1], ...]) + + def test_boolean_indexing_fast_path(self): + # These used to either give the wrong error, or incorrectly give no + # error. + a = np.ones((3, 3)) + + # This used to incorrectly work (and give an array of shape (0,)) + idx1 = np.array([[False]*9]) + assert_raises_regex(IndexError, + "boolean index did not match indexed array along axis 0; " + "size of axis is 3 but size of corresponding boolean axis is 1", + lambda: a[idx1]) + + # This used to incorrectly give a ValueError: operands could not be broadcast together + idx2 = np.array([[False]*8 + [True]]) + assert_raises_regex(IndexError, + "boolean index did not match indexed array along axis 0; " + "size of axis is 3 but size of corresponding boolean axis is 1", + lambda: a[idx2]) + + # This is the same as it used to be. The above two should work like this. + idx3 = np.array([[False]*10]) + assert_raises_regex(IndexError, + "boolean index did not match indexed array along axis 0; " + "size of axis is 3 but size of corresponding boolean axis is 1", + lambda: a[idx3]) + + # This used to give ValueError: non-broadcastable operand + a = np.ones((1, 1, 2)) + idx = np.array([[[True], [False]]]) + assert_raises_regex(IndexError, + "boolean index did not match indexed array along axis 1; " + "size of axis is 1 but size of corresponding boolean axis is 2", + lambda: a[idx]) + + +class TestArrayToIndexDeprecation: + """Creating an index from array not 0-D is an error. + + """ + def test_array_to_index_error(self): + # so no exception is expected. The raising is effectively tested above. + a = np.array([[[1]]]) + + assert_raises(TypeError, operator.index, np.array([1])) + assert_raises(TypeError, np.reshape, a, (a, -1)) + assert_raises(TypeError, np.take, a, [0], a) + + +class TestNonIntegerArrayLike: + """Tests that array_likes only valid if can safely cast to integer. + + For instance, lists give IndexError when they cannot be safely cast to + an integer. + + """ + def test_basic(self): + a = np.arange(10) + + assert_raises(IndexError, a.__getitem__, [0.5, 1.5]) + assert_raises(IndexError, a.__getitem__, (['1', '2'],)) + + # The following is valid + a.__getitem__([]) + + +class TestMultipleEllipsisError: + """An index can only have a single ellipsis. + + """ + def test_basic(self): + a = np.arange(10) + assert_raises(IndexError, lambda: a[..., ...]) + assert_raises(IndexError, a.__getitem__, ((Ellipsis,) * 2,)) + assert_raises(IndexError, a.__getitem__, ((Ellipsis,) * 3,)) + + +class TestCApiAccess: + def test_getitem(self): + subscript = functools.partial(array_indexing, 0) + + # 0-d arrays don't work: + assert_raises(IndexError, subscript, np.ones(()), 0) + # Out of bound values: + assert_raises(IndexError, subscript, np.ones(10), 11) + assert_raises(IndexError, subscript, np.ones(10), -11) + assert_raises(IndexError, subscript, np.ones((10, 10)), 11) + assert_raises(IndexError, subscript, np.ones((10, 10)), -11) + + a = np.arange(10) + assert_array_equal(a[4], subscript(a, 4)) + a = a.reshape(5, 2) + assert_array_equal(a[-4], subscript(a, -4)) + + def test_setitem(self): + assign = functools.partial(array_indexing, 1) + + # Deletion is impossible: + assert_raises(ValueError, assign, np.ones(10), 0) + # 0-d arrays don't work: + assert_raises(IndexError, assign, np.ones(()), 0, 0) + # Out of bound values: + assert_raises(IndexError, assign, np.ones(10), 11, 0) + assert_raises(IndexError, assign, np.ones(10), -11, 0) + assert_raises(IndexError, assign, np.ones((10, 10)), 11, 0) + assert_raises(IndexError, assign, np.ones((10, 10)), -11, 0) + + a = np.arange(10) + assign(a, 4, 10) + assert_(a[4] == 10) + + a = a.reshape(5, 2) + assign(a, 4, 10) + assert_array_equal(a[-1], [10, 10]) diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/test_item_selection.py b/venv/lib/python3.12/site-packages/numpy/_core/tests/test_item_selection.py new file mode 100644 index 00000000..5660ef58 --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/tests/test_item_selection.py @@ -0,0 +1,165 @@ +import sys + +import pytest + +import numpy as np +from numpy.testing import ( + assert_, assert_raises, assert_array_equal, HAS_REFCOUNT + ) + + +class TestTake: + def test_simple(self): + a = [[1, 2], [3, 4]] + a_str = [[b'1', b'2'], [b'3', b'4']] + modes = ['raise', 'wrap', 'clip'] + indices = [-1, 4] + index_arrays = [np.empty(0, dtype=np.intp), + np.empty(tuple(), dtype=np.intp), + np.empty((1, 1), dtype=np.intp)] + real_indices = {'raise': {-1: 1, 4: IndexError}, + 'wrap': {-1: 1, 4: 0}, + 'clip': {-1: 0, 4: 1}} + # Currently all types but object, use the same function generation. + # So it should not be necessary to test all. However test also a non + # refcounted struct on top of object, which has a size that hits the + # default (non-specialized) path. + types = int, object, np.dtype([('', 'i2', 3)]) + for t in types: + # ta works, even if the array may be odd if buffer interface is used + ta = np.array(a if np.issubdtype(t, np.number) else a_str, dtype=t) + tresult = list(ta.T.copy()) + for index_array in index_arrays: + if index_array.size != 0: + tresult[0].shape = (2,) + index_array.shape + tresult[1].shape = (2,) + index_array.shape + for mode in modes: + for index in indices: + real_index = real_indices[mode][index] + if real_index is IndexError and index_array.size != 0: + index_array.put(0, index) + assert_raises(IndexError, ta.take, index_array, + mode=mode, axis=1) + elif index_array.size != 0: + index_array.put(0, index) + res = ta.take(index_array, mode=mode, axis=1) + assert_array_equal(res, tresult[real_index]) + else: + res = ta.take(index_array, mode=mode, axis=1) + assert_(res.shape == (2,) + index_array.shape) + + def test_refcounting(self): + objects = [object() for i in range(10)] + for mode in ('raise', 'clip', 'wrap'): + a = np.array(objects) + b = np.array([2, 2, 4, 5, 3, 5]) + a.take(b, out=a[:6], mode=mode) + del a + if HAS_REFCOUNT: + assert_(all(sys.getrefcount(o) == 3 for o in objects)) + # not contiguous, example: + a = np.array(objects * 2)[::2] + a.take(b, out=a[:6], mode=mode) + del a + if HAS_REFCOUNT: + assert_(all(sys.getrefcount(o) == 3 for o in objects)) + + def test_unicode_mode(self): + d = np.arange(10) + k = b'\xc3\xa4'.decode("UTF8") + assert_raises(ValueError, d.take, 5, mode=k) + + def test_empty_partition(self): + # In reference to github issue #6530 + a_original = np.array([0, 2, 4, 6, 8, 10]) + a = a_original.copy() + + # An empty partition should be a successful no-op + a.partition(np.array([], dtype=np.int16)) + + assert_array_equal(a, a_original) + + def test_empty_argpartition(self): + # In reference to github issue #6530 + a = np.array([0, 2, 4, 6, 8, 10]) + a = a.argpartition(np.array([], dtype=np.int16)) + + b = np.array([0, 1, 2, 3, 4, 5]) + assert_array_equal(a, b) + + +class TestPutMask: + @pytest.mark.parametrize("dtype", list(np.typecodes["All"]) + ["i,O"]) + def test_simple(self, dtype): + if dtype.lower() == "m": + dtype += "8[ns]" + + # putmask is weird and doesn't care about value length (even shorter) + vals = np.arange(1001).astype(dtype=dtype) + + mask = np.random.randint(2, size=1000).astype(bool) + # Use vals.dtype in case of flexible dtype (i.e. string) + arr = np.zeros(1000, dtype=vals.dtype) + zeros = arr.copy() + + np.putmask(arr, mask, vals) + assert_array_equal(arr[mask], vals[:len(mask)][mask]) + assert_array_equal(arr[~mask], zeros[~mask]) + + @pytest.mark.parametrize("dtype", list(np.typecodes["All"])[1:] + ["i,O"]) + @pytest.mark.parametrize("mode", ["raise", "wrap", "clip"]) + def test_empty(self, dtype, mode): + arr = np.zeros(1000, dtype=dtype) + arr_copy = arr.copy() + mask = np.random.randint(2, size=1000).astype(bool) + + # Allowing empty values like this is weird... + np.put(arr, mask, []) + assert_array_equal(arr, arr_copy) + + +class TestPut: + @pytest.mark.parametrize("dtype", list(np.typecodes["All"])[1:] + ["i,O"]) + @pytest.mark.parametrize("mode", ["raise", "wrap", "clip"]) + def test_simple(self, dtype, mode): + if dtype.lower() == "m": + dtype += "8[ns]" + + # put is weird and doesn't care about value length (even shorter) + vals = np.arange(1001).astype(dtype=dtype) + + # Use vals.dtype in case of flexible dtype (i.e. string) + arr = np.zeros(1000, dtype=vals.dtype) + zeros = arr.copy() + + if mode == "clip": + # Special because 0 and -1 value are "reserved" for clip test + indx = np.random.permutation(len(arr) - 2)[:-500] + 1 + + indx[-1] = 0 + indx[-2] = len(arr) - 1 + indx_put = indx.copy() + indx_put[-1] = -1389 + indx_put[-2] = 1321 + else: + # Avoid duplicates (for simplicity) and fill half only + indx = np.random.permutation(len(arr) - 3)[:-500] + indx_put = indx + if mode == "wrap": + indx_put = indx_put + len(arr) + + np.put(arr, indx_put, vals, mode=mode) + assert_array_equal(arr[indx], vals[:len(indx)]) + untouched = np.ones(len(arr), dtype=bool) + untouched[indx] = False + assert_array_equal(arr[untouched], zeros[:untouched.sum()]) + + @pytest.mark.parametrize("dtype", list(np.typecodes["All"])[1:] + ["i,O"]) + @pytest.mark.parametrize("mode", ["raise", "wrap", "clip"]) + def test_empty(self, dtype, mode): + arr = np.zeros(1000, dtype=dtype) + arr_copy = arr.copy() + + # Allowing empty values like this is weird... + np.put(arr, [1, 2, 3], []) + assert_array_equal(arr, arr_copy) diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/test_limited_api.py b/venv/lib/python3.12/site-packages/numpy/_core/tests/test_limited_api.py new file mode 100644 index 00000000..5a23b491 --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/tests/test_limited_api.py @@ -0,0 +1,91 @@ +import os +import shutil +import subprocess +import sys +import sysconfig +import pytest + +from numpy.testing import IS_WASM, IS_PYPY, NOGIL_BUILD, IS_EDITABLE + +# This import is copied from random.tests.test_extending +try: + import cython + from Cython.Compiler.Version import version as cython_version +except ImportError: + cython = None +else: + from numpy._utils import _pep440 + + # Note: keep in sync with the one in pyproject.toml + required_version = "3.0.6" + if _pep440.parse(cython_version) < _pep440.Version(required_version): + # too old or wrong cython, skip the test + cython = None + +pytestmark = pytest.mark.skipif(cython is None, reason="requires cython") + + +if IS_EDITABLE: + pytest.skip( + "Editable install doesn't support tests with a compile step", + allow_module_level=True + ) + + +@pytest.fixture(scope='module') +def install_temp(tmpdir_factory): + # Based in part on test_cython from random.tests.test_extending + if IS_WASM: + pytest.skip("No subprocess") + + srcdir = os.path.join(os.path.dirname(__file__), 'examples', 'limited_api') + build_dir = tmpdir_factory.mktemp("limited_api") / "build" + os.makedirs(build_dir, exist_ok=True) + try: + subprocess.check_call(["meson", "--version"]) + except FileNotFoundError: + pytest.skip("No usable 'meson' found") + if sys.platform == "win32": + subprocess.check_call(["meson", "setup", + "--werror", + "--buildtype=release", + "--vsenv", str(srcdir)], + cwd=build_dir, + ) + else: + subprocess.check_call(["meson", "setup", "--werror", str(srcdir)], + cwd=build_dir + ) + try: + subprocess.check_call( + ["meson", "compile", "-vv"], cwd=build_dir) + except subprocess.CalledProcessError as p: + print(f"{p.stdout=}") + print(f"{p.stderr=}") + raise + + sys.path.append(str(build_dir)) + + + +@pytest.mark.skipif(IS_WASM, reason="Can't start subprocess") +@pytest.mark.xfail( + sysconfig.get_config_var("Py_DEBUG"), + reason=( + "Py_LIMITED_API is incompatible with Py_DEBUG, Py_TRACE_REFS, " + "and Py_REF_DEBUG" + ), +) +@pytest.mark.xfail( + NOGIL_BUILD, + reason="Py_GIL_DISABLED builds do not currently support the limited API", +) +@pytest.mark.skipif(IS_PYPY, reason="no support for limited API in PyPy") +def test_limited_api(install_temp): + """Test building a third-party C extension with the limited API + and building a cython extension with the limited API + """ + + import limited_api1 # Earliest (3.6) + import limited_api_latest # Latest version (current Python) + import limited_api2 # cython diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/test_longdouble.py b/venv/lib/python3.12/site-packages/numpy/_core/tests/test_longdouble.py new file mode 100644 index 00000000..a7ad5c9e --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/tests/test_longdouble.py @@ -0,0 +1,395 @@ +import warnings +import platform +import pytest + +import numpy as np +from numpy.testing import ( + assert_, assert_equal, assert_raises, assert_warns, assert_array_equal, + temppath, IS_MUSL + ) +from numpy._core.tests._locales import CommaDecimalPointLocale + + +LD_INFO = np.finfo(np.longdouble) +longdouble_longer_than_double = (LD_INFO.eps < np.finfo(np.double).eps) + + +_o = 1 + LD_INFO.eps +string_to_longdouble_inaccurate = (_o != np.longdouble(str(_o))) +del _o + + +def test_scalar_extraction(): + """Confirm that extracting a value doesn't convert to python float""" + o = 1 + LD_INFO.eps + a = np.array([o, o, o]) + assert_equal(a[1], o) + + +# Conversions string -> long double + +# 0.1 not exactly representable in base 2 floating point. +repr_precision = len(repr(np.longdouble(0.1))) +# +2 from macro block starting around line 842 in scalartypes.c.src. + + +@pytest.mark.skipif(IS_MUSL, + reason="test flaky on musllinux") +@pytest.mark.skipif(LD_INFO.precision + 2 >= repr_precision, + reason="repr precision not enough to show eps") +def test_str_roundtrip(): + # We will only see eps in repr if within printing precision. + o = 1 + LD_INFO.eps + assert_equal(np.longdouble(str(o)), o, "str was %s" % str(o)) + + +@pytest.mark.skipif(string_to_longdouble_inaccurate, reason="Need strtold_l") +def test_str_roundtrip_bytes(): + o = 1 + LD_INFO.eps + assert_equal(np.longdouble(str(o).encode("ascii")), o) + + +@pytest.mark.skipif(string_to_longdouble_inaccurate, reason="Need strtold_l") +@pytest.mark.parametrize("strtype", (np.str_, np.bytes_, str, bytes)) +def test_array_and_stringlike_roundtrip(strtype): + """ + Test that string representations of long-double roundtrip both + for array casting and scalar coercion, see also gh-15608. + """ + o = 1 + LD_INFO.eps + + if strtype in (np.bytes_, bytes): + o_str = strtype(str(o).encode("ascii")) + else: + o_str = strtype(str(o)) + + # Test that `o` is correctly coerced from the string-like + assert o == np.longdouble(o_str) + + # Test that arrays also roundtrip correctly: + o_strarr = np.asarray([o] * 3, dtype=strtype) + assert (o == o_strarr.astype(np.longdouble)).all() + + # And array coercion and casting to string give the same as scalar repr: + assert (o_strarr == o_str).all() + assert (np.asarray([o] * 3).astype(strtype) == o_str).all() + + +def test_bogus_string(): + assert_raises(ValueError, np.longdouble, "spam") + assert_raises(ValueError, np.longdouble, "1.0 flub") + + +@pytest.mark.skipif(string_to_longdouble_inaccurate, reason="Need strtold_l") +def test_fromstring(): + o = 1 + LD_INFO.eps + s = (" " + str(o))*5 + a = np.array([o]*5) + assert_equal(np.fromstring(s, sep=" ", dtype=np.longdouble), a, + err_msg="reading '%s'" % s) + + +def test_fromstring_complex(): + for ctype in ["complex", "cdouble"]: + # Check spacing between separator + assert_equal(np.fromstring("1, 2 , 3 ,4", sep=",", dtype=ctype), + np.array([1., 2., 3., 4.])) + # Real component not specified + assert_equal(np.fromstring("1j, -2j, 3j, 4e1j", sep=",", dtype=ctype), + np.array([1.j, -2.j, 3.j, 40.j])) + # Both components specified + assert_equal(np.fromstring("1+1j,2-2j, -3+3j, -4e1+4j", sep=",", dtype=ctype), + np.array([1. + 1.j, 2. - 2.j, - 3. + 3.j, - 40. + 4j])) + # Spaces at wrong places + with assert_warns(DeprecationWarning): + assert_equal(np.fromstring("1+2 j,3", dtype=ctype, sep=","), + np.array([1.])) + with assert_warns(DeprecationWarning): + assert_equal(np.fromstring("1+ 2j,3", dtype=ctype, sep=","), + np.array([1.])) + with assert_warns(DeprecationWarning): + assert_equal(np.fromstring("1 +2j,3", dtype=ctype, sep=","), + np.array([1.])) + with assert_warns(DeprecationWarning): + assert_equal(np.fromstring("1+j", dtype=ctype, sep=","), + np.array([1.])) + with assert_warns(DeprecationWarning): + assert_equal(np.fromstring("1+", dtype=ctype, sep=","), + np.array([1.])) + with assert_warns(DeprecationWarning): + assert_equal(np.fromstring("1j+1", dtype=ctype, sep=","), + np.array([1j])) + + +def test_fromstring_bogus(): + with assert_warns(DeprecationWarning): + assert_equal(np.fromstring("1. 2. 3. flop 4.", dtype=float, sep=" "), + np.array([1., 2., 3.])) + + +def test_fromstring_empty(): + with assert_warns(DeprecationWarning): + assert_equal(np.fromstring("xxxxx", sep="x"), + np.array([])) + + +def test_fromstring_missing(): + with assert_warns(DeprecationWarning): + assert_equal(np.fromstring("1xx3x4x5x6", sep="x"), + np.array([1])) + + +class TestFileBased: + + ldbl = 1 + LD_INFO.eps + tgt = np.array([ldbl]*5) + out = ''.join([str(t) + '\n' for t in tgt]) + + def test_fromfile_bogus(self): + with temppath() as path: + with open(path, 'w') as f: + f.write("1. 2. 3. flop 4.\n") + + with assert_warns(DeprecationWarning): + res = np.fromfile(path, dtype=float, sep=" ") + assert_equal(res, np.array([1., 2., 3.])) + + def test_fromfile_complex(self): + for ctype in ["complex", "cdouble"]: + # Check spacing between separator and only real component specified + with temppath() as path: + with open(path, 'w') as f: + f.write("1, 2 , 3 ,4\n") + + res = np.fromfile(path, dtype=ctype, sep=",") + assert_equal(res, np.array([1., 2., 3., 4.])) + + # Real component not specified + with temppath() as path: + with open(path, 'w') as f: + f.write("1j, -2j, 3j, 4e1j\n") + + res = np.fromfile(path, dtype=ctype, sep=",") + assert_equal(res, np.array([1.j, -2.j, 3.j, 40.j])) + + # Both components specified + with temppath() as path: + with open(path, 'w') as f: + f.write("1+1j,2-2j, -3+3j, -4e1+4j\n") + + res = np.fromfile(path, dtype=ctype, sep=",") + assert_equal(res, np.array([1. + 1.j, 2. - 2.j, - 3. + 3.j, - 40. + 4j])) + + # Spaces at wrong places + with temppath() as path: + with open(path, 'w') as f: + f.write("1+2 j,3\n") + + with assert_warns(DeprecationWarning): + res = np.fromfile(path, dtype=ctype, sep=",") + assert_equal(res, np.array([1.])) + + # Spaces at wrong places + with temppath() as path: + with open(path, 'w') as f: + f.write("1+ 2j,3\n") + + with assert_warns(DeprecationWarning): + res = np.fromfile(path, dtype=ctype, sep=",") + assert_equal(res, np.array([1.])) + + # Spaces at wrong places + with temppath() as path: + with open(path, 'w') as f: + f.write("1 +2j,3\n") + + with assert_warns(DeprecationWarning): + res = np.fromfile(path, dtype=ctype, sep=",") + assert_equal(res, np.array([1.])) + + # Spaces at wrong places + with temppath() as path: + with open(path, 'w') as f: + f.write("1+j\n") + + with assert_warns(DeprecationWarning): + res = np.fromfile(path, dtype=ctype, sep=",") + assert_equal(res, np.array([1.])) + + # Spaces at wrong places + with temppath() as path: + with open(path, 'w') as f: + f.write("1+\n") + + with assert_warns(DeprecationWarning): + res = np.fromfile(path, dtype=ctype, sep=",") + assert_equal(res, np.array([1.])) + + # Spaces at wrong places + with temppath() as path: + with open(path, 'w') as f: + f.write("1j+1\n") + + with assert_warns(DeprecationWarning): + res = np.fromfile(path, dtype=ctype, sep=",") + assert_equal(res, np.array([1.j])) + + + + @pytest.mark.skipif(string_to_longdouble_inaccurate, + reason="Need strtold_l") + def test_fromfile(self): + with temppath() as path: + with open(path, 'w') as f: + f.write(self.out) + res = np.fromfile(path, dtype=np.longdouble, sep="\n") + assert_equal(res, self.tgt) + + @pytest.mark.skipif(string_to_longdouble_inaccurate, + reason="Need strtold_l") + def test_genfromtxt(self): + with temppath() as path: + with open(path, 'w') as f: + f.write(self.out) + res = np.genfromtxt(path, dtype=np.longdouble) + assert_equal(res, self.tgt) + + @pytest.mark.skipif(string_to_longdouble_inaccurate, + reason="Need strtold_l") + def test_loadtxt(self): + with temppath() as path: + with open(path, 'w') as f: + f.write(self.out) + res = np.loadtxt(path, dtype=np.longdouble) + assert_equal(res, self.tgt) + + @pytest.mark.skipif(string_to_longdouble_inaccurate, + reason="Need strtold_l") + def test_tofile_roundtrip(self): + with temppath() as path: + self.tgt.tofile(path, sep=" ") + res = np.fromfile(path, dtype=np.longdouble, sep=" ") + assert_equal(res, self.tgt) + + +# Conversions long double -> string + + +def test_str_exact(): + o = 1 + LD_INFO.eps + assert_(str(o) != '1') + + +@pytest.mark.skipif(longdouble_longer_than_double, reason="BUG #2376") +@pytest.mark.skipif(string_to_longdouble_inaccurate, + reason="Need strtold_l") +def test_format(): + o = 1 + LD_INFO.eps + assert_("{0:.40g}".format(o) != '1') + + +@pytest.mark.skipif(longdouble_longer_than_double, reason="BUG #2376") +@pytest.mark.skipif(string_to_longdouble_inaccurate, + reason="Need strtold_l") +def test_percent(): + o = 1 + LD_INFO.eps + assert_("%.40g" % o != '1') + + +@pytest.mark.skipif(longdouble_longer_than_double, + reason="array repr problem") +@pytest.mark.skipif(string_to_longdouble_inaccurate, + reason="Need strtold_l") +def test_array_repr(): + o = 1 + LD_INFO.eps + a = np.array([o]) + b = np.array([1], dtype=np.longdouble) + if not np.all(a != b): + raise ValueError("precision loss creating arrays") + assert_(repr(a) != repr(b)) + +# +# Locale tests: scalar types formatting should be independent of the locale +# + +class TestCommaDecimalPointLocale(CommaDecimalPointLocale): + + def test_str_roundtrip_foreign(self): + o = 1.5 + assert_equal(o, np.longdouble(str(o))) + + def test_fromstring_foreign_repr(self): + f = 1.234 + a = np.fromstring(repr(f), dtype=float, sep=" ") + assert_equal(a[0], f) + + def test_fromstring_best_effort_float(self): + with assert_warns(DeprecationWarning): + assert_equal(np.fromstring("1,234", dtype=float, sep=" "), + np.array([1.])) + + def test_fromstring_best_effort(self): + with assert_warns(DeprecationWarning): + assert_equal(np.fromstring("1,234", dtype=np.longdouble, sep=" "), + np.array([1.])) + + def test_fromstring_foreign(self): + s = "1.234" + a = np.fromstring(s, dtype=np.longdouble, sep=" ") + assert_equal(a[0], np.longdouble(s)) + + def test_fromstring_foreign_sep(self): + a = np.array([1, 2, 3, 4]) + b = np.fromstring("1,2,3,4,", dtype=np.longdouble, sep=",") + assert_array_equal(a, b) + + def test_fromstring_foreign_value(self): + with assert_warns(DeprecationWarning): + b = np.fromstring("1,234", dtype=np.longdouble, sep=" ") + assert_array_equal(b[0], 1) + + +@pytest.mark.parametrize("int_val", [ + # cases discussed in gh-10723 + # and gh-9968 + 2 ** 1024, 0]) +def test_longdouble_from_int(int_val): + # for issue gh-9968 + str_val = str(int_val) + # we'll expect a RuntimeWarning on platforms + # with np.longdouble equivalent to np.double + # for large integer input + with warnings.catch_warnings(record=True) as w: + warnings.filterwarnings('always', '', RuntimeWarning) + # can be inf==inf on some platforms + assert np.longdouble(int_val) == np.longdouble(str_val) + # we can't directly compare the int and + # max longdouble value on all platforms + if np.allclose(np.finfo(np.longdouble).max, + np.finfo(np.double).max) and w: + assert w[0].category is RuntimeWarning + +@pytest.mark.parametrize("bool_val", [ + True, False]) +def test_longdouble_from_bool(bool_val): + assert np.longdouble(bool_val) == np.longdouble(int(bool_val)) + + +@pytest.mark.skipif( + not (IS_MUSL and platform.machine() == "x86_64"), + reason="only need to run on musllinux_x86_64" +) +def test_musllinux_x86_64_signature(): + # this test may fail if you're emulating musllinux_x86_64 on a different + # architecture, but should pass natively. + known_sigs = [b'\xcd\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xfb\xbf'] + sig = (np.longdouble(-1.0) / np.longdouble(10.0)) + sig = sig.view(sig.dtype.newbyteorder('<')).tobytes()[:10] + assert sig in known_sigs + + +def test_eps_positive(): + # np.finfo('g').eps should be positive on all platforms. If this isn't true + # then something may have gone wrong with the MachArLike, e.g. if + # np._core.getlimits._discovered_machar didn't work properly + assert np.finfo(np.longdouble).eps > 0. diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/test_machar.py b/venv/lib/python3.12/site-packages/numpy/_core/tests/test_machar.py new file mode 100644 index 00000000..c7f67707 --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/tests/test_machar.py @@ -0,0 +1,30 @@ +""" +Test machar. Given recent changes to hardcode type data, we might want to get +rid of both MachAr and this test at some point. + +""" +from numpy._core._machar import MachAr +import numpy._core.numerictypes as ntypes +from numpy import errstate, array + + +class TestMachAr: + def _run_machar_highprec(self): + # Instantiate MachAr instance with high enough precision to cause + # underflow + try: + hiprec = ntypes.float96 + MachAr(lambda v: array(v, hiprec)) + except AttributeError: + # Fixme, this needs to raise a 'skip' exception. + "Skipping test: no ntypes.float96 available on this platform." + + def test_underlow(self): + # Regression test for #759: + # instantiating MachAr for dtype = np.float96 raises spurious warning. + with errstate(all='raise'): + try: + self._run_machar_highprec() + except FloatingPointError as e: + msg = "Caught %s exception, should not have been raised." % e + raise AssertionError(msg) diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/test_mem_overlap.py b/venv/lib/python3.12/site-packages/numpy/_core/tests/test_mem_overlap.py new file mode 100644 index 00000000..4ea70c04 --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/tests/test_mem_overlap.py @@ -0,0 +1,933 @@ +import itertools +import pytest + +import numpy as np +from numpy._core._multiarray_tests import solve_diophantine, internal_overlap +from numpy._core import _umath_tests +from numpy.lib.stride_tricks import as_strided +from numpy.testing import ( + assert_, assert_raises, assert_equal, assert_array_equal + ) + + +ndims = 2 +size = 10 +shape = tuple([size] * ndims) + +MAY_SHARE_BOUNDS = 0 +MAY_SHARE_EXACT = -1 + + +def _indices_for_nelems(nelems): + """Returns slices of length nelems, from start onwards, in direction sign.""" + + if nelems == 0: + return [size // 2] # int index + + res = [] + for step in (1, 2): + for sign in (-1, 1): + start = size // 2 - nelems * step * sign // 2 + stop = start + nelems * step * sign + res.append(slice(start, stop, step * sign)) + + return res + + +def _indices_for_axis(): + """Returns (src, dst) pairs of indices.""" + + res = [] + for nelems in (0, 2, 3): + ind = _indices_for_nelems(nelems) + res.extend(itertools.product(ind, ind)) # all assignments of size "nelems" + + return res + + +def _indices(ndims): + """Returns ((axis0_src, axis0_dst), (axis1_src, axis1_dst), ... ) index pairs.""" + + ind = _indices_for_axis() + return itertools.product(ind, repeat=ndims) + + +def _check_assignment(srcidx, dstidx): + """Check assignment arr[dstidx] = arr[srcidx] works.""" + + arr = np.arange(np.prod(shape)).reshape(shape) + + cpy = arr.copy() + + cpy[dstidx] = arr[srcidx] + arr[dstidx] = arr[srcidx] + + assert_(np.all(arr == cpy), + 'assigning arr[%s] = arr[%s]' % (dstidx, srcidx)) + + +def test_overlapping_assignments(): + # Test automatically generated assignments which overlap in memory. + + inds = _indices(ndims) + + for ind in inds: + srcidx = tuple([a[0] for a in ind]) + dstidx = tuple([a[1] for a in ind]) + + _check_assignment(srcidx, dstidx) + + +@pytest.mark.slow +def test_diophantine_fuzz(): + # Fuzz test the diophantine solver + rng = np.random.RandomState(1234) + + max_int = np.iinfo(np.intp).max + + for ndim in range(10): + feasible_count = 0 + infeasible_count = 0 + + min_count = 500//(ndim + 1) + + while min(feasible_count, infeasible_count) < min_count: + # Ensure big and small integer problems + A_max = 1 + rng.randint(0, 11, dtype=np.intp)**6 + U_max = rng.randint(0, 11, dtype=np.intp)**6 + + A_max = min(max_int, A_max) + U_max = min(max_int-1, U_max) + + A = tuple(int(rng.randint(1, A_max+1, dtype=np.intp)) + for j in range(ndim)) + U = tuple(int(rng.randint(0, U_max+2, dtype=np.intp)) + for j in range(ndim)) + + b_ub = min(max_int-2, sum(a*ub for a, ub in zip(A, U))) + b = int(rng.randint(-1, b_ub+2, dtype=np.intp)) + + if ndim == 0 and feasible_count < min_count: + b = 0 + + X = solve_diophantine(A, U, b) + + if X is None: + # Check the simplified decision problem agrees + X_simplified = solve_diophantine(A, U, b, simplify=1) + assert_(X_simplified is None, (A, U, b, X_simplified)) + + # Check no solution exists (provided the problem is + # small enough so that brute force checking doesn't + # take too long) + ranges = tuple(range(0, a*ub+1, a) for a, ub in zip(A, U)) + + size = 1 + for r in ranges: + size *= len(r) + if size < 100000: + assert_(not any(sum(w) == b for w in itertools.product(*ranges))) + infeasible_count += 1 + else: + # Check the simplified decision problem agrees + X_simplified = solve_diophantine(A, U, b, simplify=1) + assert_(X_simplified is not None, (A, U, b, X_simplified)) + + # Check validity + assert_(sum(a*x for a, x in zip(A, X)) == b) + assert_(all(0 <= x <= ub for x, ub in zip(X, U))) + feasible_count += 1 + + +def test_diophantine_overflow(): + # Smoke test integer overflow detection + max_intp = np.iinfo(np.intp).max + max_int64 = np.iinfo(np.int64).max + + if max_int64 <= max_intp: + # Check that the algorithm works internally in 128-bit; + # solving this problem requires large intermediate numbers + A = (max_int64//2, max_int64//2 - 10) + U = (max_int64//2, max_int64//2 - 10) + b = 2*(max_int64//2) - 10 + + assert_equal(solve_diophantine(A, U, b), (1, 1)) + + +def check_may_share_memory_exact(a, b): + got = np.may_share_memory(a, b, max_work=MAY_SHARE_EXACT) + + assert_equal(np.may_share_memory(a, b), + np.may_share_memory(a, b, max_work=MAY_SHARE_BOUNDS)) + + a.fill(0) + b.fill(0) + a.fill(1) + exact = b.any() + + err_msg = "" + if got != exact: + err_msg = " " + "\n ".join([ + "base_a - base_b = %r" % (a.__array_interface__['data'][0] - b.__array_interface__['data'][0],), + "shape_a = %r" % (a.shape,), + "shape_b = %r" % (b.shape,), + "strides_a = %r" % (a.strides,), + "strides_b = %r" % (b.strides,), + "size_a = %r" % (a.size,), + "size_b = %r" % (b.size,) + ]) + + assert_equal(got, exact, err_msg=err_msg) + + +def test_may_share_memory_manual(): + # Manual test cases for may_share_memory + + # Base arrays + xs0 = [ + np.zeros([13, 21, 23, 22], dtype=np.int8), + np.zeros([13, 21, 23*2, 22], dtype=np.int8)[:,:,::2,:] + ] + + # Generate all negative stride combinations + xs = [] + for x in xs0: + for ss in itertools.product(*(([slice(None), slice(None, None, -1)],)*4)): + xp = x[ss] + xs.append(xp) + + for x in xs: + # The default is a simple extent check + assert_(np.may_share_memory(x[:,0,:], x[:,1,:])) + assert_(np.may_share_memory(x[:,0,:], x[:,1,:], max_work=None)) + + # Exact checks + check_may_share_memory_exact(x[:,0,:], x[:,1,:]) + check_may_share_memory_exact(x[:,::7], x[:,3::3]) + + try: + xp = x.ravel() + if xp.flags.owndata: + continue + xp = xp.view(np.int16) + except ValueError: + continue + + # 0-size arrays cannot overlap + check_may_share_memory_exact(x.ravel()[6:6], + xp.reshape(13, 21, 23, 11)[:,::7]) + + # Test itemsize is dealt with + check_may_share_memory_exact(x[:,::7], + xp.reshape(13, 21, 23, 11)) + check_may_share_memory_exact(x[:,::7], + xp.reshape(13, 21, 23, 11)[:,3::3]) + check_may_share_memory_exact(x.ravel()[6:7], + xp.reshape(13, 21, 23, 11)[:,::7]) + + # Check unit size + x = np.zeros([1], dtype=np.int8) + check_may_share_memory_exact(x, x) + check_may_share_memory_exact(x, x.copy()) + + +def iter_random_view_pairs(x, same_steps=True, equal_size=False): + rng = np.random.RandomState(1234) + + if equal_size and same_steps: + raise ValueError() + + def random_slice(n, step): + start = rng.randint(0, n+1, dtype=np.intp) + stop = rng.randint(start, n+1, dtype=np.intp) + if rng.randint(0, 2, dtype=np.intp) == 0: + stop, start = start, stop + step *= -1 + return slice(start, stop, step) + + def random_slice_fixed_size(n, step, size): + start = rng.randint(0, n+1 - size*step) + stop = start + (size-1)*step + 1 + if rng.randint(0, 2) == 0: + stop, start = start-1, stop-1 + if stop < 0: + stop = None + step *= -1 + return slice(start, stop, step) + + # First a few regular views + yield x, x + for j in range(1, 7, 3): + yield x[j:], x[:-j] + yield x[...,j:], x[...,:-j] + + # An array with zero stride internal overlap + strides = list(x.strides) + strides[0] = 0 + xp = as_strided(x, shape=x.shape, strides=strides) + yield x, xp + yield xp, xp + + # An array with non-zero stride internal overlap + strides = list(x.strides) + if strides[0] > 1: + strides[0] = 1 + xp = as_strided(x, shape=x.shape, strides=strides) + yield x, xp + yield xp, xp + + # Then discontiguous views + while True: + steps = tuple(rng.randint(1, 11, dtype=np.intp) + if rng.randint(0, 5, dtype=np.intp) == 0 else 1 + for j in range(x.ndim)) + s1 = tuple(random_slice(p, s) for p, s in zip(x.shape, steps)) + + t1 = np.arange(x.ndim) + rng.shuffle(t1) + + if equal_size: + t2 = t1 + else: + t2 = np.arange(x.ndim) + rng.shuffle(t2) + + a = x[s1] + + if equal_size: + if a.size == 0: + continue + + steps2 = tuple(rng.randint(1, max(2, p//(1+pa))) + if rng.randint(0, 5) == 0 else 1 + for p, s, pa in zip(x.shape, s1, a.shape)) + s2 = tuple(random_slice_fixed_size(p, s, pa) + for p, s, pa in zip(x.shape, steps2, a.shape)) + elif same_steps: + steps2 = steps + else: + steps2 = tuple(rng.randint(1, 11, dtype=np.intp) + if rng.randint(0, 5, dtype=np.intp) == 0 else 1 + for j in range(x.ndim)) + + if not equal_size: + s2 = tuple(random_slice(p, s) for p, s in zip(x.shape, steps2)) + + a = a.transpose(t1) + b = x[s2].transpose(t2) + + yield a, b + + +def check_may_share_memory_easy_fuzz(get_max_work, same_steps, min_count): + # Check that overlap problems with common strides are solved with + # little work. + x = np.zeros([17,34,71,97], dtype=np.int16) + + feasible = 0 + infeasible = 0 + + pair_iter = iter_random_view_pairs(x, same_steps) + + while min(feasible, infeasible) < min_count: + a, b = next(pair_iter) + + bounds_overlap = np.may_share_memory(a, b) + may_share_answer = np.may_share_memory(a, b) + easy_answer = np.may_share_memory(a, b, max_work=get_max_work(a, b)) + exact_answer = np.may_share_memory(a, b, max_work=MAY_SHARE_EXACT) + + if easy_answer != exact_answer: + # assert_equal is slow... + assert_equal(easy_answer, exact_answer) + + if may_share_answer != bounds_overlap: + assert_equal(may_share_answer, bounds_overlap) + + if bounds_overlap: + if exact_answer: + feasible += 1 + else: + infeasible += 1 + + +@pytest.mark.slow +def test_may_share_memory_easy_fuzz(): + # Check that overlap problems with common strides are always + # solved with little work. + + check_may_share_memory_easy_fuzz(get_max_work=lambda a, b: 1, + same_steps=True, + min_count=2000) + + +@pytest.mark.slow +def test_may_share_memory_harder_fuzz(): + # Overlap problems with not necessarily common strides take more + # work. + # + # The work bound below can't be reduced much. Harder problems can + # also exist but not be detected here, as the set of problems + # comes from RNG. + + check_may_share_memory_easy_fuzz(get_max_work=lambda a, b: max(a.size, b.size)//2, + same_steps=False, + min_count=2000) + + +def test_shares_memory_api(): + x = np.zeros([4, 5, 6], dtype=np.int8) + + assert_equal(np.shares_memory(x, x), True) + assert_equal(np.shares_memory(x, x.copy()), False) + + a = x[:,::2,::3] + b = x[:,::3,::2] + assert_equal(np.shares_memory(a, b), True) + assert_equal(np.shares_memory(a, b, max_work=None), True) + assert_raises( + np.exceptions.TooHardError, np.shares_memory, a, b, max_work=1 + ) + + +def test_may_share_memory_bad_max_work(): + x = np.zeros([1]) + assert_raises(OverflowError, np.may_share_memory, x, x, max_work=10**100) + assert_raises(OverflowError, np.shares_memory, x, x, max_work=10**100) + + +def test_internal_overlap_diophantine(): + def check(A, U, exists=None): + X = solve_diophantine(A, U, 0, require_ub_nontrivial=1) + + if exists is None: + exists = (X is not None) + + if X is not None: + assert_(sum(a*x for a, x in zip(A, X)) == sum(a*u//2 for a, u in zip(A, U))) + assert_(all(0 <= x <= u for x, u in zip(X, U))) + assert_(any(x != u//2 for x, u in zip(X, U))) + + if exists: + assert_(X is not None, repr(X)) + else: + assert_(X is None, repr(X)) + + # Smoke tests + check((3, 2), (2*2, 3*2), exists=True) + check((3*2, 2), (15*2, (3-1)*2), exists=False) + + +def test_internal_overlap_slices(): + # Slicing an array never generates internal overlap + + x = np.zeros([17,34,71,97], dtype=np.int16) + + rng = np.random.RandomState(1234) + + def random_slice(n, step): + start = rng.randint(0, n+1, dtype=np.intp) + stop = rng.randint(start, n+1, dtype=np.intp) + if rng.randint(0, 2, dtype=np.intp) == 0: + stop, start = start, stop + step *= -1 + return slice(start, stop, step) + + cases = 0 + min_count = 5000 + + while cases < min_count: + steps = tuple(rng.randint(1, 11, dtype=np.intp) + if rng.randint(0, 5, dtype=np.intp) == 0 else 1 + for j in range(x.ndim)) + t1 = np.arange(x.ndim) + rng.shuffle(t1) + s1 = tuple(random_slice(p, s) for p, s in zip(x.shape, steps)) + a = x[s1].transpose(t1) + + assert_(not internal_overlap(a)) + cases += 1 + + +def check_internal_overlap(a, manual_expected=None): + got = internal_overlap(a) + + # Brute-force check + m = set() + ranges = tuple(range(n) for n in a.shape) + for v in itertools.product(*ranges): + offset = sum(s*w for s, w in zip(a.strides, v)) + if offset in m: + expected = True + break + else: + m.add(offset) + else: + expected = False + + # Compare + if got != expected: + assert_equal(got, expected, err_msg=repr((a.strides, a.shape))) + if manual_expected is not None and expected != manual_expected: + assert_equal(expected, manual_expected) + return got + + +def test_internal_overlap_manual(): + # Stride tricks can construct arrays with internal overlap + + # We don't care about memory bounds, the array is not + # read/write accessed + x = np.arange(1).astype(np.int8) + + # Check low-dimensional special cases + + check_internal_overlap(x, False) # 1-dim + check_internal_overlap(x.reshape([]), False) # 0-dim + + a = as_strided(x, strides=(3, 4), shape=(4, 4)) + check_internal_overlap(a, False) + + a = as_strided(x, strides=(3, 4), shape=(5, 4)) + check_internal_overlap(a, True) + + a = as_strided(x, strides=(0,), shape=(0,)) + check_internal_overlap(a, False) + + a = as_strided(x, strides=(0,), shape=(1,)) + check_internal_overlap(a, False) + + a = as_strided(x, strides=(0,), shape=(2,)) + check_internal_overlap(a, True) + + a = as_strided(x, strides=(0, -9993), shape=(87, 22)) + check_internal_overlap(a, True) + + a = as_strided(x, strides=(0, -9993), shape=(1, 22)) + check_internal_overlap(a, False) + + a = as_strided(x, strides=(0, -9993), shape=(0, 22)) + check_internal_overlap(a, False) + + +def test_internal_overlap_fuzz(): + # Fuzz check; the brute-force check is fairly slow + + x = np.arange(1).astype(np.int8) + + overlap = 0 + no_overlap = 0 + min_count = 100 + + rng = np.random.RandomState(1234) + + while min(overlap, no_overlap) < min_count: + ndim = rng.randint(1, 4, dtype=np.intp) + + strides = tuple(rng.randint(-1000, 1000, dtype=np.intp) + for j in range(ndim)) + shape = tuple(rng.randint(1, 30, dtype=np.intp) + for j in range(ndim)) + + a = as_strided(x, strides=strides, shape=shape) + result = check_internal_overlap(a) + + if result: + overlap += 1 + else: + no_overlap += 1 + + +def test_non_ndarray_inputs(): + # Regression check for gh-5604 + + class MyArray: + def __init__(self, data): + self.data = data + + @property + def __array_interface__(self): + return self.data.__array_interface__ + + class MyArray2: + def __init__(self, data): + self.data = data + + def __array__(self, dtype=None, copy=None): + return self.data + + for cls in [MyArray, MyArray2]: + x = np.arange(5) + + assert_(np.may_share_memory(cls(x[::2]), x[1::2])) + assert_(not np.shares_memory(cls(x[::2]), x[1::2])) + + assert_(np.shares_memory(cls(x[1::3]), x[::2])) + assert_(np.may_share_memory(cls(x[1::3]), x[::2])) + + +def view_element_first_byte(x): + """Construct an array viewing the first byte of each element of `x`""" + from numpy.lib._stride_tricks_impl import DummyArray + interface = dict(x.__array_interface__) + interface['typestr'] = '|b1' + interface['descr'] = [('', '|b1')] + return np.asarray(DummyArray(interface, x)) + + +def assert_copy_equivalent(operation, args, out, **kwargs): + """ + Check that operation(*args, out=out) produces results + equivalent to out[...] = operation(*args, out=out.copy()) + """ + + kwargs['out'] = out + kwargs2 = dict(kwargs) + kwargs2['out'] = out.copy() + + out_orig = out.copy() + out[...] = operation(*args, **kwargs2) + expected = out.copy() + out[...] = out_orig + + got = operation(*args, **kwargs).copy() + + if (got != expected).any(): + assert_equal(got, expected) + + +class TestUFunc: + """ + Test ufunc call memory overlap handling + """ + + def check_unary_fuzz(self, operation, get_out_axis_size, dtype=np.int16, + count=5000): + shapes = [7, 13, 8, 21, 29, 32] + + rng = np.random.RandomState(1234) + + for ndim in range(1, 6): + x = rng.randint(0, 2**16, size=shapes[:ndim]).astype(dtype) + + it = iter_random_view_pairs(x, same_steps=False, equal_size=True) + + min_count = count // (ndim + 1)**2 + + overlapping = 0 + while overlapping < min_count: + a, b = next(it) + + a_orig = a.copy() + b_orig = b.copy() + + if get_out_axis_size is None: + assert_copy_equivalent(operation, [a], out=b) + + if np.shares_memory(a, b): + overlapping += 1 + else: + for axis in itertools.chain(range(ndim), [None]): + a[...] = a_orig + b[...] = b_orig + + # Determine size for reduction axis (None if scalar) + outsize, scalarize = get_out_axis_size(a, b, axis) + if outsize == 'skip': + continue + + # Slice b to get an output array of the correct size + sl = [slice(None)] * ndim + if axis is None: + if outsize is None: + sl = [slice(0, 1)] + [0]*(ndim - 1) + else: + sl = [slice(0, outsize)] + [0]*(ndim - 1) + else: + if outsize is None: + k = b.shape[axis]//2 + if ndim == 1: + sl[axis] = slice(k, k + 1) + else: + sl[axis] = k + else: + assert b.shape[axis] >= outsize + sl[axis] = slice(0, outsize) + b_out = b[tuple(sl)] + + if scalarize: + b_out = b_out.reshape([]) + + if np.shares_memory(a, b_out): + overlapping += 1 + + # Check result + assert_copy_equivalent(operation, [a], out=b_out, axis=axis) + + @pytest.mark.slow + def test_unary_ufunc_call_fuzz(self): + self.check_unary_fuzz(np.invert, None, np.int16) + + @pytest.mark.slow + def test_unary_ufunc_call_complex_fuzz(self): + # Complex typically has a smaller alignment than itemsize + self.check_unary_fuzz(np.negative, None, np.complex128, count=500) + + def test_binary_ufunc_accumulate_fuzz(self): + def get_out_axis_size(a, b, axis): + if axis is None: + if a.ndim == 1: + return a.size, False + else: + return 'skip', False # accumulate doesn't support this + else: + return a.shape[axis], False + + self.check_unary_fuzz(np.add.accumulate, get_out_axis_size, + dtype=np.int16, count=500) + + def test_binary_ufunc_reduce_fuzz(self): + def get_out_axis_size(a, b, axis): + return None, (axis is None or a.ndim == 1) + + self.check_unary_fuzz(np.add.reduce, get_out_axis_size, + dtype=np.int16, count=500) + + def test_binary_ufunc_reduceat_fuzz(self): + def get_out_axis_size(a, b, axis): + if axis is None: + if a.ndim == 1: + return a.size, False + else: + return 'skip', False # reduceat doesn't support this + else: + return a.shape[axis], False + + def do_reduceat(a, out, axis): + if axis is None: + size = len(a) + step = size//len(out) + else: + size = a.shape[axis] + step = a.shape[axis] // out.shape[axis] + idx = np.arange(0, size, step) + return np.add.reduceat(a, idx, out=out, axis=axis) + + self.check_unary_fuzz(do_reduceat, get_out_axis_size, + dtype=np.int16, count=500) + + def test_binary_ufunc_reduceat_manual(self): + def check(ufunc, a, ind, out): + c1 = ufunc.reduceat(a.copy(), ind.copy(), out=out.copy()) + c2 = ufunc.reduceat(a, ind, out=out) + assert_array_equal(c1, c2) + + # Exactly same input/output arrays + a = np.arange(10000, dtype=np.int16) + check(np.add, a, a[::-1].copy(), a) + + # Overlap with index + a = np.arange(10000, dtype=np.int16) + check(np.add, a, a[::-1], a) + + @pytest.mark.slow + def test_unary_gufunc_fuzz(self): + shapes = [7, 13, 8, 21, 29, 32] + gufunc = _umath_tests.euclidean_pdist + + rng = np.random.RandomState(1234) + + for ndim in range(2, 6): + x = rng.rand(*shapes[:ndim]) + + it = iter_random_view_pairs(x, same_steps=False, equal_size=True) + + min_count = 500 // (ndim + 1)**2 + + overlapping = 0 + while overlapping < min_count: + a, b = next(it) + + if min(a.shape[-2:]) < 2 or min(b.shape[-2:]) < 2 or a.shape[-1] < 2: + continue + + # Ensure the shapes are so that euclidean_pdist is happy + if b.shape[-1] > b.shape[-2]: + b = b[...,0,:] + else: + b = b[...,:,0] + + n = a.shape[-2] + p = n * (n - 1) // 2 + if p <= b.shape[-1] and p > 0: + b = b[...,:p] + else: + n = max(2, int(np.sqrt(b.shape[-1]))//2) + p = n * (n - 1) // 2 + a = a[...,:n,:] + b = b[...,:p] + + # Call + if np.shares_memory(a, b): + overlapping += 1 + + with np.errstate(over='ignore', invalid='ignore'): + assert_copy_equivalent(gufunc, [a], out=b) + + def test_ufunc_at_manual(self): + def check(ufunc, a, ind, b=None): + a0 = a.copy() + if b is None: + ufunc.at(a0, ind.copy()) + c1 = a0.copy() + ufunc.at(a, ind) + c2 = a.copy() + else: + ufunc.at(a0, ind.copy(), b.copy()) + c1 = a0.copy() + ufunc.at(a, ind, b) + c2 = a.copy() + assert_array_equal(c1, c2) + + # Overlap with index + a = np.arange(10000, dtype=np.int16) + check(np.invert, a[::-1], a) + + # Overlap with second data array + a = np.arange(100, dtype=np.int16) + ind = np.arange(0, 100, 2, dtype=np.int16) + check(np.add, a, ind, a[25:75]) + + def test_unary_ufunc_1d_manual(self): + # Exercise ufunc fast-paths (that avoid creation of an `np.nditer`) + + def check(a, b): + a_orig = a.copy() + b_orig = b.copy() + + b0 = b.copy() + c1 = ufunc(a, out=b0) + c2 = ufunc(a, out=b) + assert_array_equal(c1, c2) + + # Trigger "fancy ufunc loop" code path + mask = view_element_first_byte(b).view(np.bool) + + a[...] = a_orig + b[...] = b_orig + c1 = ufunc(a, out=b.copy(), where=mask.copy()).copy() + + a[...] = a_orig + b[...] = b_orig + c2 = ufunc(a, out=b, where=mask.copy()).copy() + + # Also, mask overlapping with output + a[...] = a_orig + b[...] = b_orig + c3 = ufunc(a, out=b, where=mask).copy() + + assert_array_equal(c1, c2) + assert_array_equal(c1, c3) + + dtypes = [np.int8, np.int16, np.int32, np.int64, np.float32, + np.float64, np.complex64, np.complex128] + dtypes = [np.dtype(x) for x in dtypes] + + for dtype in dtypes: + if np.issubdtype(dtype, np.integer): + ufunc = np.invert + else: + ufunc = np.reciprocal + + n = 1000 + k = 10 + indices = [ + np.index_exp[:n], + np.index_exp[k:k+n], + np.index_exp[n-1::-1], + np.index_exp[k+n-1:k-1:-1], + np.index_exp[:2*n:2], + np.index_exp[k:k+2*n:2], + np.index_exp[2*n-1::-2], + np.index_exp[k+2*n-1:k-1:-2], + ] + + for xi, yi in itertools.product(indices, indices): + v = np.arange(1, 1 + n*2 + k, dtype=dtype) + x = v[xi] + y = v[yi] + + with np.errstate(all='ignore'): + check(x, y) + + # Scalar cases + check(x[:1], y) + check(x[-1:], y) + check(x[:1].reshape([]), y) + check(x[-1:].reshape([]), y) + + def test_unary_ufunc_where_same(self): + # Check behavior at wheremask overlap + ufunc = np.invert + + def check(a, out, mask): + c1 = ufunc(a, out=out.copy(), where=mask.copy()) + c2 = ufunc(a, out=out, where=mask) + assert_array_equal(c1, c2) + + # Check behavior with same input and output arrays + x = np.arange(100).astype(np.bool) + check(x, x, x) + check(x, x.copy(), x) + check(x, x, x.copy()) + + @pytest.mark.slow + def test_binary_ufunc_1d_manual(self): + ufunc = np.add + + def check(a, b, c): + c0 = c.copy() + c1 = ufunc(a, b, out=c0) + c2 = ufunc(a, b, out=c) + assert_array_equal(c1, c2) + + for dtype in [np.int8, np.int16, np.int32, np.int64, + np.float32, np.float64, np.complex64, np.complex128]: + # Check different data dependency orders + + n = 1000 + k = 10 + + indices = [] + for p in [1, 2]: + indices.extend([ + np.index_exp[:p*n:p], + np.index_exp[k:k+p*n:p], + np.index_exp[p*n-1::-p], + np.index_exp[k+p*n-1:k-1:-p], + ]) + + for x, y, z in itertools.product(indices, indices, indices): + v = np.arange(6*n).astype(dtype) + x = v[x] + y = v[y] + z = v[z] + + check(x, y, z) + + # Scalar cases + check(x[:1], y, z) + check(x[-1:], y, z) + check(x[:1].reshape([]), y, z) + check(x[-1:].reshape([]), y, z) + check(x, y[:1], z) + check(x, y[-1:], z) + check(x, y[:1].reshape([]), z) + check(x, y[-1:].reshape([]), z) + + def test_inplace_op_simple_manual(self): + rng = np.random.RandomState(1234) + x = rng.rand(200, 200) # bigger than bufsize + + x += x.T + assert_array_equal(x - x.T, 0) diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/test_mem_policy.py b/venv/lib/python3.12/site-packages/numpy/_core/tests/test_mem_policy.py new file mode 100644 index 00000000..32459ab4 --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/tests/test_mem_policy.py @@ -0,0 +1,450 @@ +import asyncio +import gc +import os +import sys +import threading +import warnings + +import pytest + +import numpy as np +from numpy.testing import extbuild, assert_warns, IS_WASM, IS_EDITABLE +from numpy._core.multiarray import get_handler_name + + +@pytest.fixture +def get_module(tmp_path): + """ Add a memory policy that returns a false pointer 64 bytes into the + actual allocation, and fill the prefix with some text. Then check at each + memory manipulation that the prefix exists, to make sure all alloc/realloc/ + free/calloc go via the functions here. + """ + if sys.platform.startswith('cygwin'): + pytest.skip('link fails on cygwin') + if IS_WASM: + pytest.skip("Can't build module inside Wasm") + if IS_EDITABLE: + pytest.skip("Can't build module for editable install") + + functions = [ + ("get_default_policy", "METH_NOARGS", """ + Py_INCREF(PyDataMem_DefaultHandler); + return PyDataMem_DefaultHandler; + """), + ("set_secret_data_policy", "METH_NOARGS", """ + PyObject *secret_data = + PyCapsule_New(&secret_data_handler, "mem_handler", NULL); + if (secret_data == NULL) { + return NULL; + } + PyObject *old = PyDataMem_SetHandler(secret_data); + Py_DECREF(secret_data); + return old; + """), + ("set_wrong_capsule_name_data_policy", "METH_NOARGS", """ + PyObject *wrong_name_capsule = + PyCapsule_New(&secret_data_handler, "not_mem_handler", NULL); + if (wrong_name_capsule == NULL) { + return NULL; + } + PyObject *old = PyDataMem_SetHandler(wrong_name_capsule); + Py_DECREF(wrong_name_capsule); + return old; + """), + ("set_old_policy", "METH_O", """ + PyObject *old; + if (args != NULL && PyCapsule_CheckExact(args)) { + old = PyDataMem_SetHandler(args); + } + else { + old = PyDataMem_SetHandler(NULL); + } + return old; + """), + ("get_array", "METH_NOARGS", """ + char *buf = (char *)malloc(20); + npy_intp dims[1]; + dims[0] = 20; + PyArray_Descr *descr = PyArray_DescrNewFromType(NPY_UINT8); + return PyArray_NewFromDescr(&PyArray_Type, descr, 1, dims, NULL, + buf, NPY_ARRAY_WRITEABLE, NULL); + """), + ("set_own", "METH_O", """ + if (!PyArray_Check(args)) { + PyErr_SetString(PyExc_ValueError, + "need an ndarray"); + return NULL; + } + PyArray_ENABLEFLAGS((PyArrayObject*)args, NPY_ARRAY_OWNDATA); + // Maybe try this too? + // PyArray_BASE(PyArrayObject *)args) = NULL; + Py_RETURN_NONE; + """), + ("get_array_with_base", "METH_NOARGS", """ + char *buf = (char *)malloc(20); + npy_intp dims[1]; + dims[0] = 20; + PyArray_Descr *descr = PyArray_DescrNewFromType(NPY_UINT8); + PyObject *arr = PyArray_NewFromDescr(&PyArray_Type, descr, 1, dims, + NULL, buf, + NPY_ARRAY_WRITEABLE, NULL); + if (arr == NULL) return NULL; + PyObject *obj = PyCapsule_New(buf, "buf capsule", + (PyCapsule_Destructor)&warn_on_free); + if (obj == NULL) { + Py_DECREF(arr); + return NULL; + } + if (PyArray_SetBaseObject((PyArrayObject *)arr, obj) < 0) { + Py_DECREF(arr); + Py_DECREF(obj); + return NULL; + } + return arr; + + """), + ] + prologue = ''' + #define NPY_TARGET_VERSION NPY_1_22_API_VERSION + #define NPY_NO_DEPRECATED_API NPY_1_7_API_VERSION + #include + /* + * This struct allows the dynamic configuration of the allocator funcs + * of the `secret_data_allocator`. It is provided here for + * demonstration purposes, as a valid `ctx` use-case scenario. + */ + typedef struct { + void *(*malloc)(size_t); + void *(*calloc)(size_t, size_t); + void *(*realloc)(void *, size_t); + void (*free)(void *); + } SecretDataAllocatorFuncs; + + NPY_NO_EXPORT void * + shift_alloc(void *ctx, size_t sz) { + SecretDataAllocatorFuncs *funcs = (SecretDataAllocatorFuncs *)ctx; + char *real = (char *)funcs->malloc(sz + 64); + if (real == NULL) { + return NULL; + } + snprintf(real, 64, "originally allocated %ld", (unsigned long)sz); + return (void *)(real + 64); + } + NPY_NO_EXPORT void * + shift_zero(void *ctx, size_t sz, size_t cnt) { + SecretDataAllocatorFuncs *funcs = (SecretDataAllocatorFuncs *)ctx; + char *real = (char *)funcs->calloc(sz + 64, cnt); + if (real == NULL) { + return NULL; + } + snprintf(real, 64, "originally allocated %ld via zero", + (unsigned long)sz); + return (void *)(real + 64); + } + NPY_NO_EXPORT void + shift_free(void *ctx, void * p, npy_uintp sz) { + SecretDataAllocatorFuncs *funcs = (SecretDataAllocatorFuncs *)ctx; + if (p == NULL) { + return ; + } + char *real = (char *)p - 64; + if (strncmp(real, "originally allocated", 20) != 0) { + fprintf(stdout, "uh-oh, unmatched shift_free, " + "no appropriate prefix\\n"); + /* Make C runtime crash by calling free on the wrong address */ + funcs->free((char *)p + 10); + /* funcs->free(real); */ + } + else { + npy_uintp i = (npy_uintp)atoi(real +20); + if (i != sz) { + fprintf(stderr, "uh-oh, unmatched shift_free" + "(ptr, %ld) but allocated %ld\\n", sz, i); + /* This happens in some places, only print */ + funcs->free(real); + } + else { + funcs->free(real); + } + } + } + NPY_NO_EXPORT void * + shift_realloc(void *ctx, void * p, npy_uintp sz) { + SecretDataAllocatorFuncs *funcs = (SecretDataAllocatorFuncs *)ctx; + if (p != NULL) { + char *real = (char *)p - 64; + if (strncmp(real, "originally allocated", 20) != 0) { + fprintf(stdout, "uh-oh, unmatched shift_realloc\\n"); + return realloc(p, sz); + } + return (void *)((char *)funcs->realloc(real, sz + 64) + 64); + } + else { + char *real = (char *)funcs->realloc(p, sz + 64); + if (real == NULL) { + return NULL; + } + snprintf(real, 64, "originally allocated " + "%ld via realloc", (unsigned long)sz); + return (void *)(real + 64); + } + } + /* As an example, we use the standard {m|c|re}alloc/free funcs. */ + static SecretDataAllocatorFuncs secret_data_handler_ctx = { + malloc, + calloc, + realloc, + free + }; + static PyDataMem_Handler secret_data_handler = { + "secret_data_allocator", + 1, + { + &secret_data_handler_ctx, /* ctx */ + shift_alloc, /* malloc */ + shift_zero, /* calloc */ + shift_realloc, /* realloc */ + shift_free /* free */ + } + }; + void warn_on_free(void *capsule) { + PyErr_WarnEx(PyExc_UserWarning, "in warn_on_free", 1); + void * obj = PyCapsule_GetPointer(capsule, + PyCapsule_GetName(capsule)); + free(obj); + }; + ''' + more_init = "import_array();" + try: + import mem_policy + return mem_policy + except ImportError: + pass + # if it does not exist, build and load it + return extbuild.build_and_import_extension('mem_policy', + functions, + prologue=prologue, + include_dirs=[np.get_include()], + build_dir=tmp_path, + more_init=more_init) + + +def test_set_policy(get_module): + + get_handler_name = np._core.multiarray.get_handler_name + get_handler_version = np._core.multiarray.get_handler_version + orig_policy_name = get_handler_name() + + a = np.arange(10).reshape((2, 5)) # a doesn't own its own data + assert get_handler_name(a) is None + assert get_handler_version(a) is None + assert get_handler_name(a.base) == orig_policy_name + assert get_handler_version(a.base) == 1 + + orig_policy = get_module.set_secret_data_policy() + + b = np.arange(10).reshape((2, 5)) # b doesn't own its own data + assert get_handler_name(b) is None + assert get_handler_version(b) is None + assert get_handler_name(b.base) == 'secret_data_allocator' + assert get_handler_version(b.base) == 1 + + if orig_policy_name == 'default_allocator': + get_module.set_old_policy(None) # tests PyDataMem_SetHandler(NULL) + assert get_handler_name() == 'default_allocator' + else: + get_module.set_old_policy(orig_policy) + assert get_handler_name() == orig_policy_name + + with pytest.raises(ValueError, + match="Capsule must be named 'mem_handler'"): + get_module.set_wrong_capsule_name_data_policy() + + +def test_default_policy_singleton(get_module): + get_handler_name = np._core.multiarray.get_handler_name + + # set the policy to default + orig_policy = get_module.set_old_policy(None) + + assert get_handler_name() == 'default_allocator' + + # re-set the policy to default + def_policy_1 = get_module.set_old_policy(None) + + assert get_handler_name() == 'default_allocator' + + # set the policy to original + def_policy_2 = get_module.set_old_policy(orig_policy) + + # since default policy is a singleton, + # these should be the same object + assert def_policy_1 is def_policy_2 is get_module.get_default_policy() + + +def test_policy_propagation(get_module): + # The memory policy goes hand-in-hand with flags.owndata + + class MyArr(np.ndarray): + pass + + get_handler_name = np._core.multiarray.get_handler_name + orig_policy_name = get_handler_name() + a = np.arange(10).view(MyArr).reshape((2, 5)) + assert get_handler_name(a) is None + assert a.flags.owndata is False + + assert get_handler_name(a.base) is None + assert a.base.flags.owndata is False + + assert get_handler_name(a.base.base) == orig_policy_name + assert a.base.base.flags.owndata is True + + +async def concurrent_context1(get_module, orig_policy_name, event): + if orig_policy_name == 'default_allocator': + get_module.set_secret_data_policy() + assert get_handler_name() == 'secret_data_allocator' + else: + get_module.set_old_policy(None) + assert get_handler_name() == 'default_allocator' + event.set() + + +async def concurrent_context2(get_module, orig_policy_name, event): + await event.wait() + # the policy is not affected by changes in parallel contexts + assert get_handler_name() == orig_policy_name + # change policy in the child context + if orig_policy_name == 'default_allocator': + get_module.set_secret_data_policy() + assert get_handler_name() == 'secret_data_allocator' + else: + get_module.set_old_policy(None) + assert get_handler_name() == 'default_allocator' + + +async def async_test_context_locality(get_module): + orig_policy_name = np._core.multiarray.get_handler_name() + + event = asyncio.Event() + # the child contexts inherit the parent policy + concurrent_task1 = asyncio.create_task( + concurrent_context1(get_module, orig_policy_name, event)) + concurrent_task2 = asyncio.create_task( + concurrent_context2(get_module, orig_policy_name, event)) + await concurrent_task1 + await concurrent_task2 + + # the parent context is not affected by child policy changes + assert np._core.multiarray.get_handler_name() == orig_policy_name + + +def test_context_locality(get_module): + if (sys.implementation.name == 'pypy' + and sys.pypy_version_info[:3] < (7, 3, 6)): + pytest.skip('no context-locality support in PyPy < 7.3.6') + asyncio.run(async_test_context_locality(get_module)) + + +def concurrent_thread1(get_module, event): + get_module.set_secret_data_policy() + assert np._core.multiarray.get_handler_name() == 'secret_data_allocator' + event.set() + + +def concurrent_thread2(get_module, event): + event.wait() + # the policy is not affected by changes in parallel threads + assert np._core.multiarray.get_handler_name() == 'default_allocator' + # change policy in the child thread + get_module.set_secret_data_policy() + + +def test_thread_locality(get_module): + orig_policy_name = np._core.multiarray.get_handler_name() + + event = threading.Event() + # the child threads do not inherit the parent policy + concurrent_task1 = threading.Thread(target=concurrent_thread1, + args=(get_module, event)) + concurrent_task2 = threading.Thread(target=concurrent_thread2, + args=(get_module, event)) + concurrent_task1.start() + concurrent_task2.start() + concurrent_task1.join() + concurrent_task2.join() + + # the parent thread is not affected by child policy changes + assert np._core.multiarray.get_handler_name() == orig_policy_name + + +@pytest.mark.skip(reason="too slow, see gh-23975") +def test_new_policy(get_module): + a = np.arange(10) + orig_policy_name = np._core.multiarray.get_handler_name(a) + + orig_policy = get_module.set_secret_data_policy() + + b = np.arange(10) + assert np._core.multiarray.get_handler_name(b) == 'secret_data_allocator' + + # test array manipulation. This is slow + if orig_policy_name == 'default_allocator': + # when the np._core.test tests recurse into this test, the + # policy will be set so this "if" will be false, preventing + # infinite recursion + # + # if needed, debug this by + # - running tests with -- -s (to not capture stdout/stderr + # - setting verbose=2 + # - setting extra_argv=['-vv'] here + assert np._core.test('full', verbose=1, extra_argv=[]) + # also try the ma tests, the pickling test is quite tricky + assert np.ma.test('full', verbose=1, extra_argv=[]) + + get_module.set_old_policy(orig_policy) + + c = np.arange(10) + assert np._core.multiarray.get_handler_name(c) == orig_policy_name + + +@pytest.mark.xfail(sys.implementation.name == "pypy", + reason=("bad interaction between getenv and " + "os.environ inside pytest")) +@pytest.mark.parametrize("policy", ["0", "1", None]) +def test_switch_owner(get_module, policy): + a = get_module.get_array() + assert np._core.multiarray.get_handler_name(a) is None + get_module.set_own(a) + + if policy is None: + # See what we expect to be set based on the env variable + policy = os.getenv("NUMPY_WARN_IF_NO_MEM_POLICY", "0") == "1" + oldval = None + else: + policy = policy == "1" + oldval = np._core._multiarray_umath._set_numpy_warn_if_no_mem_policy( + policy) + try: + # The policy should be NULL, so we have to assume we can call + # "free". A warning is given if the policy == "1" + if policy: + with assert_warns(RuntimeWarning) as w: + del a + gc.collect() + else: + del a + gc.collect() + + finally: + if oldval is not None: + np._core._multiarray_umath._set_numpy_warn_if_no_mem_policy(oldval) + + +def test_owner_is_base(get_module): + a = get_module.get_array_with_base() + with pytest.warns(UserWarning, match='warn_on_free'): + del a + gc.collect() + gc.collect() diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/test_memmap.py b/venv/lib/python3.12/site-packages/numpy/_core/tests/test_memmap.py new file mode 100644 index 00000000..9603e831 --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/tests/test_memmap.py @@ -0,0 +1,221 @@ +import sys +import os +import mmap +import pytest +from pathlib import Path +from tempfile import NamedTemporaryFile, TemporaryFile + +from numpy import ( + memmap, sum, average, prod, ndarray, isscalar, add, subtract, multiply) + +from numpy import arange, allclose, asarray +from numpy.testing import ( + assert_, assert_equal, assert_array_equal, suppress_warnings, IS_PYPY, + break_cycles + ) + +class TestMemmap: + def setup_method(self): + self.tmpfp = NamedTemporaryFile(prefix='mmap') + self.shape = (3, 4) + self.dtype = 'float32' + self.data = arange(12, dtype=self.dtype) + self.data.resize(self.shape) + + def teardown_method(self): + self.tmpfp.close() + self.data = None + if IS_PYPY: + break_cycles() + break_cycles() + + def test_roundtrip(self): + # Write data to file + fp = memmap(self.tmpfp, dtype=self.dtype, mode='w+', + shape=self.shape) + fp[:] = self.data[:] + del fp # Test __del__ machinery, which handles cleanup + + # Read data back from file + newfp = memmap(self.tmpfp, dtype=self.dtype, mode='r', + shape=self.shape) + assert_(allclose(self.data, newfp)) + assert_array_equal(self.data, newfp) + assert_equal(newfp.flags.writeable, False) + + def test_open_with_filename(self, tmp_path): + tmpname = tmp_path / 'mmap' + fp = memmap(tmpname, dtype=self.dtype, mode='w+', + shape=self.shape) + fp[:] = self.data[:] + del fp + + def test_unnamed_file(self): + with TemporaryFile() as f: + fp = memmap(f, dtype=self.dtype, shape=self.shape) + del fp + + def test_attributes(self): + offset = 1 + mode = "w+" + fp = memmap(self.tmpfp, dtype=self.dtype, mode=mode, + shape=self.shape, offset=offset) + assert_equal(offset, fp.offset) + assert_equal(mode, fp.mode) + del fp + + def test_filename(self, tmp_path): + tmpname = tmp_path / "mmap" + fp = memmap(tmpname, dtype=self.dtype, mode='w+', + shape=self.shape) + abspath = Path(os.path.abspath(tmpname)) + fp[:] = self.data[:] + assert_equal(abspath, fp.filename) + b = fp[:1] + assert_equal(abspath, b.filename) + del b + del fp + + def test_path(self, tmp_path): + tmpname = tmp_path / "mmap" + fp = memmap(Path(tmpname), dtype=self.dtype, mode='w+', + shape=self.shape) + # os.path.realpath does not resolve symlinks on Windows + # see: https://bugs.python.org/issue9949 + # use Path.resolve, just as memmap class does internally + abspath = str(Path(tmpname).resolve()) + fp[:] = self.data[:] + assert_equal(abspath, str(fp.filename.resolve())) + b = fp[:1] + assert_equal(abspath, str(b.filename.resolve())) + del b + del fp + + def test_filename_fileobj(self): + fp = memmap(self.tmpfp, dtype=self.dtype, mode="w+", + shape=self.shape) + assert_equal(fp.filename, self.tmpfp.name) + + @pytest.mark.skipif(sys.platform == 'gnu0', + reason="Known to fail on hurd") + def test_flush(self): + fp = memmap(self.tmpfp, dtype=self.dtype, mode='w+', + shape=self.shape) + fp[:] = self.data[:] + assert_equal(fp[0], self.data[0]) + fp.flush() + + def test_del(self): + # Make sure a view does not delete the underlying mmap + fp_base = memmap(self.tmpfp, dtype=self.dtype, mode='w+', + shape=self.shape) + fp_base[0] = 5 + fp_view = fp_base[0:1] + assert_equal(fp_view[0], 5) + del fp_view + # Should still be able to access and assign values after + # deleting the view + assert_equal(fp_base[0], 5) + fp_base[0] = 6 + assert_equal(fp_base[0], 6) + + def test_arithmetic_drops_references(self): + fp = memmap(self.tmpfp, dtype=self.dtype, mode='w+', + shape=self.shape) + tmp = (fp + 10) + if isinstance(tmp, memmap): + assert_(tmp._mmap is not fp._mmap) + + def test_indexing_drops_references(self): + fp = memmap(self.tmpfp, dtype=self.dtype, mode='w+', + shape=self.shape) + tmp = fp[(1, 2), (2, 3)] + if isinstance(tmp, memmap): + assert_(tmp._mmap is not fp._mmap) + + def test_slicing_keeps_references(self): + fp = memmap(self.tmpfp, dtype=self.dtype, mode='w+', + shape=self.shape) + assert_(fp[:2, :2]._mmap is fp._mmap) + + def test_view(self): + fp = memmap(self.tmpfp, dtype=self.dtype, shape=self.shape) + new1 = fp.view() + new2 = new1.view() + assert_(new1.base is fp) + assert_(new2.base is fp) + new_array = asarray(fp) + assert_(new_array.base is fp) + + def test_ufunc_return_ndarray(self): + fp = memmap(self.tmpfp, dtype=self.dtype, shape=self.shape) + fp[:] = self.data + + with suppress_warnings() as sup: + sup.filter(FutureWarning, "np.average currently does not preserve") + for unary_op in [sum, average, prod]: + result = unary_op(fp) + assert_(isscalar(result)) + assert_(result.__class__ is self.data[0, 0].__class__) + + assert_(unary_op(fp, axis=0).__class__ is ndarray) + assert_(unary_op(fp, axis=1).__class__ is ndarray) + + for binary_op in [add, subtract, multiply]: + assert_(binary_op(fp, self.data).__class__ is ndarray) + assert_(binary_op(self.data, fp).__class__ is ndarray) + assert_(binary_op(fp, fp).__class__ is ndarray) + + fp += 1 + assert(fp.__class__ is memmap) + add(fp, 1, out=fp) + assert(fp.__class__ is memmap) + + def test_getitem(self): + fp = memmap(self.tmpfp, dtype=self.dtype, shape=self.shape) + fp[:] = self.data + + assert_(fp[1:, :-1].__class__ is memmap) + # Fancy indexing returns a copy that is not memmapped + assert_(fp[[0, 1]].__class__ is ndarray) + + def test_memmap_subclass(self): + class MemmapSubClass(memmap): + pass + + fp = MemmapSubClass(self.tmpfp, dtype=self.dtype, shape=self.shape) + fp[:] = self.data + + # We keep previous behavior for subclasses of memmap, i.e. the + # ufunc and __getitem__ output is never turned into a ndarray + assert_(sum(fp, axis=0).__class__ is MemmapSubClass) + assert_(sum(fp).__class__ is MemmapSubClass) + assert_(fp[1:, :-1].__class__ is MemmapSubClass) + assert(fp[[0, 1]].__class__ is MemmapSubClass) + + def test_mmap_offset_greater_than_allocation_granularity(self): + size = 5 * mmap.ALLOCATIONGRANULARITY + offset = mmap.ALLOCATIONGRANULARITY + 1 + fp = memmap(self.tmpfp, shape=size, mode='w+', offset=offset) + assert_(fp.offset == offset) + + def test_no_shape(self): + self.tmpfp.write(b'a'*16) + mm = memmap(self.tmpfp, dtype='float64') + assert_equal(mm.shape, (2,)) + + def test_empty_array(self): + # gh-12653 + with pytest.raises(ValueError, match='empty file'): + memmap(self.tmpfp, shape=(0,4), mode='w+') + + self.tmpfp.write(b'\0') + + # ok now the file is not empty + memmap(self.tmpfp, shape=(0,4), mode='w+') + + def test_shape_type(self): + memmap(self.tmpfp, shape=3, mode='w+') + memmap(self.tmpfp, shape=self.shape, mode='w+') + memmap(self.tmpfp, shape=list(self.shape), mode='w+') + memmap(self.tmpfp, shape=asarray(self.shape), mode='w+') diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/test_multiarray.py b/venv/lib/python3.12/site-packages/numpy/_core/tests/test_multiarray.py new file mode 100644 index 00000000..2f7e3c57 --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/tests/test_multiarray.py @@ -0,0 +1,10341 @@ +from __future__ import annotations + +import collections.abc +import tempfile +import sys +import warnings +import operator +import io +import itertools +import functools +import ctypes +import os +import gc +import re +import weakref +import pytest +from contextlib import contextmanager +import pickle +import pathlib +import builtins +from decimal import Decimal +import mmap + +import numpy as np +import numpy._core._multiarray_tests as _multiarray_tests +from numpy._core._rational_tests import rational +from numpy.exceptions import AxisError, ComplexWarning +from numpy.testing import ( + assert_, assert_raises, assert_warns, assert_equal, assert_almost_equal, + assert_array_equal, assert_raises_regex, assert_array_almost_equal, + assert_allclose, IS_PYPY, IS_WASM, IS_PYSTON, HAS_REFCOUNT, + assert_array_less, runstring, temppath, suppress_warnings, break_cycles, + check_support_sve, assert_array_compare, + ) +from numpy.testing._private.utils import requires_memory, _no_tracing +from numpy._core.tests._locales import CommaDecimalPointLocale +from numpy.lib.recfunctions import repack_fields +from numpy._core.multiarray import _get_ndarray_c_version, dot + +# Need to test an object that does not fully implement math interface +from datetime import timedelta, datetime + + +def assert_arg_sorted(arr, arg): + # resulting array should be sorted and arg values should be unique + assert_equal(arr[arg], np.sort(arr)) + assert_equal(np.sort(arg), np.arange(len(arg))) + + +def assert_arr_partitioned(kth, k, arr_part): + assert_equal(arr_part[k], kth) + assert_array_compare(operator.__le__, arr_part[:k], kth) + assert_array_compare(operator.__ge__, arr_part[k:], kth) + + +def _aligned_zeros(shape, dtype=float, order="C", align=None): + """ + Allocate a new ndarray with aligned memory. + + The ndarray is guaranteed *not* aligned to twice the requested alignment. + Eg, if align=4, guarantees it is not aligned to 8. If align=None uses + dtype.alignment.""" + dtype = np.dtype(dtype) + if dtype == np.dtype(object): + # Can't do this, fall back to standard allocation (which + # should always be sufficiently aligned) + if align is not None: + raise ValueError("object array alignment not supported") + return np.zeros(shape, dtype=dtype, order=order) + if align is None: + align = dtype.alignment + if not hasattr(shape, '__len__'): + shape = (shape,) + size = functools.reduce(operator.mul, shape) * dtype.itemsize + buf = np.empty(size + 2*align + 1, np.uint8) + + ptr = buf.__array_interface__['data'][0] + offset = ptr % align + if offset != 0: + offset = align - offset + if (ptr % (2*align)) == 0: + offset += align + + # Note: slices producing 0-size arrays do not necessarily change + # data pointer --- so we use and allocate size+1 + buf = buf[offset:offset+size+1][:-1] + buf.fill(0) + data = np.ndarray(shape, dtype, buf, order=order) + return data + + +class TestFlags: + def setup_method(self): + self.a = np.arange(10) + + def test_writeable(self): + mydict = locals() + self.a.flags.writeable = False + assert_raises(ValueError, runstring, 'self.a[0] = 3', mydict) + self.a.flags.writeable = True + self.a[0] = 5 + self.a[0] = 0 + + def test_writeable_any_base(self): + # Ensure that any base being writeable is sufficient to change flag; + # this is especially interesting for arrays from an array interface. + arr = np.arange(10) + + class subclass(np.ndarray): + pass + + # Create subclass so base will not be collapsed, this is OK to change + view1 = arr.view(subclass) + view2 = view1[...] + arr.flags.writeable = False + view2.flags.writeable = False + view2.flags.writeable = True # Can be set to True again. + + arr = np.arange(10) + + class frominterface: + def __init__(self, arr): + self.arr = arr + self.__array_interface__ = arr.__array_interface__ + + view1 = np.asarray(frominterface) + view2 = view1[...] + view2.flags.writeable = False + view2.flags.writeable = True + + view1.flags.writeable = False + view2.flags.writeable = False + with assert_raises(ValueError): + # Must assume not writeable, since only base is not: + view2.flags.writeable = True + + def test_writeable_from_readonly(self): + # gh-9440 - make sure fromstring, from buffer on readonly buffers + # set writeable False + data = b'\x00' * 100 + vals = np.frombuffer(data, 'B') + assert_raises(ValueError, vals.setflags, write=True) + types = np.dtype( [('vals', 'u1'), ('res3', 'S4')] ) + values = np._core.records.fromstring(data, types) + vals = values['vals'] + assert_raises(ValueError, vals.setflags, write=True) + + def test_writeable_from_buffer(self): + data = bytearray(b'\x00' * 100) + vals = np.frombuffer(data, 'B') + assert_(vals.flags.writeable) + vals.setflags(write=False) + assert_(vals.flags.writeable is False) + vals.setflags(write=True) + assert_(vals.flags.writeable) + types = np.dtype( [('vals', 'u1'), ('res3', 'S4')] ) + values = np._core.records.fromstring(data, types) + vals = values['vals'] + assert_(vals.flags.writeable) + vals.setflags(write=False) + assert_(vals.flags.writeable is False) + vals.setflags(write=True) + assert_(vals.flags.writeable) + + @pytest.mark.skipif(IS_PYPY, reason="PyPy always copies") + def test_writeable_pickle(self): + import pickle + # Small arrays will be copied without setting base. + # See condition for using PyArray_SetBaseObject in + # array_setstate. + a = np.arange(1000) + for v in range(pickle.HIGHEST_PROTOCOL): + vals = pickle.loads(pickle.dumps(a, v)) + assert_(vals.flags.writeable) + assert_(isinstance(vals.base, bytes)) + + def test_writeable_from_c_data(self): + # Test that the writeable flag can be changed for an array wrapping + # low level C-data, but not owning its data. + # Also see that this is deprecated to change from python. + from numpy._core._multiarray_tests import get_c_wrapping_array + + arr_writeable = get_c_wrapping_array(True) + assert not arr_writeable.flags.owndata + assert arr_writeable.flags.writeable + view = arr_writeable[...] + + # Toggling the writeable flag works on the view: + view.flags.writeable = False + assert not view.flags.writeable + view.flags.writeable = True + assert view.flags.writeable + # Flag can be unset on the arr_writeable: + arr_writeable.flags.writeable = False + + arr_readonly = get_c_wrapping_array(False) + assert not arr_readonly.flags.owndata + assert not arr_readonly.flags.writeable + + for arr in [arr_writeable, arr_readonly]: + view = arr[...] + view.flags.writeable = False # make sure it is readonly + arr.flags.writeable = False + assert not arr.flags.writeable + + with assert_raises(ValueError): + view.flags.writeable = True + + with warnings.catch_warnings(): + warnings.simplefilter("error", DeprecationWarning) + with assert_raises(DeprecationWarning): + arr.flags.writeable = True + + with assert_warns(DeprecationWarning): + arr.flags.writeable = True + + def test_warnonwrite(self): + a = np.arange(10) + a.flags._warn_on_write = True + with warnings.catch_warnings(record=True) as w: + warnings.filterwarnings('always') + a[1] = 10 + a[2] = 10 + # only warn once + assert_(len(w) == 1) + + @pytest.mark.parametrize(["flag", "flag_value", "writeable"], + [("writeable", True, True), + # Delete _warn_on_write after deprecation and simplify + # the parameterization: + ("_warn_on_write", True, False), + ("writeable", False, False)]) + def test_readonly_flag_protocols(self, flag, flag_value, writeable): + a = np.arange(10) + setattr(a.flags, flag, flag_value) + + class MyArr: + __array_struct__ = a.__array_struct__ + + assert memoryview(a).readonly is not writeable + assert a.__array_interface__['data'][1] is not writeable + assert np.asarray(MyArr()).flags.writeable is writeable + + def test_otherflags(self): + assert_equal(self.a.flags.carray, True) + assert_equal(self.a.flags['C'], True) + assert_equal(self.a.flags.farray, False) + assert_equal(self.a.flags.behaved, True) + assert_equal(self.a.flags.fnc, False) + assert_equal(self.a.flags.forc, True) + assert_equal(self.a.flags.owndata, True) + assert_equal(self.a.flags.writeable, True) + assert_equal(self.a.flags.aligned, True) + assert_equal(self.a.flags.writebackifcopy, False) + assert_equal(self.a.flags['X'], False) + assert_equal(self.a.flags['WRITEBACKIFCOPY'], False) + + def test_string_align(self): + a = np.zeros(4, dtype=np.dtype('|S4')) + assert_(a.flags.aligned) + # not power of two are accessed byte-wise and thus considered aligned + a = np.zeros(5, dtype=np.dtype('|S4')) + assert_(a.flags.aligned) + + def test_void_align(self): + a = np.zeros(4, dtype=np.dtype([("a", "i4"), ("b", "i4")])) + assert_(a.flags.aligned) + + @pytest.mark.parametrize("row_size", [5, 1 << 16]) + @pytest.mark.parametrize("row_count", [1, 5]) + @pytest.mark.parametrize("ndmin", [0, 1, 2]) + def test_xcontiguous_load_txt(self, row_size, row_count, ndmin): + s = io.StringIO('\n'.join(['1.0 ' * row_size] * row_count)) + a = np.loadtxt(s, ndmin=ndmin) + + assert a.flags.c_contiguous + x = [i for i in a.shape if i != 1] + assert a.flags.f_contiguous == (len(x) <= 1) + + +class TestHash: + # see #3793 + def test_int(self): + for st, ut, s in [(np.int8, np.uint8, 8), + (np.int16, np.uint16, 16), + (np.int32, np.uint32, 32), + (np.int64, np.uint64, 64)]: + for i in range(1, s): + assert_equal(hash(st(-2**i)), hash(-2**i), + err_msg="%r: -2**%d" % (st, i)) + assert_equal(hash(st(2**(i - 1))), hash(2**(i - 1)), + err_msg="%r: 2**%d" % (st, i - 1)) + assert_equal(hash(st(2**i - 1)), hash(2**i - 1), + err_msg="%r: 2**%d - 1" % (st, i)) + + i = max(i - 1, 1) + assert_equal(hash(ut(2**(i - 1))), hash(2**(i - 1)), + err_msg="%r: 2**%d" % (ut, i - 1)) + assert_equal(hash(ut(2**i - 1)), hash(2**i - 1), + err_msg="%r: 2**%d - 1" % (ut, i)) + + +class TestAttributes: + def setup_method(self): + self.one = np.arange(10) + self.two = np.arange(20).reshape(4, 5) + self.three = np.arange(60, dtype=np.float64).reshape(2, 5, 6) + + def test_attributes(self): + assert_equal(self.one.shape, (10,)) + assert_equal(self.two.shape, (4, 5)) + assert_equal(self.three.shape, (2, 5, 6)) + self.three.shape = (10, 3, 2) + assert_equal(self.three.shape, (10, 3, 2)) + self.three.shape = (2, 5, 6) + assert_equal(self.one.strides, (self.one.itemsize,)) + num = self.two.itemsize + assert_equal(self.two.strides, (5*num, num)) + num = self.three.itemsize + assert_equal(self.three.strides, (30*num, 6*num, num)) + assert_equal(self.one.ndim, 1) + assert_equal(self.two.ndim, 2) + assert_equal(self.three.ndim, 3) + num = self.two.itemsize + assert_equal(self.two.size, 20) + assert_equal(self.two.nbytes, 20*num) + assert_equal(self.two.itemsize, self.two.dtype.itemsize) + assert_equal(self.two.base, np.arange(20)) + + def test_dtypeattr(self): + assert_equal(self.one.dtype, np.dtype(np.int_)) + assert_equal(self.three.dtype, np.dtype(np.float64)) + assert_equal(self.one.dtype.char, np.dtype(int).char) + assert self.one.dtype.char in "lq" + assert_equal(self.three.dtype.char, 'd') + assert_(self.three.dtype.str[0] in '<>') + assert_equal(self.one.dtype.str[1], 'i') + assert_equal(self.three.dtype.str[1], 'f') + + def test_int_subclassing(self): + # Regression test for https://github.com/numpy/numpy/pull/3526 + + numpy_int = np.int_(0) + + # int_ doesn't inherit from Python int, because it's not fixed-width + assert_(not isinstance(numpy_int, int)) + + def test_stridesattr(self): + x = self.one + + def make_array(size, offset, strides): + return np.ndarray(size, buffer=x, dtype=int, + offset=offset*x.itemsize, + strides=strides*x.itemsize) + + assert_equal(make_array(4, 4, -1), np.array([4, 3, 2, 1])) + assert_raises(ValueError, make_array, 4, 4, -2) + assert_raises(ValueError, make_array, 4, 2, -1) + assert_raises(ValueError, make_array, 8, 3, 1) + assert_equal(make_array(8, 3, 0), np.array([3]*8)) + # Check behavior reported in gh-2503: + assert_raises(ValueError, make_array, (2, 3), 5, np.array([-2, -3])) + make_array(0, 0, 10) + + def test_set_stridesattr(self): + x = self.one + + def make_array(size, offset, strides): + try: + r = np.ndarray([size], dtype=int, buffer=x, + offset=offset*x.itemsize) + except Exception as e: + raise RuntimeError(e) + r.strides = strides = strides*x.itemsize + return r + + assert_equal(make_array(4, 4, -1), np.array([4, 3, 2, 1])) + assert_equal(make_array(7, 3, 1), np.array([3, 4, 5, 6, 7, 8, 9])) + assert_raises(ValueError, make_array, 4, 4, -2) + assert_raises(ValueError, make_array, 4, 2, -1) + assert_raises(RuntimeError, make_array, 8, 3, 1) + # Check that the true extent of the array is used. + # Test relies on as_strided base not exposing a buffer. + x = np.lib.stride_tricks.as_strided(np.arange(1), (10, 10), (0, 0)) + + def set_strides(arr, strides): + arr.strides = strides + + assert_raises(ValueError, set_strides, x, (10*x.itemsize, x.itemsize)) + + # Test for offset calculations: + x = np.lib.stride_tricks.as_strided(np.arange(10, dtype=np.int8)[-1], + shape=(10,), strides=(-1,)) + assert_raises(ValueError, set_strides, x[::-1], -1) + a = x[::-1] + a.strides = 1 + a[::2].strides = 2 + + # test 0d + arr_0d = np.array(0) + arr_0d.strides = () + assert_raises(TypeError, set_strides, arr_0d, None) + + def test_fill(self): + for t in "?bhilqpBHILQPfdgFDGO": + x = np.empty((3, 2, 1), t) + y = np.empty((3, 2, 1), t) + x.fill(1) + y[...] = 1 + assert_equal(x, y) + + def test_fill_max_uint64(self): + x = np.empty((3, 2, 1), dtype=np.uint64) + y = np.empty((3, 2, 1), dtype=np.uint64) + value = 2**64 - 1 + y[...] = value + x.fill(value) + assert_array_equal(x, y) + + def test_fill_struct_array(self): + # Filling from a scalar + x = np.array([(0, 0.0), (1, 1.0)], dtype='i4,f8') + x.fill(x[0]) + assert_equal(x['f1'][1], x['f1'][0]) + # Filling from a tuple that can be converted + # to a scalar + x = np.zeros(2, dtype=[('a', 'f8'), ('b', 'i4')]) + x.fill((3.5, -2)) + assert_array_equal(x['a'], [3.5, 3.5]) + assert_array_equal(x['b'], [-2, -2]) + + def test_fill_readonly(self): + # gh-22922 + a = np.zeros(11) + a.setflags(write=False) + with pytest.raises(ValueError, match=".*read-only"): + a.fill(0) + + def test_fill_subarrays(self): + # NOTE: + # This is also a regression test for a crash with PYTHONMALLOC=debug + + dtype = np.dtype("2i4')) + assert_(np.dtype([('a', 'i4')])) + + def test_structured_non_void(self): + fields = [('a', 'i8'), ('b', 'f8')]) + assert_equal(a == b, [False, True]) + assert_equal(a != b, [True, False]) + + a = np.array([(5, 42), (10, 1)], dtype=[('a', '>f8'), ('b', 'i8')]) + assert_equal(a == b, [False, True]) + assert_equal(a != b, [True, False]) + + # Including with embedded subarray dtype (although subarray comparison + # itself may still be a bit weird and compare the raw data) + a = np.array([(5, 42), (10, 1)], dtype=[('a', '10>f8'), ('b', '5i8')]) + assert_equal(a == b, [False, True]) + assert_equal(a != b, [True, False]) + + @pytest.mark.parametrize("op", [ + operator.eq, lambda x, y: operator.eq(y, x), + operator.ne, lambda x, y: operator.ne(y, x)]) + def test_void_comparison_failures(self, op): + # In principle, one could decide to return an array of False for some + # if comparisons are impossible. But right now we return TypeError + # when "void" dtype are involved. + x = np.zeros(3, dtype=[('a', 'i1')]) + y = np.zeros(3) + # Cannot compare non-structured to structured: + with pytest.raises(TypeError): + op(x, y) + + # Added title prevents promotion, but casts are OK: + y = np.zeros(3, dtype=[(('title', 'a'), 'i1')]) + assert np.can_cast(y.dtype, x.dtype) + with pytest.raises(TypeError): + op(x, y) + + x = np.zeros(3, dtype="V7") + y = np.zeros(3, dtype="V8") + with pytest.raises(TypeError): + op(x, y) + + def test_casting(self): + # Check that casting a structured array to change its byte order + # works + a = np.array([(1,)], dtype=[('a', 'i4')], casting='unsafe')) + b = a.astype([('a', '>i4')]) + a_tmp = a.byteswap() + a_tmp = a_tmp.view(a_tmp.dtype.newbyteorder()) + assert_equal(b, a_tmp) + assert_equal(a['a'][0], b['a'][0]) + + # Check that equality comparison works on structured arrays if + # they are 'equiv'-castable + a = np.array([(5, 42), (10, 1)], dtype=[('a', '>i4'), ('b', 'f8')]) + assert_(np.can_cast(a.dtype, b.dtype, casting='equiv')) + assert_equal(a == b, [True, True]) + + # Check that 'equiv' casting can change byte order + assert_(np.can_cast(a.dtype, b.dtype, casting='equiv')) + c = a.astype(b.dtype, casting='equiv') + assert_equal(a == c, [True, True]) + + # Check that 'safe' casting can change byte order and up-cast + # fields + t = [('a', 'f8')] + assert_(np.can_cast(a.dtype, t, casting='safe')) + c = a.astype(t, casting='safe') + assert_equal((c == np.array([(5, 42), (10, 1)], dtype=t)), + [True, True]) + + # Check that 'same_kind' casting can change byte order and + # change field widths within a "kind" + t = [('a', 'f4')] + assert_(np.can_cast(a.dtype, t, casting='same_kind')) + c = a.astype(t, casting='same_kind') + assert_equal((c == np.array([(5, 42), (10, 1)], dtype=t)), + [True, True]) + + # Check that casting fails if the casting rule should fail on + # any of the fields + t = [('a', '>i8'), ('b', 'i2'), ('b', 'i8'), ('b', 'i4')] + assert_(not np.can_cast(a.dtype, t, casting=casting)) + t = [('a', '>i4'), ('b', 'i8") + ab = np.array([(1, 2)], dtype=[A, B]) + ba = np.array([(1, 2)], dtype=[B, A]) + assert_raises(TypeError, np.concatenate, ab, ba) + assert_raises(TypeError, np.result_type, ab.dtype, ba.dtype) + assert_raises(TypeError, np.promote_types, ab.dtype, ba.dtype) + + # dtypes with same field names/order but different memory offsets + # and byte-order are promotable to packed nbo. + assert_equal(np.promote_types(ab.dtype, ba[['a', 'b']].dtype), + repack_fields(ab.dtype.newbyteorder('N'))) + + # gh-13667 + # dtypes with different fieldnames but castable field types are castable + assert_equal(np.can_cast(ab.dtype, ba.dtype), True) + assert_equal(ab.astype(ba.dtype).dtype, ba.dtype) + assert_equal(np.can_cast('f8,i8', [('f0', 'f8'), ('f1', 'i8')]), True) + assert_equal(np.can_cast('f8,i8', [('f1', 'f8'), ('f0', 'i8')]), True) + assert_equal(np.can_cast('f8,i8', [('f1', 'i8'), ('f0', 'f8')]), False) + assert_equal(np.can_cast('f8,i8', [('f1', 'i8'), ('f0', 'f8')], + casting='unsafe'), True) + + ab[:] = ba # make sure assignment still works + + # tests of type-promotion of corresponding fields + dt1 = np.dtype([("", "i4")]) + dt2 = np.dtype([("", "i8")]) + assert_equal(np.promote_types(dt1, dt2), np.dtype([('f0', 'i8')])) + assert_equal(np.promote_types(dt2, dt1), np.dtype([('f0', 'i8')])) + assert_raises(TypeError, np.promote_types, dt1, np.dtype([("", "V3")])) + assert_equal(np.promote_types('i4,f8', 'i8,f4'), + np.dtype([('f0', 'i8'), ('f1', 'f8')])) + # test nested case + dt1nest = np.dtype([("", dt1)]) + dt2nest = np.dtype([("", dt2)]) + assert_equal(np.promote_types(dt1nest, dt2nest), + np.dtype([('f0', np.dtype([('f0', 'i8')]))])) + + # note that offsets are lost when promoting: + dt = np.dtype({'names': ['x'], 'formats': ['i4'], 'offsets': [8]}) + a = np.ones(3, dtype=dt) + assert_equal(np.concatenate([a, a]).dtype, np.dtype([('x', 'i4')])) + + @pytest.mark.parametrize("dtype_dict", [ + dict(names=["a", "b"], formats=["i4", "f"], itemsize=100), + dict(names=["a", "b"], formats=["i4", "f"], + offsets=[0, 12])]) + @pytest.mark.parametrize("align", [True, False]) + def test_structured_promotion_packs(self, dtype_dict, align): + # Structured dtypes are packed when promoted (we consider the packed + # form to be "canonical"), so tere is no extra padding. + dtype = np.dtype(dtype_dict, align=align) + # Remove non "canonical" dtype options: + dtype_dict.pop("itemsize", None) + dtype_dict.pop("offsets", None) + expected = np.dtype(dtype_dict, align=align) + + res = np.promote_types(dtype, dtype) + assert res.itemsize == expected.itemsize + assert res.fields == expected.fields + + # But the "expected" one, should just be returned unchanged: + res = np.promote_types(expected, expected) + assert res is expected + + def test_structured_asarray_is_view(self): + # A scalar viewing an array preserves its view even when creating a + # new array. This test documents behaviour, it may not be the best + # desired behaviour. + arr = np.array([1], dtype="i,i") + scalar = arr[0] + assert not scalar.flags.owndata # view into the array + assert np.asarray(scalar).base is scalar + # But never when a dtype is passed in: + assert np.asarray(scalar, dtype=scalar.dtype).base is None + # A scalar which owns its data does not have this property. + # It is not easy to create one, one method is to use pickle: + scalar = pickle.loads(pickle.dumps(scalar)) + assert scalar.flags.owndata + assert np.asarray(scalar).base is None + +class TestBool: + def test_test_interning(self): + a0 = np.bool(0) + b0 = np.bool(False) + assert_(a0 is b0) + a1 = np.bool(1) + b1 = np.bool(True) + assert_(a1 is b1) + assert_(np.array([True])[0] is a1) + assert_(np.array(True)[()] is a1) + + def test_sum(self): + d = np.ones(101, dtype=bool) + assert_equal(d.sum(), d.size) + assert_equal(d[::2].sum(), d[::2].size) + assert_equal(d[::-2].sum(), d[::-2].size) + + d = np.frombuffer(b'\xff\xff' * 100, dtype=bool) + assert_equal(d.sum(), d.size) + assert_equal(d[::2].sum(), d[::2].size) + assert_equal(d[::-2].sum(), d[::-2].size) + + def check_count_nonzero(self, power, length): + powers = [2 ** i for i in range(length)] + for i in range(2**power): + l = [(i & x) != 0 for x in powers] + a = np.array(l, dtype=bool) + c = builtins.sum(l) + assert_equal(np.count_nonzero(a), c) + av = a.view(np.uint8) + av *= 3 + assert_equal(np.count_nonzero(a), c) + av *= 4 + assert_equal(np.count_nonzero(a), c) + av[av != 0] = 0xFF + assert_equal(np.count_nonzero(a), c) + + def test_count_nonzero(self): + # check all 12 bit combinations in a length 17 array + # covers most cases of the 16 byte unrolled code + self.check_count_nonzero(12, 17) + + @pytest.mark.slow + def test_count_nonzero_all(self): + # check all combinations in a length 17 array + # covers all cases of the 16 byte unrolled code + self.check_count_nonzero(17, 17) + + def test_count_nonzero_unaligned(self): + # prevent mistakes as e.g. gh-4060 + for o in range(7): + a = np.zeros((18,), dtype=bool)[o+1:] + a[:o] = True + assert_equal(np.count_nonzero(a), builtins.sum(a.tolist())) + a = np.ones((18,), dtype=bool)[o+1:] + a[:o] = False + assert_equal(np.count_nonzero(a), builtins.sum(a.tolist())) + + def _test_cast_from_flexible(self, dtype): + # empty string -> false + for n in range(3): + v = np.array(b'', (dtype, n)) + assert_equal(bool(v), False) + assert_equal(bool(v[()]), False) + assert_equal(v.astype(bool), False) + assert_(isinstance(v.astype(bool), np.ndarray)) + assert_(v[()].astype(bool) is np.False_) + + # anything else -> true + for n in range(1, 4): + for val in [b'a', b'0', b' ']: + v = np.array(val, (dtype, n)) + assert_equal(bool(v), True) + assert_equal(bool(v[()]), True) + assert_equal(v.astype(bool), True) + assert_(isinstance(v.astype(bool), np.ndarray)) + assert_(v[()].astype(bool) is np.True_) + + def test_cast_from_void(self): + self._test_cast_from_flexible(np.void) + + @pytest.mark.xfail(reason="See gh-9847") + def test_cast_from_unicode(self): + self._test_cast_from_flexible(np.str_) + + @pytest.mark.xfail(reason="See gh-9847") + def test_cast_from_bytes(self): + self._test_cast_from_flexible(np.bytes_) + + +class TestZeroSizeFlexible: + @staticmethod + def _zeros(shape, dtype=str): + dtype = np.dtype(dtype) + if dtype == np.void: + return np.zeros(shape, dtype=(dtype, 0)) + + # not constructable directly + dtype = np.dtype([('x', dtype, 0)]) + return np.zeros(shape, dtype=dtype)['x'] + + def test_create(self): + zs = self._zeros(10, bytes) + assert_equal(zs.itemsize, 0) + zs = self._zeros(10, np.void) + assert_equal(zs.itemsize, 0) + zs = self._zeros(10, str) + assert_equal(zs.itemsize, 0) + + def _test_sort_partition(self, name, kinds, **kwargs): + # Previously, these would all hang + for dt in [bytes, np.void, str]: + zs = self._zeros(10, dt) + sort_method = getattr(zs, name) + sort_func = getattr(np, name) + for kind in kinds: + sort_method(kind=kind, **kwargs) + sort_func(zs, kind=kind, **kwargs) + + def test_sort(self): + self._test_sort_partition('sort', kinds='qhs') + + def test_argsort(self): + self._test_sort_partition('argsort', kinds='qhs') + + def test_partition(self): + self._test_sort_partition('partition', kinds=['introselect'], kth=2) + + def test_argpartition(self): + self._test_sort_partition('argpartition', kinds=['introselect'], kth=2) + + def test_resize(self): + # previously an error + for dt in [bytes, np.void, str]: + zs = self._zeros(10, dt) + zs.resize(25) + zs.resize((10, 10)) + + def test_view(self): + for dt in [bytes, np.void, str]: + zs = self._zeros(10, dt) + + # viewing as itself should be allowed + assert_equal(zs.view(dt).dtype, np.dtype(dt)) + + # viewing as any non-empty type gives an empty result + assert_equal(zs.view((dt, 1)).shape, (0,)) + + def test_dumps(self): + zs = self._zeros(10, int) + assert_equal(zs, pickle.loads(zs.dumps())) + + def test_pickle(self): + for proto in range(2, pickle.HIGHEST_PROTOCOL + 1): + for dt in [bytes, np.void, str]: + zs = self._zeros(10, dt) + p = pickle.dumps(zs, protocol=proto) + zs2 = pickle.loads(p) + + assert_equal(zs.dtype, zs2.dtype) + + def test_pickle_empty(self): + """Checking if an empty array pickled and un-pickled will not cause a + segmentation fault""" + arr = np.array([]).reshape(999999, 0) + pk_dmp = pickle.dumps(arr) + pk_load = pickle.loads(pk_dmp) + + assert pk_load.size == 0 + + @pytest.mark.skipif(pickle.HIGHEST_PROTOCOL < 5, + reason="requires pickle protocol 5") + def test_pickle_with_buffercallback(self): + array = np.arange(10) + buffers = [] + bytes_string = pickle.dumps(array, buffer_callback=buffers.append, + protocol=5) + array_from_buffer = pickle.loads(bytes_string, buffers=buffers) + # when using pickle protocol 5 with buffer callbacks, + # array_from_buffer is reconstructed from a buffer holding a view + # to the initial array's data, so modifying an element in array + # should modify it in array_from_buffer too. + array[0] = -1 + assert array_from_buffer[0] == -1, array_from_buffer[0] + + +class TestMethods: + + sort_kinds = ['quicksort', 'heapsort', 'stable'] + + def test_all_where(self): + a = np.array([[True, False, True], + [False, False, False], + [True, True, True]]) + wh_full = np.array([[True, False, True], + [False, False, False], + [True, False, True]]) + wh_lower = np.array([[False], + [False], + [True]]) + for _ax in [0, None]: + assert_equal(a.all(axis=_ax, where=wh_lower), + np.all(a[wh_lower[:,0],:], axis=_ax)) + assert_equal(np.all(a, axis=_ax, where=wh_lower), + a[wh_lower[:,0],:].all(axis=_ax)) + + assert_equal(a.all(where=wh_full), True) + assert_equal(np.all(a, where=wh_full), True) + assert_equal(a.all(where=False), True) + assert_equal(np.all(a, where=False), True) + + def test_any_where(self): + a = np.array([[True, False, True], + [False, False, False], + [True, True, True]]) + wh_full = np.array([[False, True, False], + [True, True, True], + [False, False, False]]) + wh_middle = np.array([[False], + [True], + [False]]) + for _ax in [0, None]: + assert_equal(a.any(axis=_ax, where=wh_middle), + np.any(a[wh_middle[:,0],:], axis=_ax)) + assert_equal(np.any(a, axis=_ax, where=wh_middle), + a[wh_middle[:,0],:].any(axis=_ax)) + assert_equal(a.any(where=wh_full), False) + assert_equal(np.any(a, where=wh_full), False) + assert_equal(a.any(where=False), False) + assert_equal(np.any(a, where=False), False) + + @pytest.mark.parametrize("dtype", + ["i8", "U10", "object", "datetime64[ms]"]) + def test_any_and_all_result_dtype(self, dtype): + arr = np.ones(3, dtype=dtype) + assert arr.any().dtype == np.bool + assert arr.all().dtype == np.bool + + def test_any_and_all_object_dtype(self): + # (seberg) Not sure we should even allow dtype here, but it is. + arr = np.ones(3, dtype=object) + # keepdims to prevent getting a scalar. + assert arr.any(dtype=object, keepdims=True).dtype == object + assert arr.all(dtype=object, keepdims=True).dtype == object + + def test_compress(self): + tgt = [[5, 6, 7, 8, 9]] + arr = np.arange(10).reshape(2, 5) + out = arr.compress([0, 1], axis=0) + assert_equal(out, tgt) + + tgt = [[1, 3], [6, 8]] + out = arr.compress([0, 1, 0, 1, 0], axis=1) + assert_equal(out, tgt) + + tgt = [[1], [6]] + arr = np.arange(10).reshape(2, 5) + out = arr.compress([0, 1], axis=1) + assert_equal(out, tgt) + + arr = np.arange(10).reshape(2, 5) + out = arr.compress([0, 1]) + assert_equal(out, 1) + + def test_choose(self): + x = 2*np.ones((3,), dtype=int) + y = 3*np.ones((3,), dtype=int) + x2 = 2*np.ones((2, 3), dtype=int) + y2 = 3*np.ones((2, 3), dtype=int) + ind = np.array([0, 0, 1]) + + A = ind.choose((x, y)) + assert_equal(A, [2, 2, 3]) + + A = ind.choose((x2, y2)) + assert_equal(A, [[2, 2, 3], [2, 2, 3]]) + + A = ind.choose((x, y2)) + assert_equal(A, [[2, 2, 3], [2, 2, 3]]) + + oned = np.ones(1) + # gh-12031, caused SEGFAULT + assert_raises(TypeError, oned.choose,np.void(0), [oned]) + + out = np.array(0) + ret = np.choose(np.array(1), [10, 20, 30], out=out) + assert out is ret + assert_equal(out[()], 20) + + # gh-6272 check overlap on out + x = np.arange(5) + y = np.choose([0,0,0], [x[:3], x[:3], x[:3]], out=x[1:4], mode='wrap') + assert_equal(y, np.array([0, 1, 2])) + + def test_prod(self): + ba = [1, 2, 10, 11, 6, 5, 4] + ba2 = [[1, 2, 3, 4], [5, 6, 7, 9], [10, 3, 4, 5]] + + for ctype in [np.int16, np.uint16, np.int32, np.uint32, + np.float32, np.float64, np.complex64, np.complex128]: + a = np.array(ba, ctype) + a2 = np.array(ba2, ctype) + if ctype in ['1', 'b']: + assert_raises(ArithmeticError, a.prod) + assert_raises(ArithmeticError, a2.prod, axis=1) + else: + assert_equal(a.prod(axis=0), 26400) + assert_array_equal(a2.prod(axis=0), + np.array([50, 36, 84, 180], ctype)) + assert_array_equal(a2.prod(axis=-1), + np.array([24, 1890, 600], ctype)) + + @pytest.mark.parametrize('dtype', [None, object]) + def test_repeat(self, dtype): + m = np.array([1, 2, 3, 4, 5, 6], dtype=dtype) + m_rect = m.reshape((2, 3)) + + A = m.repeat([1, 3, 2, 1, 1, 2]) + assert_equal(A, [1, 2, 2, 2, 3, + 3, 4, 5, 6, 6]) + + A = m.repeat(2) + assert_equal(A, [1, 1, 2, 2, 3, 3, + 4, 4, 5, 5, 6, 6]) + + A = m_rect.repeat([2, 1], axis=0) + assert_equal(A, [[1, 2, 3], + [1, 2, 3], + [4, 5, 6]]) + + A = m_rect.repeat([1, 3, 2], axis=1) + assert_equal(A, [[1, 2, 2, 2, 3, 3], + [4, 5, 5, 5, 6, 6]]) + + A = m_rect.repeat(2, axis=0) + assert_equal(A, [[1, 2, 3], + [1, 2, 3], + [4, 5, 6], + [4, 5, 6]]) + + A = m_rect.repeat(2, axis=1) + assert_equal(A, [[1, 1, 2, 2, 3, 3], + [4, 4, 5, 5, 6, 6]]) + + def test_reshape(self): + arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]]) + + tgt = [[1, 2, 3, 4, 5, 6], [7, 8, 9, 10, 11, 12]] + assert_equal(arr.reshape(2, 6), tgt) + + tgt = [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]] + assert_equal(arr.reshape(3, 4), tgt) + + tgt = [[1, 10, 8, 6], [4, 2, 11, 9], [7, 5, 3, 12]] + assert_equal(arr.reshape((3, 4), order='F'), tgt) + + tgt = [[1, 4, 7, 10], [2, 5, 8, 11], [3, 6, 9, 12]] + assert_equal(arr.T.reshape((3, 4), order='C'), tgt) + + def test_round(self): + def check_round(arr, expected, *round_args): + assert_equal(arr.round(*round_args), expected) + # With output array + out = np.zeros_like(arr) + res = arr.round(*round_args, out=out) + assert_equal(out, expected) + assert out is res + + check_round(np.array([1.2, 1.5]), [1, 2]) + check_round(np.array(1.5), 2) + check_round(np.array([12.2, 15.5]), [10, 20], -1) + check_round(np.array([12.15, 15.51]), [12.2, 15.5], 1) + # Complex rounding + check_round(np.array([4.5 + 1.5j]), [4 + 2j]) + check_round(np.array([12.5 + 15.5j]), [10 + 20j], -1) + + def test_squeeze(self): + a = np.array([[[1], [2], [3]]]) + assert_equal(a.squeeze(), [1, 2, 3]) + assert_equal(a.squeeze(axis=(0,)), [[1], [2], [3]]) + assert_raises(ValueError, a.squeeze, axis=(1,)) + assert_equal(a.squeeze(axis=(2,)), [[1, 2, 3]]) + + def test_transpose(self): + a = np.array([[1, 2], [3, 4]]) + assert_equal(a.transpose(), [[1, 3], [2, 4]]) + assert_raises(ValueError, lambda: a.transpose(0)) + assert_raises(ValueError, lambda: a.transpose(0, 0)) + assert_raises(ValueError, lambda: a.transpose(0, 1, 2)) + + def test_sort(self): + # test ordering for floats and complex containing nans. It is only + # necessary to check the less-than comparison, so sorts that + # only follow the insertion sort path are sufficient. We only + # test doubles and complex doubles as the logic is the same. + + # check doubles + msg = "Test real sort order with nans" + a = np.array([np.nan, 1, 0]) + b = np.sort(a) + assert_equal(b, a[::-1], msg) + # check complex + msg = "Test complex sort order with nans" + a = np.zeros(9, dtype=np.complex128) + a.real += [np.nan, np.nan, np.nan, 1, 0, 1, 1, 0, 0] + a.imag += [np.nan, 1, 0, np.nan, np.nan, 1, 0, 1, 0] + b = np.sort(a) + assert_equal(b, a[::-1], msg) + + with assert_raises_regex( + ValueError, + "kind` and `stable` parameters can't be provided at the same time" + ): + np.sort(a, kind="stable", stable=True) + + # all c scalar sorts use the same code with different types + # so it suffices to run a quick check with one type. The number + # of sorted items must be greater than ~50 to check the actual + # algorithm because quick and merge sort fall over to insertion + # sort for small arrays. + + @pytest.mark.parametrize('dtype', [np.uint8, np.uint16, np.uint32, np.uint64, + np.float16, np.float32, np.float64, + np.longdouble]) + def test_sort_unsigned(self, dtype): + a = np.arange(101, dtype=dtype) + b = a[::-1].copy() + for kind in self.sort_kinds: + msg = "scalar sort, kind=%s" % kind + c = a.copy() + c.sort(kind=kind) + assert_equal(c, a, msg) + c = b.copy() + c.sort(kind=kind) + assert_equal(c, a, msg) + + @pytest.mark.parametrize('dtype', + [np.int8, np.int16, np.int32, np.int64, np.float16, + np.float32, np.float64, np.longdouble]) + def test_sort_signed(self, dtype): + a = np.arange(-50, 51, dtype=dtype) + b = a[::-1].copy() + for kind in self.sort_kinds: + msg = "scalar sort, kind=%s" % (kind) + c = a.copy() + c.sort(kind=kind) + assert_equal(c, a, msg) + c = b.copy() + c.sort(kind=kind) + assert_equal(c, a, msg) + + @pytest.mark.parametrize('dtype', [np.float32, np.float64, np.longdouble]) + @pytest.mark.parametrize('part', ['real', 'imag']) + def test_sort_complex(self, part, dtype): + # test complex sorts. These use the same code as the scalars + # but the compare function differs. + cdtype = { + np.single: np.csingle, + np.double: np.cdouble, + np.longdouble: np.clongdouble, + }[dtype] + a = np.arange(-50, 51, dtype=dtype) + b = a[::-1].copy() + ai = (a * (1+1j)).astype(cdtype) + bi = (b * (1+1j)).astype(cdtype) + setattr(ai, part, 1) + setattr(bi, part, 1) + for kind in self.sort_kinds: + msg = "complex sort, %s part == 1, kind=%s" % (part, kind) + c = ai.copy() + c.sort(kind=kind) + assert_equal(c, ai, msg) + c = bi.copy() + c.sort(kind=kind) + assert_equal(c, ai, msg) + + def test_sort_complex_byte_swapping(self): + # test sorting of complex arrays requiring byte-swapping, gh-5441 + for endianness in '<>': + for dt in np.typecodes['Complex']: + arr = np.array([1+3.j, 2+2.j, 3+1.j], dtype=endianness + dt) + c = arr.copy() + c.sort() + msg = 'byte-swapped complex sort, dtype={0}'.format(dt) + assert_equal(c, arr, msg) + + @pytest.mark.parametrize('dtype', [np.bytes_, np.str_]) + def test_sort_string(self, dtype): + # np.array will perform the encoding to bytes for us in the bytes test + a = np.array(['aaaaaaaa' + chr(i) for i in range(101)], dtype=dtype) + b = a[::-1].copy() + for kind in self.sort_kinds: + msg = "kind=%s" % kind + c = a.copy() + c.sort(kind=kind) + assert_equal(c, a, msg) + c = b.copy() + c.sort(kind=kind) + assert_equal(c, a, msg) + + def test_sort_object(self): + # test object array sorts. + a = np.empty((101,), dtype=object) + a[:] = list(range(101)) + b = a[::-1] + for kind in ['q', 'h', 'm']: + msg = "kind=%s" % kind + c = a.copy() + c.sort(kind=kind) + assert_equal(c, a, msg) + c = b.copy() + c.sort(kind=kind) + assert_equal(c, a, msg) + + @pytest.mark.parametrize("dt", [ + np.dtype([('f', float), ('i', int)]), + np.dtype([('f', float), ('i', object)])]) + @pytest.mark.parametrize("step", [1, 2]) + def test_sort_structured(self, dt, step): + # test record array sorts. + a = np.array([(i, i) for i in range(101*step)], dtype=dt) + b = a[::-1] + for kind in ['q', 'h', 'm']: + msg = "kind=%s" % kind + c = a.copy()[::step] + indx = c.argsort(kind=kind) + c.sort(kind=kind) + assert_equal(c, a[::step], msg) + assert_equal(a[::step][indx], a[::step], msg) + c = b.copy()[::step] + indx = c.argsort(kind=kind) + c.sort(kind=kind) + assert_equal(c, a[step-1::step], msg) + assert_equal(b[::step][indx], a[step-1::step], msg) + + @pytest.mark.parametrize('dtype', ['datetime64[D]', 'timedelta64[D]']) + def test_sort_time(self, dtype): + # test datetime64 and timedelta64 sorts. + a = np.arange(0, 101, dtype=dtype) + b = a[::-1] + for kind in ['q', 'h', 'm']: + msg = "kind=%s" % kind + c = a.copy() + c.sort(kind=kind) + assert_equal(c, a, msg) + c = b.copy() + c.sort(kind=kind) + assert_equal(c, a, msg) + + def test_sort_axis(self): + # check axis handling. This should be the same for all type + # specific sorts, so we only check it for one type and one kind + a = np.array([[3, 2], [1, 0]]) + b = np.array([[1, 0], [3, 2]]) + c = np.array([[2, 3], [0, 1]]) + d = a.copy() + d.sort(axis=0) + assert_equal(d, b, "test sort with axis=0") + d = a.copy() + d.sort(axis=1) + assert_equal(d, c, "test sort with axis=1") + d = a.copy() + d.sort() + assert_equal(d, c, "test sort with default axis") + + def test_sort_size_0(self): + # check axis handling for multidimensional empty arrays + a = np.array([]) + a.shape = (3, 2, 1, 0) + for axis in range(-a.ndim, a.ndim): + msg = 'test empty array sort with axis={0}'.format(axis) + assert_equal(np.sort(a, axis=axis), a, msg) + msg = 'test empty array sort with axis=None' + assert_equal(np.sort(a, axis=None), a.ravel(), msg) + + def test_sort_bad_ordering(self): + # test generic class with bogus ordering, + # should not segfault. + class Boom: + def __lt__(self, other): + return True + + a = np.array([Boom()] * 100, dtype=object) + for kind in self.sort_kinds: + msg = "kind=%s" % kind + c = a.copy() + c.sort(kind=kind) + assert_equal(c, a, msg) + + def test_void_sort(self): + # gh-8210 - previously segfaulted + for i in range(4): + rand = np.random.randint(256, size=4000, dtype=np.uint8) + arr = rand.view('V4') + arr[::-1].sort() + + dt = np.dtype([('val', 'i4', (1,))]) + for i in range(4): + rand = np.random.randint(256, size=4000, dtype=np.uint8) + arr = rand.view(dt) + arr[::-1].sort() + + def test_sort_raises(self): + #gh-9404 + arr = np.array([0, datetime.now(), 1], dtype=object) + for kind in self.sort_kinds: + assert_raises(TypeError, arr.sort, kind=kind) + #gh-3879 + class Raiser: + def raises_anything(*args, **kwargs): + raise TypeError("SOMETHING ERRORED") + __eq__ = __ne__ = __lt__ = __gt__ = __ge__ = __le__ = raises_anything + arr = np.array([[Raiser(), n] for n in range(10)]).reshape(-1) + np.random.shuffle(arr) + for kind in self.sort_kinds: + assert_raises(TypeError, arr.sort, kind=kind) + + def test_sort_degraded(self): + # test degraded dataset would take minutes to run with normal qsort + d = np.arange(1000000) + do = d.copy() + x = d + # create a median of 3 killer where each median is the sorted second + # last element of the quicksort partition + while x.size > 3: + mid = x.size // 2 + x[mid], x[-2] = x[-2], x[mid] + x = x[:-2] + + assert_equal(np.sort(d), do) + assert_equal(d[np.argsort(d)], do) + + def test_copy(self): + def assert_fortran(arr): + assert_(arr.flags.fortran) + assert_(arr.flags.f_contiguous) + assert_(not arr.flags.c_contiguous) + + def assert_c(arr): + assert_(not arr.flags.fortran) + assert_(not arr.flags.f_contiguous) + assert_(arr.flags.c_contiguous) + + a = np.empty((2, 2), order='F') + # Test copying a Fortran array + assert_c(a.copy()) + assert_c(a.copy('C')) + assert_fortran(a.copy('F')) + assert_fortran(a.copy('A')) + + # Now test starting with a C array. + a = np.empty((2, 2), order='C') + assert_c(a.copy()) + assert_c(a.copy('C')) + assert_fortran(a.copy('F')) + assert_c(a.copy('A')) + + @pytest.mark.parametrize("dtype", ['O', np.int32, 'i,O']) + def test__deepcopy__(self, dtype): + # Force the entry of NULLs into array + a = np.empty(4, dtype=dtype) + ctypes.memset(a.ctypes.data, 0, a.nbytes) + + # Ensure no error is raised, see gh-21833 + b = a.__deepcopy__({}) + + a[0] = 42 + with pytest.raises(AssertionError): + assert_array_equal(a, b) + + def test__deepcopy__catches_failure(self): + class MyObj: + def __deepcopy__(self, *args, **kwargs): + raise RuntimeError + + arr = np.array([1, MyObj(), 3], dtype='O') + with pytest.raises(RuntimeError): + arr.__deepcopy__({}) + + def test_sort_order(self): + # Test sorting an array with fields + x1 = np.array([21, 32, 14]) + x2 = np.array(['my', 'first', 'name']) + x3 = np.array([3.1, 4.5, 6.2]) + r = np.rec.fromarrays([x1, x2, x3], names='id,word,number') + + r.sort(order=['id']) + assert_equal(r.id, np.array([14, 21, 32])) + assert_equal(r.word, np.array(['name', 'my', 'first'])) + assert_equal(r.number, np.array([6.2, 3.1, 4.5])) + + r.sort(order=['word']) + assert_equal(r.id, np.array([32, 21, 14])) + assert_equal(r.word, np.array(['first', 'my', 'name'])) + assert_equal(r.number, np.array([4.5, 3.1, 6.2])) + + r.sort(order=['number']) + assert_equal(r.id, np.array([21, 32, 14])) + assert_equal(r.word, np.array(['my', 'first', 'name'])) + assert_equal(r.number, np.array([3.1, 4.5, 6.2])) + + assert_raises_regex(ValueError, 'duplicate', + lambda: r.sort(order=['id', 'id'])) + + if sys.byteorder == 'little': + strtype = '>i2' + else: + strtype = '': + for dt in np.typecodes['Complex']: + arr = np.array([1+3.j, 2+2.j, 3+1.j], dtype=endianness + dt) + msg = 'byte-swapped complex argsort, dtype={0}'.format(dt) + assert_equal(arr.argsort(), + np.arange(len(arr), dtype=np.intp), msg) + + # test string argsorts. + s = 'aaaaaaaa' + a = np.array([s + chr(i) for i in range(101)]) + b = a[::-1].copy() + r = np.arange(101) + rr = r[::-1] + for kind in self.sort_kinds: + msg = "string argsort, kind=%s" % kind + assert_equal(a.copy().argsort(kind=kind), r, msg) + assert_equal(b.copy().argsort(kind=kind), rr, msg) + + # test unicode argsorts. + s = 'aaaaaaaa' + a = np.array([s + chr(i) for i in range(101)], dtype=np.str_) + b = a[::-1] + r = np.arange(101) + rr = r[::-1] + for kind in self.sort_kinds: + msg = "unicode argsort, kind=%s" % kind + assert_equal(a.copy().argsort(kind=kind), r, msg) + assert_equal(b.copy().argsort(kind=kind), rr, msg) + + # test object array argsorts. + a = np.empty((101,), dtype=object) + a[:] = list(range(101)) + b = a[::-1] + r = np.arange(101) + rr = r[::-1] + for kind in self.sort_kinds: + msg = "object argsort, kind=%s" % kind + assert_equal(a.copy().argsort(kind=kind), r, msg) + assert_equal(b.copy().argsort(kind=kind), rr, msg) + + # test structured array argsorts. + dt = np.dtype([('f', float), ('i', int)]) + a = np.array([(i, i) for i in range(101)], dtype=dt) + b = a[::-1] + r = np.arange(101) + rr = r[::-1] + for kind in self.sort_kinds: + msg = "structured array argsort, kind=%s" % kind + assert_equal(a.copy().argsort(kind=kind), r, msg) + assert_equal(b.copy().argsort(kind=kind), rr, msg) + + # test datetime64 argsorts. + a = np.arange(0, 101, dtype='datetime64[D]') + b = a[::-1] + r = np.arange(101) + rr = r[::-1] + for kind in ['q', 'h', 'm']: + msg = "datetime64 argsort, kind=%s" % kind + assert_equal(a.copy().argsort(kind=kind), r, msg) + assert_equal(b.copy().argsort(kind=kind), rr, msg) + + # test timedelta64 argsorts. + a = np.arange(0, 101, dtype='timedelta64[D]') + b = a[::-1] + r = np.arange(101) + rr = r[::-1] + for kind in ['q', 'h', 'm']: + msg = "timedelta64 argsort, kind=%s" % kind + assert_equal(a.copy().argsort(kind=kind), r, msg) + assert_equal(b.copy().argsort(kind=kind), rr, msg) + + # check axis handling. This should be the same for all type + # specific argsorts, so we only check it for one type and one kind + a = np.array([[3, 2], [1, 0]]) + b = np.array([[1, 1], [0, 0]]) + c = np.array([[1, 0], [1, 0]]) + assert_equal(a.copy().argsort(axis=0), b) + assert_equal(a.copy().argsort(axis=1), c) + assert_equal(a.copy().argsort(), c) + + # check axis handling for multidimensional empty arrays + a = np.array([]) + a.shape = (3, 2, 1, 0) + for axis in range(-a.ndim, a.ndim): + msg = 'test empty array argsort with axis={0}'.format(axis) + assert_equal(np.argsort(a, axis=axis), + np.zeros_like(a, dtype=np.intp), msg) + msg = 'test empty array argsort with axis=None' + assert_equal(np.argsort(a, axis=None), + np.zeros_like(a.ravel(), dtype=np.intp), msg) + + # check that stable argsorts are stable + r = np.arange(100) + # scalars + a = np.zeros(100) + assert_equal(a.argsort(kind='m'), r) + # complex + a = np.zeros(100, dtype=complex) + assert_equal(a.argsort(kind='m'), r) + # string + a = np.array(['aaaaaaaaa' for i in range(100)]) + assert_equal(a.argsort(kind='m'), r) + # unicode + a = np.array(['aaaaaaaaa' for i in range(100)], dtype=np.str_) + assert_equal(a.argsort(kind='m'), r) + + with assert_raises_regex( + ValueError, + "kind` and `stable` parameters can't be provided at the same time" + ): + np.argsort(a, kind="stable", stable=True) + + def test_sort_unicode_kind(self): + d = np.arange(10) + k = b'\xc3\xa4'.decode("UTF8") + assert_raises(ValueError, d.sort, kind=k) + assert_raises(ValueError, d.argsort, kind=k) + + @pytest.mark.parametrize('a', [ + np.array([0, 1, np.nan], dtype=np.float16), + np.array([0, 1, np.nan], dtype=np.float32), + np.array([0, 1, np.nan]), + ]) + def test_searchsorted_floats(self, a): + # test for floats arrays containing nans. Explicitly test + # half, single, and double precision floats to verify that + # the NaN-handling is correct. + msg = "Test real (%s) searchsorted with nans, side='l'" % a.dtype + b = a.searchsorted(a, side='left') + assert_equal(b, np.arange(3), msg) + msg = "Test real (%s) searchsorted with nans, side='r'" % a.dtype + b = a.searchsorted(a, side='right') + assert_equal(b, np.arange(1, 4), msg) + # check keyword arguments + a.searchsorted(v=1) + x = np.array([0, 1, np.nan], dtype='float32') + y = np.searchsorted(x, x[-1]) + assert_equal(y, 2) + + def test_searchsorted_complex(self): + # test for complex arrays containing nans. + # The search sorted routines use the compare functions for the + # array type, so this checks if that is consistent with the sort + # order. + # check double complex + a = np.zeros(9, dtype=np.complex128) + a.real += [0, 0, 1, 1, 0, 1, np.nan, np.nan, np.nan] + a.imag += [0, 1, 0, 1, np.nan, np.nan, 0, 1, np.nan] + msg = "Test complex searchsorted with nans, side='l'" + b = a.searchsorted(a, side='left') + assert_equal(b, np.arange(9), msg) + msg = "Test complex searchsorted with nans, side='r'" + b = a.searchsorted(a, side='right') + assert_equal(b, np.arange(1, 10), msg) + msg = "Test searchsorted with little endian, side='l'" + a = np.array([0, 128], dtype=' p[:, i]).all(), + msg="%d: %r < %r" % (i, p[:, i], p[:, i + 1:].T)) + for row in range(p.shape[0]): + self.assert_partitioned(p[row], [i]) + self.assert_partitioned(parg[row], [i]) + + p = np.partition(d0, i, axis=0, kind=k) + parg = d0[np.argpartition(d0, i, axis=0, kind=k), + np.arange(d0.shape[1])[None, :]] + aae(p[i, :], np.array([i] * d1.shape[0], dtype=dt)) + # array_less does not seem to work right + at((p[:i, :] <= p[i, :]).all(), + msg="%d: %r <= %r" % (i, p[i, :], p[:i, :])) + at((p[i + 1:, :] > p[i, :]).all(), + msg="%d: %r < %r" % (i, p[i, :], p[:, i + 1:])) + for col in range(p.shape[1]): + self.assert_partitioned(p[:, col], [i]) + self.assert_partitioned(parg[:, col], [i]) + + # check inplace + dc = d.copy() + dc.partition(i, kind=k) + assert_equal(dc, np.partition(d, i, kind=k)) + dc = d0.copy() + dc.partition(i, axis=0, kind=k) + assert_equal(dc, np.partition(d0, i, axis=0, kind=k)) + dc = d1.copy() + dc.partition(i, axis=1, kind=k) + assert_equal(dc, np.partition(d1, i, axis=1, kind=k)) + + def assert_partitioned(self, d, kth): + prev = 0 + for k in np.sort(kth): + assert_array_compare(operator.__le__, d[prev:k], d[k], + err_msg='kth %d' % k) + assert_((d[k:] >= d[k]).all(), + msg="kth %d, %r not greater equal %r" % (k, d[k:], d[k])) + prev = k + 1 + + def test_partition_iterative(self): + d = np.arange(17) + kth = (0, 1, 2, 429, 231) + assert_raises(ValueError, d.partition, kth) + assert_raises(ValueError, d.argpartition, kth) + d = np.arange(10).reshape((2, 5)) + assert_raises(ValueError, d.partition, kth, axis=0) + assert_raises(ValueError, d.partition, kth, axis=1) + assert_raises(ValueError, np.partition, d, kth, axis=1) + assert_raises(ValueError, np.partition, d, kth, axis=None) + + d = np.array([3, 4, 2, 1]) + p = np.partition(d, (0, 3)) + self.assert_partitioned(p, (0, 3)) + self.assert_partitioned(d[np.argpartition(d, (0, 3))], (0, 3)) + + assert_array_equal(p, np.partition(d, (-3, -1))) + assert_array_equal(p, d[np.argpartition(d, (-3, -1))]) + + d = np.arange(17) + np.random.shuffle(d) + d.partition(range(d.size)) + assert_array_equal(np.arange(17), d) + np.random.shuffle(d) + assert_array_equal(np.arange(17), d[d.argpartition(range(d.size))]) + + # test unsorted kth + d = np.arange(17) + np.random.shuffle(d) + keys = np.array([1, 3, 8, -2]) + np.random.shuffle(d) + p = np.partition(d, keys) + self.assert_partitioned(p, keys) + p = d[np.argpartition(d, keys)] + self.assert_partitioned(p, keys) + np.random.shuffle(keys) + assert_array_equal(np.partition(d, keys), p) + assert_array_equal(d[np.argpartition(d, keys)], p) + + # equal kth + d = np.arange(20)[::-1] + self.assert_partitioned(np.partition(d, [5]*4), [5]) + self.assert_partitioned(np.partition(d, [5]*4 + [6, 13]), + [5]*4 + [6, 13]) + self.assert_partitioned(d[np.argpartition(d, [5]*4)], [5]) + self.assert_partitioned(d[np.argpartition(d, [5]*4 + [6, 13])], + [5]*4 + [6, 13]) + + d = np.arange(12) + np.random.shuffle(d) + d1 = np.tile(np.arange(12), (4, 1)) + map(np.random.shuffle, d1) + d0 = np.transpose(d1) + + kth = (1, 6, 7, -1) + p = np.partition(d1, kth, axis=1) + pa = d1[np.arange(d1.shape[0])[:, None], + d1.argpartition(kth, axis=1)] + assert_array_equal(p, pa) + for i in range(d1.shape[0]): + self.assert_partitioned(p[i,:], kth) + p = np.partition(d0, kth, axis=0) + pa = d0[np.argpartition(d0, kth, axis=0), + np.arange(d0.shape[1])[None,:]] + assert_array_equal(p, pa) + for i in range(d0.shape[1]): + self.assert_partitioned(p[:, i], kth) + + def test_partition_cdtype(self): + d = np.array([('Galahad', 1.7, 38), ('Arthur', 1.8, 41), + ('Lancelot', 1.9, 38)], + dtype=[('name', '|S10'), ('height', ' (numpy ufunc, has_in_place_version, preferred_dtype) + ops = { + 'add': (np.add, True, float), + 'sub': (np.subtract, True, float), + 'mul': (np.multiply, True, float), + 'truediv': (np.true_divide, True, float), + 'floordiv': (np.floor_divide, True, float), + 'mod': (np.remainder, True, float), + 'divmod': (np.divmod, False, float), + 'pow': (np.power, True, int), + 'lshift': (np.left_shift, True, int), + 'rshift': (np.right_shift, True, int), + 'and': (np.bitwise_and, True, int), + 'xor': (np.bitwise_xor, True, int), + 'or': (np.bitwise_or, True, int), + 'matmul': (np.matmul, True, float), + # 'ge': (np.less_equal, False), + # 'gt': (np.less, False), + # 'le': (np.greater_equal, False), + # 'lt': (np.greater, False), + # 'eq': (np.equal, False), + # 'ne': (np.not_equal, False), + } + + class Coerced(Exception): + pass + + def array_impl(self): + raise Coerced + + def op_impl(self, other): + return "forward" + + def rop_impl(self, other): + return "reverse" + + def iop_impl(self, other): + return "in-place" + + def array_ufunc_impl(self, ufunc, method, *args, **kwargs): + return ("__array_ufunc__", ufunc, method, args, kwargs) + + # Create an object with the given base, in the given module, with a + # bunch of placeholder __op__ methods, and optionally a + # __array_ufunc__ and __array_priority__. + def make_obj(base, array_priority=False, array_ufunc=False, + alleged_module="__main__"): + class_namespace = {"__array__": array_impl} + if array_priority is not False: + class_namespace["__array_priority__"] = array_priority + for op in ops: + class_namespace["__{0}__".format(op)] = op_impl + class_namespace["__r{0}__".format(op)] = rop_impl + class_namespace["__i{0}__".format(op)] = iop_impl + if array_ufunc is not False: + class_namespace["__array_ufunc__"] = array_ufunc + eval_namespace = {"base": base, + "class_namespace": class_namespace, + "__name__": alleged_module, + } + MyType = eval("type('MyType', (base,), class_namespace)", + eval_namespace) + if issubclass(MyType, np.ndarray): + # Use this range to avoid special case weirdnesses around + # divide-by-0, pow(x, 2), overflow due to pow(big, big), etc. + return np.arange(3, 7).reshape(2, 2).view(MyType) + else: + return MyType() + + def check(obj, binop_override_expected, ufunc_override_expected, + inplace_override_expected, check_scalar=True): + for op, (ufunc, has_inplace, dtype) in ops.items(): + err_msg = ('op: %s, ufunc: %s, has_inplace: %s, dtype: %s' + % (op, ufunc, has_inplace, dtype)) + check_objs = [np.arange(3, 7, dtype=dtype).reshape(2, 2)] + if check_scalar: + check_objs.append(check_objs[0][0]) + for arr in check_objs: + arr_method = getattr(arr, "__{0}__".format(op)) + + def first_out_arg(result): + if op == "divmod": + assert_(isinstance(result, tuple)) + return result[0] + else: + return result + + # arr __op__ obj + if binop_override_expected: + assert_equal(arr_method(obj), NotImplemented, err_msg) + elif ufunc_override_expected: + assert_equal(arr_method(obj)[0], "__array_ufunc__", + err_msg) + else: + if (isinstance(obj, np.ndarray) and + (type(obj).__array_ufunc__ is + np.ndarray.__array_ufunc__)): + # __array__ gets ignored + res = first_out_arg(arr_method(obj)) + assert_(res.__class__ is obj.__class__, err_msg) + else: + assert_raises((TypeError, Coerced), + arr_method, obj, err_msg=err_msg) + # obj __op__ arr + arr_rmethod = getattr(arr, "__r{0}__".format(op)) + if ufunc_override_expected: + res = arr_rmethod(obj) + assert_equal(res[0], "__array_ufunc__", + err_msg=err_msg) + assert_equal(res[1], ufunc, err_msg=err_msg) + else: + if (isinstance(obj, np.ndarray) and + (type(obj).__array_ufunc__ is + np.ndarray.__array_ufunc__)): + # __array__ gets ignored + res = first_out_arg(arr_rmethod(obj)) + assert_(res.__class__ is obj.__class__, err_msg) + else: + # __array_ufunc__ = "asdf" creates a TypeError + assert_raises((TypeError, Coerced), + arr_rmethod, obj, err_msg=err_msg) + + # arr __iop__ obj + # array scalars don't have in-place operators + if has_inplace and isinstance(arr, np.ndarray): + arr_imethod = getattr(arr, "__i{0}__".format(op)) + if inplace_override_expected: + assert_equal(arr_method(obj), NotImplemented, + err_msg=err_msg) + elif ufunc_override_expected: + res = arr_imethod(obj) + assert_equal(res[0], "__array_ufunc__", err_msg) + assert_equal(res[1], ufunc, err_msg) + assert_(type(res[-1]["out"]) is tuple, err_msg) + assert_(res[-1]["out"][0] is arr, err_msg) + else: + if (isinstance(obj, np.ndarray) and + (type(obj).__array_ufunc__ is + np.ndarray.__array_ufunc__)): + # __array__ gets ignored + assert_(arr_imethod(obj) is arr, err_msg) + else: + assert_raises((TypeError, Coerced), + arr_imethod, obj, + err_msg=err_msg) + + op_fn = getattr(operator, op, None) + if op_fn is None: + op_fn = getattr(operator, op + "_", None) + if op_fn is None: + op_fn = getattr(builtins, op) + assert_equal(op_fn(obj, arr), "forward", err_msg) + if not isinstance(obj, np.ndarray): + if binop_override_expected: + assert_equal(op_fn(arr, obj), "reverse", err_msg) + elif ufunc_override_expected: + assert_equal(op_fn(arr, obj)[0], "__array_ufunc__", + err_msg) + if ufunc_override_expected: + assert_equal(ufunc(obj, arr)[0], "__array_ufunc__", + err_msg) + + # No array priority, no array_ufunc -> nothing called + check(make_obj(object), False, False, False) + # Negative array priority, no array_ufunc -> nothing called + # (has to be very negative, because scalar priority is -1000000.0) + check(make_obj(object, array_priority=-2**30), False, False, False) + # Positive array priority, no array_ufunc -> binops and iops only + check(make_obj(object, array_priority=1), True, False, True) + # ndarray ignores array_priority for ndarray subclasses + check(make_obj(np.ndarray, array_priority=1), False, False, False, + check_scalar=False) + # Positive array_priority and array_ufunc -> array_ufunc only + check(make_obj(object, array_priority=1, + array_ufunc=array_ufunc_impl), False, True, False) + check(make_obj(np.ndarray, array_priority=1, + array_ufunc=array_ufunc_impl), False, True, False) + # array_ufunc set to None -> defer binops only + check(make_obj(object, array_ufunc=None), True, False, False) + check(make_obj(np.ndarray, array_ufunc=None), True, False, False, + check_scalar=False) + + @pytest.mark.parametrize("priority", [None, "runtime error"]) + def test_ufunc_binop_bad_array_priority(self, priority): + # Mainly checks that this does not crash. The second array has a lower + # priority than -1 ("error value"). If the __radd__ actually exists, + # bad things can happen (I think via the scalar paths). + # In principle both of these can probably just be errors in the future. + class BadPriority: + @property + def __array_priority__(self): + if priority == "runtime error": + raise RuntimeError("RuntimeError in __array_priority__!") + return priority + + def __radd__(self, other): + return "result" + + class LowPriority(np.ndarray): + __array_priority__ = -1000 + + # Priority failure uses the same as scalars (smaller -1000). So the + # LowPriority wins with 'result' for each element (inner operation). + res = np.arange(3).view(LowPriority) + BadPriority() + assert res.shape == (3,) + assert res[0] == 'result' + + @pytest.mark.parametrize("scalar", [ + np.longdouble(1), np.timedelta64(120, 'm')]) + @pytest.mark.parametrize("op", [operator.add, operator.xor]) + def test_scalar_binop_guarantees_ufunc(self, scalar, op): + # Test that __array_ufunc__ will always cause ufunc use even when + # we have to protect some other calls from recursing (see gh-26904). + class SomeClass: + def __array_ufunc__(self, ufunc, method, *inputs, **kw): + return "result" + + assert SomeClass() + scalar == "result" + assert scalar + SomeClass() == "result" + + def test_ufunc_override_normalize_signature(self): + # gh-5674 + class SomeClass: + def __array_ufunc__(self, ufunc, method, *inputs, **kw): + return kw + + a = SomeClass() + kw = np.add(a, [1]) + assert_('sig' not in kw and 'signature' not in kw) + kw = np.add(a, [1], sig='ii->i') + assert_('sig' not in kw and 'signature' in kw) + assert_equal(kw['signature'], 'ii->i') + kw = np.add(a, [1], signature='ii->i') + assert_('sig' not in kw and 'signature' in kw) + assert_equal(kw['signature'], 'ii->i') + + def test_array_ufunc_index(self): + # Check that index is set appropriately, also if only an output + # is passed on (latter is another regression tests for github bug 4753) + # This also checks implicitly that 'out' is always a tuple. + class CheckIndex: + def __array_ufunc__(self, ufunc, method, *inputs, **kw): + for i, a in enumerate(inputs): + if a is self: + return i + # calls below mean we must be in an output. + for j, a in enumerate(kw['out']): + if a is self: + return (j,) + + a = CheckIndex() + dummy = np.arange(2.) + # 1 input, 1 output + assert_equal(np.sin(a), 0) + assert_equal(np.sin(dummy, a), (0,)) + assert_equal(np.sin(dummy, out=a), (0,)) + assert_equal(np.sin(dummy, out=(a,)), (0,)) + assert_equal(np.sin(a, a), 0) + assert_equal(np.sin(a, out=a), 0) + assert_equal(np.sin(a, out=(a,)), 0) + # 1 input, 2 outputs + assert_equal(np.modf(dummy, a), (0,)) + assert_equal(np.modf(dummy, None, a), (1,)) + assert_equal(np.modf(dummy, dummy, a), (1,)) + assert_equal(np.modf(dummy, out=(a, None)), (0,)) + assert_equal(np.modf(dummy, out=(a, dummy)), (0,)) + assert_equal(np.modf(dummy, out=(None, a)), (1,)) + assert_equal(np.modf(dummy, out=(dummy, a)), (1,)) + assert_equal(np.modf(a, out=(dummy, a)), 0) + with assert_raises(TypeError): + # Out argument must be tuple, since there are multiple outputs + np.modf(dummy, out=a) + + assert_raises(ValueError, np.modf, dummy, out=(a,)) + + # 2 inputs, 1 output + assert_equal(np.add(a, dummy), 0) + assert_equal(np.add(dummy, a), 1) + assert_equal(np.add(dummy, dummy, a), (0,)) + assert_equal(np.add(dummy, a, a), 1) + assert_equal(np.add(dummy, dummy, out=a), (0,)) + assert_equal(np.add(dummy, dummy, out=(a,)), (0,)) + assert_equal(np.add(a, dummy, out=a), 0) + + def test_out_override(self): + # regression test for github bug 4753 + class OutClass(np.ndarray): + def __array_ufunc__(self, ufunc, method, *inputs, **kw): + if 'out' in kw: + tmp_kw = kw.copy() + tmp_kw.pop('out') + func = getattr(ufunc, method) + kw['out'][0][...] = func(*inputs, **tmp_kw) + + A = np.array([0]).view(OutClass) + B = np.array([5]) + C = np.array([6]) + np.multiply(C, B, A) + assert_equal(A[0], 30) + assert_(isinstance(A, OutClass)) + A[0] = 0 + np.multiply(C, B, out=A) + assert_equal(A[0], 30) + assert_(isinstance(A, OutClass)) + + def test_pow_override_with_errors(self): + # regression test for gh-9112 + class PowerOnly(np.ndarray): + def __array_ufunc__(self, ufunc, method, *inputs, **kw): + if ufunc is not np.power: + raise NotImplementedError + return "POWER!" + # explicit cast to float, to ensure the fast power path is taken. + a = np.array(5., dtype=np.float64).view(PowerOnly) + assert_equal(a ** 2.5, "POWER!") + with assert_raises(NotImplementedError): + a ** 0.5 + with assert_raises(NotImplementedError): + a ** 0 + with assert_raises(NotImplementedError): + a ** 1 + with assert_raises(NotImplementedError): + a ** -1 + with assert_raises(NotImplementedError): + a ** 2 + + def test_pow_array_object_dtype(self): + # test pow on arrays of object dtype + class SomeClass: + def __init__(self, num=None): + self.num = num + + # want to ensure a fast pow path is not taken + def __mul__(self, other): + raise AssertionError('__mul__ should not be called') + + def __div__(self, other): + raise AssertionError('__div__ should not be called') + + def __pow__(self, exp): + return SomeClass(num=self.num ** exp) + + def __eq__(self, other): + if isinstance(other, SomeClass): + return self.num == other.num + + __rpow__ = __pow__ + + def pow_for(exp, arr): + return np.array([x ** exp for x in arr]) + + obj_arr = np.array([SomeClass(1), SomeClass(2), SomeClass(3)]) + + assert_equal(obj_arr ** 0.5, pow_for(0.5, obj_arr)) + assert_equal(obj_arr ** 0, pow_for(0, obj_arr)) + assert_equal(obj_arr ** 1, pow_for(1, obj_arr)) + assert_equal(obj_arr ** -1, pow_for(-1, obj_arr)) + assert_equal(obj_arr ** 2, pow_for(2, obj_arr)) + + def test_pos_array_ufunc_override(self): + class A(np.ndarray): + def __array_ufunc__(self, ufunc, method, *inputs, **kwargs): + return getattr(ufunc, method)(*[i.view(np.ndarray) for + i in inputs], **kwargs) + tst = np.array('foo').view(A) + with assert_raises(TypeError): + +tst + + +class TestTemporaryElide: + # elision is only triggered on relatively large arrays + + def test_extension_incref_elide(self): + # test extension (e.g. cython) calling PyNumber_* slots without + # increasing the reference counts + # + # def incref_elide(a): + # d = input.copy() # refcount 1 + # return d, d + d # PyNumber_Add without increasing refcount + from numpy._core._multiarray_tests import incref_elide + d = np.ones(100000) + orig, res = incref_elide(d) + d + d + # the return original should not be changed to an inplace operation + assert_array_equal(orig, d) + assert_array_equal(res, d + d) + + def test_extension_incref_elide_stack(self): + # scanning if the refcount == 1 object is on the python stack to check + # that we are called directly from python is flawed as object may still + # be above the stack pointer and we have no access to the top of it + # + # def incref_elide_l(d): + # return l[4] + l[4] # PyNumber_Add without increasing refcount + from numpy._core._multiarray_tests import incref_elide_l + # padding with 1 makes sure the object on the stack is not overwritten + l = [1, 1, 1, 1, np.ones(100000)] + res = incref_elide_l(l) + # the return original should not be changed to an inplace operation + assert_array_equal(l[4], np.ones(100000)) + assert_array_equal(res, l[4] + l[4]) + + def test_temporary_with_cast(self): + # check that we don't elide into a temporary which would need casting + d = np.ones(200000, dtype=np.int64) + r = ((d + d) + np.array(2**222, dtype='O')) + assert_equal(r.dtype, np.dtype('O')) + + r = ((d + d) / 2) + assert_equal(r.dtype, np.dtype('f8')) + + r = np.true_divide((d + d), 2) + assert_equal(r.dtype, np.dtype('f8')) + + r = ((d + d) / 2.) + assert_equal(r.dtype, np.dtype('f8')) + + r = ((d + d) // 2) + assert_equal(r.dtype, np.dtype(np.int64)) + + # commutative elision into the astype result + f = np.ones(100000, dtype=np.float32) + assert_equal(((f + f) + f.astype(np.float64)).dtype, np.dtype('f8')) + + # no elision into lower type + d = f.astype(np.float64) + assert_equal(((f + f) + d).dtype, d.dtype) + l = np.ones(100000, dtype=np.longdouble) + assert_equal(((d + d) + l).dtype, l.dtype) + + # test unary abs with different output dtype + for dt in (np.complex64, np.complex128, np.clongdouble): + c = np.ones(100000, dtype=dt) + r = abs(c * 2.0) + assert_equal(r.dtype, np.dtype('f%d' % (c.itemsize // 2))) + + def test_elide_broadcast(self): + # test no elision on broadcast to higher dimension + # only triggers elision code path in debug mode as triggering it in + # normal mode needs 256kb large matching dimension, so a lot of memory + d = np.ones((2000, 1), dtype=int) + b = np.ones((2000), dtype=bool) + r = (1 - d) + b + assert_equal(r, 1) + assert_equal(r.shape, (2000, 2000)) + + def test_elide_scalar(self): + # check inplace op does not create ndarray from scalars + a = np.bool() + assert_(type(~(a & a)) is np.bool) + + def test_elide_scalar_readonly(self): + # The imaginary part of a real array is readonly. This needs to go + # through fast_scalar_power which is only called for powers of + # +1, -1, 0, 0.5, and 2, so use 2. Also need valid refcount for + # elision which can be gotten for the imaginary part of a real + # array. Should not error. + a = np.empty(100000, dtype=np.float64) + a.imag ** 2 + + def test_elide_readonly(self): + # don't try to elide readonly temporaries + r = np.asarray(np.broadcast_to(np.zeros(1), 100000).flat) * 0.0 + assert_equal(r, 0) + + def test_elide_updateifcopy(self): + a = np.ones(2**20)[::2] + b = a.flat.__array__() + 1 + del b + assert_equal(a, 1) + + +class TestCAPI: + def test_IsPythonScalar(self): + from numpy._core._multiarray_tests import IsPythonScalar + assert_(IsPythonScalar(b'foobar')) + assert_(IsPythonScalar(1)) + assert_(IsPythonScalar(2**80)) + assert_(IsPythonScalar(2.)) + assert_(IsPythonScalar("a")) + + @pytest.mark.parametrize("converter", + [_multiarray_tests.run_scalar_intp_converter, + _multiarray_tests.run_scalar_intp_from_sequence]) + def test_intp_sequence_converters(self, converter): + # Test simple values (-1 is special for error return paths) + assert converter(10) == (10,) + assert converter(-1) == (-1,) + # A 0-D array looks a bit like a sequence but must take the integer + # path: + assert converter(np.array(123)) == (123,) + # Test simple sequences (intp_from_sequence only supports length 1): + assert converter((10,)) == (10,) + assert converter(np.array([11])) == (11,) + + @pytest.mark.parametrize("converter", + [_multiarray_tests.run_scalar_intp_converter, + _multiarray_tests.run_scalar_intp_from_sequence]) + @pytest.mark.skipif(IS_PYPY and sys.implementation.version <= (7, 3, 8), + reason="PyPy bug in error formatting") + def test_intp_sequence_converters_errors(self, converter): + with pytest.raises(TypeError, + match="expected a sequence of integers or a single integer, "): + converter(object()) + with pytest.raises(TypeError, + match="expected a sequence of integers or a single integer, " + "got '32.0'"): + converter(32.) + with pytest.raises(TypeError, + match="'float' object cannot be interpreted as an integer"): + converter([32.]) + with pytest.raises(ValueError, + match="Maximum allowed dimension"): + # These converters currently convert overflows to a ValueError + converter(2**64) + + +class TestSubscripting: + def test_test_zero_rank(self): + x = np.array([1, 2, 3]) + assert_(isinstance(x[0], np.int_)) + assert_(type(x[0, ...]) is np.ndarray) + + +class TestPickling: + @pytest.mark.skipif(pickle.HIGHEST_PROTOCOL >= 5, + reason=('this tests the error messages when trying to' + 'protocol 5 although it is not available')) + def test_correct_protocol5_error_message(self): + array = np.arange(10) + + def test_record_array_with_object_dtype(self): + my_object = object() + + arr_with_object = np.array( + [(my_object, 1, 2.0)], + dtype=[('a', object), ('b', int), ('c', float)]) + arr_without_object = np.array( + [('xxx', 1, 2.0)], + dtype=[('a', str), ('b', int), ('c', float)]) + + for proto in range(2, pickle.HIGHEST_PROTOCOL + 1): + depickled_arr_with_object = pickle.loads( + pickle.dumps(arr_with_object, protocol=proto)) + depickled_arr_without_object = pickle.loads( + pickle.dumps(arr_without_object, protocol=proto)) + + assert_equal(arr_with_object.dtype, + depickled_arr_with_object.dtype) + assert_equal(arr_without_object.dtype, + depickled_arr_without_object.dtype) + + @pytest.mark.skipif(pickle.HIGHEST_PROTOCOL < 5, + reason="requires pickle protocol 5") + def test_f_contiguous_array(self): + f_contiguous_array = np.array([[1, 2, 3], [4, 5, 6]], order='F') + buffers = [] + + # When using pickle protocol 5, Fortran-contiguous arrays can be + # serialized using out-of-band buffers + bytes_string = pickle.dumps(f_contiguous_array, protocol=5, + buffer_callback=buffers.append) + + assert len(buffers) > 0 + + depickled_f_contiguous_array = pickle.loads(bytes_string, + buffers=buffers) + + assert_equal(f_contiguous_array, depickled_f_contiguous_array) + + def test_non_contiguous_array(self): + non_contiguous_array = np.arange(12).reshape(3, 4)[:, :2] + assert not non_contiguous_array.flags.c_contiguous + assert not non_contiguous_array.flags.f_contiguous + + # make sure non-contiguous arrays can be pickled-depickled + # using any protocol + for proto in range(2, pickle.HIGHEST_PROTOCOL + 1): + depickled_non_contiguous_array = pickle.loads( + pickle.dumps(non_contiguous_array, protocol=proto)) + + assert_equal(non_contiguous_array, depickled_non_contiguous_array) + + def test_roundtrip(self): + for proto in range(2, pickle.HIGHEST_PROTOCOL + 1): + carray = np.array([[2, 9], [7, 0], [3, 8]]) + DATA = [ + carray, + np.transpose(carray), + np.array([('xxx', 1, 2.0)], dtype=[('a', (str, 3)), ('b', int), + ('c', float)]) + ] + + refs = [weakref.ref(a) for a in DATA] + for a in DATA: + assert_equal( + a, pickle.loads(pickle.dumps(a, protocol=proto)), + err_msg="%r" % a) + del a, DATA, carray + break_cycles() + # check for reference leaks (gh-12793) + for ref in refs: + assert ref() is None + + def _loads(self, obj): + return pickle.loads(obj, encoding='latin1') + + # version 0 pickles, using protocol=2 to pickle + # version 0 doesn't have a version field + def test_version0_int8(self): + s = b"\x80\x02cnumpy.core._internal\n_reconstruct\nq\x01cnumpy\nndarray\nq\x02K\x00\x85U\x01b\x87Rq\x03(K\x04\x85cnumpy\ndtype\nq\x04U\x02i1K\x00K\x01\x87Rq\x05(U\x01|NNJ\xff\xff\xff\xffJ\xff\xff\xff\xfftb\x89U\x04\x01\x02\x03\x04tb." # noqa + a = np.array([1, 2, 3, 4], dtype=np.int8) + p = self._loads(s) + assert_equal(a, p) + + def test_version0_float32(self): + s = b"\x80\x02cnumpy.core._internal\n_reconstruct\nq\x01cnumpy\nndarray\nq\x02K\x00\x85U\x01b\x87Rq\x03(K\x04\x85cnumpy\ndtype\nq\x04U\x02f4K\x00K\x01\x87Rq\x05(U\x01= g2, [g1[i] >= g2[i] for i in [0, 1, 2]]) + assert_array_equal(g1 < g2, [g1[i] < g2[i] for i in [0, 1, 2]]) + assert_array_equal(g1 > g2, [g1[i] > g2[i] for i in [0, 1, 2]]) + + def test_mixed(self): + g1 = np.array(["spam", "spa", "spammer", "and eggs"]) + g2 = "spam" + assert_array_equal(g1 == g2, [x == g2 for x in g1]) + assert_array_equal(g1 != g2, [x != g2 for x in g1]) + assert_array_equal(g1 < g2, [x < g2 for x in g1]) + assert_array_equal(g1 > g2, [x > g2 for x in g1]) + assert_array_equal(g1 <= g2, [x <= g2 for x in g1]) + assert_array_equal(g1 >= g2, [x >= g2 for x in g1]) + + def test_unicode(self): + g1 = np.array(["This", "is", "example"]) + g2 = np.array(["This", "was", "example"]) + assert_array_equal(g1 == g2, [g1[i] == g2[i] for i in [0, 1, 2]]) + assert_array_equal(g1 != g2, [g1[i] != g2[i] for i in [0, 1, 2]]) + assert_array_equal(g1 <= g2, [g1[i] <= g2[i] for i in [0, 1, 2]]) + assert_array_equal(g1 >= g2, [g1[i] >= g2[i] for i in [0, 1, 2]]) + assert_array_equal(g1 < g2, [g1[i] < g2[i] for i in [0, 1, 2]]) + assert_array_equal(g1 > g2, [g1[i] > g2[i] for i in [0, 1, 2]]) + +class TestArgmaxArgminCommon: + + sizes = [(), (3,), (3, 2), (2, 3), + (3, 3), (2, 3, 4), (4, 3, 2), + (1, 2, 3, 4), (2, 3, 4, 1), + (3, 4, 1, 2), (4, 1, 2, 3), + (64,), (128,), (256,)] + + @pytest.mark.parametrize("size, axis", itertools.chain(*[[(size, axis) + for axis in list(range(-len(size), len(size))) + [None]] + for size in sizes])) + @pytest.mark.parametrize('method', [np.argmax, np.argmin]) + def test_np_argmin_argmax_keepdims(self, size, axis, method): + + arr = np.random.normal(size=size) + + # contiguous arrays + if axis is None: + new_shape = [1 for _ in range(len(size))] + else: + new_shape = list(size) + new_shape[axis] = 1 + new_shape = tuple(new_shape) + + _res_orig = method(arr, axis=axis) + res_orig = _res_orig.reshape(new_shape) + res = method(arr, axis=axis, keepdims=True) + assert_equal(res, res_orig) + assert_(res.shape == new_shape) + outarray = np.empty(res.shape, dtype=res.dtype) + res1 = method(arr, axis=axis, out=outarray, + keepdims=True) + assert_(res1 is outarray) + assert_equal(res, outarray) + + if len(size) > 0: + wrong_shape = list(new_shape) + if axis is not None: + wrong_shape[axis] = 2 + else: + wrong_shape[0] = 2 + wrong_outarray = np.empty(wrong_shape, dtype=res.dtype) + with pytest.raises(ValueError): + method(arr.T, axis=axis, + out=wrong_outarray, keepdims=True) + + # non-contiguous arrays + if axis is None: + new_shape = [1 for _ in range(len(size))] + else: + new_shape = list(size)[::-1] + new_shape[axis] = 1 + new_shape = tuple(new_shape) + + _res_orig = method(arr.T, axis=axis) + res_orig = _res_orig.reshape(new_shape) + res = method(arr.T, axis=axis, keepdims=True) + assert_equal(res, res_orig) + assert_(res.shape == new_shape) + outarray = np.empty(new_shape[::-1], dtype=res.dtype) + outarray = outarray.T + res1 = method(arr.T, axis=axis, out=outarray, + keepdims=True) + assert_(res1 is outarray) + assert_equal(res, outarray) + + if len(size) > 0: + # one dimension lesser for non-zero sized + # array should raise an error + with pytest.raises(ValueError): + method(arr[0], axis=axis, + out=outarray, keepdims=True) + + if len(size) > 0: + wrong_shape = list(new_shape) + if axis is not None: + wrong_shape[axis] = 2 + else: + wrong_shape[0] = 2 + wrong_outarray = np.empty(wrong_shape, dtype=res.dtype) + with pytest.raises(ValueError): + method(arr.T, axis=axis, + out=wrong_outarray, keepdims=True) + + @pytest.mark.parametrize('method', ['max', 'min']) + def test_all(self, method): + a = np.random.normal(0, 1, (4, 5, 6, 7, 8)) + arg_method = getattr(a, 'arg' + method) + val_method = getattr(a, method) + for i in range(a.ndim): + a_maxmin = val_method(i) + aarg_maxmin = arg_method(i) + axes = list(range(a.ndim)) + axes.remove(i) + assert_(np.all(a_maxmin == aarg_maxmin.choose( + *a.transpose(i, *axes)))) + + @pytest.mark.parametrize('method', ['argmax', 'argmin']) + def test_output_shape(self, method): + # see also gh-616 + a = np.ones((10, 5)) + arg_method = getattr(a, method) + # Check some simple shape mismatches + out = np.ones(11, dtype=np.int_) + assert_raises(ValueError, arg_method, -1, out) + + out = np.ones((2, 5), dtype=np.int_) + assert_raises(ValueError, arg_method, -1, out) + + # these could be relaxed possibly (used to allow even the previous) + out = np.ones((1, 10), dtype=np.int_) + assert_raises(ValueError, arg_method, -1, out) + + out = np.ones(10, dtype=np.int_) + arg_method(-1, out=out) + assert_equal(out, arg_method(-1)) + + @pytest.mark.parametrize('ndim', [0, 1]) + @pytest.mark.parametrize('method', ['argmax', 'argmin']) + def test_ret_is_out(self, ndim, method): + a = np.ones((4,) + (256,)*ndim) + arg_method = getattr(a, method) + out = np.empty((256,)*ndim, dtype=np.intp) + ret = arg_method(axis=0, out=out) + assert ret is out + + @pytest.mark.parametrize('np_array, method, idx, val', + [(np.zeros, 'argmax', 5942, "as"), + (np.ones, 'argmin', 6001, "0")]) + def test_unicode(self, np_array, method, idx, val): + d = np_array(6031, dtype='= cmin)) + assert_(np.all(x <= cmax)) + + def _clip_type(self, type_group, array_max, + clip_min, clip_max, inplace=False, + expected_min=None, expected_max=None): + if expected_min is None: + expected_min = clip_min + if expected_max is None: + expected_max = clip_max + + for T in np._core.sctypes[type_group]: + if sys.byteorder == 'little': + byte_orders = ['=', '>'] + else: + byte_orders = ['<', '='] + + for byteorder in byte_orders: + dtype = np.dtype(T).newbyteorder(byteorder) + + x = (np.random.random(1000) * array_max).astype(dtype) + if inplace: + # The tests that call us pass clip_min and clip_max that + # might not fit in the destination dtype. They were written + # assuming the previous unsafe casting, which now must be + # passed explicitly to avoid a warning. + x.clip(clip_min, clip_max, x, casting='unsafe') + else: + x = x.clip(clip_min, clip_max) + byteorder = '=' + + if x.dtype.byteorder == '|': + byteorder = '|' + assert_equal(x.dtype.byteorder, byteorder) + self._check_range(x, expected_min, expected_max) + return x + + def test_basic(self): + for inplace in [False, True]: + self._clip_type( + 'float', 1024, -12.8, 100.2, inplace=inplace) + self._clip_type( + 'float', 1024, 0, 0, inplace=inplace) + + self._clip_type( + 'int', 1024, -120, 100, inplace=inplace) + self._clip_type( + 'int', 1024, 0, 0, inplace=inplace) + + self._clip_type( + 'uint', 1024, 0, 0, inplace=inplace) + self._clip_type( + 'uint', 1024, 10, 100, inplace=inplace) + + @pytest.mark.parametrize("inplace", [False, True]) + def test_int_out_of_range(self, inplace): + # Simple check for out-of-bound integers, also testing the in-place + # path. + x = (np.random.random(1000) * 255).astype("uint8") + out = np.empty_like(x) + res = x.clip(-1, 300, out=out if inplace else None) + assert res is out or not inplace + assert (res == x).all() + + res = x.clip(-1, 50, out=out if inplace else None) + assert res is out or not inplace + assert (res <= 50).all() + assert (res[x <= 50] == x[x <= 50]).all() + + res = x.clip(100, 1000, out=out if inplace else None) + assert res is out or not inplace + assert (res >= 100).all() + assert (res[x >= 100] == x[x >= 100]).all() + + def test_record_array(self): + rec = np.array([(-5, 2.0, 3.0), (5.0, 4.0, 3.0)], + dtype=[('x', '= 3)) + x = val.clip(min=3) + assert_(np.all(x >= 3)) + x = val.clip(max=4) + assert_(np.all(x <= 4)) + + def test_nan(self): + input_arr = np.array([-2., np.nan, 0.5, 3., 0.25, np.nan]) + result = input_arr.clip(-1, 1) + expected = np.array([-1., np.nan, 0.5, 1., 0.25, np.nan]) + assert_array_equal(result, expected) + + +class TestCompress: + def test_axis(self): + tgt = [[5, 6, 7, 8, 9]] + arr = np.arange(10).reshape(2, 5) + out = np.compress([0, 1], arr, axis=0) + assert_equal(out, tgt) + + tgt = [[1, 3], [6, 8]] + out = np.compress([0, 1, 0, 1, 0], arr, axis=1) + assert_equal(out, tgt) + + def test_truncate(self): + tgt = [[1], [6]] + arr = np.arange(10).reshape(2, 5) + out = np.compress([0, 1], arr, axis=1) + assert_equal(out, tgt) + + def test_flatten(self): + arr = np.arange(10).reshape(2, 5) + out = np.compress([0, 1], arr) + assert_equal(out, 1) + + +class TestPutmask: + def tst_basic(self, x, T, mask, val): + np.putmask(x, mask, val) + assert_equal(x[mask], np.array(val, T)) + + def test_ip_types(self): + unchecked_types = [bytes, str, np.void] + + x = np.random.random(1000)*100 + mask = x < 40 + + for val in [-100, 0, 15]: + for types in np._core.sctypes.values(): + for T in types: + if T not in unchecked_types: + if val < 0 and np.dtype(T).kind == "u": + val = np.iinfo(T).max - 99 + self.tst_basic(x.copy().astype(T), T, mask, val) + + # Also test string of a length which uses an untypical length + dt = np.dtype("S3") + self.tst_basic(x.astype(dt), dt.type, mask, dt.type(val)[:3]) + + def test_mask_size(self): + assert_raises(ValueError, np.putmask, np.array([1, 2, 3]), [True], 5) + + @pytest.mark.parametrize('dtype', ('>i4', 'f8'), ('z', '= 2, 3) + + def test_kwargs(self): + x = np.array([0, 0]) + np.putmask(x, [0, 1], [-1, -2]) + assert_array_equal(x, [0, -2]) + + x = np.array([0, 0]) + np.putmask(x, mask=[0, 1], values=[-1, -2]) + assert_array_equal(x, [0, -2]) + + x = np.array([0, 0]) + np.putmask(x, values=[-1, -2], mask=[0, 1]) + assert_array_equal(x, [0, -2]) + + with pytest.raises(TypeError): + np.putmask(a=x, values=[-1, -2], mask=[0, 1]) + + +class TestTake: + def tst_basic(self, x): + ind = list(range(x.shape[0])) + assert_array_equal(x.take(ind, axis=0), x) + + def test_ip_types(self): + unchecked_types = [bytes, str, np.void] + + x = np.random.random(24)*100 + x.shape = 2, 3, 4 + for types in np._core.sctypes.values(): + for T in types: + if T not in unchecked_types: + self.tst_basic(x.copy().astype(T)) + + # Also test string of a length which uses an untypical length + self.tst_basic(x.astype("S3")) + + def test_raise(self): + x = np.random.random(24)*100 + x.shape = 2, 3, 4 + assert_raises(IndexError, x.take, [0, 1, 2], axis=0) + assert_raises(IndexError, x.take, [-3], axis=0) + assert_array_equal(x.take([-1], axis=0)[0], x[1]) + + def test_clip(self): + x = np.random.random(24)*100 + x.shape = 2, 3, 4 + assert_array_equal(x.take([-1], axis=0, mode='clip')[0], x[0]) + assert_array_equal(x.take([2], axis=0, mode='clip')[0], x[1]) + + def test_wrap(self): + x = np.random.random(24)*100 + x.shape = 2, 3, 4 + assert_array_equal(x.take([-1], axis=0, mode='wrap')[0], x[1]) + assert_array_equal(x.take([2], axis=0, mode='wrap')[0], x[0]) + assert_array_equal(x.take([3], axis=0, mode='wrap')[0], x[1]) + + @pytest.mark.parametrize('dtype', ('>i4', 'f8'), ('z', ' 16MB + d = np.zeros(4 * 1024 ** 2) + d.tofile(tmp_filename) + assert_equal(os.path.getsize(tmp_filename), d.nbytes) + assert_array_equal(d, np.fromfile(tmp_filename)) + # check offset + with open(tmp_filename, "r+b") as f: + f.seek(d.nbytes) + d.tofile(f) + assert_equal(os.path.getsize(tmp_filename), d.nbytes * 2) + # check append mode (gh-8329) + open(tmp_filename, "w").close() # delete file contents + with open(tmp_filename, "ab") as f: + d.tofile(f) + assert_array_equal(d, np.fromfile(tmp_filename)) + with open(tmp_filename, "ab") as f: + d.tofile(f) + assert_equal(os.path.getsize(tmp_filename), d.nbytes * 2) + + def test_io_open_buffered_fromfile(self, x, tmp_filename): + # gh-6632 + x.tofile(tmp_filename) + with open(tmp_filename, 'rb', buffering=-1) as f: + y = np.fromfile(f, dtype=x.dtype) + assert_array_equal(y, x.flat) + + def test_file_position_after_fromfile(self, tmp_filename): + # gh-4118 + sizes = [io.DEFAULT_BUFFER_SIZE//8, + io.DEFAULT_BUFFER_SIZE, + io.DEFAULT_BUFFER_SIZE*8] + + for size in sizes: + with open(tmp_filename, 'wb') as f: + f.seek(size-1) + f.write(b'\0') + + for mode in ['rb', 'r+b']: + err_msg = "%d %s" % (size, mode) + + with open(tmp_filename, mode) as f: + f.read(2) + np.fromfile(f, dtype=np.float64, count=1) + pos = f.tell() + assert_equal(pos, 10, err_msg=err_msg) + + def test_file_position_after_tofile(self, tmp_filename): + # gh-4118 + sizes = [io.DEFAULT_BUFFER_SIZE//8, + io.DEFAULT_BUFFER_SIZE, + io.DEFAULT_BUFFER_SIZE*8] + + for size in sizes: + err_msg = "%d" % (size,) + + with open(tmp_filename, 'wb') as f: + f.seek(size-1) + f.write(b'\0') + f.seek(10) + f.write(b'12') + np.array([0], dtype=np.float64).tofile(f) + pos = f.tell() + assert_equal(pos, 10 + 2 + 8, err_msg=err_msg) + + with open(tmp_filename, 'r+b') as f: + f.read(2) + f.seek(0, 1) # seek between read&write required by ANSI C + np.array([0], dtype=np.float64).tofile(f) + pos = f.tell() + assert_equal(pos, 10, err_msg=err_msg) + + def test_load_object_array_fromfile(self, tmp_filename): + # gh-12300 + with open(tmp_filename, 'w') as f: + # Ensure we have a file with consistent contents + pass + + with open(tmp_filename, 'rb') as f: + assert_raises_regex(ValueError, "Cannot read into object array", + np.fromfile, f, dtype=object) + + assert_raises_regex(ValueError, "Cannot read into object array", + np.fromfile, tmp_filename, dtype=object) + + def test_fromfile_offset(self, x, tmp_filename): + with open(tmp_filename, 'wb') as f: + x.tofile(f) + + with open(tmp_filename, 'rb') as f: + y = np.fromfile(f, dtype=x.dtype, offset=0) + assert_array_equal(y, x.flat) + + with open(tmp_filename, 'rb') as f: + count_items = len(x.flat) // 8 + offset_items = len(x.flat) // 4 + offset_bytes = x.dtype.itemsize * offset_items + y = np.fromfile( + f, dtype=x.dtype, count=count_items, offset=offset_bytes + ) + assert_array_equal( + y, x.flat[offset_items:offset_items+count_items] + ) + + # subsequent seeks should stack + offset_bytes = x.dtype.itemsize + z = np.fromfile(f, dtype=x.dtype, offset=offset_bytes) + assert_array_equal(z, x.flat[offset_items+count_items+1:]) + + with open(tmp_filename, 'wb') as f: + x.tofile(f, sep=",") + + with open(tmp_filename, 'rb') as f: + assert_raises_regex( + TypeError, + "'offset' argument only permitted for binary files", + np.fromfile, tmp_filename, dtype=x.dtype, + sep=",", offset=1) + + @pytest.mark.skipif(IS_PYPY, reason="bug in PyPy's PyNumber_AsSsize_t") + def test_fromfile_bad_dup(self, x, tmp_filename): + def dup_str(fd): + return 'abc' + + def dup_bigint(fd): + return 2**68 + + old_dup = os.dup + try: + with open(tmp_filename, 'wb') as f: + x.tofile(f) + for dup, exc in ((dup_str, TypeError), (dup_bigint, OSError)): + os.dup = dup + assert_raises(exc, np.fromfile, f) + finally: + os.dup = old_dup + + def _check_from(self, s, value, filename, **kw): + if 'sep' not in kw: + y = np.frombuffer(s, **kw) + else: + y = np.fromstring(s, **kw) + assert_array_equal(y, value) + + with open(filename, 'wb') as f: + f.write(s) + y = np.fromfile(filename, **kw) + assert_array_equal(y, value) + + @pytest.fixture(params=["period", "comma"]) + def decimal_sep_localization(self, request): + """ + Including this fixture in a test will automatically + execute it with both types of decimal separator. + + So:: + + def test_decimal(decimal_sep_localization): + pass + + is equivalent to the following two tests:: + + def test_decimal_period_separator(): + pass + + def test_decimal_comma_separator(): + with CommaDecimalPointLocale(): + pass + """ + if request.param == "period": + yield + elif request.param == "comma": + with CommaDecimalPointLocale(): + yield + else: + assert False, request.param + + def test_nan(self, tmp_filename, decimal_sep_localization): + self._check_from( + b"nan +nan -nan NaN nan(foo) +NaN(BAR) -NAN(q_u_u_x_)", + [np.nan, np.nan, np.nan, np.nan, np.nan, np.nan, np.nan], + tmp_filename, + sep=' ') + + def test_inf(self, tmp_filename, decimal_sep_localization): + self._check_from( + b"inf +inf -inf infinity -Infinity iNfInItY -inF", + [np.inf, np.inf, -np.inf, np.inf, -np.inf, np.inf, -np.inf], + tmp_filename, + sep=' ') + + def test_numbers(self, tmp_filename, decimal_sep_localization): + self._check_from( + b"1.234 -1.234 .3 .3e55 -123133.1231e+133", + [1.234, -1.234, .3, .3e55, -123133.1231e+133], + tmp_filename, + sep=' ') + + def test_binary(self, tmp_filename): + self._check_from( + b'\x00\x00\x80?\x00\x00\x00@\x00\x00@@\x00\x00\x80@', + np.array([1, 2, 3, 4]), + tmp_filename, + dtype='']) + @pytest.mark.parametrize('dtype', [float, int, complex]) + def test_basic(self, byteorder, dtype): + dt = np.dtype(dtype).newbyteorder(byteorder) + x = (np.random.random((4, 7)) * 5).astype(dt) + buf = x.tobytes() + assert_array_equal(np.frombuffer(buf, dtype=dt), x.flat) + + @pytest.mark.parametrize("obj", [np.arange(10), b"12345678"]) + def test_array_base(self, obj): + # Objects (including NumPy arrays), which do not use the + # `release_buffer` slot should be directly used as a base object. + # See also gh-21612 + new = np.frombuffer(obj) + assert new.base is obj + + def test_empty(self): + assert_array_equal(np.frombuffer(b''), np.array([])) + + @pytest.mark.skipif(IS_PYPY, + reason="PyPy's memoryview currently does not track exports. See: " + "https://foss.heptapod.net/pypy/pypy/-/issues/3724") + def test_mmap_close(self): + # The old buffer protocol was not safe for some things that the new + # one is. But `frombuffer` always used the old one for a long time. + # Checks that it is safe with the new one (using memoryviews) + with tempfile.TemporaryFile(mode='wb') as tmp: + tmp.write(b"asdf") + tmp.flush() + mm = mmap.mmap(tmp.fileno(), 0) + arr = np.frombuffer(mm, dtype=np.uint8) + with pytest.raises(BufferError): + mm.close() # cannot close while array uses the buffer + del arr + mm.close() + +class TestFlat: + def setup_method(self): + a0 = np.arange(20.0) + a = a0.reshape(4, 5) + a0.shape = (4, 5) + a.flags.writeable = False + self.a = a + self.b = a[::2, ::2] + self.a0 = a0 + self.b0 = a0[::2, ::2] + + def test_contiguous(self): + testpassed = False + try: + self.a.flat[12] = 100.0 + except ValueError: + testpassed = True + assert_(testpassed) + assert_(self.a.flat[12] == 12.0) + + def test_discontiguous(self): + testpassed = False + try: + self.b.flat[4] = 100.0 + except ValueError: + testpassed = True + assert_(testpassed) + assert_(self.b.flat[4] == 12.0) + + def test___array__(self): + c = self.a.flat.__array__() + d = self.b.flat.__array__() + e = self.a0.flat.__array__() + f = self.b0.flat.__array__() + + assert_(c.flags.writeable is False) + assert_(d.flags.writeable is False) + assert_(e.flags.writeable is True) + assert_(f.flags.writeable is False) + assert_(c.flags.writebackifcopy is False) + assert_(d.flags.writebackifcopy is False) + assert_(e.flags.writebackifcopy is False) + assert_(f.flags.writebackifcopy is False) + + @pytest.mark.skipif(not HAS_REFCOUNT, reason="Python lacks refcounts") + def test_refcount(self): + # includes regression test for reference count error gh-13165 + inds = [np.intp(0), np.array([True]*self.a.size), np.array([0]), None] + indtype = np.dtype(np.intp) + rc_indtype = sys.getrefcount(indtype) + for ind in inds: + rc_ind = sys.getrefcount(ind) + for _ in range(100): + try: + self.a.flat[ind] + except IndexError: + pass + assert_(abs(sys.getrefcount(ind) - rc_ind) < 50) + assert_(abs(sys.getrefcount(indtype) - rc_indtype) < 50) + + def test_index_getset(self): + it = np.arange(10).reshape(2, 1, 5).flat + with pytest.raises(AttributeError): + it.index = 10 + + for _ in it: + pass + # Check the value of `.index` is updated correctly (see also gh-19153) + # If the type was incorrect, this would show up on big-endian machines + assert it.index == it.base.size + + def test_maxdims(self): + # The flat iterator and thus attribute is currently unfortunately + # limited to only 32 dimensions (after bumping it to 64 for 2.0) + a = np.ones((1,) * 64) + + with pytest.raises(RuntimeError, + match=".*32 dimensions but the array has 64"): + a.flat + + +class TestResize: + + @_no_tracing + def test_basic(self): + x = np.array([[1, 0, 0], [0, 1, 0], [0, 0, 1]]) + if IS_PYPY: + x.resize((5, 5), refcheck=False) + else: + x.resize((5, 5)) + assert_array_equal(x.flat[:9], + np.array([[1, 0, 0], [0, 1, 0], [0, 0, 1]]).flat) + assert_array_equal(x[9:].flat, 0) + + def test_check_reference(self): + x = np.array([[1, 0, 0], [0, 1, 0], [0, 0, 1]]) + y = x + assert_raises(ValueError, x.resize, (5, 1)) + del y # avoid pyflakes unused variable warning. + + @_no_tracing + def test_int_shape(self): + x = np.eye(3) + if IS_PYPY: + x.resize(3, refcheck=False) + else: + x.resize(3) + assert_array_equal(x, np.eye(3)[0,:]) + + def test_none_shape(self): + x = np.eye(3) + x.resize(None) + assert_array_equal(x, np.eye(3)) + x.resize() + assert_array_equal(x, np.eye(3)) + + def test_0d_shape(self): + # to it multiple times to test it does not break alloc cache gh-9216 + for i in range(10): + x = np.empty((1,)) + x.resize(()) + assert_equal(x.shape, ()) + assert_equal(x.size, 1) + x = np.empty(()) + x.resize((1,)) + assert_equal(x.shape, (1,)) + assert_equal(x.size, 1) + + def test_invalid_arguments(self): + assert_raises(TypeError, np.eye(3).resize, 'hi') + assert_raises(ValueError, np.eye(3).resize, -1) + assert_raises(TypeError, np.eye(3).resize, order=1) + assert_raises(TypeError, np.eye(3).resize, refcheck='hi') + + @_no_tracing + def test_freeform_shape(self): + x = np.eye(3) + if IS_PYPY: + x.resize(3, 2, 1, refcheck=False) + else: + x.resize(3, 2, 1) + assert_(x.shape == (3, 2, 1)) + + @_no_tracing + def test_zeros_appended(self): + x = np.eye(3) + if IS_PYPY: + x.resize(2, 3, 3, refcheck=False) + else: + x.resize(2, 3, 3) + assert_array_equal(x[0], np.eye(3)) + assert_array_equal(x[1], np.zeros((3, 3))) + + @_no_tracing + def test_obj_obj(self): + # check memory is initialized on resize, gh-4857 + a = np.ones(10, dtype=[('k', object, 2)]) + if IS_PYPY: + a.resize(15, refcheck=False) + else: + a.resize(15,) + assert_equal(a.shape, (15,)) + assert_array_equal(a['k'][-5:], 0) + assert_array_equal(a['k'][:-5], 1) + + def test_empty_view(self): + # check that sizes containing a zero don't trigger a reallocate for + # already empty arrays + x = np.zeros((10, 0), int) + x_view = x[...] + x_view.resize((0, 10)) + x_view.resize((0, 100)) + + def test_check_weakref(self): + x = np.array([[1, 0, 0], [0, 1, 0], [0, 0, 1]]) + xref = weakref.ref(x) + assert_raises(ValueError, x.resize, (5, 1)) + del xref # avoid pyflakes unused variable warning. + + +class TestRecord: + def test_field_rename(self): + dt = np.dtype([('f', float), ('i', int)]) + dt.names = ['p', 'q'] + assert_equal(dt.names, ['p', 'q']) + + def test_multiple_field_name_occurrence(self): + def test_dtype_init(): + np.dtype([("A", "f8"), ("B", "f8"), ("A", "f8")]) + + # Error raised when multiple fields have the same name + assert_raises(ValueError, test_dtype_init) + + def test_bytes_fields(self): + # Bytes are not allowed in field names and not recognized in titles + # on Py3 + assert_raises(TypeError, np.dtype, [(b'a', int)]) + assert_raises(TypeError, np.dtype, [(('b', b'a'), int)]) + + dt = np.dtype([((b'a', 'b'), int)]) + assert_raises(TypeError, dt.__getitem__, b'a') + + x = np.array([(1,), (2,), (3,)], dtype=dt) + assert_raises(IndexError, x.__getitem__, b'a') + + y = x[0] + assert_raises(IndexError, y.__getitem__, b'a') + + def test_multiple_field_name_unicode(self): + def test_dtype_unicode(): + np.dtype([("\u20B9", "f8"), ("B", "f8"), ("\u20B9", "f8")]) + + # Error raised when multiple fields have the same name(unicode included) + assert_raises(ValueError, test_dtype_unicode) + + def test_fromarrays_unicode(self): + # A single name string provided to fromarrays() is allowed to be unicode + # on both Python 2 and 3: + x = np._core.records.fromarrays( + [[0], [1]], names='a,b', formats='i4,i4') + assert_equal(x['a'][0], 0) + assert_equal(x['b'][0], 1) + + def test_unicode_order(self): + # Test that we can sort with order as a unicode field name in both Python 2 and + # 3: + name = 'b' + x = np.array([1, 3, 2], dtype=[(name, int)]) + x.sort(order=name) + assert_equal(x['b'], np.array([1, 2, 3])) + + def test_field_names(self): + # Test unicode and 8-bit / byte strings can be used + a = np.zeros((1,), dtype=[('f1', 'i4'), + ('f2', 'i4'), + ('f3', [('sf1', 'i4')])]) + # byte string indexing fails gracefully + assert_raises(IndexError, a.__setitem__, b'f1', 1) + assert_raises(IndexError, a.__getitem__, b'f1') + assert_raises(IndexError, a['f1'].__setitem__, b'sf1', 1) + assert_raises(IndexError, a['f1'].__getitem__, b'sf1') + b = a.copy() + fn1 = str('f1') + b[fn1] = 1 + assert_equal(b[fn1], 1) + fnn = str('not at all') + assert_raises(ValueError, b.__setitem__, fnn, 1) + assert_raises(ValueError, b.__getitem__, fnn) + b[0][fn1] = 2 + assert_equal(b[fn1], 2) + # Subfield + assert_raises(ValueError, b[0].__setitem__, fnn, 1) + assert_raises(ValueError, b[0].__getitem__, fnn) + # Subfield + fn3 = str('f3') + sfn1 = str('sf1') + b[fn3][sfn1] = 1 + assert_equal(b[fn3][sfn1], 1) + assert_raises(ValueError, b[fn3].__setitem__, fnn, 1) + assert_raises(ValueError, b[fn3].__getitem__, fnn) + # multiple subfields + fn2 = str('f2') + b[fn2] = 3 + + assert_equal(b[['f1', 'f2']][0].tolist(), (2, 3)) + assert_equal(b[['f2', 'f1']][0].tolist(), (3, 2)) + assert_equal(b[['f1', 'f3']][0].tolist(), (2, (1,))) + + # non-ascii unicode field indexing is well behaved + assert_raises(ValueError, a.__setitem__, '\u03e0', 1) + assert_raises(ValueError, a.__getitem__, '\u03e0') + + def test_record_hash(self): + a = np.array([(1, 2), (1, 2)], dtype='i1,i2') + a.flags.writeable = False + b = np.array([(1, 2), (3, 4)], dtype=[('num1', 'i1'), ('num2', 'i2')]) + b.flags.writeable = False + c = np.array([(1, 2), (3, 4)], dtype='i1,i2') + c.flags.writeable = False + assert_(hash(a[0]) == hash(a[1])) + assert_(hash(a[0]) == hash(b[0])) + assert_(hash(a[0]) != hash(b[1])) + assert_(hash(c[0]) == hash(a[0]) and c[0] == a[0]) + + def test_record_no_hash(self): + a = np.array([(1, 2), (1, 2)], dtype='i1,i2') + assert_raises(TypeError, hash, a[0]) + + def test_empty_structure_creation(self): + # make sure these do not raise errors (gh-5631) + np.array([()], dtype={'names': [], 'formats': [], + 'offsets': [], 'itemsize': 12}) + np.array([(), (), (), (), ()], dtype={'names': [], 'formats': [], + 'offsets': [], 'itemsize': 12}) + + def test_multifield_indexing_view(self): + a = np.ones(3, dtype=[('a', 'i4'), ('b', 'f4'), ('c', 'u4')]) + v = a[['a', 'c']] + assert_(v.base is a) + assert_(v.dtype == np.dtype({'names': ['a', 'c'], + 'formats': ['i4', 'u4'], + 'offsets': [0, 8]})) + v[:] = (4,5) + assert_equal(a[0].item(), (4, 1, 5)) + +class TestView: + def test_basic(self): + x = np.array([(1, 2, 3, 4), (5, 6, 7, 8)], + dtype=[('r', np.int8), ('g', np.int8), + ('b', np.int8), ('a', np.int8)]) + # We must be specific about the endianness here: + y = x.view(dtype=' 0) + assert_(issubclass(w[0].category, RuntimeWarning)) + + def test_empty(self): + A = np.zeros((0, 3)) + for f in self.funcs: + for axis in [0, None]: + with warnings.catch_warnings(record=True) as w: + warnings.simplefilter('always') + assert_(np.isnan(f(A, axis=axis)).all()) + assert_(len(w) > 0) + assert_(issubclass(w[0].category, RuntimeWarning)) + for axis in [1]: + with warnings.catch_warnings(record=True) as w: + warnings.simplefilter('always') + assert_equal(f(A, axis=axis), np.zeros([])) + + def test_mean_values(self): + for mat in [self.rmat, self.cmat, self.omat]: + for axis in [0, 1]: + tgt = mat.sum(axis=axis) + res = _mean(mat, axis=axis) * mat.shape[axis] + assert_almost_equal(res, tgt) + for axis in [None]: + tgt = mat.sum(axis=axis) + res = _mean(mat, axis=axis) * np.prod(mat.shape) + assert_almost_equal(res, tgt) + + def test_mean_float16(self): + # This fail if the sum inside mean is done in float16 instead + # of float32. + assert_(_mean(np.ones(100000, dtype='float16')) == 1) + + def test_mean_axis_error(self): + # Ensure that AxisError is raised instead of IndexError when axis is + # out of bounds, see gh-15817. + with assert_raises(np.exceptions.AxisError): + np.arange(10).mean(axis=2) + + def test_mean_where(self): + a = np.arange(16).reshape((4, 4)) + wh_full = np.array([[False, True, False, True], + [True, False, True, False], + [True, True, False, False], + [False, False, True, True]]) + wh_partial = np.array([[False], + [True], + [True], + [False]]) + _cases = [(1, True, [1.5, 5.5, 9.5, 13.5]), + (0, wh_full, [6., 5., 10., 9.]), + (1, wh_full, [2., 5., 8.5, 14.5]), + (0, wh_partial, [6., 7., 8., 9.])] + for _ax, _wh, _res in _cases: + assert_allclose(a.mean(axis=_ax, where=_wh), + np.array(_res)) + assert_allclose(np.mean(a, axis=_ax, where=_wh), + np.array(_res)) + + a3d = np.arange(16).reshape((2, 2, 4)) + _wh_partial = np.array([False, True, True, False]) + _res = [[1.5, 5.5], [9.5, 13.5]] + assert_allclose(a3d.mean(axis=2, where=_wh_partial), + np.array(_res)) + assert_allclose(np.mean(a3d, axis=2, where=_wh_partial), + np.array(_res)) + + with pytest.warns(RuntimeWarning) as w: + assert_allclose(a.mean(axis=1, where=wh_partial), + np.array([np.nan, 5.5, 9.5, np.nan])) + with pytest.warns(RuntimeWarning) as w: + assert_equal(a.mean(where=False), np.nan) + with pytest.warns(RuntimeWarning) as w: + assert_equal(np.mean(a, where=False), np.nan) + + def test_var_values(self): + for mat in [self.rmat, self.cmat, self.omat]: + for axis in [0, 1, None]: + msqr = _mean(mat * mat.conj(), axis=axis) + mean = _mean(mat, axis=axis) + tgt = msqr - mean * mean.conjugate() + res = _var(mat, axis=axis) + assert_almost_equal(res, tgt) + + @pytest.mark.parametrize(('complex_dtype', 'ndec'), ( + ('complex64', 6), + ('complex128', 7), + ('clongdouble', 7), + )) + def test_var_complex_values(self, complex_dtype, ndec): + # Test fast-paths for every builtin complex type + for axis in [0, 1, None]: + mat = self.cmat.copy().astype(complex_dtype) + msqr = _mean(mat * mat.conj(), axis=axis) + mean = _mean(mat, axis=axis) + tgt = msqr - mean * mean.conjugate() + res = _var(mat, axis=axis) + assert_almost_equal(res, tgt, decimal=ndec) + + def test_var_dimensions(self): + # _var paths for complex number introduce additions on views that + # increase dimensions. Ensure this generalizes to higher dims + mat = np.stack([self.cmat]*3) + for axis in [0, 1, 2, -1, None]: + msqr = _mean(mat * mat.conj(), axis=axis) + mean = _mean(mat, axis=axis) + tgt = msqr - mean * mean.conjugate() + res = _var(mat, axis=axis) + assert_almost_equal(res, tgt) + + def test_var_complex_byteorder(self): + # Test that var fast-path does not cause failures for complex arrays + # with non-native byteorder + cmat = self.cmat.copy().astype('complex128') + cmat_swapped = cmat.astype(cmat.dtype.newbyteorder()) + assert_almost_equal(cmat.var(), cmat_swapped.var()) + + def test_var_axis_error(self): + # Ensure that AxisError is raised instead of IndexError when axis is + # out of bounds, see gh-15817. + with assert_raises(np.exceptions.AxisError): + np.arange(10).var(axis=2) + + def test_var_where(self): + a = np.arange(25).reshape((5, 5)) + wh_full = np.array([[False, True, False, True, True], + [True, False, True, True, False], + [True, True, False, False, True], + [False, True, True, False, True], + [True, False, True, True, False]]) + wh_partial = np.array([[False], + [True], + [True], + [False], + [True]]) + _cases = [(0, True, [50., 50., 50., 50., 50.]), + (1, True, [2., 2., 2., 2., 2.])] + for _ax, _wh, _res in _cases: + assert_allclose(a.var(axis=_ax, where=_wh), + np.array(_res)) + assert_allclose(np.var(a, axis=_ax, where=_wh), + np.array(_res)) + + a3d = np.arange(16).reshape((2, 2, 4)) + _wh_partial = np.array([False, True, True, False]) + _res = [[0.25, 0.25], [0.25, 0.25]] + assert_allclose(a3d.var(axis=2, where=_wh_partial), + np.array(_res)) + assert_allclose(np.var(a3d, axis=2, where=_wh_partial), + np.array(_res)) + + assert_allclose(np.var(a, axis=1, where=wh_full), + np.var(a[wh_full].reshape((5, 3)), axis=1)) + assert_allclose(np.var(a, axis=0, where=wh_partial), + np.var(a[wh_partial[:,0]], axis=0)) + with pytest.warns(RuntimeWarning) as w: + assert_equal(a.var(where=False), np.nan) + with pytest.warns(RuntimeWarning) as w: + assert_equal(np.var(a, where=False), np.nan) + + def test_std_values(self): + for mat in [self.rmat, self.cmat, self.omat]: + for axis in [0, 1, None]: + tgt = np.sqrt(_var(mat, axis=axis)) + res = _std(mat, axis=axis) + assert_almost_equal(res, tgt) + + def test_std_where(self): + a = np.arange(25).reshape((5,5))[::-1] + whf = np.array([[False, True, False, True, True], + [True, False, True, False, True], + [True, True, False, True, False], + [True, False, True, True, False], + [False, True, False, True, True]]) + whp = np.array([[False], + [False], + [True], + [True], + [False]]) + _cases = [ + (0, True, 7.07106781*np.ones(5)), + (1, True, 1.41421356*np.ones(5)), + (0, whf, + np.array([4.0824829 , 8.16496581, 5., 7.39509973, 8.49836586])), + (0, whp, 2.5*np.ones(5)) + ] + for _ax, _wh, _res in _cases: + assert_allclose(a.std(axis=_ax, where=_wh), _res) + assert_allclose(np.std(a, axis=_ax, where=_wh), _res) + + a3d = np.arange(16).reshape((2, 2, 4)) + _wh_partial = np.array([False, True, True, False]) + _res = [[0.5, 0.5], [0.5, 0.5]] + assert_allclose(a3d.std(axis=2, where=_wh_partial), + np.array(_res)) + assert_allclose(np.std(a3d, axis=2, where=_wh_partial), + np.array(_res)) + + assert_allclose(a.std(axis=1, where=whf), + np.std(a[whf].reshape((5,3)), axis=1)) + assert_allclose(np.std(a, axis=1, where=whf), + (a[whf].reshape((5,3))).std(axis=1)) + assert_allclose(a.std(axis=0, where=whp), + np.std(a[whp[:,0]], axis=0)) + assert_allclose(np.std(a, axis=0, where=whp), + (a[whp[:,0]]).std(axis=0)) + with pytest.warns(RuntimeWarning) as w: + assert_equal(a.std(where=False), np.nan) + with pytest.warns(RuntimeWarning) as w: + assert_equal(np.std(a, where=False), np.nan) + + def test_subclass(self): + class TestArray(np.ndarray): + def __new__(cls, data, info): + result = np.array(data) + result = result.view(cls) + result.info = info + return result + + def __array_finalize__(self, obj): + self.info = getattr(obj, "info", '') + + dat = TestArray([[1, 2, 3, 4], [5, 6, 7, 8]], 'jubba') + res = dat.mean(1) + assert_(res.info == dat.info) + res = dat.std(1) + assert_(res.info == dat.info) + res = dat.var(1) + assert_(res.info == dat.info) + + +class TestVdot: + def test_basic(self): + dt_numeric = np.typecodes['AllFloat'] + np.typecodes['AllInteger'] + dt_complex = np.typecodes['Complex'] + + # test real + a = np.eye(3) + for dt in dt_numeric + 'O': + b = a.astype(dt) + res = np.vdot(b, b) + assert_(np.isscalar(res)) + assert_equal(np.vdot(b, b), 3) + + # test complex + a = np.eye(3) * 1j + for dt in dt_complex + 'O': + b = a.astype(dt) + res = np.vdot(b, b) + assert_(np.isscalar(res)) + assert_equal(np.vdot(b, b), 3) + + # test boolean + b = np.eye(3, dtype=bool) + res = np.vdot(b, b) + assert_(np.isscalar(res)) + assert_equal(np.vdot(b, b), True) + + def test_vdot_array_order(self): + a = np.array([[1, 2], [3, 4]], order='C') + b = np.array([[1, 2], [3, 4]], order='F') + res = np.vdot(a, a) + + # integer arrays are exact + assert_equal(np.vdot(a, b), res) + assert_equal(np.vdot(b, a), res) + assert_equal(np.vdot(b, b), res) + + def test_vdot_uncontiguous(self): + for size in [2, 1000]: + # Different sizes match different branches in vdot. + a = np.zeros((size, 2, 2)) + b = np.zeros((size, 2, 2)) + a[:, 0, 0] = np.arange(size) + b[:, 0, 0] = np.arange(size) + 1 + # Make a and b uncontiguous: + a = a[..., 0] + b = b[..., 0] + + assert_equal(np.vdot(a, b), + np.vdot(a.flatten(), b.flatten())) + assert_equal(np.vdot(a, b.copy()), + np.vdot(a.flatten(), b.flatten())) + assert_equal(np.vdot(a.copy(), b), + np.vdot(a.flatten(), b.flatten())) + assert_equal(np.vdot(a.copy('F'), b), + np.vdot(a.flatten(), b.flatten())) + assert_equal(np.vdot(a, b.copy('F')), + np.vdot(a.flatten(), b.flatten())) + + +class TestDot: + def setup_method(self): + np.random.seed(128) + self.A = np.random.rand(4, 2) + self.b1 = np.random.rand(2, 1) + self.b2 = np.random.rand(2) + self.b3 = np.random.rand(1, 2) + self.b4 = np.random.rand(4) + self.N = 7 + + def test_dotmatmat(self): + A = self.A + res = np.dot(A.transpose(), A) + tgt = np.array([[1.45046013, 0.86323640], + [0.86323640, 0.84934569]]) + assert_almost_equal(res, tgt, decimal=self.N) + + def test_dotmatvec(self): + A, b1 = self.A, self.b1 + res = np.dot(A, b1) + tgt = np.array([[0.32114320], [0.04889721], + [0.15696029], [0.33612621]]) + assert_almost_equal(res, tgt, decimal=self.N) + + def test_dotmatvec2(self): + A, b2 = self.A, self.b2 + res = np.dot(A, b2) + tgt = np.array([0.29677940, 0.04518649, 0.14468333, 0.31039293]) + assert_almost_equal(res, tgt, decimal=self.N) + + def test_dotvecmat(self): + A, b4 = self.A, self.b4 + res = np.dot(b4, A) + tgt = np.array([1.23495091, 1.12222648]) + assert_almost_equal(res, tgt, decimal=self.N) + + def test_dotvecmat2(self): + b3, A = self.b3, self.A + res = np.dot(b3, A.transpose()) + tgt = np.array([[0.58793804, 0.08957460, 0.30605758, 0.62716383]]) + assert_almost_equal(res, tgt, decimal=self.N) + + def test_dotvecmat3(self): + A, b4 = self.A, self.b4 + res = np.dot(A.transpose(), b4) + tgt = np.array([1.23495091, 1.12222648]) + assert_almost_equal(res, tgt, decimal=self.N) + + def test_dotvecvecouter(self): + b1, b3 = self.b1, self.b3 + res = np.dot(b1, b3) + tgt = np.array([[0.20128610, 0.08400440], [0.07190947, 0.03001058]]) + assert_almost_equal(res, tgt, decimal=self.N) + + def test_dotvecvecinner(self): + b1, b3 = self.b1, self.b3 + res = np.dot(b3, b1) + tgt = np.array([[ 0.23129668]]) + assert_almost_equal(res, tgt, decimal=self.N) + + def test_dotcolumnvect1(self): + b1 = np.ones((3, 1)) + b2 = [5.3] + res = np.dot(b1, b2) + tgt = np.array([5.3, 5.3, 5.3]) + assert_almost_equal(res, tgt, decimal=self.N) + + def test_dotcolumnvect2(self): + b1 = np.ones((3, 1)).transpose() + b2 = [6.2] + res = np.dot(b2, b1) + tgt = np.array([6.2, 6.2, 6.2]) + assert_almost_equal(res, tgt, decimal=self.N) + + def test_dotvecscalar(self): + np.random.seed(100) + b1 = np.random.rand(1, 1) + b2 = np.random.rand(1, 4) + res = np.dot(b1, b2) + tgt = np.array([[0.15126730, 0.23068496, 0.45905553, 0.00256425]]) + assert_almost_equal(res, tgt, decimal=self.N) + + def test_dotvecscalar2(self): + np.random.seed(100) + b1 = np.random.rand(4, 1) + b2 = np.random.rand(1, 1) + res = np.dot(b1, b2) + tgt = np.array([[0.00256425],[0.00131359],[0.00200324],[ 0.00398638]]) + assert_almost_equal(res, tgt, decimal=self.N) + + def test_all(self): + dims = [(), (1,), (1, 1)] + dout = [(), (1,), (1, 1), (1,), (), (1,), (1, 1), (1,), (1, 1)] + for dim, (dim1, dim2) in zip(dout, itertools.product(dims, dims)): + b1 = np.zeros(dim1) + b2 = np.zeros(dim2) + res = np.dot(b1, b2) + tgt = np.zeros(dim) + assert_(res.shape == tgt.shape) + assert_almost_equal(res, tgt, decimal=self.N) + + def test_vecobject(self): + class Vec: + def __init__(self, sequence=None): + if sequence is None: + sequence = [] + self.array = np.array(sequence) + + def __add__(self, other): + out = Vec() + out.array = self.array + other.array + return out + + def __sub__(self, other): + out = Vec() + out.array = self.array - other.array + return out + + def __mul__(self, other): # with scalar + out = Vec(self.array.copy()) + out.array *= other + return out + + def __rmul__(self, other): + return self*other + + U_non_cont = np.transpose([[1., 1.], [1., 2.]]) + U_cont = np.ascontiguousarray(U_non_cont) + x = np.array([Vec([1., 0.]), Vec([0., 1.])]) + zeros = np.array([Vec([0., 0.]), Vec([0., 0.])]) + zeros_test = np.dot(U_cont, x) - np.dot(U_non_cont, x) + assert_equal(zeros[0].array, zeros_test[0].array) + assert_equal(zeros[1].array, zeros_test[1].array) + + def test_dot_2args(self): + + a = np.array([[1, 2], [3, 4]], dtype=float) + b = np.array([[1, 0], [1, 1]], dtype=float) + c = np.array([[3, 2], [7, 4]], dtype=float) + + d = dot(a, b) + assert_allclose(c, d) + + def test_dot_3args(self): + + np.random.seed(22) + f = np.random.random_sample((1024, 16)) + v = np.random.random_sample((16, 32)) + + r = np.empty((1024, 32)) + for i in range(12): + dot(f, v, r) + if HAS_REFCOUNT: + assert_equal(sys.getrefcount(r), 2) + r2 = dot(f, v, out=None) + assert_array_equal(r2, r) + assert_(r is dot(f, v, out=r)) + + v = v[:, 0].copy() # v.shape == (16,) + r = r[:, 0].copy() # r.shape == (1024,) + r2 = dot(f, v) + assert_(r is dot(f, v, r)) + assert_array_equal(r2, r) + + def test_dot_3args_errors(self): + + np.random.seed(22) + f = np.random.random_sample((1024, 16)) + v = np.random.random_sample((16, 32)) + + r = np.empty((1024, 31)) + assert_raises(ValueError, dot, f, v, r) + + r = np.empty((1024,)) + assert_raises(ValueError, dot, f, v, r) + + r = np.empty((32,)) + assert_raises(ValueError, dot, f, v, r) + + r = np.empty((32, 1024)) + assert_raises(ValueError, dot, f, v, r) + assert_raises(ValueError, dot, f, v, r.T) + + r = np.empty((1024, 64)) + assert_raises(ValueError, dot, f, v, r[:, ::2]) + assert_raises(ValueError, dot, f, v, r[:, :32]) + + r = np.empty((1024, 32), dtype=np.float32) + assert_raises(ValueError, dot, f, v, r) + + r = np.empty((1024, 32), dtype=int) + assert_raises(ValueError, dot, f, v, r) + + def test_dot_out_result(self): + x = np.ones((), dtype=np.float16) + y = np.ones((5,), dtype=np.float16) + z = np.zeros((5,), dtype=np.float16) + res = x.dot(y, out=z) + assert np.array_equal(res, y) + assert np.array_equal(z, y) + + def test_dot_out_aliasing(self): + x = np.ones((), dtype=np.float16) + y = np.ones((5,), dtype=np.float16) + z = np.zeros((5,), dtype=np.float16) + res = x.dot(y, out=z) + z[0] = 2 + assert np.array_equal(res, z) + + def test_dot_array_order(self): + a = np.array([[1, 2], [3, 4]], order='C') + b = np.array([[1, 2], [3, 4]], order='F') + res = np.dot(a, a) + + # integer arrays are exact + assert_equal(np.dot(a, b), res) + assert_equal(np.dot(b, a), res) + assert_equal(np.dot(b, b), res) + + def test_accelerate_framework_sgemv_fix(self): + + def aligned_array(shape, align, dtype, order='C'): + d = dtype(0) + N = np.prod(shape) + tmp = np.zeros(N * d.nbytes + align, dtype=np.uint8) + address = tmp.__array_interface__["data"][0] + for offset in range(align): + if (address + offset) % align == 0: + break + tmp = tmp[offset:offset+N*d.nbytes].view(dtype=dtype) + return tmp.reshape(shape, order=order) + + def as_aligned(arr, align, dtype, order='C'): + aligned = aligned_array(arr.shape, align, dtype, order) + aligned[:] = arr[:] + return aligned + + def assert_dot_close(A, X, desired): + assert_allclose(np.dot(A, X), desired, rtol=1e-5, atol=1e-7) + + m = aligned_array(100, 15, np.float32) + s = aligned_array((100, 100), 15, np.float32) + np.dot(s, m) # this will always segfault if the bug is present + + testdata = itertools.product((15, 32), (10000,), (200, 89), ('C', 'F')) + for align, m, n, a_order in testdata: + # Calculation in double precision + A_d = np.random.rand(m, n) + X_d = np.random.rand(n) + desired = np.dot(A_d, X_d) + # Calculation with aligned single precision + A_f = as_aligned(A_d, align, np.float32, order=a_order) + X_f = as_aligned(X_d, align, np.float32) + assert_dot_close(A_f, X_f, desired) + # Strided A rows + A_d_2 = A_d[::2] + desired = np.dot(A_d_2, X_d) + A_f_2 = A_f[::2] + assert_dot_close(A_f_2, X_f, desired) + # Strided A columns, strided X vector + A_d_22 = A_d_2[:, ::2] + X_d_2 = X_d[::2] + desired = np.dot(A_d_22, X_d_2) + A_f_22 = A_f_2[:, ::2] + X_f_2 = X_f[::2] + assert_dot_close(A_f_22, X_f_2, desired) + # Check the strides are as expected + if a_order == 'F': + assert_equal(A_f_22.strides, (8, 8 * m)) + else: + assert_equal(A_f_22.strides, (8 * n, 8)) + assert_equal(X_f_2.strides, (8,)) + # Strides in A rows + cols only + X_f_2c = as_aligned(X_f_2, align, np.float32) + assert_dot_close(A_f_22, X_f_2c, desired) + # Strides just in A cols + A_d_12 = A_d[:, ::2] + desired = np.dot(A_d_12, X_d_2) + A_f_12 = A_f[:, ::2] + assert_dot_close(A_f_12, X_f_2c, desired) + # Strides in A cols and X + assert_dot_close(A_f_12, X_f_2, desired) + + @pytest.mark.slow + @pytest.mark.parametrize("dtype", [np.float64, np.complex128]) + @requires_memory(free_bytes=18e9) # complex case needs 18GiB+ + def test_huge_vectordot(self, dtype): + # Large vector multiplications are chunked with 32bit BLAS + # Test that the chunking does the right thing, see also gh-22262 + data = np.ones(2**30+100, dtype=dtype) + res = np.dot(data, data) + assert res == 2**30+100 + + def test_dtype_discovery_fails(self): + # See gh-14247, error checking was missing for failed dtype discovery + class BadObject: + def __array__(self, dtype=None, copy=None): + raise TypeError("just this tiny mint leaf") + + with pytest.raises(TypeError): + np.dot(BadObject(), BadObject()) + + with pytest.raises(TypeError): + np.dot(3.0, BadObject()) + + +class MatmulCommon: + """Common tests for '@' operator and numpy.matmul. + + """ + # Should work with these types. Will want to add + # "O" at some point + types = "?bhilqBHILQefdgFDGO" + + def test_exceptions(self): + dims = [ + ((1,), (2,)), # mismatched vector vector + ((2, 1,), (2,)), # mismatched matrix vector + ((2,), (1, 2)), # mismatched vector matrix + ((1, 2), (3, 1)), # mismatched matrix matrix + ((1,), ()), # vector scalar + ((), (1)), # scalar vector + ((1, 1), ()), # matrix scalar + ((), (1, 1)), # scalar matrix + ((2, 2, 1), (3, 1, 2)), # cannot broadcast + ] + + for dt, (dm1, dm2) in itertools.product(self.types, dims): + a = np.ones(dm1, dtype=dt) + b = np.ones(dm2, dtype=dt) + assert_raises(ValueError, self.matmul, a, b) + + def test_shapes(self): + dims = [ + ((1, 1), (2, 1, 1)), # broadcast first argument + ((2, 1, 1), (1, 1)), # broadcast second argument + ((2, 1, 1), (2, 1, 1)), # matrix stack sizes match + ] + + for dt, (dm1, dm2) in itertools.product(self.types, dims): + a = np.ones(dm1, dtype=dt) + b = np.ones(dm2, dtype=dt) + res = self.matmul(a, b) + assert_(res.shape == (2, 1, 1)) + + # vector vector returns scalars. + for dt in self.types: + a = np.ones((2,), dtype=dt) + b = np.ones((2,), dtype=dt) + c = self.matmul(a, b) + assert_(np.array(c).shape == ()) + + def test_result_types(self): + mat = np.ones((1,1)) + vec = np.ones((1,)) + for dt in self.types: + m = mat.astype(dt) + v = vec.astype(dt) + for arg in [(m, v), (v, m), (m, m)]: + res = self.matmul(*arg) + assert_(res.dtype == dt) + + # vector vector returns scalars + if dt != "O": + res = self.matmul(v, v) + assert_(type(res) is np.dtype(dt).type) + + def test_scalar_output(self): + vec1 = np.array([2]) + vec2 = np.array([3, 4]).reshape(1, -1) + tgt = np.array([6, 8]) + for dt in self.types[1:]: + v1 = vec1.astype(dt) + v2 = vec2.astype(dt) + res = self.matmul(v1, v2) + assert_equal(res, tgt) + res = self.matmul(v2.T, v1) + assert_equal(res, tgt) + + # boolean type + vec = np.array([True, True], dtype='?').reshape(1, -1) + res = self.matmul(vec[:, 0], vec) + assert_equal(res, True) + + def test_vector_vector_values(self): + vec1 = np.array([1, 2]) + vec2 = np.array([3, 4]).reshape(-1, 1) + tgt1 = np.array([11]) + tgt2 = np.array([[3, 6], [4, 8]]) + for dt in self.types[1:]: + v1 = vec1.astype(dt) + v2 = vec2.astype(dt) + res = self.matmul(v1, v2) + assert_equal(res, tgt1) + # no broadcast, we must make v1 into a 2d ndarray + res = self.matmul(v2, v1.reshape(1, -1)) + assert_equal(res, tgt2) + + # boolean type + vec = np.array([True, True], dtype='?') + res = self.matmul(vec, vec) + assert_equal(res, True) + + def test_vector_matrix_values(self): + vec = np.array([1, 2]) + mat1 = np.array([[1, 2], [3, 4]]) + mat2 = np.stack([mat1]*2, axis=0) + tgt1 = np.array([7, 10]) + tgt2 = np.stack([tgt1]*2, axis=0) + for dt in self.types[1:]: + v = vec.astype(dt) + m1 = mat1.astype(dt) + m2 = mat2.astype(dt) + res = self.matmul(v, m1) + assert_equal(res, tgt1) + res = self.matmul(v, m2) + assert_equal(res, tgt2) + + # boolean type + vec = np.array([True, False]) + mat1 = np.array([[True, False], [False, True]]) + mat2 = np.stack([mat1]*2, axis=0) + tgt1 = np.array([True, False]) + tgt2 = np.stack([tgt1]*2, axis=0) + + res = self.matmul(vec, mat1) + assert_equal(res, tgt1) + res = self.matmul(vec, mat2) + assert_equal(res, tgt2) + + def test_matrix_vector_values(self): + vec = np.array([1, 2]) + mat1 = np.array([[1, 2], [3, 4]]) + mat2 = np.stack([mat1]*2, axis=0) + tgt1 = np.array([5, 11]) + tgt2 = np.stack([tgt1]*2, axis=0) + for dt in self.types[1:]: + v = vec.astype(dt) + m1 = mat1.astype(dt) + m2 = mat2.astype(dt) + res = self.matmul(m1, v) + assert_equal(res, tgt1) + res = self.matmul(m2, v) + assert_equal(res, tgt2) + + # boolean type + vec = np.array([True, False]) + mat1 = np.array([[True, False], [False, True]]) + mat2 = np.stack([mat1]*2, axis=0) + tgt1 = np.array([True, False]) + tgt2 = np.stack([tgt1]*2, axis=0) + + res = self.matmul(vec, mat1) + assert_equal(res, tgt1) + res = self.matmul(vec, mat2) + assert_equal(res, tgt2) + + def test_matrix_matrix_values(self): + mat1 = np.array([[1, 2], [3, 4]]) + mat2 = np.array([[1, 0], [1, 1]]) + mat12 = np.stack([mat1, mat2], axis=0) + mat21 = np.stack([mat2, mat1], axis=0) + tgt11 = np.array([[7, 10], [15, 22]]) + tgt12 = np.array([[3, 2], [7, 4]]) + tgt21 = np.array([[1, 2], [4, 6]]) + tgt12_21 = np.stack([tgt12, tgt21], axis=0) + tgt11_12 = np.stack((tgt11, tgt12), axis=0) + tgt11_21 = np.stack((tgt11, tgt21), axis=0) + for dt in self.types[1:]: + m1 = mat1.astype(dt) + m2 = mat2.astype(dt) + m12 = mat12.astype(dt) + m21 = mat21.astype(dt) + + # matrix @ matrix + res = self.matmul(m1, m2) + assert_equal(res, tgt12) + res = self.matmul(m2, m1) + assert_equal(res, tgt21) + + # stacked @ matrix + res = self.matmul(m12, m1) + assert_equal(res, tgt11_21) + + # matrix @ stacked + res = self.matmul(m1, m12) + assert_equal(res, tgt11_12) + + # stacked @ stacked + res = self.matmul(m12, m21) + assert_equal(res, tgt12_21) + + # boolean type + m1 = np.array([[1, 1], [0, 0]], dtype=np.bool) + m2 = np.array([[1, 0], [1, 1]], dtype=np.bool) + m12 = np.stack([m1, m2], axis=0) + m21 = np.stack([m2, m1], axis=0) + tgt11 = m1 + tgt12 = m1 + tgt21 = np.array([[1, 1], [1, 1]], dtype=np.bool) + tgt12_21 = np.stack([tgt12, tgt21], axis=0) + tgt11_12 = np.stack((tgt11, tgt12), axis=0) + tgt11_21 = np.stack((tgt11, tgt21), axis=0) + + # matrix @ matrix + res = self.matmul(m1, m2) + assert_equal(res, tgt12) + res = self.matmul(m2, m1) + assert_equal(res, tgt21) + + # stacked @ matrix + res = self.matmul(m12, m1) + assert_equal(res, tgt11_21) + + # matrix @ stacked + res = self.matmul(m1, m12) + assert_equal(res, tgt11_12) + + # stacked @ stacked + res = self.matmul(m12, m21) + assert_equal(res, tgt12_21) + + +class TestMatmul(MatmulCommon): + matmul = np.matmul + + def test_out_arg(self): + a = np.ones((5, 2), dtype=float) + b = np.array([[1, 3], [5, 7]], dtype=float) + tgt = np.dot(a, b) + + # test as positional argument + msg = "out positional argument" + out = np.zeros((5, 2), dtype=float) + self.matmul(a, b, out) + assert_array_equal(out, tgt, err_msg=msg) + + # test as keyword argument + msg = "out keyword argument" + out = np.zeros((5, 2), dtype=float) + self.matmul(a, b, out=out) + assert_array_equal(out, tgt, err_msg=msg) + + # test out with not allowed type cast (safe casting) + msg = "Cannot cast ufunc .* output" + out = np.zeros((5, 2), dtype=np.int32) + assert_raises_regex(TypeError, msg, self.matmul, a, b, out=out) + + # test out with type upcast to complex + out = np.zeros((5, 2), dtype=np.complex128) + c = self.matmul(a, b, out=out) + assert_(c is out) + with suppress_warnings() as sup: + sup.filter(ComplexWarning, '') + c = c.astype(tgt.dtype) + assert_array_equal(c, tgt) + + def test_empty_out(self): + # Check that the output cannot be broadcast, so that it cannot be + # size zero when the outer dimensions (iterator size) has size zero. + arr = np.ones((0, 1, 1)) + out = np.ones((1, 1, 1)) + assert self.matmul(arr, arr).shape == (0, 1, 1) + + with pytest.raises(ValueError, match=r"non-broadcastable"): + self.matmul(arr, arr, out=out) + + def test_out_contiguous(self): + a = np.ones((5, 2), dtype=float) + b = np.array([[1, 3], [5, 7]], dtype=float) + v = np.array([1, 3], dtype=float) + tgt = np.dot(a, b) + tgt_mv = np.dot(a, v) + + # test out non-contiguous + out = np.ones((5, 2, 2), dtype=float) + c = self.matmul(a, b, out=out[..., 0]) + assert c.base is out + assert_array_equal(c, tgt) + c = self.matmul(a, v, out=out[:, 0, 0]) + assert_array_equal(c, tgt_mv) + c = self.matmul(v, a.T, out=out[:, 0, 0]) + assert_array_equal(c, tgt_mv) + + # test out contiguous in only last dim + out = np.ones((10, 2), dtype=float) + c = self.matmul(a, b, out=out[::2, :]) + assert_array_equal(c, tgt) + + # test transposes of out, args + out = np.ones((5, 2), dtype=float) + c = self.matmul(b.T, a.T, out=out.T) + assert_array_equal(out, tgt) + + m1 = np.arange(15.).reshape(5, 3) + m2 = np.arange(21.).reshape(3, 7) + m3 = np.arange(30.).reshape(5, 6)[:, ::2] # non-contiguous + vc = np.arange(10.) + vr = np.arange(6.) + m0 = np.zeros((3, 0)) + @pytest.mark.parametrize('args', ( + # matrix-matrix + (m1, m2), (m2.T, m1.T), (m2.T.copy(), m1.T), (m2.T, m1.T.copy()), + # matrix-matrix-transpose, contiguous and non + (m1, m1.T), (m1.T, m1), (m1, m3.T), (m3, m1.T), + (m3, m3.T), (m3.T, m3), + # matrix-matrix non-contiguous + (m3, m2), (m2.T, m3.T), (m2.T.copy(), m3.T), + # vector-matrix, matrix-vector, contiguous + (m1, vr[:3]), (vc[:5], m1), (m1.T, vc[:5]), (vr[:3], m1.T), + # vector-matrix, matrix-vector, vector non-contiguous + (m1, vr[::2]), (vc[::2], m1), (m1.T, vc[::2]), (vr[::2], m1.T), + # vector-matrix, matrix-vector, matrix non-contiguous + (m3, vr[:3]), (vc[:5], m3), (m3.T, vc[:5]), (vr[:3], m3.T), + # vector-matrix, matrix-vector, both non-contiguous + (m3, vr[::2]), (vc[::2], m3), (m3.T, vc[::2]), (vr[::2], m3.T), + # size == 0 + (m0, m0.T), (m0.T, m0), (m1, m0), (m0.T, m1.T), + )) + def test_dot_equivalent(self, args): + r1 = np.matmul(*args) + r2 = np.dot(*args) + assert_equal(r1, r2) + + r3 = np.matmul(args[0].copy(), args[1].copy()) + assert_equal(r1, r3) + + def test_matmul_object(self): + import fractions + + f = np.vectorize(fractions.Fraction) + def random_ints(): + return np.random.randint(1, 1000, size=(10, 3, 3)) + M1 = f(random_ints(), random_ints()) + M2 = f(random_ints(), random_ints()) + + M3 = self.matmul(M1, M2) + + [N1, N2, N3] = [a.astype(float) for a in [M1, M2, M3]] + + assert_allclose(N3, self.matmul(N1, N2)) + + def test_matmul_object_type_scalar(self): + from fractions import Fraction as F + v = np.array([F(2,3), F(5,7)]) + res = self.matmul(v, v) + assert_(type(res) is F) + + def test_matmul_empty(self): + a = np.empty((3, 0), dtype=object) + b = np.empty((0, 3), dtype=object) + c = np.zeros((3, 3)) + assert_array_equal(np.matmul(a, b), c) + + def test_matmul_exception_multiply(self): + # test that matmul fails if `__mul__` is missing + class add_not_multiply: + def __add__(self, other): + return self + a = np.full((3,3), add_not_multiply()) + with assert_raises(TypeError): + b = np.matmul(a, a) + + def test_matmul_exception_add(self): + # test that matmul fails if `__add__` is missing + class multiply_not_add: + def __mul__(self, other): + return self + a = np.full((3,3), multiply_not_add()) + with assert_raises(TypeError): + b = np.matmul(a, a) + + def test_matmul_bool(self): + # gh-14439 + a = np.array([[1, 0],[1, 1]], dtype=bool) + assert np.max(a.view(np.uint8)) == 1 + b = np.matmul(a, a) + # matmul with boolean output should always be 0, 1 + assert np.max(b.view(np.uint8)) == 1 + + rg = np.random.default_rng(np.random.PCG64(43)) + d = rg.integers(2, size=4*5, dtype=np.int8) + d = d.reshape(4, 5) > 0 + out1 = np.matmul(d, d.reshape(5, 4)) + out2 = np.dot(d, d.reshape(5, 4)) + assert_equal(out1, out2) + + c = np.matmul(np.zeros((2, 0), dtype=bool), np.zeros(0, dtype=bool)) + assert not np.any(c) + + +class TestMatmulOperator(MatmulCommon): + import operator + matmul = operator.matmul + + def test_array_priority_override(self): + + class A: + __array_priority__ = 1000 + + def __matmul__(self, other): + return "A" + + def __rmatmul__(self, other): + return "A" + + a = A() + b = np.ones(2) + assert_equal(self.matmul(a, b), "A") + assert_equal(self.matmul(b, a), "A") + + def test_matmul_raises(self): + assert_raises(TypeError, self.matmul, np.int8(5), np.int8(5)) + assert_raises(TypeError, self.matmul, np.void(b'abc'), np.void(b'abc')) + assert_raises(TypeError, self.matmul, np.arange(10), np.void(b'abc')) + + +class TestMatmulInplace: + DTYPES = {} + for i in MatmulCommon.types: + for j in MatmulCommon.types: + if np.can_cast(j, i): + DTYPES[f"{i}-{j}"] = (np.dtype(i), np.dtype(j)) + + @pytest.mark.parametrize("dtype1,dtype2", DTYPES.values(), ids=DTYPES) + def test_basic(self, dtype1: np.dtype, dtype2: np.dtype) -> None: + a = np.arange(10).reshape(5, 2).astype(dtype1) + a_id = id(a) + b = np.ones((2, 2), dtype=dtype2) + + ref = a @ b + a @= b + + assert id(a) == a_id + assert a.dtype == dtype1 + assert a.shape == (5, 2) + if dtype1.kind in "fc": + np.testing.assert_allclose(a, ref) + else: + np.testing.assert_array_equal(a, ref) + + SHAPES = { + "2d_large": ((10**5, 10), (10, 10)), + "3d_large": ((10**4, 10, 10), (1, 10, 10)), + "1d": ((3,), (3,)), + "2d_1d": ((3, 3), (3,)), + "1d_2d": ((3,), (3, 3)), + "2d_broadcast": ((3, 3), (3, 1)), + "2d_broadcast_reverse": ((1, 3), (3, 3)), + "3d_broadcast1": ((3, 3, 3), (1, 3, 1)), + "3d_broadcast2": ((3, 3, 3), (1, 3, 3)), + "3d_broadcast3": ((3, 3, 3), (3, 3, 1)), + "3d_broadcast_reverse1": ((1, 3, 3), (3, 3, 3)), + "3d_broadcast_reverse2": ((3, 1, 3), (3, 3, 3)), + "3d_broadcast_reverse3": ((1, 1, 3), (3, 3, 3)), + } + + @pytest.mark.parametrize("a_shape,b_shape", SHAPES.values(), ids=SHAPES) + def test_shapes(self, a_shape: tuple[int, ...], b_shape: tuple[int, ...]): + a_size = np.prod(a_shape) + a = np.arange(a_size).reshape(a_shape).astype(np.float64) + a_id = id(a) + + b_size = np.prod(b_shape) + b = np.arange(b_size).reshape(b_shape) + + ref = a @ b + if ref.shape != a_shape: + with pytest.raises(ValueError): + a @= b + return + else: + a @= b + + assert id(a) == a_id + assert a.dtype.type == np.float64 + assert a.shape == a_shape + np.testing.assert_allclose(a, ref) + + +def test_matmul_axes(): + a = np.arange(3*4*5).reshape(3, 4, 5) + c = np.matmul(a, a, axes=[(-2, -1), (-1, -2), (1, 2)]) + assert c.shape == (3, 4, 4) + d = np.matmul(a, a, axes=[(-2, -1), (-1, -2), (0, 1)]) + assert d.shape == (4, 4, 3) + e = np.swapaxes(d, 0, 2) + assert_array_equal(e, c) + f = np.matmul(a, np.arange(3), axes=[(1, 0), (0), (0)]) + assert f.shape == (4, 5) + + +class TestInner: + + def test_inner_type_mismatch(self): + c = 1. + A = np.array((1,1), dtype='i,i') + + assert_raises(TypeError, np.inner, c, A) + assert_raises(TypeError, np.inner, A, c) + + def test_inner_scalar_and_vector(self): + for dt in np.typecodes['AllInteger'] + np.typecodes['AllFloat'] + '?': + sca = np.array(3, dtype=dt)[()] + vec = np.array([1, 2], dtype=dt) + desired = np.array([3, 6], dtype=dt) + assert_equal(np.inner(vec, sca), desired) + assert_equal(np.inner(sca, vec), desired) + + def test_vecself(self): + # Ticket 844. + # Inner product of a vector with itself segfaults or give + # meaningless result + a = np.zeros(shape=(1, 80), dtype=np.float64) + p = np.inner(a, a) + assert_almost_equal(p, 0, decimal=14) + + def test_inner_product_with_various_contiguities(self): + # github issue 6532 + for dt in np.typecodes['AllInteger'] + np.typecodes['AllFloat'] + '?': + # check an inner product involving a matrix transpose + A = np.array([[1, 2], [3, 4]], dtype=dt) + B = np.array([[1, 3], [2, 4]], dtype=dt) + C = np.array([1, 1], dtype=dt) + desired = np.array([4, 6], dtype=dt) + assert_equal(np.inner(A.T, C), desired) + assert_equal(np.inner(C, A.T), desired) + assert_equal(np.inner(B, C), desired) + assert_equal(np.inner(C, B), desired) + # check a matrix product + desired = np.array([[7, 10], [15, 22]], dtype=dt) + assert_equal(np.inner(A, B), desired) + # check the syrk vs. gemm paths + desired = np.array([[5, 11], [11, 25]], dtype=dt) + assert_equal(np.inner(A, A), desired) + assert_equal(np.inner(A, A.copy()), desired) + # check an inner product involving an aliased and reversed view + a = np.arange(5).astype(dt) + b = a[::-1] + desired = np.array(10, dtype=dt).item() + assert_equal(np.inner(b, a), desired) + + def test_3d_tensor(self): + for dt in np.typecodes['AllInteger'] + np.typecodes['AllFloat'] + '?': + a = np.arange(24).reshape(2,3,4).astype(dt) + b = np.arange(24, 48).reshape(2,3,4).astype(dt) + desired = np.array( + [[[[ 158, 182, 206], + [ 230, 254, 278]], + + [[ 566, 654, 742], + [ 830, 918, 1006]], + + [[ 974, 1126, 1278], + [1430, 1582, 1734]]], + + [[[1382, 1598, 1814], + [2030, 2246, 2462]], + + [[1790, 2070, 2350], + [2630, 2910, 3190]], + + [[2198, 2542, 2886], + [3230, 3574, 3918]]]] + ).astype(dt) + assert_equal(np.inner(a, b), desired) + assert_equal(np.inner(b, a).transpose(2,3,0,1), desired) + + +class TestChoose: + def setup_method(self): + self.x = 2*np.ones((3,), dtype=int) + self.y = 3*np.ones((3,), dtype=int) + self.x2 = 2*np.ones((2, 3), dtype=int) + self.y2 = 3*np.ones((2, 3), dtype=int) + self.ind = [0, 0, 1] + + def test_basic(self): + A = np.choose(self.ind, (self.x, self.y)) + assert_equal(A, [2, 2, 3]) + + def test_broadcast1(self): + A = np.choose(self.ind, (self.x2, self.y2)) + assert_equal(A, [[2, 2, 3], [2, 2, 3]]) + + def test_broadcast2(self): + A = np.choose(self.ind, (self.x, self.y2)) + assert_equal(A, [[2, 2, 3], [2, 2, 3]]) + + @pytest.mark.parametrize("ops", + [(1000, np.array([1], dtype=np.uint8)), + (-1, np.array([1], dtype=np.uint8)), + (1., np.float32(3)), + (1., np.array([3], dtype=np.float32))],) + def test_output_dtype(self, ops): + expected_dt = np.result_type(*ops) + assert(np.choose([0], ops).dtype == expected_dt) + + def test_dimension_and_args_limit(self): + # Maxdims for the legacy iterator is 32, but the maximum number + # of arguments is actually larger (a itself also counts here) + a = np.ones((1,) * 32, dtype=np.intp) + res = a.choose([0, a] + [2] * 61) + with pytest.raises(ValueError, + match="Need at least 0 and at most 64 array objects"): + a.choose([0, a] + [2] * 62) + + assert_array_equal(res, a) + # Choose is unfortunately limited to 32 dims as of NumPy 2.0 + a = np.ones((1,) * 60, dtype=np.intp) + with pytest.raises(RuntimeError, + match=".*32 dimensions but the array has 60"): + a.choose([a, a]) + + +class TestRepeat: + def setup_method(self): + self.m = np.array([1, 2, 3, 4, 5, 6]) + self.m_rect = self.m.reshape((2, 3)) + + def test_basic(self): + A = np.repeat(self.m, [1, 3, 2, 1, 1, 2]) + assert_equal(A, [1, 2, 2, 2, 3, + 3, 4, 5, 6, 6]) + + def test_broadcast1(self): + A = np.repeat(self.m, 2) + assert_equal(A, [1, 1, 2, 2, 3, 3, + 4, 4, 5, 5, 6, 6]) + + def test_axis_spec(self): + A = np.repeat(self.m_rect, [2, 1], axis=0) + assert_equal(A, [[1, 2, 3], + [1, 2, 3], + [4, 5, 6]]) + + A = np.repeat(self.m_rect, [1, 3, 2], axis=1) + assert_equal(A, [[1, 2, 2, 2, 3, 3], + [4, 5, 5, 5, 6, 6]]) + + def test_broadcast2(self): + A = np.repeat(self.m_rect, 2, axis=0) + assert_equal(A, [[1, 2, 3], + [1, 2, 3], + [4, 5, 6], + [4, 5, 6]]) + + A = np.repeat(self.m_rect, 2, axis=1) + assert_equal(A, [[1, 1, 2, 2, 3, 3], + [4, 4, 5, 5, 6, 6]]) + + +# TODO: test for multidimensional +NEIGH_MODE = {'zero': 0, 'one': 1, 'constant': 2, 'circular': 3, 'mirror': 4} + + +@pytest.mark.parametrize('dt', [float, Decimal], ids=['float', 'object']) +class TestNeighborhoodIter: + # Simple, 2d tests + def test_simple2d(self, dt): + # Test zero and one padding for simple data type + x = np.array([[0, 1], [2, 3]], dtype=dt) + r = [np.array([[0, 0, 0], [0, 0, 1]], dtype=dt), + np.array([[0, 0, 0], [0, 1, 0]], dtype=dt), + np.array([[0, 0, 1], [0, 2, 3]], dtype=dt), + np.array([[0, 1, 0], [2, 3, 0]], dtype=dt)] + l = _multiarray_tests.test_neighborhood_iterator( + x, [-1, 0, -1, 1], x[0], NEIGH_MODE['zero']) + assert_array_equal(l, r) + + r = [np.array([[1, 1, 1], [1, 0, 1]], dtype=dt), + np.array([[1, 1, 1], [0, 1, 1]], dtype=dt), + np.array([[1, 0, 1], [1, 2, 3]], dtype=dt), + np.array([[0, 1, 1], [2, 3, 1]], dtype=dt)] + l = _multiarray_tests.test_neighborhood_iterator( + x, [-1, 0, -1, 1], x[0], NEIGH_MODE['one']) + assert_array_equal(l, r) + + r = [np.array([[4, 4, 4], [4, 0, 1]], dtype=dt), + np.array([[4, 4, 4], [0, 1, 4]], dtype=dt), + np.array([[4, 0, 1], [4, 2, 3]], dtype=dt), + np.array([[0, 1, 4], [2, 3, 4]], dtype=dt)] + l = _multiarray_tests.test_neighborhood_iterator( + x, [-1, 0, -1, 1], 4, NEIGH_MODE['constant']) + assert_array_equal(l, r) + + # Test with start in the middle + r = [np.array([[4, 0, 1], [4, 2, 3]], dtype=dt), + np.array([[0, 1, 4], [2, 3, 4]], dtype=dt)] + l = _multiarray_tests.test_neighborhood_iterator( + x, [-1, 0, -1, 1], 4, NEIGH_MODE['constant'], 2) + assert_array_equal(l, r) + + def test_mirror2d(self, dt): + x = np.array([[0, 1], [2, 3]], dtype=dt) + r = [np.array([[0, 0, 1], [0, 0, 1]], dtype=dt), + np.array([[0, 1, 1], [0, 1, 1]], dtype=dt), + np.array([[0, 0, 1], [2, 2, 3]], dtype=dt), + np.array([[0, 1, 1], [2, 3, 3]], dtype=dt)] + l = _multiarray_tests.test_neighborhood_iterator( + x, [-1, 0, -1, 1], x[0], NEIGH_MODE['mirror']) + assert_array_equal(l, r) + + # Simple, 1d tests + def test_simple(self, dt): + # Test padding with constant values + x = np.linspace(1, 5, 5).astype(dt) + r = [[0, 1, 2], [1, 2, 3], [2, 3, 4], [3, 4, 5], [4, 5, 0]] + l = _multiarray_tests.test_neighborhood_iterator( + x, [-1, 1], x[0], NEIGH_MODE['zero']) + assert_array_equal(l, r) + + r = [[1, 1, 2], [1, 2, 3], [2, 3, 4], [3, 4, 5], [4, 5, 1]] + l = _multiarray_tests.test_neighborhood_iterator( + x, [-1, 1], x[0], NEIGH_MODE['one']) + assert_array_equal(l, r) + + r = [[x[4], 1, 2], [1, 2, 3], [2, 3, 4], [3, 4, 5], [4, 5, x[4]]] + l = _multiarray_tests.test_neighborhood_iterator( + x, [-1, 1], x[4], NEIGH_MODE['constant']) + assert_array_equal(l, r) + + # Test mirror modes + def test_mirror(self, dt): + x = np.linspace(1, 5, 5).astype(dt) + r = np.array([[2, 1, 1, 2, 3], [1, 1, 2, 3, 4], [1, 2, 3, 4, 5], + [2, 3, 4, 5, 5], [3, 4, 5, 5, 4]], dtype=dt) + l = _multiarray_tests.test_neighborhood_iterator( + x, [-2, 2], x[1], NEIGH_MODE['mirror']) + assert_([i.dtype == dt for i in l]) + assert_array_equal(l, r) + + # Circular mode + def test_circular(self, dt): + x = np.linspace(1, 5, 5).astype(dt) + r = np.array([[4, 5, 1, 2, 3], [5, 1, 2, 3, 4], [1, 2, 3, 4, 5], + [2, 3, 4, 5, 1], [3, 4, 5, 1, 2]], dtype=dt) + l = _multiarray_tests.test_neighborhood_iterator( + x, [-2, 2], x[0], NEIGH_MODE['circular']) + assert_array_equal(l, r) + + +# Test stacking neighborhood iterators +class TestStackedNeighborhoodIter: + # Simple, 1d test: stacking 2 constant-padded neigh iterators + def test_simple_const(self): + dt = np.float64 + # Test zero and one padding for simple data type + x = np.array([1, 2, 3], dtype=dt) + r = [np.array([0], dtype=dt), + np.array([0], dtype=dt), + np.array([1], dtype=dt), + np.array([2], dtype=dt), + np.array([3], dtype=dt), + np.array([0], dtype=dt), + np.array([0], dtype=dt)] + l = _multiarray_tests.test_neighborhood_iterator_oob( + x, [-2, 4], NEIGH_MODE['zero'], [0, 0], NEIGH_MODE['zero']) + assert_array_equal(l, r) + + r = [np.array([1, 0, 1], dtype=dt), + np.array([0, 1, 2], dtype=dt), + np.array([1, 2, 3], dtype=dt), + np.array([2, 3, 0], dtype=dt), + np.array([3, 0, 1], dtype=dt)] + l = _multiarray_tests.test_neighborhood_iterator_oob( + x, [-1, 3], NEIGH_MODE['zero'], [-1, 1], NEIGH_MODE['one']) + assert_array_equal(l, r) + + # 2nd simple, 1d test: stacking 2 neigh iterators, mixing const padding and + # mirror padding + def test_simple_mirror(self): + dt = np.float64 + # Stacking zero on top of mirror + x = np.array([1, 2, 3], dtype=dt) + r = [np.array([0, 1, 1], dtype=dt), + np.array([1, 1, 2], dtype=dt), + np.array([1, 2, 3], dtype=dt), + np.array([2, 3, 3], dtype=dt), + np.array([3, 3, 0], dtype=dt)] + l = _multiarray_tests.test_neighborhood_iterator_oob( + x, [-1, 3], NEIGH_MODE['mirror'], [-1, 1], NEIGH_MODE['zero']) + assert_array_equal(l, r) + + # Stacking mirror on top of zero + x = np.array([1, 2, 3], dtype=dt) + r = [np.array([1, 0, 0], dtype=dt), + np.array([0, 0, 1], dtype=dt), + np.array([0, 1, 2], dtype=dt), + np.array([1, 2, 3], dtype=dt), + np.array([2, 3, 0], dtype=dt)] + l = _multiarray_tests.test_neighborhood_iterator_oob( + x, [-1, 3], NEIGH_MODE['zero'], [-2, 0], NEIGH_MODE['mirror']) + assert_array_equal(l, r) + + # Stacking mirror on top of zero: 2nd + x = np.array([1, 2, 3], dtype=dt) + r = [np.array([0, 1, 2], dtype=dt), + np.array([1, 2, 3], dtype=dt), + np.array([2, 3, 0], dtype=dt), + np.array([3, 0, 0], dtype=dt), + np.array([0, 0, 3], dtype=dt)] + l = _multiarray_tests.test_neighborhood_iterator_oob( + x, [-1, 3], NEIGH_MODE['zero'], [0, 2], NEIGH_MODE['mirror']) + assert_array_equal(l, r) + + # Stacking mirror on top of zero: 3rd + x = np.array([1, 2, 3], dtype=dt) + r = [np.array([1, 0, 0, 1, 2], dtype=dt), + np.array([0, 0, 1, 2, 3], dtype=dt), + np.array([0, 1, 2, 3, 0], dtype=dt), + np.array([1, 2, 3, 0, 0], dtype=dt), + np.array([2, 3, 0, 0, 3], dtype=dt)] + l = _multiarray_tests.test_neighborhood_iterator_oob( + x, [-1, 3], NEIGH_MODE['zero'], [-2, 2], NEIGH_MODE['mirror']) + assert_array_equal(l, r) + + # 3rd simple, 1d test: stacking 2 neigh iterators, mixing const padding and + # circular padding + def test_simple_circular(self): + dt = np.float64 + # Stacking zero on top of mirror + x = np.array([1, 2, 3], dtype=dt) + r = [np.array([0, 3, 1], dtype=dt), + np.array([3, 1, 2], dtype=dt), + np.array([1, 2, 3], dtype=dt), + np.array([2, 3, 1], dtype=dt), + np.array([3, 1, 0], dtype=dt)] + l = _multiarray_tests.test_neighborhood_iterator_oob( + x, [-1, 3], NEIGH_MODE['circular'], [-1, 1], NEIGH_MODE['zero']) + assert_array_equal(l, r) + + # Stacking mirror on top of zero + x = np.array([1, 2, 3], dtype=dt) + r = [np.array([3, 0, 0], dtype=dt), + np.array([0, 0, 1], dtype=dt), + np.array([0, 1, 2], dtype=dt), + np.array([1, 2, 3], dtype=dt), + np.array([2, 3, 0], dtype=dt)] + l = _multiarray_tests.test_neighborhood_iterator_oob( + x, [-1, 3], NEIGH_MODE['zero'], [-2, 0], NEIGH_MODE['circular']) + assert_array_equal(l, r) + + # Stacking mirror on top of zero: 2nd + x = np.array([1, 2, 3], dtype=dt) + r = [np.array([0, 1, 2], dtype=dt), + np.array([1, 2, 3], dtype=dt), + np.array([2, 3, 0], dtype=dt), + np.array([3, 0, 0], dtype=dt), + np.array([0, 0, 1], dtype=dt)] + l = _multiarray_tests.test_neighborhood_iterator_oob( + x, [-1, 3], NEIGH_MODE['zero'], [0, 2], NEIGH_MODE['circular']) + assert_array_equal(l, r) + + # Stacking mirror on top of zero: 3rd + x = np.array([1, 2, 3], dtype=dt) + r = [np.array([3, 0, 0, 1, 2], dtype=dt), + np.array([0, 0, 1, 2, 3], dtype=dt), + np.array([0, 1, 2, 3, 0], dtype=dt), + np.array([1, 2, 3, 0, 0], dtype=dt), + np.array([2, 3, 0, 0, 1], dtype=dt)] + l = _multiarray_tests.test_neighborhood_iterator_oob( + x, [-1, 3], NEIGH_MODE['zero'], [-2, 2], NEIGH_MODE['circular']) + assert_array_equal(l, r) + + # 4th simple, 1d test: stacking 2 neigh iterators, but with lower iterator + # being strictly within the array + def test_simple_strict_within(self): + dt = np.float64 + # Stacking zero on top of zero, first neighborhood strictly inside the + # array + x = np.array([1, 2, 3], dtype=dt) + r = [np.array([1, 2, 3, 0], dtype=dt)] + l = _multiarray_tests.test_neighborhood_iterator_oob( + x, [1, 1], NEIGH_MODE['zero'], [-1, 2], NEIGH_MODE['zero']) + assert_array_equal(l, r) + + # Stacking mirror on top of zero, first neighborhood strictly inside the + # array + x = np.array([1, 2, 3], dtype=dt) + r = [np.array([1, 2, 3, 3], dtype=dt)] + l = _multiarray_tests.test_neighborhood_iterator_oob( + x, [1, 1], NEIGH_MODE['zero'], [-1, 2], NEIGH_MODE['mirror']) + assert_array_equal(l, r) + + # Stacking mirror on top of zero, first neighborhood strictly inside the + # array + x = np.array([1, 2, 3], dtype=dt) + r = [np.array([1, 2, 3, 1], dtype=dt)] + l = _multiarray_tests.test_neighborhood_iterator_oob( + x, [1, 1], NEIGH_MODE['zero'], [-1, 2], NEIGH_MODE['circular']) + assert_array_equal(l, r) + +class TestWarnings: + + def test_complex_warning(self): + x = np.array([1, 2]) + y = np.array([1-2j, 1+2j]) + + with warnings.catch_warnings(): + warnings.simplefilter("error", ComplexWarning) + assert_raises(ComplexWarning, x.__setitem__, slice(None), y) + assert_equal(x, [1, 2]) + + +class TestMinScalarType: + + def test_usigned_shortshort(self): + dt = np.min_scalar_type(2**8-1) + wanted = np.dtype('uint8') + assert_equal(wanted, dt) + + def test_usigned_short(self): + dt = np.min_scalar_type(2**16-1) + wanted = np.dtype('uint16') + assert_equal(wanted, dt) + + def test_usigned_int(self): + dt = np.min_scalar_type(2**32-1) + wanted = np.dtype('uint32') + assert_equal(wanted, dt) + + def test_usigned_longlong(self): + dt = np.min_scalar_type(2**63-1) + wanted = np.dtype('uint64') + assert_equal(wanted, dt) + + def test_object(self): + dt = np.min_scalar_type(2**64) + wanted = np.dtype('O') + assert_equal(wanted, dt) + + +from numpy._core._internal import _dtype_from_pep3118 + + +class TestPEP3118Dtype: + def _check(self, spec, wanted): + dt = np.dtype(wanted) + actual = _dtype_from_pep3118(spec) + assert_equal(actual, dt, + err_msg="spec %r != dtype %r" % (spec, wanted)) + + def test_native_padding(self): + align = np.dtype('i').alignment + for j in range(8): + if j == 0: + s = 'bi' + else: + s = 'b%dxi' % j + self._check('@'+s, {'f0': ('i1', 0), + 'f1': ('i', align*(1 + j//align))}) + self._check('='+s, {'f0': ('i1', 0), + 'f1': ('i', 1+j)}) + + def test_native_padding_2(self): + # Native padding should work also for structs and sub-arrays + self._check('x3T{xi}', {'f0': (({'f0': ('i', 4)}, (3,)), 4)}) + self._check('^x3T{xi}', {'f0': (({'f0': ('i', 1)}, (3,)), 1)}) + + def test_trailing_padding(self): + # Trailing padding should be included, *and*, the item size + # should match the alignment if in aligned mode + align = np.dtype('i').alignment + size = np.dtype('i').itemsize + + def aligned(n): + return align*(1 + (n-1)//align) + + base = dict(formats=['i'], names=['f0']) + + self._check('ix', dict(itemsize=aligned(size + 1), **base)) + self._check('ixx', dict(itemsize=aligned(size + 2), **base)) + self._check('ixxx', dict(itemsize=aligned(size + 3), **base)) + self._check('ixxxx', dict(itemsize=aligned(size + 4), **base)) + self._check('i7x', dict(itemsize=aligned(size + 7), **base)) + + self._check('^ix', dict(itemsize=size + 1, **base)) + self._check('^ixx', dict(itemsize=size + 2, **base)) + self._check('^ixxx', dict(itemsize=size + 3, **base)) + self._check('^ixxxx', dict(itemsize=size + 4, **base)) + self._check('^i7x', dict(itemsize=size + 7, **base)) + + def test_native_padding_3(self): + dt = np.dtype( + [('a', 'b'), ('b', 'i'), + ('sub', np.dtype('b,i')), ('c', 'i')], + align=True) + self._check("T{b:a:xxxi:b:T{b:f0:=i:f1:}:sub:xxxi:c:}", dt) + + dt = np.dtype( + [('a', 'b'), ('b', 'i'), ('c', 'b'), ('d', 'b'), + ('e', 'b'), ('sub', np.dtype('b,i', align=True))]) + self._check("T{b:a:=i:b:b:c:b:d:b:e:T{b:f0:xxxi:f1:}:sub:}", dt) + + def test_padding_with_array_inside_struct(self): + dt = np.dtype( + [('a', 'b'), ('b', 'i'), ('c', 'b', (3,)), + ('d', 'i')], + align=True) + self._check("T{b:a:xxxi:b:3b:c:xi:d:}", dt) + + def test_byteorder_inside_struct(self): + # The byte order after @T{=i} should be '=', not '@'. + # Check this by noting the absence of native alignment. + self._check('@T{^i}xi', {'f0': ({'f0': ('i', 0)}, 0), + 'f1': ('i', 5)}) + + def test_intra_padding(self): + # Natively aligned sub-arrays may require some internal padding + align = np.dtype('i').alignment + size = np.dtype('i').itemsize + + def aligned(n): + return (align*(1 + (n-1)//align)) + + self._check('(3)T{ix}', (dict( + names=['f0'], + formats=['i'], + offsets=[0], + itemsize=aligned(size + 1) + ), (3,))) + + def test_char_vs_string(self): + dt = np.dtype('c') + self._check('c', dt) + + dt = np.dtype([('f0', 'S1', (4,)), ('f1', 'S4')]) + self._check('4c4s', dt) + + def test_field_order(self): + # gh-9053 - previously, we relied on dictionary key order + self._check("(0)I:a:f:b:", [('a', 'I', (0,)), ('b', 'f')]) + self._check("(0)I:b:f:a:", [('b', 'I', (0,)), ('a', 'f')]) + + def test_unnamed_fields(self): + self._check('ii', [('f0', 'i'), ('f1', 'i')]) + self._check('ii:f0:', [('f1', 'i'), ('f0', 'i')]) + + self._check('i', 'i') + self._check('i:f0:', [('f0', 'i')]) + + +class TestNewBufferProtocol: + """ Test PEP3118 buffers """ + + def _check_roundtrip(self, obj): + obj = np.asarray(obj) + x = memoryview(obj) + y = np.asarray(x) + y2 = np.array(x) + assert_(not y.flags.owndata) + assert_(y2.flags.owndata) + + assert_equal(y.dtype, obj.dtype) + assert_equal(y.shape, obj.shape) + assert_array_equal(obj, y) + + assert_equal(y2.dtype, obj.dtype) + assert_equal(y2.shape, obj.shape) + assert_array_equal(obj, y2) + + def test_roundtrip(self): + x = np.array([1, 2, 3, 4, 5], dtype='i4') + self._check_roundtrip(x) + + x = np.array([[1, 2], [3, 4]], dtype=np.float64) + self._check_roundtrip(x) + + x = np.zeros((3, 3, 3), dtype=np.float32)[:, 0,:] + self._check_roundtrip(x) + + dt = [('a', 'b'), + ('b', 'h'), + ('c', 'i'), + ('d', 'l'), + ('dx', 'q'), + ('e', 'B'), + ('f', 'H'), + ('g', 'I'), + ('h', 'L'), + ('hx', 'Q'), + ('i', np.single), + ('j', np.double), + ('k', np.longdouble), + ('ix', np.csingle), + ('jx', np.cdouble), + ('kx', np.clongdouble), + ('l', 'S4'), + ('m', 'U4'), + ('n', 'V3'), + ('o', '?'), + ('p', np.half), + ] + x = np.array( + [(1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + b'aaaa', 'bbbb', b'xxx', True, 1.0)], + dtype=dt) + self._check_roundtrip(x) + + x = np.array(([[1, 2], [3, 4]],), dtype=[('a', (int, (2, 2)))]) + self._check_roundtrip(x) + + x = np.array([1, 2, 3], dtype='>i2') + self._check_roundtrip(x) + + x = np.array([1, 2, 3], dtype='') + x = np.zeros(4, dtype=dt) + self._check_roundtrip(x) + + def test_roundtrip_scalar(self): + # Issue #4015. + self._check_roundtrip(0) + + def test_invalid_buffer_format(self): + # datetime64 cannot be used fully in a buffer yet + # Should be fixed in the next Numpy major release + dt = np.dtype([('a', 'uint16'), ('b', 'M8[s]')]) + a = np.empty(3, dt) + assert_raises((ValueError, BufferError), memoryview, a) + assert_raises((ValueError, BufferError), memoryview, np.array((3), 'M8[D]')) + + def test_export_simple_1d(self): + x = np.array([1, 2, 3, 4, 5], dtype='i') + y = memoryview(x) + assert_equal(y.format, 'i') + assert_equal(y.shape, (5,)) + assert_equal(y.ndim, 1) + assert_equal(y.strides, (4,)) + assert_equal(y.suboffsets, ()) + assert_equal(y.itemsize, 4) + + def test_export_simple_nd(self): + x = np.array([[1, 2], [3, 4]], dtype=np.float64) + y = memoryview(x) + assert_equal(y.format, 'd') + assert_equal(y.shape, (2, 2)) + assert_equal(y.ndim, 2) + assert_equal(y.strides, (16, 8)) + assert_equal(y.suboffsets, ()) + assert_equal(y.itemsize, 8) + + def test_export_discontiguous(self): + x = np.zeros((3, 3, 3), dtype=np.float32)[:, 0,:] + y = memoryview(x) + assert_equal(y.format, 'f') + assert_equal(y.shape, (3, 3)) + assert_equal(y.ndim, 2) + assert_equal(y.strides, (36, 4)) + assert_equal(y.suboffsets, ()) + assert_equal(y.itemsize, 4) + + def test_export_record(self): + dt = [('a', 'b'), + ('b', 'h'), + ('c', 'i'), + ('d', 'l'), + ('dx', 'q'), + ('e', 'B'), + ('f', 'H'), + ('g', 'I'), + ('h', 'L'), + ('hx', 'Q'), + ('i', np.single), + ('j', np.double), + ('k', np.longdouble), + ('ix', np.csingle), + ('jx', np.cdouble), + ('kx', np.clongdouble), + ('l', 'S4'), + ('m', 'U4'), + ('n', 'V3'), + ('o', '?'), + ('p', np.half), + ] + x = np.array( + [(1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + b'aaaa', 'bbbb', b' ', True, 1.0)], + dtype=dt) + y = memoryview(x) + assert_equal(y.shape, (1,)) + assert_equal(y.ndim, 1) + assert_equal(y.suboffsets, ()) + + sz = sum([np.dtype(b).itemsize for a, b in dt]) + if np.dtype('l').itemsize == 4: + assert_equal(y.format, 'T{b:a:=h:b:i:c:l:d:q:dx:B:e:@H:f:=I:g:L:h:Q:hx:f:i:d:j:^g:k:=Zf:ix:Zd:jx:^Zg:kx:4s:l:=4w:m:3x:n:?:o:@e:p:}') + else: + assert_equal(y.format, 'T{b:a:=h:b:i:c:q:d:q:dx:B:e:@H:f:=I:g:Q:h:Q:hx:f:i:d:j:^g:k:=Zf:ix:Zd:jx:^Zg:kx:4s:l:=4w:m:3x:n:?:o:@e:p:}') + assert_equal(y.strides, (sz,)) + assert_equal(y.itemsize, sz) + + def test_export_subarray(self): + x = np.array(([[1, 2], [3, 4]],), dtype=[('a', ('i', (2, 2)))]) + y = memoryview(x) + assert_equal(y.format, 'T{(2,2)i:a:}') + assert_equal(y.shape, ()) + assert_equal(y.ndim, 0) + assert_equal(y.strides, ()) + assert_equal(y.suboffsets, ()) + assert_equal(y.itemsize, 16) + + def test_export_endian(self): + x = np.array([1, 2, 3], dtype='>i') + y = memoryview(x) + if sys.byteorder == 'little': + assert_equal(y.format, '>i') + else: + assert_equal(y.format, 'i') + + x = np.array([1, 2, 3], dtype=' np.array(0, dtype=dt1), "type %s failed" % (dt1,)) + assert_(not 1 < np.array(0, dtype=dt1), "type %s failed" % (dt1,)) + + for dt2 in np.typecodes['AllInteger']: + assert_(np.array(1, dtype=dt1) > np.array(0, dtype=dt2), + "type %s and %s failed" % (dt1, dt2)) + assert_(not np.array(1, dtype=dt1) < np.array(0, dtype=dt2), + "type %s and %s failed" % (dt1, dt2)) + + # Unsigned integers + for dt1 in 'BHILQP': + assert_(-1 < np.array(1, dtype=dt1), "type %s failed" % (dt1,)) + assert_(not -1 > np.array(1, dtype=dt1), "type %s failed" % (dt1,)) + assert_(-1 != np.array(1, dtype=dt1), "type %s failed" % (dt1,)) + + # Unsigned vs signed + for dt2 in 'bhilqp': + assert_(np.array(1, dtype=dt1) > np.array(-1, dtype=dt2), + "type %s and %s failed" % (dt1, dt2)) + assert_(not np.array(1, dtype=dt1) < np.array(-1, dtype=dt2), + "type %s and %s failed" % (dt1, dt2)) + assert_(np.array(1, dtype=dt1) != np.array(-1, dtype=dt2), + "type %s and %s failed" % (dt1, dt2)) + + # Signed integers and floats + for dt1 in 'bhlqp' + np.typecodes['Float']: + assert_(1 > np.array(-1, dtype=dt1), "type %s failed" % (dt1,)) + assert_(not 1 < np.array(-1, dtype=dt1), "type %s failed" % (dt1,)) + assert_(-1 == np.array(-1, dtype=dt1), "type %s failed" % (dt1,)) + + for dt2 in 'bhlqp' + np.typecodes['Float']: + assert_(np.array(1, dtype=dt1) > np.array(-1, dtype=dt2), + "type %s and %s failed" % (dt1, dt2)) + assert_(not np.array(1, dtype=dt1) < np.array(-1, dtype=dt2), + "type %s and %s failed" % (dt1, dt2)) + assert_(np.array(-1, dtype=dt1) == np.array(-1, dtype=dt2), + "type %s and %s failed" % (dt1, dt2)) + + def test_to_bool_scalar(self): + assert_equal(bool(np.array([False])), False) + assert_equal(bool(np.array([True])), True) + assert_equal(bool(np.array([[42]])), True) + assert_raises(ValueError, bool, np.array([1, 2])) + + class NotConvertible: + def __bool__(self): + raise NotImplementedError + + assert_raises(NotImplementedError, bool, np.array(NotConvertible())) + assert_raises(NotImplementedError, bool, np.array([NotConvertible()])) + if IS_PYSTON: + pytest.skip("Pyston disables recursion checking") + + self_containing = np.array([None]) + self_containing[0] = self_containing + + Error = RecursionError + + assert_raises(Error, bool, self_containing) # previously stack overflow + self_containing[0] = None # resolve circular reference + + def test_to_int_scalar(self): + # gh-9972 means that these aren't always the same + int_funcs = (int, lambda x: x.__int__()) + for int_func in int_funcs: + assert_equal(int_func(np.array(0)), 0) + with assert_warns(DeprecationWarning): + assert_equal(int_func(np.array([1])), 1) + with assert_warns(DeprecationWarning): + assert_equal(int_func(np.array([[42]])), 42) + assert_raises(TypeError, int_func, np.array([1, 2])) + + # gh-9972 + assert_equal(4, int_func(np.array('4'))) + assert_equal(5, int_func(np.bytes_(b'5'))) + assert_equal(6, int_func(np.str_('6'))) + + # The delegation of int() to __trunc__ was deprecated in + # Python 3.11. + if sys.version_info < (3, 11): + class HasTrunc: + def __trunc__(self): + return 3 + assert_equal(3, int_func(np.array(HasTrunc()))) + with assert_warns(DeprecationWarning): + assert_equal(3, int_func(np.array([HasTrunc()]))) + else: + pass + + class NotConvertible: + def __int__(self): + raise NotImplementedError + assert_raises(NotImplementedError, + int_func, np.array(NotConvertible())) + with assert_warns(DeprecationWarning): + assert_raises(NotImplementedError, + int_func, np.array([NotConvertible()])) + + +class TestWhere: + def test_basic(self): + dts = [bool, np.int16, np.int32, np.int64, np.double, np.complex128, + np.longdouble, np.clongdouble] + for dt in dts: + c = np.ones(53, dtype=bool) + assert_equal(np.where( c, dt(0), dt(1)), dt(0)) + assert_equal(np.where(~c, dt(0), dt(1)), dt(1)) + assert_equal(np.where(True, dt(0), dt(1)), dt(0)) + assert_equal(np.where(False, dt(0), dt(1)), dt(1)) + d = np.ones_like(c).astype(dt) + e = np.zeros_like(d) + r = d.astype(dt) + c[7] = False + r[7] = e[7] + assert_equal(np.where(c, e, e), e) + assert_equal(np.where(c, d, e), r) + assert_equal(np.where(c, d, e[0]), r) + assert_equal(np.where(c, d[0], e), r) + assert_equal(np.where(c[::2], d[::2], e[::2]), r[::2]) + assert_equal(np.where(c[1::2], d[1::2], e[1::2]), r[1::2]) + assert_equal(np.where(c[::3], d[::3], e[::3]), r[::3]) + assert_equal(np.where(c[1::3], d[1::3], e[1::3]), r[1::3]) + assert_equal(np.where(c[::-2], d[::-2], e[::-2]), r[::-2]) + assert_equal(np.where(c[::-3], d[::-3], e[::-3]), r[::-3]) + assert_equal(np.where(c[1::-3], d[1::-3], e[1::-3]), r[1::-3]) + + @pytest.mark.skipif(IS_WASM, reason="no wasm fp exception support") + def test_exotic(self): + # object + assert_array_equal(np.where(True, None, None), np.array(None)) + # zero sized + m = np.array([], dtype=bool).reshape(0, 3) + b = np.array([], dtype=np.float64).reshape(0, 3) + assert_array_equal(np.where(m, 0, b), np.array([]).reshape(0, 3)) + + # object cast + d = np.array([-1.34, -0.16, -0.54, -0.31, -0.08, -0.95, 0.000, 0.313, + 0.547, -0.18, 0.876, 0.236, 1.969, 0.310, 0.699, 1.013, + 1.267, 0.229, -1.39, 0.487]) + nan = float('NaN') + e = np.array(['5z', '0l', nan, 'Wz', nan, nan, 'Xq', 'cs', nan, nan, + 'QN', nan, nan, 'Fd', nan, nan, 'kp', nan, '36', 'i1'], + dtype=object) + m = np.array([0, 0, 1, 0, 1, 1, 0, 0, 1, 1, + 0, 1, 1, 0, 1, 1, 0, 1, 0, 0], dtype=bool) + + r = e[:] + r[np.where(m)] = d[np.where(m)] + assert_array_equal(np.where(m, d, e), r) + + r = e[:] + r[np.where(~m)] = d[np.where(~m)] + assert_array_equal(np.where(m, e, d), r) + + assert_array_equal(np.where(m, e, e), e) + + # minimal dtype result with NaN scalar (e.g required by pandas) + d = np.array([1., 2.], dtype=np.float32) + e = float('NaN') + assert_equal(np.where(True, d, e).dtype, np.float32) + e = float('Infinity') + assert_equal(np.where(True, d, e).dtype, np.float32) + e = float('-Infinity') + assert_equal(np.where(True, d, e).dtype, np.float32) + # With NEP 50 adopted, the float will overflow here: + e = float(1e150) + with pytest.warns(RuntimeWarning, match="overflow"): + res = np.where(True, d, e) + assert res.dtype == np.float32 + + def test_ndim(self): + c = [True, False] + a = np.zeros((2, 25)) + b = np.ones((2, 25)) + r = np.where(np.array(c)[:,np.newaxis], a, b) + assert_array_equal(r[0], a[0]) + assert_array_equal(r[1], b[0]) + + a = a.T + b = b.T + r = np.where(c, a, b) + assert_array_equal(r[:,0], a[:,0]) + assert_array_equal(r[:,1], b[:,0]) + + def test_dtype_mix(self): + c = np.array([False, True, False, False, False, False, True, False, + False, False, True, False]) + a = np.uint32(1) + b = np.array([5., 0., 3., 2., -1., -4., 0., -10., 10., 1., 0., 3.], + dtype=np.float64) + r = np.array([5., 1., 3., 2., -1., -4., 1., -10., 10., 1., 1., 3.], + dtype=np.float64) + assert_equal(np.where(c, a, b), r) + + a = a.astype(np.float32) + b = b.astype(np.int64) + assert_equal(np.where(c, a, b), r) + + # non bool mask + c = c.astype(int) + c[c != 0] = 34242324 + assert_equal(np.where(c, a, b), r) + # invert + tmpmask = c != 0 + c[c == 0] = 41247212 + c[tmpmask] = 0 + assert_equal(np.where(c, b, a), r) + + def test_foreign(self): + c = np.array([False, True, False, False, False, False, True, False, + False, False, True, False]) + r = np.array([5., 1., 3., 2., -1., -4., 1., -10., 10., 1., 1., 3.], + dtype=np.float64) + a = np.ones(1, dtype='>i4') + b = np.array([5., 0., 3., 2., -1., -4., 0., -10., 10., 1., 0., 3.], + dtype=np.float64) + assert_equal(np.where(c, a, b), r) + + b = b.astype('>f8') + assert_equal(np.where(c, a, b), r) + + a = a.astype('i4') + assert_equal(np.where(c, a, b), r) + + def test_error(self): + c = [True, True] + a = np.ones((4, 5)) + b = np.ones((5, 5)) + assert_raises(ValueError, np.where, c, a, a) + assert_raises(ValueError, np.where, c[0], a, b) + + def test_string(self): + # gh-4778 check strings are properly filled with nulls + a = np.array("abc") + b = np.array("x" * 753) + assert_equal(np.where(True, a, b), "abc") + assert_equal(np.where(False, b, a), "abc") + + # check native datatype sized strings + a = np.array("abcd") + b = np.array("x" * 8) + assert_equal(np.where(True, a, b), "abcd") + assert_equal(np.where(False, b, a), "abcd") + + def test_empty_result(self): + # pass empty where result through an assignment which reads the data of + # empty arrays, error detectable with valgrind, see gh-8922 + x = np.zeros((1, 1)) + ibad = np.vstack(np.where(x == 99.)) + assert_array_equal(ibad, + np.atleast_2d(np.array([[],[]], dtype=np.intp))) + + def test_largedim(self): + # invalid read regression gh-9304 + shape = [10, 2, 3, 4, 5, 6] + np.random.seed(2) + array = np.random.rand(*shape) + + for i in range(10): + benchmark = array.nonzero() + result = array.nonzero() + assert_array_equal(benchmark, result) + + def test_kwargs(self): + a = np.zeros(1) + with assert_raises(TypeError): + np.where(a, x=a, y=a) + + +if not IS_PYPY: + # sys.getsizeof() is not valid on PyPy + class TestSizeOf: + + def test_empty_array(self): + x = np.array([]) + assert_(sys.getsizeof(x) > 0) + + def check_array(self, dtype): + elem_size = dtype(0).itemsize + + for length in [10, 50, 100, 500]: + x = np.arange(length, dtype=dtype) + assert_(sys.getsizeof(x) > length * elem_size) + + def test_array_int32(self): + self.check_array(np.int32) + + def test_array_int64(self): + self.check_array(np.int64) + + def test_array_float32(self): + self.check_array(np.float32) + + def test_array_float64(self): + self.check_array(np.float64) + + def test_view(self): + d = np.ones(100) + assert_(sys.getsizeof(d[...]) < sys.getsizeof(d)) + + def test_reshape(self): + d = np.ones(100) + assert_(sys.getsizeof(d) < sys.getsizeof(d.reshape(100, 1, 1).copy())) + + @_no_tracing + def test_resize(self): + d = np.ones(100) + old = sys.getsizeof(d) + d.resize(50) + assert_(old > sys.getsizeof(d)) + d.resize(150) + assert_(old < sys.getsizeof(d)) + + @pytest.mark.parametrize("dtype", ["u4,f4", "u4,O"]) + def test_resize_structured(self, dtype): + a = np.array([(0, 0.0) for i in range(5)], dtype=dtype) + a.resize(1000) + assert_array_equal(a, np.zeros(1000, dtype=dtype)) + + def test_error(self): + d = np.ones(100) + assert_raises(TypeError, d.__sizeof__, "a") + + +class TestHashing: + + def test_arrays_not_hashable(self): + x = np.ones(3) + assert_raises(TypeError, hash, x) + + def test_collections_hashable(self): + x = np.array([]) + assert_(not isinstance(x, collections.abc.Hashable)) + + +class TestArrayPriority: + # This will go away when __array_priority__ is settled, meanwhile + # it serves to check unintended changes. + op = operator + binary_ops = [ + op.pow, op.add, op.sub, op.mul, op.floordiv, op.truediv, op.mod, + op.and_, op.or_, op.xor, op.lshift, op.rshift, op.mod, op.gt, + op.ge, op.lt, op.le, op.ne, op.eq + ] + + class Foo(np.ndarray): + __array_priority__ = 100. + + def __new__(cls, *args, **kwargs): + return np.array(*args, **kwargs).view(cls) + + class Bar(np.ndarray): + __array_priority__ = 101. + + def __new__(cls, *args, **kwargs): + return np.array(*args, **kwargs).view(cls) + + class Other: + __array_priority__ = 1000. + + def _all(self, other): + return self.__class__() + + __add__ = __radd__ = _all + __sub__ = __rsub__ = _all + __mul__ = __rmul__ = _all + __pow__ = __rpow__ = _all + __div__ = __rdiv__ = _all + __mod__ = __rmod__ = _all + __truediv__ = __rtruediv__ = _all + __floordiv__ = __rfloordiv__ = _all + __and__ = __rand__ = _all + __xor__ = __rxor__ = _all + __or__ = __ror__ = _all + __lshift__ = __rlshift__ = _all + __rshift__ = __rrshift__ = _all + __eq__ = _all + __ne__ = _all + __gt__ = _all + __ge__ = _all + __lt__ = _all + __le__ = _all + + def test_ndarray_subclass(self): + a = np.array([1, 2]) + b = self.Bar([1, 2]) + for f in self.binary_ops: + msg = repr(f) + assert_(isinstance(f(a, b), self.Bar), msg) + assert_(isinstance(f(b, a), self.Bar), msg) + + def test_ndarray_other(self): + a = np.array([1, 2]) + b = self.Other() + for f in self.binary_ops: + msg = repr(f) + assert_(isinstance(f(a, b), self.Other), msg) + assert_(isinstance(f(b, a), self.Other), msg) + + def test_subclass_subclass(self): + a = self.Foo([1, 2]) + b = self.Bar([1, 2]) + for f in self.binary_ops: + msg = repr(f) + assert_(isinstance(f(a, b), self.Bar), msg) + assert_(isinstance(f(b, a), self.Bar), msg) + + def test_subclass_other(self): + a = self.Foo([1, 2]) + b = self.Other() + for f in self.binary_ops: + msg = repr(f) + assert_(isinstance(f(a, b), self.Other), msg) + assert_(isinstance(f(b, a), self.Other), msg) + + +class TestBytestringArrayNonzero: + + def test_empty_bstring_array_is_falsey(self): + assert_(not np.array([''], dtype=str)) + + def test_whitespace_bstring_array_is_truthy(self): + a = np.array(['spam'], dtype=str) + a[0] = ' \0\0' + assert_(a) + + def test_all_null_bstring_array_is_falsey(self): + a = np.array(['spam'], dtype=str) + a[0] = '\0\0\0\0' + assert_(not a) + + def test_null_inside_bstring_array_is_truthy(self): + a = np.array(['spam'], dtype=str) + a[0] = ' \0 \0' + assert_(a) + + +class TestUnicodeEncoding: + """ + Tests for encoding related bugs, such as UCS2 vs UCS4, round-tripping + issues, etc + """ + def test_round_trip(self): + """ Tests that GETITEM, SETITEM, and PyArray_Scalar roundtrip """ + # gh-15363 + arr = np.zeros(shape=(), dtype="U1") + for i in range(1, sys.maxunicode + 1): + expected = chr(i) + arr[()] = expected + assert arr[()] == expected + assert arr.item() == expected + + def test_assign_scalar(self): + # gh-3258 + l = np.array(['aa', 'bb']) + l[:] = np.str_('cc') + assert_equal(l, ['cc', 'cc']) + + def test_fill_scalar(self): + # gh-7227 + l = np.array(['aa', 'bb']) + l.fill(np.str_('cc')) + assert_equal(l, ['cc', 'cc']) + + +class TestUnicodeArrayNonzero: + + def test_empty_ustring_array_is_falsey(self): + assert_(not np.array([''], dtype=np.str_)) + + def test_whitespace_ustring_array_is_truthy(self): + a = np.array(['eggs'], dtype=np.str_) + a[0] = ' \0\0' + assert_(a) + + def test_all_null_ustring_array_is_falsey(self): + a = np.array(['eggs'], dtype=np.str_) + a[0] = '\0\0\0\0' + assert_(not a) + + def test_null_inside_ustring_array_is_truthy(self): + a = np.array(['eggs'], dtype=np.str_) + a[0] = ' \0 \0' + assert_(a) + + +class TestFormat: + + def test_0d(self): + a = np.array(np.pi) + assert_equal('{:0.3g}'.format(a), '3.14') + assert_equal('{:0.3g}'.format(a[()]), '3.14') + + def test_1d_no_format(self): + a = np.array([np.pi]) + assert_equal('{}'.format(a), str(a)) + + def test_1d_format(self): + # until gh-5543, ensure that the behaviour matches what it used to be + a = np.array([np.pi]) + assert_raises(TypeError, '{:30}'.format, a) + + +from numpy.testing import IS_PYPY + + +class TestCTypes: + + def test_ctypes_is_available(self): + test_arr = np.array([[1, 2, 3], [4, 5, 6]]) + + assert_equal(ctypes, test_arr.ctypes._ctypes) + assert_equal(tuple(test_arr.ctypes.shape), (2, 3)) + + def test_ctypes_is_not_available(self): + from numpy._core import _internal + _internal.ctypes = None + try: + test_arr = np.array([[1, 2, 3], [4, 5, 6]]) + + assert_(isinstance(test_arr.ctypes._ctypes, + _internal._missing_ctypes)) + assert_equal(tuple(test_arr.ctypes.shape), (2, 3)) + finally: + _internal.ctypes = ctypes + + def _make_readonly(x): + x.flags.writeable = False + return x + + @pytest.mark.parametrize('arr', [ + np.array([1, 2, 3]), + np.array([['one', 'two'], ['three', 'four']]), + np.array((1, 2), dtype='i4,i4'), + np.zeros((2,), dtype= + np.dtype(dict( + formats=['2, [44, 55]) + assert_equal(a, np.array([[0, 44], [1, 55], [2, 44]])) + # hit one of the failing paths + assert_raises(ValueError, np.place, a, a>20, []) + + def test_put_noncontiguous(self): + a = np.arange(6).reshape(2, 3).T # force non-c-contiguous + np.put(a, [0, 2], [44, 55]) + assert_equal(a, np.array([[44, 3], [55, 4], [2, 5]])) + + def test_putmask_noncontiguous(self): + a = np.arange(6).reshape(2, 3).T # force non-c-contiguous + # uses arr_putmask + np.putmask(a, a>2, a**2) + assert_equal(a, np.array([[0, 9], [1, 16], [2, 25]])) + + def test_take_mode_raise(self): + a = np.arange(6, dtype='int') + out = np.empty(2, dtype='int') + np.take(a, [0, 2], out=out, mode='raise') + assert_equal(out, np.array([0, 2])) + + def test_choose_mod_raise(self): + a = np.array([[1, 0, 1], [0, 1, 0], [1, 0, 1]]) + out = np.empty((3,3), dtype='int') + choices = [-10, 10] + np.choose(a, choices, out=out, mode='raise') + assert_equal(out, np.array([[ 10, -10, 10], + [-10, 10, -10], + [ 10, -10, 10]])) + + def test_flatiter__array__(self): + a = np.arange(9).reshape(3, 3) + b = a.T.flat + c = b.__array__() + # triggers the WRITEBACKIFCOPY resolution, assuming refcount semantics + del c + + def test_dot_out(self): + # if HAVE_CBLAS, will use WRITEBACKIFCOPY + a = np.arange(9, dtype=float).reshape(3, 3) + b = np.dot(a, a, out=a) + assert_equal(b, np.array([[15, 18, 21], [42, 54, 66], [69, 90, 111]])) + + def test_view_assign(self): + from numpy._core._multiarray_tests import ( + npy_create_writebackifcopy, npy_resolve + ) + + arr = np.arange(9).reshape(3, 3).T + arr_wb = npy_create_writebackifcopy(arr) + assert_(arr_wb.flags.writebackifcopy) + assert_(arr_wb.base is arr) + arr_wb[...] = -100 + npy_resolve(arr_wb) + # arr changes after resolve, even though we assigned to arr_wb + assert_equal(arr, -100) + # after resolve, the two arrays no longer reference each other + assert_(arr_wb.ctypes.data != 0) + assert_equal(arr_wb.base, None) + # assigning to arr_wb does not get transferred to arr + arr_wb[...] = 100 + assert_equal(arr, -100) + + @pytest.mark.leaks_references( + reason="increments self in dealloc; ignore since deprecated path.") + def test_dealloc_warning(self): + with suppress_warnings() as sup: + sup.record(RuntimeWarning) + arr = np.arange(9).reshape(3, 3) + v = arr.T + _multiarray_tests.npy_abuse_writebackifcopy(v) + assert len(sup.log) == 1 + + def test_view_discard_refcount(self): + from numpy._core._multiarray_tests import ( + npy_create_writebackifcopy, npy_discard + ) + + arr = np.arange(9).reshape(3, 3).T + orig = arr.copy() + if HAS_REFCOUNT: + arr_cnt = sys.getrefcount(arr) + arr_wb = npy_create_writebackifcopy(arr) + assert_(arr_wb.flags.writebackifcopy) + assert_(arr_wb.base is arr) + arr_wb[...] = -100 + npy_discard(arr_wb) + # arr remains unchanged after discard + assert_equal(arr, orig) + # after discard, the two arrays no longer reference each other + assert_(arr_wb.ctypes.data != 0) + assert_equal(arr_wb.base, None) + if HAS_REFCOUNT: + assert_equal(arr_cnt, sys.getrefcount(arr)) + # assigning to arr_wb does not get transferred to arr + arr_wb[...] = 100 + assert_equal(arr, orig) + + +class TestArange: + def test_infinite(self): + assert_raises_regex( + ValueError, "size exceeded", + np.arange, 0, np.inf + ) + + def test_nan_step(self): + assert_raises_regex( + ValueError, "cannot compute length", + np.arange, 0, 1, np.nan + ) + + def test_zero_step(self): + assert_raises(ZeroDivisionError, np.arange, 0, 10, 0) + assert_raises(ZeroDivisionError, np.arange, 0.0, 10.0, 0.0) + + # empty range + assert_raises(ZeroDivisionError, np.arange, 0, 0, 0) + assert_raises(ZeroDivisionError, np.arange, 0.0, 0.0, 0.0) + + def test_require_range(self): + assert_raises(TypeError, np.arange) + assert_raises(TypeError, np.arange, step=3) + assert_raises(TypeError, np.arange, dtype='int64') + assert_raises(TypeError, np.arange, start=4) + + def test_start_stop_kwarg(self): + keyword_stop = np.arange(stop=3) + keyword_zerotostop = np.arange(0, stop=3) + keyword_start_stop = np.arange(start=3, stop=9) + + assert len(keyword_stop) == 3 + assert len(keyword_zerotostop) == 3 + assert len(keyword_start_stop) == 6 + assert_array_equal(keyword_stop, keyword_zerotostop) + + def test_arange_booleans(self): + # Arange makes some sense for booleans and works up to length 2. + # But it is weird since `arange(2, 4, dtype=bool)` works. + # Arguably, much or all of this could be deprecated/removed. + res = np.arange(False, dtype=bool) + assert_array_equal(res, np.array([], dtype="bool")) + + res = np.arange(True, dtype="bool") + assert_array_equal(res, [False]) + + res = np.arange(2, dtype="bool") + assert_array_equal(res, [False, True]) + + # This case is especially weird, but drops out without special case: + res = np.arange(6, 8, dtype="bool") + assert_array_equal(res, [True, True]) + + with pytest.raises(TypeError): + np.arange(3, dtype="bool") + + @pytest.mark.parametrize("dtype", ["S3", "U", "5i"]) + def test_rejects_bad_dtypes(self, dtype): + dtype = np.dtype(dtype) + DType_name = re.escape(str(type(dtype))) + with pytest.raises(TypeError, + match=rf"arange\(\) not supported for inputs .* {DType_name}"): + np.arange(2, dtype=dtype) + + def test_rejects_strings(self): + # Explicitly test error for strings which may call "b" - "a": + DType_name = re.escape(str(type(np.array("a").dtype))) + with pytest.raises(TypeError, + match=rf"arange\(\) not supported for inputs .* {DType_name}"): + np.arange("a", "b") + + def test_byteswapped(self): + res_be = np.arange(1, 1000, dtype=">i4") + res_le = np.arange(1, 1000, dtype="i4" + assert res_le.dtype == " arr2 + + +@pytest.mark.parametrize("op", [ + operator.eq, operator.ne, operator.le, operator.lt, operator.ge, + operator.gt]) +def test_comparisons_forwards_error(op): + class NotArray: + def __array__(self, dtype=None, copy=None): + raise TypeError("run you fools") + + with pytest.raises(TypeError, match="run you fools"): + op(np.arange(2), NotArray()) + + with pytest.raises(TypeError, match="run you fools"): + op(NotArray(), np.arange(2)) + + +def test_richcompare_scalar_boolean_singleton_return(): + # These are currently guaranteed to be the boolean singletons, but maybe + # returning NumPy booleans would also be OK: + assert (np.array(0) == "a") is False + assert (np.array(0) != "a") is True + assert (np.int16(0) == "a") is False + assert (np.int16(0) != "a") is True + + +@pytest.mark.parametrize("op", [ + operator.eq, operator.ne, operator.le, operator.lt, operator.ge, + operator.gt]) +def test_ragged_comparison_fails(op): + # This needs to convert the internal array to True/False, which fails: + a = np.array([1, np.array([1, 2, 3])], dtype=object) + b = np.array([1, np.array([1, 2, 3])], dtype=object) + + with pytest.raises(ValueError, match="The truth value.*ambiguous"): + op(a, b) + + +@pytest.mark.parametrize( + ["fun", "npfun"], + [ + (_multiarray_tests.npy_cabs, np.absolute), + (_multiarray_tests.npy_carg, np.angle) + ] +) +@pytest.mark.parametrize("x", [1, np.inf, -np.inf, np.nan]) +@pytest.mark.parametrize("y", [1, np.inf, -np.inf, np.nan]) +@pytest.mark.parametrize("test_dtype", np.complexfloating.__subclasses__()) +def test_npymath_complex(fun, npfun, x, y, test_dtype): + # Smoketest npymath functions + z = test_dtype(complex(x, y)) + with np.errstate(invalid='ignore'): + # Fallback implementations may emit a warning for +-inf (see gh-24876): + # RuntimeWarning: invalid value encountered in absolute + got = fun(z) + expected = npfun(z) + assert_allclose(got, expected) + + +def test_npymath_real(): + # Smoketest npymath functions + from numpy._core._multiarray_tests import ( + npy_log10, npy_cosh, npy_sinh, npy_tan, npy_tanh) + + funcs = {npy_log10: np.log10, + npy_cosh: np.cosh, + npy_sinh: np.sinh, + npy_tan: np.tan, + npy_tanh: np.tanh} + vals = (1, np.inf, -np.inf, np.nan) + types = (np.float32, np.float64, np.longdouble) + + with np.errstate(all='ignore'): + for fun, npfun in funcs.items(): + for x, t in itertools.product(vals, types): + z = t(x) + got = fun(z) + expected = npfun(z) + assert_allclose(got, expected) + +def test_uintalignment_and_alignment(): + # alignment code needs to satisfy these requirements: + # 1. numpy structs match C struct layout + # 2. ufuncs/casting is safe wrt to aligned access + # 3. copy code is safe wrt to "uint alidned" access + # + # Complex types are the main problem, whose alignment may not be the same + # as their "uint alignment". + # + # This test might only fail on certain platforms, where uint64 alignment is + # not equal to complex64 alignment. The second 2 tests will only fail + # for DEBUG=1. + + d1 = np.dtype('u1,c8', align=True) + d2 = np.dtype('u4,c8', align=True) + d3 = np.dtype({'names': ['a', 'b'], 'formats': ['u1', d1]}, align=True) + + assert_equal(np.zeros(1, dtype=d1)['f1'].flags['ALIGNED'], True) + assert_equal(np.zeros(1, dtype=d2)['f1'].flags['ALIGNED'], True) + assert_equal(np.zeros(1, dtype='u1,c8')['f1'].flags['ALIGNED'], False) + + # check that C struct matches numpy struct size + s = _multiarray_tests.get_struct_alignments() + for d, (alignment, size) in zip([d1,d2,d3], s): + assert_equal(d.alignment, alignment) + assert_equal(d.itemsize, size) + + # check that ufuncs don't complain in debug mode + # (this is probably OK if the aligned flag is true above) + src = np.zeros((2,2), dtype=d1)['f1'] # 4-byte aligned, often + np.exp(src) # assert fails? + + # check that copy code doesn't complain in debug mode + dst = np.zeros((2,2), dtype='c8') + dst[:,1] = src[:,1] # assert in lowlevel_strided_loops fails? + +class TestAlignment: + # adapted from scipy._lib.tests.test__util.test__aligned_zeros + # Checks that unusual memory alignments don't trip up numpy. + + def check(self, shape, dtype, order, align): + err_msg = repr((shape, dtype, order, align)) + x = _aligned_zeros(shape, dtype, order, align=align) + if align is None: + align = np.dtype(dtype).alignment + assert_equal(x.__array_interface__['data'][0] % align, 0) + if hasattr(shape, '__len__'): + assert_equal(x.shape, shape, err_msg) + else: + assert_equal(x.shape, (shape,), err_msg) + assert_equal(x.dtype, dtype) + if order == "C": + assert_(x.flags.c_contiguous, err_msg) + elif order == "F": + if x.size > 0: + assert_(x.flags.f_contiguous, err_msg) + elif order is None: + assert_(x.flags.c_contiguous, err_msg) + else: + raise ValueError() + + def test_various_alignments(self): + for align in [1, 2, 3, 4, 8, 12, 16, 32, 64, None]: + for n in [0, 1, 3, 11]: + for order in ["C", "F", None]: + for dtype in list(np.typecodes["All"]) + ['i4,i4,i4']: + if dtype == 'O': + # object dtype can't be misaligned + continue + for shape in [n, (1, 2, 3, n)]: + self.check(shape, np.dtype(dtype), order, align) + + def test_strided_loop_alignments(self): + # particularly test that complex64 and float128 use right alignment + # code-paths, since these are particularly problematic. It is useful to + # turn on USE_DEBUG for this test, so lowlevel-loop asserts are run. + for align in [1, 2, 4, 8, 12, 16, None]: + xf64 = _aligned_zeros(3, np.float64) + + xc64 = _aligned_zeros(3, np.complex64, align=align) + xf128 = _aligned_zeros(3, np.longdouble, align=align) + + # test casting, both to and from misaligned + with suppress_warnings() as sup: + sup.filter(ComplexWarning, "Casting complex values") + xc64.astype('f8') + xf64.astype(np.complex64) + test = xc64 + xf64 + + xf128.astype('f8') + xf64.astype(np.longdouble) + test = xf128 + xf64 + + test = xf128 + xc64 + + # test copy, both to and from misaligned + # contig copy + xf64[:] = xf64.copy() + xc64[:] = xc64.copy() + xf128[:] = xf128.copy() + # strided copy + xf64[::2] = xf64[::2].copy() + xc64[::2] = xc64[::2].copy() + xf128[::2] = xf128[::2].copy() + +def test_getfield(): + a = np.arange(32, dtype='uint16') + if sys.byteorder == 'little': + i = 0 + j = 1 + else: + i = 1 + j = 0 + b = a.getfield('int8', i) + assert_equal(b, a) + b = a.getfield('int8', j) + assert_equal(b, 0) + pytest.raises(ValueError, a.getfield, 'uint8', -1) + pytest.raises(ValueError, a.getfield, 'uint8', 16) + pytest.raises(ValueError, a.getfield, 'uint64', 0) + + +class TestViewDtype: + """ + Verify that making a view of a non-contiguous array works as expected. + """ + def test_smaller_dtype_multiple(self): + # x is non-contiguous + x = np.arange(10, dtype=' rc_a) + assert_(sys.getrefcount(dt) > rc_dt) + # del 'it' + it = None + assert_equal(sys.getrefcount(a), rc_a) + assert_equal(sys.getrefcount(dt), rc_dt) + + # With a copy + a = arange(6, dtype='f4') + dt = np.dtype('f4') + rc_a = sys.getrefcount(a) + rc_dt = sys.getrefcount(dt) + it = nditer(a, [], + [['readwrite']], + op_dtypes=[dt]) + rc2_a = sys.getrefcount(a) + rc2_dt = sys.getrefcount(dt) + it2 = it.copy() + assert_(sys.getrefcount(a) > rc2_a) + if sys.version_info < (3, 13): + # np.dtype('f4') is immortal after Python 3.13 + assert_(sys.getrefcount(dt) > rc2_dt) + it = None + assert_equal(sys.getrefcount(a), rc2_a) + assert_equal(sys.getrefcount(dt), rc2_dt) + it2 = None + assert_equal(sys.getrefcount(a), rc_a) + assert_equal(sys.getrefcount(dt), rc_dt) + + del it2 # avoid pyflakes unused variable warning + +def test_iter_best_order(): + # The iterator should always find the iteration order + # with increasing memory addresses + + # Test the ordering for 1-D to 5-D shapes + for shape in [(5,), (3, 4), (2, 3, 4), (2, 3, 4, 3), (2, 3, 2, 2, 3)]: + a = arange(np.prod(shape)) + # Test each combination of positive and negative strides + for dirs in range(2**len(shape)): + dirs_index = [slice(None)]*len(shape) + for bit in range(len(shape)): + if ((2**bit) & dirs): + dirs_index[bit] = slice(None, None, -1) + dirs_index = tuple(dirs_index) + + aview = a.reshape(shape)[dirs_index] + # C-order + i = nditer(aview, [], [['readonly']]) + assert_equal([x for x in i], a) + # Fortran-order + i = nditer(aview.T, [], [['readonly']]) + assert_equal([x for x in i], a) + # Other order + if len(shape) > 2: + i = nditer(aview.swapaxes(0, 1), [], [['readonly']]) + assert_equal([x for x in i], a) + +def test_iter_c_order(): + # Test forcing C order + + # Test the ordering for 1-D to 5-D shapes + for shape in [(5,), (3, 4), (2, 3, 4), (2, 3, 4, 3), (2, 3, 2, 2, 3)]: + a = arange(np.prod(shape)) + # Test each combination of positive and negative strides + for dirs in range(2**len(shape)): + dirs_index = [slice(None)]*len(shape) + for bit in range(len(shape)): + if ((2**bit) & dirs): + dirs_index[bit] = slice(None, None, -1) + dirs_index = tuple(dirs_index) + + aview = a.reshape(shape)[dirs_index] + # C-order + i = nditer(aview, order='C') + assert_equal([x for x in i], aview.ravel(order='C')) + # Fortran-order + i = nditer(aview.T, order='C') + assert_equal([x for x in i], aview.T.ravel(order='C')) + # Other order + if len(shape) > 2: + i = nditer(aview.swapaxes(0, 1), order='C') + assert_equal([x for x in i], + aview.swapaxes(0, 1).ravel(order='C')) + +def test_iter_f_order(): + # Test forcing F order + + # Test the ordering for 1-D to 5-D shapes + for shape in [(5,), (3, 4), (2, 3, 4), (2, 3, 4, 3), (2, 3, 2, 2, 3)]: + a = arange(np.prod(shape)) + # Test each combination of positive and negative strides + for dirs in range(2**len(shape)): + dirs_index = [slice(None)]*len(shape) + for bit in range(len(shape)): + if ((2**bit) & dirs): + dirs_index[bit] = slice(None, None, -1) + dirs_index = tuple(dirs_index) + + aview = a.reshape(shape)[dirs_index] + # C-order + i = nditer(aview, order='F') + assert_equal([x for x in i], aview.ravel(order='F')) + # Fortran-order + i = nditer(aview.T, order='F') + assert_equal([x for x in i], aview.T.ravel(order='F')) + # Other order + if len(shape) > 2: + i = nditer(aview.swapaxes(0, 1), order='F') + assert_equal([x for x in i], + aview.swapaxes(0, 1).ravel(order='F')) + +def test_iter_c_or_f_order(): + # Test forcing any contiguous (C or F) order + + # Test the ordering for 1-D to 5-D shapes + for shape in [(5,), (3, 4), (2, 3, 4), (2, 3, 4, 3), (2, 3, 2, 2, 3)]: + a = arange(np.prod(shape)) + # Test each combination of positive and negative strides + for dirs in range(2**len(shape)): + dirs_index = [slice(None)]*len(shape) + for bit in range(len(shape)): + if ((2**bit) & dirs): + dirs_index[bit] = slice(None, None, -1) + dirs_index = tuple(dirs_index) + + aview = a.reshape(shape)[dirs_index] + # C-order + i = nditer(aview, order='A') + assert_equal([x for x in i], aview.ravel(order='A')) + # Fortran-order + i = nditer(aview.T, order='A') + assert_equal([x for x in i], aview.T.ravel(order='A')) + # Other order + if len(shape) > 2: + i = nditer(aview.swapaxes(0, 1), order='A') + assert_equal([x for x in i], + aview.swapaxes(0, 1).ravel(order='A')) + +def test_nditer_multi_index_set(): + # Test the multi_index set + a = np.arange(6).reshape(2, 3) + it = np.nditer(a, flags=['multi_index']) + + # Removes the iteration on two first elements of a[0] + it.multi_index = (0, 2,) + + assert_equal([i for i in it], [2, 3, 4, 5]) + +@pytest.mark.skipif(not HAS_REFCOUNT, reason="Python lacks refcounts") +def test_nditer_multi_index_set_refcount(): + # Test if the reference count on index variable is decreased + + index = 0 + i = np.nditer(np.array([111, 222, 333, 444]), flags=['multi_index']) + + start_count = sys.getrefcount(index) + i.multi_index = (index,) + end_count = sys.getrefcount(index) + + assert_equal(start_count, end_count) + +def test_iter_best_order_multi_index_1d(): + # The multi-indices should be correct with any reordering + + a = arange(4) + # 1D order + i = nditer(a, ['multi_index'], [['readonly']]) + assert_equal(iter_multi_index(i), [(0,), (1,), (2,), (3,)]) + # 1D reversed order + i = nditer(a[::-1], ['multi_index'], [['readonly']]) + assert_equal(iter_multi_index(i), [(3,), (2,), (1,), (0,)]) + +def test_iter_best_order_multi_index_2d(): + # The multi-indices should be correct with any reordering + + a = arange(6) + # 2D C-order + i = nditer(a.reshape(2, 3), ['multi_index'], [['readonly']]) + assert_equal(iter_multi_index(i), [(0, 0), (0, 1), (0, 2), (1, 0), (1, 1), (1, 2)]) + # 2D Fortran-order + i = nditer(a.reshape(2, 3).copy(order='F'), ['multi_index'], [['readonly']]) + assert_equal(iter_multi_index(i), [(0, 0), (1, 0), (0, 1), (1, 1), (0, 2), (1, 2)]) + # 2D reversed C-order + i = nditer(a.reshape(2, 3)[::-1], ['multi_index'], [['readonly']]) + assert_equal(iter_multi_index(i), [(1, 0), (1, 1), (1, 2), (0, 0), (0, 1), (0, 2)]) + i = nditer(a.reshape(2, 3)[:, ::-1], ['multi_index'], [['readonly']]) + assert_equal(iter_multi_index(i), [(0, 2), (0, 1), (0, 0), (1, 2), (1, 1), (1, 0)]) + i = nditer(a.reshape(2, 3)[::-1, ::-1], ['multi_index'], [['readonly']]) + assert_equal(iter_multi_index(i), [(1, 2), (1, 1), (1, 0), (0, 2), (0, 1), (0, 0)]) + # 2D reversed Fortran-order + i = nditer(a.reshape(2, 3).copy(order='F')[::-1], ['multi_index'], [['readonly']]) + assert_equal(iter_multi_index(i), [(1, 0), (0, 0), (1, 1), (0, 1), (1, 2), (0, 2)]) + i = nditer(a.reshape(2, 3).copy(order='F')[:, ::-1], + ['multi_index'], [['readonly']]) + assert_equal(iter_multi_index(i), [(0, 2), (1, 2), (0, 1), (1, 1), (0, 0), (1, 0)]) + i = nditer(a.reshape(2, 3).copy(order='F')[::-1, ::-1], + ['multi_index'], [['readonly']]) + assert_equal(iter_multi_index(i), [(1, 2), (0, 2), (1, 1), (0, 1), (1, 0), (0, 0)]) + +def test_iter_best_order_multi_index_3d(): + # The multi-indices should be correct with any reordering + + a = arange(12) + # 3D C-order + i = nditer(a.reshape(2, 3, 2), ['multi_index'], [['readonly']]) + assert_equal(iter_multi_index(i), + [(0, 0, 0), (0, 0, 1), (0, 1, 0), (0, 1, 1), (0, 2, 0), (0, 2, 1), + (1, 0, 0), (1, 0, 1), (1, 1, 0), (1, 1, 1), (1, 2, 0), (1, 2, 1)]) + # 3D Fortran-order + i = nditer(a.reshape(2, 3, 2).copy(order='F'), ['multi_index'], [['readonly']]) + assert_equal(iter_multi_index(i), + [(0, 0, 0), (1, 0, 0), (0, 1, 0), (1, 1, 0), (0, 2, 0), (1, 2, 0), + (0, 0, 1), (1, 0, 1), (0, 1, 1), (1, 1, 1), (0, 2, 1), (1, 2, 1)]) + # 3D reversed C-order + i = nditer(a.reshape(2, 3, 2)[::-1], ['multi_index'], [['readonly']]) + assert_equal(iter_multi_index(i), + [(1, 0, 0), (1, 0, 1), (1, 1, 0), (1, 1, 1), (1, 2, 0), (1, 2, 1), + (0, 0, 0), (0, 0, 1), (0, 1, 0), (0, 1, 1), (0, 2, 0), (0, 2, 1)]) + i = nditer(a.reshape(2, 3, 2)[:, ::-1], ['multi_index'], [['readonly']]) + assert_equal(iter_multi_index(i), + [(0, 2, 0), (0, 2, 1), (0, 1, 0), (0, 1, 1), (0, 0, 0), (0, 0, 1), + (1, 2, 0), (1, 2, 1), (1, 1, 0), (1, 1, 1), (1, 0, 0), (1, 0, 1)]) + i = nditer(a.reshape(2, 3, 2)[:,:, ::-1], ['multi_index'], [['readonly']]) + assert_equal(iter_multi_index(i), + [(0, 0, 1), (0, 0, 0), (0, 1, 1), (0, 1, 0), (0, 2, 1), (0, 2, 0), + (1, 0, 1), (1, 0, 0), (1, 1, 1), (1, 1, 0), (1, 2, 1), (1, 2, 0)]) + # 3D reversed Fortran-order + i = nditer(a.reshape(2, 3, 2).copy(order='F')[::-1], + ['multi_index'], [['readonly']]) + assert_equal(iter_multi_index(i), + [(1, 0, 0), (0, 0, 0), (1, 1, 0), (0, 1, 0), (1, 2, 0), (0, 2, 0), + (1, 0, 1), (0, 0, 1), (1, 1, 1), (0, 1, 1), (1, 2, 1), (0, 2, 1)]) + i = nditer(a.reshape(2, 3, 2).copy(order='F')[:, ::-1], + ['multi_index'], [['readonly']]) + assert_equal(iter_multi_index(i), + [(0, 2, 0), (1, 2, 0), (0, 1, 0), (1, 1, 0), (0, 0, 0), (1, 0, 0), + (0, 2, 1), (1, 2, 1), (0, 1, 1), (1, 1, 1), (0, 0, 1), (1, 0, 1)]) + i = nditer(a.reshape(2, 3, 2).copy(order='F')[:,:, ::-1], + ['multi_index'], [['readonly']]) + assert_equal(iter_multi_index(i), + [(0, 0, 1), (1, 0, 1), (0, 1, 1), (1, 1, 1), (0, 2, 1), (1, 2, 1), + (0, 0, 0), (1, 0, 0), (0, 1, 0), (1, 1, 0), (0, 2, 0), (1, 2, 0)]) + +def test_iter_best_order_c_index_1d(): + # The C index should be correct with any reordering + + a = arange(4) + # 1D order + i = nditer(a, ['c_index'], [['readonly']]) + assert_equal(iter_indices(i), [0, 1, 2, 3]) + # 1D reversed order + i = nditer(a[::-1], ['c_index'], [['readonly']]) + assert_equal(iter_indices(i), [3, 2, 1, 0]) + +def test_iter_best_order_c_index_2d(): + # The C index should be correct with any reordering + + a = arange(6) + # 2D C-order + i = nditer(a.reshape(2, 3), ['c_index'], [['readonly']]) + assert_equal(iter_indices(i), [0, 1, 2, 3, 4, 5]) + # 2D Fortran-order + i = nditer(a.reshape(2, 3).copy(order='F'), + ['c_index'], [['readonly']]) + assert_equal(iter_indices(i), [0, 3, 1, 4, 2, 5]) + # 2D reversed C-order + i = nditer(a.reshape(2, 3)[::-1], ['c_index'], [['readonly']]) + assert_equal(iter_indices(i), [3, 4, 5, 0, 1, 2]) + i = nditer(a.reshape(2, 3)[:, ::-1], ['c_index'], [['readonly']]) + assert_equal(iter_indices(i), [2, 1, 0, 5, 4, 3]) + i = nditer(a.reshape(2, 3)[::-1, ::-1], ['c_index'], [['readonly']]) + assert_equal(iter_indices(i), [5, 4, 3, 2, 1, 0]) + # 2D reversed Fortran-order + i = nditer(a.reshape(2, 3).copy(order='F')[::-1], + ['c_index'], [['readonly']]) + assert_equal(iter_indices(i), [3, 0, 4, 1, 5, 2]) + i = nditer(a.reshape(2, 3).copy(order='F')[:, ::-1], + ['c_index'], [['readonly']]) + assert_equal(iter_indices(i), [2, 5, 1, 4, 0, 3]) + i = nditer(a.reshape(2, 3).copy(order='F')[::-1, ::-1], + ['c_index'], [['readonly']]) + assert_equal(iter_indices(i), [5, 2, 4, 1, 3, 0]) + +def test_iter_best_order_c_index_3d(): + # The C index should be correct with any reordering + + a = arange(12) + # 3D C-order + i = nditer(a.reshape(2, 3, 2), ['c_index'], [['readonly']]) + assert_equal(iter_indices(i), + [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]) + # 3D Fortran-order + i = nditer(a.reshape(2, 3, 2).copy(order='F'), + ['c_index'], [['readonly']]) + assert_equal(iter_indices(i), + [0, 6, 2, 8, 4, 10, 1, 7, 3, 9, 5, 11]) + # 3D reversed C-order + i = nditer(a.reshape(2, 3, 2)[::-1], ['c_index'], [['readonly']]) + assert_equal(iter_indices(i), + [6, 7, 8, 9, 10, 11, 0, 1, 2, 3, 4, 5]) + i = nditer(a.reshape(2, 3, 2)[:, ::-1], ['c_index'], [['readonly']]) + assert_equal(iter_indices(i), + [4, 5, 2, 3, 0, 1, 10, 11, 8, 9, 6, 7]) + i = nditer(a.reshape(2, 3, 2)[:,:, ::-1], ['c_index'], [['readonly']]) + assert_equal(iter_indices(i), + [1, 0, 3, 2, 5, 4, 7, 6, 9, 8, 11, 10]) + # 3D reversed Fortran-order + i = nditer(a.reshape(2, 3, 2).copy(order='F')[::-1], + ['c_index'], [['readonly']]) + assert_equal(iter_indices(i), + [6, 0, 8, 2, 10, 4, 7, 1, 9, 3, 11, 5]) + i = nditer(a.reshape(2, 3, 2).copy(order='F')[:, ::-1], + ['c_index'], [['readonly']]) + assert_equal(iter_indices(i), + [4, 10, 2, 8, 0, 6, 5, 11, 3, 9, 1, 7]) + i = nditer(a.reshape(2, 3, 2).copy(order='F')[:,:, ::-1], + ['c_index'], [['readonly']]) + assert_equal(iter_indices(i), + [1, 7, 3, 9, 5, 11, 0, 6, 2, 8, 4, 10]) + +def test_iter_best_order_f_index_1d(): + # The Fortran index should be correct with any reordering + + a = arange(4) + # 1D order + i = nditer(a, ['f_index'], [['readonly']]) + assert_equal(iter_indices(i), [0, 1, 2, 3]) + # 1D reversed order + i = nditer(a[::-1], ['f_index'], [['readonly']]) + assert_equal(iter_indices(i), [3, 2, 1, 0]) + +def test_iter_best_order_f_index_2d(): + # The Fortran index should be correct with any reordering + + a = arange(6) + # 2D C-order + i = nditer(a.reshape(2, 3), ['f_index'], [['readonly']]) + assert_equal(iter_indices(i), [0, 2, 4, 1, 3, 5]) + # 2D Fortran-order + i = nditer(a.reshape(2, 3).copy(order='F'), + ['f_index'], [['readonly']]) + assert_equal(iter_indices(i), [0, 1, 2, 3, 4, 5]) + # 2D reversed C-order + i = nditer(a.reshape(2, 3)[::-1], ['f_index'], [['readonly']]) + assert_equal(iter_indices(i), [1, 3, 5, 0, 2, 4]) + i = nditer(a.reshape(2, 3)[:, ::-1], ['f_index'], [['readonly']]) + assert_equal(iter_indices(i), [4, 2, 0, 5, 3, 1]) + i = nditer(a.reshape(2, 3)[::-1, ::-1], ['f_index'], [['readonly']]) + assert_equal(iter_indices(i), [5, 3, 1, 4, 2, 0]) + # 2D reversed Fortran-order + i = nditer(a.reshape(2, 3).copy(order='F')[::-1], + ['f_index'], [['readonly']]) + assert_equal(iter_indices(i), [1, 0, 3, 2, 5, 4]) + i = nditer(a.reshape(2, 3).copy(order='F')[:, ::-1], + ['f_index'], [['readonly']]) + assert_equal(iter_indices(i), [4, 5, 2, 3, 0, 1]) + i = nditer(a.reshape(2, 3).copy(order='F')[::-1, ::-1], + ['f_index'], [['readonly']]) + assert_equal(iter_indices(i), [5, 4, 3, 2, 1, 0]) + +def test_iter_best_order_f_index_3d(): + # The Fortran index should be correct with any reordering + + a = arange(12) + # 3D C-order + i = nditer(a.reshape(2, 3, 2), ['f_index'], [['readonly']]) + assert_equal(iter_indices(i), + [0, 6, 2, 8, 4, 10, 1, 7, 3, 9, 5, 11]) + # 3D Fortran-order + i = nditer(a.reshape(2, 3, 2).copy(order='F'), + ['f_index'], [['readonly']]) + assert_equal(iter_indices(i), + [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]) + # 3D reversed C-order + i = nditer(a.reshape(2, 3, 2)[::-1], ['f_index'], [['readonly']]) + assert_equal(iter_indices(i), + [1, 7, 3, 9, 5, 11, 0, 6, 2, 8, 4, 10]) + i = nditer(a.reshape(2, 3, 2)[:, ::-1], ['f_index'], [['readonly']]) + assert_equal(iter_indices(i), + [4, 10, 2, 8, 0, 6, 5, 11, 3, 9, 1, 7]) + i = nditer(a.reshape(2, 3, 2)[:,:, ::-1], ['f_index'], [['readonly']]) + assert_equal(iter_indices(i), + [6, 0, 8, 2, 10, 4, 7, 1, 9, 3, 11, 5]) + # 3D reversed Fortran-order + i = nditer(a.reshape(2, 3, 2).copy(order='F')[::-1], + ['f_index'], [['readonly']]) + assert_equal(iter_indices(i), + [1, 0, 3, 2, 5, 4, 7, 6, 9, 8, 11, 10]) + i = nditer(a.reshape(2, 3, 2).copy(order='F')[:, ::-1], + ['f_index'], [['readonly']]) + assert_equal(iter_indices(i), + [4, 5, 2, 3, 0, 1, 10, 11, 8, 9, 6, 7]) + i = nditer(a.reshape(2, 3, 2).copy(order='F')[:,:, ::-1], + ['f_index'], [['readonly']]) + assert_equal(iter_indices(i), + [6, 7, 8, 9, 10, 11, 0, 1, 2, 3, 4, 5]) + +def test_iter_no_inner_full_coalesce(): + # Check no_inner iterators which coalesce into a single inner loop + + for shape in [(5,), (3, 4), (2, 3, 4), (2, 3, 4, 3), (2, 3, 2, 2, 3)]: + size = np.prod(shape) + a = arange(size) + # Test each combination of forward and backwards indexing + for dirs in range(2**len(shape)): + dirs_index = [slice(None)]*len(shape) + for bit in range(len(shape)): + if ((2**bit) & dirs): + dirs_index[bit] = slice(None, None, -1) + dirs_index = tuple(dirs_index) + + aview = a.reshape(shape)[dirs_index] + # C-order + i = nditer(aview, ['external_loop'], [['readonly']]) + assert_equal(i.ndim, 1) + assert_equal(i[0].shape, (size,)) + # Fortran-order + i = nditer(aview.T, ['external_loop'], [['readonly']]) + assert_equal(i.ndim, 1) + assert_equal(i[0].shape, (size,)) + # Other order + if len(shape) > 2: + i = nditer(aview.swapaxes(0, 1), + ['external_loop'], [['readonly']]) + assert_equal(i.ndim, 1) + assert_equal(i[0].shape, (size,)) + +def test_iter_no_inner_dim_coalescing(): + # Check no_inner iterators whose dimensions may not coalesce completely + + # Skipping the last element in a dimension prevents coalescing + # with the next-bigger dimension + a = arange(24).reshape(2, 3, 4)[:,:, :-1] + i = nditer(a, ['external_loop'], [['readonly']]) + assert_equal(i.ndim, 2) + assert_equal(i[0].shape, (3,)) + a = arange(24).reshape(2, 3, 4)[:, :-1,:] + i = nditer(a, ['external_loop'], [['readonly']]) + assert_equal(i.ndim, 2) + assert_equal(i[0].shape, (8,)) + a = arange(24).reshape(2, 3, 4)[:-1,:,:] + i = nditer(a, ['external_loop'], [['readonly']]) + assert_equal(i.ndim, 1) + assert_equal(i[0].shape, (12,)) + + # Even with lots of 1-sized dimensions, should still coalesce + a = arange(24).reshape(1, 1, 2, 1, 1, 3, 1, 1, 4, 1, 1) + i = nditer(a, ['external_loop'], [['readonly']]) + assert_equal(i.ndim, 1) + assert_equal(i[0].shape, (24,)) + +def test_iter_dim_coalescing(): + # Check that the correct number of dimensions are coalesced + + # Tracking a multi-index disables coalescing + a = arange(24).reshape(2, 3, 4) + i = nditer(a, ['multi_index'], [['readonly']]) + assert_equal(i.ndim, 3) + + # A tracked index can allow coalescing if it's compatible with the array + a3d = arange(24).reshape(2, 3, 4) + i = nditer(a3d, ['c_index'], [['readonly']]) + assert_equal(i.ndim, 1) + i = nditer(a3d.swapaxes(0, 1), ['c_index'], [['readonly']]) + assert_equal(i.ndim, 3) + i = nditer(a3d.T, ['c_index'], [['readonly']]) + assert_equal(i.ndim, 3) + i = nditer(a3d.T, ['f_index'], [['readonly']]) + assert_equal(i.ndim, 1) + i = nditer(a3d.T.swapaxes(0, 1), ['f_index'], [['readonly']]) + assert_equal(i.ndim, 3) + + # When C or F order is forced, coalescing may still occur + a3d = arange(24).reshape(2, 3, 4) + i = nditer(a3d, order='C') + assert_equal(i.ndim, 1) + i = nditer(a3d.T, order='C') + assert_equal(i.ndim, 3) + i = nditer(a3d, order='F') + assert_equal(i.ndim, 3) + i = nditer(a3d.T, order='F') + assert_equal(i.ndim, 1) + i = nditer(a3d, order='A') + assert_equal(i.ndim, 1) + i = nditer(a3d.T, order='A') + assert_equal(i.ndim, 1) + +def test_iter_broadcasting(): + # Standard NumPy broadcasting rules + + # 1D with scalar + i = nditer([arange(6), np.int32(2)], ['multi_index'], [['readonly']]*2) + assert_equal(i.itersize, 6) + assert_equal(i.shape, (6,)) + + # 2D with scalar + i = nditer([arange(6).reshape(2, 3), np.int32(2)], + ['multi_index'], [['readonly']]*2) + assert_equal(i.itersize, 6) + assert_equal(i.shape, (2, 3)) + # 2D with 1D + i = nditer([arange(6).reshape(2, 3), arange(3)], + ['multi_index'], [['readonly']]*2) + assert_equal(i.itersize, 6) + assert_equal(i.shape, (2, 3)) + i = nditer([arange(2).reshape(2, 1), arange(3)], + ['multi_index'], [['readonly']]*2) + assert_equal(i.itersize, 6) + assert_equal(i.shape, (2, 3)) + # 2D with 2D + i = nditer([arange(2).reshape(2, 1), arange(3).reshape(1, 3)], + ['multi_index'], [['readonly']]*2) + assert_equal(i.itersize, 6) + assert_equal(i.shape, (2, 3)) + + # 3D with scalar + i = nditer([np.int32(2), arange(24).reshape(4, 2, 3)], + ['multi_index'], [['readonly']]*2) + assert_equal(i.itersize, 24) + assert_equal(i.shape, (4, 2, 3)) + # 3D with 1D + i = nditer([arange(3), arange(24).reshape(4, 2, 3)], + ['multi_index'], [['readonly']]*2) + assert_equal(i.itersize, 24) + assert_equal(i.shape, (4, 2, 3)) + i = nditer([arange(3), arange(8).reshape(4, 2, 1)], + ['multi_index'], [['readonly']]*2) + assert_equal(i.itersize, 24) + assert_equal(i.shape, (4, 2, 3)) + # 3D with 2D + i = nditer([arange(6).reshape(2, 3), arange(24).reshape(4, 2, 3)], + ['multi_index'], [['readonly']]*2) + assert_equal(i.itersize, 24) + assert_equal(i.shape, (4, 2, 3)) + i = nditer([arange(2).reshape(2, 1), arange(24).reshape(4, 2, 3)], + ['multi_index'], [['readonly']]*2) + assert_equal(i.itersize, 24) + assert_equal(i.shape, (4, 2, 3)) + i = nditer([arange(3).reshape(1, 3), arange(8).reshape(4, 2, 1)], + ['multi_index'], [['readonly']]*2) + assert_equal(i.itersize, 24) + assert_equal(i.shape, (4, 2, 3)) + # 3D with 3D + i = nditer([arange(2).reshape(1, 2, 1), arange(3).reshape(1, 1, 3), + arange(4).reshape(4, 1, 1)], + ['multi_index'], [['readonly']]*3) + assert_equal(i.itersize, 24) + assert_equal(i.shape, (4, 2, 3)) + i = nditer([arange(6).reshape(1, 2, 3), arange(4).reshape(4, 1, 1)], + ['multi_index'], [['readonly']]*2) + assert_equal(i.itersize, 24) + assert_equal(i.shape, (4, 2, 3)) + i = nditer([arange(24).reshape(4, 2, 3), arange(12).reshape(4, 1, 3)], + ['multi_index'], [['readonly']]*2) + assert_equal(i.itersize, 24) + assert_equal(i.shape, (4, 2, 3)) + +def test_iter_itershape(): + # Check that allocated outputs work with a specified shape + a = np.arange(6, dtype='i2').reshape(2, 3) + i = nditer([a, None], [], [['readonly'], ['writeonly', 'allocate']], + op_axes=[[0, 1, None], None], + itershape=(-1, -1, 4)) + assert_equal(i.operands[1].shape, (2, 3, 4)) + assert_equal(i.operands[1].strides, (24, 8, 2)) + + i = nditer([a.T, None], [], [['readonly'], ['writeonly', 'allocate']], + op_axes=[[0, 1, None], None], + itershape=(-1, -1, 4)) + assert_equal(i.operands[1].shape, (3, 2, 4)) + assert_equal(i.operands[1].strides, (8, 24, 2)) + + i = nditer([a.T, None], [], [['readonly'], ['writeonly', 'allocate']], + order='F', + op_axes=[[0, 1, None], None], + itershape=(-1, -1, 4)) + assert_equal(i.operands[1].shape, (3, 2, 4)) + assert_equal(i.operands[1].strides, (2, 6, 12)) + + # If we specify 1 in the itershape, it shouldn't allow broadcasting + # of that dimension to a bigger value + assert_raises(ValueError, nditer, [a, None], [], + [['readonly'], ['writeonly', 'allocate']], + op_axes=[[0, 1, None], None], + itershape=(-1, 1, 4)) + # Test bug that for no op_axes but itershape, they are NULLed correctly + i = np.nditer([np.ones(2), None, None], itershape=(2,)) + +def test_iter_broadcasting_errors(): + # Check that errors are thrown for bad broadcasting shapes + + # 1D with 1D + assert_raises(ValueError, nditer, [arange(2), arange(3)], + [], [['readonly']]*2) + # 2D with 1D + assert_raises(ValueError, nditer, + [arange(6).reshape(2, 3), arange(2)], + [], [['readonly']]*2) + # 2D with 2D + assert_raises(ValueError, nditer, + [arange(6).reshape(2, 3), arange(9).reshape(3, 3)], + [], [['readonly']]*2) + assert_raises(ValueError, nditer, + [arange(6).reshape(2, 3), arange(4).reshape(2, 2)], + [], [['readonly']]*2) + # 3D with 3D + assert_raises(ValueError, nditer, + [arange(36).reshape(3, 3, 4), arange(24).reshape(2, 3, 4)], + [], [['readonly']]*2) + assert_raises(ValueError, nditer, + [arange(8).reshape(2, 4, 1), arange(24).reshape(2, 3, 4)], + [], [['readonly']]*2) + + # Verify that the error message mentions the right shapes + try: + nditer([arange(2).reshape(1, 2, 1), + arange(3).reshape(1, 3), + arange(6).reshape(2, 3)], + [], + [['readonly'], ['readonly'], ['writeonly', 'no_broadcast']]) + raise AssertionError('Should have raised a broadcast error') + except ValueError as e: + msg = str(e) + # The message should contain the shape of the 3rd operand + assert_(msg.find('(2,3)') >= 0, + 'Message "%s" doesn\'t contain operand shape (2,3)' % msg) + # The message should contain the broadcast shape + assert_(msg.find('(1,2,3)') >= 0, + 'Message "%s" doesn\'t contain broadcast shape (1,2,3)' % msg) + + try: + nditer([arange(6).reshape(2, 3), arange(2)], + [], + [['readonly'], ['readonly']], + op_axes=[[0, 1], [0, np.newaxis]], + itershape=(4, 3)) + raise AssertionError('Should have raised a broadcast error') + except ValueError as e: + msg = str(e) + # The message should contain "shape->remappedshape" for each operand + assert_(msg.find('(2,3)->(2,3)') >= 0, + 'Message "%s" doesn\'t contain operand shape (2,3)->(2,3)' % msg) + assert_(msg.find('(2,)->(2,newaxis)') >= 0, + ('Message "%s" doesn\'t contain remapped operand shape' + + '(2,)->(2,newaxis)') % msg) + # The message should contain the itershape parameter + assert_(msg.find('(4,3)') >= 0, + 'Message "%s" doesn\'t contain itershape parameter (4,3)' % msg) + + try: + nditer([np.zeros((2, 1, 1)), np.zeros((2,))], + [], + [['writeonly', 'no_broadcast'], ['readonly']]) + raise AssertionError('Should have raised a broadcast error') + except ValueError as e: + msg = str(e) + # The message should contain the shape of the bad operand + assert_(msg.find('(2,1,1)') >= 0, + 'Message "%s" doesn\'t contain operand shape (2,1,1)' % msg) + # The message should contain the broadcast shape + assert_(msg.find('(2,1,2)') >= 0, + 'Message "%s" doesn\'t contain the broadcast shape (2,1,2)' % msg) + +def test_iter_flags_errors(): + # Check that bad combinations of flags produce errors + + a = arange(6) + + # Not enough operands + assert_raises(ValueError, nditer, [], [], []) + # Too many operands + assert_raises(ValueError, nditer, [a]*100, [], [['readonly']]*100) + # Bad global flag + assert_raises(ValueError, nditer, [a], ['bad flag'], [['readonly']]) + # Bad op flag + assert_raises(ValueError, nditer, [a], [], [['readonly', 'bad flag']]) + # Bad order parameter + assert_raises(ValueError, nditer, [a], [], [['readonly']], order='G') + # Bad casting parameter + assert_raises(ValueError, nditer, [a], [], [['readonly']], casting='noon') + # op_flags must match ops + assert_raises(ValueError, nditer, [a]*3, [], [['readonly']]*2) + # Cannot track both a C and an F index + assert_raises(ValueError, nditer, a, + ['c_index', 'f_index'], [['readonly']]) + # Inner iteration and multi-indices/indices are incompatible + assert_raises(ValueError, nditer, a, + ['external_loop', 'multi_index'], [['readonly']]) + assert_raises(ValueError, nditer, a, + ['external_loop', 'c_index'], [['readonly']]) + assert_raises(ValueError, nditer, a, + ['external_loop', 'f_index'], [['readonly']]) + # Must specify exactly one of readwrite/readonly/writeonly per operand + assert_raises(ValueError, nditer, a, [], [[]]) + assert_raises(ValueError, nditer, a, [], [['readonly', 'writeonly']]) + assert_raises(ValueError, nditer, a, [], [['readonly', 'readwrite']]) + assert_raises(ValueError, nditer, a, [], [['writeonly', 'readwrite']]) + assert_raises(ValueError, nditer, a, + [], [['readonly', 'writeonly', 'readwrite']]) + # Python scalars are always readonly + assert_raises(TypeError, nditer, 1.5, [], [['writeonly']]) + assert_raises(TypeError, nditer, 1.5, [], [['readwrite']]) + # Array scalars are always readonly + assert_raises(TypeError, nditer, np.int32(1), [], [['writeonly']]) + assert_raises(TypeError, nditer, np.int32(1), [], [['readwrite']]) + # Check readonly array + a.flags.writeable = False + assert_raises(ValueError, nditer, a, [], [['writeonly']]) + assert_raises(ValueError, nditer, a, [], [['readwrite']]) + a.flags.writeable = True + # Multi-indices available only with the multi_index flag + i = nditer(arange(6), [], [['readonly']]) + assert_raises(ValueError, lambda i:i.multi_index, i) + # Index available only with an index flag + assert_raises(ValueError, lambda i:i.index, i) + # GotoCoords and GotoIndex incompatible with buffering or no_inner + + def assign_multi_index(i): + i.multi_index = (0,) + + def assign_index(i): + i.index = 0 + + def assign_iterindex(i): + i.iterindex = 0 + + def assign_iterrange(i): + i.iterrange = (0, 1) + i = nditer(arange(6), ['external_loop']) + assert_raises(ValueError, assign_multi_index, i) + assert_raises(ValueError, assign_index, i) + assert_raises(ValueError, assign_iterindex, i) + assert_raises(ValueError, assign_iterrange, i) + i = nditer(arange(6), ['buffered']) + assert_raises(ValueError, assign_multi_index, i) + assert_raises(ValueError, assign_index, i) + assert_raises(ValueError, assign_iterrange, i) + # Can't iterate if size is zero + assert_raises(ValueError, nditer, np.array([])) + +def test_iter_slice(): + a, b, c = np.arange(3), np.arange(3), np.arange(3.) + i = nditer([a, b, c], [], ['readwrite']) + with i: + i[0:2] = (3, 3) + assert_equal(a, [3, 1, 2]) + assert_equal(b, [3, 1, 2]) + assert_equal(c, [0, 1, 2]) + i[1] = 12 + assert_equal(i[0:2], [3, 12]) + +def test_iter_assign_mapping(): + a = np.arange(24, dtype='f8').reshape(2, 3, 4).T + it = np.nditer(a, [], [['readwrite', 'updateifcopy']], + casting='same_kind', op_dtypes=[np.dtype('f4')]) + with it: + it.operands[0][...] = 3 + it.operands[0][...] = 14 + assert_equal(a, 14) + it = np.nditer(a, [], [['readwrite', 'updateifcopy']], + casting='same_kind', op_dtypes=[np.dtype('f4')]) + with it: + x = it.operands[0][-1:1] + x[...] = 14 + it.operands[0][...] = -1234 + assert_equal(a, -1234) + # check for no warnings on dealloc + x = None + it = None + +def test_iter_nbo_align_contig(): + # Check that byte order, alignment, and contig changes work + + # Byte order change by requesting a specific dtype + a = np.arange(6, dtype='f4') + au = a.byteswap() + au = au.view(au.dtype.newbyteorder()) + assert_(a.dtype.byteorder != au.dtype.byteorder) + i = nditer(au, [], [['readwrite', 'updateifcopy']], + casting='equiv', + op_dtypes=[np.dtype('f4')]) + with i: + # context manager triggers WRITEBACKIFCOPY on i at exit + assert_equal(i.dtypes[0].byteorder, a.dtype.byteorder) + assert_equal(i.operands[0].dtype.byteorder, a.dtype.byteorder) + assert_equal(i.operands[0], a) + i.operands[0][:] = 2 + assert_equal(au, [2]*6) + del i # should not raise a warning + # Byte order change by requesting NBO + a = np.arange(6, dtype='f4') + au = a.byteswap() + au = au.view(au.dtype.newbyteorder()) + assert_(a.dtype.byteorder != au.dtype.byteorder) + with nditer(au, [], [['readwrite', 'updateifcopy', 'nbo']], + casting='equiv') as i: + # context manager triggers UPDATEIFCOPY on i at exit + assert_equal(i.dtypes[0].byteorder, a.dtype.byteorder) + assert_equal(i.operands[0].dtype.byteorder, a.dtype.byteorder) + assert_equal(i.operands[0], a) + i.operands[0][:] = 12345 + i.operands[0][:] = 2 + assert_equal(au, [2]*6) + + # Unaligned input + a = np.zeros((6*4+1,), dtype='i1')[1:] + a.dtype = 'f4' + a[:] = np.arange(6, dtype='f4') + assert_(not a.flags.aligned) + # Without 'aligned', shouldn't copy + i = nditer(a, [], [['readonly']]) + assert_(not i.operands[0].flags.aligned) + assert_equal(i.operands[0], a) + # With 'aligned', should make a copy + with nditer(a, [], [['readwrite', 'updateifcopy', 'aligned']]) as i: + assert_(i.operands[0].flags.aligned) + # context manager triggers UPDATEIFCOPY on i at exit + assert_equal(i.operands[0], a) + i.operands[0][:] = 3 + assert_equal(a, [3]*6) + + # Discontiguous input + a = arange(12) + # If it is contiguous, shouldn't copy + i = nditer(a[:6], [], [['readonly']]) + assert_(i.operands[0].flags.contiguous) + assert_equal(i.operands[0], a[:6]) + # If it isn't contiguous, should buffer + i = nditer(a[::2], ['buffered', 'external_loop'], + [['readonly', 'contig']], + buffersize=10) + assert_(i[0].flags.contiguous) + assert_equal(i[0], a[::2]) + +def test_iter_array_cast(): + # Check that arrays are cast as requested + + # No cast 'f4' -> 'f4' + a = np.arange(6, dtype='f4').reshape(2, 3) + i = nditer(a, [], [['readwrite']], op_dtypes=[np.dtype('f4')]) + with i: + assert_equal(i.operands[0], a) + assert_equal(i.operands[0].dtype, np.dtype('f4')) + + # Byte-order cast ' '>f4' + a = np.arange(6, dtype='f4')]) as i: + assert_equal(i.operands[0], a) + assert_equal(i.operands[0].dtype, np.dtype('>f4')) + + # Safe case 'f4' -> 'f8' + a = np.arange(24, dtype='f4').reshape(2, 3, 4).swapaxes(1, 2) + i = nditer(a, [], [['readonly', 'copy']], + casting='safe', + op_dtypes=[np.dtype('f8')]) + assert_equal(i.operands[0], a) + assert_equal(i.operands[0].dtype, np.dtype('f8')) + # The memory layout of the temporary should match a (a is (48,4,16)) + # except negative strides get flipped to positive strides. + assert_equal(i.operands[0].strides, (96, 8, 32)) + a = a[::-1,:, ::-1] + i = nditer(a, [], [['readonly', 'copy']], + casting='safe', + op_dtypes=[np.dtype('f8')]) + assert_equal(i.operands[0], a) + assert_equal(i.operands[0].dtype, np.dtype('f8')) + assert_equal(i.operands[0].strides, (96, 8, 32)) + + # Same-kind cast 'f8' -> 'f4' -> 'f8' + a = np.arange(24, dtype='f8').reshape(2, 3, 4).T + with nditer(a, [], + [['readwrite', 'updateifcopy']], + casting='same_kind', + op_dtypes=[np.dtype('f4')]) as i: + assert_equal(i.operands[0], a) + assert_equal(i.operands[0].dtype, np.dtype('f4')) + assert_equal(i.operands[0].strides, (4, 16, 48)) + # Check that WRITEBACKIFCOPY is activated at exit + i.operands[0][2, 1, 1] = -12.5 + assert_(a[2, 1, 1] != -12.5) + assert_equal(a[2, 1, 1], -12.5) + + a = np.arange(6, dtype='i4')[::-2] + with nditer(a, [], + [['writeonly', 'updateifcopy']], + casting='unsafe', + op_dtypes=[np.dtype('f4')]) as i: + assert_equal(i.operands[0].dtype, np.dtype('f4')) + # Even though the stride was negative in 'a', it + # becomes positive in the temporary + assert_equal(i.operands[0].strides, (4,)) + i.operands[0][:] = [1, 2, 3] + assert_equal(a, [1, 2, 3]) + +def test_iter_array_cast_errors(): + # Check that invalid casts are caught + + # Need to enable copying for casts to occur + assert_raises(TypeError, nditer, arange(2, dtype='f4'), [], + [['readonly']], op_dtypes=[np.dtype('f8')]) + # Also need to allow casting for casts to occur + assert_raises(TypeError, nditer, arange(2, dtype='f4'), [], + [['readonly', 'copy']], casting='no', + op_dtypes=[np.dtype('f8')]) + assert_raises(TypeError, nditer, arange(2, dtype='f4'), [], + [['readonly', 'copy']], casting='equiv', + op_dtypes=[np.dtype('f8')]) + assert_raises(TypeError, nditer, arange(2, dtype='f8'), [], + [['writeonly', 'updateifcopy']], + casting='no', + op_dtypes=[np.dtype('f4')]) + assert_raises(TypeError, nditer, arange(2, dtype='f8'), [], + [['writeonly', 'updateifcopy']], + casting='equiv', + op_dtypes=[np.dtype('f4')]) + # ' '>f4' should not work with casting='no' + assert_raises(TypeError, nditer, arange(2, dtype='f4')]) + # 'f4' -> 'f8' is a safe cast, but 'f8' -> 'f4' isn't + assert_raises(TypeError, nditer, arange(2, dtype='f4'), [], + [['readwrite', 'updateifcopy']], + casting='safe', + op_dtypes=[np.dtype('f8')]) + assert_raises(TypeError, nditer, arange(2, dtype='f8'), [], + [['readwrite', 'updateifcopy']], + casting='safe', + op_dtypes=[np.dtype('f4')]) + # 'f4' -> 'i4' is neither a safe nor a same-kind cast + assert_raises(TypeError, nditer, arange(2, dtype='f4'), [], + [['readonly', 'copy']], + casting='same_kind', + op_dtypes=[np.dtype('i4')]) + assert_raises(TypeError, nditer, arange(2, dtype='i4'), [], + [['writeonly', 'updateifcopy']], + casting='same_kind', + op_dtypes=[np.dtype('f4')]) + +def test_iter_scalar_cast(): + # Check that scalars are cast as requested + + # No cast 'f4' -> 'f4' + i = nditer(np.float32(2.5), [], [['readonly']], + op_dtypes=[np.dtype('f4')]) + assert_equal(i.dtypes[0], np.dtype('f4')) + assert_equal(i.value.dtype, np.dtype('f4')) + assert_equal(i.value, 2.5) + # Safe cast 'f4' -> 'f8' + i = nditer(np.float32(2.5), [], + [['readonly', 'copy']], + casting='safe', + op_dtypes=[np.dtype('f8')]) + assert_equal(i.dtypes[0], np.dtype('f8')) + assert_equal(i.value.dtype, np.dtype('f8')) + assert_equal(i.value, 2.5) + # Same-kind cast 'f8' -> 'f4' + i = nditer(np.float64(2.5), [], + [['readonly', 'copy']], + casting='same_kind', + op_dtypes=[np.dtype('f4')]) + assert_equal(i.dtypes[0], np.dtype('f4')) + assert_equal(i.value.dtype, np.dtype('f4')) + assert_equal(i.value, 2.5) + # Unsafe cast 'f8' -> 'i4' + i = nditer(np.float64(3.0), [], + [['readonly', 'copy']], + casting='unsafe', + op_dtypes=[np.dtype('i4')]) + assert_equal(i.dtypes[0], np.dtype('i4')) + assert_equal(i.value.dtype, np.dtype('i4')) + assert_equal(i.value, 3) + # Readonly scalars may be cast even without setting COPY or BUFFERED + i = nditer(3, [], [['readonly']], op_dtypes=[np.dtype('f8')]) + assert_equal(i[0].dtype, np.dtype('f8')) + assert_equal(i[0], 3.) + +def test_iter_scalar_cast_errors(): + # Check that invalid casts are caught + + # Need to allow copying/buffering for write casts of scalars to occur + assert_raises(TypeError, nditer, np.float32(2), [], + [['readwrite']], op_dtypes=[np.dtype('f8')]) + assert_raises(TypeError, nditer, 2.5, [], + [['readwrite']], op_dtypes=[np.dtype('f4')]) + # 'f8' -> 'f4' isn't a safe cast if the value would overflow + assert_raises(TypeError, nditer, np.float64(1e60), [], + [['readonly']], + casting='safe', + op_dtypes=[np.dtype('f4')]) + # 'f4' -> 'i4' is neither a safe nor a same-kind cast + assert_raises(TypeError, nditer, np.float32(2), [], + [['readonly']], + casting='same_kind', + op_dtypes=[np.dtype('i4')]) + +def test_iter_object_arrays_basic(): + # Check that object arrays work + + obj = {'a':3,'b':'d'} + a = np.array([[1, 2, 3], None, obj, None], dtype='O') + if HAS_REFCOUNT: + rc = sys.getrefcount(obj) + + # Need to allow references for object arrays + assert_raises(TypeError, nditer, a) + if HAS_REFCOUNT: + assert_equal(sys.getrefcount(obj), rc) + + i = nditer(a, ['refs_ok'], ['readonly']) + vals = [x_[()] for x_ in i] + assert_equal(np.array(vals, dtype='O'), a) + vals, i, x = [None]*3 + if HAS_REFCOUNT: + assert_equal(sys.getrefcount(obj), rc) + + i = nditer(a.reshape(2, 2).T, ['refs_ok', 'buffered'], + ['readonly'], order='C') + assert_(i.iterationneedsapi) + vals = [x_[()] for x_ in i] + assert_equal(np.array(vals, dtype='O'), a.reshape(2, 2).ravel(order='F')) + vals, i, x = [None]*3 + if HAS_REFCOUNT: + assert_equal(sys.getrefcount(obj), rc) + + i = nditer(a.reshape(2, 2).T, ['refs_ok', 'buffered'], + ['readwrite'], order='C') + with i: + for x in i: + x[...] = None + vals, i, x = [None]*3 + if HAS_REFCOUNT: + assert_(sys.getrefcount(obj) == rc-1) + assert_equal(a, np.array([None]*4, dtype='O')) + +def test_iter_object_arrays_conversions(): + # Conversions to/from objects + a = np.arange(6, dtype='O') + i = nditer(a, ['refs_ok', 'buffered'], ['readwrite'], + casting='unsafe', op_dtypes='i4') + with i: + for x in i: + x[...] += 1 + assert_equal(a, np.arange(6)+1) + + a = np.arange(6, dtype='i4') + i = nditer(a, ['refs_ok', 'buffered'], ['readwrite'], + casting='unsafe', op_dtypes='O') + with i: + for x in i: + x[...] += 1 + assert_equal(a, np.arange(6)+1) + + # Non-contiguous object array + a = np.zeros((6,), dtype=[('p', 'i1'), ('a', 'O')]) + a = a['a'] + a[:] = np.arange(6) + i = nditer(a, ['refs_ok', 'buffered'], ['readwrite'], + casting='unsafe', op_dtypes='i4') + with i: + for x in i: + x[...] += 1 + assert_equal(a, np.arange(6)+1) + + #Non-contiguous value array + a = np.zeros((6,), dtype=[('p', 'i1'), ('a', 'i4')]) + a = a['a'] + a[:] = np.arange(6) + 98172488 + i = nditer(a, ['refs_ok', 'buffered'], ['readwrite'], + casting='unsafe', op_dtypes='O') + with i: + ob = i[0][()] + if HAS_REFCOUNT: + rc = sys.getrefcount(ob) + for x in i: + x[...] += 1 + if HAS_REFCOUNT: + assert_(sys.getrefcount(ob) == rc-1) + assert_equal(a, np.arange(6)+98172489) + +def test_iter_common_dtype(): + # Check that the iterator finds a common data type correctly + # (some checks are somewhat duplicate after adopting NEP 50) + + i = nditer([array([3], dtype='f4'), array([0], dtype='f8')], + ['common_dtype'], + [['readonly', 'copy']]*2, + casting='safe') + assert_equal(i.dtypes[0], np.dtype('f8')) + assert_equal(i.dtypes[1], np.dtype('f8')) + i = nditer([array([3], dtype='i4'), array([0], dtype='f4')], + ['common_dtype'], + [['readonly', 'copy']]*2, + casting='safe') + assert_equal(i.dtypes[0], np.dtype('f8')) + assert_equal(i.dtypes[1], np.dtype('f8')) + i = nditer([array([3], dtype='f4'), array(0, dtype='f8')], + ['common_dtype'], + [['readonly', 'copy']]*2, + casting='same_kind') + assert_equal(i.dtypes[0], np.dtype('f8')) + assert_equal(i.dtypes[1], np.dtype('f8')) + i = nditer([array([3], dtype='u4'), array(0, dtype='i4')], + ['common_dtype'], + [['readonly', 'copy']]*2, + casting='safe') + assert_equal(i.dtypes[0], np.dtype('i8')) + assert_equal(i.dtypes[1], np.dtype('i8')) + i = nditer([array([3], dtype='u4'), array(-12, dtype='i4')], + ['common_dtype'], + [['readonly', 'copy']]*2, + casting='safe') + assert_equal(i.dtypes[0], np.dtype('i8')) + assert_equal(i.dtypes[1], np.dtype('i8')) + i = nditer([array([3], dtype='u4'), array(-12, dtype='i4'), + array([2j], dtype='c8'), array([9], dtype='f8')], + ['common_dtype'], + [['readonly', 'copy']]*4, + casting='safe') + assert_equal(i.dtypes[0], np.dtype('c16')) + assert_equal(i.dtypes[1], np.dtype('c16')) + assert_equal(i.dtypes[2], np.dtype('c16')) + assert_equal(i.dtypes[3], np.dtype('c16')) + assert_equal(i.value, (3, -12, 2j, 9)) + + # When allocating outputs, other outputs aren't factored in + i = nditer([array([3], dtype='i4'), None, array([2j], dtype='c16')], [], + [['readonly', 'copy'], + ['writeonly', 'allocate'], + ['writeonly']], + casting='safe') + assert_equal(i.dtypes[0], np.dtype('i4')) + assert_equal(i.dtypes[1], np.dtype('i4')) + assert_equal(i.dtypes[2], np.dtype('c16')) + # But, if common data types are requested, they are + i = nditer([array([3], dtype='i4'), None, array([2j], dtype='c16')], + ['common_dtype'], + [['readonly', 'copy'], + ['writeonly', 'allocate'], + ['writeonly']], + casting='safe') + assert_equal(i.dtypes[0], np.dtype('c16')) + assert_equal(i.dtypes[1], np.dtype('c16')) + assert_equal(i.dtypes[2], np.dtype('c16')) + +def test_iter_copy_if_overlap(): + # Ensure the iterator makes copies on read/write overlap, if requested + + # Copy not needed, 1 op + for flag in ['readonly', 'writeonly', 'readwrite']: + a = arange(10) + i = nditer([a], ['copy_if_overlap'], [[flag]]) + with i: + assert_(i.operands[0] is a) + + # Copy needed, 2 ops, read-write overlap + x = arange(10) + a = x[1:] + b = x[:-1] + with nditer([a, b], ['copy_if_overlap'], [['readonly'], ['readwrite']]) as i: + assert_(not np.shares_memory(*i.operands)) + + # Copy not needed with elementwise, 2 ops, exactly same arrays + x = arange(10) + a = x + b = x + i = nditer([a, b], ['copy_if_overlap'], [['readonly', 'overlap_assume_elementwise'], + ['readwrite', 'overlap_assume_elementwise']]) + with i: + assert_(i.operands[0] is a and i.operands[1] is b) + with nditer([a, b], ['copy_if_overlap'], [['readonly'], ['readwrite']]) as i: + assert_(i.operands[0] is a and not np.shares_memory(i.operands[1], b)) + + # Copy not needed, 2 ops, no overlap + x = arange(10) + a = x[::2] + b = x[1::2] + i = nditer([a, b], ['copy_if_overlap'], [['readonly'], ['writeonly']]) + assert_(i.operands[0] is a and i.operands[1] is b) + + # Copy needed, 2 ops, read-write overlap + x = arange(4, dtype=np.int8) + a = x[3:] + b = x.view(np.int32)[:1] + with nditer([a, b], ['copy_if_overlap'], [['readonly'], ['writeonly']]) as i: + assert_(not np.shares_memory(*i.operands)) + + # Copy needed, 3 ops, read-write overlap + for flag in ['writeonly', 'readwrite']: + x = np.ones([10, 10]) + a = x + b = x.T + c = x + with nditer([a, b, c], ['copy_if_overlap'], + [['readonly'], ['readonly'], [flag]]) as i: + a2, b2, c2 = i.operands + assert_(not np.shares_memory(a2, c2)) + assert_(not np.shares_memory(b2, c2)) + + # Copy not needed, 3 ops, read-only overlap + x = np.ones([10, 10]) + a = x + b = x.T + c = x + i = nditer([a, b, c], ['copy_if_overlap'], + [['readonly'], ['readonly'], ['readonly']]) + a2, b2, c2 = i.operands + assert_(a is a2) + assert_(b is b2) + assert_(c is c2) + + # Copy not needed, 3 ops, read-only overlap + x = np.ones([10, 10]) + a = x + b = np.ones([10, 10]) + c = x.T + i = nditer([a, b, c], ['copy_if_overlap'], + [['readonly'], ['writeonly'], ['readonly']]) + a2, b2, c2 = i.operands + assert_(a is a2) + assert_(b is b2) + assert_(c is c2) + + # Copy not needed, 3 ops, write-only overlap + x = np.arange(7) + a = x[:3] + b = x[3:6] + c = x[4:7] + i = nditer([a, b, c], ['copy_if_overlap'], + [['readonly'], ['writeonly'], ['writeonly']]) + a2, b2, c2 = i.operands + assert_(a is a2) + assert_(b is b2) + assert_(c is c2) + +def test_iter_op_axes(): + # Check that custom axes work + + # Reverse the axes + a = arange(6).reshape(2, 3) + i = nditer([a, a.T], [], [['readonly']]*2, op_axes=[[0, 1], [1, 0]]) + assert_(all([x == y for (x, y) in i])) + a = arange(24).reshape(2, 3, 4) + i = nditer([a.T, a], [], [['readonly']]*2, op_axes=[[2, 1, 0], None]) + assert_(all([x == y for (x, y) in i])) + + # Broadcast 1D to any dimension + a = arange(1, 31).reshape(2, 3, 5) + b = arange(1, 3) + i = nditer([a, b], [], [['readonly']]*2, op_axes=[None, [0, -1, -1]]) + assert_equal([x*y for (x, y) in i], (a*b.reshape(2, 1, 1)).ravel()) + b = arange(1, 4) + i = nditer([a, b], [], [['readonly']]*2, op_axes=[None, [-1, 0, -1]]) + assert_equal([x*y for (x, y) in i], (a*b.reshape(1, 3, 1)).ravel()) + b = arange(1, 6) + i = nditer([a, b], [], [['readonly']]*2, + op_axes=[None, [np.newaxis, np.newaxis, 0]]) + assert_equal([x*y for (x, y) in i], (a*b.reshape(1, 1, 5)).ravel()) + + # Inner product-style broadcasting + a = arange(24).reshape(2, 3, 4) + b = arange(40).reshape(5, 2, 4) + i = nditer([a, b], ['multi_index'], [['readonly']]*2, + op_axes=[[0, 1, -1, -1], [-1, -1, 0, 1]]) + assert_equal(i.shape, (2, 3, 5, 2)) + + # Matrix product-style broadcasting + a = arange(12).reshape(3, 4) + b = arange(20).reshape(4, 5) + i = nditer([a, b], ['multi_index'], [['readonly']]*2, + op_axes=[[0, -1], [-1, 1]]) + assert_equal(i.shape, (3, 5)) + +def test_iter_op_axes_errors(): + # Check that custom axes throws errors for bad inputs + + # Wrong number of items in op_axes + a = arange(6).reshape(2, 3) + assert_raises(ValueError, nditer, [a, a], [], [['readonly']]*2, + op_axes=[[0], [1], [0]]) + # Out of bounds items in op_axes + assert_raises(ValueError, nditer, [a, a], [], [['readonly']]*2, + op_axes=[[2, 1], [0, 1]]) + assert_raises(ValueError, nditer, [a, a], [], [['readonly']]*2, + op_axes=[[0, 1], [2, -1]]) + # Duplicate items in op_axes + assert_raises(ValueError, nditer, [a, a], [], [['readonly']]*2, + op_axes=[[0, 0], [0, 1]]) + assert_raises(ValueError, nditer, [a, a], [], [['readonly']]*2, + op_axes=[[0, 1], [1, 1]]) + + # Different sized arrays in op_axes + assert_raises(ValueError, nditer, [a, a], [], [['readonly']]*2, + op_axes=[[0, 1], [0, 1, 0]]) + + # Non-broadcastable dimensions in the result + assert_raises(ValueError, nditer, [a, a], [], [['readonly']]*2, + op_axes=[[0, 1], [1, 0]]) + +def test_iter_copy(): + # Check that copying the iterator works correctly + a = arange(24).reshape(2, 3, 4) + + # Simple iterator + i = nditer(a) + j = i.copy() + assert_equal([x[()] for x in i], [x[()] for x in j]) + + i.iterindex = 3 + j = i.copy() + assert_equal([x[()] for x in i], [x[()] for x in j]) + + # Buffered iterator + i = nditer(a, ['buffered', 'ranged'], order='F', buffersize=3) + j = i.copy() + assert_equal([x[()] for x in i], [x[()] for x in j]) + + i.iterindex = 3 + j = i.copy() + assert_equal([x[()] for x in i], [x[()] for x in j]) + + i.iterrange = (3, 9) + j = i.copy() + assert_equal([x[()] for x in i], [x[()] for x in j]) + + i.iterrange = (2, 18) + next(i) + next(i) + j = i.copy() + assert_equal([x[()] for x in i], [x[()] for x in j]) + + # Casting iterator + with nditer(a, ['buffered'], order='F', casting='unsafe', + op_dtypes='f8', buffersize=5) as i: + j = i.copy() + assert_equal([x[()] for x in j], a.ravel(order='F')) + + a = arange(24, dtype=' unstructured (any to object), and many other + # casts, which cause this to require all steps in the casting machinery + # one level down as well as the iterator copy (which uses NpyAuxData clone) + in_dtype = np.dtype([("a", np.dtype("i,")), + ("b", np.dtype(">i,d,S17,>d,3f,O,i1"))]) + out_dtype = np.dtype([("a", np.dtype("O")), + ("b", np.dtype(">i,>i,S17,>d,>U3,3d,i1,O"))]) + arr = np.ones(1000, dtype=in_dtype) + + it = np.nditer((arr,), ["buffered", "external_loop", "refs_ok"], + op_dtypes=[out_dtype], casting="unsafe") + it_copy = it.copy() + + res1 = next(it) + del it + res2 = next(it_copy) + del it_copy + + expected = arr["a"].astype(out_dtype["a"]) + assert_array_equal(res1["a"], expected) + assert_array_equal(res2["a"], expected) + + for field in in_dtype["b"].names: + # Note that the .base avoids the subarray field + expected = arr["b"][field].astype(out_dtype["b"][field].base) + assert_array_equal(res1["b"][field], expected) + assert_array_equal(res2["b"][field], expected) + + +def test_iter_copy_casts_structured2(): + # Similar to the above, this is a fairly arcane test to cover internals + in_dtype = np.dtype([("a", np.dtype("O,O")), + ("b", np.dtype("5O,3O,(1,)O,(1,)i,(1,)O"))]) + out_dtype = np.dtype([("a", np.dtype("O")), + ("b", np.dtype("O,3i,4O,4O,4i"))]) + + arr = np.ones(1, dtype=in_dtype) + it = np.nditer((arr,), ["buffered", "external_loop", "refs_ok"], + op_dtypes=[out_dtype], casting="unsafe") + it_copy = it.copy() + + res1 = next(it) + del it + res2 = next(it_copy) + del it_copy + + # Array of two structured scalars: + for res in res1, res2: + # Cast to tuple by getitem, which may be weird and changeable?: + assert type(res["a"][0]) == tuple + assert res["a"][0] == (1, 1) + + for res in res1, res2: + assert_array_equal(res["b"]["f0"][0], np.ones(5, dtype=object)) + assert_array_equal(res["b"]["f1"], np.ones((1, 3), dtype="i")) + assert res["b"]["f2"].shape == (1, 4) + assert_array_equal(res["b"]["f2"][0], np.ones(4, dtype=object)) + assert_array_equal(res["b"]["f3"][0], np.ones(4, dtype=object)) + assert_array_equal(res["b"]["f3"][0], np.ones(4, dtype="i")) + + +def test_iter_allocate_output_simple(): + # Check that the iterator will properly allocate outputs + + # Simple case + a = arange(6) + i = nditer([a, None], [], [['readonly'], ['writeonly', 'allocate']], + op_dtypes=[None, np.dtype('f4')]) + assert_equal(i.operands[1].shape, a.shape) + assert_equal(i.operands[1].dtype, np.dtype('f4')) + +def test_iter_allocate_output_buffered_readwrite(): + # Allocated output with buffering + delay_bufalloc + + a = arange(6) + i = nditer([a, None], ['buffered', 'delay_bufalloc'], + [['readonly'], ['allocate', 'readwrite']]) + with i: + i.operands[1][:] = 1 + i.reset() + for x in i: + x[1][...] += x[0][...] + assert_equal(i.operands[1], a+1) + +def test_iter_allocate_output_itorder(): + # The allocated output should match the iteration order + + # C-order input, best iteration order + a = arange(6, dtype='i4').reshape(2, 3) + i = nditer([a, None], [], [['readonly'], ['writeonly', 'allocate']], + op_dtypes=[None, np.dtype('f4')]) + assert_equal(i.operands[1].shape, a.shape) + assert_equal(i.operands[1].strides, a.strides) + assert_equal(i.operands[1].dtype, np.dtype('f4')) + # F-order input, best iteration order + a = arange(24, dtype='i4').reshape(2, 3, 4).T + i = nditer([a, None], [], [['readonly'], ['writeonly', 'allocate']], + op_dtypes=[None, np.dtype('f4')]) + assert_equal(i.operands[1].shape, a.shape) + assert_equal(i.operands[1].strides, a.strides) + assert_equal(i.operands[1].dtype, np.dtype('f4')) + # Non-contiguous input, C iteration order + a = arange(24, dtype='i4').reshape(2, 3, 4).swapaxes(0, 1) + i = nditer([a, None], [], + [['readonly'], ['writeonly', 'allocate']], + order='C', + op_dtypes=[None, np.dtype('f4')]) + assert_equal(i.operands[1].shape, a.shape) + assert_equal(i.operands[1].strides, (32, 16, 4)) + assert_equal(i.operands[1].dtype, np.dtype('f4')) + +def test_iter_allocate_output_opaxes(): + # Specifying op_axes should work + + a = arange(24, dtype='i4').reshape(2, 3, 4) + i = nditer([None, a], [], [['writeonly', 'allocate'], ['readonly']], + op_dtypes=[np.dtype('u4'), None], + op_axes=[[1, 2, 0], None]) + assert_equal(i.operands[0].shape, (4, 2, 3)) + assert_equal(i.operands[0].strides, (4, 48, 16)) + assert_equal(i.operands[0].dtype, np.dtype('u4')) + +def test_iter_allocate_output_types_promotion(): + # Check type promotion of automatic outputs (this was more interesting + # before NEP 50...) + + i = nditer([array([3], dtype='f4'), array([0], dtype='f8'), None], [], + [['readonly']]*2+[['writeonly', 'allocate']]) + assert_equal(i.dtypes[2], np.dtype('f8')) + i = nditer([array([3], dtype='i4'), array([0], dtype='f4'), None], [], + [['readonly']]*2+[['writeonly', 'allocate']]) + assert_equal(i.dtypes[2], np.dtype('f8')) + i = nditer([array([3], dtype='f4'), array(0, dtype='f8'), None], [], + [['readonly']]*2+[['writeonly', 'allocate']]) + assert_equal(i.dtypes[2], np.dtype('f8')) + i = nditer([array([3], dtype='u4'), array(0, dtype='i4'), None], [], + [['readonly']]*2+[['writeonly', 'allocate']]) + assert_equal(i.dtypes[2], np.dtype('i8')) + i = nditer([array([3], dtype='u4'), array(-12, dtype='i4'), None], [], + [['readonly']]*2+[['writeonly', 'allocate']]) + assert_equal(i.dtypes[2], np.dtype('i8')) + +def test_iter_allocate_output_types_byte_order(): + # Verify the rules for byte order changes + + # When there's just one input, the output type exactly matches + a = array([3], dtype='u4') + a = a.view(a.dtype.newbyteorder()) + i = nditer([a, None], [], + [['readonly'], ['writeonly', 'allocate']]) + assert_equal(i.dtypes[0], i.dtypes[1]) + # With two or more inputs, the output type is in native byte order + i = nditer([a, a, None], [], + [['readonly'], ['readonly'], ['writeonly', 'allocate']]) + assert_(i.dtypes[0] != i.dtypes[2]) + assert_equal(i.dtypes[0].newbyteorder('='), i.dtypes[2]) + +def test_iter_allocate_output_types_scalar(): + # If the inputs are all scalars, the output should be a scalar + + i = nditer([None, 1, 2.3, np.float32(12), np.complex128(3)], [], + [['writeonly', 'allocate']] + [['readonly']]*4) + assert_equal(i.operands[0].dtype, np.dtype('complex128')) + assert_equal(i.operands[0].ndim, 0) + +def test_iter_allocate_output_subtype(): + # Make sure that the subtype with priority wins + class MyNDArray(np.ndarray): + __array_priority__ = 15 + + # subclass vs ndarray + a = np.array([[1, 2], [3, 4]]).view(MyNDArray) + b = np.arange(4).reshape(2, 2).T + i = nditer([a, b, None], [], + [['readonly'], ['readonly'], ['writeonly', 'allocate']]) + assert_equal(type(a), type(i.operands[2])) + assert_(type(b) is not type(i.operands[2])) + assert_equal(i.operands[2].shape, (2, 2)) + + # If subtypes are disabled, we should get back an ndarray. + i = nditer([a, b, None], [], + [['readonly'], ['readonly'], + ['writeonly', 'allocate', 'no_subtype']]) + assert_equal(type(b), type(i.operands[2])) + assert_(type(a) is not type(i.operands[2])) + assert_equal(i.operands[2].shape, (2, 2)) + +def test_iter_allocate_output_errors(): + # Check that the iterator will throw errors for bad output allocations + + # Need an input if no output data type is specified + a = arange(6) + assert_raises(TypeError, nditer, [a, None], [], + [['writeonly'], ['writeonly', 'allocate']]) + # Allocated output should be flagged for writing + assert_raises(ValueError, nditer, [a, None], [], + [['readonly'], ['allocate', 'readonly']]) + # Allocated output can't have buffering without delayed bufalloc + assert_raises(ValueError, nditer, [a, None], ['buffered'], + ['allocate', 'readwrite']) + # Must specify dtype if there are no inputs (cannot promote existing ones; + # maybe this should use the 'f4' here, but it does not historically.) + assert_raises(TypeError, nditer, [None, None], [], + [['writeonly', 'allocate'], + ['writeonly', 'allocate']], + op_dtypes=[None, np.dtype('f4')]) + # If using op_axes, must specify all the axes + a = arange(24, dtype='i4').reshape(2, 3, 4) + assert_raises(ValueError, nditer, [a, None], [], + [['readonly'], ['writeonly', 'allocate']], + op_dtypes=[None, np.dtype('f4')], + op_axes=[None, [0, np.newaxis, 1]]) + # If using op_axes, the axes must be within bounds + assert_raises(ValueError, nditer, [a, None], [], + [['readonly'], ['writeonly', 'allocate']], + op_dtypes=[None, np.dtype('f4')], + op_axes=[None, [0, 3, 1]]) + # If using op_axes, there can't be duplicates + assert_raises(ValueError, nditer, [a, None], [], + [['readonly'], ['writeonly', 'allocate']], + op_dtypes=[None, np.dtype('f4')], + op_axes=[None, [0, 2, 1, 0]]) + # Not all axes may be specified if a reduction. If there is a hole + # in op_axes, this is an error. + a = arange(24, dtype='i4').reshape(2, 3, 4) + assert_raises(ValueError, nditer, [a, None], ["reduce_ok"], + [['readonly'], ['readwrite', 'allocate']], + op_dtypes=[None, np.dtype('f4')], + op_axes=[None, [0, np.newaxis, 2]]) + +def test_all_allocated(): + # When no output and no shape is given, `()` is used as shape. + i = np.nditer([None], op_dtypes=["int64"]) + assert i.operands[0].shape == () + assert i.dtypes == (np.dtype("int64"),) + + i = np.nditer([None], op_dtypes=["int64"], itershape=(2, 3, 4)) + assert i.operands[0].shape == (2, 3, 4) + +def test_iter_remove_axis(): + a = arange(24).reshape(2, 3, 4) + + i = nditer(a, ['multi_index']) + i.remove_axis(1) + assert_equal([x for x in i], a[:, 0,:].ravel()) + + a = a[::-1,:,:] + i = nditer(a, ['multi_index']) + i.remove_axis(0) + assert_equal([x for x in i], a[0,:,:].ravel()) + +def test_iter_remove_multi_index_inner_loop(): + # Check that removing multi-index support works + + a = arange(24).reshape(2, 3, 4) + + i = nditer(a, ['multi_index']) + assert_equal(i.ndim, 3) + assert_equal(i.shape, (2, 3, 4)) + assert_equal(i.itviews[0].shape, (2, 3, 4)) + + # Removing the multi-index tracking causes all dimensions to coalesce + before = [x for x in i] + i.remove_multi_index() + after = [x for x in i] + + assert_equal(before, after) + assert_equal(i.ndim, 1) + assert_raises(ValueError, lambda i:i.shape, i) + assert_equal(i.itviews[0].shape, (24,)) + + # Removing the inner loop means there's just one iteration + i.reset() + assert_equal(i.itersize, 24) + assert_equal(i[0].shape, tuple()) + i.enable_external_loop() + assert_equal(i.itersize, 24) + assert_equal(i[0].shape, (24,)) + assert_equal(i.value, arange(24)) + +def test_iter_iterindex(): + # Make sure iterindex works + + buffersize = 5 + a = arange(24).reshape(4, 3, 2) + for flags in ([], ['buffered']): + i = nditer(a, flags, buffersize=buffersize) + assert_equal(iter_iterindices(i), list(range(24))) + i.iterindex = 2 + assert_equal(iter_iterindices(i), list(range(2, 24))) + + i = nditer(a, flags, order='F', buffersize=buffersize) + assert_equal(iter_iterindices(i), list(range(24))) + i.iterindex = 5 + assert_equal(iter_iterindices(i), list(range(5, 24))) + + i = nditer(a[::-1], flags, order='F', buffersize=buffersize) + assert_equal(iter_iterindices(i), list(range(24))) + i.iterindex = 9 + assert_equal(iter_iterindices(i), list(range(9, 24))) + + i = nditer(a[::-1, ::-1], flags, order='C', buffersize=buffersize) + assert_equal(iter_iterindices(i), list(range(24))) + i.iterindex = 13 + assert_equal(iter_iterindices(i), list(range(13, 24))) + + i = nditer(a[::1, ::-1], flags, buffersize=buffersize) + assert_equal(iter_iterindices(i), list(range(24))) + i.iterindex = 23 + assert_equal(iter_iterindices(i), list(range(23, 24))) + i.reset() + i.iterindex = 2 + assert_equal(iter_iterindices(i), list(range(2, 24))) + +def test_iter_iterrange(): + # Make sure getting and resetting the iterrange works + + buffersize = 5 + a = arange(24, dtype='i4').reshape(4, 3, 2) + a_fort = a.ravel(order='F') + + i = nditer(a, ['ranged'], ['readonly'], order='F', + buffersize=buffersize) + assert_equal(i.iterrange, (0, 24)) + assert_equal([x[()] for x in i], a_fort) + for r in [(0, 24), (1, 2), (3, 24), (5, 5), (0, 20), (23, 24)]: + i.iterrange = r + assert_equal(i.iterrange, r) + assert_equal([x[()] for x in i], a_fort[r[0]:r[1]]) + + i = nditer(a, ['ranged', 'buffered'], ['readonly'], order='F', + op_dtypes='f8', buffersize=buffersize) + assert_equal(i.iterrange, (0, 24)) + assert_equal([x[()] for x in i], a_fort) + for r in [(0, 24), (1, 2), (3, 24), (5, 5), (0, 20), (23, 24)]: + i.iterrange = r + assert_equal(i.iterrange, r) + assert_equal([x[()] for x in i], a_fort[r[0]:r[1]]) + + def get_array(i): + val = np.array([], dtype='f8') + for x in i: + val = np.concatenate((val, x)) + return val + + i = nditer(a, ['ranged', 'buffered', 'external_loop'], + ['readonly'], order='F', + op_dtypes='f8', buffersize=buffersize) + assert_equal(i.iterrange, (0, 24)) + assert_equal(get_array(i), a_fort) + for r in [(0, 24), (1, 2), (3, 24), (5, 5), (0, 20), (23, 24)]: + i.iterrange = r + assert_equal(i.iterrange, r) + assert_equal(get_array(i), a_fort[r[0]:r[1]]) + +def test_iter_buffering(): + # Test buffering with several buffer sizes and types + arrays = [] + # F-order swapped array + _tmp = np.arange(24, dtype='c16').reshape(2, 3, 4).T + _tmp = _tmp.view(_tmp.dtype.newbyteorder()).byteswap() + arrays.append(_tmp) + # Contiguous 1-dimensional array + arrays.append(np.arange(10, dtype='f4')) + # Unaligned array + a = np.zeros((4*16+1,), dtype='i1')[1:] + a.dtype = 'i4' + a[:] = np.arange(16, dtype='i4') + arrays.append(a) + # 4-D F-order array + arrays.append(np.arange(120, dtype='i4').reshape(5, 3, 2, 4).T) + for a in arrays: + for buffersize in (1, 2, 3, 5, 8, 11, 16, 1024): + vals = [] + i = nditer(a, ['buffered', 'external_loop'], + [['readonly', 'nbo', 'aligned']], + order='C', + casting='equiv', + buffersize=buffersize) + while not i.finished: + assert_(i[0].size <= buffersize) + vals.append(i[0].copy()) + i.iternext() + assert_equal(np.concatenate(vals), a.ravel(order='C')) + +def test_iter_write_buffering(): + # Test that buffering of writes is working + + # F-order swapped array + a = np.arange(24).reshape(2, 3, 4).T + a = a.view(a.dtype.newbyteorder()).byteswap() + i = nditer(a, ['buffered'], + [['readwrite', 'nbo', 'aligned']], + casting='equiv', + order='C', + buffersize=16) + x = 0 + with i: + while not i.finished: + i[0] = x + x += 1 + i.iternext() + assert_equal(a.ravel(order='C'), np.arange(24)) + +def test_iter_buffering_delayed_alloc(): + # Test that delaying buffer allocation works + + a = np.arange(6) + b = np.arange(1, dtype='f4') + i = nditer([a, b], ['buffered', 'delay_bufalloc', 'multi_index', 'reduce_ok'], + ['readwrite'], + casting='unsafe', + op_dtypes='f4') + assert_(i.has_delayed_bufalloc) + assert_raises(ValueError, lambda i:i.multi_index, i) + assert_raises(ValueError, lambda i:i[0], i) + assert_raises(ValueError, lambda i:i[0:2], i) + + def assign_iter(i): + i[0] = 0 + assert_raises(ValueError, assign_iter, i) + + i.reset() + assert_(not i.has_delayed_bufalloc) + assert_equal(i.multi_index, (0,)) + with i: + assert_equal(i[0], 0) + i[1] = 1 + assert_equal(i[0:2], [0, 1]) + assert_equal([[x[0][()], x[1][()]] for x in i], list(zip(range(6), [1]*6))) + +def test_iter_buffered_cast_simple(): + # Test that buffering can handle a simple cast + + a = np.arange(10, dtype='f4') + i = nditer(a, ['buffered', 'external_loop'], + [['readwrite', 'nbo', 'aligned']], + casting='same_kind', + op_dtypes=[np.dtype('f8')], + buffersize=3) + with i: + for v in i: + v[...] *= 2 + + assert_equal(a, 2*np.arange(10, dtype='f4')) + +def test_iter_buffered_cast_byteswapped(): + # Test that buffering can handle a cast which requires swap->cast->swap + + a = np.arange(10, dtype='f4') + a = a.view(a.dtype.newbyteorder()).byteswap() + i = nditer(a, ['buffered', 'external_loop'], + [['readwrite', 'nbo', 'aligned']], + casting='same_kind', + op_dtypes=[np.dtype('f8').newbyteorder()], + buffersize=3) + with i: + for v in i: + v[...] *= 2 + + assert_equal(a, 2*np.arange(10, dtype='f4')) + + with suppress_warnings() as sup: + sup.filter(np.exceptions.ComplexWarning) + + a = np.arange(10, dtype='f8') + a = a.view(a.dtype.newbyteorder()).byteswap() + i = nditer(a, ['buffered', 'external_loop'], + [['readwrite', 'nbo', 'aligned']], + casting='unsafe', + op_dtypes=[np.dtype('c8').newbyteorder()], + buffersize=3) + with i: + for v in i: + v[...] *= 2 + + assert_equal(a, 2*np.arange(10, dtype='f8')) + +def test_iter_buffered_cast_byteswapped_complex(): + # Test that buffering can handle a cast which requires swap->cast->copy + + a = np.arange(10, dtype='c8') + a = a.view(a.dtype.newbyteorder()).byteswap() + a += 2j + i = nditer(a, ['buffered', 'external_loop'], + [['readwrite', 'nbo', 'aligned']], + casting='same_kind', + op_dtypes=[np.dtype('c16')], + buffersize=3) + with i: + for v in i: + v[...] *= 2 + assert_equal(a, 2*np.arange(10, dtype='c8') + 4j) + + a = np.arange(10, dtype='c8') + a += 2j + i = nditer(a, ['buffered', 'external_loop'], + [['readwrite', 'nbo', 'aligned']], + casting='same_kind', + op_dtypes=[np.dtype('c16').newbyteorder()], + buffersize=3) + with i: + for v in i: + v[...] *= 2 + assert_equal(a, 2*np.arange(10, dtype='c8') + 4j) + + a = np.arange(10, dtype=np.clongdouble) + a = a.view(a.dtype.newbyteorder()).byteswap() + a += 2j + i = nditer(a, ['buffered', 'external_loop'], + [['readwrite', 'nbo', 'aligned']], + casting='same_kind', + op_dtypes=[np.dtype('c16')], + buffersize=3) + with i: + for v in i: + v[...] *= 2 + assert_equal(a, 2*np.arange(10, dtype=np.clongdouble) + 4j) + + a = np.arange(10, dtype=np.longdouble) + a = a.view(a.dtype.newbyteorder()).byteswap() + i = nditer(a, ['buffered', 'external_loop'], + [['readwrite', 'nbo', 'aligned']], + casting='same_kind', + op_dtypes=[np.dtype('f4')], + buffersize=7) + with i: + for v in i: + v[...] *= 2 + assert_equal(a, 2*np.arange(10, dtype=np.longdouble)) + +def test_iter_buffered_cast_structured_type(): + # Tests buffering of structured types + + # simple -> struct type (duplicates the value) + sdt = [('a', 'f4'), ('b', 'i8'), ('c', 'c8', (2, 3)), ('d', 'O')] + a = np.arange(3, dtype='f4') + 0.5 + i = nditer(a, ['buffered', 'refs_ok'], ['readonly'], + casting='unsafe', + op_dtypes=sdt) + vals = [np.array(x) for x in i] + assert_equal(vals[0]['a'], 0.5) + assert_equal(vals[0]['b'], 0) + assert_equal(vals[0]['c'], [[(0.5)]*3]*2) + assert_equal(vals[0]['d'], 0.5) + assert_equal(vals[1]['a'], 1.5) + assert_equal(vals[1]['b'], 1) + assert_equal(vals[1]['c'], [[(1.5)]*3]*2) + assert_equal(vals[1]['d'], 1.5) + assert_equal(vals[0].dtype, np.dtype(sdt)) + + # object -> struct type + sdt = [('a', 'f4'), ('b', 'i8'), ('c', 'c8', (2, 3)), ('d', 'O')] + a = np.zeros((3,), dtype='O') + a[0] = (0.5, 0.5, [[0.5, 0.5, 0.5], [0.5, 0.5, 0.5]], 0.5) + a[1] = (1.5, 1.5, [[1.5, 1.5, 1.5], [1.5, 1.5, 1.5]], 1.5) + a[2] = (2.5, 2.5, [[2.5, 2.5, 2.5], [2.5, 2.5, 2.5]], 2.5) + if HAS_REFCOUNT: + rc = sys.getrefcount(a[0]) + i = nditer(a, ['buffered', 'refs_ok'], ['readonly'], + casting='unsafe', + op_dtypes=sdt) + vals = [x.copy() for x in i] + assert_equal(vals[0]['a'], 0.5) + assert_equal(vals[0]['b'], 0) + assert_equal(vals[0]['c'], [[(0.5)]*3]*2) + assert_equal(vals[0]['d'], 0.5) + assert_equal(vals[1]['a'], 1.5) + assert_equal(vals[1]['b'], 1) + assert_equal(vals[1]['c'], [[(1.5)]*3]*2) + assert_equal(vals[1]['d'], 1.5) + assert_equal(vals[0].dtype, np.dtype(sdt)) + vals, i, x = [None]*3 + if HAS_REFCOUNT: + assert_equal(sys.getrefcount(a[0]), rc) + + # single-field struct type -> simple + sdt = [('a', 'f4')] + a = np.array([(5.5,), (8,)], dtype=sdt) + i = nditer(a, ['buffered', 'refs_ok'], ['readonly'], + casting='unsafe', + op_dtypes='i4') + assert_equal([x_[()] for x_ in i], [5, 8]) + + # make sure multi-field struct type -> simple doesn't work + sdt = [('a', 'f4'), ('b', 'i8'), ('d', 'O')] + a = np.array([(5.5, 7, 'test'), (8, 10, 11)], dtype=sdt) + assert_raises(TypeError, lambda: ( + nditer(a, ['buffered', 'refs_ok'], ['readonly'], + casting='unsafe', + op_dtypes='i4'))) + + # struct type -> struct type (field-wise copy) + sdt1 = [('a', 'f4'), ('b', 'i8'), ('d', 'O')] + sdt2 = [('d', 'u2'), ('a', 'O'), ('b', 'f8')] + a = np.array([(1, 2, 3), (4, 5, 6)], dtype=sdt1) + i = nditer(a, ['buffered', 'refs_ok'], ['readonly'], + casting='unsafe', + op_dtypes=sdt2) + assert_equal(i[0].dtype, np.dtype(sdt2)) + assert_equal([np.array(x_) for x_ in i], + [np.array((1, 2, 3), dtype=sdt2), + np.array((4, 5, 6), dtype=sdt2)]) + + +def test_iter_buffered_cast_structured_type_failure_with_cleanup(): + # make sure struct type -> struct type with different + # number of fields fails + sdt1 = [('a', 'f4'), ('b', 'i8'), ('d', 'O')] + sdt2 = [('b', 'O'), ('a', 'f8')] + a = np.array([(1, 2, 3), (4, 5, 6)], dtype=sdt1) + + for intent in ["readwrite", "readonly", "writeonly"]: + # This test was initially designed to test an error at a different + # place, but will now raise earlier to to the cast not being possible: + # `assert np.can_cast(a.dtype, sdt2, casting="unsafe")` fails. + # Without a faulty DType, there is probably no reliable + # way to get the initial tested behaviour. + simple_arr = np.array([1, 2], dtype="i,i") # requires clean up + with pytest.raises(TypeError): + nditer((simple_arr, a), ['buffered', 'refs_ok'], [intent, intent], + casting='unsafe', op_dtypes=["f,f", sdt2]) + + +def test_buffered_cast_error_paths(): + with pytest.raises(ValueError): + # The input is cast into an `S3` buffer + np.nditer((np.array("a", dtype="S1"),), op_dtypes=["i"], + casting="unsafe", flags=["buffered"]) + + # The `M8[ns]` is cast into the `S3` output + it = np.nditer((np.array(1, dtype="i"),), op_dtypes=["S1"], + op_flags=["writeonly"], casting="unsafe", flags=["buffered"]) + with pytest.raises(ValueError): + with it: + buf = next(it) + buf[...] = "a" # cannot be converted to int. + +@pytest.mark.skipif(IS_WASM, reason="Cannot start subprocess") +@pytest.mark.skipif(not HAS_REFCOUNT, reason="PyPy seems to not hit this.") +def test_buffered_cast_error_paths_unraisable(): + # The following gives an unraisable error. Pytest sometimes captures that + # (depending python and/or pytest version). So with Python>=3.8 this can + # probably be cleaned out in the future to check for + # pytest.PytestUnraisableExceptionWarning: + code = textwrap.dedent(""" + import numpy as np + + it = np.nditer((np.array(1, dtype="i"),), op_dtypes=["S1"], + op_flags=["writeonly"], casting="unsafe", flags=["buffered"]) + buf = next(it) + buf[...] = "a" + del buf, it # Flushing only happens during deallocate right now. + """) + res = subprocess.check_output([sys.executable, "-c", code], + stderr=subprocess.STDOUT, text=True) + assert "ValueError" in res + + +def test_iter_buffered_cast_subarray(): + # Tests buffering of subarrays + + # one element -> many (copies it to all) + sdt1 = [('a', 'f4')] + sdt2 = [('a', 'f8', (3, 2, 2))] + a = np.zeros((6,), dtype=sdt1) + a['a'] = np.arange(6) + i = nditer(a, ['buffered', 'refs_ok'], ['readonly'], + casting='unsafe', + op_dtypes=sdt2) + assert_equal(i[0].dtype, np.dtype(sdt2)) + for x, count in zip(i, list(range(6))): + assert_(np.all(x['a'] == count)) + + # one element -> many -> back (copies it to all) + sdt1 = [('a', 'O', (1, 1))] + sdt2 = [('a', 'O', (3, 2, 2))] + a = np.zeros((6,), dtype=sdt1) + a['a'][:, 0, 0] = np.arange(6) + i = nditer(a, ['buffered', 'refs_ok'], ['readwrite'], + casting='unsafe', + op_dtypes=sdt2) + with i: + assert_equal(i[0].dtype, np.dtype(sdt2)) + count = 0 + for x in i: + assert_(np.all(x['a'] == count)) + x['a'][0] += 2 + count += 1 + assert_equal(a['a'], np.arange(6).reshape(6, 1, 1)+2) + + # many -> one element -> back (copies just element 0) + sdt1 = [('a', 'O', (3, 2, 2))] + sdt2 = [('a', 'O', (1,))] + a = np.zeros((6,), dtype=sdt1) + a['a'][:, 0, 0, 0] = np.arange(6) + i = nditer(a, ['buffered', 'refs_ok'], ['readwrite'], + casting='unsafe', + op_dtypes=sdt2) + with i: + assert_equal(i[0].dtype, np.dtype(sdt2)) + count = 0 + for x in i: + assert_equal(x['a'], count) + x['a'] += 2 + count += 1 + assert_equal(a['a'], np.arange(6).reshape(6, 1, 1, 1)*np.ones((1, 3, 2, 2))+2) + + # many -> one element -> back (copies just element 0) + sdt1 = [('a', 'f8', (3, 2, 2))] + sdt2 = [('a', 'O', (1,))] + a = np.zeros((6,), dtype=sdt1) + a['a'][:, 0, 0, 0] = np.arange(6) + i = nditer(a, ['buffered', 'refs_ok'], ['readonly'], + casting='unsafe', + op_dtypes=sdt2) + assert_equal(i[0].dtype, np.dtype(sdt2)) + count = 0 + for x in i: + assert_equal(x['a'], count) + count += 1 + + # many -> one element (copies just element 0) + sdt1 = [('a', 'O', (3, 2, 2))] + sdt2 = [('a', 'f4', (1,))] + a = np.zeros((6,), dtype=sdt1) + a['a'][:, 0, 0, 0] = np.arange(6) + i = nditer(a, ['buffered', 'refs_ok'], ['readonly'], + casting='unsafe', + op_dtypes=sdt2) + assert_equal(i[0].dtype, np.dtype(sdt2)) + count = 0 + for x in i: + assert_equal(x['a'], count) + count += 1 + + # many -> matching shape (straightforward copy) + sdt1 = [('a', 'O', (3, 2, 2))] + sdt2 = [('a', 'f4', (3, 2, 2))] + a = np.zeros((6,), dtype=sdt1) + a['a'] = np.arange(6*3*2*2).reshape(6, 3, 2, 2) + i = nditer(a, ['buffered', 'refs_ok'], ['readonly'], + casting='unsafe', + op_dtypes=sdt2) + assert_equal(i[0].dtype, np.dtype(sdt2)) + count = 0 + for x in i: + assert_equal(x['a'], a[count]['a']) + count += 1 + + # vector -> smaller vector (truncates) + sdt1 = [('a', 'f8', (6,))] + sdt2 = [('a', 'f4', (2,))] + a = np.zeros((6,), dtype=sdt1) + a['a'] = np.arange(6*6).reshape(6, 6) + i = nditer(a, ['buffered', 'refs_ok'], ['readonly'], + casting='unsafe', + op_dtypes=sdt2) + assert_equal(i[0].dtype, np.dtype(sdt2)) + count = 0 + for x in i: + assert_equal(x['a'], a[count]['a'][:2]) + count += 1 + + # vector -> bigger vector (pads with zeros) + sdt1 = [('a', 'f8', (2,))] + sdt2 = [('a', 'f4', (6,))] + a = np.zeros((6,), dtype=sdt1) + a['a'] = np.arange(6*2).reshape(6, 2) + i = nditer(a, ['buffered', 'refs_ok'], ['readonly'], + casting='unsafe', + op_dtypes=sdt2) + assert_equal(i[0].dtype, np.dtype(sdt2)) + count = 0 + for x in i: + assert_equal(x['a'][:2], a[count]['a']) + assert_equal(x['a'][2:], [0, 0, 0, 0]) + count += 1 + + # vector -> matrix (broadcasts) + sdt1 = [('a', 'f8', (2,))] + sdt2 = [('a', 'f4', (2, 2))] + a = np.zeros((6,), dtype=sdt1) + a['a'] = np.arange(6*2).reshape(6, 2) + i = nditer(a, ['buffered', 'refs_ok'], ['readonly'], + casting='unsafe', + op_dtypes=sdt2) + assert_equal(i[0].dtype, np.dtype(sdt2)) + count = 0 + for x in i: + assert_equal(x['a'][0], a[count]['a']) + assert_equal(x['a'][1], a[count]['a']) + count += 1 + + # vector -> matrix (broadcasts and zero-pads) + sdt1 = [('a', 'f8', (2, 1))] + sdt2 = [('a', 'f4', (3, 2))] + a = np.zeros((6,), dtype=sdt1) + a['a'] = np.arange(6*2).reshape(6, 2, 1) + i = nditer(a, ['buffered', 'refs_ok'], ['readonly'], + casting='unsafe', + op_dtypes=sdt2) + assert_equal(i[0].dtype, np.dtype(sdt2)) + count = 0 + for x in i: + assert_equal(x['a'][:2, 0], a[count]['a'][:, 0]) + assert_equal(x['a'][:2, 1], a[count]['a'][:, 0]) + assert_equal(x['a'][2,:], [0, 0]) + count += 1 + + # matrix -> matrix (truncates and zero-pads) + sdt1 = [('a', 'f8', (2, 3))] + sdt2 = [('a', 'f4', (3, 2))] + a = np.zeros((6,), dtype=sdt1) + a['a'] = np.arange(6*2*3).reshape(6, 2, 3) + i = nditer(a, ['buffered', 'refs_ok'], ['readonly'], + casting='unsafe', + op_dtypes=sdt2) + assert_equal(i[0].dtype, np.dtype(sdt2)) + count = 0 + for x in i: + assert_equal(x['a'][:2, 0], a[count]['a'][:, 0]) + assert_equal(x['a'][:2, 1], a[count]['a'][:, 1]) + assert_equal(x['a'][2,:], [0, 0]) + count += 1 + +def test_iter_buffering_badwriteback(): + # Writing back from a buffer cannot combine elements + + # a needs write buffering, but had a broadcast dimension + a = np.arange(6).reshape(2, 3, 1) + b = np.arange(12).reshape(2, 3, 2) + assert_raises(ValueError, nditer, [a, b], + ['buffered', 'external_loop'], + [['readwrite'], ['writeonly']], + order='C') + + # But if a is readonly, it's fine + nditer([a, b], ['buffered', 'external_loop'], + [['readonly'], ['writeonly']], + order='C') + + # If a has just one element, it's fine too (constant 0 stride, a reduction) + a = np.arange(1).reshape(1, 1, 1) + nditer([a, b], ['buffered', 'external_loop', 'reduce_ok'], + [['readwrite'], ['writeonly']], + order='C') + + # check that it fails on other dimensions too + a = np.arange(6).reshape(1, 3, 2) + assert_raises(ValueError, nditer, [a, b], + ['buffered', 'external_loop'], + [['readwrite'], ['writeonly']], + order='C') + a = np.arange(4).reshape(2, 1, 2) + assert_raises(ValueError, nditer, [a, b], + ['buffered', 'external_loop'], + [['readwrite'], ['writeonly']], + order='C') + +def test_iter_buffering_string(): + # Safe casting disallows shrinking strings + a = np.array(['abc', 'a', 'abcd'], dtype=np.bytes_) + assert_equal(a.dtype, np.dtype('S4')) + assert_raises(TypeError, nditer, a, ['buffered'], ['readonly'], + op_dtypes='S2') + i = nditer(a, ['buffered'], ['readonly'], op_dtypes='S6') + assert_equal(i[0], b'abc') + assert_equal(i[0].dtype, np.dtype('S6')) + + a = np.array(['abc', 'a', 'abcd'], dtype=np.str_) + assert_equal(a.dtype, np.dtype('U4')) + assert_raises(TypeError, nditer, a, ['buffered'], ['readonly'], + op_dtypes='U2') + i = nditer(a, ['buffered'], ['readonly'], op_dtypes='U6') + assert_equal(i[0], 'abc') + assert_equal(i[0].dtype, np.dtype('U6')) + +def test_iter_buffering_growinner(): + # Test that the inner loop grows when no buffering is needed + a = np.arange(30) + i = nditer(a, ['buffered', 'growinner', 'external_loop'], + buffersize=5) + # Should end up with just one inner loop here + assert_equal(i[0].size, a.size) + + +@pytest.mark.slow +def test_iter_buffered_reduce_reuse(): + # large enough array for all views, including negative strides. + a = np.arange(2*3**5)[3**5:3**5+1] + flags = ['buffered', 'delay_bufalloc', 'multi_index', 'reduce_ok', 'refs_ok'] + op_flags = [('readonly',), ('readwrite', 'allocate')] + op_axes_list = [[(0, 1, 2), (0, 1, -1)], [(0, 1, 2), (0, -1, -1)]] + # wrong dtype to force buffering + op_dtypes = [float, a.dtype] + + def get_params(): + for xs in range(-3**2, 3**2 + 1): + for ys in range(xs, 3**2 + 1): + for op_axes in op_axes_list: + # last stride is reduced and because of that not + # important for this test, as it is the inner stride. + strides = (xs * a.itemsize, ys * a.itemsize, a.itemsize) + arr = np.lib.stride_tricks.as_strided(a, (3, 3, 3), strides) + + for skip in [0, 1]: + yield arr, op_axes, skip + + for arr, op_axes, skip in get_params(): + nditer2 = np.nditer([arr.copy(), None], + op_axes=op_axes, flags=flags, op_flags=op_flags, + op_dtypes=op_dtypes) + with nditer2: + nditer2.operands[-1][...] = 0 + nditer2.reset() + nditer2.iterindex = skip + + for (a2_in, b2_in) in nditer2: + b2_in += a2_in.astype(np.int_) + + comp_res = nditer2.operands[-1] + + for bufsize in range(0, 3**3): + nditer1 = np.nditer([arr, None], + op_axes=op_axes, flags=flags, op_flags=op_flags, + buffersize=bufsize, op_dtypes=op_dtypes) + with nditer1: + nditer1.operands[-1][...] = 0 + nditer1.reset() + nditer1.iterindex = skip + + for (a1_in, b1_in) in nditer1: + b1_in += a1_in.astype(np.int_) + + res = nditer1.operands[-1] + assert_array_equal(res, comp_res) + + +def test_iter_no_broadcast(): + # Test that the no_broadcast flag works + a = np.arange(24).reshape(2, 3, 4) + b = np.arange(6).reshape(2, 3, 1) + c = np.arange(12).reshape(3, 4) + + nditer([a, b, c], [], + [['readonly', 'no_broadcast'], + ['readonly'], ['readonly']]) + assert_raises(ValueError, nditer, [a, b, c], [], + [['readonly'], ['readonly', 'no_broadcast'], ['readonly']]) + assert_raises(ValueError, nditer, [a, b, c], [], + [['readonly'], ['readonly'], ['readonly', 'no_broadcast']]) + + +class TestIterNested: + + def test_basic(self): + # Test nested iteration basic usage + a = arange(12).reshape(2, 3, 2) + + i, j = np.nested_iters(a, [[0], [1, 2]]) + vals = [list(j) for _ in i] + assert_equal(vals, [[0, 1, 2, 3, 4, 5], [6, 7, 8, 9, 10, 11]]) + + i, j = np.nested_iters(a, [[0, 1], [2]]) + vals = [list(j) for _ in i] + assert_equal(vals, [[0, 1], [2, 3], [4, 5], [6, 7], [8, 9], [10, 11]]) + + i, j = np.nested_iters(a, [[0, 2], [1]]) + vals = [list(j) for _ in i] + assert_equal(vals, [[0, 2, 4], [1, 3, 5], [6, 8, 10], [7, 9, 11]]) + + def test_reorder(self): + # Test nested iteration basic usage + a = arange(12).reshape(2, 3, 2) + + # In 'K' order (default), it gets reordered + i, j = np.nested_iters(a, [[0], [2, 1]]) + vals = [list(j) for _ in i] + assert_equal(vals, [[0, 1, 2, 3, 4, 5], [6, 7, 8, 9, 10, 11]]) + + i, j = np.nested_iters(a, [[1, 0], [2]]) + vals = [list(j) for _ in i] + assert_equal(vals, [[0, 1], [2, 3], [4, 5], [6, 7], [8, 9], [10, 11]]) + + i, j = np.nested_iters(a, [[2, 0], [1]]) + vals = [list(j) for _ in i] + assert_equal(vals, [[0, 2, 4], [1, 3, 5], [6, 8, 10], [7, 9, 11]]) + + # In 'C' order, it doesn't + i, j = np.nested_iters(a, [[0], [2, 1]], order='C') + vals = [list(j) for _ in i] + assert_equal(vals, [[0, 2, 4, 1, 3, 5], [6, 8, 10, 7, 9, 11]]) + + i, j = np.nested_iters(a, [[1, 0], [2]], order='C') + vals = [list(j) for _ in i] + assert_equal(vals, [[0, 1], [6, 7], [2, 3], [8, 9], [4, 5], [10, 11]]) + + i, j = np.nested_iters(a, [[2, 0], [1]], order='C') + vals = [list(j) for _ in i] + assert_equal(vals, [[0, 2, 4], [6, 8, 10], [1, 3, 5], [7, 9, 11]]) + + def test_flip_axes(self): + # Test nested iteration with negative axes + a = arange(12).reshape(2, 3, 2)[::-1, ::-1, ::-1] + + # In 'K' order (default), the axes all get flipped + i, j = np.nested_iters(a, [[0], [1, 2]]) + vals = [list(j) for _ in i] + assert_equal(vals, [[0, 1, 2, 3, 4, 5], [6, 7, 8, 9, 10, 11]]) + + i, j = np.nested_iters(a, [[0, 1], [2]]) + vals = [list(j) for _ in i] + assert_equal(vals, [[0, 1], [2, 3], [4, 5], [6, 7], [8, 9], [10, 11]]) + + i, j = np.nested_iters(a, [[0, 2], [1]]) + vals = [list(j) for _ in i] + assert_equal(vals, [[0, 2, 4], [1, 3, 5], [6, 8, 10], [7, 9, 11]]) + + # In 'C' order, flipping axes is disabled + i, j = np.nested_iters(a, [[0], [1, 2]], order='C') + vals = [list(j) for _ in i] + assert_equal(vals, [[11, 10, 9, 8, 7, 6], [5, 4, 3, 2, 1, 0]]) + + i, j = np.nested_iters(a, [[0, 1], [2]], order='C') + vals = [list(j) for _ in i] + assert_equal(vals, [[11, 10], [9, 8], [7, 6], [5, 4], [3, 2], [1, 0]]) + + i, j = np.nested_iters(a, [[0, 2], [1]], order='C') + vals = [list(j) for _ in i] + assert_equal(vals, [[11, 9, 7], [10, 8, 6], [5, 3, 1], [4, 2, 0]]) + + def test_broadcast(self): + # Test nested iteration with broadcasting + a = arange(2).reshape(2, 1) + b = arange(3).reshape(1, 3) + + i, j = np.nested_iters([a, b], [[0], [1]]) + vals = [list(j) for _ in i] + assert_equal(vals, [[[0, 0], [0, 1], [0, 2]], [[1, 0], [1, 1], [1, 2]]]) + + i, j = np.nested_iters([a, b], [[1], [0]]) + vals = [list(j) for _ in i] + assert_equal(vals, [[[0, 0], [1, 0]], [[0, 1], [1, 1]], [[0, 2], [1, 2]]]) + + def test_dtype_copy(self): + # Test nested iteration with a copy to change dtype + + # copy + a = arange(6, dtype='i4').reshape(2, 3) + i, j = np.nested_iters(a, [[0], [1]], + op_flags=['readonly', 'copy'], + op_dtypes='f8') + assert_equal(j[0].dtype, np.dtype('f8')) + vals = [list(j) for _ in i] + assert_equal(vals, [[0, 1, 2], [3, 4, 5]]) + vals = None + + # writebackifcopy - using context manager + a = arange(6, dtype='f4').reshape(2, 3) + i, j = np.nested_iters(a, [[0], [1]], + op_flags=['readwrite', 'updateifcopy'], + casting='same_kind', + op_dtypes='f8') + with i, j: + assert_equal(j[0].dtype, np.dtype('f8')) + for x in i: + for y in j: + y[...] += 1 + assert_equal(a, [[0, 1, 2], [3, 4, 5]]) + assert_equal(a, [[1, 2, 3], [4, 5, 6]]) + + # writebackifcopy - using close() + a = arange(6, dtype='f4').reshape(2, 3) + i, j = np.nested_iters(a, [[0], [1]], + op_flags=['readwrite', 'updateifcopy'], + casting='same_kind', + op_dtypes='f8') + assert_equal(j[0].dtype, np.dtype('f8')) + for x in i: + for y in j: + y[...] += 1 + assert_equal(a, [[0, 1, 2], [3, 4, 5]]) + i.close() + j.close() + assert_equal(a, [[1, 2, 3], [4, 5, 6]]) + + def test_dtype_buffered(self): + # Test nested iteration with buffering to change dtype + + a = arange(6, dtype='f4').reshape(2, 3) + i, j = np.nested_iters(a, [[0], [1]], + flags=['buffered'], + op_flags=['readwrite'], + casting='same_kind', + op_dtypes='f8') + assert_equal(j[0].dtype, np.dtype('f8')) + for x in i: + for y in j: + y[...] += 1 + assert_equal(a, [[1, 2, 3], [4, 5, 6]]) + + def test_0d(self): + a = np.arange(12).reshape(2, 3, 2) + i, j = np.nested_iters(a, [[], [1, 0, 2]]) + vals = [list(j) for _ in i] + assert_equal(vals, [[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]]) + + i, j = np.nested_iters(a, [[1, 0, 2], []]) + vals = [list(j) for _ in i] + assert_equal(vals, [[0], [1], [2], [3], [4], [5], [6], [7], [8], [9], [10], [11]]) + + i, j, k = np.nested_iters(a, [[2, 0], [], [1]]) + vals = [] + for x in i: + for y in j: + vals.append([z for z in k]) + assert_equal(vals, [[0, 2, 4], [1, 3, 5], [6, 8, 10], [7, 9, 11]]) + + def test_iter_nested_iters_dtype_buffered(self): + # Test nested iteration with buffering to change dtype + + a = arange(6, dtype='f4').reshape(2, 3) + i, j = np.nested_iters(a, [[0], [1]], + flags=['buffered'], + op_flags=['readwrite'], + casting='same_kind', + op_dtypes='f8') + with i, j: + assert_equal(j[0].dtype, np.dtype('f8')) + for x in i: + for y in j: + y[...] += 1 + assert_equal(a, [[1, 2, 3], [4, 5, 6]]) + +def test_iter_reduction_error(): + + a = np.arange(6) + assert_raises(ValueError, nditer, [a, None], [], + [['readonly'], ['readwrite', 'allocate']], + op_axes=[[0], [-1]]) + + a = np.arange(6).reshape(2, 3) + assert_raises(ValueError, nditer, [a, None], ['external_loop'], + [['readonly'], ['readwrite', 'allocate']], + op_axes=[[0, 1], [-1, -1]]) + +def test_iter_reduction(): + # Test doing reductions with the iterator + + a = np.arange(6) + i = nditer([a, None], ['reduce_ok'], + [['readonly'], ['readwrite', 'allocate']], + op_axes=[[0], [-1]]) + # Need to initialize the output operand to the addition unit + with i: + i.operands[1][...] = 0 + # Do the reduction + for x, y in i: + y[...] += x + # Since no axes were specified, should have allocated a scalar + assert_equal(i.operands[1].ndim, 0) + assert_equal(i.operands[1], np.sum(a)) + + a = np.arange(6).reshape(2, 3) + i = nditer([a, None], ['reduce_ok', 'external_loop'], + [['readonly'], ['readwrite', 'allocate']], + op_axes=[[0, 1], [-1, -1]]) + # Need to initialize the output operand to the addition unit + with i: + i.operands[1][...] = 0 + # Reduction shape/strides for the output + assert_equal(i[1].shape, (6,)) + assert_equal(i[1].strides, (0,)) + # Do the reduction + for x, y in i: + # Use a for loop instead of ``y[...] += x`` + # (equivalent to ``y[...] = y[...].copy() + x``), + # because y has zero strides we use for the reduction + for j in range(len(y)): + y[j] += x[j] + # Since no axes were specified, should have allocated a scalar + assert_equal(i.operands[1].ndim, 0) + assert_equal(i.operands[1], np.sum(a)) + + # This is a tricky reduction case for the buffering double loop + # to handle + a = np.ones((2, 3, 5)) + it1 = nditer([a, None], ['reduce_ok', 'external_loop'], + [['readonly'], ['readwrite', 'allocate']], + op_axes=[None, [0, -1, 1]]) + it2 = nditer([a, None], ['reduce_ok', 'external_loop', + 'buffered', 'delay_bufalloc'], + [['readonly'], ['readwrite', 'allocate']], + op_axes=[None, [0, -1, 1]], buffersize=10) + with it1, it2: + it1.operands[1].fill(0) + it2.operands[1].fill(0) + it2.reset() + for x in it1: + x[1][...] += x[0] + for x in it2: + x[1][...] += x[0] + assert_equal(it1.operands[1], it2.operands[1]) + assert_equal(it2.operands[1].sum(), a.size) + +def test_iter_buffering_reduction(): + # Test doing buffered reductions with the iterator + + a = np.arange(6) + b = np.array(0., dtype='f8').byteswap() + b = b.view(b.dtype.newbyteorder()) + i = nditer([a, b], ['reduce_ok', 'buffered'], + [['readonly'], ['readwrite', 'nbo']], + op_axes=[[0], [-1]]) + with i: + assert_equal(i[1].dtype, np.dtype('f8')) + assert_(i[1].dtype != b.dtype) + # Do the reduction + for x, y in i: + y[...] += x + # Since no axes were specified, should have allocated a scalar + assert_equal(b, np.sum(a)) + + a = np.arange(6).reshape(2, 3) + b = np.array([0, 0], dtype='f8').byteswap() + b = b.view(b.dtype.newbyteorder()) + i = nditer([a, b], ['reduce_ok', 'external_loop', 'buffered'], + [['readonly'], ['readwrite', 'nbo']], + op_axes=[[0, 1], [0, -1]]) + # Reduction shape/strides for the output + with i: + assert_equal(i[1].shape, (3,)) + assert_equal(i[1].strides, (0,)) + # Do the reduction + for x, y in i: + # Use a for loop instead of ``y[...] += x`` + # (equivalent to ``y[...] = y[...].copy() + x``), + # because y has zero strides we use for the reduction + for j in range(len(y)): + y[j] += x[j] + assert_equal(b, np.sum(a, axis=1)) + + # Iterator inner double loop was wrong on this one + p = np.arange(2) + 1 + it = np.nditer([p, None], + ['delay_bufalloc', 'reduce_ok', 'buffered', 'external_loop'], + [['readonly'], ['readwrite', 'allocate']], + op_axes=[[-1, 0], [-1, -1]], + itershape=(2, 2)) + with it: + it.operands[1].fill(0) + it.reset() + assert_equal(it[0], [1, 2, 1, 2]) + + # Iterator inner loop should take argument contiguity into account + x = np.ones((7, 13, 8), np.int8)[4:6,1:11:6,1:5].transpose(1, 2, 0) + x[...] = np.arange(x.size).reshape(x.shape) + y_base = np.arange(4*4, dtype=np.int8).reshape(4, 4) + y_base_copy = y_base.copy() + y = y_base[::2,:,None] + + it = np.nditer([y, x], + ['buffered', 'external_loop', 'reduce_ok'], + [['readwrite'], ['readonly']]) + with it: + for a, b in it: + a.fill(2) + + assert_equal(y_base[1::2], y_base_copy[1::2]) + assert_equal(y_base[::2], 2) + +def test_iter_buffering_reduction_reuse_reduce_loops(): + # There was a bug triggering reuse of the reduce loop inappropriately, + # which caused processing to happen in unnecessarily small chunks + # and overran the buffer. + + a = np.zeros((2, 7)) + b = np.zeros((1, 7)) + it = np.nditer([a, b], flags=['reduce_ok', 'external_loop', 'buffered'], + op_flags=[['readonly'], ['readwrite']], + buffersize=5) + + with it: + bufsizes = [x.shape[0] for x, y in it] + assert_equal(bufsizes, [5, 2, 5, 2]) + assert_equal(sum(bufsizes), a.size) + +def test_iter_writemasked_badinput(): + a = np.zeros((2, 3)) + b = np.zeros((3,)) + m = np.array([[True, True, False], [False, True, False]]) + m2 = np.array([True, True, False]) + m3 = np.array([0, 1, 1], dtype='u1') + mbad1 = np.array([0, 1, 1], dtype='i1') + mbad2 = np.array([0, 1, 1], dtype='f4') + + # Need an 'arraymask' if any operand is 'writemasked' + assert_raises(ValueError, nditer, [a, m], [], + [['readwrite', 'writemasked'], ['readonly']]) + + # A 'writemasked' operand must not be readonly + assert_raises(ValueError, nditer, [a, m], [], + [['readonly', 'writemasked'], ['readonly', 'arraymask']]) + + # 'writemasked' and 'arraymask' may not be used together + assert_raises(ValueError, nditer, [a, m], [], + [['readonly'], ['readwrite', 'arraymask', 'writemasked']]) + + # 'arraymask' may only be specified once + assert_raises(ValueError, nditer, [a, m, m2], [], + [['readwrite', 'writemasked'], + ['readonly', 'arraymask'], + ['readonly', 'arraymask']]) + + # An 'arraymask' with nothing 'writemasked' also doesn't make sense + assert_raises(ValueError, nditer, [a, m], [], + [['readwrite'], ['readonly', 'arraymask']]) + + # A writemasked reduction requires a similarly smaller mask + assert_raises(ValueError, nditer, [a, b, m], ['reduce_ok'], + [['readonly'], + ['readwrite', 'writemasked'], + ['readonly', 'arraymask']]) + # But this should work with a smaller/equal mask to the reduction operand + np.nditer([a, b, m2], ['reduce_ok'], + [['readonly'], + ['readwrite', 'writemasked'], + ['readonly', 'arraymask']]) + # The arraymask itself cannot be a reduction + assert_raises(ValueError, nditer, [a, b, m2], ['reduce_ok'], + [['readonly'], + ['readwrite', 'writemasked'], + ['readwrite', 'arraymask']]) + + # A uint8 mask is ok too + np.nditer([a, m3], ['buffered'], + [['readwrite', 'writemasked'], + ['readonly', 'arraymask']], + op_dtypes=['f4', None], + casting='same_kind') + # An int8 mask isn't ok + assert_raises(TypeError, np.nditer, [a, mbad1], ['buffered'], + [['readwrite', 'writemasked'], + ['readonly', 'arraymask']], + op_dtypes=['f4', None], + casting='same_kind') + # A float32 mask isn't ok + assert_raises(TypeError, np.nditer, [a, mbad2], ['buffered'], + [['readwrite', 'writemasked'], + ['readonly', 'arraymask']], + op_dtypes=['f4', None], + casting='same_kind') + + +def _is_buffered(iterator): + try: + iterator.itviews + except ValueError: + return True + return False + +@pytest.mark.parametrize("a", + [np.zeros((3,), dtype='f8'), + np.zeros((9876, 3*5), dtype='f8')[::2, :], + np.zeros((4, 312, 124, 3), dtype='f8')[::2, :, ::2, :], + # Also test with the last dimension strided (so it does not fit if + # there is repeated access) + np.zeros((9,), dtype='f8')[::3], + np.zeros((9876, 3*10), dtype='f8')[::2, ::5], + np.zeros((4, 312, 124, 3), dtype='f8')[::2, :, ::2, ::-1]]) +def test_iter_writemasked(a): + # Note, the slicing above is to ensure that nditer cannot combine multiple + # axes into one. The repetition is just to make things a bit more + # interesting. + shape = a.shape + reps = shape[-1] // 3 + msk = np.empty(shape, dtype=bool) + msk[...] = [True, True, False] * reps + + # When buffering is unused, 'writemasked' effectively does nothing. + # It's up to the user of the iterator to obey the requested semantics. + it = np.nditer([a, msk], [], + [['readwrite', 'writemasked'], + ['readonly', 'arraymask']]) + with it: + for x, m in it: + x[...] = 1 + # Because we violated the semantics, all the values became 1 + assert_equal(a, np.broadcast_to([1, 1, 1] * reps, shape)) + + # Even if buffering is enabled, we still may be accessing the array + # directly. + it = np.nditer([a, msk], ['buffered'], + [['readwrite', 'writemasked'], + ['readonly', 'arraymask']]) + # @seberg: I honestly don't currently understand why a "buffered" iterator + # would end up not using a buffer for the small array here at least when + # "writemasked" is used, that seems confusing... Check by testing for + # actual memory overlap! + is_buffered = True + with it: + for x, m in it: + x[...] = 2.5 + if np.may_share_memory(x, a): + is_buffered = False + + if not is_buffered: + # Because we violated the semantics, all the values became 2.5 + assert_equal(a, np.broadcast_to([2.5, 2.5, 2.5] * reps, shape)) + else: + # For large sizes, the iterator may be buffered: + assert_equal(a, np.broadcast_to([2.5, 2.5, 1] * reps, shape)) + a[...] = 2.5 + + # If buffering will definitely happening, for instance because of + # a cast, only the items selected by the mask will be copied back from + # the buffer. + it = np.nditer([a, msk], ['buffered'], + [['readwrite', 'writemasked'], + ['readonly', 'arraymask']], + op_dtypes=['i8', None], + casting='unsafe') + with it: + for x, m in it: + x[...] = 3 + # Even though we violated the semantics, only the selected values + # were copied back + assert_equal(a, np.broadcast_to([3, 3, 2.5] * reps, shape)) + + +@pytest.mark.parametrize(["mask", "mask_axes"], [ + # Allocated operand (only broadcasts with -1) + (None, [-1, 0]), + # Reduction along the first dimension (with and without op_axes) + (np.zeros((1, 4), dtype="bool"), [0, 1]), + (np.zeros((1, 4), dtype="bool"), None), + # Test 0-D and -1 op_axes + (np.zeros(4, dtype="bool"), [-1, 0]), + (np.zeros((), dtype="bool"), [-1, -1]), + (np.zeros((), dtype="bool"), None)]) +def test_iter_writemasked_broadcast_error(mask, mask_axes): + # This assumes that a readwrite mask makes sense. This is likely not the + # case and should simply be deprecated. + arr = np.zeros((3, 4)) + itflags = ["reduce_ok"] + mask_flags = ["arraymask", "readwrite", "allocate"] + a_flags = ["writeonly", "writemasked"] + if mask_axes is None: + op_axes = None + else: + op_axes = [mask_axes, [0, 1]] + + with assert_raises(ValueError): + np.nditer((mask, arr), flags=itflags, op_flags=[mask_flags, a_flags], + op_axes=op_axes) + + +def test_iter_writemasked_decref(): + # force casting (to make it interesting) by using a structured dtype. + arr = np.arange(10000).astype(">i,O") + original = arr.copy() + mask = np.random.randint(0, 2, size=10000).astype(bool) + + it = np.nditer([arr, mask], ['buffered', "refs_ok"], + [['readwrite', 'writemasked'], + ['readonly', 'arraymask']], + op_dtypes=[" string -> longdouble` for the + # conversion. But Python may refuse `str(int)` for huge ints. + # In that case, RuntimeWarning would be correct, but conversion + # fails earlier (seems to happen on 32bit linux, possibly only debug). + if dtype in "gG": + try: + str(too_big_int) + except ValueError: + pytest.skip("`huge_int -> string -> longdouble` failed") + + # Otherwise, we overflow to infinity: + with pytest.warns(RuntimeWarning): + res = scalar_type(1) + too_big_int + assert res.dtype == dtype + assert res == np.inf + + with pytest.warns(RuntimeWarning): + # We force the dtype here, since windows may otherwise pick the + # double instead of the longdouble loop. That leads to slightly + # different results (conversion of the int fails as above). + res = np.add(np.array(1, dtype=dtype), too_big_int, dtype=dtype) + assert res.dtype == dtype + assert res == np.inf + + +@pytest.mark.parametrize("op", [operator.add, operator.pow]) +def test_weak_promotion_scalar_path(op): + # Some additional paths exercising the weak scalars. + np._set_promotion_state("weak") + + # Integer path: + res = op(np.uint8(3), 5) + assert res == op(3, 5) + assert res.dtype == np.uint8 or res.dtype == bool + + with pytest.raises(OverflowError): + op(np.uint8(3), 1000) + + # Float path: + res = op(np.float32(3), 5.) + assert res == op(3., 5.) + assert res.dtype == np.float32 or res.dtype == bool + + +def test_nep50_complex_promotion(): + np._set_promotion_state("weak") + + with pytest.warns(RuntimeWarning, match=".*overflow"): + res = np.complex64(3) + complex(2**300) + + assert type(res) == np.complex64 + + +def test_nep50_integer_conversion_errors(): + # Do not worry about warnings here (auto-fixture will reset). + np._set_promotion_state("weak") + # Implementation for error paths is mostly missing (as of writing) + with pytest.raises(OverflowError, match=".*uint8"): + np.array([1], np.uint8) + 300 + + with pytest.raises(OverflowError, match=".*uint8"): + np.uint8(1) + 300 + + # Error message depends on platform (maybe unsigned int or unsigned long) + with pytest.raises(OverflowError, + match="Python integer -1 out of bounds for uint8"): + np.uint8(1) + -1 + + +def test_nep50_integer_regression(): + # Test the old integer promotion rules. When the integer is too large, + # we need to keep using the old-style promotion. + np._set_promotion_state("legacy") + arr = np.array(1) + assert (arr + 2**63).dtype == np.float64 + assert (arr[()] + 2**63).dtype == np.float64 + + +def test_nep50_with_axisconcatenator(): + # I promised that this will be an error in the future in the 1.25 + # release notes; test this (NEP 50 opt-in makes the deprecation an error). + np._set_promotion_state("weak") + + with pytest.raises(OverflowError): + np.r_[np.arange(5, dtype=np.int8), 255] + + +@pytest.mark.parametrize("ufunc", [np.add, np.power]) +@pytest.mark.parametrize("state", ["weak", "weak_and_warn"]) +def test_nep50_huge_integers(ufunc, state): + # Very large integers are complicated, because they go to uint64 or + # object dtype. This tests covers a few possible paths (some of which + # cannot give the NEP 50 warnings). + np._set_promotion_state(state) + + with pytest.raises(OverflowError): + ufunc(np.int64(0), 2**63) # 2**63 too large for int64 + + if state == "weak_and_warn": + with pytest.warns(UserWarning, + match="result dtype changed.*float64.*uint64"): + with pytest.raises(OverflowError): + ufunc(np.uint64(0), 2**64) + else: + with pytest.raises(OverflowError): + ufunc(np.uint64(0), 2**64) # 2**64 cannot be represented by uint64 + + # However, 2**63 can be represented by the uint64 (and that is used): + if state == "weak_and_warn": + with pytest.warns(UserWarning, + match="result dtype changed.*float64.*uint64"): + res = ufunc(np.uint64(1), 2**63) + else: + res = ufunc(np.uint64(1), 2**63) + + assert res.dtype == np.uint64 + assert res == ufunc(1, 2**63, dtype=object) + + # The following paths fail to warn correctly about the change: + with pytest.raises(OverflowError): + ufunc(np.int64(1), 2**63) # np.array(2**63) would go to uint + + with pytest.raises(OverflowError): + ufunc(np.int64(1), 2**100) # np.array(2**100) would go to object + + # This would go to object and thus a Python float, not a NumPy one: + res = ufunc(1.0, 2**100) + assert isinstance(res, np.float64) + + +def test_nep50_in_concat_and_choose(): + np._set_promotion_state("weak_and_warn") + + with pytest.warns(UserWarning, match="result dtype changed"): + res = np.concatenate([np.float32(1), 1.], axis=None) + assert res.dtype == "float32" + + with pytest.warns(UserWarning, match="result dtype changed"): + res = np.choose(1, [np.float32(1), 1.]) + assert res.dtype == "float32" + + +@pytest.mark.parametrize("expected,dtypes,optional_dtypes", [ + (np.float32, [np.float32], + [np.float16, 0.0, np.uint16, np.int16, np.int8, 0]), + (np.complex64, [np.float32, 0j], + [np.float16, 0.0, np.uint16, np.int16, np.int8, 0]), + (np.float32, [np.int16, np.uint16, np.float16], + [np.int8, np.uint8, np.float32, 0., 0]), + (np.int32, [np.int16, np.uint16], + [np.int8, np.uint8, 0, np.bool]), + ]) +@hypothesis.given(data=strategies.data()) +def test_expected_promotion(expected, dtypes, optional_dtypes, data): + np._set_promotion_state("weak") + + # Sample randomly while ensuring "dtypes" is always present: + optional = data.draw(strategies.lists( + strategies.sampled_from(dtypes + optional_dtypes))) + all_dtypes = dtypes + optional + dtypes_sample = data.draw(strategies.permutations(all_dtypes)) + + res = np.result_type(*dtypes_sample) + assert res == expected + + +@pytest.mark.parametrize("sctype", + [np.int8, np.int16, np.int32, np.int64, + np.uint8, np.uint16, np.uint32, np.uint64]) +@pytest.mark.parametrize("other_val", + [-2*100, -1, 0, 9, 10, 11, 2**63, 2*100]) +@pytest.mark.parametrize("comp", + [operator.eq, operator.ne, operator.le, operator.lt, + operator.ge, operator.gt]) +def test_integer_comparison(sctype, other_val, comp): + np._set_promotion_state("weak") + + # Test that comparisons with integers (especially out-of-bound) ones + # works correctly. + val_obj = 10 + val = sctype(val_obj) + # Check that the scalar behaves the same as the python int: + assert comp(10, other_val) == comp(val, other_val) + assert comp(val, other_val) == comp(10, other_val) + # Except for the result type: + assert type(comp(val, other_val)) is np.bool + + # Check that the integer array and object array behave the same: + val_obj = np.array([10, 10], dtype=object) + val = val_obj.astype(sctype) + assert_array_equal(comp(val_obj, other_val), comp(val, other_val)) + assert_array_equal(comp(other_val, val_obj), comp(other_val, val)) + + +@pytest.mark.parametrize("comp", + [np.equal, np.not_equal, np.less_equal, np.less, + np.greater_equal, np.greater]) +def test_integer_integer_comparison(comp): + np._set_promotion_state("weak") + + # Test that the NumPy comparison ufuncs work with large Python integers + assert comp(2**200, -2**200) == comp(2**200, -2**200, dtype=object) + + +def create_with_scalar(sctype, value): + return sctype(value) + + +def create_with_array(sctype, value): + return np.array([value], dtype=sctype) + + +@pytest.mark.parametrize("sctype", + [np.int8, np.int16, np.int32, np.int64, + np.uint8, np.uint16, np.uint32, np.uint64]) +@pytest.mark.parametrize("create", [create_with_scalar, create_with_array]) +def test_oob_creation(sctype, create): + iinfo = np.iinfo(sctype) + + with pytest.raises(OverflowError): + create(sctype, iinfo.min - 1) + + with pytest.raises(OverflowError): + create(sctype, iinfo.max + 1) + + with pytest.raises(OverflowError): + create(sctype, str(iinfo.min - 1)) + + with pytest.raises(OverflowError): + create(sctype, str(iinfo.max + 1)) + + assert create(sctype, iinfo.min) == iinfo.min + assert create(sctype, iinfo.max) == iinfo.max + + +@pytest.mark.skipif(IS_WASM, reason="wasm doesn't have support for threads") +def test_thread_local_promotion_state(): + b = threading.Barrier(2) + + def legacy_no_warn(): + np._set_promotion_state("legacy") + b.wait() + assert np._get_promotion_state() == "legacy" + + def weak_warn(): + np._set_promotion_state("weak") + b.wait() + assert np._get_promotion_state() == "weak" + + task1 = threading.Thread(target=legacy_no_warn) + task2 = threading.Thread(target=weak_warn) + + task1.start() + task2.start() + task1.join() + task2.join() diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/test_numeric.py b/venv/lib/python3.12/site-packages/numpy/_core/tests/test_numeric.py new file mode 100644 index 00000000..ae80aadd --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/tests/test_numeric.py @@ -0,0 +1,4191 @@ +import sys +import warnings +import itertools +import platform +import pytest +import math +from decimal import Decimal + +import numpy as np +from numpy._core import umath, sctypes +from numpy._core.numerictypes import obj2sctype +from numpy.exceptions import AxisError +from numpy.random import rand, randint, randn +from numpy.testing import ( + assert_, assert_equal, assert_raises, assert_raises_regex, + assert_array_equal, assert_almost_equal, assert_array_almost_equal, + assert_warns, assert_array_max_ulp, HAS_REFCOUNT, IS_WASM + ) +from numpy._core._rational_tests import rational +from numpy import ma + +from hypothesis import given, strategies as st +from hypothesis.extra import numpy as hynp + + +class TestResize: + def test_copies(self): + A = np.array([[1, 2], [3, 4]]) + Ar1 = np.array([[1, 2, 3, 4], [1, 2, 3, 4]]) + assert_equal(np.resize(A, (2, 4)), Ar1) + + Ar2 = np.array([[1, 2], [3, 4], [1, 2], [3, 4]]) + assert_equal(np.resize(A, (4, 2)), Ar2) + + Ar3 = np.array([[1, 2, 3], [4, 1, 2], [3, 4, 1], [2, 3, 4]]) + assert_equal(np.resize(A, (4, 3)), Ar3) + + def test_repeats(self): + A = np.array([1, 2, 3]) + Ar1 = np.array([[1, 2, 3, 1], [2, 3, 1, 2]]) + assert_equal(np.resize(A, (2, 4)), Ar1) + + Ar2 = np.array([[1, 2], [3, 1], [2, 3], [1, 2]]) + assert_equal(np.resize(A, (4, 2)), Ar2) + + Ar3 = np.array([[1, 2, 3], [1, 2, 3], [1, 2, 3], [1, 2, 3]]) + assert_equal(np.resize(A, (4, 3)), Ar3) + + def test_zeroresize(self): + A = np.array([[1, 2], [3, 4]]) + Ar = np.resize(A, (0,)) + assert_array_equal(Ar, np.array([])) + assert_equal(A.dtype, Ar.dtype) + + Ar = np.resize(A, (0, 2)) + assert_equal(Ar.shape, (0, 2)) + + Ar = np.resize(A, (2, 0)) + assert_equal(Ar.shape, (2, 0)) + + def test_reshape_from_zero(self): + # See also gh-6740 + A = np.zeros(0, dtype=[('a', np.float32)]) + Ar = np.resize(A, (2, 1)) + assert_array_equal(Ar, np.zeros((2, 1), Ar.dtype)) + assert_equal(A.dtype, Ar.dtype) + + def test_negative_resize(self): + A = np.arange(0, 10, dtype=np.float32) + new_shape = (-10, -1) + with pytest.raises(ValueError, match=r"negative"): + np.resize(A, new_shape=new_shape) + + def test_subclass(self): + class MyArray(np.ndarray): + __array_priority__ = 1. + + my_arr = np.array([1]).view(MyArray) + assert type(np.resize(my_arr, 5)) is MyArray + assert type(np.resize(my_arr, 0)) is MyArray + + my_arr = np.array([]).view(MyArray) + assert type(np.resize(my_arr, 5)) is MyArray + + +class TestNonarrayArgs: + # check that non-array arguments to functions wrap them in arrays + def test_choose(self): + choices = [[0, 1, 2], + [3, 4, 5], + [5, 6, 7]] + tgt = [5, 1, 5] + a = [2, 0, 1] + + out = np.choose(a, choices) + assert_equal(out, tgt) + + def test_clip(self): + arr = [-1, 5, 2, 3, 10, -4, -9] + out = np.clip(arr, 2, 7) + tgt = [2, 5, 2, 3, 7, 2, 2] + assert_equal(out, tgt) + + def test_compress(self): + arr = [[0, 1, 2, 3, 4], + [5, 6, 7, 8, 9]] + tgt = [[5, 6, 7, 8, 9]] + out = np.compress([0, 1], arr, axis=0) + assert_equal(out, tgt) + + def test_count_nonzero(self): + arr = [[0, 1, 7, 0, 0], + [3, 0, 0, 2, 19]] + tgt = np.array([2, 3]) + out = np.count_nonzero(arr, axis=1) + assert_equal(out, tgt) + + def test_diagonal(self): + a = [[0, 1, 2, 3], + [4, 5, 6, 7], + [8, 9, 10, 11]] + out = np.diagonal(a) + tgt = [0, 5, 10] + + assert_equal(out, tgt) + + def test_mean(self): + A = [[1, 2, 3], [4, 5, 6]] + assert_(np.mean(A) == 3.5) + assert_(np.all(np.mean(A, 0) == np.array([2.5, 3.5, 4.5]))) + assert_(np.all(np.mean(A, 1) == np.array([2., 5.]))) + + with warnings.catch_warnings(record=True) as w: + warnings.filterwarnings('always', '', RuntimeWarning) + assert_(np.isnan(np.mean([]))) + assert_(w[0].category is RuntimeWarning) + + def test_ptp(self): + a = [3, 4, 5, 10, -3, -5, 6.0] + assert_equal(np.ptp(a, axis=0), 15.0) + + def test_prod(self): + arr = [[1, 2, 3, 4], + [5, 6, 7, 9], + [10, 3, 4, 5]] + tgt = [24, 1890, 600] + + assert_equal(np.prod(arr, axis=-1), tgt) + + def test_ravel(self): + a = [[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]] + tgt = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12] + assert_equal(np.ravel(a), tgt) + + def test_repeat(self): + a = [1, 2, 3] + tgt = [1, 1, 2, 2, 3, 3] + + out = np.repeat(a, 2) + assert_equal(out, tgt) + + def test_reshape(self): + arr = [[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]] + tgt = [[1, 2, 3, 4, 5, 6], [7, 8, 9, 10, 11, 12]] + assert_equal(np.reshape(arr, (2, 6)), tgt) + + def test_reshape_shape_arg(self): + arr = np.arange(12) + shape = (3, 4) + expected = arr.reshape(shape) + + with pytest.raises( + TypeError, + match="You cannot specify 'newshape' and 'shape' " + "arguments at the same time." + ): + np.reshape(arr, shape=shape, newshape=shape) + with pytest.raises( + TypeError, + match=r"reshape\(\) missing 1 required positional " + "argument: 'shape'" + ): + np.reshape(arr) + + assert_equal(np.reshape(arr, shape), expected) + assert_equal(np.reshape(arr, shape, order="C"), expected) + assert_equal(np.reshape(arr, shape, "C"), expected) + assert_equal(np.reshape(arr, shape=shape), expected) + assert_equal(np.reshape(arr, shape=shape, order="C"), expected) + with pytest.warns(DeprecationWarning): + actual = np.reshape(arr, newshape=shape) + assert_equal(actual, expected) + + def test_reshape_copy_arg(self): + arr = np.arange(24).reshape(2, 3, 4) + arr_f_ord = np.array(arr, order="F") + shape = (12, 2) + + assert np.shares_memory(np.reshape(arr, shape), arr) + assert np.shares_memory(np.reshape(arr, shape, order="C"), arr) + assert np.shares_memory( + np.reshape(arr_f_ord, shape, order="F"), arr_f_ord) + assert np.shares_memory(np.reshape(arr, shape, copy=None), arr) + assert np.shares_memory(np.reshape(arr, shape, copy=False), arr) + assert np.shares_memory(arr.reshape(shape, copy=False), arr) + assert not np.shares_memory(np.reshape(arr, shape, copy=True), arr) + assert not np.shares_memory( + np.reshape(arr, shape, order="C", copy=True), arr) + assert not np.shares_memory( + np.reshape(arr, shape, order="F", copy=True), arr) + assert not np.shares_memory( + np.reshape(arr, shape, order="F", copy=None), arr) + + err_msg = "Unable to avoid creating a copy while reshaping." + with pytest.raises(ValueError, match=err_msg): + np.reshape(arr, shape, order="F", copy=False) + with pytest.raises(ValueError, match=err_msg): + np.reshape(arr_f_ord, shape, order="C", copy=False) + + def test_round(self): + arr = [1.56, 72.54, 6.35, 3.25] + tgt = [1.6, 72.5, 6.4, 3.2] + assert_equal(np.around(arr, decimals=1), tgt) + s = np.float64(1.) + assert_(isinstance(s.round(), np.float64)) + assert_equal(s.round(), 1.) + + @pytest.mark.parametrize('dtype', [ + np.int8, np.int16, np.int32, np.int64, + np.uint8, np.uint16, np.uint32, np.uint64, + np.float16, np.float32, np.float64, + ]) + def test_dunder_round(self, dtype): + s = dtype(1) + assert_(isinstance(round(s), int)) + assert_(isinstance(round(s, None), int)) + assert_(isinstance(round(s, ndigits=None), int)) + assert_equal(round(s), 1) + assert_equal(round(s, None), 1) + assert_equal(round(s, ndigits=None), 1) + + @pytest.mark.parametrize('val, ndigits', [ + pytest.param(2**31 - 1, -1, + marks=pytest.mark.skip(reason="Out of range of int32") + ), + (2**31 - 1, 1-math.ceil(math.log10(2**31 - 1))), + (2**31 - 1, -math.ceil(math.log10(2**31 - 1))) + ]) + def test_dunder_round_edgecases(self, val, ndigits): + assert_equal(round(val, ndigits), round(np.int32(val), ndigits)) + + def test_dunder_round_accuracy(self): + f = np.float64(5.1 * 10**73) + assert_(isinstance(round(f, -73), np.float64)) + assert_array_max_ulp(round(f, -73), 5.0 * 10**73) + assert_(isinstance(round(f, ndigits=-73), np.float64)) + assert_array_max_ulp(round(f, ndigits=-73), 5.0 * 10**73) + + i = np.int64(501) + assert_(isinstance(round(i, -2), np.int64)) + assert_array_max_ulp(round(i, -2), 500) + assert_(isinstance(round(i, ndigits=-2), np.int64)) + assert_array_max_ulp(round(i, ndigits=-2), 500) + + @pytest.mark.xfail(raises=AssertionError, reason="gh-15896") + def test_round_py_consistency(self): + f = 5.1 * 10**73 + assert_equal(round(np.float64(f), -73), round(f, -73)) + + def test_searchsorted(self): + arr = [-8, -5, -1, 3, 6, 10] + out = np.searchsorted(arr, 0) + assert_equal(out, 3) + + def test_size(self): + A = [[1, 2, 3], [4, 5, 6]] + assert_(np.size(A) == 6) + assert_(np.size(A, 0) == 2) + assert_(np.size(A, 1) == 3) + + def test_squeeze(self): + A = [[[1, 1, 1], [2, 2, 2], [3, 3, 3]]] + assert_equal(np.squeeze(A).shape, (3, 3)) + assert_equal(np.squeeze(np.zeros((1, 3, 1))).shape, (3,)) + assert_equal(np.squeeze(np.zeros((1, 3, 1)), axis=0).shape, (3, 1)) + assert_equal(np.squeeze(np.zeros((1, 3, 1)), axis=-1).shape, (1, 3)) + assert_equal(np.squeeze(np.zeros((1, 3, 1)), axis=2).shape, (1, 3)) + assert_equal(np.squeeze([np.zeros((3, 1))]).shape, (3,)) + assert_equal(np.squeeze([np.zeros((3, 1))], axis=0).shape, (3, 1)) + assert_equal(np.squeeze([np.zeros((3, 1))], axis=2).shape, (1, 3)) + assert_equal(np.squeeze([np.zeros((3, 1))], axis=-1).shape, (1, 3)) + + def test_std(self): + A = [[1, 2, 3], [4, 5, 6]] + assert_almost_equal(np.std(A), 1.707825127659933) + assert_almost_equal(np.std(A, 0), np.array([1.5, 1.5, 1.5])) + assert_almost_equal(np.std(A, 1), np.array([0.81649658, 0.81649658])) + + with warnings.catch_warnings(record=True) as w: + warnings.filterwarnings('always', '', RuntimeWarning) + assert_(np.isnan(np.std([]))) + assert_(w[0].category is RuntimeWarning) + + def test_swapaxes(self): + tgt = [[[0, 4], [2, 6]], [[1, 5], [3, 7]]] + a = [[[0, 1], [2, 3]], [[4, 5], [6, 7]]] + out = np.swapaxes(a, 0, 2) + assert_equal(out, tgt) + + def test_sum(self): + m = [[1, 2, 3], + [4, 5, 6], + [7, 8, 9]] + tgt = [[6], [15], [24]] + out = np.sum(m, axis=1, keepdims=True) + + assert_equal(tgt, out) + + def test_take(self): + tgt = [2, 3, 5] + indices = [1, 2, 4] + a = [1, 2, 3, 4, 5] + + out = np.take(a, indices) + assert_equal(out, tgt) + + pairs = [ + (np.int32, np.int32), (np.int32, np.int64), + (np.int64, np.int32), (np.int64, np.int64) + ] + for array_type, indices_type in pairs: + x = np.array([1, 2, 3, 4, 5], dtype=array_type) + ind = np.array([0, 2, 2, 3], dtype=indices_type) + tgt = np.array([1, 3, 3, 4], dtype=array_type) + out = np.take(x, ind) + assert_equal(out, tgt) + assert_equal(out.dtype, tgt.dtype) + + def test_trace(self): + c = [[1, 2], [3, 4], [5, 6]] + assert_equal(np.trace(c), 5) + + def test_transpose(self): + arr = [[1, 2], [3, 4], [5, 6]] + tgt = [[1, 3, 5], [2, 4, 6]] + assert_equal(np.transpose(arr, (1, 0)), tgt) + assert_equal(np.matrix_transpose(arr), tgt) + + def test_var(self): + A = [[1, 2, 3], [4, 5, 6]] + assert_almost_equal(np.var(A), 2.9166666666666665) + assert_almost_equal(np.var(A, 0), np.array([2.25, 2.25, 2.25])) + assert_almost_equal(np.var(A, 1), np.array([0.66666667, 0.66666667])) + + with warnings.catch_warnings(record=True) as w: + warnings.filterwarnings('always', '', RuntimeWarning) + assert_(np.isnan(np.var([]))) + assert_(w[0].category is RuntimeWarning) + + B = np.array([None, 0]) + B[0] = 1j + assert_almost_equal(np.var(B), 0.25) + + def test_std_with_mean_keyword(self): + # Setting the seed to make the test reproducible + rng = np.random.RandomState(1234) + A = rng.randn(10, 20, 5) + 0.5 + + mean_out = np.zeros((10, 1, 5)) + std_out = np.zeros((10, 1, 5)) + + mean = np.mean(A, + out=mean_out, + axis=1, + keepdims=True) + + # The returned object should be the object specified during calling + assert mean_out is mean + + std = np.std(A, + out=std_out, + axis=1, + keepdims=True, + mean=mean) + + # The returned object should be the object specified during calling + assert std_out is std + + # Shape of returned mean and std should be same + assert std.shape == mean.shape + assert std.shape == (10, 1, 5) + + # Output should be the same as from the individual algorithms + std_old = np.std(A, axis=1, keepdims=True) + + assert std_old.shape == mean.shape + assert_almost_equal(std, std_old) + + def test_var_with_mean_keyword(self): + # Setting the seed to make the test reproducible + rng = np.random.RandomState(1234) + A = rng.randn(10, 20, 5) + 0.5 + + mean_out = np.zeros((10, 1, 5)) + var_out = np.zeros((10, 1, 5)) + + mean = np.mean(A, + out=mean_out, + axis=1, + keepdims=True) + + # The returned object should be the object specified during calling + assert mean_out is mean + + var = np.var(A, + out=var_out, + axis=1, + keepdims=True, + mean=mean) + + # The returned object should be the object specified during calling + assert var_out is var + + # Shape of returned mean and var should be same + assert var.shape == mean.shape + assert var.shape == (10, 1, 5) + + # Output should be the same as from the individual algorithms + var_old = np.var(A, axis=1, keepdims=True) + + assert var_old.shape == mean.shape + assert_almost_equal(var, var_old) + + def test_std_with_mean_keyword_keepdims_false(self): + rng = np.random.RandomState(1234) + A = rng.randn(10, 20, 5) + 0.5 + + mean = np.mean(A, + axis=1, + keepdims=True) + + std = np.std(A, + axis=1, + keepdims=False, + mean=mean) + + # Shape of returned mean and std should be same + assert std.shape == (10, 5) + + # Output should be the same as from the individual algorithms + std_old = np.std(A, axis=1, keepdims=False) + mean_old = np.mean(A, axis=1, keepdims=False) + + assert std_old.shape == mean_old.shape + assert_equal(std, std_old) + + def test_var_with_mean_keyword_keepdims_false(self): + rng = np.random.RandomState(1234) + A = rng.randn(10, 20, 5) + 0.5 + + mean = np.mean(A, + axis=1, + keepdims=True) + + var = np.var(A, + axis=1, + keepdims=False, + mean=mean) + + # Shape of returned mean and var should be same + assert var.shape == (10, 5) + + # Output should be the same as from the individual algorithms + var_old = np.var(A, axis=1, keepdims=False) + mean_old = np.mean(A, axis=1, keepdims=False) + + assert var_old.shape == mean_old.shape + assert_equal(var, var_old) + + def test_std_with_mean_keyword_where_nontrivial(self): + rng = np.random.RandomState(1234) + A = rng.randn(10, 20, 5) + 0.5 + + where = A > 0.5 + + mean = np.mean(A, + axis=1, + keepdims=True, + where=where) + + std = np.std(A, + axis=1, + keepdims=False, + mean=mean, + where=where) + + # Shape of returned mean and std should be same + assert std.shape == (10, 5) + + # Output should be the same as from the individual algorithms + std_old = np.std(A, axis=1, where=where) + mean_old = np.mean(A, axis=1, where=where) + + assert std_old.shape == mean_old.shape + assert_equal(std, std_old) + + def test_var_with_mean_keyword_where_nontrivial(self): + rng = np.random.RandomState(1234) + A = rng.randn(10, 20, 5) + 0.5 + + where = A > 0.5 + + mean = np.mean(A, + axis=1, + keepdims=True, + where=where) + + var = np.var(A, + axis=1, + keepdims=False, + mean=mean, + where=where) + + # Shape of returned mean and var should be same + assert var.shape == (10, 5) + + # Output should be the same as from the individual algorithms + var_old = np.var(A, axis=1, where=where) + mean_old = np.mean(A, axis=1, where=where) + + assert var_old.shape == mean_old.shape + assert_equal(var, var_old) + + def test_std_with_mean_keyword_multiple_axis(self): + # Setting the seed to make the test reproducible + rng = np.random.RandomState(1234) + A = rng.randn(10, 20, 5) + 0.5 + + axis = (0, 2) + + mean = np.mean(A, + out=None, + axis=axis, + keepdims=True) + + std = np.std(A, + out=None, + axis=axis, + keepdims=False, + mean=mean) + + # Shape of returned mean and std should be same + assert std.shape == (20,) + + # Output should be the same as from the individual algorithms + std_old = np.std(A, axis=axis, keepdims=False) + + assert_almost_equal(std, std_old) + + def test_std_with_mean_keyword_axis_None(self): + # Setting the seed to make the test reproducible + rng = np.random.RandomState(1234) + A = rng.randn(10, 20, 5) + 0.5 + + axis = None + + mean = np.mean(A, + out=None, + axis=axis, + keepdims=True) + + std = np.std(A, + out=None, + axis=axis, + keepdims=False, + mean=mean) + + # Shape of returned mean and std should be same + assert std.shape == () + + # Output should be the same as from the individual algorithms + std_old = np.std(A, axis=axis, keepdims=False) + + assert_almost_equal(std, std_old) + + def test_std_with_mean_keyword_keepdims_true_masked(self): + + A = ma.array([[2., 3., 4., 5.], + [1., 2., 3., 4.]], + mask=[[True, False, True, False], + [True, False, True, False]]) + + B = ma.array([[100., 3., 104., 5.], + [101., 2., 103., 4.]], + mask=[[True, False, True, False], + [True, False, True, False]]) + + mean_out = ma.array([[0., 0., 0., 0.]], + mask=[[False, False, False, False]]) + std_out = ma.array([[0., 0., 0., 0.]], + mask=[[False, False, False, False]]) + + axis = 0 + + mean = np.mean(A, out=mean_out, + axis=axis, keepdims=True) + + std = np.std(A, out=std_out, + axis=axis, keepdims=True, + mean=mean) + + # Shape of returned mean and std should be same + assert std.shape == mean.shape + assert std.shape == (1, 4) + + # Output should be the same as from the individual algorithms + std_old = np.std(A, axis=axis, keepdims=True) + mean_old = np.mean(A, axis=axis, keepdims=True) + + assert std_old.shape == mean_old.shape + assert_almost_equal(std, std_old) + assert_almost_equal(mean, mean_old) + + assert mean_out is mean + assert std_out is std + + # masked elements should be ignored + mean_b = np.mean(B, axis=axis, keepdims=True) + std_b = np.std(B, axis=axis, keepdims=True, mean=mean_b) + assert_almost_equal(std, std_b) + assert_almost_equal(mean, mean_b) + + def test_var_with_mean_keyword_keepdims_true_masked(self): + + A = ma.array([[2., 3., 4., 5.], + [1., 2., 3., 4.]], + mask=[[True, False, True, False], + [True, False, True, False]]) + + B = ma.array([[100., 3., 104., 5.], + [101., 2., 103., 4.]], + mask=[[True, False, True, False], + [True, False, True, False]]) + + mean_out = ma.array([[0., 0., 0., 0.]], + mask=[[False, False, False, False]]) + var_out = ma.array([[0., 0., 0., 0.]], + mask=[[False, False, False, False]]) + + axis = 0 + + mean = np.mean(A, out=mean_out, + axis=axis, keepdims=True) + + var = np.var(A, out=var_out, + axis=axis, keepdims=True, + mean=mean) + + # Shape of returned mean and var should be same + assert var.shape == mean.shape + assert var.shape == (1, 4) + + # Output should be the same as from the individual algorithms + var_old = np.var(A, axis=axis, keepdims=True) + mean_old = np.mean(A, axis=axis, keepdims=True) + + assert var_old.shape == mean_old.shape + assert_almost_equal(var, var_old) + assert_almost_equal(mean, mean_old) + + assert mean_out is mean + assert var_out is var + + # masked elements should be ignored + mean_b = np.mean(B, axis=axis, keepdims=True) + var_b = np.var(B, axis=axis, keepdims=True, mean=mean_b) + assert_almost_equal(var, var_b) + assert_almost_equal(mean, mean_b) + + +class TestIsscalar: + def test_isscalar(self): + assert_(np.isscalar(3.1)) + assert_(np.isscalar(np.int16(12345))) + assert_(np.isscalar(False)) + assert_(np.isscalar('numpy')) + assert_(not np.isscalar([3.1])) + assert_(not np.isscalar(None)) + + # PEP 3141 + from fractions import Fraction + assert_(np.isscalar(Fraction(5, 17))) + from numbers import Number + assert_(np.isscalar(Number())) + + +class TestBoolScalar: + def test_logical(self): + f = np.False_ + t = np.True_ + s = "xyz" + assert_((t and s) is s) + assert_((f and s) is f) + + def test_bitwise_or(self): + f = np.False_ + t = np.True_ + assert_((t | t) is t) + assert_((f | t) is t) + assert_((t | f) is t) + assert_((f | f) is f) + + def test_bitwise_and(self): + f = np.False_ + t = np.True_ + assert_((t & t) is t) + assert_((f & t) is f) + assert_((t & f) is f) + assert_((f & f) is f) + + def test_bitwise_xor(self): + f = np.False_ + t = np.True_ + assert_((t ^ t) is f) + assert_((f ^ t) is t) + assert_((t ^ f) is t) + assert_((f ^ f) is f) + + +class TestBoolArray: + def setup_method(self): + # offset for simd tests + self.t = np.array([True] * 41, dtype=bool)[1::] + self.f = np.array([False] * 41, dtype=bool)[1::] + self.o = np.array([False] * 42, dtype=bool)[2::] + self.nm = self.f.copy() + self.im = self.t.copy() + self.nm[3] = True + self.nm[-2] = True + self.im[3] = False + self.im[-2] = False + + def test_all_any(self): + assert_(self.t.all()) + assert_(self.t.any()) + assert_(not self.f.all()) + assert_(not self.f.any()) + assert_(self.nm.any()) + assert_(self.im.any()) + assert_(not self.nm.all()) + assert_(not self.im.all()) + # check bad element in all positions + for i in range(256 - 7): + d = np.array([False] * 256, dtype=bool)[7::] + d[i] = True + assert_(np.any(d)) + e = np.array([True] * 256, dtype=bool)[7::] + e[i] = False + assert_(not np.all(e)) + assert_array_equal(e, ~d) + # big array test for blocked libc loops + for i in list(range(9, 6000, 507)) + [7764, 90021, -10]: + d = np.array([False] * 100043, dtype=bool) + d[i] = True + assert_(np.any(d), msg="%r" % i) + e = np.array([True] * 100043, dtype=bool) + e[i] = False + assert_(not np.all(e), msg="%r" % i) + + def test_logical_not_abs(self): + assert_array_equal(~self.t, self.f) + assert_array_equal(np.abs(~self.t), self.f) + assert_array_equal(np.abs(~self.f), self.t) + assert_array_equal(np.abs(self.f), self.f) + assert_array_equal(~np.abs(self.f), self.t) + assert_array_equal(~np.abs(self.t), self.f) + assert_array_equal(np.abs(~self.nm), self.im) + np.logical_not(self.t, out=self.o) + assert_array_equal(self.o, self.f) + np.abs(self.t, out=self.o) + assert_array_equal(self.o, self.t) + + def test_logical_and_or_xor(self): + assert_array_equal(self.t | self.t, self.t) + assert_array_equal(self.f | self.f, self.f) + assert_array_equal(self.t | self.f, self.t) + assert_array_equal(self.f | self.t, self.t) + np.logical_or(self.t, self.t, out=self.o) + assert_array_equal(self.o, self.t) + assert_array_equal(self.t & self.t, self.t) + assert_array_equal(self.f & self.f, self.f) + assert_array_equal(self.t & self.f, self.f) + assert_array_equal(self.f & self.t, self.f) + np.logical_and(self.t, self.t, out=self.o) + assert_array_equal(self.o, self.t) + assert_array_equal(self.t ^ self.t, self.f) + assert_array_equal(self.f ^ self.f, self.f) + assert_array_equal(self.t ^ self.f, self.t) + assert_array_equal(self.f ^ self.t, self.t) + np.logical_xor(self.t, self.t, out=self.o) + assert_array_equal(self.o, self.f) + + assert_array_equal(self.nm & self.t, self.nm) + assert_array_equal(self.im & self.f, False) + assert_array_equal(self.nm & True, self.nm) + assert_array_equal(self.im & False, self.f) + assert_array_equal(self.nm | self.t, self.t) + assert_array_equal(self.im | self.f, self.im) + assert_array_equal(self.nm | True, self.t) + assert_array_equal(self.im | False, self.im) + assert_array_equal(self.nm ^ self.t, self.im) + assert_array_equal(self.im ^ self.f, self.im) + assert_array_equal(self.nm ^ True, self.im) + assert_array_equal(self.im ^ False, self.im) + + +class TestBoolCmp: + def setup_method(self): + self.f = np.ones(256, dtype=np.float32) + self.ef = np.ones(self.f.size, dtype=bool) + self.d = np.ones(128, dtype=np.float64) + self.ed = np.ones(self.d.size, dtype=bool) + # generate values for all permutation of 256bit simd vectors + s = 0 + for i in range(32): + self.f[s:s+8] = [i & 2**x for x in range(8)] + self.ef[s:s+8] = [(i & 2**x) != 0 for x in range(8)] + s += 8 + s = 0 + for i in range(16): + self.d[s:s+4] = [i & 2**x for x in range(4)] + self.ed[s:s+4] = [(i & 2**x) != 0 for x in range(4)] + s += 4 + + self.nf = self.f.copy() + self.nd = self.d.copy() + self.nf[self.ef] = np.nan + self.nd[self.ed] = np.nan + + self.inff = self.f.copy() + self.infd = self.d.copy() + self.inff[::3][self.ef[::3]] = np.inf + self.infd[::3][self.ed[::3]] = np.inf + self.inff[1::3][self.ef[1::3]] = -np.inf + self.infd[1::3][self.ed[1::3]] = -np.inf + self.inff[2::3][self.ef[2::3]] = np.nan + self.infd[2::3][self.ed[2::3]] = np.nan + self.efnonan = self.ef.copy() + self.efnonan[2::3] = False + self.ednonan = self.ed.copy() + self.ednonan[2::3] = False + + self.signf = self.f.copy() + self.signd = self.d.copy() + self.signf[self.ef] *= -1. + self.signd[self.ed] *= -1. + self.signf[1::6][self.ef[1::6]] = -np.inf + self.signd[1::6][self.ed[1::6]] = -np.inf + # On RISC-V, many operations that produce NaNs, such as converting + # a -NaN from f64 to f32, return a canonical NaN. The canonical + # NaNs are always positive. See section 11.3 NaN Generation and + # Propagation of the RISC-V Unprivileged ISA for more details. + # We disable the float32 sign test on riscv64 for -np.nan as the sign + # of the NaN will be lost when it's converted to a float32. + if platform.machine() != 'riscv64': + self.signf[3::6][self.ef[3::6]] = -np.nan + self.signd[3::6][self.ed[3::6]] = -np.nan + self.signf[4::6][self.ef[4::6]] = -0. + self.signd[4::6][self.ed[4::6]] = -0. + + def test_float(self): + # offset for alignment test + for i in range(4): + assert_array_equal(self.f[i:] > 0, self.ef[i:]) + assert_array_equal(self.f[i:] - 1 >= 0, self.ef[i:]) + assert_array_equal(self.f[i:] == 0, ~self.ef[i:]) + assert_array_equal(-self.f[i:] < 0, self.ef[i:]) + assert_array_equal(-self.f[i:] + 1 <= 0, self.ef[i:]) + r = self.f[i:] != 0 + assert_array_equal(r, self.ef[i:]) + r2 = self.f[i:] != np.zeros_like(self.f[i:]) + r3 = 0 != self.f[i:] + assert_array_equal(r, r2) + assert_array_equal(r, r3) + # check bool == 0x1 + assert_array_equal(r.view(np.int8), r.astype(np.int8)) + assert_array_equal(r2.view(np.int8), r2.astype(np.int8)) + assert_array_equal(r3.view(np.int8), r3.astype(np.int8)) + + # isnan on amd64 takes the same code path + assert_array_equal(np.isnan(self.nf[i:]), self.ef[i:]) + assert_array_equal(np.isfinite(self.nf[i:]), ~self.ef[i:]) + assert_array_equal(np.isfinite(self.inff[i:]), ~self.ef[i:]) + assert_array_equal(np.isinf(self.inff[i:]), self.efnonan[i:]) + assert_array_equal(np.signbit(self.signf[i:]), self.ef[i:]) + + def test_double(self): + # offset for alignment test + for i in range(2): + assert_array_equal(self.d[i:] > 0, self.ed[i:]) + assert_array_equal(self.d[i:] - 1 >= 0, self.ed[i:]) + assert_array_equal(self.d[i:] == 0, ~self.ed[i:]) + assert_array_equal(-self.d[i:] < 0, self.ed[i:]) + assert_array_equal(-self.d[i:] + 1 <= 0, self.ed[i:]) + r = self.d[i:] != 0 + assert_array_equal(r, self.ed[i:]) + r2 = self.d[i:] != np.zeros_like(self.d[i:]) + r3 = 0 != self.d[i:] + assert_array_equal(r, r2) + assert_array_equal(r, r3) + # check bool == 0x1 + assert_array_equal(r.view(np.int8), r.astype(np.int8)) + assert_array_equal(r2.view(np.int8), r2.astype(np.int8)) + assert_array_equal(r3.view(np.int8), r3.astype(np.int8)) + + # isnan on amd64 takes the same code path + assert_array_equal(np.isnan(self.nd[i:]), self.ed[i:]) + assert_array_equal(np.isfinite(self.nd[i:]), ~self.ed[i:]) + assert_array_equal(np.isfinite(self.infd[i:]), ~self.ed[i:]) + assert_array_equal(np.isinf(self.infd[i:]), self.ednonan[i:]) + assert_array_equal(np.signbit(self.signd[i:]), self.ed[i:]) + + +class TestSeterr: + def test_default(self): + err = np.geterr() + assert_equal(err, + dict(divide='warn', + invalid='warn', + over='warn', + under='ignore') + ) + + def test_set(self): + with np.errstate(): + err = np.seterr() + old = np.seterr(divide='print') + assert_(err == old) + new = np.seterr() + assert_(new['divide'] == 'print') + np.seterr(over='raise') + assert_(np.geterr()['over'] == 'raise') + assert_(new['divide'] == 'print') + np.seterr(**old) + assert_(np.geterr() == old) + + @pytest.mark.skipif(IS_WASM, reason="no wasm fp exception support") + @pytest.mark.skipif(platform.machine() == "armv5tel", reason="See gh-413.") + def test_divide_err(self): + with np.errstate(divide='raise'): + with assert_raises(FloatingPointError): + np.array([1.]) / np.array([0.]) + + np.seterr(divide='ignore') + np.array([1.]) / np.array([0.]) + + +class TestFloatExceptions: + def assert_raises_fpe(self, fpeerr, flop, x, y): + ftype = type(x) + try: + flop(x, y) + assert_(False, + "Type %s did not raise fpe error '%s'." % (ftype, fpeerr)) + except FloatingPointError as exc: + assert_(str(exc).find(fpeerr) >= 0, + "Type %s raised wrong fpe error '%s'." % (ftype, exc)) + + def assert_op_raises_fpe(self, fpeerr, flop, sc1, sc2): + # Check that fpe exception is raised. + # + # Given a floating operation `flop` and two scalar values, check that + # the operation raises the floating point exception specified by + # `fpeerr`. Tests all variants with 0-d array scalars as well. + + self.assert_raises_fpe(fpeerr, flop, sc1, sc2) + self.assert_raises_fpe(fpeerr, flop, sc1[()], sc2) + self.assert_raises_fpe(fpeerr, flop, sc1, sc2[()]) + self.assert_raises_fpe(fpeerr, flop, sc1[()], sc2[()]) + + # Test for all real and complex float types + @pytest.mark.skipif(IS_WASM, reason="no wasm fp exception support") + @pytest.mark.parametrize("typecode", np.typecodes["AllFloat"]) + def test_floating_exceptions(self, typecode): + if 'bsd' in sys.platform and typecode in 'gG': + pytest.skip(reason="Fallback impl for (c)longdouble may not raise " + "FPE errors as expected on BSD OSes, " + "see gh-24876, gh-23379") + + # Test basic arithmetic function errors + with np.errstate(all='raise'): + ftype = obj2sctype(typecode) + if np.dtype(ftype).kind == 'f': + # Get some extreme values for the type + fi = np.finfo(ftype) + ft_tiny = fi._machar.tiny + ft_max = fi.max + ft_eps = fi.eps + underflow = 'underflow' + divbyzero = 'divide by zero' + else: + # 'c', complex, corresponding real dtype + rtype = type(ftype(0).real) + fi = np.finfo(rtype) + ft_tiny = ftype(fi._machar.tiny) + ft_max = ftype(fi.max) + ft_eps = ftype(fi.eps) + # The complex types raise different exceptions + underflow = '' + divbyzero = '' + overflow = 'overflow' + invalid = 'invalid' + + # The value of tiny for double double is NaN, so we need to + # pass the assert + if not np.isnan(ft_tiny): + self.assert_raises_fpe(underflow, + lambda a, b: a/b, ft_tiny, ft_max) + self.assert_raises_fpe(underflow, + lambda a, b: a*b, ft_tiny, ft_tiny) + self.assert_raises_fpe(overflow, + lambda a, b: a*b, ft_max, ftype(2)) + self.assert_raises_fpe(overflow, + lambda a, b: a/b, ft_max, ftype(0.5)) + self.assert_raises_fpe(overflow, + lambda a, b: a+b, ft_max, ft_max*ft_eps) + self.assert_raises_fpe(overflow, + lambda a, b: a-b, -ft_max, ft_max*ft_eps) + self.assert_raises_fpe(overflow, + np.power, ftype(2), ftype(2**fi.nexp)) + self.assert_raises_fpe(divbyzero, + lambda a, b: a/b, ftype(1), ftype(0)) + self.assert_raises_fpe( + invalid, lambda a, b: a/b, ftype(np.inf), ftype(np.inf) + ) + self.assert_raises_fpe(invalid, + lambda a, b: a/b, ftype(0), ftype(0)) + self.assert_raises_fpe( + invalid, lambda a, b: a-b, ftype(np.inf), ftype(np.inf) + ) + self.assert_raises_fpe( + invalid, lambda a, b: a+b, ftype(np.inf), ftype(-np.inf) + ) + self.assert_raises_fpe(invalid, + lambda a, b: a*b, ftype(0), ftype(np.inf)) + + @pytest.mark.skipif(IS_WASM, reason="no wasm fp exception support") + def test_warnings(self): + # test warning code path + with warnings.catch_warnings(record=True) as w: + warnings.simplefilter("always") + with np.errstate(all="warn"): + np.divide(1, 0.) + assert_equal(len(w), 1) + assert_("divide by zero" in str(w[0].message)) + np.array(1e300) * np.array(1e300) + assert_equal(len(w), 2) + assert_("overflow" in str(w[-1].message)) + np.array(np.inf) - np.array(np.inf) + assert_equal(len(w), 3) + assert_("invalid value" in str(w[-1].message)) + np.array(1e-300) * np.array(1e-300) + assert_equal(len(w), 4) + assert_("underflow" in str(w[-1].message)) + + +class TestTypes: + def check_promotion_cases(self, promote_func): + # tests that the scalars get coerced correctly. + b = np.bool(0) + i8, i16, i32, i64 = np.int8(0), np.int16(0), np.int32(0), np.int64(0) + u8, u16, u32, u64 = np.uint8(0), np.uint16(0), np.uint32(0), np.uint64(0) + f32, f64, fld = np.float32(0), np.float64(0), np.longdouble(0) + c64, c128, cld = np.complex64(0), np.complex128(0), np.clongdouble(0) + + # coercion within the same kind + assert_equal(promote_func(i8, i16), np.dtype(np.int16)) + assert_equal(promote_func(i32, i8), np.dtype(np.int32)) + assert_equal(promote_func(i16, i64), np.dtype(np.int64)) + assert_equal(promote_func(u8, u32), np.dtype(np.uint32)) + assert_equal(promote_func(f32, f64), np.dtype(np.float64)) + assert_equal(promote_func(fld, f32), np.dtype(np.longdouble)) + assert_equal(promote_func(f64, fld), np.dtype(np.longdouble)) + assert_equal(promote_func(c128, c64), np.dtype(np.complex128)) + assert_equal(promote_func(cld, c128), np.dtype(np.clongdouble)) + assert_equal(promote_func(c64, fld), np.dtype(np.clongdouble)) + + # coercion between kinds + assert_equal(promote_func(b, i32), np.dtype(np.int32)) + assert_equal(promote_func(b, u8), np.dtype(np.uint8)) + assert_equal(promote_func(i8, u8), np.dtype(np.int16)) + assert_equal(promote_func(u8, i32), np.dtype(np.int32)) + assert_equal(promote_func(i64, u32), np.dtype(np.int64)) + assert_equal(promote_func(u64, i32), np.dtype(np.float64)) + assert_equal(promote_func(i32, f32), np.dtype(np.float64)) + assert_equal(promote_func(i64, f32), np.dtype(np.float64)) + assert_equal(promote_func(f32, i16), np.dtype(np.float32)) + assert_equal(promote_func(f32, u32), np.dtype(np.float64)) + assert_equal(promote_func(f32, c64), np.dtype(np.complex64)) + assert_equal(promote_func(c128, f32), np.dtype(np.complex128)) + assert_equal(promote_func(cld, f64), np.dtype(np.clongdouble)) + + # coercion between scalars and 1-D arrays + assert_equal(promote_func(np.array([b]), i8), np.dtype(np.int8)) + assert_equal(promote_func(np.array([b]), u8), np.dtype(np.uint8)) + assert_equal(promote_func(np.array([b]), i32), np.dtype(np.int32)) + assert_equal(promote_func(np.array([b]), u32), np.dtype(np.uint32)) + assert_equal(promote_func(np.array([i8]), i64), np.dtype(np.int64)) + # unsigned and signed unfortunately tend to promote to float64: + assert_equal(promote_func(u64, np.array([i32])), np.dtype(np.float64)) + assert_equal(promote_func(i64, np.array([u32])), np.dtype(np.int64)) + assert_equal(promote_func(np.array([u16]), i32), np.dtype(np.int32)) + assert_equal(promote_func(np.int32(-1), np.array([u64])), + np.dtype(np.float64)) + assert_equal(promote_func(f64, np.array([f32])), np.dtype(np.float64)) + assert_equal(promote_func(fld, np.array([f32])), + np.dtype(np.longdouble)) + assert_equal(promote_func(np.array([f64]), fld), + np.dtype(np.longdouble)) + assert_equal(promote_func(fld, np.array([c64])), + np.dtype(np.clongdouble)) + assert_equal(promote_func(c64, np.array([f64])), + np.dtype(np.complex128)) + assert_equal(promote_func(np.complex64(3j), np.array([f64])), + np.dtype(np.complex128)) + assert_equal(promote_func(np.array([f32]), c128), + np.dtype(np.complex128)) + + # coercion between scalars and 1-D arrays, where + # the scalar has greater kind than the array + assert_equal(promote_func(np.array([b]), f64), np.dtype(np.float64)) + assert_equal(promote_func(np.array([b]), i64), np.dtype(np.int64)) + assert_equal(promote_func(np.array([b]), u64), np.dtype(np.uint64)) + assert_equal(promote_func(np.array([i8]), f64), np.dtype(np.float64)) + assert_equal(promote_func(np.array([u16]), f64), np.dtype(np.float64)) + + + def test_coercion(self): + def res_type(a, b): + return np.add(a, b).dtype + + self.check_promotion_cases(res_type) + + # Use-case: float/complex scalar * bool/int8 array + # shouldn't narrow the float/complex type + for a in [np.array([True, False]), np.array([-3, 12], dtype=np.int8)]: + b = 1.234 * a + assert_equal(b.dtype, np.dtype('f8'), "array type %s" % a.dtype) + b = np.longdouble(1.234) * a + assert_equal(b.dtype, np.dtype(np.longdouble), + "array type %s" % a.dtype) + b = np.float64(1.234) * a + assert_equal(b.dtype, np.dtype('f8'), "array type %s" % a.dtype) + b = np.float32(1.234) * a + assert_equal(b.dtype, np.dtype('f4'), "array type %s" % a.dtype) + b = np.float16(1.234) * a + assert_equal(b.dtype, np.dtype('f2'), "array type %s" % a.dtype) + + b = 1.234j * a + assert_equal(b.dtype, np.dtype('c16'), "array type %s" % a.dtype) + b = np.clongdouble(1.234j) * a + assert_equal(b.dtype, np.dtype(np.clongdouble), + "array type %s" % a.dtype) + b = np.complex128(1.234j) * a + assert_equal(b.dtype, np.dtype('c16'), "array type %s" % a.dtype) + b = np.complex64(1.234j) * a + assert_equal(b.dtype, np.dtype('c8'), "array type %s" % a.dtype) + + # The following use-case is problematic, and to resolve its + # tricky side-effects requires more changes. + # + # Use-case: (1-t)*a, where 't' is a boolean array and 'a' is + # a float32, shouldn't promote to float64 + # + # a = np.array([1.0, 1.5], dtype=np.float32) + # t = np.array([True, False]) + # b = t*a + # assert_equal(b, [1.0, 0.0]) + # assert_equal(b.dtype, np.dtype('f4')) + # b = (1-t)*a + # assert_equal(b, [0.0, 1.5]) + # assert_equal(b.dtype, np.dtype('f4')) + # + # Probably ~t (bitwise negation) is more proper to use here, + # but this is arguably less intuitive to understand at a glance, and + # would fail if 't' is actually an integer array instead of boolean: + # + # b = (~t)*a + # assert_equal(b, [0.0, 1.5]) + # assert_equal(b.dtype, np.dtype('f4')) + + def test_result_type(self): + self.check_promotion_cases(np.result_type) + assert_(np.result_type(None) == np.dtype(None)) + + def test_promote_types_endian(self): + # promote_types should always return native-endian types + assert_equal(np.promote_types('i8', '>i8'), np.dtype('i8')) + + assert_equal(np.promote_types('>i8', '>U16'), np.dtype('U21')) + assert_equal(np.promote_types('U16', '>i8'), np.dtype('U21')) + assert_equal(np.promote_types('S5', '>U8'), np.dtype('U8')) + assert_equal(np.promote_types('U8', '>S5'), np.dtype('U8')) + assert_equal(np.promote_types('U8', '>U5'), np.dtype('U8')) + + assert_equal(np.promote_types('M8', '>M8'), np.dtype('M8')) + assert_equal(np.promote_types('m8', '>m8'), np.dtype('m8')) + + def test_can_cast_and_promote_usertypes(self): + # The rational type defines safe casting for signed integers, + # boolean. Rational itself *does* cast safely to double. + # (rational does not actually cast to all signed integers, e.g. + # int64 can be both long and longlong and it registers only the first) + valid_types = ["int8", "int16", "int32", "int64", "bool"] + invalid_types = "BHILQP" + "FDG" + "mM" + "f" + "V" + + rational_dt = np.dtype(rational) + for numpy_dtype in valid_types: + numpy_dtype = np.dtype(numpy_dtype) + assert np.can_cast(numpy_dtype, rational_dt) + assert np.promote_types(numpy_dtype, rational_dt) is rational_dt + + for numpy_dtype in invalid_types: + numpy_dtype = np.dtype(numpy_dtype) + assert not np.can_cast(numpy_dtype, rational_dt) + with pytest.raises(TypeError): + np.promote_types(numpy_dtype, rational_dt) + + double_dt = np.dtype("double") + assert np.can_cast(rational_dt, double_dt) + assert np.promote_types(double_dt, rational_dt) is double_dt + + @pytest.mark.parametrize("swap", ["", "swap"]) + @pytest.mark.parametrize("string_dtype", ["U", "S"]) + def test_promote_types_strings(self, swap, string_dtype): + if swap == "swap": + promote_types = lambda a, b: np.promote_types(b, a) + else: + promote_types = np.promote_types + + S = string_dtype + + # Promote numeric with unsized string: + assert_equal(promote_types('bool', S), np.dtype(S+'5')) + assert_equal(promote_types('b', S), np.dtype(S+'4')) + assert_equal(promote_types('u1', S), np.dtype(S+'3')) + assert_equal(promote_types('u2', S), np.dtype(S+'5')) + assert_equal(promote_types('u4', S), np.dtype(S+'10')) + assert_equal(promote_types('u8', S), np.dtype(S+'20')) + assert_equal(promote_types('i1', S), np.dtype(S+'4')) + assert_equal(promote_types('i2', S), np.dtype(S+'6')) + assert_equal(promote_types('i4', S), np.dtype(S+'11')) + assert_equal(promote_types('i8', S), np.dtype(S+'21')) + # Promote numeric with sized string: + assert_equal(promote_types('bool', S+'1'), np.dtype(S+'5')) + assert_equal(promote_types('bool', S+'30'), np.dtype(S+'30')) + assert_equal(promote_types('b', S+'1'), np.dtype(S+'4')) + assert_equal(promote_types('b', S+'30'), np.dtype(S+'30')) + assert_equal(promote_types('u1', S+'1'), np.dtype(S+'3')) + assert_equal(promote_types('u1', S+'30'), np.dtype(S+'30')) + assert_equal(promote_types('u2', S+'1'), np.dtype(S+'5')) + assert_equal(promote_types('u2', S+'30'), np.dtype(S+'30')) + assert_equal(promote_types('u4', S+'1'), np.dtype(S+'10')) + assert_equal(promote_types('u4', S+'30'), np.dtype(S+'30')) + assert_equal(promote_types('u8', S+'1'), np.dtype(S+'20')) + assert_equal(promote_types('u8', S+'30'), np.dtype(S+'30')) + # Promote with object: + assert_equal(promote_types('O', S+'30'), np.dtype('O')) + + @pytest.mark.parametrize(["dtype1", "dtype2"], + [[np.dtype("V6"), np.dtype("V10")], # mismatch shape + # Mismatching names: + [np.dtype([("name1", "i8")]), np.dtype([("name2", "i8")])], + ]) + def test_invalid_void_promotion(self, dtype1, dtype2): + with pytest.raises(TypeError): + np.promote_types(dtype1, dtype2) + + @pytest.mark.parametrize(["dtype1", "dtype2"], + [[np.dtype("V10"), np.dtype("V10")], + [np.dtype([("name1", "i8")]), + np.dtype([("name1", np.dtype("i8").newbyteorder())])], + [np.dtype("i8,i8"), np.dtype("i8,>i8")], + [np.dtype("i8,i8"), np.dtype("i4,i4")], + ]) + def test_valid_void_promotion(self, dtype1, dtype2): + assert np.promote_types(dtype1, dtype2) == dtype1 + + @pytest.mark.parametrize("dtype", + list(np.typecodes["All"]) + + ["i,i", "10i", "S3", "S100", "U3", "U100", rational]) + def test_promote_identical_types_metadata(self, dtype): + # The same type passed in twice to promote types always + # preserves metadata + metadata = {1: 1} + dtype = np.dtype(dtype, metadata=metadata) + + res = np.promote_types(dtype, dtype) + assert res.metadata == dtype.metadata + + # byte-swapping preserves and makes the dtype native: + dtype = dtype.newbyteorder() + if dtype.isnative: + # The type does not have byte swapping + return + + res = np.promote_types(dtype, dtype) + + # Metadata is (currently) generally lost on byte-swapping (except for + # unicode. + if dtype.char != "U": + assert res.metadata is None + else: + assert res.metadata == metadata + assert res.isnative + + @pytest.mark.slow + @pytest.mark.filterwarnings('ignore:Promotion of numbers:FutureWarning') + @pytest.mark.parametrize(["dtype1", "dtype2"], + itertools.product( + list(np.typecodes["All"]) + + ["i,i", "S3", "S100", "U3", "U100", rational], + repeat=2)) + def test_promote_types_metadata(self, dtype1, dtype2): + """Metadata handling in promotion does not appear formalized + right now in NumPy. This test should thus be considered to + document behaviour, rather than test the correct definition of it. + + This test is very ugly, it was useful for rewriting part of the + promotion, but probably should eventually be replaced/deleted + (i.e. when metadata handling in promotion is better defined). + """ + metadata1 = {1: 1} + metadata2 = {2: 2} + dtype1 = np.dtype(dtype1, metadata=metadata1) + dtype2 = np.dtype(dtype2, metadata=metadata2) + + try: + res = np.promote_types(dtype1, dtype2) + except TypeError: + # Promotion failed, this test only checks metadata + return + + if res.char not in "USV" or res.names is not None or res.shape != (): + # All except string dtypes (and unstructured void) lose metadata + # on promotion (unless both dtypes are identical). + # At some point structured ones did not, but were restrictive. + assert res.metadata is None + elif res == dtype1: + # If one result is the result, it is usually returned unchanged: + assert res is dtype1 + elif res == dtype2: + # dtype1 may have been cast to the same type/kind as dtype2. + # If the resulting dtype is identical we currently pick the cast + # version of dtype1, which lost the metadata: + if np.promote_types(dtype1, dtype2.kind) == dtype2: + res.metadata is None + else: + res.metadata == metadata2 + else: + assert res.metadata is None + + # Try again for byteswapped version + dtype1 = dtype1.newbyteorder() + assert dtype1.metadata == metadata1 + res_bs = np.promote_types(dtype1, dtype2) + assert res_bs == res + assert res_bs.metadata == res.metadata + + def test_can_cast(self): + assert_(np.can_cast(np.int32, np.int64)) + assert_(np.can_cast(np.float64, complex)) + assert_(not np.can_cast(complex, float)) + + assert_(np.can_cast('i8', 'f8')) + assert_(not np.can_cast('i8', 'f4')) + assert_(np.can_cast('i4', 'S11')) + + assert_(np.can_cast('i8', 'i8', 'no')) + assert_(not np.can_cast('i8', 'no')) + + assert_(np.can_cast('i8', 'equiv')) + assert_(not np.can_cast('i8', 'equiv')) + + assert_(np.can_cast('i8', 'safe')) + assert_(not np.can_cast('i4', 'safe')) + + assert_(np.can_cast('i4', 'same_kind')) + assert_(not np.can_cast('u4', 'same_kind')) + + assert_(np.can_cast('u4', 'unsafe')) + + assert_(np.can_cast('bool', 'S5')) + assert_(not np.can_cast('bool', 'S4')) + + assert_(np.can_cast('b', 'S4')) + assert_(not np.can_cast('b', 'S3')) + + assert_(np.can_cast('u1', 'S3')) + assert_(not np.can_cast('u1', 'S2')) + assert_(np.can_cast('u2', 'S5')) + assert_(not np.can_cast('u2', 'S4')) + assert_(np.can_cast('u4', 'S10')) + assert_(not np.can_cast('u4', 'S9')) + assert_(np.can_cast('u8', 'S20')) + assert_(not np.can_cast('u8', 'S19')) + + assert_(np.can_cast('i1', 'S4')) + assert_(not np.can_cast('i1', 'S3')) + assert_(np.can_cast('i2', 'S6')) + assert_(not np.can_cast('i2', 'S5')) + assert_(np.can_cast('i4', 'S11')) + assert_(not np.can_cast('i4', 'S10')) + assert_(np.can_cast('i8', 'S21')) + assert_(not np.can_cast('i8', 'S20')) + + assert_(np.can_cast('bool', 'S5')) + assert_(not np.can_cast('bool', 'S4')) + + assert_(np.can_cast('b', 'U4')) + assert_(not np.can_cast('b', 'U3')) + + assert_(np.can_cast('u1', 'U3')) + assert_(not np.can_cast('u1', 'U2')) + assert_(np.can_cast('u2', 'U5')) + assert_(not np.can_cast('u2', 'U4')) + assert_(np.can_cast('u4', 'U10')) + assert_(not np.can_cast('u4', 'U9')) + assert_(np.can_cast('u8', 'U20')) + assert_(not np.can_cast('u8', 'U19')) + + assert_(np.can_cast('i1', 'U4')) + assert_(not np.can_cast('i1', 'U3')) + assert_(np.can_cast('i2', 'U6')) + assert_(not np.can_cast('i2', 'U5')) + assert_(np.can_cast('i4', 'U11')) + assert_(not np.can_cast('i4', 'U10')) + assert_(np.can_cast('i8', 'U21')) + assert_(not np.can_cast('i8', 'U20')) + + assert_raises(TypeError, np.can_cast, 'i4', None) + assert_raises(TypeError, np.can_cast, None, 'i4') + + # Also test keyword arguments + assert_(np.can_cast(from_=np.int32, to=np.int64)) + + def test_can_cast_simple_to_structured(self): + # Non-structured can only be cast to structured in 'unsafe' mode. + assert_(not np.can_cast('i4', 'i4,i4')) + assert_(not np.can_cast('i4', 'i4,i2')) + assert_(np.can_cast('i4', 'i4,i4', casting='unsafe')) + assert_(np.can_cast('i4', 'i4,i2', casting='unsafe')) + # Even if there is just a single field which is OK. + assert_(not np.can_cast('i2', [('f1', 'i4')])) + assert_(not np.can_cast('i2', [('f1', 'i4')], casting='same_kind')) + assert_(np.can_cast('i2', [('f1', 'i4')], casting='unsafe')) + # It should be the same for recursive structured or subarrays. + assert_(not np.can_cast('i2', [('f1', 'i4,i4')])) + assert_(np.can_cast('i2', [('f1', 'i4,i4')], casting='unsafe')) + assert_(not np.can_cast('i2', [('f1', '(2,3)i4')])) + assert_(np.can_cast('i2', [('f1', '(2,3)i4')], casting='unsafe')) + + def test_can_cast_structured_to_simple(self): + # Need unsafe casting for structured to simple. + assert_(not np.can_cast([('f1', 'i4')], 'i4')) + assert_(np.can_cast([('f1', 'i4')], 'i4', casting='unsafe')) + assert_(np.can_cast([('f1', 'i4')], 'i2', casting='unsafe')) + # Since it is unclear what is being cast, multiple fields to + # single should not work even for unsafe casting. + assert_(not np.can_cast('i4,i4', 'i4', casting='unsafe')) + # But a single field inside a single field is OK. + assert_(not np.can_cast([('f1', [('x', 'i4')])], 'i4')) + assert_(np.can_cast([('f1', [('x', 'i4')])], 'i4', casting='unsafe')) + # And a subarray is fine too - it will just take the first element + # (arguably not very consistently; might also take the first field). + assert_(not np.can_cast([('f0', '(3,)i4')], 'i4')) + assert_(np.can_cast([('f0', '(3,)i4')], 'i4', casting='unsafe')) + # But a structured subarray with multiple fields should fail. + assert_(not np.can_cast([('f0', ('i4,i4'), (2,))], 'i4', + casting='unsafe')) + + @pytest.mark.xfail(np._get_promotion_state() != "legacy", + reason="NEP 50: no python int/float/complex support (yet)") + def test_can_cast_values(self): + # gh-5917 + for dt in sctypes['int'] + sctypes['uint']: + ii = np.iinfo(dt) + assert_(np.can_cast(ii.min, dt)) + assert_(np.can_cast(ii.max, dt)) + assert_(not np.can_cast(ii.min - 1, dt)) + assert_(not np.can_cast(ii.max + 1, dt)) + + for dt in sctypes['float']: + fi = np.finfo(dt) + assert_(np.can_cast(fi.min, dt)) + assert_(np.can_cast(fi.max, dt)) + + @pytest.mark.parametrize("dtype", + list("?bhilqBHILQefdgFDG") + [rational]) + def test_can_cast_scalars(self, dtype): + # Basic test to ensure that scalars are supported in can-cast + # (does not check behavior exhaustively). + dtype = np.dtype(dtype) + scalar = dtype.type(0) + + assert np.can_cast(scalar, "int64") == np.can_cast(dtype, "int64") + assert np.can_cast(scalar, "float32", casting="unsafe") + + +# Custom exception class to test exception propagation in fromiter +class NIterError(Exception): + pass + + +class TestFromiter: + def makegen(self): + return (x**2 for x in range(24)) + + def test_types(self): + ai32 = np.fromiter(self.makegen(), np.int32) + ai64 = np.fromiter(self.makegen(), np.int64) + af = np.fromiter(self.makegen(), float) + assert_(ai32.dtype == np.dtype(np.int32)) + assert_(ai64.dtype == np.dtype(np.int64)) + assert_(af.dtype == np.dtype(float)) + + def test_lengths(self): + expected = np.array(list(self.makegen())) + a = np.fromiter(self.makegen(), int) + a20 = np.fromiter(self.makegen(), int, 20) + assert_(len(a) == len(expected)) + assert_(len(a20) == 20) + assert_raises(ValueError, np.fromiter, + self.makegen(), int, len(expected) + 10) + + def test_values(self): + expected = np.array(list(self.makegen())) + a = np.fromiter(self.makegen(), int) + a20 = np.fromiter(self.makegen(), int, 20) + assert_(np.all(a == expected, axis=0)) + assert_(np.all(a20 == expected[:20], axis=0)) + + def load_data(self, n, eindex): + # Utility method for the issue 2592 tests. + # Raise an exception at the desired index in the iterator. + for e in range(n): + if e == eindex: + raise NIterError('error at index %s' % eindex) + yield e + + @pytest.mark.parametrize("dtype", [int, object]) + @pytest.mark.parametrize(["count", "error_index"], [(10, 5), (10, 9)]) + def test_2592(self, count, error_index, dtype): + # Test iteration exceptions are correctly raised. The data/generator + # has `count` elements but errors at `error_index` + iterable = self.load_data(count, error_index) + with pytest.raises(NIterError): + np.fromiter(iterable, dtype=dtype, count=count) + + @pytest.mark.parametrize("dtype", ["S", "S0", "V0", "U0"]) + def test_empty_not_structured(self, dtype): + # Note, "S0" could be allowed at some point, so long "S" (without + # any length) is rejected. + with pytest.raises(ValueError, match="Must specify length"): + np.fromiter([], dtype=dtype) + + @pytest.mark.parametrize(["dtype", "data"], + [("d", [1, 2, 3, 4, 5, 6, 7, 8, 9]), + ("O", [1, 2, 3, 4, 5, 6, 7, 8, 9]), + ("i,O", [(1, 2), (5, 4), (2, 3), (9, 8), (6, 7)]), + # subarray dtypes (important because their dimensions end up + # in the result arrays dimension: + ("2i", [(1, 2), (5, 4), (2, 3), (9, 8), (6, 7)]), + (np.dtype(("O", (2, 3))), + [((1, 2, 3), (3, 4, 5)), ((3, 2, 1), (5, 4, 3))])]) + @pytest.mark.parametrize("length_hint", [0, 1]) + def test_growth_and_complicated_dtypes(self, dtype, data, length_hint): + dtype = np.dtype(dtype) + + data = data * 100 # make sure we realloc a bit + + class MyIter: + # Class/example from gh-15789 + def __length_hint__(self): + # only required to be an estimate, this is legal + return length_hint # 0 or 1 + + def __iter__(self): + return iter(data) + + res = np.fromiter(MyIter(), dtype=dtype) + expected = np.array(data, dtype=dtype) + + assert_array_equal(res, expected) + + def test_empty_result(self): + class MyIter: + def __length_hint__(self): + return 10 + + def __iter__(self): + return iter([]) # actual iterator is empty. + + res = np.fromiter(MyIter(), dtype="d") + assert res.shape == (0,) + assert res.dtype == "d" + + def test_too_few_items(self): + msg = "iterator too short: Expected 10 but iterator had only 3 items." + with pytest.raises(ValueError, match=msg): + np.fromiter([1, 2, 3], count=10, dtype=int) + + def test_failed_itemsetting(self): + with pytest.raises(TypeError): + np.fromiter([1, None, 3], dtype=int) + + # The following manages to hit somewhat trickier code paths: + iterable = ((2, 3, 4) for i in range(5)) + with pytest.raises(ValueError): + np.fromiter(iterable, dtype=np.dtype((int, 2))) + +class TestNonzero: + def test_nonzero_trivial(self): + assert_equal(np.count_nonzero(np.array([])), 0) + assert_equal(np.count_nonzero(np.array([], dtype='?')), 0) + assert_equal(np.nonzero(np.array([])), ([],)) + + assert_equal(np.count_nonzero(np.array([0])), 0) + assert_equal(np.count_nonzero(np.array([0], dtype='?')), 0) + assert_equal(np.nonzero(np.array([0])), ([],)) + + assert_equal(np.count_nonzero(np.array([1])), 1) + assert_equal(np.count_nonzero(np.array([1], dtype='?')), 1) + assert_equal(np.nonzero(np.array([1])), ([0],)) + + def test_nonzero_zerodim(self): + err_msg = "Calling nonzero on 0d arrays is not allowed" + with assert_raises_regex(ValueError, err_msg): + np.nonzero(np.array(0)) + with assert_raises_regex(ValueError, err_msg): + np.array(1).nonzero() + + def test_nonzero_onedim(self): + x = np.array([1, 0, 2, -1, 0, 0, 8]) + assert_equal(np.count_nonzero(x), 4) + assert_equal(np.count_nonzero(x), 4) + assert_equal(np.nonzero(x), ([0, 2, 3, 6],)) + + # x = np.array([(1, 2), (0, 0), (1, 1), (-1, 3), (0, 7)], + # dtype=[('a', 'i4'), ('b', 'i2')]) + x = np.array([(1, 2, -5, -3), (0, 0, 2, 7), (1, 1, 0, 1), (-1, 3, 1, 0), (0, 7, 0, 4)], + dtype=[('a', 'i4'), ('b', 'i2'), ('c', 'i1'), ('d', 'i8')]) + assert_equal(np.count_nonzero(x['a']), 3) + assert_equal(np.count_nonzero(x['b']), 4) + assert_equal(np.count_nonzero(x['c']), 3) + assert_equal(np.count_nonzero(x['d']), 4) + assert_equal(np.nonzero(x['a']), ([0, 2, 3],)) + assert_equal(np.nonzero(x['b']), ([0, 2, 3, 4],)) + + def test_nonzero_twodim(self): + x = np.array([[0, 1, 0], [2, 0, 3]]) + assert_equal(np.count_nonzero(x.astype('i1')), 3) + assert_equal(np.count_nonzero(x.astype('i2')), 3) + assert_equal(np.count_nonzero(x.astype('i4')), 3) + assert_equal(np.count_nonzero(x.astype('i8')), 3) + assert_equal(np.nonzero(x), ([0, 1, 1], [1, 0, 2])) + + x = np.eye(3) + assert_equal(np.count_nonzero(x.astype('i1')), 3) + assert_equal(np.count_nonzero(x.astype('i2')), 3) + assert_equal(np.count_nonzero(x.astype('i4')), 3) + assert_equal(np.count_nonzero(x.astype('i8')), 3) + assert_equal(np.nonzero(x), ([0, 1, 2], [0, 1, 2])) + + x = np.array([[(0, 1), (0, 0), (1, 11)], + [(1, 1), (1, 0), (0, 0)], + [(0, 0), (1, 5), (0, 1)]], dtype=[('a', 'f4'), ('b', 'u1')]) + assert_equal(np.count_nonzero(x['a']), 4) + assert_equal(np.count_nonzero(x['b']), 5) + assert_equal(np.nonzero(x['a']), ([0, 1, 1, 2], [2, 0, 1, 1])) + assert_equal(np.nonzero(x['b']), ([0, 0, 1, 2, 2], [0, 2, 0, 1, 2])) + + assert_(not x['a'].T.flags.aligned) + assert_equal(np.count_nonzero(x['a'].T), 4) + assert_equal(np.count_nonzero(x['b'].T), 5) + assert_equal(np.nonzero(x['a'].T), ([0, 1, 1, 2], [1, 1, 2, 0])) + assert_equal(np.nonzero(x['b'].T), ([0, 0, 1, 2, 2], [0, 1, 2, 0, 2])) + + def test_sparse(self): + # test special sparse condition boolean code path + for i in range(20): + c = np.zeros(200, dtype=bool) + c[i::20] = True + assert_equal(np.nonzero(c)[0], np.arange(i, 200 + i, 20)) + + c = np.zeros(400, dtype=bool) + c[10 + i:20 + i] = True + c[20 + i*2] = True + assert_equal(np.nonzero(c)[0], + np.concatenate((np.arange(10 + i, 20 + i), [20 + i*2]))) + + def test_return_type(self): + class C(np.ndarray): + pass + + for view in (C, np.ndarray): + for nd in range(1, 4): + shape = tuple(range(2, 2+nd)) + x = np.arange(np.prod(shape)).reshape(shape).view(view) + for nzx in (np.nonzero(x), x.nonzero()): + for nzx_i in nzx: + assert_(type(nzx_i) is np.ndarray) + assert_(nzx_i.flags.writeable) + + def test_count_nonzero_axis(self): + # Basic check of functionality + m = np.array([[0, 1, 7, 0, 0], [3, 0, 0, 2, 19]]) + + expected = np.array([1, 1, 1, 1, 1]) + assert_equal(np.count_nonzero(m, axis=0), expected) + + expected = np.array([2, 3]) + assert_equal(np.count_nonzero(m, axis=1), expected) + + assert_raises(ValueError, np.count_nonzero, m, axis=(1, 1)) + assert_raises(TypeError, np.count_nonzero, m, axis='foo') + assert_raises(AxisError, np.count_nonzero, m, axis=3) + assert_raises(TypeError, np.count_nonzero, + m, axis=np.array([[1], [2]])) + + def test_count_nonzero_axis_all_dtypes(self): + # More thorough test that the axis argument is respected + # for all dtypes and responds correctly when presented with + # either integer or tuple arguments for axis + msg = "Mismatch for dtype: %s" + + def assert_equal_w_dt(a, b, err_msg): + assert_equal(a.dtype, b.dtype, err_msg=err_msg) + assert_equal(a, b, err_msg=err_msg) + + for dt in np.typecodes['All']: + err_msg = msg % (np.dtype(dt).name,) + + if dt != 'V': + if dt != 'M': + m = np.zeros((3, 3), dtype=dt) + n = np.ones(1, dtype=dt) + + m[0, 0] = n[0] + m[1, 0] = n[0] + + else: # np.zeros doesn't work for np.datetime64 + m = np.array(['1970-01-01'] * 9) + m = m.reshape((3, 3)) + + m[0, 0] = '1970-01-12' + m[1, 0] = '1970-01-12' + m = m.astype(dt) + + expected = np.array([2, 0, 0], dtype=np.intp) + assert_equal_w_dt(np.count_nonzero(m, axis=0), + expected, err_msg=err_msg) + + expected = np.array([1, 1, 0], dtype=np.intp) + assert_equal_w_dt(np.count_nonzero(m, axis=1), + expected, err_msg=err_msg) + + expected = np.array(2) + assert_equal(np.count_nonzero(m, axis=(0, 1)), + expected, err_msg=err_msg) + assert_equal(np.count_nonzero(m, axis=None), + expected, err_msg=err_msg) + assert_equal(np.count_nonzero(m), + expected, err_msg=err_msg) + + if dt == 'V': + # There are no 'nonzero' objects for np.void, so the testing + # setup is slightly different for this dtype + m = np.array([np.void(1)] * 6).reshape((2, 3)) + + expected = np.array([0, 0, 0], dtype=np.intp) + assert_equal_w_dt(np.count_nonzero(m, axis=0), + expected, err_msg=err_msg) + + expected = np.array([0, 0], dtype=np.intp) + assert_equal_w_dt(np.count_nonzero(m, axis=1), + expected, err_msg=err_msg) + + expected = np.array(0) + assert_equal(np.count_nonzero(m, axis=(0, 1)), + expected, err_msg=err_msg) + assert_equal(np.count_nonzero(m, axis=None), + expected, err_msg=err_msg) + assert_equal(np.count_nonzero(m), + expected, err_msg=err_msg) + + def test_count_nonzero_axis_consistent(self): + # Check that the axis behaviour for valid axes in + # non-special cases is consistent (and therefore + # correct) by checking it against an integer array + # that is then casted to the generic object dtype + from itertools import combinations, permutations + + axis = (0, 1, 2, 3) + size = (5, 5, 5, 5) + msg = "Mismatch for axis: %s" + + rng = np.random.RandomState(1234) + m = rng.randint(-100, 100, size=size) + n = m.astype(object) + + for length in range(len(axis)): + for combo in combinations(axis, length): + for perm in permutations(combo): + assert_equal( + np.count_nonzero(m, axis=perm), + np.count_nonzero(n, axis=perm), + err_msg=msg % (perm,)) + + def test_countnonzero_axis_empty(self): + a = np.array([[0, 0, 1], [1, 0, 1]]) + assert_equal(np.count_nonzero(a, axis=()), a.astype(bool)) + + def test_countnonzero_keepdims(self): + a = np.array([[0, 0, 1, 0], + [0, 3, 5, 0], + [7, 9, 2, 0]]) + assert_equal(np.count_nonzero(a, axis=0, keepdims=True), + [[1, 2, 3, 0]]) + assert_equal(np.count_nonzero(a, axis=1, keepdims=True), + [[1], [2], [3]]) + assert_equal(np.count_nonzero(a, keepdims=True), + [[6]]) + + def test_array_method(self): + # Tests that the array method + # call to nonzero works + m = np.array([[1, 0, 0], [4, 0, 6]]) + tgt = [[0, 1, 1], [0, 0, 2]] + + assert_equal(m.nonzero(), tgt) + + def test_nonzero_invalid_object(self): + # gh-9295 + a = np.array([np.array([1, 2]), 3], dtype=object) + assert_raises(ValueError, np.nonzero, a) + + class BoolErrors: + def __bool__(self): + raise ValueError("Not allowed") + + assert_raises(ValueError, np.nonzero, np.array([BoolErrors()])) + + def test_nonzero_sideeffect_safety(self): + # gh-13631 + class FalseThenTrue: + _val = False + def __bool__(self): + try: + return self._val + finally: + self._val = True + + class TrueThenFalse: + _val = True + def __bool__(self): + try: + return self._val + finally: + self._val = False + + # result grows on the second pass + a = np.array([True, FalseThenTrue()]) + assert_raises(RuntimeError, np.nonzero, a) + + a = np.array([[True], [FalseThenTrue()]]) + assert_raises(RuntimeError, np.nonzero, a) + + # result shrinks on the second pass + a = np.array([False, TrueThenFalse()]) + assert_raises(RuntimeError, np.nonzero, a) + + a = np.array([[False], [TrueThenFalse()]]) + assert_raises(RuntimeError, np.nonzero, a) + + def test_nonzero_sideffects_structured_void(self): + # Checks that structured void does not mutate alignment flag of + # original array. + arr = np.zeros(5, dtype="i1,i8,i8") # `ones` may short-circuit + assert arr.flags.aligned # structs are considered "aligned" + assert not arr["f2"].flags.aligned + # make sure that nonzero/count_nonzero do not flip the flag: + np.nonzero(arr) + assert arr.flags.aligned + np.count_nonzero(arr) + assert arr.flags.aligned + + def test_nonzero_exception_safe(self): + # gh-13930 + + class ThrowsAfter: + def __init__(self, iters): + self.iters_left = iters + + def __bool__(self): + if self.iters_left == 0: + raise ValueError("called `iters` times") + + self.iters_left -= 1 + return True + + """ + Test that a ValueError is raised instead of a SystemError + + If the __bool__ function is called after the error state is set, + Python (cpython) will raise a SystemError. + """ + + # assert that an exception in first pass is handled correctly + a = np.array([ThrowsAfter(5)]*10) + assert_raises(ValueError, np.nonzero, a) + + # raise exception in second pass for 1-dimensional loop + a = np.array([ThrowsAfter(15)]*10) + assert_raises(ValueError, np.nonzero, a) + + # raise exception in second pass for n-dimensional loop + a = np.array([[ThrowsAfter(15)]]*10) + assert_raises(ValueError, np.nonzero, a) + + @pytest.mark.skipif(IS_WASM, reason="wasm doesn't have threads") + def test_structured_threadsafety(self): + # Nonzero (and some other functions) should be threadsafe for + # structured datatypes, see gh-15387. This test can behave randomly. + from concurrent.futures import ThreadPoolExecutor + + # Create a deeply nested dtype to make a failure more likely: + dt = np.dtype([("", "f8")]) + dt = np.dtype([("", dt)]) + dt = np.dtype([("", dt)] * 2) + # The array should be large enough to likely run into threading issues + arr = np.random.uniform(size=(5000, 4)).view(dt)[:, 0] + def func(arr): + arr.nonzero() + + tpe = ThreadPoolExecutor(max_workers=8) + futures = [tpe.submit(func, arr) for _ in range(10)] + for f in futures: + f.result() + + assert arr.dtype is dt + + +class TestIndex: + def test_boolean(self): + a = rand(3, 5, 8) + V = rand(5, 8) + g1 = randint(0, 5, size=15) + g2 = randint(0, 8, size=15) + V[g1, g2] = -V[g1, g2] + assert_((np.array([a[0][V > 0], a[1][V > 0], a[2][V > 0]]) == a[:, V > 0]).all()) + + def test_boolean_edgecase(self): + a = np.array([], dtype='int32') + b = np.array([], dtype='bool') + c = a[b] + assert_equal(c, []) + assert_equal(c.dtype, np.dtype('int32')) + + +class TestBinaryRepr: + def test_zero(self): + assert_equal(np.binary_repr(0), '0') + + def test_positive(self): + assert_equal(np.binary_repr(10), '1010') + assert_equal(np.binary_repr(12522), + '11000011101010') + assert_equal(np.binary_repr(10736848), + '101000111101010011010000') + + def test_negative(self): + assert_equal(np.binary_repr(-1), '-1') + assert_equal(np.binary_repr(-10), '-1010') + assert_equal(np.binary_repr(-12522), + '-11000011101010') + assert_equal(np.binary_repr(-10736848), + '-101000111101010011010000') + + def test_sufficient_width(self): + assert_equal(np.binary_repr(0, width=5), '00000') + assert_equal(np.binary_repr(10, width=7), '0001010') + assert_equal(np.binary_repr(-5, width=7), '1111011') + + def test_neg_width_boundaries(self): + # see gh-8670 + + # Ensure that the example in the issue does not + # break before proceeding to a more thorough test. + assert_equal(np.binary_repr(-128, width=8), '10000000') + + for width in range(1, 11): + num = -2**(width - 1) + exp = '1' + (width - 1) * '0' + assert_equal(np.binary_repr(num, width=width), exp) + + def test_large_neg_int64(self): + # See gh-14289. + assert_equal(np.binary_repr(np.int64(-2**62), width=64), + '11' + '0'*62) + + +class TestBaseRepr: + def test_base3(self): + assert_equal(np.base_repr(3**5, 3), '100000') + + def test_positive(self): + assert_equal(np.base_repr(12, 10), '12') + assert_equal(np.base_repr(12, 10, 4), '000012') + assert_equal(np.base_repr(12, 4), '30') + assert_equal(np.base_repr(3731624803700888, 36), '10QR0ROFCEW') + + def test_negative(self): + assert_equal(np.base_repr(-12, 10), '-12') + assert_equal(np.base_repr(-12, 10, 4), '-000012') + assert_equal(np.base_repr(-12, 4), '-30') + + def test_base_range(self): + with assert_raises(ValueError): + np.base_repr(1, 1) + with assert_raises(ValueError): + np.base_repr(1, 37) + + def test_minimal_signed_int(self): + assert_equal(np.base_repr(np.int8(-128)), '-10000000') + + +def _test_array_equal_parametrizations(): + """ + we pre-create arrays as we sometime want to pass the same instance + and sometime not. Passing the same instances may not mean the array are + equal, especially when containing None + """ + # those are 0-d arrays, it used to be a special case + # where (e0 == e0).all() would raise + e0 = np.array(0, dtype="int") + e1 = np.array(1, dtype="float") + # x,y, nan_equal, expected_result + yield (e0, e0.copy(), None, True) + yield (e0, e0.copy(), False, True) + yield (e0, e0.copy(), True, True) + + # + yield (e1, e1.copy(), None, True) + yield (e1, e1.copy(), False, True) + yield (e1, e1.copy(), True, True) + + # Non-nanable – those cannot hold nans + a12 = np.array([1, 2]) + a12b = a12.copy() + a123 = np.array([1, 2, 3]) + a13 = np.array([1, 3]) + a34 = np.array([3, 4]) + + aS1 = np.array(["a"], dtype="S1") + aS1b = aS1.copy() + aS1u4 = np.array([("a", 1)], dtype="S1,u4") + aS1u4b = aS1u4.copy() + + yield (a12, a12b, None, True) + yield (a12, a12, None, True) + yield (a12, a123, None, False) + yield (a12, a34, None, False) + yield (a12, a13, None, False) + yield (aS1, aS1b, None, True) + yield (aS1, aS1, None, True) + + # Non-float dtype - equal_nan should have no effect, + yield (a123, a123, None, True) + yield (a123, a123, False, True) + yield (a123, a123, True, True) + yield (a123, a123.copy(), None, True) + yield (a123, a123.copy(), False, True) + yield (a123, a123.copy(), True, True) + yield (a123.astype("float"), a123.astype("float"), None, True) + yield (a123.astype("float"), a123.astype("float"), False, True) + yield (a123.astype("float"), a123.astype("float"), True, True) + + # these can hold None + b1 = np.array([1, 2, np.nan]) + b2 = np.array([1, np.nan, 2]) + b3 = np.array([1, 2, np.inf]) + b4 = np.array(np.nan) + + # instances are the same + yield (b1, b1, None, False) + yield (b1, b1, False, False) + yield (b1, b1, True, True) + + # equal but not same instance + yield (b1, b1.copy(), None, False) + yield (b1, b1.copy(), False, False) + yield (b1, b1.copy(), True, True) + + # same once stripped of Nan + yield (b1, b2, None, False) + yield (b1, b2, False, False) + yield (b1, b2, True, False) + + # nan's not conflated with inf's + yield (b1, b3, None, False) + yield (b1, b3, False, False) + yield (b1, b3, True, False) + + # all Nan + yield (b4, b4, None, False) + yield (b4, b4, False, False) + yield (b4, b4, True, True) + yield (b4, b4.copy(), None, False) + yield (b4, b4.copy(), False, False) + yield (b4, b4.copy(), True, True) + + t1 = b1.astype("timedelta64") + t2 = b2.astype("timedelta64") + + # Timedeltas are particular + yield (t1, t1, None, False) + yield (t1, t1, False, False) + yield (t1, t1, True, True) + + yield (t1, t1.copy(), None, False) + yield (t1, t1.copy(), False, False) + yield (t1, t1.copy(), True, True) + + yield (t1, t2, None, False) + yield (t1, t2, False, False) + yield (t1, t2, True, False) + + # Multi-dimensional array + md1 = np.array([[0, 1], [np.nan, 1]]) + + yield (md1, md1, None, False) + yield (md1, md1, False, False) + yield (md1, md1, True, True) + yield (md1, md1.copy(), None, False) + yield (md1, md1.copy(), False, False) + yield (md1, md1.copy(), True, True) + # both complexes are nan+nan.j but the same instance + cplx1, cplx2 = [np.array([np.nan + np.nan * 1j])] * 2 + + # only real or img are nan. + cplx3, cplx4 = np.complex64(1, np.nan), np.complex64(np.nan, 1) + + # Complex values + yield (cplx1, cplx2, None, False) + yield (cplx1, cplx2, False, False) + yield (cplx1, cplx2, True, True) + + # Complex values, 1+nan, nan+1j + yield (cplx3, cplx4, None, False) + yield (cplx3, cplx4, False, False) + yield (cplx3, cplx4, True, True) + + +class TestArrayComparisons: + @pytest.mark.parametrize( + "bx,by,equal_nan,expected", _test_array_equal_parametrizations() + ) + def test_array_equal_equal_nan(self, bx, by, equal_nan, expected): + """ + This test array_equal for a few combinaison: + + - are the two inputs the same object or not (same object many not + be equal if contains NaNs) + - Whether we should consider or not, NaNs, being equal. + + """ + if equal_nan is None: + res = np.array_equal(bx, by) + else: + res = np.array_equal(bx, by, equal_nan=equal_nan) + assert_(res is expected) + assert_(type(res) is bool) + + def test_array_equal_different_scalar_types(self): + # https://github.com/numpy/numpy/issues/27271 + a = np.array("foo") + b = np.array(1) + assert not np.array_equal(a, b) + assert not np.array_equiv(a, b) + + def test_none_compares_elementwise(self): + a = np.array([None, 1, None], dtype=object) + assert_equal(a == None, [True, False, True]) + assert_equal(a != None, [False, True, False]) + + a = np.ones(3) + assert_equal(a == None, [False, False, False]) + assert_equal(a != None, [True, True, True]) + + def test_array_equiv(self): + res = np.array_equiv(np.array([1, 2]), np.array([1, 2])) + assert_(res) + assert_(type(res) is bool) + res = np.array_equiv(np.array([1, 2]), np.array([1, 2, 3])) + assert_(not res) + assert_(type(res) is bool) + res = np.array_equiv(np.array([1, 2]), np.array([3, 4])) + assert_(not res) + assert_(type(res) is bool) + res = np.array_equiv(np.array([1, 2]), np.array([1, 3])) + assert_(not res) + assert_(type(res) is bool) + + res = np.array_equiv(np.array([1, 1]), np.array([1])) + assert_(res) + assert_(type(res) is bool) + res = np.array_equiv(np.array([1, 1]), np.array([[1], [1]])) + assert_(res) + assert_(type(res) is bool) + res = np.array_equiv(np.array([1, 2]), np.array([2])) + assert_(not res) + assert_(type(res) is bool) + res = np.array_equiv(np.array([1, 2]), np.array([[1], [2]])) + assert_(not res) + assert_(type(res) is bool) + res = np.array_equiv(np.array([1, 2]), np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])) + assert_(not res) + assert_(type(res) is bool) + + @pytest.mark.parametrize("dtype", ["V0", "V3", "V10"]) + def test_compare_unstructured_voids(self, dtype): + zeros = np.zeros(3, dtype=dtype) + + assert_array_equal(zeros, zeros) + assert not (zeros != zeros).any() + + if dtype == "V0": + # Can't test != of actually different data + return + + nonzeros = np.array([b"1", b"2", b"3"], dtype=dtype) + + assert not (zeros == nonzeros).any() + assert (zeros != nonzeros).all() + + +def assert_array_strict_equal(x, y): + assert_array_equal(x, y) + # Check flags, 32 bit arches typically don't provide 16 byte alignment + if ((x.dtype.alignment <= 8 or + np.intp().dtype.itemsize != 4) and + sys.platform != 'win32'): + assert_(x.flags == y.flags) + else: + assert_(x.flags.owndata == y.flags.owndata) + assert_(x.flags.writeable == y.flags.writeable) + assert_(x.flags.c_contiguous == y.flags.c_contiguous) + assert_(x.flags.f_contiguous == y.flags.f_contiguous) + assert_(x.flags.writebackifcopy == y.flags.writebackifcopy) + # check endianness + assert_(x.dtype.isnative == y.dtype.isnative) + + +class TestClip: + def setup_method(self): + self.nr = 5 + self.nc = 3 + + def fastclip(self, a, m, M, out=None, **kwargs): + return a.clip(m, M, out=out, **kwargs) + + def clip(self, a, m, M, out=None): + # use a.choose to verify fastclip result + selector = np.less(a, m) + 2*np.greater(a, M) + return selector.choose((a, m, M), out=out) + + # Handy functions + def _generate_data(self, n, m): + return randn(n, m) + + def _generate_data_complex(self, n, m): + return randn(n, m) + 1.j * rand(n, m) + + def _generate_flt_data(self, n, m): + return (randn(n, m)).astype(np.float32) + + def _neg_byteorder(self, a): + a = np.asarray(a) + if sys.byteorder == 'little': + a = a.astype(a.dtype.newbyteorder('>')) + else: + a = a.astype(a.dtype.newbyteorder('<')) + return a + + def _generate_non_native_data(self, n, m): + data = randn(n, m) + data = self._neg_byteorder(data) + assert_(not data.dtype.isnative) + return data + + def _generate_int_data(self, n, m): + return (10 * rand(n, m)).astype(np.int64) + + def _generate_int32_data(self, n, m): + return (10 * rand(n, m)).astype(np.int32) + + # Now the real test cases + + @pytest.mark.parametrize("dtype", '?bhilqpBHILQPefdgFDGO') + def test_ones_pathological(self, dtype): + # for preservation of behavior described in + # gh-12519; amin > amax behavior may still change + # in the future + arr = np.ones(10, dtype=dtype) + expected = np.zeros(10, dtype=dtype) + actual = np.clip(arr, 1, 0) + if dtype == 'O': + assert actual.tolist() == expected.tolist() + else: + assert_equal(actual, expected) + + def test_simple_double(self): + # Test native double input with scalar min/max. + a = self._generate_data(self.nr, self.nc) + m = 0.1 + M = 0.6 + ac = self.fastclip(a, m, M) + act = self.clip(a, m, M) + assert_array_strict_equal(ac, act) + + def test_simple_int(self): + # Test native int input with scalar min/max. + a = self._generate_int_data(self.nr, self.nc) + a = a.astype(int) + m = -2 + M = 4 + ac = self.fastclip(a, m, M) + act = self.clip(a, m, M) + assert_array_strict_equal(ac, act) + + def test_array_double(self): + # Test native double input with array min/max. + a = self._generate_data(self.nr, self.nc) + m = np.zeros(a.shape) + M = m + 0.5 + ac = self.fastclip(a, m, M) + act = self.clip(a, m, M) + assert_array_strict_equal(ac, act) + + def test_simple_nonnative(self): + # Test non native double input with scalar min/max. + # Test native double input with non native double scalar min/max. + a = self._generate_non_native_data(self.nr, self.nc) + m = -0.5 + M = 0.6 + ac = self.fastclip(a, m, M) + act = self.clip(a, m, M) + assert_array_equal(ac, act) + + # Test native double input with non native double scalar min/max. + a = self._generate_data(self.nr, self.nc) + m = -0.5 + M = self._neg_byteorder(0.6) + assert_(not M.dtype.isnative) + ac = self.fastclip(a, m, M) + act = self.clip(a, m, M) + assert_array_equal(ac, act) + + def test_simple_complex(self): + # Test native complex input with native double scalar min/max. + # Test native input with complex double scalar min/max. + a = 3 * self._generate_data_complex(self.nr, self.nc) + m = -0.5 + M = 1. + ac = self.fastclip(a, m, M) + act = self.clip(a, m, M) + assert_array_strict_equal(ac, act) + + # Test native input with complex double scalar min/max. + a = 3 * self._generate_data(self.nr, self.nc) + m = -0.5 + 1.j + M = 1. + 2.j + ac = self.fastclip(a, m, M) + act = self.clip(a, m, M) + assert_array_strict_equal(ac, act) + + def test_clip_complex(self): + # Address Issue gh-5354 for clipping complex arrays + # Test native complex input without explicit min/max + # ie, either min=None or max=None + a = np.ones(10, dtype=complex) + m = a.min() + M = a.max() + am = self.fastclip(a, m, None) + aM = self.fastclip(a, None, M) + assert_array_strict_equal(am, a) + assert_array_strict_equal(aM, a) + + def test_clip_non_contig(self): + # Test clip for non contiguous native input and native scalar min/max. + a = self._generate_data(self.nr * 2, self.nc * 3) + a = a[::2, ::3] + assert_(not a.flags['F_CONTIGUOUS']) + assert_(not a.flags['C_CONTIGUOUS']) + ac = self.fastclip(a, -1.6, 1.7) + act = self.clip(a, -1.6, 1.7) + assert_array_strict_equal(ac, act) + + def test_simple_out(self): + # Test native double input with scalar min/max. + a = self._generate_data(self.nr, self.nc) + m = -0.5 + M = 0.6 + ac = np.zeros(a.shape) + act = np.zeros(a.shape) + self.fastclip(a, m, M, ac) + self.clip(a, m, M, act) + assert_array_strict_equal(ac, act) + + @pytest.mark.parametrize("casting", [None, "unsafe"]) + def test_simple_int32_inout(self, casting): + # Test native int32 input with double min/max and int32 out. + a = self._generate_int32_data(self.nr, self.nc) + m = np.float64(0) + M = np.float64(2) + ac = np.zeros(a.shape, dtype=np.int32) + act = ac.copy() + if casting is None: + with pytest.raises(TypeError): + self.fastclip(a, m, M, ac, casting=casting) + else: + # explicitly passing "unsafe" will silence warning + self.fastclip(a, m, M, ac, casting=casting) + self.clip(a, m, M, act) + assert_array_strict_equal(ac, act) + + def test_simple_int64_out(self): + # Test native int32 input with int32 scalar min/max and int64 out. + a = self._generate_int32_data(self.nr, self.nc) + m = np.int32(-1) + M = np.int32(1) + ac = np.zeros(a.shape, dtype=np.int64) + act = ac.copy() + self.fastclip(a, m, M, ac) + self.clip(a, m, M, act) + assert_array_strict_equal(ac, act) + + def test_simple_int64_inout(self): + # Test native int32 input with double array min/max and int32 out. + a = self._generate_int32_data(self.nr, self.nc) + m = np.zeros(a.shape, np.float64) + M = np.float64(1) + ac = np.zeros(a.shape, dtype=np.int32) + act = ac.copy() + self.fastclip(a, m, M, out=ac, casting="unsafe") + self.clip(a, m, M, act) + assert_array_strict_equal(ac, act) + + def test_simple_int32_out(self): + # Test native double input with scalar min/max and int out. + a = self._generate_data(self.nr, self.nc) + m = -1.0 + M = 2.0 + ac = np.zeros(a.shape, dtype=np.int32) + act = ac.copy() + self.fastclip(a, m, M, out=ac, casting="unsafe") + self.clip(a, m, M, act) + assert_array_strict_equal(ac, act) + + def test_simple_inplace_01(self): + # Test native double input with array min/max in-place. + a = self._generate_data(self.nr, self.nc) + ac = a.copy() + m = np.zeros(a.shape) + M = 1.0 + self.fastclip(a, m, M, a) + self.clip(a, m, M, ac) + assert_array_strict_equal(a, ac) + + def test_simple_inplace_02(self): + # Test native double input with scalar min/max in-place. + a = self._generate_data(self.nr, self.nc) + ac = a.copy() + m = -0.5 + M = 0.6 + self.fastclip(a, m, M, a) + self.clip(ac, m, M, ac) + assert_array_strict_equal(a, ac) + + def test_noncontig_inplace(self): + # Test non contiguous double input with double scalar min/max in-place. + a = self._generate_data(self.nr * 2, self.nc * 3) + a = a[::2, ::3] + assert_(not a.flags['F_CONTIGUOUS']) + assert_(not a.flags['C_CONTIGUOUS']) + ac = a.copy() + m = -0.5 + M = 0.6 + self.fastclip(a, m, M, a) + self.clip(ac, m, M, ac) + assert_array_equal(a, ac) + + def test_type_cast_01(self): + # Test native double input with scalar min/max. + a = self._generate_data(self.nr, self.nc) + m = -0.5 + M = 0.6 + ac = self.fastclip(a, m, M) + act = self.clip(a, m, M) + assert_array_strict_equal(ac, act) + + def test_type_cast_02(self): + # Test native int32 input with int32 scalar min/max. + a = self._generate_int_data(self.nr, self.nc) + a = a.astype(np.int32) + m = -2 + M = 4 + ac = self.fastclip(a, m, M) + act = self.clip(a, m, M) + assert_array_strict_equal(ac, act) + + def test_type_cast_03(self): + # Test native int32 input with float64 scalar min/max. + a = self._generate_int32_data(self.nr, self.nc) + m = -2 + M = 4 + ac = self.fastclip(a, np.float64(m), np.float64(M)) + act = self.clip(a, np.float64(m), np.float64(M)) + assert_array_strict_equal(ac, act) + + def test_type_cast_04(self): + # Test native int32 input with float32 scalar min/max. + a = self._generate_int32_data(self.nr, self.nc) + m = np.float32(-2) + M = np.float32(4) + act = self.fastclip(a, m, M) + ac = self.clip(a, m, M) + assert_array_strict_equal(ac, act) + + def test_type_cast_05(self): + # Test native int32 with double arrays min/max. + a = self._generate_int_data(self.nr, self.nc) + m = -0.5 + M = 1. + ac = self.fastclip(a, m * np.zeros(a.shape), M) + act = self.clip(a, m * np.zeros(a.shape), M) + assert_array_strict_equal(ac, act) + + def test_type_cast_06(self): + # Test native with NON native scalar min/max. + a = self._generate_data(self.nr, self.nc) + m = 0.5 + m_s = self._neg_byteorder(m) + M = 1. + act = self.clip(a, m_s, M) + ac = self.fastclip(a, m_s, M) + assert_array_strict_equal(ac, act) + + def test_type_cast_07(self): + # Test NON native with native array min/max. + a = self._generate_data(self.nr, self.nc) + m = -0.5 * np.ones(a.shape) + M = 1. + a_s = self._neg_byteorder(a) + assert_(not a_s.dtype.isnative) + act = a_s.clip(m, M) + ac = self.fastclip(a_s, m, M) + assert_array_strict_equal(ac, act) + + def test_type_cast_08(self): + # Test NON native with native scalar min/max. + a = self._generate_data(self.nr, self.nc) + m = -0.5 + M = 1. + a_s = self._neg_byteorder(a) + assert_(not a_s.dtype.isnative) + ac = self.fastclip(a_s, m, M) + act = a_s.clip(m, M) + assert_array_strict_equal(ac, act) + + def test_type_cast_09(self): + # Test native with NON native array min/max. + a = self._generate_data(self.nr, self.nc) + m = -0.5 * np.ones(a.shape) + M = 1. + m_s = self._neg_byteorder(m) + assert_(not m_s.dtype.isnative) + ac = self.fastclip(a, m_s, M) + act = self.clip(a, m_s, M) + assert_array_strict_equal(ac, act) + + def test_type_cast_10(self): + # Test native int32 with float min/max and float out for output argument. + a = self._generate_int_data(self.nr, self.nc) + b = np.zeros(a.shape, dtype=np.float32) + m = np.float32(-0.5) + M = np.float32(1) + act = self.clip(a, m, M, out=b) + ac = self.fastclip(a, m, M, out=b) + assert_array_strict_equal(ac, act) + + def test_type_cast_11(self): + # Test non native with native scalar, min/max, out non native + a = self._generate_non_native_data(self.nr, self.nc) + b = a.copy() + b = b.astype(b.dtype.newbyteorder('>')) + bt = b.copy() + m = -0.5 + M = 1. + self.fastclip(a, m, M, out=b) + self.clip(a, m, M, out=bt) + assert_array_strict_equal(b, bt) + + def test_type_cast_12(self): + # Test native int32 input and min/max and float out + a = self._generate_int_data(self.nr, self.nc) + b = np.zeros(a.shape, dtype=np.float32) + m = np.int32(0) + M = np.int32(1) + act = self.clip(a, m, M, out=b) + ac = self.fastclip(a, m, M, out=b) + assert_array_strict_equal(ac, act) + + def test_clip_with_out_simple(self): + # Test native double input with scalar min/max + a = self._generate_data(self.nr, self.nc) + m = -0.5 + M = 0.6 + ac = np.zeros(a.shape) + act = np.zeros(a.shape) + self.fastclip(a, m, M, ac) + self.clip(a, m, M, act) + assert_array_strict_equal(ac, act) + + def test_clip_with_out_simple2(self): + # Test native int32 input with double min/max and int32 out + a = self._generate_int32_data(self.nr, self.nc) + m = np.float64(0) + M = np.float64(2) + ac = np.zeros(a.shape, dtype=np.int32) + act = ac.copy() + self.fastclip(a, m, M, out=ac, casting="unsafe") + self.clip(a, m, M, act) + assert_array_strict_equal(ac, act) + + def test_clip_with_out_simple_int32(self): + # Test native int32 input with int32 scalar min/max and int64 out + a = self._generate_int32_data(self.nr, self.nc) + m = np.int32(-1) + M = np.int32(1) + ac = np.zeros(a.shape, dtype=np.int64) + act = ac.copy() + self.fastclip(a, m, M, ac) + self.clip(a, m, M, act) + assert_array_strict_equal(ac, act) + + def test_clip_with_out_array_int32(self): + # Test native int32 input with double array min/max and int32 out + a = self._generate_int32_data(self.nr, self.nc) + m = np.zeros(a.shape, np.float64) + M = np.float64(1) + ac = np.zeros(a.shape, dtype=np.int32) + act = ac.copy() + self.fastclip(a, m, M, out=ac, casting="unsafe") + self.clip(a, m, M, act) + assert_array_strict_equal(ac, act) + + def test_clip_with_out_array_outint32(self): + # Test native double input with scalar min/max and int out + a = self._generate_data(self.nr, self.nc) + m = -1.0 + M = 2.0 + ac = np.zeros(a.shape, dtype=np.int32) + act = ac.copy() + self.fastclip(a, m, M, out=ac, casting="unsafe") + self.clip(a, m, M, act) + assert_array_strict_equal(ac, act) + + def test_clip_with_out_transposed(self): + # Test that the out argument works when transposed + a = np.arange(16).reshape(4, 4) + out = np.empty_like(a).T + a.clip(4, 10, out=out) + expected = self.clip(a, 4, 10) + assert_array_equal(out, expected) + + def test_clip_with_out_memory_overlap(self): + # Test that the out argument works when it has memory overlap + a = np.arange(16).reshape(4, 4) + ac = a.copy() + a[:-1].clip(4, 10, out=a[1:]) + expected = self.clip(ac[:-1], 4, 10) + assert_array_equal(a[1:], expected) + + def test_clip_inplace_array(self): + # Test native double input with array min/max + a = self._generate_data(self.nr, self.nc) + ac = a.copy() + m = np.zeros(a.shape) + M = 1.0 + self.fastclip(a, m, M, a) + self.clip(a, m, M, ac) + assert_array_strict_equal(a, ac) + + def test_clip_inplace_simple(self): + # Test native double input with scalar min/max + a = self._generate_data(self.nr, self.nc) + ac = a.copy() + m = -0.5 + M = 0.6 + self.fastclip(a, m, M, a) + self.clip(a, m, M, ac) + assert_array_strict_equal(a, ac) + + def test_clip_func_takes_out(self): + # Ensure that the clip() function takes an out=argument. + a = self._generate_data(self.nr, self.nc) + ac = a.copy() + m = -0.5 + M = 0.6 + a2 = np.clip(a, m, M, out=a) + self.clip(a, m, M, ac) + assert_array_strict_equal(a2, ac) + assert_(a2 is a) + + def test_clip_nan(self): + d = np.arange(7.) + assert_equal(d.clip(min=np.nan), np.nan) + assert_equal(d.clip(max=np.nan), np.nan) + assert_equal(d.clip(min=np.nan, max=np.nan), np.nan) + assert_equal(d.clip(min=-2, max=np.nan), np.nan) + assert_equal(d.clip(min=np.nan, max=10), np.nan) + + def test_object_clip(self): + a = np.arange(10, dtype=object) + actual = np.clip(a, 1, 5) + expected = np.array([1, 1, 2, 3, 4, 5, 5, 5, 5, 5]) + assert actual.tolist() == expected.tolist() + + def test_clip_all_none(self): + arr = np.arange(10, dtype=object) + assert_equal(np.clip(arr, None, None), arr) + assert_equal(np.clip(arr), arr) + + def test_clip_invalid_casting(self): + a = np.arange(10, dtype=object) + with assert_raises_regex(ValueError, + 'casting must be one of'): + self.fastclip(a, 1, 8, casting="garbage") + + @pytest.mark.parametrize("amin, amax", [ + # two scalars + (1, 0), + # mix scalar and array + (1, np.zeros(10)), + # two arrays + (np.ones(10), np.zeros(10)), + ]) + def test_clip_value_min_max_flip(self, amin, amax): + a = np.arange(10, dtype=np.int64) + # requirement from ufunc_docstrings.py + expected = np.minimum(np.maximum(a, amin), amax) + actual = np.clip(a, amin, amax) + assert_equal(actual, expected) + + @pytest.mark.parametrize("arr, amin, amax, exp", [ + # for a bug in npy_ObjectClip, based on a + # case produced by hypothesis + (np.zeros(10, dtype=object), + 0, + -2**64+1, + np.full(10, -2**64+1, dtype=object)), + # for bugs in NPY_TIMEDELTA_MAX, based on a case + # produced by hypothesis + (np.zeros(10, dtype='m8') - 1, + 0, + 0, + np.zeros(10, dtype='m8')), + ]) + def test_clip_problem_cases(self, arr, amin, amax, exp): + actual = np.clip(arr, amin, amax) + assert_equal(actual, exp) + + @pytest.mark.parametrize("arr, amin, amax", [ + # problematic scalar nan case from hypothesis + (np.zeros(10, dtype=np.int64), + np.array(np.nan), + np.zeros(10, dtype=np.int32)), + ]) + def test_clip_scalar_nan_propagation(self, arr, amin, amax): + # enforcement of scalar nan propagation for comparisons + # called through clip() + expected = np.minimum(np.maximum(arr, amin), amax) + actual = np.clip(arr, amin, amax) + assert_equal(actual, expected) + + @pytest.mark.xfail(reason="propagation doesn't match spec") + @pytest.mark.parametrize("arr, amin, amax", [ + (np.array([1] * 10, dtype='m8'), + np.timedelta64('NaT'), + np.zeros(10, dtype=np.int32)), + ]) + @pytest.mark.filterwarnings("ignore::DeprecationWarning") + def test_NaT_propagation(self, arr, amin, amax): + # NOTE: the expected function spec doesn't + # propagate NaT, but clip() now does + expected = np.minimum(np.maximum(arr, amin), amax) + actual = np.clip(arr, amin, amax) + assert_equal(actual, expected) + + @given( + data=st.data(), + arr=hynp.arrays( + dtype=hynp.integer_dtypes() | hynp.floating_dtypes(), + shape=hynp.array_shapes() + ) + ) + def test_clip_property(self, data, arr): + """A property-based test using Hypothesis. + + This aims for maximum generality: it could in principle generate *any* + valid inputs to np.clip, and in practice generates much more varied + inputs than human testers come up with. + + Because many of the inputs have tricky dependencies - compatible dtypes + and mutually-broadcastable shapes - we use `st.data()` strategy draw + values *inside* the test function, from strategies we construct based + on previous values. An alternative would be to define a custom strategy + with `@st.composite`, but until we have duplicated code inline is fine. + + That accounts for most of the function; the actual test is just three + lines to calculate and compare actual vs expected results! + """ + numeric_dtypes = hynp.integer_dtypes() | hynp.floating_dtypes() + # Generate shapes for the bounds which can be broadcast with each other + # and with the base shape. Below, we might decide to use scalar bounds, + # but it's clearer to generate these shapes unconditionally in advance. + in_shapes, result_shape = data.draw( + hynp.mutually_broadcastable_shapes( + num_shapes=2, base_shape=arr.shape + ) + ) + # Scalar `nan` is deprecated due to the differing behaviour it shows. + s = numeric_dtypes.flatmap( + lambda x: hynp.from_dtype(x, allow_nan=False)) + amin = data.draw(s | hynp.arrays(dtype=numeric_dtypes, + shape=in_shapes[0], elements={"allow_nan": False})) + amax = data.draw(s | hynp.arrays(dtype=numeric_dtypes, + shape=in_shapes[1], elements={"allow_nan": False})) + + # Then calculate our result and expected result and check that they're + # equal! See gh-12519 and gh-19457 for discussion deciding on this + # property and the result_type argument. + result = np.clip(arr, amin, amax) + t = np.result_type(arr, amin, amax) + expected = np.minimum(amax, np.maximum(arr, amin, dtype=t), dtype=t) + assert result.dtype == t + assert_array_equal(result, expected) + + def test_clip_min_max_args(self): + arr = np.arange(5) + + assert_array_equal(np.clip(arr), arr) + assert_array_equal(np.clip(arr, min=2, max=3), np.clip(arr, 2, 3)) + assert_array_equal(np.clip(arr, min=None, max=2), + np.clip(arr, None, 2)) + + with assert_raises_regex(TypeError, "missing 1 required positional " + "argument: 'a_max'"): + np.clip(arr, 2) + with assert_raises_regex(TypeError, "missing 1 required positional " + "argument: 'a_min'"): + np.clip(arr, a_max=2) + msg = ("Passing `min` or `max` keyword argument when `a_min` and " + "`a_max` are provided is forbidden.") + with assert_raises_regex(ValueError, msg): + np.clip(arr, 2, 3, max=3) + with assert_raises_regex(ValueError, msg): + np.clip(arr, 2, 3, min=2) + + @pytest.mark.parametrize("dtype,min,max", [ + ("int32", -2**32-1, 2**32), + ("int32", -2**320, None), + ("int32", None, 2**300), + ("int32", -1000, 2**32), + ("int32", -2**32-1, 1000), + ("uint8", -1, 129), + ]) + def test_out_of_bound_pyints(self, dtype, min, max): + a = np.arange(10000).astype(dtype) + # Check min only + c = np.clip(a, min=min, max=max) + assert not np.may_share_memory(a, c) + assert c.dtype == a.dtype + if min is not None: + assert (c >= min).all() + if max is not None: + assert (c <= max).all() + +class TestAllclose: + rtol = 1e-5 + atol = 1e-8 + + def setup_method(self): + self.olderr = np.seterr(invalid='ignore') + + def teardown_method(self): + np.seterr(**self.olderr) + + def tst_allclose(self, x, y): + assert_(np.allclose(x, y), "%s and %s not close" % (x, y)) + + def tst_not_allclose(self, x, y): + assert_(not np.allclose(x, y), "%s and %s shouldn't be close" % (x, y)) + + def test_ip_allclose(self): + # Parametric test factory. + arr = np.array([100, 1000]) + aran = np.arange(125).reshape((5, 5, 5)) + + atol = self.atol + rtol = self.rtol + + data = [([1, 0], [1, 0]), + ([atol], [0]), + ([1], [1+rtol+atol]), + (arr, arr + arr*rtol), + (arr, arr + arr*rtol + atol*2), + (aran, aran + aran*rtol), + (np.inf, np.inf), + (np.inf, [np.inf])] + + for (x, y) in data: + self.tst_allclose(x, y) + + def test_ip_not_allclose(self): + # Parametric test factory. + aran = np.arange(125).reshape((5, 5, 5)) + + atol = self.atol + rtol = self.rtol + + data = [([np.inf, 0], [1, np.inf]), + ([np.inf, 0], [1, 0]), + ([np.inf, np.inf], [1, np.inf]), + ([np.inf, np.inf], [1, 0]), + ([-np.inf, 0], [np.inf, 0]), + ([np.nan, 0], [np.nan, 0]), + ([atol*2], [0]), + ([1], [1+rtol+atol*2]), + (aran, aran + aran*atol + atol*2), + (np.array([np.inf, 1]), np.array([0, np.inf]))] + + for (x, y) in data: + self.tst_not_allclose(x, y) + + def test_no_parameter_modification(self): + x = np.array([np.inf, 1]) + y = np.array([0, np.inf]) + np.allclose(x, y) + assert_array_equal(x, np.array([np.inf, 1])) + assert_array_equal(y, np.array([0, np.inf])) + + def test_min_int(self): + # Could make problems because of abs(min_int) == min_int + min_int = np.iinfo(np.int_).min + a = np.array([min_int], dtype=np.int_) + assert_(np.allclose(a, a)) + + def test_equalnan(self): + x = np.array([1.0, np.nan]) + assert_(np.allclose(x, x, equal_nan=True)) + + def test_return_class_is_ndarray(self): + # Issue gh-6475 + # Check that allclose does not preserve subtypes + class Foo(np.ndarray): + def __new__(cls, *args, **kwargs): + return np.array(*args, **kwargs).view(cls) + + a = Foo([1]) + assert_(type(np.allclose(a, a)) is bool) + + +class TestIsclose: + rtol = 1e-5 + atol = 1e-8 + + def _setup(self): + atol = self.atol + rtol = self.rtol + arr = np.array([100, 1000]) + aran = np.arange(125).reshape((5, 5, 5)) + + self.all_close_tests = [ + ([1, 0], [1, 0]), + ([atol], [0]), + ([1], [1 + rtol + atol]), + (arr, arr + arr*rtol), + (arr, arr + arr*rtol + atol), + (aran, aran + aran*rtol), + (np.inf, np.inf), + (np.inf, [np.inf]), + ([np.inf, -np.inf], [np.inf, -np.inf]), + ] + self.none_close_tests = [ + ([np.inf, 0], [1, np.inf]), + ([np.inf, -np.inf], [1, 0]), + ([np.inf, np.inf], [1, -np.inf]), + ([np.inf, np.inf], [1, 0]), + ([np.nan, 0], [np.nan, -np.inf]), + ([atol*2], [0]), + ([1], [1 + rtol + atol*2]), + (aran, aran + rtol*1.1*aran + atol*1.1), + (np.array([np.inf, 1]), np.array([0, np.inf])), + ] + self.some_close_tests = [ + ([np.inf, 0], [np.inf, atol*2]), + ([atol, 1, 1e6*(1 + 2*rtol) + atol], [0, np.nan, 1e6]), + (np.arange(3), [0, 1, 2.1]), + (np.nan, [np.nan, np.nan, np.nan]), + ([0], [atol, np.inf, -np.inf, np.nan]), + (0, [atol, np.inf, -np.inf, np.nan]), + ] + self.some_close_results = [ + [True, False], + [True, False, False], + [True, True, False], + [False, False, False], + [True, False, False, False], + [True, False, False, False], + ] + + def test_ip_isclose(self): + self._setup() + tests = self.some_close_tests + results = self.some_close_results + for (x, y), result in zip(tests, results): + assert_array_equal(np.isclose(x, y), result) + + x = np.array([2.1, 2.1, 2.1, 2.1, 5, np.nan]) + y = np.array([2, 2, 2, 2, np.nan, 5]) + atol = [0.11, 0.09, 1e-8, 1e-8, 1, 1] + rtol = [1e-8, 1e-8, 0.06, 0.04, 1, 1] + expected = np.array([True, False, True, False, False, False]) + assert_array_equal(np.isclose(x, y, rtol=rtol, atol=atol), expected) + + message = "operands could not be broadcast together..." + atol = np.array([1e-8, 1e-8]) + with assert_raises(ValueError, msg=message): + np.isclose(x, y, atol=atol) + + rtol = np.array([1e-5, 1e-5]) + with assert_raises(ValueError, msg=message): + np.isclose(x, y, rtol=rtol) + + def test_nep50_isclose(self): + below_one = float(1.-np.finfo('f8').eps) + f32 = np.array(below_one, 'f4') # This is just 1 at float32 precision + assert f32 > np.array(below_one) + # NEP 50 broadcasting of python scalars + assert f32 == below_one + # Test that it works for isclose arguments too (and that those fail if + # one uses a numpy float64). + assert np.isclose(f32, below_one, atol=0, rtol=0) + assert np.isclose(f32, np.float32(0), atol=below_one) + assert np.isclose(f32, 2, atol=0, rtol=below_one/2) + assert not np.isclose(f32, np.float64(below_one), atol=0, rtol=0) + assert not np.isclose(f32, np.float32(0), atol=np.float64(below_one)) + assert not np.isclose(f32, 2, atol=0, rtol=np.float64(below_one/2)) + + def tst_all_isclose(self, x, y): + assert_(np.all(np.isclose(x, y)), "%s and %s not close" % (x, y)) + + def tst_none_isclose(self, x, y): + msg = "%s and %s shouldn't be close" + assert_(not np.any(np.isclose(x, y)), msg % (x, y)) + + def tst_isclose_allclose(self, x, y): + msg = "isclose.all() and allclose aren't same for %s and %s" + msg2 = "isclose and allclose aren't same for %s and %s" + if np.isscalar(x) and np.isscalar(y): + assert_(np.isclose(x, y) == np.allclose(x, y), msg=msg2 % (x, y)) + else: + assert_array_equal(np.isclose(x, y).all(), np.allclose(x, y), msg % (x, y)) + + def test_ip_all_isclose(self): + self._setup() + for (x, y) in self.all_close_tests: + self.tst_all_isclose(x, y) + + x = np.array([2.3, 3.6, 4.4, np.nan]) + y = np.array([2, 3, 4, np.nan]) + atol = [0.31, 0, 0, 1] + rtol = [0, 0.21, 0.11, 1] + assert np.allclose(x, y, atol=atol, rtol=rtol, equal_nan=True) + assert not np.allclose(x, y, atol=0.1, rtol=0.1, equal_nan=True) + + # Show that gh-14330 is resolved + assert np.allclose([1, 2, float('nan')], [1, 2, float('nan')], + atol=[1, 1, 1], equal_nan=True) + + def test_ip_none_isclose(self): + self._setup() + for (x, y) in self.none_close_tests: + self.tst_none_isclose(x, y) + + def test_ip_isclose_allclose(self): + self._setup() + tests = (self.all_close_tests + self.none_close_tests + + self.some_close_tests) + for (x, y) in tests: + self.tst_isclose_allclose(x, y) + + def test_equal_nan(self): + assert_array_equal(np.isclose(np.nan, np.nan, equal_nan=True), [True]) + arr = np.array([1.0, np.nan]) + assert_array_equal(np.isclose(arr, arr, equal_nan=True), [True, True]) + + def test_masked_arrays(self): + # Make sure to test the output type when arguments are interchanged. + + x = np.ma.masked_where([True, True, False], np.arange(3)) + assert_(type(x) is type(np.isclose(2, x))) + assert_(type(x) is type(np.isclose(x, 2))) + + x = np.ma.masked_where([True, True, False], [np.nan, np.inf, np.nan]) + assert_(type(x) is type(np.isclose(np.inf, x))) + assert_(type(x) is type(np.isclose(x, np.inf))) + + x = np.ma.masked_where([True, True, False], [np.nan, np.nan, np.nan]) + y = np.isclose(np.nan, x, equal_nan=True) + assert_(type(x) is type(y)) + # Ensure that the mask isn't modified... + assert_array_equal([True, True, False], y.mask) + y = np.isclose(x, np.nan, equal_nan=True) + assert_(type(x) is type(y)) + # Ensure that the mask isn't modified... + assert_array_equal([True, True, False], y.mask) + + x = np.ma.masked_where([True, True, False], [np.nan, np.nan, np.nan]) + y = np.isclose(x, x, equal_nan=True) + assert_(type(x) is type(y)) + # Ensure that the mask isn't modified... + assert_array_equal([True, True, False], y.mask) + + def test_scalar_return(self): + assert_(np.isscalar(np.isclose(1, 1))) + + def test_no_parameter_modification(self): + x = np.array([np.inf, 1]) + y = np.array([0, np.inf]) + np.isclose(x, y) + assert_array_equal(x, np.array([np.inf, 1])) + assert_array_equal(y, np.array([0, np.inf])) + + def test_non_finite_scalar(self): + # GH7014, when two scalars are compared the output should also be a + # scalar + assert_(np.isclose(np.inf, -np.inf) is np.False_) + assert_(np.isclose(0, np.inf) is np.False_) + assert_(type(np.isclose(0, np.inf)) is np.bool) + + def test_timedelta(self): + # Allclose currently works for timedelta64 as long as `atol` is + # an integer or also a timedelta64 + a = np.array([[1, 2, 3, "NaT"]], dtype="m8[ns]") + assert np.isclose(a, a, atol=0, equal_nan=True).all() + assert np.isclose(a, a, atol=np.timedelta64(1, "ns"), equal_nan=True).all() + assert np.allclose(a, a, atol=0, equal_nan=True) + assert np.allclose(a, a, atol=np.timedelta64(1, "ns"), equal_nan=True) + + +class TestStdVar: + def setup_method(self): + self.A = np.array([1, -1, 1, -1]) + self.real_var = 1 + + def test_basic(self): + assert_almost_equal(np.var(self.A), self.real_var) + assert_almost_equal(np.std(self.A)**2, self.real_var) + + def test_scalars(self): + assert_equal(np.var(1), 0) + assert_equal(np.std(1), 0) + + def test_ddof1(self): + assert_almost_equal(np.var(self.A, ddof=1), + self.real_var * len(self.A) / (len(self.A) - 1)) + assert_almost_equal(np.std(self.A, ddof=1)**2, + self.real_var*len(self.A) / (len(self.A) - 1)) + + def test_ddof2(self): + assert_almost_equal(np.var(self.A, ddof=2), + self.real_var * len(self.A) / (len(self.A) - 2)) + assert_almost_equal(np.std(self.A, ddof=2)**2, + self.real_var * len(self.A) / (len(self.A) - 2)) + + def test_correction(self): + assert_almost_equal( + np.var(self.A, correction=1), np.var(self.A, ddof=1) + ) + assert_almost_equal( + np.std(self.A, correction=1), np.std(self.A, ddof=1) + ) + + err_msg = "ddof and correction can't be provided simultaneously." + + with assert_raises_regex(ValueError, err_msg): + np.var(self.A, ddof=1, correction=0) + + with assert_raises_regex(ValueError, err_msg): + np.std(self.A, ddof=1, correction=1) + + def test_out_scalar(self): + d = np.arange(10) + out = np.array(0.) + r = np.std(d, out=out) + assert_(r is out) + assert_array_equal(r, out) + r = np.var(d, out=out) + assert_(r is out) + assert_array_equal(r, out) + r = np.mean(d, out=out) + assert_(r is out) + assert_array_equal(r, out) + + +class TestStdVarComplex: + def test_basic(self): + A = np.array([1, 1.j, -1, -1.j]) + real_var = 1 + assert_almost_equal(np.var(A), real_var) + assert_almost_equal(np.std(A)**2, real_var) + + def test_scalars(self): + assert_equal(np.var(1j), 0) + assert_equal(np.std(1j), 0) + + +class TestCreationFuncs: + # Test ones, zeros, empty and full. + + def setup_method(self): + dtypes = {np.dtype(tp) for tp in itertools.chain(*sctypes.values())} + # void, bytes, str + variable_sized = {tp for tp in dtypes if tp.str.endswith('0')} + keyfunc = lambda dtype: dtype.str + self.dtypes = sorted(dtypes - variable_sized | + {np.dtype(tp.str.replace("0", str(i))) + for tp in variable_sized for i in range(1, 10)}, + key=keyfunc) + self.dtypes += [type(dt) for dt in sorted(dtypes, key=keyfunc)] + self.orders = {'C': 'c_contiguous', 'F': 'f_contiguous'} + self.ndims = 10 + + def check_function(self, func, fill_value=None): + par = ((0, 1, 2), + range(self.ndims), + self.orders, + self.dtypes) + fill_kwarg = {} + if fill_value is not None: + fill_kwarg = {'fill_value': fill_value} + + for size, ndims, order, dtype in itertools.product(*par): + shape = ndims * [size] + + is_void = dtype is np.dtypes.VoidDType or ( + isinstance(dtype, np.dtype) and dtype.str.startswith('|V')) + + # do not fill void type + if fill_kwarg and is_void: + continue + + arr = func(shape, order=order, dtype=dtype, + **fill_kwarg) + + if isinstance(dtype, np.dtype): + assert_equal(arr.dtype, dtype) + elif isinstance(dtype, type(np.dtype)): + if dtype in (np.dtypes.StrDType, np.dtypes.BytesDType): + dtype_str = np.dtype(dtype.type).str.replace('0', '1') + assert_equal(arr.dtype, np.dtype(dtype_str)) + else: + assert_equal(arr.dtype, np.dtype(dtype.type)) + assert_(getattr(arr.flags, self.orders[order])) + + if fill_value is not None: + if arr.dtype.str.startswith('|S'): + val = str(fill_value) + else: + val = fill_value + assert_equal(arr, dtype.type(val)) + + def test_zeros(self): + self.check_function(np.zeros) + + def test_ones(self): + self.check_function(np.ones) + + def test_empty(self): + self.check_function(np.empty) + + def test_full(self): + self.check_function(np.full, 0) + self.check_function(np.full, 1) + + @pytest.mark.skipif(not HAS_REFCOUNT, reason="Python lacks refcounts") + def test_for_reference_leak(self): + # Make sure we have an object for reference + dim = 1 + beg = sys.getrefcount(dim) + np.zeros([dim]*10) + assert_(sys.getrefcount(dim) == beg) + np.ones([dim]*10) + assert_(sys.getrefcount(dim) == beg) + np.empty([dim]*10) + assert_(sys.getrefcount(dim) == beg) + np.full([dim]*10, 0) + assert_(sys.getrefcount(dim) == beg) + + +class TestLikeFuncs: + '''Test ones_like, zeros_like, empty_like and full_like''' + + def setup_method(self): + self.data = [ + # Array scalars + (np.array(3.), None), + (np.array(3), 'f8'), + # 1D arrays + (np.arange(6, dtype='f4'), None), + (np.arange(6), 'c16'), + # 2D C-layout arrays + (np.arange(6).reshape(2, 3), None), + (np.arange(6).reshape(3, 2), 'i1'), + # 2D F-layout arrays + (np.arange(6).reshape((2, 3), order='F'), None), + (np.arange(6).reshape((3, 2), order='F'), 'i1'), + # 3D C-layout arrays + (np.arange(24).reshape(2, 3, 4), None), + (np.arange(24).reshape(4, 3, 2), 'f4'), + # 3D F-layout arrays + (np.arange(24).reshape((2, 3, 4), order='F'), None), + (np.arange(24).reshape((4, 3, 2), order='F'), 'f4'), + # 3D non-C/F-layout arrays + (np.arange(24).reshape(2, 3, 4).swapaxes(0, 1), None), + (np.arange(24).reshape(4, 3, 2).swapaxes(0, 1), '?'), + ] + self.shapes = [(), (5,), (5,6,), (5,6,7,)] + + def compare_array_value(self, dz, value, fill_value): + if value is not None: + if fill_value: + # Conversion is close to what np.full_like uses + # but we may want to convert directly in the future + # which may result in errors (where this does not). + z = np.array(value).astype(dz.dtype) + assert_(np.all(dz == z)) + else: + assert_(np.all(dz == value)) + + def check_like_function(self, like_function, value, fill_value=False): + if fill_value: + fill_kwarg = {'fill_value': value} + else: + fill_kwarg = {} + for d, dtype in self.data: + # default (K) order, dtype + dz = like_function(d, dtype=dtype, **fill_kwarg) + assert_equal(dz.shape, d.shape) + assert_equal(np.array(dz.strides)*d.dtype.itemsize, + np.array(d.strides)*dz.dtype.itemsize) + assert_equal(d.flags.c_contiguous, dz.flags.c_contiguous) + assert_equal(d.flags.f_contiguous, dz.flags.f_contiguous) + if dtype is None: + assert_equal(dz.dtype, d.dtype) + else: + assert_equal(dz.dtype, np.dtype(dtype)) + self.compare_array_value(dz, value, fill_value) + + # C order, default dtype + dz = like_function(d, order='C', dtype=dtype, **fill_kwarg) + assert_equal(dz.shape, d.shape) + assert_(dz.flags.c_contiguous) + if dtype is None: + assert_equal(dz.dtype, d.dtype) + else: + assert_equal(dz.dtype, np.dtype(dtype)) + self.compare_array_value(dz, value, fill_value) + + # F order, default dtype + dz = like_function(d, order='F', dtype=dtype, **fill_kwarg) + assert_equal(dz.shape, d.shape) + assert_(dz.flags.f_contiguous) + if dtype is None: + assert_equal(dz.dtype, d.dtype) + else: + assert_equal(dz.dtype, np.dtype(dtype)) + self.compare_array_value(dz, value, fill_value) + + # A order + dz = like_function(d, order='A', dtype=dtype, **fill_kwarg) + assert_equal(dz.shape, d.shape) + if d.flags.f_contiguous: + assert_(dz.flags.f_contiguous) + else: + assert_(dz.flags.c_contiguous) + if dtype is None: + assert_equal(dz.dtype, d.dtype) + else: + assert_equal(dz.dtype, np.dtype(dtype)) + self.compare_array_value(dz, value, fill_value) + + # Test the 'shape' parameter + for s in self.shapes: + for o in 'CFA': + sz = like_function(d, dtype=dtype, shape=s, order=o, + **fill_kwarg) + assert_equal(sz.shape, s) + if dtype is None: + assert_equal(sz.dtype, d.dtype) + else: + assert_equal(sz.dtype, np.dtype(dtype)) + if o == 'C' or (o == 'A' and d.flags.c_contiguous): + assert_(sz.flags.c_contiguous) + elif o == 'F' or (o == 'A' and d.flags.f_contiguous): + assert_(sz.flags.f_contiguous) + self.compare_array_value(sz, value, fill_value) + + if (d.ndim != len(s)): + assert_equal(np.argsort(like_function(d, dtype=dtype, + shape=s, order='K', + **fill_kwarg).strides), + np.argsort(np.empty(s, dtype=dtype, + order='C').strides)) + else: + assert_equal(np.argsort(like_function(d, dtype=dtype, + shape=s, order='K', + **fill_kwarg).strides), + np.argsort(d.strides)) + + # Test the 'subok' parameter + class MyNDArray(np.ndarray): + pass + + a = np.array([[1, 2], [3, 4]]).view(MyNDArray) + + b = like_function(a, **fill_kwarg) + assert_(type(b) is MyNDArray) + + b = like_function(a, subok=False, **fill_kwarg) + assert_(type(b) is not MyNDArray) + + # Test invalid dtype + with assert_raises(TypeError): + a = np.array(b"abc") + like_function(a, dtype="S-1", **fill_kwarg) + + def test_ones_like(self): + self.check_like_function(np.ones_like, 1) + + def test_zeros_like(self): + self.check_like_function(np.zeros_like, 0) + + def test_empty_like(self): + self.check_like_function(np.empty_like, None) + + def test_filled_like(self): + self.check_like_function(np.full_like, 0, True) + self.check_like_function(np.full_like, 1, True) + # Large integers may overflow, but using int64 is OK (casts) + # see also gh-27075 + with pytest.raises(OverflowError): + np.full_like(np.ones(3, dtype=np.int8), 1000) + self.check_like_function(np.full_like, np.int64(1000), True) + self.check_like_function(np.full_like, 123.456, True) + # Inf to integer casts cause invalid-value errors: ignore them. + with np.errstate(invalid="ignore"): + self.check_like_function(np.full_like, np.inf, True) + + @pytest.mark.parametrize('likefunc', [np.empty_like, np.full_like, + np.zeros_like, np.ones_like]) + @pytest.mark.parametrize('dtype', [str, bytes]) + def test_dtype_str_bytes(self, likefunc, dtype): + # Regression test for gh-19860 + a = np.arange(16).reshape(2, 8) + b = a[:, ::2] # Ensure b is not contiguous. + kwargs = {'fill_value': ''} if likefunc == np.full_like else {} + result = likefunc(b, dtype=dtype, **kwargs) + if dtype == str: + assert result.strides == (16, 4) + else: + # dtype is bytes + assert result.strides == (4, 1) + + +class TestCorrelate: + def _setup(self, dt): + self.x = np.array([1, 2, 3, 4, 5], dtype=dt) + self.xs = np.arange(1, 20)[::3] + self.y = np.array([-1, -2, -3], dtype=dt) + self.z1 = np.array([-3., -8., -14., -20., -26., -14., -5.], dtype=dt) + self.z1_4 = np.array([-2., -5., -8., -11., -14., -5.], dtype=dt) + self.z1r = np.array([-15., -22., -22., -16., -10., -4., -1.], dtype=dt) + self.z2 = np.array([-5., -14., -26., -20., -14., -8., -3.], dtype=dt) + self.z2r = np.array([-1., -4., -10., -16., -22., -22., -15.], dtype=dt) + self.zs = np.array([-3., -14., -30., -48., -66., -84., + -102., -54., -19.], dtype=dt) + + def test_float(self): + self._setup(float) + z = np.correlate(self.x, self.y, 'full') + assert_array_almost_equal(z, self.z1) + z = np.correlate(self.x, self.y[:-1], 'full') + assert_array_almost_equal(z, self.z1_4) + z = np.correlate(self.y, self.x, 'full') + assert_array_almost_equal(z, self.z2) + z = np.correlate(self.x[::-1], self.y, 'full') + assert_array_almost_equal(z, self.z1r) + z = np.correlate(self.y, self.x[::-1], 'full') + assert_array_almost_equal(z, self.z2r) + z = np.correlate(self.xs, self.y, 'full') + assert_array_almost_equal(z, self.zs) + + def test_object(self): + self._setup(Decimal) + z = np.correlate(self.x, self.y, 'full') + assert_array_almost_equal(z, self.z1) + z = np.correlate(self.y, self.x, 'full') + assert_array_almost_equal(z, self.z2) + + def test_no_overwrite(self): + d = np.ones(100) + k = np.ones(3) + np.correlate(d, k) + assert_array_equal(d, np.ones(100)) + assert_array_equal(k, np.ones(3)) + + def test_complex(self): + x = np.array([1, 2, 3, 4+1j], dtype=complex) + y = np.array([-1, -2j, 3+1j], dtype=complex) + r_z = np.array([3-1j, 6, 8+1j, 11+5j, -5+8j, -4-1j], dtype=complex) + r_z = r_z[::-1].conjugate() + z = np.correlate(y, x, mode='full') + assert_array_almost_equal(z, r_z) + + def test_zero_size(self): + with pytest.raises(ValueError): + np.correlate(np.array([]), np.ones(1000), mode='full') + with pytest.raises(ValueError): + np.correlate(np.ones(1000), np.array([]), mode='full') + + def test_mode(self): + d = np.ones(100) + k = np.ones(3) + default_mode = np.correlate(d, k, mode='valid') + with assert_warns(DeprecationWarning): + valid_mode = np.correlate(d, k, mode='v') + assert_array_equal(valid_mode, default_mode) + # integer mode + with assert_raises(ValueError): + np.correlate(d, k, mode=-1) + assert_array_equal(np.correlate(d, k, mode=0), valid_mode) + # illegal arguments + with assert_raises(TypeError): + np.correlate(d, k, mode=None) + + +class TestConvolve: + def test_object(self): + d = [1.] * 100 + k = [1.] * 3 + assert_array_almost_equal(np.convolve(d, k)[2:-2], np.full(98, 3)) + + def test_no_overwrite(self): + d = np.ones(100) + k = np.ones(3) + np.convolve(d, k) + assert_array_equal(d, np.ones(100)) + assert_array_equal(k, np.ones(3)) + + def test_mode(self): + d = np.ones(100) + k = np.ones(3) + default_mode = np.convolve(d, k, mode='full') + with assert_warns(DeprecationWarning): + full_mode = np.convolve(d, k, mode='f') + assert_array_equal(full_mode, default_mode) + # integer mode + with assert_raises(ValueError): + np.convolve(d, k, mode=-1) + assert_array_equal(np.convolve(d, k, mode=2), full_mode) + # illegal arguments + with assert_raises(TypeError): + np.convolve(d, k, mode=None) + + +class TestArgwhere: + + @pytest.mark.parametrize('nd', [0, 1, 2]) + def test_nd(self, nd): + # get an nd array with multiple elements in every dimension + x = np.empty((2,)*nd, bool) + + # none + x[...] = False + assert_equal(np.argwhere(x).shape, (0, nd)) + + # only one + x[...] = False + x.flat[0] = True + assert_equal(np.argwhere(x).shape, (1, nd)) + + # all but one + x[...] = True + x.flat[0] = False + assert_equal(np.argwhere(x).shape, (x.size - 1, nd)) + + # all + x[...] = True + assert_equal(np.argwhere(x).shape, (x.size, nd)) + + def test_2D(self): + x = np.arange(6).reshape((2, 3)) + assert_array_equal(np.argwhere(x > 1), + [[0, 2], + [1, 0], + [1, 1], + [1, 2]]) + + def test_list(self): + assert_equal(np.argwhere([4, 0, 2, 1, 3]), [[0], [2], [3], [4]]) + + +class TestRoll: + def test_roll1d(self): + x = np.arange(10) + xr = np.roll(x, 2) + assert_equal(xr, np.array([8, 9, 0, 1, 2, 3, 4, 5, 6, 7])) + + def test_roll2d(self): + x2 = np.reshape(np.arange(10), (2, 5)) + x2r = np.roll(x2, 1) + assert_equal(x2r, np.array([[9, 0, 1, 2, 3], [4, 5, 6, 7, 8]])) + + x2r = np.roll(x2, 1, axis=0) + assert_equal(x2r, np.array([[5, 6, 7, 8, 9], [0, 1, 2, 3, 4]])) + + x2r = np.roll(x2, 1, axis=1) + assert_equal(x2r, np.array([[4, 0, 1, 2, 3], [9, 5, 6, 7, 8]])) + + # Roll multiple axes at once. + x2r = np.roll(x2, 1, axis=(0, 1)) + assert_equal(x2r, np.array([[9, 5, 6, 7, 8], [4, 0, 1, 2, 3]])) + + x2r = np.roll(x2, (1, 0), axis=(0, 1)) + assert_equal(x2r, np.array([[5, 6, 7, 8, 9], [0, 1, 2, 3, 4]])) + + x2r = np.roll(x2, (-1, 0), axis=(0, 1)) + assert_equal(x2r, np.array([[5, 6, 7, 8, 9], [0, 1, 2, 3, 4]])) + + x2r = np.roll(x2, (0, 1), axis=(0, 1)) + assert_equal(x2r, np.array([[4, 0, 1, 2, 3], [9, 5, 6, 7, 8]])) + + x2r = np.roll(x2, (0, -1), axis=(0, 1)) + assert_equal(x2r, np.array([[1, 2, 3, 4, 0], [6, 7, 8, 9, 5]])) + + x2r = np.roll(x2, (1, 1), axis=(0, 1)) + assert_equal(x2r, np.array([[9, 5, 6, 7, 8], [4, 0, 1, 2, 3]])) + + x2r = np.roll(x2, (-1, -1), axis=(0, 1)) + assert_equal(x2r, np.array([[6, 7, 8, 9, 5], [1, 2, 3, 4, 0]])) + + # Roll the same axis multiple times. + x2r = np.roll(x2, 1, axis=(0, 0)) + assert_equal(x2r, np.array([[0, 1, 2, 3, 4], [5, 6, 7, 8, 9]])) + + x2r = np.roll(x2, 1, axis=(1, 1)) + assert_equal(x2r, np.array([[3, 4, 0, 1, 2], [8, 9, 5, 6, 7]])) + + # Roll more than one turn in either direction. + x2r = np.roll(x2, 6, axis=1) + assert_equal(x2r, np.array([[4, 0, 1, 2, 3], [9, 5, 6, 7, 8]])) + + x2r = np.roll(x2, -4, axis=1) + assert_equal(x2r, np.array([[4, 0, 1, 2, 3], [9, 5, 6, 7, 8]])) + + def test_roll_empty(self): + x = np.array([]) + assert_equal(np.roll(x, 1), np.array([])) + + def test_roll_unsigned_shift(self): + x = np.arange(4) + shift = np.uint16(2) + assert_equal(np.roll(x, shift), np.roll(x, 2)) + + shift = np.uint64(2**63+2) + assert_equal(np.roll(x, shift), np.roll(x, 2)) + + def test_roll_big_int(self): + x = np.arange(4) + assert_equal(np.roll(x, 2**100), x) + + +class TestRollaxis: + + # expected shape indexed by (axis, start) for array of + # shape (1, 2, 3, 4) + tgtshape = {(0, 0): (1, 2, 3, 4), (0, 1): (1, 2, 3, 4), + (0, 2): (2, 1, 3, 4), (0, 3): (2, 3, 1, 4), + (0, 4): (2, 3, 4, 1), + (1, 0): (2, 1, 3, 4), (1, 1): (1, 2, 3, 4), + (1, 2): (1, 2, 3, 4), (1, 3): (1, 3, 2, 4), + (1, 4): (1, 3, 4, 2), + (2, 0): (3, 1, 2, 4), (2, 1): (1, 3, 2, 4), + (2, 2): (1, 2, 3, 4), (2, 3): (1, 2, 3, 4), + (2, 4): (1, 2, 4, 3), + (3, 0): (4, 1, 2, 3), (3, 1): (1, 4, 2, 3), + (3, 2): (1, 2, 4, 3), (3, 3): (1, 2, 3, 4), + (3, 4): (1, 2, 3, 4)} + + def test_exceptions(self): + a = np.arange(1*2*3*4).reshape(1, 2, 3, 4) + assert_raises(AxisError, np.rollaxis, a, -5, 0) + assert_raises(AxisError, np.rollaxis, a, 0, -5) + assert_raises(AxisError, np.rollaxis, a, 4, 0) + assert_raises(AxisError, np.rollaxis, a, 0, 5) + + def test_results(self): + a = np.arange(1*2*3*4).reshape(1, 2, 3, 4).copy() + aind = np.indices(a.shape) + assert_(a.flags['OWNDATA']) + for (i, j) in self.tgtshape: + # positive axis, positive start + res = np.rollaxis(a, axis=i, start=j) + i0, i1, i2, i3 = aind[np.array(res.shape) - 1] + assert_(np.all(res[i0, i1, i2, i3] == a)) + assert_(res.shape == self.tgtshape[(i, j)], str((i,j))) + assert_(not res.flags['OWNDATA']) + + # negative axis, positive start + ip = i + 1 + res = np.rollaxis(a, axis=-ip, start=j) + i0, i1, i2, i3 = aind[np.array(res.shape) - 1] + assert_(np.all(res[i0, i1, i2, i3] == a)) + assert_(res.shape == self.tgtshape[(4 - ip, j)]) + assert_(not res.flags['OWNDATA']) + + # positive axis, negative start + jp = j + 1 if j < 4 else j + res = np.rollaxis(a, axis=i, start=-jp) + i0, i1, i2, i3 = aind[np.array(res.shape) - 1] + assert_(np.all(res[i0, i1, i2, i3] == a)) + assert_(res.shape == self.tgtshape[(i, 4 - jp)]) + assert_(not res.flags['OWNDATA']) + + # negative axis, negative start + ip = i + 1 + jp = j + 1 if j < 4 else j + res = np.rollaxis(a, axis=-ip, start=-jp) + i0, i1, i2, i3 = aind[np.array(res.shape) - 1] + assert_(np.all(res[i0, i1, i2, i3] == a)) + assert_(res.shape == self.tgtshape[(4 - ip, 4 - jp)]) + assert_(not res.flags['OWNDATA']) + + +class TestMoveaxis: + def test_move_to_end(self): + x = np.random.randn(5, 6, 7) + for source, expected in [(0, (6, 7, 5)), + (1, (5, 7, 6)), + (2, (5, 6, 7)), + (-1, (5, 6, 7))]: + actual = np.moveaxis(x, source, -1).shape + assert_(actual, expected) + + def test_move_new_position(self): + x = np.random.randn(1, 2, 3, 4) + for source, destination, expected in [ + (0, 1, (2, 1, 3, 4)), + (1, 2, (1, 3, 2, 4)), + (1, -1, (1, 3, 4, 2)), + ]: + actual = np.moveaxis(x, source, destination).shape + assert_(actual, expected) + + def test_preserve_order(self): + x = np.zeros((1, 2, 3, 4)) + for source, destination in [ + (0, 0), + (3, -1), + (-1, 3), + ([0, -1], [0, -1]), + ([2, 0], [2, 0]), + (range(4), range(4)), + ]: + actual = np.moveaxis(x, source, destination).shape + assert_(actual, (1, 2, 3, 4)) + + def test_move_multiples(self): + x = np.zeros((0, 1, 2, 3)) + for source, destination, expected in [ + ([0, 1], [2, 3], (2, 3, 0, 1)), + ([2, 3], [0, 1], (2, 3, 0, 1)), + ([0, 1, 2], [2, 3, 0], (2, 3, 0, 1)), + ([3, 0], [1, 0], (0, 3, 1, 2)), + ([0, 3], [0, 1], (0, 3, 1, 2)), + ]: + actual = np.moveaxis(x, source, destination).shape + assert_(actual, expected) + + def test_errors(self): + x = np.random.randn(1, 2, 3) + assert_raises_regex(AxisError, 'source.*out of bounds', + np.moveaxis, x, 3, 0) + assert_raises_regex(AxisError, 'source.*out of bounds', + np.moveaxis, x, -4, 0) + assert_raises_regex(AxisError, 'destination.*out of bounds', + np.moveaxis, x, 0, 5) + assert_raises_regex(ValueError, 'repeated axis in `source`', + np.moveaxis, x, [0, 0], [0, 1]) + assert_raises_regex(ValueError, 'repeated axis in `destination`', + np.moveaxis, x, [0, 1], [1, 1]) + assert_raises_regex(ValueError, 'must have the same number', + np.moveaxis, x, 0, [0, 1]) + assert_raises_regex(ValueError, 'must have the same number', + np.moveaxis, x, [0, 1], [0]) + + def test_array_likes(self): + x = np.ma.zeros((1, 2, 3)) + result = np.moveaxis(x, 0, 0) + assert_(x.shape, result.shape) + assert_(isinstance(result, np.ma.MaskedArray)) + + x = [1, 2, 3] + result = np.moveaxis(x, 0, 0) + assert_(x, list(result)) + assert_(isinstance(result, np.ndarray)) + + +class TestCross: + @pytest.mark.filterwarnings( + "ignore:.*2-dimensional vectors.*:DeprecationWarning" + ) + def test_2x2(self): + u = [1, 2] + v = [3, 4] + z = -2 + cp = np.cross(u, v) + assert_equal(cp, z) + cp = np.cross(v, u) + assert_equal(cp, -z) + + @pytest.mark.filterwarnings( + "ignore:.*2-dimensional vectors.*:DeprecationWarning" + ) + def test_2x3(self): + u = [1, 2] + v = [3, 4, 5] + z = np.array([10, -5, -2]) + cp = np.cross(u, v) + assert_equal(cp, z) + cp = np.cross(v, u) + assert_equal(cp, -z) + + def test_3x3(self): + u = [1, 2, 3] + v = [4, 5, 6] + z = np.array([-3, 6, -3]) + cp = np.cross(u, v) + assert_equal(cp, z) + cp = np.cross(v, u) + assert_equal(cp, -z) + + @pytest.mark.filterwarnings( + "ignore:.*2-dimensional vectors.*:DeprecationWarning" + ) + def test_broadcasting(self): + # Ticket #2624 (Trac #2032) + u = np.tile([1, 2], (11, 1)) + v = np.tile([3, 4], (11, 1)) + z = -2 + assert_equal(np.cross(u, v), z) + assert_equal(np.cross(v, u), -z) + assert_equal(np.cross(u, u), 0) + + u = np.tile([1, 2], (11, 1)).T + v = np.tile([3, 4, 5], (11, 1)) + z = np.tile([10, -5, -2], (11, 1)) + assert_equal(np.cross(u, v, axisa=0), z) + assert_equal(np.cross(v, u.T), -z) + assert_equal(np.cross(v, v), 0) + + u = np.tile([1, 2, 3], (11, 1)).T + v = np.tile([3, 4], (11, 1)).T + z = np.tile([-12, 9, -2], (11, 1)) + assert_equal(np.cross(u, v, axisa=0, axisb=0), z) + assert_equal(np.cross(v.T, u.T), -z) + assert_equal(np.cross(u.T, u.T), 0) + + u = np.tile([1, 2, 3], (5, 1)) + v = np.tile([4, 5, 6], (5, 1)).T + z = np.tile([-3, 6, -3], (5, 1)) + assert_equal(np.cross(u, v, axisb=0), z) + assert_equal(np.cross(v.T, u), -z) + assert_equal(np.cross(u, u), 0) + + @pytest.mark.filterwarnings( + "ignore:.*2-dimensional vectors.*:DeprecationWarning" + ) + def test_broadcasting_shapes(self): + u = np.ones((2, 1, 3)) + v = np.ones((5, 3)) + assert_equal(np.cross(u, v).shape, (2, 5, 3)) + u = np.ones((10, 3, 5)) + v = np.ones((2, 5)) + assert_equal(np.cross(u, v, axisa=1, axisb=0).shape, (10, 5, 3)) + assert_raises(AxisError, np.cross, u, v, axisa=1, axisb=2) + assert_raises(AxisError, np.cross, u, v, axisa=3, axisb=0) + u = np.ones((10, 3, 5, 7)) + v = np.ones((5, 7, 2)) + assert_equal(np.cross(u, v, axisa=1, axisc=2).shape, (10, 5, 3, 7)) + assert_raises(AxisError, np.cross, u, v, axisa=-5, axisb=2) + assert_raises(AxisError, np.cross, u, v, axisa=1, axisb=-4) + # gh-5885 + u = np.ones((3, 4, 2)) + for axisc in range(-2, 2): + assert_equal(np.cross(u, u, axisc=axisc).shape, (3, 4)) + + def test_uint8_int32_mixed_dtypes(self): + # regression test for gh-19138 + u = np.array([[195, 8, 9]], np.uint8) + v = np.array([250, 166, 68], np.int32) + z = np.array([[950, 11010, -30370]], dtype=np.int32) + assert_equal(np.cross(v, u), z) + assert_equal(np.cross(u, v), -z) + + @pytest.mark.parametrize("a, b", [(0, [1, 2]), ([1, 2], 3)]) + def test_zero_dimension(self, a, b): + with pytest.raises(ValueError) as exc: + np.cross(a, b) + assert "At least one array has zero dimension" in str(exc.value) + + +def test_outer_out_param(): + arr1 = np.ones((5,)) + arr2 = np.ones((2,)) + arr3 = np.linspace(-2, 2, 5) + out1 = np.ndarray(shape=(5,5)) + out2 = np.ndarray(shape=(2, 5)) + res1 = np.outer(arr1, arr3, out1) + assert_equal(res1, out1) + assert_equal(np.outer(arr2, arr3, out2), out2) + + +class TestIndices: + + def test_simple(self): + [x, y] = np.indices((4, 3)) + assert_array_equal(x, np.array([[0, 0, 0], + [1, 1, 1], + [2, 2, 2], + [3, 3, 3]])) + assert_array_equal(y, np.array([[0, 1, 2], + [0, 1, 2], + [0, 1, 2], + [0, 1, 2]])) + + def test_single_input(self): + [x] = np.indices((4,)) + assert_array_equal(x, np.array([0, 1, 2, 3])) + + [x] = np.indices((4,), sparse=True) + assert_array_equal(x, np.array([0, 1, 2, 3])) + + def test_scalar_input(self): + assert_array_equal([], np.indices(())) + assert_array_equal([], np.indices((), sparse=True)) + assert_array_equal([[]], np.indices((0,))) + assert_array_equal([[]], np.indices((0,), sparse=True)) + + def test_sparse(self): + [x, y] = np.indices((4,3), sparse=True) + assert_array_equal(x, np.array([[0], [1], [2], [3]])) + assert_array_equal(y, np.array([[0, 1, 2]])) + + @pytest.mark.parametrize("dtype", [np.int32, np.int64, np.float32, np.float64]) + @pytest.mark.parametrize("dims", [(), (0,), (4, 3)]) + def test_return_type(self, dtype, dims): + inds = np.indices(dims, dtype=dtype) + assert_(inds.dtype == dtype) + + for arr in np.indices(dims, dtype=dtype, sparse=True): + assert_(arr.dtype == dtype) + + +class TestRequire: + flag_names = ['C', 'C_CONTIGUOUS', 'CONTIGUOUS', + 'F', 'F_CONTIGUOUS', 'FORTRAN', + 'A', 'ALIGNED', + 'W', 'WRITEABLE', + 'O', 'OWNDATA'] + + def generate_all_false(self, dtype): + arr = np.zeros((2, 2), [('junk', 'i1'), ('a', dtype)]) + arr.setflags(write=False) + a = arr['a'] + assert_(not a.flags['C']) + assert_(not a.flags['F']) + assert_(not a.flags['O']) + assert_(not a.flags['W']) + assert_(not a.flags['A']) + return a + + def set_and_check_flag(self, flag, dtype, arr): + if dtype is None: + dtype = arr.dtype + b = np.require(arr, dtype, [flag]) + assert_(b.flags[flag]) + assert_(b.dtype == dtype) + + # a further call to np.require ought to return the same array + # unless OWNDATA is specified. + c = np.require(b, None, [flag]) + if flag[0] != 'O': + assert_(c is b) + else: + assert_(c.flags[flag]) + + def test_require_each(self): + + id = ['f8', 'i4'] + fd = [None, 'f8', 'c16'] + for idtype, fdtype, flag in itertools.product(id, fd, self.flag_names): + a = self.generate_all_false(idtype) + self.set_and_check_flag(flag, fdtype, a) + + def test_unknown_requirement(self): + a = self.generate_all_false('f8') + assert_raises(KeyError, np.require, a, None, 'Q') + + def test_non_array_input(self): + a = np.require([1, 2, 3, 4], 'i4', ['C', 'A', 'O']) + assert_(a.flags['O']) + assert_(a.flags['C']) + assert_(a.flags['A']) + assert_(a.dtype == 'i4') + assert_equal(a, [1, 2, 3, 4]) + + def test_C_and_F_simul(self): + a = self.generate_all_false('f8') + assert_raises(ValueError, np.require, a, None, ['C', 'F']) + + def test_ensure_array(self): + class ArraySubclass(np.ndarray): + pass + + a = ArraySubclass((2, 2)) + b = np.require(a, None, ['E']) + assert_(type(b) is np.ndarray) + + def test_preserve_subtype(self): + class ArraySubclass(np.ndarray): + pass + + for flag in self.flag_names: + a = ArraySubclass((2, 2)) + self.set_and_check_flag(flag, None, a) + + +class TestBroadcast: + def test_broadcast_in_args(self): + # gh-5881 + arrs = [np.empty((6, 7)), np.empty((5, 6, 1)), np.empty((7,)), + np.empty((5, 1, 7))] + mits = [np.broadcast(*arrs), + np.broadcast(np.broadcast(*arrs[:0]), np.broadcast(*arrs[0:])), + np.broadcast(np.broadcast(*arrs[:1]), np.broadcast(*arrs[1:])), + np.broadcast(np.broadcast(*arrs[:2]), np.broadcast(*arrs[2:])), + np.broadcast(arrs[0], np.broadcast(*arrs[1:-1]), arrs[-1])] + for mit in mits: + assert_equal(mit.shape, (5, 6, 7)) + assert_equal(mit.ndim, 3) + assert_equal(mit.nd, 3) + assert_equal(mit.numiter, 4) + for a, ia in zip(arrs, mit.iters): + assert_(a is ia.base) + + def test_broadcast_single_arg(self): + # gh-6899 + arrs = [np.empty((5, 6, 7))] + mit = np.broadcast(*arrs) + assert_equal(mit.shape, (5, 6, 7)) + assert_equal(mit.ndim, 3) + assert_equal(mit.nd, 3) + assert_equal(mit.numiter, 1) + assert_(arrs[0] is mit.iters[0].base) + + def test_number_of_arguments(self): + arr = np.empty((5,)) + for j in range(70): + arrs = [arr] * j + if j > 64: + assert_raises(ValueError, np.broadcast, *arrs) + else: + mit = np.broadcast(*arrs) + assert_equal(mit.numiter, j) + + def test_broadcast_error_kwargs(self): + #gh-13455 + arrs = [np.empty((5, 6, 7))] + mit = np.broadcast(*arrs) + mit2 = np.broadcast(*arrs, **{}) + assert_equal(mit.shape, mit2.shape) + assert_equal(mit.ndim, mit2.ndim) + assert_equal(mit.nd, mit2.nd) + assert_equal(mit.numiter, mit2.numiter) + assert_(mit.iters[0].base is mit2.iters[0].base) + + assert_raises(ValueError, np.broadcast, 1, **{'x': 1}) + + def test_shape_mismatch_error_message(self): + with pytest.raises(ValueError, match=r"arg 0 with shape \(1, 3\) and " + r"arg 2 with shape \(2,\)"): + np.broadcast([[1, 2, 3]], [[4], [5]], [6, 7]) + + +class TestKeepdims: + + class sub_array(np.ndarray): + def sum(self, axis=None, dtype=None, out=None): + return np.ndarray.sum(self, axis, dtype, out, keepdims=True) + + def test_raise(self): + sub_class = self.sub_array + x = np.arange(30).view(sub_class) + assert_raises(TypeError, np.sum, x, keepdims=True) + + +class TestTensordot: + + def test_zero_dimension(self): + # Test resolution to issue #5663 + a = np.ndarray((3,0)) + b = np.ndarray((0,4)) + td = np.tensordot(a, b, (1, 0)) + assert_array_equal(td, np.dot(a, b)) + assert_array_equal(td, np.einsum('ij,jk', a, b)) + + def test_zero_dimensional(self): + # gh-12130 + arr_0d = np.array(1) + ret = np.tensordot(arr_0d, arr_0d, ([], [])) # contracting no axes is well defined + assert_array_equal(ret, arr_0d) + + +class TestAsType: + + def test_astype(self): + data = [[1, 2], [3, 4]] + actual = np.astype( + np.array(data, dtype=np.int64), np.uint32 + ) + expected = np.array(data, dtype=np.uint32) + + assert_array_equal(actual, expected) + assert_equal(actual.dtype, expected.dtype) + + assert np.shares_memory( + actual, np.astype(actual, actual.dtype, copy=False) + ) + + actual = np.astype(np.int64(10), np.float64) + expected = np.float64(10) + assert_equal(actual, expected) + assert_equal(actual.dtype, expected.dtype) + + with pytest.raises(TypeError, match="Input should be a NumPy array"): + np.astype(data, np.float64) diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/test_numerictypes.py b/venv/lib/python3.12/site-packages/numpy/_core/tests/test_numerictypes.py new file mode 100644 index 00000000..db4509b9 --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/tests/test_numerictypes.py @@ -0,0 +1,620 @@ +import sys +import itertools + +import pytest +import numpy as np +import numpy._core.numerictypes as nt +from numpy._core.numerictypes import ( + issctype, sctype2char, maximum_sctype, sctypes +) +from numpy.testing import ( + assert_, assert_equal, assert_raises, assert_raises_regex, IS_PYPY +) + +# This is the structure of the table used for plain objects: +# +# +-+-+-+ +# |x|y|z| +# +-+-+-+ + +# Structure of a plain array description: +Pdescr = [ + ('x', 'i4', (2,)), + ('y', 'f8', (2, 2)), + ('z', 'u1')] + +# A plain list of tuples with values for testing: +PbufferT = [ + # x y z + ([3, 2], [[6., 4.], [6., 4.]], 8), + ([4, 3], [[7., 5.], [7., 5.]], 9), + ] + + +# This is the structure of the table used for nested objects (DON'T PANIC!): +# +# +-+---------------------------------+-----+----------+-+-+ +# |x|Info |color|info |y|z| +# | +-----+--+----------------+----+--+ +----+-----+ | | +# | |value|y2|Info2 |name|z2| |Name|Value| | | +# | | | +----+-----+--+--+ | | | | | | | +# | | | |name|value|y3|z3| | | | | | | | +# +-+-----+--+----+-----+--+--+----+--+-----+----+-----+-+-+ +# + +# The corresponding nested array description: +Ndescr = [ + ('x', 'i4', (2,)), + ('Info', [ + ('value', 'c16'), + ('y2', 'f8'), + ('Info2', [ + ('name', 'S2'), + ('value', 'c16', (2,)), + ('y3', 'f8', (2,)), + ('z3', 'u4', (2,))]), + ('name', 'S2'), + ('z2', 'b1')]), + ('color', 'S2'), + ('info', [ + ('Name', 'U8'), + ('Value', 'c16')]), + ('y', 'f8', (2, 2)), + ('z', 'u1')] + +NbufferT = [ + # x Info color info y z + # value y2 Info2 name z2 Name Value + # name value y3 z3 + ([3, 2], (6j, 6., (b'nn', [6j, 4j], [6., 4.], [1, 2]), b'NN', True), + b'cc', ('NN', 6j), [[6., 4.], [6., 4.]], 8), + ([4, 3], (7j, 7., (b'oo', [7j, 5j], [7., 5.], [2, 1]), b'OO', False), + b'dd', ('OO', 7j), [[7., 5.], [7., 5.]], 9), + ] + + +byteorder = {'little':'<', 'big':'>'}[sys.byteorder] + +def normalize_descr(descr): + "Normalize a description adding the platform byteorder." + + out = [] + for item in descr: + dtype = item[1] + if isinstance(dtype, str): + if dtype[0] not in ['|', '<', '>']: + onebyte = dtype[1:] == "1" + if onebyte or dtype[0] in ['S', 'V', 'b']: + dtype = "|" + dtype + else: + dtype = byteorder + dtype + if len(item) > 2 and np.prod(item[2]) > 1: + nitem = (item[0], dtype, item[2]) + else: + nitem = (item[0], dtype) + out.append(nitem) + elif isinstance(dtype, list): + l = normalize_descr(dtype) + out.append((item[0], l)) + else: + raise ValueError("Expected a str or list and got %s" % + (type(item))) + return out + + +############################################################ +# Creation tests +############################################################ + +class CreateZeros: + """Check the creation of heterogeneous arrays zero-valued""" + + def test_zeros0D(self): + """Check creation of 0-dimensional objects""" + h = np.zeros((), dtype=self._descr) + assert_(normalize_descr(self._descr) == h.dtype.descr) + assert_(h.dtype.fields['x'][0].name[:4] == 'void') + assert_(h.dtype.fields['x'][0].char == 'V') + assert_(h.dtype.fields['x'][0].type == np.void) + # A small check that data is ok + assert_equal(h['z'], np.zeros((), dtype='u1')) + + def test_zerosSD(self): + """Check creation of single-dimensional objects""" + h = np.zeros((2,), dtype=self._descr) + assert_(normalize_descr(self._descr) == h.dtype.descr) + assert_(h.dtype['y'].name[:4] == 'void') + assert_(h.dtype['y'].char == 'V') + assert_(h.dtype['y'].type == np.void) + # A small check that data is ok + assert_equal(h['z'], np.zeros((2,), dtype='u1')) + + def test_zerosMD(self): + """Check creation of multi-dimensional objects""" + h = np.zeros((2, 3), dtype=self._descr) + assert_(normalize_descr(self._descr) == h.dtype.descr) + assert_(h.dtype['z'].name == 'uint8') + assert_(h.dtype['z'].char == 'B') + assert_(h.dtype['z'].type == np.uint8) + # A small check that data is ok + assert_equal(h['z'], np.zeros((2, 3), dtype='u1')) + + +class TestCreateZerosPlain(CreateZeros): + """Check the creation of heterogeneous arrays zero-valued (plain)""" + _descr = Pdescr + +class TestCreateZerosNested(CreateZeros): + """Check the creation of heterogeneous arrays zero-valued (nested)""" + _descr = Ndescr + + +class CreateValues: + """Check the creation of heterogeneous arrays with values""" + + def test_tuple(self): + """Check creation from tuples""" + h = np.array(self._buffer, dtype=self._descr) + assert_(normalize_descr(self._descr) == h.dtype.descr) + if self.multiple_rows: + assert_(h.shape == (2,)) + else: + assert_(h.shape == ()) + + def test_list_of_tuple(self): + """Check creation from list of tuples""" + h = np.array([self._buffer], dtype=self._descr) + assert_(normalize_descr(self._descr) == h.dtype.descr) + if self.multiple_rows: + assert_(h.shape == (1, 2)) + else: + assert_(h.shape == (1,)) + + def test_list_of_list_of_tuple(self): + """Check creation from list of list of tuples""" + h = np.array([[self._buffer]], dtype=self._descr) + assert_(normalize_descr(self._descr) == h.dtype.descr) + if self.multiple_rows: + assert_(h.shape == (1, 1, 2)) + else: + assert_(h.shape == (1, 1)) + + +class TestCreateValuesPlainSingle(CreateValues): + """Check the creation of heterogeneous arrays (plain, single row)""" + _descr = Pdescr + multiple_rows = 0 + _buffer = PbufferT[0] + +class TestCreateValuesPlainMultiple(CreateValues): + """Check the creation of heterogeneous arrays (plain, multiple rows)""" + _descr = Pdescr + multiple_rows = 1 + _buffer = PbufferT + +class TestCreateValuesNestedSingle(CreateValues): + """Check the creation of heterogeneous arrays (nested, single row)""" + _descr = Ndescr + multiple_rows = 0 + _buffer = NbufferT[0] + +class TestCreateValuesNestedMultiple(CreateValues): + """Check the creation of heterogeneous arrays (nested, multiple rows)""" + _descr = Ndescr + multiple_rows = 1 + _buffer = NbufferT + + +############################################################ +# Reading tests +############################################################ + +class ReadValuesPlain: + """Check the reading of values in heterogeneous arrays (plain)""" + + def test_access_fields(self): + h = np.array(self._buffer, dtype=self._descr) + if not self.multiple_rows: + assert_(h.shape == ()) + assert_equal(h['x'], np.array(self._buffer[0], dtype='i4')) + assert_equal(h['y'], np.array(self._buffer[1], dtype='f8')) + assert_equal(h['z'], np.array(self._buffer[2], dtype='u1')) + else: + assert_(len(h) == 2) + assert_equal(h['x'], np.array([self._buffer[0][0], + self._buffer[1][0]], dtype='i4')) + assert_equal(h['y'], np.array([self._buffer[0][1], + self._buffer[1][1]], dtype='f8')) + assert_equal(h['z'], np.array([self._buffer[0][2], + self._buffer[1][2]], dtype='u1')) + + +class TestReadValuesPlainSingle(ReadValuesPlain): + """Check the creation of heterogeneous arrays (plain, single row)""" + _descr = Pdescr + multiple_rows = 0 + _buffer = PbufferT[0] + +class TestReadValuesPlainMultiple(ReadValuesPlain): + """Check the values of heterogeneous arrays (plain, multiple rows)""" + _descr = Pdescr + multiple_rows = 1 + _buffer = PbufferT + +class ReadValuesNested: + """Check the reading of values in heterogeneous arrays (nested)""" + + def test_access_top_fields(self): + """Check reading the top fields of a nested array""" + h = np.array(self._buffer, dtype=self._descr) + if not self.multiple_rows: + assert_(h.shape == ()) + assert_equal(h['x'], np.array(self._buffer[0], dtype='i4')) + assert_equal(h['y'], np.array(self._buffer[4], dtype='f8')) + assert_equal(h['z'], np.array(self._buffer[5], dtype='u1')) + else: + assert_(len(h) == 2) + assert_equal(h['x'], np.array([self._buffer[0][0], + self._buffer[1][0]], dtype='i4')) + assert_equal(h['y'], np.array([self._buffer[0][4], + self._buffer[1][4]], dtype='f8')) + assert_equal(h['z'], np.array([self._buffer[0][5], + self._buffer[1][5]], dtype='u1')) + + def test_nested1_acessors(self): + """Check reading the nested fields of a nested array (1st level)""" + h = np.array(self._buffer, dtype=self._descr) + if not self.multiple_rows: + assert_equal(h['Info']['value'], + np.array(self._buffer[1][0], dtype='c16')) + assert_equal(h['Info']['y2'], + np.array(self._buffer[1][1], dtype='f8')) + assert_equal(h['info']['Name'], + np.array(self._buffer[3][0], dtype='U2')) + assert_equal(h['info']['Value'], + np.array(self._buffer[3][1], dtype='c16')) + else: + assert_equal(h['Info']['value'], + np.array([self._buffer[0][1][0], + self._buffer[1][1][0]], + dtype='c16')) + assert_equal(h['Info']['y2'], + np.array([self._buffer[0][1][1], + self._buffer[1][1][1]], + dtype='f8')) + assert_equal(h['info']['Name'], + np.array([self._buffer[0][3][0], + self._buffer[1][3][0]], + dtype='U2')) + assert_equal(h['info']['Value'], + np.array([self._buffer[0][3][1], + self._buffer[1][3][1]], + dtype='c16')) + + def test_nested2_acessors(self): + """Check reading the nested fields of a nested array (2nd level)""" + h = np.array(self._buffer, dtype=self._descr) + if not self.multiple_rows: + assert_equal(h['Info']['Info2']['value'], + np.array(self._buffer[1][2][1], dtype='c16')) + assert_equal(h['Info']['Info2']['z3'], + np.array(self._buffer[1][2][3], dtype='u4')) + else: + assert_equal(h['Info']['Info2']['value'], + np.array([self._buffer[0][1][2][1], + self._buffer[1][1][2][1]], + dtype='c16')) + assert_equal(h['Info']['Info2']['z3'], + np.array([self._buffer[0][1][2][3], + self._buffer[1][1][2][3]], + dtype='u4')) + + def test_nested1_descriptor(self): + """Check access nested descriptors of a nested array (1st level)""" + h = np.array(self._buffer, dtype=self._descr) + assert_(h.dtype['Info']['value'].name == 'complex128') + assert_(h.dtype['Info']['y2'].name == 'float64') + assert_(h.dtype['info']['Name'].name == 'str256') + assert_(h.dtype['info']['Value'].name == 'complex128') + + def test_nested2_descriptor(self): + """Check access nested descriptors of a nested array (2nd level)""" + h = np.array(self._buffer, dtype=self._descr) + assert_(h.dtype['Info']['Info2']['value'].name == 'void256') + assert_(h.dtype['Info']['Info2']['z3'].name == 'void64') + + +class TestReadValuesNestedSingle(ReadValuesNested): + """Check the values of heterogeneous arrays (nested, single row)""" + _descr = Ndescr + multiple_rows = False + _buffer = NbufferT[0] + +class TestReadValuesNestedMultiple(ReadValuesNested): + """Check the values of heterogeneous arrays (nested, multiple rows)""" + _descr = Ndescr + multiple_rows = True + _buffer = NbufferT + +class TestEmptyField: + def test_assign(self): + a = np.arange(10, dtype=np.float32) + a.dtype = [("int", "<0i4"), ("float", "<2f4")] + assert_(a['int'].shape == (5, 0)) + assert_(a['float'].shape == (5, 2)) + + +class TestMultipleFields: + def setup_method(self): + self.ary = np.array([(1, 2, 3, 4), (5, 6, 7, 8)], dtype='i4,f4,i2,c8') + + def _bad_call(self): + return self.ary['f0', 'f1'] + + def test_no_tuple(self): + assert_raises(IndexError, self._bad_call) + + def test_return(self): + res = self.ary[['f0', 'f2']].tolist() + assert_(res == [(1, 3), (5, 7)]) + + +class TestIsSubDType: + # scalar types can be promoted into dtypes + wrappers = [np.dtype, lambda x: x] + + def test_both_abstract(self): + assert_(np.issubdtype(np.floating, np.inexact)) + assert_(not np.issubdtype(np.inexact, np.floating)) + + def test_same(self): + for cls in (np.float32, np.int32): + for w1, w2 in itertools.product(self.wrappers, repeat=2): + assert_(np.issubdtype(w1(cls), w2(cls))) + + def test_subclass(self): + # note we cannot promote floating to a dtype, as it would turn into a + # concrete type + for w in self.wrappers: + assert_(np.issubdtype(w(np.float32), np.floating)) + assert_(np.issubdtype(w(np.float64), np.floating)) + + def test_subclass_backwards(self): + for w in self.wrappers: + assert_(not np.issubdtype(np.floating, w(np.float32))) + assert_(not np.issubdtype(np.floating, w(np.float64))) + + def test_sibling_class(self): + for w1, w2 in itertools.product(self.wrappers, repeat=2): + assert_(not np.issubdtype(w1(np.float32), w2(np.float64))) + assert_(not np.issubdtype(w1(np.float64), w2(np.float32))) + + def test_nondtype_nonscalartype(self): + # See gh-14619 and gh-9505 which introduced the deprecation to fix + # this. These tests are directly taken from gh-9505 + assert not np.issubdtype(np.float32, 'float64') + assert not np.issubdtype(np.float32, 'f8') + assert not np.issubdtype(np.int32, str) + assert not np.issubdtype(np.int32, 'int64') + assert not np.issubdtype(np.str_, 'void') + # for the following the correct spellings are + # np.integer, np.floating, or np.complexfloating respectively: + assert not np.issubdtype(np.int8, int) # np.int8 is never np.int_ + assert not np.issubdtype(np.float32, float) + assert not np.issubdtype(np.complex64, complex) + assert not np.issubdtype(np.float32, "float") + assert not np.issubdtype(np.float64, "f") + + # Test the same for the correct first datatype and abstract one + # in the case of int, float, complex: + assert np.issubdtype(np.float64, 'float64') + assert np.issubdtype(np.float64, 'f8') + assert np.issubdtype(np.str_, str) + assert np.issubdtype(np.int64, 'int64') + assert np.issubdtype(np.void, 'void') + assert np.issubdtype(np.int8, np.integer) + assert np.issubdtype(np.float32, np.floating) + assert np.issubdtype(np.complex64, np.complexfloating) + assert np.issubdtype(np.float64, "float") + assert np.issubdtype(np.float32, "f") + + +class TestIsDType: + """ + Check correctness of `np.isdtype`. The test considers different argument + configurations: `np.isdtype(dtype, k1)` and `np.isdtype(dtype, (k1, k2))` + with concrete dtypes and dtype groups. + """ + dtype_group_dict = { + "signed integer": sctypes["int"], + "unsigned integer": sctypes["uint"], + "integral": sctypes["int"] + sctypes["uint"], + "real floating": sctypes["float"], + "complex floating": sctypes["complex"], + "numeric": ( + sctypes["int"] + sctypes["uint"] + sctypes["float"] + + sctypes["complex"] + ) + } + + @pytest.mark.parametrize( + "dtype,close_dtype", + [ + (np.int64, np.int32), (np.uint64, np.uint32), + (np.float64, np.float32), (np.complex128, np.complex64) + ] + ) + @pytest.mark.parametrize( + "dtype_group", + [ + None, "signed integer", "unsigned integer", "integral", + "real floating", "complex floating", "numeric" + ] + ) + def test_isdtype(self, dtype, close_dtype, dtype_group): + # First check if same dtypes return `true` and different ones + # give `false` (even if they're close in the dtype hierarchy!) + if dtype_group is None: + assert np.isdtype(dtype, dtype) + assert not np.isdtype(dtype, close_dtype) + assert np.isdtype(dtype, (dtype, close_dtype)) + + # Check that dtype and a dtype group that it belongs to + # return `true`, and `false` otherwise. + elif dtype in self.dtype_group_dict[dtype_group]: + assert np.isdtype(dtype, dtype_group) + assert np.isdtype(dtype, (close_dtype, dtype_group)) + else: + assert not np.isdtype(dtype, dtype_group) + + def test_isdtype_invalid_args(self): + with assert_raises_regex(TypeError, r".*must be a NumPy dtype.*"): + np.isdtype("int64", np.int64) + with assert_raises_regex(TypeError, r".*kind argument must.*"): + np.isdtype(np.int64, 1) + with assert_raises_regex(ValueError, r".*not a known kind name.*"): + np.isdtype(np.int64, "int64") + + def test_sctypes_complete(self): + # issue 26439: int32/intc were masking each other on 32-bit builds + assert np.int32 in sctypes['int'] + assert np.intc in sctypes['int'] + assert np.int64 in sctypes['int'] + assert np.uint32 in sctypes['uint'] + assert np.uintc in sctypes['uint'] + assert np.uint64 in sctypes['uint'] + +class TestSctypeDict: + def test_longdouble(self): + assert_(np._core.sctypeDict['float64'] is not np.longdouble) + assert_(np._core.sctypeDict['complex128'] is not np.clongdouble) + + def test_ulong(self): + assert np._core.sctypeDict['ulong'] is np.ulong + assert np.dtype(np.ulong) is np.dtype("ulong") + assert np.dtype(np.ulong).itemsize == np.dtype(np.long).itemsize + + +@pytest.mark.filterwarnings("ignore:.*maximum_sctype.*:DeprecationWarning") +class TestMaximumSctype: + + # note that parametrizing with sctype['int'] and similar would skip types + # with the same size (gh-11923) + + @pytest.mark.parametrize( + 't', [np.byte, np.short, np.intc, np.long, np.longlong] + ) + def test_int(self, t): + assert_equal(maximum_sctype(t), np._core.sctypes['int'][-1]) + + @pytest.mark.parametrize( + 't', [np.ubyte, np.ushort, np.uintc, np.ulong, np.ulonglong] + ) + def test_uint(self, t): + assert_equal(maximum_sctype(t), np._core.sctypes['uint'][-1]) + + @pytest.mark.parametrize('t', [np.half, np.single, np.double, np.longdouble]) + def test_float(self, t): + assert_equal(maximum_sctype(t), np._core.sctypes['float'][-1]) + + @pytest.mark.parametrize('t', [np.csingle, np.cdouble, np.clongdouble]) + def test_complex(self, t): + assert_equal(maximum_sctype(t), np._core.sctypes['complex'][-1]) + + @pytest.mark.parametrize('t', [np.bool, np.object_, np.str_, np.bytes_, + np.void]) + def test_other(self, t): + assert_equal(maximum_sctype(t), t) + + +class Test_sctype2char: + # This function is old enough that we're really just documenting the quirks + # at this point. + + def test_scalar_type(self): + assert_equal(sctype2char(np.double), 'd') + assert_equal(sctype2char(np.long), 'l') + assert_equal(sctype2char(np.int_), np.array(0).dtype.char) + assert_equal(sctype2char(np.str_), 'U') + assert_equal(sctype2char(np.bytes_), 'S') + + def test_other_type(self): + assert_equal(sctype2char(float), 'd') + assert_equal(sctype2char(list), 'O') + assert_equal(sctype2char(np.ndarray), 'O') + + def test_third_party_scalar_type(self): + from numpy._core._rational_tests import rational + assert_raises(KeyError, sctype2char, rational) + assert_raises(KeyError, sctype2char, rational(1)) + + def test_array_instance(self): + assert_equal(sctype2char(np.array([1.0, 2.0])), 'd') + + def test_abstract_type(self): + assert_raises(KeyError, sctype2char, np.floating) + + def test_non_type(self): + assert_raises(ValueError, sctype2char, 1) + +@pytest.mark.parametrize("rep, expected", [ + (np.int32, True), + (list, False), + (1.1, False), + (str, True), + (np.dtype(np.float64), True), + (np.dtype((np.int16, (3, 4))), True), + (np.dtype([('a', np.int8)]), True), + ]) +def test_issctype(rep, expected): + # ensure proper identification of scalar + # data-types by issctype() + actual = issctype(rep) + assert type(actual) is bool + assert_equal(actual, expected) + + +@pytest.mark.skipif(sys.flags.optimize > 1, + reason="no docstrings present to inspect when PYTHONOPTIMIZE/Py_OptimizeFlag > 1") +@pytest.mark.xfail(IS_PYPY, + reason="PyPy cannot modify tp_doc after PyType_Ready") +class TestDocStrings: + def test_platform_dependent_aliases(self): + if np.int64 is np.int_: + assert_('int64' in np.int_.__doc__) + elif np.int64 is np.longlong: + assert_('int64' in np.longlong.__doc__) + + +class TestScalarTypeNames: + # gh-9799 + + numeric_types = [ + np.byte, np.short, np.intc, np.long, np.longlong, + np.ubyte, np.ushort, np.uintc, np.ulong, np.ulonglong, + np.half, np.single, np.double, np.longdouble, + np.csingle, np.cdouble, np.clongdouble, + ] + + def test_names_are_unique(self): + # none of the above may be aliases for each other + assert len(set(self.numeric_types)) == len(self.numeric_types) + + # names must be unique + names = [t.__name__ for t in self.numeric_types] + assert len(set(names)) == len(names) + + @pytest.mark.parametrize('t', numeric_types) + def test_names_reflect_attributes(self, t): + """ Test that names correspond to where the type is under ``np.`` """ + assert getattr(np, t.__name__) is t + + @pytest.mark.parametrize('t', numeric_types) + def test_names_are_undersood_by_dtype(self, t): + """ Test the dtype constructor maps names back to the type """ + assert np.dtype(t.__name__).type is t + + +class TestBoolDefinition: + def test_bool_definition(self): + assert nt.bool is np.bool diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/test_overrides.py b/venv/lib/python3.12/site-packages/numpy/_core/tests/test_overrides.py new file mode 100644 index 00000000..fabcaa10 --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/tests/test_overrides.py @@ -0,0 +1,747 @@ +import inspect +import sys +import os +import tempfile +from io import StringIO +from unittest import mock +import pickle + +import pytest + +import numpy as np +from numpy.testing import ( + assert_, assert_equal, assert_raises, assert_raises_regex) +from numpy._core.overrides import ( + _get_implementing_args, array_function_dispatch, + verify_matching_signatures) + + +def _return_not_implemented(self, *args, **kwargs): + return NotImplemented + + +# need to define this at the top level to test pickling +@array_function_dispatch(lambda array: (array,)) +def dispatched_one_arg(array): + """Docstring.""" + return 'original' + + +@array_function_dispatch(lambda array1, array2: (array1, array2)) +def dispatched_two_arg(array1, array2): + """Docstring.""" + return 'original' + + +class TestGetImplementingArgs: + + def test_ndarray(self): + array = np.array(1) + + args = _get_implementing_args([array]) + assert_equal(list(args), [array]) + + args = _get_implementing_args([array, array]) + assert_equal(list(args), [array]) + + args = _get_implementing_args([array, 1]) + assert_equal(list(args), [array]) + + args = _get_implementing_args([1, array]) + assert_equal(list(args), [array]) + + def test_ndarray_subclasses(self): + + class OverrideSub(np.ndarray): + __array_function__ = _return_not_implemented + + class NoOverrideSub(np.ndarray): + pass + + array = np.array(1).view(np.ndarray) + override_sub = np.array(1).view(OverrideSub) + no_override_sub = np.array(1).view(NoOverrideSub) + + args = _get_implementing_args([array, override_sub]) + assert_equal(list(args), [override_sub, array]) + + args = _get_implementing_args([array, no_override_sub]) + assert_equal(list(args), [no_override_sub, array]) + + args = _get_implementing_args( + [override_sub, no_override_sub]) + assert_equal(list(args), [override_sub, no_override_sub]) + + def test_ndarray_and_duck_array(self): + + class Other: + __array_function__ = _return_not_implemented + + array = np.array(1) + other = Other() + + args = _get_implementing_args([other, array]) + assert_equal(list(args), [other, array]) + + args = _get_implementing_args([array, other]) + assert_equal(list(args), [array, other]) + + def test_ndarray_subclass_and_duck_array(self): + + class OverrideSub(np.ndarray): + __array_function__ = _return_not_implemented + + class Other: + __array_function__ = _return_not_implemented + + array = np.array(1) + subarray = np.array(1).view(OverrideSub) + other = Other() + + assert_equal(_get_implementing_args([array, subarray, other]), + [subarray, array, other]) + assert_equal(_get_implementing_args([array, other, subarray]), + [subarray, array, other]) + + def test_many_duck_arrays(self): + + class A: + __array_function__ = _return_not_implemented + + class B(A): + __array_function__ = _return_not_implemented + + class C(A): + __array_function__ = _return_not_implemented + + class D: + __array_function__ = _return_not_implemented + + a = A() + b = B() + c = C() + d = D() + + assert_equal(_get_implementing_args([1]), []) + assert_equal(_get_implementing_args([a]), [a]) + assert_equal(_get_implementing_args([a, 1]), [a]) + assert_equal(_get_implementing_args([a, a, a]), [a]) + assert_equal(_get_implementing_args([a, d, a]), [a, d]) + assert_equal(_get_implementing_args([a, b]), [b, a]) + assert_equal(_get_implementing_args([b, a]), [b, a]) + assert_equal(_get_implementing_args([a, b, c]), [b, c, a]) + assert_equal(_get_implementing_args([a, c, b]), [c, b, a]) + + def test_too_many_duck_arrays(self): + namespace = dict(__array_function__=_return_not_implemented) + types = [type('A' + str(i), (object,), namespace) for i in range(65)] + relevant_args = [t() for t in types] + + actual = _get_implementing_args(relevant_args[:64]) + assert_equal(actual, relevant_args[:64]) + + with assert_raises_regex(TypeError, 'distinct argument types'): + _get_implementing_args(relevant_args) + + +class TestNDArrayArrayFunction: + + def test_method(self): + + class Other: + __array_function__ = _return_not_implemented + + class NoOverrideSub(np.ndarray): + pass + + class OverrideSub(np.ndarray): + __array_function__ = _return_not_implemented + + array = np.array([1]) + other = Other() + no_override_sub = array.view(NoOverrideSub) + override_sub = array.view(OverrideSub) + + result = array.__array_function__(func=dispatched_two_arg, + types=(np.ndarray,), + args=(array, 1.), kwargs={}) + assert_equal(result, 'original') + + result = array.__array_function__(func=dispatched_two_arg, + types=(np.ndarray, Other), + args=(array, other), kwargs={}) + assert_(result is NotImplemented) + + result = array.__array_function__(func=dispatched_two_arg, + types=(np.ndarray, NoOverrideSub), + args=(array, no_override_sub), + kwargs={}) + assert_equal(result, 'original') + + result = array.__array_function__(func=dispatched_two_arg, + types=(np.ndarray, OverrideSub), + args=(array, override_sub), + kwargs={}) + assert_equal(result, 'original') + + with assert_raises_regex(TypeError, 'no implementation found'): + np.concatenate((array, other)) + + expected = np.concatenate((array, array)) + result = np.concatenate((array, no_override_sub)) + assert_equal(result, expected.view(NoOverrideSub)) + result = np.concatenate((array, override_sub)) + assert_equal(result, expected.view(OverrideSub)) + + def test_no_wrapper(self): + # This shouldn't happen unless a user intentionally calls + # __array_function__ with invalid arguments, but check that we raise + # an appropriate error all the same. + array = np.array(1) + func = lambda x: x + with assert_raises_regex(AttributeError, '_implementation'): + array.__array_function__(func=func, types=(np.ndarray,), + args=(array,), kwargs={}) + + def test_wrong_arguments(self): + # Check our implementation guards against wrong arguments. + a = np.array([1, 2]) + with pytest.raises(TypeError, match="args must be a tuple"): + a.__array_function__(np.reshape, (np.ndarray,), a, (2, 1)) + with pytest.raises(TypeError, match="kwargs must be a dict"): + a.__array_function__(np.reshape, (np.ndarray,), (a,), (2, 1)) + + +class TestArrayFunctionDispatch: + + def test_pickle(self): + for proto in range(2, pickle.HIGHEST_PROTOCOL + 1): + roundtripped = pickle.loads( + pickle.dumps(dispatched_one_arg, protocol=proto)) + assert_(roundtripped is dispatched_one_arg) + + def test_name_and_docstring(self): + assert_equal(dispatched_one_arg.__name__, 'dispatched_one_arg') + if sys.flags.optimize < 2: + assert_equal(dispatched_one_arg.__doc__, 'Docstring.') + + def test_interface(self): + + class MyArray: + def __array_function__(self, func, types, args, kwargs): + return (self, func, types, args, kwargs) + + original = MyArray() + (obj, func, types, args, kwargs) = dispatched_one_arg(original) + assert_(obj is original) + assert_(func is dispatched_one_arg) + assert_equal(set(types), {MyArray}) + # assert_equal uses the overloaded np.iscomplexobj() internally + assert_(args == (original,)) + assert_equal(kwargs, {}) + + def test_not_implemented(self): + + class MyArray: + def __array_function__(self, func, types, args, kwargs): + return NotImplemented + + array = MyArray() + with assert_raises_regex(TypeError, 'no implementation found'): + dispatched_one_arg(array) + + def test_where_dispatch(self): + + class DuckArray: + def __array_function__(self, ufunc, method, *inputs, **kwargs): + return "overridden" + + array = np.array(1) + duck_array = DuckArray() + + result = np.std(array, where=duck_array) + + assert_equal(result, "overridden") + + +class TestVerifyMatchingSignatures: + + def test_verify_matching_signatures(self): + + verify_matching_signatures(lambda x: 0, lambda x: 0) + verify_matching_signatures(lambda x=None: 0, lambda x=None: 0) + verify_matching_signatures(lambda x=1: 0, lambda x=None: 0) + + with assert_raises(RuntimeError): + verify_matching_signatures(lambda a: 0, lambda b: 0) + with assert_raises(RuntimeError): + verify_matching_signatures(lambda x: 0, lambda x=None: 0) + with assert_raises(RuntimeError): + verify_matching_signatures(lambda x=None: 0, lambda y=None: 0) + with assert_raises(RuntimeError): + verify_matching_signatures(lambda x=1: 0, lambda y=1: 0) + + def test_array_function_dispatch(self): + + with assert_raises(RuntimeError): + @array_function_dispatch(lambda x: (x,)) + def f(y): + pass + + # should not raise + @array_function_dispatch(lambda x: (x,), verify=False) + def f(y): + pass + + +def _new_duck_type_and_implements(): + """Create a duck array type and implements functions.""" + HANDLED_FUNCTIONS = {} + + class MyArray: + def __array_function__(self, func, types, args, kwargs): + if func not in HANDLED_FUNCTIONS: + return NotImplemented + if not all(issubclass(t, MyArray) for t in types): + return NotImplemented + return HANDLED_FUNCTIONS[func](*args, **kwargs) + + def implements(numpy_function): + """Register an __array_function__ implementations.""" + def decorator(func): + HANDLED_FUNCTIONS[numpy_function] = func + return func + return decorator + + return (MyArray, implements) + + +class TestArrayFunctionImplementation: + + def test_one_arg(self): + MyArray, implements = _new_duck_type_and_implements() + + @implements(dispatched_one_arg) + def _(array): + return 'myarray' + + assert_equal(dispatched_one_arg(1), 'original') + assert_equal(dispatched_one_arg(MyArray()), 'myarray') + + def test_optional_args(self): + MyArray, implements = _new_duck_type_and_implements() + + @array_function_dispatch(lambda array, option=None: (array,)) + def func_with_option(array, option='default'): + return option + + @implements(func_with_option) + def my_array_func_with_option(array, new_option='myarray'): + return new_option + + # we don't need to implement every option on __array_function__ + # implementations + assert_equal(func_with_option(1), 'default') + assert_equal(func_with_option(1, option='extra'), 'extra') + assert_equal(func_with_option(MyArray()), 'myarray') + with assert_raises(TypeError): + func_with_option(MyArray(), option='extra') + + # but new options on implementations can't be used + result = my_array_func_with_option(MyArray(), new_option='yes') + assert_equal(result, 'yes') + with assert_raises(TypeError): + func_with_option(MyArray(), new_option='no') + + def test_not_implemented(self): + MyArray, implements = _new_duck_type_and_implements() + + @array_function_dispatch(lambda array: (array,), module='my') + def func(array): + return array + + array = np.array(1) + assert_(func(array) is array) + assert_equal(func.__module__, 'my') + + with assert_raises_regex( + TypeError, "no implementation found for 'my.func'"): + func(MyArray()) + + @pytest.mark.parametrize("name", ["concatenate", "mean", "asarray"]) + def test_signature_error_message_simple(self, name): + func = getattr(np, name) + try: + # all of these functions need an argument: + func() + except TypeError as e: + exc = e + + assert exc.args[0].startswith(f"{name}()") + + def test_signature_error_message(self): + # The lambda function will be named "", but the TypeError + # should show the name as "func" + def _dispatcher(): + return () + + @array_function_dispatch(_dispatcher) + def func(): + pass + + try: + func._implementation(bad_arg=3) + except TypeError as e: + expected_exception = e + + try: + func(bad_arg=3) + raise AssertionError("must fail") + except TypeError as exc: + if exc.args[0].startswith("_dispatcher"): + # We replace the qualname currently, but it used `__name__` + # (relevant functions have the same name and qualname anyway) + pytest.skip("Python version is not using __qualname__ for " + "TypeError formatting.") + + assert exc.args == expected_exception.args + + @pytest.mark.parametrize("value", [234, "this func is not replaced"]) + def test_dispatcher_error(self, value): + # If the dispatcher raises an error, we must not attempt to mutate it + error = TypeError(value) + + def dispatcher(): + raise error + + @array_function_dispatch(dispatcher) + def func(): + return 3 + + try: + func() + raise AssertionError("must fail") + except TypeError as exc: + assert exc is error # unmodified exception + + def test_properties(self): + # Check that str and repr are sensible + func = dispatched_two_arg + assert str(func) == str(func._implementation) + repr_no_id = repr(func).split("at ")[0] + repr_no_id_impl = repr(func._implementation).split("at ")[0] + assert repr_no_id == repr_no_id_impl + + @pytest.mark.parametrize("func", [ + lambda x, y: 0, # no like argument + lambda like=None: 0, # not keyword only + lambda *, like=None, a=3: 0, # not last (not that it matters) + ]) + def test_bad_like_sig(self, func): + # We sanity check the signature, and these should fail. + with pytest.raises(RuntimeError): + array_function_dispatch()(func) + + def test_bad_like_passing(self): + # Cover internal sanity check for passing like as first positional arg + def func(*, like=None): + pass + + func_with_like = array_function_dispatch()(func) + with pytest.raises(TypeError): + func_with_like() + with pytest.raises(TypeError): + func_with_like(like=234) + + def test_too_many_args(self): + # Mainly a unit-test to increase coverage + objs = [] + for i in range(80): + class MyArr: + def __array_function__(self, *args, **kwargs): + return NotImplemented + + objs.append(MyArr()) + + def _dispatch(*args): + return args + + @array_function_dispatch(_dispatch) + def func(*args): + pass + + with pytest.raises(TypeError, match="maximum number"): + func(*objs) + + + +class TestNDArrayMethods: + + def test_repr(self): + # gh-12162: should still be defined even if __array_function__ doesn't + # implement np.array_repr() + + class MyArray(np.ndarray): + def __array_function__(*args, **kwargs): + return NotImplemented + + array = np.array(1).view(MyArray) + assert_equal(repr(array), 'MyArray(1)') + assert_equal(str(array), '1') + + +class TestNumPyFunctions: + + def test_set_module(self): + assert_equal(np.sum.__module__, 'numpy') + assert_equal(np.char.equal.__module__, 'numpy.char') + assert_equal(np.fft.fft.__module__, 'numpy.fft') + assert_equal(np.linalg.solve.__module__, 'numpy.linalg') + + def test_inspect_sum(self): + signature = inspect.signature(np.sum) + assert_('axis' in signature.parameters) + + def test_override_sum(self): + MyArray, implements = _new_duck_type_and_implements() + + @implements(np.sum) + def _(array): + return 'yes' + + assert_equal(np.sum(MyArray()), 'yes') + + def test_sum_on_mock_array(self): + + # We need a proxy for mocks because __array_function__ is only looked + # up in the class dict + class ArrayProxy: + def __init__(self, value): + self.value = value + def __array_function__(self, *args, **kwargs): + return self.value.__array_function__(*args, **kwargs) + def __array__(self, *args, **kwargs): + return self.value.__array__(*args, **kwargs) + + proxy = ArrayProxy(mock.Mock(spec=ArrayProxy)) + proxy.value.__array_function__.return_value = 1 + result = np.sum(proxy) + assert_equal(result, 1) + proxy.value.__array_function__.assert_called_once_with( + np.sum, (ArrayProxy,), (proxy,), {}) + proxy.value.__array__.assert_not_called() + + def test_sum_forwarding_implementation(self): + + class MyArray(np.ndarray): + + def sum(self, axis, out): + return 'summed' + + def __array_function__(self, func, types, args, kwargs): + return super().__array_function__(func, types, args, kwargs) + + # note: the internal implementation of np.sum() calls the .sum() method + array = np.array(1).view(MyArray) + assert_equal(np.sum(array), 'summed') + + +class TestArrayLike: + def setup_method(self): + class MyArray: + def __init__(self, function=None): + self.function = function + + def __array_function__(self, func, types, args, kwargs): + assert func is getattr(np, func.__name__) + try: + my_func = getattr(self, func.__name__) + except AttributeError: + return NotImplemented + return my_func(*args, **kwargs) + + self.MyArray = MyArray + + class MyNoArrayFunctionArray: + def __init__(self, function=None): + self.function = function + + self.MyNoArrayFunctionArray = MyNoArrayFunctionArray + + def add_method(self, name, arr_class, enable_value_error=False): + def _definition(*args, **kwargs): + # Check that `like=` isn't propagated downstream + assert 'like' not in kwargs + + if enable_value_error and 'value_error' in kwargs: + raise ValueError + + return arr_class(getattr(arr_class, name)) + setattr(arr_class, name, _definition) + + def func_args(*args, **kwargs): + return args, kwargs + + def test_array_like_not_implemented(self): + self.add_method('array', self.MyArray) + + ref = self.MyArray.array() + + with assert_raises_regex(TypeError, 'no implementation found'): + array_like = np.asarray(1, like=ref) + + _array_tests = [ + ('array', *func_args((1,))), + ('asarray', *func_args((1,))), + ('asanyarray', *func_args((1,))), + ('ascontiguousarray', *func_args((2, 3))), + ('asfortranarray', *func_args((2, 3))), + ('require', *func_args((np.arange(6).reshape(2, 3),), + requirements=['A', 'F'])), + ('empty', *func_args((1,))), + ('full', *func_args((1,), 2)), + ('ones', *func_args((1,))), + ('zeros', *func_args((1,))), + ('arange', *func_args(3)), + ('frombuffer', *func_args(b'\x00' * 8, dtype=int)), + ('fromiter', *func_args(range(3), dtype=int)), + ('fromstring', *func_args('1,2', dtype=int, sep=',')), + ('loadtxt', *func_args(lambda: StringIO('0 1\n2 3'))), + ('genfromtxt', *func_args(lambda: StringIO('1,2.1'), + dtype=[('int', 'i8'), ('float', 'f8')], + delimiter=',')), + ] + + @pytest.mark.parametrize('function, args, kwargs', _array_tests) + @pytest.mark.parametrize('numpy_ref', [True, False]) + def test_array_like(self, function, args, kwargs, numpy_ref): + self.add_method('array', self.MyArray) + self.add_method(function, self.MyArray) + np_func = getattr(np, function) + my_func = getattr(self.MyArray, function) + + if numpy_ref is True: + ref = np.array(1) + else: + ref = self.MyArray.array() + + like_args = tuple(a() if callable(a) else a for a in args) + array_like = np_func(*like_args, **kwargs, like=ref) + + if numpy_ref is True: + assert type(array_like) is np.ndarray + + np_args = tuple(a() if callable(a) else a for a in args) + np_arr = np_func(*np_args, **kwargs) + + # Special-case np.empty to ensure values match + if function == "empty": + np_arr.fill(1) + array_like.fill(1) + + assert_equal(array_like, np_arr) + else: + assert type(array_like) is self.MyArray + assert array_like.function is my_func + + @pytest.mark.parametrize('function, args, kwargs', _array_tests) + @pytest.mark.parametrize('ref', [1, [1], "MyNoArrayFunctionArray"]) + def test_no_array_function_like(self, function, args, kwargs, ref): + self.add_method('array', self.MyNoArrayFunctionArray) + self.add_method(function, self.MyNoArrayFunctionArray) + np_func = getattr(np, function) + + # Instantiate ref if it's the MyNoArrayFunctionArray class + if ref == "MyNoArrayFunctionArray": + ref = self.MyNoArrayFunctionArray.array() + + like_args = tuple(a() if callable(a) else a for a in args) + + with assert_raises_regex(TypeError, + 'The `like` argument must be an array-like that implements'): + np_func(*like_args, **kwargs, like=ref) + + @pytest.mark.parametrize('numpy_ref', [True, False]) + def test_array_like_fromfile(self, numpy_ref): + self.add_method('array', self.MyArray) + self.add_method("fromfile", self.MyArray) + + if numpy_ref is True: + ref = np.array(1) + else: + ref = self.MyArray.array() + + data = np.random.random(5) + + with tempfile.TemporaryDirectory() as tmpdir: + fname = os.path.join(tmpdir, "testfile") + data.tofile(fname) + + array_like = np.fromfile(fname, like=ref) + if numpy_ref is True: + assert type(array_like) is np.ndarray + np_res = np.fromfile(fname, like=ref) + assert_equal(np_res, data) + assert_equal(array_like, np_res) + else: + assert type(array_like) is self.MyArray + assert array_like.function is self.MyArray.fromfile + + def test_exception_handling(self): + self.add_method('array', self.MyArray, enable_value_error=True) + + ref = self.MyArray.array() + + with assert_raises(TypeError): + # Raises the error about `value_error` being invalid first + np.array(1, value_error=True, like=ref) + + @pytest.mark.parametrize('function, args, kwargs', _array_tests) + def test_like_as_none(self, function, args, kwargs): + self.add_method('array', self.MyArray) + self.add_method(function, self.MyArray) + np_func = getattr(np, function) + + like_args = tuple(a() if callable(a) else a for a in args) + # required for loadtxt and genfromtxt to init w/o error. + like_args_exp = tuple(a() if callable(a) else a for a in args) + + array_like = np_func(*like_args, **kwargs, like=None) + expected = np_func(*like_args_exp, **kwargs) + # Special-case np.empty to ensure values match + if function == "empty": + array_like.fill(1) + expected.fill(1) + assert_equal(array_like, expected) + + +def test_function_like(): + # We provide a `__get__` implementation, make sure it works + assert type(np.mean) is np._core._multiarray_umath._ArrayFunctionDispatcher + + class MyClass: + def __array__(self, dtype=None, copy=None): + # valid argument to mean: + return np.arange(3) + + func1 = staticmethod(np.mean) + func2 = np.mean + func3 = classmethod(np.mean) + + m = MyClass() + assert m.func1([10]) == 10 + assert m.func2() == 1 # mean of the arange + with pytest.raises(TypeError, match="unsupported operand type"): + # Tries to operate on the class + m.func3() + + # Manual binding also works (the above may shortcut): + bound = np.mean.__get__(m, MyClass) + assert bound() == 1 + + bound = np.mean.__get__(None, MyClass) # unbound actually + assert bound([10]) == 10 + + bound = np.mean.__get__(MyClass) # classmethod + with pytest.raises(TypeError, match="unsupported operand type"): + bound() diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/test_print.py b/venv/lib/python3.12/site-packages/numpy/_core/tests/test_print.py new file mode 100644 index 00000000..7f164497 --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/tests/test_print.py @@ -0,0 +1,202 @@ +import sys + +import pytest + +import numpy as np +from numpy.testing import assert_, assert_equal, IS_MUSL +from numpy._core.tests._locales import CommaDecimalPointLocale + + +from io import StringIO + +_REF = {np.inf: 'inf', -np.inf: '-inf', np.nan: 'nan'} + + +@pytest.mark.parametrize('tp', [np.float32, np.double, np.longdouble]) +def test_float_types(tp): + """ Check formatting. + + This is only for the str function, and only for simple types. + The precision of np.float32 and np.longdouble aren't the same as the + python float precision. + + """ + for x in [0, 1, -1, 1e20]: + assert_equal(str(tp(x)), str(float(x)), + err_msg='Failed str formatting for type %s' % tp) + + if tp(1e16).itemsize > 4: + assert_equal(str(tp(1e16)), str(float('1e16')), + err_msg='Failed str formatting for type %s' % tp) + else: + ref = '1e+16' + assert_equal(str(tp(1e16)), ref, + err_msg='Failed str formatting for type %s' % tp) + + +@pytest.mark.parametrize('tp', [np.float32, np.double, np.longdouble]) +def test_nan_inf_float(tp): + """ Check formatting of nan & inf. + + This is only for the str function, and only for simple types. + The precision of np.float32 and np.longdouble aren't the same as the + python float precision. + + """ + for x in [np.inf, -np.inf, np.nan]: + assert_equal(str(tp(x)), _REF[x], + err_msg='Failed str formatting for type %s' % tp) + + +@pytest.mark.parametrize('tp', [np.complex64, np.cdouble, np.clongdouble]) +def test_complex_types(tp): + """Check formatting of complex types. + + This is only for the str function, and only for simple types. + The precision of np.float32 and np.longdouble aren't the same as the + python float precision. + + """ + for x in [0, 1, -1, 1e20]: + assert_equal(str(tp(x)), str(complex(x)), + err_msg='Failed str formatting for type %s' % tp) + assert_equal(str(tp(x*1j)), str(complex(x*1j)), + err_msg='Failed str formatting for type %s' % tp) + assert_equal(str(tp(x + x*1j)), str(complex(x + x*1j)), + err_msg='Failed str formatting for type %s' % tp) + + if tp(1e16).itemsize > 8: + assert_equal(str(tp(1e16)), str(complex(1e16)), + err_msg='Failed str formatting for type %s' % tp) + else: + ref = '(1e+16+0j)' + assert_equal(str(tp(1e16)), ref, + err_msg='Failed str formatting for type %s' % tp) + + +@pytest.mark.parametrize('dtype', [np.complex64, np.cdouble, np.clongdouble]) +def test_complex_inf_nan(dtype): + """Check inf/nan formatting of complex types.""" + TESTS = { + complex(np.inf, 0): "(inf+0j)", + complex(0, np.inf): "infj", + complex(-np.inf, 0): "(-inf+0j)", + complex(0, -np.inf): "-infj", + complex(np.inf, 1): "(inf+1j)", + complex(1, np.inf): "(1+infj)", + complex(-np.inf, 1): "(-inf+1j)", + complex(1, -np.inf): "(1-infj)", + complex(np.nan, 0): "(nan+0j)", + complex(0, np.nan): "nanj", + complex(-np.nan, 0): "(nan+0j)", + complex(0, -np.nan): "nanj", + complex(np.nan, 1): "(nan+1j)", + complex(1, np.nan): "(1+nanj)", + complex(-np.nan, 1): "(nan+1j)", + complex(1, -np.nan): "(1+nanj)", + } + for c, s in TESTS.items(): + assert_equal(str(dtype(c)), s) + + +# print tests +def _test_redirected_print(x, tp, ref=None): + file = StringIO() + file_tp = StringIO() + stdout = sys.stdout + try: + sys.stdout = file_tp + print(tp(x)) + sys.stdout = file + if ref: + print(ref) + else: + print(x) + finally: + sys.stdout = stdout + + assert_equal(file.getvalue(), file_tp.getvalue(), + err_msg='print failed for type%s' % tp) + + +@pytest.mark.parametrize('tp', [np.float32, np.double, np.longdouble]) +def test_float_type_print(tp): + """Check formatting when using print """ + for x in [0, 1, -1, 1e20]: + _test_redirected_print(float(x), tp) + + for x in [np.inf, -np.inf, np.nan]: + _test_redirected_print(float(x), tp, _REF[x]) + + if tp(1e16).itemsize > 4: + _test_redirected_print(float(1e16), tp) + else: + ref = '1e+16' + _test_redirected_print(float(1e16), tp, ref) + + +@pytest.mark.parametrize('tp', [np.complex64, np.cdouble, np.clongdouble]) +def test_complex_type_print(tp): + """Check formatting when using print """ + # We do not create complex with inf/nan directly because the feature is + # missing in python < 2.6 + for x in [0, 1, -1, 1e20]: + _test_redirected_print(complex(x), tp) + + if tp(1e16).itemsize > 8: + _test_redirected_print(complex(1e16), tp) + else: + ref = '(1e+16+0j)' + _test_redirected_print(complex(1e16), tp, ref) + + _test_redirected_print(complex(np.inf, 1), tp, '(inf+1j)') + _test_redirected_print(complex(-np.inf, 1), tp, '(-inf+1j)') + _test_redirected_print(complex(-np.nan, 1), tp, '(nan+1j)') + + +def test_scalar_format(): + """Test the str.format method with NumPy scalar types""" + tests = [('{0}', True, np.bool), + ('{0}', False, np.bool), + ('{0:d}', 130, np.uint8), + ('{0:d}', 50000, np.uint16), + ('{0:d}', 3000000000, np.uint32), + ('{0:d}', 15000000000000000000, np.uint64), + ('{0:d}', -120, np.int8), + ('{0:d}', -30000, np.int16), + ('{0:d}', -2000000000, np.int32), + ('{0:d}', -7000000000000000000, np.int64), + ('{0:g}', 1.5, np.float16), + ('{0:g}', 1.5, np.float32), + ('{0:g}', 1.5, np.float64), + ('{0:g}', 1.5, np.longdouble), + ('{0:g}', 1.5+0.5j, np.complex64), + ('{0:g}', 1.5+0.5j, np.complex128), + ('{0:g}', 1.5+0.5j, np.clongdouble)] + + for (fmat, val, valtype) in tests: + try: + assert_equal(fmat.format(val), fmat.format(valtype(val)), + "failed with val %s, type %s" % (val, valtype)) + except ValueError as e: + assert_(False, + "format raised exception (fmt='%s', val=%s, type=%s, exc='%s')" % + (fmat, repr(val), repr(valtype), str(e))) + + +# +# Locale tests: scalar types formatting should be independent of the locale +# + +class TestCommaDecimalPointLocale(CommaDecimalPointLocale): + + def test_locale_single(self): + assert_equal(str(np.float32(1.2)), str(float(1.2))) + + def test_locale_double(self): + assert_equal(str(np.double(1.2)), str(float(1.2))) + + @pytest.mark.skipif(IS_MUSL, + reason="test flaky on musllinux") + def test_locale_longdouble(self): + assert_equal(str(np.longdouble('1.2')), str(float(1.2))) diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/test_protocols.py b/venv/lib/python3.12/site-packages/numpy/_core/tests/test_protocols.py new file mode 100644 index 00000000..1709629f --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/tests/test_protocols.py @@ -0,0 +1,45 @@ +import pytest +import warnings +import numpy as np + + +@pytest.mark.filterwarnings("error") +def test_getattr_warning(): + # issue gh-14735: make sure we clear only getattr errors, and let warnings + # through + class Wrapper: + def __init__(self, array): + self.array = array + + def __len__(self): + return len(self.array) + + def __getitem__(self, item): + return type(self)(self.array[item]) + + def __getattr__(self, name): + if name.startswith("__array_"): + warnings.warn("object got converted", UserWarning, stacklevel=1) + + return getattr(self.array, name) + + def __repr__(self): + return "".format(self=self) + + array = Wrapper(np.arange(10)) + with pytest.raises(UserWarning, match="object got converted"): + np.asarray(array) + + +def test_array_called(): + class Wrapper: + val = '0' * 100 + + def __array__(self, dtype=None, copy=None): + return np.array([self.val], dtype=dtype, copy=copy) + + + wrapped = Wrapper() + arr = np.array(wrapped, dtype=str) + assert arr.dtype == 'U100' + assert arr[0] == Wrapper.val diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/test_records.py b/venv/lib/python3.12/site-packages/numpy/_core/tests/test_records.py new file mode 100644 index 00000000..151fa4e6 --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/tests/test_records.py @@ -0,0 +1,540 @@ +import collections.abc +import textwrap +from io import BytesIO +from os import path +from pathlib import Path +import pickle + +import pytest + +import numpy as np +from numpy.testing import ( + assert_, assert_equal, assert_array_equal, assert_array_almost_equal, + assert_raises, temppath, + ) + + +class TestFromrecords: + def test_fromrecords(self): + r = np.rec.fromrecords([[456, 'dbe', 1.2], [2, 'de', 1.3]], + names='col1,col2,col3') + assert_equal(r[0].item(), (456, 'dbe', 1.2)) + assert_equal(r['col1'].dtype.kind, 'i') + assert_equal(r['col2'].dtype.kind, 'U') + assert_equal(r['col2'].dtype.itemsize, 12) + assert_equal(r['col3'].dtype.kind, 'f') + + def test_fromrecords_0len(self): + """ Verify fromrecords works with a 0-length input """ + dtype = [('a', float), ('b', float)] + r = np.rec.fromrecords([], dtype=dtype) + assert_equal(r.shape, (0,)) + + def test_fromrecords_2d(self): + data = [ + [(1, 2), (3, 4), (5, 6)], + [(6, 5), (4, 3), (2, 1)] + ] + expected_a = [[1, 3, 5], [6, 4, 2]] + expected_b = [[2, 4, 6], [5, 3, 1]] + + # try with dtype + r1 = np.rec.fromrecords(data, dtype=[('a', int), ('b', int)]) + assert_equal(r1['a'], expected_a) + assert_equal(r1['b'], expected_b) + + # try with names + r2 = np.rec.fromrecords(data, names=['a', 'b']) + assert_equal(r2['a'], expected_a) + assert_equal(r2['b'], expected_b) + + assert_equal(r1, r2) + + def test_method_array(self): + r = np.rec.array( + b'abcdefg' * 100, formats='i2,S3,i4', shape=3, byteorder='big' + ) + assert_equal(r[1].item(), (25444, b'efg', 1633837924)) + + def test_method_array2(self): + r = np.rec.array( + [ + (1, 11, 'a'), (2, 22, 'b'), (3, 33, 'c'), (4, 44, 'd'), + (5, 55, 'ex'), (6, 66, 'f'), (7, 77, 'g') + ], + formats='u1,f4,S1' + ) + assert_equal(r[1].item(), (2, 22.0, b'b')) + + def test_recarray_slices(self): + r = np.rec.array( + [ + (1, 11, 'a'), (2, 22, 'b'), (3, 33, 'c'), (4, 44, 'd'), + (5, 55, 'ex'), (6, 66, 'f'), (7, 77, 'g') + ], + formats='u1,f4,S1' + ) + assert_equal(r[1::2][1].item(), (4, 44.0, b'd')) + + def test_recarray_fromarrays(self): + x1 = np.array([1, 2, 3, 4]) + x2 = np.array(['a', 'dd', 'xyz', '12']) + x3 = np.array([1.1, 2, 3, 4]) + r = np.rec.fromarrays([x1, x2, x3], names='a,b,c') + assert_equal(r[1].item(), (2, 'dd', 2.0)) + x1[1] = 34 + assert_equal(r.a, np.array([1, 2, 3, 4])) + + def test_recarray_fromfile(self): + data_dir = path.join(path.dirname(__file__), 'data') + filename = path.join(data_dir, 'recarray_from_file.fits') + fd = open(filename, 'rb') + fd.seek(2880 * 2) + r1 = np.rec.fromfile(fd, formats='f8,i4,S5', shape=3, byteorder='big') + fd.seek(2880 * 2) + r2 = np.rec.array(fd, formats='f8,i4,S5', shape=3, byteorder='big') + fd.seek(2880 * 2) + bytes_array = BytesIO() + bytes_array.write(fd.read()) + bytes_array.seek(0) + r3 = np.rec.fromfile( + bytes_array, formats='f8,i4,S5', shape=3, byteorder='big' + ) + fd.close() + assert_equal(r1, r2) + assert_equal(r2, r3) + + def test_recarray_from_obj(self): + count = 10 + a = np.zeros(count, dtype='O') + b = np.zeros(count, dtype='f8') + c = np.zeros(count, dtype='f8') + for i in range(len(a)): + a[i] = list(range(1, 10)) + + mine = np.rec.fromarrays([a, b, c], names='date,data1,data2') + for i in range(len(a)): + assert_(mine.date[i] == list(range(1, 10))) + assert_(mine.data1[i] == 0.0) + assert_(mine.data2[i] == 0.0) + + def test_recarray_repr(self): + a = np.array([(1, 0.1), (2, 0.2)], + dtype=[('foo', ' 2) & (a < 6)) + xb = np.where((b > 2) & (b < 6)) + ya = ((a > 2) & (a < 6)) + yb = ((b > 2) & (b < 6)) + assert_array_almost_equal(xa, ya.nonzero()) + assert_array_almost_equal(xb, yb.nonzero()) + assert_(np.all(a[ya] > 0.5)) + assert_(np.all(b[yb] > 0.5)) + + def test_endian_where(self): + # GitHub issue #369 + net = np.zeros(3, dtype='>f4') + net[1] = 0.00458849 + net[2] = 0.605202 + max_net = net.max() + test = np.where(net <= 0., max_net, net) + correct = np.array([ 0.60520202, 0.00458849, 0.60520202]) + assert_array_almost_equal(test, correct) + + def test_endian_recarray(self): + # Ticket #2185 + dt = np.dtype([ + ('head', '>u4'), + ('data', '>u4', 2), + ]) + buf = np.recarray(1, dtype=dt) + buf[0]['head'] = 1 + buf[0]['data'][:] = [1, 1] + + h = buf[0]['head'] + d = buf[0]['data'][0] + buf[0]['head'] = h + buf[0]['data'][0] = d + assert_(buf[0]['head'] == 1) + + def test_mem_dot(self): + # Ticket #106 + x = np.random.randn(0, 1) + y = np.random.randn(10, 1) + # Dummy array to detect bad memory access: + _z = np.ones(10) + _dummy = np.empty((0, 10)) + z = np.lib.stride_tricks.as_strided(_z, _dummy.shape, _dummy.strides) + np.dot(x, np.transpose(y), out=z) + assert_equal(_z, np.ones(10)) + # Do the same for the built-in dot: + np._core.multiarray.dot(x, np.transpose(y), out=z) + assert_equal(_z, np.ones(10)) + + def test_arange_endian(self): + # Ticket #111 + ref = np.arange(10) + x = np.arange(10, dtype=' 1 and x['two'] > 2) + + def test_method_args(self): + # Make sure methods and functions have same default axis + # keyword and arguments + funcs1 = ['argmax', 'argmin', 'sum', 'any', 'all', 'cumsum', + 'cumprod', 'prod', 'std', 'var', 'mean', + 'round', 'min', 'max', 'argsort', 'sort'] + funcs2 = ['compress', 'take', 'repeat'] + + for func in funcs1: + arr = np.random.rand(8, 7) + arr2 = arr.copy() + res1 = getattr(arr, func)() + res2 = getattr(np, func)(arr2) + if res1 is None: + res1 = arr + + if res1.dtype.kind in 'uib': + assert_((res1 == res2).all(), func) + else: + assert_(abs(res1-res2).max() < 1e-8, func) + + for func in funcs2: + arr1 = np.random.rand(8, 7) + arr2 = np.random.rand(8, 7) + res1 = None + if func == 'compress': + arr1 = arr1.ravel() + res1 = getattr(arr2, func)(arr1) + else: + arr2 = (15*arr2).astype(int).ravel() + if res1 is None: + res1 = getattr(arr1, func)(arr2) + res2 = getattr(np, func)(arr1, arr2) + assert_(abs(res1-res2).max() < 1e-8, func) + + def test_mem_lexsort_strings(self): + # Ticket #298 + lst = ['abc', 'cde', 'fgh'] + np.lexsort((lst,)) + + def test_fancy_index(self): + # Ticket #302 + x = np.array([1, 2])[np.array([0])] + assert_equal(x.shape, (1,)) + + def test_recarray_copy(self): + # Ticket #312 + dt = [('x', np.int16), ('y', np.float64)] + ra = np.array([(1, 2.3)], dtype=dt) + rb = np.rec.array(ra, dtype=dt) + rb['x'] = 2. + assert_(ra['x'] != rb['x']) + + def test_rec_fromarray(self): + # Ticket #322 + x1 = np.array([[1, 2], [3, 4], [5, 6]]) + x2 = np.array(['a', 'dd', 'xyz']) + x3 = np.array([1.1, 2, 3]) + np.rec.fromarrays([x1, x2, x3], formats="(2,)i4,S3,f8") + + def test_object_array_assign(self): + x = np.empty((2, 2), object) + x.flat[2] = (1, 2, 3) + assert_equal(x.flat[2], (1, 2, 3)) + + def test_ndmin_float64(self): + # Ticket #324 + x = np.array([1, 2, 3], dtype=np.float64) + assert_equal(np.array(x, dtype=np.float32, ndmin=2).ndim, 2) + assert_equal(np.array(x, dtype=np.float64, ndmin=2).ndim, 2) + + def test_ndmin_order(self): + # Issue #465 and related checks + assert_(np.array([1, 2], order='C', ndmin=3).flags.c_contiguous) + assert_(np.array([1, 2], order='F', ndmin=3).flags.f_contiguous) + assert_(np.array(np.ones((2, 2), order='F'), ndmin=3).flags.f_contiguous) + assert_(np.array(np.ones((2, 2), order='C'), ndmin=3).flags.c_contiguous) + + def test_mem_axis_minimization(self): + # Ticket #327 + data = np.arange(5) + data = np.add.outer(data, data) + + def test_mem_float_imag(self): + # Ticket #330 + np.float64(1.0).imag + + def test_dtype_tuple(self): + # Ticket #334 + assert_(np.dtype('i4') == np.dtype(('i4', ()))) + + def test_dtype_posttuple(self): + # Ticket #335 + np.dtype([('col1', '()i4')]) + + def test_numeric_carray_compare(self): + # Ticket #341 + assert_equal(np.array(['X'], 'c'), b'X') + + def test_string_array_size(self): + # Ticket #342 + assert_raises(ValueError, + np.array, [['X'], ['X', 'X', 'X']], '|S1') + + def test_dtype_repr(self): + # Ticket #344 + dt1 = np.dtype(('uint32', 2)) + dt2 = np.dtype(('uint32', (2,))) + assert_equal(dt1.__repr__(), dt2.__repr__()) + + def test_reshape_order(self): + # Make sure reshape order works. + a = np.arange(6).reshape(2, 3, order='F') + assert_equal(a, [[0, 2, 4], [1, 3, 5]]) + a = np.array([[1, 2], [3, 4], [5, 6], [7, 8]]) + b = a[:, 1] + assert_equal(b.reshape(2, 2, order='F'), [[2, 6], [4, 8]]) + + def test_reshape_zero_strides(self): + # Issue #380, test reshaping of zero strided arrays + a = np.ones(1) + a = np.lib.stride_tricks.as_strided(a, shape=(5,), strides=(0,)) + assert_(a.reshape(5, 1).strides[0] == 0) + + def test_reshape_zero_size(self): + # GitHub Issue #2700, setting shape failed for 0-sized arrays + a = np.ones((0, 2)) + a.shape = (-1, 2) + + def test_reshape_trailing_ones_strides(self): + # GitHub issue gh-2949, bad strides for trailing ones of new shape + a = np.zeros(12, dtype=np.int32)[::2] # not contiguous + strides_c = (16, 8, 8, 8) + strides_f = (8, 24, 48, 48) + assert_equal(a.reshape(3, 2, 1, 1).strides, strides_c) + assert_equal(a.reshape(3, 2, 1, 1, order='F').strides, strides_f) + assert_equal(np.array(0, dtype=np.int32).reshape(1, 1).strides, (4, 4)) + + def test_repeat_discont(self): + # Ticket #352 + a = np.arange(12).reshape(4, 3)[:, 2] + assert_equal(a.repeat(3), [2, 2, 2, 5, 5, 5, 8, 8, 8, 11, 11, 11]) + + def test_array_index(self): + # Make sure optimization is not called in this case. + a = np.array([1, 2, 3]) + a2 = np.array([[1, 2, 3]]) + assert_equal(a[np.where(a == 3)], a2[np.where(a2 == 3)]) + + def test_object_argmax(self): + a = np.array([1, 2, 3], dtype=object) + assert_(a.argmax() == 2) + + def test_recarray_fields(self): + # Ticket #372 + dt0 = np.dtype([('f0', 'i4'), ('f1', 'i4')]) + dt1 = np.dtype([('f0', 'i8'), ('f1', 'i8')]) + for a in [np.array([(1, 2), (3, 4)], "i4,i4"), + np.rec.array([(1, 2), (3, 4)], "i4,i4"), + np.rec.array([(1, 2), (3, 4)]), + np.rec.fromarrays([(1, 2), (3, 4)], "i4,i4"), + np.rec.fromarrays([(1, 2), (3, 4)])]: + assert_(a.dtype in [dt0, dt1]) + + def test_random_shuffle(self): + # Ticket #374 + a = np.arange(5).reshape((5, 1)) + b = a.copy() + np.random.shuffle(b) + assert_equal(np.sort(b, axis=0), a) + + def test_refcount_vdot(self): + # Changeset #3443 + _assert_valid_refcount(np.vdot) + + def test_startswith(self): + ca = np.char.array(['Hi', 'There']) + assert_equal(ca.startswith('H'), [True, False]) + + def test_noncommutative_reduce_accumulate(self): + # Ticket #413 + tosubtract = np.arange(5) + todivide = np.array([2.0, 0.5, 0.25]) + assert_equal(np.subtract.reduce(tosubtract), -10) + assert_equal(np.divide.reduce(todivide), 16.0) + assert_array_equal(np.subtract.accumulate(tosubtract), + np.array([0, -1, -3, -6, -10])) + assert_array_equal(np.divide.accumulate(todivide), + np.array([2., 4., 16.])) + + def test_convolve_empty(self): + # Convolve should raise an error for empty input array. + assert_raises(ValueError, np.convolve, [], [1]) + assert_raises(ValueError, np.convolve, [1], []) + + def test_multidim_byteswap(self): + # Ticket #449 + r = np.array([(1, (0, 1, 2))], dtype="i2,3i2") + assert_array_equal(r.byteswap(), + np.array([(256, (0, 256, 512))], r.dtype)) + + def test_string_NULL(self): + # Changeset 3557 + assert_equal(np.array("a\x00\x0b\x0c\x00").item(), + 'a\x00\x0b\x0c') + + def test_junk_in_string_fields_of_recarray(self): + # Ticket #483 + r = np.array([[b'abc']], dtype=[('var1', '|S20')]) + assert_(asbytes(r['var1'][0][0]) == b'abc') + + def test_take_output(self): + # Ensure that 'take' honours output parameter. + x = np.arange(12).reshape((3, 4)) + a = np.take(x, [0, 2], axis=1) + b = np.zeros_like(a) + np.take(x, [0, 2], axis=1, out=b) + assert_array_equal(a, b) + + def test_take_object_fail(self): + # Issue gh-3001 + d = 123. + a = np.array([d, 1], dtype=object) + if HAS_REFCOUNT: + ref_d = sys.getrefcount(d) + try: + a.take([0, 100]) + except IndexError: + pass + if HAS_REFCOUNT: + assert_(ref_d == sys.getrefcount(d)) + + def test_array_str_64bit(self): + # Ticket #501 + s = np.array([1, np.nan], dtype=np.float64) + with np.errstate(all='raise'): + np.array_str(s) # Should succeed + + def test_frompyfunc_endian(self): + # Ticket #503 + from math import radians + uradians = np.frompyfunc(radians, 1, 1) + big_endian = np.array([83.4, 83.5], dtype='>f8') + little_endian = np.array([83.4, 83.5], dtype=' object + # casting succeeds + def rs(): + x = np.ones([484, 286]) + y = np.zeros([484, 286]) + x |= y + + assert_raises(TypeError, rs) + + def test_unicode_scalar(self): + # Ticket #600 + x = np.array(["DROND", "DROND1"], dtype="U6") + el = x[1] + for proto in range(2, pickle.HIGHEST_PROTOCOL + 1): + new = pickle.loads(pickle.dumps(el, protocol=proto)) + assert_equal(new, el) + + def test_arange_non_native_dtype(self): + # Ticket #616 + for T in ('>f4', ' 0)] = v + + assert_raises(IndexError, ia, x, s, np.zeros(9, dtype=float)) + assert_raises(IndexError, ia, x, s, np.zeros(11, dtype=float)) + + # Old special case (different code path): + assert_raises(ValueError, ia, x.flat, s, np.zeros(9, dtype=float)) + assert_raises(ValueError, ia, x.flat, s, np.zeros(11, dtype=float)) + + def test_mem_scalar_indexing(self): + # Ticket #603 + x = np.array([0], dtype=float) + index = np.array(0, dtype=np.int32) + x[index] + + def test_binary_repr_0_width(self): + assert_equal(np.binary_repr(0, width=3), '000') + + def test_fromstring(self): + assert_equal(np.fromstring("12:09:09", dtype=int, sep=":"), + [12, 9, 9]) + + def test_searchsorted_variable_length(self): + x = np.array(['a', 'aa', 'b']) + y = np.array(['d', 'e']) + assert_equal(x.searchsorted(y), [3, 3]) + + def test_string_argsort_with_zeros(self): + # Check argsort for strings containing zeros. + x = np.frombuffer(b"\x00\x02\x00\x01", dtype="|S2") + assert_array_equal(x.argsort(kind='m'), np.array([1, 0])) + assert_array_equal(x.argsort(kind='q'), np.array([1, 0])) + + def test_string_sort_with_zeros(self): + # Check sort for strings containing zeros. + x = np.frombuffer(b"\x00\x02\x00\x01", dtype="|S2") + y = np.frombuffer(b"\x00\x01\x00\x02", dtype="|S2") + assert_array_equal(np.sort(x, kind="q"), y) + + def test_copy_detection_zero_dim(self): + # Ticket #658 + np.indices((0, 3, 4)).T.reshape(-1, 3) + + def test_flat_byteorder(self): + # Ticket #657 + x = np.arange(10) + assert_array_equal(x.astype('>i4'), x.astype('i4').flat[:], x.astype('i4')): + x = np.array([-1, 0, 1], dtype=dt) + assert_equal(x.flat[0].dtype, x[0].dtype) + + def test_copy_detection_corner_case(self): + # Ticket #658 + np.indices((0, 3, 4)).T.reshape(-1, 3) + + def test_object_array_refcounting(self): + # Ticket #633 + if not hasattr(sys, 'getrefcount'): + return + + # NB. this is probably CPython-specific + + cnt = sys.getrefcount + + a = object() + b = object() + c = object() + + cnt0_a = cnt(a) + cnt0_b = cnt(b) + cnt0_c = cnt(c) + + # -- 0d -> 1-d broadcast slice assignment + + arr = np.zeros(5, dtype=np.object_) + + arr[:] = a + assert_equal(cnt(a), cnt0_a + 5) + + arr[:] = b + assert_equal(cnt(a), cnt0_a) + assert_equal(cnt(b), cnt0_b + 5) + + arr[:2] = c + assert_equal(cnt(b), cnt0_b + 3) + assert_equal(cnt(c), cnt0_c + 2) + + del arr + + # -- 1-d -> 2-d broadcast slice assignment + + arr = np.zeros((5, 2), dtype=np.object_) + arr0 = np.zeros(2, dtype=np.object_) + + arr0[0] = a + assert_(cnt(a) == cnt0_a + 1) + arr0[1] = b + assert_(cnt(b) == cnt0_b + 1) + + arr[:, :] = arr0 + assert_(cnt(a) == cnt0_a + 6) + assert_(cnt(b) == cnt0_b + 6) + + arr[:, 0] = None + assert_(cnt(a) == cnt0_a + 1) + + del arr, arr0 + + # -- 2-d copying + flattening + + arr = np.zeros((5, 2), dtype=np.object_) + + arr[:, 0] = a + arr[:, 1] = b + assert_(cnt(a) == cnt0_a + 5) + assert_(cnt(b) == cnt0_b + 5) + + arr2 = arr.copy() + assert_(cnt(a) == cnt0_a + 10) + assert_(cnt(b) == cnt0_b + 10) + + arr2 = arr[:, 0].copy() + assert_(cnt(a) == cnt0_a + 10) + assert_(cnt(b) == cnt0_b + 5) + + arr2 = arr.flatten() + assert_(cnt(a) == cnt0_a + 10) + assert_(cnt(b) == cnt0_b + 10) + + del arr, arr2 + + # -- concatenate, repeat, take, choose + + arr1 = np.zeros((5, 1), dtype=np.object_) + arr2 = np.zeros((5, 1), dtype=np.object_) + + arr1[...] = a + arr2[...] = b + assert_(cnt(a) == cnt0_a + 5) + assert_(cnt(b) == cnt0_b + 5) + + tmp = np.concatenate((arr1, arr2)) + assert_(cnt(a) == cnt0_a + 5 + 5) + assert_(cnt(b) == cnt0_b + 5 + 5) + + tmp = arr1.repeat(3, axis=0) + assert_(cnt(a) == cnt0_a + 5 + 3*5) + + tmp = arr1.take([1, 2, 3], axis=0) + assert_(cnt(a) == cnt0_a + 5 + 3) + + x = np.array([[0], [1], [0], [1], [1]], int) + tmp = x.choose(arr1, arr2) + assert_(cnt(a) == cnt0_a + 5 + 2) + assert_(cnt(b) == cnt0_b + 5 + 3) + + del tmp # Avoid pyflakes unused variable warning + + def test_mem_custom_float_to_array(self): + # Ticket 702 + class MyFloat: + def __float__(self): + return 1.0 + + tmp = np.atleast_1d([MyFloat()]) + tmp.astype(float) # Should succeed + + def test_object_array_refcount_self_assign(self): + # Ticket #711 + class VictimObject: + deleted = False + + def __del__(self): + self.deleted = True + + d = VictimObject() + arr = np.zeros(5, dtype=np.object_) + arr[:] = d + del d + arr[:] = arr # refcount of 'd' might hit zero here + assert_(not arr[0].deleted) + arr[:] = arr # trying to induce a segfault by doing it again... + assert_(not arr[0].deleted) + + def test_mem_fromiter_invalid_dtype_string(self): + x = [1, 2, 3] + assert_raises(ValueError, + np.fromiter, [xi for xi in x], dtype='S') + + def test_reduce_big_object_array(self): + # Ticket #713 + oldsize = np.setbufsize(10*16) + a = np.array([None]*161, object) + assert_(not np.any(a)) + np.setbufsize(oldsize) + + def test_mem_0d_array_index(self): + # Ticket #714 + np.zeros(10)[np.array(0)] + + def test_nonnative_endian_fill(self): + # Non-native endian arrays were incorrectly filled with scalars + # before r5034. + if sys.byteorder == 'little': + dtype = np.dtype('>i4') + else: + dtype = np.dtype('data contains non-zero floats + x = np.array([123456789e199], dtype=np.float64) + if IS_PYPY: + x.resize((m, 0), refcheck=False) + else: + x.resize((m, 0)) + y = np.array([123456789e199], dtype=np.float64) + if IS_PYPY: + y.resize((0, n), refcheck=False) + else: + y.resize((0, n)) + + # `dot` should just return zero (m, n) matrix + z = np.dot(x, y) + assert_(np.all(z == 0)) + assert_(z.shape == (m, n)) + + def test_zeros(self): + # Regression test for #1061. + # Set a size which cannot fit into a 64 bits signed integer + sz = 2 ** 64 + with assert_raises_regex(ValueError, + 'Maximum allowed dimension exceeded'): + np.empty(sz) + + def test_huge_arange(self): + # Regression test for #1062. + # Set a size which cannot fit into a 64 bits signed integer + sz = 2 ** 64 + with assert_raises_regex(ValueError, + 'Maximum allowed size exceeded'): + np.arange(sz) + assert_(np.size == sz) + + def test_fromiter_bytes(self): + # Ticket #1058 + a = np.fromiter(list(range(10)), dtype='b') + b = np.fromiter(list(range(10)), dtype='B') + assert_(np.all(a == np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]))) + assert_(np.all(b == np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]))) + + def test_array_from_sequence_scalar_array(self): + # Ticket #1078: segfaults when creating an array with a sequence of + # 0d arrays. + a = np.array((np.ones(2), np.array(2)), dtype=object) + assert_equal(a.shape, (2,)) + assert_equal(a.dtype, np.dtype(object)) + assert_equal(a[0], np.ones(2)) + assert_equal(a[1], np.array(2)) + + a = np.array(((1,), np.array(1)), dtype=object) + assert_equal(a.shape, (2,)) + assert_equal(a.dtype, np.dtype(object)) + assert_equal(a[0], (1,)) + assert_equal(a[1], np.array(1)) + + def test_array_from_sequence_scalar_array2(self): + # Ticket #1081: weird array with strange input... + t = np.array([np.array([]), np.array(0, object)], dtype=object) + assert_equal(t.shape, (2,)) + assert_equal(t.dtype, np.dtype(object)) + + def test_array_too_big(self): + # Ticket #1080. + assert_raises(ValueError, np.zeros, [975]*7, np.int8) + assert_raises(ValueError, np.zeros, [26244]*5, np.int8) + + def test_dtype_keyerrors_(self): + # Ticket #1106. + dt = np.dtype([('f1', np.uint)]) + assert_raises(KeyError, dt.__getitem__, "f2") + assert_raises(IndexError, dt.__getitem__, 1) + assert_raises(TypeError, dt.__getitem__, 0.0) + + def test_lexsort_buffer_length(self): + # Ticket #1217, don't segfault. + a = np.ones(100, dtype=np.int8) + b = np.ones(100, dtype=np.int32) + i = np.lexsort((a[::-1], b)) + assert_equal(i, np.arange(100, dtype=int)) + + def test_object_array_to_fixed_string(self): + # Ticket #1235. + a = np.array(['abcdefgh', 'ijklmnop'], dtype=np.object_) + b = np.array(a, dtype=(np.str_, 8)) + assert_equal(a, b) + c = np.array(a, dtype=(np.str_, 5)) + assert_equal(c, np.array(['abcde', 'ijklm'])) + d = np.array(a, dtype=(np.str_, 12)) + assert_equal(a, d) + e = np.empty((2, ), dtype=(np.str_, 8)) + e[:] = a[:] + assert_equal(a, e) + + def test_unicode_to_string_cast(self): + # Ticket #1240. + a = np.array([['abc', '\u03a3'], + ['asdf', 'erw']], + dtype='U') + assert_raises(UnicodeEncodeError, np.array, a, 'S4') + + def test_unicode_to_string_cast_error(self): + # gh-15790 + a = np.array(['\x80'] * 129, dtype='U3') + assert_raises(UnicodeEncodeError, np.array, a, 'S') + b = a.reshape(3, 43)[:-1, :-1] + assert_raises(UnicodeEncodeError, np.array, b, 'S') + + def test_mixed_string_byte_array_creation(self): + a = np.array(['1234', b'123']) + assert_(a.itemsize == 16) + a = np.array([b'123', '1234']) + assert_(a.itemsize == 16) + a = np.array(['1234', b'123', '12345']) + assert_(a.itemsize == 20) + a = np.array([b'123', '1234', b'12345']) + assert_(a.itemsize == 20) + a = np.array([b'123', '1234', b'1234']) + assert_(a.itemsize == 16) + + def test_misaligned_objects_segfault(self): + # Ticket #1198 and #1267 + a1 = np.zeros((10,), dtype='O,c') + a2 = np.array(['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'], 'S10') + a1['f0'] = a2 + repr(a1) + np.argmax(a1['f0']) + a1['f0'][1] = "FOO" + a1['f0'] = "FOO" + np.array(a1['f0'], dtype='S') + np.nonzero(a1['f0']) + a1.sort() + copy.deepcopy(a1) + + def test_misaligned_scalars_segfault(self): + # Ticket #1267 + s1 = np.array(('a', 'Foo'), dtype='c,O') + s2 = np.array(('b', 'Bar'), dtype='c,O') + s1['f1'] = s2['f1'] + s1['f1'] = 'Baz' + + def test_misaligned_dot_product_objects(self): + # Ticket #1267 + # This didn't require a fix, but it's worth testing anyway, because + # it may fail if .dot stops enforcing the arrays to be BEHAVED + a = np.array([[(1, 'a'), (0, 'a')], [(0, 'a'), (1, 'a')]], dtype='O,c') + b = np.array([[(4, 'a'), (1, 'a')], [(2, 'a'), (2, 'a')]], dtype='O,c') + np.dot(a['f0'], b['f0']) + + def test_byteswap_complex_scalar(self): + # Ticket #1259 and gh-441 + for dtype in [np.dtype('<'+t) for t in np.typecodes['Complex']]: + z = np.array([2.2-1.1j], dtype) + x = z[0] # always native-endian + y = x.byteswap() + if x.dtype.byteorder == z.dtype.byteorder: + # little-endian machine + assert_equal(x, np.frombuffer(y.tobytes(), dtype=dtype.newbyteorder())) + else: + # big-endian machine + assert_equal(x, np.frombuffer(y.tobytes(), dtype=dtype)) + # double check real and imaginary parts: + assert_equal(x.real, y.real.byteswap()) + assert_equal(x.imag, y.imag.byteswap()) + + def test_structured_arrays_with_objects1(self): + # Ticket #1299 + stra = 'aaaa' + strb = 'bbbb' + x = np.array([[(0, stra), (1, strb)]], 'i8,O') + x[x.nonzero()] = x.ravel()[:1] + assert_(x[0, 1] == x[0, 0]) + + @pytest.mark.skipif( + sys.version_info >= (3, 12), + reason="Python 3.12 has immortal refcounts, this test no longer works." + ) + @pytest.mark.skipif(not HAS_REFCOUNT, reason="Python lacks refcounts") + def test_structured_arrays_with_objects2(self): + # Ticket #1299 second test + stra = 'aaaa' + strb = 'bbbb' + numb = sys.getrefcount(strb) + numa = sys.getrefcount(stra) + x = np.array([[(0, stra), (1, strb)]], 'i8,O') + x[x.nonzero()] = x.ravel()[:1] + assert_(sys.getrefcount(strb) == numb) + assert_(sys.getrefcount(stra) == numa + 2) + + def test_duplicate_title_and_name(self): + # Ticket #1254 + dtspec = [(('a', 'a'), 'i'), ('b', 'i')] + assert_raises(ValueError, np.dtype, dtspec) + + def test_signed_integer_division_overflow(self): + # Ticket #1317. + def test_type(t): + min = np.array([np.iinfo(t).min]) + min //= -1 + + with np.errstate(over="ignore"): + for t in (np.int8, np.int16, np.int32, np.int64, int): + test_type(t) + + def test_buffer_hashlib(self): + from hashlib import sha256 + + x = np.array([1, 2, 3], dtype=np.dtype('c') + + def test_log1p_compiler_shenanigans(self): + # Check if log1p is behaving on 32 bit intel systems. + assert_(np.isfinite(np.log1p(np.exp2(-53)))) + + def test_fromiter_comparison(self): + a = np.fromiter(list(range(10)), dtype='b') + b = np.fromiter(list(range(10)), dtype='B') + assert_(np.all(a == np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]))) + assert_(np.all(b == np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]))) + + def test_fromstring_crash(self): + # Ticket #1345: the following should not cause a crash + with assert_warns(DeprecationWarning): + np.fromstring(b'aa, aa, 1.0', sep=',') + + def test_ticket_1539(self): + dtypes = [x for x in np._core.sctypeDict.values() + if (issubclass(x, np.number) + and not issubclass(x, np.timedelta64))] + a = np.array([], np.bool) # not x[0] because it is unordered + failures = [] + + for x in dtypes: + b = a.astype(x) + for y in dtypes: + c = a.astype(y) + try: + d = np.dot(b, c) + except TypeError: + failures.append((x, y)) + else: + if d != 0: + failures.append((x, y)) + if failures: + raise AssertionError("Failures: %r" % failures) + + def test_ticket_1538(self): + x = np.finfo(np.float32) + for name in 'eps epsneg max min resolution tiny'.split(): + assert_equal(type(getattr(x, name)), np.float32, + err_msg=name) + + def test_ticket_1434(self): + # Check that the out= argument in var and std has an effect + data = np.array(((1, 2, 3), (4, 5, 6), (7, 8, 9))) + out = np.zeros((3,)) + + ret = data.var(axis=1, out=out) + assert_(ret is out) + assert_array_equal(ret, data.var(axis=1)) + + ret = data.std(axis=1, out=out) + assert_(ret is out) + assert_array_equal(ret, data.std(axis=1)) + + def test_complex_nan_maximum(self): + cnan = complex(0, np.nan) + assert_equal(np.maximum(1, cnan), cnan) + + def test_subclass_int_tuple_assignment(self): + # ticket #1563 + class Subclass(np.ndarray): + def __new__(cls, i): + return np.ones((i,)).view(cls) + + x = Subclass(5) + x[(0,)] = 2 # shouldn't raise an exception + assert_equal(x[0], 2) + + def test_ufunc_no_unnecessary_views(self): + # ticket #1548 + class Subclass(np.ndarray): + pass + x = np.array([1, 2, 3]).view(Subclass) + y = np.add(x, x, x) + assert_equal(id(x), id(y)) + + @pytest.mark.skipif(not HAS_REFCOUNT, reason="Python lacks refcounts") + def test_take_refcount(self): + # ticket #939 + a = np.arange(16, dtype=float) + a.shape = (4, 4) + lut = np.ones((5 + 3, 4), float) + rgba = np.empty(shape=a.shape + (4,), dtype=lut.dtype) + c1 = sys.getrefcount(rgba) + try: + lut.take(a, axis=0, mode='clip', out=rgba) + except TypeError: + pass + c2 = sys.getrefcount(rgba) + assert_equal(c1, c2) + + def test_fromfile_tofile_seeks(self): + # On Python 3, tofile/fromfile used to get (#1610) the Python + # file handle out of sync + f0 = tempfile.NamedTemporaryFile() + f = f0.file + f.write(np.arange(255, dtype='u1').tobytes()) + + f.seek(20) + ret = np.fromfile(f, count=4, dtype='u1') + assert_equal(ret, np.array([20, 21, 22, 23], dtype='u1')) + assert_equal(f.tell(), 24) + + f.seek(40) + np.array([1, 2, 3], dtype='u1').tofile(f) + assert_equal(f.tell(), 43) + + f.seek(40) + data = f.read(3) + assert_equal(data, b"\x01\x02\x03") + + f.seek(80) + f.read(4) + data = np.fromfile(f, dtype='u1', count=4) + assert_equal(data, np.array([84, 85, 86, 87], dtype='u1')) + + f.close() + + def test_complex_scalar_warning(self): + for tp in [np.csingle, np.cdouble, np.clongdouble]: + x = tp(1+2j) + assert_warns(ComplexWarning, float, x) + with suppress_warnings() as sup: + sup.filter(ComplexWarning) + assert_equal(float(x), float(x.real)) + + def test_complex_scalar_complex_cast(self): + for tp in [np.csingle, np.cdouble, np.clongdouble]: + x = tp(1+2j) + assert_equal(complex(x), 1+2j) + + def test_complex_boolean_cast(self): + # Ticket #2218 + for tp in [np.csingle, np.cdouble, np.clongdouble]: + x = np.array([0, 0+0.5j, 0.5+0j], dtype=tp) + assert_equal(x.astype(bool), np.array([0, 1, 1], dtype=bool)) + assert_(np.any(x)) + assert_(np.all(x[1:])) + + def test_uint_int_conversion(self): + x = 2**64 - 1 + assert_equal(int(np.uint64(x)), x) + + def test_duplicate_field_names_assign(self): + ra = np.fromiter(((i*3, i*2) for i in range(10)), dtype='i8,f8') + ra.dtype.names = ('f1', 'f2') + repr(ra) # should not cause a segmentation fault + assert_raises(ValueError, setattr, ra.dtype, 'names', ('f1', 'f1')) + + def test_eq_string_and_object_array(self): + # From e-mail thread "__eq__ with str and object" (Keith Goodman) + a1 = np.array(['a', 'b'], dtype=object) + a2 = np.array(['a', 'c']) + assert_array_equal(a1 == a2, [True, False]) + assert_array_equal(a2 == a1, [True, False]) + + def test_nonzero_byteswap(self): + a = np.array([0x80000000, 0x00000080, 0], dtype=np.uint32) + a.dtype = np.float32 + assert_equal(a.nonzero()[0], [1]) + a = a.byteswap() + a = a.view(a.dtype.newbyteorder()) + assert_equal(a.nonzero()[0], [1]) # [0] if nonzero() ignores swap + + def test_empty_mul(self): + a = np.array([1.]) + a[1:1] *= 2 + assert_equal(a, [1.]) + + def test_array_side_effect(self): + # The second use of itemsize was throwing an exception because in + # ctors.c, discover_itemsize was calling PyObject_Length without + # checking the return code. This failed to get the length of the + # number 2, and the exception hung around until something checked + # PyErr_Occurred() and returned an error. + assert_equal(np.dtype('S10').itemsize, 10) + np.array([['abc', 2], ['long ', '0123456789']], dtype=np.bytes_) + assert_equal(np.dtype('S10').itemsize, 10) + + def test_any_float(self): + # all and any for floats + a = np.array([0.1, 0.9]) + assert_(np.any(a)) + assert_(np.all(a)) + + def test_large_float_sum(self): + a = np.arange(10000, dtype='f') + assert_equal(a.sum(dtype='d'), a.astype('d').sum()) + + def test_ufunc_casting_out(self): + a = np.array(1.0, dtype=np.float32) + b = np.array(1.0, dtype=np.float64) + c = np.array(1.0, dtype=np.float32) + np.add(a, b, out=c) + assert_equal(c, 2.0) + + def test_array_scalar_contiguous(self): + # Array scalars are both C and Fortran contiguous + assert_(np.array(1.0).flags.c_contiguous) + assert_(np.array(1.0).flags.f_contiguous) + assert_(np.array(np.float32(1.0)).flags.c_contiguous) + assert_(np.array(np.float32(1.0)).flags.f_contiguous) + + def test_squeeze_contiguous(self): + # Similar to GitHub issue #387 + a = np.zeros((1, 2)).squeeze() + b = np.zeros((2, 2, 2), order='F')[:, :, ::2].squeeze() + assert_(a.flags.c_contiguous) + assert_(a.flags.f_contiguous) + assert_(b.flags.f_contiguous) + + def test_squeeze_axis_handling(self): + # Issue #10779 + # Ensure proper handling of objects + # that don't support axis specification + # when squeezing + + class OldSqueeze(np.ndarray): + + def __new__(cls, + input_array): + obj = np.asarray(input_array).view(cls) + return obj + + # it is perfectly reasonable that prior + # to numpy version 1.7.0 a subclass of ndarray + # might have been created that did not expect + # squeeze to have an axis argument + # NOTE: this example is somewhat artificial; + # it is designed to simulate an old API + # expectation to guard against regression + def squeeze(self): + return super().squeeze() + + oldsqueeze = OldSqueeze(np.array([[1],[2],[3]])) + + # if no axis argument is specified the old API + # expectation should give the correct result + assert_equal(np.squeeze(oldsqueeze), + np.array([1,2,3])) + + # likewise, axis=None should work perfectly well + # with the old API expectation + assert_equal(np.squeeze(oldsqueeze, axis=None), + np.array([1,2,3])) + + # however, specification of any particular axis + # should raise a TypeError in the context of the + # old API specification, even when using a valid + # axis specification like 1 for this array + with assert_raises(TypeError): + # this would silently succeed for array + # subclasses / objects that did not support + # squeeze axis argument handling before fixing + # Issue #10779 + np.squeeze(oldsqueeze, axis=1) + + # check for the same behavior when using an invalid + # axis specification -- in this case axis=0 does not + # have size 1, but the priority should be to raise + # a TypeError for the axis argument and NOT a + # ValueError for squeezing a non-empty dimension + with assert_raises(TypeError): + np.squeeze(oldsqueeze, axis=0) + + # the new API knows how to handle the axis + # argument and will return a ValueError if + # attempting to squeeze an axis that is not + # of length 1 + with assert_raises(ValueError): + np.squeeze(np.array([[1],[2],[3]]), axis=0) + + def test_reduce_contiguous(self): + # GitHub issue #387 + a = np.add.reduce(np.zeros((2, 1, 2)), (0, 1)) + b = np.add.reduce(np.zeros((2, 1, 2)), 1) + assert_(a.flags.c_contiguous) + assert_(a.flags.f_contiguous) + assert_(b.flags.c_contiguous) + + @pytest.mark.skipif(IS_PYSTON, reason="Pyston disables recursion checking") + def test_object_array_self_reference(self): + # Object arrays with references to themselves can cause problems + a = np.array(0, dtype=object) + a[()] = a + assert_raises(RecursionError, int, a) + assert_raises(RecursionError, float, a) + a[()] = None + + @pytest.mark.skipif(IS_PYSTON, reason="Pyston disables recursion checking") + def test_object_array_circular_reference(self): + # Test the same for a circular reference. + a = np.array(0, dtype=object) + b = np.array(0, dtype=object) + a[()] = b + b[()] = a + assert_raises(RecursionError, int, a) + # NumPy has no tp_traverse currently, so circular references + # cannot be detected. So resolve it: + a[()] = None + + # This was causing a to become like the above + a = np.array(0, dtype=object) + a[...] += 1 + assert_equal(a, 1) + + def test_object_array_nested(self): + # but is fine with a reference to a different array + a = np.array(0, dtype=object) + b = np.array(0, dtype=object) + a[()] = b + assert_equal(int(a), int(0)) + assert_equal(float(a), float(0)) + + def test_object_array_self_copy(self): + # An object array being copied into itself DECREF'ed before INCREF'ing + # causing segmentation faults (gh-3787) + a = np.array(object(), dtype=object) + np.copyto(a, a) + if HAS_REFCOUNT: + assert_(sys.getrefcount(a[()]) == 2) + a[()].__class__ # will segfault if object was deleted + + def test_zerosize_accumulate(self): + "Ticket #1733" + x = np.array([[42, 0]], dtype=np.uint32) + assert_equal(np.add.accumulate(x[:-1, 0]), []) + + def test_objectarray_setfield(self): + # Setfield should not overwrite Object fields with non-Object data + x = np.array([1, 2, 3], dtype=object) + assert_raises(TypeError, x.setfield, 4, np.int32, 0) + + def test_setting_rank0_string(self): + "Ticket #1736" + s1 = b"hello1" + s2 = b"hello2" + a = np.zeros((), dtype="S10") + a[()] = s1 + assert_equal(a, np.array(s1)) + a[()] = np.array(s2) + assert_equal(a, np.array(s2)) + + a = np.zeros((), dtype='f4') + a[()] = 3 + assert_equal(a, np.array(3)) + a[()] = np.array(4) + assert_equal(a, np.array(4)) + + def test_string_astype(self): + "Ticket #1748" + s1 = b'black' + s2 = b'white' + s3 = b'other' + a = np.array([[s1], [s2], [s3]]) + assert_equal(a.dtype, np.dtype('S5')) + b = a.astype(np.dtype('S0')) + assert_equal(b.dtype, np.dtype('S5')) + + def test_ticket_1756(self): + # Ticket #1756 + s = b'0123456789abcdef' + a = np.array([s]*5) + for i in range(1, 17): + a1 = np.array(a, "|S%d" % i) + a2 = np.array([s[:i]]*5) + assert_equal(a1, a2) + + def test_fields_strides(self): + "gh-2355" + r = np.frombuffer(b'abcdefghijklmnop'*4*3, dtype='i4,(2,3)u2') + assert_equal(r[0:3:2]['f1'], r['f1'][0:3:2]) + assert_equal(r[0:3:2]['f1'][0], r[0:3:2][0]['f1']) + assert_equal(r[0:3:2]['f1'][0][()], r[0:3:2][0]['f1'][()]) + assert_equal(r[0:3:2]['f1'][0].strides, r[0:3:2][0]['f1'].strides) + + def test_alignment_update(self): + # Check that alignment flag is updated on stride setting + a = np.arange(10) + assert_(a.flags.aligned) + a.strides = 3 + assert_(not a.flags.aligned) + + def test_ticket_1770(self): + "Should not segfault on python 3k" + import numpy as np + try: + a = np.zeros((1,), dtype=[('f1', 'f')]) + a['f1'] = 1 + a['f2'] = 1 + except ValueError: + pass + except Exception: + raise AssertionError + + def test_ticket_1608(self): + "x.flat shouldn't modify data" + x = np.array([[1, 2], [3, 4]]).T + np.array(x.flat) + assert_equal(x, [[1, 3], [2, 4]]) + + def test_pickle_string_overwrite(self): + import re + + data = np.array([1], dtype='b') + blob = pickle.dumps(data, protocol=1) + data = pickle.loads(blob) + + # Check that loads does not clobber interned strings + s = re.sub("a(.)", "\x01\\1", "a_") + assert_equal(s[0], "\x01") + data[0] = 0x6a + s = re.sub("a(.)", "\x01\\1", "a_") + assert_equal(s[0], "\x01") + + def test_pickle_bytes_overwrite(self): + for proto in range(2, pickle.HIGHEST_PROTOCOL + 1): + data = np.array([1], dtype='b') + data = pickle.loads(pickle.dumps(data, protocol=proto)) + data[0] = 0x7d + bytestring = "\x01 ".encode('ascii') + assert_equal(bytestring[0:1], '\x01'.encode('ascii')) + + def test_pickle_py2_array_latin1_hack(self): + # Check that unpickling hacks in Py3 that support + # encoding='latin1' work correctly. + + # Python2 output for pickle.dumps(numpy.array([129], dtype='b')) + data = b"cnumpy.core.multiarray\n_reconstruct\np0\n(cnumpy\nndarray\np1\n(I0\ntp2\nS'b'\np3\ntp4\nRp5\n(I1\n(I1\ntp6\ncnumpy\ndtype\np7\n(S'i1'\np8\nI0\nI1\ntp9\nRp10\n(I3\nS'|'\np11\nNNNI-1\nI-1\nI0\ntp12\nbI00\nS'\\x81'\np13\ntp14\nb." # noqa + # This should work: + result = pickle.loads(data, encoding='latin1') + assert_array_equal(result, np.array([129]).astype('b')) + # Should not segfault: + assert_raises(Exception, pickle.loads, data, encoding='koi8-r') + + def test_pickle_py2_scalar_latin1_hack(self): + # Check that scalar unpickling hack in Py3 that supports + # encoding='latin1' work correctly. + + # Python2 output for pickle.dumps(...) + datas = [ + # (original, python2_pickle, koi8r_validity) + (np.str_('\u6bd2'), + b"cnumpy.core.multiarray\nscalar\np0\n(cnumpy\ndtype\np1\n(S'U1'\np2\nI0\nI1\ntp3\nRp4\n(I3\nS'<'\np5\nNNNI4\nI4\nI0\ntp6\nbS'\\xd2k\\x00\\x00'\np7\ntp8\nRp9\n.", # noqa + 'invalid'), + + (np.float64(9e123), + b"cnumpy.core.multiarray\nscalar\np0\n(cnumpy\ndtype\np1\n(S'f8'\np2\nI0\nI1\ntp3\nRp4\n(I3\nS'<'\np5\nNNNI-1\nI-1\nI0\ntp6\nbS'O\\x81\\xb7Z\\xaa:\\xabY'\np7\ntp8\nRp9\n.", # noqa + 'invalid'), + + # different 8-bit code point in KOI8-R vs latin1 + (np.bytes_(b'\x9c'), + b"cnumpy.core.multiarray\nscalar\np0\n(cnumpy\ndtype\np1\n(S'S1'\np2\nI0\nI1\ntp3\nRp4\n(I3\nS'|'\np5\nNNNI1\nI1\nI0\ntp6\nbS'\\x9c'\np7\ntp8\nRp9\n.", # noqa + 'different'), + ] + for original, data, koi8r_validity in datas: + result = pickle.loads(data, encoding='latin1') + assert_equal(result, original) + + # Decoding under non-latin1 encoding (e.g.) KOI8-R can + # produce bad results, but should not segfault. + if koi8r_validity == 'different': + # Unicode code points happen to lie within latin1, + # but are different in koi8-r, resulting to silent + # bogus results + result = pickle.loads(data, encoding='koi8-r') + assert_(result != original) + elif koi8r_validity == 'invalid': + # Unicode code points outside latin1, so results + # to an encoding exception + assert_raises( + ValueError, pickle.loads, data, encoding='koi8-r' + ) + else: + raise ValueError(koi8r_validity) + + def test_structured_type_to_object(self): + a_rec = np.array([(0, 1), (3, 2)], dtype='i4,i8') + a_obj = np.empty((2,), dtype=object) + a_obj[0] = (0, 1) + a_obj[1] = (3, 2) + # astype records -> object + assert_equal(a_rec.astype(object), a_obj) + # '=' records -> object + b = np.empty_like(a_obj) + b[...] = a_rec + assert_equal(b, a_obj) + # '=' object -> records + b = np.empty_like(a_rec) + b[...] = a_obj + assert_equal(b, a_rec) + + def test_assign_obj_listoflists(self): + # Ticket # 1870 + # The inner list should get assigned to the object elements + a = np.zeros(4, dtype=object) + b = a.copy() + a[0] = [1] + a[1] = [2] + a[2] = [3] + a[3] = [4] + b[...] = [[1], [2], [3], [4]] + assert_equal(a, b) + # The first dimension should get broadcast + a = np.zeros((2, 2), dtype=object) + a[...] = [[1, 2]] + assert_equal(a, [[1, 2], [1, 2]]) + + @pytest.mark.slow_pypy + def test_memoryleak(self): + # Ticket #1917 - ensure that array data doesn't leak + for i in range(1000): + # 100MB times 1000 would give 100GB of memory usage if it leaks + a = np.empty((100000000,), dtype='i1') + del a + + @pytest.mark.skipif(not HAS_REFCOUNT, reason="Python lacks refcounts") + def test_ufunc_reduce_memoryleak(self): + a = np.arange(6) + acnt = sys.getrefcount(a) + np.add.reduce(a) + assert_equal(sys.getrefcount(a), acnt) + + def test_search_sorted_invalid_arguments(self): + # Ticket #2021, should not segfault. + x = np.arange(0, 4, dtype='datetime64[D]') + assert_raises(TypeError, x.searchsorted, 1) + + def test_string_truncation(self): + # Ticket #1990 - Data can be truncated in creation of an array from a + # mixed sequence of numeric values and strings (gh-2583) + for val in [True, 1234, 123.4, complex(1, 234)]: + for tostr, dtype in [(asunicode, "U"), (asbytes, "S")]: + b = np.array([val, tostr('xx')], dtype=dtype) + assert_equal(tostr(b[0]), tostr(val)) + b = np.array([tostr('xx'), val], dtype=dtype) + assert_equal(tostr(b[1]), tostr(val)) + + # test also with longer strings + b = np.array([val, tostr('xxxxxxxxxx')], dtype=dtype) + assert_equal(tostr(b[0]), tostr(val)) + b = np.array([tostr('xxxxxxxxxx'), val], dtype=dtype) + assert_equal(tostr(b[1]), tostr(val)) + + def test_string_truncation_ucs2(self): + # Ticket #2081. Python compiled with two byte unicode + # can lead to truncation if itemsize is not properly + # adjusted for NumPy's four byte unicode. + a = np.array(['abcd']) + assert_equal(a.dtype.itemsize, 16) + + def test_unique_stable(self): + # Ticket #2063 must always choose stable sort for argsort to + # get consistent results + v = np.array(([0]*5 + [1]*6 + [2]*6)*4) + res = np.unique(v, return_index=True) + tgt = (np.array([0, 1, 2]), np.array([ 0, 5, 11])) + assert_equal(res, tgt) + + def test_unicode_alloc_dealloc_match(self): + # Ticket #1578, the mismatch only showed up when running + # python-debug for python versions >= 2.7, and then as + # a core dump and error message. + a = np.array(['abc'], dtype=np.str_)[0] + del a + + def test_refcount_error_in_clip(self): + # Ticket #1588 + a = np.zeros((2,), dtype='>i2').clip(min=0) + x = a + a + # This used to segfault: + y = str(x) + # Check the final string: + assert_(y == "[0 0]") + + def test_searchsorted_wrong_dtype(self): + # Ticket #2189, it used to segfault, so we check that it raises the + # proper exception. + a = np.array([('a', 1)], dtype='S1, int') + assert_raises(TypeError, np.searchsorted, a, 1.2) + # Ticket #2066, similar problem: + dtype = np.rec.format_parser(['i4', 'i4'], [], []) + a = np.recarray((2,), dtype) + a[...] = [(1, 2), (3, 4)] + assert_raises(TypeError, np.searchsorted, a, 1) + + def test_complex64_alignment(self): + # Issue gh-2668 (trac 2076), segfault on sparc due to misalignment + dtt = np.complex64 + arr = np.arange(10, dtype=dtt) + # 2D array + arr2 = np.reshape(arr, (2, 5)) + # Fortran write followed by (C or F) read caused bus error + data_str = arr2.tobytes('F') + data_back = np.ndarray(arr2.shape, + arr2.dtype, + buffer=data_str, + order='F') + assert_array_equal(arr2, data_back) + + def test_structured_count_nonzero(self): + arr = np.array([0, 1]).astype('i4, 2i4')[:1] + count = np.count_nonzero(arr) + assert_equal(count, 0) + + def test_copymodule_preserves_f_contiguity(self): + a = np.empty((2, 2), order='F') + b = copy.copy(a) + c = copy.deepcopy(a) + assert_(b.flags.fortran) + assert_(b.flags.f_contiguous) + assert_(c.flags.fortran) + assert_(c.flags.f_contiguous) + + def test_fortran_order_buffer(self): + import numpy as np + a = np.array([['Hello', 'Foob']], dtype='U5', order='F') + arr = np.ndarray(shape=[1, 2, 5], dtype='U1', buffer=a) + arr2 = np.array([[['H', 'e', 'l', 'l', 'o'], + ['F', 'o', 'o', 'b', '']]]) + assert_array_equal(arr, arr2) + + def test_assign_from_sequence_error(self): + # Ticket #4024. + arr = np.array([1, 2, 3]) + assert_raises(ValueError, arr.__setitem__, slice(None), [9, 9]) + arr.__setitem__(slice(None), [9]) + assert_equal(arr, [9, 9, 9]) + + def test_format_on_flex_array_element(self): + # Ticket #4369. + dt = np.dtype([('date', ' 0: + # unpickling ndarray goes through _frombuffer for protocol 5 + assert b'numpy._core.numeric' in s + else: + assert b'numpy._core.multiarray' in s + + def test_object_casting_errors(self): + # gh-11993 update to ValueError (see gh-16909), since strings can in + # principle be converted to complex, but this string cannot. + arr = np.array(['AAAAA', 18465886.0, 18465886.0], dtype=object) + assert_raises(ValueError, arr.astype, 'c8') + + def test_eff1d_casting(self): + # gh-12711 + x = np.array([1, 2, 4, 7, 0], dtype=np.int16) + res = np.ediff1d(x, to_begin=-99, to_end=np.array([88, 99])) + assert_equal(res, [-99, 1, 2, 3, -7, 88, 99]) + + # The use of safe casting means, that 1<<20 is cast unsafely, an + # error may be better, but currently there is no mechanism for it. + res = np.ediff1d(x, to_begin=(1<<20), to_end=(1<<20)) + assert_equal(res, [0, 1, 2, 3, -7, 0]) + + def test_pickle_datetime64_array(self): + # gh-12745 (would fail with pickle5 installed) + d = np.datetime64('2015-07-04 12:59:59.50', 'ns') + arr = np.array([d]) + for proto in range(2, pickle.HIGHEST_PROTOCOL + 1): + dumped = pickle.dumps(arr, protocol=proto) + assert_equal(pickle.loads(dumped), arr) + + def test_bad_array_interface(self): + class T: + __array_interface__ = {} + + with assert_raises(ValueError): + np.array([T()]) + + def test_2d__array__shape(self): + class T: + def __array__(self, dtype=None, copy=None): + return np.ndarray(shape=(0,0)) + + # Make sure __array__ is used instead of Sequence methods. + def __iter__(self): + return iter([]) + + def __getitem__(self, idx): + raise AssertionError("__getitem__ was called") + + def __len__(self): + return 0 + + + t = T() + # gh-13659, would raise in broadcasting [x=t for x in result] + arr = np.array([t]) + assert arr.shape == (1, 0, 0) + + @pytest.mark.skipif(sys.maxsize < 2 ** 31 + 1, reason='overflows 32-bit python') + def test_to_ctypes(self): + #gh-14214 + arr = np.zeros((2 ** 31 + 1,), 'b') + assert arr.size * arr.itemsize > 2 ** 31 + c_arr = np.ctypeslib.as_ctypes(arr) + assert_equal(c_arr._length_, arr.size) + + def test_complex_conversion_error(self): + # gh-17068 + with pytest.raises(TypeError, match=r"Unable to convert dtype.*"): + complex(np.array("now", np.datetime64)) + + def test__array_interface__descr(self): + # gh-17068 + dt = np.dtype(dict(names=['a', 'b'], + offsets=[0, 0], + formats=[np.int64, np.int64])) + descr = np.array((1, 1), dtype=dt).__array_interface__['descr'] + assert descr == [('', '|V8')] # instead of [(b'', '|V8')] + + @pytest.mark.skipif(sys.maxsize < 2 ** 31 + 1, reason='overflows 32-bit python') + @requires_memory(free_bytes=9e9) + def test_dot_big_stride(self): + # gh-17111 + # blas stride = stride//itemsize > int32 max + int32_max = np.iinfo(np.int32).max + n = int32_max + 3 + a = np.empty([n], dtype=np.float32) + b = a[::n-1] + b[...] = 1 + assert b.strides[0] > int32_max * b.dtype.itemsize + assert np.dot(b, b) == 2.0 + + def test_frompyfunc_name(self): + # name conversion was failing for python 3 strings + # resulting in the default '?' name. Also test utf-8 + # encoding using non-ascii name. + def cassé(x): + return x + + f = np.frompyfunc(cassé, 1, 1) + assert str(f) == "" + + @pytest.mark.parametrize("operation", [ + 'add', 'subtract', 'multiply', 'floor_divide', + 'conjugate', 'fmod', 'square', 'reciprocal', + 'power', 'absolute', 'negative', 'positive', + 'greater', 'greater_equal', 'less', + 'less_equal', 'equal', 'not_equal', 'logical_and', + 'logical_not', 'logical_or', 'bitwise_and', 'bitwise_or', + 'bitwise_xor', 'invert', 'left_shift', 'right_shift', + 'gcd', 'lcm' + ] + ) + @pytest.mark.parametrize("order", [ + ('b->', 'B->'), + ('h->', 'H->'), + ('i->', 'I->'), + ('l->', 'L->'), + ('q->', 'Q->'), + ] + ) + def test_ufunc_order(self, operation, order): + # gh-18075 + # Ensure signed types before unsigned + def get_idx(string, str_lst): + for i, s in enumerate(str_lst): + if string in s: + return i + raise ValueError(f"{string} not in list") + types = getattr(np, operation).types + assert get_idx(order[0], types) < get_idx(order[1], types), ( + f"Unexpected types order of ufunc in {operation}" + f"for {order}. Possible fix: Use signed before unsigned" + "in generate_umath.py") + + def test_nonbool_logical(self): + # gh-22845 + # create two arrays with bit patterns that do not overlap. + # needs to be large enough to test both SIMD and scalar paths + size = 100 + a = np.frombuffer(b'\x01' * size, dtype=np.bool) + b = np.frombuffer(b'\x80' * size, dtype=np.bool) + expected = np.ones(size, dtype=np.bool) + assert_array_equal(np.logical_and(a, b), expected) + + @pytest.mark.skipif(IS_PYPY, reason="PyPy issue 2742") + def test_gh_23737(self): + with pytest.raises(TypeError, match="not an acceptable base type"): + class Y(np.flexible): + pass + + with pytest.raises(TypeError, match="not an acceptable base type"): + class X(np.flexible, np.ma.core.MaskedArray): + pass + + def test_load_ufunc_pickle(self): + # ufuncs are pickled with a semi-private path in + # numpy.core._multiarray_umath and must be loadable without warning + # despite np.core being deprecated. + test_data = b'\x80\x04\x95(\x00\x00\x00\x00\x00\x00\x00\x8c\x1cnumpy.core._multiarray_umath\x94\x8c\x03add\x94\x93\x94.' # noqa + result = pickle.loads(test_data, encoding='bytes') + assert result is np.add + + def test__array_namespace__(self): + arr = np.arange(2) + + xp = arr.__array_namespace__() + assert xp is np + xp = arr.__array_namespace__(api_version="2021.12") + assert xp is np + xp = arr.__array_namespace__(api_version="2022.12") + assert xp is np + xp = arr.__array_namespace__(api_version="2023.12") + assert xp is np + xp = arr.__array_namespace__(api_version=None) + assert xp is np + + with pytest.raises( + ValueError, + match="Version \"2024.12\" of the Array API Standard " + "is not supported." + ): + arr.__array_namespace__(api_version="2024.12") + + with pytest.raises( + ValueError, + match="Only None and strings are allowed as the Array API version" + ): + arr.__array_namespace__(api_version=2023) + + def test_isin_refcnt_bug(self): + # gh-25295 + for _ in range(1000): + np.isclose(np.int64(2), np.int64(2), atol=1e-15, rtol=1e-300) + + def test_replace_regression(self): + # gh-25513 segfault + carr = np.char.chararray((2,), itemsize=25) + test_strings = [b' 4.52173913043478315E+00', + b' 4.95652173913043548E+00'] + carr[:] = test_strings + out = carr.replace(b"E", b"D") + expected = np.char.chararray((2,), itemsize=25) + expected[:] = [s.replace(b"E", b"D") for s in test_strings] + assert_array_equal(out, expected) + + def test_logspace_base_does_not_determine_dtype(self): + # gh-24957 and cupy/cupy/issues/7946 + start = np.array([0, 2], dtype=np.float16) + stop = np.array([2, 0], dtype=np.float16) + out = np.logspace(start, stop, num=5, axis=1, dtype=np.float32) + expected = np.array([[1., 3.1621094, 10., 31.625, 100.], + [100., 31.625, 10., 3.1621094, 1.]], + dtype=np.float32) + assert_almost_equal(out, expected) + # Check test fails if the calculation is done in float64, as happened + # before when a python float base incorrectly influenced the dtype. + out2 = np.logspace(start, stop, num=5, axis=1, dtype=np.float32, + base=np.array([10.0])) + with pytest.raises(AssertionError, match="not almost equal"): + assert_almost_equal(out2, expected) + + def test_vectorize_fixed_width_string(self): + arr = np.array(["SOme wOrd DŽ ß ᾛ ΣΣ ffi⁵Å Ç Ⅰ"]).astype(np.str_) + f = str.casefold + res = np.vectorize(f, otypes=[arr.dtype])(arr) + assert res.dtype == "U30" + + def test_repeated_square_consistency(self): + # gh-26940 + buf = np.array([-5.171866611150749e-07 + 2.5618634555957426e-07j, + 0, 0, 0, 0, 0]) + # Test buffer with regular and reverse strides + for in_vec in [buf[:3], buf[:3][::-1]]: + expected_res = np.square(in_vec) + # Output vector immediately follows input vector + # to reproduce off-by-one in nomemoverlap check. + for res in [buf[3:], buf[3:][::-1]]: + res = buf[3:] + np.square(in_vec, out=res) + assert_equal(res, expected_res) + + def test_sort_unique_crash(self): + # gh-27037 + for _ in range(4): + vals = np.linspace(0, 1, num=128) + data = np.broadcast_to(vals, (128, 128, 128)) + data = data.transpose(0, 2, 1).copy() + np.unique(data) diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/test_scalar_ctors.py b/venv/lib/python3.12/site-packages/numpy/_core/tests/test_scalar_ctors.py new file mode 100644 index 00000000..f4f36f0c --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/tests/test_scalar_ctors.py @@ -0,0 +1,204 @@ +""" +Test the scalar constructors, which also do type-coercion +""" +import pytest + +import numpy as np +from numpy.testing import ( + assert_equal, assert_almost_equal, assert_warns, + ) + +class TestFromString: + def test_floating(self): + # Ticket #640, floats from string + fsingle = np.single('1.234') + fdouble = np.double('1.234') + flongdouble = np.longdouble('1.234') + assert_almost_equal(fsingle, 1.234) + assert_almost_equal(fdouble, 1.234) + assert_almost_equal(flongdouble, 1.234) + + def test_floating_overflow(self): + """ Strings containing an unrepresentable float overflow """ + fhalf = np.half('1e10000') + assert_equal(fhalf, np.inf) + fsingle = np.single('1e10000') + assert_equal(fsingle, np.inf) + fdouble = np.double('1e10000') + assert_equal(fdouble, np.inf) + flongdouble = assert_warns(RuntimeWarning, np.longdouble, '1e10000') + assert_equal(flongdouble, np.inf) + + fhalf = np.half('-1e10000') + assert_equal(fhalf, -np.inf) + fsingle = np.single('-1e10000') + assert_equal(fsingle, -np.inf) + fdouble = np.double('-1e10000') + assert_equal(fdouble, -np.inf) + flongdouble = assert_warns(RuntimeWarning, np.longdouble, '-1e10000') + assert_equal(flongdouble, -np.inf) + + +class TestExtraArgs: + def test_superclass(self): + # try both positional and keyword arguments + s = np.str_(b'\\x61', encoding='unicode-escape') + assert s == 'a' + s = np.str_(b'\\x61', 'unicode-escape') + assert s == 'a' + + # previously this would return '\\xx' + with pytest.raises(UnicodeDecodeError): + np.str_(b'\\xx', encoding='unicode-escape') + with pytest.raises(UnicodeDecodeError): + np.str_(b'\\xx', 'unicode-escape') + + # superclass fails, but numpy succeeds + assert np.bytes_(-2) == b'-2' + + def test_datetime(self): + dt = np.datetime64('2000-01', ('M', 2)) + assert np.datetime_data(dt) == ('M', 2) + + with pytest.raises(TypeError): + np.datetime64('2000', garbage=True) + + def test_bool(self): + with pytest.raises(TypeError): + np.bool(False, garbage=True) + + def test_void(self): + with pytest.raises(TypeError): + np.void(b'test', garbage=True) + + +class TestFromInt: + def test_intp(self): + # Ticket #99 + assert_equal(1024, np.intp(1024)) + + def test_uint64_from_negative(self): + with pytest.raises(OverflowError): + np.uint64(-2) + + +int_types = [np.byte, np.short, np.intc, np.long, np.longlong] +uint_types = [np.ubyte, np.ushort, np.uintc, np.ulong, np.ulonglong] +float_types = [np.half, np.single, np.double, np.longdouble] +cfloat_types = [np.csingle, np.cdouble, np.clongdouble] + + +class TestArrayFromScalar: + """ gh-15467 and gh-19125 """ + + def _do_test(self, t1, t2, arg=2): + if arg is None: + x = t1() + elif isinstance(arg, tuple): + if t1 is np.clongdouble: + pytest.xfail("creating a clongdouble from real and " + "imaginary parts isn't supported") + x = t1(*arg) + else: + x = t1(arg) + arr = np.array(x, dtype=t2) + # type should be preserved exactly + if t2 is None: + assert arr.dtype.type is t1 + else: + assert arr.dtype.type is t2 + + @pytest.mark.parametrize('t1', int_types + uint_types) + @pytest.mark.parametrize('t2', int_types + uint_types + [None]) + def test_integers(self, t1, t2): + return self._do_test(t1, t2) + + @pytest.mark.parametrize('t1', float_types) + @pytest.mark.parametrize('t2', float_types + [None]) + def test_reals(self, t1, t2): + return self._do_test(t1, t2) + + @pytest.mark.parametrize('t1', cfloat_types) + @pytest.mark.parametrize('t2', cfloat_types + [None]) + @pytest.mark.parametrize('arg', [2, 1 + 3j, (1, 2), None]) + def test_complex(self, t1, t2, arg): + self._do_test(t1, t2, arg) + + @pytest.mark.parametrize('t', cfloat_types) + def test_complex_errors(self, t): + with pytest.raises(TypeError): + t(1j, 1j) + with pytest.raises(TypeError): + t(1, None) + with pytest.raises(TypeError): + t(None, 1) + + +@pytest.mark.parametrize("length", + [5, np.int8(5), np.array(5, dtype=np.uint16)]) +def test_void_via_length(length): + res = np.void(length) + assert type(res) is np.void + assert res.item() == b"\0" * 5 + assert res.dtype == "V5" + +@pytest.mark.parametrize("bytes_", + [b"spam", np.array(567.)]) +def test_void_from_byteslike(bytes_): + res = np.void(bytes_) + expected = bytes(bytes_) + assert type(res) is np.void + assert res.item() == expected + + # Passing dtype can extend it (this is how filling works) + res = np.void(bytes_, dtype="V100") + assert type(res) is np.void + assert res.item()[:len(expected)] == expected + assert res.item()[len(expected):] == b"\0" * (res.nbytes - len(expected)) + # As well as shorten: + res = np.void(bytes_, dtype="V4") + assert type(res) is np.void + assert res.item() == expected[:4] + +def test_void_arraylike_trumps_byteslike(): + # The memoryview is converted as an array-like of shape (18,) + # rather than a single bytes-like of that length. + m = memoryview(b"just one mintleaf?") + res = np.void(m) + assert type(res) is np.ndarray + assert res.dtype == "V1" + assert res.shape == (18,) + +def test_void_dtype_arg(): + # Basic test for the dtype argument (positional and keyword) + res = np.void((1, 2), dtype="i,i") + assert res.item() == (1, 2) + res = np.void((2, 3), "i,i") + assert res.item() == (2, 3) + +@pytest.mark.parametrize("data", + [5, np.int8(5), np.array(5, dtype=np.uint16)]) +def test_void_from_integer_with_dtype(data): + # The "length" meaning is ignored, rather data is used: + res = np.void(data, dtype="i,i") + assert type(res) is np.void + assert res.dtype == "i,i" + assert res["f0"] == 5 and res["f1"] == 5 + +def test_void_from_structure(): + dtype = np.dtype([('s', [('f', 'f8'), ('u', 'U1')]), ('i', 'i2')]) + data = np.array(((1., 'a'), 2), dtype=dtype) + res = np.void(data[()], dtype=dtype) + assert type(res) is np.void + assert res.dtype == dtype + assert res == data[()] + +def test_void_bad_dtype(): + with pytest.raises(TypeError, + match="void: descr must be a `void.*int64"): + np.void(4, dtype="i8") + + # Subarray dtype (with shape `(4,)` is rejected): + with pytest.raises(TypeError, + match=r"void: descr must be a `void.*\(4,\)"): + np.void(4, dtype="4i") diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/test_scalar_methods.py b/venv/lib/python3.12/site-packages/numpy/_core/tests/test_scalar_methods.py new file mode 100644 index 00000000..7b6e8355 --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/tests/test_scalar_methods.py @@ -0,0 +1,225 @@ +""" +Test the scalar constructors, which also do type-coercion +""" +import fractions +import platform +import types +from typing import Any, Type + +import pytest +import numpy as np + +from numpy._core import sctypes +from numpy.testing import assert_equal, assert_raises, IS_MUSL + + +class TestAsIntegerRatio: + # derived in part from the cpython test "test_floatasratio" + + @pytest.mark.parametrize("ftype", [ + np.half, np.single, np.double, np.longdouble]) + @pytest.mark.parametrize("f, ratio", [ + (0.875, (7, 8)), + (-0.875, (-7, 8)), + (0.0, (0, 1)), + (11.5, (23, 2)), + ]) + def test_small(self, ftype, f, ratio): + assert_equal(ftype(f).as_integer_ratio(), ratio) + + @pytest.mark.parametrize("ftype", [ + np.half, np.single, np.double, np.longdouble]) + def test_simple_fractions(self, ftype): + R = fractions.Fraction + assert_equal(R(0, 1), + R(*ftype(0.0).as_integer_ratio())) + assert_equal(R(5, 2), + R(*ftype(2.5).as_integer_ratio())) + assert_equal(R(1, 2), + R(*ftype(0.5).as_integer_ratio())) + assert_equal(R(-2100, 1), + R(*ftype(-2100.0).as_integer_ratio())) + + @pytest.mark.parametrize("ftype", [ + np.half, np.single, np.double, np.longdouble]) + def test_errors(self, ftype): + assert_raises(OverflowError, ftype('inf').as_integer_ratio) + assert_raises(OverflowError, ftype('-inf').as_integer_ratio) + assert_raises(ValueError, ftype('nan').as_integer_ratio) + + def test_against_known_values(self): + R = fractions.Fraction + assert_equal(R(1075, 512), + R(*np.half(2.1).as_integer_ratio())) + assert_equal(R(-1075, 512), + R(*np.half(-2.1).as_integer_ratio())) + assert_equal(R(4404019, 2097152), + R(*np.single(2.1).as_integer_ratio())) + assert_equal(R(-4404019, 2097152), + R(*np.single(-2.1).as_integer_ratio())) + assert_equal(R(4728779608739021, 2251799813685248), + R(*np.double(2.1).as_integer_ratio())) + assert_equal(R(-4728779608739021, 2251799813685248), + R(*np.double(-2.1).as_integer_ratio())) + # longdouble is platform dependent + + @pytest.mark.parametrize("ftype, frac_vals, exp_vals", [ + # dtype test cases generated using hypothesis + # first five generated cases per dtype + (np.half, [0.0, 0.01154830649280303, 0.31082276347447274, + 0.527350517124794, 0.8308562335072596], + [0, 1, 0, -8, 12]), + (np.single, [0.0, 0.09248576989263226, 0.8160498218131407, + 0.17389442853722373, 0.7956044195067877], + [0, 12, 10, 17, -26]), + (np.double, [0.0, 0.031066908499895136, 0.5214135908877832, + 0.45780736035689296, 0.5906586745934036], + [0, -801, 51, 194, -653]), + pytest.param( + np.longdouble, + [0.0, 0.20492557202724854, 0.4277180662199366, 0.9888085019891495, + 0.9620175814461964], + [0, -7400, 14266, -7822, -8721], + marks=[ + pytest.mark.skipif( + np.finfo(np.double) == np.finfo(np.longdouble), + reason="long double is same as double"), + pytest.mark.skipif( + platform.machine().startswith("ppc"), + reason="IBM double double"), + ] + ) + ]) + def test_roundtrip(self, ftype, frac_vals, exp_vals): + for frac, exp in zip(frac_vals, exp_vals): + f = np.ldexp(ftype(frac), exp) + assert f.dtype == ftype + n, d = f.as_integer_ratio() + + try: + nf = np.longdouble(n) + df = np.longdouble(d) + if not np.isfinite(df): + raise OverflowError + except (OverflowError, RuntimeWarning): + # the values may not fit in any float type + pytest.skip("longdouble too small on this platform") + + assert_equal(nf / df, f, "{}/{}".format(n, d)) + + +class TestIsInteger: + @pytest.mark.parametrize("str_value", ["inf", "nan"]) + @pytest.mark.parametrize("code", np.typecodes["Float"]) + def test_special(self, code: str, str_value: str) -> None: + cls = np.dtype(code).type + value = cls(str_value) + assert not value.is_integer() + + @pytest.mark.parametrize( + "code", np.typecodes["Float"] + np.typecodes["AllInteger"] + ) + def test_true(self, code: str) -> None: + float_array = np.arange(-5, 5).astype(code) + for value in float_array: + assert value.is_integer() + + @pytest.mark.parametrize("code", np.typecodes["Float"]) + def test_false(self, code: str) -> None: + float_array = np.arange(-5, 5).astype(code) + float_array *= 1.1 + for value in float_array: + if value == 0: + continue + assert not value.is_integer() + + +class TestClassGetItem: + @pytest.mark.parametrize("cls", [ + np.number, + np.integer, + np.inexact, + np.unsignedinteger, + np.signedinteger, + np.floating, + ]) + def test_abc(self, cls: Type[np.number]) -> None: + alias = cls[Any] + assert isinstance(alias, types.GenericAlias) + assert alias.__origin__ is cls + + def test_abc_complexfloating(self) -> None: + alias = np.complexfloating[Any, Any] + assert isinstance(alias, types.GenericAlias) + assert alias.__origin__ is np.complexfloating + + @pytest.mark.parametrize("arg_len", range(4)) + def test_abc_complexfloating_subscript_tuple(self, arg_len: int) -> None: + arg_tup = (Any,) * arg_len + if arg_len in (1, 2): + assert np.complexfloating[arg_tup] + else: + match = f"Too {'few' if arg_len == 0 else 'many'} arguments" + with pytest.raises(TypeError, match=match): + np.complexfloating[arg_tup] + + @pytest.mark.parametrize("cls", [np.generic, np.flexible, np.character]) + def test_abc_non_numeric(self, cls: Type[np.generic]) -> None: + with pytest.raises(TypeError): + cls[Any] + + @pytest.mark.parametrize("code", np.typecodes["All"]) + def test_concrete(self, code: str) -> None: + cls = np.dtype(code).type + with pytest.raises(TypeError): + cls[Any] + + @pytest.mark.parametrize("arg_len", range(4)) + def test_subscript_tuple(self, arg_len: int) -> None: + arg_tup = (Any,) * arg_len + if arg_len == 1: + assert np.number[arg_tup] + else: + with pytest.raises(TypeError): + np.number[arg_tup] + + def test_subscript_scalar(self) -> None: + assert np.number[Any] + + +class TestBitCount: + # derived in part from the cpython test "test_bit_count" + + @pytest.mark.parametrize("itype", sctypes['int']+sctypes['uint']) + def test_small(self, itype): + for a in range(max(np.iinfo(itype).min, 0), 128): + msg = f"Smoke test for {itype}({a}).bit_count()" + assert itype(a).bit_count() == bin(a).count("1"), msg + + def test_bit_count(self): + for exp in [10, 17, 63]: + a = 2**exp + assert np.uint64(a).bit_count() == 1 + assert np.uint64(a - 1).bit_count() == exp + assert np.uint64(a ^ 63).bit_count() == 7 + assert np.uint64((a - 1) ^ 510).bit_count() == exp - 8 + + +class TestDevice: + """ + Test scalar.device attribute and scalar.to_device() method. + """ + scalars = [np.bool(True), np.int64(1), np.uint64(1), np.float64(1.0), + np.complex128(1+1j)] + + @pytest.mark.parametrize("scalar", scalars) + def test_device(self, scalar): + assert scalar.device == "cpu" + + @pytest.mark.parametrize("scalar", scalars) + def test_to_device(self, scalar): + assert scalar.to_device("cpu") is scalar + + @pytest.mark.parametrize("scalar", scalars) + def test___array_namespace__(self, scalar): + assert scalar.__array_namespace__() is np diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/test_scalarbuffer.py b/venv/lib/python3.12/site-packages/numpy/_core/tests/test_scalarbuffer.py new file mode 100644 index 00000000..26cf3953 --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/tests/test_scalarbuffer.py @@ -0,0 +1,153 @@ +""" +Test scalar buffer interface adheres to PEP 3118 +""" +import numpy as np +from numpy._core._rational_tests import rational +from numpy._core._multiarray_tests import get_buffer_info +import pytest + +from numpy.testing import assert_, assert_equal, assert_raises + +# PEP3118 format strings for native (standard alignment and byteorder) types +scalars_and_codes = [ + (np.bool, '?'), + (np.byte, 'b'), + (np.short, 'h'), + (np.intc, 'i'), + (np.long, 'l'), + (np.longlong, 'q'), + (np.ubyte, 'B'), + (np.ushort, 'H'), + (np.uintc, 'I'), + (np.ulong, 'L'), + (np.ulonglong, 'Q'), + (np.half, 'e'), + (np.single, 'f'), + (np.double, 'd'), + (np.longdouble, 'g'), + (np.csingle, 'Zf'), + (np.cdouble, 'Zd'), + (np.clongdouble, 'Zg'), +] +scalars_only, codes_only = zip(*scalars_and_codes) + + +class TestScalarPEP3118: + + @pytest.mark.parametrize('scalar', scalars_only, ids=codes_only) + def test_scalar_match_array(self, scalar): + x = scalar() + a = np.array([], dtype=np.dtype(scalar)) + mv_x = memoryview(x) + mv_a = memoryview(a) + assert_equal(mv_x.format, mv_a.format) + + @pytest.mark.parametrize('scalar', scalars_only, ids=codes_only) + def test_scalar_dim(self, scalar): + x = scalar() + mv_x = memoryview(x) + assert_equal(mv_x.itemsize, np.dtype(scalar).itemsize) + assert_equal(mv_x.ndim, 0) + assert_equal(mv_x.shape, ()) + assert_equal(mv_x.strides, ()) + assert_equal(mv_x.suboffsets, ()) + + @pytest.mark.parametrize('scalar, code', scalars_and_codes, ids=codes_only) + def test_scalar_code_and_properties(self, scalar, code): + x = scalar() + expected = dict(strides=(), itemsize=x.dtype.itemsize, ndim=0, + shape=(), format=code, readonly=True) + + mv_x = memoryview(x) + assert self._as_dict(mv_x) == expected + + @pytest.mark.parametrize('scalar', scalars_only, ids=codes_only) + def test_scalar_buffers_readonly(self, scalar): + x = scalar() + with pytest.raises(BufferError, match="scalar buffer is readonly"): + get_buffer_info(x, ["WRITABLE"]) + + def test_void_scalar_structured_data(self): + dt = np.dtype([('name', np.str_, 16), ('grades', np.float64, (2,))]) + x = np.array(('ndarray_scalar', (1.2, 3.0)), dtype=dt)[()] + assert_(isinstance(x, np.void)) + mv_x = memoryview(x) + expected_size = 16 * np.dtype((np.str_, 1)).itemsize + expected_size += 2 * np.dtype(np.float64).itemsize + assert_equal(mv_x.itemsize, expected_size) + assert_equal(mv_x.ndim, 0) + assert_equal(mv_x.shape, ()) + assert_equal(mv_x.strides, ()) + assert_equal(mv_x.suboffsets, ()) + + # check scalar format string against ndarray format string + a = np.array([('Sarah', (8.0, 7.0)), ('John', (6.0, 7.0))], dtype=dt) + assert_(isinstance(a, np.ndarray)) + mv_a = memoryview(a) + assert_equal(mv_x.itemsize, mv_a.itemsize) + assert_equal(mv_x.format, mv_a.format) + + # Check that we do not allow writeable buffer export (technically + # we could allow it sometimes here...) + with pytest.raises(BufferError, match="scalar buffer is readonly"): + get_buffer_info(x, ["WRITABLE"]) + + def _as_dict(self, m): + return dict(strides=m.strides, shape=m.shape, itemsize=m.itemsize, + ndim=m.ndim, format=m.format, readonly=m.readonly) + + def test_datetime_memoryview(self): + # gh-11656 + # Values verified with v1.13.3, shape is not () as in test_scalar_dim + + dt1 = np.datetime64('2016-01-01') + dt2 = np.datetime64('2017-01-01') + expected = dict(strides=(1,), itemsize=1, ndim=1, shape=(8,), + format='B', readonly=True) + v = memoryview(dt1) + assert self._as_dict(v) == expected + + v = memoryview(dt2 - dt1) + assert self._as_dict(v) == expected + + dt = np.dtype([('a', 'uint16'), ('b', 'M8[s]')]) + a = np.empty(1, dt) + # Fails to create a PEP 3118 valid buffer + assert_raises((ValueError, BufferError), memoryview, a[0]) + + # Check that we do not allow writeable buffer export + with pytest.raises(BufferError, match="scalar buffer is readonly"): + get_buffer_info(dt1, ["WRITABLE"]) + + @pytest.mark.parametrize('s', [ + pytest.param("\x32\x32", id="ascii"), + pytest.param("\uFE0F\uFE0F", id="basic multilingual"), + pytest.param("\U0001f4bb\U0001f4bb", id="non-BMP"), + ]) + def test_str_ucs4(self, s): + s = np.str_(s) # only our subclass implements the buffer protocol + + # all the same, characters always encode as ucs4 + expected = dict(strides=(), itemsize=8, ndim=0, shape=(), format='2w', + readonly=True) + + v = memoryview(s) + assert self._as_dict(v) == expected + + # integers of the paltform-appropriate endianness + code_points = np.frombuffer(v, dtype='i4') + + assert_equal(code_points, [ord(c) for c in s]) + + # Check that we do not allow writeable buffer export + with pytest.raises(BufferError, match="scalar buffer is readonly"): + get_buffer_info(s, ["WRITABLE"]) + + def test_user_scalar_fails_buffer(self): + r = rational(1) + with assert_raises(TypeError): + memoryview(r) + + # Check that we do not allow writeable buffer export + with pytest.raises(BufferError, match="scalar buffer is readonly"): + get_buffer_info(r, ["WRITABLE"]) diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/test_scalarinherit.py b/venv/lib/python3.12/site-packages/numpy/_core/tests/test_scalarinherit.py new file mode 100644 index 00000000..52591215 --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/tests/test_scalarinherit.py @@ -0,0 +1,105 @@ +""" Test printing of scalar types. + +""" +import pytest + +import numpy as np +from numpy.testing import assert_, assert_raises + + +class A: + pass +class B(A, np.float64): + pass + +class C(B): + pass +class D(C, B): + pass + +class B0(np.float64, A): + pass +class C0(B0): + pass + +class HasNew: + def __new__(cls, *args, **kwargs): + return cls, args, kwargs + +class B1(np.float64, HasNew): + pass + + +class TestInherit: + def test_init(self): + x = B(1.0) + assert_(str(x) == '1.0') + y = C(2.0) + assert_(str(y) == '2.0') + z = D(3.0) + assert_(str(z) == '3.0') + + def test_init2(self): + x = B0(1.0) + assert_(str(x) == '1.0') + y = C0(2.0) + assert_(str(y) == '2.0') + + def test_gh_15395(self): + # HasNew is the second base, so `np.float64` should have priority + x = B1(1.0) + assert_(str(x) == '1.0') + + # previously caused RecursionError!? + with pytest.raises(TypeError): + B1(1.0, 2.0) + + def test_int_repr(self): + # Test that integer repr works correctly for subclasses (gh-27106) + class my_int16(np.int16): + pass + + s = repr(my_int16(3)) + assert s == "my_int16(3)" + +class TestCharacter: + def test_char_radd(self): + # GH issue 9620, reached gentype_add and raise TypeError + np_s = np.bytes_('abc') + np_u = np.str_('abc') + s = b'def' + u = 'def' + assert_(np_s.__radd__(np_s) is NotImplemented) + assert_(np_s.__radd__(np_u) is NotImplemented) + assert_(np_s.__radd__(s) is NotImplemented) + assert_(np_s.__radd__(u) is NotImplemented) + assert_(np_u.__radd__(np_s) is NotImplemented) + assert_(np_u.__radd__(np_u) is NotImplemented) + assert_(np_u.__radd__(s) is NotImplemented) + assert_(np_u.__radd__(u) is NotImplemented) + assert_(s + np_s == b'defabc') + assert_(u + np_u == 'defabc') + + class MyStr(str, np.generic): + # would segfault + pass + + with assert_raises(TypeError): + # Previously worked, but gave completely wrong result + ret = s + MyStr('abc') + + class MyBytes(bytes, np.generic): + # would segfault + pass + + ret = s + MyBytes(b'abc') + assert(type(ret) is type(s)) + assert ret == b"defabc" + + def test_char_repeat(self): + np_s = np.bytes_('abc') + np_u = np.str_('abc') + res_s = b'abc' * 5 + res_u = 'abc' * 5 + assert_(np_s * 5 == res_s) + assert_(np_u * 5 == res_u) diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/test_scalarmath.py b/venv/lib/python3.12/site-packages/numpy/_core/tests/test_scalarmath.py new file mode 100644 index 00000000..af9360b9 --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/tests/test_scalarmath.py @@ -0,0 +1,1166 @@ +import contextlib +import sys +import warnings +import itertools +import operator +import platform +from numpy._utils import _pep440 +import pytest +from hypothesis import given, settings +from hypothesis.strategies import sampled_from +from hypothesis.extra import numpy as hynp + +import numpy as np +from numpy.exceptions import ComplexWarning +from numpy._core._rational_tests import rational +from numpy.testing import ( + assert_, assert_equal, assert_raises, assert_almost_equal, + assert_array_equal, IS_PYPY, suppress_warnings, _gen_alignment_data, + assert_warns, check_support_sve, + ) + +types = [np.bool, np.byte, np.ubyte, np.short, np.ushort, np.intc, np.uintc, + np.int_, np.uint, np.longlong, np.ulonglong, + np.single, np.double, np.longdouble, np.csingle, + np.cdouble, np.clongdouble] + +floating_types = np.floating.__subclasses__() +complex_floating_types = np.complexfloating.__subclasses__() + +objecty_things = [object(), None, np.array(None, dtype=object)] + +binary_operators_for_scalars = [ + operator.lt, operator.le, operator.eq, operator.ne, operator.ge, + operator.gt, operator.add, operator.floordiv, operator.mod, + operator.mul, operator.pow, operator.sub, operator.truediv +] +binary_operators_for_scalar_ints = binary_operators_for_scalars + [ + operator.xor, operator.or_, operator.and_ +] + + +# This compares scalarmath against ufuncs. + +class TestTypes: + def test_types(self): + for atype in types: + a = atype(1) + assert_(a == 1, "error with %r: got %r" % (atype, a)) + + def test_type_add(self): + # list of types + for k, atype in enumerate(types): + a_scalar = atype(3) + a_array = np.array([3], dtype=atype) + for l, btype in enumerate(types): + b_scalar = btype(1) + b_array = np.array([1], dtype=btype) + c_scalar = a_scalar + b_scalar + c_array = a_array + b_array + # It was comparing the type numbers, but the new ufunc + # function-finding mechanism finds the lowest function + # to which both inputs can be cast - which produces 'l' + # when you do 'q' + 'b'. The old function finding mechanism + # skipped ahead based on the first argument, but that + # does not produce properly symmetric results... + assert_equal(c_scalar.dtype, c_array.dtype, + "error with types (%d/'%c' + %d/'%c')" % + (k, np.dtype(atype).char, l, np.dtype(btype).char)) + + def test_type_create(self): + for k, atype in enumerate(types): + a = np.array([1, 2, 3], atype) + b = atype([1, 2, 3]) + assert_equal(a, b) + + def test_leak(self): + # test leak of scalar objects + # a leak would show up in valgrind as still-reachable of ~2.6MB + for i in range(200000): + np.add(1, 1) + + +def check_ufunc_scalar_equivalence(op, arr1, arr2): + scalar1 = arr1[()] + scalar2 = arr2[()] + assert isinstance(scalar1, np.generic) + assert isinstance(scalar2, np.generic) + + if arr1.dtype.kind == "c" or arr2.dtype.kind == "c": + comp_ops = {operator.ge, operator.gt, operator.le, operator.lt} + if op in comp_ops and (np.isnan(scalar1) or np.isnan(scalar2)): + pytest.xfail("complex comp ufuncs use sort-order, scalars do not.") + if op == operator.pow and arr2.item() in [-1, 0, 0.5, 1, 2]: + # array**scalar special case can have different result dtype + # (Other powers may have issues also, but are not hit here.) + # TODO: It would be nice to resolve this issue. + pytest.skip("array**2 can have incorrect/weird result dtype") + + # ignore fpe's since they may just mismatch for integers anyway. + with warnings.catch_warnings(), np.errstate(all="ignore"): + # Comparisons DeprecationWarnings replacing errors (2022-03): + warnings.simplefilter("error", DeprecationWarning) + try: + res = op(arr1, arr2) + except Exception as e: + with pytest.raises(type(e)): + op(scalar1, scalar2) + else: + scalar_res = op(scalar1, scalar2) + assert_array_equal(scalar_res, res, strict=True) + + +@pytest.mark.slow +@settings(max_examples=10000, deadline=2000) +@given(sampled_from(binary_operators_for_scalars), + hynp.arrays(dtype=hynp.scalar_dtypes(), shape=()), + hynp.arrays(dtype=hynp.scalar_dtypes(), shape=())) +def test_array_scalar_ufunc_equivalence(op, arr1, arr2): + """ + This is a thorough test attempting to cover important promotion paths + and ensuring that arrays and scalars stay as aligned as possible. + However, if it creates troubles, it should maybe just be removed. + """ + check_ufunc_scalar_equivalence(op, arr1, arr2) + + +@pytest.mark.slow +@given(sampled_from(binary_operators_for_scalars), + hynp.scalar_dtypes(), hynp.scalar_dtypes()) +def test_array_scalar_ufunc_dtypes(op, dt1, dt2): + # Same as above, but don't worry about sampling weird values so that we + # do not have to sample as much + arr1 = np.array(2, dtype=dt1) + arr2 = np.array(3, dtype=dt2) # some power do weird things. + + check_ufunc_scalar_equivalence(op, arr1, arr2) + + +@pytest.mark.parametrize("fscalar", [np.float16, np.float32]) +def test_int_float_promotion_truediv(fscalar): + # Promotion for mixed int and float32/float16 must not go to float64 + i = np.int8(1) + f = fscalar(1) + expected = np.result_type(i, f) + assert (i / f).dtype == expected + assert (f / i).dtype == expected + # But normal int / int true division goes to float64: + assert (i / i).dtype == np.dtype("float64") + # For int16, result has to be ast least float32 (takes ufunc path): + assert (np.int16(1) / f).dtype == np.dtype("float32") + + +class TestBaseMath: + @pytest.mark.xfail(check_support_sve(), reason="gh-22982") + def test_blocked(self): + # test alignments offsets for simd instructions + # alignments for vz + 2 * (vs - 1) + 1 + for dt, sz in [(np.float32, 11), (np.float64, 7), (np.int32, 11)]: + for out, inp1, inp2, msg in _gen_alignment_data(dtype=dt, + type='binary', + max_size=sz): + exp1 = np.ones_like(inp1) + inp1[...] = np.ones_like(inp1) + inp2[...] = np.zeros_like(inp2) + assert_almost_equal(np.add(inp1, inp2), exp1, err_msg=msg) + assert_almost_equal(np.add(inp1, 2), exp1 + 2, err_msg=msg) + assert_almost_equal(np.add(1, inp2), exp1, err_msg=msg) + + np.add(inp1, inp2, out=out) + assert_almost_equal(out, exp1, err_msg=msg) + + inp2[...] += np.arange(inp2.size, dtype=dt) + 1 + assert_almost_equal(np.square(inp2), + np.multiply(inp2, inp2), err_msg=msg) + # skip true divide for ints + if dt != np.int32: + assert_almost_equal(np.reciprocal(inp2), + np.divide(1, inp2), err_msg=msg) + + inp1[...] = np.ones_like(inp1) + np.add(inp1, 2, out=out) + assert_almost_equal(out, exp1 + 2, err_msg=msg) + inp2[...] = np.ones_like(inp2) + np.add(2, inp2, out=out) + assert_almost_equal(out, exp1 + 2, err_msg=msg) + + def test_lower_align(self): + # check data that is not aligned to element size + # i.e doubles are aligned to 4 bytes on i386 + d = np.zeros(23 * 8, dtype=np.int8)[4:-4].view(np.float64) + o = np.zeros(23 * 8, dtype=np.int8)[4:-4].view(np.float64) + assert_almost_equal(d + d, d * 2) + np.add(d, d, out=o) + np.add(np.ones_like(d), d, out=o) + np.add(d, np.ones_like(d), out=o) + np.add(np.ones_like(d), d) + np.add(d, np.ones_like(d)) + + +class TestPower: + def test_small_types(self): + for t in [np.int8, np.int16, np.float16]: + a = t(3) + b = a ** 4 + assert_(b == 81, "error with %r: got %r" % (t, b)) + + def test_large_types(self): + for t in [np.int32, np.int64, np.float32, np.float64, np.longdouble]: + a = t(51) + b = a ** 4 + msg = "error with %r: got %r" % (t, b) + if np.issubdtype(t, np.integer): + assert_(b == 6765201, msg) + else: + assert_almost_equal(b, 6765201, err_msg=msg) + + def test_integers_to_negative_integer_power(self): + # Note that the combination of uint64 with a signed integer + # has common type np.float64. The other combinations should all + # raise a ValueError for integer ** negative integer. + exp = [np.array(-1, dt)[()] for dt in 'bhilq'] + + # 1 ** -1 possible special case + base = [np.array(1, dt)[()] for dt in 'bhilqBHILQ'] + for i1, i2 in itertools.product(base, exp): + if i1.dtype != np.uint64: + assert_raises(ValueError, operator.pow, i1, i2) + else: + res = operator.pow(i1, i2) + assert_(res.dtype.type is np.float64) + assert_almost_equal(res, 1.) + + # -1 ** -1 possible special case + base = [np.array(-1, dt)[()] for dt in 'bhilq'] + for i1, i2 in itertools.product(base, exp): + if i1.dtype != np.uint64: + assert_raises(ValueError, operator.pow, i1, i2) + else: + res = operator.pow(i1, i2) + assert_(res.dtype.type is np.float64) + assert_almost_equal(res, -1.) + + # 2 ** -1 perhaps generic + base = [np.array(2, dt)[()] for dt in 'bhilqBHILQ'] + for i1, i2 in itertools.product(base, exp): + if i1.dtype != np.uint64: + assert_raises(ValueError, operator.pow, i1, i2) + else: + res = operator.pow(i1, i2) + assert_(res.dtype.type is np.float64) + assert_almost_equal(res, .5) + + def test_mixed_types(self): + typelist = [np.int8, np.int16, np.float16, + np.float32, np.float64, np.int8, + np.int16, np.int32, np.int64] + for t1 in typelist: + for t2 in typelist: + a = t1(3) + b = t2(2) + result = a**b + msg = ("error with %r and %r:" + "got %r, expected %r") % (t1, t2, result, 9) + if np.issubdtype(np.dtype(result), np.integer): + assert_(result == 9, msg) + else: + assert_almost_equal(result, 9, err_msg=msg) + + def test_modular_power(self): + # modular power is not implemented, so ensure it errors + a = 5 + b = 4 + c = 10 + expected = pow(a, b, c) # noqa: F841 + for t in (np.int32, np.float32, np.complex64): + # note that 3-operand power only dispatches on the first argument + assert_raises(TypeError, operator.pow, t(a), b, c) + assert_raises(TypeError, operator.pow, np.array(t(a)), b, c) + + +def floordiv_and_mod(x, y): + return (x // y, x % y) + + +def _signs(dt): + if dt in np.typecodes['UnsignedInteger']: + return (+1,) + else: + return (+1, -1) + + +class TestModulus: + + def test_modulus_basic(self): + dt = np.typecodes['AllInteger'] + np.typecodes['Float'] + for op in [floordiv_and_mod, divmod]: + for dt1, dt2 in itertools.product(dt, dt): + for sg1, sg2 in itertools.product(_signs(dt1), _signs(dt2)): + fmt = 'op: %s, dt1: %s, dt2: %s, sg1: %s, sg2: %s' + msg = fmt % (op.__name__, dt1, dt2, sg1, sg2) + a = np.array(sg1*71, dtype=dt1)[()] + b = np.array(sg2*19, dtype=dt2)[()] + div, rem = op(a, b) + assert_equal(div*b + rem, a, err_msg=msg) + if sg2 == -1: + assert_(b < rem <= 0, msg) + else: + assert_(b > rem >= 0, msg) + + def test_float_modulus_exact(self): + # test that float results are exact for small integers. This also + # holds for the same integers scaled by powers of two. + nlst = list(range(-127, 0)) + plst = list(range(1, 128)) + dividend = nlst + [0] + plst + divisor = nlst + plst + arg = list(itertools.product(dividend, divisor)) + tgt = list(divmod(*t) for t in arg) + + a, b = np.array(arg, dtype=int).T + # convert exact integer results from Python to float so that + # signed zero can be used, it is checked. + tgtdiv, tgtrem = np.array(tgt, dtype=float).T + tgtdiv = np.where((tgtdiv == 0.0) & ((b < 0) ^ (a < 0)), -0.0, tgtdiv) + tgtrem = np.where((tgtrem == 0.0) & (b < 0), -0.0, tgtrem) + + for op in [floordiv_and_mod, divmod]: + for dt in np.typecodes['Float']: + msg = 'op: %s, dtype: %s' % (op.__name__, dt) + fa = a.astype(dt) + fb = b.astype(dt) + # use list comprehension so a_ and b_ are scalars + div, rem = zip(*[op(a_, b_) for a_, b_ in zip(fa, fb)]) + assert_equal(div, tgtdiv, err_msg=msg) + assert_equal(rem, tgtrem, err_msg=msg) + + def test_float_modulus_roundoff(self): + # gh-6127 + dt = np.typecodes['Float'] + for op in [floordiv_and_mod, divmod]: + for dt1, dt2 in itertools.product(dt, dt): + for sg1, sg2 in itertools.product((+1, -1), (+1, -1)): + fmt = 'op: %s, dt1: %s, dt2: %s, sg1: %s, sg2: %s' + msg = fmt % (op.__name__, dt1, dt2, sg1, sg2) + a = np.array(sg1*78*6e-8, dtype=dt1)[()] + b = np.array(sg2*6e-8, dtype=dt2)[()] + div, rem = op(a, b) + # Equal assertion should hold when fmod is used + assert_equal(div*b + rem, a, err_msg=msg) + if sg2 == -1: + assert_(b < rem <= 0, msg) + else: + assert_(b > rem >= 0, msg) + + def test_float_modulus_corner_cases(self): + # Check remainder magnitude. + for dt in np.typecodes['Float']: + b = np.array(1.0, dtype=dt) + a = np.nextafter(np.array(0.0, dtype=dt), -b) + rem = operator.mod(a, b) + assert_(rem <= b, 'dt: %s' % dt) + rem = operator.mod(-a, -b) + assert_(rem >= -b, 'dt: %s' % dt) + + # Check nans, inf + with suppress_warnings() as sup: + sup.filter(RuntimeWarning, "invalid value encountered in remainder") + sup.filter(RuntimeWarning, "divide by zero encountered in remainder") + sup.filter(RuntimeWarning, "divide by zero encountered in floor_divide") + sup.filter(RuntimeWarning, "divide by zero encountered in divmod") + sup.filter(RuntimeWarning, "invalid value encountered in divmod") + for dt in np.typecodes['Float']: + fone = np.array(1.0, dtype=dt) + fzer = np.array(0.0, dtype=dt) + finf = np.array(np.inf, dtype=dt) + fnan = np.array(np.nan, dtype=dt) + rem = operator.mod(fone, fzer) + assert_(np.isnan(rem), 'dt: %s' % dt) + # MSVC 2008 returns NaN here, so disable the check. + #rem = operator.mod(fone, finf) + #assert_(rem == fone, 'dt: %s' % dt) + rem = operator.mod(fone, fnan) + assert_(np.isnan(rem), 'dt: %s' % dt) + rem = operator.mod(finf, fone) + assert_(np.isnan(rem), 'dt: %s' % dt) + for op in [floordiv_and_mod, divmod]: + div, mod = op(fone, fzer) + assert_(np.isinf(div)) and assert_(np.isnan(mod)) + + def test_inplace_floordiv_handling(self): + # issue gh-12927 + # this only applies to in-place floordiv //=, because the output type + # promotes to float which does not fit + a = np.array([1, 2], np.int64) + b = np.array([1, 2], np.uint64) + with pytest.raises(TypeError, + match=r"Cannot cast ufunc 'floor_divide' output from"): + a //= b + + +class TestComplexDivision: + def test_zero_division(self): + with np.errstate(all="ignore"): + for t in [np.complex64, np.complex128]: + a = t(0.0) + b = t(1.0) + assert_(np.isinf(b/a)) + b = t(complex(np.inf, np.inf)) + assert_(np.isinf(b/a)) + b = t(complex(np.inf, np.nan)) + assert_(np.isinf(b/a)) + b = t(complex(np.nan, np.inf)) + assert_(np.isinf(b/a)) + b = t(complex(np.nan, np.nan)) + assert_(np.isnan(b/a)) + b = t(0.) + assert_(np.isnan(b/a)) + + def test_signed_zeros(self): + with np.errstate(all="ignore"): + for t in [np.complex64, np.complex128]: + # tupled (numerator, denominator, expected) + # for testing as expected == numerator/denominator + data = ( + (( 0.0,-1.0), ( 0.0, 1.0), (-1.0,-0.0)), + (( 0.0,-1.0), ( 0.0,-1.0), ( 1.0,-0.0)), + (( 0.0,-1.0), (-0.0,-1.0), ( 1.0, 0.0)), + (( 0.0,-1.0), (-0.0, 1.0), (-1.0, 0.0)), + (( 0.0, 1.0), ( 0.0,-1.0), (-1.0, 0.0)), + (( 0.0,-1.0), ( 0.0,-1.0), ( 1.0,-0.0)), + ((-0.0,-1.0), ( 0.0,-1.0), ( 1.0,-0.0)), + ((-0.0, 1.0), ( 0.0,-1.0), (-1.0,-0.0)) + ) + for cases in data: + n = cases[0] + d = cases[1] + ex = cases[2] + result = t(complex(n[0], n[1])) / t(complex(d[0], d[1])) + # check real and imag parts separately to avoid comparison + # in array context, which does not account for signed zeros + assert_equal(result.real, ex[0]) + assert_equal(result.imag, ex[1]) + + def test_branches(self): + with np.errstate(all="ignore"): + for t in [np.complex64, np.complex128]: + # tupled (numerator, denominator, expected) + # for testing as expected == numerator/denominator + data = list() + + # trigger branch: real(fabs(denom)) > imag(fabs(denom)) + # followed by else condition as neither are == 0 + data.append((( 2.0, 1.0), ( 2.0, 1.0), (1.0, 0.0))) + + # trigger branch: real(fabs(denom)) > imag(fabs(denom)) + # followed by if condition as both are == 0 + # is performed in test_zero_division(), so this is skipped + + # trigger else if branch: real(fabs(denom)) < imag(fabs(denom)) + data.append((( 1.0, 2.0), ( 1.0, 2.0), (1.0, 0.0))) + + for cases in data: + n = cases[0] + d = cases[1] + ex = cases[2] + result = t(complex(n[0], n[1])) / t(complex(d[0], d[1])) + # check real and imag parts separately to avoid comparison + # in array context, which does not account for signed zeros + assert_equal(result.real, ex[0]) + assert_equal(result.imag, ex[1]) + + +class TestConversion: + def test_int_from_long(self): + l = [1e6, 1e12, 1e18, -1e6, -1e12, -1e18] + li = [10**6, 10**12, 10**18, -10**6, -10**12, -10**18] + for T in [None, np.float64, np.int64]: + a = np.array(l, dtype=T) + assert_equal([int(_m) for _m in a], li) + + a = np.array(l[:3], dtype=np.uint64) + assert_equal([int(_m) for _m in a], li[:3]) + + def test_iinfo_long_values(self): + for code in 'bBhH': + with pytest.raises(OverflowError): + np.array(np.iinfo(code).max + 1, dtype=code) + + for code in np.typecodes['AllInteger']: + res = np.array(np.iinfo(code).max, dtype=code) + tgt = np.iinfo(code).max + assert_(res == tgt) + + for code in np.typecodes['AllInteger']: + res = np.dtype(code).type(np.iinfo(code).max) + tgt = np.iinfo(code).max + assert_(res == tgt) + + def test_int_raise_behaviour(self): + def overflow_error_func(dtype): + dtype(np.iinfo(dtype).max + 1) + + for code in [np.int_, np.uint, np.longlong, np.ulonglong]: + assert_raises(OverflowError, overflow_error_func, code) + + def test_int_from_infinite_longdouble(self): + # gh-627 + x = np.longdouble(np.inf) + assert_raises(OverflowError, int, x) + with suppress_warnings() as sup: + sup.record(ComplexWarning) + x = np.clongdouble(np.inf) + assert_raises(OverflowError, int, x) + assert_equal(len(sup.log), 1) + + @pytest.mark.skipif(not IS_PYPY, reason="Test is PyPy only (gh-9972)") + def test_int_from_infinite_longdouble___int__(self): + x = np.longdouble(np.inf) + assert_raises(OverflowError, x.__int__) + with suppress_warnings() as sup: + sup.record(ComplexWarning) + x = np.clongdouble(np.inf) + assert_raises(OverflowError, x.__int__) + assert_equal(len(sup.log), 1) + + @pytest.mark.skipif(np.finfo(np.double) == np.finfo(np.longdouble), + reason="long double is same as double") + @pytest.mark.skipif(platform.machine().startswith("ppc"), + reason="IBM double double") + def test_int_from_huge_longdouble(self): + # Produce a longdouble that would overflow a double, + # use exponent that avoids bug in Darwin pow function. + exp = np.finfo(np.double).maxexp - 1 + huge_ld = 2 * 1234 * np.longdouble(2) ** exp + huge_i = 2 * 1234 * 2 ** exp + assert_(huge_ld != np.inf) + assert_equal(int(huge_ld), huge_i) + + def test_int_from_longdouble(self): + x = np.longdouble(1.5) + assert_equal(int(x), 1) + x = np.longdouble(-10.5) + assert_equal(int(x), -10) + + def test_numpy_scalar_relational_operators(self): + # All integer + for dt1 in np.typecodes['AllInteger']: + assert_(1 > np.array(0, dtype=dt1)[()], "type %s failed" % (dt1,)) + assert_(not 1 < np.array(0, dtype=dt1)[()], "type %s failed" % (dt1,)) + + for dt2 in np.typecodes['AllInteger']: + assert_(np.array(1, dtype=dt1)[()] > np.array(0, dtype=dt2)[()], + "type %s and %s failed" % (dt1, dt2)) + assert_(not np.array(1, dtype=dt1)[()] < np.array(0, dtype=dt2)[()], + "type %s and %s failed" % (dt1, dt2)) + + #Unsigned integers + for dt1 in 'BHILQP': + assert_(-1 < np.array(1, dtype=dt1)[()], "type %s failed" % (dt1,)) + assert_(not -1 > np.array(1, dtype=dt1)[()], "type %s failed" % (dt1,)) + assert_(-1 != np.array(1, dtype=dt1)[()], "type %s failed" % (dt1,)) + + #unsigned vs signed + for dt2 in 'bhilqp': + assert_(np.array(1, dtype=dt1)[()] > np.array(-1, dtype=dt2)[()], + "type %s and %s failed" % (dt1, dt2)) + assert_(not np.array(1, dtype=dt1)[()] < np.array(-1, dtype=dt2)[()], + "type %s and %s failed" % (dt1, dt2)) + assert_(np.array(1, dtype=dt1)[()] != np.array(-1, dtype=dt2)[()], + "type %s and %s failed" % (dt1, dt2)) + + #Signed integers and floats + for dt1 in 'bhlqp' + np.typecodes['Float']: + assert_(1 > np.array(-1, dtype=dt1)[()], "type %s failed" % (dt1,)) + assert_(not 1 < np.array(-1, dtype=dt1)[()], "type %s failed" % (dt1,)) + assert_(-1 == np.array(-1, dtype=dt1)[()], "type %s failed" % (dt1,)) + + for dt2 in 'bhlqp' + np.typecodes['Float']: + assert_(np.array(1, dtype=dt1)[()] > np.array(-1, dtype=dt2)[()], + "type %s and %s failed" % (dt1, dt2)) + assert_(not np.array(1, dtype=dt1)[()] < np.array(-1, dtype=dt2)[()], + "type %s and %s failed" % (dt1, dt2)) + assert_(np.array(-1, dtype=dt1)[()] == np.array(-1, dtype=dt2)[()], + "type %s and %s failed" % (dt1, dt2)) + + def test_scalar_comparison_to_none(self): + # Scalars should just return False and not give a warnings. + # The comparisons are flagged by pep8, ignore that. + with warnings.catch_warnings(record=True) as w: + warnings.filterwarnings('always', '', FutureWarning) + assert_(not np.float32(1) == None) + assert_(not np.str_('test') == None) + # This is dubious (see below): + assert_(not np.datetime64('NaT') == None) + + assert_(np.float32(1) != None) + assert_(np.str_('test') != None) + # This is dubious (see below): + assert_(np.datetime64('NaT') != None) + assert_(len(w) == 0) + + # For documentation purposes, this is why the datetime is dubious. + # At the time of deprecation this was no behaviour change, but + # it has to be considered when the deprecations are done. + assert_(np.equal(np.datetime64('NaT'), None)) + + +#class TestRepr: +# def test_repr(self): +# for t in types: +# val = t(1197346475.0137341) +# val_repr = repr(val) +# val2 = eval(val_repr) +# assert_equal( val, val2 ) + + +class TestRepr: + def _test_type_repr(self, t): + finfo = np.finfo(t) + last_fraction_bit_idx = finfo.nexp + finfo.nmant + last_exponent_bit_idx = finfo.nexp + storage_bytes = np.dtype(t).itemsize*8 + # could add some more types to the list below + for which in ['small denorm', 'small norm']: + # Values from https://en.wikipedia.org/wiki/IEEE_754 + constr = np.array([0x00]*storage_bytes, dtype=np.uint8) + if which == 'small denorm': + byte = last_fraction_bit_idx // 8 + bytebit = 7-(last_fraction_bit_idx % 8) + constr[byte] = 1 << bytebit + elif which == 'small norm': + byte = last_exponent_bit_idx // 8 + bytebit = 7-(last_exponent_bit_idx % 8) + constr[byte] = 1 << bytebit + else: + raise ValueError('hmm') + val = constr.view(t)[0] + val_repr = repr(val) + val2 = t(eval(val_repr)) + if not (val2 == 0 and val < 1e-100): + assert_equal(val, val2) + + def test_float_repr(self): + # long double test cannot work, because eval goes through a python + # float + for t in [np.float32, np.float64]: + self._test_type_repr(t) + + +if not IS_PYPY: + # sys.getsizeof() is not valid on PyPy + class TestSizeOf: + + def test_equal_nbytes(self): + for type in types: + x = type(0) + assert_(sys.getsizeof(x) > x.nbytes) + + def test_error(self): + d = np.float32() + assert_raises(TypeError, d.__sizeof__, "a") + + +class TestMultiply: + def test_seq_repeat(self): + # Test that basic sequences get repeated when multiplied with + # numpy integers. And errors are raised when multiplied with others. + # Some of this behaviour may be controversial and could be open for + # change. + accepted_types = set(np.typecodes["AllInteger"]) + deprecated_types = {'?'} + forbidden_types = ( + set(np.typecodes["All"]) - accepted_types - deprecated_types) + forbidden_types -= {'V'} # can't default-construct void scalars + + for seq_type in (list, tuple): + seq = seq_type([1, 2, 3]) + for numpy_type in accepted_types: + i = np.dtype(numpy_type).type(2) + assert_equal(seq * i, seq * int(i)) + assert_equal(i * seq, int(i) * seq) + + for numpy_type in deprecated_types: + i = np.dtype(numpy_type).type() + assert_equal( + assert_warns(DeprecationWarning, operator.mul, seq, i), + seq * int(i)) + assert_equal( + assert_warns(DeprecationWarning, operator.mul, i, seq), + int(i) * seq) + + for numpy_type in forbidden_types: + i = np.dtype(numpy_type).type() + assert_raises(TypeError, operator.mul, seq, i) + assert_raises(TypeError, operator.mul, i, seq) + + def test_no_seq_repeat_basic_array_like(self): + # Test that an array-like which does not know how to be multiplied + # does not attempt sequence repeat (raise TypeError). + # See also gh-7428. + class ArrayLike: + def __init__(self, arr): + self.arr = arr + + def __array__(self, dtype=None, copy=None): + return self.arr + + # Test for simple ArrayLike above and memoryviews (original report) + for arr_like in (ArrayLike(np.ones(3)), memoryview(np.ones(3))): + assert_array_equal(arr_like * np.float32(3.), np.full(3, 3.)) + assert_array_equal(np.float32(3.) * arr_like, np.full(3, 3.)) + assert_array_equal(arr_like * np.int_(3), np.full(3, 3)) + assert_array_equal(np.int_(3) * arr_like, np.full(3, 3)) + + +class TestNegative: + def test_exceptions(self): + a = np.ones((), dtype=np.bool)[()] + assert_raises(TypeError, operator.neg, a) + + def test_result(self): + types = np.typecodes['AllInteger'] + np.typecodes['AllFloat'] + with suppress_warnings() as sup: + sup.filter(RuntimeWarning) + for dt in types: + a = np.ones((), dtype=dt)[()] + if dt in np.typecodes['UnsignedInteger']: + st = np.dtype(dt).type + max = st(np.iinfo(dt).max) + assert_equal(operator.neg(a), max) + else: + assert_equal(operator.neg(a) + a, 0) + +class TestSubtract: + def test_exceptions(self): + a = np.ones((), dtype=np.bool)[()] + assert_raises(TypeError, operator.sub, a, a) + + def test_result(self): + types = np.typecodes['AllInteger'] + np.typecodes['AllFloat'] + with suppress_warnings() as sup: + sup.filter(RuntimeWarning) + for dt in types: + a = np.ones((), dtype=dt)[()] + assert_equal(operator.sub(a, a), 0) + + +class TestAbs: + def _test_abs_func(self, absfunc, test_dtype): + x = test_dtype(-1.5) + assert_equal(absfunc(x), 1.5) + x = test_dtype(0.0) + res = absfunc(x) + # assert_equal() checks zero signedness + assert_equal(res, 0.0) + x = test_dtype(-0.0) + res = absfunc(x) + assert_equal(res, 0.0) + + x = test_dtype(np.finfo(test_dtype).max) + assert_equal(absfunc(x), x.real) + + with suppress_warnings() as sup: + sup.filter(UserWarning) + x = test_dtype(np.finfo(test_dtype).tiny) + assert_equal(absfunc(x), x.real) + + x = test_dtype(np.finfo(test_dtype).min) + assert_equal(absfunc(x), -x.real) + + @pytest.mark.parametrize("dtype", floating_types + complex_floating_types) + def test_builtin_abs(self, dtype): + if ( + sys.platform == "cygwin" and dtype == np.clongdouble and + ( + _pep440.parse(platform.release().split("-")[0]) + < _pep440.Version("3.3.0") + ) + ): + pytest.xfail( + reason="absl is computed in double precision on cygwin < 3.3" + ) + self._test_abs_func(abs, dtype) + + @pytest.mark.parametrize("dtype", floating_types + complex_floating_types) + def test_numpy_abs(self, dtype): + if ( + sys.platform == "cygwin" and dtype == np.clongdouble and + ( + _pep440.parse(platform.release().split("-")[0]) + < _pep440.Version("3.3.0") + ) + ): + pytest.xfail( + reason="absl is computed in double precision on cygwin < 3.3" + ) + self._test_abs_func(np.abs, dtype) + +class TestBitShifts: + + @pytest.mark.parametrize('type_code', np.typecodes['AllInteger']) + @pytest.mark.parametrize('op', + [operator.rshift, operator.lshift], ids=['>>', '<<']) + def test_shift_all_bits(self, type_code, op): + """Shifts where the shift amount is the width of the type or wider """ + # gh-2449 + dt = np.dtype(type_code) + nbits = dt.itemsize * 8 + for val in [5, -5]: + for shift in [nbits, nbits + 4]: + val_scl = np.array(val).astype(dt)[()] + shift_scl = dt.type(shift) + res_scl = op(val_scl, shift_scl) + if val_scl < 0 and op is operator.rshift: + # sign bit is preserved + assert_equal(res_scl, -1) + else: + assert_equal(res_scl, 0) + + # Result on scalars should be the same as on arrays + val_arr = np.array([val_scl]*32, dtype=dt) + shift_arr = np.array([shift]*32, dtype=dt) + res_arr = op(val_arr, shift_arr) + assert_equal(res_arr, res_scl) + + +class TestHash: + @pytest.mark.parametrize("type_code", np.typecodes['AllInteger']) + def test_integer_hashes(self, type_code): + scalar = np.dtype(type_code).type + for i in range(128): + assert hash(i) == hash(scalar(i)) + + @pytest.mark.parametrize("type_code", np.typecodes['AllFloat']) + def test_float_and_complex_hashes(self, type_code): + scalar = np.dtype(type_code).type + for val in [np.pi, np.inf, 3, 6.]: + numpy_val = scalar(val) + # Cast back to Python, in case the NumPy scalar has less precision + if numpy_val.dtype.kind == 'c': + val = complex(numpy_val) + else: + val = float(numpy_val) + assert val == numpy_val + assert hash(val) == hash(numpy_val) + + if hash(float(np.nan)) != hash(float(np.nan)): + # If Python distinguishes different NaNs we do so too (gh-18833) + assert hash(scalar(np.nan)) != hash(scalar(np.nan)) + + @pytest.mark.parametrize("type_code", np.typecodes['Complex']) + def test_complex_hashes(self, type_code): + # Test some complex valued hashes specifically: + scalar = np.dtype(type_code).type + for val in [np.pi+1j, np.inf-3j, 3j, 6.+1j]: + numpy_val = scalar(val) + assert hash(complex(numpy_val)) == hash(numpy_val) + + +@contextlib.contextmanager +def recursionlimit(n): + o = sys.getrecursionlimit() + try: + sys.setrecursionlimit(n) + yield + finally: + sys.setrecursionlimit(o) + + +@given(sampled_from(objecty_things), + sampled_from(binary_operators_for_scalar_ints), + sampled_from(types + [rational])) +def test_operator_object_left(o, op, type_): + try: + with recursionlimit(200): + op(o, type_(1)) + except TypeError: + pass + + +@given(sampled_from(objecty_things), + sampled_from(binary_operators_for_scalar_ints), + sampled_from(types + [rational])) +def test_operator_object_right(o, op, type_): + try: + with recursionlimit(200): + op(type_(1), o) + except TypeError: + pass + + +@given(sampled_from(binary_operators_for_scalars), + sampled_from(types), + sampled_from(types)) +def test_operator_scalars(op, type1, type2): + try: + op(type1(1), type2(1)) + except TypeError: + pass + + +@pytest.mark.parametrize("op", binary_operators_for_scalars) +@pytest.mark.parametrize("sctype", [np.longdouble, np.clongdouble]) +def test_longdouble_operators_with_obj(sctype, op): + # This is/used to be tricky, because NumPy generally falls back to + # using the ufunc via `np.asarray()`, this effectively might do: + # longdouble + None + # -> asarray(longdouble) + np.array(None, dtype=object) + # -> asarray(longdouble).astype(object) + np.array(None, dtype=object) + # And after getting the scalars in the inner loop: + # -> longdouble + None + # + # That would recurse infinitely. Other scalars return the python object + # on cast, so this type of things works OK. + # + # As of NumPy 2.1, this has been consolidated into the np.generic binops + # and now checks `.item()`. That also allows the below path to work now. + try: + op(sctype(3), None) + except TypeError: + pass + try: + op(None, sctype(3)) + except TypeError: + pass + + +@pytest.mark.parametrize("op", [operator.add, operator.pow, operator.sub]) +@pytest.mark.parametrize("sctype", [np.longdouble, np.clongdouble]) +def test_longdouble_with_arrlike(sctype, op): + # As of NumPy 2.1, longdouble behaves like other types and can coerce + # e.g. lists. (Not necessarily better, but consistent.) + assert_array_equal(op(sctype(3), [1, 2]), op(3, np.array([1, 2]))) + assert_array_equal(op([1, 2], sctype(3)), op(np.array([1, 2]), 3)) + + +@pytest.mark.parametrize("op", binary_operators_for_scalars) +@pytest.mark.parametrize("sctype", [np.longdouble, np.clongdouble]) +@np.errstate(all="ignore") +def test_longdouble_operators_with_large_int(sctype, op): + # (See `test_longdouble_operators_with_obj` for why longdouble is special) + # NEP 50 means that the result is clearly a (c)longdouble here: + if sctype == np.clongdouble and op in [operator.mod, operator.floordiv]: + # The above operators are not support for complex though... + with pytest.raises(TypeError): + op(sctype(3), 2**64) + with pytest.raises(TypeError): + op(sctype(3), 2**64) + else: + assert op(sctype(3), -2**64) == op(sctype(3), sctype(-2**64)) + assert op(2**64, sctype(3)) == op(sctype(2**64), sctype(3)) + + +@pytest.mark.parametrize("dtype", np.typecodes["AllInteger"]) +@pytest.mark.parametrize("operation", [ + lambda min, max: max + max, + lambda min, max: min - max, + lambda min, max: max * max], ids=["+", "-", "*"]) +def test_scalar_integer_operation_overflow(dtype, operation): + st = np.dtype(dtype).type + min = st(np.iinfo(dtype).min) + max = st(np.iinfo(dtype).max) + + with pytest.warns(RuntimeWarning, match="overflow encountered"): + operation(min, max) + + +@pytest.mark.parametrize("dtype", np.typecodes["Integer"]) +@pytest.mark.parametrize("operation", [ + lambda min, neg_1: -min, + lambda min, neg_1: abs(min), + lambda min, neg_1: min * neg_1, + pytest.param(lambda min, neg_1: min // neg_1, + marks=pytest.mark.skip(reason="broken on some platforms"))], + ids=["neg", "abs", "*", "//"]) +def test_scalar_signed_integer_overflow(dtype, operation): + # The minimum signed integer can "overflow" for some additional operations + st = np.dtype(dtype).type + min = st(np.iinfo(dtype).min) + neg_1 = st(-1) + + with pytest.warns(RuntimeWarning, match="overflow encountered"): + operation(min, neg_1) + + +@pytest.mark.parametrize("dtype", np.typecodes["UnsignedInteger"]) +def test_scalar_unsigned_integer_overflow(dtype): + val = np.dtype(dtype).type(8) + with pytest.warns(RuntimeWarning, match="overflow encountered"): + -val + + zero = np.dtype(dtype).type(0) + -zero # does not warn + +@pytest.mark.parametrize("dtype", np.typecodes["AllInteger"]) +@pytest.mark.parametrize("operation", [ + lambda val, zero: val // zero, + lambda val, zero: val % zero, ], ids=["//", "%"]) +def test_scalar_integer_operation_divbyzero(dtype, operation): + st = np.dtype(dtype).type + val = st(100) + zero = st(0) + + with pytest.warns(RuntimeWarning, match="divide by zero"): + operation(val, zero) + + +ops_with_names = [ + ("__lt__", "__gt__", operator.lt, True), + ("__le__", "__ge__", operator.le, True), + ("__eq__", "__eq__", operator.eq, True), + # Note __op__ and __rop__ may be identical here: + ("__ne__", "__ne__", operator.ne, True), + ("__gt__", "__lt__", operator.gt, True), + ("__ge__", "__le__", operator.ge, True), + ("__floordiv__", "__rfloordiv__", operator.floordiv, False), + ("__truediv__", "__rtruediv__", operator.truediv, False), + ("__add__", "__radd__", operator.add, False), + ("__mod__", "__rmod__", operator.mod, False), + ("__mul__", "__rmul__", operator.mul, False), + ("__pow__", "__rpow__", operator.pow, False), + ("__sub__", "__rsub__", operator.sub, False), +] + + +@pytest.mark.parametrize(["__op__", "__rop__", "op", "cmp"], ops_with_names) +@pytest.mark.parametrize("sctype", [np.float32, np.float64, np.longdouble]) +def test_subclass_deferral(sctype, __op__, __rop__, op, cmp): + """ + This test covers scalar subclass deferral. Note that this is exceedingly + complicated, especially since it tends to fall back to the array paths and + these additionally add the "array priority" mechanism. + + The behaviour was modified subtly in 1.22 (to make it closer to how Python + scalars work). Due to its complexity and the fact that subclassing NumPy + scalars is probably a bad idea to begin with. There is probably room + for adjustments here. + """ + class myf_simple1(sctype): + pass + + class myf_simple2(sctype): + pass + + def op_func(self, other): + return __op__ + + def rop_func(self, other): + return __rop__ + + myf_op = type("myf_op", (sctype,), {__op__: op_func, __rop__: rop_func}) + + # inheritance has to override, or this is correctly lost: + res = op(myf_simple1(1), myf_simple2(2)) + assert type(res) == sctype or type(res) == np.bool + assert op(myf_simple1(1), myf_simple2(2)) == op(1, 2) # inherited + + # Two independent subclasses do not really define an order. This could + # be attempted, but we do not since Python's `int` does neither: + assert op(myf_op(1), myf_simple1(2)) == __op__ + assert op(myf_simple1(1), myf_op(2)) == op(1, 2) # inherited + + +def test_longdouble_complex(): + # Simple test to check longdouble and complex combinations, since these + # need to go through promotion, which longdouble needs to be careful about. + x = np.longdouble(1) + assert x + 1j == 1+1j + assert 1j + x == 1+1j + + +@pytest.mark.parametrize(["__op__", "__rop__", "op", "cmp"], ops_with_names) +@pytest.mark.parametrize("subtype", [float, int, complex, np.float16]) +@np._no_nep50_warning() +def test_pyscalar_subclasses(subtype, __op__, __rop__, op, cmp): + # This tests that python scalar subclasses behave like a float64 (if they + # don't override it). + # In an earlier version of NEP 50, they behaved like the Python buildins. + def op_func(self, other): + return __op__ + + def rop_func(self, other): + return __rop__ + + # Check that deferring is indicated using `__array_ufunc__`: + myt = type("myt", (subtype,), + {__op__: op_func, __rop__: rop_func, "__array_ufunc__": None}) + + # Just like normally, we should never presume we can modify the float. + assert op(myt(1), np.float64(2)) == __op__ + assert op(np.float64(1), myt(2)) == __rop__ + + if op in {operator.mod, operator.floordiv} and subtype == complex: + return # module is not support for complex. Do not test. + + if __rop__ == __op__: + return + + # When no deferring is indicated, subclasses are handled normally. + myt = type("myt", (subtype,), {__rop__: rop_func}) + behaves_like = lambda x: np.array(subtype(x))[()] + + # Check for float32, as a float subclass float64 may behave differently + res = op(myt(1), np.float16(2)) + expected = op(behaves_like(1), np.float16(2)) + assert res == expected + assert type(res) == type(expected) + res = op(np.float32(2), myt(1)) + expected = op(np.float32(2), behaves_like(1)) + assert res == expected + assert type(res) == type(expected) + + # Same check for longdouble (compare via dtype to accept float64 when + # longdouble has the identical size), which is currently not perfectly + # consistent. + res = op(myt(1), np.longdouble(2)) + expected = op(behaves_like(1), np.longdouble(2)) + assert res == expected + assert np.dtype(type(res)) == np.dtype(type(expected)) + res = op(np.float32(2), myt(1)) + expected = op(np.float32(2), behaves_like(1)) + assert res == expected + assert np.dtype(type(res)) == np.dtype(type(expected)) + + +def test_truediv_int(): + # This should work, as the result is float: + assert np.uint8(3) / 123454 == np.float64(3) / 123454 + + +@pytest.mark.slow +@pytest.mark.parametrize("op", + # TODO: Power is a bit special, but here mostly bools seem to behave oddly + [op for op in binary_operators_for_scalars if op is not operator.pow]) +@pytest.mark.parametrize("sctype", types) +@pytest.mark.parametrize("other_type", [float, int, complex]) +@pytest.mark.parametrize("rop", [True, False]) +def test_scalar_matches_array_op_with_pyscalar(op, sctype, other_type, rop): + # Check that the ufunc path matches by coercing to an array explicitly + val1 = sctype(2) + val2 = other_type(2) + + if rop: + _op = op + op = lambda x, y: _op(y, x) + + try: + res = op(val1, val2) + except TypeError: + try: + expected = op(np.asarray(val1), val2) + raise AssertionError("ufunc didn't raise.") + except TypeError: + return + else: + expected = op(np.asarray(val1), val2) + + # Note that we only check dtype equivalency, as ufuncs may pick the lower + # dtype if they are equivalent. + assert res == expected + if isinstance(val1, float) and other_type is complex and rop: + # Python complex accepts float subclasses, so we don't get a chance + # and the result may be a Python complelx (thus, the `np.array()``) + assert np.array(res).dtype == expected.dtype + else: + assert res.dtype == expected.dtype diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/test_scalarprint.py b/venv/lib/python3.12/site-packages/numpy/_core/tests/test_scalarprint.py new file mode 100644 index 00000000..f47542ef --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/tests/test_scalarprint.py @@ -0,0 +1,382 @@ +""" Test printing of scalar types. + +""" +import code +import platform +import pytest +import sys + +from tempfile import TemporaryFile +import numpy as np +from numpy.testing import assert_, assert_equal, assert_raises, IS_MUSL + +class TestRealScalars: + def test_str(self): + svals = [0.0, -0.0, 1, -1, np.inf, -np.inf, np.nan] + styps = [np.float16, np.float32, np.float64, np.longdouble] + wanted = [ + ['0.0', '0.0', '0.0', '0.0' ], + ['-0.0', '-0.0', '-0.0', '-0.0'], + ['1.0', '1.0', '1.0', '1.0' ], + ['-1.0', '-1.0', '-1.0', '-1.0'], + ['inf', 'inf', 'inf', 'inf' ], + ['-inf', '-inf', '-inf', '-inf'], + ['nan', 'nan', 'nan', 'nan']] + + for wants, val in zip(wanted, svals): + for want, styp in zip(wants, styps): + msg = 'for str({}({}))'.format(np.dtype(styp).name, repr(val)) + assert_equal(str(styp(val)), want, err_msg=msg) + + def test_scalar_cutoffs(self): + # test that both the str and repr of np.float64 behaves + # like python floats in python3. + def check(v): + assert_equal(str(np.float64(v)), str(v)) + assert_equal(str(np.float64(v)), repr(v)) + assert_equal(repr(np.float64(v)), f"np.float64({v!r})") + assert_equal(repr(np.float64(v)), f"np.float64({v})") + + # check we use the same number of significant digits + check(1.12345678901234567890) + check(0.0112345678901234567890) + + # check switch from scientific output to positional and back + check(1e-5) + check(1e-4) + check(1e15) + check(1e16) + + def test_py2_float_print(self): + # gh-10753 + # In python2, the python float type implements an obsolete method + # tp_print, which overrides tp_repr and tp_str when using "print" to + # output to a "real file" (ie, not a StringIO). Make sure we don't + # inherit it. + x = np.double(0.1999999999999) + with TemporaryFile('r+t') as f: + print(x, file=f) + f.seek(0) + output = f.read() + assert_equal(output, str(x) + '\n') + # In python2 the value float('0.1999999999999') prints with reduced + # precision as '0.2', but we want numpy's np.double('0.1999999999999') + # to print the unique value, '0.1999999999999'. + + # gh-11031 + # Only in the python2 interactive shell and when stdout is a "real" + # file, the output of the last command is printed to stdout without + # Py_PRINT_RAW (unlike the print statement) so `>>> x` and `>>> print + # x` are potentially different. Make sure they are the same. The only + # way I found to get prompt-like output is using an actual prompt from + # the 'code' module. Again, must use tempfile to get a "real" file. + + # dummy user-input which enters one line and then ctrl-Ds. + def userinput(): + yield 'np.sqrt(2)' + raise EOFError + gen = userinput() + input_func = lambda prompt="": next(gen) + + with TemporaryFile('r+t') as fo, TemporaryFile('r+t') as fe: + orig_stdout, orig_stderr = sys.stdout, sys.stderr + sys.stdout, sys.stderr = fo, fe + + code.interact(local={'np': np}, readfunc=input_func, banner='') + + sys.stdout, sys.stderr = orig_stdout, orig_stderr + + fo.seek(0) + capture = fo.read().strip() + + assert_equal(capture, repr(np.sqrt(2))) + + def test_dragon4(self): + # these tests are adapted from Ryan Juckett's dragon4 implementation, + # see dragon4.c for details. + + fpos32 = lambda x, **k: np.format_float_positional(np.float32(x), **k) + fsci32 = lambda x, **k: np.format_float_scientific(np.float32(x), **k) + fpos64 = lambda x, **k: np.format_float_positional(np.float64(x), **k) + fsci64 = lambda x, **k: np.format_float_scientific(np.float64(x), **k) + + preckwd = lambda prec: {'unique': False, 'precision': prec} + + assert_equal(fpos32('1.0'), "1.") + assert_equal(fsci32('1.0'), "1.e+00") + assert_equal(fpos32('10.234'), "10.234") + assert_equal(fpos32('-10.234'), "-10.234") + assert_equal(fsci32('10.234'), "1.0234e+01") + assert_equal(fsci32('-10.234'), "-1.0234e+01") + assert_equal(fpos32('1000.0'), "1000.") + assert_equal(fpos32('1.0', precision=0), "1.") + assert_equal(fsci32('1.0', precision=0), "1.e+00") + assert_equal(fpos32('10.234', precision=0), "10.") + assert_equal(fpos32('-10.234', precision=0), "-10.") + assert_equal(fsci32('10.234', precision=0), "1.e+01") + assert_equal(fsci32('-10.234', precision=0), "-1.e+01") + assert_equal(fpos32('10.234', precision=2), "10.23") + assert_equal(fsci32('-10.234', precision=2), "-1.02e+01") + assert_equal(fsci64('9.9999999999999995e-08', **preckwd(16)), + '9.9999999999999995e-08') + assert_equal(fsci64('9.8813129168249309e-324', **preckwd(16)), + '9.8813129168249309e-324') + assert_equal(fsci64('9.9999999999999694e-311', **preckwd(16)), + '9.9999999999999694e-311') + + + # test rounding + # 3.1415927410 is closest float32 to np.pi + assert_equal(fpos32('3.14159265358979323846', **preckwd(10)), + "3.1415927410") + assert_equal(fsci32('3.14159265358979323846', **preckwd(10)), + "3.1415927410e+00") + assert_equal(fpos64('3.14159265358979323846', **preckwd(10)), + "3.1415926536") + assert_equal(fsci64('3.14159265358979323846', **preckwd(10)), + "3.1415926536e+00") + # 299792448 is closest float32 to 299792458 + assert_equal(fpos32('299792458.0', **preckwd(5)), "299792448.00000") + assert_equal(fsci32('299792458.0', **preckwd(5)), "2.99792e+08") + assert_equal(fpos64('299792458.0', **preckwd(5)), "299792458.00000") + assert_equal(fsci64('299792458.0', **preckwd(5)), "2.99792e+08") + + assert_equal(fpos32('3.14159265358979323846', **preckwd(25)), + "3.1415927410125732421875000") + assert_equal(fpos64('3.14159265358979323846', **preckwd(50)), + "3.14159265358979311599796346854418516159057617187500") + assert_equal(fpos64('3.14159265358979323846'), "3.141592653589793") + + + # smallest numbers + assert_equal(fpos32(0.5**(126 + 23), unique=False, precision=149), + "0.00000000000000000000000000000000000000000000140129846432" + "4817070923729583289916131280261941876515771757068283889791" + "08268586060148663818836212158203125") + + assert_equal(fpos64(5e-324, unique=False, precision=1074), + "0.00000000000000000000000000000000000000000000000000000000" + "0000000000000000000000000000000000000000000000000000000000" + "0000000000000000000000000000000000000000000000000000000000" + "0000000000000000000000000000000000000000000000000000000000" + "0000000000000000000000000000000000000000000000000000000000" + "0000000000000000000000000000000000049406564584124654417656" + "8792868221372365059802614324764425585682500675507270208751" + "8652998363616359923797965646954457177309266567103559397963" + "9877479601078187812630071319031140452784581716784898210368" + "8718636056998730723050006387409153564984387312473397273169" + "6151400317153853980741262385655911710266585566867681870395" + "6031062493194527159149245532930545654440112748012970999954" + "1931989409080416563324524757147869014726780159355238611550" + "1348035264934720193790268107107491703332226844753335720832" + "4319360923828934583680601060115061698097530783422773183292" + "4790498252473077637592724787465608477820373446969953364701" + "7972677717585125660551199131504891101451037862738167250955" + "8373897335989936648099411642057026370902792427675445652290" + "87538682506419718265533447265625") + + # largest numbers + f32x = np.finfo(np.float32).max + assert_equal(fpos32(f32x, **preckwd(0)), + "340282346638528859811704183484516925440.") + assert_equal(fpos64(np.finfo(np.float64).max, **preckwd(0)), + "1797693134862315708145274237317043567980705675258449965989" + "1747680315726078002853876058955863276687817154045895351438" + "2464234321326889464182768467546703537516986049910576551282" + "0762454900903893289440758685084551339423045832369032229481" + "6580855933212334827479782620414472316873817718091929988125" + "0404026184124858368.") + # Warning: In unique mode only the integer digits necessary for + # uniqueness are computed, the rest are 0. + assert_equal(fpos32(f32x), + "340282350000000000000000000000000000000.") + + # Further tests of zero-padding vs rounding in different combinations + # of unique, fractional, precision, min_digits + # precision can only reduce digits, not add them. + # min_digits can only extend digits, not reduce them. + assert_equal(fpos32(f32x, unique=True, fractional=True, precision=0), + "340282350000000000000000000000000000000.") + assert_equal(fpos32(f32x, unique=True, fractional=True, precision=4), + "340282350000000000000000000000000000000.") + assert_equal(fpos32(f32x, unique=True, fractional=True, min_digits=0), + "340282346638528859811704183484516925440.") + assert_equal(fpos32(f32x, unique=True, fractional=True, min_digits=4), + "340282346638528859811704183484516925440.0000") + assert_equal(fpos32(f32x, unique=True, fractional=True, + min_digits=4, precision=4), + "340282346638528859811704183484516925440.0000") + assert_raises(ValueError, fpos32, f32x, unique=True, fractional=False, + precision=0) + assert_equal(fpos32(f32x, unique=True, fractional=False, precision=4), + "340300000000000000000000000000000000000.") + assert_equal(fpos32(f32x, unique=True, fractional=False, precision=20), + "340282350000000000000000000000000000000.") + assert_equal(fpos32(f32x, unique=True, fractional=False, min_digits=4), + "340282350000000000000000000000000000000.") + assert_equal(fpos32(f32x, unique=True, fractional=False, + min_digits=20), + "340282346638528859810000000000000000000.") + assert_equal(fpos32(f32x, unique=True, fractional=False, + min_digits=15), + "340282346638529000000000000000000000000.") + assert_equal(fpos32(f32x, unique=False, fractional=False, precision=4), + "340300000000000000000000000000000000000.") + # test that unique rounding is preserved when precision is supplied + # but no extra digits need to be printed (gh-18609) + a = np.float64.fromhex('-1p-97') + assert_equal(fsci64(a, unique=True), '-6.310887241768095e-30') + assert_equal(fsci64(a, unique=False, precision=15), + '-6.310887241768094e-30') + assert_equal(fsci64(a, unique=True, precision=15), + '-6.310887241768095e-30') + assert_equal(fsci64(a, unique=True, min_digits=15), + '-6.310887241768095e-30') + assert_equal(fsci64(a, unique=True, precision=15, min_digits=15), + '-6.310887241768095e-30') + # adds/remove digits in unique mode with unbiased rnding + assert_equal(fsci64(a, unique=True, precision=14), + '-6.31088724176809e-30') + assert_equal(fsci64(a, unique=True, min_digits=16), + '-6.3108872417680944e-30') + assert_equal(fsci64(a, unique=True, precision=16), + '-6.310887241768095e-30') + assert_equal(fsci64(a, unique=True, min_digits=14), + '-6.310887241768095e-30') + # test min_digits in unique mode with different rounding cases + assert_equal(fsci64('1e120', min_digits=3), '1.000e+120') + assert_equal(fsci64('1e100', min_digits=3), '1.000e+100') + + # test trailing zeros + assert_equal(fpos32('1.0', unique=False, precision=3), "1.000") + assert_equal(fpos64('1.0', unique=False, precision=3), "1.000") + assert_equal(fsci32('1.0', unique=False, precision=3), "1.000e+00") + assert_equal(fsci64('1.0', unique=False, precision=3), "1.000e+00") + assert_equal(fpos32('1.5', unique=False, precision=3), "1.500") + assert_equal(fpos64('1.5', unique=False, precision=3), "1.500") + assert_equal(fsci32('1.5', unique=False, precision=3), "1.500e+00") + assert_equal(fsci64('1.5', unique=False, precision=3), "1.500e+00") + # gh-10713 + assert_equal(fpos64('324', unique=False, precision=5, + fractional=False), "324.00") + + def test_dragon4_interface(self): + tps = [np.float16, np.float32, np.float64] + # test is flaky for musllinux on np.float128 + if hasattr(np, 'float128') and not IS_MUSL: + tps.append(np.float128) + + fpos = np.format_float_positional + fsci = np.format_float_scientific + + for tp in tps: + # test padding + assert_equal(fpos(tp('1.0'), pad_left=4, pad_right=4), " 1. ") + assert_equal(fpos(tp('-1.0'), pad_left=4, pad_right=4), " -1. ") + assert_equal(fpos(tp('-10.2'), + pad_left=4, pad_right=4), " -10.2 ") + + # test exp_digits + assert_equal(fsci(tp('1.23e1'), exp_digits=5), "1.23e+00001") + + # test fixed (non-unique) mode + assert_equal(fpos(tp('1.0'), unique=False, precision=4), "1.0000") + assert_equal(fsci(tp('1.0'), unique=False, precision=4), + "1.0000e+00") + + # test trimming + # trim of 'k' or '.' only affects non-unique mode, since unique + # mode will not output trailing 0s. + assert_equal(fpos(tp('1.'), unique=False, precision=4, trim='k'), + "1.0000") + + assert_equal(fpos(tp('1.'), unique=False, precision=4, trim='.'), + "1.") + assert_equal(fpos(tp('1.2'), unique=False, precision=4, trim='.'), + "1.2" if tp != np.float16 else "1.2002") + + assert_equal(fpos(tp('1.'), unique=False, precision=4, trim='0'), + "1.0") + assert_equal(fpos(tp('1.2'), unique=False, precision=4, trim='0'), + "1.2" if tp != np.float16 else "1.2002") + assert_equal(fpos(tp('1.'), trim='0'), "1.0") + + assert_equal(fpos(tp('1.'), unique=False, precision=4, trim='-'), + "1") + assert_equal(fpos(tp('1.2'), unique=False, precision=4, trim='-'), + "1.2" if tp != np.float16 else "1.2002") + assert_equal(fpos(tp('1.'), trim='-'), "1") + assert_equal(fpos(tp('1.001'), precision=1, trim='-'), "1") + + @pytest.mark.skipif(not platform.machine().startswith("ppc64"), + reason="only applies to ppc float128 values") + def test_ppc64_ibm_double_double128(self): + # check that the precision decreases once we get into the subnormal + # range. Unlike float64, this starts around 1e-292 instead of 1e-308, + # which happens when the first double is normal and the second is + # subnormal. + x = np.float128('2.123123123123123123123123123123123e-286') + got = [str(x/np.float128('2e' + str(i))) for i in range(0,40)] + expected = [ + "1.06156156156156156156156156156157e-286", + "1.06156156156156156156156156156158e-287", + "1.06156156156156156156156156156159e-288", + "1.0615615615615615615615615615616e-289", + "1.06156156156156156156156156156157e-290", + "1.06156156156156156156156156156156e-291", + "1.0615615615615615615615615615616e-292", + "1.0615615615615615615615615615615e-293", + "1.061561561561561561561561561562e-294", + "1.06156156156156156156156156155e-295", + "1.0615615615615615615615615616e-296", + "1.06156156156156156156156156e-297", + "1.06156156156156156156156157e-298", + "1.0615615615615615615615616e-299", + "1.06156156156156156156156e-300", + "1.06156156156156156156155e-301", + "1.0615615615615615615616e-302", + "1.061561561561561561562e-303", + "1.06156156156156156156e-304", + "1.0615615615615615618e-305", + "1.06156156156156156e-306", + "1.06156156156156157e-307", + "1.0615615615615616e-308", + "1.06156156156156e-309", + "1.06156156156157e-310", + "1.0615615615616e-311", + "1.06156156156e-312", + "1.06156156154e-313", + "1.0615615616e-314", + "1.06156156e-315", + "1.06156155e-316", + "1.061562e-317", + "1.06156e-318", + "1.06155e-319", + "1.0617e-320", + "1.06e-321", + "1.04e-322", + "1e-323", + "0.0", + "0.0"] + assert_equal(got, expected) + + # Note: we follow glibc behavior, but it (or gcc) might not be right. + # In particular we can get two values that print the same but are not + # equal: + a = np.float128('2')/np.float128('3') + b = np.float128(str(a)) + assert_equal(str(a), str(b)) + assert_(a != b) + + def float32_roundtrip(self): + # gh-9360 + x = np.float32(1024 - 2**-14) + y = np.float32(1024 - 2**-13) + assert_(repr(x) != repr(y)) + assert_equal(np.float32(repr(x)), x) + assert_equal(np.float32(repr(y)), y) + + def float64_vs_python(self): + # gh-2643, gh-6136, gh-6908 + assert_equal(repr(np.float64(0.1)), repr(0.1)) + assert_(repr(np.float64(0.20000000000000004)) != repr(0.2)) diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/test_shape_base.py b/venv/lib/python3.12/site-packages/numpy/_core/tests/test_shape_base.py new file mode 100644 index 00000000..a885cb64 --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/tests/test_shape_base.py @@ -0,0 +1,860 @@ +import pytest +import numpy as np +from numpy._core import ( + array, arange, atleast_1d, atleast_2d, atleast_3d, block, vstack, hstack, + newaxis, concatenate, stack + ) +from numpy.exceptions import AxisError +from numpy._core.shape_base import (_block_dispatcher, _block_setup, + _block_concatenate, _block_slicing) +from numpy.testing import ( + assert_, assert_raises, assert_array_equal, assert_equal, + assert_raises_regex, assert_warns, IS_PYPY + ) + + +class TestAtleast1d: + def test_0D_array(self): + a = array(1) + b = array(2) + res = [atleast_1d(a), atleast_1d(b)] + desired = [array([1]), array([2])] + assert_array_equal(res, desired) + + def test_1D_array(self): + a = array([1, 2]) + b = array([2, 3]) + res = [atleast_1d(a), atleast_1d(b)] + desired = [array([1, 2]), array([2, 3])] + assert_array_equal(res, desired) + + def test_2D_array(self): + a = array([[1, 2], [1, 2]]) + b = array([[2, 3], [2, 3]]) + res = [atleast_1d(a), atleast_1d(b)] + desired = [a, b] + assert_array_equal(res, desired) + + def test_3D_array(self): + a = array([[1, 2], [1, 2]]) + b = array([[2, 3], [2, 3]]) + a = array([a, a]) + b = array([b, b]) + res = [atleast_1d(a), atleast_1d(b)] + desired = [a, b] + assert_array_equal(res, desired) + + def test_r1array(self): + """ Test to make sure equivalent Travis O's r1array function + """ + assert_(atleast_1d(3).shape == (1,)) + assert_(atleast_1d(3j).shape == (1,)) + assert_(atleast_1d(3.0).shape == (1,)) + assert_(atleast_1d([[2, 3], [4, 5]]).shape == (2, 2)) + + +class TestAtleast2d: + def test_0D_array(self): + a = array(1) + b = array(2) + res = [atleast_2d(a), atleast_2d(b)] + desired = [array([[1]]), array([[2]])] + assert_array_equal(res, desired) + + def test_1D_array(self): + a = array([1, 2]) + b = array([2, 3]) + res = [atleast_2d(a), atleast_2d(b)] + desired = [array([[1, 2]]), array([[2, 3]])] + assert_array_equal(res, desired) + + def test_2D_array(self): + a = array([[1, 2], [1, 2]]) + b = array([[2, 3], [2, 3]]) + res = [atleast_2d(a), atleast_2d(b)] + desired = [a, b] + assert_array_equal(res, desired) + + def test_3D_array(self): + a = array([[1, 2], [1, 2]]) + b = array([[2, 3], [2, 3]]) + a = array([a, a]) + b = array([b, b]) + res = [atleast_2d(a), atleast_2d(b)] + desired = [a, b] + assert_array_equal(res, desired) + + def test_r2array(self): + """ Test to make sure equivalent Travis O's r2array function + """ + assert_(atleast_2d(3).shape == (1, 1)) + assert_(atleast_2d([3j, 1]).shape == (1, 2)) + assert_(atleast_2d([[[3, 1], [4, 5]], [[3, 5], [1, 2]]]).shape == (2, 2, 2)) + + +class TestAtleast3d: + def test_0D_array(self): + a = array(1) + b = array(2) + res = [atleast_3d(a), atleast_3d(b)] + desired = [array([[[1]]]), array([[[2]]])] + assert_array_equal(res, desired) + + def test_1D_array(self): + a = array([1, 2]) + b = array([2, 3]) + res = [atleast_3d(a), atleast_3d(b)] + desired = [array([[[1], [2]]]), array([[[2], [3]]])] + assert_array_equal(res, desired) + + def test_2D_array(self): + a = array([[1, 2], [1, 2]]) + b = array([[2, 3], [2, 3]]) + res = [atleast_3d(a), atleast_3d(b)] + desired = [a[:,:, newaxis], b[:,:, newaxis]] + assert_array_equal(res, desired) + + def test_3D_array(self): + a = array([[1, 2], [1, 2]]) + b = array([[2, 3], [2, 3]]) + a = array([a, a]) + b = array([b, b]) + res = [atleast_3d(a), atleast_3d(b)] + desired = [a, b] + assert_array_equal(res, desired) + + +class TestHstack: + def test_non_iterable(self): + assert_raises(TypeError, hstack, 1) + + def test_empty_input(self): + assert_raises(ValueError, hstack, ()) + + def test_0D_array(self): + a = array(1) + b = array(2) + res = hstack([a, b]) + desired = array([1, 2]) + assert_array_equal(res, desired) + + def test_1D_array(self): + a = array([1]) + b = array([2]) + res = hstack([a, b]) + desired = array([1, 2]) + assert_array_equal(res, desired) + + def test_2D_array(self): + a = array([[1], [2]]) + b = array([[1], [2]]) + res = hstack([a, b]) + desired = array([[1, 1], [2, 2]]) + assert_array_equal(res, desired) + + def test_generator(self): + with pytest.raises(TypeError, match="arrays to stack must be"): + hstack(np.arange(3) for _ in range(2)) + with pytest.raises(TypeError, match="arrays to stack must be"): + hstack(map(lambda x: x, np.ones((3, 2)))) + + def test_casting_and_dtype(self): + a = np.array([1, 2, 3]) + b = np.array([2.5, 3.5, 4.5]) + res = np.hstack((a, b), casting="unsafe", dtype=np.int64) + expected_res = np.array([1, 2, 3, 2, 3, 4]) + assert_array_equal(res, expected_res) + + def test_casting_and_dtype_type_error(self): + a = np.array([1, 2, 3]) + b = np.array([2.5, 3.5, 4.5]) + with pytest.raises(TypeError): + hstack((a, b), casting="safe", dtype=np.int64) + + +class TestVstack: + def test_non_iterable(self): + assert_raises(TypeError, vstack, 1) + + def test_empty_input(self): + assert_raises(ValueError, vstack, ()) + + def test_0D_array(self): + a = array(1) + b = array(2) + res = vstack([a, b]) + desired = array([[1], [2]]) + assert_array_equal(res, desired) + + def test_1D_array(self): + a = array([1]) + b = array([2]) + res = vstack([a, b]) + desired = array([[1], [2]]) + assert_array_equal(res, desired) + + def test_2D_array(self): + a = array([[1], [2]]) + b = array([[1], [2]]) + res = vstack([a, b]) + desired = array([[1], [2], [1], [2]]) + assert_array_equal(res, desired) + + def test_2D_array2(self): + a = array([1, 2]) + b = array([1, 2]) + res = vstack([a, b]) + desired = array([[1, 2], [1, 2]]) + assert_array_equal(res, desired) + + def test_generator(self): + with pytest.raises(TypeError, match="arrays to stack must be"): + vstack(np.arange(3) for _ in range(2)) + + def test_casting_and_dtype(self): + a = np.array([1, 2, 3]) + b = np.array([2.5, 3.5, 4.5]) + res = np.vstack((a, b), casting="unsafe", dtype=np.int64) + expected_res = np.array([[1, 2, 3], [2, 3, 4]]) + assert_array_equal(res, expected_res) + + def test_casting_and_dtype_type_error(self): + a = np.array([1, 2, 3]) + b = np.array([2.5, 3.5, 4.5]) + with pytest.raises(TypeError): + vstack((a, b), casting="safe", dtype=np.int64) + + + +class TestConcatenate: + def test_returns_copy(self): + a = np.eye(3) + b = np.concatenate([a]) + b[0, 0] = 2 + assert b[0, 0] != a[0, 0] + + def test_exceptions(self): + # test axis must be in bounds + for ndim in [1, 2, 3]: + a = np.ones((1,)*ndim) + np.concatenate((a, a), axis=0) # OK + assert_raises(AxisError, np.concatenate, (a, a), axis=ndim) + assert_raises(AxisError, np.concatenate, (a, a), axis=-(ndim + 1)) + + # Scalars cannot be concatenated + assert_raises(ValueError, concatenate, (0,)) + assert_raises(ValueError, concatenate, (np.array(0),)) + + # dimensionality must match + assert_raises_regex( + ValueError, + r"all the input arrays must have same number of dimensions, but " + r"the array at index 0 has 1 dimension\(s\) and the array at " + r"index 1 has 2 dimension\(s\)", + np.concatenate, (np.zeros(1), np.zeros((1, 1)))) + + # test shapes must match except for concatenation axis + a = np.ones((1, 2, 3)) + b = np.ones((2, 2, 3)) + axis = list(range(3)) + for i in range(3): + np.concatenate((a, b), axis=axis[0]) # OK + assert_raises_regex( + ValueError, + "all the input array dimensions except for the concatenation axis " + "must match exactly, but along dimension {}, the array at " + "index 0 has size 1 and the array at index 1 has size 2" + .format(i), + np.concatenate, (a, b), axis=axis[1]) + assert_raises(ValueError, np.concatenate, (a, b), axis=axis[2]) + a = np.moveaxis(a, -1, 0) + b = np.moveaxis(b, -1, 0) + axis.append(axis.pop(0)) + + # No arrays to concatenate raises ValueError + assert_raises(ValueError, concatenate, ()) + + def test_concatenate_axis_None(self): + a = np.arange(4, dtype=np.float64).reshape((2, 2)) + b = list(range(3)) + c = ['x'] + r = np.concatenate((a, a), axis=None) + assert_equal(r.dtype, a.dtype) + assert_equal(r.ndim, 1) + r = np.concatenate((a, b), axis=None) + assert_equal(r.size, a.size + len(b)) + assert_equal(r.dtype, a.dtype) + r = np.concatenate((a, b, c), axis=None, dtype="U") + d = array(['0.0', '1.0', '2.0', '3.0', + '0', '1', '2', 'x']) + assert_array_equal(r, d) + + out = np.zeros(a.size + len(b)) + r = np.concatenate((a, b), axis=None) + rout = np.concatenate((a, b), axis=None, out=out) + assert_(out is rout) + assert_equal(r, rout) + + def test_large_concatenate_axis_None(self): + # When no axis is given, concatenate uses flattened versions. + # This also had a bug with many arrays (see gh-5979). + x = np.arange(1, 100) + r = np.concatenate(x, None) + assert_array_equal(x, r) + + # Once upon a time, this was the same as `axis=None` now it fails + # (with an unspecified error, as multiple things are wrong here) + with pytest.raises(ValueError): + np.concatenate(x, 100) + + def test_concatenate(self): + # Test concatenate function + # One sequence returns unmodified (but as array) + r4 = list(range(4)) + assert_array_equal(concatenate((r4,)), r4) + # Any sequence + assert_array_equal(concatenate((tuple(r4),)), r4) + assert_array_equal(concatenate((array(r4),)), r4) + # 1D default concatenation + r3 = list(range(3)) + assert_array_equal(concatenate((r4, r3)), r4 + r3) + # Mixed sequence types + assert_array_equal(concatenate((tuple(r4), r3)), r4 + r3) + assert_array_equal(concatenate((array(r4), r3)), r4 + r3) + # Explicit axis specification + assert_array_equal(concatenate((r4, r3), 0), r4 + r3) + # Including negative + assert_array_equal(concatenate((r4, r3), -1), r4 + r3) + # 2D + a23 = array([[10, 11, 12], [13, 14, 15]]) + a13 = array([[0, 1, 2]]) + res = array([[10, 11, 12], [13, 14, 15], [0, 1, 2]]) + assert_array_equal(concatenate((a23, a13)), res) + assert_array_equal(concatenate((a23, a13), 0), res) + assert_array_equal(concatenate((a23.T, a13.T), 1), res.T) + assert_array_equal(concatenate((a23.T, a13.T), -1), res.T) + # Arrays much match shape + assert_raises(ValueError, concatenate, (a23.T, a13.T), 0) + # 3D + res = arange(2 * 3 * 7).reshape((2, 3, 7)) + a0 = res[..., :4] + a1 = res[..., 4:6] + a2 = res[..., 6:] + assert_array_equal(concatenate((a0, a1, a2), 2), res) + assert_array_equal(concatenate((a0, a1, a2), -1), res) + assert_array_equal(concatenate((a0.T, a1.T, a2.T), 0), res.T) + + out = res.copy() + rout = concatenate((a0, a1, a2), 2, out=out) + assert_(out is rout) + assert_equal(res, rout) + + @pytest.mark.skipif(IS_PYPY, reason="PYPY handles sq_concat, nb_add differently than cpython") + def test_operator_concat(self): + import operator + a = array([1, 2]) + b = array([3, 4]) + n = [1,2] + res = array([1, 2, 3, 4]) + assert_raises(TypeError, operator.concat, a, b) + assert_raises(TypeError, operator.concat, a, n) + assert_raises(TypeError, operator.concat, n, a) + assert_raises(TypeError, operator.concat, a, 1) + assert_raises(TypeError, operator.concat, 1, a) + + def test_bad_out_shape(self): + a = array([1, 2]) + b = array([3, 4]) + + assert_raises(ValueError, concatenate, (a, b), out=np.empty(5)) + assert_raises(ValueError, concatenate, (a, b), out=np.empty((4,1))) + assert_raises(ValueError, concatenate, (a, b), out=np.empty((1,4))) + concatenate((a, b), out=np.empty(4)) + + @pytest.mark.parametrize("axis", [None, 0]) + @pytest.mark.parametrize("out_dtype", ["c8", "f4", "f8", ">f8", "i8", "S4"]) + @pytest.mark.parametrize("casting", + ['no', 'equiv', 'safe', 'same_kind', 'unsafe']) + def test_out_and_dtype(self, axis, out_dtype, casting): + # Compare usage of `out=out` with `dtype=out.dtype` + out = np.empty(4, dtype=out_dtype) + to_concat = (array([1.1, 2.2]), array([3.3, 4.4])) + + if not np.can_cast(to_concat[0], out_dtype, casting=casting): + with assert_raises(TypeError): + concatenate(to_concat, out=out, axis=axis, casting=casting) + with assert_raises(TypeError): + concatenate(to_concat, dtype=out.dtype, + axis=axis, casting=casting) + else: + res_out = concatenate(to_concat, out=out, + axis=axis, casting=casting) + res_dtype = concatenate(to_concat, dtype=out.dtype, + axis=axis, casting=casting) + assert res_out is out + assert_array_equal(out, res_dtype) + assert res_dtype.dtype == out_dtype + + with assert_raises(TypeError): + concatenate(to_concat, out=out, dtype=out_dtype, axis=axis) + + @pytest.mark.parametrize("axis", [None, 0]) + @pytest.mark.parametrize("string_dt", ["S", "U", "S0", "U0"]) + @pytest.mark.parametrize("arrs", + [([0.],), ([0.], [1]), ([0], ["string"], [1.])]) + def test_dtype_with_promotion(self, arrs, string_dt, axis): + # Note that U0 and S0 should be deprecated eventually and changed to + # actually give the empty string result (together with `np.array`) + res = np.concatenate(arrs, axis=axis, dtype=string_dt, casting="unsafe") + # The actual dtype should be identical to a cast (of a double array): + assert res.dtype == np.array(1.).astype(string_dt).dtype + + @pytest.mark.parametrize("axis", [None, 0]) + def test_string_dtype_does_not_inspect(self, axis): + with pytest.raises(TypeError): + np.concatenate(([None], [1]), dtype="S", axis=axis) + with pytest.raises(TypeError): + np.concatenate(([None], [1]), dtype="U", axis=axis) + + @pytest.mark.parametrize("axis", [None, 0]) + def test_subarray_error(self, axis): + with pytest.raises(TypeError, match=".*subarray dtype"): + np.concatenate(([1], [1]), dtype="(2,)i", axis=axis) + + +def test_stack(): + # non-iterable input + assert_raises(TypeError, stack, 1) + + # 0d input + for input_ in [(1, 2, 3), + [np.int32(1), np.int32(2), np.int32(3)], + [np.array(1), np.array(2), np.array(3)]]: + assert_array_equal(stack(input_), [1, 2, 3]) + # 1d input examples + a = np.array([1, 2, 3]) + b = np.array([4, 5, 6]) + r1 = array([[1, 2, 3], [4, 5, 6]]) + assert_array_equal(np.stack((a, b)), r1) + assert_array_equal(np.stack((a, b), axis=1), r1.T) + # all input types + assert_array_equal(np.stack(list([a, b])), r1) + assert_array_equal(np.stack(array([a, b])), r1) + # all shapes for 1d input + arrays = [np.random.randn(3) for _ in range(10)] + axes = [0, 1, -1, -2] + expected_shapes = [(10, 3), (3, 10), (3, 10), (10, 3)] + for axis, expected_shape in zip(axes, expected_shapes): + assert_equal(np.stack(arrays, axis).shape, expected_shape) + assert_raises_regex(AxisError, 'out of bounds', stack, arrays, axis=2) + assert_raises_regex(AxisError, 'out of bounds', stack, arrays, axis=-3) + # all shapes for 2d input + arrays = [np.random.randn(3, 4) for _ in range(10)] + axes = [0, 1, 2, -1, -2, -3] + expected_shapes = [(10, 3, 4), (3, 10, 4), (3, 4, 10), + (3, 4, 10), (3, 10, 4), (10, 3, 4)] + for axis, expected_shape in zip(axes, expected_shapes): + assert_equal(np.stack(arrays, axis).shape, expected_shape) + # empty arrays + assert_(stack([[], [], []]).shape == (3, 0)) + assert_(stack([[], [], []], axis=1).shape == (0, 3)) + # out + out = np.zeros_like(r1) + np.stack((a, b), out=out) + assert_array_equal(out, r1) + # edge cases + assert_raises_regex(ValueError, 'need at least one array', stack, []) + assert_raises_regex(ValueError, 'must have the same shape', + stack, [1, np.arange(3)]) + assert_raises_regex(ValueError, 'must have the same shape', + stack, [np.arange(3), 1]) + assert_raises_regex(ValueError, 'must have the same shape', + stack, [np.arange(3), 1], axis=1) + assert_raises_regex(ValueError, 'must have the same shape', + stack, [np.zeros((3, 3)), np.zeros(3)], axis=1) + assert_raises_regex(ValueError, 'must have the same shape', + stack, [np.arange(2), np.arange(3)]) + + # do not accept generators + with pytest.raises(TypeError, match="arrays to stack must be"): + stack(x for x in range(3)) + + #casting and dtype test + a = np.array([1, 2, 3]) + b = np.array([2.5, 3.5, 4.5]) + res = np.stack((a, b), axis=1, casting="unsafe", dtype=np.int64) + expected_res = np.array([[1, 2], [2, 3], [3, 4]]) + assert_array_equal(res, expected_res) + #casting and dtype with TypeError + with assert_raises(TypeError): + stack((a, b), dtype=np.int64, axis=1, casting="safe") + + +def test_unstack(): + a = np.arange(24).reshape((2, 3, 4)) + + for stacks in [np.unstack(a), + np.unstack(a, axis=0), + np.unstack(a, axis=-3)]: + assert isinstance(stacks, tuple) + assert len(stacks) == 2 + assert_array_equal(stacks[0], a[0]) + assert_array_equal(stacks[1], a[1]) + + for stacks in [np.unstack(a, axis=1), + np.unstack(a, axis=-2)]: + assert isinstance(stacks, tuple) + assert len(stacks) == 3 + assert_array_equal(stacks[0], a[:, 0]) + assert_array_equal(stacks[1], a[:, 1]) + assert_array_equal(stacks[2], a[:, 2]) + + for stacks in [np.unstack(a, axis=2), + np.unstack(a, axis=-1)]: + assert isinstance(stacks, tuple) + assert len(stacks) == 4 + assert_array_equal(stacks[0], a[:, :, 0]) + assert_array_equal(stacks[1], a[:, :, 1]) + assert_array_equal(stacks[2], a[:, :, 2]) + assert_array_equal(stacks[3], a[:, :, 3]) + + assert_raises(ValueError, np.unstack, a, axis=3) + assert_raises(ValueError, np.unstack, a, axis=-4) + assert_raises(ValueError, np.unstack, np.array(0), axis=0) + + +@pytest.mark.parametrize("axis", [0]) +@pytest.mark.parametrize("out_dtype", ["c8", "f4", "f8", ">f8", "i8"]) +@pytest.mark.parametrize("casting", + ['no', 'equiv', 'safe', 'same_kind', 'unsafe']) +def test_stack_out_and_dtype(axis, out_dtype, casting): + to_concat = (array([1, 2]), array([3, 4])) + res = array([[1, 2], [3, 4]]) + out = np.zeros_like(res) + + if not np.can_cast(to_concat[0], out_dtype, casting=casting): + with assert_raises(TypeError): + stack(to_concat, dtype=out_dtype, + axis=axis, casting=casting) + else: + res_out = stack(to_concat, out=out, + axis=axis, casting=casting) + res_dtype = stack(to_concat, dtype=out_dtype, + axis=axis, casting=casting) + assert res_out is out + assert_array_equal(out, res_dtype) + assert res_dtype.dtype == out_dtype + + with assert_raises(TypeError): + stack(to_concat, out=out, dtype=out_dtype, axis=axis) + + +class TestBlock: + @pytest.fixture(params=['block', 'force_concatenate', 'force_slicing']) + def block(self, request): + # blocking small arrays and large arrays go through different paths. + # the algorithm is triggered depending on the number of element + # copies required. + # We define a test fixture that forces most tests to go through + # both code paths. + # Ultimately, this should be removed if a single algorithm is found + # to be faster for both small and large arrays. + def _block_force_concatenate(arrays): + arrays, list_ndim, result_ndim, _ = _block_setup(arrays) + return _block_concatenate(arrays, list_ndim, result_ndim) + + def _block_force_slicing(arrays): + arrays, list_ndim, result_ndim, _ = _block_setup(arrays) + return _block_slicing(arrays, list_ndim, result_ndim) + + if request.param == 'force_concatenate': + return _block_force_concatenate + elif request.param == 'force_slicing': + return _block_force_slicing + elif request.param == 'block': + return block + else: + raise ValueError('Unknown blocking request. There is a typo in the tests.') + + def test_returns_copy(self, block): + a = np.eye(3) + b = block(a) + b[0, 0] = 2 + assert b[0, 0] != a[0, 0] + + def test_block_total_size_estimate(self, block): + _, _, _, total_size = _block_setup([1]) + assert total_size == 1 + + _, _, _, total_size = _block_setup([[1]]) + assert total_size == 1 + + _, _, _, total_size = _block_setup([[1, 1]]) + assert total_size == 2 + + _, _, _, total_size = _block_setup([[1], [1]]) + assert total_size == 2 + + _, _, _, total_size = _block_setup([[1, 2], [3, 4]]) + assert total_size == 4 + + def test_block_simple_row_wise(self, block): + a_2d = np.ones((2, 2)) + b_2d = 2 * a_2d + desired = np.array([[1, 1, 2, 2], + [1, 1, 2, 2]]) + result = block([a_2d, b_2d]) + assert_equal(desired, result) + + def test_block_simple_column_wise(self, block): + a_2d = np.ones((2, 2)) + b_2d = 2 * a_2d + expected = np.array([[1, 1], + [1, 1], + [2, 2], + [2, 2]]) + result = block([[a_2d], [b_2d]]) + assert_equal(expected, result) + + def test_block_with_1d_arrays_row_wise(self, block): + # # # 1-D vectors are treated as row arrays + a = np.array([1, 2, 3]) + b = np.array([2, 3, 4]) + expected = np.array([1, 2, 3, 2, 3, 4]) + result = block([a, b]) + assert_equal(expected, result) + + def test_block_with_1d_arrays_multiple_rows(self, block): + a = np.array([1, 2, 3]) + b = np.array([2, 3, 4]) + expected = np.array([[1, 2, 3, 2, 3, 4], + [1, 2, 3, 2, 3, 4]]) + result = block([[a, b], [a, b]]) + assert_equal(expected, result) + + def test_block_with_1d_arrays_column_wise(self, block): + # # # 1-D vectors are treated as row arrays + a_1d = np.array([1, 2, 3]) + b_1d = np.array([2, 3, 4]) + expected = np.array([[1, 2, 3], + [2, 3, 4]]) + result = block([[a_1d], [b_1d]]) + assert_equal(expected, result) + + def test_block_mixed_1d_and_2d(self, block): + a_2d = np.ones((2, 2)) + b_1d = np.array([2, 2]) + result = block([[a_2d], [b_1d]]) + expected = np.array([[1, 1], + [1, 1], + [2, 2]]) + assert_equal(expected, result) + + def test_block_complicated(self, block): + # a bit more complicated + one_2d = np.array([[1, 1, 1]]) + two_2d = np.array([[2, 2, 2]]) + three_2d = np.array([[3, 3, 3, 3, 3, 3]]) + four_1d = np.array([4, 4, 4, 4, 4, 4]) + five_0d = np.array(5) + six_1d = np.array([6, 6, 6, 6, 6]) + zero_2d = np.zeros((2, 6)) + + expected = np.array([[1, 1, 1, 2, 2, 2], + [3, 3, 3, 3, 3, 3], + [4, 4, 4, 4, 4, 4], + [5, 6, 6, 6, 6, 6], + [0, 0, 0, 0, 0, 0], + [0, 0, 0, 0, 0, 0]]) + + result = block([[one_2d, two_2d], + [three_2d], + [four_1d], + [five_0d, six_1d], + [zero_2d]]) + assert_equal(result, expected) + + def test_nested(self, block): + one = np.array([1, 1, 1]) + two = np.array([[2, 2, 2], [2, 2, 2], [2, 2, 2]]) + three = np.array([3, 3, 3]) + four = np.array([4, 4, 4]) + five = np.array(5) + six = np.array([6, 6, 6, 6, 6]) + zero = np.zeros((2, 6)) + + result = block([ + [ + block([ + [one], + [three], + [four] + ]), + two + ], + [five, six], + [zero] + ]) + expected = np.array([[1, 1, 1, 2, 2, 2], + [3, 3, 3, 2, 2, 2], + [4, 4, 4, 2, 2, 2], + [5, 6, 6, 6, 6, 6], + [0, 0, 0, 0, 0, 0], + [0, 0, 0, 0, 0, 0]]) + + assert_equal(result, expected) + + def test_3d(self, block): + a000 = np.ones((2, 2, 2), int) * 1 + + a100 = np.ones((3, 2, 2), int) * 2 + a010 = np.ones((2, 3, 2), int) * 3 + a001 = np.ones((2, 2, 3), int) * 4 + + a011 = np.ones((2, 3, 3), int) * 5 + a101 = np.ones((3, 2, 3), int) * 6 + a110 = np.ones((3, 3, 2), int) * 7 + + a111 = np.ones((3, 3, 3), int) * 8 + + result = block([ + [ + [a000, a001], + [a010, a011], + ], + [ + [a100, a101], + [a110, a111], + ] + ]) + expected = array([[[1, 1, 4, 4, 4], + [1, 1, 4, 4, 4], + [3, 3, 5, 5, 5], + [3, 3, 5, 5, 5], + [3, 3, 5, 5, 5]], + + [[1, 1, 4, 4, 4], + [1, 1, 4, 4, 4], + [3, 3, 5, 5, 5], + [3, 3, 5, 5, 5], + [3, 3, 5, 5, 5]], + + [[2, 2, 6, 6, 6], + [2, 2, 6, 6, 6], + [7, 7, 8, 8, 8], + [7, 7, 8, 8, 8], + [7, 7, 8, 8, 8]], + + [[2, 2, 6, 6, 6], + [2, 2, 6, 6, 6], + [7, 7, 8, 8, 8], + [7, 7, 8, 8, 8], + [7, 7, 8, 8, 8]], + + [[2, 2, 6, 6, 6], + [2, 2, 6, 6, 6], + [7, 7, 8, 8, 8], + [7, 7, 8, 8, 8], + [7, 7, 8, 8, 8]]]) + + assert_array_equal(result, expected) + + def test_block_with_mismatched_shape(self, block): + a = np.array([0, 0]) + b = np.eye(2) + assert_raises(ValueError, block, [a, b]) + assert_raises(ValueError, block, [b, a]) + + to_block = [[np.ones((2,3)), np.ones((2,2))], + [np.ones((2,2)), np.ones((2,2))]] + assert_raises(ValueError, block, to_block) + def test_no_lists(self, block): + assert_equal(block(1), np.array(1)) + assert_equal(block(np.eye(3)), np.eye(3)) + + def test_invalid_nesting(self, block): + msg = 'depths are mismatched' + assert_raises_regex(ValueError, msg, block, [1, [2]]) + assert_raises_regex(ValueError, msg, block, [1, []]) + assert_raises_regex(ValueError, msg, block, [[1], 2]) + assert_raises_regex(ValueError, msg, block, [[], 2]) + assert_raises_regex(ValueError, msg, block, [ + [[1], [2]], + [[3, 4]], + [5] # missing brackets + ]) + + def test_empty_lists(self, block): + assert_raises_regex(ValueError, 'empty', block, []) + assert_raises_regex(ValueError, 'empty', block, [[]]) + assert_raises_regex(ValueError, 'empty', block, [[1], []]) + + def test_tuple(self, block): + assert_raises_regex(TypeError, 'tuple', block, ([1, 2], [3, 4])) + assert_raises_regex(TypeError, 'tuple', block, [(1, 2), (3, 4)]) + + def test_different_ndims(self, block): + a = 1. + b = 2 * np.ones((1, 2)) + c = 3 * np.ones((1, 1, 3)) + + result = block([a, b, c]) + expected = np.array([[[1., 2., 2., 3., 3., 3.]]]) + + assert_equal(result, expected) + + def test_different_ndims_depths(self, block): + a = 1. + b = 2 * np.ones((1, 2)) + c = 3 * np.ones((1, 2, 3)) + + result = block([[a, b], [c]]) + expected = np.array([[[1., 2., 2.], + [3., 3., 3.], + [3., 3., 3.]]]) + + assert_equal(result, expected) + + def test_block_memory_order(self, block): + # 3D + arr_c = np.zeros((3,)*3, order='C') + arr_f = np.zeros((3,)*3, order='F') + + b_c = [[[arr_c, arr_c], + [arr_c, arr_c]], + [[arr_c, arr_c], + [arr_c, arr_c]]] + + b_f = [[[arr_f, arr_f], + [arr_f, arr_f]], + [[arr_f, arr_f], + [arr_f, arr_f]]] + + assert block(b_c).flags['C_CONTIGUOUS'] + assert block(b_f).flags['F_CONTIGUOUS'] + + arr_c = np.zeros((3, 3), order='C') + arr_f = np.zeros((3, 3), order='F') + # 2D + b_c = [[arr_c, arr_c], + [arr_c, arr_c]] + + b_f = [[arr_f, arr_f], + [arr_f, arr_f]] + + assert block(b_c).flags['C_CONTIGUOUS'] + assert block(b_f).flags['F_CONTIGUOUS'] + + +def test_block_dispatcher(): + class ArrayLike: + pass + a = ArrayLike() + b = ArrayLike() + c = ArrayLike() + assert_equal(list(_block_dispatcher(a)), [a]) + assert_equal(list(_block_dispatcher([a])), [a]) + assert_equal(list(_block_dispatcher([a, b])), [a, b]) + assert_equal(list(_block_dispatcher([[a], [b, [c]]])), [a, b, c]) + # don't recurse into non-lists + assert_equal(list(_block_dispatcher((a, b))), [(a, b)]) diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/test_simd.py b/venv/lib/python3.12/site-packages/numpy/_core/tests/test_simd.py new file mode 100644 index 00000000..9d472555 --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/tests/test_simd.py @@ -0,0 +1,1333 @@ +# NOTE: Please avoid the use of numpy.testing since NPYV intrinsics +# may be involved in their functionality. +import pytest, math, re +import itertools +import operator +from numpy._core._simd import targets, clear_floatstatus, get_floatstatus +from numpy._core._multiarray_umath import __cpu_baseline__ + +def check_floatstatus(divbyzero=False, overflow=False, + underflow=False, invalid=False, + all=False): + #define NPY_FPE_DIVIDEBYZERO 1 + #define NPY_FPE_OVERFLOW 2 + #define NPY_FPE_UNDERFLOW 4 + #define NPY_FPE_INVALID 8 + err = get_floatstatus() + ret = (all or divbyzero) and (err & 1) != 0 + ret |= (all or overflow) and (err & 2) != 0 + ret |= (all or underflow) and (err & 4) != 0 + ret |= (all or invalid) and (err & 8) != 0 + return ret + +class _Test_Utility: + # submodule of the desired SIMD extension, e.g. targets["AVX512F"] + npyv = None + # the current data type suffix e.g. 's8' + sfx = None + # target name can be 'baseline' or one or more of CPU features + target_name = None + + def __getattr__(self, attr): + """ + To call NPV intrinsics without the attribute 'npyv' and + auto suffixing intrinsics according to class attribute 'sfx' + """ + return getattr(self.npyv, attr + "_" + self.sfx) + + def _x2(self, intrin_name): + return getattr(self.npyv, f"{intrin_name}_{self.sfx}x2") + + def _data(self, start=None, count=None, reverse=False): + """ + Create list of consecutive numbers according to number of vector's lanes. + """ + if start is None: + start = 1 + if count is None: + count = self.nlanes + rng = range(start, start + count) + if reverse: + rng = reversed(rng) + if self._is_fp(): + return [x / 1.0 for x in rng] + return list(rng) + + def _is_unsigned(self): + return self.sfx[0] == 'u' + + def _is_signed(self): + return self.sfx[0] == 's' + + def _is_fp(self): + return self.sfx[0] == 'f' + + def _scalar_size(self): + return int(self.sfx[1:]) + + def _int_clip(self, seq): + if self._is_fp(): + return seq + max_int = self._int_max() + min_int = self._int_min() + return [min(max(v, min_int), max_int) for v in seq] + + def _int_max(self): + if self._is_fp(): + return None + max_u = self._to_unsigned(self.setall(-1))[0] + if self._is_signed(): + return max_u // 2 + return max_u + + def _int_min(self): + if self._is_fp(): + return None + if self._is_unsigned(): + return 0 + return -(self._int_max() + 1) + + def _true_mask(self): + max_unsig = getattr(self.npyv, "setall_u" + self.sfx[1:])(-1) + return max_unsig[0] + + def _to_unsigned(self, vector): + if isinstance(vector, (list, tuple)): + return getattr(self.npyv, "load_u" + self.sfx[1:])(vector) + else: + sfx = vector.__name__.replace("npyv_", "") + if sfx[0] == "b": + cvt_intrin = "cvt_u{0}_b{0}" + else: + cvt_intrin = "reinterpret_u{0}_{1}" + return getattr(self.npyv, cvt_intrin.format(sfx[1:], sfx))(vector) + + def _pinfinity(self): + return float("inf") + + def _ninfinity(self): + return -float("inf") + + def _nan(self): + return float("nan") + + def _cpu_features(self): + target = self.target_name + if target == "baseline": + target = __cpu_baseline__ + else: + target = target.split('__') # multi-target separator + return ' '.join(target) + +class _SIMD_BOOL(_Test_Utility): + """ + To test all boolean vector types at once + """ + def _nlanes(self): + return getattr(self.npyv, "nlanes_u" + self.sfx[1:]) + + def _data(self, start=None, count=None, reverse=False): + true_mask = self._true_mask() + rng = range(self._nlanes()) + if reverse: + rng = reversed(rng) + return [true_mask if x % 2 else 0 for x in rng] + + def _load_b(self, data): + len_str = self.sfx[1:] + load = getattr(self.npyv, "load_u" + len_str) + cvt = getattr(self.npyv, f"cvt_b{len_str}_u{len_str}") + return cvt(load(data)) + + def test_operators_logical(self): + """ + Logical operations for boolean types. + Test intrinsics: + npyv_xor_##SFX, npyv_and_##SFX, npyv_or_##SFX, npyv_not_##SFX, + npyv_andc_b8, npvy_orc_b8, nvpy_xnor_b8 + """ + data_a = self._data() + data_b = self._data(reverse=True) + vdata_a = self._load_b(data_a) + vdata_b = self._load_b(data_b) + + data_and = [a & b for a, b in zip(data_a, data_b)] + vand = getattr(self, "and")(vdata_a, vdata_b) + assert vand == data_and + + data_or = [a | b for a, b in zip(data_a, data_b)] + vor = getattr(self, "or")(vdata_a, vdata_b) + assert vor == data_or + + data_xor = [a ^ b for a, b in zip(data_a, data_b)] + vxor = getattr(self, "xor")(vdata_a, vdata_b) + assert vxor == data_xor + + vnot = getattr(self, "not")(vdata_a) + assert vnot == data_b + + # among the boolean types, andc, orc and xnor only support b8 + if self.sfx not in ("b8"): + return + + data_andc = [(a & ~b) & 0xFF for a, b in zip(data_a, data_b)] + vandc = getattr(self, "andc")(vdata_a, vdata_b) + assert data_andc == vandc + + data_orc = [(a | ~b) & 0xFF for a, b in zip(data_a, data_b)] + vorc = getattr(self, "orc")(vdata_a, vdata_b) + assert data_orc == vorc + + data_xnor = [~(a ^ b) & 0xFF for a, b in zip(data_a, data_b)] + vxnor = getattr(self, "xnor")(vdata_a, vdata_b) + assert data_xnor == vxnor + + def test_tobits(self): + data2bits = lambda data: sum([int(x != 0) << i for i, x in enumerate(data, 0)]) + for data in (self._data(), self._data(reverse=True)): + vdata = self._load_b(data) + data_bits = data2bits(data) + tobits = self.tobits(vdata) + bin_tobits = bin(tobits) + assert bin_tobits == bin(data_bits) + + def test_pack(self): + """ + Pack multiple vectors into one + Test intrinsics: + npyv_pack_b8_b16 + npyv_pack_b8_b32 + npyv_pack_b8_b64 + """ + if self.sfx not in ("b16", "b32", "b64"): + return + # create the vectors + data = self._data() + rdata = self._data(reverse=True) + vdata = self._load_b(data) + vrdata = self._load_b(rdata) + pack_simd = getattr(self.npyv, f"pack_b8_{self.sfx}") + # for scalar execution, concatenate the elements of the multiple lists + # into a single list (spack) and then iterate over the elements of + # the created list applying a mask to capture the first byte of them. + if self.sfx == "b16": + spack = [(i & 0xFF) for i in (list(rdata) + list(data))] + vpack = pack_simd(vrdata, vdata) + elif self.sfx == "b32": + spack = [(i & 0xFF) for i in (2*list(rdata) + 2*list(data))] + vpack = pack_simd(vrdata, vrdata, vdata, vdata) + elif self.sfx == "b64": + spack = [(i & 0xFF) for i in (4*list(rdata) + 4*list(data))] + vpack = pack_simd(vrdata, vrdata, vrdata, vrdata, + vdata, vdata, vdata, vdata) + assert vpack == spack + + @pytest.mark.parametrize("intrin", ["any", "all"]) + @pytest.mark.parametrize("data", ( + [-1, 0], + [0, -1], + [-1], + [0] + )) + def test_operators_crosstest(self, intrin, data): + """ + Test intrinsics: + npyv_any_##SFX + npyv_all_##SFX + """ + data_a = self._load_b(data * self._nlanes()) + func = eval(intrin) + intrin = getattr(self, intrin) + desired = func(data_a) + simd = intrin(data_a) + assert not not simd == desired + +class _SIMD_INT(_Test_Utility): + """ + To test all integer vector types at once + """ + def test_operators_shift(self): + if self.sfx in ("u8", "s8"): + return + + data_a = self._data(self._int_max() - self.nlanes) + data_b = self._data(self._int_min(), reverse=True) + vdata_a, vdata_b = self.load(data_a), self.load(data_b) + + for count in range(self._scalar_size()): + # load to cast + data_shl_a = self.load([a << count for a in data_a]) + # left shift + shl = self.shl(vdata_a, count) + assert shl == data_shl_a + # load to cast + data_shr_a = self.load([a >> count for a in data_a]) + # right shift + shr = self.shr(vdata_a, count) + assert shr == data_shr_a + + # shift by zero or max or out-range immediate constant is not applicable and illogical + for count in range(1, self._scalar_size()): + # load to cast + data_shl_a = self.load([a << count for a in data_a]) + # left shift by an immediate constant + shli = self.shli(vdata_a, count) + assert shli == data_shl_a + # load to cast + data_shr_a = self.load([a >> count for a in data_a]) + # right shift by an immediate constant + shri = self.shri(vdata_a, count) + assert shri == data_shr_a + + def test_arithmetic_subadd_saturated(self): + if self.sfx in ("u32", "s32", "u64", "s64"): + return + + data_a = self._data(self._int_max() - self.nlanes) + data_b = self._data(self._int_min(), reverse=True) + vdata_a, vdata_b = self.load(data_a), self.load(data_b) + + data_adds = self._int_clip([a + b for a, b in zip(data_a, data_b)]) + adds = self.adds(vdata_a, vdata_b) + assert adds == data_adds + + data_subs = self._int_clip([a - b for a, b in zip(data_a, data_b)]) + subs = self.subs(vdata_a, vdata_b) + assert subs == data_subs + + def test_math_max_min(self): + data_a = self._data() + data_b = self._data(self.nlanes) + vdata_a, vdata_b = self.load(data_a), self.load(data_b) + + data_max = [max(a, b) for a, b in zip(data_a, data_b)] + simd_max = self.max(vdata_a, vdata_b) + assert simd_max == data_max + + data_min = [min(a, b) for a, b in zip(data_a, data_b)] + simd_min = self.min(vdata_a, vdata_b) + assert simd_min == data_min + + @pytest.mark.parametrize("start", [-100, -10000, 0, 100, 10000]) + def test_reduce_max_min(self, start): + """ + Test intrinsics: + npyv_reduce_max_##sfx + npyv_reduce_min_##sfx + """ + vdata_a = self.load(self._data(start)) + assert self.reduce_max(vdata_a) == max(vdata_a) + assert self.reduce_min(vdata_a) == min(vdata_a) + + +class _SIMD_FP32(_Test_Utility): + """ + To only test single precision + """ + def test_conversions(self): + """ + Round to nearest even integer, assume CPU control register is set to rounding. + Test intrinsics: + npyv_round_s32_##SFX + """ + features = self._cpu_features() + if not self.npyv.simd_f64 and re.match(r".*(NEON|ASIMD)", features): + # very costly to emulate nearest even on Armv7 + # instead we round halves to up. e.g. 0.5 -> 1, -0.5 -> -1 + _round = lambda v: int(v + (0.5 if v >= 0 else -0.5)) + else: + _round = round + vdata_a = self.load(self._data()) + vdata_a = self.sub(vdata_a, self.setall(0.5)) + data_round = [_round(x) for x in vdata_a] + vround = self.round_s32(vdata_a) + assert vround == data_round + +class _SIMD_FP64(_Test_Utility): + """ + To only test double precision + """ + def test_conversions(self): + """ + Round to nearest even integer, assume CPU control register is set to rounding. + Test intrinsics: + npyv_round_s32_##SFX + """ + vdata_a = self.load(self._data()) + vdata_a = self.sub(vdata_a, self.setall(0.5)) + vdata_b = self.mul(vdata_a, self.setall(-1.5)) + data_round = [round(x) for x in list(vdata_a) + list(vdata_b)] + vround = self.round_s32(vdata_a, vdata_b) + assert vround == data_round + +class _SIMD_FP(_Test_Utility): + """ + To test all float vector types at once + """ + def test_arithmetic_fused(self): + vdata_a, vdata_b, vdata_c = [self.load(self._data())]*3 + vdata_cx2 = self.add(vdata_c, vdata_c) + # multiply and add, a*b + c + data_fma = self.load([a * b + c for a, b, c in zip(vdata_a, vdata_b, vdata_c)]) + fma = self.muladd(vdata_a, vdata_b, vdata_c) + assert fma == data_fma + # multiply and subtract, a*b - c + fms = self.mulsub(vdata_a, vdata_b, vdata_c) + data_fms = self.sub(data_fma, vdata_cx2) + assert fms == data_fms + # negate multiply and add, -(a*b) + c + nfma = self.nmuladd(vdata_a, vdata_b, vdata_c) + data_nfma = self.sub(vdata_cx2, data_fma) + assert nfma == data_nfma + # negate multiply and subtract, -(a*b) - c + nfms = self.nmulsub(vdata_a, vdata_b, vdata_c) + data_nfms = self.mul(data_fma, self.setall(-1)) + assert nfms == data_nfms + # multiply, add for odd elements and subtract even elements. + # (a * b) -+ c + fmas = list(self.muladdsub(vdata_a, vdata_b, vdata_c)) + assert fmas[0::2] == list(data_fms)[0::2] + assert fmas[1::2] == list(data_fma)[1::2] + + def test_abs(self): + pinf, ninf, nan = self._pinfinity(), self._ninfinity(), self._nan() + data = self._data() + vdata = self.load(self._data()) + + abs_cases = ((-0, 0), (ninf, pinf), (pinf, pinf), (nan, nan)) + for case, desired in abs_cases: + data_abs = [desired]*self.nlanes + vabs = self.abs(self.setall(case)) + assert vabs == pytest.approx(data_abs, nan_ok=True) + + vabs = self.abs(self.mul(vdata, self.setall(-1))) + assert vabs == data + + def test_sqrt(self): + pinf, ninf, nan = self._pinfinity(), self._ninfinity(), self._nan() + data = self._data() + vdata = self.load(self._data()) + + sqrt_cases = ((-0.0, -0.0), (0.0, 0.0), (-1.0, nan), (ninf, nan), (pinf, pinf)) + for case, desired in sqrt_cases: + data_sqrt = [desired]*self.nlanes + sqrt = self.sqrt(self.setall(case)) + assert sqrt == pytest.approx(data_sqrt, nan_ok=True) + + data_sqrt = self.load([math.sqrt(x) for x in data]) # load to truncate precision + sqrt = self.sqrt(vdata) + assert sqrt == data_sqrt + + def test_square(self): + pinf, ninf, nan = self._pinfinity(), self._ninfinity(), self._nan() + data = self._data() + vdata = self.load(self._data()) + # square + square_cases = ((nan, nan), (pinf, pinf), (ninf, pinf)) + for case, desired in square_cases: + data_square = [desired]*self.nlanes + square = self.square(self.setall(case)) + assert square == pytest.approx(data_square, nan_ok=True) + + data_square = [x*x for x in data] + square = self.square(vdata) + assert square == data_square + + @pytest.mark.parametrize("intrin, func", [("ceil", math.ceil), + ("trunc", math.trunc), ("floor", math.floor), ("rint", round)]) + def test_rounding(self, intrin, func): + """ + Test intrinsics: + npyv_rint_##SFX + npyv_ceil_##SFX + npyv_trunc_##SFX + npyv_floor##SFX + """ + intrin_name = intrin + intrin = getattr(self, intrin) + pinf, ninf, nan = self._pinfinity(), self._ninfinity(), self._nan() + # special cases + round_cases = ((nan, nan), (pinf, pinf), (ninf, ninf)) + for case, desired in round_cases: + data_round = [desired]*self.nlanes + _round = intrin(self.setall(case)) + assert _round == pytest.approx(data_round, nan_ok=True) + + for x in range(0, 2**20, 256**2): + for w in (-1.05, -1.10, -1.15, 1.05, 1.10, 1.15): + data = self.load([(x+a)*w for a in range(self.nlanes)]) + data_round = [func(x) for x in data] + _round = intrin(data) + assert _round == data_round + + # test large numbers + for i in ( + 1.1529215045988576e+18, 4.6116860183954304e+18, + 5.902958103546122e+20, 2.3611832414184488e+21 + ): + x = self.setall(i) + y = intrin(x) + data_round = [func(n) for n in x] + assert y == data_round + + # signed zero + if intrin_name == "floor": + data_szero = (-0.0,) + else: + data_szero = (-0.0, -0.25, -0.30, -0.45, -0.5) + + for w in data_szero: + _round = self._to_unsigned(intrin(self.setall(w))) + data_round = self._to_unsigned(self.setall(-0.0)) + assert _round == data_round + + @pytest.mark.parametrize("intrin", [ + "max", "maxp", "maxn", "min", "minp", "minn" + ]) + def test_max_min(self, intrin): + """ + Test intrinsics: + npyv_max_##sfx + npyv_maxp_##sfx + npyv_maxn_##sfx + npyv_min_##sfx + npyv_minp_##sfx + npyv_minn_##sfx + npyv_reduce_max_##sfx + npyv_reduce_maxp_##sfx + npyv_reduce_maxn_##sfx + npyv_reduce_min_##sfx + npyv_reduce_minp_##sfx + npyv_reduce_minn_##sfx + """ + pinf, ninf, nan = self._pinfinity(), self._ninfinity(), self._nan() + chk_nan = {"xp": 1, "np": 1, "nn": 2, "xn": 2}.get(intrin[-2:], 0) + func = eval(intrin[:3]) + reduce_intrin = getattr(self, "reduce_" + intrin) + intrin = getattr(self, intrin) + hf_nlanes = self.nlanes//2 + + cases = ( + ([0.0, -0.0], [-0.0, 0.0]), + ([10, -10], [10, -10]), + ([pinf, 10], [10, ninf]), + ([10, pinf], [ninf, 10]), + ([10, -10], [10, -10]), + ([-10, 10], [-10, 10]) + ) + for op1, op2 in cases: + vdata_a = self.load(op1*hf_nlanes) + vdata_b = self.load(op2*hf_nlanes) + data = func(vdata_a, vdata_b) + simd = intrin(vdata_a, vdata_b) + assert simd == data + data = func(vdata_a) + simd = reduce_intrin(vdata_a) + assert simd == data + + if not chk_nan: + return + if chk_nan == 1: + test_nan = lambda a, b: ( + b if math.isnan(a) else a if math.isnan(b) else b + ) + else: + test_nan = lambda a, b: ( + nan if math.isnan(a) or math.isnan(b) else b + ) + cases = ( + (nan, 10), + (10, nan), + (nan, pinf), + (pinf, nan), + (nan, nan) + ) + for op1, op2 in cases: + vdata_ab = self.load([op1, op2]*hf_nlanes) + data = test_nan(op1, op2) + simd = reduce_intrin(vdata_ab) + assert simd == pytest.approx(data, nan_ok=True) + vdata_a = self.setall(op1) + vdata_b = self.setall(op2) + data = [data] * self.nlanes + simd = intrin(vdata_a, vdata_b) + assert simd == pytest.approx(data, nan_ok=True) + + def test_reciprocal(self): + pinf, ninf, nan = self._pinfinity(), self._ninfinity(), self._nan() + data = self._data() + vdata = self.load(self._data()) + + recip_cases = ((nan, nan), (pinf, 0.0), (ninf, -0.0), (0.0, pinf), (-0.0, ninf)) + for case, desired in recip_cases: + data_recip = [desired]*self.nlanes + recip = self.recip(self.setall(case)) + assert recip == pytest.approx(data_recip, nan_ok=True) + + data_recip = self.load([1/x for x in data]) # load to truncate precision + recip = self.recip(vdata) + assert recip == data_recip + + def test_special_cases(self): + """ + Compare Not NaN. Test intrinsics: + npyv_notnan_##SFX + """ + nnan = self.notnan(self.setall(self._nan())) + assert nnan == [0]*self.nlanes + + @pytest.mark.parametrize("intrin_name", [ + "rint", "trunc", "ceil", "floor" + ]) + def test_unary_invalid_fpexception(self, intrin_name): + intrin = getattr(self, intrin_name) + for d in [float("nan"), float("inf"), -float("inf")]: + v = self.setall(d) + clear_floatstatus() + intrin(v) + assert check_floatstatus(invalid=True) == False + + @pytest.mark.parametrize('py_comp,np_comp', [ + (operator.lt, "cmplt"), + (operator.le, "cmple"), + (operator.gt, "cmpgt"), + (operator.ge, "cmpge"), + (operator.eq, "cmpeq"), + (operator.ne, "cmpneq") + ]) + def test_comparison_with_nan(self, py_comp, np_comp): + pinf, ninf, nan = self._pinfinity(), self._ninfinity(), self._nan() + mask_true = self._true_mask() + + def to_bool(vector): + return [lane == mask_true for lane in vector] + + intrin = getattr(self, np_comp) + cmp_cases = ((0, nan), (nan, 0), (nan, nan), (pinf, nan), + (ninf, nan), (-0.0, +0.0)) + for case_operand1, case_operand2 in cmp_cases: + data_a = [case_operand1]*self.nlanes + data_b = [case_operand2]*self.nlanes + vdata_a = self.setall(case_operand1) + vdata_b = self.setall(case_operand2) + vcmp = to_bool(intrin(vdata_a, vdata_b)) + data_cmp = [py_comp(a, b) for a, b in zip(data_a, data_b)] + assert vcmp == data_cmp + + @pytest.mark.parametrize("intrin", ["any", "all"]) + @pytest.mark.parametrize("data", ( + [float("nan"), 0], + [0, float("nan")], + [float("nan"), 1], + [1, float("nan")], + [float("nan"), float("nan")], + [0.0, -0.0], + [-0.0, 0.0], + [1.0, -0.0] + )) + def test_operators_crosstest(self, intrin, data): + """ + Test intrinsics: + npyv_any_##SFX + npyv_all_##SFX + """ + data_a = self.load(data * self.nlanes) + func = eval(intrin) + intrin = getattr(self, intrin) + desired = func(data_a) + simd = intrin(data_a) + assert not not simd == desired + +class _SIMD_ALL(_Test_Utility): + """ + To test all vector types at once + """ + def test_memory_load(self): + data = self._data() + # unaligned load + load_data = self.load(data) + assert load_data == data + # aligned load + loada_data = self.loada(data) + assert loada_data == data + # stream load + loads_data = self.loads(data) + assert loads_data == data + # load lower part + loadl = self.loadl(data) + loadl_half = list(loadl)[:self.nlanes//2] + data_half = data[:self.nlanes//2] + assert loadl_half == data_half + assert loadl != data # detect overflow + + def test_memory_store(self): + data = self._data() + vdata = self.load(data) + # unaligned store + store = [0] * self.nlanes + self.store(store, vdata) + assert store == data + # aligned store + store_a = [0] * self.nlanes + self.storea(store_a, vdata) + assert store_a == data + # stream store + store_s = [0] * self.nlanes + self.stores(store_s, vdata) + assert store_s == data + # store lower part + store_l = [0] * self.nlanes + self.storel(store_l, vdata) + assert store_l[:self.nlanes//2] == data[:self.nlanes//2] + assert store_l != vdata # detect overflow + # store higher part + store_h = [0] * self.nlanes + self.storeh(store_h, vdata) + assert store_h[:self.nlanes//2] == data[self.nlanes//2:] + assert store_h != vdata # detect overflow + + @pytest.mark.parametrize("intrin, elsizes, scale, fill", [ + ("self.load_tillz, self.load_till", (32, 64), 1, [0xffff]), + ("self.load2_tillz, self.load2_till", (32, 64), 2, [0xffff, 0x7fff]), + ]) + def test_memory_partial_load(self, intrin, elsizes, scale, fill): + if self._scalar_size() not in elsizes: + return + npyv_load_tillz, npyv_load_till = eval(intrin) + data = self._data() + lanes = list(range(1, self.nlanes + 1)) + lanes += [self.nlanes**2, self.nlanes**4] # test out of range + for n in lanes: + load_till = npyv_load_till(data, n, *fill) + load_tillz = npyv_load_tillz(data, n) + n *= scale + data_till = data[:n] + fill * ((self.nlanes-n) // scale) + assert load_till == data_till + data_tillz = data[:n] + [0] * (self.nlanes-n) + assert load_tillz == data_tillz + + @pytest.mark.parametrize("intrin, elsizes, scale", [ + ("self.store_till", (32, 64), 1), + ("self.store2_till", (32, 64), 2), + ]) + def test_memory_partial_store(self, intrin, elsizes, scale): + if self._scalar_size() not in elsizes: + return + npyv_store_till = eval(intrin) + data = self._data() + data_rev = self._data(reverse=True) + vdata = self.load(data) + lanes = list(range(1, self.nlanes + 1)) + lanes += [self.nlanes**2, self.nlanes**4] + for n in lanes: + data_till = data_rev.copy() + data_till[:n*scale] = data[:n*scale] + store_till = self._data(reverse=True) + npyv_store_till(store_till, n, vdata) + assert store_till == data_till + + @pytest.mark.parametrize("intrin, elsizes, scale", [ + ("self.loadn", (32, 64), 1), + ("self.loadn2", (32, 64), 2), + ]) + def test_memory_noncont_load(self, intrin, elsizes, scale): + if self._scalar_size() not in elsizes: + return + npyv_loadn = eval(intrin) + for stride in range(-64, 64): + if stride < 0: + data = self._data(stride, -stride*self.nlanes) + data_stride = list(itertools.chain( + *zip(*[data[-i::stride] for i in range(scale, 0, -1)]) + )) + elif stride == 0: + data = self._data() + data_stride = data[0:scale] * (self.nlanes//scale) + else: + data = self._data(count=stride*self.nlanes) + data_stride = list(itertools.chain( + *zip(*[data[i::stride] for i in range(scale)])) + ) + data_stride = self.load(data_stride) # cast unsigned + loadn = npyv_loadn(data, stride) + assert loadn == data_stride + + @pytest.mark.parametrize("intrin, elsizes, scale, fill", [ + ("self.loadn_tillz, self.loadn_till", (32, 64), 1, [0xffff]), + ("self.loadn2_tillz, self.loadn2_till", (32, 64), 2, [0xffff, 0x7fff]), + ]) + def test_memory_noncont_partial_load(self, intrin, elsizes, scale, fill): + if self._scalar_size() not in elsizes: + return + npyv_loadn_tillz, npyv_loadn_till = eval(intrin) + lanes = list(range(1, self.nlanes + 1)) + lanes += [self.nlanes**2, self.nlanes**4] + for stride in range(-64, 64): + if stride < 0: + data = self._data(stride, -stride*self.nlanes) + data_stride = list(itertools.chain( + *zip(*[data[-i::stride] for i in range(scale, 0, -1)]) + )) + elif stride == 0: + data = self._data() + data_stride = data[0:scale] * (self.nlanes//scale) + else: + data = self._data(count=stride*self.nlanes) + data_stride = list(itertools.chain( + *zip(*[data[i::stride] for i in range(scale)]) + )) + data_stride = list(self.load(data_stride)) # cast unsigned + for n in lanes: + nscale = n * scale + llanes = self.nlanes - nscale + data_stride_till = ( + data_stride[:nscale] + fill * (llanes//scale) + ) + loadn_till = npyv_loadn_till(data, stride, n, *fill) + assert loadn_till == data_stride_till + data_stride_tillz = data_stride[:nscale] + [0] * llanes + loadn_tillz = npyv_loadn_tillz(data, stride, n) + assert loadn_tillz == data_stride_tillz + + @pytest.mark.parametrize("intrin, elsizes, scale", [ + ("self.storen", (32, 64), 1), + ("self.storen2", (32, 64), 2), + ]) + def test_memory_noncont_store(self, intrin, elsizes, scale): + if self._scalar_size() not in elsizes: + return + npyv_storen = eval(intrin) + data = self._data() + vdata = self.load(data) + hlanes = self.nlanes // scale + for stride in range(1, 64): + data_storen = [0xff] * stride * self.nlanes + for s in range(0, hlanes*stride, stride): + i = (s//stride)*scale + data_storen[s:s+scale] = data[i:i+scale] + storen = [0xff] * stride * self.nlanes + storen += [0x7f]*64 + npyv_storen(storen, stride, vdata) + assert storen[:-64] == data_storen + assert storen[-64:] == [0x7f]*64 # detect overflow + + for stride in range(-64, 0): + data_storen = [0xff] * -stride * self.nlanes + for s in range(0, hlanes*stride, stride): + i = (s//stride)*scale + data_storen[s-scale:s or None] = data[i:i+scale] + storen = [0x7f]*64 + storen += [0xff] * -stride * self.nlanes + npyv_storen(storen, stride, vdata) + assert storen[64:] == data_storen + assert storen[:64] == [0x7f]*64 # detect overflow + # stride 0 + data_storen = [0x7f] * self.nlanes + storen = data_storen.copy() + data_storen[0:scale] = data[-scale:] + npyv_storen(storen, 0, vdata) + assert storen == data_storen + + @pytest.mark.parametrize("intrin, elsizes, scale", [ + ("self.storen_till", (32, 64), 1), + ("self.storen2_till", (32, 64), 2), + ]) + def test_memory_noncont_partial_store(self, intrin, elsizes, scale): + if self._scalar_size() not in elsizes: + return + npyv_storen_till = eval(intrin) + data = self._data() + vdata = self.load(data) + lanes = list(range(1, self.nlanes + 1)) + lanes += [self.nlanes**2, self.nlanes**4] + hlanes = self.nlanes // scale + for stride in range(1, 64): + for n in lanes: + data_till = [0xff] * stride * self.nlanes + tdata = data[:n*scale] + [0xff] * (self.nlanes-n*scale) + for s in range(0, hlanes*stride, stride)[:n]: + i = (s//stride)*scale + data_till[s:s+scale] = tdata[i:i+scale] + storen_till = [0xff] * stride * self.nlanes + storen_till += [0x7f]*64 + npyv_storen_till(storen_till, stride, n, vdata) + assert storen_till[:-64] == data_till + assert storen_till[-64:] == [0x7f]*64 # detect overflow + + for stride in range(-64, 0): + for n in lanes: + data_till = [0xff] * -stride * self.nlanes + tdata = data[:n*scale] + [0xff] * (self.nlanes-n*scale) + for s in range(0, hlanes*stride, stride)[:n]: + i = (s//stride)*scale + data_till[s-scale:s or None] = tdata[i:i+scale] + storen_till = [0x7f]*64 + storen_till += [0xff] * -stride * self.nlanes + npyv_storen_till(storen_till, stride, n, vdata) + assert storen_till[64:] == data_till + assert storen_till[:64] == [0x7f]*64 # detect overflow + + # stride 0 + for n in lanes: + data_till = [0x7f] * self.nlanes + storen_till = data_till.copy() + data_till[0:scale] = data[:n*scale][-scale:] + npyv_storen_till(storen_till, 0, n, vdata) + assert storen_till == data_till + + @pytest.mark.parametrize("intrin, table_size, elsize", [ + ("self.lut32", 32, 32), + ("self.lut16", 16, 64) + ]) + def test_lut(self, intrin, table_size, elsize): + """ + Test lookup table intrinsics: + npyv_lut32_##sfx + npyv_lut16_##sfx + """ + if elsize != self._scalar_size(): + return + intrin = eval(intrin) + idx_itrin = getattr(self.npyv, f"setall_u{elsize}") + table = range(0, table_size) + for i in table: + broadi = self.setall(i) + idx = idx_itrin(i) + lut = intrin(table, idx) + assert lut == broadi + + def test_misc(self): + broadcast_zero = self.zero() + assert broadcast_zero == [0] * self.nlanes + for i in range(1, 10): + broadcasti = self.setall(i) + assert broadcasti == [i] * self.nlanes + + data_a, data_b = self._data(), self._data(reverse=True) + vdata_a, vdata_b = self.load(data_a), self.load(data_b) + + # py level of npyv_set_* don't support ignoring the extra specified lanes or + # fill non-specified lanes with zero. + vset = self.set(*data_a) + assert vset == data_a + # py level of npyv_setf_* don't support ignoring the extra specified lanes or + # fill non-specified lanes with the specified scalar. + vsetf = self.setf(10, *data_a) + assert vsetf == data_a + + # We're testing the sanity of _simd's type-vector, + # reinterpret* intrinsics itself are tested via compiler + # during the build of _simd module + sfxes = ["u8", "s8", "u16", "s16", "u32", "s32", "u64", "s64"] + if self.npyv.simd_f64: + sfxes.append("f64") + if self.npyv.simd_f32: + sfxes.append("f32") + for sfx in sfxes: + vec_name = getattr(self, "reinterpret_" + sfx)(vdata_a).__name__ + assert vec_name == "npyv_" + sfx + + # select & mask operations + select_a = self.select(self.cmpeq(self.zero(), self.zero()), vdata_a, vdata_b) + assert select_a == data_a + select_b = self.select(self.cmpneq(self.zero(), self.zero()), vdata_a, vdata_b) + assert select_b == data_b + + # test extract elements + assert self.extract0(vdata_b) == vdata_b[0] + + # cleanup intrinsic is only used with AVX for + # zeroing registers to avoid the AVX-SSE transition penalty, + # so nothing to test here + self.npyv.cleanup() + + def test_reorder(self): + data_a, data_b = self._data(), self._data(reverse=True) + vdata_a, vdata_b = self.load(data_a), self.load(data_b) + # lower half part + data_a_lo = data_a[:self.nlanes//2] + data_b_lo = data_b[:self.nlanes//2] + # higher half part + data_a_hi = data_a[self.nlanes//2:] + data_b_hi = data_b[self.nlanes//2:] + # combine two lower parts + combinel = self.combinel(vdata_a, vdata_b) + assert combinel == data_a_lo + data_b_lo + # combine two higher parts + combineh = self.combineh(vdata_a, vdata_b) + assert combineh == data_a_hi + data_b_hi + # combine x2 + combine = self.combine(vdata_a, vdata_b) + assert combine == (data_a_lo + data_b_lo, data_a_hi + data_b_hi) + + # zip(interleave) + data_zipl = self.load([ + v for p in zip(data_a_lo, data_b_lo) for v in p + ]) + data_ziph = self.load([ + v for p in zip(data_a_hi, data_b_hi) for v in p + ]) + vzip = self.zip(vdata_a, vdata_b) + assert vzip == (data_zipl, data_ziph) + vzip = [0]*self.nlanes*2 + self._x2("store")(vzip, (vdata_a, vdata_b)) + assert vzip == list(data_zipl) + list(data_ziph) + + # unzip(deinterleave) + unzip = self.unzip(data_zipl, data_ziph) + assert unzip == (data_a, data_b) + unzip = self._x2("load")(list(data_zipl) + list(data_ziph)) + assert unzip == (data_a, data_b) + + def test_reorder_rev64(self): + # Reverse elements of each 64-bit lane + ssize = self._scalar_size() + if ssize == 64: + return + data_rev64 = [ + y for x in range(0, self.nlanes, 64//ssize) + for y in reversed(range(x, x + 64//ssize)) + ] + rev64 = self.rev64(self.load(range(self.nlanes))) + assert rev64 == data_rev64 + + def test_reorder_permi128(self): + """ + Test permuting elements for each 128-bit lane. + npyv_permi128_##sfx + """ + ssize = self._scalar_size() + if ssize < 32: + return + data = self.load(self._data()) + permn = 128//ssize + permd = permn-1 + nlane128 = self.nlanes//permn + shfl = [0, 1] if ssize == 64 else [0, 2, 4, 6] + for i in range(permn): + indices = [(i >> shf) & permd for shf in shfl] + vperm = self.permi128(data, *indices) + data_vperm = [ + data[j + (e & -permn)] + for e, j in enumerate(indices*nlane128) + ] + assert vperm == data_vperm + + @pytest.mark.parametrize('func, intrin', [ + (operator.lt, "cmplt"), + (operator.le, "cmple"), + (operator.gt, "cmpgt"), + (operator.ge, "cmpge"), + (operator.eq, "cmpeq") + ]) + def test_operators_comparison(self, func, intrin): + if self._is_fp(): + data_a = self._data() + else: + data_a = self._data(self._int_max() - self.nlanes) + data_b = self._data(self._int_min(), reverse=True) + vdata_a, vdata_b = self.load(data_a), self.load(data_b) + intrin = getattr(self, intrin) + + mask_true = self._true_mask() + def to_bool(vector): + return [lane == mask_true for lane in vector] + + data_cmp = [func(a, b) for a, b in zip(data_a, data_b)] + cmp = to_bool(intrin(vdata_a, vdata_b)) + assert cmp == data_cmp + + def test_operators_logical(self): + if self._is_fp(): + data_a = self._data() + else: + data_a = self._data(self._int_max() - self.nlanes) + data_b = self._data(self._int_min(), reverse=True) + vdata_a, vdata_b = self.load(data_a), self.load(data_b) + + if self._is_fp(): + data_cast_a = self._to_unsigned(vdata_a) + data_cast_b = self._to_unsigned(vdata_b) + cast, cast_data = self._to_unsigned, self._to_unsigned + else: + data_cast_a, data_cast_b = data_a, data_b + cast, cast_data = lambda a: a, self.load + + data_xor = cast_data([a ^ b for a, b in zip(data_cast_a, data_cast_b)]) + vxor = cast(self.xor(vdata_a, vdata_b)) + assert vxor == data_xor + + data_or = cast_data([a | b for a, b in zip(data_cast_a, data_cast_b)]) + vor = cast(getattr(self, "or")(vdata_a, vdata_b)) + assert vor == data_or + + data_and = cast_data([a & b for a, b in zip(data_cast_a, data_cast_b)]) + vand = cast(getattr(self, "and")(vdata_a, vdata_b)) + assert vand == data_and + + data_not = cast_data([~a for a in data_cast_a]) + vnot = cast(getattr(self, "not")(vdata_a)) + assert vnot == data_not + + if self.sfx not in ("u8"): + return + data_andc = [a & ~b for a, b in zip(data_cast_a, data_cast_b)] + vandc = cast(getattr(self, "andc")(vdata_a, vdata_b)) + assert vandc == data_andc + + @pytest.mark.parametrize("intrin", ["any", "all"]) + @pytest.mark.parametrize("data", ( + [1, 2, 3, 4], + [-1, -2, -3, -4], + [0, 1, 2, 3, 4], + [0x7f, 0x7fff, 0x7fffffff, 0x7fffffffffffffff], + [0, -1, -2, -3, 4], + [0], + [1], + [-1] + )) + def test_operators_crosstest(self, intrin, data): + """ + Test intrinsics: + npyv_any_##SFX + npyv_all_##SFX + """ + data_a = self.load(data * self.nlanes) + func = eval(intrin) + intrin = getattr(self, intrin) + desired = func(data_a) + simd = intrin(data_a) + assert not not simd == desired + + def test_conversion_boolean(self): + bsfx = "b" + self.sfx[1:] + to_boolean = getattr(self.npyv, "cvt_%s_%s" % (bsfx, self.sfx)) + from_boolean = getattr(self.npyv, "cvt_%s_%s" % (self.sfx, bsfx)) + + false_vb = to_boolean(self.setall(0)) + true_vb = self.cmpeq(self.setall(0), self.setall(0)) + assert false_vb != true_vb + + false_vsfx = from_boolean(false_vb) + true_vsfx = from_boolean(true_vb) + assert false_vsfx != true_vsfx + + def test_conversion_expand(self): + """ + Test expand intrinsics: + npyv_expand_u16_u8 + npyv_expand_u32_u16 + """ + if self.sfx not in ("u8", "u16"): + return + totype = self.sfx[0]+str(int(self.sfx[1:])*2) + expand = getattr(self.npyv, f"expand_{totype}_{self.sfx}") + # close enough from the edge to detect any deviation + data = self._data(self._int_max() - self.nlanes) + vdata = self.load(data) + edata = expand(vdata) + # lower half part + data_lo = data[:self.nlanes//2] + # higher half part + data_hi = data[self.nlanes//2:] + assert edata == (data_lo, data_hi) + + def test_arithmetic_subadd(self): + if self._is_fp(): + data_a = self._data() + else: + data_a = self._data(self._int_max() - self.nlanes) + data_b = self._data(self._int_min(), reverse=True) + vdata_a, vdata_b = self.load(data_a), self.load(data_b) + + # non-saturated + data_add = self.load([a + b for a, b in zip(data_a, data_b)]) # load to cast + add = self.add(vdata_a, vdata_b) + assert add == data_add + data_sub = self.load([a - b for a, b in zip(data_a, data_b)]) + sub = self.sub(vdata_a, vdata_b) + assert sub == data_sub + + def test_arithmetic_mul(self): + if self.sfx in ("u64", "s64"): + return + + if self._is_fp(): + data_a = self._data() + else: + data_a = self._data(self._int_max() - self.nlanes) + data_b = self._data(self._int_min(), reverse=True) + vdata_a, vdata_b = self.load(data_a), self.load(data_b) + + data_mul = self.load([a * b for a, b in zip(data_a, data_b)]) + mul = self.mul(vdata_a, vdata_b) + assert mul == data_mul + + def test_arithmetic_div(self): + if not self._is_fp(): + return + + data_a, data_b = self._data(), self._data(reverse=True) + vdata_a, vdata_b = self.load(data_a), self.load(data_b) + + # load to truncate f64 to precision of f32 + data_div = self.load([a / b for a, b in zip(data_a, data_b)]) + div = self.div(vdata_a, vdata_b) + assert div == data_div + + def test_arithmetic_intdiv(self): + """ + Test integer division intrinsics: + npyv_divisor_##sfx + npyv_divc_##sfx + """ + if self._is_fp(): + return + + int_min = self._int_min() + def trunc_div(a, d): + """ + Divide towards zero works with large integers > 2^53, + and wrap around overflow similar to what C does. + """ + if d == -1 and a == int_min: + return a + sign_a, sign_d = a < 0, d < 0 + if a == 0 or sign_a == sign_d: + return a // d + return (a + sign_d - sign_a) // d + 1 + + data = [1, -int_min] # to test overflow + data += range(0, 2**8, 2**5) + data += range(0, 2**8, 2**5-1) + bsize = self._scalar_size() + if bsize > 8: + data += range(2**8, 2**16, 2**13) + data += range(2**8, 2**16, 2**13-1) + if bsize > 16: + data += range(2**16, 2**32, 2**29) + data += range(2**16, 2**32, 2**29-1) + if bsize > 32: + data += range(2**32, 2**64, 2**61) + data += range(2**32, 2**64, 2**61-1) + # negate + data += [-x for x in data] + for dividend, divisor in itertools.product(data, data): + divisor = self.setall(divisor)[0] # cast + if divisor == 0: + continue + dividend = self.load(self._data(dividend)) + data_divc = [trunc_div(a, divisor) for a in dividend] + divisor_parms = self.divisor(divisor) + divc = self.divc(dividend, divisor_parms) + assert divc == data_divc + + def test_arithmetic_reduce_sum(self): + """ + Test reduce sum intrinsics: + npyv_sum_##sfx + """ + if self.sfx not in ("u32", "u64", "f32", "f64"): + return + # reduce sum + data = self._data() + vdata = self.load(data) + + data_sum = sum(data) + vsum = self.sum(vdata) + assert vsum == data_sum + + def test_arithmetic_reduce_sumup(self): + """ + Test extend reduce sum intrinsics: + npyv_sumup_##sfx + """ + if self.sfx not in ("u8", "u16"): + return + rdata = (0, self.nlanes, self._int_min(), self._int_max()-self.nlanes) + for r in rdata: + data = self._data(r) + vdata = self.load(data) + data_sum = sum(data) + vsum = self.sumup(vdata) + assert vsum == data_sum + + def test_mask_conditional(self): + """ + Conditional addition and subtraction for all supported data types. + Test intrinsics: + npyv_ifadd_##SFX, npyv_ifsub_##SFX + """ + vdata_a = self.load(self._data()) + vdata_b = self.load(self._data(reverse=True)) + true_mask = self.cmpeq(self.zero(), self.zero()) + false_mask = self.cmpneq(self.zero(), self.zero()) + + data_sub = self.sub(vdata_b, vdata_a) + ifsub = self.ifsub(true_mask, vdata_b, vdata_a, vdata_b) + assert ifsub == data_sub + ifsub = self.ifsub(false_mask, vdata_a, vdata_b, vdata_b) + assert ifsub == vdata_b + + data_add = self.add(vdata_b, vdata_a) + ifadd = self.ifadd(true_mask, vdata_b, vdata_a, vdata_b) + assert ifadd == data_add + ifadd = self.ifadd(false_mask, vdata_a, vdata_b, vdata_b) + assert ifadd == vdata_b + + if not self._is_fp(): + return + data_div = self.div(vdata_b, vdata_a) + ifdiv = self.ifdiv(true_mask, vdata_b, vdata_a, vdata_b) + assert ifdiv == data_div + ifdivz = self.ifdivz(true_mask, vdata_b, vdata_a) + assert ifdivz == data_div + ifdiv = self.ifdiv(false_mask, vdata_a, vdata_b, vdata_b) + assert ifdiv == vdata_b + ifdivz = self.ifdivz(false_mask, vdata_a, vdata_b) + assert ifdivz == self.zero() + +bool_sfx = ("b8", "b16", "b32", "b64") +int_sfx = ("u8", "s8", "u16", "s16", "u32", "s32", "u64", "s64") +fp_sfx = ("f32", "f64") +all_sfx = int_sfx + fp_sfx +tests_registry = { + bool_sfx: _SIMD_BOOL, + int_sfx : _SIMD_INT, + fp_sfx : _SIMD_FP, + ("f32",): _SIMD_FP32, + ("f64",): _SIMD_FP64, + all_sfx : _SIMD_ALL +} +for target_name, npyv in targets.items(): + simd_width = npyv.simd if npyv else '' + pretty_name = target_name.split('__') # multi-target separator + if len(pretty_name) > 1: + # multi-target + pretty_name = f"({' '.join(pretty_name)})" + else: + pretty_name = pretty_name[0] + + skip = "" + skip_sfx = dict() + if not npyv: + skip = f"target '{pretty_name}' isn't supported by current machine" + elif not npyv.simd: + skip = f"target '{pretty_name}' isn't supported by NPYV" + else: + if not npyv.simd_f32: + skip_sfx["f32"] = f"target '{pretty_name}' "\ + "doesn't support single-precision" + if not npyv.simd_f64: + skip_sfx["f64"] = f"target '{pretty_name}' doesn't"\ + "support double-precision" + + for sfxes, cls in tests_registry.items(): + for sfx in sfxes: + skip_m = skip_sfx.get(sfx, skip) + inhr = (cls,) + attr = dict(npyv=targets[target_name], sfx=sfx, target_name=target_name) + tcls = type(f"Test{cls.__name__}_{simd_width}_{target_name}_{sfx}", inhr, attr) + if skip_m: + pytest.mark.skip(reason=skip_m)(tcls) + globals()[tcls.__name__] = tcls diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/test_simd_module.py b/venv/lib/python3.12/site-packages/numpy/_core/tests/test_simd_module.py new file mode 100644 index 00000000..6bd68c22 --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/tests/test_simd_module.py @@ -0,0 +1,101 @@ +import pytest +from numpy._core._simd import targets +""" +This testing unit only for checking the sanity of common functionality, +therefore all we need is just to take one submodule that represents any +of enabled SIMD extensions to run the test on it and the second submodule +required to run only one check related to the possibility of mixing +the data types among each submodule. +""" +npyvs = [npyv_mod for npyv_mod in targets.values() if npyv_mod and npyv_mod.simd] +npyv, npyv2 = (npyvs + [None, None])[:2] + +unsigned_sfx = ["u8", "u16", "u32", "u64"] +signed_sfx = ["s8", "s16", "s32", "s64"] +fp_sfx = [] +if npyv and npyv.simd_f32: + fp_sfx.append("f32") +if npyv and npyv.simd_f64: + fp_sfx.append("f64") + +int_sfx = unsigned_sfx + signed_sfx +all_sfx = unsigned_sfx + int_sfx + +@pytest.mark.skipif(not npyv, reason="could not find any SIMD extension with NPYV support") +class Test_SIMD_MODULE: + + @pytest.mark.parametrize('sfx', all_sfx) + def test_num_lanes(self, sfx): + nlanes = getattr(npyv, "nlanes_" + sfx) + vector = getattr(npyv, "setall_" + sfx)(1) + assert len(vector) == nlanes + + @pytest.mark.parametrize('sfx', all_sfx) + def test_type_name(self, sfx): + vector = getattr(npyv, "setall_" + sfx)(1) + assert vector.__name__ == "npyv_" + sfx + + def test_raises(self): + a, b = [npyv.setall_u32(1)]*2 + for sfx in all_sfx: + vcb = lambda intrin: getattr(npyv, f"{intrin}_{sfx}") + pytest.raises(TypeError, vcb("add"), a) + pytest.raises(TypeError, vcb("add"), a, b, a) + pytest.raises(TypeError, vcb("setall")) + pytest.raises(TypeError, vcb("setall"), [1]) + pytest.raises(TypeError, vcb("load"), 1) + pytest.raises(ValueError, vcb("load"), [1]) + pytest.raises(ValueError, vcb("store"), [1], getattr(npyv, f"reinterpret_{sfx}_u32")(a)) + + @pytest.mark.skipif(not npyv2, reason=( + "could not find a second SIMD extension with NPYV support" + )) + def test_nomix(self): + # mix among submodules isn't allowed + a = npyv.setall_u32(1) + a2 = npyv2.setall_u32(1) + pytest.raises(TypeError, npyv.add_u32, a2, a2) + pytest.raises(TypeError, npyv2.add_u32, a, a) + + @pytest.mark.parametrize('sfx', unsigned_sfx) + def test_unsigned_overflow(self, sfx): + nlanes = getattr(npyv, "nlanes_" + sfx) + maxu = (1 << int(sfx[1:])) - 1 + maxu_72 = (1 << 72) - 1 + lane = getattr(npyv, "setall_" + sfx)(maxu_72)[0] + assert lane == maxu + lanes = getattr(npyv, "load_" + sfx)([maxu_72] * nlanes) + assert lanes == [maxu] * nlanes + lane = getattr(npyv, "setall_" + sfx)(-1)[0] + assert lane == maxu + lanes = getattr(npyv, "load_" + sfx)([-1] * nlanes) + assert lanes == [maxu] * nlanes + + @pytest.mark.parametrize('sfx', signed_sfx) + def test_signed_overflow(self, sfx): + nlanes = getattr(npyv, "nlanes_" + sfx) + maxs_72 = (1 << 71) - 1 + lane = getattr(npyv, "setall_" + sfx)(maxs_72)[0] + assert lane == -1 + lanes = getattr(npyv, "load_" + sfx)([maxs_72] * nlanes) + assert lanes == [-1] * nlanes + mins_72 = -1 << 71 + lane = getattr(npyv, "setall_" + sfx)(mins_72)[0] + assert lane == 0 + lanes = getattr(npyv, "load_" + sfx)([mins_72] * nlanes) + assert lanes == [0] * nlanes + + def test_truncate_f32(self): + if not npyv.simd_f32: + pytest.skip("F32 isn't support by the SIMD extension") + f32 = npyv.setall_f32(0.1)[0] + assert f32 != 0.1 + assert round(f32, 1) == 0.1 + + def test_compare(self): + data_range = range(0, npyv.nlanes_u32) + vdata = npyv.load_u32(data_range) + assert vdata == list(data_range) + assert vdata == tuple(data_range) + for i in data_range: + assert vdata[i] == data_range[i] diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/test_stringdtype.py b/venv/lib/python3.12/site-packages/numpy/_core/tests/test_stringdtype.py new file mode 100644 index 00000000..f087802e --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/tests/test_stringdtype.py @@ -0,0 +1,1750 @@ +import concurrent.futures +import itertools +import os +import pickle +import string +import sys +import tempfile + +import numpy as np +import pytest + +from numpy.dtypes import StringDType +from numpy._core.tests._natype import pd_NA +from numpy.testing import assert_array_equal, IS_WASM, IS_PYPY + + +@pytest.fixture +def string_list(): + return ["abc", "def", "ghi" * 10, "A¢☃€ 😊" * 100, "Abc" * 1000, "DEF"] + + +@pytest.fixture +def random_string_list(): + chars = list(string.ascii_letters + string.digits) + chars = np.array(chars, dtype="U1") + ret = np.random.choice(chars, size=100 * 10, replace=True) + return ret.view("U100") + + +@pytest.fixture(params=[True, False]) +def coerce(request): + return request.param + + +@pytest.fixture( + params=["unset", None, pd_NA, np.nan, float("nan"), "__nan__"], + ids=["unset", "None", "pandas.NA", "np.nan", "float('nan')", "string nan"], +) +def na_object(request): + return request.param + + +def get_dtype(na_object, coerce=True): + # explicit is check for pd_NA because != with pd_NA returns pd_NA + if na_object is pd_NA or na_object != "unset": + return StringDType(na_object=na_object, coerce=coerce) + else: + return StringDType(coerce=coerce) + + +@pytest.fixture() +def dtype(na_object, coerce): + return get_dtype(na_object, coerce) + + +# second copy for cast tests to do a cartesian product over dtypes +@pytest.fixture(params=[True, False]) +def coerce2(request): + return request.param + + +@pytest.fixture( + params=["unset", None, pd_NA, np.nan, float("nan"), "__nan__"], + ids=["unset", "None", "pandas.NA", "np.nan", "float('nan')", "string nan"], +) +def na_object2(request): + return request.param + + +@pytest.fixture() +def dtype2(na_object2, coerce2): + # explicit is check for pd_NA because != with pd_NA returns pd_NA + if na_object2 is pd_NA or na_object2 != "unset": + return StringDType(na_object=na_object2, coerce=coerce2) + else: + return StringDType(coerce=coerce2) + + +def test_dtype_creation(): + hashes = set() + dt = StringDType() + assert not hasattr(dt, "na_object") and dt.coerce is True + hashes.add(hash(dt)) + + dt = StringDType(na_object=None) + assert dt.na_object is None and dt.coerce is True + hashes.add(hash(dt)) + + dt = StringDType(coerce=False) + assert not hasattr(dt, "na_object") and dt.coerce is False + hashes.add(hash(dt)) + + dt = StringDType(na_object=None, coerce=False) + assert dt.na_object is None and dt.coerce is False + hashes.add(hash(dt)) + + assert len(hashes) == 4 + + dt = np.dtype("T") + assert dt == StringDType() + assert dt.kind == "T" + assert dt.char == "T" + + hashes.add(hash(dt)) + assert len(hashes) == 4 + + +def test_dtype_equality(dtype): + assert dtype == dtype + for ch in "SU": + assert dtype != np.dtype(ch) + assert dtype != np.dtype(f"{ch}8") + + +def test_dtype_repr(dtype): + if not hasattr(dtype, "na_object") and dtype.coerce: + assert repr(dtype) == "StringDType()" + elif dtype.coerce: + assert repr(dtype) == f"StringDType(na_object={repr(dtype.na_object)})" + elif not hasattr(dtype, "na_object"): + assert repr(dtype) == "StringDType(coerce=False)" + else: + assert ( + repr(dtype) + == f"StringDType(na_object={repr(dtype.na_object)}, coerce=False)" + ) + + +def test_create_with_na(dtype): + if not hasattr(dtype, "na_object"): + pytest.skip("does not have an na object") + na_val = dtype.na_object + string_list = ["hello", na_val, "world"] + arr = np.array(string_list, dtype=dtype) + assert str(arr) == "[" + " ".join([repr(s) for s in string_list]) + "]" + assert arr[1] is dtype.na_object + + +@pytest.mark.parametrize("i", list(range(5))) +def test_set_replace_na(i): + # Test strings of various lengths can be set to NaN and then replaced. + s_empty = "" + s_short = "0123456789" + s_medium = "abcdefghijklmnopqrstuvwxyz" + s_long = "-=+" * 100 + strings = [s_medium, s_empty, s_short, s_medium, s_long] + a = np.array(strings, StringDType(na_object=np.nan)) + for s in [a[i], s_medium+s_short, s_short, s_empty, s_long]: + a[i] = np.nan + assert np.isnan(a[i]) + a[i] = s + assert a[i] == s + assert_array_equal(a, strings[:i] + [s] + strings[i+1:]) + + +def test_null_roundtripping(): + data = ["hello\0world", "ABC\0DEF\0\0"] + arr = np.array(data, dtype="T") + assert data[0] == arr[0] + assert data[1] == arr[1] + + +def test_string_too_large_error(): + arr = np.array(["a", "b", "c"], dtype=StringDType()) + with pytest.raises(MemoryError): + arr * (2**63 - 2) + + +@pytest.mark.parametrize( + "data", + [ + ["abc", "def", "ghi"], + ["🤣", "📵", "😰"], + ["🚜", "🙃", "😾"], + ["😹", "🚠", "🚌"], + ], +) +def test_array_creation_utf8(dtype, data): + arr = np.array(data, dtype=dtype) + assert str(arr) == "[" + " ".join(["'" + str(d) + "'" for d in data]) + "]" + assert arr.dtype == dtype + + +@pytest.mark.parametrize( + "data", + [ + [1, 2, 3], + [b"abc", b"def", b"ghi"], + [object, object, object], + ], +) +def test_scalars_string_conversion(data, dtype): + if dtype.coerce: + assert_array_equal( + np.array(data, dtype=dtype), + np.array([str(d) for d in data], dtype=dtype), + ) + else: + with pytest.raises(ValueError): + np.array(data, dtype=dtype) + + +@pytest.mark.parametrize( + ("strings"), + [ + ["this", "is", "an", "array"], + ["€", "", "😊"], + ["A¢☃€ 😊", " A☃€¢😊", "☃€😊 A¢", "😊☃A¢ €"], + ], +) +def test_self_casts(dtype, dtype2, strings): + if hasattr(dtype, "na_object"): + strings = strings + [dtype.na_object] + elif hasattr(dtype2, "na_object"): + strings = strings + [""] + arr = np.array(strings, dtype=dtype) + newarr = arr.astype(dtype2) + + if hasattr(dtype, "na_object") and not hasattr(dtype2, "na_object"): + assert newarr[-1] == str(dtype.na_object) + with pytest.raises(TypeError): + arr.astype(dtype2, casting="safe") + elif hasattr(dtype, "na_object") and hasattr(dtype2, "na_object"): + assert newarr[-1] is dtype2.na_object + arr.astype(dtype2, casting="safe") + elif hasattr(dtype2, "na_object"): + assert newarr[-1] == "" + arr.astype(dtype2, casting="safe") + else: + arr.astype(dtype2, casting="safe") + + if hasattr(dtype, "na_object") and hasattr(dtype2, "na_object"): + na1 = dtype.na_object + na2 = dtype2.na_object + if (na1 is not na2 and + # check for pd_NA first because bool(pd_NA) is an error + ((na1 is pd_NA or na2 is pd_NA) or + # the second check is a NaN check, spelled this way + # to avoid errors from math.isnan and np.isnan + (na1 != na2 and not (na1 != na1 and na2 != na2)))): + with pytest.raises(TypeError): + arr[:-1] == newarr[:-1] + return + assert_array_equal(arr[:-1], newarr[:-1]) + + +@pytest.mark.parametrize( + ("strings"), + [ + ["this", "is", "an", "array"], + ["€", "", "😊"], + ["A¢☃€ 😊", " A☃€¢😊", "☃€😊 A¢", "😊☃A¢ €"], + ], +) +class TestStringLikeCasts: + def test_unicode_casts(self, dtype, strings): + arr = np.array(strings, dtype=np.str_).astype(dtype) + expected = np.array(strings, dtype=dtype) + assert_array_equal(arr, expected) + + arr_as_U8 = expected.astype("U8") + assert_array_equal(arr_as_U8, np.array(strings, dtype="U8")) + assert_array_equal(arr_as_U8.astype(dtype), arr) + arr_as_U3 = expected.astype("U3") + assert_array_equal(arr_as_U3, np.array(strings, dtype="U3")) + assert_array_equal( + arr_as_U3.astype(dtype), + np.array([s[:3] for s in strings], dtype=dtype), + ) + + def test_void_casts(self, dtype, strings): + sarr = np.array(strings, dtype=dtype) + utf8_bytes = [s.encode("utf-8") for s in strings] + void_dtype = f"V{max([len(s) for s in utf8_bytes])}" + varr = np.array(utf8_bytes, dtype=void_dtype) + assert_array_equal(varr, sarr.astype(void_dtype)) + assert_array_equal(varr.astype(dtype), sarr) + + def test_bytes_casts(self, dtype, strings): + sarr = np.array(strings, dtype=dtype) + try: + utf8_bytes = [s.encode("ascii") for s in strings] + bytes_dtype = f"S{max([len(s) for s in utf8_bytes])}" + barr = np.array(utf8_bytes, dtype=bytes_dtype) + assert_array_equal(barr, sarr.astype(bytes_dtype)) + assert_array_equal(barr.astype(dtype), sarr) + except UnicodeEncodeError: + with pytest.raises(UnicodeEncodeError): + sarr.astype("S20") + + +def test_additional_unicode_cast(random_string_list, dtype): + arr = np.array(random_string_list, dtype=dtype) + # test that this short-circuits correctly + assert_array_equal(arr, arr.astype(arr.dtype)) + # tests the casts via the comparison promoter + assert_array_equal(arr, arr.astype(random_string_list.dtype)) + + +def test_insert_scalar(dtype, string_list): + """Test that inserting a scalar works.""" + arr = np.array(string_list, dtype=dtype) + scalar_instance = "what" + arr[1] = scalar_instance + assert_array_equal( + arr, + np.array(string_list[:1] + ["what"] + string_list[2:], dtype=dtype), + ) + + +comparison_operators = [ + np.equal, + np.not_equal, + np.greater, + np.greater_equal, + np.less, + np.less_equal, +] + + +@pytest.mark.parametrize("op", comparison_operators) +@pytest.mark.parametrize("o_dtype", [np.str_, object, StringDType()]) +def test_comparisons(string_list, dtype, op, o_dtype): + sarr = np.array(string_list, dtype=dtype) + oarr = np.array(string_list, dtype=o_dtype) + + # test that comparison operators work + res = op(sarr, sarr) + ores = op(oarr, oarr) + # test that promotion works as well + orres = op(sarr, oarr) + olres = op(oarr, sarr) + + assert_array_equal(res, ores) + assert_array_equal(res, orres) + assert_array_equal(res, olres) + + # test we get the correct answer for unequal length strings + sarr2 = np.array([s + "2" for s in string_list], dtype=dtype) + oarr2 = np.array([s + "2" for s in string_list], dtype=o_dtype) + + res = op(sarr, sarr2) + ores = op(oarr, oarr2) + olres = op(oarr, sarr2) + orres = op(sarr, oarr2) + + assert_array_equal(res, ores) + assert_array_equal(res, olres) + assert_array_equal(res, orres) + + res = op(sarr2, sarr) + ores = op(oarr2, oarr) + olres = op(oarr2, sarr) + orres = op(sarr2, oarr) + + assert_array_equal(res, ores) + assert_array_equal(res, olres) + assert_array_equal(res, orres) + + +def test_isnan(dtype, string_list): + if not hasattr(dtype, "na_object"): + pytest.skip("no na support") + sarr = np.array(string_list + [dtype.na_object], dtype=dtype) + is_nan = isinstance(dtype.na_object, float) and np.isnan(dtype.na_object) + bool_errors = 0 + try: + bool(dtype.na_object) + except TypeError: + bool_errors = 1 + if is_nan or bool_errors: + # isnan is only true when na_object is a NaN + assert_array_equal( + np.isnan(sarr), + np.array([0] * len(string_list) + [1], dtype=np.bool), + ) + else: + assert not np.any(np.isnan(sarr)) + + +def test_pickle(dtype, string_list): + arr = np.array(string_list, dtype=dtype) + + with tempfile.NamedTemporaryFile("wb", delete=False) as f: + pickle.dump([arr, dtype], f) + + with open(f.name, "rb") as f: + res = pickle.load(f) + + assert_array_equal(res[0], arr) + assert res[1] == dtype + + os.remove(f.name) + + +@pytest.mark.parametrize( + "strings", + [ + ["left", "right", "leftovers", "righty", "up", "down"], + [ + "left" * 10, + "right" * 10, + "leftovers" * 10, + "righty" * 10, + "up" * 10, + ], + ["🤣🤣", "🤣", "📵", "😰"], + ["🚜", "🙃", "😾"], + ["😹", "🚠", "🚌"], + ["A¢☃€ 😊", " A☃€¢😊", "☃€😊 A¢", "😊☃A¢ €"], + ], +) +def test_sort(dtype, strings): + """Test that sorting matches python's internal sorting.""" + + def test_sort(strings, arr_sorted): + arr = np.array(strings, dtype=dtype) + np.random.default_rng().shuffle(arr) + na_object = getattr(arr.dtype, "na_object", "") + if na_object is None and None in strings: + with pytest.raises( + ValueError, + match="Cannot compare null that is not a nan-like value", + ): + arr.sort() + else: + arr.sort() + assert np.array_equal(arr, arr_sorted, equal_nan=True) + + # make a copy so we don't mutate the lists in the fixture + strings = strings.copy() + arr_sorted = np.array(sorted(strings), dtype=dtype) + test_sort(strings, arr_sorted) + + if not hasattr(dtype, "na_object"): + return + + # make sure NAs get sorted to the end of the array and string NAs get + # sorted like normal strings + strings.insert(0, dtype.na_object) + strings.insert(2, dtype.na_object) + # can't use append because doing that with NA converts + # the result to object dtype + if not isinstance(dtype.na_object, str): + arr_sorted = np.array( + arr_sorted.tolist() + [dtype.na_object, dtype.na_object], + dtype=dtype, + ) + else: + arr_sorted = np.array(sorted(strings), dtype=dtype) + + test_sort(strings, arr_sorted) + + +@pytest.mark.parametrize( + "strings", + [ + ["A¢☃€ 😊", " A☃€¢😊", "☃€😊 A¢", "😊☃A¢ €"], + ["A¢☃€ 😊", "", " ", " "], + ["", "a", "😸", "ááðfáíóåéë"], + ], +) +def test_nonzero(strings, na_object): + dtype = get_dtype(na_object) + arr = np.array(strings, dtype=dtype) + is_nonzero = np.array( + [i for i, item in enumerate(strings) if len(item) != 0]) + assert_array_equal(arr.nonzero()[0], is_nonzero) + + if na_object is not pd_NA and na_object == 'unset': + return + + strings_with_na = np.array(strings + [na_object], dtype=dtype) + is_nan = np.isnan(np.array([dtype.na_object], dtype=dtype))[0] + + if is_nan: + assert strings_with_na.nonzero()[0][-1] == 4 + else: + assert strings_with_na.nonzero()[0][-1] == 3 + + # check that the casting to bool and nonzero give consistent results + assert_array_equal(strings_with_na[strings_with_na.nonzero()], + strings_with_na[strings_with_na.astype(bool)]) + + +def test_where(string_list, na_object): + dtype = get_dtype(na_object) + a = np.array(string_list, dtype=dtype) + b = a[::-1] + res = np.where([True, False, True, False, True, False], a, b) + assert_array_equal(res, [a[0], b[1], a[2], b[3], a[4], b[5]]) + + +def test_fancy_indexing(string_list): + sarr = np.array(string_list, dtype="T") + assert_array_equal(sarr, sarr[np.arange(sarr.shape[0])]) + + # see gh-27003 and gh-27053 + for ind in [[True, True], [0, 1], ...]: + for lop in [['a'*16, 'b'*16], ['', '']]: + a = np.array(lop, dtype="T") + rop = ['d'*16, 'e'*16] + for b in [rop, np.array(rop, dtype="T")]: + a[ind] = b + assert_array_equal(a, b) + assert a[0] == 'd'*16 + + +def test_creation_functions(): + assert_array_equal(np.zeros(3, dtype="T"), ["", "", ""]) + assert_array_equal(np.empty(3, dtype="T"), ["", "", ""]) + + assert np.zeros(3, dtype="T")[0] == "" + assert np.empty(3, dtype="T")[0] == "" + + +def test_concatenate(string_list): + sarr = np.array(string_list, dtype="T") + sarr_cat = np.array(string_list + string_list, dtype="T") + + assert_array_equal(np.concatenate([sarr], axis=0), sarr) + + +def test_resize_method(string_list): + sarr = np.array(string_list, dtype="T") + if IS_PYPY: + sarr.resize(len(string_list)+3, refcheck=False) + else: + sarr.resize(len(string_list)+3) + assert_array_equal(sarr, np.array(string_list + ['']*3, dtype="T")) + + +def test_create_with_copy_none(string_list): + arr = np.array(string_list, dtype=StringDType()) + # create another stringdtype array with an arena that has a different + # in-memory layout than the first array + arr_rev = np.array(string_list[::-1], dtype=StringDType()) + + # this should create a copy and the resulting array + # shouldn't share an allocator or arena with arr_rev, despite + # explicitly passing arr_rev.dtype + arr_copy = np.array(arr, copy=None, dtype=arr_rev.dtype) + np.testing.assert_array_equal(arr, arr_copy) + assert arr_copy.base is None + + with pytest.raises(ValueError, match="Unable to avoid copy"): + np.array(arr, copy=False, dtype=arr_rev.dtype) + + # because we're using arr's dtype instance, the view is safe + arr_view = np.array(arr, copy=None, dtype=arr.dtype) + np.testing.assert_array_equal(arr, arr) + np.testing.assert_array_equal(arr_view[::-1], arr_rev) + assert arr_view is arr + + +def test_astype_copy_false(): + orig_dt = StringDType() + arr = np.array(["hello", "world"], dtype=StringDType()) + assert not arr.astype(StringDType(coerce=False), copy=False).dtype.coerce + + assert arr.astype(orig_dt, copy=False).dtype is orig_dt + +@pytest.mark.parametrize( + "strings", + [ + ["left", "right", "leftovers", "righty", "up", "down"], + ["🤣🤣", "🤣", "📵", "😰"], + ["🚜", "🙃", "😾"], + ["😹", "🚠", "🚌"], + ["A¢☃€ 😊", " A☃€¢😊", "☃€😊 A¢", "😊☃A¢ €"], + ], +) +def test_argmax(strings): + """Test that argmax/argmin matches what python calculates.""" + arr = np.array(strings, dtype="T") + assert np.argmax(arr) == strings.index(max(strings)) + assert np.argmin(arr) == strings.index(min(strings)) + + +@pytest.mark.parametrize( + "arrfunc,expected", + [ + [np.sort, None], + [np.nonzero, (np.array([], dtype=np.int_),)], + [np.argmax, 0], + [np.argmin, 0], + ], +) +def test_arrfuncs_zeros(arrfunc, expected): + arr = np.zeros(10, dtype="T") + result = arrfunc(arr) + if expected is None: + expected = arr + assert_array_equal(result, expected, strict=True) + + +@pytest.mark.parametrize( + ("strings", "cast_answer", "any_answer", "all_answer"), + [ + [["hello", "world"], [True, True], True, True], + [["", ""], [False, False], False, False], + [["hello", ""], [True, False], True, False], + [["", "world"], [False, True], True, False], + ], +) +def test_cast_to_bool(strings, cast_answer, any_answer, all_answer): + sarr = np.array(strings, dtype="T") + assert_array_equal(sarr.astype("bool"), cast_answer) + + assert np.any(sarr) == any_answer + assert np.all(sarr) == all_answer + + +@pytest.mark.parametrize( + ("strings", "cast_answer"), + [ + [[True, True], ["True", "True"]], + [[False, False], ["False", "False"]], + [[True, False], ["True", "False"]], + [[False, True], ["False", "True"]], + ], +) +def test_cast_from_bool(strings, cast_answer): + barr = np.array(strings, dtype=bool) + assert_array_equal(barr.astype("T"), np.array(cast_answer, dtype="T")) + + +@pytest.mark.parametrize("bitsize", [8, 16, 32, 64]) +@pytest.mark.parametrize("signed", [True, False]) +def test_sized_integer_casts(bitsize, signed): + idtype = f"int{bitsize}" + if signed: + inp = [-(2**p - 1) for p in reversed(range(bitsize - 1))] + inp += [2**p - 1 for p in range(1, bitsize - 1)] + else: + idtype = "u" + idtype + inp = [2**p - 1 for p in range(bitsize)] + ainp = np.array(inp, dtype=idtype) + assert_array_equal(ainp, ainp.astype("T").astype(idtype)) + + # safe casting works + ainp.astype("T", casting="safe") + + with pytest.raises(TypeError): + ainp.astype("T").astype(idtype, casting="safe") + + oob = [str(2**bitsize), str(-(2**bitsize))] + with pytest.raises(OverflowError): + np.array(oob, dtype="T").astype(idtype) + + with pytest.raises(ValueError): + np.array(["1", np.nan, "3"], + dtype=StringDType(na_object=np.nan)).astype(idtype) + + +@pytest.mark.parametrize("typename", ["byte", "short", "int", "longlong"]) +@pytest.mark.parametrize("signed", ["", "u"]) +def test_unsized_integer_casts(typename, signed): + idtype = f"{signed}{typename}" + + inp = [1, 2, 3, 4] + ainp = np.array(inp, dtype=idtype) + assert_array_equal(ainp, ainp.astype("T").astype(idtype)) + + +@pytest.mark.parametrize( + "typename", + [ + pytest.param( + "longdouble", + marks=pytest.mark.xfail( + np.dtypes.LongDoubleDType() != np.dtypes.Float64DType(), + reason="numpy lacks an ld2a implementation", + strict=True, + ), + ), + "float64", + "float32", + "float16", + ], +) +def test_float_casts(typename): + inp = [1.1, 2.8, -3.2, 2.7e4] + ainp = np.array(inp, dtype=typename) + assert_array_equal(ainp, ainp.astype("T").astype(typename)) + + inp = [0.1] + sres = np.array(inp, dtype=typename).astype("T") + res = sres.astype(typename) + assert_array_equal(np.array(inp, dtype=typename), res) + assert sres[0] == "0.1" + + if typename == "longdouble": + # let's not worry about platform-dependent rounding of longdouble + return + + fi = np.finfo(typename) + + inp = [1e-324, fi.smallest_subnormal, -1e-324, -fi.smallest_subnormal] + eres = [0, fi.smallest_subnormal, -0, -fi.smallest_subnormal] + res = np.array(inp, dtype=typename).astype("T").astype(typename) + assert_array_equal(eres, res) + + inp = [2e308, fi.max, -2e308, fi.min] + eres = [np.inf, fi.max, -np.inf, fi.min] + res = np.array(inp, dtype=typename).astype("T").astype(typename) + assert_array_equal(eres, res) + + +@pytest.mark.parametrize( + "typename", + [ + "csingle", + "cdouble", + pytest.param( + "clongdouble", + marks=pytest.mark.xfail( + np.dtypes.CLongDoubleDType() != np.dtypes.Complex128DType(), + reason="numpy lacks an ld2a implementation", + strict=True, + ), + ), + ], +) +def test_cfloat_casts(typename): + inp = [1.1 + 1.1j, 2.8 + 2.8j, -3.2 - 3.2j, 2.7e4 + 2.7e4j] + ainp = np.array(inp, dtype=typename) + assert_array_equal(ainp, ainp.astype("T").astype(typename)) + + inp = [0.1 + 0.1j] + sres = np.array(inp, dtype=typename).astype("T") + res = sres.astype(typename) + assert_array_equal(np.array(inp, dtype=typename), res) + assert sres[0] == "(0.1+0.1j)" + + +def test_take(string_list): + sarr = np.array(string_list, dtype="T") + res = sarr.take(np.arange(len(string_list))) + assert_array_equal(sarr, res) + + # make sure it also works for out + out = np.empty(len(string_list), dtype="T") + out[0] = "hello" + res = sarr.take(np.arange(len(string_list)), out=out) + assert res is out + assert_array_equal(sarr, res) + + +@pytest.mark.parametrize("use_out", [True, False]) +@pytest.mark.parametrize( + "ufunc_name,func", + [ + ("min", min), + ("max", max), + ], +) +def test_ufuncs_minmax(string_list, ufunc_name, func, use_out): + """Test that the min/max ufuncs match Python builtin min/max behavior.""" + arr = np.array(string_list, dtype="T") + uarr = np.array(string_list, dtype=str) + res = np.array(func(string_list), dtype="T") + assert_array_equal(getattr(arr, ufunc_name)(), res) + + ufunc = getattr(np, ufunc_name + "imum") + + if use_out: + res = ufunc(arr, arr, out=arr) + else: + res = ufunc(arr, arr) + + assert_array_equal(uarr, res) + assert_array_equal(getattr(arr, ufunc_name)(), func(string_list)) + + +def test_max_regression(): + arr = np.array(['y', 'y', 'z'], dtype="T") + assert arr.max() == 'z' + + +@pytest.mark.parametrize("use_out", [True, False]) +@pytest.mark.parametrize( + "other_strings", + [ + ["abc", "def" * 500, "ghi" * 16, "🤣" * 100, "📵", "😰"], + ["🚜", "🙃", "😾", "😹", "🚠", "🚌"], + ["🥦", "¨", "⨯", "∰ ", "⨌ ", "⎶ "], + ], +) +def test_ufunc_add(dtype, string_list, other_strings, use_out): + arr1 = np.array(string_list, dtype=dtype) + arr2 = np.array(other_strings, dtype=dtype) + result = np.array([a + b for a, b in zip(arr1, arr2)], dtype=dtype) + + if use_out: + res = np.add(arr1, arr2, out=arr1) + else: + res = np.add(arr1, arr2) + + assert_array_equal(res, result) + + if not hasattr(dtype, "na_object"): + return + + is_nan = isinstance(dtype.na_object, float) and np.isnan(dtype.na_object) + is_str = isinstance(dtype.na_object, str) + bool_errors = 0 + try: + bool(dtype.na_object) + except TypeError: + bool_errors = 1 + + arr1 = np.array([dtype.na_object] + string_list, dtype=dtype) + arr2 = np.array(other_strings + [dtype.na_object], dtype=dtype) + + if is_nan or bool_errors or is_str: + res = np.add(arr1, arr2) + assert_array_equal(res[1:-1], arr1[1:-1] + arr2[1:-1]) + if not is_str: + assert res[0] is dtype.na_object and res[-1] is dtype.na_object + else: + assert res[0] == dtype.na_object + arr2[0] + assert res[-1] == arr1[-1] + dtype.na_object + else: + with pytest.raises(ValueError): + np.add(arr1, arr2) + + +def test_ufunc_add_reduce(dtype): + values = ["a", "this is a long string", "c"] + arr = np.array(values, dtype=dtype) + out = np.empty((), dtype=dtype) + + expected = np.array("".join(values), dtype=dtype) + assert_array_equal(np.add.reduce(arr), expected) + + np.add.reduce(arr, out=out) + assert_array_equal(out, expected) + + +def test_add_promoter(string_list): + arr = np.array(string_list, dtype=StringDType()) + lresult = np.array(["hello" + s for s in string_list], dtype=StringDType()) + rresult = np.array([s + "hello" for s in string_list], dtype=StringDType()) + + for op in ["hello", np.str_("hello"), np.array(["hello"])]: + assert_array_equal(op + arr, lresult) + assert_array_equal(arr + op, rresult) + + # The promoter should be able to handle things if users pass `dtype=` + res = np.add("hello", string_list, dtype=StringDType) + assert res.dtype == StringDType() + + # The promoter should not kick in if users override the input, + # which means arr is cast, this fails because of the unknown length. + with pytest.raises(TypeError, match="cannot cast dtype"): + np.add(arr, "add", signature=("U", "U", None), casting="unsafe") + + # But it must simply reject the following: + with pytest.raises(TypeError, match=".*did not contain a loop"): + np.add(arr, "add", signature=(None, "U", None)) + + with pytest.raises(TypeError, match=".*did not contain a loop"): + np.add("a", "b", signature=("U", "U", StringDType)) + + +def test_add_no_legacy_promote_with_signature(): + # Possibly misplaced, but useful to test with string DType. We check that + # if there is clearly no loop found, a stray `dtype=` doesn't break things + # Regression test for the bad error in gh-26735 + # (If legacy promotion is gone, this can be deleted...) + with pytest.raises(TypeError, match=".*did not contain a loop"): + np.add("3", 6, dtype=StringDType) + + +def test_add_promoter_reduce(): + # Exact TypeError could change, but ensure StringDtype doesn't match + with pytest.raises(TypeError, match="the resolved dtypes are not"): + np.add.reduce(np.array(["a", "b"], dtype="U")) + + # On the other hand, using `dtype=T` in the *ufunc* should work. + np.add.reduce(np.array(["a", "b"], dtype="U"), dtype=np.dtypes.StringDType) + + +def test_multiply_reduce(): + # At the time of writing (NumPy 2.0) this is very limited (and rather + # ridiculous anyway). But it works and actually makes some sense... + # (NumPy does not allow non-scalar initial values) + repeats = np.array([2, 3, 4]) + val = "school-🚌" + res = np.multiply.reduce(repeats, initial=val, dtype=np.dtypes.StringDType) + assert res == val * np.prod(repeats) + + +def test_multiply_two_string_raises(): + arr = np.array(["hello", "world"], dtype="T") + with pytest.raises(np._core._exceptions._UFuncNoLoopError): + np.multiply(arr, arr) + + +@pytest.mark.parametrize("use_out", [True, False]) +@pytest.mark.parametrize("other", [2, [2, 1, 3, 4, 1, 3]]) +@pytest.mark.parametrize( + "other_dtype", + [ + None, + "int8", + "int16", + "int32", + "int64", + "uint8", + "uint16", + "uint32", + "uint64", + "short", + "int", + "intp", + "long", + "longlong", + "ushort", + "uint", + "uintp", + "ulong", + "ulonglong", + ], +) +def test_ufunc_multiply(dtype, string_list, other, other_dtype, use_out): + """Test the two-argument ufuncs match python builtin behavior.""" + arr = np.array(string_list, dtype=dtype) + if other_dtype is not None: + other_dtype = np.dtype(other_dtype) + try: + len(other) + result = [s * o for s, o in zip(string_list, other)] + other = np.array(other) + if other_dtype is not None: + other = other.astype(other_dtype) + except TypeError: + if other_dtype is not None: + other = other_dtype.type(other) + result = [s * other for s in string_list] + + if use_out: + arr_cache = arr.copy() + lres = np.multiply(arr, other, out=arr) + assert_array_equal(lres, result) + arr[:] = arr_cache + assert lres is arr + arr *= other + assert_array_equal(arr, result) + arr[:] = arr_cache + rres = np.multiply(other, arr, out=arr) + assert rres is arr + assert_array_equal(rres, result) + else: + lres = arr * other + assert_array_equal(lres, result) + rres = other * arr + assert_array_equal(rres, result) + + if not hasattr(dtype, "na_object"): + return + + is_nan = np.isnan(np.array([dtype.na_object], dtype=dtype))[0] + is_str = isinstance(dtype.na_object, str) + bool_errors = 0 + try: + bool(dtype.na_object) + except TypeError: + bool_errors = 1 + + arr = np.array(string_list + [dtype.na_object], dtype=dtype) + + try: + len(other) + other = np.append(other, 3) + if other_dtype is not None: + other = other.astype(other_dtype) + except TypeError: + pass + + if is_nan or bool_errors or is_str: + for res in [arr * other, other * arr]: + assert_array_equal(res[:-1], result) + if not is_str: + assert res[-1] is dtype.na_object + else: + try: + assert res[-1] == dtype.na_object * other[-1] + except (IndexError, TypeError): + assert res[-1] == dtype.na_object * other + else: + with pytest.raises(TypeError): + arr * other + with pytest.raises(TypeError): + other * arr + + +def test_findlike_promoters(): + r = "Wally" + l = "Where's Wally?" + s = np.int32(3) + e = np.int8(13) + for dtypes in [("T", "U"), ("U", "T")]: + for function, answer in [ + (np.strings.index, 8), + (np.strings.endswith, True), + ]: + assert answer == function( + np.array(l, dtype=dtypes[0]), np.array(r, dtype=dtypes[1]), s, e + ) + + +def test_strip_promoter(): + arg = ["Hello!!!!", "Hello??!!"] + strip_char = "!" + answer = ["Hello", "Hello??"] + for dtypes in [("T", "U"), ("U", "T")]: + result = np.strings.strip( + np.array(arg, dtype=dtypes[0]), + np.array(strip_char, dtype=dtypes[1]) + ) + assert_array_equal(result, answer) + assert result.dtype.char == "T" + + +def test_replace_promoter(): + arg = ["Hello, planet!", "planet, Hello!"] + old = "planet" + new = "world" + answer = ["Hello, world!", "world, Hello!"] + for dtypes in itertools.product("TU", repeat=3): + if dtypes == ("U", "U", "U"): + continue + answer_arr = np.strings.replace( + np.array(arg, dtype=dtypes[0]), + np.array(old, dtype=dtypes[1]), + np.array(new, dtype=dtypes[2]), + ) + assert_array_equal(answer_arr, answer) + assert answer_arr.dtype.char == "T" + + +def test_center_promoter(): + arg = ["Hello", "planet!"] + fillchar = "/" + for dtypes in [("T", "U"), ("U", "T")]: + answer = np.strings.center( + np.array(arg, dtype=dtypes[0]), 9, np.array(fillchar, dtype=dtypes[1]) + ) + assert_array_equal(answer, ["//Hello//", "/planet!/"]) + assert answer.dtype.char == "T" + + +DATETIME_INPUT = [ + np.datetime64("1923-04-14T12:43:12"), + np.datetime64("1994-06-21T14:43:15"), + np.datetime64("2001-10-15T04:10:32"), + np.datetime64("NaT"), + np.datetime64("1995-11-25T16:02:16"), + np.datetime64("2005-01-04T03:14:12"), + np.datetime64("2041-12-03T14:05:03"), +] + + +TIMEDELTA_INPUT = [ + np.timedelta64(12358, "s"), + np.timedelta64(23, "s"), + np.timedelta64(74, "s"), + np.timedelta64("NaT"), + np.timedelta64(23, "s"), + np.timedelta64(73, "s"), + np.timedelta64(7, "s"), +] + + +@pytest.mark.parametrize( + "input_data, input_dtype", + [ + (DATETIME_INPUT, "M8[s]"), + (TIMEDELTA_INPUT, "m8[s]") + ] +) +def test_datetime_timedelta_cast(dtype, input_data, input_dtype): + + a = np.array(input_data, dtype=input_dtype) + + has_na = hasattr(dtype, "na_object") + is_str = isinstance(getattr(dtype, "na_object", None), str) + + if not has_na or is_str: + a = np.delete(a, 3) + + sa = a.astype(dtype) + ra = sa.astype(a.dtype) + + if has_na and not is_str: + assert sa[3] is dtype.na_object + assert np.isnat(ra[3]) + + assert_array_equal(a, ra) + + if has_na and not is_str: + # don't worry about comparing how NaT is converted + sa = np.delete(sa, 3) + a = np.delete(a, 3) + + if input_dtype.startswith("M"): + assert_array_equal(sa, a.astype("U")) + else: + # The timedelta to unicode cast produces strings + # that aren't round-trippable and we don't want to + # reproduce that behavior in stringdtype + assert_array_equal(sa, a.astype("int64").astype("U")) + + +def test_nat_casts(): + s = 'nat' + all_nats = itertools.product(*zip(s.upper(), s.lower())) + all_nats = list(map(''.join, all_nats)) + NaT_dt = np.datetime64('NaT') + NaT_td = np.timedelta64('NaT') + for na_object in [np._NoValue, None, np.nan, 'nat', '']: + # numpy treats empty string and all case combinations of 'nat' as NaT + dtype = StringDType(na_object=na_object) + arr = np.array([''] + all_nats, dtype=dtype) + dt_array = arr.astype('M8[s]') + td_array = arr.astype('m8[s]') + assert_array_equal(dt_array, NaT_dt) + assert_array_equal(td_array, NaT_td) + + if na_object is np._NoValue: + output_object = 'NaT' + else: + output_object = na_object + + for arr in [dt_array, td_array]: + assert_array_equal( + arr.astype(dtype), + np.array([output_object]*arr.size, dtype=dtype)) + + +def test_nat_conversion(): + for nat in [np.datetime64("NaT", "s"), np.timedelta64("NaT", "s")]: + with pytest.raises(ValueError, match="string coercion is disabled"): + np.array(["a", nat], dtype=StringDType(coerce=False)) + + +def test_growing_strings(dtype): + # growing a string leads to a heap allocation, this tests to make sure + # we do that bookkeeping correctly for all possible starting cases + data = [ + "hello", # a short string + "abcdefghijklmnopqestuvwxyz", # a medium heap-allocated string + "hello" * 200, # a long heap-allocated string + ] + + arr = np.array(data, dtype=dtype) + uarr = np.array(data, dtype=str) + + for _ in range(5): + arr = arr + arr + uarr = uarr + uarr + + assert_array_equal(arr, uarr) + + +@pytest.mark.skipif(IS_WASM, reason="no threading support in wasm") +def test_threaded_access_and_mutation(dtype, random_string_list): + # this test uses an RNG and may crash or cause deadlocks if there is a + # threading bug + rng = np.random.default_rng(0x4D3D3D3) + + def func(arr): + rnd = rng.random() + # either write to random locations in the array, compute a ufunc, or + # re-initialize the array + if rnd < 0.25: + num = np.random.randint(0, arr.size) + arr[num] = arr[num] + "hello" + elif rnd < 0.5: + if rnd < 0.375: + np.add(arr, arr) + else: + np.add(arr, arr, out=arr) + elif rnd < 0.75: + if rnd < 0.875: + np.multiply(arr, np.int64(2)) + else: + np.multiply(arr, np.int64(2), out=arr) + else: + arr[:] = random_string_list + + with concurrent.futures.ThreadPoolExecutor(max_workers=8) as tpe: + arr = np.array(random_string_list, dtype=dtype) + futures = [tpe.submit(func, arr) for _ in range(500)] + + for f in futures: + f.result() + + +UFUNC_TEST_DATA = [ + "hello" * 10, + "Ae¢☃€ 😊" * 20, + "entry\nwith\nnewlines", + "entry\twith\ttabs", +] + + +@pytest.fixture +def string_array(dtype): + return np.array(UFUNC_TEST_DATA, dtype=dtype) + + +@pytest.fixture +def unicode_array(): + return np.array(UFUNC_TEST_DATA, dtype=np.str_) + + +NAN_PRESERVING_FUNCTIONS = [ + "capitalize", + "expandtabs", + "lower", + "lstrip", + "rstrip", + "splitlines", + "strip", + "swapcase", + "title", + "upper", +] + +BOOL_OUTPUT_FUNCTIONS = [ + "isalnum", + "isalpha", + "isdigit", + "islower", + "isspace", + "istitle", + "isupper", + "isnumeric", + "isdecimal", +] + +UNARY_FUNCTIONS = [ + "str_len", + "capitalize", + "expandtabs", + "isalnum", + "isalpha", + "isdigit", + "islower", + "isspace", + "istitle", + "isupper", + "lower", + "lstrip", + "rstrip", + "splitlines", + "strip", + "swapcase", + "title", + "upper", + "isnumeric", + "isdecimal", + "isalnum", + "islower", + "istitle", + "isupper", +] + +UNIMPLEMENTED_VEC_STRING_FUNCTIONS = [ + "capitalize", + "expandtabs", + "lower", + "splitlines", + "swapcase", + "title", + "upper", +] + +ONLY_IN_NP_CHAR = [ + "join", + "split", + "rsplit", + "splitlines" +] + + +@pytest.mark.parametrize("function_name", UNARY_FUNCTIONS) +def test_unary(string_array, unicode_array, function_name): + if function_name in ONLY_IN_NP_CHAR: + func = getattr(np.char, function_name) + else: + func = getattr(np.strings, function_name) + dtype = string_array.dtype + sres = func(string_array) + ures = func(unicode_array) + if sres.dtype == StringDType(): + ures = ures.astype(StringDType()) + assert_array_equal(sres, ures) + + if not hasattr(dtype, "na_object"): + return + + is_nan = np.isnan(np.array([dtype.na_object], dtype=dtype))[0] + is_str = isinstance(dtype.na_object, str) + na_arr = np.insert(string_array, 0, dtype.na_object) + + if function_name in UNIMPLEMENTED_VEC_STRING_FUNCTIONS: + if not is_str: + # to avoid these errors we'd need to add NA support to _vec_string + with pytest.raises((ValueError, TypeError)): + func(na_arr) + else: + if function_name == "splitlines": + assert func(na_arr)[0] == func(dtype.na_object)[()] + else: + assert func(na_arr)[0] == func(dtype.na_object) + return + if function_name == "str_len" and not is_str: + # str_len always errors for any non-string null, even NA ones because + # it has an integer result + with pytest.raises(ValueError): + func(na_arr) + return + if function_name in BOOL_OUTPUT_FUNCTIONS: + if is_nan: + assert func(na_arr)[0] is np.False_ + elif is_str: + assert func(na_arr)[0] == func(dtype.na_object) + else: + with pytest.raises(ValueError): + func(na_arr) + return + if not (is_nan or is_str): + with pytest.raises(ValueError): + func(na_arr) + return + res = func(na_arr) + if is_nan and function_name in NAN_PRESERVING_FUNCTIONS: + assert res[0] is dtype.na_object + elif is_str: + assert res[0] == func(dtype.na_object) + + +unicode_bug_fail = pytest.mark.xfail( + reason="unicode output width is buggy", strict=True +) + +# None means that the argument is a string array +BINARY_FUNCTIONS = [ + ("add", (None, None)), + ("multiply", (None, 2)), + ("mod", ("format: %s", None)), + ("center", (None, 25)), + ("count", (None, "A")), + ("encode", (None, "UTF-8")), + ("endswith", (None, "lo")), + ("find", (None, "A")), + ("index", (None, "e")), + ("join", ("-", None)), + ("ljust", (None, 12)), + ("lstrip", (None, "A")), + ("partition", (None, "A")), + ("replace", (None, "A", "B")), + ("rfind", (None, "A")), + ("rindex", (None, "e")), + ("rjust", (None, 12)), + ("rsplit", (None, "A")), + ("rstrip", (None, "A")), + ("rpartition", (None, "A")), + ("split", (None, "A")), + ("strip", (None, "A")), + ("startswith", (None, "A")), + ("zfill", (None, 12)), +] + +PASSES_THROUGH_NAN_NULLS = [ + "add", + "center", + "ljust", + "multiply", + "replace", + "rjust", + "strip", + "lstrip", + "rstrip", + "replace" + "zfill", +] + +NULLS_ARE_FALSEY = [ + "startswith", + "endswith", +] + +NULLS_ALWAYS_ERROR = [ + "count", + "find", + "rfind", +] + +SUPPORTS_NULLS = ( + PASSES_THROUGH_NAN_NULLS + + NULLS_ARE_FALSEY + + NULLS_ALWAYS_ERROR +) + + +def call_func(func, args, array, sanitize=True): + if args == (None, None): + return func(array, array) + if args[0] is None: + if sanitize: + san_args = tuple( + np.array(arg, dtype=array.dtype) if isinstance(arg, str) else + arg for arg in args[1:] + ) + else: + san_args = args[1:] + return func(array, *san_args) + if args[1] is None: + return func(args[0], array) + # shouldn't ever happen + assert 0 + + +@pytest.mark.parametrize("function_name, args", BINARY_FUNCTIONS) +def test_binary(string_array, unicode_array, function_name, args): + if function_name in ONLY_IN_NP_CHAR: + func = getattr(np.char, function_name) + else: + func = getattr(np.strings, function_name) + sres = call_func(func, args, string_array) + ures = call_func(func, args, unicode_array, sanitize=False) + if not isinstance(sres, tuple) and sres.dtype == StringDType(): + ures = ures.astype(StringDType()) + assert_array_equal(sres, ures) + + dtype = string_array.dtype + if function_name not in SUPPORTS_NULLS or not hasattr(dtype, "na_object"): + return + + na_arr = np.insert(string_array, 0, dtype.na_object) + is_nan = np.isnan(np.array([dtype.na_object], dtype=dtype))[0] + is_str = isinstance(dtype.na_object, str) + should_error = not (is_nan or is_str) + + if ( + (function_name in NULLS_ALWAYS_ERROR and not is_str) + or (function_name in PASSES_THROUGH_NAN_NULLS and should_error) + or (function_name in NULLS_ARE_FALSEY and should_error) + ): + with pytest.raises((ValueError, TypeError)): + call_func(func, args, na_arr) + return + + res = call_func(func, args, na_arr) + + if is_str: + assert res[0] == call_func(func, args, na_arr[:1]) + elif function_name in NULLS_ARE_FALSEY: + assert res[0] is np.False_ + elif function_name in PASSES_THROUGH_NAN_NULLS: + assert res[0] is dtype.na_object + else: + # shouldn't ever get here + assert 0 + + +@pytest.mark.parametrize("function, expected", [ + (np.strings.find, [[2, -1], [1, -1]]), + (np.strings.startswith, [[False, False], [True, False]])]) +@pytest.mark.parametrize("start, stop", [ + (1, 4), + (np.int8(1), np.int8(4)), + (np.array([1, 1], dtype='u2'), np.array([4, 4], dtype='u2'))]) +def test_non_default_start_stop(function, start, stop, expected): + a = np.array([["--🐍--", "--🦜--"], + ["-🐍---", "-🦜---"]], "T") + indx = function(a, "🐍", start, stop) + assert_array_equal(indx, expected) + + +@pytest.mark.parametrize("count", [2, np.int8(2), np.array([2, 2], 'u2')]) +def test_replace_non_default_repeat(count): + a = np.array(["🐍--", "🦜-🦜-"], "T") + result = np.strings.replace(a, "🦜-", "🦜†", count) + assert_array_equal(result, np.array(["🐍--", "🦜†🦜†"], "T")) + + +def test_strip_ljust_rjust_consistency(string_array, unicode_array): + rjs = np.char.rjust(string_array, 1000) + rju = np.char.rjust(unicode_array, 1000) + + ljs = np.char.ljust(string_array, 1000) + lju = np.char.ljust(unicode_array, 1000) + + assert_array_equal( + np.char.lstrip(rjs), + np.char.lstrip(rju).astype(StringDType()), + ) + + assert_array_equal( + np.char.rstrip(ljs), + np.char.rstrip(lju).astype(StringDType()), + ) + + assert_array_equal( + np.char.strip(ljs), + np.char.strip(lju).astype(StringDType()), + ) + + assert_array_equal( + np.char.strip(rjs), + np.char.strip(rju).astype(StringDType()), + ) + + +def test_unset_na_coercion(): + # a dtype instance with an unset na object is compatible + # with a dtype that has one set + + # this test uses the "add" and "equal" ufunc but all ufuncs that + # accept more than one string argument and produce a string should + # behave this way + # TODO: generalize to more ufuncs + inp = ["hello", "world"] + arr = np.array(inp, dtype=StringDType(na_object=None)) + for op_dtype in [None, StringDType(), StringDType(coerce=False), + StringDType(na_object=None)]: + if op_dtype is None: + op = "2" + else: + op = np.array("2", dtype=op_dtype) + res = arr + op + assert_array_equal(res, ["hello2", "world2"]) + + # dtype instances with distinct explicitly set NA objects are incompatible + for op_dtype in [StringDType(na_object=pd_NA), StringDType(na_object="")]: + op = np.array("2", dtype=op_dtype) + with pytest.raises(TypeError): + arr + op + + # comparisons only consider the na_object + for op_dtype in [None, StringDType(), StringDType(coerce=True), + StringDType(na_object=None)]: + if op_dtype is None: + op = inp + else: + op = np.array(inp, dtype=op_dtype) + assert_array_equal(arr, op) + + for op_dtype in [StringDType(na_object=pd_NA), + StringDType(na_object=np.nan)]: + op = np.array(inp, dtype=op_dtype) + with pytest.raises(TypeError): + arr == op + + +class TestImplementation: + """Check that strings are stored in the arena when possible. + + This tests implementation details, so should be adjusted if + the implementation changes. + """ + + @classmethod + def setup_class(self): + self.MISSING = 0x80 + self.INITIALIZED = 0x40 + self.OUTSIDE_ARENA = 0x20 + self.LONG = 0x10 + self.dtype = StringDType(na_object=np.nan) + self.sizeofstr = self.dtype.itemsize + sp = self.dtype.itemsize // 2 # pointer size = sizeof(size_t) + # Below, size is not strictly correct, since it really uses + # 7 (or 3) bytes, but good enough for the tests here. + self.view_dtype = np.dtype([ + ('offset', f'u{sp}'), + ('size', f'u{sp // 2}'), + ('xsiz', f'V{sp // 2 - 1}'), + ('size_and_flags', 'u1'), + ] if sys.byteorder == 'little' else [ + ('size_and_flags', 'u1'), + ('xsiz', f'V{sp // 2 - 1}'), + ('size', f'u{sp // 2}'), + ('offset', f'u{sp}'), + ]) + self.s_empty = "" + self.s_short = "01234" + self.s_medium = "abcdefghijklmnopqrstuvwxyz" + self.s_long = "-=+" * 100 + self.a = np.array( + [self.s_empty, self.s_short, self.s_medium, self.s_long], + self.dtype) + + def get_view(self, a): + # Cannot view a StringDType as anything else directly, since + # it has references. So, we use a stride trick hack. + from numpy.lib._stride_tricks_impl import DummyArray + interface = dict(a.__array_interface__) + interface['descr'] = self.view_dtype.descr + interface['typestr'] = self.view_dtype.str + return np.asarray(DummyArray(interface, base=a)) + + def get_flags(self, a): + return self.get_view(a)['size_and_flags'] & 0xf0 + + def is_short(self, a): + return self.get_flags(a) == self.INITIALIZED | self.OUTSIDE_ARENA + + def is_on_heap(self, a): + return self.get_flags(a) == (self.INITIALIZED + | self.OUTSIDE_ARENA + | self.LONG) + + def is_missing(self, a): + return self.get_flags(a) & self.MISSING == self.MISSING + + def in_arena(self, a): + return (self.get_flags(a) & (self.INITIALIZED | self.OUTSIDE_ARENA) + == self.INITIALIZED) + + def test_setup(self): + is_short = self.is_short(self.a) + length = np.strings.str_len(self.a) + assert_array_equal(is_short, (length > 0) & (length <= 15)) + assert_array_equal(self.in_arena(self.a), [False, False, True, True]) + assert_array_equal(self.is_on_heap(self.a), False) + assert_array_equal(self.is_missing(self.a), False) + view = self.get_view(self.a) + sizes = np.where(is_short, view['size_and_flags'] & 0xf, + view['size']) + assert_array_equal(sizes, np.strings.str_len(self.a)) + assert_array_equal(view['xsiz'][2:], + np.void(b'\x00' * (self.sizeofstr // 4 - 1))) + # Check that the medium string uses only 1 byte for its length + # in the arena, while the long string takes 8 (or 4). + offsets = view['offset'] + assert offsets[2] == 1 + assert offsets[3] == 1 + len(self.s_medium) + self.sizeofstr // 2 + + def test_empty(self): + e = np.empty((3,), self.dtype) + assert_array_equal(self.get_flags(e), 0) + assert_array_equal(e, "") + + def test_zeros(self): + z = np.zeros((2,), self.dtype) + assert_array_equal(self.get_flags(z), 0) + assert_array_equal(z, "") + + def test_copy(self): + c = self.a.copy() + assert_array_equal(self.get_flags(c), self.get_flags(self.a)) + assert_array_equal(c, self.a) + offsets = self.get_view(c)['offset'] + assert offsets[2] == 1 + assert offsets[3] == 1 + len(self.s_medium) + self.sizeofstr // 2 + + def test_arena_use_with_setting(self): + c = np.zeros_like(self.a) + assert_array_equal(self.get_flags(c), 0) + c[:] = self.a + assert_array_equal(self.get_flags(c), self.get_flags(self.a)) + assert_array_equal(c, self.a) + + def test_arena_reuse_with_setting(self): + c = self.a.copy() + c[:] = self.a + assert_array_equal(self.get_flags(c), self.get_flags(self.a)) + assert_array_equal(c, self.a) + + def test_arena_reuse_after_missing(self): + c = self.a.copy() + c[:] = np.nan + assert np.all(self.is_missing(c)) + # Replacing with the original strings, the arena should be reused. + c[:] = self.a + assert_array_equal(self.get_flags(c), self.get_flags(self.a)) + assert_array_equal(c, self.a) + + def test_arena_reuse_after_empty(self): + c = self.a.copy() + c[:] = "" + assert_array_equal(c, "") + # Replacing with the original strings, the arena should be reused. + c[:] = self.a + assert_array_equal(self.get_flags(c), self.get_flags(self.a)) + assert_array_equal(c, self.a) + + def test_arena_reuse_for_shorter(self): + c = self.a.copy() + # A string slightly shorter than the shortest in the arena + # should be used for all strings in the arena. + c[:] = self.s_medium[:-1] + assert_array_equal(c, self.s_medium[:-1]) + # first empty string in original was never initialized, so + # filling it in now leaves it initialized inside the arena. + # second string started as a short string so it can never live + # in the arena. + in_arena = np.array([True, False, True, True]) + assert_array_equal(self.in_arena(c), in_arena) + # But when a short string is replaced, it will go on the heap. + assert_array_equal(self.is_short(c), False) + assert_array_equal(self.is_on_heap(c), ~in_arena) + # We can put the originals back, and they'll still fit, + # and short strings are back as short strings + c[:] = self.a + assert_array_equal(c, self.a) + assert_array_equal(self.in_arena(c), in_arena) + assert_array_equal(self.is_short(c), self.is_short(self.a)) + assert_array_equal(self.is_on_heap(c), False) + + def test_arena_reuse_if_possible(self): + c = self.a.copy() + # A slightly longer string will not fit in the arena for + # the medium string, but will fit for the longer one. + c[:] = self.s_medium + "±" + assert_array_equal(c, self.s_medium + "±") + in_arena_exp = np.strings.str_len(self.a) >= len(self.s_medium) + 1 + # first entry started uninitialized and empty, so filling it leaves + # it in the arena + in_arena_exp[0] = True + assert not np.all(in_arena_exp == self.in_arena(self.a)) + assert_array_equal(self.in_arena(c), in_arena_exp) + assert_array_equal(self.is_short(c), False) + assert_array_equal(self.is_on_heap(c), ~in_arena_exp) + # And once outside arena, it stays outside, since offset is lost. + # But short strings are used again. + c[:] = self.a + is_short_exp = self.is_short(self.a) + assert_array_equal(c, self.a) + assert_array_equal(self.in_arena(c), in_arena_exp) + assert_array_equal(self.is_short(c), is_short_exp) + assert_array_equal(self.is_on_heap(c), ~in_arena_exp & ~is_short_exp) + + def test_arena_no_reuse_after_short(self): + c = self.a.copy() + # If we replace a string with a short string, it cannot + # go into the arena after because the offset is lost. + c[:] = self.s_short + assert_array_equal(c, self.s_short) + assert_array_equal(self.in_arena(c), False) + c[:] = self.a + assert_array_equal(c, self.a) + assert_array_equal(self.in_arena(c), False) + assert_array_equal(self.is_on_heap(c), self.in_arena(self.a)) diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/test_strings.py b/venv/lib/python3.12/site-packages/numpy/_core/tests/test_strings.py new file mode 100644 index 00000000..a94b5293 --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/tests/test_strings.py @@ -0,0 +1,1205 @@ +import sys +import pytest + +import operator +import numpy as np + +from numpy.testing import assert_array_equal, assert_raises, IS_PYPY + + +COMPARISONS = [ + (operator.eq, np.equal, "=="), + (operator.ne, np.not_equal, "!="), + (operator.lt, np.less, "<"), + (operator.le, np.less_equal, "<="), + (operator.gt, np.greater, ">"), + (operator.ge, np.greater_equal, ">="), +] + +MAX = np.iinfo(np.int64).max + +IS_PYPY_LT_7_3_16 = IS_PYPY and sys.implementation.version < (7, 3, 16) + +@pytest.mark.parametrize(["op", "ufunc", "sym"], COMPARISONS) +def test_mixed_string_comparison_ufuncs_fail(op, ufunc, sym): + arr_string = np.array(["a", "b"], dtype="S") + arr_unicode = np.array(["a", "c"], dtype="U") + + with pytest.raises(TypeError, match="did not contain a loop"): + ufunc(arr_string, arr_unicode) + + with pytest.raises(TypeError, match="did not contain a loop"): + ufunc(arr_unicode, arr_string) + +@pytest.mark.parametrize(["op", "ufunc", "sym"], COMPARISONS) +def test_mixed_string_comparisons_ufuncs_with_cast(op, ufunc, sym): + arr_string = np.array(["a", "b"], dtype="S") + arr_unicode = np.array(["a", "c"], dtype="U") + + # While there is no loop, manual casting is acceptable: + res1 = ufunc(arr_string, arr_unicode, signature="UU->?", casting="unsafe") + res2 = ufunc(arr_string, arr_unicode, signature="SS->?", casting="unsafe") + + expected = op(arr_string.astype("U"), arr_unicode) + assert_array_equal(res1, expected) + assert_array_equal(res2, expected) + + +@pytest.mark.parametrize(["op", "ufunc", "sym"], COMPARISONS) +@pytest.mark.parametrize("dtypes", [ + ("S2", "S2"), ("S2", "S10"), + ("U1"), (">U1", ">U1"), + ("U10")]) +@pytest.mark.parametrize("aligned", [True, False]) +def test_string_comparisons(op, ufunc, sym, dtypes, aligned): + # ensure native byte-order for the first view to stay within unicode range + native_dt = np.dtype(dtypes[0]).newbyteorder("=") + arr = np.arange(2**15).view(native_dt).astype(dtypes[0]) + if not aligned: + # Make `arr` unaligned: + new = np.zeros(arr.nbytes + 1, dtype=np.uint8)[1:].view(dtypes[0]) + new[...] = arr + arr = new + + arr2 = arr.astype(dtypes[1], copy=True) + np.random.shuffle(arr2) + arr[0] = arr2[0] # make sure one matches + + expected = [op(d1, d2) for d1, d2 in zip(arr.tolist(), arr2.tolist())] + assert_array_equal(op(arr, arr2), expected) + assert_array_equal(ufunc(arr, arr2), expected) + assert_array_equal( + np.char.compare_chararrays(arr, arr2, sym, False), expected + ) + + expected = [op(d2, d1) for d1, d2 in zip(arr.tolist(), arr2.tolist())] + assert_array_equal(op(arr2, arr), expected) + assert_array_equal(ufunc(arr2, arr), expected) + assert_array_equal( + np.char.compare_chararrays(arr2, arr, sym, False), expected + ) + + +@pytest.mark.parametrize(["op", "ufunc", "sym"], COMPARISONS) +@pytest.mark.parametrize("dtypes", [ + ("S2", "S2"), ("S2", "S10"), ("U10")]) +def test_string_comparisons_empty(op, ufunc, sym, dtypes): + arr = np.empty((1, 0, 1, 5), dtype=dtypes[0]) + arr2 = np.empty((100, 1, 0, 1), dtype=dtypes[1]) + + expected = np.empty(np.broadcast_shapes(arr.shape, arr2.shape), dtype=bool) + assert_array_equal(op(arr, arr2), expected) + assert_array_equal(ufunc(arr, arr2), expected) + assert_array_equal( + np.char.compare_chararrays(arr, arr2, sym, False), expected + ) + + +@pytest.mark.parametrize("str_dt", ["S", "U"]) +@pytest.mark.parametrize("float_dt", np.typecodes["AllFloat"]) +def test_float_to_string_cast(str_dt, float_dt): + float_dt = np.dtype(float_dt) + fi = np.finfo(float_dt) + arr = np.array([np.nan, np.inf, -np.inf, fi.max, fi.min], dtype=float_dt) + expected = ["nan", "inf", "-inf", str(fi.max), str(fi.min)] + if float_dt.kind == "c": + expected = [f"({r}+0j)" for r in expected] + + res = arr.astype(str_dt) + assert_array_equal(res, np.array(expected, dtype=str_dt)) + + +@pytest.mark.parametrize("dt", ["S", "U", "T"]) +class TestMethods: + + @pytest.mark.parametrize("in1,in2,out", [ + ("", "", ""), + ("abc", "abc", "abcabc"), + ("12345", "12345", "1234512345"), + ("MixedCase", "MixedCase", "MixedCaseMixedCase"), + ("12345 \0 ", "12345 \0 ", "12345 \0 12345 \0 "), + ("UPPER", "UPPER", "UPPERUPPER"), + (["abc", "def"], ["hello", "world"], ["abchello", "defworld"]), + ]) + def test_add(self, in1, in2, out, dt): + in1 = np.array(in1, dtype=dt) + in2 = np.array(in2, dtype=dt) + out = np.array(out, dtype=dt) + assert_array_equal(np.strings.add(in1, in2), out) + + @pytest.mark.parametrize("in1,in2,out", [ + ("abc", 3, "abcabcabc"), + ("abc", 0, ""), + ("abc", -1, ""), + (["abc", "def"], [1, 4], ["abc", "defdefdefdef"]), + ]) + def test_multiply(self, in1, in2, out, dt): + in1 = np.array(in1, dtype=dt) + out = np.array(out, dtype=dt) + assert_array_equal(np.strings.multiply(in1, in2), out) + + def test_multiply_raises(self, dt): + with pytest.raises(TypeError, match="unsupported type"): + np.strings.multiply(np.array("abc", dtype=dt), 3.14) + + with pytest.raises(MemoryError): + np.strings.multiply(np.array("abc", dtype=dt), sys.maxsize) + + @pytest.mark.parametrize("i_dt", [np.int8, np.int16, np.int32, + np.int64, np.int_]) + def test_multiply_integer_dtypes(self, i_dt, dt): + a = np.array("abc", dtype=dt) + i = np.array(3, dtype=i_dt) + res = np.array("abcabcabc", dtype=dt) + assert_array_equal(np.strings.multiply(a, i), res) + + @pytest.mark.parametrize("in_,out", [ + ("", False), + ("a", True), + ("A", True), + ("\n", False), + ("abc", True), + ("aBc123", False), + ("abc\n", False), + (["abc", "aBc123"], [True, False]), + ]) + def test_isalpha(self, in_, out, dt): + in_ = np.array(in_, dtype=dt) + assert_array_equal(np.strings.isalpha(in_), out) + + @pytest.mark.parametrize("in_,out", [ + ('', False), + ('a', True), + ('A', True), + ('\n', False), + ('123abc456', True), + ('a1b3c', True), + ('aBc000 ', False), + ('abc\n', False), + ]) + def test_isalnum(self, in_, out, dt): + in_ = np.array(in_, dtype=dt) + assert_array_equal(np.strings.isalnum(in_), out) + + @pytest.mark.parametrize("in_,out", [ + ("", False), + ("a", False), + ("0", True), + ("012345", True), + ("012345a", False), + (["a", "012345"], [False, True]), + ]) + def test_isdigit(self, in_, out, dt): + in_ = np.array(in_, dtype=dt) + assert_array_equal(np.strings.isdigit(in_), out) + + @pytest.mark.parametrize("in_,out", [ + ("", False), + ("a", False), + ("1", False), + (" ", True), + ("\t", True), + ("\r", True), + ("\n", True), + (" \t\r \n", True), + (" \t\r\na", False), + (["\t1", " \t\r \n"], [False, True]) + ]) + def test_isspace(self, in_, out, dt): + in_ = np.array(in_, dtype=dt) + assert_array_equal(np.strings.isspace(in_), out) + + @pytest.mark.parametrize("in_,out", [ + ('', False), + ('a', True), + ('A', False), + ('\n', False), + ('abc', True), + ('aBc', False), + ('abc\n', True), + ]) + def test_islower(self, in_, out, dt): + in_ = np.array(in_, dtype=dt) + assert_array_equal(np.strings.islower(in_), out) + + @pytest.mark.parametrize("in_,out", [ + ('', False), + ('a', False), + ('A', True), + ('\n', False), + ('ABC', True), + ('AbC', False), + ('ABC\n', True), + ]) + def test_isupper(self, in_, out, dt): + in_ = np.array(in_, dtype=dt) + assert_array_equal(np.strings.isupper(in_), out) + + @pytest.mark.parametrize("in_,out", [ + ('', False), + ('a', False), + ('A', True), + ('\n', False), + ('A Titlecased Line', True), + ('A\nTitlecased Line', True), + ('A Titlecased, Line', True), + ('Not a capitalized String', False), + ('Not\ta Titlecase String', False), + ('Not--a Titlecase String', False), + ('NOT', False), + ]) + def test_istitle(self, in_, out, dt): + in_ = np.array(in_, dtype=dt) + assert_array_equal(np.strings.istitle(in_), out) + + @pytest.mark.parametrize("in_,out", [ + ("", 0), + ("abc", 3), + ("12345", 5), + ("MixedCase", 9), + ("12345 \x00 ", 8), + ("UPPER", 5), + (["abc", "12345 \x00 "], [3, 8]), + ]) + def test_str_len(self, in_, out, dt): + in_ = np.array(in_, dtype=dt) + assert_array_equal(np.strings.str_len(in_), out) + + @pytest.mark.parametrize("a,sub,start,end,out", [ + ("abcdefghiabc", "abc", 0, None, 0), + ("abcdefghiabc", "abc", 1, None, 9), + ("abcdefghiabc", "def", 4, None, -1), + ("abc", "", 0, None, 0), + ("abc", "", 3, None, 3), + ("abc", "", 4, None, -1), + ("rrarrrrrrrrra", "a", 0, None, 2), + ("rrarrrrrrrrra", "a", 4, None, 12), + ("rrarrrrrrrrra", "a", 4, 6, -1), + ("", "", 0, None, 0), + ("", "", 1, 1, -1), + ("", "", MAX, 0, -1), + ("", "xx", 0, None, -1), + ("", "xx", 1, 1, -1), + ("", "xx", MAX, 0, -1), + pytest.param(99*"a" + "b", "b", 0, None, 99, + id="99*a+b-b-0-None-99"), + pytest.param(98*"a" + "ba", "ba", 0, None, 98, + id="98*a+ba-ba-0-None-98"), + pytest.param(100*"a", "b", 0, None, -1, + id="100*a-b-0-None--1"), + pytest.param(30000*"a" + 100*"b", 100*"b", 0, None, 30000, + id="30000*a+100*b-100*b-0-None-30000"), + pytest.param(30000*"a", 100*"b", 0, None, -1, + id="30000*a-100*b-0-None--1"), + pytest.param(15000*"a" + 15000*"b", 15000*"b", 0, None, 15000, + id="15000*a+15000*b-15000*b-0-None-15000"), + pytest.param(15000*"a" + 15000*"b", 15000*"c", 0, None, -1, + id="15000*a+15000*b-15000*c-0-None--1"), + (["abcdefghiabc", "rrarrrrrrrrra"], ["def", "arr"], [0, 3], + None, [3, -1]), + ("Ae¢☃€ 😊" * 2, "😊", 0, None, 6), + ("Ae¢☃€ 😊" * 2, "😊", 7, None, 13), + ]) + def test_find(self, a, sub, start, end, out, dt): + if "😊" in a and dt == "S": + pytest.skip("Bytes dtype does not support non-ascii input") + a = np.array(a, dtype=dt) + sub = np.array(sub, dtype=dt) + assert_array_equal(np.strings.find(a, sub, start, end), out) + + @pytest.mark.parametrize("a,sub,start,end,out", [ + ("abcdefghiabc", "abc", 0, None, 9), + ("abcdefghiabc", "", 0, None, 12), + ("abcdefghiabc", "abcd", 0, None, 0), + ("abcdefghiabc", "abcz", 0, None, -1), + ("abc", "", 0, None, 3), + ("abc", "", 3, None, 3), + ("abc", "", 4, None, -1), + ("rrarrrrrrrrra", "a", 0, None, 12), + ("rrarrrrrrrrra", "a", 4, None, 12), + ("rrarrrrrrrrra", "a", 4, 6, -1), + (["abcdefghiabc", "rrarrrrrrrrra"], ["abc", "a"], [0, 0], + None, [9, 12]), + ("Ae¢☃€ 😊" * 2, "😊", 0, None, 13), + ("Ae¢☃€ 😊" * 2, "😊", 0, 7, 6), + ]) + def test_rfind(self, a, sub, start, end, out, dt): + if "😊" in a and dt == "S": + pytest.skip("Bytes dtype does not support non-ascii input") + a = np.array(a, dtype=dt) + sub = np.array(sub, dtype=dt) + assert_array_equal(np.strings.rfind(a, sub, start, end), out) + + @pytest.mark.parametrize("a,sub,start,end,out", [ + ("aaa", "a", 0, None, 3), + ("aaa", "b", 0, None, 0), + ("aaa", "a", 1, None, 2), + ("aaa", "a", 10, None, 0), + ("aaa", "a", -1, None, 1), + ("aaa", "a", -10, None, 3), + ("aaa", "a", 0, 1, 1), + ("aaa", "a", 0, 10, 3), + ("aaa", "a", 0, -1, 2), + ("aaa", "a", 0, -10, 0), + ("aaa", "", 1, None, 3), + ("aaa", "", 3, None, 1), + ("aaa", "", 10, None, 0), + ("aaa", "", -1, None, 2), + ("aaa", "", -10, None, 4), + ("aaa", "aaaa", 0, None, 0), + pytest.param(98*"a" + "ba", "ba", 0, None, 1, + id="98*a+ba-ba-0-None-1"), + pytest.param(30000*"a" + 100*"b", 100*"b", 0, None, 1, + id="30000*a+100*b-100*b-0-None-1"), + pytest.param(30000*"a", 100*"b", 0, None, 0, + id="30000*a-100*b-0-None-0"), + pytest.param(30000*"a" + 100*"ab", "ab", 0, None, 100, + id="30000*a+100*ab-ab-0-None-100"), + pytest.param(15000*"a" + 15000*"b", 15000*"b", 0, None, 1, + id="15000*a+15000*b-15000*b-0-None-1"), + pytest.param(15000*"a" + 15000*"b", 15000*"c", 0, None, 0, + id="15000*a+15000*b-15000*c-0-None-0"), + ("", "", 0, None, 1), + ("", "", 1, 1, 0), + ("", "", MAX, 0, 0), + ("", "xx", 0, None, 0), + ("", "xx", 1, 1, 0), + ("", "xx", MAX, 0, 0), + (["aaa", ""], ["a", ""], [0, 0], None, [3, 1]), + ("Ae¢☃€ 😊" * 100, "😊", 0, None, 100), + ]) + def test_count(self, a, sub, start, end, out, dt): + if "😊" in a and dt == "S": + pytest.skip("Bytes dtype does not support non-ascii input") + a = np.array(a, dtype=dt) + sub = np.array(sub, dtype=dt) + assert_array_equal(np.strings.count(a, sub, start, end), out) + + @pytest.mark.parametrize("a,prefix,start,end,out", [ + ("hello", "he", 0, None, True), + ("hello", "hello", 0, None, True), + ("hello", "hello world", 0, None, False), + ("hello", "", 0, None, True), + ("hello", "ello", 0, None, False), + ("hello", "ello", 1, None, True), + ("hello", "o", 4, None, True), + ("hello", "o", 5, None, False), + ("hello", "", 5, None, True), + ("hello", "lo", 6, None, False), + ("helloworld", "lowo", 3, None, True), + ("helloworld", "lowo", 3, 7, True), + ("helloworld", "lowo", 3, 6, False), + ("", "", 0, 1, True), + ("", "", 0, 0, True), + ("", "", 1, 0, False), + ("hello", "he", 0, -1, True), + ("hello", "he", -53, -1, True), + ("hello", "hello", 0, -1, False), + ("hello", "hello world", -1, -10, False), + ("hello", "ello", -5, None, False), + ("hello", "ello", -4, None, True), + ("hello", "o", -2, None, False), + ("hello", "o", -1, None, True), + ("hello", "", -3, -3, True), + ("hello", "lo", -9, None, False), + (["hello", ""], ["he", ""], [0, 0], None, [True, True]), + ]) + def test_startswith(self, a, prefix, start, end, out, dt): + a = np.array(a, dtype=dt) + prefix = np.array(prefix, dtype=dt) + assert_array_equal(np.strings.startswith(a, prefix, start, end), out) + + @pytest.mark.parametrize("a,suffix,start,end,out", [ + ("hello", "lo", 0, None, True), + ("hello", "he", 0, None, False), + ("hello", "", 0, None, True), + ("hello", "hello world", 0, None, False), + ("helloworld", "worl", 0, None, False), + ("helloworld", "worl", 3, 9, True), + ("helloworld", "world", 3, 12, True), + ("helloworld", "lowo", 1, 7, True), + ("helloworld", "lowo", 2, 7, True), + ("helloworld", "lowo", 3, 7, True), + ("helloworld", "lowo", 4, 7, False), + ("helloworld", "lowo", 3, 8, False), + ("ab", "ab", 0, 1, False), + ("ab", "ab", 0, 0, False), + ("", "", 0, 1, True), + ("", "", 0, 0, True), + ("", "", 1, 0, False), + ("hello", "lo", -2, None, True), + ("hello", "he", -2, None, False), + ("hello", "", -3, -3, True), + ("hello", "hello world", -10, -2, False), + ("helloworld", "worl", -6, None, False), + ("helloworld", "worl", -5, -1, True), + ("helloworld", "worl", -5, 9, True), + ("helloworld", "world", -7, 12, True), + ("helloworld", "lowo", -99, -3, True), + ("helloworld", "lowo", -8, -3, True), + ("helloworld", "lowo", -7, -3, True), + ("helloworld", "lowo", 3, -4, False), + ("helloworld", "lowo", -8, -2, False), + (["hello", "helloworld"], ["lo", "worl"], [0, -6], None, + [True, False]), + ]) + def test_endswith(self, a, suffix, start, end, out, dt): + a = np.array(a, dtype=dt) + suffix = np.array(suffix, dtype=dt) + assert_array_equal(np.strings.endswith(a, suffix, start, end), out) + + @pytest.mark.parametrize("a,chars,out", [ + ("", None, ""), + (" hello ", None, "hello "), + ("hello", None, "hello"), + (" \t\n\r\f\vabc \t\n\r\f\v", None, "abc \t\n\r\f\v"), + ([" hello ", "hello"], None, ["hello ", "hello"]), + ("", "", ""), + ("", "xyz", ""), + ("hello", "", "hello"), + ("xyzzyhelloxyzzy", "xyz", "helloxyzzy"), + ("hello", "xyz", "hello"), + ("xyxz", "xyxz", ""), + ("xyxzx", "x", "yxzx"), + (["xyzzyhelloxyzzy", "hello"], ["xyz", "xyz"], + ["helloxyzzy", "hello"]), + (["ba", "ac", "baa", "bba"], "b", ["a", "ac", "aa", "a"]), + ]) + def test_lstrip(self, a, chars, out, dt): + a = np.array(a, dtype=dt) + out = np.array(out, dtype=dt) + if chars is not None: + chars = np.array(chars, dtype=dt) + assert_array_equal(np.strings.lstrip(a, chars), out) + else: + assert_array_equal(np.strings.lstrip(a), out) + + @pytest.mark.parametrize("a,chars,out", [ + ("", None, ""), + (" hello ", None, " hello"), + ("hello", None, "hello"), + (" \t\n\r\f\vabc \t\n\r\f\v", None, " \t\n\r\f\vabc"), + ([" hello ", "hello"], None, [" hello", "hello"]), + ("", "", ""), + ("", "xyz", ""), + ("hello", "", "hello"), + (["hello ", "abcdefghijklmnop"], None, + ["hello", "abcdefghijklmnop"]), + ("xyzzyhelloxyzzy", "xyz", "xyzzyhello"), + ("hello", "xyz", "hello"), + ("xyxz", "xyxz", ""), + (" ", None, ""), + ("xyxzx", "x", "xyxz"), + (["xyzzyhelloxyzzy", "hello"], ["xyz", "xyz"], + ["xyzzyhello", "hello"]), + (["ab", "ac", "aab", "abb"], "b", ["a", "ac", "aa", "a"]), + ]) + def test_rstrip(self, a, chars, out, dt): + a = np.array(a, dtype=dt) + out = np.array(out, dtype=dt) + if chars is not None: + chars = np.array(chars, dtype=dt) + assert_array_equal(np.strings.rstrip(a, chars), out) + else: + assert_array_equal(np.strings.rstrip(a), out) + + @pytest.mark.parametrize("a,chars,out", [ + ("", None, ""), + (" hello ", None, "hello"), + ("hello", None, "hello"), + (" \t\n\r\f\vabc \t\n\r\f\v", None, "abc"), + ([" hello ", "hello"], None, ["hello", "hello"]), + ("", "", ""), + ("", "xyz", ""), + ("hello", "", "hello"), + ("xyzzyhelloxyzzy", "xyz", "hello"), + ("hello", "xyz", "hello"), + ("xyxz", "xyxz", ""), + ("xyxzx", "x", "yxz"), + (["xyzzyhelloxyzzy", "hello"], ["xyz", "xyz"], + ["hello", "hello"]), + (["bab", "ac", "baab", "bbabb"], "b", ["a", "ac", "aa", "a"]), + ]) + def test_strip(self, a, chars, out, dt): + a = np.array(a, dtype=dt) + if chars is not None: + chars = np.array(chars, dtype=dt) + out = np.array(out, dtype=dt) + assert_array_equal(np.strings.strip(a, chars), out) + + @pytest.mark.parametrize("buf,old,new,count,res", [ + ("", "", "", -1, ""), + ("", "", "A", -1, "A"), + ("", "A", "", -1, ""), + ("", "A", "A", -1, ""), + ("", "", "", 100, ""), + ("", "", "A", 100, "A"), + ("A", "", "", -1, "A"), + ("A", "", "*", -1, "*A*"), + ("A", "", "*1", -1, "*1A*1"), + ("A", "", "*-#", -1, "*-#A*-#"), + ("AA", "", "*-", -1, "*-A*-A*-"), + ("AA", "", "*-", -1, "*-A*-A*-"), + ("AA", "", "*-", 4, "*-A*-A*-"), + ("AA", "", "*-", 3, "*-A*-A*-"), + ("AA", "", "*-", 2, "*-A*-A"), + ("AA", "", "*-", 1, "*-AA"), + ("AA", "", "*-", 0, "AA"), + ("A", "A", "", -1, ""), + ("AAA", "A", "", -1, ""), + ("AAA", "A", "", -1, ""), + ("AAA", "A", "", 4, ""), + ("AAA", "A", "", 3, ""), + ("AAA", "A", "", 2, "A"), + ("AAA", "A", "", 1, "AA"), + ("AAA", "A", "", 0, "AAA"), + ("AAAAAAAAAA", "A", "", -1, ""), + ("ABACADA", "A", "", -1, "BCD"), + ("ABACADA", "A", "", -1, "BCD"), + ("ABACADA", "A", "", 5, "BCD"), + ("ABACADA", "A", "", 4, "BCD"), + ("ABACADA", "A", "", 3, "BCDA"), + ("ABACADA", "A", "", 2, "BCADA"), + ("ABACADA", "A", "", 1, "BACADA"), + ("ABACADA", "A", "", 0, "ABACADA"), + ("ABCAD", "A", "", -1, "BCD"), + ("ABCADAA", "A", "", -1, "BCD"), + ("BCD", "A", "", -1, "BCD"), + ("*************", "A", "", -1, "*************"), + ("^"+"A"*1000+"^", "A", "", 999, "^A^"), + ("the", "the", "", -1, ""), + ("theater", "the", "", -1, "ater"), + ("thethe", "the", "", -1, ""), + ("thethethethe", "the", "", -1, ""), + ("theatheatheathea", "the", "", -1, "aaaa"), + ("that", "the", "", -1, "that"), + ("thaet", "the", "", -1, "thaet"), + ("here and there", "the", "", -1, "here and re"), + ("here and there and there", "the", "", -1, "here and re and re"), + ("here and there and there", "the", "", 3, "here and re and re"), + ("here and there and there", "the", "", 2, "here and re and re"), + ("here and there and there", "the", "", 1, "here and re and there"), + ("here and there and there", "the", "", 0, "here and there and there"), + ("here and there and there", "the", "", -1, "here and re and re"), + ("abc", "the", "", -1, "abc"), + ("abcdefg", "the", "", -1, "abcdefg"), + ("bbobob", "bob", "", -1, "bob"), + ("bbobobXbbobob", "bob", "", -1, "bobXbob"), + ("aaaaaaabob", "bob", "", -1, "aaaaaaa"), + ("aaaaaaa", "bob", "", -1, "aaaaaaa"), + ("Who goes there?", "o", "o", -1, "Who goes there?"), + ("Who goes there?", "o", "O", -1, "WhO gOes there?"), + ("Who goes there?", "o", "O", -1, "WhO gOes there?"), + ("Who goes there?", "o", "O", 3, "WhO gOes there?"), + ("Who goes there?", "o", "O", 2, "WhO gOes there?"), + ("Who goes there?", "o", "O", 1, "WhO goes there?"), + ("Who goes there?", "o", "O", 0, "Who goes there?"), + ("Who goes there?", "a", "q", -1, "Who goes there?"), + ("Who goes there?", "W", "w", -1, "who goes there?"), + ("WWho goes there?WW", "W", "w", -1, "wwho goes there?ww"), + ("Who goes there?", "?", "!", -1, "Who goes there!"), + ("Who goes there??", "?", "!", -1, "Who goes there!!"), + ("Who goes there?", ".", "!", -1, "Who goes there?"), + ("This is a tissue", "is", "**", -1, "Th** ** a t**sue"), + ("This is a tissue", "is", "**", -1, "Th** ** a t**sue"), + ("This is a tissue", "is", "**", 4, "Th** ** a t**sue"), + ("This is a tissue", "is", "**", 3, "Th** ** a t**sue"), + ("This is a tissue", "is", "**", 2, "Th** ** a tissue"), + ("This is a tissue", "is", "**", 1, "Th** is a tissue"), + ("This is a tissue", "is", "**", 0, "This is a tissue"), + ("bobob", "bob", "cob", -1, "cobob"), + ("bobobXbobobob", "bob", "cob", -1, "cobobXcobocob"), + ("bobob", "bot", "bot", -1, "bobob"), + ("Reykjavik", "k", "KK", -1, "ReyKKjaviKK"), + ("Reykjavik", "k", "KK", -1, "ReyKKjaviKK"), + ("Reykjavik", "k", "KK", 2, "ReyKKjaviKK"), + ("Reykjavik", "k", "KK", 1, "ReyKKjavik"), + ("Reykjavik", "k", "KK", 0, "Reykjavik"), + ("A.B.C.", ".", "----", -1, "A----B----C----"), + ("Reykjavik", "q", "KK", -1, "Reykjavik"), + ("spam, spam, eggs and spam", "spam", "ham", -1, + "ham, ham, eggs and ham"), + ("spam, spam, eggs and spam", "spam", "ham", -1, + "ham, ham, eggs and ham"), + ("spam, spam, eggs and spam", "spam", "ham", 4, + "ham, ham, eggs and ham"), + ("spam, spam, eggs and spam", "spam", "ham", 3, + "ham, ham, eggs and ham"), + ("spam, spam, eggs and spam", "spam", "ham", 2, + "ham, ham, eggs and spam"), + ("spam, spam, eggs and spam", "spam", "ham", 1, + "ham, spam, eggs and spam"), + ("spam, spam, eggs and spam", "spam", "ham", 0, + "spam, spam, eggs and spam"), + ("bobobob", "bobob", "bob", -1, "bobob"), + ("bobobobXbobobob", "bobob", "bob", -1, "bobobXbobob"), + ("BOBOBOB", "bob", "bobby", -1, "BOBOBOB"), + ("one!two!three!", "!", "@", 1, "one@two!three!"), + ("one!two!three!", "!", "", -1, "onetwothree"), + ("one!two!three!", "!", "@", 2, "one@two@three!"), + ("one!two!three!", "!", "@", 3, "one@two@three@"), + ("one!two!three!", "!", "@", 4, "one@two@three@"), + ("one!two!three!", "!", "@", 0, "one!two!three!"), + ("one!two!three!", "!", "@", -1, "one@two@three@"), + ("one!two!three!", "x", "@", -1, "one!two!three!"), + ("one!two!three!", "x", "@", 2, "one!two!three!"), + ("abc", "", "-", -1, "-a-b-c-"), + ("abc", "", "-", 3, "-a-b-c"), + ("abc", "", "-", 0, "abc"), + ("abc", "ab", "--", 0, "abc"), + ("abc", "xy", "--", -1, "abc"), + (["abbc", "abbd"], "b", "z", [1, 2], ["azbc", "azzd"]), + ]) + def test_replace(self, buf, old, new, count, res, dt): + if "😊" in buf and dt == "S": + pytest.skip("Bytes dtype does not support non-ascii input") + buf = np.array(buf, dtype=dt) + old = np.array(old, dtype=dt) + new = np.array(new, dtype=dt) + res = np.array(res, dtype=dt) + assert_array_equal(np.strings.replace(buf, old, new, count), res) + + @pytest.mark.parametrize("buf,sub,start,end,res", [ + ("abcdefghiabc", "", 0, None, 0), + ("abcdefghiabc", "def", 0, None, 3), + ("abcdefghiabc", "abc", 0, None, 0), + ("abcdefghiabc", "abc", 1, None, 9), + ]) + def test_index(self, buf, sub, start, end, res, dt): + buf = np.array(buf, dtype=dt) + sub = np.array(sub, dtype=dt) + assert_array_equal(np.strings.index(buf, sub, start, end), res) + + @pytest.mark.parametrize("buf,sub,start,end", [ + ("abcdefghiabc", "hib", 0, None), + ("abcdefghiab", "abc", 1, None), + ("abcdefghi", "ghi", 8, None), + ("abcdefghi", "ghi", -1, None), + ("rrarrrrrrrrra", "a", 4, 6), + ]) + def test_index_raises(self, buf, sub, start, end, dt): + buf = np.array(buf, dtype=dt) + sub = np.array(sub, dtype=dt) + with pytest.raises(ValueError, match="substring not found"): + np.strings.index(buf, sub, start, end) + + @pytest.mark.parametrize("buf,sub,start,end,res", [ + ("abcdefghiabc", "", 0, None, 12), + ("abcdefghiabc", "def", 0, None, 3), + ("abcdefghiabc", "abc", 0, None, 9), + ("abcdefghiabc", "abc", 0, -1, 0), + ]) + def test_rindex(self, buf, sub, start, end, res, dt): + buf = np.array(buf, dtype=dt) + sub = np.array(sub, dtype=dt) + assert_array_equal(np.strings.rindex(buf, sub, start, end), res) + + @pytest.mark.parametrize("buf,sub,start,end", [ + ("abcdefghiabc", "hib", 0, None), + ("defghiabc", "def", 1, None), + ("defghiabc", "abc", 0, -1), + ("abcdefghi", "ghi", 0, 8), + ("abcdefghi", "ghi", 0, -1), + ("rrarrrrrrrrra", "a", 4, 6), + ]) + def test_rindex_raises(self, buf, sub, start, end, dt): + buf = np.array(buf, dtype=dt) + sub = np.array(sub, dtype=dt) + with pytest.raises(ValueError, match="substring not found"): + np.strings.rindex(buf, sub, start, end) + + @pytest.mark.parametrize("buf,tabsize,res", [ + ("abc\rab\tdef\ng\thi", 8, "abc\rab def\ng hi"), + ("abc\rab\tdef\ng\thi", 4, "abc\rab def\ng hi"), + ("abc\r\nab\tdef\ng\thi", 8, "abc\r\nab def\ng hi"), + ("abc\r\nab\tdef\ng\thi", 4, "abc\r\nab def\ng hi"), + ("abc\r\nab\r\ndef\ng\r\nhi", 4, "abc\r\nab\r\ndef\ng\r\nhi"), + (" \ta\n\tb", 1, " a\n b"), + ]) + def test_expandtabs(self, buf, tabsize, res, dt): + buf = np.array(buf, dtype=dt) + res = np.array(res, dtype=dt) + assert_array_equal(np.strings.expandtabs(buf, tabsize), res) + + def test_expandtabs_raises_overflow(self, dt): + with pytest.raises(OverflowError, match="new string is too long"): + np.strings.expandtabs(np.array("\ta\n\tb", dtype=dt), sys.maxsize) + np.strings.expandtabs(np.array("\ta\n\tb", dtype=dt), 2**61) + + FILL_ERROR = "The fill character must be exactly one character long" + + def test_center_raises_multiple_character_fill(self, dt): + buf = np.array("abc", dtype=dt) + fill = np.array("**", dtype=dt) + with pytest.raises(TypeError, match=self.FILL_ERROR): + np.strings.center(buf, 10, fill) + + def test_ljust_raises_multiple_character_fill(self, dt): + buf = np.array("abc", dtype=dt) + fill = np.array("**", dtype=dt) + with pytest.raises(TypeError, match=self.FILL_ERROR): + np.strings.ljust(buf, 10, fill) + + def test_rjust_raises_multiple_character_fill(self, dt): + buf = np.array("abc", dtype=dt) + fill = np.array("**", dtype=dt) + with pytest.raises(TypeError, match=self.FILL_ERROR): + np.strings.rjust(buf, 10, fill) + + @pytest.mark.parametrize("buf,width,fillchar,res", [ + ('abc', 10, ' ', ' abc '), + ('abc', 6, ' ', ' abc '), + ('abc', 3, ' ', 'abc'), + ('abc', 2, ' ', 'abc'), + ('abc', 10, '*', '***abc****'), + ]) + def test_center(self, buf, width, fillchar, res, dt): + buf = np.array(buf, dtype=dt) + fillchar = np.array(fillchar, dtype=dt) + res = np.array(res, dtype=dt) + assert_array_equal(np.strings.center(buf, width, fillchar), res) + + @pytest.mark.parametrize("buf,width,fillchar,res", [ + ('abc', 10, ' ', 'abc '), + ('abc', 6, ' ', 'abc '), + ('abc', 3, ' ', 'abc'), + ('abc', 2, ' ', 'abc'), + ('abc', 10, '*', 'abc*******'), + ]) + def test_ljust(self, buf, width, fillchar, res, dt): + buf = np.array(buf, dtype=dt) + fillchar = np.array(fillchar, dtype=dt) + res = np.array(res, dtype=dt) + assert_array_equal(np.strings.ljust(buf, width, fillchar), res) + + @pytest.mark.parametrize("buf,width,fillchar,res", [ + ('abc', 10, ' ', ' abc'), + ('abc', 6, ' ', ' abc'), + ('abc', 3, ' ', 'abc'), + ('abc', 2, ' ', 'abc'), + ('abc', 10, '*', '*******abc'), + ]) + def test_rjust(self, buf, width, fillchar, res, dt): + buf = np.array(buf, dtype=dt) + fillchar = np.array(fillchar, dtype=dt) + res = np.array(res, dtype=dt) + assert_array_equal(np.strings.rjust(buf, width, fillchar), res) + + @pytest.mark.parametrize("buf,width,res", [ + ('123', 2, '123'), + ('123', 3, '123'), + ('0123', 4, '0123'), + ('+123', 3, '+123'), + ('+123', 4, '+123'), + ('+123', 5, '+0123'), + ('+0123', 5, '+0123'), + ('-123', 3, '-123'), + ('-123', 4, '-123'), + ('-0123', 5, '-0123'), + ('000', 3, '000'), + ('34', 1, '34'), + ('0034', 4, '0034'), + ]) + def test_zfill(self, buf, width, res, dt): + buf = np.array(buf, dtype=dt) + res = np.array(res, dtype=dt) + assert_array_equal(np.strings.zfill(buf, width), res) + + @pytest.mark.parametrize("buf,sep,res1,res2,res3", [ + ("this is the partition method", "ti", "this is the par", + "ti", "tion method"), + ("http://www.python.org", "://", "http", "://", "www.python.org"), + ("http://www.python.org", "?", "http://www.python.org", "", ""), + ("http://www.python.org", "http://", "", "http://", "www.python.org"), + ("http://www.python.org", "org", "http://www.python.", "org", ""), + ("http://www.python.org", ["://", "?", "http://", "org"], + ["http", "http://www.python.org", "", "http://www.python."], + ["://", "", "http://", "org"], + ["www.python.org", "", "www.python.org", ""]), + ("mississippi", "ss", "mi", "ss", "issippi"), + ("mississippi", "i", "m", "i", "ssissippi"), + ("mississippi", "w", "mississippi", "", ""), + ]) + def test_partition(self, buf, sep, res1, res2, res3, dt): + buf = np.array(buf, dtype=dt) + sep = np.array(sep, dtype=dt) + res1 = np.array(res1, dtype=dt) + res2 = np.array(res2, dtype=dt) + res3 = np.array(res3, dtype=dt) + act1, act2, act3 = np.strings.partition(buf, sep) + assert_array_equal(act1, res1) + assert_array_equal(act2, res2) + assert_array_equal(act3, res3) + assert_array_equal(act1 + act2 + act3, buf) + + @pytest.mark.parametrize("buf,sep,res1,res2,res3", [ + ("this is the partition method", "ti", "this is the parti", + "ti", "on method"), + ("http://www.python.org", "://", "http", "://", "www.python.org"), + ("http://www.python.org", "?", "", "", "http://www.python.org"), + ("http://www.python.org", "http://", "", "http://", "www.python.org"), + ("http://www.python.org", "org", "http://www.python.", "org", ""), + ("http://www.python.org", ["://", "?", "http://", "org"], + ["http", "", "", "http://www.python."], + ["://", "", "http://", "org"], + ["www.python.org", "http://www.python.org", "www.python.org", ""]), + ("mississippi", "ss", "missi", "ss", "ippi"), + ("mississippi", "i", "mississipp", "i", ""), + ("mississippi", "w", "", "", "mississippi"), + ]) + def test_rpartition(self, buf, sep, res1, res2, res3, dt): + buf = np.array(buf, dtype=dt) + sep = np.array(sep, dtype=dt) + res1 = np.array(res1, dtype=dt) + res2 = np.array(res2, dtype=dt) + res3 = np.array(res3, dtype=dt) + act1, act2, act3 = np.strings.rpartition(buf, sep) + assert_array_equal(act1, res1) + assert_array_equal(act2, res2) + assert_array_equal(act3, res3) + assert_array_equal(act1 + act2 + act3, buf) + + +@pytest.mark.parametrize("dt", ["U", "T"]) +class TestMethodsWithUnicode: + @pytest.mark.parametrize("in_,out", [ + ("", False), + ("a", False), + ("0", True), + ("\u2460", False), # CIRCLED DIGIT 1 + ("\xbc", False), # VULGAR FRACTION ONE QUARTER + ("\u0660", True), # ARABIC_INDIC DIGIT ZERO + ("012345", True), + ("012345a", False), + (["0", "a"], [True, False]), + ]) + def test_isdecimal_unicode(self, in_, out, dt): + buf = np.array(in_, dtype=dt) + assert_array_equal(np.strings.isdecimal(buf), out) + + @pytest.mark.parametrize("in_,out", [ + ("", False), + ("a", False), + ("0", True), + ("\u2460", True), # CIRCLED DIGIT 1 + ("\xbc", True), # VULGAR FRACTION ONE QUARTER + ("\u0660", True), # ARABIC_INDIC DIGIT ZERO + ("012345", True), + ("012345a", False), + (["0", "a"], [True, False]), + ]) + def test_isnumeric_unicode(self, in_, out, dt): + buf = np.array(in_, dtype=dt) + assert_array_equal(np.strings.isnumeric(buf), out) + + @pytest.mark.parametrize("buf,old,new,count,res", [ + ("...\u043c......<", "<", "<", -1, "...\u043c......<"), + ("Ae¢☃€ 😊" * 2, "A", "B", -1, "Be¢☃€ 😊Be¢☃€ 😊"), + ("Ae¢☃€ 😊" * 2, "😊", "B", -1, "Ae¢☃€ BAe¢☃€ B"), + ]) + def test_replace_unicode(self, buf, old, new, count, res, dt): + buf = np.array(buf, dtype=dt) + old = np.array(old, dtype=dt) + new = np.array(new, dtype=dt) + res = np.array(res, dtype=dt) + assert_array_equal(np.strings.replace(buf, old, new, count), res) + + @pytest.mark.parametrize("in_", [ + '\U00010401', + '\U00010427', + '\U00010429', + '\U0001044E', + '\U0001D7F6', + '\U00011066', + '\U000104A0', + pytest.param('\U0001F107', marks=pytest.mark.xfail( + sys.platform == 'win32' and IS_PYPY_LT_7_3_16, + reason="PYPY bug in Py_UNICODE_ISALNUM", + strict=True)), + ]) + def test_isalnum_unicode(self, in_, dt): + in_ = np.array(in_, dtype=dt) + assert_array_equal(np.strings.isalnum(in_), True) + + @pytest.mark.parametrize("in_,out", [ + ('\u1FFc', False), + ('\u2167', False), + ('\U00010401', False), + ('\U00010427', False), + ('\U0001F40D', False), + ('\U0001F46F', False), + ('\u2177', True), + pytest.param('\U00010429', True, marks=pytest.mark.xfail( + sys.platform == 'win32' and IS_PYPY_LT_7_3_16, + reason="PYPY bug in Py_UNICODE_ISLOWER", + strict=True)), + ('\U0001044E', True), + ]) + def test_islower_unicode(self, in_, out, dt): + in_ = np.array(in_, dtype=dt) + assert_array_equal(np.strings.islower(in_), out) + + @pytest.mark.parametrize("in_,out", [ + ('\u1FFc', False), + ('\u2167', True), + ('\U00010401', True), + ('\U00010427', True), + ('\U0001F40D', False), + ('\U0001F46F', False), + ('\u2177', False), + pytest.param('\U00010429', False, marks=pytest.mark.xfail( + sys.platform == 'win32' and IS_PYPY_LT_7_3_16, + reason="PYPY bug in Py_UNICODE_ISUPPER", + strict=True)), + ('\U0001044E', False), + ]) + def test_isupper_unicode(self, in_, out, dt): + in_ = np.array(in_, dtype=dt) + assert_array_equal(np.strings.isupper(in_), out) + + @pytest.mark.parametrize("in_,out", [ + ('\u1FFc', True), + ('Greek \u1FFcitlecases ...', True), + pytest.param('\U00010401\U00010429', True, marks=pytest.mark.xfail( + sys.platform == 'win32' and IS_PYPY_LT_7_3_16, + reason="PYPY bug in Py_UNICODE_ISISTITLE", + strict=True)), + ('\U00010427\U0001044E', True), + pytest.param('\U00010429', False, marks=pytest.mark.xfail( + sys.platform == 'win32' and IS_PYPY_LT_7_3_16, + reason="PYPY bug in Py_UNICODE_ISISTITLE", + strict=True)), + ('\U0001044E', False), + ('\U0001F40D', False), + ('\U0001F46F', False), + ]) + def test_istitle_unicode(self, in_, out, dt): + in_ = np.array(in_, dtype=dt) + assert_array_equal(np.strings.istitle(in_), out) + + @pytest.mark.parametrize("buf,sub,start,end,res", [ + ("Ae¢☃€ 😊" * 2, "😊", 0, None, 6), + ("Ae¢☃€ 😊" * 2, "😊", 7, None, 13), + ]) + def test_index_unicode(self, buf, sub, start, end, res, dt): + buf = np.array(buf, dtype=dt) + sub = np.array(sub, dtype=dt) + assert_array_equal(np.strings.index(buf, sub, start, end), res) + + def test_index_raises_unicode(self, dt): + with pytest.raises(ValueError, match="substring not found"): + np.strings.index("Ae¢☃€ 😊", "😀") + + @pytest.mark.parametrize("buf,res", [ + ("Ae¢☃€ \t 😊", "Ae¢☃€ 😊"), + ("\t\U0001044E", " \U0001044E"), + ]) + def test_expandtabs(self, buf, res, dt): + buf = np.array(buf, dtype=dt) + res = np.array(res, dtype=dt) + assert_array_equal(np.strings.expandtabs(buf), res) + + @pytest.mark.parametrize("buf,width,fillchar,res", [ + ('x', 2, '\U0001044E', 'x\U0001044E'), + ('x', 3, '\U0001044E', '\U0001044Ex\U0001044E'), + ('x', 4, '\U0001044E', '\U0001044Ex\U0001044E\U0001044E'), + ]) + def test_center(self, buf, width, fillchar, res, dt): + buf = np.array(buf, dtype=dt) + fillchar = np.array(fillchar, dtype=dt) + res = np.array(res, dtype=dt) + assert_array_equal(np.strings.center(buf, width, fillchar), res) + + @pytest.mark.parametrize("buf,width,fillchar,res", [ + ('x', 2, '\U0001044E', 'x\U0001044E'), + ('x', 3, '\U0001044E', 'x\U0001044E\U0001044E'), + ('x', 4, '\U0001044E', 'x\U0001044E\U0001044E\U0001044E'), + ]) + def test_ljust(self, buf, width, fillchar, res, dt): + buf = np.array(buf, dtype=dt) + fillchar = np.array(fillchar, dtype=dt) + res = np.array(res, dtype=dt) + assert_array_equal(np.strings.ljust(buf, width, fillchar), res) + + @pytest.mark.parametrize("buf,width,fillchar,res", [ + ('x', 2, '\U0001044E', '\U0001044Ex'), + ('x', 3, '\U0001044E', '\U0001044E\U0001044Ex'), + ('x', 4, '\U0001044E', '\U0001044E\U0001044E\U0001044Ex'), + ]) + def test_rjust(self, buf, width, fillchar, res, dt): + buf = np.array(buf, dtype=dt) + fillchar = np.array(fillchar, dtype=dt) + res = np.array(res, dtype=dt) + assert_array_equal(np.strings.rjust(buf, width, fillchar), res) + + @pytest.mark.parametrize("buf,sep,res1,res2,res3", [ + ("āāāāĀĀĀĀ", "Ă", "āāāāĀĀĀĀ", "", ""), + ("āāāāĂĀĀĀĀ", "Ă", "āāāā", "Ă", "ĀĀĀĀ"), + ("āāāāĂĂĀĀĀĀ", "ĂĂ", "āāāā", "ĂĂ", "ĀĀĀĀ"), + ("𐌁𐌁𐌁𐌁𐌀𐌀𐌀𐌀", "𐌂", "𐌁𐌁𐌁𐌁𐌀𐌀𐌀𐌀", "", ""), + ("𐌁𐌁𐌁𐌁𐌂𐌀𐌀𐌀𐌀", "𐌂", "𐌁𐌁𐌁𐌁", "𐌂", "𐌀𐌀𐌀𐌀"), + ("𐌁𐌁𐌁𐌁𐌂𐌂𐌀𐌀𐌀𐌀", "𐌂𐌂", "𐌁𐌁𐌁𐌁", "𐌂𐌂", "𐌀𐌀𐌀𐌀"), + ("𐌁𐌁𐌁𐌁𐌂𐌂𐌂𐌂𐌀𐌀𐌀𐌀", "𐌂𐌂𐌂𐌂", "𐌁𐌁𐌁𐌁", "𐌂𐌂𐌂𐌂", "𐌀𐌀𐌀𐌀"), + ]) + def test_partition(self, buf, sep, res1, res2, res3, dt): + buf = np.array(buf, dtype=dt) + sep = np.array(sep, dtype=dt) + res1 = np.array(res1, dtype=dt) + res2 = np.array(res2, dtype=dt) + res3 = np.array(res3, dtype=dt) + act1, act2, act3 = np.strings.partition(buf, sep) + assert_array_equal(act1, res1) + assert_array_equal(act2, res2) + assert_array_equal(act3, res3) + assert_array_equal(act1 + act2 + act3, buf) + + @pytest.mark.parametrize("buf,sep,res1,res2,res3", [ + ("āāāāĀĀĀĀ", "Ă", "", "", "āāāāĀĀĀĀ"), + ("āāāāĂĀĀĀĀ", "Ă", "āāāā", "Ă", "ĀĀĀĀ"), + ("āāāāĂĂĀĀĀĀ", "ĂĂ", "āāāā", "ĂĂ", "ĀĀĀĀ"), + ("𐌁𐌁𐌁𐌁𐌀𐌀𐌀𐌀", "𐌂", "", "", "𐌁𐌁𐌁𐌁𐌀𐌀𐌀𐌀"), + ("𐌁𐌁𐌁𐌁𐌂𐌀𐌀𐌀𐌀", "𐌂", "𐌁𐌁𐌁𐌁", "𐌂", "𐌀𐌀𐌀𐌀"), + ("𐌁𐌁𐌁𐌁𐌂𐌂𐌀𐌀𐌀𐌀", "𐌂𐌂", "𐌁𐌁𐌁𐌁", "𐌂𐌂", "𐌀𐌀𐌀𐌀"), + ]) + def test_rpartition(self, buf, sep, res1, res2, res3, dt): + buf = np.array(buf, dtype=dt) + sep = np.array(sep, dtype=dt) + res1 = np.array(res1, dtype=dt) + res2 = np.array(res2, dtype=dt) + res3 = np.array(res3, dtype=dt) + act1, act2, act3 = np.strings.rpartition(buf, sep) + assert_array_equal(act1, res1) + assert_array_equal(act2, res2) + assert_array_equal(act3, res3) + assert_array_equal(act1 + act2 + act3, buf) + + @pytest.mark.parametrize("method", ["strip", "lstrip", "rstrip"]) + @pytest.mark.parametrize( + "source,strip", + [ + ("λμ", "μ"), + ("λμ", "λ"), + ("λ"*5 + "μ"*2, "μ"), + ("λ" * 5 + "μ" * 2, "λ"), + ("λ" * 5 + "A" + "μ" * 2, "μλ"), + ("λμ" * 5, "μ"), + ("λμ" * 5, "λ"), + ]) + def test_strip_functions_unicode(self, source, strip, method, dt): + src_array = np.array([source], dtype=dt) + + npy_func = getattr(np.strings, method) + py_func = getattr(str, method) + + expected = np.array([py_func(source, strip)], dtype=dt) + actual = npy_func(src_array, strip) + + assert_array_equal(actual, expected) + + +class TestMixedTypeMethods: + def test_center(self): + buf = np.array("😊", dtype="U") + fill = np.array("*", dtype="S") + res = np.array("*😊*", dtype="U") + assert_array_equal(np.strings.center(buf, 3, fill), res) + + buf = np.array("s", dtype="S") + fill = np.array("*", dtype="U") + res = np.array("*s*", dtype="S") + assert_array_equal(np.strings.center(buf, 3, fill), res) + + with pytest.raises(ValueError, match="'ascii' codec can't encode"): + buf = np.array("s", dtype="S") + fill = np.array("😊", dtype="U") + np.strings.center(buf, 3, fill) + + def test_ljust(self): + buf = np.array("😊", dtype="U") + fill = np.array("*", dtype="S") + res = np.array("😊**", dtype="U") + assert_array_equal(np.strings.ljust(buf, 3, fill), res) + + buf = np.array("s", dtype="S") + fill = np.array("*", dtype="U") + res = np.array("s**", dtype="S") + assert_array_equal(np.strings.ljust(buf, 3, fill), res) + + with pytest.raises(ValueError, match="'ascii' codec can't encode"): + buf = np.array("s", dtype="S") + fill = np.array("😊", dtype="U") + np.strings.ljust(buf, 3, fill) + + def test_rjust(self): + buf = np.array("😊", dtype="U") + fill = np.array("*", dtype="S") + res = np.array("**😊", dtype="U") + assert_array_equal(np.strings.rjust(buf, 3, fill), res) + + buf = np.array("s", dtype="S") + fill = np.array("*", dtype="U") + res = np.array("**s", dtype="S") + assert_array_equal(np.strings.rjust(buf, 3, fill), res) + + with pytest.raises(ValueError, match="'ascii' codec can't encode"): + buf = np.array("s", dtype="S") + fill = np.array("😊", dtype="U") + np.strings.rjust(buf, 3, fill) + + +class TestUnicodeOnlyMethodsRaiseWithBytes: + def test_isdecimal_raises(self): + in_ = np.array(b"1") + with assert_raises(TypeError): + np.strings.isdecimal(in_) + + def test_isnumeric_bytes(self): + in_ = np.array(b"1") + with assert_raises(TypeError): + np.strings.isnumeric(in_) + + +def check_itemsize(n_elem, dt): + if dt == "T": + return np.dtype(dt).itemsize + if dt == "S": + return n_elem + if dt == "U": + return n_elem * 4 + +@pytest.mark.parametrize("dt", ["S", "U", "T"]) +class TestReplaceOnArrays: + + def test_replace_count_and_size(self, dt): + a = np.array(["0123456789" * i for i in range(4)], dtype=dt) + r1 = np.strings.replace(a, "5", "ABCDE") + assert r1.dtype.itemsize == check_itemsize(3*10 + 3*4, dt) + r1_res = np.array(["01234ABCDE6789" * i for i in range(4)], dtype=dt) + assert_array_equal(r1, r1_res) + r2 = np.strings.replace(a, "5", "ABCDE", 1) + assert r2.dtype.itemsize == check_itemsize(3*10 + 4, dt) + r3 = np.strings.replace(a, "5", "ABCDE", 0) + assert r3.dtype.itemsize == a.dtype.itemsize + assert_array_equal(r3, a) + # Negative values mean to replace all. + r4 = np.strings.replace(a, "5", "ABCDE", -1) + assert r4.dtype.itemsize == check_itemsize(3*10 + 3*4, dt) + assert_array_equal(r4, r1) + # We can do count on an element-by-element basis. + r5 = np.strings.replace(a, "5", "ABCDE", [-1, -1, -1, 1]) + assert r5.dtype.itemsize == check_itemsize(3*10 + 4, dt) + assert_array_equal(r5, np.array( + ["01234ABCDE6789" * i for i in range(3)] + + ["01234ABCDE6789" + "0123456789" * 2], dtype=dt)) + + def test_replace_broadcasting(self, dt): + a = np.array("0,0,0", dtype=dt) + r1 = np.strings.replace(a, "0", "1", np.arange(3)) + assert r1.dtype == a.dtype + assert_array_equal(r1, np.array(["0,0,0", "1,0,0", "1,1,0"], dtype=dt)) + r2 = np.strings.replace(a, "0", [["1"], ["2"]], np.arange(1, 4)) + assert_array_equal(r2, np.array([["1,0,0", "1,1,0", "1,1,1"], + ["2,0,0", "2,2,0", "2,2,2"]], + dtype=dt)) + r3 = np.strings.replace(a, ["0", "0,0", "0,0,0"], "X") + assert_array_equal(r3, np.array(["X,X,X", "X,0", "X"], dtype=dt)) diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/test_ufunc.py b/venv/lib/python3.12/site-packages/numpy/_core/tests/test_ufunc.py new file mode 100644 index 00000000..26b6a1aa --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/tests/test_ufunc.py @@ -0,0 +1,3178 @@ +import warnings +import itertools +import sys +import ctypes as ct +import pickle + +import pytest +from pytest import param + +import numpy as np +import numpy._core.umath as ncu +import numpy._core._umath_tests as umt +import numpy.linalg._umath_linalg as uml +import numpy._core._operand_flag_tests as opflag_tests +import numpy._core._rational_tests as _rational_tests +from numpy.exceptions import AxisError +from numpy.testing import ( + assert_, assert_equal, assert_raises, assert_array_equal, + assert_almost_equal, assert_array_almost_equal, assert_no_warnings, + assert_allclose, HAS_REFCOUNT, suppress_warnings, IS_WASM, IS_PYPY, + ) +from numpy.testing._private.utils import requires_memory + + +UNARY_UFUNCS = [obj for obj in np._core.umath.__dict__.values() + if isinstance(obj, np.ufunc)] +UNARY_OBJECT_UFUNCS = [uf for uf in UNARY_UFUNCS if "O->O" in uf.types] + +# Remove functions that do not support `floats` +UNARY_OBJECT_UFUNCS.remove(getattr(np, 'bitwise_count')) + + +class TestUfuncKwargs: + def test_kwarg_exact(self): + assert_raises(TypeError, np.add, 1, 2, castingx='safe') + assert_raises(TypeError, np.add, 1, 2, dtypex=int) + assert_raises(TypeError, np.add, 1, 2, extobjx=[4096]) + assert_raises(TypeError, np.add, 1, 2, outx=None) + assert_raises(TypeError, np.add, 1, 2, sigx='ii->i') + assert_raises(TypeError, np.add, 1, 2, signaturex='ii->i') + assert_raises(TypeError, np.add, 1, 2, subokx=False) + assert_raises(TypeError, np.add, 1, 2, wherex=[True]) + + def test_sig_signature(self): + assert_raises(TypeError, np.add, 1, 2, sig='ii->i', + signature='ii->i') + + def test_sig_dtype(self): + assert_raises(TypeError, np.add, 1, 2, sig='ii->i', + dtype=int) + assert_raises(TypeError, np.add, 1, 2, signature='ii->i', + dtype=int) + + def test_extobj_removed(self): + assert_raises(TypeError, np.add, 1, 2, extobj=[4096]) + + +class TestUfuncGenericLoops: + """Test generic loops. + + The loops to be tested are: + + PyUFunc_ff_f_As_dd_d + PyUFunc_ff_f + PyUFunc_dd_d + PyUFunc_gg_g + PyUFunc_FF_F_As_DD_D + PyUFunc_DD_D + PyUFunc_FF_F + PyUFunc_GG_G + PyUFunc_OO_O + PyUFunc_OO_O_method + PyUFunc_f_f_As_d_d + PyUFunc_d_d + PyUFunc_f_f + PyUFunc_g_g + PyUFunc_F_F_As_D_D + PyUFunc_F_F + PyUFunc_D_D + PyUFunc_G_G + PyUFunc_O_O + PyUFunc_O_O_method + PyUFunc_On_Om + + Where: + + f -- float + d -- double + g -- long double + F -- complex float + D -- complex double + G -- complex long double + O -- python object + + It is difficult to assure that each of these loops is entered from the + Python level as the special cased loops are a moving target and the + corresponding types are architecture dependent. We probably need to + define C level testing ufuncs to get at them. For the time being, I've + just looked at the signatures registered in the build directory to find + relevant functions. + + """ + np_dtypes = [ + (np.single, np.single), (np.single, np.double), + (np.csingle, np.csingle), (np.csingle, np.cdouble), + (np.double, np.double), (np.longdouble, np.longdouble), + (np.cdouble, np.cdouble), (np.clongdouble, np.clongdouble)] + + @pytest.mark.parametrize('input_dtype,output_dtype', np_dtypes) + def test_unary_PyUFunc(self, input_dtype, output_dtype, f=np.exp, x=0, y=1): + xs = np.full(10, input_dtype(x), dtype=output_dtype) + ys = f(xs)[::2] + assert_allclose(ys, y) + assert_equal(ys.dtype, output_dtype) + + def f2(x, y): + return x**y + + @pytest.mark.parametrize('input_dtype,output_dtype', np_dtypes) + def test_binary_PyUFunc(self, input_dtype, output_dtype, f=f2, x=0, y=1): + xs = np.full(10, input_dtype(x), dtype=output_dtype) + ys = f(xs, xs)[::2] + assert_allclose(ys, y) + assert_equal(ys.dtype, output_dtype) + + # class to use in testing object method loops + class foo: + def conjugate(self): + return np.bool(1) + + def logical_xor(self, obj): + return np.bool(1) + + def test_unary_PyUFunc_O_O(self): + x = np.ones(10, dtype=object) + assert_(np.all(np.abs(x) == 1)) + + def test_unary_PyUFunc_O_O_method_simple(self, foo=foo): + x = np.full(10, foo(), dtype=object) + assert_(np.all(np.conjugate(x) == True)) + + def test_binary_PyUFunc_OO_O(self): + x = np.ones(10, dtype=object) + assert_(np.all(np.add(x, x) == 2)) + + def test_binary_PyUFunc_OO_O_method(self, foo=foo): + x = np.full(10, foo(), dtype=object) + assert_(np.all(np.logical_xor(x, x))) + + def test_binary_PyUFunc_On_Om_method(self, foo=foo): + x = np.full((10, 2, 3), foo(), dtype=object) + assert_(np.all(np.logical_xor(x, x))) + + def test_python_complex_conjugate(self): + # The conjugate ufunc should fall back to calling the method: + arr = np.array([1+2j, 3-4j], dtype="O") + assert isinstance(arr[0], complex) + res = np.conjugate(arr) + assert res.dtype == np.dtype("O") + assert_array_equal(res, np.array([1-2j, 3+4j], dtype="O")) + + @pytest.mark.parametrize("ufunc", UNARY_OBJECT_UFUNCS) + def test_unary_PyUFunc_O_O_method_full(self, ufunc): + """Compare the result of the object loop with non-object one""" + val = np.float64(np.pi/4) + + class MyFloat(np.float64): + def __getattr__(self, attr): + try: + return super().__getattr__(attr) + except AttributeError: + return lambda: getattr(np._core.umath, attr)(val) + + # Use 0-D arrays, to ensure the same element call + num_arr = np.array(val, dtype=np.float64) + obj_arr = np.array(MyFloat(val), dtype="O") + + with np.errstate(all="raise"): + try: + res_num = ufunc(num_arr) + except Exception as exc: + with assert_raises(type(exc)): + ufunc(obj_arr) + else: + res_obj = ufunc(obj_arr) + assert_array_almost_equal(res_num.astype("O"), res_obj) + + +def _pickleable_module_global(): + pass + + +class TestUfunc: + def test_pickle(self): + for proto in range(2, pickle.HIGHEST_PROTOCOL + 1): + assert_(pickle.loads(pickle.dumps(np.sin, + protocol=proto)) is np.sin) + + # Check that ufunc not defined in the top level numpy namespace + # such as numpy._core._rational_tests.test_add can also be pickled + res = pickle.loads(pickle.dumps(_rational_tests.test_add, + protocol=proto)) + assert_(res is _rational_tests.test_add) + + def test_pickle_withstring(self): + astring = (b"cnumpy.core\n_ufunc_reconstruct\np0\n" + b"(S'numpy._core.umath'\np1\nS'cos'\np2\ntp3\nRp4\n.") + assert_(pickle.loads(astring) is np.cos) + + @pytest.mark.skipif(IS_PYPY, reason="'is' check does not work on PyPy") + def test_pickle_name_is_qualname(self): + # This tests that a simplification of our ufunc pickle code will + # lead to allowing qualnames as names. Future ufuncs should + # possible add a specific qualname, or a hook into pickling instead + # (dask+numba may benefit). + _pickleable_module_global.ufunc = umt._pickleable_module_global_ufunc + + obj = pickle.loads(pickle.dumps(_pickleable_module_global.ufunc)) + assert obj is umt._pickleable_module_global_ufunc + + def test_reduceat_shifting_sum(self): + L = 6 + x = np.arange(L) + idx = np.array(list(zip(np.arange(L - 2), np.arange(L - 2) + 2))).ravel() + assert_array_equal(np.add.reduceat(x, idx)[::2], [1, 3, 5, 7]) + + def test_all_ufunc(self): + """Try to check presence and results of all ufuncs. + + The list of ufuncs comes from generate_umath.py and is as follows: + + ===== ==== ============= =============== ======================== + done args function types notes + ===== ==== ============= =============== ======================== + n 1 conjugate nums + O + n 1 absolute nums + O complex -> real + n 1 negative nums + O + n 1 sign nums + O -> int + n 1 invert bool + ints + O flts raise an error + n 1 degrees real + M cmplx raise an error + n 1 radians real + M cmplx raise an error + n 1 arccos flts + M + n 1 arccosh flts + M + n 1 arcsin flts + M + n 1 arcsinh flts + M + n 1 arctan flts + M + n 1 arctanh flts + M + n 1 cos flts + M + n 1 sin flts + M + n 1 tan flts + M + n 1 cosh flts + M + n 1 sinh flts + M + n 1 tanh flts + M + n 1 exp flts + M + n 1 expm1 flts + M + n 1 log flts + M + n 1 log10 flts + M + n 1 log1p flts + M + n 1 sqrt flts + M real x < 0 raises error + n 1 ceil real + M + n 1 trunc real + M + n 1 floor real + M + n 1 fabs real + M + n 1 rint flts + M + n 1 isnan flts -> bool + n 1 isinf flts -> bool + n 1 isfinite flts -> bool + n 1 signbit real -> bool + n 1 modf real -> (frac, int) + n 1 logical_not bool + nums + M -> bool + n 2 left_shift ints + O flts raise an error + n 2 right_shift ints + O flts raise an error + n 2 add bool + nums + O boolean + is || + n 2 subtract bool + nums + O boolean - is ^ + n 2 multiply bool + nums + O boolean * is & + n 2 divide nums + O + n 2 floor_divide nums + O + n 2 true_divide nums + O bBhH -> f, iIlLqQ -> d + n 2 fmod nums + M + n 2 power nums + O + n 2 greater bool + nums + O -> bool + n 2 greater_equal bool + nums + O -> bool + n 2 less bool + nums + O -> bool + n 2 less_equal bool + nums + O -> bool + n 2 equal bool + nums + O -> bool + n 2 not_equal bool + nums + O -> bool + n 2 logical_and bool + nums + M -> bool + n 2 logical_or bool + nums + M -> bool + n 2 logical_xor bool + nums + M -> bool + n 2 maximum bool + nums + O + n 2 minimum bool + nums + O + n 2 bitwise_and bool + ints + O flts raise an error + n 2 bitwise_or bool + ints + O flts raise an error + n 2 bitwise_xor bool + ints + O flts raise an error + n 2 arctan2 real + M + n 2 remainder ints + real + O + n 2 hypot real + M + ===== ==== ============= =============== ======================== + + Types other than those listed will be accepted, but they are cast to + the smallest compatible type for which the function is defined. The + casting rules are: + + bool -> int8 -> float32 + ints -> double + + """ + pass + + # from include/numpy/ufuncobject.h + size_inferred = 2 + can_ignore = 4 + def test_signature0(self): + # the arguments to test_signature are: nin, nout, core_signature + enabled, num_dims, ixs, flags, sizes = umt.test_signature( + 2, 1, "(i),(i)->()") + assert_equal(enabled, 1) + assert_equal(num_dims, (1, 1, 0)) + assert_equal(ixs, (0, 0)) + assert_equal(flags, (self.size_inferred,)) + assert_equal(sizes, (-1,)) + + def test_signature1(self): + # empty core signature; treat as plain ufunc (with trivial core) + enabled, num_dims, ixs, flags, sizes = umt.test_signature( + 2, 1, "(),()->()") + assert_equal(enabled, 0) + assert_equal(num_dims, (0, 0, 0)) + assert_equal(ixs, ()) + assert_equal(flags, ()) + assert_equal(sizes, ()) + + def test_signature2(self): + # more complicated names for variables + enabled, num_dims, ixs, flags, sizes = umt.test_signature( + 2, 1, "(i1,i2),(J_1)->(_kAB)") + assert_equal(enabled, 1) + assert_equal(num_dims, (2, 1, 1)) + assert_equal(ixs, (0, 1, 2, 3)) + assert_equal(flags, (self.size_inferred,)*4) + assert_equal(sizes, (-1, -1, -1, -1)) + + def test_signature3(self): + enabled, num_dims, ixs, flags, sizes = umt.test_signature( + 2, 1, "(i1, i12), (J_1)->(i12, i2)") + assert_equal(enabled, 1) + assert_equal(num_dims, (2, 1, 2)) + assert_equal(ixs, (0, 1, 2, 1, 3)) + assert_equal(flags, (self.size_inferred,)*4) + assert_equal(sizes, (-1, -1, -1, -1)) + + def test_signature4(self): + # matrix_multiply signature from _umath_tests + enabled, num_dims, ixs, flags, sizes = umt.test_signature( + 2, 1, "(n,k),(k,m)->(n,m)") + assert_equal(enabled, 1) + assert_equal(num_dims, (2, 2, 2)) + assert_equal(ixs, (0, 1, 1, 2, 0, 2)) + assert_equal(flags, (self.size_inferred,)*3) + assert_equal(sizes, (-1, -1, -1)) + + def test_signature5(self): + # matmul signature from _umath_tests + enabled, num_dims, ixs, flags, sizes = umt.test_signature( + 2, 1, "(n?,k),(k,m?)->(n?,m?)") + assert_equal(enabled, 1) + assert_equal(num_dims, (2, 2, 2)) + assert_equal(ixs, (0, 1, 1, 2, 0, 2)) + assert_equal(flags, (self.size_inferred | self.can_ignore, + self.size_inferred, + self.size_inferred | self.can_ignore)) + assert_equal(sizes, (-1, -1, -1)) + + def test_signature6(self): + enabled, num_dims, ixs, flags, sizes = umt.test_signature( + 1, 1, "(3)->()") + assert_equal(enabled, 1) + assert_equal(num_dims, (1, 0)) + assert_equal(ixs, (0,)) + assert_equal(flags, (0,)) + assert_equal(sizes, (3,)) + + def test_signature7(self): + enabled, num_dims, ixs, flags, sizes = umt.test_signature( + 3, 1, "(3),(03,3),(n)->(9)") + assert_equal(enabled, 1) + assert_equal(num_dims, (1, 2, 1, 1)) + assert_equal(ixs, (0, 0, 0, 1, 2)) + assert_equal(flags, (0, self.size_inferred, 0)) + assert_equal(sizes, (3, -1, 9)) + + def test_signature8(self): + enabled, num_dims, ixs, flags, sizes = umt.test_signature( + 3, 1, "(3?),(3?,3?),(n)->(9)") + assert_equal(enabled, 1) + assert_equal(num_dims, (1, 2, 1, 1)) + assert_equal(ixs, (0, 0, 0, 1, 2)) + assert_equal(flags, (self.can_ignore, self.size_inferred, 0)) + assert_equal(sizes, (3, -1, 9)) + + def test_signature9(self): + enabled, num_dims, ixs, flags, sizes = umt.test_signature( + 1, 1, "( 3) -> ( )") + assert_equal(enabled, 1) + assert_equal(num_dims, (1, 0)) + assert_equal(ixs, (0,)) + assert_equal(flags, (0,)) + assert_equal(sizes, (3,)) + + def test_signature10(self): + enabled, num_dims, ixs, flags, sizes = umt.test_signature( + 3, 1, "( 3? ) , (3? , 3?) ,(n )-> ( 9)") + assert_equal(enabled, 1) + assert_equal(num_dims, (1, 2, 1, 1)) + assert_equal(ixs, (0, 0, 0, 1, 2)) + assert_equal(flags, (self.can_ignore, self.size_inferred, 0)) + assert_equal(sizes, (3, -1, 9)) + + def test_signature_failure_extra_parenthesis(self): + with assert_raises(ValueError): + umt.test_signature(2, 1, "((i)),(i)->()") + + def test_signature_failure_mismatching_parenthesis(self): + with assert_raises(ValueError): + umt.test_signature(2, 1, "(i),)i(->()") + + def test_signature_failure_signature_missing_input_arg(self): + with assert_raises(ValueError): + umt.test_signature(2, 1, "(i),->()") + + def test_signature_failure_signature_missing_output_arg(self): + with assert_raises(ValueError): + umt.test_signature(2, 2, "(i),(i)->()") + + def test_get_signature(self): + assert_equal(np.vecdot.signature, "(n),(n)->()") + + def test_forced_sig(self): + a = 0.5*np.arange(3, dtype='f8') + assert_equal(np.add(a, 0.5), [0.5, 1, 1.5]) + with pytest.warns(DeprecationWarning): + assert_equal(np.add(a, 0.5, sig='i', casting='unsafe'), [0, 0, 1]) + assert_equal(np.add(a, 0.5, sig='ii->i', casting='unsafe'), [0, 0, 1]) + with pytest.warns(DeprecationWarning): + assert_equal(np.add(a, 0.5, sig=('i4',), casting='unsafe'), + [0, 0, 1]) + assert_equal(np.add(a, 0.5, sig=('i4', 'i4', 'i4'), + casting='unsafe'), [0, 0, 1]) + + b = np.zeros((3,), dtype='f8') + np.add(a, 0.5, out=b) + assert_equal(b, [0.5, 1, 1.5]) + b[:] = 0 + with pytest.warns(DeprecationWarning): + np.add(a, 0.5, sig='i', out=b, casting='unsafe') + assert_equal(b, [0, 0, 1]) + b[:] = 0 + np.add(a, 0.5, sig='ii->i', out=b, casting='unsafe') + assert_equal(b, [0, 0, 1]) + b[:] = 0 + with pytest.warns(DeprecationWarning): + np.add(a, 0.5, sig=('i4',), out=b, casting='unsafe') + assert_equal(b, [0, 0, 1]) + b[:] = 0 + np.add(a, 0.5, sig=('i4', 'i4', 'i4'), out=b, casting='unsafe') + assert_equal(b, [0, 0, 1]) + + def test_signature_all_None(self): + # signature all None, is an acceptable alternative (since 1.21) + # to not providing a signature. + res1 = np.add([3], [4], sig=(None, None, None)) + res2 = np.add([3], [4]) + assert_array_equal(res1, res2) + res1 = np.maximum([3], [4], sig=(None, None, None)) + res2 = np.maximum([3], [4]) + assert_array_equal(res1, res2) + + with pytest.raises(TypeError): + # special case, that would be deprecated anyway, so errors: + np.add(3, 4, signature=(None,)) + + def test_signature_dtype_type(self): + # Since that will be the normal behaviour (past NumPy 1.21) + # we do support the types already: + float_dtype = type(np.dtype(np.float64)) + np.add(3, 4, signature=(float_dtype, float_dtype, None)) + + @pytest.mark.parametrize("get_kwarg", [ + lambda dt: dict(dtype=x), + lambda dt: dict(signature=(x, None, None))]) + def test_signature_dtype_instances_allowed(self, get_kwarg): + # We allow certain dtype instances when there is a clear singleton + # and the given one is equivalent; mainly for backcompat. + int64 = np.dtype("int64") + int64_2 = pickle.loads(pickle.dumps(int64)) + # Relies on pickling behavior, if assert fails just remove test... + assert int64 is not int64_2 + + assert np.add(1, 2, **get_kwarg(int64_2)).dtype == int64 + td = np.timedelta(2, "s") + assert np.add(td, td, **get_kwarg("m8")).dtype == "m8[s]" + + @pytest.mark.parametrize("get_kwarg", [ + param(lambda x: dict(dtype=x), id="dtype"), + param(lambda x: dict(signature=(x, None, None)), id="signature")]) + def test_signature_dtype_instances_allowed(self, get_kwarg): + msg = "The `dtype` and `signature` arguments to ufuncs" + + with pytest.raises(TypeError, match=msg): + np.add(3, 5, **get_kwarg(np.dtype("int64").newbyteorder())) + with pytest.raises(TypeError, match=msg): + np.add(3, 5, **get_kwarg(np.dtype("m8[ns]"))) + with pytest.raises(TypeError, match=msg): + np.add(3, 5, **get_kwarg("m8[ns]")) + + @pytest.mark.parametrize("casting", ["unsafe", "same_kind", "safe"]) + def test_partial_signature_mismatch(self, casting): + # If the second argument matches already, no need to specify it: + res = np.ldexp(np.float32(1.), np.int_(2), dtype="d") + assert res.dtype == "d" + res = np.ldexp(np.float32(1.), np.int_(2), signature=(None, None, "d")) + assert res.dtype == "d" + + # ldexp only has a loop for long input as second argument, overriding + # the output cannot help with that (no matter the casting) + with pytest.raises(TypeError): + np.ldexp(1., np.uint64(3), dtype="d") + with pytest.raises(TypeError): + np.ldexp(1., np.uint64(3), signature=(None, None, "d")) + + def test_partial_signature_mismatch_with_cache(self): + with pytest.raises(TypeError): + np.add(np.float16(1), np.uint64(2), sig=("e", "d", None)) + # Ensure e,d->None is in the dispatching cache (double loop) + np.add(np.float16(1), np.float64(2)) + # The error must still be raised: + with pytest.raises(TypeError): + np.add(np.float16(1), np.uint64(2), sig=("e", "d", None)) + + @pytest.mark.xfail(np._get_promotion_state() != "legacy", + reason="NEP 50 impl breaks casting checks when `dtype=` is used " + "together with python scalars.") + def test_use_output_signature_for_all_arguments(self): + # Test that providing only `dtype=` or `signature=(None, None, dtype)` + # is sufficient if falling back to a homogeneous signature works. + # In this case, the `intp, intp -> intp` loop is chosen. + res = np.power(1.5, 2.8, dtype=np.intp, casting="unsafe") + assert res == 1 # the cast happens first. + res = np.power(1.5, 2.8, signature=(None, None, np.intp), + casting="unsafe") + assert res == 1 + with pytest.raises(TypeError): + # the unsafe casting would normally cause errors though: + np.power(1.5, 2.8, dtype=np.intp) + + def test_signature_errors(self): + with pytest.raises(TypeError, + match="the signature object to ufunc must be a string or"): + np.add(3, 4, signature=123.) # neither a string nor a tuple + + with pytest.raises(ValueError): + # bad symbols that do not translate to dtypes + np.add(3, 4, signature="%^->#") + + with pytest.raises(ValueError): + np.add(3, 4, signature=b"ii-i") # incomplete and byte string + + with pytest.raises(ValueError): + np.add(3, 4, signature="ii>i") # incomplete string + + with pytest.raises(ValueError): + np.add(3, 4, signature=(None, "f8")) # bad length + + with pytest.raises(UnicodeDecodeError): + np.add(3, 4, signature=b"\xff\xff->i") + + def test_forced_dtype_times(self): + # Signatures only set the type numbers (not the actual loop dtypes) + # so using `M` in a signature/dtype should generally work: + a = np.array(['2010-01-02', '1999-03-14', '1833-03'], dtype='>M8[D]') + np.maximum(a, a, dtype="M") + np.maximum.reduce(a, dtype="M") + + arr = np.arange(10, dtype="m8[s]") + np.add(arr, arr, dtype="m") + np.maximum(arr, arr, dtype="m") + + @pytest.mark.parametrize("ufunc", [np.add, np.sqrt]) + def test_cast_safety(self, ufunc): + """Basic test for the safest casts, because ufuncs inner loops can + indicate a cast-safety as well (which is normally always "no"). + """ + def call_ufunc(arr, **kwargs): + return ufunc(*(arr,) * ufunc.nin, **kwargs) + + arr = np.array([1., 2., 3.], dtype=np.float32) + arr_bs = arr.astype(arr.dtype.newbyteorder()) + expected = call_ufunc(arr) + # Normally, a "no" cast: + res = call_ufunc(arr, casting="no") + assert_array_equal(expected, res) + # Byte-swapping is not allowed with "no" though: + with pytest.raises(TypeError): + call_ufunc(arr_bs, casting="no") + + # But is allowed with "equiv": + res = call_ufunc(arr_bs, casting="equiv") + assert_array_equal(expected, res) + + # Casting to float64 is safe, but not equiv: + with pytest.raises(TypeError): + call_ufunc(arr_bs, dtype=np.float64, casting="equiv") + + # but it is safe cast: + res = call_ufunc(arr_bs, dtype=np.float64, casting="safe") + expected = call_ufunc(arr.astype(np.float64)) # upcast + assert_array_equal(expected, res) + + @pytest.mark.parametrize("ufunc", [np.add, np.equal]) + def test_cast_safety_scalar(self, ufunc): + # We test add and equal, because equal has special scalar handling + # Note that the "equiv" casting behavior should maybe be considered + # a current implementation detail. + with pytest.raises(TypeError): + # this picks an integer loop, which is not safe + ufunc(3., 4., dtype=int, casting="safe") + + with pytest.raises(TypeError): + # We accept python float as float64 but not float32 for equiv. + ufunc(3., 4., dtype="float32", casting="equiv") + + # Special case for object and equal (note that equiv implies safe) + ufunc(3, 4, dtype=object, casting="equiv") + # Picks a double loop for both, first is equiv, second safe: + ufunc(np.array([3.]), 3., casting="equiv") + ufunc(np.array([3.]), 3, casting="safe") + ufunc(np.array([3]), 3, casting="equiv") + + def test_cast_safety_scalar_special(self): + # We allow this (and it succeeds) via object, although the equiv + # part may not be important. + np.equal(np.array([3]), 2**300, casting="equiv") + + def test_true_divide(self): + a = np.array(10) + b = np.array(20) + tgt = np.array(0.5) + + for tc in 'bhilqBHILQefdgFDG': + dt = np.dtype(tc) + aa = a.astype(dt) + bb = b.astype(dt) + + # Check result value and dtype. + for x, y in itertools.product([aa, -aa], [bb, -bb]): + + # Check with no output type specified + if tc in 'FDG': + tgt = complex(x)/complex(y) + else: + tgt = float(x)/float(y) + + res = np.true_divide(x, y) + rtol = max(np.finfo(res).resolution, 1e-15) + assert_allclose(res, tgt, rtol=rtol) + + if tc in 'bhilqBHILQ': + assert_(res.dtype.name == 'float64') + else: + assert_(res.dtype.name == dt.name ) + + # Check with output type specified. This also checks for the + # incorrect casts in issue gh-3484 because the unary '-' does + # not change types, even for unsigned types, Hence casts in the + # ufunc from signed to unsigned and vice versa will lead to + # errors in the values. + for tcout in 'bhilqBHILQ': + dtout = np.dtype(tcout) + assert_raises(TypeError, np.true_divide, x, y, dtype=dtout) + + for tcout in 'efdg': + dtout = np.dtype(tcout) + if tc in 'FDG': + # Casting complex to float is not allowed + assert_raises(TypeError, np.true_divide, x, y, dtype=dtout) + else: + tgt = float(x)/float(y) + rtol = max(np.finfo(dtout).resolution, 1e-15) + # The value of tiny for double double is NaN + with suppress_warnings() as sup: + sup.filter(UserWarning) + if not np.isnan(np.finfo(dtout).tiny): + atol = max(np.finfo(dtout).tiny, 3e-308) + else: + atol = 3e-308 + # Some test values result in invalid for float16 + # and the cast to it may overflow to inf. + with np.errstate(invalid='ignore', over='ignore'): + res = np.true_divide(x, y, dtype=dtout) + if not np.isfinite(res) and tcout == 'e': + continue + assert_allclose(res, tgt, rtol=rtol, atol=atol) + assert_(res.dtype.name == dtout.name) + + for tcout in 'FDG': + dtout = np.dtype(tcout) + tgt = complex(x)/complex(y) + rtol = max(np.finfo(dtout).resolution, 1e-15) + # The value of tiny for double double is NaN + with suppress_warnings() as sup: + sup.filter(UserWarning) + if not np.isnan(np.finfo(dtout).tiny): + atol = max(np.finfo(dtout).tiny, 3e-308) + else: + atol = 3e-308 + res = np.true_divide(x, y, dtype=dtout) + if not np.isfinite(res): + continue + assert_allclose(res, tgt, rtol=rtol, atol=atol) + assert_(res.dtype.name == dtout.name) + + # Check booleans + a = np.ones((), dtype=np.bool) + res = np.true_divide(a, a) + assert_(res == 1.0) + assert_(res.dtype.name == 'float64') + res = np.true_divide(~a, a) + assert_(res == 0.0) + assert_(res.dtype.name == 'float64') + + def test_sum_stability(self): + a = np.ones(500, dtype=np.float32) + assert_almost_equal((a / 10.).sum() - a.size / 10., 0, 4) + + a = np.ones(500, dtype=np.float64) + assert_almost_equal((a / 10.).sum() - a.size / 10., 0, 13) + + @pytest.mark.skipif(IS_WASM, reason="fp errors don't work in wasm") + def test_sum(self): + for dt in (int, np.float16, np.float32, np.float64, np.longdouble): + for v in (0, 1, 2, 7, 8, 9, 15, 16, 19, 127, + 128, 1024, 1235): + # warning if sum overflows, which it does in float16 + with warnings.catch_warnings(record=True) as w: + warnings.simplefilter("always", RuntimeWarning) + + tgt = dt(v * (v + 1) / 2) + overflow = not np.isfinite(tgt) + assert_equal(len(w), 1 * overflow) + + d = np.arange(1, v + 1, dtype=dt) + + assert_almost_equal(np.sum(d), tgt) + assert_equal(len(w), 2 * overflow) + + assert_almost_equal(np.sum(d[::-1]), tgt) + assert_equal(len(w), 3 * overflow) + + d = np.ones(500, dtype=dt) + assert_almost_equal(np.sum(d[::2]), 250.) + assert_almost_equal(np.sum(d[1::2]), 250.) + assert_almost_equal(np.sum(d[::3]), 167.) + assert_almost_equal(np.sum(d[1::3]), 167.) + assert_almost_equal(np.sum(d[::-2]), 250.) + assert_almost_equal(np.sum(d[-1::-2]), 250.) + assert_almost_equal(np.sum(d[::-3]), 167.) + assert_almost_equal(np.sum(d[-1::-3]), 167.) + # sum with first reduction entry != 0 + d = np.ones((1,), dtype=dt) + d += d + assert_almost_equal(d, 2.) + + def test_sum_complex(self): + for dt in (np.complex64, np.complex128, np.clongdouble): + for v in (0, 1, 2, 7, 8, 9, 15, 16, 19, 127, + 128, 1024, 1235): + tgt = dt(v * (v + 1) / 2) - dt((v * (v + 1) / 2) * 1j) + d = np.empty(v, dtype=dt) + d.real = np.arange(1, v + 1) + d.imag = -np.arange(1, v + 1) + assert_almost_equal(np.sum(d), tgt) + assert_almost_equal(np.sum(d[::-1]), tgt) + + d = np.ones(500, dtype=dt) + 1j + assert_almost_equal(np.sum(d[::2]), 250. + 250j) + assert_almost_equal(np.sum(d[1::2]), 250. + 250j) + assert_almost_equal(np.sum(d[::3]), 167. + 167j) + assert_almost_equal(np.sum(d[1::3]), 167. + 167j) + assert_almost_equal(np.sum(d[::-2]), 250. + 250j) + assert_almost_equal(np.sum(d[-1::-2]), 250. + 250j) + assert_almost_equal(np.sum(d[::-3]), 167. + 167j) + assert_almost_equal(np.sum(d[-1::-3]), 167. + 167j) + # sum with first reduction entry != 0 + d = np.ones((1,), dtype=dt) + 1j + d += d + assert_almost_equal(d, 2. + 2j) + + def test_sum_initial(self): + # Integer, single axis + assert_equal(np.sum([3], initial=2), 5) + + # Floating point + assert_almost_equal(np.sum([0.2], initial=0.1), 0.3) + + # Multiple non-adjacent axes + assert_equal(np.sum(np.ones((2, 3, 5), dtype=np.int64), axis=(0, 2), initial=2), + [12, 12, 12]) + + def test_sum_where(self): + # More extensive tests done in test_reduction_with_where. + assert_equal(np.sum([[1., 2.], [3., 4.]], where=[True, False]), 4.) + assert_equal(np.sum([[1., 2.], [3., 4.]], axis=0, initial=5., + where=[True, False]), [9., 5.]) + + def test_vecdot(self): + arr1 = np.arange(6).reshape((2, 3)) + arr2 = np.arange(3).reshape((1, 3)) + + actual = np.vecdot(arr1, arr2) + expected = np.array([5, 14]) + + assert_array_equal(actual, expected) + + actual2 = np.vecdot(arr1.T, arr2.T, axis=-2) + assert_array_equal(actual2, expected) + + actual3 = np.vecdot(arr1.astype("object"), arr2) + assert_array_equal(actual3, expected.astype("object")) + + def test_vecdot_complex(self): + arr1 = np.array([1, 2j, 3]) + arr2 = np.array([1, 2, 3]) + + actual = np.vecdot(arr1, arr2) + expected = np.array([10-4j]) + assert_array_equal(actual, expected) + + actual2 = np.vecdot(arr2, arr1) + assert_array_equal(actual2, expected.conj()) + + actual3 = np.vecdot(arr1.astype("object"), arr2.astype("object")) + assert_array_equal(actual3, expected.astype("object")) + + def test_vecdot_subclass(self): + class MySubclass(np.ndarray): + pass + + arr1 = np.arange(6).reshape((2, 3)).view(MySubclass) + arr2 = np.arange(3).reshape((1, 3)).view(MySubclass) + result = np.vecdot(arr1, arr2) + assert isinstance(result, MySubclass) + + def test_vecdot_object_no_conjugate(self): + arr = np.array(["1", "2"], dtype=object) + with pytest.raises(AttributeError, match="conjugate"): + np.vecdot(arr, arr) + + def test_vecdot_object_breaks_outer_loop_on_error(self): + arr1 = np.ones((3, 3)).astype(object) + arr2 = arr1.copy() + arr2[1, 1] = None + out = np.zeros(3).astype(object) + with pytest.raises(TypeError, match=r"\*: 'float' and 'NoneType'"): + np.vecdot(arr1, arr2, out=out) + assert out[0] == 3 + assert out[1] == out[2] == 0 + + def test_broadcast(self): + msg = "broadcast" + a = np.arange(4).reshape((2, 1, 2)) + b = np.arange(4).reshape((1, 2, 2)) + assert_array_equal(np.vecdot(a, b), np.sum(a*b, axis=-1), err_msg=msg) + msg = "extend & broadcast loop dimensions" + b = np.arange(4).reshape((2, 2)) + assert_array_equal(np.vecdot(a, b), np.sum(a*b, axis=-1), err_msg=msg) + # Broadcast in core dimensions should fail + a = np.arange(8).reshape((4, 2)) + b = np.arange(4).reshape((4, 1)) + assert_raises(ValueError, np.vecdot, a, b) + # Extend core dimensions should fail + a = np.arange(8).reshape((4, 2)) + b = np.array(7) + assert_raises(ValueError, np.vecdot, a, b) + # Broadcast should fail + a = np.arange(2).reshape((2, 1, 1)) + b = np.arange(3).reshape((3, 1, 1)) + assert_raises(ValueError, np.vecdot, a, b) + + # Writing to a broadcasted array with overlap should warn, gh-2705 + a = np.arange(2) + b = np.arange(4).reshape((2, 2)) + u, v = np.broadcast_arrays(a, b) + assert_equal(u.strides[0], 0) + x = u + v + with warnings.catch_warnings(record=True) as w: + warnings.simplefilter("always") + u += v + assert_equal(len(w), 1) + assert_(x[0, 0] != u[0, 0]) + + # Output reduction should not be allowed. + # See gh-15139 + a = np.arange(6).reshape(3, 2) + b = np.ones(2) + out = np.empty(()) + assert_raises(ValueError, np.vecdot, a, b, out) + out2 = np.empty(3) + c = np.vecdot(a, b, out2) + assert_(c is out2) + + def test_out_broadcasts(self): + # For ufuncs and gufuncs (not for reductions), we currently allow + # the output to cause broadcasting of the input arrays. + # both along dimensions with shape 1 and dimensions which do not + # exist at all in the inputs. + arr = np.arange(3).reshape(1, 3) + out = np.empty((5, 4, 3)) + np.add(arr, arr, out=out) + assert (out == np.arange(3) * 2).all() + + # The same holds for gufuncs (gh-16484) + np.vecdot(arr, arr, out=out) + # the result would be just a scalar `5`, but is broadcast fully: + assert (out == 5).all() + + @pytest.mark.parametrize(["arr", "out"], [ + ([2], np.empty(())), + ([1, 2], np.empty(1)), + (np.ones((4, 3)), np.empty((4, 1)))], + ids=["(1,)->()", "(2,)->(1,)", "(4, 3)->(4, 1)"]) + def test_out_broadcast_errors(self, arr, out): + # Output is (currently) allowed to broadcast inputs, but it cannot be + # smaller than the actual result. + with pytest.raises(ValueError, match="non-broadcastable"): + np.positive(arr, out=out) + + with pytest.raises(ValueError, match="non-broadcastable"): + np.add(np.ones(()), arr, out=out) + + def test_type_cast(self): + msg = "type cast" + a = np.arange(6, dtype='short').reshape((2, 3)) + assert_array_equal(np.vecdot(a, a), np.sum(a*a, axis=-1), + err_msg=msg) + msg = "type cast on one argument" + a = np.arange(6).reshape((2, 3)) + b = a + 0.1 + assert_array_almost_equal(np.vecdot(a, b), np.sum(a*b, axis=-1), + err_msg=msg) + + def test_endian(self): + msg = "big endian" + a = np.arange(6, dtype='>i4').reshape((2, 3)) + assert_array_equal(np.vecdot(a, a), np.sum(a*a, axis=-1), + err_msg=msg) + msg = "little endian" + a = np.arange(6, dtype='()' + a = np.arange(27.).reshape((3, 3, 3)) + b = np.arange(10., 19.).reshape((3, 1, 3)) + # basic tests on inputs (outputs tested below with matrix_multiply). + c = np.vecdot(a, b) + assert_array_equal(c, (a * b).sum(-1)) + # default + c = np.vecdot(a, b, axes=[(-1,), (-1,), ()]) + assert_array_equal(c, (a * b).sum(-1)) + # integers ok for single axis. + c = np.vecdot(a, b, axes=[-1, -1, ()]) + assert_array_equal(c, (a * b).sum(-1)) + # mix fine + c = np.vecdot(a, b, axes=[(-1,), -1, ()]) + assert_array_equal(c, (a * b).sum(-1)) + # can omit last axis. + c = np.vecdot(a, b, axes=[-1, -1]) + assert_array_equal(c, (a * b).sum(-1)) + # can pass in other types of integer (with __index__ protocol) + c = np.vecdot(a, b, axes=[np.int8(-1), np.array(-1, dtype=np.int32)]) + assert_array_equal(c, (a * b).sum(-1)) + # swap some axes + c = np.vecdot(a, b, axes=[0, 0]) + assert_array_equal(c, (a * b).sum(0)) + c = np.vecdot(a, b, axes=[0, 2]) + assert_array_equal(c, (a.transpose(1, 2, 0) * b).sum(-1)) + # Check errors for improperly constructed axes arguments. + # should have list. + assert_raises(TypeError, np.vecdot, a, b, axes=-1) + # needs enough elements + assert_raises(ValueError, np.vecdot, a, b, axes=[-1]) + # should pass in indices. + assert_raises(TypeError, np.vecdot, a, b, axes=[-1.0, -1.0]) + assert_raises(TypeError, np.vecdot, a, b, axes=[(-1.0,), -1]) + assert_raises(TypeError, np.vecdot, a, b, axes=[None, 1]) + # cannot pass an index unless there is only one dimension + # (output is wrong in this case) + assert_raises(AxisError, np.vecdot, a, b, axes=[-1, -1, -1]) + # or pass in generally the wrong number of axes + assert_raises(AxisError, np.vecdot, a, b, axes=[-1, -1, (-1,)]) + assert_raises(AxisError, np.vecdot, a, b, axes=[-1, (-2, -1), ()]) + # axes need to have same length. + assert_raises(ValueError, np.vecdot, a, b, axes=[0, 1]) + + # matrix_multiply signature: '(m,n),(n,p)->(m,p)' + mm = umt.matrix_multiply + a = np.arange(12).reshape((2, 3, 2)) + b = np.arange(8).reshape((2, 2, 2, 1)) + 1 + # Sanity check. + c = mm(a, b) + assert_array_equal(c, np.matmul(a, b)) + # Default axes. + c = mm(a, b, axes=[(-2, -1), (-2, -1), (-2, -1)]) + assert_array_equal(c, np.matmul(a, b)) + # Default with explicit axes. + c = mm(a, b, axes=[(1, 2), (2, 3), (2, 3)]) + assert_array_equal(c, np.matmul(a, b)) + # swap some axes. + c = mm(a, b, axes=[(0, -1), (1, 2), (-2, -1)]) + assert_array_equal(c, np.matmul(a.transpose(1, 0, 2), + b.transpose(0, 3, 1, 2))) + # Default with output array. + c = np.empty((2, 2, 3, 1)) + d = mm(a, b, out=c, axes=[(1, 2), (2, 3), (2, 3)]) + assert_(c is d) + assert_array_equal(c, np.matmul(a, b)) + # Transposed output array + c = np.empty((1, 2, 2, 3)) + d = mm(a, b, out=c, axes=[(-2, -1), (-2, -1), (3, 0)]) + assert_(c is d) + assert_array_equal(c, np.matmul(a, b).transpose(3, 0, 1, 2)) + # Check errors for improperly constructed axes arguments. + # wrong argument + assert_raises(TypeError, mm, a, b, axis=1) + # axes should be list + assert_raises(TypeError, mm, a, b, axes=1) + assert_raises(TypeError, mm, a, b, axes=((-2, -1), (-2, -1), (-2, -1))) + # list needs to have right length + assert_raises(ValueError, mm, a, b, axes=[]) + assert_raises(ValueError, mm, a, b, axes=[(-2, -1)]) + # list should not contain None, or lists + assert_raises(TypeError, mm, a, b, axes=[None, None, None]) + assert_raises(TypeError, + mm, a, b, axes=[[-2, -1], [-2, -1], [-2, -1]]) + assert_raises(TypeError, + mm, a, b, axes=[(-2, -1), (-2, -1), [-2, -1]]) + assert_raises(TypeError, mm, a, b, axes=[(-2, -1), (-2, -1), None]) + # single integers are AxisErrors if more are required + assert_raises(AxisError, mm, a, b, axes=[-1, -1, -1]) + assert_raises(AxisError, mm, a, b, axes=[(-2, -1), (-2, -1), -1]) + # tuples should not have duplicated values + assert_raises(ValueError, mm, a, b, axes=[(-2, -1), (-2, -1), (-2, -2)]) + # arrays should have enough axes. + z = np.zeros((2, 2)) + assert_raises(ValueError, mm, z, z[0]) + assert_raises(ValueError, mm, z, z, out=z[:, 0]) + assert_raises(ValueError, mm, z[1], z, axes=[0, 1]) + assert_raises(ValueError, mm, z, z, out=z[0], axes=[0, 1]) + # Regular ufuncs should not accept axes. + assert_raises(TypeError, np.add, 1., 1., axes=[0]) + # should be able to deal with bad unrelated kwargs. + assert_raises(TypeError, mm, z, z, axes=[0, 1], parrot=True) + + def test_axis_argument(self): + # vecdot signature: '(n),(n)->()' + a = np.arange(27.).reshape((3, 3, 3)) + b = np.arange(10., 19.).reshape((3, 1, 3)) + c = np.vecdot(a, b) + assert_array_equal(c, (a * b).sum(-1)) + c = np.vecdot(a, b, axis=-1) + assert_array_equal(c, (a * b).sum(-1)) + out = np.zeros_like(c) + d = np.vecdot(a, b, axis=-1, out=out) + assert_(d is out) + assert_array_equal(d, c) + c = np.vecdot(a, b, axis=0) + assert_array_equal(c, (a * b).sum(0)) + # Sanity checks on innerwt and cumsum. + a = np.arange(6).reshape((2, 3)) + b = np.arange(10, 16).reshape((2, 3)) + w = np.arange(20, 26).reshape((2, 3)) + assert_array_equal(umt.innerwt(a, b, w, axis=0), + np.sum(a * b * w, axis=0)) + assert_array_equal(umt.cumsum(a, axis=0), np.cumsum(a, axis=0)) + assert_array_equal(umt.cumsum(a, axis=-1), np.cumsum(a, axis=-1)) + out = np.empty_like(a) + b = umt.cumsum(a, out=out, axis=0) + assert_(out is b) + assert_array_equal(b, np.cumsum(a, axis=0)) + b = umt.cumsum(a, out=out, axis=1) + assert_(out is b) + assert_array_equal(b, np.cumsum(a, axis=-1)) + # Check errors. + # Cannot pass in both axis and axes. + assert_raises(TypeError, np.vecdot, a, b, axis=0, axes=[0, 0]) + # Not an integer. + assert_raises(TypeError, np.vecdot, a, b, axis=[0]) + # more than 1 core dimensions. + mm = umt.matrix_multiply + assert_raises(TypeError, mm, a, b, axis=1) + # Output wrong size in axis. + out = np.empty((1, 2, 3), dtype=a.dtype) + assert_raises(ValueError, umt.cumsum, a, out=out, axis=0) + # Regular ufuncs should not accept axis. + assert_raises(TypeError, np.add, 1., 1., axis=0) + + def test_keepdims_argument(self): + # vecdot signature: '(n),(n)->()' + a = np.arange(27.).reshape((3, 3, 3)) + b = np.arange(10., 19.).reshape((3, 1, 3)) + c = np.vecdot(a, b) + assert_array_equal(c, (a * b).sum(-1)) + c = np.vecdot(a, b, keepdims=False) + assert_array_equal(c, (a * b).sum(-1)) + c = np.vecdot(a, b, keepdims=True) + assert_array_equal(c, (a * b).sum(-1, keepdims=True)) + out = np.zeros_like(c) + d = np.vecdot(a, b, keepdims=True, out=out) + assert_(d is out) + assert_array_equal(d, c) + # Now combined with axis and axes. + c = np.vecdot(a, b, axis=-1, keepdims=False) + assert_array_equal(c, (a * b).sum(-1, keepdims=False)) + c = np.vecdot(a, b, axis=-1, keepdims=True) + assert_array_equal(c, (a * b).sum(-1, keepdims=True)) + c = np.vecdot(a, b, axis=0, keepdims=False) + assert_array_equal(c, (a * b).sum(0, keepdims=False)) + c = np.vecdot(a, b, axis=0, keepdims=True) + assert_array_equal(c, (a * b).sum(0, keepdims=True)) + c = np.vecdot(a, b, axes=[(-1,), (-1,), ()], keepdims=False) + assert_array_equal(c, (a * b).sum(-1)) + c = np.vecdot(a, b, axes=[(-1,), (-1,), (-1,)], keepdims=True) + assert_array_equal(c, (a * b).sum(-1, keepdims=True)) + c = np.vecdot(a, b, axes=[0, 0], keepdims=False) + assert_array_equal(c, (a * b).sum(0)) + c = np.vecdot(a, b, axes=[0, 0, 0], keepdims=True) + assert_array_equal(c, (a * b).sum(0, keepdims=True)) + c = np.vecdot(a, b, axes=[0, 2], keepdims=False) + assert_array_equal(c, (a.transpose(1, 2, 0) * b).sum(-1)) + c = np.vecdot(a, b, axes=[0, 2], keepdims=True) + assert_array_equal(c, (a.transpose(1, 2, 0) * b).sum(-1, + keepdims=True)) + c = np.vecdot(a, b, axes=[0, 2, 2], keepdims=True) + assert_array_equal(c, (a.transpose(1, 2, 0) * b).sum(-1, + keepdims=True)) + c = np.vecdot(a, b, axes=[0, 2, 0], keepdims=True) + assert_array_equal(c, (a * b.transpose(2, 0, 1)).sum(0, keepdims=True)) + # Hardly useful, but should work. + c = np.vecdot(a, b, axes=[0, 2, 1], keepdims=True) + assert_array_equal(c, (a.transpose(1, 0, 2) * b.transpose(0, 2, 1)) + .sum(1, keepdims=True)) + # Check with two core dimensions. + a = np.eye(3) * np.arange(4.)[:, np.newaxis, np.newaxis] + expected = uml.det(a) + c = uml.det(a, keepdims=False) + assert_array_equal(c, expected) + c = uml.det(a, keepdims=True) + assert_array_equal(c, expected[:, np.newaxis, np.newaxis]) + a = np.eye(3) * np.arange(4.)[:, np.newaxis, np.newaxis] + expected_s, expected_l = uml.slogdet(a) + cs, cl = uml.slogdet(a, keepdims=False) + assert_array_equal(cs, expected_s) + assert_array_equal(cl, expected_l) + cs, cl = uml.slogdet(a, keepdims=True) + assert_array_equal(cs, expected_s[:, np.newaxis, np.newaxis]) + assert_array_equal(cl, expected_l[:, np.newaxis, np.newaxis]) + # Sanity check on innerwt. + a = np.arange(6).reshape((2, 3)) + b = np.arange(10, 16).reshape((2, 3)) + w = np.arange(20, 26).reshape((2, 3)) + assert_array_equal(umt.innerwt(a, b, w, keepdims=True), + np.sum(a * b * w, axis=-1, keepdims=True)) + assert_array_equal(umt.innerwt(a, b, w, axis=0, keepdims=True), + np.sum(a * b * w, axis=0, keepdims=True)) + # Check errors. + # Not a boolean + assert_raises(TypeError, np.vecdot, a, b, keepdims='true') + # More than 1 core dimension, and core output dimensions. + mm = umt.matrix_multiply + assert_raises(TypeError, mm, a, b, keepdims=True) + assert_raises(TypeError, mm, a, b, keepdims=False) + # Regular ufuncs should not accept keepdims. + assert_raises(TypeError, np.add, 1., 1., keepdims=False) + + def test_innerwt(self): + a = np.arange(6).reshape((2, 3)) + b = np.arange(10, 16).reshape((2, 3)) + w = np.arange(20, 26).reshape((2, 3)) + assert_array_equal(umt.innerwt(a, b, w), np.sum(a*b*w, axis=-1)) + a = np.arange(100, 124).reshape((2, 3, 4)) + b = np.arange(200, 224).reshape((2, 3, 4)) + w = np.arange(300, 324).reshape((2, 3, 4)) + assert_array_equal(umt.innerwt(a, b, w), np.sum(a*b*w, axis=-1)) + + def test_innerwt_empty(self): + """Test generalized ufunc with zero-sized operands""" + a = np.array([], dtype='f8') + b = np.array([], dtype='f8') + w = np.array([], dtype='f8') + assert_array_equal(umt.innerwt(a, b, w), np.sum(a*b*w, axis=-1)) + + def test_cross1d(self): + """Test with fixed-sized signature.""" + a = np.eye(3) + assert_array_equal(umt.cross1d(a, a), np.zeros((3, 3))) + out = np.zeros((3, 3)) + result = umt.cross1d(a[0], a, out) + assert_(result is out) + assert_array_equal(result, np.vstack((np.zeros(3), a[2], -a[1]))) + assert_raises(ValueError, umt.cross1d, np.eye(4), np.eye(4)) + assert_raises(ValueError, umt.cross1d, a, np.arange(4.)) + # Wrong output core dimension. + assert_raises(ValueError, umt.cross1d, a, np.arange(3.), np.zeros((3, 4))) + # Wrong output broadcast dimension (see gh-15139). + assert_raises(ValueError, umt.cross1d, a, np.arange(3.), np.zeros(3)) + + def test_can_ignore_signature(self): + # Comparing the effects of ? in signature: + # matrix_multiply: (m,n),(n,p)->(m,p) # all must be there. + # matmul: (m?,n),(n,p?)->(m?,p?) # allow missing m, p. + mat = np.arange(12).reshape((2, 3, 2)) + single_vec = np.arange(2) + col_vec = single_vec[:, np.newaxis] + col_vec_array = np.arange(8).reshape((2, 2, 2, 1)) + 1 + # matrix @ single column vector with proper dimension + mm_col_vec = umt.matrix_multiply(mat, col_vec) + # matmul does the same thing + matmul_col_vec = umt.matmul(mat, col_vec) + assert_array_equal(matmul_col_vec, mm_col_vec) + # matrix @ vector without dimension making it a column vector. + # matrix multiply fails -> missing core dim. + assert_raises(ValueError, umt.matrix_multiply, mat, single_vec) + # matmul mimicker passes, and returns a vector. + matmul_col = umt.matmul(mat, single_vec) + assert_array_equal(matmul_col, mm_col_vec.squeeze()) + # Now with a column array: same as for column vector, + # broadcasting sensibly. + mm_col_vec = umt.matrix_multiply(mat, col_vec_array) + matmul_col_vec = umt.matmul(mat, col_vec_array) + assert_array_equal(matmul_col_vec, mm_col_vec) + # As above, but for row vector + single_vec = np.arange(3) + row_vec = single_vec[np.newaxis, :] + row_vec_array = np.arange(24).reshape((4, 2, 1, 1, 3)) + 1 + # row vector @ matrix + mm_row_vec = umt.matrix_multiply(row_vec, mat) + matmul_row_vec = umt.matmul(row_vec, mat) + assert_array_equal(matmul_row_vec, mm_row_vec) + # single row vector @ matrix + assert_raises(ValueError, umt.matrix_multiply, single_vec, mat) + matmul_row = umt.matmul(single_vec, mat) + assert_array_equal(matmul_row, mm_row_vec.squeeze()) + # row vector array @ matrix + mm_row_vec = umt.matrix_multiply(row_vec_array, mat) + matmul_row_vec = umt.matmul(row_vec_array, mat) + assert_array_equal(matmul_row_vec, mm_row_vec) + # Now for vector combinations + # row vector @ column vector + col_vec = row_vec.T + col_vec_array = row_vec_array.swapaxes(-2, -1) + mm_row_col_vec = umt.matrix_multiply(row_vec, col_vec) + matmul_row_col_vec = umt.matmul(row_vec, col_vec) + assert_array_equal(matmul_row_col_vec, mm_row_col_vec) + # single row vector @ single col vector + assert_raises(ValueError, umt.matrix_multiply, single_vec, single_vec) + matmul_row_col = umt.matmul(single_vec, single_vec) + assert_array_equal(matmul_row_col, mm_row_col_vec.squeeze()) + # row vector array @ matrix + mm_row_col_array = umt.matrix_multiply(row_vec_array, col_vec_array) + matmul_row_col_array = umt.matmul(row_vec_array, col_vec_array) + assert_array_equal(matmul_row_col_array, mm_row_col_array) + # Finally, check that things are *not* squeezed if one gives an + # output. + out = np.zeros_like(mm_row_col_array) + out = umt.matrix_multiply(row_vec_array, col_vec_array, out=out) + assert_array_equal(out, mm_row_col_array) + out[:] = 0 + out = umt.matmul(row_vec_array, col_vec_array, out=out) + assert_array_equal(out, mm_row_col_array) + # And check one cannot put missing dimensions back. + out = np.zeros_like(mm_row_col_vec) + assert_raises(ValueError, umt.matrix_multiply, single_vec, single_vec, + out) + # But fine for matmul, since it is just a broadcast. + out = umt.matmul(single_vec, single_vec, out) + assert_array_equal(out, mm_row_col_vec.squeeze()) + + def test_matrix_multiply(self): + self.compare_matrix_multiply_results(np.int64) + self.compare_matrix_multiply_results(np.double) + + def test_matrix_multiply_umath_empty(self): + res = umt.matrix_multiply(np.ones((0, 10)), np.ones((10, 0))) + assert_array_equal(res, np.zeros((0, 0))) + res = umt.matrix_multiply(np.ones((10, 0)), np.ones((0, 10))) + assert_array_equal(res, np.zeros((10, 10))) + + def compare_matrix_multiply_results(self, tp): + d1 = np.array(np.random.rand(2, 3, 4), dtype=tp) + d2 = np.array(np.random.rand(2, 3, 4), dtype=tp) + msg = "matrix multiply on type %s" % d1.dtype.name + + def permute_n(n): + if n == 1: + return ([0],) + ret = () + base = permute_n(n-1) + for perm in base: + for i in range(n): + new = perm + [n-1] + new[n-1] = new[i] + new[i] = n-1 + ret += (new,) + return ret + + def slice_n(n): + if n == 0: + return ((),) + ret = () + base = slice_n(n-1) + for sl in base: + ret += (sl+(slice(None),),) + ret += (sl+(slice(0, 1),),) + return ret + + def broadcastable(s1, s2): + return s1 == s2 or s1 == 1 or s2 == 1 + + permute_3 = permute_n(3) + slice_3 = slice_n(3) + ((slice(None, None, -1),)*3,) + + ref = True + for p1 in permute_3: + for p2 in permute_3: + for s1 in slice_3: + for s2 in slice_3: + a1 = d1.transpose(p1)[s1] + a2 = d2.transpose(p2)[s2] + ref = ref and a1.base is not None + ref = ref and a2.base is not None + if (a1.shape[-1] == a2.shape[-2] and + broadcastable(a1.shape[0], a2.shape[0])): + assert_array_almost_equal( + umt.matrix_multiply(a1, a2), + np.sum(a2[..., np.newaxis].swapaxes(-3, -1) * + a1[..., np.newaxis,:], axis=-1), + err_msg=msg + ' %s %s' % (str(a1.shape), + str(a2.shape))) + + assert_equal(ref, True, err_msg="reference check") + + def test_euclidean_pdist(self): + a = np.arange(12, dtype=float).reshape(4, 3) + out = np.empty((a.shape[0] * (a.shape[0] - 1) // 2,), dtype=a.dtype) + umt.euclidean_pdist(a, out) + b = np.sqrt(np.sum((a[:, None] - a)**2, axis=-1)) + b = b[~np.tri(a.shape[0], dtype=bool)] + assert_almost_equal(out, b) + # An output array is required to determine p with signature (n,d)->(p) + assert_raises(ValueError, umt.euclidean_pdist, a) + + def test_cumsum(self): + a = np.arange(10) + result = umt.cumsum(a) + assert_array_equal(result, a.cumsum()) + + def test_object_logical(self): + a = np.array([3, None, True, False, "test", ""], dtype=object) + assert_equal(np.logical_or(a, None), + np.array([x or None for x in a], dtype=object)) + assert_equal(np.logical_or(a, True), + np.array([x or True for x in a], dtype=object)) + assert_equal(np.logical_or(a, 12), + np.array([x or 12 for x in a], dtype=object)) + assert_equal(np.logical_or(a, "blah"), + np.array([x or "blah" for x in a], dtype=object)) + + assert_equal(np.logical_and(a, None), + np.array([x and None for x in a], dtype=object)) + assert_equal(np.logical_and(a, True), + np.array([x and True for x in a], dtype=object)) + assert_equal(np.logical_and(a, 12), + np.array([x and 12 for x in a], dtype=object)) + assert_equal(np.logical_and(a, "blah"), + np.array([x and "blah" for x in a], dtype=object)) + + assert_equal(np.logical_not(a), + np.array([not x for x in a], dtype=object)) + + assert_equal(np.logical_or.reduce(a), 3) + assert_equal(np.logical_and.reduce(a), None) + + def test_object_comparison(self): + class HasComparisons: + def __eq__(self, other): + return '==' + + arr0d = np.array(HasComparisons()) + assert_equal(arr0d == arr0d, True) + assert_equal(np.equal(arr0d, arr0d), True) # normal behavior is a cast + + arr1d = np.array([HasComparisons()]) + assert_equal(arr1d == arr1d, np.array([True])) + assert_equal(np.equal(arr1d, arr1d), np.array([True])) # normal behavior is a cast + assert_equal(np.equal(arr1d, arr1d, dtype=object), np.array(['=='])) + + def test_object_array_reduction(self): + # Reductions on object arrays + a = np.array(['a', 'b', 'c'], dtype=object) + assert_equal(np.sum(a), 'abc') + assert_equal(np.max(a), 'c') + assert_equal(np.min(a), 'a') + a = np.array([True, False, True], dtype=object) + assert_equal(np.sum(a), 2) + assert_equal(np.prod(a), 0) + assert_equal(np.any(a), True) + assert_equal(np.all(a), False) + assert_equal(np.max(a), True) + assert_equal(np.min(a), False) + assert_equal(np.array([[1]], dtype=object).sum(), 1) + assert_equal(np.array([[[1, 2]]], dtype=object).sum((0, 1)), [1, 2]) + assert_equal(np.array([1], dtype=object).sum(initial=1), 2) + assert_equal(np.array([[1], [2, 3]], dtype=object) + .sum(initial=[0], where=[False, True]), [0, 2, 3]) + + def test_object_array_accumulate_inplace(self): + # Checks that in-place accumulates work, see also gh-7402 + arr = np.ones(4, dtype=object) + arr[:] = [[1] for i in range(4)] + # Twice reproduced also for tuples: + np.add.accumulate(arr, out=arr) + np.add.accumulate(arr, out=arr) + assert_array_equal(arr, + np.array([[1]*i for i in [1, 3, 6, 10]], dtype=object), + ) + + # And the same if the axis argument is used + arr = np.ones((2, 4), dtype=object) + arr[0, :] = [[2] for i in range(4)] + np.add.accumulate(arr, out=arr, axis=-1) + np.add.accumulate(arr, out=arr, axis=-1) + assert_array_equal(arr[0, :], + np.array([[2]*i for i in [1, 3, 6, 10]], dtype=object), + ) + + def test_object_array_accumulate_failure(self): + # Typical accumulation on object works as expected: + res = np.add.accumulate(np.array([1, 0, 2], dtype=object)) + assert_array_equal(res, np.array([1, 1, 3], dtype=object)) + # But errors are propagated from the inner-loop if they occur: + with pytest.raises(TypeError): + np.add.accumulate([1, None, 2]) + + def test_object_array_reduceat_inplace(self): + # Checks that in-place reduceats work, see also gh-7465 + arr = np.empty(4, dtype=object) + arr[:] = [[1] for i in range(4)] + out = np.empty(4, dtype=object) + out[:] = [[1] for i in range(4)] + np.add.reduceat(arr, np.arange(4), out=arr) + np.add.reduceat(arr, np.arange(4), out=arr) + assert_array_equal(arr, out) + + # And the same if the axis argument is used + arr = np.ones((2, 4), dtype=object) + arr[0, :] = [[2] for i in range(4)] + out = np.ones((2, 4), dtype=object) + out[0, :] = [[2] for i in range(4)] + np.add.reduceat(arr, np.arange(4), out=arr, axis=-1) + np.add.reduceat(arr, np.arange(4), out=arr, axis=-1) + assert_array_equal(arr, out) + + def test_object_array_reduceat_failure(self): + # Reduceat works as expected when no invalid operation occurs (None is + # not involved in an operation here) + res = np.add.reduceat(np.array([1, None, 2], dtype=object), [1, 2]) + assert_array_equal(res, np.array([None, 2], dtype=object)) + # But errors when None would be involved in an operation: + with pytest.raises(TypeError): + np.add.reduceat([1, None, 2], [0, 2]) + + def test_zerosize_reduction(self): + # Test with default dtype and object dtype + for a in [[], np.array([], dtype=object)]: + assert_equal(np.sum(a), 0) + assert_equal(np.prod(a), 1) + assert_equal(np.any(a), False) + assert_equal(np.all(a), True) + assert_raises(ValueError, np.max, a) + assert_raises(ValueError, np.min, a) + + def test_axis_out_of_bounds(self): + a = np.array([False, False]) + assert_raises(AxisError, a.all, axis=1) + a = np.array([False, False]) + assert_raises(AxisError, a.all, axis=-2) + + a = np.array([False, False]) + assert_raises(AxisError, a.any, axis=1) + a = np.array([False, False]) + assert_raises(AxisError, a.any, axis=-2) + + def test_scalar_reduction(self): + # The functions 'sum', 'prod', etc allow specifying axis=0 + # even for scalars + assert_equal(np.sum(3, axis=0), 3) + assert_equal(np.prod(3.5, axis=0), 3.5) + assert_equal(np.any(True, axis=0), True) + assert_equal(np.all(False, axis=0), False) + assert_equal(np.max(3, axis=0), 3) + assert_equal(np.min(2.5, axis=0), 2.5) + + # Check scalar behaviour for ufuncs without an identity + assert_equal(np.power.reduce(3), 3) + + # Make sure that scalars are coming out from this operation + assert_(type(np.prod(np.float32(2.5), axis=0)) is np.float32) + assert_(type(np.sum(np.float32(2.5), axis=0)) is np.float32) + assert_(type(np.max(np.float32(2.5), axis=0)) is np.float32) + assert_(type(np.min(np.float32(2.5), axis=0)) is np.float32) + + # check if scalars/0-d arrays get cast + assert_(type(np.any(0, axis=0)) is np.bool) + + # assert that 0-d arrays get wrapped + class MyArray(np.ndarray): + pass + a = np.array(1).view(MyArray) + assert_(type(np.any(a)) is MyArray) + + def test_casting_out_param(self): + # Test that it's possible to do casts on output + a = np.ones((200, 100), np.int64) + b = np.ones((200, 100), np.int64) + c = np.ones((200, 100), np.float64) + np.add(a, b, out=c) + assert_equal(c, 2) + + a = np.zeros(65536) + b = np.zeros(65536, dtype=np.float32) + np.subtract(a, 0, out=b) + assert_equal(b, 0) + + def test_where_param(self): + # Test that the where= ufunc parameter works with regular arrays + a = np.arange(7) + b = np.ones(7) + c = np.zeros(7) + np.add(a, b, out=c, where=(a % 2 == 1)) + assert_equal(c, [0, 2, 0, 4, 0, 6, 0]) + + a = np.arange(4).reshape(2, 2) + 2 + np.power(a, [2, 3], out=a, where=[[0, 1], [1, 0]]) + assert_equal(a, [[2, 27], [16, 5]]) + # Broadcasting the where= parameter + np.subtract(a, 2, out=a, where=[True, False]) + assert_equal(a, [[0, 27], [14, 5]]) + + def test_where_param_buffer_output(self): + # This test is temporarily skipped because it requires + # adding masking features to the nditer to work properly + + # With casting on output + a = np.ones(10, np.int64) + b = np.ones(10, np.int64) + c = 1.5 * np.ones(10, np.float64) + np.add(a, b, out=c, where=[1, 0, 0, 1, 0, 0, 1, 1, 1, 0]) + assert_equal(c, [2, 1.5, 1.5, 2, 1.5, 1.5, 2, 2, 2, 1.5]) + + def test_where_param_alloc(self): + # With casting and allocated output + a = np.array([1], dtype=np.int64) + m = np.array([True], dtype=bool) + assert_equal(np.sqrt(a, where=m), [1]) + + # No casting and allocated output + a = np.array([1], dtype=np.float64) + m = np.array([True], dtype=bool) + assert_equal(np.sqrt(a, where=m), [1]) + + def test_where_with_broadcasting(self): + # See gh-17198 + a = np.random.random((5000, 4)) + b = np.random.random((5000, 1)) + + where = a > 0.3 + out = np.full_like(a, 0) + np.less(a, b, where=where, out=out) + b_where = np.broadcast_to(b, a.shape)[where] + assert_array_equal((a[where] < b_where), out[where].astype(bool)) + assert not out[~where].any() # outside mask, out remains all 0 + + def check_identityless_reduction(self, a): + # np.minimum.reduce is an identityless reduction + + # Verify that it sees the zero at various positions + a[...] = 1 + a[1, 0, 0] = 0 + assert_equal(np.minimum.reduce(a, axis=None), 0) + assert_equal(np.minimum.reduce(a, axis=(0, 1)), [0, 1, 1, 1]) + assert_equal(np.minimum.reduce(a, axis=(0, 2)), [0, 1, 1]) + assert_equal(np.minimum.reduce(a, axis=(1, 2)), [1, 0]) + assert_equal(np.minimum.reduce(a, axis=0), + [[0, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1]]) + assert_equal(np.minimum.reduce(a, axis=1), + [[1, 1, 1, 1], [0, 1, 1, 1]]) + assert_equal(np.minimum.reduce(a, axis=2), + [[1, 1, 1], [0, 1, 1]]) + assert_equal(np.minimum.reduce(a, axis=()), a) + + a[...] = 1 + a[0, 1, 0] = 0 + assert_equal(np.minimum.reduce(a, axis=None), 0) + assert_equal(np.minimum.reduce(a, axis=(0, 1)), [0, 1, 1, 1]) + assert_equal(np.minimum.reduce(a, axis=(0, 2)), [1, 0, 1]) + assert_equal(np.minimum.reduce(a, axis=(1, 2)), [0, 1]) + assert_equal(np.minimum.reduce(a, axis=0), + [[1, 1, 1, 1], [0, 1, 1, 1], [1, 1, 1, 1]]) + assert_equal(np.minimum.reduce(a, axis=1), + [[0, 1, 1, 1], [1, 1, 1, 1]]) + assert_equal(np.minimum.reduce(a, axis=2), + [[1, 0, 1], [1, 1, 1]]) + assert_equal(np.minimum.reduce(a, axis=()), a) + + a[...] = 1 + a[0, 0, 1] = 0 + assert_equal(np.minimum.reduce(a, axis=None), 0) + assert_equal(np.minimum.reduce(a, axis=(0, 1)), [1, 0, 1, 1]) + assert_equal(np.minimum.reduce(a, axis=(0, 2)), [0, 1, 1]) + assert_equal(np.minimum.reduce(a, axis=(1, 2)), [0, 1]) + assert_equal(np.minimum.reduce(a, axis=0), + [[1, 0, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1]]) + assert_equal(np.minimum.reduce(a, axis=1), + [[1, 0, 1, 1], [1, 1, 1, 1]]) + assert_equal(np.minimum.reduce(a, axis=2), + [[0, 1, 1], [1, 1, 1]]) + assert_equal(np.minimum.reduce(a, axis=()), a) + + @requires_memory(6 * 1024**3) + @pytest.mark.skipif(sys.maxsize < 2**32, + reason="test array too large for 32bit platform") + def test_identityless_reduction_huge_array(self): + # Regression test for gh-20921 (copying identity incorrectly failed) + arr = np.zeros((2, 2**31), 'uint8') + arr[:, 0] = [1, 3] + arr[:, -1] = [4, 1] + res = np.maximum.reduce(arr, axis=0) + del arr + assert res[0] == 3 + assert res[-1] == 4 + + def test_identityless_reduction_corder(self): + a = np.empty((2, 3, 4), order='C') + self.check_identityless_reduction(a) + + def test_identityless_reduction_forder(self): + a = np.empty((2, 3, 4), order='F') + self.check_identityless_reduction(a) + + def test_identityless_reduction_otherorder(self): + a = np.empty((2, 4, 3), order='C').swapaxes(1, 2) + self.check_identityless_reduction(a) + + def test_identityless_reduction_noncontig(self): + a = np.empty((3, 5, 4), order='C').swapaxes(1, 2) + a = a[1:, 1:, 1:] + self.check_identityless_reduction(a) + + def test_identityless_reduction_noncontig_unaligned(self): + a = np.empty((3*4*5*8 + 1,), dtype='i1') + a = a[1:].view(dtype='f8') + a.shape = (3, 4, 5) + a = a[1:, 1:, 1:] + self.check_identityless_reduction(a) + + def test_reduce_identity_depends_on_loop(self): + """ + The type of the result should always depend on the selected loop, not + necessarily the output (only relevant for object arrays). + """ + # For an object loop, the default value 0 with type int is used: + assert type(np.add.reduce([], dtype=object)) is int + out = np.array(None, dtype=object) + # When the loop is float64 but `out` is object this does not happen, + # the result is float64 cast to object (which gives Python `float`). + np.add.reduce([], out=out, dtype=np.float64) + assert type(out[()]) is float + + def test_initial_reduction(self): + # np.minimum.reduce is an identityless reduction + + # For cases like np.maximum(np.abs(...), initial=0) + # More generally, a supremum over non-negative numbers. + assert_equal(np.maximum.reduce([], initial=0), 0) + + # For cases like reduction of an empty array over the reals. + assert_equal(np.minimum.reduce([], initial=np.inf), np.inf) + assert_equal(np.maximum.reduce([], initial=-np.inf), -np.inf) + + # Random tests + assert_equal(np.minimum.reduce([5], initial=4), 4) + assert_equal(np.maximum.reduce([4], initial=5), 5) + assert_equal(np.maximum.reduce([5], initial=4), 5) + assert_equal(np.minimum.reduce([4], initial=5), 4) + + # Check initial=None raises ValueError for both types of ufunc reductions + assert_raises(ValueError, np.minimum.reduce, [], initial=None) + assert_raises(ValueError, np.add.reduce, [], initial=None) + # Also in the somewhat special object case: + with pytest.raises(ValueError): + np.add.reduce([], initial=None, dtype=object) + + # Check that np._NoValue gives default behavior. + assert_equal(np.add.reduce([], initial=np._NoValue), 0) + + # Check that initial kwarg behaves as intended for dtype=object + a = np.array([10], dtype=object) + res = np.add.reduce(a, initial=5) + assert_equal(res, 15) + + def test_empty_reduction_and_identity(self): + arr = np.zeros((0, 5)) + # OK, since the reduction itself is *not* empty, the result is + assert np.true_divide.reduce(arr, axis=1).shape == (0,) + # Not OK, the reduction itself is empty and we have no identity + with pytest.raises(ValueError): + np.true_divide.reduce(arr, axis=0) + + # Test that an empty reduction fails also if the result is empty + arr = np.zeros((0, 0, 5)) + with pytest.raises(ValueError): + np.true_divide.reduce(arr, axis=1) + + # Division reduction makes sense with `initial=1` (empty or not): + res = np.true_divide.reduce(arr, axis=1, initial=1) + assert_array_equal(res, np.ones((0, 5))) + + @pytest.mark.parametrize('axis', (0, 1, None)) + @pytest.mark.parametrize('where', (np.array([False, True, True]), + np.array([[True], [False], [True]]), + np.array([[True, False, False], + [False, True, False], + [False, True, True]]))) + def test_reduction_with_where(self, axis, where): + a = np.arange(9.).reshape(3, 3) + a_copy = a.copy() + a_check = np.zeros_like(a) + np.positive(a, out=a_check, where=where) + + res = np.add.reduce(a, axis=axis, where=where) + check = a_check.sum(axis) + assert_equal(res, check) + # Check we do not overwrite elements of a internally. + assert_array_equal(a, a_copy) + + @pytest.mark.parametrize(('axis', 'where'), + ((0, np.array([True, False, True])), + (1, [True, True, False]), + (None, True))) + @pytest.mark.parametrize('initial', (-np.inf, 5.)) + def test_reduction_with_where_and_initial(self, axis, where, initial): + a = np.arange(9.).reshape(3, 3) + a_copy = a.copy() + a_check = np.full(a.shape, -np.inf) + np.positive(a, out=a_check, where=where) + + res = np.maximum.reduce(a, axis=axis, where=where, initial=initial) + check = a_check.max(axis, initial=initial) + assert_equal(res, check) + + def test_reduction_where_initial_needed(self): + a = np.arange(9.).reshape(3, 3) + m = [False, True, False] + assert_raises(ValueError, np.maximum.reduce, a, where=m) + + def test_identityless_reduction_nonreorderable(self): + a = np.array([[8.0, 2.0, 2.0], [1.0, 0.5, 0.25]]) + + res = np.divide.reduce(a, axis=0) + assert_equal(res, [8.0, 4.0, 8.0]) + + res = np.divide.reduce(a, axis=1) + assert_equal(res, [2.0, 8.0]) + + res = np.divide.reduce(a, axis=()) + assert_equal(res, a) + + assert_raises(ValueError, np.divide.reduce, a, axis=(0, 1)) + + def test_reduce_zero_axis(self): + # If we have a n x m array and do a reduction with axis=1, then we are + # doing n reductions, and each reduction takes an m-element array. For + # a reduction operation without an identity, then: + # n > 0, m > 0: fine + # n = 0, m > 0: fine, doing 0 reductions of m-element arrays + # n > 0, m = 0: can't reduce a 0-element array, ValueError + # n = 0, m = 0: can't reduce a 0-element array, ValueError (for + # consistency with the above case) + # This test doesn't actually look at return values, it just checks to + # make sure that error we get an error in exactly those cases where we + # expect one, and assumes the calculations themselves are done + # correctly. + + def ok(f, *args, **kwargs): + f(*args, **kwargs) + + def err(f, *args, **kwargs): + assert_raises(ValueError, f, *args, **kwargs) + + def t(expect, func, n, m): + expect(func, np.zeros((n, m)), axis=1) + expect(func, np.zeros((m, n)), axis=0) + expect(func, np.zeros((n // 2, n // 2, m)), axis=2) + expect(func, np.zeros((n // 2, m, n // 2)), axis=1) + expect(func, np.zeros((n, m // 2, m // 2)), axis=(1, 2)) + expect(func, np.zeros((m // 2, n, m // 2)), axis=(0, 2)) + expect(func, np.zeros((m // 3, m // 3, m // 3, + n // 2, n // 2)), + axis=(0, 1, 2)) + # Check what happens if the inner (resp. outer) dimensions are a + # mix of zero and non-zero: + expect(func, np.zeros((10, m, n)), axis=(0, 1)) + expect(func, np.zeros((10, n, m)), axis=(0, 2)) + expect(func, np.zeros((m, 10, n)), axis=0) + expect(func, np.zeros((10, m, n)), axis=1) + expect(func, np.zeros((10, n, m)), axis=2) + + # np.maximum is just an arbitrary ufunc with no reduction identity + assert_equal(np.maximum.identity, None) + t(ok, np.maximum.reduce, 30, 30) + t(ok, np.maximum.reduce, 0, 30) + t(err, np.maximum.reduce, 30, 0) + t(err, np.maximum.reduce, 0, 0) + err(np.maximum.reduce, []) + np.maximum.reduce(np.zeros((0, 0)), axis=()) + + # all of the combinations are fine for a reduction that has an + # identity + t(ok, np.add.reduce, 30, 30) + t(ok, np.add.reduce, 0, 30) + t(ok, np.add.reduce, 30, 0) + t(ok, np.add.reduce, 0, 0) + np.add.reduce([]) + np.add.reduce(np.zeros((0, 0)), axis=()) + + # OTOH, accumulate always makes sense for any combination of n and m, + # because it maps an m-element array to an m-element array. These + # tests are simpler because accumulate doesn't accept multiple axes. + for uf in (np.maximum, np.add): + uf.accumulate(np.zeros((30, 0)), axis=0) + uf.accumulate(np.zeros((0, 30)), axis=0) + uf.accumulate(np.zeros((30, 30)), axis=0) + uf.accumulate(np.zeros((0, 0)), axis=0) + + def test_safe_casting(self): + # In old versions of numpy, in-place operations used the 'unsafe' + # casting rules. In versions >= 1.10, 'same_kind' is the + # default and an exception is raised instead of a warning. + # when 'same_kind' is not satisfied. + a = np.array([1, 2, 3], dtype=int) + # Non-in-place addition is fine + assert_array_equal(assert_no_warnings(np.add, a, 1.1), + [2.1, 3.1, 4.1]) + assert_raises(TypeError, np.add, a, 1.1, out=a) + + def add_inplace(a, b): + a += b + + assert_raises(TypeError, add_inplace, a, 1.1) + # Make sure that explicitly overriding the exception is allowed: + assert_no_warnings(np.add, a, 1.1, out=a, casting="unsafe") + assert_array_equal(a, [2, 3, 4]) + + def test_ufunc_custom_out(self): + # Test ufunc with built in input types and custom output type + + a = np.array([0, 1, 2], dtype='i8') + b = np.array([0, 1, 2], dtype='i8') + c = np.empty(3, dtype=_rational_tests.rational) + + # Output must be specified so numpy knows what + # ufunc signature to look for + result = _rational_tests.test_add(a, b, c) + target = np.array([0, 2, 4], dtype=_rational_tests.rational) + assert_equal(result, target) + + # The new resolution means that we can (usually) find custom loops + # as long as they match exactly: + result = _rational_tests.test_add(a, b) + assert_equal(result, target) + + # This works even more generally, so long the default common-dtype + # promoter works out: + result = _rational_tests.test_add(a, b.astype(np.uint16), out=c) + assert_equal(result, target) + + # This scalar path used to go into legacy promotion, but doesn't now: + result = _rational_tests.test_add(a, np.uint16(2)) + target = np.array([2, 3, 4], dtype=_rational_tests.rational) + assert_equal(result, target) + + def test_operand_flags(self): + a = np.arange(16, dtype=int).reshape(4, 4) + b = np.arange(9, dtype=int).reshape(3, 3) + opflag_tests.inplace_add(a[:-1, :-1], b) + assert_equal(a, np.array([[0, 2, 4, 3], [7, 9, 11, 7], + [14, 16, 18, 11], [12, 13, 14, 15]])) + + a = np.array(0) + opflag_tests.inplace_add(a, 3) + assert_equal(a, 3) + opflag_tests.inplace_add(a, [3, 4]) + assert_equal(a, 10) + + def test_struct_ufunc(self): + import numpy._core._struct_ufunc_tests as struct_ufunc + + a = np.array([(1, 2, 3)], dtype='u8,u8,u8') + b = np.array([(1, 2, 3)], dtype='u8,u8,u8') + + result = struct_ufunc.add_triplet(a, b) + assert_equal(result, np.array([(2, 4, 6)], dtype='u8,u8,u8')) + assert_raises(RuntimeError, struct_ufunc.register_fail) + + def test_custom_ufunc(self): + a = np.array( + [_rational_tests.rational(1, 2), + _rational_tests.rational(1, 3), + _rational_tests.rational(1, 4)], + dtype=_rational_tests.rational) + b = np.array( + [_rational_tests.rational(1, 2), + _rational_tests.rational(1, 3), + _rational_tests.rational(1, 4)], + dtype=_rational_tests.rational) + + result = _rational_tests.test_add_rationals(a, b) + expected = np.array( + [_rational_tests.rational(1), + _rational_tests.rational(2, 3), + _rational_tests.rational(1, 2)], + dtype=_rational_tests.rational) + assert_equal(result, expected) + + def test_custom_ufunc_forced_sig(self): + # gh-9351 - looking for a non-first userloop would previously hang + with assert_raises(TypeError): + np.multiply(_rational_tests.rational(1), 1, + signature=(_rational_tests.rational, int, None)) + + def test_custom_array_like(self): + + class MyThing: + __array_priority__ = 1000 + + rmul_count = 0 + getitem_count = 0 + + def __init__(self, shape): + self.shape = shape + + def __len__(self): + return self.shape[0] + + def __getitem__(self, i): + MyThing.getitem_count += 1 + if not isinstance(i, tuple): + i = (i,) + if len(i) > self.ndim: + raise IndexError("boo") + + return MyThing(self.shape[len(i):]) + + def __rmul__(self, other): + MyThing.rmul_count += 1 + return self + + np.float64(5)*MyThing((3, 3)) + assert_(MyThing.rmul_count == 1, MyThing.rmul_count) + assert_(MyThing.getitem_count <= 2, MyThing.getitem_count) + + @pytest.mark.parametrize("a", ( + np.arange(10, dtype=int), + np.arange(10, dtype=_rational_tests.rational), + )) + def test_ufunc_at_basic(self, a): + + aa = a.copy() + np.add.at(aa, [2, 5, 2], 1) + assert_equal(aa, [0, 1, 4, 3, 4, 6, 6, 7, 8, 9]) + + with pytest.raises(ValueError): + # missing second operand + np.add.at(aa, [2, 5, 3]) + + aa = a.copy() + np.negative.at(aa, [2, 5, 3]) + assert_equal(aa, [0, 1, -2, -3, 4, -5, 6, 7, 8, 9]) + + aa = a.copy() + b = np.array([100, 100, 100]) + np.add.at(aa, [2, 5, 2], b) + assert_equal(aa, [0, 1, 202, 3, 4, 105, 6, 7, 8, 9]) + + with pytest.raises(ValueError): + # extraneous second operand + np.negative.at(a, [2, 5, 3], [1, 2, 3]) + + with pytest.raises(ValueError): + # second operand cannot be converted to an array + np.add.at(a, [2, 5, 3], [[1, 2], 1]) + + # ufuncs with indexed loops for performance in ufunc.at + indexed_ufuncs = [np.add, np.subtract, np.multiply, np.floor_divide, + np.maximum, np.minimum, np.fmax, np.fmin] + + @pytest.mark.parametrize( + "typecode", np.typecodes['AllInteger'] + np.typecodes['Float']) + @pytest.mark.parametrize("ufunc", indexed_ufuncs) + def test_ufunc_at_inner_loops(self, typecode, ufunc): + if ufunc is np.divide and typecode in np.typecodes['AllInteger']: + # Avoid divide-by-zero and inf for integer divide + a = np.ones(100, dtype=typecode) + indx = np.random.randint(100, size=30, dtype=np.intp) + vals = np.arange(1, 31, dtype=typecode) + else: + a = np.ones(1000, dtype=typecode) + indx = np.random.randint(1000, size=3000, dtype=np.intp) + vals = np.arange(3000, dtype=typecode) + atag = a.copy() + # Do the calculation twice and compare the answers + with warnings.catch_warnings(record=True) as w_at: + warnings.simplefilter('always') + ufunc.at(a, indx, vals) + with warnings.catch_warnings(record=True) as w_loop: + warnings.simplefilter('always') + for i, v in zip(indx, vals): + # Make sure all the work happens inside the ufunc + # in order to duplicate error/warning handling + ufunc(atag[i], v, out=atag[i:i+1], casting="unsafe") + assert_equal(atag, a) + # If w_loop warned, make sure w_at warned as well + if len(w_loop) > 0: + # + assert len(w_at) > 0 + assert w_at[0].category == w_loop[0].category + assert str(w_at[0].message)[:10] == str(w_loop[0].message)[:10] + + @pytest.mark.parametrize("typecode", np.typecodes['Complex']) + @pytest.mark.parametrize("ufunc", [np.add, np.subtract, np.multiply]) + def test_ufunc_at_inner_loops_complex(self, typecode, ufunc): + a = np.ones(10, dtype=typecode) + indx = np.concatenate([np.ones(6, dtype=np.intp), + np.full(18, 4, dtype=np.intp)]) + value = a.dtype.type(1j) + ufunc.at(a, indx, value) + expected = np.ones_like(a) + if ufunc is np.multiply: + expected[1] = expected[4] = -1 + else: + expected[1] += 6 * (value if ufunc is np.add else -value) + expected[4] += 18 * (value if ufunc is np.add else -value) + + assert_array_equal(a, expected) + + def test_ufunc_at_ellipsis(self): + # Make sure the indexed loop check does not choke on iters + # with subspaces + arr = np.zeros(5) + np.add.at(arr, slice(None), np.ones(5)) + assert_array_equal(arr, np.ones(5)) + + def test_ufunc_at_negative(self): + arr = np.ones(5, dtype=np.int32) + indx = np.arange(5) + umt.indexed_negative.at(arr, indx) + # If it is [-1, -1, -1, -100, 0] then the regular strided loop was used + assert np.all(arr == [-1, -1, -1, -200, -1]) + + def test_ufunc_at_large(self): + # issue gh-23457 + indices = np.zeros(8195, dtype=np.int16) + b = np.zeros(8195, dtype=float) + b[0] = 10 + b[1] = 5 + b[8192:] = 100 + a = np.zeros(1, dtype=float) + np.add.at(a, indices, b) + assert a[0] == b.sum() + + def test_cast_index_fastpath(self): + arr = np.zeros(10) + values = np.ones(100000) + # index must be cast, which may be buffered in chunks: + index = np.zeros(len(values), dtype=np.uint8) + np.add.at(arr, index, values) + assert arr[0] == len(values) + + @pytest.mark.parametrize("value", [ + np.ones(1), np.ones(()), np.float64(1.), 1.]) + def test_ufunc_at_scalar_value_fastpath(self, value): + arr = np.zeros(1000) + # index must be cast, which may be buffered in chunks: + index = np.repeat(np.arange(1000), 2) + np.add.at(arr, index, value) + assert_array_equal(arr, np.full_like(arr, 2 * value)) + + def test_ufunc_at_multiD(self): + a = np.arange(9).reshape(3, 3) + b = np.array([[100, 100, 100], [200, 200, 200], [300, 300, 300]]) + np.add.at(a, (slice(None), [1, 2, 1]), b) + assert_equal(a, [[0, 201, 102], [3, 404, 205], [6, 607, 308]]) + + a = np.arange(27).reshape(3, 3, 3) + b = np.array([100, 200, 300]) + np.add.at(a, (slice(None), slice(None), [1, 2, 1]), b) + assert_equal(a, + [[[0, 401, 202], + [3, 404, 205], + [6, 407, 208]], + + [[9, 410, 211], + [12, 413, 214], + [15, 416, 217]], + + [[18, 419, 220], + [21, 422, 223], + [24, 425, 226]]]) + + a = np.arange(9).reshape(3, 3) + b = np.array([[100, 100, 100], [200, 200, 200], [300, 300, 300]]) + np.add.at(a, ([1, 2, 1], slice(None)), b) + assert_equal(a, [[0, 1, 2], [403, 404, 405], [206, 207, 208]]) + + a = np.arange(27).reshape(3, 3, 3) + b = np.array([100, 200, 300]) + np.add.at(a, (slice(None), [1, 2, 1], slice(None)), b) + assert_equal(a, + [[[0, 1, 2], + [203, 404, 605], + [106, 207, 308]], + + [[9, 10, 11], + [212, 413, 614], + [115, 216, 317]], + + [[18, 19, 20], + [221, 422, 623], + [124, 225, 326]]]) + + a = np.arange(9).reshape(3, 3) + b = np.array([100, 200, 300]) + np.add.at(a, (0, [1, 2, 1]), b) + assert_equal(a, [[0, 401, 202], [3, 4, 5], [6, 7, 8]]) + + a = np.arange(27).reshape(3, 3, 3) + b = np.array([100, 200, 300]) + np.add.at(a, ([1, 2, 1], 0, slice(None)), b) + assert_equal(a, + [[[0, 1, 2], + [3, 4, 5], + [6, 7, 8]], + + [[209, 410, 611], + [12, 13, 14], + [15, 16, 17]], + + [[118, 219, 320], + [21, 22, 23], + [24, 25, 26]]]) + + a = np.arange(27).reshape(3, 3, 3) + b = np.array([100, 200, 300]) + np.add.at(a, (slice(None), slice(None), slice(None)), b) + assert_equal(a, + [[[100, 201, 302], + [103, 204, 305], + [106, 207, 308]], + + [[109, 210, 311], + [112, 213, 314], + [115, 216, 317]], + + [[118, 219, 320], + [121, 222, 323], + [124, 225, 326]]]) + + def test_ufunc_at_0D(self): + a = np.array(0) + np.add.at(a, (), 1) + assert_equal(a, 1) + + assert_raises(IndexError, np.add.at, a, 0, 1) + assert_raises(IndexError, np.add.at, a, [], 1) + + def test_ufunc_at_dtypes(self): + # Test mixed dtypes + a = np.arange(10) + np.power.at(a, [1, 2, 3, 2], 3.5) + assert_equal(a, np.array([0, 1, 4414, 46, 4, 5, 6, 7, 8, 9])) + + def test_ufunc_at_boolean(self): + # Test boolean indexing and boolean ufuncs + a = np.arange(10) + index = a % 2 == 0 + np.equal.at(a, index, [0, 2, 4, 6, 8]) + assert_equal(a, [1, 1, 1, 3, 1, 5, 1, 7, 1, 9]) + + # Test unary operator + a = np.arange(10, dtype='u4') + np.invert.at(a, [2, 5, 2]) + assert_equal(a, [0, 1, 2, 3, 4, 5 ^ 0xffffffff, 6, 7, 8, 9]) + + def test_ufunc_at_advanced(self): + # Test empty subspace + orig = np.arange(4) + a = orig[:, None][:, 0:0] + np.add.at(a, [0, 1], 3) + assert_array_equal(orig, np.arange(4)) + + # Test with swapped byte order + index = np.array([1, 2, 1], np.dtype('i').newbyteorder()) + values = np.array([1, 2, 3, 4], np.dtype('f').newbyteorder()) + np.add.at(values, index, 3) + assert_array_equal(values, [1, 8, 6, 4]) + + # Test exception thrown + values = np.array(['a', 1], dtype=object) + assert_raises(TypeError, np.add.at, values, [0, 1], 1) + assert_array_equal(values, np.array(['a', 1], dtype=object)) + + # Test multiple output ufuncs raise error, gh-5665 + assert_raises(ValueError, np.modf.at, np.arange(10), [1]) + + # Test maximum + a = np.array([1, 2, 3]) + np.maximum.at(a, [0], 0) + assert_equal(a, np.array([1, 2, 3])) + + @pytest.mark.parametrize("dtype", + np.typecodes['AllInteger'] + np.typecodes['Float']) + @pytest.mark.parametrize("ufunc", + [np.add, np.subtract, np.divide, np.minimum, np.maximum]) + def test_at_negative_indexes(self, dtype, ufunc): + a = np.arange(0, 10).astype(dtype) + indxs = np.array([-1, 1, -1, 2]).astype(np.intp) + vals = np.array([1, 5, 2, 10], dtype=a.dtype) + + expected = a.copy() + for i, v in zip(indxs, vals): + expected[i] = ufunc(expected[i], v) + + ufunc.at(a, indxs, vals) + assert_array_equal(a, expected) + assert np.all(indxs == [-1, 1, -1, 2]) + + def test_at_not_none_signature(self): + # Test ufuncs with non-trivial signature raise a TypeError + a = np.ones((2, 2, 2)) + b = np.ones((1, 2, 2)) + assert_raises(TypeError, np.matmul.at, a, [0], b) + + a = np.array([[[1, 2], [3, 4]]]) + assert_raises(TypeError, np.linalg._umath_linalg.det.at, a, [0]) + + def test_at_no_loop_for_op(self): + # str dtype does not have a ufunc loop for np.add + arr = np.ones(10, dtype=str) + with pytest.raises(np._core._exceptions._UFuncNoLoopError): + np.add.at(arr, [0, 1], [0, 1]) + + def test_at_output_casting(self): + arr = np.array([-1]) + np.equal.at(arr, [0], [0]) + assert arr[0] == 0 + + def test_at_broadcast_failure(self): + arr = np.arange(5) + with pytest.raises(ValueError): + np.add.at(arr, [0, 1], [1, 2, 3]) + + + def test_reduce_arguments(self): + f = np.add.reduce + d = np.ones((5,2), dtype=int) + o = np.ones((2,), dtype=d.dtype) + r = o * 5 + assert_equal(f(d), r) + # a, axis=0, dtype=None, out=None, keepdims=False + assert_equal(f(d, axis=0), r) + assert_equal(f(d, 0), r) + assert_equal(f(d, 0, dtype=None), r) + assert_equal(f(d, 0, dtype='i'), r) + assert_equal(f(d, 0, 'i'), r) + assert_equal(f(d, 0, None), r) + assert_equal(f(d, 0, None, out=None), r) + assert_equal(f(d, 0, None, out=o), r) + assert_equal(f(d, 0, None, o), r) + assert_equal(f(d, 0, None, None), r) + assert_equal(f(d, 0, None, None, keepdims=False), r) + assert_equal(f(d, 0, None, None, True), r.reshape((1,) + r.shape)) + assert_equal(f(d, 0, None, None, False, 0), r) + assert_equal(f(d, 0, None, None, False, initial=0), r) + assert_equal(f(d, 0, None, None, False, 0, True), r) + assert_equal(f(d, 0, None, None, False, 0, where=True), r) + # multiple keywords + assert_equal(f(d, axis=0, dtype=None, out=None, keepdims=False), r) + assert_equal(f(d, 0, dtype=None, out=None, keepdims=False), r) + assert_equal(f(d, 0, None, out=None, keepdims=False), r) + assert_equal(f(d, 0, None, out=None, keepdims=False, initial=0, + where=True), r) + + # too little + assert_raises(TypeError, f) + # too much + assert_raises(TypeError, f, d, 0, None, None, False, 0, True, 1) + # invalid axis + assert_raises(TypeError, f, d, "invalid") + assert_raises(TypeError, f, d, axis="invalid") + assert_raises(TypeError, f, d, axis="invalid", dtype=None, + keepdims=True) + # invalid dtype + assert_raises(TypeError, f, d, 0, "invalid") + assert_raises(TypeError, f, d, dtype="invalid") + assert_raises(TypeError, f, d, dtype="invalid", out=None) + # invalid out + assert_raises(TypeError, f, d, 0, None, "invalid") + assert_raises(TypeError, f, d, out="invalid") + assert_raises(TypeError, f, d, out="invalid", dtype=None) + # keepdims boolean, no invalid value + # assert_raises(TypeError, f, d, 0, None, None, "invalid") + # assert_raises(TypeError, f, d, keepdims="invalid", axis=0, dtype=None) + # invalid mix + assert_raises(TypeError, f, d, 0, keepdims="invalid", dtype="invalid", + out=None) + + # invalid keyword + assert_raises(TypeError, f, d, axis=0, dtype=None, invalid=0) + assert_raises(TypeError, f, d, invalid=0) + assert_raises(TypeError, f, d, 0, keepdims=True, invalid="invalid", + out=None) + assert_raises(TypeError, f, d, axis=0, dtype=None, keepdims=True, + out=None, invalid=0) + assert_raises(TypeError, f, d, axis=0, dtype=None, + out=None, invalid=0) + + def test_structured_equal(self): + # https://github.com/numpy/numpy/issues/4855 + + class MyA(np.ndarray): + def __array_ufunc__(self, ufunc, method, *inputs, **kwargs): + return getattr(ufunc, method)(*(input.view(np.ndarray) + for input in inputs), **kwargs) + a = np.arange(12.).reshape(4,3) + ra = a.view(dtype=('f8,f8,f8')).squeeze() + mra = ra.view(MyA) + + target = np.array([ True, False, False, False], dtype=bool) + assert_equal(np.all(target == (mra == ra[0])), True) + + def test_scalar_equal(self): + # Scalar comparisons should always work, without deprecation warnings. + # even when the ufunc fails. + a = np.array(0.) + b = np.array('a') + assert_(a != b) + assert_(b != a) + assert_(not (a == b)) + assert_(not (b == a)) + + def test_NotImplemented_not_returned(self): + # See gh-5964 and gh-2091. Some of these functions are not operator + # related and were fixed for other reasons in the past. + binary_funcs = [ + np.power, np.add, np.subtract, np.multiply, np.divide, + np.true_divide, np.floor_divide, np.bitwise_and, np.bitwise_or, + np.bitwise_xor, np.left_shift, np.right_shift, np.fmax, + np.fmin, np.fmod, np.hypot, np.logaddexp, np.logaddexp2, + np.maximum, np.minimum, np.mod, + np.greater, np.greater_equal, np.less, np.less_equal, + np.equal, np.not_equal] + + a = np.array('1') + b = 1 + c = np.array([1., 2.]) + for f in binary_funcs: + assert_raises(TypeError, f, a, b) + assert_raises(TypeError, f, c, a) + + @pytest.mark.parametrize("ufunc", + [np.logical_and, np.logical_or]) # logical_xor object loop is bad + @pytest.mark.parametrize("signature", + [(None, None, object), (object, None, None), + (None, object, None)]) + def test_logical_ufuncs_object_signatures(self, ufunc, signature): + a = np.array([True, None, False], dtype=object) + res = ufunc(a, a, signature=signature) + assert res.dtype == object + + @pytest.mark.parametrize("ufunc", + [np.logical_and, np.logical_or, np.logical_xor]) + @pytest.mark.parametrize("signature", + [(bool, None, object), (object, None, bool), + (None, object, bool)]) + def test_logical_ufuncs_mixed_object_signatures(self, ufunc, signature): + # Most mixed signatures fail (except those with bool out, e.g. `OO->?`) + a = np.array([True, None, False]) + with pytest.raises(TypeError): + ufunc(a, a, signature=signature) + + @pytest.mark.parametrize("ufunc", + [np.logical_and, np.logical_or, np.logical_xor]) + def test_logical_ufuncs_support_anything(self, ufunc): + # The logical ufuncs support even input that can't be promoted: + a = np.array(b'1', dtype="V3") + c = np.array([1., 2.]) + assert_array_equal(ufunc(a, c), ufunc([True, True], True)) + assert ufunc.reduce(a) == True + # check that the output has no effect: + out = np.zeros(2, dtype=np.int32) + expected = ufunc([True, True], True).astype(out.dtype) + assert_array_equal(ufunc(a, c, out=out), expected) + out = np.zeros((), dtype=np.int32) + assert ufunc.reduce(a, out=out) == True + # Last check, test reduction when out and a match (the complexity here + # is that the "i,i->?" may seem right, but should not match. + a = np.array([3], dtype="i") + out = np.zeros((), dtype=a.dtype) + assert ufunc.reduce(a, out=out) == 1 + + @pytest.mark.parametrize("ufunc", + [np.logical_and, np.logical_or, np.logical_xor]) + @pytest.mark.parametrize("dtype", ["S", "U"]) + @pytest.mark.parametrize("values", [["1", "hi", "0"], ["", ""]]) + def test_logical_ufuncs_supports_string(self, ufunc, dtype, values): + # note that values are either all true or all false + arr = np.array(values, dtype=dtype) + obj_arr = np.array(values, dtype=object) + res = ufunc(arr, arr) + expected = ufunc(obj_arr, obj_arr, dtype=bool) + + assert_array_equal(res, expected) + + res = ufunc.reduce(arr) + expected = ufunc.reduce(obj_arr, dtype=bool) + assert_array_equal(res, expected) + + @pytest.mark.parametrize("ufunc", + [np.logical_and, np.logical_or, np.logical_xor]) + def test_logical_ufuncs_out_cast_check(self, ufunc): + a = np.array('1') + c = np.array([1., 2.]) + out = a.copy() + with pytest.raises(TypeError): + # It would be safe, but not equiv casting: + ufunc(a, c, out=out, casting="equiv") + + def test_reducelike_byteorder_resolution(self): + # See gh-20699, byte-order changes need some extra care in the type + # resolution to make the following succeed: + arr_be = np.arange(10, dtype=">i8") + arr_le = np.arange(10, dtype="i + if 'O' in typ or '?' in typ: + continue + inp, out = typ.split('->') + args = [np.ones((3, 3), t) for t in inp] + with warnings.catch_warnings(record=True): + warnings.filterwarnings("always") + res = ufunc(*args) + if isinstance(res, tuple): + outs = tuple(out) + assert len(res) == len(outs) + for r, t in zip(res, outs): + assert r.dtype == np.dtype(t) + else: + assert res.dtype == np.dtype(out) + +@pytest.mark.parametrize('ufunc', [getattr(np, x) for x in dir(np) + if isinstance(getattr(np, x), np.ufunc)]) +@np._no_nep50_warning() +def test_ufunc_noncontiguous(ufunc): + ''' + Check that contiguous and non-contiguous calls to ufuncs + have the same results for values in range(9) + ''' + for typ in ufunc.types: + # types is a list of strings like ii->i + if any(set('O?mM') & set(typ)): + # bool, object, datetime are too irregular for this simple test + continue + inp, out = typ.split('->') + args_c = [np.empty(6, t) for t in inp] + # non contiguous (3 step) + args_n = [np.empty(18, t)[::3] for t in inp] + # alignment != itemsize is possible. So create an array with such + # an odd step manually. + args_o = [] + for t in inp: + orig_dt = np.dtype(t) + off_dt = f"S{orig_dt.alignment}" # offset by alignment + dtype = np.dtype([("_", off_dt), ("t", orig_dt)], align=False) + args_o.append(np.empty(6, dtype=dtype)["t"]) + + for a in args_c + args_n + args_o: + a.flat = range(1,7) + + with warnings.catch_warnings(record=True): + warnings.filterwarnings("always") + res_c = ufunc(*args_c) + res_n = ufunc(*args_n) + res_o = ufunc(*args_o) + if len(out) == 1: + res_c = (res_c,) + res_n = (res_n,) + res_o = (res_o,) + for c_ar, n_ar, o_ar in zip(res_c, res_n, res_o): + dt = c_ar.dtype + if np.issubdtype(dt, np.floating): + # for floating point results allow a small fuss in comparisons + # since different algorithms (libm vs. intrinsics) can be used + # for different input strides + res_eps = np.finfo(dt).eps + tol = 2*res_eps + assert_allclose(res_c, res_n, atol=tol, rtol=tol) + assert_allclose(res_c, res_o, atol=tol, rtol=tol) + else: + assert_equal(c_ar, n_ar) + assert_equal(c_ar, o_ar) + + +@pytest.mark.parametrize('ufunc', [np.sign, np.equal]) +def test_ufunc_warn_with_nan(ufunc): + # issue gh-15127 + # test that calling certain ufuncs with a non-standard `nan` value does not + # emit a warning + # `b` holds a 64 bit signaling nan: the most significant bit of the + # significand is zero. + b = np.array([0x7ff0000000000001], 'i8').view('f8') + assert np.isnan(b) + if ufunc.nin == 1: + ufunc(b) + elif ufunc.nin == 2: + ufunc(b, b.copy()) + else: + raise ValueError('ufunc with more than 2 inputs') + + +@pytest.mark.skipif(not HAS_REFCOUNT, reason="Python lacks refcounts") +def test_ufunc_out_casterrors(): + # Tests that casting errors are correctly reported and buffers are + # cleared. + # The following array can be added to itself as an object array, but + # the result cannot be cast to an integer output: + value = 123 # relies on python cache (leak-check will still find it) + arr = np.array([value] * int(ncu.BUFSIZE * 1.5) + + ["string"] + + [value] * int(1.5 * ncu.BUFSIZE), dtype=object) + out = np.ones(len(arr), dtype=np.intp) + + count = sys.getrefcount(value) + with pytest.raises(ValueError): + # Output casting failure: + np.add(arr, arr, out=out, casting="unsafe") + + assert count == sys.getrefcount(value) + # output is unchanged after the error, this shows that the iteration + # was aborted (this is not necessarily defined behaviour) + assert out[-1] == 1 + + with pytest.raises(ValueError): + # Input casting failure: + np.add(arr, arr, out=out, dtype=np.intp, casting="unsafe") + + assert count == sys.getrefcount(value) + # output is unchanged after the error, this shows that the iteration + # was aborted (this is not necessarily defined behaviour) + assert out[-1] == 1 + + +@pytest.mark.parametrize("bad_offset", [0, int(ncu.BUFSIZE * 1.5)]) +def test_ufunc_input_casterrors(bad_offset): + value = 123 + arr = np.array([value] * bad_offset + + ["string"] + + [value] * int(1.5 * ncu.BUFSIZE), dtype=object) + with pytest.raises(ValueError): + # Force cast inputs, but the buffered cast of `arr` to intp fails: + np.add(arr, arr, dtype=np.intp, casting="unsafe") + + +@pytest.mark.skipif(IS_WASM, reason="fp errors don't work in wasm") +@pytest.mark.parametrize("bad_offset", [0, int(ncu.BUFSIZE * 1.5)]) +def test_ufunc_input_floatingpoint_error(bad_offset): + value = 123 + arr = np.array([value] * bad_offset + + [np.nan] + + [value] * int(1.5 * ncu.BUFSIZE)) + with np.errstate(invalid="raise"), pytest.raises(FloatingPointError): + # Force cast inputs, but the buffered cast of `arr` to intp fails: + np.add(arr, arr, dtype=np.intp, casting="unsafe") + + +def test_trivial_loop_invalid_cast(): + # This tests the fast-path "invalid cast", see gh-19904. + with pytest.raises(TypeError, + match="cast ufunc 'add' input 0"): + # the void dtype definitely cannot cast to double: + np.add(np.array(1, "i,i"), 3, signature="dd->d") + + +@pytest.mark.skipif(not HAS_REFCOUNT, reason="Python lacks refcounts") +@pytest.mark.parametrize("offset", + [0, ncu.BUFSIZE//2, int(1.5*ncu.BUFSIZE)]) +def test_reduce_casterrors(offset): + # Test reporting of casting errors in reductions, we test various + # offsets to where the casting error will occur, since these may occur + # at different places during the reduction procedure. For example + # the first item may be special. + value = 123 # relies on python cache (leak-check will still find it) + arr = np.array([value] * offset + + ["string"] + + [value] * int(1.5 * ncu.BUFSIZE), dtype=object) + out = np.array(-1, dtype=np.intp) + + count = sys.getrefcount(value) + with pytest.raises(ValueError, match="invalid literal"): + # This is an unsafe cast, but we currently always allow that. + # Note that the double loop is picked, but the cast fails. + # `initial=None` disables the use of an identity here to test failures + # while copying the first values path (not used when identity exists). + np.add.reduce(arr, dtype=np.intp, out=out, initial=None) + assert count == sys.getrefcount(value) + # If an error occurred during casting, the operation is done at most until + # the error occurs (the result of which would be `value * offset`) and -1 + # if the error happened immediately. + # This does not define behaviour, the output is invalid and thus undefined + assert out[()] < value * offset + + +def test_object_reduce_cleanup_on_failure(): + # Test cleanup, including of the initial value (manually provided or not) + with pytest.raises(TypeError): + np.add.reduce([1, 2, None], initial=4) + + with pytest.raises(TypeError): + np.add.reduce([1, 2, None]) + + +@pytest.mark.skipif(IS_WASM, reason="fp errors don't work in wasm") +@pytest.mark.parametrize("method", + [np.add.accumulate, np.add.reduce, + pytest.param(lambda x: np.add.reduceat(x, [0]), id="reduceat"), + pytest.param(lambda x: np.log.at(x, [2]), id="at")]) +def test_ufunc_methods_floaterrors(method): + # adding inf and -inf (or log(-inf) creates an invalid float and warns + arr = np.array([np.inf, 0, -np.inf]) + with np.errstate(all="warn"): + with pytest.warns(RuntimeWarning, match="invalid value"): + method(arr) + + arr = np.array([np.inf, 0, -np.inf]) + with np.errstate(all="raise"): + with pytest.raises(FloatingPointError): + method(arr) + + +def _check_neg_zero(value): + if value != 0.0: + return False + if not np.signbit(value.real): + return False + if value.dtype.kind == "c": + return np.signbit(value.imag) + return True + +@pytest.mark.parametrize("dtype", np.typecodes["AllFloat"]) +def test_addition_negative_zero(dtype): + dtype = np.dtype(dtype) + if dtype.kind == "c": + neg_zero = dtype.type(complex(-0.0, -0.0)) + else: + neg_zero = dtype.type(-0.0) + + arr = np.array(neg_zero) + arr2 = np.array(neg_zero) + + assert _check_neg_zero(arr + arr2) + # In-place ops may end up on a different path (reduce path) see gh-21211 + arr += arr2 + assert _check_neg_zero(arr) + + +@pytest.mark.parametrize("dtype", np.typecodes["AllFloat"]) +@pytest.mark.parametrize("use_initial", [True, False]) +def test_addition_reduce_negative_zero(dtype, use_initial): + dtype = np.dtype(dtype) + if dtype.kind == "c": + neg_zero = dtype.type(complex(-0.0, -0.0)) + else: + neg_zero = dtype.type(-0.0) + + kwargs = {} + if use_initial: + kwargs["initial"] = neg_zero + else: + pytest.xfail("-0. propagation in sum currently requires initial") + + # Test various length, in case SIMD paths or chunking play a role. + # 150 extends beyond the pairwise blocksize; probably not important. + for i in range(0, 150): + arr = np.array([neg_zero] * i, dtype=dtype) + res = np.sum(arr, **kwargs) + if i > 0 or use_initial: + assert _check_neg_zero(res) + else: + # `sum([])` should probably be 0.0 and not -0.0 like `sum([-0.0])` + assert not np.signbit(res.real) + assert not np.signbit(res.imag) + + +@pytest.mark.parametrize(["dt1", "dt2"], + [("S", "U"), ("U", "S"), ("S", "d"), ("S", "V"), ("U", "l")]) +def test_addition_string_types(dt1, dt2): + arr1 = np.array([1234234], dtype=dt1) + arr2 = np.array([b"423"], dtype=dt2) + with pytest.raises(np._core._exceptions.UFuncTypeError) as exc: + np.add(arr1, arr2) + + +@pytest.mark.parametrize("order1,order2", + [(">", ">"), ("<", "<"), (">", "<"), ("<", ">")]) +def test_addition_unicode_inverse_byte_order(order1, order2): + element = 'abcd' + arr1 = np.array([element], dtype=f"{order1}U4") + arr2 = np.array([element], dtype=f"{order2}U4") + result = arr1 + arr2 + assert result == 2*element + + +@pytest.mark.parametrize("dtype", [np.int8, np.int16, np.int32, np.int64]) +def test_find_non_long_args(dtype): + element = 'abcd' + start = dtype(0) + end = dtype(len(element)) + arr = np.array([element]) + result = np._core.umath.find(arr, "a", start, end) + assert result.dtype == np.dtype("intp") + assert result == 0 + + +def test_find_access_past_buffer(): + # This checks that no read past the string buffer occurs in + # string_fastsearch.h. The buffer class makes sure this is checked. + # To see it in action, you can remove the checks in the buffer and + # this test will produce an 'Invalid read' if run under valgrind. + arr = np.array([b'abcd', b'ebcd']) + result = np._core.umath.find(arr, b'cde', 0, np.iinfo(np.int64).max) + assert np.all(result == -1) + + +class TestLowlevelAPIAccess: + def test_resolve_dtypes_basic(self): + # Basic test for dtype resolution: + i4 = np.dtype("i4") + f4 = np.dtype("f4") + f8 = np.dtype("f8") + + r = np.add.resolve_dtypes((i4, f4, None)) + assert r == (f8, f8, f8) + + # Signature uses the same logic to parse as ufunc (less strict) + # the following is "same-kind" casting so works: + r = np.add.resolve_dtypes(( + i4, i4, None), signature=(None, None, "f4")) + assert r == (f4, f4, f4) + + # Check NEP 50 "weak" promotion also: + r = np.add.resolve_dtypes((f4, int, None)) + assert r == (f4, f4, f4) + + with pytest.raises(TypeError): + np.add.resolve_dtypes((i4, f4, None), casting="no") + + def test_resolve_dtypes_comparison(self): + i4 = np.dtype("i4") + i8 = np.dtype("i8") + b = np.dtype("?") + r = np.equal.resolve_dtypes((i4, i8, None)) + assert r == (i8, i8, b) + + def test_weird_dtypes(self): + S0 = np.dtype("S0") + # S0 is often converted by NumPy to S1, but not here: + r = np.equal.resolve_dtypes((S0, S0, None)) + assert r == (S0, S0, np.dtype(bool)) + + # Subarray dtypes are weird and may not work fully, we preserve them + # leading to a TypeError (currently no equal loop for void/structured) + dts = np.dtype("10i") + with pytest.raises(TypeError): + np.equal.resolve_dtypes((dts, dts, None)) + + def test_resolve_dtypes_reduction(self): + i2 = np.dtype("i2") + default_int_ = np.dtype(np.int_) + # Check special addition resolution: + res = np.add.resolve_dtypes((None, i2, None), reduction=True) + assert res == (default_int_, default_int_, default_int_) + + def test_resolve_dtypes_reduction_no_output(self): + i4 = np.dtype("i4") + with pytest.raises(TypeError): + # May be allowable at some point? + np.add.resolve_dtypes((i4, i4, i4), reduction=True) + + @pytest.mark.parametrize("dtypes", [ + (np.dtype("i"), np.dtype("i")), + (None, np.dtype("i"), np.dtype("f")), + (np.dtype("i"), None, np.dtype("f")), + ("i4", "i4", None)]) + def test_resolve_dtypes_errors(self, dtypes): + with pytest.raises(TypeError): + np.add.resolve_dtypes(dtypes) + + def test_resolve_dtypes_reduction_errors(self): + i2 = np.dtype("i2") + + with pytest.raises(TypeError): + np.add.resolve_dtypes((None, i2, i2)) + + with pytest.raises(TypeError): + np.add.signature((None, None, "i4")) + + @pytest.mark.skipif(not hasattr(ct, "pythonapi"), + reason="`ctypes.pythonapi` required for capsule unpacking.") + def test_loop_access(self): + # This is a basic test for the full strided loop access + data_t = ct.c_char_p * 2 + dim_t = ct.c_ssize_t * 1 + strides_t = ct.c_ssize_t * 2 + strided_loop_t = ct.CFUNCTYPE( + ct.c_int, ct.c_void_p, data_t, dim_t, strides_t, ct.c_void_p) + + class call_info_t(ct.Structure): + _fields_ = [ + ("strided_loop", strided_loop_t), + ("context", ct.c_void_p), + ("auxdata", ct.c_void_p), + ("requires_pyapi", ct.c_byte), + ("no_floatingpoint_errors", ct.c_byte), + ] + + i4 = np.dtype("i4") + dt, call_info_obj = np.negative._resolve_dtypes_and_context((i4, i4)) + assert dt == (i4, i4) # can be used without casting + + # Fill in the rest of the information: + np.negative._get_strided_loop(call_info_obj) + + ct.pythonapi.PyCapsule_GetPointer.restype = ct.c_void_p + call_info = ct.pythonapi.PyCapsule_GetPointer( + ct.py_object(call_info_obj), + ct.c_char_p(b"numpy_1.24_ufunc_call_info")) + + call_info = ct.cast(call_info, ct.POINTER(call_info_t)).contents + + arr = np.arange(10, dtype=i4) + call_info.strided_loop( + call_info.context, + data_t(arr.ctypes.data, arr.ctypes.data), + arr.ctypes.shape, # is a C-array with 10 here + strides_t(arr.ctypes.strides[0], arr.ctypes.strides[0]), + call_info.auxdata) + + # We just directly called the negative inner-loop in-place: + assert_array_equal(arr, -np.arange(10, dtype=i4)) + + @pytest.mark.parametrize("strides", [1, (1, 2, 3), (1, "2")]) + def test__get_strided_loop_errors_bad_strides(self, strides): + i4 = np.dtype("i4") + dt, call_info = np.negative._resolve_dtypes_and_context((i4, i4)) + + with pytest.raises(TypeError, match="fixed_strides.*tuple.*or None"): + np.negative._get_strided_loop(call_info, fixed_strides=strides) + + def test__get_strided_loop_errors_bad_call_info(self): + i4 = np.dtype("i4") + dt, call_info = np.negative._resolve_dtypes_and_context((i4, i4)) + + with pytest.raises(ValueError, match="PyCapsule"): + np.negative._get_strided_loop("not the capsule!") + + with pytest.raises(TypeError, match=".*incompatible context"): + np.add._get_strided_loop(call_info) + + np.negative._get_strided_loop(call_info) + with pytest.raises(TypeError): + # cannot call it a second time: + np.negative._get_strided_loop(call_info) + + def test_long_arrays(self): + t = np.zeros((1029, 917), dtype=np.single) + t[0][0] = 1 + t[28][414] = 1 + tc = np.cos(t) + assert_equal(tc[0][0], tc[28][414]) diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/test_umath.py b/venv/lib/python3.12/site-packages/numpy/_core/tests/test_umath.py new file mode 100644 index 00000000..9a300f19 --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/tests/test_umath.py @@ -0,0 +1,4870 @@ +import platform +import warnings +import fnmatch +import itertools +import pytest +import sys +import os +import operator +from fractions import Fraction +from functools import reduce +from collections import namedtuple + +import numpy._core.umath as ncu +from numpy._core import _umath_tests as ncu_tests, sctypes +import numpy as np +from numpy.testing import ( + assert_, assert_equal, assert_raises, assert_raises_regex, + assert_array_equal, assert_almost_equal, assert_array_almost_equal, + assert_array_max_ulp, assert_allclose, assert_no_warnings, suppress_warnings, + _gen_alignment_data, assert_array_almost_equal_nulp, IS_WASM, IS_MUSL, + IS_PYPY, HAS_REFCOUNT + ) +from numpy.testing._private.utils import _glibc_older_than + +UFUNCS = [obj for obj in np._core.umath.__dict__.values() + if isinstance(obj, np.ufunc)] + +UFUNCS_UNARY = [ + uf for uf in UFUNCS if uf.nin == 1 +] +UFUNCS_UNARY_FP = [ + uf for uf in UFUNCS_UNARY if 'f->f' in uf.types +] + +UFUNCS_BINARY = [ + uf for uf in UFUNCS if uf.nin == 2 +] +UFUNCS_BINARY_ACC = [ + uf for uf in UFUNCS_BINARY if hasattr(uf, "accumulate") and uf.nout == 1 +] + +def interesting_binop_operands(val1, val2, dtype): + """ + Helper to create "interesting" operands to cover common code paths: + * scalar inputs + * only first "values" is an array (e.g. scalar division fast-paths) + * Longer array (SIMD) placing the value of interest at different positions + * Oddly strided arrays which may not be SIMD compatible + + It does not attempt to cover unaligned access or mixed dtypes. + These are normally handled by the casting/buffering machinery. + + This is not a fixture (currently), since I believe a fixture normally + only yields once? + """ + fill_value = 1 # could be a parameter, but maybe not an optional one? + + arr1 = np.full(10003, dtype=dtype, fill_value=fill_value) + arr2 = np.full(10003, dtype=dtype, fill_value=fill_value) + + arr1[0] = val1 + arr2[0] = val2 + + extractor = lambda res: res + yield arr1[0], arr2[0], extractor, "scalars" + + extractor = lambda res: res + yield arr1[0, ...], arr2[0, ...], extractor, "scalar-arrays" + + # reset array values to fill_value: + arr1[0] = fill_value + arr2[0] = fill_value + + for pos in [0, 1, 2, 3, 4, 5, -1, -2, -3, -4]: + arr1[pos] = val1 + arr2[pos] = val2 + + extractor = lambda res: res[pos] + yield arr1, arr2, extractor, f"off-{pos}" + yield arr1, arr2[pos], extractor, f"off-{pos}-with-scalar" + + arr1[pos] = fill_value + arr2[pos] = fill_value + + for stride in [-1, 113]: + op1 = arr1[::stride] + op2 = arr2[::stride] + op1[10] = val1 + op2[10] = val2 + + extractor = lambda res: res[10] + yield op1, op2, extractor, f"stride-{stride}" + + op1[10] = fill_value + op2[10] = fill_value + + +def on_powerpc(): + """ True if we are running on a Power PC platform.""" + return platform.processor() == 'powerpc' or \ + platform.machine().startswith('ppc') + + +def bad_arcsinh(): + """The blocklisted trig functions are not accurate on aarch64/PPC for + complex256. Rather than dig through the actual problem skip the + test. This should be fixed when we can move past glibc2.17 + which is the version in manylinux2014 + """ + if platform.machine() == 'aarch64': + x = 1.78e-10 + elif on_powerpc(): + x = 2.16e-10 + else: + return False + v1 = np.arcsinh(np.float128(x)) + v2 = np.arcsinh(np.complex256(x)).real + # The eps for float128 is 1-e33, so this is way bigger + return abs((v1 / v2) - 1.0) > 1e-23 + + +class _FilterInvalids: + def setup_method(self): + self.olderr = np.seterr(invalid='ignore') + + def teardown_method(self): + np.seterr(**self.olderr) + + +class TestConstants: + def test_pi(self): + assert_allclose(ncu.pi, 3.141592653589793, 1e-15) + + def test_e(self): + assert_allclose(ncu.e, 2.718281828459045, 1e-15) + + def test_euler_gamma(self): + assert_allclose(ncu.euler_gamma, 0.5772156649015329, 1e-15) + + +class TestOut: + def test_out_subok(self): + for subok in (True, False): + a = np.array(0.5) + o = np.empty(()) + + r = np.add(a, 2, o, subok=subok) + assert_(r is o) + r = np.add(a, 2, out=o, subok=subok) + assert_(r is o) + r = np.add(a, 2, out=(o,), subok=subok) + assert_(r is o) + + d = np.array(5.7) + o1 = np.empty(()) + o2 = np.empty((), dtype=np.int32) + + r1, r2 = np.frexp(d, o1, None, subok=subok) + assert_(r1 is o1) + r1, r2 = np.frexp(d, None, o2, subok=subok) + assert_(r2 is o2) + r1, r2 = np.frexp(d, o1, o2, subok=subok) + assert_(r1 is o1) + assert_(r2 is o2) + + r1, r2 = np.frexp(d, out=(o1, None), subok=subok) + assert_(r1 is o1) + r1, r2 = np.frexp(d, out=(None, o2), subok=subok) + assert_(r2 is o2) + r1, r2 = np.frexp(d, out=(o1, o2), subok=subok) + assert_(r1 is o1) + assert_(r2 is o2) + + with assert_raises(TypeError): + # Out argument must be tuple, since there are multiple outputs. + r1, r2 = np.frexp(d, out=o1, subok=subok) + + assert_raises(TypeError, np.add, a, 2, o, o, subok=subok) + assert_raises(TypeError, np.add, a, 2, o, out=o, subok=subok) + assert_raises(TypeError, np.add, a, 2, None, out=o, subok=subok) + assert_raises(ValueError, np.add, a, 2, out=(o, o), subok=subok) + assert_raises(ValueError, np.add, a, 2, out=(), subok=subok) + assert_raises(TypeError, np.add, a, 2, [], subok=subok) + assert_raises(TypeError, np.add, a, 2, out=[], subok=subok) + assert_raises(TypeError, np.add, a, 2, out=([],), subok=subok) + o.flags.writeable = False + assert_raises(ValueError, np.add, a, 2, o, subok=subok) + assert_raises(ValueError, np.add, a, 2, out=o, subok=subok) + assert_raises(ValueError, np.add, a, 2, out=(o,), subok=subok) + + def test_out_wrap_subok(self): + class ArrayWrap(np.ndarray): + __array_priority__ = 10 + + def __new__(cls, arr): + return np.asarray(arr).view(cls).copy() + + def __array_wrap__(self, arr, context=None, return_scalar=False): + return arr.view(type(self)) + + for subok in (True, False): + a = ArrayWrap([0.5]) + + r = np.add(a, 2, subok=subok) + if subok: + assert_(isinstance(r, ArrayWrap)) + else: + assert_(type(r) == np.ndarray) + + r = np.add(a, 2, None, subok=subok) + if subok: + assert_(isinstance(r, ArrayWrap)) + else: + assert_(type(r) == np.ndarray) + + r = np.add(a, 2, out=None, subok=subok) + if subok: + assert_(isinstance(r, ArrayWrap)) + else: + assert_(type(r) == np.ndarray) + + r = np.add(a, 2, out=(None,), subok=subok) + if subok: + assert_(isinstance(r, ArrayWrap)) + else: + assert_(type(r) == np.ndarray) + + d = ArrayWrap([5.7]) + o1 = np.empty((1,)) + o2 = np.empty((1,), dtype=np.int32) + + r1, r2 = np.frexp(d, o1, subok=subok) + if subok: + assert_(isinstance(r2, ArrayWrap)) + else: + assert_(type(r2) == np.ndarray) + + r1, r2 = np.frexp(d, o1, None, subok=subok) + if subok: + assert_(isinstance(r2, ArrayWrap)) + else: + assert_(type(r2) == np.ndarray) + + r1, r2 = np.frexp(d, None, o2, subok=subok) + if subok: + assert_(isinstance(r1, ArrayWrap)) + else: + assert_(type(r1) == np.ndarray) + + r1, r2 = np.frexp(d, out=(o1, None), subok=subok) + if subok: + assert_(isinstance(r2, ArrayWrap)) + else: + assert_(type(r2) == np.ndarray) + + r1, r2 = np.frexp(d, out=(None, o2), subok=subok) + if subok: + assert_(isinstance(r1, ArrayWrap)) + else: + assert_(type(r1) == np.ndarray) + + with assert_raises(TypeError): + # Out argument must be tuple, since there are multiple outputs. + r1, r2 = np.frexp(d, out=o1, subok=subok) + + @pytest.mark.skipif(not HAS_REFCOUNT, reason="Python lacks refcounts") + def test_out_wrap_no_leak(self): + # Regression test for gh-26545 + class ArrSubclass(np.ndarray): + pass + + arr = np.arange(10).view(ArrSubclass) + + arr *= 1 + assert sys.getrefcount(arr) == 2 + + +class TestComparisons: + import operator + + @pytest.mark.parametrize('dtype', sctypes['uint'] + sctypes['int'] + + sctypes['float'] + [np.bool]) + @pytest.mark.parametrize('py_comp,np_comp', [ + (operator.lt, np.less), + (operator.le, np.less_equal), + (operator.gt, np.greater), + (operator.ge, np.greater_equal), + (operator.eq, np.equal), + (operator.ne, np.not_equal) + ]) + def test_comparison_functions(self, dtype, py_comp, np_comp): + # Initialize input arrays + if dtype == np.bool: + a = np.random.choice(a=[False, True], size=1000) + b = np.random.choice(a=[False, True], size=1000) + scalar = True + else: + a = np.random.randint(low=1, high=10, size=1000).astype(dtype) + b = np.random.randint(low=1, high=10, size=1000).astype(dtype) + scalar = 5 + np_scalar = np.dtype(dtype).type(scalar) + a_lst = a.tolist() + b_lst = b.tolist() + + # (Binary) Comparison (x1=array, x2=array) + comp_b = np_comp(a, b).view(np.uint8) + comp_b_list = [int(py_comp(x, y)) for x, y in zip(a_lst, b_lst)] + + # (Scalar1) Comparison (x1=scalar, x2=array) + comp_s1 = np_comp(np_scalar, b).view(np.uint8) + comp_s1_list = [int(py_comp(scalar, x)) for x in b_lst] + + # (Scalar2) Comparison (x1=array, x2=scalar) + comp_s2 = np_comp(a, np_scalar).view(np.uint8) + comp_s2_list = [int(py_comp(x, scalar)) for x in a_lst] + + # Sequence: Binary, Scalar1 and Scalar2 + assert_(comp_b.tolist() == comp_b_list, + f"Failed comparison ({py_comp.__name__})") + assert_(comp_s1.tolist() == comp_s1_list, + f"Failed comparison ({py_comp.__name__})") + assert_(comp_s2.tolist() == comp_s2_list, + f"Failed comparison ({py_comp.__name__})") + + def test_ignore_object_identity_in_equal(self): + # Check comparing identical objects whose comparison + # is not a simple boolean, e.g., arrays that are compared elementwise. + a = np.array([np.array([1, 2, 3]), None], dtype=object) + assert_raises(ValueError, np.equal, a, a) + + # Check error raised when comparing identical non-comparable objects. + class FunkyType: + def __eq__(self, other): + raise TypeError("I won't compare") + + a = np.array([FunkyType()]) + assert_raises(TypeError, np.equal, a, a) + + # Check identity doesn't override comparison mismatch. + a = np.array([np.nan], dtype=object) + assert_equal(np.equal(a, a), [False]) + + def test_ignore_object_identity_in_not_equal(self): + # Check comparing identical objects whose comparison + # is not a simple boolean, e.g., arrays that are compared elementwise. + a = np.array([np.array([1, 2, 3]), None], dtype=object) + assert_raises(ValueError, np.not_equal, a, a) + + # Check error raised when comparing identical non-comparable objects. + class FunkyType: + def __ne__(self, other): + raise TypeError("I won't compare") + + a = np.array([FunkyType()]) + assert_raises(TypeError, np.not_equal, a, a) + + # Check identity doesn't override comparison mismatch. + a = np.array([np.nan], dtype=object) + assert_equal(np.not_equal(a, a), [True]) + + def test_error_in_equal_reduce(self): + # gh-20929 + # make sure np.equal.reduce raises a TypeError if an array is passed + # without specifying the dtype + a = np.array([0, 0]) + assert_equal(np.equal.reduce(a, dtype=bool), True) + assert_raises(TypeError, np.equal.reduce, a) + + def test_object_dtype(self): + assert np.equal(1, [1], dtype=object).dtype == object + assert np.equal(1, [1], signature=(None, None, "O")).dtype == object + + def test_object_nonbool_dtype_error(self): + # bool output dtype is fine of course: + assert np.equal(1, [1], dtype=bool).dtype == bool + + # but the following are examples do not have a loop: + with pytest.raises(TypeError, match="No loop matching"): + np.equal(1, 1, dtype=np.int64) + + with pytest.raises(TypeError, match="No loop matching"): + np.equal(1, 1, sig=(None, None, "l")) + + @pytest.mark.parametrize("dtypes", ["qQ", "Qq"]) + @pytest.mark.parametrize('py_comp, np_comp', [ + (operator.lt, np.less), + (operator.le, np.less_equal), + (operator.gt, np.greater), + (operator.ge, np.greater_equal), + (operator.eq, np.equal), + (operator.ne, np.not_equal) + ]) + @pytest.mark.parametrize("vals", [(2**60, 2**60+1), (2**60+1, 2**60)]) + def test_large_integer_direct_comparison( + self, dtypes, py_comp, np_comp, vals): + # Note that float(2**60) + 1 == float(2**60). + a1 = np.array([2**60], dtype=dtypes[0]) + a2 = np.array([2**60 + 1], dtype=dtypes[1]) + expected = py_comp(2**60, 2**60+1) + + assert py_comp(a1, a2) == expected + assert np_comp(a1, a2) == expected + # Also check the scalars: + s1 = a1[0] + s2 = a2[0] + assert isinstance(s1, np.integer) + assert isinstance(s2, np.integer) + # The Python operator here is mainly interesting: + assert py_comp(s1, s2) == expected + assert np_comp(s1, s2) == expected + + @pytest.mark.parametrize("dtype", np.typecodes['UnsignedInteger']) + @pytest.mark.parametrize('py_comp_func, np_comp_func', [ + (operator.lt, np.less), + (operator.le, np.less_equal), + (operator.gt, np.greater), + (operator.ge, np.greater_equal), + (operator.eq, np.equal), + (operator.ne, np.not_equal) + ]) + @pytest.mark.parametrize("flip", [True, False]) + def test_unsigned_signed_direct_comparison( + self, dtype, py_comp_func, np_comp_func, flip): + if flip: + py_comp = lambda x, y: py_comp_func(y, x) + np_comp = lambda x, y: np_comp_func(y, x) + else: + py_comp = py_comp_func + np_comp = np_comp_func + + arr = np.array([np.iinfo(dtype).max], dtype=dtype) + expected = py_comp(int(arr[0]), -1) + + assert py_comp(arr, -1) == expected + assert np_comp(arr, -1) == expected + + scalar = arr[0] + assert isinstance(scalar, np.integer) + # The Python operator here is mainly interesting: + assert py_comp(scalar, -1) == expected + assert np_comp(scalar, -1) == expected + + +class TestAdd: + def test_reduce_alignment(self): + # gh-9876 + # make sure arrays with weird strides work with the optimizations in + # pairwise_sum_@TYPE@. On x86, the 'b' field will count as aligned at a + # 4 byte offset, even though its itemsize is 8. + a = np.zeros(2, dtype=[('a', np.int32), ('b', np.float64)]) + a['a'] = -1 + assert_equal(a['b'].sum(), 0) + + +class TestDivision: + def test_division_int(self): + # int division should follow Python + x = np.array([5, 10, 90, 100, -5, -10, -90, -100, -120]) + if 5 / 10 == 0.5: + assert_equal(x / 100, [0.05, 0.1, 0.9, 1, + -0.05, -0.1, -0.9, -1, -1.2]) + else: + assert_equal(x / 100, [0, 0, 0, 1, -1, -1, -1, -1, -2]) + assert_equal(x // 100, [0, 0, 0, 1, -1, -1, -1, -1, -2]) + assert_equal(x % 100, [5, 10, 90, 0, 95, 90, 10, 0, 80]) + + @pytest.mark.skipif(IS_WASM, reason="fp errors don't work in wasm") + @pytest.mark.parametrize("dtype,ex_val", itertools.product( + sctypes['int'] + sctypes['uint'], ( + ( + # dividend + "np.array(range(fo.max-lsize, fo.max)).astype(dtype)," + # divisors + "np.arange(lsize).astype(dtype)," + # scalar divisors + "range(15)" + ), + ( + # dividend + "np.arange(fo.min, fo.min+lsize).astype(dtype)," + # divisors + "np.arange(lsize//-2, lsize//2).astype(dtype)," + # scalar divisors + "range(fo.min, fo.min + 15)" + ), ( + # dividend + "np.array(range(fo.max-lsize, fo.max)).astype(dtype)," + # divisors + "np.arange(lsize).astype(dtype)," + # scalar divisors + "[1,3,9,13,neg, fo.min+1, fo.min//2, fo.max//3, fo.max//4]" + ) + ) + )) + def test_division_int_boundary(self, dtype, ex_val): + fo = np.iinfo(dtype) + neg = -1 if fo.min < 0 else 1 + # Large enough to test SIMD loops and remainder elements + lsize = 512 + 7 + a, b, divisors = eval(ex_val) + a_lst, b_lst = a.tolist(), b.tolist() + + c_div = lambda n, d: ( + 0 if d == 0 else ( + fo.min if (n and n == fo.min and d == -1) else n//d + ) + ) + with np.errstate(divide='ignore'): + ac = a.copy() + ac //= b + div_ab = a // b + div_lst = [c_div(x, y) for x, y in zip(a_lst, b_lst)] + + msg = "Integer arrays floor division check (//)" + assert all(div_ab == div_lst), msg + msg_eq = "Integer arrays floor division check (//=)" + assert all(ac == div_lst), msg_eq + + for divisor in divisors: + ac = a.copy() + with np.errstate(divide='ignore', over='ignore'): + div_a = a // divisor + ac //= divisor + div_lst = [c_div(i, divisor) for i in a_lst] + + assert all(div_a == div_lst), msg + assert all(ac == div_lst), msg_eq + + with np.errstate(divide='raise', over='raise'): + if 0 in b: + # Verify overflow case + with pytest.raises(FloatingPointError, + match="divide by zero encountered in floor_divide"): + a // b + else: + a // b + if fo.min and fo.min in a: + with pytest.raises(FloatingPointError, + match='overflow encountered in floor_divide'): + a // -1 + elif fo.min: + a // -1 + with pytest.raises(FloatingPointError, + match="divide by zero encountered in floor_divide"): + a // 0 + with pytest.raises(FloatingPointError, + match="divide by zero encountered in floor_divide"): + ac = a.copy() + ac //= 0 + + np.array([], dtype=dtype) // 0 + + @pytest.mark.skipif(IS_WASM, reason="fp errors don't work in wasm") + @pytest.mark.parametrize("dtype,ex_val", itertools.product( + sctypes['int'] + sctypes['uint'], ( + "np.array([fo.max, 1, 2, 1, 1, 2, 3], dtype=dtype)", + "np.array([fo.min, 1, -2, 1, 1, 2, -3]).astype(dtype)", + "np.arange(fo.min, fo.min+(100*10), 10, dtype=dtype)", + "np.array(range(fo.max-(100*7), fo.max, 7)).astype(dtype)", + ) + )) + def test_division_int_reduce(self, dtype, ex_val): + fo = np.iinfo(dtype) + a = eval(ex_val) + lst = a.tolist() + c_div = lambda n, d: ( + 0 if d == 0 or (n and n == fo.min and d == -1) else n//d + ) + + with np.errstate(divide='ignore'): + div_a = np.floor_divide.reduce(a) + div_lst = reduce(c_div, lst) + msg = "Reduce floor integer division check" + assert div_a == div_lst, msg + + with np.errstate(divide='raise', over='raise'): + with pytest.raises(FloatingPointError, + match="divide by zero encountered in reduce"): + np.floor_divide.reduce(np.arange(-100, 100).astype(dtype)) + if fo.min: + with pytest.raises(FloatingPointError, + match='overflow encountered in reduce'): + np.floor_divide.reduce( + np.array([fo.min, 1, -1], dtype=dtype) + ) + + @pytest.mark.parametrize( + "dividend,divisor,quotient", + [(np.timedelta64(2,'Y'), np.timedelta64(2,'M'), 12), + (np.timedelta64(2,'Y'), np.timedelta64(-2,'M'), -12), + (np.timedelta64(-2,'Y'), np.timedelta64(2,'M'), -12), + (np.timedelta64(-2,'Y'), np.timedelta64(-2,'M'), 12), + (np.timedelta64(2,'M'), np.timedelta64(-2,'Y'), -1), + (np.timedelta64(2,'Y'), np.timedelta64(0,'M'), 0), + (np.timedelta64(2,'Y'), 2, np.timedelta64(1,'Y')), + (np.timedelta64(2,'Y'), -2, np.timedelta64(-1,'Y')), + (np.timedelta64(-2,'Y'), 2, np.timedelta64(-1,'Y')), + (np.timedelta64(-2,'Y'), -2, np.timedelta64(1,'Y')), + (np.timedelta64(-2,'Y'), -2, np.timedelta64(1,'Y')), + (np.timedelta64(-2,'Y'), -3, np.timedelta64(0,'Y')), + (np.timedelta64(-2,'Y'), 0, np.timedelta64('Nat','Y')), + ]) + def test_division_int_timedelta(self, dividend, divisor, quotient): + # If either divisor is 0 or quotient is Nat, check for division by 0 + if divisor and (isinstance(quotient, int) or not np.isnat(quotient)): + msg = "Timedelta floor division check" + assert dividend // divisor == quotient, msg + + # Test for arrays as well + msg = "Timedelta arrays floor division check" + dividend_array = np.array([dividend]*5) + quotient_array = np.array([quotient]*5) + assert all(dividend_array // divisor == quotient_array), msg + else: + if IS_WASM: + pytest.skip("fp errors don't work in wasm") + with np.errstate(divide='raise', invalid='raise'): + with pytest.raises(FloatingPointError): + dividend // divisor + + def test_division_complex(self): + # check that implementation is correct + msg = "Complex division implementation check" + x = np.array([1. + 1.*1j, 1. + .5*1j, 1. + 2.*1j], dtype=np.complex128) + assert_almost_equal(x**2/x, x, err_msg=msg) + # check overflow, underflow + msg = "Complex division overflow/underflow check" + x = np.array([1.e+110, 1.e-110], dtype=np.complex128) + y = x**2/x + assert_almost_equal(y/x, [1, 1], err_msg=msg) + + def test_zero_division_complex(self): + with np.errstate(invalid="ignore", divide="ignore"): + x = np.array([0.0], dtype=np.complex128) + y = 1.0/x + assert_(np.isinf(y)[0]) + y = complex(np.inf, np.nan)/x + assert_(np.isinf(y)[0]) + y = complex(np.nan, np.inf)/x + assert_(np.isinf(y)[0]) + y = complex(np.inf, np.inf)/x + assert_(np.isinf(y)[0]) + y = 0.0/x + assert_(np.isnan(y)[0]) + + def test_floor_division_complex(self): + # check that floor division, divmod and remainder raises type errors + x = np.array([.9 + 1j, -.1 + 1j, .9 + .5*1j, .9 + 2.*1j], dtype=np.complex128) + with pytest.raises(TypeError): + x // 7 + with pytest.raises(TypeError): + np.divmod(x, 7) + with pytest.raises(TypeError): + np.remainder(x, 7) + + def test_floor_division_signed_zero(self): + # Check that the sign bit is correctly set when dividing positive and + # negative zero by one. + x = np.zeros(10) + assert_equal(np.signbit(x//1), 0) + assert_equal(np.signbit((-x)//1), 1) + + @pytest.mark.skipif(hasattr(np.__config__, "blas_ssl2_info"), + reason="gh-22982") + @pytest.mark.skipif(IS_WASM, reason="fp errors don't work in wasm") + @pytest.mark.parametrize('dtype', np.typecodes['Float']) + def test_floor_division_errors(self, dtype): + fnan = np.array(np.nan, dtype=dtype) + fone = np.array(1.0, dtype=dtype) + fzer = np.array(0.0, dtype=dtype) + finf = np.array(np.inf, dtype=dtype) + # divide by zero error check + with np.errstate(divide='raise', invalid='ignore'): + assert_raises(FloatingPointError, np.floor_divide, fone, fzer) + with np.errstate(divide='ignore', invalid='raise'): + np.floor_divide(fone, fzer) + + # The following already contain a NaN and should not warn + with np.errstate(all='raise'): + np.floor_divide(fnan, fone) + np.floor_divide(fone, fnan) + np.floor_divide(fnan, fzer) + np.floor_divide(fzer, fnan) + + @pytest.mark.parametrize('dtype', np.typecodes['Float']) + def test_floor_division_corner_cases(self, dtype): + # test corner cases like 1.0//0.0 for errors and return vals + x = np.zeros(10, dtype=dtype) + y = np.ones(10, dtype=dtype) + fnan = np.array(np.nan, dtype=dtype) + fone = np.array(1.0, dtype=dtype) + fzer = np.array(0.0, dtype=dtype) + finf = np.array(np.inf, dtype=dtype) + with suppress_warnings() as sup: + sup.filter(RuntimeWarning, "invalid value encountered in floor_divide") + div = np.floor_divide(fnan, fone) + assert(np.isnan(div)), "dt: %s, div: %s" % (dt, div) + div = np.floor_divide(fone, fnan) + assert(np.isnan(div)), "dt: %s, div: %s" % (dt, div) + div = np.floor_divide(fnan, fzer) + assert(np.isnan(div)), "dt: %s, div: %s" % (dt, div) + # verify 1.0//0.0 computations return inf + with np.errstate(divide='ignore'): + z = np.floor_divide(y, x) + assert_(np.isinf(z).all()) + +def floor_divide_and_remainder(x, y): + return (np.floor_divide(x, y), np.remainder(x, y)) + + +def _signs(dt): + if dt in np.typecodes['UnsignedInteger']: + return (+1,) + else: + return (+1, -1) + + +class TestRemainder: + + def test_remainder_basic(self): + dt = np.typecodes['AllInteger'] + np.typecodes['Float'] + for op in [floor_divide_and_remainder, np.divmod]: + for dt1, dt2 in itertools.product(dt, dt): + for sg1, sg2 in itertools.product(_signs(dt1), _signs(dt2)): + fmt = 'op: %s, dt1: %s, dt2: %s, sg1: %s, sg2: %s' + msg = fmt % (op.__name__, dt1, dt2, sg1, sg2) + a = np.array(sg1*71, dtype=dt1) + b = np.array(sg2*19, dtype=dt2) + div, rem = op(a, b) + assert_equal(div*b + rem, a, err_msg=msg) + if sg2 == -1: + assert_(b < rem <= 0, msg) + else: + assert_(b > rem >= 0, msg) + + def test_float_remainder_exact(self): + # test that float results are exact for small integers. This also + # holds for the same integers scaled by powers of two. + nlst = list(range(-127, 0)) + plst = list(range(1, 128)) + dividend = nlst + [0] + plst + divisor = nlst + plst + arg = list(itertools.product(dividend, divisor)) + tgt = list(divmod(*t) for t in arg) + + a, b = np.array(arg, dtype=int).T + # convert exact integer results from Python to float so that + # signed zero can be used, it is checked. + tgtdiv, tgtrem = np.array(tgt, dtype=float).T + tgtdiv = np.where((tgtdiv == 0.0) & ((b < 0) ^ (a < 0)), -0.0, tgtdiv) + tgtrem = np.where((tgtrem == 0.0) & (b < 0), -0.0, tgtrem) + + for op in [floor_divide_and_remainder, np.divmod]: + for dt in np.typecodes['Float']: + msg = 'op: %s, dtype: %s' % (op.__name__, dt) + fa = a.astype(dt) + fb = b.astype(dt) + div, rem = op(fa, fb) + assert_equal(div, tgtdiv, err_msg=msg) + assert_equal(rem, tgtrem, err_msg=msg) + + def test_float_remainder_roundoff(self): + # gh-6127 + dt = np.typecodes['Float'] + for op in [floor_divide_and_remainder, np.divmod]: + for dt1, dt2 in itertools.product(dt, dt): + for sg1, sg2 in itertools.product((+1, -1), (+1, -1)): + fmt = 'op: %s, dt1: %s, dt2: %s, sg1: %s, sg2: %s' + msg = fmt % (op.__name__, dt1, dt2, sg1, sg2) + a = np.array(sg1*78*6e-8, dtype=dt1) + b = np.array(sg2*6e-8, dtype=dt2) + div, rem = op(a, b) + # Equal assertion should hold when fmod is used + assert_equal(div*b + rem, a, err_msg=msg) + if sg2 == -1: + assert_(b < rem <= 0, msg) + else: + assert_(b > rem >= 0, msg) + + @pytest.mark.skipif(IS_WASM, reason="fp errors don't work in wasm") + @pytest.mark.xfail(sys.platform.startswith("darwin"), + reason="MacOS seems to not give the correct 'invalid' warning for " + "`fmod`. Hopefully, others always do.") + @pytest.mark.parametrize('dtype', np.typecodes['Float']) + def test_float_divmod_errors(self, dtype): + # Check valid errors raised for divmod and remainder + fzero = np.array(0.0, dtype=dtype) + fone = np.array(1.0, dtype=dtype) + finf = np.array(np.inf, dtype=dtype) + fnan = np.array(np.nan, dtype=dtype) + # since divmod is combination of both remainder and divide + # ops it will set both dividebyzero and invalid flags + with np.errstate(divide='raise', invalid='ignore'): + assert_raises(FloatingPointError, np.divmod, fone, fzero) + with np.errstate(divide='ignore', invalid='raise'): + assert_raises(FloatingPointError, np.divmod, fone, fzero) + with np.errstate(invalid='raise'): + assert_raises(FloatingPointError, np.divmod, fzero, fzero) + with np.errstate(invalid='raise'): + assert_raises(FloatingPointError, np.divmod, finf, finf) + with np.errstate(divide='ignore', invalid='raise'): + assert_raises(FloatingPointError, np.divmod, finf, fzero) + with np.errstate(divide='raise', invalid='ignore'): + # inf / 0 does not set any flags, only the modulo creates a NaN + np.divmod(finf, fzero) + + @pytest.mark.skipif(hasattr(np.__config__, "blas_ssl2_info"), + reason="gh-22982") + @pytest.mark.skipif(IS_WASM, reason="fp errors don't work in wasm") + @pytest.mark.xfail(sys.platform.startswith("darwin"), + reason="MacOS seems to not give the correct 'invalid' warning for " + "`fmod`. Hopefully, others always do.") + @pytest.mark.parametrize('dtype', np.typecodes['Float']) + @pytest.mark.parametrize('fn', [np.fmod, np.remainder]) + def test_float_remainder_errors(self, dtype, fn): + fzero = np.array(0.0, dtype=dtype) + fone = np.array(1.0, dtype=dtype) + finf = np.array(np.inf, dtype=dtype) + fnan = np.array(np.nan, dtype=dtype) + + # The following already contain a NaN and should not warn. + with np.errstate(all='raise'): + with pytest.raises(FloatingPointError, + match="invalid value"): + fn(fone, fzero) + fn(fnan, fzero) + fn(fzero, fnan) + fn(fone, fnan) + fn(fnan, fone) + + @pytest.mark.skipif(IS_WASM, reason="fp errors don't work in wasm") + def test_float_remainder_overflow(self): + a = np.finfo(np.float64).tiny + with np.errstate(over='ignore', invalid='ignore'): + div, mod = np.divmod(4, a) + np.isinf(div) + assert_(mod == 0) + with np.errstate(over='raise', invalid='ignore'): + assert_raises(FloatingPointError, np.divmod, 4, a) + with np.errstate(invalid='raise', over='ignore'): + assert_raises(FloatingPointError, np.divmod, 4, a) + + def test_float_divmod_corner_cases(self): + # check nan cases + for dt in np.typecodes['Float']: + fnan = np.array(np.nan, dtype=dt) + fone = np.array(1.0, dtype=dt) + fzer = np.array(0.0, dtype=dt) + finf = np.array(np.inf, dtype=dt) + with suppress_warnings() as sup: + sup.filter(RuntimeWarning, "invalid value encountered in divmod") + sup.filter(RuntimeWarning, "divide by zero encountered in divmod") + div, rem = np.divmod(fone, fzer) + assert(np.isinf(div)), 'dt: %s, div: %s' % (dt, rem) + assert(np.isnan(rem)), 'dt: %s, rem: %s' % (dt, rem) + div, rem = np.divmod(fzer, fzer) + assert(np.isnan(rem)), 'dt: %s, rem: %s' % (dt, rem) + assert_(np.isnan(div)), 'dt: %s, rem: %s' % (dt, rem) + div, rem = np.divmod(finf, finf) + assert(np.isnan(div)), 'dt: %s, rem: %s' % (dt, rem) + assert(np.isnan(rem)), 'dt: %s, rem: %s' % (dt, rem) + div, rem = np.divmod(finf, fzer) + assert(np.isinf(div)), 'dt: %s, rem: %s' % (dt, rem) + assert(np.isnan(rem)), 'dt: %s, rem: %s' % (dt, rem) + div, rem = np.divmod(fnan, fone) + assert(np.isnan(rem)), "dt: %s, rem: %s" % (dt, rem) + assert(np.isnan(div)), "dt: %s, rem: %s" % (dt, rem) + div, rem = np.divmod(fone, fnan) + assert(np.isnan(rem)), "dt: %s, rem: %s" % (dt, rem) + assert(np.isnan(div)), "dt: %s, rem: %s" % (dt, rem) + div, rem = np.divmod(fnan, fzer) + assert(np.isnan(rem)), "dt: %s, rem: %s" % (dt, rem) + assert(np.isnan(div)), "dt: %s, rem: %s" % (dt, rem) + + def test_float_remainder_corner_cases(self): + # Check remainder magnitude. + for dt in np.typecodes['Float']: + fone = np.array(1.0, dtype=dt) + fzer = np.array(0.0, dtype=dt) + fnan = np.array(np.nan, dtype=dt) + b = np.array(1.0, dtype=dt) + a = np.nextafter(np.array(0.0, dtype=dt), -b) + rem = np.remainder(a, b) + assert_(rem <= b, 'dt: %s' % dt) + rem = np.remainder(-a, -b) + assert_(rem >= -b, 'dt: %s' % dt) + + # Check nans, inf + with suppress_warnings() as sup: + sup.filter(RuntimeWarning, "invalid value encountered in remainder") + sup.filter(RuntimeWarning, "invalid value encountered in fmod") + for dt in np.typecodes['Float']: + fone = np.array(1.0, dtype=dt) + fzer = np.array(0.0, dtype=dt) + finf = np.array(np.inf, dtype=dt) + fnan = np.array(np.nan, dtype=dt) + rem = np.remainder(fone, fzer) + assert_(np.isnan(rem), 'dt: %s, rem: %s' % (dt, rem)) + # MSVC 2008 returns NaN here, so disable the check. + #rem = np.remainder(fone, finf) + #assert_(rem == fone, 'dt: %s, rem: %s' % (dt, rem)) + rem = np.remainder(finf, fone) + fmod = np.fmod(finf, fone) + assert_(np.isnan(fmod), 'dt: %s, fmod: %s' % (dt, fmod)) + assert_(np.isnan(rem), 'dt: %s, rem: %s' % (dt, rem)) + rem = np.remainder(finf, finf) + fmod = np.fmod(finf, fone) + assert_(np.isnan(rem), 'dt: %s, rem: %s' % (dt, rem)) + assert_(np.isnan(fmod), 'dt: %s, fmod: %s' % (dt, fmod)) + rem = np.remainder(finf, fzer) + fmod = np.fmod(finf, fzer) + assert_(np.isnan(rem), 'dt: %s, rem: %s' % (dt, rem)) + assert_(np.isnan(fmod), 'dt: %s, fmod: %s' % (dt, fmod)) + rem = np.remainder(fone, fnan) + fmod = np.fmod(fone, fnan) + assert_(np.isnan(rem), 'dt: %s, rem: %s' % (dt, rem)) + assert_(np.isnan(fmod), 'dt: %s, fmod: %s' % (dt, fmod)) + rem = np.remainder(fnan, fzer) + fmod = np.fmod(fnan, fzer) + assert_(np.isnan(rem), 'dt: %s, rem: %s' % (dt, rem)) + assert_(np.isnan(fmod), 'dt: %s, fmod: %s' % (dt, rem)) + rem = np.remainder(fnan, fone) + fmod = np.fmod(fnan, fone) + assert_(np.isnan(rem), 'dt: %s, rem: %s' % (dt, rem)) + assert_(np.isnan(fmod), 'dt: %s, fmod: %s' % (dt, rem)) + + +class TestDivisionIntegerOverflowsAndDivideByZero: + result_type = namedtuple('result_type', + ['nocast', 'casted']) + helper_lambdas = { + 'zero': lambda dtype: 0, + 'min': lambda dtype: np.iinfo(dtype).min, + 'neg_min': lambda dtype: -np.iinfo(dtype).min, + 'min-zero': lambda dtype: (np.iinfo(dtype).min, 0), + 'neg_min-zero': lambda dtype: (-np.iinfo(dtype).min, 0), + } + overflow_results = { + np.remainder: result_type( + helper_lambdas['zero'], helper_lambdas['zero']), + np.fmod: result_type( + helper_lambdas['zero'], helper_lambdas['zero']), + operator.mod: result_type( + helper_lambdas['zero'], helper_lambdas['zero']), + operator.floordiv: result_type( + helper_lambdas['min'], helper_lambdas['neg_min']), + np.floor_divide: result_type( + helper_lambdas['min'], helper_lambdas['neg_min']), + np.divmod: result_type( + helper_lambdas['min-zero'], helper_lambdas['neg_min-zero']) + } + + @pytest.mark.skipif(IS_WASM, reason="fp errors don't work in wasm") + @pytest.mark.parametrize("dtype", np.typecodes["Integer"]) + def test_signed_division_overflow(self, dtype): + to_check = interesting_binop_operands(np.iinfo(dtype).min, -1, dtype) + for op1, op2, extractor, operand_identifier in to_check: + with pytest.warns(RuntimeWarning, match="overflow encountered"): + res = op1 // op2 + + assert res.dtype == op1.dtype + assert extractor(res) == np.iinfo(op1.dtype).min + + # Remainder is well defined though, and does not warn: + res = op1 % op2 + assert res.dtype == op1.dtype + assert extractor(res) == 0 + # Check fmod as well: + res = np.fmod(op1, op2) + assert extractor(res) == 0 + + # Divmod warns for the division part: + with pytest.warns(RuntimeWarning, match="overflow encountered"): + res1, res2 = np.divmod(op1, op2) + + assert res1.dtype == res2.dtype == op1.dtype + assert extractor(res1) == np.iinfo(op1.dtype).min + assert extractor(res2) == 0 + + @pytest.mark.skipif(IS_WASM, reason="fp errors don't work in wasm") + @pytest.mark.parametrize("dtype", np.typecodes["AllInteger"]) + def test_divide_by_zero(self, dtype): + # Note that the return value cannot be well defined here, but NumPy + # currently uses 0 consistently. This could be changed. + to_check = interesting_binop_operands(1, 0, dtype) + for op1, op2, extractor, operand_identifier in to_check: + with pytest.warns(RuntimeWarning, match="divide by zero"): + res = op1 // op2 + + assert res.dtype == op1.dtype + assert extractor(res) == 0 + + with pytest.warns(RuntimeWarning, match="divide by zero"): + res1, res2 = np.divmod(op1, op2) + + assert res1.dtype == res2.dtype == op1.dtype + assert extractor(res1) == 0 + assert extractor(res2) == 0 + + @pytest.mark.skipif(IS_WASM, reason="fp errors don't work in wasm") + @pytest.mark.parametrize("dividend_dtype", sctypes['int']) + @pytest.mark.parametrize("divisor_dtype", sctypes['int']) + @pytest.mark.parametrize("operation", + [np.remainder, np.fmod, np.divmod, np.floor_divide, + operator.mod, operator.floordiv]) + @np.errstate(divide='warn', over='warn') + def test_overflows(self, dividend_dtype, divisor_dtype, operation): + # SIMD tries to perform the operation on as many elements as possible + # that is a multiple of the register's size. We resort to the + # default implementation for the leftover elements. + # We try to cover all paths here. + arrays = [np.array([np.iinfo(dividend_dtype).min]*i, + dtype=dividend_dtype) for i in range(1, 129)] + divisor = np.array([-1], dtype=divisor_dtype) + # If dividend is a larger type than the divisor (`else` case), + # then, result will be a larger type than dividend and will not + # result in an overflow for `divmod` and `floor_divide`. + if np.dtype(dividend_dtype).itemsize >= np.dtype( + divisor_dtype).itemsize and operation in ( + np.divmod, np.floor_divide, operator.floordiv): + with pytest.warns( + RuntimeWarning, + match="overflow encountered in"): + result = operation( + dividend_dtype(np.iinfo(dividend_dtype).min), + divisor_dtype(-1) + ) + assert result == self.overflow_results[operation].nocast( + dividend_dtype) + + # Arrays + for a in arrays: + # In case of divmod, we need to flatten the result + # column first as we get a column vector of quotient and + # remainder and a normal flatten of the expected result. + with pytest.warns( + RuntimeWarning, + match="overflow encountered in"): + result = np.array(operation(a, divisor)).flatten('f') + expected_array = np.array( + [self.overflow_results[operation].nocast( + dividend_dtype)]*len(a)).flatten() + assert_array_equal(result, expected_array) + else: + # Scalars + result = operation( + dividend_dtype(np.iinfo(dividend_dtype).min), + divisor_dtype(-1) + ) + assert result == self.overflow_results[operation].casted( + dividend_dtype) + + # Arrays + for a in arrays: + # See above comment on flatten + result = np.array(operation(a, divisor)).flatten('f') + expected_array = np.array( + [self.overflow_results[operation].casted( + dividend_dtype)]*len(a)).flatten() + assert_array_equal(result, expected_array) + + +class TestCbrt: + def test_cbrt_scalar(self): + assert_almost_equal((np.cbrt(np.float32(-2.5)**3)), -2.5) + + def test_cbrt(self): + x = np.array([1., 2., -3., np.inf, -np.inf]) + assert_almost_equal(np.cbrt(x**3), x) + + assert_(np.isnan(np.cbrt(np.nan))) + assert_equal(np.cbrt(np.inf), np.inf) + assert_equal(np.cbrt(-np.inf), -np.inf) + + +class TestPower: + def test_power_float(self): + x = np.array([1., 2., 3.]) + assert_equal(x**0, [1., 1., 1.]) + assert_equal(x**1, x) + assert_equal(x**2, [1., 4., 9.]) + y = x.copy() + y **= 2 + assert_equal(y, [1., 4., 9.]) + assert_almost_equal(x**(-1), [1., 0.5, 1./3]) + assert_almost_equal(x**(0.5), [1., ncu.sqrt(2), ncu.sqrt(3)]) + + for out, inp, msg in _gen_alignment_data(dtype=np.float32, + type='unary', + max_size=11): + exp = [ncu.sqrt(i) for i in inp] + assert_almost_equal(inp**(0.5), exp, err_msg=msg) + np.sqrt(inp, out=out) + assert_equal(out, exp, err_msg=msg) + + for out, inp, msg in _gen_alignment_data(dtype=np.float64, + type='unary', + max_size=7): + exp = [ncu.sqrt(i) for i in inp] + assert_almost_equal(inp**(0.5), exp, err_msg=msg) + np.sqrt(inp, out=out) + assert_equal(out, exp, err_msg=msg) + + def test_power_complex(self): + x = np.array([1+2j, 2+3j, 3+4j]) + assert_equal(x**0, [1., 1., 1.]) + assert_equal(x**1, x) + assert_almost_equal(x**2, [-3+4j, -5+12j, -7+24j]) + assert_almost_equal(x**3, [(1+2j)**3, (2+3j)**3, (3+4j)**3]) + assert_almost_equal(x**4, [(1+2j)**4, (2+3j)**4, (3+4j)**4]) + assert_almost_equal(x**(-1), [1/(1+2j), 1/(2+3j), 1/(3+4j)]) + assert_almost_equal(x**(-2), [1/(1+2j)**2, 1/(2+3j)**2, 1/(3+4j)**2]) + assert_almost_equal(x**(-3), [(-11+2j)/125, (-46-9j)/2197, + (-117-44j)/15625]) + assert_almost_equal(x**(0.5), [ncu.sqrt(1+2j), ncu.sqrt(2+3j), + ncu.sqrt(3+4j)]) + norm = 1./((x**14)[0]) + assert_almost_equal(x**14 * norm, + [i * norm for i in [-76443+16124j, 23161315+58317492j, + 5583548873 + 2465133864j]]) + + # Ticket #836 + def assert_complex_equal(x, y): + assert_array_equal(x.real, y.real) + assert_array_equal(x.imag, y.imag) + + for z in [complex(0, np.inf), complex(1, np.inf)]: + z = np.array([z], dtype=np.complex128) + with np.errstate(invalid="ignore"): + assert_complex_equal(z**1, z) + assert_complex_equal(z**2, z*z) + assert_complex_equal(z**3, z*z*z) + + def test_power_zero(self): + # ticket #1271 + zero = np.array([0j]) + one = np.array([1+0j]) + cnan = np.array([complex(np.nan, np.nan)]) + # FIXME cinf not tested. + #cinf = np.array([complex(np.inf, 0)]) + + def assert_complex_equal(x, y): + x, y = np.asarray(x), np.asarray(y) + assert_array_equal(x.real, y.real) + assert_array_equal(x.imag, y.imag) + + # positive powers + for p in [0.33, 0.5, 1, 1.5, 2, 3, 4, 5, 6.6]: + assert_complex_equal(np.power(zero, p), zero) + + # zero power + assert_complex_equal(np.power(zero, 0), one) + with np.errstate(invalid="ignore"): + assert_complex_equal(np.power(zero, 0+1j), cnan) + + # negative power + for p in [0.33, 0.5, 1, 1.5, 2, 3, 4, 5, 6.6]: + assert_complex_equal(np.power(zero, -p), cnan) + assert_complex_equal(np.power(zero, -1+0.2j), cnan) + + @pytest.mark.skipif(IS_WASM, reason="fp errors don't work in wasm") + def test_zero_power_nonzero(self): + # Testing 0^{Non-zero} issue 18378 + zero = np.array([0.0+0.0j]) + cnan = np.array([complex(np.nan, np.nan)]) + + def assert_complex_equal(x, y): + assert_array_equal(x.real, y.real) + assert_array_equal(x.imag, y.imag) + + #Complex powers with positive real part will not generate a warning + assert_complex_equal(np.power(zero, 1+4j), zero) + assert_complex_equal(np.power(zero, 2-3j), zero) + #Testing zero values when real part is greater than zero + assert_complex_equal(np.power(zero, 1+1j), zero) + assert_complex_equal(np.power(zero, 1+0j), zero) + assert_complex_equal(np.power(zero, 1-1j), zero) + #Complex powers will negative real part or 0 (provided imaginary + # part is not zero) will generate a NAN and hence a RUNTIME warning + with pytest.warns(expected_warning=RuntimeWarning) as r: + assert_complex_equal(np.power(zero, -1+1j), cnan) + assert_complex_equal(np.power(zero, -2-3j), cnan) + assert_complex_equal(np.power(zero, -7+0j), cnan) + assert_complex_equal(np.power(zero, 0+1j), cnan) + assert_complex_equal(np.power(zero, 0-1j), cnan) + assert len(r) == 5 + + def test_fast_power(self): + x = np.array([1, 2, 3], np.int16) + res = x**2.0 + assert_((x**2.00001).dtype is res.dtype) + assert_array_equal(res, [1, 4, 9]) + # check the inplace operation on the casted copy doesn't mess with x + assert_(not np.may_share_memory(res, x)) + assert_array_equal(x, [1, 2, 3]) + + # Check that the fast path ignores 1-element not 0-d arrays + res = x ** np.array([[[2]]]) + assert_equal(res.shape, (1, 1, 3)) + + def test_integer_power(self): + a = np.array([15, 15], 'i8') + b = np.power(a, a) + assert_equal(b, [437893890380859375, 437893890380859375]) + + def test_integer_power_with_integer_zero_exponent(self): + dtypes = np.typecodes['Integer'] + for dt in dtypes: + arr = np.arange(-10, 10, dtype=dt) + assert_equal(np.power(arr, 0), np.ones_like(arr)) + + dtypes = np.typecodes['UnsignedInteger'] + for dt in dtypes: + arr = np.arange(10, dtype=dt) + assert_equal(np.power(arr, 0), np.ones_like(arr)) + + def test_integer_power_of_1(self): + dtypes = np.typecodes['AllInteger'] + for dt in dtypes: + arr = np.arange(10, dtype=dt) + assert_equal(np.power(1, arr), np.ones_like(arr)) + + def test_integer_power_of_zero(self): + dtypes = np.typecodes['AllInteger'] + for dt in dtypes: + arr = np.arange(1, 10, dtype=dt) + assert_equal(np.power(0, arr), np.zeros_like(arr)) + + def test_integer_to_negative_power(self): + dtypes = np.typecodes['Integer'] + for dt in dtypes: + a = np.array([0, 1, 2, 3], dtype=dt) + b = np.array([0, 1, 2, -3], dtype=dt) + one = np.array(1, dtype=dt) + minusone = np.array(-1, dtype=dt) + assert_raises(ValueError, np.power, a, b) + assert_raises(ValueError, np.power, a, minusone) + assert_raises(ValueError, np.power, one, b) + assert_raises(ValueError, np.power, one, minusone) + + def test_float_to_inf_power(self): + for dt in [np.float32, np.float64]: + a = np.array([1, 1, 2, 2, -2, -2, np.inf, -np.inf], dt) + b = np.array([np.inf, -np.inf, np.inf, -np.inf, + np.inf, -np.inf, np.inf, -np.inf], dt) + r = np.array([1, 1, np.inf, 0, np.inf, 0, np.inf, 0], dt) + assert_equal(np.power(a, b), r) + + def test_power_fast_paths(self): + # gh-26055 + for dt in [np.float32, np.float64]: + a = np.array([0, 1.1, 2, 12e12, -10., np.inf, -np.inf], dt) + expected = np.array([0.0, 1.21, 4., 1.44e+26, 100, np.inf, np.inf]) + result = np.power(a, 2.) + assert_array_max_ulp(result, expected.astype(dt), maxulp=1) + + a = np.array([0, 1.1, 2, 12e12], dt) + expected = np.sqrt(a).astype(dt) + result = np.power(a, 0.5) + assert_array_max_ulp(result, expected, maxulp=1) + + +class TestFloat_power: + def test_type_conversion(self): + arg_type = '?bhilBHILefdgFDG' + res_type = 'ddddddddddddgDDG' + for dtin, dtout in zip(arg_type, res_type): + msg = "dtin: %s, dtout: %s" % (dtin, dtout) + arg = np.ones(1, dtype=dtin) + res = np.float_power(arg, arg) + assert_(res.dtype.name == np.dtype(dtout).name, msg) + + +class TestLog2: + @pytest.mark.parametrize('dt', ['f', 'd', 'g']) + def test_log2_values(self, dt): + x = [1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024] + y = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10] + xf = np.array(x, dtype=dt) + yf = np.array(y, dtype=dt) + assert_almost_equal(np.log2(xf), yf) + + @pytest.mark.parametrize("i", range(1, 65)) + def test_log2_ints(self, i): + # a good log2 implementation should provide this, + # might fail on OS with bad libm + v = np.log2(2.**i) + assert_equal(v, float(i), err_msg='at exponent %d' % i) + + @pytest.mark.skipif(IS_WASM, reason="fp errors don't work in wasm") + def test_log2_special(self): + assert_equal(np.log2(1.), 0.) + assert_equal(np.log2(np.inf), np.inf) + assert_(np.isnan(np.log2(np.nan))) + + with warnings.catch_warnings(record=True) as w: + warnings.filterwarnings('always', '', RuntimeWarning) + assert_(np.isnan(np.log2(-1.))) + assert_(np.isnan(np.log2(-np.inf))) + assert_equal(np.log2(0.), -np.inf) + assert_(w[0].category is RuntimeWarning) + assert_(w[1].category is RuntimeWarning) + assert_(w[2].category is RuntimeWarning) + + +class TestExp2: + def test_exp2_values(self): + x = [1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024] + y = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10] + for dt in ['f', 'd', 'g']: + xf = np.array(x, dtype=dt) + yf = np.array(y, dtype=dt) + assert_almost_equal(np.exp2(yf), xf) + + +class TestLogAddExp2(_FilterInvalids): + # Need test for intermediate precisions + def test_logaddexp2_values(self): + x = [1, 2, 3, 4, 5] + y = [5, 4, 3, 2, 1] + z = [6, 6, 6, 6, 6] + for dt, dec_ in zip(['f', 'd', 'g'], [6, 15, 15]): + xf = np.log2(np.array(x, dtype=dt)) + yf = np.log2(np.array(y, dtype=dt)) + zf = np.log2(np.array(z, dtype=dt)) + assert_almost_equal(np.logaddexp2(xf, yf), zf, decimal=dec_) + + def test_logaddexp2_range(self): + x = [1000000, -1000000, 1000200, -1000200] + y = [1000200, -1000200, 1000000, -1000000] + z = [1000200, -1000000, 1000200, -1000000] + for dt in ['f', 'd', 'g']: + logxf = np.array(x, dtype=dt) + logyf = np.array(y, dtype=dt) + logzf = np.array(z, dtype=dt) + assert_almost_equal(np.logaddexp2(logxf, logyf), logzf) + + def test_inf(self): + inf = np.inf + x = [inf, -inf, inf, -inf, inf, 1, -inf, 1] + y = [inf, inf, -inf, -inf, 1, inf, 1, -inf] + z = [inf, inf, inf, -inf, inf, inf, 1, 1] + with np.errstate(invalid='raise'): + for dt in ['f', 'd', 'g']: + logxf = np.array(x, dtype=dt) + logyf = np.array(y, dtype=dt) + logzf = np.array(z, dtype=dt) + assert_equal(np.logaddexp2(logxf, logyf), logzf) + + def test_nan(self): + assert_(np.isnan(np.logaddexp2(np.nan, np.inf))) + assert_(np.isnan(np.logaddexp2(np.inf, np.nan))) + assert_(np.isnan(np.logaddexp2(np.nan, 0))) + assert_(np.isnan(np.logaddexp2(0, np.nan))) + assert_(np.isnan(np.logaddexp2(np.nan, np.nan))) + + def test_reduce(self): + assert_equal(np.logaddexp2.identity, -np.inf) + assert_equal(np.logaddexp2.reduce([]), -np.inf) + assert_equal(np.logaddexp2.reduce([-np.inf]), -np.inf) + assert_equal(np.logaddexp2.reduce([-np.inf, 0]), 0) + + +class TestLog: + def test_log_values(self): + x = [1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024] + y = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10] + for dt in ['f', 'd', 'g']: + log2_ = 0.69314718055994530943 + xf = np.array(x, dtype=dt) + yf = np.array(y, dtype=dt)*log2_ + assert_almost_equal(np.log(xf), yf) + + # test aliasing(issue #17761) + x = np.array([2, 0.937500, 3, 0.947500, 1.054697]) + xf = np.log(x) + assert_almost_equal(np.log(x, out=x), xf) + + def test_log_values_maxofdtype(self): + # test log() of max for dtype does not raise + dtypes = [np.float32, np.float64] + # This is failing at least on linux aarch64 (see gh-25460), and on most + # other non x86-64 platforms checking `longdouble` isn't too useful as + # it's an alias for float64. + if platform.machine() == 'x86_64': + dtypes += [np.longdouble] + + for dt in dtypes: + with np.errstate(all='raise'): + x = np.finfo(dt).max + np.log(x) + + def test_log_strides(self): + np.random.seed(42) + strides = np.array([-4,-3,-2,-1,1,2,3,4]) + sizes = np.arange(2,100) + for ii in sizes: + x_f64 = np.float64(np.random.uniform(low=0.01, high=100.0,size=ii)) + x_special = x_f64.copy() + x_special[3:-1:4] = 1.0 + y_true = np.log(x_f64) + y_special = np.log(x_special) + for jj in strides: + assert_array_almost_equal_nulp(np.log(x_f64[::jj]), y_true[::jj], nulp=2) + assert_array_almost_equal_nulp(np.log(x_special[::jj]), y_special[::jj], nulp=2) + + # Reference values were computed with mpmath, with mp.dps = 200. + @pytest.mark.parametrize( + 'z, wref', + [(1 + 1e-12j, 5e-25 + 1e-12j), + (1.000000000000001 + 3e-08j, + 1.5602230246251546e-15 + 2.999999999999996e-08j), + (0.9999995000000417 + 0.0009999998333333417j, + 7.831475869017683e-18 + 0.001j), + (0.9999999999999996 + 2.999999999999999e-08j, + 5.9107901499372034e-18 + 3e-08j), + (0.99995000042 - 0.009999833j, + -7.015159763822903e-15 - 0.009999999665816696j)], + ) + def test_log_precision_float64(self, z, wref): + w = np.log(z) + assert_allclose(w, wref, rtol=1e-15) + + # Reference values were computed with mpmath, with mp.dps = 200. + @pytest.mark.parametrize( + 'z, wref', + [(np.complex64(1.0 + 3e-6j), np.complex64(4.5e-12+3e-06j)), + (np.complex64(1.0 - 2e-5j), np.complex64(1.9999999e-10 - 2e-5j)), + (np.complex64(0.9999999 + 1e-06j), + np.complex64(-1.192088e-07+1.0000001e-06j))], + ) + def test_log_precision_float32(self, z, wref): + w = np.log(z) + assert_allclose(w, wref, rtol=1e-6) + + +class TestExp: + def test_exp_values(self): + x = [1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024] + y = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10] + for dt in ['f', 'd', 'g']: + log2_ = 0.69314718055994530943 + xf = np.array(x, dtype=dt) + yf = np.array(y, dtype=dt)*log2_ + assert_almost_equal(np.exp(yf), xf) + + def test_exp_strides(self): + np.random.seed(42) + strides = np.array([-4,-3,-2,-1,1,2,3,4]) + sizes = np.arange(2,100) + for ii in sizes: + x_f64 = np.float64(np.random.uniform(low=0.01, high=709.1,size=ii)) + y_true = np.exp(x_f64) + for jj in strides: + assert_array_almost_equal_nulp(np.exp(x_f64[::jj]), y_true[::jj], nulp=2) + +class TestSpecialFloats: + def test_exp_values(self): + with np.errstate(under='raise', over='raise'): + x = [np.nan, np.nan, np.inf, 0.] + y = [np.nan, -np.nan, np.inf, -np.inf] + for dt in ['e', 'f', 'd', 'g']: + xf = np.array(x, dtype=dt) + yf = np.array(y, dtype=dt) + assert_equal(np.exp(yf), xf) + + # See: https://github.com/numpy/numpy/issues/19192 + @pytest.mark.xfail( + _glibc_older_than("2.17"), + reason="Older glibc versions may not raise appropriate FP exceptions" + ) + def test_exp_exceptions(self): + with np.errstate(over='raise'): + assert_raises(FloatingPointError, np.exp, np.float16(11.0899)) + assert_raises(FloatingPointError, np.exp, np.float32(100.)) + assert_raises(FloatingPointError, np.exp, np.float32(1E19)) + assert_raises(FloatingPointError, np.exp, np.float64(800.)) + assert_raises(FloatingPointError, np.exp, np.float64(1E19)) + + with np.errstate(under='raise'): + assert_raises(FloatingPointError, np.exp, np.float16(-17.5)) + assert_raises(FloatingPointError, np.exp, np.float32(-1000.)) + assert_raises(FloatingPointError, np.exp, np.float32(-1E19)) + assert_raises(FloatingPointError, np.exp, np.float64(-1000.)) + assert_raises(FloatingPointError, np.exp, np.float64(-1E19)) + + @pytest.mark.skipif(IS_WASM, reason="fp errors don't work in wasm") + def test_log_values(self): + with np.errstate(all='ignore'): + x = [np.nan, np.nan, np.inf, np.nan, -np.inf, np.nan] + y = [np.nan, -np.nan, np.inf, -np.inf, 0.0, -1.0] + y1p = [np.nan, -np.nan, np.inf, -np.inf, -1.0, -2.0] + for dt in ['e', 'f', 'd', 'g']: + xf = np.array(x, dtype=dt) + yf = np.array(y, dtype=dt) + yf1p = np.array(y1p, dtype=dt) + assert_equal(np.log(yf), xf) + assert_equal(np.log2(yf), xf) + assert_equal(np.log10(yf), xf) + assert_equal(np.log1p(yf1p), xf) + + with np.errstate(divide='raise'): + for dt in ['e', 'f', 'd']: + assert_raises(FloatingPointError, np.log, + np.array(0.0, dtype=dt)) + assert_raises(FloatingPointError, np.log2, + np.array(0.0, dtype=dt)) + assert_raises(FloatingPointError, np.log10, + np.array(0.0, dtype=dt)) + assert_raises(FloatingPointError, np.log1p, + np.array(-1.0, dtype=dt)) + + with np.errstate(invalid='raise'): + for dt in ['e', 'f', 'd']: + assert_raises(FloatingPointError, np.log, + np.array(-np.inf, dtype=dt)) + assert_raises(FloatingPointError, np.log, + np.array(-1.0, dtype=dt)) + assert_raises(FloatingPointError, np.log2, + np.array(-np.inf, dtype=dt)) + assert_raises(FloatingPointError, np.log2, + np.array(-1.0, dtype=dt)) + assert_raises(FloatingPointError, np.log10, + np.array(-np.inf, dtype=dt)) + assert_raises(FloatingPointError, np.log10, + np.array(-1.0, dtype=dt)) + assert_raises(FloatingPointError, np.log1p, + np.array(-np.inf, dtype=dt)) + assert_raises(FloatingPointError, np.log1p, + np.array(-2.0, dtype=dt)) + + # See https://github.com/numpy/numpy/issues/18005 + with assert_no_warnings(): + a = np.array(1e9, dtype='float32') + np.log(a) + + @pytest.mark.skipif(IS_WASM, reason="fp errors don't work in wasm") + @pytest.mark.parametrize('dtype', ['e', 'f', 'd', 'g']) + def test_sincos_values(self, dtype): + with np.errstate(all='ignore'): + x = [np.nan, np.nan, np.nan, np.nan] + y = [np.nan, -np.nan, np.inf, -np.inf] + xf = np.array(x, dtype=dtype) + yf = np.array(y, dtype=dtype) + assert_equal(np.sin(yf), xf) + assert_equal(np.cos(yf), xf) + + @pytest.mark.skipif(IS_WASM, reason="fp errors don't work in wasm") + @pytest.mark.xfail( + sys.platform.startswith("darwin"), + reason="underflow is triggered for scalar 'sin'" + ) + def test_sincos_underflow(self): + with np.errstate(under='raise'): + underflow_trigger = np.array( + float.fromhex("0x1.f37f47a03f82ap-511"), + dtype=np.float64 + ) + np.sin(underflow_trigger) + np.cos(underflow_trigger) + + @pytest.mark.skipif(IS_WASM, reason="fp errors don't work in wasm") + @pytest.mark.parametrize('callable', [np.sin, np.cos]) + @pytest.mark.parametrize('dtype', ['e', 'f', 'd']) + @pytest.mark.parametrize('value', [np.inf, -np.inf]) + def test_sincos_errors(self, callable, dtype, value): + with np.errstate(invalid='raise'): + assert_raises(FloatingPointError, callable, + np.array([value], dtype=dtype)) + + @pytest.mark.parametrize('callable', [np.sin, np.cos]) + @pytest.mark.parametrize('dtype', ['f', 'd']) + @pytest.mark.parametrize('stride', [-1, 1, 2, 4, 5]) + def test_sincos_overlaps(self, callable, dtype, stride): + N = 100 + M = N // abs(stride) + rng = np.random.default_rng(42) + x = rng.standard_normal(N, dtype) + y = callable(x[::stride]) + callable(x[::stride], out=x[:M]) + assert_equal(x[:M], y) + + @pytest.mark.parametrize('dt', ['e', 'f', 'd', 'g']) + def test_sqrt_values(self, dt): + with np.errstate(all='ignore'): + x = [np.nan, np.nan, np.inf, np.nan, 0.] + y = [np.nan, -np.nan, np.inf, -np.inf, 0.] + xf = np.array(x, dtype=dt) + yf = np.array(y, dtype=dt) + assert_equal(np.sqrt(yf), xf) + + # with np.errstate(invalid='raise'): + # assert_raises( + # FloatingPointError, np.sqrt, np.array(-100., dtype=dt) + # ) + + def test_abs_values(self): + x = [np.nan, np.nan, np.inf, np.inf, 0., 0., 1.0, 1.0] + y = [np.nan, -np.nan, np.inf, -np.inf, 0., -0., -1.0, 1.0] + for dt in ['e', 'f', 'd', 'g']: + xf = np.array(x, dtype=dt) + yf = np.array(y, dtype=dt) + assert_equal(np.abs(yf), xf) + + @pytest.mark.skipif(IS_WASM, reason="fp errors don't work in wasm") + def test_square_values(self): + x = [np.nan, np.nan, np.inf, np.inf] + y = [np.nan, -np.nan, np.inf, -np.inf] + with np.errstate(all='ignore'): + for dt in ['e', 'f', 'd', 'g']: + xf = np.array(x, dtype=dt) + yf = np.array(y, dtype=dt) + assert_equal(np.square(yf), xf) + + with np.errstate(over='raise'): + assert_raises(FloatingPointError, np.square, + np.array(1E3, dtype='e')) + assert_raises(FloatingPointError, np.square, + np.array(1E32, dtype='f')) + assert_raises(FloatingPointError, np.square, + np.array(1E200, dtype='d')) + + @pytest.mark.skipif(IS_WASM, reason="fp errors don't work in wasm") + def test_reciprocal_values(self): + with np.errstate(all='ignore'): + x = [np.nan, np.nan, 0.0, -0.0, np.inf, -np.inf] + y = [np.nan, -np.nan, np.inf, -np.inf, 0., -0.] + for dt in ['e', 'f', 'd', 'g']: + xf = np.array(x, dtype=dt) + yf = np.array(y, dtype=dt) + assert_equal(np.reciprocal(yf), xf) + + with np.errstate(divide='raise'): + for dt in ['e', 'f', 'd', 'g']: + assert_raises(FloatingPointError, np.reciprocal, + np.array(-0.0, dtype=dt)) + + @pytest.mark.skipif(IS_WASM, reason="fp errors don't work in wasm") + def test_tan(self): + with np.errstate(all='ignore'): + in_ = [np.nan, -np.nan, 0.0, -0.0, np.inf, -np.inf] + out = [np.nan, np.nan, 0.0, -0.0, np.nan, np.nan] + for dt in ['e', 'f', 'd']: + in_arr = np.array(in_, dtype=dt) + out_arr = np.array(out, dtype=dt) + assert_equal(np.tan(in_arr), out_arr) + + with np.errstate(invalid='raise'): + for dt in ['e', 'f', 'd']: + assert_raises(FloatingPointError, np.tan, + np.array(np.inf, dtype=dt)) + assert_raises(FloatingPointError, np.tan, + np.array(-np.inf, dtype=dt)) + + @pytest.mark.skipif(IS_WASM, reason="fp errors don't work in wasm") + def test_arcsincos(self): + with np.errstate(all='ignore'): + in_ = [np.nan, -np.nan, np.inf, -np.inf] + out = [np.nan, np.nan, np.nan, np.nan] + for dt in ['e', 'f', 'd']: + in_arr = np.array(in_, dtype=dt) + out_arr = np.array(out, dtype=dt) + assert_equal(np.arcsin(in_arr), out_arr) + assert_equal(np.arccos(in_arr), out_arr) + + for callable in [np.arcsin, np.arccos]: + for value in [np.inf, -np.inf, 2.0, -2.0]: + for dt in ['e', 'f', 'd']: + with np.errstate(invalid='raise'): + assert_raises(FloatingPointError, callable, + np.array(value, dtype=dt)) + + def test_arctan(self): + with np.errstate(all='ignore'): + in_ = [np.nan, -np.nan] + out = [np.nan, np.nan] + for dt in ['e', 'f', 'd']: + in_arr = np.array(in_, dtype=dt) + out_arr = np.array(out, dtype=dt) + assert_equal(np.arctan(in_arr), out_arr) + + @pytest.mark.skipif(IS_WASM, reason="fp errors don't work in wasm") + def test_sinh(self): + in_ = [np.nan, -np.nan, np.inf, -np.inf] + out = [np.nan, np.nan, np.inf, -np.inf] + for dt in ['e', 'f', 'd']: + in_arr = np.array(in_, dtype=dt) + out_arr = np.array(out, dtype=dt) + assert_equal(np.sinh(in_arr), out_arr) + + with np.errstate(over='raise'): + assert_raises(FloatingPointError, np.sinh, + np.array(12.0, dtype='e')) + assert_raises(FloatingPointError, np.sinh, + np.array(120.0, dtype='f')) + assert_raises(FloatingPointError, np.sinh, + np.array(1200.0, dtype='d')) + + @pytest.mark.skipif(IS_WASM, reason="fp errors don't work in wasm") + @pytest.mark.skipif('bsd' in sys.platform, + reason="fallback implementation may not raise, see gh-2487") + def test_cosh(self): + in_ = [np.nan, -np.nan, np.inf, -np.inf] + out = [np.nan, np.nan, np.inf, np.inf] + for dt in ['e', 'f', 'd']: + in_arr = np.array(in_, dtype=dt) + out_arr = np.array(out, dtype=dt) + assert_equal(np.cosh(in_arr), out_arr) + + with np.errstate(over='raise'): + assert_raises(FloatingPointError, np.cosh, + np.array(12.0, dtype='e')) + assert_raises(FloatingPointError, np.cosh, + np.array(120.0, dtype='f')) + assert_raises(FloatingPointError, np.cosh, + np.array(1200.0, dtype='d')) + + def test_tanh(self): + in_ = [np.nan, -np.nan, np.inf, -np.inf] + out = [np.nan, np.nan, 1.0, -1.0] + for dt in ['e', 'f', 'd']: + in_arr = np.array(in_, dtype=dt) + out_arr = np.array(out, dtype=dt) + assert_array_max_ulp(np.tanh(in_arr), out_arr, 3) + + def test_arcsinh(self): + in_ = [np.nan, -np.nan, np.inf, -np.inf] + out = [np.nan, np.nan, np.inf, -np.inf] + for dt in ['e', 'f', 'd']: + in_arr = np.array(in_, dtype=dt) + out_arr = np.array(out, dtype=dt) + assert_equal(np.arcsinh(in_arr), out_arr) + + @pytest.mark.skipif(IS_WASM, reason="fp errors don't work in wasm") + def test_arccosh(self): + with np.errstate(all='ignore'): + in_ = [np.nan, -np.nan, np.inf, -np.inf, 1.0, 0.0] + out = [np.nan, np.nan, np.inf, np.nan, 0.0, np.nan] + for dt in ['e', 'f', 'd']: + in_arr = np.array(in_, dtype=dt) + out_arr = np.array(out, dtype=dt) + assert_equal(np.arccosh(in_arr), out_arr) + + for value in [0.0, -np.inf]: + with np.errstate(invalid='raise'): + for dt in ['e', 'f', 'd']: + assert_raises(FloatingPointError, np.arccosh, + np.array(value, dtype=dt)) + + @pytest.mark.skipif(IS_WASM, reason="fp errors don't work in wasm") + def test_arctanh(self): + with np.errstate(all='ignore'): + in_ = [np.nan, -np.nan, np.inf, -np.inf, 1.0, -1.0, 2.0] + out = [np.nan, np.nan, np.nan, np.nan, np.inf, -np.inf, np.nan] + for dt in ['e', 'f', 'd']: + in_arr = np.array(in_, dtype=dt) + out_arr = np.array(out, dtype=dt) + assert_equal(np.arctanh(in_arr), out_arr) + + for value in [1.01, np.inf, -np.inf, 1.0, -1.0]: + with np.errstate(invalid='raise', divide='raise'): + for dt in ['e', 'f', 'd']: + assert_raises(FloatingPointError, np.arctanh, + np.array(value, dtype=dt)) + + # Make sure glibc < 2.18 atanh is not used, issue 25087 + assert np.signbit(np.arctanh(-1j).real) + + # See: https://github.com/numpy/numpy/issues/20448 + @pytest.mark.xfail( + _glibc_older_than("2.17"), + reason="Older glibc versions may not raise appropriate FP exceptions" + ) + def test_exp2(self): + with np.errstate(all='ignore'): + in_ = [np.nan, -np.nan, np.inf, -np.inf] + out = [np.nan, np.nan, np.inf, 0.0] + for dt in ['e', 'f', 'd']: + in_arr = np.array(in_, dtype=dt) + out_arr = np.array(out, dtype=dt) + assert_equal(np.exp2(in_arr), out_arr) + + for value in [2000.0, -2000.0]: + with np.errstate(over='raise', under='raise'): + for dt in ['e', 'f', 'd']: + assert_raises(FloatingPointError, np.exp2, + np.array(value, dtype=dt)) + + @pytest.mark.skipif(IS_WASM, reason="fp errors don't work in wasm") + def test_expm1(self): + with np.errstate(all='ignore'): + in_ = [np.nan, -np.nan, np.inf, -np.inf] + out = [np.nan, np.nan, np.inf, -1.0] + for dt in ['e', 'f', 'd']: + in_arr = np.array(in_, dtype=dt) + out_arr = np.array(out, dtype=dt) + assert_equal(np.expm1(in_arr), out_arr) + + for value in [200.0, 2000.0]: + with np.errstate(over='raise'): + for dt in ['e', 'f']: + assert_raises(FloatingPointError, np.expm1, + np.array(value, dtype=dt)) + + # test to ensure no spurious FP exceptions are raised due to SIMD + INF_INVALID_ERR = [ + np.cos, np.sin, np.tan, np.arccos, np.arcsin, np.spacing, np.arctanh + ] + NEG_INVALID_ERR = [ + np.log, np.log2, np.log10, np.log1p, np.sqrt, np.arccosh, + np.arctanh + ] + ONE_INVALID_ERR = [ + np.arctanh, + ] + LTONE_INVALID_ERR = [ + np.arccosh, + ] + BYZERO_ERR = [ + np.log, np.log2, np.log10, np.reciprocal, np.arccosh + ] + + @pytest.mark.parametrize("ufunc", UFUNCS_UNARY_FP) + @pytest.mark.parametrize("dtype", ('e', 'f', 'd')) + @pytest.mark.parametrize("data, escape", ( + ([0.03], LTONE_INVALID_ERR), + ([0.03]*32, LTONE_INVALID_ERR), + # neg + ([-1.0], NEG_INVALID_ERR), + ([-1.0]*32, NEG_INVALID_ERR), + # flat + ([1.0], ONE_INVALID_ERR), + ([1.0]*32, ONE_INVALID_ERR), + # zero + ([0.0], BYZERO_ERR), + ([0.0]*32, BYZERO_ERR), + ([-0.0], BYZERO_ERR), + ([-0.0]*32, BYZERO_ERR), + # nan + ([0.5, 0.5, 0.5, np.nan], LTONE_INVALID_ERR), + ([0.5, 0.5, 0.5, np.nan]*32, LTONE_INVALID_ERR), + ([np.nan, 1.0, 1.0, 1.0], ONE_INVALID_ERR), + ([np.nan, 1.0, 1.0, 1.0]*32, ONE_INVALID_ERR), + ([np.nan], []), + ([np.nan]*32, []), + # inf + ([0.5, 0.5, 0.5, np.inf], INF_INVALID_ERR + LTONE_INVALID_ERR), + ([0.5, 0.5, 0.5, np.inf]*32, INF_INVALID_ERR + LTONE_INVALID_ERR), + ([np.inf, 1.0, 1.0, 1.0], INF_INVALID_ERR), + ([np.inf, 1.0, 1.0, 1.0]*32, INF_INVALID_ERR), + ([np.inf], INF_INVALID_ERR), + ([np.inf]*32, INF_INVALID_ERR), + # ninf + ([0.5, 0.5, 0.5, -np.inf], + NEG_INVALID_ERR + INF_INVALID_ERR + LTONE_INVALID_ERR), + ([0.5, 0.5, 0.5, -np.inf]*32, + NEG_INVALID_ERR + INF_INVALID_ERR + LTONE_INVALID_ERR), + ([-np.inf, 1.0, 1.0, 1.0], NEG_INVALID_ERR + INF_INVALID_ERR), + ([-np.inf, 1.0, 1.0, 1.0]*32, NEG_INVALID_ERR + INF_INVALID_ERR), + ([-np.inf], NEG_INVALID_ERR + INF_INVALID_ERR), + ([-np.inf]*32, NEG_INVALID_ERR + INF_INVALID_ERR), + )) + def test_unary_spurious_fpexception(self, ufunc, dtype, data, escape): + if escape and ufunc in escape: + return + # FIXME: NAN raises FP invalid exception: + # - ceil/float16 on MSVC:32-bit + # - spacing/float16 on almost all platforms + if ufunc in (np.spacing, np.ceil) and dtype == 'e': + return + array = np.array(data, dtype=dtype) + with assert_no_warnings(): + ufunc(array) + + @pytest.mark.parametrize("dtype", ('e', 'f', 'd')) + def test_divide_spurious_fpexception(self, dtype): + dt = np.dtype(dtype) + dt_info = np.finfo(dt) + subnorm = dt_info.smallest_subnormal + # Verify a bug fix caused due to filling the remaining lanes of the + # partially loaded dividend SIMD vector with ones, which leads to + # raising an overflow warning when the divisor is denormal. + # see https://github.com/numpy/numpy/issues/25097 + with assert_no_warnings(): + np.zeros(128 + 1, dtype=dt) / subnorm + +class TestFPClass: + @pytest.mark.parametrize("stride", [-5, -4, -3, -2, -1, 1, + 2, 4, 5, 6, 7, 8, 9, 10]) + def test_fpclass(self, stride): + arr_f64 = np.array([np.nan, -np.nan, np.inf, -np.inf, -1.0, 1.0, -0.0, 0.0, 2.2251e-308, -2.2251e-308], dtype='d') + arr_f32 = np.array([np.nan, -np.nan, np.inf, -np.inf, -1.0, 1.0, -0.0, 0.0, 1.4013e-045, -1.4013e-045], dtype='f') + nan = np.array([True, True, False, False, False, False, False, False, False, False]) + inf = np.array([False, False, True, True, False, False, False, False, False, False]) + sign = np.array([False, True, False, True, True, False, True, False, False, True]) + finite = np.array([False, False, False, False, True, True, True, True, True, True]) + assert_equal(np.isnan(arr_f32[::stride]), nan[::stride]) + assert_equal(np.isnan(arr_f64[::stride]), nan[::stride]) + assert_equal(np.isinf(arr_f32[::stride]), inf[::stride]) + assert_equal(np.isinf(arr_f64[::stride]), inf[::stride]) + if platform.machine() == 'riscv64': + # On RISC-V, many operations that produce NaNs, such as converting + # a -NaN from f64 to f32, return a canonical NaN. The canonical + # NaNs are always positive. See section 11.3 NaN Generation and + # Propagation of the RISC-V Unprivileged ISA for more details. + # We disable the sign test on riscv64 for -np.nan as we + # cannot assume that its sign will be honoured in these tests. + arr_f64_rv = np.copy(arr_f64) + arr_f32_rv = np.copy(arr_f32) + arr_f64_rv[1] = -1.0 + arr_f32_rv[1] = -1.0 + assert_equal(np.signbit(arr_f32_rv[::stride]), sign[::stride]) + assert_equal(np.signbit(arr_f64_rv[::stride]), sign[::stride]) + else: + assert_equal(np.signbit(arr_f32[::stride]), sign[::stride]) + assert_equal(np.signbit(arr_f64[::stride]), sign[::stride]) + assert_equal(np.isfinite(arr_f32[::stride]), finite[::stride]) + assert_equal(np.isfinite(arr_f64[::stride]), finite[::stride]) + + @pytest.mark.parametrize("dtype", ['d', 'f']) + def test_fp_noncontiguous(self, dtype): + data = np.array([np.nan, -np.nan, np.inf, -np.inf, -1.0, + 1.0, -0.0, 0.0, 2.2251e-308, + -2.2251e-308], dtype=dtype) + nan = np.array([True, True, False, False, False, False, + False, False, False, False]) + inf = np.array([False, False, True, True, False, False, + False, False, False, False]) + sign = np.array([False, True, False, True, True, False, + True, False, False, True]) + finite = np.array([False, False, False, False, True, True, + True, True, True, True]) + out = np.ndarray(data.shape, dtype='bool') + ncontig_in = data[1::3] + ncontig_out = out[1::3] + contig_in = np.array(ncontig_in) + + if platform.machine() == 'riscv64': + # Disable the -np.nan signbit tests on riscv64. See comments in + # test_fpclass for more details. + data_rv = np.copy(data) + data_rv[1] = -1.0 + ncontig_sign_in = data_rv[1::3] + contig_sign_in = np.array(ncontig_sign_in) + else: + ncontig_sign_in = ncontig_in + contig_sign_in = contig_in + + assert_equal(ncontig_in.flags.c_contiguous, False) + assert_equal(ncontig_out.flags.c_contiguous, False) + assert_equal(contig_in.flags.c_contiguous, True) + assert_equal(ncontig_sign_in.flags.c_contiguous, False) + assert_equal(contig_sign_in.flags.c_contiguous, True) + # ncontig in, ncontig out + assert_equal(np.isnan(ncontig_in, out=ncontig_out), nan[1::3]) + assert_equal(np.isinf(ncontig_in, out=ncontig_out), inf[1::3]) + assert_equal(np.signbit(ncontig_sign_in, out=ncontig_out), sign[1::3]) + assert_equal(np.isfinite(ncontig_in, out=ncontig_out), finite[1::3]) + # contig in, ncontig out + assert_equal(np.isnan(contig_in, out=ncontig_out), nan[1::3]) + assert_equal(np.isinf(contig_in, out=ncontig_out), inf[1::3]) + assert_equal(np.signbit(contig_sign_in, out=ncontig_out), sign[1::3]) + assert_equal(np.isfinite(contig_in, out=ncontig_out), finite[1::3]) + # ncontig in, contig out + assert_equal(np.isnan(ncontig_in), nan[1::3]) + assert_equal(np.isinf(ncontig_in), inf[1::3]) + assert_equal(np.signbit(ncontig_sign_in), sign[1::3]) + assert_equal(np.isfinite(ncontig_in), finite[1::3]) + # contig in, contig out, nd stride + data_split = np.array(np.array_split(data, 2)) + nan_split = np.array(np.array_split(nan, 2)) + inf_split = np.array(np.array_split(inf, 2)) + sign_split = np.array(np.array_split(sign, 2)) + finite_split = np.array(np.array_split(finite, 2)) + assert_equal(np.isnan(data_split), nan_split) + assert_equal(np.isinf(data_split), inf_split) + if platform.machine() == 'riscv64': + data_split_rv = np.array(np.array_split(data_rv, 2)) + assert_equal(np.signbit(data_split_rv), sign_split) + else: + assert_equal(np.signbit(data_split), sign_split) + assert_equal(np.isfinite(data_split), finite_split) + +class TestLDExp: + @pytest.mark.parametrize("stride", [-4,-2,-1,1,2,4]) + @pytest.mark.parametrize("dtype", ['f', 'd']) + def test_ldexp(self, dtype, stride): + mant = np.array([0.125, 0.25, 0.5, 1., 1., 2., 4., 8.], dtype=dtype) + exp = np.array([3, 2, 1, 0, 0, -1, -2, -3], dtype='i') + out = np.zeros(8, dtype=dtype) + assert_equal(np.ldexp(mant[::stride], exp[::stride], out=out[::stride]), np.ones(8, dtype=dtype)[::stride]) + assert_equal(out[::stride], np.ones(8, dtype=dtype)[::stride]) + +class TestFRExp: + @pytest.mark.parametrize("stride", [-4,-2,-1,1,2,4]) + @pytest.mark.parametrize("dtype", ['f', 'd']) + @pytest.mark.skipif(not sys.platform.startswith('linux'), + reason="np.frexp gives different answers for NAN/INF on windows and linux") + @pytest.mark.xfail(IS_MUSL, reason="gh23049") + def test_frexp(self, dtype, stride): + arr = np.array([np.nan, np.nan, np.inf, -np.inf, 0.0, -0.0, 1.0, -1.0], dtype=dtype) + mant_true = np.array([np.nan, np.nan, np.inf, -np.inf, 0.0, -0.0, 0.5, -0.5], dtype=dtype) + exp_true = np.array([0, 0, 0, 0, 0, 0, 1, 1], dtype='i') + out_mant = np.ones(8, dtype=dtype) + out_exp = 2*np.ones(8, dtype='i') + mant, exp = np.frexp(arr[::stride], out=(out_mant[::stride], out_exp[::stride])) + assert_equal(mant_true[::stride], mant) + assert_equal(exp_true[::stride], exp) + assert_equal(out_mant[::stride], mant_true[::stride]) + assert_equal(out_exp[::stride], exp_true[::stride]) + +# func : [maxulperror, low, high] +avx_ufuncs = {'sqrt' :[1, 0., 100.], + 'absolute' :[0, -100., 100.], + 'reciprocal' :[1, 1., 100.], + 'square' :[1, -100., 100.], + 'rint' :[0, -100., 100.], + 'floor' :[0, -100., 100.], + 'ceil' :[0, -100., 100.], + 'trunc' :[0, -100., 100.]} + +class TestAVXUfuncs: + def test_avx_based_ufunc(self): + strides = np.array([-4,-3,-2,-1,1,2,3,4]) + np.random.seed(42) + for func, prop in avx_ufuncs.items(): + maxulperr = prop[0] + minval = prop[1] + maxval = prop[2] + # various array sizes to ensure masking in AVX is tested + for size in range(1,32): + myfunc = getattr(np, func) + x_f32 = np.random.uniform(low=minval, high=maxval, + size=size).astype(np.float32) + x_f64 = x_f32.astype(np.float64) + x_f128 = x_f32.astype(np.longdouble) + y_true128 = myfunc(x_f128) + if maxulperr == 0: + assert_equal(myfunc(x_f32), y_true128.astype(np.float32)) + assert_equal(myfunc(x_f64), y_true128.astype(np.float64)) + else: + assert_array_max_ulp(myfunc(x_f32), + y_true128.astype(np.float32), + maxulp=maxulperr) + assert_array_max_ulp(myfunc(x_f64), + y_true128.astype(np.float64), + maxulp=maxulperr) + # various strides to test gather instruction + if size > 1: + y_true32 = myfunc(x_f32) + y_true64 = myfunc(x_f64) + for jj in strides: + assert_equal(myfunc(x_f64[::jj]), y_true64[::jj]) + assert_equal(myfunc(x_f32[::jj]), y_true32[::jj]) + +class TestAVXFloat32Transcendental: + def test_exp_float32(self): + np.random.seed(42) + x_f32 = np.float32(np.random.uniform(low=0.0,high=88.1,size=1000000)) + x_f64 = np.float64(x_f32) + assert_array_max_ulp(np.exp(x_f32), np.float32(np.exp(x_f64)), maxulp=3) + + def test_log_float32(self): + np.random.seed(42) + x_f32 = np.float32(np.random.uniform(low=0.0,high=1000,size=1000000)) + x_f64 = np.float64(x_f32) + assert_array_max_ulp(np.log(x_f32), np.float32(np.log(x_f64)), maxulp=4) + + def test_sincos_float32(self): + np.random.seed(42) + N = 1000000 + M = np.int_(N/20) + index = np.random.randint(low=0, high=N, size=M) + x_f32 = np.float32(np.random.uniform(low=-100.,high=100.,size=N)) + if not _glibc_older_than("2.17"): + # test coverage for elements > 117435.992f for which glibc is used + # this is known to be problematic on old glibc, so skip it there + x_f32[index] = np.float32(10E+10*np.random.rand(M)) + x_f64 = np.float64(x_f32) + assert_array_max_ulp(np.sin(x_f32), np.float32(np.sin(x_f64)), maxulp=2) + assert_array_max_ulp(np.cos(x_f32), np.float32(np.cos(x_f64)), maxulp=2) + # test aliasing(issue #17761) + tx_f32 = x_f32.copy() + assert_array_max_ulp(np.sin(x_f32, out=x_f32), np.float32(np.sin(x_f64)), maxulp=2) + assert_array_max_ulp(np.cos(tx_f32, out=tx_f32), np.float32(np.cos(x_f64)), maxulp=2) + + def test_strided_float32(self): + np.random.seed(42) + strides = np.array([-4,-3,-2,-1,1,2,3,4]) + sizes = np.arange(2,100) + for ii in sizes: + x_f32 = np.float32(np.random.uniform(low=0.01,high=88.1,size=ii)) + x_f32_large = x_f32.copy() + x_f32_large[3:-1:4] = 120000.0 + exp_true = np.exp(x_f32) + log_true = np.log(x_f32) + sin_true = np.sin(x_f32_large) + cos_true = np.cos(x_f32_large) + for jj in strides: + assert_array_almost_equal_nulp(np.exp(x_f32[::jj]), exp_true[::jj], nulp=2) + assert_array_almost_equal_nulp(np.log(x_f32[::jj]), log_true[::jj], nulp=2) + assert_array_almost_equal_nulp(np.sin(x_f32_large[::jj]), sin_true[::jj], nulp=2) + assert_array_almost_equal_nulp(np.cos(x_f32_large[::jj]), cos_true[::jj], nulp=2) + +class TestLogAddExp(_FilterInvalids): + def test_logaddexp_values(self): + x = [1, 2, 3, 4, 5] + y = [5, 4, 3, 2, 1] + z = [6, 6, 6, 6, 6] + for dt, dec_ in zip(['f', 'd', 'g'], [6, 15, 15]): + xf = np.log(np.array(x, dtype=dt)) + yf = np.log(np.array(y, dtype=dt)) + zf = np.log(np.array(z, dtype=dt)) + assert_almost_equal(np.logaddexp(xf, yf), zf, decimal=dec_) + + def test_logaddexp_range(self): + x = [1000000, -1000000, 1000200, -1000200] + y = [1000200, -1000200, 1000000, -1000000] + z = [1000200, -1000000, 1000200, -1000000] + for dt in ['f', 'd', 'g']: + logxf = np.array(x, dtype=dt) + logyf = np.array(y, dtype=dt) + logzf = np.array(z, dtype=dt) + assert_almost_equal(np.logaddexp(logxf, logyf), logzf) + + def test_inf(self): + inf = np.inf + x = [inf, -inf, inf, -inf, inf, 1, -inf, 1] + y = [inf, inf, -inf, -inf, 1, inf, 1, -inf] + z = [inf, inf, inf, -inf, inf, inf, 1, 1] + with np.errstate(invalid='raise'): + for dt in ['f', 'd', 'g']: + logxf = np.array(x, dtype=dt) + logyf = np.array(y, dtype=dt) + logzf = np.array(z, dtype=dt) + assert_equal(np.logaddexp(logxf, logyf), logzf) + + def test_nan(self): + assert_(np.isnan(np.logaddexp(np.nan, np.inf))) + assert_(np.isnan(np.logaddexp(np.inf, np.nan))) + assert_(np.isnan(np.logaddexp(np.nan, 0))) + assert_(np.isnan(np.logaddexp(0, np.nan))) + assert_(np.isnan(np.logaddexp(np.nan, np.nan))) + + def test_reduce(self): + assert_equal(np.logaddexp.identity, -np.inf) + assert_equal(np.logaddexp.reduce([]), -np.inf) + + +class TestLog1p: + def test_log1p(self): + assert_almost_equal(ncu.log1p(0.2), ncu.log(1.2)) + assert_almost_equal(ncu.log1p(1e-6), ncu.log(1+1e-6)) + + def test_special(self): + with np.errstate(invalid="ignore", divide="ignore"): + assert_equal(ncu.log1p(np.nan), np.nan) + assert_equal(ncu.log1p(np.inf), np.inf) + assert_equal(ncu.log1p(-1.), -np.inf) + assert_equal(ncu.log1p(-2.), np.nan) + assert_equal(ncu.log1p(-np.inf), np.nan) + + +class TestExpm1: + def test_expm1(self): + assert_almost_equal(ncu.expm1(0.2), ncu.exp(0.2)-1) + assert_almost_equal(ncu.expm1(1e-6), ncu.exp(1e-6)-1) + + def test_special(self): + assert_equal(ncu.expm1(np.inf), np.inf) + assert_equal(ncu.expm1(0.), 0.) + assert_equal(ncu.expm1(-0.), -0.) + assert_equal(ncu.expm1(np.inf), np.inf) + assert_equal(ncu.expm1(-np.inf), -1.) + + def test_complex(self): + x = np.asarray(1e-12) + assert_allclose(x, ncu.expm1(x)) + x = x.astype(np.complex128) + assert_allclose(x, ncu.expm1(x)) + + +class TestHypot: + def test_simple(self): + assert_almost_equal(ncu.hypot(1, 1), ncu.sqrt(2)) + assert_almost_equal(ncu.hypot(0, 0), 0) + + def test_reduce(self): + assert_almost_equal(ncu.hypot.reduce([3.0, 4.0]), 5.0) + assert_almost_equal(ncu.hypot.reduce([3.0, 4.0, 0]), 5.0) + assert_almost_equal(ncu.hypot.reduce([9.0, 12.0, 20.0]), 25.0) + assert_equal(ncu.hypot.reduce([]), 0.0) + + +def assert_hypot_isnan(x, y): + with np.errstate(invalid='ignore'): + assert_(np.isnan(ncu.hypot(x, y)), + "hypot(%s, %s) is %s, not nan" % (x, y, ncu.hypot(x, y))) + + +def assert_hypot_isinf(x, y): + with np.errstate(invalid='ignore'): + assert_(np.isinf(ncu.hypot(x, y)), + "hypot(%s, %s) is %s, not inf" % (x, y, ncu.hypot(x, y))) + + +class TestHypotSpecialValues: + def test_nan_outputs(self): + assert_hypot_isnan(np.nan, np.nan) + assert_hypot_isnan(np.nan, 1) + + def test_nan_outputs2(self): + assert_hypot_isinf(np.nan, np.inf) + assert_hypot_isinf(np.inf, np.nan) + assert_hypot_isinf(np.inf, 0) + assert_hypot_isinf(0, np.inf) + assert_hypot_isinf(np.inf, np.inf) + assert_hypot_isinf(np.inf, 23.0) + + def test_no_fpe(self): + assert_no_warnings(ncu.hypot, np.inf, 0) + + +def assert_arctan2_isnan(x, y): + assert_(np.isnan(ncu.arctan2(x, y)), "arctan(%s, %s) is %s, not nan" % (x, y, ncu.arctan2(x, y))) + + +def assert_arctan2_ispinf(x, y): + assert_((np.isinf(ncu.arctan2(x, y)) and ncu.arctan2(x, y) > 0), "arctan(%s, %s) is %s, not +inf" % (x, y, ncu.arctan2(x, y))) + + +def assert_arctan2_isninf(x, y): + assert_((np.isinf(ncu.arctan2(x, y)) and ncu.arctan2(x, y) < 0), "arctan(%s, %s) is %s, not -inf" % (x, y, ncu.arctan2(x, y))) + + +def assert_arctan2_ispzero(x, y): + assert_((ncu.arctan2(x, y) == 0 and not np.signbit(ncu.arctan2(x, y))), "arctan(%s, %s) is %s, not +0" % (x, y, ncu.arctan2(x, y))) + + +def assert_arctan2_isnzero(x, y): + assert_((ncu.arctan2(x, y) == 0 and np.signbit(ncu.arctan2(x, y))), "arctan(%s, %s) is %s, not -0" % (x, y, ncu.arctan2(x, y))) + + +class TestArctan2SpecialValues: + def test_one_one(self): + # atan2(1, 1) returns pi/4. + assert_almost_equal(ncu.arctan2(1, 1), 0.25 * np.pi) + assert_almost_equal(ncu.arctan2(-1, 1), -0.25 * np.pi) + assert_almost_equal(ncu.arctan2(1, -1), 0.75 * np.pi) + + def test_zero_nzero(self): + # atan2(+-0, -0) returns +-pi. + assert_almost_equal(ncu.arctan2(ncu.PZERO, ncu.NZERO), np.pi) + assert_almost_equal(ncu.arctan2(ncu.NZERO, ncu.NZERO), -np.pi) + + def test_zero_pzero(self): + # atan2(+-0, +0) returns +-0. + assert_arctan2_ispzero(ncu.PZERO, ncu.PZERO) + assert_arctan2_isnzero(ncu.NZERO, ncu.PZERO) + + def test_zero_negative(self): + # atan2(+-0, x) returns +-pi for x < 0. + assert_almost_equal(ncu.arctan2(ncu.PZERO, -1), np.pi) + assert_almost_equal(ncu.arctan2(ncu.NZERO, -1), -np.pi) + + def test_zero_positive(self): + # atan2(+-0, x) returns +-0 for x > 0. + assert_arctan2_ispzero(ncu.PZERO, 1) + assert_arctan2_isnzero(ncu.NZERO, 1) + + def test_positive_zero(self): + # atan2(y, +-0) returns +pi/2 for y > 0. + assert_almost_equal(ncu.arctan2(1, ncu.PZERO), 0.5 * np.pi) + assert_almost_equal(ncu.arctan2(1, ncu.NZERO), 0.5 * np.pi) + + def test_negative_zero(self): + # atan2(y, +-0) returns -pi/2 for y < 0. + assert_almost_equal(ncu.arctan2(-1, ncu.PZERO), -0.5 * np.pi) + assert_almost_equal(ncu.arctan2(-1, ncu.NZERO), -0.5 * np.pi) + + def test_any_ninf(self): + # atan2(+-y, -infinity) returns +-pi for finite y > 0. + assert_almost_equal(ncu.arctan2(1, -np.inf), np.pi) + assert_almost_equal(ncu.arctan2(-1, -np.inf), -np.pi) + + def test_any_pinf(self): + # atan2(+-y, +infinity) returns +-0 for finite y > 0. + assert_arctan2_ispzero(1, np.inf) + assert_arctan2_isnzero(-1, np.inf) + + def test_inf_any(self): + # atan2(+-infinity, x) returns +-pi/2 for finite x. + assert_almost_equal(ncu.arctan2( np.inf, 1), 0.5 * np.pi) + assert_almost_equal(ncu.arctan2(-np.inf, 1), -0.5 * np.pi) + + def test_inf_ninf(self): + # atan2(+-infinity, -infinity) returns +-3*pi/4. + assert_almost_equal(ncu.arctan2( np.inf, -np.inf), 0.75 * np.pi) + assert_almost_equal(ncu.arctan2(-np.inf, -np.inf), -0.75 * np.pi) + + def test_inf_pinf(self): + # atan2(+-infinity, +infinity) returns +-pi/4. + assert_almost_equal(ncu.arctan2( np.inf, np.inf), 0.25 * np.pi) + assert_almost_equal(ncu.arctan2(-np.inf, np.inf), -0.25 * np.pi) + + def test_nan_any(self): + # atan2(nan, x) returns nan for any x, including inf + assert_arctan2_isnan(np.nan, np.inf) + assert_arctan2_isnan(np.inf, np.nan) + assert_arctan2_isnan(np.nan, np.nan) + + +class TestLdexp: + def _check_ldexp(self, tp): + assert_almost_equal(ncu.ldexp(np.array(2., np.float32), + np.array(3, tp)), 16.) + assert_almost_equal(ncu.ldexp(np.array(2., np.float64), + np.array(3, tp)), 16.) + assert_almost_equal(ncu.ldexp(np.array(2., np.longdouble), + np.array(3, tp)), 16.) + + def test_ldexp(self): + # The default Python int type should work + assert_almost_equal(ncu.ldexp(2., 3), 16.) + # The following int types should all be accepted + self._check_ldexp(np.int8) + self._check_ldexp(np.int16) + self._check_ldexp(np.int32) + self._check_ldexp('i') + self._check_ldexp('l') + + def test_ldexp_overflow(self): + # silence warning emitted on overflow + with np.errstate(over="ignore"): + imax = np.iinfo(np.dtype('l')).max + imin = np.iinfo(np.dtype('l')).min + assert_equal(ncu.ldexp(2., imax), np.inf) + assert_equal(ncu.ldexp(2., imin), 0) + + +class TestMaximum(_FilterInvalids): + def test_reduce(self): + dflt = np.typecodes['AllFloat'] + dint = np.typecodes['AllInteger'] + seq1 = np.arange(11) + seq2 = seq1[::-1] + func = np.maximum.reduce + for dt in dint: + tmp1 = seq1.astype(dt) + tmp2 = seq2.astype(dt) + assert_equal(func(tmp1), 10) + assert_equal(func(tmp2), 10) + for dt in dflt: + tmp1 = seq1.astype(dt) + tmp2 = seq2.astype(dt) + assert_equal(func(tmp1), 10) + assert_equal(func(tmp2), 10) + tmp1[::2] = np.nan + tmp2[::2] = np.nan + assert_equal(func(tmp1), np.nan) + assert_equal(func(tmp2), np.nan) + + def test_reduce_complex(self): + assert_equal(np.maximum.reduce([1, 2j]), 1) + assert_equal(np.maximum.reduce([1+3j, 2j]), 1+3j) + + def test_float_nans(self): + nan = np.nan + arg1 = np.array([0, nan, nan]) + arg2 = np.array([nan, 0, nan]) + out = np.array([nan, nan, nan]) + assert_equal(np.maximum(arg1, arg2), out) + + def test_object_nans(self): + # Multiple checks to give this a chance to + # fail if cmp is used instead of rich compare. + # Failure cannot be guaranteed. + for i in range(1): + x = np.array(float('nan'), object) + y = 1.0 + z = np.array(float('nan'), object) + assert_(np.maximum(x, y) == 1.0) + assert_(np.maximum(z, y) == 1.0) + + def test_complex_nans(self): + nan = np.nan + for cnan in [complex(nan, 0), complex(0, nan), complex(nan, nan)]: + arg1 = np.array([0, cnan, cnan], dtype=complex) + arg2 = np.array([cnan, 0, cnan], dtype=complex) + out = np.array([nan, nan, nan], dtype=complex) + assert_equal(np.maximum(arg1, arg2), out) + + def test_object_array(self): + arg1 = np.arange(5, dtype=object) + arg2 = arg1 + 1 + assert_equal(np.maximum(arg1, arg2), arg2) + + def test_strided_array(self): + arr1 = np.array([-4.0, 1.0, 10.0, 0.0, np.nan, -np.nan, np.inf, -np.inf]) + arr2 = np.array([-2.0,-1.0, np.nan, 1.0, 0.0, np.nan, 1.0, -3.0]) + maxtrue = np.array([-2.0, 1.0, np.nan, 1.0, np.nan, np.nan, np.inf, -3.0]) + out = np.ones(8) + out_maxtrue = np.array([-2.0, 1.0, 1.0, 10.0, 1.0, 1.0, np.nan, 1.0]) + assert_equal(np.maximum(arr1,arr2), maxtrue) + assert_equal(np.maximum(arr1[::2],arr2[::2]), maxtrue[::2]) + assert_equal(np.maximum(arr1[:4:], arr2[::2]), np.array([-2.0, np.nan, 10.0, 1.0])) + assert_equal(np.maximum(arr1[::3], arr2[:3:]), np.array([-2.0, 0.0, np.nan])) + assert_equal(np.maximum(arr1[:6:2], arr2[::3], out=out[::3]), np.array([-2.0, 10., np.nan])) + assert_equal(out, out_maxtrue) + + def test_precision(self): + dtypes = [np.float16, np.float32, np.float64, np.longdouble] + + for dt in dtypes: + dtmin = np.finfo(dt).min + dtmax = np.finfo(dt).max + d1 = dt(0.1) + d1_next = np.nextafter(d1, np.inf) + + test_cases = [ + # v1 v2 expected + (dtmin, -np.inf, dtmin), + (dtmax, -np.inf, dtmax), + (d1, d1_next, d1_next), + (dtmax, np.nan, np.nan), + ] + + for v1, v2, expected in test_cases: + assert_equal(np.maximum([v1], [v2]), [expected]) + assert_equal(np.maximum.reduce([v1, v2]), expected) + + +class TestMinimum(_FilterInvalids): + def test_reduce(self): + dflt = np.typecodes['AllFloat'] + dint = np.typecodes['AllInteger'] + seq1 = np.arange(11) + seq2 = seq1[::-1] + func = np.minimum.reduce + for dt in dint: + tmp1 = seq1.astype(dt) + tmp2 = seq2.astype(dt) + assert_equal(func(tmp1), 0) + assert_equal(func(tmp2), 0) + for dt in dflt: + tmp1 = seq1.astype(dt) + tmp2 = seq2.astype(dt) + assert_equal(func(tmp1), 0) + assert_equal(func(tmp2), 0) + tmp1[::2] = np.nan + tmp2[::2] = np.nan + assert_equal(func(tmp1), np.nan) + assert_equal(func(tmp2), np.nan) + + def test_reduce_complex(self): + assert_equal(np.minimum.reduce([1, 2j]), 2j) + assert_equal(np.minimum.reduce([1+3j, 2j]), 2j) + + def test_float_nans(self): + nan = np.nan + arg1 = np.array([0, nan, nan]) + arg2 = np.array([nan, 0, nan]) + out = np.array([nan, nan, nan]) + assert_equal(np.minimum(arg1, arg2), out) + + def test_object_nans(self): + # Multiple checks to give this a chance to + # fail if cmp is used instead of rich compare. + # Failure cannot be guaranteed. + for i in range(1): + x = np.array(float('nan'), object) + y = 1.0 + z = np.array(float('nan'), object) + assert_(np.minimum(x, y) == 1.0) + assert_(np.minimum(z, y) == 1.0) + + def test_complex_nans(self): + nan = np.nan + for cnan in [complex(nan, 0), complex(0, nan), complex(nan, nan)]: + arg1 = np.array([0, cnan, cnan], dtype=complex) + arg2 = np.array([cnan, 0, cnan], dtype=complex) + out = np.array([nan, nan, nan], dtype=complex) + assert_equal(np.minimum(arg1, arg2), out) + + def test_object_array(self): + arg1 = np.arange(5, dtype=object) + arg2 = arg1 + 1 + assert_equal(np.minimum(arg1, arg2), arg1) + + def test_strided_array(self): + arr1 = np.array([-4.0, 1.0, 10.0, 0.0, np.nan, -np.nan, np.inf, -np.inf]) + arr2 = np.array([-2.0,-1.0, np.nan, 1.0, 0.0, np.nan, 1.0, -3.0]) + mintrue = np.array([-4.0, -1.0, np.nan, 0.0, np.nan, np.nan, 1.0, -np.inf]) + out = np.ones(8) + out_mintrue = np.array([-4.0, 1.0, 1.0, 1.0, 1.0, 1.0, np.nan, 1.0]) + assert_equal(np.minimum(arr1,arr2), mintrue) + assert_equal(np.minimum(arr1[::2],arr2[::2]), mintrue[::2]) + assert_equal(np.minimum(arr1[:4:], arr2[::2]), np.array([-4.0, np.nan, 0.0, 0.0])) + assert_equal(np.minimum(arr1[::3], arr2[:3:]), np.array([-4.0, -1.0, np.nan])) + assert_equal(np.minimum(arr1[:6:2], arr2[::3], out=out[::3]), np.array([-4.0, 1.0, np.nan])) + assert_equal(out, out_mintrue) + + def test_precision(self): + dtypes = [np.float16, np.float32, np.float64, np.longdouble] + + for dt in dtypes: + dtmin = np.finfo(dt).min + dtmax = np.finfo(dt).max + d1 = dt(0.1) + d1_next = np.nextafter(d1, np.inf) + + test_cases = [ + # v1 v2 expected + (dtmin, np.inf, dtmin), + (dtmax, np.inf, dtmax), + (d1, d1_next, d1), + (dtmin, np.nan, np.nan), + ] + + for v1, v2, expected in test_cases: + assert_equal(np.minimum([v1], [v2]), [expected]) + assert_equal(np.minimum.reduce([v1, v2]), expected) + + +class TestFmax(_FilterInvalids): + def test_reduce(self): + dflt = np.typecodes['AllFloat'] + dint = np.typecodes['AllInteger'] + seq1 = np.arange(11) + seq2 = seq1[::-1] + func = np.fmax.reduce + for dt in dint: + tmp1 = seq1.astype(dt) + tmp2 = seq2.astype(dt) + assert_equal(func(tmp1), 10) + assert_equal(func(tmp2), 10) + for dt in dflt: + tmp1 = seq1.astype(dt) + tmp2 = seq2.astype(dt) + assert_equal(func(tmp1), 10) + assert_equal(func(tmp2), 10) + tmp1[::2] = np.nan + tmp2[::2] = np.nan + assert_equal(func(tmp1), 9) + assert_equal(func(tmp2), 9) + + def test_reduce_complex(self): + assert_equal(np.fmax.reduce([1, 2j]), 1) + assert_equal(np.fmax.reduce([1+3j, 2j]), 1+3j) + + def test_float_nans(self): + nan = np.nan + arg1 = np.array([0, nan, nan]) + arg2 = np.array([nan, 0, nan]) + out = np.array([0, 0, nan]) + assert_equal(np.fmax(arg1, arg2), out) + + def test_complex_nans(self): + nan = np.nan + for cnan in [complex(nan, 0), complex(0, nan), complex(nan, nan)]: + arg1 = np.array([0, cnan, cnan], dtype=complex) + arg2 = np.array([cnan, 0, cnan], dtype=complex) + out = np.array([0, 0, nan], dtype=complex) + assert_equal(np.fmax(arg1, arg2), out) + + def test_precision(self): + dtypes = [np.float16, np.float32, np.float64, np.longdouble] + + for dt in dtypes: + dtmin = np.finfo(dt).min + dtmax = np.finfo(dt).max + d1 = dt(0.1) + d1_next = np.nextafter(d1, np.inf) + + test_cases = [ + # v1 v2 expected + (dtmin, -np.inf, dtmin), + (dtmax, -np.inf, dtmax), + (d1, d1_next, d1_next), + (dtmax, np.nan, dtmax), + ] + + for v1, v2, expected in test_cases: + assert_equal(np.fmax([v1], [v2]), [expected]) + assert_equal(np.fmax.reduce([v1, v2]), expected) + + +class TestFmin(_FilterInvalids): + def test_reduce(self): + dflt = np.typecodes['AllFloat'] + dint = np.typecodes['AllInteger'] + seq1 = np.arange(11) + seq2 = seq1[::-1] + func = np.fmin.reduce + for dt in dint: + tmp1 = seq1.astype(dt) + tmp2 = seq2.astype(dt) + assert_equal(func(tmp1), 0) + assert_equal(func(tmp2), 0) + for dt in dflt: + tmp1 = seq1.astype(dt) + tmp2 = seq2.astype(dt) + assert_equal(func(tmp1), 0) + assert_equal(func(tmp2), 0) + tmp1[::2] = np.nan + tmp2[::2] = np.nan + assert_equal(func(tmp1), 1) + assert_equal(func(tmp2), 1) + + def test_reduce_complex(self): + assert_equal(np.fmin.reduce([1, 2j]), 2j) + assert_equal(np.fmin.reduce([1+3j, 2j]), 2j) + + def test_float_nans(self): + nan = np.nan + arg1 = np.array([0, nan, nan]) + arg2 = np.array([nan, 0, nan]) + out = np.array([0, 0, nan]) + assert_equal(np.fmin(arg1, arg2), out) + + def test_complex_nans(self): + nan = np.nan + for cnan in [complex(nan, 0), complex(0, nan), complex(nan, nan)]: + arg1 = np.array([0, cnan, cnan], dtype=complex) + arg2 = np.array([cnan, 0, cnan], dtype=complex) + out = np.array([0, 0, nan], dtype=complex) + assert_equal(np.fmin(arg1, arg2), out) + + def test_precision(self): + dtypes = [np.float16, np.float32, np.float64, np.longdouble] + + for dt in dtypes: + dtmin = np.finfo(dt).min + dtmax = np.finfo(dt).max + d1 = dt(0.1) + d1_next = np.nextafter(d1, np.inf) + + test_cases = [ + # v1 v2 expected + (dtmin, np.inf, dtmin), + (dtmax, np.inf, dtmax), + (d1, d1_next, d1), + (dtmin, np.nan, dtmin), + ] + + for v1, v2, expected in test_cases: + assert_equal(np.fmin([v1], [v2]), [expected]) + assert_equal(np.fmin.reduce([v1, v2]), expected) + + +class TestBool: + def test_exceptions(self): + a = np.ones(1, dtype=np.bool) + assert_raises(TypeError, np.negative, a) + assert_raises(TypeError, np.positive, a) + assert_raises(TypeError, np.subtract, a, a) + + def test_truth_table_logical(self): + # 2, 3 and 4 serves as true values + input1 = [0, 0, 3, 2] + input2 = [0, 4, 0, 2] + + typecodes = (np.typecodes['AllFloat'] + + np.typecodes['AllInteger'] + + '?') # boolean + for dtype in map(np.dtype, typecodes): + arg1 = np.asarray(input1, dtype=dtype) + arg2 = np.asarray(input2, dtype=dtype) + + # OR + out = [False, True, True, True] + for func in (np.logical_or, np.maximum): + assert_equal(func(arg1, arg2).astype(bool), out) + # AND + out = [False, False, False, True] + for func in (np.logical_and, np.minimum): + assert_equal(func(arg1, arg2).astype(bool), out) + # XOR + out = [False, True, True, False] + for func in (np.logical_xor, np.not_equal): + assert_equal(func(arg1, arg2).astype(bool), out) + + def test_truth_table_bitwise(self): + arg1 = [False, False, True, True] + arg2 = [False, True, False, True] + + out = [False, True, True, True] + assert_equal(np.bitwise_or(arg1, arg2), out) + + out = [False, False, False, True] + assert_equal(np.bitwise_and(arg1, arg2), out) + + out = [False, True, True, False] + assert_equal(np.bitwise_xor(arg1, arg2), out) + + def test_reduce(self): + none = np.array([0, 0, 0, 0], bool) + some = np.array([1, 0, 1, 1], bool) + every = np.array([1, 1, 1, 1], bool) + empty = np.array([], bool) + + arrs = [none, some, every, empty] + + for arr in arrs: + assert_equal(np.logical_and.reduce(arr), all(arr)) + + for arr in arrs: + assert_equal(np.logical_or.reduce(arr), any(arr)) + + for arr in arrs: + assert_equal(np.logical_xor.reduce(arr), arr.sum() % 2 == 1) + + +class TestBitwiseUFuncs: + + _all_ints_bits = [ + np.dtype(c).itemsize * 8 for c in np.typecodes["AllInteger"]] + bitwise_types = [ + np.dtype(c) for c in '?' + np.typecodes["AllInteger"] + 'O'] + bitwise_bits = [ + 2, # boolean type + *_all_ints_bits, # All integers + max(_all_ints_bits) + 1, # Object_ type + ] + + def test_values(self): + for dt in self.bitwise_types: + zeros = np.array([0], dtype=dt) + ones = np.array([-1]).astype(dt) + msg = "dt = '%s'" % dt.char + + assert_equal(np.bitwise_not(zeros), ones, err_msg=msg) + assert_equal(np.bitwise_not(ones), zeros, err_msg=msg) + + assert_equal(np.bitwise_or(zeros, zeros), zeros, err_msg=msg) + assert_equal(np.bitwise_or(zeros, ones), ones, err_msg=msg) + assert_equal(np.bitwise_or(ones, zeros), ones, err_msg=msg) + assert_equal(np.bitwise_or(ones, ones), ones, err_msg=msg) + + assert_equal(np.bitwise_xor(zeros, zeros), zeros, err_msg=msg) + assert_equal(np.bitwise_xor(zeros, ones), ones, err_msg=msg) + assert_equal(np.bitwise_xor(ones, zeros), ones, err_msg=msg) + assert_equal(np.bitwise_xor(ones, ones), zeros, err_msg=msg) + + assert_equal(np.bitwise_and(zeros, zeros), zeros, err_msg=msg) + assert_equal(np.bitwise_and(zeros, ones), zeros, err_msg=msg) + assert_equal(np.bitwise_and(ones, zeros), zeros, err_msg=msg) + assert_equal(np.bitwise_and(ones, ones), ones, err_msg=msg) + + def test_types(self): + for dt in self.bitwise_types: + zeros = np.array([0], dtype=dt) + ones = np.array([-1]).astype(dt) + msg = "dt = '%s'" % dt.char + + assert_(np.bitwise_not(zeros).dtype == dt, msg) + assert_(np.bitwise_or(zeros, zeros).dtype == dt, msg) + assert_(np.bitwise_xor(zeros, zeros).dtype == dt, msg) + assert_(np.bitwise_and(zeros, zeros).dtype == dt, msg) + + def test_identity(self): + assert_(np.bitwise_or.identity == 0, 'bitwise_or') + assert_(np.bitwise_xor.identity == 0, 'bitwise_xor') + assert_(np.bitwise_and.identity == -1, 'bitwise_and') + + def test_reduction(self): + binary_funcs = (np.bitwise_or, np.bitwise_xor, np.bitwise_and) + + for dt in self.bitwise_types: + zeros = np.array([0], dtype=dt) + ones = np.array([-1]).astype(dt) + for f in binary_funcs: + msg = "dt: '%s', f: '%s'" % (dt, f) + assert_equal(f.reduce(zeros), zeros, err_msg=msg) + assert_equal(f.reduce(ones), ones, err_msg=msg) + + # Test empty reduction, no object dtype + for dt in self.bitwise_types[:-1]: + # No object array types + empty = np.array([], dtype=dt) + for f in binary_funcs: + msg = "dt: '%s', f: '%s'" % (dt, f) + tgt = np.array(f.identity).astype(dt) + res = f.reduce(empty) + assert_equal(res, tgt, err_msg=msg) + assert_(res.dtype == tgt.dtype, msg) + + # Empty object arrays use the identity. Note that the types may + # differ, the actual type used is determined by the assign_identity + # function and is not the same as the type returned by the identity + # method. + for f in binary_funcs: + msg = "dt: '%s'" % (f,) + empty = np.array([], dtype=object) + tgt = f.identity + res = f.reduce(empty) + assert_equal(res, tgt, err_msg=msg) + + # Non-empty object arrays do not use the identity + for f in binary_funcs: + msg = "dt: '%s'" % (f,) + btype = np.array([True], dtype=object) + assert_(type(f.reduce(btype)) is bool, msg) + + @pytest.mark.parametrize("input_dtype_obj, bitsize", + zip(bitwise_types, bitwise_bits)) + def test_bitwise_count(self, input_dtype_obj, bitsize): + input_dtype = input_dtype_obj.type + + for i in range(1, bitsize): + num = 2**i - 1 + msg = f"bitwise_count for {num}" + assert i == np.bitwise_count(input_dtype(num)), msg + if np.issubdtype( + input_dtype, np.signedinteger) or input_dtype == np.object_: + assert i == np.bitwise_count(input_dtype(-num)), msg + + a = np.array([2**i-1 for i in range(1, bitsize)], dtype=input_dtype) + bitwise_count_a = np.bitwise_count(a) + expected = np.arange(1, bitsize, dtype=input_dtype) + + msg = f"array bitwise_count for {input_dtype}" + assert all(bitwise_count_a == expected), msg + + +class TestInt: + def test_logical_not(self): + x = np.ones(10, dtype=np.int16) + o = np.ones(10 * 2, dtype=bool) + tgt = o.copy() + tgt[::2] = False + os = o[::2] + assert_array_equal(np.logical_not(x, out=os), False) + assert_array_equal(o, tgt) + + +class TestFloatingPoint: + def test_floating_point(self): + assert_equal(ncu.FLOATING_POINT_SUPPORT, 1) + + +class TestDegrees: + def test_degrees(self): + assert_almost_equal(ncu.degrees(np.pi), 180.0) + assert_almost_equal(ncu.degrees(-0.5*np.pi), -90.0) + + +class TestRadians: + def test_radians(self): + assert_almost_equal(ncu.radians(180.0), np.pi) + assert_almost_equal(ncu.radians(-90.0), -0.5*np.pi) + + +class TestHeavside: + def test_heaviside(self): + x = np.array([[-30.0, -0.1, 0.0, 0.2], [7.5, np.nan, np.inf, -np.inf]]) + expectedhalf = np.array([[0.0, 0.0, 0.5, 1.0], [1.0, np.nan, 1.0, 0.0]]) + expected1 = expectedhalf.copy() + expected1[0, 2] = 1 + + h = ncu.heaviside(x, 0.5) + assert_equal(h, expectedhalf) + + h = ncu.heaviside(x, 1.0) + assert_equal(h, expected1) + + x = x.astype(np.float32) + + h = ncu.heaviside(x, np.float32(0.5)) + assert_equal(h, expectedhalf.astype(np.float32)) + + h = ncu.heaviside(x, np.float32(1.0)) + assert_equal(h, expected1.astype(np.float32)) + + +class TestSign: + def test_sign(self): + a = np.array([np.inf, -np.inf, np.nan, 0.0, 3.0, -3.0]) + out = np.zeros(a.shape) + tgt = np.array([1., -1., np.nan, 0.0, 1.0, -1.0]) + + with np.errstate(invalid='ignore'): + res = ncu.sign(a) + assert_equal(res, tgt) + res = ncu.sign(a, out) + assert_equal(res, tgt) + assert_equal(out, tgt) + + def test_sign_complex(self): + a = np.array([ + np.inf, -np.inf, complex(0, np.inf), complex(0, -np.inf), + complex(np.inf, np.inf), complex(np.inf, -np.inf), # nan + np.nan, complex(0, np.nan), complex(np.nan, np.nan), # nan + 0.0, # 0. + 3.0, -3.0, -2j, 3.0+4.0j, -8.0+6.0j + ]) + out = np.zeros(a.shape, a.dtype) + tgt = np.array([ + 1., -1., 1j, -1j, + ] + [complex(np.nan, np.nan)] * 5 + [ + 0.0, + 1.0, -1.0, -1j, 0.6+0.8j, -0.8+0.6j]) + + with np.errstate(invalid='ignore'): + res = ncu.sign(a) + assert_equal(res, tgt) + res = ncu.sign(a, out) + assert_(res is out) + assert_equal(res, tgt) + + def test_sign_dtype_object(self): + # In reference to github issue #6229 + + foo = np.array([-.1, 0, .1]) + a = np.sign(foo.astype(object)) + b = np.sign(foo) + + assert_array_equal(a, b) + + def test_sign_dtype_nan_object(self): + # In reference to github issue #6229 + def test_nan(): + foo = np.array([np.nan]) + # FIXME: a not used + a = np.sign(foo.astype(object)) + + assert_raises(TypeError, test_nan) + +class TestMinMax: + def test_minmax_blocked(self): + # simd tests on max/min, test all alignments, slow but important + # for 2 * vz + 2 * (vs - 1) + 1 (unrolled once) + for dt, sz in [(np.float32, 15), (np.float64, 7)]: + for out, inp, msg in _gen_alignment_data(dtype=dt, type='unary', + max_size=sz): + for i in range(inp.size): + inp[:] = np.arange(inp.size, dtype=dt) + inp[i] = np.nan + emsg = lambda: '%r\n%s' % (inp, msg) + with suppress_warnings() as sup: + sup.filter(RuntimeWarning, + "invalid value encountered in reduce") + assert_(np.isnan(inp.max()), msg=emsg) + assert_(np.isnan(inp.min()), msg=emsg) + + inp[i] = 1e10 + assert_equal(inp.max(), 1e10, err_msg=msg) + inp[i] = -1e10 + assert_equal(inp.min(), -1e10, err_msg=msg) + + def test_lower_align(self): + # check data that is not aligned to element size + # i.e doubles are aligned to 4 bytes on i386 + d = np.zeros(23 * 8, dtype=np.int8)[4:-4].view(np.float64) + assert_equal(d.max(), d[0]) + assert_equal(d.min(), d[0]) + + def test_reduce_reorder(self): + # gh 10370, 11029 Some compilers reorder the call to npy_getfloatstatus + # and put it before the call to an intrinsic function that causes + # invalid status to be set. Also make sure warnings are not emitted + for n in (2, 4, 8, 16, 32): + for dt in (np.float32, np.float16, np.complex64): + for r in np.diagflat(np.array([np.nan] * n, dtype=dt)): + assert_equal(np.min(r), np.nan) + + def test_minimize_no_warns(self): + a = np.minimum(np.nan, 1) + assert_equal(a, np.nan) + + +class TestAbsoluteNegative: + def test_abs_neg_blocked(self): + # simd tests on abs, test all alignments for vz + 2 * (vs - 1) + 1 + for dt, sz in [(np.float32, 11), (np.float64, 5)]: + for out, inp, msg in _gen_alignment_data(dtype=dt, type='unary', + max_size=sz): + tgt = [ncu.absolute(i) for i in inp] + np.absolute(inp, out=out) + assert_equal(out, tgt, err_msg=msg) + assert_((out >= 0).all()) + + tgt = [-1*(i) for i in inp] + np.negative(inp, out=out) + assert_equal(out, tgt, err_msg=msg) + + for v in [np.nan, -np.inf, np.inf]: + for i in range(inp.size): + d = np.arange(inp.size, dtype=dt) + inp[:] = -d + inp[i] = v + d[i] = -v if v == -np.inf else v + assert_array_equal(np.abs(inp), d, err_msg=msg) + np.abs(inp, out=out) + assert_array_equal(out, d, err_msg=msg) + + assert_array_equal(-inp, -1*inp, err_msg=msg) + d = -1 * inp + np.negative(inp, out=out) + assert_array_equal(out, d, err_msg=msg) + + def test_lower_align(self): + # check data that is not aligned to element size + # i.e doubles are aligned to 4 bytes on i386 + d = np.zeros(23 * 8, dtype=np.int8)[4:-4].view(np.float64) + assert_equal(np.abs(d), d) + assert_equal(np.negative(d), -d) + np.negative(d, out=d) + np.negative(np.ones_like(d), out=d) + np.abs(d, out=d) + np.abs(np.ones_like(d), out=d) + + @pytest.mark.parametrize("dtype", ['d', 'f', 'int32', 'int64']) + @pytest.mark.parametrize("big", [True, False]) + def test_noncontiguous(self, dtype, big): + data = np.array([-1.0, 1.0, -0.0, 0.0, 2.2251e-308, -2.5, 2.5, -6, + 6, -2.2251e-308, -8, 10], dtype=dtype) + expect = np.array([1.0, -1.0, 0.0, -0.0, -2.2251e-308, 2.5, -2.5, 6, + -6, 2.2251e-308, 8, -10], dtype=dtype) + if big: + data = np.repeat(data, 10) + expect = np.repeat(expect, 10) + out = np.ndarray(data.shape, dtype=dtype) + ncontig_in = data[1::2] + ncontig_out = out[1::2] + contig_in = np.array(ncontig_in) + # contig in, contig out + assert_array_equal(np.negative(contig_in), expect[1::2]) + # contig in, ncontig out + assert_array_equal(np.negative(contig_in, out=ncontig_out), + expect[1::2]) + # ncontig in, contig out + assert_array_equal(np.negative(ncontig_in), expect[1::2]) + # ncontig in, ncontig out + assert_array_equal(np.negative(ncontig_in, out=ncontig_out), + expect[1::2]) + # contig in, contig out, nd stride + data_split = np.array(np.array_split(data, 2)) + expect_split = np.array(np.array_split(expect, 2)) + assert_equal(np.negative(data_split), expect_split) + + +class TestPositive: + def test_valid(self): + valid_dtypes = [int, float, complex, object] + for dtype in valid_dtypes: + x = np.arange(5, dtype=dtype) + result = np.positive(x) + assert_equal(x, result, err_msg=str(dtype)) + + def test_invalid(self): + with assert_raises(TypeError): + np.positive(True) + with assert_raises(TypeError): + np.positive(np.datetime64('2000-01-01')) + with assert_raises(TypeError): + np.positive(np.array(['foo'], dtype=str)) + with assert_raises(TypeError): + np.positive(np.array(['bar'], dtype=object)) + + +class TestSpecialMethods: + def test_wrap(self): + + class with_wrap: + def __array__(self, dtype=None, copy=None): + return np.zeros(1) + + def __array_wrap__(self, arr, context, return_scalar): + r = with_wrap() + r.arr = arr + r.context = context + return r + + a = with_wrap() + x = ncu.minimum(a, a) + assert_equal(x.arr, np.zeros(1)) + func, args, i = x.context + assert_(func is ncu.minimum) + assert_equal(len(args), 2) + assert_equal(args[0], a) + assert_equal(args[1], a) + assert_equal(i, 0) + + def test_wrap_out(self): + # Calling convention for out should not affect how special methods are + # called + + class StoreArrayPrepareWrap(np.ndarray): + _wrap_args = None + _prepare_args = None + + def __new__(cls): + return np.zeros(()).view(cls) + + def __array_wrap__(self, obj, context, return_scalar): + self._wrap_args = context[1] + return obj + + @property + def args(self): + # We need to ensure these are fetched at the same time, before + # any other ufuncs are called by the assertions + return self._wrap_args + + def __repr__(self): + return "a" # for short test output + + def do_test(f_call, f_expected): + a = StoreArrayPrepareWrap() + + f_call(a) + + w = a.args + expected = f_expected(a) + try: + assert w == expected + except AssertionError as e: + # assert_equal produces truly useless error messages + raise AssertionError("\n".join([ + "Bad arguments passed in ufunc call", + " expected: {}".format(expected), + " __array_wrap__ got: {}".format(w) + ])) + + # method not on the out argument + do_test(lambda a: np.add(a, 0), lambda a: (a, 0)) + do_test(lambda a: np.add(a, 0, None), lambda a: (a, 0)) + do_test(lambda a: np.add(a, 0, out=None), lambda a: (a, 0)) + do_test(lambda a: np.add(a, 0, out=(None,)), lambda a: (a, 0)) + + # method on the out argument + do_test(lambda a: np.add(0, 0, a), lambda a: (0, 0, a)) + do_test(lambda a: np.add(0, 0, out=a), lambda a: (0, 0, a)) + do_test(lambda a: np.add(0, 0, out=(a,)), lambda a: (0, 0, a)) + + # Also check the where mask handling: + do_test(lambda a: np.add(a, 0, where=False), lambda a: (a, 0)) + do_test(lambda a: np.add(0, 0, a, where=False), lambda a: (0, 0, a)) + + def test_wrap_with_iterable(self): + # test fix for bug #1026: + + class with_wrap(np.ndarray): + __array_priority__ = 10 + + def __new__(cls): + return np.asarray(1).view(cls).copy() + + def __array_wrap__(self, arr, context, return_scalar): + return arr.view(type(self)) + + a = with_wrap() + x = ncu.multiply(a, (1, 2, 3)) + assert_(isinstance(x, with_wrap)) + assert_array_equal(x, np.array((1, 2, 3))) + + def test_priority_with_scalar(self): + # test fix for bug #826: + + class A(np.ndarray): + __array_priority__ = 10 + + def __new__(cls): + return np.asarray(1.0, 'float64').view(cls).copy() + + a = A() + x = np.float64(1)*a + assert_(isinstance(x, A)) + assert_array_equal(x, np.array(1)) + + def test_priority(self): + + class A: + def __array__(self, dtype=None, copy=None): + return np.zeros(1) + + def __array_wrap__(self, arr, context, return_scalar): + r = type(self)() + r.arr = arr + r.context = context + return r + + class B(A): + __array_priority__ = 20. + + class C(A): + __array_priority__ = 40. + + x = np.zeros(1) + a = A() + b = B() + c = C() + f = ncu.minimum + assert_(type(f(x, x)) is np.ndarray) + assert_(type(f(x, a)) is A) + assert_(type(f(x, b)) is B) + assert_(type(f(x, c)) is C) + assert_(type(f(a, x)) is A) + assert_(type(f(b, x)) is B) + assert_(type(f(c, x)) is C) + + assert_(type(f(a, a)) is A) + assert_(type(f(a, b)) is B) + assert_(type(f(b, a)) is B) + assert_(type(f(b, b)) is B) + assert_(type(f(b, c)) is C) + assert_(type(f(c, b)) is C) + assert_(type(f(c, c)) is C) + + assert_(type(ncu.exp(a) is A)) + assert_(type(ncu.exp(b) is B)) + assert_(type(ncu.exp(c) is C)) + + def test_failing_wrap(self): + + class A: + def __array__(self, dtype=None, copy=None): + return np.zeros(2) + + def __array_wrap__(self, arr, context, return_scalar): + raise RuntimeError + + a = A() + assert_raises(RuntimeError, ncu.maximum, a, a) + assert_raises(RuntimeError, ncu.maximum.reduce, a) + + def test_failing_out_wrap(self): + + singleton = np.array([1.0]) + + class Ok(np.ndarray): + def __array_wrap__(self, obj, context, return_scalar): + return singleton + + class Bad(np.ndarray): + def __array_wrap__(self, obj, context, return_scalar): + raise RuntimeError + + ok = np.empty(1).view(Ok) + bad = np.empty(1).view(Bad) + # double-free (segfault) of "ok" if "bad" raises an exception + for i in range(10): + assert_raises(RuntimeError, ncu.frexp, 1, ok, bad) + + def test_none_wrap(self): + # Tests that issue #8507 is resolved. Previously, this would segfault + + class A: + def __array__(self, dtype=None, copy=None): + return np.zeros(1) + + def __array_wrap__(self, arr, context=None, return_scalar=False): + return None + + a = A() + assert_equal(ncu.maximum(a, a), None) + + def test_default_prepare(self): + + class with_wrap: + __array_priority__ = 10 + + def __array__(self, dtype=None, copy=None): + return np.zeros(1) + + def __array_wrap__(self, arr, context, return_scalar): + return arr + + a = with_wrap() + x = ncu.minimum(a, a) + assert_equal(x, np.zeros(1)) + assert_equal(type(x), np.ndarray) + + def test_array_too_many_args(self): + + class A: + def __array__(self, dtype, context, copy=None): + return np.zeros(1) + + a = A() + assert_raises_regex(TypeError, '2 required positional', np.sum, a) + + def test_ufunc_override(self): + # check override works even with instance with high priority. + class A: + def __array_ufunc__(self, func, method, *inputs, **kwargs): + return self, func, method, inputs, kwargs + + class MyNDArray(np.ndarray): + __array_priority__ = 100 + + a = A() + b = np.array([1]).view(MyNDArray) + res0 = np.multiply(a, b) + res1 = np.multiply(b, b, out=a) + + # self + assert_equal(res0[0], a) + assert_equal(res1[0], a) + assert_equal(res0[1], np.multiply) + assert_equal(res1[1], np.multiply) + assert_equal(res0[2], '__call__') + assert_equal(res1[2], '__call__') + assert_equal(res0[3], (a, b)) + assert_equal(res1[3], (b, b)) + assert_equal(res0[4], {}) + assert_equal(res1[4], {'out': (a,)}) + + def test_ufunc_override_mro(self): + + # Some multi arg functions for testing. + def tres_mul(a, b, c): + return a * b * c + + def quatro_mul(a, b, c, d): + return a * b * c * d + + # Make these into ufuncs. + three_mul_ufunc = np.frompyfunc(tres_mul, 3, 1) + four_mul_ufunc = np.frompyfunc(quatro_mul, 4, 1) + + class A: + def __array_ufunc__(self, func, method, *inputs, **kwargs): + return "A" + + class ASub(A): + def __array_ufunc__(self, func, method, *inputs, **kwargs): + return "ASub" + + class B: + def __array_ufunc__(self, func, method, *inputs, **kwargs): + return "B" + + class C: + def __init__(self): + self.count = 0 + + def __array_ufunc__(self, func, method, *inputs, **kwargs): + self.count += 1 + return NotImplemented + + class CSub(C): + def __array_ufunc__(self, func, method, *inputs, **kwargs): + self.count += 1 + return NotImplemented + + a = A() + a_sub = ASub() + b = B() + c = C() + + # Standard + res = np.multiply(a, a_sub) + assert_equal(res, "ASub") + res = np.multiply(a_sub, b) + assert_equal(res, "ASub") + + # With 1 NotImplemented + res = np.multiply(c, a) + assert_equal(res, "A") + assert_equal(c.count, 1) + # Check our counter works, so we can trust tests below. + res = np.multiply(c, a) + assert_equal(c.count, 2) + + # Both NotImplemented. + c = C() + c_sub = CSub() + assert_raises(TypeError, np.multiply, c, c_sub) + assert_equal(c.count, 1) + assert_equal(c_sub.count, 1) + c.count = c_sub.count = 0 + assert_raises(TypeError, np.multiply, c_sub, c) + assert_equal(c.count, 1) + assert_equal(c_sub.count, 1) + c.count = 0 + assert_raises(TypeError, np.multiply, c, c) + assert_equal(c.count, 1) + c.count = 0 + assert_raises(TypeError, np.multiply, 2, c) + assert_equal(c.count, 1) + + # Ternary testing. + assert_equal(three_mul_ufunc(a, 1, 2), "A") + assert_equal(three_mul_ufunc(1, a, 2), "A") + assert_equal(three_mul_ufunc(1, 2, a), "A") + + assert_equal(three_mul_ufunc(a, a, 6), "A") + assert_equal(three_mul_ufunc(a, 2, a), "A") + assert_equal(three_mul_ufunc(a, 2, b), "A") + assert_equal(three_mul_ufunc(a, 2, a_sub), "ASub") + assert_equal(three_mul_ufunc(a, a_sub, 3), "ASub") + c.count = 0 + assert_equal(three_mul_ufunc(c, a_sub, 3), "ASub") + assert_equal(c.count, 1) + c.count = 0 + assert_equal(three_mul_ufunc(1, a_sub, c), "ASub") + assert_equal(c.count, 0) + + c.count = 0 + assert_equal(three_mul_ufunc(a, b, c), "A") + assert_equal(c.count, 0) + c_sub.count = 0 + assert_equal(three_mul_ufunc(a, b, c_sub), "A") + assert_equal(c_sub.count, 0) + assert_equal(three_mul_ufunc(1, 2, b), "B") + + assert_raises(TypeError, three_mul_ufunc, 1, 2, c) + assert_raises(TypeError, three_mul_ufunc, c_sub, 2, c) + assert_raises(TypeError, three_mul_ufunc, c_sub, 2, 3) + + # Quaternary testing. + assert_equal(four_mul_ufunc(a, 1, 2, 3), "A") + assert_equal(four_mul_ufunc(1, a, 2, 3), "A") + assert_equal(four_mul_ufunc(1, 1, a, 3), "A") + assert_equal(four_mul_ufunc(1, 1, 2, a), "A") + + assert_equal(four_mul_ufunc(a, b, 2, 3), "A") + assert_equal(four_mul_ufunc(1, a, 2, b), "A") + assert_equal(four_mul_ufunc(b, 1, a, 3), "B") + assert_equal(four_mul_ufunc(a_sub, 1, 2, a), "ASub") + assert_equal(four_mul_ufunc(a, 1, 2, a_sub), "ASub") + + c = C() + c_sub = CSub() + assert_raises(TypeError, four_mul_ufunc, 1, 2, 3, c) + assert_equal(c.count, 1) + c.count = 0 + assert_raises(TypeError, four_mul_ufunc, 1, 2, c_sub, c) + assert_equal(c_sub.count, 1) + assert_equal(c.count, 1) + c2 = C() + c.count = c_sub.count = 0 + assert_raises(TypeError, four_mul_ufunc, 1, c, c_sub, c2) + assert_equal(c_sub.count, 1) + assert_equal(c.count, 1) + assert_equal(c2.count, 0) + c.count = c2.count = c_sub.count = 0 + assert_raises(TypeError, four_mul_ufunc, c2, c, c_sub, c) + assert_equal(c_sub.count, 1) + assert_equal(c.count, 0) + assert_equal(c2.count, 1) + + def test_ufunc_override_methods(self): + + class A: + def __array_ufunc__(self, ufunc, method, *inputs, **kwargs): + return self, ufunc, method, inputs, kwargs + + # __call__ + a = A() + with assert_raises(TypeError): + np.multiply.__call__(1, a, foo='bar', answer=42) + res = np.multiply.__call__(1, a, subok='bar', where=42) + assert_equal(res[0], a) + assert_equal(res[1], np.multiply) + assert_equal(res[2], '__call__') + assert_equal(res[3], (1, a)) + assert_equal(res[4], {'subok': 'bar', 'where': 42}) + + # __call__, wrong args + assert_raises(TypeError, np.multiply, a) + assert_raises(TypeError, np.multiply, a, a, a, a) + assert_raises(TypeError, np.multiply, a, a, sig='a', signature='a') + assert_raises(TypeError, ncu_tests.inner1d, a, a, axis=0, axes=[0, 0]) + + # reduce, positional args + res = np.multiply.reduce(a, 'axis0', 'dtype0', 'out0', 'keep0') + assert_equal(res[0], a) + assert_equal(res[1], np.multiply) + assert_equal(res[2], 'reduce') + assert_equal(res[3], (a,)) + assert_equal(res[4], {'dtype':'dtype0', + 'out': ('out0',), + 'keepdims': 'keep0', + 'axis': 'axis0'}) + + # reduce, kwargs + res = np.multiply.reduce(a, axis='axis0', dtype='dtype0', out='out0', + keepdims='keep0', initial='init0', + where='where0') + assert_equal(res[0], a) + assert_equal(res[1], np.multiply) + assert_equal(res[2], 'reduce') + assert_equal(res[3], (a,)) + assert_equal(res[4], {'dtype':'dtype0', + 'out': ('out0',), + 'keepdims': 'keep0', + 'axis': 'axis0', + 'initial': 'init0', + 'where': 'where0'}) + + # reduce, output equal to None removed, but not other explicit ones, + # even if they are at their default value. + res = np.multiply.reduce(a, 0, None, None, False) + assert_equal(res[4], {'axis': 0, 'dtype': None, 'keepdims': False}) + res = np.multiply.reduce(a, out=None, axis=0, keepdims=True) + assert_equal(res[4], {'axis': 0, 'keepdims': True}) + res = np.multiply.reduce(a, None, out=(None,), dtype=None) + assert_equal(res[4], {'axis': None, 'dtype': None}) + res = np.multiply.reduce(a, 0, None, None, False, 2, True) + assert_equal(res[4], {'axis': 0, 'dtype': None, 'keepdims': False, + 'initial': 2, 'where': True}) + # np._NoValue ignored for initial + res = np.multiply.reduce(a, 0, None, None, False, + np._NoValue, True) + assert_equal(res[4], {'axis': 0, 'dtype': None, 'keepdims': False, + 'where': True}) + # None kept for initial, True for where. + res = np.multiply.reduce(a, 0, None, None, False, None, True) + assert_equal(res[4], {'axis': 0, 'dtype': None, 'keepdims': False, + 'initial': None, 'where': True}) + + # reduce, wrong args + assert_raises(ValueError, np.multiply.reduce, a, out=()) + assert_raises(ValueError, np.multiply.reduce, a, out=('out0', 'out1')) + assert_raises(TypeError, np.multiply.reduce, a, 'axis0', axis='axis0') + + # accumulate, pos args + res = np.multiply.accumulate(a, 'axis0', 'dtype0', 'out0') + assert_equal(res[0], a) + assert_equal(res[1], np.multiply) + assert_equal(res[2], 'accumulate') + assert_equal(res[3], (a,)) + assert_equal(res[4], {'dtype':'dtype0', + 'out': ('out0',), + 'axis': 'axis0'}) + + # accumulate, kwargs + res = np.multiply.accumulate(a, axis='axis0', dtype='dtype0', + out='out0') + assert_equal(res[0], a) + assert_equal(res[1], np.multiply) + assert_equal(res[2], 'accumulate') + assert_equal(res[3], (a,)) + assert_equal(res[4], {'dtype':'dtype0', + 'out': ('out0',), + 'axis': 'axis0'}) + + # accumulate, output equal to None removed. + res = np.multiply.accumulate(a, 0, None, None) + assert_equal(res[4], {'axis': 0, 'dtype': None}) + res = np.multiply.accumulate(a, out=None, axis=0, dtype='dtype1') + assert_equal(res[4], {'axis': 0, 'dtype': 'dtype1'}) + res = np.multiply.accumulate(a, None, out=(None,), dtype=None) + assert_equal(res[4], {'axis': None, 'dtype': None}) + + # accumulate, wrong args + assert_raises(ValueError, np.multiply.accumulate, a, out=()) + assert_raises(ValueError, np.multiply.accumulate, a, + out=('out0', 'out1')) + assert_raises(TypeError, np.multiply.accumulate, a, + 'axis0', axis='axis0') + + # reduceat, pos args + res = np.multiply.reduceat(a, [4, 2], 'axis0', 'dtype0', 'out0') + assert_equal(res[0], a) + assert_equal(res[1], np.multiply) + assert_equal(res[2], 'reduceat') + assert_equal(res[3], (a, [4, 2])) + assert_equal(res[4], {'dtype':'dtype0', + 'out': ('out0',), + 'axis': 'axis0'}) + + # reduceat, kwargs + res = np.multiply.reduceat(a, [4, 2], axis='axis0', dtype='dtype0', + out='out0') + assert_equal(res[0], a) + assert_equal(res[1], np.multiply) + assert_equal(res[2], 'reduceat') + assert_equal(res[3], (a, [4, 2])) + assert_equal(res[4], {'dtype':'dtype0', + 'out': ('out0',), + 'axis': 'axis0'}) + + # reduceat, output equal to None removed. + res = np.multiply.reduceat(a, [4, 2], 0, None, None) + assert_equal(res[4], {'axis': 0, 'dtype': None}) + res = np.multiply.reduceat(a, [4, 2], axis=None, out=None, dtype='dt') + assert_equal(res[4], {'axis': None, 'dtype': 'dt'}) + res = np.multiply.reduceat(a, [4, 2], None, None, out=(None,)) + assert_equal(res[4], {'axis': None, 'dtype': None}) + + # reduceat, wrong args + assert_raises(ValueError, np.multiply.reduce, a, [4, 2], out=()) + assert_raises(ValueError, np.multiply.reduce, a, [4, 2], + out=('out0', 'out1')) + assert_raises(TypeError, np.multiply.reduce, a, [4, 2], + 'axis0', axis='axis0') + + # outer + res = np.multiply.outer(a, 42) + assert_equal(res[0], a) + assert_equal(res[1], np.multiply) + assert_equal(res[2], 'outer') + assert_equal(res[3], (a, 42)) + assert_equal(res[4], {}) + + # outer, wrong args + assert_raises(TypeError, np.multiply.outer, a) + assert_raises(TypeError, np.multiply.outer, a, a, a, a) + assert_raises(TypeError, np.multiply.outer, a, a, sig='a', signature='a') + + # at + res = np.multiply.at(a, [4, 2], 'b0') + assert_equal(res[0], a) + assert_equal(res[1], np.multiply) + assert_equal(res[2], 'at') + assert_equal(res[3], (a, [4, 2], 'b0')) + + # at, wrong args + assert_raises(TypeError, np.multiply.at, a) + assert_raises(TypeError, np.multiply.at, a, a, a, a) + + def test_ufunc_override_out(self): + + class A: + def __array_ufunc__(self, ufunc, method, *inputs, **kwargs): + return kwargs + + class B: + def __array_ufunc__(self, ufunc, method, *inputs, **kwargs): + return kwargs + + a = A() + b = B() + res0 = np.multiply(a, b, 'out_arg') + res1 = np.multiply(a, b, out='out_arg') + res2 = np.multiply(2, b, 'out_arg') + res3 = np.multiply(3, b, out='out_arg') + res4 = np.multiply(a, 4, 'out_arg') + res5 = np.multiply(a, 5, out='out_arg') + + assert_equal(res0['out'][0], 'out_arg') + assert_equal(res1['out'][0], 'out_arg') + assert_equal(res2['out'][0], 'out_arg') + assert_equal(res3['out'][0], 'out_arg') + assert_equal(res4['out'][0], 'out_arg') + assert_equal(res5['out'][0], 'out_arg') + + # ufuncs with multiple output modf and frexp. + res6 = np.modf(a, 'out0', 'out1') + res7 = np.frexp(a, 'out0', 'out1') + assert_equal(res6['out'][0], 'out0') + assert_equal(res6['out'][1], 'out1') + assert_equal(res7['out'][0], 'out0') + assert_equal(res7['out'][1], 'out1') + + # While we're at it, check that default output is never passed on. + assert_(np.sin(a, None) == {}) + assert_(np.sin(a, out=None) == {}) + assert_(np.sin(a, out=(None,)) == {}) + assert_(np.modf(a, None) == {}) + assert_(np.modf(a, None, None) == {}) + assert_(np.modf(a, out=(None, None)) == {}) + with assert_raises(TypeError): + # Out argument must be tuple, since there are multiple outputs. + np.modf(a, out=None) + + # don't give positional and output argument, or too many arguments. + # wrong number of arguments in the tuple is an error too. + assert_raises(TypeError, np.multiply, a, b, 'one', out='two') + assert_raises(TypeError, np.multiply, a, b, 'one', 'two') + assert_raises(ValueError, np.multiply, a, b, out=('one', 'two')) + assert_raises(TypeError, np.multiply, a, out=()) + assert_raises(TypeError, np.modf, a, 'one', out=('two', 'three')) + assert_raises(TypeError, np.modf, a, 'one', 'two', 'three') + assert_raises(ValueError, np.modf, a, out=('one', 'two', 'three')) + assert_raises(ValueError, np.modf, a, out=('one',)) + + def test_ufunc_override_where(self): + + class OverriddenArrayOld(np.ndarray): + + def _unwrap(self, objs): + cls = type(self) + result = [] + for obj in objs: + if isinstance(obj, cls): + obj = np.array(obj) + elif type(obj) != np.ndarray: + return NotImplemented + result.append(obj) + return result + + def __array_ufunc__(self, ufunc, method, *inputs, **kwargs): + + inputs = self._unwrap(inputs) + if inputs is NotImplemented: + return NotImplemented + + kwargs = kwargs.copy() + if "out" in kwargs: + kwargs["out"] = self._unwrap(kwargs["out"]) + if kwargs["out"] is NotImplemented: + return NotImplemented + + r = super().__array_ufunc__(ufunc, method, *inputs, **kwargs) + if r is not NotImplemented: + r = r.view(type(self)) + + return r + + class OverriddenArrayNew(OverriddenArrayOld): + def __array_ufunc__(self, ufunc, method, *inputs, **kwargs): + + kwargs = kwargs.copy() + if "where" in kwargs: + kwargs["where"] = self._unwrap((kwargs["where"], )) + if kwargs["where"] is NotImplemented: + return NotImplemented + else: + kwargs["where"] = kwargs["where"][0] + + r = super().__array_ufunc__(ufunc, method, *inputs, **kwargs) + if r is not NotImplemented: + r = r.view(type(self)) + + return r + + ufunc = np.negative + + array = np.array([1, 2, 3]) + where = np.array([True, False, True]) + expected = ufunc(array, where=where) + + with pytest.raises(TypeError): + ufunc(array, where=where.view(OverriddenArrayOld)) + + result_1 = ufunc( + array, + where=where.view(OverriddenArrayNew) + ) + assert isinstance(result_1, OverriddenArrayNew) + assert np.all(np.array(result_1) == expected, where=where) + + result_2 = ufunc( + array.view(OverriddenArrayNew), + where=where.view(OverriddenArrayNew) + ) + assert isinstance(result_2, OverriddenArrayNew) + assert np.all(np.array(result_2) == expected, where=where) + + def test_ufunc_override_exception(self): + + class A: + def __array_ufunc__(self, *a, **kwargs): + raise ValueError("oops") + + a = A() + assert_raises(ValueError, np.negative, 1, out=a) + assert_raises(ValueError, np.negative, a) + assert_raises(ValueError, np.divide, 1., a) + + def test_ufunc_override_not_implemented(self): + + class A: + def __array_ufunc__(self, *args, **kwargs): + return NotImplemented + + msg = ("operand type(s) all returned NotImplemented from " + "__array_ufunc__(, '__call__', <*>): 'A'") + with assert_raises_regex(TypeError, fnmatch.translate(msg)): + np.negative(A()) + + msg = ("operand type(s) all returned NotImplemented from " + "__array_ufunc__(, '__call__', <*>, , " + "out=(1,)): 'A', 'object', 'int'") + with assert_raises_regex(TypeError, fnmatch.translate(msg)): + np.add(A(), object(), out=1) + + def test_ufunc_override_disabled(self): + + class OptOut: + __array_ufunc__ = None + + opt_out = OptOut() + + # ufuncs always raise + msg = "operand 'OptOut' does not support ufuncs" + with assert_raises_regex(TypeError, msg): + np.add(opt_out, 1) + with assert_raises_regex(TypeError, msg): + np.add(1, opt_out) + with assert_raises_regex(TypeError, msg): + np.negative(opt_out) + + # opt-outs still hold even when other arguments have pathological + # __array_ufunc__ implementations + + class GreedyArray: + def __array_ufunc__(self, *args, **kwargs): + return self + + greedy = GreedyArray() + assert_(np.negative(greedy) is greedy) + with assert_raises_regex(TypeError, msg): + np.add(greedy, opt_out) + with assert_raises_regex(TypeError, msg): + np.add(greedy, 1, out=opt_out) + + def test_gufunc_override(self): + # gufunc are just ufunc instances, but follow a different path, + # so check __array_ufunc__ overrides them properly. + class A: + def __array_ufunc__(self, ufunc, method, *inputs, **kwargs): + return self, ufunc, method, inputs, kwargs + + inner1d = ncu_tests.inner1d + a = A() + res = inner1d(a, a) + assert_equal(res[0], a) + assert_equal(res[1], inner1d) + assert_equal(res[2], '__call__') + assert_equal(res[3], (a, a)) + assert_equal(res[4], {}) + + res = inner1d(1, 1, out=a) + assert_equal(res[0], a) + assert_equal(res[1], inner1d) + assert_equal(res[2], '__call__') + assert_equal(res[3], (1, 1)) + assert_equal(res[4], {'out': (a,)}) + + # wrong number of arguments in the tuple is an error too. + assert_raises(TypeError, inner1d, a, out='two') + assert_raises(TypeError, inner1d, a, a, 'one', out='two') + assert_raises(TypeError, inner1d, a, a, 'one', 'two') + assert_raises(ValueError, inner1d, a, a, out=('one', 'two')) + assert_raises(ValueError, inner1d, a, a, out=()) + + def test_ufunc_override_with_super(self): + # NOTE: this class is used in doc/source/user/basics.subclassing.rst + # if you make any changes here, do update it there too. + class A(np.ndarray): + def __array_ufunc__(self, ufunc, method, *inputs, out=None, **kwargs): + args = [] + in_no = [] + for i, input_ in enumerate(inputs): + if isinstance(input_, A): + in_no.append(i) + args.append(input_.view(np.ndarray)) + else: + args.append(input_) + + outputs = out + out_no = [] + if outputs: + out_args = [] + for j, output in enumerate(outputs): + if isinstance(output, A): + out_no.append(j) + out_args.append(output.view(np.ndarray)) + else: + out_args.append(output) + kwargs['out'] = tuple(out_args) + else: + outputs = (None,) * ufunc.nout + + info = {} + if in_no: + info['inputs'] = in_no + if out_no: + info['outputs'] = out_no + + results = super().__array_ufunc__(ufunc, method, + *args, **kwargs) + if results is NotImplemented: + return NotImplemented + + if method == 'at': + if isinstance(inputs[0], A): + inputs[0].info = info + return + + if ufunc.nout == 1: + results = (results,) + + results = tuple((np.asarray(result).view(A) + if output is None else output) + for result, output in zip(results, outputs)) + if results and isinstance(results[0], A): + results[0].info = info + + return results[0] if len(results) == 1 else results + + class B: + def __array_ufunc__(self, ufunc, method, *inputs, **kwargs): + if any(isinstance(input_, A) for input_ in inputs): + return "A!" + else: + return NotImplemented + + d = np.arange(5.) + # 1 input, 1 output + a = np.arange(5.).view(A) + b = np.sin(a) + check = np.sin(d) + assert_(np.all(check == b)) + assert_equal(b.info, {'inputs': [0]}) + b = np.sin(d, out=(a,)) + assert_(np.all(check == b)) + assert_equal(b.info, {'outputs': [0]}) + assert_(b is a) + a = np.arange(5.).view(A) + b = np.sin(a, out=a) + assert_(np.all(check == b)) + assert_equal(b.info, {'inputs': [0], 'outputs': [0]}) + + # 1 input, 2 outputs + a = np.arange(5.).view(A) + b1, b2 = np.modf(a) + assert_equal(b1.info, {'inputs': [0]}) + b1, b2 = np.modf(d, out=(None, a)) + assert_(b2 is a) + assert_equal(b1.info, {'outputs': [1]}) + a = np.arange(5.).view(A) + b = np.arange(5.).view(A) + c1, c2 = np.modf(a, out=(a, b)) + assert_(c1 is a) + assert_(c2 is b) + assert_equal(c1.info, {'inputs': [0], 'outputs': [0, 1]}) + + # 2 input, 1 output + a = np.arange(5.).view(A) + b = np.arange(5.).view(A) + c = np.add(a, b, out=a) + assert_(c is a) + assert_equal(c.info, {'inputs': [0, 1], 'outputs': [0]}) + # some tests with a non-ndarray subclass + a = np.arange(5.) + b = B() + assert_(a.__array_ufunc__(np.add, '__call__', a, b) is NotImplemented) + assert_(b.__array_ufunc__(np.add, '__call__', a, b) is NotImplemented) + assert_raises(TypeError, np.add, a, b) + a = a.view(A) + assert_(a.__array_ufunc__(np.add, '__call__', a, b) is NotImplemented) + assert_(b.__array_ufunc__(np.add, '__call__', a, b) == "A!") + assert_(np.add(a, b) == "A!") + # regression check for gh-9102 -- tests ufunc.reduce implicitly. + d = np.array([[1, 2, 3], [1, 2, 3]]) + a = d.view(A) + c = a.any() + check = d.any() + assert_equal(c, check) + assert_(c.info, {'inputs': [0]}) + c = a.max() + check = d.max() + assert_equal(c, check) + assert_(c.info, {'inputs': [0]}) + b = np.array(0).view(A) + c = a.max(out=b) + assert_equal(c, check) + assert_(c is b) + assert_(c.info, {'inputs': [0], 'outputs': [0]}) + check = a.max(axis=0) + b = np.zeros_like(check).view(A) + c = a.max(axis=0, out=b) + assert_equal(c, check) + assert_(c is b) + assert_(c.info, {'inputs': [0], 'outputs': [0]}) + # simple explicit tests of reduce, accumulate, reduceat + check = np.add.reduce(d, axis=1) + c = np.add.reduce(a, axis=1) + assert_equal(c, check) + assert_(c.info, {'inputs': [0]}) + b = np.zeros_like(c) + c = np.add.reduce(a, 1, None, b) + assert_equal(c, check) + assert_(c is b) + assert_(c.info, {'inputs': [0], 'outputs': [0]}) + check = np.add.accumulate(d, axis=0) + c = np.add.accumulate(a, axis=0) + assert_equal(c, check) + assert_(c.info, {'inputs': [0]}) + b = np.zeros_like(c) + c = np.add.accumulate(a, 0, None, b) + assert_equal(c, check) + assert_(c is b) + assert_(c.info, {'inputs': [0], 'outputs': [0]}) + indices = [0, 2, 1] + check = np.add.reduceat(d, indices, axis=1) + c = np.add.reduceat(a, indices, axis=1) + assert_equal(c, check) + assert_(c.info, {'inputs': [0]}) + b = np.zeros_like(c) + c = np.add.reduceat(a, indices, 1, None, b) + assert_equal(c, check) + assert_(c is b) + assert_(c.info, {'inputs': [0], 'outputs': [0]}) + # and a few tests for at + d = np.array([[1, 2, 3], [1, 2, 3]]) + check = d.copy() + a = d.copy().view(A) + np.add.at(check, ([0, 1], [0, 2]), 1.) + np.add.at(a, ([0, 1], [0, 2]), 1.) + assert_equal(a, check) + assert_(a.info, {'inputs': [0]}) + b = np.array(1.).view(A) + a = d.copy().view(A) + np.add.at(a, ([0, 1], [0, 2]), b) + assert_equal(a, check) + assert_(a.info, {'inputs': [0, 2]}) + + def test_array_ufunc_direct_call(self): + # This is mainly a regression test for gh-24023 (shouldn't segfault) + a = np.array(1) + with pytest.raises(TypeError): + a.__array_ufunc__() + + # No kwargs means kwargs may be NULL on the C-level + with pytest.raises(TypeError): + a.__array_ufunc__(1, 2) + + # And the same with a valid call: + res = a.__array_ufunc__(np.add, "__call__", a, a) + assert_array_equal(res, a + a) + +class TestChoose: + def test_mixed(self): + c = np.array([True, True]) + a = np.array([True, True]) + assert_equal(np.choose(c, (a, 1)), np.array([1, 1])) + + +class TestRationalFunctions: + def test_lcm(self): + self._test_lcm_inner(np.int16) + self._test_lcm_inner(np.uint16) + + def test_lcm_object(self): + self._test_lcm_inner(np.object_) + + def test_gcd(self): + self._test_gcd_inner(np.int16) + self._test_lcm_inner(np.uint16) + + def test_gcd_object(self): + self._test_gcd_inner(np.object_) + + def _test_lcm_inner(self, dtype): + # basic use + a = np.array([12, 120], dtype=dtype) + b = np.array([20, 200], dtype=dtype) + assert_equal(np.lcm(a, b), [60, 600]) + + if not issubclass(dtype, np.unsignedinteger): + # negatives are ignored + a = np.array([12, -12, 12, -12], dtype=dtype) + b = np.array([20, 20, -20, -20], dtype=dtype) + assert_equal(np.lcm(a, b), [60]*4) + + # reduce + a = np.array([3, 12, 20], dtype=dtype) + assert_equal(np.lcm.reduce([3, 12, 20]), 60) + + # broadcasting, and a test including 0 + a = np.arange(6).astype(dtype) + b = 20 + assert_equal(np.lcm(a, b), [0, 20, 20, 60, 20, 20]) + + def _test_gcd_inner(self, dtype): + # basic use + a = np.array([12, 120], dtype=dtype) + b = np.array([20, 200], dtype=dtype) + assert_equal(np.gcd(a, b), [4, 40]) + + if not issubclass(dtype, np.unsignedinteger): + # negatives are ignored + a = np.array([12, -12, 12, -12], dtype=dtype) + b = np.array([20, 20, -20, -20], dtype=dtype) + assert_equal(np.gcd(a, b), [4]*4) + + # reduce + a = np.array([15, 25, 35], dtype=dtype) + assert_equal(np.gcd.reduce(a), 5) + + # broadcasting, and a test including 0 + a = np.arange(6).astype(dtype) + b = 20 + assert_equal(np.gcd(a, b), [20, 1, 2, 1, 4, 5]) + + def test_lcm_overflow(self): + # verify that we don't overflow when a*b does overflow + big = np.int32(np.iinfo(np.int32).max // 11) + a = 2*big + b = 5*big + assert_equal(np.lcm(a, b), 10*big) + + def test_gcd_overflow(self): + for dtype in (np.int32, np.int64): + # verify that we don't overflow when taking abs(x) + # not relevant for lcm, where the result is unrepresentable anyway + a = dtype(np.iinfo(dtype).min) # negative power of two + q = -(a // 4) + assert_equal(np.gcd(a, q*3), q) + assert_equal(np.gcd(a, -q*3), q) + + def test_decimal(self): + from decimal import Decimal + a = np.array([1, 1, -1, -1]) * Decimal('0.20') + b = np.array([1, -1, 1, -1]) * Decimal('0.12') + + assert_equal(np.gcd(a, b), 4*[Decimal('0.04')]) + assert_equal(np.lcm(a, b), 4*[Decimal('0.60')]) + + def test_float(self): + # not well-defined on float due to rounding errors + assert_raises(TypeError, np.gcd, 0.3, 0.4) + assert_raises(TypeError, np.lcm, 0.3, 0.4) + + def test_huge_integers(self): + # Converting to an array first is a bit different as it means we + # have an explicit object dtype: + assert_equal(np.array(2**200), 2**200) + # Special promotion rules should ensure that this also works for + # two Python integers (even if slow). + # (We do this for comparisons, as the result is always bool and + # we also special case array comparisons with Python integers) + np.equal(2**200, 2**200) + + # But, we cannot do this when it would affect the result dtype: + with pytest.raises(OverflowError): + np.gcd(2**100, 3**100) + + # Asking for `object` explicitly is fine, though: + assert np.gcd(2**100, 3**100, dtype=object) == 1 + + # As of now, the below work, because it is using arrays (which + # will be object arrays) + a = np.array(2**100 * 3**5) + b = np.array([2**100 * 5**7, 2**50 * 3**10]) + assert_equal(np.gcd(a, b), [2**100, 2**50 * 3**5]) + assert_equal(np.lcm(a, b), [2**100 * 3**5 * 5**7, 2**100 * 3**10]) + + def test_inf_and_nan(self): + inf = np.array([np.inf], dtype=np.object_) + assert_raises(ValueError, np.gcd, inf, 1) + assert_raises(ValueError, np.gcd, 1, inf) + assert_raises(ValueError, np.gcd, np.nan, inf) + assert_raises(TypeError, np.gcd, 4, float(np.inf)) + + + +class TestRoundingFunctions: + + def test_object_direct(self): + """ test direct implementation of these magic methods """ + class C: + def __floor__(self): + return 1 + def __ceil__(self): + return 2 + def __trunc__(self): + return 3 + + arr = np.array([C(), C()]) + assert_equal(np.floor(arr), [1, 1]) + assert_equal(np.ceil(arr), [2, 2]) + assert_equal(np.trunc(arr), [3, 3]) + + def test_object_indirect(self): + """ test implementations via __float__ """ + class C: + def __float__(self): + return -2.5 + + arr = np.array([C(), C()]) + assert_equal(np.floor(arr), [-3, -3]) + assert_equal(np.ceil(arr), [-2, -2]) + with pytest.raises(TypeError): + np.trunc(arr) # consistent with math.trunc + + def test_fraction(self): + f = Fraction(-4, 3) + assert_equal(np.floor(f), -2) + assert_equal(np.ceil(f), -1) + assert_equal(np.trunc(f), -1) + + @pytest.mark.parametrize('func', [np.floor, np.ceil, np.trunc]) + @pytest.mark.parametrize('dtype', [np.bool, np.float64, np.float32, + np.int64, np.uint32]) + def test_output_dtype(self, func, dtype): + arr = np.array([-2, 0, 4, 8]).astype(dtype) + result = func(arr) + assert_equal(arr, result) + assert result.dtype == dtype + + +class TestComplexFunctions: + funcs = [np.arcsin, np.arccos, np.arctan, np.arcsinh, np.arccosh, + np.arctanh, np.sin, np.cos, np.tan, np.exp, + np.exp2, np.log, np.sqrt, np.log10, np.log2, + np.log1p] + + def test_it(self): + for f in self.funcs: + if f is np.arccosh: + x = 1.5 + else: + x = .5 + fr = f(x) + fz = f(complex(x)) + assert_almost_equal(fz.real, fr, err_msg='real part %s' % f) + assert_almost_equal(fz.imag, 0., err_msg='imag part %s' % f) + + @pytest.mark.xfail(IS_WASM, reason="doesn't work") + def test_precisions_consistent(self): + z = 1 + 1j + for f in self.funcs: + fcf = f(np.csingle(z)) + fcd = f(np.cdouble(z)) + fcl = f(np.clongdouble(z)) + assert_almost_equal(fcf, fcd, decimal=6, err_msg='fch-fcd %s' % f) + assert_almost_equal(fcl, fcd, decimal=15, err_msg='fch-fcl %s' % f) + + @pytest.mark.xfail(IS_WASM, reason="doesn't work") + def test_branch_cuts(self): + # check branch cuts and continuity on them + _check_branch_cut(np.log, -0.5, 1j, 1, -1, True) + _check_branch_cut(np.log2, -0.5, 1j, 1, -1, True) + _check_branch_cut(np.log10, -0.5, 1j, 1, -1, True) + _check_branch_cut(np.log1p, -1.5, 1j, 1, -1, True) + _check_branch_cut(np.sqrt, -0.5, 1j, 1, -1, True) + + _check_branch_cut(np.arcsin, [ -2, 2], [1j, 1j], 1, -1, True) + _check_branch_cut(np.arccos, [ -2, 2], [1j, 1j], 1, -1, True) + _check_branch_cut(np.arctan, [0-2j, 2j], [1, 1], -1, 1, True) + + _check_branch_cut(np.arcsinh, [0-2j, 2j], [1, 1], -1, 1, True) + _check_branch_cut(np.arccosh, [ -1, 0.5], [1j, 1j], 1, -1, True) + _check_branch_cut(np.arctanh, [ -2, 2], [1j, 1j], 1, -1, True) + + # check against bogus branch cuts: assert continuity between quadrants + _check_branch_cut(np.arcsin, [0-2j, 2j], [ 1, 1], 1, 1) + _check_branch_cut(np.arccos, [0-2j, 2j], [ 1, 1], 1, 1) + _check_branch_cut(np.arctan, [ -2, 2], [1j, 1j], 1, 1) + + _check_branch_cut(np.arcsinh, [ -2, 2, 0], [1j, 1j, 1], 1, 1) + _check_branch_cut(np.arccosh, [0-2j, 2j, 2], [1, 1, 1j], 1, 1) + _check_branch_cut(np.arctanh, [0-2j, 2j, 0], [1, 1, 1j], 1, 1) + + @pytest.mark.xfail(IS_WASM, reason="doesn't work") + def test_branch_cuts_complex64(self): + # check branch cuts and continuity on them + _check_branch_cut(np.log, -0.5, 1j, 1, -1, True, np.complex64) + _check_branch_cut(np.log2, -0.5, 1j, 1, -1, True, np.complex64) + _check_branch_cut(np.log10, -0.5, 1j, 1, -1, True, np.complex64) + _check_branch_cut(np.log1p, -1.5, 1j, 1, -1, True, np.complex64) + _check_branch_cut(np.sqrt, -0.5, 1j, 1, -1, True, np.complex64) + + _check_branch_cut(np.arcsin, [ -2, 2], [1j, 1j], 1, -1, True, np.complex64) + _check_branch_cut(np.arccos, [ -2, 2], [1j, 1j], 1, -1, True, np.complex64) + _check_branch_cut(np.arctan, [0-2j, 2j], [1, 1], -1, 1, True, np.complex64) + + _check_branch_cut(np.arcsinh, [0-2j, 2j], [1, 1], -1, 1, True, np.complex64) + _check_branch_cut(np.arccosh, [ -1, 0.5], [1j, 1j], 1, -1, True, np.complex64) + _check_branch_cut(np.arctanh, [ -2, 2], [1j, 1j], 1, -1, True, np.complex64) + + # check against bogus branch cuts: assert continuity between quadrants + _check_branch_cut(np.arcsin, [0-2j, 2j], [ 1, 1], 1, 1, False, np.complex64) + _check_branch_cut(np.arccos, [0-2j, 2j], [ 1, 1], 1, 1, False, np.complex64) + _check_branch_cut(np.arctan, [ -2, 2], [1j, 1j], 1, 1, False, np.complex64) + + _check_branch_cut(np.arcsinh, [ -2, 2, 0], [1j, 1j, 1], 1, 1, False, np.complex64) + _check_branch_cut(np.arccosh, [0-2j, 2j, 2], [1, 1, 1j], 1, 1, False, np.complex64) + _check_branch_cut(np.arctanh, [0-2j, 2j, 0], [1, 1, 1j], 1, 1, False, np.complex64) + + def test_against_cmath(self): + import cmath + + points = [-1-1j, -1+1j, +1-1j, +1+1j] + name_map = {'arcsin': 'asin', 'arccos': 'acos', 'arctan': 'atan', + 'arcsinh': 'asinh', 'arccosh': 'acosh', 'arctanh': 'atanh'} + atol = 4*np.finfo(complex).eps + for func in self.funcs: + fname = func.__name__.split('.')[-1] + cname = name_map.get(fname, fname) + try: + cfunc = getattr(cmath, cname) + except AttributeError: + continue + for p in points: + a = complex(func(np.complex128(p))) + b = cfunc(p) + assert_( + abs(a - b) < atol, + "%s %s: %s; cmath: %s" % (fname, p, a, b) + ) + + @pytest.mark.xfail( + # manylinux2014 uses glibc2.17 + _glibc_older_than("2.18"), + reason="Older glibc versions are imprecise (maybe passes with SIMD?)" + ) + @pytest.mark.xfail(IS_WASM, reason="doesn't work") + @pytest.mark.parametrize('dtype', [ + np.complex64, np.complex128, np.clongdouble + ]) + def test_loss_of_precision(self, dtype): + """Check loss of precision in complex arc* functions""" + if dtype is np.clongdouble and platform.machine() != 'x86_64': + # Failures on musllinux, aarch64, s390x, ppc64le (see gh-17554) + pytest.skip('Only works reliably for x86-64 and recent glibc') + + # Check against known-good functions + + info = np.finfo(dtype) + real_dtype = dtype(0.).real.dtype + eps = info.eps + + def check(x, rtol): + x = x.astype(real_dtype) + + z = x.astype(dtype) + d = np.absolute(np.arcsinh(x)/np.arcsinh(z).real - 1) + assert_(np.all(d < rtol), (np.argmax(d), x[np.argmax(d)], d.max(), + 'arcsinh')) + + z = (1j*x).astype(dtype) + d = np.absolute(np.arcsinh(x)/np.arcsin(z).imag - 1) + assert_(np.all(d < rtol), (np.argmax(d), x[np.argmax(d)], d.max(), + 'arcsin')) + + z = x.astype(dtype) + d = np.absolute(np.arctanh(x)/np.arctanh(z).real - 1) + assert_(np.all(d < rtol), (np.argmax(d), x[np.argmax(d)], d.max(), + 'arctanh')) + + z = (1j*x).astype(dtype) + d = np.absolute(np.arctanh(x)/np.arctan(z).imag - 1) + assert_(np.all(d < rtol), (np.argmax(d), x[np.argmax(d)], d.max(), + 'arctan')) + + # The switchover was chosen as 1e-3; hence there can be up to + # ~eps/1e-3 of relative cancellation error before it + + x_series = np.logspace(-20, -3.001, 200) + x_basic = np.logspace(-2.999, 0, 10, endpoint=False) + + if dtype is np.clongdouble: + if bad_arcsinh(): + pytest.skip("Trig functions of np.clongdouble values known " + "to be inaccurate on aarch64 and PPC for some " + "compilation configurations.") + # It's not guaranteed that the system-provided arc functions + # are accurate down to a few epsilons. (Eg. on Linux 64-bit) + # So, give more leeway for long complex tests here: + check(x_series, 50.0*eps) + else: + check(x_series, 2.1*eps) + check(x_basic, 2.0*eps/1e-3) + + # Check a few points + + z = np.array([1e-5*(1+1j)], dtype=dtype) + p = 9.999999999333333333e-6 + 1.000000000066666666e-5j + d = np.absolute(1-np.arctanh(z)/p) + assert_(np.all(d < 1e-15)) + + p = 1.0000000000333333333e-5 + 9.999999999666666667e-6j + d = np.absolute(1-np.arcsinh(z)/p) + assert_(np.all(d < 1e-15)) + + p = 9.999999999333333333e-6j + 1.000000000066666666e-5 + d = np.absolute(1-np.arctan(z)/p) + assert_(np.all(d < 1e-15)) + + p = 1.0000000000333333333e-5j + 9.999999999666666667e-6 + d = np.absolute(1-np.arcsin(z)/p) + assert_(np.all(d < 1e-15)) + + # Check continuity across switchover points + + def check(func, z0, d=1): + z0 = np.asarray(z0, dtype=dtype) + zp = z0 + abs(z0) * d * eps * 2 + zm = z0 - abs(z0) * d * eps * 2 + assert_(np.all(zp != zm), (zp, zm)) + + # NB: the cancellation error at the switchover is at least eps + good = (abs(func(zp) - func(zm)) < 2*eps) + assert_(np.all(good), (func, z0[~good])) + + for func in (np.arcsinh, np.arcsinh, np.arcsin, np.arctanh, np.arctan): + pts = [rp+1j*ip for rp in (-1e-3, 0, 1e-3) for ip in(-1e-3, 0, 1e-3) + if rp != 0 or ip != 0] + check(func, pts, 1) + check(func, pts, 1j) + check(func, pts, 1+1j) + + @np.errstate(all="ignore") + def test_promotion_corner_cases(self): + for func in self.funcs: + assert func(np.float16(1)).dtype == np.float16 + # Integer to low precision float promotion is a dubious choice: + assert func(np.uint8(1)).dtype == np.float16 + assert func(np.int16(1)).dtype == np.float32 + + +class TestAttributes: + def test_attributes(self): + add = ncu.add + assert_equal(add.__name__, 'add') + assert_(add.ntypes >= 18) # don't fail if types added + assert_('ii->i' in add.types) + assert_equal(add.nin, 2) + assert_equal(add.nout, 1) + assert_equal(add.identity, 0) + + def test_doc(self): + # don't bother checking the long list of kwargs, which are likely to + # change + assert_(ncu.add.__doc__.startswith( + "add(x1, x2, /, out=None, *, where=True")) + assert_(ncu.frexp.__doc__.startswith( + "frexp(x[, out1, out2], / [, out=(None, None)], *, where=True")) + + +class TestSubclass: + + def test_subclass_op(self): + + class simple(np.ndarray): + def __new__(subtype, shape): + self = np.ndarray.__new__(subtype, shape, dtype=object) + self.fill(0) + return self + + a = simple((3, 4)) + assert_equal(a+a, a) + + +class TestFrompyfunc: + + def test_identity(self): + def mul(a, b): + return a * b + + # with identity=value + mul_ufunc = np.frompyfunc(mul, nin=2, nout=1, identity=1) + assert_equal(mul_ufunc.reduce([2, 3, 4]), 24) + assert_equal(mul_ufunc.reduce(np.ones((2, 2)), axis=(0, 1)), 1) + assert_equal(mul_ufunc.reduce([]), 1) + + # with identity=None (reorderable) + mul_ufunc = np.frompyfunc(mul, nin=2, nout=1, identity=None) + assert_equal(mul_ufunc.reduce([2, 3, 4]), 24) + assert_equal(mul_ufunc.reduce(np.ones((2, 2)), axis=(0, 1)), 1) + assert_raises(ValueError, lambda: mul_ufunc.reduce([])) + + # with no identity (not reorderable) + mul_ufunc = np.frompyfunc(mul, nin=2, nout=1) + assert_equal(mul_ufunc.reduce([2, 3, 4]), 24) + assert_raises(ValueError, lambda: mul_ufunc.reduce(np.ones((2, 2)), axis=(0, 1))) + assert_raises(ValueError, lambda: mul_ufunc.reduce([])) + + +def _check_branch_cut(f, x0, dx, re_sign=1, im_sign=-1, sig_zero_ok=False, + dtype=complex): + """ + Check for a branch cut in a function. + + Assert that `x0` lies on a branch cut of function `f` and `f` is + continuous from the direction `dx`. + + Parameters + ---------- + f : func + Function to check + x0 : array-like + Point on branch cut + dx : array-like + Direction to check continuity in + re_sign, im_sign : {1, -1} + Change of sign of the real or imaginary part expected + sig_zero_ok : bool + Whether to check if the branch cut respects signed zero (if applicable) + dtype : dtype + Dtype to check (should be complex) + + """ + x0 = np.atleast_1d(x0).astype(dtype) + dx = np.atleast_1d(dx).astype(dtype) + + if np.dtype(dtype).char == 'F': + scale = np.finfo(dtype).eps * 1e2 + atol = np.float32(1e-2) + else: + scale = np.finfo(dtype).eps * 1e3 + atol = 1e-4 + + y0 = f(x0) + yp = f(x0 + dx*scale*np.absolute(x0)/np.absolute(dx)) + ym = f(x0 - dx*scale*np.absolute(x0)/np.absolute(dx)) + + assert_(np.all(np.absolute(y0.real - yp.real) < atol), (y0, yp)) + assert_(np.all(np.absolute(y0.imag - yp.imag) < atol), (y0, yp)) + assert_(np.all(np.absolute(y0.real - ym.real*re_sign) < atol), (y0, ym)) + assert_(np.all(np.absolute(y0.imag - ym.imag*im_sign) < atol), (y0, ym)) + + if sig_zero_ok: + # check that signed zeros also work as a displacement + jr = (x0.real == 0) & (dx.real != 0) + ji = (x0.imag == 0) & (dx.imag != 0) + if np.any(jr): + x = x0[jr] + x.real = ncu.NZERO + ym = f(x) + assert_(np.all(np.absolute(y0[jr].real - ym.real*re_sign) < atol), (y0[jr], ym)) + assert_(np.all(np.absolute(y0[jr].imag - ym.imag*im_sign) < atol), (y0[jr], ym)) + + if np.any(ji): + x = x0[ji] + x.imag = ncu.NZERO + ym = f(x) + assert_(np.all(np.absolute(y0[ji].real - ym.real*re_sign) < atol), (y0[ji], ym)) + assert_(np.all(np.absolute(y0[ji].imag - ym.imag*im_sign) < atol), (y0[ji], ym)) + +def test_copysign(): + assert_(np.copysign(1, -1) == -1) + with np.errstate(divide="ignore"): + assert_(1 / np.copysign(0, -1) < 0) + assert_(1 / np.copysign(0, 1) > 0) + assert_(np.signbit(np.copysign(np.nan, -1))) + assert_(not np.signbit(np.copysign(np.nan, 1))) + +def _test_nextafter(t): + one = t(1) + two = t(2) + zero = t(0) + eps = np.finfo(t).eps + assert_(np.nextafter(one, two) - one == eps) + assert_(np.nextafter(one, zero) - one < 0) + assert_(np.isnan(np.nextafter(np.nan, one))) + assert_(np.isnan(np.nextafter(one, np.nan))) + assert_(np.nextafter(one, one) == one) + +def test_nextafter(): + return _test_nextafter(np.float64) + + +def test_nextafterf(): + return _test_nextafter(np.float32) + + +@pytest.mark.skipif(np.finfo(np.double) == np.finfo(np.longdouble), + reason="long double is same as double") +@pytest.mark.xfail(condition=platform.machine().startswith("ppc64"), + reason="IBM double double") +def test_nextafterl(): + return _test_nextafter(np.longdouble) + + +def test_nextafter_0(): + for t, direction in itertools.product(np._core.sctypes['float'], (1, -1)): + # The value of tiny for double double is NaN, so we need to pass the + # assert + with suppress_warnings() as sup: + sup.filter(UserWarning) + if not np.isnan(np.finfo(t).tiny): + tiny = np.finfo(t).tiny + assert_( + 0. < direction * np.nextafter(t(0), t(direction)) < tiny) + assert_equal(np.nextafter(t(0), t(direction)) / t(2.1), direction * 0.0) + +def _test_spacing(t): + one = t(1) + eps = np.finfo(t).eps + nan = t(np.nan) + inf = t(np.inf) + with np.errstate(invalid='ignore'): + assert_equal(np.spacing(one), eps) + assert_(np.isnan(np.spacing(nan))) + assert_(np.isnan(np.spacing(inf))) + assert_(np.isnan(np.spacing(-inf))) + assert_(np.spacing(t(1e30)) != 0) + +def test_spacing(): + return _test_spacing(np.float64) + +def test_spacingf(): + return _test_spacing(np.float32) + + +@pytest.mark.skipif(np.finfo(np.double) == np.finfo(np.longdouble), + reason="long double is same as double") +@pytest.mark.xfail(condition=platform.machine().startswith("ppc64"), + reason="IBM double double") +def test_spacingl(): + return _test_spacing(np.longdouble) + +def test_spacing_gfortran(): + # Reference from this fortran file, built with gfortran 4.3.3 on linux + # 32bits: + # PROGRAM test_spacing + # INTEGER, PARAMETER :: SGL = SELECTED_REAL_KIND(p=6, r=37) + # INTEGER, PARAMETER :: DBL = SELECTED_REAL_KIND(p=13, r=200) + # + # WRITE(*,*) spacing(0.00001_DBL) + # WRITE(*,*) spacing(1.0_DBL) + # WRITE(*,*) spacing(1000._DBL) + # WRITE(*,*) spacing(10500._DBL) + # + # WRITE(*,*) spacing(0.00001_SGL) + # WRITE(*,*) spacing(1.0_SGL) + # WRITE(*,*) spacing(1000._SGL) + # WRITE(*,*) spacing(10500._SGL) + # END PROGRAM + ref = {np.float64: [1.69406589450860068E-021, + 2.22044604925031308E-016, + 1.13686837721616030E-013, + 1.81898940354585648E-012], + np.float32: [9.09494702E-13, + 1.19209290E-07, + 6.10351563E-05, + 9.76562500E-04]} + + for dt, dec_ in zip([np.float32, np.float64], (10, 20)): + x = np.array([1e-5, 1, 1000, 10500], dtype=dt) + assert_array_almost_equal(np.spacing(x), ref[dt], decimal=dec_) + +def test_nextafter_vs_spacing(): + # XXX: spacing does not handle long double yet + for t in [np.float32, np.float64]: + for _f in [1, 1e-5, 1000]: + f = t(_f) + f1 = t(_f + 1) + assert_(np.nextafter(f, f1) - f == np.spacing(f)) + +def test_pos_nan(): + """Check np.nan is a positive nan.""" + assert_(np.signbit(np.nan) == 0) + +def test_reduceat(): + """Test bug in reduceat when structured arrays are not copied.""" + db = np.dtype([('name', 'S11'), ('time', np.int64), ('value', np.float32)]) + a = np.empty([100], dtype=db) + a['name'] = 'Simple' + a['time'] = 10 + a['value'] = 100 + indx = [0, 7, 15, 25] + + h2 = [] + val1 = indx[0] + for val2 in indx[1:]: + h2.append(np.add.reduce(a['value'][val1:val2])) + val1 = val2 + h2.append(np.add.reduce(a['value'][val1:])) + h2 = np.array(h2) + + # test buffered -- this should work + h1 = np.add.reduceat(a['value'], indx) + assert_array_almost_equal(h1, h2) + + # This is when the error occurs. + # test no buffer + np.setbufsize(32) + h1 = np.add.reduceat(a['value'], indx) + np.setbufsize(ncu.UFUNC_BUFSIZE_DEFAULT) + assert_array_almost_equal(h1, h2) + +def test_reduceat_empty(): + """Reduceat should work with empty arrays""" + indices = np.array([], 'i4') + x = np.array([], 'f8') + result = np.add.reduceat(x, indices) + assert_equal(result.dtype, x.dtype) + assert_equal(result.shape, (0,)) + # Another case with a slightly different zero-sized shape + x = np.ones((5, 2)) + result = np.add.reduceat(x, [], axis=0) + assert_equal(result.dtype, x.dtype) + assert_equal(result.shape, (0, 2)) + result = np.add.reduceat(x, [], axis=1) + assert_equal(result.dtype, x.dtype) + assert_equal(result.shape, (5, 0)) + +def test_complex_nan_comparisons(): + nans = [complex(np.nan, 0), complex(0, np.nan), complex(np.nan, np.nan)] + fins = [complex(1, 0), complex(-1, 0), complex(0, 1), complex(0, -1), + complex(1, 1), complex(-1, -1), complex(0, 0)] + + with np.errstate(invalid='ignore'): + for x in nans + fins: + x = np.array([x]) + for y in nans + fins: + y = np.array([y]) + + if np.isfinite(x) and np.isfinite(y): + continue + + assert_equal(x < y, False, err_msg="%r < %r" % (x, y)) + assert_equal(x > y, False, err_msg="%r > %r" % (x, y)) + assert_equal(x <= y, False, err_msg="%r <= %r" % (x, y)) + assert_equal(x >= y, False, err_msg="%r >= %r" % (x, y)) + assert_equal(x == y, False, err_msg="%r == %r" % (x, y)) + + +def test_rint_big_int(): + # np.rint bug for large integer values on Windows 32-bit and MKL + # https://github.com/numpy/numpy/issues/6685 + val = 4607998452777363968 + # This is exactly representable in floating point + assert_equal(val, int(float(val))) + # Rint should not change the value + assert_equal(val, np.rint(val)) + + +@pytest.mark.parametrize('ftype', [np.float32, np.float64]) +def test_memoverlap_accumulate(ftype): + # Reproduces bug https://github.com/numpy/numpy/issues/15597 + arr = np.array([0.61, 0.60, 0.77, 0.41, 0.19], dtype=ftype) + out_max = np.array([0.61, 0.61, 0.77, 0.77, 0.77], dtype=ftype) + out_min = np.array([0.61, 0.60, 0.60, 0.41, 0.19], dtype=ftype) + assert_equal(np.maximum.accumulate(arr), out_max) + assert_equal(np.minimum.accumulate(arr), out_min) + +@pytest.mark.parametrize("ufunc, dtype", [ + (ufunc, t[0]) + for ufunc in UFUNCS_BINARY_ACC + for t in ufunc.types + if t[-1] == '?' and t[0] not in 'DFGMmO' +]) +def test_memoverlap_accumulate_cmp(ufunc, dtype): + if ufunc.signature: + pytest.skip('For generic signatures only') + for size in (2, 8, 32, 64, 128, 256): + arr = np.array([0, 1, 1]*size, dtype=dtype) + acc = ufunc.accumulate(arr, dtype='?') + acc_u8 = acc.view(np.uint8) + exp = np.array(list(itertools.accumulate(arr, ufunc)), dtype=np.uint8) + assert_equal(exp, acc_u8) + +@pytest.mark.parametrize("ufunc, dtype", [ + (ufunc, t[0]) + for ufunc in UFUNCS_BINARY_ACC + for t in ufunc.types + if t[0] == t[1] and t[0] == t[-1] and t[0] not in 'DFGMmO?' +]) +def test_memoverlap_accumulate_symmetric(ufunc, dtype): + if ufunc.signature: + pytest.skip('For generic signatures only') + with np.errstate(all='ignore'): + for size in (2, 8, 32, 64, 128, 256): + arr = np.array([0, 1, 2]*size).astype(dtype) + acc = ufunc.accumulate(arr, dtype=dtype) + exp = np.array(list(itertools.accumulate(arr, ufunc)), dtype=dtype) + assert_equal(exp, acc) + +def test_signaling_nan_exceptions(): + with assert_no_warnings(): + a = np.ndarray(shape=(), dtype='float32', buffer=b'\x00\xe0\xbf\xff') + np.isnan(a) + +@pytest.mark.parametrize("arr", [ + np.arange(2), + np.matrix([0, 1]), + np.matrix([[0, 1], [2, 5]]), + ]) +def test_outer_subclass_preserve(arr): + # for gh-8661 + class foo(np.ndarray): pass + actual = np.multiply.outer(arr.view(foo), arr.view(foo)) + assert actual.__class__.__name__ == 'foo' + +def test_outer_bad_subclass(): + class BadArr1(np.ndarray): + def __array_finalize__(self, obj): + # The outer call reshapes to 3 dims, try to do a bad reshape. + if self.ndim == 3: + self.shape = self.shape + (1,) + + class BadArr2(np.ndarray): + def __array_finalize__(self, obj): + if isinstance(obj, BadArr2): + # outer inserts 1-sized dims. In that case disturb them. + if self.shape[-1] == 1: + self.shape = self.shape[::-1] + + for cls in [BadArr1, BadArr2]: + arr = np.ones((2, 3)).view(cls) + with assert_raises(TypeError) as a: + # The first array gets reshaped (not the second one) + np.add.outer(arr, [1, 2]) + + # This actually works, since we only see the reshaping error: + arr = np.ones((2, 3)).view(cls) + assert type(np.add.outer([1, 2], arr)) is cls + +def test_outer_exceeds_maxdims(): + deep = np.ones((1,) * 33) + with assert_raises(ValueError): + np.add.outer(deep, deep) + +def test_bad_legacy_ufunc_silent_errors(): + # legacy ufuncs can't report errors and NumPy can't check if the GIL + # is released. So NumPy has to check after the GIL is released just to + # cover all bases. `np.power` uses/used to use this. + arr = np.arange(3).astype(np.float64) + + with pytest.raises(RuntimeError, match=r"How unexpected :\)!"): + ncu_tests.always_error(arr, arr) + + with pytest.raises(RuntimeError, match=r"How unexpected :\)!"): + # not contiguous means the fast-path cannot be taken + non_contig = arr.repeat(20).reshape(-1, 6)[:, ::2] + ncu_tests.always_error(non_contig, arr) + + with pytest.raises(RuntimeError, match=r"How unexpected :\)!"): + ncu_tests.always_error.outer(arr, arr) + + with pytest.raises(RuntimeError, match=r"How unexpected :\)!"): + ncu_tests.always_error.reduce(arr) + + with pytest.raises(RuntimeError, match=r"How unexpected :\)!"): + ncu_tests.always_error.reduceat(arr, [0, 1]) + + with pytest.raises(RuntimeError, match=r"How unexpected :\)!"): + ncu_tests.always_error.accumulate(arr) + + with pytest.raises(RuntimeError, match=r"How unexpected :\)!"): + ncu_tests.always_error.at(arr, [0, 1, 2], arr) + + +@pytest.mark.parametrize('x1', [np.arange(3.0), [0.0, 1.0, 2.0]]) +def test_bad_legacy_gufunc_silent_errors(x1): + # Verify that an exception raised in a gufunc loop propagates correctly. + # The signature of always_error_gufunc is '(i),()->()'. + with pytest.raises(RuntimeError, match=r"How unexpected :\)!"): + ncu_tests.always_error_gufunc(x1, 0.0) + + +class TestAddDocstring: + @pytest.mark.skipif(sys.flags.optimize == 2, reason="Python running -OO") + @pytest.mark.skipif(IS_PYPY, reason="PyPy does not modify tp_doc") + def test_add_same_docstring(self): + # test for attributes (which are C-level defined) + ncu.add_docstring(np.ndarray.flat, np.ndarray.flat.__doc__) + + # And typical functions: + def func(): + """docstring""" + return + + ncu.add_docstring(func, func.__doc__) + + @pytest.mark.skipif(sys.flags.optimize == 2, reason="Python running -OO") + def test_different_docstring_fails(self): + # test for attributes (which are C-level defined) + with assert_raises(RuntimeError): + ncu.add_docstring(np.ndarray.flat, "different docstring") + + # And typical functions: + def func(): + """docstring""" + return + + with assert_raises(RuntimeError): + ncu.add_docstring(func, "different docstring") + + +class TestAdd_newdoc_ufunc: + def test_ufunc_arg(self): + assert_raises(TypeError, ncu._add_newdoc_ufunc, 2, "blah") + assert_raises(ValueError, ncu._add_newdoc_ufunc, np.add, "blah") + + def test_string_arg(self): + assert_raises(TypeError, ncu._add_newdoc_ufunc, np.add, 3) diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/test_umath_accuracy.py b/venv/lib/python3.12/site-packages/numpy/_core/tests/test_umath_accuracy.py new file mode 100644 index 00000000..493c7d6f --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/tests/test_umath_accuracy.py @@ -0,0 +1,119 @@ +import numpy as np +import os +from os import path +import sys +import pytest +from ctypes import c_longlong, c_double, c_float, c_int, cast, pointer, POINTER +from numpy.testing import assert_array_max_ulp +from numpy.testing._private.utils import _glibc_older_than +from numpy._core._multiarray_umath import __cpu_features__ + +UNARY_UFUNCS = [obj for obj in np._core.umath.__dict__.values() if + isinstance(obj, np.ufunc)] +UNARY_OBJECT_UFUNCS = [uf for uf in UNARY_UFUNCS if "O->O" in uf.types] + +# Remove functions that do not support `floats` +UNARY_OBJECT_UFUNCS.remove(getattr(np, 'invert')) +UNARY_OBJECT_UFUNCS.remove(getattr(np, 'bitwise_count')) + +IS_AVX = __cpu_features__.get('AVX512F', False) or \ + (__cpu_features__.get('FMA3', False) and __cpu_features__.get('AVX2', False)) + +IS_AVX512FP16 = __cpu_features__.get('AVX512FP16', False) + +# only run on linux with AVX, also avoid old glibc (numpy/numpy#20448). +runtest = (sys.platform.startswith('linux') + and IS_AVX and not _glibc_older_than("2.17")) +platform_skip = pytest.mark.skipif(not runtest, + reason="avoid testing inconsistent platform " + "library implementations") + +# convert string to hex function taken from: +# https://stackoverflow.com/questions/1592158/convert-hex-to-float # +def convert(s, datatype="np.float32"): + i = int(s, 16) # convert from hex to a Python int + if (datatype == "np.float64"): + cp = pointer(c_longlong(i)) # make this into a c long long integer + fp = cast(cp, POINTER(c_double)) # cast the int pointer to a double pointer + else: + cp = pointer(c_int(i)) # make this into a c integer + fp = cast(cp, POINTER(c_float)) # cast the int pointer to a float pointer + + return fp.contents.value # dereference the pointer, get the float + +str_to_float = np.vectorize(convert) + +class TestAccuracy: + @platform_skip + def test_validate_transcendentals(self): + with np.errstate(all='ignore'): + data_dir = path.join(path.dirname(__file__), 'data') + files = os.listdir(data_dir) + files = list(filter(lambda f: f.endswith('.csv'), files)) + for filename in files: + filepath = path.join(data_dir, filename) + with open(filepath) as fid: + file_without_comments = (r for r in fid if not r[0] in ('$', '#')) + data = np.genfromtxt(file_without_comments, + dtype=('|S39','|S39','|S39',int), + names=('type','input','output','ulperr'), + delimiter=',', + skip_header=1) + npname = path.splitext(filename)[0].split('-')[3] + npfunc = getattr(np, npname) + for datatype in np.unique(data['type']): + data_subset = data[data['type'] == datatype] + inval = np.array(str_to_float(data_subset['input'].astype(str), data_subset['type'].astype(str)), dtype=eval(datatype)) + outval = np.array(str_to_float(data_subset['output'].astype(str), data_subset['type'].astype(str)), dtype=eval(datatype)) + perm = np.random.permutation(len(inval)) + inval = inval[perm] + outval = outval[perm] + maxulperr = data_subset['ulperr'].max() + assert_array_max_ulp(npfunc(inval), outval, maxulperr) + + @pytest.mark.skipif(IS_AVX512FP16, + reason = "SVML FP16 have slightly higher ULP errors") + @pytest.mark.parametrize("ufunc", UNARY_OBJECT_UFUNCS) + def test_validate_fp16_transcendentals(self, ufunc): + with np.errstate(all='ignore'): + arr = np.arange(65536, dtype=np.int16) + datafp16 = np.frombuffer(arr.tobytes(), dtype=np.float16) + datafp32 = datafp16.astype(np.float32) + assert_array_max_ulp(ufunc(datafp16), ufunc(datafp32), + maxulp=1, dtype=np.float16) + + @pytest.mark.skipif(not IS_AVX512FP16, + reason="lower ULP only apply for SVML FP16") + def test_validate_svml_fp16(self): + max_ulp_err = { + "arccos": 2.54, + "arccosh": 2.09, + "arcsin": 3.06, + "arcsinh": 1.51, + "arctan": 2.61, + "arctanh": 1.88, + "cbrt": 1.57, + "cos": 1.43, + "cosh": 1.33, + "exp2": 1.33, + "exp": 1.27, + "expm1": 0.53, + "log": 1.80, + "log10": 1.27, + "log1p": 1.88, + "log2": 1.80, + "sin": 1.88, + "sinh": 2.05, + "tan": 2.26, + "tanh": 3.00, + } + + with np.errstate(all='ignore'): + arr = np.arange(65536, dtype=np.int16) + datafp16 = np.frombuffer(arr.tobytes(), dtype=np.float16) + datafp32 = datafp16.astype(np.float32) + for func in max_ulp_err: + ufunc = getattr(np, func) + ulp = np.ceil(max_ulp_err[func]) + assert_array_max_ulp(ufunc(datafp16), ufunc(datafp32), + maxulp=ulp, dtype=np.float16) diff --git a/venv/lib/python3.12/site-packages/numpy/_core/tests/test_umath_complex.py b/venv/lib/python3.12/site-packages/numpy/_core/tests/test_umath_complex.py new file mode 100644 index 00000000..cc54c16d --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_core/tests/test_umath_complex.py @@ -0,0 +1,622 @@ +import sys +import platform +import pytest + +import numpy as np +# import the c-extension module directly since _arg is not exported via umath +import numpy._core._multiarray_umath as ncu +from numpy.testing import ( + assert_raises, assert_equal, assert_array_equal, assert_almost_equal, assert_array_max_ulp + ) + +# TODO: branch cuts (use Pauli code) +# TODO: conj 'symmetry' +# TODO: FPU exceptions + +# At least on Windows the results of many complex functions are not conforming +# to the C99 standard. See ticket 1574. +# Ditto for Solaris (ticket 1642) and OS X on PowerPC. +#FIXME: this will probably change when we require full C99 compatibility +with np.errstate(all='ignore'): + functions_seem_flaky = ((np.exp(complex(np.inf, 0)).imag != 0) + or (np.log(complex(ncu.NZERO, 0)).imag != np.pi)) +# TODO: replace with a check on whether platform-provided C99 funcs are used +xfail_complex_tests = (not sys.platform.startswith('linux') or functions_seem_flaky) + +# TODO This can be xfail when the generator functions are got rid of. +platform_skip = pytest.mark.skipif(xfail_complex_tests, + reason="Inadequate C99 complex support") + + + +class TestCexp: + def test_simple(self): + check = check_complex_value + f = np.exp + + check(f, 1, 0, np.exp(1), 0, False) + check(f, 0, 1, np.cos(1), np.sin(1), False) + + ref = np.exp(1) * complex(np.cos(1), np.sin(1)) + check(f, 1, 1, ref.real, ref.imag, False) + + @platform_skip + def test_special_values(self): + # C99: Section G 6.3.1 + + check = check_complex_value + f = np.exp + + # cexp(+-0 + 0i) is 1 + 0i + check(f, ncu.PZERO, 0, 1, 0, False) + check(f, ncu.NZERO, 0, 1, 0, False) + + # cexp(x + infi) is nan + nani for finite x and raises 'invalid' FPU + # exception + check(f, 1, np.inf, np.nan, np.nan) + check(f, -1, np.inf, np.nan, np.nan) + check(f, 0, np.inf, np.nan, np.nan) + + # cexp(inf + 0i) is inf + 0i + check(f, np.inf, 0, np.inf, 0) + + # cexp(-inf + yi) is +0 * (cos(y) + i sin(y)) for finite y + check(f, -np.inf, 1, ncu.PZERO, ncu.PZERO) + check(f, -np.inf, 0.75 * np.pi, ncu.NZERO, ncu.PZERO) + + # cexp(inf + yi) is +inf * (cos(y) + i sin(y)) for finite y + check(f, np.inf, 1, np.inf, np.inf) + check(f, np.inf, 0.75 * np.pi, -np.inf, np.inf) + + # cexp(-inf + inf i) is +-0 +- 0i (signs unspecified) + def _check_ninf_inf(dummy): + msgform = "cexp(-inf, inf) is (%f, %f), expected (+-0, +-0)" + with np.errstate(invalid='ignore'): + z = f(np.array(complex(-np.inf, np.inf))) + if z.real != 0 or z.imag != 0: + raise AssertionError(msgform % (z.real, z.imag)) + + _check_ninf_inf(None) + + # cexp(inf + inf i) is +-inf + NaNi and raised invalid FPU ex. + def _check_inf_inf(dummy): + msgform = "cexp(inf, inf) is (%f, %f), expected (+-inf, nan)" + with np.errstate(invalid='ignore'): + z = f(np.array(complex(np.inf, np.inf))) + if not np.isinf(z.real) or not np.isnan(z.imag): + raise AssertionError(msgform % (z.real, z.imag)) + + _check_inf_inf(None) + + # cexp(-inf + nan i) is +-0 +- 0i + def _check_ninf_nan(dummy): + msgform = "cexp(-inf, nan) is (%f, %f), expected (+-0, +-0)" + with np.errstate(invalid='ignore'): + z = f(np.array(complex(-np.inf, np.nan))) + if z.real != 0 or z.imag != 0: + raise AssertionError(msgform % (z.real, z.imag)) + + _check_ninf_nan(None) + + # cexp(inf + nan i) is +-inf + nan + def _check_inf_nan(dummy): + msgform = "cexp(-inf, nan) is (%f, %f), expected (+-inf, nan)" + with np.errstate(invalid='ignore'): + z = f(np.array(complex(np.inf, np.nan))) + if not np.isinf(z.real) or not np.isnan(z.imag): + raise AssertionError(msgform % (z.real, z.imag)) + + _check_inf_nan(None) + + # cexp(nan + yi) is nan + nani for y != 0 (optional: raises invalid FPU + # ex) + check(f, np.nan, 1, np.nan, np.nan) + check(f, np.nan, -1, np.nan, np.nan) + + check(f, np.nan, np.inf, np.nan, np.nan) + check(f, np.nan, -np.inf, np.nan, np.nan) + + # cexp(nan + nani) is nan + nani + check(f, np.nan, np.nan, np.nan, np.nan) + + # TODO This can be xfail when the generator functions are got rid of. + @pytest.mark.skip(reason="cexp(nan + 0I) is wrong on most platforms") + def test_special_values2(self): + # XXX: most implementations get it wrong here (including glibc <= 2.10) + # cexp(nan + 0i) is nan + 0i + check = check_complex_value + f = np.exp + + check(f, np.nan, 0, np.nan, 0) + +class TestClog: + def test_simple(self): + x = np.array([1+0j, 1+2j]) + y_r = np.log(np.abs(x)) + 1j * np.angle(x) + y = np.log(x) + assert_almost_equal(y, y_r) + + @platform_skip + @pytest.mark.skipif(platform.machine() == "armv5tel", reason="See gh-413.") + def test_special_values(self): + xl = [] + yl = [] + + # From C99 std (Sec 6.3.2) + # XXX: check exceptions raised + # --- raise for invalid fails. + + # clog(-0 + i0) returns -inf + i pi and raises the 'divide-by-zero' + # floating-point exception. + with np.errstate(divide='raise'): + x = np.array([ncu.NZERO], dtype=complex) + y = complex(-np.inf, np.pi) + assert_raises(FloatingPointError, np.log, x) + with np.errstate(divide='ignore'): + assert_almost_equal(np.log(x), y) + + xl.append(x) + yl.append(y) + + # clog(+0 + i0) returns -inf + i0 and raises the 'divide-by-zero' + # floating-point exception. + with np.errstate(divide='raise'): + x = np.array([0], dtype=complex) + y = complex(-np.inf, 0) + assert_raises(FloatingPointError, np.log, x) + with np.errstate(divide='ignore'): + assert_almost_equal(np.log(x), y) + + xl.append(x) + yl.append(y) + + # clog(x + i inf returns +inf + i pi /2, for finite x. + x = np.array([complex(1, np.inf)], dtype=complex) + y = complex(np.inf, 0.5 * np.pi) + assert_almost_equal(np.log(x), y) + xl.append(x) + yl.append(y) + + x = np.array([complex(-1, np.inf)], dtype=complex) + assert_almost_equal(np.log(x), y) + xl.append(x) + yl.append(y) + + # clog(x + iNaN) returns NaN + iNaN and optionally raises the + # 'invalid' floating- point exception, for finite x. + with np.errstate(invalid='raise'): + x = np.array([complex(1., np.nan)], dtype=complex) + y = complex(np.nan, np.nan) + #assert_raises(FloatingPointError, np.log, x) + with np.errstate(invalid='ignore'): + assert_almost_equal(np.log(x), y) + + xl.append(x) + yl.append(y) + + with np.errstate(invalid='raise'): + x = np.array([np.inf + 1j * np.nan], dtype=complex) + #assert_raises(FloatingPointError, np.log, x) + with np.errstate(invalid='ignore'): + assert_almost_equal(np.log(x), y) + + xl.append(x) + yl.append(y) + + # clog(- inf + iy) returns +inf + ipi , for finite positive-signed y. + x = np.array([-np.inf + 1j], dtype=complex) + y = complex(np.inf, np.pi) + assert_almost_equal(np.log(x), y) + xl.append(x) + yl.append(y) + + # clog(+ inf + iy) returns +inf + i0, for finite positive-signed y. + x = np.array([np.inf + 1j], dtype=complex) + y = complex(np.inf, 0) + assert_almost_equal(np.log(x), y) + xl.append(x) + yl.append(y) + + # clog(- inf + i inf) returns +inf + i3pi /4. + x = np.array([complex(-np.inf, np.inf)], dtype=complex) + y = complex(np.inf, 0.75 * np.pi) + assert_almost_equal(np.log(x), y) + xl.append(x) + yl.append(y) + + # clog(+ inf + i inf) returns +inf + ipi /4. + x = np.array([complex(np.inf, np.inf)], dtype=complex) + y = complex(np.inf, 0.25 * np.pi) + assert_almost_equal(np.log(x), y) + xl.append(x) + yl.append(y) + + # clog(+/- inf + iNaN) returns +inf + iNaN. + x = np.array([complex(np.inf, np.nan)], dtype=complex) + y = complex(np.inf, np.nan) + assert_almost_equal(np.log(x), y) + xl.append(x) + yl.append(y) + + x = np.array([complex(-np.inf, np.nan)], dtype=complex) + assert_almost_equal(np.log(x), y) + xl.append(x) + yl.append(y) + + # clog(NaN + iy) returns NaN + iNaN and optionally raises the + # 'invalid' floating-point exception, for finite y. + x = np.array([complex(np.nan, 1)], dtype=complex) + y = complex(np.nan, np.nan) + assert_almost_equal(np.log(x), y) + xl.append(x) + yl.append(y) + + # clog(NaN + i inf) returns +inf + iNaN. + x = np.array([complex(np.nan, np.inf)], dtype=complex) + y = complex(np.inf, np.nan) + assert_almost_equal(np.log(x), y) + xl.append(x) + yl.append(y) + + # clog(NaN + iNaN) returns NaN + iNaN. + x = np.array([complex(np.nan, np.nan)], dtype=complex) + y = complex(np.nan, np.nan) + assert_almost_equal(np.log(x), y) + xl.append(x) + yl.append(y) + + # clog(conj(z)) = conj(clog(z)). + xa = np.array(xl, dtype=complex) + ya = np.array(yl, dtype=complex) + with np.errstate(divide='ignore'): + for i in range(len(xa)): + assert_almost_equal(np.log(xa[i].conj()), ya[i].conj()) + + +class TestCsqrt: + + def test_simple(self): + # sqrt(1) + check_complex_value(np.sqrt, 1, 0, 1, 0) + + # sqrt(1i) + rres = 0.5*np.sqrt(2) + ires = rres + check_complex_value(np.sqrt, 0, 1, rres, ires, False) + + # sqrt(-1) + check_complex_value(np.sqrt, -1, 0, 0, 1) + + def test_simple_conjugate(self): + ref = np.conj(np.sqrt(complex(1, 1))) + + def f(z): + return np.sqrt(np.conj(z)) + + check_complex_value(f, 1, 1, ref.real, ref.imag, False) + + #def test_branch_cut(self): + # _check_branch_cut(f, -1, 0, 1, -1) + + @platform_skip + def test_special_values(self): + # C99: Sec G 6.4.2 + + check = check_complex_value + f = np.sqrt + + # csqrt(+-0 + 0i) is 0 + 0i + check(f, ncu.PZERO, 0, 0, 0) + check(f, ncu.NZERO, 0, 0, 0) + + # csqrt(x + infi) is inf + infi for any x (including NaN) + check(f, 1, np.inf, np.inf, np.inf) + check(f, -1, np.inf, np.inf, np.inf) + + check(f, ncu.PZERO, np.inf, np.inf, np.inf) + check(f, ncu.NZERO, np.inf, np.inf, np.inf) + check(f, np.inf, np.inf, np.inf, np.inf) + check(f, -np.inf, np.inf, np.inf, np.inf) + check(f, -np.nan, np.inf, np.inf, np.inf) + + # csqrt(x + nani) is nan + nani for any finite x + check(f, 1, np.nan, np.nan, np.nan) + check(f, -1, np.nan, np.nan, np.nan) + check(f, 0, np.nan, np.nan, np.nan) + + # csqrt(-inf + yi) is +0 + infi for any finite y > 0 + check(f, -np.inf, 1, ncu.PZERO, np.inf) + + # csqrt(inf + yi) is +inf + 0i for any finite y > 0 + check(f, np.inf, 1, np.inf, ncu.PZERO) + + # csqrt(-inf + nani) is nan +- infi (both +i infi are valid) + def _check_ninf_nan(dummy): + msgform = "csqrt(-inf, nan) is (%f, %f), expected (nan, +-inf)" + z = np.sqrt(np.array(complex(-np.inf, np.nan))) + #Fixme: ugly workaround for isinf bug. + with np.errstate(invalid='ignore'): + if not (np.isnan(z.real) and np.isinf(z.imag)): + raise AssertionError(msgform % (z.real, z.imag)) + + _check_ninf_nan(None) + + # csqrt(+inf + nani) is inf + nani + check(f, np.inf, np.nan, np.inf, np.nan) + + # csqrt(nan + yi) is nan + nani for any finite y (infinite handled in x + # + nani) + check(f, np.nan, 0, np.nan, np.nan) + check(f, np.nan, 1, np.nan, np.nan) + check(f, np.nan, np.nan, np.nan, np.nan) + + # XXX: check for conj(csqrt(z)) == csqrt(conj(z)) (need to fix branch + # cuts first) + +class TestCpow: + def setup_method(self): + self.olderr = np.seterr(invalid='ignore') + + def teardown_method(self): + np.seterr(**self.olderr) + + def test_simple(self): + x = np.array([1+1j, 0+2j, 1+2j, np.inf, np.nan]) + y_r = x ** 2 + y = np.power(x, 2) + assert_almost_equal(y, y_r) + + def test_scalar(self): + x = np.array([1, 1j, 2, 2.5+.37j, np.inf, np.nan]) + y = np.array([1, 1j, -0.5+1.5j, -0.5+1.5j, 2, 3]) + lx = list(range(len(x))) + + # Hardcode the expected `builtins.complex` values, + # as complex exponentiation is broken as of bpo-44698 + p_r = [ + 1+0j, + 0.20787957635076193+0j, + 0.35812203996480685+0.6097119028618724j, + 0.12659112128185032+0.48847676699581527j, + complex(np.inf, np.nan), + complex(np.nan, np.nan), + ] + + n_r = [x[i] ** y[i] for i in lx] + for i in lx: + assert_almost_equal(n_r[i], p_r[i], err_msg='Loop %d\n' % i) + + def test_array(self): + x = np.array([1, 1j, 2, 2.5+.37j, np.inf, np.nan]) + y = np.array([1, 1j, -0.5+1.5j, -0.5+1.5j, 2, 3]) + lx = list(range(len(x))) + + # Hardcode the expected `builtins.complex` values, + # as complex exponentiation is broken as of bpo-44698 + p_r = [ + 1+0j, + 0.20787957635076193+0j, + 0.35812203996480685+0.6097119028618724j, + 0.12659112128185032+0.48847676699581527j, + complex(np.inf, np.nan), + complex(np.nan, np.nan), + ] + + n_r = x ** y + for i in lx: + assert_almost_equal(n_r[i], p_r[i], err_msg='Loop %d\n' % i) + +class TestCabs: + def setup_method(self): + self.olderr = np.seterr(invalid='ignore') + + def teardown_method(self): + np.seterr(**self.olderr) + + def test_simple(self): + x = np.array([1+1j, 0+2j, 1+2j, np.inf, np.nan]) + y_r = np.array([np.sqrt(2.), 2, np.sqrt(5), np.inf, np.nan]) + y = np.abs(x) + assert_almost_equal(y, y_r) + + def test_fabs(self): + # Test that np.abs(x +- 0j) == np.abs(x) (as mandated by C99 for cabs) + x = np.array([1+0j], dtype=complex) + assert_array_equal(np.abs(x), np.real(x)) + + x = np.array([complex(1, ncu.NZERO)], dtype=complex) + assert_array_equal(np.abs(x), np.real(x)) + + x = np.array([complex(np.inf, ncu.NZERO)], dtype=complex) + assert_array_equal(np.abs(x), np.real(x)) + + x = np.array([complex(np.nan, ncu.NZERO)], dtype=complex) + assert_array_equal(np.abs(x), np.real(x)) + + def test_cabs_inf_nan(self): + x, y = [], [] + + # cabs(+-nan + nani) returns nan + x.append(np.nan) + y.append(np.nan) + check_real_value(np.abs, np.nan, np.nan, np.nan) + + x.append(np.nan) + y.append(-np.nan) + check_real_value(np.abs, -np.nan, np.nan, np.nan) + + # According to C99 standard, if exactly one of the real/part is inf and + # the other nan, then cabs should return inf + x.append(np.inf) + y.append(np.nan) + check_real_value(np.abs, np.inf, np.nan, np.inf) + + x.append(-np.inf) + y.append(np.nan) + check_real_value(np.abs, -np.inf, np.nan, np.inf) + + # cabs(conj(z)) == conj(cabs(z)) (= cabs(z)) + def f(a): + return np.abs(np.conj(a)) + + def g(a, b): + return np.abs(complex(a, b)) + + xa = np.array(x, dtype=complex) + assert len(xa) == len(x) == len(y) + for xi, yi in zip(x, y): + ref = g(xi, yi) + check_real_value(f, xi, yi, ref) + +class TestCarg: + def test_simple(self): + check_real_value(ncu._arg, 1, 0, 0, False) + check_real_value(ncu._arg, 0, 1, 0.5*np.pi, False) + + check_real_value(ncu._arg, 1, 1, 0.25*np.pi, False) + check_real_value(ncu._arg, ncu.PZERO, ncu.PZERO, ncu.PZERO) + + # TODO This can be xfail when the generator functions are got rid of. + @pytest.mark.skip( + reason="Complex arithmetic with signed zero fails on most platforms") + def test_zero(self): + # carg(-0 +- 0i) returns +- pi + check_real_value(ncu._arg, ncu.NZERO, ncu.PZERO, np.pi, False) + check_real_value(ncu._arg, ncu.NZERO, ncu.NZERO, -np.pi, False) + + # carg(+0 +- 0i) returns +- 0 + check_real_value(ncu._arg, ncu.PZERO, ncu.PZERO, ncu.PZERO) + check_real_value(ncu._arg, ncu.PZERO, ncu.NZERO, ncu.NZERO) + + # carg(x +- 0i) returns +- 0 for x > 0 + check_real_value(ncu._arg, 1, ncu.PZERO, ncu.PZERO, False) + check_real_value(ncu._arg, 1, ncu.NZERO, ncu.NZERO, False) + + # carg(x +- 0i) returns +- pi for x < 0 + check_real_value(ncu._arg, -1, ncu.PZERO, np.pi, False) + check_real_value(ncu._arg, -1, ncu.NZERO, -np.pi, False) + + # carg(+- 0 + yi) returns pi/2 for y > 0 + check_real_value(ncu._arg, ncu.PZERO, 1, 0.5 * np.pi, False) + check_real_value(ncu._arg, ncu.NZERO, 1, 0.5 * np.pi, False) + + # carg(+- 0 + yi) returns -pi/2 for y < 0 + check_real_value(ncu._arg, ncu.PZERO, -1, 0.5 * np.pi, False) + check_real_value(ncu._arg, ncu.NZERO, -1, -0.5 * np.pi, False) + + #def test_branch_cuts(self): + # _check_branch_cut(ncu._arg, -1, 1j, -1, 1) + + def test_special_values(self): + # carg(-np.inf +- yi) returns +-pi for finite y > 0 + check_real_value(ncu._arg, -np.inf, 1, np.pi, False) + check_real_value(ncu._arg, -np.inf, -1, -np.pi, False) + + # carg(np.inf +- yi) returns +-0 for finite y > 0 + check_real_value(ncu._arg, np.inf, 1, ncu.PZERO, False) + check_real_value(ncu._arg, np.inf, -1, ncu.NZERO, False) + + # carg(x +- np.infi) returns +-pi/2 for finite x + check_real_value(ncu._arg, 1, np.inf, 0.5 * np.pi, False) + check_real_value(ncu._arg, 1, -np.inf, -0.5 * np.pi, False) + + # carg(-np.inf +- np.infi) returns +-3pi/4 + check_real_value(ncu._arg, -np.inf, np.inf, 0.75 * np.pi, False) + check_real_value(ncu._arg, -np.inf, -np.inf, -0.75 * np.pi, False) + + # carg(np.inf +- np.infi) returns +-pi/4 + check_real_value(ncu._arg, np.inf, np.inf, 0.25 * np.pi, False) + check_real_value(ncu._arg, np.inf, -np.inf, -0.25 * np.pi, False) + + # carg(x + yi) returns np.nan if x or y is nan + check_real_value(ncu._arg, np.nan, 0, np.nan, False) + check_real_value(ncu._arg, 0, np.nan, np.nan, False) + + check_real_value(ncu._arg, np.nan, np.inf, np.nan, False) + check_real_value(ncu._arg, np.inf, np.nan, np.nan, False) + + +def check_real_value(f, x1, y1, x, exact=True): + z1 = np.array([complex(x1, y1)]) + if exact: + assert_equal(f(z1), x) + else: + assert_almost_equal(f(z1), x) + + +def check_complex_value(f, x1, y1, x2, y2, exact=True): + z1 = np.array([complex(x1, y1)]) + z2 = complex(x2, y2) + with np.errstate(invalid='ignore'): + if exact: + assert_equal(f(z1), z2) + else: + assert_almost_equal(f(z1), z2) + +class TestSpecialComplexAVX: + @pytest.mark.parametrize("stride", [-4,-2,-1,1,2,4]) + @pytest.mark.parametrize("astype", [np.complex64, np.complex128]) + def test_array(self, stride, astype): + arr = np.array([complex(np.nan , np.nan), + complex(np.nan , np.inf), + complex(np.inf , np.nan), + complex(np.inf , np.inf), + complex(0. , np.inf), + complex(np.inf , 0.), + complex(0. , 0.), + complex(0. , np.nan), + complex(np.nan , 0.)], dtype=astype) + abs_true = np.array([np.nan, np.inf, np.inf, np.inf, np.inf, np.inf, 0., np.nan, np.nan], dtype=arr.real.dtype) + sq_true = np.array([complex(np.nan, np.nan), + complex(np.nan, np.nan), + complex(np.nan, np.nan), + complex(np.nan, np.inf), + complex(-np.inf, np.nan), + complex(np.inf, np.nan), + complex(0., 0.), + complex(np.nan, np.nan), + complex(np.nan, np.nan)], dtype=astype) + with np.errstate(invalid='ignore'): + assert_equal(np.abs(arr[::stride]), abs_true[::stride]) + assert_equal(np.square(arr[::stride]), sq_true[::stride]) + +class TestComplexAbsoluteAVX: + @pytest.mark.parametrize("arraysize", [1,2,3,4,5,6,7,8,9,10,11,13,15,17,18,19]) + @pytest.mark.parametrize("stride", [-4,-3,-2,-1,1,2,3,4]) + @pytest.mark.parametrize("astype", [np.complex64, np.complex128]) + # test to ensure masking and strides work as intended in the AVX implementation + def test_array(self, arraysize, stride, astype): + arr = np.ones(arraysize, dtype=astype) + abs_true = np.ones(arraysize, dtype=arr.real.dtype) + assert_equal(np.abs(arr[::stride]), abs_true[::stride]) + +# Testcase taken as is from https://github.com/numpy/numpy/issues/16660 +class TestComplexAbsoluteMixedDTypes: + @pytest.mark.parametrize("stride", [-4,-3,-2,-1,1,2,3,4]) + @pytest.mark.parametrize("astype", [np.complex64, np.complex128]) + @pytest.mark.parametrize("func", ['abs', 'square', 'conjugate']) + + def test_array(self, stride, astype, func): + dtype = [('template_id', 'U') + uni_arr2 = str_arr.astype(').itemsize` instead.", + "byte_bounds": "Now it's available under `np.lib.array_utils.byte_bounds`", + "compare_chararrays": + "It's still available as `np.char.compare_chararrays`.", + "format_parser": "It's still available as `np.rec.format_parser`.", + "alltrue": "Use `np.all` instead.", + "sometrue": "Use `np.any` instead.", +} diff --git a/venv/lib/python3.12/site-packages/numpy/_globals.py b/venv/lib/python3.12/site-packages/numpy/_globals.py new file mode 100644 index 00000000..a1474177 --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_globals.py @@ -0,0 +1,95 @@ +""" +Module defining global singleton classes. + +This module raises a RuntimeError if an attempt to reload it is made. In that +way the identities of the classes defined here are fixed and will remain so +even if numpy itself is reloaded. In particular, a function like the following +will still work correctly after numpy is reloaded:: + + def foo(arg=np._NoValue): + if arg is np._NoValue: + ... + +That was not the case when the singleton classes were defined in the numpy +``__init__.py`` file. See gh-7844 for a discussion of the reload problem that +motivated this module. + +""" +import enum + +from ._utils import set_module as _set_module + +__all__ = ['_NoValue', '_CopyMode'] + + +# Disallow reloading this module so as to preserve the identities of the +# classes defined here. +if '_is_loaded' in globals(): + raise RuntimeError('Reloading numpy._globals is not allowed') +_is_loaded = True + + +class _NoValueType: + """Special keyword value. + + The instance of this class may be used as the default value assigned to a + keyword if no other obvious default (e.g., `None`) is suitable, + + Common reasons for using this keyword are: + + - A new keyword is added to a function, and that function forwards its + inputs to another function or method which can be defined outside of + NumPy. For example, ``np.std(x)`` calls ``x.std``, so when a ``keepdims`` + keyword was added that could only be forwarded if the user explicitly + specified ``keepdims``; downstream array libraries may not have added + the same keyword, so adding ``x.std(..., keepdims=keepdims)`` + unconditionally could have broken previously working code. + - A keyword is being deprecated, and a deprecation warning must only be + emitted when the keyword is used. + + """ + __instance = None + def __new__(cls): + # ensure that only one instance exists + if not cls.__instance: + cls.__instance = super().__new__(cls) + return cls.__instance + + def __repr__(self): + return "" + + +_NoValue = _NoValueType() + + +@_set_module("numpy") +class _CopyMode(enum.Enum): + """ + An enumeration for the copy modes supported + by numpy.copy() and numpy.array(). The following three modes are supported, + + - ALWAYS: This means that a deep copy of the input + array will always be taken. + - IF_NEEDED: This means that a deep copy of the input + array will be taken only if necessary. + - NEVER: This means that the deep copy will never be taken. + If a copy cannot be avoided then a `ValueError` will be + raised. + + Note that the buffer-protocol could in theory do copies. NumPy currently + assumes an object exporting the buffer protocol will never do this. + """ + + ALWAYS = True + NEVER = False + IF_NEEDED = 2 + + def __bool__(self): + # For backwards compatibility + if self == _CopyMode.ALWAYS: + return True + + if self == _CopyMode.NEVER: + return False + + raise ValueError(f"{self} is neither True nor False.") diff --git a/venv/lib/python3.12/site-packages/numpy/_pyinstaller/__init__.py b/venv/lib/python3.12/site-packages/numpy/_pyinstaller/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/venv/lib/python3.12/site-packages/numpy/_pyinstaller/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/_pyinstaller/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..c3330258 Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/_pyinstaller/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/numpy/_pyinstaller/__pycache__/hook-numpy.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/_pyinstaller/__pycache__/hook-numpy.cpython-312.pyc new file mode 100644 index 00000000..2dfb8076 Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/_pyinstaller/__pycache__/hook-numpy.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/numpy/_pyinstaller/hook-numpy.py b/venv/lib/python3.12/site-packages/numpy/_pyinstaller/hook-numpy.py new file mode 100644 index 00000000..84f3626b --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_pyinstaller/hook-numpy.py @@ -0,0 +1,36 @@ +"""This hook should collect all binary files and any hidden modules that numpy +needs. + +Our (some-what inadequate) docs for writing PyInstaller hooks are kept here: +https://pyinstaller.readthedocs.io/en/stable/hooks.html + +""" +from PyInstaller.compat import is_conda, is_pure_conda +from PyInstaller.utils.hooks import collect_dynamic_libs, is_module_satisfies + +# Collect all DLLs inside numpy's installation folder, dump them into built +# app's root. +binaries = collect_dynamic_libs("numpy", ".") + +# If using Conda without any non-conda virtual environment manager: +if is_pure_conda: + # Assume running the NumPy from Conda-forge and collect it's DLLs from the + # communal Conda bin directory. DLLs from NumPy's dependencies must also be + # collected to capture MKL, OpenBlas, OpenMP, etc. + from PyInstaller.utils.hooks import conda_support + datas = conda_support.collect_dynamic_libs("numpy", dependencies=True) + +# Submodules PyInstaller cannot detect. `_dtype_ctypes` is only imported +# from C and `_multiarray_tests` is used in tests (which are not packed). +hiddenimports = ['numpy._core._dtype_ctypes', 'numpy._core._multiarray_tests'] + +# Remove testing and building code and packages that are referenced throughout +# NumPy but are not really dependencies. +excludedimports = [ + "scipy", + "pytest", + "f2py", + "setuptools", + "distutils", + "numpy.distutils", +] diff --git a/venv/lib/python3.12/site-packages/numpy/_pyinstaller/tests/__init__.py b/venv/lib/python3.12/site-packages/numpy/_pyinstaller/tests/__init__.py new file mode 100644 index 00000000..f7c033bc --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_pyinstaller/tests/__init__.py @@ -0,0 +1,16 @@ +from numpy.testing import IS_WASM, IS_EDITABLE +import pytest + + +if IS_WASM: + pytest.skip( + "WASM/Pyodide does not use or support Fortran", + allow_module_level=True + ) + + +if IS_EDITABLE: + pytest.skip( + "Editable install doesn't support tests with a compile step", + allow_module_level=True + ) diff --git a/venv/lib/python3.12/site-packages/numpy/_pyinstaller/tests/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/_pyinstaller/tests/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..875b28fc Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/_pyinstaller/tests/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/numpy/_pyinstaller/tests/__pycache__/pyinstaller-smoke.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/_pyinstaller/tests/__pycache__/pyinstaller-smoke.cpython-312.pyc new file mode 100644 index 00000000..a66e329a Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/_pyinstaller/tests/__pycache__/pyinstaller-smoke.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/numpy/_pyinstaller/tests/__pycache__/test_pyinstaller.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/_pyinstaller/tests/__pycache__/test_pyinstaller.cpython-312.pyc new file mode 100644 index 00000000..d33b7cf1 Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/_pyinstaller/tests/__pycache__/test_pyinstaller.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/numpy/_pyinstaller/tests/pyinstaller-smoke.py b/venv/lib/python3.12/site-packages/numpy/_pyinstaller/tests/pyinstaller-smoke.py new file mode 100644 index 00000000..eb28070e --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_pyinstaller/tests/pyinstaller-smoke.py @@ -0,0 +1,32 @@ +"""A crude *bit of everything* smoke test to verify PyInstaller compatibility. + +PyInstaller typically goes wrong by forgetting to package modules, extension +modules or shared libraries. This script should aim to touch as many of those +as possible in an attempt to trip a ModuleNotFoundError or a DLL load failure +due to an uncollected resource. Missing resources are unlikely to lead to +arithmetic errors so there's generally no need to verify any calculation's +output - merely that it made it to the end OK. This script should not +explicitly import any of numpy's submodules as that gives PyInstaller undue +hints that those submodules exist and should be collected (accessing implicitly +loaded submodules is OK). + +""" +import numpy as np + +a = np.arange(1., 10.).reshape((3, 3)) % 5 +np.linalg.det(a) +a @ a +a @ a.T +np.linalg.inv(a) +np.sin(np.exp(a)) +np.linalg.svd(a) +np.linalg.eigh(a) + +np.unique(np.random.randint(0, 10, 100)) +np.sort(np.random.uniform(0, 10, 100)) + +np.fft.fft(np.exp(2j * np.pi * np.arange(8) / 8)) +np.ma.masked_array(np.arange(10), np.random.rand(10) < .5).sum() +np.polynomial.Legendre([7, 8, 9]).roots() + +print("I made it!") diff --git a/venv/lib/python3.12/site-packages/numpy/_pyinstaller/tests/test_pyinstaller.py b/venv/lib/python3.12/site-packages/numpy/_pyinstaller/tests/test_pyinstaller.py new file mode 100644 index 00000000..a9061da1 --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_pyinstaller/tests/test_pyinstaller.py @@ -0,0 +1,35 @@ +import subprocess +from pathlib import Path + +import pytest + + +# PyInstaller has been very unproactive about replacing 'imp' with 'importlib'. +@pytest.mark.filterwarnings('ignore::DeprecationWarning') +# It also leaks io.BytesIO()s. +@pytest.mark.filterwarnings('ignore::ResourceWarning') +@pytest.mark.parametrize("mode", ["--onedir", "--onefile"]) +@pytest.mark.slow +def test_pyinstaller(mode, tmp_path): + """Compile and run pyinstaller-smoke.py using PyInstaller.""" + + pyinstaller_cli = pytest.importorskip("PyInstaller.__main__").run + + source = Path(__file__).with_name("pyinstaller-smoke.py").resolve() + args = [ + # Place all generated files in ``tmp_path``. + '--workpath', str(tmp_path / "build"), + '--distpath', str(tmp_path / "dist"), + '--specpath', str(tmp_path), + mode, + str(source), + ] + pyinstaller_cli(args) + + if mode == "--onefile": + exe = tmp_path / "dist" / source.stem + else: + exe = tmp_path / "dist" / source.stem / source.stem + + p = subprocess.run([str(exe)], check=True, stdout=subprocess.PIPE) + assert p.stdout.strip() == b"I made it!" diff --git a/venv/lib/python3.12/site-packages/numpy/_pytesttester.py b/venv/lib/python3.12/site-packages/numpy/_pytesttester.py new file mode 100644 index 00000000..4548fc68 --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_pytesttester.py @@ -0,0 +1,199 @@ +""" +Pytest test running. + +This module implements the ``test()`` function for NumPy modules. The usual +boiler plate for doing that is to put the following in the module +``__init__.py`` file:: + + from numpy._pytesttester import PytestTester + test = PytestTester(__name__) + del PytestTester + + +Warnings filtering and other runtime settings should be dealt with in the +``pytest.ini`` file in the numpy repo root. The behavior of the test depends on +whether or not that file is found as follows: + +* ``pytest.ini`` is present (develop mode) + All warnings except those explicitly filtered out are raised as error. +* ``pytest.ini`` is absent (release mode) + DeprecationWarnings and PendingDeprecationWarnings are ignored, other + warnings are passed through. + +In practice, tests run from the numpy repo are run in development mode with +``spin``, through the standard ``spin test`` invocation or from an inplace +build with ``pytest numpy``. + +This module is imported by every numpy subpackage, so lies at the top level to +simplify circular import issues. For the same reason, it contains no numpy +imports at module scope, instead importing numpy within function calls. +""" +import sys +import os + +__all__ = ['PytestTester'] + + +def _show_numpy_info(): + import numpy as np + + print("NumPy version %s" % np.__version__) + info = np.lib._utils_impl._opt_info() + print("NumPy CPU features: ", (info if info else 'nothing enabled')) + + +class PytestTester: + """ + Pytest test runner. + + A test function is typically added to a package's __init__.py like so:: + + from numpy._pytesttester import PytestTester + test = PytestTester(__name__).test + del PytestTester + + Calling this test function finds and runs all tests associated with the + module and all its sub-modules. + + Attributes + ---------- + module_name : str + Full path to the package to test. + + Parameters + ---------- + module_name : module name + The name of the module to test. + + Notes + ----- + Unlike the previous ``nose``-based implementation, this class is not + publicly exposed as it performs some ``numpy``-specific warning + suppression. + + """ + def __init__(self, module_name): + self.module_name = module_name + + def __call__(self, label='fast', verbose=1, extra_argv=None, + doctests=False, coverage=False, durations=-1, tests=None): + """ + Run tests for module using pytest. + + Parameters + ---------- + label : {'fast', 'full'}, optional + Identifies the tests to run. When set to 'fast', tests decorated + with `pytest.mark.slow` are skipped, when 'full', the slow marker + is ignored. + verbose : int, optional + Verbosity value for test outputs, in the range 1-3. Default is 1. + extra_argv : list, optional + List with any extra arguments to pass to pytests. + doctests : bool, optional + .. note:: Not supported + coverage : bool, optional + If True, report coverage of NumPy code. Default is False. + Requires installation of (pip) pytest-cov. + durations : int, optional + If < 0, do nothing, If 0, report time of all tests, if > 0, + report the time of the slowest `timer` tests. Default is -1. + tests : test or list of tests + Tests to be executed with pytest '--pyargs' + + Returns + ------- + result : bool + Return True on success, false otherwise. + + Notes + ----- + Each NumPy module exposes `test` in its namespace to run all tests for + it. For example, to run all tests for numpy.lib: + + >>> np.lib.test() #doctest: +SKIP + + Examples + -------- + >>> result = np.lib.test() #doctest: +SKIP + ... + 1023 passed, 2 skipped, 6 deselected, 1 xfailed in 10.39 seconds + >>> result + True + + """ + import pytest + import warnings + + module = sys.modules[self.module_name] + module_path = os.path.abspath(module.__path__[0]) + + # setup the pytest arguments + pytest_args = ["-l"] + + # offset verbosity. The "-q" cancels a "-v". + pytest_args += ["-q"] + + if sys.version_info < (3, 12): + with warnings.catch_warnings(): + warnings.simplefilter("always") + # Filter out distutils cpu warnings (could be localized to + # distutils tests). ASV has problems with top level import, + # so fetch module for suppression here. + from numpy.distutils import cpuinfo + + # Filter out annoying import messages. Want these in both develop and + # release mode. + pytest_args += [ + "-W ignore:Not importing directory", + "-W ignore:numpy.dtype size changed", + "-W ignore:numpy.ufunc size changed", + "-W ignore::UserWarning:cpuinfo", + ] + + # When testing matrices, ignore their PendingDeprecationWarnings + pytest_args += [ + "-W ignore:the matrix subclass is not", + "-W ignore:Importing from numpy.matlib is", + ] + + if doctests: + pytest_args += ["--doctest-modules"] + + if extra_argv: + pytest_args += list(extra_argv) + + if verbose > 1: + pytest_args += ["-" + "v"*(verbose - 1)] + + if coverage: + pytest_args += ["--cov=" + module_path] + + if label == "fast": + # not importing at the top level to avoid circular import of module + from numpy.testing import IS_PYPY + if IS_PYPY: + pytest_args += ["-m", "not slow and not slow_pypy"] + else: + pytest_args += ["-m", "not slow"] + + elif label != "full": + pytest_args += ["-m", label] + + if durations >= 0: + pytest_args += ["--durations=%s" % durations] + + if tests is None: + tests = [self.module_name] + + pytest_args += ["--pyargs"] + list(tests) + + # run tests. + _show_numpy_info() + + try: + code = pytest.main(pytest_args) + except SystemExit as exc: + code = exc.code + + return code == 0 diff --git a/venv/lib/python3.12/site-packages/numpy/_pytesttester.pyi b/venv/lib/python3.12/site-packages/numpy/_pytesttester.pyi new file mode 100644 index 00000000..67ac87b3 --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_pytesttester.pyi @@ -0,0 +1,18 @@ +from collections.abc import Iterable +from typing import Literal as L + +__all__: list[str] + +class PytestTester: + module_name: str + def __init__(self, module_name: str) -> None: ... + def __call__( + self, + label: L["fast", "full"] = ..., + verbose: int = ..., + extra_argv: None | Iterable[str] = ..., + doctests: L[False] = ..., + coverage: bool = ..., + durations: int = ..., + tests: None | Iterable[str] = ..., + ) -> bool: ... diff --git a/venv/lib/python3.12/site-packages/numpy/_typing/__init__.py b/venv/lib/python3.12/site-packages/numpy/_typing/__init__.py new file mode 100644 index 00000000..01c5a7c4 --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_typing/__init__.py @@ -0,0 +1,224 @@ +"""Private counterpart of ``numpy.typing``.""" + +from __future__ import annotations + +from .. import ufunc +from .._utils import set_module +from typing import TYPE_CHECKING, final + + +@final # Disallow the creation of arbitrary `NBitBase` subclasses +@set_module("numpy.typing") +class NBitBase: + """ + A type representing `numpy.number` precision during static type checking. + + Used exclusively for the purpose static type checking, `NBitBase` + represents the base of a hierarchical set of subclasses. + Each subsequent subclass is herein used for representing a lower level + of precision, *e.g.* ``64Bit > 32Bit > 16Bit``. + + .. versionadded:: 1.20 + + Examples + -------- + Below is a typical usage example: `NBitBase` is herein used for annotating + a function that takes a float and integer of arbitrary precision + as arguments and returns a new float of whichever precision is largest + (*e.g.* ``np.float16 + np.int64 -> np.float64``). + + .. code-block:: python + + >>> from __future__ import annotations + >>> from typing import TypeVar, TYPE_CHECKING + >>> import numpy as np + >>> import numpy.typing as npt + + >>> T1 = TypeVar("T1", bound=npt.NBitBase) + >>> T2 = TypeVar("T2", bound=npt.NBitBase) + + >>> def add(a: np.floating[T1], b: np.integer[T2]) -> np.floating[T1 | T2]: + ... return a + b + + >>> a = np.float16() + >>> b = np.int64() + >>> out = add(a, b) + + >>> if TYPE_CHECKING: + ... reveal_locals() + ... # note: Revealed local types are: + ... # note: a: numpy.floating[numpy.typing._16Bit*] + ... # note: b: numpy.signedinteger[numpy.typing._64Bit*] + ... # note: out: numpy.floating[numpy.typing._64Bit*] + + """ + + def __init_subclass__(cls) -> None: + allowed_names = { + "NBitBase", "_256Bit", "_128Bit", "_96Bit", "_80Bit", + "_64Bit", "_32Bit", "_16Bit", "_8Bit", + } + if cls.__name__ not in allowed_names: + raise TypeError('cannot inherit from final class "NBitBase"') + super().__init_subclass__() + + +# Silence errors about subclassing a `@final`-decorated class +class _256Bit(NBitBase): # type: ignore[misc] + pass + +class _128Bit(_256Bit): # type: ignore[misc] + pass + +class _96Bit(_128Bit): # type: ignore[misc] + pass + +class _80Bit(_96Bit): # type: ignore[misc] + pass + +class _64Bit(_80Bit): # type: ignore[misc] + pass + +class _32Bit(_64Bit): # type: ignore[misc] + pass + +class _16Bit(_32Bit): # type: ignore[misc] + pass + +class _8Bit(_16Bit): # type: ignore[misc] + pass + + +from ._nested_sequence import ( + _NestedSequence as _NestedSequence, +) +from ._nbit import ( + _NBitByte as _NBitByte, + _NBitShort as _NBitShort, + _NBitIntC as _NBitIntC, + _NBitIntP as _NBitIntP, + _NBitInt as _NBitInt, + _NBitLong as _NBitLong, + _NBitLongLong as _NBitLongLong, + _NBitHalf as _NBitHalf, + _NBitSingle as _NBitSingle, + _NBitDouble as _NBitDouble, + _NBitLongDouble as _NBitLongDouble, +) +from ._char_codes import ( + _BoolCodes as _BoolCodes, + _UInt8Codes as _UInt8Codes, + _UInt16Codes as _UInt16Codes, + _UInt32Codes as _UInt32Codes, + _UInt64Codes as _UInt64Codes, + _Int8Codes as _Int8Codes, + _Int16Codes as _Int16Codes, + _Int32Codes as _Int32Codes, + _Int64Codes as _Int64Codes, + _Float16Codes as _Float16Codes, + _Float32Codes as _Float32Codes, + _Float64Codes as _Float64Codes, + _Complex64Codes as _Complex64Codes, + _Complex128Codes as _Complex128Codes, + _ByteCodes as _ByteCodes, + _ShortCodes as _ShortCodes, + _IntCCodes as _IntCCodes, + _IntPCodes as _IntPCodes, + _IntCodes as _IntCodes, + _LongCodes as _LongCodes, + _LongLongCodes as _LongLongCodes, + _UByteCodes as _UByteCodes, + _UShortCodes as _UShortCodes, + _UIntCCodes as _UIntCCodes, + _UIntPCodes as _UIntPCodes, + _UIntCodes as _UIntCodes, + _ULongCodes as _ULongCodes, + _ULongLongCodes as _ULongLongCodes, + _HalfCodes as _HalfCodes, + _SingleCodes as _SingleCodes, + _DoubleCodes as _DoubleCodes, + _LongDoubleCodes as _LongDoubleCodes, + _CSingleCodes as _CSingleCodes, + _CDoubleCodes as _CDoubleCodes, + _CLongDoubleCodes as _CLongDoubleCodes, + _DT64Codes as _DT64Codes, + _TD64Codes as _TD64Codes, + _StrCodes as _StrCodes, + _BytesCodes as _BytesCodes, + _VoidCodes as _VoidCodes, + _ObjectCodes as _ObjectCodes, +) +from ._scalars import ( + _CharLike_co as _CharLike_co, + _BoolLike_co as _BoolLike_co, + _UIntLike_co as _UIntLike_co, + _IntLike_co as _IntLike_co, + _FloatLike_co as _FloatLike_co, + _ComplexLike_co as _ComplexLike_co, + _TD64Like_co as _TD64Like_co, + _NumberLike_co as _NumberLike_co, + _ScalarLike_co as _ScalarLike_co, + _VoidLike_co as _VoidLike_co, +) +from ._shape import ( + _Shape as _Shape, + _ShapeLike as _ShapeLike, +) +from ._dtype_like import ( + DTypeLike as DTypeLike, + _DTypeLike as _DTypeLike, + _SupportsDType as _SupportsDType, + _VoidDTypeLike as _VoidDTypeLike, + _DTypeLikeBool as _DTypeLikeBool, + _DTypeLikeUInt as _DTypeLikeUInt, + _DTypeLikeInt as _DTypeLikeInt, + _DTypeLikeFloat as _DTypeLikeFloat, + _DTypeLikeComplex as _DTypeLikeComplex, + _DTypeLikeTD64 as _DTypeLikeTD64, + _DTypeLikeDT64 as _DTypeLikeDT64, + _DTypeLikeObject as _DTypeLikeObject, + _DTypeLikeVoid as _DTypeLikeVoid, + _DTypeLikeStr as _DTypeLikeStr, + _DTypeLikeBytes as _DTypeLikeBytes, + _DTypeLikeComplex_co as _DTypeLikeComplex_co, +) +from ._array_like import ( + NDArray as NDArray, + ArrayLike as ArrayLike, + _ArrayLike as _ArrayLike, + _FiniteNestedSequence as _FiniteNestedSequence, + _SupportsArray as _SupportsArray, + _SupportsArrayFunc as _SupportsArrayFunc, + _ArrayLikeInt as _ArrayLikeInt, + _ArrayLikeBool_co as _ArrayLikeBool_co, + _ArrayLikeUInt_co as _ArrayLikeUInt_co, + _ArrayLikeInt_co as _ArrayLikeInt_co, + _ArrayLikeFloat_co as _ArrayLikeFloat_co, + _ArrayLikeComplex_co as _ArrayLikeComplex_co, + _ArrayLikeNumber_co as _ArrayLikeNumber_co, + _ArrayLikeTD64_co as _ArrayLikeTD64_co, + _ArrayLikeDT64_co as _ArrayLikeDT64_co, + _ArrayLikeObject_co as _ArrayLikeObject_co, + _ArrayLikeVoid_co as _ArrayLikeVoid_co, + _ArrayLikeStr_co as _ArrayLikeStr_co, + _ArrayLikeBytes_co as _ArrayLikeBytes_co, + _ArrayLikeUnknown as _ArrayLikeUnknown, + _UnknownType as _UnknownType, +) + +if TYPE_CHECKING: + from ._ufunc import ( + _UFunc_Nin1_Nout1 as _UFunc_Nin1_Nout1, + _UFunc_Nin2_Nout1 as _UFunc_Nin2_Nout1, + _UFunc_Nin1_Nout2 as _UFunc_Nin1_Nout2, + _UFunc_Nin2_Nout2 as _UFunc_Nin2_Nout2, + _GUFunc_Nin2_Nout1 as _GUFunc_Nin2_Nout1, + ) +else: + # Declare the (type-check-only) ufunc subclasses as ufunc aliases during + # runtime; this helps autocompletion tools such as Jedi (numpy/numpy#19834) + _UFunc_Nin1_Nout1 = ufunc + _UFunc_Nin2_Nout1 = ufunc + _UFunc_Nin1_Nout2 = ufunc + _UFunc_Nin2_Nout2 = ufunc + _GUFunc_Nin2_Nout1 = ufunc diff --git a/venv/lib/python3.12/site-packages/numpy/_typing/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/_typing/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..593d616e Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/_typing/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/numpy/_typing/__pycache__/_add_docstring.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/_typing/__pycache__/_add_docstring.cpython-312.pyc new file mode 100644 index 00000000..e31aee9c Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/_typing/__pycache__/_add_docstring.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/numpy/_typing/__pycache__/_array_like.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/_typing/__pycache__/_array_like.cpython-312.pyc new file mode 100644 index 00000000..e903b8cb Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/_typing/__pycache__/_array_like.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/numpy/_typing/__pycache__/_char_codes.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/_typing/__pycache__/_char_codes.cpython-312.pyc new file mode 100644 index 00000000..b390d055 Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/_typing/__pycache__/_char_codes.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/numpy/_typing/__pycache__/_dtype_like.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/_typing/__pycache__/_dtype_like.cpython-312.pyc new file mode 100644 index 00000000..fe8e3f4c Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/_typing/__pycache__/_dtype_like.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/numpy/_typing/__pycache__/_extended_precision.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/_typing/__pycache__/_extended_precision.cpython-312.pyc new file mode 100644 index 00000000..788b99c8 Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/_typing/__pycache__/_extended_precision.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/numpy/_typing/__pycache__/_nbit.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/_typing/__pycache__/_nbit.cpython-312.pyc new file mode 100644 index 00000000..ea1103ff Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/_typing/__pycache__/_nbit.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/numpy/_typing/__pycache__/_nested_sequence.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/_typing/__pycache__/_nested_sequence.cpython-312.pyc new file mode 100644 index 00000000..2a6de71d Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/_typing/__pycache__/_nested_sequence.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/numpy/_typing/__pycache__/_scalars.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/_typing/__pycache__/_scalars.cpython-312.pyc new file mode 100644 index 00000000..6287fb96 Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/_typing/__pycache__/_scalars.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/numpy/_typing/__pycache__/_shape.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/_typing/__pycache__/_shape.cpython-312.pyc new file mode 100644 index 00000000..b926b4a9 Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/_typing/__pycache__/_shape.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/numpy/_typing/_add_docstring.py b/venv/lib/python3.12/site-packages/numpy/_typing/_add_docstring.py new file mode 100644 index 00000000..758d1a5b --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_typing/_add_docstring.py @@ -0,0 +1,152 @@ +"""A module for creating docstrings for sphinx ``data`` domains.""" + +import re +import textwrap + +from ._array_like import NDArray + +_docstrings_list = [] + + +def add_newdoc(name: str, value: str, doc: str) -> None: + """Append ``_docstrings_list`` with a docstring for `name`. + + Parameters + ---------- + name : str + The name of the object. + value : str + A string-representation of the object. + doc : str + The docstring of the object. + + """ + _docstrings_list.append((name, value, doc)) + + +def _parse_docstrings() -> str: + """Convert all docstrings in ``_docstrings_list`` into a single + sphinx-legible text block. + + """ + type_list_ret = [] + for name, value, doc in _docstrings_list: + s = textwrap.dedent(doc).replace("\n", "\n ") + + # Replace sections by rubrics + lines = s.split("\n") + new_lines = [] + indent = "" + for line in lines: + m = re.match(r'^(\s+)[-=]+\s*$', line) + if m and new_lines: + prev = textwrap.dedent(new_lines.pop()) + if prev == "Examples": + indent = "" + new_lines.append(f'{m.group(1)}.. rubric:: {prev}') + else: + indent = 4 * " " + new_lines.append(f'{m.group(1)}.. admonition:: {prev}') + new_lines.append("") + else: + new_lines.append(f"{indent}{line}") + + s = "\n".join(new_lines) + s_block = f""".. data:: {name}\n :value: {value}\n {s}""" + type_list_ret.append(s_block) + return "\n".join(type_list_ret) + + +add_newdoc('ArrayLike', 'typing.Union[...]', + """ + A `~typing.Union` representing objects that can be coerced + into an `~numpy.ndarray`. + + Among others this includes the likes of: + + * Scalars. + * (Nested) sequences. + * Objects implementing the `~class.__array__` protocol. + + .. versionadded:: 1.20 + + See Also + -------- + :term:`array_like`: + Any scalar or sequence that can be interpreted as an ndarray. + + Examples + -------- + .. code-block:: python + + >>> import numpy as np + >>> import numpy.typing as npt + + >>> def as_array(a: npt.ArrayLike) -> np.ndarray: + ... return np.array(a) + + """) + +add_newdoc('DTypeLike', 'typing.Union[...]', + """ + A `~typing.Union` representing objects that can be coerced + into a `~numpy.dtype`. + + Among others this includes the likes of: + + * :class:`type` objects. + * Character codes or the names of :class:`type` objects. + * Objects with the ``.dtype`` attribute. + + .. versionadded:: 1.20 + + See Also + -------- + :ref:`Specifying and constructing data types ` + A comprehensive overview of all objects that can be coerced + into data types. + + Examples + -------- + .. code-block:: python + + >>> import numpy as np + >>> import numpy.typing as npt + + >>> def as_dtype(d: npt.DTypeLike) -> np.dtype: + ... return np.dtype(d) + + """) + +add_newdoc('NDArray', repr(NDArray), + """ + A `np.ndarray[Any, np.dtype[+ScalarType]] ` type alias + :term:`generic ` w.r.t. its `dtype.type `. + + Can be used during runtime for typing arrays with a given dtype + and unspecified shape. + + .. versionadded:: 1.21 + + Examples + -------- + .. code-block:: python + + >>> import numpy as np + >>> import numpy.typing as npt + + >>> print(npt.NDArray) + numpy.ndarray[typing.Any, numpy.dtype[+_ScalarType_co]] + + >>> print(npt.NDArray[np.float64]) + numpy.ndarray[typing.Any, numpy.dtype[numpy.float64]] + + >>> NDArrayInt = npt.NDArray[np.int_] + >>> a: NDArrayInt = np.arange(10) + + >>> def func(a: npt.ArrayLike) -> npt.NDArray[Any]: + ... return np.array(a) + + """) + +_docstrings = _parse_docstrings() diff --git a/venv/lib/python3.12/site-packages/numpy/_typing/_array_like.py b/venv/lib/python3.12/site-packages/numpy/_typing/_array_like.py new file mode 100644 index 00000000..5cc501ab --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_typing/_array_like.py @@ -0,0 +1,170 @@ +from __future__ import annotations + +import sys +from collections.abc import Collection, Callable, Sequence +from typing import Any, Protocol, TypeAlias, TypeVar, runtime_checkable + +import numpy as np +from numpy import ( + ndarray, + dtype, + generic, + unsignedinteger, + integer, + floating, + complexfloating, + number, + timedelta64, + datetime64, + object_, + void, + str_, + bytes_, +) +from ._nested_sequence import _NestedSequence + +_T = TypeVar("_T") +_ScalarType = TypeVar("_ScalarType", bound=generic) +_ScalarType_co = TypeVar("_ScalarType_co", bound=generic, covariant=True) +_DType = TypeVar("_DType", bound=dtype[Any]) +_DType_co = TypeVar("_DType_co", covariant=True, bound=dtype[Any]) + +NDArray: TypeAlias = ndarray[Any, dtype[_ScalarType_co]] + +# The `_SupportsArray` protocol only cares about the default dtype +# (i.e. `dtype=None` or no `dtype` parameter at all) of the to-be returned +# array. +# Concrete implementations of the protocol are responsible for adding +# any and all remaining overloads +@runtime_checkable +class _SupportsArray(Protocol[_DType_co]): + def __array__(self) -> ndarray[Any, _DType_co]: ... + + +@runtime_checkable +class _SupportsArrayFunc(Protocol): + """A protocol class representing `~class.__array_function__`.""" + def __array_function__( + self, + func: Callable[..., Any], + types: Collection[type[Any]], + args: tuple[Any, ...], + kwargs: dict[str, Any], + ) -> object: ... + + +# TODO: Wait until mypy supports recursive objects in combination with typevars +_FiniteNestedSequence: TypeAlias = ( + _T + | Sequence[_T] + | Sequence[Sequence[_T]] + | Sequence[Sequence[Sequence[_T]]] + | Sequence[Sequence[Sequence[Sequence[_T]]]] +) + +# A subset of `npt.ArrayLike` that can be parametrized w.r.t. `np.generic` +_ArrayLike: TypeAlias = ( + _SupportsArray[dtype[_ScalarType]] + | _NestedSequence[_SupportsArray[dtype[_ScalarType]]] +) + +# A union representing array-like objects; consists of two typevars: +# One representing types that can be parametrized w.r.t. `np.dtype` +# and another one for the rest +_DualArrayLike: TypeAlias = ( + _SupportsArray[_DType] + | _NestedSequence[_SupportsArray[_DType]] + | _T + | _NestedSequence[_T] +) + +if sys.version_info >= (3, 12): + from collections.abc import Buffer + + ArrayLike: TypeAlias = Buffer | _DualArrayLike[ + dtype[Any], + bool | int | float | complex | str | bytes, + ] +else: + ArrayLike: TypeAlias = _DualArrayLike[ + dtype[Any], + bool | int | float | complex | str | bytes, + ] + +# `ArrayLike_co`: array-like objects that can be coerced into `X` +# given the casting rules `same_kind` +_ArrayLikeBool_co: TypeAlias = _DualArrayLike[ + dtype[np.bool], + bool, +] +_ArrayLikeUInt_co: TypeAlias = _DualArrayLike[ + dtype[np.bool] | dtype[unsignedinteger[Any]], + bool, +] +_ArrayLikeInt_co: TypeAlias = _DualArrayLike[ + dtype[np.bool] | dtype[integer[Any]], + bool | int, +] +_ArrayLikeFloat_co: TypeAlias = _DualArrayLike[ + dtype[np.bool] | dtype[integer[Any]] | dtype[floating[Any]], + bool | int | float, +] +_ArrayLikeComplex_co: TypeAlias = _DualArrayLike[ + ( + dtype[np.bool] + | dtype[integer[Any]] + | dtype[floating[Any]] + | dtype[complexfloating[Any, Any]] + ), + bool | int | float | complex, +] +_ArrayLikeNumber_co: TypeAlias = _DualArrayLike[ + dtype[np.bool] | dtype[number[Any]], + bool | int | float | complex, +] +_ArrayLikeTD64_co: TypeAlias = _DualArrayLike[ + dtype[np.bool] | dtype[integer[Any]] | dtype[timedelta64], + bool | int, +] +_ArrayLikeDT64_co: TypeAlias = ( + _SupportsArray[dtype[datetime64]] + | _NestedSequence[_SupportsArray[dtype[datetime64]]] +) +_ArrayLikeObject_co: TypeAlias = ( + _SupportsArray[dtype[object_]] + | _NestedSequence[_SupportsArray[dtype[object_]]] +) + +_ArrayLikeVoid_co: TypeAlias = ( + _SupportsArray[dtype[void]] + | _NestedSequence[_SupportsArray[dtype[void]]] +) +_ArrayLikeStr_co: TypeAlias = _DualArrayLike[ + dtype[str_], + str, +] +_ArrayLikeBytes_co: TypeAlias = _DualArrayLike[ + dtype[bytes_], + bytes, +] + +# NOTE: This includes `builtins.bool`, but not `numpy.bool`. +_ArrayLikeInt: TypeAlias = _DualArrayLike[ + dtype[integer[Any]], + int, +] + +# Extra ArrayLike type so that pyright can deal with NDArray[Any] +# Used as the first overload, should only match NDArray[Any], +# not any actual types. +# https://github.com/numpy/numpy/pull/22193 +if sys.version_info >= (3, 11): + from typing import Never as _UnknownType +else: + from typing import NoReturn as _UnknownType + + +_ArrayLikeUnknown: TypeAlias = _DualArrayLike[ + dtype[_UnknownType], + _UnknownType, +] diff --git a/venv/lib/python3.12/site-packages/numpy/_typing/_callable.pyi b/venv/lib/python3.12/site-packages/numpy/_typing/_callable.pyi new file mode 100644 index 00000000..2dd22336 --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_typing/_callable.pyi @@ -0,0 +1,381 @@ +""" +A module with various ``typing.Protocol`` subclasses that implement +the ``__call__`` magic method. + +See the `Mypy documentation`_ on protocols for more details. + +.. _`Mypy documentation`: https://mypy.readthedocs.io/en/stable/protocols.html#callback-protocols + +""" + +from __future__ import annotations + +from typing import ( + TypeAlias, + TypeVar, + final, + overload, + Any, + NoReturn, + Protocol, +) + +import numpy as np +from numpy import ( + generic, + timedelta64, + number, + integer, + unsignedinteger, + signedinteger, + int8, + int_, + floating, + float64, + complexfloating, + complex128, +) +from ._nbit import _NBitInt, _NBitDouble +from ._scalars import ( + _BoolLike_co, + _IntLike_co, + _FloatLike_co, + _NumberLike_co, +) +from . import NBitBase +from ._array_like import NDArray +from ._nested_sequence import _NestedSequence + +_T1 = TypeVar("_T1") +_T2 = TypeVar("_T2") +_T1_contra = TypeVar("_T1_contra", contravariant=True) +_T2_contra = TypeVar("_T2_contra", contravariant=True) + +_2Tuple: TypeAlias = tuple[_T1, _T1] + +_NBit1 = TypeVar("_NBit1", bound=NBitBase) +_NBit2 = TypeVar("_NBit2", bound=NBitBase) + +_IntType = TypeVar("_IntType", bound=integer) +_FloatType = TypeVar("_FloatType", bound=floating) +_NumberType = TypeVar("_NumberType", bound=number) +_NumberType_co = TypeVar("_NumberType_co", covariant=True, bound=number) +_GenericType_co = TypeVar("_GenericType_co", covariant=True, bound=generic) + +class _BoolOp(Protocol[_GenericType_co]): + @overload + def __call__(self, other: _BoolLike_co, /) -> _GenericType_co: ... + @overload # platform dependent + def __call__(self, other: int, /) -> int_: ... + @overload + def __call__(self, other: float, /) -> float64: ... + @overload + def __call__(self, other: complex, /) -> complex128: ... + @overload + def __call__(self, other: _NumberType, /) -> _NumberType: ... + +class _BoolBitOp(Protocol[_GenericType_co]): + @overload + def __call__(self, other: _BoolLike_co, /) -> _GenericType_co: ... + @overload # platform dependent + def __call__(self, other: int, /) -> int_: ... + @overload + def __call__(self, other: _IntType, /) -> _IntType: ... + +class _BoolSub(Protocol): + # Note that `other: bool` is absent here + @overload + def __call__(self, other: bool, /) -> NoReturn: ... + @overload # platform dependent + def __call__(self, other: int, /) -> int_: ... + @overload + def __call__(self, other: float, /) -> float64: ... + @overload + def __call__(self, other: complex, /) -> complex128: ... + @overload + def __call__(self, other: _NumberType, /) -> _NumberType: ... + +class _BoolTrueDiv(Protocol): + @overload + def __call__(self, other: float | _IntLike_co, /) -> float64: ... + @overload + def __call__(self, other: complex, /) -> complex128: ... + @overload + def __call__(self, other: _NumberType, /) -> _NumberType: ... + +class _BoolMod(Protocol): + @overload + def __call__(self, other: _BoolLike_co, /) -> int8: ... + @overload # platform dependent + def __call__(self, other: int, /) -> int_: ... + @overload + def __call__(self, other: float, /) -> float64: ... + @overload + def __call__(self, other: _IntType, /) -> _IntType: ... + @overload + def __call__(self, other: _FloatType, /) -> _FloatType: ... + +class _BoolDivMod(Protocol): + @overload + def __call__(self, other: _BoolLike_co, /) -> _2Tuple[int8]: ... + @overload # platform dependent + def __call__(self, other: int, /) -> _2Tuple[int_]: ... + @overload + def __call__(self, other: float, /) -> _2Tuple[floating[_NBit1 | _NBitDouble]]: ... + @overload + def __call__(self, other: _IntType, /) -> _2Tuple[_IntType]: ... + @overload + def __call__(self, other: _FloatType, /) -> _2Tuple[_FloatType]: ... + +class _TD64Div(Protocol[_NumberType_co]): + @overload + def __call__(self, other: timedelta64, /) -> _NumberType_co: ... + @overload + def __call__(self, other: _BoolLike_co, /) -> NoReturn: ... + @overload + def __call__(self, other: _FloatLike_co, /) -> timedelta64: ... + +class _IntTrueDiv(Protocol[_NBit1]): + @overload + def __call__(self, other: bool, /) -> floating[_NBit1]: ... + @overload + def __call__(self, other: int, /) -> floating[_NBit1 | _NBitInt]: ... + @overload + def __call__(self, other: float, /) -> floating[_NBit1 | _NBitDouble]: ... + @overload + def __call__( + self, other: complex, /, + ) -> complexfloating[_NBit1 | _NBitDouble, _NBit1 | _NBitDouble]: ... + @overload + def __call__(self, other: integer[_NBit2], /) -> floating[_NBit1 | _NBit2]: ... + +class _UnsignedIntOp(Protocol[_NBit1]): + # NOTE: `uint64 + signedinteger -> float64` + @overload + def __call__(self, other: bool, /) -> unsignedinteger[_NBit1]: ... + @overload + def __call__( + self, other: int | signedinteger[Any], / + ) -> Any: ... + @overload + def __call__(self, other: float, /) -> floating[_NBit1 | _NBitDouble]: ... + @overload + def __call__( + self, other: complex, /, + ) -> complexfloating[_NBit1 | _NBitDouble, _NBit1 | _NBitDouble]: ... + @overload + def __call__( + self, other: unsignedinteger[_NBit2], / + ) -> unsignedinteger[_NBit1 | _NBit2]: ... + +class _UnsignedIntBitOp(Protocol[_NBit1]): + @overload + def __call__(self, other: bool, /) -> unsignedinteger[_NBit1]: ... + @overload + def __call__(self, other: int, /) -> signedinteger[Any]: ... + @overload + def __call__(self, other: signedinteger[Any], /) -> signedinteger[Any]: ... + @overload + def __call__( + self, other: unsignedinteger[_NBit2], / + ) -> unsignedinteger[_NBit1 | _NBit2]: ... + +class _UnsignedIntMod(Protocol[_NBit1]): + @overload + def __call__(self, other: bool, /) -> unsignedinteger[_NBit1]: ... + @overload + def __call__( + self, other: int | signedinteger[Any], / + ) -> Any: ... + @overload + def __call__(self, other: float, /) -> floating[_NBit1 | _NBitDouble]: ... + @overload + def __call__( + self, other: unsignedinteger[_NBit2], / + ) -> unsignedinteger[_NBit1 | _NBit2]: ... + +class _UnsignedIntDivMod(Protocol[_NBit1]): + @overload + def __call__(self, other: bool, /) -> _2Tuple[signedinteger[_NBit1]]: ... + @overload + def __call__( + self, other: int | signedinteger[Any], / + ) -> _2Tuple[Any]: ... + @overload + def __call__(self, other: float, /) -> _2Tuple[floating[_NBit1 | _NBitDouble]]: ... + @overload + def __call__( + self, other: unsignedinteger[_NBit2], / + ) -> _2Tuple[unsignedinteger[_NBit1 | _NBit2]]: ... + +class _SignedIntOp(Protocol[_NBit1]): + @overload + def __call__(self, other: bool, /) -> signedinteger[_NBit1]: ... + @overload + def __call__(self, other: int, /) -> signedinteger[_NBit1 | _NBitInt]: ... + @overload + def __call__(self, other: float, /) -> floating[_NBit1 | _NBitDouble]: ... + @overload + def __call__( + self, other: complex, /, + ) -> complexfloating[_NBit1 | _NBitDouble, _NBit1 | _NBitDouble]: ... + @overload + def __call__( + self, other: signedinteger[_NBit2], /, + ) -> signedinteger[_NBit1 | _NBit2]: ... + +class _SignedIntBitOp(Protocol[_NBit1]): + @overload + def __call__(self, other: bool, /) -> signedinteger[_NBit1]: ... + @overload + def __call__(self, other: int, /) -> signedinteger[_NBit1 | _NBitInt]: ... + @overload + def __call__( + self, other: signedinteger[_NBit2], /, + ) -> signedinteger[_NBit1 | _NBit2]: ... + +class _SignedIntMod(Protocol[_NBit1]): + @overload + def __call__(self, other: bool, /) -> signedinteger[_NBit1]: ... + @overload + def __call__(self, other: int, /) -> signedinteger[_NBit1 | _NBitInt]: ... + @overload + def __call__(self, other: float, /) -> floating[_NBit1 | _NBitDouble]: ... + @overload + def __call__( + self, other: signedinteger[_NBit2], /, + ) -> signedinteger[_NBit1 | _NBit2]: ... + +class _SignedIntDivMod(Protocol[_NBit1]): + @overload + def __call__(self, other: bool, /) -> _2Tuple[signedinteger[_NBit1]]: ... + @overload + def __call__(self, other: int, /) -> _2Tuple[signedinteger[_NBit1 | _NBitInt]]: ... + @overload + def __call__(self, other: float, /) -> _2Tuple[floating[_NBit1 | _NBitDouble]]: ... + @overload + def __call__( + self, other: signedinteger[_NBit2], /, + ) -> _2Tuple[signedinteger[_NBit1 | _NBit2]]: ... + +class _FloatOp(Protocol[_NBit1]): + @overload + def __call__(self, other: bool, /) -> floating[_NBit1]: ... + @overload + def __call__(self, other: int, /) -> floating[_NBit1 | _NBitInt]: ... + @overload + def __call__(self, other: float, /) -> floating[_NBit1 | _NBitDouble]: ... + @overload + def __call__( + self, other: complex, /, + ) -> complexfloating[_NBit1 | _NBitDouble, _NBit1 | _NBitDouble]: ... + @overload + def __call__( + self, other: integer[_NBit2] | floating[_NBit2], / + ) -> floating[_NBit1 | _NBit2]: ... + +class _FloatMod(Protocol[_NBit1]): + @overload + def __call__(self, other: bool, /) -> floating[_NBit1]: ... + @overload + def __call__(self, other: int, /) -> floating[_NBit1 | _NBitInt]: ... + @overload + def __call__(self, other: float, /) -> floating[_NBit1 | _NBitDouble]: ... + @overload + def __call__( + self, other: integer[_NBit2] | floating[_NBit2], / + ) -> floating[_NBit1 | _NBit2]: ... + +class _FloatDivMod(Protocol[_NBit1]): + @overload + def __call__(self, other: bool, /) -> _2Tuple[floating[_NBit1]]: ... + @overload + def __call__(self, other: int, /) -> _2Tuple[floating[_NBit1 | _NBitInt]]: ... + @overload + def __call__(self, other: float, /) -> _2Tuple[floating[_NBit1 | _NBitDouble]]: ... + @overload + def __call__( + self, other: integer[_NBit2] | floating[_NBit2], / + ) -> _2Tuple[floating[_NBit1 | _NBit2]]: ... + +class _ComplexOp(Protocol[_NBit1]): + @overload + def __call__(self, other: bool, /) -> complexfloating[_NBit1, _NBit1]: ... + @overload + def __call__(self, other: int, /) -> complexfloating[_NBit1 | _NBitInt, _NBit1 | _NBitInt]: ... + @overload + def __call__( + self, other: complex, /, + ) -> complexfloating[_NBit1 | _NBitDouble, _NBit1 | _NBitDouble]: ... + @overload + def __call__( + self, + other: ( + integer[_NBit2] + | floating[_NBit2] + | complexfloating[_NBit2, _NBit2] + ), /, + ) -> complexfloating[_NBit1 | _NBit2, _NBit1 | _NBit2]: ... + +class _NumberOp(Protocol): + def __call__(self, other: _NumberLike_co, /) -> Any: ... + +@final +class _SupportsLT(Protocol): + def __lt__(self, other: Any, /) -> Any: ... + +@final +class _SupportsLE(Protocol): + def __le__(self, other: Any, /) -> Any: ... + +@final +class _SupportsGT(Protocol): + def __gt__(self, other: Any, /) -> Any: ... + +@final +class _SupportsGE(Protocol): + def __ge__(self, other: Any, /) -> Any: ... + +@final +class _ComparisonOpLT(Protocol[_T1_contra, _T2_contra]): + @overload + def __call__(self, other: _T1_contra, /) -> np.bool: ... + @overload + def __call__(self, other: _T2_contra, /) -> NDArray[np.bool]: ... + @overload + def __call__(self, other: _NestedSequence[_SupportsGT], /) -> NDArray[np.bool]: ... + @overload + def __call__(self, other: _SupportsGT, /) -> np.bool: ... + +@final +class _ComparisonOpLE(Protocol[_T1_contra, _T2_contra]): + @overload + def __call__(self, other: _T1_contra, /) -> np.bool: ... + @overload + def __call__(self, other: _T2_contra, /) -> NDArray[np.bool]: ... + @overload + def __call__(self, other: _NestedSequence[_SupportsGE], /) -> NDArray[np.bool]: ... + @overload + def __call__(self, other: _SupportsGE, /) -> np.bool: ... + +@final +class _ComparisonOpGT(Protocol[_T1_contra, _T2_contra]): + @overload + def __call__(self, other: _T1_contra, /) -> np.bool: ... + @overload + def __call__(self, other: _T2_contra, /) -> NDArray[np.bool]: ... + @overload + def __call__(self, other: _NestedSequence[_SupportsLT], /) -> NDArray[np.bool]: ... + @overload + def __call__(self, other: _SupportsLT, /) -> np.bool: ... + +@final +class _ComparisonOpGE(Protocol[_T1_contra, _T2_contra]): + @overload + def __call__(self, other: _T1_contra, /) -> np.bool: ... + @overload + def __call__(self, other: _T2_contra, /) -> NDArray[np.bool]: ... + @overload + def __call__(self, other: _NestedSequence[_SupportsGT], /) -> NDArray[np.bool]: ... + @overload + def __call__(self, other: _SupportsGT, /) -> np.bool: ... diff --git a/venv/lib/python3.12/site-packages/numpy/_typing/_char_codes.py b/venv/lib/python3.12/site-packages/numpy/_typing/_char_codes.py new file mode 100644 index 00000000..1d36cc81 --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_typing/_char_codes.py @@ -0,0 +1,141 @@ +from typing import Literal + +_BoolCodes = Literal["bool", "bool_", "?", "|?", "=?", "?"] + +_UInt8Codes = Literal["uint8", "u1", "|u1", "=u1", "u1"] +_UInt16Codes = Literal["uint16", "u2", "|u2", "=u2", "u2"] +_UInt32Codes = Literal["uint32", "u4", "|u4", "=u4", "u4"] +_UInt64Codes = Literal["uint64", "u8", "|u8", "=u8", "u8"] + +_Int8Codes = Literal["int8", "i1", "|i1", "=i1", "i1"] +_Int16Codes = Literal["int16", "i2", "|i2", "=i2", "i2"] +_Int32Codes = Literal["int32", "i4", "|i4", "=i4", "i4"] +_Int64Codes = Literal["int64", "i8", "|i8", "=i8", "i8"] + +_Float16Codes = Literal["float16", "f2", "|f2", "=f2", "f2"] +_Float32Codes = Literal["float32", "f4", "|f4", "=f4", "f4"] +_Float64Codes = Literal["float64", "f8", "|f8", "=f8", "f8"] + +_Complex64Codes = Literal["complex64", "c8", "|c8", "=c8", "c8"] +_Complex128Codes = Literal["complex128", "c16", "|c16", "=c16", "c16"] + +_ByteCodes = Literal["byte", "b", "|b", "=b", "b"] +_ShortCodes = Literal["short", "h", "|h", "=h", "h"] +_IntCCodes = Literal["intc", "i", "|i", "=i", "i"] +_IntPCodes = Literal["intp", "int", "int_", "n", "|n", "=n", "n"] +_LongCodes = Literal["long", "l", "|l", "=l", "l"] +_IntCodes = _IntPCodes +_LongLongCodes = Literal["longlong", "q", "|q", "=q", "q"] + +_UByteCodes = Literal["ubyte", "B", "|B", "=B", "B"] +_UShortCodes = Literal["ushort", "H", "|H", "=H", "H"] +_UIntCCodes = Literal["uintc", "I", "|I", "=I", "I"] +_UIntPCodes = Literal["uintp", "uint", "N", "|N", "=N", "N"] +_ULongCodes = Literal["ulong", "L", "|L", "=L", "L"] +_UIntCodes = _UIntPCodes +_ULongLongCodes = Literal["ulonglong", "Q", "|Q", "=Q", "Q"] + +_HalfCodes = Literal["half", "e", "|e", "=e", "e"] +_SingleCodes = Literal["single", "f", "|f", "=f", "f"] +_DoubleCodes = Literal["double", "float", "d", "|d", "=d", "d"] +_LongDoubleCodes = Literal["longdouble", "g", "|g", "=g", "g"] + +_CSingleCodes = Literal["csingle", "F", "|F", "=F", "F"] +_CDoubleCodes = Literal["cdouble", "complex", "D", "|D", "=D", "D"] +_CLongDoubleCodes = Literal["clongdouble", "G", "|G", "=G", "G"] + +_StrCodes = Literal["str", "str_", "unicode", "U", "|U", "=U", "U"] +_BytesCodes = Literal["bytes", "bytes_", "S", "|S", "=S", "S"] +_VoidCodes = Literal["void", "V", "|V", "=V", "V"] +_ObjectCodes = Literal["object", "object_", "O", "|O", "=O", "O"] + +_DT64Codes = Literal[ + "datetime64", "|datetime64", "=datetime64", + "datetime64", + "datetime64[Y]", "|datetime64[Y]", "=datetime64[Y]", + "datetime64[Y]", + "datetime64[M]", "|datetime64[M]", "=datetime64[M]", + "datetime64[M]", + "datetime64[W]", "|datetime64[W]", "=datetime64[W]", + "datetime64[W]", + "datetime64[D]", "|datetime64[D]", "=datetime64[D]", + "datetime64[D]", + "datetime64[h]", "|datetime64[h]", "=datetime64[h]", + "datetime64[h]", + "datetime64[m]", "|datetime64[m]", "=datetime64[m]", + "datetime64[m]", + "datetime64[s]", "|datetime64[s]", "=datetime64[s]", + "datetime64[s]", + "datetime64[ms]", "|datetime64[ms]", "=datetime64[ms]", + "datetime64[ms]", + "datetime64[us]", "|datetime64[us]", "=datetime64[us]", + "datetime64[us]", + "datetime64[ns]", "|datetime64[ns]", "=datetime64[ns]", + "datetime64[ns]", + "datetime64[ps]", "|datetime64[ps]", "=datetime64[ps]", + "datetime64[ps]", + "datetime64[fs]", "|datetime64[fs]", "=datetime64[fs]", + "datetime64[fs]", + "datetime64[as]", "|datetime64[as]", "=datetime64[as]", + "datetime64[as]", + "M", "|M", "=M", "M", + "M8", "|M8", "=M8", "M8", + "M8[Y]", "|M8[Y]", "=M8[Y]", "M8[Y]", + "M8[M]", "|M8[M]", "=M8[M]", "M8[M]", + "M8[W]", "|M8[W]", "=M8[W]", "M8[W]", + "M8[D]", "|M8[D]", "=M8[D]", "M8[D]", + "M8[h]", "|M8[h]", "=M8[h]", "M8[h]", + "M8[m]", "|M8[m]", "=M8[m]", "M8[m]", + "M8[s]", "|M8[s]", "=M8[s]", "M8[s]", + "M8[ms]", "|M8[ms]", "=M8[ms]", "M8[ms]", + "M8[us]", "|M8[us]", "=M8[us]", "M8[us]", + "M8[ns]", "|M8[ns]", "=M8[ns]", "M8[ns]", + "M8[ps]", "|M8[ps]", "=M8[ps]", "M8[ps]", + "M8[fs]", "|M8[fs]", "=M8[fs]", "M8[fs]", + "M8[as]", "|M8[as]", "=M8[as]", "M8[as]", +] +_TD64Codes = Literal[ + "timedelta64", "|timedelta64", "=timedelta64", + "timedelta64", + "timedelta64[Y]", "|timedelta64[Y]", "=timedelta64[Y]", + "timedelta64[Y]", + "timedelta64[M]", "|timedelta64[M]", "=timedelta64[M]", + "timedelta64[M]", + "timedelta64[W]", "|timedelta64[W]", "=timedelta64[W]", + "timedelta64[W]", + "timedelta64[D]", "|timedelta64[D]", "=timedelta64[D]", + "timedelta64[D]", + "timedelta64[h]", "|timedelta64[h]", "=timedelta64[h]", + "timedelta64[h]", + "timedelta64[m]", "|timedelta64[m]", "=timedelta64[m]", + "timedelta64[m]", + "timedelta64[s]", "|timedelta64[s]", "=timedelta64[s]", + "timedelta64[s]", + "timedelta64[ms]", "|timedelta64[ms]", "=timedelta64[ms]", + "timedelta64[ms]", + "timedelta64[us]", "|timedelta64[us]", "=timedelta64[us]", + "timedelta64[us]", + "timedelta64[ns]", "|timedelta64[ns]", "=timedelta64[ns]", + "timedelta64[ns]", + "timedelta64[ps]", "|timedelta64[ps]", "=timedelta64[ps]", + "timedelta64[ps]", + "timedelta64[fs]", "|timedelta64[fs]", "=timedelta64[fs]", + "timedelta64[fs]", + "timedelta64[as]", "|timedelta64[as]", "=timedelta64[as]", + "timedelta64[as]", + "m", "|m", "=m", "m", + "m8", "|m8", "=m8", "m8", + "m8[Y]", "|m8[Y]", "=m8[Y]", "m8[Y]", + "m8[M]", "|m8[M]", "=m8[M]", "m8[M]", + "m8[W]", "|m8[W]", "=m8[W]", "m8[W]", + "m8[D]", "|m8[D]", "=m8[D]", "m8[D]", + "m8[h]", "|m8[h]", "=m8[h]", "m8[h]", + "m8[m]", "|m8[m]", "=m8[m]", "m8[m]", + "m8[s]", "|m8[s]", "=m8[s]", "m8[s]", + "m8[ms]", "|m8[ms]", "=m8[ms]", "m8[ms]", + "m8[us]", "|m8[us]", "=m8[us]", "m8[us]", + "m8[ns]", "|m8[ns]", "=m8[ns]", "m8[ns]", + "m8[ps]", "|m8[ps]", "=m8[ps]", "m8[ps]", + "m8[fs]", "|m8[fs]", "=m8[fs]", "m8[fs]", + "m8[as]", "|m8[as]", "=m8[as]", "m8[as]", +] diff --git a/venv/lib/python3.12/site-packages/numpy/_typing/_dtype_like.py b/venv/lib/python3.12/site-packages/numpy/_typing/_dtype_like.py new file mode 100644 index 00000000..b68b5337 --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_typing/_dtype_like.py @@ -0,0 +1,249 @@ +from collections.abc import Sequence +from typing import ( + Any, + TypeAlias, + TypeVar, + Protocol, + TypedDict, + runtime_checkable, +) + +import numpy as np + +from ._shape import _ShapeLike + +from ._char_codes import ( + _BoolCodes, + _UInt8Codes, + _UInt16Codes, + _UInt32Codes, + _UInt64Codes, + _Int8Codes, + _Int16Codes, + _Int32Codes, + _Int64Codes, + _Float16Codes, + _Float32Codes, + _Float64Codes, + _Complex64Codes, + _Complex128Codes, + _ByteCodes, + _ShortCodes, + _IntCCodes, + _LongCodes, + _LongLongCodes, + _IntPCodes, + _IntCodes, + _UByteCodes, + _UShortCodes, + _UIntCCodes, + _ULongCodes, + _ULongLongCodes, + _UIntPCodes, + _UIntCodes, + _HalfCodes, + _SingleCodes, + _DoubleCodes, + _LongDoubleCodes, + _CSingleCodes, + _CDoubleCodes, + _CLongDoubleCodes, + _DT64Codes, + _TD64Codes, + _StrCodes, + _BytesCodes, + _VoidCodes, + _ObjectCodes, +) + +_SCT = TypeVar("_SCT", bound=np.generic) +_DType_co = TypeVar("_DType_co", covariant=True, bound=np.dtype[Any]) + +_DTypeLikeNested: TypeAlias = Any # TODO: wait for support for recursive types + + +# Mandatory keys +class _DTypeDictBase(TypedDict): + names: Sequence[str] + formats: Sequence[_DTypeLikeNested] + + +# Mandatory + optional keys +class _DTypeDict(_DTypeDictBase, total=False): + # Only `str` elements are usable as indexing aliases, + # but `titles` can in principle accept any object + offsets: Sequence[int] + titles: Sequence[Any] + itemsize: int + aligned: bool + + +# A protocol for anything with the dtype attribute +@runtime_checkable +class _SupportsDType(Protocol[_DType_co]): + @property + def dtype(self) -> _DType_co: ... + + +# A subset of `npt.DTypeLike` that can be parametrized w.r.t. `np.generic` +_DTypeLike: TypeAlias = ( + np.dtype[_SCT] + | type[_SCT] + | _SupportsDType[np.dtype[_SCT]] +) + + +# Would create a dtype[np.void] +_VoidDTypeLike: TypeAlias = ( + # (flexible_dtype, itemsize) + tuple[_DTypeLikeNested, int] + # (fixed_dtype, shape) + | tuple[_DTypeLikeNested, _ShapeLike] + # [(field_name, field_dtype, field_shape), ...] + # + # The type here is quite broad because NumPy accepts quite a wide + # range of inputs inside the list; see the tests for some + # examples. + | list[Any] + # {'names': ..., 'formats': ..., 'offsets': ..., 'titles': ..., + # 'itemsize': ...} + | _DTypeDict + # (base_dtype, new_dtype) + | tuple[_DTypeLikeNested, _DTypeLikeNested] +) + +# Anything that can be coerced into numpy.dtype. +# Reference: https://docs.scipy.org/doc/numpy/reference/arrays.dtypes.html +DTypeLike: TypeAlias = ( + np.dtype[Any] + # default data type (float64) + | None + # array-scalar types and generic types + | type[Any] # NOTE: We're stuck with `type[Any]` due to object dtypes + # anything with a dtype attribute + | _SupportsDType[np.dtype[Any]] + # character codes, type strings or comma-separated fields, e.g., 'float64' + | str + | _VoidDTypeLike +) + +# NOTE: while it is possible to provide the dtype as a dict of +# dtype-like objects (e.g. `{'field1': ..., 'field2': ..., ...}`), +# this syntax is officially discourged and +# therefore not included in the type-union defining `DTypeLike`. +# +# See https://github.com/numpy/numpy/issues/16891 for more details. + +# Aliases for commonly used dtype-like objects. +# Note that the precision of `np.number` subclasses is ignored herein. +_DTypeLikeBool: TypeAlias = ( + type[bool] + | type[np.bool] + | np.dtype[np.bool] + | _SupportsDType[np.dtype[np.bool]] + | _BoolCodes +) +_DTypeLikeUInt: TypeAlias = ( + type[np.unsignedinteger] + | np.dtype[np.unsignedinteger] + | _SupportsDType[np.dtype[np.unsignedinteger]] + | _UInt8Codes + | _UInt16Codes + | _UInt32Codes + | _UInt64Codes + | _UByteCodes + | _UShortCodes + | _UIntCCodes + | _LongCodes + | _ULongLongCodes + | _UIntPCodes + | _UIntCodes +) +_DTypeLikeInt: TypeAlias = ( + type[int] + | type[np.signedinteger] + | np.dtype[np.signedinteger] + | _SupportsDType[np.dtype[np.signedinteger]] + | _Int8Codes + | _Int16Codes + | _Int32Codes + | _Int64Codes + | _ByteCodes + | _ShortCodes + | _IntCCodes + | _LongCodes + | _LongLongCodes + | _IntPCodes + | _IntCodes +) +_DTypeLikeFloat: TypeAlias = ( + type[float] + | type[np.floating] + | np.dtype[np.floating] + | _SupportsDType[np.dtype[np.floating]] + | _Float16Codes + | _Float32Codes + | _Float64Codes + | _HalfCodes + | _SingleCodes + | _DoubleCodes + | _LongDoubleCodes +) +_DTypeLikeComplex: TypeAlias = ( + type[complex] + | type[np.complexfloating] + | np.dtype[np.complexfloating] + | _SupportsDType[np.dtype[np.complexfloating]] + | _Complex64Codes + | _Complex128Codes + | _CSingleCodes + | _CDoubleCodes + | _CLongDoubleCodes +) +_DTypeLikeDT64: TypeAlias = ( + type[np.timedelta64] + | np.dtype[np.timedelta64] + | _SupportsDType[np.dtype[np.timedelta64]] + | _TD64Codes +) +_DTypeLikeTD64: TypeAlias = ( + type[np.datetime64] + | np.dtype[np.datetime64] + | _SupportsDType[np.dtype[np.datetime64]] + | _DT64Codes +) +_DTypeLikeStr: TypeAlias = ( + type[str] + | type[np.str_] + | np.dtype[np.str_] + | _SupportsDType[np.dtype[np.str_]] + | _StrCodes +) +_DTypeLikeBytes: TypeAlias = ( + type[bytes] + | type[np.bytes_] + | np.dtype[np.bytes_] + | _SupportsDType[np.dtype[np.bytes_]] + | _BytesCodes +) +_DTypeLikeVoid: TypeAlias = ( + type[np.void] + | np.dtype[np.void] + | _SupportsDType[np.dtype[np.void]] + | _VoidCodes + | _VoidDTypeLike +) +_DTypeLikeObject: TypeAlias = ( + type + | np.dtype[np.object_] + | _SupportsDType[np.dtype[np.object_]] + | _ObjectCodes +) + +_DTypeLikeComplex_co: TypeAlias = ( + _DTypeLikeBool + | _DTypeLikeUInt + | _DTypeLikeInt + | _DTypeLikeFloat + | _DTypeLikeComplex +) diff --git a/venv/lib/python3.12/site-packages/numpy/_typing/_extended_precision.py b/venv/lib/python3.12/site-packages/numpy/_typing/_extended_precision.py new file mode 100644 index 00000000..7246b47d --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_typing/_extended_precision.py @@ -0,0 +1,27 @@ +"""A module with platform-specific extended precision +`numpy.number` subclasses. + +The subclasses are defined here (instead of ``__init__.pyi``) such +that they can be imported conditionally via the numpy's mypy plugin. +""" + +import numpy as np +from . import ( + _80Bit, + _96Bit, + _128Bit, + _256Bit, +) + +uint128 = np.unsignedinteger[_128Bit] +uint256 = np.unsignedinteger[_256Bit] +int128 = np.signedinteger[_128Bit] +int256 = np.signedinteger[_256Bit] +float80 = np.floating[_80Bit] +float96 = np.floating[_96Bit] +float128 = np.floating[_128Bit] +float256 = np.floating[_256Bit] +complex160 = np.complexfloating[_80Bit, _80Bit] +complex192 = np.complexfloating[_96Bit, _96Bit] +complex256 = np.complexfloating[_128Bit, _128Bit] +complex512 = np.complexfloating[_256Bit, _256Bit] diff --git a/venv/lib/python3.12/site-packages/numpy/_typing/_nbit.py b/venv/lib/python3.12/site-packages/numpy/_typing/_nbit.py new file mode 100644 index 00000000..7a4ca883 --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_typing/_nbit.py @@ -0,0 +1,17 @@ +"""A module with the precisions of platform-specific `~numpy.number`s.""" + +from typing import Any + +# To-be replaced with a `npt.NBitBase` subclass by numpy's mypy plugin +_NBitByte = Any +_NBitShort = Any +_NBitIntC = Any +_NBitIntP = Any +_NBitInt = Any +_NBitLong = Any +_NBitLongLong = Any + +_NBitHalf = Any +_NBitSingle = Any +_NBitDouble = Any +_NBitLongDouble = Any diff --git a/venv/lib/python3.12/site-packages/numpy/_typing/_nested_sequence.py b/venv/lib/python3.12/site-packages/numpy/_typing/_nested_sequence.py new file mode 100644 index 00000000..3d0d25ae --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_typing/_nested_sequence.py @@ -0,0 +1,86 @@ +"""A module containing the `_NestedSequence` protocol.""" + +from __future__ import annotations + +from collections.abc import Iterator +from typing import ( + Any, + TypeVar, + Protocol, + runtime_checkable, +) + +__all__ = ["_NestedSequence"] + +_T_co = TypeVar("_T_co", covariant=True) + + +@runtime_checkable +class _NestedSequence(Protocol[_T_co]): + """A protocol for representing nested sequences. + + Warning + ------- + `_NestedSequence` currently does not work in combination with typevars, + *e.g.* ``def func(a: _NestedSequnce[T]) -> T: ...``. + + See Also + -------- + collections.abc.Sequence + ABCs for read-only and mutable :term:`sequences`. + + Examples + -------- + .. code-block:: python + + >>> from __future__ import annotations + + >>> from typing import TYPE_CHECKING + >>> import numpy as np + >>> from numpy._typing import _NestedSequence + + >>> def get_dtype(seq: _NestedSequence[float]) -> np.dtype[np.float64]: + ... return np.asarray(seq).dtype + + >>> a = get_dtype([1.0]) + >>> b = get_dtype([[1.0]]) + >>> c = get_dtype([[[1.0]]]) + >>> d = get_dtype([[[[1.0]]]]) + + >>> if TYPE_CHECKING: + ... reveal_locals() + ... # note: Revealed local types are: + ... # note: a: numpy.dtype[numpy.floating[numpy._typing._64Bit]] + ... # note: b: numpy.dtype[numpy.floating[numpy._typing._64Bit]] + ... # note: c: numpy.dtype[numpy.floating[numpy._typing._64Bit]] + ... # note: d: numpy.dtype[numpy.floating[numpy._typing._64Bit]] + + """ + + def __len__(self, /) -> int: + """Implement ``len(self)``.""" + raise NotImplementedError + + def __getitem__(self, index: int, /) -> _T_co | _NestedSequence[_T_co]: + """Implement ``self[x]``.""" + raise NotImplementedError + + def __contains__(self, x: object, /) -> bool: + """Implement ``x in self``.""" + raise NotImplementedError + + def __iter__(self, /) -> Iterator[_T_co | _NestedSequence[_T_co]]: + """Implement ``iter(self)``.""" + raise NotImplementedError + + def __reversed__(self, /) -> Iterator[_T_co | _NestedSequence[_T_co]]: + """Implement ``reversed(self)``.""" + raise NotImplementedError + + def count(self, value: Any, /) -> int: + """Return the number of occurrences of `value`.""" + raise NotImplementedError + + def index(self, value: Any, /) -> int: + """Return the first index of `value`.""" + raise NotImplementedError diff --git a/venv/lib/python3.12/site-packages/numpy/_typing/_scalars.py b/venv/lib/python3.12/site-packages/numpy/_typing/_scalars.py new file mode 100644 index 00000000..97316d02 --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_typing/_scalars.py @@ -0,0 +1,27 @@ +from typing import Any, TypeAlias + +import numpy as np + +# NOTE: `_StrLike_co` and `_BytesLike_co` are pointless, as `np.str_` and +# `np.bytes_` are already subclasses of their builtin counterpart + +_CharLike_co: TypeAlias = str | bytes + +# The 6 `Like_co` type-aliases below represent all scalars that can be +# coerced into `` (with the casting rule `same_kind`) +_BoolLike_co: TypeAlias = bool | np.bool +_UIntLike_co: TypeAlias = np.unsignedinteger[Any] | _BoolLike_co +_IntLike_co: TypeAlias = int | np.integer[Any] | _BoolLike_co +_FloatLike_co: TypeAlias = float | np.floating[Any] | _IntLike_co +_ComplexLike_co: TypeAlias = ( + complex + | np.complexfloating[Any, Any] + | _FloatLike_co +) +_TD64Like_co: TypeAlias = np.timedelta64 | _IntLike_co + +_NumberLike_co: TypeAlias = int | float | complex | np.number[Any] | np.bool +_ScalarLike_co: TypeAlias = int | float | complex | str | bytes | np.generic + +# `_VoidLike_co` is technically not a scalar, but it's close enough +_VoidLike_co: TypeAlias = tuple[Any, ...] | np.void diff --git a/venv/lib/python3.12/site-packages/numpy/_typing/_shape.py b/venv/lib/python3.12/site-packages/numpy/_typing/_shape.py new file mode 100644 index 00000000..2b854d65 --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_typing/_shape.py @@ -0,0 +1,7 @@ +from collections.abc import Sequence +from typing import SupportsIndex, TypeAlias + +_Shape: TypeAlias = tuple[int, ...] + +# Anything that can be coerced to a shape tuple +_ShapeLike: TypeAlias = SupportsIndex | Sequence[SupportsIndex] diff --git a/venv/lib/python3.12/site-packages/numpy/_typing/_ufunc.pyi b/venv/lib/python3.12/site-packages/numpy/_typing/_ufunc.pyi new file mode 100644 index 00000000..9495321e --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_typing/_ufunc.pyi @@ -0,0 +1,412 @@ +"""A module with private type-check-only `numpy.ufunc` subclasses. + +The signatures of the ufuncs are too varied to reasonably type +with a single class. So instead, `ufunc` has been expanded into +four private subclasses, one for each combination of +`~ufunc.nin` and `~ufunc.nout`. + +""" + +from typing import ( + Any, + Generic, + overload, + TypeVar, + Literal, + SupportsIndex, + Protocol, + NoReturn, +) +from typing_extensions import LiteralString + +from numpy import ufunc, _CastingKind, _OrderKACF +from numpy.typing import NDArray + +from ._shape import _ShapeLike +from ._scalars import _ScalarLike_co +from ._array_like import ArrayLike, _ArrayLikeBool_co, _ArrayLikeInt_co +from ._dtype_like import DTypeLike + +_T = TypeVar("_T") +_2Tuple = tuple[_T, _T] +_3Tuple = tuple[_T, _T, _T] +_4Tuple = tuple[_T, _T, _T, _T] + +_NTypes = TypeVar("_NTypes", bound=int, covariant=True) +_IDType = TypeVar("_IDType", covariant=True) +_NameType = TypeVar("_NameType", bound=LiteralString, covariant=True) +_Signature = TypeVar("_Signature", bound=LiteralString, covariant=True) + + +class _SupportsArrayUFunc(Protocol): + def __array_ufunc__( + self, + ufunc: ufunc, + method: Literal["__call__", "reduce", "reduceat", "accumulate", "outer", "at"], + *inputs: Any, + **kwargs: Any, + ) -> Any: ... + + +# NOTE: `reduce`, `accumulate`, `reduceat` and `outer` raise a ValueError for +# ufuncs that don't accept two input arguments and return one output argument. +# In such cases the respective methods return `NoReturn` + +# NOTE: Similarly, `at` won't be defined for ufuncs that return +# multiple outputs; in such cases `at` is typed to return `NoReturn` + +# NOTE: If 2 output types are returned then `out` must be a +# 2-tuple of arrays. Otherwise `None` or a plain array are also acceptable + +class _UFunc_Nin1_Nout1(ufunc, Generic[_NameType, _NTypes, _IDType]): # type: ignore[misc] + @property + def __name__(self) -> _NameType: ... + @property + def ntypes(self) -> _NTypes: ... + @property + def identity(self) -> _IDType: ... + @property + def nin(self) -> Literal[1]: ... + @property + def nout(self) -> Literal[1]: ... + @property + def nargs(self) -> Literal[2]: ... + @property + def signature(self) -> None: ... + + @overload + def __call__( + self, + __x1: _ScalarLike_co, + out: None = ..., + *, + where: None | _ArrayLikeBool_co = ..., + casting: _CastingKind = ..., + order: _OrderKACF = ..., + dtype: DTypeLike = ..., + subok: bool = ..., + signature: str | _2Tuple[None | str] = ..., + ) -> Any: ... + @overload + def __call__( + self, + __x1: ArrayLike, + out: None | NDArray[Any] | tuple[NDArray[Any]] = ..., + *, + where: None | _ArrayLikeBool_co = ..., + casting: _CastingKind = ..., + order: _OrderKACF = ..., + dtype: DTypeLike = ..., + subok: bool = ..., + signature: str | _2Tuple[None | str] = ..., + ) -> NDArray[Any]: ... + @overload + def __call__( + self, + __x1: _SupportsArrayUFunc, + out: None | NDArray[Any] | tuple[NDArray[Any]] = ..., + *, + where: None | _ArrayLikeBool_co = ..., + casting: _CastingKind = ..., + order: _OrderKACF = ..., + dtype: DTypeLike = ..., + subok: bool = ..., + signature: str | _2Tuple[None | str] = ..., + ) -> Any: ... + + def at( + self, + a: _SupportsArrayUFunc, + indices: _ArrayLikeInt_co, + /, + ) -> None: ... + + def reduce(self, *args, **kwargs) -> NoReturn: ... + def accumulate(self, *args, **kwargs) -> NoReturn: ... + def reduceat(self, *args, **kwargs) -> NoReturn: ... + def outer(self, *args, **kwargs) -> NoReturn: ... + + +class _UFunc_Nin2_Nout1(ufunc, Generic[_NameType, _NTypes, _IDType]): # type: ignore[misc] + @property + def __name__(self) -> _NameType: ... + @property + def ntypes(self) -> _NTypes: ... + @property + def identity(self) -> _IDType: ... + @property + def nin(self) -> Literal[2]: ... + @property + def nout(self) -> Literal[1]: ... + @property + def nargs(self) -> Literal[3]: ... + @property + def signature(self) -> None: ... + + @overload + def __call__( + self, + __x1: _ScalarLike_co, + __x2: _ScalarLike_co, + out: None = ..., + *, + where: None | _ArrayLikeBool_co = ..., + casting: _CastingKind = ..., + order: _OrderKACF = ..., + dtype: DTypeLike = ..., + subok: bool = ..., + signature: str | _3Tuple[None | str] = ..., + ) -> Any: ... + @overload + def __call__( + self, + __x1: ArrayLike, + __x2: ArrayLike, + out: None | NDArray[Any] | tuple[NDArray[Any]] = ..., + *, + where: None | _ArrayLikeBool_co = ..., + casting: _CastingKind = ..., + order: _OrderKACF = ..., + dtype: DTypeLike = ..., + subok: bool = ..., + signature: str | _3Tuple[None | str] = ..., + ) -> NDArray[Any]: ... + + def at( + self, + a: NDArray[Any], + indices: _ArrayLikeInt_co, + b: ArrayLike, + /, + ) -> None: ... + + def reduce( + self, + array: ArrayLike, + axis: None | _ShapeLike = ..., + dtype: DTypeLike = ..., + out: None | NDArray[Any] = ..., + keepdims: bool = ..., + initial: Any = ..., + where: _ArrayLikeBool_co = ..., + ) -> Any: ... + + def accumulate( + self, + array: ArrayLike, + axis: SupportsIndex = ..., + dtype: DTypeLike = ..., + out: None | NDArray[Any] = ..., + ) -> NDArray[Any]: ... + + def reduceat( + self, + array: ArrayLike, + indices: _ArrayLikeInt_co, + axis: SupportsIndex = ..., + dtype: DTypeLike = ..., + out: None | NDArray[Any] = ..., + ) -> NDArray[Any]: ... + + # Expand `**kwargs` into explicit keyword-only arguments + @overload + def outer( + self, + A: _ScalarLike_co, + B: _ScalarLike_co, + /, *, + out: None = ..., + where: None | _ArrayLikeBool_co = ..., + casting: _CastingKind = ..., + order: _OrderKACF = ..., + dtype: DTypeLike = ..., + subok: bool = ..., + signature: str | _3Tuple[None | str] = ..., + ) -> Any: ... + @overload + def outer( # type: ignore[misc] + self, + A: ArrayLike, + B: ArrayLike, + /, *, + out: None | NDArray[Any] | tuple[NDArray[Any]] = ..., + where: None | _ArrayLikeBool_co = ..., + casting: _CastingKind = ..., + order: _OrderKACF = ..., + dtype: DTypeLike = ..., + subok: bool = ..., + signature: str | _3Tuple[None | str] = ..., + ) -> NDArray[Any]: ... + +class _UFunc_Nin1_Nout2(ufunc, Generic[_NameType, _NTypes, _IDType]): # type: ignore[misc] + @property + def __name__(self) -> _NameType: ... + @property + def ntypes(self) -> _NTypes: ... + @property + def identity(self) -> _IDType: ... + @property + def nin(self) -> Literal[1]: ... + @property + def nout(self) -> Literal[2]: ... + @property + def nargs(self) -> Literal[3]: ... + @property + def signature(self) -> None: ... + + @overload + def __call__( + self, + __x1: _ScalarLike_co, + __out1: None = ..., + __out2: None = ..., + *, + where: None | _ArrayLikeBool_co = ..., + casting: _CastingKind = ..., + order: _OrderKACF = ..., + dtype: DTypeLike = ..., + subok: bool = ..., + signature: str | _3Tuple[None | str] = ..., + ) -> _2Tuple[Any]: ... + @overload + def __call__( + self, + __x1: ArrayLike, + __out1: None | NDArray[Any] = ..., + __out2: None | NDArray[Any] = ..., + *, + out: _2Tuple[NDArray[Any]] = ..., + where: None | _ArrayLikeBool_co = ..., + casting: _CastingKind = ..., + order: _OrderKACF = ..., + dtype: DTypeLike = ..., + subok: bool = ..., + signature: str | _3Tuple[None | str] = ..., + ) -> _2Tuple[NDArray[Any]]: ... + @overload + def __call__( + self, + __x1: _SupportsArrayUFunc, + __out1: None | NDArray[Any] = ..., + __out2: None | NDArray[Any] = ..., + *, + out: _2Tuple[NDArray[Any]] = ..., + where: None | _ArrayLikeBool_co = ..., + casting: _CastingKind = ..., + order: _OrderKACF = ..., + dtype: DTypeLike = ..., + subok: bool = ..., + signature: str | _3Tuple[None | str] = ..., + ) -> _2Tuple[Any]: ... + + def at(self, *args, **kwargs) -> NoReturn: ... + def reduce(self, *args, **kwargs) -> NoReturn: ... + def accumulate(self, *args, **kwargs) -> NoReturn: ... + def reduceat(self, *args, **kwargs) -> NoReturn: ... + def outer(self, *args, **kwargs) -> NoReturn: ... + +class _UFunc_Nin2_Nout2(ufunc, Generic[_NameType, _NTypes, _IDType]): # type: ignore[misc] + @property + def __name__(self) -> _NameType: ... + @property + def ntypes(self) -> _NTypes: ... + @property + def identity(self) -> _IDType: ... + @property + def nin(self) -> Literal[2]: ... + @property + def nout(self) -> Literal[2]: ... + @property + def nargs(self) -> Literal[4]: ... + @property + def signature(self) -> None: ... + + @overload + def __call__( + self, + __x1: _ScalarLike_co, + __x2: _ScalarLike_co, + __out1: None = ..., + __out2: None = ..., + *, + where: None | _ArrayLikeBool_co = ..., + casting: _CastingKind = ..., + order: _OrderKACF = ..., + dtype: DTypeLike = ..., + subok: bool = ..., + signature: str | _4Tuple[None | str] = ..., + ) -> _2Tuple[Any]: ... + @overload + def __call__( + self, + __x1: ArrayLike, + __x2: ArrayLike, + __out1: None | NDArray[Any] = ..., + __out2: None | NDArray[Any] = ..., + *, + out: _2Tuple[NDArray[Any]] = ..., + where: None | _ArrayLikeBool_co = ..., + casting: _CastingKind = ..., + order: _OrderKACF = ..., + dtype: DTypeLike = ..., + subok: bool = ..., + signature: str | _4Tuple[None | str] = ..., + ) -> _2Tuple[NDArray[Any]]: ... + + def at(self, *args, **kwargs) -> NoReturn: ... + def reduce(self, *args, **kwargs) -> NoReturn: ... + def accumulate(self, *args, **kwargs) -> NoReturn: ... + def reduceat(self, *args, **kwargs) -> NoReturn: ... + def outer(self, *args, **kwargs) -> NoReturn: ... + +class _GUFunc_Nin2_Nout1(ufunc, Generic[_NameType, _NTypes, _IDType, _Signature]): # type: ignore[misc] + @property + def __name__(self) -> _NameType: ... + @property + def ntypes(self) -> _NTypes: ... + @property + def identity(self) -> _IDType: ... + @property + def nin(self) -> Literal[2]: ... + @property + def nout(self) -> Literal[1]: ... + @property + def nargs(self) -> Literal[3]: ... + @property + def signature(self) -> _Signature: ... + + # Scalar for 1D array-likes; ndarray otherwise + @overload + def __call__( + self, + __x1: ArrayLike, + __x2: ArrayLike, + out: None = ..., + *, + casting: _CastingKind = ..., + order: _OrderKACF = ..., + dtype: DTypeLike = ..., + subok: bool = ..., + signature: str | _3Tuple[None | str] = ..., + axes: list[_2Tuple[SupportsIndex]] = ..., + ) -> Any: ... + @overload + def __call__( + self, + __x1: ArrayLike, + __x2: ArrayLike, + out: NDArray[Any] | tuple[NDArray[Any]], + *, + casting: _CastingKind = ..., + order: _OrderKACF = ..., + dtype: DTypeLike = ..., + subok: bool = ..., + signature: str | _3Tuple[None | str] = ..., + axes: list[_2Tuple[SupportsIndex]] = ..., + ) -> NDArray[Any]: ... + + def at(self, *args, **kwargs) -> NoReturn: ... + def reduce(self, *args, **kwargs) -> NoReturn: ... + def accumulate(self, *args, **kwargs) -> NoReturn: ... + def reduceat(self, *args, **kwargs) -> NoReturn: ... + def outer(self, *args, **kwargs) -> NoReturn: ... diff --git a/venv/lib/python3.12/site-packages/numpy/_utils/__init__.py b/venv/lib/python3.12/site-packages/numpy/_utils/__init__.py new file mode 100644 index 00000000..9794c4e0 --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_utils/__init__.py @@ -0,0 +1,87 @@ +""" +This is a module for defining private helpers which do not depend on the +rest of NumPy. + +Everything in here must be self-contained so that it can be +imported anywhere else without creating circular imports. +If a utility requires the import of NumPy, it probably belongs +in ``numpy._core``. +""" + +import functools +import warnings +from ._convertions import asunicode, asbytes + + +def set_module(module): + """Private decorator for overriding __module__ on a function or class. + + Example usage:: + + @set_module('numpy') + def example(): + pass + + assert example.__module__ == 'numpy' + """ + def decorator(func): + if module is not None: + func.__module__ = module + return func + return decorator + + +def _rename_parameter(old_names, new_names, dep_version=None): + """ + Generate decorator for backward-compatible keyword renaming. + + Apply the decorator generated by `_rename_parameter` to functions with a + renamed parameter to maintain backward-compatibility. + + After decoration, the function behaves as follows: + If only the new parameter is passed into the function, behave as usual. + If only the old parameter is passed into the function (as a keyword), raise + a DeprecationWarning if `dep_version` is provided, and behave as usual + otherwise. + If both old and new parameters are passed into the function, raise a + DeprecationWarning if `dep_version` is provided, and raise the appropriate + TypeError (function got multiple values for argument). + + Parameters + ---------- + old_names : list of str + Old names of parameters + new_name : list of str + New names of parameters + dep_version : str, optional + Version of NumPy in which old parameter was deprecated in the format + 'X.Y.Z'. If supplied, the deprecation message will indicate that + support for the old parameter will be removed in version 'X.Y+2.Z' + + Notes + ----- + Untested with functions that accept *args. Probably won't work as written. + + """ + def decorator(fun): + @functools.wraps(fun) + def wrapper(*args, **kwargs): + for old_name, new_name in zip(old_names, new_names): + if old_name in kwargs: + if dep_version: + end_version = dep_version.split('.') + end_version[1] = str(int(end_version[1]) + 2) + end_version = '.'.join(end_version) + msg = (f"Use of keyword argument `{old_name}` is " + f"deprecated and replaced by `{new_name}`. " + f"Support for `{old_name}` will be removed " + f"in NumPy {end_version}.") + warnings.warn(msg, DeprecationWarning, stacklevel=2) + if new_name in kwargs: + msg = (f"{fun.__name__}() got multiple values for " + f"argument now known as `{new_name}`") + raise TypeError(msg) + kwargs[new_name] = kwargs.pop(old_name) + return fun(*args, **kwargs) + return wrapper + return decorator diff --git a/venv/lib/python3.12/site-packages/numpy/_utils/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/_utils/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 00000000..e6fa48cd Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/_utils/__pycache__/__init__.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/numpy/_utils/__pycache__/_convertions.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/_utils/__pycache__/_convertions.cpython-312.pyc new file mode 100644 index 00000000..896202fc Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/_utils/__pycache__/_convertions.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/numpy/_utils/__pycache__/_inspect.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/_utils/__pycache__/_inspect.cpython-312.pyc new file mode 100644 index 00000000..b7e42bc1 Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/_utils/__pycache__/_inspect.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/numpy/_utils/__pycache__/_pep440.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/_utils/__pycache__/_pep440.cpython-312.pyc new file mode 100644 index 00000000..629bc523 Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/_utils/__pycache__/_pep440.cpython-312.pyc differ diff --git a/venv/lib/python3.12/site-packages/numpy/_utils/_convertions.py b/venv/lib/python3.12/site-packages/numpy/_utils/_convertions.py new file mode 100644 index 00000000..ab15a8ba --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_utils/_convertions.py @@ -0,0 +1,18 @@ +""" +A set of methods retained from np.compat module that +are still used across codebase. +""" + +__all__ = ["asunicode", "asbytes"] + + +def asunicode(s): + if isinstance(s, bytes): + return s.decode('latin1') + return str(s) + + +def asbytes(s): + if isinstance(s, bytes): + return s + return str(s).encode('latin1') diff --git a/venv/lib/python3.12/site-packages/numpy/_utils/_inspect.py b/venv/lib/python3.12/site-packages/numpy/_utils/_inspect.py new file mode 100644 index 00000000..9a874a71 --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_utils/_inspect.py @@ -0,0 +1,191 @@ +"""Subset of inspect module from upstream python + +We use this instead of upstream because upstream inspect is slow to import, and +significantly contributes to numpy import times. Importing this copy has almost +no overhead. + +""" +import types + +__all__ = ['getargspec', 'formatargspec'] + +# ----------------------------------------------------------- type-checking +def ismethod(object): + """Return true if the object is an instance method. + + Instance method objects provide these attributes: + __doc__ documentation string + __name__ name with which this method was defined + im_class class object in which this method belongs + im_func function object containing implementation of method + im_self instance to which this method is bound, or None + + """ + return isinstance(object, types.MethodType) + +def isfunction(object): + """Return true if the object is a user-defined function. + + Function objects provide these attributes: + __doc__ documentation string + __name__ name with which this function was defined + func_code code object containing compiled function bytecode + func_defaults tuple of any default values for arguments + func_doc (same as __doc__) + func_globals global namespace in which this function was defined + func_name (same as __name__) + + """ + return isinstance(object, types.FunctionType) + +def iscode(object): + """Return true if the object is a code object. + + Code objects provide these attributes: + co_argcount number of arguments (not including * or ** args) + co_code string of raw compiled bytecode + co_consts tuple of constants used in the bytecode + co_filename name of file in which this code object was created + co_firstlineno number of first line in Python source code + co_flags bitmap: 1=optimized | 2=newlocals | 4=*arg | 8=**arg + co_lnotab encoded mapping of line numbers to bytecode indices + co_name name with which this code object was defined + co_names tuple of names of local variables + co_nlocals number of local variables + co_stacksize virtual machine stack space required + co_varnames tuple of names of arguments and local variables + + """ + return isinstance(object, types.CodeType) + +# ------------------------------------------------ argument list extraction +# These constants are from Python's compile.h. +CO_OPTIMIZED, CO_NEWLOCALS, CO_VARARGS, CO_VARKEYWORDS = 1, 2, 4, 8 + +def getargs(co): + """Get information about the arguments accepted by a code object. + + Three things are returned: (args, varargs, varkw), where 'args' is + a list of argument names (possibly containing nested lists), and + 'varargs' and 'varkw' are the names of the * and ** arguments or None. + + """ + + if not iscode(co): + raise TypeError('arg is not a code object') + + nargs = co.co_argcount + names = co.co_varnames + args = list(names[:nargs]) + + # The following acrobatics are for anonymous (tuple) arguments. + # Which we do not need to support, so remove to avoid importing + # the dis module. + for i in range(nargs): + if args[i][:1] in ['', '.']: + raise TypeError("tuple function arguments are not supported") + varargs = None + if co.co_flags & CO_VARARGS: + varargs = co.co_varnames[nargs] + nargs = nargs + 1 + varkw = None + if co.co_flags & CO_VARKEYWORDS: + varkw = co.co_varnames[nargs] + return args, varargs, varkw + +def getargspec(func): + """Get the names and default values of a function's arguments. + + A tuple of four things is returned: (args, varargs, varkw, defaults). + 'args' is a list of the argument names (it may contain nested lists). + 'varargs' and 'varkw' are the names of the * and ** arguments or None. + 'defaults' is an n-tuple of the default values of the last n arguments. + + """ + + if ismethod(func): + func = func.__func__ + if not isfunction(func): + raise TypeError('arg is not a Python function') + args, varargs, varkw = getargs(func.__code__) + return args, varargs, varkw, func.__defaults__ + +def getargvalues(frame): + """Get information about arguments passed into a particular frame. + + A tuple of four things is returned: (args, varargs, varkw, locals). + 'args' is a list of the argument names (it may contain nested lists). + 'varargs' and 'varkw' are the names of the * and ** arguments or None. + 'locals' is the locals dictionary of the given frame. + + """ + args, varargs, varkw = getargs(frame.f_code) + return args, varargs, varkw, frame.f_locals + +def joinseq(seq): + if len(seq) == 1: + return '(' + seq[0] + ',)' + else: + return '(' + ', '.join(seq) + ')' + +def strseq(object, convert, join=joinseq): + """Recursively walk a sequence, stringifying each element. + + """ + if type(object) in [list, tuple]: + return join([strseq(_o, convert, join) for _o in object]) + else: + return convert(object) + +def formatargspec(args, varargs=None, varkw=None, defaults=None, + formatarg=str, + formatvarargs=lambda name: '*' + name, + formatvarkw=lambda name: '**' + name, + formatvalue=lambda value: '=' + repr(value), + join=joinseq): + """Format an argument spec from the 4 values returned by getargspec. + + The first four arguments are (args, varargs, varkw, defaults). The + other four arguments are the corresponding optional formatting functions + that are called to turn names and values into strings. The ninth + argument is an optional function to format the sequence of arguments. + + """ + specs = [] + if defaults: + firstdefault = len(args) - len(defaults) + for i in range(len(args)): + spec = strseq(args[i], formatarg, join) + if defaults and i >= firstdefault: + spec = spec + formatvalue(defaults[i - firstdefault]) + specs.append(spec) + if varargs is not None: + specs.append(formatvarargs(varargs)) + if varkw is not None: + specs.append(formatvarkw(varkw)) + return '(' + ', '.join(specs) + ')' + +def formatargvalues(args, varargs, varkw, locals, + formatarg=str, + formatvarargs=lambda name: '*' + name, + formatvarkw=lambda name: '**' + name, + formatvalue=lambda value: '=' + repr(value), + join=joinseq): + """Format an argument spec from the 4 values returned by getargvalues. + + The first four arguments are (args, varargs, varkw, locals). The + next four arguments are the corresponding optional formatting functions + that are called to turn names and values into strings. The ninth + argument is an optional function to format the sequence of arguments. + + """ + def convert(name, locals=locals, + formatarg=formatarg, formatvalue=formatvalue): + return formatarg(name) + formatvalue(locals[name]) + specs = [strseq(arg, convert, join) for arg in args] + + if varargs: + specs.append(formatvarargs(varargs) + formatvalue(locals[varargs])) + if varkw: + specs.append(formatvarkw(varkw) + formatvalue(locals[varkw])) + return '(' + ', '.join(specs) + ')' diff --git a/venv/lib/python3.12/site-packages/numpy/_utils/_pep440.py b/venv/lib/python3.12/site-packages/numpy/_utils/_pep440.py new file mode 100644 index 00000000..73d0afb5 --- /dev/null +++ b/venv/lib/python3.12/site-packages/numpy/_utils/_pep440.py @@ -0,0 +1,487 @@ +"""Utility to compare pep440 compatible version strings. + +The LooseVersion and StrictVersion classes that distutils provides don't +work; they don't recognize anything like alpha/beta/rc/dev versions. +""" + +# Copyright (c) Donald Stufft and individual contributors. +# All rights reserved. + +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are met: + +# 1. Redistributions of source code must retain the above copyright notice, +# this list of conditions and the following disclaimer. + +# 2. Redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in the +# documentation and/or other materials provided with the distribution. + +# 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. + +import collections +import itertools +import re + + +__all__ = [ + "parse", "Version", "LegacyVersion", "InvalidVersion", "VERSION_PATTERN", +] + + +# BEGIN packaging/_structures.py + + +class Infinity: + def __repr__(self): + return "Infinity" + + def __hash__(self): + return hash(repr(self)) + + def __lt__(self, other): + return False + + def __le__(self, other): + return False + + def __eq__(self, other): + return isinstance(other, self.__class__) + + def __ne__(self, other): + return not isinstance(other, self.__class__) + + def __gt__(self, other): + return True + + def __ge__(self, other): + return True + + def __neg__(self): + return NegativeInfinity + + +Infinity = Infinity() + + +class NegativeInfinity: + def __repr__(self): + return "-Infinity" + + def __hash__(self): + return hash(repr(self)) + + def __lt__(self, other): + return True + + def __le__(self, other): + return True + + def __eq__(self, other): + return isinstance(other, self.__class__) + + def __ne__(self, other): + return not isinstance(other, self.__class__) + + def __gt__(self, other): + return False + + def __ge__(self, other): + return False + + def __neg__(self): + return Infinity + + +# BEGIN packaging/version.py + + +NegativeInfinity = NegativeInfinity() + +_Version = collections.namedtuple( + "_Version", + ["epoch", "release", "dev", "pre", "post", "local"], +) + + +def parse(version): + """ + Parse the given version string and return either a :class:`Version` object + or a :class:`LegacyVersion` object depending on if the given version is + a valid PEP 440 version or a legacy version. + """ + try: + return Version(version) + except InvalidVersion: + return LegacyVersion(version) + + +class InvalidVersion(ValueError): + """ + An invalid version was found, users should refer to PEP 440. + """ + + +class _BaseVersion: + + def __hash__(self): + return hash(self._key) + + def __lt__(self, other): + return self._compare(other, lambda s, o: s < o) + + def __le__(self, other): + return self._compare(other, lambda s, o: s <= o) + + def __eq__(self, other): + return self._compare(other, lambda s, o: s == o) + + def __ge__(self, other): + return self._compare(other, lambda s, o: s >= o) + + def __gt__(self, other): + return self._compare(other, lambda s, o: s > o) + + def __ne__(self, other): + return self._compare(other, lambda s, o: s != o) + + def _compare(self, other, method): + if not isinstance(other, _BaseVersion): + return NotImplemented + + return method(self._key, other._key) + + +class LegacyVersion(_BaseVersion): + + def __init__(self, version): + self._version = str(version) + self._key = _legacy_cmpkey(self._version) + + def __str__(self): + return self._version + + def __repr__(self): + return "".format(repr(str(self))) + + @property + def public(self): + return self._version + + @property + def base_version(self): + return self._version + + @property + def local(self): + return None + + @property + def is_prerelease(self): + return False + + @property + def is_postrelease(self): + return False + + +_legacy_version_component_re = re.compile( + r"(\d+ | [a-z]+ | \.| -)", re.VERBOSE, +) + +_legacy_version_replacement_map = { + "pre": "c", "preview": "c", "-": "final-", "rc": "c", "dev": "@", +} + + +def _parse_version_parts(s): + for part in _legacy_version_component_re.split(s): + part = _legacy_version_replacement_map.get(part, part) + + if not part or part == ".": + continue + + if part[:1] in "0123456789": + # pad for numeric comparison + yield part.zfill(8) + else: + yield "*" + part + + # ensure that alpha/beta/candidate are before final + yield "*final" + + +def _legacy_cmpkey(version): + # We hardcode an epoch of -1 here. A PEP 440 version can only have an epoch + # greater than or equal to 0. This will effectively put the LegacyVersion, + # which uses the defacto standard originally implemented by setuptools, + # as before all PEP 440 versions. + epoch = -1 + + # This scheme is taken from pkg_resources.parse_version setuptools prior to + # its adoption of the packaging library. + parts = [] + for part in _parse_version_parts(version.lower()): + if part.startswith("*"): + # remove "-" before a prerelease tag + if part < "*final": + while parts and parts[-1] == "*final-": + parts.pop() + + # remove trailing zeros from each series of numeric parts + while parts and parts[-1] == "00000000": + parts.pop() + + parts.append(part) + parts = tuple(parts) + + return epoch, parts + + +# 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
+            [-_\.]?
+            (?P(a|b|c|rc|alpha|beta|pre|preview))
+            [-_\.]?
+            (?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
+"""
+
+
+class Version(_BaseVersion):
+
+    _regex = re.compile(
+        r"^\s*" + VERSION_PATTERN + r"\s*$",
+        re.VERBOSE | re.IGNORECASE,
+    )
+
+    def __init__(self, version):
+        # Validate the version and parse it into pieces
+        match = self._regex.search(version)
+        if not match:
+            raise InvalidVersion("Invalid version: '{0}'".format(version))
+
+        # 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):
+        return "".format(repr(str(self)))
+
+    def __str__(self):
+        parts = []
+
+        # Epoch
+        if self._version.epoch != 0:
+            parts.append("{0}!".format(self._version.epoch))
+
+        # Release segment
+        parts.append(".".join(str(x) for x in self._version.release))
+
+        # Pre-release
+        if self._version.pre is not None:
+            parts.append("".join(str(x) for x in self._version.pre))
+
+        # Post-release
+        if self._version.post is not None:
+            parts.append(".post{0}".format(self._version.post[1]))
+
+        # Development release
+        if self._version.dev is not None:
+            parts.append(".dev{0}".format(self._version.dev[1]))
+
+        # Local version segment
+        if self._version.local is not None:
+            parts.append(
+                "+{0}".format(".".join(str(x) for x in self._version.local))
+            )
+
+        return "".join(parts)
+
+    @property
+    def public(self):
+        return str(self).split("+", 1)[0]
+
+    @property
+    def base_version(self):
+        parts = []
+
+        # Epoch
+        if self._version.epoch != 0:
+            parts.append("{0}!".format(self._version.epoch))
+
+        # Release segment
+        parts.append(".".join(str(x) for x in self._version.release))
+
+        return "".join(parts)
+
+    @property
+    def local(self):
+        version_string = str(self)
+        if "+" in version_string:
+            return version_string.split("+", 1)[1]
+
+    @property
+    def is_prerelease(self):
+        return bool(self._version.dev or self._version.pre)
+
+    @property
+    def is_postrelease(self):
+        return bool(self._version.post)
+
+
+def _parse_letter_version(letter, number):
+    if letter:
+        # We assume there is an implicit 0 in a pre-release if there is
+        # no 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)
+    if not letter and number:
+        # We assume that if we are given a number but not given a letter,
+        # then this is using the implicit post release syntax (e.g., 1.0-1)
+        letter = "post"
+
+        return letter, int(number)
+
+
+_local_version_seperators = re.compile(r"[\._-]")
+
+
+def _parse_local_version(local):
+    """
+    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_seperators.split(local)
+        )
+
+
+def _cmpkey(epoch, release, pre, post, dev, local):
+    # 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 no 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 = -Infinity
+    # Versions without a pre-release (except as noted above) should sort after
+    # those with one.
+    elif pre is None:
+        pre = Infinity
+
+    # Versions without a post-segment should sort before those with one.
+    if post is None:
+        post = -Infinity
+
+    # Versions without a development segment should sort after those with one.
+    if dev is None:
+        dev = Infinity
+
+    if local is None:
+        # Versions without a local segment should sort before those with one.
+        local = -Infinity
+    else:
+        # Versions with a local segment need that segment parsed to implement
+        # the sorting rules in PEP440.
+        # - Alphanumeric segments sort before numeric segments
+        # - Alphanumeric 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 (-Infinity, i)
+            for i in local
+        )
+
+    return epoch, release, pre, post, dev, local
diff --git a/venv/lib/python3.12/site-packages/numpy/char/__init__.py b/venv/lib/python3.12/site-packages/numpy/char/__init__.py
new file mode 100644
index 00000000..9eb66c18
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/char/__init__.py
@@ -0,0 +1,2 @@
+from numpy._core.defchararray import __all__, __doc__
+from numpy._core.defchararray import *
diff --git a/venv/lib/python3.12/site-packages/numpy/char/__init__.pyi b/venv/lib/python3.12/site-packages/numpy/char/__init__.pyi
new file mode 100644
index 00000000..3a98cbb4
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/char/__init__.pyi
@@ -0,0 +1,57 @@
+from numpy._core.defchararray import (
+    equal as equal,
+    not_equal as not_equal,
+    greater_equal as greater_equal,
+    less_equal as less_equal,
+    greater as greater,
+    less as less,
+    str_len as str_len,
+    add as add,
+    multiply as multiply,
+    mod as mod,
+    capitalize as capitalize,
+    center as center,
+    count as count,
+    decode as decode,
+    encode as encode,
+    endswith as endswith,
+    expandtabs as expandtabs,
+    find as find,
+    index as index,
+    isalnum as isalnum,
+    isalpha as isalpha,
+    isdigit as isdigit,
+    islower as islower,
+    isspace as isspace,
+    istitle as istitle,
+    isupper as isupper,
+    join as join,
+    ljust as ljust,
+    lower as lower,
+    lstrip as lstrip,
+    partition as partition,
+    replace as replace,
+    rfind as rfind,
+    rindex as rindex,
+    rjust as rjust,
+    rpartition as rpartition,
+    rsplit as rsplit,
+    rstrip as rstrip,
+    split as split,
+    splitlines as splitlines,
+    startswith as startswith,
+    strip as strip,
+    swapcase as swapcase,
+    title as title,
+    translate as translate,
+    upper as upper,
+    zfill as zfill,
+    isnumeric as isnumeric,
+    isdecimal as isdecimal,
+    array as array,
+    asarray as asarray,
+    compare_chararrays as compare_chararrays,
+    chararray as chararray
+)
+
+__all__: list[str]
diff --git a/venv/lib/python3.12/site-packages/numpy/char/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/char/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 00000000..be6aed61
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/char/__pycache__/__init__.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/compat/__init__.py b/venv/lib/python3.12/site-packages/numpy/compat/__init__.py
new file mode 100644
index 00000000..729265aa
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/compat/__init__.py
@@ -0,0 +1,29 @@
+"""
+Compatibility module.
+
+This module contains duplicated code from Python itself or 3rd party
+extensions, which may be included for the following reasons:
+
+  * compatibility
+  * we may only need a small subset of the copied library/module
+
+This module is deprecated since 1.26.0 and will be removed in future versions.
+
+"""
+
+import warnings
+
+from .._utils import _inspect
+from .._utils._inspect import getargspec, formatargspec
+from . import py3k
+from .py3k import *
+
+warnings.warn(
+    "`np.compat`, which was used during the Python 2 to 3 transition,"
+    " is deprecated since 1.26.0, and will be removed",
+    DeprecationWarning, stacklevel=2
+)
+
+__all__ = []
+__all__.extend(_inspect.__all__)
+__all__.extend(py3k.__all__)
diff --git a/venv/lib/python3.12/site-packages/numpy/compat/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/compat/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 00000000..240289bf
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/compat/__pycache__/__init__.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/compat/__pycache__/py3k.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/compat/__pycache__/py3k.cpython-312.pyc
new file mode 100644
index 00000000..7a17a228
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/compat/__pycache__/py3k.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/compat/py3k.py b/venv/lib/python3.12/site-packages/numpy/compat/py3k.py
new file mode 100644
index 00000000..d02c9f8f
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/compat/py3k.py
@@ -0,0 +1,145 @@
+"""
+Python 3.X compatibility tools.
+
+While this file was originally intended for Python 2 -> 3 transition,
+it is now used to create a compatibility layer between different
+minor versions of Python 3.
+
+While the active version of numpy may not support a given version of python, we
+allow downstream libraries to continue to use these shims for forward
+compatibility with numpy while they transition their code to newer versions of
+Python.
+"""
+__all__ = ['bytes', 'asbytes', 'isfileobj', 'getexception', 'strchar',
+           'unicode', 'asunicode', 'asbytes_nested', 'asunicode_nested',
+           'asstr', 'open_latin1', 'long', 'basestring', 'sixu',
+           'integer_types', 'is_pathlib_path', 'npy_load_module', 'Path',
+           'pickle', 'contextlib_nullcontext', 'os_fspath', 'os_PathLike']
+
+import sys
+import os
+from pathlib import Path
+import io
+try:
+    import pickle5 as pickle
+except ImportError:
+    import pickle
+
+long = int
+integer_types = (int,)
+basestring = str
+unicode = str
+bytes = bytes
+
+def asunicode(s):
+    if isinstance(s, bytes):
+        return s.decode('latin1')
+    return str(s)
+
+def asbytes(s):
+    if isinstance(s, bytes):
+        return s
+    return str(s).encode('latin1')
+
+def asstr(s):
+    if isinstance(s, bytes):
+        return s.decode('latin1')
+    return str(s)
+
+def isfileobj(f):
+    if not isinstance(f, (io.FileIO, io.BufferedReader, io.BufferedWriter)):
+        return False
+    try:
+        # BufferedReader/Writer may raise OSError when
+        # fetching `fileno()` (e.g. when wrapping BytesIO).
+        f.fileno()
+        return True
+    except OSError:
+        return False
+
+def open_latin1(filename, mode='r'):
+    return open(filename, mode=mode, encoding='iso-8859-1')
+
+def sixu(s):
+    return s
+
+strchar = 'U'
+
+def getexception():
+    return sys.exc_info()[1]
+
+def asbytes_nested(x):
+    if hasattr(x, '__iter__') and not isinstance(x, (bytes, unicode)):
+        return [asbytes_nested(y) for y in x]
+    else:
+        return asbytes(x)
+
+def asunicode_nested(x):
+    if hasattr(x, '__iter__') and not isinstance(x, (bytes, unicode)):
+        return [asunicode_nested(y) for y in x]
+    else:
+        return asunicode(x)
+
+def is_pathlib_path(obj):
+    """
+    Check whether obj is a `pathlib.Path` object.
+
+    Prefer using ``isinstance(obj, os.PathLike)`` instead of this function.
+    """
+    return isinstance(obj, Path)
+
+# from Python 3.7
+class contextlib_nullcontext:
+    """Context manager that does no additional processing.
+
+    Used as a stand-in for a normal context manager, when a particular
+    block of code is only sometimes used with a normal context manager:
+
+    cm = optional_cm if condition else nullcontext()
+    with cm:
+        # Perform operation, using optional_cm if condition is True
+
+    .. note::
+        Prefer using `contextlib.nullcontext` instead of this context manager.
+    """
+
+    def __init__(self, enter_result=None):
+        self.enter_result = enter_result
+
+    def __enter__(self):
+        return self.enter_result
+
+    def __exit__(self, *excinfo):
+        pass
+
+
+def npy_load_module(name, fn, info=None):
+    """
+    Load a module. Uses ``load_module`` which will be deprecated in python
+    3.12. An alternative that uses ``exec_module`` is in
+    numpy.distutils.misc_util.exec_mod_from_location
+
+    .. versionadded:: 1.11.2
+
+    Parameters
+    ----------
+    name : str
+        Full module name.
+    fn : str
+        Path to module file.
+    info : tuple, optional
+        Only here for backward compatibility with Python 2.*.
+
+    Returns
+    -------
+    mod : module
+
+    """
+    # Explicitly lazy import this to avoid paying the cost
+    # of importing importlib at startup
+    from importlib.machinery import SourceFileLoader
+    return SourceFileLoader(name, fn).load_module()
+
+
+os_fspath = os.fspath
+os_PathLike = os.PathLike
diff --git a/venv/lib/python3.12/site-packages/numpy/compat/tests/__init__.py b/venv/lib/python3.12/site-packages/numpy/compat/tests/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/venv/lib/python3.12/site-packages/numpy/compat/tests/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/compat/tests/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 00000000..4c6c155b
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/compat/tests/__pycache__/__init__.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/conftest.py b/venv/lib/python3.12/site-packages/numpy/conftest.py
new file mode 100644
index 00000000..677537e2
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/conftest.py
@@ -0,0 +1,247 @@
+"""
+Pytest configuration and fixtures for the Numpy test suite.
+"""
+import os
+import sys
+import tempfile
+from contextlib import contextmanager
+import warnings
+
+import hypothesis
+import pytest
+import numpy
+
+from numpy._core._multiarray_tests import get_fpu_mode
+from numpy.testing._private.utils import NOGIL_BUILD
+
+try:
+    from scipy_doctest.conftest import dt_config
+    HAVE_SCPDT = True
+except ModuleNotFoundError:
+    HAVE_SCPDT = False
+
+
+_old_fpu_mode = None
+_collect_results = {}
+
+# Use a known and persistent tmpdir for hypothesis' caches, which
+# can be automatically cleared by the OS or user.
+hypothesis.configuration.set_hypothesis_home_dir(
+    os.path.join(tempfile.gettempdir(), ".hypothesis")
+)
+
+# We register two custom profiles for Numpy - for details see
+# https://hypothesis.readthedocs.io/en/latest/settings.html
+# The first is designed for our own CI runs; the latter also 
+# forces determinism and is designed for use via np.test()
+hypothesis.settings.register_profile(
+    name="numpy-profile", deadline=None, print_blob=True,
+)
+hypothesis.settings.register_profile(
+    name="np.test() profile",
+    deadline=None, print_blob=True, database=None, derandomize=True,
+    suppress_health_check=list(hypothesis.HealthCheck),
+)
+# Note that the default profile is chosen based on the presence 
+# of pytest.ini, but can be overridden by passing the 
+# --hypothesis-profile=NAME argument to pytest.
+_pytest_ini = os.path.join(os.path.dirname(__file__), "..", "pytest.ini")
+hypothesis.settings.load_profile(
+    "numpy-profile" if os.path.isfile(_pytest_ini) else "np.test() profile"
+)
+
+# The experimentalAPI is used in _umath_tests
+os.environ["NUMPY_EXPERIMENTAL_DTYPE_API"] = "1"
+
+def pytest_configure(config):
+    config.addinivalue_line("markers",
+        "valgrind_error: Tests that are known to error under valgrind.")
+    config.addinivalue_line("markers",
+        "leaks_references: Tests that are known to leak references.")
+    config.addinivalue_line("markers",
+        "slow: Tests that are very slow.")
+    config.addinivalue_line("markers",
+        "slow_pypy: Tests that are very slow on pypy.")
+
+
+def pytest_addoption(parser):
+    parser.addoption("--available-memory", action="store", default=None,
+                     help=("Set amount of memory available for running the "
+                           "test suite. This can result to tests requiring "
+                           "especially large amounts of memory to be skipped. "
+                           "Equivalent to setting environment variable "
+                           "NPY_AVAILABLE_MEM. Default: determined"
+                           "automatically."))
+
+
+gil_enabled_at_start = True
+if NOGIL_BUILD:
+    gil_enabled_at_start = sys._is_gil_enabled()
+
+
+def pytest_sessionstart(session):
+    available_mem = session.config.getoption('available_memory')
+    if available_mem is not None:
+        os.environ['NPY_AVAILABLE_MEM'] = available_mem
+
+
+def pytest_terminal_summary(terminalreporter, exitstatus, config):
+    if NOGIL_BUILD and not gil_enabled_at_start and sys._is_gil_enabled():
+        tr = terminalreporter
+        tr.ensure_newline()
+        tr.section("GIL re-enabled", sep="=", red=True, bold=True)
+        tr.line("The GIL was re-enabled at runtime during the tests.")
+        tr.line("This can happen with no test failures if the RuntimeWarning")
+        tr.line("raised by Python when this happens is filtered by a test.")
+        tr.line("")
+        tr.line("Please ensure all new C modules declare support for running")
+        tr.line("without the GIL. Any new tests that intentionally imports ")
+        tr.line("code that re-enables the GIL should do so in a subprocess.")
+        pytest.exit("GIL re-enabled during tests", returncode=1)
+
+#FIXME when yield tests are gone.
+@pytest.hookimpl()
+def pytest_itemcollected(item):
+    """
+    Check FPU precision mode was not changed during test collection.
+
+    The clumsy way we do it here is mainly necessary because numpy
+    still uses yield tests, which can execute code at test collection
+    time.
+    """
+    global _old_fpu_mode
+
+    mode = get_fpu_mode()
+
+    if _old_fpu_mode is None:
+        _old_fpu_mode = mode
+    elif mode != _old_fpu_mode:
+        _collect_results[item] = (_old_fpu_mode, mode)
+        _old_fpu_mode = mode
+
+
+@pytest.fixture(scope="function", autouse=True)
+def check_fpu_mode(request):
+    """
+    Check FPU precision mode was not changed during the test.
+    """
+    old_mode = get_fpu_mode()
+    yield
+    new_mode = get_fpu_mode()
+
+    if old_mode != new_mode:
+        raise AssertionError("FPU precision mode changed from {0:#x} to {1:#x}"
+                             " during the test".format(old_mode, new_mode))
+
+    collect_result = _collect_results.get(request.node)
+    if collect_result is not None:
+        old_mode, new_mode = collect_result
+        raise AssertionError("FPU precision mode changed from {0:#x} to {1:#x}"
+                             " when collecting the test".format(old_mode,
+                                                                new_mode))
+
+
+@pytest.fixture(autouse=True)
+def add_np(doctest_namespace):
+    doctest_namespace['np'] = numpy
+
+@pytest.fixture(autouse=True)
+def env_setup(monkeypatch):
+    monkeypatch.setenv('PYTHONHASHSEED', '0')
+
+
+@pytest.fixture(params=[True, False])
+def weak_promotion(request):
+    """
+    Fixture to ensure "legacy" promotion state or change it to use the new
+    weak promotion (plus warning).  `old_promotion` should be used as a
+    parameter in the function.
+    """
+    state = numpy._get_promotion_state()
+    if request.param:
+        numpy._set_promotion_state("weak_and_warn")
+    else:
+        numpy._set_promotion_state("legacy")
+
+    yield request.param
+    numpy._set_promotion_state(state)
+
+
+if HAVE_SCPDT:
+
+    @contextmanager
+    def warnings_errors_and_rng(test=None):
+        """Filter out the wall of DeprecationWarnings.
+        """
+        msgs = ["The numpy.linalg.linalg",
+                "The numpy.fft.helper",
+                "dep_util",
+                "pkg_resources",
+                "numpy.core.umath",
+                "msvccompiler",
+                "Deprecated call",
+                "numpy.core",
+                "`np.compat`",
+                "Importing from numpy.matlib",
+                "This function is deprecated.",    # random_integers
+                "Data type alias 'a'",     # numpy.rec.fromfile
+                "Arrays of 2-dimensional vectors",   # matlib.cross
+                "`in1d` is deprecated", ]
+        msg = "|".join(msgs)
+
+        msgs_r = [
+            "invalid value encountered",
+            "divide by zero encountered"
+        ]
+        msg_r = "|".join(msgs_r)
+
+        with warnings.catch_warnings():
+            warnings.filterwarnings(
+                'ignore', category=DeprecationWarning, message=msg
+            )
+            warnings.filterwarnings(
+                'ignore', category=RuntimeWarning, message=msg_r
+            )
+            yield
+
+    # find and check doctests under this context manager
+    dt_config.user_context_mgr = warnings_errors_and_rng
+
+    # numpy specific tweaks from refguide-check
+    dt_config.rndm_markers.add('#uninitialized')
+    dt_config.rndm_markers.add('# uninitialized')
+
+    import doctest
+    dt_config.optionflags = doctest.NORMALIZE_WHITESPACE | doctest.ELLIPSIS
+
+    # recognize the StringDType repr
+    dt_config.check_namespace['StringDType'] = numpy.dtypes.StringDType
+
+    # temporary skips
+    dt_config.skiplist = set([
+        'numpy.savez',    # unclosed file
+        'numpy.matlib.savez',
+        'numpy.__array_namespace_info__',
+        'numpy.matlib.__array_namespace_info__',
+    ])
+
+    # xfail problematic tutorials
+    dt_config.pytest_extra_xfail = {
+        'how-to-verify-bug.rst': '',
+        'c-info.ufunc-tutorial.rst': '',
+        'basics.interoperability.rst': 'needs pandas',
+        'basics.dispatch.rst': 'errors out in /testing/overrides.py',
+        'basics.subclassing.rst': '.. testcode:: admonitions not understood',
+        'misc.rst': 'manipulates warnings',
+    }
+
+    # ignores are for things fail doctest collection (optionals etc)
+    dt_config.pytest_extra_ignore = [
+        'numpy/distutils',
+        'numpy/_core/cversions.py',
+        'numpy/_pyinstaller',
+        'numpy/random/_examples',
+        'numpy/compat',
+        'numpy/f2py/_backends/_distutils.py',
+    ]
+
diff --git a/venv/lib/python3.12/site-packages/numpy/core/__init__.py b/venv/lib/python3.12/site-packages/numpy/core/__init__.py
new file mode 100644
index 00000000..e7d3c678
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/core/__init__.py
@@ -0,0 +1,32 @@
+"""
+The `numpy.core` submodule exists solely for backward compatibility
+purposes. The original `core` was renamed to `_core` and made private.
+`numpy.core` will be removed in the future.
+"""
+from numpy import _core
+from ._utils import _raise_warning
+
+
+# We used to use `np.core._ufunc_reconstruct` to unpickle.
+# This is unnecessary, but old pickles saved before 1.20 will be using it,
+# and there is no reason to break loading them.
+def _ufunc_reconstruct(module, name):
+    # The `fromlist` kwarg is required to ensure that `mod` points to the
+    # inner-most module rather than the parent package when module name is
+    # nested. This makes it possible to pickle non-toplevel ufuncs such as
+    # scipy.special.expit for instance.
+    mod = __import__(module, fromlist=[name])
+    return getattr(mod, name)
+
+
+# force lazy-loading of submodules to ensure a warning is printed
+
+__all__ = ["arrayprint", "defchararray", "_dtype_ctypes", "_dtype",
+           "einsumfunc", "fromnumeric", "function_base", "getlimits",
+           "_internal", "multiarray", "_multiarray_umath", "numeric",
+           "numerictypes", "overrides", "records", "shape_base", "umath"]
+
+def __getattr__(attr_name):
+    attr = getattr(_core, attr_name)
+    _raise_warning(attr_name)
+    return attr
diff --git a/venv/lib/python3.12/site-packages/numpy/core/__init__.pyi b/venv/lib/python3.12/site-packages/numpy/core/__init__.pyi
new file mode 100644
index 00000000..e69de29b
diff --git a/venv/lib/python3.12/site-packages/numpy/core/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/core/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 00000000..941fcbd3
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/core/__pycache__/__init__.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/core/__pycache__/_dtype.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/core/__pycache__/_dtype.cpython-312.pyc
new file mode 100644
index 00000000..78d0a0f2
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/core/__pycache__/_dtype.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/core/__pycache__/_dtype_ctypes.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/core/__pycache__/_dtype_ctypes.cpython-312.pyc
new file mode 100644
index 00000000..bd50c5da
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/core/__pycache__/_dtype_ctypes.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/core/__pycache__/_internal.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/core/__pycache__/_internal.cpython-312.pyc
new file mode 100644
index 00000000..dd9911b0
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/core/__pycache__/_internal.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/core/__pycache__/_multiarray_umath.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/core/__pycache__/_multiarray_umath.cpython-312.pyc
new file mode 100644
index 00000000..a7387846
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/core/__pycache__/_multiarray_umath.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/core/__pycache__/_utils.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/core/__pycache__/_utils.cpython-312.pyc
new file mode 100644
index 00000000..f4594546
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/core/__pycache__/_utils.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/core/__pycache__/arrayprint.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/core/__pycache__/arrayprint.cpython-312.pyc
new file mode 100644
index 00000000..df00a2db
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/core/__pycache__/arrayprint.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/core/__pycache__/defchararray.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/core/__pycache__/defchararray.cpython-312.pyc
new file mode 100644
index 00000000..235f7856
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/core/__pycache__/defchararray.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/core/__pycache__/einsumfunc.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/core/__pycache__/einsumfunc.cpython-312.pyc
new file mode 100644
index 00000000..852c8c70
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/core/__pycache__/einsumfunc.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/core/__pycache__/fromnumeric.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/core/__pycache__/fromnumeric.cpython-312.pyc
new file mode 100644
index 00000000..04d226b5
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/core/__pycache__/fromnumeric.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/core/__pycache__/function_base.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/core/__pycache__/function_base.cpython-312.pyc
new file mode 100644
index 00000000..0239c8f6
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/core/__pycache__/function_base.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/core/__pycache__/getlimits.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/core/__pycache__/getlimits.cpython-312.pyc
new file mode 100644
index 00000000..ea450cc6
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/core/__pycache__/getlimits.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/core/__pycache__/multiarray.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/core/__pycache__/multiarray.cpython-312.pyc
new file mode 100644
index 00000000..d811e3dc
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/core/__pycache__/multiarray.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/core/__pycache__/numeric.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/core/__pycache__/numeric.cpython-312.pyc
new file mode 100644
index 00000000..25cf161f
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/core/__pycache__/numeric.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/core/__pycache__/numerictypes.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/core/__pycache__/numerictypes.cpython-312.pyc
new file mode 100644
index 00000000..73a8a42b
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/core/__pycache__/numerictypes.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/core/__pycache__/overrides.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/core/__pycache__/overrides.cpython-312.pyc
new file mode 100644
index 00000000..f589f747
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/core/__pycache__/overrides.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/core/__pycache__/records.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/core/__pycache__/records.cpython-312.pyc
new file mode 100644
index 00000000..c7031061
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/core/__pycache__/records.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/core/__pycache__/shape_base.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/core/__pycache__/shape_base.cpython-312.pyc
new file mode 100644
index 00000000..480a7cc2
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/core/__pycache__/shape_base.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/core/__pycache__/umath.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/core/__pycache__/umath.cpython-312.pyc
new file mode 100644
index 00000000..39c37030
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/core/__pycache__/umath.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/core/_dtype.py b/venv/lib/python3.12/site-packages/numpy/core/_dtype.py
new file mode 100644
index 00000000..613a1d25
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/core/_dtype.py
@@ -0,0 +1,9 @@
+def __getattr__(attr_name):
+    from numpy._core import _dtype
+    from ._utils import _raise_warning
+    ret = getattr(_dtype, attr_name, None)
+    if ret is None:
+        raise AttributeError(
+            f"module 'numpy.core._dtype' has no attribute {attr_name}")
+    _raise_warning(attr_name, "_dtype")
+    return ret
diff --git a/venv/lib/python3.12/site-packages/numpy/core/_dtype_ctypes.py b/venv/lib/python3.12/site-packages/numpy/core/_dtype_ctypes.py
new file mode 100644
index 00000000..0dadd794
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/core/_dtype_ctypes.py
@@ -0,0 +1,9 @@
+def __getattr__(attr_name):
+    from numpy._core import _dtype_ctypes
+    from ._utils import _raise_warning
+    ret = getattr(_dtype_ctypes, attr_name, None)
+    if ret is None:
+        raise AttributeError(
+            f"module 'numpy.core._dtype_ctypes' has no attribute {attr_name}")
+    _raise_warning(attr_name, "_dtype_ctypes")
+    return ret
diff --git a/venv/lib/python3.12/site-packages/numpy/core/_internal.py b/venv/lib/python3.12/site-packages/numpy/core/_internal.py
new file mode 100644
index 00000000..7755c7c3
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/core/_internal.py
@@ -0,0 +1,25 @@
+from numpy._core import _internal
+
+# Build a new array from the information in a pickle.
+# Note that the name numpy.core._internal._reconstruct is embedded in
+# pickles of ndarrays made with NumPy before release 1.0
+# so don't remove the name here, or you'll
+# break backward compatibility.
+def _reconstruct(subtype, shape, dtype):
+    from numpy import ndarray
+    return ndarray.__new__(subtype, shape, dtype)
+
+
+# Pybind11 (in versions <= 2.11.1) imports _dtype_from_pep3118 from the
+# _internal submodule, therefore it must be importable without a warning.
+_dtype_from_pep3118 = _internal._dtype_from_pep3118
+
+def __getattr__(attr_name):
+    from numpy._core import _internal
+    from ._utils import _raise_warning
+    ret = getattr(_internal, attr_name, None)
+    if ret is None:
+        raise AttributeError(
+            f"module 'numpy.core._internal' has no attribute {attr_name}")
+    _raise_warning(attr_name, "_internal")
+    return ret
diff --git a/venv/lib/python3.12/site-packages/numpy/core/_multiarray_umath.py b/venv/lib/python3.12/site-packages/numpy/core/_multiarray_umath.py
new file mode 100644
index 00000000..04cc8822
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/core/_multiarray_umath.py
@@ -0,0 +1,55 @@
+from numpy._core import _multiarray_umath
+from numpy import ufunc
+
+for item in _multiarray_umath.__dir__():
+    # ufuncs appear in pickles with a path in numpy.core._multiarray_umath
+    # and so must import from this namespace without warning or error
+    attr = getattr(_multiarray_umath, item)
+    if isinstance(attr, ufunc):
+        globals()[item] = attr
+
+
+def __getattr__(attr_name):
+    from numpy._core import _multiarray_umath
+    from ._utils import _raise_warning
+
+    if attr_name in {"_ARRAY_API", "_UFUNC_API"}:
+        from numpy.version import short_version
+        import textwrap
+        import traceback
+        import sys
+
+        msg = textwrap.dedent(f"""
+            A module that was compiled using NumPy 1.x cannot be run in
+            NumPy {short_version} as it may crash. To support both 1.x and 2.x
+            versions of NumPy, modules must be compiled with NumPy 2.0.
+            Some module may need to rebuild instead e.g. with 'pybind11>=2.12'.
+
+            If you are a user of the module, the easiest solution will be to
+            downgrade to 'numpy<2' or try to upgrade the affected module.
+            We expect that some modules will need time to support NumPy 2.
+
+            """)
+        tb_msg = "Traceback (most recent call last):"
+        for line in traceback.format_stack()[:-1]:
+            if "frozen importlib" in line:
+                continue
+            tb_msg += line
+
+        # Also print the message (with traceback).  This is because old versions
+        # of NumPy unfortunately set up the import to replace (and hide) the
+        # error.  The traceback shouldn't be needed, but e.g. pytest plugins
+        # seem to swallow it and we should be failing anyway...
+        sys.stderr.write(msg + tb_msg)
+        raise ImportError(msg)
+
+    ret = getattr(_multiarray_umath, attr_name, None)
+    if ret is None:
+        raise AttributeError(
+            "module 'numpy.core._multiarray_umath' has no attribute "
+            f"{attr_name}")
+    _raise_warning(attr_name, "_multiarray_umath")
+    return ret
+
+
+del _multiarray_umath, ufunc
diff --git a/venv/lib/python3.12/site-packages/numpy/core/_utils.py b/venv/lib/python3.12/site-packages/numpy/core/_utils.py
new file mode 100644
index 00000000..ad076b03
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/core/_utils.py
@@ -0,0 +1,21 @@
+import warnings
+
+
+def _raise_warning(attr: str, submodule: str = None) -> None:
+    new_module = "numpy._core"
+    old_module = "numpy.core"
+    if submodule is not None:
+        new_module = f"{new_module}.{submodule}"
+        old_module = f"{old_module}.{submodule}"
+    warnings.warn(
+        f"{old_module} is deprecated and has been renamed to {new_module}. "
+        "The numpy._core namespace contains private NumPy internals and its "
+        "use is discouraged, as NumPy internals can change without warning in "
+        "any release. In practice, most real-world usage of numpy.core is to "
+        "access functionality in the public NumPy API. If that is the case, "
+        "use the public NumPy API. If not, you are using NumPy internals. "
+        "If you would still like to access an internal attribute, "
+        f"use {new_module}.{attr}.",
+        DeprecationWarning, 
+        stacklevel=3
+    )
diff --git a/venv/lib/python3.12/site-packages/numpy/core/arrayprint.py b/venv/lib/python3.12/site-packages/numpy/core/arrayprint.py
new file mode 100644
index 00000000..4e746546
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/core/arrayprint.py
@@ -0,0 +1,9 @@
+def __getattr__(attr_name):
+    from numpy._core import arrayprint
+    from ._utils import _raise_warning
+    ret = getattr(arrayprint, attr_name, None)
+    if ret is None:
+        raise AttributeError(
+            f"module 'numpy.core.arrayprint' has no attribute {attr_name}")
+    _raise_warning(attr_name, "arrayprint")
+    return ret
diff --git a/venv/lib/python3.12/site-packages/numpy/core/defchararray.py b/venv/lib/python3.12/site-packages/numpy/core/defchararray.py
new file mode 100644
index 00000000..ffab82ac
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/core/defchararray.py
@@ -0,0 +1,9 @@
+def __getattr__(attr_name):
+    from numpy._core import defchararray
+    from ._utils import _raise_warning
+    ret = getattr(defchararray, attr_name, None)
+    if ret is None:
+        raise AttributeError(
+            f"module 'numpy.core.defchararray' has no attribute {attr_name}")
+    _raise_warning(attr_name, "defchararray")
+    return ret
diff --git a/venv/lib/python3.12/site-packages/numpy/core/einsumfunc.py b/venv/lib/python3.12/site-packages/numpy/core/einsumfunc.py
new file mode 100644
index 00000000..74aa410f
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/core/einsumfunc.py
@@ -0,0 +1,9 @@
+def __getattr__(attr_name):
+    from numpy._core import einsumfunc
+    from ._utils import _raise_warning
+    ret = getattr(einsumfunc, attr_name, None)
+    if ret is None:
+        raise AttributeError(
+            f"module 'numpy.core.einsumfunc' has no attribute {attr_name}")
+    _raise_warning(attr_name, "einsumfunc")
+    return ret
diff --git a/venv/lib/python3.12/site-packages/numpy/core/fromnumeric.py b/venv/lib/python3.12/site-packages/numpy/core/fromnumeric.py
new file mode 100644
index 00000000..1ea11d79
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/core/fromnumeric.py
@@ -0,0 +1,9 @@
+def __getattr__(attr_name):
+    from numpy._core import fromnumeric
+    from ._utils import _raise_warning
+    ret = getattr(fromnumeric, attr_name, None)
+    if ret is None:
+        raise AttributeError(
+            f"module 'numpy.core.fromnumeric' has no attribute {attr_name}")
+    _raise_warning(attr_name, "fromnumeric")
+    return ret
diff --git a/venv/lib/python3.12/site-packages/numpy/core/function_base.py b/venv/lib/python3.12/site-packages/numpy/core/function_base.py
new file mode 100644
index 00000000..20e098b6
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/core/function_base.py
@@ -0,0 +1,9 @@
+def __getattr__(attr_name):
+    from numpy._core import function_base
+    from ._utils import _raise_warning
+    ret = getattr(function_base, attr_name, None)
+    if ret is None:
+        raise AttributeError(
+            f"module 'numpy.core.function_base' has no attribute {attr_name}")
+    _raise_warning(attr_name, "function_base")
+    return ret
diff --git a/venv/lib/python3.12/site-packages/numpy/core/getlimits.py b/venv/lib/python3.12/site-packages/numpy/core/getlimits.py
new file mode 100644
index 00000000..faa084ae
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/core/getlimits.py
@@ -0,0 +1,9 @@
+def __getattr__(attr_name):
+    from numpy._core import getlimits
+    from ._utils import _raise_warning
+    ret = getattr(getlimits, attr_name, None)
+    if ret is None:
+        raise AttributeError(
+            f"module 'numpy.core.getlimits' has no attribute {attr_name}")
+    _raise_warning(attr_name, "getlimits")
+    return ret
diff --git a/venv/lib/python3.12/site-packages/numpy/core/multiarray.py b/venv/lib/python3.12/site-packages/numpy/core/multiarray.py
new file mode 100644
index 00000000..0290c852
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/core/multiarray.py
@@ -0,0 +1,24 @@
+from numpy._core import multiarray
+
+# these must import without warning or error from numpy.core.multiarray to
+# support old pickle files
+for item in ["_reconstruct", "scalar"]:
+    globals()[item] = getattr(multiarray, item)
+
+# Pybind11 (in versions <= 2.11.1) imports _ARRAY_API from the multiarray
+# submodule as a part of NumPy initialization, therefore it must be importable
+# without a warning.
+_ARRAY_API = multiarray._ARRAY_API
+
+def __getattr__(attr_name):
+    from numpy._core import multiarray
+    from ._utils import _raise_warning
+    ret = getattr(multiarray, attr_name, None)
+    if ret is None:
+        raise AttributeError(
+            f"module 'numpy.core.multiarray' has no attribute {attr_name}")
+    _raise_warning(attr_name, "multiarray")
+    return ret
+
+
+del multiarray
diff --git a/venv/lib/python3.12/site-packages/numpy/core/numeric.py b/venv/lib/python3.12/site-packages/numpy/core/numeric.py
new file mode 100644
index 00000000..af0658d4
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/core/numeric.py
@@ -0,0 +1,11 @@
+def __getattr__(attr_name):
+    from numpy._core import numeric
+    from ._utils import _raise_warning
+
+    sentinel = object()
+    ret = getattr(numeric, attr_name, sentinel)
+    if ret is sentinel:
+        raise AttributeError(
+            f"module 'numpy.core.numeric' has no attribute {attr_name}")
+    _raise_warning(attr_name, "numeric")
+    return ret
diff --git a/venv/lib/python3.12/site-packages/numpy/core/numerictypes.py b/venv/lib/python3.12/site-packages/numpy/core/numerictypes.py
new file mode 100644
index 00000000..0e887cbf
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/core/numerictypes.py
@@ -0,0 +1,9 @@
+def __getattr__(attr_name):
+    from numpy._core import numerictypes
+    from ._utils import _raise_warning
+    ret = getattr(numerictypes, attr_name, None)
+    if ret is None:
+        raise AttributeError(
+            f"module 'numpy.core.numerictypes' has no attribute {attr_name}")
+    _raise_warning(attr_name, "numerictypes")
+    return ret
diff --git a/venv/lib/python3.12/site-packages/numpy/core/overrides.py b/venv/lib/python3.12/site-packages/numpy/core/overrides.py
new file mode 100644
index 00000000..3297999c
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/core/overrides.py
@@ -0,0 +1,9 @@
+def __getattr__(attr_name):
+    from numpy._core import overrides
+    from ._utils import _raise_warning
+    ret = getattr(overrides, attr_name, None)
+    if ret is None:
+        raise AttributeError(
+            f"module 'numpy.core.overrides' has no attribute {attr_name}")
+    _raise_warning(attr_name, "overrides")
+    return ret
diff --git a/venv/lib/python3.12/site-packages/numpy/core/records.py b/venv/lib/python3.12/site-packages/numpy/core/records.py
new file mode 100644
index 00000000..94c0d269
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/core/records.py
@@ -0,0 +1,9 @@
+def __getattr__(attr_name):
+    from numpy._core import records
+    from ._utils import _raise_warning
+    ret = getattr(records, attr_name, None)
+    if ret is None:
+        raise AttributeError(
+            f"module 'numpy.core.records' has no attribute {attr_name}")
+    _raise_warning(attr_name, "records")
+    return ret
diff --git a/venv/lib/python3.12/site-packages/numpy/core/shape_base.py b/venv/lib/python3.12/site-packages/numpy/core/shape_base.py
new file mode 100644
index 00000000..10b8712c
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/core/shape_base.py
@@ -0,0 +1,9 @@
+def __getattr__(attr_name):
+    from numpy._core import shape_base
+    from ._utils import _raise_warning
+    ret = getattr(shape_base, attr_name, None)
+    if ret is None:
+        raise AttributeError(
+            f"module 'numpy.core.shape_base' has no attribute {attr_name}")
+    _raise_warning(attr_name, "shape_base")
+    return ret
diff --git a/venv/lib/python3.12/site-packages/numpy/core/umath.py b/venv/lib/python3.12/site-packages/numpy/core/umath.py
new file mode 100644
index 00000000..6ef031d7
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/core/umath.py
@@ -0,0 +1,9 @@
+def __getattr__(attr_name):
+    from numpy._core import umath
+    from ._utils import _raise_warning
+    ret = getattr(umath, attr_name, None)
+    if ret is None:
+        raise AttributeError(
+            f"module 'numpy.core.umath' has no attribute {attr_name}")
+    _raise_warning(attr_name, "umath")
+    return ret
diff --git a/venv/lib/python3.12/site-packages/numpy/ctypeslib.py b/venv/lib/python3.12/site-packages/numpy/ctypeslib.py
new file mode 100644
index 00000000..ea94ad30
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/ctypeslib.py
@@ -0,0 +1,561 @@
+"""
+============================
+``ctypes`` Utility Functions
+============================
+
+See Also
+--------
+load_library : Load a C library.
+ndpointer : Array restype/argtype with verification.
+as_ctypes : Create a ctypes array from an ndarray.
+as_array : Create an ndarray from a ctypes array.
+
+References
+----------
+.. [1] "SciPy Cookbook: ctypes", https://scipy-cookbook.readthedocs.io/items/Ctypes.html
+
+Examples
+--------
+Load the C library:
+
+>>> _lib = np.ctypeslib.load_library('libmystuff', '.')     #doctest: +SKIP
+
+Our result type, an ndarray that must be of type double, be 1-dimensional
+and is C-contiguous in memory:
+
+>>> array_1d_double = np.ctypeslib.ndpointer(
+...                          dtype=np.double,
+...                          ndim=1, flags='CONTIGUOUS')    #doctest: +SKIP
+
+Our C-function typically takes an array and updates its values
+in-place.  For example::
+
+    void foo_func(double* x, int length)
+    {
+        int i;
+        for (i = 0; i < length; i++) {
+            x[i] = i*i;
+        }
+    }
+
+We wrap it using:
+
+>>> _lib.foo_func.restype = None                      #doctest: +SKIP
+>>> _lib.foo_func.argtypes = [array_1d_double, c_int] #doctest: +SKIP
+
+Then, we're ready to call ``foo_func``:
+
+>>> out = np.empty(15, dtype=np.double)
+>>> _lib.foo_func(out, len(out))                #doctest: +SKIP
+
+"""
+__all__ = ['load_library', 'ndpointer', 'c_intp', 'as_ctypes', 'as_array',
+           'as_ctypes_type']
+
+import os
+from numpy import (
+    integer, ndarray, dtype as _dtype, asarray, frombuffer
+)
+from numpy._core.multiarray import _flagdict, flagsobj
+
+try:
+    import ctypes
+except ImportError:
+    ctypes = None
+
+if ctypes is None:
+    def _dummy(*args, **kwds):
+        """
+        Dummy object that raises an ImportError if ctypes is not available.
+
+        Raises
+        ------
+        ImportError
+            If ctypes is not available.
+
+        """
+        raise ImportError("ctypes is not available.")
+    load_library = _dummy
+    as_ctypes = _dummy
+    as_array = _dummy
+    from numpy import intp as c_intp
+    _ndptr_base = object
+else:
+    import numpy._core._internal as nic
+    c_intp = nic._getintp_ctype()
+    del nic
+    _ndptr_base = ctypes.c_void_p
+
+    # Adapted from Albert Strasheim
+    def load_library(libname, loader_path):
+        """
+        It is possible to load a library using
+
+        >>> lib = ctypes.cdll[] # doctest: +SKIP
+
+        But there are cross-platform considerations, such as library file extensions,
+        plus the fact Windows will just load the first library it finds with that name.
+        NumPy supplies the load_library function as a convenience.
+
+        .. versionchanged:: 1.20.0
+            Allow libname and loader_path to take any
+            :term:`python:path-like object`.
+
+        Parameters
+        ----------
+        libname : path-like
+            Name of the library, which can have 'lib' as a prefix,
+            but without an extension.
+        loader_path : path-like
+            Where the library can be found.
+
+        Returns
+        -------
+        ctypes.cdll[libpath] : library object
+           A ctypes library object
+
+        Raises
+        ------
+        OSError
+            If there is no library with the expected extension, or the
+            library is defective and cannot be loaded.
+        """
+        # Convert path-like objects into strings
+        libname = os.fsdecode(libname)
+        loader_path = os.fsdecode(loader_path)
+
+        ext = os.path.splitext(libname)[1]
+        if not ext:
+            import sys
+            import sysconfig
+            # Try to load library with platform-specific name, otherwise
+            # default to libname.[so|dll|dylib].  Sometimes, these files are
+            # built erroneously on non-linux platforms.
+            base_ext = ".so"
+            if sys.platform.startswith("darwin"):
+                base_ext = ".dylib"
+            elif sys.platform.startswith("win"):
+                base_ext = ".dll"
+            libname_ext = [libname + base_ext]
+            so_ext = sysconfig.get_config_var("EXT_SUFFIX")
+            if not so_ext == base_ext:
+                libname_ext.insert(0, libname + so_ext)
+        else:
+            libname_ext = [libname]
+
+        loader_path = os.path.abspath(loader_path)
+        if not os.path.isdir(loader_path):
+            libdir = os.path.dirname(loader_path)
+        else:
+            libdir = loader_path
+
+        for ln in libname_ext:
+            libpath = os.path.join(libdir, ln)
+            if os.path.exists(libpath):
+                try:
+                    return ctypes.cdll[libpath]
+                except OSError:
+                    ## defective lib file
+                    raise
+        ## if no successful return in the libname_ext loop:
+        raise OSError("no file with expected extension")
+
+
+def _num_fromflags(flaglist):
+    num = 0
+    for val in flaglist:
+        num += _flagdict[val]
+    return num
+
+_flagnames = ['C_CONTIGUOUS', 'F_CONTIGUOUS', 'ALIGNED', 'WRITEABLE',
+              'OWNDATA', 'WRITEBACKIFCOPY']
+def _flags_fromnum(num):
+    res = []
+    for key in _flagnames:
+        value = _flagdict[key]
+        if (num & value):
+            res.append(key)
+    return res
+
+
+class _ndptr(_ndptr_base):
+    @classmethod
+    def from_param(cls, obj):
+        if not isinstance(obj, ndarray):
+            raise TypeError("argument must be an ndarray")
+        if cls._dtype_ is not None \
+               and obj.dtype != cls._dtype_:
+            raise TypeError("array must have data type %s" % cls._dtype_)
+        if cls._ndim_ is not None \
+               and obj.ndim != cls._ndim_:
+            raise TypeError("array must have %d dimension(s)" % cls._ndim_)
+        if cls._shape_ is not None \
+               and obj.shape != cls._shape_:
+            raise TypeError("array must have shape %s" % str(cls._shape_))
+        if cls._flags_ is not None \
+               and ((obj.flags.num & cls._flags_) != cls._flags_):
+            raise TypeError("array must have flags %s" %
+                    _flags_fromnum(cls._flags_))
+        return obj.ctypes
+
+
+class _concrete_ndptr(_ndptr):
+    """
+    Like _ndptr, but with `_shape_` and `_dtype_` specified.
+
+    Notably, this means the pointer has enough information to reconstruct
+    the array, which is not generally true.
+    """
+    def _check_retval_(self):
+        """
+        This method is called when this class is used as the .restype
+        attribute for a shared-library function, to automatically wrap the
+        pointer into an array.
+        """
+        return self.contents
+
+    @property
+    def contents(self):
+        """
+        Get an ndarray viewing the data pointed to by this pointer.
+
+        This mirrors the `contents` attribute of a normal ctypes pointer
+        """
+        full_dtype = _dtype((self._dtype_, self._shape_))
+        full_ctype = ctypes.c_char * full_dtype.itemsize
+        buffer = ctypes.cast(self, ctypes.POINTER(full_ctype)).contents
+        return frombuffer(buffer, dtype=full_dtype).squeeze(axis=0)
+
+
+# Factory for an array-checking class with from_param defined for
+#  use with ctypes argtypes mechanism
+_pointer_type_cache = {}
+def ndpointer(dtype=None, ndim=None, shape=None, flags=None):
+    """
+    Array-checking restype/argtypes.
+
+    An ndpointer instance is used to describe an ndarray in restypes
+    and argtypes specifications.  This approach is more flexible than
+    using, for example, ``POINTER(c_double)``, since several restrictions
+    can be specified, which are verified upon calling the ctypes function.
+    These include data type, number of dimensions, shape and flags.  If a
+    given array does not satisfy the specified restrictions,
+    a ``TypeError`` is raised.
+
+    Parameters
+    ----------
+    dtype : data-type, optional
+        Array data-type.
+    ndim : int, optional
+        Number of array dimensions.
+    shape : tuple of ints, optional
+        Array shape.
+    flags : str or tuple of str
+        Array flags; may be one or more of:
+
+        - C_CONTIGUOUS / C / CONTIGUOUS
+        - F_CONTIGUOUS / F / FORTRAN
+        - OWNDATA / O
+        - WRITEABLE / W
+        - ALIGNED / A
+        - WRITEBACKIFCOPY / X
+
+    Returns
+    -------
+    klass : ndpointer type object
+        A type object, which is an ``_ndtpr`` instance containing
+        dtype, ndim, shape and flags information.
+
+    Raises
+    ------
+    TypeError
+        If a given array does not satisfy the specified restrictions.
+
+    Examples
+    --------
+    >>> clib.somefunc.argtypes = [np.ctypeslib.ndpointer(dtype=np.float64,
+    ...                                                  ndim=1,
+    ...                                                  flags='C_CONTIGUOUS')]
+    ... #doctest: +SKIP
+    >>> clib.somefunc(np.array([1, 2, 3], dtype=np.float64))
+    ... #doctest: +SKIP
+
+    """
+
+    # normalize dtype to an Optional[dtype]
+    if dtype is not None:
+        dtype = _dtype(dtype)
+
+    # normalize flags to an Optional[int]
+    num = None
+    if flags is not None:
+        if isinstance(flags, str):
+            flags = flags.split(',')
+        elif isinstance(flags, (int, integer)):
+            num = flags
+            flags = _flags_fromnum(num)
+        elif isinstance(flags, flagsobj):
+            num = flags.num
+            flags = _flags_fromnum(num)
+        if num is None:
+            try:
+                flags = [x.strip().upper() for x in flags]
+            except Exception as e:
+                raise TypeError("invalid flags specification") from e
+            num = _num_fromflags(flags)
+
+    # normalize shape to an Optional[tuple]
+    if shape is not None:
+        try:
+            shape = tuple(shape)
+        except TypeError:
+            # single integer -> 1-tuple
+            shape = (shape,)
+
+    cache_key = (dtype, ndim, shape, num)
+
+    try:
+        return _pointer_type_cache[cache_key]
+    except KeyError:
+        pass
+
+    # produce a name for the new type
+    if dtype is None:
+        name = 'any'
+    elif dtype.names is not None:
+        name = str(id(dtype))
+    else:
+        name = dtype.str
+    if ndim is not None:
+        name += "_%dd" % ndim
+    if shape is not None:
+        name += "_"+"x".join(str(x) for x in shape)
+    if flags is not None:
+        name += "_"+"_".join(flags)
+
+    if dtype is not None and shape is not None:
+        base = _concrete_ndptr
+    else:
+        base = _ndptr
+
+    klass = type("ndpointer_%s"%name, (base,),
+                 {"_dtype_": dtype,
+                  "_shape_" : shape,
+                  "_ndim_" : ndim,
+                  "_flags_" : num})
+    _pointer_type_cache[cache_key] = klass
+    return klass
+
+
+if ctypes is not None:
+    def _ctype_ndarray(element_type, shape):
+        """ Create an ndarray of the given element type and shape """
+        for dim in shape[::-1]:
+            element_type = dim * element_type
+            # prevent the type name include np.ctypeslib
+            element_type.__module__ = None
+        return element_type
+
+
+    def _get_scalar_type_map():
+        """
+        Return a dictionary mapping native endian scalar dtype to ctypes types
+        """
+        ct = ctypes
+        simple_types = [
+            ct.c_byte, ct.c_short, ct.c_int, ct.c_long, ct.c_longlong,
+            ct.c_ubyte, ct.c_ushort, ct.c_uint, ct.c_ulong, ct.c_ulonglong,
+            ct.c_float, ct.c_double,
+            ct.c_bool,
+        ]
+        return {_dtype(ctype): ctype for ctype in simple_types}
+
+
+    _scalar_type_map = _get_scalar_type_map()
+
+
+    def _ctype_from_dtype_scalar(dtype):
+        # swapping twice ensure that `=` is promoted to <, >, or |
+        dtype_with_endian = dtype.newbyteorder('S').newbyteorder('S')
+        dtype_native = dtype.newbyteorder('=')
+        try:
+            ctype = _scalar_type_map[dtype_native]
+        except KeyError as e:
+            raise NotImplementedError(
+                "Converting {!r} to a ctypes type".format(dtype)
+            ) from None
+
+        if dtype_with_endian.byteorder == '>':
+            ctype = ctype.__ctype_be__
+        elif dtype_with_endian.byteorder == '<':
+            ctype = ctype.__ctype_le__
+
+        return ctype
+
+
+    def _ctype_from_dtype_subarray(dtype):
+        element_dtype, shape = dtype.subdtype
+        ctype = _ctype_from_dtype(element_dtype)
+        return _ctype_ndarray(ctype, shape)
+
+
+    def _ctype_from_dtype_structured(dtype):
+        # extract offsets of each field
+        field_data = []
+        for name in dtype.names:
+            field_dtype, offset = dtype.fields[name][:2]
+            field_data.append((offset, name, _ctype_from_dtype(field_dtype)))
+
+        # ctypes doesn't care about field order
+        field_data = sorted(field_data, key=lambda f: f[0])
+
+        if len(field_data) > 1 and all(offset == 0 for offset, name, ctype in field_data):
+            # union, if multiple fields all at address 0
+            size = 0
+            _fields_ = []
+            for offset, name, ctype in field_data:
+                _fields_.append((name, ctype))
+                size = max(size, ctypes.sizeof(ctype))
+
+            # pad to the right size
+            if dtype.itemsize != size:
+                _fields_.append(('', ctypes.c_char * dtype.itemsize))
+
+            # we inserted manual padding, so always `_pack_`
+            return type('union', (ctypes.Union,), dict(
+                _fields_=_fields_,
+                _pack_=1,
+                __module__=None,
+            ))
+        else:
+            last_offset = 0
+            _fields_ = []
+            for offset, name, ctype in field_data:
+                padding = offset - last_offset
+                if padding < 0:
+                    raise NotImplementedError("Overlapping fields")
+                if padding > 0:
+                    _fields_.append(('', ctypes.c_char * padding))
+
+                _fields_.append((name, ctype))
+                last_offset = offset + ctypes.sizeof(ctype)
+
+
+            padding = dtype.itemsize - last_offset
+            if padding > 0:
+                _fields_.append(('', ctypes.c_char * padding))
+
+            # we inserted manual padding, so always `_pack_`
+            return type('struct', (ctypes.Structure,), dict(
+                _fields_=_fields_,
+                _pack_=1,
+                __module__=None,
+            ))
+
+
+    def _ctype_from_dtype(dtype):
+        if dtype.fields is not None:
+            return _ctype_from_dtype_structured(dtype)
+        elif dtype.subdtype is not None:
+            return _ctype_from_dtype_subarray(dtype)
+        else:
+            return _ctype_from_dtype_scalar(dtype)
+
+
+    def as_ctypes_type(dtype):
+        r"""
+        Convert a dtype into a ctypes type.
+
+        Parameters
+        ----------
+        dtype : dtype
+            The dtype to convert
+
+        Returns
+        -------
+        ctype
+            A ctype scalar, union, array, or struct
+
+        Raises
+        ------
+        NotImplementedError
+            If the conversion is not possible
+
+        Notes
+        -----
+        This function does not losslessly round-trip in either direction.
+
+        ``np.dtype(as_ctypes_type(dt))`` will:
+
+        - insert padding fields
+        - reorder fields to be sorted by offset
+        - discard field titles
+
+        ``as_ctypes_type(np.dtype(ctype))`` will:
+
+        - discard the class names of `ctypes.Structure`\ s and
+          `ctypes.Union`\ s
+        - convert single-element `ctypes.Union`\ s into single-element
+          `ctypes.Structure`\ s
+        - insert padding fields
+
+        Examples
+        --------
+        Converting a simple dtype:
+
+        >>> dt = np.dtype('int8')
+        >>> ctype = np.ctypeslib.as_ctypes_type(dt)
+        >>> ctype
+        
+
+        Converting a structured dtype:
+
+        >>> dt = np.dtype([('x', 'i4'), ('y', 'f4')])
+        >>> ctype = np.ctypeslib.as_ctypes_type(dt)
+        >>> ctype
+        
+
+        """
+        return _ctype_from_dtype(_dtype(dtype))
+
+
+    def as_array(obj, shape=None):
+        """
+        Create a numpy array from a ctypes array or POINTER.
+
+        The numpy array shares the memory with the ctypes object.
+
+        The shape parameter must be given if converting from a ctypes POINTER.
+        The shape parameter is ignored if converting from a ctypes array
+        """
+        if isinstance(obj, ctypes._Pointer):
+            # convert pointers to an array of the desired shape
+            if shape is None:
+                raise TypeError(
+                    'as_array() requires a shape argument when called on a '
+                    'pointer')
+            p_arr_type = ctypes.POINTER(_ctype_ndarray(obj._type_, shape))
+            obj = ctypes.cast(obj, p_arr_type).contents
+
+        return asarray(obj)
+
+
+    def as_ctypes(obj):
+        """Create and return a ctypes object from a numpy array.  Actually
+        anything that exposes the __array_interface__ is accepted."""
+        ai = obj.__array_interface__
+        if ai["strides"]:
+            raise TypeError("strided arrays not supported")
+        if ai["version"] != 3:
+            raise TypeError("only __array_interface__ version 3 supported")
+        addr, readonly = ai["data"]
+        if readonly:
+            raise TypeError("readonly arrays unsupported")
+
+        # can't use `_dtype((ai["typestr"], ai["shape"]))` here, as it overflows
+        # dtype.itemsize (gh-14214)
+        ctype_scalar = as_ctypes_type(ai["typestr"])
+        result_type = _ctype_ndarray(ctype_scalar, ai["shape"])
+        result = result_type.from_address(addr)
+        result.__keep = obj
+        return result
diff --git a/venv/lib/python3.12/site-packages/numpy/ctypeslib.pyi b/venv/lib/python3.12/site-packages/numpy/ctypeslib.pyi
new file mode 100644
index 00000000..ce8854ca
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/ctypeslib.pyi
@@ -0,0 +1,253 @@
+# NOTE: Numpy's mypy plugin is used for importing the correct
+# platform-specific `ctypes._SimpleCData[int]` sub-type
+from ctypes import c_int64 as _c_intp
+
+import os
+import ctypes
+from collections.abc import Iterable, Sequence
+from typing import (
+    Literal as L,
+    Any,
+    TypeVar,
+    Generic,
+    overload,
+    ClassVar,
+)
+
+import numpy as np
+from numpy import (
+    ndarray,
+    dtype,
+    generic,
+    byte,
+    short,
+    intc,
+    long,
+    longlong,
+    intp,
+    ubyte,
+    ushort,
+    uintc,
+    ulong,
+    ulonglong,
+    uintp,
+    single,
+    double,
+    longdouble,
+    void,
+)
+from numpy._core._internal import _ctypes
+from numpy._core.multiarray import flagsobj
+from numpy._typing import (
+    # Arrays
+    NDArray,
+    _ArrayLike,
+
+    # Shapes
+    _ShapeLike,
+
+    # DTypes
+    DTypeLike,
+    _DTypeLike,
+    _VoidDTypeLike,
+    _BoolCodes,
+    _UByteCodes,
+    _UShortCodes,
+    _UIntCCodes,
+    _ULongCodes,
+    _ULongLongCodes,
+    _ByteCodes,
+    _ShortCodes,
+    _IntCCodes,
+    _LongCodes,
+    _LongLongCodes,
+    _SingleCodes,
+    _DoubleCodes,
+    _LongDoubleCodes,
+)
+
+# TODO: Add a proper `_Shape` bound once we've got variadic typevars
+_DType = TypeVar("_DType", bound=dtype[Any])
+_DTypeOptional = TypeVar("_DTypeOptional", bound=None | dtype[Any])
+_SCT = TypeVar("_SCT", bound=generic)
+
+_FlagsKind = L[
+    'C_CONTIGUOUS', 'CONTIGUOUS', 'C',
+    'F_CONTIGUOUS', 'FORTRAN', 'F',
+    'ALIGNED', 'A',
+    'WRITEABLE', 'W',
+    'OWNDATA', 'O',
+    'WRITEBACKIFCOPY', 'X',
+]
+
+# TODO: Add a shape typevar once we have variadic typevars (PEP 646)
+class _ndptr(ctypes.c_void_p, Generic[_DTypeOptional]):
+    # In practice these 4 classvars are defined in the dynamic class
+    # returned by `ndpointer`
+    _dtype_: ClassVar[_DTypeOptional]
+    _shape_: ClassVar[None]
+    _ndim_: ClassVar[None | int]
+    _flags_: ClassVar[None | list[_FlagsKind]]
+
+    @overload
+    @classmethod
+    def from_param(cls: type[_ndptr[None]], obj: NDArray[Any]) -> _ctypes[Any]: ...
+    @overload
+    @classmethod
+    def from_param(cls: type[_ndptr[_DType]], obj: ndarray[Any, _DType]) -> _ctypes[Any]: ...
+
+class _concrete_ndptr(_ndptr[_DType]):
+    _dtype_: ClassVar[_DType]
+    _shape_: ClassVar[tuple[int, ...]]
+    @property
+    def contents(self) -> ndarray[Any, _DType]: ...
+
+def load_library(
+    libname: str | bytes | os.PathLike[str] | os.PathLike[bytes],
+    loader_path: str | bytes | os.PathLike[str] | os.PathLike[bytes],
+) -> ctypes.CDLL: ...
+
+__all__: list[str]
+
+c_intp = _c_intp
+
+@overload
+def ndpointer(
+    dtype: None = ...,
+    ndim: int = ...,
+    shape: None | _ShapeLike = ...,
+    flags: None | _FlagsKind | Iterable[_FlagsKind] | int | flagsobj = ...,
+) -> type[_ndptr[None]]: ...
+@overload
+def ndpointer(
+    dtype: _DTypeLike[_SCT],
+    ndim: int = ...,
+    *,
+    shape: _ShapeLike,
+    flags: None | _FlagsKind | Iterable[_FlagsKind] | int | flagsobj = ...,
+) -> type[_concrete_ndptr[dtype[_SCT]]]: ...
+@overload
+def ndpointer(
+    dtype: DTypeLike,
+    ndim: int = ...,
+    *,
+    shape: _ShapeLike,
+    flags: None | _FlagsKind | Iterable[_FlagsKind] | int | flagsobj = ...,
+) -> type[_concrete_ndptr[dtype[Any]]]: ...
+@overload
+def ndpointer(
+    dtype: _DTypeLike[_SCT],
+    ndim: int = ...,
+    shape: None = ...,
+    flags: None | _FlagsKind | Iterable[_FlagsKind] | int | flagsobj = ...,
+) -> type[_ndptr[dtype[_SCT]]]: ...
+@overload
+def ndpointer(
+    dtype: DTypeLike,
+    ndim: int = ...,
+    shape: None = ...,
+    flags: None | _FlagsKind | Iterable[_FlagsKind] | int | flagsobj = ...,
+) -> type[_ndptr[dtype[Any]]]: ...
+
+@overload
+def as_ctypes_type(dtype: _BoolCodes | _DTypeLike[np.bool] | type[ctypes.c_bool]) -> type[ctypes.c_bool]: ...
+@overload
+def as_ctypes_type(dtype: _ByteCodes | _DTypeLike[byte] | type[ctypes.c_byte]) -> type[ctypes.c_byte]: ...
+@overload
+def as_ctypes_type(dtype: _ShortCodes | _DTypeLike[short] | type[ctypes.c_short]) -> type[ctypes.c_short]: ...
+@overload
+def as_ctypes_type(dtype: _IntCCodes | _DTypeLike[intc] | type[ctypes.c_int]) -> type[ctypes.c_int]: ...
+@overload
+def as_ctypes_type(dtype: _LongCodes | _DTypeLike[long] | type[ctypes.c_long]) -> type[ctypes.c_long]: ...
+@overload
+def as_ctypes_type(dtype: type[int]) -> type[c_intp]: ...
+@overload
+def as_ctypes_type(dtype: _LongLongCodes | _DTypeLike[longlong] | type[ctypes.c_longlong]) -> type[ctypes.c_longlong]: ...
+@overload
+def as_ctypes_type(dtype: _UByteCodes | _DTypeLike[ubyte] | type[ctypes.c_ubyte]) -> type[ctypes.c_ubyte]: ...
+@overload
+def as_ctypes_type(dtype: _UShortCodes | _DTypeLike[ushort] | type[ctypes.c_ushort]) -> type[ctypes.c_ushort]: ...
+@overload
+def as_ctypes_type(dtype: _UIntCCodes | _DTypeLike[uintc] | type[ctypes.c_uint]) -> type[ctypes.c_uint]: ...
+@overload
+def as_ctypes_type(dtype: _ULongCodes | _DTypeLike[ulong] | type[ctypes.c_ulong]) -> type[ctypes.c_ulong]: ...
+@overload
+def as_ctypes_type(dtype: _ULongLongCodes | _DTypeLike[ulonglong] | type[ctypes.c_ulonglong]) -> type[ctypes.c_ulonglong]: ...
+@overload
+def as_ctypes_type(dtype: _SingleCodes | _DTypeLike[single] | type[ctypes.c_float]) -> type[ctypes.c_float]: ...
+@overload
+def as_ctypes_type(dtype: _DoubleCodes | _DTypeLike[double] | type[float | ctypes.c_double]) -> type[ctypes.c_double]: ...
+@overload
+def as_ctypes_type(dtype: _LongDoubleCodes | _DTypeLike[longdouble] | type[ctypes.c_longdouble]) -> type[ctypes.c_longdouble]: ...
+@overload
+def as_ctypes_type(dtype: _VoidDTypeLike) -> type[Any]: ...  # `ctypes.Union` or `ctypes.Structure`
+@overload
+def as_ctypes_type(dtype: str) -> type[Any]: ...
+
+@overload
+def as_array(obj: ctypes._PointerLike, shape: Sequence[int]) -> NDArray[Any]: ...
+@overload
+def as_array(obj: _ArrayLike[_SCT], shape: None | _ShapeLike = ...) -> NDArray[_SCT]: ...
+@overload
+def as_array(obj: object, shape: None | _ShapeLike = ...) -> NDArray[Any]: ...
+
+@overload
+def as_ctypes(obj: np.bool) -> ctypes.c_bool: ...
+@overload
+def as_ctypes(obj: byte) -> ctypes.c_byte: ...
+@overload
+def as_ctypes(obj: short) -> ctypes.c_short: ...
+@overload
+def as_ctypes(obj: intc) -> ctypes.c_int: ...
+@overload
+def as_ctypes(obj: long) -> ctypes.c_long: ...
+@overload
+def as_ctypes(obj: longlong) -> ctypes.c_longlong: ...
+@overload
+def as_ctypes(obj: ubyte) -> ctypes.c_ubyte: ...
+@overload
+def as_ctypes(obj: ushort) -> ctypes.c_ushort: ...
+@overload
+def as_ctypes(obj: uintc) -> ctypes.c_uint: ...
+@overload
+def as_ctypes(obj: ulong) -> ctypes.c_ulong: ...
+@overload
+def as_ctypes(obj: ulonglong) -> ctypes.c_ulonglong: ...
+@overload
+def as_ctypes(obj: single) -> ctypes.c_float: ...
+@overload
+def as_ctypes(obj: double) -> ctypes.c_double: ...
+@overload
+def as_ctypes(obj: longdouble) -> ctypes.c_longdouble: ...
+@overload
+def as_ctypes(obj: void) -> Any: ...  # `ctypes.Union` or `ctypes.Structure`
+@overload
+def as_ctypes(obj: NDArray[np.bool]) -> ctypes.Array[ctypes.c_bool]: ...
+@overload
+def as_ctypes(obj: NDArray[byte]) -> ctypes.Array[ctypes.c_byte]: ...
+@overload
+def as_ctypes(obj: NDArray[short]) -> ctypes.Array[ctypes.c_short]: ...
+@overload
+def as_ctypes(obj: NDArray[intc]) -> ctypes.Array[ctypes.c_int]: ...
+@overload
+def as_ctypes(obj: NDArray[long]) -> ctypes.Array[ctypes.c_long]: ...
+@overload
+def as_ctypes(obj: NDArray[longlong]) -> ctypes.Array[ctypes.c_longlong]: ...
+@overload
+def as_ctypes(obj: NDArray[ubyte]) -> ctypes.Array[ctypes.c_ubyte]: ...
+@overload
+def as_ctypes(obj: NDArray[ushort]) -> ctypes.Array[ctypes.c_ushort]: ...
+@overload
+def as_ctypes(obj: NDArray[uintc]) -> ctypes.Array[ctypes.c_uint]: ...
+@overload
+def as_ctypes(obj: NDArray[ulong]) -> ctypes.Array[ctypes.c_ulong]: ...
+@overload
+def as_ctypes(obj: NDArray[ulonglong]) -> ctypes.Array[ctypes.c_ulonglong]: ...
+@overload
+def as_ctypes(obj: NDArray[single]) -> ctypes.Array[ctypes.c_float]: ...
+@overload
+def as_ctypes(obj: NDArray[double]) -> ctypes.Array[ctypes.c_double]: ...
+@overload
+def as_ctypes(obj: NDArray[longdouble]) -> ctypes.Array[ctypes.c_longdouble]: ...
+@overload
+def as_ctypes(obj: NDArray[void]) -> ctypes.Array[Any]: ...  # `ctypes.Union` or `ctypes.Structure`
diff --git a/venv/lib/python3.12/site-packages/numpy/doc/__pycache__/ufuncs.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/doc/__pycache__/ufuncs.cpython-312.pyc
new file mode 100644
index 00000000..22d5a855
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/doc/__pycache__/ufuncs.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/doc/ufuncs.py b/venv/lib/python3.12/site-packages/numpy/doc/ufuncs.py
new file mode 100644
index 00000000..7324168e
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/doc/ufuncs.py
@@ -0,0 +1,138 @@
+"""
+===================
+Universal Functions
+===================
+
+Ufuncs are, generally speaking, mathematical functions or operations that are
+applied element-by-element to the contents of an array. That is, the result
+in each output array element only depends on the value in the corresponding
+input array (or arrays) and on no other array elements. NumPy comes with a
+large suite of ufuncs, and scipy extends that suite substantially. The simplest
+example is the addition operator: ::
+
+ >>> np.array([0,2,3,4]) + np.array([1,1,-1,2])
+ array([1, 3, 2, 6])
+
+The ufunc module lists all the available ufuncs in numpy. Documentation on
+the specific ufuncs may be found in those modules. This documentation is
+intended to address the more general aspects of ufuncs common to most of
+them. All of the ufuncs that make use of Python operators (e.g., +, -, etc.)
+have equivalent functions defined (e.g. add() for +)
+
+Type coercion
+=============
+
+What happens when a binary operator (e.g., +,-,\\*,/, etc) deals with arrays of
+two different types? What is the type of the result? Typically, the result is
+the higher of the two types. For example: ::
+
+ float32 + float64 -> float64
+ int8 + int32 -> int32
+ int16 + float32 -> float32
+ float32 + complex64 -> complex64
+
+There are some less obvious cases generally involving mixes of types
+(e.g. uints, ints and floats) where equal bit sizes for each are not
+capable of saving all the information in a different type of equivalent
+bit size. Some examples are int32 vs float32 or uint32 vs int32.
+Generally, the result is the higher type of larger size than both
+(if available). So: ::
+
+ int32 + float32 -> float64
+ uint32 + int32 -> int64
+
+Finally, the type coercion behavior when expressions involve Python
+scalars is different than that seen for arrays. Since Python has a
+limited number of types, combining a Python int with a dtype=np.int8
+array does not coerce to the higher type but instead, the type of the
+array prevails. So the rules for Python scalars combined with arrays is
+that the result will be that of the array equivalent the Python scalar
+if the Python scalar is of a higher 'kind' than the array (e.g., float
+vs. int), otherwise the resultant type will be that of the array.
+For example: ::
+
+  Python int + int8 -> int8
+  Python float + int8 -> float64
+
+ufunc methods
+=============
+
+Binary ufuncs support 4 methods.
+
+**.reduce(arr)** applies the binary operator to elements of the array in
+  sequence. For example: ::
+
+ >>> np.add.reduce(np.arange(10))  # adds all elements of array
+ 45
+
+For multidimensional arrays, the first dimension is reduced by default: ::
+
+ >>> np.add.reduce(np.arange(10).reshape(2,5))
+     array([ 5,  7,  9, 11, 13])
+
+The axis keyword can be used to specify different axes to reduce: ::
+
+ >>> np.add.reduce(np.arange(10).reshape(2,5),axis=1)
+ array([10, 35])
+
+**.accumulate(arr)** applies the binary operator and generates an
+equivalently shaped array that includes the accumulated amount for each
+element of the array. A couple examples: ::
+
+ >>> np.add.accumulate(np.arange(10))
+ array([ 0,  1,  3,  6, 10, 15, 21, 28, 36, 45])
+ >>> np.multiply.accumulate(np.arange(1,9))
+ array([    1,     2,     6,    24,   120,   720,  5040, 40320])
+
+The behavior for multidimensional arrays is the same as for .reduce(),
+as is the use of the axis keyword).
+
+**.reduceat(arr,indices)** allows one to apply reduce to selected parts
+  of an array. It is a difficult method to understand. See the documentation
+  at:
+
+**.outer(arr1,arr2)** generates an outer operation on the two arrays arr1 and
+  arr2. It will work on multidimensional arrays (the shape of the result is
+  the concatenation of the two input shapes.: ::
+
+ >>> np.multiply.outer(np.arange(3),np.arange(4))
+ array([[0, 0, 0, 0],
+        [0, 1, 2, 3],
+        [0, 2, 4, 6]])
+
+Output arguments
+================
+
+All ufuncs accept an optional output array. The array must be of the expected
+output shape. Beware that if the type of the output array is of a different
+(and lower) type than the output result, the results may be silently truncated
+or otherwise corrupted in the downcast to the lower type. This usage is useful
+when one wants to avoid creating large temporary arrays and instead allows one
+to reuse the same array memory repeatedly (at the expense of not being able to
+use more convenient operator notation in expressions). Note that when the
+output argument is used, the ufunc still returns a reference to the result.
+
+ >>> x = np.arange(2)
+ >>> np.add(np.arange(2, dtype=float), np.arange(2, dtype=float), x,
+ ...        casting='unsafe')
+ array([0, 2])
+ >>> x
+ array([0, 2])
+
+and & or as ufuncs
+==================
+
+Invariably people try to use the python 'and' and 'or' as logical operators
+(and quite understandably). But these operators do not behave as normal
+operators since Python treats these quite differently. They cannot be
+overloaded with array equivalents. Thus using 'and' or 'or' with an array
+results in an error. There are two alternatives:
+
+ 1) use the ufunc functions logical_and() and logical_or().
+ 2) use the bitwise operators & and \\|. The drawback of these is that if
+    the arguments to these operators are not boolean arrays, the result is
+    likely incorrect. On the other hand, most usages of logical_and and
+    logical_or are with boolean arrays. As long as one is careful, this is
+    a convenient way to apply these operators.
+
+"""
diff --git a/venv/lib/python3.12/site-packages/numpy/dtypes.py b/venv/lib/python3.12/site-packages/numpy/dtypes.py
new file mode 100644
index 00000000..550a29e1
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/dtypes.py
@@ -0,0 +1,41 @@
+"""
+This module is home to specific dtypes related functionality and their classes.
+For more general information about dtypes, also see `numpy.dtype` and
+:ref:`arrays.dtypes`.
+
+Similar to the builtin ``types`` module, this submodule defines types (classes)
+that are not widely used directly.
+
+.. versionadded:: NumPy 1.25
+
+    The dtypes module is new in NumPy 1.25.  Previously DType classes were
+    only accessible indirectly.
+
+
+DType classes
+-------------
+
+The following are the classes of the corresponding NumPy dtype instances and
+NumPy scalar types.  The classes can be used in ``isinstance`` checks and can
+also be instantiated or used directly.  Direct use of these classes is not
+typical, since their scalar counterparts (e.g. ``np.float64``) or strings
+like ``"float64"`` can be used.
+"""
+
+# See doc/source/reference/routines.dtypes.rst for module-level docs
+
+__all__ = []
+
+
+def _add_dtype_helper(DType, alias):
+    # Function to add DTypes a bit more conveniently without channeling them
+    # through `numpy._core._multiarray_umath` namespace or similar.
+    from numpy import dtypes
+
+    setattr(dtypes, DType.__name__, DType)
+    __all__.append(DType.__name__)
+
+    if alias:
+        alias = alias.removeprefix("numpy.dtypes.")
+        setattr(dtypes, alias, DType)
+        __all__.append(alias)
diff --git a/venv/lib/python3.12/site-packages/numpy/dtypes.pyi b/venv/lib/python3.12/site-packages/numpy/dtypes.pyi
new file mode 100644
index 00000000..706e538c
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/dtypes.pyi
@@ -0,0 +1,600 @@
+from typing import (
+    Any,
+    Final,
+    Generic,
+    Literal as L,
+    NoReturn,
+    TypeAlias,
+    TypeVar,
+    final,
+)
+from typing_extensions import LiteralString
+
+import numpy as np
+
+__all__ = [
+    'BoolDType',
+    'Int8DType',
+    'ByteDType',
+    'UInt8DType',
+    'UByteDType',
+    'Int16DType',
+    'ShortDType',
+    'UInt16DType',
+    'UShortDType',
+    'Int32DType',
+    'IntDType',
+    'UInt32DType',
+    'UIntDType',
+    'Int64DType',
+    'LongDType',
+    'UInt64DType',
+    'ULongDType',
+    'LongLongDType',
+    'ULongLongDType',
+    'Float16DType',
+    'Float32DType',
+    'Float64DType',
+    'LongDoubleDType',
+    'Complex64DType',
+    'Complex128DType',
+    'CLongDoubleDType',
+    'ObjectDType',
+    'BytesDType',
+    'StrDType',
+    'VoidDType',
+    'DateTime64DType',
+    'TimeDelta64DType',
+    'StringDType',
+]
+
+# Helper base classes (typing-only)
+
+_SelfT = TypeVar("_SelfT", bound=np.dtype[Any])
+_SCT_co = TypeVar("_SCT_co", bound=np.generic, covariant=True)
+
+class _SimpleDType(Generic[_SCT_co], np.dtype[_SCT_co]):  # type: ignore[misc]
+    names: None  # pyright: ignore[reportIncompatibleVariableOverride]
+    def __new__(cls: type[_SelfT], /) -> _SelfT: ...
+    def __getitem__(self, key: Any, /) -> NoReturn: ...
+    @property
+    def base(self) -> np.dtype[_SCT_co]: ...
+    @property
+    def fields(self) -> None: ...
+    @property
+    def isalignedstruct(self) -> L[False]: ...
+    @property
+    def isnative(self) -> L[True]: ...
+    @property
+    def ndim(self) -> L[0]: ...
+    @property
+    def shape(self) -> tuple[()]: ...
+    @property
+    def subdtype(self) -> None: ...
+
+class _LiteralDType(Generic[_SCT_co], _SimpleDType[_SCT_co]):
+    @property
+    def flags(self) -> L[0]: ...
+    @property
+    def hasobject(self) -> L[False]: ...
+
+# Helper mixins (typing-only):
+
+_KindT_co = TypeVar("_KindT_co", bound=LiteralString, covariant=True)
+_CharT_co = TypeVar("_CharT_co", bound=LiteralString, covariant=True)
+_NumT_co = TypeVar("_NumT_co", bound=int, covariant=True)
+
+class _TypeCodes(Generic[_KindT_co, _CharT_co, _NumT_co]):
+    @final
+    @property
+    def kind(self) -> _KindT_co: ...
+    @final
+    @property
+    def char(self) -> _CharT_co: ...
+    @final
+    @property
+    def num(self) -> _NumT_co: ...
+
+class _NoOrder:
+    @final
+    @property
+    def byteorder(self) -> L["|"]: ...
+
+class _NativeOrder:
+    @final
+    @property
+    def byteorder(self) -> L["="]: ...
+
+_DataSize_co = TypeVar("_DataSize_co", bound=int, covariant=True)
+_ItemSize_co = TypeVar("_ItemSize_co", bound=int, covariant=True)
+
+class _NBit(Generic[_DataSize_co, _ItemSize_co]):
+    @final
+    @property
+    def alignment(self) -> _DataSize_co: ...
+    @final
+    @property
+    def itemsize(self) -> _ItemSize_co: ...
+
+class _8Bit(_NoOrder, _NBit[L[1], L[1]]): ...
+
+# Boolean:
+
+@final
+class BoolDType(
+    _TypeCodes[L["b"], L["?"], L[0]],
+    _8Bit,
+    _LiteralDType[np.bool],
+):
+    @property
+    def name(self) -> L["bool"]: ...
+    @property
+    def str(self) -> L["|b1"]: ...
+
+# Sized integers:
+
+@final
+class Int8DType(
+    _TypeCodes[L["i"], L["b"], L[1]],
+    _8Bit,
+    _LiteralDType[np.int8],
+):
+    @property
+    def name(self) -> L["int8"]: ...
+    @property
+    def str(self) -> L["|i1"]: ...
+
+@final
+class UInt8DType(
+    _TypeCodes[L["u"], L["B"], L[2]],
+    _8Bit,
+    _LiteralDType[np.uint8],
+):
+    @property
+    def name(self) -> L["uint8"]: ...
+    @property
+    def str(self) -> L["|u1"]: ...
+
+@final
+class Int16DType(
+    _TypeCodes[L["i"], L["h"], L[3]],
+    _NativeOrder,
+    _NBit[L[2], L[2]],
+    _LiteralDType[np.int16],
+):
+    @property
+    def name(self) -> L["int16"]: ...
+    @property
+    def str(self) -> L["i2"]: ...
+
+@final
+class UInt16DType(
+    _TypeCodes[L["u"], L["H"], L[4]],
+    _NativeOrder,
+    _NBit[L[2], L[2]],
+    _LiteralDType[np.uint16],
+):
+    @property
+    def name(self) -> L["uint16"]: ...
+    @property
+    def str(self) -> L["u2"]: ...
+
+@final
+class Int32DType(
+    _TypeCodes[L["i"], L["i", "l"], L[5, 7]],
+    _NativeOrder,
+    _NBit[L[4], L[4]],
+    _LiteralDType[np.int32],
+):
+    @property
+    def name(self) -> L["int32"]: ...
+    @property
+    def str(self) -> L["i4"]: ...
+
+@final
+class UInt32DType(
+    _TypeCodes[L["u"], L["I", "L"], L[6, 8]],
+    _NativeOrder,
+    _NBit[L[4], L[4]],
+    _LiteralDType[np.uint32],
+):
+    @property
+    def name(self) -> L["uint32"]: ...
+    @property
+    def str(self) -> L["u4"]: ...
+
+@final
+class Int64DType(
+    _TypeCodes[L["i"], L["l", "q"], L[7, 9]],
+    _NativeOrder,
+    _NBit[L[8], L[8]],
+    _LiteralDType[np.int64],
+):
+    @property
+    def name(self) -> L["int64"]: ...
+    @property
+    def str(self) -> L["i8"]: ...
+
+@final
+class UInt64DType(
+    _TypeCodes[L["u"], L["L", "Q"], L[8, 10]],
+    _NativeOrder,
+    _NBit[L[8], L[8]],
+    _LiteralDType[np.uint64],
+):
+    @property
+    def name(self) -> L["uint64"]: ...
+    @property
+    def str(self) -> L["u8"]: ...
+
+# Standard C-named version/alias:
+ByteDType: Final = Int8DType
+UByteDType: Final = UInt8DType
+ShortDType: Final = Int16DType
+UShortDType: Final = UInt16DType
+
+@final
+class IntDType(
+    _TypeCodes[L["i"], L["i"], L[5]],
+    _NativeOrder,
+    _NBit[L[4], L[4]],
+    _LiteralDType[np.intc],
+):
+    @property
+    def name(self) -> L["int32"]: ...
+    @property
+    def str(self) -> L["i4"]: ...
+
+@final
+class UIntDType(
+    _TypeCodes[L["u"], L["I"], L[6]],
+    _NativeOrder,
+    _NBit[L[4], L[4]],
+    _LiteralDType[np.uintc],
+):
+    @property
+    def name(self) -> L["uint32"]: ...
+    @property
+    def str(self) -> L["u4"]: ...
+
+@final
+class LongDType(
+    _TypeCodes[L["i"], L["l"], L[7]],
+    _NativeOrder,
+    _NBit[L[4, 8], L[4, 8]],
+    _LiteralDType[np.long],
+):
+    @property
+    def name(self) -> L["int32", "int64"]: ...
+    @property
+    def str(self) -> L["i4", "i8"]: ...
+
+@final
+class ULongDType(
+    _TypeCodes[L["u"], L["L"], L[8]],
+    _NativeOrder,
+    _NBit[L[4, 8], L[4, 8]],
+    _LiteralDType[np.ulong],
+):
+    @property
+    def name(self) -> L["uint32", "uint64"]: ...
+    @property
+    def str(self) -> L["u4", "u8"]: ...
+
+@final
+class LongLongDType(
+    _TypeCodes[L["i"], L["q"], L[9]],
+    _NativeOrder,
+    _NBit[L[8], L[8]],
+    _LiteralDType[np.longlong],
+):
+    @property
+    def name(self) -> L["int64"]: ...
+    @property
+    def str(self) -> L["i8"]: ...
+
+@final
+class ULongLongDType(
+    _TypeCodes[L["u"], L["Q"], L[10]],
+    _NativeOrder,
+    _NBit[L[8], L[8]],
+    _LiteralDType[np.ulonglong],
+):
+    @property
+    def name(self) -> L["uint64"]: ...
+    @property
+    def str(self) -> L["u8"]: ...
+
+# Floats:
+
+@final
+class Float16DType(
+    _TypeCodes[L["f"], L["e"], L[23]],
+    _NativeOrder,
+    _NBit[L[2], L[2]],
+    _LiteralDType[np.float16],
+):
+    @property
+    def name(self) -> L["float16"]: ...
+    @property
+    def str(self) -> L["f2"]: ...
+
+@final
+class Float32DType(
+    _TypeCodes[L["f"], L["f"], L[11]],
+    _NativeOrder,
+    _NBit[L[4], L[4]],
+    _LiteralDType[np.float32],
+):
+    @property
+    def name(self) -> L["float32"]: ...
+    @property
+    def str(self) -> L["f4"]: ...
+
+@final
+class Float64DType(
+    _TypeCodes[L["f"], L["d"], L[12]],
+    _NativeOrder,
+    _NBit[L[8], L[8]],
+    _LiteralDType[np.float64],
+):
+    @property
+    def name(self) -> L["float64"]: ...
+    @property
+    def str(self) -> L["f8"]: ...
+
+@final
+class LongDoubleDType(
+    _TypeCodes[L["f"], L["g"], L[13]],
+    _NativeOrder,
+    _NBit[L[8, 12, 16], L[8, 12, 16]],
+    _LiteralDType[np.longdouble],
+):
+    @property
+    def name(self) -> L["float64", "float96", "float128"]: ...
+    @property
+    def str(self) -> L["f8", "f12", "f16"]: ...
+
+# Complex:
+
+@final
+class Complex64DType(
+    _TypeCodes[L["c"], L["F"], L[14]],
+    _NativeOrder,
+    _NBit[L[4], L[8]],
+    _LiteralDType[np.complex64],
+):
+    @property
+    def name(self) -> L["complex64"]: ...
+    @property
+    def str(self) -> L["c8"]: ...
+
+@final
+class Complex128DType(
+    _TypeCodes[L["c"], L["D"], L[15]],
+    _NativeOrder,
+    _NBit[L[8], L[16]],
+    _LiteralDType[np.complex128],
+):
+    @property
+    def name(self) -> L["complex128"]: ...
+    @property
+    def str(self) -> L["c16"]: ...
+
+@final
+class CLongDoubleDType(
+    _TypeCodes[L["c"], L["G"], L[16]],
+    _NativeOrder,
+    _NBit[L[8, 12, 16], L[16, 24, 32]],
+    _LiteralDType[np.clongdouble],
+):
+    @property
+    def name(self) -> L["complex128", "complex192", "complex256"]: ...
+    @property
+    def str(self) -> L["c16", "c24", "c32"]: ...
+
+# Python objects:
+
+@final
+class ObjectDType(
+    _TypeCodes[L["O"], L["O"], L[17]],
+    _NoOrder,
+    _NBit[L[8], L[8]],
+    _SimpleDType[np.object_],
+):
+    @property
+    def hasobject(self) -> L[True]: ...
+    @property
+    def name(self) -> L["object"]: ...
+    @property
+    def str(self) -> L["|O"]: ...
+
+# Flexible:
+
+@final
+class BytesDType(
+    Generic[_ItemSize_co],
+    _TypeCodes[L["S"], L["S"], L[18]],
+    _NoOrder,
+    _NBit[L[1],_ItemSize_co],
+    _SimpleDType[np.bytes_],
+):
+    def __new__(cls, size: _ItemSize_co, /) -> BytesDType[_ItemSize_co]: ...
+    @property
+    def hasobject(self) -> L[False]: ...
+    @property
+    def name(self) -> LiteralString: ...
+    @property
+    def str(self) -> LiteralString: ...
+
+@final
+class StrDType(
+    Generic[_ItemSize_co],
+    _TypeCodes[L["U"], L["U"], L[19]],
+    _NativeOrder,
+    _NBit[L[4],_ItemSize_co],
+    _SimpleDType[np.str_],
+):
+    def __new__(cls, size: _ItemSize_co, /) -> StrDType[_ItemSize_co]: ...
+    @property
+    def hasobject(self) -> L[False]: ...
+    @property
+    def name(self) -> LiteralString: ...
+    @property
+    def str(self) -> LiteralString: ...
+
+@final
+class VoidDType(
+    Generic[_ItemSize_co],
+    _TypeCodes[L["V"], L["V"], L[20]],
+    _NoOrder,
+    _NBit[L[1], _ItemSize_co],
+    np.dtype[np.void],  # type: ignore[misc]
+):
+    # NOTE: `VoidDType(...)` raises a `TypeError` at the moment
+    def __new__(cls, length: _ItemSize_co, /) -> NoReturn: ...
+    @property
+    def base(self: _SelfT) -> _SelfT: ...
+    @property
+    def isalignedstruct(self) -> L[False]: ...
+    @property
+    def isnative(self) -> L[True]: ...
+    @property
+    def ndim(self) -> L[0]: ...
+    @property
+    def shape(self) -> tuple[()]: ...
+    @property
+    def subdtype(self) -> None: ...
+    @property
+    def name(self) -> LiteralString: ...
+    @property
+    def str(self) -> LiteralString: ...
+
+# Other:
+
+_DateUnit: TypeAlias = L["Y", "M", "W", "D"]
+_TimeUnit: TypeAlias = L["h", "m", "s", "ms", "us", "ns", "ps", "fs", "as"]
+_DateTimeUnit: TypeAlias = _DateUnit | _TimeUnit
+
+@final
+class DateTime64DType(
+    _TypeCodes[L["M"], L["M"], L[21]],
+    _NativeOrder,
+    _NBit[L[8], L[8]],
+    _LiteralDType[np.datetime64],
+):
+    # NOTE: `DateTime64DType(...)` raises a `TypeError` at the moment
+    # TODO: Once implemented, don't forget the`unit: L["μs"]` overload.
+    def __new__(cls, unit: _DateTimeUnit, /) -> NoReturn: ...
+    @property
+    def name(self) -> L[
+        "datetime64",
+        "datetime64[Y]",
+        "datetime64[M]",
+        "datetime64[W]",
+        "datetime64[D]",
+        "datetime64[h]",
+        "datetime64[m]",
+        "datetime64[s]",
+        "datetime64[ms]",
+        "datetime64[us]",
+        "datetime64[ns]",
+        "datetime64[ps]",
+        "datetime64[fs]",
+        "datetime64[as]",
+    ]: ...
+    @property
+    def str(self) -> L[
+        "M8",
+        "M8[Y]",
+        "M8[M]",
+        "M8[W]",
+        "M8[D]",
+        "M8[h]",
+        "M8[m]",
+        "M8[s]",
+        "M8[ms]",
+        "M8[us]",
+        "M8[ns]",
+        "M8[ps]",
+        "M8[fs]",
+        "M8[as]",
+    ]: ...
+
+@final
+class TimeDelta64DType(
+    _TypeCodes[L["m"], L["m"], L[22]],
+    _NativeOrder,
+    _NBit[L[8], L[8]],
+    _LiteralDType[np.timedelta64],
+):
+    # NOTE: `TimeDelta64DType(...)` raises a `TypeError` at the moment
+    # TODO: Once implemented, don't forget to overload on `unit: L["μs"]`.
+    def __new__(cls, unit: _DateTimeUnit, /) -> NoReturn: ...
+    @property
+    def name(self) -> L[
+        "timedelta64",
+        "timedelta64[Y]",
+        "timedelta64[M]",
+        "timedelta64[W]",
+        "timedelta64[D]",
+        "timedelta64[h]",
+        "timedelta64[m]",
+        "timedelta64[s]",
+        "timedelta64[ms]",
+        "timedelta64[us]",
+        "timedelta64[ns]",
+        "timedelta64[ps]",
+        "timedelta64[fs]",
+        "timedelta64[as]",
+    ]: ...
+    @property
+    def str(self) -> L[
+        "m8",
+        "m8[Y]",
+        "m8[M]",
+        "m8[W]",
+        "m8[D]",
+        "m8[h]",
+        "m8[m]",
+        "m8[s]",
+        "m8[ms]",
+        "m8[us]",
+        "m8[ns]",
+        "m8[ps]",
+        "m8[fs]",
+        "m8[as]",
+    ]: ...
+
+@final
+class StringDType(
+    _TypeCodes[L["T"], L["T"], L[2056]],
+    _NativeOrder,
+    _NBit[L[8], L[16]],
+    # TODO: Replace the (invalid) `str` with the scalar type, once implemented
+    np.dtype[str],  # type: ignore[misc]
+):
+    def __new__(cls, /) -> StringDType: ...
+    def __getitem__(self, key: Any, /) -> NoReturn: ...
+    @property
+    def base(self) -> StringDType: ...
+    @property
+    def fields(self) -> None: ...
+    @property
+    def hasobject(self) -> L[True]: ...
+    @property
+    def isalignedstruct(self) -> L[False]: ...
+    @property
+    def isnative(self) -> L[True]: ...
+    @property
+    def name(self) -> L["StringDType64", "StringDType128"]: ...
+    @property
+    def ndim(self) -> L[0]: ...
+    @property
+    def shape(self) -> tuple[()]: ...
+    @property
+    def str(self) -> L["|T8", "|T16"]: ...
+    @property
+    def subdtype(self) -> None: ...
+    @property
+    def type(self) -> type[str]: ...
diff --git a/venv/lib/python3.12/site-packages/numpy/exceptions.py b/venv/lib/python3.12/site-packages/numpy/exceptions.py
new file mode 100644
index 00000000..adf88c75
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/exceptions.py
@@ -0,0 +1,249 @@
+"""
+Exceptions and Warnings (:mod:`numpy.exceptions`)
+=================================================
+
+General exceptions used by NumPy.  Note that some exceptions may be module
+specific, such as linear algebra errors.
+
+.. versionadded:: NumPy 1.25
+
+    The exceptions module is new in NumPy 1.25.  Older exceptions remain
+    available through the main NumPy namespace for compatibility.
+
+.. currentmodule:: numpy.exceptions
+
+Warnings
+--------
+.. autosummary::
+   :toctree: generated/
+
+   ComplexWarning             Given when converting complex to real.
+   VisibleDeprecationWarning  Same as a DeprecationWarning, but more visible.
+   RankWarning                Issued when the design matrix is rank deficient.
+
+Exceptions
+----------
+.. autosummary::
+   :toctree: generated/
+
+    AxisError          Given when an axis was invalid.
+    DTypePromotionError   Given when no common dtype could be found.
+    TooHardError       Error specific to `numpy.shares_memory`.
+
+"""
+
+
+__all__ = [
+    "ComplexWarning", "VisibleDeprecationWarning", "ModuleDeprecationWarning",
+    "TooHardError", "AxisError", "DTypePromotionError"]
+
+
+# Disallow reloading this module so as to preserve the identities of the
+# classes defined here.
+if '_is_loaded' in globals():
+    raise RuntimeError('Reloading numpy._globals is not allowed')
+_is_loaded = True
+
+
+class ComplexWarning(RuntimeWarning):
+    """
+    The warning raised when casting a complex dtype to a real dtype.
+
+    As implemented, casting a complex number to a real discards its imaginary
+    part, but this behavior may not be what the user actually wants.
+
+    """
+    pass
+
+
+class ModuleDeprecationWarning(DeprecationWarning):
+    """Module deprecation warning.
+
+    .. warning::
+
+        This warning should not be used, since nose testing is not relevant
+        anymore.
+
+    The nose tester turns ordinary Deprecation warnings into test failures.
+    That makes it hard to deprecate whole modules, because they get
+    imported by default. So this is a special Deprecation warning that the
+    nose tester will let pass without making tests fail.
+
+    """
+    pass
+
+
+class VisibleDeprecationWarning(UserWarning):
+    """Visible deprecation warning.
+
+    By default, python will not show deprecation warnings, so this class
+    can be used when a very visible warning is helpful, for example because
+    the usage is most likely a user bug.
+
+    """
+    pass
+
+
+class RankWarning(RuntimeWarning):
+    """Matrix rank warning.
+    
+    Issued by polynomial functions when the design matrix is rank deficient.
+    
+    """
+    pass
+
+
+# Exception used in shares_memory()
+class TooHardError(RuntimeError):
+    """max_work was exceeded.
+
+    This is raised whenever the maximum number of candidate solutions
+    to consider specified by the ``max_work`` parameter is exceeded.
+    Assigning a finite number to max_work may have caused the operation
+    to fail.
+
+    """
+    pass
+
+
+class AxisError(ValueError, IndexError):
+    """Axis supplied was invalid.
+
+    This is raised whenever an ``axis`` parameter is specified that is larger
+    than the number of array dimensions.
+    For compatibility with code written against older numpy versions, which
+    raised a mixture of :exc:`ValueError` and :exc:`IndexError` for this
+    situation, this exception subclasses both to ensure that
+    ``except ValueError`` and ``except IndexError`` statements continue
+    to catch ``AxisError``.
+
+    .. versionadded:: 1.13
+
+    Parameters
+    ----------
+    axis : int or str
+        The out of bounds axis or a custom exception message.
+        If an axis is provided, then `ndim` should be specified as well.
+    ndim : int, optional
+        The number of array dimensions.
+    msg_prefix : str, optional
+        A prefix for the exception message.
+
+    Attributes
+    ----------
+    axis : int, optional
+        The out of bounds axis or ``None`` if a custom exception
+        message was provided. This should be the axis as passed by
+        the user, before any normalization to resolve negative indices.
+
+        .. versionadded:: 1.22
+    ndim : int, optional
+        The number of array dimensions or ``None`` if a custom exception
+        message was provided.
+
+        .. versionadded:: 1.22
+
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> array_1d = np.arange(10)
+    >>> np.cumsum(array_1d, axis=1)
+    Traceback (most recent call last):
+      ...
+    numpy.exceptions.AxisError: axis 1 is out of bounds for array of dimension 1
+
+    Negative axes are preserved:
+
+    >>> np.cumsum(array_1d, axis=-2)
+    Traceback (most recent call last):
+      ...
+    numpy.exceptions.AxisError: axis -2 is out of bounds for array of dimension 1
+
+    The class constructor generally takes the axis and arrays'
+    dimensionality as arguments:
+
+    >>> print(np.exceptions.AxisError(2, 1, msg_prefix='error'))
+    error: axis 2 is out of bounds for array of dimension 1
+
+    Alternatively, a custom exception message can be passed:
+
+    >>> print(np.exceptions.AxisError('Custom error message'))
+    Custom error message
+
+    """
+
+    __slots__ = ("axis", "ndim", "_msg")
+
+    def __init__(self, axis, ndim=None, msg_prefix=None):
+        if ndim is msg_prefix is None:
+            # single-argument form: directly set the error message
+            self._msg = axis
+            self.axis = None
+            self.ndim = None
+        else:
+            self._msg = msg_prefix
+            self.axis = axis
+            self.ndim = ndim
+
+    def __str__(self):
+        axis = self.axis
+        ndim = self.ndim
+
+        if axis is ndim is None:
+            return self._msg
+        else:
+            msg = f"axis {axis} is out of bounds for array of dimension {ndim}"
+            if self._msg is not None:
+                msg = f"{self._msg}: {msg}"
+            return msg
+
+
+class DTypePromotionError(TypeError):
+    """Multiple DTypes could not be converted to a common one.
+
+    This exception derives from ``TypeError`` and is raised whenever dtypes
+    cannot be converted to a single common one.  This can be because they
+    are of a different category/class or incompatible instances of the same
+    one (see Examples).
+
+    Notes
+    -----
+    Many functions will use promotion to find the correct result and
+    implementation.  For these functions the error will typically be chained
+    with a more specific error indicating that no implementation was found
+    for the input dtypes.
+
+    Typically promotion should be considered "invalid" between the dtypes of
+    two arrays when `arr1 == arr2` can safely return all ``False`` because the
+    dtypes are fundamentally different.
+
+    Examples
+    --------
+    Datetimes and complex numbers are incompatible classes and cannot be
+    promoted:
+
+    >>> import numpy as np
+    >>> np.result_type(np.dtype("M8[s]"), np.complex128)  # doctest: +IGNORE_EXCEPTION_DETAIL
+    Traceback (most recent call last):
+     ...
+    DTypePromotionError: The DType  could not
+    be promoted by . This means that no common
+    DType exists for the given inputs. For example they cannot be stored in a
+    single array unless the dtype is `object`. The full list of DTypes is:
+    (, )
+
+    For example for structured dtypes, the structure can mismatch and the
+    same ``DTypePromotionError`` is given when two structured dtypes with
+    a mismatch in their number of fields is given:
+
+    >>> dtype1 = np.dtype([("field1", np.float64), ("field2", np.int64)])
+    >>> dtype2 = np.dtype([("field1", np.float64)])
+    >>> np.promote_types(dtype1, dtype2)  # doctest: +IGNORE_EXCEPTION_DETAIL
+    Traceback (most recent call last):
+     ...
+    DTypePromotionError: field names `('field1', 'field2')` and `('field1',)`
+    mismatch.
+
+    """  # NOQA
+    pass
diff --git a/venv/lib/python3.12/site-packages/numpy/exceptions.pyi b/venv/lib/python3.12/site-packages/numpy/exceptions.pyi
new file mode 100644
index 00000000..8a99713f
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/exceptions.pyi
@@ -0,0 +1,19 @@
+from typing import overload
+
+__all__: list[str]
+
+class ComplexWarning(RuntimeWarning): ...
+class ModuleDeprecationWarning(DeprecationWarning): ...
+class VisibleDeprecationWarning(UserWarning): ...
+class RankWarning(RuntimeWarning): ...
+class TooHardError(RuntimeError): ...
+class DTypePromotionError(TypeError): ...
+
+class AxisError(ValueError, IndexError):
+    axis: None | int
+    ndim: None | int
+    @overload
+    def __init__(self, axis: str, ndim: None = ..., msg_prefix: None = ...) -> None: ...
+    @overload
+    def __init__(self, axis: int, ndim: int, msg_prefix: None | str = ...) -> None: ...
+    def __str__(self) -> str: ...
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/__init__.py b/venv/lib/python3.12/site-packages/numpy/f2py/__init__.py
new file mode 100644
index 00000000..dfb89767
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/__init__.py
@@ -0,0 +1,88 @@
+#!/usr/bin/env python3
+"""Fortran to Python Interface Generator.
+
+Copyright 1999 -- 2011 Pearu Peterson all rights reserved.
+Copyright 2011 -- present NumPy Developers.
+Permission to use, modify, and distribute this software is given under the terms
+of the NumPy License.
+
+NO WARRANTY IS EXPRESSED OR IMPLIED.  USE AT YOUR OWN RISK.
+"""
+__all__ = ['run_main', 'get_include']
+
+import sys
+import subprocess
+import os
+import warnings
+
+from numpy.exceptions import VisibleDeprecationWarning
+from . import f2py2e
+from . import diagnose
+
+run_main = f2py2e.run_main
+main = f2py2e.main
+
+
+def get_include():
+    """
+    Return the directory that contains the ``fortranobject.c`` and ``.h`` files.
+
+    .. note::
+
+        This function is not needed when building an extension with
+        `numpy.distutils` directly from ``.f`` and/or ``.pyf`` files
+        in one go.
+
+    Python extension modules built with f2py-generated code need to use
+    ``fortranobject.c`` as a source file, and include the ``fortranobject.h``
+    header. This function can be used to obtain the directory containing
+    both of these files.
+
+    Returns
+    -------
+    include_path : str
+        Absolute path to the directory containing ``fortranobject.c`` and
+        ``fortranobject.h``.
+
+    Notes
+    -----
+    .. versionadded:: 1.21.1
+
+    Unless the build system you are using has specific support for f2py,
+    building a Python extension using a ``.pyf`` signature file is a two-step
+    process. For a module ``mymod``:
+
+    * Step 1: run ``python -m numpy.f2py mymod.pyf --quiet``. This
+      generates ``mymodmodule.c`` and (if needed)
+      ``mymod-f2pywrappers.f`` files next to ``mymod.pyf``.
+    * Step 2: build your Python extension module. This requires the
+      following source files:
+
+      * ``mymodmodule.c``
+      * ``mymod-f2pywrappers.f`` (if it was generated in Step 1)
+      * ``fortranobject.c``
+
+    See Also
+    --------
+    numpy.get_include : function that returns the numpy include directory
+
+    """
+    return os.path.join(os.path.dirname(__file__), 'src')
+
+
+def __getattr__(attr):
+
+    # Avoid importing things that aren't needed for building
+    # which might import the main numpy module
+    if attr == "test":
+        from numpy._pytesttester import PytestTester
+        test = PytestTester(__name__)
+        return test
+
+    else:
+        raise AttributeError("module {!r} has no attribute "
+                              "{!r}".format(__name__, attr))
+
+
+def __dir__():
+    return list(globals().keys() | {"test"})
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/__init__.pyi b/venv/lib/python3.12/site-packages/numpy/f2py/__init__.pyi
new file mode 100644
index 00000000..81b6a24f
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/__init__.pyi
@@ -0,0 +1,42 @@
+import os
+import subprocess
+from collections.abc import Iterable
+from typing import Literal as L, Any, overload, TypedDict
+
+from numpy._pytesttester import PytestTester
+
+class _F2PyDictBase(TypedDict):
+    csrc: list[str]
+    h: list[str]
+
+class _F2PyDict(_F2PyDictBase, total=False):
+    fsrc: list[str]
+    ltx: list[str]
+
+__all__: list[str]
+test: PytestTester
+
+def run_main(comline_list: Iterable[str]) -> dict[str, _F2PyDict]: ...
+
+@overload
+def compile(  # type: ignore[misc]
+    source: str | bytes,
+    modulename: str = ...,
+    extra_args: str | list[str] = ...,
+    verbose: bool = ...,
+    source_fn: None | str | bytes | os.PathLike[Any] = ...,
+    extension: L[".f", ".f90"] = ...,
+    full_output: L[False] = ...,
+) -> int: ...
+@overload
+def compile(
+    source: str | bytes,
+    modulename: str = ...,
+    extra_args: str | list[str] = ...,
+    verbose: bool = ...,
+    source_fn: None | str | bytes | os.PathLike[Any] = ...,
+    extension: L[".f", ".f90"] = ...,
+    full_output: L[True] = ...,
+) -> subprocess.CompletedProcess[bytes]: ...
+
+def get_include() -> str: ...
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/__main__.py b/venv/lib/python3.12/site-packages/numpy/f2py/__main__.py
new file mode 100644
index 00000000..936a753a
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/__main__.py
@@ -0,0 +1,5 @@
+# See:
+# https://web.archive.org/web/20140822061353/http://cens.ioc.ee/projects/f2py2e
+from numpy.f2py.f2py2e import main
+
+main()
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/f2py/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 00000000..ee8e327c
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/f2py/__pycache__/__init__.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/__pycache__/__main__.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/f2py/__pycache__/__main__.cpython-312.pyc
new file mode 100644
index 00000000..fcfc2799
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/f2py/__pycache__/__main__.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/__pycache__/__version__.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/f2py/__pycache__/__version__.cpython-312.pyc
new file mode 100644
index 00000000..8b00b486
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/f2py/__pycache__/__version__.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/__pycache__/_isocbind.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/f2py/__pycache__/_isocbind.cpython-312.pyc
new file mode 100644
index 00000000..b2ead472
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/f2py/__pycache__/_isocbind.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/__pycache__/_src_pyf.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/f2py/__pycache__/_src_pyf.cpython-312.pyc
new file mode 100644
index 00000000..2ab2ce8b
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/f2py/__pycache__/_src_pyf.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/__pycache__/auxfuncs.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/f2py/__pycache__/auxfuncs.cpython-312.pyc
new file mode 100644
index 00000000..c0693dad
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/f2py/__pycache__/auxfuncs.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/__pycache__/capi_maps.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/f2py/__pycache__/capi_maps.cpython-312.pyc
new file mode 100644
index 00000000..1e1255e2
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/f2py/__pycache__/capi_maps.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/__pycache__/cb_rules.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/f2py/__pycache__/cb_rules.cpython-312.pyc
new file mode 100644
index 00000000..aa47ce76
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/f2py/__pycache__/cb_rules.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/__pycache__/cfuncs.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/f2py/__pycache__/cfuncs.cpython-312.pyc
new file mode 100644
index 00000000..081c8049
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/f2py/__pycache__/cfuncs.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/__pycache__/common_rules.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/f2py/__pycache__/common_rules.cpython-312.pyc
new file mode 100644
index 00000000..ca7e24a2
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/f2py/__pycache__/common_rules.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/__pycache__/crackfortran.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/f2py/__pycache__/crackfortran.cpython-312.pyc
new file mode 100644
index 00000000..f0f4ff5f
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/f2py/__pycache__/crackfortran.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/__pycache__/diagnose.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/f2py/__pycache__/diagnose.cpython-312.pyc
new file mode 100644
index 00000000..6104dbfe
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/f2py/__pycache__/diagnose.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/__pycache__/f2py2e.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/f2py/__pycache__/f2py2e.cpython-312.pyc
new file mode 100644
index 00000000..aa796d76
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/f2py/__pycache__/f2py2e.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/__pycache__/f90mod_rules.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/f2py/__pycache__/f90mod_rules.cpython-312.pyc
new file mode 100644
index 00000000..04f4fc63
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/f2py/__pycache__/f90mod_rules.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/__pycache__/func2subr.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/f2py/__pycache__/func2subr.cpython-312.pyc
new file mode 100644
index 00000000..d60e220e
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/f2py/__pycache__/func2subr.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/__pycache__/rules.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/f2py/__pycache__/rules.cpython-312.pyc
new file mode 100644
index 00000000..7cd9ff40
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/f2py/__pycache__/rules.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/__pycache__/symbolic.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/f2py/__pycache__/symbolic.cpython-312.pyc
new file mode 100644
index 00000000..e831c892
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/f2py/__pycache__/symbolic.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/__pycache__/use_rules.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/f2py/__pycache__/use_rules.cpython-312.pyc
new file mode 100644
index 00000000..d1e8eb29
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/f2py/__pycache__/use_rules.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/__version__.py b/venv/lib/python3.12/site-packages/numpy/f2py/__version__.py
new file mode 100644
index 00000000..e20d7c1d
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/__version__.py
@@ -0,0 +1 @@
+from numpy.version import version
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/_backends/__init__.py b/venv/lib/python3.12/site-packages/numpy/f2py/_backends/__init__.py
new file mode 100644
index 00000000..e91393c1
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/_backends/__init__.py
@@ -0,0 +1,9 @@
+def f2py_build_generator(name):
+    if name == "meson":
+        from ._meson import MesonBackend
+        return MesonBackend
+    elif name == "distutils":
+        from ._distutils import DistutilsBackend
+        return DistutilsBackend
+    else:
+        raise ValueError(f"Unknown backend: {name}")
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/_backends/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/f2py/_backends/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 00000000..98875700
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/f2py/_backends/__pycache__/__init__.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/_backends/__pycache__/_backend.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/f2py/_backends/__pycache__/_backend.cpython-312.pyc
new file mode 100644
index 00000000..66d814d7
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/f2py/_backends/__pycache__/_backend.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/_backends/__pycache__/_distutils.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/f2py/_backends/__pycache__/_distutils.cpython-312.pyc
new file mode 100644
index 00000000..c5391acf
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/f2py/_backends/__pycache__/_distutils.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/_backends/__pycache__/_meson.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/f2py/_backends/__pycache__/_meson.cpython-312.pyc
new file mode 100644
index 00000000..010d86b6
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/f2py/_backends/__pycache__/_meson.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/_backends/_backend.py b/venv/lib/python3.12/site-packages/numpy/f2py/_backends/_backend.py
new file mode 100644
index 00000000..a7d43d25
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/_backends/_backend.py
@@ -0,0 +1,46 @@
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+
+
+class Backend(ABC):
+    def __init__(
+        self,
+        modulename,
+        sources,
+        extra_objects,
+        build_dir,
+        include_dirs,
+        library_dirs,
+        libraries,
+        define_macros,
+        undef_macros,
+        f2py_flags,
+        sysinfo_flags,
+        fc_flags,
+        flib_flags,
+        setup_flags,
+        remove_build_dir,
+        extra_dat,
+    ):
+        self.modulename = modulename
+        self.sources = sources
+        self.extra_objects = extra_objects
+        self.build_dir = build_dir
+        self.include_dirs = include_dirs
+        self.library_dirs = library_dirs
+        self.libraries = libraries
+        self.define_macros = define_macros
+        self.undef_macros = undef_macros
+        self.f2py_flags = f2py_flags
+        self.sysinfo_flags = sysinfo_flags
+        self.fc_flags = fc_flags
+        self.flib_flags = flib_flags
+        self.setup_flags = setup_flags
+        self.remove_build_dir = remove_build_dir
+        self.extra_dat = extra_dat
+
+    @abstractmethod
+    def compile(self) -> None:
+        """Compile the wrapper."""
+        pass
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/_backends/_distutils.py b/venv/lib/python3.12/site-packages/numpy/f2py/_backends/_distutils.py
new file mode 100644
index 00000000..f2436f86
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/_backends/_distutils.py
@@ -0,0 +1,75 @@
+from ._backend import Backend
+
+from numpy.distutils.core import setup, Extension
+from numpy.distutils.system_info import get_info
+from numpy.distutils.misc_util import dict_append
+from numpy.exceptions import VisibleDeprecationWarning
+import os
+import sys
+import shutil
+import warnings
+
+
+class DistutilsBackend(Backend):
+    def __init__(sef, *args, **kwargs):
+        warnings.warn(
+            "\ndistutils has been deprecated since NumPy 1.26.x\n"
+            "Use the Meson backend instead, or generate wrappers"
+            " without -c and use a custom build script",
+            VisibleDeprecationWarning,
+            stacklevel=2,
+        )
+        super().__init__(*args, **kwargs)
+
+    def compile(self):
+        num_info = {}
+        if num_info:
+            self.include_dirs.extend(num_info.get("include_dirs", []))
+        ext_args = {
+            "name": self.modulename,
+            "sources": self.sources,
+            "include_dirs": self.include_dirs,
+            "library_dirs": self.library_dirs,
+            "libraries": self.libraries,
+            "define_macros": self.define_macros,
+            "undef_macros": self.undef_macros,
+            "extra_objects": self.extra_objects,
+            "f2py_options": self.f2py_flags,
+        }
+
+        if self.sysinfo_flags:
+            for n in self.sysinfo_flags:
+                i = get_info(n)
+                if not i:
+                    print(
+                        f"No {repr(n)} resources found"
+                        "in system (try `f2py --help-link`)"
+                    )
+                dict_append(ext_args, **i)
+
+        ext = Extension(**ext_args)
+
+        sys.argv = [sys.argv[0]] + self.setup_flags
+        sys.argv.extend(
+            [
+                "build",
+                "--build-temp",
+                self.build_dir,
+                "--build-base",
+                self.build_dir,
+                "--build-platlib",
+                ".",
+                "--disable-optimization",
+            ]
+        )
+
+        if self.fc_flags:
+            sys.argv.extend(["config_fc"] + self.fc_flags)
+        if self.flib_flags:
+            sys.argv.extend(["build_ext"] + self.flib_flags)
+
+        setup(ext_modules=[ext])
+
+        if self.remove_build_dir and os.path.exists(self.build_dir):
+            print(f"Removing build directory {self.build_dir}")
+            shutil.rmtree(self.build_dir)
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/_backends/_meson.py b/venv/lib/python3.12/site-packages/numpy/f2py/_backends/_meson.py
new file mode 100644
index 00000000..b438ed22
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/_backends/_meson.py
@@ -0,0 +1,234 @@
+from __future__ import annotations
+
+import os
+import errno
+import shutil
+import subprocess
+import sys
+import re
+from pathlib import Path
+
+from ._backend import Backend
+from string import Template
+from itertools import chain
+
+import warnings
+
+
+class MesonTemplate:
+    """Template meson build file generation class."""
+
+    def __init__(
+        self,
+        modulename: str,
+        sources: list[Path],
+        deps: list[str],
+        libraries: list[str],
+        library_dirs: list[Path],
+        include_dirs: list[Path],
+        object_files: list[Path],
+        linker_args: list[str],
+        fortran_args: list[str],
+        build_type: str,
+        python_exe: str,
+    ):
+        self.modulename = modulename
+        self.build_template_path = (
+            Path(__file__).parent.absolute() / "meson.build.template"
+        )
+        self.sources = sources
+        self.deps = deps
+        self.libraries = libraries
+        self.library_dirs = library_dirs
+        if include_dirs is not None:
+            self.include_dirs = include_dirs
+        else:
+            self.include_dirs = []
+        self.substitutions = {}
+        self.objects = object_files
+        # Convert args to '' wrapped variant for meson
+        self.fortran_args = [
+            f"'{x}'" if not (x.startswith("'") and x.endswith("'")) else x
+            for x in fortran_args
+        ]
+        self.pipeline = [
+            self.initialize_template,
+            self.sources_substitution,
+            self.deps_substitution,
+            self.include_substitution,
+            self.libraries_substitution,
+            self.fortran_args_substitution,
+        ]
+        self.build_type = build_type
+        self.python_exe = python_exe
+        self.indent = " " * 21
+
+    def meson_build_template(self) -> str:
+        if not self.build_template_path.is_file():
+            raise FileNotFoundError(
+                errno.ENOENT,
+                "Meson build template"
+                f" {self.build_template_path.absolute()}"
+                " does not exist.",
+            )
+        return self.build_template_path.read_text()
+
+    def initialize_template(self) -> None:
+        self.substitutions["modulename"] = self.modulename
+        self.substitutions["buildtype"] = self.build_type
+        self.substitutions["python"] = self.python_exe
+
+    def sources_substitution(self) -> None:
+        self.substitutions["source_list"] = ",\n".join(
+            [f"{self.indent}'''{source}'''," for source in self.sources]
+        )
+
+    def deps_substitution(self) -> None:
+        self.substitutions["dep_list"] = f",\n{self.indent}".join(
+            [f"{self.indent}dependency('{dep}')," for dep in self.deps]
+        )
+
+    def libraries_substitution(self) -> None:
+        self.substitutions["lib_dir_declarations"] = "\n".join(
+            [
+                f"lib_dir_{i} = declare_dependency(link_args : ['''-L{lib_dir}'''])"
+                for i, lib_dir in enumerate(self.library_dirs)
+            ]
+        )
+
+        self.substitutions["lib_declarations"] = "\n".join(
+            [
+                f"{lib.replace('.','_')} = declare_dependency(link_args : ['-l{lib}'])"
+                for lib in self.libraries
+            ]
+        )
+
+        self.substitutions["lib_list"] = f"\n{self.indent}".join(
+            [f"{self.indent}{lib.replace('.','_')}," for lib in self.libraries]
+        )
+        self.substitutions["lib_dir_list"] = f"\n{self.indent}".join(
+            [f"{self.indent}lib_dir_{i}," for i in range(len(self.library_dirs))]
+        )
+
+    def include_substitution(self) -> None:
+        self.substitutions["inc_list"] = f",\n{self.indent}".join(
+            [f"{self.indent}'''{inc}'''," for inc in self.include_dirs]
+        )
+
+    def fortran_args_substitution(self) -> None:
+        if self.fortran_args:
+            self.substitutions["fortran_args"] = (
+                f"{self.indent}fortran_args: [{', '.join([arg for arg in self.fortran_args])}],"
+            )
+        else:
+            self.substitutions["fortran_args"] = ""
+
+    def generate_meson_build(self):
+        for node in self.pipeline:
+            node()
+        template = Template(self.meson_build_template())
+        meson_build = template.substitute(self.substitutions)
+        meson_build = re.sub(r",,", ",", meson_build)
+        return meson_build
+
+
+class MesonBackend(Backend):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.dependencies = self.extra_dat.get("dependencies", [])
+        self.meson_build_dir = "bbdir"
+        self.build_type = (
+            "debug" if any("debug" in flag for flag in self.fc_flags) else "release"
+        )
+        self.fc_flags = _get_flags(self.fc_flags)
+
+    def _move_exec_to_root(self, build_dir: Path):
+        walk_dir = Path(build_dir) / self.meson_build_dir
+        path_objects = chain(
+            walk_dir.glob(f"{self.modulename}*.so"),
+            walk_dir.glob(f"{self.modulename}*.pyd"),
+        )
+        # Same behavior as distutils
+        # https://github.com/numpy/numpy/issues/24874#issuecomment-1835632293
+        for path_object in path_objects:
+            dest_path = Path.cwd() / path_object.name
+            if dest_path.exists():
+                dest_path.unlink()
+            shutil.copy2(path_object, dest_path)
+            os.remove(path_object)
+
+    def write_meson_build(self, build_dir: Path) -> None:
+        """Writes the meson build file at specified location"""
+        meson_template = MesonTemplate(
+            self.modulename,
+            self.sources,
+            self.dependencies,
+            self.libraries,
+            self.library_dirs,
+            self.include_dirs,
+            self.extra_objects,
+            self.flib_flags,
+            self.fc_flags,
+            self.build_type,
+            sys.executable,
+        )
+        src = meson_template.generate_meson_build()
+        Path(build_dir).mkdir(parents=True, exist_ok=True)
+        meson_build_file = Path(build_dir) / "meson.build"
+        meson_build_file.write_text(src)
+        return meson_build_file
+
+    def _run_subprocess_command(self, command, cwd):
+        subprocess.run(command, cwd=cwd, check=True)
+
+    def run_meson(self, build_dir: Path):
+        setup_command = ["meson", "setup", self.meson_build_dir]
+        self._run_subprocess_command(setup_command, build_dir)
+        compile_command = ["meson", "compile", "-C", self.meson_build_dir]
+        self._run_subprocess_command(compile_command, build_dir)
+
+    def compile(self) -> None:
+        self.sources = _prepare_sources(self.modulename, self.sources, self.build_dir)
+        self.write_meson_build(self.build_dir)
+        self.run_meson(self.build_dir)
+        self._move_exec_to_root(self.build_dir)
+
+
+def _prepare_sources(mname, sources, bdir):
+    extended_sources = sources.copy()
+    Path(bdir).mkdir(parents=True, exist_ok=True)
+    # Copy sources
+    for source in sources:
+        if Path(source).exists() and Path(source).is_file():
+            shutil.copy(source, bdir)
+    generated_sources = [
+        Path(f"{mname}module.c"),
+        Path(f"{mname}-f2pywrappers2.f90"),
+        Path(f"{mname}-f2pywrappers.f"),
+    ]
+    bdir = Path(bdir)
+    for generated_source in generated_sources:
+        if generated_source.exists():
+            shutil.copy(generated_source, bdir / generated_source.name)
+            extended_sources.append(generated_source.name)
+            generated_source.unlink()
+    extended_sources = [
+        Path(source).name
+        for source in extended_sources
+        if not Path(source).suffix == ".pyf"
+    ]
+    return extended_sources
+
+
+def _get_flags(fc_flags):
+    flag_values = []
+    flag_pattern = re.compile(r"--f(77|90)flags=(.*)")
+    for flag in fc_flags:
+        match_result = flag_pattern.match(flag)
+        if match_result:
+            values = match_result.group(2).strip().split()
+            values = [val.strip("'\"") for val in values]
+            flag_values.extend(values)
+    # Hacky way to preserve order of flags
+    unique_flags = list(dict.fromkeys(flag_values))
+    return unique_flags
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/_backends/meson.build.template b/venv/lib/python3.12/site-packages/numpy/f2py/_backends/meson.build.template
new file mode 100644
index 00000000..fdcc1b17
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/_backends/meson.build.template
@@ -0,0 +1,55 @@
+project('${modulename}',
+        ['c', 'fortran'],
+        version : '0.1',
+        meson_version: '>= 1.1.0',
+        default_options : [
+                            'warning_level=1',
+                            'buildtype=${buildtype}'
+                          ])
+fc = meson.get_compiler('fortran')
+
+py = import('python').find_installation('''${python}''', pure: false)
+py_dep = py.dependency()
+
+incdir_numpy = run_command(py,
+  ['-c', 'import os; os.chdir(".."); import numpy; print(numpy.get_include())'],
+  check : true
+).stdout().strip()
+
+incdir_f2py = run_command(py,
+    ['-c', 'import os; os.chdir(".."); import numpy.f2py; print(numpy.f2py.get_include())'],
+    check : true
+).stdout().strip()
+
+inc_np = include_directories(incdir_numpy)
+np_dep = declare_dependency(include_directories: inc_np)
+
+incdir_f2py = incdir_numpy / '..' / '..' / 'f2py' / 'src'
+inc_f2py = include_directories(incdir_f2py)
+fortranobject_c = incdir_f2py / 'fortranobject.c'
+
+inc_np = include_directories(incdir_numpy, incdir_f2py)
+# gh-25000
+quadmath_dep = fc.find_library('quadmath', required: false)
+
+${lib_declarations}
+${lib_dir_declarations}
+
+py.extension_module('${modulename}',
+                     [
+${source_list},
+                     fortranobject_c
+                     ],
+                     include_directories: [
+                     inc_np,
+${inc_list}
+                     ],
+                     dependencies : [
+                     py_dep,
+                     quadmath_dep,
+${dep_list}
+${lib_list}
+${lib_dir_list}
+                     ],
+${fortran_args}
+                     install : true)
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/_isocbind.py b/venv/lib/python3.12/site-packages/numpy/f2py/_isocbind.py
new file mode 100644
index 00000000..3043c5d9
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/_isocbind.py
@@ -0,0 +1,62 @@
+"""
+ISO_C_BINDING maps for f2py2e.
+Only required declarations/macros/functions will be used.
+
+Copyright 1999 -- 2011 Pearu Peterson all rights reserved.
+Copyright 2011 -- present NumPy Developers.
+Permission to use, modify, and distribute this software is given under the
+terms of the NumPy License.
+
+NO WARRANTY IS EXPRESSED OR IMPLIED.  USE AT YOUR OWN RISK.
+"""
+# These map to keys in c2py_map, via forced casting for now, see gh-25229
+iso_c_binding_map = {
+    'integer': {
+        'c_int': 'int',
+        'c_short': 'short',  # 'short' <=> 'int' for now
+        'c_long': 'long',  # 'long' <=> 'int' for now
+        'c_long_long': 'long_long',
+        'c_signed_char': 'signed_char',
+        'c_size_t': 'unsigned',  # size_t <=> 'unsigned' for now
+        'c_int8_t': 'signed_char',  # int8_t <=> 'signed_char' for now
+        'c_int16_t': 'short',  # int16_t <=> 'short' for now
+        'c_int32_t': 'int',  # int32_t <=> 'int' for now
+        'c_int64_t': 'long_long',
+        'c_int_least8_t': 'signed_char',  # int_least8_t <=> 'signed_char' for now
+        'c_int_least16_t': 'short',  # int_least16_t <=> 'short' for now
+        'c_int_least32_t': 'int',  # int_least32_t <=> 'int' for now
+        'c_int_least64_t': 'long_long',
+        'c_int_fast8_t': 'signed_char',  # int_fast8_t <=> 'signed_char' for now
+        'c_int_fast16_t': 'short',  # int_fast16_t <=> 'short' for now
+        'c_int_fast32_t': 'int',  # int_fast32_t <=> 'int' for now
+        'c_int_fast64_t': 'long_long',
+        'c_intmax_t': 'long_long',  # intmax_t <=> 'long_long' for now
+        'c_intptr_t': 'long',  # intptr_t <=> 'long' for now
+        'c_ptrdiff_t': 'long',  # ptrdiff_t <=> 'long' for now
+    },
+    'real': {
+        'c_float': 'float',
+        'c_double': 'double',
+        'c_long_double': 'long_double'
+    },
+    'complex': {
+        'c_float_complex': 'complex_float',
+        'c_double_complex': 'complex_double',
+        'c_long_double_complex': 'complex_long_double'
+    },
+    'logical': {
+        'c_bool': 'unsigned_char'  # _Bool <=> 'unsigned_char' for now
+    },
+    'character': {
+        'c_char': 'char'
+    }
+}
+
+# TODO: See gh-25229
+isoc_c2pycode_map = {}
+iso_c2py_map = {}
+
+isoc_kindmap = {}
+for fortran_type, c_type_dict in iso_c_binding_map.items():
+    for c_type in c_type_dict.keys():
+        isoc_kindmap[c_type] = fortran_type
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/_src_pyf.py b/venv/lib/python3.12/site-packages/numpy/f2py/_src_pyf.py
new file mode 100644
index 00000000..6247b95b
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/_src_pyf.py
@@ -0,0 +1,239 @@
+import re
+
+# START OF CODE VENDORED FROM `numpy.distutils.from_template`
+#############################################################
+"""
+process_file(filename)
+
+  takes templated file .xxx.src and produces .xxx file where .xxx
+  is .pyf .f90 or .f using the following template rules:
+
+  '<..>' denotes a template.
+
+  All function and subroutine blocks in a source file with names that
+  contain '<..>' will be replicated according to the rules in '<..>'.
+
+  The number of comma-separated words in '<..>' will determine the number of
+  replicates.
+
+  '<..>' may have two different forms, named and short. For example,
+
+  named:
+    where anywhere inside a block '
' will be replaced with
+   'd', 's', 'z', and 'c' for each replicate of the block.
+
+   <_c>  is already defined: <_c=s,d,c,z>
+   <_t>  is already defined: <_t=real,double precision,complex,double complex>
+
+  short:
+   , a short form of the named, useful when no 
 appears inside
+   a block.
+
+  In general, '<..>' contains a comma separated list of arbitrary
+  expressions. If these expression must contain a comma|leftarrow|rightarrow,
+  then prepend the comma|leftarrow|rightarrow with a backslash.
+
+  If an expression matches '\\' then it will be replaced
+  by -th expression.
+
+  Note that all '<..>' forms in a block must have the same number of
+  comma-separated entries.
+
+ Predefined named template rules:
+  
+  
+  
+  
+  
+"""
+
+routine_start_re = re.compile(r'(\n|\A)((     (\$|\*))|)\s*(subroutine|function)\b', re.I)
+routine_end_re = re.compile(r'\n\s*end\s*(subroutine|function)\b.*(\n|\Z)', re.I)
+function_start_re = re.compile(r'\n     (\$|\*)\s*function\b', re.I)
+
+def parse_structure(astr):
+    """ Return a list of tuples for each function or subroutine each
+    tuple is the start and end of a subroutine or function to be
+    expanded.
+    """
+
+    spanlist = []
+    ind = 0
+    while True:
+        m = routine_start_re.search(astr, ind)
+        if m is None:
+            break
+        start = m.start()
+        if function_start_re.match(astr, start, m.end()):
+            while True:
+                i = astr.rfind('\n', ind, start)
+                if i==-1:
+                    break
+                start = i
+                if astr[i:i+7]!='\n     $':
+                    break
+        start += 1
+        m = routine_end_re.search(astr, m.end())
+        ind = end = m and m.end()-1 or len(astr)
+        spanlist.append((start, end))
+    return spanlist
+
+template_re = re.compile(r"<\s*(\w[\w\d]*)\s*>")
+named_re = re.compile(r"<\s*(\w[\w\d]*)\s*=\s*(.*?)\s*>")
+list_re = re.compile(r"<\s*((.*?))\s*>")
+
+def find_repl_patterns(astr):
+    reps = named_re.findall(astr)
+    names = {}
+    for rep in reps:
+        name = rep[0].strip() or unique_key(names)
+        repl = rep[1].replace(r'\,', '@comma@')
+        thelist = conv(repl)
+        names[name] = thelist
+    return names
+
+def find_and_remove_repl_patterns(astr):
+    names = find_repl_patterns(astr)
+    astr = re.subn(named_re, '', astr)[0]
+    return astr, names
+
+item_re = re.compile(r"\A\\(?P\d+)\Z")
+def conv(astr):
+    b = astr.split(',')
+    l = [x.strip() for x in b]
+    for i in range(len(l)):
+        m = item_re.match(l[i])
+        if m:
+            j = int(m.group('index'))
+            l[i] = l[j]
+    return ','.join(l)
+
+def unique_key(adict):
+    """ Obtain a unique key given a dictionary."""
+    allkeys = list(adict.keys())
+    done = False
+    n = 1
+    while not done:
+        newkey = '__l%s' % (n)
+        if newkey in allkeys:
+            n += 1
+        else:
+            done = True
+    return newkey
+
+
+template_name_re = re.compile(r'\A\s*(\w[\w\d]*)\s*\Z')
+def expand_sub(substr, names):
+    substr = substr.replace(r'\>', '@rightarrow@')
+    substr = substr.replace(r'\<', '@leftarrow@')
+    lnames = find_repl_patterns(substr)
+    substr = named_re.sub(r"<\1>", substr)  # get rid of definition templates
+
+    def listrepl(mobj):
+        thelist = conv(mobj.group(1).replace(r'\,', '@comma@'))
+        if template_name_re.match(thelist):
+            return "<%s>" % (thelist)
+        name = None
+        for key in lnames.keys():    # see if list is already in dictionary
+            if lnames[key] == thelist:
+                name = key
+        if name is None:      # this list is not in the dictionary yet
+            name = unique_key(lnames)
+            lnames[name] = thelist
+        return "<%s>" % name
+
+    substr = list_re.sub(listrepl, substr) # convert all lists to named templates
+                                           # newnames are constructed as needed
+
+    numsubs = None
+    base_rule = None
+    rules = {}
+    for r in template_re.findall(substr):
+        if r not in rules:
+            thelist = lnames.get(r, names.get(r, None))
+            if thelist is None:
+                raise ValueError('No replicates found for <%s>' % (r))
+            if r not in names and not thelist.startswith('_'):
+                names[r] = thelist
+            rule = [i.replace('@comma@', ',') for i in thelist.split(',')]
+            num = len(rule)
+
+            if numsubs is None:
+                numsubs = num
+                rules[r] = rule
+                base_rule = r
+            elif num == numsubs:
+                rules[r] = rule
+            else:
+                print("Mismatch in number of replacements (base <{}={}>) "
+                      "for <{}={}>. Ignoring.".format(base_rule, ','.join(rules[base_rule]), r, thelist))
+    if not rules:
+        return substr
+
+    def namerepl(mobj):
+        name = mobj.group(1)
+        return rules.get(name, (k+1)*[name])[k]
+
+    newstr = ''
+    for k in range(numsubs):
+        newstr += template_re.sub(namerepl, substr) + '\n\n'
+
+    newstr = newstr.replace('@rightarrow@', '>')
+    newstr = newstr.replace('@leftarrow@', '<')
+    return newstr
+
+def process_str(allstr):
+    newstr = allstr
+    writestr = ''
+
+    struct = parse_structure(newstr)
+
+    oldend = 0
+    names = {}
+    names.update(_special_names)
+    for sub in struct:
+        cleanedstr, defs = find_and_remove_repl_patterns(newstr[oldend:sub[0]])
+        writestr += cleanedstr
+        names.update(defs)
+        writestr += expand_sub(newstr[sub[0]:sub[1]], names)
+        oldend =  sub[1]
+    writestr += newstr[oldend:]
+
+    return writestr
+
+include_src_re = re.compile(r"(\n|\A)\s*include\s*['\"](?P[\w\d./\\]+\.src)['\"]", re.I)
+
+def resolve_includes(source):
+    d = os.path.dirname(source)
+    with open(source) as fid:
+        lines = []
+        for line in fid:
+            m = include_src_re.match(line)
+            if m:
+                fn = m.group('name')
+                if not os.path.isabs(fn):
+                    fn = os.path.join(d, fn)
+                if os.path.isfile(fn):
+                    lines.extend(resolve_includes(fn))
+                else:
+                    lines.append(line)
+            else:
+                lines.append(line)
+    return lines
+
+def process_file(source):
+    lines = resolve_includes(source)
+    return process_str(''.join(lines))
+
+_special_names = find_repl_patterns('''
+<_c=s,d,c,z>
+<_t=real,double precision,complex,double complex>
+
+
+
+
+
+''')
+
+# END OF CODE VENDORED FROM `numpy.distutils.from_template`
+###########################################################
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/auxfuncs.py b/venv/lib/python3.12/site-packages/numpy/f2py/auxfuncs.py
new file mode 100644
index 00000000..88a9ff55
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/auxfuncs.py
@@ -0,0 +1,996 @@
+"""
+Auxiliary functions for f2py2e.
+
+Copyright 1999 -- 2011 Pearu Peterson all rights reserved.
+Copyright 2011 -- present NumPy Developers.
+Permission to use, modify, and distribute this software is given under the
+terms of the NumPy (BSD style) LICENSE.
+
+NO WARRANTY IS EXPRESSED OR IMPLIED.  USE AT YOUR OWN RISK.
+"""
+import pprint
+import sys
+import re
+import types
+from functools import reduce
+from copy import deepcopy
+
+from . import __version__
+from . import cfuncs
+from .cfuncs import errmess
+
+__all__ = [
+    'applyrules', 'debugcapi', 'dictappend', 'errmess', 'gentitle',
+    'getargs2', 'getcallprotoargument', 'getcallstatement',
+    'getfortranname', 'getpymethoddef', 'getrestdoc', 'getusercode',
+    'getusercode1', 'getdimension', 'hasbody', 'hascallstatement', 'hascommon',
+    'hasexternals', 'hasinitvalue', 'hasnote', 'hasresultnote',
+    'isallocatable', 'isarray', 'isarrayofstrings',
+    'ischaracter', 'ischaracterarray', 'ischaracter_or_characterarray',
+    'iscomplex',
+    'iscomplexarray', 'iscomplexfunction', 'iscomplexfunction_warn',
+    'isdouble', 'isdummyroutine', 'isexternal', 'isfunction',
+    'isfunction_wrap', 'isint1', 'isint1array', 'isinteger', 'isintent_aux',
+    'isintent_c', 'isintent_callback', 'isintent_copy', 'isintent_dict',
+    'isintent_hide', 'isintent_in', 'isintent_inout', 'isintent_inplace',
+    'isintent_nothide', 'isintent_out', 'isintent_overwrite', 'islogical',
+    'islogicalfunction', 'islong_complex', 'islong_double',
+    'islong_doublefunction', 'islong_long', 'islong_longfunction',
+    'ismodule', 'ismoduleroutine', 'isoptional', 'isprivate', 'isvariable',
+    'isrequired', 'isroutine', 'isscalar', 'issigned_long_longarray',
+    'isstring', 'isstringarray', 'isstring_or_stringarray', 'isstringfunction',
+    'issubroutine', 'get_f2py_modulename', 'issubroutine_wrap', 'isthreadsafe',
+    'isunsigned', 'isunsigned_char', 'isunsigned_chararray',
+    'isunsigned_long_long', 'isunsigned_long_longarray', 'isunsigned_short',
+    'isunsigned_shortarray', 'l_and', 'l_not', 'l_or', 'outmess', 'replace',
+    'show', 'stripcomma', 'throw_error', 'isattr_value', 'getuseblocks',
+    'process_f2cmap_dict'
+]
+
+
+f2py_version = __version__.version
+
+
+show = pprint.pprint
+
+options = {}
+debugoptions = []
+wrapfuncs = 1
+
+
+def outmess(t):
+    if options.get('verbose', 1):
+        sys.stdout.write(t)
+
+
+def debugcapi(var):
+    return 'capi' in debugoptions
+
+
+def _ischaracter(var):
+    return 'typespec' in var and var['typespec'] == 'character' and \
+           not isexternal(var)
+
+
+def _isstring(var):
+    return 'typespec' in var and var['typespec'] == 'character' and \
+           not isexternal(var)
+
+
+def ischaracter_or_characterarray(var):
+    return _ischaracter(var) and 'charselector' not in var
+
+
+def ischaracter(var):
+    return ischaracter_or_characterarray(var) and not isarray(var)
+
+
+def ischaracterarray(var):
+    return ischaracter_or_characterarray(var) and isarray(var)
+
+
+def isstring_or_stringarray(var):
+    return _ischaracter(var) and 'charselector' in var
+
+
+def isstring(var):
+    return isstring_or_stringarray(var) and not isarray(var)
+
+
+def isstringarray(var):
+    return isstring_or_stringarray(var) and isarray(var)
+
+
+def isarrayofstrings(var):  # obsolete?
+    # leaving out '*' for now so that `character*(*) a(m)` and `character
+    # a(m,*)` are treated differently. Luckily `character**` is illegal.
+    return isstringarray(var) and var['dimension'][-1] == '(*)'
+
+
+def isarray(var):
+    return 'dimension' in var and not isexternal(var)
+
+
+def isscalar(var):
+    return not (isarray(var) or isstring(var) or isexternal(var))
+
+
+def iscomplex(var):
+    return isscalar(var) and \
+           var.get('typespec') in ['complex', 'double complex']
+
+
+def islogical(var):
+    return isscalar(var) and var.get('typespec') == 'logical'
+
+
+def isinteger(var):
+    return isscalar(var) and var.get('typespec') == 'integer'
+
+
+def isreal(var):
+    return isscalar(var) and var.get('typespec') == 'real'
+
+
+def get_kind(var):
+    try:
+        return var['kindselector']['*']
+    except KeyError:
+        try:
+            return var['kindselector']['kind']
+        except KeyError:
+            pass
+
+
+def isint1(var):
+    return var.get('typespec') == 'integer' \
+        and get_kind(var) == '1' and not isarray(var)
+
+
+def islong_long(var):
+    if not isscalar(var):
+        return 0
+    if var.get('typespec') not in ['integer', 'logical']:
+        return 0
+    return get_kind(var) == '8'
+
+
+def isunsigned_char(var):
+    if not isscalar(var):
+        return 0
+    if var.get('typespec') != 'integer':
+        return 0
+    return get_kind(var) == '-1'
+
+
+def isunsigned_short(var):
+    if not isscalar(var):
+        return 0
+    if var.get('typespec') != 'integer':
+        return 0
+    return get_kind(var) == '-2'
+
+
+def isunsigned(var):
+    if not isscalar(var):
+        return 0
+    if var.get('typespec') != 'integer':
+        return 0
+    return get_kind(var) == '-4'
+
+
+def isunsigned_long_long(var):
+    if not isscalar(var):
+        return 0
+    if var.get('typespec') != 'integer':
+        return 0
+    return get_kind(var) == '-8'
+
+
+def isdouble(var):
+    if not isscalar(var):
+        return 0
+    if not var.get('typespec') == 'real':
+        return 0
+    return get_kind(var) == '8'
+
+
+def islong_double(var):
+    if not isscalar(var):
+        return 0
+    if not var.get('typespec') == 'real':
+        return 0
+    return get_kind(var) == '16'
+
+
+def islong_complex(var):
+    if not iscomplex(var):
+        return 0
+    return get_kind(var) == '32'
+
+
+def iscomplexarray(var):
+    return isarray(var) and \
+           var.get('typespec') in ['complex', 'double complex']
+
+
+def isint1array(var):
+    return isarray(var) and var.get('typespec') == 'integer' \
+        and get_kind(var) == '1'
+
+
+def isunsigned_chararray(var):
+    return isarray(var) and var.get('typespec') in ['integer', 'logical']\
+        and get_kind(var) == '-1'
+
+
+def isunsigned_shortarray(var):
+    return isarray(var) and var.get('typespec') in ['integer', 'logical']\
+        and get_kind(var) == '-2'
+
+
+def isunsignedarray(var):
+    return isarray(var) and var.get('typespec') in ['integer', 'logical']\
+        and get_kind(var) == '-4'
+
+
+def isunsigned_long_longarray(var):
+    return isarray(var) and var.get('typespec') in ['integer', 'logical']\
+        and get_kind(var) == '-8'
+
+
+def issigned_chararray(var):
+    return isarray(var) and var.get('typespec') in ['integer', 'logical']\
+        and get_kind(var) == '1'
+
+
+def issigned_shortarray(var):
+    return isarray(var) and var.get('typespec') in ['integer', 'logical']\
+        and get_kind(var) == '2'
+
+
+def issigned_array(var):
+    return isarray(var) and var.get('typespec') in ['integer', 'logical']\
+        and get_kind(var) == '4'
+
+
+def issigned_long_longarray(var):
+    return isarray(var) and var.get('typespec') in ['integer', 'logical']\
+        and get_kind(var) == '8'
+
+
+def isallocatable(var):
+    return 'attrspec' in var and 'allocatable' in var['attrspec']
+
+
+def ismutable(var):
+    return not ('dimension' not in var or isstring(var))
+
+
+def ismoduleroutine(rout):
+    return 'modulename' in rout
+
+
+def ismodule(rout):
+    return 'block' in rout and 'module' == rout['block']
+
+
+def isfunction(rout):
+    return 'block' in rout and 'function' == rout['block']
+
+
+def isfunction_wrap(rout):
+    if isintent_c(rout):
+        return 0
+    return wrapfuncs and isfunction(rout) and (not isexternal(rout))
+
+
+def issubroutine(rout):
+    return 'block' in rout and 'subroutine' == rout['block']
+
+
+def issubroutine_wrap(rout):
+    if isintent_c(rout):
+        return 0
+    return issubroutine(rout) and hasassumedshape(rout)
+
+def isattr_value(var):
+    return 'value' in var.get('attrspec', [])
+
+
+def hasassumedshape(rout):
+    if rout.get('hasassumedshape'):
+        return True
+    for a in rout['args']:
+        for d in rout['vars'].get(a, {}).get('dimension', []):
+            if d == ':':
+                rout['hasassumedshape'] = True
+                return True
+    return False
+
+
+def requiresf90wrapper(rout):
+    return ismoduleroutine(rout) or hasassumedshape(rout)
+
+
+def isroutine(rout):
+    return isfunction(rout) or issubroutine(rout)
+
+
+def islogicalfunction(rout):
+    if not isfunction(rout):
+        return 0
+    if 'result' in rout:
+        a = rout['result']
+    else:
+        a = rout['name']
+    if a in rout['vars']:
+        return islogical(rout['vars'][a])
+    return 0
+
+
+def islong_longfunction(rout):
+    if not isfunction(rout):
+        return 0
+    if 'result' in rout:
+        a = rout['result']
+    else:
+        a = rout['name']
+    if a in rout['vars']:
+        return islong_long(rout['vars'][a])
+    return 0
+
+
+def islong_doublefunction(rout):
+    if not isfunction(rout):
+        return 0
+    if 'result' in rout:
+        a = rout['result']
+    else:
+        a = rout['name']
+    if a in rout['vars']:
+        return islong_double(rout['vars'][a])
+    return 0
+
+
+def iscomplexfunction(rout):
+    if not isfunction(rout):
+        return 0
+    if 'result' in rout:
+        a = rout['result']
+    else:
+        a = rout['name']
+    if a in rout['vars']:
+        return iscomplex(rout['vars'][a])
+    return 0
+
+
+def iscomplexfunction_warn(rout):
+    if iscomplexfunction(rout):
+        outmess("""\
+    **************************************************************
+        Warning: code with a function returning complex value
+        may not work correctly with your Fortran compiler.
+        When using GNU gcc/g77 compilers, codes should work
+        correctly for callbacks with:
+        f2py -c -DF2PY_CB_RETURNCOMPLEX
+    **************************************************************\n""")
+        return 1
+    return 0
+
+
+def isstringfunction(rout):
+    if not isfunction(rout):
+        return 0
+    if 'result' in rout:
+        a = rout['result']
+    else:
+        a = rout['name']
+    if a in rout['vars']:
+        return isstring(rout['vars'][a])
+    return 0
+
+
+def hasexternals(rout):
+    return 'externals' in rout and rout['externals']
+
+
+def isthreadsafe(rout):
+    return 'f2pyenhancements' in rout and \
+           'threadsafe' in rout['f2pyenhancements']
+
+
+def hasvariables(rout):
+    return 'vars' in rout and rout['vars']
+
+
+def isoptional(var):
+    return ('attrspec' in var and 'optional' in var['attrspec'] and
+            'required' not in var['attrspec']) and isintent_nothide(var)
+
+
+def isexternal(var):
+    return 'attrspec' in var and 'external' in var['attrspec']
+
+
+def getdimension(var):
+    dimpattern = r"\((.*?)\)"
+    if 'attrspec' in var.keys():
+        if any('dimension' in s for s in var['attrspec']):
+            return [re.findall(dimpattern, v) for v in var['attrspec']][0]
+
+
+def isrequired(var):
+    return not isoptional(var) and isintent_nothide(var)
+
+
+def isintent_in(var):
+    if 'intent' not in var:
+        return 1
+    if 'hide' in var['intent']:
+        return 0
+    if 'inplace' in var['intent']:
+        return 0
+    if 'in' in var['intent']:
+        return 1
+    if 'out' in var['intent']:
+        return 0
+    if 'inout' in var['intent']:
+        return 0
+    if 'outin' in var['intent']:
+        return 0
+    return 1
+
+
+def isintent_inout(var):
+    return ('intent' in var and ('inout' in var['intent'] or
+            'outin' in var['intent']) and 'in' not in var['intent'] and
+            'hide' not in var['intent'] and 'inplace' not in var['intent'])
+
+
+def isintent_out(var):
+    return 'out' in var.get('intent', [])
+
+
+def isintent_hide(var):
+    return ('intent' in var and ('hide' in var['intent'] or
+            ('out' in var['intent'] and 'in' not in var['intent'] and
+                (not l_or(isintent_inout, isintent_inplace)(var)))))
+
+
+def isintent_nothide(var):
+    return not isintent_hide(var)
+
+
+def isintent_c(var):
+    return 'c' in var.get('intent', [])
+
+
+def isintent_cache(var):
+    return 'cache' in var.get('intent', [])
+
+
+def isintent_copy(var):
+    return 'copy' in var.get('intent', [])
+
+
+def isintent_overwrite(var):
+    return 'overwrite' in var.get('intent', [])
+
+
+def isintent_callback(var):
+    return 'callback' in var.get('intent', [])
+
+
+def isintent_inplace(var):
+    return 'inplace' in var.get('intent', [])
+
+
+def isintent_aux(var):
+    return 'aux' in var.get('intent', [])
+
+
+def isintent_aligned4(var):
+    return 'aligned4' in var.get('intent', [])
+
+
+def isintent_aligned8(var):
+    return 'aligned8' in var.get('intent', [])
+
+
+def isintent_aligned16(var):
+    return 'aligned16' in var.get('intent', [])
+
+
+isintent_dict = {isintent_in: 'INTENT_IN', isintent_inout: 'INTENT_INOUT',
+                 isintent_out: 'INTENT_OUT', isintent_hide: 'INTENT_HIDE',
+                 isintent_cache: 'INTENT_CACHE',
+                 isintent_c: 'INTENT_C', isoptional: 'OPTIONAL',
+                 isintent_inplace: 'INTENT_INPLACE',
+                 isintent_aligned4: 'INTENT_ALIGNED4',
+                 isintent_aligned8: 'INTENT_ALIGNED8',
+                 isintent_aligned16: 'INTENT_ALIGNED16',
+                 }
+
+
+def isprivate(var):
+    return 'attrspec' in var and 'private' in var['attrspec']
+
+
+def isvariable(var):
+    # heuristic to find public/private declarations of filtered subroutines
+    if len(var) == 1 and 'attrspec' in var and \
+            var['attrspec'][0] in ('public', 'private'):
+        is_var = False
+    else:
+        is_var = True
+    return is_var
+
+def hasinitvalue(var):
+    return '=' in var
+
+
+def hasinitvalueasstring(var):
+    if not hasinitvalue(var):
+        return 0
+    return var['='][0] in ['"', "'"]
+
+
+def hasnote(var):
+    return 'note' in var
+
+
+def hasresultnote(rout):
+    if not isfunction(rout):
+        return 0
+    if 'result' in rout:
+        a = rout['result']
+    else:
+        a = rout['name']
+    if a in rout['vars']:
+        return hasnote(rout['vars'][a])
+    return 0
+
+
+def hascommon(rout):
+    return 'common' in rout
+
+
+def containscommon(rout):
+    if hascommon(rout):
+        return 1
+    if hasbody(rout):
+        for b in rout['body']:
+            if containscommon(b):
+                return 1
+    return 0
+
+
+def containsmodule(block):
+    if ismodule(block):
+        return 1
+    if not hasbody(block):
+        return 0
+    for b in block['body']:
+        if containsmodule(b):
+            return 1
+    return 0
+
+
+def hasbody(rout):
+    return 'body' in rout
+
+
+def hascallstatement(rout):
+    return getcallstatement(rout) is not None
+
+
+def istrue(var):
+    return 1
+
+
+def isfalse(var):
+    return 0
+
+
+class F2PYError(Exception):
+    pass
+
+
+class throw_error:
+
+    def __init__(self, mess):
+        self.mess = mess
+
+    def __call__(self, var):
+        mess = '\n\n  var = %s\n  Message: %s\n' % (var, self.mess)
+        raise F2PYError(mess)
+
+
+def l_and(*f):
+    l1, l2 = 'lambda v', []
+    for i in range(len(f)):
+        l1 = '%s,f%d=f[%d]' % (l1, i, i)
+        l2.append('f%d(v)' % (i))
+    return eval('%s:%s' % (l1, ' and '.join(l2)))
+
+
+def l_or(*f):
+    l1, l2 = 'lambda v', []
+    for i in range(len(f)):
+        l1 = '%s,f%d=f[%d]' % (l1, i, i)
+        l2.append('f%d(v)' % (i))
+    return eval('%s:%s' % (l1, ' or '.join(l2)))
+
+
+def l_not(f):
+    return eval('lambda v,f=f:not f(v)')
+
+
+def isdummyroutine(rout):
+    try:
+        return rout['f2pyenhancements']['fortranname'] == ''
+    except KeyError:
+        return 0
+
+
+def getfortranname(rout):
+    try:
+        name = rout['f2pyenhancements']['fortranname']
+        if name == '':
+            raise KeyError
+        if not name:
+            errmess('Failed to use fortranname from %s\n' %
+                    (rout['f2pyenhancements']))
+            raise KeyError
+    except KeyError:
+        name = rout['name']
+    return name
+
+
+def getmultilineblock(rout, blockname, comment=1, counter=0):
+    try:
+        r = rout['f2pyenhancements'].get(blockname)
+    except KeyError:
+        return
+    if not r:
+        return
+    if counter > 0 and isinstance(r, str):
+        return
+    if isinstance(r, list):
+        if counter >= len(r):
+            return
+        r = r[counter]
+    if r[:3] == "'''":
+        if comment:
+            r = '\t/* start ' + blockname + \
+                ' multiline (' + repr(counter) + ') */\n' + r[3:]
+        else:
+            r = r[3:]
+        if r[-3:] == "'''":
+            if comment:
+                r = r[:-3] + '\n\t/* end multiline (' + repr(counter) + ')*/'
+            else:
+                r = r[:-3]
+        else:
+            errmess("%s multiline block should end with `'''`: %s\n"
+                    % (blockname, repr(r)))
+    return r
+
+
+def getcallstatement(rout):
+    return getmultilineblock(rout, 'callstatement')
+
+
+def getcallprotoargument(rout, cb_map={}):
+    r = getmultilineblock(rout, 'callprotoargument', comment=0)
+    if r:
+        return r
+    if hascallstatement(rout):
+        outmess(
+            'warning: callstatement is defined without callprotoargument\n')
+        return
+    from .capi_maps import getctype
+    arg_types, arg_types2 = [], []
+    if l_and(isstringfunction, l_not(isfunction_wrap))(rout):
+        arg_types.extend(['char*', 'size_t'])
+    for n in rout['args']:
+        var = rout['vars'][n]
+        if isintent_callback(var):
+            continue
+        if n in cb_map:
+            ctype = cb_map[n] + '_typedef'
+        else:
+            ctype = getctype(var)
+            if l_and(isintent_c, l_or(isscalar, iscomplex))(var):
+                pass
+            elif isstring(var):
+                pass
+            else:
+                if not isattr_value(var):
+                    ctype = ctype + '*'
+            if (isstring(var)
+                 or isarrayofstrings(var)  # obsolete?
+                 or isstringarray(var)):
+                arg_types2.append('size_t')
+        arg_types.append(ctype)
+
+    proto_args = ','.join(arg_types + arg_types2)
+    if not proto_args:
+        proto_args = 'void'
+    return proto_args
+
+
+def getusercode(rout):
+    return getmultilineblock(rout, 'usercode')
+
+
+def getusercode1(rout):
+    return getmultilineblock(rout, 'usercode', counter=1)
+
+
+def getpymethoddef(rout):
+    return getmultilineblock(rout, 'pymethoddef')
+
+
+def getargs(rout):
+    sortargs, args = [], []
+    if 'args' in rout:
+        args = rout['args']
+        if 'sortvars' in rout:
+            for a in rout['sortvars']:
+                if a in args:
+                    sortargs.append(a)
+            for a in args:
+                if a not in sortargs:
+                    sortargs.append(a)
+        else:
+            sortargs = rout['args']
+    return args, sortargs
+
+
+def getargs2(rout):
+    sortargs, args = [], rout.get('args', [])
+    auxvars = [a for a in rout['vars'].keys() if isintent_aux(rout['vars'][a])
+               and a not in args]
+    args = auxvars + args
+    if 'sortvars' in rout:
+        for a in rout['sortvars']:
+            if a in args:
+                sortargs.append(a)
+        for a in args:
+            if a not in sortargs:
+                sortargs.append(a)
+    else:
+        sortargs = auxvars + rout['args']
+    return args, sortargs
+
+
+def getrestdoc(rout):
+    if 'f2pymultilines' not in rout:
+        return None
+    k = None
+    if rout['block'] == 'python module':
+        k = rout['block'], rout['name']
+    return rout['f2pymultilines'].get(k, None)
+
+
+def gentitle(name):
+    ln = (80 - len(name) - 6) // 2
+    return '/*%s %s %s*/' % (ln * '*', name, ln * '*')
+
+
+def flatlist(lst):
+    if isinstance(lst, list):
+        return reduce(lambda x, y, f=flatlist: x + f(y), lst, [])
+    return [lst]
+
+
+def stripcomma(s):
+    if s and s[-1] == ',':
+        return s[:-1]
+    return s
+
+
+def replace(str, d, defaultsep=''):
+    if isinstance(d, list):
+        return [replace(str, _m, defaultsep) for _m in d]
+    if isinstance(str, list):
+        return [replace(_m, d, defaultsep) for _m in str]
+    for k in 2 * list(d.keys()):
+        if k == 'separatorsfor':
+            continue
+        if 'separatorsfor' in d and k in d['separatorsfor']:
+            sep = d['separatorsfor'][k]
+        else:
+            sep = defaultsep
+        if isinstance(d[k], list):
+            str = str.replace('#%s#' % (k), sep.join(flatlist(d[k])))
+        else:
+            str = str.replace('#%s#' % (k), d[k])
+    return str
+
+
+def dictappend(rd, ar):
+    if isinstance(ar, list):
+        for a in ar:
+            rd = dictappend(rd, a)
+        return rd
+    for k in ar.keys():
+        if k[0] == '_':
+            continue
+        if k in rd:
+            if isinstance(rd[k], str):
+                rd[k] = [rd[k]]
+            if isinstance(rd[k], list):
+                if isinstance(ar[k], list):
+                    rd[k] = rd[k] + ar[k]
+                else:
+                    rd[k].append(ar[k])
+            elif isinstance(rd[k], dict):
+                if isinstance(ar[k], dict):
+                    if k == 'separatorsfor':
+                        for k1 in ar[k].keys():
+                            if k1 not in rd[k]:
+                                rd[k][k1] = ar[k][k1]
+                    else:
+                        rd[k] = dictappend(rd[k], ar[k])
+        else:
+            rd[k] = ar[k]
+    return rd
+
+
+def applyrules(rules, d, var={}):
+    ret = {}
+    if isinstance(rules, list):
+        for r in rules:
+            rr = applyrules(r, d, var)
+            ret = dictappend(ret, rr)
+            if '_break' in rr:
+                break
+        return ret
+    if '_check' in rules and (not rules['_check'](var)):
+        return ret
+    if 'need' in rules:
+        res = applyrules({'needs': rules['need']}, d, var)
+        if 'needs' in res:
+            cfuncs.append_needs(res['needs'])
+
+    for k in rules.keys():
+        if k == 'separatorsfor':
+            ret[k] = rules[k]
+            continue
+        if isinstance(rules[k], str):
+            ret[k] = replace(rules[k], d)
+        elif isinstance(rules[k], list):
+            ret[k] = []
+            for i in rules[k]:
+                ar = applyrules({k: i}, d, var)
+                if k in ar:
+                    ret[k].append(ar[k])
+        elif k[0] == '_':
+            continue
+        elif isinstance(rules[k], dict):
+            ret[k] = []
+            for k1 in rules[k].keys():
+                if isinstance(k1, types.FunctionType) and k1(var):
+                    if isinstance(rules[k][k1], list):
+                        for i in rules[k][k1]:
+                            if isinstance(i, dict):
+                                res = applyrules({'supertext': i}, d, var)
+                                if 'supertext' in res:
+                                    i = res['supertext']
+                                else:
+                                    i = ''
+                            ret[k].append(replace(i, d))
+                    else:
+                        i = rules[k][k1]
+                        if isinstance(i, dict):
+                            res = applyrules({'supertext': i}, d)
+                            if 'supertext' in res:
+                                i = res['supertext']
+                            else:
+                                i = ''
+                        ret[k].append(replace(i, d))
+        else:
+            errmess('applyrules: ignoring rule %s.\n' % repr(rules[k]))
+        if isinstance(ret[k], list):
+            if len(ret[k]) == 1:
+                ret[k] = ret[k][0]
+            if ret[k] == []:
+                del ret[k]
+    return ret
+
+_f2py_module_name_match = re.compile(r'\s*python\s*module\s*(?P[\w_]+)',
+                                     re.I).match
+_f2py_user_module_name_match = re.compile(r'\s*python\s*module\s*(?P[\w_]*?'
+                                          r'__user__[\w_]*)', re.I).match
+
+def get_f2py_modulename(source):
+    name = None
+    with open(source) as f:
+        for line in f:
+            m = _f2py_module_name_match(line)
+            if m:
+                if _f2py_user_module_name_match(line): # skip *__user__* names
+                    continue
+                name = m.group('name')
+                break
+    return name
+
+def getuseblocks(pymod):
+    all_uses = []
+    for inner in pymod['body']:
+        for modblock in inner['body']:
+            if modblock.get('use'):
+                all_uses.extend([x for x in modblock.get("use").keys() if "__" not in x])
+    return all_uses
+
+def process_f2cmap_dict(f2cmap_all, new_map, c2py_map, verbose = False):
+    """
+    Update the Fortran-to-C type mapping dictionary with new mappings and
+    return a list of successfully mapped C types.
+
+    This function integrates a new mapping dictionary into an existing
+    Fortran-to-C type mapping dictionary. It ensures that all keys are in
+    lowercase and validates new entries against a given C-to-Python mapping
+    dictionary. Redefinitions and invalid entries are reported with a warning.
+
+    Parameters
+    ----------
+    f2cmap_all : dict
+        The existing Fortran-to-C type mapping dictionary that will be updated.
+        It should be a dictionary of dictionaries where the main keys represent
+        Fortran types and the nested dictionaries map Fortran type specifiers
+        to corresponding C types.
+
+    new_map : dict
+        A dictionary containing new type mappings to be added to `f2cmap_all`.
+        The structure should be similar to `f2cmap_all`, with keys representing
+        Fortran types and values being dictionaries of type specifiers and their
+        C type equivalents.
+
+    c2py_map : dict
+        A dictionary used for validating the C types in `new_map`. It maps C
+        types to corresponding Python types and is used to ensure that the C
+        types specified in `new_map` are valid.
+
+    verbose : boolean
+        A flag used to provide information about the types mapped
+
+    Returns
+    -------
+    tuple of (dict, list)
+        The updated Fortran-to-C type mapping dictionary and a list of
+        successfully mapped C types.
+    """
+    f2cmap_mapped = []
+
+    new_map_lower = {}
+    for k, d1 in new_map.items():
+        d1_lower = {k1.lower(): v1 for k1, v1 in d1.items()}
+        new_map_lower[k.lower()] = d1_lower
+
+    for k, d1 in new_map_lower.items():
+        if k not in f2cmap_all:
+            f2cmap_all[k] = {}
+
+        for k1, v1 in d1.items():
+            if v1 in c2py_map:
+                if k1 in f2cmap_all[k]:
+                    outmess(
+                        "\tWarning: redefinition of {'%s':{'%s':'%s'->'%s'}}\n"
+                        % (k, k1, f2cmap_all[k][k1], v1)
+                    )
+                f2cmap_all[k][k1] = v1
+                if verbose:
+                    outmess('\tMapping "%s(kind=%s)" to "%s"\n' % (k, k1, v1))
+                f2cmap_mapped.append(v1)
+            else:
+                if verbose:
+                    errmess(
+                        "\tIgnoring map {'%s':{'%s':'%s'}}: '%s' must be in %s\n"
+                        % (k, k1, v1, v1, list(c2py_map.keys()))
+                    )
+
+    return f2cmap_all, f2cmap_mapped
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/capi_maps.py b/venv/lib/python3.12/site-packages/numpy/f2py/capi_maps.py
new file mode 100644
index 00000000..8a8939d7
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/capi_maps.py
@@ -0,0 +1,821 @@
+"""
+Copyright 1999 -- 2011 Pearu Peterson all rights reserved.
+Copyright 2011 -- present NumPy Developers.
+Permission to use, modify, and distribute this software is given under the
+terms of the NumPy License.
+
+NO WARRANTY IS EXPRESSED OR IMPLIED.  USE AT YOUR OWN RISK.
+"""
+from . import __version__
+f2py_version = __version__.version
+
+import copy
+import re
+import os
+from .crackfortran import markoutercomma
+from . import cb_rules
+from ._isocbind import iso_c_binding_map, isoc_c2pycode_map, iso_c2py_map
+
+# The environment provided by auxfuncs.py is needed for some calls to eval.
+# As the needed functions cannot be determined by static inspection of the
+# code, it is safest to use import * pending a major refactoring of f2py.
+from .auxfuncs import *
+
+__all__ = [
+    'getctype', 'getstrlength', 'getarrdims', 'getpydocsign',
+    'getarrdocsign', 'getinit', 'sign2map', 'routsign2map', 'modsign2map',
+    'cb_sign2map', 'cb_routsign2map', 'common_sign2map', 'process_f2cmap_dict'
+]
+
+
+depargs = []
+lcb_map = {}
+lcb2_map = {}
+# forced casting: mainly caused by the fact that Python or Numeric
+#                 C/APIs do not support the corresponding C types.
+c2py_map = {'double': 'float',
+            'float': 'float',                          # forced casting
+            'long_double': 'float',                    # forced casting
+            'char': 'int',                             # forced casting
+            'signed_char': 'int',                      # forced casting
+            'unsigned_char': 'int',                    # forced casting
+            'short': 'int',                            # forced casting
+            'unsigned_short': 'int',                   # forced casting
+            'int': 'int',                              # forced casting
+            'long': 'int',
+            'long_long': 'long',
+            'unsigned': 'int',                         # forced casting
+            'complex_float': 'complex',                # forced casting
+            'complex_double': 'complex',
+            'complex_long_double': 'complex',          # forced casting
+            'string': 'string',
+            'character': 'bytes',
+            }
+
+c2capi_map = {'double': 'NPY_DOUBLE',
+                'float': 'NPY_FLOAT',
+                'long_double': 'NPY_LONGDOUBLE',
+                'char': 'NPY_BYTE',
+                'unsigned_char': 'NPY_UBYTE',
+                'signed_char': 'NPY_BYTE',
+                'short': 'NPY_SHORT',
+                'unsigned_short': 'NPY_USHORT',
+                'int': 'NPY_INT',
+                'unsigned': 'NPY_UINT',
+                'long': 'NPY_LONG',
+                'unsigned_long': 'NPY_ULONG',
+                'long_long': 'NPY_LONGLONG',
+                'unsigned_long_long': 'NPY_ULONGLONG',
+                'complex_float': 'NPY_CFLOAT',
+                'complex_double': 'NPY_CDOUBLE',
+                'complex_long_double': 'NPY_CDOUBLE',
+                'string': 'NPY_STRING',
+                'character': 'NPY_STRING'}
+
+c2pycode_map = {'double': 'd',
+                'float': 'f',
+                'long_double': 'g',
+                'char': 'b',
+                'unsigned_char': 'B',
+                'signed_char': 'b',
+                'short': 'h',
+                'unsigned_short': 'H',
+                'int': 'i',
+                'unsigned': 'I',
+                'long': 'l',
+                'unsigned_long': 'L',
+                'long_long': 'q',
+                'unsigned_long_long': 'Q',
+                'complex_float': 'F',
+                'complex_double': 'D',
+                'complex_long_double': 'G',
+                'string': 'S',
+                'character': 'c'}
+
+# https://docs.python.org/3/c-api/arg.html#building-values
+c2buildvalue_map = {'double': 'd',
+                    'float': 'f',
+                    'char': 'b',
+                    'signed_char': 'b',
+                    'short': 'h',
+                    'int': 'i',
+                    'long': 'l',
+                    'long_long': 'L',
+                    'complex_float': 'N',
+                    'complex_double': 'N',
+                    'complex_long_double': 'N',
+                    'string': 'y',
+                    'character': 'c'}
+
+f2cmap_all = {'real': {'': 'float', '4': 'float', '8': 'double',
+                       '12': 'long_double', '16': 'long_double'},
+              'integer': {'': 'int', '1': 'signed_char', '2': 'short',
+                          '4': 'int', '8': 'long_long',
+                          '-1': 'unsigned_char', '-2': 'unsigned_short',
+                          '-4': 'unsigned', '-8': 'unsigned_long_long'},
+              'complex': {'': 'complex_float', '8': 'complex_float',
+                          '16': 'complex_double', '24': 'complex_long_double',
+                          '32': 'complex_long_double'},
+              'complexkind': {'': 'complex_float', '4': 'complex_float',
+                              '8': 'complex_double', '12': 'complex_long_double',
+                              '16': 'complex_long_double'},
+              'logical': {'': 'int', '1': 'char', '2': 'short', '4': 'int',
+                          '8': 'long_long'},
+              'double complex': {'': 'complex_double'},
+              'double precision': {'': 'double'},
+              'byte': {'': 'char'},
+              }
+
+# Add ISO_C handling
+c2pycode_map.update(isoc_c2pycode_map)
+c2py_map.update(iso_c2py_map)
+f2cmap_all, _ = process_f2cmap_dict(f2cmap_all, iso_c_binding_map, c2py_map)
+# End ISO_C handling
+f2cmap_default = copy.deepcopy(f2cmap_all)
+
+f2cmap_mapped = []
+
+def load_f2cmap_file(f2cmap_file):
+    global f2cmap_all, f2cmap_mapped
+
+    f2cmap_all = copy.deepcopy(f2cmap_default)
+
+    if f2cmap_file is None:
+        # Default value
+        f2cmap_file = '.f2py_f2cmap'
+        if not os.path.isfile(f2cmap_file):
+            return
+
+    # User defined additions to f2cmap_all.
+    # f2cmap_file must contain a dictionary of dictionaries, only. For
+    # example, {'real':{'low':'float'}} means that Fortran 'real(low)' is
+    # interpreted as C 'float'. This feature is useful for F90/95 users if
+    # they use PARAMETERS in type specifications.
+    try:
+        outmess('Reading f2cmap from {!r} ...\n'.format(f2cmap_file))
+        with open(f2cmap_file) as f:
+            d = eval(f.read().lower(), {}, {})
+        f2cmap_all, f2cmap_mapped = process_f2cmap_dict(f2cmap_all, d, c2py_map, True)
+        outmess('Successfully applied user defined f2cmap changes\n')
+    except Exception as msg:
+        errmess('Failed to apply user defined f2cmap changes: %s. Skipping.\n' % (msg))
+
+
+cformat_map = {'double': '%g',
+               'float': '%g',
+               'long_double': '%Lg',
+               'char': '%d',
+               'signed_char': '%d',
+               'unsigned_char': '%hhu',
+               'short': '%hd',
+               'unsigned_short': '%hu',
+               'int': '%d',
+               'unsigned': '%u',
+               'long': '%ld',
+               'unsigned_long': '%lu',
+               'long_long': '%ld',
+               'complex_float': '(%g,%g)',
+               'complex_double': '(%g,%g)',
+               'complex_long_double': '(%Lg,%Lg)',
+               'string': '\\"%s\\"',
+               'character': "'%c'",
+               }
+
+# Auxiliary functions
+
+
+def getctype(var):
+    """
+    Determines C type
+    """
+    ctype = 'void'
+    if isfunction(var):
+        if 'result' in var:
+            a = var['result']
+        else:
+            a = var['name']
+        if a in var['vars']:
+            return getctype(var['vars'][a])
+        else:
+            errmess('getctype: function %s has no return value?!\n' % a)
+    elif issubroutine(var):
+        return ctype
+    elif ischaracter_or_characterarray(var):
+        return 'character'
+    elif isstring_or_stringarray(var):
+        return 'string'
+    elif 'typespec' in var and var['typespec'].lower() in f2cmap_all:
+        typespec = var['typespec'].lower()
+        f2cmap = f2cmap_all[typespec]
+        ctype = f2cmap['']  # default type
+        if 'kindselector' in var:
+            if '*' in var['kindselector']:
+                try:
+                    ctype = f2cmap[var['kindselector']['*']]
+                except KeyError:
+                    errmess('getctype: "%s %s %s" not supported.\n' %
+                            (var['typespec'], '*', var['kindselector']['*']))
+            elif 'kind' in var['kindselector']:
+                if typespec + 'kind' in f2cmap_all:
+                    f2cmap = f2cmap_all[typespec + 'kind']
+                try:
+                    ctype = f2cmap[var['kindselector']['kind']]
+                except KeyError:
+                    if typespec in f2cmap_all:
+                        f2cmap = f2cmap_all[typespec]
+                    try:
+                        ctype = f2cmap[str(var['kindselector']['kind'])]
+                    except KeyError:
+                        errmess('getctype: "%s(kind=%s)" is mapped to C "%s" (to override define dict(%s = dict(%s="")) in %s/.f2py_f2cmap file).\n'
+                                % (typespec, var['kindselector']['kind'], ctype,
+                                   typespec, var['kindselector']['kind'], os.getcwd()))
+    else:
+        if not isexternal(var):
+            errmess('getctype: No C-type found in "%s", assuming void.\n' % var)
+    return ctype
+
+
+def f2cexpr(expr):
+    """Rewrite Fortran expression as f2py supported C expression.
+
+    Due to the lack of a proper expression parser in f2py, this
+    function uses a heuristic approach that assumes that Fortran
+    arithmetic expressions are valid C arithmetic expressions when
+    mapping Fortran function calls to the corresponding C function/CPP
+    macros calls.
+
+    """
+    # TODO: support Fortran `len` function with optional kind parameter
+    expr = re.sub(r'\blen\b', 'f2py_slen', expr)
+    return expr
+
+
+def getstrlength(var):
+    if isstringfunction(var):
+        if 'result' in var:
+            a = var['result']
+        else:
+            a = var['name']
+        if a in var['vars']:
+            return getstrlength(var['vars'][a])
+        else:
+            errmess('getstrlength: function %s has no return value?!\n' % a)
+    if not isstring(var):
+        errmess(
+            'getstrlength: expected a signature of a string but got: %s\n' % (repr(var)))
+    len = '1'
+    if 'charselector' in var:
+        a = var['charselector']
+        if '*' in a:
+            len = a['*']
+        elif 'len' in a:
+            len = f2cexpr(a['len'])
+    if re.match(r'\(\s*(\*|:)\s*\)', len) or re.match(r'(\*|:)', len):
+        if isintent_hide(var):
+            errmess('getstrlength:intent(hide): expected a string with defined length but got: %s\n' % (
+                repr(var)))
+        len = '-1'
+    return len
+
+
+def getarrdims(a, var, verbose=0):
+    ret = {}
+    if isstring(var) and not isarray(var):
+        ret['size'] = getstrlength(var)
+        ret['rank'] = '0'
+        ret['dims'] = ''
+    elif isscalar(var):
+        ret['size'] = '1'
+        ret['rank'] = '0'
+        ret['dims'] = ''
+    elif isarray(var):
+        dim = copy.copy(var['dimension'])
+        ret['size'] = '*'.join(dim)
+        try:
+            ret['size'] = repr(eval(ret['size']))
+        except Exception:
+            pass
+        ret['dims'] = ','.join(dim)
+        ret['rank'] = repr(len(dim))
+        ret['rank*[-1]'] = repr(len(dim) * [-1])[1:-1]
+        for i in range(len(dim)):  # solve dim for dependencies
+            v = []
+            if dim[i] in depargs:
+                v = [dim[i]]
+            else:
+                for va in depargs:
+                    if re.match(r'.*?\b%s\b.*' % va, dim[i]):
+                        v.append(va)
+            for va in v:
+                if depargs.index(va) > depargs.index(a):
+                    dim[i] = '*'
+                    break
+        ret['setdims'], i = '', -1
+        for d in dim:
+            i = i + 1
+            if d not in ['*', ':', '(*)', '(:)']:
+                ret['setdims'] = '%s#varname#_Dims[%d]=%s,' % (
+                    ret['setdims'], i, d)
+        if ret['setdims']:
+            ret['setdims'] = ret['setdims'][:-1]
+        ret['cbsetdims'], i = '', -1
+        for d in var['dimension']:
+            i = i + 1
+            if d not in ['*', ':', '(*)', '(:)']:
+                ret['cbsetdims'] = '%s#varname#_Dims[%d]=%s,' % (
+                    ret['cbsetdims'], i, d)
+            elif isintent_in(var):
+                outmess('getarrdims:warning: assumed shape array, using 0 instead of %r\n'
+                        % (d))
+                ret['cbsetdims'] = '%s#varname#_Dims[%d]=%s,' % (
+                    ret['cbsetdims'], i, 0)
+            elif verbose:
+                errmess(
+                    'getarrdims: If in call-back function: array argument %s must have bounded dimensions: got %s\n' % (repr(a), repr(d)))
+        if ret['cbsetdims']:
+            ret['cbsetdims'] = ret['cbsetdims'][:-1]
+#         if not isintent_c(var):
+#             var['dimension'].reverse()
+    return ret
+
+
+def getpydocsign(a, var):
+    global lcb_map
+    if isfunction(var):
+        if 'result' in var:
+            af = var['result']
+        else:
+            af = var['name']
+        if af in var['vars']:
+            return getpydocsign(af, var['vars'][af])
+        else:
+            errmess('getctype: function %s has no return value?!\n' % af)
+        return '', ''
+    sig, sigout = a, a
+    opt = ''
+    if isintent_in(var):
+        opt = 'input'
+    elif isintent_inout(var):
+        opt = 'in/output'
+    out_a = a
+    if isintent_out(var):
+        for k in var['intent']:
+            if k[:4] == 'out=':
+                out_a = k[4:]
+                break
+    init = ''
+    ctype = getctype(var)
+
+    if hasinitvalue(var):
+        init, showinit = getinit(a, var)
+        init = ', optional\\n    Default: %s' % showinit
+    if isscalar(var):
+        if isintent_inout(var):
+            sig = '%s : %s rank-0 array(%s,\'%s\')%s' % (a, opt, c2py_map[ctype],
+                                                         c2pycode_map[ctype], init)
+        else:
+            sig = '%s : %s %s%s' % (a, opt, c2py_map[ctype], init)
+        sigout = '%s : %s' % (out_a, c2py_map[ctype])
+    elif isstring(var):
+        if isintent_inout(var):
+            sig = '%s : %s rank-0 array(string(len=%s),\'c\')%s' % (
+                a, opt, getstrlength(var), init)
+        else:
+            sig = '%s : %s string(len=%s)%s' % (
+                a, opt, getstrlength(var), init)
+        sigout = '%s : string(len=%s)' % (out_a, getstrlength(var))
+    elif isarray(var):
+        dim = var['dimension']
+        rank = repr(len(dim))
+        sig = '%s : %s rank-%s array(\'%s\') with bounds (%s)%s' % (a, opt, rank,
+                                                                    c2pycode_map[
+                                                                        ctype],
+                                                                    ','.join(dim), init)
+        if a == out_a:
+            sigout = '%s : rank-%s array(\'%s\') with bounds (%s)'\
+                % (a, rank, c2pycode_map[ctype], ','.join(dim))
+        else:
+            sigout = '%s : rank-%s array(\'%s\') with bounds (%s) and %s storage'\
+                % (out_a, rank, c2pycode_map[ctype], ','.join(dim), a)
+    elif isexternal(var):
+        ua = ''
+        if a in lcb_map and lcb_map[a] in lcb2_map and 'argname' in lcb2_map[lcb_map[a]]:
+            ua = lcb2_map[lcb_map[a]]['argname']
+            if not ua == a:
+                ua = ' => %s' % ua
+            else:
+                ua = ''
+        sig = '%s : call-back function%s' % (a, ua)
+        sigout = sig
+    else:
+        errmess(
+            'getpydocsign: Could not resolve docsignature for "%s".\n' % a)
+    return sig, sigout
+
+
+def getarrdocsign(a, var):
+    ctype = getctype(var)
+    if isstring(var) and (not isarray(var)):
+        sig = '%s : rank-0 array(string(len=%s),\'c\')' % (a,
+                                                           getstrlength(var))
+    elif isscalar(var):
+        sig = '%s : rank-0 array(%s,\'%s\')' % (a, c2py_map[ctype],
+                                                c2pycode_map[ctype],)
+    elif isarray(var):
+        dim = var['dimension']
+        rank = repr(len(dim))
+        sig = '%s : rank-%s array(\'%s\') with bounds (%s)' % (a, rank,
+                                                               c2pycode_map[
+                                                                   ctype],
+                                                               ','.join(dim))
+    return sig
+
+
+def getinit(a, var):
+    if isstring(var):
+        init, showinit = '""', "''"
+    else:
+        init, showinit = '', ''
+    if hasinitvalue(var):
+        init = var['=']
+        showinit = init
+        if iscomplex(var) or iscomplexarray(var):
+            ret = {}
+
+            try:
+                v = var["="]
+                if ',' in v:
+                    ret['init.r'], ret['init.i'] = markoutercomma(
+                        v[1:-1]).split('@,@')
+                else:
+                    v = eval(v, {}, {})
+                    ret['init.r'], ret['init.i'] = str(v.real), str(v.imag)
+            except Exception:
+                raise ValueError(
+                    'getinit: expected complex number `(r,i)\' but got `%s\' as initial value of %r.' % (init, a))
+            if isarray(var):
+                init = '(capi_c.r=%s,capi_c.i=%s,capi_c)' % (
+                    ret['init.r'], ret['init.i'])
+        elif isstring(var):
+            if not init:
+                init, showinit = '""', "''"
+            if init[0] == "'":
+                init = '"%s"' % (init[1:-1].replace('"', '\\"'))
+            if init[0] == '"':
+                showinit = "'%s'" % (init[1:-1])
+    return init, showinit
+
+
+def get_elsize(var):
+    if isstring(var) or isstringarray(var):
+        elsize = getstrlength(var)
+        # override with user-specified length when available:
+        elsize = var['charselector'].get('f2py_len', elsize)
+        return elsize
+    if ischaracter(var) or ischaracterarray(var):
+        return '1'
+    # for numerical types, PyArray_New* functions ignore specified
+    # elsize, so we just return 1 and let elsize be determined at
+    # runtime, see fortranobject.c
+    return '1'
+
+
+def sign2map(a, var):
+    """
+    varname,ctype,atype
+    init,init.r,init.i,pytype
+    vardebuginfo,vardebugshowvalue,varshowvalue
+    varrformat
+
+    intent
+    """
+    out_a = a
+    if isintent_out(var):
+        for k in var['intent']:
+            if k[:4] == 'out=':
+                out_a = k[4:]
+                break
+    ret = {'varname': a, 'outvarname': out_a, 'ctype': getctype(var)}
+    intent_flags = []
+    for f, s in isintent_dict.items():
+        if f(var):
+            intent_flags.append('F2PY_%s' % s)
+    if intent_flags:
+        # TODO: Evaluate intent_flags here.
+        ret['intent'] = '|'.join(intent_flags)
+    else:
+        ret['intent'] = 'F2PY_INTENT_IN'
+    if isarray(var):
+        ret['varrformat'] = 'N'
+    elif ret['ctype'] in c2buildvalue_map:
+        ret['varrformat'] = c2buildvalue_map[ret['ctype']]
+    else:
+        ret['varrformat'] = 'O'
+    ret['init'], ret['showinit'] = getinit(a, var)
+    if hasinitvalue(var) and iscomplex(var) and not isarray(var):
+        ret['init.r'], ret['init.i'] = markoutercomma(
+            ret['init'][1:-1]).split('@,@')
+    if isexternal(var):
+        ret['cbnamekey'] = a
+        if a in lcb_map:
+            ret['cbname'] = lcb_map[a]
+            ret['maxnofargs'] = lcb2_map[lcb_map[a]]['maxnofargs']
+            ret['nofoptargs'] = lcb2_map[lcb_map[a]]['nofoptargs']
+            ret['cbdocstr'] = lcb2_map[lcb_map[a]]['docstr']
+            ret['cblatexdocstr'] = lcb2_map[lcb_map[a]]['latexdocstr']
+        else:
+            ret['cbname'] = a
+            errmess('sign2map: Confused: external %s is not in lcb_map%s.\n' % (
+                a, list(lcb_map.keys())))
+    if isstring(var):
+        ret['length'] = getstrlength(var)
+    if isarray(var):
+        ret = dictappend(ret, getarrdims(a, var))
+        dim = copy.copy(var['dimension'])
+    if ret['ctype'] in c2capi_map:
+        ret['atype'] = c2capi_map[ret['ctype']]
+        ret['elsize'] = get_elsize(var)
+    # Debug info
+    if debugcapi(var):
+        il = [isintent_in, 'input', isintent_out, 'output',
+              isintent_inout, 'inoutput', isrequired, 'required',
+              isoptional, 'optional', isintent_hide, 'hidden',
+              iscomplex, 'complex scalar',
+              l_and(isscalar, l_not(iscomplex)), 'scalar',
+              isstring, 'string', isarray, 'array',
+              iscomplexarray, 'complex array', isstringarray, 'string array',
+              iscomplexfunction, 'complex function',
+              l_and(isfunction, l_not(iscomplexfunction)), 'function',
+              isexternal, 'callback',
+              isintent_callback, 'callback',
+              isintent_aux, 'auxiliary',
+              ]
+        rl = []
+        for i in range(0, len(il), 2):
+            if il[i](var):
+                rl.append(il[i + 1])
+        if isstring(var):
+            rl.append('slen(%s)=%s' % (a, ret['length']))
+        if isarray(var):
+            ddim = ','.join(
+                map(lambda x, y: '%s|%s' % (x, y), var['dimension'], dim))
+            rl.append('dims(%s)' % ddim)
+        if isexternal(var):
+            ret['vardebuginfo'] = 'debug-capi:%s=>%s:%s' % (
+                a, ret['cbname'], ','.join(rl))
+        else:
+            ret['vardebuginfo'] = 'debug-capi:%s %s=%s:%s' % (
+                ret['ctype'], a, ret['showinit'], ','.join(rl))
+        if isscalar(var):
+            if ret['ctype'] in cformat_map:
+                ret['vardebugshowvalue'] = 'debug-capi:%s=%s' % (
+                    a, cformat_map[ret['ctype']])
+        if isstring(var):
+            ret['vardebugshowvalue'] = 'debug-capi:slen(%s)=%%d %s=\\"%%s\\"' % (
+                a, a)
+        if isexternal(var):
+            ret['vardebugshowvalue'] = 'debug-capi:%s=%%p' % (a)
+    if ret['ctype'] in cformat_map:
+        ret['varshowvalue'] = '#name#:%s=%s' % (a, cformat_map[ret['ctype']])
+        ret['showvalueformat'] = '%s' % (cformat_map[ret['ctype']])
+    if isstring(var):
+        ret['varshowvalue'] = '#name#:slen(%s)=%%d %s=\\"%%s\\"' % (a, a)
+    ret['pydocsign'], ret['pydocsignout'] = getpydocsign(a, var)
+    if hasnote(var):
+        ret['note'] = var['note']
+    return ret
+
+
+def routsign2map(rout):
+    """
+    name,NAME,begintitle,endtitle
+    rname,ctype,rformat
+    routdebugshowvalue
+    """
+    global lcb_map
+    name = rout['name']
+    fname = getfortranname(rout)
+    ret = {'name': name,
+           'texname': name.replace('_', '\\_'),
+           'name_lower': name.lower(),
+           'NAME': name.upper(),
+           'begintitle': gentitle(name),
+           'endtitle': gentitle('end of %s' % name),
+           'fortranname': fname,
+           'FORTRANNAME': fname.upper(),
+           'callstatement': getcallstatement(rout) or '',
+           'usercode': getusercode(rout) or '',
+           'usercode1': getusercode1(rout) or '',
+           }
+    if '_' in fname:
+        ret['F_FUNC'] = 'F_FUNC_US'
+    else:
+        ret['F_FUNC'] = 'F_FUNC'
+    if '_' in name:
+        ret['F_WRAPPEDFUNC'] = 'F_WRAPPEDFUNC_US'
+    else:
+        ret['F_WRAPPEDFUNC'] = 'F_WRAPPEDFUNC'
+    lcb_map = {}
+    if 'use' in rout:
+        for u in rout['use'].keys():
+            if u in cb_rules.cb_map:
+                for un in cb_rules.cb_map[u]:
+                    ln = un[0]
+                    if 'map' in rout['use'][u]:
+                        for k in rout['use'][u]['map'].keys():
+                            if rout['use'][u]['map'][k] == un[0]:
+                                ln = k
+                                break
+                    lcb_map[ln] = un[1]
+    elif 'externals' in rout and rout['externals']:
+        errmess('routsign2map: Confused: function %s has externals %s but no "use" statement.\n' % (
+            ret['name'], repr(rout['externals'])))
+    ret['callprotoargument'] = getcallprotoargument(rout, lcb_map) or ''
+    if isfunction(rout):
+        if 'result' in rout:
+            a = rout['result']
+        else:
+            a = rout['name']
+        ret['rname'] = a
+        ret['pydocsign'], ret['pydocsignout'] = getpydocsign(a, rout)
+        ret['ctype'] = getctype(rout['vars'][a])
+        if hasresultnote(rout):
+            ret['resultnote'] = rout['vars'][a]['note']
+            rout['vars'][a]['note'] = ['See elsewhere.']
+        if ret['ctype'] in c2buildvalue_map:
+            ret['rformat'] = c2buildvalue_map[ret['ctype']]
+        else:
+            ret['rformat'] = 'O'
+            errmess('routsign2map: no c2buildvalue key for type %s\n' %
+                    (repr(ret['ctype'])))
+        if debugcapi(rout):
+            if ret['ctype'] in cformat_map:
+                ret['routdebugshowvalue'] = 'debug-capi:%s=%s' % (
+                    a, cformat_map[ret['ctype']])
+            if isstringfunction(rout):
+                ret['routdebugshowvalue'] = 'debug-capi:slen(%s)=%%d %s=\\"%%s\\"' % (
+                    a, a)
+        if isstringfunction(rout):
+            ret['rlength'] = getstrlength(rout['vars'][a])
+            if ret['rlength'] == '-1':
+                errmess('routsign2map: expected explicit specification of the length of the string returned by the fortran function %s; taking 10.\n' % (
+                    repr(rout['name'])))
+                ret['rlength'] = '10'
+    if hasnote(rout):
+        ret['note'] = rout['note']
+        rout['note'] = ['See elsewhere.']
+    return ret
+
+
+def modsign2map(m):
+    """
+    modulename
+    """
+    if ismodule(m):
+        ret = {'f90modulename': m['name'],
+               'F90MODULENAME': m['name'].upper(),
+               'texf90modulename': m['name'].replace('_', '\\_')}
+    else:
+        ret = {'modulename': m['name'],
+               'MODULENAME': m['name'].upper(),
+               'texmodulename': m['name'].replace('_', '\\_')}
+    ret['restdoc'] = getrestdoc(m) or []
+    if hasnote(m):
+        ret['note'] = m['note']
+    ret['usercode'] = getusercode(m) or ''
+    ret['usercode1'] = getusercode1(m) or ''
+    if m['body']:
+        ret['interface_usercode'] = getusercode(m['body'][0]) or ''
+    else:
+        ret['interface_usercode'] = ''
+    ret['pymethoddef'] = getpymethoddef(m) or ''
+    if 'gil_used' in m:
+        ret['gil_used'] = m['gil_used']
+    if 'coutput' in m:
+        ret['coutput'] = m['coutput']
+    if 'f2py_wrapper_output' in m:
+        ret['f2py_wrapper_output'] = m['f2py_wrapper_output']
+    return ret
+
+
+def cb_sign2map(a, var, index=None):
+    ret = {'varname': a}
+    ret['varname_i'] = ret['varname']
+    ret['ctype'] = getctype(var)
+    if ret['ctype'] in c2capi_map:
+        ret['atype'] = c2capi_map[ret['ctype']]
+        ret['elsize'] = get_elsize(var)
+    if ret['ctype'] in cformat_map:
+        ret['showvalueformat'] = '%s' % (cformat_map[ret['ctype']])
+    if isarray(var):
+        ret = dictappend(ret, getarrdims(a, var))
+    ret['pydocsign'], ret['pydocsignout'] = getpydocsign(a, var)
+    if hasnote(var):
+        ret['note'] = var['note']
+        var['note'] = ['See elsewhere.']
+    return ret
+
+
+def cb_routsign2map(rout, um):
+    """
+    name,begintitle,endtitle,argname
+    ctype,rctype,maxnofargs,nofoptargs,returncptr
+    """
+    ret = {'name': 'cb_%s_in_%s' % (rout['name'], um),
+           'returncptr': ''}
+    if isintent_callback(rout):
+        if '_' in rout['name']:
+            F_FUNC = 'F_FUNC_US'
+        else:
+            F_FUNC = 'F_FUNC'
+        ret['callbackname'] = '%s(%s,%s)' \
+                              % (F_FUNC,
+                                 rout['name'].lower(),
+                                 rout['name'].upper(),
+                                 )
+        ret['static'] = 'extern'
+    else:
+        ret['callbackname'] = ret['name']
+        ret['static'] = 'static'
+    ret['argname'] = rout['name']
+    ret['begintitle'] = gentitle(ret['name'])
+    ret['endtitle'] = gentitle('end of %s' % ret['name'])
+    ret['ctype'] = getctype(rout)
+    ret['rctype'] = 'void'
+    if ret['ctype'] == 'string':
+        ret['rctype'] = 'void'
+    else:
+        ret['rctype'] = ret['ctype']
+    if ret['rctype'] != 'void':
+        if iscomplexfunction(rout):
+            ret['returncptr'] = """
+#ifdef F2PY_CB_RETURNCOMPLEX
+return_value=
+#endif
+"""
+        else:
+            ret['returncptr'] = 'return_value='
+    if ret['ctype'] in cformat_map:
+        ret['showvalueformat'] = '%s' % (cformat_map[ret['ctype']])
+    if isstringfunction(rout):
+        ret['strlength'] = getstrlength(rout)
+    if isfunction(rout):
+        if 'result' in rout:
+            a = rout['result']
+        else:
+            a = rout['name']
+        if hasnote(rout['vars'][a]):
+            ret['note'] = rout['vars'][a]['note']
+            rout['vars'][a]['note'] = ['See elsewhere.']
+        ret['rname'] = a
+        ret['pydocsign'], ret['pydocsignout'] = getpydocsign(a, rout)
+        if iscomplexfunction(rout):
+            ret['rctype'] = """
+#ifdef F2PY_CB_RETURNCOMPLEX
+#ctype#
+#else
+void
+#endif
+"""
+    else:
+        if hasnote(rout):
+            ret['note'] = rout['note']
+            rout['note'] = ['See elsewhere.']
+    nofargs = 0
+    nofoptargs = 0
+    if 'args' in rout and 'vars' in rout:
+        for a in rout['args']:
+            var = rout['vars'][a]
+            if l_or(isintent_in, isintent_inout)(var):
+                nofargs = nofargs + 1
+                if isoptional(var):
+                    nofoptargs = nofoptargs + 1
+    ret['maxnofargs'] = repr(nofargs)
+    ret['nofoptargs'] = repr(nofoptargs)
+    if hasnote(rout) and isfunction(rout) and 'result' in rout:
+        ret['routnote'] = rout['note']
+        rout['note'] = ['See elsewhere.']
+    return ret
+
+
+def common_sign2map(a, var):  # obsolute
+    ret = {'varname': a, 'ctype': getctype(var)}
+    if isstringarray(var):
+        ret['ctype'] = 'char'
+    if ret['ctype'] in c2capi_map:
+        ret['atype'] = c2capi_map[ret['ctype']]
+        ret['elsize'] = get_elsize(var)
+    if ret['ctype'] in cformat_map:
+        ret['showvalueformat'] = '%s' % (cformat_map[ret['ctype']])
+    if isarray(var):
+        ret = dictappend(ret, getarrdims(a, var))
+    elif isstring(var):
+        ret['size'] = getstrlength(var)
+        ret['rank'] = '1'
+    ret['pydocsign'], ret['pydocsignout'] = getpydocsign(a, var)
+    if hasnote(var):
+        ret['note'] = var['note']
+        var['note'] = ['See elsewhere.']
+    # for strings this returns 0-rank but actually is 1-rank
+    ret['arrdocstr'] = getarrdocsign(a, var)
+    return ret
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/cb_rules.py b/venv/lib/python3.12/site-packages/numpy/f2py/cb_rules.py
new file mode 100644
index 00000000..faf8dd40
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/cb_rules.py
@@ -0,0 +1,644 @@
+"""
+Build call-back mechanism for f2py2e.
+
+Copyright 1999 -- 2011 Pearu Peterson all rights reserved.
+Copyright 2011 -- present NumPy Developers.
+Permission to use, modify, and distribute this software is given under the
+terms of the NumPy License.
+
+NO WARRANTY IS EXPRESSED OR IMPLIED.  USE AT YOUR OWN RISK.
+"""
+from . import __version__
+from .auxfuncs import (
+    applyrules, debugcapi, dictappend, errmess, getargs, hasnote, isarray,
+    iscomplex, iscomplexarray, iscomplexfunction, isfunction, isintent_c,
+    isintent_hide, isintent_in, isintent_inout, isintent_nothide,
+    isintent_out, isoptional, isrequired, isscalar, isstring,
+    isstringfunction, issubroutine, l_and, l_not, l_or, outmess, replace,
+    stripcomma, throw_error
+)
+from . import cfuncs
+
+f2py_version = __version__.version
+
+
+################## Rules for callback function ##############
+
+cb_routine_rules = {
+    'cbtypedefs': 'typedef #rctype#(*#name#_typedef)(#optargs_td##args_td##strarglens_td##noargs#);',
+    'body': """
+#begintitle#
+typedef struct {
+    PyObject *capi;
+    PyTupleObject *args_capi;
+    int nofargs;
+    jmp_buf jmpbuf;
+} #name#_t;
+
+#if defined(F2PY_THREAD_LOCAL_DECL) && !defined(F2PY_USE_PYTHON_TLS)
+
+static F2PY_THREAD_LOCAL_DECL #name#_t *_active_#name# = NULL;
+
+static #name#_t *swap_active_#name#(#name#_t *ptr) {
+    #name#_t *prev = _active_#name#;
+    _active_#name# = ptr;
+    return prev;
+}
+
+static #name#_t *get_active_#name#(void) {
+    return _active_#name#;
+}
+
+#else
+
+static #name#_t *swap_active_#name#(#name#_t *ptr) {
+    char *key = "__f2py_cb_#name#";
+    return (#name#_t *)F2PySwapThreadLocalCallbackPtr(key, ptr);
+}
+
+static #name#_t *get_active_#name#(void) {
+    char *key = "__f2py_cb_#name#";
+    return (#name#_t *)F2PyGetThreadLocalCallbackPtr(key);
+}
+
+#endif
+
+/*typedef #rctype#(*#name#_typedef)(#optargs_td##args_td##strarglens_td##noargs#);*/
+#static# #rctype# #callbackname# (#optargs##args##strarglens##noargs#) {
+    #name#_t cb_local = { NULL, NULL, 0 };
+    #name#_t *cb = NULL;
+    PyTupleObject *capi_arglist = NULL;
+    PyObject *capi_return = NULL;
+    PyObject *capi_tmp = NULL;
+    PyObject *capi_arglist_list = NULL;
+    int capi_j,capi_i = 0;
+    int capi_longjmp_ok = 1;
+#decl#
+#ifdef F2PY_REPORT_ATEXIT
+f2py_cb_start_clock();
+#endif
+    cb = get_active_#name#();
+    if (cb == NULL) {
+        capi_longjmp_ok = 0;
+        cb = &cb_local;
+    }
+    capi_arglist = cb->args_capi;
+    CFUNCSMESS(\"cb:Call-back function #name# (maxnofargs=#maxnofargs#(-#nofoptargs#))\\n\");
+    CFUNCSMESSPY(\"cb:#name#_capi=\",cb->capi);
+    if (cb->capi==NULL) {
+        capi_longjmp_ok = 0;
+        cb->capi = PyObject_GetAttrString(#modulename#_module,\"#argname#\");
+        CFUNCSMESSPY(\"cb:#name#_capi=\",cb->capi);
+    }
+    if (cb->capi==NULL) {
+        PyErr_SetString(#modulename#_error,\"cb: Callback #argname# not defined (as an argument or module #modulename# attribute).\\n\");
+        goto capi_fail;
+    }
+    if (F2PyCapsule_Check(cb->capi)) {
+    #name#_typedef #name#_cptr;
+    #name#_cptr = F2PyCapsule_AsVoidPtr(cb->capi);
+    #returncptr#(*#name#_cptr)(#optargs_nm##args_nm##strarglens_nm#);
+    #return#
+    }
+    if (capi_arglist==NULL) {
+        capi_longjmp_ok = 0;
+        capi_tmp = PyObject_GetAttrString(#modulename#_module,\"#argname#_extra_args\");
+        if (capi_tmp) {
+            capi_arglist = (PyTupleObject *)PySequence_Tuple(capi_tmp);
+            Py_DECREF(capi_tmp);
+            if (capi_arglist==NULL) {
+                PyErr_SetString(#modulename#_error,\"Failed to convert #modulename#.#argname#_extra_args to tuple.\\n\");
+                goto capi_fail;
+            }
+        } else {
+            PyErr_Clear();
+            capi_arglist = (PyTupleObject *)Py_BuildValue(\"()\");
+        }
+    }
+    if (capi_arglist == NULL) {
+        PyErr_SetString(#modulename#_error,\"Callback #argname# argument list is not set.\\n\");
+        goto capi_fail;
+    }
+#setdims#
+#ifdef PYPY_VERSION
+#define CAPI_ARGLIST_SETITEM(idx, value) PyList_SetItem((PyObject *)capi_arglist_list, idx, value)
+    capi_arglist_list = PySequence_List((PyObject *)capi_arglist);
+    if (capi_arglist_list == NULL) goto capi_fail;
+#else
+#define CAPI_ARGLIST_SETITEM(idx, value) PyTuple_SetItem((PyObject *)capi_arglist, idx, value)
+#endif
+#pyobjfrom#
+#undef CAPI_ARGLIST_SETITEM
+#ifdef PYPY_VERSION
+    CFUNCSMESSPY(\"cb:capi_arglist=\",capi_arglist_list);
+#else
+    CFUNCSMESSPY(\"cb:capi_arglist=\",capi_arglist);
+#endif
+    CFUNCSMESS(\"cb:Call-back calling Python function #argname#.\\n\");
+#ifdef F2PY_REPORT_ATEXIT
+f2py_cb_start_call_clock();
+#endif
+#ifdef PYPY_VERSION
+    capi_return = PyObject_CallObject(cb->capi,(PyObject *)capi_arglist_list);
+    Py_DECREF(capi_arglist_list);
+    capi_arglist_list = NULL;
+#else
+    capi_return = PyObject_CallObject(cb->capi,(PyObject *)capi_arglist);
+#endif
+#ifdef F2PY_REPORT_ATEXIT
+f2py_cb_stop_call_clock();
+#endif
+    CFUNCSMESSPY(\"cb:capi_return=\",capi_return);
+    if (capi_return == NULL) {
+        fprintf(stderr,\"capi_return is NULL\\n\");
+        goto capi_fail;
+    }
+    if (capi_return == Py_None) {
+        Py_DECREF(capi_return);
+        capi_return = Py_BuildValue(\"()\");
+    }
+    else if (!PyTuple_Check(capi_return)) {
+        capi_return = Py_BuildValue(\"(N)\",capi_return);
+    }
+    capi_j = PyTuple_Size(capi_return);
+    capi_i = 0;
+#frompyobj#
+    CFUNCSMESS(\"cb:#name#:successful\\n\");
+    Py_DECREF(capi_return);
+#ifdef F2PY_REPORT_ATEXIT
+f2py_cb_stop_clock();
+#endif
+    goto capi_return_pt;
+capi_fail:
+    fprintf(stderr,\"Call-back #name# failed.\\n\");
+    Py_XDECREF(capi_return);
+    Py_XDECREF(capi_arglist_list);
+    if (capi_longjmp_ok) {
+        longjmp(cb->jmpbuf,-1);
+    }
+capi_return_pt:
+    ;
+#return#
+}
+#endtitle#
+""",
+    'need': ['setjmp.h', 'CFUNCSMESS', 'F2PY_THREAD_LOCAL_DECL'],
+    'maxnofargs': '#maxnofargs#',
+    'nofoptargs': '#nofoptargs#',
+    'docstr': """\
+    def #argname#(#docsignature#): return #docreturn#\\n\\
+#docstrsigns#""",
+    'latexdocstr': """
+{{}\\verb@def #argname#(#latexdocsignature#): return #docreturn#@{}}
+#routnote#
+
+#latexdocstrsigns#""",
+    'docstrshort': 'def #argname#(#docsignature#): return #docreturn#'
+}
+cb_rout_rules = [
+    {  # Init
+        'separatorsfor': {'decl': '\n',
+                          'args': ',', 'optargs': '', 'pyobjfrom': '\n', 'freemem': '\n',
+                          'args_td': ',', 'optargs_td': '',
+                          'args_nm': ',', 'optargs_nm': '',
+                          'frompyobj': '\n', 'setdims': '\n',
+                          'docstrsigns': '\\n"\n"',
+                          'latexdocstrsigns': '\n',
+                          'latexdocstrreq': '\n', 'latexdocstropt': '\n',
+                          'latexdocstrout': '\n', 'latexdocstrcbs': '\n',
+                          },
+        'decl': '/*decl*/', 'pyobjfrom': '/*pyobjfrom*/', 'frompyobj': '/*frompyobj*/',
+        'args': [], 'optargs': '', 'return': '', 'strarglens': '', 'freemem': '/*freemem*/',
+        'args_td': [], 'optargs_td': '', 'strarglens_td': '',
+        'args_nm': [], 'optargs_nm': '', 'strarglens_nm': '',
+        'noargs': '',
+        'setdims': '/*setdims*/',
+        'docstrsigns': '', 'latexdocstrsigns': '',
+        'docstrreq': '    Required arguments:',
+        'docstropt': '    Optional arguments:',
+        'docstrout': '    Return objects:',
+        'docstrcbs': '    Call-back functions:',
+        'docreturn': '', 'docsign': '', 'docsignopt': '',
+        'latexdocstrreq': '\\noindent Required arguments:',
+        'latexdocstropt': '\\noindent Optional arguments:',
+        'latexdocstrout': '\\noindent Return objects:',
+        'latexdocstrcbs': '\\noindent Call-back functions:',
+        'routnote': {hasnote: '--- #note#', l_not(hasnote): ''},
+    }, {  # Function
+        'decl': '    #ctype# return_value = 0;',
+        'frompyobj': [
+            {debugcapi: '    CFUNCSMESS("cb:Getting return_value->");'},
+            '''\
+    if (capi_j>capi_i) {
+        GETSCALARFROMPYTUPLE(capi_return,capi_i++,&return_value,#ctype#,
+          "#ctype#_from_pyobj failed in converting return_value of"
+          " call-back function #name# to C #ctype#\\n");
+    } else {
+        fprintf(stderr,"Warning: call-back function #name# did not provide"
+                       " return value (index=%d, type=#ctype#)\\n",capi_i);
+    }''',
+            {debugcapi:
+             '    fprintf(stderr,"#showvalueformat#.\\n",return_value);'}
+        ],
+        'need': ['#ctype#_from_pyobj', {debugcapi: 'CFUNCSMESS'}, 'GETSCALARFROMPYTUPLE'],
+        'return': '    return return_value;',
+        '_check': l_and(isfunction, l_not(isstringfunction), l_not(iscomplexfunction))
+    },
+    {  # String function
+        'pyobjfrom': {debugcapi: '    fprintf(stderr,"debug-capi:cb:#name#:%d:\\n",return_value_len);'},
+        'args': '#ctype# return_value,int return_value_len',
+        'args_nm': 'return_value,&return_value_len',
+        'args_td': '#ctype# ,int',
+        'frompyobj': [
+            {debugcapi: '    CFUNCSMESS("cb:Getting return_value->\\"");'},
+            """\
+    if (capi_j>capi_i) {
+        GETSTRFROMPYTUPLE(capi_return,capi_i++,return_value,return_value_len);
+    } else {
+        fprintf(stderr,"Warning: call-back function #name# did not provide"
+                       " return value (index=%d, type=#ctype#)\\n",capi_i);
+    }""",
+            {debugcapi:
+             '    fprintf(stderr,"#showvalueformat#\\".\\n",return_value);'}
+        ],
+        'need': ['#ctype#_from_pyobj', {debugcapi: 'CFUNCSMESS'},
+                 'string.h', 'GETSTRFROMPYTUPLE'],
+        'return': 'return;',
+        '_check': isstringfunction
+    },
+    {  # Complex function
+        'optargs': """
+#ifndef F2PY_CB_RETURNCOMPLEX
+#ctype# *return_value
+#endif
+""",
+        'optargs_nm': """
+#ifndef F2PY_CB_RETURNCOMPLEX
+return_value
+#endif
+""",
+        'optargs_td': """
+#ifndef F2PY_CB_RETURNCOMPLEX
+#ctype# *
+#endif
+""",
+        'decl': """
+#ifdef F2PY_CB_RETURNCOMPLEX
+    #ctype# return_value = {0, 0};
+#endif
+""",
+        'frompyobj': [
+            {debugcapi: '    CFUNCSMESS("cb:Getting return_value->");'},
+            """\
+    if (capi_j>capi_i) {
+#ifdef F2PY_CB_RETURNCOMPLEX
+        GETSCALARFROMPYTUPLE(capi_return,capi_i++,&return_value,#ctype#,
+          \"#ctype#_from_pyobj failed in converting return_value of call-back\"
+          \" function #name# to C #ctype#\\n\");
+#else
+        GETSCALARFROMPYTUPLE(capi_return,capi_i++,return_value,#ctype#,
+          \"#ctype#_from_pyobj failed in converting return_value of call-back\"
+          \" function #name# to C #ctype#\\n\");
+#endif
+    } else {
+        fprintf(stderr,
+                \"Warning: call-back function #name# did not provide\"
+                \" return value (index=%d, type=#ctype#)\\n\",capi_i);
+    }""",
+            {debugcapi: """\
+#ifdef F2PY_CB_RETURNCOMPLEX
+    fprintf(stderr,\"#showvalueformat#.\\n\",(return_value).r,(return_value).i);
+#else
+    fprintf(stderr,\"#showvalueformat#.\\n\",(*return_value).r,(*return_value).i);
+#endif
+"""}
+        ],
+        'return': """
+#ifdef F2PY_CB_RETURNCOMPLEX
+    return return_value;
+#else
+    return;
+#endif
+""",
+        'need': ['#ctype#_from_pyobj', {debugcapi: 'CFUNCSMESS'},
+                 'string.h', 'GETSCALARFROMPYTUPLE', '#ctype#'],
+        '_check': iscomplexfunction
+    },
+    {'docstrout': '        #pydocsignout#',
+     'latexdocstrout': ['\\item[]{{}\\verb@#pydocsignout#@{}}',
+                        {hasnote: '--- #note#'}],
+     'docreturn': '#rname#,',
+     '_check': isfunction},
+    {'_check': issubroutine, 'return': 'return;'}
+]
+
+cb_arg_rules = [
+    {  # Doc
+        'docstropt': {l_and(isoptional, isintent_nothide): '        #pydocsign#'},
+        'docstrreq': {l_and(isrequired, isintent_nothide): '        #pydocsign#'},
+        'docstrout': {isintent_out: '        #pydocsignout#'},
+        'latexdocstropt': {l_and(isoptional, isintent_nothide): ['\\item[]{{}\\verb@#pydocsign#@{}}',
+                                                                 {hasnote: '--- #note#'}]},
+        'latexdocstrreq': {l_and(isrequired, isintent_nothide): ['\\item[]{{}\\verb@#pydocsign#@{}}',
+                                                                 {hasnote: '--- #note#'}]},
+        'latexdocstrout': {isintent_out: ['\\item[]{{}\\verb@#pydocsignout#@{}}',
+                                          {l_and(hasnote, isintent_hide): '--- #note#',
+                                           l_and(hasnote, isintent_nothide): '--- See above.'}]},
+        'docsign': {l_and(isrequired, isintent_nothide): '#varname#,'},
+        'docsignopt': {l_and(isoptional, isintent_nothide): '#varname#,'},
+        'depend': ''
+    },
+    {
+        'args': {
+            l_and(isscalar, isintent_c): '#ctype# #varname_i#',
+            l_and(isscalar, l_not(isintent_c)): '#ctype# *#varname_i#_cb_capi',
+            isarray: '#ctype# *#varname_i#',
+            isstring: '#ctype# #varname_i#'
+        },
+        'args_nm': {
+            l_and(isscalar, isintent_c): '#varname_i#',
+            l_and(isscalar, l_not(isintent_c)): '#varname_i#_cb_capi',
+            isarray: '#varname_i#',
+            isstring: '#varname_i#'
+        },
+        'args_td': {
+            l_and(isscalar, isintent_c): '#ctype#',
+            l_and(isscalar, l_not(isintent_c)): '#ctype# *',
+            isarray: '#ctype# *',
+            isstring: '#ctype#'
+        },
+        'need': {l_or(isscalar, isarray, isstring): '#ctype#'},
+        # untested with multiple args
+        'strarglens': {isstring: ',int #varname_i#_cb_len'},
+        'strarglens_td': {isstring: ',int'},  # untested with multiple args
+        # untested with multiple args
+        'strarglens_nm': {isstring: ',#varname_i#_cb_len'},
+    },
+    {  # Scalars
+        'decl': {l_not(isintent_c): '    #ctype# #varname_i#=(*#varname_i#_cb_capi);'},
+        'error': {l_and(isintent_c, isintent_out,
+                        throw_error('intent(c,out) is forbidden for callback scalar arguments')):
+                  ''},
+        'frompyobj': [{debugcapi: '    CFUNCSMESS("cb:Getting #varname#->");'},
+                      {isintent_out:
+                       '    if (capi_j>capi_i)\n        GETSCALARFROMPYTUPLE(capi_return,capi_i++,#varname_i#_cb_capi,#ctype#,"#ctype#_from_pyobj failed in converting argument #varname# of call-back function #name# to C #ctype#\\n");'},
+                      {l_and(debugcapi, l_and(l_not(iscomplex), isintent_c)):
+                          '    fprintf(stderr,"#showvalueformat#.\\n",#varname_i#);'},
+                      {l_and(debugcapi, l_and(l_not(iscomplex), l_not( isintent_c))):
+                          '    fprintf(stderr,"#showvalueformat#.\\n",*#varname_i#_cb_capi);'},
+                      {l_and(debugcapi, l_and(iscomplex, isintent_c)):
+                          '    fprintf(stderr,"#showvalueformat#.\\n",(#varname_i#).r,(#varname_i#).i);'},
+                      {l_and(debugcapi, l_and(iscomplex, l_not( isintent_c))):
+                          '    fprintf(stderr,"#showvalueformat#.\\n",(*#varname_i#_cb_capi).r,(*#varname_i#_cb_capi).i);'},
+                      ],
+        'need': [{isintent_out: ['#ctype#_from_pyobj', 'GETSCALARFROMPYTUPLE']},
+                 {debugcapi: 'CFUNCSMESS'}],
+        '_check': isscalar
+    }, {
+        'pyobjfrom': [{isintent_in: """\
+    if (cb->nofargs>capi_i)
+        if (CAPI_ARGLIST_SETITEM(capi_i++,pyobj_from_#ctype#1(#varname_i#)))
+            goto capi_fail;"""},
+                      {isintent_inout: """\
+    if (cb->nofargs>capi_i)
+        if (CAPI_ARGLIST_SETITEM(capi_i++,pyarr_from_p_#ctype#1(#varname_i#_cb_capi)))
+            goto capi_fail;"""}],
+        'need': [{isintent_in: 'pyobj_from_#ctype#1'},
+                 {isintent_inout: 'pyarr_from_p_#ctype#1'},
+                 {iscomplex: '#ctype#'}],
+        '_check': l_and(isscalar, isintent_nothide),
+        '_optional': ''
+    }, {  # String
+        'frompyobj': [{debugcapi: '    CFUNCSMESS("cb:Getting #varname#->\\"");'},
+                      """    if (capi_j>capi_i)
+        GETSTRFROMPYTUPLE(capi_return,capi_i++,#varname_i#,#varname_i#_cb_len);""",
+                      {debugcapi:
+                       '    fprintf(stderr,"#showvalueformat#\\":%d:.\\n",#varname_i#,#varname_i#_cb_len);'},
+                      ],
+        'need': ['#ctype#', 'GETSTRFROMPYTUPLE',
+                 {debugcapi: 'CFUNCSMESS'}, 'string.h'],
+        '_check': l_and(isstring, isintent_out)
+    }, {
+        'pyobjfrom': [
+            {debugcapi:
+             ('    fprintf(stderr,"debug-capi:cb:#varname#=#showvalueformat#:'
+              '%d:\\n",#varname_i#,#varname_i#_cb_len);')},
+            {isintent_in: """\
+    if (cb->nofargs>capi_i)
+        if (CAPI_ARGLIST_SETITEM(capi_i++,pyobj_from_#ctype#1size(#varname_i#,#varname_i#_cb_len)))
+            goto capi_fail;"""},
+                      {isintent_inout: """\
+    if (cb->nofargs>capi_i) {
+        int #varname_i#_cb_dims[] = {#varname_i#_cb_len};
+        if (CAPI_ARGLIST_SETITEM(capi_i++,pyarr_from_p_#ctype#1(#varname_i#,#varname_i#_cb_dims)))
+            goto capi_fail;
+    }"""}],
+        'need': [{isintent_in: 'pyobj_from_#ctype#1size'},
+                 {isintent_inout: 'pyarr_from_p_#ctype#1'}],
+        '_check': l_and(isstring, isintent_nothide),
+        '_optional': ''
+    },
+    # Array ...
+    {
+        'decl': '    npy_intp #varname_i#_Dims[#rank#] = {#rank*[-1]#};',
+        'setdims': '    #cbsetdims#;',
+        '_check': isarray,
+        '_depend': ''
+    },
+    {
+        'pyobjfrom': [{debugcapi: '    fprintf(stderr,"debug-capi:cb:#varname#\\n");'},
+                      {isintent_c: """\
+    if (cb->nofargs>capi_i) {
+        /* tmp_arr will be inserted to capi_arglist_list that will be
+           destroyed when leaving callback function wrapper together
+           with tmp_arr. */
+        PyArrayObject *tmp_arr = (PyArrayObject *)PyArray_New(&PyArray_Type,
+          #rank#,#varname_i#_Dims,#atype#,NULL,(char*)#varname_i#,#elsize#,
+          NPY_ARRAY_CARRAY,NULL);
+""",
+                       l_not(isintent_c): """\
+    if (cb->nofargs>capi_i) {
+        /* tmp_arr will be inserted to capi_arglist_list that will be
+           destroyed when leaving callback function wrapper together
+           with tmp_arr. */
+        PyArrayObject *tmp_arr = (PyArrayObject *)PyArray_New(&PyArray_Type,
+          #rank#,#varname_i#_Dims,#atype#,NULL,(char*)#varname_i#,#elsize#,
+          NPY_ARRAY_FARRAY,NULL);
+""",
+                       },
+                      """
+        if (tmp_arr==NULL)
+            goto capi_fail;
+        if (CAPI_ARGLIST_SETITEM(capi_i++,(PyObject *)tmp_arr))
+            goto capi_fail;
+}"""],
+        '_check': l_and(isarray, isintent_nothide, l_or(isintent_in, isintent_inout)),
+        '_optional': '',
+    }, {
+        'frompyobj': [{debugcapi: '    CFUNCSMESS("cb:Getting #varname#->");'},
+                      """    if (capi_j>capi_i) {
+        PyArrayObject *rv_cb_arr = NULL;
+        if ((capi_tmp = PyTuple_GetItem(capi_return,capi_i++))==NULL) goto capi_fail;
+        rv_cb_arr =  array_from_pyobj(#atype#,#varname_i#_Dims,#rank#,F2PY_INTENT_IN""",
+                      {isintent_c: '|F2PY_INTENT_C'},
+                      """,capi_tmp);
+        if (rv_cb_arr == NULL) {
+            fprintf(stderr,\"rv_cb_arr is NULL\\n\");
+            goto capi_fail;
+        }
+        MEMCOPY(#varname_i#,PyArray_DATA(rv_cb_arr),PyArray_NBYTES(rv_cb_arr));
+        if (capi_tmp != (PyObject *)rv_cb_arr) {
+            Py_DECREF(rv_cb_arr);
+        }
+    }""",
+                      {debugcapi: '    fprintf(stderr,"<-.\\n");'},
+                      ],
+        'need': ['MEMCOPY', {iscomplexarray: '#ctype#'}],
+        '_check': l_and(isarray, isintent_out)
+    }, {
+        'docreturn': '#varname#,',
+        '_check': isintent_out
+    }
+]
+
+################## Build call-back module #############
+cb_map = {}
+
+
+def buildcallbacks(m):
+    cb_map[m['name']] = []
+    for bi in m['body']:
+        if bi['block'] == 'interface':
+            for b in bi['body']:
+                if b:
+                    buildcallback(b, m['name'])
+                else:
+                    errmess('warning: empty body for %s\n' % (m['name']))
+
+
+def buildcallback(rout, um):
+    from . import capi_maps
+
+    outmess('    Constructing call-back function "cb_%s_in_%s"\n' %
+            (rout['name'], um))
+    args, depargs = getargs(rout)
+    capi_maps.depargs = depargs
+    var = rout['vars']
+    vrd = capi_maps.cb_routsign2map(rout, um)
+    rd = dictappend({}, vrd)
+    cb_map[um].append([rout['name'], rd['name']])
+    for r in cb_rout_rules:
+        if ('_check' in r and r['_check'](rout)) or ('_check' not in r):
+            ar = applyrules(r, vrd, rout)
+            rd = dictappend(rd, ar)
+    savevrd = {}
+    for i, a in enumerate(args):
+        vrd = capi_maps.cb_sign2map(a, var[a], index=i)
+        savevrd[a] = vrd
+        for r in cb_arg_rules:
+            if '_depend' in r:
+                continue
+            if '_optional' in r and isoptional(var[a]):
+                continue
+            if ('_check' in r and r['_check'](var[a])) or ('_check' not in r):
+                ar = applyrules(r, vrd, var[a])
+                rd = dictappend(rd, ar)
+                if '_break' in r:
+                    break
+    for a in args:
+        vrd = savevrd[a]
+        for r in cb_arg_rules:
+            if '_depend' in r:
+                continue
+            if ('_optional' not in r) or ('_optional' in r and isrequired(var[a])):
+                continue
+            if ('_check' in r and r['_check'](var[a])) or ('_check' not in r):
+                ar = applyrules(r, vrd, var[a])
+                rd = dictappend(rd, ar)
+                if '_break' in r:
+                    break
+    for a in depargs:
+        vrd = savevrd[a]
+        for r in cb_arg_rules:
+            if '_depend' not in r:
+                continue
+            if '_optional' in r:
+                continue
+            if ('_check' in r and r['_check'](var[a])) or ('_check' not in r):
+                ar = applyrules(r, vrd, var[a])
+                rd = dictappend(rd, ar)
+                if '_break' in r:
+                    break
+    if 'args' in rd and 'optargs' in rd:
+        if isinstance(rd['optargs'], list):
+            rd['optargs'] = rd['optargs'] + ["""
+#ifndef F2PY_CB_RETURNCOMPLEX
+,
+#endif
+"""]
+            rd['optargs_nm'] = rd['optargs_nm'] + ["""
+#ifndef F2PY_CB_RETURNCOMPLEX
+,
+#endif
+"""]
+            rd['optargs_td'] = rd['optargs_td'] + ["""
+#ifndef F2PY_CB_RETURNCOMPLEX
+,
+#endif
+"""]
+    if isinstance(rd['docreturn'], list):
+        rd['docreturn'] = stripcomma(
+            replace('#docreturn#', {'docreturn': rd['docreturn']}))
+    optargs = stripcomma(replace('#docsignopt#',
+                                 {'docsignopt': rd['docsignopt']}
+                                 ))
+    if optargs == '':
+        rd['docsignature'] = stripcomma(
+            replace('#docsign#', {'docsign': rd['docsign']}))
+    else:
+        rd['docsignature'] = replace('#docsign#[#docsignopt#]',
+                                     {'docsign': rd['docsign'],
+                                      'docsignopt': optargs,
+                                      })
+    rd['latexdocsignature'] = rd['docsignature'].replace('_', '\\_')
+    rd['latexdocsignature'] = rd['latexdocsignature'].replace(',', ', ')
+    rd['docstrsigns'] = []
+    rd['latexdocstrsigns'] = []
+    for k in ['docstrreq', 'docstropt', 'docstrout', 'docstrcbs']:
+        if k in rd and isinstance(rd[k], list):
+            rd['docstrsigns'] = rd['docstrsigns'] + rd[k]
+        k = 'latex' + k
+        if k in rd and isinstance(rd[k], list):
+            rd['latexdocstrsigns'] = rd['latexdocstrsigns'] + rd[k][0:1] +\
+                ['\\begin{description}'] + rd[k][1:] +\
+                ['\\end{description}']
+    if 'args' not in rd:
+        rd['args'] = ''
+        rd['args_td'] = ''
+        rd['args_nm'] = ''
+    if not (rd.get('args') or rd.get('optargs') or rd.get('strarglens')):
+        rd['noargs'] = 'void'
+
+    ar = applyrules(cb_routine_rules, rd)
+    cfuncs.callbacks[rd['name']] = ar['body']
+    if isinstance(ar['need'], str):
+        ar['need'] = [ar['need']]
+
+    if 'need' in rd:
+        for t in cfuncs.typedefs.keys():
+            if t in rd['need']:
+                ar['need'].append(t)
+
+    cfuncs.typedefs_generated[rd['name'] + '_typedef'] = ar['cbtypedefs']
+    ar['need'].append(rd['name'] + '_typedef')
+    cfuncs.needs[rd['name']] = ar['need']
+
+    capi_maps.lcb2_map[rd['name']] = {'maxnofargs': ar['maxnofargs'],
+                                      'nofoptargs': ar['nofoptargs'],
+                                      'docstr': ar['docstr'],
+                                      'latexdocstr': ar['latexdocstr'],
+                                      'argname': rd['argname']
+                                      }
+    outmess('      %s\n' % (ar['docstrshort']))
+    return
+################## Build call-back function #############
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/cfuncs.py b/venv/lib/python3.12/site-packages/numpy/f2py/cfuncs.py
new file mode 100644
index 00000000..1dc32473
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/cfuncs.py
@@ -0,0 +1,1545 @@
+#!/usr/bin/env python3
+"""
+C declarations, CPP macros, and C functions for f2py2e.
+Only required declarations/macros/functions will be used.
+
+Copyright 1999 -- 2011 Pearu Peterson all rights reserved.
+Copyright 2011 -- present NumPy Developers.
+Permission to use, modify, and distribute this software is given under the
+terms of the NumPy License.
+
+NO WARRANTY IS EXPRESSED OR IMPLIED.  USE AT YOUR OWN RISK.
+"""
+import sys
+import copy
+
+from . import __version__
+
+f2py_version = __version__.version
+
+
+def errmess(s: str) -> None:
+    """
+    Write an error message to stderr.
+
+    This indirection is needed because sys.stderr might not always be available (see #26862).
+    """
+    if sys.stderr is not None:
+        sys.stderr.write(s)
+
+##################### Definitions ##################
+
+outneeds = {'includes0': [], 'includes': [], 'typedefs': [], 'typedefs_generated': [],
+            'userincludes': [],
+            'cppmacros': [], 'cfuncs': [], 'callbacks': [], 'f90modhooks': [],
+            'commonhooks': []}
+needs = {}
+includes0 = {'includes0': '/*need_includes0*/'}
+includes = {'includes': '/*need_includes*/'}
+userincludes = {'userincludes': '/*need_userincludes*/'}
+typedefs = {'typedefs': '/*need_typedefs*/'}
+typedefs_generated = {'typedefs_generated': '/*need_typedefs_generated*/'}
+cppmacros = {'cppmacros': '/*need_cppmacros*/'}
+cfuncs = {'cfuncs': '/*need_cfuncs*/'}
+callbacks = {'callbacks': '/*need_callbacks*/'}
+f90modhooks = {'f90modhooks': '/*need_f90modhooks*/',
+               'initf90modhooksstatic': '/*initf90modhooksstatic*/',
+               'initf90modhooksdynamic': '/*initf90modhooksdynamic*/',
+               }
+commonhooks = {'commonhooks': '/*need_commonhooks*/',
+               'initcommonhooks': '/*need_initcommonhooks*/',
+               }
+
+############ Includes ###################
+
+includes0['math.h'] = '#include '
+includes0['string.h'] = '#include '
+includes0['setjmp.h'] = '#include '
+
+includes['arrayobject.h'] = '''#define PY_ARRAY_UNIQUE_SYMBOL PyArray_API
+#include "arrayobject.h"'''
+includes['npy_math.h'] = '#include "numpy/npy_math.h"'
+
+includes['arrayobject.h'] = '#include "fortranobject.h"'
+includes['stdarg.h'] = '#include '
+
+############# Type definitions ###############
+
+typedefs['unsigned_char'] = 'typedef unsigned char unsigned_char;'
+typedefs['unsigned_short'] = 'typedef unsigned short unsigned_short;'
+typedefs['unsigned_long'] = 'typedef unsigned long unsigned_long;'
+typedefs['signed_char'] = 'typedef signed char signed_char;'
+typedefs['long_long'] = """
+#if defined(NPY_OS_WIN32)
+typedef __int64 long_long;
+#else
+typedef long long long_long;
+typedef unsigned long long unsigned_long_long;
+#endif
+"""
+typedefs['unsigned_long_long'] = """
+#if defined(NPY_OS_WIN32)
+typedef __uint64 long_long;
+#else
+typedef unsigned long long unsigned_long_long;
+#endif
+"""
+typedefs['long_double'] = """
+#ifndef _LONG_DOUBLE
+typedef long double long_double;
+#endif
+"""
+typedefs[
+    'complex_long_double'] = 'typedef struct {long double r,i;} complex_long_double;'
+typedefs['complex_float'] = 'typedef struct {float r,i;} complex_float;'
+typedefs['complex_double'] = 'typedef struct {double r,i;} complex_double;'
+typedefs['string'] = """typedef char * string;"""
+typedefs['character'] = """typedef char character;"""
+
+
+############### CPP macros ####################
+cppmacros['CFUNCSMESS'] = """
+#ifdef DEBUGCFUNCS
+#define CFUNCSMESS(mess) fprintf(stderr,\"debug-capi:\"mess);
+#define CFUNCSMESSPY(mess,obj) CFUNCSMESS(mess) \\
+    PyObject_Print((PyObject *)obj,stderr,Py_PRINT_RAW);\\
+    fprintf(stderr,\"\\n\");
+#else
+#define CFUNCSMESS(mess)
+#define CFUNCSMESSPY(mess,obj)
+#endif
+"""
+cppmacros['F_FUNC'] = """
+#if defined(PREPEND_FORTRAN)
+#if defined(NO_APPEND_FORTRAN)
+#if defined(UPPERCASE_FORTRAN)
+#define F_FUNC(f,F) _##F
+#else
+#define F_FUNC(f,F) _##f
+#endif
+#else
+#if defined(UPPERCASE_FORTRAN)
+#define F_FUNC(f,F) _##F##_
+#else
+#define F_FUNC(f,F) _##f##_
+#endif
+#endif
+#else
+#if defined(NO_APPEND_FORTRAN)
+#if defined(UPPERCASE_FORTRAN)
+#define F_FUNC(f,F) F
+#else
+#define F_FUNC(f,F) f
+#endif
+#else
+#if defined(UPPERCASE_FORTRAN)
+#define F_FUNC(f,F) F##_
+#else
+#define F_FUNC(f,F) f##_
+#endif
+#endif
+#endif
+#if defined(UNDERSCORE_G77)
+#define F_FUNC_US(f,F) F_FUNC(f##_,F##_)
+#else
+#define F_FUNC_US(f,F) F_FUNC(f,F)
+#endif
+"""
+cppmacros['F_WRAPPEDFUNC'] = """
+#if defined(PREPEND_FORTRAN)
+#if defined(NO_APPEND_FORTRAN)
+#if defined(UPPERCASE_FORTRAN)
+#define F_WRAPPEDFUNC(f,F) _F2PYWRAP##F
+#else
+#define F_WRAPPEDFUNC(f,F) _f2pywrap##f
+#endif
+#else
+#if defined(UPPERCASE_FORTRAN)
+#define F_WRAPPEDFUNC(f,F) _F2PYWRAP##F##_
+#else
+#define F_WRAPPEDFUNC(f,F) _f2pywrap##f##_
+#endif
+#endif
+#else
+#if defined(NO_APPEND_FORTRAN)
+#if defined(UPPERCASE_FORTRAN)
+#define F_WRAPPEDFUNC(f,F) F2PYWRAP##F
+#else
+#define F_WRAPPEDFUNC(f,F) f2pywrap##f
+#endif
+#else
+#if defined(UPPERCASE_FORTRAN)
+#define F_WRAPPEDFUNC(f,F) F2PYWRAP##F##_
+#else
+#define F_WRAPPEDFUNC(f,F) f2pywrap##f##_
+#endif
+#endif
+#endif
+#if defined(UNDERSCORE_G77)
+#define F_WRAPPEDFUNC_US(f,F) F_WRAPPEDFUNC(f##_,F##_)
+#else
+#define F_WRAPPEDFUNC_US(f,F) F_WRAPPEDFUNC(f,F)
+#endif
+"""
+cppmacros['F_MODFUNC'] = """
+#if defined(F90MOD2CCONV1) /*E.g. Compaq Fortran */
+#if defined(NO_APPEND_FORTRAN)
+#define F_MODFUNCNAME(m,f) $ ## m ## $ ## f
+#else
+#define F_MODFUNCNAME(m,f) $ ## m ## $ ## f ## _
+#endif
+#endif
+
+#if defined(F90MOD2CCONV2) /*E.g. IBM XL Fortran, not tested though */
+#if defined(NO_APPEND_FORTRAN)
+#define F_MODFUNCNAME(m,f)  __ ## m ## _MOD_ ## f
+#else
+#define F_MODFUNCNAME(m,f)  __ ## m ## _MOD_ ## f ## _
+#endif
+#endif
+
+#if defined(F90MOD2CCONV3) /*E.g. MIPSPro Compilers */
+#if defined(NO_APPEND_FORTRAN)
+#define F_MODFUNCNAME(m,f)  f ## .in. ## m
+#else
+#define F_MODFUNCNAME(m,f)  f ## .in. ## m ## _
+#endif
+#endif
+/*
+#if defined(UPPERCASE_FORTRAN)
+#define F_MODFUNC(m,M,f,F) F_MODFUNCNAME(M,F)
+#else
+#define F_MODFUNC(m,M,f,F) F_MODFUNCNAME(m,f)
+#endif
+*/
+
+#define F_MODFUNC(m,f) (*(f2pymodstruct##m##.##f))
+"""
+cppmacros['SWAPUNSAFE'] = """
+#define SWAP(a,b) (size_t)(a) = ((size_t)(a) ^ (size_t)(b));\\
+ (size_t)(b) = ((size_t)(a) ^ (size_t)(b));\\
+ (size_t)(a) = ((size_t)(a) ^ (size_t)(b))
+"""
+cppmacros['SWAP'] = """
+#define SWAP(a,b,t) {\\
+    t *c;\\
+    c = a;\\
+    a = b;\\
+    b = c;}
+"""
+# cppmacros['ISCONTIGUOUS']='#define ISCONTIGUOUS(m) (PyArray_FLAGS(m) &
+# NPY_ARRAY_C_CONTIGUOUS)'
+cppmacros['PRINTPYOBJERR'] = """
+#define PRINTPYOBJERR(obj)\\
+    fprintf(stderr,\"#modulename#.error is related to \");\\
+    PyObject_Print((PyObject *)obj,stderr,Py_PRINT_RAW);\\
+    fprintf(stderr,\"\\n\");
+"""
+cppmacros['MINMAX'] = """
+#ifndef max
+#define max(a,b) ((a > b) ? (a) : (b))
+#endif
+#ifndef min
+#define min(a,b) ((a < b) ? (a) : (b))
+#endif
+#ifndef MAX
+#define MAX(a,b) ((a > b) ? (a) : (b))
+#endif
+#ifndef MIN
+#define MIN(a,b) ((a < b) ? (a) : (b))
+#endif
+"""
+cppmacros['len..'] = """
+/* See fortranobject.h for definitions. The macros here are provided for BC. */
+#define rank f2py_rank
+#define shape f2py_shape
+#define fshape f2py_shape
+#define len f2py_len
+#define flen f2py_flen
+#define slen f2py_slen
+#define size f2py_size
+"""
+cppmacros['pyobj_from_char1'] = r"""
+#define pyobj_from_char1(v) (PyLong_FromLong(v))
+"""
+cppmacros['pyobj_from_short1'] = r"""
+#define pyobj_from_short1(v) (PyLong_FromLong(v))
+"""
+needs['pyobj_from_int1'] = ['signed_char']
+cppmacros['pyobj_from_int1'] = r"""
+#define pyobj_from_int1(v) (PyLong_FromLong(v))
+"""
+cppmacros['pyobj_from_long1'] = r"""
+#define pyobj_from_long1(v) (PyLong_FromLong(v))
+"""
+needs['pyobj_from_long_long1'] = ['long_long']
+cppmacros['pyobj_from_long_long1'] = """
+#ifdef HAVE_LONG_LONG
+#define pyobj_from_long_long1(v) (PyLong_FromLongLong(v))
+#else
+#warning HAVE_LONG_LONG is not available. Redefining pyobj_from_long_long.
+#define pyobj_from_long_long1(v) (PyLong_FromLong(v))
+#endif
+"""
+needs['pyobj_from_long_double1'] = ['long_double']
+cppmacros['pyobj_from_long_double1'] = """
+#define pyobj_from_long_double1(v) (PyFloat_FromDouble(v))"""
+cppmacros['pyobj_from_double1'] = """
+#define pyobj_from_double1(v) (PyFloat_FromDouble(v))"""
+cppmacros['pyobj_from_float1'] = """
+#define pyobj_from_float1(v) (PyFloat_FromDouble(v))"""
+needs['pyobj_from_complex_long_double1'] = ['complex_long_double']
+cppmacros['pyobj_from_complex_long_double1'] = """
+#define pyobj_from_complex_long_double1(v) (PyComplex_FromDoubles(v.r,v.i))"""
+needs['pyobj_from_complex_double1'] = ['complex_double']
+cppmacros['pyobj_from_complex_double1'] = """
+#define pyobj_from_complex_double1(v) (PyComplex_FromDoubles(v.r,v.i))"""
+needs['pyobj_from_complex_float1'] = ['complex_float']
+cppmacros['pyobj_from_complex_float1'] = """
+#define pyobj_from_complex_float1(v) (PyComplex_FromDoubles(v.r,v.i))"""
+needs['pyobj_from_string1'] = ['string']
+cppmacros['pyobj_from_string1'] = """
+#define pyobj_from_string1(v) (PyUnicode_FromString((char *)v))"""
+needs['pyobj_from_string1size'] = ['string']
+cppmacros['pyobj_from_string1size'] = """
+#define pyobj_from_string1size(v,len) (PyUnicode_FromStringAndSize((char *)v, len))"""
+needs['TRYPYARRAYTEMPLATE'] = ['PRINTPYOBJERR']
+cppmacros['TRYPYARRAYTEMPLATE'] = """
+/* New SciPy */
+#define TRYPYARRAYTEMPLATECHAR case NPY_STRING: *(char *)(PyArray_DATA(arr))=*v; break;
+#define TRYPYARRAYTEMPLATELONG case NPY_LONG: *(long *)(PyArray_DATA(arr))=*v; break;
+#define TRYPYARRAYTEMPLATEOBJECT case NPY_OBJECT: PyArray_SETITEM(arr,PyArray_DATA(arr),pyobj_from_ ## ctype ## 1(*v)); break;
+
+#define TRYPYARRAYTEMPLATE(ctype,typecode) \\
+        PyArrayObject *arr = NULL;\\
+        if (!obj) return -2;\\
+        if (!PyArray_Check(obj)) return -1;\\
+        if (!(arr=(PyArrayObject *)obj)) {fprintf(stderr,\"TRYPYARRAYTEMPLATE:\");PRINTPYOBJERR(obj);return 0;}\\
+        if (PyArray_DESCR(arr)->type==typecode)  {*(ctype *)(PyArray_DATA(arr))=*v; return 1;}\\
+        switch (PyArray_TYPE(arr)) {\\
+                case NPY_DOUBLE: *(npy_double *)(PyArray_DATA(arr))=*v; break;\\
+                case NPY_INT: *(npy_int *)(PyArray_DATA(arr))=*v; break;\\
+                case NPY_LONG: *(npy_long *)(PyArray_DATA(arr))=*v; break;\\
+                case NPY_FLOAT: *(npy_float *)(PyArray_DATA(arr))=*v; break;\\
+                case NPY_CDOUBLE: *(npy_double *)(PyArray_DATA(arr))=*v; break;\\
+                case NPY_CFLOAT: *(npy_float *)(PyArray_DATA(arr))=*v; break;\\
+                case NPY_BOOL: *(npy_bool *)(PyArray_DATA(arr))=(*v!=0); break;\\
+                case NPY_UBYTE: *(npy_ubyte *)(PyArray_DATA(arr))=*v; break;\\
+                case NPY_BYTE: *(npy_byte *)(PyArray_DATA(arr))=*v; break;\\
+                case NPY_SHORT: *(npy_short *)(PyArray_DATA(arr))=*v; break;\\
+                case NPY_USHORT: *(npy_ushort *)(PyArray_DATA(arr))=*v; break;\\
+                case NPY_UINT: *(npy_uint *)(PyArray_DATA(arr))=*v; break;\\
+                case NPY_ULONG: *(npy_ulong *)(PyArray_DATA(arr))=*v; break;\\
+                case NPY_LONGLONG: *(npy_longlong *)(PyArray_DATA(arr))=*v; break;\\
+                case NPY_ULONGLONG: *(npy_ulonglong *)(PyArray_DATA(arr))=*v; break;\\
+                case NPY_LONGDOUBLE: *(npy_longdouble *)(PyArray_DATA(arr))=*v; break;\\
+                case NPY_CLONGDOUBLE: *(npy_longdouble *)(PyArray_DATA(arr))=*v; break;\\
+                case NPY_OBJECT: PyArray_SETITEM(arr, PyArray_DATA(arr), pyobj_from_ ## ctype ## 1(*v)); break;\\
+        default: return -2;\\
+        };\\
+        return 1
+"""
+
+needs['TRYCOMPLEXPYARRAYTEMPLATE'] = ['PRINTPYOBJERR']
+cppmacros['TRYCOMPLEXPYARRAYTEMPLATE'] = """
+#define TRYCOMPLEXPYARRAYTEMPLATEOBJECT case NPY_OBJECT: PyArray_SETITEM(arr, PyArray_DATA(arr), pyobj_from_complex_ ## ctype ## 1((*v))); break;
+#define TRYCOMPLEXPYARRAYTEMPLATE(ctype,typecode)\\
+        PyArrayObject *arr = NULL;\\
+        if (!obj) return -2;\\
+        if (!PyArray_Check(obj)) return -1;\\
+        if (!(arr=(PyArrayObject *)obj)) {fprintf(stderr,\"TRYCOMPLEXPYARRAYTEMPLATE:\");PRINTPYOBJERR(obj);return 0;}\\
+        if (PyArray_DESCR(arr)->type==typecode) {\\
+            *(ctype *)(PyArray_DATA(arr))=(*v).r;\\
+            *(ctype *)(PyArray_DATA(arr)+sizeof(ctype))=(*v).i;\\
+            return 1;\\
+        }\\
+        switch (PyArray_TYPE(arr)) {\\
+                case NPY_CDOUBLE: *(npy_double *)(PyArray_DATA(arr))=(*v).r;\\
+                                  *(npy_double *)(PyArray_DATA(arr)+sizeof(npy_double))=(*v).i;\\
+                                  break;\\
+                case NPY_CFLOAT: *(npy_float *)(PyArray_DATA(arr))=(*v).r;\\
+                                 *(npy_float *)(PyArray_DATA(arr)+sizeof(npy_float))=(*v).i;\\
+                                 break;\\
+                case NPY_DOUBLE: *(npy_double *)(PyArray_DATA(arr))=(*v).r; break;\\
+                case NPY_LONG: *(npy_long *)(PyArray_DATA(arr))=(*v).r; break;\\
+                case NPY_FLOAT: *(npy_float *)(PyArray_DATA(arr))=(*v).r; break;\\
+                case NPY_INT: *(npy_int *)(PyArray_DATA(arr))=(*v).r; break;\\
+                case NPY_SHORT: *(npy_short *)(PyArray_DATA(arr))=(*v).r; break;\\
+                case NPY_UBYTE: *(npy_ubyte *)(PyArray_DATA(arr))=(*v).r; break;\\
+                case NPY_BYTE: *(npy_byte *)(PyArray_DATA(arr))=(*v).r; break;\\
+                case NPY_BOOL: *(npy_bool *)(PyArray_DATA(arr))=((*v).r!=0 && (*v).i!=0); break;\\
+                case NPY_USHORT: *(npy_ushort *)(PyArray_DATA(arr))=(*v).r; break;\\
+                case NPY_UINT: *(npy_uint *)(PyArray_DATA(arr))=(*v).r; break;\\
+                case NPY_ULONG: *(npy_ulong *)(PyArray_DATA(arr))=(*v).r; break;\\
+                case NPY_LONGLONG: *(npy_longlong *)(PyArray_DATA(arr))=(*v).r; break;\\
+                case NPY_ULONGLONG: *(npy_ulonglong *)(PyArray_DATA(arr))=(*v).r; break;\\
+                case NPY_LONGDOUBLE: *(npy_longdouble *)(PyArray_DATA(arr))=(*v).r; break;\\
+                case NPY_CLONGDOUBLE: *(npy_longdouble *)(PyArray_DATA(arr))=(*v).r;\\
+                                      *(npy_longdouble *)(PyArray_DATA(arr)+sizeof(npy_longdouble))=(*v).i;\\
+                                      break;\\
+                case NPY_OBJECT: PyArray_SETITEM(arr, PyArray_DATA(arr), pyobj_from_complex_ ## ctype ## 1((*v))); break;\\
+                default: return -2;\\
+        };\\
+        return -1;
+"""
+# cppmacros['NUMFROMARROBJ']="""
+# define NUMFROMARROBJ(typenum,ctype) \\
+#     if (PyArray_Check(obj)) arr = (PyArrayObject *)obj;\\
+#     else arr = (PyArrayObject *)PyArray_ContiguousFromObject(obj,typenum,0,0);\\
+#     if (arr) {\\
+#         if (PyArray_TYPE(arr)==NPY_OBJECT) {\\
+#             if (!ctype ## _from_pyobj(v,(PyArray_DESCR(arr)->getitem)(PyArray_DATA(arr)),\"\"))\\
+#             goto capi_fail;\\
+#         } else {\\
+#             (PyArray_DESCR(arr)->cast[typenum])(PyArray_DATA(arr),1,(char*)v,1,1);\\
+#         }\\
+#         if ((PyObject *)arr != obj) { Py_DECREF(arr); }\\
+#         return 1;\\
+#     }
+# """
+# XXX: Note that CNUMFROMARROBJ is identical with NUMFROMARROBJ
+# cppmacros['CNUMFROMARROBJ']="""
+# define CNUMFROMARROBJ(typenum,ctype) \\
+#     if (PyArray_Check(obj)) arr = (PyArrayObject *)obj;\\
+#     else arr = (PyArrayObject *)PyArray_ContiguousFromObject(obj,typenum,0,0);\\
+#     if (arr) {\\
+#         if (PyArray_TYPE(arr)==NPY_OBJECT) {\\
+#             if (!ctype ## _from_pyobj(v,(PyArray_DESCR(arr)->getitem)(PyArray_DATA(arr)),\"\"))\\
+#             goto capi_fail;\\
+#         } else {\\
+#             (PyArray_DESCR(arr)->cast[typenum])((void *)(PyArray_DATA(arr)),1,(void *)(v),1,1);\\
+#         }\\
+#         if ((PyObject *)arr != obj) { Py_DECREF(arr); }\\
+#         return 1;\\
+#     }
+# """
+
+
+needs['GETSTRFROMPYTUPLE'] = ['STRINGCOPYN', 'PRINTPYOBJERR']
+cppmacros['GETSTRFROMPYTUPLE'] = """
+#define GETSTRFROMPYTUPLE(tuple,index,str,len) {\\
+        PyObject *rv_cb_str = PyTuple_GetItem((tuple),(index));\\
+        if (rv_cb_str == NULL)\\
+            goto capi_fail;\\
+        if (PyBytes_Check(rv_cb_str)) {\\
+            str[len-1]='\\0';\\
+            STRINGCOPYN((str),PyBytes_AS_STRING((PyBytesObject*)rv_cb_str),(len));\\
+        } else {\\
+            PRINTPYOBJERR(rv_cb_str);\\
+            PyErr_SetString(#modulename#_error,\"string object expected\");\\
+            goto capi_fail;\\
+        }\\
+    }
+"""
+cppmacros['GETSCALARFROMPYTUPLE'] = """
+#define GETSCALARFROMPYTUPLE(tuple,index,var,ctype,mess) {\\
+        if ((capi_tmp = PyTuple_GetItem((tuple),(index)))==NULL) goto capi_fail;\\
+        if (!(ctype ## _from_pyobj((var),capi_tmp,mess)))\\
+            goto capi_fail;\\
+    }
+"""
+
+cppmacros['FAILNULL'] = """\
+#define FAILNULL(p) do {                                            \\
+    if ((p) == NULL) {                                              \\
+        PyErr_SetString(PyExc_MemoryError, "NULL pointer found");   \\
+        goto capi_fail;                                             \\
+    }                                                               \\
+} while (0)
+"""
+needs['MEMCOPY'] = ['string.h', 'FAILNULL']
+cppmacros['MEMCOPY'] = """
+#define MEMCOPY(to,from,n)\\
+    do { FAILNULL(to); FAILNULL(from); (void)memcpy(to,from,n); } while (0)
+"""
+cppmacros['STRINGMALLOC'] = """
+#define STRINGMALLOC(str,len)\\
+    if ((str = (string)malloc(len+1)) == NULL) {\\
+        PyErr_SetString(PyExc_MemoryError, \"out of memory\");\\
+        goto capi_fail;\\
+    } else {\\
+        (str)[len] = '\\0';\\
+    }
+"""
+cppmacros['STRINGFREE'] = """
+#define STRINGFREE(str) do {if (!(str == NULL)) free(str);} while (0)
+"""
+needs['STRINGPADN'] = ['string.h']
+cppmacros['STRINGPADN'] = """
+/*
+STRINGPADN replaces null values with padding values from the right.
+
+`to` must have size of at least N bytes.
+
+If the `to[N-1]` has null value, then replace it and all the
+preceding, nulls with the given padding.
+
+STRINGPADN(to, N, PADDING, NULLVALUE) is an inverse operation.
+*/
+#define STRINGPADN(to, N, NULLVALUE, PADDING)                   \\
+    do {                                                        \\
+        int _m = (N);                                           \\
+        char *_to = (to);                                       \\
+        for (_m -= 1; _m >= 0 && _to[_m] == NULLVALUE; _m--) {  \\
+             _to[_m] = PADDING;                                 \\
+        }                                                       \\
+    } while (0)
+"""
+needs['STRINGCOPYN'] = ['string.h', 'FAILNULL']
+cppmacros['STRINGCOPYN'] = """
+/*
+STRINGCOPYN copies N bytes.
+
+`to` and `from` buffers must have sizes of at least N bytes.
+*/
+#define STRINGCOPYN(to,from,N)                                  \\
+    do {                                                        \\
+        int _m = (N);                                           \\
+        char *_to = (to);                                       \\
+        char *_from = (from);                                   \\
+        FAILNULL(_to); FAILNULL(_from);                         \\
+        (void)strncpy(_to, _from, _m);             \\
+    } while (0)
+"""
+needs['STRINGCOPY'] = ['string.h', 'FAILNULL']
+cppmacros['STRINGCOPY'] = """
+#define STRINGCOPY(to,from)\\
+    do { FAILNULL(to); FAILNULL(from); (void)strcpy(to,from); } while (0)
+"""
+cppmacros['CHECKGENERIC'] = """
+#define CHECKGENERIC(check,tcheck,name) \\
+    if (!(check)) {\\
+        PyErr_SetString(#modulename#_error,\"(\"tcheck\") failed for \"name);\\
+        /*goto capi_fail;*/\\
+    } else """
+cppmacros['CHECKARRAY'] = """
+#define CHECKARRAY(check,tcheck,name) \\
+    if (!(check)) {\\
+        PyErr_SetString(#modulename#_error,\"(\"tcheck\") failed for \"name);\\
+        /*goto capi_fail;*/\\
+    } else """
+cppmacros['CHECKSTRING'] = """
+#define CHECKSTRING(check,tcheck,name,show,var)\\
+    if (!(check)) {\\
+        char errstring[256];\\
+        sprintf(errstring, \"%s: \"show, \"(\"tcheck\") failed for \"name, slen(var), var);\\
+        PyErr_SetString(#modulename#_error, errstring);\\
+        /*goto capi_fail;*/\\
+    } else """
+cppmacros['CHECKSCALAR'] = """
+#define CHECKSCALAR(check,tcheck,name,show,var)\\
+    if (!(check)) {\\
+        char errstring[256];\\
+        sprintf(errstring, \"%s: \"show, \"(\"tcheck\") failed for \"name, var);\\
+        PyErr_SetString(#modulename#_error,errstring);\\
+        /*goto capi_fail;*/\\
+    } else """
+# cppmacros['CHECKDIMS']="""
+# define CHECKDIMS(dims,rank) \\
+#     for (int i=0;i<(rank);i++)\\
+#         if (dims[i]<0) {\\
+#             fprintf(stderr,\"Unspecified array argument requires a complete dimension specification.\\n\");\\
+#             goto capi_fail;\\
+#         }
+# """
+cppmacros[
+    'ARRSIZE'] = '#define ARRSIZE(dims,rank) (_PyArray_multiply_list(dims,rank))'
+cppmacros['OLDPYNUM'] = """
+#ifdef OLDPYNUM
+#error You need to install NumPy version 0.13 or higher. See https://scipy.org/install.html
+#endif
+"""
+cppmacros["F2PY_THREAD_LOCAL_DECL"] = """
+#ifndef F2PY_THREAD_LOCAL_DECL
+#if defined(_MSC_VER)
+#define F2PY_THREAD_LOCAL_DECL __declspec(thread)
+#elif defined(NPY_OS_MINGW)
+#define F2PY_THREAD_LOCAL_DECL __thread
+#elif defined(__STDC_VERSION__) \\
+      && (__STDC_VERSION__ >= 201112L) \\
+      && !defined(__STDC_NO_THREADS__) \\
+      && (!defined(__GLIBC__) || __GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ > 12)) \\
+      && !defined(NPY_OS_OPENBSD) && !defined(NPY_OS_HAIKU)
+/* __STDC_NO_THREADS__ was first defined in a maintenance release of glibc 2.12,
+   see https://lists.gnu.org/archive/html/commit-hurd/2012-07/msg00180.html,
+   so `!defined(__STDC_NO_THREADS__)` may give false positive for the existence
+   of `threads.h` when using an older release of glibc 2.12
+   See gh-19437 for details on OpenBSD */
+#include 
+#define F2PY_THREAD_LOCAL_DECL thread_local
+#elif defined(__GNUC__) \\
+      && (__GNUC__ > 4 || (__GNUC__ == 4 && (__GNUC_MINOR__ >= 4)))
+#define F2PY_THREAD_LOCAL_DECL __thread
+#endif
+#endif
+"""
+################# C functions ###############
+
+cfuncs['calcarrindex'] = """
+static int calcarrindex(int *i,PyArrayObject *arr) {
+    int k,ii = i[0];
+    for (k=1; k < PyArray_NDIM(arr); k++)
+        ii += (ii*(PyArray_DIM(arr,k) - 1)+i[k]); /* assuming contiguous arr */
+    return ii;
+}"""
+cfuncs['calcarrindextr'] = """
+static int calcarrindextr(int *i,PyArrayObject *arr) {
+    int k,ii = i[PyArray_NDIM(arr)-1];
+    for (k=1; k < PyArray_NDIM(arr); k++)
+        ii += (ii*(PyArray_DIM(arr,PyArray_NDIM(arr)-k-1) - 1)+i[PyArray_NDIM(arr)-k-1]); /* assuming contiguous arr */
+    return ii;
+}"""
+cfuncs['forcomb'] = """
+static struct { int nd;npy_intp *d;int *i,*i_tr,tr; } forcombcache;
+static int initforcomb(npy_intp *dims,int nd,int tr) {
+  int k;
+  if (dims==NULL) return 0;
+  if (nd<0) return 0;
+  forcombcache.nd = nd;
+  forcombcache.d = dims;
+  forcombcache.tr = tr;
+  if ((forcombcache.i = (int *)malloc(sizeof(int)*nd))==NULL) return 0;
+  if ((forcombcache.i_tr = (int *)malloc(sizeof(int)*nd))==NULL) return 0;
+  for (k=1;k PyArray_NBYTES(arr)) {
+            n = PyArray_NBYTES(arr);
+        }
+        STRINGCOPYN(buf, str, n);
+        return 1;
+    }
+capi_fail:
+    PRINTPYOBJERR(obj);
+    PyErr_SetString(#modulename#_error, \"try_pyarr_from_string failed\");
+    return 0;
+}
+"""
+needs['string_from_pyobj'] = ['string', 'STRINGMALLOC', 'STRINGCOPYN']
+cfuncs['string_from_pyobj'] = """
+/*
+  Create a new string buffer `str` of at most length `len` from a
+  Python string-like object `obj`.
+
+  The string buffer has given size (len) or the size of inistr when len==-1.
+
+  The string buffer is padded with blanks: in Fortran, trailing blanks
+  are insignificant contrary to C nulls.
+ */
+static int
+string_from_pyobj(string *str, int *len, const string inistr, PyObject *obj,
+                  const char *errmess)
+{
+    PyObject *tmp = NULL;
+    string buf = NULL;
+    npy_intp n = -1;
+#ifdef DEBUGCFUNCS
+fprintf(stderr,\"string_from_pyobj(str='%s',len=%d,inistr='%s',obj=%p)\\n\",
+               (char*)str, *len, (char *)inistr, obj);
+#endif
+    if (obj == Py_None) {
+        n = strlen(inistr);
+        buf = inistr;
+    }
+    else if (PyArray_Check(obj)) {
+        PyArrayObject *arr = (PyArrayObject *)obj;
+        if (!ISCONTIGUOUS(arr)) {
+            PyErr_SetString(PyExc_ValueError,
+                            \"array object is non-contiguous.\");
+            goto capi_fail;
+        }
+        n = PyArray_NBYTES(arr);
+        buf = PyArray_DATA(arr);
+        n = strnlen(buf, n);
+    }
+    else {
+        if (PyBytes_Check(obj)) {
+            tmp = obj;
+            Py_INCREF(tmp);
+        }
+        else if (PyUnicode_Check(obj)) {
+            tmp = PyUnicode_AsASCIIString(obj);
+        }
+        else {
+            PyObject *tmp2;
+            tmp2 = PyObject_Str(obj);
+            if (tmp2) {
+                tmp = PyUnicode_AsASCIIString(tmp2);
+                Py_DECREF(tmp2);
+            }
+            else {
+                tmp = NULL;
+            }
+        }
+        if (tmp == NULL) goto capi_fail;
+        n = PyBytes_GET_SIZE(tmp);
+        buf = PyBytes_AS_STRING(tmp);
+    }
+    if (*len == -1) {
+        /* TODO: change the type of `len` so that we can remove this */
+        if (n > NPY_MAX_INT) {
+            PyErr_SetString(PyExc_OverflowError,
+                            "object too large for a 32-bit int");
+            goto capi_fail;
+        }
+        *len = n;
+    }
+    else if (*len < n) {
+        /* discard the last (len-n) bytes of input buf */
+        n = *len;
+    }
+    if (n < 0 || *len < 0 || buf == NULL) {
+        goto capi_fail;
+    }
+    STRINGMALLOC(*str, *len);  // *str is allocated with size (*len + 1)
+    if (n < *len) {
+        /*
+          Pad fixed-width string with nulls. The caller will replace
+          nulls with blanks when the corresponding argument is not
+          intent(c).
+        */
+        memset(*str + n, '\\0', *len - n);
+    }
+    STRINGCOPYN(*str, buf, n);
+    Py_XDECREF(tmp);
+    return 1;
+capi_fail:
+    Py_XDECREF(tmp);
+    {
+        PyObject* err = PyErr_Occurred();
+        if (err == NULL) {
+            err = #modulename#_error;
+        }
+        PyErr_SetString(err, errmess);
+    }
+    return 0;
+}
+"""
+
+cfuncs['character_from_pyobj'] = """
+static int
+character_from_pyobj(character* v, PyObject *obj, const char *errmess) {
+    if (PyBytes_Check(obj)) {
+        /* empty bytes has trailing null, so dereferencing is always safe */
+        *v = PyBytes_AS_STRING(obj)[0];
+        return 1;
+    } else if (PyUnicode_Check(obj)) {
+        PyObject* tmp = PyUnicode_AsASCIIString(obj);
+        if (tmp != NULL) {
+            *v = PyBytes_AS_STRING(tmp)[0];
+            Py_DECREF(tmp);
+            return 1;
+        }
+    } else if (PyArray_Check(obj)) {
+        PyArrayObject* arr = (PyArrayObject*)obj;
+        if (F2PY_ARRAY_IS_CHARACTER_COMPATIBLE(arr)) {
+            *v = PyArray_BYTES(arr)[0];
+            return 1;
+        } else if (F2PY_IS_UNICODE_ARRAY(arr)) {
+            // TODO: update when numpy will support 1-byte and
+            // 2-byte unicode dtypes
+            PyObject* tmp = PyUnicode_FromKindAndData(
+                              PyUnicode_4BYTE_KIND,
+                              PyArray_BYTES(arr),
+                              (PyArray_NBYTES(arr)>0?1:0));
+            if (tmp != NULL) {
+                if (character_from_pyobj(v, tmp, errmess)) {
+                    Py_DECREF(tmp);
+                    return 1;
+                }
+                Py_DECREF(tmp);
+            }
+        }
+    } else if (PySequence_Check(obj)) {
+        PyObject* tmp = PySequence_GetItem(obj,0);
+        if (tmp != NULL) {
+            if (character_from_pyobj(v, tmp, errmess)) {
+                Py_DECREF(tmp);
+                return 1;
+            }
+            Py_DECREF(tmp);
+        }
+    }
+    {
+        /* TODO: This error (and most other) error handling needs cleaning. */
+        char mess[F2PY_MESSAGE_BUFFER_SIZE];
+        strcpy(mess, errmess);
+        PyObject* err = PyErr_Occurred();
+        if (err == NULL) {
+            err = PyExc_TypeError;
+            Py_INCREF(err);
+        }
+        else {
+            Py_INCREF(err);
+            PyErr_Clear();
+        }
+        sprintf(mess + strlen(mess),
+                " -- expected str|bytes|sequence-of-str-or-bytes, got ");
+        f2py_describe(obj, mess + strlen(mess));
+        PyErr_SetString(err, mess);
+        Py_DECREF(err);
+    }
+    return 0;
+}
+"""
+
+# TODO: These should be dynamically generated, too many mapped to int things,
+# see note in _isocbind.py
+needs['char_from_pyobj'] = ['int_from_pyobj']
+cfuncs['char_from_pyobj'] = """
+static int
+char_from_pyobj(char* v, PyObject *obj, const char *errmess) {
+    int i = 0;
+    if (int_from_pyobj(&i, obj, errmess)) {
+        *v = (char)i;
+        return 1;
+    }
+    return 0;
+}
+"""
+
+
+needs['signed_char_from_pyobj'] = ['int_from_pyobj', 'signed_char']
+cfuncs['signed_char_from_pyobj'] = """
+static int
+signed_char_from_pyobj(signed_char* v, PyObject *obj, const char *errmess) {
+    int i = 0;
+    if (int_from_pyobj(&i, obj, errmess)) {
+        *v = (signed_char)i;
+        return 1;
+    }
+    return 0;
+}
+"""
+
+
+needs['short_from_pyobj'] = ['int_from_pyobj']
+cfuncs['short_from_pyobj'] = """
+static int
+short_from_pyobj(short* v, PyObject *obj, const char *errmess) {
+    int i = 0;
+    if (int_from_pyobj(&i, obj, errmess)) {
+        *v = (short)i;
+        return 1;
+    }
+    return 0;
+}
+"""
+
+
+cfuncs['int_from_pyobj'] = """
+static int
+int_from_pyobj(int* v, PyObject *obj, const char *errmess)
+{
+    PyObject* tmp = NULL;
+
+    if (PyLong_Check(obj)) {
+        *v = Npy__PyLong_AsInt(obj);
+        return !(*v == -1 && PyErr_Occurred());
+    }
+
+    tmp = PyNumber_Long(obj);
+    if (tmp) {
+        *v = Npy__PyLong_AsInt(tmp);
+        Py_DECREF(tmp);
+        return !(*v == -1 && PyErr_Occurred());
+    }
+
+    if (PyComplex_Check(obj)) {
+        PyErr_Clear();
+        tmp = PyObject_GetAttrString(obj,\"real\");
+    }
+    else if (PyBytes_Check(obj) || PyUnicode_Check(obj)) {
+        /*pass*/;
+    }
+    else if (PySequence_Check(obj)) {
+        PyErr_Clear();
+        tmp = PySequence_GetItem(obj, 0);
+    }
+
+    if (tmp) {
+        if (int_from_pyobj(v, tmp, errmess)) {
+            Py_DECREF(tmp);
+            return 1;
+        }
+        Py_DECREF(tmp);
+    }
+
+    {
+        PyObject* err = PyErr_Occurred();
+        if (err == NULL) {
+            err = #modulename#_error;
+        }
+        PyErr_SetString(err, errmess);
+    }
+    return 0;
+}
+"""
+
+
+cfuncs['long_from_pyobj'] = """
+static int
+long_from_pyobj(long* v, PyObject *obj, const char *errmess) {
+    PyObject* tmp = NULL;
+
+    if (PyLong_Check(obj)) {
+        *v = PyLong_AsLong(obj);
+        return !(*v == -1 && PyErr_Occurred());
+    }
+
+    tmp = PyNumber_Long(obj);
+    if (tmp) {
+        *v = PyLong_AsLong(tmp);
+        Py_DECREF(tmp);
+        return !(*v == -1 && PyErr_Occurred());
+    }
+
+    if (PyComplex_Check(obj)) {
+        PyErr_Clear();
+        tmp = PyObject_GetAttrString(obj,\"real\");
+    }
+    else if (PyBytes_Check(obj) || PyUnicode_Check(obj)) {
+        /*pass*/;
+    }
+    else if (PySequence_Check(obj)) {
+        PyErr_Clear();
+        tmp = PySequence_GetItem(obj, 0);
+    }
+
+    if (tmp) {
+        if (long_from_pyobj(v, tmp, errmess)) {
+            Py_DECREF(tmp);
+            return 1;
+        }
+        Py_DECREF(tmp);
+    }
+    {
+        PyObject* err = PyErr_Occurred();
+        if (err == NULL) {
+            err = #modulename#_error;
+        }
+        PyErr_SetString(err, errmess);
+    }
+    return 0;
+}
+"""
+
+
+needs['long_long_from_pyobj'] = ['long_long']
+cfuncs['long_long_from_pyobj'] = """
+static int
+long_long_from_pyobj(long_long* v, PyObject *obj, const char *errmess)
+{
+    PyObject* tmp = NULL;
+
+    if (PyLong_Check(obj)) {
+        *v = PyLong_AsLongLong(obj);
+        return !(*v == -1 && PyErr_Occurred());
+    }
+
+    tmp = PyNumber_Long(obj);
+    if (tmp) {
+        *v = PyLong_AsLongLong(tmp);
+        Py_DECREF(tmp);
+        return !(*v == -1 && PyErr_Occurred());
+    }
+
+    if (PyComplex_Check(obj)) {
+        PyErr_Clear();
+        tmp = PyObject_GetAttrString(obj,\"real\");
+    }
+    else if (PyBytes_Check(obj) || PyUnicode_Check(obj)) {
+        /*pass*/;
+    }
+    else if (PySequence_Check(obj)) {
+        PyErr_Clear();
+        tmp = PySequence_GetItem(obj, 0);
+    }
+
+    if (tmp) {
+        if (long_long_from_pyobj(v, tmp, errmess)) {
+            Py_DECREF(tmp);
+            return 1;
+        }
+        Py_DECREF(tmp);
+    }
+    {
+        PyObject* err = PyErr_Occurred();
+        if (err == NULL) {
+            err = #modulename#_error;
+        }
+        PyErr_SetString(err,errmess);
+    }
+    return 0;
+}
+"""
+
+
+needs['long_double_from_pyobj'] = ['double_from_pyobj', 'long_double']
+cfuncs['long_double_from_pyobj'] = """
+static int
+long_double_from_pyobj(long_double* v, PyObject *obj, const char *errmess)
+{
+    double d=0;
+    if (PyArray_CheckScalar(obj)){
+        if PyArray_IsScalar(obj, LongDouble) {
+            PyArray_ScalarAsCtype(obj, v);
+            return 1;
+        }
+        else if (PyArray_Check(obj) && PyArray_TYPE(obj) == NPY_LONGDOUBLE) {
+            (*v) = *((npy_longdouble *)PyArray_DATA(obj));
+            return 1;
+        }
+    }
+    if (double_from_pyobj(&d, obj, errmess)) {
+        *v = (long_double)d;
+        return 1;
+    }
+    return 0;
+}
+"""
+
+
+cfuncs['double_from_pyobj'] = """
+static int
+double_from_pyobj(double* v, PyObject *obj, const char *errmess)
+{
+    PyObject* tmp = NULL;
+    if (PyFloat_Check(obj)) {
+        *v = PyFloat_AsDouble(obj);
+        return !(*v == -1.0 && PyErr_Occurred());
+    }
+
+    tmp = PyNumber_Float(obj);
+    if (tmp) {
+        *v = PyFloat_AsDouble(tmp);
+        Py_DECREF(tmp);
+        return !(*v == -1.0 && PyErr_Occurred());
+    }
+
+    if (PyComplex_Check(obj)) {
+        PyErr_Clear();
+        tmp = PyObject_GetAttrString(obj,\"real\");
+    }
+    else if (PyBytes_Check(obj) || PyUnicode_Check(obj)) {
+        /*pass*/;
+    }
+    else if (PySequence_Check(obj)) {
+        PyErr_Clear();
+        tmp = PySequence_GetItem(obj, 0);
+    }
+
+    if (tmp) {
+        if (double_from_pyobj(v,tmp,errmess)) {Py_DECREF(tmp); return 1;}
+        Py_DECREF(tmp);
+    }
+    {
+        PyObject* err = PyErr_Occurred();
+        if (err==NULL) err = #modulename#_error;
+        PyErr_SetString(err,errmess);
+    }
+    return 0;
+}
+"""
+
+
+needs['float_from_pyobj'] = ['double_from_pyobj']
+cfuncs['float_from_pyobj'] = """
+static int
+float_from_pyobj(float* v, PyObject *obj, const char *errmess)
+{
+    double d=0.0;
+    if (double_from_pyobj(&d,obj,errmess)) {
+        *v = (float)d;
+        return 1;
+    }
+    return 0;
+}
+"""
+
+
+needs['complex_long_double_from_pyobj'] = ['complex_long_double', 'long_double',
+                                           'complex_double_from_pyobj', 'npy_math.h']
+cfuncs['complex_long_double_from_pyobj'] = """
+static int
+complex_long_double_from_pyobj(complex_long_double* v, PyObject *obj, const char *errmess)
+{
+    complex_double cd = {0.0,0.0};
+    if (PyArray_CheckScalar(obj)){
+        if PyArray_IsScalar(obj, CLongDouble) {
+            PyArray_ScalarAsCtype(obj, v);
+            return 1;
+        }
+        else if (PyArray_Check(obj) && PyArray_TYPE(obj)==NPY_CLONGDOUBLE) {
+            (*v).r = npy_creall(*(((npy_clongdouble *)PyArray_DATA(obj))));
+            (*v).i = npy_cimagl(*(((npy_clongdouble *)PyArray_DATA(obj))));
+            return 1;
+        }
+    }
+    if (complex_double_from_pyobj(&cd,obj,errmess)) {
+        (*v).r = (long_double)cd.r;
+        (*v).i = (long_double)cd.i;
+        return 1;
+    }
+    return 0;
+}
+"""
+
+
+needs['complex_double_from_pyobj'] = ['complex_double', 'npy_math.h']
+cfuncs['complex_double_from_pyobj'] = """
+static int
+complex_double_from_pyobj(complex_double* v, PyObject *obj, const char *errmess) {
+    Py_complex c;
+    if (PyComplex_Check(obj)) {
+        c = PyComplex_AsCComplex(obj);
+        (*v).r = c.real;
+        (*v).i = c.imag;
+        return 1;
+    }
+    if (PyArray_IsScalar(obj, ComplexFloating)) {
+        if (PyArray_IsScalar(obj, CFloat)) {
+            npy_cfloat new;
+            PyArray_ScalarAsCtype(obj, &new);
+            (*v).r = (double)npy_crealf(new);
+            (*v).i = (double)npy_cimagf(new);
+        }
+        else if (PyArray_IsScalar(obj, CLongDouble)) {
+            npy_clongdouble new;
+            PyArray_ScalarAsCtype(obj, &new);
+            (*v).r = (double)npy_creall(new);
+            (*v).i = (double)npy_cimagl(new);
+        }
+        else { /* if (PyArray_IsScalar(obj, CDouble)) */
+            PyArray_ScalarAsCtype(obj, v);
+        }
+        return 1;
+    }
+    if (PyArray_CheckScalar(obj)) { /* 0-dim array or still array scalar */
+        PyArrayObject *arr;
+        if (PyArray_Check(obj)) {
+            arr = (PyArrayObject *)PyArray_Cast((PyArrayObject *)obj, NPY_CDOUBLE);
+        }
+        else {
+            arr = (PyArrayObject *)PyArray_FromScalar(obj, PyArray_DescrFromType(NPY_CDOUBLE));
+        }
+        if (arr == NULL) {
+            return 0;
+        }
+        (*v).r = npy_creal(*(((npy_cdouble *)PyArray_DATA(arr))));
+        (*v).i = npy_cimag(*(((npy_cdouble *)PyArray_DATA(arr))));
+        Py_DECREF(arr);
+        return 1;
+    }
+    /* Python does not provide PyNumber_Complex function :-( */
+    (*v).i = 0.0;
+    if (PyFloat_Check(obj)) {
+        (*v).r = PyFloat_AsDouble(obj);
+        return !((*v).r == -1.0 && PyErr_Occurred());
+    }
+    if (PyLong_Check(obj)) {
+        (*v).r = PyLong_AsDouble(obj);
+        return !((*v).r == -1.0 && PyErr_Occurred());
+    }
+    if (PySequence_Check(obj) && !(PyBytes_Check(obj) || PyUnicode_Check(obj))) {
+        PyObject *tmp = PySequence_GetItem(obj,0);
+        if (tmp) {
+            if (complex_double_from_pyobj(v,tmp,errmess)) {
+                Py_DECREF(tmp);
+                return 1;
+            }
+            Py_DECREF(tmp);
+        }
+    }
+    {
+        PyObject* err = PyErr_Occurred();
+        if (err==NULL)
+            err = PyExc_TypeError;
+        PyErr_SetString(err,errmess);
+    }
+    return 0;
+}
+"""
+
+
+needs['complex_float_from_pyobj'] = [
+    'complex_float', 'complex_double_from_pyobj']
+cfuncs['complex_float_from_pyobj'] = """
+static int
+complex_float_from_pyobj(complex_float* v,PyObject *obj,const char *errmess)
+{
+    complex_double cd={0.0,0.0};
+    if (complex_double_from_pyobj(&cd,obj,errmess)) {
+        (*v).r = (float)cd.r;
+        (*v).i = (float)cd.i;
+        return 1;
+    }
+    return 0;
+}
+"""
+
+
+cfuncs['try_pyarr_from_character'] = """
+static int try_pyarr_from_character(PyObject* obj, character* v) {
+    PyArrayObject *arr = (PyArrayObject*)obj;
+    if (!obj) return -2;
+    if (PyArray_Check(obj)) {
+        if (F2PY_ARRAY_IS_CHARACTER_COMPATIBLE(arr))  {
+            *(character *)(PyArray_DATA(arr)) = *v;
+            return 1;
+        }
+    }
+    {
+        char mess[F2PY_MESSAGE_BUFFER_SIZE];
+        PyObject* err = PyErr_Occurred();
+        if (err == NULL) {
+            err = PyExc_ValueError;
+            strcpy(mess, "try_pyarr_from_character failed"
+                         " -- expected bytes array-scalar|array, got ");
+            f2py_describe(obj, mess + strlen(mess));
+            PyErr_SetString(err, mess);
+        }
+    }
+    return 0;
+}
+"""
+
+needs['try_pyarr_from_char'] = ['pyobj_from_char1', 'TRYPYARRAYTEMPLATE']
+cfuncs[
+    'try_pyarr_from_char'] = 'static int try_pyarr_from_char(PyObject* obj,char* v) {\n    TRYPYARRAYTEMPLATE(char,\'c\');\n}\n'
+needs['try_pyarr_from_signed_char'] = ['TRYPYARRAYTEMPLATE', 'unsigned_char']
+cfuncs[
+    'try_pyarr_from_unsigned_char'] = 'static int try_pyarr_from_unsigned_char(PyObject* obj,unsigned_char* v) {\n    TRYPYARRAYTEMPLATE(unsigned_char,\'b\');\n}\n'
+needs['try_pyarr_from_signed_char'] = ['TRYPYARRAYTEMPLATE', 'signed_char']
+cfuncs[
+    'try_pyarr_from_signed_char'] = 'static int try_pyarr_from_signed_char(PyObject* obj,signed_char* v) {\n    TRYPYARRAYTEMPLATE(signed_char,\'1\');\n}\n'
+needs['try_pyarr_from_short'] = ['pyobj_from_short1', 'TRYPYARRAYTEMPLATE']
+cfuncs[
+    'try_pyarr_from_short'] = 'static int try_pyarr_from_short(PyObject* obj,short* v) {\n    TRYPYARRAYTEMPLATE(short,\'s\');\n}\n'
+needs['try_pyarr_from_int'] = ['pyobj_from_int1', 'TRYPYARRAYTEMPLATE']
+cfuncs[
+    'try_pyarr_from_int'] = 'static int try_pyarr_from_int(PyObject* obj,int* v) {\n    TRYPYARRAYTEMPLATE(int,\'i\');\n}\n'
+needs['try_pyarr_from_long'] = ['pyobj_from_long1', 'TRYPYARRAYTEMPLATE']
+cfuncs[
+    'try_pyarr_from_long'] = 'static int try_pyarr_from_long(PyObject* obj,long* v) {\n    TRYPYARRAYTEMPLATE(long,\'l\');\n}\n'
+needs['try_pyarr_from_long_long'] = [
+    'pyobj_from_long_long1', 'TRYPYARRAYTEMPLATE', 'long_long']
+cfuncs[
+    'try_pyarr_from_long_long'] = 'static int try_pyarr_from_long_long(PyObject* obj,long_long* v) {\n    TRYPYARRAYTEMPLATE(long_long,\'L\');\n}\n'
+needs['try_pyarr_from_float'] = ['pyobj_from_float1', 'TRYPYARRAYTEMPLATE']
+cfuncs[
+    'try_pyarr_from_float'] = 'static int try_pyarr_from_float(PyObject* obj,float* v) {\n    TRYPYARRAYTEMPLATE(float,\'f\');\n}\n'
+needs['try_pyarr_from_double'] = ['pyobj_from_double1', 'TRYPYARRAYTEMPLATE']
+cfuncs[
+    'try_pyarr_from_double'] = 'static int try_pyarr_from_double(PyObject* obj,double* v) {\n    TRYPYARRAYTEMPLATE(double,\'d\');\n}\n'
+needs['try_pyarr_from_complex_float'] = [
+    'pyobj_from_complex_float1', 'TRYCOMPLEXPYARRAYTEMPLATE', 'complex_float']
+cfuncs[
+    'try_pyarr_from_complex_float'] = 'static int try_pyarr_from_complex_float(PyObject* obj,complex_float* v) {\n    TRYCOMPLEXPYARRAYTEMPLATE(float,\'F\');\n}\n'
+needs['try_pyarr_from_complex_double'] = [
+    'pyobj_from_complex_double1', 'TRYCOMPLEXPYARRAYTEMPLATE', 'complex_double']
+cfuncs[
+    'try_pyarr_from_complex_double'] = 'static int try_pyarr_from_complex_double(PyObject* obj,complex_double* v) {\n    TRYCOMPLEXPYARRAYTEMPLATE(double,\'D\');\n}\n'
+
+
+needs['create_cb_arglist'] = ['CFUNCSMESS', 'PRINTPYOBJERR', 'MINMAX']
+# create the list of arguments to be used when calling back to python
+cfuncs['create_cb_arglist'] = """
+static int
+create_cb_arglist(PyObject* fun, PyTupleObject* xa , const int maxnofargs,
+                  const int nofoptargs, int *nofargs, PyTupleObject **args,
+                  const char *errmess)
+{
+    PyObject *tmp = NULL;
+    PyObject *tmp_fun = NULL;
+    Py_ssize_t tot, opt, ext, siz, i, di = 0;
+    CFUNCSMESS(\"create_cb_arglist\\n\");
+    tot=opt=ext=siz=0;
+    /* Get the total number of arguments */
+    if (PyFunction_Check(fun)) {
+        tmp_fun = fun;
+        Py_INCREF(tmp_fun);
+    }
+    else {
+        di = 1;
+        if (PyObject_HasAttrString(fun,\"im_func\")) {
+            tmp_fun = PyObject_GetAttrString(fun,\"im_func\");
+        }
+        else if (PyObject_HasAttrString(fun,\"__call__\")) {
+            tmp = PyObject_GetAttrString(fun,\"__call__\");
+            if (PyObject_HasAttrString(tmp,\"im_func\"))
+                tmp_fun = PyObject_GetAttrString(tmp,\"im_func\");
+            else {
+                tmp_fun = fun; /* built-in function */
+                Py_INCREF(tmp_fun);
+                tot = maxnofargs;
+                if (PyCFunction_Check(fun)) {
+                    /* In case the function has a co_argcount (like on PyPy) */
+                    di = 0;
+                }
+                if (xa != NULL)
+                    tot += PyTuple_Size((PyObject *)xa);
+            }
+            Py_XDECREF(tmp);
+        }
+        else if (PyFortran_Check(fun) || PyFortran_Check1(fun)) {
+            tot = maxnofargs;
+            if (xa != NULL)
+                tot += PyTuple_Size((PyObject *)xa);
+            tmp_fun = fun;
+            Py_INCREF(tmp_fun);
+        }
+        else if (F2PyCapsule_Check(fun)) {
+            tot = maxnofargs;
+            if (xa != NULL)
+                ext = PyTuple_Size((PyObject *)xa);
+            if(ext>0) {
+                fprintf(stderr,\"extra arguments tuple cannot be used with PyCapsule call-back\\n\");
+                goto capi_fail;
+            }
+            tmp_fun = fun;
+            Py_INCREF(tmp_fun);
+        }
+    }
+
+    if (tmp_fun == NULL) {
+        fprintf(stderr,
+                \"Call-back argument must be function|instance|instance.__call__|f2py-function \"
+                \"but got %s.\\n\",
+                ((fun == NULL) ? \"NULL\" : Py_TYPE(fun)->tp_name));
+        goto capi_fail;
+    }
+
+    if (PyObject_HasAttrString(tmp_fun,\"__code__\")) {
+        if (PyObject_HasAttrString(tmp = PyObject_GetAttrString(tmp_fun,\"__code__\"),\"co_argcount\")) {
+            PyObject *tmp_argcount = PyObject_GetAttrString(tmp,\"co_argcount\");
+            Py_DECREF(tmp);
+            if (tmp_argcount == NULL) {
+                goto capi_fail;
+            }
+            tot = PyLong_AsSsize_t(tmp_argcount) - di;
+            Py_DECREF(tmp_argcount);
+        }
+    }
+    /* Get the number of optional arguments */
+    if (PyObject_HasAttrString(tmp_fun,\"__defaults__\")) {
+        if (PyTuple_Check(tmp = PyObject_GetAttrString(tmp_fun,\"__defaults__\")))
+            opt = PyTuple_Size(tmp);
+        Py_XDECREF(tmp);
+    }
+    /* Get the number of extra arguments */
+    if (xa != NULL)
+        ext = PyTuple_Size((PyObject *)xa);
+    /* Calculate the size of call-backs argument list */
+    siz = MIN(maxnofargs+ext,tot);
+    *nofargs = MAX(0,siz-ext);
+
+#ifdef DEBUGCFUNCS
+    fprintf(stderr,
+            \"debug-capi:create_cb_arglist:maxnofargs(-nofoptargs),\"
+            \"tot,opt,ext,siz,nofargs = %d(-%d), %zd, %zd, %zd, %zd, %d\\n\",
+            maxnofargs, nofoptargs, tot, opt, ext, siz, *nofargs);
+#endif
+
+    if (siz < tot-opt) {
+        fprintf(stderr,
+                \"create_cb_arglist: Failed to build argument list \"
+                \"(siz) with enough arguments (tot-opt) required by \"
+                \"user-supplied function (siz,tot,opt=%zd, %zd, %zd).\\n\",
+                siz, tot, opt);
+        goto capi_fail;
+    }
+
+    /* Initialize argument list */
+    *args = (PyTupleObject *)PyTuple_New(siz);
+    for (i=0;i<*nofargs;i++) {
+        Py_INCREF(Py_None);
+        PyTuple_SET_ITEM((PyObject *)(*args),i,Py_None);
+    }
+    if (xa != NULL)
+        for (i=(*nofargs);i 0:
+            if outneeds[n][0] not in needs:
+                out.append(outneeds[n][0])
+                del outneeds[n][0]
+            else:
+                flag = 0
+                for k in outneeds[n][1:]:
+                    if k in needs[outneeds[n][0]]:
+                        flag = 1
+                        break
+                if flag:
+                    outneeds[n] = outneeds[n][1:] + [outneeds[n][0]]
+                else:
+                    out.append(outneeds[n][0])
+                    del outneeds[n][0]
+            if saveout and (0 not in map(lambda x, y: x == y, saveout, outneeds[n])) \
+                    and outneeds[n] != []:
+                print(n, saveout)
+                errmess(
+                    'get_needs: no progress in sorting needs, probably circular dependence, skipping.\n')
+                out = out + saveout
+                break
+            saveout = copy.copy(outneeds[n])
+        if out == []:
+            out = [n]
+        res[n] = out
+    return res
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/common_rules.py b/venv/lib/python3.12/site-packages/numpy/f2py/common_rules.py
new file mode 100644
index 00000000..64347b73
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/common_rules.py
@@ -0,0 +1,146 @@
+"""
+Build common block mechanism for f2py2e.
+
+Copyright 1999 -- 2011 Pearu Peterson all rights reserved.
+Copyright 2011 -- present NumPy Developers.
+Permission to use, modify, and distribute this software is given under the
+terms of the NumPy License
+
+NO WARRANTY IS EXPRESSED OR IMPLIED.  USE AT YOUR OWN RISK.
+"""
+from . import __version__
+f2py_version = __version__.version
+
+from .auxfuncs import (
+    hasbody, hascommon, hasnote, isintent_hide, outmess, getuseblocks
+)
+from . import capi_maps
+from . import func2subr
+from .crackfortran import rmbadname
+
+
+def findcommonblocks(block, top=1):
+    ret = []
+    if hascommon(block):
+        for key, value in block['common'].items():
+            vars_ = {v: block['vars'][v] for v in value}
+            ret.append((key, value, vars_))
+    elif hasbody(block):
+        for b in block['body']:
+            ret = ret + findcommonblocks(b, 0)
+    if top:
+        tret = []
+        names = []
+        for t in ret:
+            if t[0] not in names:
+                names.append(t[0])
+                tret.append(t)
+        return tret
+    return ret
+
+
+def buildhooks(m):
+    ret = {'commonhooks': [], 'initcommonhooks': [],
+           'docs': ['"COMMON blocks:\\n"']}
+    fwrap = ['']
+
+    def fadd(line, s=fwrap):
+        s[0] = '%s\n      %s' % (s[0], line)
+    chooks = ['']
+
+    def cadd(line, s=chooks):
+        s[0] = '%s\n%s' % (s[0], line)
+    ihooks = ['']
+
+    def iadd(line, s=ihooks):
+        s[0] = '%s\n%s' % (s[0], line)
+    doc = ['']
+
+    def dadd(line, s=doc):
+        s[0] = '%s\n%s' % (s[0], line)
+    for (name, vnames, vars) in findcommonblocks(m):
+        lower_name = name.lower()
+        hnames, inames = [], []
+        for n in vnames:
+            if isintent_hide(vars[n]):
+                hnames.append(n)
+            else:
+                inames.append(n)
+        if hnames:
+            outmess('\t\tConstructing COMMON block support for "%s"...\n\t\t  %s\n\t\t  Hidden: %s\n' % (
+                name, ','.join(inames), ','.join(hnames)))
+        else:
+            outmess('\t\tConstructing COMMON block support for "%s"...\n\t\t  %s\n' % (
+                name, ','.join(inames)))
+        fadd('subroutine f2pyinit%s(setupfunc)' % name)
+        for usename in getuseblocks(m):
+            fadd(f'use {usename}')
+        fadd('external setupfunc')
+        for n in vnames:
+            fadd(func2subr.var2fixfortran(vars, n))
+        if name == '_BLNK_':
+            fadd('common %s' % (','.join(vnames)))
+        else:
+            fadd('common /%s/ %s' % (name, ','.join(vnames)))
+        fadd('call setupfunc(%s)' % (','.join(inames)))
+        fadd('end\n')
+        cadd('static FortranDataDef f2py_%s_def[] = {' % (name))
+        idims = []
+        for n in inames:
+            ct = capi_maps.getctype(vars[n])
+            elsize = capi_maps.get_elsize(vars[n])
+            at = capi_maps.c2capi_map[ct]
+            dm = capi_maps.getarrdims(n, vars[n])
+            if dm['dims']:
+                idims.append('(%s)' % (dm['dims']))
+            else:
+                idims.append('')
+            dms = dm['dims'].strip()
+            if not dms:
+                dms = '-1'
+            cadd('\t{\"%s\",%s,{{%s}},%s, %s},'
+                 % (n, dm['rank'], dms, at, elsize))
+        cadd('\t{NULL}\n};')
+        inames1 = rmbadname(inames)
+        inames1_tps = ','.join(['char *' + s for s in inames1])
+        cadd('static void f2py_setup_%s(%s) {' % (name, inames1_tps))
+        cadd('\tint i_f2py=0;')
+        for n in inames1:
+            cadd('\tf2py_%s_def[i_f2py++].data = %s;' % (name, n))
+        cadd('}')
+        if '_' in lower_name:
+            F_FUNC = 'F_FUNC_US'
+        else:
+            F_FUNC = 'F_FUNC'
+        cadd('extern void %s(f2pyinit%s,F2PYINIT%s)(void(*)(%s));'
+             % (F_FUNC, lower_name, name.upper(),
+                ','.join(['char*'] * len(inames1))))
+        cadd('static void f2py_init_%s(void) {' % name)
+        cadd('\t%s(f2pyinit%s,F2PYINIT%s)(f2py_setup_%s);'
+             % (F_FUNC, lower_name, name.upper(), name))
+        cadd('}\n')
+        iadd('\ttmp = PyFortranObject_New(f2py_%s_def,f2py_init_%s);' % (name, name))
+        iadd('\tif (tmp == NULL) return NULL;')
+        iadd('\tif (F2PyDict_SetItemString(d, \"%s\", tmp) == -1) return NULL;'
+             % name)
+        iadd('\tPy_DECREF(tmp);')
+        tname = name.replace('_', '\\_')
+        dadd('\\subsection{Common block \\texttt{%s}}\n' % (tname))
+        dadd('\\begin{description}')
+        for n in inames:
+            dadd('\\item[]{{}\\verb@%s@{}}' %
+                 (capi_maps.getarrdocsign(n, vars[n])))
+            if hasnote(vars[n]):
+                note = vars[n]['note']
+                if isinstance(note, list):
+                    note = '\n'.join(note)
+                dadd('--- %s' % (note))
+        dadd('\\end{description}')
+        ret['docs'].append(
+            '"\t/%s/ %s\\n"' % (name, ','.join(map(lambda v, d: v + d, inames, idims))))
+    ret['commonhooks'] = chooks
+    ret['initcommonhooks'] = ihooks
+    ret['latexdoc'] = doc[0]
+    if len(ret['docs']) <= 1:
+        ret['docs'] = ''
+    return ret, fwrap[0]
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/crackfortran.py b/venv/lib/python3.12/site-packages/numpy/f2py/crackfortran.py
new file mode 100755
index 00000000..68ef46c0
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/crackfortran.py
@@ -0,0 +1,3755 @@
+#!/usr/bin/env python3
+"""
+crackfortran --- read fortran (77,90) code and extract declaration information.
+
+Copyright 1999 -- 2011 Pearu Peterson all rights reserved.
+Copyright 2011 -- present NumPy Developers.
+Permission to use, modify, and distribute this software is given under the
+terms of the NumPy License.
+
+NO WARRANTY IS EXPRESSED OR IMPLIED.  USE AT YOUR OWN RISK.
+
+
+Usage of crackfortran:
+======================
+Command line keys: -quiet,-verbose,-fix,-f77,-f90,-show,-h 
+                   -m ,--ignore-contains
+Functions: crackfortran, crack2fortran
+The following Fortran statements/constructions are supported
+(or will be if needed):
+   block data,byte,call,character,common,complex,contains,data,
+   dimension,double complex,double precision,end,external,function,
+   implicit,integer,intent,interface,intrinsic,
+   logical,module,optional,parameter,private,public,
+   program,real,(sequence?),subroutine,type,use,virtual,
+   include,pythonmodule
+Note: 'virtual' is mapped to 'dimension'.
+Note: 'implicit integer (z) static (z)' is 'implicit static (z)' (this is minor bug).
+Note: code after 'contains' will be ignored until its scope ends.
+Note: 'common' statement is extended: dimensions are moved to variable definitions
+Note: f2py directive: f2py is read as 
+Note: pythonmodule is introduced to represent Python module
+
+Usage:
+  `postlist=crackfortran(files)`
+  `postlist` contains declaration information read from the list of files `files`.
+  `crack2fortran(postlist)` returns a fortran code to be saved to pyf-file
+
+  `postlist` has the following structure:
+ *** it is a list of dictionaries containing `blocks':
+     B = {'block','body','vars','parent_block'[,'name','prefix','args','result',
+          'implicit','externals','interfaced','common','sortvars',
+          'commonvars','note']}
+     B['block'] = 'interface' | 'function' | 'subroutine' | 'module' |
+                  'program' | 'block data' | 'type' | 'pythonmodule' |
+                  'abstract interface'
+     B['body'] --- list containing `subblocks' with the same structure as `blocks'
+     B['parent_block'] --- dictionary of a parent block:
+                             C['body'][]['parent_block'] is C
+     B['vars'] --- dictionary of variable definitions
+     B['sortvars'] --- dictionary of variable definitions sorted by dependence (independent first)
+     B['name'] --- name of the block (not if B['block']=='interface')
+     B['prefix'] --- prefix string (only if B['block']=='function')
+     B['args'] --- list of argument names if B['block']== 'function' | 'subroutine'
+     B['result'] --- name of the return value (only if B['block']=='function')
+     B['implicit'] --- dictionary {'a':,'b':...} | None
+     B['externals'] --- list of variables being external
+     B['interfaced'] --- list of variables being external and defined
+     B['common'] --- dictionary of common blocks (list of objects)
+     B['commonvars'] --- list of variables used in common blocks (dimensions are moved to variable definitions)
+     B['from'] --- string showing the 'parents' of the current block
+     B['use'] --- dictionary of modules used in current block:
+         {:{['only':<0|1>],['map':{:,...}]}}
+     B['note'] --- list of LaTeX comments on the block
+     B['f2pyenhancements'] --- optional dictionary
+          {'threadsafe':'','fortranname':,
+           'callstatement':|,
+           'callprotoargument':,
+           'usercode':|,
+           'pymethoddef:'
+           }
+     B['entry'] --- dictionary {entryname:argslist,..}
+     B['varnames'] --- list of variable names given in the order of reading the
+                       Fortran code, useful for derived types.
+     B['saved_interface'] --- a string of scanned routine signature, defines explicit interface
+ *** Variable definition is a dictionary
+     D = B['vars'][] =
+     {'typespec'[,'attrspec','kindselector','charselector','=','typename']}
+     D['typespec'] = 'byte' | 'character' | 'complex' | 'double complex' |
+                     'double precision' | 'integer' | 'logical' | 'real' | 'type'
+     D['attrspec'] --- list of attributes (e.g. 'dimension()',
+                       'external','intent(in|out|inout|hide|c|callback|cache|aligned4|aligned8|aligned16)',
+                       'optional','required', etc)
+     K = D['kindselector'] = {['*','kind']} (only if D['typespec'] =
+                         'complex' | 'integer' | 'logical' | 'real' )
+     C = D['charselector'] = {['*','len','kind','f2py_len']}
+                             (only if D['typespec']=='character')
+     D['='] --- initialization expression string
+     D['typename'] --- name of the type if D['typespec']=='type'
+     D['dimension'] --- list of dimension bounds
+     D['intent'] --- list of intent specifications
+     D['depend'] --- list of variable names on which current variable depends on
+     D['check'] --- list of C-expressions; if C-expr returns zero, exception is raised
+     D['note'] --- list of LaTeX comments on the variable
+ *** Meaning of kind/char selectors (few examples):
+     D['typespec>']*K['*']
+     D['typespec'](kind=K['kind'])
+     character*C['*']
+     character(len=C['len'],kind=C['kind'], f2py_len=C['f2py_len'])
+     (see also fortran type declaration statement formats below)
+
+Fortran 90 type declaration statement format (F77 is subset of F90)
+====================================================================
+(Main source: IBM XL Fortran 5.1 Language Reference Manual)
+type declaration =  [[]::] 
+ = byte                          |
+             character[]     |
+             complex[]       |
+             double complex                |
+             double precision              |
+             integer[]       |
+             logical[]       |
+             real[]          |
+             type()
+ = *                |
+             ([len=][,[kind=]]) |
+             (kind=[,len=])
+ = *                 |
+             ([kind=])
+ = comma separated list of attributes.
+             Only the following attributes are used in
+             building up the interface:
+                external
+                (parameter --- affects '=' key)
+                optional
+                intent
+             Other attributes are ignored.
+ = in | out | inout
+ = comma separated list of dimension bounds.
+ =  [[*][()] | [()]*]
+                      [// | =] [,]
+
+In addition, the following attributes are used: check,depend,note
+
+TODO:
+    * Apply 'parameter' attribute (e.g. 'integer parameter :: i=2' 'real x(i)'
+                                   -> 'real x(2)')
+    The above may be solved by creating appropriate preprocessor program, for example.
+
+"""
+import sys
+import string
+import fileinput
+import re
+import os
+import copy
+import platform
+import codecs
+from pathlib import Path
+try:
+    import charset_normalizer
+except ImportError:
+    charset_normalizer = None
+
+from . import __version__
+
+# The environment provided by auxfuncs.py is needed for some calls to eval.
+# As the needed functions cannot be determined by static inspection of the
+# code, it is safest to use import * pending a major refactoring of f2py.
+from .auxfuncs import *
+from . import symbolic
+
+f2py_version = __version__.version
+
+# Global flags:
+strictf77 = 1          # Ignore `!' comments unless line[0]=='!'
+sourcecodeform = 'fix'  # 'fix','free'
+quiet = 0              # Be verbose if 0 (Obsolete: not used any more)
+verbose = 1            # Be quiet if 0, extra verbose if > 1.
+tabchar = 4 * ' '
+pyffilename = ''
+f77modulename = ''
+skipemptyends = 0      # for old F77 programs without 'program' statement
+ignorecontains = 1
+dolowercase = 1
+debug = []
+
+# Global variables
+beginpattern = ''
+currentfilename = ''
+expectbegin = 1
+f90modulevars = {}
+filepositiontext = ''
+gotnextfile = 1
+groupcache = None
+groupcounter = 0
+grouplist = {groupcounter: []}
+groupname = ''
+include_paths = []
+neededmodule = -1
+onlyfuncs = []
+previous_context = None
+skipblocksuntil = -1
+skipfuncs = []
+skipfunctions = []
+usermodules = []
+
+
+def reset_global_f2py_vars():
+    global groupcounter, grouplist, neededmodule, expectbegin
+    global skipblocksuntil, usermodules, f90modulevars, gotnextfile
+    global filepositiontext, currentfilename, skipfunctions, skipfuncs
+    global onlyfuncs, include_paths, previous_context
+    global strictf77, sourcecodeform, quiet, verbose, tabchar, pyffilename
+    global f77modulename, skipemptyends, ignorecontains, dolowercase, debug
+
+    # flags
+    strictf77 = 1
+    sourcecodeform = 'fix'
+    quiet = 0
+    verbose = 1
+    tabchar = 4 * ' '
+    pyffilename = ''
+    f77modulename = ''
+    skipemptyends = 0
+    ignorecontains = 1
+    dolowercase = 1
+    debug = []
+    # variables
+    groupcounter = 0
+    grouplist = {groupcounter: []}
+    neededmodule = -1
+    expectbegin = 1
+    skipblocksuntil = -1
+    usermodules = []
+    f90modulevars = {}
+    gotnextfile = 1
+    filepositiontext = ''
+    currentfilename = ''
+    skipfunctions = []
+    skipfuncs = []
+    onlyfuncs = []
+    include_paths = []
+    previous_context = None
+
+
+def outmess(line, flag=1):
+    global filepositiontext
+
+    if not verbose:
+        return
+    if not quiet:
+        if flag:
+            sys.stdout.write(filepositiontext)
+        sys.stdout.write(line)
+
+re._MAXCACHE = 50
+defaultimplicitrules = {}
+for c in "abcdefghopqrstuvwxyz$_":
+    defaultimplicitrules[c] = {'typespec': 'real'}
+for c in "ijklmn":
+    defaultimplicitrules[c] = {'typespec': 'integer'}
+badnames = {}
+invbadnames = {}
+for n in ['int', 'double', 'float', 'char', 'short', 'long', 'void', 'case', 'while',
+          'return', 'signed', 'unsigned', 'if', 'for', 'typedef', 'sizeof', 'union',
+          'struct', 'static', 'register', 'new', 'break', 'do', 'goto', 'switch',
+          'continue', 'else', 'inline', 'extern', 'delete', 'const', 'auto',
+          'len', 'rank', 'shape', 'index', 'slen', 'size', '_i',
+          'max', 'min',
+          'flen', 'fshape',
+          'string', 'complex_double', 'float_double', 'stdin', 'stderr', 'stdout',
+          'type', 'default']:
+    badnames[n] = n + '_bn'
+    invbadnames[n + '_bn'] = n
+
+
+def rmbadname1(name):
+    if name in badnames:
+        errmess('rmbadname1: Replacing "%s" with "%s".\n' %
+                (name, badnames[name]))
+        return badnames[name]
+    return name
+
+
+def rmbadname(names):
+    return [rmbadname1(_m) for _m in names]
+
+
+def undo_rmbadname1(name):
+    if name in invbadnames:
+        errmess('undo_rmbadname1: Replacing "%s" with "%s".\n'
+                % (name, invbadnames[name]))
+        return invbadnames[name]
+    return name
+
+
+def undo_rmbadname(names):
+    return [undo_rmbadname1(_m) for _m in names]
+
+
+_has_f_header = re.compile(r'-\*-\s*fortran\s*-\*-', re.I).search
+_has_f90_header = re.compile(r'-\*-\s*f90\s*-\*-', re.I).search
+_has_fix_header = re.compile(r'-\*-\s*fix\s*-\*-', re.I).search
+_free_f90_start = re.compile(r'[^c*]\s*[^\s\d\t]', re.I).match
+
+# Extensions
+COMMON_FREE_EXTENSIONS = ['.f90', '.f95', '.f03', '.f08']
+COMMON_FIXED_EXTENSIONS = ['.for', '.ftn', '.f77', '.f']
+
+
+def openhook(filename, mode):
+    """Ensures that filename is opened with correct encoding parameter.
+
+    This function uses charset_normalizer package, when available, for
+    determining the encoding of the file to be opened. When charset_normalizer
+    is not available, the function detects only UTF encodings, otherwise, ASCII
+    encoding is used as fallback.
+    """
+    # Reads in the entire file. Robust detection of encoding.
+    # Correctly handles comments or late stage unicode characters
+    # gh-22871
+    if charset_normalizer is not None:
+        encoding = charset_normalizer.from_path(filename).best().encoding
+    else:
+        # hint: install charset_normalizer for correct encoding handling
+        # No need to read the whole file for trying with startswith
+        nbytes = min(32, os.path.getsize(filename))
+        with open(filename, 'rb') as fhandle:
+            raw = fhandle.read(nbytes)
+            if raw.startswith(codecs.BOM_UTF8):
+                encoding = 'UTF-8-SIG'
+            elif raw.startswith((codecs.BOM_UTF32_LE, codecs.BOM_UTF32_BE)):
+                encoding = 'UTF-32'
+            elif raw.startswith((codecs.BOM_LE, codecs.BOM_BE)):
+                encoding = 'UTF-16'
+            else:
+                # Fallback, without charset_normalizer
+                encoding = 'ascii'
+    return open(filename, mode, encoding=encoding)
+
+
+def is_free_format(fname):
+    """Check if file is in free format Fortran."""
+    # f90 allows both fixed and free format, assuming fixed unless
+    # signs of free format are detected.
+    result = False
+    if Path(fname).suffix.lower() in COMMON_FREE_EXTENSIONS:
+        result = True
+    with openhook(fname, 'r') as fhandle:
+        line = fhandle.readline()
+        n = 15  # the number of non-comment lines to scan for hints
+        if _has_f_header(line):
+            n = 0
+        elif _has_f90_header(line):
+            n = 0
+            result = True
+        while n > 0 and line:
+            if line[0] != '!' and line.strip():
+                n -= 1
+                if (line[0] != '\t' and _free_f90_start(line[:5])) or line[-2:-1] == '&':
+                    result = True
+                    break
+            line = fhandle.readline()
+    return result
+
+
+# Read fortran (77,90) code
+def readfortrancode(ffile, dowithline=show, istop=1):
+    """
+    Read fortran codes from files and
+     1) Get rid of comments, line continuations, and empty lines; lower cases.
+     2) Call dowithline(line) on every line.
+     3) Recursively call itself when statement \"include ''\" is met.
+    """
+    global gotnextfile, filepositiontext, currentfilename, sourcecodeform, strictf77
+    global beginpattern, quiet, verbose, dolowercase, include_paths
+
+    if not istop:
+        saveglobals = gotnextfile, filepositiontext, currentfilename, sourcecodeform, strictf77,\
+            beginpattern, quiet, verbose, dolowercase
+    if ffile == []:
+        return
+    localdolowercase = dolowercase
+    # cont: set to True when the content of the last line read
+    # indicates statement continuation
+    cont = False
+    finalline = ''
+    ll = ''
+    includeline = re.compile(
+        r'\s*include\s*(\'|")(?P[^\'"]*)(\'|")', re.I)
+    cont1 = re.compile(r'(?P.*)&\s*\Z')
+    cont2 = re.compile(r'(\s*&|)(?P.*)')
+    mline_mark = re.compile(r".*?'''")
+    if istop:
+        dowithline('', -1)
+    ll, l1 = '', ''
+    spacedigits = [' '] + [str(_m) for _m in range(10)]
+    filepositiontext = ''
+    fin = fileinput.FileInput(ffile, openhook=openhook)
+    while True:
+        try:
+            l = fin.readline()
+        except UnicodeDecodeError as msg:
+            raise Exception(
+                f'readfortrancode: reading {fin.filename()}#{fin.lineno()}'
+                f' failed with\n{msg}.\nIt is likely that installing charset_normalizer'
+                ' package will help f2py determine the input file encoding'
+                ' correctly.')
+        if not l:
+            break
+        if fin.isfirstline():
+            filepositiontext = ''
+            currentfilename = fin.filename()
+            gotnextfile = 1
+            l1 = l
+            strictf77 = 0
+            sourcecodeform = 'fix'
+            ext = os.path.splitext(currentfilename)[1]
+            if Path(currentfilename).suffix.lower() in COMMON_FIXED_EXTENSIONS and \
+                    not (_has_f90_header(l) or _has_fix_header(l)):
+                strictf77 = 1
+            elif is_free_format(currentfilename) and not _has_fix_header(l):
+                sourcecodeform = 'free'
+            if strictf77:
+                beginpattern = beginpattern77
+            else:
+                beginpattern = beginpattern90
+            outmess('\tReading file %s (format:%s%s)\n'
+                    % (repr(currentfilename), sourcecodeform,
+                       strictf77 and ',strict' or ''))
+
+        l = l.expandtabs().replace('\xa0', ' ')
+        # Get rid of newline characters
+        while not l == '':
+            if l[-1] not in "\n\r\f":
+                break
+            l = l[:-1]
+        # Unconditionally remove comments
+        (l, rl) = split_by_unquoted(l, '!')
+        l += ' '
+        if rl[:5].lower() == '!f2py':  # f2py directive
+            l, _ = split_by_unquoted(l + 4 * ' ' + rl[5:], '!')
+        if l.strip() == '':  # Skip empty line
+            if sourcecodeform == 'free':
+                # In free form, a statement continues in the next line
+                # that is not a comment line [3.3.2.4^1], lines with
+                # blanks are comment lines [3.3.2.3^1]. Hence, the
+                # line continuation flag must retain its state.
+                pass
+            else:
+                # In fixed form, statement continuation is determined
+                # by a non-blank character at the 6-th position. Empty
+                # line indicates a start of a new statement
+                # [3.3.3.3^1]. Hence, the line continuation flag must
+                # be reset.
+                cont = False
+            continue
+        if sourcecodeform == 'fix':
+            if l[0] in ['*', 'c', '!', 'C', '#']:
+                if l[1:5].lower() == 'f2py':  # f2py directive
+                    l = '     ' + l[5:]
+                else:  # Skip comment line
+                    cont = False
+                    continue
+            elif strictf77:
+                if len(l) > 72:
+                    l = l[:72]
+            if not (l[0] in spacedigits):
+                raise Exception('readfortrancode: Found non-(space,digit) char '
+                                'in the first column.\n\tAre you sure that '
+                                'this code is in fix form?\n\tline=%s' % repr(l))
+
+            if (not cont or strictf77) and (len(l) > 5 and not l[5] == ' '):
+                # Continuation of a previous line
+                ll = ll + l[6:]
+                finalline = ''
+                origfinalline = ''
+            else:
+                r = cont1.match(l)
+                if r:
+                    l = r.group('line') # Continuation follows ..
+                if cont:
+                    ll = ll + cont2.match(l).group('line')
+                    finalline = ''
+                    origfinalline = ''
+                else:
+                    # clean up line beginning from possible digits.
+                    l = '     ' + l[5:]
+                    if localdolowercase:
+                        finalline = ll.lower()
+                    else:
+                        finalline = ll
+                    origfinalline = ll
+                    ll = l
+
+        elif sourcecodeform == 'free':
+            if not cont and ext == '.pyf' and mline_mark.match(l):
+                l = l + '\n'
+                while True:
+                    lc = fin.readline()
+                    if not lc:
+                        errmess(
+                            'Unexpected end of file when reading multiline\n')
+                        break
+                    l = l + lc
+                    if mline_mark.match(lc):
+                        break
+                l = l.rstrip()
+            r = cont1.match(l)
+            if r:
+                l = r.group('line')  # Continuation follows ..
+            if cont:
+                ll = ll + cont2.match(l).group('line')
+                finalline = ''
+                origfinalline = ''
+            else:
+                if localdolowercase:
+                    finalline = ll.lower()
+                else:
+                    finalline = ll
+                origfinalline = ll
+                ll = l
+            cont = (r is not None)
+        else:
+            raise ValueError(
+                "Flag sourcecodeform must be either 'fix' or 'free': %s" % repr(sourcecodeform))
+        filepositiontext = 'Line #%d in %s:"%s"\n\t' % (
+            fin.filelineno() - 1, currentfilename, l1)
+        m = includeline.match(origfinalline)
+        if m:
+            fn = m.group('name')
+            if os.path.isfile(fn):
+                readfortrancode(fn, dowithline=dowithline, istop=0)
+            else:
+                include_dirs = [
+                    os.path.dirname(currentfilename)] + include_paths
+                foundfile = 0
+                for inc_dir in include_dirs:
+                    fn1 = os.path.join(inc_dir, fn)
+                    if os.path.isfile(fn1):
+                        foundfile = 1
+                        readfortrancode(fn1, dowithline=dowithline, istop=0)
+                        break
+                if not foundfile:
+                    outmess('readfortrancode: could not find include file %s in %s. Ignoring.\n' % (
+                        repr(fn), os.pathsep.join(include_dirs)))
+        else:
+            dowithline(finalline)
+        l1 = ll
+    if localdolowercase:
+        finalline = ll.lower()
+    else:
+        finalline = ll
+    origfinalline = ll
+    filepositiontext = 'Line #%d in %s:"%s"\n\t' % (
+        fin.filelineno() - 1, currentfilename, l1)
+    m = includeline.match(origfinalline)
+    if m:
+        fn = m.group('name')
+        if os.path.isfile(fn):
+            readfortrancode(fn, dowithline=dowithline, istop=0)
+        else:
+            include_dirs = [os.path.dirname(currentfilename)] + include_paths
+            foundfile = 0
+            for inc_dir in include_dirs:
+                fn1 = os.path.join(inc_dir, fn)
+                if os.path.isfile(fn1):
+                    foundfile = 1
+                    readfortrancode(fn1, dowithline=dowithline, istop=0)
+                    break
+            if not foundfile:
+                outmess('readfortrancode: could not find include file %s in %s. Ignoring.\n' % (
+                    repr(fn), os.pathsep.join(include_dirs)))
+    else:
+        dowithline(finalline)
+    filepositiontext = ''
+    fin.close()
+    if istop:
+        dowithline('', 1)
+    else:
+        gotnextfile, filepositiontext, currentfilename, sourcecodeform, strictf77,\
+            beginpattern, quiet, verbose, dolowercase = saveglobals
+
+# Crack line
+beforethisafter = r'\s*(?P%s(?=\s*(\b(%s)\b)))' + \
+    r'\s*(?P(\b(%s)\b))' + \
+    r'\s*(?P%s)\s*\Z'
+##
+fortrantypes = r'character|logical|integer|real|complex|double\s*(precision\s*(complex|)|complex)|type(?=\s*\([\w\s,=(*)]*\))|byte'
+typespattern = re.compile(
+    beforethisafter % ('', fortrantypes, fortrantypes, '.*'), re.I), 'type'
+typespattern4implicit = re.compile(beforethisafter % (
+    '', fortrantypes + '|static|automatic|undefined', fortrantypes + '|static|automatic|undefined', '.*'), re.I)
+#
+functionpattern = re.compile(beforethisafter % (
+    r'([a-z]+[\w\s(=*+-/)]*?|)', 'function', 'function', '.*'), re.I), 'begin'
+subroutinepattern = re.compile(beforethisafter % (
+    r'[a-z\s]*?', 'subroutine', 'subroutine', '.*'), re.I), 'begin'
+# modulepattern=re.compile(beforethisafter%('[a-z\s]*?','module','module','.*'),re.I),'begin'
+#
+groupbegins77 = r'program|block\s*data'
+beginpattern77 = re.compile(
+    beforethisafter % ('', groupbegins77, groupbegins77, '.*'), re.I), 'begin'
+groupbegins90 = groupbegins77 + \
+    r'|module(?!\s*procedure)|python\s*module|(abstract|)\s*interface|' + \
+    r'type(?!\s*\()'
+beginpattern90 = re.compile(
+    beforethisafter % ('', groupbegins90, groupbegins90, '.*'), re.I), 'begin'
+groupends = (r'end|endprogram|endblockdata|endmodule|endpythonmodule|'
+             r'endinterface|endsubroutine|endfunction')
+endpattern = re.compile(
+    beforethisafter % ('', groupends, groupends, '.*'), re.I), 'end'
+# block, the Fortran 2008 construct needs special handling in the rest of the file
+endifs = r'end\s*(if|do|where|select|while|forall|associate|' + \
+         r'critical|enum|team)'
+endifpattern = re.compile(
+    beforethisafter % (r'[\w]*?', endifs, endifs, '.*'), re.I), 'endif'
+#
+moduleprocedures = r'module\s*procedure'
+moduleprocedurepattern = re.compile(
+    beforethisafter % ('', moduleprocedures, moduleprocedures, '.*'), re.I), \
+    'moduleprocedure'
+implicitpattern = re.compile(
+    beforethisafter % ('', 'implicit', 'implicit', '.*'), re.I), 'implicit'
+dimensionpattern = re.compile(beforethisafter % (
+    '', 'dimension|virtual', 'dimension|virtual', '.*'), re.I), 'dimension'
+externalpattern = re.compile(
+    beforethisafter % ('', 'external', 'external', '.*'), re.I), 'external'
+optionalpattern = re.compile(
+    beforethisafter % ('', 'optional', 'optional', '.*'), re.I), 'optional'
+requiredpattern = re.compile(
+    beforethisafter % ('', 'required', 'required', '.*'), re.I), 'required'
+publicpattern = re.compile(
+    beforethisafter % ('', 'public', 'public', '.*'), re.I), 'public'
+privatepattern = re.compile(
+    beforethisafter % ('', 'private', 'private', '.*'), re.I), 'private'
+intrinsicpattern = re.compile(
+    beforethisafter % ('', 'intrinsic', 'intrinsic', '.*'), re.I), 'intrinsic'
+intentpattern = re.compile(beforethisafter % (
+    '', 'intent|depend|note|check', 'intent|depend|note|check', r'\s*\(.*?\).*'), re.I), 'intent'
+parameterpattern = re.compile(
+    beforethisafter % ('', 'parameter', 'parameter', r'\s*\(.*'), re.I), 'parameter'
+datapattern = re.compile(
+    beforethisafter % ('', 'data', 'data', '.*'), re.I), 'data'
+callpattern = re.compile(
+    beforethisafter % ('', 'call', 'call', '.*'), re.I), 'call'
+entrypattern = re.compile(
+    beforethisafter % ('', 'entry', 'entry', '.*'), re.I), 'entry'
+callfunpattern = re.compile(
+    beforethisafter % ('', 'callfun', 'callfun', '.*'), re.I), 'callfun'
+commonpattern = re.compile(
+    beforethisafter % ('', 'common', 'common', '.*'), re.I), 'common'
+usepattern = re.compile(
+    beforethisafter % ('', 'use', 'use', '.*'), re.I), 'use'
+containspattern = re.compile(
+    beforethisafter % ('', 'contains', 'contains', ''), re.I), 'contains'
+formatpattern = re.compile(
+    beforethisafter % ('', 'format', 'format', '.*'), re.I), 'format'
+# Non-fortran and f2py-specific statements
+f2pyenhancementspattern = re.compile(beforethisafter % ('', 'threadsafe|fortranname|callstatement|callprotoargument|usercode|pymethoddef',
+                                                        'threadsafe|fortranname|callstatement|callprotoargument|usercode|pymethoddef', '.*'), re.I | re.S), 'f2pyenhancements'
+multilinepattern = re.compile(
+    r"\s*(?P''')(?P.*?)(?P''')\s*\Z", re.S), 'multiline'
+##
+
+def split_by_unquoted(line, characters):
+    """
+    Splits the line into (line[:i], line[i:]),
+    where i is the index of first occurrence of one of the characters
+    not within quotes, or len(line) if no such index exists
+    """
+    assert not (set('"\'') & set(characters)), "cannot split by unquoted quotes"
+    r = re.compile(
+        r"\A(?P({single_quoted}|{double_quoted}|{not_quoted})*)"
+        r"(?P{char}.*)\Z".format(
+            not_quoted="[^\"'{}]".format(re.escape(characters)),
+            char="[{}]".format(re.escape(characters)),
+            single_quoted=r"('([^'\\]|(\\.))*')",
+            double_quoted=r'("([^"\\]|(\\.))*")'))
+    m = r.match(line)
+    if m:
+        d = m.groupdict()
+        return (d["before"], d["after"])
+    return (line, "")
+
+def _simplifyargs(argsline):
+    a = []
+    for n in markoutercomma(argsline).split('@,@'):
+        for r in '(),':
+            n = n.replace(r, '_')
+        a.append(n)
+    return ','.join(a)
+
+crackline_re_1 = re.compile(r'\s*(?P\b[a-z]+\w*\b)\s*=.*', re.I)
+crackline_bind_1 = re.compile(r'\s*(?P\b[a-z]+\w*\b)\s*=.*', re.I)
+crackline_bindlang = re.compile(r'\s*bind\(\s*(?P[^,]+)\s*,\s*name\s*=\s*"(?P[^"]+)"\s*\)', re.I)
+
+def crackline(line, reset=0):
+    """
+    reset=-1  --- initialize
+    reset=0   --- crack the line
+    reset=1   --- final check if mismatch of blocks occurred
+
+    Cracked data is saved in grouplist[0].
+    """
+    global beginpattern, groupcounter, groupname, groupcache, grouplist
+    global filepositiontext, currentfilename, neededmodule, expectbegin
+    global skipblocksuntil, skipemptyends, previous_context, gotnextfile
+
+    _, has_semicolon = split_by_unquoted(line, ";")
+    if has_semicolon and not (f2pyenhancementspattern[0].match(line) or
+                               multilinepattern[0].match(line)):
+        # XXX: non-zero reset values need testing
+        assert reset == 0, repr(reset)
+        # split line on unquoted semicolons
+        line, semicolon_line = split_by_unquoted(line, ";")
+        while semicolon_line:
+            crackline(line, reset)
+            line, semicolon_line = split_by_unquoted(semicolon_line[1:], ";")
+        crackline(line, reset)
+        return
+    if reset < 0:
+        groupcounter = 0
+        groupname = {groupcounter: ''}
+        groupcache = {groupcounter: {}}
+        grouplist = {groupcounter: []}
+        groupcache[groupcounter]['body'] = []
+        groupcache[groupcounter]['vars'] = {}
+        groupcache[groupcounter]['block'] = ''
+        groupcache[groupcounter]['name'] = ''
+        neededmodule = -1
+        skipblocksuntil = -1
+        return
+    if reset > 0:
+        fl = 0
+        if f77modulename and neededmodule == groupcounter:
+            fl = 2
+        while groupcounter > fl:
+            outmess('crackline: groupcounter=%s groupname=%s\n' %
+                    (repr(groupcounter), repr(groupname)))
+            outmess(
+                'crackline: Mismatch of blocks encountered. Trying to fix it by assuming "end" statement.\n')
+            grouplist[groupcounter - 1].append(groupcache[groupcounter])
+            grouplist[groupcounter - 1][-1]['body'] = grouplist[groupcounter]
+            del grouplist[groupcounter]
+            groupcounter = groupcounter - 1
+        if f77modulename and neededmodule == groupcounter:
+            grouplist[groupcounter - 1].append(groupcache[groupcounter])
+            grouplist[groupcounter - 1][-1]['body'] = grouplist[groupcounter]
+            del grouplist[groupcounter]
+            groupcounter = groupcounter - 1  # end interface
+            grouplist[groupcounter - 1].append(groupcache[groupcounter])
+            grouplist[groupcounter - 1][-1]['body'] = grouplist[groupcounter]
+            del grouplist[groupcounter]
+            groupcounter = groupcounter - 1  # end module
+            neededmodule = -1
+        return
+    if line == '':
+        return
+    flag = 0
+    for pat in [dimensionpattern, externalpattern, intentpattern, optionalpattern,
+                requiredpattern,
+                parameterpattern, datapattern, publicpattern, privatepattern,
+                intrinsicpattern,
+                endifpattern, endpattern,
+                formatpattern,
+                beginpattern, functionpattern, subroutinepattern,
+                implicitpattern, typespattern, commonpattern,
+                callpattern, usepattern, containspattern,
+                entrypattern,
+                f2pyenhancementspattern,
+                multilinepattern,
+                moduleprocedurepattern
+                ]:
+        m = pat[0].match(line)
+        if m:
+            break
+        flag = flag + 1
+    if not m:
+        re_1 = crackline_re_1
+        if 0 <= skipblocksuntil <= groupcounter:
+            return
+        if 'externals' in groupcache[groupcounter]:
+            for name in groupcache[groupcounter]['externals']:
+                if name in invbadnames:
+                    name = invbadnames[name]
+                if 'interfaced' in groupcache[groupcounter] and name in groupcache[groupcounter]['interfaced']:
+                    continue
+                m1 = re.match(
+                    r'(?P[^"]*)\b%s\b\s*@\(@(?P[^@]*)@\)@.*\Z' % name, markouterparen(line), re.I)
+                if m1:
+                    m2 = re_1.match(m1.group('before'))
+                    a = _simplifyargs(m1.group('args'))
+                    if m2:
+                        line = 'callfun %s(%s) result (%s)' % (
+                            name, a, m2.group('result'))
+                    else:
+                        line = 'callfun %s(%s)' % (name, a)
+                    m = callfunpattern[0].match(line)
+                    if not m:
+                        outmess(
+                            'crackline: could not resolve function call for line=%s.\n' % repr(line))
+                        return
+                    analyzeline(m, 'callfun', line)
+                    return
+        if verbose > 1 or (verbose == 1 and currentfilename.lower().endswith('.pyf')):
+            previous_context = None
+            outmess('crackline:%d: No pattern for line\n' % (groupcounter))
+        return
+    elif pat[1] == 'end':
+        if 0 <= skipblocksuntil < groupcounter:
+            groupcounter = groupcounter - 1
+            if skipblocksuntil <= groupcounter:
+                return
+        if groupcounter <= 0:
+            raise Exception('crackline: groupcounter(=%s) is nonpositive. '
+                            'Check the blocks.'
+                            % (groupcounter))
+        m1 = beginpattern[0].match(line)
+        if (m1) and (not m1.group('this') == groupname[groupcounter]):
+            raise Exception('crackline: End group %s does not match with '
+                            'previous Begin group %s\n\t%s' %
+                            (repr(m1.group('this')), repr(groupname[groupcounter]),
+                             filepositiontext)
+                            )
+        if skipblocksuntil == groupcounter:
+            skipblocksuntil = -1
+        grouplist[groupcounter - 1].append(groupcache[groupcounter])
+        grouplist[groupcounter - 1][-1]['body'] = grouplist[groupcounter]
+        del grouplist[groupcounter]
+        groupcounter = groupcounter - 1
+        if not skipemptyends:
+            expectbegin = 1
+    elif pat[1] == 'begin':
+        if 0 <= skipblocksuntil <= groupcounter:
+            groupcounter = groupcounter + 1
+            return
+        gotnextfile = 0
+        analyzeline(m, pat[1], line)
+        expectbegin = 0
+    elif pat[1] == 'endif':
+        pass
+    elif pat[1] == 'moduleprocedure':
+        analyzeline(m, pat[1], line)
+    elif pat[1] == 'contains':
+        if ignorecontains:
+            return
+        if 0 <= skipblocksuntil <= groupcounter:
+            return
+        skipblocksuntil = groupcounter
+    else:
+        if 0 <= skipblocksuntil <= groupcounter:
+            return
+        analyzeline(m, pat[1], line)
+
+
+def markouterparen(line):
+    l = ''
+    f = 0
+    for c in line:
+        if c == '(':
+            f = f + 1
+            if f == 1:
+                l = l + '@(@'
+                continue
+        elif c == ')':
+            f = f - 1
+            if f == 0:
+                l = l + '@)@'
+                continue
+        l = l + c
+    return l
+
+
+def markoutercomma(line, comma=','):
+    l = ''
+    f = 0
+    before, after = split_by_unquoted(line, comma + '()')
+    l += before
+    while after:
+        if (after[0] == comma) and (f == 0):
+            l += '@' + comma + '@'
+        else:
+            l += after[0]
+            if after[0] == '(':
+                f += 1
+            elif after[0] == ')':
+                f -= 1
+        before, after = split_by_unquoted(after[1:], comma + '()')
+        l += before
+    assert not f, repr((f, line, l))
+    return l
+
+def unmarkouterparen(line):
+    r = line.replace('@(@', '(').replace('@)@', ')')
+    return r
+
+
+def appenddecl(decl, decl2, force=1):
+    if not decl:
+        decl = {}
+    if not decl2:
+        return decl
+    if decl is decl2:
+        return decl
+    for k in list(decl2.keys()):
+        if k == 'typespec':
+            if force or k not in decl:
+                decl[k] = decl2[k]
+        elif k == 'attrspec':
+            for l in decl2[k]:
+                decl = setattrspec(decl, l, force)
+        elif k == 'kindselector':
+            decl = setkindselector(decl, decl2[k], force)
+        elif k == 'charselector':
+            decl = setcharselector(decl, decl2[k], force)
+        elif k in ['=', 'typename']:
+            if force or k not in decl:
+                decl[k] = decl2[k]
+        elif k == 'note':
+            pass
+        elif k in ['intent', 'check', 'dimension', 'optional',
+                   'required', 'depend']:
+            errmess('appenddecl: "%s" not implemented.\n' % k)
+        else:
+            raise Exception('appenddecl: Unknown variable definition key: ' +
+                            str(k))
+    return decl
+
+selectpattern = re.compile(
+    r'\s*(?P(@\(@.*?@\)@|\*[\d*]+|\*\s*@\(@.*?@\)@|))(?P.*)\Z', re.I)
+typedefpattern = re.compile(
+    r'(?:,(?P[\w(),]+))?(::)?(?P\b[a-z$_][\w$]*\b)'
+    r'(?:\((?P[\w,]*)\))?\Z', re.I)
+nameargspattern = re.compile(
+    r'\s*(?P\b[\w$]+\b)\s*(@\(@\s*(?P[\w\s,]*)\s*@\)@|)\s*((result(\s*@\(@\s*(?P\b[\w$]+\b)\s*@\)@|))|(bind\s*@\(@\s*(?P(?:(?!@\)@).)*)\s*@\)@))*\s*\Z', re.I)
+operatorpattern = re.compile(
+    r'\s*(?P(operator|assignment))'
+    r'@\(@\s*(?P[^)]+)\s*@\)@\s*\Z', re.I)
+callnameargspattern = re.compile(
+    r'\s*(?P\b[\w$]+\b)\s*@\(@\s*(?P.*)\s*@\)@\s*\Z', re.I)
+real16pattern = re.compile(
+    r'([-+]?(?:\d+(?:\.\d*)?|\d*\.\d+))[dD]((?:[-+]?\d+)?)')
+real8pattern = re.compile(
+    r'([-+]?((?:\d+(?:\.\d*)?|\d*\.\d+))[eE]((?:[-+]?\d+)?)|(\d+\.\d*))')
+
+_intentcallbackpattern = re.compile(r'intent\s*\(.*?\bcallback\b', re.I)
+
+
+def _is_intent_callback(vdecl):
+    for a in vdecl.get('attrspec', []):
+        if _intentcallbackpattern.match(a):
+            return 1
+    return 0
+
+
+def _resolvetypedefpattern(line):
+    line = ''.join(line.split())  # removes whitespace
+    m1 = typedefpattern.match(line)
+    print(line, m1)
+    if m1:
+        attrs = m1.group('attributes')
+        attrs = [a.lower() for a in attrs.split(',')] if attrs else []
+        return m1.group('name'), attrs, m1.group('params')
+    return None, [], None
+
+def parse_name_for_bind(line):
+    pattern = re.compile(r'bind\(\s*(?P[^,]+)(?:\s*,\s*name\s*=\s*["\'](?P[^"\']+)["\']\s*)?\)', re.I)
+    match = pattern.search(line)
+    bind_statement = None
+    if match:
+        bind_statement = match.group(0)
+        # Remove the 'bind' construct from the line.
+        line = line[:match.start()] + line[match.end():]
+    return line, bind_statement
+
+def _resolvenameargspattern(line):
+    line, bind_cname = parse_name_for_bind(line)
+    line = markouterparen(line)
+    m1 = nameargspattern.match(line)
+    if m1:
+        return m1.group('name'), m1.group('args'), m1.group('result'), bind_cname
+    m1 = operatorpattern.match(line)
+    if m1:
+        name = m1.group('scheme') + '(' + m1.group('name') + ')'
+        return name, [], None, None
+    m1 = callnameargspattern.match(line)
+    if m1:
+        return m1.group('name'), m1.group('args'), None, None
+    return None, [], None, None
+
+
+def analyzeline(m, case, line):
+    """
+    Reads each line in the input file in sequence and updates global vars.
+
+    Effectively reads and collects information from the input file to the
+    global variable groupcache, a dictionary containing info about each part
+    of the fortran module.
+
+    At the end of analyzeline, information is filtered into the correct dict
+    keys, but parameter values and dimensions are not yet interpreted.
+    """
+    global groupcounter, groupname, groupcache, grouplist, filepositiontext
+    global currentfilename, f77modulename, neededinterface, neededmodule
+    global expectbegin, gotnextfile, previous_context
+
+    block = m.group('this')
+    if case != 'multiline':
+        previous_context = None
+    if expectbegin and case not in ['begin', 'call', 'callfun', 'type'] \
+       and not skipemptyends and groupcounter < 1:
+        newname = os.path.basename(currentfilename).split('.')[0]
+        outmess(
+            'analyzeline: no group yet. Creating program group with name "%s".\n' % newname)
+        gotnextfile = 0
+        groupcounter = groupcounter + 1
+        groupname[groupcounter] = 'program'
+        groupcache[groupcounter] = {}
+        grouplist[groupcounter] = []
+        groupcache[groupcounter]['body'] = []
+        groupcache[groupcounter]['vars'] = {}
+        groupcache[groupcounter]['block'] = 'program'
+        groupcache[groupcounter]['name'] = newname
+        groupcache[groupcounter]['from'] = 'fromsky'
+        expectbegin = 0
+    if case in ['begin', 'call', 'callfun']:
+        # Crack line => block,name,args,result
+        block = block.lower()
+        if re.match(r'block\s*data', block, re.I):
+            block = 'block data'
+        elif re.match(r'python\s*module', block, re.I):
+            block = 'python module'
+        elif re.match(r'abstract\s*interface', block, re.I):
+            block = 'abstract interface'
+        if block == 'type':
+            name, attrs, _ = _resolvetypedefpattern(m.group('after'))
+            groupcache[groupcounter]['vars'][name] = dict(attrspec = attrs)
+            args = []
+            result = None
+        else:
+            name, args, result, bindcline = _resolvenameargspattern(m.group('after'))
+        if name is None:
+            if block == 'block data':
+                name = '_BLOCK_DATA_'
+            else:
+                name = ''
+            if block not in ['interface', 'block data', 'abstract interface']:
+                outmess('analyzeline: No name/args pattern found for line.\n')
+
+        previous_context = (block, name, groupcounter)
+        if args:
+            args = rmbadname([x.strip()
+                              for x in markoutercomma(args).split('@,@')])
+        else:
+            args = []
+        if '' in args:
+            while '' in args:
+                args.remove('')
+            outmess(
+                'analyzeline: argument list is malformed (missing argument).\n')
+
+        # end of crack line => block,name,args,result
+        needmodule = 0
+        needinterface = 0
+
+        if case in ['call', 'callfun']:
+            needinterface = 1
+            if 'args' not in groupcache[groupcounter]:
+                return
+            if name not in groupcache[groupcounter]['args']:
+                return
+            for it in grouplist[groupcounter]:
+                if it['name'] == name:
+                    return
+            if name in groupcache[groupcounter]['interfaced']:
+                return
+            block = {'call': 'subroutine', 'callfun': 'function'}[case]
+        if f77modulename and neededmodule == -1 and groupcounter <= 1:
+            neededmodule = groupcounter + 2
+            needmodule = 1
+            if block not in ['interface', 'abstract interface']:
+                needinterface = 1
+        # Create new block(s)
+        groupcounter = groupcounter + 1
+        groupcache[groupcounter] = {}
+        grouplist[groupcounter] = []
+        if needmodule:
+            if verbose > 1:
+                outmess('analyzeline: Creating module block %s\n' %
+                        repr(f77modulename), 0)
+            groupname[groupcounter] = 'module'
+            groupcache[groupcounter]['block'] = 'python module'
+            groupcache[groupcounter]['name'] = f77modulename
+            groupcache[groupcounter]['from'] = ''
+            groupcache[groupcounter]['body'] = []
+            groupcache[groupcounter]['externals'] = []
+            groupcache[groupcounter]['interfaced'] = []
+            groupcache[groupcounter]['vars'] = {}
+            groupcounter = groupcounter + 1
+            groupcache[groupcounter] = {}
+            grouplist[groupcounter] = []
+        if needinterface:
+            if verbose > 1:
+                outmess('analyzeline: Creating additional interface block (groupcounter=%s).\n' % (
+                    groupcounter), 0)
+            groupname[groupcounter] = 'interface'
+            groupcache[groupcounter]['block'] = 'interface'
+            groupcache[groupcounter]['name'] = 'unknown_interface'
+            groupcache[groupcounter]['from'] = '%s:%s' % (
+                groupcache[groupcounter - 1]['from'], groupcache[groupcounter - 1]['name'])
+            groupcache[groupcounter]['body'] = []
+            groupcache[groupcounter]['externals'] = []
+            groupcache[groupcounter]['interfaced'] = []
+            groupcache[groupcounter]['vars'] = {}
+            groupcounter = groupcounter + 1
+            groupcache[groupcounter] = {}
+            grouplist[groupcounter] = []
+        groupname[groupcounter] = block
+        groupcache[groupcounter]['block'] = block
+        if not name:
+            name = 'unknown_' + block.replace(' ', '_')
+        groupcache[groupcounter]['prefix'] = m.group('before')
+        groupcache[groupcounter]['name'] = rmbadname1(name)
+        groupcache[groupcounter]['result'] = result
+        if groupcounter == 1:
+            groupcache[groupcounter]['from'] = currentfilename
+        else:
+            if f77modulename and groupcounter == 3:
+                groupcache[groupcounter]['from'] = '%s:%s' % (
+                    groupcache[groupcounter - 1]['from'], currentfilename)
+            else:
+                groupcache[groupcounter]['from'] = '%s:%s' % (
+                    groupcache[groupcounter - 1]['from'], groupcache[groupcounter - 1]['name'])
+        for k in list(groupcache[groupcounter].keys()):
+            if not groupcache[groupcounter][k]:
+                del groupcache[groupcounter][k]
+
+        groupcache[groupcounter]['args'] = args
+        groupcache[groupcounter]['body'] = []
+        groupcache[groupcounter]['externals'] = []
+        groupcache[groupcounter]['interfaced'] = []
+        groupcache[groupcounter]['vars'] = {}
+        groupcache[groupcounter]['entry'] = {}
+        # end of creation
+        if block == 'type':
+            groupcache[groupcounter]['varnames'] = []
+
+        if case in ['call', 'callfun']:  # set parents variables
+            if name not in groupcache[groupcounter - 2]['externals']:
+                groupcache[groupcounter - 2]['externals'].append(name)
+            groupcache[groupcounter]['vars'] = copy.deepcopy(
+                groupcache[groupcounter - 2]['vars'])
+            try:
+                del groupcache[groupcounter]['vars'][name][
+                    groupcache[groupcounter]['vars'][name]['attrspec'].index('external')]
+            except Exception:
+                pass
+        if block in ['function', 'subroutine']:  # set global attributes
+            # name is fortran name
+            if bindcline:
+                bindcdat = re.search(crackline_bindlang, bindcline)
+                if bindcdat:
+                    groupcache[groupcounter]['bindlang'] = {name : {}}
+                    groupcache[groupcounter]['bindlang'][name]["lang"] = bindcdat.group('lang')
+                    if bindcdat.group('lang_name'):
+                        groupcache[groupcounter]['bindlang'][name]["name"] = bindcdat.group('lang_name')
+            try:
+                groupcache[groupcounter]['vars'][name] = appenddecl(
+                    groupcache[groupcounter]['vars'][name], groupcache[groupcounter - 2]['vars'][''])
+            except Exception:
+                pass
+            if case == 'callfun':  # return type
+                if result and result in groupcache[groupcounter]['vars']:
+                    if not name == result:
+                        groupcache[groupcounter]['vars'][name] = appenddecl(
+                            groupcache[groupcounter]['vars'][name], groupcache[groupcounter]['vars'][result])
+            # if groupcounter>1: # name is interfaced
+            try:
+                groupcache[groupcounter - 2]['interfaced'].append(name)
+            except Exception:
+                pass
+        if block == 'function':
+            t = typespattern[0].match(m.group('before') + ' ' + name)
+            if t:
+                typespec, selector, attr, edecl = cracktypespec0(
+                    t.group('this'), t.group('after'))
+                updatevars(typespec, selector, attr, edecl)
+
+        if case in ['call', 'callfun']:
+            grouplist[groupcounter - 1].append(groupcache[groupcounter])
+            grouplist[groupcounter - 1][-1]['body'] = grouplist[groupcounter]
+            del grouplist[groupcounter]
+            groupcounter = groupcounter - 1  # end routine
+            grouplist[groupcounter - 1].append(groupcache[groupcounter])
+            grouplist[groupcounter - 1][-1]['body'] = grouplist[groupcounter]
+            del grouplist[groupcounter]
+            groupcounter = groupcounter - 1  # end interface
+
+    elif case == 'entry':
+        name, args, result, _= _resolvenameargspattern(m.group('after'))
+        if name is not None:
+            if args:
+                args = rmbadname([x.strip()
+                                  for x in markoutercomma(args).split('@,@')])
+            else:
+                args = []
+            assert result is None, repr(result)
+            groupcache[groupcounter]['entry'][name] = args
+            previous_context = ('entry', name, groupcounter)
+    elif case == 'type':
+        typespec, selector, attr, edecl = cracktypespec0(
+            block, m.group('after'))
+        last_name = updatevars(typespec, selector, attr, edecl)
+        if last_name is not None:
+            previous_context = ('variable', last_name, groupcounter)
+    elif case in ['dimension', 'intent', 'optional', 'required', 'external', 'public', 'private', 'intrinsic']:
+        edecl = groupcache[groupcounter]['vars']
+        ll = m.group('after').strip()
+        i = ll.find('::')
+        if i < 0 and case == 'intent':
+            i = markouterparen(ll).find('@)@') - 2
+            ll = ll[:i + 1] + '::' + ll[i + 1:]
+            i = ll.find('::')
+            if ll[i:] == '::' and 'args' in groupcache[groupcounter]:
+                outmess('All arguments will have attribute %s%s\n' %
+                        (m.group('this'), ll[:i]))
+                ll = ll + ','.join(groupcache[groupcounter]['args'])
+        if i < 0:
+            i = 0
+            pl = ''
+        else:
+            pl = ll[:i].strip()
+            ll = ll[i + 2:]
+        ch = markoutercomma(pl).split('@,@')
+        if len(ch) > 1:
+            pl = ch[0]
+            outmess('analyzeline: cannot handle multiple attributes without type specification. Ignoring %r.\n' % (
+                ','.join(ch[1:])))
+        last_name = None
+
+        for e in [x.strip() for x in markoutercomma(ll).split('@,@')]:
+            m1 = namepattern.match(e)
+            if not m1:
+                if case in ['public', 'private']:
+                    k = ''
+                else:
+                    print(m.groupdict())
+                    outmess('analyzeline: no name pattern found in %s statement for %s. Skipping.\n' % (
+                        case, repr(e)))
+                    continue
+            else:
+                k = rmbadname1(m1.group('name'))
+            if case in ['public', 'private'] and \
+               (k == 'operator' or k == 'assignment'):
+                k += m1.group('after')
+            if k not in edecl:
+                edecl[k] = {}
+            if case == 'dimension':
+                ap = case + m1.group('after')
+            if case == 'intent':
+                ap = m.group('this') + pl
+                if _intentcallbackpattern.match(ap):
+                    if k not in groupcache[groupcounter]['args']:
+                        if groupcounter > 1:
+                            if '__user__' not in groupcache[groupcounter - 2]['name']:
+                                outmess(
+                                    'analyzeline: missing __user__ module (could be nothing)\n')
+                            # fixes ticket 1693
+                            if k != groupcache[groupcounter]['name']:
+                                outmess('analyzeline: appending intent(callback) %s'
+                                        ' to %s arguments\n' % (k, groupcache[groupcounter]['name']))
+                                groupcache[groupcounter]['args'].append(k)
+                        else:
+                            errmess(
+                                'analyzeline: intent(callback) %s is ignored\n' % (k))
+                    else:
+                        errmess('analyzeline: intent(callback) %s is already'
+                                ' in argument list\n' % (k))
+            if case in ['optional', 'required', 'public', 'external', 'private', 'intrinsic']:
+                ap = case
+            if 'attrspec' in edecl[k]:
+                edecl[k]['attrspec'].append(ap)
+            else:
+                edecl[k]['attrspec'] = [ap]
+            if case == 'external':
+                if groupcache[groupcounter]['block'] == 'program':
+                    outmess('analyzeline: ignoring program arguments\n')
+                    continue
+                if k not in groupcache[groupcounter]['args']:
+                    continue
+                if 'externals' not in groupcache[groupcounter]:
+                    groupcache[groupcounter]['externals'] = []
+                groupcache[groupcounter]['externals'].append(k)
+            last_name = k
+        groupcache[groupcounter]['vars'] = edecl
+        if last_name is not None:
+            previous_context = ('variable', last_name, groupcounter)
+    elif case == 'moduleprocedure':
+        groupcache[groupcounter]['implementedby'] = \
+            [x.strip() for x in m.group('after').split(',')]
+    elif case == 'parameter':
+        edecl = groupcache[groupcounter]['vars']
+        ll = m.group('after').strip()[1:-1]
+        last_name = None
+        for e in markoutercomma(ll).split('@,@'):
+            try:
+                k, initexpr = [x.strip() for x in e.split('=')]
+            except Exception:
+                outmess(
+                    'analyzeline: could not extract name,expr in parameter statement "%s" of "%s"\n' % (e, ll))
+                continue
+            params = get_parameters(edecl)
+            k = rmbadname1(k)
+            if k not in edecl:
+                edecl[k] = {}
+            if '=' in edecl[k] and (not edecl[k]['='] == initexpr):
+                outmess('analyzeline: Overwriting the value of parameter "%s" ("%s") with "%s".\n' % (
+                    k, edecl[k]['='], initexpr))
+            t = determineexprtype(initexpr, params)
+            if t:
+                if t.get('typespec') == 'real':
+                    tt = list(initexpr)
+                    for m in real16pattern.finditer(initexpr):
+                        tt[m.start():m.end()] = list(
+                            initexpr[m.start():m.end()].lower().replace('d', 'e'))
+                    initexpr = ''.join(tt)
+                elif t.get('typespec') == 'complex':
+                    initexpr = initexpr[1:].lower().replace('d', 'e').\
+                        replace(',', '+1j*(')
+            try:
+                v = eval(initexpr, {}, params)
+            except (SyntaxError, NameError, TypeError) as msg:
+                errmess('analyzeline: Failed to evaluate %r. Ignoring: %s\n'
+                        % (initexpr, msg))
+                continue
+            edecl[k]['='] = repr(v)
+            if 'attrspec' in edecl[k]:
+                edecl[k]['attrspec'].append('parameter')
+            else:
+                edecl[k]['attrspec'] = ['parameter']
+            last_name = k
+        groupcache[groupcounter]['vars'] = edecl
+        if last_name is not None:
+            previous_context = ('variable', last_name, groupcounter)
+    elif case == 'implicit':
+        if m.group('after').strip().lower() == 'none':
+            groupcache[groupcounter]['implicit'] = None
+        elif m.group('after'):
+            if 'implicit' in groupcache[groupcounter]:
+                impl = groupcache[groupcounter]['implicit']
+            else:
+                impl = {}
+            if impl is None:
+                outmess(
+                    'analyzeline: Overwriting earlier "implicit none" statement.\n')
+                impl = {}
+            for e in markoutercomma(m.group('after')).split('@,@'):
+                decl = {}
+                m1 = re.match(
+                    r'\s*(?P.*?)\s*(\(\s*(?P[a-z-, ]+)\s*\)\s*|)\Z', e, re.I)
+                if not m1:
+                    outmess(
+                        'analyzeline: could not extract info of implicit statement part "%s"\n' % (e))
+                    continue
+                m2 = typespattern4implicit.match(m1.group('this'))
+                if not m2:
+                    outmess(
+                        'analyzeline: could not extract types pattern of implicit statement part "%s"\n' % (e))
+                    continue
+                typespec, selector, attr, edecl = cracktypespec0(
+                    m2.group('this'), m2.group('after'))
+                kindselect, charselect, typename = cracktypespec(
+                    typespec, selector)
+                decl['typespec'] = typespec
+                decl['kindselector'] = kindselect
+                decl['charselector'] = charselect
+                decl['typename'] = typename
+                for k in list(decl.keys()):
+                    if not decl[k]:
+                        del decl[k]
+                for r in markoutercomma(m1.group('after')).split('@,@'):
+                    if '-' in r:
+                        try:
+                            begc, endc = [x.strip() for x in r.split('-')]
+                        except Exception:
+                            outmess(
+                                'analyzeline: expected "-" instead of "%s" in range list of implicit statement\n' % r)
+                            continue
+                    else:
+                        begc = endc = r.strip()
+                    if not len(begc) == len(endc) == 1:
+                        outmess(
+                            'analyzeline: expected "-" instead of "%s" in range list of implicit statement (2)\n' % r)
+                        continue
+                    for o in range(ord(begc), ord(endc) + 1):
+                        impl[chr(o)] = decl
+            groupcache[groupcounter]['implicit'] = impl
+    elif case == 'data':
+        ll = []
+        dl = ''
+        il = ''
+        f = 0
+        fc = 1
+        inp = 0
+        for c in m.group('after'):
+            if not inp:
+                if c == "'":
+                    fc = not fc
+                if c == '/' and fc:
+                    f = f + 1
+                    continue
+            if c == '(':
+                inp = inp + 1
+            elif c == ')':
+                inp = inp - 1
+            if f == 0:
+                dl = dl + c
+            elif f == 1:
+                il = il + c
+            elif f == 2:
+                dl = dl.strip()
+                if dl.startswith(','):
+                    dl = dl[1:].strip()
+                ll.append([dl, il])
+                dl = c
+                il = ''
+                f = 0
+        if f == 2:
+            dl = dl.strip()
+            if dl.startswith(','):
+                dl = dl[1:].strip()
+            ll.append([dl, il])
+        vars = groupcache[groupcounter].get('vars', {})
+        last_name = None
+        for l in ll:
+            l[0], l[1] = l[0].strip(), l[1].strip()
+            if l[0].startswith(','):
+                l[0] = l[0][1:]
+            if l[0].startswith('('):
+                outmess('analyzeline: implied-DO list "%s" is not supported. Skipping.\n' % l[0])
+                continue
+            for idx, v in enumerate(rmbadname([x.strip() for x in markoutercomma(l[0]).split('@,@')])):
+                if v.startswith('('):
+                    outmess('analyzeline: implied-DO list "%s" is not supported. Skipping.\n' % v)
+                    # XXX: subsequent init expressions may get wrong values.
+                    # Ignoring since data statements are irrelevant for
+                    # wrapping.
+                    continue
+                if '!' in l[1]:
+                    # Fixes gh-24746 pyf generation
+                    # XXX: This essentially ignores the value for generating the pyf which is fine:
+                    # integer dimension(3) :: mytab
+                    # common /mycom/ mytab
+                    # Since in any case it is initialized in the Fortran code
+                    outmess('Comment line in declaration "%s" is not supported. Skipping.\n' % l[1])
+                    continue
+                vars.setdefault(v, {})
+                vtype = vars[v].get('typespec')
+                vdim = getdimension(vars[v])
+                matches = re.findall(r"\(.*?\)", l[1]) if vtype == 'complex' else l[1].split(',')
+                try:
+                    new_val = "(/{}/)".format(", ".join(matches)) if vdim else matches[idx]
+                except IndexError:
+                    # gh-24746
+                    # Runs only if above code fails. Fixes the line
+                    # DATA IVAR1, IVAR2, IVAR3, IVAR4, EVAR5 /4*0,0.0D0/
+                    # by expanding to ['0', '0', '0', '0', '0.0d0']
+                    if any("*" in m for m in matches):
+                        expanded_list = []
+                        for match in matches:
+                            if "*" in match:
+                                try:
+                                    multiplier, value = match.split("*")
+                                    expanded_list.extend([value.strip()] * int(multiplier))
+                                except ValueError: # if int(multiplier) fails
+                                    expanded_list.append(match.strip())
+                            else:
+                                expanded_list.append(match.strip())
+                        matches = expanded_list
+                    new_val = "(/{}/)".format(", ".join(matches)) if vdim else matches[idx]
+                current_val = vars[v].get('=')
+                if current_val and (current_val != new_val):
+                    outmess('analyzeline: changing init expression of "%s" ("%s") to "%s"\n' % (v, current_val, new_val))
+                vars[v]['='] = new_val
+                last_name = v
+        groupcache[groupcounter]['vars'] = vars
+        if last_name:
+            previous_context = ('variable', last_name, groupcounter)
+    elif case == 'common':
+        line = m.group('after').strip()
+        if not line[0] == '/':
+            line = '//' + line
+        cl = []
+        f = 0
+        bn = ''
+        ol = ''
+        for c in line:
+            if c == '/':
+                f = f + 1
+                continue
+            if f >= 3:
+                bn = bn.strip()
+                if not bn:
+                    bn = '_BLNK_'
+                cl.append([bn, ol])
+                f = f - 2
+                bn = ''
+                ol = ''
+            if f % 2:
+                bn = bn + c
+            else:
+                ol = ol + c
+        bn = bn.strip()
+        if not bn:
+            bn = '_BLNK_'
+        cl.append([bn, ol])
+        commonkey = {}
+        if 'common' in groupcache[groupcounter]:
+            commonkey = groupcache[groupcounter]['common']
+        for c in cl:
+            if c[0] not in commonkey:
+                commonkey[c[0]] = []
+            for i in [x.strip() for x in markoutercomma(c[1]).split('@,@')]:
+                if i:
+                    commonkey[c[0]].append(i)
+        groupcache[groupcounter]['common'] = commonkey
+        previous_context = ('common', bn, groupcounter)
+    elif case == 'use':
+        m1 = re.match(
+            r'\A\s*(?P\b\w+\b)\s*((,(\s*\bonly\b\s*:|(?P))\s*(?P.*))|)\s*\Z', m.group('after'), re.I)
+        if m1:
+            mm = m1.groupdict()
+            if 'use' not in groupcache[groupcounter]:
+                groupcache[groupcounter]['use'] = {}
+            name = m1.group('name')
+            groupcache[groupcounter]['use'][name] = {}
+            isonly = 0
+            if 'list' in mm and mm['list'] is not None:
+                if 'notonly' in mm and mm['notonly'] is None:
+                    isonly = 1
+                groupcache[groupcounter]['use'][name]['only'] = isonly
+                ll = [x.strip() for x in mm['list'].split(',')]
+                rl = {}
+                for l in ll:
+                    if '=' in l:
+                        m2 = re.match(
+                            r'\A\s*(?P\b\w+\b)\s*=\s*>\s*(?P\b\w+\b)\s*\Z', l, re.I)
+                        if m2:
+                            rl[m2.group('local').strip()] = m2.group(
+                                'use').strip()
+                        else:
+                            outmess(
+                                'analyzeline: Not local=>use pattern found in %s\n' % repr(l))
+                    else:
+                        rl[l] = l
+                    groupcache[groupcounter]['use'][name]['map'] = rl
+            else:
+                pass
+        else:
+            print(m.groupdict())
+            outmess('analyzeline: Could not crack the use statement.\n')
+    elif case in ['f2pyenhancements']:
+        if 'f2pyenhancements' not in groupcache[groupcounter]:
+            groupcache[groupcounter]['f2pyenhancements'] = {}
+        d = groupcache[groupcounter]['f2pyenhancements']
+        if m.group('this') == 'usercode' and 'usercode' in d:
+            if isinstance(d['usercode'], str):
+                d['usercode'] = [d['usercode']]
+            d['usercode'].append(m.group('after'))
+        else:
+            d[m.group('this')] = m.group('after')
+    elif case == 'multiline':
+        if previous_context is None:
+            if verbose:
+                outmess('analyzeline: No context for multiline block.\n')
+            return
+        gc = groupcounter
+        appendmultiline(groupcache[gc],
+                        previous_context[:2],
+                        m.group('this'))
+    else:
+        if verbose > 1:
+            print(m.groupdict())
+            outmess('analyzeline: No code implemented for line.\n')
+
+
+def appendmultiline(group, context_name, ml):
+    if 'f2pymultilines' not in group:
+        group['f2pymultilines'] = {}
+    d = group['f2pymultilines']
+    if context_name not in d:
+        d[context_name] = []
+    d[context_name].append(ml)
+    return
+
+
+def cracktypespec0(typespec, ll):
+    selector = None
+    attr = None
+    if re.match(r'double\s*complex', typespec, re.I):
+        typespec = 'double complex'
+    elif re.match(r'double\s*precision', typespec, re.I):
+        typespec = 'double precision'
+    else:
+        typespec = typespec.strip().lower()
+    m1 = selectpattern.match(markouterparen(ll))
+    if not m1:
+        outmess(
+            'cracktypespec0: no kind/char_selector pattern found for line.\n')
+        return
+    d = m1.groupdict()
+    for k in list(d.keys()):
+        d[k] = unmarkouterparen(d[k])
+    if typespec in ['complex', 'integer', 'logical', 'real', 'character', 'type']:
+        selector = d['this']
+        ll = d['after']
+    i = ll.find('::')
+    if i >= 0:
+        attr = ll[:i].strip()
+        ll = ll[i + 2:]
+    return typespec, selector, attr, ll
+#####
+namepattern = re.compile(r'\s*(?P\b\w+\b)\s*(?P.*)\s*\Z', re.I)
+kindselector = re.compile(
+    r'\s*(\(\s*(kind\s*=)?\s*(?P.*)\s*\)|\*\s*(?P.*?))\s*\Z', re.I)
+charselector = re.compile(
+    r'\s*(\((?P.*)\)|\*\s*(?P.*))\s*\Z', re.I)
+lenkindpattern = re.compile(
+    r'\s*(kind\s*=\s*(?P.*?)\s*(@,@\s*len\s*=\s*(?P.*)|)'
+    r'|(len\s*=\s*|)(?P.*?)\s*(@,@\s*(kind\s*=\s*|)(?P.*)'
+    r'|(f2py_len\s*=\s*(?P.*))|))\s*\Z', re.I)
+lenarraypattern = re.compile(
+    r'\s*(@\(@\s*(?!/)\s*(?P.*?)\s*@\)@\s*\*\s*(?P.*?)|(\*\s*(?P.*?)|)\s*(@\(@\s*(?!/)\s*(?P.*?)\s*@\)@|))\s*(=\s*(?P.*?)|(@\(@|)/\s*(?P.*?)\s*/(@\)@|)|)\s*\Z', re.I)
+
+
+def removespaces(expr):
+    expr = expr.strip()
+    if len(expr) <= 1:
+        return expr
+    expr2 = expr[0]
+    for i in range(1, len(expr) - 1):
+        if (expr[i] == ' ' and
+            ((expr[i + 1] in "()[]{}=+-/* ") or
+                (expr[i - 1] in "()[]{}=+-/* "))):
+            continue
+        expr2 = expr2 + expr[i]
+    expr2 = expr2 + expr[-1]
+    return expr2
+
+
+def markinnerspaces(line):
+    """
+    The function replace all spaces in the input variable line which are 
+    surrounded with quotation marks, with the triplet "@_@".
+
+    For instance, for the input "a 'b c'" the function returns "a 'b@_@c'"
+
+    Parameters
+    ----------
+    line : str
+
+    Returns
+    -------
+    str
+
+    """  
+    fragment = ''
+    inside = False
+    current_quote = None
+    escaped = ''
+    for c in line:
+        if escaped == '\\' and c in ['\\', '\'', '"']:
+            fragment += c
+            escaped = c
+            continue
+        if not inside and c in ['\'', '"']:
+            current_quote = c
+        if c == current_quote:
+            inside = not inside
+        elif c == ' ' and inside:
+            fragment += '@_@'
+            continue
+        fragment += c
+        escaped = c  # reset to non-backslash
+    return fragment
+
+
+def updatevars(typespec, selector, attrspec, entitydecl):
+    """
+    Returns last_name, the variable name without special chars, parenthesis
+        or dimension specifiers.
+
+    Alters groupcache to add the name, typespec, attrspec (and possibly value)
+    of current variable.
+    """
+    global groupcache, groupcounter
+
+    last_name = None
+    kindselect, charselect, typename = cracktypespec(typespec, selector)
+    # Clean up outer commas, whitespace and undesired chars from attrspec
+    if attrspec:
+        attrspec = [x.strip() for x in markoutercomma(attrspec).split('@,@')]
+        l = []
+        c = re.compile(r'(?P[a-zA-Z]+)')
+        for a in attrspec:
+            if not a:
+                continue
+            m = c.match(a)
+            if m:
+                s = m.group('start').lower()
+                a = s + a[len(s):]
+            l.append(a)
+        attrspec = l
+    el = [x.strip() for x in markoutercomma(entitydecl).split('@,@')]
+    el1 = []
+    for e in el:
+        for e1 in [x.strip() for x in markoutercomma(removespaces(markinnerspaces(e)), comma=' ').split('@ @')]:
+            if e1:
+                el1.append(e1.replace('@_@', ' '))
+    for e in el1:
+        m = namepattern.match(e)
+        if not m:
+            outmess(
+                'updatevars: no name pattern found for entity=%s. Skipping.\n' % (repr(e)))
+            continue
+        ename = rmbadname1(m.group('name'))
+        edecl = {}
+        if ename in groupcache[groupcounter]['vars']:
+            edecl = groupcache[groupcounter]['vars'][ename].copy()
+            not_has_typespec = 'typespec' not in edecl
+            if not_has_typespec:
+                edecl['typespec'] = typespec
+            elif typespec and (not typespec == edecl['typespec']):
+                outmess('updatevars: attempt to change the type of "%s" ("%s") to "%s". Ignoring.\n' % (
+                    ename, edecl['typespec'], typespec))
+            if 'kindselector' not in edecl:
+                edecl['kindselector'] = copy.copy(kindselect)
+            elif kindselect:
+                for k in list(kindselect.keys()):
+                    if k in edecl['kindselector'] and (not kindselect[k] == edecl['kindselector'][k]):
+                        outmess('updatevars: attempt to change the kindselector "%s" of "%s" ("%s") to "%s". Ignoring.\n' % (
+                            k, ename, edecl['kindselector'][k], kindselect[k]))
+                    else:
+                        edecl['kindselector'][k] = copy.copy(kindselect[k])
+            if 'charselector' not in edecl and charselect:
+                if not_has_typespec:
+                    edecl['charselector'] = charselect
+                else:
+                    errmess('updatevars:%s: attempt to change empty charselector to %r. Ignoring.\n'
+                            % (ename, charselect))
+            elif charselect:
+                for k in list(charselect.keys()):
+                    if k in edecl['charselector'] and (not charselect[k] == edecl['charselector'][k]):
+                        outmess('updatevars: attempt to change the charselector "%s" of "%s" ("%s") to "%s". Ignoring.\n' % (
+                            k, ename, edecl['charselector'][k], charselect[k]))
+                    else:
+                        edecl['charselector'][k] = copy.copy(charselect[k])
+            if 'typename' not in edecl:
+                edecl['typename'] = typename
+            elif typename and (not edecl['typename'] == typename):
+                outmess('updatevars: attempt to change the typename of "%s" ("%s") to "%s". Ignoring.\n' % (
+                    ename, edecl['typename'], typename))
+            if 'attrspec' not in edecl:
+                edecl['attrspec'] = copy.copy(attrspec)
+            elif attrspec:
+                for a in attrspec:
+                    if a not in edecl['attrspec']:
+                        edecl['attrspec'].append(a)
+        else:
+            edecl['typespec'] = copy.copy(typespec)
+            edecl['kindselector'] = copy.copy(kindselect)
+            edecl['charselector'] = copy.copy(charselect)
+            edecl['typename'] = typename
+            edecl['attrspec'] = copy.copy(attrspec)
+        if 'external' in (edecl.get('attrspec') or []) and e in groupcache[groupcounter]['args']:
+            if 'externals' not in groupcache[groupcounter]:
+                groupcache[groupcounter]['externals'] = []
+            groupcache[groupcounter]['externals'].append(e)
+        if m.group('after'):
+            m1 = lenarraypattern.match(markouterparen(m.group('after')))
+            if m1:
+                d1 = m1.groupdict()
+                for lk in ['len', 'array', 'init']:
+                    if d1[lk + '2'] is not None:
+                        d1[lk] = d1[lk + '2']
+                        del d1[lk + '2']
+                for k in list(d1.keys()):
+                    if d1[k] is not None:
+                        d1[k] = unmarkouterparen(d1[k])
+                    else:
+                        del d1[k]
+
+                if 'len' in d1 and 'array' in d1:
+                    if d1['len'] == '':
+                        d1['len'] = d1['array']
+                        del d1['array']
+                    elif typespec == 'character':
+                        if ('charselector' not in edecl) or (not edecl['charselector']):
+                            edecl['charselector'] = {}
+                        if 'len' in edecl['charselector']:
+                            del edecl['charselector']['len']
+                        edecl['charselector']['*'] = d1['len']
+                        del d1['len']
+                    else:
+                        d1['array'] = d1['array'] + ',' + d1['len']
+                        del d1['len']
+                        errmess('updatevars: "%s %s" is mapped to "%s %s(%s)"\n' % (
+                            typespec, e, typespec, ename, d1['array']))
+
+                if 'len' in d1:
+                    if typespec in ['complex', 'integer', 'logical', 'real']:
+                        if ('kindselector' not in edecl) or (not edecl['kindselector']):
+                            edecl['kindselector'] = {}
+                        edecl['kindselector']['*'] = d1['len']
+                        del d1['len']
+                    elif typespec == 'character':
+                        if ('charselector' not in edecl) or (not edecl['charselector']):
+                            edecl['charselector'] = {}
+                        if 'len' in edecl['charselector']:
+                            del edecl['charselector']['len']
+                        edecl['charselector']['*'] = d1['len']
+                        del d1['len']
+
+                if 'init' in d1:
+                    if '=' in edecl and (not edecl['='] == d1['init']):
+                        outmess('updatevars: attempt to change the init expression of "%s" ("%s") to "%s". Ignoring.\n' % (
+                            ename, edecl['='], d1['init']))
+                    else:
+                        edecl['='] = d1['init']
+
+                if 'array' in d1:
+                    dm = 'dimension(%s)' % d1['array']
+                    if 'attrspec' not in edecl or (not edecl['attrspec']):
+                        edecl['attrspec'] = [dm]
+                    else:
+                        edecl['attrspec'].append(dm)
+                        for dm1 in edecl['attrspec']:
+                            if dm1[:9] == 'dimension' and dm1 != dm:
+                                del edecl['attrspec'][-1]
+                                errmess('updatevars:%s: attempt to change %r to %r. Ignoring.\n'
+                                        % (ename, dm1, dm))
+                                break
+
+            else:
+                outmess('updatevars: could not crack entity declaration "%s". Ignoring.\n' % (
+                    ename + m.group('after')))
+        for k in list(edecl.keys()):
+            if not edecl[k]:
+                del edecl[k]
+        groupcache[groupcounter]['vars'][ename] = edecl
+        if 'varnames' in groupcache[groupcounter]:
+            groupcache[groupcounter]['varnames'].append(ename)
+        last_name = ename
+    return last_name
+
+
+def cracktypespec(typespec, selector):
+    kindselect = None
+    charselect = None
+    typename = None
+    if selector:
+        if typespec in ['complex', 'integer', 'logical', 'real']:
+            kindselect = kindselector.match(selector)
+            if not kindselect:
+                outmess(
+                    'cracktypespec: no kindselector pattern found for %s\n' % (repr(selector)))
+                return
+            kindselect = kindselect.groupdict()
+            kindselect['*'] = kindselect['kind2']
+            del kindselect['kind2']
+            for k in list(kindselect.keys()):
+                if not kindselect[k]:
+                    del kindselect[k]
+            for k, i in list(kindselect.items()):
+                kindselect[k] = rmbadname1(i)
+        elif typespec == 'character':
+            charselect = charselector.match(selector)
+            if not charselect:
+                outmess(
+                    'cracktypespec: no charselector pattern found for %s\n' % (repr(selector)))
+                return
+            charselect = charselect.groupdict()
+            charselect['*'] = charselect['charlen']
+            del charselect['charlen']
+            if charselect['lenkind']:
+                lenkind = lenkindpattern.match(
+                    markoutercomma(charselect['lenkind']))
+                lenkind = lenkind.groupdict()
+                for lk in ['len', 'kind']:
+                    if lenkind[lk + '2']:
+                        lenkind[lk] = lenkind[lk + '2']
+                    charselect[lk] = lenkind[lk]
+                    del lenkind[lk + '2']
+                if lenkind['f2py_len'] is not None:
+                    # used to specify the length of assumed length strings
+                    charselect['f2py_len'] = lenkind['f2py_len']
+            del charselect['lenkind']
+            for k in list(charselect.keys()):
+                if not charselect[k]:
+                    del charselect[k]
+            for k, i in list(charselect.items()):
+                charselect[k] = rmbadname1(i)
+        elif typespec == 'type':
+            typename = re.match(r'\s*\(\s*(?P\w+)\s*\)', selector, re.I)
+            if typename:
+                typename = typename.group('name')
+            else:
+                outmess('cracktypespec: no typename found in %s\n' %
+                        (repr(typespec + selector)))
+        else:
+            outmess('cracktypespec: no selector used for %s\n' %
+                    (repr(selector)))
+    return kindselect, charselect, typename
+######
+
+
+def setattrspec(decl, attr, force=0):
+    if not decl:
+        decl = {}
+    if not attr:
+        return decl
+    if 'attrspec' not in decl:
+        decl['attrspec'] = [attr]
+        return decl
+    if force:
+        decl['attrspec'].append(attr)
+    if attr in decl['attrspec']:
+        return decl
+    if attr == 'static' and 'automatic' not in decl['attrspec']:
+        decl['attrspec'].append(attr)
+    elif attr == 'automatic' and 'static' not in decl['attrspec']:
+        decl['attrspec'].append(attr)
+    elif attr == 'public':
+        if 'private' not in decl['attrspec']:
+            decl['attrspec'].append(attr)
+    elif attr == 'private':
+        if 'public' not in decl['attrspec']:
+            decl['attrspec'].append(attr)
+    else:
+        decl['attrspec'].append(attr)
+    return decl
+
+
+def setkindselector(decl, sel, force=0):
+    if not decl:
+        decl = {}
+    if not sel:
+        return decl
+    if 'kindselector' not in decl:
+        decl['kindselector'] = sel
+        return decl
+    for k in list(sel.keys()):
+        if force or k not in decl['kindselector']:
+            decl['kindselector'][k] = sel[k]
+    return decl
+
+
+def setcharselector(decl, sel, force=0):
+    if not decl:
+        decl = {}
+    if not sel:
+        return decl
+    if 'charselector' not in decl:
+        decl['charselector'] = sel
+        return decl
+
+    for k in list(sel.keys()):
+        if force or k not in decl['charselector']:
+            decl['charselector'][k] = sel[k]
+    return decl
+
+
+def getblockname(block, unknown='unknown'):
+    if 'name' in block:
+        return block['name']
+    return unknown
+
+# post processing
+
+
+def setmesstext(block):
+    global filepositiontext
+
+    try:
+        filepositiontext = 'In: %s:%s\n' % (block['from'], block['name'])
+    except Exception:
+        pass
+
+
+def get_usedict(block):
+    usedict = {}
+    if 'parent_block' in block:
+        usedict = get_usedict(block['parent_block'])
+    if 'use' in block:
+        usedict.update(block['use'])
+    return usedict
+
+
+def get_useparameters(block, param_map=None):
+    global f90modulevars
+
+    if param_map is None:
+        param_map = {}
+    usedict = get_usedict(block)
+    if not usedict:
+        return param_map
+    for usename, mapping in list(usedict.items()):
+        usename = usename.lower()
+        if usename not in f90modulevars:
+            outmess('get_useparameters: no module %s info used by %s\n' %
+                    (usename, block.get('name')))
+            continue
+        mvars = f90modulevars[usename]
+        params = get_parameters(mvars)
+        if not params:
+            continue
+        # XXX: apply mapping
+        if mapping:
+            errmess('get_useparameters: mapping for %s not impl.\n' % (mapping))
+        for k, v in list(params.items()):
+            if k in param_map:
+                outmess('get_useparameters: overriding parameter %s with'
+                        ' value from module %s\n' % (repr(k), repr(usename)))
+            param_map[k] = v
+
+    return param_map
+
+
+def postcrack2(block, tab='', param_map=None):
+    global f90modulevars
+
+    if not f90modulevars:
+        return block
+    if isinstance(block, list):
+        ret = [postcrack2(g, tab=tab + '\t', param_map=param_map)
+               for g in block]
+        return ret
+    setmesstext(block)
+    outmess('%sBlock: %s\n' % (tab, block['name']), 0)
+
+    if param_map is None:
+        param_map = get_useparameters(block)
+
+    if param_map is not None and 'vars' in block:
+        vars = block['vars']
+        for n in list(vars.keys()):
+            var = vars[n]
+            if 'kindselector' in var:
+                kind = var['kindselector']
+                if 'kind' in kind:
+                    val = kind['kind']
+                    if val in param_map:
+                        kind['kind'] = param_map[val]
+    new_body = [postcrack2(b, tab=tab + '\t', param_map=param_map)
+                for b in block['body']]
+    block['body'] = new_body
+
+    return block
+
+
+def postcrack(block, args=None, tab=''):
+    """
+    TODO:
+          function return values
+          determine expression types if in argument list
+    """
+    global usermodules, onlyfunctions
+
+    if isinstance(block, list):
+        gret = []
+        uret = []
+        for g in block:
+            setmesstext(g)
+            g = postcrack(g, tab=tab + '\t')
+            # sort user routines to appear first
+            if 'name' in g and '__user__' in g['name']:
+                uret.append(g)
+            else:
+                gret.append(g)
+        return uret + gret
+    setmesstext(block)
+    if not isinstance(block, dict) and 'block' not in block:
+        raise Exception('postcrack: Expected block dictionary instead of ' +
+                        str(block))
+    if 'name' in block and not block['name'] == 'unknown_interface':
+        outmess('%sBlock: %s\n' % (tab, block['name']), 0)
+    block = analyzeargs(block)
+    block = analyzecommon(block)
+    block['vars'] = analyzevars(block)
+    block['sortvars'] = sortvarnames(block['vars'])
+    if 'args' in block and block['args']:
+        args = block['args']
+    block['body'] = analyzebody(block, args, tab=tab)
+
+    userisdefined = []
+    if 'use' in block:
+        useblock = block['use']
+        for k in list(useblock.keys()):
+            if '__user__' in k:
+                userisdefined.append(k)
+    else:
+        useblock = {}
+    name = ''
+    if 'name' in block:
+        name = block['name']
+    # and not userisdefined: # Build a __user__ module
+    if 'externals' in block and block['externals']:
+        interfaced = []
+        if 'interfaced' in block:
+            interfaced = block['interfaced']
+        mvars = copy.copy(block['vars'])
+        if name:
+            mname = name + '__user__routines'
+        else:
+            mname = 'unknown__user__routines'
+        if mname in userisdefined:
+            i = 1
+            while '%s_%i' % (mname, i) in userisdefined:
+                i = i + 1
+            mname = '%s_%i' % (mname, i)
+        interface = {'block': 'interface', 'body': [],
+                     'vars': {}, 'name': name + '_user_interface'}
+        for e in block['externals']:
+            if e in interfaced:
+                edef = []
+                j = -1
+                for b in block['body']:
+                    j = j + 1
+                    if b['block'] == 'interface':
+                        i = -1
+                        for bb in b['body']:
+                            i = i + 1
+                            if 'name' in bb and bb['name'] == e:
+                                edef = copy.copy(bb)
+                                del b['body'][i]
+                                break
+                        if edef:
+                            if not b['body']:
+                                del block['body'][j]
+                            del interfaced[interfaced.index(e)]
+                            break
+                interface['body'].append(edef)
+            else:
+                if e in mvars and not isexternal(mvars[e]):
+                    interface['vars'][e] = mvars[e]
+        if interface['vars'] or interface['body']:
+            block['interfaced'] = interfaced
+            mblock = {'block': 'python module', 'body': [
+                interface], 'vars': {}, 'name': mname, 'interfaced': block['externals']}
+            useblock[mname] = {}
+            usermodules.append(mblock)
+    if useblock:
+        block['use'] = useblock
+    return block
+
+
+def sortvarnames(vars):
+    indep = []
+    dep = []
+    for v in list(vars.keys()):
+        if 'depend' in vars[v] and vars[v]['depend']:
+            dep.append(v)
+        else:
+            indep.append(v)
+    n = len(dep)
+    i = 0
+    while dep:  # XXX: How to catch dependence cycles correctly?
+        v = dep[0]
+        fl = 0
+        for w in dep[1:]:
+            if w in vars[v]['depend']:
+                fl = 1
+                break
+        if fl:
+            dep = dep[1:] + [v]
+            i = i + 1
+            if i > n:
+                errmess('sortvarnames: failed to compute dependencies because'
+                        ' of cyclic dependencies between '
+                        + ', '.join(dep) + '\n')
+                indep = indep + dep
+                break
+        else:
+            indep.append(v)
+            dep = dep[1:]
+            n = len(dep)
+            i = 0
+    return indep
+
+
+def analyzecommon(block):
+    if not hascommon(block):
+        return block
+    commonvars = []
+    for k in list(block['common'].keys()):
+        comvars = []
+        for e in block['common'][k]:
+            m = re.match(
+                r'\A\s*\b(?P.*?)\b\s*(\((?P.*?)\)|)\s*\Z', e, re.I)
+            if m:
+                dims = []
+                if m.group('dims'):
+                    dims = [x.strip()
+                            for x in markoutercomma(m.group('dims')).split('@,@')]
+                n = rmbadname1(m.group('name').strip())
+                if n in block['vars']:
+                    if 'attrspec' in block['vars'][n]:
+                        block['vars'][n]['attrspec'].append(
+                            'dimension(%s)' % (','.join(dims)))
+                    else:
+                        block['vars'][n]['attrspec'] = [
+                            'dimension(%s)' % (','.join(dims))]
+                else:
+                    if dims:
+                        block['vars'][n] = {
+                            'attrspec': ['dimension(%s)' % (','.join(dims))]}
+                    else:
+                        block['vars'][n] = {}
+                if n not in commonvars:
+                    commonvars.append(n)
+            else:
+                n = e
+                errmess(
+                    'analyzecommon: failed to extract "[()]" from "%s" in common /%s/.\n' % (e, k))
+            comvars.append(n)
+        block['common'][k] = comvars
+    if 'commonvars' not in block:
+        block['commonvars'] = commonvars
+    else:
+        block['commonvars'] = block['commonvars'] + commonvars
+    return block
+
+
+def analyzebody(block, args, tab=''):
+    global usermodules, skipfuncs, onlyfuncs, f90modulevars
+
+    setmesstext(block)
+
+    maybe_private = {
+        key: value
+        for key, value in block['vars'].items()
+        if 'attrspec' not in value or 'public' not in value['attrspec']
+    }
+
+    body = []
+    for b in block['body']:
+        b['parent_block'] = block
+        if b['block'] in ['function', 'subroutine']:
+            if args is not None and b['name'] not in args:
+                continue
+            else:
+                as_ = b['args']
+            # Add private members to skipfuncs for gh-23879
+            if b['name'] in maybe_private.keys():
+                skipfuncs.append(b['name'])
+            if b['name'] in skipfuncs:
+                continue
+            if onlyfuncs and b['name'] not in onlyfuncs:
+                continue
+            b['saved_interface'] = crack2fortrangen(
+                b, '\n' + ' ' * 6, as_interface=True)
+
+        else:
+            as_ = args
+        b = postcrack(b, as_, tab=tab + '\t')
+        if b['block'] in ['interface', 'abstract interface'] and \
+           not b['body'] and not b.get('implementedby'):
+            if 'f2pyenhancements' not in b:
+                continue
+        if b['block'].replace(' ', '') == 'pythonmodule':
+            usermodules.append(b)
+        else:
+            if b['block'] == 'module':
+                f90modulevars[b['name']] = b['vars']
+            body.append(b)
+    return body
+
+
+def buildimplicitrules(block):
+    setmesstext(block)
+    implicitrules = defaultimplicitrules
+    attrrules = {}
+    if 'implicit' in block:
+        if block['implicit'] is None:
+            implicitrules = None
+            if verbose > 1:
+                outmess(
+                    'buildimplicitrules: no implicit rules for routine %s.\n' % repr(block['name']))
+        else:
+            for k in list(block['implicit'].keys()):
+                if block['implicit'][k].get('typespec') not in ['static', 'automatic']:
+                    implicitrules[k] = block['implicit'][k]
+                else:
+                    attrrules[k] = block['implicit'][k]['typespec']
+    return implicitrules, attrrules
+
+
+def myeval(e, g=None, l=None):
+    """ Like `eval` but returns only integers and floats """
+    r = eval(e, g, l)
+    if type(r) in [int, float]:
+        return r
+    raise ValueError('r=%r' % (r))
+
+getlincoef_re_1 = re.compile(r'\A\b\w+\b\Z', re.I)
+
+
+def getlincoef(e, xset):  # e = a*x+b ; x in xset
+    """
+    Obtain ``a`` and ``b`` when ``e == "a*x+b"``, where ``x`` is a symbol in
+    xset.
+
+    >>> getlincoef('2*x + 1', {'x'})
+    (2, 1, 'x')
+    >>> getlincoef('3*x + x*2 + 2 + 1', {'x'})
+    (5, 3, 'x')
+    >>> getlincoef('0', {'x'})
+    (0, 0, None)
+    >>> getlincoef('0*x', {'x'})
+    (0, 0, 'x')
+    >>> getlincoef('x*x', {'x'})
+    (None, None, None)
+
+    This can be tricked by sufficiently complex expressions
+
+    >>> getlincoef('(x - 0.5)*(x - 1.5)*(x - 1)*x + 2*x + 3', {'x'})
+    (2.0, 3.0, 'x')
+    """
+    try:
+        c = int(myeval(e, {}, {}))
+        return 0, c, None
+    except Exception:
+        pass
+    if getlincoef_re_1.match(e):
+        return 1, 0, e
+    len_e = len(e)
+    for x in xset:
+        if len(x) > len_e:
+            continue
+        if re.search(r'\w\s*\([^)]*\b' + x + r'\b', e):
+            # skip function calls having x as an argument, e.g max(1, x)
+            continue
+        re_1 = re.compile(r'(?P.*?)\b' + x + r'\b(?P.*)', re.I)
+        m = re_1.match(e)
+        if m:
+            try:
+                m1 = re_1.match(e)
+                while m1:
+                    ee = '%s(%s)%s' % (
+                        m1.group('before'), 0, m1.group('after'))
+                    m1 = re_1.match(ee)
+                b = myeval(ee, {}, {})
+                m1 = re_1.match(e)
+                while m1:
+                    ee = '%s(%s)%s' % (
+                        m1.group('before'), 1, m1.group('after'))
+                    m1 = re_1.match(ee)
+                a = myeval(ee, {}, {}) - b
+                m1 = re_1.match(e)
+                while m1:
+                    ee = '%s(%s)%s' % (
+                        m1.group('before'), 0.5, m1.group('after'))
+                    m1 = re_1.match(ee)
+                c = myeval(ee, {}, {})
+                # computing another point to be sure that expression is linear
+                m1 = re_1.match(e)
+                while m1:
+                    ee = '%s(%s)%s' % (
+                        m1.group('before'), 1.5, m1.group('after'))
+                    m1 = re_1.match(ee)
+                c2 = myeval(ee, {}, {})
+                if (a * 0.5 + b == c and a * 1.5 + b == c2):
+                    return a, b, x
+            except Exception:
+                pass
+            break
+    return None, None, None
+
+
+word_pattern = re.compile(r'\b[a-z][\w$]*\b', re.I)
+
+
+def _get_depend_dict(name, vars, deps):
+    if name in vars:
+        words = vars[name].get('depend', [])
+
+        if '=' in vars[name] and not isstring(vars[name]):
+            for word in word_pattern.findall(vars[name]['=']):
+                # The word_pattern may return values that are not
+                # only variables, they can be string content for instance
+                if word not in words and word in vars and word != name:
+                    words.append(word)
+        for word in words[:]:
+            for w in deps.get(word, []) \
+                    or _get_depend_dict(word, vars, deps):
+                if w not in words:
+                    words.append(w)
+    else:
+        outmess('_get_depend_dict: no dependence info for %s\n' % (repr(name)))
+        words = []
+    deps[name] = words
+    return words
+
+
+def _calc_depend_dict(vars):
+    names = list(vars.keys())
+    depend_dict = {}
+    for n in names:
+        _get_depend_dict(n, vars, depend_dict)
+    return depend_dict
+
+
+def get_sorted_names(vars):
+    depend_dict = _calc_depend_dict(vars)
+    names = []
+    for name in list(depend_dict.keys()):
+        if not depend_dict[name]:
+            names.append(name)
+            del depend_dict[name]
+    while depend_dict:
+        for name, lst in list(depend_dict.items()):
+            new_lst = [n for n in lst if n in depend_dict]
+            if not new_lst:
+                names.append(name)
+                del depend_dict[name]
+            else:
+                depend_dict[name] = new_lst
+    return [name for name in names if name in vars]
+
+
+def _kind_func(string):
+    # XXX: return something sensible.
+    if string[0] in "'\"":
+        string = string[1:-1]
+    if real16pattern.match(string):
+        return 8
+    elif real8pattern.match(string):
+        return 4
+    return 'kind(' + string + ')'
+
+
+def _selected_int_kind_func(r):
+    # XXX: This should be processor dependent
+    m = 10 ** r
+    if m <= 2 ** 8:
+        return 1
+    if m <= 2 ** 16:
+        return 2
+    if m <= 2 ** 32:
+        return 4
+    if m <= 2 ** 63:
+        return 8
+    if m <= 2 ** 128:
+        return 16
+    return -1
+
+
+def _selected_real_kind_func(p, r=0, radix=0):
+    # XXX: This should be processor dependent
+    # This is only verified for 0 <= p <= 20, possibly good for p <= 33 and above
+    if p < 7:
+        return 4
+    if p < 16:
+        return 8
+    machine = platform.machine().lower()
+    if machine.startswith(('aarch64', 'alpha', 'arm64', 'loongarch', 'mips', 'power', 'ppc', 'riscv', 's390x', 'sparc')):
+        if p <= 33:
+            return 16
+    else:
+        if p < 19:
+            return 10
+        elif p <= 33:
+            return 16
+    return -1
+
+
+def get_parameters(vars, global_params={}):
+    params = copy.copy(global_params)
+    g_params = copy.copy(global_params)
+    for name, func in [('kind', _kind_func),
+                       ('selected_int_kind', _selected_int_kind_func),
+                       ('selected_real_kind', _selected_real_kind_func), ]:
+        if name not in g_params:
+            g_params[name] = func
+    param_names = []
+    for n in get_sorted_names(vars):
+        if 'attrspec' in vars[n] and 'parameter' in vars[n]['attrspec']:
+            param_names.append(n)
+    kind_re = re.compile(r'\bkind\s*\(\s*(?P.*)\s*\)', re.I)
+    selected_int_kind_re = re.compile(
+        r'\bselected_int_kind\s*\(\s*(?P.*)\s*\)', re.I)
+    selected_kind_re = re.compile(
+        r'\bselected_(int|real)_kind\s*\(\s*(?P.*)\s*\)', re.I)
+    for n in param_names:
+        if '=' in vars[n]:
+            v = vars[n]['=']
+            if islogical(vars[n]):
+                v = v.lower()
+                for repl in [
+                    ('.false.', 'False'),
+                    ('.true.', 'True'),
+                    # TODO: test .eq., .neq., etc replacements.
+                ]:
+                    v = v.replace(*repl)
+
+            v = kind_re.sub(r'kind("\1")', v)
+            v = selected_int_kind_re.sub(r'selected_int_kind(\1)', v)
+
+            # We need to act according to the data.
+            # The easy case is if the data has a kind-specifier,
+            # then we may easily remove those specifiers.
+            # However, it may be that the user uses other specifiers...(!)
+            is_replaced = False
+
+            if 'kindselector' in vars[n]:
+                # Remove kind specifier (including those defined
+                # by parameters)
+                if 'kind' in vars[n]['kindselector']:
+                    orig_v_len = len(v)
+                    v = v.replace('_' + vars[n]['kindselector']['kind'], '')
+                    # Again, this will be true if even a single specifier
+                    # has been replaced, see comment above.
+                    is_replaced = len(v) < orig_v_len
+
+            if not is_replaced:
+                if not selected_kind_re.match(v):
+                    v_ = v.split('_')
+                    # In case there are additive parameters
+                    if len(v_) > 1: 
+                        v = ''.join(v_[:-1]).lower().replace(v_[-1].lower(), '')
+
+            # Currently this will not work for complex numbers.
+            # There is missing code for extracting a complex number,
+            # which may be defined in either of these:
+            #  a) (Re, Im)
+            #  b) cmplx(Re, Im)
+            #  c) dcmplx(Re, Im)
+            #  d) cmplx(Re, Im, )
+
+            if isdouble(vars[n]):
+                tt = list(v)
+                for m in real16pattern.finditer(v):
+                    tt[m.start():m.end()] = list(
+                        v[m.start():m.end()].lower().replace('d', 'e'))
+                v = ''.join(tt)
+
+            elif iscomplex(vars[n]):
+                outmess(f'get_parameters[TODO]: '
+                        f'implement evaluation of complex expression {v}\n')
+
+            dimspec = ([s.removeprefix('dimension').strip()
+                        for s in vars[n]['attrspec']
+                       if s.startswith('dimension')] or [None])[0]
+
+            # Handle _dp for gh-6624
+            # Also fixes gh-20460
+            if real16pattern.search(v):
+                v = 8
+            elif real8pattern.search(v):
+                v = 4
+            try:
+                params[n] = param_eval(v, g_params, params, dimspec=dimspec)
+            except Exception as msg:
+                params[n] = v
+                outmess(f'get_parameters: got "{msg}" on {n!r}\n')
+
+            if isstring(vars[n]) and isinstance(params[n], int):
+                params[n] = chr(params[n])
+            nl = n.lower()
+            if nl != n:
+                params[nl] = params[n]
+        else:
+            print(vars[n])
+            outmess(f'get_parameters:parameter {n!r} does not have value?!\n')
+    return params
+
+
+def _eval_length(length, params):
+    if length in ['(:)', '(*)', '*']:
+        return '(*)'
+    return _eval_scalar(length, params)
+
+
+_is_kind_number = re.compile(r'\d+_').match
+
+
+def _eval_scalar(value, params):
+    if _is_kind_number(value):
+        value = value.split('_')[0]
+    try:
+        # TODO: use symbolic from PR #19805
+        value = eval(value, {}, params)
+        value = (repr if isinstance(value, str) else str)(value)
+    except (NameError, SyntaxError, TypeError):
+        return value
+    except Exception as msg:
+        errmess('"%s" in evaluating %r '
+                '(available names: %s)\n'
+                % (msg, value, list(params.keys())))
+    return value
+
+
+def analyzevars(block):
+    """
+    Sets correct dimension information for each variable/parameter
+    """
+
+    global f90modulevars
+
+    setmesstext(block)
+    implicitrules, attrrules = buildimplicitrules(block)
+    vars = copy.copy(block['vars'])
+    if block['block'] == 'function' and block['name'] not in vars:
+        vars[block['name']] = {}
+    if '' in block['vars']:
+        del vars['']
+        if 'attrspec' in block['vars']['']:
+            gen = block['vars']['']['attrspec']
+            for n in set(vars) | set(b['name'] for b in block['body']):
+                for k in ['public', 'private']:
+                    if k in gen:
+                        vars[n] = setattrspec(vars.get(n, {}), k)
+    svars = []
+    args = block['args']
+    for a in args:
+        try:
+            vars[a]
+            svars.append(a)
+        except KeyError:
+            pass
+    for n in list(vars.keys()):
+        if n not in args:
+            svars.append(n)
+
+    params = get_parameters(vars, get_useparameters(block))
+    # At this point, params are read and interpreted, but
+    # the params used to define vars are not yet parsed
+    dep_matches = {}
+    name_match = re.compile(r'[A-Za-z][\w$]*').match
+    for v in list(vars.keys()):
+        m = name_match(v)
+        if m:
+            n = v[m.start():m.end()]
+            try:
+                dep_matches[n]
+            except KeyError:
+                dep_matches[n] = re.compile(r'.*\b%s\b' % (v), re.I).match
+    for n in svars:
+        if n[0] in list(attrrules.keys()):
+            vars[n] = setattrspec(vars[n], attrrules[n[0]])
+        if 'typespec' not in vars[n]:
+            if not('attrspec' in vars[n] and 'external' in vars[n]['attrspec']):
+                if implicitrules:
+                    ln0 = n[0].lower()
+                    for k in list(implicitrules[ln0].keys()):
+                        if k == 'typespec' and implicitrules[ln0][k] == 'undefined':
+                            continue
+                        if k not in vars[n]:
+                            vars[n][k] = implicitrules[ln0][k]
+                        elif k == 'attrspec':
+                            for l in implicitrules[ln0][k]:
+                                vars[n] = setattrspec(vars[n], l)
+                elif n in block['args']:
+                    outmess('analyzevars: typespec of variable %s is not defined in routine %s.\n' % (
+                        repr(n), block['name']))
+        if 'charselector' in vars[n]:
+            if 'len' in vars[n]['charselector']:
+                l = vars[n]['charselector']['len']
+                try:
+                    l = str(eval(l, {}, params))
+                except Exception:
+                    pass
+                vars[n]['charselector']['len'] = l
+
+        if 'kindselector' in vars[n]:
+            if 'kind' in vars[n]['kindselector']:
+                l = vars[n]['kindselector']['kind']
+                try:
+                    l = str(eval(l, {}, params))
+                except Exception:
+                    pass
+                vars[n]['kindselector']['kind'] = l
+
+        dimension_exprs = {}
+        if 'attrspec' in vars[n]:
+            attr = vars[n]['attrspec']
+            attr.reverse()
+            vars[n]['attrspec'] = []
+            dim, intent, depend, check, note = None, None, None, None, None
+            for a in attr:
+                if a[:9] == 'dimension':
+                    dim = (a[9:].strip())[1:-1]
+                elif a[:6] == 'intent':
+                    intent = (a[6:].strip())[1:-1]
+                elif a[:6] == 'depend':
+                    depend = (a[6:].strip())[1:-1]
+                elif a[:5] == 'check':
+                    check = (a[5:].strip())[1:-1]
+                elif a[:4] == 'note':
+                    note = (a[4:].strip())[1:-1]
+                else:
+                    vars[n] = setattrspec(vars[n], a)
+                if intent:
+                    if 'intent' not in vars[n]:
+                        vars[n]['intent'] = []
+                    for c in [x.strip() for x in markoutercomma(intent).split('@,@')]:
+                        # Remove spaces so that 'in out' becomes 'inout'
+                        tmp = c.replace(' ', '')
+                        if tmp not in vars[n]['intent']:
+                            vars[n]['intent'].append(tmp)
+                    intent = None
+                if note:
+                    note = note.replace('\\n\\n', '\n\n')
+                    note = note.replace('\\n ', '\n')
+                    if 'note' not in vars[n]:
+                        vars[n]['note'] = [note]
+                    else:
+                        vars[n]['note'].append(note)
+                    note = None
+                if depend is not None:
+                    if 'depend' not in vars[n]:
+                        vars[n]['depend'] = []
+                    for c in rmbadname([x.strip() for x in markoutercomma(depend).split('@,@')]):
+                        if c not in vars[n]['depend']:
+                            vars[n]['depend'].append(c)
+                    depend = None
+                if check is not None:
+                    if 'check' not in vars[n]:
+                        vars[n]['check'] = []
+                    for c in [x.strip() for x in markoutercomma(check).split('@,@')]:
+                        if c not in vars[n]['check']:
+                            vars[n]['check'].append(c)
+                    check = None
+            if dim and 'dimension' not in vars[n]:
+                vars[n]['dimension'] = []
+                for d in rmbadname(
+                        [x.strip() for x in markoutercomma(dim).split('@,@')]
+                ):
+                    # d is the expression inside the dimension declaration
+                    # Evaluate `d` with respect to params
+                    try:
+                        # the dimension for this variable depends on a
+                        # previously defined parameter
+                        d = param_parse(d, params)
+                    except (ValueError, IndexError, KeyError):
+                        outmess(
+                            'analyzevars: could not parse dimension for '
+                            f'variable {d!r}\n'
+                        )
+
+                    dim_char = ':' if d == ':' else '*'
+                    if d == dim_char:
+                        dl = [dim_char]
+                    else:
+                        dl = markoutercomma(d, ':').split('@:@')
+                    if len(dl) == 2 and '*' in dl:  # e.g. dimension(5:*)
+                        dl = ['*']
+                        d = '*'
+                    if len(dl) == 1 and dl[0] != dim_char:
+                        dl = ['1', dl[0]]
+                    if len(dl) == 2:
+                        d1, d2 = map(symbolic.Expr.parse, dl)
+                        dsize = d2 - d1 + 1
+                        d = dsize.tostring(language=symbolic.Language.C)
+                        # find variables v that define d as a linear
+                        # function, `d == a * v + b`, and store
+                        # coefficients a and b for further analysis.
+                        solver_and_deps = {}
+                        for v in block['vars']:
+                            s = symbolic.as_symbol(v)
+                            if dsize.contains(s):
+                                try:
+                                    a, b = dsize.linear_solve(s)
+
+                                    def solve_v(s, a=a, b=b):
+                                        return (s - b) / a
+
+                                    all_symbols = set(a.symbols())
+                                    all_symbols.update(b.symbols())
+                                except RuntimeError as msg:
+                                    # d is not a linear function of v,
+                                    # however, if v can be determined
+                                    # from d using other means,
+                                    # implement the corresponding
+                                    # solve_v function here.
+                                    solve_v = None
+                                    all_symbols = set(dsize.symbols())
+                                v_deps = set(
+                                    s.data for s in all_symbols
+                                    if s.data in vars)
+                                solver_and_deps[v] = solve_v, list(v_deps)
+                        # Note that dsize may contain symbols that are
+                        # not defined in block['vars']. Here we assume
+                        # these correspond to Fortran/C intrinsic
+                        # functions or that are defined by other
+                        # means. We'll let the compiler validate the
+                        # definiteness of such symbols.
+                        dimension_exprs[d] = solver_and_deps
+                    vars[n]['dimension'].append(d)
+
+        if 'check' not in vars[n] and 'args' in block and n in block['args']:
+            # n is an argument that has no checks defined. Here we
+            # generate some consistency checks for n, and when n is an
+            # array, generate checks for its dimensions and construct
+            # initialization expressions.
+            n_deps = vars[n].get('depend', [])
+            n_checks = []
+            n_is_input = l_or(isintent_in, isintent_inout,
+                              isintent_inplace)(vars[n])
+            if isarray(vars[n]):  # n is array
+                for i, d in enumerate(vars[n]['dimension']):
+                    coeffs_and_deps = dimension_exprs.get(d)
+                    if coeffs_and_deps is None:
+                        # d is `:` or `*` or a constant expression
+                        pass
+                    elif n_is_input:
+                        # n is an input array argument and its shape
+                        # may define variables used in dimension
+                        # specifications.
+                        for v, (solver, deps) in coeffs_and_deps.items():
+                            def compute_deps(v, deps):
+                                for v1 in coeffs_and_deps.get(v, [None, []])[1]:
+                                    if v1 not in deps:
+                                        deps.add(v1)
+                                        compute_deps(v1, deps)
+                            all_deps = set()
+                            compute_deps(v, all_deps)
+                            if (v in n_deps
+                                 or '=' in vars[v]
+                                 or 'depend' in vars[v]):
+                                # Skip a variable that
+                                # - n depends on
+                                # - has user-defined initialization expression
+                                # - has user-defined dependencies
+                                continue
+                            if solver is not None and v not in all_deps:
+                                # v can be solved from d, hence, we
+                                # make it an optional argument with
+                                # initialization expression:
+                                is_required = False
+                                init = solver(symbolic.as_symbol(
+                                    f'shape({n}, {i})'))
+                                init = init.tostring(
+                                    language=symbolic.Language.C)
+                                vars[v]['='] = init
+                                # n needs to be initialized before v. So,
+                                # making v dependent on n and on any
+                                # variables in solver or d.
+                                vars[v]['depend'] = [n] + deps
+                                if 'check' not in vars[v]:
+                                    # add check only when no
+                                    # user-specified checks exist
+                                    vars[v]['check'] = [
+                                        f'shape({n}, {i}) == {d}']
+                            else:
+                                # d is a non-linear function on v,
+                                # hence, v must be a required input
+                                # argument that n will depend on
+                                is_required = True
+                                if 'intent' not in vars[v]:
+                                    vars[v]['intent'] = []
+                                if 'in' not in vars[v]['intent']:
+                                    vars[v]['intent'].append('in')
+                                # v needs to be initialized before n
+                                n_deps.append(v)
+                                n_checks.append(
+                                    f'shape({n}, {i}) == {d}')
+                            v_attr = vars[v].get('attrspec', [])
+                            if not ('optional' in v_attr
+                                    or 'required' in v_attr):
+                                v_attr.append(
+                                    'required' if is_required else 'optional')
+                            if v_attr:
+                                vars[v]['attrspec'] = v_attr
+                    if coeffs_and_deps is not None:
+                        # extend v dependencies with ones specified in attrspec
+                        for v, (solver, deps) in coeffs_and_deps.items():
+                            v_deps = vars[v].get('depend', [])
+                            for aa in vars[v].get('attrspec', []):
+                                if aa.startswith('depend'):
+                                    aa = ''.join(aa.split())
+                                    v_deps.extend(aa[7:-1].split(','))
+                            if v_deps:
+                                vars[v]['depend'] = list(set(v_deps))
+                            if n not in v_deps:
+                                n_deps.append(v)
+            elif isstring(vars[n]):
+                if 'charselector' in vars[n]:
+                    if '*' in vars[n]['charselector']:
+                        length = _eval_length(vars[n]['charselector']['*'],
+                                              params)
+                        vars[n]['charselector']['*'] = length
+                    elif 'len' in vars[n]['charselector']:
+                        length = _eval_length(vars[n]['charselector']['len'],
+                                              params)
+                        del vars[n]['charselector']['len']
+                        vars[n]['charselector']['*'] = length
+            if n_checks:
+                vars[n]['check'] = n_checks
+            if n_deps:
+                vars[n]['depend'] = list(set(n_deps))
+
+        if '=' in vars[n]:
+            if 'attrspec' not in vars[n]:
+                vars[n]['attrspec'] = []
+            if ('optional' not in vars[n]['attrspec']) and \
+               ('required' not in vars[n]['attrspec']):
+                vars[n]['attrspec'].append('optional')
+            if 'depend' not in vars[n]:
+                vars[n]['depend'] = []
+                for v, m in list(dep_matches.items()):
+                    if m(vars[n]['=']):
+                        vars[n]['depend'].append(v)
+                if not vars[n]['depend']:
+                    del vars[n]['depend']
+            if isscalar(vars[n]):
+                vars[n]['='] = _eval_scalar(vars[n]['='], params)
+
+    for n in list(vars.keys()):
+        if n == block['name']:  # n is block name
+            if 'note' in vars[n]:
+                block['note'] = vars[n]['note']
+            if block['block'] == 'function':
+                if 'result' in block and block['result'] in vars:
+                    vars[n] = appenddecl(vars[n], vars[block['result']])
+                if 'prefix' in block:
+                    pr = block['prefix']
+                    pr1 = pr.replace('pure', '')
+                    ispure = (not pr == pr1)
+                    pr = pr1.replace('recursive', '')
+                    isrec = (not pr == pr1)
+                    m = typespattern[0].match(pr)
+                    if m:
+                        typespec, selector, attr, edecl = cracktypespec0(
+                            m.group('this'), m.group('after'))
+                        kindselect, charselect, typename = cracktypespec(
+                            typespec, selector)
+                        vars[n]['typespec'] = typespec
+                        try:
+                            if block['result']:
+                                vars[block['result']]['typespec'] = typespec
+                        except Exception:
+                            pass
+                        if kindselect:
+                            if 'kind' in kindselect:
+                                try:
+                                    kindselect['kind'] = eval(
+                                        kindselect['kind'], {}, params)
+                                except Exception:
+                                    pass
+                            vars[n]['kindselector'] = kindselect
+                        if charselect:
+                            vars[n]['charselector'] = charselect
+                        if typename:
+                            vars[n]['typename'] = typename
+                        if ispure:
+                            vars[n] = setattrspec(vars[n], 'pure')
+                        if isrec:
+                            vars[n] = setattrspec(vars[n], 'recursive')
+                    else:
+                        outmess(
+                            'analyzevars: prefix (%s) were not used\n' % repr(block['prefix']))
+    if not block['block'] in ['module', 'pythonmodule', 'python module', 'block data']:
+        if 'commonvars' in block:
+            neededvars = copy.copy(block['args'] + block['commonvars'])
+        else:
+            neededvars = copy.copy(block['args'])
+        for n in list(vars.keys()):
+            if l_or(isintent_callback, isintent_aux)(vars[n]):
+                neededvars.append(n)
+        if 'entry' in block:
+            neededvars.extend(list(block['entry'].keys()))
+            for k in list(block['entry'].keys()):
+                for n in block['entry'][k]:
+                    if n not in neededvars:
+                        neededvars.append(n)
+        if block['block'] == 'function':
+            if 'result' in block:
+                neededvars.append(block['result'])
+            else:
+                neededvars.append(block['name'])
+        if block['block'] in ['subroutine', 'function']:
+            name = block['name']
+            if name in vars and 'intent' in vars[name]:
+                block['intent'] = vars[name]['intent']
+        if block['block'] == 'type':
+            neededvars.extend(list(vars.keys()))
+        for n in list(vars.keys()):
+            if n not in neededvars:
+                del vars[n]
+    return vars
+
+
+analyzeargs_re_1 = re.compile(r'\A[a-z]+[\w$]*\Z', re.I)
+
+
+def param_eval(v, g_params, params, dimspec=None):
+    """
+    Creates a dictionary of indices and values for each parameter in a
+    parameter array to be evaluated later.
+
+    WARNING: It is not possible to initialize multidimensional array
+    parameters e.g. dimension(-3:1, 4, 3:5) at this point. This is because in
+    Fortran initialization through array constructor requires the RESHAPE
+    intrinsic function. Since the right-hand side of the parameter declaration
+    is not executed in f2py, but rather at the compiled c/fortran extension,
+    later, it is not possible to execute a reshape of a parameter array.
+    One issue remains: if the user wants to access the array parameter from
+    python, we should either
+    1) allow them to access the parameter array using python standard indexing
+       (which is often incompatible with the original fortran indexing)
+    2) allow the parameter array to be accessed in python as a dictionary with
+       fortran indices as keys
+    We are choosing 2 for now.
+    """
+    if dimspec is None:
+        try:
+            p = eval(v, g_params, params)
+        except Exception as msg:
+            p = v
+            outmess(f'param_eval: got "{msg}" on {v!r}\n')
+        return p
+
+    # This is an array parameter.
+    # First, we parse the dimension information
+    if len(dimspec) < 2 or dimspec[::len(dimspec)-1] != "()":
+        raise ValueError(f'param_eval: dimension {dimspec} can\'t be parsed')
+    dimrange = dimspec[1:-1].split(',')
+    if len(dimrange) == 1:
+        # e.g. dimension(2) or dimension(-1:1)
+        dimrange = dimrange[0].split(':')
+        # now, dimrange is a list of 1 or 2 elements
+        if len(dimrange) == 1:
+            bound = param_parse(dimrange[0], params)
+            dimrange = range(1, int(bound)+1)
+        else:
+            lbound = param_parse(dimrange[0], params)
+            ubound = param_parse(dimrange[1], params)
+            dimrange = range(int(lbound), int(ubound)+1)
+    else:
+        raise ValueError(f'param_eval: multidimensional array parameters '
+                         '{dimspec} not supported')
+
+    # Parse parameter value
+    v = (v[2:-2] if v.startswith('(/') else v).split(',')
+    v_eval = []
+    for item in v:
+        try:
+            item = eval(item, g_params, params)
+        except Exception as msg:
+            outmess(f'param_eval: got "{msg}" on {item!r}\n')
+        v_eval.append(item)
+
+    p = dict(zip(dimrange, v_eval))
+
+    return p
+
+
+def param_parse(d, params):
+    """Recursively parse array dimensions.
+
+    Parses the declaration of an array variable or parameter
+    `dimension` keyword, and is called recursively if the
+    dimension for this array is a previously defined parameter
+    (found in `params`).
+
+    Parameters
+    ----------
+    d : str
+        Fortran expression describing the dimension of an array.
+    params : dict
+        Previously parsed parameters declared in the Fortran source file.
+
+    Returns
+    -------
+    out : str
+        Parsed dimension expression.
+
+    Examples
+    --------
+
+    * If the line being analyzed is
+
+      `integer, parameter, dimension(2) :: pa = (/ 3, 5 /)`
+
+      then `d = 2` and we return immediately, with
+
+    >>> d = '2'
+    >>> param_parse(d, params)
+    2
+
+    * If the line being analyzed is
+
+      `integer, parameter, dimension(pa) :: pb = (/1, 2, 3/)`
+
+      then `d = 'pa'`; since `pa` is a previously parsed parameter,
+      and `pa = 3`, we call `param_parse` recursively, to obtain
+
+    >>> d = 'pa'
+    >>> params = {'pa': 3}
+    >>> param_parse(d, params)
+    3
+
+    * If the line being analyzed is
+
+      `integer, parameter, dimension(pa(1)) :: pb = (/1, 2, 3/)`
+
+      then `d = 'pa(1)'`; since `pa` is a previously parsed parameter,
+      and `pa(1) = 3`, we call `param_parse` recursively, to obtain
+
+    >>> d = 'pa(1)'
+    >>> params = dict(pa={1: 3, 2: 5})
+    >>> param_parse(d, params)
+    3
+    """
+    if "(" in d:
+        # this dimension expression is an array
+        dname = d[:d.find("(")]
+        ddims = d[d.find("(")+1:d.rfind(")")]
+        # this dimension expression is also a parameter;
+        # parse it recursively
+        index = int(param_parse(ddims, params))
+        return str(params[dname][index])
+    elif d in params:
+        return str(params[d])
+    else:
+        for p in params:
+            re_1 = re.compile(
+                r'(?P.*?)\b' + p + r'\b(?P.*)', re.I
+            )
+            m = re_1.match(d)
+            while m:
+                d = m.group('before') + \
+                    str(params[p]) + m.group('after')
+                m = re_1.match(d)
+        return d
+
+
+def expr2name(a, block, args=[]):
+    orig_a = a
+    a_is_expr = not analyzeargs_re_1.match(a)
+    if a_is_expr:  # `a` is an expression
+        implicitrules, attrrules = buildimplicitrules(block)
+        at = determineexprtype(a, block['vars'], implicitrules)
+        na = 'e_'
+        for c in a:
+            c = c.lower()
+            if c not in string.ascii_lowercase + string.digits:
+                c = '_'
+            na = na + c
+        if na[-1] == '_':
+            na = na + 'e'
+        else:
+            na = na + '_e'
+        a = na
+        while a in block['vars'] or a in block['args']:
+            a = a + 'r'
+    if a in args:
+        k = 1
+        while a + str(k) in args:
+            k = k + 1
+        a = a + str(k)
+    if a_is_expr:
+        block['vars'][a] = at
+    else:
+        if a not in block['vars']:
+            if orig_a in block['vars']:
+                block['vars'][a] = block['vars'][orig_a]
+            else:
+                block['vars'][a] = {}
+        if 'externals' in block and orig_a in block['externals'] + block['interfaced']:
+            block['vars'][a] = setattrspec(block['vars'][a], 'external')
+    return a
+
+
+def analyzeargs(block):
+    setmesstext(block)
+    implicitrules, _ = buildimplicitrules(block)
+    if 'args' not in block:
+        block['args'] = []
+    args = []
+    for a in block['args']:
+        a = expr2name(a, block, args)
+        args.append(a)
+    block['args'] = args
+    if 'entry' in block:
+        for k, args1 in list(block['entry'].items()):
+            for a in args1:
+                if a not in block['vars']:
+                    block['vars'][a] = {}
+
+    for b in block['body']:
+        if b['name'] in args:
+            if 'externals' not in block:
+                block['externals'] = []
+            if b['name'] not in block['externals']:
+                block['externals'].append(b['name'])
+    if 'result' in block and block['result'] not in block['vars']:
+        block['vars'][block['result']] = {}
+    return block
+
+determineexprtype_re_1 = re.compile(r'\A\(.+?,.+?\)\Z', re.I)
+determineexprtype_re_2 = re.compile(r'\A[+-]?\d+(_(?P\w+)|)\Z', re.I)
+determineexprtype_re_3 = re.compile(
+    r'\A[+-]?[\d.]+[-\d+de.]*(_(?P\w+)|)\Z', re.I)
+determineexprtype_re_4 = re.compile(r'\A\(.*\)\Z', re.I)
+determineexprtype_re_5 = re.compile(r'\A(?P\w+)\s*\(.*?\)\s*\Z', re.I)
+
+
+def _ensure_exprdict(r):
+    if isinstance(r, int):
+        return {'typespec': 'integer'}
+    if isinstance(r, float):
+        return {'typespec': 'real'}
+    if isinstance(r, complex):
+        return {'typespec': 'complex'}
+    if isinstance(r, dict):
+        return r
+    raise AssertionError(repr(r))
+
+
+def determineexprtype(expr, vars, rules={}):
+    if expr in vars:
+        return _ensure_exprdict(vars[expr])
+    expr = expr.strip()
+    if determineexprtype_re_1.match(expr):
+        return {'typespec': 'complex'}
+    m = determineexprtype_re_2.match(expr)
+    if m:
+        if 'name' in m.groupdict() and m.group('name'):
+            outmess(
+                'determineexprtype: selected kind types not supported (%s)\n' % repr(expr))
+        return {'typespec': 'integer'}
+    m = determineexprtype_re_3.match(expr)
+    if m:
+        if 'name' in m.groupdict() and m.group('name'):
+            outmess(
+                'determineexprtype: selected kind types not supported (%s)\n' % repr(expr))
+        return {'typespec': 'real'}
+    for op in ['+', '-', '*', '/']:
+        for e in [x.strip() for x in markoutercomma(expr, comma=op).split('@' + op + '@')]:
+            if e in vars:
+                return _ensure_exprdict(vars[e])
+    t = {}
+    if determineexprtype_re_4.match(expr):  # in parenthesis
+        t = determineexprtype(expr[1:-1], vars, rules)
+    else:
+        m = determineexprtype_re_5.match(expr)
+        if m:
+            rn = m.group('name')
+            t = determineexprtype(m.group('name'), vars, rules)
+            if t and 'attrspec' in t:
+                del t['attrspec']
+            if not t:
+                if rn[0] in rules:
+                    return _ensure_exprdict(rules[rn[0]])
+    if expr[0] in '\'"':
+        return {'typespec': 'character', 'charselector': {'*': '*'}}
+    if not t:
+        outmess(
+            'determineexprtype: could not determine expressions (%s) type.\n' % (repr(expr)))
+    return t
+
+######
+
+
+def crack2fortrangen(block, tab='\n', as_interface=False):
+    global skipfuncs, onlyfuncs
+
+    setmesstext(block)
+    ret = ''
+    if isinstance(block, list):
+        for g in block:
+            if g and g['block'] in ['function', 'subroutine']:
+                if g['name'] in skipfuncs:
+                    continue
+                if onlyfuncs and g['name'] not in onlyfuncs:
+                    continue
+            ret = ret + crack2fortrangen(g, tab, as_interface=as_interface)
+        return ret
+    prefix = ''
+    name = ''
+    args = ''
+    blocktype = block['block']
+    if blocktype == 'program':
+        return ''
+    argsl = []
+    if 'name' in block:
+        name = block['name']
+    if 'args' in block:
+        vars = block['vars']
+        for a in block['args']:
+            a = expr2name(a, block, argsl)
+            if not isintent_callback(vars[a]):
+                argsl.append(a)
+        if block['block'] == 'function' or argsl:
+            args = '(%s)' % ','.join(argsl)
+    f2pyenhancements = ''
+    if 'f2pyenhancements' in block:
+        for k in list(block['f2pyenhancements'].keys()):
+            f2pyenhancements = '%s%s%s %s' % (
+                f2pyenhancements, tab + tabchar, k, block['f2pyenhancements'][k])
+    intent_lst = block.get('intent', [])[:]
+    if blocktype == 'function' and 'callback' in intent_lst:
+        intent_lst.remove('callback')
+    if intent_lst:
+        f2pyenhancements = '%s%sintent(%s) %s' %\
+                           (f2pyenhancements, tab + tabchar,
+                            ','.join(intent_lst), name)
+    use = ''
+    if 'use' in block:
+        use = use2fortran(block['use'], tab + tabchar)
+    common = ''
+    if 'common' in block:
+        common = common2fortran(block['common'], tab + tabchar)
+    if name == 'unknown_interface':
+        name = ''
+    result = ''
+    if 'result' in block:
+        result = ' result (%s)' % block['result']
+        if block['result'] not in argsl:
+            argsl.append(block['result'])
+    body = crack2fortrangen(block['body'], tab + tabchar, as_interface=as_interface)
+    vars = vars2fortran(
+        block, block['vars'], argsl, tab + tabchar, as_interface=as_interface)
+    mess = ''
+    if 'from' in block and not as_interface:
+        mess = '! in %s' % block['from']
+    if 'entry' in block:
+        entry_stmts = ''
+        for k, i in list(block['entry'].items()):
+            entry_stmts = '%s%sentry %s(%s)' \
+                          % (entry_stmts, tab + tabchar, k, ','.join(i))
+        body = body + entry_stmts
+    if blocktype == 'block data' and name == '_BLOCK_DATA_':
+        name = ''
+    ret = '%s%s%s %s%s%s %s%s%s%s%s%s%send %s %s' % (
+        tab, prefix, blocktype, name, args, result, mess, f2pyenhancements, use, vars, common, body, tab, blocktype, name)
+    return ret
+
+
+def common2fortran(common, tab=''):
+    ret = ''
+    for k in list(common.keys()):
+        if k == '_BLNK_':
+            ret = '%s%scommon %s' % (ret, tab, ','.join(common[k]))
+        else:
+            ret = '%s%scommon /%s/ %s' % (ret, tab, k, ','.join(common[k]))
+    return ret
+
+
+def use2fortran(use, tab=''):
+    ret = ''
+    for m in list(use.keys()):
+        ret = '%s%suse %s,' % (ret, tab, m)
+        if use[m] == {}:
+            if ret and ret[-1] == ',':
+                ret = ret[:-1]
+            continue
+        if 'only' in use[m] and use[m]['only']:
+            ret = '%s only:' % (ret)
+        if 'map' in use[m] and use[m]['map']:
+            c = ' '
+            for k in list(use[m]['map'].keys()):
+                if k == use[m]['map'][k]:
+                    ret = '%s%s%s' % (ret, c, k)
+                    c = ','
+                else:
+                    ret = '%s%s%s=>%s' % (ret, c, k, use[m]['map'][k])
+                    c = ','
+        if ret and ret[-1] == ',':
+            ret = ret[:-1]
+    return ret
+
+
+def true_intent_list(var):
+    lst = var['intent']
+    ret = []
+    for intent in lst:
+        try:
+            f = globals()['isintent_%s' % intent]
+        except KeyError:
+            pass
+        else:
+            if f(var):
+                ret.append(intent)
+    return ret
+
+
+def vars2fortran(block, vars, args, tab='', as_interface=False):
+    setmesstext(block)
+    ret = ''
+    nout = []
+    for a in args:
+        if a in block['vars']:
+            nout.append(a)
+    if 'commonvars' in block:
+        for a in block['commonvars']:
+            if a in vars:
+                if a not in nout:
+                    nout.append(a)
+            else:
+                errmess(
+                    'vars2fortran: Confused?!: "%s" is not defined in vars.\n' % a)
+    if 'varnames' in block:
+        nout.extend(block['varnames'])
+    if not as_interface:
+        for a in list(vars.keys()):
+            if a not in nout:
+                nout.append(a)
+    for a in nout:
+        if 'depend' in vars[a]:
+            for d in vars[a]['depend']:
+                if d in vars and 'depend' in vars[d] and a in vars[d]['depend']:
+                    errmess(
+                        'vars2fortran: Warning: cross-dependence between variables "%s" and "%s"\n' % (a, d))
+        if 'externals' in block and a in block['externals']:
+            if isintent_callback(vars[a]):
+                ret = '%s%sintent(callback) %s' % (ret, tab, a)
+            ret = '%s%sexternal %s' % (ret, tab, a)
+            if isoptional(vars[a]):
+                ret = '%s%soptional %s' % (ret, tab, a)
+            if a in vars and 'typespec' not in vars[a]:
+                continue
+            cont = 1
+            for b in block['body']:
+                if a == b['name'] and b['block'] == 'function':
+                    cont = 0
+                    break
+            if cont:
+                continue
+        if a not in vars:
+            show(vars)
+            outmess('vars2fortran: No definition for argument "%s".\n' % a)
+            continue
+        if a == block['name']:
+            if block['block'] != 'function' or block.get('result'):
+                # 1) skip declaring a variable that name matches with
+                #    subroutine name
+                # 2) skip declaring function when its type is
+                #    declared via `result` construction
+                continue
+        if 'typespec' not in vars[a]:
+            if 'attrspec' in vars[a] and 'external' in vars[a]['attrspec']:
+                if a in args:
+                    ret = '%s%sexternal %s' % (ret, tab, a)
+                continue
+            show(vars[a])
+            outmess('vars2fortran: No typespec for argument "%s".\n' % a)
+            continue
+        vardef = vars[a]['typespec']
+        if vardef == 'type' and 'typename' in vars[a]:
+            vardef = '%s(%s)' % (vardef, vars[a]['typename'])
+        selector = {}
+        if 'kindselector' in vars[a]:
+            selector = vars[a]['kindselector']
+        elif 'charselector' in vars[a]:
+            selector = vars[a]['charselector']
+        if '*' in selector:
+            if selector['*'] in ['*', ':']:
+                vardef = '%s*(%s)' % (vardef, selector['*'])
+            else:
+                vardef = '%s*%s' % (vardef, selector['*'])
+        else:
+            if 'len' in selector:
+                vardef = '%s(len=%s' % (vardef, selector['len'])
+                if 'kind' in selector:
+                    vardef = '%s,kind=%s)' % (vardef, selector['kind'])
+                else:
+                    vardef = '%s)' % (vardef)
+            elif 'kind' in selector:
+                vardef = '%s(kind=%s)' % (vardef, selector['kind'])
+        c = ' '
+        if 'attrspec' in vars[a]:
+            attr = [l for l in vars[a]['attrspec']
+                    if l not in ['external']]
+            if as_interface and 'intent(in)' in attr and 'intent(out)' in attr:
+                # In Fortran, intent(in, out) are conflicting while
+                # intent(in, out) can be specified only via
+                # `!f2py intent(out) ..`.
+                # So, for the Fortran interface, we'll drop
+                # intent(out) to resolve the conflict.
+                attr.remove('intent(out)')
+            if attr:
+                vardef = '%s, %s' % (vardef, ','.join(attr))
+                c = ','
+        if 'dimension' in vars[a]:
+            vardef = '%s%sdimension(%s)' % (
+                vardef, c, ','.join(vars[a]['dimension']))
+            c = ','
+        if 'intent' in vars[a]:
+            lst = true_intent_list(vars[a])
+            if lst:
+                vardef = '%s%sintent(%s)' % (vardef, c, ','.join(lst))
+            c = ','
+        if 'check' in vars[a]:
+            vardef = '%s%scheck(%s)' % (vardef, c, ','.join(vars[a]['check']))
+            c = ','
+        if 'depend' in vars[a]:
+            vardef = '%s%sdepend(%s)' % (
+                vardef, c, ','.join(vars[a]['depend']))
+            c = ','
+        if '=' in vars[a]:
+            v = vars[a]['=']
+            if vars[a]['typespec'] in ['complex', 'double complex']:
+                try:
+                    v = eval(v)
+                    v = '(%s,%s)' % (v.real, v.imag)
+                except Exception:
+                    pass
+            vardef = '%s :: %s=%s' % (vardef, a, v)
+        else:
+            vardef = '%s :: %s' % (vardef, a)
+        ret = '%s%s%s' % (ret, tab, vardef)
+    return ret
+######
+
+
+# We expose post_processing_hooks as global variable so that
+# user-libraries could register their own hooks to f2py.
+post_processing_hooks = []
+
+
+def crackfortran(files):
+    global usermodules, post_processing_hooks
+
+    outmess('Reading fortran codes...\n', 0)
+    readfortrancode(files, crackline)
+    outmess('Post-processing...\n', 0)
+    usermodules = []
+    postlist = postcrack(grouplist[0])
+    outmess('Applying post-processing hooks...\n', 0)
+    for hook in post_processing_hooks:
+        outmess(f'  {hook.__name__}\n', 0)
+        postlist = traverse(postlist, hook)
+    outmess('Post-processing (stage 2)...\n', 0)
+    postlist = postcrack2(postlist)
+    return usermodules + postlist
+
+
+def crack2fortran(block):
+    global f2py_version
+
+    pyf = crack2fortrangen(block) + '\n'
+    header = """!    -*- f90 -*-
+! Note: the context of this file is case sensitive.
+"""
+    footer = """
+! This file was auto-generated with f2py (version:%s).
+! See:
+! https://web.archive.org/web/20140822061353/http://cens.ioc.ee/projects/f2py2e
+""" % (f2py_version)
+    return header + pyf + footer
+
+
+def _is_visit_pair(obj):
+    return (isinstance(obj, tuple)
+            and len(obj) == 2
+            and isinstance(obj[0], (int, str)))
+
+
+def traverse(obj, visit, parents=[], result=None, *args, **kwargs):
+    '''Traverse f2py data structure with the following visit function:
+
+    def visit(item, parents, result, *args, **kwargs):
+        """
+
+        parents is a list of key-"f2py data structure" pairs from which
+        items are taken from.
+
+        result is a f2py data structure that is filled with the
+        return value of the visit function.
+
+        item is 2-tuple (index, value) if parents[-1][1] is a list
+        item is 2-tuple (key, value) if parents[-1][1] is a dict
+
+        The return value of visit must be None, or of the same kind as
+        item, that is, if parents[-1] is a list, the return value must
+        be 2-tuple (new_index, new_value), or if parents[-1] is a
+        dict, the return value must be 2-tuple (new_key, new_value).
+
+        If new_index or new_value is None, the return value of visit
+        is ignored, that is, it will not be added to the result.
+
+        If the return value is None, the content of obj will be
+        traversed, otherwise not.
+        """
+    '''
+
+    if _is_visit_pair(obj):
+        if obj[0] == 'parent_block':
+            # avoid infinite recursion
+            return obj
+        new_result = visit(obj, parents, result, *args, **kwargs)
+        if new_result is not None:
+            assert _is_visit_pair(new_result)
+            return new_result
+        parent = obj
+        result_key, obj = obj
+    else:
+        parent = (None, obj)
+        result_key = None
+
+    if isinstance(obj, list):
+        new_result = []
+        for index, value in enumerate(obj):
+            new_index, new_item = traverse((index, value), visit,
+                                           parents=parents + [parent],
+                                           result=result, *args, **kwargs)
+            if new_index is not None:
+                new_result.append(new_item)
+    elif isinstance(obj, dict):
+        new_result = dict()
+        for key, value in obj.items():
+            new_key, new_value = traverse((key, value), visit,
+                                          parents=parents + [parent],
+                                          result=result, *args, **kwargs)
+            if new_key is not None:
+                new_result[new_key] = new_value
+    else:
+        new_result = obj
+
+    if result_key is None:
+        return new_result
+    return result_key, new_result
+
+
+def character_backward_compatibility_hook(item, parents, result,
+                                          *args, **kwargs):
+    """Previously, Fortran character was incorrectly treated as
+    character*1. This hook fixes the usage of the corresponding
+    variables in `check`, `dimension`, `=`, and `callstatement`
+    expressions.
+
+    The usage of `char*` in `callprotoargument` expression can be left
+    unchanged because C `character` is C typedef of `char`, although,
+    new implementations should use `character*` in the corresponding
+    expressions.
+
+    See https://github.com/numpy/numpy/pull/19388 for more information.
+
+    """
+    parent_key, parent_value = parents[-1]
+    key, value = item
+
+    def fix_usage(varname, value):
+        value = re.sub(r'[*]\s*\b' + varname + r'\b', varname, value)
+        value = re.sub(r'\b' + varname + r'\b\s*[\[]\s*0\s*[\]]',
+                       varname, value)
+        return value
+
+    if parent_key in ['dimension', 'check']:
+        assert parents[-3][0] == 'vars'
+        vars_dict = parents[-3][1]
+    elif key == '=':
+        assert parents[-2][0] == 'vars'
+        vars_dict = parents[-2][1]
+    else:
+        vars_dict = None
+
+    new_value = None
+    if vars_dict is not None:
+        new_value = value
+        for varname, vd in vars_dict.items():
+            if ischaracter(vd):
+                new_value = fix_usage(varname, new_value)
+    elif key == 'callstatement':
+        vars_dict = parents[-2][1]['vars']
+        new_value = value
+        for varname, vd in vars_dict.items():
+            if ischaracter(vd):
+                # replace all occurrences of `` with
+                # `&` in argument passing
+                new_value = re.sub(
+                    r'(? `{new_value}`\n', 1)
+        return (key, new_value)
+
+
+post_processing_hooks.append(character_backward_compatibility_hook)
+
+
+if __name__ == "__main__":
+    files = []
+    funcs = []
+    f = 1
+    f2 = 0
+    f3 = 0
+    showblocklist = 0
+    for l in sys.argv[1:]:
+        if l == '':
+            pass
+        elif l[0] == ':':
+            f = 0
+        elif l == '-quiet':
+            quiet = 1
+            verbose = 0
+        elif l == '-verbose':
+            verbose = 2
+            quiet = 0
+        elif l == '-fix':
+            if strictf77:
+                outmess(
+                    'Use option -f90 before -fix if Fortran 90 code is in fix form.\n', 0)
+            skipemptyends = 1
+            sourcecodeform = 'fix'
+        elif l == '-skipemptyends':
+            skipemptyends = 1
+        elif l == '--ignore-contains':
+            ignorecontains = 1
+        elif l == '-f77':
+            strictf77 = 1
+            sourcecodeform = 'fix'
+        elif l == '-f90':
+            strictf77 = 0
+            sourcecodeform = 'free'
+            skipemptyends = 1
+        elif l == '-h':
+            f2 = 1
+        elif l == '-show':
+            showblocklist = 1
+        elif l == '-m':
+            f3 = 1
+        elif l[0] == '-':
+            errmess('Unknown option %s\n' % repr(l))
+        elif f2:
+            f2 = 0
+            pyffilename = l
+        elif f3:
+            f3 = 0
+            f77modulename = l
+        elif f:
+            try:
+                open(l).close()
+                files.append(l)
+            except OSError as detail:
+                errmess(f'OSError: {detail!s}\n')
+        else:
+            funcs.append(l)
+    if not strictf77 and f77modulename and not skipemptyends:
+        outmess("""\
+  Warning: You have specified module name for non Fortran 77 code that
+  should not need one (expect if you are scanning F90 code for non
+  module blocks but then you should use flag -skipemptyends and also
+  be sure that the files do not contain programs without program
+  statement).
+""", 0)
+
+    postlist = crackfortran(files)
+    if pyffilename:
+        outmess('Writing fortran code to file %s\n' % repr(pyffilename), 0)
+        pyf = crack2fortran(postlist)
+        with open(pyffilename, 'w') as f:
+            f.write(pyf)
+    if showblocklist:
+        show(postlist)
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/diagnose.py b/venv/lib/python3.12/site-packages/numpy/f2py/diagnose.py
new file mode 100644
index 00000000..86d7004a
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/diagnose.py
@@ -0,0 +1,154 @@
+#!/usr/bin/env python3
+import os
+import sys
+import tempfile
+
+
+def run_command(cmd):
+    print('Running %r:' % (cmd))
+    os.system(cmd)
+    print('------')
+
+
+def run():
+    _path = os.getcwd()
+    os.chdir(tempfile.gettempdir())
+    print('------')
+    print('os.name=%r' % (os.name))
+    print('------')
+    print('sys.platform=%r' % (sys.platform))
+    print('------')
+    print('sys.version:')
+    print(sys.version)
+    print('------')
+    print('sys.prefix:')
+    print(sys.prefix)
+    print('------')
+    print('sys.path=%r' % (':'.join(sys.path)))
+    print('------')
+
+    try:
+        import numpy
+        has_newnumpy = 1
+    except ImportError as e:
+        print('Failed to import new numpy:', e)
+        has_newnumpy = 0
+
+    try:
+        from numpy.f2py import f2py2e
+        has_f2py2e = 1
+    except ImportError as e:
+        print('Failed to import f2py2e:', e)
+        has_f2py2e = 0
+
+    try:
+        import numpy.distutils
+        has_numpy_distutils = 2
+    except ImportError:
+        try:
+            import numpy_distutils
+            has_numpy_distutils = 1
+        except ImportError as e:
+            print('Failed to import numpy_distutils:', e)
+            has_numpy_distutils = 0
+
+    if has_newnumpy:
+        try:
+            print('Found new numpy version %r in %s' %
+                  (numpy.__version__, numpy.__file__))
+        except Exception as msg:
+            print('error:', msg)
+            print('------')
+
+    if has_f2py2e:
+        try:
+            print('Found f2py2e version %r in %s' %
+                  (f2py2e.__version__.version, f2py2e.__file__))
+        except Exception as msg:
+            print('error:', msg)
+            print('------')
+
+    if has_numpy_distutils:
+        try:
+            if has_numpy_distutils == 2:
+                print('Found numpy.distutils version %r in %r' % (
+                    numpy.distutils.__version__,
+                    numpy.distutils.__file__))
+            else:
+                print('Found numpy_distutils version %r in %r' % (
+                    numpy_distutils.numpy_distutils_version.numpy_distutils_version,
+                    numpy_distutils.__file__))
+            print('------')
+        except Exception as msg:
+            print('error:', msg)
+            print('------')
+        try:
+            if has_numpy_distutils == 1:
+                print(
+                    'Importing numpy_distutils.command.build_flib ...', end=' ')
+                import numpy_distutils.command.build_flib as build_flib
+                print('ok')
+                print('------')
+                try:
+                    print(
+                        'Checking availability of supported Fortran compilers:')
+                    for compiler_class in build_flib.all_compilers:
+                        compiler_class(verbose=1).is_available()
+                        print('------')
+                except Exception as msg:
+                    print('error:', msg)
+                    print('------')
+        except Exception as msg:
+            print(
+                'error:', msg, '(ignore it, build_flib is obsolute for numpy.distutils 0.2.2 and up)')
+            print('------')
+        try:
+            if has_numpy_distutils == 2:
+                print('Importing numpy.distutils.fcompiler ...', end=' ')
+                import numpy.distutils.fcompiler as fcompiler
+            else:
+                print('Importing numpy_distutils.fcompiler ...', end=' ')
+                import numpy_distutils.fcompiler as fcompiler
+            print('ok')
+            print('------')
+            try:
+                print('Checking availability of supported Fortran compilers:')
+                fcompiler.show_fcompilers()
+                print('------')
+            except Exception as msg:
+                print('error:', msg)
+                print('------')
+        except Exception as msg:
+            print('error:', msg)
+            print('------')
+        try:
+            if has_numpy_distutils == 2:
+                print('Importing numpy.distutils.cpuinfo ...', end=' ')
+                from numpy.distutils.cpuinfo import cpuinfo
+                print('ok')
+                print('------')
+            else:
+                try:
+                    print(
+                        'Importing numpy_distutils.command.cpuinfo ...', end=' ')
+                    from numpy_distutils.command.cpuinfo import cpuinfo
+                    print('ok')
+                    print('------')
+                except Exception as msg:
+                    print('error:', msg, '(ignore it)')
+                    print('Importing numpy_distutils.cpuinfo ...', end=' ')
+                    from numpy_distutils.cpuinfo import cpuinfo
+                    print('ok')
+                    print('------')
+            cpu = cpuinfo()
+            print('CPU information:', end=' ')
+            for name in dir(cpuinfo):
+                if name[0] == '_' and name[1] != '_' and getattr(cpu, name[1:])():
+                    print(name[1:], end=' ')
+            print('------')
+        except Exception as msg:
+            print('error:', msg)
+            print('------')
+    os.chdir(_path)
+if __name__ == "__main__":
+    run()
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/f2py2e.py b/venv/lib/python3.12/site-packages/numpy/f2py/f2py2e.py
new file mode 100755
index 00000000..f9fa2980
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/f2py2e.py
@@ -0,0 +1,787 @@
+#!/usr/bin/env python3
+"""
+
+f2py2e - Fortran to Python C/API generator. 2nd Edition.
+         See __usage__ below.
+
+Copyright 1999 -- 2011 Pearu Peterson all rights reserved.
+Copyright 2011 -- present NumPy Developers.
+Permission to use, modify, and distribute this software is given under the
+terms of the NumPy License.
+
+NO WARRANTY IS EXPRESSED OR IMPLIED.  USE AT YOUR OWN RISK.
+"""
+import sys
+import os
+import pprint
+import re
+from pathlib import Path
+from itertools import dropwhile
+import argparse
+import copy
+
+from . import crackfortran
+from . import rules
+from . import cb_rules
+from . import auxfuncs
+from . import cfuncs
+from . import f90mod_rules
+from . import __version__
+from . import capi_maps
+from .cfuncs import errmess
+from numpy.f2py._backends import f2py_build_generator
+
+f2py_version = __version__.version
+numpy_version = __version__.version
+
+# outmess=sys.stdout.write
+show = pprint.pprint
+outmess = auxfuncs.outmess
+MESON_ONLY_VER = (sys.version_info >= (3, 12))
+
+__usage__ =\
+f"""Usage:
+
+1) To construct extension module sources:
+
+      f2py []  [[[only:]||[skip:]] \\
+                                         ] \\
+                                       [:  ...]
+
+2) To compile fortran files and build extension modules:
+
+      f2py -c [, , ] 
+
+3) To generate signature files:
+
+      f2py -h  ...< same options as in (1) >
+
+Description: This program generates a Python C/API file (module.c)
+             that contains wrappers for given fortran functions so that they
+             can be called from Python. With the -c option the corresponding
+             extension modules are built.
+
+Options:
+
+  -h     Write signatures of the fortran routines to file 
+                   and exit. You can then edit  and use it instead
+                   of . If ==stdout then the
+                   signatures are printed to stdout.
+    Names of fortran routines for which Python C/API
+                   functions will be generated. Default is all that are found
+                   in .
+    Paths to fortran/signature files that will be scanned for
+                    in order to determine their signatures.
+  skip:            Ignore fortran functions that follow until `:'.
+  only:            Use only fortran functions that follow until `:'.
+  :                Get back to  mode.
+
+  -m   Name of the module; f2py generates a Python/C API
+                   file module.c or extension module .
+                   Default is 'untitled'.
+
+  '-include
'  Writes additional headers in the C wrapper, can be passed
+                      multiple times, generates #include 
 each time.
+
+  --[no-]lower     Do [not] lower the cases in . By default,
+                   --lower is assumed with -h key, and --no-lower without -h key.
+
+  --build-dir   All f2py generated files are created in .
+                   Default is tempfile.mkdtemp().
+
+  --overwrite-signature  Overwrite existing signature file.
+
+  --[no-]latex-doc Create (or not) module.tex.
+                   Default is --no-latex-doc.
+  --short-latex    Create 'incomplete' LaTeX document (without commands
+                   \\documentclass, \\tableofcontents, and \\begin{{document}},
+                   \\end{{document}}).
+
+  --[no-]rest-doc Create (or not) module.rst.
+                   Default is --no-rest-doc.
+
+  --debug-capi     Create C/API code that reports the state of the wrappers
+                   during runtime. Useful for debugging.
+
+  --[no-]wrap-functions    Create Fortran subroutine wrappers to Fortran 77
+                   functions. --wrap-functions is default because it ensures
+                   maximum portability/compiler independence.
+
+  --[no-]freethreading-compatible    Create a module that declares it does or
+                   doesn't require the GIL. The default is
+                   --freethreading-compatible for backward
+                   compatibility. Inspect the Fortran code you are wrapping for
+                   thread safety issues before passing
+                   --no-freethreading-compatible, as f2py does not analyze
+                   fortran code for thread safety issues.
+
+  --include-paths ::...   Search include files from the given
+                   directories.
+
+  --help-link [..] List system resources found by system_info.py. See also
+                   --link- switch below. [..] is optional list
+                   of resources names. E.g. try 'f2py --help-link lapack_opt'.
+
+  --f2cmap   Load Fortran-to-Python KIND specification from the given
+                   file. Default: .f2py_f2cmap in current directory.
+
+  --quiet          Run quietly.
+  --verbose        Run with extra verbosity.
+  --skip-empty-wrappers   Only generate wrapper files when needed.
+  -v               Print f2py version ID and exit.
+
+
+build backend options (only effective with -c)
+[NO_MESON] is used to indicate an option not meant to be used
+with the meson backend or above Python 3.12:
+
+  --fcompiler=         Specify Fortran compiler type by vendor [NO_MESON]
+  --compiler=          Specify distutils C compiler type [NO_MESON]
+
+  --help-fcompiler     List available Fortran compilers and exit [NO_MESON]
+  --f77exec=           Specify the path to F77 compiler [NO_MESON]
+  --f90exec=           Specify the path to F90 compiler [NO_MESON]
+  --f77flags=          Specify F77 compiler flags
+  --f90flags=          Specify F90 compiler flags
+  --opt=               Specify optimization flags [NO_MESON]
+  --arch=              Specify architecture specific optimization flags [NO_MESON]
+  --noopt              Compile without optimization [NO_MESON]
+  --noarch             Compile without arch-dependent optimization [NO_MESON]
+  --debug              Compile with debugging information
+
+  --dep                
+                       Specify a meson dependency for the module. This may
+                       be passed multiple times for multiple dependencies.
+                       Dependencies are stored in a list for further processing.
+
+                       Example: --dep lapack --dep scalapack
+                       This will identify "lapack" and "scalapack" as dependencies
+                       and remove them from argv, leaving a dependencies list
+                       containing ["lapack", "scalapack"].
+
+  --backend            
+                       Specify the build backend for the compilation process.
+                       The supported backends are 'meson' and 'distutils'.
+                       If not specified, defaults to 'distutils'. On
+                       Python 3.12 or higher, the default is 'meson'.
+
+Extra options (only effective with -c):
+
+  --link-    Link extension module with  as defined
+                       by numpy.distutils/system_info.py. E.g. to link
+                       with optimized LAPACK libraries (vecLib on MacOSX,
+                       ATLAS elsewhere), use --link-lapack_opt.
+                       See also --help-link switch. [NO_MESON]
+
+  -L/path/to/lib/ -l
+  -D -U
+  -I/path/to/include/
+  .o .so .a
+
+  Using the following macros may be required with non-gcc Fortran
+  compilers:
+    -DPREPEND_FORTRAN -DNO_APPEND_FORTRAN -DUPPERCASE_FORTRAN
+
+  When using -DF2PY_REPORT_ATEXIT, a performance report of F2PY
+  interface is printed out at exit (platforms: Linux).
+
+  When using -DF2PY_REPORT_ON_ARRAY_COPY=, a message is
+  sent to stderr whenever F2PY interface makes a copy of an
+  array. Integer  sets the threshold for array sizes when
+  a message should be shown.
+
+Version:     {f2py_version}
+numpy Version: {numpy_version}
+License:     NumPy license (see LICENSE.txt in the NumPy source code)
+Copyright 1999 -- 2011 Pearu Peterson all rights reserved.
+Copyright 2011 -- present NumPy Developers.
+https://numpy.org/doc/stable/f2py/index.html\n"""
+
+
+def scaninputline(inputline):
+    files, skipfuncs, onlyfuncs, debug = [], [], [], []
+    f, f2, f3, f5, f6, f8, f9, f10 = 1, 0, 0, 0, 0, 0, 0, 0
+    verbose = 1
+    emptygen = True
+    dolc = -1
+    dolatexdoc = 0
+    dorestdoc = 0
+    wrapfuncs = 1
+    buildpath = '.'
+    include_paths, freethreading_compatible, inputline = get_newer_options(inputline)
+    signsfile, modulename = None, None
+    options = {'buildpath': buildpath,
+               'coutput': None,
+               'f2py_wrapper_output': None}
+    for l in inputline:
+        if l == '':
+            pass
+        elif l == 'only:':
+            f = 0
+        elif l == 'skip:':
+            f = -1
+        elif l == ':':
+            f = 1
+        elif l[:8] == '--debug-':
+            debug.append(l[8:])
+        elif l == '--lower':
+            dolc = 1
+        elif l == '--build-dir':
+            f6 = 1
+        elif l == '--no-lower':
+            dolc = 0
+        elif l == '--quiet':
+            verbose = 0
+        elif l == '--verbose':
+            verbose += 1
+        elif l == '--latex-doc':
+            dolatexdoc = 1
+        elif l == '--no-latex-doc':
+            dolatexdoc = 0
+        elif l == '--rest-doc':
+            dorestdoc = 1
+        elif l == '--no-rest-doc':
+            dorestdoc = 0
+        elif l == '--wrap-functions':
+            wrapfuncs = 1
+        elif l == '--no-wrap-functions':
+            wrapfuncs = 0
+        elif l == '--short-latex':
+            options['shortlatex'] = 1
+        elif l == '--coutput':
+            f8 = 1
+        elif l == '--f2py-wrapper-output':
+            f9 = 1
+        elif l == '--f2cmap':
+            f10 = 1
+        elif l == '--overwrite-signature':
+            options['h-overwrite'] = 1
+        elif l == '-h':
+            f2 = 1
+        elif l == '-m':
+            f3 = 1
+        elif l[:2] == '-v':
+            print(f2py_version)
+            sys.exit()
+        elif l == '--show-compilers':
+            f5 = 1
+        elif l[:8] == '-include':
+            cfuncs.outneeds['userincludes'].append(l[9:-1])
+            cfuncs.userincludes[l[9:-1]] = '#include ' + l[8:]
+        elif l == '--skip-empty-wrappers':
+            emptygen = False
+        elif l[0] == '-':
+            errmess('Unknown option %s\n' % repr(l))
+            sys.exit()
+        elif f2:
+            f2 = 0
+            signsfile = l
+        elif f3:
+            f3 = 0
+            modulename = l
+        elif f6:
+            f6 = 0
+            buildpath = l
+        elif f8:
+            f8 = 0
+            options["coutput"] = l
+        elif f9:
+            f9 = 0
+            options["f2py_wrapper_output"] = l
+        elif f10:
+            f10 = 0
+            options["f2cmap_file"] = l
+        elif f == 1:
+            try:
+                with open(l):
+                    pass
+                files.append(l)
+            except OSError as detail:
+                errmess(f'OSError: {detail!s}. Skipping file "{l!s}".\n')
+        elif f == -1:
+            skipfuncs.append(l)
+        elif f == 0:
+            onlyfuncs.append(l)
+    if not f5 and not files and not modulename:
+        print(__usage__)
+        sys.exit()
+    if not os.path.isdir(buildpath):
+        if not verbose:
+            outmess('Creating build directory %s\n' % (buildpath))
+        os.mkdir(buildpath)
+    if signsfile:
+        signsfile = os.path.join(buildpath, signsfile)
+    if signsfile and os.path.isfile(signsfile) and 'h-overwrite' not in options:
+        errmess(
+            'Signature file "%s" exists!!! Use --overwrite-signature to overwrite.\n' % (signsfile))
+        sys.exit()
+
+    options['emptygen'] = emptygen
+    options['debug'] = debug
+    options['verbose'] = verbose
+    if dolc == -1 and not signsfile:
+        options['do-lower'] = 0
+    else:
+        options['do-lower'] = dolc
+    if modulename:
+        options['module'] = modulename
+    if signsfile:
+        options['signsfile'] = signsfile
+    if onlyfuncs:
+        options['onlyfuncs'] = onlyfuncs
+    if skipfuncs:
+        options['skipfuncs'] = skipfuncs
+    options['dolatexdoc'] = dolatexdoc
+    options['dorestdoc'] = dorestdoc
+    options['wrapfuncs'] = wrapfuncs
+    options['buildpath'] = buildpath
+    options['include_paths'] = include_paths
+    options['requires_gil'] = not freethreading_compatible
+    options.setdefault('f2cmap_file', None)
+    return files, options
+
+
+def callcrackfortran(files, options):
+    rules.options = options
+    crackfortran.debug = options['debug']
+    crackfortran.verbose = options['verbose']
+    if 'module' in options:
+        crackfortran.f77modulename = options['module']
+    if 'skipfuncs' in options:
+        crackfortran.skipfuncs = options['skipfuncs']
+    if 'onlyfuncs' in options:
+        crackfortran.onlyfuncs = options['onlyfuncs']
+    crackfortran.include_paths[:] = options['include_paths']
+    crackfortran.dolowercase = options['do-lower']
+    postlist = crackfortran.crackfortran(files)
+    if 'signsfile' in options:
+        outmess('Saving signatures to file "%s"\n' % (options['signsfile']))
+        pyf = crackfortran.crack2fortran(postlist)
+        if options['signsfile'][-6:] == 'stdout':
+            sys.stdout.write(pyf)
+        else:
+            with open(options['signsfile'], 'w') as f:
+                f.write(pyf)
+    if options["coutput"] is None:
+        for mod in postlist:
+            mod["coutput"] = "%smodule.c" % mod["name"]
+    else:
+        for mod in postlist:
+            mod["coutput"] = options["coutput"]
+    if options["f2py_wrapper_output"] is None:
+        for mod in postlist:
+            mod["f2py_wrapper_output"] = "%s-f2pywrappers.f" % mod["name"]
+    else:
+        for mod in postlist:
+            mod["f2py_wrapper_output"] = options["f2py_wrapper_output"]
+    for mod in postlist:
+        if options["requires_gil"]:
+            mod['gil_used'] = 'Py_MOD_GIL_USED'
+        else:
+            mod['gil_used'] = 'Py_MOD_GIL_NOT_USED'
+    return postlist
+
+
+def buildmodules(lst):
+    cfuncs.buildcfuncs()
+    outmess('Building modules...\n')
+    modules, mnames, isusedby = [], [], {}
+    for item in lst:
+        if '__user__' in item['name']:
+            cb_rules.buildcallbacks(item)
+        else:
+            if 'use' in item:
+                for u in item['use'].keys():
+                    if u not in isusedby:
+                        isusedby[u] = []
+                    isusedby[u].append(item['name'])
+            modules.append(item)
+            mnames.append(item['name'])
+    ret = {}
+    for module, name in zip(modules, mnames):
+        if name in isusedby:
+            outmess('\tSkipping module "%s" which is used by %s.\n' % (
+                name, ','.join('"%s"' % s for s in isusedby[name])))
+        else:
+            um = []
+            if 'use' in module:
+                for u in module['use'].keys():
+                    if u in isusedby and u in mnames:
+                        um.append(modules[mnames.index(u)])
+                    else:
+                        outmess(
+                            f'\tModule "{name}" uses nonexisting "{u}" '
+                            'which will be ignored.\n')
+            ret[name] = {}
+            dict_append(ret[name], rules.buildmodule(module, um))
+    return ret
+
+
+def dict_append(d_out, d_in):
+    for (k, v) in d_in.items():
+        if k not in d_out:
+            d_out[k] = []
+        if isinstance(v, list):
+            d_out[k] = d_out[k] + v
+        else:
+            d_out[k].append(v)
+
+
+def run_main(comline_list):
+    """
+    Equivalent to running::
+
+        f2py 
+
+    where ``=string.join(,' ')``, but in Python.  Unless
+    ``-h`` is used, this function returns a dictionary containing
+    information on generated modules and their dependencies on source
+    files.
+
+    You cannot build extension modules with this function, that is,
+    using ``-c`` is not allowed. Use the ``compile`` command instead.
+
+    Examples
+    --------
+    The command ``f2py -m scalar scalar.f`` can be executed from Python as
+    follows.
+
+    .. literalinclude:: ../../source/f2py/code/results/run_main_session.dat
+        :language: python
+
+    """
+    crackfortran.reset_global_f2py_vars()
+    f2pydir = os.path.dirname(os.path.abspath(cfuncs.__file__))
+    fobjhsrc = os.path.join(f2pydir, 'src', 'fortranobject.h')
+    fobjcsrc = os.path.join(f2pydir, 'src', 'fortranobject.c')
+    # gh-22819 -- begin
+    parser = make_f2py_compile_parser()
+    args, comline_list = parser.parse_known_args(comline_list)
+    pyf_files, _ = filter_files("", "[.]pyf([.]src|)", comline_list)
+    # Checks that no existing modulename is defined in a pyf file
+    # TODO: Remove all this when scaninputline is replaced
+    if args.module_name:
+        if "-h" in comline_list:
+            modname = (
+                args.module_name
+            )  # Directly use from args when -h is present
+        else:
+            modname = validate_modulename(
+                pyf_files, args.module_name
+            )  # Validate modname when -h is not present
+        comline_list += ['-m', modname]  # needed for the rest of scaninputline
+    # gh-22819 -- end
+    files, options = scaninputline(comline_list)
+    auxfuncs.options = options
+    capi_maps.load_f2cmap_file(options['f2cmap_file'])
+    postlist = callcrackfortran(files, options)
+    isusedby = {}
+    for plist in postlist:
+        if 'use' in plist:
+            for u in plist['use'].keys():
+                if u not in isusedby:
+                    isusedby[u] = []
+                isusedby[u].append(plist['name'])
+    for plist in postlist:
+        if plist['block'] == 'python module' and '__user__' in plist['name']:
+            if plist['name'] in isusedby:
+                # if not quiet:
+                outmess(
+                    f'Skipping Makefile build for module "{plist["name"]}" '
+                    'which is used by {}\n'.format(
+                        ','.join(f'"{s}"' for s in isusedby[plist['name']])))
+    if 'signsfile' in options:
+        if options['verbose'] > 1:
+            outmess(
+                'Stopping. Edit the signature file and then run f2py on the signature file: ')
+            outmess('%s %s\n' %
+                    (os.path.basename(sys.argv[0]), options['signsfile']))
+        return
+    for plist in postlist:
+        if plist['block'] != 'python module':
+            if 'python module' not in options:
+                errmess(
+                    'Tip: If your original code is Fortran source then you must use -m option.\n')
+            raise TypeError('All blocks must be python module blocks but got %s' % (
+                repr(plist['block'])))
+    auxfuncs.debugoptions = options['debug']
+    f90mod_rules.options = options
+    auxfuncs.wrapfuncs = options['wrapfuncs']
+
+    ret = buildmodules(postlist)
+
+    for mn in ret.keys():
+        dict_append(ret[mn], {'csrc': fobjcsrc, 'h': fobjhsrc})
+    return ret
+
+
+def filter_files(prefix, suffix, files, remove_prefix=None):
+    """
+    Filter files by prefix and suffix.
+    """
+    filtered, rest = [], []
+    match = re.compile(prefix + r'.*' + suffix + r'\Z').match
+    if remove_prefix:
+        ind = len(prefix)
+    else:
+        ind = 0
+    for file in [x.strip() for x in files]:
+        if match(file):
+            filtered.append(file[ind:])
+        else:
+            rest.append(file)
+    return filtered, rest
+
+
+def get_prefix(module):
+    p = os.path.dirname(os.path.dirname(module.__file__))
+    return p
+
+
+class CombineIncludePaths(argparse.Action):
+    def __call__(self, parser, namespace, values, option_string=None):
+        include_paths_set = set(getattr(namespace, 'include_paths', []) or [])
+        if option_string == "--include_paths":
+            outmess("Use --include-paths or -I instead of --include_paths which will be removed")
+        if option_string == "--include-paths" or option_string == "--include_paths":
+            include_paths_set.update(values.split(':'))
+        else:
+            include_paths_set.add(values)
+        setattr(namespace, 'include_paths', list(include_paths_set))
+
+def f2py_parser():
+    parser = argparse.ArgumentParser(add_help=False)
+    parser.add_argument("-I", dest="include_paths", action=CombineIncludePaths)
+    parser.add_argument("--include-paths", dest="include_paths", action=CombineIncludePaths)
+    parser.add_argument("--include_paths", dest="include_paths", action=CombineIncludePaths)
+    parser.add_argument("--freethreading-compatible", dest="ftcompat", action=argparse.BooleanOptionalAction)
+    return parser
+
+def get_newer_options(iline):
+    iline = (' '.join(iline)).split()
+    parser = f2py_parser()
+    args, remain = parser.parse_known_args(iline)
+    ipaths = args.include_paths
+    if args.include_paths is None:
+        ipaths = []
+    return ipaths, args.ftcompat, remain
+
+def make_f2py_compile_parser():
+    parser = argparse.ArgumentParser(add_help=False)
+    parser.add_argument("--dep", action="append", dest="dependencies")
+    parser.add_argument("--backend", choices=['meson', 'distutils'], default='distutils')
+    parser.add_argument("-m", dest="module_name")
+    return parser
+
+def preparse_sysargv():
+    # To keep backwards bug compatibility, newer flags are handled by argparse,
+    # and `sys.argv` is passed to the rest of `f2py` as is.
+    parser = make_f2py_compile_parser()
+
+    args, remaining_argv = parser.parse_known_args()
+    sys.argv = [sys.argv[0]] + remaining_argv
+
+    backend_key = args.backend
+    if MESON_ONLY_VER and backend_key == 'distutils':
+        outmess("Cannot use distutils backend with Python>=3.12,"
+                " using meson backend instead.\n")
+        backend_key = "meson"
+
+    return {
+        "dependencies": args.dependencies or [],
+        "backend": backend_key,
+        "modulename": args.module_name,
+    }
+
+def run_compile():
+    """
+    Do it all in one call!
+    """
+    import tempfile
+
+    # Collect dependency flags, preprocess sys.argv
+    argy = preparse_sysargv()
+    modulename = argy["modulename"]
+    if modulename is None:
+        modulename = 'untitled'
+    dependencies = argy["dependencies"]
+    backend_key = argy["backend"]
+    build_backend = f2py_build_generator(backend_key)
+
+    i = sys.argv.index('-c')
+    del sys.argv[i]
+
+    remove_build_dir = 0
+    try:
+        i = sys.argv.index('--build-dir')
+    except ValueError:
+        i = None
+    if i is not None:
+        build_dir = sys.argv[i + 1]
+        del sys.argv[i + 1]
+        del sys.argv[i]
+    else:
+        remove_build_dir = 1
+        build_dir = tempfile.mkdtemp()
+
+    _reg1 = re.compile(r'--link-')
+    sysinfo_flags = [_m for _m in sys.argv[1:] if _reg1.match(_m)]
+    sys.argv = [_m for _m in sys.argv if _m not in sysinfo_flags]
+    if sysinfo_flags:
+        sysinfo_flags = [f[7:] for f in sysinfo_flags]
+
+    _reg2 = re.compile(
+        r'--((no-|)(wrap-functions|lower|freethreading-compatible)|debug-capi|quiet|skip-empty-wrappers)|-include')
+    f2py_flags = [_m for _m in sys.argv[1:] if _reg2.match(_m)]
+    sys.argv = [_m for _m in sys.argv if _m not in f2py_flags]
+    f2py_flags2 = []
+    fl = 0
+    for a in sys.argv[1:]:
+        if a in ['only:', 'skip:']:
+            fl = 1
+        elif a == ':':
+            fl = 0
+        if fl or a == ':':
+            f2py_flags2.append(a)
+    if f2py_flags2 and f2py_flags2[-1] != ':':
+        f2py_flags2.append(':')
+    f2py_flags.extend(f2py_flags2)
+    sys.argv = [_m for _m in sys.argv if _m not in f2py_flags2]
+    _reg3 = re.compile(
+        r'--((f(90)?compiler(-exec|)|compiler)=|help-compiler)')
+    flib_flags = [_m for _m in sys.argv[1:] if _reg3.match(_m)]
+    sys.argv = [_m for _m in sys.argv if _m not in flib_flags]
+    # TODO: Once distutils is dropped completely, i.e. min_ver >= 3.12, unify into --fflags
+    reg_f77_f90_flags = re.compile(r'--f(77|90)flags=')
+    reg_distutils_flags = re.compile(r'--((f(77|90)exec|opt|arch)=|(debug|noopt|noarch|help-fcompiler))')
+    fc_flags = [_m for _m in sys.argv[1:] if reg_f77_f90_flags.match(_m)]
+    distutils_flags = [_m for _m in sys.argv[1:] if reg_distutils_flags.match(_m)]
+    if not (MESON_ONLY_VER or backend_key == 'meson'):
+        fc_flags.extend(distutils_flags)
+    sys.argv = [_m for _m in sys.argv if _m not in (fc_flags + distutils_flags)]
+
+    del_list = []
+    for s in flib_flags:
+        v = '--fcompiler='
+        if s[:len(v)] == v:
+            if MESON_ONLY_VER or backend_key == 'meson':
+                outmess(
+                    "--fcompiler cannot be used with meson,"
+                    "set compiler with the FC environment variable\n"
+                    )
+            else:
+                from numpy.distutils import fcompiler
+                fcompiler.load_all_fcompiler_classes()
+                allowed_keys = list(fcompiler.fcompiler_class.keys())
+                nv = ov = s[len(v):].lower()
+                if ov not in allowed_keys:
+                    vmap = {}  # XXX
+                    try:
+                        nv = vmap[ov]
+                    except KeyError:
+                        if ov not in vmap.values():
+                            print('Unknown vendor: "%s"' % (s[len(v):]))
+                    nv = ov
+                i = flib_flags.index(s)
+                flib_flags[i] = '--fcompiler=' + nv
+                continue
+    for s in del_list:
+        i = flib_flags.index(s)
+        del flib_flags[i]
+    assert len(flib_flags) <= 2, repr(flib_flags)
+
+    _reg5 = re.compile(r'--(verbose)')
+    setup_flags = [_m for _m in sys.argv[1:] if _reg5.match(_m)]
+    sys.argv = [_m for _m in sys.argv if _m not in setup_flags]
+
+    if '--quiet' in f2py_flags:
+        setup_flags.append('--quiet')
+
+    # Ugly filter to remove everything but sources
+    sources = sys.argv[1:]
+    f2cmapopt = '--f2cmap'
+    if f2cmapopt in sys.argv:
+        i = sys.argv.index(f2cmapopt)
+        f2py_flags.extend(sys.argv[i:i + 2])
+        del sys.argv[i + 1], sys.argv[i]
+        sources = sys.argv[1:]
+
+    pyf_files, _sources = filter_files("", "[.]pyf([.]src|)", sources)
+    sources = pyf_files + _sources
+    modulename = validate_modulename(pyf_files, modulename)
+    extra_objects, sources = filter_files('', '[.](o|a|so|dylib)', sources)
+    library_dirs, sources = filter_files('-L', '', sources, remove_prefix=1)
+    libraries, sources = filter_files('-l', '', sources, remove_prefix=1)
+    undef_macros, sources = filter_files('-U', '', sources, remove_prefix=1)
+    define_macros, sources = filter_files('-D', '', sources, remove_prefix=1)
+    for i in range(len(define_macros)):
+        name_value = define_macros[i].split('=', 1)
+        if len(name_value) == 1:
+            name_value.append(None)
+        if len(name_value) == 2:
+            define_macros[i] = tuple(name_value)
+        else:
+            print('Invalid use of -D:', name_value)
+
+    # Construct wrappers / signatures / things
+    if backend_key == 'meson':
+        if not pyf_files:
+            outmess('Using meson backend\nWill pass --lower to f2py\nSee https://numpy.org/doc/stable/f2py/buildtools/meson.html\n')
+            f2py_flags.append('--lower')
+            run_main(f" {' '.join(f2py_flags)} -m {modulename} {' '.join(sources)}".split())
+        else:
+            run_main(f" {' '.join(f2py_flags)} {' '.join(pyf_files)}".split())
+
+    # Order matters here, includes are needed for run_main above
+    include_dirs, _, sources = get_newer_options(sources)
+    # Now use the builder
+    builder = build_backend(
+        modulename,
+        sources,
+        extra_objects,
+        build_dir,
+        include_dirs,
+        library_dirs,
+        libraries,
+        define_macros,
+        undef_macros,
+        f2py_flags,
+        sysinfo_flags,
+        fc_flags,
+        flib_flags,
+        setup_flags,
+        remove_build_dir,
+        {"dependencies": dependencies},
+    )
+
+    builder.compile()
+
+
+def validate_modulename(pyf_files, modulename='untitled'):
+    if len(pyf_files) > 1:
+        raise ValueError("Only one .pyf file per call")
+    if pyf_files:
+        pyff = pyf_files[0]
+        pyf_modname = auxfuncs.get_f2py_modulename(pyff)
+        if modulename != pyf_modname:
+            outmess(
+                f"Ignoring -m {modulename}.\n"
+                f"{pyff} defines {pyf_modname} to be the modulename.\n"
+            )
+            modulename = pyf_modname
+    return modulename
+
+def main():
+    if '--help-link' in sys.argv[1:]:
+        sys.argv.remove('--help-link')
+        if MESON_ONLY_VER:
+            outmess("Use --dep for meson builds\n")
+        else:
+            from numpy.distutils.system_info import show_all
+            show_all()
+        return
+
+    if '-c' in sys.argv[1:]:
+        run_compile()
+    else:
+        run_main(sys.argv[1:])
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/f90mod_rules.py b/venv/lib/python3.12/site-packages/numpy/f2py/f90mod_rules.py
new file mode 100644
index 00000000..9c52938f
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/f90mod_rules.py
@@ -0,0 +1,272 @@
+"""
+Build F90 module support for f2py2e.
+
+Copyright 1999 -- 2011 Pearu Peterson all rights reserved.
+Copyright 2011 -- present NumPy Developers.
+Permission to use, modify, and distribute this software is given under the
+terms of the NumPy License.
+
+NO WARRANTY IS EXPRESSED OR IMPLIED.  USE AT YOUR OWN RISK.
+"""
+__version__ = "$Revision: 1.27 $"[10:-1]
+
+f2py_version = 'See `f2py -v`'
+
+import numpy as np
+
+from . import capi_maps
+from . import func2subr
+from .crackfortran import undo_rmbadname, undo_rmbadname1
+
+# The environment provided by auxfuncs.py is needed for some calls to eval.
+# As the needed functions cannot be determined by static inspection of the
+# code, it is safest to use import * pending a major refactoring of f2py.
+from .auxfuncs import *
+
+options = {}
+
+
+def findf90modules(m):
+    if ismodule(m):
+        return [m]
+    if not hasbody(m):
+        return []
+    ret = []
+    for b in m['body']:
+        if ismodule(b):
+            ret.append(b)
+        else:
+            ret = ret + findf90modules(b)
+    return ret
+
+fgetdims1 = """\
+      external f2pysetdata
+      logical ns
+      integer r,i
+      integer(%d) s(*)
+      ns = .FALSE.
+      if (allocated(d)) then
+         do i=1,r
+            if ((size(d,i).ne.s(i)).and.(s(i).ge.0)) then
+               ns = .TRUE.
+            end if
+         end do
+         if (ns) then
+            deallocate(d)
+         end if
+      end if
+      if ((.not.allocated(d)).and.(s(1).ge.1)) then""" % np.intp().itemsize
+
+fgetdims2 = """\
+      end if
+      if (allocated(d)) then
+         do i=1,r
+            s(i) = size(d,i)
+         end do
+      end if
+      flag = 1
+      call f2pysetdata(d,allocated(d))"""
+
+fgetdims2_sa = """\
+      end if
+      if (allocated(d)) then
+         do i=1,r
+            s(i) = size(d,i)
+         end do
+         !s(r) must be equal to len(d(1))
+      end if
+      flag = 2
+      call f2pysetdata(d,allocated(d))"""
+
+
+def buildhooks(pymod):
+    from . import rules
+    ret = {'f90modhooks': [], 'initf90modhooks': [], 'body': [],
+           'need': ['F_FUNC', 'arrayobject.h'],
+           'separatorsfor': {'includes0': '\n', 'includes': '\n'},
+           'docs': ['"Fortran 90/95 modules:\\n"'],
+           'latexdoc': []}
+    fhooks = ['']
+
+    def fadd(line, s=fhooks):
+        s[0] = '%s\n      %s' % (s[0], line)
+    doc = ['']
+
+    def dadd(line, s=doc):
+        s[0] = '%s\n%s' % (s[0], line)
+
+    usenames = getuseblocks(pymod)
+    for m in findf90modules(pymod):
+        contains_functions_or_subroutines = any(
+            item for item in m["body"] if item["block"] in ["function", "subroutine"]
+        )
+        sargs, fargs, efargs, modobjs, notvars, onlyvars = [], [], [], [], [
+            m['name']], []
+        sargsp = []
+        ifargs = []
+        mfargs = []
+        if hasbody(m):
+            for b in m['body']:
+                notvars.append(b['name'])
+        for n in m['vars'].keys():
+            var = m['vars'][n]
+
+            if (n not in notvars and isvariable(var)) and (not l_or(isintent_hide, isprivate)(var)):
+                onlyvars.append(n)
+                mfargs.append(n)
+        outmess('\t\tConstructing F90 module support for "%s"...\n' %
+                (m['name']))
+        if len(onlyvars) == 0 and len(notvars) == 1 and m['name'] in notvars:
+            outmess(f"\t\t\tSkipping {m['name']} since there are no public vars/func in this module...\n")
+            continue
+
+        if m['name'] in usenames and not contains_functions_or_subroutines:
+            outmess(f"\t\t\tSkipping {m['name']} since it is in 'use'...\n")
+            continue
+        if onlyvars:
+            outmess('\t\t  Variables: %s\n' % (' '.join(onlyvars)))
+        chooks = ['']
+
+        def cadd(line, s=chooks):
+            s[0] = '%s\n%s' % (s[0], line)
+        ihooks = ['']
+
+        def iadd(line, s=ihooks):
+            s[0] = '%s\n%s' % (s[0], line)
+
+        vrd = capi_maps.modsign2map(m)
+        cadd('static FortranDataDef f2py_%s_def[] = {' % (m['name']))
+        dadd('\\subsection{Fortran 90/95 module \\texttt{%s}}\n' % (m['name']))
+        if hasnote(m):
+            note = m['note']
+            if isinstance(note, list):
+                note = '\n'.join(note)
+            dadd(note)
+        if onlyvars:
+            dadd('\\begin{description}')
+        for n in onlyvars:
+            var = m['vars'][n]
+            modobjs.append(n)
+            ct = capi_maps.getctype(var)
+            at = capi_maps.c2capi_map[ct]
+            dm = capi_maps.getarrdims(n, var)
+            dms = dm['dims'].replace('*', '-1').strip()
+            dms = dms.replace(':', '-1').strip()
+            if not dms:
+                dms = '-1'
+            use_fgetdims2 = fgetdims2
+            cadd('\t{"%s",%s,{{%s}},%s, %s},' %
+                 (undo_rmbadname1(n), dm['rank'], dms, at,
+                  capi_maps.get_elsize(var)))
+            dadd('\\item[]{{}\\verb@%s@{}}' %
+                 (capi_maps.getarrdocsign(n, var)))
+            if hasnote(var):
+                note = var['note']
+                if isinstance(note, list):
+                    note = '\n'.join(note)
+                dadd('--- %s' % (note))
+            if isallocatable(var):
+                fargs.append('f2py_%s_getdims_%s' % (m['name'], n))
+                efargs.append(fargs[-1])
+                sargs.append(
+                    'void (*%s)(int*,npy_intp*,void(*)(char*,npy_intp*),int*)' % (n))
+                sargsp.append('void (*)(int*,npy_intp*,void(*)(char*,npy_intp*),int*)')
+                iadd('\tf2py_%s_def[i_f2py++].func = %s;' % (m['name'], n))
+                fadd('subroutine %s(r,s,f2pysetdata,flag)' % (fargs[-1]))
+                fadd('use %s, only: d => %s\n' %
+                     (m['name'], undo_rmbadname1(n)))
+                fadd('integer flag\n')
+                fhooks[0] = fhooks[0] + fgetdims1
+                dms = range(1, int(dm['rank']) + 1)
+                fadd(' allocate(d(%s))\n' %
+                     (','.join(['s(%s)' % i for i in dms])))
+                fhooks[0] = fhooks[0] + use_fgetdims2
+                fadd('end subroutine %s' % (fargs[-1]))
+            else:
+                fargs.append(n)
+                sargs.append('char *%s' % (n))
+                sargsp.append('char*')
+                iadd('\tf2py_%s_def[i_f2py++].data = %s;' % (m['name'], n))
+        if onlyvars:
+            dadd('\\end{description}')
+        if hasbody(m):
+            for b in m['body']:
+                if not isroutine(b):
+                    outmess("f90mod_rules.buildhooks:"
+                            f" skipping {b['block']} {b['name']}\n")
+                    continue
+                modobjs.append('%s()' % (b['name']))
+                b['modulename'] = m['name']
+                api, wrap = rules.buildapi(b)
+                if isfunction(b):
+                    fhooks[0] = fhooks[0] + wrap
+                    fargs.append('f2pywrap_%s_%s' % (m['name'], b['name']))
+                    ifargs.append(func2subr.createfuncwrapper(b, signature=1))
+                else:
+                    if wrap:
+                        fhooks[0] = fhooks[0] + wrap
+                        fargs.append('f2pywrap_%s_%s' % (m['name'], b['name']))
+                        ifargs.append(
+                            func2subr.createsubrwrapper(b, signature=1))
+                    else:
+                        fargs.append(b['name'])
+                        mfargs.append(fargs[-1])
+                api['externroutines'] = []
+                ar = applyrules(api, vrd)
+                ar['docs'] = []
+                ar['docshort'] = []
+                ret = dictappend(ret, ar)
+                cadd(('\t{"%s",-1,{{-1}},0,0,NULL,(void *)'
+                      'f2py_rout_#modulename#_%s_%s,'
+                      'doc_f2py_rout_#modulename#_%s_%s},')
+                     % (b['name'], m['name'], b['name'], m['name'], b['name']))
+                sargs.append('char *%s' % (b['name']))
+                sargsp.append('char *')
+                iadd('\tf2py_%s_def[i_f2py++].data = %s;' %
+                     (m['name'], b['name']))
+        cadd('\t{NULL}\n};\n')
+        iadd('}')
+        ihooks[0] = 'static void f2py_setup_%s(%s) {\n\tint i_f2py=0;%s' % (
+            m['name'], ','.join(sargs), ihooks[0])
+        if '_' in m['name']:
+            F_FUNC = 'F_FUNC_US'
+        else:
+            F_FUNC = 'F_FUNC'
+        iadd('extern void %s(f2pyinit%s,F2PYINIT%s)(void (*)(%s));'
+             % (F_FUNC, m['name'], m['name'].upper(), ','.join(sargsp)))
+        iadd('static void f2py_init_%s(void) {' % (m['name']))
+        iadd('\t%s(f2pyinit%s,F2PYINIT%s)(f2py_setup_%s);'
+             % (F_FUNC, m['name'], m['name'].upper(), m['name']))
+        iadd('}\n')
+        ret['f90modhooks'] = ret['f90modhooks'] + chooks + ihooks
+        ret['initf90modhooks'] = ['\tPyDict_SetItemString(d, "%s", PyFortranObject_New(f2py_%s_def,f2py_init_%s));' % (
+            m['name'], m['name'], m['name'])] + ret['initf90modhooks']
+        fadd('')
+        fadd('subroutine f2pyinit%s(f2pysetupfunc)' % (m['name']))
+        if mfargs:
+            for a in undo_rmbadname(mfargs):
+                fadd('use %s, only : %s' % (m['name'], a))
+        if ifargs:
+            fadd(' '.join(['interface'] + ifargs))
+            fadd('end interface')
+        fadd('external f2pysetupfunc')
+        if efargs:
+            for a in undo_rmbadname(efargs):
+                fadd('external %s' % (a))
+        fadd('call f2pysetupfunc(%s)' % (','.join(undo_rmbadname(fargs))))
+        fadd('end subroutine f2pyinit%s\n' % (m['name']))
+
+        dadd('\n'.join(ret['latexdoc']).replace(
+            r'\subsection{', r'\subsubsection{'))
+
+        ret['latexdoc'] = []
+        ret['docs'].append('"\t%s --- %s"' % (m['name'],
+                                              ','.join(undo_rmbadname(modobjs))))
+
+    ret['routine_defs'] = ''
+    ret['doc'] = []
+    ret['docshort'] = []
+    ret['latexdoc'] = doc[0]
+    if len(ret['docs']) <= 1:
+        ret['docs'] = ''
+    return ret, fhooks[0]
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/func2subr.py b/venv/lib/python3.12/site-packages/numpy/f2py/func2subr.py
new file mode 100644
index 00000000..b9aa9fc0
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/func2subr.py
@@ -0,0 +1,323 @@
+"""
+
+Rules for building C/API module with f2py2e.
+
+Copyright 1999 -- 2011 Pearu Peterson all rights reserved.
+Copyright 2011 -- present NumPy Developers.
+Permission to use, modify, and distribute this software is given under the
+terms of the NumPy License.
+
+NO WARRANTY IS EXPRESSED OR IMPLIED.  USE AT YOUR OWN RISK.
+"""
+import copy
+
+from .auxfuncs import (
+    getfortranname, isexternal, isfunction, isfunction_wrap, isintent_in,
+    isintent_out, islogicalfunction, ismoduleroutine, isscalar,
+    issubroutine, issubroutine_wrap, outmess, show
+)
+
+from ._isocbind import isoc_kindmap
+
+def var2fixfortran(vars, a, fa=None, f90mode=None):
+    if fa is None:
+        fa = a
+    if a not in vars:
+        show(vars)
+        outmess('var2fixfortran: No definition for argument "%s".\n' % a)
+        return ''
+    if 'typespec' not in vars[a]:
+        show(vars[a])
+        outmess('var2fixfortran: No typespec for argument "%s".\n' % a)
+        return ''
+    vardef = vars[a]['typespec']
+    if vardef == 'type' and 'typename' in vars[a]:
+        vardef = '%s(%s)' % (vardef, vars[a]['typename'])
+    selector = {}
+    lk = ''
+    if 'kindselector' in vars[a]:
+        selector = vars[a]['kindselector']
+        lk = 'kind'
+    elif 'charselector' in vars[a]:
+        selector = vars[a]['charselector']
+        lk = 'len'
+    if '*' in selector:
+        if f90mode:
+            if selector['*'] in ['*', ':', '(*)']:
+                vardef = '%s(len=*)' % (vardef)
+            else:
+                vardef = '%s(%s=%s)' % (vardef, lk, selector['*'])
+        else:
+            if selector['*'] in ['*', ':']:
+                vardef = '%s*(%s)' % (vardef, selector['*'])
+            else:
+                vardef = '%s*%s' % (vardef, selector['*'])
+    else:
+        if 'len' in selector:
+            vardef = '%s(len=%s' % (vardef, selector['len'])
+            if 'kind' in selector:
+                vardef = '%s,kind=%s)' % (vardef, selector['kind'])
+            else:
+                vardef = '%s)' % (vardef)
+        elif 'kind' in selector:
+            vardef = '%s(kind=%s)' % (vardef, selector['kind'])
+
+    vardef = '%s %s' % (vardef, fa)
+    if 'dimension' in vars[a]:
+        vardef = '%s(%s)' % (vardef, ','.join(vars[a]['dimension']))
+    return vardef
+
+def useiso_c_binding(rout):
+    useisoc = False
+    for key, value in rout['vars'].items():
+        kind_value = value.get('kindselector', {}).get('kind')
+        if kind_value in isoc_kindmap:
+            return True
+    return useisoc
+
+def createfuncwrapper(rout, signature=0):
+    assert isfunction(rout)
+
+    extra_args = []
+    vars = rout['vars']
+    for a in rout['args']:
+        v = rout['vars'][a]
+        for i, d in enumerate(v.get('dimension', [])):
+            if d == ':':
+                dn = 'f2py_%s_d%s' % (a, i)
+                dv = dict(typespec='integer', intent=['hide'])
+                dv['='] = 'shape(%s, %s)' % (a, i)
+                extra_args.append(dn)
+                vars[dn] = dv
+                v['dimension'][i] = dn
+    rout['args'].extend(extra_args)
+    need_interface = bool(extra_args)
+
+    ret = ['']
+
+    def add(line, ret=ret):
+        ret[0] = '%s\n      %s' % (ret[0], line)
+    name = rout['name']
+    fortranname = getfortranname(rout)
+    f90mode = ismoduleroutine(rout)
+    newname = '%sf2pywrap' % (name)
+
+    if newname not in vars:
+        vars[newname] = vars[name]
+        args = [newname] + rout['args'][1:]
+    else:
+        args = [newname] + rout['args']
+
+    l_tmpl = var2fixfortran(vars, name, '@@@NAME@@@', f90mode)
+    if l_tmpl[:13] == 'character*(*)':
+        if f90mode:
+            l_tmpl = 'character(len=10)' + l_tmpl[13:]
+        else:
+            l_tmpl = 'character*10' + l_tmpl[13:]
+        charselect = vars[name]['charselector']
+        if charselect.get('*', '') == '(*)':
+            charselect['*'] = '10'
+
+    l1 = l_tmpl.replace('@@@NAME@@@', newname)
+    rl = None
+
+    useisoc = useiso_c_binding(rout)
+    sargs = ', '.join(args)
+    if f90mode:
+        # gh-23598 fix warning
+        # Essentially, this gets called again with modules where the name of the
+        # function is added to the arguments, which is not required, and removed
+        sargs = sargs.replace(f"{name}, ", '')
+        args = [arg for arg in args if arg != name]
+        rout['args'] = args
+        add('subroutine f2pywrap_%s_%s (%s)' %
+            (rout['modulename'], name, sargs))
+        if not signature:
+            add('use %s, only : %s' % (rout['modulename'], fortranname))
+        if useisoc:
+            add('use iso_c_binding')
+    else:
+        add('subroutine f2pywrap%s (%s)' % (name, sargs))
+        if useisoc:
+            add('use iso_c_binding')
+        if not need_interface:
+            add('external %s' % (fortranname))
+            rl = l_tmpl.replace('@@@NAME@@@', '') + ' ' + fortranname
+
+    if need_interface:
+        for line in rout['saved_interface'].split('\n'):
+            if line.lstrip().startswith('use ') and '__user__' not in line:
+                add(line)
+
+    args = args[1:]
+    dumped_args = []
+    for a in args:
+        if isexternal(vars[a]):
+            add('external %s' % (a))
+            dumped_args.append(a)
+    for a in args:
+        if a in dumped_args:
+            continue
+        if isscalar(vars[a]):
+            add(var2fixfortran(vars, a, f90mode=f90mode))
+            dumped_args.append(a)
+    for a in args:
+        if a in dumped_args:
+            continue
+        if isintent_in(vars[a]):
+            add(var2fixfortran(vars, a, f90mode=f90mode))
+            dumped_args.append(a)
+    for a in args:
+        if a in dumped_args:
+            continue
+        add(var2fixfortran(vars, a, f90mode=f90mode))
+
+    add(l1)
+    if rl is not None:
+        add(rl)
+
+    if need_interface:
+        if f90mode:
+            # f90 module already defines needed interface
+            pass
+        else:
+            add('interface')
+            add(rout['saved_interface'].lstrip())
+            add('end interface')
+
+    sargs = ', '.join([a for a in args if a not in extra_args])
+
+    if not signature:
+        if islogicalfunction(rout):
+            add('%s = .not.(.not.%s(%s))' % (newname, fortranname, sargs))
+        else:
+            add('%s = %s(%s)' % (newname, fortranname, sargs))
+    if f90mode:
+        add('end subroutine f2pywrap_%s_%s' % (rout['modulename'], name))
+    else:
+        add('end')
+    return ret[0]
+
+
+def createsubrwrapper(rout, signature=0):
+    assert issubroutine(rout)
+
+    extra_args = []
+    vars = rout['vars']
+    for a in rout['args']:
+        v = rout['vars'][a]
+        for i, d in enumerate(v.get('dimension', [])):
+            if d == ':':
+                dn = 'f2py_%s_d%s' % (a, i)
+                dv = dict(typespec='integer', intent=['hide'])
+                dv['='] = 'shape(%s, %s)' % (a, i)
+                extra_args.append(dn)
+                vars[dn] = dv
+                v['dimension'][i] = dn
+    rout['args'].extend(extra_args)
+    need_interface = bool(extra_args)
+
+    ret = ['']
+
+    def add(line, ret=ret):
+        ret[0] = '%s\n      %s' % (ret[0], line)
+    name = rout['name']
+    fortranname = getfortranname(rout)
+    f90mode = ismoduleroutine(rout)
+
+    args = rout['args']
+
+    useisoc = useiso_c_binding(rout)
+    sargs = ', '.join(args)
+    if f90mode:
+        add('subroutine f2pywrap_%s_%s (%s)' %
+            (rout['modulename'], name, sargs))
+        if useisoc:
+            add('use iso_c_binding')
+        if not signature:
+            add('use %s, only : %s' % (rout['modulename'], fortranname))
+    else:
+        add('subroutine f2pywrap%s (%s)' % (name, sargs))
+        if useisoc:
+            add('use iso_c_binding')
+        if not need_interface:
+            add('external %s' % (fortranname))
+
+    if need_interface:
+        for line in rout['saved_interface'].split('\n'):
+            if line.lstrip().startswith('use ') and '__user__' not in line:
+                add(line)
+
+    dumped_args = []
+    for a in args:
+        if isexternal(vars[a]):
+            add('external %s' % (a))
+            dumped_args.append(a)
+    for a in args:
+        if a in dumped_args:
+            continue
+        if isscalar(vars[a]):
+            add(var2fixfortran(vars, a, f90mode=f90mode))
+            dumped_args.append(a)
+    for a in args:
+        if a in dumped_args:
+            continue
+        add(var2fixfortran(vars, a, f90mode=f90mode))
+
+    if need_interface:
+        if f90mode:
+            # f90 module already defines needed interface
+            pass
+        else:
+            add('interface')
+            for line in rout['saved_interface'].split('\n'):
+                if line.lstrip().startswith('use ') and '__user__' in line:
+                    continue
+                add(line)
+            add('end interface')
+
+    sargs = ', '.join([a for a in args if a not in extra_args])
+
+    if not signature:
+        add('call %s(%s)' % (fortranname, sargs))
+    if f90mode:
+        add('end subroutine f2pywrap_%s_%s' % (rout['modulename'], name))
+    else:
+        add('end')
+    return ret[0]
+
+
+def assubr(rout):
+    if isfunction_wrap(rout):
+        fortranname = getfortranname(rout)
+        name = rout['name']
+        outmess('\t\tCreating wrapper for Fortran function "%s"("%s")...\n' % (
+            name, fortranname))
+        rout = copy.copy(rout)
+        fname = name
+        rname = fname
+        if 'result' in rout:
+            rname = rout['result']
+            rout['vars'][fname] = rout['vars'][rname]
+        fvar = rout['vars'][fname]
+        if not isintent_out(fvar):
+            if 'intent' not in fvar:
+                fvar['intent'] = []
+            fvar['intent'].append('out')
+            flag = 1
+            for i in fvar['intent']:
+                if i.startswith('out='):
+                    flag = 0
+                    break
+            if flag:
+                fvar['intent'].append('out=%s' % (rname))
+        rout['args'][:] = [fname] + rout['args']
+        return rout, createfuncwrapper(rout)
+    if issubroutine_wrap(rout):
+        fortranname = getfortranname(rout)
+        name = rout['name']
+        outmess('\t\tCreating wrapper for Fortran subroutine "%s"("%s")...\n'
+                % (name, fortranname))
+        rout = copy.copy(rout)
+        return rout, createsubrwrapper(rout)
+    return rout, ''
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/rules.py b/venv/lib/python3.12/site-packages/numpy/f2py/rules.py
new file mode 100755
index 00000000..7566e1ec
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/rules.py
@@ -0,0 +1,1573 @@
+#!/usr/bin/env python3
+"""
+
+Rules for building C/API module with f2py2e.
+
+Here is a skeleton of a new wrapper function (13Dec2001):
+
+wrapper_function(args)
+  declarations
+  get_python_arguments, say, `a' and `b'
+
+  get_a_from_python
+  if (successful) {
+
+    get_b_from_python
+    if (successful) {
+
+      callfortran
+      if (successful) {
+
+        put_a_to_python
+        if (successful) {
+
+          put_b_to_python
+          if (successful) {
+
+            buildvalue = ...
+
+          }
+
+        }
+
+      }
+
+    }
+    cleanup_b
+
+  }
+  cleanup_a
+
+  return buildvalue
+
+Copyright 1999 -- 2011 Pearu Peterson all rights reserved.
+Copyright 2011 -- present NumPy Developers.
+Permission to use, modify, and distribute this software is given under the
+terms of the NumPy License.
+
+NO WARRANTY IS EXPRESSED OR IMPLIED.  USE AT YOUR OWN RISK.
+"""
+import os, sys
+import time
+import copy
+from pathlib import Path
+
+# __version__.version is now the same as the NumPy version
+from . import __version__
+
+from .auxfuncs import (
+    applyrules, debugcapi, dictappend, errmess, gentitle, getargs2,
+    hascallstatement, hasexternals, hasinitvalue, hasnote,
+    hasresultnote, isarray, isarrayofstrings, ischaracter,
+    ischaracterarray, ischaracter_or_characterarray, iscomplex,
+    iscomplexarray, iscomplexfunction, iscomplexfunction_warn,
+    isdummyroutine, isexternal, isfunction, isfunction_wrap, isint1,
+    isint1array, isintent_aux, isintent_c, isintent_callback,
+    isintent_copy, isintent_hide, isintent_inout, isintent_nothide,
+    isintent_out, isintent_overwrite, islogical, islong_complex,
+    islong_double, islong_doublefunction, islong_long,
+    islong_longfunction, ismoduleroutine, isoptional, isrequired,
+    isscalar, issigned_long_longarray, isstring, isstringarray,
+    isstringfunction, issubroutine, isattr_value,
+    issubroutine_wrap, isthreadsafe, isunsigned, isunsigned_char,
+    isunsigned_chararray, isunsigned_long_long,
+    isunsigned_long_longarray, isunsigned_short, isunsigned_shortarray,
+    l_and, l_not, l_or, outmess, replace, stripcomma, requiresf90wrapper
+)
+
+from . import capi_maps
+from . import cfuncs
+from . import common_rules
+from . import use_rules
+from . import f90mod_rules
+from . import func2subr
+
+f2py_version = __version__.version
+numpy_version = __version__.version
+
+options = {}
+sepdict = {}
+# for k in ['need_cfuncs']: sepdict[k]=','
+for k in ['decl',
+          'frompyobj',
+          'cleanupfrompyobj',
+          'topyarr', 'method',
+          'pyobjfrom', 'closepyobjfrom',
+          'freemem',
+          'userincludes',
+          'includes0', 'includes', 'typedefs', 'typedefs_generated',
+          'cppmacros', 'cfuncs', 'callbacks',
+          'latexdoc',
+          'restdoc',
+          'routine_defs', 'externroutines',
+          'initf2pywraphooks',
+          'commonhooks', 'initcommonhooks',
+          'f90modhooks', 'initf90modhooks']:
+    sepdict[k] = '\n'
+
+#################### Rules for C/API module #################
+
+generationtime = int(os.environ.get('SOURCE_DATE_EPOCH', time.time()))
+module_rules = {
+    'modulebody': """\
+/* File: #modulename#module.c
+ * This file is auto-generated with f2py (version:#f2py_version#).
+ * f2py is a Fortran to Python Interface Generator (FPIG), Second Edition,
+ * written by Pearu Peterson .
+ * Generation date: """ + time.asctime(time.gmtime(generationtime)) + """
+ * Do not edit this file directly unless you know what you are doing!!!
+ */
+
+#ifdef __cplusplus
+extern \"C\" {
+#endif
+
+#ifndef PY_SSIZE_T_CLEAN
+#define PY_SSIZE_T_CLEAN
+#endif /* PY_SSIZE_T_CLEAN */
+
+/* Unconditionally included */
+#include 
+#include 
+
+""" + gentitle("See f2py2e/cfuncs.py: includes") + """
+#includes#
+#includes0#
+
+""" + gentitle("See f2py2e/rules.py: mod_rules['modulebody']") + """
+static PyObject *#modulename#_error;
+static PyObject *#modulename#_module;
+
+""" + gentitle("See f2py2e/cfuncs.py: typedefs") + """
+#typedefs#
+
+""" + gentitle("See f2py2e/cfuncs.py: typedefs_generated") + """
+#typedefs_generated#
+
+""" + gentitle("See f2py2e/cfuncs.py: cppmacros") + """
+#cppmacros#
+
+""" + gentitle("See f2py2e/cfuncs.py: cfuncs") + """
+#cfuncs#
+
+""" + gentitle("See f2py2e/cfuncs.py: userincludes") + """
+#userincludes#
+
+""" + gentitle("See f2py2e/capi_rules.py: usercode") + """
+#usercode#
+
+/* See f2py2e/rules.py */
+#externroutines#
+
+""" + gentitle("See f2py2e/capi_rules.py: usercode1") + """
+#usercode1#
+
+""" + gentitle("See f2py2e/cb_rules.py: buildcallback") + """
+#callbacks#
+
+""" + gentitle("See f2py2e/rules.py: buildapi") + """
+#body#
+
+""" + gentitle("See f2py2e/f90mod_rules.py: buildhooks") + """
+#f90modhooks#
+
+""" + gentitle("See f2py2e/rules.py: module_rules['modulebody']") + """
+
+""" + gentitle("See f2py2e/common_rules.py: buildhooks") + """
+#commonhooks#
+
+""" + gentitle("See f2py2e/rules.py") + """
+
+static FortranDataDef f2py_routine_defs[] = {
+#routine_defs#
+    {NULL}
+};
+
+static PyMethodDef f2py_module_methods[] = {
+#pymethoddef#
+    {NULL,NULL}
+};
+
+static struct PyModuleDef moduledef = {
+    PyModuleDef_HEAD_INIT,
+    "#modulename#",
+    NULL,
+    -1,
+    f2py_module_methods,
+    NULL,
+    NULL,
+    NULL,
+    NULL
+};
+
+PyMODINIT_FUNC PyInit_#modulename#(void) {
+    int i;
+    PyObject *m,*d, *s, *tmp;
+    m = #modulename#_module = PyModule_Create(&moduledef);
+    Py_SET_TYPE(&PyFortran_Type, &PyType_Type);
+    import_array();
+    if (PyErr_Occurred())
+        {PyErr_SetString(PyExc_ImportError, \"can't initialize module #modulename# (failed to import numpy)\"); return m;}
+    d = PyModule_GetDict(m);
+    s = PyUnicode_FromString(\"#f2py_version#\");
+    PyDict_SetItemString(d, \"__version__\", s);
+    Py_DECREF(s);
+    s = PyUnicode_FromString(
+        \"This module '#modulename#' is auto-generated with f2py (version:#f2py_version#).\\nFunctions:\\n\"\n#docs#\".\");
+    PyDict_SetItemString(d, \"__doc__\", s);
+    Py_DECREF(s);
+    s = PyUnicode_FromString(\"""" + numpy_version + """\");
+    PyDict_SetItemString(d, \"__f2py_numpy_version__\", s);
+    Py_DECREF(s);
+    #modulename#_error = PyErr_NewException (\"#modulename#.error\", NULL, NULL);
+    /*
+     * Store the error object inside the dict, so that it could get deallocated.
+     * (in practice, this is a module, so it likely will not and cannot.)
+     */
+    PyDict_SetItemString(d, \"_#modulename#_error\", #modulename#_error);
+    Py_DECREF(#modulename#_error);
+    for(i=0;f2py_routine_defs[i].name!=NULL;i++) {
+        tmp = PyFortranObject_NewAsAttr(&f2py_routine_defs[i]);
+        PyDict_SetItemString(d, f2py_routine_defs[i].name, tmp);
+        Py_DECREF(tmp);
+    }
+#initf2pywraphooks#
+#initf90modhooks#
+#initcommonhooks#
+#interface_usercode#
+
+#if Py_GIL_DISABLED
+    // signal whether this module supports running with the GIL disabled
+    PyUnstable_Module_SetGIL(m , #gil_used#);
+#endif
+
+#ifdef F2PY_REPORT_ATEXIT
+    if (! PyErr_Occurred())
+        on_exit(f2py_report_on_exit,(void*)\"#modulename#\");
+#endif
+    return m;
+}
+#ifdef __cplusplus
+}
+#endif
+""",
+    'separatorsfor': {'latexdoc': '\n\n',
+                      'restdoc': '\n\n'},
+    'latexdoc': ['\\section{Module \\texttt{#texmodulename#}}\n',
+                 '#modnote#\n',
+                 '#latexdoc#'],
+    'restdoc': ['Module #modulename#\n' + '=' * 80,
+                '\n#restdoc#']
+}
+
+defmod_rules = [
+    {'body': '/*eof body*/',
+     'method': '/*eof method*/',
+     'externroutines': '/*eof externroutines*/',
+     'routine_defs': '/*eof routine_defs*/',
+     'initf90modhooks': '/*eof initf90modhooks*/',
+     'initf2pywraphooks': '/*eof initf2pywraphooks*/',
+     'initcommonhooks': '/*eof initcommonhooks*/',
+     'latexdoc': '',
+     'restdoc': '',
+     'modnote': {hasnote: '#note#', l_not(hasnote): ''},
+     }
+]
+
+routine_rules = {
+    'separatorsfor': sepdict,
+    'body': """
+#begintitle#
+static char doc_#apiname#[] = \"\\\n#docreturn##name#(#docsignatureshort#)\\n\\nWrapper for ``#name#``.\\\n\\n#docstrsigns#\";
+/* #declfortranroutine# */
+static PyObject *#apiname#(const PyObject *capi_self,
+                           PyObject *capi_args,
+                           PyObject *capi_keywds,
+                           #functype# (*f2py_func)(#callprotoargument#)) {
+    PyObject * volatile capi_buildvalue = NULL;
+    volatile int f2py_success = 1;
+#decl#
+    static char *capi_kwlist[] = {#kwlist##kwlistopt##kwlistxa#NULL};
+#usercode#
+#routdebugenter#
+#ifdef F2PY_REPORT_ATEXIT
+f2py_start_clock();
+#endif
+    if (!PyArg_ParseTupleAndKeywords(capi_args,capi_keywds,\\
+        \"#argformat#|#keyformat##xaformat#:#pyname#\",\\
+        capi_kwlist#args_capi##keys_capi##keys_xa#))\n        return NULL;
+#frompyobj#
+/*end of frompyobj*/
+#ifdef F2PY_REPORT_ATEXIT
+f2py_start_call_clock();
+#endif
+#callfortranroutine#
+if (PyErr_Occurred())
+  f2py_success = 0;
+#ifdef F2PY_REPORT_ATEXIT
+f2py_stop_call_clock();
+#endif
+/*end of callfortranroutine*/
+        if (f2py_success) {
+#pyobjfrom#
+/*end of pyobjfrom*/
+        CFUNCSMESS(\"Building return value.\\n\");
+        capi_buildvalue = Py_BuildValue(\"#returnformat#\"#return#);
+/*closepyobjfrom*/
+#closepyobjfrom#
+        } /*if (f2py_success) after callfortranroutine*/
+/*cleanupfrompyobj*/
+#cleanupfrompyobj#
+    if (capi_buildvalue == NULL) {
+#routdebugfailure#
+    } else {
+#routdebugleave#
+    }
+    CFUNCSMESS(\"Freeing memory.\\n\");
+#freemem#
+#ifdef F2PY_REPORT_ATEXIT
+f2py_stop_clock();
+#endif
+    return capi_buildvalue;
+}
+#endtitle#
+""",
+    'routine_defs': '#routine_def#',
+    'initf2pywraphooks': '#initf2pywraphook#',
+    'externroutines': '#declfortranroutine#',
+    'doc': '#docreturn##name#(#docsignature#)',
+    'docshort': '#docreturn##name#(#docsignatureshort#)',
+    'docs': '"    #docreturn##name#(#docsignature#)\\n"\n',
+    'need': ['arrayobject.h', 'CFUNCSMESS', 'MINMAX'],
+    'cppmacros': {debugcapi: '#define DEBUGCFUNCS'},
+    'latexdoc': ['\\subsection{Wrapper function \\texttt{#texname#}}\n',
+                 """
+\\noindent{{}\\verb@#docreturn##name#@{}}\\texttt{(#latexdocsignatureshort#)}
+#routnote#
+
+#latexdocstrsigns#
+"""],
+    'restdoc': ['Wrapped function ``#name#``\n' + '-' * 80,
+
+                ]
+}
+
+################## Rules for C/API function ##############
+
+rout_rules = [
+    {  # Init
+        'separatorsfor': {'callfortranroutine': '\n', 'routdebugenter': '\n', 'decl': '\n',
+                          'routdebugleave': '\n', 'routdebugfailure': '\n',
+                          'setjmpbuf': ' || ',
+                          'docstrreq': '\n', 'docstropt': '\n', 'docstrout': '\n',
+                          'docstrcbs': '\n', 'docstrsigns': '\\n"\n"',
+                          'latexdocstrsigns': '\n',
+                          'latexdocstrreq': '\n', 'latexdocstropt': '\n',
+                          'latexdocstrout': '\n', 'latexdocstrcbs': '\n',
+                          },
+        'kwlist': '', 'kwlistopt': '', 'callfortran': '', 'callfortranappend': '',
+        'docsign': '', 'docsignopt': '', 'decl': '/*decl*/',
+        'freemem': '/*freemem*/',
+        'docsignshort': '', 'docsignoptshort': '',
+        'docstrsigns': '', 'latexdocstrsigns': '',
+        'docstrreq': '\\nParameters\\n----------',
+        'docstropt': '\\nOther Parameters\\n----------------',
+        'docstrout': '\\nReturns\\n-------',
+        'docstrcbs': '\\nNotes\\n-----\\nCall-back functions::\\n',
+        'latexdocstrreq': '\\noindent Required arguments:',
+        'latexdocstropt': '\\noindent Optional arguments:',
+        'latexdocstrout': '\\noindent Return objects:',
+        'latexdocstrcbs': '\\noindent Call-back functions:',
+        'args_capi': '', 'keys_capi': '', 'functype': '',
+        'frompyobj': '/*frompyobj*/',
+        # this list will be reversed
+        'cleanupfrompyobj': ['/*end of cleanupfrompyobj*/'],
+        'pyobjfrom': '/*pyobjfrom*/',
+        # this list will be reversed
+        'closepyobjfrom': ['/*end of closepyobjfrom*/'],
+        'topyarr': '/*topyarr*/', 'routdebugleave': '/*routdebugleave*/',
+        'routdebugenter': '/*routdebugenter*/',
+        'routdebugfailure': '/*routdebugfailure*/',
+        'callfortranroutine': '/*callfortranroutine*/',
+        'argformat': '', 'keyformat': '', 'need_cfuncs': '',
+        'docreturn': '', 'return': '', 'returnformat': '', 'rformat': '',
+        'kwlistxa': '', 'keys_xa': '', 'xaformat': '', 'docsignxa': '', 'docsignxashort': '',
+        'initf2pywraphook': '',
+        'routnote': {hasnote: '--- #note#', l_not(hasnote): ''},
+    }, {
+        'apiname': 'f2py_rout_#modulename#_#name#',
+        'pyname': '#modulename#.#name#',
+        'decl': '',
+        '_check': l_not(ismoduleroutine)
+    }, {
+        'apiname': 'f2py_rout_#modulename#_#f90modulename#_#name#',
+        'pyname': '#modulename#.#f90modulename#.#name#',
+        'decl': '',
+        '_check': ismoduleroutine
+    }, {  # Subroutine
+        'functype': 'void',
+        'declfortranroutine': {l_and(l_not(l_or(ismoduleroutine, isintent_c)), l_not(isdummyroutine)): 'extern void #F_FUNC#(#fortranname#,#FORTRANNAME#)(#callprotoargument#);',
+                               l_and(l_not(ismoduleroutine), isintent_c, l_not(isdummyroutine)): 'extern void #fortranname#(#callprotoargument#);',
+                               ismoduleroutine: '',
+                               isdummyroutine: ''
+                               },
+        'routine_def': {
+            l_not(l_or(ismoduleroutine, isintent_c, isdummyroutine)):
+            '    {\"#name#\",-1,{{-1}},0,0,(char *)'
+            '  #F_FUNC#(#fortranname#,#FORTRANNAME#),'
+            '  (f2py_init_func)#apiname#,doc_#apiname#},',
+            l_and(l_not(ismoduleroutine), isintent_c, l_not(isdummyroutine)):
+            '    {\"#name#\",-1,{{-1}},0,0,(char *)#fortranname#,'
+            '  (f2py_init_func)#apiname#,doc_#apiname#},',
+            l_and(l_not(ismoduleroutine), isdummyroutine):
+            '    {\"#name#\",-1,{{-1}},0,0,NULL,'
+            '  (f2py_init_func)#apiname#,doc_#apiname#},',
+        },
+        'need': {l_and(l_not(l_or(ismoduleroutine, isintent_c)), l_not(isdummyroutine)): 'F_FUNC'},
+        'callfortranroutine': [
+            {debugcapi: [
+                """    fprintf(stderr,\"debug-capi:Fortran subroutine `#fortranname#(#callfortran#)\'\\n\");"""]},
+            {hasexternals: """\
+        if (#setjmpbuf#) {
+            f2py_success = 0;
+        } else {"""},
+            {isthreadsafe: '            Py_BEGIN_ALLOW_THREADS'},
+            {hascallstatement: '''                #callstatement#;
+                /*(*f2py_func)(#callfortran#);*/'''},
+            {l_not(l_or(hascallstatement, isdummyroutine))
+                   : '                (*f2py_func)(#callfortran#);'},
+            {isthreadsafe: '            Py_END_ALLOW_THREADS'},
+            {hasexternals: """        }"""}
+        ],
+        '_check': l_and(issubroutine, l_not(issubroutine_wrap)),
+    }, {  # Wrapped function
+        'functype': 'void',
+        'declfortranroutine': {l_not(l_or(ismoduleroutine, isdummyroutine)): 'extern void #F_WRAPPEDFUNC#(#name_lower#,#NAME#)(#callprotoargument#);',
+                               isdummyroutine: '',
+                               },
+
+        'routine_def': {
+            l_not(l_or(ismoduleroutine, isdummyroutine)):
+            '    {\"#name#\",-1,{{-1}},0,0,(char *)'
+            '  #F_WRAPPEDFUNC#(#name_lower#,#NAME#),'
+            '  (f2py_init_func)#apiname#,doc_#apiname#},',
+            isdummyroutine:
+            '    {\"#name#\",-1,{{-1}},0,0,NULL,'
+            '  (f2py_init_func)#apiname#,doc_#apiname#},',
+        },
+        'initf2pywraphook': {l_not(l_or(ismoduleroutine, isdummyroutine)): '''
+    {
+      extern #ctype# #F_FUNC#(#name_lower#,#NAME#)(void);
+      PyObject* o = PyDict_GetItemString(d,"#name#");
+      tmp = F2PyCapsule_FromVoidPtr((void*)#F_FUNC#(#name_lower#,#NAME#),NULL);
+      PyObject_SetAttrString(o,"_cpointer", tmp);
+      Py_DECREF(tmp);
+      s = PyUnicode_FromString("#name#");
+      PyObject_SetAttrString(o,"__name__", s);
+      Py_DECREF(s);
+    }
+    '''},
+        'need': {l_not(l_or(ismoduleroutine, isdummyroutine)): ['F_WRAPPEDFUNC', 'F_FUNC']},
+        'callfortranroutine': [
+            {debugcapi: [
+                """    fprintf(stderr,\"debug-capi:Fortran subroutine `f2pywrap#name_lower#(#callfortran#)\'\\n\");"""]},
+            {hasexternals: """\
+    if (#setjmpbuf#) {
+        f2py_success = 0;
+    } else {"""},
+            {isthreadsafe: '    Py_BEGIN_ALLOW_THREADS'},
+            {l_not(l_or(hascallstatement, isdummyroutine))
+                   : '    (*f2py_func)(#callfortran#);'},
+            {hascallstatement:
+                '    #callstatement#;\n    /*(*f2py_func)(#callfortran#);*/'},
+            {isthreadsafe: '    Py_END_ALLOW_THREADS'},
+            {hasexternals: '    }'}
+        ],
+        '_check': isfunction_wrap,
+    }, {  # Wrapped subroutine
+        'functype': 'void',
+        'declfortranroutine': {l_not(l_or(ismoduleroutine, isdummyroutine)): 'extern void #F_WRAPPEDFUNC#(#name_lower#,#NAME#)(#callprotoargument#);',
+                               isdummyroutine: '',
+                               },
+
+        'routine_def': {
+            l_not(l_or(ismoduleroutine, isdummyroutine)):
+            '    {\"#name#\",-1,{{-1}},0,0,(char *)'
+            '  #F_WRAPPEDFUNC#(#name_lower#,#NAME#),'
+            '  (f2py_init_func)#apiname#,doc_#apiname#},',
+            isdummyroutine:
+            '    {\"#name#\",-1,{{-1}},0,0,NULL,'
+            '  (f2py_init_func)#apiname#,doc_#apiname#},',
+        },
+        'initf2pywraphook': {l_not(l_or(ismoduleroutine, isdummyroutine)): '''
+    {
+      extern void #F_FUNC#(#name_lower#,#NAME#)(void);
+      PyObject* o = PyDict_GetItemString(d,"#name#");
+      tmp = F2PyCapsule_FromVoidPtr((void*)#F_FUNC#(#name_lower#,#NAME#),NULL);
+      PyObject_SetAttrString(o,"_cpointer", tmp);
+      Py_DECREF(tmp);
+      s = PyUnicode_FromString("#name#");
+      PyObject_SetAttrString(o,"__name__", s);
+      Py_DECREF(s);
+    }
+    '''},
+        'need': {l_not(l_or(ismoduleroutine, isdummyroutine)): ['F_WRAPPEDFUNC', 'F_FUNC']},
+        'callfortranroutine': [
+            {debugcapi: [
+                """    fprintf(stderr,\"debug-capi:Fortran subroutine `f2pywrap#name_lower#(#callfortran#)\'\\n\");"""]},
+            {hasexternals: """\
+    if (#setjmpbuf#) {
+        f2py_success = 0;
+    } else {"""},
+            {isthreadsafe: '    Py_BEGIN_ALLOW_THREADS'},
+            {l_not(l_or(hascallstatement, isdummyroutine))
+                   : '    (*f2py_func)(#callfortran#);'},
+            {hascallstatement:
+                '    #callstatement#;\n    /*(*f2py_func)(#callfortran#);*/'},
+            {isthreadsafe: '    Py_END_ALLOW_THREADS'},
+            {hasexternals: '    }'}
+        ],
+        '_check': issubroutine_wrap,
+    }, {  # Function
+        'functype': '#ctype#',
+        'docreturn': {l_not(isintent_hide): '#rname#,'},
+        'docstrout': '#pydocsignout#',
+        'latexdocstrout': ['\\item[]{{}\\verb@#pydocsignout#@{}}',
+                           {hasresultnote: '--- #resultnote#'}],
+        'callfortranroutine': [{l_and(debugcapi, isstringfunction): """\
+#ifdef USESCOMPAQFORTRAN
+    fprintf(stderr,\"debug-capi:Fortran function #ctype# #fortranname#(#callcompaqfortran#)\\n\");
+#else
+    fprintf(stderr,\"debug-capi:Fortran function #ctype# #fortranname#(#callfortran#)\\n\");
+#endif
+"""},
+                               {l_and(debugcapi, l_not(isstringfunction)): """\
+    fprintf(stderr,\"debug-capi:Fortran function #ctype# #fortranname#(#callfortran#)\\n\");
+"""}
+                               ],
+        '_check': l_and(isfunction, l_not(isfunction_wrap))
+    }, {  # Scalar function
+        'declfortranroutine': {l_and(l_not(l_or(ismoduleroutine, isintent_c)), l_not(isdummyroutine)): 'extern #ctype# #F_FUNC#(#fortranname#,#FORTRANNAME#)(#callprotoargument#);',
+                               l_and(l_not(ismoduleroutine), isintent_c, l_not(isdummyroutine)): 'extern #ctype# #fortranname#(#callprotoargument#);',
+                               isdummyroutine: ''
+                               },
+        'routine_def': {
+            l_and(l_not(l_or(ismoduleroutine, isintent_c)),
+                  l_not(isdummyroutine)):
+            ('    {\"#name#\",-1,{{-1}},0,0,(char *)'
+             '  #F_FUNC#(#fortranname#,#FORTRANNAME#),'
+             '  (f2py_init_func)#apiname#,doc_#apiname#},'),
+            l_and(l_not(ismoduleroutine), isintent_c, l_not(isdummyroutine)):
+            ('    {\"#name#\",-1,{{-1}},0,0,(char *)#fortranname#,'
+             '  (f2py_init_func)#apiname#,doc_#apiname#},'),
+            isdummyroutine:
+            '    {\"#name#\",-1,{{-1}},0,0,NULL,'
+            '(f2py_init_func)#apiname#,doc_#apiname#},',
+        },
+        'decl': [{iscomplexfunction_warn: '    #ctype# #name#_return_value={0,0};',
+                  l_not(iscomplexfunction): '    #ctype# #name#_return_value=0;'},
+                 {iscomplexfunction:
+                  '    PyObject *#name#_return_value_capi = Py_None;'}
+                 ],
+        'callfortranroutine': [
+            {hasexternals: """\
+    if (#setjmpbuf#) {
+        f2py_success = 0;
+    } else {"""},
+            {isthreadsafe: '    Py_BEGIN_ALLOW_THREADS'},
+            {hascallstatement: '''    #callstatement#;
+/*    #name#_return_value = (*f2py_func)(#callfortran#);*/
+'''},
+            {l_not(l_or(hascallstatement, isdummyroutine))
+                   : '    #name#_return_value = (*f2py_func)(#callfortran#);'},
+            {isthreadsafe: '    Py_END_ALLOW_THREADS'},
+            {hasexternals: '    }'},
+            {l_and(debugcapi, iscomplexfunction)
+                   : '    fprintf(stderr,"#routdebugshowvalue#\\n",#name#_return_value.r,#name#_return_value.i);'},
+            {l_and(debugcapi, l_not(iscomplexfunction)): '    fprintf(stderr,"#routdebugshowvalue#\\n",#name#_return_value);'}],
+        'pyobjfrom': {iscomplexfunction: '    #name#_return_value_capi = pyobj_from_#ctype#1(#name#_return_value);'},
+        'need': [{l_not(isdummyroutine): 'F_FUNC'},
+                 {iscomplexfunction: 'pyobj_from_#ctype#1'},
+                 {islong_longfunction: 'long_long'},
+                 {islong_doublefunction: 'long_double'}],
+        'returnformat': {l_not(isintent_hide): '#rformat#'},
+        'return': {iscomplexfunction: ',#name#_return_value_capi',
+                   l_not(l_or(iscomplexfunction, isintent_hide)): ',#name#_return_value'},
+        '_check': l_and(isfunction, l_not(isstringfunction), l_not(isfunction_wrap))
+    }, {  # String function # in use for --no-wrap
+        'declfortranroutine': 'extern void #F_FUNC#(#fortranname#,#FORTRANNAME#)(#callprotoargument#);',
+        'routine_def': {l_not(l_or(ismoduleroutine, isintent_c)):
+                        '    {\"#name#\",-1,{{-1}},0,0,(char *)#F_FUNC#(#fortranname#,#FORTRANNAME#),(f2py_init_func)#apiname#,doc_#apiname#},',
+                        l_and(l_not(ismoduleroutine), isintent_c):
+                        '    {\"#name#\",-1,{{-1}},0,0,(char *)#fortranname#,(f2py_init_func)#apiname#,doc_#apiname#},'
+                        },
+        'decl': ['    #ctype# #name#_return_value = NULL;',
+                 '    int #name#_return_value_len = 0;'],
+        'callfortran':'#name#_return_value,#name#_return_value_len,',
+        'callfortranroutine':['    #name#_return_value_len = #rlength#;',
+                              '    if ((#name#_return_value = (string)malloc('
+                              + '#name#_return_value_len+1) == NULL) {',
+                              '        PyErr_SetString(PyExc_MemoryError, \"out of memory\");',
+                              '        f2py_success = 0;',
+                              '    } else {',
+                              "        (#name#_return_value)[#name#_return_value_len] = '\\0';",
+                              '    }',
+                              '    if (f2py_success) {',
+                              {hasexternals: """\
+        if (#setjmpbuf#) {
+            f2py_success = 0;
+        } else {"""},
+                              {isthreadsafe: '        Py_BEGIN_ALLOW_THREADS'},
+                              """\
+#ifdef USESCOMPAQFORTRAN
+        (*f2py_func)(#callcompaqfortran#);
+#else
+        (*f2py_func)(#callfortran#);
+#endif
+""",
+                              {isthreadsafe: '        Py_END_ALLOW_THREADS'},
+                              {hasexternals: '        }'},
+                              {debugcapi:
+                                  '        fprintf(stderr,"#routdebugshowvalue#\\n",#name#_return_value_len,#name#_return_value);'},
+                              '    } /* if (f2py_success) after (string)malloc */',
+                              ],
+        'returnformat': '#rformat#',
+        'return': ',#name#_return_value',
+        'freemem': '    STRINGFREE(#name#_return_value);',
+        'need': ['F_FUNC', '#ctype#', 'STRINGFREE'],
+        '_check':l_and(isstringfunction, l_not(isfunction_wrap))  # ???obsolete
+    },
+    {  # Debugging
+        'routdebugenter': '    fprintf(stderr,"debug-capi:Python C/API function #modulename#.#name#(#docsignature#)\\n");',
+        'routdebugleave': '    fprintf(stderr,"debug-capi:Python C/API function #modulename#.#name#: successful.\\n");',
+        'routdebugfailure': '    fprintf(stderr,"debug-capi:Python C/API function #modulename#.#name#: failure.\\n");',
+        '_check': debugcapi
+    }
+]
+
+################ Rules for arguments ##################
+
+typedef_need_dict = {islong_long: 'long_long',
+                     islong_double: 'long_double',
+                     islong_complex: 'complex_long_double',
+                     isunsigned_char: 'unsigned_char',
+                     isunsigned_short: 'unsigned_short',
+                     isunsigned: 'unsigned',
+                     isunsigned_long_long: 'unsigned_long_long',
+                     isunsigned_chararray: 'unsigned_char',
+                     isunsigned_shortarray: 'unsigned_short',
+                     isunsigned_long_longarray: 'unsigned_long_long',
+                     issigned_long_longarray: 'long_long',
+                     isint1: 'signed_char',
+                     ischaracter_or_characterarray: 'character',
+                     }
+
+aux_rules = [
+    {
+        'separatorsfor': sepdict
+    },
+    {  # Common
+        'frompyobj': ['    /* Processing auxiliary variable #varname# */',
+                      {debugcapi: '    fprintf(stderr,"#vardebuginfo#\\n");'}, ],
+        'cleanupfrompyobj': '    /* End of cleaning variable #varname# */',
+        'need': typedef_need_dict,
+    },
+    # Scalars (not complex)
+    {  # Common
+        'decl': '    #ctype# #varname# = 0;',
+        'need': {hasinitvalue: 'math.h'},
+        'frompyobj': {hasinitvalue: '    #varname# = #init#;'},
+        '_check': l_and(isscalar, l_not(iscomplex)),
+    },
+    {
+        'return': ',#varname#',
+        'docstrout': '#pydocsignout#',
+        'docreturn': '#outvarname#,',
+        'returnformat': '#varrformat#',
+        '_check': l_and(isscalar, l_not(iscomplex), isintent_out),
+    },
+    # Complex scalars
+    {  # Common
+        'decl': '    #ctype# #varname#;',
+        'frompyobj': {hasinitvalue: '    #varname#.r = #init.r#, #varname#.i = #init.i#;'},
+        '_check': iscomplex
+    },
+    # String
+    {  # Common
+        'decl': ['    #ctype# #varname# = NULL;',
+                 '    int slen(#varname#);',
+                 ],
+        'need':['len..'],
+        '_check':isstring
+    },
+    # Array
+    {  # Common
+        'decl': ['    #ctype# *#varname# = NULL;',
+                 '    npy_intp #varname#_Dims[#rank#] = {#rank*[-1]#};',
+                 '    const int #varname#_Rank = #rank#;',
+                 ],
+        'need':['len..', {hasinitvalue: 'forcomb'}, {hasinitvalue: 'CFUNCSMESS'}],
+        '_check': isarray
+    },
+    # Scalararray
+    {  # Common
+        '_check': l_and(isarray, l_not(iscomplexarray))
+    }, {  # Not hidden
+        '_check': l_and(isarray, l_not(iscomplexarray), isintent_nothide)
+    },
+    # Integer*1 array
+    {'need': '#ctype#',
+     '_check': isint1array,
+     '_depend': ''
+     },
+    # Integer*-1 array
+    {'need': '#ctype#',
+     '_check': l_or(isunsigned_chararray, isunsigned_char),
+     '_depend': ''
+     },
+    # Integer*-2 array
+    {'need': '#ctype#',
+     '_check': isunsigned_shortarray,
+     '_depend': ''
+     },
+    # Integer*-8 array
+    {'need': '#ctype#',
+     '_check': isunsigned_long_longarray,
+     '_depend': ''
+     },
+    # Complexarray
+    {'need': '#ctype#',
+     '_check': iscomplexarray,
+     '_depend': ''
+     },
+    # Stringarray
+    {
+        'callfortranappend': {isarrayofstrings: 'flen(#varname#),'},
+        'need': 'string',
+        '_check': isstringarray
+    }
+]
+
+arg_rules = [
+    {
+        'separatorsfor': sepdict
+    },
+    {  # Common
+        'frompyobj': ['    /* Processing variable #varname# */',
+                      {debugcapi: '    fprintf(stderr,"#vardebuginfo#\\n");'}, ],
+        'cleanupfrompyobj': '    /* End of cleaning variable #varname# */',
+        '_depend': '',
+        'need': typedef_need_dict,
+    },
+    # Doc signatures
+    {
+        'docstropt': {l_and(isoptional, isintent_nothide): '#pydocsign#'},
+        'docstrreq': {l_and(isrequired, isintent_nothide): '#pydocsign#'},
+        'docstrout': {isintent_out: '#pydocsignout#'},
+        'latexdocstropt': {l_and(isoptional, isintent_nothide): ['\\item[]{{}\\verb@#pydocsign#@{}}',
+                                                                 {hasnote: '--- #note#'}]},
+        'latexdocstrreq': {l_and(isrequired, isintent_nothide): ['\\item[]{{}\\verb@#pydocsign#@{}}',
+                                                                 {hasnote: '--- #note#'}]},
+        'latexdocstrout': {isintent_out: ['\\item[]{{}\\verb@#pydocsignout#@{}}',
+                                          {l_and(hasnote, isintent_hide): '--- #note#',
+                                           l_and(hasnote, isintent_nothide): '--- See above.'}]},
+        'depend': ''
+    },
+    # Required/Optional arguments
+    {
+        'kwlist': '"#varname#",',
+        'docsign': '#varname#,',
+        '_check': l_and(isintent_nothide, l_not(isoptional))
+    },
+    {
+        'kwlistopt': '"#varname#",',
+        'docsignopt': '#varname#=#showinit#,',
+        'docsignoptshort': '#varname#,',
+        '_check': l_and(isintent_nothide, isoptional)
+    },
+    # Docstring/BuildValue
+    {
+        'docreturn': '#outvarname#,',
+        'returnformat': '#varrformat#',
+        '_check': isintent_out
+    },
+    # Externals (call-back functions)
+    {  # Common
+        'docsignxa': {isintent_nothide: '#varname#_extra_args=(),'},
+        'docsignxashort': {isintent_nothide: '#varname#_extra_args,'},
+        'docstropt': {isintent_nothide: '#varname#_extra_args : input tuple, optional\\n    Default: ()'},
+        'docstrcbs': '#cbdocstr#',
+        'latexdocstrcbs': '\\item[] #cblatexdocstr#',
+        'latexdocstropt': {isintent_nothide: '\\item[]{{}\\verb@#varname#_extra_args := () input tuple@{}} --- Extra arguments for call-back function {{}\\verb@#varname#@{}}.'},
+        'decl': ['    #cbname#_t #varname#_cb = { Py_None, NULL, 0 };',
+                 '    #cbname#_t *#varname#_cb_ptr = &#varname#_cb;',
+                 '    PyTupleObject *#varname#_xa_capi = NULL;',
+                 {l_not(isintent_callback):
+                  '    #cbname#_typedef #varname#_cptr;'}
+                 ],
+        'kwlistxa': {isintent_nothide: '"#varname#_extra_args",'},
+        'argformat': {isrequired: 'O'},
+        'keyformat': {isoptional: 'O'},
+        'xaformat': {isintent_nothide: 'O!'},
+        'args_capi': {isrequired: ',&#varname#_cb.capi'},
+        'keys_capi': {isoptional: ',&#varname#_cb.capi'},
+        'keys_xa': ',&PyTuple_Type,&#varname#_xa_capi',
+        'setjmpbuf': '(setjmp(#varname#_cb.jmpbuf))',
+        'callfortran': {l_not(isintent_callback): '#varname#_cptr,'},
+        'need': ['#cbname#', 'setjmp.h'],
+        '_check':isexternal
+    },
+    {
+        'frompyobj': [{l_not(isintent_callback): """\
+if(F2PyCapsule_Check(#varname#_cb.capi)) {
+  #varname#_cptr = F2PyCapsule_AsVoidPtr(#varname#_cb.capi);
+} else {
+  #varname#_cptr = #cbname#;
+}
+"""}, {isintent_callback: """\
+if (#varname#_cb.capi==Py_None) {
+  #varname#_cb.capi = PyObject_GetAttrString(#modulename#_module,\"#varname#\");
+  if (#varname#_cb.capi) {
+    if (#varname#_xa_capi==NULL) {
+      if (PyObject_HasAttrString(#modulename#_module,\"#varname#_extra_args\")) {
+        PyObject* capi_tmp = PyObject_GetAttrString(#modulename#_module,\"#varname#_extra_args\");
+        if (capi_tmp) {
+          #varname#_xa_capi = (PyTupleObject *)PySequence_Tuple(capi_tmp);
+          Py_DECREF(capi_tmp);
+        }
+        else {
+          #varname#_xa_capi = (PyTupleObject *)Py_BuildValue(\"()\");
+        }
+        if (#varname#_xa_capi==NULL) {
+          PyErr_SetString(#modulename#_error,\"Failed to convert #modulename#.#varname#_extra_args to tuple.\\n\");
+          return NULL;
+        }
+      }
+    }
+  }
+  if (#varname#_cb.capi==NULL) {
+    PyErr_SetString(#modulename#_error,\"Callback #varname# not defined (as an argument or module #modulename# attribute).\\n\");
+    return NULL;
+  }
+}
+"""},
+            """\
+    if (create_cb_arglist(#varname#_cb.capi,#varname#_xa_capi,#maxnofargs#,#nofoptargs#,&#varname#_cb.nofargs,&#varname#_cb.args_capi,\"failed in processing argument list for call-back #varname#.\")) {
+""",
+            {debugcapi: ["""\
+        fprintf(stderr,\"debug-capi:Assuming %d arguments; at most #maxnofargs#(-#nofoptargs#) is expected.\\n\",#varname#_cb.nofargs);
+        CFUNCSMESSPY(\"for #varname#=\",#varname#_cb.capi);""",
+                         {l_not(isintent_callback): """        fprintf(stderr,\"#vardebugshowvalue# (call-back in C).\\n\",#cbname#);"""}]},
+            """\
+        CFUNCSMESS(\"Saving callback variables for `#varname#`.\\n\");
+        #varname#_cb_ptr = swap_active_#cbname#(#varname#_cb_ptr);""",
+        ],
+        'cleanupfrompyobj':
+        """\
+        CFUNCSMESS(\"Restoring callback variables for `#varname#`.\\n\");
+        #varname#_cb_ptr = swap_active_#cbname#(#varname#_cb_ptr);
+        Py_DECREF(#varname#_cb.args_capi);
+    }""",
+        'need': ['SWAP', 'create_cb_arglist'],
+        '_check':isexternal,
+        '_depend':''
+    },
+    # Scalars (not complex)
+    {  # Common
+        'decl': '    #ctype# #varname# = 0;',
+        'pyobjfrom': {debugcapi: '    fprintf(stderr,"#vardebugshowvalue#\\n",#varname#);'},
+        'callfortran': {l_or(isintent_c, isattr_value): '#varname#,', l_not(l_or(isintent_c, isattr_value)): '&#varname#,'},
+        'return': {isintent_out: ',#varname#'},
+        '_check': l_and(isscalar, l_not(iscomplex))
+    }, {
+        'need': {hasinitvalue: 'math.h'},
+        '_check': l_and(isscalar, l_not(iscomplex)),
+    }, {  # Not hidden
+        'decl': '    PyObject *#varname#_capi = Py_None;',
+        'argformat': {isrequired: 'O'},
+        'keyformat': {isoptional: 'O'},
+        'args_capi': {isrequired: ',&#varname#_capi'},
+        'keys_capi': {isoptional: ',&#varname#_capi'},
+        'pyobjfrom': {isintent_inout: """\
+    f2py_success = try_pyarr_from_#ctype#(#varname#_capi,&#varname#);
+    if (f2py_success) {"""},
+        'closepyobjfrom': {isintent_inout: "    } /*if (f2py_success) of #varname# pyobjfrom*/"},
+        'need': {isintent_inout: 'try_pyarr_from_#ctype#'},
+        '_check': l_and(isscalar, l_not(iscomplex), l_not(isstring),
+                        isintent_nothide)
+    }, {
+        'frompyobj': [
+            # hasinitvalue...
+            #   if pyobj is None:
+            #     varname = init
+            #   else
+            #     from_pyobj(varname)
+            #
+            # isoptional and noinitvalue...
+            #   if pyobj is not None:
+            #     from_pyobj(varname)
+            #   else:
+            #     varname is uninitialized
+            #
+            # ...
+            #   from_pyobj(varname)
+            #
+            {hasinitvalue: '    if (#varname#_capi == Py_None) #varname# = #init#; else',
+             '_depend': ''},
+            {l_and(isoptional, l_not(hasinitvalue)): '    if (#varname#_capi != Py_None)',
+             '_depend': ''},
+            {l_not(islogical): '''\
+        f2py_success = #ctype#_from_pyobj(&#varname#,#varname#_capi,"#pyname#() #nth# (#varname#) can\'t be converted to #ctype#");
+    if (f2py_success) {'''},
+            {islogical: '''\
+        #varname# = (#ctype#)PyObject_IsTrue(#varname#_capi);
+        f2py_success = 1;
+    if (f2py_success) {'''},
+        ],
+        'cleanupfrompyobj': '    } /*if (f2py_success) of #varname#*/',
+        'need': {l_not(islogical): '#ctype#_from_pyobj'},
+        '_check': l_and(isscalar, l_not(iscomplex), isintent_nothide),
+        '_depend': ''
+    }, {  # Hidden
+        'frompyobj': {hasinitvalue: '    #varname# = #init#;'},
+        'need': typedef_need_dict,
+        '_check': l_and(isscalar, l_not(iscomplex), isintent_hide),
+        '_depend': ''
+    }, {  # Common
+        'frompyobj': {debugcapi: '    fprintf(stderr,"#vardebugshowvalue#\\n",#varname#);'},
+        '_check': l_and(isscalar, l_not(iscomplex)),
+        '_depend': ''
+    },
+    # Complex scalars
+    {  # Common
+        'decl': '    #ctype# #varname#;',
+        'callfortran': {isintent_c: '#varname#,', l_not(isintent_c): '&#varname#,'},
+        'pyobjfrom': {debugcapi: '    fprintf(stderr,"#vardebugshowvalue#\\n",#varname#.r,#varname#.i);'},
+        'return': {isintent_out: ',#varname#_capi'},
+        '_check': iscomplex
+    }, {  # Not hidden
+        'decl': '    PyObject *#varname#_capi = Py_None;',
+        'argformat': {isrequired: 'O'},
+        'keyformat': {isoptional: 'O'},
+        'args_capi': {isrequired: ',&#varname#_capi'},
+        'keys_capi': {isoptional: ',&#varname#_capi'},
+        'need': {isintent_inout: 'try_pyarr_from_#ctype#'},
+        'pyobjfrom': {isintent_inout: """\
+        f2py_success = try_pyarr_from_#ctype#(#varname#_capi,&#varname#);
+        if (f2py_success) {"""},
+        'closepyobjfrom': {isintent_inout: "        } /*if (f2py_success) of #varname# pyobjfrom*/"},
+        '_check': l_and(iscomplex, isintent_nothide)
+    }, {
+        'frompyobj': [{hasinitvalue: '    if (#varname#_capi==Py_None) {#varname#.r = #init.r#, #varname#.i = #init.i#;} else'},
+                      {l_and(isoptional, l_not(hasinitvalue))
+                             : '    if (#varname#_capi != Py_None)'},
+                      '        f2py_success = #ctype#_from_pyobj(&#varname#,#varname#_capi,"#pyname#() #nth# (#varname#) can\'t be converted to #ctype#");'
+                      '\n    if (f2py_success) {'],
+        'cleanupfrompyobj': '    }  /*if (f2py_success) of #varname# frompyobj*/',
+        'need': ['#ctype#_from_pyobj'],
+        '_check': l_and(iscomplex, isintent_nothide),
+        '_depend': ''
+    }, {  # Hidden
+        'decl': {isintent_out: '    PyObject *#varname#_capi = Py_None;'},
+        '_check': l_and(iscomplex, isintent_hide)
+    }, {
+        'frompyobj': {hasinitvalue: '    #varname#.r = #init.r#, #varname#.i = #init.i#;'},
+        '_check': l_and(iscomplex, isintent_hide),
+        '_depend': ''
+    }, {  # Common
+        'pyobjfrom': {isintent_out: '    #varname#_capi = pyobj_from_#ctype#1(#varname#);'},
+        'need': ['pyobj_from_#ctype#1'],
+        '_check': iscomplex
+    }, {
+        'frompyobj': {debugcapi: '    fprintf(stderr,"#vardebugshowvalue#\\n",#varname#.r,#varname#.i);'},
+        '_check': iscomplex,
+        '_depend': ''
+    },
+    # String
+    {  # Common
+        'decl': ['    #ctype# #varname# = NULL;',
+                 '    int slen(#varname#);',
+                 '    PyObject *#varname#_capi = Py_None;'],
+        'callfortran':'#varname#,',
+        'callfortranappend':'slen(#varname#),',
+        'pyobjfrom':[
+            {debugcapi:
+             '    fprintf(stderr,'
+             '"#vardebugshowvalue#\\n",slen(#varname#),#varname#);'},
+            # The trailing null value for Fortran is blank.
+            {l_and(isintent_out, l_not(isintent_c)):
+             "        STRINGPADN(#varname#, slen(#varname#), ' ', '\\0');"},
+        ],
+        'return': {isintent_out: ',#varname#'},
+        'need': ['len..',
+                 {l_and(isintent_out, l_not(isintent_c)): 'STRINGPADN'}],
+        '_check': isstring
+    }, {  # Common
+        'frompyobj': [
+            """\
+    slen(#varname#) = #elsize#;
+    f2py_success = #ctype#_from_pyobj(&#varname#,&slen(#varname#),#init#,"""
+"""#varname#_capi,\"#ctype#_from_pyobj failed in converting #nth#"""
+"""`#varname#\' of #pyname# to C #ctype#\");
+    if (f2py_success) {""",
+            # The trailing null value for Fortran is blank.
+            {l_not(isintent_c):
+             "        STRINGPADN(#varname#, slen(#varname#), '\\0', ' ');"},
+        ],
+        'cleanupfrompyobj': """\
+        STRINGFREE(#varname#);
+    }  /*if (f2py_success) of #varname#*/""",
+        'need': ['#ctype#_from_pyobj', 'len..', 'STRINGFREE',
+                 {l_not(isintent_c): 'STRINGPADN'}],
+        '_check':isstring,
+        '_depend':''
+    }, {  # Not hidden
+        'argformat': {isrequired: 'O'},
+        'keyformat': {isoptional: 'O'},
+        'args_capi': {isrequired: ',&#varname#_capi'},
+        'keys_capi': {isoptional: ',&#varname#_capi'},
+        'pyobjfrom': [
+            {l_and(isintent_inout, l_not(isintent_c)):
+             "        STRINGPADN(#varname#, slen(#varname#), ' ', '\\0');"},
+            {isintent_inout: '''\
+    f2py_success = try_pyarr_from_#ctype#(#varname#_capi, #varname#,
+                                          slen(#varname#));
+    if (f2py_success) {'''}],
+        'closepyobjfrom': {isintent_inout: '    } /*if (f2py_success) of #varname# pyobjfrom*/'},
+        'need': {isintent_inout: 'try_pyarr_from_#ctype#',
+                 l_and(isintent_inout, l_not(isintent_c)): 'STRINGPADN'},
+        '_check': l_and(isstring, isintent_nothide)
+    }, {  # Hidden
+        '_check': l_and(isstring, isintent_hide)
+    }, {
+        'frompyobj': {debugcapi: '    fprintf(stderr,"#vardebugshowvalue#\\n",slen(#varname#),#varname#);'},
+        '_check': isstring,
+        '_depend': ''
+    },
+    # Array
+    {  # Common
+        'decl': ['    #ctype# *#varname# = NULL;',
+                 '    npy_intp #varname#_Dims[#rank#] = {#rank*[-1]#};',
+                 '    const int #varname#_Rank = #rank#;',
+                 '    PyArrayObject *capi_#varname#_as_array = NULL;',
+                 '    int capi_#varname#_intent = 0;',
+                 {isstringarray: '    int slen(#varname#) = 0;'},
+                 ],
+        'callfortran':'#varname#,',
+        'callfortranappend': {isstringarray: 'slen(#varname#),'},
+        'return': {isintent_out: ',capi_#varname#_as_array'},
+        'need': 'len..',
+        '_check': isarray
+    }, {  # intent(overwrite) array
+        'decl': '    int capi_overwrite_#varname# = 1;',
+        'kwlistxa': '"overwrite_#varname#",',
+        'xaformat': 'i',
+        'keys_xa': ',&capi_overwrite_#varname#',
+        'docsignxa': 'overwrite_#varname#=1,',
+        'docsignxashort': 'overwrite_#varname#,',
+        'docstropt': 'overwrite_#varname# : input int, optional\\n    Default: 1',
+        '_check': l_and(isarray, isintent_overwrite),
+    }, {
+        'frompyobj': '    capi_#varname#_intent |= (capi_overwrite_#varname#?0:F2PY_INTENT_COPY);',
+        '_check': l_and(isarray, isintent_overwrite),
+        '_depend': '',
+    },
+    {  # intent(copy) array
+        'decl': '    int capi_overwrite_#varname# = 0;',
+        'kwlistxa': '"overwrite_#varname#",',
+        'xaformat': 'i',
+        'keys_xa': ',&capi_overwrite_#varname#',
+        'docsignxa': 'overwrite_#varname#=0,',
+        'docsignxashort': 'overwrite_#varname#,',
+        'docstropt': 'overwrite_#varname# : input int, optional\\n    Default: 0',
+        '_check': l_and(isarray, isintent_copy),
+    }, {
+        'frompyobj': '    capi_#varname#_intent |= (capi_overwrite_#varname#?0:F2PY_INTENT_COPY);',
+        '_check': l_and(isarray, isintent_copy),
+        '_depend': '',
+    }, {
+        'need': [{hasinitvalue: 'forcomb'}, {hasinitvalue: 'CFUNCSMESS'}],
+        '_check': isarray,
+        '_depend': ''
+    }, {  # Not hidden
+        'decl': '    PyObject *#varname#_capi = Py_None;',
+        'argformat': {isrequired: 'O'},
+        'keyformat': {isoptional: 'O'},
+        'args_capi': {isrequired: ',&#varname#_capi'},
+        'keys_capi': {isoptional: ',&#varname#_capi'},
+        '_check': l_and(isarray, isintent_nothide)
+    }, {
+        'frompyobj': [
+            '    #setdims#;',
+            '    capi_#varname#_intent |= #intent#;',
+            ('    const char * capi_errmess = "#modulename#.#pyname#:'
+             ' failed to create array from the #nth# `#varname#`";'),
+            {isintent_hide:
+             '    capi_#varname#_as_array = ndarray_from_pyobj('
+             '  #atype#,#elsize#,#varname#_Dims,#varname#_Rank,'
+             '  capi_#varname#_intent,Py_None,capi_errmess);'},
+            {isintent_nothide:
+             '    capi_#varname#_as_array = ndarray_from_pyobj('
+             '  #atype#,#elsize#,#varname#_Dims,#varname#_Rank,'
+             '  capi_#varname#_intent,#varname#_capi,capi_errmess);'},
+            """\
+    if (capi_#varname#_as_array == NULL) {
+        PyObject* capi_err = PyErr_Occurred();
+        if (capi_err == NULL) {
+            capi_err = #modulename#_error;
+            PyErr_SetString(capi_err, capi_errmess);
+        }
+    } else {
+        #varname# = (#ctype# *)(PyArray_DATA(capi_#varname#_as_array));
+""",
+            {isstringarray:
+             '    slen(#varname#) = f2py_itemsize(#varname#);'},
+            {hasinitvalue: [
+                {isintent_nothide:
+                 '    if (#varname#_capi == Py_None) {'},
+                {isintent_hide: '    {'},
+                {iscomplexarray: '        #ctype# capi_c;'},
+                """\
+        int *_i,capi_i=0;
+        CFUNCSMESS(\"#name#: Initializing #varname#=#init#\\n\");
+        if (initforcomb(PyArray_DIMS(capi_#varname#_as_array),
+                        PyArray_NDIM(capi_#varname#_as_array),1)) {
+            while ((_i = nextforcomb()))
+                #varname#[capi_i++] = #init#; /* fortran way */
+        } else {
+            PyObject *exc, *val, *tb;
+            PyErr_Fetch(&exc, &val, &tb);
+            PyErr_SetString(exc ? exc : #modulename#_error,
+                \"Initialization of #nth# #varname# failed (initforcomb).\");
+            npy_PyErr_ChainExceptionsCause(exc, val, tb);
+            f2py_success = 0;
+        }
+    }
+    if (f2py_success) {"""]},
+                      ],
+        'cleanupfrompyobj': [  # note that this list will be reversed
+            '    }  '
+            '/* if (capi_#varname#_as_array == NULL) ... else of #varname# */',
+            {l_not(l_or(isintent_out, isintent_hide)): """\
+    if((PyObject *)capi_#varname#_as_array!=#varname#_capi) {
+        Py_XDECREF(capi_#varname#_as_array); }"""},
+            {l_and(isintent_hide, l_not(isintent_out))
+                   : """        Py_XDECREF(capi_#varname#_as_array);"""},
+            {hasinitvalue: '    }  /*if (f2py_success) of #varname# init*/'},
+        ],
+        '_check': isarray,
+        '_depend': ''
+    },
+    # Scalararray
+    {  # Common
+        '_check': l_and(isarray, l_not(iscomplexarray))
+    }, {  # Not hidden
+        '_check': l_and(isarray, l_not(iscomplexarray), isintent_nothide)
+    },
+    # Integer*1 array
+    {'need': '#ctype#',
+     '_check': isint1array,
+     '_depend': ''
+     },
+    # Integer*-1 array
+    {'need': '#ctype#',
+     '_check': isunsigned_chararray,
+     '_depend': ''
+     },
+    # Integer*-2 array
+    {'need': '#ctype#',
+     '_check': isunsigned_shortarray,
+     '_depend': ''
+     },
+    # Integer*-8 array
+    {'need': '#ctype#',
+     '_check': isunsigned_long_longarray,
+     '_depend': ''
+     },
+    # Complexarray
+    {'need': '#ctype#',
+     '_check': iscomplexarray,
+     '_depend': ''
+     },
+    # Character
+    {
+        'need': 'string',
+        '_check': ischaracter,
+    },
+    # Character array
+    {
+        'need': 'string',
+        '_check': ischaracterarray,
+    },
+    # Stringarray
+    {
+        'callfortranappend': {isarrayofstrings: 'flen(#varname#),'},
+        'need': 'string',
+        '_check': isstringarray
+    }
+]
+
+################# Rules for checking ###############
+
+check_rules = [
+    {
+        'frompyobj': {debugcapi: '    fprintf(stderr,\"debug-capi:Checking `#check#\'\\n\");'},
+        'need': 'len..'
+    }, {
+        'frompyobj': '    CHECKSCALAR(#check#,\"#check#\",\"#nth# #varname#\",\"#varshowvalue#\",#varname#) {',
+        'cleanupfrompyobj': '    } /*CHECKSCALAR(#check#)*/',
+        'need': 'CHECKSCALAR',
+        '_check': l_and(isscalar, l_not(iscomplex)),
+        '_break': ''
+    }, {
+        'frompyobj': '    CHECKSTRING(#check#,\"#check#\",\"#nth# #varname#\",\"#varshowvalue#\",#varname#) {',
+        'cleanupfrompyobj': '    } /*CHECKSTRING(#check#)*/',
+        'need': 'CHECKSTRING',
+        '_check': isstring,
+        '_break': ''
+    }, {
+        'need': 'CHECKARRAY',
+        'frompyobj': '    CHECKARRAY(#check#,\"#check#\",\"#nth# #varname#\") {',
+        'cleanupfrompyobj': '    } /*CHECKARRAY(#check#)*/',
+        '_check': isarray,
+        '_break': ''
+    }, {
+        'need': 'CHECKGENERIC',
+        'frompyobj': '    CHECKGENERIC(#check#,\"#check#\",\"#nth# #varname#\") {',
+        'cleanupfrompyobj': '    } /*CHECKGENERIC(#check#)*/',
+    }
+]
+
+########## Applying the rules. No need to modify what follows #############
+
+#################### Build C/API module #######################
+
+
+def buildmodule(m, um):
+    """
+    Return
+    """
+    outmess('    Building module "%s"...\n' % (m['name']))
+    ret = {}
+    mod_rules = defmod_rules[:]
+    vrd = capi_maps.modsign2map(m)
+    rd = dictappend({'f2py_version': f2py_version}, vrd)
+    funcwrappers = []
+    funcwrappers2 = []  # F90 codes
+    for n in m['interfaced']:
+        nb = None
+        for bi in m['body']:
+            if bi['block'] not in ['interface', 'abstract interface']:
+                errmess('buildmodule: Expected interface block. Skipping.\n')
+                continue
+            for b in bi['body']:
+                if b['name'] == n:
+                    nb = b
+                    break
+
+        if not nb:
+            print(
+                'buildmodule: Could not find the body of interfaced routine "%s". Skipping.\n' % (n), file=sys.stderr)
+            continue
+        nb_list = [nb]
+        if 'entry' in nb:
+            for k, a in nb['entry'].items():
+                nb1 = copy.deepcopy(nb)
+                del nb1['entry']
+                nb1['name'] = k
+                nb1['args'] = a
+                nb_list.append(nb1)
+        for nb in nb_list:
+            # requiresf90wrapper must be called before buildapi as it
+            # rewrites assumed shape arrays as automatic arrays.
+            isf90 = requiresf90wrapper(nb)
+            # options is in scope here
+            if options['emptygen']:
+                b_path = options['buildpath']
+                m_name = vrd['modulename']
+                outmess('    Generating possibly empty wrappers"\n')
+                Path(f"{b_path}/{vrd['coutput']}").touch()
+                if isf90:
+                    # f77 + f90 wrappers
+                    outmess(f'    Maybe empty "{m_name}-f2pywrappers2.f90"\n')
+                    Path(f'{b_path}/{m_name}-f2pywrappers2.f90').touch()
+                    outmess(f'    Maybe empty "{m_name}-f2pywrappers.f"\n')
+                    Path(f'{b_path}/{m_name}-f2pywrappers.f').touch()
+                else:
+                    # only f77 wrappers
+                    outmess(f'    Maybe empty "{m_name}-f2pywrappers.f"\n')
+                    Path(f'{b_path}/{m_name}-f2pywrappers.f').touch()
+            api, wrap = buildapi(nb)
+            if wrap:
+                if isf90:
+                    funcwrappers2.append(wrap)
+                else:
+                    funcwrappers.append(wrap)
+            ar = applyrules(api, vrd)
+            rd = dictappend(rd, ar)
+
+    # Construct COMMON block support
+    cr, wrap = common_rules.buildhooks(m)
+    if wrap:
+        funcwrappers.append(wrap)
+    ar = applyrules(cr, vrd)
+    rd = dictappend(rd, ar)
+
+    # Construct F90 module support
+    mr, wrap = f90mod_rules.buildhooks(m)
+    if wrap:
+        funcwrappers2.append(wrap)
+    ar = applyrules(mr, vrd)
+    rd = dictappend(rd, ar)
+
+    for u in um:
+        ar = use_rules.buildusevars(u, m['use'][u['name']])
+        rd = dictappend(rd, ar)
+
+    needs = cfuncs.get_needs()
+    # Add mapped definitions
+    needs['typedefs'] += [cvar for cvar in capi_maps.f2cmap_mapped #
+                          if cvar in typedef_need_dict.values()]
+    code = {}
+    for n in needs.keys():
+        code[n] = []
+        for k in needs[n]:
+            c = ''
+            if k in cfuncs.includes0:
+                c = cfuncs.includes0[k]
+            elif k in cfuncs.includes:
+                c = cfuncs.includes[k]
+            elif k in cfuncs.userincludes:
+                c = cfuncs.userincludes[k]
+            elif k in cfuncs.typedefs:
+                c = cfuncs.typedefs[k]
+            elif k in cfuncs.typedefs_generated:
+                c = cfuncs.typedefs_generated[k]
+            elif k in cfuncs.cppmacros:
+                c = cfuncs.cppmacros[k]
+            elif k in cfuncs.cfuncs:
+                c = cfuncs.cfuncs[k]
+            elif k in cfuncs.callbacks:
+                c = cfuncs.callbacks[k]
+            elif k in cfuncs.f90modhooks:
+                c = cfuncs.f90modhooks[k]
+            elif k in cfuncs.commonhooks:
+                c = cfuncs.commonhooks[k]
+            else:
+                errmess('buildmodule: unknown need %s.\n' % (repr(k)))
+                continue
+            code[n].append(c)
+    mod_rules.append(code)
+    for r in mod_rules:
+        if ('_check' in r and r['_check'](m)) or ('_check' not in r):
+            ar = applyrules(r, vrd, m)
+            rd = dictappend(rd, ar)
+    ar = applyrules(module_rules, rd)
+
+    fn = os.path.join(options['buildpath'], vrd['coutput'])
+    ret['csrc'] = fn
+    with open(fn, 'w') as f:
+        f.write(ar['modulebody'].replace('\t', 2 * ' '))
+    outmess('    Wrote C/API module "%s" to file "%s"\n' % (m['name'], fn))
+
+    if options['dorestdoc']:
+        fn = os.path.join(
+            options['buildpath'], vrd['modulename'] + 'module.rest')
+        with open(fn, 'w') as f:
+            f.write('.. -*- rest -*-\n')
+            f.write('\n'.join(ar['restdoc']))
+        outmess('    ReST Documentation is saved to file "%s/%smodule.rest"\n' %
+                (options['buildpath'], vrd['modulename']))
+    if options['dolatexdoc']:
+        fn = os.path.join(
+            options['buildpath'], vrd['modulename'] + 'module.tex')
+        ret['ltx'] = fn
+        with open(fn, 'w') as f:
+            f.write(
+                '%% This file is auto-generated with f2py (version:%s)\n' % (f2py_version))
+            if 'shortlatex' not in options:
+                f.write(
+                    '\\documentclass{article}\n\\usepackage{a4wide}\n\\begin{document}\n\\tableofcontents\n\n')
+                f.write('\n'.join(ar['latexdoc']))
+            if 'shortlatex' not in options:
+                f.write('\\end{document}')
+        outmess('    Documentation is saved to file "%s/%smodule.tex"\n' %
+                (options['buildpath'], vrd['modulename']))
+    if funcwrappers:
+        wn = os.path.join(options['buildpath'], vrd['f2py_wrapper_output'])
+        ret['fsrc'] = wn
+        with open(wn, 'w') as f:
+            f.write('C     -*- fortran -*-\n')
+            f.write(
+                'C     This file is autogenerated with f2py (version:%s)\n' % (f2py_version))
+            f.write(
+                'C     It contains Fortran 77 wrappers to fortran functions.\n')
+            lines = []
+            for l in ('\n\n'.join(funcwrappers) + '\n').split('\n'):
+                if 0 <= l.find('!') < 66:
+                    # don't split comment lines
+                    lines.append(l + '\n')
+                elif l and l[0] == ' ':
+                    while len(l) >= 66:
+                        lines.append(l[:66] + '\n     &')
+                        l = l[66:]
+                    lines.append(l + '\n')
+                else:
+                    lines.append(l + '\n')
+            lines = ''.join(lines).replace('\n     &\n', '\n')
+            f.write(lines)
+        outmess('    Fortran 77 wrappers are saved to "%s"\n' % (wn))
+    if funcwrappers2:
+        wn = os.path.join(
+            options['buildpath'], '%s-f2pywrappers2.f90' % (vrd['modulename']))
+        ret['fsrc'] = wn
+        with open(wn, 'w') as f:
+            f.write('!     -*- f90 -*-\n')
+            f.write(
+                '!     This file is autogenerated with f2py (version:%s)\n' % (f2py_version))
+            f.write(
+                '!     It contains Fortran 90 wrappers to fortran functions.\n')
+            lines = []
+            for l in ('\n\n'.join(funcwrappers2) + '\n').split('\n'):
+                if 0 <= l.find('!') < 72:
+                    # don't split comment lines
+                    lines.append(l + '\n')
+                elif len(l) > 72 and l[0] == ' ':
+                    lines.append(l[:72] + '&\n     &')
+                    l = l[72:]
+                    while len(l) > 66:
+                        lines.append(l[:66] + '&\n     &')
+                        l = l[66:]
+                    lines.append(l + '\n')
+                else:
+                    lines.append(l + '\n')
+            lines = ''.join(lines).replace('\n     &\n', '\n')
+            f.write(lines)
+        outmess('    Fortran 90 wrappers are saved to "%s"\n' % (wn))
+    return ret
+
+################## Build C/API function #############
+
+stnd = {1: 'st', 2: 'nd', 3: 'rd', 4: 'th', 5: 'th',
+        6: 'th', 7: 'th', 8: 'th', 9: 'th', 0: 'th'}
+
+
+def buildapi(rout):
+    rout, wrap = func2subr.assubr(rout)
+    args, depargs = getargs2(rout)
+    capi_maps.depargs = depargs
+    var = rout['vars']
+
+    if ismoduleroutine(rout):
+        outmess('            Constructing wrapper function "%s.%s"...\n' %
+                (rout['modulename'], rout['name']))
+    else:
+        outmess('        Constructing wrapper function "%s"...\n' % (rout['name']))
+    # Routine
+    vrd = capi_maps.routsign2map(rout)
+    rd = dictappend({}, vrd)
+    for r in rout_rules:
+        if ('_check' in r and r['_check'](rout)) or ('_check' not in r):
+            ar = applyrules(r, vrd, rout)
+            rd = dictappend(rd, ar)
+
+    # Args
+    nth, nthk = 0, 0
+    savevrd = {}
+    for a in args:
+        vrd = capi_maps.sign2map(a, var[a])
+        if isintent_aux(var[a]):
+            _rules = aux_rules
+        else:
+            _rules = arg_rules
+            if not isintent_hide(var[a]):
+                if not isoptional(var[a]):
+                    nth = nth + 1
+                    vrd['nth'] = repr(nth) + stnd[nth % 10] + ' argument'
+                else:
+                    nthk = nthk + 1
+                    vrd['nth'] = repr(nthk) + stnd[nthk % 10] + ' keyword'
+            else:
+                vrd['nth'] = 'hidden'
+        savevrd[a] = vrd
+        for r in _rules:
+            if '_depend' in r:
+                continue
+            if ('_check' in r and r['_check'](var[a])) or ('_check' not in r):
+                ar = applyrules(r, vrd, var[a])
+                rd = dictappend(rd, ar)
+                if '_break' in r:
+                    break
+    for a in depargs:
+        if isintent_aux(var[a]):
+            _rules = aux_rules
+        else:
+            _rules = arg_rules
+        vrd = savevrd[a]
+        for r in _rules:
+            if '_depend' not in r:
+                continue
+            if ('_check' in r and r['_check'](var[a])) or ('_check' not in r):
+                ar = applyrules(r, vrd, var[a])
+                rd = dictappend(rd, ar)
+                if '_break' in r:
+                    break
+        if 'check' in var[a]:
+            for c in var[a]['check']:
+                vrd['check'] = c
+                ar = applyrules(check_rules, vrd, var[a])
+                rd = dictappend(rd, ar)
+    if isinstance(rd['cleanupfrompyobj'], list):
+        rd['cleanupfrompyobj'].reverse()
+    if isinstance(rd['closepyobjfrom'], list):
+        rd['closepyobjfrom'].reverse()
+    rd['docsignature'] = stripcomma(replace('#docsign##docsignopt##docsignxa#',
+                                            {'docsign': rd['docsign'],
+                                             'docsignopt': rd['docsignopt'],
+                                             'docsignxa': rd['docsignxa']}))
+    optargs = stripcomma(replace('#docsignopt##docsignxa#',
+                                 {'docsignxa': rd['docsignxashort'],
+                                  'docsignopt': rd['docsignoptshort']}
+                                 ))
+    if optargs == '':
+        rd['docsignatureshort'] = stripcomma(
+            replace('#docsign#', {'docsign': rd['docsign']}))
+    else:
+        rd['docsignatureshort'] = replace('#docsign#[#docsignopt#]',
+                                          {'docsign': rd['docsign'],
+                                           'docsignopt': optargs,
+                                           })
+    rd['latexdocsignatureshort'] = rd['docsignatureshort'].replace('_', '\\_')
+    rd['latexdocsignatureshort'] = rd[
+        'latexdocsignatureshort'].replace(',', ', ')
+    cfs = stripcomma(replace('#callfortran##callfortranappend#', {
+                     'callfortran': rd['callfortran'], 'callfortranappend': rd['callfortranappend']}))
+    if len(rd['callfortranappend']) > 1:
+        rd['callcompaqfortran'] = stripcomma(replace('#callfortran# 0,#callfortranappend#', {
+                                             'callfortran': rd['callfortran'], 'callfortranappend': rd['callfortranappend']}))
+    else:
+        rd['callcompaqfortran'] = cfs
+    rd['callfortran'] = cfs
+    if isinstance(rd['docreturn'], list):
+        rd['docreturn'] = stripcomma(
+            replace('#docreturn#', {'docreturn': rd['docreturn']})) + ' = '
+    rd['docstrsigns'] = []
+    rd['latexdocstrsigns'] = []
+    for k in ['docstrreq', 'docstropt', 'docstrout', 'docstrcbs']:
+        if k in rd and isinstance(rd[k], list):
+            rd['docstrsigns'] = rd['docstrsigns'] + rd[k]
+        k = 'latex' + k
+        if k in rd and isinstance(rd[k], list):
+            rd['latexdocstrsigns'] = rd['latexdocstrsigns'] + rd[k][0:1] +\
+                ['\\begin{description}'] + rd[k][1:] +\
+                ['\\end{description}']
+
+    ar = applyrules(routine_rules, rd)
+    if ismoduleroutine(rout):
+        outmess('              %s\n' % (ar['docshort']))
+    else:
+        outmess('          %s\n' % (ar['docshort']))
+    return ar, wrap
+
+
+#################### EOF rules.py #######################
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/setup.cfg b/venv/lib/python3.12/site-packages/numpy/f2py/setup.cfg
new file mode 100644
index 00000000..14669544
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/setup.cfg
@@ -0,0 +1,3 @@
+[bdist_rpm]
+doc_files = docs/
+            tests/
\ No newline at end of file
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/src/fortranobject.c b/venv/lib/python3.12/site-packages/numpy/f2py/src/fortranobject.c
new file mode 100644
index 00000000..35941472
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/src/fortranobject.c
@@ -0,0 +1,1423 @@
+#define FORTRANOBJECT_C
+#include "fortranobject.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include 
+#include 
+#include 
+
+/*
+  This file implements: FortranObject, array_from_pyobj, copy_ND_array
+
+  Author: Pearu Peterson 
+  $Revision: 1.52 $
+  $Date: 2005/07/11 07:44:20 $
+*/
+
+int
+F2PyDict_SetItemString(PyObject *dict, char *name, PyObject *obj)
+{
+    if (obj == NULL) {
+        fprintf(stderr, "Error loading %s\n", name);
+        if (PyErr_Occurred()) {
+            PyErr_Print();
+            PyErr_Clear();
+        }
+        return -1;
+    }
+    return PyDict_SetItemString(dict, name, obj);
+}
+
+/*
+ * Python-only fallback for thread-local callback pointers
+ */
+void *
+F2PySwapThreadLocalCallbackPtr(char *key, void *ptr)
+{
+    PyObject *local_dict, *value;
+    void *prev;
+
+    local_dict = PyThreadState_GetDict();
+    if (local_dict == NULL) {
+        Py_FatalError(
+                "F2PySwapThreadLocalCallbackPtr: PyThreadState_GetDict "
+                "failed");
+    }
+
+    value = PyDict_GetItemString(local_dict, key);
+    if (value != NULL) {
+        prev = PyLong_AsVoidPtr(value);
+        if (PyErr_Occurred()) {
+            Py_FatalError(
+                    "F2PySwapThreadLocalCallbackPtr: PyLong_AsVoidPtr failed");
+        }
+    }
+    else {
+        prev = NULL;
+    }
+
+    value = PyLong_FromVoidPtr((void *)ptr);
+    if (value == NULL) {
+        Py_FatalError(
+                "F2PySwapThreadLocalCallbackPtr: PyLong_FromVoidPtr failed");
+    }
+
+    if (PyDict_SetItemString(local_dict, key, value) != 0) {
+        Py_FatalError(
+                "F2PySwapThreadLocalCallbackPtr: PyDict_SetItemString failed");
+    }
+
+    Py_DECREF(value);
+
+    return prev;
+}
+
+void *
+F2PyGetThreadLocalCallbackPtr(char *key)
+{
+    PyObject *local_dict, *value;
+    void *prev;
+
+    local_dict = PyThreadState_GetDict();
+    if (local_dict == NULL) {
+        Py_FatalError(
+                "F2PyGetThreadLocalCallbackPtr: PyThreadState_GetDict failed");
+    }
+
+    value = PyDict_GetItemString(local_dict, key);
+    if (value != NULL) {
+        prev = PyLong_AsVoidPtr(value);
+        if (PyErr_Occurred()) {
+            Py_FatalError(
+                    "F2PyGetThreadLocalCallbackPtr: PyLong_AsVoidPtr failed");
+        }
+    }
+    else {
+        prev = NULL;
+    }
+
+    return prev;
+}
+
+static PyArray_Descr *
+get_descr_from_type_and_elsize(const int type_num, const int elsize)  {
+  PyArray_Descr * descr = PyArray_DescrFromType(type_num);
+  if (type_num == NPY_STRING) {
+    // PyArray_DescrFromType returns descr with elsize = 0.
+    PyArray_DESCR_REPLACE(descr);
+    if (descr == NULL) {
+      return NULL;
+    }
+    PyDataType_SET_ELSIZE(descr, elsize);
+  }
+  return descr;
+}
+
+/************************* FortranObject *******************************/
+
+typedef PyObject *(*fortranfunc)(PyObject *, PyObject *, PyObject *, void *);
+
+PyObject *
+PyFortranObject_New(FortranDataDef *defs, f2py_void_func init)
+{
+    int i;
+    PyFortranObject *fp = NULL;
+    PyObject *v = NULL;
+    if (init != NULL) { /* Initialize F90 module objects */
+        (*(init))();
+    }
+    fp = PyObject_New(PyFortranObject, &PyFortran_Type);
+    if (fp == NULL) {
+        return NULL;
+    }
+    if ((fp->dict = PyDict_New()) == NULL) {
+        Py_DECREF(fp);
+        return NULL;
+    }
+    fp->len = 0;
+    while (defs[fp->len].name != NULL) {
+        fp->len++;
+    }
+    if (fp->len == 0) {
+        goto fail;
+    }
+    fp->defs = defs;
+    for (i = 0; i < fp->len; i++) {
+        if (fp->defs[i].rank == -1) { /* Is Fortran routine */
+            v = PyFortranObject_NewAsAttr(&(fp->defs[i]));
+            if (v == NULL) {
+                goto fail;
+            }
+            PyDict_SetItemString(fp->dict, fp->defs[i].name, v);
+            Py_XDECREF(v);
+        }
+        else if ((fp->defs[i].data) !=
+                 NULL) { /* Is Fortran variable or array (not allocatable) */
+            PyArray_Descr *
+            descr = get_descr_from_type_and_elsize(fp->defs[i].type,
+                                                   fp->defs[i].elsize);
+            if (descr == NULL) {
+                goto fail;
+            }
+            v = PyArray_NewFromDescr(&PyArray_Type, descr, fp->defs[i].rank,
+                                     fp->defs[i].dims.d, NULL, fp->defs[i].data,
+                                     NPY_ARRAY_FARRAY, NULL);
+            if (v == NULL) {
+                Py_DECREF(descr);
+                goto fail;
+            }
+            PyDict_SetItemString(fp->dict, fp->defs[i].name, v);
+            Py_XDECREF(v);
+        }
+    }
+    return (PyObject *)fp;
+fail:
+    Py_XDECREF(fp);
+    return NULL;
+}
+
+PyObject *
+PyFortranObject_NewAsAttr(FortranDataDef *defs)
+{ /* used for calling F90 module routines */
+    PyFortranObject *fp = NULL;
+    fp = PyObject_New(PyFortranObject, &PyFortran_Type);
+    if (fp == NULL)
+        return NULL;
+    if ((fp->dict = PyDict_New()) == NULL) {
+        PyObject_Del(fp);
+        return NULL;
+    }
+    fp->len = 1;
+    fp->defs = defs;
+    if (defs->rank == -1) {
+      PyDict_SetItemString(fp->dict, "__name__", PyUnicode_FromFormat("function %s", defs->name));
+    } else if (defs->rank == 0) {
+      PyDict_SetItemString(fp->dict, "__name__", PyUnicode_FromFormat("scalar %s", defs->name));
+    } else {
+      PyDict_SetItemString(fp->dict, "__name__", PyUnicode_FromFormat("array %s", defs->name));
+    }
+    return (PyObject *)fp;
+}
+
+/* Fortran methods */
+
+static void
+fortran_dealloc(PyFortranObject *fp)
+{
+    Py_XDECREF(fp->dict);
+    PyObject_Del(fp);
+}
+
+/* Returns number of bytes consumed from buf, or -1 on error. */
+static Py_ssize_t
+format_def(char *buf, Py_ssize_t size, FortranDataDef def)
+{
+    char *p = buf;
+    int i;
+    npy_intp n;
+
+    n = PyOS_snprintf(p, size, "array(%" NPY_INTP_FMT, def.dims.d[0]);
+    if (n < 0 || n >= size) {
+        return -1;
+    }
+    p += n;
+    size -= n;
+
+    for (i = 1; i < def.rank; i++) {
+        n = PyOS_snprintf(p, size, ",%" NPY_INTP_FMT, def.dims.d[i]);
+        if (n < 0 || n >= size) {
+            return -1;
+        }
+        p += n;
+        size -= n;
+    }
+
+    if (size <= 0) {
+        return -1;
+    }
+
+    *p++ = ')';
+    size--;
+
+    if (def.data == NULL) {
+        static const char notalloc[] = ", not allocated";
+        if ((size_t)size < sizeof(notalloc)) {
+            return -1;
+        }
+        memcpy(p, notalloc, sizeof(notalloc));
+        p += sizeof(notalloc);
+        size -= sizeof(notalloc);
+    }
+
+    return p - buf;
+}
+
+static PyObject *
+fortran_doc(FortranDataDef def)
+{
+    char *buf, *p;
+    PyObject *s = NULL;
+    Py_ssize_t n, origsize, size = 100;
+
+    if (def.doc != NULL) {
+        size += strlen(def.doc);
+    }
+    origsize = size;
+    buf = p = (char *)PyMem_Malloc(size);
+    if (buf == NULL) {
+        return PyErr_NoMemory();
+    }
+
+    if (def.rank == -1) {
+        if (def.doc) {
+            n = strlen(def.doc);
+            if (n > size) {
+                goto fail;
+            }
+            memcpy(p, def.doc, n);
+            p += n;
+            size -= n;
+        }
+        else {
+            n = PyOS_snprintf(p, size, "%s - no docs available", def.name);
+            if (n < 0 || n >= size) {
+                goto fail;
+            }
+            p += n;
+            size -= n;
+        }
+    }
+    else {
+        PyArray_Descr *d = PyArray_DescrFromType(def.type);
+        n = PyOS_snprintf(p, size, "%s : '%c'-", def.name, d->type);
+        Py_DECREF(d);
+        if (n < 0 || n >= size) {
+            goto fail;
+        }
+        p += n;
+        size -= n;
+
+        if (def.data == NULL) {
+            n = format_def(p, size, def);
+            if (n < 0) {
+                goto fail;
+            }
+            p += n;
+            size -= n;
+        }
+        else if (def.rank > 0) {
+            n = format_def(p, size, def);
+            if (n < 0) {
+                goto fail;
+            }
+            p += n;
+            size -= n;
+        }
+        else {
+            n = strlen("scalar");
+            if (size < n) {
+                goto fail;
+            }
+            memcpy(p, "scalar", n);
+            p += n;
+            size -= n;
+        }
+    }
+    if (size <= 1) {
+        goto fail;
+    }
+    *p++ = '\n';
+    size--;
+
+    /* p now points one beyond the last character of the string in buf */
+    s = PyUnicode_FromStringAndSize(buf, p - buf);
+
+    PyMem_Free(buf);
+    return s;
+
+fail:
+    fprintf(stderr,
+            "fortranobject.c: fortran_doc: len(p)=%zd>%zd=size:"
+            " too long docstring required, increase size\n",
+            p - buf, origsize);
+    PyMem_Free(buf);
+    return NULL;
+}
+
+static FortranDataDef *save_def; /* save pointer of an allocatable array */
+static void
+set_data(char *d, npy_intp *f)
+{           /* callback from Fortran */
+    if (*f) /* In fortran f=allocated(d) */
+        save_def->data = d;
+    else
+        save_def->data = NULL;
+    /* printf("set_data: d=%p,f=%d\n",d,*f); */
+}
+
+static PyObject *
+fortran_getattr(PyFortranObject *fp, char *name)
+{
+    int i, j, k, flag;
+    if (fp->dict != NULL) {
+        PyObject *v = _PyDict_GetItemStringWithError(fp->dict, name);
+        if (v == NULL && PyErr_Occurred()) {
+            return NULL;
+        }
+        else if (v != NULL) {
+            Py_INCREF(v);
+            return v;
+        }
+    }
+    for (i = 0, j = 1; i < fp->len && (j = strcmp(name, fp->defs[i].name));
+         i++)
+        ;
+    if (j == 0)
+        if (fp->defs[i].rank != -1) { /* F90 allocatable array */
+            if (fp->defs[i].func == NULL)
+                return NULL;
+            for (k = 0; k < fp->defs[i].rank; ++k) fp->defs[i].dims.d[k] = -1;
+            save_def = &fp->defs[i];
+            (*(fp->defs[i].func))(&fp->defs[i].rank, fp->defs[i].dims.d,
+                                  set_data, &flag);
+            if (flag == 2)
+                k = fp->defs[i].rank + 1;
+            else
+                k = fp->defs[i].rank;
+            if (fp->defs[i].data != NULL) { /* array is allocated */
+                PyObject *v = PyArray_New(
+                        &PyArray_Type, k, fp->defs[i].dims.d, fp->defs[i].type,
+                        NULL, fp->defs[i].data, 0, NPY_ARRAY_FARRAY, NULL);
+                if (v == NULL)
+                    return NULL;
+                /* Py_INCREF(v); */
+                return v;
+            }
+            else { /* array is not allocated */
+                Py_RETURN_NONE;
+            }
+        }
+    if (strcmp(name, "__dict__") == 0) {
+        Py_INCREF(fp->dict);
+        return fp->dict;
+    }
+    if (strcmp(name, "__doc__") == 0) {
+        PyObject *s = PyUnicode_FromString(""), *s2, *s3;
+        for (i = 0; i < fp->len; i++) {
+            s2 = fortran_doc(fp->defs[i]);
+            s3 = PyUnicode_Concat(s, s2);
+            Py_DECREF(s2);
+            Py_DECREF(s);
+            s = s3;
+        }
+        if (PyDict_SetItemString(fp->dict, name, s))
+            return NULL;
+        return s;
+    }
+    if ((strcmp(name, "_cpointer") == 0) && (fp->len == 1)) {
+        PyObject *cobj =
+                F2PyCapsule_FromVoidPtr((void *)(fp->defs[0].data), NULL);
+        if (PyDict_SetItemString(fp->dict, name, cobj))
+            return NULL;
+        return cobj;
+    }
+    PyObject *str, *ret;
+    str = PyUnicode_FromString(name);
+    ret = PyObject_GenericGetAttr((PyObject *)fp, str);
+    Py_DECREF(str);
+    return ret;
+}
+
+static int
+fortran_setattr(PyFortranObject *fp, char *name, PyObject *v)
+{
+    int i, j, flag;
+    PyArrayObject *arr = NULL;
+    for (i = 0, j = 1; i < fp->len && (j = strcmp(name, fp->defs[i].name));
+         i++)
+        ;
+    if (j == 0) {
+        if (fp->defs[i].rank == -1) {
+            PyErr_SetString(PyExc_AttributeError,
+                            "over-writing fortran routine");
+            return -1;
+        }
+        if (fp->defs[i].func != NULL) { /* is allocatable array */
+            npy_intp dims[F2PY_MAX_DIMS];
+            int k;
+            save_def = &fp->defs[i];
+            if (v != Py_None) { /* set new value (reallocate if needed --
+                                   see f2py generated code for more
+                                   details ) */
+                for (k = 0; k < fp->defs[i].rank; k++) dims[k] = -1;
+                if ((arr = array_from_pyobj(fp->defs[i].type, dims,
+                                            fp->defs[i].rank, F2PY_INTENT_IN,
+                                            v)) == NULL)
+                    return -1;
+                (*(fp->defs[i].func))(&fp->defs[i].rank, PyArray_DIMS(arr),
+                                      set_data, &flag);
+            }
+            else { /* deallocate */
+                for (k = 0; k < fp->defs[i].rank; k++) dims[k] = 0;
+                (*(fp->defs[i].func))(&fp->defs[i].rank, dims, set_data,
+                                      &flag);
+                for (k = 0; k < fp->defs[i].rank; k++) dims[k] = -1;
+            }
+            memcpy(fp->defs[i].dims.d, dims,
+                   fp->defs[i].rank * sizeof(npy_intp));
+        }
+        else { /* not allocatable array */
+            if ((arr = array_from_pyobj(fp->defs[i].type, fp->defs[i].dims.d,
+                                        fp->defs[i].rank, F2PY_INTENT_IN,
+                                        v)) == NULL)
+                return -1;
+        }
+        if (fp->defs[i].data !=
+            NULL) { /* copy Python object to Fortran array */
+            npy_intp s = PyArray_MultiplyList(fp->defs[i].dims.d,
+                                              PyArray_NDIM(arr));
+            if (s == -1)
+                s = PyArray_MultiplyList(PyArray_DIMS(arr), PyArray_NDIM(arr));
+            if (s < 0 || (memcpy(fp->defs[i].data, PyArray_DATA(arr),
+                                 s * PyArray_ITEMSIZE(arr))) == NULL) {
+                if ((PyObject *)arr != v) {
+                    Py_DECREF(arr);
+                }
+                return -1;
+            }
+            if ((PyObject *)arr != v) {
+                Py_DECREF(arr);
+            }
+        }
+        else
+            return (fp->defs[i].func == NULL ? -1 : 0);
+        return 0; /* successful */
+    }
+    if (fp->dict == NULL) {
+        fp->dict = PyDict_New();
+        if (fp->dict == NULL)
+            return -1;
+    }
+    if (v == NULL) {
+        int rv = PyDict_DelItemString(fp->dict, name);
+        if (rv < 0)
+            PyErr_SetString(PyExc_AttributeError,
+                            "delete non-existing fortran attribute");
+        return rv;
+    }
+    else
+        return PyDict_SetItemString(fp->dict, name, v);
+}
+
+static PyObject *
+fortran_call(PyFortranObject *fp, PyObject *arg, PyObject *kw)
+{
+    int i = 0;
+    /*  printf("fortran call
+        name=%s,func=%p,data=%p,%p\n",fp->defs[i].name,
+        fp->defs[i].func,fp->defs[i].data,&fp->defs[i].data); */
+    if (fp->defs[i].rank == -1) { /* is Fortran routine */
+        if (fp->defs[i].func == NULL) {
+            PyErr_Format(PyExc_RuntimeError, "no function to call");
+            return NULL;
+        }
+        else if (fp->defs[i].data == NULL)
+            /* dummy routine */
+            return (*((fortranfunc)(fp->defs[i].func)))((PyObject *)fp, arg,
+                                                        kw, NULL);
+        else
+            return (*((fortranfunc)(fp->defs[i].func)))(
+                    (PyObject *)fp, arg, kw, (void *)fp->defs[i].data);
+    }
+    PyErr_Format(PyExc_TypeError, "this fortran object is not callable");
+    return NULL;
+}
+
+static PyObject *
+fortran_repr(PyFortranObject *fp)
+{
+    PyObject *name = NULL, *repr = NULL;
+    name = PyObject_GetAttrString((PyObject *)fp, "__name__");
+    PyErr_Clear();
+    if (name != NULL && PyUnicode_Check(name)) {
+        repr = PyUnicode_FromFormat("", name);
+    }
+    else {
+        repr = PyUnicode_FromString("");
+    }
+    Py_XDECREF(name);
+    return repr;
+}
+
+PyTypeObject PyFortran_Type = {
+        PyVarObject_HEAD_INIT(NULL, 0).tp_name = "fortran",
+        .tp_basicsize = sizeof(PyFortranObject),
+        .tp_dealloc = (destructor)fortran_dealloc,
+        .tp_getattr = (getattrfunc)fortran_getattr,
+        .tp_setattr = (setattrfunc)fortran_setattr,
+        .tp_repr = (reprfunc)fortran_repr,
+        .tp_call = (ternaryfunc)fortran_call,
+};
+
+/************************* f2py_report_atexit *******************************/
+
+#ifdef F2PY_REPORT_ATEXIT
+static int passed_time = 0;
+static int passed_counter = 0;
+static int passed_call_time = 0;
+static struct timeb start_time;
+static struct timeb stop_time;
+static struct timeb start_call_time;
+static struct timeb stop_call_time;
+static int cb_passed_time = 0;
+static int cb_passed_counter = 0;
+static int cb_passed_call_time = 0;
+static struct timeb cb_start_time;
+static struct timeb cb_stop_time;
+static struct timeb cb_start_call_time;
+static struct timeb cb_stop_call_time;
+
+extern void
+f2py_start_clock(void)
+{
+    ftime(&start_time);
+}
+extern void
+f2py_start_call_clock(void)
+{
+    f2py_stop_clock();
+    ftime(&start_call_time);
+}
+extern void
+f2py_stop_clock(void)
+{
+    ftime(&stop_time);
+    passed_time += 1000 * (stop_time.time - start_time.time);
+    passed_time += stop_time.millitm - start_time.millitm;
+}
+extern void
+f2py_stop_call_clock(void)
+{
+    ftime(&stop_call_time);
+    passed_call_time += 1000 * (stop_call_time.time - start_call_time.time);
+    passed_call_time += stop_call_time.millitm - start_call_time.millitm;
+    passed_counter += 1;
+    f2py_start_clock();
+}
+
+extern void
+f2py_cb_start_clock(void)
+{
+    ftime(&cb_start_time);
+}
+extern void
+f2py_cb_start_call_clock(void)
+{
+    f2py_cb_stop_clock();
+    ftime(&cb_start_call_time);
+}
+extern void
+f2py_cb_stop_clock(void)
+{
+    ftime(&cb_stop_time);
+    cb_passed_time += 1000 * (cb_stop_time.time - cb_start_time.time);
+    cb_passed_time += cb_stop_time.millitm - cb_start_time.millitm;
+}
+extern void
+f2py_cb_stop_call_clock(void)
+{
+    ftime(&cb_stop_call_time);
+    cb_passed_call_time +=
+            1000 * (cb_stop_call_time.time - cb_start_call_time.time);
+    cb_passed_call_time +=
+            cb_stop_call_time.millitm - cb_start_call_time.millitm;
+    cb_passed_counter += 1;
+    f2py_cb_start_clock();
+}
+
+static int f2py_report_on_exit_been_here = 0;
+extern void
+f2py_report_on_exit(int exit_flag, void *name)
+{
+    if (f2py_report_on_exit_been_here) {
+        fprintf(stderr, "             %s\n", (char *)name);
+        return;
+    }
+    f2py_report_on_exit_been_here = 1;
+    fprintf(stderr, "                      /-----------------------\\\n");
+    fprintf(stderr, "                     < F2PY performance report >\n");
+    fprintf(stderr, "                      \\-----------------------/\n");
+    fprintf(stderr, "Overall time spent in ...\n");
+    fprintf(stderr, "(a) wrapped (Fortran/C) functions           : %8d msec\n",
+            passed_call_time);
+    fprintf(stderr, "(b) f2py interface,           %6d calls  : %8d msec\n",
+            passed_counter, passed_time);
+    fprintf(stderr, "(c) call-back (Python) functions            : %8d msec\n",
+            cb_passed_call_time);
+    fprintf(stderr, "(d) f2py call-back interface, %6d calls  : %8d msec\n",
+            cb_passed_counter, cb_passed_time);
+
+    fprintf(stderr,
+            "(e) wrapped (Fortran/C) functions (actual) : %8d msec\n\n",
+            passed_call_time - cb_passed_call_time - cb_passed_time);
+    fprintf(stderr,
+            "Use -DF2PY_REPORT_ATEXIT_DISABLE to disable this message.\n");
+    fprintf(stderr, "Exit status: %d\n", exit_flag);
+    fprintf(stderr, "Modules    : %s\n", (char *)name);
+}
+#endif
+
+/********************** report on array copy ****************************/
+
+#ifdef F2PY_REPORT_ON_ARRAY_COPY
+static void
+f2py_report_on_array_copy(PyArrayObject *arr)
+{
+    const npy_intp arr_size = PyArray_Size((PyObject *)arr);
+    if (arr_size > F2PY_REPORT_ON_ARRAY_COPY) {
+        fprintf(stderr,
+                "copied an array: size=%ld, elsize=%" NPY_INTP_FMT "\n",
+                arr_size, (npy_intp)PyArray_ITEMSIZE(arr));
+    }
+}
+static void
+f2py_report_on_array_copy_fromany(void)
+{
+    fprintf(stderr, "created an array from object\n");
+}
+
+#define F2PY_REPORT_ON_ARRAY_COPY_FROMARR \
+    f2py_report_on_array_copy((PyArrayObject *)arr)
+#define F2PY_REPORT_ON_ARRAY_COPY_FROMANY f2py_report_on_array_copy_fromany()
+#else
+#define F2PY_REPORT_ON_ARRAY_COPY_FROMARR
+#define F2PY_REPORT_ON_ARRAY_COPY_FROMANY
+#endif
+
+/************************* array_from_obj *******************************/
+
+/*
+ * File: array_from_pyobj.c
+ *
+ * Description:
+ * ------------
+ * Provides array_from_pyobj function that returns a contiguous array
+ * object with the given dimensions and required storage order, either
+ * in row-major (C) or column-major (Fortran) order. The function
+ * array_from_pyobj is very flexible about its Python object argument
+ * that can be any number, list, tuple, or array.
+ *
+ * array_from_pyobj is used in f2py generated Python extension
+ * modules.
+ *
+ * Author: Pearu Peterson 
+ * Created: 13-16 January 2002
+ * $Id: fortranobject.c,v 1.52 2005/07/11 07:44:20 pearu Exp $
+ */
+
+static int check_and_fix_dimensions(const PyArrayObject* arr,
+                                    const int rank,
+                                    npy_intp *dims,
+                                    const char *errmess);
+
+static int
+find_first_negative_dimension(const int rank, const npy_intp *dims)
+{
+    int i;
+    for (i = 0; i < rank; ++i) {
+        if (dims[i] < 0) {
+            return i;
+        }
+    }
+    return -1;
+}
+
+#ifdef DEBUG_COPY_ND_ARRAY
+void
+dump_dims(int rank, npy_intp const *dims)
+{
+    int i;
+    printf("[");
+    for (i = 0; i < rank; ++i) {
+        printf("%3" NPY_INTP_FMT, dims[i]);
+    }
+    printf("]\n");
+}
+void
+dump_attrs(const PyArrayObject *obj)
+{
+    const PyArrayObject_fields *arr = (const PyArrayObject_fields *)obj;
+    int rank = PyArray_NDIM(arr);
+    npy_intp size = PyArray_Size((PyObject *)arr);
+    printf("\trank = %d, flags = %d, size = %" NPY_INTP_FMT "\n", rank,
+           arr->flags, size);
+    printf("\tstrides = ");
+    dump_dims(rank, arr->strides);
+    printf("\tdimensions = ");
+    dump_dims(rank, arr->dimensions);
+}
+#endif
+
+#define SWAPTYPE(a, b, t) \
+    {                     \
+        t c;              \
+        c = (a);          \
+        (a) = (b);        \
+        (b) = c;          \
+    }
+
+static int
+swap_arrays(PyArrayObject *obj1, PyArrayObject *obj2)
+{
+    PyArrayObject_fields *arr1 = (PyArrayObject_fields *)obj1,
+                         *arr2 = (PyArrayObject_fields *)obj2;
+    SWAPTYPE(arr1->data, arr2->data, char *);
+    SWAPTYPE(arr1->nd, arr2->nd, int);
+    SWAPTYPE(arr1->dimensions, arr2->dimensions, npy_intp *);
+    SWAPTYPE(arr1->strides, arr2->strides, npy_intp *);
+    SWAPTYPE(arr1->base, arr2->base, PyObject *);
+    SWAPTYPE(arr1->descr, arr2->descr, PyArray_Descr *);
+    SWAPTYPE(arr1->flags, arr2->flags, int);
+    /* SWAPTYPE(arr1->weakreflist,arr2->weakreflist,PyObject*); */
+    return 0;
+}
+
+#define ARRAY_ISCOMPATIBLE(arr,type_num)                                \
+    ((PyArray_ISINTEGER(arr) && PyTypeNum_ISINTEGER(type_num)) ||     \
+     (PyArray_ISFLOAT(arr) && PyTypeNum_ISFLOAT(type_num)) ||         \
+     (PyArray_ISCOMPLEX(arr) && PyTypeNum_ISCOMPLEX(type_num)) ||     \
+     (PyArray_ISBOOL(arr) && PyTypeNum_ISBOOL(type_num)) ||           \
+     (PyArray_ISSTRING(arr) && PyTypeNum_ISSTRING(type_num)))
+
+static int
+get_elsize(PyObject *obj) {
+  /*
+    get_elsize determines array itemsize from a Python object.  Returns
+    elsize if successful, -1 otherwise.
+
+    Supported types of the input are: numpy.ndarray, bytes, str, tuple,
+    list.
+  */
+
+  if (PyArray_Check(obj)) {
+    return PyArray_ITEMSIZE((PyArrayObject *)obj);
+  } else if (PyBytes_Check(obj)) {
+    return PyBytes_GET_SIZE(obj);
+  } else if (PyUnicode_Check(obj)) {
+    return PyUnicode_GET_LENGTH(obj);
+  } else if (PySequence_Check(obj)) {
+    PyObject* fast = PySequence_Fast(obj, "f2py:fortranobject.c:get_elsize");
+    if (fast != NULL) {
+      Py_ssize_t i, n = PySequence_Fast_GET_SIZE(fast);
+      int sz, elsize = 0;
+      for (i=0; i elsize) {
+          elsize = sz;
+        }
+      }
+      Py_DECREF(fast);
+      return elsize;
+    }
+  }
+  return -1;
+}
+
+extern PyArrayObject *
+ndarray_from_pyobj(const int type_num,
+                   const int elsize_,
+                   npy_intp *dims,
+                   const int rank,
+                   const int intent,
+                   PyObject *obj,
+                   const char *errmess) {
+    /*
+     * Return an array with given element type and shape from a Python
+     * object while taking into account the usage intent of the array.
+     *
+     * - element type is defined by type_num and elsize
+     * - shape is defined by dims and rank
+     *
+     * ndarray_from_pyobj is used to convert Python object arguments
+     * to numpy ndarrays with given type and shape that data is passed
+     * to interfaced Fortran or C functions.
+     *
+     * errmess (if not NULL), contains a prefix of an error message
+     * for an exception to be triggered within this function.
+     *
+     * Negative elsize value means that elsize is to be determined
+     * from the Python object in runtime.
+     *
+     * Note on strings
+     * ---------------
+     *
+     * String type (type_num == NPY_STRING) does not have fixed
+     * element size and, by default, the type object sets it to
+     * 0. Therefore, for string types, one has to use elsize
+     * argument. For other types, elsize value is ignored.
+     *
+     * NumPy defines the type of a fixed-width string as
+     * dtype('S'). In addition, there is also dtype('c'), that
+     * appears as dtype('S1') (these have the same type_num value),
+     * but is actually different (.char attribute is either 'S' or
+     * 'c', respecitely).
+     *
+     * In Fortran, character arrays and strings are different
+     * concepts.  The relation between Fortran types, NumPy dtypes,
+     * and type_num-elsize pairs, is defined as follows:
+     *
+     * character*5 foo     | dtype('S5')  | elsize=5, shape=()
+     * character(5) foo    | dtype('S1')  | elsize=1, shape=(5)
+     * character*5 foo(n)  | dtype('S5')  | elsize=5, shape=(n,)
+     * character(5) foo(n) | dtype('S1')  | elsize=1, shape=(5, n)
+     * character*(*) foo   | dtype('S')   | elsize=-1, shape=()
+     *
+     * Note about reference counting
+     * -----------------------------
+     *
+     * If the caller returns the array to Python, it must be done with
+     * Py_BuildValue("N",arr).  Otherwise, if obj!=arr then the caller
+     * must call Py_DECREF(arr).
+     *
+     * Note on intent(cache,out,..)
+     * ----------------------------
+     * Don't expect correct data when returning intent(cache) array.
+     *
+     */
+    char mess[F2PY_MESSAGE_BUFFER_SIZE];
+    PyArrayObject *arr = NULL;
+    int elsize = (elsize_ < 0 ? get_elsize(obj) : elsize_);
+    if (elsize < 0) {
+      if (errmess != NULL) {
+        strcpy(mess, errmess);
+      }
+      sprintf(mess + strlen(mess),
+              " -- failed to determine element size from %s",
+              Py_TYPE(obj)->tp_name);
+      PyErr_SetString(PyExc_SystemError, mess);
+      return NULL;
+    }
+    PyArray_Descr * descr = get_descr_from_type_and_elsize(type_num, elsize);  // new reference
+    if (descr == NULL) {
+      return NULL;
+    }
+    elsize = PyDataType_ELSIZE(descr);
+    if ((intent & F2PY_INTENT_HIDE)
+        || ((intent & F2PY_INTENT_CACHE) && (obj == Py_None))
+        || ((intent & F2PY_OPTIONAL) && (obj == Py_None))
+        ) {
+        /* intent(cache), optional, intent(hide) */
+        int ineg = find_first_negative_dimension(rank, dims);
+        if (ineg >= 0) {
+            int i;
+            strcpy(mess, "failed to create intent(cache|hide)|optional array"
+                   "-- must have defined dimensions but got (");
+            for(i = 0; i < rank; ++i)
+                sprintf(mess + strlen(mess), "%" NPY_INTP_FMT ",", dims[i]);
+            strcat(mess, ")");
+            PyErr_SetString(PyExc_ValueError, mess);
+            Py_DECREF(descr);
+            return NULL;
+        }
+        arr = (PyArrayObject *)                                      \
+          PyArray_NewFromDescr(&PyArray_Type, descr, rank, dims,
+                               NULL, NULL, !(intent & F2PY_INTENT_C), NULL);
+        if (arr == NULL) {
+          Py_DECREF(descr);
+          return NULL;
+        }
+        if (PyArray_ITEMSIZE(arr) != elsize) {
+          strcpy(mess, "failed to create intent(cache|hide)|optional array");
+          sprintf(mess+strlen(mess)," -- expected elsize=%d got %" NPY_INTP_FMT, elsize, (npy_intp)PyArray_ITEMSIZE(arr));
+          PyErr_SetString(PyExc_ValueError,mess);
+          Py_DECREF(arr);
+          return NULL;
+        }
+        if (!(intent & F2PY_INTENT_CACHE)) {
+          PyArray_FILLWBYTE(arr, 0);
+        }
+        return arr;
+    }
+
+    if (PyArray_Check(obj)) {
+        arr = (PyArrayObject *)obj;
+        if (intent & F2PY_INTENT_CACHE) {
+            /* intent(cache) */
+            if (PyArray_ISONESEGMENT(arr)
+                && PyArray_ITEMSIZE(arr) >= elsize) {
+                if (check_and_fix_dimensions(arr, rank, dims, errmess)) {
+                  Py_DECREF(descr);
+                  return NULL;
+                }
+                if (intent & F2PY_INTENT_OUT)
+                  Py_INCREF(arr);
+                Py_DECREF(descr);
+                return arr;
+            }
+            strcpy(mess, "failed to initialize intent(cache) array");
+            if (!PyArray_ISONESEGMENT(arr))
+                strcat(mess, " -- input must be in one segment");
+            if (PyArray_ITEMSIZE(arr) < elsize)
+                sprintf(mess + strlen(mess),
+                        " -- expected at least elsize=%d but got "
+                        "%" NPY_INTP_FMT,
+                        elsize, (npy_intp)PyArray_ITEMSIZE(arr));
+            PyErr_SetString(PyExc_ValueError, mess);
+            Py_DECREF(descr);
+            return NULL;
+        }
+
+        /* here we have always intent(in) or intent(inout) or intent(inplace)
+         */
+
+        if (check_and_fix_dimensions(arr, rank, dims, errmess)) {
+          Py_DECREF(descr);
+          return NULL;
+        }
+        /*
+        printf("intent alignment=%d\n", F2PY_GET_ALIGNMENT(intent));
+        printf("alignment check=%d\n", F2PY_CHECK_ALIGNMENT(arr, intent));
+        int i;
+        for (i=1;i<=16;i++)
+          printf("i=%d isaligned=%d\n", i, ARRAY_ISALIGNED(arr, i));
+        */
+        if ((! (intent & F2PY_INTENT_COPY)) &&
+            PyArray_ITEMSIZE(arr) == elsize &&
+            ARRAY_ISCOMPATIBLE(arr,type_num) &&
+            F2PY_CHECK_ALIGNMENT(arr, intent)) {
+            if ((intent & F2PY_INTENT_INOUT || intent & F2PY_INTENT_INPLACE)
+              ? ((intent & F2PY_INTENT_C) ? PyArray_ISCARRAY(arr) : PyArray_ISFARRAY(arr))
+              : ((intent & F2PY_INTENT_C) ? PyArray_ISCARRAY_RO(arr) : PyArray_ISFARRAY_RO(arr))) {
+                if ((intent & F2PY_INTENT_OUT)) {
+                    Py_INCREF(arr);
+                }
+                /* Returning input array */
+                Py_DECREF(descr);
+                return arr;
+            }
+        }
+        if (intent & F2PY_INTENT_INOUT) {
+            strcpy(mess, "failed to initialize intent(inout) array");
+            /* Must use PyArray_IS*ARRAY because intent(inout) requires
+             * writable input */
+            if ((intent & F2PY_INTENT_C) && !PyArray_ISCARRAY(arr))
+                strcat(mess, " -- input not contiguous");
+            if (!(intent & F2PY_INTENT_C) && !PyArray_ISFARRAY(arr))
+                strcat(mess, " -- input not fortran contiguous");
+            if (PyArray_ITEMSIZE(arr) != elsize)
+                sprintf(mess + strlen(mess),
+                        " -- expected elsize=%d but got %" NPY_INTP_FMT,
+                        elsize,
+                        (npy_intp)PyArray_ITEMSIZE(arr)
+                        );
+            if (!(ARRAY_ISCOMPATIBLE(arr, type_num))) {
+                sprintf(mess + strlen(mess),
+                        " -- input '%c' not compatible to '%c'",
+                        PyArray_DESCR(arr)->type, descr->type);
+            }
+            if (!(F2PY_CHECK_ALIGNMENT(arr, intent)))
+                sprintf(mess + strlen(mess), " -- input not %d-aligned",
+                        F2PY_GET_ALIGNMENT(intent));
+            PyErr_SetString(PyExc_ValueError, mess);
+            Py_DECREF(descr);
+            return NULL;
+        }
+
+        /* here we have always intent(in) or intent(inplace) */
+
+        {
+          PyArrayObject * retarr = (PyArrayObject *)                    \
+            PyArray_NewFromDescr(&PyArray_Type, descr, PyArray_NDIM(arr), PyArray_DIMS(arr),
+                                 NULL, NULL, !(intent & F2PY_INTENT_C), NULL);
+          if (retarr==NULL) {
+            Py_DECREF(descr);
+            return NULL;
+          }
+          F2PY_REPORT_ON_ARRAY_COPY_FROMARR;
+          if (PyArray_CopyInto(retarr, arr)) {
+            Py_DECREF(retarr);
+            return NULL;
+          }
+          if (intent & F2PY_INTENT_INPLACE) {
+            if (swap_arrays(arr,retarr)) {
+              Py_DECREF(retarr);
+              return NULL; /* XXX: set exception */
+            }
+            Py_XDECREF(retarr);
+            if (intent & F2PY_INTENT_OUT)
+              Py_INCREF(arr);
+          } else {
+            arr = retarr;
+          }
+        }
+        return arr;
+    }
+
+    if ((intent & F2PY_INTENT_INOUT) || (intent & F2PY_INTENT_INPLACE) ||
+        (intent & F2PY_INTENT_CACHE)) {
+        PyErr_Format(PyExc_TypeError,
+                     "failed to initialize intent(inout|inplace|cache) "
+                     "array, input '%s' object is not an array",
+                     Py_TYPE(obj)->tp_name);
+        Py_DECREF(descr);
+        return NULL;
+    }
+
+    {
+        F2PY_REPORT_ON_ARRAY_COPY_FROMANY;
+        arr = (PyArrayObject *)PyArray_FromAny(
+                obj, descr, 0, 0,
+                ((intent & F2PY_INTENT_C) ? NPY_ARRAY_CARRAY
+                                          : NPY_ARRAY_FARRAY) |
+                        NPY_ARRAY_FORCECAST,
+                NULL);
+        // Warning: in the case of NPY_STRING, PyArray_FromAny may
+        // reset descr->elsize, e.g. dtype('S0') becomes dtype('S1').
+        if (arr == NULL) {
+          Py_DECREF(descr);
+          return NULL;
+        }
+        if (type_num != NPY_STRING && PyArray_ITEMSIZE(arr) != elsize) {
+          // This is internal sanity tests: elsize has been set to
+          // descr->elsize in the beginning of this function.
+          strcpy(mess, "failed to initialize intent(in) array");
+          sprintf(mess + strlen(mess),
+                  " -- expected elsize=%d got %" NPY_INTP_FMT, elsize,
+                  (npy_intp)PyArray_ITEMSIZE(arr));
+          PyErr_SetString(PyExc_ValueError, mess);
+          Py_DECREF(arr);
+          return NULL;
+        }
+        if (check_and_fix_dimensions(arr, rank, dims, errmess)) {
+          Py_DECREF(arr);
+          return NULL;
+        }
+        return arr;
+    }
+}
+
+extern PyArrayObject *
+array_from_pyobj(const int type_num,
+                                npy_intp *dims,
+                                const int rank,
+                                const int intent,
+                                PyObject *obj) {
+  /*
+    Same as ndarray_from_pyobj but with elsize determined from type,
+    if possible. Provided for backward compatibility.
+   */
+  PyArray_Descr* descr = PyArray_DescrFromType(type_num);
+  int elsize = PyDataType_ELSIZE(descr);
+  Py_DECREF(descr);
+  return ndarray_from_pyobj(type_num, elsize, dims, rank, intent, obj, NULL);
+}
+
+/*****************************************/
+/* Helper functions for array_from_pyobj */
+/*****************************************/
+
+static int
+check_and_fix_dimensions(const PyArrayObject* arr, const int rank,
+                         npy_intp *dims, const char *errmess)
+{
+    /*
+     * This function fills in blanks (that are -1's) in dims list using
+     * the dimensions from arr. It also checks that non-blank dims will
+     * match with the corresponding values in arr dimensions.
+     *
+     * Returns 0 if the function is successful.
+     *
+     * If an error condition is detected, an exception is set and 1 is
+     * returned.
+     */
+    char mess[F2PY_MESSAGE_BUFFER_SIZE];
+    const npy_intp arr_size =
+            (PyArray_NDIM(arr)) ? PyArray_Size((PyObject *)arr) : 1;
+#ifdef DEBUG_COPY_ND_ARRAY
+    dump_attrs(arr);
+    printf("check_and_fix_dimensions:init: dims=");
+    dump_dims(rank, dims);
+#endif
+    if (rank > PyArray_NDIM(arr)) { /* [1,2] -> [[1],[2]]; 1 -> [[1]]  */
+        npy_intp new_size = 1;
+        int free_axe = -1;
+        int i;
+        npy_intp d;
+        /* Fill dims where -1 or 0; check dimensions; calc new_size; */
+        for (i = 0; i < PyArray_NDIM(arr); ++i) {
+            d = PyArray_DIM(arr, i);
+            if (dims[i] >= 0) {
+                if (d > 1 && dims[i] != d) {
+                    PyErr_Format(
+                            PyExc_ValueError,
+                            "%d-th dimension must be fixed to %" NPY_INTP_FMT
+                            " but got %" NPY_INTP_FMT "\n",
+                            i, dims[i], d);
+                    return 1;
+                }
+                if (!dims[i])
+                    dims[i] = 1;
+            }
+            else {
+                dims[i] = d ? d : 1;
+            }
+            new_size *= dims[i];
+        }
+        for (i = PyArray_NDIM(arr); i < rank; ++i)
+            if (dims[i] > 1) {
+                PyErr_Format(PyExc_ValueError,
+                             "%d-th dimension must be %" NPY_INTP_FMT
+                             " but got 0 (not defined).\n",
+                             i, dims[i]);
+                return 1;
+            }
+            else if (free_axe < 0)
+                free_axe = i;
+            else
+                dims[i] = 1;
+        if (free_axe >= 0) {
+            dims[free_axe] = arr_size / new_size;
+            new_size *= dims[free_axe];
+        }
+        if (new_size != arr_size) {
+            PyErr_Format(PyExc_ValueError,
+                         "unexpected array size: new_size=%" NPY_INTP_FMT
+                         ", got array with arr_size=%" NPY_INTP_FMT
+                         " (maybe too many free indices)\n",
+                         new_size, arr_size);
+            return 1;
+        }
+    }
+    else if (rank == PyArray_NDIM(arr)) {
+        npy_intp new_size = 1;
+        int i;
+        npy_intp d;
+        for (i = 0; i < rank; ++i) {
+            d = PyArray_DIM(arr, i);
+            if (dims[i] >= 0) {
+                if (d > 1 && d != dims[i]) {
+                    if (errmess != NULL) {
+                        strcpy(mess, errmess);
+                    }
+                    sprintf(mess + strlen(mess),
+                            " -- %d-th dimension must be fixed to %"
+                            NPY_INTP_FMT " but got %" NPY_INTP_FMT,
+                            i, dims[i], d);
+                    PyErr_SetString(PyExc_ValueError, mess);
+                    return 1;
+                }
+                if (!dims[i])
+                    dims[i] = 1;
+            }
+            else
+                dims[i] = d;
+            new_size *= dims[i];
+        }
+        if (new_size != arr_size) {
+            PyErr_Format(PyExc_ValueError,
+                         "unexpected array size: new_size=%" NPY_INTP_FMT
+                         ", got array with arr_size=%" NPY_INTP_FMT "\n",
+                         new_size, arr_size);
+            return 1;
+        }
+    }
+    else { /* [[1,2]] -> [[1],[2]] */
+        int i, j;
+        npy_intp d;
+        int effrank;
+        npy_intp size;
+        for (i = 0, effrank = 0; i < PyArray_NDIM(arr); ++i)
+            if (PyArray_DIM(arr, i) > 1)
+                ++effrank;
+        if (dims[rank - 1] >= 0)
+            if (effrank > rank) {
+                PyErr_Format(PyExc_ValueError,
+                             "too many axes: %d (effrank=%d), "
+                             "expected rank=%d\n",
+                             PyArray_NDIM(arr), effrank, rank);
+                return 1;
+            }
+
+        for (i = 0, j = 0; i < rank; ++i) {
+            while (j < PyArray_NDIM(arr) && PyArray_DIM(arr, j) < 2) ++j;
+            if (j >= PyArray_NDIM(arr))
+                d = 1;
+            else
+                d = PyArray_DIM(arr, j++);
+            if (dims[i] >= 0) {
+                if (d > 1 && d != dims[i]) {
+                    if (errmess != NULL) {
+                        strcpy(mess, errmess);
+                    }
+                    sprintf(mess + strlen(mess),
+                            " -- %d-th dimension must be fixed to %"
+                            NPY_INTP_FMT " but got %" NPY_INTP_FMT
+                            " (real index=%d)\n",
+                            i, dims[i], d, j-1);
+                    PyErr_SetString(PyExc_ValueError, mess);
+                    return 1;
+                }
+                if (!dims[i])
+                    dims[i] = 1;
+            }
+            else
+                dims[i] = d;
+        }
+
+        for (i = rank; i < PyArray_NDIM(arr);
+             ++i) { /* [[1,2],[3,4]] -> [1,2,3,4] */
+            while (j < PyArray_NDIM(arr) && PyArray_DIM(arr, j) < 2) ++j;
+            if (j >= PyArray_NDIM(arr))
+                d = 1;
+            else
+                d = PyArray_DIM(arr, j++);
+            dims[rank - 1] *= d;
+        }
+        for (i = 0, size = 1; i < rank; ++i) size *= dims[i];
+        if (size != arr_size) {
+            char msg[200];
+            int len;
+            snprintf(msg, sizeof(msg),
+                     "unexpected array size: size=%" NPY_INTP_FMT
+                     ", arr_size=%" NPY_INTP_FMT
+                     ", rank=%d, effrank=%d, arr.nd=%d, dims=[",
+                     size, arr_size, rank, effrank, PyArray_NDIM(arr));
+            for (i = 0; i < rank; ++i) {
+                len = strlen(msg);
+                snprintf(msg + len, sizeof(msg) - len, " %" NPY_INTP_FMT,
+                         dims[i]);
+            }
+            len = strlen(msg);
+            snprintf(msg + len, sizeof(msg) - len, " ], arr.dims=[");
+            for (i = 0; i < PyArray_NDIM(arr); ++i) {
+                len = strlen(msg);
+                snprintf(msg + len, sizeof(msg) - len, " %" NPY_INTP_FMT,
+                         PyArray_DIM(arr, i));
+            }
+            len = strlen(msg);
+            snprintf(msg + len, sizeof(msg) - len, " ]\n");
+            PyErr_SetString(PyExc_ValueError, msg);
+            return 1;
+        }
+    }
+#ifdef DEBUG_COPY_ND_ARRAY
+    printf("check_and_fix_dimensions:end: dims=");
+    dump_dims(rank, dims);
+#endif
+    return 0;
+}
+
+/* End of file: array_from_pyobj.c */
+
+/************************* copy_ND_array *******************************/
+
+extern int
+copy_ND_array(const PyArrayObject *arr, PyArrayObject *out)
+{
+    F2PY_REPORT_ON_ARRAY_COPY_FROMARR;
+    return PyArray_CopyInto(out, (PyArrayObject *)arr);
+}
+
+/********************* Various utility functions ***********************/
+
+extern int
+f2py_describe(PyObject *obj, char *buf) {
+  /*
+    Write the description of a Python object to buf. The caller must
+    provide buffer with size sufficient to write the description.
+
+    Return 1 on success.
+  */
+  char localbuf[F2PY_MESSAGE_BUFFER_SIZE];
+  if (PyBytes_Check(obj)) {
+    sprintf(localbuf, "%d-%s", (npy_int)PyBytes_GET_SIZE(obj), Py_TYPE(obj)->tp_name);
+  } else if (PyUnicode_Check(obj)) {
+    sprintf(localbuf, "%d-%s", (npy_int)PyUnicode_GET_LENGTH(obj), Py_TYPE(obj)->tp_name);
+  } else if (PyArray_CheckScalar(obj)) {
+    PyArrayObject* arr = (PyArrayObject*)obj;
+    sprintf(localbuf, "%c%" NPY_INTP_FMT "-%s-scalar", PyArray_DESCR(arr)->kind, PyArray_ITEMSIZE(arr), Py_TYPE(obj)->tp_name);
+  } else if (PyArray_Check(obj)) {
+    int i;
+    PyArrayObject* arr = (PyArrayObject*)obj;
+    strcpy(localbuf, "(");
+    for (i=0; ikind, PyArray_ITEMSIZE(arr), Py_TYPE(obj)->tp_name);
+  } else if (PySequence_Check(obj)) {
+    sprintf(localbuf, "%d-%s", (npy_int)PySequence_Length(obj), Py_TYPE(obj)->tp_name);
+  } else {
+    sprintf(localbuf, "%s instance", Py_TYPE(obj)->tp_name);
+  }
+  // TODO: detect the size of buf and make sure that size(buf) >= size(localbuf).
+  strcpy(buf, localbuf);
+  return 1;
+}
+
+extern npy_intp
+f2py_size_impl(PyArrayObject* var, ...)
+{
+  npy_intp sz = 0;
+  npy_intp dim;
+  npy_intp rank;
+  va_list argp;
+  va_start(argp, var);
+  dim = va_arg(argp, npy_int);
+  if (dim==-1)
+    {
+      sz = PyArray_SIZE(var);
+    }
+  else
+    {
+      rank = PyArray_NDIM(var);
+      if (dim>=1 && dim<=rank)
+        sz = PyArray_DIM(var, dim-1);
+      else
+        fprintf(stderr, "f2py_size: 2nd argument value=%" NPY_INTP_FMT
+                " fails to satisfy 1<=value<=%" NPY_INTP_FMT
+                ". Result will be 0.\n", dim, rank);
+    }
+  va_end(argp);
+  return sz;
+}
+
+/*********************************************/
+/* Compatibility functions for Python >= 3.0 */
+/*********************************************/
+
+PyObject *
+F2PyCapsule_FromVoidPtr(void *ptr, void (*dtor)(PyObject *))
+{
+    PyObject *ret = PyCapsule_New(ptr, NULL, dtor);
+    if (ret == NULL) {
+        PyErr_Clear();
+    }
+    return ret;
+}
+
+void *
+F2PyCapsule_AsVoidPtr(PyObject *obj)
+{
+    void *ret = PyCapsule_GetPointer(obj, NULL);
+    if (ret == NULL) {
+        PyErr_Clear();
+    }
+    return ret;
+}
+
+int
+F2PyCapsule_Check(PyObject *ptr)
+{
+    return PyCapsule_CheckExact(ptr);
+}
+
+#ifdef __cplusplus
+}
+#endif
+/************************* EOF fortranobject.c *******************************/
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/src/fortranobject.h b/venv/lib/python3.12/site-packages/numpy/f2py/src/fortranobject.h
new file mode 100644
index 00000000..4aed2f60
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/src/fortranobject.h
@@ -0,0 +1,173 @@
+#ifndef Py_FORTRANOBJECT_H
+#define Py_FORTRANOBJECT_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include 
+
+#ifndef NPY_NO_DEPRECATED_API
+#define NPY_NO_DEPRECATED_API NPY_API_VERSION
+#endif
+#ifdef FORTRANOBJECT_C
+#define NO_IMPORT_ARRAY
+#endif
+#define PY_ARRAY_UNIQUE_SYMBOL _npy_f2py_ARRAY_API
+#include "numpy/arrayobject.h"
+#include "numpy/npy_3kcompat.h"
+
+#ifdef F2PY_REPORT_ATEXIT
+#include 
+// clang-format off
+extern void f2py_start_clock(void);
+extern void f2py_stop_clock(void);
+extern void f2py_start_call_clock(void);
+extern void f2py_stop_call_clock(void);
+extern void f2py_cb_start_clock(void);
+extern void f2py_cb_stop_clock(void);
+extern void f2py_cb_start_call_clock(void);
+extern void f2py_cb_stop_call_clock(void);
+extern void f2py_report_on_exit(int, void *);
+// clang-format on
+#endif
+
+#ifdef DMALLOC
+#include "dmalloc.h"
+#endif
+
+/* Fortran object interface */
+
+/*
+123456789-123456789-123456789-123456789-123456789-123456789-123456789-12
+
+PyFortranObject represents various Fortran objects:
+Fortran (module) routines, COMMON blocks, module data.
+
+Author: Pearu Peterson 
+*/
+
+#define F2PY_MAX_DIMS 40
+#define F2PY_MESSAGE_BUFFER_SIZE 300  // Increase on "stack smashing detected"
+
+typedef void (*f2py_set_data_func)(char *, npy_intp *);
+typedef void (*f2py_void_func)(void);
+typedef void (*f2py_init_func)(int *, npy_intp *, f2py_set_data_func, int *);
+
+/*typedef void* (*f2py_c_func)(void*,...);*/
+
+typedef void *(*f2pycfunc)(void);
+
+typedef struct {
+    char *name; /* attribute (array||routine) name */
+    int rank;   /* array rank, 0 for scalar, max is F2PY_MAX_DIMS,
+                   || rank=-1 for Fortran routine */
+    struct {
+        npy_intp d[F2PY_MAX_DIMS];
+    } dims;              /* dimensions of the array, || not used */
+    int type;            /* PyArray_ || not used */
+    int elsize;                /* Element size || not used */
+    char *data;          /* pointer to array || Fortran routine */
+    f2py_init_func func; /* initialization function for
+                            allocatable arrays:
+                            func(&rank,dims,set_ptr_func,name,len(name))
+                            || C/API wrapper for Fortran routine */
+    char *doc;           /* documentation string; only recommended
+                            for routines. */
+} FortranDataDef;
+
+typedef struct {
+    PyObject_HEAD
+    int len;              /* Number of attributes */
+    FortranDataDef *defs; /* An array of FortranDataDef's */
+    PyObject *dict;       /* Fortran object attribute dictionary */
+} PyFortranObject;
+
+#define PyFortran_Check(op) (Py_TYPE(op) == &PyFortran_Type)
+#define PyFortran_Check1(op) (0 == strcmp(Py_TYPE(op)->tp_name, "fortran"))
+
+extern PyTypeObject PyFortran_Type;
+extern int
+F2PyDict_SetItemString(PyObject *dict, char *name, PyObject *obj);
+extern PyObject *
+PyFortranObject_New(FortranDataDef *defs, f2py_void_func init);
+extern PyObject *
+PyFortranObject_NewAsAttr(FortranDataDef *defs);
+
+PyObject *
+F2PyCapsule_FromVoidPtr(void *ptr, void (*dtor)(PyObject *));
+void *
+F2PyCapsule_AsVoidPtr(PyObject *obj);
+int
+F2PyCapsule_Check(PyObject *ptr);
+
+extern void *
+F2PySwapThreadLocalCallbackPtr(char *key, void *ptr);
+extern void *
+F2PyGetThreadLocalCallbackPtr(char *key);
+
+#define ISCONTIGUOUS(m) (PyArray_FLAGS(m) & NPY_ARRAY_C_CONTIGUOUS)
+#define F2PY_INTENT_IN 1
+#define F2PY_INTENT_INOUT 2
+#define F2PY_INTENT_OUT 4
+#define F2PY_INTENT_HIDE 8
+#define F2PY_INTENT_CACHE 16
+#define F2PY_INTENT_COPY 32
+#define F2PY_INTENT_C 64
+#define F2PY_OPTIONAL 128
+#define F2PY_INTENT_INPLACE 256
+#define F2PY_INTENT_ALIGNED4 512
+#define F2PY_INTENT_ALIGNED8 1024
+#define F2PY_INTENT_ALIGNED16 2048
+
+#define ARRAY_ISALIGNED(ARR, SIZE) ((size_t)(PyArray_DATA(ARR)) % (SIZE) == 0)
+#define F2PY_ALIGN4(intent) (intent & F2PY_INTENT_ALIGNED4)
+#define F2PY_ALIGN8(intent) (intent & F2PY_INTENT_ALIGNED8)
+#define F2PY_ALIGN16(intent) (intent & F2PY_INTENT_ALIGNED16)
+
+#define F2PY_GET_ALIGNMENT(intent) \
+    (F2PY_ALIGN4(intent)           \
+             ? 4                   \
+             : (F2PY_ALIGN8(intent) ? 8 : (F2PY_ALIGN16(intent) ? 16 : 1)))
+#define F2PY_CHECK_ALIGNMENT(arr, intent) \
+    ARRAY_ISALIGNED(arr, F2PY_GET_ALIGNMENT(intent))
+#define F2PY_ARRAY_IS_CHARACTER_COMPATIBLE(arr) ((PyArray_DESCR(arr)->type_num == NPY_STRING && PyArray_ITEMSIZE(arr) >= 1) \
+                                                 || PyArray_DESCR(arr)->type_num == NPY_UINT8)
+#define F2PY_IS_UNICODE_ARRAY(arr) (PyArray_DESCR(arr)->type_num == NPY_UNICODE)
+
+extern PyArrayObject *
+ndarray_from_pyobj(const int type_num, const int elsize_, npy_intp *dims,
+                   const int rank, const int intent, PyObject *obj,
+                   const char *errmess);
+
+extern PyArrayObject *
+array_from_pyobj(const int type_num, npy_intp *dims, const int rank,
+                 const int intent, PyObject *obj);
+extern int
+copy_ND_array(const PyArrayObject *in, PyArrayObject *out);
+
+#ifdef DEBUG_COPY_ND_ARRAY
+extern void
+dump_attrs(const PyArrayObject *arr);
+#endif
+
+  extern int f2py_describe(PyObject *obj, char *buf);
+
+  /* Utility CPP macros and functions that can be used in signature file
+     expressions. See signature-file.rst for documentation.
+  */
+
+#define f2py_itemsize(var) (PyArray_ITEMSIZE(capi_ ## var ## _as_array))
+#define f2py_size(var, ...) f2py_size_impl((PyArrayObject *)(capi_ ## var ## _as_array), ## __VA_ARGS__, -1)
+#define f2py_rank(var) var ## _Rank
+#define f2py_shape(var,dim) var ## _Dims[dim]
+#define f2py_len(var) f2py_shape(var,0)
+#define f2py_fshape(var,dim) f2py_shape(var,rank(var)-dim-1)
+#define f2py_flen(var) f2py_fshape(var,0)
+#define f2py_slen(var) capi_ ## var ## _len
+
+  extern npy_intp f2py_size_impl(PyArrayObject* var, ...);
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_FORTRANOBJECT_H */
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/symbolic.py b/venv/lib/python3.12/site-packages/numpy/f2py/symbolic.py
new file mode 100644
index 00000000..6884a473
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/symbolic.py
@@ -0,0 +1,1517 @@
+"""Fortran/C symbolic expressions
+
+References:
+- J3/21-007: Draft Fortran 202x. https://j3-fortran.org/doc/year/21/21-007.pdf
+
+Copyright 1999 -- 2011 Pearu Peterson all rights reserved.
+Copyright 2011 -- present NumPy Developers.
+Permission to use, modify, and distribute this software is given under the
+terms of the NumPy License.
+
+NO WARRANTY IS EXPRESSED OR IMPLIED.  USE AT YOUR OWN RISK.
+"""
+
+# To analyze Fortran expressions to solve dimensions specifications,
+# for instances, we implement a minimal symbolic engine for parsing
+# expressions into a tree of expression instances. As a first
+# instance, we care only about arithmetic expressions involving
+# integers and operations like addition (+), subtraction (-),
+# multiplication (*), division (Fortran / is Python //, Fortran // is
+# concatenate), and exponentiation (**).  In addition, .pyf files may
+# contain C expressions that support here is implemented as well.
+#
+# TODO: support logical constants (Op.BOOLEAN)
+# TODO: support logical operators (.AND., ...)
+# TODO: support defined operators (.MYOP., ...)
+#
+__all__ = ['Expr']
+
+
+import re
+import warnings
+from enum import Enum
+from math import gcd
+
+
+class Language(Enum):
+    """
+    Used as Expr.tostring language argument.
+    """
+    Python = 0
+    Fortran = 1
+    C = 2
+
+
+class Op(Enum):
+    """
+    Used as Expr op attribute.
+    """
+    INTEGER = 10
+    REAL = 12
+    COMPLEX = 15
+    STRING = 20
+    ARRAY = 30
+    SYMBOL = 40
+    TERNARY = 100
+    APPLY = 200
+    INDEXING = 210
+    CONCAT = 220
+    RELATIONAL = 300
+    TERMS = 1000
+    FACTORS = 2000
+    REF = 3000
+    DEREF = 3001
+
+
+class RelOp(Enum):
+    """
+    Used in Op.RELATIONAL expression to specify the function part.
+    """
+    EQ = 1
+    NE = 2
+    LT = 3
+    LE = 4
+    GT = 5
+    GE = 6
+
+    @classmethod
+    def fromstring(cls, s, language=Language.C):
+        if language is Language.Fortran:
+            return {'.eq.': RelOp.EQ, '.ne.': RelOp.NE,
+                    '.lt.': RelOp.LT, '.le.': RelOp.LE,
+                    '.gt.': RelOp.GT, '.ge.': RelOp.GE}[s.lower()]
+        return {'==': RelOp.EQ, '!=': RelOp.NE, '<': RelOp.LT,
+                '<=': RelOp.LE, '>': RelOp.GT, '>=': RelOp.GE}[s]
+
+    def tostring(self, language=Language.C):
+        if language is Language.Fortran:
+            return {RelOp.EQ: '.eq.', RelOp.NE: '.ne.',
+                    RelOp.LT: '.lt.', RelOp.LE: '.le.',
+                    RelOp.GT: '.gt.', RelOp.GE: '.ge.'}[self]
+        return {RelOp.EQ: '==', RelOp.NE: '!=',
+                RelOp.LT: '<', RelOp.LE: '<=',
+                RelOp.GT: '>', RelOp.GE: '>='}[self]
+
+
+class ArithOp(Enum):
+    """
+    Used in Op.APPLY expression to specify the function part.
+    """
+    POS = 1
+    NEG = 2
+    ADD = 3
+    SUB = 4
+    MUL = 5
+    DIV = 6
+    POW = 7
+
+
+class OpError(Exception):
+    pass
+
+
+class Precedence(Enum):
+    """
+    Used as Expr.tostring precedence argument.
+    """
+    ATOM = 0
+    POWER = 1
+    UNARY = 2
+    PRODUCT = 3
+    SUM = 4
+    LT = 6
+    EQ = 7
+    LAND = 11
+    LOR = 12
+    TERNARY = 13
+    ASSIGN = 14
+    TUPLE = 15
+    NONE = 100
+
+
+integer_types = (int,)
+number_types = (int, float)
+
+
+def _pairs_add(d, k, v):
+    # Internal utility method for updating terms and factors data.
+    c = d.get(k)
+    if c is None:
+        d[k] = v
+    else:
+        c = c + v
+        if c:
+            d[k] = c
+        else:
+            del d[k]
+
+
+class ExprWarning(UserWarning):
+    pass
+
+
+def ewarn(message):
+    warnings.warn(message, ExprWarning, stacklevel=2)
+
+
+class Expr:
+    """Represents a Fortran expression as a op-data pair.
+
+    Expr instances are hashable and sortable.
+    """
+
+    @staticmethod
+    def parse(s, language=Language.C):
+        """Parse a Fortran expression to a Expr.
+        """
+        return fromstring(s, language=language)
+
+    def __init__(self, op, data):
+        assert isinstance(op, Op)
+
+        # sanity checks
+        if op is Op.INTEGER:
+            # data is a 2-tuple of numeric object and a kind value
+            # (default is 4)
+            assert isinstance(data, tuple) and len(data) == 2
+            assert isinstance(data[0], int)
+            assert isinstance(data[1], (int, str)), data
+        elif op is Op.REAL:
+            # data is a 2-tuple of numeric object and a kind value
+            # (default is 4)
+            assert isinstance(data, tuple) and len(data) == 2
+            assert isinstance(data[0], float)
+            assert isinstance(data[1], (int, str)), data
+        elif op is Op.COMPLEX:
+            # data is a 2-tuple of constant expressions
+            assert isinstance(data, tuple) and len(data) == 2
+        elif op is Op.STRING:
+            # data is a 2-tuple of quoted string and a kind value
+            # (default is 1)
+            assert isinstance(data, tuple) and len(data) == 2
+            assert (isinstance(data[0], str)
+                    and data[0][::len(data[0])-1] in ('""', "''", '@@'))
+            assert isinstance(data[1], (int, str)), data
+        elif op is Op.SYMBOL:
+            # data is any hashable object
+            assert hash(data) is not None
+        elif op in (Op.ARRAY, Op.CONCAT):
+            # data is a tuple of expressions
+            assert isinstance(data, tuple)
+            assert all(isinstance(item, Expr) for item in data), data
+        elif op in (Op.TERMS, Op.FACTORS):
+            # data is {:} where dict values
+            # are nonzero Python integers
+            assert isinstance(data, dict)
+        elif op is Op.APPLY:
+            # data is (, , ) where
+            # operands are Expr instances
+            assert isinstance(data, tuple) and len(data) == 3
+            # function is any hashable object
+            assert hash(data[0]) is not None
+            assert isinstance(data[1], tuple)
+            assert isinstance(data[2], dict)
+        elif op is Op.INDEXING:
+            # data is (, )
+            assert isinstance(data, tuple) and len(data) == 2
+            # function is any hashable object
+            assert hash(data[0]) is not None
+        elif op is Op.TERNARY:
+            # data is (, , )
+            assert isinstance(data, tuple) and len(data) == 3
+        elif op in (Op.REF, Op.DEREF):
+            # data is Expr instance
+            assert isinstance(data, Expr)
+        elif op is Op.RELATIONAL:
+            # data is (, , )
+            assert isinstance(data, tuple) and len(data) == 3
+        else:
+            raise NotImplementedError(
+                f'unknown op or missing sanity check: {op}')
+
+        self.op = op
+        self.data = data
+
+    def __eq__(self, other):
+        return (isinstance(other, Expr)
+                and self.op is other.op
+                and self.data == other.data)
+
+    def __hash__(self):
+        if self.op in (Op.TERMS, Op.FACTORS):
+            data = tuple(sorted(self.data.items()))
+        elif self.op is Op.APPLY:
+            data = self.data[:2] + tuple(sorted(self.data[2].items()))
+        else:
+            data = self.data
+        return hash((self.op, data))
+
+    def __lt__(self, other):
+        if isinstance(other, Expr):
+            if self.op is not other.op:
+                return self.op.value < other.op.value
+            if self.op in (Op.TERMS, Op.FACTORS):
+                return (tuple(sorted(self.data.items()))
+                        < tuple(sorted(other.data.items())))
+            if self.op is Op.APPLY:
+                if self.data[:2] != other.data[:2]:
+                    return self.data[:2] < other.data[:2]
+                return tuple(sorted(self.data[2].items())) < tuple(
+                    sorted(other.data[2].items()))
+            return self.data < other.data
+        return NotImplemented
+
+    def __le__(self, other): return self == other or self < other
+
+    def __gt__(self, other): return not (self <= other)
+
+    def __ge__(self, other): return not (self < other)
+
+    def __repr__(self):
+        return f'{type(self).__name__}({self.op}, {self.data!r})'
+
+    def __str__(self):
+        return self.tostring()
+
+    def tostring(self, parent_precedence=Precedence.NONE,
+                 language=Language.Fortran):
+        """Return a string representation of Expr.
+        """
+        if self.op in (Op.INTEGER, Op.REAL):
+            precedence = (Precedence.SUM if self.data[0] < 0
+                          else Precedence.ATOM)
+            r = str(self.data[0]) + (f'_{self.data[1]}'
+                                     if self.data[1] != 4 else '')
+        elif self.op is Op.COMPLEX:
+            r = ', '.join(item.tostring(Precedence.TUPLE, language=language)
+                          for item in self.data)
+            r = '(' + r + ')'
+            precedence = Precedence.ATOM
+        elif self.op is Op.SYMBOL:
+            precedence = Precedence.ATOM
+            r = str(self.data)
+        elif self.op is Op.STRING:
+            r = self.data[0]
+            if self.data[1] != 1:
+                r = self.data[1] + '_' + r
+            precedence = Precedence.ATOM
+        elif self.op is Op.ARRAY:
+            r = ', '.join(item.tostring(Precedence.TUPLE, language=language)
+                          for item in self.data)
+            r = '[' + r + ']'
+            precedence = Precedence.ATOM
+        elif self.op is Op.TERMS:
+            terms = []
+            for term, coeff in sorted(self.data.items()):
+                if coeff < 0:
+                    op = ' - '
+                    coeff = -coeff
+                else:
+                    op = ' + '
+                if coeff == 1:
+                    term = term.tostring(Precedence.SUM, language=language)
+                else:
+                    if term == as_number(1):
+                        term = str(coeff)
+                    else:
+                        term = f'{coeff} * ' + term.tostring(
+                            Precedence.PRODUCT, language=language)
+                if terms:
+                    terms.append(op)
+                elif op == ' - ':
+                    terms.append('-')
+                terms.append(term)
+            r = ''.join(terms) or '0'
+            precedence = Precedence.SUM if terms else Precedence.ATOM
+        elif self.op is Op.FACTORS:
+            factors = []
+            tail = []
+            for base, exp in sorted(self.data.items()):
+                op = ' * '
+                if exp == 1:
+                    factor = base.tostring(Precedence.PRODUCT,
+                                           language=language)
+                elif language is Language.C:
+                    if exp in range(2, 10):
+                        factor = base.tostring(Precedence.PRODUCT,
+                                               language=language)
+                        factor = ' * '.join([factor] * exp)
+                    elif exp in range(-10, 0):
+                        factor = base.tostring(Precedence.PRODUCT,
+                                               language=language)
+                        tail += [factor] * -exp
+                        continue
+                    else:
+                        factor = base.tostring(Precedence.TUPLE,
+                                               language=language)
+                        factor = f'pow({factor}, {exp})'
+                else:
+                    factor = base.tostring(Precedence.POWER,
+                                           language=language) + f' ** {exp}'
+                if factors:
+                    factors.append(op)
+                factors.append(factor)
+            if tail:
+                if not factors:
+                    factors += ['1']
+                factors += ['/', '(', ' * '.join(tail), ')']
+            r = ''.join(factors) or '1'
+            precedence = Precedence.PRODUCT if factors else Precedence.ATOM
+        elif self.op is Op.APPLY:
+            name, args, kwargs = self.data
+            if name is ArithOp.DIV and language is Language.C:
+                numer, denom = [arg.tostring(Precedence.PRODUCT,
+                                             language=language)
+                                for arg in args]
+                r = f'{numer} / {denom}'
+                precedence = Precedence.PRODUCT
+            else:
+                args = [arg.tostring(Precedence.TUPLE, language=language)
+                        for arg in args]
+                args += [k + '=' + v.tostring(Precedence.NONE)
+                         for k, v in kwargs.items()]
+                r = f'{name}({", ".join(args)})'
+                precedence = Precedence.ATOM
+        elif self.op is Op.INDEXING:
+            name = self.data[0]
+            args = [arg.tostring(Precedence.TUPLE, language=language)
+                    for arg in self.data[1:]]
+            r = f'{name}[{", ".join(args)}]'
+            precedence = Precedence.ATOM
+        elif self.op is Op.CONCAT:
+            args = [arg.tostring(Precedence.PRODUCT, language=language)
+                    for arg in self.data]
+            r = " // ".join(args)
+            precedence = Precedence.PRODUCT
+        elif self.op is Op.TERNARY:
+            cond, expr1, expr2 = [a.tostring(Precedence.TUPLE,
+                                             language=language)
+                                  for a in self.data]
+            if language is Language.C:
+                r = f'({cond}?{expr1}:{expr2})'
+            elif language is Language.Python:
+                r = f'({expr1} if {cond} else {expr2})'
+            elif language is Language.Fortran:
+                r = f'merge({expr1}, {expr2}, {cond})'
+            else:
+                raise NotImplementedError(
+                    f'tostring for {self.op} and {language}')
+            precedence = Precedence.ATOM
+        elif self.op is Op.REF:
+            r = '&' + self.data.tostring(Precedence.UNARY, language=language)
+            precedence = Precedence.UNARY
+        elif self.op is Op.DEREF:
+            r = '*' + self.data.tostring(Precedence.UNARY, language=language)
+            precedence = Precedence.UNARY
+        elif self.op is Op.RELATIONAL:
+            rop, left, right = self.data
+            precedence = (Precedence.EQ if rop in (RelOp.EQ, RelOp.NE)
+                          else Precedence.LT)
+            left = left.tostring(precedence, language=language)
+            right = right.tostring(precedence, language=language)
+            rop = rop.tostring(language=language)
+            r = f'{left} {rop} {right}'
+        else:
+            raise NotImplementedError(f'tostring for op {self.op}')
+        if parent_precedence.value < precedence.value:
+            # If parent precedence is higher than operand precedence,
+            # operand will be enclosed in parenthesis.
+            return '(' + r + ')'
+        return r
+
+    def __pos__(self):
+        return self
+
+    def __neg__(self):
+        return self * -1
+
+    def __add__(self, other):
+        other = as_expr(other)
+        if isinstance(other, Expr):
+            if self.op is other.op:
+                if self.op in (Op.INTEGER, Op.REAL):
+                    return as_number(
+                        self.data[0] + other.data[0],
+                        max(self.data[1], other.data[1]))
+                if self.op is Op.COMPLEX:
+                    r1, i1 = self.data
+                    r2, i2 = other.data
+                    return as_complex(r1 + r2, i1 + i2)
+                if self.op is Op.TERMS:
+                    r = Expr(self.op, dict(self.data))
+                    for k, v in other.data.items():
+                        _pairs_add(r.data, k, v)
+                    return normalize(r)
+            if self.op is Op.COMPLEX and other.op in (Op.INTEGER, Op.REAL):
+                return self + as_complex(other)
+            elif self.op in (Op.INTEGER, Op.REAL) and other.op is Op.COMPLEX:
+                return as_complex(self) + other
+            elif self.op is Op.REAL and other.op is Op.INTEGER:
+                return self + as_real(other, kind=self.data[1])
+            elif self.op is Op.INTEGER and other.op is Op.REAL:
+                return as_real(self, kind=other.data[1]) + other
+            return as_terms(self) + as_terms(other)
+        return NotImplemented
+
+    def __radd__(self, other):
+        if isinstance(other, number_types):
+            return as_number(other) + self
+        return NotImplemented
+
+    def __sub__(self, other):
+        return self + (-other)
+
+    def __rsub__(self, other):
+        if isinstance(other, number_types):
+            return as_number(other) - self
+        return NotImplemented
+
+    def __mul__(self, other):
+        other = as_expr(other)
+        if isinstance(other, Expr):
+            if self.op is other.op:
+                if self.op in (Op.INTEGER, Op.REAL):
+                    return as_number(self.data[0] * other.data[0],
+                                     max(self.data[1], other.data[1]))
+                elif self.op is Op.COMPLEX:
+                    r1, i1 = self.data
+                    r2, i2 = other.data
+                    return as_complex(r1 * r2 - i1 * i2, r1 * i2 + r2 * i1)
+
+                if self.op is Op.FACTORS:
+                    r = Expr(self.op, dict(self.data))
+                    for k, v in other.data.items():
+                        _pairs_add(r.data, k, v)
+                    return normalize(r)
+                elif self.op is Op.TERMS:
+                    r = Expr(self.op, {})
+                    for t1, c1 in self.data.items():
+                        for t2, c2 in other.data.items():
+                            _pairs_add(r.data, t1 * t2, c1 * c2)
+                    return normalize(r)
+
+            if self.op is Op.COMPLEX and other.op in (Op.INTEGER, Op.REAL):
+                return self * as_complex(other)
+            elif other.op is Op.COMPLEX and self.op in (Op.INTEGER, Op.REAL):
+                return as_complex(self) * other
+            elif self.op is Op.REAL and other.op is Op.INTEGER:
+                return self * as_real(other, kind=self.data[1])
+            elif self.op is Op.INTEGER and other.op is Op.REAL:
+                return as_real(self, kind=other.data[1]) * other
+
+            if self.op is Op.TERMS:
+                return self * as_terms(other)
+            elif other.op is Op.TERMS:
+                return as_terms(self) * other
+
+            return as_factors(self) * as_factors(other)
+        return NotImplemented
+
+    def __rmul__(self, other):
+        if isinstance(other, number_types):
+            return as_number(other) * self
+        return NotImplemented
+
+    def __pow__(self, other):
+        other = as_expr(other)
+        if isinstance(other, Expr):
+            if other.op is Op.INTEGER:
+                exponent = other.data[0]
+                # TODO: other kind not used
+                if exponent == 0:
+                    return as_number(1)
+                if exponent == 1:
+                    return self
+                if exponent > 0:
+                    if self.op is Op.FACTORS:
+                        r = Expr(self.op, {})
+                        for k, v in self.data.items():
+                            r.data[k] = v * exponent
+                        return normalize(r)
+                    return self * (self ** (exponent - 1))
+                elif exponent != -1:
+                    return (self ** (-exponent)) ** -1
+                return Expr(Op.FACTORS, {self: exponent})
+            return as_apply(ArithOp.POW, self, other)
+        return NotImplemented
+
+    def __truediv__(self, other):
+        other = as_expr(other)
+        if isinstance(other, Expr):
+            # Fortran / is different from Python /:
+            # - `/` is a truncate operation for integer operands
+            return normalize(as_apply(ArithOp.DIV, self, other))
+        return NotImplemented
+
+    def __rtruediv__(self, other):
+        other = as_expr(other)
+        if isinstance(other, Expr):
+            return other / self
+        return NotImplemented
+
+    def __floordiv__(self, other):
+        other = as_expr(other)
+        if isinstance(other, Expr):
+            # Fortran // is different from Python //:
+            # - `//` is a concatenate operation for string operands
+            return normalize(Expr(Op.CONCAT, (self, other)))
+        return NotImplemented
+
+    def __rfloordiv__(self, other):
+        other = as_expr(other)
+        if isinstance(other, Expr):
+            return other // self
+        return NotImplemented
+
+    def __call__(self, *args, **kwargs):
+        # In Fortran, parenthesis () are use for both function call as
+        # well as indexing operations.
+        #
+        # TODO: implement a method for deciding when __call__ should
+        # return an INDEXING expression.
+        return as_apply(self, *map(as_expr, args),
+                        **dict((k, as_expr(v)) for k, v in kwargs.items()))
+
+    def __getitem__(self, index):
+        # Provided to support C indexing operations that .pyf files
+        # may contain.
+        index = as_expr(index)
+        if not isinstance(index, tuple):
+            index = index,
+        if len(index) > 1:
+            ewarn(f'C-index should be a single expression but got `{index}`')
+        return Expr(Op.INDEXING, (self,) + index)
+
+    def substitute(self, symbols_map):
+        """Recursively substitute symbols with values in symbols map.
+
+        Symbols map is a dictionary of symbol-expression pairs.
+        """
+        if self.op is Op.SYMBOL:
+            value = symbols_map.get(self)
+            if value is None:
+                return self
+            m = re.match(r'\A(@__f2py_PARENTHESIS_(\w+)_\d+@)\Z', self.data)
+            if m:
+                # complement to fromstring method
+                items, paren = m.groups()
+                if paren in ['ROUNDDIV', 'SQUARE']:
+                    return as_array(value)
+                assert paren == 'ROUND', (paren, value)
+            return value
+        if self.op in (Op.INTEGER, Op.REAL, Op.STRING):
+            return self
+        if self.op in (Op.ARRAY, Op.COMPLEX):
+            return Expr(self.op, tuple(item.substitute(symbols_map)
+                                       for item in self.data))
+        if self.op is Op.CONCAT:
+            return normalize(Expr(self.op, tuple(item.substitute(symbols_map)
+                                                 for item in self.data)))
+        if self.op is Op.TERMS:
+            r = None
+            for term, coeff in self.data.items():
+                if r is None:
+                    r = term.substitute(symbols_map) * coeff
+                else:
+                    r += term.substitute(symbols_map) * coeff
+            if r is None:
+                ewarn('substitute: empty TERMS expression interpreted as'
+                      ' int-literal 0')
+                return as_number(0)
+            return r
+        if self.op is Op.FACTORS:
+            r = None
+            for base, exponent in self.data.items():
+                if r is None:
+                    r = base.substitute(symbols_map) ** exponent
+                else:
+                    r *= base.substitute(symbols_map) ** exponent
+            if r is None:
+                ewarn('substitute: empty FACTORS expression interpreted'
+                      ' as int-literal 1')
+                return as_number(1)
+            return r
+        if self.op is Op.APPLY:
+            target, args, kwargs = self.data
+            if isinstance(target, Expr):
+                target = target.substitute(symbols_map)
+            args = tuple(a.substitute(symbols_map) for a in args)
+            kwargs = dict((k, v.substitute(symbols_map))
+                          for k, v in kwargs.items())
+            return normalize(Expr(self.op, (target, args, kwargs)))
+        if self.op is Op.INDEXING:
+            func = self.data[0]
+            if isinstance(func, Expr):
+                func = func.substitute(symbols_map)
+            args = tuple(a.substitute(symbols_map) for a in self.data[1:])
+            return normalize(Expr(self.op, (func,) + args))
+        if self.op is Op.TERNARY:
+            operands = tuple(a.substitute(symbols_map) for a in self.data)
+            return normalize(Expr(self.op, operands))
+        if self.op in (Op.REF, Op.DEREF):
+            return normalize(Expr(self.op, self.data.substitute(symbols_map)))
+        if self.op is Op.RELATIONAL:
+            rop, left, right = self.data
+            left = left.substitute(symbols_map)
+            right = right.substitute(symbols_map)
+            return normalize(Expr(self.op, (rop, left, right)))
+        raise NotImplementedError(f'substitute method for {self.op}: {self!r}')
+
+    def traverse(self, visit, *args, **kwargs):
+        """Traverse expression tree with visit function.
+
+        The visit function is applied to an expression with given args
+        and kwargs.
+
+        Traverse call returns an expression returned by visit when not
+        None, otherwise return a new normalized expression with
+        traverse-visit sub-expressions.
+        """
+        result = visit(self, *args, **kwargs)
+        if result is not None:
+            return result
+
+        if self.op in (Op.INTEGER, Op.REAL, Op.STRING, Op.SYMBOL):
+            return self
+        elif self.op in (Op.COMPLEX, Op.ARRAY, Op.CONCAT, Op.TERNARY):
+            return normalize(Expr(self.op, tuple(
+                item.traverse(visit, *args, **kwargs)
+                for item in self.data)))
+        elif self.op in (Op.TERMS, Op.FACTORS):
+            data = {}
+            for k, v in self.data.items():
+                k = k.traverse(visit, *args, **kwargs)
+                v = (v.traverse(visit, *args, **kwargs)
+                     if isinstance(v, Expr) else v)
+                if k in data:
+                    v = data[k] + v
+                data[k] = v
+            return normalize(Expr(self.op, data))
+        elif self.op is Op.APPLY:
+            obj = self.data[0]
+            func = (obj.traverse(visit, *args, **kwargs)
+                    if isinstance(obj, Expr) else obj)
+            operands = tuple(operand.traverse(visit, *args, **kwargs)
+                             for operand in self.data[1])
+            kwoperands = dict((k, v.traverse(visit, *args, **kwargs))
+                              for k, v in self.data[2].items())
+            return normalize(Expr(self.op, (func, operands, kwoperands)))
+        elif self.op is Op.INDEXING:
+            obj = self.data[0]
+            obj = (obj.traverse(visit, *args, **kwargs)
+                   if isinstance(obj, Expr) else obj)
+            indices = tuple(index.traverse(visit, *args, **kwargs)
+                            for index in self.data[1:])
+            return normalize(Expr(self.op, (obj,) + indices))
+        elif self.op in (Op.REF, Op.DEREF):
+            return normalize(Expr(self.op,
+                                  self.data.traverse(visit, *args, **kwargs)))
+        elif self.op is Op.RELATIONAL:
+            rop, left, right = self.data
+            left = left.traverse(visit, *args, **kwargs)
+            right = right.traverse(visit, *args, **kwargs)
+            return normalize(Expr(self.op, (rop, left, right)))
+        raise NotImplementedError(f'traverse method for {self.op}')
+
+    def contains(self, other):
+        """Check if self contains other.
+        """
+        found = []
+
+        def visit(expr, found=found):
+            if found:
+                return expr
+            elif expr == other:
+                found.append(1)
+                return expr
+
+        self.traverse(visit)
+
+        return len(found) != 0
+
+    def symbols(self):
+        """Return a set of symbols contained in self.
+        """
+        found = set()
+
+        def visit(expr, found=found):
+            if expr.op is Op.SYMBOL:
+                found.add(expr)
+
+        self.traverse(visit)
+
+        return found
+
+    def polynomial_atoms(self):
+        """Return a set of expressions used as atoms in polynomial self.
+        """
+        found = set()
+
+        def visit(expr, found=found):
+            if expr.op is Op.FACTORS:
+                for b in expr.data:
+                    b.traverse(visit)
+                return expr
+            if expr.op in (Op.TERMS, Op.COMPLEX):
+                return
+            if expr.op is Op.APPLY and isinstance(expr.data[0], ArithOp):
+                if expr.data[0] is ArithOp.POW:
+                    expr.data[1][0].traverse(visit)
+                    return expr
+                return
+            if expr.op in (Op.INTEGER, Op.REAL):
+                return expr
+
+            found.add(expr)
+
+            if expr.op in (Op.INDEXING, Op.APPLY):
+                return expr
+
+        self.traverse(visit)
+
+        return found
+
+    def linear_solve(self, symbol):
+        """Return a, b such that a * symbol + b == self.
+
+        If self is not linear with respect to symbol, raise RuntimeError.
+        """
+        b = self.substitute({symbol: as_number(0)})
+        ax = self - b
+        a = ax.substitute({symbol: as_number(1)})
+
+        zero, _ = as_numer_denom(a * symbol - ax)
+
+        if zero != as_number(0):
+            raise RuntimeError(f'not a {symbol}-linear equation:'
+                               f' {a} * {symbol} + {b} == {self}')
+        return a, b
+
+
+def normalize(obj):
+    """Normalize Expr and apply basic evaluation methods.
+    """
+    if not isinstance(obj, Expr):
+        return obj
+
+    if obj.op is Op.TERMS:
+        d = {}
+        for t, c in obj.data.items():
+            if c == 0:
+                continue
+            if t.op is Op.COMPLEX and c != 1:
+                t = t * c
+                c = 1
+            if t.op is Op.TERMS:
+                for t1, c1 in t.data.items():
+                    _pairs_add(d, t1, c1 * c)
+            else:
+                _pairs_add(d, t, c)
+        if len(d) == 0:
+            # TODO: determine correct kind
+            return as_number(0)
+        elif len(d) == 1:
+            (t, c), = d.items()
+            if c == 1:
+                return t
+        return Expr(Op.TERMS, d)
+
+    if obj.op is Op.FACTORS:
+        coeff = 1
+        d = {}
+        for b, e in obj.data.items():
+            if e == 0:
+                continue
+            if b.op is Op.TERMS and isinstance(e, integer_types) and e > 1:
+                # expand integer powers of sums
+                b = b * (b ** (e - 1))
+                e = 1
+
+            if b.op in (Op.INTEGER, Op.REAL):
+                if e == 1:
+                    coeff *= b.data[0]
+                elif e > 0:
+                    coeff *= b.data[0] ** e
+                else:
+                    _pairs_add(d, b, e)
+            elif b.op is Op.FACTORS:
+                if e > 0 and isinstance(e, integer_types):
+                    for b1, e1 in b.data.items():
+                        _pairs_add(d, b1, e1 * e)
+                else:
+                    _pairs_add(d, b, e)
+            else:
+                _pairs_add(d, b, e)
+        if len(d) == 0 or coeff == 0:
+            # TODO: determine correct kind
+            assert isinstance(coeff, number_types)
+            return as_number(coeff)
+        elif len(d) == 1:
+            (b, e), = d.items()
+            if e == 1:
+                t = b
+            else:
+                t = Expr(Op.FACTORS, d)
+            if coeff == 1:
+                return t
+            return Expr(Op.TERMS, {t: coeff})
+        elif coeff == 1:
+            return Expr(Op.FACTORS, d)
+        else:
+            return Expr(Op.TERMS, {Expr(Op.FACTORS, d): coeff})
+
+    if obj.op is Op.APPLY and obj.data[0] is ArithOp.DIV:
+        dividend, divisor = obj.data[1]
+        t1, c1 = as_term_coeff(dividend)
+        t2, c2 = as_term_coeff(divisor)
+        if isinstance(c1, integer_types) and isinstance(c2, integer_types):
+            g = gcd(c1, c2)
+            c1, c2 = c1//g, c2//g
+        else:
+            c1, c2 = c1/c2, 1
+
+        if t1.op is Op.APPLY and t1.data[0] is ArithOp.DIV:
+            numer = t1.data[1][0] * c1
+            denom = t1.data[1][1] * t2 * c2
+            return as_apply(ArithOp.DIV, numer, denom)
+
+        if t2.op is Op.APPLY and t2.data[0] is ArithOp.DIV:
+            numer = t2.data[1][1] * t1 * c1
+            denom = t2.data[1][0] * c2
+            return as_apply(ArithOp.DIV, numer, denom)
+
+        d = dict(as_factors(t1).data)
+        for b, e in as_factors(t2).data.items():
+            _pairs_add(d, b, -e)
+        numer, denom = {}, {}
+        for b, e in d.items():
+            if e > 0:
+                numer[b] = e
+            else:
+                denom[b] = -e
+        numer = normalize(Expr(Op.FACTORS, numer)) * c1
+        denom = normalize(Expr(Op.FACTORS, denom)) * c2
+
+        if denom.op in (Op.INTEGER, Op.REAL) and denom.data[0] == 1:
+            # TODO: denom kind not used
+            return numer
+        return as_apply(ArithOp.DIV, numer, denom)
+
+    if obj.op is Op.CONCAT:
+        lst = [obj.data[0]]
+        for s in obj.data[1:]:
+            last = lst[-1]
+            if (
+                    last.op is Op.STRING
+                    and s.op is Op.STRING
+                    and last.data[0][0] in '"\''
+                    and s.data[0][0] == last.data[0][-1]
+            ):
+                new_last = as_string(last.data[0][:-1] + s.data[0][1:],
+                                     max(last.data[1], s.data[1]))
+                lst[-1] = new_last
+            else:
+                lst.append(s)
+        if len(lst) == 1:
+            return lst[0]
+        return Expr(Op.CONCAT, tuple(lst))
+
+    if obj.op is Op.TERNARY:
+        cond, expr1, expr2 = map(normalize, obj.data)
+        if cond.op is Op.INTEGER:
+            return expr1 if cond.data[0] else expr2
+        return Expr(Op.TERNARY, (cond, expr1, expr2))
+
+    return obj
+
+
+def as_expr(obj):
+    """Convert non-Expr objects to Expr objects.
+    """
+    if isinstance(obj, complex):
+        return as_complex(obj.real, obj.imag)
+    if isinstance(obj, number_types):
+        return as_number(obj)
+    if isinstance(obj, str):
+        # STRING expression holds string with boundary quotes, hence
+        # applying repr:
+        return as_string(repr(obj))
+    if isinstance(obj, tuple):
+        return tuple(map(as_expr, obj))
+    return obj
+
+
+def as_symbol(obj):
+    """Return object as SYMBOL expression (variable or unparsed expression).
+    """
+    return Expr(Op.SYMBOL, obj)
+
+
+def as_number(obj, kind=4):
+    """Return object as INTEGER or REAL constant.
+    """
+    if isinstance(obj, int):
+        return Expr(Op.INTEGER, (obj, kind))
+    if isinstance(obj, float):
+        return Expr(Op.REAL, (obj, kind))
+    if isinstance(obj, Expr):
+        if obj.op in (Op.INTEGER, Op.REAL):
+            return obj
+    raise OpError(f'cannot convert {obj} to INTEGER or REAL constant')
+
+
+def as_integer(obj, kind=4):
+    """Return object as INTEGER constant.
+    """
+    if isinstance(obj, int):
+        return Expr(Op.INTEGER, (obj, kind))
+    if isinstance(obj, Expr):
+        if obj.op is Op.INTEGER:
+            return obj
+    raise OpError(f'cannot convert {obj} to INTEGER constant')
+
+
+def as_real(obj, kind=4):
+    """Return object as REAL constant.
+    """
+    if isinstance(obj, int):
+        return Expr(Op.REAL, (float(obj), kind))
+    if isinstance(obj, float):
+        return Expr(Op.REAL, (obj, kind))
+    if isinstance(obj, Expr):
+        if obj.op is Op.REAL:
+            return obj
+        elif obj.op is Op.INTEGER:
+            return Expr(Op.REAL, (float(obj.data[0]), kind))
+    raise OpError(f'cannot convert {obj} to REAL constant')
+
+
+def as_string(obj, kind=1):
+    """Return object as STRING expression (string literal constant).
+    """
+    return Expr(Op.STRING, (obj, kind))
+
+
+def as_array(obj):
+    """Return object as ARRAY expression (array constant).
+    """
+    if isinstance(obj, Expr):
+        obj = obj,
+    return Expr(Op.ARRAY, obj)
+
+
+def as_complex(real, imag=0):
+    """Return object as COMPLEX expression (complex literal constant).
+    """
+    return Expr(Op.COMPLEX, (as_expr(real), as_expr(imag)))
+
+
+def as_apply(func, *args, **kwargs):
+    """Return object as APPLY expression (function call, constructor, etc.)
+    """
+    return Expr(Op.APPLY,
+                (func, tuple(map(as_expr, args)),
+                 dict((k, as_expr(v)) for k, v in kwargs.items())))
+
+
+def as_ternary(cond, expr1, expr2):
+    """Return object as TERNARY expression (cond?expr1:expr2).
+    """
+    return Expr(Op.TERNARY, (cond, expr1, expr2))
+
+
+def as_ref(expr):
+    """Return object as referencing expression.
+    """
+    return Expr(Op.REF, expr)
+
+
+def as_deref(expr):
+    """Return object as dereferencing expression.
+    """
+    return Expr(Op.DEREF, expr)
+
+
+def as_eq(left, right):
+    return Expr(Op.RELATIONAL, (RelOp.EQ, left, right))
+
+
+def as_ne(left, right):
+    return Expr(Op.RELATIONAL, (RelOp.NE, left, right))
+
+
+def as_lt(left, right):
+    return Expr(Op.RELATIONAL, (RelOp.LT, left, right))
+
+
+def as_le(left, right):
+    return Expr(Op.RELATIONAL, (RelOp.LE, left, right))
+
+
+def as_gt(left, right):
+    return Expr(Op.RELATIONAL, (RelOp.GT, left, right))
+
+
+def as_ge(left, right):
+    return Expr(Op.RELATIONAL, (RelOp.GE, left, right))
+
+
+def as_terms(obj):
+    """Return expression as TERMS expression.
+    """
+    if isinstance(obj, Expr):
+        obj = normalize(obj)
+        if obj.op is Op.TERMS:
+            return obj
+        if obj.op is Op.INTEGER:
+            return Expr(Op.TERMS, {as_integer(1, obj.data[1]): obj.data[0]})
+        if obj.op is Op.REAL:
+            return Expr(Op.TERMS, {as_real(1, obj.data[1]): obj.data[0]})
+        return Expr(Op.TERMS, {obj: 1})
+    raise OpError(f'cannot convert {type(obj)} to terms Expr')
+
+
+def as_factors(obj):
+    """Return expression as FACTORS expression.
+    """
+    if isinstance(obj, Expr):
+        obj = normalize(obj)
+        if obj.op is Op.FACTORS:
+            return obj
+        if obj.op is Op.TERMS:
+            if len(obj.data) == 1:
+                (term, coeff), = obj.data.items()
+                if coeff == 1:
+                    return Expr(Op.FACTORS, {term: 1})
+                return Expr(Op.FACTORS, {term: 1, Expr.number(coeff): 1})
+        if (obj.op is Op.APPLY
+             and obj.data[0] is ArithOp.DIV
+             and not obj.data[2]):
+            return Expr(Op.FACTORS, {obj.data[1][0]: 1, obj.data[1][1]: -1})
+        return Expr(Op.FACTORS, {obj: 1})
+    raise OpError(f'cannot convert {type(obj)} to terms Expr')
+
+
+def as_term_coeff(obj):
+    """Return expression as term-coefficient pair.
+    """
+    if isinstance(obj, Expr):
+        obj = normalize(obj)
+        if obj.op is Op.INTEGER:
+            return as_integer(1, obj.data[1]), obj.data[0]
+        if obj.op is Op.REAL:
+            return as_real(1, obj.data[1]), obj.data[0]
+        if obj.op is Op.TERMS:
+            if len(obj.data) == 1:
+                (term, coeff), = obj.data.items()
+                return term, coeff
+            # TODO: find common divisor of coefficients
+        if obj.op is Op.APPLY and obj.data[0] is ArithOp.DIV:
+            t, c = as_term_coeff(obj.data[1][0])
+            return as_apply(ArithOp.DIV, t, obj.data[1][1]), c
+        return obj, 1
+    raise OpError(f'cannot convert {type(obj)} to term and coeff')
+
+
+def as_numer_denom(obj):
+    """Return expression as numer-denom pair.
+    """
+    if isinstance(obj, Expr):
+        obj = normalize(obj)
+        if obj.op in (Op.INTEGER, Op.REAL, Op.COMPLEX, Op.SYMBOL,
+                      Op.INDEXING, Op.TERNARY):
+            return obj, as_number(1)
+        elif obj.op is Op.APPLY:
+            if obj.data[0] is ArithOp.DIV and not obj.data[2]:
+                numers, denoms = map(as_numer_denom, obj.data[1])
+                return numers[0] * denoms[1], numers[1] * denoms[0]
+            return obj, as_number(1)
+        elif obj.op is Op.TERMS:
+            numers, denoms = [], []
+            for term, coeff in obj.data.items():
+                n, d = as_numer_denom(term)
+                n = n * coeff
+                numers.append(n)
+                denoms.append(d)
+            numer, denom = as_number(0), as_number(1)
+            for i in range(len(numers)):
+                n = numers[i]
+                for j in range(len(numers)):
+                    if i != j:
+                        n *= denoms[j]
+                numer += n
+                denom *= denoms[i]
+            if denom.op in (Op.INTEGER, Op.REAL) and denom.data[0] < 0:
+                numer, denom = -numer, -denom
+            return numer, denom
+        elif obj.op is Op.FACTORS:
+            numer, denom = as_number(1), as_number(1)
+            for b, e in obj.data.items():
+                bnumer, bdenom = as_numer_denom(b)
+                if e > 0:
+                    numer *= bnumer ** e
+                    denom *= bdenom ** e
+                elif e < 0:
+                    numer *= bdenom ** (-e)
+                    denom *= bnumer ** (-e)
+            return numer, denom
+    raise OpError(f'cannot convert {type(obj)} to numer and denom')
+
+
+def _counter():
+    # Used internally to generate unique dummy symbols
+    counter = 0
+    while True:
+        counter += 1
+        yield counter
+
+
+COUNTER = _counter()
+
+
+def eliminate_quotes(s):
+    """Replace quoted substrings of input string.
+
+    Return a new string and a mapping of replacements.
+    """
+    d = {}
+
+    def repl(m):
+        kind, value = m.groups()[:2]
+        if kind:
+            # remove trailing underscore
+            kind = kind[:-1]
+        p = {"'": "SINGLE", '"': "DOUBLE"}[value[0]]
+        k = f'{kind}@__f2py_QUOTES_{p}_{COUNTER.__next__()}@'
+        d[k] = value
+        return k
+
+    new_s = re.sub(r'({kind}_|)({single_quoted}|{double_quoted})'.format(
+        kind=r'\w[\w\d_]*',
+        single_quoted=r"('([^'\\]|(\\.))*')",
+        double_quoted=r'("([^"\\]|(\\.))*")'),
+        repl, s)
+
+    assert '"' not in new_s
+    assert "'" not in new_s
+
+    return new_s, d
+
+
+def insert_quotes(s, d):
+    """Inverse of eliminate_quotes.
+    """
+    for k, v in d.items():
+        kind = k[:k.find('@')]
+        if kind:
+            kind += '_'
+        s = s.replace(k, kind + v)
+    return s
+
+
+def replace_parenthesis(s):
+    """Replace substrings of input that are enclosed in parenthesis.
+
+    Return a new string and a mapping of replacements.
+    """
+    # Find a parenthesis pair that appears first.
+
+    # Fortran deliminator are `(`, `)`, `[`, `]`, `(/', '/)`, `/`.
+    # We don't handle `/` deliminator because it is not a part of an
+    # expression.
+    left, right = None, None
+    mn_i = len(s)
+    for left_, right_ in (('(/', '/)'),
+                          '()',
+                          '{}',  # to support C literal structs
+                          '[]'):
+        i = s.find(left_)
+        if i == -1:
+            continue
+        if i < mn_i:
+            mn_i = i
+            left, right = left_, right_
+
+    if left is None:
+        return s, {}
+
+    i = mn_i
+    j = s.find(right, i)
+
+    while s.count(left, i + 1, j) != s.count(right, i + 1, j):
+        j = s.find(right, j + 1)
+        if j == -1:
+            raise ValueError(f'Mismatch of {left+right} parenthesis in {s!r}')
+
+    p = {'(': 'ROUND', '[': 'SQUARE', '{': 'CURLY', '(/': 'ROUNDDIV'}[left]
+
+    k = f'@__f2py_PARENTHESIS_{p}_{COUNTER.__next__()}@'
+    v = s[i+len(left):j]
+    r, d = replace_parenthesis(s[j+len(right):])
+    d[k] = v
+    return s[:i] + k + r, d
+
+
+def _get_parenthesis_kind(s):
+    assert s.startswith('@__f2py_PARENTHESIS_'), s
+    return s.split('_')[4]
+
+
+def unreplace_parenthesis(s, d):
+    """Inverse of replace_parenthesis.
+    """
+    for k, v in d.items():
+        p = _get_parenthesis_kind(k)
+        left = dict(ROUND='(', SQUARE='[', CURLY='{', ROUNDDIV='(/')[p]
+        right = dict(ROUND=')', SQUARE=']', CURLY='}', ROUNDDIV='/)')[p]
+        s = s.replace(k, left + v + right)
+    return s
+
+
+def fromstring(s, language=Language.C):
+    """Create an expression from a string.
+
+    This is a "lazy" parser, that is, only arithmetic operations are
+    resolved, non-arithmetic operations are treated as symbols.
+    """
+    r = _FromStringWorker(language=language).parse(s)
+    if isinstance(r, Expr):
+        return r
+    raise ValueError(f'failed to parse `{s}` to Expr instance: got `{r}`')
+
+
+class _Pair:
+    # Internal class to represent a pair of expressions
+
+    def __init__(self, left, right):
+        self.left = left
+        self.right = right
+
+    def substitute(self, symbols_map):
+        left, right = self.left, self.right
+        if isinstance(left, Expr):
+            left = left.substitute(symbols_map)
+        if isinstance(right, Expr):
+            right = right.substitute(symbols_map)
+        return _Pair(left, right)
+
+    def __repr__(self):
+        return f'{type(self).__name__}({self.left}, {self.right})'
+
+
+class _FromStringWorker:
+
+    def __init__(self, language=Language.C):
+        self.original = None
+        self.quotes_map = None
+        self.language = language
+
+    def finalize_string(self, s):
+        return insert_quotes(s, self.quotes_map)
+
+    def parse(self, inp):
+        self.original = inp
+        unquoted, self.quotes_map = eliminate_quotes(inp)
+        return self.process(unquoted)
+
+    def process(self, s, context='expr'):
+        """Parse string within the given context.
+
+        The context may define the result in case of ambiguous
+        expressions. For instance, consider expressions `f(x, y)` and
+        `(x, y) + (a, b)` where `f` is a function and pair `(x, y)`
+        denotes complex number. Specifying context as "args" or
+        "expr", the subexpression `(x, y)` will be parse to an
+        argument list or to a complex number, respectively.
+        """
+        if isinstance(s, (list, tuple)):
+            return type(s)(self.process(s_, context) for s_ in s)
+
+        assert isinstance(s, str), (type(s), s)
+
+        # replace subexpressions in parenthesis with f2py @-names
+        r, raw_symbols_map = replace_parenthesis(s)
+        r = r.strip()
+
+        def restore(r):
+            # restores subexpressions marked with f2py @-names
+            if isinstance(r, (list, tuple)):
+                return type(r)(map(restore, r))
+            return unreplace_parenthesis(r, raw_symbols_map)
+
+        # comma-separated tuple
+        if ',' in r:
+            operands = restore(r.split(','))
+            if context == 'args':
+                return tuple(self.process(operands))
+            if context == 'expr':
+                if len(operands) == 2:
+                    # complex number literal
+                    return as_complex(*self.process(operands))
+            raise NotImplementedError(
+                f'parsing comma-separated list (context={context}): {r}')
+
+        # ternary operation
+        m = re.match(r'\A([^?]+)[?]([^:]+)[:](.+)\Z', r)
+        if m:
+            assert context == 'expr', context
+            oper, expr1, expr2 = restore(m.groups())
+            oper = self.process(oper)
+            expr1 = self.process(expr1)
+            expr2 = self.process(expr2)
+            return as_ternary(oper, expr1, expr2)
+
+        # relational expression
+        if self.language is Language.Fortran:
+            m = re.match(
+                r'\A(.+)\s*[.](eq|ne|lt|le|gt|ge)[.]\s*(.+)\Z', r, re.I)
+        else:
+            m = re.match(
+                r'\A(.+)\s*([=][=]|[!][=]|[<][=]|[<]|[>][=]|[>])\s*(.+)\Z', r)
+        if m:
+            left, rop, right = m.groups()
+            if self.language is Language.Fortran:
+                rop = '.' + rop + '.'
+            left, right = self.process(restore((left, right)))
+            rop = RelOp.fromstring(rop, language=self.language)
+            return Expr(Op.RELATIONAL, (rop, left, right))
+
+        # keyword argument
+        m = re.match(r'\A(\w[\w\d_]*)\s*[=](.*)\Z', r)
+        if m:
+            keyname, value = m.groups()
+            value = restore(value)
+            return _Pair(keyname, self.process(value))
+
+        # addition/subtraction operations
+        operands = re.split(r'((? 1:
+            result = self.process(restore(operands[0] or '0'))
+            for op, operand in zip(operands[1::2], operands[2::2]):
+                operand = self.process(restore(operand))
+                op = op.strip()
+                if op == '+':
+                    result += operand
+                else:
+                    assert op == '-'
+                    result -= operand
+            return result
+
+        # string concatenate operation
+        if self.language is Language.Fortran and '//' in r:
+            operands = restore(r.split('//'))
+            return Expr(Op.CONCAT,
+                        tuple(self.process(operands)))
+
+        # multiplication/division operations
+        operands = re.split(r'(?<=[@\w\d_])\s*([*]|/)',
+                            (r if self.language is Language.C
+                             else r.replace('**', '@__f2py_DOUBLE_STAR@')))
+        if len(operands) > 1:
+            operands = restore(operands)
+            if self.language is not Language.C:
+                operands = [operand.replace('@__f2py_DOUBLE_STAR@', '**')
+                            for operand in operands]
+            # Expression is an arithmetic product
+            result = self.process(operands[0])
+            for op, operand in zip(operands[1::2], operands[2::2]):
+                operand = self.process(operand)
+                op = op.strip()
+                if op == '*':
+                    result *= operand
+                else:
+                    assert op == '/'
+                    result /= operand
+            return result
+
+        # referencing/dereferencing
+        if r.startswith('*') or r.startswith('&'):
+            op = {'*': Op.DEREF, '&': Op.REF}[r[0]]
+            operand = self.process(restore(r[1:]))
+            return Expr(op, operand)
+
+        # exponentiation operations
+        if self.language is not Language.C and '**' in r:
+            operands = list(reversed(restore(r.split('**'))))
+            result = self.process(operands[0])
+            for operand in operands[1:]:
+                operand = self.process(operand)
+                result = operand ** result
+            return result
+
+        # int-literal-constant
+        m = re.match(r'\A({digit_string})({kind}|)\Z'.format(
+            digit_string=r'\d+',
+            kind=r'_(\d+|\w[\w\d_]*)'), r)
+        if m:
+            value, _, kind = m.groups()
+            if kind and kind.isdigit():
+                kind = int(kind)
+            return as_integer(int(value), kind or 4)
+
+        # real-literal-constant
+        m = re.match(r'\A({significant}({exponent}|)|\d+{exponent})({kind}|)\Z'
+                     .format(
+                         significant=r'[.]\d+|\d+[.]\d*',
+                         exponent=r'[edED][+-]?\d+',
+                         kind=r'_(\d+|\w[\w\d_]*)'), r)
+        if m:
+            value, _, _, kind = m.groups()
+            if kind and kind.isdigit():
+                kind = int(kind)
+            value = value.lower()
+            if 'd' in value:
+                return as_real(float(value.replace('d', 'e')), kind or 8)
+            return as_real(float(value), kind or 4)
+
+        # string-literal-constant with kind parameter specification
+        if r in self.quotes_map:
+            kind = r[:r.find('@')]
+            return as_string(self.quotes_map[r], kind or 1)
+
+        # array constructor or literal complex constant or
+        # parenthesized expression
+        if r in raw_symbols_map:
+            paren = _get_parenthesis_kind(r)
+            items = self.process(restore(raw_symbols_map[r]),
+                                 'expr' if paren == 'ROUND' else 'args')
+            if paren == 'ROUND':
+                if isinstance(items, Expr):
+                    return items
+            if paren in ['ROUNDDIV', 'SQUARE']:
+                # Expression is a array constructor
+                if isinstance(items, Expr):
+                    items = (items,)
+                return as_array(items)
+
+        # function call/indexing
+        m = re.match(r'\A(.+)\s*(@__f2py_PARENTHESIS_(ROUND|SQUARE)_\d+@)\Z',
+                     r)
+        if m:
+            target, args, paren = m.groups()
+            target = self.process(restore(target))
+            args = self.process(restore(args)[1:-1], 'args')
+            if not isinstance(args, tuple):
+                args = args,
+            if paren == 'ROUND':
+                kwargs = dict((a.left, a.right) for a in args
+                              if isinstance(a, _Pair))
+                args = tuple(a for a in args if not isinstance(a, _Pair))
+                # Warning: this could also be Fortran indexing operation..
+                return as_apply(target, *args, **kwargs)
+            else:
+                # Expression is a C/Python indexing operation
+                # (e.g. used in .pyf files)
+                assert paren == 'SQUARE'
+                return target[args]
+
+        # Fortran standard conforming identifier
+        m = re.match(r'\A\w[\w\d_]*\Z', r)
+        if m:
+            return as_symbol(r)
+
+        # fall-back to symbol
+        r = self.finalize_string(restore(r))
+        ewarn(
+            f'fromstring: treating {r!r} as symbol (original={self.original})')
+        return as_symbol(r)
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/__init__.py b/venv/lib/python3.12/site-packages/numpy/f2py/tests/__init__.py
new file mode 100644
index 00000000..5ecb6807
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/tests/__init__.py
@@ -0,0 +1,15 @@
+from numpy.testing import IS_WASM, IS_EDITABLE
+import pytest
+
+if IS_WASM:
+    pytest.skip(
+        "WASM/Pyodide does not use or support Fortran",
+        allow_module_level=True
+    )
+
+
+if IS_EDITABLE:
+    pytest.skip(
+        "Editable install doesn't support tests with a compile step",
+        allow_module_level=True
+    )
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/f2py/tests/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 00000000..c6d3e45f
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/f2py/tests/__pycache__/__init__.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/__pycache__/test_abstract_interface.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/f2py/tests/__pycache__/test_abstract_interface.cpython-312.pyc
new file mode 100644
index 00000000..4ecac5a3
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/f2py/tests/__pycache__/test_abstract_interface.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/__pycache__/test_array_from_pyobj.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/f2py/tests/__pycache__/test_array_from_pyobj.cpython-312.pyc
new file mode 100644
index 00000000..f60262bb
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/f2py/tests/__pycache__/test_array_from_pyobj.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/__pycache__/test_assumed_shape.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/f2py/tests/__pycache__/test_assumed_shape.cpython-312.pyc
new file mode 100644
index 00000000..22de67f9
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/f2py/tests/__pycache__/test_assumed_shape.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/__pycache__/test_block_docstring.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/f2py/tests/__pycache__/test_block_docstring.cpython-312.pyc
new file mode 100644
index 00000000..b515595d
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/f2py/tests/__pycache__/test_block_docstring.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/__pycache__/test_callback.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/f2py/tests/__pycache__/test_callback.cpython-312.pyc
new file mode 100644
index 00000000..1e8e4737
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/f2py/tests/__pycache__/test_callback.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/__pycache__/test_character.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/f2py/tests/__pycache__/test_character.cpython-312.pyc
new file mode 100644
index 00000000..e602bc86
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/f2py/tests/__pycache__/test_character.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/__pycache__/test_common.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/f2py/tests/__pycache__/test_common.cpython-312.pyc
new file mode 100644
index 00000000..8c45d9d3
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/f2py/tests/__pycache__/test_common.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/__pycache__/test_crackfortran.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/f2py/tests/__pycache__/test_crackfortran.cpython-312.pyc
new file mode 100644
index 00000000..e5c01dea
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/f2py/tests/__pycache__/test_crackfortran.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/__pycache__/test_data.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/f2py/tests/__pycache__/test_data.cpython-312.pyc
new file mode 100644
index 00000000..dc48db7c
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/f2py/tests/__pycache__/test_data.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/__pycache__/test_docs.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/f2py/tests/__pycache__/test_docs.cpython-312.pyc
new file mode 100644
index 00000000..b3b45c99
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/f2py/tests/__pycache__/test_docs.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/__pycache__/test_f2cmap.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/f2py/tests/__pycache__/test_f2cmap.cpython-312.pyc
new file mode 100644
index 00000000..4d9ea6a5
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/f2py/tests/__pycache__/test_f2cmap.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/__pycache__/test_f2py2e.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/f2py/tests/__pycache__/test_f2py2e.cpython-312.pyc
new file mode 100644
index 00000000..938b7e62
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/f2py/tests/__pycache__/test_f2py2e.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/__pycache__/test_isoc.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/f2py/tests/__pycache__/test_isoc.cpython-312.pyc
new file mode 100644
index 00000000..4fd8b7c2
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/f2py/tests/__pycache__/test_isoc.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/__pycache__/test_kind.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/f2py/tests/__pycache__/test_kind.cpython-312.pyc
new file mode 100644
index 00000000..0dd2c670
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/f2py/tests/__pycache__/test_kind.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/__pycache__/test_mixed.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/f2py/tests/__pycache__/test_mixed.cpython-312.pyc
new file mode 100644
index 00000000..313e839a
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/f2py/tests/__pycache__/test_mixed.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/__pycache__/test_modules.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/f2py/tests/__pycache__/test_modules.cpython-312.pyc
new file mode 100644
index 00000000..543a850c
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/f2py/tests/__pycache__/test_modules.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/__pycache__/test_parameter.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/f2py/tests/__pycache__/test_parameter.cpython-312.pyc
new file mode 100644
index 00000000..7db22aec
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/f2py/tests/__pycache__/test_parameter.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/__pycache__/test_pyf_src.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/f2py/tests/__pycache__/test_pyf_src.cpython-312.pyc
new file mode 100644
index 00000000..84444f65
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/f2py/tests/__pycache__/test_pyf_src.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/__pycache__/test_quoted_character.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/f2py/tests/__pycache__/test_quoted_character.cpython-312.pyc
new file mode 100644
index 00000000..4c3ba8cd
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/f2py/tests/__pycache__/test_quoted_character.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/__pycache__/test_regression.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/f2py/tests/__pycache__/test_regression.cpython-312.pyc
new file mode 100644
index 00000000..a9bf792a
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/f2py/tests/__pycache__/test_regression.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/__pycache__/test_return_character.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/f2py/tests/__pycache__/test_return_character.cpython-312.pyc
new file mode 100644
index 00000000..33b96885
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/f2py/tests/__pycache__/test_return_character.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/__pycache__/test_return_complex.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/f2py/tests/__pycache__/test_return_complex.cpython-312.pyc
new file mode 100644
index 00000000..d1778e3a
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/f2py/tests/__pycache__/test_return_complex.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/__pycache__/test_return_integer.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/f2py/tests/__pycache__/test_return_integer.cpython-312.pyc
new file mode 100644
index 00000000..8266dc23
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/f2py/tests/__pycache__/test_return_integer.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/__pycache__/test_return_logical.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/f2py/tests/__pycache__/test_return_logical.cpython-312.pyc
new file mode 100644
index 00000000..2fbb449d
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/f2py/tests/__pycache__/test_return_logical.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/__pycache__/test_return_real.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/f2py/tests/__pycache__/test_return_real.cpython-312.pyc
new file mode 100644
index 00000000..d73a5fd2
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/f2py/tests/__pycache__/test_return_real.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/__pycache__/test_semicolon_split.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/f2py/tests/__pycache__/test_semicolon_split.cpython-312.pyc
new file mode 100644
index 00000000..bbf4d779
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/f2py/tests/__pycache__/test_semicolon_split.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/__pycache__/test_size.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/f2py/tests/__pycache__/test_size.cpython-312.pyc
new file mode 100644
index 00000000..928c37a2
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/f2py/tests/__pycache__/test_size.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/__pycache__/test_string.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/f2py/tests/__pycache__/test_string.cpython-312.pyc
new file mode 100644
index 00000000..50ef3127
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/f2py/tests/__pycache__/test_string.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/__pycache__/test_symbolic.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/f2py/tests/__pycache__/test_symbolic.cpython-312.pyc
new file mode 100644
index 00000000..6415df41
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/f2py/tests/__pycache__/test_symbolic.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/__pycache__/test_value_attrspec.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/f2py/tests/__pycache__/test_value_attrspec.cpython-312.pyc
new file mode 100644
index 00000000..cd7ea858
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/f2py/tests/__pycache__/test_value_attrspec.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/__pycache__/util.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/f2py/tests/__pycache__/util.cpython-312.pyc
new file mode 100644
index 00000000..773e5ef0
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/f2py/tests/__pycache__/util.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/abstract_interface/foo.f90 b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/abstract_interface/foo.f90
new file mode 100644
index 00000000..76d16aae
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/abstract_interface/foo.f90
@@ -0,0 +1,34 @@
+module ops_module
+
+  abstract interface
+    subroutine op(x, y, z)
+      integer, intent(in) :: x, y
+      integer, intent(out) :: z
+    end subroutine
+  end interface
+
+contains
+
+  subroutine foo(x, y, r1, r2)
+    integer, intent(in) :: x, y
+    integer, intent(out) :: r1, r2
+    procedure (op) add1, add2
+    procedure (op), pointer::p
+    p=>add1
+    call p(x, y, r1)
+    p=>add2
+    call p(x, y, r2)
+  end subroutine
+end module
+
+subroutine add1(x, y, z)
+  integer, intent(in) :: x, y
+  integer, intent(out) :: z
+  z = x + y
+end subroutine
+
+subroutine add2(x, y, z)
+  integer, intent(in) :: x, y
+  integer, intent(out) :: z
+  z = x + 2 * y
+end subroutine
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/abstract_interface/gh18403_mod.f90 b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/abstract_interface/gh18403_mod.f90
new file mode 100644
index 00000000..36791e46
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/abstract_interface/gh18403_mod.f90
@@ -0,0 +1,6 @@
+module test
+  abstract interface
+    subroutine foo()
+    end subroutine
+  end interface
+end module test
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/array_from_pyobj/wrapmodule.c b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/array_from_pyobj/wrapmodule.c
new file mode 100644
index 00000000..b66672a4
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/array_from_pyobj/wrapmodule.c
@@ -0,0 +1,235 @@
+/*
+ * This file was auto-generated with f2py (version:2_1330) and hand edited by
+ * Pearu for testing purposes.  Do not edit this file unless you know what you
+ * are doing!!!
+ */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************** See f2py2e/cfuncs.py: includes ***********************/
+
+#define PY_SSIZE_T_CLEAN
+#include 
+#include "fortranobject.h"
+#include 
+
+static PyObject *wrap_error;
+static PyObject *wrap_module;
+
+/************************************ call ************************************/
+static char doc_f2py_rout_wrap_call[] = "\
+Function signature:\n\
+  arr = call(type_num,dims,intent,obj)\n\
+Required arguments:\n"
+"  type_num : input int\n"
+"  dims : input int-sequence\n"
+"  intent : input int\n"
+"  obj : input python object\n"
+"Return objects:\n"
+"  arr : array";
+static PyObject *f2py_rout_wrap_call(PyObject *capi_self,
+                                     PyObject *capi_args) {
+  PyObject * volatile capi_buildvalue = NULL;
+  int type_num = 0;
+  int elsize = 0;
+  npy_intp *dims = NULL;
+  PyObject *dims_capi = Py_None;
+  int rank = 0;
+  int intent = 0;
+  PyArrayObject *capi_arr_tmp = NULL;
+  PyObject *arr_capi = Py_None;
+  int i;
+
+  if (!PyArg_ParseTuple(capi_args,"iiOiO|:wrap.call",\
+                        &type_num,&elsize,&dims_capi,&intent,&arr_capi))
+    return NULL;
+  rank = PySequence_Length(dims_capi);
+  dims = malloc(rank*sizeof(npy_intp));
+  for (i=0;ikind,
+                       PyArray_DESCR(arr)->type,
+                       PyArray_TYPE(arr),
+                       PyArray_ITEMSIZE(arr),
+                       PyDataType_ALIGNMENT(PyArray_DESCR(arr)),
+                       PyArray_FLAGS(arr),
+                       PyArray_ITEMSIZE(arr));
+}
+
+static PyMethodDef f2py_module_methods[] = {
+
+  {"call",f2py_rout_wrap_call,METH_VARARGS,doc_f2py_rout_wrap_call},
+  {"array_attrs",f2py_rout_wrap_attrs,METH_VARARGS,doc_f2py_rout_wrap_attrs},
+  {NULL,NULL}
+};
+
+static struct PyModuleDef moduledef = {
+    PyModuleDef_HEAD_INIT,
+    "test_array_from_pyobj_ext",
+    NULL,
+    -1,
+    f2py_module_methods,
+    NULL,
+    NULL,
+    NULL,
+    NULL
+};
+
+PyMODINIT_FUNC PyInit_test_array_from_pyobj_ext(void) {
+  PyObject *m,*d, *s;
+  m = wrap_module = PyModule_Create(&moduledef);
+  Py_SET_TYPE(&PyFortran_Type, &PyType_Type);
+  import_array();
+  if (PyErr_Occurred())
+    Py_FatalError("can't initialize module wrap (failed to import numpy)");
+  d = PyModule_GetDict(m);
+  s = PyUnicode_FromString("This module 'wrap' is auto-generated with f2py (version:2_1330).\nFunctions:\n"
+                           "  arr = call(type_num,dims,intent,obj)\n"
+                           ".");
+  PyDict_SetItemString(d, "__doc__", s);
+  wrap_error = PyErr_NewException ("wrap.error", NULL, NULL);
+  Py_DECREF(s);
+
+#define ADDCONST(NAME, CONST)              \
+    s = PyLong_FromLong(CONST);             \
+    PyDict_SetItemString(d, NAME, s);      \
+    Py_DECREF(s)
+
+  ADDCONST("F2PY_INTENT_IN", F2PY_INTENT_IN);
+  ADDCONST("F2PY_INTENT_INOUT", F2PY_INTENT_INOUT);
+  ADDCONST("F2PY_INTENT_OUT", F2PY_INTENT_OUT);
+  ADDCONST("F2PY_INTENT_HIDE", F2PY_INTENT_HIDE);
+  ADDCONST("F2PY_INTENT_CACHE", F2PY_INTENT_CACHE);
+  ADDCONST("F2PY_INTENT_COPY", F2PY_INTENT_COPY);
+  ADDCONST("F2PY_INTENT_C", F2PY_INTENT_C);
+  ADDCONST("F2PY_OPTIONAL", F2PY_OPTIONAL);
+  ADDCONST("F2PY_INTENT_INPLACE", F2PY_INTENT_INPLACE);
+  ADDCONST("NPY_BOOL", NPY_BOOL);
+  ADDCONST("NPY_BYTE", NPY_BYTE);
+  ADDCONST("NPY_UBYTE", NPY_UBYTE);
+  ADDCONST("NPY_SHORT", NPY_SHORT);
+  ADDCONST("NPY_USHORT", NPY_USHORT);
+  ADDCONST("NPY_INT", NPY_INT);
+  ADDCONST("NPY_UINT", NPY_UINT);
+  ADDCONST("NPY_INTP", NPY_INTP);
+  ADDCONST("NPY_UINTP", NPY_UINTP);
+  ADDCONST("NPY_LONG", NPY_LONG);
+  ADDCONST("NPY_ULONG", NPY_ULONG);
+  ADDCONST("NPY_LONGLONG", NPY_LONGLONG);
+  ADDCONST("NPY_ULONGLONG", NPY_ULONGLONG);
+  ADDCONST("NPY_FLOAT", NPY_FLOAT);
+  ADDCONST("NPY_DOUBLE", NPY_DOUBLE);
+  ADDCONST("NPY_LONGDOUBLE", NPY_LONGDOUBLE);
+  ADDCONST("NPY_CFLOAT", NPY_CFLOAT);
+  ADDCONST("NPY_CDOUBLE", NPY_CDOUBLE);
+  ADDCONST("NPY_CLONGDOUBLE", NPY_CLONGDOUBLE);
+  ADDCONST("NPY_OBJECT", NPY_OBJECT);
+  ADDCONST("NPY_STRING", NPY_STRING);
+  ADDCONST("NPY_UNICODE", NPY_UNICODE);
+  ADDCONST("NPY_VOID", NPY_VOID);
+  ADDCONST("NPY_NTYPES_LEGACY", NPY_NTYPES_LEGACY);
+  ADDCONST("NPY_NOTYPE", NPY_NOTYPE);
+  ADDCONST("NPY_USERDEF", NPY_USERDEF);
+
+  ADDCONST("CONTIGUOUS", NPY_ARRAY_C_CONTIGUOUS);
+  ADDCONST("FORTRAN", NPY_ARRAY_F_CONTIGUOUS);
+  ADDCONST("OWNDATA", NPY_ARRAY_OWNDATA);
+  ADDCONST("FORCECAST", NPY_ARRAY_FORCECAST);
+  ADDCONST("ENSURECOPY", NPY_ARRAY_ENSURECOPY);
+  ADDCONST("ENSUREARRAY", NPY_ARRAY_ENSUREARRAY);
+  ADDCONST("ALIGNED", NPY_ARRAY_ALIGNED);
+  ADDCONST("WRITEABLE", NPY_ARRAY_WRITEABLE);
+  ADDCONST("WRITEBACKIFCOPY", NPY_ARRAY_WRITEBACKIFCOPY);
+
+  ADDCONST("BEHAVED", NPY_ARRAY_BEHAVED);
+  ADDCONST("BEHAVED_NS", NPY_ARRAY_BEHAVED_NS);
+  ADDCONST("CARRAY", NPY_ARRAY_CARRAY);
+  ADDCONST("FARRAY", NPY_ARRAY_FARRAY);
+  ADDCONST("CARRAY_RO", NPY_ARRAY_CARRAY_RO);
+  ADDCONST("FARRAY_RO", NPY_ARRAY_FARRAY_RO);
+  ADDCONST("DEFAULT", NPY_ARRAY_DEFAULT);
+  ADDCONST("UPDATE_ALL", NPY_ARRAY_UPDATE_ALL);
+
+#undef ADDCONST
+
+  if (PyErr_Occurred())
+    Py_FatalError("can't initialize module wrap");
+
+#ifdef F2PY_REPORT_ATEXIT
+  on_exit(f2py_report_on_exit,(void*)"array_from_pyobj.wrap.call");
+#endif
+
+#if Py_GIL_DISABLED
+    // signal whether this module supports running with the GIL disabled
+    PyUnstable_Module_SetGIL(m, Py_MOD_GIL_NOT_USED);
+#endif
+
+  return m;
+}
+#ifdef __cplusplus
+}
+#endif
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/assumed_shape/.f2py_f2cmap b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/assumed_shape/.f2py_f2cmap
new file mode 100644
index 00000000..2665f89b
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/assumed_shape/.f2py_f2cmap
@@ -0,0 +1 @@
+dict(real=dict(rk="double"))
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/assumed_shape/foo_free.f90 b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/assumed_shape/foo_free.f90
new file mode 100644
index 00000000..b301710f
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/assumed_shape/foo_free.f90
@@ -0,0 +1,34 @@
+
+subroutine sum(x, res)
+  implicit none
+  real, intent(in) :: x(:)
+  real, intent(out) :: res
+
+  integer :: i
+
+  !print *, "sum: size(x) = ", size(x)
+
+  res = 0.0
+
+  do i = 1, size(x)
+    res = res + x(i)
+  enddo
+
+end subroutine sum
+
+function fsum(x) result (res)
+  implicit none
+  real, intent(in) :: x(:)
+  real :: res
+
+  integer :: i
+
+  !print *, "fsum: size(x) = ", size(x)
+
+  res = 0.0
+
+  do i = 1, size(x)
+    res = res + x(i)
+  enddo
+
+end function fsum
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/assumed_shape/foo_mod.f90 b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/assumed_shape/foo_mod.f90
new file mode 100644
index 00000000..cbe6317e
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/assumed_shape/foo_mod.f90
@@ -0,0 +1,41 @@
+
+module mod
+
+contains
+
+subroutine sum(x, res)
+  implicit none
+  real, intent(in) :: x(:)
+  real, intent(out) :: res
+
+  integer :: i
+
+  !print *, "sum: size(x) = ", size(x)
+
+  res = 0.0
+
+  do i = 1, size(x)
+    res = res + x(i)
+  enddo
+
+end subroutine sum
+
+function fsum(x) result (res)
+  implicit none
+  real, intent(in) :: x(:)
+  real :: res
+
+  integer :: i
+
+  !print *, "fsum: size(x) = ", size(x)
+
+  res = 0.0
+
+  do i = 1, size(x)
+    res = res + x(i)
+  enddo
+
+end function fsum
+
+
+end module mod
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/assumed_shape/foo_use.f90 b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/assumed_shape/foo_use.f90
new file mode 100644
index 00000000..337465ac
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/assumed_shape/foo_use.f90
@@ -0,0 +1,19 @@
+subroutine sum_with_use(x, res)
+  use precision
+
+  implicit none
+
+  real(kind=rk), intent(in) :: x(:)
+  real(kind=rk), intent(out) :: res
+
+  integer :: i
+
+  !print *, "size(x) = ", size(x)
+
+  res = 0.0
+
+  do i = 1, size(x)
+    res = res + x(i)
+  enddo
+
+ end subroutine
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/assumed_shape/precision.f90 b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/assumed_shape/precision.f90
new file mode 100644
index 00000000..ed6c70cb
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/assumed_shape/precision.f90
@@ -0,0 +1,4 @@
+module precision
+  integer, parameter :: rk = selected_real_kind(8)
+  integer, parameter :: ik = selected_real_kind(4)
+end module
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/block_docstring/foo.f b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/block_docstring/foo.f
new file mode 100644
index 00000000..c8315f12
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/block_docstring/foo.f
@@ -0,0 +1,6 @@
+      SUBROUTINE FOO()
+      INTEGER BAR(2, 3)
+
+      COMMON  /BLOCK/ BAR
+      RETURN
+      END
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/callback/foo.f b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/callback/foo.f
new file mode 100644
index 00000000..ba397bb3
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/callback/foo.f
@@ -0,0 +1,62 @@
+       subroutine t(fun,a)
+       integer a
+cf2py  intent(out) a
+       external fun
+       call fun(a)
+       end
+
+       subroutine func(a)
+cf2py  intent(in,out) a
+       integer a
+       a = a + 11
+       end
+
+       subroutine func0(a)
+cf2py  intent(out) a
+       integer a
+       a = 11
+       end
+
+       subroutine t2(a)
+cf2py  intent(callback) fun
+       integer a
+cf2py  intent(out) a
+       external fun
+       call fun(a)
+       end
+
+       subroutine string_callback(callback, a)
+       external callback
+       double precision callback
+       double precision a
+       character*1 r
+cf2py  intent(out) a
+       r = 'r'
+       a = callback(r)
+       end
+
+       subroutine string_callback_array(callback, cu, lencu, a)
+       external callback
+       integer callback
+       integer lencu
+       character*8 cu(lencu)
+       integer a
+cf2py  intent(out) a
+
+       a = callback(cu, lencu)
+       end
+
+       subroutine hidden_callback(a, r)
+       external global_f
+cf2py  intent(callback, hide) global_f
+       integer a, r, global_f
+cf2py  intent(out) r
+       r = global_f(a)
+       end
+
+       subroutine hidden_callback2(a, r)
+       external global_f
+       integer a, r, global_f
+cf2py  intent(out) r
+       r = global_f(a)
+       end
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/callback/gh17797.f90 b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/callback/gh17797.f90
new file mode 100644
index 00000000..49853afd
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/callback/gh17797.f90
@@ -0,0 +1,7 @@
+function gh17797(f, y) result(r)
+  external f
+  integer(8) :: r, f
+  integer(8), dimension(:) :: y
+  r = f(0)
+  r = r + sum(y)
+end function gh17797
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/callback/gh18335.f90 b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/callback/gh18335.f90
new file mode 100644
index 00000000..92b6d754
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/callback/gh18335.f90
@@ -0,0 +1,17 @@
+        ! When gh18335_workaround is defined as an extension,
+        ! the issue cannot be reproduced.
+        !subroutine gh18335_workaround(f, y)
+        !  implicit none
+        !  external f
+        !  integer(kind=1) :: y(1)
+        !  call f(y)
+        !end subroutine gh18335_workaround
+
+        function gh18335(f) result (r)
+          implicit none
+          external f
+          integer(kind=1) :: y(1), r
+          y(1) = 123
+          call f(y)
+          r = y(1)
+        end function gh18335
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/callback/gh25211.f b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/callback/gh25211.f
new file mode 100644
index 00000000..ba727a10
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/callback/gh25211.f
@@ -0,0 +1,10 @@
+      SUBROUTINE FOO(FUN,R)
+      EXTERNAL FUN
+      INTEGER I
+      REAL*8 R, FUN
+Cf2py intent(out) r
+      R = 0D0
+      DO I=-5,5
+         R = R + FUN(I)
+      ENDDO
+      END
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/callback/gh25211.pyf b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/callback/gh25211.pyf
new file mode 100644
index 00000000..f1201115
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/callback/gh25211.pyf
@@ -0,0 +1,18 @@
+python module __user__routines
+    interface
+        function fun(i) result (r)
+            integer :: i
+            real*8 :: r
+        end function fun
+    end interface
+end python module __user__routines
+
+python module callback2
+    interface
+        subroutine foo(f,r)
+            use __user__routines, f=>fun
+            external f
+            real*8 intent(out) :: r
+        end subroutine foo
+    end interface
+end python module callback2
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/cli/gh_22819.pyf b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/cli/gh_22819.pyf
new file mode 100644
index 00000000..8eb5bb10
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/cli/gh_22819.pyf
@@ -0,0 +1,6 @@
+python module test_22819
+    interface
+        subroutine hello()
+        end subroutine hello
+    end interface
+end python module test_22819
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/cli/hi77.f b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/cli/hi77.f
new file mode 100644
index 00000000..8b916ebe
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/cli/hi77.f
@@ -0,0 +1,3 @@
+      SUBROUTINE HI
+        PRINT*, "HELLO WORLD"
+      END SUBROUTINE
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/cli/hiworld.f90 b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/cli/hiworld.f90
new file mode 100644
index 00000000..981f8775
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/cli/hiworld.f90
@@ -0,0 +1,3 @@
+function hi()
+  print*, "Hello World"
+end function
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/common/block.f b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/common/block.f
new file mode 100644
index 00000000..7ea7968f
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/common/block.f
@@ -0,0 +1,11 @@
+      SUBROUTINE INITCB
+      DOUBLE PRECISION LONG
+      CHARACTER        STRING
+      INTEGER          OK
+    
+      COMMON  /BLOCK/ LONG, STRING, OK
+      LONG = 1.0
+      STRING = '2'
+      OK = 3
+      RETURN
+      END
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/common/gh19161.f90 b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/common/gh19161.f90
new file mode 100644
index 00000000..a2f40735
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/common/gh19161.f90
@@ -0,0 +1,10 @@
+module typedefmod
+  use iso_fortran_env, only: real32
+end module typedefmod
+
+module data
+  use typedefmod, only: real32
+  implicit none
+  real(kind=real32) :: x
+  common/test/x
+end module data
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/crackfortran/accesstype.f90 b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/crackfortran/accesstype.f90
new file mode 100644
index 00000000..e2cbd445
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/crackfortran/accesstype.f90
@@ -0,0 +1,13 @@
+module foo
+  public
+  type, private, bind(c) :: a
+     integer :: i
+  end type a
+  type, bind(c) :: b_
+     integer :: j
+  end type b_
+  public :: b_
+  type :: c
+     integer :: k
+  end type c
+end module foo
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/crackfortran/data_common.f b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/crackfortran/data_common.f
new file mode 100644
index 00000000..5ffd865c
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/crackfortran/data_common.f
@@ -0,0 +1,8 @@
+        BLOCK DATA PARAM_INI
+        COMMON /MYCOM/ MYDATA
+            DATA MYDATA /0/
+        END
+        SUBROUTINE SUB1
+        COMMON /MYCOM/ MYDATA
+        MYDATA = MYDATA + 1
+        END
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/crackfortran/data_multiplier.f b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/crackfortran/data_multiplier.f
new file mode 100644
index 00000000..19ff8a83
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/crackfortran/data_multiplier.f
@@ -0,0 +1,5 @@
+      BLOCK DATA MYBLK
+      IMPLICIT DOUBLE PRECISION (A-H,O-Z)
+      COMMON /MYCOM/ IVAR1, IVAR2, IVAR3, IVAR4, EVAR5
+            DATA IVAR1, IVAR2, IVAR3, IVAR4, EVAR5 /2*3,2*2,0.0D0/
+      END
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/crackfortran/data_stmts.f90 b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/crackfortran/data_stmts.f90
new file mode 100644
index 00000000..576c5e48
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/crackfortran/data_stmts.f90
@@ -0,0 +1,20 @@
+! gh-23276
+module cmplxdat
+  implicit none
+  integer :: i, j
+  real :: x, y
+  real, dimension(2) :: z
+  real(kind=8) :: pi
+  complex(kind=8), target :: medium_ref_index
+  complex(kind=8), target :: ref_index_one, ref_index_two
+  complex(kind=8), dimension(2) :: my_array
+  real(kind=8), dimension(3) :: my_real_array = (/1.0d0, 2.0d0, 3.0d0/)
+
+  data i, j / 2, 3 /
+  data x, y / 1.5, 2.0 /
+  data z / 3.5, 7.0 /
+  data medium_ref_index / (1.d0, 0.d0) /
+  data ref_index_one, ref_index_two / (13.0d0, 21.0d0), (-30.0d0, 43.0d0) /
+  data my_array / (1.0d0, 2.0d0), (-3.0d0, 4.0d0) /
+  data pi / 3.1415926535897932384626433832795028841971693993751058209749445923078164062d0 /
+end module cmplxdat
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/crackfortran/data_with_comments.f b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/crackfortran/data_with_comments.f
new file mode 100644
index 00000000..4128f004
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/crackfortran/data_with_comments.f
@@ -0,0 +1,8 @@
+      BLOCK DATA PARAM_INI
+      COMMON /MYCOM/ MYTAB
+      INTEGER  MYTAB(3)
+      DATA MYTAB/
+     *   0, ! 1 and more commenty stuff
+     *   4, ! 2
+     *   0 /
+      END
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/crackfortran/foo_deps.f90 b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/crackfortran/foo_deps.f90
new file mode 100644
index 00000000..e327b25c
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/crackfortran/foo_deps.f90
@@ -0,0 +1,6 @@
+module foo
+  type bar
+    character(len = 4) :: text
+  end type bar
+  type(bar), parameter :: abar = bar('abar')
+end module foo
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/crackfortran/gh15035.f b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/crackfortran/gh15035.f
new file mode 100644
index 00000000..1bb2e674
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/crackfortran/gh15035.f
@@ -0,0 +1,16 @@
+        subroutine subb(k)
+          real(8), intent(inout) :: k(:)
+          k=k+1
+        endsubroutine
+
+        subroutine subc(w,k)
+          real(8), intent(in) :: w(:)
+          real(8), intent(out) :: k(size(w))
+          k=w+1
+        endsubroutine
+
+        function t0(value)
+          character value
+          character t0
+          t0 = value
+        endfunction
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/crackfortran/gh17859.f b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/crackfortran/gh17859.f
new file mode 100644
index 00000000..99595384
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/crackfortran/gh17859.f
@@ -0,0 +1,12 @@
+        integer(8) function external_as_statement(fcn)
+        implicit none
+        external fcn
+        integer(8) :: fcn
+        external_as_statement = fcn(0)
+        end
+
+        integer(8) function external_as_attribute(fcn)
+        implicit none
+        integer(8), external :: fcn
+        external_as_attribute = fcn(0)
+        end
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/crackfortran/gh22648.pyf b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/crackfortran/gh22648.pyf
new file mode 100644
index 00000000..b3454f18
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/crackfortran/gh22648.pyf
@@ -0,0 +1,7 @@
+python module iri16py ! in
+    interface  ! in :iri16py
+        block data  ! in :iri16py:iridreg_modified.for
+           COMMON /fircom/ eden,tabhe,tabla,tabmo,tabza,tabfl
+       end block data 
+    end interface 
+end python module iri16py
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/crackfortran/gh23533.f b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/crackfortran/gh23533.f
new file mode 100644
index 00000000..db522afa
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/crackfortran/gh23533.f
@@ -0,0 +1,5 @@
+      SUBROUTINE EXAMPLE( )
+        IF( .TRUE. ) THEN
+            CALL DO_SOMETHING()
+        END IF ! ** .TRUE. **
+      END
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/crackfortran/gh23598.f90 b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/crackfortran/gh23598.f90
new file mode 100644
index 00000000..e0dffb5e
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/crackfortran/gh23598.f90
@@ -0,0 +1,4 @@
+integer function intproduct(a, b) result(res)
+  integer, intent(in) :: a, b
+  res = a*b
+end function
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/crackfortran/gh23598Warn.f90 b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/crackfortran/gh23598Warn.f90
new file mode 100644
index 00000000..3b44efc5
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/crackfortran/gh23598Warn.f90
@@ -0,0 +1,11 @@
+module test_bug
+    implicit none
+    private
+    public :: intproduct
+
+contains
+    integer function intproduct(a, b) result(res)
+    integer, intent(in) :: a, b
+    res = a*b
+    end function
+end module
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/crackfortran/gh23879.f90 b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/crackfortran/gh23879.f90
new file mode 100644
index 00000000..fac262d5
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/crackfortran/gh23879.f90
@@ -0,0 +1,20 @@
+module gh23879
+    implicit none
+    private
+    public :: foo
+
+ contains
+
+    subroutine foo(a, b)
+       integer, intent(in) :: a
+       integer, intent(out) :: b
+       b = a
+       call bar(b)
+    end subroutine
+
+    subroutine bar(x)
+        integer, intent(inout) :: x
+        x = 2*x
+     end subroutine
+
+ end module gh23879
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/crackfortran/gh2848.f90 b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/crackfortran/gh2848.f90
new file mode 100644
index 00000000..31ea9327
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/crackfortran/gh2848.f90
@@ -0,0 +1,13 @@
+      subroutine gh2848( &
+        ! first 2 parameters
+        par1, par2,&
+        ! last 2 parameters
+        par3, par4)
+
+        integer, intent(in)  :: par1, par2
+        integer, intent(out) :: par3, par4
+
+        par3 = par1
+        par4 = par2
+
+      end subroutine gh2848
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/crackfortran/operators.f90 b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/crackfortran/operators.f90
new file mode 100644
index 00000000..1d060a3d
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/crackfortran/operators.f90
@@ -0,0 +1,49 @@
+module foo
+  type bar
+     character(len = 32) :: item
+  end type bar
+  interface operator(.item.)
+     module procedure item_int, item_real
+  end interface operator(.item.)
+  interface operator(==)
+     module procedure items_are_equal
+  end interface operator(==)
+  interface assignment(=)
+     module procedure get_int, get_real
+  end interface assignment(=)
+contains
+  function item_int(val) result(elem)
+    integer, intent(in) :: val
+    type(bar) :: elem
+
+    write(elem%item, "(I32)") val
+  end function item_int
+
+  function item_real(val) result(elem)
+    real, intent(in) :: val
+    type(bar) :: elem
+
+    write(elem%item, "(1PE32.12)") val
+  end function item_real
+
+  function items_are_equal(val1, val2) result(equal)
+    type(bar), intent(in) :: val1, val2
+    logical :: equal
+
+    equal = (val1%item == val2%item)
+  end function items_are_equal
+
+  subroutine get_real(rval, item)
+    real, intent(out) :: rval
+    type(bar), intent(in) :: item
+
+    read(item%item, *) rval
+  end subroutine get_real
+
+  subroutine get_int(rval, item)
+    integer, intent(out) :: rval
+    type(bar), intent(in) :: item
+
+    read(item%item, *) rval
+  end subroutine get_int
+end module foo
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/crackfortran/privatemod.f90 b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/crackfortran/privatemod.f90
new file mode 100644
index 00000000..2674c214
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/crackfortran/privatemod.f90
@@ -0,0 +1,11 @@
+module foo
+  private
+  integer :: a
+  public :: setA
+  integer :: b
+contains
+  subroutine setA(v)
+    integer, intent(in) :: v
+    a = v
+  end subroutine setA
+end module foo
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/crackfortran/publicmod.f90 b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/crackfortran/publicmod.f90
new file mode 100644
index 00000000..1db76e3f
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/crackfortran/publicmod.f90
@@ -0,0 +1,10 @@
+module foo
+  public
+  integer, private :: a
+  public :: setA
+contains
+  subroutine setA(v)
+    integer, intent(in) :: v
+    a = v
+  end subroutine setA
+end module foo
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/crackfortran/pubprivmod.f90 b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/crackfortran/pubprivmod.f90
new file mode 100644
index 00000000..46bef7cb
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/crackfortran/pubprivmod.f90
@@ -0,0 +1,10 @@
+module foo
+  public
+  integer, private :: a
+  integer :: b
+contains
+  subroutine setA(v)
+    integer, intent(in) :: v
+    a = v
+  end subroutine setA
+end module foo
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/crackfortran/unicode_comment.f90 b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/crackfortran/unicode_comment.f90
new file mode 100644
index 00000000..13515ce9
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/crackfortran/unicode_comment.f90
@@ -0,0 +1,4 @@
+subroutine foo(x)
+  real(8), intent(in) :: x
+  ! Écrit à l'écran la valeur de x
+end subroutine
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/f2cmap/.f2py_f2cmap b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/f2cmap/.f2py_f2cmap
new file mode 100644
index 00000000..a4425f88
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/f2cmap/.f2py_f2cmap
@@ -0,0 +1 @@
+dict(real=dict(real32='float', real64='double'), integer=dict(int64='long_long'))
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/f2cmap/isoFortranEnvMap.f90 b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/f2cmap/isoFortranEnvMap.f90
new file mode 100644
index 00000000..1e1dc1d4
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/f2cmap/isoFortranEnvMap.f90
@@ -0,0 +1,9 @@
+      subroutine func1(n, x, res)
+        use, intrinsic :: iso_fortran_env, only: int64, real64
+        implicit none
+        integer(int64), intent(in) :: n
+        real(real64), intent(in) :: x(n)
+        real(real64), intent(out) :: res
+!f2py   intent(hide) :: n
+        res = sum(x)
+      end
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/isocintrin/isoCtests.f90 b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/isocintrin/isoCtests.f90
new file mode 100644
index 00000000..765f7c1c
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/isocintrin/isoCtests.f90
@@ -0,0 +1,34 @@
+  module coddity
+    use iso_c_binding, only: c_double, c_int, c_int64_t
+    implicit none
+    contains
+      subroutine c_add(a, b, c) bind(c, name="c_add")
+        real(c_double), intent(in) :: a, b
+        real(c_double), intent(out) :: c
+        c = a + b
+      end subroutine c_add
+      ! gh-9693
+      function wat(x, y) result(z) bind(c)
+          integer(c_int), intent(in) :: x, y
+          integer(c_int) :: z
+
+          z = x + 7
+      end function wat
+      ! gh-25207
+      subroutine c_add_int64(a, b, c) bind(c)
+        integer(c_int64_t), intent(in) :: a, b
+        integer(c_int64_t), intent(out) :: c
+        c = a + b
+      end subroutine c_add_int64
+      ! gh-25207
+      subroutine add_arr(A, B, C)
+         integer(c_int64_t), intent(in) :: A(3)
+         integer(c_int64_t), intent(in) :: B(3)
+         integer(c_int64_t), intent(out) :: C(3)
+         integer :: j
+
+         do j = 1, 3
+            C(j) = A(j)+B(j)
+         end do
+      end subroutine
+  end module coddity
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/kind/foo.f90 b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/kind/foo.f90
new file mode 100644
index 00000000..d3d15cfb
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/kind/foo.f90
@@ -0,0 +1,20 @@
+
+
+subroutine selectedrealkind(p, r, res)
+  implicit none
+  
+  integer, intent(in) :: p, r
+  !f2py integer :: r=0
+  integer, intent(out) :: res
+  res = selected_real_kind(p, r)
+
+end subroutine
+
+subroutine selectedintkind(p, res)
+  implicit none
+
+  integer, intent(in) :: p
+  integer, intent(out) :: res
+  res = selected_int_kind(p)
+
+end subroutine
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/mixed/foo.f b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/mixed/foo.f
new file mode 100644
index 00000000..c3474257
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/mixed/foo.f
@@ -0,0 +1,5 @@
+      subroutine bar11(a)
+cf2py intent(out) a
+      integer a
+      a = 11
+      end
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/mixed/foo_fixed.f90 b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/mixed/foo_fixed.f90
new file mode 100644
index 00000000..7543a6ac
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/mixed/foo_fixed.f90
@@ -0,0 +1,8 @@
+      module foo_fixed
+      contains
+        subroutine bar12(a)
+!f2py intent(out) a
+          integer a
+          a = 12
+        end subroutine bar12
+      end module foo_fixed
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/mixed/foo_free.f90 b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/mixed/foo_free.f90
new file mode 100644
index 00000000..c1b641f1
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/mixed/foo_free.f90
@@ -0,0 +1,8 @@
+module foo_free
+contains
+  subroutine bar13(a)
+    !f2py intent(out) a
+    integer a
+    a = 13
+  end subroutine bar13
+end module foo_free
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/modules/gh25337/data.f90 b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/modules/gh25337/data.f90
new file mode 100644
index 00000000..483d13ce
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/modules/gh25337/data.f90
@@ -0,0 +1,8 @@
+module data
+   real(8) :: shift
+contains
+   subroutine set_shift(in_shift)
+      real(8), intent(in) :: in_shift
+      shift = in_shift
+   end subroutine set_shift
+end module data
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/modules/gh25337/use_data.f90 b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/modules/gh25337/use_data.f90
new file mode 100644
index 00000000..b3fae8b8
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/modules/gh25337/use_data.f90
@@ -0,0 +1,6 @@
+subroutine shift_a(dim_a, a)
+    use data, only: shift
+    integer, intent(in) :: dim_a
+    real(8), intent(inout), dimension(dim_a) :: a
+    a = a + shift
+end subroutine shift_a
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/modules/gh26920/two_mods_with_no_public_entities.f90 b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/modules/gh26920/two_mods_with_no_public_entities.f90
new file mode 100644
index 00000000..07adce59
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/modules/gh26920/two_mods_with_no_public_entities.f90
@@ -0,0 +1,21 @@
+    module mod2
+        implicit none
+        private mod2_func1
+    contains
+
+        subroutine mod2_func1()
+            print*, "mod2_func1"
+        end subroutine mod2_func1
+
+    end module mod2
+
+    module mod1
+        implicit none
+        private :: mod1_func1
+    contains
+
+        subroutine mod1_func1()
+            print*, "mod1_func1"
+        end subroutine mod1_func1
+
+    end module mod1
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/modules/gh26920/two_mods_with_one_public_routine.f90 b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/modules/gh26920/two_mods_with_one_public_routine.f90
new file mode 100644
index 00000000..b7fb95b0
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/modules/gh26920/two_mods_with_one_public_routine.f90
@@ -0,0 +1,21 @@
+    module mod2
+        implicit none
+        PUBLIC :: mod2_func1
+    contains
+
+        subroutine mod2_func1()
+            print*, "mod2_func1"
+        end subroutine mod2_func1
+
+    end module mod2
+
+    module mod1
+        implicit none
+        PUBLIC :: mod1_func1
+    contains
+
+        subroutine mod1_func1()
+            print*, "mod1_func1"
+        end subroutine mod1_func1
+
+    end module mod1
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/modules/module_data_docstring.f90 b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/modules/module_data_docstring.f90
new file mode 100644
index 00000000..4505e0cb
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/modules/module_data_docstring.f90
@@ -0,0 +1,12 @@
+module mod
+  integer :: i
+  integer :: x(4)
+  real, dimension(2,3) :: a
+  real, allocatable, dimension(:,:) :: b
+contains
+  subroutine foo
+    integer :: k
+    k = 1
+    a(1,2) = a(1,2)+3
+  end subroutine foo
+end module mod
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/modules/use_modules.f90 b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/modules/use_modules.f90
new file mode 100644
index 00000000..aa40c86c
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/modules/use_modules.f90
@@ -0,0 +1,20 @@
+module mathops
+  implicit none
+contains
+  function add(a, b) result(c)
+    integer, intent(in) :: a, b
+    integer :: c
+    c = a + b
+  end function add
+end module mathops
+
+module useops
+  use mathops, only: add
+  implicit none
+contains
+  function sum_and_double(a, b) result(d)
+    integer, intent(in) :: a, b
+    integer :: d
+    d = 2 * add(a, b)
+  end function sum_and_double
+end module useops
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/negative_bounds/issue_20853.f90 b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/negative_bounds/issue_20853.f90
new file mode 100644
index 00000000..bf1fa928
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/negative_bounds/issue_20853.f90
@@ -0,0 +1,7 @@
+subroutine foo(is_, ie_, arr, tout)
+ implicit none
+ integer :: is_,ie_
+ real, intent(in) :: arr(is_:ie_)
+ real, intent(out) :: tout(is_:ie_)
+ tout = arr
+end
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/parameter/constant_array.f90 b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/parameter/constant_array.f90
new file mode 100644
index 00000000..9a6bf816
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/parameter/constant_array.f90
@@ -0,0 +1,45 @@
+! Check that parameter arrays are correctly intercepted.
+subroutine foo_array(x, y, z)
+  implicit none
+  integer, parameter :: dp = selected_real_kind(15)
+  integer, parameter :: pa = 2
+  integer, parameter :: intparamarray(2) = (/ 3, 5 /)
+  integer, dimension(pa), parameter :: pb = (/ 2, 10 /)
+  integer, parameter, dimension(intparamarray(1)) :: pc = (/ 2, 10, 20 /)
+  real(dp), parameter :: doubleparamarray(3) = (/ 3.14_dp, 4._dp, 6.44_dp /)
+  real(dp), intent(inout) :: x(intparamarray(1))
+  real(dp), intent(inout) :: y(intparamarray(2))
+  real(dp), intent(out) :: z
+
+  x = x/pb(2)
+  y = y*pc(2)
+  z = doubleparamarray(1)*doubleparamarray(2) + doubleparamarray(3)
+
+  return
+end subroutine
+
+subroutine foo_array_any_index(x, y)
+  implicit none
+  integer, parameter :: dp = selected_real_kind(15)
+  integer, parameter, dimension(-1:1) :: myparamarray = (/ 6, 3, 1 /)
+  integer, parameter, dimension(2) :: nested = (/ 2, 0 /)
+  integer, parameter :: dim = 2
+  real(dp), intent(in) :: x(myparamarray(-1))
+  real(dp), intent(out) :: y(nested(1), myparamarray(nested(dim)))
+
+  y = reshape(x, (/nested(1), myparamarray(nested(2))/))
+
+  return
+end subroutine
+
+subroutine foo_array_delims(x)
+  implicit none
+  integer, parameter :: dp = selected_real_kind(15)
+  integer, parameter, dimension(2) :: myparamarray = (/ (6), 1 /)
+  integer, parameter, dimension(3) :: test = (/2, 1, (3)/)
+  real(dp), intent(out) :: x
+
+  x = myparamarray(1)+test(3)
+
+  return
+end subroutine
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/parameter/constant_both.f90 b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/parameter/constant_both.f90
new file mode 100644
index 00000000..ac90cedc
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/parameter/constant_both.f90
@@ -0,0 +1,57 @@
+! Check that parameters are correct intercepted.
+! Constants with comma separations are commonly
+! used, for instance Pi = 3._dp
+subroutine foo(x)
+  implicit none
+  integer, parameter :: sp = selected_real_kind(6)
+  integer, parameter :: dp = selected_real_kind(15)
+  integer, parameter :: ii = selected_int_kind(9)
+  integer, parameter :: il = selected_int_kind(18)
+  real(dp), intent(inout) :: x
+  dimension x(3)
+  real(sp), parameter :: three_s = 3._sp
+  real(dp), parameter :: three_d = 3._dp
+  integer(ii), parameter :: three_i = 3_ii
+  integer(il), parameter :: three_l = 3_il
+  x(1) = x(1) + x(2) * three_s * three_i + x(3) * three_d * three_l
+  x(2) = x(2) * three_s
+  x(3) = x(3) * three_l
+  return
+end subroutine
+
+
+subroutine foo_no(x)
+  implicit none
+  integer, parameter :: sp = selected_real_kind(6)
+  integer, parameter :: dp = selected_real_kind(15)
+  integer, parameter :: ii = selected_int_kind(9)
+  integer, parameter :: il = selected_int_kind(18)
+  real(dp), intent(inout) :: x
+  dimension x(3)
+  real(sp), parameter :: three_s = 3.
+  real(dp), parameter :: three_d = 3.
+  integer(ii), parameter :: three_i = 3
+  integer(il), parameter :: three_l = 3
+  x(1) = x(1) + x(2) * three_s * three_i + x(3) * three_d * three_l
+  x(2) = x(2) * three_s
+  x(3) = x(3) * three_l
+  return
+end subroutine
+
+subroutine foo_sum(x)
+  implicit none
+  integer, parameter :: sp = selected_real_kind(6)
+  integer, parameter :: dp = selected_real_kind(15)
+  integer, parameter :: ii = selected_int_kind(9)
+  integer, parameter :: il = selected_int_kind(18)
+  real(dp), intent(inout) :: x
+  dimension x(3)
+  real(sp), parameter :: three_s = 2._sp + 1._sp
+  real(dp), parameter :: three_d = 1._dp + 2._dp
+  integer(ii), parameter :: three_i = 2_ii + 1_ii
+  integer(il), parameter :: three_l = 1_il + 2_il
+  x(1) = x(1) + x(2) * three_s * three_i + x(3) * three_d * three_l
+  x(2) = x(2) * three_s
+  x(3) = x(3) * three_l
+  return
+end subroutine
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/parameter/constant_compound.f90 b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/parameter/constant_compound.f90
new file mode 100644
index 00000000..e51f5e9b
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/parameter/constant_compound.f90
@@ -0,0 +1,15 @@
+! Check that parameters are correct intercepted.
+! Constants with comma separations are commonly
+! used, for instance Pi = 3._dp
+subroutine foo_compound_int(x)
+  implicit none
+  integer, parameter :: ii = selected_int_kind(9)
+  integer(ii), intent(inout) :: x
+  dimension x(3)
+  integer(ii), parameter :: three = 3_ii
+  integer(ii), parameter :: two = 2_ii
+  integer(ii), parameter :: six = three * 1_ii * two
+
+  x(1) = x(1) + x(2) + x(3) * six
+  return
+end subroutine
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/parameter/constant_integer.f90 b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/parameter/constant_integer.f90
new file mode 100644
index 00000000..aaa83d2e
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/parameter/constant_integer.f90
@@ -0,0 +1,22 @@
+! Check that parameters are correct intercepted.
+! Constants with comma separations are commonly
+! used, for instance Pi = 3._dp
+subroutine foo_int(x)
+  implicit none
+  integer, parameter :: ii = selected_int_kind(9)
+  integer(ii), intent(inout) :: x
+  dimension x(3)
+  integer(ii), parameter :: three = 3_ii
+  x(1) = x(1) + x(2) + x(3) * three
+  return
+end subroutine
+
+subroutine foo_long(x)
+  implicit none
+  integer, parameter :: ii = selected_int_kind(18)
+  integer(ii), intent(inout) :: x
+  dimension x(3)
+  integer(ii), parameter :: three = 3_ii
+  x(1) = x(1) + x(2) + x(3) * three
+  return
+end subroutine
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/parameter/constant_non_compound.f90 b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/parameter/constant_non_compound.f90
new file mode 100644
index 00000000..62c9a5b9
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/parameter/constant_non_compound.f90
@@ -0,0 +1,23 @@
+! Check that parameters are correct intercepted.
+! Specifically that types of constants without 
+! compound kind specs are correctly inferred
+! adapted Gibbs iteration code from pymc 
+! for this test case 
+subroutine foo_non_compound_int(x)
+  implicit none
+  integer, parameter :: ii = selected_int_kind(9)
+
+  integer(ii)   maxiterates
+  parameter (maxiterates=2)
+
+  integer(ii)   maxseries
+  parameter (maxseries=2)
+
+  integer(ii)   wasize
+  parameter (wasize=maxiterates*maxseries)
+  integer(ii), intent(inout) :: x
+  dimension x(wasize)
+
+  x(1) = x(1) + x(2) + x(3) + x(4) * wasize
+  return
+end subroutine
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/parameter/constant_real.f90 b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/parameter/constant_real.f90
new file mode 100644
index 00000000..02ac9dd9
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/parameter/constant_real.f90
@@ -0,0 +1,23 @@
+! Check that parameters are correct intercepted.
+! Constants with comma separations are commonly
+! used, for instance Pi = 3._dp
+subroutine foo_single(x)
+  implicit none
+  integer, parameter :: rp = selected_real_kind(6)
+  real(rp), intent(inout) :: x
+  dimension x(3)
+  real(rp), parameter :: three = 3._rp
+  x(1) = x(1) + x(2) + x(3) * three
+  return
+end subroutine
+
+subroutine foo_double(x)
+  implicit none
+  integer, parameter :: rp = selected_real_kind(15)
+  real(rp), intent(inout) :: x
+  dimension x(3)
+  real(rp), parameter :: three = 3._rp
+  x(1) = x(1) + x(2) + x(3) * three
+  return
+end subroutine
+
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/quoted_character/foo.f b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/quoted_character/foo.f
new file mode 100644
index 00000000..9dc1cfa4
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/quoted_character/foo.f
@@ -0,0 +1,14 @@
+      SUBROUTINE FOO(OUT1, OUT2, OUT3, OUT4, OUT5, OUT6)
+      CHARACTER SINGLE, DOUBLE, SEMICOL, EXCLA, OPENPAR, CLOSEPAR
+      PARAMETER (SINGLE="'", DOUBLE='"', SEMICOL=';', EXCLA="!",
+     1           OPENPAR="(", CLOSEPAR=")")
+      CHARACTER OUT1, OUT2, OUT3, OUT4, OUT5, OUT6
+Cf2py intent(out) OUT1, OUT2, OUT3, OUT4, OUT5, OUT6
+      OUT1 = SINGLE
+      OUT2 = DOUBLE
+      OUT3 = SEMICOL
+      OUT4 = EXCLA
+      OUT5 = OPENPAR
+      OUT6 = CLOSEPAR
+      RETURN
+      END
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/regression/AB.inc b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/regression/AB.inc
new file mode 100644
index 00000000..8a02f631
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/regression/AB.inc
@@ -0,0 +1 @@
+real(8) b, n, m
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/regression/f77comments.f b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/regression/f77comments.f
new file mode 100644
index 00000000..452a01a1
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/regression/f77comments.f
@@ -0,0 +1,26 @@
+      SUBROUTINE TESTSUB(
+     &    INPUT1, INPUT2,                                 !Input
+     &    OUTPUT1, OUTPUT2)                               !Output
+
+      IMPLICIT NONE
+      INTEGER, INTENT(IN) :: INPUT1, INPUT2
+      INTEGER, INTENT(OUT) :: OUTPUT1, OUTPUT2
+
+      OUTPUT1 = INPUT1 + INPUT2
+      OUTPUT2 = INPUT1 * INPUT2
+
+      RETURN
+      END SUBROUTINE TESTSUB
+
+      SUBROUTINE TESTSUB2(OUTPUT)
+      IMPLICIT NONE
+      INTEGER, PARAMETER :: N = 10 ! Array dimension
+      REAL, INTENT(OUT) :: OUTPUT(N)
+      INTEGER :: I
+
+      DO I = 1, N
+         OUTPUT(I) = I * 2.0
+      END DO
+
+      RETURN
+      END
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/regression/f77fixedform.f95 b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/regression/f77fixedform.f95
new file mode 100644
index 00000000..e47a13f7
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/regression/f77fixedform.f95
@@ -0,0 +1,5 @@
+C This is an invalid file, but it does compile with -ffixed-form
+      subroutine mwe(
+     & x)
+          real x
+      end subroutine mwe
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/regression/f90continuation.f90 b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/regression/f90continuation.f90
new file mode 100644
index 00000000..879e716b
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/regression/f90continuation.f90
@@ -0,0 +1,9 @@
+SUBROUTINE TESTSUB(INPUT1, & ! Hello
+! commenty
+INPUT2, OUTPUT1, OUTPUT2) ! more comments
+    INTEGER, INTENT(IN) :: INPUT1, INPUT2
+    INTEGER, INTENT(OUT) :: OUTPUT1, OUTPUT2
+    OUTPUT1 = INPUT1 + &
+              INPUT2
+    OUTPUT2 = INPUT1 * INPUT2
+END SUBROUTINE TESTSUB
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/regression/incfile.f90 b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/regression/incfile.f90
new file mode 100644
index 00000000..276ef3a6
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/regression/incfile.f90
@@ -0,0 +1,5 @@
+function add(n,m) result(b)
+  implicit none
+  include 'AB.inc'
+  b = n + m
+end function add
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/regression/inout.f90 b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/regression/inout.f90
new file mode 100644
index 00000000..80cdad90
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/regression/inout.f90
@@ -0,0 +1,9 @@
+! Check that intent(in out) translates as intent(inout).
+! The separation seems to be a common usage.
+      subroutine foo(x)
+          implicit none
+          real(4), intent(in out) :: x
+          dimension x(3)
+          x(1) = x(1) + x(2) + x(3)
+          return
+      end
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/return_character/foo77.f b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/return_character/foo77.f
new file mode 100644
index 00000000..facae101
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/return_character/foo77.f
@@ -0,0 +1,45 @@
+       function t0(value)
+         character value
+         character t0
+         t0 = value
+       end
+       function t1(value)
+         character*1 value
+         character*1 t1
+         t1 = value
+       end
+       function t5(value)
+         character*5 value
+         character*5 t5
+         t5 = value
+       end
+       function ts(value)
+         character*(*) value
+         character*(*) ts
+         ts = value
+       end
+
+       subroutine s0(t0,value)
+         character value
+         character t0
+cf2py    intent(out) t0
+         t0 = value
+       end
+       subroutine s1(t1,value)
+         character*1 value
+         character*1 t1
+cf2py    intent(out) t1
+         t1 = value
+       end
+       subroutine s5(t5,value)
+         character*5 value
+         character*5 t5
+cf2py    intent(out) t5
+         t5 = value
+       end
+       subroutine ss(ts,value)
+         character*(*) value
+         character*10 ts
+cf2py    intent(out) ts
+         ts = value
+       end
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/return_character/foo90.f90 b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/return_character/foo90.f90
new file mode 100644
index 00000000..36182bcf
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/return_character/foo90.f90
@@ -0,0 +1,48 @@
+module f90_return_char
+  contains
+       function t0(value)
+         character :: value
+         character :: t0
+         t0 = value
+       end function t0
+       function t1(value)
+         character(len=1) :: value
+         character(len=1) :: t1
+         t1 = value
+       end function t1
+       function t5(value)
+         character(len=5) :: value
+         character(len=5) :: t5
+         t5 = value
+       end function t5
+       function ts(value)
+         character(len=*) :: value
+         character(len=10) :: ts
+         ts = value
+       end function ts
+
+       subroutine s0(t0,value)
+         character :: value
+         character :: t0
+!f2py    intent(out) t0
+         t0 = value
+       end subroutine s0
+       subroutine s1(t1,value)
+         character(len=1) :: value
+         character(len=1) :: t1
+!f2py    intent(out) t1
+         t1 = value
+       end subroutine s1
+       subroutine s5(t5,value)
+         character(len=5) :: value
+         character(len=5) :: t5
+!f2py    intent(out) t5
+         t5 = value
+       end subroutine s5
+       subroutine ss(ts,value)
+         character(len=*) :: value
+         character(len=10) :: ts
+!f2py    intent(out) ts
+         ts = value
+       end subroutine ss
+end module f90_return_char
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/return_complex/foo77.f b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/return_complex/foo77.f
new file mode 100644
index 00000000..37a1ec84
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/return_complex/foo77.f
@@ -0,0 +1,45 @@
+       function t0(value)
+         complex value
+         complex t0
+         t0 = value
+       end
+       function t8(value)
+         complex*8 value
+         complex*8 t8
+         t8 = value
+       end
+       function t16(value)
+         complex*16 value
+         complex*16 t16
+         t16 = value
+       end
+       function td(value)
+         double complex value
+         double complex td
+         td = value
+       end
+
+       subroutine s0(t0,value)
+         complex value
+         complex t0
+cf2py    intent(out) t0
+         t0 = value
+       end
+       subroutine s8(t8,value)
+         complex*8 value
+         complex*8 t8
+cf2py    intent(out) t8
+         t8 = value
+       end
+       subroutine s16(t16,value)
+         complex*16 value
+         complex*16 t16
+cf2py    intent(out) t16
+         t16 = value
+       end
+       subroutine sd(td,value)
+         double complex value
+         double complex td
+cf2py    intent(out) td
+         td = value
+       end
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/return_complex/foo90.f90 b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/return_complex/foo90.f90
new file mode 100644
index 00000000..adc27b47
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/return_complex/foo90.f90
@@ -0,0 +1,48 @@
+module f90_return_complex
+  contains
+       function t0(value)
+         complex :: value
+         complex :: t0
+         t0 = value
+       end function t0
+       function t8(value)
+         complex(kind=4) :: value
+         complex(kind=4) :: t8
+         t8 = value
+       end function t8
+       function t16(value)
+         complex(kind=8) :: value
+         complex(kind=8) :: t16
+         t16 = value
+       end function t16
+       function td(value)
+         double complex :: value
+         double complex :: td
+         td = value
+       end function td
+
+       subroutine s0(t0,value)
+         complex :: value
+         complex :: t0
+!f2py    intent(out) t0
+         t0 = value
+       end subroutine s0
+       subroutine s8(t8,value)
+         complex(kind=4) :: value
+         complex(kind=4) :: t8
+!f2py    intent(out) t8
+         t8 = value
+       end subroutine s8
+       subroutine s16(t16,value)
+         complex(kind=8) :: value
+         complex(kind=8) :: t16
+!f2py    intent(out) t16
+         t16 = value
+       end subroutine s16
+       subroutine sd(td,value)
+         double complex :: value
+         double complex :: td
+!f2py    intent(out) td
+         td = value
+       end subroutine sd
+end module f90_return_complex
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/return_integer/foo77.f b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/return_integer/foo77.f
new file mode 100644
index 00000000..1ab895b9
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/return_integer/foo77.f
@@ -0,0 +1,56 @@
+       function t0(value)
+         integer value
+         integer t0
+         t0 = value
+       end
+       function t1(value)
+         integer*1 value
+         integer*1 t1
+         t1 = value
+       end
+       function t2(value)
+         integer*2 value
+         integer*2 t2
+         t2 = value
+       end
+       function t4(value)
+         integer*4 value
+         integer*4 t4
+         t4 = value
+       end
+       function t8(value)
+         integer*8 value
+         integer*8 t8
+         t8 = value
+       end
+
+       subroutine s0(t0,value)
+         integer value
+         integer t0
+cf2py    intent(out) t0
+         t0 = value
+       end
+       subroutine s1(t1,value)
+         integer*1 value
+         integer*1 t1
+cf2py    intent(out) t1
+         t1 = value
+       end
+       subroutine s2(t2,value)
+         integer*2 value
+         integer*2 t2
+cf2py    intent(out) t2
+         t2 = value
+       end
+       subroutine s4(t4,value)
+         integer*4 value
+         integer*4 t4
+cf2py    intent(out) t4
+         t4 = value
+       end
+       subroutine s8(t8,value)
+         integer*8 value
+         integer*8 t8
+cf2py    intent(out) t8
+         t8 = value
+       end
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/return_integer/foo90.f90 b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/return_integer/foo90.f90
new file mode 100644
index 00000000..ba9249aa
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/return_integer/foo90.f90
@@ -0,0 +1,59 @@
+module f90_return_integer
+  contains
+       function t0(value)
+         integer :: value
+         integer :: t0
+         t0 = value
+       end function t0
+       function t1(value)
+         integer(kind=1) :: value
+         integer(kind=1) :: t1
+         t1 = value
+       end function t1
+       function t2(value)
+         integer(kind=2) :: value
+         integer(kind=2) :: t2
+         t2 = value
+       end function t2
+       function t4(value)
+         integer(kind=4) :: value
+         integer(kind=4) :: t4
+         t4 = value
+       end function t4
+       function t8(value)
+         integer(kind=8) :: value
+         integer(kind=8) :: t8
+         t8 = value
+       end function t8
+
+       subroutine s0(t0,value)
+         integer :: value
+         integer :: t0
+!f2py    intent(out) t0
+         t0 = value
+       end subroutine s0
+       subroutine s1(t1,value)
+         integer(kind=1) :: value
+         integer(kind=1) :: t1
+!f2py    intent(out) t1
+         t1 = value
+       end subroutine s1
+       subroutine s2(t2,value)
+         integer(kind=2) :: value
+         integer(kind=2) :: t2
+!f2py    intent(out) t2
+         t2 = value
+       end subroutine s2
+       subroutine s4(t4,value)
+         integer(kind=4) :: value
+         integer(kind=4) :: t4
+!f2py    intent(out) t4
+         t4 = value
+       end subroutine s4
+       subroutine s8(t8,value)
+         integer(kind=8) :: value
+         integer(kind=8) :: t8
+!f2py    intent(out) t8
+         t8 = value
+       end subroutine s8
+end module f90_return_integer
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/return_logical/foo77.f b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/return_logical/foo77.f
new file mode 100644
index 00000000..ef530145
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/return_logical/foo77.f
@@ -0,0 +1,56 @@
+       function t0(value)
+         logical value
+         logical t0
+         t0 = value
+       end
+       function t1(value)
+         logical*1 value
+         logical*1 t1
+         t1 = value
+       end
+       function t2(value)
+         logical*2 value
+         logical*2 t2
+         t2 = value
+       end
+       function t4(value)
+         logical*4 value
+         logical*4 t4
+         t4 = value
+       end
+c       function t8(value)
+c         logical*8 value
+c         logical*8 t8
+c         t8 = value
+c       end
+
+       subroutine s0(t0,value)
+         logical value
+         logical t0
+cf2py    intent(out) t0
+         t0 = value
+       end
+       subroutine s1(t1,value)
+         logical*1 value
+         logical*1 t1
+cf2py    intent(out) t1
+         t1 = value
+       end
+       subroutine s2(t2,value)
+         logical*2 value
+         logical*2 t2
+cf2py    intent(out) t2
+         t2 = value
+       end
+       subroutine s4(t4,value)
+         logical*4 value
+         logical*4 t4
+cf2py    intent(out) t4
+         t4 = value
+       end
+c       subroutine s8(t8,value)
+c         logical*8 value
+c         logical*8 t8
+cf2py    intent(out) t8
+c         t8 = value
+c       end
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/return_logical/foo90.f90 b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/return_logical/foo90.f90
new file mode 100644
index 00000000..a4526468
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/return_logical/foo90.f90
@@ -0,0 +1,59 @@
+module f90_return_logical
+  contains
+       function t0(value)
+         logical :: value
+         logical :: t0
+         t0 = value
+       end function t0
+       function t1(value)
+         logical(kind=1) :: value
+         logical(kind=1) :: t1
+         t1 = value
+       end function t1
+       function t2(value)
+         logical(kind=2) :: value
+         logical(kind=2) :: t2
+         t2 = value
+       end function t2
+       function t4(value)
+         logical(kind=4) :: value
+         logical(kind=4) :: t4
+         t4 = value
+       end function t4
+       function t8(value)
+         logical(kind=8) :: value
+         logical(kind=8) :: t8
+         t8 = value
+       end function t8
+
+       subroutine s0(t0,value)
+         logical :: value
+         logical :: t0
+!f2py    intent(out) t0
+         t0 = value
+       end subroutine s0
+       subroutine s1(t1,value)
+         logical(kind=1) :: value
+         logical(kind=1) :: t1
+!f2py    intent(out) t1
+         t1 = value
+       end subroutine s1
+       subroutine s2(t2,value)
+         logical(kind=2) :: value
+         logical(kind=2) :: t2
+!f2py    intent(out) t2
+         t2 = value
+       end subroutine s2
+       subroutine s4(t4,value)
+         logical(kind=4) :: value
+         logical(kind=4) :: t4
+!f2py    intent(out) t4
+         t4 = value
+       end subroutine s4
+       subroutine s8(t8,value)
+         logical(kind=8) :: value
+         logical(kind=8) :: t8
+!f2py    intent(out) t8
+         t8 = value
+       end subroutine s8
+end module f90_return_logical
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/return_real/foo77.f b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/return_real/foo77.f
new file mode 100644
index 00000000..bf43dbf1
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/return_real/foo77.f
@@ -0,0 +1,45 @@
+       function t0(value)
+         real value
+         real t0
+         t0 = value
+       end
+       function t4(value)
+         real*4 value
+         real*4 t4
+         t4 = value
+       end
+       function t8(value)
+         real*8 value
+         real*8 t8
+         t8 = value
+       end
+       function td(value)
+         double precision value
+         double precision td
+         td = value
+       end
+
+       subroutine s0(t0,value)
+         real value
+         real t0
+cf2py    intent(out) t0
+         t0 = value
+       end
+       subroutine s4(t4,value)
+         real*4 value
+         real*4 t4
+cf2py    intent(out) t4
+         t4 = value
+       end
+       subroutine s8(t8,value)
+         real*8 value
+         real*8 t8
+cf2py    intent(out) t8
+         t8 = value
+       end
+       subroutine sd(td,value)
+         double precision value
+         double precision td
+cf2py    intent(out) td
+         td = value
+       end
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/return_real/foo90.f90 b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/return_real/foo90.f90
new file mode 100644
index 00000000..df971998
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/return_real/foo90.f90
@@ -0,0 +1,48 @@
+module f90_return_real
+  contains
+       function t0(value)
+         real :: value
+         real :: t0
+         t0 = value
+       end function t0
+       function t4(value)
+         real(kind=4) :: value
+         real(kind=4) :: t4
+         t4 = value
+       end function t4
+       function t8(value)
+         real(kind=8) :: value
+         real(kind=8) :: t8
+         t8 = value
+       end function t8
+       function td(value)
+         double precision :: value
+         double precision :: td
+         td = value
+       end function td
+
+       subroutine s0(t0,value)
+         real :: value
+         real :: t0
+!f2py    intent(out) t0
+         t0 = value
+       end subroutine s0
+       subroutine s4(t4,value)
+         real(kind=4) :: value
+         real(kind=4) :: t4
+!f2py    intent(out) t4
+         t4 = value
+       end subroutine s4
+       subroutine s8(t8,value)
+         real(kind=8) :: value
+         real(kind=8) :: t8
+!f2py    intent(out) t8
+         t8 = value
+       end subroutine s8
+       subroutine sd(td,value)
+         double precision :: value
+         double precision :: td
+!f2py    intent(out) td
+         td = value
+       end subroutine sd
+end module f90_return_real
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/size/foo.f90 b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/size/foo.f90
new file mode 100644
index 00000000..5b66f8c4
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/size/foo.f90
@@ -0,0 +1,44 @@
+
+subroutine foo(a, n, m, b)
+  implicit none
+
+  real, intent(in) :: a(n, m)
+  integer, intent(in) :: n, m
+  real, intent(out) :: b(size(a, 1))
+
+  integer :: i
+
+  do i = 1, size(b)
+    b(i) = sum(a(i,:))
+  enddo
+end subroutine
+
+subroutine trans(x,y)
+  implicit none
+  real, intent(in), dimension(:,:) :: x
+  real, intent(out), dimension( size(x,2), size(x,1) ) :: y
+  integer :: N, M, i, j
+  N = size(x,1)
+  M = size(x,2)
+  DO i=1,N
+     do j=1,M
+        y(j,i) = x(i,j)
+     END DO
+  END DO
+end subroutine trans
+
+subroutine flatten(x,y)
+  implicit none
+  real, intent(in), dimension(:,:) :: x
+  real, intent(out), dimension( size(x) ) :: y
+  integer :: N, M, i, j, k
+  N = size(x,1)
+  M = size(x,2)
+  k = 1
+  DO i=1,N
+     do j=1,M
+        y(k) = x(i,j)
+        k = k + 1
+     END DO
+  END DO
+end subroutine flatten
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/string/char.f90 b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/string/char.f90
new file mode 100644
index 00000000..bb7985ce
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/string/char.f90
@@ -0,0 +1,29 @@
+MODULE char_test
+
+CONTAINS
+
+SUBROUTINE change_strings(strings, n_strs, out_strings)
+    IMPLICIT NONE
+
+    ! Inputs
+    INTEGER, INTENT(IN) :: n_strs
+    CHARACTER, INTENT(IN), DIMENSION(2,n_strs) :: strings
+    CHARACTER, INTENT(OUT), DIMENSION(2,n_strs) :: out_strings
+
+!f2py INTEGER, INTENT(IN) :: n_strs
+!f2py CHARACTER, INTENT(IN), DIMENSION(2,n_strs) :: strings
+!f2py CHARACTER, INTENT(OUT), DIMENSION(2,n_strs) :: strings
+
+    ! Misc.
+    INTEGER*4 :: j
+
+
+    DO j=1, n_strs
+        out_strings(1,j) = strings(1,j)
+        out_strings(2,j) = 'A'
+    END DO
+
+END SUBROUTINE change_strings
+
+END MODULE char_test
+
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/string/fixed_string.f90 b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/string/fixed_string.f90
new file mode 100644
index 00000000..7fd15854
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/string/fixed_string.f90
@@ -0,0 +1,34 @@
+function sint(s) result(i)
+   implicit none
+   character(len=*) :: s
+   integer :: j, i
+   i = 0
+   do j=len(s), 1, -1
+    if (.not.((i.eq.0).and.(s(j:j).eq.' '))) then
+      i = i + ichar(s(j:j)) * 10 ** (j - 1)
+    endif
+   end do
+   return
+ end function sint
+
+ function test_in_bytes4(a) result (i)
+   implicit none
+   integer :: sint
+   character(len=4) :: a
+   integer :: i
+   i = sint(a)
+   a(1:1) = 'A'
+   return
+ end function test_in_bytes4
+
+ function test_inout_bytes4(a) result (i)
+   implicit none
+   integer :: sint
+   character(len=4), intent(inout) :: a
+   integer :: i
+   if (a(1:1).ne.' ') then
+     a(1:1) = 'E'
+   endif
+   i = sint(a)
+   return
+ end function test_inout_bytes4
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/string/gh24008.f b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/string/gh24008.f
new file mode 100644
index 00000000..ab64cf77
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/string/gh24008.f
@@ -0,0 +1,8 @@
+      SUBROUTINE GREET(NAME, GREETING)
+      CHARACTER NAME*(*), GREETING*(*)
+      CHARACTER*(50) MESSAGE
+
+      MESSAGE = 'Hello, ' // NAME // ', ' // GREETING
+c$$$      PRINT *, MESSAGE
+
+      END SUBROUTINE GREET
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/string/gh24662.f90 b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/string/gh24662.f90
new file mode 100644
index 00000000..ca53413c
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/string/gh24662.f90
@@ -0,0 +1,7 @@
+subroutine string_inout_optional(output)
+    implicit none
+    character*(32), optional, intent(inout) :: output
+    if (present(output)) then
+      output="output string"
+    endif
+end subroutine
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/string/gh25286.f90 b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/string/gh25286.f90
new file mode 100644
index 00000000..db1c7100
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/string/gh25286.f90
@@ -0,0 +1,14 @@
+subroutine charint(trans, info)
+    character, intent(in) :: trans
+    integer, intent(out) :: info
+    if (trans == 'N') then
+        info = 1
+    else if (trans == 'T') then
+        info = 2
+    else if (trans == 'C') then
+        info = 3
+    else
+        info = -1
+    end if
+
+end subroutine charint
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/string/gh25286.pyf b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/string/gh25286.pyf
new file mode 100644
index 00000000..7b960907
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/string/gh25286.pyf
@@ -0,0 +1,12 @@
+python module _char_handling_test
+    interface
+    subroutine charint(trans, info)
+        callstatement (*f2py_func)(&trans, &info)
+        callprotoargument char*, int*
+
+        character, intent(in), check(trans=='N'||trans=='T'||trans=='C') :: trans = 'N'
+        integer intent(out) :: info
+
+    end subroutine charint
+    end interface
+end python module _char_handling_test
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/string/gh25286_bc.pyf b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/string/gh25286_bc.pyf
new file mode 100644
index 00000000..e7b10fa9
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/string/gh25286_bc.pyf
@@ -0,0 +1,12 @@
+python module _char_handling_test
+    interface
+    subroutine charint(trans, info)
+        callstatement (*f2py_func)(&trans, &info)
+        callprotoargument char*, int*
+
+        character, intent(in), check(*trans=='N'||*trans=='T'||*trans=='C') :: trans = 'N'
+        integer intent(out) :: info
+
+    end subroutine charint
+    end interface
+end python module _char_handling_test
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/string/scalar_string.f90 b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/string/scalar_string.f90
new file mode 100644
index 00000000..f8f07617
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/string/scalar_string.f90
@@ -0,0 +1,9 @@
+MODULE string_test
+
+  character(len=8) :: string
+  character string77 * 8
+
+  character(len=12), dimension(5,7) :: strarr
+  character strarr77(5,7) * 12
+
+END MODULE string_test
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/string/string.f b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/string/string.f
new file mode 100644
index 00000000..5210ca4d
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/string/string.f
@@ -0,0 +1,12 @@
+C FILE: STRING.F
+      SUBROUTINE FOO(A,B,C,D)
+      CHARACTER*5 A, B
+      CHARACTER*(*) C,D
+Cf2py intent(in) a,c
+Cf2py intent(inout) b,d
+      A(1:1) = 'A'
+      B(1:1) = 'B'
+      C(1:1) = 'C'
+      D(1:1) = 'D'
+      END
+C END OF FILE STRING.F
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/value_attrspec/gh21665.f90 b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/value_attrspec/gh21665.f90
new file mode 100644
index 00000000..7d9dc0fd
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/tests/src/value_attrspec/gh21665.f90
@@ -0,0 +1,9 @@
+module fortfuncs
+  implicit none
+contains
+  subroutine square(x,y)
+    integer, intent(in), value :: x
+    integer, intent(out) :: y
+    y = x*x
+  end subroutine square
+end module fortfuncs
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/test_abstract_interface.py b/venv/lib/python3.12/site-packages/numpy/f2py/tests/test_abstract_interface.py
new file mode 100644
index 00000000..2c6555ae
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/tests/test_abstract_interface.py
@@ -0,0 +1,26 @@
+from pathlib import Path
+import pytest
+import textwrap
+from . import util
+from numpy.f2py import crackfortran
+from numpy.testing import IS_WASM
+
+
+@pytest.mark.skipif(IS_WASM, reason="Cannot start subprocess")
+@pytest.mark.slow
+class TestAbstractInterface(util.F2PyTest):
+    sources = [util.getpath("tests", "src", "abstract_interface", "foo.f90")]
+
+    skip = ["add1", "add2"]
+
+    def test_abstract_interface(self):
+        assert self.module.ops_module.foo(3, 5) == (8, 13)
+
+    def test_parse_abstract_interface(self):
+        # Test gh18403
+        fpath = util.getpath("tests", "src", "abstract_interface",
+                             "gh18403_mod.f90")
+        mod = crackfortran.crackfortran([str(fpath)])
+        assert len(mod) == 1
+        assert len(mod[0]["body"]) == 1
+        assert mod[0]["body"][0]["block"] == "abstract interface"
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/test_array_from_pyobj.py b/venv/lib/python3.12/site-packages/numpy/f2py/tests/test_array_from_pyobj.py
new file mode 100644
index 00000000..c10fe75a
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/tests/test_array_from_pyobj.py
@@ -0,0 +1,679 @@
+import os
+import sys
+import copy
+import platform
+import pytest
+from pathlib import Path
+
+import numpy as np
+
+from numpy.testing import assert_, assert_equal
+from numpy._core._type_aliases import c_names_dict as _c_names_dict
+from . import util
+
+wrap = None
+
+# Extend core typeinfo with CHARACTER to test dtype('c')
+c_names_dict = dict(
+    CHARACTER=np.dtype("c"),
+    **_c_names_dict
+)
+
+
+def get_testdir():
+    testroot = Path(__file__).resolve().parent / "src"
+    return  testroot / "array_from_pyobj"
+
+def setup_module():
+    """
+    Build the required testing extension module
+
+    """
+    global wrap
+
+    if wrap is None:
+        src = [
+            get_testdir() / "wrapmodule.c",
+        ]
+        wrap = util.build_meson(src, module_name = "test_array_from_pyobj_ext")
+
+
+def flags_info(arr):
+    flags = wrap.array_attrs(arr)[6]
+    return flags2names(flags)
+
+
+def flags2names(flags):
+    info = []
+    for flagname in [
+            "CONTIGUOUS",
+            "FORTRAN",
+            "OWNDATA",
+            "ENSURECOPY",
+            "ENSUREARRAY",
+            "ALIGNED",
+            "NOTSWAPPED",
+            "WRITEABLE",
+            "WRITEBACKIFCOPY",
+            "UPDATEIFCOPY",
+            "BEHAVED",
+            "BEHAVED_RO",
+            "CARRAY",
+            "FARRAY",
+    ]:
+        if abs(flags) & getattr(wrap, flagname, 0):
+            info.append(flagname)
+    return info
+
+
+class Intent:
+    def __init__(self, intent_list=[]):
+        self.intent_list = intent_list[:]
+        flags = 0
+        for i in intent_list:
+            if i == "optional":
+                flags |= wrap.F2PY_OPTIONAL
+            else:
+                flags |= getattr(wrap, "F2PY_INTENT_" + i.upper())
+        self.flags = flags
+
+    def __getattr__(self, name):
+        name = name.lower()
+        if name == "in_":
+            name = "in"
+        return self.__class__(self.intent_list + [name])
+
+    def __str__(self):
+        return "intent(%s)" % (",".join(self.intent_list))
+
+    def __repr__(self):
+        return "Intent(%r)" % (self.intent_list)
+
+    def is_intent(self, *names):
+        return all(name in self.intent_list for name in names)
+
+    def is_intent_exact(self, *names):
+        return len(self.intent_list) == len(names) and self.is_intent(*names)
+
+
+intent = Intent()
+
+_type_names = [
+    "BOOL",
+    "BYTE",
+    "UBYTE",
+    "SHORT",
+    "USHORT",
+    "INT",
+    "UINT",
+    "LONG",
+    "ULONG",
+    "LONGLONG",
+    "ULONGLONG",
+    "FLOAT",
+    "DOUBLE",
+    "CFLOAT",
+    "STRING1",
+    "STRING5",
+    "CHARACTER",
+]
+
+_cast_dict = {"BOOL": ["BOOL"]}
+_cast_dict["BYTE"] = _cast_dict["BOOL"] + ["BYTE"]
+_cast_dict["UBYTE"] = _cast_dict["BOOL"] + ["UBYTE"]
+_cast_dict["BYTE"] = ["BYTE"]
+_cast_dict["UBYTE"] = ["UBYTE"]
+_cast_dict["SHORT"] = _cast_dict["BYTE"] + ["UBYTE", "SHORT"]
+_cast_dict["USHORT"] = _cast_dict["UBYTE"] + ["BYTE", "USHORT"]
+_cast_dict["INT"] = _cast_dict["SHORT"] + ["USHORT", "INT"]
+_cast_dict["UINT"] = _cast_dict["USHORT"] + ["SHORT", "UINT"]
+
+_cast_dict["LONG"] = _cast_dict["INT"] + ["LONG"]
+_cast_dict["ULONG"] = _cast_dict["UINT"] + ["ULONG"]
+
+_cast_dict["LONGLONG"] = _cast_dict["LONG"] + ["LONGLONG"]
+_cast_dict["ULONGLONG"] = _cast_dict["ULONG"] + ["ULONGLONG"]
+
+_cast_dict["FLOAT"] = _cast_dict["SHORT"] + ["USHORT", "FLOAT"]
+_cast_dict["DOUBLE"] = _cast_dict["INT"] + ["UINT", "FLOAT", "DOUBLE"]
+
+_cast_dict["CFLOAT"] = _cast_dict["FLOAT"] + ["CFLOAT"]
+
+_cast_dict['STRING1'] = ['STRING1']
+_cast_dict['STRING5'] = ['STRING5']
+_cast_dict['CHARACTER'] = ['CHARACTER']
+
+# 32 bit system malloc typically does not provide the alignment required by
+# 16 byte long double types this means the inout intent cannot be satisfied
+# and several tests fail as the alignment flag can be randomly true or fals
+# when numpy gains an aligned allocator the tests could be enabled again
+#
+# Furthermore, on macOS ARM64, LONGDOUBLE is an alias for DOUBLE.
+if ((np.intp().dtype.itemsize != 4 or np.clongdouble().dtype.alignment <= 8)
+        and sys.platform != "win32"
+        and (platform.system(), platform.processor()) != ("Darwin", "arm")):
+    _type_names.extend(["LONGDOUBLE", "CDOUBLE", "CLONGDOUBLE"])
+    _cast_dict["LONGDOUBLE"] = _cast_dict["LONG"] + [
+        "ULONG",
+        "FLOAT",
+        "DOUBLE",
+        "LONGDOUBLE",
+    ]
+    _cast_dict["CLONGDOUBLE"] = _cast_dict["LONGDOUBLE"] + [
+        "CFLOAT",
+        "CDOUBLE",
+        "CLONGDOUBLE",
+    ]
+    _cast_dict["CDOUBLE"] = _cast_dict["DOUBLE"] + ["CFLOAT", "CDOUBLE"]
+
+
+class Type:
+    _type_cache = {}
+
+    def __new__(cls, name):
+        if isinstance(name, np.dtype):
+            dtype0 = name
+            name = None
+            for n, i in c_names_dict.items():
+                if not isinstance(i, type) and dtype0.type is i.type:
+                    name = n
+                    break
+        obj = cls._type_cache.get(name.upper(), None)
+        if obj is not None:
+            return obj
+        obj = object.__new__(cls)
+        obj._init(name)
+        cls._type_cache[name.upper()] = obj
+        return obj
+
+    def _init(self, name):
+        self.NAME = name.upper()
+
+        if self.NAME == 'CHARACTER':
+            info = c_names_dict[self.NAME]
+            self.type_num = getattr(wrap, 'NPY_STRING')
+            self.elsize = 1
+            self.dtype = np.dtype('c')
+        elif self.NAME.startswith('STRING'):
+            info = c_names_dict[self.NAME[:6]]
+            self.type_num = getattr(wrap, 'NPY_STRING')
+            self.elsize = int(self.NAME[6:] or 0)
+            self.dtype = np.dtype(f'S{self.elsize}')
+        else:
+            info = c_names_dict[self.NAME]
+            self.type_num = getattr(wrap, 'NPY_' + self.NAME)
+            self.elsize = info.itemsize
+            self.dtype = np.dtype(info.type)
+
+        assert self.type_num == info.num
+        self.type = info.type
+        self.dtypechar = info.char
+
+    def __repr__(self):
+        return (f"Type({self.NAME})|type_num={self.type_num},"
+                f" dtype={self.dtype},"
+                f" type={self.type}, elsize={self.elsize},"
+                f" dtypechar={self.dtypechar}")
+
+    def cast_types(self):
+        return [self.__class__(_m) for _m in _cast_dict[self.NAME]]
+
+    def all_types(self):
+        return [self.__class__(_m) for _m in _type_names]
+
+    def smaller_types(self):
+        bits = c_names_dict[self.NAME].alignment
+        types = []
+        for name in _type_names:
+            if c_names_dict[name].alignment < bits:
+                types.append(Type(name))
+        return types
+
+    def equal_types(self):
+        bits = c_names_dict[self.NAME].alignment
+        types = []
+        for name in _type_names:
+            if name == self.NAME:
+                continue
+            if c_names_dict[name].alignment == bits:
+                types.append(Type(name))
+        return types
+
+    def larger_types(self):
+        bits = c_names_dict[self.NAME].alignment
+        types = []
+        for name in _type_names:
+            if c_names_dict[name].alignment > bits:
+                types.append(Type(name))
+        return types
+
+
+class Array:
+
+    def __repr__(self):
+        return (f'Array({self.type}, {self.dims}, {self.intent},'
+                f' {self.obj})|arr={self.arr}')
+
+    def __init__(self, typ, dims, intent, obj):
+        self.type = typ
+        self.dims = dims
+        self.intent = intent
+        self.obj_copy = copy.deepcopy(obj)
+        self.obj = obj
+
+        # arr.dtypechar may be different from typ.dtypechar
+        self.arr = wrap.call(typ.type_num,
+                             typ.elsize,
+                             dims, intent.flags, obj)
+
+        assert isinstance(self.arr, np.ndarray)
+
+        self.arr_attr = wrap.array_attrs(self.arr)
+
+        if len(dims) > 1:
+            if self.intent.is_intent("c"):
+                assert (intent.flags & wrap.F2PY_INTENT_C)
+                assert not self.arr.flags["FORTRAN"]
+                assert self.arr.flags["CONTIGUOUS"]
+                assert (not self.arr_attr[6] & wrap.FORTRAN)
+            else:
+                assert (not intent.flags & wrap.F2PY_INTENT_C)
+                assert self.arr.flags["FORTRAN"]
+                assert not self.arr.flags["CONTIGUOUS"]
+                assert (self.arr_attr[6] & wrap.FORTRAN)
+
+        if obj is None:
+            self.pyarr = None
+            self.pyarr_attr = None
+            return
+
+        if intent.is_intent("cache"):
+            assert isinstance(obj, np.ndarray), repr(type(obj))
+            self.pyarr = np.array(obj).reshape(*dims).copy()
+        else:
+            self.pyarr = np.array(
+                np.array(obj, dtype=typ.dtypechar).reshape(*dims),
+                order=self.intent.is_intent("c") and "C" or "F",
+            )
+            assert self.pyarr.dtype == typ
+        self.pyarr.setflags(write=self.arr.flags["WRITEABLE"])
+        assert self.pyarr.flags["OWNDATA"], (obj, intent)
+        self.pyarr_attr = wrap.array_attrs(self.pyarr)
+
+        if len(dims) > 1:
+            if self.intent.is_intent("c"):
+                assert not self.pyarr.flags["FORTRAN"]
+                assert self.pyarr.flags["CONTIGUOUS"]
+                assert (not self.pyarr_attr[6] & wrap.FORTRAN)
+            else:
+                assert self.pyarr.flags["FORTRAN"]
+                assert not self.pyarr.flags["CONTIGUOUS"]
+                assert (self.pyarr_attr[6] & wrap.FORTRAN)
+
+        assert self.arr_attr[1] == self.pyarr_attr[1]  # nd
+        assert self.arr_attr[2] == self.pyarr_attr[2]  # dimensions
+        if self.arr_attr[1] <= 1:
+            assert self.arr_attr[3] == self.pyarr_attr[3], repr((
+                self.arr_attr[3],
+                self.pyarr_attr[3],
+                self.arr.tobytes(),
+                self.pyarr.tobytes(),
+            ))  # strides
+        assert self.arr_attr[5][-2:] == self.pyarr_attr[5][-2:], repr((
+            self.arr_attr[5], self.pyarr_attr[5]
+            ))  # descr
+        assert self.arr_attr[6] == self.pyarr_attr[6], repr((
+            self.arr_attr[6],
+            self.pyarr_attr[6],
+            flags2names(0 * self.arr_attr[6] - self.pyarr_attr[6]),
+            flags2names(self.arr_attr[6]),
+            intent,
+        ))  # flags
+
+        if intent.is_intent("cache"):
+            assert self.arr_attr[5][3] >= self.type.elsize
+        else:
+            assert self.arr_attr[5][3] == self.type.elsize
+            assert (self.arr_equal(self.pyarr, self.arr))
+
+        if isinstance(self.obj, np.ndarray):
+            if typ.elsize == Type(obj.dtype).elsize:
+                if not intent.is_intent("copy") and self.arr_attr[1] <= 1:
+                    assert self.has_shared_memory()
+
+    def arr_equal(self, arr1, arr2):
+        if arr1.shape != arr2.shape:
+            return False
+        return (arr1 == arr2).all()
+
+    def __str__(self):
+        return str(self.arr)
+
+    def has_shared_memory(self):
+        """Check that created array shares data with input array."""
+        if self.obj is self.arr:
+            return True
+        if not isinstance(self.obj, np.ndarray):
+            return False
+        obj_attr = wrap.array_attrs(self.obj)
+        return obj_attr[0] == self.arr_attr[0]
+
+
+class TestIntent:
+    def test_in_out(self):
+        assert str(intent.in_.out) == "intent(in,out)"
+        assert intent.in_.c.is_intent("c")
+        assert not intent.in_.c.is_intent_exact("c")
+        assert intent.in_.c.is_intent_exact("c", "in")
+        assert intent.in_.c.is_intent_exact("in", "c")
+        assert not intent.in_.is_intent("c")
+
+
+class TestSharedMemory:
+
+    @pytest.fixture(autouse=True, scope="class", params=_type_names)
+    def setup_type(self, request):
+        request.cls.type = Type(request.param)
+        request.cls.array = lambda self, dims, intent, obj: Array(
+            Type(request.param), dims, intent, obj)
+
+    @property
+    def num2seq(self):
+        if self.type.NAME.startswith('STRING'):
+            elsize = self.type.elsize
+            return ['1' * elsize, '2' * elsize]
+        return [1, 2]
+
+    @property
+    def num23seq(self):
+        if self.type.NAME.startswith('STRING'):
+            elsize = self.type.elsize
+            return [['1' * elsize, '2' * elsize, '3' * elsize],
+                    ['4' * elsize, '5' * elsize, '6' * elsize]]
+        return [[1, 2, 3], [4, 5, 6]]
+
+    def test_in_from_2seq(self):
+        a = self.array([2], intent.in_, self.num2seq)
+        assert not a.has_shared_memory()
+
+    def test_in_from_2casttype(self):
+        for t in self.type.cast_types():
+            obj = np.array(self.num2seq, dtype=t.dtype)
+            a = self.array([len(self.num2seq)], intent.in_, obj)
+            if t.elsize == self.type.elsize:
+                assert a.has_shared_memory(), repr((self.type.dtype, t.dtype))
+            else:
+                assert not a.has_shared_memory()
+
+    @pytest.mark.parametrize("write", ["w", "ro"])
+    @pytest.mark.parametrize("order", ["C", "F"])
+    @pytest.mark.parametrize("inp", ["2seq", "23seq"])
+    def test_in_nocopy(self, write, order, inp):
+        """Test if intent(in) array can be passed without copies"""
+        seq = getattr(self, "num" + inp)
+        obj = np.array(seq, dtype=self.type.dtype, order=order)
+        obj.setflags(write=(write == 'w'))
+        a = self.array(obj.shape,
+                       ((order == 'C' and intent.in_.c) or intent.in_), obj)
+        assert a.has_shared_memory()
+
+    def test_inout_2seq(self):
+        obj = np.array(self.num2seq, dtype=self.type.dtype)
+        a = self.array([len(self.num2seq)], intent.inout, obj)
+        assert a.has_shared_memory()
+
+        try:
+            a = self.array([2], intent.in_.inout, self.num2seq)
+        except TypeError as msg:
+            if not str(msg).startswith(
+                    "failed to initialize intent(inout|inplace|cache) array"):
+                raise
+        else:
+            raise SystemError("intent(inout) should have failed on sequence")
+
+    def test_f_inout_23seq(self):
+        obj = np.array(self.num23seq, dtype=self.type.dtype, order="F")
+        shape = (len(self.num23seq), len(self.num23seq[0]))
+        a = self.array(shape, intent.in_.inout, obj)
+        assert a.has_shared_memory()
+
+        obj = np.array(self.num23seq, dtype=self.type.dtype, order="C")
+        shape = (len(self.num23seq), len(self.num23seq[0]))
+        try:
+            a = self.array(shape, intent.in_.inout, obj)
+        except ValueError as msg:
+            if not str(msg).startswith(
+                    "failed to initialize intent(inout) array"):
+                raise
+        else:
+            raise SystemError(
+                "intent(inout) should have failed on improper array")
+
+    def test_c_inout_23seq(self):
+        obj = np.array(self.num23seq, dtype=self.type.dtype)
+        shape = (len(self.num23seq), len(self.num23seq[0]))
+        a = self.array(shape, intent.in_.c.inout, obj)
+        assert a.has_shared_memory()
+
+    def test_in_copy_from_2casttype(self):
+        for t in self.type.cast_types():
+            obj = np.array(self.num2seq, dtype=t.dtype)
+            a = self.array([len(self.num2seq)], intent.in_.copy, obj)
+            assert not a.has_shared_memory()
+
+    def test_c_in_from_23seq(self):
+        a = self.array(
+            [len(self.num23seq), len(self.num23seq[0])], intent.in_,
+            self.num23seq)
+        assert not a.has_shared_memory()
+
+    def test_in_from_23casttype(self):
+        for t in self.type.cast_types():
+            obj = np.array(self.num23seq, dtype=t.dtype)
+            a = self.array(
+                [len(self.num23seq), len(self.num23seq[0])], intent.in_, obj)
+            assert not a.has_shared_memory()
+
+    def test_f_in_from_23casttype(self):
+        for t in self.type.cast_types():
+            obj = np.array(self.num23seq, dtype=t.dtype, order="F")
+            a = self.array(
+                [len(self.num23seq), len(self.num23seq[0])], intent.in_, obj)
+            if t.elsize == self.type.elsize:
+                assert a.has_shared_memory()
+            else:
+                assert not a.has_shared_memory()
+
+    def test_c_in_from_23casttype(self):
+        for t in self.type.cast_types():
+            obj = np.array(self.num23seq, dtype=t.dtype)
+            a = self.array(
+                [len(self.num23seq), len(self.num23seq[0])], intent.in_.c, obj)
+            if t.elsize == self.type.elsize:
+                assert a.has_shared_memory()
+            else:
+                assert not a.has_shared_memory()
+
+    def test_f_copy_in_from_23casttype(self):
+        for t in self.type.cast_types():
+            obj = np.array(self.num23seq, dtype=t.dtype, order="F")
+            a = self.array(
+                [len(self.num23seq), len(self.num23seq[0])], intent.in_.copy,
+                obj)
+            assert not a.has_shared_memory()
+
+    def test_c_copy_in_from_23casttype(self):
+        for t in self.type.cast_types():
+            obj = np.array(self.num23seq, dtype=t.dtype)
+            a = self.array(
+                [len(self.num23seq), len(self.num23seq[0])], intent.in_.c.copy,
+                obj)
+            assert not a.has_shared_memory()
+
+    def test_in_cache_from_2casttype(self):
+        for t in self.type.all_types():
+            if t.elsize != self.type.elsize:
+                continue
+            obj = np.array(self.num2seq, dtype=t.dtype)
+            shape = (len(self.num2seq), )
+            a = self.array(shape, intent.in_.c.cache, obj)
+            assert a.has_shared_memory()
+
+            a = self.array(shape, intent.in_.cache, obj)
+            assert a.has_shared_memory()
+
+            obj = np.array(self.num2seq, dtype=t.dtype, order="F")
+            a = self.array(shape, intent.in_.c.cache, obj)
+            assert a.has_shared_memory()
+
+            a = self.array(shape, intent.in_.cache, obj)
+            assert a.has_shared_memory(), repr(t.dtype)
+
+            try:
+                a = self.array(shape, intent.in_.cache, obj[::-1])
+            except ValueError as msg:
+                if not str(msg).startswith(
+                        "failed to initialize intent(cache) array"):
+                    raise
+            else:
+                raise SystemError(
+                    "intent(cache) should have failed on multisegmented array")
+
+    def test_in_cache_from_2casttype_failure(self):
+        for t in self.type.all_types():
+            if t.NAME == 'STRING':
+                # string elsize is 0, so skipping the test
+                continue
+            if t.elsize >= self.type.elsize:
+                continue
+            is_int = np.issubdtype(t.dtype, np.integer)
+            if is_int and int(self.num2seq[0]) > np.iinfo(t.dtype).max:
+                # skip test if num2seq would trigger an overflow error
+                continue
+            obj = np.array(self.num2seq, dtype=t.dtype)
+            shape = (len(self.num2seq), )
+            try:
+                self.array(shape, intent.in_.cache, obj)  # Should succeed
+            except ValueError as msg:
+                if not str(msg).startswith(
+                        "failed to initialize intent(cache) array"):
+                    raise
+            else:
+                raise SystemError(
+                    "intent(cache) should have failed on smaller array")
+
+    def test_cache_hidden(self):
+        shape = (2, )
+        a = self.array(shape, intent.cache.hide, None)
+        assert a.arr.shape == shape
+
+        shape = (2, 3)
+        a = self.array(shape, intent.cache.hide, None)
+        assert a.arr.shape == shape
+
+        shape = (-1, 3)
+        try:
+            a = self.array(shape, intent.cache.hide, None)
+        except ValueError as msg:
+            if not str(msg).startswith(
+                    "failed to create intent(cache|hide)|optional array"):
+                raise
+        else:
+            raise SystemError(
+                "intent(cache) should have failed on undefined dimensions")
+
+    def test_hidden(self):
+        shape = (2, )
+        a = self.array(shape, intent.hide, None)
+        assert a.arr.shape == shape
+        assert a.arr_equal(a.arr, np.zeros(shape, dtype=self.type.dtype))
+
+        shape = (2, 3)
+        a = self.array(shape, intent.hide, None)
+        assert a.arr.shape == shape
+        assert a.arr_equal(a.arr, np.zeros(shape, dtype=self.type.dtype))
+        assert a.arr.flags["FORTRAN"] and not a.arr.flags["CONTIGUOUS"]
+
+        shape = (2, 3)
+        a = self.array(shape, intent.c.hide, None)
+        assert a.arr.shape == shape
+        assert a.arr_equal(a.arr, np.zeros(shape, dtype=self.type.dtype))
+        assert not a.arr.flags["FORTRAN"] and a.arr.flags["CONTIGUOUS"]
+
+        shape = (-1, 3)
+        try:
+            a = self.array(shape, intent.hide, None)
+        except ValueError as msg:
+            if not str(msg).startswith(
+                    "failed to create intent(cache|hide)|optional array"):
+                raise
+        else:
+            raise SystemError(
+                "intent(hide) should have failed on undefined dimensions")
+
+    def test_optional_none(self):
+        shape = (2, )
+        a = self.array(shape, intent.optional, None)
+        assert a.arr.shape == shape
+        assert a.arr_equal(a.arr, np.zeros(shape, dtype=self.type.dtype))
+
+        shape = (2, 3)
+        a = self.array(shape, intent.optional, None)
+        assert a.arr.shape == shape
+        assert a.arr_equal(a.arr, np.zeros(shape, dtype=self.type.dtype))
+        assert a.arr.flags["FORTRAN"] and not a.arr.flags["CONTIGUOUS"]
+
+        shape = (2, 3)
+        a = self.array(shape, intent.c.optional, None)
+        assert a.arr.shape == shape
+        assert a.arr_equal(a.arr, np.zeros(shape, dtype=self.type.dtype))
+        assert not a.arr.flags["FORTRAN"] and a.arr.flags["CONTIGUOUS"]
+
+    def test_optional_from_2seq(self):
+        obj = self.num2seq
+        shape = (len(obj), )
+        a = self.array(shape, intent.optional, obj)
+        assert a.arr.shape == shape
+        assert not a.has_shared_memory()
+
+    def test_optional_from_23seq(self):
+        obj = self.num23seq
+        shape = (len(obj), len(obj[0]))
+        a = self.array(shape, intent.optional, obj)
+        assert a.arr.shape == shape
+        assert not a.has_shared_memory()
+
+        a = self.array(shape, intent.optional.c, obj)
+        assert a.arr.shape == shape
+        assert not a.has_shared_memory()
+
+    def test_inplace(self):
+        obj = np.array(self.num23seq, dtype=self.type.dtype)
+        assert not obj.flags["FORTRAN"] and obj.flags["CONTIGUOUS"]
+        shape = obj.shape
+        a = self.array(shape, intent.inplace, obj)
+        assert obj[1][2] == a.arr[1][2], repr((obj, a.arr))
+        a.arr[1][2] = 54
+        assert obj[1][2] == a.arr[1][2] == np.array(54, dtype=self.type.dtype)
+        assert a.arr is obj
+        assert obj.flags["FORTRAN"]  # obj attributes are changed inplace!
+        assert not obj.flags["CONTIGUOUS"]
+
+    def test_inplace_from_casttype(self):
+        for t in self.type.cast_types():
+            if t is self.type:
+                continue
+            obj = np.array(self.num23seq, dtype=t.dtype)
+            assert obj.dtype.type == t.type
+            assert obj.dtype.type is not self.type.type
+            assert not obj.flags["FORTRAN"] and obj.flags["CONTIGUOUS"]
+            shape = obj.shape
+            a = self.array(shape, intent.inplace, obj)
+            assert obj[1][2] == a.arr[1][2], repr((obj, a.arr))
+            a.arr[1][2] = 54
+            assert obj[1][2] == a.arr[1][2] == np.array(54,
+                                                        dtype=self.type.dtype)
+            assert a.arr is obj
+            assert obj.flags["FORTRAN"]  # obj attributes changed inplace!
+            assert not obj.flags["CONTIGUOUS"]
+            assert obj.dtype.type is self.type.type  # obj changed inplace!
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/test_assumed_shape.py b/venv/lib/python3.12/site-packages/numpy/f2py/tests/test_assumed_shape.py
new file mode 100644
index 00000000..d4664cf8
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/tests/test_assumed_shape.py
@@ -0,0 +1,49 @@
+import os
+import pytest
+import tempfile
+
+from . import util
+
+
+class TestAssumedShapeSumExample(util.F2PyTest):
+    sources = [
+        util.getpath("tests", "src", "assumed_shape", "foo_free.f90"),
+        util.getpath("tests", "src", "assumed_shape", "foo_use.f90"),
+        util.getpath("tests", "src", "assumed_shape", "precision.f90"),
+        util.getpath("tests", "src", "assumed_shape", "foo_mod.f90"),
+        util.getpath("tests", "src", "assumed_shape", ".f2py_f2cmap"),
+    ]
+
+    @pytest.mark.slow
+    def test_all(self):
+        r = self.module.fsum([1, 2])
+        assert r == 3
+        r = self.module.sum([1, 2])
+        assert r == 3
+        r = self.module.sum_with_use([1, 2])
+        assert r == 3
+
+        r = self.module.mod.sum([1, 2])
+        assert r == 3
+        r = self.module.mod.fsum([1, 2])
+        assert r == 3
+
+
+class TestF2cmapOption(TestAssumedShapeSumExample):
+    def setup_method(self):
+        # Use a custom file name for .f2py_f2cmap
+        self.sources = list(self.sources)
+        f2cmap_src = self.sources.pop(-1)
+
+        self.f2cmap_file = tempfile.NamedTemporaryFile(delete=False)
+        with open(f2cmap_src, "rb") as f:
+            self.f2cmap_file.write(f.read())
+        self.f2cmap_file.close()
+
+        self.sources.append(self.f2cmap_file.name)
+        self.options = ["--f2cmap", self.f2cmap_file.name]
+
+        super().setup_method()
+
+    def teardown_method(self):
+        os.unlink(self.f2cmap_file.name)
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/test_block_docstring.py b/venv/lib/python3.12/site-packages/numpy/f2py/tests/test_block_docstring.py
new file mode 100644
index 00000000..16b5559e
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/tests/test_block_docstring.py
@@ -0,0 +1,18 @@
+import sys
+import pytest
+from . import util
+
+from numpy.testing import IS_PYPY
+
+
+@pytest.mark.slow
+class TestBlockDocString(util.F2PyTest):
+    sources = [util.getpath("tests", "src", "block_docstring", "foo.f")]
+
+    @pytest.mark.skipif(sys.platform == "win32",
+                        reason="Fails with MinGW64 Gfortran (Issue #9673)")
+    @pytest.mark.xfail(IS_PYPY,
+                       reason="PyPy cannot modify tp_doc after PyType_Ready")
+    def test_block_docstring(self):
+        expected = "bar : 'i'-array(2,3)\n"
+        assert self.module.block.__doc__ == expected
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/test_callback.py b/venv/lib/python3.12/site-packages/numpy/f2py/tests/test_callback.py
new file mode 100644
index 00000000..8bd6175a
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/tests/test_callback.py
@@ -0,0 +1,246 @@
+import math
+import textwrap
+import sys
+import pytest
+import threading
+import traceback
+import time
+
+import numpy as np
+from numpy.testing import IS_PYPY
+from . import util
+
+
+class TestF77Callback(util.F2PyTest):
+    sources = [util.getpath("tests", "src", "callback", "foo.f")]
+
+    @pytest.mark.parametrize("name", "t,t2".split(","))
+    @pytest.mark.slow
+    def test_all(self, name):
+        self.check_function(name)
+
+    @pytest.mark.xfail(IS_PYPY,
+                       reason="PyPy cannot modify tp_doc after PyType_Ready")
+    def test_docstring(self):
+        expected = textwrap.dedent("""\
+        a = t(fun,[fun_extra_args])
+
+        Wrapper for ``t``.
+
+        Parameters
+        ----------
+        fun : call-back function
+
+        Other Parameters
+        ----------------
+        fun_extra_args : input tuple, optional
+            Default: ()
+
+        Returns
+        -------
+        a : int
+
+        Notes
+        -----
+        Call-back functions::
+
+            def fun(): return a
+            Return objects:
+                a : int
+        """)
+        assert self.module.t.__doc__ == expected
+
+    def check_function(self, name):
+        t = getattr(self.module, name)
+        r = t(lambda: 4)
+        assert r == 4
+        r = t(lambda a: 5, fun_extra_args=(6, ))
+        assert r == 5
+        r = t(lambda a: a, fun_extra_args=(6, ))
+        assert r == 6
+        r = t(lambda a: 5 + a, fun_extra_args=(7, ))
+        assert r == 12
+        r = t(lambda a: math.degrees(a), fun_extra_args=(math.pi, ))
+        assert r == 180
+        r = t(math.degrees, fun_extra_args=(math.pi, ))
+        assert r == 180
+
+        r = t(self.module.func, fun_extra_args=(6, ))
+        assert r == 17
+        r = t(self.module.func0)
+        assert r == 11
+        r = t(self.module.func0._cpointer)
+        assert r == 11
+
+        class A:
+            def __call__(self):
+                return 7
+
+            def mth(self):
+                return 9
+
+        a = A()
+        r = t(a)
+        assert r == 7
+        r = t(a.mth)
+        assert r == 9
+
+    @pytest.mark.skipif(sys.platform == 'win32',
+                        reason='Fails with MinGW64 Gfortran (Issue #9673)')
+    def test_string_callback(self):
+        def callback(code):
+            if code == "r":
+                return 0
+            else:
+                return 1
+
+        f = getattr(self.module, "string_callback")
+        r = f(callback)
+        assert r == 0
+
+    @pytest.mark.skipif(sys.platform == 'win32',
+                        reason='Fails with MinGW64 Gfortran (Issue #9673)')
+    def test_string_callback_array(self):
+        # See gh-10027
+        cu1 = np.zeros((1, ), "S8")
+        cu2 = np.zeros((1, 8), "c")
+        cu3 = np.array([""], "S8")
+
+        def callback(cu, lencu):
+            if cu.shape != (lencu,):
+                return 1
+            if cu.dtype != "S8":
+                return 2
+            if not np.all(cu == b""):
+                return 3
+            return 0
+
+        f = getattr(self.module, "string_callback_array")
+        for cu in [cu1, cu2, cu3]:
+            res = f(callback, cu, cu.size)
+            assert res == 0
+
+    def test_threadsafety(self):
+        # Segfaults if the callback handling is not threadsafe
+
+        errors = []
+
+        def cb():
+            # Sleep here to make it more likely for another thread
+            # to call their callback at the same time.
+            time.sleep(1e-3)
+
+            # Check reentrancy
+            r = self.module.t(lambda: 123)
+            assert r == 123
+
+            return 42
+
+        def runner(name):
+            try:
+                for j in range(50):
+                    r = self.module.t(cb)
+                    assert r == 42
+                    self.check_function(name)
+            except Exception:
+                errors.append(traceback.format_exc())
+
+        threads = [
+            threading.Thread(target=runner, args=(arg, ))
+            for arg in ("t", "t2") for n in range(20)
+        ]
+
+        for t in threads:
+            t.start()
+
+        for t in threads:
+            t.join()
+
+        errors = "\n\n".join(errors)
+        if errors:
+            raise AssertionError(errors)
+
+    def test_hidden_callback(self):
+        try:
+            self.module.hidden_callback(2)
+        except Exception as msg:
+            assert str(msg).startswith("Callback global_f not defined")
+
+        try:
+            self.module.hidden_callback2(2)
+        except Exception as msg:
+            assert str(msg).startswith("cb: Callback global_f not defined")
+
+        self.module.global_f = lambda x: x + 1
+        r = self.module.hidden_callback(2)
+        assert r == 3
+
+        self.module.global_f = lambda x: x + 2
+        r = self.module.hidden_callback(2)
+        assert r == 4
+
+        del self.module.global_f
+        try:
+            self.module.hidden_callback(2)
+        except Exception as msg:
+            assert str(msg).startswith("Callback global_f not defined")
+
+        self.module.global_f = lambda x=0: x + 3
+        r = self.module.hidden_callback(2)
+        assert r == 5
+
+        # reproducer of gh18341
+        r = self.module.hidden_callback2(2)
+        assert r == 3
+
+
+class TestF77CallbackPythonTLS(TestF77Callback):
+    """
+    Callback tests using Python thread-local storage instead of
+    compiler-provided
+    """
+
+    options = ["-DF2PY_USE_PYTHON_TLS"]
+
+
+class TestF90Callback(util.F2PyTest):
+    sources = [util.getpath("tests", "src", "callback", "gh17797.f90")]
+
+    @pytest.mark.slow
+    def test_gh17797(self):
+        def incr(x):
+            return x + 123
+
+        y = np.array([1, 2, 3], dtype=np.int64)
+        r = self.module.gh17797(incr, y)
+        assert r == 123 + 1 + 2 + 3
+
+
+class TestGH18335(util.F2PyTest):
+    """The reproduction of the reported issue requires specific input that
+    extensions may break the issue conditions, so the reproducer is
+    implemented as a separate test class. Do not extend this test with
+    other tests!
+    """
+    sources = [util.getpath("tests", "src", "callback", "gh18335.f90")]
+
+    @pytest.mark.slow
+    def test_gh18335(self):
+        def foo(x):
+            x[0] += 1
+
+        r = self.module.gh18335(foo)
+        assert r == 123 + 1
+
+
+class TestGH25211(util.F2PyTest):
+    sources = [util.getpath("tests", "src", "callback", "gh25211.f"),
+               util.getpath("tests", "src", "callback", "gh25211.pyf")]
+    module_name = "callback2"
+
+    def test_gh25211(self):
+        def bar(x):
+            return x*x
+
+        res = self.module.foo(bar)
+        assert res == 110
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/test_character.py b/venv/lib/python3.12/site-packages/numpy/f2py/tests/test_character.py
new file mode 100644
index 00000000..50e55e1a
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/tests/test_character.py
@@ -0,0 +1,639 @@
+import pytest
+import textwrap
+from numpy.testing import assert_array_equal, assert_equal, assert_raises
+import numpy as np
+from numpy.f2py.tests import util
+
+
+@pytest.mark.slow
+class TestCharacterString(util.F2PyTest):
+    # options = ['--debug-capi', '--build-dir', '/tmp/test-build-f2py']
+    suffix = '.f90'
+    fprefix = 'test_character_string'
+    length_list = ['1', '3', 'star']
+
+    code = ''
+    for length in length_list:
+        fsuffix = length
+        clength = dict(star='(*)').get(length, length)
+
+        code += textwrap.dedent(f"""
+
+        subroutine {fprefix}_input_{fsuffix}(c, o, n)
+          character*{clength}, intent(in) :: c
+          integer n
+          !f2py integer, depend(c), intent(hide) :: n = slen(c)
+          integer*1, dimension(n) :: o
+          !f2py intent(out) o
+          o = transfer(c, o)
+        end subroutine {fprefix}_input_{fsuffix}
+
+        subroutine {fprefix}_output_{fsuffix}(c, o, n)
+          character*{clength}, intent(out) :: c
+          integer n
+          integer*1, dimension(n), intent(in) :: o
+          !f2py integer, depend(o), intent(hide) :: n = len(o)
+          c = transfer(o, c)
+        end subroutine {fprefix}_output_{fsuffix}
+
+        subroutine {fprefix}_array_input_{fsuffix}(c, o, m, n)
+          integer m, i, n
+          character*{clength}, intent(in), dimension(m) :: c
+          !f2py integer, depend(c), intent(hide) :: m = len(c)
+          !f2py integer, depend(c), intent(hide) :: n = f2py_itemsize(c)
+          integer*1, dimension(m, n), intent(out) :: o
+          do i=1,m
+            o(i, :) = transfer(c(i), o(i, :))
+          end do
+        end subroutine {fprefix}_array_input_{fsuffix}
+
+        subroutine {fprefix}_array_output_{fsuffix}(c, o, m, n)
+          character*{clength}, intent(out), dimension(m) :: c
+          integer n
+          integer*1, dimension(m, n), intent(in) :: o
+          !f2py character(f2py_len=n) :: c
+          !f2py integer, depend(o), intent(hide) :: m = len(o)
+          !f2py integer, depend(o), intent(hide) :: n = shape(o, 1)
+          do i=1,m
+            c(i) = transfer(o(i, :), c(i))
+          end do
+        end subroutine {fprefix}_array_output_{fsuffix}
+
+        subroutine {fprefix}_2d_array_input_{fsuffix}(c, o, m1, m2, n)
+          integer m1, m2, i, j, n
+          character*{clength}, intent(in), dimension(m1, m2) :: c
+          !f2py integer, depend(c), intent(hide) :: m1 = len(c)
+          !f2py integer, depend(c), intent(hide) :: m2 = shape(c, 1)
+          !f2py integer, depend(c), intent(hide) :: n = f2py_itemsize(c)
+          integer*1, dimension(m1, m2, n), intent(out) :: o
+          do i=1,m1
+            do j=1,m2
+              o(i, j, :) = transfer(c(i, j), o(i, j, :))
+            end do
+          end do
+        end subroutine {fprefix}_2d_array_input_{fsuffix}
+        """)
+
+    @pytest.mark.parametrize("length", length_list)
+    def test_input(self, length):
+        fsuffix = {'(*)': 'star'}.get(length, length)
+        f = getattr(self.module, self.fprefix + '_input_' + fsuffix)
+
+        a = {'1': 'a', '3': 'abc', 'star': 'abcde' * 3}[length]
+
+        assert_array_equal(f(a), np.array(list(map(ord, a)), dtype='u1'))
+
+    @pytest.mark.parametrize("length", length_list[:-1])
+    def test_output(self, length):
+        fsuffix = length
+        f = getattr(self.module, self.fprefix + '_output_' + fsuffix)
+
+        a = {'1': 'a', '3': 'abc'}[length]
+
+        assert_array_equal(f(np.array(list(map(ord, a)), dtype='u1')),
+                           a.encode())
+
+    @pytest.mark.parametrize("length", length_list)
+    def test_array_input(self, length):
+        fsuffix = length
+        f = getattr(self.module, self.fprefix + '_array_input_' + fsuffix)
+
+        a = np.array([{'1': 'a', '3': 'abc', 'star': 'abcde' * 3}[length],
+                      {'1': 'A', '3': 'ABC', 'star': 'ABCDE' * 3}[length],
+                      ], dtype='S')
+
+        expected = np.array([[c for c in s] for s in a], dtype='u1')
+        assert_array_equal(f(a), expected)
+
+    @pytest.mark.parametrize("length", length_list)
+    def test_array_output(self, length):
+        fsuffix = length
+        f = getattr(self.module, self.fprefix + '_array_output_' + fsuffix)
+
+        expected = np.array(
+            [{'1': 'a', '3': 'abc', 'star': 'abcde' * 3}[length],
+             {'1': 'A', '3': 'ABC', 'star': 'ABCDE' * 3}[length]], dtype='S')
+
+        a = np.array([[c for c in s] for s in expected], dtype='u1')
+        assert_array_equal(f(a), expected)
+
+    @pytest.mark.parametrize("length", length_list)
+    def test_2d_array_input(self, length):
+        fsuffix = length
+        f = getattr(self.module, self.fprefix + '_2d_array_input_' + fsuffix)
+
+        a = np.array([[{'1': 'a', '3': 'abc', 'star': 'abcde' * 3}[length],
+                       {'1': 'A', '3': 'ABC', 'star': 'ABCDE' * 3}[length]],
+                      [{'1': 'f', '3': 'fgh', 'star': 'fghij' * 3}[length],
+                       {'1': 'F', '3': 'FGH', 'star': 'FGHIJ' * 3}[length]]],
+                     dtype='S')
+        expected = np.array([[[c for c in item] for item in row] for row in a],
+                            dtype='u1', order='F')
+        assert_array_equal(f(a), expected)
+
+
+class TestCharacter(util.F2PyTest):
+    # options = ['--debug-capi', '--build-dir', '/tmp/test-build-f2py']
+    suffix = '.f90'
+    fprefix = 'test_character'
+
+    code = textwrap.dedent(f"""
+       subroutine {fprefix}_input(c, o)
+          character, intent(in) :: c
+          integer*1 o
+          !f2py intent(out) o
+          o = transfer(c, o)
+       end subroutine {fprefix}_input
+
+       subroutine {fprefix}_output(c, o)
+          character :: c
+          integer*1, intent(in) :: o
+          !f2py intent(out) c
+          c = transfer(o, c)
+       end subroutine {fprefix}_output
+
+       subroutine {fprefix}_input_output(c, o)
+          character, intent(in) :: c
+          character o
+          !f2py intent(out) o
+          o = c
+       end subroutine {fprefix}_input_output
+
+       subroutine {fprefix}_inout(c, n)
+          character :: c, n
+          !f2py intent(in) n
+          !f2py intent(inout) c
+          c = n
+       end subroutine {fprefix}_inout
+
+       function {fprefix}_return(o) result (c)
+          character :: c
+          character, intent(in) :: o
+          c = transfer(o, c)
+       end function {fprefix}_return
+
+       subroutine {fprefix}_array_input(c, o)
+          character, intent(in) :: c(3)
+          integer*1 o(3)
+          !f2py intent(out) o
+          integer i
+          do i=1,3
+            o(i) = transfer(c(i), o(i))
+          end do
+       end subroutine {fprefix}_array_input
+
+       subroutine {fprefix}_2d_array_input(c, o)
+          character, intent(in) :: c(2, 3)
+          integer*1 o(2, 3)
+          !f2py intent(out) o
+          integer i, j
+          do i=1,2
+            do j=1,3
+              o(i, j) = transfer(c(i, j), o(i, j))
+            end do
+          end do
+       end subroutine {fprefix}_2d_array_input
+
+       subroutine {fprefix}_array_output(c, o)
+          character :: c(3)
+          integer*1, intent(in) :: o(3)
+          !f2py intent(out) c
+          do i=1,3
+            c(i) = transfer(o(i), c(i))
+          end do
+       end subroutine {fprefix}_array_output
+
+       subroutine {fprefix}_array_inout(c, n)
+          character :: c(3), n(3)
+          !f2py intent(in) n(3)
+          !f2py intent(inout) c(3)
+          do i=1,3
+            c(i) = n(i)
+          end do
+       end subroutine {fprefix}_array_inout
+
+       subroutine {fprefix}_2d_array_inout(c, n)
+          character :: c(2, 3), n(2, 3)
+          !f2py intent(in) n(2, 3)
+          !f2py intent(inout) c(2. 3)
+          integer i, j
+          do i=1,2
+            do j=1,3
+              c(i, j) = n(i, j)
+            end do
+          end do
+       end subroutine {fprefix}_2d_array_inout
+
+       function {fprefix}_array_return(o) result (c)
+          character, dimension(3) :: c
+          character, intent(in) :: o(3)
+          do i=1,3
+            c(i) = o(i)
+          end do
+       end function {fprefix}_array_return
+
+       function {fprefix}_optional(o) result (c)
+          character, intent(in) :: o
+          !f2py character o = "a"
+          character :: c
+          c = o
+       end function {fprefix}_optional
+    """)
+
+    @pytest.mark.parametrize("dtype", ['c', 'S1'])
+    def test_input(self, dtype):
+        f = getattr(self.module, self.fprefix + '_input')
+
+        assert_equal(f(np.array('a', dtype=dtype)), ord('a'))
+        assert_equal(f(np.array(b'a', dtype=dtype)), ord('a'))
+        assert_equal(f(np.array(['a'], dtype=dtype)), ord('a'))
+        assert_equal(f(np.array('abc', dtype=dtype)), ord('a'))
+        assert_equal(f(np.array([['a']], dtype=dtype)), ord('a'))
+
+    def test_input_varia(self):
+        f = getattr(self.module, self.fprefix + '_input')
+
+        assert_equal(f('a'), ord('a'))
+        assert_equal(f(b'a'), ord(b'a'))
+        assert_equal(f(''), 0)
+        assert_equal(f(b''), 0)
+        assert_equal(f(b'\0'), 0)
+        assert_equal(f('ab'), ord('a'))
+        assert_equal(f(b'ab'), ord('a'))
+        assert_equal(f(['a']), ord('a'))
+
+        assert_equal(f(np.array(b'a')), ord('a'))
+        assert_equal(f(np.array([b'a'])), ord('a'))
+        a = np.array('a')
+        assert_equal(f(a), ord('a'))
+        a = np.array(['a'])
+        assert_equal(f(a), ord('a'))
+
+        try:
+            f([])
+        except IndexError as msg:
+            if not str(msg).endswith(' got 0-list'):
+                raise
+        else:
+            raise SystemError(f'{f.__name__} should have failed on empty list')
+
+        try:
+            f(97)
+        except TypeError as msg:
+            if not str(msg).endswith(' got int instance'):
+                raise
+        else:
+            raise SystemError(f'{f.__name__} should have failed on int value')
+
+    @pytest.mark.parametrize("dtype", ['c', 'S1', 'U1'])
+    def test_array_input(self, dtype):
+        f = getattr(self.module, self.fprefix + '_array_input')
+
+        assert_array_equal(f(np.array(['a', 'b', 'c'], dtype=dtype)),
+                           np.array(list(map(ord, 'abc')), dtype='i1'))
+        assert_array_equal(f(np.array([b'a', b'b', b'c'], dtype=dtype)),
+                           np.array(list(map(ord, 'abc')), dtype='i1'))
+
+    def test_array_input_varia(self):
+        f = getattr(self.module, self.fprefix + '_array_input')
+        assert_array_equal(f(['a', 'b', 'c']),
+                           np.array(list(map(ord, 'abc')), dtype='i1'))
+        assert_array_equal(f([b'a', b'b', b'c']),
+                           np.array(list(map(ord, 'abc')), dtype='i1'))
+
+        try:
+            f(['a', 'b', 'c', 'd'])
+        except ValueError as msg:
+            if not str(msg).endswith(
+                    'th dimension must be fixed to 3 but got 4'):
+                raise
+        else:
+            raise SystemError(
+                f'{f.__name__} should have failed on wrong input')
+
+    @pytest.mark.parametrize("dtype", ['c', 'S1', 'U1'])
+    def test_2d_array_input(self, dtype):
+        f = getattr(self.module, self.fprefix + '_2d_array_input')
+
+        a = np.array([['a', 'b', 'c'],
+                      ['d', 'e', 'f']], dtype=dtype, order='F')
+        expected = a.view(np.uint32 if dtype == 'U1' else np.uint8)
+        assert_array_equal(f(a), expected)
+
+    def test_output(self):
+        f = getattr(self.module, self.fprefix + '_output')
+
+        assert_equal(f(ord(b'a')), b'a')
+        assert_equal(f(0), b'\0')
+
+    def test_array_output(self):
+        f = getattr(self.module, self.fprefix + '_array_output')
+
+        assert_array_equal(f(list(map(ord, 'abc'))),
+                           np.array(list('abc'), dtype='S1'))
+
+    def test_input_output(self):
+        f = getattr(self.module, self.fprefix + '_input_output')
+
+        assert_equal(f(b'a'), b'a')
+        assert_equal(f('a'), b'a')
+        assert_equal(f(''), b'\0')
+
+    @pytest.mark.parametrize("dtype", ['c', 'S1'])
+    def test_inout(self, dtype):
+        f = getattr(self.module, self.fprefix + '_inout')
+
+        a = np.array(list('abc'), dtype=dtype)
+        f(a, 'A')
+        assert_array_equal(a, np.array(list('Abc'), dtype=a.dtype))
+        f(a[1:], 'B')
+        assert_array_equal(a, np.array(list('ABc'), dtype=a.dtype))
+
+        a = np.array(['abc'], dtype=dtype)
+        f(a, 'A')
+        assert_array_equal(a, np.array(['Abc'], dtype=a.dtype))
+
+    def test_inout_varia(self):
+        f = getattr(self.module, self.fprefix + '_inout')
+        a = np.array('abc', dtype='S3')
+        f(a, 'A')
+        assert_array_equal(a, np.array('Abc', dtype=a.dtype))
+
+        a = np.array(['abc'], dtype='S3')
+        f(a, 'A')
+        assert_array_equal(a, np.array(['Abc'], dtype=a.dtype))
+
+        try:
+            f('abc', 'A')
+        except ValueError as msg:
+            if not str(msg).endswith(' got 3-str'):
+                raise
+        else:
+            raise SystemError(f'{f.__name__} should have failed on str value')
+
+    @pytest.mark.parametrize("dtype", ['c', 'S1'])
+    def test_array_inout(self, dtype):
+        f = getattr(self.module, self.fprefix + '_array_inout')
+        n = np.array(['A', 'B', 'C'], dtype=dtype, order='F')
+
+        a = np.array(['a', 'b', 'c'], dtype=dtype, order='F')
+        f(a, n)
+        assert_array_equal(a, n)
+
+        a = np.array(['a', 'b', 'c', 'd'], dtype=dtype)
+        f(a[1:], n)
+        assert_array_equal(a, np.array(['a', 'A', 'B', 'C'], dtype=dtype))
+
+        a = np.array([['a', 'b', 'c']], dtype=dtype, order='F')
+        f(a, n)
+        assert_array_equal(a, np.array([['A', 'B', 'C']], dtype=dtype))
+
+        a = np.array(['a', 'b', 'c', 'd'], dtype=dtype, order='F')
+        try:
+            f(a, n)
+        except ValueError as msg:
+            if not str(msg).endswith(
+                    'th dimension must be fixed to 3 but got 4'):
+                raise
+        else:
+            raise SystemError(
+                f'{f.__name__} should have failed on wrong input')
+
+    @pytest.mark.parametrize("dtype", ['c', 'S1'])
+    def test_2d_array_inout(self, dtype):
+        f = getattr(self.module, self.fprefix + '_2d_array_inout')
+        n = np.array([['A', 'B', 'C'],
+                      ['D', 'E', 'F']],
+                     dtype=dtype, order='F')
+        a = np.array([['a', 'b', 'c'],
+                      ['d', 'e', 'f']],
+                     dtype=dtype, order='F')
+        f(a, n)
+        assert_array_equal(a, n)
+
+    def test_return(self):
+        f = getattr(self.module, self.fprefix + '_return')
+
+        assert_equal(f('a'), b'a')
+
+    @pytest.mark.skip('fortran function returning array segfaults')
+    def test_array_return(self):
+        f = getattr(self.module, self.fprefix + '_array_return')
+
+        a = np.array(list('abc'), dtype='S1')
+        assert_array_equal(f(a), a)
+
+    def test_optional(self):
+        f = getattr(self.module, self.fprefix + '_optional')
+
+        assert_equal(f(), b"a")
+        assert_equal(f(b'B'), b"B")
+
+
+class TestMiscCharacter(util.F2PyTest):
+    # options = ['--debug-capi', '--build-dir', '/tmp/test-build-f2py']
+    suffix = '.f90'
+    fprefix = 'test_misc_character'
+
+    code = textwrap.dedent(f"""
+       subroutine {fprefix}_gh18684(x, y, m)
+         character(len=5), dimension(m), intent(in) :: x
+         character*5, dimension(m), intent(out) :: y
+         integer i, m
+         !f2py integer, intent(hide), depend(x) :: m = f2py_len(x)
+         do i=1,m
+           y(i) = x(i)
+         end do
+       end subroutine {fprefix}_gh18684
+
+       subroutine {fprefix}_gh6308(x, i)
+         integer i
+         !f2py check(i>=0 && i<12) i
+         character*5 name, x
+         common name(12)
+         name(i + 1) = x
+       end subroutine {fprefix}_gh6308
+
+       subroutine {fprefix}_gh4519(x)
+         character(len=*), intent(in) :: x(:)
+         !f2py intent(out) x
+         integer :: i
+         ! Uncomment for debug printing:
+         !do i=1, size(x)
+         !   print*, "x(",i,")=", x(i)
+         !end do
+       end subroutine {fprefix}_gh4519
+
+       pure function {fprefix}_gh3425(x) result (y)
+         character(len=*), intent(in) :: x
+         character(len=len(x)) :: y
+         integer :: i
+         do i = 1, len(x)
+           j = iachar(x(i:i))
+           if (j>=iachar("a") .and. j<=iachar("z") ) then
+             y(i:i) = achar(j-32)
+           else
+             y(i:i) = x(i:i)
+           endif
+         end do
+       end function {fprefix}_gh3425
+
+       subroutine {fprefix}_character_bc_new(x, y, z)
+         character, intent(in) :: x
+         character, intent(out) :: y
+         !f2py character, depend(x) :: y = x
+         !f2py character, dimension((x=='a'?1:2)), depend(x), intent(out) :: z
+         character, dimension(*) :: z
+         !f2py character, optional, check(x == 'a' || x == 'b') :: x = 'a'
+         !f2py callstatement (*f2py_func)(&x, &y, z)
+         !f2py callprotoargument character*, character*, character*
+         if (y.eq.x) then
+           y = x
+         else
+           y = 'e'
+         endif
+         z(1) = 'c'
+       end subroutine {fprefix}_character_bc_new
+
+       subroutine {fprefix}_character_bc_old(x, y, z)
+         character, intent(in) :: x
+         character, intent(out) :: y
+         !f2py character, depend(x) :: y = x[0]
+         !f2py character, dimension((*x=='a'?1:2)), depend(x), intent(out) :: z
+         character, dimension(*) :: z
+         !f2py character, optional, check(*x == 'a' || x[0] == 'b') :: x = 'a'
+         !f2py callstatement (*f2py_func)(x, y, z)
+         !f2py callprotoargument char*, char*, char*
+          if (y.eq.x) then
+           y = x
+         else
+           y = 'e'
+         endif
+         z(1) = 'c'
+       end subroutine {fprefix}_character_bc_old
+    """)
+
+    @pytest.mark.slow
+    def test_gh18684(self):
+        # Test character(len=5) and character*5 usages
+        f = getattr(self.module, self.fprefix + '_gh18684')
+        x = np.array(["abcde", "fghij"], dtype='S5')
+        y = f(x)
+
+        assert_array_equal(x, y)
+
+    def test_gh6308(self):
+        # Test character string array in a common block
+        f = getattr(self.module, self.fprefix + '_gh6308')
+
+        assert_equal(self.module._BLNK_.name.dtype, np.dtype('S5'))
+        assert_equal(len(self.module._BLNK_.name), 12)
+        f("abcde", 0)
+        assert_equal(self.module._BLNK_.name[0], b"abcde")
+        f("12345", 5)
+        assert_equal(self.module._BLNK_.name[5], b"12345")
+
+    def test_gh4519(self):
+        # Test array of assumed length strings
+        f = getattr(self.module, self.fprefix + '_gh4519')
+
+        for x, expected in [
+                ('a', dict(shape=(), dtype=np.dtype('S1'))),
+                ('text', dict(shape=(), dtype=np.dtype('S4'))),
+                (np.array(['1', '2', '3'], dtype='S1'),
+                 dict(shape=(3,), dtype=np.dtype('S1'))),
+                (['1', '2', '34'],
+                 dict(shape=(3,), dtype=np.dtype('S2'))),
+                (['', ''], dict(shape=(2,), dtype=np.dtype('S1')))]:
+            r = f(x)
+            for k, v in expected.items():
+                assert_equal(getattr(r, k), v)
+
+    def test_gh3425(self):
+        # Test returning a copy of assumed length string
+        f = getattr(self.module, self.fprefix + '_gh3425')
+        # f is equivalent to bytes.upper
+
+        assert_equal(f('abC'), b'ABC')
+        assert_equal(f(''), b'')
+        assert_equal(f('abC12d'), b'ABC12D')
+
+    @pytest.mark.parametrize("state", ['new', 'old'])
+    def test_character_bc(self, state):
+        f = getattr(self.module, self.fprefix + '_character_bc_' + state)
+
+        c, a = f()
+        assert_equal(c, b'a')
+        assert_equal(len(a), 1)
+
+        c, a = f(b'b')
+        assert_equal(c, b'b')
+        assert_equal(len(a), 2)
+
+        assert_raises(Exception, lambda: f(b'c'))
+
+
+class TestStringScalarArr(util.F2PyTest):
+    sources = [util.getpath("tests", "src", "string", "scalar_string.f90")]
+
+    def test_char(self):
+        for out in (self.module.string_test.string,
+                    self.module.string_test.string77):
+            expected = ()
+            assert out.shape == expected
+            expected = '|S8'
+            assert out.dtype == expected
+
+    def test_char_arr(self):
+        for out in (self.module.string_test.strarr,
+                    self.module.string_test.strarr77):
+            expected = (5,7)
+            assert out.shape == expected
+            expected = '|S12'
+            assert out.dtype == expected
+
+class TestStringAssumedLength(util.F2PyTest):
+    sources = [util.getpath("tests", "src", "string", "gh24008.f")]
+
+    def test_gh24008(self):
+        self.module.greet("joe", "bob")
+
+@pytest.mark.slow
+class TestStringOptionalInOut(util.F2PyTest):
+    sources = [util.getpath("tests", "src", "string", "gh24662.f90")]
+
+    def test_gh24662(self):
+        self.module.string_inout_optional()
+        a = np.array('hi', dtype='S32')
+        self.module.string_inout_optional(a)
+        assert "output string" in a.tobytes().decode()
+        with pytest.raises(Exception):
+            aa = "Hi"
+            self.module.string_inout_optional(aa)
+
+
+@pytest.mark.slow
+class TestNewCharHandling(util.F2PyTest):
+    # from v1.24 onwards, gh-19388
+    sources = [
+        util.getpath("tests", "src", "string", "gh25286.pyf"),
+        util.getpath("tests", "src", "string", "gh25286.f90")
+    ]
+    module_name = "_char_handling_test"
+
+    def test_gh25286(self):
+        info = self.module.charint('T')
+        assert info == 2
+
+@pytest.mark.slow
+class TestBCCharHandling(util.F2PyTest):
+    # SciPy style, "incorrect" bindings with a hook
+    sources = [
+        util.getpath("tests", "src", "string", "gh25286_bc.pyf"),
+        util.getpath("tests", "src", "string", "gh25286.f90")
+    ]
+    module_name = "_char_handling_test"
+
+    def test_gh25286(self):
+        info = self.module.charint('T')
+        assert info == 2
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/test_common.py b/venv/lib/python3.12/site-packages/numpy/f2py/tests/test_common.py
new file mode 100644
index 00000000..09bd6147
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/tests/test_common.py
@@ -0,0 +1,20 @@
+import pytest
+import numpy as np
+from . import util
+
+@pytest.mark.slow
+class TestCommonBlock(util.F2PyTest):
+    sources = [util.getpath("tests", "src", "common", "block.f")]
+
+    def test_common_block(self):
+        self.module.initcb()
+        assert self.module.block.long_bn == np.array(1.0, dtype=np.float64)
+        assert self.module.block.string_bn == np.array("2", dtype="|S1")
+        assert self.module.block.ok == np.array(3, dtype=np.int32)
+
+
+class TestCommonWithUse(util.F2PyTest):
+    sources = [util.getpath("tests", "src", "common", "gh19161.f90")]
+
+    def test_common_gh19161(self):
+        assert self.module.data.x == 0
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/test_crackfortran.py b/venv/lib/python3.12/site-packages/numpy/f2py/tests/test_crackfortran.py
new file mode 100644
index 00000000..4986cfbd
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/tests/test_crackfortran.py
@@ -0,0 +1,407 @@
+import importlib
+import codecs
+import time
+import unicodedata
+import pytest
+import numpy as np
+from numpy.f2py.crackfortran import markinnerspaces, nameargspattern
+from . import util
+from numpy.f2py import crackfortran
+import textwrap
+import contextlib
+import io
+
+
+class TestNoSpace(util.F2PyTest):
+    # issue gh-15035: add handling for endsubroutine, endfunction with no space
+    # between "end" and the block name
+    sources = [util.getpath("tests", "src", "crackfortran", "gh15035.f")]
+
+    def test_module(self):
+        k = np.array([1, 2, 3], dtype=np.float64)
+        w = np.array([1, 2, 3], dtype=np.float64)
+        self.module.subb(k)
+        assert np.allclose(k, w + 1)
+        self.module.subc([w, k])
+        assert np.allclose(k, w + 1)
+        assert self.module.t0("23") == b"2"
+
+
+class TestPublicPrivate:
+    def test_defaultPrivate(self):
+        fpath = util.getpath("tests", "src", "crackfortran", "privatemod.f90")
+        mod = crackfortran.crackfortran([str(fpath)])
+        assert len(mod) == 1
+        mod = mod[0]
+        assert "private" in mod["vars"]["a"]["attrspec"]
+        assert "public" not in mod["vars"]["a"]["attrspec"]
+        assert "private" in mod["vars"]["b"]["attrspec"]
+        assert "public" not in mod["vars"]["b"]["attrspec"]
+        assert "private" not in mod["vars"]["seta"]["attrspec"]
+        assert "public" in mod["vars"]["seta"]["attrspec"]
+
+    def test_defaultPublic(self, tmp_path):
+        fpath = util.getpath("tests", "src", "crackfortran", "publicmod.f90")
+        mod = crackfortran.crackfortran([str(fpath)])
+        assert len(mod) == 1
+        mod = mod[0]
+        assert "private" in mod["vars"]["a"]["attrspec"]
+        assert "public" not in mod["vars"]["a"]["attrspec"]
+        assert "private" not in mod["vars"]["seta"]["attrspec"]
+        assert "public" in mod["vars"]["seta"]["attrspec"]
+
+    def test_access_type(self, tmp_path):
+        fpath = util.getpath("tests", "src", "crackfortran", "accesstype.f90")
+        mod = crackfortran.crackfortran([str(fpath)])
+        assert len(mod) == 1
+        tt = mod[0]['vars']
+        assert set(tt['a']['attrspec']) == {'private', 'bind(c)'}
+        assert set(tt['b_']['attrspec']) == {'public', 'bind(c)'}
+        assert set(tt['c']['attrspec']) == {'public'}
+
+    def test_nowrap_private_proceedures(self, tmp_path):
+        fpath = util.getpath("tests", "src", "crackfortran", "gh23879.f90")
+        mod = crackfortran.crackfortran([str(fpath)])
+        assert len(mod) == 1
+        pyf = crackfortran.crack2fortran(mod)
+        assert 'bar' not in pyf
+
+class TestModuleProcedure:
+    def test_moduleOperators(self, tmp_path):
+        fpath = util.getpath("tests", "src", "crackfortran", "operators.f90")
+        mod = crackfortran.crackfortran([str(fpath)])
+        assert len(mod) == 1
+        mod = mod[0]
+        assert "body" in mod and len(mod["body"]) == 9
+        assert mod["body"][1]["name"] == "operator(.item.)"
+        assert "implementedby" in mod["body"][1]
+        assert mod["body"][1]["implementedby"] == \
+            ["item_int", "item_real"]
+        assert mod["body"][2]["name"] == "operator(==)"
+        assert "implementedby" in mod["body"][2]
+        assert mod["body"][2]["implementedby"] == ["items_are_equal"]
+        assert mod["body"][3]["name"] == "assignment(=)"
+        assert "implementedby" in mod["body"][3]
+        assert mod["body"][3]["implementedby"] == \
+            ["get_int", "get_real"]
+
+    def test_notPublicPrivate(self, tmp_path):
+        fpath = util.getpath("tests", "src", "crackfortran", "pubprivmod.f90")
+        mod = crackfortran.crackfortran([str(fpath)])
+        assert len(mod) == 1
+        mod = mod[0]
+        assert mod['vars']['a']['attrspec'] == ['private', ]
+        assert mod['vars']['b']['attrspec'] == ['public', ]
+        assert mod['vars']['seta']['attrspec'] == ['public', ]
+
+
+class TestExternal(util.F2PyTest):
+    # issue gh-17859: add external attribute support
+    sources = [util.getpath("tests", "src", "crackfortran", "gh17859.f")]
+
+    def test_external_as_statement(self):
+        def incr(x):
+            return x + 123
+
+        r = self.module.external_as_statement(incr)
+        assert r == 123
+
+    def test_external_as_attribute(self):
+        def incr(x):
+            return x + 123
+
+        r = self.module.external_as_attribute(incr)
+        assert r == 123
+
+
+class TestCrackFortran(util.F2PyTest):
+    # gh-2848: commented lines between parameters in subroutine parameter lists
+    sources = [util.getpath("tests", "src", "crackfortran", "gh2848.f90")]
+
+    def test_gh2848(self):
+        r = self.module.gh2848(1, 2)
+        assert r == (1, 2)
+
+
+class TestMarkinnerspaces:
+    # gh-14118: markinnerspaces does not handle multiple quotations
+
+    def test_do_not_touch_normal_spaces(self):
+        test_list = ["a ", " a", "a b c", "'abcdefghij'"]
+        for i in test_list:
+            assert markinnerspaces(i) == i
+
+    def test_one_relevant_space(self):
+        assert markinnerspaces("a 'b c' \\' \\'") == "a 'b@_@c' \\' \\'"
+        assert markinnerspaces(r'a "b c" \" \"') == r'a "b@_@c" \" \"'
+
+    def test_ignore_inner_quotes(self):
+        assert markinnerspaces("a 'b c\" \" d' e") == "a 'b@_@c\"@_@\"@_@d' e"
+        assert markinnerspaces("a \"b c' ' d\" e") == "a \"b@_@c'@_@'@_@d\" e"
+
+    def test_multiple_relevant_spaces(self):
+        assert markinnerspaces("a 'b c' 'd e'") == "a 'b@_@c' 'd@_@e'"
+        assert markinnerspaces(r'a "b c" "d e"') == r'a "b@_@c" "d@_@e"'
+
+
+class TestDimSpec(util.F2PyTest):
+    """This test suite tests various expressions that are used as dimension
+    specifications.
+
+    There exists two usage cases where analyzing dimensions
+    specifications are important.
+
+    In the first case, the size of output arrays must be defined based
+    on the inputs to a Fortran function. Because Fortran supports
+    arbitrary bases for indexing, for instance, `arr(lower:upper)`,
+    f2py has to evaluate an expression `upper - lower + 1` where
+    `lower` and `upper` are arbitrary expressions of input parameters.
+    The evaluation is performed in C, so f2py has to translate Fortran
+    expressions to valid C expressions (an alternative approach is
+    that a developer specifies the corresponding C expressions in a
+    .pyf file).
+
+    In the second case, when user provides an input array with a given
+    size but some hidden parameters used in dimensions specifications
+    need to be determined based on the input array size. This is a
+    harder problem because f2py has to solve the inverse problem: find
+    a parameter `p` such that `upper(p) - lower(p) + 1` equals to the
+    size of input array. In the case when this equation cannot be
+    solved (e.g. because the input array size is wrong), raise an
+    error before calling the Fortran function (that otherwise would
+    likely crash Python process when the size of input arrays is
+    wrong). f2py currently supports this case only when the equation
+    is linear with respect to unknown parameter.
+
+    """
+
+    suffix = ".f90"
+
+    code_template = textwrap.dedent("""
+      function get_arr_size_{count}(a, n) result (length)
+        integer, intent(in) :: n
+        integer, dimension({dimspec}), intent(out) :: a
+        integer length
+        length = size(a)
+      end function
+
+      subroutine get_inv_arr_size_{count}(a, n)
+        integer :: n
+        ! the value of n is computed in f2py wrapper
+        !f2py intent(out) n
+        integer, dimension({dimspec}), intent(in) :: a
+        if (a({first}).gt.0) then
+          ! print*, "a=", a
+        endif
+      end subroutine
+    """)
+
+    linear_dimspecs = [
+        "n", "2*n", "2:n", "n/2", "5 - n/2", "3*n:20", "n*(n+1):n*(n+5)",
+        "2*n, n"
+    ]
+    nonlinear_dimspecs = ["2*n:3*n*n+2*n"]
+    all_dimspecs = linear_dimspecs + nonlinear_dimspecs
+
+    code = ""
+    for count, dimspec in enumerate(all_dimspecs):
+        lst = [(d.split(":")[0] if ":" in d else "1") for d in dimspec.split(',')]
+        code += code_template.format(
+            count=count,
+            dimspec=dimspec,
+            first=", ".join(lst),
+        )
+
+    @pytest.mark.parametrize("dimspec", all_dimspecs)
+    @pytest.mark.slow
+    def test_array_size(self, dimspec):
+
+        count = self.all_dimspecs.index(dimspec)
+        get_arr_size = getattr(self.module, f"get_arr_size_{count}")
+
+        for n in [1, 2, 3, 4, 5]:
+            sz, a = get_arr_size(n)
+            assert a.size == sz
+
+    @pytest.mark.parametrize("dimspec", all_dimspecs)
+    def test_inv_array_size(self, dimspec):
+
+        count = self.all_dimspecs.index(dimspec)
+        get_arr_size = getattr(self.module, f"get_arr_size_{count}")
+        get_inv_arr_size = getattr(self.module, f"get_inv_arr_size_{count}")
+
+        for n in [1, 2, 3, 4, 5]:
+            sz, a = get_arr_size(n)
+            if dimspec in self.nonlinear_dimspecs:
+                # one must specify n as input, the call we'll ensure
+                # that a and n are compatible:
+                n1 = get_inv_arr_size(a, n)
+            else:
+                # in case of linear dependence, n can be determined
+                # from the shape of a:
+                n1 = get_inv_arr_size(a)
+            # n1 may be different from n (for instance, when `a` size
+            # is a function of some `n` fraction) but it must produce
+            # the same sized array
+            sz1, _ = get_arr_size(n1)
+            assert sz == sz1, (n, n1, sz, sz1)
+
+
+class TestModuleDeclaration:
+    def test_dependencies(self, tmp_path):
+        fpath = util.getpath("tests", "src", "crackfortran", "foo_deps.f90")
+        mod = crackfortran.crackfortran([str(fpath)])
+        assert len(mod) == 1
+        assert mod[0]["vars"]["abar"]["="] == "bar('abar')"
+
+
+class TestEval(util.F2PyTest):
+    def test_eval_scalar(self):
+        eval_scalar = crackfortran._eval_scalar
+
+        assert eval_scalar('123', {}) == '123'
+        assert eval_scalar('12 + 3', {}) == '15'
+        assert eval_scalar('a + b', dict(a=1, b=2)) == '3'
+        assert eval_scalar('"123"', {}) == "'123'"
+
+
+class TestFortranReader(util.F2PyTest):
+    @pytest.mark.parametrize("encoding",
+                             ['ascii', 'utf-8', 'utf-16', 'utf-32'])
+    def test_input_encoding(self, tmp_path, encoding):
+        # gh-635
+        f_path = tmp_path / f"input_with_{encoding}_encoding.f90"
+        with f_path.open('w', encoding=encoding) as ff:
+            ff.write("""
+                     subroutine foo()
+                     end subroutine foo
+                     """)
+        mod = crackfortran.crackfortran([str(f_path)])
+        assert mod[0]['name'] == 'foo'
+
+
+@pytest.mark.slow
+class TestUnicodeComment(util.F2PyTest):
+    sources = [util.getpath("tests", "src", "crackfortran", "unicode_comment.f90")]
+
+    @pytest.mark.skipif(
+        (importlib.util.find_spec("charset_normalizer") is None),
+        reason="test requires charset_normalizer which is not installed",
+    )
+    def test_encoding_comment(self):
+        self.module.foo(3)
+
+
+class TestNameArgsPatternBacktracking:
+    @pytest.mark.parametrize(
+        ['adversary'],
+        [
+            ('@)@bind@(@',),
+            ('@)@bind                         @(@',),
+            ('@)@bind foo bar baz@(@',)
+        ]
+    )
+    def test_nameargspattern_backtracking(self, adversary):
+        '''address ReDOS vulnerability:
+        https://github.com/numpy/numpy/issues/23338'''
+        trials_per_batch = 12
+        batches_per_regex = 4
+        start_reps, end_reps = 15, 25
+        for ii in range(start_reps, end_reps):
+            repeated_adversary = adversary * ii
+            # test times in small batches.
+            # this gives us more chances to catch a bad regex
+            # while still catching it before too long if it is bad
+            for _ in range(batches_per_regex):
+                times = []
+                for _ in range(trials_per_batch):
+                    t0 = time.perf_counter()
+                    mtch = nameargspattern.search(repeated_adversary)
+                    times.append(time.perf_counter() - t0)
+                # our pattern should be much faster than 0.2s per search
+                # it's unlikely that a bad regex will pass even on fast CPUs
+                assert np.median(times) < 0.2
+            assert not mtch
+            # if the adversary is capped with @)@, it becomes acceptable
+            # according to the old version of the regex.
+            # that should still be true.
+            good_version_of_adversary = repeated_adversary + '@)@'
+            assert nameargspattern.search(good_version_of_adversary)
+
+class TestFunctionReturn(util.F2PyTest):
+    sources = [util.getpath("tests", "src", "crackfortran", "gh23598.f90")]
+
+    @pytest.mark.slow
+    def test_function_rettype(self):
+        # gh-23598
+        assert self.module.intproduct(3, 4) == 12
+
+
+class TestFortranGroupCounters(util.F2PyTest):
+    def test_end_if_comment(self):
+        # gh-23533
+        fpath = util.getpath("tests", "src", "crackfortran", "gh23533.f")
+        try:
+            crackfortran.crackfortran([str(fpath)])
+        except Exception as exc:
+            assert False, f"'crackfortran.crackfortran' raised an exception {exc}"
+
+
+class TestF77CommonBlockReader:
+    def test_gh22648(self, tmp_path):
+        fpath = util.getpath("tests", "src", "crackfortran", "gh22648.pyf")
+        with contextlib.redirect_stdout(io.StringIO()) as stdout_f2py:
+            mod = crackfortran.crackfortran([str(fpath)])
+        assert "Mismatch" not in stdout_f2py.getvalue()
+
+class TestParamEval:
+    # issue gh-11612, array parameter parsing
+    def test_param_eval_nested(self):
+        v = '(/3.14, 4./)'
+        g_params = dict(kind=crackfortran._kind_func,
+                selected_int_kind=crackfortran._selected_int_kind_func,
+                selected_real_kind=crackfortran._selected_real_kind_func)
+        params = {'dp': 8, 'intparamarray': {1: 3, 2: 5},
+                  'nested': {1: 1, 2: 2, 3: 3}}
+        dimspec = '(2)'
+        ret = crackfortran.param_eval(v, g_params, params, dimspec=dimspec)
+        assert ret == {1: 3.14, 2: 4.0}
+
+    def test_param_eval_nonstandard_range(self):
+        v = '(/ 6, 3, 1 /)'
+        g_params = dict(kind=crackfortran._kind_func,
+                selected_int_kind=crackfortran._selected_int_kind_func,
+                selected_real_kind=crackfortran._selected_real_kind_func)
+        params = {}
+        dimspec = '(-1:1)'
+        ret = crackfortran.param_eval(v, g_params, params, dimspec=dimspec)
+        assert ret == {-1: 6, 0: 3, 1: 1}
+
+    def test_param_eval_empty_range(self):
+        v = '6'
+        g_params = dict(kind=crackfortran._kind_func,
+                selected_int_kind=crackfortran._selected_int_kind_func,
+                selected_real_kind=crackfortran._selected_real_kind_func)
+        params = {}
+        dimspec = ''
+        pytest.raises(ValueError, crackfortran.param_eval, v, g_params, params,
+                      dimspec=dimspec)
+
+    def test_param_eval_non_array_param(self):
+        v = '3.14_dp'
+        g_params = dict(kind=crackfortran._kind_func,
+                selected_int_kind=crackfortran._selected_int_kind_func,
+                selected_real_kind=crackfortran._selected_real_kind_func)
+        params = {}
+        ret = crackfortran.param_eval(v, g_params, params, dimspec=None)
+        assert ret == '3.14_dp'
+
+    def test_param_eval_too_many_dims(self):
+        v = 'reshape((/ (i, i=1, 250) /), (/5, 10, 5/))'
+        g_params = dict(kind=crackfortran._kind_func,
+                selected_int_kind=crackfortran._selected_int_kind_func,
+                selected_real_kind=crackfortran._selected_real_kind_func)
+        params = {}
+        dimspec = '(0:4, 3:12, 5)'
+        pytest.raises(ValueError, crackfortran.param_eval, v, g_params, params,
+                      dimspec=dimspec)
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/test_data.py b/venv/lib/python3.12/site-packages/numpy/f2py/tests/test_data.py
new file mode 100644
index 00000000..5af5c404
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/tests/test_data.py
@@ -0,0 +1,71 @@
+import os
+import pytest
+import numpy as np
+
+from . import util
+from numpy.f2py.crackfortran import crackfortran
+
+
+class TestData(util.F2PyTest):
+    sources = [util.getpath("tests", "src", "crackfortran", "data_stmts.f90")]
+
+    # For gh-23276
+    @pytest.mark.slow
+    def test_data_stmts(self):
+        assert self.module.cmplxdat.i == 2
+        assert self.module.cmplxdat.j == 3
+        assert self.module.cmplxdat.x == 1.5
+        assert self.module.cmplxdat.y == 2.0
+        assert self.module.cmplxdat.pi == 3.1415926535897932384626433832795028841971693993751058209749445923078164062
+        assert self.module.cmplxdat.medium_ref_index == np.array(1.+0.j)
+        assert np.all(self.module.cmplxdat.z == np.array([3.5, 7.0]))
+        assert np.all(self.module.cmplxdat.my_array == np.array([ 1.+2.j, -3.+4.j]))
+        assert np.all(self.module.cmplxdat.my_real_array == np.array([ 1., 2., 3.]))
+        assert np.all(self.module.cmplxdat.ref_index_one == np.array([13.0 + 21.0j]))
+        assert np.all(self.module.cmplxdat.ref_index_two == np.array([-30.0 + 43.0j]))
+
+    def test_crackedlines(self):
+        mod = crackfortran(self.sources)
+        assert mod[0]['vars']['x']['='] == '1.5'
+        assert mod[0]['vars']['y']['='] == '2.0'
+        assert mod[0]['vars']['pi']['='] == '3.1415926535897932384626433832795028841971693993751058209749445923078164062d0'
+        assert mod[0]['vars']['my_real_array']['='] == '(/1.0d0, 2.0d0, 3.0d0/)'
+        assert mod[0]['vars']['ref_index_one']['='] == '(13.0d0, 21.0d0)'
+        assert mod[0]['vars']['ref_index_two']['='] == '(-30.0d0, 43.0d0)'
+        assert mod[0]['vars']['my_array']['='] == '(/(1.0d0, 2.0d0), (-3.0d0, 4.0d0)/)'
+        assert mod[0]['vars']['z']['='] == '(/3.5,  7.0/)'
+
+class TestDataF77(util.F2PyTest):
+    sources = [util.getpath("tests", "src", "crackfortran", "data_common.f")]
+
+    # For gh-23276
+    def test_data_stmts(self):
+        assert self.module.mycom.mydata == 0
+
+    def test_crackedlines(self):
+        mod = crackfortran(str(self.sources[0]))
+        print(mod[0]['vars'])
+        assert mod[0]['vars']['mydata']['='] == '0'
+
+
+class TestDataMultiplierF77(util.F2PyTest):
+    sources = [util.getpath("tests", "src", "crackfortran", "data_multiplier.f")]
+
+    # For gh-23276
+    def test_data_stmts(self):
+        assert self.module.mycom.ivar1 == 3
+        assert self.module.mycom.ivar2 == 3
+        assert self.module.mycom.ivar3 == 2
+        assert self.module.mycom.ivar4 == 2
+        assert self.module.mycom.evar5 == 0
+
+
+class TestDataWithCommentsF77(util.F2PyTest):
+    sources = [util.getpath("tests", "src", "crackfortran", "data_with_comments.f")]
+
+    # For gh-23276
+    def test_data_stmts(self):
+        assert len(self.module.mycom.mytab) == 3
+        assert self.module.mycom.mytab[0] == 0
+        assert self.module.mycom.mytab[1] == 4
+        assert self.module.mycom.mytab[2] == 0
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/test_docs.py b/venv/lib/python3.12/site-packages/numpy/f2py/tests/test_docs.py
new file mode 100644
index 00000000..55540a9c
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/tests/test_docs.py
@@ -0,0 +1,59 @@
+import pytest
+import numpy as np
+from numpy.testing import assert_array_equal, assert_equal
+from . import util
+from pathlib import Path
+
+def get_docdir():
+    parents = Path(__file__).resolve().parents
+    try:
+        # Assumes that spin is used to run tests
+        nproot = parents[8]
+    except IndexError:
+        docdir = None
+    else:
+        docdir = nproot / "doc" / "source" / "f2py" / "code"
+    if docdir and docdir.is_dir():
+        return docdir
+    # Assumes that an editable install is used to run tests
+    return parents[3] / "doc" / "source" / "f2py" / "code"
+
+pytestmark = pytest.mark.skipif(
+    not get_docdir().is_dir(),
+    reason=f"Could not find f2py documentation sources"
+    f"({get_docdir()} does not exist)",
+)
+
+def _path(*args):
+    return get_docdir().joinpath(*args)
+
+@pytest.mark.slow
+class TestDocAdvanced(util.F2PyTest):
+    # options = ['--debug-capi', '--build-dir', '/tmp/build-f2py']
+    sources = [_path('asterisk1.f90'), _path('asterisk2.f90'),
+               _path('ftype.f')]
+
+    def test_asterisk1(self):
+        foo = getattr(self.module, 'foo1')
+        assert_equal(foo(), b'123456789A12')
+
+    def test_asterisk2(self):
+        foo = getattr(self.module, 'foo2')
+        assert_equal(foo(2), b'12')
+        assert_equal(foo(12), b'123456789A12')
+        assert_equal(foo(20), b'123456789A123456789B')
+
+    def test_ftype(self):
+        ftype = self.module
+        ftype.foo()
+        assert_equal(ftype.data.a, 0)
+        ftype.data.a = 3
+        ftype.data.x = [1, 2, 3]
+        assert_equal(ftype.data.a, 3)
+        assert_array_equal(ftype.data.x,
+                           np.array([1, 2, 3], dtype=np.float32))
+        ftype.data.x[1] = 45
+        assert_array_equal(ftype.data.x,
+                           np.array([1, 45, 3], dtype=np.float32))
+
+    # TODO: implement test methods for other example Fortran codes
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/test_f2cmap.py b/venv/lib/python3.12/site-packages/numpy/f2py/tests/test_f2cmap.py
new file mode 100644
index 00000000..6596ada3
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/tests/test_f2cmap.py
@@ -0,0 +1,15 @@
+from . import util
+import numpy as np
+
+class TestF2Cmap(util.F2PyTest):
+    sources = [
+        util.getpath("tests", "src", "f2cmap", "isoFortranEnvMap.f90"),
+        util.getpath("tests", "src", "f2cmap", ".f2py_f2cmap")
+    ]
+
+    # gh-15095
+    def test_gh15095(self):
+        inp = np.ones(3)
+        out = self.module.func1(inp)
+        exp_out = 3
+        assert out == exp_out
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/test_f2py2e.py b/venv/lib/python3.12/site-packages/numpy/f2py/tests/test_f2py2e.py
new file mode 100644
index 00000000..ce0046eb
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/tests/test_f2py2e.py
@@ -0,0 +1,959 @@
+import textwrap, re, sys, subprocess, shlex
+from pathlib import Path
+from collections import namedtuple
+import platform
+
+import pytest
+
+from . import util
+from numpy.f2py.f2py2e import main as f2pycli
+from numpy.testing._private.utils import NOGIL_BUILD
+
+#######################
+# F2PY Test utilities #
+######################
+
+# Tests for CLI commands which call meson will fail if no compilers are present, these are to be skipped
+
+def compiler_check_f2pycli():
+    if not util.has_fortran_compiler():
+        pytest.skip("CLI command needs a Fortran compiler")
+    else:
+        f2pycli()
+
+#########################
+# CLI utils and classes #
+#########################
+
+PPaths = namedtuple("PPaths", "finp, f90inp, pyf, wrap77, wrap90, cmodf")
+
+
+def get_io_paths(fname_inp, mname="untitled"):
+    """Takes in a temporary file for testing and returns the expected output and input paths
+
+    Here expected output is essentially one of any of the possible generated
+    files.
+
+    ..note::
+
+         Since this does not actually run f2py, none of these are guaranteed to
+         exist, and module names are typically incorrect
+
+    Parameters
+    ----------
+    fname_inp : str
+                The input filename
+    mname : str, optional
+                The name of the module, untitled by default
+
+    Returns
+    -------
+    genp : NamedTuple PPaths
+            The possible paths which are generated, not all of which exist
+    """
+    bpath = Path(fname_inp)
+    return PPaths(
+        finp=bpath.with_suffix(".f"),
+        f90inp=bpath.with_suffix(".f90"),
+        pyf=bpath.with_suffix(".pyf"),
+        wrap77=bpath.with_name(f"{mname}-f2pywrappers.f"),
+        wrap90=bpath.with_name(f"{mname}-f2pywrappers2.f90"),
+        cmodf=bpath.with_name(f"{mname}module.c"),
+    )
+
+
+################
+# CLI Fixtures #
+################
+
+
+@pytest.fixture(scope="session")
+def hello_world_f90(tmpdir_factory):
+    """Generates a single f90 file for testing"""
+    fdat = util.getpath("tests", "src", "cli", "hiworld.f90").read_text()
+    fn = tmpdir_factory.getbasetemp() / "hello.f90"
+    fn.write_text(fdat, encoding="ascii")
+    return fn
+
+
+@pytest.fixture(scope="session")
+def gh23598_warn(tmpdir_factory):
+    """F90 file for testing warnings in gh23598"""
+    fdat = util.getpath("tests", "src", "crackfortran", "gh23598Warn.f90").read_text()
+    fn = tmpdir_factory.getbasetemp() / "gh23598Warn.f90"
+    fn.write_text(fdat, encoding="ascii")
+    return fn
+
+
+@pytest.fixture(scope="session")
+def gh22819_cli(tmpdir_factory):
+    """F90 file for testing disallowed CLI arguments in ghff819"""
+    fdat = util.getpath("tests", "src", "cli", "gh_22819.pyf").read_text()
+    fn = tmpdir_factory.getbasetemp() / "gh_22819.pyf"
+    fn.write_text(fdat, encoding="ascii")
+    return fn
+
+
+@pytest.fixture(scope="session")
+def hello_world_f77(tmpdir_factory):
+    """Generates a single f77 file for testing"""
+    fdat = util.getpath("tests", "src", "cli", "hi77.f").read_text()
+    fn = tmpdir_factory.getbasetemp() / "hello.f"
+    fn.write_text(fdat, encoding="ascii")
+    return fn
+
+
+@pytest.fixture(scope="session")
+def retreal_f77(tmpdir_factory):
+    """Generates a single f77 file for testing"""
+    fdat = util.getpath("tests", "src", "return_real", "foo77.f").read_text()
+    fn = tmpdir_factory.getbasetemp() / "foo.f"
+    fn.write_text(fdat, encoding="ascii")
+    return fn
+
+@pytest.fixture(scope="session")
+def f2cmap_f90(tmpdir_factory):
+    """Generates a single f90 file for testing"""
+    fdat = util.getpath("tests", "src", "f2cmap", "isoFortranEnvMap.f90").read_text()
+    f2cmap = util.getpath("tests", "src", "f2cmap", ".f2py_f2cmap").read_text()
+    fn = tmpdir_factory.getbasetemp() / "f2cmap.f90"
+    fmap = tmpdir_factory.getbasetemp() / "mapfile"
+    fn.write_text(fdat, encoding="ascii")
+    fmap.write_text(f2cmap, encoding="ascii")
+    return fn
+
+#########
+# Tests #
+#########
+
+def test_gh22819_cli(capfd, gh22819_cli, monkeypatch):
+    """Check that module names are handled correctly
+    gh-22819
+    Essentially, the -m name cannot be used to import the module, so the module
+    named in the .pyf needs to be used instead
+
+    CLI :: -m and a .pyf file
+    """
+    ipath = Path(gh22819_cli)
+    monkeypatch.setattr(sys, "argv", f"f2py -m blah {ipath}".split())
+    with util.switchdir(ipath.parent):
+        f2pycli()
+        gen_paths = [item.name for item in ipath.parent.rglob("*") if item.is_file()]
+        assert "blahmodule.c" not in gen_paths # shouldn't be generated
+        assert "blah-f2pywrappers.f" not in gen_paths
+        assert "test_22819-f2pywrappers.f" in gen_paths
+        assert "test_22819module.c" in gen_paths
+        assert "Ignoring blah"
+
+
+def test_gh22819_many_pyf(capfd, gh22819_cli, monkeypatch):
+    """Only one .pyf file allowed
+    gh-22819
+    CLI :: .pyf files
+    """
+    ipath = Path(gh22819_cli)
+    monkeypatch.setattr(sys, "argv", f"f2py -m blah {ipath} hello.pyf".split())
+    with util.switchdir(ipath.parent):
+        with pytest.raises(ValueError, match="Only one .pyf file per call"):
+            f2pycli()
+
+
+def test_gh23598_warn(capfd, gh23598_warn, monkeypatch):
+    foutl = get_io_paths(gh23598_warn, mname="test")
+    ipath = foutl.f90inp
+    monkeypatch.setattr(
+        sys, "argv",
+        f'f2py {ipath} -m test'.split())
+
+    with util.switchdir(ipath.parent):
+        f2pycli()  # Generate files
+        wrapper = foutl.wrap90.read_text()
+        assert "intproductf2pywrap, intpr" not in wrapper
+
+
+def test_gen_pyf(capfd, hello_world_f90, monkeypatch):
+    """Ensures that a signature file is generated via the CLI
+    CLI :: -h
+    """
+    ipath = Path(hello_world_f90)
+    opath = Path(hello_world_f90).stem + ".pyf"
+    monkeypatch.setattr(sys, "argv", f'f2py -h {opath} {ipath}'.split())
+
+    with util.switchdir(ipath.parent):
+        f2pycli()  # Generate wrappers
+        out, _ = capfd.readouterr()
+        assert "Saving signatures to file" in out
+        assert Path(f'{opath}').exists()
+
+
+def test_gen_pyf_stdout(capfd, hello_world_f90, monkeypatch):
+    """Ensures that a signature file can be dumped to stdout
+    CLI :: -h
+    """
+    ipath = Path(hello_world_f90)
+    monkeypatch.setattr(sys, "argv", f'f2py -h stdout {ipath}'.split())
+    with util.switchdir(ipath.parent):
+        f2pycli()
+        out, _ = capfd.readouterr()
+        assert "Saving signatures to file" in out
+        assert "function hi() ! in " in out
+
+
+def test_gen_pyf_no_overwrite(capfd, hello_world_f90, monkeypatch):
+    """Ensures that the CLI refuses to overwrite signature files
+    CLI :: -h without --overwrite-signature
+    """
+    ipath = Path(hello_world_f90)
+    monkeypatch.setattr(sys, "argv", f'f2py -h faker.pyf {ipath}'.split())
+
+    with util.switchdir(ipath.parent):
+        Path("faker.pyf").write_text("Fake news", encoding="ascii")
+        with pytest.raises(SystemExit):
+            f2pycli()  # Refuse to overwrite
+            _, err = capfd.readouterr()
+            assert "Use --overwrite-signature to overwrite" in err
+
+
+@pytest.mark.skipif(sys.version_info <= (3, 12), reason="Python 3.12 required")
+def test_untitled_cli(capfd, hello_world_f90, monkeypatch):
+    """Check that modules are named correctly
+
+    CLI :: defaults
+    """
+    ipath = Path(hello_world_f90)
+    monkeypatch.setattr(sys, "argv", f"f2py --backend meson -c {ipath}".split())
+    with util.switchdir(ipath.parent):
+        compiler_check_f2pycli()
+        out, _ = capfd.readouterr()
+        assert "untitledmodule.c" in out
+
+
+@pytest.mark.skipif((platform.system() != 'Linux') or (sys.version_info <= (3, 12)), reason='Compiler and 3.12 required')
+def test_no_py312_distutils_fcompiler(capfd, hello_world_f90, monkeypatch):
+    """Check that no distutils imports are performed on 3.12
+    CLI :: --fcompiler --help-link --backend distutils
+    """
+    MNAME = "hi"
+    foutl = get_io_paths(hello_world_f90, mname=MNAME)
+    ipath = foutl.f90inp
+    monkeypatch.setattr(
+        sys, "argv", f"f2py {ipath} -c --fcompiler=gfortran -m {MNAME}".split()
+    )
+    with util.switchdir(ipath.parent):
+        compiler_check_f2pycli()
+        out, _ = capfd.readouterr()
+        assert "--fcompiler cannot be used with meson" in out
+    monkeypatch.setattr(
+        sys, "argv", f"f2py --help-link".split()
+    )
+    with util.switchdir(ipath.parent):
+        f2pycli()
+        out, _ = capfd.readouterr()
+        assert "Use --dep for meson builds" in out
+    MNAME = "hi2" # Needs to be different for a new -c
+    monkeypatch.setattr(
+        sys, "argv", f"f2py {ipath} -c -m {MNAME} --backend distutils".split()
+    )
+    with util.switchdir(ipath.parent):
+        f2pycli()
+        out, _ = capfd.readouterr()
+        assert "Cannot use distutils backend with Python>=3.12" in out
+
+
+@pytest.mark.xfail
+def test_f2py_skip(capfd, retreal_f77, monkeypatch):
+    """Tests that functions can be skipped
+    CLI :: skip:
+    """
+    foutl = get_io_paths(retreal_f77, mname="test")
+    ipath = foutl.finp
+    toskip = "t0 t4 t8 sd s8 s4"
+    remaining = "td s0"
+    monkeypatch.setattr(
+        sys, "argv",
+        f'f2py {ipath} -m test skip: {toskip}'.split())
+
+    with util.switchdir(ipath.parent):
+        f2pycli()
+        out, err = capfd.readouterr()
+        for skey in toskip.split():
+            assert (
+                f'buildmodule: Could not found the body of interfaced routine "{skey}". Skipping.'
+                in err)
+        for rkey in remaining.split():
+            assert f'Constructing wrapper function "{rkey}"' in out
+
+
+def test_f2py_only(capfd, retreal_f77, monkeypatch):
+    """Test that functions can be kept by only:
+    CLI :: only:
+    """
+    foutl = get_io_paths(retreal_f77, mname="test")
+    ipath = foutl.finp
+    toskip = "t0 t4 t8 sd s8 s4"
+    tokeep = "td s0"
+    monkeypatch.setattr(
+        sys, "argv",
+        f'f2py {ipath} -m test only: {tokeep}'.split())
+
+    with util.switchdir(ipath.parent):
+        f2pycli()
+        out, err = capfd.readouterr()
+        for skey in toskip.split():
+            assert (
+                f'buildmodule: Could not find the body of interfaced routine "{skey}". Skipping.'
+                in err)
+        for rkey in tokeep.split():
+            assert f'Constructing wrapper function "{rkey}"' in out
+
+
+def test_file_processing_switch(capfd, hello_world_f90, retreal_f77,
+                                monkeypatch):
+    """Tests that it is possible to return to file processing mode
+    CLI :: :
+    BUG: numpy-gh #20520
+    """
+    foutl = get_io_paths(retreal_f77, mname="test")
+    ipath = foutl.finp
+    toskip = "t0 t4 t8 sd s8 s4"
+    ipath2 = Path(hello_world_f90)
+    tokeep = "td s0 hi"  # hi is in ipath2
+    mname = "blah"
+    monkeypatch.setattr(
+        sys,
+        "argv",
+        f'f2py {ipath} -m {mname} only: {tokeep} : {ipath2}'.split(
+        ),
+    )
+
+    with util.switchdir(ipath.parent):
+        f2pycli()
+        out, err = capfd.readouterr()
+        for skey in toskip.split():
+            assert (
+                f'buildmodule: Could not find the body of interfaced routine "{skey}". Skipping.'
+                in err)
+        for rkey in tokeep.split():
+            assert f'Constructing wrapper function "{rkey}"' in out
+
+
+def test_mod_gen_f77(capfd, hello_world_f90, monkeypatch):
+    """Checks the generation of files based on a module name
+    CLI :: -m
+    """
+    MNAME = "hi"
+    foutl = get_io_paths(hello_world_f90, mname=MNAME)
+    ipath = foutl.f90inp
+    monkeypatch.setattr(sys, "argv", f'f2py {ipath} -m {MNAME}'.split())
+    with util.switchdir(ipath.parent):
+        f2pycli()
+
+    # Always generate C module
+    assert Path.exists(foutl.cmodf)
+    # File contains a function, check for F77 wrappers
+    assert Path.exists(foutl.wrap77)
+
+
+def test_mod_gen_gh25263(capfd, hello_world_f77, monkeypatch):
+    """Check that pyf files are correctly generated with module structure
+    CLI :: -m  -h pyf_file
+    BUG: numpy-gh #20520
+    """
+    MNAME = "hi"
+    foutl = get_io_paths(hello_world_f77, mname=MNAME)
+    ipath = foutl.finp
+    monkeypatch.setattr(sys, "argv", f'f2py {ipath} -m {MNAME} -h hi.pyf'.split())
+    with util.switchdir(ipath.parent):
+        f2pycli()
+        with Path('hi.pyf').open() as hipyf:
+            pyfdat = hipyf.read()
+            assert "python module hi" in pyfdat
+
+
+def test_lower_cmod(capfd, hello_world_f77, monkeypatch):
+    """Lowers cases by flag or when -h is present
+
+    CLI :: --[no-]lower
+    """
+    foutl = get_io_paths(hello_world_f77, mname="test")
+    ipath = foutl.finp
+    capshi = re.compile(r"HI\(\)")
+    capslo = re.compile(r"hi\(\)")
+    # Case I: --lower is passed
+    monkeypatch.setattr(sys, "argv", f'f2py {ipath} -m test --lower'.split())
+    with util.switchdir(ipath.parent):
+        f2pycli()
+        out, _ = capfd.readouterr()
+        assert capslo.search(out) is not None
+        assert capshi.search(out) is None
+    # Case II: --no-lower is passed
+    monkeypatch.setattr(sys, "argv",
+                        f'f2py {ipath} -m test --no-lower'.split())
+    with util.switchdir(ipath.parent):
+        f2pycli()
+        out, _ = capfd.readouterr()
+        assert capslo.search(out) is None
+        assert capshi.search(out) is not None
+
+
+def test_lower_sig(capfd, hello_world_f77, monkeypatch):
+    """Lowers cases in signature files by flag or when -h is present
+
+    CLI :: --[no-]lower -h
+    """
+    foutl = get_io_paths(hello_world_f77, mname="test")
+    ipath = foutl.finp
+    # Signature files
+    capshi = re.compile(r"Block: HI")
+    capslo = re.compile(r"Block: hi")
+    # Case I: --lower is implied by -h
+    # TODO: Clean up to prevent passing --overwrite-signature
+    monkeypatch.setattr(
+        sys,
+        "argv",
+        f'f2py {ipath} -h {foutl.pyf} -m test --overwrite-signature'.split(),
+    )
+
+    with util.switchdir(ipath.parent):
+        f2pycli()
+        out, _ = capfd.readouterr()
+        assert capslo.search(out) is not None
+        assert capshi.search(out) is None
+
+    # Case II: --no-lower overrides -h
+    monkeypatch.setattr(
+        sys,
+        "argv",
+        f'f2py {ipath} -h {foutl.pyf} -m test --overwrite-signature --no-lower'
+        .split(),
+    )
+
+    with util.switchdir(ipath.parent):
+        f2pycli()
+        out, _ = capfd.readouterr()
+        assert capslo.search(out) is None
+        assert capshi.search(out) is not None
+
+
+def test_build_dir(capfd, hello_world_f90, monkeypatch):
+    """Ensures that the build directory can be specified
+
+    CLI :: --build-dir
+    """
+    ipath = Path(hello_world_f90)
+    mname = "blah"
+    odir = "tttmp"
+    monkeypatch.setattr(sys, "argv",
+                        f'f2py -m {mname} {ipath} --build-dir {odir}'.split())
+
+    with util.switchdir(ipath.parent):
+        f2pycli()
+        out, _ = capfd.readouterr()
+        assert f"Wrote C/API module \"{mname}\"" in out
+
+
+def test_overwrite(capfd, hello_world_f90, monkeypatch):
+    """Ensures that the build directory can be specified
+
+    CLI :: --overwrite-signature
+    """
+    ipath = Path(hello_world_f90)
+    monkeypatch.setattr(
+        sys, "argv",
+        f'f2py -h faker.pyf {ipath} --overwrite-signature'.split())
+
+    with util.switchdir(ipath.parent):
+        Path("faker.pyf").write_text("Fake news", encoding="ascii")
+        f2pycli()
+        out, _ = capfd.readouterr()
+        assert "Saving signatures to file" in out
+
+
+def test_latexdoc(capfd, hello_world_f90, monkeypatch):
+    """Ensures that TeX documentation is written out
+
+    CLI :: --latex-doc
+    """
+    ipath = Path(hello_world_f90)
+    mname = "blah"
+    monkeypatch.setattr(sys, "argv",
+                        f'f2py -m {mname} {ipath} --latex-doc'.split())
+
+    with util.switchdir(ipath.parent):
+        f2pycli()
+        out, _ = capfd.readouterr()
+        assert "Documentation is saved to file" in out
+        with Path(f"{mname}module.tex").open() as otex:
+            assert "\\documentclass" in otex.read()
+
+
+def test_nolatexdoc(capfd, hello_world_f90, monkeypatch):
+    """Ensures that TeX documentation is written out
+
+    CLI :: --no-latex-doc
+    """
+    ipath = Path(hello_world_f90)
+    mname = "blah"
+    monkeypatch.setattr(sys, "argv",
+                        f'f2py -m {mname} {ipath} --no-latex-doc'.split())
+
+    with util.switchdir(ipath.parent):
+        f2pycli()
+        out, _ = capfd.readouterr()
+        assert "Documentation is saved to file" not in out
+
+
+def test_shortlatex(capfd, hello_world_f90, monkeypatch):
+    """Ensures that truncated documentation is written out
+
+    TODO: Test to ensure this has no effect without --latex-doc
+    CLI :: --latex-doc --short-latex
+    """
+    ipath = Path(hello_world_f90)
+    mname = "blah"
+    monkeypatch.setattr(
+        sys,
+        "argv",
+        f'f2py -m {mname} {ipath} --latex-doc --short-latex'.split(),
+    )
+
+    with util.switchdir(ipath.parent):
+        f2pycli()
+        out, _ = capfd.readouterr()
+        assert "Documentation is saved to file" in out
+        with Path(f"./{mname}module.tex").open() as otex:
+            assert "\\documentclass" not in otex.read()
+
+
+def test_restdoc(capfd, hello_world_f90, monkeypatch):
+    """Ensures that RsT documentation is written out
+
+    CLI :: --rest-doc
+    """
+    ipath = Path(hello_world_f90)
+    mname = "blah"
+    monkeypatch.setattr(sys, "argv",
+                        f'f2py -m {mname} {ipath} --rest-doc'.split())
+
+    with util.switchdir(ipath.parent):
+        f2pycli()
+        out, _ = capfd.readouterr()
+        assert "ReST Documentation is saved to file" in out
+        with Path(f"./{mname}module.rest").open() as orst:
+            assert r".. -*- rest -*-" in orst.read()
+
+
+def test_norestexdoc(capfd, hello_world_f90, monkeypatch):
+    """Ensures that TeX documentation is written out
+
+    CLI :: --no-rest-doc
+    """
+    ipath = Path(hello_world_f90)
+    mname = "blah"
+    monkeypatch.setattr(sys, "argv",
+                        f'f2py -m {mname} {ipath} --no-rest-doc'.split())
+
+    with util.switchdir(ipath.parent):
+        f2pycli()
+        out, _ = capfd.readouterr()
+        assert "ReST Documentation is saved to file" not in out
+
+
+def test_debugcapi(capfd, hello_world_f90, monkeypatch):
+    """Ensures that debugging wrappers are written
+
+    CLI :: --debug-capi
+    """
+    ipath = Path(hello_world_f90)
+    mname = "blah"
+    monkeypatch.setattr(sys, "argv",
+                        f'f2py -m {mname} {ipath} --debug-capi'.split())
+
+    with util.switchdir(ipath.parent):
+        f2pycli()
+        with Path(f"./{mname}module.c").open() as ocmod:
+            assert r"#define DEBUGCFUNCS" in ocmod.read()
+
+
+@pytest.mark.skip(reason="Consistently fails on CI; noisy so skip not xfail.")
+def test_debugcapi_bld(hello_world_f90, monkeypatch):
+    """Ensures that debugging wrappers work
+
+    CLI :: --debug-capi -c
+    """
+    ipath = Path(hello_world_f90)
+    mname = "blah"
+    monkeypatch.setattr(sys, "argv",
+                        f'f2py -m {mname} {ipath} -c --debug-capi'.split())
+
+    with util.switchdir(ipath.parent):
+        f2pycli()
+        cmd_run = shlex.split(f"{sys.executable} -c \"import blah; blah.hi()\"")
+        rout = subprocess.run(cmd_run, capture_output=True, encoding='UTF-8')
+        eout = ' Hello World\n'
+        eerr = textwrap.dedent("""\
+debug-capi:Python C/API function blah.hi()
+debug-capi:float hi=:output,hidden,scalar
+debug-capi:hi=0
+debug-capi:Fortran subroutine `f2pywraphi(&hi)'
+debug-capi:hi=0
+debug-capi:Building return value.
+debug-capi:Python C/API function blah.hi: successful.
+debug-capi:Freeing memory.
+        """)
+        assert rout.stdout == eout
+        assert rout.stderr == eerr
+
+
+def test_wrapfunc_def(capfd, hello_world_f90, monkeypatch):
+    """Ensures that fortran subroutine wrappers for F77 are included by default
+
+    CLI :: --[no]-wrap-functions
+    """
+    # Implied
+    ipath = Path(hello_world_f90)
+    mname = "blah"
+    monkeypatch.setattr(sys, "argv", f'f2py -m {mname} {ipath}'.split())
+
+    with util.switchdir(ipath.parent):
+        f2pycli()
+    out, _ = capfd.readouterr()
+    assert r"Fortran 77 wrappers are saved to" in out
+
+    # Explicit
+    monkeypatch.setattr(sys, "argv",
+                        f'f2py -m {mname} {ipath} --wrap-functions'.split())
+
+    with util.switchdir(ipath.parent):
+        f2pycli()
+        out, _ = capfd.readouterr()
+        assert r"Fortran 77 wrappers are saved to" in out
+
+
+def test_nowrapfunc(capfd, hello_world_f90, monkeypatch):
+    """Ensures that fortran subroutine wrappers for F77 can be disabled
+
+    CLI :: --no-wrap-functions
+    """
+    ipath = Path(hello_world_f90)
+    mname = "blah"
+    monkeypatch.setattr(sys, "argv",
+                        f'f2py -m {mname} {ipath} --no-wrap-functions'.split())
+
+    with util.switchdir(ipath.parent):
+        f2pycli()
+        out, _ = capfd.readouterr()
+        assert r"Fortran 77 wrappers are saved to" not in out
+
+
+def test_inclheader(capfd, hello_world_f90, monkeypatch):
+    """Add to the include directories
+
+    CLI :: -include
+    TODO: Document this in the help string
+    """
+    ipath = Path(hello_world_f90)
+    mname = "blah"
+    monkeypatch.setattr(
+        sys,
+        "argv",
+        f'f2py -m {mname} {ipath} -include -include '.
+        split(),
+    )
+
+    with util.switchdir(ipath.parent):
+        f2pycli()
+        with Path(f"./{mname}module.c").open() as ocmod:
+            ocmr = ocmod.read()
+            assert "#include " in ocmr
+            assert "#include " in ocmr
+
+
+def test_inclpath():
+    """Add to the include directories
+
+    CLI :: --include-paths
+    """
+    # TODO: populate
+    pass
+
+
+def test_hlink():
+    """Add to the include directories
+
+    CLI :: --help-link
+    """
+    # TODO: populate
+    pass
+
+
+def test_f2cmap(capfd, f2cmap_f90, monkeypatch):
+    """Check that Fortran-to-Python KIND specs can be passed
+
+    CLI :: --f2cmap
+    """
+    ipath = Path(f2cmap_f90)
+    monkeypatch.setattr(sys, "argv", f'f2py -m blah {ipath} --f2cmap mapfile'.split())
+
+    with util.switchdir(ipath.parent):
+        f2pycli()
+        out, _ = capfd.readouterr()
+        assert "Reading f2cmap from 'mapfile' ..." in out
+        assert "Mapping \"real(kind=real32)\" to \"float\"" in out
+        assert "Mapping \"real(kind=real64)\" to \"double\"" in out
+        assert "Mapping \"integer(kind=int64)\" to \"long_long\"" in out
+        assert "Successfully applied user defined f2cmap changes" in out
+
+
+def test_quiet(capfd, hello_world_f90, monkeypatch):
+    """Reduce verbosity
+
+    CLI :: --quiet
+    """
+    ipath = Path(hello_world_f90)
+    monkeypatch.setattr(sys, "argv", f'f2py -m blah {ipath} --quiet'.split())
+
+    with util.switchdir(ipath.parent):
+        f2pycli()
+        out, _ = capfd.readouterr()
+        assert len(out) == 0
+
+
+def test_verbose(capfd, hello_world_f90, monkeypatch):
+    """Increase verbosity
+
+    CLI :: --verbose
+    """
+    ipath = Path(hello_world_f90)
+    monkeypatch.setattr(sys, "argv", f'f2py -m blah {ipath} --verbose'.split())
+
+    with util.switchdir(ipath.parent):
+        f2pycli()
+        out, _ = capfd.readouterr()
+        assert "analyzeline" in out
+
+
+def test_version(capfd, monkeypatch):
+    """Ensure version
+
+    CLI :: -v
+    """
+    monkeypatch.setattr(sys, "argv", 'f2py -v'.split())
+    # TODO: f2py2e should not call sys.exit() after printing the version
+    with pytest.raises(SystemExit):
+        f2pycli()
+        out, _ = capfd.readouterr()
+        import numpy as np
+        assert np.__version__ == out.strip()
+
+
+@pytest.mark.skip(reason="Consistently fails on CI; noisy so skip not xfail.")
+def test_npdistop(hello_world_f90, monkeypatch):
+    """
+    CLI :: -c
+    """
+    ipath = Path(hello_world_f90)
+    monkeypatch.setattr(sys, "argv", f'f2py -m blah {ipath} -c'.split())
+
+    with util.switchdir(ipath.parent):
+        f2pycli()
+        cmd_run = shlex.split(f"{sys.executable} -c \"import blah; blah.hi()\"")
+        rout = subprocess.run(cmd_run, capture_output=True, encoding='UTF-8')
+        eout = ' Hello World\n'
+        assert rout.stdout == eout
+
+
+@pytest.mark.skipif((platform.system() != 'Linux') or sys.version_info <= (3, 12),
+                    reason='Compiler and Python 3.12 or newer required')
+def test_no_freethreading_compatible(hello_world_f90, monkeypatch):
+    """
+    CLI :: --no-freethreading-compatible
+    """
+    ipath = Path(hello_world_f90)
+    monkeypatch.setattr(sys, "argv", f'f2py -m blah {ipath} -c --no-freethreading-compatible'.split())
+
+    with util.switchdir(ipath.parent):
+        compiler_check_f2pycli()
+        cmd = f"{sys.executable} -c \"import blah; blah.hi();"
+        if NOGIL_BUILD:
+            cmd += "import sys; assert sys._is_gil_enabled() is True\""
+        else:
+            cmd += "\""
+        cmd_run = shlex.split(cmd)
+        rout = subprocess.run(cmd_run, capture_output=True, encoding='UTF-8')
+        eout = ' Hello World\n'
+        assert rout.stdout == eout
+        if NOGIL_BUILD:
+            assert "The global interpreter lock (GIL) has been enabled to load module 'blah'" in rout.stderr
+        assert rout.returncode == 0
+
+
+@pytest.mark.skipif((platform.system() != 'Linux') or sys.version_info <= (3, 12),
+                    reason='Compiler and Python 3.12 or newer required')
+def test_freethreading_compatible(hello_world_f90, monkeypatch):
+    """
+    CLI :: --freethreading_compatible
+    """
+    ipath = Path(hello_world_f90)
+    monkeypatch.setattr(sys, "argv", f'f2py -m blah {ipath} -c --freethreading-compatible'.split())
+
+    with util.switchdir(ipath.parent):
+        compiler_check_f2pycli()
+        cmd = f"{sys.executable} -c \"import blah; blah.hi();"
+        if NOGIL_BUILD:
+            cmd += "import sys; assert sys._is_gil_enabled() is False\""
+        else:
+            cmd += "\""
+        cmd_run = shlex.split(cmd)
+        rout = subprocess.run(cmd_run, capture_output=True, encoding='UTF-8')
+        eout = ' Hello World\n'
+        assert rout.stdout == eout
+        assert rout.stderr == ""
+        assert rout.returncode == 0
+
+
+# Numpy distutils flags
+# TODO: These should be tested separately
+
+def test_npd_fcompiler():
+    """
+    CLI :: -c --fcompiler
+    """
+    # TODO: populate
+    pass
+
+
+def test_npd_compiler():
+    """
+    CLI :: -c --compiler
+    """
+    # TODO: populate
+    pass
+
+
+def test_npd_help_fcompiler():
+    """
+    CLI :: -c --help-fcompiler
+    """
+    # TODO: populate
+    pass
+
+
+def test_npd_f77exec():
+    """
+    CLI :: -c --f77exec
+    """
+    # TODO: populate
+    pass
+
+
+def test_npd_f90exec():
+    """
+    CLI :: -c --f90exec
+    """
+    # TODO: populate
+    pass
+
+
+def test_npd_f77flags():
+    """
+    CLI :: -c --f77flags
+    """
+    # TODO: populate
+    pass
+
+
+def test_npd_f90flags():
+    """
+    CLI :: -c --f90flags
+    """
+    # TODO: populate
+    pass
+
+
+def test_npd_opt():
+    """
+    CLI :: -c --opt
+    """
+    # TODO: populate
+    pass
+
+
+def test_npd_arch():
+    """
+    CLI :: -c --arch
+    """
+    # TODO: populate
+    pass
+
+
+def test_npd_noopt():
+    """
+    CLI :: -c --noopt
+    """
+    # TODO: populate
+    pass
+
+
+def test_npd_noarch():
+    """
+    CLI :: -c --noarch
+    """
+    # TODO: populate
+    pass
+
+
+def test_npd_debug():
+    """
+    CLI :: -c --debug
+    """
+    # TODO: populate
+    pass
+
+
+def test_npd_link_auto():
+    """
+    CLI :: -c --link-
+    """
+    # TODO: populate
+    pass
+
+
+def test_npd_lib():
+    """
+    CLI :: -c -L/path/to/lib/ -l
+    """
+    # TODO: populate
+    pass
+
+
+def test_npd_define():
+    """
+    CLI :: -D
+    """
+    # TODO: populate
+    pass
+
+
+def test_npd_undefine():
+    """
+    CLI :: -U
+    """
+    # TODO: populate
+    pass
+
+
+def test_npd_incl():
+    """
+    CLI :: -I/path/to/include/
+    """
+    # TODO: populate
+    pass
+
+
+def test_npd_linker():
+    """
+    CLI :: .o .so .a
+    """
+    # TODO: populate
+    pass
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/test_isoc.py b/venv/lib/python3.12/site-packages/numpy/f2py/tests/test_isoc.py
new file mode 100644
index 00000000..97f71e6c
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/tests/test_isoc.py
@@ -0,0 +1,53 @@
+from . import util
+import numpy as np
+import pytest
+from numpy.testing import assert_allclose
+
+class TestISOC(util.F2PyTest):
+    sources = [
+        util.getpath("tests", "src", "isocintrin", "isoCtests.f90"),
+    ]
+
+    # gh-24553
+    @pytest.mark.slow
+    def test_c_double(self):
+        out = self.module.coddity.c_add(1, 2)
+        exp_out = 3
+        assert  out == exp_out
+
+    # gh-9693
+    def test_bindc_function(self):
+        out = self.module.coddity.wat(1, 20)
+        exp_out = 8
+        assert  out == exp_out
+
+    # gh-25207
+    def test_bindc_kinds(self):
+        out = self.module.coddity.c_add_int64(1, 20)
+        exp_out = 21
+        assert  out == exp_out
+
+    # gh-25207
+    def test_bindc_add_arr(self):
+        a = np.array([1,2,3])
+        b = np.array([1,2,3])
+        out = self.module.coddity.add_arr(a, b)
+        exp_out = a*2
+        assert_allclose(out, exp_out)
+
+
+def test_process_f2cmap_dict():
+    from numpy.f2py.auxfuncs import process_f2cmap_dict
+
+    f2cmap_all = {"integer": {"8": "rubbish_type"}}
+    new_map = {"INTEGER": {"4": "int"}}
+    c2py_map = {"int": "int", "rubbish_type": "long"}
+
+    exp_map, exp_maptyp = ({"integer": {"8": "rubbish_type", "4": "int"}}, ["int"])
+
+    # Call the function
+    res_map, res_maptyp = process_f2cmap_dict(f2cmap_all, new_map, c2py_map)
+
+    # Assert the result is as expected
+    assert res_map == exp_map
+    assert res_maptyp == exp_maptyp
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/test_kind.py b/venv/lib/python3.12/site-packages/numpy/f2py/tests/test_kind.py
new file mode 100644
index 00000000..c8cc57ff
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/tests/test_kind.py
@@ -0,0 +1,50 @@
+import sys
+import os
+import pytest
+import platform
+
+from numpy.f2py.crackfortran import (
+    _selected_int_kind_func as selected_int_kind,
+    _selected_real_kind_func as selected_real_kind,
+)
+from . import util
+
+
+class TestKind(util.F2PyTest):
+    sources = [util.getpath("tests", "src", "kind", "foo.f90")]
+
+    @pytest.mark.skipif(sys.maxsize < 2 ** 31 + 1,
+                        reason="Fails for 32 bit machines")
+    def test_int(self):
+        """Test `int` kind_func for integers up to 10**40."""
+        selectedintkind = self.module.selectedintkind
+
+        for i in range(40):
+            assert selectedintkind(i) == selected_int_kind(
+                i
+            ), f"selectedintkind({i}): expected {selected_int_kind(i)!r} but got {selectedintkind(i)!r}"
+
+    def test_real(self):
+        """
+        Test (processor-dependent) `real` kind_func for real numbers
+        of up to 31 digits precision (extended/quadruple).
+        """
+        selectedrealkind = self.module.selectedrealkind
+
+        for i in range(32):
+            assert selectedrealkind(i) == selected_real_kind(
+                i
+            ), f"selectedrealkind({i}): expected {selected_real_kind(i)!r} but got {selectedrealkind(i)!r}"
+
+    @pytest.mark.xfail(platform.machine().lower().startswith("ppc"),
+                       reason="Some PowerPC may not support full IEEE 754 precision")
+    def test_quad_precision(self):
+        """
+        Test kind_func for quadruple precision [`real(16)`] of 32+ digits .
+        """
+        selectedrealkind = self.module.selectedrealkind
+
+        for i in range(32, 40):
+            assert selectedrealkind(i) == selected_real_kind(
+                i
+            ), f"selectedrealkind({i}): expected {selected_real_kind(i)!r} but got {selectedrealkind(i)!r}"
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/test_mixed.py b/venv/lib/python3.12/site-packages/numpy/f2py/tests/test_mixed.py
new file mode 100644
index 00000000..49d0ba20
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/tests/test_mixed.py
@@ -0,0 +1,34 @@
+import os
+import textwrap
+import pytest
+
+from numpy.testing import IS_PYPY
+from . import util
+
+
+class TestMixed(util.F2PyTest):
+    sources = [
+        util.getpath("tests", "src", "mixed", "foo.f"),
+        util.getpath("tests", "src", "mixed", "foo_fixed.f90"),
+        util.getpath("tests", "src", "mixed", "foo_free.f90"),
+    ]
+
+    @pytest.mark.slow
+    def test_all(self):
+        assert self.module.bar11() == 11
+        assert self.module.foo_fixed.bar12() == 12
+        assert self.module.foo_free.bar13() == 13
+
+    @pytest.mark.xfail(IS_PYPY,
+                       reason="PyPy cannot modify tp_doc after PyType_Ready")
+    def test_docstring(self):
+        expected = textwrap.dedent("""\
+        a = bar11()
+
+        Wrapper for ``bar11``.
+
+        Returns
+        -------
+        a : int
+        """)
+        assert self.module.bar11.__doc__ == expected
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/test_modules.py b/venv/lib/python3.12/site-packages/numpy/f2py/tests/test_modules.py
new file mode 100644
index 00000000..436e0c70
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/tests/test_modules.py
@@ -0,0 +1,81 @@
+import pytest
+import textwrap
+
+from . import util
+from numpy.testing import IS_PYPY
+
+
+@pytest.mark.slow
+class TestModuleFilterPublicEntities(util.F2PyTest):
+    sources = [
+        util.getpath(
+            "tests", "src", "modules", "gh26920",
+            "two_mods_with_one_public_routine.f90"
+        )
+    ]
+    # we filter the only public function mod2
+    only = ["mod1_func1", ]
+
+    def test_gh26920(self):
+        # if it compiles and can be loaded, things are fine
+        pass
+
+
+@pytest.mark.slow
+class TestModuleWithoutPublicEntities(util.F2PyTest):
+    sources = [
+        util.getpath(
+            "tests", "src", "modules", "gh26920",
+            "two_mods_with_no_public_entities.f90"
+        )
+    ]
+    only = ["mod1_func1", ]
+
+    def test_gh26920(self):
+        # if it compiles and can be loaded, things are fine
+        pass
+
+
+@pytest.mark.slow
+class TestModuleDocString(util.F2PyTest):
+    sources = [util.getpath("tests", "src", "modules", "module_data_docstring.f90")]
+
+    @pytest.mark.xfail(IS_PYPY, reason="PyPy cannot modify tp_doc after PyType_Ready")
+    def test_module_docstring(self):
+        assert self.module.mod.__doc__ == textwrap.dedent(
+            """\
+                     i : 'i'-scalar
+                     x : 'i'-array(4)
+                     a : 'f'-array(2,3)
+                     b : 'f'-array(-1,-1), not allocated\x00
+                     foo()\n
+                     Wrapper for ``foo``.\n\n"""
+        )
+
+
+@pytest.mark.slow
+class TestModuleAndSubroutine(util.F2PyTest):
+    module_name = "example"
+    sources = [
+        util.getpath("tests", "src", "modules", "gh25337", "data.f90"),
+        util.getpath("tests", "src", "modules", "gh25337", "use_data.f90"),
+    ]
+
+    def test_gh25337(self):
+        self.module.data.set_shift(3)
+        assert "data" in dir(self.module)
+
+
+@pytest.mark.slow
+class TestUsedModule(util.F2PyTest):
+    module_name = "fmath"
+    sources = [
+        util.getpath("tests", "src", "modules", "use_modules.f90"),
+    ]
+
+    def test_gh25867(self):
+        compiled_mods = [x for x in dir(self.module) if "__" not in x]
+        assert "useops" in compiled_mods
+        assert self.module.useops.sum_and_double(3, 7) == 20
+        assert "mathops" in compiled_mods
+        assert self.module.mathops.add(3, 7) == 10
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/test_parameter.py b/venv/lib/python3.12/site-packages/numpy/f2py/tests/test_parameter.py
new file mode 100644
index 00000000..9c83af17
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/tests/test_parameter.py
@@ -0,0 +1,131 @@
+import os
+import pytest
+
+import numpy as np
+
+from . import util
+
+
+class TestParameters(util.F2PyTest):
+    # Check that intent(in out) translates as intent(inout)
+    sources = [
+        util.getpath("tests", "src", "parameter", "constant_real.f90"),
+        util.getpath("tests", "src", "parameter", "constant_integer.f90"),
+        util.getpath("tests", "src", "parameter", "constant_both.f90"),
+        util.getpath("tests", "src", "parameter", "constant_compound.f90"),
+        util.getpath("tests", "src", "parameter", "constant_non_compound.f90"),
+        util.getpath("tests", "src", "parameter", "constant_array.f90"),
+    ]
+
+    @pytest.mark.slow
+    def test_constant_real_single(self):
+        # non-contiguous should raise error
+        x = np.arange(6, dtype=np.float32)[::2]
+        pytest.raises(ValueError, self.module.foo_single, x)
+
+        # check values with contiguous array
+        x = np.arange(3, dtype=np.float32)
+        self.module.foo_single(x)
+        assert np.allclose(x, [0 + 1 + 2 * 3, 1, 2])
+
+    @pytest.mark.slow
+    def test_constant_real_double(self):
+        # non-contiguous should raise error
+        x = np.arange(6, dtype=np.float64)[::2]
+        pytest.raises(ValueError, self.module.foo_double, x)
+
+        # check values with contiguous array
+        x = np.arange(3, dtype=np.float64)
+        self.module.foo_double(x)
+        assert np.allclose(x, [0 + 1 + 2 * 3, 1, 2])
+
+    @pytest.mark.slow
+    def test_constant_compound_int(self):
+        # non-contiguous should raise error
+        x = np.arange(6, dtype=np.int32)[::2]
+        pytest.raises(ValueError, self.module.foo_compound_int, x)
+
+        # check values with contiguous array
+        x = np.arange(3, dtype=np.int32)
+        self.module.foo_compound_int(x)
+        assert np.allclose(x, [0 + 1 + 2 * 6, 1, 2])
+
+    @pytest.mark.slow
+    def test_constant_non_compound_int(self):
+        # check values
+        x = np.arange(4, dtype=np.int32)
+        self.module.foo_non_compound_int(x)
+        assert np.allclose(x, [0 + 1 + 2 + 3 * 4, 1, 2, 3])
+
+    @pytest.mark.slow
+    def test_constant_integer_int(self):
+        # non-contiguous should raise error
+        x = np.arange(6, dtype=np.int32)[::2]
+        pytest.raises(ValueError, self.module.foo_int, x)
+
+        # check values with contiguous array
+        x = np.arange(3, dtype=np.int32)
+        self.module.foo_int(x)
+        assert np.allclose(x, [0 + 1 + 2 * 3, 1, 2])
+
+    @pytest.mark.slow
+    def test_constant_integer_long(self):
+        # non-contiguous should raise error
+        x = np.arange(6, dtype=np.int64)[::2]
+        pytest.raises(ValueError, self.module.foo_long, x)
+
+        # check values with contiguous array
+        x = np.arange(3, dtype=np.int64)
+        self.module.foo_long(x)
+        assert np.allclose(x, [0 + 1 + 2 * 3, 1, 2])
+
+    @pytest.mark.slow
+    def test_constant_both(self):
+        # non-contiguous should raise error
+        x = np.arange(6, dtype=np.float64)[::2]
+        pytest.raises(ValueError, self.module.foo, x)
+
+        # check values with contiguous array
+        x = np.arange(3, dtype=np.float64)
+        self.module.foo(x)
+        assert np.allclose(x, [0 + 1 * 3 * 3 + 2 * 3 * 3, 1 * 3, 2 * 3])
+
+    @pytest.mark.slow
+    def test_constant_no(self):
+        # non-contiguous should raise error
+        x = np.arange(6, dtype=np.float64)[::2]
+        pytest.raises(ValueError, self.module.foo_no, x)
+
+        # check values with contiguous array
+        x = np.arange(3, dtype=np.float64)
+        self.module.foo_no(x)
+        assert np.allclose(x, [0 + 1 * 3 * 3 + 2 * 3 * 3, 1 * 3, 2 * 3])
+
+    @pytest.mark.slow
+    def test_constant_sum(self):
+        # non-contiguous should raise error
+        x = np.arange(6, dtype=np.float64)[::2]
+        pytest.raises(ValueError, self.module.foo_sum, x)
+
+        # check values with contiguous array
+        x = np.arange(3, dtype=np.float64)
+        self.module.foo_sum(x)
+        assert np.allclose(x, [0 + 1 * 3 * 3 + 2 * 3 * 3, 1 * 3, 2 * 3])
+
+    def test_constant_array(self):
+        x = np.arange(3, dtype=np.float64)
+        y = np.arange(5, dtype=np.float64)
+        z = self.module.foo_array(x, y)
+        assert np.allclose(x, [0.0, 1./10, 2./10])
+        assert np.allclose(y, [0.0, 1.*10, 2.*10, 3.*10, 4.*10])
+        assert np.allclose(z, 19.0)
+
+    def test_constant_array_any_index(self):
+        x = np.arange(6, dtype=np.float64)
+        y = self.module.foo_array_any_index(x)
+        assert np.allclose(y, x.reshape((2, 3), order='F'))
+
+    def test_constant_array_delims(self):
+        x = self.module.foo_array_delims()
+        assert x == 9
+
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/test_pyf_src.py b/venv/lib/python3.12/site-packages/numpy/f2py/tests/test_pyf_src.py
new file mode 100644
index 00000000..f77ded2f
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/tests/test_pyf_src.py
@@ -0,0 +1,44 @@
+# This test is ported from numpy.distutils
+from numpy.f2py._src_pyf import process_str
+from numpy.testing import assert_equal
+
+
+pyf_src = """
+python module foo
+    <_rd=real,double precision>
+    interface
+        subroutine foosub(tol)
+            <_rd>, intent(in,out) :: tol
+        end subroutine foosub
+    end interface
+end python module foo
+"""
+
+expected_pyf = """
+python module foo
+    interface
+        subroutine sfoosub(tol)
+            real, intent(in,out) :: tol
+        end subroutine sfoosub
+        subroutine dfoosub(tol)
+            double precision, intent(in,out) :: tol
+        end subroutine dfoosub
+    end interface
+end python module foo
+"""
+
+
+def normalize_whitespace(s):
+    """
+    Remove leading and trailing whitespace, and convert internal
+    stretches of whitespace to a single space.
+    """
+    return ' '.join(s.split())
+
+
+def test_from_template():
+    """Regression test for gh-10712."""
+    pyf = process_str(pyf_src)
+    normalized_pyf = normalize_whitespace(pyf)
+    normalized_expected_pyf = normalize_whitespace(expected_pyf)
+    assert_equal(normalized_pyf, normalized_expected_pyf)
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/test_quoted_character.py b/venv/lib/python3.12/site-packages/numpy/f2py/tests/test_quoted_character.py
new file mode 100644
index 00000000..85e83a78
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/tests/test_quoted_character.py
@@ -0,0 +1,17 @@
+"""See https://github.com/numpy/numpy/pull/10676.
+
+"""
+import sys
+import pytest
+
+from . import util
+
+
+class TestQuotedCharacter(util.F2PyTest):
+    sources = [util.getpath("tests", "src", "quoted_character", "foo.f")]
+
+    @pytest.mark.skipif(sys.platform == "win32",
+                        reason="Fails with MinGW64 Gfortran (Issue #9673)")
+    @pytest.mark.slow
+    def test_quoted_character(self):
+        assert self.module.foo() == (b"'", b'"', b";", b"!", b"(", b")")
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/test_regression.py b/venv/lib/python3.12/site-packages/numpy/f2py/tests/test_regression.py
new file mode 100644
index 00000000..e11ed1a0
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/tests/test_regression.py
@@ -0,0 +1,141 @@
+import os
+import pytest
+import platform
+
+import numpy as np
+import numpy.testing as npt
+
+from . import util
+
+
+class TestIntentInOut(util.F2PyTest):
+    # Check that intent(in out) translates as intent(inout)
+    sources = [util.getpath("tests", "src", "regression", "inout.f90")]
+
+    @pytest.mark.slow
+    def test_inout(self):
+        # non-contiguous should raise error
+        x = np.arange(6, dtype=np.float32)[::2]
+        pytest.raises(ValueError, self.module.foo, x)
+
+        # check values with contiguous array
+        x = np.arange(3, dtype=np.float32)
+        self.module.foo(x)
+        assert np.allclose(x, [3, 1, 2])
+
+
+class TestNegativeBounds(util.F2PyTest):
+    # Check that negative bounds work correctly
+    sources = [util.getpath("tests", "src", "negative_bounds", "issue_20853.f90")]
+
+    @pytest.mark.slow
+    def test_negbound(self):
+        xvec = np.arange(12)
+        xlow = -6
+        xhigh = 4
+        # Calculate the upper bound,
+        # Keeping the 1 index in mind
+        def ubound(xl, xh):
+            return xh - xl + 1
+        rval = self.module.foo(is_=xlow, ie_=xhigh,
+                        arr=xvec[:ubound(xlow, xhigh)])
+        expval = np.arange(11, dtype = np.float32)
+        assert np.allclose(rval, expval)
+
+
+class TestNumpyVersionAttribute(util.F2PyTest):
+    # Check that th attribute __f2py_numpy_version__ is present
+    # in the compiled module and that has the value np.__version__.
+    sources = [util.getpath("tests", "src", "regression", "inout.f90")]
+
+    @pytest.mark.slow
+    def test_numpy_version_attribute(self):
+
+        # Check that self.module has an attribute named "__f2py_numpy_version__"
+        assert hasattr(self.module, "__f2py_numpy_version__")
+
+        # Check that the attribute __f2py_numpy_version__ is a string
+        assert isinstance(self.module.__f2py_numpy_version__, str)
+
+        # Check that __f2py_numpy_version__ has the value numpy.__version__
+        assert np.__version__ == self.module.__f2py_numpy_version__
+
+
+def test_include_path():
+    incdir = np.f2py.get_include()
+    fnames_in_dir = os.listdir(incdir)
+    for fname in ("fortranobject.c", "fortranobject.h"):
+        assert fname in fnames_in_dir
+
+
+class TestIncludeFiles(util.F2PyTest):
+    sources = [util.getpath("tests", "src", "regression", "incfile.f90")]
+    options = [f"-I{util.getpath('tests', 'src', 'regression')}",
+               f"--include-paths {util.getpath('tests', 'src', 'regression')}"]
+
+    @pytest.mark.slow
+    def test_gh25344(self):
+        exp = 7.0
+        res = self.module.add(3.0, 4.0)
+        assert  exp == res
+
+class TestF77Comments(util.F2PyTest):
+    # Check that comments are stripped from F77 continuation lines
+    sources = [util.getpath("tests", "src", "regression", "f77comments.f")]
+
+    @pytest.mark.slow
+    def test_gh26148(self):
+        x1 = np.array(3, dtype=np.int32)
+        x2 = np.array(5, dtype=np.int32)
+        res=self.module.testsub(x1, x2)
+        assert(res[0] == 8)
+        assert(res[1] == 15)
+
+    @pytest.mark.slow
+    def test_gh26466(self):
+        # Check that comments after PARAMETER directions are stripped
+        expected = np.arange(1, 11, dtype=np.float32)*2
+        res=self.module.testsub2()
+        npt.assert_allclose(expected, res)
+
+class TestF90Contiuation(util.F2PyTest):
+    # Check that comments are stripped from F90 continuation lines
+    sources = [util.getpath("tests", "src", "regression", "f90continuation.f90")]
+
+    @pytest.mark.slow
+    def test_gh26148b(self):
+        x1 = np.array(3, dtype=np.int32)
+        x2 = np.array(5, dtype=np.int32)
+        res=self.module.testsub(x1, x2)
+        assert(res[0] == 8)
+        assert(res[1] == 15)
+
+@pytest.mark.slow
+def test_gh26623():
+    # Including libraries with . should not generate an incorrect meson.build
+    try:
+        aa = util.build_module(
+            [util.getpath("tests", "src", "regression", "f90continuation.f90")],
+            ["-lfoo.bar"],
+            module_name="Blah",
+        )
+    except RuntimeError as rerr:
+        assert "lparen got assign" not in str(rerr)
+
+
+@pytest.mark.slow
+@pytest.mark.skipif(platform.system() not in ['Linux', 'Darwin'], reason='Unsupported on this platform for now')
+def test_gh25784():
+    # Compile dubious file using passed flags
+    try:
+        aa = util.build_module(
+            [util.getpath("tests", "src", "regression", "f77fixedform.f95")],
+            options=[
+                # Meson will collect and dedup these to pass to fortran_args:
+                "--f77flags='-ffixed-form -O2'",
+                "--f90flags=\"-ffixed-form -Og\"",
+            ],
+            module_name="Blah",
+        )
+    except ImportError as rerr:
+        assert "unknown_subroutine_" in str(rerr)
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/test_return_character.py b/venv/lib/python3.12/site-packages/numpy/f2py/tests/test_return_character.py
new file mode 100644
index 00000000..078d445a
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/tests/test_return_character.py
@@ -0,0 +1,46 @@
+import pytest
+
+from numpy import array
+from . import util
+import platform
+
+IS_S390X = platform.machine() == "s390x"
+
+
+@pytest.mark.slow
+class TestReturnCharacter(util.F2PyTest):
+    def check_function(self, t, tname):
+        if tname in ["t0", "t1", "s0", "s1"]:
+            assert t("23") == b"2"
+            r = t("ab")
+            assert r == b"a"
+            r = t(array("ab"))
+            assert r == b"a"
+            r = t(array(77, "u1"))
+            assert r == b"M"
+        elif tname in ["ts", "ss"]:
+            assert t(23) == b"23"
+            assert t("123456789abcdef") == b"123456789a"
+        elif tname in ["t5", "s5"]:
+            assert t(23) == b"23"
+            assert t("ab") == b"ab"
+            assert t("123456789abcdef") == b"12345"
+        else:
+            raise NotImplementedError
+
+
+class TestFReturnCharacter(TestReturnCharacter):
+    sources = [
+        util.getpath("tests", "src", "return_character", "foo77.f"),
+        util.getpath("tests", "src", "return_character", "foo90.f90"),
+    ]
+
+    @pytest.mark.xfail(IS_S390X, reason="callback returns ' '")
+    @pytest.mark.parametrize("name", "t0,t1,t5,s0,s1,s5,ss".split(","))
+    def test_all_f77(self, name):
+        self.check_function(getattr(self.module, name), name)
+
+    @pytest.mark.xfail(IS_S390X, reason="callback returns ' '")
+    @pytest.mark.parametrize("name", "t0,t1,t5,ts,s0,s1,s5,ss".split(","))
+    def test_all_f90(self, name):
+        self.check_function(getattr(self.module.f90_return_char, name), name)
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/test_return_complex.py b/venv/lib/python3.12/site-packages/numpy/f2py/tests/test_return_complex.py
new file mode 100644
index 00000000..17811f5d
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/tests/test_return_complex.py
@@ -0,0 +1,66 @@
+import pytest
+
+from numpy import array
+from . import util
+
+
+@pytest.mark.slow
+class TestReturnComplex(util.F2PyTest):
+    def check_function(self, t, tname):
+        if tname in ["t0", "t8", "s0", "s8"]:
+            err = 1e-5
+        else:
+            err = 0.0
+        assert abs(t(234j) - 234.0j) <= err
+        assert abs(t(234.6) - 234.6) <= err
+        assert abs(t(234) - 234.0) <= err
+        assert abs(t(234.6 + 3j) - (234.6 + 3j)) <= err
+        # assert abs(t('234')-234.)<=err
+        # assert abs(t('234.6')-234.6)<=err
+        assert abs(t(-234) + 234.0) <= err
+        assert abs(t([234]) - 234.0) <= err
+        assert abs(t((234, )) - 234.0) <= err
+        assert abs(t(array(234)) - 234.0) <= err
+        assert abs(t(array(23 + 4j, "F")) - (23 + 4j)) <= err
+        assert abs(t(array([234])) - 234.0) <= err
+        assert abs(t(array([[234]])) - 234.0) <= err
+        assert abs(t(array([234]).astype("b")) + 22.0) <= err
+        assert abs(t(array([234], "h")) - 234.0) <= err
+        assert abs(t(array([234], "i")) - 234.0) <= err
+        assert abs(t(array([234], "l")) - 234.0) <= err
+        assert abs(t(array([234], "q")) - 234.0) <= err
+        assert abs(t(array([234], "f")) - 234.0) <= err
+        assert abs(t(array([234], "d")) - 234.0) <= err
+        assert abs(t(array([234 + 3j], "F")) - (234 + 3j)) <= err
+        assert abs(t(array([234], "D")) - 234.0) <= err
+
+        # pytest.raises(TypeError, t, array([234], 'S1'))
+        pytest.raises(TypeError, t, "abc")
+
+        pytest.raises(IndexError, t, [])
+        pytest.raises(IndexError, t, ())
+
+        pytest.raises(TypeError, t, t)
+        pytest.raises(TypeError, t, {})
+
+        try:
+            r = t(10**400)
+            assert repr(r) in ["(inf+0j)", "(Infinity+0j)"]
+        except OverflowError:
+            pass
+
+
+class TestFReturnComplex(TestReturnComplex):
+    sources = [
+        util.getpath("tests", "src", "return_complex", "foo77.f"),
+        util.getpath("tests", "src", "return_complex", "foo90.f90"),
+    ]
+
+    @pytest.mark.parametrize("name", "t0,t8,t16,td,s0,s8,s16,sd".split(","))
+    def test_all_f77(self, name):
+        self.check_function(getattr(self.module, name), name)
+
+    @pytest.mark.parametrize("name", "t0,t8,t16,td,s0,s8,s16,sd".split(","))
+    def test_all_f90(self, name):
+        self.check_function(getattr(self.module.f90_return_complex, name),
+                            name)
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/test_return_integer.py b/venv/lib/python3.12/site-packages/numpy/f2py/tests/test_return_integer.py
new file mode 100644
index 00000000..428afec4
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/tests/test_return_integer.py
@@ -0,0 +1,54 @@
+import pytest
+
+from numpy import array
+from . import util
+
+
+@pytest.mark.slow
+class TestReturnInteger(util.F2PyTest):
+    def check_function(self, t, tname):
+        assert t(123) == 123
+        assert t(123.6) == 123
+        assert t("123") == 123
+        assert t(-123) == -123
+        assert t([123]) == 123
+        assert t((123, )) == 123
+        assert t(array(123)) == 123
+        assert t(array(123, "b")) == 123
+        assert t(array(123, "h")) == 123
+        assert t(array(123, "i")) == 123
+        assert t(array(123, "l")) == 123
+        assert t(array(123, "B")) == 123
+        assert t(array(123, "f")) == 123
+        assert t(array(123, "d")) == 123
+
+        # pytest.raises(ValueError, t, array([123],'S3'))
+        pytest.raises(ValueError, t, "abc")
+
+        pytest.raises(IndexError, t, [])
+        pytest.raises(IndexError, t, ())
+
+        pytest.raises(Exception, t, t)
+        pytest.raises(Exception, t, {})
+
+        if tname in ["t8", "s8"]:
+            pytest.raises(OverflowError, t, 100000000000000000000000)
+            pytest.raises(OverflowError, t, 10000000011111111111111.23)
+
+
+class TestFReturnInteger(TestReturnInteger):
+    sources = [
+        util.getpath("tests", "src", "return_integer", "foo77.f"),
+        util.getpath("tests", "src", "return_integer", "foo90.f90"),
+    ]
+
+    @pytest.mark.parametrize("name",
+                             "t0,t1,t2,t4,t8,s0,s1,s2,s4,s8".split(","))
+    def test_all_f77(self, name):
+        self.check_function(getattr(self.module, name), name)
+
+    @pytest.mark.parametrize("name",
+                             "t0,t1,t2,t4,t8,s0,s1,s2,s4,s8".split(","))
+    def test_all_f90(self, name):
+        self.check_function(getattr(self.module.f90_return_integer, name),
+                            name)
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/test_return_logical.py b/venv/lib/python3.12/site-packages/numpy/f2py/tests/test_return_logical.py
new file mode 100644
index 00000000..92fb902a
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/tests/test_return_logical.py
@@ -0,0 +1,64 @@
+import pytest
+
+from numpy import array
+from . import util
+
+
+class TestReturnLogical(util.F2PyTest):
+    def check_function(self, t):
+        assert t(True) == 1
+        assert t(False) == 0
+        assert t(0) == 0
+        assert t(None) == 0
+        assert t(0.0) == 0
+        assert t(0j) == 0
+        assert t(1j) == 1
+        assert t(234) == 1
+        assert t(234.6) == 1
+        assert t(234.6 + 3j) == 1
+        assert t("234") == 1
+        assert t("aaa") == 1
+        assert t("") == 0
+        assert t([]) == 0
+        assert t(()) == 0
+        assert t({}) == 0
+        assert t(t) == 1
+        assert t(-234) == 1
+        assert t(10**100) == 1
+        assert t([234]) == 1
+        assert t((234, )) == 1
+        assert t(array(234)) == 1
+        assert t(array([234])) == 1
+        assert t(array([[234]])) == 1
+        assert t(array([127], "b")) == 1
+        assert t(array([234], "h")) == 1
+        assert t(array([234], "i")) == 1
+        assert t(array([234], "l")) == 1
+        assert t(array([234], "f")) == 1
+        assert t(array([234], "d")) == 1
+        assert t(array([234 + 3j], "F")) == 1
+        assert t(array([234], "D")) == 1
+        assert t(array(0)) == 0
+        assert t(array([0])) == 0
+        assert t(array([[0]])) == 0
+        assert t(array([0j])) == 0
+        assert t(array([1])) == 1
+        pytest.raises(ValueError, t, array([0, 0]))
+
+
+class TestFReturnLogical(TestReturnLogical):
+    sources = [
+        util.getpath("tests", "src", "return_logical", "foo77.f"),
+        util.getpath("tests", "src", "return_logical", "foo90.f90"),
+    ]
+
+    @pytest.mark.slow
+    @pytest.mark.parametrize("name", "t0,t1,t2,t4,s0,s1,s2,s4".split(","))
+    def test_all_f77(self, name):
+        self.check_function(getattr(self.module, name))
+
+    @pytest.mark.slow
+    @pytest.mark.parametrize("name",
+                             "t0,t1,t2,t4,t8,s0,s1,s2,s4,s8".split(","))
+    def test_all_f90(self, name):
+        self.check_function(getattr(self.module.f90_return_logical, name))
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/test_return_real.py b/venv/lib/python3.12/site-packages/numpy/f2py/tests/test_return_real.py
new file mode 100644
index 00000000..d9b316dc
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/tests/test_return_real.py
@@ -0,0 +1,108 @@
+import platform
+import pytest
+import numpy as np
+
+from numpy import array
+from . import util
+
+
+@pytest.mark.slow
+class TestReturnReal(util.F2PyTest):
+    def check_function(self, t, tname):
+        if tname in ["t0", "t4", "s0", "s4"]:
+            err = 1e-5
+        else:
+            err = 0.0
+        assert abs(t(234) - 234.0) <= err
+        assert abs(t(234.6) - 234.6) <= err
+        assert abs(t("234") - 234) <= err
+        assert abs(t("234.6") - 234.6) <= err
+        assert abs(t(-234) + 234) <= err
+        assert abs(t([234]) - 234) <= err
+        assert abs(t((234, )) - 234.0) <= err
+        assert abs(t(array(234)) - 234.0) <= err
+        assert abs(t(array(234).astype("b")) + 22) <= err
+        assert abs(t(array(234, "h")) - 234.0) <= err
+        assert abs(t(array(234, "i")) - 234.0) <= err
+        assert abs(t(array(234, "l")) - 234.0) <= err
+        assert abs(t(array(234, "B")) - 234.0) <= err
+        assert abs(t(array(234, "f")) - 234.0) <= err
+        assert abs(t(array(234, "d")) - 234.0) <= err
+        if tname in ["t0", "t4", "s0", "s4"]:
+            assert t(1e200) == t(1e300)  # inf
+
+        # pytest.raises(ValueError, t, array([234], 'S1'))
+        pytest.raises(ValueError, t, "abc")
+
+        pytest.raises(IndexError, t, [])
+        pytest.raises(IndexError, t, ())
+
+        pytest.raises(Exception, t, t)
+        pytest.raises(Exception, t, {})
+
+        try:
+            r = t(10**400)
+            assert repr(r) in ["inf", "Infinity"]
+        except OverflowError:
+            pass
+
+
+@pytest.mark.skipif(
+    platform.system() == "Darwin",
+    reason="Prone to error when run with numpy/f2py/tests on mac os, "
+    "but not when run in isolation",
+)
+@pytest.mark.skipif(
+    np.dtype(np.intp).itemsize < 8,
+    reason="32-bit builds are buggy"
+)
+class TestCReturnReal(TestReturnReal):
+    suffix = ".pyf"
+    module_name = "c_ext_return_real"
+    code = """
+python module c_ext_return_real
+usercode \'\'\'
+float t4(float value) { return value; }
+void s4(float *t4, float value) { *t4 = value; }
+double t8(double value) { return value; }
+void s8(double *t8, double value) { *t8 = value; }
+\'\'\'
+interface
+  function t4(value)
+    real*4 intent(c) :: t4,value
+  end
+  function t8(value)
+    real*8 intent(c) :: t8,value
+  end
+  subroutine s4(t4,value)
+    intent(c) s4
+    real*4 intent(out) :: t4
+    real*4 intent(c) :: value
+  end
+  subroutine s8(t8,value)
+    intent(c) s8
+    real*8 intent(out) :: t8
+    real*8 intent(c) :: value
+  end
+end interface
+end python module c_ext_return_real
+    """
+
+    @pytest.mark.parametrize("name", "t4,t8,s4,s8".split(","))
+    def test_all(self, name):
+        self.check_function(getattr(self.module, name), name)
+
+
+class TestFReturnReal(TestReturnReal):
+    sources = [
+        util.getpath("tests", "src", "return_real", "foo77.f"),
+        util.getpath("tests", "src", "return_real", "foo90.f90"),
+    ]
+
+    @pytest.mark.parametrize("name", "t0,t4,t8,td,s0,s4,s8,sd".split(","))
+    def test_all_f77(self, name):
+        self.check_function(getattr(self.module, name), name)
+
+    @pytest.mark.parametrize("name", "t0,t4,t8,td,s0,s4,s8,sd".split(","))
+    def test_all_f90(self, name):
+        self.check_function(getattr(self.module.f90_return_real, name), name)
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/test_semicolon_split.py b/venv/lib/python3.12/site-packages/numpy/f2py/tests/test_semicolon_split.py
new file mode 100644
index 00000000..ab9c093d
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/tests/test_semicolon_split.py
@@ -0,0 +1,75 @@
+import platform
+import pytest
+import numpy as np
+
+from . import util
+
+
+@pytest.mark.skipif(
+    platform.system() == "Darwin",
+    reason="Prone to error when run with numpy/f2py/tests on mac os, "
+    "but not when run in isolation",
+)
+@pytest.mark.skipif(
+    np.dtype(np.intp).itemsize < 8,
+    reason="32-bit builds are buggy"
+)
+class TestMultiline(util.F2PyTest):
+    suffix = ".pyf"
+    module_name = "multiline"
+    code = f"""
+python module {module_name}
+    usercode '''
+void foo(int* x) {{
+    char dummy = ';';
+    *x = 42;
+}}
+'''
+    interface
+        subroutine foo(x)
+            intent(c) foo
+            integer intent(out) :: x
+        end subroutine foo
+    end interface
+end python module {module_name}
+    """
+
+    def test_multiline(self):
+        assert self.module.foo() == 42
+
+
+@pytest.mark.skipif(
+    platform.system() == "Darwin",
+    reason="Prone to error when run with numpy/f2py/tests on mac os, "
+    "but not when run in isolation",
+)
+@pytest.mark.skipif(
+    np.dtype(np.intp).itemsize < 8,
+    reason="32-bit builds are buggy"
+)
+@pytest.mark.slow
+class TestCallstatement(util.F2PyTest):
+    suffix = ".pyf"
+    module_name = "callstatement"
+    code = f"""
+python module {module_name}
+    usercode '''
+void foo(int* x) {{
+}}
+'''
+    interface
+        subroutine foo(x)
+            intent(c) foo
+            integer intent(out) :: x
+            callprotoargument int*
+            callstatement {{ &
+                ; &
+                x = 42; &
+            }}
+        end subroutine foo
+    end interface
+end python module {module_name}
+    """
+
+    def test_callstatement(self):
+        assert self.module.foo() == 42
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/test_size.py b/venv/lib/python3.12/site-packages/numpy/f2py/tests/test_size.py
new file mode 100644
index 00000000..bd2c349d
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/tests/test_size.py
@@ -0,0 +1,45 @@
+import os
+import pytest
+import numpy as np
+
+from . import util
+
+
+class TestSizeSumExample(util.F2PyTest):
+    sources = [util.getpath("tests", "src", "size", "foo.f90")]
+
+    @pytest.mark.slow
+    def test_all(self):
+        r = self.module.foo([[]])
+        assert r == [0]
+
+        r = self.module.foo([[1, 2]])
+        assert r == [3]
+
+        r = self.module.foo([[1, 2], [3, 4]])
+        assert np.allclose(r, [3, 7])
+
+        r = self.module.foo([[1, 2], [3, 4], [5, 6]])
+        assert np.allclose(r, [3, 7, 11])
+
+    @pytest.mark.slow
+    def test_transpose(self):
+        r = self.module.trans([[]])
+        assert np.allclose(r.T, np.array([[]]))
+
+        r = self.module.trans([[1, 2]])
+        assert np.allclose(r, [[1.], [2.]])
+
+        r = self.module.trans([[1, 2, 3], [4, 5, 6]])
+        assert np.allclose(r, [[1, 4], [2, 5], [3, 6]])
+
+    @pytest.mark.slow
+    def test_flatten(self):
+        r = self.module.flatten([[]])
+        assert np.allclose(r, [])
+
+        r = self.module.flatten([[1, 2]])
+        assert np.allclose(r, [1, 2])
+
+        r = self.module.flatten([[1, 2, 3], [4, 5, 6]])
+        assert np.allclose(r, [1, 2, 3, 4, 5, 6])
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/test_string.py b/venv/lib/python3.12/site-packages/numpy/f2py/tests/test_string.py
new file mode 100644
index 00000000..9e937188
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/tests/test_string.py
@@ -0,0 +1,100 @@
+import os
+import pytest
+import textwrap
+import numpy as np
+from . import util
+
+
+class TestString(util.F2PyTest):
+    sources = [util.getpath("tests", "src", "string", "char.f90")]
+
+    @pytest.mark.slow
+    def test_char(self):
+        strings = np.array(["ab", "cd", "ef"], dtype="c").T
+        inp, out = self.module.char_test.change_strings(
+            strings, strings.shape[1])
+        assert inp == pytest.approx(strings)
+        expected = strings.copy()
+        expected[1, :] = "AAA"
+        assert out == pytest.approx(expected)
+
+
+class TestDocStringArguments(util.F2PyTest):
+    sources = [util.getpath("tests", "src", "string", "string.f")]
+
+    def test_example(self):
+        a = np.array(b"123\0\0")
+        b = np.array(b"123\0\0")
+        c = np.array(b"123")
+        d = np.array(b"123")
+
+        self.module.foo(a, b, c, d)
+
+        assert a.tobytes() == b"123\0\0"
+        assert b.tobytes() == b"B23\0\0"
+        assert c.tobytes() == b"123"
+        assert d.tobytes() == b"D23"
+
+
+class TestFixedString(util.F2PyTest):
+    sources = [util.getpath("tests", "src", "string", "fixed_string.f90")]
+
+    @staticmethod
+    def _sint(s, start=0, end=None):
+        """Return the content of a string buffer as integer value.
+
+        For example:
+          _sint('1234') -> 4321
+          _sint('123A') -> 17321
+        """
+        if isinstance(s, np.ndarray):
+            s = s.tobytes()
+        elif isinstance(s, str):
+            s = s.encode()
+        assert isinstance(s, bytes)
+        if end is None:
+            end = len(s)
+        i = 0
+        for j in range(start, min(end, len(s))):
+            i += s[j] * 10**j
+        return i
+
+    def _get_input(self, intent="in"):
+        if intent in ["in"]:
+            yield ""
+            yield "1"
+            yield "1234"
+            yield "12345"
+            yield b""
+            yield b"\0"
+            yield b"1"
+            yield b"\01"
+            yield b"1\0"
+            yield b"1234"
+            yield b"12345"
+        yield np.ndarray((), np.bytes_, buffer=b"")  # array(b'', dtype='|S0')
+        yield np.array(b"")  # array(b'', dtype='|S1')
+        yield np.array(b"\0")
+        yield np.array(b"1")
+        yield np.array(b"1\0")
+        yield np.array(b"\01")
+        yield np.array(b"1234")
+        yield np.array(b"123\0")
+        yield np.array(b"12345")
+
+    def test_intent_in(self):
+        for s in self._get_input():
+            r = self.module.test_in_bytes4(s)
+            # also checks that s is not changed inplace
+            expected = self._sint(s, end=4)
+            assert r == expected, s
+
+    def test_intent_inout(self):
+        for s in self._get_input(intent="inout"):
+            rest = self._sint(s, start=4)
+            r = self.module.test_inout_bytes4(s)
+            expected = self._sint(s, end=4)
+            assert r == expected
+
+            # check that the rest of input string is preserved
+            assert rest == self._sint(s, start=4)
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/test_symbolic.py b/venv/lib/python3.12/site-packages/numpy/f2py/tests/test_symbolic.py
new file mode 100644
index 00000000..84527831
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/tests/test_symbolic.py
@@ -0,0 +1,494 @@
+import pytest
+
+from numpy.f2py.symbolic import (
+    Expr,
+    Op,
+    ArithOp,
+    Language,
+    as_symbol,
+    as_number,
+    as_string,
+    as_array,
+    as_complex,
+    as_terms,
+    as_factors,
+    eliminate_quotes,
+    insert_quotes,
+    fromstring,
+    as_expr,
+    as_apply,
+    as_numer_denom,
+    as_ternary,
+    as_ref,
+    as_deref,
+    normalize,
+    as_eq,
+    as_ne,
+    as_lt,
+    as_gt,
+    as_le,
+    as_ge,
+)
+from . import util
+
+
+class TestSymbolic(util.F2PyTest):
+    def test_eliminate_quotes(self):
+        def worker(s):
+            r, d = eliminate_quotes(s)
+            s1 = insert_quotes(r, d)
+            assert s1 == s
+
+        for kind in ["", "mykind_"]:
+            worker(kind + '"1234" // "ABCD"')
+            worker(kind + '"1234" // ' + kind + '"ABCD"')
+            worker(kind + "\"1234\" // 'ABCD'")
+            worker(kind + '"1234" // ' + kind + "'ABCD'")
+            worker(kind + '"1\\"2\'AB\'34"')
+            worker("a = " + kind + "'1\\'2\"AB\"34'")
+
+    def test_sanity(self):
+        x = as_symbol("x")
+        y = as_symbol("y")
+        z = as_symbol("z")
+
+        assert x.op == Op.SYMBOL
+        assert repr(x) == "Expr(Op.SYMBOL, 'x')"
+        assert x == x
+        assert x != y
+        assert hash(x) is not None
+
+        n = as_number(123)
+        m = as_number(456)
+        assert n.op == Op.INTEGER
+        assert repr(n) == "Expr(Op.INTEGER, (123, 4))"
+        assert n == n
+        assert n != m
+        assert hash(n) is not None
+
+        fn = as_number(12.3)
+        fm = as_number(45.6)
+        assert fn.op == Op.REAL
+        assert repr(fn) == "Expr(Op.REAL, (12.3, 4))"
+        assert fn == fn
+        assert fn != fm
+        assert hash(fn) is not None
+
+        c = as_complex(1, 2)
+        c2 = as_complex(3, 4)
+        assert c.op == Op.COMPLEX
+        assert repr(c) == ("Expr(Op.COMPLEX, (Expr(Op.INTEGER, (1, 4)),"
+                           " Expr(Op.INTEGER, (2, 4))))")
+        assert c == c
+        assert c != c2
+        assert hash(c) is not None
+
+        s = as_string("'123'")
+        s2 = as_string('"ABC"')
+        assert s.op == Op.STRING
+        assert repr(s) == "Expr(Op.STRING, (\"'123'\", 1))", repr(s)
+        assert s == s
+        assert s != s2
+
+        a = as_array((n, m))
+        b = as_array((n, ))
+        assert a.op == Op.ARRAY
+        assert repr(a) == ("Expr(Op.ARRAY, (Expr(Op.INTEGER, (123, 4)),"
+                           " Expr(Op.INTEGER, (456, 4))))")
+        assert a == a
+        assert a != b
+
+        t = as_terms(x)
+        u = as_terms(y)
+        assert t.op == Op.TERMS
+        assert repr(t) == "Expr(Op.TERMS, {Expr(Op.SYMBOL, 'x'): 1})"
+        assert t == t
+        assert t != u
+        assert hash(t) is not None
+
+        v = as_factors(x)
+        w = as_factors(y)
+        assert v.op == Op.FACTORS
+        assert repr(v) == "Expr(Op.FACTORS, {Expr(Op.SYMBOL, 'x'): 1})"
+        assert v == v
+        assert w != v
+        assert hash(v) is not None
+
+        t = as_ternary(x, y, z)
+        u = as_ternary(x, z, y)
+        assert t.op == Op.TERNARY
+        assert t == t
+        assert t != u
+        assert hash(t) is not None
+
+        e = as_eq(x, y)
+        f = as_lt(x, y)
+        assert e.op == Op.RELATIONAL
+        assert e == e
+        assert e != f
+        assert hash(e) is not None
+
+    def test_tostring_fortran(self):
+        x = as_symbol("x")
+        y = as_symbol("y")
+        z = as_symbol("z")
+        n = as_number(123)
+        m = as_number(456)
+        a = as_array((n, m))
+        c = as_complex(n, m)
+
+        assert str(x) == "x"
+        assert str(n) == "123"
+        assert str(a) == "[123, 456]"
+        assert str(c) == "(123, 456)"
+
+        assert str(Expr(Op.TERMS, {x: 1})) == "x"
+        assert str(Expr(Op.TERMS, {x: 2})) == "2 * x"
+        assert str(Expr(Op.TERMS, {x: -1})) == "-x"
+        assert str(Expr(Op.TERMS, {x: -2})) == "-2 * x"
+        assert str(Expr(Op.TERMS, {x: 1, y: 1})) == "x + y"
+        assert str(Expr(Op.TERMS, {x: -1, y: -1})) == "-x - y"
+        assert str(Expr(Op.TERMS, {x: 2, y: 3})) == "2 * x + 3 * y"
+        assert str(Expr(Op.TERMS, {x: -2, y: 3})) == "-2 * x + 3 * y"
+        assert str(Expr(Op.TERMS, {x: 2, y: -3})) == "2 * x - 3 * y"
+
+        assert str(Expr(Op.FACTORS, {x: 1})) == "x"
+        assert str(Expr(Op.FACTORS, {x: 2})) == "x ** 2"
+        assert str(Expr(Op.FACTORS, {x: -1})) == "x ** -1"
+        assert str(Expr(Op.FACTORS, {x: -2})) == "x ** -2"
+        assert str(Expr(Op.FACTORS, {x: 1, y: 1})) == "x * y"
+        assert str(Expr(Op.FACTORS, {x: 2, y: 3})) == "x ** 2 * y ** 3"
+
+        v = Expr(Op.FACTORS, {x: 2, Expr(Op.TERMS, {x: 1, y: 1}): 3})
+        assert str(v) == "x ** 2 * (x + y) ** 3", str(v)
+        v = Expr(Op.FACTORS, {x: 2, Expr(Op.FACTORS, {x: 1, y: 1}): 3})
+        assert str(v) == "x ** 2 * (x * y) ** 3", str(v)
+
+        assert str(Expr(Op.APPLY, ("f", (), {}))) == "f()"
+        assert str(Expr(Op.APPLY, ("f", (x, ), {}))) == "f(x)"
+        assert str(Expr(Op.APPLY, ("f", (x, y), {}))) == "f(x, y)"
+        assert str(Expr(Op.INDEXING, ("f", x))) == "f[x]"
+
+        assert str(as_ternary(x, y, z)) == "merge(y, z, x)"
+        assert str(as_eq(x, y)) == "x .eq. y"
+        assert str(as_ne(x, y)) == "x .ne. y"
+        assert str(as_lt(x, y)) == "x .lt. y"
+        assert str(as_le(x, y)) == "x .le. y"
+        assert str(as_gt(x, y)) == "x .gt. y"
+        assert str(as_ge(x, y)) == "x .ge. y"
+
+    def test_tostring_c(self):
+        language = Language.C
+        x = as_symbol("x")
+        y = as_symbol("y")
+        z = as_symbol("z")
+        n = as_number(123)
+
+        assert Expr(Op.FACTORS, {x: 2}).tostring(language=language) == "x * x"
+        assert (Expr(Op.FACTORS, {
+            x + y: 2
+        }).tostring(language=language) == "(x + y) * (x + y)")
+        assert Expr(Op.FACTORS, {
+            x: 12
+        }).tostring(language=language) == "pow(x, 12)"
+
+        assert as_apply(ArithOp.DIV, x,
+                        y).tostring(language=language) == "x / y"
+        assert (as_apply(ArithOp.DIV, x,
+                         x + y).tostring(language=language) == "x / (x + y)")
+        assert (as_apply(ArithOp.DIV, x - y, x +
+                         y).tostring(language=language) == "(x - y) / (x + y)")
+        assert (x + (x - y) / (x + y) +
+                n).tostring(language=language) == "123 + x + (x - y) / (x + y)"
+
+        assert as_ternary(x, y, z).tostring(language=language) == "(x?y:z)"
+        assert as_eq(x, y).tostring(language=language) == "x == y"
+        assert as_ne(x, y).tostring(language=language) == "x != y"
+        assert as_lt(x, y).tostring(language=language) == "x < y"
+        assert as_le(x, y).tostring(language=language) == "x <= y"
+        assert as_gt(x, y).tostring(language=language) == "x > y"
+        assert as_ge(x, y).tostring(language=language) == "x >= y"
+
+    def test_operations(self):
+        x = as_symbol("x")
+        y = as_symbol("y")
+        z = as_symbol("z")
+
+        assert x + x == Expr(Op.TERMS, {x: 2})
+        assert x - x == Expr(Op.INTEGER, (0, 4))
+        assert x + y == Expr(Op.TERMS, {x: 1, y: 1})
+        assert x - y == Expr(Op.TERMS, {x: 1, y: -1})
+        assert x * x == Expr(Op.FACTORS, {x: 2})
+        assert x * y == Expr(Op.FACTORS, {x: 1, y: 1})
+
+        assert +x == x
+        assert -x == Expr(Op.TERMS, {x: -1}), repr(-x)
+        assert 2 * x == Expr(Op.TERMS, {x: 2})
+        assert 2 + x == Expr(Op.TERMS, {x: 1, as_number(1): 2})
+        assert 2 * x + 3 * y == Expr(Op.TERMS, {x: 2, y: 3})
+        assert (x + y) * 2 == Expr(Op.TERMS, {x: 2, y: 2})
+
+        assert x**2 == Expr(Op.FACTORS, {x: 2})
+        assert (x + y)**2 == Expr(
+            Op.TERMS,
+            {
+                Expr(Op.FACTORS, {x: 2}): 1,
+                Expr(Op.FACTORS, {y: 2}): 1,
+                Expr(Op.FACTORS, {
+                    x: 1,
+                    y: 1
+                }): 2,
+            },
+        )
+        assert (x + y) * x == x**2 + x * y
+        assert (x + y)**2 == x**2 + 2 * x * y + y**2
+        assert (x + y)**2 + (x - y)**2 == 2 * x**2 + 2 * y**2
+        assert (x + y) * z == x * z + y * z
+        assert z * (x + y) == x * z + y * z
+
+        assert (x / 2) == as_apply(ArithOp.DIV, x, as_number(2))
+        assert (2 * x / 2) == x
+        assert (3 * x / 2) == as_apply(ArithOp.DIV, 3 * x, as_number(2))
+        assert (4 * x / 2) == 2 * x
+        assert (5 * x / 2) == as_apply(ArithOp.DIV, 5 * x, as_number(2))
+        assert (6 * x / 2) == 3 * x
+        assert ((3 * 5) * x / 6) == as_apply(ArithOp.DIV, 5 * x, as_number(2))
+        assert (30 * x**2 * y**4 / (24 * x**3 * y**3)) == as_apply(
+            ArithOp.DIV, 5 * y, 4 * x)
+        assert ((15 * x / 6) / 5) == as_apply(ArithOp.DIV, x,
+                                              as_number(2)), (15 * x / 6) / 5
+        assert (x / (5 / x)) == as_apply(ArithOp.DIV, x**2, as_number(5))
+
+        assert (x / 2.0) == Expr(Op.TERMS, {x: 0.5})
+
+        s = as_string('"ABC"')
+        t = as_string('"123"')
+
+        assert s // t == Expr(Op.STRING, ('"ABC123"', 1))
+        assert s // x == Expr(Op.CONCAT, (s, x))
+        assert x // s == Expr(Op.CONCAT, (x, s))
+
+        c = as_complex(1.0, 2.0)
+        assert -c == as_complex(-1.0, -2.0)
+        assert c + c == as_expr((1 + 2j) * 2)
+        assert c * c == as_expr((1 + 2j)**2)
+
+    def test_substitute(self):
+        x = as_symbol("x")
+        y = as_symbol("y")
+        z = as_symbol("z")
+        a = as_array((x, y))
+
+        assert x.substitute({x: y}) == y
+        assert (x + y).substitute({x: z}) == y + z
+        assert (x * y).substitute({x: z}) == y * z
+        assert (x**4).substitute({x: z}) == z**4
+        assert (x / y).substitute({x: z}) == z / y
+        assert x.substitute({x: y + z}) == y + z
+        assert a.substitute({x: y + z}) == as_array((y + z, y))
+
+        assert as_ternary(x, y,
+                          z).substitute({x: y + z}) == as_ternary(y + z, y, z)
+        assert as_eq(x, y).substitute({x: y + z}) == as_eq(y + z, y)
+
+    def test_fromstring(self):
+
+        x = as_symbol("x")
+        y = as_symbol("y")
+        z = as_symbol("z")
+        f = as_symbol("f")
+        s = as_string('"ABC"')
+        t = as_string('"123"')
+        a = as_array((x, y))
+
+        assert fromstring("x") == x
+        assert fromstring("+ x") == x
+        assert fromstring("-  x") == -x
+        assert fromstring("x + y") == x + y
+        assert fromstring("x + 1") == x + 1
+        assert fromstring("x * y") == x * y
+        assert fromstring("x * 2") == x * 2
+        assert fromstring("x / y") == x / y
+        assert fromstring("x ** 2", language=Language.Python) == x**2
+        assert fromstring("x ** 2 ** 3", language=Language.Python) == x**2**3
+        assert fromstring("(x + y) * z") == (x + y) * z
+
+        assert fromstring("f(x)") == f(x)
+        assert fromstring("f(x,y)") == f(x, y)
+        assert fromstring("f[x]") == f[x]
+        assert fromstring("f[x][y]") == f[x][y]
+
+        assert fromstring('"ABC"') == s
+        assert (normalize(
+            fromstring('"ABC" // "123" ',
+                       language=Language.Fortran)) == s // t)
+        assert fromstring('f("ABC")') == f(s)
+        assert fromstring('MYSTRKIND_"ABC"') == as_string('"ABC"', "MYSTRKIND")
+
+        assert fromstring("(/x, y/)") == a, fromstring("(/x, y/)")
+        assert fromstring("f((/x, y/))") == f(a)
+        assert fromstring("(/(x+y)*z/)") == as_array(((x + y) * z, ))
+
+        assert fromstring("123") == as_number(123)
+        assert fromstring("123_2") == as_number(123, 2)
+        assert fromstring("123_myintkind") == as_number(123, "myintkind")
+
+        assert fromstring("123.0") == as_number(123.0, 4)
+        assert fromstring("123.0_4") == as_number(123.0, 4)
+        assert fromstring("123.0_8") == as_number(123.0, 8)
+        assert fromstring("123.0e0") == as_number(123.0, 4)
+        assert fromstring("123.0d0") == as_number(123.0, 8)
+        assert fromstring("123d0") == as_number(123.0, 8)
+        assert fromstring("123e-0") == as_number(123.0, 4)
+        assert fromstring("123d+0") == as_number(123.0, 8)
+        assert fromstring("123.0_myrealkind") == as_number(123.0, "myrealkind")
+        assert fromstring("3E4") == as_number(30000.0, 4)
+
+        assert fromstring("(1, 2)") == as_complex(1, 2)
+        assert fromstring("(1e2, PI)") == as_complex(as_number(100.0),
+                                                     as_symbol("PI"))
+
+        assert fromstring("[1, 2]") == as_array((as_number(1), as_number(2)))
+
+        assert fromstring("POINT(x, y=1)") == as_apply(as_symbol("POINT"),
+                                                       x,
+                                                       y=as_number(1))
+        assert fromstring(
+            'PERSON(name="John", age=50, shape=(/34, 23/))') == as_apply(
+                as_symbol("PERSON"),
+                name=as_string('"John"'),
+                age=as_number(50),
+                shape=as_array((as_number(34), as_number(23))),
+            )
+
+        assert fromstring("x?y:z") == as_ternary(x, y, z)
+
+        assert fromstring("*x") == as_deref(x)
+        assert fromstring("**x") == as_deref(as_deref(x))
+        assert fromstring("&x") == as_ref(x)
+        assert fromstring("(*x) * (*y)") == as_deref(x) * as_deref(y)
+        assert fromstring("(*x) * *y") == as_deref(x) * as_deref(y)
+        assert fromstring("*x * *y") == as_deref(x) * as_deref(y)
+        assert fromstring("*x**y") == as_deref(x) * as_deref(y)
+
+        assert fromstring("x == y") == as_eq(x, y)
+        assert fromstring("x != y") == as_ne(x, y)
+        assert fromstring("x < y") == as_lt(x, y)
+        assert fromstring("x > y") == as_gt(x, y)
+        assert fromstring("x <= y") == as_le(x, y)
+        assert fromstring("x >= y") == as_ge(x, y)
+
+        assert fromstring("x .eq. y", language=Language.Fortran) == as_eq(x, y)
+        assert fromstring("x .ne. y", language=Language.Fortran) == as_ne(x, y)
+        assert fromstring("x .lt. y", language=Language.Fortran) == as_lt(x, y)
+        assert fromstring("x .gt. y", language=Language.Fortran) == as_gt(x, y)
+        assert fromstring("x .le. y", language=Language.Fortran) == as_le(x, y)
+        assert fromstring("x .ge. y", language=Language.Fortran) == as_ge(x, y)
+
+    def test_traverse(self):
+        x = as_symbol("x")
+        y = as_symbol("y")
+        z = as_symbol("z")
+        f = as_symbol("f")
+
+        # Use traverse to substitute a symbol
+        def replace_visit(s, r=z):
+            if s == x:
+                return r
+
+        assert x.traverse(replace_visit) == z
+        assert y.traverse(replace_visit) == y
+        assert z.traverse(replace_visit) == z
+        assert (f(y)).traverse(replace_visit) == f(y)
+        assert (f(x)).traverse(replace_visit) == f(z)
+        assert (f[y]).traverse(replace_visit) == f[y]
+        assert (f[z]).traverse(replace_visit) == f[z]
+        assert (x + y + z).traverse(replace_visit) == (2 * z + y)
+        assert (x +
+                f(y, x - z)).traverse(replace_visit) == (z +
+                                                         f(y, as_number(0)))
+        assert as_eq(x, y).traverse(replace_visit) == as_eq(z, y)
+
+        # Use traverse to collect symbols, method 1
+        function_symbols = set()
+        symbols = set()
+
+        def collect_symbols(s):
+            if s.op is Op.APPLY:
+                oper = s.data[0]
+                function_symbols.add(oper)
+                if oper in symbols:
+                    symbols.remove(oper)
+            elif s.op is Op.SYMBOL and s not in function_symbols:
+                symbols.add(s)
+
+        (x + f(y, x - z)).traverse(collect_symbols)
+        assert function_symbols == {f}
+        assert symbols == {x, y, z}
+
+        # Use traverse to collect symbols, method 2
+        def collect_symbols2(expr, symbols):
+            if expr.op is Op.SYMBOL:
+                symbols.add(expr)
+
+        symbols = set()
+        (x + f(y, x - z)).traverse(collect_symbols2, symbols)
+        assert symbols == {x, y, z, f}
+
+        # Use traverse to partially collect symbols
+        def collect_symbols3(expr, symbols):
+            if expr.op is Op.APPLY:
+                # skip traversing function calls
+                return expr
+            if expr.op is Op.SYMBOL:
+                symbols.add(expr)
+
+        symbols = set()
+        (x + f(y, x - z)).traverse(collect_symbols3, symbols)
+        assert symbols == {x}
+
+    def test_linear_solve(self):
+        x = as_symbol("x")
+        y = as_symbol("y")
+        z = as_symbol("z")
+
+        assert x.linear_solve(x) == (as_number(1), as_number(0))
+        assert (x + 1).linear_solve(x) == (as_number(1), as_number(1))
+        assert (2 * x).linear_solve(x) == (as_number(2), as_number(0))
+        assert (2 * x + 3).linear_solve(x) == (as_number(2), as_number(3))
+        assert as_number(3).linear_solve(x) == (as_number(0), as_number(3))
+        assert y.linear_solve(x) == (as_number(0), y)
+        assert (y * z).linear_solve(x) == (as_number(0), y * z)
+
+        assert (x + y).linear_solve(x) == (as_number(1), y)
+        assert (z * x + y).linear_solve(x) == (z, y)
+        assert ((z + y) * x + y).linear_solve(x) == (z + y, y)
+        assert (z * y * x + y).linear_solve(x) == (z * y, y)
+
+        pytest.raises(RuntimeError, lambda: (x * x).linear_solve(x))
+
+    def test_as_numer_denom(self):
+        x = as_symbol("x")
+        y = as_symbol("y")
+        n = as_number(123)
+
+        assert as_numer_denom(x) == (x, as_number(1))
+        assert as_numer_denom(x / n) == (x, n)
+        assert as_numer_denom(n / x) == (n, x)
+        assert as_numer_denom(x / y) == (x, y)
+        assert as_numer_denom(x * y) == (x * y, as_number(1))
+        assert as_numer_denom(n + x / y) == (x + n * y, y)
+        assert as_numer_denom(n + x / (y - x / n)) == (y * n**2, y * n - x)
+
+    def test_polynomial_atoms(self):
+        x = as_symbol("x")
+        y = as_symbol("y")
+        n = as_number(123)
+
+        assert x.polynomial_atoms() == {x}
+        assert n.polynomial_atoms() == set()
+        assert (y[x]).polynomial_atoms() == {y[x]}
+        assert (y(x)).polynomial_atoms() == {y(x)}
+        assert (y(x) + x).polynomial_atoms() == {y(x), x}
+        assert (y(x) * x[y]).polynomial_atoms() == {y(x), x[y]}
+        assert (y(x)**x).polynomial_atoms() == {y(x)}
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/test_value_attrspec.py b/venv/lib/python3.12/site-packages/numpy/f2py/tests/test_value_attrspec.py
new file mode 100644
index 00000000..3855a627
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/tests/test_value_attrspec.py
@@ -0,0 +1,15 @@
+import os
+import pytest
+
+from . import util
+
+class TestValueAttr(util.F2PyTest):
+    sources = [util.getpath("tests", "src", "value_attrspec", "gh21665.f90")]
+
+    # gh-21665
+    @pytest.mark.slow
+    def test_gh21665(self):
+        inp = 2
+        out = self.module.fortfuncs.square(inp)
+        exp_out = 4
+        assert out == exp_out
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/tests/util.py b/venv/lib/python3.12/site-packages/numpy/f2py/tests/util.py
new file mode 100644
index 00000000..9cad71a9
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/tests/util.py
@@ -0,0 +1,444 @@
+"""
+Utility functions for
+
+- building and importing modules on test time, using a temporary location
+- detecting if compilers are present
+- determining paths to tests
+
+"""
+import glob
+import os
+import sys
+import subprocess
+import tempfile
+import shutil
+import atexit
+import textwrap
+import re
+import pytest
+import contextlib
+import numpy
+import concurrent.futures
+
+from pathlib import Path
+from numpy._utils import asunicode
+from numpy.testing import temppath, IS_WASM
+from importlib import import_module
+from numpy.f2py._backends._meson import MesonBackend
+
+#
+# Check if compilers are available at all...
+#
+
+def check_language(lang, code_snippet=None):
+    if sys.platform == "win32":
+        pytest.skip("No Fortran tests on Windows (Issue #25134)", allow_module_level=True)
+    tmpdir = tempfile.mkdtemp()
+    try:
+        meson_file = os.path.join(tmpdir, "meson.build")
+        with open(meson_file, "w") as f:
+            f.write("project('check_compilers')\n")
+            f.write(f"add_languages('{lang}')\n")
+            if code_snippet:
+                f.write(f"{lang}_compiler = meson.get_compiler('{lang}')\n")
+                f.write(f"{lang}_code = '''{code_snippet}'''\n")
+                f.write(
+                    f"_have_{lang}_feature ="
+                    f"{lang}_compiler.compiles({lang}_code,"
+                    f" name: '{lang} feature check')\n"
+                )
+        try:
+            runmeson = subprocess.run(
+                ["meson", "setup", "btmp"],
+                check=False,
+                cwd=tmpdir,
+                capture_output=True,
+            )
+        except subprocess.CalledProcessError:
+            pytest.skip("meson not present, skipping compiler dependent test", allow_module_level=True)
+        return runmeson.returncode == 0
+    finally:
+        shutil.rmtree(tmpdir)
+    return False
+
+
+fortran77_code = '''
+C Example Fortran 77 code
+      PROGRAM HELLO
+      PRINT *, 'Hello, Fortran 77!'
+      END
+'''
+
+fortran90_code = '''
+! Example Fortran 90 code
+program hello90
+  type :: greeting
+    character(len=20) :: text
+  end type greeting
+
+  type(greeting) :: greet
+  greet%text = 'hello, fortran 90!'
+  print *, greet%text
+end program hello90
+'''
+
+# Dummy class for caching relevant checks
+class CompilerChecker:
+    def __init__(self):
+        self.compilers_checked = False
+        self.has_c = False
+        self.has_f77 = False
+        self.has_f90 = False
+
+    def check_compilers(self):
+        if (not self.compilers_checked) and (not sys.platform == "cygwin"):
+            with concurrent.futures.ThreadPoolExecutor() as executor:
+                futures = [
+                    executor.submit(check_language, "c"),
+                    executor.submit(check_language, "fortran", fortran77_code),
+                    executor.submit(check_language, "fortran", fortran90_code)
+                ]
+
+                self.has_c = futures[0].result()
+                self.has_f77 = futures[1].result()
+                self.has_f90 = futures[2].result()
+
+            self.compilers_checked = True
+
+if not IS_WASM:
+    checker = CompilerChecker()
+    checker.check_compilers()
+
+def has_c_compiler():
+    return checker.has_c
+
+def has_f77_compiler():
+    return checker.has_f77
+
+def has_f90_compiler():
+    return checker.has_f90
+
+def has_fortran_compiler():
+    return (checker.has_f90 and checker.has_f77)
+
+
+#
+# Maintaining a temporary module directory
+#
+
+_module_dir = None
+_module_num = 5403
+
+if sys.platform == "cygwin":
+    NUMPY_INSTALL_ROOT = Path(__file__).parent.parent.parent
+    _module_list = list(NUMPY_INSTALL_ROOT.glob("**/*.dll"))
+
+
+def _cleanup():
+    global _module_dir
+    if _module_dir is not None:
+        try:
+            sys.path.remove(_module_dir)
+        except ValueError:
+            pass
+        try:
+            shutil.rmtree(_module_dir)
+        except OSError:
+            pass
+        _module_dir = None
+
+
+def get_module_dir():
+    global _module_dir
+    if _module_dir is None:
+        _module_dir = tempfile.mkdtemp()
+        atexit.register(_cleanup)
+        if _module_dir not in sys.path:
+            sys.path.insert(0, _module_dir)
+    return _module_dir
+
+
+def get_temp_module_name():
+    # Assume single-threaded, and the module dir usable only by this thread
+    global _module_num
+    get_module_dir()
+    name = "_test_ext_module_%d" % _module_num
+    _module_num += 1
+    if name in sys.modules:
+        # this should not be possible, but check anyway
+        raise RuntimeError("Temporary module name already in use.")
+    return name
+
+
+def _memoize(func):
+    memo = {}
+
+    def wrapper(*a, **kw):
+        key = repr((a, kw))
+        if key not in memo:
+            try:
+                memo[key] = func(*a, **kw)
+            except Exception as e:
+                memo[key] = e
+                raise
+        ret = memo[key]
+        if isinstance(ret, Exception):
+            raise ret
+        return ret
+
+    wrapper.__name__ = func.__name__
+    return wrapper
+
+
+#
+# Building modules
+#
+
+
+@_memoize
+def build_module(source_files, options=[], skip=[], only=[], module_name=None):
+    """
+    Compile and import a f2py module, built from the given files.
+
+    """
+
+    code = f"import sys; sys.path = {sys.path!r}; import numpy.f2py; numpy.f2py.main()"
+
+    d = get_module_dir()
+    # gh-27045 : Skip if no compilers are found
+    if not has_fortran_compiler():
+        pytest.skip("No Fortran compiler available")
+
+    # Copy files
+    dst_sources = []
+    f2py_sources = []
+    for fn in source_files:
+        if not os.path.isfile(fn):
+            raise RuntimeError("%s is not a file" % fn)
+        dst = os.path.join(d, os.path.basename(fn))
+        shutil.copyfile(fn, dst)
+        dst_sources.append(dst)
+
+        base, ext = os.path.splitext(dst)
+        if ext in (".f90", ".f95", ".f", ".c", ".pyf"):
+            f2py_sources.append(dst)
+
+    assert f2py_sources
+
+    # Prepare options
+    if module_name is None:
+        module_name = get_temp_module_name()
+    gil_options = []
+    if '--freethreading-compatible' not in options and '--no-freethreading-compatible' not in options:
+        # default to disabling the GIL if unset in options
+        gil_options = ['--freethreading-compatible']
+    f2py_opts = ["-c", "-m", module_name] + options + gil_options + f2py_sources
+    f2py_opts += ["--backend", "meson"]
+    if skip:
+        f2py_opts += ["skip:"] + skip
+    if only:
+        f2py_opts += ["only:"] + only
+
+    # Build
+    cwd = os.getcwd()
+    try:
+        os.chdir(d)
+        cmd = [sys.executable, "-c", code] + f2py_opts
+        p = subprocess.Popen(cmd,
+                             stdout=subprocess.PIPE,
+                             stderr=subprocess.STDOUT)
+        out, err = p.communicate()
+        if p.returncode != 0:
+            raise RuntimeError("Running f2py failed: %s\n%s" %
+                               (cmd[4:], asunicode(out)))
+    finally:
+        os.chdir(cwd)
+
+        # Partial cleanup
+        for fn in dst_sources:
+            os.unlink(fn)
+
+    # Rebase (Cygwin-only)
+    if sys.platform == "cygwin":
+        # If someone starts deleting modules after import, this will
+        # need to change to record how big each module is, rather than
+        # relying on rebase being able to find that from the files.
+        _module_list.extend(
+            glob.glob(os.path.join(d, "{:s}*".format(module_name)))
+        )
+        subprocess.check_call(
+            ["/usr/bin/rebase", "--database", "--oblivious", "--verbose"]
+            + _module_list
+        )
+
+    # Import
+    return import_module(module_name)
+
+
+@_memoize
+def build_code(source_code,
+               options=[],
+               skip=[],
+               only=[],
+               suffix=None,
+               module_name=None):
+    """
+    Compile and import Fortran code using f2py.
+
+    """
+    if suffix is None:
+        suffix = ".f"
+    with temppath(suffix=suffix) as path:
+        with open(path, "w") as f:
+            f.write(source_code)
+        return build_module([path],
+                            options=options,
+                            skip=skip,
+                            only=only,
+                            module_name=module_name)
+
+
+#
+# Building with meson
+#
+
+
+class SimplifiedMesonBackend(MesonBackend):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+    def compile(self):
+        self.write_meson_build(self.build_dir)
+        self.run_meson(self.build_dir)
+
+
+def build_meson(source_files, module_name=None, **kwargs):
+    """
+    Build a module via Meson and import it.
+    """
+
+    # gh-27045 : Skip if no compilers are found
+    if not has_fortran_compiler():
+        pytest.skip("No Fortran compiler available")
+
+    build_dir = get_module_dir()
+    if module_name is None:
+        module_name = get_temp_module_name()
+
+    # Initialize the MesonBackend
+    backend = SimplifiedMesonBackend(
+        modulename=module_name,
+        sources=source_files,
+        extra_objects=kwargs.get("extra_objects", []),
+        build_dir=build_dir,
+        include_dirs=kwargs.get("include_dirs", []),
+        library_dirs=kwargs.get("library_dirs", []),
+        libraries=kwargs.get("libraries", []),
+        define_macros=kwargs.get("define_macros", []),
+        undef_macros=kwargs.get("undef_macros", []),
+        f2py_flags=kwargs.get("f2py_flags", []),
+        sysinfo_flags=kwargs.get("sysinfo_flags", []),
+        fc_flags=kwargs.get("fc_flags", []),
+        flib_flags=kwargs.get("flib_flags", []),
+        setup_flags=kwargs.get("setup_flags", []),
+        remove_build_dir=kwargs.get("remove_build_dir", False),
+        extra_dat=kwargs.get("extra_dat", {}),
+    )
+
+    backend.compile()
+
+    # Import the compiled module
+    sys.path.insert(0, f"{build_dir}/{backend.meson_build_dir}")
+    return import_module(module_name)
+
+
+#
+# Unittest convenience
+#
+
+
+class F2PyTest:
+    code = None
+    sources = None
+    options = []
+    skip = []
+    only = []
+    suffix = ".f"
+    module = None
+    _has_c_compiler = None
+    _has_f77_compiler = None
+    _has_f90_compiler = None
+
+    @property
+    def module_name(self):
+        cls = type(self)
+        return f'_{cls.__module__.rsplit(".",1)[-1]}_{cls.__name__}_ext_module'
+
+    @classmethod
+    def setup_class(cls):
+        if sys.platform == "win32":
+            pytest.skip("Fails with MinGW64 Gfortran (Issue #9673)")
+        F2PyTest._has_c_compiler = has_c_compiler()
+        F2PyTest._has_f77_compiler = has_f77_compiler()
+        F2PyTest._has_f90_compiler = has_f90_compiler()
+        F2PyTest._has_fortran_compiler = has_fortran_compiler()
+
+    def setup_method(self):
+        if self.module is not None:
+            return
+
+        codes = self.sources if self.sources else []
+        if self.code:
+            codes.append(self.suffix)
+
+        needs_f77 = any(str(fn).endswith(".f") for fn in codes)
+        needs_f90 = any(str(fn).endswith(".f90") for fn in codes)
+        needs_pyf = any(str(fn).endswith(".pyf") for fn in codes)
+
+        if needs_f77 and not self._has_f77_compiler:
+            pytest.skip("No Fortran 77 compiler available")
+        if needs_f90 and not self._has_f90_compiler:
+            pytest.skip("No Fortran 90 compiler available")
+        if needs_pyf and not self._has_fortran_compiler:
+            pytest.skip("No Fortran compiler available")
+
+        # Build the module
+        if self.code is not None:
+            self.module = build_code(
+                self.code,
+                options=self.options,
+                skip=self.skip,
+                only=self.only,
+                suffix=self.suffix,
+                module_name=self.module_name,
+            )
+
+        if self.sources is not None:
+            self.module = build_module(
+                self.sources,
+                options=self.options,
+                skip=self.skip,
+                only=self.only,
+                module_name=self.module_name,
+            )
+
+
+#
+# Helper functions
+#
+
+
+def getpath(*a):
+    # Package root
+    d = Path(numpy.f2py.__file__).parent.resolve()
+    return d.joinpath(*a)
+
+
+@contextlib.contextmanager
+def switchdir(path):
+    curpath = Path.cwd()
+    os.chdir(path)
+    try:
+        yield
+    finally:
+        os.chdir(curpath)
diff --git a/venv/lib/python3.12/site-packages/numpy/f2py/use_rules.py b/venv/lib/python3.12/site-packages/numpy/f2py/use_rules.py
new file mode 100644
index 00000000..808b3dd9
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/f2py/use_rules.py
@@ -0,0 +1,106 @@
+"""
+Build 'use others module data' mechanism for f2py2e.
+
+Copyright 1999 -- 2011 Pearu Peterson all rights reserved.
+Copyright 2011 -- present NumPy Developers.
+Permission to use, modify, and distribute this software is given under the
+terms of the NumPy License.
+
+NO WARRANTY IS EXPRESSED OR IMPLIED.  USE AT YOUR OWN RISK.
+"""
+__version__ = "$Revision: 1.3 $"[10:-1]
+
+f2py_version = 'See `f2py -v`'
+
+
+from .auxfuncs import (
+    applyrules, dictappend, gentitle, hasnote, outmess
+)
+
+
+usemodule_rules = {
+    'body': """
+#begintitle#
+static char doc_#apiname#[] = \"\\\nVariable wrapper signature:\\n\\
+\t #name# = get_#name#()\\n\\
+Arguments:\\n\\
+#docstr#\";
+extern F_MODFUNC(#usemodulename#,#USEMODULENAME#,#realname#,#REALNAME#);
+static PyObject *#apiname#(PyObject *capi_self, PyObject *capi_args) {
+/*#decl#*/
+\tif (!PyArg_ParseTuple(capi_args, \"\")) goto capi_fail;
+printf(\"c: %d\\n\",F_MODFUNC(#usemodulename#,#USEMODULENAME#,#realname#,#REALNAME#));
+\treturn Py_BuildValue(\"\");
+capi_fail:
+\treturn NULL;
+}
+""",
+    'method': '\t{\"get_#name#\",#apiname#,METH_VARARGS|METH_KEYWORDS,doc_#apiname#},',
+    'need': ['F_MODFUNC']
+}
+
+################
+
+
+def buildusevars(m, r):
+    ret = {}
+    outmess(
+        '\t\tBuilding use variable hooks for module "%s" (feature only for F90/F95)...\n' % (m['name']))
+    varsmap = {}
+    revmap = {}
+    if 'map' in r:
+        for k in r['map'].keys():
+            if r['map'][k] in revmap:
+                outmess('\t\t\tVariable "%s<=%s" is already mapped by "%s". Skipping.\n' % (
+                    r['map'][k], k, revmap[r['map'][k]]))
+            else:
+                revmap[r['map'][k]] = k
+    if 'only' in r and r['only']:
+        for v in r['map'].keys():
+            if r['map'][v] in m['vars']:
+
+                if revmap[r['map'][v]] == v:
+                    varsmap[v] = r['map'][v]
+                else:
+                    outmess('\t\t\tIgnoring map "%s=>%s". See above.\n' %
+                            (v, r['map'][v]))
+            else:
+                outmess(
+                    '\t\t\tNo definition for variable "%s=>%s". Skipping.\n' % (v, r['map'][v]))
+    else:
+        for v in m['vars'].keys():
+            if v in revmap:
+                varsmap[v] = revmap[v]
+            else:
+                varsmap[v] = v
+    for v in varsmap.keys():
+        ret = dictappend(ret, buildusevar(v, varsmap[v], m['vars'], m['name']))
+    return ret
+
+
+def buildusevar(name, realname, vars, usemodulename):
+    outmess('\t\t\tConstructing wrapper function for variable "%s=>%s"...\n' % (
+        name, realname))
+    ret = {}
+    vrd = {'name': name,
+           'realname': realname,
+           'REALNAME': realname.upper(),
+           'usemodulename': usemodulename,
+           'USEMODULENAME': usemodulename.upper(),
+           'texname': name.replace('_', '\\_'),
+           'begintitle': gentitle('%s=>%s' % (name, realname)),
+           'endtitle': gentitle('end of %s=>%s' % (name, realname)),
+           'apiname': '#modulename#_use_%s_from_%s' % (realname, usemodulename)
+           }
+    nummap = {0: 'Ro', 1: 'Ri', 2: 'Rii', 3: 'Riii', 4: 'Riv',
+              5: 'Rv', 6: 'Rvi', 7: 'Rvii', 8: 'Rviii', 9: 'Rix'}
+    vrd['texnamename'] = name
+    for i in nummap.keys():
+        vrd['texnamename'] = vrd['texnamename'].replace(repr(i), nummap[i])
+    if hasnote(vars[realname]):
+        vrd['note'] = vars[realname]['note']
+    rd = dictappend({}, vrd)
+
+    print(name, realname, vars[realname])
+    ret = applyrules(usemodule_rules, rd)
+    return ret
diff --git a/venv/lib/python3.12/site-packages/numpy/fft/__init__.py b/venv/lib/python3.12/site-packages/numpy/fft/__init__.py
new file mode 100644
index 00000000..0f6e6373
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/fft/__init__.py
@@ -0,0 +1,215 @@
+"""
+Discrete Fourier Transform (:mod:`numpy.fft`)
+=============================================
+
+.. currentmodule:: numpy.fft
+
+The SciPy module `scipy.fft` is a more comprehensive superset
+of ``numpy.fft``, which includes only a basic set of routines.
+
+Standard FFTs
+-------------
+
+.. autosummary::
+   :toctree: generated/
+
+   fft       Discrete Fourier transform.
+   ifft      Inverse discrete Fourier transform.
+   fft2      Discrete Fourier transform in two dimensions.
+   ifft2     Inverse discrete Fourier transform in two dimensions.
+   fftn      Discrete Fourier transform in N-dimensions.
+   ifftn     Inverse discrete Fourier transform in N dimensions.
+
+Real FFTs
+---------
+
+.. autosummary::
+   :toctree: generated/
+
+   rfft      Real discrete Fourier transform.
+   irfft     Inverse real discrete Fourier transform.
+   rfft2     Real discrete Fourier transform in two dimensions.
+   irfft2    Inverse real discrete Fourier transform in two dimensions.
+   rfftn     Real discrete Fourier transform in N dimensions.
+   irfftn    Inverse real discrete Fourier transform in N dimensions.
+
+Hermitian FFTs
+--------------
+
+.. autosummary::
+   :toctree: generated/
+
+   hfft      Hermitian discrete Fourier transform.
+   ihfft     Inverse Hermitian discrete Fourier transform.
+
+Helper routines
+---------------
+
+.. autosummary::
+   :toctree: generated/
+
+   fftfreq   Discrete Fourier Transform sample frequencies.
+   rfftfreq  DFT sample frequencies (for usage with rfft, irfft).
+   fftshift  Shift zero-frequency component to center of spectrum.
+   ifftshift Inverse of fftshift.
+
+
+Background information
+----------------------
+
+Fourier analysis is fundamentally a method for expressing a function as a
+sum of periodic components, and for recovering the function from those
+components.  When both the function and its Fourier transform are
+replaced with discretized counterparts, it is called the discrete Fourier
+transform (DFT).  The DFT has become a mainstay of numerical computing in
+part because of a very fast algorithm for computing it, called the Fast
+Fourier Transform (FFT), which was known to Gauss (1805) and was brought
+to light in its current form by Cooley and Tukey [CT]_.  Press et al. [NR]_
+provide an accessible introduction to Fourier analysis and its
+applications.
+
+Because the discrete Fourier transform separates its input into
+components that contribute at discrete frequencies, it has a great number
+of applications in digital signal processing, e.g., for filtering, and in
+this context the discretized input to the transform is customarily
+referred to as a *signal*, which exists in the *time domain*.  The output
+is called a *spectrum* or *transform* and exists in the *frequency
+domain*.
+
+Implementation details
+----------------------
+
+There are many ways to define the DFT, varying in the sign of the
+exponent, normalization, etc.  In this implementation, the DFT is defined
+as
+
+.. math::
+   A_k =  \\sum_{m=0}^{n-1} a_m \\exp\\left\\{-2\\pi i{mk \\over n}\\right\\}
+   \\qquad k = 0,\\ldots,n-1.
+
+The DFT is in general defined for complex inputs and outputs, and a
+single-frequency component at linear frequency :math:`f` is
+represented by a complex exponential
+:math:`a_m = \\exp\\{2\\pi i\\,f m\\Delta t\\}`, where :math:`\\Delta t`
+is the sampling interval.
+
+The values in the result follow so-called "standard" order: If ``A =
+fft(a, n)``, then ``A[0]`` contains the zero-frequency term (the sum of
+the signal), which is always purely real for real inputs. Then ``A[1:n/2]``
+contains the positive-frequency terms, and ``A[n/2+1:]`` contains the
+negative-frequency terms, in order of decreasingly negative frequency.
+For an even number of input points, ``A[n/2]`` represents both positive and
+negative Nyquist frequency, and is also purely real for real input.  For
+an odd number of input points, ``A[(n-1)/2]`` contains the largest positive
+frequency, while ``A[(n+1)/2]`` contains the largest negative frequency.
+The routine ``np.fft.fftfreq(n)`` returns an array giving the frequencies
+of corresponding elements in the output.  The routine
+``np.fft.fftshift(A)`` shifts transforms and their frequencies to put the
+zero-frequency components in the middle, and ``np.fft.ifftshift(A)`` undoes
+that shift.
+
+When the input `a` is a time-domain signal and ``A = fft(a)``, ``np.abs(A)``
+is its amplitude spectrum and ``np.abs(A)**2`` is its power spectrum.
+The phase spectrum is obtained by ``np.angle(A)``.
+
+The inverse DFT is defined as
+
+.. math::
+   a_m = \\frac{1}{n}\\sum_{k=0}^{n-1}A_k\\exp\\left\\{2\\pi i{mk\\over n}\\right\\}
+   \\qquad m = 0,\\ldots,n-1.
+
+It differs from the forward transform by the sign of the exponential
+argument and the default normalization by :math:`1/n`.
+
+Type Promotion
+--------------
+
+`numpy.fft` promotes ``float32`` and ``complex64`` arrays to ``float64`` and
+``complex128`` arrays respectively. For an FFT implementation that does not
+promote input arrays, see `scipy.fftpack`.
+
+Normalization
+-------------
+
+The argument ``norm`` indicates which direction of the pair of direct/inverse
+transforms is scaled and with what normalization factor.
+The default normalization (``"backward"``) has the direct (forward) transforms
+unscaled and the inverse (backward) transforms scaled by :math:`1/n`. It is
+possible to obtain unitary transforms by setting the keyword argument ``norm``
+to ``"ortho"`` so that both direct and inverse transforms are scaled by
+:math:`1/\\sqrt{n}`. Finally, setting the keyword argument ``norm`` to
+``"forward"`` has the direct transforms scaled by :math:`1/n` and the inverse
+transforms unscaled (i.e. exactly opposite to the default ``"backward"``).
+`None` is an alias of the default option ``"backward"`` for backward
+compatibility.
+
+Real and Hermitian transforms
+-----------------------------
+
+When the input is purely real, its transform is Hermitian, i.e., the
+component at frequency :math:`f_k` is the complex conjugate of the
+component at frequency :math:`-f_k`, which means that for real
+inputs there is no information in the negative frequency components that
+is not already available from the positive frequency components.
+The family of `rfft` functions is
+designed to operate on real inputs, and exploits this symmetry by
+computing only the positive frequency components, up to and including the
+Nyquist frequency.  Thus, ``n`` input points produce ``n/2+1`` complex
+output points.  The inverses of this family assumes the same symmetry of
+its input, and for an output of ``n`` points uses ``n/2+1`` input points.
+
+Correspondingly, when the spectrum is purely real, the signal is
+Hermitian.  The `hfft` family of functions exploits this symmetry by
+using ``n/2+1`` complex points in the input (time) domain for ``n`` real
+points in the frequency domain.
+
+In higher dimensions, FFTs are used, e.g., for image analysis and
+filtering.  The computational efficiency of the FFT means that it can
+also be a faster way to compute large convolutions, using the property
+that a convolution in the time domain is equivalent to a point-by-point
+multiplication in the frequency domain.
+
+Higher dimensions
+-----------------
+
+In two dimensions, the DFT is defined as
+
+.. math::
+   A_{kl} =  \\sum_{m=0}^{M-1} \\sum_{n=0}^{N-1}
+   a_{mn}\\exp\\left\\{-2\\pi i \\left({mk\\over M}+{nl\\over N}\\right)\\right\\}
+   \\qquad k = 0, \\ldots, M-1;\\quad l = 0, \\ldots, N-1,
+
+which extends in the obvious way to higher dimensions, and the inverses
+in higher dimensions also extend in the same way.
+
+References
+----------
+
+.. [CT] Cooley, James W., and John W. Tukey, 1965, "An algorithm for the
+        machine calculation of complex Fourier series," *Math. Comput.*
+        19: 297-301.
+
+.. [NR] Press, W., Teukolsky, S., Vetterline, W.T., and Flannery, B.P.,
+        2007, *Numerical Recipes: The Art of Scientific Computing*, ch.
+        12-13.  Cambridge Univ. Press, Cambridge, UK.
+
+Examples
+--------
+
+For examples, see the various functions.
+
+"""
+
+from . import _pocketfft, _helper
+# TODO: `numpy.fft.helper`` was deprecated in NumPy 2.0. It should
+# be deleted once downstream libraries move to `numpy.fft`.
+from . import helper
+from ._pocketfft import *
+from ._helper import *
+
+__all__ = _pocketfft.__all__.copy()
+__all__ += _helper.__all__
+
+from numpy._pytesttester import PytestTester
+test = PytestTester(__name__)
+del PytestTester
diff --git a/venv/lib/python3.12/site-packages/numpy/fft/__init__.pyi b/venv/lib/python3.12/site-packages/numpy/fft/__init__.pyi
new file mode 100644
index 00000000..504baff2
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/fft/__init__.pyi
@@ -0,0 +1,28 @@
+from numpy._pytesttester import PytestTester
+
+from numpy.fft._pocketfft import (
+    fft as fft,
+    ifft as ifft,
+    rfft as rfft,
+    irfft as irfft,
+    hfft as hfft,
+    ihfft as ihfft,
+    rfftn as rfftn,
+    irfftn as irfftn,
+    rfft2 as rfft2,
+    irfft2 as irfft2,
+    fft2 as fft2,
+    ifft2 as ifft2,
+    fftn as fftn,
+    ifftn as ifftn,
+)
+
+from numpy.fft._helper import (
+    fftshift as fftshift,
+    ifftshift as ifftshift,
+    fftfreq as fftfreq,
+    rfftfreq as rfftfreq,
+)
+
+__all__: list[str]
+test: PytestTester
diff --git a/venv/lib/python3.12/site-packages/numpy/fft/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/fft/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 00000000..5621d247
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/fft/__pycache__/__init__.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/fft/__pycache__/_helper.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/fft/__pycache__/_helper.cpython-312.pyc
new file mode 100644
index 00000000..2c783bc6
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/fft/__pycache__/_helper.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/fft/__pycache__/_pocketfft.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/fft/__pycache__/_pocketfft.cpython-312.pyc
new file mode 100644
index 00000000..2ba0b951
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/fft/__pycache__/_pocketfft.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/fft/__pycache__/helper.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/fft/__pycache__/helper.cpython-312.pyc
new file mode 100644
index 00000000..22ee843c
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/fft/__pycache__/helper.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/fft/_helper.py b/venv/lib/python3.12/site-packages/numpy/fft/_helper.py
new file mode 100644
index 00000000..f6c114ba
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/fft/_helper.py
@@ -0,0 +1,235 @@
+"""
+Discrete Fourier Transforms - _helper.py
+
+"""
+from numpy._core import integer, empty, arange, asarray, roll
+from numpy._core.overrides import array_function_dispatch, set_module
+
+# Created by Pearu Peterson, September 2002
+
+__all__ = ['fftshift', 'ifftshift', 'fftfreq', 'rfftfreq']
+
+integer_types = (int, integer)
+
+
+def _fftshift_dispatcher(x, axes=None):
+    return (x,)
+
+
+@array_function_dispatch(_fftshift_dispatcher, module='numpy.fft')
+def fftshift(x, axes=None):
+    """
+    Shift the zero-frequency component to the center of the spectrum.
+
+    This function swaps half-spaces for all axes listed (defaults to all).
+    Note that ``y[0]`` is the Nyquist component only if ``len(x)`` is even.
+
+    Parameters
+    ----------
+    x : array_like
+        Input array.
+    axes : int or shape tuple, optional
+        Axes over which to shift.  Default is None, which shifts all axes.
+
+    Returns
+    -------
+    y : ndarray
+        The shifted array.
+
+    See Also
+    --------
+    ifftshift : The inverse of `fftshift`.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> freqs = np.fft.fftfreq(10, 0.1)
+    >>> freqs
+    array([ 0.,  1.,  2., ..., -3., -2., -1.])
+    >>> np.fft.fftshift(freqs)
+    array([-5., -4., -3., -2., -1.,  0.,  1.,  2.,  3.,  4.])
+
+    Shift the zero-frequency component only along the second axis:
+
+    >>> freqs = np.fft.fftfreq(9, d=1./9).reshape(3, 3)
+    >>> freqs
+    array([[ 0.,  1.,  2.],
+           [ 3.,  4., -4.],
+           [-3., -2., -1.]])
+    >>> np.fft.fftshift(freqs, axes=(1,))
+    array([[ 2.,  0.,  1.],
+           [-4.,  3.,  4.],
+           [-1., -3., -2.]])
+
+    """
+    x = asarray(x)
+    if axes is None:
+        axes = tuple(range(x.ndim))
+        shift = [dim // 2 for dim in x.shape]
+    elif isinstance(axes, integer_types):
+        shift = x.shape[axes] // 2
+    else:
+        shift = [x.shape[ax] // 2 for ax in axes]
+
+    return roll(x, shift, axes)
+
+
+@array_function_dispatch(_fftshift_dispatcher, module='numpy.fft')
+def ifftshift(x, axes=None):
+    """
+    The inverse of `fftshift`. Although identical for even-length `x`, the
+    functions differ by one sample for odd-length `x`.
+
+    Parameters
+    ----------
+    x : array_like
+        Input array.
+    axes : int or shape tuple, optional
+        Axes over which to calculate.  Defaults to None, which shifts all axes.
+
+    Returns
+    -------
+    y : ndarray
+        The shifted array.
+
+    See Also
+    --------
+    fftshift : Shift zero-frequency component to the center of the spectrum.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> freqs = np.fft.fftfreq(9, d=1./9).reshape(3, 3)
+    >>> freqs
+    array([[ 0.,  1.,  2.],
+           [ 3.,  4., -4.],
+           [-3., -2., -1.]])
+    >>> np.fft.ifftshift(np.fft.fftshift(freqs))
+    array([[ 0.,  1.,  2.],
+           [ 3.,  4., -4.],
+           [-3., -2., -1.]])
+
+    """
+    x = asarray(x)
+    if axes is None:
+        axes = tuple(range(x.ndim))
+        shift = [-(dim // 2) for dim in x.shape]
+    elif isinstance(axes, integer_types):
+        shift = -(x.shape[axes] // 2)
+    else:
+        shift = [-(x.shape[ax] // 2) for ax in axes]
+
+    return roll(x, shift, axes)
+
+
+@set_module('numpy.fft')
+def fftfreq(n, d=1.0, device=None):
+    """
+    Return the Discrete Fourier Transform sample frequencies.
+
+    The returned float array `f` contains the frequency bin centers in cycles
+    per unit of the sample spacing (with zero at the start).  For instance, if
+    the sample spacing is in seconds, then the frequency unit is cycles/second.
+
+    Given a window length `n` and a sample spacing `d`::
+
+      f = [0, 1, ...,   n/2-1,     -n/2, ..., -1] / (d*n)   if n is even
+      f = [0, 1, ..., (n-1)/2, -(n-1)/2, ..., -1] / (d*n)   if n is odd
+
+    Parameters
+    ----------
+    n : int
+        Window length.
+    d : scalar, optional
+        Sample spacing (inverse of the sampling rate). Defaults to 1.
+    device : str, optional
+        The device on which to place the created array. Default: ``None``.
+        For Array-API interoperability only, so must be ``"cpu"`` if passed.
+
+        .. versionadded:: 2.0.0
+
+    Returns
+    -------
+    f : ndarray
+        Array of length `n` containing the sample frequencies.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> signal = np.array([-2, 8, 6, 4, 1, 0, 3, 5], dtype=float)
+    >>> fourier = np.fft.fft(signal)
+    >>> n = signal.size
+    >>> timestep = 0.1
+    >>> freq = np.fft.fftfreq(n, d=timestep)
+    >>> freq
+    array([ 0.  ,  1.25,  2.5 , ..., -3.75, -2.5 , -1.25])
+
+    """
+    if not isinstance(n, integer_types):
+        raise ValueError("n should be an integer")
+    val = 1.0 / (n * d)
+    results = empty(n, int, device=device)
+    N = (n-1)//2 + 1
+    p1 = arange(0, N, dtype=int, device=device)
+    results[:N] = p1
+    p2 = arange(-(n//2), 0, dtype=int, device=device)
+    results[N:] = p2
+    return results * val
+
+
+@set_module('numpy.fft')
+def rfftfreq(n, d=1.0, device=None):
+    """
+    Return the Discrete Fourier Transform sample frequencies
+    (for usage with rfft, irfft).
+
+    The returned float array `f` contains the frequency bin centers in cycles
+    per unit of the sample spacing (with zero at the start).  For instance, if
+    the sample spacing is in seconds, then the frequency unit is cycles/second.
+
+    Given a window length `n` and a sample spacing `d`::
+
+      f = [0, 1, ...,     n/2-1,     n/2] / (d*n)   if n is even
+      f = [0, 1, ..., (n-1)/2-1, (n-1)/2] / (d*n)   if n is odd
+
+    Unlike `fftfreq` (but like `scipy.fftpack.rfftfreq`)
+    the Nyquist frequency component is considered to be positive.
+
+    Parameters
+    ----------
+    n : int
+        Window length.
+    d : scalar, optional
+        Sample spacing (inverse of the sampling rate). Defaults to 1.
+    device : str, optional
+        The device on which to place the created array. Default: ``None``.
+        For Array-API interoperability only, so must be ``"cpu"`` if passed.
+
+        .. versionadded:: 2.0.0
+
+    Returns
+    -------
+    f : ndarray
+        Array of length ``n//2 + 1`` containing the sample frequencies.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> signal = np.array([-2, 8, 6, 4, 1, 0, 3, 5, -3, 4], dtype=float)
+    >>> fourier = np.fft.rfft(signal)
+    >>> n = signal.size
+    >>> sample_rate = 100
+    >>> freq = np.fft.fftfreq(n, d=1./sample_rate)
+    >>> freq
+    array([  0.,  10.,  20., ..., -30., -20., -10.])
+    >>> freq = np.fft.rfftfreq(n, d=1./sample_rate)
+    >>> freq
+    array([  0.,  10.,  20.,  30.,  40.,  50.])
+
+    """
+    if not isinstance(n, integer_types):
+        raise ValueError("n should be an integer")
+    val = 1.0/(n*d)
+    N = n//2 + 1
+    results = arange(0, N, dtype=int, device=device)
+    return results * val
diff --git a/venv/lib/python3.12/site-packages/numpy/fft/_helper.pyi b/venv/lib/python3.12/site-packages/numpy/fft/_helper.pyi
new file mode 100644
index 00000000..a3c17fc6
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/fft/_helper.pyi
@@ -0,0 +1,51 @@
+from typing import Any, TypeVar, overload, Literal as L
+
+from numpy import generic, integer, floating, complexfloating
+from numpy._typing import (
+    NDArray,
+    ArrayLike,
+    _ShapeLike,
+    _ArrayLike,
+    _ArrayLikeFloat_co,
+    _ArrayLikeComplex_co,
+)
+
+_SCT = TypeVar("_SCT", bound=generic)
+
+__all__: list[str]
+
+@overload
+def fftshift(x: _ArrayLike[_SCT], axes: None | _ShapeLike = ...) -> NDArray[_SCT]: ...
+@overload
+def fftshift(x: ArrayLike, axes: None | _ShapeLike = ...) -> NDArray[Any]: ...
+
+@overload
+def ifftshift(x: _ArrayLike[_SCT], axes: None | _ShapeLike = ...) -> NDArray[_SCT]: ...
+@overload
+def ifftshift(x: ArrayLike, axes: None | _ShapeLike = ...) -> NDArray[Any]: ...
+
+@overload
+def fftfreq(
+    n: int | integer[Any],
+    d: _ArrayLikeFloat_co = ...,
+    device: None | L["cpu"] = ...,
+) -> NDArray[floating[Any]]: ...
+@overload
+def fftfreq(
+    n: int | integer[Any],
+    d: _ArrayLikeComplex_co = ...,
+    device: None | L["cpu"] = ...,
+) -> NDArray[complexfloating[Any, Any]]: ...
+
+@overload
+def rfftfreq(
+    n: int | integer[Any],
+    d: _ArrayLikeFloat_co = ...,
+    device: None | L["cpu"] = ...,
+) -> NDArray[floating[Any]]: ...
+@overload
+def rfftfreq(
+    n: int | integer[Any],
+    d: _ArrayLikeComplex_co = ...,
+    device: None | L["cpu"] = ...,
+) -> NDArray[complexfloating[Any, Any]]: ...
diff --git a/venv/lib/python3.12/site-packages/numpy/fft/_pocketfft.py b/venv/lib/python3.12/site-packages/numpy/fft/_pocketfft.py
new file mode 100644
index 00000000..4edeecc0
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/fft/_pocketfft.py
@@ -0,0 +1,1715 @@
+"""
+Discrete Fourier Transforms
+
+Routines in this module:
+
+fft(a, n=None, axis=-1, norm="backward")
+ifft(a, n=None, axis=-1, norm="backward")
+rfft(a, n=None, axis=-1, norm="backward")
+irfft(a, n=None, axis=-1, norm="backward")
+hfft(a, n=None, axis=-1, norm="backward")
+ihfft(a, n=None, axis=-1, norm="backward")
+fftn(a, s=None, axes=None, norm="backward")
+ifftn(a, s=None, axes=None, norm="backward")
+rfftn(a, s=None, axes=None, norm="backward")
+irfftn(a, s=None, axes=None, norm="backward")
+fft2(a, s=None, axes=(-2,-1), norm="backward")
+ifft2(a, s=None, axes=(-2, -1), norm="backward")
+rfft2(a, s=None, axes=(-2,-1), norm="backward")
+irfft2(a, s=None, axes=(-2, -1), norm="backward")
+
+i = inverse transform
+r = transform of purely real data
+h = Hermite transform
+n = n-dimensional transform
+2 = 2-dimensional transform
+(Note: 2D routines are just nD routines with different default
+behavior.)
+
+"""
+__all__ = ['fft', 'ifft', 'rfft', 'irfft', 'hfft', 'ihfft', 'rfftn',
+           'irfftn', 'rfft2', 'irfft2', 'fft2', 'ifft2', 'fftn', 'ifftn']
+
+import functools
+import warnings
+
+from numpy.lib.array_utils import normalize_axis_index
+from numpy._core import (asarray, empty_like, result_type,
+                         conjugate, take, sqrt, reciprocal)
+from . import _pocketfft_umath as pfu
+from numpy._core import overrides
+
+
+array_function_dispatch = functools.partial(
+    overrides.array_function_dispatch, module='numpy.fft')
+
+
+# `inv_norm` is a float by which the result of the transform needs to be
+# divided. This replaces the original, more intuitive 'fct` parameter to avoid
+# divisions by zero (or alternatively additional checks) in the case of
+# zero-length axes during its computation.
+def _raw_fft(a, n, axis, is_real, is_forward, norm, out=None):
+    if n < 1:
+        raise ValueError(f"Invalid number of FFT data points ({n}) specified.")
+
+    # Calculate the normalization factor, passing in the array dtype to
+    # avoid precision loss in the possible sqrt or reciprocal.
+    if not is_forward:
+        norm = _swap_direction(norm)
+
+    real_dtype = result_type(a.real.dtype, 1.0)
+    if norm is None or norm == "backward":
+        fct = 1
+    elif norm == "ortho":
+        fct = reciprocal(sqrt(n, dtype=real_dtype))
+    elif norm == "forward":
+        fct = reciprocal(n, dtype=real_dtype)
+    else:
+        raise ValueError(f'Invalid norm value {norm}; should be "backward",'
+                         '"ortho" or "forward".')
+
+    n_out = n
+    if is_real:
+        if is_forward:
+            ufunc = pfu.rfft_n_even if n % 2 == 0 else pfu.rfft_n_odd
+            n_out = n // 2 + 1
+        else:
+            ufunc = pfu.irfft
+    else:
+        ufunc = pfu.fft if is_forward else pfu.ifft
+
+    axis = normalize_axis_index(axis, a.ndim)
+
+    if out is None:
+        if is_real and not is_forward:  # irfft, complex in, real output.
+            out_dtype = real_dtype
+        else:  # Others, complex output.
+            out_dtype = result_type(a.dtype, 1j)
+        out = empty_like(a, shape=a.shape[:axis] + (n_out,) + a.shape[axis+1:],
+                         dtype=out_dtype)
+    elif ((shape := getattr(out, "shape", None)) is not None
+          and (len(shape) != a.ndim or shape[axis] != n_out)):
+        raise ValueError("output array has wrong shape.")
+
+    return ufunc(a, fct, axes=[(axis,), (), (axis,)], out=out)
+
+
+_SWAP_DIRECTION_MAP = {"backward": "forward", None: "forward",
+                       "ortho": "ortho", "forward": "backward"}
+
+
+def _swap_direction(norm):
+    try:
+        return _SWAP_DIRECTION_MAP[norm]
+    except KeyError:
+        raise ValueError(f'Invalid norm value {norm}; should be "backward", '
+                         '"ortho" or "forward".') from None
+
+
+def _fft_dispatcher(a, n=None, axis=None, norm=None, out=None):
+    return (a, out)
+
+
+@array_function_dispatch(_fft_dispatcher)
+def fft(a, n=None, axis=-1, norm=None, out=None):
+    """
+    Compute the one-dimensional discrete Fourier Transform.
+
+    This function computes the one-dimensional *n*-point discrete Fourier
+    Transform (DFT) with the efficient Fast Fourier Transform (FFT)
+    algorithm [CT].
+
+    Parameters
+    ----------
+    a : array_like
+        Input array, can be complex.
+    n : int, optional
+        Length of the transformed axis of the output.
+        If `n` is smaller than the length of the input, the input is cropped.
+        If it is larger, the input is padded with zeros.  If `n` is not given,
+        the length of the input along the axis specified by `axis` is used.
+    axis : int, optional
+        Axis over which to compute the FFT.  If not given, the last axis is
+        used.
+    norm : {"backward", "ortho", "forward"}, optional
+        .. versionadded:: 1.10.0
+
+        Normalization mode (see `numpy.fft`). Default is "backward".
+        Indicates which direction of the forward/backward pair of transforms
+        is scaled and with what normalization factor.
+
+        .. versionadded:: 1.20.0
+
+            The "backward", "forward" values were added.
+    out : complex ndarray, optional
+        If provided, the result will be placed in this array. It should be
+        of the appropriate shape and dtype.
+
+        .. versionadded:: 2.0.0
+
+    Returns
+    -------
+    out : complex ndarray
+        The truncated or zero-padded input, transformed along the axis
+        indicated by `axis`, or the last one if `axis` is not specified.
+
+    Raises
+    ------
+    IndexError
+        If `axis` is not a valid axis of `a`.
+
+    See Also
+    --------
+    numpy.fft : for definition of the DFT and conventions used.
+    ifft : The inverse of `fft`.
+    fft2 : The two-dimensional FFT.
+    fftn : The *n*-dimensional FFT.
+    rfftn : The *n*-dimensional FFT of real input.
+    fftfreq : Frequency bins for given FFT parameters.
+
+    Notes
+    -----
+    FFT (Fast Fourier Transform) refers to a way the discrete Fourier
+    Transform (DFT) can be calculated efficiently, by using symmetries in the
+    calculated terms.  The symmetry is highest when `n` is a power of 2, and
+    the transform is therefore most efficient for these sizes.
+
+    The DFT is defined, with the conventions used in this implementation, in
+    the documentation for the `numpy.fft` module.
+
+    References
+    ----------
+    .. [CT] Cooley, James W., and John W. Tukey, 1965, "An algorithm for the
+            machine calculation of complex Fourier series," *Math. Comput.*
+            19: 297-301.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> np.fft.fft(np.exp(2j * np.pi * np.arange(8) / 8))
+    array([-2.33486982e-16+1.14423775e-17j,  8.00000000e+00-1.25557246e-15j,
+            2.33486982e-16+2.33486982e-16j,  0.00000000e+00+1.22464680e-16j,
+           -1.14423775e-17+2.33486982e-16j,  0.00000000e+00+5.20784380e-16j,
+            1.14423775e-17+1.14423775e-17j,  0.00000000e+00+1.22464680e-16j])
+
+    In this example, real input has an FFT which is Hermitian, i.e., symmetric
+    in the real part and anti-symmetric in the imaginary part, as described in
+    the `numpy.fft` documentation:
+
+    >>> import matplotlib.pyplot as plt
+    >>> t = np.arange(256)
+    >>> sp = np.fft.fft(np.sin(t))
+    >>> freq = np.fft.fftfreq(t.shape[-1])
+    >>> plt.plot(freq, sp.real, freq, sp.imag)
+    [, ]
+    >>> plt.show()
+
+    """
+    a = asarray(a)
+    if n is None:
+        n = a.shape[axis]
+    output = _raw_fft(a, n, axis, False, True, norm, out)
+    return output
+
+
+@array_function_dispatch(_fft_dispatcher)
+def ifft(a, n=None, axis=-1, norm=None, out=None):
+    """
+    Compute the one-dimensional inverse discrete Fourier Transform.
+
+    This function computes the inverse of the one-dimensional *n*-point
+    discrete Fourier transform computed by `fft`.  In other words,
+    ``ifft(fft(a)) == a`` to within numerical accuracy.
+    For a general description of the algorithm and definitions,
+    see `numpy.fft`.
+
+    The input should be ordered in the same way as is returned by `fft`,
+    i.e.,
+
+    * ``a[0]`` should contain the zero frequency term,
+    * ``a[1:n//2]`` should contain the positive-frequency terms,
+    * ``a[n//2 + 1:]`` should contain the negative-frequency terms, in
+      increasing order starting from the most negative frequency.
+
+    For an even number of input points, ``A[n//2]`` represents the sum of
+    the values at the positive and negative Nyquist frequencies, as the two
+    are aliased together. See `numpy.fft` for details.
+
+    Parameters
+    ----------
+    a : array_like
+        Input array, can be complex.
+    n : int, optional
+        Length of the transformed axis of the output.
+        If `n` is smaller than the length of the input, the input is cropped.
+        If it is larger, the input is padded with zeros.  If `n` is not given,
+        the length of the input along the axis specified by `axis` is used.
+        See notes about padding issues.
+    axis : int, optional
+        Axis over which to compute the inverse DFT.  If not given, the last
+        axis is used.
+    norm : {"backward", "ortho", "forward"}, optional
+        .. versionadded:: 1.10.0
+
+        Normalization mode (see `numpy.fft`). Default is "backward".
+        Indicates which direction of the forward/backward pair of transforms
+        is scaled and with what normalization factor.
+
+        .. versionadded:: 1.20.0
+
+            The "backward", "forward" values were added.
+
+    out : complex ndarray, optional
+        If provided, the result will be placed in this array. It should be
+        of the appropriate shape and dtype.
+
+        .. versionadded:: 2.0.0
+
+    Returns
+    -------
+    out : complex ndarray
+        The truncated or zero-padded input, transformed along the axis
+        indicated by `axis`, or the last one if `axis` is not specified.
+
+    Raises
+    ------
+    IndexError
+        If `axis` is not a valid axis of `a`.
+
+    See Also
+    --------
+    numpy.fft : An introduction, with definitions and general explanations.
+    fft : The one-dimensional (forward) FFT, of which `ifft` is the inverse
+    ifft2 : The two-dimensional inverse FFT.
+    ifftn : The n-dimensional inverse FFT.
+
+    Notes
+    -----
+    If the input parameter `n` is larger than the size of the input, the input
+    is padded by appending zeros at the end.  Even though this is the common
+    approach, it might lead to surprising results.  If a different padding is
+    desired, it must be performed before calling `ifft`.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> np.fft.ifft([0, 4, 0, 0])
+    array([ 1.+0.j,  0.+1.j, -1.+0.j,  0.-1.j]) # may vary
+
+    Create and plot a band-limited signal with random phases:
+
+    >>> import matplotlib.pyplot as plt
+    >>> t = np.arange(400)
+    >>> n = np.zeros((400,), dtype=complex)
+    >>> n[40:60] = np.exp(1j*np.random.uniform(0, 2*np.pi, (20,)))
+    >>> s = np.fft.ifft(n)
+    >>> plt.plot(t, s.real, label='real')
+    []
+    >>> plt.plot(t, s.imag, '--', label='imaginary')
+    []
+    >>> plt.legend()
+    
+    >>> plt.show()
+
+    """
+    a = asarray(a)
+    if n is None:
+        n = a.shape[axis]
+    output = _raw_fft(a, n, axis, False, False, norm, out=out)
+    return output
+
+
+@array_function_dispatch(_fft_dispatcher)
+def rfft(a, n=None, axis=-1, norm=None, out=None):
+    """
+    Compute the one-dimensional discrete Fourier Transform for real input.
+
+    This function computes the one-dimensional *n*-point discrete Fourier
+    Transform (DFT) of a real-valued array by means of an efficient algorithm
+    called the Fast Fourier Transform (FFT).
+
+    Parameters
+    ----------
+    a : array_like
+        Input array
+    n : int, optional
+        Number of points along transformation axis in the input to use.
+        If `n` is smaller than the length of the input, the input is cropped.
+        If it is larger, the input is padded with zeros. If `n` is not given,
+        the length of the input along the axis specified by `axis` is used.
+    axis : int, optional
+        Axis over which to compute the FFT. If not given, the last axis is
+        used.
+    norm : {"backward", "ortho", "forward"}, optional
+        .. versionadded:: 1.10.0
+
+        Normalization mode (see `numpy.fft`). Default is "backward".
+        Indicates which direction of the forward/backward pair of transforms
+        is scaled and with what normalization factor.
+
+        .. versionadded:: 1.20.0
+
+            The "backward", "forward" values were added.
+
+    out : complex ndarray, optional
+        If provided, the result will be placed in this array. It should be
+        of the appropriate shape and dtype.
+
+        .. versionadded:: 2.0.0
+
+    Returns
+    -------
+    out : complex ndarray
+        The truncated or zero-padded input, transformed along the axis
+        indicated by `axis`, or the last one if `axis` is not specified.
+        If `n` is even, the length of the transformed axis is ``(n/2)+1``.
+        If `n` is odd, the length is ``(n+1)/2``.
+
+    Raises
+    ------
+    IndexError
+        If `axis` is not a valid axis of `a`.
+
+    See Also
+    --------
+    numpy.fft : For definition of the DFT and conventions used.
+    irfft : The inverse of `rfft`.
+    fft : The one-dimensional FFT of general (complex) input.
+    fftn : The *n*-dimensional FFT.
+    rfftn : The *n*-dimensional FFT of real input.
+
+    Notes
+    -----
+    When the DFT is computed for purely real input, the output is
+    Hermitian-symmetric, i.e. the negative frequency terms are just the complex
+    conjugates of the corresponding positive-frequency terms, and the
+    negative-frequency terms are therefore redundant.  This function does not
+    compute the negative frequency terms, and the length of the transformed
+    axis of the output is therefore ``n//2 + 1``.
+
+    When ``A = rfft(a)`` and fs is the sampling frequency, ``A[0]`` contains
+    the zero-frequency term 0*fs, which is real due to Hermitian symmetry.
+
+    If `n` is even, ``A[-1]`` contains the term representing both positive
+    and negative Nyquist frequency (+fs/2 and -fs/2), and must also be purely
+    real. If `n` is odd, there is no term at fs/2; ``A[-1]`` contains
+    the largest positive frequency (fs/2*(n-1)/n), and is complex in the
+    general case.
+
+    If the input `a` contains an imaginary part, it is silently discarded.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> np.fft.fft([0, 1, 0, 0])
+    array([ 1.+0.j,  0.-1.j, -1.+0.j,  0.+1.j]) # may vary
+    >>> np.fft.rfft([0, 1, 0, 0])
+    array([ 1.+0.j,  0.-1.j, -1.+0.j]) # may vary
+
+    Notice how the final element of the `fft` output is the complex conjugate
+    of the second element, for real input. For `rfft`, this symmetry is
+    exploited to compute only the non-negative frequency terms.
+
+    """
+    a = asarray(a)
+    if n is None:
+        n = a.shape[axis]
+    output = _raw_fft(a, n, axis, True, True, norm, out=out)
+    return output
+
+
+@array_function_dispatch(_fft_dispatcher)
+def irfft(a, n=None, axis=-1, norm=None, out=None):
+    """
+    Computes the inverse of `rfft`.
+
+    This function computes the inverse of the one-dimensional *n*-point
+    discrete Fourier Transform of real input computed by `rfft`.
+    In other words, ``irfft(rfft(a), len(a)) == a`` to within numerical
+    accuracy. (See Notes below for why ``len(a)`` is necessary here.)
+
+    The input is expected to be in the form returned by `rfft`, i.e. the
+    real zero-frequency term followed by the complex positive frequency terms
+    in order of increasing frequency.  Since the discrete Fourier Transform of
+    real input is Hermitian-symmetric, the negative frequency terms are taken
+    to be the complex conjugates of the corresponding positive frequency terms.
+
+    Parameters
+    ----------
+    a : array_like
+        The input array.
+    n : int, optional
+        Length of the transformed axis of the output.
+        For `n` output points, ``n//2+1`` input points are necessary.  If the
+        input is longer than this, it is cropped.  If it is shorter than this,
+        it is padded with zeros.  If `n` is not given, it is taken to be
+        ``2*(m-1)`` where ``m`` is the length of the input along the axis
+        specified by `axis`.
+    axis : int, optional
+        Axis over which to compute the inverse FFT. If not given, the last
+        axis is used.
+    norm : {"backward", "ortho", "forward"}, optional
+        .. versionadded:: 1.10.0
+
+        Normalization mode (see `numpy.fft`). Default is "backward".
+        Indicates which direction of the forward/backward pair of transforms
+        is scaled and with what normalization factor.
+
+        .. versionadded:: 1.20.0
+
+            The "backward", "forward" values were added.
+
+    out : ndarray, optional
+        If provided, the result will be placed in this array. It should be
+        of the appropriate shape and dtype.
+
+        .. versionadded:: 2.0.0
+
+    Returns
+    -------
+    out : ndarray
+        The truncated or zero-padded input, transformed along the axis
+        indicated by `axis`, or the last one if `axis` is not specified.
+        The length of the transformed axis is `n`, or, if `n` is not given,
+        ``2*(m-1)`` where ``m`` is the length of the transformed axis of the
+        input. To get an odd number of output points, `n` must be specified.
+
+    Raises
+    ------
+    IndexError
+        If `axis` is not a valid axis of `a`.
+
+    See Also
+    --------
+    numpy.fft : For definition of the DFT and conventions used.
+    rfft : The one-dimensional FFT of real input, of which `irfft` is inverse.
+    fft : The one-dimensional FFT.
+    irfft2 : The inverse of the two-dimensional FFT of real input.
+    irfftn : The inverse of the *n*-dimensional FFT of real input.
+
+    Notes
+    -----
+    Returns the real valued `n`-point inverse discrete Fourier transform
+    of `a`, where `a` contains the non-negative frequency terms of a
+    Hermitian-symmetric sequence. `n` is the length of the result, not the
+    input.
+
+    If you specify an `n` such that `a` must be zero-padded or truncated, the
+    extra/removed values will be added/removed at high frequencies. One can
+    thus resample a series to `m` points via Fourier interpolation by:
+    ``a_resamp = irfft(rfft(a), m)``.
+
+    The correct interpretation of the hermitian input depends on the length of
+    the original data, as given by `n`. This is because each input shape could
+    correspond to either an odd or even length signal. By default, `irfft`
+    assumes an even output length which puts the last entry at the Nyquist
+    frequency; aliasing with its symmetric counterpart. By Hermitian symmetry,
+    the value is thus treated as purely real. To avoid losing information, the
+    correct length of the real input **must** be given.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> np.fft.ifft([1, -1j, -1, 1j])
+    array([0.+0.j,  1.+0.j,  0.+0.j,  0.+0.j]) # may vary
+    >>> np.fft.irfft([1, -1j, -1])
+    array([0.,  1.,  0.,  0.])
+
+    Notice how the last term in the input to the ordinary `ifft` is the
+    complex conjugate of the second term, and the output has zero imaginary
+    part everywhere.  When calling `irfft`, the negative frequencies are not
+    specified, and the output array is purely real.
+
+    """
+    a = asarray(a)
+    if n is None:
+        n = (a.shape[axis] - 1) * 2
+    output = _raw_fft(a, n, axis, True, False, norm, out=out)
+    return output
+
+
+@array_function_dispatch(_fft_dispatcher)
+def hfft(a, n=None, axis=-1, norm=None, out=None):
+    """
+    Compute the FFT of a signal that has Hermitian symmetry, i.e., a real
+    spectrum.
+
+    Parameters
+    ----------
+    a : array_like
+        The input array.
+    n : int, optional
+        Length of the transformed axis of the output. For `n` output
+        points, ``n//2 + 1`` input points are necessary.  If the input is
+        longer than this, it is cropped.  If it is shorter than this, it is
+        padded with zeros.  If `n` is not given, it is taken to be ``2*(m-1)``
+        where ``m`` is the length of the input along the axis specified by
+        `axis`.
+    axis : int, optional
+        Axis over which to compute the FFT. If not given, the last
+        axis is used.
+    norm : {"backward", "ortho", "forward"}, optional
+        .. versionadded:: 1.10.0
+
+        Normalization mode (see `numpy.fft`). Default is "backward".
+        Indicates which direction of the forward/backward pair of transforms
+        is scaled and with what normalization factor.
+
+        .. versionadded:: 1.20.0
+
+            The "backward", "forward" values were added.
+
+    out : ndarray, optional
+        If provided, the result will be placed in this array. It should be
+        of the appropriate shape and dtype.
+
+        .. versionadded:: 2.0.0
+
+    Returns
+    -------
+    out : ndarray
+        The truncated or zero-padded input, transformed along the axis
+        indicated by `axis`, or the last one if `axis` is not specified.
+        The length of the transformed axis is `n`, or, if `n` is not given,
+        ``2*m - 2`` where ``m`` is the length of the transformed axis of
+        the input. To get an odd number of output points, `n` must be
+        specified, for instance as ``2*m - 1`` in the typical case,
+
+    Raises
+    ------
+    IndexError
+        If `axis` is not a valid axis of `a`.
+
+    See also
+    --------
+    rfft : Compute the one-dimensional FFT for real input.
+    ihfft : The inverse of `hfft`.
+
+    Notes
+    -----
+    `hfft`/`ihfft` are a pair analogous to `rfft`/`irfft`, but for the
+    opposite case: here the signal has Hermitian symmetry in the time
+    domain and is real in the frequency domain. So here it's `hfft` for
+    which you must supply the length of the result if it is to be odd.
+
+    * even: ``ihfft(hfft(a, 2*len(a) - 2)) == a``, within roundoff error,
+    * odd: ``ihfft(hfft(a, 2*len(a) - 1)) == a``, within roundoff error.
+
+    The correct interpretation of the hermitian input depends on the length of
+    the original data, as given by `n`. This is because each input shape could
+    correspond to either an odd or even length signal. By default, `hfft`
+    assumes an even output length which puts the last entry at the Nyquist
+    frequency; aliasing with its symmetric counterpart. By Hermitian symmetry,
+    the value is thus treated as purely real. To avoid losing information, the
+    shape of the full signal **must** be given.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> signal = np.array([1, 2, 3, 4, 3, 2])
+    >>> np.fft.fft(signal)
+    array([15.+0.j,  -4.+0.j,   0.+0.j,  -1.-0.j,   0.+0.j,  -4.+0.j]) # may vary
+    >>> np.fft.hfft(signal[:4]) # Input first half of signal
+    array([15.,  -4.,   0.,  -1.,   0.,  -4.])
+    >>> np.fft.hfft(signal, 6)  # Input entire signal and truncate
+    array([15.,  -4.,   0.,  -1.,   0.,  -4.])
+
+
+    >>> signal = np.array([[1, 1.j], [-1.j, 2]])
+    >>> np.conj(signal.T) - signal   # check Hermitian symmetry
+    array([[ 0.-0.j,  -0.+0.j], # may vary
+           [ 0.+0.j,  0.-0.j]])
+    >>> freq_spectrum = np.fft.hfft(signal)
+    >>> freq_spectrum
+    array([[ 1.,  1.],
+           [ 2., -2.]])
+
+    """
+    a = asarray(a)
+    if n is None:
+        n = (a.shape[axis] - 1) * 2
+    new_norm = _swap_direction(norm)
+    output = irfft(conjugate(a), n, axis, norm=new_norm, out=None)
+    return output
+
+
+@array_function_dispatch(_fft_dispatcher)
+def ihfft(a, n=None, axis=-1, norm=None, out=None):
+    """
+    Compute the inverse FFT of a signal that has Hermitian symmetry.
+
+    Parameters
+    ----------
+    a : array_like
+        Input array.
+    n : int, optional
+        Length of the inverse FFT, the number of points along
+        transformation axis in the input to use.  If `n` is smaller than
+        the length of the input, the input is cropped.  If it is larger,
+        the input is padded with zeros. If `n` is not given, the length of
+        the input along the axis specified by `axis` is used.
+    axis : int, optional
+        Axis over which to compute the inverse FFT. If not given, the last
+        axis is used.
+    norm : {"backward", "ortho", "forward"}, optional
+        .. versionadded:: 1.10.0
+
+        Normalization mode (see `numpy.fft`). Default is "backward".
+        Indicates which direction of the forward/backward pair of transforms
+        is scaled and with what normalization factor.
+
+        .. versionadded:: 1.20.0
+
+            The "backward", "forward" values were added.
+
+    out : complex ndarray, optional
+        If provided, the result will be placed in this array. It should be
+        of the appropriate shape and dtype.
+
+        .. versionadded:: 2.0.0
+
+    Returns
+    -------
+    out : complex ndarray
+        The truncated or zero-padded input, transformed along the axis
+        indicated by `axis`, or the last one if `axis` is not specified.
+        The length of the transformed axis is ``n//2 + 1``.
+
+    See also
+    --------
+    hfft, irfft
+
+    Notes
+    -----
+    `hfft`/`ihfft` are a pair analogous to `rfft`/`irfft`, but for the
+    opposite case: here the signal has Hermitian symmetry in the time
+    domain and is real in the frequency domain. So here it's `hfft` for
+    which you must supply the length of the result if it is to be odd:
+
+    * even: ``ihfft(hfft(a, 2*len(a) - 2)) == a``, within roundoff error,
+    * odd: ``ihfft(hfft(a, 2*len(a) - 1)) == a``, within roundoff error.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> spectrum = np.array([ 15, -4, 0, -1, 0, -4])
+    >>> np.fft.ifft(spectrum)
+    array([1.+0.j,  2.+0.j,  3.+0.j,  4.+0.j,  3.+0.j,  2.+0.j]) # may vary
+    >>> np.fft.ihfft(spectrum)
+    array([ 1.-0.j,  2.-0.j,  3.-0.j,  4.-0.j]) # may vary
+
+    """
+    a = asarray(a)
+    if n is None:
+        n = a.shape[axis]
+    new_norm = _swap_direction(norm)
+    out = rfft(a, n, axis, norm=new_norm, out=out)
+    return conjugate(out, out=out)
+
+
+def _cook_nd_args(a, s=None, axes=None, invreal=0):
+    if s is None:
+        shapeless = True
+        if axes is None:
+            s = list(a.shape)
+        else:
+            s = take(a.shape, axes)
+    else:
+        shapeless = False
+    s = list(s)
+    if axes is None:
+        if not shapeless:
+            msg = ("`axes` should not be `None` if `s` is not `None` "
+                   "(Deprecated in NumPy 2.0). In a future version of NumPy, "
+                   "this will raise an error and `s[i]` will correspond to "
+                   "the size along the transformed axis specified by "
+                   "`axes[i]`. To retain current behaviour, pass a sequence "
+                   "[0, ..., k-1] to `axes` for an array of dimension k.")
+            warnings.warn(msg, DeprecationWarning, stacklevel=3)
+        axes = list(range(-len(s), 0))
+    if len(s) != len(axes):
+        raise ValueError("Shape and axes have different lengths.")
+    if invreal and shapeless:
+        s[-1] = (a.shape[axes[-1]] - 1) * 2
+    if None in s:
+        msg = ("Passing an array containing `None` values to `s` is "
+               "deprecated in NumPy 2.0 and will raise an error in "
+               "a future version of NumPy. To use the default behaviour "
+               "of the corresponding 1-D transform, pass the value matching "
+               "the default for its `n` parameter. To use the default "
+               "behaviour for every axis, the `s` argument can be omitted.")
+        warnings.warn(msg, DeprecationWarning, stacklevel=3)
+    # use the whole input array along axis `i` if `s[i] == -1`
+    s = [a.shape[_a] if _s == -1 else _s for _s, _a in zip(s, axes)]
+    return s, axes
+
+
+def _raw_fftnd(a, s=None, axes=None, function=fft, norm=None, out=None):
+    a = asarray(a)
+    s, axes = _cook_nd_args(a, s, axes)
+    itl = list(range(len(axes)))
+    itl.reverse()
+    for ii in itl:
+        a = function(a, n=s[ii], axis=axes[ii], norm=norm, out=out)
+    return a
+
+
+def _fftn_dispatcher(a, s=None, axes=None, norm=None, out=None):
+    return (a, out)
+
+
+@array_function_dispatch(_fftn_dispatcher)
+def fftn(a, s=None, axes=None, norm=None, out=None):
+    """
+    Compute the N-dimensional discrete Fourier Transform.
+
+    This function computes the *N*-dimensional discrete Fourier Transform over
+    any number of axes in an *M*-dimensional array by means of the Fast Fourier
+    Transform (FFT).
+
+    Parameters
+    ----------
+    a : array_like
+        Input array, can be complex.
+    s : sequence of ints, optional
+        Shape (length of each transformed axis) of the output
+        (``s[0]`` refers to axis 0, ``s[1]`` to axis 1, etc.).
+        This corresponds to ``n`` for ``fft(x, n)``.
+        Along any axis, if the given shape is smaller than that of the input,
+        the input is cropped. If it is larger, the input is padded with zeros.
+
+        .. versionchanged:: 2.0
+
+            If it is ``-1``, the whole input is used (no padding/trimming).
+
+        If `s` is not given, the shape of the input along the axes specified
+        by `axes` is used.
+
+        .. deprecated:: 2.0
+
+            If `s` is not ``None``, `axes` must not be ``None`` either.
+
+        .. deprecated:: 2.0
+
+            `s` must contain only ``int`` s, not ``None`` values. ``None``
+            values currently mean that the default value for ``n`` is used
+            in the corresponding 1-D transform, but this behaviour is
+            deprecated.
+
+    axes : sequence of ints, optional
+        Axes over which to compute the FFT.  If not given, the last ``len(s)``
+        axes are used, or all axes if `s` is also not specified.
+        Repeated indices in `axes` means that the transform over that axis is
+        performed multiple times.
+
+        .. deprecated:: 2.0
+
+            If `s` is specified, the corresponding `axes` to be transformed
+            must be explicitly specified too.
+
+    norm : {"backward", "ortho", "forward"}, optional
+        .. versionadded:: 1.10.0
+
+        Normalization mode (see `numpy.fft`). Default is "backward".
+        Indicates which direction of the forward/backward pair of transforms
+        is scaled and with what normalization factor.
+
+        .. versionadded:: 1.20.0
+
+            The "backward", "forward" values were added.
+
+    out : complex ndarray, optional
+        If provided, the result will be placed in this array. It should be
+        of the appropriate shape and dtype for all axes (and hence is
+        incompatible with passing in all but the trivial ``s``).
+
+        .. versionadded:: 2.0.0
+
+    Returns
+    -------
+    out : complex ndarray
+        The truncated or zero-padded input, transformed along the axes
+        indicated by `axes`, or by a combination of `s` and `a`,
+        as explained in the parameters section above.
+
+    Raises
+    ------
+    ValueError
+        If `s` and `axes` have different length.
+    IndexError
+        If an element of `axes` is larger than than the number of axes of `a`.
+
+    See Also
+    --------
+    numpy.fft : Overall view of discrete Fourier transforms, with definitions
+        and conventions used.
+    ifftn : The inverse of `fftn`, the inverse *n*-dimensional FFT.
+    fft : The one-dimensional FFT, with definitions and conventions used.
+    rfftn : The *n*-dimensional FFT of real input.
+    fft2 : The two-dimensional FFT.
+    fftshift : Shifts zero-frequency terms to centre of array
+
+    Notes
+    -----
+    The output, analogously to `fft`, contains the term for zero frequency in
+    the low-order corner of all axes, the positive frequency terms in the
+    first half of all axes, the term for the Nyquist frequency in the middle
+    of all axes and the negative frequency terms in the second half of all
+    axes, in order of decreasingly negative frequency.
+
+    See `numpy.fft` for details, definitions and conventions used.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> a = np.mgrid[:3, :3, :3][0]
+    >>> np.fft.fftn(a, axes=(1, 2))
+    array([[[ 0.+0.j,   0.+0.j,   0.+0.j], # may vary
+            [ 0.+0.j,   0.+0.j,   0.+0.j],
+            [ 0.+0.j,   0.+0.j,   0.+0.j]],
+           [[ 9.+0.j,   0.+0.j,   0.+0.j],
+            [ 0.+0.j,   0.+0.j,   0.+0.j],
+            [ 0.+0.j,   0.+0.j,   0.+0.j]],
+           [[18.+0.j,   0.+0.j,   0.+0.j],
+            [ 0.+0.j,   0.+0.j,   0.+0.j],
+            [ 0.+0.j,   0.+0.j,   0.+0.j]]])
+    >>> np.fft.fftn(a, (2, 2), axes=(0, 1))
+    array([[[ 2.+0.j,  2.+0.j,  2.+0.j], # may vary
+            [ 0.+0.j,  0.+0.j,  0.+0.j]],
+           [[-2.+0.j, -2.+0.j, -2.+0.j],
+            [ 0.+0.j,  0.+0.j,  0.+0.j]]])
+
+    >>> import matplotlib.pyplot as plt
+    >>> [X, Y] = np.meshgrid(2 * np.pi * np.arange(200) / 12,
+    ...                      2 * np.pi * np.arange(200) / 34)
+    >>> S = np.sin(X) + np.cos(Y) + np.random.uniform(0, 1, X.shape)
+    >>> FS = np.fft.fftn(S)
+    >>> plt.imshow(np.log(np.abs(np.fft.fftshift(FS))**2))
+    
+    >>> plt.show()
+
+    """
+    return _raw_fftnd(a, s, axes, fft, norm, out=out)
+
+
+@array_function_dispatch(_fftn_dispatcher)
+def ifftn(a, s=None, axes=None, norm=None, out=None):
+    """
+    Compute the N-dimensional inverse discrete Fourier Transform.
+
+    This function computes the inverse of the N-dimensional discrete
+    Fourier Transform over any number of axes in an M-dimensional array by
+    means of the Fast Fourier Transform (FFT).  In other words,
+    ``ifftn(fftn(a)) == a`` to within numerical accuracy.
+    For a description of the definitions and conventions used, see `numpy.fft`.
+
+    The input, analogously to `ifft`, should be ordered in the same way as is
+    returned by `fftn`, i.e. it should have the term for zero frequency
+    in all axes in the low-order corner, the positive frequency terms in the
+    first half of all axes, the term for the Nyquist frequency in the middle
+    of all axes and the negative frequency terms in the second half of all
+    axes, in order of decreasingly negative frequency.
+
+    Parameters
+    ----------
+    a : array_like
+        Input array, can be complex.
+    s : sequence of ints, optional
+        Shape (length of each transformed axis) of the output
+        (``s[0]`` refers to axis 0, ``s[1]`` to axis 1, etc.).
+        This corresponds to ``n`` for ``ifft(x, n)``.
+        Along any axis, if the given shape is smaller than that of the input,
+        the input is cropped. If it is larger, the input is padded with zeros.
+
+        .. versionchanged:: 2.0
+
+            If it is ``-1``, the whole input is used (no padding/trimming).
+
+        If `s` is not given, the shape of the input along the axes specified
+        by `axes` is used. See notes for issue on `ifft` zero padding.
+
+        .. deprecated:: 2.0
+
+            If `s` is not ``None``, `axes` must not be ``None`` either.
+
+        .. deprecated:: 2.0
+
+            `s` must contain only ``int`` s, not ``None`` values. ``None``
+            values currently mean that the default value for ``n`` is used
+            in the corresponding 1-D transform, but this behaviour is
+            deprecated.
+
+    axes : sequence of ints, optional
+        Axes over which to compute the IFFT.  If not given, the last ``len(s)``
+        axes are used, or all axes if `s` is also not specified.
+        Repeated indices in `axes` means that the inverse transform over that
+        axis is performed multiple times.
+
+        .. deprecated:: 2.0
+
+            If `s` is specified, the corresponding `axes` to be transformed
+            must be explicitly specified too.
+
+    norm : {"backward", "ortho", "forward"}, optional
+        .. versionadded:: 1.10.0
+
+        Normalization mode (see `numpy.fft`). Default is "backward".
+        Indicates which direction of the forward/backward pair of transforms
+        is scaled and with what normalization factor.
+
+        .. versionadded:: 1.20.0
+
+            The "backward", "forward" values were added.
+
+    out : complex ndarray, optional
+        If provided, the result will be placed in this array. It should be
+        of the appropriate shape and dtype for all axes (and hence is
+        incompatible with passing in all but the trivial ``s``).
+
+        .. versionadded:: 2.0.0
+
+    Returns
+    -------
+    out : complex ndarray
+        The truncated or zero-padded input, transformed along the axes
+        indicated by `axes`, or by a combination of `s` or `a`,
+        as explained in the parameters section above.
+
+    Raises
+    ------
+    ValueError
+        If `s` and `axes` have different length.
+    IndexError
+        If an element of `axes` is larger than than the number of axes of `a`.
+
+    See Also
+    --------
+    numpy.fft : Overall view of discrete Fourier transforms, with definitions
+         and conventions used.
+    fftn : The forward *n*-dimensional FFT, of which `ifftn` is the inverse.
+    ifft : The one-dimensional inverse FFT.
+    ifft2 : The two-dimensional inverse FFT.
+    ifftshift : Undoes `fftshift`, shifts zero-frequency terms to beginning
+        of array.
+
+    Notes
+    -----
+    See `numpy.fft` for definitions and conventions used.
+
+    Zero-padding, analogously with `ifft`, is performed by appending zeros to
+    the input along the specified dimension.  Although this is the common
+    approach, it might lead to surprising results.  If another form of zero
+    padding is desired, it must be performed before `ifftn` is called.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> a = np.eye(4)
+    >>> np.fft.ifftn(np.fft.fftn(a, axes=(0,)), axes=(1,))
+    array([[1.+0.j,  0.+0.j,  0.+0.j,  0.+0.j], # may vary
+           [0.+0.j,  1.+0.j,  0.+0.j,  0.+0.j],
+           [0.+0.j,  0.+0.j,  1.+0.j,  0.+0.j],
+           [0.+0.j,  0.+0.j,  0.+0.j,  1.+0.j]])
+
+
+    Create and plot an image with band-limited frequency content:
+
+    >>> import matplotlib.pyplot as plt
+    >>> n = np.zeros((200,200), dtype=complex)
+    >>> n[60:80, 20:40] = np.exp(1j*np.random.uniform(0, 2*np.pi, (20, 20)))
+    >>> im = np.fft.ifftn(n).real
+    >>> plt.imshow(im)
+    
+    >>> plt.show()
+
+    """
+    return _raw_fftnd(a, s, axes, ifft, norm, out=out)
+
+
+@array_function_dispatch(_fftn_dispatcher)
+def fft2(a, s=None, axes=(-2, -1), norm=None, out=None):
+    """
+    Compute the 2-dimensional discrete Fourier Transform.
+
+    This function computes the *n*-dimensional discrete Fourier Transform
+    over any axes in an *M*-dimensional array by means of the
+    Fast Fourier Transform (FFT).  By default, the transform is computed over
+    the last two axes of the input array, i.e., a 2-dimensional FFT.
+
+    Parameters
+    ----------
+    a : array_like
+        Input array, can be complex
+    s : sequence of ints, optional
+        Shape (length of each transformed axis) of the output
+        (``s[0]`` refers to axis 0, ``s[1]`` to axis 1, etc.).
+        This corresponds to ``n`` for ``fft(x, n)``.
+        Along each axis, if the given shape is smaller than that of the input,
+        the input is cropped. If it is larger, the input is padded with zeros.
+
+        .. versionchanged:: 2.0
+
+            If it is ``-1``, the whole input is used (no padding/trimming).
+
+        If `s` is not given, the shape of the input along the axes specified
+        by `axes` is used.
+
+        .. deprecated:: 2.0
+
+            If `s` is not ``None``, `axes` must not be ``None`` either.
+
+        .. deprecated:: 2.0
+
+            `s` must contain only ``int`` s, not ``None`` values. ``None``
+            values currently mean that the default value for ``n`` is used
+            in the corresponding 1-D transform, but this behaviour is
+            deprecated.
+
+    axes : sequence of ints, optional
+        Axes over which to compute the FFT.  If not given, the last two
+        axes are used.  A repeated index in `axes` means the transform over
+        that axis is performed multiple times.  A one-element sequence means
+        that a one-dimensional FFT is performed. Default: ``(-2, -1)``.
+
+        .. deprecated:: 2.0
+
+            If `s` is specified, the corresponding `axes` to be transformed
+            must not be ``None``.
+
+    norm : {"backward", "ortho", "forward"}, optional
+        .. versionadded:: 1.10.0
+
+        Normalization mode (see `numpy.fft`). Default is "backward".
+        Indicates which direction of the forward/backward pair of transforms
+        is scaled and with what normalization factor.
+
+        .. versionadded:: 1.20.0
+
+            The "backward", "forward" values were added.
+
+    out : complex ndarray, optional
+        If provided, the result will be placed in this array. It should be
+        of the appropriate shape and dtype for all axes (and hence only the
+        last axis can have ``s`` not equal to the shape at that axis).
+
+        .. versionadded:: 2.0.0
+
+    Returns
+    -------
+    out : complex ndarray
+        The truncated or zero-padded input, transformed along the axes
+        indicated by `axes`, or the last two axes if `axes` is not given.
+
+    Raises
+    ------
+    ValueError
+        If `s` and `axes` have different length, or `axes` not given and
+        ``len(s) != 2``.
+    IndexError
+        If an element of `axes` is larger than than the number of axes of `a`.
+
+    See Also
+    --------
+    numpy.fft : Overall view of discrete Fourier transforms, with definitions
+         and conventions used.
+    ifft2 : The inverse two-dimensional FFT.
+    fft : The one-dimensional FFT.
+    fftn : The *n*-dimensional FFT.
+    fftshift : Shifts zero-frequency terms to the center of the array.
+        For two-dimensional input, swaps first and third quadrants, and second
+        and fourth quadrants.
+
+    Notes
+    -----
+    `fft2` is just `fftn` with a different default for `axes`.
+
+    The output, analogously to `fft`, contains the term for zero frequency in
+    the low-order corner of the transformed axes, the positive frequency terms
+    in the first half of these axes, the term for the Nyquist frequency in the
+    middle of the axes and the negative frequency terms in the second half of
+    the axes, in order of decreasingly negative frequency.
+
+    See `fftn` for details and a plotting example, and `numpy.fft` for
+    definitions and conventions used.
+
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> a = np.mgrid[:5, :5][0]
+    >>> np.fft.fft2(a)
+    array([[ 50.  +0.j        ,   0.  +0.j        ,   0.  +0.j        , # may vary
+              0.  +0.j        ,   0.  +0.j        ],
+           [-12.5+17.20477401j,   0.  +0.j        ,   0.  +0.j        ,
+              0.  +0.j        ,   0.  +0.j        ],
+           [-12.5 +4.0614962j ,   0.  +0.j        ,   0.  +0.j        ,
+              0.  +0.j        ,   0.  +0.j        ],
+           [-12.5 -4.0614962j ,   0.  +0.j        ,   0.  +0.j        ,
+              0.  +0.j        ,   0.  +0.j        ],
+           [-12.5-17.20477401j,   0.  +0.j        ,   0.  +0.j        ,
+              0.  +0.j        ,   0.  +0.j        ]])
+
+    """
+    return _raw_fftnd(a, s, axes, fft, norm, out=out)
+
+
+@array_function_dispatch(_fftn_dispatcher)
+def ifft2(a, s=None, axes=(-2, -1), norm=None, out=None):
+    """
+    Compute the 2-dimensional inverse discrete Fourier Transform.
+
+    This function computes the inverse of the 2-dimensional discrete Fourier
+    Transform over any number of axes in an M-dimensional array by means of
+    the Fast Fourier Transform (FFT).  In other words, ``ifft2(fft2(a)) == a``
+    to within numerical accuracy.  By default, the inverse transform is
+    computed over the last two axes of the input array.
+
+    The input, analogously to `ifft`, should be ordered in the same way as is
+    returned by `fft2`, i.e. it should have the term for zero frequency
+    in the low-order corner of the two axes, the positive frequency terms in
+    the first half of these axes, the term for the Nyquist frequency in the
+    middle of the axes and the negative frequency terms in the second half of
+    both axes, in order of decreasingly negative frequency.
+
+    Parameters
+    ----------
+    a : array_like
+        Input array, can be complex.
+    s : sequence of ints, optional
+        Shape (length of each axis) of the output (``s[0]`` refers to axis 0,
+        ``s[1]`` to axis 1, etc.).  This corresponds to `n` for ``ifft(x, n)``.
+        Along each axis, if the given shape is smaller than that of the input,
+        the input is cropped. If it is larger, the input is padded with zeros.
+
+        .. versionchanged:: 2.0
+
+            If it is ``-1``, the whole input is used (no padding/trimming).
+
+        If `s` is not given, the shape of the input along the axes specified
+        by `axes` is used.  See notes for issue on `ifft` zero padding.
+
+        .. deprecated:: 2.0
+
+            If `s` is not ``None``, `axes` must not be ``None`` either.
+
+        .. deprecated:: 2.0
+
+            `s` must contain only ``int`` s, not ``None`` values. ``None``
+            values currently mean that the default value for ``n`` is used
+            in the corresponding 1-D transform, but this behaviour is
+            deprecated.
+
+    axes : sequence of ints, optional
+        Axes over which to compute the FFT.  If not given, the last two
+        axes are used.  A repeated index in `axes` means the transform over
+        that axis is performed multiple times.  A one-element sequence means
+        that a one-dimensional FFT is performed. Default: ``(-2, -1)``.
+
+        .. deprecated:: 2.0
+
+            If `s` is specified, the corresponding `axes` to be transformed
+            must not be ``None``.
+
+    norm : {"backward", "ortho", "forward"}, optional
+        .. versionadded:: 1.10.0
+
+        Normalization mode (see `numpy.fft`). Default is "backward".
+        Indicates which direction of the forward/backward pair of transforms
+        is scaled and with what normalization factor.
+
+        .. versionadded:: 1.20.0
+
+            The "backward", "forward" values were added.
+
+    out : complex ndarray, optional
+        If provided, the result will be placed in this array. It should be
+        of the appropriate shape and dtype for all axes (and hence is
+        incompatible with passing in all but the trivial ``s``).
+
+        .. versionadded:: 2.0.0
+
+    Returns
+    -------
+    out : complex ndarray
+        The truncated or zero-padded input, transformed along the axes
+        indicated by `axes`, or the last two axes if `axes` is not given.
+
+    Raises
+    ------
+    ValueError
+        If `s` and `axes` have different length, or `axes` not given and
+        ``len(s) != 2``.
+    IndexError
+        If an element of `axes` is larger than than the number of axes of `a`.
+
+    See Also
+    --------
+    numpy.fft : Overall view of discrete Fourier transforms, with definitions
+         and conventions used.
+    fft2 : The forward 2-dimensional FFT, of which `ifft2` is the inverse.
+    ifftn : The inverse of the *n*-dimensional FFT.
+    fft : The one-dimensional FFT.
+    ifft : The one-dimensional inverse FFT.
+
+    Notes
+    -----
+    `ifft2` is just `ifftn` with a different default for `axes`.
+
+    See `ifftn` for details and a plotting example, and `numpy.fft` for
+    definition and conventions used.
+
+    Zero-padding, analogously with `ifft`, is performed by appending zeros to
+    the input along the specified dimension.  Although this is the common
+    approach, it might lead to surprising results.  If another form of zero
+    padding is desired, it must be performed before `ifft2` is called.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> a = 4 * np.eye(4)
+    >>> np.fft.ifft2(a)
+    array([[1.+0.j,  0.+0.j,  0.+0.j,  0.+0.j], # may vary
+           [0.+0.j,  0.+0.j,  0.+0.j,  1.+0.j],
+           [0.+0.j,  0.+0.j,  1.+0.j,  0.+0.j],
+           [0.+0.j,  1.+0.j,  0.+0.j,  0.+0.j]])
+
+    """
+    return _raw_fftnd(a, s, axes, ifft, norm, out=None)
+
+
+@array_function_dispatch(_fftn_dispatcher)
+def rfftn(a, s=None, axes=None, norm=None, out=None):
+    """
+    Compute the N-dimensional discrete Fourier Transform for real input.
+
+    This function computes the N-dimensional discrete Fourier Transform over
+    any number of axes in an M-dimensional real array by means of the Fast
+    Fourier Transform (FFT).  By default, all axes are transformed, with the
+    real transform performed over the last axis, while the remaining
+    transforms are complex.
+
+    Parameters
+    ----------
+    a : array_like
+        Input array, taken to be real.
+    s : sequence of ints, optional
+        Shape (length along each transformed axis) to use from the input.
+        (``s[0]`` refers to axis 0, ``s[1]`` to axis 1, etc.).
+        The final element of `s` corresponds to `n` for ``rfft(x, n)``, while
+        for the remaining axes, it corresponds to `n` for ``fft(x, n)``.
+        Along any axis, if the given shape is smaller than that of the input,
+        the input is cropped. If it is larger, the input is padded with zeros.
+
+        .. versionchanged:: 2.0
+
+            If it is ``-1``, the whole input is used (no padding/trimming).
+
+        If `s` is not given, the shape of the input along the axes specified
+        by `axes` is used.
+
+        .. deprecated:: 2.0
+
+            If `s` is not ``None``, `axes` must not be ``None`` either.
+
+        .. deprecated:: 2.0
+
+            `s` must contain only ``int`` s, not ``None`` values. ``None``
+            values currently mean that the default value for ``n`` is used
+            in the corresponding 1-D transform, but this behaviour is
+            deprecated.
+
+    axes : sequence of ints, optional
+        Axes over which to compute the FFT.  If not given, the last ``len(s)``
+        axes are used, or all axes if `s` is also not specified.
+
+        .. deprecated:: 2.0
+
+            If `s` is specified, the corresponding `axes` to be transformed
+            must be explicitly specified too.
+
+    norm : {"backward", "ortho", "forward"}, optional
+        .. versionadded:: 1.10.0
+
+        Normalization mode (see `numpy.fft`). Default is "backward".
+        Indicates which direction of the forward/backward pair of transforms
+        is scaled and with what normalization factor.
+
+        .. versionadded:: 1.20.0
+
+            The "backward", "forward" values were added.
+
+    out : complex ndarray, optional
+        If provided, the result will be placed in this array. It should be
+        of the appropriate shape and dtype for all axes (and hence is
+        incompatible with passing in all but the trivial ``s``).
+
+        .. versionadded:: 2.0.0
+
+    Returns
+    -------
+    out : complex ndarray
+        The truncated or zero-padded input, transformed along the axes
+        indicated by `axes`, or by a combination of `s` and `a`,
+        as explained in the parameters section above.
+        The length of the last axis transformed will be ``s[-1]//2+1``,
+        while the remaining transformed axes will have lengths according to
+        `s`, or unchanged from the input.
+
+    Raises
+    ------
+    ValueError
+        If `s` and `axes` have different length.
+    IndexError
+        If an element of `axes` is larger than than the number of axes of `a`.
+
+    See Also
+    --------
+    irfftn : The inverse of `rfftn`, i.e. the inverse of the n-dimensional FFT
+         of real input.
+    fft : The one-dimensional FFT, with definitions and conventions used.
+    rfft : The one-dimensional FFT of real input.
+    fftn : The n-dimensional FFT.
+    rfft2 : The two-dimensional FFT of real input.
+
+    Notes
+    -----
+    The transform for real input is performed over the last transformation
+    axis, as by `rfft`, then the transform over the remaining axes is
+    performed as by `fftn`.  The order of the output is as for `rfft` for the
+    final transformation axis, and as for `fftn` for the remaining
+    transformation axes.
+
+    See `fft` for details, definitions and conventions used.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> a = np.ones((2, 2, 2))
+    >>> np.fft.rfftn(a)
+    array([[[8.+0.j,  0.+0.j], # may vary
+            [0.+0.j,  0.+0.j]],
+           [[0.+0.j,  0.+0.j],
+            [0.+0.j,  0.+0.j]]])
+
+    >>> np.fft.rfftn(a, axes=(2, 0))
+    array([[[4.+0.j,  0.+0.j], # may vary
+            [4.+0.j,  0.+0.j]],
+           [[0.+0.j,  0.+0.j],
+            [0.+0.j,  0.+0.j]]])
+
+    """
+    a = asarray(a)
+    s, axes = _cook_nd_args(a, s, axes)
+    a = rfft(a, s[-1], axes[-1], norm, out=out)
+    for ii in range(len(axes)-2, -1, -1):
+        a = fft(a, s[ii], axes[ii], norm, out=out)
+    return a
+
+
+@array_function_dispatch(_fftn_dispatcher)
+def rfft2(a, s=None, axes=(-2, -1), norm=None, out=None):
+    """
+    Compute the 2-dimensional FFT of a real array.
+
+    Parameters
+    ----------
+    a : array
+        Input array, taken to be real.
+    s : sequence of ints, optional
+        Shape of the FFT.
+
+        .. versionchanged:: 2.0
+
+            If it is ``-1``, the whole input is used (no padding/trimming).
+
+        .. deprecated:: 2.0
+
+            If `s` is not ``None``, `axes` must not be ``None`` either.
+
+        .. deprecated:: 2.0
+
+            `s` must contain only ``int`` s, not ``None`` values. ``None``
+            values currently mean that the default value for ``n`` is used
+            in the corresponding 1-D transform, but this behaviour is
+            deprecated.
+
+    axes : sequence of ints, optional
+        Axes over which to compute the FFT. Default: ``(-2, -1)``.
+
+        .. deprecated:: 2.0
+
+            If `s` is specified, the corresponding `axes` to be transformed
+            must not be ``None``.
+
+    norm : {"backward", "ortho", "forward"}, optional
+        .. versionadded:: 1.10.0
+
+        Normalization mode (see `numpy.fft`). Default is "backward".
+        Indicates which direction of the forward/backward pair of transforms
+        is scaled and with what normalization factor.
+
+        .. versionadded:: 1.20.0
+
+            The "backward", "forward" values were added.
+
+    out : complex ndarray, optional
+        If provided, the result will be placed in this array. It should be
+        of the appropriate shape and dtype for the last inverse transform.
+        incompatible with passing in all but the trivial ``s``).
+
+        .. versionadded:: 2.0.0
+
+    Returns
+    -------
+    out : ndarray
+        The result of the real 2-D FFT.
+
+    See Also
+    --------
+    rfftn : Compute the N-dimensional discrete Fourier Transform for real
+            input.
+
+    Notes
+    -----
+    This is really just `rfftn` with different default behavior.
+    For more details see `rfftn`.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> a = np.mgrid[:5, :5][0]
+    >>> np.fft.rfft2(a)
+    array([[ 50.  +0.j        ,   0.  +0.j        ,   0.  +0.j        ],
+           [-12.5+17.20477401j,   0.  +0.j        ,   0.  +0.j        ],
+           [-12.5 +4.0614962j ,   0.  +0.j        ,   0.  +0.j        ],
+           [-12.5 -4.0614962j ,   0.  +0.j        ,   0.  +0.j        ],
+           [-12.5-17.20477401j,   0.  +0.j        ,   0.  +0.j        ]])
+    """
+    return rfftn(a, s, axes, norm, out=out)
+
+
+@array_function_dispatch(_fftn_dispatcher)
+def irfftn(a, s=None, axes=None, norm=None, out=None):
+    """
+    Computes the inverse of `rfftn`.
+
+    This function computes the inverse of the N-dimensional discrete
+    Fourier Transform for real input over any number of axes in an
+    M-dimensional array by means of the Fast Fourier Transform (FFT).  In
+    other words, ``irfftn(rfftn(a), a.shape) == a`` to within numerical
+    accuracy. (The ``a.shape`` is necessary like ``len(a)`` is for `irfft`,
+    and for the same reason.)
+
+    The input should be ordered in the same way as is returned by `rfftn`,
+    i.e. as for `irfft` for the final transformation axis, and as for `ifftn`
+    along all the other axes.
+
+    Parameters
+    ----------
+    a : array_like
+        Input array.
+    s : sequence of ints, optional
+        Shape (length of each transformed axis) of the output
+        (``s[0]`` refers to axis 0, ``s[1]`` to axis 1, etc.). `s` is also the
+        number of input points used along this axis, except for the last axis,
+        where ``s[-1]//2+1`` points of the input are used.
+        Along any axis, if the shape indicated by `s` is smaller than that of
+        the input, the input is cropped.  If it is larger, the input is padded
+        with zeros.
+
+        .. versionchanged:: 2.0
+
+            If it is ``-1``, the whole input is used (no padding/trimming).
+
+        If `s` is not given, the shape of the input along the axes
+        specified by axes is used. Except for the last axis which is taken to
+        be ``2*(m-1)`` where ``m`` is the length of the input along that axis.
+
+        .. deprecated:: 2.0
+
+            If `s` is not ``None``, `axes` must not be ``None`` either.
+
+        .. deprecated:: 2.0
+
+            `s` must contain only ``int`` s, not ``None`` values. ``None``
+            values currently mean that the default value for ``n`` is used
+            in the corresponding 1-D transform, but this behaviour is
+            deprecated.
+
+    axes : sequence of ints, optional
+        Axes over which to compute the inverse FFT. If not given, the last
+        `len(s)` axes are used, or all axes if `s` is also not specified.
+        Repeated indices in `axes` means that the inverse transform over that
+        axis is performed multiple times.
+
+        .. deprecated:: 2.0
+
+            If `s` is specified, the corresponding `axes` to be transformed
+            must be explicitly specified too.
+
+    norm : {"backward", "ortho", "forward"}, optional
+        .. versionadded:: 1.10.0
+
+        Normalization mode (see `numpy.fft`). Default is "backward".
+        Indicates which direction of the forward/backward pair of transforms
+        is scaled and with what normalization factor.
+
+        .. versionadded:: 1.20.0
+
+            The "backward", "forward" values were added.
+
+    out : ndarray, optional
+        If provided, the result will be placed in this array. It should be
+        of the appropriate shape and dtype for the last transformation.
+
+        .. versionadded:: 2.0.0
+
+    Returns
+    -------
+    out : ndarray
+        The truncated or zero-padded input, transformed along the axes
+        indicated by `axes`, or by a combination of `s` or `a`,
+        as explained in the parameters section above.
+        The length of each transformed axis is as given by the corresponding
+        element of `s`, or the length of the input in every axis except for the
+        last one if `s` is not given.  In the final transformed axis the length
+        of the output when `s` is not given is ``2*(m-1)`` where ``m`` is the
+        length of the final transformed axis of the input.  To get an odd
+        number of output points in the final axis, `s` must be specified.
+
+    Raises
+    ------
+    ValueError
+        If `s` and `axes` have different length.
+    IndexError
+        If an element of `axes` is larger than than the number of axes of `a`.
+
+    See Also
+    --------
+    rfftn : The forward n-dimensional FFT of real input,
+            of which `ifftn` is the inverse.
+    fft : The one-dimensional FFT, with definitions and conventions used.
+    irfft : The inverse of the one-dimensional FFT of real input.
+    irfft2 : The inverse of the two-dimensional FFT of real input.
+
+    Notes
+    -----
+    See `fft` for definitions and conventions used.
+
+    See `rfft` for definitions and conventions used for real input.
+
+    The correct interpretation of the hermitian input depends on the shape of
+    the original data, as given by `s`. This is because each input shape could
+    correspond to either an odd or even length signal. By default, `irfftn`
+    assumes an even output length which puts the last entry at the Nyquist
+    frequency; aliasing with its symmetric counterpart. When performing the
+    final complex to real transform, the last value is thus treated as purely
+    real. To avoid losing information, the correct shape of the real input
+    **must** be given.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> a = np.zeros((3, 2, 2))
+    >>> a[0, 0, 0] = 3 * 2 * 2
+    >>> np.fft.irfftn(a)
+    array([[[1.,  1.],
+            [1.,  1.]],
+           [[1.,  1.],
+            [1.,  1.]],
+           [[1.,  1.],
+            [1.,  1.]]])
+
+    """
+    a = asarray(a)
+    s, axes = _cook_nd_args(a, s, axes, invreal=1)
+    for ii in range(len(axes)-1):
+        a = ifft(a, s[ii], axes[ii], norm)
+    a = irfft(a, s[-1], axes[-1], norm, out=out)
+    return a
+
+
+@array_function_dispatch(_fftn_dispatcher)
+def irfft2(a, s=None, axes=(-2, -1), norm=None, out=None):
+    """
+    Computes the inverse of `rfft2`.
+
+    Parameters
+    ----------
+    a : array_like
+        The input array
+    s : sequence of ints, optional
+        Shape of the real output to the inverse FFT.
+
+        .. versionchanged:: 2.0
+
+            If it is ``-1``, the whole input is used (no padding/trimming).
+
+        .. deprecated:: 2.0
+
+            If `s` is not ``None``, `axes` must not be ``None`` either.
+
+        .. deprecated:: 2.0
+
+            `s` must contain only ``int`` s, not ``None`` values. ``None``
+            values currently mean that the default value for ``n`` is used
+            in the corresponding 1-D transform, but this behaviour is
+            deprecated.
+
+    axes : sequence of ints, optional
+        The axes over which to compute the inverse fft.
+        Default: ``(-2, -1)``, the last two axes.
+
+        .. deprecated:: 2.0
+
+            If `s` is specified, the corresponding `axes` to be transformed
+            must not be ``None``.
+
+    norm : {"backward", "ortho", "forward"}, optional
+        .. versionadded:: 1.10.0
+
+        Normalization mode (see `numpy.fft`). Default is "backward".
+        Indicates which direction of the forward/backward pair of transforms
+        is scaled and with what normalization factor.
+
+        .. versionadded:: 1.20.0
+
+            The "backward", "forward" values were added.
+
+    out : ndarray, optional
+        If provided, the result will be placed in this array. It should be
+        of the appropriate shape and dtype for the last transformation.
+
+        .. versionadded:: 2.0.0
+
+    Returns
+    -------
+    out : ndarray
+        The result of the inverse real 2-D FFT.
+
+    See Also
+    --------
+    rfft2 : The forward two-dimensional FFT of real input,
+            of which `irfft2` is the inverse.
+    rfft : The one-dimensional FFT for real input.
+    irfft : The inverse of the one-dimensional FFT of real input.
+    irfftn : Compute the inverse of the N-dimensional FFT of real input.
+
+    Notes
+    -----
+    This is really `irfftn` with different defaults.
+    For more details see `irfftn`.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> a = np.mgrid[:5, :5][0]
+    >>> A = np.fft.rfft2(a)
+    >>> np.fft.irfft2(A, s=a.shape)
+    array([[0., 0., 0., 0., 0.],
+           [1., 1., 1., 1., 1.],
+           [2., 2., 2., 2., 2.],
+           [3., 3., 3., 3., 3.],
+           [4., 4., 4., 4., 4.]])
+    """
+    return irfftn(a, s, axes, norm, out=None)
diff --git a/venv/lib/python3.12/site-packages/numpy/fft/_pocketfft.pyi b/venv/lib/python3.12/site-packages/numpy/fft/_pocketfft.pyi
new file mode 100644
index 00000000..7f088572
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/fft/_pocketfft.pyi
@@ -0,0 +1,122 @@
+from collections.abc import Sequence
+from typing import Literal as L
+
+from numpy import complex128, float64
+from numpy._typing import ArrayLike, NDArray, _ArrayLikeNumber_co
+
+_NormKind = L[None, "backward", "ortho", "forward"]
+
+__all__: list[str]
+
+def fft(
+    a: ArrayLike,
+    n: None | int = ...,
+    axis: int = ...,
+    norm: _NormKind = ...,
+    out: None | NDArray[complex128] = ...,
+) -> NDArray[complex128]: ...
+
+def ifft(
+    a: ArrayLike,
+    n: None | int = ...,
+    axis: int = ...,
+    norm: _NormKind = ...,
+    out: None | NDArray[complex128] = ...,
+) -> NDArray[complex128]: ...
+
+def rfft(
+    a: ArrayLike,
+    n: None | int = ...,
+    axis: int = ...,
+    norm: _NormKind = ...,
+    out: None | NDArray[complex128] = ...,
+) -> NDArray[complex128]: ...
+
+def irfft(
+    a: ArrayLike,
+    n: None | int = ...,
+    axis: int = ...,
+    norm: _NormKind = ...,
+    out: None | NDArray[float64] = ...,
+) -> NDArray[float64]: ...
+
+# Input array must be compatible with `np.conjugate`
+def hfft(
+    a: _ArrayLikeNumber_co,
+    n: None | int = ...,
+    axis: int = ...,
+    norm: _NormKind = ...,
+    out: None | NDArray[float64] = ...,
+) -> NDArray[float64]: ...
+
+def ihfft(
+    a: ArrayLike,
+    n: None | int = ...,
+    axis: int = ...,
+    norm: _NormKind = ...,
+    out: None | NDArray[complex128] = ...,
+) -> NDArray[complex128]: ...
+
+def fftn(
+    a: ArrayLike,
+    s: None | Sequence[int] = ...,
+    axes: None | Sequence[int] = ...,
+    norm: _NormKind = ...,
+    out: None | NDArray[complex128] = ...,
+) -> NDArray[complex128]: ...
+
+def ifftn(
+    a: ArrayLike,
+    s: None | Sequence[int] = ...,
+    axes: None | Sequence[int] = ...,
+    norm: _NormKind = ...,
+    out: None | NDArray[complex128] = ...,
+) -> NDArray[complex128]: ...
+
+def rfftn(
+    a: ArrayLike,
+    s: None | Sequence[int] = ...,
+    axes: None | Sequence[int] = ...,
+    norm: _NormKind = ...,
+    out: None | NDArray[complex128] = ...,
+) -> NDArray[complex128]: ...
+
+def irfftn(
+    a: ArrayLike,
+    s: None | Sequence[int] = ...,
+    axes: None | Sequence[int] = ...,
+    norm: _NormKind = ...,
+    out: None | NDArray[float64] = ...,
+) -> NDArray[float64]: ...
+
+def fft2(
+    a: ArrayLike,
+    s: None | Sequence[int] = ...,
+    axes: None | Sequence[int] = ...,
+    norm: _NormKind = ...,
+    out: None | NDArray[complex128] = ...,
+) -> NDArray[complex128]: ...
+
+def ifft2(
+    a: ArrayLike,
+    s: None | Sequence[int] = ...,
+    axes: None | Sequence[int] = ...,
+    norm: _NormKind = ...,
+    out: None | NDArray[complex128] = ...,
+) -> NDArray[complex128]: ...
+
+def rfft2(
+    a: ArrayLike,
+    s: None | Sequence[int] = ...,
+    axes: None | Sequence[int] = ...,
+    norm: _NormKind = ...,
+    out: None | NDArray[complex128] = ...,
+) -> NDArray[complex128]: ...
+
+def irfft2(
+    a: ArrayLike,
+    s: None | Sequence[int] = ...,
+    axes: None | Sequence[int] = ...,
+    norm: _NormKind = ...,
+    out: None | NDArray[float64] = ...,
+) -> NDArray[float64]: ...
diff --git a/venv/lib/python3.12/site-packages/numpy/fft/_pocketfft_umath.cpython-312-darwin.so b/venv/lib/python3.12/site-packages/numpy/fft/_pocketfft_umath.cpython-312-darwin.so
new file mode 100755
index 00000000..1b1a8038
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/fft/_pocketfft_umath.cpython-312-darwin.so differ
diff --git a/venv/lib/python3.12/site-packages/numpy/fft/helper.py b/venv/lib/python3.12/site-packages/numpy/fft/helper.py
new file mode 100644
index 00000000..4375cedf
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/fft/helper.py
@@ -0,0 +1,16 @@
+def __getattr__(attr_name):
+    import warnings
+    from numpy.fft import _helper
+    ret = getattr(_helper, attr_name, None)
+    if ret is None:
+        raise AttributeError(
+            f"module 'numpy.fft.helper' has no attribute {attr_name}")
+    warnings.warn(
+        "The numpy.fft.helper has been made private and renamed to "
+        "numpy.fft._helper. All four functions exported by it (i.e. fftshift, "
+        "ifftshift, fftfreq, rfftfreq) are available from numpy.fft. "
+        f"Please use numpy.fft.{attr_name} instead.",
+        DeprecationWarning,
+        stacklevel=3
+    )
+    return ret
diff --git a/venv/lib/python3.12/site-packages/numpy/fft/tests/__init__.py b/venv/lib/python3.12/site-packages/numpy/fft/tests/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/venv/lib/python3.12/site-packages/numpy/fft/tests/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/fft/tests/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 00000000..f7926cc1
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/fft/tests/__pycache__/__init__.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/fft/tests/__pycache__/test_helper.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/fft/tests/__pycache__/test_helper.cpython-312.pyc
new file mode 100644
index 00000000..bc03f936
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/fft/tests/__pycache__/test_helper.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/fft/tests/__pycache__/test_pocketfft.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/fft/tests/__pycache__/test_pocketfft.cpython-312.pyc
new file mode 100644
index 00000000..98224ca0
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/fft/tests/__pycache__/test_pocketfft.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/fft/tests/test_helper.py b/venv/lib/python3.12/site-packages/numpy/fft/tests/test_helper.py
new file mode 100644
index 00000000..852e6625
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/fft/tests/test_helper.py
@@ -0,0 +1,167 @@
+"""Test functions for fftpack.helper module
+
+Copied from fftpack.helper by Pearu Peterson, October 2005
+
+"""
+import numpy as np
+from numpy.testing import assert_array_almost_equal
+from numpy import fft, pi
+
+
+class TestFFTShift:
+
+    def test_definition(self):
+        x = [0, 1, 2, 3, 4, -4, -3, -2, -1]
+        y = [-4, -3, -2, -1, 0, 1, 2, 3, 4]
+        assert_array_almost_equal(fft.fftshift(x), y)
+        assert_array_almost_equal(fft.ifftshift(y), x)
+        x = [0, 1, 2, 3, 4, -5, -4, -3, -2, -1]
+        y = [-5, -4, -3, -2, -1, 0, 1, 2, 3, 4]
+        assert_array_almost_equal(fft.fftshift(x), y)
+        assert_array_almost_equal(fft.ifftshift(y), x)
+
+    def test_inverse(self):
+        for n in [1, 4, 9, 100, 211]:
+            x = np.random.random((n,))
+            assert_array_almost_equal(fft.ifftshift(fft.fftshift(x)), x)
+
+    def test_axes_keyword(self):
+        freqs = [[0, 1, 2], [3, 4, -4], [-3, -2, -1]]
+        shifted = [[-1, -3, -2], [2, 0, 1], [-4, 3, 4]]
+        assert_array_almost_equal(fft.fftshift(freqs, axes=(0, 1)), shifted)
+        assert_array_almost_equal(fft.fftshift(freqs, axes=0),
+                                  fft.fftshift(freqs, axes=(0,)))
+        assert_array_almost_equal(fft.ifftshift(shifted, axes=(0, 1)), freqs)
+        assert_array_almost_equal(fft.ifftshift(shifted, axes=0),
+                                  fft.ifftshift(shifted, axes=(0,)))
+
+        assert_array_almost_equal(fft.fftshift(freqs), shifted)
+        assert_array_almost_equal(fft.ifftshift(shifted), freqs)
+
+    def test_uneven_dims(self):
+        """ Test 2D input, which has uneven dimension sizes """
+        freqs = [
+            [0, 1],
+            [2, 3],
+            [4, 5]
+        ]
+
+        # shift in dimension 0
+        shift_dim0 = [
+            [4, 5],
+            [0, 1],
+            [2, 3]
+        ]
+        assert_array_almost_equal(fft.fftshift(freqs, axes=0), shift_dim0)
+        assert_array_almost_equal(fft.ifftshift(shift_dim0, axes=0), freqs)
+        assert_array_almost_equal(fft.fftshift(freqs, axes=(0,)), shift_dim0)
+        assert_array_almost_equal(fft.ifftshift(shift_dim0, axes=[0]), freqs)
+
+        # shift in dimension 1
+        shift_dim1 = [
+            [1, 0],
+            [3, 2],
+            [5, 4]
+        ]
+        assert_array_almost_equal(fft.fftshift(freqs, axes=1), shift_dim1)
+        assert_array_almost_equal(fft.ifftshift(shift_dim1, axes=1), freqs)
+
+        # shift in both dimensions
+        shift_dim_both = [
+            [5, 4],
+            [1, 0],
+            [3, 2]
+        ]
+        assert_array_almost_equal(fft.fftshift(freqs, axes=(0, 1)), shift_dim_both)
+        assert_array_almost_equal(fft.ifftshift(shift_dim_both, axes=(0, 1)), freqs)
+        assert_array_almost_equal(fft.fftshift(freqs, axes=[0, 1]), shift_dim_both)
+        assert_array_almost_equal(fft.ifftshift(shift_dim_both, axes=[0, 1]), freqs)
+
+        # axes=None (default) shift in all dimensions
+        assert_array_almost_equal(fft.fftshift(freqs, axes=None), shift_dim_both)
+        assert_array_almost_equal(fft.ifftshift(shift_dim_both, axes=None), freqs)
+        assert_array_almost_equal(fft.fftshift(freqs), shift_dim_both)
+        assert_array_almost_equal(fft.ifftshift(shift_dim_both), freqs)
+
+    def test_equal_to_original(self):
+        """ Test that the new (>=v1.15) implementation (see #10073) is equal to the original (<=v1.14) """
+        from numpy._core import asarray, concatenate, arange, take
+
+        def original_fftshift(x, axes=None):
+            """ How fftshift was implemented in v1.14"""
+            tmp = asarray(x)
+            ndim = tmp.ndim
+            if axes is None:
+                axes = list(range(ndim))
+            elif isinstance(axes, int):
+                axes = (axes,)
+            y = tmp
+            for k in axes:
+                n = tmp.shape[k]
+                p2 = (n + 1) // 2
+                mylist = concatenate((arange(p2, n), arange(p2)))
+                y = take(y, mylist, k)
+            return y
+
+        def original_ifftshift(x, axes=None):
+            """ How ifftshift was implemented in v1.14 """
+            tmp = asarray(x)
+            ndim = tmp.ndim
+            if axes is None:
+                axes = list(range(ndim))
+            elif isinstance(axes, int):
+                axes = (axes,)
+            y = tmp
+            for k in axes:
+                n = tmp.shape[k]
+                p2 = n - (n + 1) // 2
+                mylist = concatenate((arange(p2, n), arange(p2)))
+                y = take(y, mylist, k)
+            return y
+
+        # create possible 2d array combinations and try all possible keywords
+        # compare output to original functions
+        for i in range(16):
+            for j in range(16):
+                for axes_keyword in [0, 1, None, (0,), (0, 1)]:
+                    inp = np.random.rand(i, j)
+
+                    assert_array_almost_equal(fft.fftshift(inp, axes_keyword),
+                                              original_fftshift(inp, axes_keyword))
+
+                    assert_array_almost_equal(fft.ifftshift(inp, axes_keyword),
+                                              original_ifftshift(inp, axes_keyword))
+
+
+class TestFFTFreq:
+
+    def test_definition(self):
+        x = [0, 1, 2, 3, 4, -4, -3, -2, -1]
+        assert_array_almost_equal(9*fft.fftfreq(9), x)
+        assert_array_almost_equal(9*pi*fft.fftfreq(9, pi), x)
+        x = [0, 1, 2, 3, 4, -5, -4, -3, -2, -1]
+        assert_array_almost_equal(10*fft.fftfreq(10), x)
+        assert_array_almost_equal(10*pi*fft.fftfreq(10, pi), x)
+
+
+class TestRFFTFreq:
+
+    def test_definition(self):
+        x = [0, 1, 2, 3, 4]
+        assert_array_almost_equal(9*fft.rfftfreq(9), x)
+        assert_array_almost_equal(9*pi*fft.rfftfreq(9, pi), x)
+        x = [0, 1, 2, 3, 4, 5]
+        assert_array_almost_equal(10*fft.rfftfreq(10), x)
+        assert_array_almost_equal(10*pi*fft.rfftfreq(10, pi), x)
+
+
+class TestIRFFTN:
+
+    def test_not_last_axis_success(self):
+        ar, ai = np.random.random((2, 16, 8, 32))
+        a = ar + 1j*ai
+
+        axes = (-2,)
+
+        # Should not raise error
+        fft.irfftn(a, axes=axes)
diff --git a/venv/lib/python3.12/site-packages/numpy/fft/tests/test_pocketfft.py b/venv/lib/python3.12/site-packages/numpy/fft/tests/test_pocketfft.py
new file mode 100644
index 00000000..fc6592e4
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/fft/tests/test_pocketfft.py
@@ -0,0 +1,589 @@
+import numpy as np
+import pytest
+from numpy.random import random
+from numpy.testing import (
+        assert_array_equal, assert_raises, assert_allclose, IS_WASM
+        )
+import threading
+import queue
+
+
+def fft1(x):
+    L = len(x)
+    phase = -2j * np.pi * (np.arange(L) / L)
+    phase = np.arange(L).reshape(-1, 1) * phase
+    return np.sum(x*np.exp(phase), axis=1)
+
+
+class TestFFTShift:
+
+    def test_fft_n(self):
+        assert_raises(ValueError, np.fft.fft, [1, 2, 3], 0)
+
+
+class TestFFT1D:
+
+    def test_identity(self):
+        maxlen = 512
+        x = random(maxlen) + 1j*random(maxlen)
+        xr = random(maxlen)
+        for i in range(1, maxlen):
+            assert_allclose(np.fft.ifft(np.fft.fft(x[0:i])), x[0:i],
+                            atol=1e-12)
+            assert_allclose(np.fft.irfft(np.fft.rfft(xr[0:i]), i),
+                            xr[0:i], atol=1e-12)
+
+    @pytest.mark.parametrize("dtype", [np.single, np.double, np.longdouble])
+    def test_identity_long_short(self, dtype):
+        # Test with explicitly given number of points, both for n
+        # smaller and for n larger than the input size.
+        maxlen = 16
+        atol = 5 * np.spacing(np.array(1., dtype=dtype))
+        x = random(maxlen).astype(dtype) + 1j*random(maxlen).astype(dtype)
+        xx = np.concatenate([x, np.zeros_like(x)])
+        xr = random(maxlen).astype(dtype)
+        xxr = np.concatenate([xr, np.zeros_like(xr)])
+        for i in range(1, maxlen*2):
+            check_c = np.fft.ifft(np.fft.fft(x, n=i), n=i)
+            assert check_c.real.dtype == dtype
+            assert_allclose(check_c, xx[0:i], atol=atol, rtol=0)
+            check_r = np.fft.irfft(np.fft.rfft(xr, n=i), n=i)
+            assert check_r.dtype == dtype
+            assert_allclose(check_r, xxr[0:i], atol=atol, rtol=0)
+
+    @pytest.mark.parametrize("dtype", [np.single, np.double, np.longdouble])
+    def test_identity_long_short_reversed(self, dtype):
+        # Also test explicitly given number of points in reversed order.
+        maxlen = 16
+        atol = 5 * np.spacing(np.array(1., dtype=dtype))
+        x = random(maxlen).astype(dtype) + 1j*random(maxlen).astype(dtype)
+        xx = np.concatenate([x, np.zeros_like(x)])
+        for i in range(1, maxlen*2):
+            check_via_c = np.fft.fft(np.fft.ifft(x, n=i), n=i)
+            assert check_via_c.dtype == x.dtype
+            assert_allclose(check_via_c, xx[0:i], atol=atol, rtol=0)
+            # For irfft, we can neither recover the imaginary part of
+            # the first element, nor the imaginary part of the last
+            # element if npts is even.  So, set to 0 for the comparison.
+            y = x.copy()
+            n = i // 2 + 1
+            y.imag[0] = 0
+            if i % 2 == 0:
+                y.imag[n-1:] = 0
+            yy = np.concatenate([y, np.zeros_like(y)])
+            check_via_r = np.fft.rfft(np.fft.irfft(x, n=i), n=i)
+            assert check_via_r.dtype == x.dtype
+            assert_allclose(check_via_r, yy[0:n], atol=atol, rtol=0)
+
+    def test_fft(self):
+        x = random(30) + 1j*random(30)
+        assert_allclose(fft1(x), np.fft.fft(x), atol=1e-6)
+        assert_allclose(fft1(x), np.fft.fft(x, norm="backward"), atol=1e-6)
+        assert_allclose(fft1(x) / np.sqrt(30),
+                        np.fft.fft(x, norm="ortho"), atol=1e-6)
+        assert_allclose(fft1(x) / 30.,
+                        np.fft.fft(x, norm="forward"), atol=1e-6)
+
+    @pytest.mark.parametrize("axis", (0, 1))
+    @pytest.mark.parametrize("dtype", (complex, float))
+    @pytest.mark.parametrize("transpose", (True, False))
+    def test_fft_out_argument(self, dtype, transpose, axis):
+        def zeros_like(x):
+            if transpose:
+                return np.zeros_like(x.T).T
+            else:
+                return np.zeros_like(x)
+
+        # tests below only test the out parameter
+        if dtype is complex:
+            y = random((10, 20)) + 1j*random((10, 20))
+            fft, ifft = np.fft.fft, np.fft.ifft
+        else:
+            y = random((10, 20))
+            fft, ifft = np.fft.rfft, np.fft.irfft
+
+        expected = fft(y, axis=axis)
+        out = zeros_like(expected)
+        result = fft(y, out=out, axis=axis)
+        assert result is out
+        assert_array_equal(result, expected)
+
+        expected2 = ifft(expected, axis=axis)
+        out2 = out if dtype is complex else zeros_like(expected2)
+        result2 = ifft(out, out=out2, axis=axis)
+        assert result2 is out2
+        assert_array_equal(result2, expected2)
+
+    @pytest.mark.parametrize("axis", [0, 1])
+    def test_fft_inplace_out(self, axis):
+        # Test some weirder in-place combinations
+        y = random((20, 20)) + 1j*random((20, 20))
+        # Fully in-place.
+        y1 = y.copy()
+        expected1 = np.fft.fft(y1, axis=axis)
+        result1 = np.fft.fft(y1, axis=axis, out=y1)
+        assert result1 is y1
+        assert_array_equal(result1, expected1)
+        # In-place of part of the array; rest should be unchanged.
+        y2 = y.copy()
+        out2 = y2[:10] if axis == 0 else y2[:, :10]
+        expected2 = np.fft.fft(y2, n=10, axis=axis)
+        result2 = np.fft.fft(y2, n=10, axis=axis, out=out2)
+        assert result2 is out2
+        assert_array_equal(result2, expected2)
+        if axis == 0:
+            assert_array_equal(y2[10:], y[10:])
+        else:
+            assert_array_equal(y2[:, 10:], y[:, 10:])
+        # In-place of another part of the array.
+        y3 = y.copy()
+        y3_sel = y3[5:] if axis == 0 else y3[:, 5:]
+        out3 = y3[5:15] if axis == 0 else y3[:, 5:15]
+        expected3 = np.fft.fft(y3_sel, n=10, axis=axis)
+        result3 = np.fft.fft(y3_sel, n=10, axis=axis, out=out3)
+        assert result3 is out3
+        assert_array_equal(result3, expected3)
+        if axis == 0:
+            assert_array_equal(y3[:5], y[:5])
+            assert_array_equal(y3[15:], y[15:])
+        else:
+            assert_array_equal(y3[:, :5], y[:, :5])
+            assert_array_equal(y3[:, 15:], y[:, 15:])
+        # In-place with n > nin; rest should be unchanged.
+        y4 = y.copy()
+        y4_sel = y4[:10] if axis == 0 else y4[:, :10]
+        out4 = y4[:15] if axis == 0 else y4[:, :15]
+        expected4 = np.fft.fft(y4_sel, n=15, axis=axis)
+        result4 = np.fft.fft(y4_sel, n=15, axis=axis, out=out4)
+        assert result4 is out4
+        assert_array_equal(result4, expected4)
+        if axis == 0:
+            assert_array_equal(y4[15:], y[15:])
+        else:
+            assert_array_equal(y4[:, 15:], y[:, 15:])
+        # Overwrite in a transpose.
+        y5 = y.copy()
+        out5 = y5.T
+        result5 = np.fft.fft(y5, axis=axis, out=out5)
+        assert result5 is out5
+        assert_array_equal(result5, expected1)
+        # Reverse strides.
+        y6 = y.copy()
+        out6 = y6[::-1] if axis == 0 else y6[:, ::-1]
+        result6 = np.fft.fft(y6, axis=axis, out=out6)
+        assert result6 is out6
+        assert_array_equal(result6, expected1)
+
+    def test_fft_bad_out(self):
+        x = np.arange(30.)
+        with pytest.raises(TypeError, match="must be of ArrayType"):
+            np.fft.fft(x, out="")
+        with pytest.raises(ValueError, match="has wrong shape"):
+            np.fft.fft(x, out=np.zeros_like(x).reshape(5, -1))
+        with pytest.raises(TypeError, match="Cannot cast"):
+            np.fft.fft(x, out=np.zeros_like(x, dtype=float))
+
+    @pytest.mark.parametrize('norm', (None, 'backward', 'ortho', 'forward'))
+    def test_ifft(self, norm):
+        x = random(30) + 1j*random(30)
+        assert_allclose(
+            x, np.fft.ifft(np.fft.fft(x, norm=norm), norm=norm),
+            atol=1e-6)
+        # Ensure we get the correct error message
+        with pytest.raises(ValueError,
+                           match='Invalid number of FFT data points'):
+            np.fft.ifft([], norm=norm)
+
+    def test_fft2(self):
+        x = random((30, 20)) + 1j*random((30, 20))
+        assert_allclose(np.fft.fft(np.fft.fft(x, axis=1), axis=0),
+                        np.fft.fft2(x), atol=1e-6)
+        assert_allclose(np.fft.fft2(x),
+                        np.fft.fft2(x, norm="backward"), atol=1e-6)
+        assert_allclose(np.fft.fft2(x) / np.sqrt(30 * 20),
+                        np.fft.fft2(x, norm="ortho"), atol=1e-6)
+        assert_allclose(np.fft.fft2(x) / (30. * 20.),
+                        np.fft.fft2(x, norm="forward"), atol=1e-6)
+
+    def test_ifft2(self):
+        x = random((30, 20)) + 1j*random((30, 20))
+        assert_allclose(np.fft.ifft(np.fft.ifft(x, axis=1), axis=0),
+                        np.fft.ifft2(x), atol=1e-6)
+        assert_allclose(np.fft.ifft2(x),
+                        np.fft.ifft2(x, norm="backward"), atol=1e-6)
+        assert_allclose(np.fft.ifft2(x) * np.sqrt(30 * 20),
+                        np.fft.ifft2(x, norm="ortho"), atol=1e-6)
+        assert_allclose(np.fft.ifft2(x) * (30. * 20.),
+                        np.fft.ifft2(x, norm="forward"), atol=1e-6)
+
+    def test_fftn(self):
+        x = random((30, 20, 10)) + 1j*random((30, 20, 10))
+        assert_allclose(
+            np.fft.fft(np.fft.fft(np.fft.fft(x, axis=2), axis=1), axis=0),
+            np.fft.fftn(x), atol=1e-6)
+        assert_allclose(np.fft.fftn(x),
+                        np.fft.fftn(x, norm="backward"), atol=1e-6)
+        assert_allclose(np.fft.fftn(x) / np.sqrt(30 * 20 * 10),
+                        np.fft.fftn(x, norm="ortho"), atol=1e-6)
+        assert_allclose(np.fft.fftn(x) / (30. * 20. * 10.),
+                        np.fft.fftn(x, norm="forward"), atol=1e-6)
+
+    def test_ifftn(self):
+        x = random((30, 20, 10)) + 1j*random((30, 20, 10))
+        assert_allclose(
+            np.fft.ifft(np.fft.ifft(np.fft.ifft(x, axis=2), axis=1), axis=0),
+            np.fft.ifftn(x), atol=1e-6)
+        assert_allclose(np.fft.ifftn(x),
+                        np.fft.ifftn(x, norm="backward"), atol=1e-6)
+        assert_allclose(np.fft.ifftn(x) * np.sqrt(30 * 20 * 10),
+                        np.fft.ifftn(x, norm="ortho"), atol=1e-6)
+        assert_allclose(np.fft.ifftn(x) * (30. * 20. * 10.),
+                        np.fft.ifftn(x, norm="forward"), atol=1e-6)
+
+    def test_rfft(self):
+        x = random(30)
+        for n in [x.size, 2*x.size]:
+            for norm in [None, 'backward', 'ortho', 'forward']:
+                assert_allclose(
+                    np.fft.fft(x, n=n, norm=norm)[:(n//2 + 1)],
+                    np.fft.rfft(x, n=n, norm=norm), atol=1e-6)
+            assert_allclose(
+                np.fft.rfft(x, n=n),
+                np.fft.rfft(x, n=n, norm="backward"), atol=1e-6)
+            assert_allclose(
+                np.fft.rfft(x, n=n) / np.sqrt(n),
+                np.fft.rfft(x, n=n, norm="ortho"), atol=1e-6)
+            assert_allclose(
+                np.fft.rfft(x, n=n) / n,
+                np.fft.rfft(x, n=n, norm="forward"), atol=1e-6)
+
+    def test_rfft_even(self):
+        x = np.arange(8)
+        n = 4
+        y = np.fft.rfft(x, n)
+        assert_allclose(y, np.fft.fft(x[:n])[:n//2 + 1], rtol=1e-14)
+
+    def test_rfft_odd(self):
+        x = np.array([1, 0, 2, 3, -3])
+        y = np.fft.rfft(x)
+        assert_allclose(y, np.fft.fft(x)[:3], rtol=1e-14)
+
+    def test_irfft(self):
+        x = random(30)
+        assert_allclose(x, np.fft.irfft(np.fft.rfft(x)), atol=1e-6)
+        assert_allclose(x, np.fft.irfft(np.fft.rfft(x, norm="backward"),
+                        norm="backward"), atol=1e-6)
+        assert_allclose(x, np.fft.irfft(np.fft.rfft(x, norm="ortho"),
+                        norm="ortho"), atol=1e-6)
+        assert_allclose(x, np.fft.irfft(np.fft.rfft(x, norm="forward"),
+                        norm="forward"), atol=1e-6)
+
+    def test_rfft2(self):
+        x = random((30, 20))
+        assert_allclose(np.fft.fft2(x)[:, :11], np.fft.rfft2(x), atol=1e-6)
+        assert_allclose(np.fft.rfft2(x),
+                        np.fft.rfft2(x, norm="backward"), atol=1e-6)
+        assert_allclose(np.fft.rfft2(x) / np.sqrt(30 * 20),
+                        np.fft.rfft2(x, norm="ortho"), atol=1e-6)
+        assert_allclose(np.fft.rfft2(x) / (30. * 20.),
+                        np.fft.rfft2(x, norm="forward"), atol=1e-6)
+
+    def test_irfft2(self):
+        x = random((30, 20))
+        assert_allclose(x, np.fft.irfft2(np.fft.rfft2(x)), atol=1e-6)
+        assert_allclose(x, np.fft.irfft2(np.fft.rfft2(x, norm="backward"),
+                        norm="backward"), atol=1e-6)
+        assert_allclose(x, np.fft.irfft2(np.fft.rfft2(x, norm="ortho"),
+                        norm="ortho"), atol=1e-6)
+        assert_allclose(x, np.fft.irfft2(np.fft.rfft2(x, norm="forward"),
+                        norm="forward"), atol=1e-6)
+
+    def test_rfftn(self):
+        x = random((30, 20, 10))
+        assert_allclose(np.fft.fftn(x)[:, :, :6], np.fft.rfftn(x), atol=1e-6)
+        assert_allclose(np.fft.rfftn(x),
+                        np.fft.rfftn(x, norm="backward"), atol=1e-6)
+        assert_allclose(np.fft.rfftn(x) / np.sqrt(30 * 20 * 10),
+                        np.fft.rfftn(x, norm="ortho"), atol=1e-6)
+        assert_allclose(np.fft.rfftn(x) / (30. * 20. * 10.),
+                        np.fft.rfftn(x, norm="forward"), atol=1e-6)
+        # Regression test for gh-27159
+        x = np.ones((2, 3))
+        result = np.fft.rfftn(x, axes=(0, 0, 1), s=(10, 20, 40))
+        assert result.shape == (10, 21)
+        expected = np.fft.fft(np.fft.fft(np.fft.rfft(x, axis=1, n=40),
+                            axis=0, n=20), axis=0, n=10)
+        assert expected.shape == (10, 21)
+        assert_allclose(result, expected, atol=1e-6)
+
+    def test_irfftn(self):
+        x = random((30, 20, 10))
+        assert_allclose(x, np.fft.irfftn(np.fft.rfftn(x)), atol=1e-6)
+        assert_allclose(x, np.fft.irfftn(np.fft.rfftn(x, norm="backward"),
+                        norm="backward"), atol=1e-6)
+        assert_allclose(x, np.fft.irfftn(np.fft.rfftn(x, norm="ortho"),
+                        norm="ortho"), atol=1e-6)
+        assert_allclose(x, np.fft.irfftn(np.fft.rfftn(x, norm="forward"),
+                        norm="forward"), atol=1e-6)
+
+    def test_hfft(self):
+        x = random(14) + 1j*random(14)
+        x_herm = np.concatenate((random(1), x, random(1)))
+        x = np.concatenate((x_herm, x[::-1].conj()))
+        assert_allclose(np.fft.fft(x), np.fft.hfft(x_herm), atol=1e-6)
+        assert_allclose(np.fft.hfft(x_herm),
+                        np.fft.hfft(x_herm, norm="backward"), atol=1e-6)
+        assert_allclose(np.fft.hfft(x_herm) / np.sqrt(30),
+                        np.fft.hfft(x_herm, norm="ortho"), atol=1e-6)
+        assert_allclose(np.fft.hfft(x_herm) / 30.,
+                        np.fft.hfft(x_herm, norm="forward"), atol=1e-6)
+
+    def test_ihfft(self):
+        x = random(14) + 1j*random(14)
+        x_herm = np.concatenate((random(1), x, random(1)))
+        x = np.concatenate((x_herm, x[::-1].conj()))
+        assert_allclose(x_herm, np.fft.ihfft(np.fft.hfft(x_herm)), atol=1e-6)
+        assert_allclose(x_herm, np.fft.ihfft(np.fft.hfft(x_herm,
+                        norm="backward"), norm="backward"), atol=1e-6)
+        assert_allclose(x_herm, np.fft.ihfft(np.fft.hfft(x_herm,
+                        norm="ortho"), norm="ortho"), atol=1e-6)
+        assert_allclose(x_herm, np.fft.ihfft(np.fft.hfft(x_herm,
+                        norm="forward"), norm="forward"), atol=1e-6)
+
+    @pytest.mark.parametrize("op", [np.fft.fftn, np.fft.ifftn,
+                                    np.fft.rfftn, np.fft.irfftn])
+    def test_axes(self, op):
+        x = random((30, 20, 10))
+        axes = [(0, 1, 2), (0, 2, 1), (1, 0, 2), (1, 2, 0), (2, 0, 1), (2, 1, 0)]
+        for a in axes:
+            op_tr = op(np.transpose(x, a))
+            tr_op = np.transpose(op(x, axes=a), a)
+            assert_allclose(op_tr, tr_op, atol=1e-6)
+
+    @pytest.mark.parametrize("op", [np.fft.fftn, np.fft.ifftn,
+                                    np.fft.fft2, np.fft.ifft2])
+    def test_s_negative_1(self, op):
+        x = np.arange(100).reshape(10, 10)
+        # should use the whole input array along the first axis
+        assert op(x, s=(-1, 5), axes=(0, 1)).shape == (10, 5)
+
+    @pytest.mark.parametrize("op", [np.fft.fftn, np.fft.ifftn,
+                                    np.fft.rfftn, np.fft.irfftn])
+    def test_s_axes_none(self, op):
+        x = np.arange(100).reshape(10, 10)
+        with pytest.warns(match='`axes` should not be `None` if `s`'):
+            op(x, s=(-1, 5))
+
+    @pytest.mark.parametrize("op", [np.fft.fft2, np.fft.ifft2])
+    def test_s_axes_none_2D(self, op):
+        x = np.arange(100).reshape(10, 10)
+        with pytest.warns(match='`axes` should not be `None` if `s`'):
+            op(x, s=(-1, 5), axes=None)
+
+    @pytest.mark.parametrize("op", [np.fft.fftn, np.fft.ifftn,
+                                    np.fft.rfftn, np.fft.irfftn,
+                                    np.fft.fft2, np.fft.ifft2])
+    def test_s_contains_none(self, op):
+        x = random((30, 20, 10))
+        with pytest.warns(match='array containing `None` values to `s`'):
+            op(x, s=(10, None, 10), axes=(0, 1, 2))
+
+    def test_all_1d_norm_preserving(self):
+        # verify that round-trip transforms are norm-preserving
+        x = random(30)
+        x_norm = np.linalg.norm(x)
+        n = x.size * 2
+        func_pairs = [(np.fft.fft, np.fft.ifft),
+                      (np.fft.rfft, np.fft.irfft),
+                      # hfft: order so the first function takes x.size samples
+                      #       (necessary for comparison to x_norm above)
+                      (np.fft.ihfft, np.fft.hfft),
+                      ]
+        for forw, back in func_pairs:
+            for n in [x.size, 2*x.size]:
+                for norm in [None, 'backward', 'ortho', 'forward']:
+                    tmp = forw(x, n=n, norm=norm)
+                    tmp = back(tmp, n=n, norm=norm)
+                    assert_allclose(x_norm,
+                                    np.linalg.norm(tmp), atol=1e-6)
+
+    @pytest.mark.parametrize("axes", [(0, 1), (0, 2), None])
+    @pytest.mark.parametrize("dtype", (complex, float))
+    @pytest.mark.parametrize("transpose", (True, False))
+    def test_fftn_out_argument(self, dtype, transpose, axes):
+        def zeros_like(x):
+            if transpose:
+                return np.zeros_like(x.T).T
+            else:
+                return np.zeros_like(x)
+
+        # tests below only test the out parameter
+        if dtype is complex:
+            x = random((10, 5, 6)) + 1j*random((10, 5, 6))
+            fft, ifft = np.fft.fftn, np.fft.ifftn
+        else:
+            x = random((10, 5, 6))
+            fft, ifft = np.fft.rfftn, np.fft.irfftn
+
+        expected = fft(x, axes=axes)
+        out = zeros_like(expected)
+        result = fft(x, out=out, axes=axes)
+        assert result is out
+        assert_array_equal(result, expected)
+
+        expected2 = ifft(expected, axes=axes)
+        out2 = out if dtype is complex else zeros_like(expected2)
+        result2 = ifft(out, out=out2, axes=axes)
+        assert result2 is out2
+        assert_array_equal(result2, expected2)
+
+    @pytest.mark.parametrize("fft", [np.fft.fftn, np.fft.ifftn, np.fft.rfftn])
+    def test_fftn_out_and_s_interaction(self, fft):
+        # With s, shape varies, so generally one cannot pass in out.
+        if fft is np.fft.rfftn:
+            x = random((10, 5, 6))
+        else:
+            x = random((10, 5, 6)) + 1j*random((10, 5, 6))
+        with pytest.raises(ValueError, match="has wrong shape"):
+            fft(x, out=np.zeros_like(x), s=(3, 3, 3), axes=(0, 1, 2))
+        # Except on the first axis done (which is the last of axes).
+        s = (10, 5, 5)
+        expected = fft(x, s=s, axes=(0, 1, 2))
+        out = np.zeros_like(expected)
+        result = fft(x, s=s, axes=(0, 1, 2), out=out)
+        assert result is out
+        assert_array_equal(result, expected)
+
+    @pytest.mark.parametrize("s", [(9, 5, 5), (3, 3, 3)])
+    def test_irfftn_out_and_s_interaction(self, s):
+        # Since for irfftn, the output is real and thus cannot be used for
+        # intermediate steps, it should always work.
+        x = random((9, 5, 6, 2)) + 1j*random((9, 5, 6, 2))
+        expected = np.fft.irfftn(x, s=s, axes=(0, 1, 2))
+        out = np.zeros_like(expected)
+        result = np.fft.irfftn(x, s=s, axes=(0, 1, 2), out=out)
+        assert result is out
+        assert_array_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+        "dtype",
+        [np.float32, np.float64, np.complex64, np.complex128])
+@pytest.mark.parametrize("order", ["F", 'non-contiguous'])
+@pytest.mark.parametrize(
+        "fft",
+        [np.fft.fft, np.fft.fft2, np.fft.fftn,
+         np.fft.ifft, np.fft.ifft2, np.fft.ifftn])
+def test_fft_with_order(dtype, order, fft):
+    # Check that FFT/IFFT produces identical results for C, Fortran and
+    # non contiguous arrays
+    rng = np.random.RandomState(42)
+    X = rng.rand(8, 7, 13).astype(dtype, copy=False)
+    # See discussion in pull/14178
+    _tol = 8.0 * np.sqrt(np.log2(X.size)) * np.finfo(X.dtype).eps
+    if order == 'F':
+        Y = np.asfortranarray(X)
+    else:
+        # Make a non contiguous array
+        Y = X[::-1]
+        X = np.ascontiguousarray(X[::-1])
+
+    if fft.__name__.endswith('fft'):
+        for axis in range(3):
+            X_res = fft(X, axis=axis)
+            Y_res = fft(Y, axis=axis)
+            assert_allclose(X_res, Y_res, atol=_tol, rtol=_tol)
+    elif fft.__name__.endswith(('fft2', 'fftn')):
+        axes = [(0, 1), (1, 2), (0, 2)]
+        if fft.__name__.endswith('fftn'):
+            axes.extend([(0,), (1,), (2,), None])
+        for ax in axes:
+            X_res = fft(X, axes=ax)
+            Y_res = fft(Y, axes=ax)
+            assert_allclose(X_res, Y_res, atol=_tol, rtol=_tol)
+    else:
+        raise ValueError()
+
+
+@pytest.mark.parametrize("order", ["F", "C"])
+@pytest.mark.parametrize("n", [None, 7, 12])
+def test_fft_output_order(order, n):
+    rng = np.random.RandomState(42)
+    x = rng.rand(10)
+    x = np.asarray(x, dtype=np.complex64, order=order)
+    res = np.fft.fft(x, n=n)
+    assert res.flags.c_contiguous == x.flags.c_contiguous
+    assert res.flags.f_contiguous == x.flags.f_contiguous
+
+@pytest.mark.skipif(IS_WASM, reason="Cannot start thread")
+class TestFFTThreadSafe:
+    threads = 16
+    input_shape = (800, 200)
+
+    def _test_mtsame(self, func, *args):
+        def worker(args, q):
+            q.put(func(*args))
+
+        q = queue.Queue()
+        expected = func(*args)
+
+        # Spin off a bunch of threads to call the same function simultaneously
+        t = [threading.Thread(target=worker, args=(args, q))
+             for i in range(self.threads)]
+        [x.start() for x in t]
+
+        [x.join() for x in t]
+        # Make sure all threads returned the correct value
+        for i in range(self.threads):
+            assert_array_equal(q.get(timeout=5), expected,
+                'Function returned wrong value in multithreaded context')
+
+    def test_fft(self):
+        a = np.ones(self.input_shape) * 1+0j
+        self._test_mtsame(np.fft.fft, a)
+
+    def test_ifft(self):
+        a = np.ones(self.input_shape) * 1+0j
+        self._test_mtsame(np.fft.ifft, a)
+
+    def test_rfft(self):
+        a = np.ones(self.input_shape)
+        self._test_mtsame(np.fft.rfft, a)
+
+    def test_irfft(self):
+        a = np.ones(self.input_shape) * 1+0j
+        self._test_mtsame(np.fft.irfft, a)
+
+
+def test_irfft_with_n_1_regression():
+    # Regression test for gh-25661
+    x = np.arange(10)
+    np.fft.irfft(x, n=1)
+    np.fft.hfft(x, n=1)
+    np.fft.irfft(np.array([0], complex), n=10)
+
+
+def test_irfft_with_n_large_regression():
+    # Regression test for gh-25679
+    x = np.arange(5) * (1 + 1j)
+    result = np.fft.hfft(x, n=10)
+    expected = np.array([20., 9.91628173, -11.8819096, 7.1048486,
+                         -6.62459848, 4., -3.37540152, -0.16057669,
+                         1.8819096, -20.86055364])
+    assert_allclose(result, expected)
+
+
+@pytest.mark.parametrize("fft", [
+    np.fft.fft, np.fft.ifft, np.fft.rfft, np.fft.irfft
+])
+@pytest.mark.parametrize("data", [
+    np.array([False, True, False]),
+    np.arange(10, dtype=np.uint8),
+    np.arange(5, dtype=np.int16),
+])
+def test_fft_with_integer_or_bool_input(data, fft):
+    # Regression test for gh-25819
+    result = fft(data)
+    float_data = data.astype(np.result_type(data, 1.))
+    expected = fft(float_data)
+    assert_array_equal(result, expected)
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/__init__.py b/venv/lib/python3.12/site-packages/numpy/lib/__init__.py
new file mode 100644
index 00000000..f048b9e2
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/lib/__init__.py
@@ -0,0 +1,92 @@
+"""
+``numpy.lib`` is mostly a space for implementing functions that don't
+belong in core or in another NumPy submodule with a clear purpose
+(e.g. ``random``, ``fft``, ``linalg``, ``ma``).
+
+``numpy.lib``'s private submodules contain basic functions that are used by
+other public modules and are useful to have in the main name-space.
+
+"""
+
+# Public submodules
+# Note: recfunctions and (maybe) format are public too, but not imported
+from . import array_utils
+from . import introspect
+from . import mixins
+from . import npyio
+from . import scimath
+from . import stride_tricks
+
+# Private submodules
+# load module names. See https://github.com/networkx/networkx/issues/5838
+from . import _type_check_impl
+from . import _index_tricks_impl
+from . import _nanfunctions_impl
+from . import _function_base_impl
+from . import _stride_tricks_impl
+from . import _shape_base_impl
+from . import _twodim_base_impl
+from . import _ufunclike_impl
+from . import _histograms_impl
+from . import _utils_impl
+from . import _arraysetops_impl
+from . import _polynomial_impl
+from . import _npyio_impl
+from . import _arrayterator_impl
+from . import _arraypad_impl
+from . import _version
+
+# numpy.lib namespace members
+from ._arrayterator_impl import Arrayterator
+from ._version import NumpyVersion
+from numpy._core._multiarray_umath import add_docstring, tracemalloc_domain
+from numpy._core.function_base import add_newdoc
+
+__all__ = [
+    "Arrayterator", "add_docstring", "add_newdoc", "array_utils",
+    "introspect", "mixins", "NumpyVersion", "npyio", "scimath",
+    "stride_tricks", "tracemalloc_domain"
+]
+
+from numpy._pytesttester import PytestTester
+test = PytestTester(__name__)
+del PytestTester
+
+def __getattr__(attr):
+    # Warn for reprecated attributes
+    import math
+    import warnings
+
+    if attr == "math":
+        warnings.warn(
+            "`np.lib.math` is a deprecated alias for the standard library "
+            "`math` module (Deprecated Numpy 1.25). Replace usages of "
+            "`numpy.lib.math` with `math`", DeprecationWarning, stacklevel=2)
+        return math
+    elif attr == "emath":
+        raise AttributeError(
+            "numpy.lib.emath was an alias for emath module that was removed "
+            "in NumPy 2.0. Replace usages of numpy.lib.emath with "
+            "numpy.emath.", 
+            name=None
+        )
+    elif attr in (
+        "histograms", "type_check", "nanfunctions", "function_base",
+        "arraypad", "arraysetops", "ufunclike", "utils", "twodim_base",
+        "shape_base", "polynomial", "index_tricks",
+    ):
+        raise AttributeError(
+            f"numpy.lib.{attr} is now private. If you are using a public "
+            "function, it should be available in the main numpy namespace, "
+            "otherwise check the NumPy 2.0 migration guide.", 
+            name=None
+        )
+    elif attr == "arrayterator":
+        raise AttributeError(
+            "numpy.lib.arrayterator submodule is now private. To access "
+            "Arrayterator class use numpy.lib.Arrayterator.", 
+            name=None
+        )
+    else:
+        raise AttributeError("module {!r} has no attribute "
+                             "{!r}".format(__name__, attr))
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/__init__.pyi b/venv/lib/python3.12/site-packages/numpy/lib/__init__.pyi
new file mode 100644
index 00000000..b8bf2c5a
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/lib/__init__.pyi
@@ -0,0 +1,41 @@
+import math as math
+
+from numpy._pytesttester import PytestTester
+
+from numpy import (
+    ndenumerate as ndenumerate,
+    ndindex as ndindex,
+)
+
+from numpy.version import version
+
+from numpy.lib import (
+    format as format,
+    mixins as mixins,
+    scimath as scimath,
+    stride_tricks as stride_tricks,
+    npyio as npyio,
+    array_utils as array_utils,
+)
+
+from numpy.lib._version import (
+    NumpyVersion as NumpyVersion,
+)
+
+from numpy.lib._arrayterator_impl import (
+    Arrayterator as Arrayterator,
+)
+
+from numpy._core.multiarray import (
+    add_docstring as add_docstring,
+    tracemalloc_domain as tracemalloc_domain,
+)
+
+from numpy._core.function_base import (
+    add_newdoc as add_newdoc,
+)
+
+__all__: list[str]
+test: PytestTester
+
+__version__ = version
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/lib/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 00000000..0c703d97
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/lib/__pycache__/__init__.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/__pycache__/_array_utils_impl.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/lib/__pycache__/_array_utils_impl.cpython-312.pyc
new file mode 100644
index 00000000..c468cc29
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/lib/__pycache__/_array_utils_impl.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/__pycache__/_arraypad_impl.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/lib/__pycache__/_arraypad_impl.cpython-312.pyc
new file mode 100644
index 00000000..2ea14783
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/lib/__pycache__/_arraypad_impl.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/__pycache__/_arraysetops_impl.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/lib/__pycache__/_arraysetops_impl.cpython-312.pyc
new file mode 100644
index 00000000..05f74de3
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/lib/__pycache__/_arraysetops_impl.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/__pycache__/_arrayterator_impl.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/lib/__pycache__/_arrayterator_impl.cpython-312.pyc
new file mode 100644
index 00000000..dbd87751
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/lib/__pycache__/_arrayterator_impl.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/__pycache__/_datasource.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/lib/__pycache__/_datasource.cpython-312.pyc
new file mode 100644
index 00000000..64239ec7
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/lib/__pycache__/_datasource.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/__pycache__/_function_base_impl.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/lib/__pycache__/_function_base_impl.cpython-312.pyc
new file mode 100644
index 00000000..f768665e
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/lib/__pycache__/_function_base_impl.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/__pycache__/_histograms_impl.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/lib/__pycache__/_histograms_impl.cpython-312.pyc
new file mode 100644
index 00000000..bf39e3a7
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/lib/__pycache__/_histograms_impl.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/__pycache__/_index_tricks_impl.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/lib/__pycache__/_index_tricks_impl.cpython-312.pyc
new file mode 100644
index 00000000..38aa34a8
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/lib/__pycache__/_index_tricks_impl.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/__pycache__/_iotools.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/lib/__pycache__/_iotools.cpython-312.pyc
new file mode 100644
index 00000000..1d6c8a96
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/lib/__pycache__/_iotools.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/__pycache__/_nanfunctions_impl.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/lib/__pycache__/_nanfunctions_impl.cpython-312.pyc
new file mode 100644
index 00000000..3e41d66b
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/lib/__pycache__/_nanfunctions_impl.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/__pycache__/_npyio_impl.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/lib/__pycache__/_npyio_impl.cpython-312.pyc
new file mode 100644
index 00000000..6503d4cd
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/lib/__pycache__/_npyio_impl.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/__pycache__/_polynomial_impl.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/lib/__pycache__/_polynomial_impl.cpython-312.pyc
new file mode 100644
index 00000000..ffce652f
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/lib/__pycache__/_polynomial_impl.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/__pycache__/_scimath_impl.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/lib/__pycache__/_scimath_impl.cpython-312.pyc
new file mode 100644
index 00000000..9c758e07
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/lib/__pycache__/_scimath_impl.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/__pycache__/_shape_base_impl.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/lib/__pycache__/_shape_base_impl.cpython-312.pyc
new file mode 100644
index 00000000..1768bf2a
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/lib/__pycache__/_shape_base_impl.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/__pycache__/_stride_tricks_impl.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/lib/__pycache__/_stride_tricks_impl.cpython-312.pyc
new file mode 100644
index 00000000..af5505e0
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/lib/__pycache__/_stride_tricks_impl.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/__pycache__/_twodim_base_impl.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/lib/__pycache__/_twodim_base_impl.cpython-312.pyc
new file mode 100644
index 00000000..76ccf572
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/lib/__pycache__/_twodim_base_impl.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/__pycache__/_type_check_impl.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/lib/__pycache__/_type_check_impl.cpython-312.pyc
new file mode 100644
index 00000000..0bb83d6b
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/lib/__pycache__/_type_check_impl.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/__pycache__/_ufunclike_impl.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/lib/__pycache__/_ufunclike_impl.cpython-312.pyc
new file mode 100644
index 00000000..d20a5f3a
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/lib/__pycache__/_ufunclike_impl.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/__pycache__/_user_array_impl.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/lib/__pycache__/_user_array_impl.cpython-312.pyc
new file mode 100644
index 00000000..4ede93b2
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/lib/__pycache__/_user_array_impl.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/__pycache__/_utils_impl.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/lib/__pycache__/_utils_impl.cpython-312.pyc
new file mode 100644
index 00000000..905d61f7
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/lib/__pycache__/_utils_impl.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/__pycache__/_version.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/lib/__pycache__/_version.cpython-312.pyc
new file mode 100644
index 00000000..eb0c92bc
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/lib/__pycache__/_version.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/__pycache__/array_utils.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/lib/__pycache__/array_utils.cpython-312.pyc
new file mode 100644
index 00000000..71fa8a90
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/lib/__pycache__/array_utils.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/__pycache__/format.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/lib/__pycache__/format.cpython-312.pyc
new file mode 100644
index 00000000..e1b8e32e
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/lib/__pycache__/format.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/__pycache__/introspect.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/lib/__pycache__/introspect.cpython-312.pyc
new file mode 100644
index 00000000..da05591a
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/lib/__pycache__/introspect.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/__pycache__/mixins.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/lib/__pycache__/mixins.cpython-312.pyc
new file mode 100644
index 00000000..791c9eb1
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/lib/__pycache__/mixins.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/__pycache__/npyio.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/lib/__pycache__/npyio.cpython-312.pyc
new file mode 100644
index 00000000..d85ac8e6
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/lib/__pycache__/npyio.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/__pycache__/recfunctions.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/lib/__pycache__/recfunctions.cpython-312.pyc
new file mode 100644
index 00000000..1f7b1591
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/lib/__pycache__/recfunctions.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/__pycache__/scimath.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/lib/__pycache__/scimath.cpython-312.pyc
new file mode 100644
index 00000000..0454a0f5
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/lib/__pycache__/scimath.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/__pycache__/stride_tricks.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/lib/__pycache__/stride_tricks.cpython-312.pyc
new file mode 100644
index 00000000..f0961200
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/lib/__pycache__/stride_tricks.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/__pycache__/user_array.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/lib/__pycache__/user_array.cpython-312.pyc
new file mode 100644
index 00000000..63b24b36
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/lib/__pycache__/user_array.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/_array_utils_impl.py b/venv/lib/python3.12/site-packages/numpy/lib/_array_utils_impl.py
new file mode 100644
index 00000000..d5f77816
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/lib/_array_utils_impl.py
@@ -0,0 +1,62 @@
+"""
+Miscellaneous utils.
+"""
+from numpy._core import asarray
+from numpy._core.numeric import normalize_axis_tuple, normalize_axis_index
+from numpy._utils import set_module
+
+__all__ = ["byte_bounds", "normalize_axis_tuple", "normalize_axis_index"]
+
+
+@set_module("numpy.lib.array_utils")
+def byte_bounds(a):
+    """
+    Returns pointers to the end-points of an array.
+
+    Parameters
+    ----------
+    a : ndarray
+        Input array. It must conform to the Python-side of the array
+        interface.
+
+    Returns
+    -------
+    (low, high) : tuple of 2 integers
+        The first integer is the first byte of the array, the second
+        integer is just past the last byte of the array.  If `a` is not
+        contiguous it will not use every byte between the (`low`, `high`)
+        values.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> I = np.eye(2, dtype='f'); I.dtype
+    dtype('float32')
+    >>> low, high = np.lib.array_utils.byte_bounds(I)
+    >>> high - low == I.size*I.itemsize
+    True
+    >>> I = np.eye(2); I.dtype
+    dtype('float64')
+    >>> low, high = np.lib.array_utils.byte_bounds(I)
+    >>> high - low == I.size*I.itemsize
+    True
+
+    """
+    ai = a.__array_interface__
+    a_data = ai['data'][0]
+    astrides = ai['strides']
+    ashape = ai['shape']
+    bytes_a = asarray(a).dtype.itemsize
+
+    a_low = a_high = a_data
+    if astrides is None:
+        # contiguous case
+        a_high += a.size * bytes_a
+    else:
+        for shape, stride in zip(ashape, astrides):
+            if stride < 0:
+                a_low += (shape-1)*stride
+            else:
+                a_high += (shape-1)*stride
+        a_high += bytes_a
+    return a_low, a_high
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/_array_utils_impl.pyi b/venv/lib/python3.12/site-packages/numpy/lib/_array_utils_impl.pyi
new file mode 100644
index 00000000..a38a62f2
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/lib/_array_utils_impl.pyi
@@ -0,0 +1,25 @@
+from typing import Any, Iterable, Tuple
+
+from numpy import generic
+from numpy.typing import NDArray
+
+__all__: list[str]
+
+# NOTE: In practice `byte_bounds` can (potentially) take any object
+# implementing the `__array_interface__` protocol. The caveat is
+# that certain keys, marked as optional in the spec, must be present for
+#  `byte_bounds`. This concerns `"strides"` and `"data"`.
+def byte_bounds(a: generic | NDArray[Any]) -> tuple[int, int]: ...
+
+def normalize_axis_tuple(
+    axis: int | Iterable[int], 
+    ndim: int = ..., 
+    argname: None | str = ..., 
+    allow_duplicate: None | bool = ...,
+) -> Tuple[int, int]: ...
+
+def normalize_axis_index(
+    axis: int = ...,
+    ndim: int = ...,
+    msg_prefix: None | str = ...,
+) -> int: ...
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/_arraypad_impl.py b/venv/lib/python3.12/site-packages/numpy/lib/_arraypad_impl.py
new file mode 100644
index 00000000..8bdb1b99
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/lib/_arraypad_impl.py
@@ -0,0 +1,895 @@
+"""
+The arraypad module contains a group of functions to pad values onto the edges
+of an n-dimensional array.
+
+"""
+import numpy as np
+from numpy._core.overrides import array_function_dispatch
+from numpy.lib._index_tricks_impl import ndindex
+
+
+__all__ = ['pad']
+
+
+###############################################################################
+# Private utility functions.
+
+
+def _round_if_needed(arr, dtype):
+    """
+    Rounds arr inplace if destination dtype is integer.
+
+    Parameters
+    ----------
+    arr : ndarray
+        Input array.
+    dtype : dtype
+        The dtype of the destination array.
+    """
+    if np.issubdtype(dtype, np.integer):
+        arr.round(out=arr)
+
+
+def _slice_at_axis(sl, axis):
+    """
+    Construct tuple of slices to slice an array in the given dimension.
+
+    Parameters
+    ----------
+    sl : slice
+        The slice for the given dimension.
+    axis : int
+        The axis to which `sl` is applied. All other dimensions are left
+        "unsliced".
+
+    Returns
+    -------
+    sl : tuple of slices
+        A tuple with slices matching `shape` in length.
+
+    Examples
+    --------
+    >>> np._slice_at_axis(slice(None, 3, -1), 1)
+    (slice(None, None, None), slice(None, 3, -1), (...,))
+    """
+    return (slice(None),) * axis + (sl,) + (...,)
+
+
+def _view_roi(array, original_area_slice, axis):
+    """
+    Get a view of the current region of interest during iterative padding.
+
+    When padding multiple dimensions iteratively corner values are
+    unnecessarily overwritten multiple times. This function reduces the
+    working area for the first dimensions so that corners are excluded.
+
+    Parameters
+    ----------
+    array : ndarray
+        The array with the region of interest.
+    original_area_slice : tuple of slices
+        Denotes the area with original values of the unpadded array.
+    axis : int
+        The currently padded dimension assuming that `axis` is padded before
+        `axis` + 1.
+
+    Returns
+    -------
+    roi : ndarray
+        The region of interest of the original `array`.
+    """
+    axis += 1
+    sl = (slice(None),) * axis + original_area_slice[axis:]
+    return array[sl]
+
+
+def _pad_simple(array, pad_width, fill_value=None):
+    """
+    Pad array on all sides with either a single value or undefined values.
+
+    Parameters
+    ----------
+    array : ndarray
+        Array to grow.
+    pad_width : sequence of tuple[int, int]
+        Pad width on both sides for each dimension in `arr`.
+    fill_value : scalar, optional
+        If provided the padded area is filled with this value, otherwise
+        the pad area left undefined.
+
+    Returns
+    -------
+    padded : ndarray
+        The padded array with the same dtype as`array`. Its order will default
+        to C-style if `array` is not F-contiguous.
+    original_area_slice : tuple
+        A tuple of slices pointing to the area of the original array.
+    """
+    # Allocate grown array
+    new_shape = tuple(
+        left + size + right
+        for size, (left, right) in zip(array.shape, pad_width)
+    )
+    order = 'F' if array.flags.fnc else 'C'  # Fortran and not also C-order
+    padded = np.empty(new_shape, dtype=array.dtype, order=order)
+
+    if fill_value is not None:
+        padded.fill(fill_value)
+
+    # Copy old array into correct space
+    original_area_slice = tuple(
+        slice(left, left + size)
+        for size, (left, right) in zip(array.shape, pad_width)
+    )
+    padded[original_area_slice] = array
+
+    return padded, original_area_slice
+
+
+def _set_pad_area(padded, axis, width_pair, value_pair):
+    """
+    Set empty-padded area in given dimension.
+
+    Parameters
+    ----------
+    padded : ndarray
+        Array with the pad area which is modified inplace.
+    axis : int
+        Dimension with the pad area to set.
+    width_pair : (int, int)
+        Pair of widths that mark the pad area on both sides in the given
+        dimension.
+    value_pair : tuple of scalars or ndarrays
+        Values inserted into the pad area on each side. It must match or be
+        broadcastable to the shape of `arr`.
+    """
+    left_slice = _slice_at_axis(slice(None, width_pair[0]), axis)
+    padded[left_slice] = value_pair[0]
+
+    right_slice = _slice_at_axis(
+        slice(padded.shape[axis] - width_pair[1], None), axis)
+    padded[right_slice] = value_pair[1]
+
+
+def _get_edges(padded, axis, width_pair):
+    """
+    Retrieve edge values from empty-padded array in given dimension.
+
+    Parameters
+    ----------
+    padded : ndarray
+        Empty-padded array.
+    axis : int
+        Dimension in which the edges are considered.
+    width_pair : (int, int)
+        Pair of widths that mark the pad area on both sides in the given
+        dimension.
+
+    Returns
+    -------
+    left_edge, right_edge : ndarray
+        Edge values of the valid area in `padded` in the given dimension. Its
+        shape will always match `padded` except for the dimension given by
+        `axis` which will have a length of 1.
+    """
+    left_index = width_pair[0]
+    left_slice = _slice_at_axis(slice(left_index, left_index + 1), axis)
+    left_edge = padded[left_slice]
+
+    right_index = padded.shape[axis] - width_pair[1]
+    right_slice = _slice_at_axis(slice(right_index - 1, right_index), axis)
+    right_edge = padded[right_slice]
+
+    return left_edge, right_edge
+
+
+def _get_linear_ramps(padded, axis, width_pair, end_value_pair):
+    """
+    Construct linear ramps for empty-padded array in given dimension.
+
+    Parameters
+    ----------
+    padded : ndarray
+        Empty-padded array.
+    axis : int
+        Dimension in which the ramps are constructed.
+    width_pair : (int, int)
+        Pair of widths that mark the pad area on both sides in the given
+        dimension.
+    end_value_pair : (scalar, scalar)
+        End values for the linear ramps which form the edge of the fully padded
+        array. These values are included in the linear ramps.
+
+    Returns
+    -------
+    left_ramp, right_ramp : ndarray
+        Linear ramps to set on both sides of `padded`.
+    """
+    edge_pair = _get_edges(padded, axis, width_pair)
+
+    left_ramp, right_ramp = (
+        np.linspace(
+            start=end_value,
+            stop=edge.squeeze(axis), # Dimension is replaced by linspace
+            num=width,
+            endpoint=False,
+            dtype=padded.dtype,
+            axis=axis
+        )
+        for end_value, edge, width in zip(
+            end_value_pair, edge_pair, width_pair
+        )
+    )
+        
+    # Reverse linear space in appropriate dimension
+    right_ramp = right_ramp[_slice_at_axis(slice(None, None, -1), axis)]
+
+    return left_ramp, right_ramp
+
+
+def _get_stats(padded, axis, width_pair, length_pair, stat_func):
+    """
+    Calculate statistic for the empty-padded array in given dimension.
+
+    Parameters
+    ----------
+    padded : ndarray
+        Empty-padded array.
+    axis : int
+        Dimension in which the statistic is calculated.
+    width_pair : (int, int)
+        Pair of widths that mark the pad area on both sides in the given
+        dimension.
+    length_pair : 2-element sequence of None or int
+        Gives the number of values in valid area from each side that is
+        taken into account when calculating the statistic. If None the entire
+        valid area in `padded` is considered.
+    stat_func : function
+        Function to compute statistic. The expected signature is
+        ``stat_func(x: ndarray, axis: int, keepdims: bool) -> ndarray``.
+
+    Returns
+    -------
+    left_stat, right_stat : ndarray
+        Calculated statistic for both sides of `padded`.
+    """
+    # Calculate indices of the edges of the area with original values
+    left_index = width_pair[0]
+    right_index = padded.shape[axis] - width_pair[1]
+    # as well as its length
+    max_length = right_index - left_index
+
+    # Limit stat_lengths to max_length
+    left_length, right_length = length_pair
+    if left_length is None or max_length < left_length:
+        left_length = max_length
+    if right_length is None or max_length < right_length:
+        right_length = max_length
+
+    if (left_length == 0 or right_length == 0) \
+            and stat_func in {np.amax, np.amin}:
+        # amax and amin can't operate on an empty array,
+        # raise a more descriptive warning here instead of the default one
+        raise ValueError("stat_length of 0 yields no value for padding")
+
+    # Calculate statistic for the left side
+    left_slice = _slice_at_axis(
+        slice(left_index, left_index + left_length), axis)
+    left_chunk = padded[left_slice]
+    left_stat = stat_func(left_chunk, axis=axis, keepdims=True)
+    _round_if_needed(left_stat, padded.dtype)
+
+    if left_length == right_length == max_length:
+        # return early as right_stat must be identical to left_stat
+        return left_stat, left_stat
+
+    # Calculate statistic for the right side
+    right_slice = _slice_at_axis(
+        slice(right_index - right_length, right_index), axis)
+    right_chunk = padded[right_slice]
+    right_stat = stat_func(right_chunk, axis=axis, keepdims=True)
+    _round_if_needed(right_stat, padded.dtype)
+
+    return left_stat, right_stat
+
+
+def _set_reflect_both(padded, axis, width_pair, method, 
+                      original_period, include_edge=False):
+    """
+    Pad `axis` of `arr` with reflection.
+
+    Parameters
+    ----------
+    padded : ndarray
+        Input array of arbitrary shape.
+    axis : int
+        Axis along which to pad `arr`.
+    width_pair : (int, int)
+        Pair of widths that mark the pad area on both sides in the given
+        dimension.
+    method : str
+        Controls method of reflection; options are 'even' or 'odd'.
+    original_period : int
+        Original length of data on `axis` of `arr`.
+    include_edge : bool
+        If true, edge value is included in reflection, otherwise the edge
+        value forms the symmetric axis to the reflection.
+
+    Returns
+    -------
+    pad_amt : tuple of ints, length 2
+        New index positions of padding to do along the `axis`. If these are
+        both 0, padding is done in this dimension.
+    """
+    left_pad, right_pad = width_pair
+    old_length = padded.shape[axis] - right_pad - left_pad
+    
+    if include_edge:
+        # Avoid wrapping with only a subset of the original area 
+        # by ensuring period can only be a multiple of the original 
+        # area's length.
+        old_length = old_length // original_period * original_period
+        # Edge is included, we need to offset the pad amount by 1
+        edge_offset = 1
+    else:
+        # Avoid wrapping with only a subset of the original area 
+        # by ensuring period can only be a multiple of the original 
+        # area's length.
+        old_length = ((old_length - 1) // (original_period - 1)
+            * (original_period - 1) + 1)
+        edge_offset = 0  # Edge is not included, no need to offset pad amount
+        old_length -= 1  # but must be omitted from the chunk
+
+    if left_pad > 0:
+        # Pad with reflected values on left side:
+        # First limit chunk size which can't be larger than pad area
+        chunk_length = min(old_length, left_pad)
+        # Slice right to left, stop on or next to edge, start relative to stop
+        stop = left_pad - edge_offset
+        start = stop + chunk_length
+        left_slice = _slice_at_axis(slice(start, stop, -1), axis)
+        left_chunk = padded[left_slice]
+
+        if method == "odd":
+            # Negate chunk and align with edge
+            edge_slice = _slice_at_axis(slice(left_pad, left_pad + 1), axis)
+            left_chunk = 2 * padded[edge_slice] - left_chunk
+
+        # Insert chunk into padded area
+        start = left_pad - chunk_length
+        stop = left_pad
+        pad_area = _slice_at_axis(slice(start, stop), axis)
+        padded[pad_area] = left_chunk
+        # Adjust pointer to left edge for next iteration
+        left_pad -= chunk_length
+
+    if right_pad > 0:
+        # Pad with reflected values on right side:
+        # First limit chunk size which can't be larger than pad area
+        chunk_length = min(old_length, right_pad)
+        # Slice right to left, start on or next to edge, stop relative to start
+        start = -right_pad + edge_offset - 2
+        stop = start - chunk_length
+        right_slice = _slice_at_axis(slice(start, stop, -1), axis)
+        right_chunk = padded[right_slice]
+
+        if method == "odd":
+            # Negate chunk and align with edge
+            edge_slice = _slice_at_axis(
+                slice(-right_pad - 1, -right_pad), axis)
+            right_chunk = 2 * padded[edge_slice] - right_chunk
+
+        # Insert chunk into padded area
+        start = padded.shape[axis] - right_pad
+        stop = start + chunk_length
+        pad_area = _slice_at_axis(slice(start, stop), axis)
+        padded[pad_area] = right_chunk
+        # Adjust pointer to right edge for next iteration
+        right_pad -= chunk_length
+
+    return left_pad, right_pad
+
+
+def _set_wrap_both(padded, axis, width_pair, original_period):
+    """
+    Pad `axis` of `arr` with wrapped values.
+
+    Parameters
+    ----------
+    padded : ndarray
+        Input array of arbitrary shape.
+    axis : int
+        Axis along which to pad `arr`.
+    width_pair : (int, int)
+        Pair of widths that mark the pad area on both sides in the given
+        dimension.
+    original_period : int
+        Original length of data on `axis` of `arr`.
+
+    Returns
+    -------
+    pad_amt : tuple of ints, length 2
+        New index positions of padding to do along the `axis`. If these are
+        both 0, padding is done in this dimension.
+    """
+    left_pad, right_pad = width_pair
+    period = padded.shape[axis] - right_pad - left_pad
+    # Avoid wrapping with only a subset of the original area by ensuring period
+    # can only be a multiple of the original area's length.
+    period = period // original_period * original_period
+
+    # If the current dimension of `arr` doesn't contain enough valid values
+    # (not part of the undefined pad area) we need to pad multiple times.
+    # Each time the pad area shrinks on both sides which is communicated with
+    # these variables.
+    new_left_pad = 0
+    new_right_pad = 0
+
+    if left_pad > 0:
+        # Pad with wrapped values on left side
+        # First slice chunk from left side of the non-pad area.
+        # Use min(period, left_pad) to ensure that chunk is not larger than
+        # pad area.
+        slice_end = left_pad + period
+        slice_start = slice_end - min(period, left_pad)
+        right_slice = _slice_at_axis(slice(slice_start, slice_end), axis)
+        right_chunk = padded[right_slice]
+
+        if left_pad > period:
+            # Chunk is smaller than pad area
+            pad_area = _slice_at_axis(slice(left_pad - period, left_pad), axis)
+            new_left_pad = left_pad - period
+        else:
+            # Chunk matches pad area
+            pad_area = _slice_at_axis(slice(None, left_pad), axis)
+        padded[pad_area] = right_chunk
+
+    if right_pad > 0:
+        # Pad with wrapped values on right side
+        # First slice chunk from right side of the non-pad area.
+        # Use min(period, right_pad) to ensure that chunk is not larger than
+        # pad area.
+        slice_start = -right_pad - period
+        slice_end = slice_start + min(period, right_pad)
+        left_slice = _slice_at_axis(slice(slice_start, slice_end), axis)
+        left_chunk = padded[left_slice]
+
+        if right_pad > period:
+            # Chunk is smaller than pad area
+            pad_area = _slice_at_axis(
+                slice(-right_pad, -right_pad + period), axis)
+            new_right_pad = right_pad - period
+        else:
+            # Chunk matches pad area
+            pad_area = _slice_at_axis(slice(-right_pad, None), axis)
+        padded[pad_area] = left_chunk
+
+    return new_left_pad, new_right_pad
+
+
+def _as_pairs(x, ndim, as_index=False):
+    """
+    Broadcast `x` to an array with the shape (`ndim`, 2).
+
+    A helper function for `pad` that prepares and validates arguments like
+    `pad_width` for iteration in pairs.
+
+    Parameters
+    ----------
+    x : {None, scalar, array-like}
+        The object to broadcast to the shape (`ndim`, 2).
+    ndim : int
+        Number of pairs the broadcasted `x` will have.
+    as_index : bool, optional
+        If `x` is not None, try to round each element of `x` to an integer
+        (dtype `np.intp`) and ensure every element is positive.
+
+    Returns
+    -------
+    pairs : nested iterables, shape (`ndim`, 2)
+        The broadcasted version of `x`.
+
+    Raises
+    ------
+    ValueError
+        If `as_index` is True and `x` contains negative elements.
+        Or if `x` is not broadcastable to the shape (`ndim`, 2).
+    """
+    if x is None:
+        # Pass through None as a special case, otherwise np.round(x) fails
+        # with an AttributeError
+        return ((None, None),) * ndim
+
+    x = np.array(x)
+    if as_index:
+        x = np.round(x).astype(np.intp, copy=False)
+
+    if x.ndim < 3:
+        # Optimization: Possibly use faster paths for cases where `x` has
+        # only 1 or 2 elements. `np.broadcast_to` could handle these as well
+        # but is currently slower
+
+        if x.size == 1:
+            # x was supplied as a single value
+            x = x.ravel()  # Ensure x[0] works for x.ndim == 0, 1, 2
+            if as_index and x < 0:
+                raise ValueError("index can't contain negative values")
+            return ((x[0], x[0]),) * ndim
+
+        if x.size == 2 and x.shape != (2, 1):
+            # x was supplied with a single value for each side
+            # but except case when each dimension has a single value
+            # which should be broadcasted to a pair,
+            # e.g. [[1], [2]] -> [[1, 1], [2, 2]] not [[1, 2], [1, 2]]
+            x = x.ravel()  # Ensure x[0], x[1] works
+            if as_index and (x[0] < 0 or x[1] < 0):
+                raise ValueError("index can't contain negative values")
+            return ((x[0], x[1]),) * ndim
+
+    if as_index and x.min() < 0:
+        raise ValueError("index can't contain negative values")
+
+    # Converting the array with `tolist` seems to improve performance
+    # when iterating and indexing the result (see usage in `pad`)
+    return np.broadcast_to(x, (ndim, 2)).tolist()
+
+
+def _pad_dispatcher(array, pad_width, mode=None, **kwargs):
+    return (array,)
+
+
+###############################################################################
+# Public functions
+
+
+@array_function_dispatch(_pad_dispatcher, module='numpy')
+def pad(array, pad_width, mode='constant', **kwargs):
+    """
+    Pad an array.
+
+    Parameters
+    ----------
+    array : array_like of rank N
+        The array to pad.
+    pad_width : {sequence, array_like, int}
+        Number of values padded to the edges of each axis.
+        ``((before_1, after_1), ... (before_N, after_N))`` unique pad widths
+        for each axis.
+        ``(before, after)`` or ``((before, after),)`` yields same before
+        and after pad for each axis.
+        ``(pad,)`` or ``int`` is a shortcut for before = after = pad width
+        for all axes.
+    mode : str or function, optional
+        One of the following string values or a user supplied function.
+
+        'constant' (default)
+            Pads with a constant value.
+        'edge'
+            Pads with the edge values of array.
+        'linear_ramp'
+            Pads with the linear ramp between end_value and the
+            array edge value.
+        'maximum'
+            Pads with the maximum value of all or part of the
+            vector along each axis.
+        'mean'
+            Pads with the mean value of all or part of the
+            vector along each axis.
+        'median'
+            Pads with the median value of all or part of the
+            vector along each axis.
+        'minimum'
+            Pads with the minimum value of all or part of the
+            vector along each axis.
+        'reflect'
+            Pads with the reflection of the vector mirrored on
+            the first and last values of the vector along each
+            axis.
+        'symmetric'
+            Pads with the reflection of the vector mirrored
+            along the edge of the array.
+        'wrap'
+            Pads with the wrap of the vector along the axis.
+            The first values are used to pad the end and the
+            end values are used to pad the beginning.
+        'empty'
+            Pads with undefined values.
+
+            .. versionadded:: 1.17
+
+        
+            Padding function, see Notes.
+    stat_length : sequence or int, optional
+        Used in 'maximum', 'mean', 'median', and 'minimum'.  Number of
+        values at edge of each axis used to calculate the statistic value.
+
+        ``((before_1, after_1), ... (before_N, after_N))`` unique statistic
+        lengths for each axis.
+
+        ``(before, after)`` or ``((before, after),)`` yields same before
+        and after statistic lengths for each axis.
+
+        ``(stat_length,)`` or ``int`` is a shortcut for
+        ``before = after = statistic`` length for all axes.
+
+        Default is ``None``, to use the entire axis.
+    constant_values : sequence or scalar, optional
+        Used in 'constant'.  The values to set the padded values for each
+        axis.
+
+        ``((before_1, after_1), ... (before_N, after_N))`` unique pad constants
+        for each axis.
+
+        ``(before, after)`` or ``((before, after),)`` yields same before
+        and after constants for each axis.
+
+        ``(constant,)`` or ``constant`` is a shortcut for
+        ``before = after = constant`` for all axes.
+
+        Default is 0.
+    end_values : sequence or scalar, optional
+        Used in 'linear_ramp'.  The values used for the ending value of the
+        linear_ramp and that will form the edge of the padded array.
+
+        ``((before_1, after_1), ... (before_N, after_N))`` unique end values
+        for each axis.
+
+        ``(before, after)`` or ``((before, after),)`` yields same before
+        and after end values for each axis.
+
+        ``(constant,)`` or ``constant`` is a shortcut for
+        ``before = after = constant`` for all axes.
+
+        Default is 0.
+    reflect_type : {'even', 'odd'}, optional
+        Used in 'reflect', and 'symmetric'.  The 'even' style is the
+        default with an unaltered reflection around the edge value.  For
+        the 'odd' style, the extended part of the array is created by
+        subtracting the reflected values from two times the edge value.
+
+    Returns
+    -------
+    pad : ndarray
+        Padded array of rank equal to `array` with shape increased
+        according to `pad_width`.
+
+    Notes
+    -----
+    .. versionadded:: 1.7.0
+
+    For an array with rank greater than 1, some of the padding of later
+    axes is calculated from padding of previous axes.  This is easiest to
+    think about with a rank 2 array where the corners of the padded array
+    are calculated by using padded values from the first axis.
+
+    The padding function, if used, should modify a rank 1 array in-place. It
+    has the following signature::
+
+        padding_func(vector, iaxis_pad_width, iaxis, kwargs)
+
+    where
+
+    vector : ndarray
+        A rank 1 array already padded with zeros.  Padded values are
+        vector[:iaxis_pad_width[0]] and vector[-iaxis_pad_width[1]:].
+    iaxis_pad_width : tuple
+        A 2-tuple of ints, iaxis_pad_width[0] represents the number of
+        values padded at the beginning of vector where
+        iaxis_pad_width[1] represents the number of values padded at
+        the end of vector.
+    iaxis : int
+        The axis currently being calculated.
+    kwargs : dict
+        Any keyword arguments the function requires.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> a = [1, 2, 3, 4, 5]
+    >>> np.pad(a, (2, 3), 'constant', constant_values=(4, 6))
+    array([4, 4, 1, ..., 6, 6, 6])
+
+    >>> np.pad(a, (2, 3), 'edge')
+    array([1, 1, 1, ..., 5, 5, 5])
+
+    >>> np.pad(a, (2, 3), 'linear_ramp', end_values=(5, -4))
+    array([ 5,  3,  1,  2,  3,  4,  5,  2, -1, -4])
+
+    >>> np.pad(a, (2,), 'maximum')
+    array([5, 5, 1, 2, 3, 4, 5, 5, 5])
+
+    >>> np.pad(a, (2,), 'mean')
+    array([3, 3, 1, 2, 3, 4, 5, 3, 3])
+
+    >>> np.pad(a, (2,), 'median')
+    array([3, 3, 1, 2, 3, 4, 5, 3, 3])
+
+    >>> a = [[1, 2], [3, 4]]
+    >>> np.pad(a, ((3, 2), (2, 3)), 'minimum')
+    array([[1, 1, 1, 2, 1, 1, 1],
+           [1, 1, 1, 2, 1, 1, 1],
+           [1, 1, 1, 2, 1, 1, 1],
+           [1, 1, 1, 2, 1, 1, 1],
+           [3, 3, 3, 4, 3, 3, 3],
+           [1, 1, 1, 2, 1, 1, 1],
+           [1, 1, 1, 2, 1, 1, 1]])
+
+    >>> a = [1, 2, 3, 4, 5]
+    >>> np.pad(a, (2, 3), 'reflect')
+    array([3, 2, 1, 2, 3, 4, 5, 4, 3, 2])
+
+    >>> np.pad(a, (2, 3), 'reflect', reflect_type='odd')
+    array([-1,  0,  1,  2,  3,  4,  5,  6,  7,  8])
+
+    >>> np.pad(a, (2, 3), 'symmetric')
+    array([2, 1, 1, 2, 3, 4, 5, 5, 4, 3])
+
+    >>> np.pad(a, (2, 3), 'symmetric', reflect_type='odd')
+    array([0, 1, 1, 2, 3, 4, 5, 5, 6, 7])
+
+    >>> np.pad(a, (2, 3), 'wrap')
+    array([4, 5, 1, 2, 3, 4, 5, 1, 2, 3])
+
+    >>> def pad_with(vector, pad_width, iaxis, kwargs):
+    ...     pad_value = kwargs.get('padder', 10)
+    ...     vector[:pad_width[0]] = pad_value
+    ...     vector[-pad_width[1]:] = pad_value
+    >>> a = np.arange(6)
+    >>> a = a.reshape((2, 3))
+    >>> np.pad(a, 2, pad_with)
+    array([[10, 10, 10, 10, 10, 10, 10],
+           [10, 10, 10, 10, 10, 10, 10],
+           [10, 10,  0,  1,  2, 10, 10],
+           [10, 10,  3,  4,  5, 10, 10],
+           [10, 10, 10, 10, 10, 10, 10],
+           [10, 10, 10, 10, 10, 10, 10]])
+    >>> np.pad(a, 2, pad_with, padder=100)
+    array([[100, 100, 100, 100, 100, 100, 100],
+           [100, 100, 100, 100, 100, 100, 100],
+           [100, 100,   0,   1,   2, 100, 100],
+           [100, 100,   3,   4,   5, 100, 100],
+           [100, 100, 100, 100, 100, 100, 100],
+           [100, 100, 100, 100, 100, 100, 100]])
+    """
+    array = np.asarray(array)
+    pad_width = np.asarray(pad_width)
+
+    if not pad_width.dtype.kind == 'i':
+        raise TypeError('`pad_width` must be of integral type.')
+
+    # Broadcast to shape (array.ndim, 2)
+    pad_width = _as_pairs(pad_width, array.ndim, as_index=True)
+
+    if callable(mode):
+        # Old behavior: Use user-supplied function with np.apply_along_axis
+        function = mode
+        # Create a new zero padded array
+        padded, _ = _pad_simple(array, pad_width, fill_value=0)
+        # And apply along each axis
+
+        for axis in range(padded.ndim):
+            # Iterate using ndindex as in apply_along_axis, but assuming that
+            # function operates inplace on the padded array.
+
+            # view with the iteration axis at the end
+            view = np.moveaxis(padded, axis, -1)
+
+            # compute indices for the iteration axes, and append a trailing
+            # ellipsis to prevent 0d arrays decaying to scalars (gh-8642)
+            inds = ndindex(view.shape[:-1])
+            inds = (ind + (Ellipsis,) for ind in inds)
+            for ind in inds:
+                function(view[ind], pad_width[axis], axis, kwargs)
+
+        return padded
+
+    # Make sure that no unsupported keywords were passed for the current mode
+    allowed_kwargs = {
+        'empty': [], 'edge': [], 'wrap': [],
+        'constant': ['constant_values'],
+        'linear_ramp': ['end_values'],
+        'maximum': ['stat_length'],
+        'mean': ['stat_length'],
+        'median': ['stat_length'],
+        'minimum': ['stat_length'],
+        'reflect': ['reflect_type'],
+        'symmetric': ['reflect_type'],
+    }
+    try:
+        unsupported_kwargs = set(kwargs) - set(allowed_kwargs[mode])
+    except KeyError:
+        raise ValueError("mode '{}' is not supported".format(mode)) from None
+    if unsupported_kwargs:
+        raise ValueError("unsupported keyword arguments for mode '{}': {}"
+                         .format(mode, unsupported_kwargs))
+
+    stat_functions = {"maximum": np.amax, "minimum": np.amin,
+                      "mean": np.mean, "median": np.median}
+
+    # Create array with final shape and original values
+    # (padded area is undefined)
+    padded, original_area_slice = _pad_simple(array, pad_width)
+    # And prepare iteration over all dimensions
+    # (zipping may be more readable than using enumerate)
+    axes = range(padded.ndim)
+
+    if mode == "constant":
+        values = kwargs.get("constant_values", 0)
+        values = _as_pairs(values, padded.ndim)
+        for axis, width_pair, value_pair in zip(axes, pad_width, values):
+            roi = _view_roi(padded, original_area_slice, axis)
+            _set_pad_area(roi, axis, width_pair, value_pair)
+
+    elif mode == "empty":
+        pass  # Do nothing as _pad_simple already returned the correct result
+
+    elif array.size == 0:
+        # Only modes "constant" and "empty" can extend empty axes, all other
+        # modes depend on `array` not being empty
+        # -> ensure every empty axis is only "padded with 0"
+        for axis, width_pair in zip(axes, pad_width):
+            if array.shape[axis] == 0 and any(width_pair):
+                raise ValueError(
+                    "can't extend empty axis {} using modes other than "
+                    "'constant' or 'empty'".format(axis)
+                )
+        # passed, don't need to do anything more as _pad_simple already
+        # returned the correct result
+
+    elif mode == "edge":
+        for axis, width_pair in zip(axes, pad_width):
+            roi = _view_roi(padded, original_area_slice, axis)
+            edge_pair = _get_edges(roi, axis, width_pair)
+            _set_pad_area(roi, axis, width_pair, edge_pair)
+
+    elif mode == "linear_ramp":
+        end_values = kwargs.get("end_values", 0)
+        end_values = _as_pairs(end_values, padded.ndim)
+        for axis, width_pair, value_pair in zip(axes, pad_width, end_values):
+            roi = _view_roi(padded, original_area_slice, axis)
+            ramp_pair = _get_linear_ramps(roi, axis, width_pair, value_pair)
+            _set_pad_area(roi, axis, width_pair, ramp_pair)
+
+    elif mode in stat_functions:
+        func = stat_functions[mode]
+        length = kwargs.get("stat_length", None)
+        length = _as_pairs(length, padded.ndim, as_index=True)
+        for axis, width_pair, length_pair in zip(axes, pad_width, length):
+            roi = _view_roi(padded, original_area_slice, axis)
+            stat_pair = _get_stats(roi, axis, width_pair, length_pair, func)
+            _set_pad_area(roi, axis, width_pair, stat_pair)
+
+    elif mode in {"reflect", "symmetric"}:
+        method = kwargs.get("reflect_type", "even")
+        include_edge = mode == "symmetric"
+        for axis, (left_index, right_index) in zip(axes, pad_width):
+            if array.shape[axis] == 1 and (left_index > 0 or right_index > 0):
+                # Extending singleton dimension for 'reflect' is legacy
+                # behavior; it really should raise an error.
+                edge_pair = _get_edges(padded, axis, (left_index, right_index))
+                _set_pad_area(
+                    padded, axis, (left_index, right_index), edge_pair)
+                continue
+
+            roi = _view_roi(padded, original_area_slice, axis)
+            while left_index > 0 or right_index > 0:
+                # Iteratively pad until dimension is filled with reflected
+                # values. This is necessary if the pad area is larger than
+                # the length of the original values in the current dimension.
+                left_index, right_index = _set_reflect_both(
+                    roi, axis, (left_index, right_index),
+                    method, array.shape[axis], include_edge
+                )
+
+    elif mode == "wrap":
+        for axis, (left_index, right_index) in zip(axes, pad_width):
+            roi = _view_roi(padded, original_area_slice, axis)
+            original_period = padded.shape[axis] - right_index - left_index
+            while left_index > 0 or right_index > 0:
+                # Iteratively pad until dimension is filled with wrapped
+                # values. This is necessary if the pad area is larger than
+                # the length of the original values in the current dimension.
+                left_index, right_index = _set_wrap_both(
+                    roi, axis, (left_index, right_index), original_period)
+
+    return padded
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/_arraypad_impl.pyi b/venv/lib/python3.12/site-packages/numpy/lib/_arraypad_impl.pyi
new file mode 100644
index 00000000..1ac6fc7d
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/lib/_arraypad_impl.pyi
@@ -0,0 +1,85 @@
+from typing import (
+    Literal as L,
+    Any,
+    overload,
+    TypeVar,
+    Protocol,
+)
+
+from numpy import generic
+
+from numpy._typing import (
+    ArrayLike,
+    NDArray,
+    _ArrayLikeInt,
+    _ArrayLike,
+)
+
+_SCT = TypeVar("_SCT", bound=generic)
+
+class _ModeFunc(Protocol):
+    def __call__(
+        self,
+        vector: NDArray[Any],
+        iaxis_pad_width: tuple[int, int],
+        iaxis: int,
+        kwargs: dict[str, Any],
+        /,
+    ) -> None: ...
+
+_ModeKind = L[
+    "constant",
+    "edge",
+    "linear_ramp",
+    "maximum",
+    "mean",
+    "median",
+    "minimum",
+    "reflect",
+    "symmetric",
+    "wrap",
+    "empty",
+]
+
+__all__: list[str]
+
+# TODO: In practice each keyword argument is exclusive to one or more
+# specific modes. Consider adding more overloads to express this in the future.
+
+# Expand `**kwargs` into explicit keyword-only arguments
+@overload
+def pad(
+    array: _ArrayLike[_SCT],
+    pad_width: _ArrayLikeInt,
+    mode: _ModeKind = ...,
+    *,
+    stat_length: None | _ArrayLikeInt = ...,
+    constant_values: ArrayLike = ...,
+    end_values: ArrayLike = ...,
+    reflect_type: L["odd", "even"] = ...,
+) -> NDArray[_SCT]: ...
+@overload
+def pad(
+    array: ArrayLike,
+    pad_width: _ArrayLikeInt,
+    mode: _ModeKind = ...,
+    *,
+    stat_length: None | _ArrayLikeInt = ...,
+    constant_values: ArrayLike = ...,
+    end_values: ArrayLike = ...,
+    reflect_type: L["odd", "even"] = ...,
+) -> NDArray[Any]: ...
+@overload
+def pad(
+    array: _ArrayLike[_SCT],
+    pad_width: _ArrayLikeInt,
+    mode: _ModeFunc,
+    **kwargs: Any,
+) -> NDArray[_SCT]: ...
+@overload
+def pad(
+    array: ArrayLike,
+    pad_width: _ArrayLikeInt,
+    mode: _ModeFunc,
+    **kwargs: Any,
+) -> NDArray[Any]: ...
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/_arraysetops_impl.py b/venv/lib/python3.12/site-packages/numpy/lib/_arraysetops_impl.py
new file mode 100644
index 00000000..3de2128c
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/lib/_arraysetops_impl.py
@@ -0,0 +1,1221 @@
+"""
+Set operations for arrays based on sorting.
+
+Notes
+-----
+
+For floating point arrays, inaccurate results may appear due to usual round-off
+and floating point comparison issues.
+
+Speed could be gained in some operations by an implementation of
+`numpy.sort`, that can provide directly the permutation vectors, thus avoiding
+calls to `numpy.argsort`.
+
+Original author: Robert Cimrman
+
+"""
+import functools
+import warnings
+from typing import NamedTuple
+
+import numpy as np
+from numpy._core import overrides
+from numpy._core._multiarray_umath import _array_converter
+
+
+array_function_dispatch = functools.partial(
+    overrides.array_function_dispatch, module='numpy')
+
+
+__all__ = [
+    "ediff1d", "in1d", "intersect1d", "isin", "setdiff1d", "setxor1d",
+    "union1d", "unique", "unique_all", "unique_counts", "unique_inverse",
+    "unique_values"
+]
+
+
+def _ediff1d_dispatcher(ary, to_end=None, to_begin=None):
+    return (ary, to_end, to_begin)
+
+
+@array_function_dispatch(_ediff1d_dispatcher)
+def ediff1d(ary, to_end=None, to_begin=None):
+    """
+    The differences between consecutive elements of an array.
+
+    Parameters
+    ----------
+    ary : array_like
+        If necessary, will be flattened before the differences are taken.
+    to_end : array_like, optional
+        Number(s) to append at the end of the returned differences.
+    to_begin : array_like, optional
+        Number(s) to prepend at the beginning of the returned differences.
+
+    Returns
+    -------
+    ediff1d : ndarray
+        The differences. Loosely, this is ``ary.flat[1:] - ary.flat[:-1]``.
+
+    See Also
+    --------
+    diff, gradient
+
+    Notes
+    -----
+    When applied to masked arrays, this function drops the mask information
+    if the `to_begin` and/or `to_end` parameters are used.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> x = np.array([1, 2, 4, 7, 0])
+    >>> np.ediff1d(x)
+    array([ 1,  2,  3, -7])
+
+    >>> np.ediff1d(x, to_begin=-99, to_end=np.array([88, 99]))
+    array([-99,   1,   2, ...,  -7,  88,  99])
+
+    The returned array is always 1D.
+
+    >>> y = [[1, 2, 4], [1, 6, 24]]
+    >>> np.ediff1d(y)
+    array([ 1,  2, -3,  5, 18])
+
+    """
+    conv = _array_converter(ary)
+    # Convert to (any) array and ravel:
+    ary = conv[0].ravel()
+
+    # enforce that the dtype of `ary` is used for the output
+    dtype_req = ary.dtype
+
+    # fast track default case
+    if to_begin is None and to_end is None:
+        return ary[1:] - ary[:-1]
+
+    if to_begin is None:
+        l_begin = 0
+    else:
+        to_begin = np.asanyarray(to_begin)
+        if not np.can_cast(to_begin, dtype_req, casting="same_kind"):
+            raise TypeError("dtype of `to_begin` must be compatible "
+                            "with input `ary` under the `same_kind` rule.")
+
+        to_begin = to_begin.ravel()
+        l_begin = len(to_begin)
+
+    if to_end is None:
+        l_end = 0
+    else:
+        to_end = np.asanyarray(to_end)
+        if not np.can_cast(to_end, dtype_req, casting="same_kind"):
+            raise TypeError("dtype of `to_end` must be compatible "
+                            "with input `ary` under the `same_kind` rule.")
+
+        to_end = to_end.ravel()
+        l_end = len(to_end)
+
+    # do the calculation in place and copy to_begin and to_end
+    l_diff = max(len(ary) - 1, 0)
+    result = np.empty_like(ary, shape=l_diff + l_begin + l_end)
+
+    if l_begin > 0:
+        result[:l_begin] = to_begin
+    if l_end > 0:
+        result[l_begin + l_diff:] = to_end
+    np.subtract(ary[1:], ary[:-1], result[l_begin:l_begin + l_diff])
+
+    return conv.wrap(result)
+
+
+def _unpack_tuple(x):
+    """ Unpacks one-element tuples for use as return values """
+    if len(x) == 1:
+        return x[0]
+    else:
+        return x
+
+
+def _unique_dispatcher(ar, return_index=None, return_inverse=None,
+                       return_counts=None, axis=None, *, equal_nan=None):
+    return (ar,)
+
+
+@array_function_dispatch(_unique_dispatcher)
+def unique(ar, return_index=False, return_inverse=False,
+           return_counts=False, axis=None, *, equal_nan=True):
+    """
+    Find the unique elements of an array.
+
+    Returns the sorted unique elements of an array. There are three optional
+    outputs in addition to the unique elements:
+
+    * the indices of the input array that give the unique values
+    * the indices of the unique array that reconstruct the input array
+    * the number of times each unique value comes up in the input array
+
+    Parameters
+    ----------
+    ar : array_like
+        Input array. Unless `axis` is specified, this will be flattened if it
+        is not already 1-D.
+    return_index : bool, optional
+        If True, also return the indices of `ar` (along the specified axis,
+        if provided, or in the flattened array) that result in the unique array.
+    return_inverse : bool, optional
+        If True, also return the indices of the unique array (for the specified
+        axis, if provided) that can be used to reconstruct `ar`.
+    return_counts : bool, optional
+        If True, also return the number of times each unique item appears
+        in `ar`.
+    axis : int or None, optional
+        The axis to operate on. If None, `ar` will be flattened. If an integer,
+        the subarrays indexed by the given axis will be flattened and treated
+        as the elements of a 1-D array with the dimension of the given axis,
+        see the notes for more details.  Object arrays or structured arrays
+        that contain objects are not supported if the `axis` kwarg is used. The
+        default is None.
+
+        .. versionadded:: 1.13.0
+
+    equal_nan : bool, optional
+        If True, collapses multiple NaN values in the return array into one.
+
+        .. versionadded:: 1.24
+
+    Returns
+    -------
+    unique : ndarray
+        The sorted unique values.
+    unique_indices : ndarray, optional
+        The indices of the first occurrences of the unique values in the
+        original array. Only provided if `return_index` is True.
+    unique_inverse : ndarray, optional
+        The indices to reconstruct the original array from the
+        unique array. Only provided if `return_inverse` is True.
+    unique_counts : ndarray, optional
+        The number of times each of the unique values comes up in the
+        original array. Only provided if `return_counts` is True.
+
+        .. versionadded:: 1.9.0
+
+    See Also
+    --------
+    repeat : Repeat elements of an array.
+
+    Notes
+    -----
+    When an axis is specified the subarrays indexed by the axis are sorted.
+    This is done by making the specified axis the first dimension of the array
+    (move the axis to the first dimension to keep the order of the other axes)
+    and then flattening the subarrays in C order. The flattened subarrays are
+    then viewed as a structured type with each element given a label, with the
+    effect that we end up with a 1-D array of structured types that can be
+    treated in the same way as any other 1-D array. The result is that the
+    flattened subarrays are sorted in lexicographic order starting with the
+    first element.
+
+    .. versionchanged: 1.21
+        If nan values are in the input array, a single nan is put
+        to the end of the sorted unique values.
+
+        Also for complex arrays all NaN values are considered equivalent
+        (no matter whether the NaN is in the real or imaginary part).
+        As the representant for the returned array the smallest one in the
+        lexicographical order is chosen - see np.sort for how the lexicographical
+        order is defined for complex arrays.
+
+    .. versionchanged: 2.0
+        For multi-dimensional inputs, ``unique_inverse`` is reshaped
+        such that the input can be reconstructed using
+        ``np.take(unique, unique_inverse, axis=axis)``. The result is
+        now not 1-dimensional when ``axis=None``.
+
+        Note that in NumPy 2.0.0 a higher dimensional array was returned also
+        when ``axis`` was not ``None``.  This was reverted, but
+        ``inverse.reshape(-1)`` can be used to ensure compatibility with both
+        versions.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> np.unique([1, 1, 2, 2, 3, 3])
+    array([1, 2, 3])
+    >>> a = np.array([[1, 1], [2, 3]])
+    >>> np.unique(a)
+    array([1, 2, 3])
+
+    Return the unique rows of a 2D array
+
+    >>> a = np.array([[1, 0, 0], [1, 0, 0], [2, 3, 4]])
+    >>> np.unique(a, axis=0)
+    array([[1, 0, 0], [2, 3, 4]])
+
+    Return the indices of the original array that give the unique values:
+
+    >>> a = np.array(['a', 'b', 'b', 'c', 'a'])
+    >>> u, indices = np.unique(a, return_index=True)
+    >>> u
+    array(['a', 'b', 'c'], dtype='>> indices
+    array([0, 1, 3])
+    >>> a[indices]
+    array(['a', 'b', 'c'], dtype='>> a = np.array([1, 2, 6, 4, 2, 3, 2])
+    >>> u, indices = np.unique(a, return_inverse=True)
+    >>> u
+    array([1, 2, 3, 4, 6])
+    >>> indices
+    array([0, 1, 4, 3, 1, 2, 1])
+    >>> u[indices]
+    array([1, 2, 6, 4, 2, 3, 2])
+
+    Reconstruct the input values from the unique values and counts:
+
+    >>> a = np.array([1, 2, 6, 4, 2, 3, 2])
+    >>> values, counts = np.unique(a, return_counts=True)
+    >>> values
+    array([1, 2, 3, 4, 6])
+    >>> counts
+    array([1, 3, 1, 1, 1])
+    >>> np.repeat(values, counts)
+    array([1, 2, 2, 2, 3, 4, 6])    # original order not preserved
+
+    """
+    ar = np.asanyarray(ar)
+    if axis is None:
+        ret = _unique1d(ar, return_index, return_inverse, return_counts, 
+                        equal_nan=equal_nan, inverse_shape=ar.shape, axis=None)
+        return _unpack_tuple(ret)
+
+    # axis was specified and not None
+    try:
+        ar = np.moveaxis(ar, axis, 0)
+    except np.exceptions.AxisError:
+        # this removes the "axis1" or "axis2" prefix from the error message
+        raise np.exceptions.AxisError(axis, ar.ndim) from None
+    inverse_shape = [1] * ar.ndim
+    inverse_shape[axis] = ar.shape[0]
+
+    # Must reshape to a contiguous 2D array for this to work...
+    orig_shape, orig_dtype = ar.shape, ar.dtype
+    ar = ar.reshape(orig_shape[0], np.prod(orig_shape[1:], dtype=np.intp))
+    ar = np.ascontiguousarray(ar)
+    dtype = [('f{i}'.format(i=i), ar.dtype) for i in range(ar.shape[1])]
+
+    # At this point, `ar` has shape `(n, m)`, and `dtype` is a structured
+    # data type with `m` fields where each field has the data type of `ar`.
+    # In the following, we create the array `consolidated`, which has
+    # shape `(n,)` with data type `dtype`.
+    try:
+        if ar.shape[1] > 0:
+            consolidated = ar.view(dtype)
+        else:
+            # If ar.shape[1] == 0, then dtype will be `np.dtype([])`, which is
+            # a data type with itemsize 0, and the call `ar.view(dtype)` will
+            # fail.  Instead, we'll use `np.empty` to explicitly create the
+            # array with shape `(len(ar),)`.  Because `dtype` in this case has
+            # itemsize 0, the total size of the result is still 0 bytes.
+            consolidated = np.empty(len(ar), dtype=dtype)
+    except TypeError as e:
+        # There's no good way to do this for object arrays, etc...
+        msg = 'The axis argument to unique is not supported for dtype {dt}'
+        raise TypeError(msg.format(dt=ar.dtype)) from e
+
+    def reshape_uniq(uniq):
+        n = len(uniq)
+        uniq = uniq.view(orig_dtype)
+        uniq = uniq.reshape(n, *orig_shape[1:])
+        uniq = np.moveaxis(uniq, 0, axis)
+        return uniq
+
+    output = _unique1d(consolidated, return_index,
+                       return_inverse, return_counts,
+                       equal_nan=equal_nan, inverse_shape=inverse_shape,
+                       axis=axis)
+    output = (reshape_uniq(output[0]),) + output[1:]
+    return _unpack_tuple(output)
+
+
+def _unique1d(ar, return_index=False, return_inverse=False,
+              return_counts=False, *, equal_nan=True, inverse_shape=None,
+              axis=None):
+    """
+    Find the unique elements of an array, ignoring shape.
+    """
+    ar = np.asanyarray(ar).flatten()
+
+    optional_indices = return_index or return_inverse
+
+    if optional_indices:
+        perm = ar.argsort(kind='mergesort' if return_index else 'quicksort')
+        aux = ar[perm]
+    else:
+        ar.sort()
+        aux = ar
+    mask = np.empty(aux.shape, dtype=np.bool)
+    mask[:1] = True
+    if (equal_nan and aux.shape[0] > 0 and aux.dtype.kind in "cfmM" and
+            np.isnan(aux[-1])):
+        if aux.dtype.kind == "c":  # for complex all NaNs are considered equivalent
+            aux_firstnan = np.searchsorted(np.isnan(aux), True, side='left')
+        else:
+            aux_firstnan = np.searchsorted(aux, aux[-1], side='left')
+        if aux_firstnan > 0:
+            mask[1:aux_firstnan] = (
+                aux[1:aux_firstnan] != aux[:aux_firstnan - 1])
+        mask[aux_firstnan] = True
+        mask[aux_firstnan + 1:] = False
+    else:
+        mask[1:] = aux[1:] != aux[:-1]
+
+    ret = (aux[mask],)
+    if return_index:
+        ret += (perm[mask],)
+    if return_inverse:
+        imask = np.cumsum(mask) - 1
+        inv_idx = np.empty(mask.shape, dtype=np.intp)
+        inv_idx[perm] = imask
+        ret += (inv_idx.reshape(inverse_shape) if axis is None else inv_idx,)
+    if return_counts:
+        idx = np.concatenate(np.nonzero(mask) + ([mask.size],))
+        ret += (np.diff(idx),)
+    return ret
+
+
+# Array API set functions
+
+class UniqueAllResult(NamedTuple):
+    values: np.ndarray
+    indices: np.ndarray
+    inverse_indices: np.ndarray
+    counts: np.ndarray
+
+
+class UniqueCountsResult(NamedTuple):
+    values: np.ndarray
+    counts: np.ndarray
+
+
+class UniqueInverseResult(NamedTuple):
+    values: np.ndarray
+    inverse_indices: np.ndarray
+
+
+def _unique_all_dispatcher(x, /):
+    return (x,)
+
+
+@array_function_dispatch(_unique_all_dispatcher)
+def unique_all(x):
+    """
+    Find the unique elements of an array, and counts, inverse and indices.
+
+    This function is an Array API compatible alternative to:
+
+    >>> x = np.array([1, 1, 2])
+    >>> np.unique(x, return_index=True, return_inverse=True,
+    ...           return_counts=True, equal_nan=False)
+    (array([1, 2]), array([0, 2]), array([0, 0, 1]), array([2, 1]))
+
+    Parameters
+    ----------
+    x : array_like
+        Input array. It will be flattened if it is not already 1-D.
+
+    Returns
+    -------
+    out : namedtuple
+        The result containing:
+
+        * values - The unique elements of an input array.
+        * indices - The first occurring indices for each unique element.
+        * inverse_indices - The indices from the set of unique elements
+          that reconstruct `x`.
+        * counts - The corresponding counts for each unique element.
+
+    See Also
+    --------
+    unique : Find the unique elements of an array.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> np.unique_all([1, 1, 2])
+    UniqueAllResult(values=array([1, 2]),
+                    indices=array([0, 2]),
+                    inverse_indices=array([0, 0, 1]),
+                    counts=array([2, 1]))
+
+    """
+    result = unique(
+        x,
+        return_index=True,
+        return_inverse=True,
+        return_counts=True,
+        equal_nan=False
+    )
+    return UniqueAllResult(*result)
+
+
+def _unique_counts_dispatcher(x, /):
+    return (x,)
+
+
+@array_function_dispatch(_unique_counts_dispatcher)
+def unique_counts(x):
+    """
+    Find the unique elements and counts of an input array `x`.
+
+    This function is an Array API compatible alternative to:
+
+    >>> x = np.array([1, 1, 2])
+    >>> np.unique(x, return_counts=True, equal_nan=False)
+    (array([1, 2]), array([2, 1]))
+
+    Parameters
+    ----------
+    x : array_like
+        Input array. It will be flattened if it is not already 1-D.
+
+    Returns
+    -------
+    out : namedtuple
+        The result containing:
+
+        * values - The unique elements of an input array.
+        * counts - The corresponding counts for each unique element.
+
+    See Also
+    --------
+    unique : Find the unique elements of an array.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> np.unique_counts([1, 1, 2])
+    UniqueCountsResult(values=array([1, 2]), counts=array([2, 1]))
+
+    """
+    result = unique(
+        x,
+        return_index=False,
+        return_inverse=False,
+        return_counts=True,
+        equal_nan=False
+    )
+    return UniqueCountsResult(*result)
+
+
+def _unique_inverse_dispatcher(x, /):
+    return (x,)
+
+
+@array_function_dispatch(_unique_inverse_dispatcher)
+def unique_inverse(x):
+    """
+    Find the unique elements of `x` and indices to reconstruct `x`.
+
+    This function is Array API compatible alternative to:
+
+    >>> x = np.array([1, 1, 2])
+    >>> np.unique(x, return_inverse=True, equal_nan=False)
+    (array([1, 2]), array([0, 0, 1]))
+
+    Parameters
+    ----------
+    x : array_like
+        Input array. It will be flattened if it is not already 1-D.
+
+    Returns
+    -------
+    out : namedtuple
+        The result containing:
+
+        * values - The unique elements of an input array.
+        * inverse_indices - The indices from the set of unique elements
+          that reconstruct `x`.
+
+    See Also
+    --------
+    unique : Find the unique elements of an array.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> np.unique_inverse([1, 1, 2])
+    UniqueInverseResult(values=array([1, 2]), inverse_indices=array([0, 0, 1]))
+
+    """
+    result = unique(
+        x,
+        return_index=False,
+        return_inverse=True,
+        return_counts=False,
+        equal_nan=False
+    )
+    return UniqueInverseResult(*result)
+
+
+def _unique_values_dispatcher(x, /):
+    return (x,)
+
+
+@array_function_dispatch(_unique_values_dispatcher)
+def unique_values(x):
+    """
+    Returns the unique elements of an input array `x`.
+
+    This function is Array API compatible alternative to:
+
+    >>> x = np.array([1, 1, 2])
+    >>> np.unique(x, equal_nan=False)
+    array([1, 2])
+
+    Parameters
+    ----------
+    x : array_like
+        Input array. It will be flattened if it is not already 1-D.
+
+    Returns
+    -------
+    out : ndarray
+        The unique elements of an input array.
+
+    See Also
+    --------
+    unique : Find the unique elements of an array.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> np.unique_values([1, 1, 2])
+    array([1, 2])
+
+    """
+    return unique(
+        x,
+        return_index=False,
+        return_inverse=False,
+        return_counts=False,
+        equal_nan=False
+    )
+
+
+def _intersect1d_dispatcher(
+        ar1, ar2, assume_unique=None, return_indices=None):
+    return (ar1, ar2)
+
+
+@array_function_dispatch(_intersect1d_dispatcher)
+def intersect1d(ar1, ar2, assume_unique=False, return_indices=False):
+    """
+    Find the intersection of two arrays.
+
+    Return the sorted, unique values that are in both of the input arrays.
+
+    Parameters
+    ----------
+    ar1, ar2 : array_like
+        Input arrays. Will be flattened if not already 1D.
+    assume_unique : bool
+        If True, the input arrays are both assumed to be unique, which
+        can speed up the calculation.  If True but ``ar1`` or ``ar2`` are not
+        unique, incorrect results and out-of-bounds indices could result.
+        Default is False.
+    return_indices : bool
+        If True, the indices which correspond to the intersection of the two
+        arrays are returned. The first instance of a value is used if there are
+        multiple. Default is False.
+
+        .. versionadded:: 1.15.0
+
+    Returns
+    -------
+    intersect1d : ndarray
+        Sorted 1D array of common and unique elements.
+    comm1 : ndarray
+        The indices of the first occurrences of the common values in `ar1`.
+        Only provided if `return_indices` is True.
+    comm2 : ndarray
+        The indices of the first occurrences of the common values in `ar2`.
+        Only provided if `return_indices` is True.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> np.intersect1d([1, 3, 4, 3], [3, 1, 2, 1])
+    array([1, 3])
+
+    To intersect more than two arrays, use functools.reduce:
+
+    >>> from functools import reduce
+    >>> reduce(np.intersect1d, ([1, 3, 4, 3], [3, 1, 2, 1], [6, 3, 4, 2]))
+    array([3])
+
+    To return the indices of the values common to the input arrays
+    along with the intersected values:
+
+    >>> x = np.array([1, 1, 2, 3, 4])
+    >>> y = np.array([2, 1, 4, 6])
+    >>> xy, x_ind, y_ind = np.intersect1d(x, y, return_indices=True)
+    >>> x_ind, y_ind
+    (array([0, 2, 4]), array([1, 0, 2]))
+    >>> xy, x[x_ind], y[y_ind]
+    (array([1, 2, 4]), array([1, 2, 4]), array([1, 2, 4]))
+
+    """
+    ar1 = np.asanyarray(ar1)
+    ar2 = np.asanyarray(ar2)
+
+    if not assume_unique:
+        if return_indices:
+            ar1, ind1 = unique(ar1, return_index=True)
+            ar2, ind2 = unique(ar2, return_index=True)
+        else:
+            ar1 = unique(ar1)
+            ar2 = unique(ar2)
+    else:
+        ar1 = ar1.ravel()
+        ar2 = ar2.ravel()
+
+    aux = np.concatenate((ar1, ar2))
+    if return_indices:
+        aux_sort_indices = np.argsort(aux, kind='mergesort')
+        aux = aux[aux_sort_indices]
+    else:
+        aux.sort()
+
+    mask = aux[1:] == aux[:-1]
+    int1d = aux[:-1][mask]
+
+    if return_indices:
+        ar1_indices = aux_sort_indices[:-1][mask]
+        ar2_indices = aux_sort_indices[1:][mask] - ar1.size
+        if not assume_unique:
+            ar1_indices = ind1[ar1_indices]
+            ar2_indices = ind2[ar2_indices]
+
+        return int1d, ar1_indices, ar2_indices
+    else:
+        return int1d
+
+
+def _setxor1d_dispatcher(ar1, ar2, assume_unique=None):
+    return (ar1, ar2)
+
+
+@array_function_dispatch(_setxor1d_dispatcher)
+def setxor1d(ar1, ar2, assume_unique=False):
+    """
+    Find the set exclusive-or of two arrays.
+
+    Return the sorted, unique values that are in only one (not both) of the
+    input arrays.
+
+    Parameters
+    ----------
+    ar1, ar2 : array_like
+        Input arrays.
+    assume_unique : bool
+        If True, the input arrays are both assumed to be unique, which
+        can speed up the calculation. Default is False.
+
+    Returns
+    -------
+    setxor1d : ndarray
+        Sorted 1D array of unique values that are in only one of the input
+        arrays.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> a = np.array([1, 2, 3, 2, 4])
+    >>> b = np.array([2, 3, 5, 7, 5])
+    >>> np.setxor1d(a,b)
+    array([1, 4, 5, 7])
+
+    """
+    if not assume_unique:
+        ar1 = unique(ar1)
+        ar2 = unique(ar2)
+
+    aux = np.concatenate((ar1, ar2), axis=None)
+    if aux.size == 0:
+        return aux
+
+    aux.sort()
+    flag = np.concatenate(([True], aux[1:] != aux[:-1], [True]))
+    return aux[flag[1:] & flag[:-1]]
+
+
+def _in1d_dispatcher(ar1, ar2, assume_unique=None, invert=None, *,
+                     kind=None):
+    return (ar1, ar2)
+
+
+@array_function_dispatch(_in1d_dispatcher)
+def in1d(ar1, ar2, assume_unique=False, invert=False, *, kind=None):
+    """
+    Test whether each element of a 1-D array is also present in a second array.
+
+    .. deprecated:: 2.0
+        Use :func:`isin` instead of `in1d` for new code.
+
+    Returns a boolean array the same length as `ar1` that is True
+    where an element of `ar1` is in `ar2` and False otherwise.
+
+    Parameters
+    ----------
+    ar1 : (M,) array_like
+        Input array.
+    ar2 : array_like
+        The values against which to test each value of `ar1`.
+    assume_unique : bool, optional
+        If True, the input arrays are both assumed to be unique, which
+        can speed up the calculation.  Default is False.
+    invert : bool, optional
+        If True, the values in the returned array are inverted (that is,
+        False where an element of `ar1` is in `ar2` and True otherwise).
+        Default is False. ``np.in1d(a, b, invert=True)`` is equivalent
+        to (but is faster than) ``np.invert(in1d(a, b))``.
+    kind : {None, 'sort', 'table'}, optional
+        The algorithm to use. This will not affect the final result,
+        but will affect the speed and memory use. The default, None,
+        will select automatically based on memory considerations.
+
+        * If 'sort', will use a mergesort-based approach. This will have
+          a memory usage of roughly 6 times the sum of the sizes of
+          `ar1` and `ar2`, not accounting for size of dtypes.
+        * If 'table', will use a lookup table approach similar
+          to a counting sort. This is only available for boolean and
+          integer arrays. This will have a memory usage of the
+          size of `ar1` plus the max-min value of `ar2`. `assume_unique`
+          has no effect when the 'table' option is used.
+        * If None, will automatically choose 'table' if
+          the required memory allocation is less than or equal to
+          6 times the sum of the sizes of `ar1` and `ar2`,
+          otherwise will use 'sort'. This is done to not use
+          a large amount of memory by default, even though
+          'table' may be faster in most cases. If 'table' is chosen,
+          `assume_unique` will have no effect.
+
+        .. versionadded:: 1.8.0
+
+    Returns
+    -------
+    in1d : (M,) ndarray, bool
+        The values `ar1[in1d]` are in `ar2`.
+
+    See Also
+    --------
+    isin                  : Version of this function that preserves the
+                            shape of ar1.
+
+    Notes
+    -----
+    `in1d` can be considered as an element-wise function version of the
+    python keyword `in`, for 1-D sequences. ``in1d(a, b)`` is roughly
+    equivalent to ``np.array([item in b for item in a])``.
+    However, this idea fails if `ar2` is a set, or similar (non-sequence)
+    container:  As ``ar2`` is converted to an array, in those cases
+    ``asarray(ar2)`` is an object array rather than the expected array of
+    contained values.
+
+    Using ``kind='table'`` tends to be faster than `kind='sort'` if the
+    following relationship is true:
+    ``log10(len(ar2)) > (log10(max(ar2)-min(ar2)) - 2.27) / 0.927``,
+    but may use greater memory. The default value for `kind` will
+    be automatically selected based only on memory usage, so one may
+    manually set ``kind='table'`` if memory constraints can be relaxed.
+
+    .. versionadded:: 1.4.0
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> test = np.array([0, 1, 2, 5, 0])
+    >>> states = [0, 2]
+    >>> mask = np.in1d(test, states)
+    >>> mask
+    array([ True, False,  True, False,  True])
+    >>> test[mask]
+    array([0, 2, 0])
+    >>> mask = np.in1d(test, states, invert=True)
+    >>> mask
+    array([False,  True, False,  True, False])
+    >>> test[mask]
+    array([1, 5])
+    """
+
+    # Deprecated in NumPy 2.0, 2023-08-18
+    warnings.warn(
+        "`in1d` is deprecated. Use `np.isin` instead.",
+        DeprecationWarning,
+        stacklevel=2
+    )
+
+    return _in1d(ar1, ar2, assume_unique, invert, kind=kind)
+
+
+def _in1d(ar1, ar2, assume_unique=False, invert=False, *, kind=None):
+    # Ravel both arrays, behavior for the first array could be different
+    ar1 = np.asarray(ar1).ravel()
+    ar2 = np.asarray(ar2).ravel()
+
+    # Ensure that iteration through object arrays yields size-1 arrays
+    if ar2.dtype == object:
+        ar2 = ar2.reshape(-1, 1)
+
+    if kind not in {None, 'sort', 'table'}:
+        raise ValueError(
+            f"Invalid kind: '{kind}'. Please use None, 'sort' or 'table'.")
+
+    # Can use the table method if all arrays are integers or boolean:
+    is_int_arrays = all(ar.dtype.kind in ("u", "i", "b") for ar in (ar1, ar2))
+    use_table_method = is_int_arrays and kind in {None, 'table'}
+
+    if use_table_method:
+        if ar2.size == 0:
+            if invert:
+                return np.ones_like(ar1, dtype=bool)
+            else:
+                return np.zeros_like(ar1, dtype=bool)
+
+        # Convert booleans to uint8 so we can use the fast integer algorithm
+        if ar1.dtype == bool:
+            ar1 = ar1.astype(np.uint8)
+        if ar2.dtype == bool:
+            ar2 = ar2.astype(np.uint8)
+
+        ar2_min = int(np.min(ar2))
+        ar2_max = int(np.max(ar2))
+
+        ar2_range = ar2_max - ar2_min
+
+        # Constraints on whether we can actually use the table method:
+        #  1. Assert memory usage is not too large
+        below_memory_constraint = ar2_range <= 6 * (ar1.size + ar2.size)
+        #  2. Check overflows for (ar2 - ar2_min); dtype=ar2.dtype
+        range_safe_from_overflow = ar2_range <= np.iinfo(ar2.dtype).max
+
+        # Optimal performance is for approximately
+        # log10(size) > (log10(range) - 2.27) / 0.927.
+        # However, here we set the requirement that by default
+        # the intermediate array can only be 6x
+        # the combined memory allocation of the original
+        # arrays. See discussion on 
+        # https://github.com/numpy/numpy/pull/12065.
+
+        if (
+            range_safe_from_overflow and 
+            (below_memory_constraint or kind == 'table')
+        ):
+
+            if invert:
+                outgoing_array = np.ones_like(ar1, dtype=bool)
+            else:
+                outgoing_array = np.zeros_like(ar1, dtype=bool)
+
+            # Make elements 1 where the integer exists in ar2
+            if invert:
+                isin_helper_ar = np.ones(ar2_range + 1, dtype=bool)
+                isin_helper_ar[ar2 - ar2_min] = 0
+            else:
+                isin_helper_ar = np.zeros(ar2_range + 1, dtype=bool)
+                isin_helper_ar[ar2 - ar2_min] = 1
+
+            # Mask out elements we know won't work
+            basic_mask = (ar1 <= ar2_max) & (ar1 >= ar2_min)
+            in_range_ar1 = ar1[basic_mask]
+            if in_range_ar1.size == 0:
+                # Nothing more to do, since all values are out of range.
+                return outgoing_array
+
+            # Unfortunately, ar2_min can be out of range for `intp` even
+            # if the calculation result must fit in range (and be positive).
+            # In that case, use ar2.dtype which must work for all unmasked
+            # values.
+            try:
+                ar2_min = np.array(ar2_min, dtype=np.intp)
+                dtype = np.intp
+            except OverflowError:
+                dtype = ar2.dtype
+
+            out = np.empty_like(in_range_ar1, dtype=np.intp)
+            outgoing_array[basic_mask] = isin_helper_ar[
+                    np.subtract(in_range_ar1, ar2_min, dtype=dtype,
+                                out=out, casting="unsafe")]
+
+            return outgoing_array
+        elif kind == 'table':  # not range_safe_from_overflow
+            raise RuntimeError(
+                "You have specified kind='table', "
+                "but the range of values in `ar2` or `ar1` exceed the "
+                "maximum integer of the datatype. "
+                "Please set `kind` to None or 'sort'."
+            )
+    elif kind == 'table':
+        raise ValueError(
+            "The 'table' method is only "
+            "supported for boolean or integer arrays. "
+            "Please select 'sort' or None for kind."
+        )
+
+
+    # Check if one of the arrays may contain arbitrary objects
+    contains_object = ar1.dtype.hasobject or ar2.dtype.hasobject
+
+    # This code is run when
+    # a) the first condition is true, making the code significantly faster
+    # b) the second condition is true (i.e. `ar1` or `ar2` may contain
+    #    arbitrary objects), since then sorting is not guaranteed to work
+    if len(ar2) < 10 * len(ar1) ** 0.145 or contains_object:
+        if invert:
+            mask = np.ones(len(ar1), dtype=bool)
+            for a in ar2:
+                mask &= (ar1 != a)
+        else:
+            mask = np.zeros(len(ar1), dtype=bool)
+            for a in ar2:
+                mask |= (ar1 == a)
+        return mask
+
+    # Otherwise use sorting
+    if not assume_unique:
+        ar1, rev_idx = np.unique(ar1, return_inverse=True)
+        ar2 = np.unique(ar2)
+
+    ar = np.concatenate((ar1, ar2))
+    # We need this to be a stable sort, so always use 'mergesort'
+    # here. The values from the first array should always come before
+    # the values from the second array.
+    order = ar.argsort(kind='mergesort')
+    sar = ar[order]
+    if invert:
+        bool_ar = (sar[1:] != sar[:-1])
+    else:
+        bool_ar = (sar[1:] == sar[:-1])
+    flag = np.concatenate((bool_ar, [invert]))
+    ret = np.empty(ar.shape, dtype=bool)
+    ret[order] = flag
+
+    if assume_unique:
+        return ret[:len(ar1)]
+    else:
+        return ret[rev_idx]
+
+
+def _isin_dispatcher(element, test_elements, assume_unique=None, invert=None,
+                     *, kind=None):
+    return (element, test_elements)
+
+
+@array_function_dispatch(_isin_dispatcher)
+def isin(element, test_elements, assume_unique=False, invert=False, *,
+         kind=None):
+    """
+    Calculates ``element in test_elements``, broadcasting over `element` only.
+    Returns a boolean array of the same shape as `element` that is True
+    where an element of `element` is in `test_elements` and False otherwise.
+
+    Parameters
+    ----------
+    element : array_like
+        Input array.
+    test_elements : array_like
+        The values against which to test each value of `element`.
+        This argument is flattened if it is an array or array_like.
+        See notes for behavior with non-array-like parameters.
+    assume_unique : bool, optional
+        If True, the input arrays are both assumed to be unique, which
+        can speed up the calculation.  Default is False.
+    invert : bool, optional
+        If True, the values in the returned array are inverted, as if
+        calculating `element not in test_elements`. Default is False.
+        ``np.isin(a, b, invert=True)`` is equivalent to (but faster
+        than) ``np.invert(np.isin(a, b))``.
+    kind : {None, 'sort', 'table'}, optional
+        The algorithm to use. This will not affect the final result,
+        but will affect the speed and memory use. The default, None,
+        will select automatically based on memory considerations.
+
+        * If 'sort', will use a mergesort-based approach. This will have
+          a memory usage of roughly 6 times the sum of the sizes of
+          `element` and `test_elements`, not accounting for size of dtypes.
+        * If 'table', will use a lookup table approach similar
+          to a counting sort. This is only available for boolean and
+          integer arrays. This will have a memory usage of the
+          size of `element` plus the max-min value of `test_elements`.
+          `assume_unique` has no effect when the 'table' option is used.
+        * If None, will automatically choose 'table' if
+          the required memory allocation is less than or equal to
+          6 times the sum of the sizes of `element` and `test_elements`,
+          otherwise will use 'sort'. This is done to not use
+          a large amount of memory by default, even though
+          'table' may be faster in most cases. If 'table' is chosen,
+          `assume_unique` will have no effect.
+
+
+    Returns
+    -------
+    isin : ndarray, bool
+        Has the same shape as `element`. The values `element[isin]`
+        are in `test_elements`.
+
+    Notes
+    -----
+
+    `isin` is an element-wise function version of the python keyword `in`.
+    ``isin(a, b)`` is roughly equivalent to
+    ``np.array([item in b for item in a])`` if `a` and `b` are 1-D sequences.
+
+    `element` and `test_elements` are converted to arrays if they are not
+    already. If `test_elements` is a set (or other non-sequence collection)
+    it will be converted to an object array with one element, rather than an
+    array of the values contained in `test_elements`. This is a consequence
+    of the `array` constructor's way of handling non-sequence collections.
+    Converting the set to a list usually gives the desired behavior.
+
+    Using ``kind='table'`` tends to be faster than `kind='sort'` if the
+    following relationship is true:
+    ``log10(len(test_elements)) >
+    (log10(max(test_elements)-min(test_elements)) - 2.27) / 0.927``,
+    but may use greater memory. The default value for `kind` will
+    be automatically selected based only on memory usage, so one may
+    manually set ``kind='table'`` if memory constraints can be relaxed.
+
+    .. versionadded:: 1.13.0
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> element = 2*np.arange(4).reshape((2, 2))
+    >>> element
+    array([[0, 2],
+           [4, 6]])
+    >>> test_elements = [1, 2, 4, 8]
+    >>> mask = np.isin(element, test_elements)
+    >>> mask
+    array([[False,  True],
+           [ True, False]])
+    >>> element[mask]
+    array([2, 4])
+
+    The indices of the matched values can be obtained with `nonzero`:
+
+    >>> np.nonzero(mask)
+    (array([0, 1]), array([1, 0]))
+
+    The test can also be inverted:
+
+    >>> mask = np.isin(element, test_elements, invert=True)
+    >>> mask
+    array([[ True, False],
+           [False,  True]])
+    >>> element[mask]
+    array([0, 6])
+
+    Because of how `array` handles sets, the following does not
+    work as expected:
+
+    >>> test_set = {1, 2, 4, 8}
+    >>> np.isin(element, test_set)
+    array([[False, False],
+           [False, False]])
+
+    Casting the set to a list gives the expected result:
+
+    >>> np.isin(element, list(test_set))
+    array([[False,  True],
+           [ True, False]])
+    """
+    element = np.asarray(element)
+    return _in1d(element, test_elements, assume_unique=assume_unique,
+                 invert=invert, kind=kind).reshape(element.shape)
+
+
+def _union1d_dispatcher(ar1, ar2):
+    return (ar1, ar2)
+
+
+@array_function_dispatch(_union1d_dispatcher)
+def union1d(ar1, ar2):
+    """
+    Find the union of two arrays.
+
+    Return the unique, sorted array of values that are in either of the two
+    input arrays.
+
+    Parameters
+    ----------
+    ar1, ar2 : array_like
+        Input arrays. They are flattened if they are not already 1D.
+
+    Returns
+    -------
+    union1d : ndarray
+        Unique, sorted union of the input arrays.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> np.union1d([-1, 0, 1], [-2, 0, 2])
+    array([-2, -1,  0,  1,  2])
+
+    To find the union of more than two arrays, use functools.reduce:
+
+    >>> from functools import reduce
+    >>> reduce(np.union1d, ([1, 3, 4, 3], [3, 1, 2, 1], [6, 3, 4, 2]))
+    array([1, 2, 3, 4, 6])
+    """
+    return unique(np.concatenate((ar1, ar2), axis=None))
+
+
+def _setdiff1d_dispatcher(ar1, ar2, assume_unique=None):
+    return (ar1, ar2)
+
+
+@array_function_dispatch(_setdiff1d_dispatcher)
+def setdiff1d(ar1, ar2, assume_unique=False):
+    """
+    Find the set difference of two arrays.
+
+    Return the unique values in `ar1` that are not in `ar2`.
+
+    Parameters
+    ----------
+    ar1 : array_like
+        Input array.
+    ar2 : array_like
+        Input comparison array.
+    assume_unique : bool
+        If True, the input arrays are both assumed to be unique, which
+        can speed up the calculation.  Default is False.
+
+    Returns
+    -------
+    setdiff1d : ndarray
+        1D array of values in `ar1` that are not in `ar2`. The result
+        is sorted when `assume_unique=False`, but otherwise only sorted
+        if the input is sorted.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> a = np.array([1, 2, 3, 2, 4, 1])
+    >>> b = np.array([3, 4, 5, 6])
+    >>> np.setdiff1d(a, b)
+    array([1, 2])
+
+    """
+    if assume_unique:
+        ar1 = np.asarray(ar1).ravel()
+    else:
+        ar1 = unique(ar1)
+        ar2 = unique(ar2)
+    return ar1[_in1d(ar1, ar2, assume_unique=True, invert=True)]
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/_arraysetops_impl.pyi b/venv/lib/python3.12/site-packages/numpy/lib/_arraysetops_impl.pyi
new file mode 100644
index 00000000..95498248
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/lib/_arraysetops_impl.pyi
@@ -0,0 +1,399 @@
+from typing import (
+    Any,
+    Generic,
+    Literal as L,
+    NamedTuple,
+    overload,
+    SupportsIndex,
+    TypeVar,
+)
+
+import numpy as np
+from numpy import (
+    generic,
+    number,
+    ushort,
+    ubyte,
+    uintc,
+    uint,
+    ulonglong,
+    short,
+    int8,
+    byte,
+    intc,
+    int_,
+    intp,
+    longlong,
+    half,
+    single,
+    double,
+    longdouble,
+    csingle,
+    cdouble,
+    clongdouble,
+    timedelta64,
+    datetime64,
+    object_,
+    str_,
+    bytes_,
+    void,
+)
+
+from numpy._typing import (
+    ArrayLike,
+    NDArray,
+    _ArrayLike,
+    _ArrayLikeBool_co,
+    _ArrayLikeDT64_co,
+    _ArrayLikeTD64_co,
+    _ArrayLikeObject_co,
+    _ArrayLikeNumber_co,
+)
+
+_SCT = TypeVar("_SCT", bound=generic)
+_NumberType = TypeVar("_NumberType", bound=number[Any])
+
+# Explicitly set all allowed values to prevent accidental castings to
+# abstract dtypes (their common super-type).
+#
+# Only relevant if two or more arguments are parametrized, (e.g. `setdiff1d`)
+# which could result in, for example, `int64` and `float64`producing a
+# `number[_64Bit]` array
+_SCTNoCast = TypeVar(
+    "_SCTNoCast",
+    np.bool,
+    ushort,
+    ubyte,
+    uintc,
+    uint,
+    ulonglong,
+    short,
+    byte,
+    intc,
+    int_,
+    longlong,
+    half,
+    single,
+    double,
+    longdouble,
+    csingle,
+    cdouble,
+    clongdouble,
+    timedelta64,
+    datetime64,
+    object_,
+    str_,
+    bytes_,
+    void,
+)
+
+class UniqueAllResult(NamedTuple, Generic[_SCT]):
+    values: NDArray[_SCT]
+    indices: NDArray[intp]
+    inverse_indices: NDArray[intp]
+    counts: NDArray[intp]
+
+class UniqueCountsResult(NamedTuple, Generic[_SCT]):
+    values: NDArray[_SCT]
+    counts: NDArray[intp]
+
+class UniqueInverseResult(NamedTuple, Generic[_SCT]):
+    values: NDArray[_SCT]
+    inverse_indices: NDArray[intp]
+
+__all__: list[str]
+
+@overload
+def ediff1d(
+    ary: _ArrayLikeBool_co,
+    to_end: None | ArrayLike = ...,
+    to_begin: None | ArrayLike = ...,
+) -> NDArray[int8]: ...
+@overload
+def ediff1d(
+    ary: _ArrayLike[_NumberType],
+    to_end: None | ArrayLike = ...,
+    to_begin: None | ArrayLike = ...,
+) -> NDArray[_NumberType]: ...
+@overload
+def ediff1d(
+    ary: _ArrayLikeNumber_co,
+    to_end: None | ArrayLike = ...,
+    to_begin: None | ArrayLike = ...,
+) -> NDArray[Any]: ...
+@overload
+def ediff1d(
+    ary: _ArrayLikeDT64_co | _ArrayLikeTD64_co,
+    to_end: None | ArrayLike = ...,
+    to_begin: None | ArrayLike = ...,
+) -> NDArray[timedelta64]: ...
+@overload
+def ediff1d(
+    ary: _ArrayLikeObject_co,
+    to_end: None | ArrayLike = ...,
+    to_begin: None | ArrayLike = ...,
+) -> NDArray[object_]: ...
+
+@overload
+def unique(
+    ar: _ArrayLike[_SCT],
+    return_index: L[False] = ...,
+    return_inverse: L[False] = ...,
+    return_counts: L[False] = ...,
+    axis: None | SupportsIndex = ...,
+    *,
+    equal_nan: bool = ...,
+) -> NDArray[_SCT]: ...
+@overload
+def unique(
+    ar: ArrayLike,
+    return_index: L[False] = ...,
+    return_inverse: L[False] = ...,
+    return_counts: L[False] = ...,
+    axis: None | SupportsIndex = ...,
+    *,
+    equal_nan: bool = ...,
+) -> NDArray[Any]: ...
+@overload
+def unique(
+    ar: _ArrayLike[_SCT],
+    return_index: L[True] = ...,
+    return_inverse: L[False] = ...,
+    return_counts: L[False] = ...,
+    axis: None | SupportsIndex = ...,
+    *,
+    equal_nan: bool = ...,
+) -> tuple[NDArray[_SCT], NDArray[intp]]: ...
+@overload
+def unique(
+    ar: ArrayLike,
+    return_index: L[True] = ...,
+    return_inverse: L[False] = ...,
+    return_counts: L[False] = ...,
+    axis: None | SupportsIndex = ...,
+    *,
+    equal_nan: bool = ...,
+) -> tuple[NDArray[Any], NDArray[intp]]: ...
+@overload
+def unique(
+    ar: _ArrayLike[_SCT],
+    return_index: L[False] = ...,
+    return_inverse: L[True] = ...,
+    return_counts: L[False] = ...,
+    axis: None | SupportsIndex = ...,
+    *,
+    equal_nan: bool = ...,
+) -> tuple[NDArray[_SCT], NDArray[intp]]: ...
+@overload
+def unique(
+    ar: ArrayLike,
+    return_index: L[False] = ...,
+    return_inverse: L[True] = ...,
+    return_counts: L[False] = ...,
+    axis: None | SupportsIndex = ...,
+    *,
+    equal_nan: bool = ...,
+) -> tuple[NDArray[Any], NDArray[intp]]: ...
+@overload
+def unique(
+    ar: _ArrayLike[_SCT],
+    return_index: L[False] = ...,
+    return_inverse: L[False] = ...,
+    return_counts: L[True] = ...,
+    axis: None | SupportsIndex = ...,
+    *,
+    equal_nan: bool = ...,
+) -> tuple[NDArray[_SCT], NDArray[intp]]: ...
+@overload
+def unique(
+    ar: ArrayLike,
+    return_index: L[False] = ...,
+    return_inverse: L[False] = ...,
+    return_counts: L[True] = ...,
+    axis: None | SupportsIndex = ...,
+    *,
+    equal_nan: bool = ...,
+) -> tuple[NDArray[Any], NDArray[intp]]: ...
+@overload
+def unique(
+    ar: _ArrayLike[_SCT],
+    return_index: L[True] = ...,
+    return_inverse: L[True] = ...,
+    return_counts: L[False] = ...,
+    axis: None | SupportsIndex = ...,
+    *,
+    equal_nan: bool = ...,
+) -> tuple[NDArray[_SCT], NDArray[intp], NDArray[intp]]: ...
+@overload
+def unique(
+    ar: ArrayLike,
+    return_index: L[True] = ...,
+    return_inverse: L[True] = ...,
+    return_counts: L[False] = ...,
+    axis: None | SupportsIndex = ...,
+    *,
+    equal_nan: bool = ...,
+) -> tuple[NDArray[Any], NDArray[intp], NDArray[intp]]: ...
+@overload
+def unique(
+    ar: _ArrayLike[_SCT],
+    return_index: L[True] = ...,
+    return_inverse: L[False] = ...,
+    return_counts: L[True] = ...,
+    axis: None | SupportsIndex = ...,
+    *,
+    equal_nan: bool = ...,
+) -> tuple[NDArray[_SCT], NDArray[intp], NDArray[intp]]: ...
+@overload
+def unique(
+    ar: ArrayLike,
+    return_index: L[True] = ...,
+    return_inverse: L[False] = ...,
+    return_counts: L[True] = ...,
+    axis: None | SupportsIndex = ...,
+    *,
+    equal_nan: bool = ...,
+) -> tuple[NDArray[Any], NDArray[intp], NDArray[intp]]: ...
+@overload
+def unique(
+    ar: _ArrayLike[_SCT],
+    return_index: L[False] = ...,
+    return_inverse: L[True] = ...,
+    return_counts: L[True] = ...,
+    axis: None | SupportsIndex = ...,
+    *,
+    equal_nan: bool = ...,
+) -> tuple[NDArray[_SCT], NDArray[intp], NDArray[intp]]: ...
+@overload
+def unique(
+    ar: ArrayLike,
+    return_index: L[False] = ...,
+    return_inverse: L[True] = ...,
+    return_counts: L[True] = ...,
+    axis: None | SupportsIndex = ...,
+    *,
+    equal_nan: bool = ...,
+) -> tuple[NDArray[Any], NDArray[intp], NDArray[intp]]: ...
+@overload
+def unique(
+    ar: _ArrayLike[_SCT],
+    return_index: L[True] = ...,
+    return_inverse: L[True] = ...,
+    return_counts: L[True] = ...,
+    axis: None | SupportsIndex = ...,
+    *,
+    equal_nan: bool = ...,
+) -> tuple[NDArray[_SCT], NDArray[intp], NDArray[intp], NDArray[intp]]: ...
+@overload
+def unique(
+    ar: ArrayLike,
+    return_index: L[True] = ...,
+    return_inverse: L[True] = ...,
+    return_counts: L[True] = ...,
+    axis: None | SupportsIndex = ...,
+    *,
+    equal_nan: bool = ...,
+) -> tuple[NDArray[Any], NDArray[intp], NDArray[intp], NDArray[intp]]: ...
+
+@overload
+def unique_all(
+    x: _ArrayLike[_SCT], /
+) -> UniqueAllResult[_SCT]: ...
+@overload
+def unique_all(
+    x: ArrayLike, /
+) -> UniqueAllResult[Any]: ...
+
+@overload
+def unique_counts(
+    x: _ArrayLike[_SCT], /
+) -> UniqueCountsResult[_SCT]: ...
+@overload
+def unique_counts(
+    x: ArrayLike, /
+) -> UniqueCountsResult[Any]: ...
+
+@overload
+def unique_inverse(x: _ArrayLike[_SCT], /) -> UniqueInverseResult[_SCT]: ...
+@overload
+def unique_inverse(x: ArrayLike, /) -> UniqueInverseResult[Any]: ...
+
+@overload
+def unique_values(x: _ArrayLike[_SCT], /) -> NDArray[_SCT]: ...
+@overload
+def unique_values(x: ArrayLike, /) -> NDArray[Any]: ...
+
+@overload
+def intersect1d(
+    ar1: _ArrayLike[_SCTNoCast],
+    ar2: _ArrayLike[_SCTNoCast],
+    assume_unique: bool = ...,
+    return_indices: L[False] = ...,
+) -> NDArray[_SCTNoCast]: ...
+@overload
+def intersect1d(
+    ar1: ArrayLike,
+    ar2: ArrayLike,
+    assume_unique: bool = ...,
+    return_indices: L[False] = ...,
+) -> NDArray[Any]: ...
+@overload
+def intersect1d(
+    ar1: _ArrayLike[_SCTNoCast],
+    ar2: _ArrayLike[_SCTNoCast],
+    assume_unique: bool = ...,
+    return_indices: L[True] = ...,
+) -> tuple[NDArray[_SCTNoCast], NDArray[intp], NDArray[intp]]: ...
+@overload
+def intersect1d(
+    ar1: ArrayLike,
+    ar2: ArrayLike,
+    assume_unique: bool = ...,
+    return_indices: L[True] = ...,
+) -> tuple[NDArray[Any], NDArray[intp], NDArray[intp]]: ...
+
+@overload
+def setxor1d(
+    ar1: _ArrayLike[_SCTNoCast],
+    ar2: _ArrayLike[_SCTNoCast],
+    assume_unique: bool = ...,
+) -> NDArray[_SCTNoCast]: ...
+@overload
+def setxor1d(
+    ar1: ArrayLike,
+    ar2: ArrayLike,
+    assume_unique: bool = ...,
+) -> NDArray[Any]: ...
+
+def isin(
+    element: ArrayLike,
+    test_elements: ArrayLike,
+    assume_unique: bool = ...,
+    invert: bool = ...,
+    *,
+    kind: None | str = ...,
+) -> NDArray[np.bool]: ...
+
+@overload
+def union1d(
+    ar1: _ArrayLike[_SCTNoCast],
+    ar2: _ArrayLike[_SCTNoCast],
+) -> NDArray[_SCTNoCast]: ...
+@overload
+def union1d(
+    ar1: ArrayLike,
+    ar2: ArrayLike,
+) -> NDArray[Any]: ...
+
+@overload
+def setdiff1d(
+    ar1: _ArrayLike[_SCTNoCast],
+    ar2: _ArrayLike[_SCTNoCast],
+    assume_unique: bool = ...,
+) -> NDArray[_SCTNoCast]: ...
+@overload
+def setdiff1d(
+    ar1: ArrayLike,
+    ar2: ArrayLike,
+    assume_unique: bool = ...,
+) -> NDArray[Any]: ...
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/_arrayterator_impl.py b/venv/lib/python3.12/site-packages/numpy/lib/_arrayterator_impl.py
new file mode 100644
index 00000000..146161d0
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/lib/_arrayterator_impl.py
@@ -0,0 +1,222 @@
+"""
+A buffered iterator for big arrays.
+
+This module solves the problem of iterating over a big file-based array
+without having to read it into memory. The `Arrayterator` class wraps
+an array object, and when iterated it will return sub-arrays with at most
+a user-specified number of elements.
+
+"""
+from operator import mul
+from functools import reduce
+
+__all__ = ['Arrayterator']
+
+
+class Arrayterator:
+    """
+    Buffered iterator for big arrays.
+
+    `Arrayterator` creates a buffered iterator for reading big arrays in small
+    contiguous blocks. The class is useful for objects stored in the
+    file system. It allows iteration over the object *without* reading
+    everything in memory; instead, small blocks are read and iterated over.
+
+    `Arrayterator` can be used with any object that supports multidimensional
+    slices. This includes NumPy arrays, but also variables from
+    Scientific.IO.NetCDF or pynetcdf for example.
+
+    Parameters
+    ----------
+    var : array_like
+        The object to iterate over.
+    buf_size : int, optional
+        The buffer size. If `buf_size` is supplied, the maximum amount of
+        data that will be read into memory is `buf_size` elements.
+        Default is None, which will read as many element as possible
+        into memory.
+
+    Attributes
+    ----------
+    var
+    buf_size
+    start
+    stop
+    step
+    shape
+    flat
+
+    See Also
+    --------
+    numpy.ndenumerate : Multidimensional array iterator.
+    numpy.flatiter : Flat array iterator.
+    numpy.memmap : Create a memory-map to an array stored
+                   in a binary file on disk.
+
+    Notes
+    -----
+    The algorithm works by first finding a "running dimension", along which
+    the blocks will be extracted. Given an array of dimensions
+    ``(d1, d2, ..., dn)``, e.g. if `buf_size` is smaller than ``d1``, the
+    first dimension will be used. If, on the other hand,
+    ``d1 < buf_size < d1*d2`` the second dimension will be used, and so on.
+    Blocks are extracted along this dimension, and when the last block is
+    returned the process continues from the next dimension, until all
+    elements have been read.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> a = np.arange(3 * 4 * 5 * 6).reshape(3, 4, 5, 6)
+    >>> a_itor = np.lib.Arrayterator(a, 2)
+    >>> a_itor.shape
+    (3, 4, 5, 6)
+
+    Now we can iterate over ``a_itor``, and it will return arrays of size
+    two. Since `buf_size` was smaller than any dimension, the first
+    dimension will be iterated over first:
+
+    >>> for subarr in a_itor:
+    ...     if not subarr.all():
+    ...         print(subarr, subarr.shape) # doctest: +SKIP
+    >>> # [[[[0 1]]]] (1, 1, 1, 2)
+
+    """
+
+    def __init__(self, var, buf_size=None):
+        self.var = var
+        self.buf_size = buf_size
+
+        self.start = [0 for dim in var.shape]
+        self.stop = [dim for dim in var.shape]
+        self.step = [1 for dim in var.shape]
+
+    def __getattr__(self, attr):
+        return getattr(self.var, attr)
+
+    def __getitem__(self, index):
+        """
+        Return a new arrayterator.
+
+        """
+        # Fix index, handling ellipsis and incomplete slices.
+        if not isinstance(index, tuple):
+            index = (index,)
+        fixed = []
+        length, dims = len(index), self.ndim
+        for slice_ in index:
+            if slice_ is Ellipsis:
+                fixed.extend([slice(None)] * (dims-length+1))
+                length = len(fixed)
+            elif isinstance(slice_, int):
+                fixed.append(slice(slice_, slice_+1, 1))
+            else:
+                fixed.append(slice_)
+        index = tuple(fixed)
+        if len(index) < dims:
+            index += (slice(None),) * (dims-len(index))
+
+        # Return a new arrayterator object.
+        out = self.__class__(self.var, self.buf_size)
+        for i, (start, stop, step, slice_) in enumerate(
+                zip(self.start, self.stop, self.step, index)):
+            out.start[i] = start + (slice_.start or 0)
+            out.step[i] = step * (slice_.step or 1)
+            out.stop[i] = start + (slice_.stop or stop-start)
+            out.stop[i] = min(stop, out.stop[i])
+        return out
+
+    def __array__(self, dtype=None, copy=None):
+        """
+        Return corresponding data.
+
+        """
+        slice_ = tuple(slice(*t) for t in zip(
+                self.start, self.stop, self.step))
+        return self.var[slice_]
+
+    @property
+    def flat(self):
+        """
+        A 1-D flat iterator for Arrayterator objects.
+
+        This iterator returns elements of the array to be iterated over in
+        `~lib.Arrayterator` one by one. 
+        It is similar to `flatiter`.
+
+        See Also
+        --------
+        lib.Arrayterator
+        flatiter
+
+        Examples
+        --------
+        >>> a = np.arange(3 * 4 * 5 * 6).reshape(3, 4, 5, 6)
+        >>> a_itor = np.lib.Arrayterator(a, 2)
+
+        >>> for subarr in a_itor.flat:
+        ...     if not subarr:
+        ...         print(subarr, type(subarr))
+        ...
+        0 
+
+        """
+        for block in self:
+            yield from block.flat
+
+    @property
+    def shape(self):
+        """
+        The shape of the array to be iterated over.
+
+        For an example, see `Arrayterator`.
+
+        """
+        return tuple(((stop-start-1)//step+1) for start, stop, step in
+                zip(self.start, self.stop, self.step))
+
+    def __iter__(self):
+        # Skip arrays with degenerate dimensions
+        if [dim for dim in self.shape if dim <= 0]:
+            return
+
+        start = self.start[:]
+        stop = self.stop[:]
+        step = self.step[:]
+        ndims = self.var.ndim
+
+        while True:
+            count = self.buf_size or reduce(mul, self.shape)
+
+            # iterate over each dimension, looking for the
+            # running dimension (ie, the dimension along which
+            # the blocks will be built from)
+            rundim = 0
+            for i in range(ndims-1, -1, -1):
+                # if count is zero we ran out of elements to read
+                # along higher dimensions, so we read only a single position
+                if count == 0:
+                    stop[i] = start[i]+1
+                elif count <= self.shape[i]:
+                    # limit along this dimension
+                    stop[i] = start[i] + count*step[i]
+                    rundim = i
+                else:
+                    # read everything along this dimension
+                    stop[i] = self.stop[i]
+                stop[i] = min(self.stop[i], stop[i])
+                count = count//self.shape[i]
+
+            # yield a block
+            slice_ = tuple(slice(*t) for t in zip(start, stop, step))
+            yield self.var[slice_]
+
+            # Update start position, taking care of overflow to
+            # other dimensions
+            start[rundim] = stop[rundim]  # start where we stopped
+            for i in range(ndims-1, 0, -1):
+                if start[i] >= self.stop[i]:
+                    start[i] = self.start[i]
+                    start[i-1] += self.step[i-1]
+            if start[0] >= self.stop[0]:
+                return
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/_arrayterator_impl.pyi b/venv/lib/python3.12/site-packages/numpy/lib/_arrayterator_impl.pyi
new file mode 100644
index 00000000..fb9c42dd
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/lib/_arrayterator_impl.pyi
@@ -0,0 +1,48 @@
+from collections.abc import Generator
+from typing import (
+    Any,
+    TypeVar,
+    overload,
+)
+
+from numpy import ndarray, dtype, generic
+from numpy._typing import DTypeLike, NDArray
+
+# TODO: Set a shape bound once we've got proper shape support
+_Shape = TypeVar("_Shape", bound=Any)
+_DType = TypeVar("_DType", bound=dtype[Any])
+_ScalarType = TypeVar("_ScalarType", bound=generic)
+
+_Index = (
+    ellipsis
+    | int
+    | slice
+    | tuple[ellipsis | int | slice, ...]
+)
+
+__all__: list[str]
+
+# NOTE: In reality `Arrayterator` does not actually inherit from `ndarray`,
+# but its ``__getattr__` method does wrap around the former and thus has
+# access to all its methods
+
+class Arrayterator(ndarray[_Shape, _DType]):
+    var: ndarray[_Shape, _DType]  # type: ignore[assignment]
+    buf_size: None | int
+    start: list[int]
+    stop: list[int]
+    step: list[int]
+
+    @property  # type: ignore[misc]
+    def shape(self) -> tuple[int, ...]: ...
+    @property
+    def flat(self: NDArray[_ScalarType]) -> Generator[_ScalarType, None, None]: ...
+    def __init__(
+        self, var: ndarray[_Shape, _DType], buf_size: None | int = ...
+    ) -> None: ...
+    @overload
+    def __array__(self, dtype: None = ..., copy: None | bool = ...) -> ndarray[Any, _DType]: ...
+    @overload
+    def __array__(self, dtype: DTypeLike, copy: None | bool = ...) -> NDArray[Any]: ...
+    def __getitem__(self, index: _Index) -> Arrayterator[Any, _DType]: ...
+    def __iter__(self) -> Generator[ndarray[Any, _DType], None, None]: ...
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/_datasource.py b/venv/lib/python3.12/site-packages/numpy/lib/_datasource.py
new file mode 100644
index 00000000..e3d85b85
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/lib/_datasource.py
@@ -0,0 +1,700 @@
+"""A file interface for handling local and remote data files.
+
+The goal of datasource is to abstract some of the file system operations
+when dealing with data files so the researcher doesn't have to know all the
+low-level details.  Through datasource, a researcher can obtain and use a
+file with one function call, regardless of location of the file.
+
+DataSource is meant to augment standard python libraries, not replace them.
+It should work seamlessly with standard file IO operations and the os
+module.
+
+DataSource files can originate locally or remotely:
+
+- local files : '/home/guido/src/local/data.txt'
+- URLs (http, ftp, ...) : 'http://www.scipy.org/not/real/data.txt'
+
+DataSource files can also be compressed or uncompressed.  Currently only
+gzip, bz2 and xz are supported.
+
+Example::
+
+    >>> # Create a DataSource, use os.curdir (default) for local storage.
+    >>> from numpy import DataSource
+    >>> ds = DataSource()
+    >>>
+    >>> # Open a remote file.
+    >>> # DataSource downloads the file, stores it locally in:
+    >>> #     './www.google.com/index.html'
+    >>> # opens the file and returns a file object.
+    >>> fp = ds.open('http://www.google.com/') # doctest: +SKIP
+    >>>
+    >>> # Use the file as you normally would
+    >>> fp.read() # doctest: +SKIP
+    >>> fp.close() # doctest: +SKIP
+
+"""
+import os
+
+from .._utils import set_module
+
+
+_open = open
+
+
+def _check_mode(mode, encoding, newline):
+    """Check mode and that encoding and newline are compatible.
+
+    Parameters
+    ----------
+    mode : str
+        File open mode.
+    encoding : str
+        File encoding.
+    newline : str
+        Newline for text files.
+
+    """
+    if "t" in mode:
+        if "b" in mode:
+            raise ValueError("Invalid mode: %r" % (mode,))
+    else:
+        if encoding is not None:
+            raise ValueError("Argument 'encoding' not supported in binary mode")
+        if newline is not None:
+            raise ValueError("Argument 'newline' not supported in binary mode")
+
+
+# Using a class instead of a module-level dictionary
+# to reduce the initial 'import numpy' overhead by
+# deferring the import of lzma, bz2 and gzip until needed
+
+# TODO: .zip support, .tar support?
+class _FileOpeners:
+    """
+    Container for different methods to open (un-)compressed files.
+
+    `_FileOpeners` contains a dictionary that holds one method for each
+    supported file format. Attribute lookup is implemented in such a way
+    that an instance of `_FileOpeners` itself can be indexed with the keys
+    of that dictionary. Currently uncompressed files as well as files
+    compressed with ``gzip``, ``bz2`` or ``xz`` compression are supported.
+
+    Notes
+    -----
+    `_file_openers`, an instance of `_FileOpeners`, is made available for
+    use in the `_datasource` module.
+
+    Examples
+    --------
+    >>> import gzip
+    >>> np.lib._datasource._file_openers.keys()
+    [None, '.bz2', '.gz', '.xz', '.lzma']
+    >>> np.lib._datasource._file_openers['.gz'] is gzip.open
+    True
+
+    """
+
+    def __init__(self):
+        self._loaded = False
+        self._file_openers = {None: open}
+
+    def _load(self):
+        if self._loaded:
+            return
+
+        try:
+            import bz2
+            self._file_openers[".bz2"] = bz2.open
+        except ImportError:
+            pass
+
+        try:
+            import gzip
+            self._file_openers[".gz"] = gzip.open
+        except ImportError:
+            pass
+
+        try:
+            import lzma
+            self._file_openers[".xz"] = lzma.open
+            self._file_openers[".lzma"] = lzma.open
+        except (ImportError, AttributeError):
+            # There are incompatible backports of lzma that do not have the
+            # lzma.open attribute, so catch that as well as ImportError.
+            pass
+
+        self._loaded = True
+
+    def keys(self):
+        """
+        Return the keys of currently supported file openers.
+
+        Parameters
+        ----------
+        None
+
+        Returns
+        -------
+        keys : list
+            The keys are None for uncompressed files and the file extension
+            strings (i.e. ``'.gz'``, ``'.xz'``) for supported compression
+            methods.
+
+        """
+        self._load()
+        return list(self._file_openers.keys())
+
+    def __getitem__(self, key):
+        self._load()
+        return self._file_openers[key]
+
+_file_openers = _FileOpeners()
+
+def open(path, mode='r', destpath=os.curdir, encoding=None, newline=None):
+    """
+    Open `path` with `mode` and return the file object.
+
+    If ``path`` is an URL, it will be downloaded, stored in the
+    `DataSource` `destpath` directory and opened from there.
+
+    Parameters
+    ----------
+    path : str or pathlib.Path
+        Local file path or URL to open.
+    mode : str, optional
+        Mode to open `path`. Mode 'r' for reading, 'w' for writing, 'a' to
+        append. Available modes depend on the type of object specified by
+        path.  Default is 'r'.
+    destpath : str, optional
+        Path to the directory where the source file gets downloaded to for
+        use.  If `destpath` is None, a temporary directory will be created.
+        The default path is the current directory.
+    encoding : {None, str}, optional
+        Open text file with given encoding. The default encoding will be
+        what `open` uses.
+    newline : {None, str}, optional
+        Newline to use when reading text file.
+
+    Returns
+    -------
+    out : file object
+        The opened file.
+
+    Notes
+    -----
+    This is a convenience function that instantiates a `DataSource` and
+    returns the file object from ``DataSource.open(path)``.
+
+    """
+
+    ds = DataSource(destpath)
+    return ds.open(path, mode, encoding=encoding, newline=newline)
+
+
+@set_module('numpy.lib.npyio')
+class DataSource:
+    """
+    DataSource(destpath='.')
+
+    A generic data source file (file, http, ftp, ...).
+
+    DataSources can be local files or remote files/URLs.  The files may
+    also be compressed or uncompressed. DataSource hides some of the
+    low-level details of downloading the file, allowing you to simply pass
+    in a valid file path (or URL) and obtain a file object.
+
+    Parameters
+    ----------
+    destpath : str or None, optional
+        Path to the directory where the source file gets downloaded to for
+        use.  If `destpath` is None, a temporary directory will be created.
+        The default path is the current directory.
+
+    Notes
+    -----
+    URLs require a scheme string (``http://``) to be used, without it they
+    will fail::
+
+        >>> repos = np.lib.npyio.DataSource()
+        >>> repos.exists('www.google.com/index.html')
+        False
+        >>> repos.exists('http://www.google.com/index.html')
+        True
+
+    Temporary directories are deleted when the DataSource is deleted.
+
+    Examples
+    --------
+    ::
+
+        >>> ds = np.lib.npyio.DataSource('/home/guido')
+        >>> urlname = 'http://www.google.com/'
+        >>> gfile = ds.open('http://www.google.com/')
+        >>> ds.abspath(urlname)
+        '/home/guido/www.google.com/index.html'
+
+        >>> ds = np.lib.npyio.DataSource(None)  # use with temporary file
+        >>> ds.open('/home/guido/foobar.txt')
+        
+        >>> ds.abspath('/home/guido/foobar.txt')
+        '/tmp/.../home/guido/foobar.txt'
+
+    """
+
+    def __init__(self, destpath=os.curdir):
+        """Create a DataSource with a local path at destpath."""
+        if destpath:
+            self._destpath = os.path.abspath(destpath)
+            self._istmpdest = False
+        else:
+            import tempfile  # deferring import to improve startup time
+            self._destpath = tempfile.mkdtemp()
+            self._istmpdest = True
+
+    def __del__(self):
+        # Remove temp directories
+        if hasattr(self, '_istmpdest') and self._istmpdest:
+            import shutil
+
+            shutil.rmtree(self._destpath)
+
+    def _iszip(self, filename):
+        """Test if the filename is a zip file by looking at the file extension.
+
+        """
+        fname, ext = os.path.splitext(filename)
+        return ext in _file_openers.keys()
+
+    def _iswritemode(self, mode):
+        """Test if the given mode will open a file for writing."""
+
+        # Currently only used to test the bz2 files.
+        _writemodes = ("w", "+")
+        return any(c in _writemodes for c in mode)
+
+    def _splitzipext(self, filename):
+        """Split zip extension from filename and return filename.
+
+        Returns
+        -------
+        base, zip_ext : {tuple}
+
+        """
+
+        if self._iszip(filename):
+            return os.path.splitext(filename)
+        else:
+            return filename, None
+
+    def _possible_names(self, filename):
+        """Return a tuple containing compressed filename variations."""
+        names = [filename]
+        if not self._iszip(filename):
+            for zipext in _file_openers.keys():
+                if zipext:
+                    names.append(filename+zipext)
+        return names
+
+    def _isurl(self, path):
+        """Test if path is a net location.  Tests the scheme and netloc."""
+
+        # We do this here to reduce the 'import numpy' initial import time.
+        from urllib.parse import urlparse
+
+        # BUG : URLs require a scheme string ('http://') to be used.
+        #       www.google.com will fail.
+        #       Should we prepend the scheme for those that don't have it and
+        #       test that also?  Similar to the way we append .gz and test for
+        #       for compressed versions of files.
+
+        scheme, netloc, upath, uparams, uquery, ufrag = urlparse(path)
+        return bool(scheme and netloc)
+
+    def _cache(self, path):
+        """Cache the file specified by path.
+
+        Creates a copy of the file in the datasource cache.
+
+        """
+        # We import these here because importing them is slow and
+        # a significant fraction of numpy's total import time.
+        import shutil
+        from urllib.request import urlopen
+
+        upath = self.abspath(path)
+
+        # ensure directory exists
+        if not os.path.exists(os.path.dirname(upath)):
+            os.makedirs(os.path.dirname(upath))
+
+        # TODO: Doesn't handle compressed files!
+        if self._isurl(path):
+            with urlopen(path) as openedurl:
+                with _open(upath, 'wb') as f:
+                    shutil.copyfileobj(openedurl, f)
+        else:
+            shutil.copyfile(path, upath)
+        return upath
+
+    def _findfile(self, path):
+        """Searches for ``path`` and returns full path if found.
+
+        If path is an URL, _findfile will cache a local copy and return the
+        path to the cached file.  If path is a local file, _findfile will
+        return a path to that local file.
+
+        The search will include possible compressed versions of the file
+        and return the first occurrence found.
+
+        """
+
+        # Build list of possible local file paths
+        if not self._isurl(path):
+            # Valid local paths
+            filelist = self._possible_names(path)
+            # Paths in self._destpath
+            filelist += self._possible_names(self.abspath(path))
+        else:
+            # Cached URLs in self._destpath
+            filelist = self._possible_names(self.abspath(path))
+            # Remote URLs
+            filelist = filelist + self._possible_names(path)
+
+        for name in filelist:
+            if self.exists(name):
+                if self._isurl(name):
+                    name = self._cache(name)
+                return name
+        return None
+
+    def abspath(self, path):
+        """
+        Return absolute path of file in the DataSource directory.
+
+        If `path` is an URL, then `abspath` will return either the location
+        the file exists locally or the location it would exist when opened
+        using the `open` method.
+
+        Parameters
+        ----------
+        path : str or pathlib.Path
+            Can be a local file or a remote URL.
+
+        Returns
+        -------
+        out : str
+            Complete path, including the `DataSource` destination directory.
+
+        Notes
+        -----
+        The functionality is based on `os.path.abspath`.
+
+        """
+        # We do this here to reduce the 'import numpy' initial import time.
+        from urllib.parse import urlparse
+
+        # TODO:  This should be more robust.  Handles case where path includes
+        #        the destpath, but not other sub-paths. Failing case:
+        #        path = /home/guido/datafile.txt
+        #        destpath = /home/alex/
+        #        upath = self.abspath(path)
+        #        upath == '/home/alex/home/guido/datafile.txt'
+
+        # handle case where path includes self._destpath
+        splitpath = path.split(self._destpath, 2)
+        if len(splitpath) > 1:
+            path = splitpath[1]
+        scheme, netloc, upath, uparams, uquery, ufrag = urlparse(path)
+        netloc = self._sanitize_relative_path(netloc)
+        upath = self._sanitize_relative_path(upath)
+        return os.path.join(self._destpath, netloc, upath)
+
+    def _sanitize_relative_path(self, path):
+        """Return a sanitised relative path for which
+        os.path.abspath(os.path.join(base, path)).startswith(base)
+        """
+        last = None
+        path = os.path.normpath(path)
+        while path != last:
+            last = path
+            # Note: os.path.join treats '/' as os.sep on Windows
+            path = path.lstrip(os.sep).lstrip('/')
+            path = path.lstrip(os.pardir).removeprefix('..')
+            drive, path = os.path.splitdrive(path)  # for Windows
+        return path
+
+    def exists(self, path):
+        """
+        Test if path exists.
+
+        Test if `path` exists as (and in this order):
+
+        - a local file.
+        - a remote URL that has been downloaded and stored locally in the
+          `DataSource` directory.
+        - a remote URL that has not been downloaded, but is valid and
+          accessible.
+
+        Parameters
+        ----------
+        path : str or pathlib.Path
+            Can be a local file or a remote URL.
+
+        Returns
+        -------
+        out : bool
+            True if `path` exists.
+
+        Notes
+        -----
+        When `path` is an URL, `exists` will return True if it's either
+        stored locally in the `DataSource` directory, or is a valid remote
+        URL.  `DataSource` does not discriminate between the two, the file
+        is accessible if it exists in either location.
+
+        """
+
+        # First test for local path
+        if os.path.exists(path):
+            return True
+
+        # We import this here because importing urllib is slow and
+        # a significant fraction of numpy's total import time.
+        from urllib.request import urlopen
+        from urllib.error import URLError
+
+        # Test cached url
+        upath = self.abspath(path)
+        if os.path.exists(upath):
+            return True
+
+        # Test remote url
+        if self._isurl(path):
+            try:
+                netfile = urlopen(path)
+                netfile.close()
+                del(netfile)
+                return True
+            except URLError:
+                return False
+        return False
+
+    def open(self, path, mode='r', encoding=None, newline=None):
+        """
+        Open and return file-like object.
+
+        If `path` is an URL, it will be downloaded, stored in the
+        `DataSource` directory and opened from there.
+
+        Parameters
+        ----------
+        path : str or pathlib.Path
+            Local file path or URL to open.
+        mode : {'r', 'w', 'a'}, optional
+            Mode to open `path`.  Mode 'r' for reading, 'w' for writing,
+            'a' to append. Available modes depend on the type of object
+            specified by `path`. Default is 'r'.
+        encoding : {None, str}, optional
+            Open text file with given encoding. The default encoding will be
+            what `open` uses.
+        newline : {None, str}, optional
+            Newline to use when reading text file.
+
+        Returns
+        -------
+        out : file object
+            File object.
+
+        """
+
+        # TODO: There is no support for opening a file for writing which
+        #       doesn't exist yet (creating a file).  Should there be?
+
+        # TODO: Add a ``subdir`` parameter for specifying the subdirectory
+        #       used to store URLs in self._destpath.
+
+        if self._isurl(path) and self._iswritemode(mode):
+            raise ValueError("URLs are not writeable")
+
+        # NOTE: _findfile will fail on a new file opened for writing.
+        found = self._findfile(path)
+        if found:
+            _fname, ext = self._splitzipext(found)
+            if ext == 'bz2':
+                mode.replace("+", "")
+            return _file_openers[ext](found, mode=mode,
+                                      encoding=encoding, newline=newline)
+        else:
+            raise FileNotFoundError(f"{path} not found.")
+
+
+class Repository (DataSource):
+    """
+    Repository(baseurl, destpath='.')
+
+    A data repository where multiple DataSource's share a base
+    URL/directory.
+
+    `Repository` extends `DataSource` by prepending a base URL (or
+    directory) to all the files it handles. Use `Repository` when you will
+    be working with multiple files from one base URL.  Initialize
+    `Repository` with the base URL, then refer to each file by its filename
+    only.
+
+    Parameters
+    ----------
+    baseurl : str
+        Path to the local directory or remote location that contains the
+        data files.
+    destpath : str or None, optional
+        Path to the directory where the source file gets downloaded to for
+        use.  If `destpath` is None, a temporary directory will be created.
+        The default path is the current directory.
+
+    Examples
+    --------
+    To analyze all files in the repository, do something like this
+    (note: this is not self-contained code)::
+
+        >>> repos = np.lib._datasource.Repository('/home/user/data/dir/')
+        >>> for filename in filelist:
+        ...     fp = repos.open(filename)
+        ...     fp.analyze()
+        ...     fp.close()
+
+    Similarly you could use a URL for a repository::
+
+        >>> repos = np.lib._datasource.Repository('http://www.xyz.edu/data')
+
+    """
+
+    def __init__(self, baseurl, destpath=os.curdir):
+        """Create a Repository with a shared url or directory of baseurl."""
+        DataSource.__init__(self, destpath=destpath)
+        self._baseurl = baseurl
+
+    def __del__(self):
+        DataSource.__del__(self)
+
+    def _fullpath(self, path):
+        """Return complete path for path.  Prepends baseurl if necessary."""
+        splitpath = path.split(self._baseurl, 2)
+        if len(splitpath) == 1:
+            result = os.path.join(self._baseurl, path)
+        else:
+            result = path    # path contains baseurl already
+        return result
+
+    def _findfile(self, path):
+        """Extend DataSource method to prepend baseurl to ``path``."""
+        return DataSource._findfile(self, self._fullpath(path))
+
+    def abspath(self, path):
+        """
+        Return absolute path of file in the Repository directory.
+
+        If `path` is an URL, then `abspath` will return either the location
+        the file exists locally or the location it would exist when opened
+        using the `open` method.
+
+        Parameters
+        ----------
+        path : str or pathlib.Path
+            Can be a local file or a remote URL. This may, but does not
+            have to, include the `baseurl` with which the `Repository` was
+            initialized.
+
+        Returns
+        -------
+        out : str
+            Complete path, including the `DataSource` destination directory.
+
+        """
+        return DataSource.abspath(self, self._fullpath(path))
+
+    def exists(self, path):
+        """
+        Test if path exists prepending Repository base URL to path.
+
+        Test if `path` exists as (and in this order):
+
+        - a local file.
+        - a remote URL that has been downloaded and stored locally in the
+          `DataSource` directory.
+        - a remote URL that has not been downloaded, but is valid and
+          accessible.
+
+        Parameters
+        ----------
+        path : str or pathlib.Path
+            Can be a local file or a remote URL. This may, but does not
+            have to, include the `baseurl` with which the `Repository` was
+            initialized.
+
+        Returns
+        -------
+        out : bool
+            True if `path` exists.
+
+        Notes
+        -----
+        When `path` is an URL, `exists` will return True if it's either
+        stored locally in the `DataSource` directory, or is a valid remote
+        URL.  `DataSource` does not discriminate between the two, the file
+        is accessible if it exists in either location.
+
+        """
+        return DataSource.exists(self, self._fullpath(path))
+
+    def open(self, path, mode='r', encoding=None, newline=None):
+        """
+        Open and return file-like object prepending Repository base URL.
+
+        If `path` is an URL, it will be downloaded, stored in the
+        DataSource directory and opened from there.
+
+        Parameters
+        ----------
+        path : str or pathlib.Path
+            Local file path or URL to open. This may, but does not have to,
+            include the `baseurl` with which the `Repository` was
+            initialized.
+        mode : {'r', 'w', 'a'}, optional
+            Mode to open `path`.  Mode 'r' for reading, 'w' for writing,
+            'a' to append. Available modes depend on the type of object
+            specified by `path`. Default is 'r'.
+        encoding : {None, str}, optional
+            Open text file with given encoding. The default encoding will be
+            what `open` uses.
+        newline : {None, str}, optional
+            Newline to use when reading text file.
+
+        Returns
+        -------
+        out : file object
+            File object.
+
+        """
+        return DataSource.open(self, self._fullpath(path), mode,
+                               encoding=encoding, newline=newline)
+
+    def listdir(self):
+        """
+        List files in the source Repository.
+
+        Returns
+        -------
+        files : list of str or pathlib.Path
+            List of file names (not containing a directory part).
+
+        Notes
+        -----
+        Does not currently work for remote repositories.
+
+        """
+        if self._isurl(self._baseurl):
+            raise NotImplementedError(
+                  "Directory listing of URLs, not supported yet.")
+        else:
+            return os.listdir(self._baseurl)
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/_function_base_impl.py b/venv/lib/python3.12/site-packages/numpy/lib/_function_base_impl.py
new file mode 100644
index 00000000..840b501b
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/lib/_function_base_impl.py
@@ -0,0 +1,5808 @@
+import builtins
+import collections.abc
+import functools
+import re
+import sys
+import warnings
+
+import numpy as np
+import numpy._core.numeric as _nx
+from numpy._core import transpose, overrides
+from numpy._core.numeric import (
+    ones, zeros_like, arange, concatenate, array, asarray, asanyarray, empty,
+    ndarray, take, dot, where, intp, integer, isscalar, absolute
+    )
+from numpy._core.umath import (
+    pi, add, arctan2, frompyfunc, cos, less_equal, sqrt, sin,
+    mod, exp, not_equal, subtract, minimum
+    )
+from numpy._core.fromnumeric import (
+    ravel, nonzero, partition, mean, any, sum
+    )
+from numpy._core.numerictypes import typecodes
+from numpy.lib._twodim_base_impl import diag
+from numpy._core.multiarray import (
+    _place, bincount, normalize_axis_index, _monotonicity,
+    interp as compiled_interp, interp_complex as compiled_interp_complex
+    )
+from numpy._core._multiarray_umath import _array_converter
+from numpy._utils import set_module
+
+# needed in this module for compatibility
+from numpy.lib._histograms_impl import histogram, histogramdd  # noqa: F401
+
+
+array_function_dispatch = functools.partial(
+    overrides.array_function_dispatch, module='numpy')
+
+
+__all__ = [
+    'select', 'piecewise', 'trim_zeros', 'copy', 'iterable', 'percentile',
+    'diff', 'gradient', 'angle', 'unwrap', 'sort_complex', 'flip',
+    'rot90', 'extract', 'place', 'vectorize', 'asarray_chkfinite', 'average',
+    'bincount', 'digitize', 'cov', 'corrcoef',
+    'median', 'sinc', 'hamming', 'hanning', 'bartlett',
+    'blackman', 'kaiser', 'trapezoid', 'trapz', 'i0',
+    'meshgrid', 'delete', 'insert', 'append', 'interp',
+    'quantile'
+    ]
+
+# _QuantileMethods is a dictionary listing all the supported methods to
+# compute quantile/percentile.
+#
+# Below virtual_index refers to the index of the element where the percentile
+# would be found in the sorted sample.
+# When the sample contains exactly the percentile wanted, the virtual_index is
+# an integer to the index of this element.
+# When the percentile wanted is in between two elements, the virtual_index
+# is made of a integer part (a.k.a 'i' or 'left') and a fractional part
+# (a.k.a 'g' or 'gamma')
+#
+# Each method in _QuantileMethods has two properties
+# get_virtual_index : Callable
+#   The function used to compute the virtual_index.
+# fix_gamma : Callable
+#   A function used for discret methods to force the index to a specific value.
+_QuantileMethods = dict(
+    # --- HYNDMAN and FAN METHODS
+    # Discrete methods
+    inverted_cdf=dict(
+        get_virtual_index=lambda n, quantiles: _inverted_cdf(n, quantiles),
+        fix_gamma=None,  # should never be called
+    ),
+    averaged_inverted_cdf=dict(
+        get_virtual_index=lambda n, quantiles: (n * quantiles) - 1,
+        fix_gamma=lambda gamma, _: _get_gamma_mask(
+            shape=gamma.shape,
+            default_value=1.,
+            conditioned_value=0.5,
+            where=gamma == 0),
+    ),
+    closest_observation=dict(
+        get_virtual_index=lambda n, quantiles: _closest_observation(n,
+                                                                    quantiles),
+        fix_gamma=None,  # should never be called
+    ),
+    # Continuous methods
+    interpolated_inverted_cdf=dict(
+        get_virtual_index=lambda n, quantiles:
+        _compute_virtual_index(n, quantiles, 0, 1),
+        fix_gamma=lambda gamma, _: gamma,
+    ),
+    hazen=dict(
+        get_virtual_index=lambda n, quantiles:
+        _compute_virtual_index(n, quantiles, 0.5, 0.5),
+        fix_gamma=lambda gamma, _: gamma,
+    ),
+    weibull=dict(
+        get_virtual_index=lambda n, quantiles:
+        _compute_virtual_index(n, quantiles, 0, 0),
+        fix_gamma=lambda gamma, _: gamma,
+    ),
+    # Default method.
+    # To avoid some rounding issues, `(n-1) * quantiles` is preferred to
+    # `_compute_virtual_index(n, quantiles, 1, 1)`.
+    # They are mathematically equivalent.
+    linear=dict(
+        get_virtual_index=lambda n, quantiles: (n - 1) * quantiles,
+        fix_gamma=lambda gamma, _: gamma,
+    ),
+    median_unbiased=dict(
+        get_virtual_index=lambda n, quantiles:
+        _compute_virtual_index(n, quantiles, 1 / 3.0, 1 / 3.0),
+        fix_gamma=lambda gamma, _: gamma,
+    ),
+    normal_unbiased=dict(
+        get_virtual_index=lambda n, quantiles:
+        _compute_virtual_index(n, quantiles, 3 / 8.0, 3 / 8.0),
+        fix_gamma=lambda gamma, _: gamma,
+    ),
+    # --- OTHER METHODS
+    lower=dict(
+        get_virtual_index=lambda n, quantiles: np.floor(
+            (n - 1) * quantiles).astype(np.intp),
+        fix_gamma=None,  # should never be called, index dtype is int
+    ),
+    higher=dict(
+        get_virtual_index=lambda n, quantiles: np.ceil(
+            (n - 1) * quantiles).astype(np.intp),
+        fix_gamma=None,  # should never be called, index dtype is int
+    ),
+    midpoint=dict(
+        get_virtual_index=lambda n, quantiles: 0.5 * (
+                np.floor((n - 1) * quantiles)
+                + np.ceil((n - 1) * quantiles)),
+        fix_gamma=lambda gamma, index: _get_gamma_mask(
+            shape=gamma.shape,
+            default_value=0.5,
+            conditioned_value=0.,
+            where=index % 1 == 0),
+    ),
+    nearest=dict(
+        get_virtual_index=lambda n, quantiles: np.around(
+            (n - 1) * quantiles).astype(np.intp),
+        fix_gamma=None,
+        # should never be called, index dtype is int
+    ))
+
+
+def _rot90_dispatcher(m, k=None, axes=None):
+    return (m,)
+
+
+@array_function_dispatch(_rot90_dispatcher)
+def rot90(m, k=1, axes=(0, 1)):
+    """
+    Rotate an array by 90 degrees in the plane specified by axes.
+
+    Rotation direction is from the first towards the second axis.
+    This means for a 2D array with the default `k` and `axes`, the
+    rotation will be counterclockwise.
+
+    Parameters
+    ----------
+    m : array_like
+        Array of two or more dimensions.
+    k : integer
+        Number of times the array is rotated by 90 degrees.
+    axes : (2,) array_like
+        The array is rotated in the plane defined by the axes.
+        Axes must be different.
+
+        .. versionadded:: 1.12.0
+
+    Returns
+    -------
+    y : ndarray
+        A rotated view of `m`.
+
+    See Also
+    --------
+    flip : Reverse the order of elements in an array along the given axis.
+    fliplr : Flip an array horizontally.
+    flipud : Flip an array vertically.
+
+    Notes
+    -----
+    ``rot90(m, k=1, axes=(1,0))``  is the reverse of
+    ``rot90(m, k=1, axes=(0,1))``
+
+    ``rot90(m, k=1, axes=(1,0))`` is equivalent to
+    ``rot90(m, k=-1, axes=(0,1))``
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> m = np.array([[1,2],[3,4]], int)
+    >>> m
+    array([[1, 2],
+           [3, 4]])
+    >>> np.rot90(m)
+    array([[2, 4],
+           [1, 3]])
+    >>> np.rot90(m, 2)
+    array([[4, 3],
+           [2, 1]])
+    >>> m = np.arange(8).reshape((2,2,2))
+    >>> np.rot90(m, 1, (1,2))
+    array([[[1, 3],
+            [0, 2]],
+           [[5, 7],
+            [4, 6]]])
+
+    """
+    axes = tuple(axes)
+    if len(axes) != 2:
+        raise ValueError("len(axes) must be 2.")
+
+    m = asanyarray(m)
+
+    if axes[0] == axes[1] or absolute(axes[0] - axes[1]) == m.ndim:
+        raise ValueError("Axes must be different.")
+
+    if (axes[0] >= m.ndim or axes[0] < -m.ndim
+        or axes[1] >= m.ndim or axes[1] < -m.ndim):
+        raise ValueError("Axes={} out of range for array of ndim={}."
+            .format(axes, m.ndim))
+
+    k %= 4
+
+    if k == 0:
+        return m[:]
+    if k == 2:
+        return flip(flip(m, axes[0]), axes[1])
+
+    axes_list = arange(0, m.ndim)
+    (axes_list[axes[0]], axes_list[axes[1]]) = (axes_list[axes[1]],
+                                                axes_list[axes[0]])
+
+    if k == 1:
+        return transpose(flip(m, axes[1]), axes_list)
+    else:
+        # k == 3
+        return flip(transpose(m, axes_list), axes[1])
+
+
+def _flip_dispatcher(m, axis=None):
+    return (m,)
+
+
+@array_function_dispatch(_flip_dispatcher)
+def flip(m, axis=None):
+    """
+    Reverse the order of elements in an array along the given axis.
+
+    The shape of the array is preserved, but the elements are reordered.
+
+    .. versionadded:: 1.12.0
+
+    Parameters
+    ----------
+    m : array_like
+        Input array.
+    axis : None or int or tuple of ints, optional
+         Axis or axes along which to flip over. The default,
+         axis=None, will flip over all of the axes of the input array.
+         If axis is negative it counts from the last to the first axis.
+
+         If axis is a tuple of ints, flipping is performed on all of the axes
+         specified in the tuple.
+
+         .. versionchanged:: 1.15.0
+            None and tuples of axes are supported
+
+    Returns
+    -------
+    out : array_like
+        A view of `m` with the entries of axis reversed.  Since a view is
+        returned, this operation is done in constant time.
+
+    See Also
+    --------
+    flipud : Flip an array vertically (axis=0).
+    fliplr : Flip an array horizontally (axis=1).
+
+    Notes
+    -----
+    flip(m, 0) is equivalent to flipud(m).
+
+    flip(m, 1) is equivalent to fliplr(m).
+
+    flip(m, n) corresponds to ``m[...,::-1,...]`` with ``::-1`` at position n.
+
+    flip(m) corresponds to ``m[::-1,::-1,...,::-1]`` with ``::-1`` at all
+    positions.
+
+    flip(m, (0, 1)) corresponds to ``m[::-1,::-1,...]`` with ``::-1`` at
+    position 0 and position 1.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> A = np.arange(8).reshape((2,2,2))
+    >>> A
+    array([[[0, 1],
+            [2, 3]],
+           [[4, 5],
+            [6, 7]]])
+    >>> np.flip(A, 0)
+    array([[[4, 5],
+            [6, 7]],
+           [[0, 1],
+            [2, 3]]])
+    >>> np.flip(A, 1)
+    array([[[2, 3],
+            [0, 1]],
+           [[6, 7],
+            [4, 5]]])
+    >>> np.flip(A)
+    array([[[7, 6],
+            [5, 4]],
+           [[3, 2],
+            [1, 0]]])
+    >>> np.flip(A, (0, 2))
+    array([[[5, 4],
+            [7, 6]],
+           [[1, 0],
+            [3, 2]]])
+    >>> rng = np.random.default_rng()
+    >>> A = rng.normal(size=(3,4,5))
+    >>> np.all(np.flip(A,2) == A[:,:,::-1,...])
+    True
+    """
+    if not hasattr(m, 'ndim'):
+        m = asarray(m)
+    if axis is None:
+        indexer = (np.s_[::-1],) * m.ndim
+    else:
+        axis = _nx.normalize_axis_tuple(axis, m.ndim)
+        indexer = [np.s_[:]] * m.ndim
+        for ax in axis:
+            indexer[ax] = np.s_[::-1]
+        indexer = tuple(indexer)
+    return m[indexer]
+
+
+@set_module('numpy')
+def iterable(y):
+    """
+    Check whether or not an object can be iterated over.
+
+    Parameters
+    ----------
+    y : object
+      Input object.
+
+    Returns
+    -------
+    b : bool
+      Return ``True`` if the object has an iterator method or is a
+      sequence and ``False`` otherwise.
+
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> np.iterable([1, 2, 3])
+    True
+    >>> np.iterable(2)
+    False
+
+    Notes
+    -----
+    In most cases, the results of ``np.iterable(obj)`` are consistent with
+    ``isinstance(obj, collections.abc.Iterable)``. One notable exception is
+    the treatment of 0-dimensional arrays::
+
+        >>> from collections.abc import Iterable
+        >>> a = np.array(1.0)  # 0-dimensional numpy array
+        >>> isinstance(a, Iterable)
+        True
+        >>> np.iterable(a)
+        False
+
+    """
+    try:
+        iter(y)
+    except TypeError:
+        return False
+    return True
+
+
+def _weights_are_valid(weights, a, axis):
+    """Validate weights array.
+    
+    We assume, weights is not None.
+    """
+    wgt = np.asanyarray(weights)
+
+    # Sanity checks
+    if a.shape != wgt.shape:
+        if axis is None:
+            raise TypeError(
+                "Axis must be specified when shapes of a and weights "
+                "differ.")
+        if wgt.shape != tuple(a.shape[ax] for ax in axis):
+            raise ValueError(
+                "Shape of weights must be consistent with "
+                "shape of a along specified axis.")
+
+        # setup wgt to broadcast along axis
+        wgt = wgt.transpose(np.argsort(axis))
+        wgt = wgt.reshape(tuple((s if ax in axis else 1)
+                                for ax, s in enumerate(a.shape)))
+    return wgt
+
+
+def _average_dispatcher(a, axis=None, weights=None, returned=None, *,
+                        keepdims=None):
+    return (a, weights)
+
+
+@array_function_dispatch(_average_dispatcher)
+def average(a, axis=None, weights=None, returned=False, *,
+            keepdims=np._NoValue):
+    """
+    Compute the weighted average along the specified axis.
+
+    Parameters
+    ----------
+    a : array_like
+        Array containing data to be averaged. If `a` is not an array, a
+        conversion is attempted.
+    axis : None or int or tuple of ints, optional
+        Axis or axes along which to average `a`.  The default,
+        `axis=None`, will average over all of the elements of the input array.
+        If axis is negative it counts from the last to the first axis.
+
+        .. versionadded:: 1.7.0
+
+        If axis is a tuple of ints, averaging is performed on all of the axes
+        specified in the tuple instead of a single axis or all the axes as
+        before.
+    weights : array_like, optional
+        An array of weights associated with the values in `a`. Each value in
+        `a` contributes to the average according to its associated weight.
+        The array of weights must be the same shape as `a` if no axis is
+        specified, otherwise the weights must have dimensions and shape
+        consistent with `a` along the specified axis.
+        If `weights=None`, then all data in `a` are assumed to have a
+        weight equal to one.
+        The calculation is::
+
+            avg = sum(a * weights) / sum(weights)
+        
+        where the sum is over all included elements.
+        The only constraint on the values of `weights` is that `sum(weights)`
+        must not be 0.
+    returned : bool, optional
+        Default is `False`. If `True`, the tuple (`average`, `sum_of_weights`)
+        is returned, otherwise only the average is returned.
+        If `weights=None`, `sum_of_weights` is equivalent to the number of
+        elements over which the average is taken.
+    keepdims : bool, optional
+        If this is set to True, the axes which are reduced are left
+        in the result as dimensions with size one. With this option,
+        the result will broadcast correctly against the original `a`.
+        *Note:* `keepdims` will not work with instances of `numpy.matrix`
+        or other classes whose methods do not support `keepdims`.
+
+        .. versionadded:: 1.23.0
+
+    Returns
+    -------
+    retval, [sum_of_weights] : array_type or double
+        Return the average along the specified axis. When `returned` is `True`,
+        return a tuple with the average as the first element and the sum
+        of the weights as the second element. `sum_of_weights` is of the
+        same type as `retval`. The result dtype follows a general pattern.
+        If `weights` is None, the result dtype will be that of `a` , or ``float64``
+        if `a` is integral. Otherwise, if `weights` is not None and `a` is non-
+        integral, the result type will be the type of lowest precision capable of
+        representing values of both `a` and `weights`. If `a` happens to be
+        integral, the previous rules still applies but the result dtype will
+        at least be ``float64``.
+
+    Raises
+    ------
+    ZeroDivisionError
+        When all weights along axis are zero. See `numpy.ma.average` for a
+        version robust to this type of error.
+    TypeError
+        When `weights` does not have the same shape as `a`, and `axis=None`.
+    ValueError
+        When `weights` does not have dimensions and shape consistent with `a`
+        along specified `axis`.
+
+    See Also
+    --------
+    mean
+
+    ma.average : average for masked arrays -- useful if your data contains
+                 "missing" values
+    numpy.result_type : Returns the type that results from applying the
+                        numpy type promotion rules to the arguments.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> data = np.arange(1, 5)
+    >>> data
+    array([1, 2, 3, 4])
+    >>> np.average(data)
+    2.5
+    >>> np.average(np.arange(1, 11), weights=np.arange(10, 0, -1))
+    4.0
+
+    >>> data = np.arange(6).reshape((3, 2))
+    >>> data
+    array([[0, 1],
+           [2, 3],
+           [4, 5]])
+    >>> np.average(data, axis=1, weights=[1./4, 3./4])
+    array([0.75, 2.75, 4.75])
+    >>> np.average(data, weights=[1./4, 3./4])
+    Traceback (most recent call last):
+        ...
+    TypeError: Axis must be specified when shapes of a and weights differ.
+
+    With ``keepdims=True``, the following result has shape (3, 1).
+
+    >>> np.average(data, axis=1, keepdims=True)
+    array([[0.5],
+           [2.5],
+           [4.5]])
+
+    >>> data = np.arange(8).reshape((2, 2, 2))
+    >>> data
+    array([[[0, 1],
+            [2, 3]],
+           [[4, 5],
+            [6, 7]]])
+    >>> np.average(data, axis=(0, 1), weights=[[1./4, 3./4], [1., 1./2]])
+    array([3.4, 4.4])
+    >>> np.average(data, axis=0, weights=[[1./4, 3./4], [1., 1./2]])
+    Traceback (most recent call last):
+        ...
+    ValueError: Shape of weights must be consistent
+    with shape of a along specified axis.
+    """
+    a = np.asanyarray(a)
+
+    if axis is not None:
+        axis = _nx.normalize_axis_tuple(axis, a.ndim, argname="axis")
+
+    if keepdims is np._NoValue:
+        # Don't pass on the keepdims argument if one wasn't given.
+        keepdims_kw = {}
+    else:
+        keepdims_kw = {'keepdims': keepdims}
+
+    if weights is None:
+        avg = a.mean(axis, **keepdims_kw)
+        avg_as_array = np.asanyarray(avg)
+        scl = avg_as_array.dtype.type(a.size/avg_as_array.size)
+    else:
+        wgt = _weights_are_valid(weights=weights, a=a, axis=axis)
+
+        if issubclass(a.dtype.type, (np.integer, np.bool)):
+            result_dtype = np.result_type(a.dtype, wgt.dtype, 'f8')
+        else:
+            result_dtype = np.result_type(a.dtype, wgt.dtype)
+
+        scl = wgt.sum(axis=axis, dtype=result_dtype, **keepdims_kw)
+        if np.any(scl == 0.0):
+            raise ZeroDivisionError(
+                "Weights sum to zero, can't be normalized")
+
+        avg = avg_as_array = np.multiply(a, wgt,
+                          dtype=result_dtype).sum(axis, **keepdims_kw) / scl
+
+    if returned:
+        if scl.shape != avg_as_array.shape:
+            scl = np.broadcast_to(scl, avg_as_array.shape).copy()
+        return avg, scl
+    else:
+        return avg
+
+
+@set_module('numpy')
+def asarray_chkfinite(a, dtype=None, order=None):
+    """Convert the input to an array, checking for NaNs or Infs.
+
+    Parameters
+    ----------
+    a : array_like
+        Input data, in any form that can be converted to an array.  This
+        includes lists, lists of tuples, tuples, tuples of tuples, tuples
+        of lists and ndarrays.  Success requires no NaNs or Infs.
+    dtype : data-type, optional
+        By default, the data-type is inferred from the input data.
+    order : {'C', 'F', 'A', 'K'}, optional
+        Memory layout.  'A' and 'K' depend on the order of input array a.
+        'C' row-major (C-style),
+        'F' column-major (Fortran-style) memory representation.
+        'A' (any) means 'F' if `a` is Fortran contiguous, 'C' otherwise
+        'K' (keep) preserve input order
+        Defaults to 'C'.
+
+    Returns
+    -------
+    out : ndarray
+        Array interpretation of `a`.  No copy is performed if the input
+        is already an ndarray.  If `a` is a subclass of ndarray, a base
+        class ndarray is returned.
+
+    Raises
+    ------
+    ValueError
+        Raises ValueError if `a` contains NaN (Not a Number) or Inf (Infinity).
+
+    See Also
+    --------
+    asarray : Create and array.
+    asanyarray : Similar function which passes through subclasses.
+    ascontiguousarray : Convert input to a contiguous array.
+    asfortranarray : Convert input to an ndarray with column-major
+                     memory order.
+    fromiter : Create an array from an iterator.
+    fromfunction : Construct an array by executing a function on grid
+                   positions.
+
+    Examples
+    --------
+    >>> import numpy as np
+
+    Convert a list into an array. If all elements are finite, then
+    ``asarray_chkfinite`` is identical to ``asarray``.
+
+    >>> a = [1, 2]
+    >>> np.asarray_chkfinite(a, dtype=float)
+    array([1., 2.])
+
+    Raises ValueError if array_like contains Nans or Infs.
+
+    >>> a = [1, 2, np.inf]
+    >>> try:
+    ...     np.asarray_chkfinite(a)
+    ... except ValueError:
+    ...     print('ValueError')
+    ...
+    ValueError
+
+    """
+    a = asarray(a, dtype=dtype, order=order)
+    if a.dtype.char in typecodes['AllFloat'] and not np.isfinite(a).all():
+        raise ValueError(
+            "array must not contain infs or NaNs")
+    return a
+
+
+def _piecewise_dispatcher(x, condlist, funclist, *args, **kw):
+    yield x
+    # support the undocumented behavior of allowing scalars
+    if np.iterable(condlist):
+        yield from condlist
+
+
+@array_function_dispatch(_piecewise_dispatcher)
+def piecewise(x, condlist, funclist, *args, **kw):
+    """
+    Evaluate a piecewise-defined function.
+
+    Given a set of conditions and corresponding functions, evaluate each
+    function on the input data wherever its condition is true.
+
+    Parameters
+    ----------
+    x : ndarray or scalar
+        The input domain.
+    condlist : list of bool arrays or bool scalars
+        Each boolean array corresponds to a function in `funclist`.  Wherever
+        `condlist[i]` is True, `funclist[i](x)` is used as the output value.
+
+        Each boolean array in `condlist` selects a piece of `x`,
+        and should therefore be of the same shape as `x`.
+
+        The length of `condlist` must correspond to that of `funclist`.
+        If one extra function is given, i.e. if
+        ``len(funclist) == len(condlist) + 1``, then that extra function
+        is the default value, used wherever all conditions are false.
+    funclist : list of callables, f(x,*args,**kw), or scalars
+        Each function is evaluated over `x` wherever its corresponding
+        condition is True.  It should take a 1d array as input and give an 1d
+        array or a scalar value as output.  If, instead of a callable,
+        a scalar is provided then a constant function (``lambda x: scalar``) is
+        assumed.
+    args : tuple, optional
+        Any further arguments given to `piecewise` are passed to the functions
+        upon execution, i.e., if called ``piecewise(..., ..., 1, 'a')``, then
+        each function is called as ``f(x, 1, 'a')``.
+    kw : dict, optional
+        Keyword arguments used in calling `piecewise` are passed to the
+        functions upon execution, i.e., if called
+        ``piecewise(..., ..., alpha=1)``, then each function is called as
+        ``f(x, alpha=1)``.
+
+    Returns
+    -------
+    out : ndarray
+        The output is the same shape and type as x and is found by
+        calling the functions in `funclist` on the appropriate portions of `x`,
+        as defined by the boolean arrays in `condlist`.  Portions not covered
+        by any condition have a default value of 0.
+
+
+    See Also
+    --------
+    choose, select, where
+
+    Notes
+    -----
+    This is similar to choose or select, except that functions are
+    evaluated on elements of `x` that satisfy the corresponding condition from
+    `condlist`.
+
+    The result is::
+
+            |--
+            |funclist[0](x[condlist[0]])
+      out = |funclist[1](x[condlist[1]])
+            |...
+            |funclist[n2](x[condlist[n2]])
+            |--
+
+    Examples
+    --------
+    >>> import numpy as np
+
+    Define the signum function, which is -1 for ``x < 0`` and +1 for ``x >= 0``.
+
+    >>> x = np.linspace(-2.5, 2.5, 6)
+    >>> np.piecewise(x, [x < 0, x >= 0], [-1, 1])
+    array([-1., -1., -1.,  1.,  1.,  1.])
+
+    Define the absolute value, which is ``-x`` for ``x <0`` and ``x`` for
+    ``x >= 0``.
+
+    >>> np.piecewise(x, [x < 0, x >= 0], [lambda x: -x, lambda x: x])
+    array([2.5,  1.5,  0.5,  0.5,  1.5,  2.5])
+
+    Apply the same function to a scalar value.
+
+    >>> y = -2
+    >>> np.piecewise(y, [y < 0, y >= 0], [lambda x: -x, lambda x: x])
+    array(2)
+
+    """
+    x = asanyarray(x)
+    n2 = len(funclist)
+
+    # undocumented: single condition is promoted to a list of one condition
+    if isscalar(condlist) or (
+            not isinstance(condlist[0], (list, ndarray)) and x.ndim != 0):
+        condlist = [condlist]
+
+    condlist = asarray(condlist, dtype=bool)
+    n = len(condlist)
+
+    if n == n2 - 1:  # compute the "otherwise" condition.
+        condelse = ~np.any(condlist, axis=0, keepdims=True)
+        condlist = np.concatenate([condlist, condelse], axis=0)
+        n += 1
+    elif n != n2:
+        raise ValueError(
+            "with {} condition(s), either {} or {} functions are expected"
+            .format(n, n, n+1)
+        )
+
+    y = zeros_like(x)
+    for cond, func in zip(condlist, funclist):
+        if not isinstance(func, collections.abc.Callable):
+            y[cond] = func
+        else:
+            vals = x[cond]
+            if vals.size > 0:
+                y[cond] = func(vals, *args, **kw)
+
+    return y
+
+
+def _select_dispatcher(condlist, choicelist, default=None):
+    yield from condlist
+    yield from choicelist
+
+
+@array_function_dispatch(_select_dispatcher)
+def select(condlist, choicelist, default=0):
+    """
+    Return an array drawn from elements in choicelist, depending on conditions.
+
+    Parameters
+    ----------
+    condlist : list of bool ndarrays
+        The list of conditions which determine from which array in `choicelist`
+        the output elements are taken. When multiple conditions are satisfied,
+        the first one encountered in `condlist` is used.
+    choicelist : list of ndarrays
+        The list of arrays from which the output elements are taken. It has
+        to be of the same length as `condlist`.
+    default : scalar, optional
+        The element inserted in `output` when all conditions evaluate to False.
+
+    Returns
+    -------
+    output : ndarray
+        The output at position m is the m-th element of the array in
+        `choicelist` where the m-th element of the corresponding array in
+        `condlist` is True.
+
+    See Also
+    --------
+    where : Return elements from one of two arrays depending on condition.
+    take, choose, compress, diag, diagonal
+
+    Examples
+    --------
+    >>> import numpy as np
+
+    Beginning with an array of integers from 0 to 5 (inclusive),
+    elements less than ``3`` are negated, elements greater than ``3``
+    are squared, and elements not meeting either of these conditions
+    (exactly ``3``) are replaced with a `default` value of ``42``.
+
+    >>> x = np.arange(6)
+    >>> condlist = [x<3, x>3]
+    >>> choicelist = [x, x**2]
+    >>> np.select(condlist, choicelist, 42)
+    array([ 0,  1,  2, 42, 16, 25])
+
+    When multiple conditions are satisfied, the first one encountered in
+    `condlist` is used.
+
+    >>> condlist = [x<=4, x>3]
+    >>> choicelist = [x, x**2]
+    >>> np.select(condlist, choicelist, 55)
+    array([ 0,  1,  2,  3,  4, 25])
+
+    """
+    # Check the size of condlist and choicelist are the same, or abort.
+    if len(condlist) != len(choicelist):
+        raise ValueError(
+            'list of cases must be same length as list of conditions')
+
+    # Now that the dtype is known, handle the deprecated select([], []) case
+    if len(condlist) == 0:
+        raise ValueError("select with an empty condition list is not possible")
+
+    # TODO: This preserves the Python int, float, complex manually to get the
+    #       right `result_type` with NEP 50.  Most likely we will grow a better
+    #       way to spell this (and this can be replaced).
+    choicelist = [
+        choice if type(choice) in (int, float, complex) else np.asarray(choice)
+        for choice in choicelist]
+    choicelist.append(default if type(default) in (int, float, complex)
+                      else np.asarray(default))
+
+    try:
+        dtype = np.result_type(*choicelist)
+    except TypeError as e:
+        msg = f'Choicelist and default value do not have a common dtype: {e}'
+        raise TypeError(msg) from None
+
+    # Convert conditions to arrays and broadcast conditions and choices
+    # as the shape is needed for the result. Doing it separately optimizes
+    # for example when all choices are scalars.
+    condlist = np.broadcast_arrays(*condlist)
+    choicelist = np.broadcast_arrays(*choicelist)
+
+    # If cond array is not an ndarray in boolean format or scalar bool, abort.
+    for i, cond in enumerate(condlist):
+        if cond.dtype.type is not np.bool:
+            raise TypeError(
+                'invalid entry {} in condlist: should be boolean ndarray'.format(i))
+
+    if choicelist[0].ndim == 0:
+        # This may be common, so avoid the call.
+        result_shape = condlist[0].shape
+    else:
+        result_shape = np.broadcast_arrays(condlist[0], choicelist[0])[0].shape
+
+    result = np.full(result_shape, choicelist[-1], dtype)
+
+    # Use np.copyto to burn each choicelist array onto result, using the
+    # corresponding condlist as a boolean mask. This is done in reverse
+    # order since the first choice should take precedence.
+    choicelist = choicelist[-2::-1]
+    condlist = condlist[::-1]
+    for choice, cond in zip(choicelist, condlist):
+        np.copyto(result, choice, where=cond)
+
+    return result
+
+
+def _copy_dispatcher(a, order=None, subok=None):
+    return (a,)
+
+
+@array_function_dispatch(_copy_dispatcher)
+def copy(a, order='K', subok=False):
+    """
+    Return an array copy of the given object.
+
+    Parameters
+    ----------
+    a : array_like
+        Input data.
+    order : {'C', 'F', 'A', 'K'}, optional
+        Controls the memory layout of the copy. 'C' means C-order,
+        'F' means F-order, 'A' means 'F' if `a` is Fortran contiguous,
+        'C' otherwise. 'K' means match the layout of `a` as closely
+        as possible. (Note that this function and :meth:`ndarray.copy` are very
+        similar, but have different default values for their order=
+        arguments.)
+    subok : bool, optional
+        If True, then sub-classes will be passed-through, otherwise the
+        returned array will be forced to be a base-class array (defaults to False).
+
+        .. versionadded:: 1.19.0
+
+    Returns
+    -------
+    arr : ndarray
+        Array interpretation of `a`.
+
+    See Also
+    --------
+    ndarray.copy : Preferred method for creating an array copy
+
+    Notes
+    -----
+    This is equivalent to:
+
+    >>> np.array(a, copy=True)  #doctest: +SKIP
+
+    The copy made of the data is shallow, i.e., for arrays with object dtype,
+    the new array will point to the same objects.
+    See Examples from `ndarray.copy`.
+
+    Examples
+    --------
+    >>> import numpy as np
+
+    Create an array x, with a reference y and a copy z:
+
+    >>> x = np.array([1, 2, 3])
+    >>> y = x
+    >>> z = np.copy(x)
+
+    Note that, when we modify x, y changes, but not z:
+
+    >>> x[0] = 10
+    >>> x[0] == y[0]
+    True
+    >>> x[0] == z[0]
+    False
+
+    Note that, np.copy clears previously set WRITEABLE=False flag.
+
+    >>> a = np.array([1, 2, 3])
+    >>> a.flags["WRITEABLE"] = False
+    >>> b = np.copy(a)
+    >>> b.flags["WRITEABLE"]
+    True
+    >>> b[0] = 3
+    >>> b
+    array([3, 2, 3])
+    """
+    return array(a, order=order, subok=subok, copy=True)
+
+# Basic operations
+
+
+def _gradient_dispatcher(f, *varargs, axis=None, edge_order=None):
+    yield f
+    yield from varargs
+
+
+@array_function_dispatch(_gradient_dispatcher)
+def gradient(f, *varargs, axis=None, edge_order=1):
+    """
+    Return the gradient of an N-dimensional array.
+
+    The gradient is computed using second order accurate central differences
+    in the interior points and either first or second order accurate one-sides
+    (forward or backwards) differences at the boundaries.
+    The returned gradient hence has the same shape as the input array.
+
+    Parameters
+    ----------
+    f : array_like
+        An N-dimensional array containing samples of a scalar function.
+    varargs : list of scalar or array, optional
+        Spacing between f values. Default unitary spacing for all dimensions.
+        Spacing can be specified using:
+
+        1. single scalar to specify a sample distance for all dimensions.
+        2. N scalars to specify a constant sample distance for each dimension.
+           i.e. `dx`, `dy`, `dz`, ...
+        3. N arrays to specify the coordinates of the values along each
+           dimension of F. The length of the array must match the size of
+           the corresponding dimension
+        4. Any combination of N scalars/arrays with the meaning of 2. and 3.
+
+        If `axis` is given, the number of varargs must equal the number of axes.
+        Default: 1. (see Examples below).
+
+    edge_order : {1, 2}, optional
+        Gradient is calculated using N-th order accurate differences
+        at the boundaries. Default: 1.
+
+        .. versionadded:: 1.9.1
+
+    axis : None or int or tuple of ints, optional
+        Gradient is calculated only along the given axis or axes
+        The default (axis = None) is to calculate the gradient for all the axes
+        of the input array. axis may be negative, in which case it counts from
+        the last to the first axis.
+
+        .. versionadded:: 1.11.0
+
+    Returns
+    -------
+    gradient : ndarray or tuple of ndarray
+        A tuple of ndarrays (or a single ndarray if there is only one
+        dimension) corresponding to the derivatives of f with respect
+        to each dimension. Each derivative has the same shape as f.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> f = np.array([1, 2, 4, 7, 11, 16])
+    >>> np.gradient(f)
+    array([1. , 1.5, 2.5, 3.5, 4.5, 5. ])
+    >>> np.gradient(f, 2)
+    array([0.5 ,  0.75,  1.25,  1.75,  2.25,  2.5 ])
+
+    Spacing can be also specified with an array that represents the coordinates
+    of the values F along the dimensions.
+    For instance a uniform spacing:
+
+    >>> x = np.arange(f.size)
+    >>> np.gradient(f, x)
+    array([1. ,  1.5,  2.5,  3.5,  4.5,  5. ])
+
+    Or a non uniform one:
+
+    >>> x = np.array([0., 1., 1.5, 3.5, 4., 6.])
+    >>> np.gradient(f, x)
+    array([1. ,  3. ,  3.5,  6.7,  6.9,  2.5])
+
+    For two dimensional arrays, the return will be two arrays ordered by
+    axis. In this example the first array stands for the gradient in
+    rows and the second one in columns direction:
+
+    >>> np.gradient(np.array([[1, 2, 6], [3, 4, 5]]))
+    (array([[ 2.,  2., -1.],
+            [ 2.,  2., -1.]]),
+     array([[1. , 2.5, 4. ],
+            [1. , 1. , 1. ]]))
+
+    In this example the spacing is also specified:
+    uniform for axis=0 and non uniform for axis=1
+
+    >>> dx = 2.
+    >>> y = [1., 1.5, 3.5]
+    >>> np.gradient(np.array([[1, 2, 6], [3, 4, 5]]), dx, y)
+    (array([[ 1. ,  1. , -0.5],
+            [ 1. ,  1. , -0.5]]),
+     array([[2. , 2. , 2. ],
+            [2. , 1.7, 0.5]]))
+
+    It is possible to specify how boundaries are treated using `edge_order`
+
+    >>> x = np.array([0, 1, 2, 3, 4])
+    >>> f = x**2
+    >>> np.gradient(f, edge_order=1)
+    array([1.,  2.,  4.,  6.,  7.])
+    >>> np.gradient(f, edge_order=2)
+    array([0., 2., 4., 6., 8.])
+
+    The `axis` keyword can be used to specify a subset of axes of which the
+    gradient is calculated
+
+    >>> np.gradient(np.array([[1, 2, 6], [3, 4, 5]]), axis=0)
+    array([[ 2.,  2., -1.],
+           [ 2.,  2., -1.]])
+
+    The `varargs` argument defines the spacing between sample points in the
+    input array. It can take two forms:
+
+    1. An array, specifying coordinates, which may be unevenly spaced:
+
+    >>> x = np.array([0., 2., 3., 6., 8.])
+    >>> y = x ** 2
+    >>> np.gradient(y, x, edge_order=2)
+    array([ 0.,  4.,  6., 12., 16.])
+
+    2. A scalar, representing the fixed sample distance:
+
+    >>> dx = 2
+    >>> x = np.array([0., 2., 4., 6., 8.])
+    >>> y = x ** 2
+    >>> np.gradient(y, dx, edge_order=2)
+    array([ 0.,  4.,  8., 12., 16.])
+
+    It's possible to provide different data for spacing along each dimension.
+    The number of arguments must match the number of dimensions in the input
+    data.
+
+    >>> dx = 2
+    >>> dy = 3
+    >>> x = np.arange(0, 6, dx)
+    >>> y = np.arange(0, 9, dy)
+    >>> xs, ys = np.meshgrid(x, y)
+    >>> zs = xs + 2 * ys
+    >>> np.gradient(zs, dy, dx)  # Passing two scalars
+    (array([[2., 2., 2.],
+            [2., 2., 2.],
+            [2., 2., 2.]]),
+     array([[1., 1., 1.],
+            [1., 1., 1.],
+            [1., 1., 1.]]))
+
+    Mixing scalars and arrays is also allowed:
+
+    >>> np.gradient(zs, y, dx)  # Passing one array and one scalar
+    (array([[2., 2., 2.],
+            [2., 2., 2.],
+            [2., 2., 2.]]),
+     array([[1., 1., 1.],
+            [1., 1., 1.],
+            [1., 1., 1.]]))
+
+    Notes
+    -----
+    Assuming that :math:`f\\in C^{3}` (i.e., :math:`f` has at least 3 continuous
+    derivatives) and let :math:`h_{*}` be a non-homogeneous stepsize, we
+    minimize the "consistency error" :math:`\\eta_{i}` between the true gradient
+    and its estimate from a linear combination of the neighboring grid-points:
+
+    .. math::
+
+        \\eta_{i} = f_{i}^{\\left(1\\right)} -
+                    \\left[ \\alpha f\\left(x_{i}\\right) +
+                            \\beta f\\left(x_{i} + h_{d}\\right) +
+                            \\gamma f\\left(x_{i}-h_{s}\\right)
+                    \\right]
+
+    By substituting :math:`f(x_{i} + h_{d})` and :math:`f(x_{i} - h_{s})`
+    with their Taylor series expansion, this translates into solving
+    the following the linear system:
+
+    .. math::
+
+        \\left\\{
+            \\begin{array}{r}
+                \\alpha+\\beta+\\gamma=0 \\\\
+                \\beta h_{d}-\\gamma h_{s}=1 \\\\
+                \\beta h_{d}^{2}+\\gamma h_{s}^{2}=0
+            \\end{array}
+        \\right.
+
+    The resulting approximation of :math:`f_{i}^{(1)}` is the following:
+
+    .. math::
+
+        \\hat f_{i}^{(1)} =
+            \\frac{
+                h_{s}^{2}f\\left(x_{i} + h_{d}\\right)
+                + \\left(h_{d}^{2} - h_{s}^{2}\\right)f\\left(x_{i}\\right)
+                - h_{d}^{2}f\\left(x_{i}-h_{s}\\right)}
+                { h_{s}h_{d}\\left(h_{d} + h_{s}\\right)}
+            + \\mathcal{O}\\left(\\frac{h_{d}h_{s}^{2}
+                                + h_{s}h_{d}^{2}}{h_{d}
+                                + h_{s}}\\right)
+
+    It is worth noting that if :math:`h_{s}=h_{d}`
+    (i.e., data are evenly spaced)
+    we find the standard second order approximation:
+
+    .. math::
+
+        \\hat f_{i}^{(1)}=
+            \\frac{f\\left(x_{i+1}\\right) - f\\left(x_{i-1}\\right)}{2h}
+            + \\mathcal{O}\\left(h^{2}\\right)
+
+    With a similar procedure the forward/backward approximations used for
+    boundaries can be derived.
+
+    References
+    ----------
+    .. [1]  Quarteroni A., Sacco R., Saleri F. (2007) Numerical Mathematics
+            (Texts in Applied Mathematics). New York: Springer.
+    .. [2]  Durran D. R. (1999) Numerical Methods for Wave Equations
+            in Geophysical Fluid Dynamics. New York: Springer.
+    .. [3]  Fornberg B. (1988) Generation of Finite Difference Formulas on
+            Arbitrarily Spaced Grids,
+            Mathematics of Computation 51, no. 184 : 699-706.
+            `PDF `_.
+    """
+    f = np.asanyarray(f)
+    N = f.ndim  # number of dimensions
+
+    if axis is None:
+        axes = tuple(range(N))
+    else:
+        axes = _nx.normalize_axis_tuple(axis, N)
+
+    len_axes = len(axes)
+    n = len(varargs)
+    if n == 0:
+        # no spacing argument - use 1 in all axes
+        dx = [1.0] * len_axes
+    elif n == 1 and np.ndim(varargs[0]) == 0:
+        # single scalar for all axes
+        dx = varargs * len_axes
+    elif n == len_axes:
+        # scalar or 1d array for each axis
+        dx = list(varargs)
+        for i, distances in enumerate(dx):
+            distances = np.asanyarray(distances)
+            if distances.ndim == 0:
+                continue
+            elif distances.ndim != 1:
+                raise ValueError("distances must be either scalars or 1d")
+            if len(distances) != f.shape[axes[i]]:
+                raise ValueError("when 1d, distances must match "
+                                 "the length of the corresponding dimension")
+            if np.issubdtype(distances.dtype, np.integer):
+                # Convert numpy integer types to float64 to avoid modular
+                # arithmetic in np.diff(distances).
+                distances = distances.astype(np.float64)
+            diffx = np.diff(distances)
+            # if distances are constant reduce to the scalar case
+            # since it brings a consistent speedup
+            if (diffx == diffx[0]).all():
+                diffx = diffx[0]
+            dx[i] = diffx
+    else:
+        raise TypeError("invalid number of arguments")
+
+    if edge_order > 2:
+        raise ValueError("'edge_order' greater than 2 not supported")
+
+    # use central differences on interior and one-sided differences on the
+    # endpoints. This preserves second order-accuracy over the full domain.
+
+    outvals = []
+
+    # create slice objects --- initially all are [:, :, ..., :]
+    slice1 = [slice(None)]*N
+    slice2 = [slice(None)]*N
+    slice3 = [slice(None)]*N
+    slice4 = [slice(None)]*N
+
+    otype = f.dtype
+    if otype.type is np.datetime64:
+        # the timedelta dtype with the same unit information
+        otype = np.dtype(otype.name.replace('datetime', 'timedelta'))
+        # view as timedelta to allow addition
+        f = f.view(otype)
+    elif otype.type is np.timedelta64:
+        pass
+    elif np.issubdtype(otype, np.inexact):
+        pass
+    else:
+        # All other types convert to floating point.
+        # First check if f is a numpy integer type; if so, convert f to float64
+        # to avoid modular arithmetic when computing the changes in f.
+        if np.issubdtype(otype, np.integer):
+            f = f.astype(np.float64)
+        otype = np.float64
+
+    for axis, ax_dx in zip(axes, dx):
+        if f.shape[axis] < edge_order + 1:
+            raise ValueError(
+                "Shape of array too small to calculate a numerical gradient, "
+                "at least (edge_order + 1) elements are required.")
+        # result allocation
+        out = np.empty_like(f, dtype=otype)
+
+        # spacing for the current axis
+        uniform_spacing = np.ndim(ax_dx) == 0
+
+        # Numerical differentiation: 2nd order interior
+        slice1[axis] = slice(1, -1)
+        slice2[axis] = slice(None, -2)
+        slice3[axis] = slice(1, -1)
+        slice4[axis] = slice(2, None)
+
+        if uniform_spacing:
+            out[tuple(slice1)] = (f[tuple(slice4)] - f[tuple(slice2)]) / (2. * ax_dx)
+        else:
+            dx1 = ax_dx[0:-1]
+            dx2 = ax_dx[1:]
+            a = -(dx2)/(dx1 * (dx1 + dx2))
+            b = (dx2 - dx1) / (dx1 * dx2)
+            c = dx1 / (dx2 * (dx1 + dx2))
+            # fix the shape for broadcasting
+            shape = np.ones(N, dtype=int)
+            shape[axis] = -1
+            a.shape = b.shape = c.shape = shape
+            # 1D equivalent -- out[1:-1] = a * f[:-2] + b * f[1:-1] + c * f[2:]
+            out[tuple(slice1)] = a * f[tuple(slice2)] + b * f[tuple(slice3)] + c * f[tuple(slice4)]
+
+        # Numerical differentiation: 1st order edges
+        if edge_order == 1:
+            slice1[axis] = 0
+            slice2[axis] = 1
+            slice3[axis] = 0
+            dx_0 = ax_dx if uniform_spacing else ax_dx[0]
+            # 1D equivalent -- out[0] = (f[1] - f[0]) / (x[1] - x[0])
+            out[tuple(slice1)] = (f[tuple(slice2)] - f[tuple(slice3)]) / dx_0
+
+            slice1[axis] = -1
+            slice2[axis] = -1
+            slice3[axis] = -2
+            dx_n = ax_dx if uniform_spacing else ax_dx[-1]
+            # 1D equivalent -- out[-1] = (f[-1] - f[-2]) / (x[-1] - x[-2])
+            out[tuple(slice1)] = (f[tuple(slice2)] - f[tuple(slice3)]) / dx_n
+
+        # Numerical differentiation: 2nd order edges
+        else:
+            slice1[axis] = 0
+            slice2[axis] = 0
+            slice3[axis] = 1
+            slice4[axis] = 2
+            if uniform_spacing:
+                a = -1.5 / ax_dx
+                b = 2. / ax_dx
+                c = -0.5 / ax_dx
+            else:
+                dx1 = ax_dx[0]
+                dx2 = ax_dx[1]
+                a = -(2. * dx1 + dx2)/(dx1 * (dx1 + dx2))
+                b = (dx1 + dx2) / (dx1 * dx2)
+                c = - dx1 / (dx2 * (dx1 + dx2))
+            # 1D equivalent -- out[0] = a * f[0] + b * f[1] + c * f[2]
+            out[tuple(slice1)] = a * f[tuple(slice2)] + b * f[tuple(slice3)] + c * f[tuple(slice4)]
+
+            slice1[axis] = -1
+            slice2[axis] = -3
+            slice3[axis] = -2
+            slice4[axis] = -1
+            if uniform_spacing:
+                a = 0.5 / ax_dx
+                b = -2. / ax_dx
+                c = 1.5 / ax_dx
+            else:
+                dx1 = ax_dx[-2]
+                dx2 = ax_dx[-1]
+                a = (dx2) / (dx1 * (dx1 + dx2))
+                b = - (dx2 + dx1) / (dx1 * dx2)
+                c = (2. * dx2 + dx1) / (dx2 * (dx1 + dx2))
+            # 1D equivalent -- out[-1] = a * f[-3] + b * f[-2] + c * f[-1]
+            out[tuple(slice1)] = a * f[tuple(slice2)] + b * f[tuple(slice3)] + c * f[tuple(slice4)]
+
+        outvals.append(out)
+
+        # reset the slice object in this dimension to ":"
+        slice1[axis] = slice(None)
+        slice2[axis] = slice(None)
+        slice3[axis] = slice(None)
+        slice4[axis] = slice(None)
+
+    if len_axes == 1:
+        return outvals[0]
+    return tuple(outvals)
+
+
+def _diff_dispatcher(a, n=None, axis=None, prepend=None, append=None):
+    return (a, prepend, append)
+
+
+@array_function_dispatch(_diff_dispatcher)
+def diff(a, n=1, axis=-1, prepend=np._NoValue, append=np._NoValue):
+    """
+    Calculate the n-th discrete difference along the given axis.
+
+    The first difference is given by ``out[i] = a[i+1] - a[i]`` along
+    the given axis, higher differences are calculated by using `diff`
+    recursively.
+
+    Parameters
+    ----------
+    a : array_like
+        Input array
+    n : int, optional
+        The number of times values are differenced. If zero, the input
+        is returned as-is.
+    axis : int, optional
+        The axis along which the difference is taken, default is the
+        last axis.
+    prepend, append : array_like, optional
+        Values to prepend or append to `a` along axis prior to
+        performing the difference.  Scalar values are expanded to
+        arrays with length 1 in the direction of axis and the shape
+        of the input array in along all other axes.  Otherwise the
+        dimension and shape must match `a` except along axis.
+
+        .. versionadded:: 1.16.0
+
+    Returns
+    -------
+    diff : ndarray
+        The n-th differences. The shape of the output is the same as `a`
+        except along `axis` where the dimension is smaller by `n`. The
+        type of the output is the same as the type of the difference
+        between any two elements of `a`. This is the same as the type of
+        `a` in most cases. A notable exception is `datetime64`, which
+        results in a `timedelta64` output array.
+
+    See Also
+    --------
+    gradient, ediff1d, cumsum
+
+    Notes
+    -----
+    Type is preserved for boolean arrays, so the result will contain
+    `False` when consecutive elements are the same and `True` when they
+    differ.
+
+    For unsigned integer arrays, the results will also be unsigned. This
+    should not be surprising, as the result is consistent with
+    calculating the difference directly:
+
+    >>> u8_arr = np.array([1, 0], dtype=np.uint8)
+    >>> np.diff(u8_arr)
+    array([255], dtype=uint8)
+    >>> u8_arr[1,...] - u8_arr[0,...]
+    255
+
+    If this is not desirable, then the array should be cast to a larger
+    integer type first:
+
+    >>> i16_arr = u8_arr.astype(np.int16)
+    >>> np.diff(i16_arr)
+    array([-1], dtype=int16)
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> x = np.array([1, 2, 4, 7, 0])
+    >>> np.diff(x)
+    array([ 1,  2,  3, -7])
+    >>> np.diff(x, n=2)
+    array([  1,   1, -10])
+
+    >>> x = np.array([[1, 3, 6, 10], [0, 5, 6, 8]])
+    >>> np.diff(x)
+    array([[2, 3, 4],
+           [5, 1, 2]])
+    >>> np.diff(x, axis=0)
+    array([[-1,  2,  0, -2]])
+
+    >>> x = np.arange('1066-10-13', '1066-10-16', dtype=np.datetime64)
+    >>> np.diff(x)
+    array([1, 1], dtype='timedelta64[D]')
+
+    """
+    if n == 0:
+        return a
+    if n < 0:
+        raise ValueError(
+            "order must be non-negative but got " + repr(n))
+
+    a = asanyarray(a)
+    nd = a.ndim
+    if nd == 0:
+        raise ValueError("diff requires input that is at least one dimensional")
+    axis = normalize_axis_index(axis, nd)
+
+    combined = []
+    if prepend is not np._NoValue:
+        prepend = np.asanyarray(prepend)
+        if prepend.ndim == 0:
+            shape = list(a.shape)
+            shape[axis] = 1
+            prepend = np.broadcast_to(prepend, tuple(shape))
+        combined.append(prepend)
+
+    combined.append(a)
+
+    if append is not np._NoValue:
+        append = np.asanyarray(append)
+        if append.ndim == 0:
+            shape = list(a.shape)
+            shape[axis] = 1
+            append = np.broadcast_to(append, tuple(shape))
+        combined.append(append)
+
+    if len(combined) > 1:
+        a = np.concatenate(combined, axis)
+
+    slice1 = [slice(None)] * nd
+    slice2 = [slice(None)] * nd
+    slice1[axis] = slice(1, None)
+    slice2[axis] = slice(None, -1)
+    slice1 = tuple(slice1)
+    slice2 = tuple(slice2)
+
+    op = not_equal if a.dtype == np.bool else subtract
+    for _ in range(n):
+        a = op(a[slice1], a[slice2])
+
+    return a
+
+
+def _interp_dispatcher(x, xp, fp, left=None, right=None, period=None):
+    return (x, xp, fp)
+
+
+@array_function_dispatch(_interp_dispatcher)
+def interp(x, xp, fp, left=None, right=None, period=None):
+    """
+    One-dimensional linear interpolation for monotonically increasing sample points.
+
+    Returns the one-dimensional piecewise linear interpolant to a function
+    with given discrete data points (`xp`, `fp`), evaluated at `x`.
+
+    Parameters
+    ----------
+    x : array_like
+        The x-coordinates at which to evaluate the interpolated values.
+
+    xp : 1-D sequence of floats
+        The x-coordinates of the data points, must be increasing if argument
+        `period` is not specified. Otherwise, `xp` is internally sorted after
+        normalizing the periodic boundaries with ``xp = xp % period``.
+
+    fp : 1-D sequence of float or complex
+        The y-coordinates of the data points, same length as `xp`.
+
+    left : optional float or complex corresponding to fp
+        Value to return for `x < xp[0]`, default is `fp[0]`.
+
+    right : optional float or complex corresponding to fp
+        Value to return for `x > xp[-1]`, default is `fp[-1]`.
+
+    period : None or float, optional
+        A period for the x-coordinates. This parameter allows the proper
+        interpolation of angular x-coordinates. Parameters `left` and `right`
+        are ignored if `period` is specified.
+
+        .. versionadded:: 1.10.0
+
+    Returns
+    -------
+    y : float or complex (corresponding to fp) or ndarray
+        The interpolated values, same shape as `x`.
+
+    Raises
+    ------
+    ValueError
+        If `xp` and `fp` have different length
+        If `xp` or `fp` are not 1-D sequences
+        If `period == 0`
+
+    See Also
+    --------
+    scipy.interpolate
+
+    Warnings
+    --------
+    The x-coordinate sequence is expected to be increasing, but this is not
+    explicitly enforced.  However, if the sequence `xp` is non-increasing,
+    interpolation results are meaningless.
+
+    Note that, since NaN is unsortable, `xp` also cannot contain NaNs.
+
+    A simple check for `xp` being strictly increasing is::
+
+        np.all(np.diff(xp) > 0)
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> xp = [1, 2, 3]
+    >>> fp = [3, 2, 0]
+    >>> np.interp(2.5, xp, fp)
+    1.0
+    >>> np.interp([0, 1, 1.5, 2.72, 3.14], xp, fp)
+    array([3.  , 3.  , 2.5 , 0.56, 0.  ])
+    >>> UNDEF = -99.0
+    >>> np.interp(3.14, xp, fp, right=UNDEF)
+    -99.0
+
+    Plot an interpolant to the sine function:
+
+    >>> x = np.linspace(0, 2*np.pi, 10)
+    >>> y = np.sin(x)
+    >>> xvals = np.linspace(0, 2*np.pi, 50)
+    >>> yinterp = np.interp(xvals, x, y)
+    >>> import matplotlib.pyplot as plt
+    >>> plt.plot(x, y, 'o')
+    []
+    >>> plt.plot(xvals, yinterp, '-x')
+    []
+    >>> plt.show()
+
+    Interpolation with periodic x-coordinates:
+
+    >>> x = [-180, -170, -185, 185, -10, -5, 0, 365]
+    >>> xp = [190, -190, 350, -350]
+    >>> fp = [5, 10, 3, 4]
+    >>> np.interp(x, xp, fp, period=360)
+    array([7.5 , 5.  , 8.75, 6.25, 3.  , 3.25, 3.5 , 3.75])
+
+    Complex interpolation:
+
+    >>> x = [1.5, 4.0]
+    >>> xp = [2,3,5]
+    >>> fp = [1.0j, 0, 2+3j]
+    >>> np.interp(x, xp, fp)
+    array([0.+1.j , 1.+1.5j])
+
+    """
+
+    fp = np.asarray(fp)
+
+    if np.iscomplexobj(fp):
+        interp_func = compiled_interp_complex
+        input_dtype = np.complex128
+    else:
+        interp_func = compiled_interp
+        input_dtype = np.float64
+
+    if period is not None:
+        if period == 0:
+            raise ValueError("period must be a non-zero value")
+        period = abs(period)
+        left = None
+        right = None
+
+        x = np.asarray(x, dtype=np.float64)
+        xp = np.asarray(xp, dtype=np.float64)
+        fp = np.asarray(fp, dtype=input_dtype)
+
+        if xp.ndim != 1 or fp.ndim != 1:
+            raise ValueError("Data points must be 1-D sequences")
+        if xp.shape[0] != fp.shape[0]:
+            raise ValueError("fp and xp are not of the same length")
+        # normalizing periodic boundaries
+        x = x % period
+        xp = xp % period
+        asort_xp = np.argsort(xp)
+        xp = xp[asort_xp]
+        fp = fp[asort_xp]
+        xp = np.concatenate((xp[-1:]-period, xp, xp[0:1]+period))
+        fp = np.concatenate((fp[-1:], fp, fp[0:1]))
+
+    return interp_func(x, xp, fp, left, right)
+
+
+def _angle_dispatcher(z, deg=None):
+    return (z,)
+
+
+@array_function_dispatch(_angle_dispatcher)
+def angle(z, deg=False):
+    """
+    Return the angle of the complex argument.
+
+    Parameters
+    ----------
+    z : array_like
+        A complex number or sequence of complex numbers.
+    deg : bool, optional
+        Return angle in degrees if True, radians if False (default).
+
+    Returns
+    -------
+    angle : ndarray or scalar
+        The counterclockwise angle from the positive real axis on the complex
+        plane in the range ``(-pi, pi]``, with dtype as numpy.float64.
+
+        .. versionchanged:: 1.16.0
+            This function works on subclasses of ndarray like `ma.array`.
+
+    See Also
+    --------
+    arctan2
+    absolute
+
+    Notes
+    -----
+    This function passes the imaginary and real parts of the argument to
+    `arctan2` to compute the result; consequently, it follows the convention
+    of `arctan2` when the magnitude of the argument is zero. See example.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> np.angle([1.0, 1.0j, 1+1j])               # in radians
+    array([ 0.        ,  1.57079633,  0.78539816]) # may vary
+    >>> np.angle(1+1j, deg=True)                  # in degrees
+    45.0
+    >>> np.angle([0., -0., complex(0., -0.), complex(-0., -0.)])  # convention
+    array([ 0.        ,  3.14159265, -0.        , -3.14159265])
+
+    """
+    z = asanyarray(z)
+    if issubclass(z.dtype.type, _nx.complexfloating):
+        zimag = z.imag
+        zreal = z.real
+    else:
+        zimag = 0
+        zreal = z
+
+    a = arctan2(zimag, zreal)
+    if deg:
+        a *= 180/pi
+    return a
+
+
+def _unwrap_dispatcher(p, discont=None, axis=None, *, period=None):
+    return (p,)
+
+
+@array_function_dispatch(_unwrap_dispatcher)
+def unwrap(p, discont=None, axis=-1, *, period=2*pi):
+    r"""
+    Unwrap by taking the complement of large deltas with respect to the period.
+
+    This unwraps a signal `p` by changing elements which have an absolute
+    difference from their predecessor of more than ``max(discont, period/2)``
+    to their `period`-complementary values.
+
+    For the default case where `period` is :math:`2\pi` and `discont` is
+    :math:`\pi`, this unwraps a radian phase `p` such that adjacent differences
+    are never greater than :math:`\pi` by adding :math:`2k\pi` for some
+    integer :math:`k`.
+
+    Parameters
+    ----------
+    p : array_like
+        Input array.
+    discont : float, optional
+        Maximum discontinuity between values, default is ``period/2``.
+        Values below ``period/2`` are treated as if they were ``period/2``.
+        To have an effect different from the default, `discont` should be
+        larger than ``period/2``.
+    axis : int, optional
+        Axis along which unwrap will operate, default is the last axis.
+    period : float, optional
+        Size of the range over which the input wraps. By default, it is
+        ``2 pi``.
+
+        .. versionadded:: 1.21.0
+
+    Returns
+    -------
+    out : ndarray
+        Output array.
+
+    See Also
+    --------
+    rad2deg, deg2rad
+
+    Notes
+    -----
+    If the discontinuity in `p` is smaller than ``period/2``,
+    but larger than `discont`, no unwrapping is done because taking
+    the complement would only make the discontinuity larger.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> phase = np.linspace(0, np.pi, num=5)
+    >>> phase[3:] += np.pi
+    >>> phase
+    array([ 0.        ,  0.78539816,  1.57079633,  5.49778714,  6.28318531]) # may vary
+    >>> np.unwrap(phase)
+    array([ 0.        ,  0.78539816,  1.57079633, -0.78539816,  0.        ]) # may vary
+    >>> np.unwrap([0, 1, 2, -1, 0], period=4)
+    array([0, 1, 2, 3, 4])
+    >>> np.unwrap([ 1, 2, 3, 4, 5, 6, 1, 2, 3], period=6)
+    array([1, 2, 3, 4, 5, 6, 7, 8, 9])
+    >>> np.unwrap([2, 3, 4, 5, 2, 3, 4, 5], period=4)
+    array([2, 3, 4, 5, 6, 7, 8, 9])
+    >>> phase_deg = np.mod(np.linspace(0 ,720, 19), 360) - 180
+    >>> np.unwrap(phase_deg, period=360)
+    array([-180., -140., -100.,  -60.,  -20.,   20.,   60.,  100.,  140.,
+            180.,  220.,  260.,  300.,  340.,  380.,  420.,  460.,  500.,
+            540.])
+    """
+    p = asarray(p)
+    nd = p.ndim
+    dd = diff(p, axis=axis)
+    if discont is None:
+        discont = period/2
+    slice1 = [slice(None, None)]*nd     # full slices
+    slice1[axis] = slice(1, None)
+    slice1 = tuple(slice1)
+    dtype = np.result_type(dd, period)
+    if _nx.issubdtype(dtype, _nx.integer):
+        interval_high, rem = divmod(period, 2)
+        boundary_ambiguous = rem == 0
+    else:
+        interval_high = period / 2
+        boundary_ambiguous = True
+    interval_low = -interval_high
+    ddmod = mod(dd - interval_low, period) + interval_low
+    if boundary_ambiguous:
+        # for `mask = (abs(dd) == period/2)`, the above line made
+        # `ddmod[mask] == -period/2`. correct these such that
+        # `ddmod[mask] == sign(dd[mask])*period/2`.
+        _nx.copyto(ddmod, interval_high,
+                   where=(ddmod == interval_low) & (dd > 0))
+    ph_correct = ddmod - dd
+    _nx.copyto(ph_correct, 0, where=abs(dd) < discont)
+    up = array(p, copy=True, dtype=dtype)
+    up[slice1] = p[slice1] + ph_correct.cumsum(axis)
+    return up
+
+
+def _sort_complex(a):
+    return (a,)
+
+
+@array_function_dispatch(_sort_complex)
+def sort_complex(a):
+    """
+    Sort a complex array using the real part first, then the imaginary part.
+
+    Parameters
+    ----------
+    a : array_like
+        Input array
+
+    Returns
+    -------
+    out : complex ndarray
+        Always returns a sorted complex array.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> np.sort_complex([5, 3, 6, 2, 1])
+    array([1.+0.j, 2.+0.j, 3.+0.j, 5.+0.j, 6.+0.j])
+
+    >>> np.sort_complex([1 + 2j, 2 - 1j, 3 - 2j, 3 - 3j, 3 + 5j])
+    array([1.+2.j,  2.-1.j,  3.-3.j,  3.-2.j,  3.+5.j])
+
+    """
+    b = array(a, copy=True)
+    b.sort()
+    if not issubclass(b.dtype.type, _nx.complexfloating):
+        if b.dtype.char in 'bhBH':
+            return b.astype('F')
+        elif b.dtype.char == 'g':
+            return b.astype('G')
+        else:
+            return b.astype('D')
+    else:
+        return b
+
+
+def _trim_zeros(filt, trim=None):
+    return (filt,)
+
+
+@array_function_dispatch(_trim_zeros)
+def trim_zeros(filt, trim='fb'):
+    """
+    Trim the leading and/or trailing zeros from a 1-D array or sequence.
+
+    Parameters
+    ----------
+    filt : 1-D array or sequence
+        Input array.
+    trim : str, optional
+        A string with 'f' representing trim from front and 'b' to trim from
+        back. Default is 'fb', trim zeros from both front and back of the
+        array.
+
+    Returns
+    -------
+    trimmed : 1-D array or sequence
+        The result of trimming the input. The input data type is preserved.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> a = np.array((0, 0, 0, 1, 2, 3, 0, 2, 1, 0))
+    >>> np.trim_zeros(a)
+    array([1, 2, 3, 0, 2, 1])
+
+    >>> np.trim_zeros(a, 'b')
+    array([0, 0, 0, ..., 0, 2, 1])
+
+    The input data type is preserved, list/tuple in means list/tuple out.
+
+    >>> np.trim_zeros([0, 1, 2, 0])
+    [1, 2]
+
+    """
+
+    first = 0
+    trim = trim.upper()
+    if 'F' in trim:
+        for i in filt:
+            if i != 0.:
+                break
+            else:
+                first = first + 1
+    last = len(filt)
+    if 'B' in trim:
+        for i in filt[::-1]:
+            if i != 0.:
+                break
+            else:
+                last = last - 1
+    return filt[first:last]
+
+
+def _extract_dispatcher(condition, arr):
+    return (condition, arr)
+
+
+@array_function_dispatch(_extract_dispatcher)
+def extract(condition, arr):
+    """
+    Return the elements of an array that satisfy some condition.
+
+    This is equivalent to ``np.compress(ravel(condition), ravel(arr))``.  If
+    `condition` is boolean ``np.extract`` is equivalent to ``arr[condition]``.
+
+    Note that `place` does the exact opposite of `extract`.
+
+    Parameters
+    ----------
+    condition : array_like
+        An array whose nonzero or True entries indicate the elements of `arr`
+        to extract.
+    arr : array_like
+        Input array of the same size as `condition`.
+
+    Returns
+    -------
+    extract : ndarray
+        Rank 1 array of values from `arr` where `condition` is True.
+
+    See Also
+    --------
+    take, put, copyto, compress, place
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> arr = np.arange(12).reshape((3, 4))
+    >>> arr
+    array([[ 0,  1,  2,  3],
+           [ 4,  5,  6,  7],
+           [ 8,  9, 10, 11]])
+    >>> condition = np.mod(arr, 3)==0
+    >>> condition
+    array([[ True, False, False,  True],
+           [False, False,  True, False],
+           [False,  True, False, False]])
+    >>> np.extract(condition, arr)
+    array([0, 3, 6, 9])
+
+
+    If `condition` is boolean:
+
+    >>> arr[condition]
+    array([0, 3, 6, 9])
+
+    """
+    return _nx.take(ravel(arr), nonzero(ravel(condition))[0])
+
+
+def _place_dispatcher(arr, mask, vals):
+    return (arr, mask, vals)
+
+
+@array_function_dispatch(_place_dispatcher)
+def place(arr, mask, vals):
+    """
+    Change elements of an array based on conditional and input values.
+
+    Similar to ``np.copyto(arr, vals, where=mask)``, the difference is that
+    `place` uses the first N elements of `vals`, where N is the number of
+    True values in `mask`, while `copyto` uses the elements where `mask`
+    is True.
+
+    Note that `extract` does the exact opposite of `place`.
+
+    Parameters
+    ----------
+    arr : ndarray
+        Array to put data into.
+    mask : array_like
+        Boolean mask array. Must have the same size as `a`.
+    vals : 1-D sequence
+        Values to put into `a`. Only the first N elements are used, where
+        N is the number of True values in `mask`. If `vals` is smaller
+        than N, it will be repeated, and if elements of `a` are to be masked,
+        this sequence must be non-empty.
+
+    See Also
+    --------
+    copyto, put, take, extract
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> arr = np.arange(6).reshape(2, 3)
+    >>> np.place(arr, arr>2, [44, 55])
+    >>> arr
+    array([[ 0,  1,  2],
+           [44, 55, 44]])
+
+    """
+    return _place(arr, mask, vals)
+
+
+def disp(mesg, device=None, linefeed=True):
+    """
+    Display a message on a device.
+
+    .. deprecated:: 2.0
+        Use your own printing function instead.
+
+    Parameters
+    ----------
+    mesg : str
+        Message to display.
+    device : object
+        Device to write message. If None, defaults to ``sys.stdout`` which is
+        very similar to ``print``. `device` needs to have ``write()`` and
+        ``flush()`` methods.
+    linefeed : bool, optional
+        Option whether to print a line feed or not. Defaults to True.
+
+    Raises
+    ------
+    AttributeError
+        If `device` does not have a ``write()`` or ``flush()`` method.
+
+    Examples
+    --------
+    >>> import numpy as np
+
+    Besides ``sys.stdout``, a file-like object can also be used as it has
+    both required methods:
+
+    >>> from io import StringIO
+    >>> buf = StringIO()
+    >>> np.disp('"Display" in a file', device=buf)
+    >>> buf.getvalue()
+    '"Display" in a file\\n'
+
+    """
+
+    # Deprecated in NumPy 2.0, 2023-07-11
+    warnings.warn(
+        "`disp` is deprecated, "
+        "use your own printing function instead. "
+        "(deprecated in NumPy 2.0)",
+        DeprecationWarning,
+        stacklevel=2
+    )    
+
+    if device is None:
+        device = sys.stdout
+    if linefeed:
+        device.write('%s\n' % mesg)
+    else:
+        device.write('%s' % mesg)
+    device.flush()
+    return
+
+
+# See https://docs.scipy.org/doc/numpy/reference/c-api.generalized-ufuncs.html
+_DIMENSION_NAME = r'\w+'
+_CORE_DIMENSION_LIST = '(?:{0:}(?:,{0:})*)?'.format(_DIMENSION_NAME)
+_ARGUMENT = r'\({}\)'.format(_CORE_DIMENSION_LIST)
+_ARGUMENT_LIST = '{0:}(?:,{0:})*'.format(_ARGUMENT)
+_SIGNATURE = '^{0:}->{0:}$'.format(_ARGUMENT_LIST)
+
+
+def _parse_gufunc_signature(signature):
+    """
+    Parse string signatures for a generalized universal function.
+
+    Arguments
+    ---------
+    signature : string
+        Generalized universal function signature, e.g., ``(m,n),(n,p)->(m,p)``
+        for ``np.matmul``.
+
+    Returns
+    -------
+    Tuple of input and output core dimensions parsed from the signature, each
+    of the form List[Tuple[str, ...]].
+    """
+    signature = re.sub(r'\s+', '', signature)
+
+    if not re.match(_SIGNATURE, signature):
+        raise ValueError(
+            'not a valid gufunc signature: {}'.format(signature))
+    return tuple([tuple(re.findall(_DIMENSION_NAME, arg))
+                  for arg in re.findall(_ARGUMENT, arg_list)]
+                 for arg_list in signature.split('->'))
+
+
+def _update_dim_sizes(dim_sizes, arg, core_dims):
+    """
+    Incrementally check and update core dimension sizes for a single argument.
+
+    Arguments
+    ---------
+    dim_sizes : Dict[str, int]
+        Sizes of existing core dimensions. Will be updated in-place.
+    arg : ndarray
+        Argument to examine.
+    core_dims : Tuple[str, ...]
+        Core dimensions for this argument.
+    """
+    if not core_dims:
+        return
+
+    num_core_dims = len(core_dims)
+    if arg.ndim < num_core_dims:
+        raise ValueError(
+            '%d-dimensional argument does not have enough '
+            'dimensions for all core dimensions %r'
+            % (arg.ndim, core_dims))
+
+    core_shape = arg.shape[-num_core_dims:]
+    for dim, size in zip(core_dims, core_shape):
+        if dim in dim_sizes:
+            if size != dim_sizes[dim]:
+                raise ValueError(
+                    'inconsistent size for core dimension %r: %r vs %r'
+                    % (dim, size, dim_sizes[dim]))
+        else:
+            dim_sizes[dim] = size
+
+
+def _parse_input_dimensions(args, input_core_dims):
+    """
+    Parse broadcast and core dimensions for vectorize with a signature.
+
+    Arguments
+    ---------
+    args : Tuple[ndarray, ...]
+        Tuple of input arguments to examine.
+    input_core_dims : List[Tuple[str, ...]]
+        List of core dimensions corresponding to each input.
+
+    Returns
+    -------
+    broadcast_shape : Tuple[int, ...]
+        Common shape to broadcast all non-core dimensions to.
+    dim_sizes : Dict[str, int]
+        Common sizes for named core dimensions.
+    """
+    broadcast_args = []
+    dim_sizes = {}
+    for arg, core_dims in zip(args, input_core_dims):
+        _update_dim_sizes(dim_sizes, arg, core_dims)
+        ndim = arg.ndim - len(core_dims)
+        dummy_array = np.lib.stride_tricks.as_strided(0, arg.shape[:ndim])
+        broadcast_args.append(dummy_array)
+    broadcast_shape = np.lib._stride_tricks_impl._broadcast_shape(
+        *broadcast_args
+    )
+    return broadcast_shape, dim_sizes
+
+
+def _calculate_shapes(broadcast_shape, dim_sizes, list_of_core_dims):
+    """Helper for calculating broadcast shapes with core dimensions."""
+    return [broadcast_shape + tuple(dim_sizes[dim] for dim in core_dims)
+            for core_dims in list_of_core_dims]
+
+
+def _create_arrays(broadcast_shape, dim_sizes, list_of_core_dims, dtypes,
+                   results=None):
+    """Helper for creating output arrays in vectorize."""
+    shapes = _calculate_shapes(broadcast_shape, dim_sizes, list_of_core_dims)
+    if dtypes is None:
+        dtypes = [None] * len(shapes)
+    if results is None:
+        arrays = tuple(np.empty(shape=shape, dtype=dtype)
+                       for shape, dtype in zip(shapes, dtypes))
+    else:
+        arrays = tuple(np.empty_like(result, shape=shape, dtype=dtype)
+                       for result, shape, dtype
+                       in zip(results, shapes, dtypes))
+    return arrays
+
+
+def _get_vectorize_dtype(dtype):
+    if dtype.char in "SU":
+        return dtype.char
+    return dtype
+
+
+@set_module('numpy')
+class vectorize:
+    """
+    vectorize(pyfunc=np._NoValue, otypes=None, doc=None, excluded=None,
+    cache=False, signature=None)
+
+    Returns an object that acts like pyfunc, but takes arrays as input.
+
+    Define a vectorized function which takes a nested sequence of objects or
+    numpy arrays as inputs and returns a single numpy array or a tuple of numpy
+    arrays. The vectorized function evaluates `pyfunc` over successive tuples
+    of the input arrays like the python map function, except it uses the
+    broadcasting rules of numpy.
+
+    The data type of the output of `vectorized` is determined by calling
+    the function with the first element of the input.  This can be avoided
+    by specifying the `otypes` argument.
+
+    Parameters
+    ----------
+    pyfunc : callable, optional
+        A python function or method.
+        Can be omitted to produce a decorator with keyword arguments.
+    otypes : str or list of dtypes, optional
+        The output data type. It must be specified as either a string of
+        typecode characters or a list of data type specifiers. There should
+        be one data type specifier for each output.
+    doc : str, optional
+        The docstring for the function. If None, the docstring will be the
+        ``pyfunc.__doc__``.
+    excluded : set, optional
+        Set of strings or integers representing the positional or keyword
+        arguments for which the function will not be vectorized.  These will be
+        passed directly to `pyfunc` unmodified.
+
+        .. versionadded:: 1.7.0
+
+    cache : bool, optional
+        If `True`, then cache the first function call that determines the number
+        of outputs if `otypes` is not provided.
+
+        .. versionadded:: 1.7.0
+
+    signature : string, optional
+        Generalized universal function signature, e.g., ``(m,n),(n)->(m)`` for
+        vectorized matrix-vector multiplication. If provided, ``pyfunc`` will
+        be called with (and expected to return) arrays with shapes given by the
+        size of corresponding core dimensions. By default, ``pyfunc`` is
+        assumed to take scalars as input and output.
+
+        .. versionadded:: 1.12.0
+
+    Returns
+    -------
+    out : callable
+        A vectorized function if ``pyfunc`` was provided,
+        a decorator otherwise.
+
+    See Also
+    --------
+    frompyfunc : Takes an arbitrary Python function and returns a ufunc
+
+    Notes
+    -----
+    The `vectorize` function is provided primarily for convenience, not for
+    performance. The implementation is essentially a for loop.
+
+    If `otypes` is not specified, then a call to the function with the
+    first argument will be used to determine the number of outputs.  The
+    results of this call will be cached if `cache` is `True` to prevent
+    calling the function twice.  However, to implement the cache, the
+    original function must be wrapped which will slow down subsequent
+    calls, so only do this if your function is expensive.
+
+    The new keyword argument interface and `excluded` argument support
+    further degrades performance.
+
+    References
+    ----------
+    .. [1] :doc:`/reference/c-api/generalized-ufuncs`
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> def myfunc(a, b):
+    ...     "Return a-b if a>b, otherwise return a+b"
+    ...     if a > b:
+    ...         return a - b
+    ...     else:
+    ...         return a + b
+
+    >>> vfunc = np.vectorize(myfunc)
+    >>> vfunc([1, 2, 3, 4], 2)
+    array([3, 4, 1, 2])
+
+    The docstring is taken from the input function to `vectorize` unless it
+    is specified:
+
+    >>> vfunc.__doc__
+    'Return a-b if a>b, otherwise return a+b'
+    >>> vfunc = np.vectorize(myfunc, doc='Vectorized `myfunc`')
+    >>> vfunc.__doc__
+    'Vectorized `myfunc`'
+
+    The output type is determined by evaluating the first element of the input,
+    unless it is specified:
+
+    >>> out = vfunc([1, 2, 3, 4], 2)
+    >>> type(out[0])
+    
+    >>> vfunc = np.vectorize(myfunc, otypes=[float])
+    >>> out = vfunc([1, 2, 3, 4], 2)
+    >>> type(out[0])
+    
+
+    The `excluded` argument can be used to prevent vectorizing over certain
+    arguments.  This can be useful for array-like arguments of a fixed length
+    such as the coefficients for a polynomial as in `polyval`:
+
+    >>> def mypolyval(p, x):
+    ...     _p = list(p)
+    ...     res = _p.pop(0)
+    ...     while _p:
+    ...         res = res*x + _p.pop(0)
+    ...     return res
+    >>> vpolyval = np.vectorize(mypolyval, excluded=['p'])
+    >>> vpolyval(p=[1, 2, 3], x=[0, 1])
+    array([3, 6])
+
+    Positional arguments may also be excluded by specifying their position:
+
+    >>> vpolyval.excluded.add(0)
+    >>> vpolyval([1, 2, 3], x=[0, 1])
+    array([3, 6])
+
+    The `signature` argument allows for vectorizing functions that act on
+    non-scalar arrays of fixed length. For example, you can use it for a
+    vectorized calculation of Pearson correlation coefficient and its p-value:
+
+    >>> import scipy.stats
+    >>> pearsonr = np.vectorize(scipy.stats.pearsonr,
+    ...                 signature='(n),(n)->(),()')
+    >>> pearsonr([[0, 1, 2, 3]], [[1, 2, 3, 4], [4, 3, 2, 1]])
+    (array([ 1., -1.]), array([ 0.,  0.]))
+
+    Or for a vectorized convolution:
+
+    >>> convolve = np.vectorize(np.convolve, signature='(n),(m)->(k)')
+    >>> convolve(np.eye(4), [1, 2, 1])
+    array([[1., 2., 1., 0., 0., 0.],
+           [0., 1., 2., 1., 0., 0.],
+           [0., 0., 1., 2., 1., 0.],
+           [0., 0., 0., 1., 2., 1.]])
+
+    Decorator syntax is supported.  The decorator can be called as
+    a function to provide keyword arguments:
+
+    >>> @np.vectorize
+    ... def identity(x):
+    ...     return x
+    ...
+    >>> identity([0, 1, 2])
+    array([0, 1, 2])
+    >>> @np.vectorize(otypes=[float])
+    ... def as_float(x):
+    ...     return x
+    ...
+    >>> as_float([0, 1, 2])
+    array([0., 1., 2.])
+    """
+    def __init__(self, pyfunc=np._NoValue, otypes=None, doc=None,
+                 excluded=None, cache=False, signature=None):
+
+        if (pyfunc != np._NoValue) and (not callable(pyfunc)):
+            #Splitting the error message to keep
+            #the length below 79 characters.
+            part1 = "When used as a decorator, "
+            part2 = "only accepts keyword arguments."
+            raise TypeError(part1 + part2)
+
+        self.pyfunc = pyfunc
+        self.cache = cache
+        self.signature = signature
+        if pyfunc != np._NoValue and hasattr(pyfunc, '__name__'):
+            self.__name__ = pyfunc.__name__
+
+        self._ufunc = {}    # Caching to improve default performance
+        self._doc = None
+        self.__doc__ = doc
+        if doc is None and hasattr(pyfunc, '__doc__'):
+            self.__doc__ = pyfunc.__doc__
+        else:
+            self._doc = doc
+
+        if isinstance(otypes, str):
+            for char in otypes:
+                if char not in typecodes['All']:
+                    raise ValueError("Invalid otype specified: %s" % (char,))
+        elif iterable(otypes):
+            otypes = [_get_vectorize_dtype(_nx.dtype(x)) for x in otypes]
+        elif otypes is not None:
+            raise ValueError("Invalid otype specification")
+        self.otypes = otypes
+
+        # Excluded variable support
+        if excluded is None:
+            excluded = set()
+        self.excluded = set(excluded)
+
+        if signature is not None:
+            self._in_and_out_core_dims = _parse_gufunc_signature(signature)
+        else:
+            self._in_and_out_core_dims = None
+
+    def _init_stage_2(self, pyfunc, *args, **kwargs):
+        self.__name__ = pyfunc.__name__
+        self.pyfunc = pyfunc
+        if self._doc is None:
+            self.__doc__ = pyfunc.__doc__
+        else:
+            self.__doc__ = self._doc
+
+    def _call_as_normal(self, *args, **kwargs):
+        """
+        Return arrays with the results of `pyfunc` broadcast (vectorized) over
+        `args` and `kwargs` not in `excluded`.
+        """
+        excluded = self.excluded
+        if not kwargs and not excluded:
+            func = self.pyfunc
+            vargs = args
+        else:
+            # The wrapper accepts only positional arguments: we use `names` and
+            # `inds` to mutate `the_args` and `kwargs` to pass to the original
+            # function.
+            nargs = len(args)
+
+            names = [_n for _n in kwargs if _n not in excluded]
+            inds = [_i for _i in range(nargs) if _i not in excluded]
+            the_args = list(args)
+
+            def func(*vargs):
+                for _n, _i in enumerate(inds):
+                    the_args[_i] = vargs[_n]
+                kwargs.update(zip(names, vargs[len(inds):]))
+                return self.pyfunc(*the_args, **kwargs)
+
+            vargs = [args[_i] for _i in inds]
+            vargs.extend([kwargs[_n] for _n in names])
+
+        return self._vectorize_call(func=func, args=vargs)
+
+    def __call__(self, *args, **kwargs):
+        if self.pyfunc is np._NoValue:
+            self._init_stage_2(*args, **kwargs)
+            return self
+
+        return self._call_as_normal(*args, **kwargs)
+
+    def _get_ufunc_and_otypes(self, func, args):
+        """Return (ufunc, otypes)."""
+        # frompyfunc will fail if args is empty
+        if not args:
+            raise ValueError('args can not be empty')
+
+        if self.otypes is not None:
+            otypes = self.otypes
+
+            # self._ufunc is a dictionary whose keys are the number of
+            # arguments (i.e. len(args)) and whose values are ufuncs created
+            # by frompyfunc. len(args) can be different for different calls if
+            # self.pyfunc has parameters with default values.  We only use the
+            # cache when func is self.pyfunc, which occurs when the call uses
+            # only positional arguments and no arguments are excluded.
+
+            nin = len(args)
+            nout = len(self.otypes)
+            if func is not self.pyfunc or nin not in self._ufunc:
+                ufunc = frompyfunc(func, nin, nout)
+            else:
+                ufunc = None  # We'll get it from self._ufunc
+            if func is self.pyfunc:
+                ufunc = self._ufunc.setdefault(nin, ufunc)
+        else:
+            # Get number of outputs and output types by calling the function on
+            # the first entries of args.  We also cache the result to prevent
+            # the subsequent call when the ufunc is evaluated.
+            # Assumes that ufunc first evaluates the 0th elements in the input
+            # arrays (the input values are not checked to ensure this)
+            args = [asarray(arg) for arg in args]
+            if builtins.any(arg.size == 0 for arg in args):
+                raise ValueError('cannot call `vectorize` on size 0 inputs '
+                                 'unless `otypes` is set')
+
+            inputs = [arg.flat[0] for arg in args]
+            outputs = func(*inputs)
+
+            # Performance note: profiling indicates that -- for simple
+            # functions at least -- this wrapping can almost double the
+            # execution time.
+            # Hence we make it optional.
+            if self.cache:
+                _cache = [outputs]
+
+                def _func(*vargs):
+                    if _cache:
+                        return _cache.pop()
+                    else:
+                        return func(*vargs)
+            else:
+                _func = func
+
+            if isinstance(outputs, tuple):
+                nout = len(outputs)
+            else:
+                nout = 1
+                outputs = (outputs,)
+
+            otypes = ''.join([asarray(outputs[_k]).dtype.char
+                              for _k in range(nout)])
+
+            # Performance note: profiling indicates that creating the ufunc is
+            # not a significant cost compared with wrapping so it seems not
+            # worth trying to cache this.
+            ufunc = frompyfunc(_func, len(args), nout)
+
+        return ufunc, otypes
+
+    def _vectorize_call(self, func, args):
+        """Vectorized call to `func` over positional `args`."""
+        if self.signature is not None:
+            res = self._vectorize_call_with_signature(func, args)
+        elif not args:
+            res = func()
+        else:
+            ufunc, otypes = self._get_ufunc_and_otypes(func=func, args=args)
+
+            # Convert args to object arrays first
+            inputs = [asanyarray(a, dtype=object) for a in args]
+
+            outputs = ufunc(*inputs)
+
+            if ufunc.nout == 1:
+                res = asanyarray(outputs, dtype=otypes[0])
+            else:
+                res = tuple([asanyarray(x, dtype=t)
+                             for x, t in zip(outputs, otypes)])
+        return res
+
+    def _vectorize_call_with_signature(self, func, args):
+        """Vectorized call over positional arguments with a signature."""
+        input_core_dims, output_core_dims = self._in_and_out_core_dims
+
+        if len(args) != len(input_core_dims):
+            raise TypeError('wrong number of positional arguments: '
+                            'expected %r, got %r'
+                            % (len(input_core_dims), len(args)))
+        args = tuple(asanyarray(arg) for arg in args)
+
+        broadcast_shape, dim_sizes = _parse_input_dimensions(
+            args, input_core_dims)
+        input_shapes = _calculate_shapes(broadcast_shape, dim_sizes,
+                                         input_core_dims)
+        args = [np.broadcast_to(arg, shape, subok=True)
+                for arg, shape in zip(args, input_shapes)]
+
+        outputs = None
+        otypes = self.otypes
+        nout = len(output_core_dims)
+
+        for index in np.ndindex(*broadcast_shape):
+            results = func(*(arg[index] for arg in args))
+
+            n_results = len(results) if isinstance(results, tuple) else 1
+
+            if nout != n_results:
+                raise ValueError(
+                    'wrong number of outputs from pyfunc: expected %r, got %r'
+                    % (nout, n_results))
+
+            if nout == 1:
+                results = (results,)
+
+            if outputs is None:
+                for result, core_dims in zip(results, output_core_dims):
+                    _update_dim_sizes(dim_sizes, result, core_dims)
+
+                outputs = _create_arrays(broadcast_shape, dim_sizes,
+                                         output_core_dims, otypes, results)
+
+            for output, result in zip(outputs, results):
+                output[index] = result
+
+        if outputs is None:
+            # did not call the function even once
+            if otypes is None:
+                raise ValueError('cannot call `vectorize` on size 0 inputs '
+                                 'unless `otypes` is set')
+            if builtins.any(dim not in dim_sizes
+                            for dims in output_core_dims
+                            for dim in dims):
+                raise ValueError('cannot call `vectorize` with a signature '
+                                 'including new output dimensions on size 0 '
+                                 'inputs')
+            outputs = _create_arrays(broadcast_shape, dim_sizes,
+                                     output_core_dims, otypes)
+
+        return outputs[0] if nout == 1 else outputs
+
+
+def _cov_dispatcher(m, y=None, rowvar=None, bias=None, ddof=None,
+                    fweights=None, aweights=None, *, dtype=None):
+    return (m, y, fweights, aweights)
+
+
+@array_function_dispatch(_cov_dispatcher)
+def cov(m, y=None, rowvar=True, bias=False, ddof=None, fweights=None,
+        aweights=None, *, dtype=None):
+    """
+    Estimate a covariance matrix, given data and weights.
+
+    Covariance indicates the level to which two variables vary together.
+    If we examine N-dimensional samples, :math:`X = [x_1, x_2, ... x_N]^T`,
+    then the covariance matrix element :math:`C_{ij}` is the covariance of
+    :math:`x_i` and :math:`x_j`. The element :math:`C_{ii}` is the variance
+    of :math:`x_i`.
+
+    See the notes for an outline of the algorithm.
+
+    Parameters
+    ----------
+    m : array_like
+        A 1-D or 2-D array containing multiple variables and observations.
+        Each row of `m` represents a variable, and each column a single
+        observation of all those variables. Also see `rowvar` below.
+    y : array_like, optional
+        An additional set of variables and observations. `y` has the same form
+        as that of `m`.
+    rowvar : bool, optional
+        If `rowvar` is True (default), then each row represents a
+        variable, with observations in the columns. Otherwise, the relationship
+        is transposed: each column represents a variable, while the rows
+        contain observations.
+    bias : bool, optional
+        Default normalization (False) is by ``(N - 1)``, where ``N`` is the
+        number of observations given (unbiased estimate). If `bias` is True,
+        then normalization is by ``N``. These values can be overridden by using
+        the keyword ``ddof`` in numpy versions >= 1.5.
+    ddof : int, optional
+        If not ``None`` the default value implied by `bias` is overridden.
+        Note that ``ddof=1`` will return the unbiased estimate, even if both
+        `fweights` and `aweights` are specified, and ``ddof=0`` will return
+        the simple average. See the notes for the details. The default value
+        is ``None``.
+
+        .. versionadded:: 1.5
+    fweights : array_like, int, optional
+        1-D array of integer frequency weights; the number of times each
+        observation vector should be repeated.
+
+        .. versionadded:: 1.10
+    aweights : array_like, optional
+        1-D array of observation vector weights. These relative weights are
+        typically large for observations considered "important" and smaller for
+        observations considered less "important". If ``ddof=0`` the array of
+        weights can be used to assign probabilities to observation vectors.
+
+        .. versionadded:: 1.10
+    dtype : data-type, optional
+        Data-type of the result. By default, the return data-type will have
+        at least `numpy.float64` precision.
+
+        .. versionadded:: 1.20
+
+    Returns
+    -------
+    out : ndarray
+        The covariance matrix of the variables.
+
+    See Also
+    --------
+    corrcoef : Normalized covariance matrix
+
+    Notes
+    -----
+    Assume that the observations are in the columns of the observation
+    array `m` and let ``f = fweights`` and ``a = aweights`` for brevity. The
+    steps to compute the weighted covariance are as follows::
+
+        >>> m = np.arange(10, dtype=np.float64)
+        >>> f = np.arange(10) * 2
+        >>> a = np.arange(10) ** 2.
+        >>> ddof = 1
+        >>> w = f * a
+        >>> v1 = np.sum(w)
+        >>> v2 = np.sum(w * a)
+        >>> m -= np.sum(m * w, axis=None, keepdims=True) / v1
+        >>> cov = np.dot(m * w, m.T) * v1 / (v1**2 - ddof * v2)
+
+    Note that when ``a == 1``, the normalization factor
+    ``v1 / (v1**2 - ddof * v2)`` goes over to ``1 / (np.sum(f) - ddof)``
+    as it should.
+
+    Examples
+    --------
+    >>> import numpy as np
+
+    Consider two variables, :math:`x_0` and :math:`x_1`, which
+    correlate perfectly, but in opposite directions:
+
+    >>> x = np.array([[0, 2], [1, 1], [2, 0]]).T
+    >>> x
+    array([[0, 1, 2],
+           [2, 1, 0]])
+
+    Note how :math:`x_0` increases while :math:`x_1` decreases. The covariance
+    matrix shows this clearly:
+
+    >>> np.cov(x)
+    array([[ 1., -1.],
+           [-1.,  1.]])
+
+    Note that element :math:`C_{0,1}`, which shows the correlation between
+    :math:`x_0` and :math:`x_1`, is negative.
+
+    Further, note how `x` and `y` are combined:
+
+    >>> x = [-2.1, -1,  4.3]
+    >>> y = [3,  1.1,  0.12]
+    >>> X = np.stack((x, y), axis=0)
+    >>> np.cov(X)
+    array([[11.71      , -4.286     ], # may vary
+           [-4.286     ,  2.144133]])
+    >>> np.cov(x, y)
+    array([[11.71      , -4.286     ], # may vary
+           [-4.286     ,  2.144133]])
+    >>> np.cov(x)
+    array(11.71)
+
+    """
+    # Check inputs
+    if ddof is not None and ddof != int(ddof):
+        raise ValueError(
+            "ddof must be integer")
+
+    # Handles complex arrays too
+    m = np.asarray(m)
+    if m.ndim > 2:
+        raise ValueError("m has more than 2 dimensions")
+
+    if y is not None:
+        y = np.asarray(y)
+        if y.ndim > 2:
+            raise ValueError("y has more than 2 dimensions")
+
+    if dtype is None:
+        if y is None:
+            dtype = np.result_type(m, np.float64)
+        else:
+            dtype = np.result_type(m, y, np.float64)
+
+    X = array(m, ndmin=2, dtype=dtype)
+    if not rowvar and X.shape[0] != 1:
+        X = X.T
+    if X.shape[0] == 0:
+        return np.array([]).reshape(0, 0)
+    if y is not None:
+        y = array(y, copy=None, ndmin=2, dtype=dtype)
+        if not rowvar and y.shape[0] != 1:
+            y = y.T
+        X = np.concatenate((X, y), axis=0)
+
+    if ddof is None:
+        if bias == 0:
+            ddof = 1
+        else:
+            ddof = 0
+
+    # Get the product of frequencies and weights
+    w = None
+    if fweights is not None:
+        fweights = np.asarray(fweights, dtype=float)
+        if not np.all(fweights == np.around(fweights)):
+            raise TypeError(
+                "fweights must be integer")
+        if fweights.ndim > 1:
+            raise RuntimeError(
+                "cannot handle multidimensional fweights")
+        if fweights.shape[0] != X.shape[1]:
+            raise RuntimeError(
+                "incompatible numbers of samples and fweights")
+        if any(fweights < 0):
+            raise ValueError(
+                "fweights cannot be negative")
+        w = fweights
+    if aweights is not None:
+        aweights = np.asarray(aweights, dtype=float)
+        if aweights.ndim > 1:
+            raise RuntimeError(
+                "cannot handle multidimensional aweights")
+        if aweights.shape[0] != X.shape[1]:
+            raise RuntimeError(
+                "incompatible numbers of samples and aweights")
+        if any(aweights < 0):
+            raise ValueError(
+                "aweights cannot be negative")
+        if w is None:
+            w = aweights
+        else:
+            w *= aweights
+
+    avg, w_sum = average(X, axis=1, weights=w, returned=True)
+    w_sum = w_sum[0]
+
+    # Determine the normalization
+    if w is None:
+        fact = X.shape[1] - ddof
+    elif ddof == 0:
+        fact = w_sum
+    elif aweights is None:
+        fact = w_sum - ddof
+    else:
+        fact = w_sum - ddof*sum(w*aweights)/w_sum
+
+    if fact <= 0:
+        warnings.warn("Degrees of freedom <= 0 for slice",
+                      RuntimeWarning, stacklevel=2)
+        fact = 0.0
+
+    X -= avg[:, None]
+    if w is None:
+        X_T = X.T
+    else:
+        X_T = (X*w).T
+    c = dot(X, X_T.conj())
+    c *= np.true_divide(1, fact)
+    return c.squeeze()
+
+
+def _corrcoef_dispatcher(x, y=None, rowvar=None, bias=None, ddof=None, *,
+                         dtype=None):
+    return (x, y)
+
+
+@array_function_dispatch(_corrcoef_dispatcher)
+def corrcoef(x, y=None, rowvar=True, bias=np._NoValue, ddof=np._NoValue, *,
+             dtype=None):
+    """
+    Return Pearson product-moment correlation coefficients.
+
+    Please refer to the documentation for `cov` for more detail.  The
+    relationship between the correlation coefficient matrix, `R`, and the
+    covariance matrix, `C`, is
+
+    .. math:: R_{ij} = \\frac{ C_{ij} } { \\sqrt{ C_{ii} C_{jj} } }
+
+    The values of `R` are between -1 and 1, inclusive.
+
+    Parameters
+    ----------
+    x : array_like
+        A 1-D or 2-D array containing multiple variables and observations.
+        Each row of `x` represents a variable, and each column a single
+        observation of all those variables. Also see `rowvar` below.
+    y : array_like, optional
+        An additional set of variables and observations. `y` has the same
+        shape as `x`.
+    rowvar : bool, optional
+        If `rowvar` is True (default), then each row represents a
+        variable, with observations in the columns. Otherwise, the relationship
+        is transposed: each column represents a variable, while the rows
+        contain observations.
+    bias : _NoValue, optional
+        Has no effect, do not use.
+
+        .. deprecated:: 1.10.0
+    ddof : _NoValue, optional
+        Has no effect, do not use.
+
+        .. deprecated:: 1.10.0
+    dtype : data-type, optional
+        Data-type of the result. By default, the return data-type will have
+        at least `numpy.float64` precision.
+
+        .. versionadded:: 1.20
+
+    Returns
+    -------
+    R : ndarray
+        The correlation coefficient matrix of the variables.
+
+    See Also
+    --------
+    cov : Covariance matrix
+
+    Notes
+    -----
+    Due to floating point rounding the resulting array may not be Hermitian,
+    the diagonal elements may not be 1, and the elements may not satisfy the
+    inequality abs(a) <= 1. The real and imaginary parts are clipped to the
+    interval [-1,  1] in an attempt to improve on that situation but is not
+    much help in the complex case.
+
+    This function accepts but discards arguments `bias` and `ddof`.  This is
+    for backwards compatibility with previous versions of this function.  These
+    arguments had no effect on the return values of the function and can be
+    safely ignored in this and previous versions of numpy.
+
+    Examples
+    --------
+    >>> import numpy as np
+
+    In this example we generate two random arrays, ``xarr`` and ``yarr``, and
+    compute the row-wise and column-wise Pearson correlation coefficients,
+    ``R``. Since ``rowvar`` is  true by  default, we first find the row-wise
+    Pearson correlation coefficients between the variables of ``xarr``.
+
+    >>> import numpy as np
+    >>> rng = np.random.default_rng(seed=42)
+    >>> xarr = rng.random((3, 3))
+    >>> xarr
+    array([[0.77395605, 0.43887844, 0.85859792],
+           [0.69736803, 0.09417735, 0.97562235],
+           [0.7611397 , 0.78606431, 0.12811363]])
+    >>> R1 = np.corrcoef(xarr)
+    >>> R1
+    array([[ 1.        ,  0.99256089, -0.68080986],
+           [ 0.99256089,  1.        , -0.76492172],
+           [-0.68080986, -0.76492172,  1.        ]])
+
+    If we add another set of variables and observations ``yarr``, we can
+    compute the row-wise Pearson correlation coefficients between the
+    variables in ``xarr`` and ``yarr``.
+
+    >>> yarr = rng.random((3, 3))
+    >>> yarr
+    array([[0.45038594, 0.37079802, 0.92676499],
+           [0.64386512, 0.82276161, 0.4434142 ],
+           [0.22723872, 0.55458479, 0.06381726]])
+    >>> R2 = np.corrcoef(xarr, yarr)
+    >>> R2
+    array([[ 1.        ,  0.99256089, -0.68080986,  0.75008178, -0.934284  ,
+            -0.99004057],
+           [ 0.99256089,  1.        , -0.76492172,  0.82502011, -0.97074098,
+            -0.99981569],
+           [-0.68080986, -0.76492172,  1.        , -0.99507202,  0.89721355,
+             0.77714685],
+           [ 0.75008178,  0.82502011, -0.99507202,  1.        , -0.93657855,
+            -0.83571711],
+           [-0.934284  , -0.97074098,  0.89721355, -0.93657855,  1.        ,
+             0.97517215],
+           [-0.99004057, -0.99981569,  0.77714685, -0.83571711,  0.97517215,
+             1.        ]])
+
+    Finally if we use the option ``rowvar=False``, the columns are now
+    being treated as the variables and we will find the column-wise Pearson
+    correlation coefficients between variables in ``xarr`` and ``yarr``.
+
+    >>> R3 = np.corrcoef(xarr, yarr, rowvar=False)
+    >>> R3
+    array([[ 1.        ,  0.77598074, -0.47458546, -0.75078643, -0.9665554 ,
+             0.22423734],
+           [ 0.77598074,  1.        , -0.92346708, -0.99923895, -0.58826587,
+            -0.44069024],
+           [-0.47458546, -0.92346708,  1.        ,  0.93773029,  0.23297648,
+             0.75137473],
+           [-0.75078643, -0.99923895,  0.93773029,  1.        ,  0.55627469,
+             0.47536961],
+           [-0.9665554 , -0.58826587,  0.23297648,  0.55627469,  1.        ,
+            -0.46666491],
+           [ 0.22423734, -0.44069024,  0.75137473,  0.47536961, -0.46666491,
+             1.        ]])
+
+    """
+    if bias is not np._NoValue or ddof is not np._NoValue:
+        # 2015-03-15, 1.10
+        warnings.warn('bias and ddof have no effect and are deprecated',
+                      DeprecationWarning, stacklevel=2)
+    c = cov(x, y, rowvar, dtype=dtype)
+    try:
+        d = diag(c)
+    except ValueError:
+        # scalar covariance
+        # nan if incorrect value (nan, inf, 0), 1 otherwise
+        return c / c
+    stddev = sqrt(d.real)
+    c /= stddev[:, None]
+    c /= stddev[None, :]
+
+    # Clip real and imaginary parts to [-1, 1].  This does not guarantee
+    # abs(a[i,j]) <= 1 for complex arrays, but is the best we can do without
+    # excessive work.
+    np.clip(c.real, -1, 1, out=c.real)
+    if np.iscomplexobj(c):
+        np.clip(c.imag, -1, 1, out=c.imag)
+
+    return c
+
+
+@set_module('numpy')
+def blackman(M):
+    """
+    Return the Blackman window.
+
+    The Blackman window is a taper formed by using the first three
+    terms of a summation of cosines. It was designed to have close to the
+    minimal leakage possible.  It is close to optimal, only slightly worse
+    than a Kaiser window.
+
+    Parameters
+    ----------
+    M : int
+        Number of points in the output window. If zero or less, an empty
+        array is returned.
+
+    Returns
+    -------
+    out : ndarray
+        The window, with the maximum value normalized to one (the value one
+        appears only if the number of samples is odd).
+
+    See Also
+    --------
+    bartlett, hamming, hanning, kaiser
+
+    Notes
+    -----
+    The Blackman window is defined as
+
+    .. math::  w(n) = 0.42 - 0.5 \\cos(2\\pi n/M) + 0.08 \\cos(4\\pi n/M)
+
+    Most references to the Blackman window come from the signal processing
+    literature, where it is used as one of many windowing functions for
+    smoothing values.  It is also known as an apodization (which means
+    "removing the foot", i.e. smoothing discontinuities at the beginning
+    and end of the sampled signal) or tapering function. It is known as a
+    "near optimal" tapering function, almost as good (by some measures)
+    as the kaiser window.
+
+    References
+    ----------
+    Blackman, R.B. and Tukey, J.W., (1958) The measurement of power spectra,
+    Dover Publications, New York.
+
+    Oppenheim, A.V., and R.W. Schafer. Discrete-Time Signal Processing.
+    Upper Saddle River, NJ: Prentice-Hall, 1999, pp. 468-471.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> import matplotlib.pyplot as plt
+    >>> np.blackman(12)
+    array([-1.38777878e-17,   3.26064346e-02,   1.59903635e-01, # may vary
+            4.14397981e-01,   7.36045180e-01,   9.67046769e-01,
+            9.67046769e-01,   7.36045180e-01,   4.14397981e-01,
+            1.59903635e-01,   3.26064346e-02,  -1.38777878e-17])
+
+    Plot the window and the frequency response.
+
+    .. plot::
+        :include-source:
+
+        import matplotlib.pyplot as plt
+        from numpy.fft import fft, fftshift
+        window = np.blackman(51)
+        plt.plot(window)
+        plt.title("Blackman window")
+        plt.ylabel("Amplitude")
+        plt.xlabel("Sample")
+        plt.show()  # doctest: +SKIP
+
+        plt.figure()
+        A = fft(window, 2048) / 25.5
+        mag = np.abs(fftshift(A))
+        freq = np.linspace(-0.5, 0.5, len(A))
+        with np.errstate(divide='ignore', invalid='ignore'):
+            response = 20 * np.log10(mag)
+        response = np.clip(response, -100, 100)
+        plt.plot(freq, response)
+        plt.title("Frequency response of Blackman window")
+        plt.ylabel("Magnitude [dB]")
+        plt.xlabel("Normalized frequency [cycles per sample]")
+        plt.axis('tight')
+        plt.show()
+
+    """
+    # Ensures at least float64 via 0.0.  M should be an integer, but conversion
+    # to double is safe for a range.
+    values = np.array([0.0, M])
+    M = values[1]
+
+    if M < 1:
+        return array([], dtype=values.dtype)
+    if M == 1:
+        return ones(1, dtype=values.dtype)
+    n = arange(1-M, M, 2)
+    return 0.42 + 0.5*cos(pi*n/(M-1)) + 0.08*cos(2.0*pi*n/(M-1))
+
+
+@set_module('numpy')
+def bartlett(M):
+    """
+    Return the Bartlett window.
+
+    The Bartlett window is very similar to a triangular window, except
+    that the end points are at zero.  It is often used in signal
+    processing for tapering a signal, without generating too much
+    ripple in the frequency domain.
+
+    Parameters
+    ----------
+    M : int
+        Number of points in the output window. If zero or less, an
+        empty array is returned.
+
+    Returns
+    -------
+    out : array
+        The triangular window, with the maximum value normalized to one
+        (the value one appears only if the number of samples is odd), with
+        the first and last samples equal to zero.
+
+    See Also
+    --------
+    blackman, hamming, hanning, kaiser
+
+    Notes
+    -----
+    The Bartlett window is defined as
+
+    .. math:: w(n) = \\frac{2}{M-1} \\left(
+              \\frac{M-1}{2} - \\left|n - \\frac{M-1}{2}\\right|
+              \\right)
+
+    Most references to the Bartlett window come from the signal processing
+    literature, where it is used as one of many windowing functions for
+    smoothing values.  Note that convolution with this window produces linear
+    interpolation.  It is also known as an apodization (which means "removing
+    the foot", i.e. smoothing discontinuities at the beginning and end of the
+    sampled signal) or tapering function. The Fourier transform of the
+    Bartlett window is the product of two sinc functions. Note the excellent
+    discussion in Kanasewich [2]_.
+
+    References
+    ----------
+    .. [1] M.S. Bartlett, "Periodogram Analysis and Continuous Spectra",
+           Biometrika 37, 1-16, 1950.
+    .. [2] E.R. Kanasewich, "Time Sequence Analysis in Geophysics",
+           The University of Alberta Press, 1975, pp. 109-110.
+    .. [3] A.V. Oppenheim and R.W. Schafer, "Discrete-Time Signal
+           Processing", Prentice-Hall, 1999, pp. 468-471.
+    .. [4] Wikipedia, "Window function",
+           https://en.wikipedia.org/wiki/Window_function
+    .. [5] W.H. Press,  B.P. Flannery, S.A. Teukolsky, and W.T. Vetterling,
+           "Numerical Recipes", Cambridge University Press, 1986, page 429.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> import matplotlib.pyplot as plt
+    >>> np.bartlett(12)
+    array([ 0.        ,  0.18181818,  0.36363636,  0.54545455,  0.72727273, # may vary
+            0.90909091,  0.90909091,  0.72727273,  0.54545455,  0.36363636,
+            0.18181818,  0.        ])
+
+    Plot the window and its frequency response (requires SciPy and matplotlib).
+
+    .. plot::
+        :include-source:
+
+        import matplotlib.pyplot as plt
+        from numpy.fft import fft, fftshift
+        window = np.bartlett(51)
+        plt.plot(window)
+        plt.title("Bartlett window")
+        plt.ylabel("Amplitude")
+        plt.xlabel("Sample")
+        plt.show()
+        plt.figure()
+        A = fft(window, 2048) / 25.5
+        mag = np.abs(fftshift(A))
+        freq = np.linspace(-0.5, 0.5, len(A))
+        with np.errstate(divide='ignore', invalid='ignore'):
+            response = 20 * np.log10(mag)
+        response = np.clip(response, -100, 100)
+        plt.plot(freq, response)
+        plt.title("Frequency response of Bartlett window")
+        plt.ylabel("Magnitude [dB]")
+        plt.xlabel("Normalized frequency [cycles per sample]")
+        plt.axis('tight')
+        plt.show()
+
+    """
+    # Ensures at least float64 via 0.0.  M should be an integer, but conversion
+    # to double is safe for a range.
+    values = np.array([0.0, M])
+    M = values[1]
+
+    if M < 1:
+        return array([], dtype=values.dtype)
+    if M == 1:
+        return ones(1, dtype=values.dtype)
+    n = arange(1-M, M, 2)
+    return where(less_equal(n, 0), 1 + n/(M-1), 1 - n/(M-1))
+
+
+@set_module('numpy')
+def hanning(M):
+    """
+    Return the Hanning window.
+
+    The Hanning window is a taper formed by using a weighted cosine.
+
+    Parameters
+    ----------
+    M : int
+        Number of points in the output window. If zero or less, an
+        empty array is returned.
+
+    Returns
+    -------
+    out : ndarray, shape(M,)
+        The window, with the maximum value normalized to one (the value
+        one appears only if `M` is odd).
+
+    See Also
+    --------
+    bartlett, blackman, hamming, kaiser
+
+    Notes
+    -----
+    The Hanning window is defined as
+
+    .. math::  w(n) = 0.5 - 0.5\\cos\\left(\\frac{2\\pi{n}}{M-1}\\right)
+               \\qquad 0 \\leq n \\leq M-1
+
+    The Hanning was named for Julius von Hann, an Austrian meteorologist.
+    It is also known as the Cosine Bell. Some authors prefer that it be
+    called a Hann window, to help avoid confusion with the very similar
+    Hamming window.
+
+    Most references to the Hanning window come from the signal processing
+    literature, where it is used as one of many windowing functions for
+    smoothing values.  It is also known as an apodization (which means
+    "removing the foot", i.e. smoothing discontinuities at the beginning
+    and end of the sampled signal) or tapering function.
+
+    References
+    ----------
+    .. [1] Blackman, R.B. and Tukey, J.W., (1958) The measurement of power
+           spectra, Dover Publications, New York.
+    .. [2] E.R. Kanasewich, "Time Sequence Analysis in Geophysics",
+           The University of Alberta Press, 1975, pp. 106-108.
+    .. [3] Wikipedia, "Window function",
+           https://en.wikipedia.org/wiki/Window_function
+    .. [4] W.H. Press,  B.P. Flannery, S.A. Teukolsky, and W.T. Vetterling,
+           "Numerical Recipes", Cambridge University Press, 1986, page 425.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> np.hanning(12)
+    array([0.        , 0.07937323, 0.29229249, 0.57115742, 0.82743037,
+           0.97974649, 0.97974649, 0.82743037, 0.57115742, 0.29229249,
+           0.07937323, 0.        ])
+
+    Plot the window and its frequency response.
+
+    .. plot::
+        :include-source:
+
+        import matplotlib.pyplot as plt
+        from numpy.fft import fft, fftshift
+        window = np.hanning(51)
+        plt.plot(window)
+        plt.title("Hann window")
+        plt.ylabel("Amplitude")
+        plt.xlabel("Sample")
+        plt.show()
+
+        plt.figure()
+        A = fft(window, 2048) / 25.5
+        mag = np.abs(fftshift(A))
+        freq = np.linspace(-0.5, 0.5, len(A))
+        with np.errstate(divide='ignore', invalid='ignore'):
+            response = 20 * np.log10(mag)
+        response = np.clip(response, -100, 100)
+        plt.plot(freq, response)
+        plt.title("Frequency response of the Hann window")
+        plt.ylabel("Magnitude [dB]")
+        plt.xlabel("Normalized frequency [cycles per sample]")
+        plt.axis('tight')
+        plt.show()
+
+    """
+    # Ensures at least float64 via 0.0.  M should be an integer, but conversion
+    # to double is safe for a range.
+    values = np.array([0.0, M])
+    M = values[1]
+
+    if M < 1:
+        return array([], dtype=values.dtype)
+    if M == 1:
+        return ones(1, dtype=values.dtype)
+    n = arange(1-M, M, 2)
+    return 0.5 + 0.5*cos(pi*n/(M-1))
+
+
+@set_module('numpy')
+def hamming(M):
+    """
+    Return the Hamming window.
+
+    The Hamming window is a taper formed by using a weighted cosine.
+
+    Parameters
+    ----------
+    M : int
+        Number of points in the output window. If zero or less, an
+        empty array is returned.
+
+    Returns
+    -------
+    out : ndarray
+        The window, with the maximum value normalized to one (the value
+        one appears only if the number of samples is odd).
+
+    See Also
+    --------
+    bartlett, blackman, hanning, kaiser
+
+    Notes
+    -----
+    The Hamming window is defined as
+
+    .. math::  w(n) = 0.54 - 0.46\\cos\\left(\\frac{2\\pi{n}}{M-1}\\right)
+               \\qquad 0 \\leq n \\leq M-1
+
+    The Hamming was named for R. W. Hamming, an associate of J. W. Tukey
+    and is described in Blackman and Tukey. It was recommended for
+    smoothing the truncated autocovariance function in the time domain.
+    Most references to the Hamming window come from the signal processing
+    literature, where it is used as one of many windowing functions for
+    smoothing values.  It is also known as an apodization (which means
+    "removing the foot", i.e. smoothing discontinuities at the beginning
+    and end of the sampled signal) or tapering function.
+
+    References
+    ----------
+    .. [1] Blackman, R.B. and Tukey, J.W., (1958) The measurement of power
+           spectra, Dover Publications, New York.
+    .. [2] E.R. Kanasewich, "Time Sequence Analysis in Geophysics", The
+           University of Alberta Press, 1975, pp. 109-110.
+    .. [3] Wikipedia, "Window function",
+           https://en.wikipedia.org/wiki/Window_function
+    .. [4] W.H. Press,  B.P. Flannery, S.A. Teukolsky, and W.T. Vetterling,
+           "Numerical Recipes", Cambridge University Press, 1986, page 425.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> np.hamming(12)
+    array([ 0.08      ,  0.15302337,  0.34890909,  0.60546483,  0.84123594, # may vary
+            0.98136677,  0.98136677,  0.84123594,  0.60546483,  0.34890909,
+            0.15302337,  0.08      ])
+
+    Plot the window and the frequency response.
+
+    .. plot::
+        :include-source:
+
+        import matplotlib.pyplot as plt
+        from numpy.fft import fft, fftshift
+        window = np.hamming(51)
+        plt.plot(window)
+        plt.title("Hamming window")
+        plt.ylabel("Amplitude")
+        plt.xlabel("Sample")
+        plt.show()
+
+        plt.figure()
+        A = fft(window, 2048) / 25.5
+        mag = np.abs(fftshift(A))
+        freq = np.linspace(-0.5, 0.5, len(A))
+        response = 20 * np.log10(mag)
+        response = np.clip(response, -100, 100)
+        plt.plot(freq, response)
+        plt.title("Frequency response of Hamming window")
+        plt.ylabel("Magnitude [dB]")
+        plt.xlabel("Normalized frequency [cycles per sample]")
+        plt.axis('tight')
+        plt.show()
+
+    """
+    # Ensures at least float64 via 0.0.  M should be an integer, but conversion
+    # to double is safe for a range.
+    values = np.array([0.0, M])
+    M = values[1]
+
+    if M < 1:
+        return array([], dtype=values.dtype)
+    if M == 1:
+        return ones(1, dtype=values.dtype)
+    n = arange(1-M, M, 2)
+    return 0.54 + 0.46*cos(pi*n/(M-1))
+
+
+## Code from cephes for i0
+
+_i0A = [
+    -4.41534164647933937950E-18,
+    3.33079451882223809783E-17,
+    -2.43127984654795469359E-16,
+    1.71539128555513303061E-15,
+    -1.16853328779934516808E-14,
+    7.67618549860493561688E-14,
+    -4.85644678311192946090E-13,
+    2.95505266312963983461E-12,
+    -1.72682629144155570723E-11,
+    9.67580903537323691224E-11,
+    -5.18979560163526290666E-10,
+    2.65982372468238665035E-9,
+    -1.30002500998624804212E-8,
+    6.04699502254191894932E-8,
+    -2.67079385394061173391E-7,
+    1.11738753912010371815E-6,
+    -4.41673835845875056359E-6,
+    1.64484480707288970893E-5,
+    -5.75419501008210370398E-5,
+    1.88502885095841655729E-4,
+    -5.76375574538582365885E-4,
+    1.63947561694133579842E-3,
+    -4.32430999505057594430E-3,
+    1.05464603945949983183E-2,
+    -2.37374148058994688156E-2,
+    4.93052842396707084878E-2,
+    -9.49010970480476444210E-2,
+    1.71620901522208775349E-1,
+    -3.04682672343198398683E-1,
+    6.76795274409476084995E-1
+    ]
+
+_i0B = [
+    -7.23318048787475395456E-18,
+    -4.83050448594418207126E-18,
+    4.46562142029675999901E-17,
+    3.46122286769746109310E-17,
+    -2.82762398051658348494E-16,
+    -3.42548561967721913462E-16,
+    1.77256013305652638360E-15,
+    3.81168066935262242075E-15,
+    -9.55484669882830764870E-15,
+    -4.15056934728722208663E-14,
+    1.54008621752140982691E-14,
+    3.85277838274214270114E-13,
+    7.18012445138366623367E-13,
+    -1.79417853150680611778E-12,
+    -1.32158118404477131188E-11,
+    -3.14991652796324136454E-11,
+    1.18891471078464383424E-11,
+    4.94060238822496958910E-10,
+    3.39623202570838634515E-9,
+    2.26666899049817806459E-8,
+    2.04891858946906374183E-7,
+    2.89137052083475648297E-6,
+    6.88975834691682398426E-5,
+    3.36911647825569408990E-3,
+    8.04490411014108831608E-1
+    ]
+
+
+def _chbevl(x, vals):
+    b0 = vals[0]
+    b1 = 0.0
+
+    for i in range(1, len(vals)):
+        b2 = b1
+        b1 = b0
+        b0 = x*b1 - b2 + vals[i]
+
+    return 0.5*(b0 - b2)
+
+
+def _i0_1(x):
+    return exp(x) * _chbevl(x/2.0-2, _i0A)
+
+
+def _i0_2(x):
+    return exp(x) * _chbevl(32.0/x - 2.0, _i0B) / sqrt(x)
+
+
+def _i0_dispatcher(x):
+    return (x,)
+
+
+@array_function_dispatch(_i0_dispatcher)
+def i0(x):
+    """
+    Modified Bessel function of the first kind, order 0.
+
+    Usually denoted :math:`I_0`.
+
+    Parameters
+    ----------
+    x : array_like of float
+        Argument of the Bessel function.
+
+    Returns
+    -------
+    out : ndarray, shape = x.shape, dtype = float
+        The modified Bessel function evaluated at each of the elements of `x`.
+
+    See Also
+    --------
+    scipy.special.i0, scipy.special.iv, scipy.special.ive
+
+    Notes
+    -----
+    The scipy implementation is recommended over this function: it is a
+    proper ufunc written in C, and more than an order of magnitude faster.
+
+    We use the algorithm published by Clenshaw [1]_ and referenced by
+    Abramowitz and Stegun [2]_, for which the function domain is
+    partitioned into the two intervals [0,8] and (8,inf), and Chebyshev
+    polynomial expansions are employed in each interval. Relative error on
+    the domain [0,30] using IEEE arithmetic is documented [3]_ as having a
+    peak of 5.8e-16 with an rms of 1.4e-16 (n = 30000).
+
+    References
+    ----------
+    .. [1] C. W. Clenshaw, "Chebyshev series for mathematical functions", in
+           *National Physical Laboratory Mathematical Tables*, vol. 5, London:
+           Her Majesty's Stationery Office, 1962.
+    .. [2] M. Abramowitz and I. A. Stegun, *Handbook of Mathematical
+           Functions*, 10th printing, New York: Dover, 1964, pp. 379.
+           https://personal.math.ubc.ca/~cbm/aands/page_379.htm
+    .. [3] https://metacpan.org/pod/distribution/Math-Cephes/lib/Math/Cephes.pod#i0:-Modified-Bessel-function-of-order-zero
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> np.i0(0.)
+    array(1.0)
+    >>> np.i0([0, 1, 2, 3])
+    array([1.        , 1.26606588, 2.2795853 , 4.88079259])
+
+    """
+    x = np.asanyarray(x)
+    if x.dtype.kind == 'c':
+        raise TypeError("i0 not supported for complex values")
+    if x.dtype.kind != 'f':
+        x = x.astype(float)
+    x = np.abs(x)
+    return piecewise(x, [x <= 8.0], [_i0_1, _i0_2])
+
+## End of cephes code for i0
+
+
+@set_module('numpy')
+def kaiser(M, beta):
+    """
+    Return the Kaiser window.
+
+    The Kaiser window is a taper formed by using a Bessel function.
+
+    Parameters
+    ----------
+    M : int
+        Number of points in the output window. If zero or less, an
+        empty array is returned.
+    beta : float
+        Shape parameter for window.
+
+    Returns
+    -------
+    out : array
+        The window, with the maximum value normalized to one (the value
+        one appears only if the number of samples is odd).
+
+    See Also
+    --------
+    bartlett, blackman, hamming, hanning
+
+    Notes
+    -----
+    The Kaiser window is defined as
+
+    .. math::  w(n) = I_0\\left( \\beta \\sqrt{1-\\frac{4n^2}{(M-1)^2}}
+               \\right)/I_0(\\beta)
+
+    with
+
+    .. math:: \\quad -\\frac{M-1}{2} \\leq n \\leq \\frac{M-1}{2},
+
+    where :math:`I_0` is the modified zeroth-order Bessel function.
+
+    The Kaiser was named for Jim Kaiser, who discovered a simple
+    approximation to the DPSS window based on Bessel functions.  The Kaiser
+    window is a very good approximation to the Digital Prolate Spheroidal
+    Sequence, or Slepian window, which is the transform which maximizes the
+    energy in the main lobe of the window relative to total energy.
+
+    The Kaiser can approximate many other windows by varying the beta
+    parameter.
+
+    ====  =======================
+    beta  Window shape
+    ====  =======================
+    0     Rectangular
+    5     Similar to a Hamming
+    6     Similar to a Hanning
+    8.6   Similar to a Blackman
+    ====  =======================
+
+    A beta value of 14 is probably a good starting point. Note that as beta
+    gets large, the window narrows, and so the number of samples needs to be
+    large enough to sample the increasingly narrow spike, otherwise NaNs will
+    get returned.
+
+    Most references to the Kaiser window come from the signal processing
+    literature, where it is used as one of many windowing functions for
+    smoothing values.  It is also known as an apodization (which means
+    "removing the foot", i.e. smoothing discontinuities at the beginning
+    and end of the sampled signal) or tapering function.
+
+    References
+    ----------
+    .. [1] J. F. Kaiser, "Digital Filters" - Ch 7 in "Systems analysis by
+           digital computer", Editors: F.F. Kuo and J.F. Kaiser, p 218-285.
+           John Wiley and Sons, New York, (1966).
+    .. [2] E.R. Kanasewich, "Time Sequence Analysis in Geophysics", The
+           University of Alberta Press, 1975, pp. 177-178.
+    .. [3] Wikipedia, "Window function",
+           https://en.wikipedia.org/wiki/Window_function
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> import matplotlib.pyplot as plt
+    >>> np.kaiser(12, 14)
+     array([7.72686684e-06, 3.46009194e-03, 4.65200189e-02, # may vary
+            2.29737120e-01, 5.99885316e-01, 9.45674898e-01,
+            9.45674898e-01, 5.99885316e-01, 2.29737120e-01,
+            4.65200189e-02, 3.46009194e-03, 7.72686684e-06])
+
+
+    Plot the window and the frequency response.
+
+    .. plot::
+        :include-source:
+
+        import matplotlib.pyplot as plt
+        from numpy.fft import fft, fftshift
+        window = np.kaiser(51, 14)
+        plt.plot(window)
+        plt.title("Kaiser window")
+        plt.ylabel("Amplitude")
+        plt.xlabel("Sample")
+        plt.show()
+
+        plt.figure()
+        A = fft(window, 2048) / 25.5
+        mag = np.abs(fftshift(A))
+        freq = np.linspace(-0.5, 0.5, len(A))
+        response = 20 * np.log10(mag)
+        response = np.clip(response, -100, 100)
+        plt.plot(freq, response)
+        plt.title("Frequency response of Kaiser window")
+        plt.ylabel("Magnitude [dB]")
+        plt.xlabel("Normalized frequency [cycles per sample]")
+        plt.axis('tight')
+        plt.show()
+
+    """
+    # Ensures at least float64 via 0.0.  M should be an integer, but conversion
+    # to double is safe for a range.  (Simplified result_type with 0.0
+    # strongly typed.  result-type is not/less order sensitive, but that mainly
+    # matters for integers anyway.)
+    values = np.array([0.0, M, beta])
+    M = values[1]
+    beta = values[2]
+
+    if M == 1:
+        return np.ones(1, dtype=values.dtype)
+    n = arange(0, M)
+    alpha = (M-1)/2.0
+    return i0(beta * sqrt(1-((n-alpha)/alpha)**2.0))/i0(beta)
+
+
+def _sinc_dispatcher(x):
+    return (x,)
+
+
+@array_function_dispatch(_sinc_dispatcher)
+def sinc(x):
+    r"""
+    Return the normalized sinc function.
+
+    The sinc function is equal to :math:`\sin(\pi x)/(\pi x)` for any argument
+    :math:`x\ne 0`. ``sinc(0)`` takes the limit value 1, making ``sinc`` not
+    only everywhere continuous but also infinitely differentiable.
+
+    .. note::
+
+        Note the normalization factor of ``pi`` used in the definition.
+        This is the most commonly used definition in signal processing.
+        Use ``sinc(x / np.pi)`` to obtain the unnormalized sinc function
+        :math:`\sin(x)/x` that is more common in mathematics.
+
+    Parameters
+    ----------
+    x : ndarray
+        Array (possibly multi-dimensional) of values for which to calculate
+        ``sinc(x)``.
+
+    Returns
+    -------
+    out : ndarray
+        ``sinc(x)``, which has the same shape as the input.
+
+    Notes
+    -----
+    The name sinc is short for "sine cardinal" or "sinus cardinalis".
+
+    The sinc function is used in various signal processing applications,
+    including in anti-aliasing, in the construction of a Lanczos resampling
+    filter, and in interpolation.
+
+    For bandlimited interpolation of discrete-time signals, the ideal
+    interpolation kernel is proportional to the sinc function.
+
+    References
+    ----------
+    .. [1] Weisstein, Eric W. "Sinc Function." From MathWorld--A Wolfram Web
+           Resource. https://mathworld.wolfram.com/SincFunction.html
+    .. [2] Wikipedia, "Sinc function",
+           https://en.wikipedia.org/wiki/Sinc_function
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> import matplotlib.pyplot as plt
+    >>> x = np.linspace(-4, 4, 41)
+    >>> np.sinc(x)
+     array([-3.89804309e-17,  -4.92362781e-02,  -8.40918587e-02, # may vary
+            -8.90384387e-02,  -5.84680802e-02,   3.89804309e-17,
+            6.68206631e-02,   1.16434881e-01,   1.26137788e-01,
+            8.50444803e-02,  -3.89804309e-17,  -1.03943254e-01,
+            -1.89206682e-01,  -2.16236208e-01,  -1.55914881e-01,
+            3.89804309e-17,   2.33872321e-01,   5.04551152e-01,
+            7.56826729e-01,   9.35489284e-01,   1.00000000e+00,
+            9.35489284e-01,   7.56826729e-01,   5.04551152e-01,
+            2.33872321e-01,   3.89804309e-17,  -1.55914881e-01,
+           -2.16236208e-01,  -1.89206682e-01,  -1.03943254e-01,
+           -3.89804309e-17,   8.50444803e-02,   1.26137788e-01,
+            1.16434881e-01,   6.68206631e-02,   3.89804309e-17,
+            -5.84680802e-02,  -8.90384387e-02,  -8.40918587e-02,
+            -4.92362781e-02,  -3.89804309e-17])
+
+    >>> plt.plot(x, np.sinc(x))
+    []
+    >>> plt.title("Sinc Function")
+    Text(0.5, 1.0, 'Sinc Function')
+    >>> plt.ylabel("Amplitude")
+    Text(0, 0.5, 'Amplitude')
+    >>> plt.xlabel("X")
+    Text(0.5, 0, 'X')
+    >>> plt.show()
+
+    """
+    x = np.asanyarray(x)
+    y = pi * where(x == 0, 1.0e-20, x)
+    return sin(y)/y
+
+
+def _ureduce(a, func, keepdims=False, **kwargs):
+    """
+    Internal Function.
+    Call `func` with `a` as first argument swapping the axes to use extended
+    axis on functions that don't support it natively.
+
+    Returns result and a.shape with axis dims set to 1.
+
+    Parameters
+    ----------
+    a : array_like
+        Input array or object that can be converted to an array.
+    func : callable
+        Reduction function capable of receiving a single axis argument.
+        It is called with `a` as first argument followed by `kwargs`.
+    kwargs : keyword arguments
+        additional keyword arguments to pass to `func`.
+
+    Returns
+    -------
+    result : tuple
+        Result of func(a, **kwargs) and a.shape with axis dims set to 1
+        which can be used to reshape the result to the same shape a ufunc with
+        keepdims=True would produce.
+
+    """
+    a = np.asanyarray(a)
+    axis = kwargs.get('axis', None)
+    out = kwargs.get('out', None)
+
+    if keepdims is np._NoValue:
+        keepdims = False
+
+    nd = a.ndim
+    if axis is not None:
+        axis = _nx.normalize_axis_tuple(axis, nd)
+
+        if keepdims:
+            if out is not None:
+                index_out = tuple(
+                    0 if i in axis else slice(None) for i in range(nd))
+                kwargs['out'] = out[(Ellipsis, ) + index_out]
+
+        if len(axis) == 1:
+            kwargs['axis'] = axis[0]
+        else:
+            keep = set(range(nd)) - set(axis)
+            nkeep = len(keep)
+            # swap axis that should not be reduced to front
+            for i, s in enumerate(sorted(keep)):
+                a = a.swapaxes(i, s)
+            # merge reduced axis
+            a = a.reshape(a.shape[:nkeep] + (-1,))
+            kwargs['axis'] = -1
+    else:
+        if keepdims:
+            if out is not None:
+                index_out = (0, ) * nd
+                kwargs['out'] = out[(Ellipsis, ) + index_out]
+
+    r = func(a, **kwargs)
+
+    if out is not None:
+        return out
+
+    if keepdims:
+        if axis is None:
+            index_r = (np.newaxis, ) * nd
+        else:
+            index_r = tuple(
+                np.newaxis if i in axis else slice(None)
+                for i in range(nd))
+        r = r[(Ellipsis, ) + index_r]
+
+    return r
+
+
+def _median_dispatcher(
+        a, axis=None, out=None, overwrite_input=None, keepdims=None):
+    return (a, out)
+
+
+@array_function_dispatch(_median_dispatcher)
+def median(a, axis=None, out=None, overwrite_input=False, keepdims=False):
+    """
+    Compute the median along the specified axis.
+
+    Returns the median of the array elements.
+
+    Parameters
+    ----------
+    a : array_like
+        Input array or object that can be converted to an array.
+    axis : {int, sequence of int, None}, optional
+        Axis or axes along which the medians are computed. The default,
+        axis=None, will compute the median along a flattened version of
+        the array.
+        
+        .. versionadded:: 1.9.0
+
+        If a sequence of axes, the array is first flattened along the
+        given axes, then the median is computed along the resulting
+        flattened axis.
+    out : ndarray, optional
+        Alternative output array in which to place the result. It must
+        have the same shape and buffer length as the expected output,
+        but the type (of the output) will be cast if necessary.
+    overwrite_input : bool, optional
+       If True, then allow use of memory of input array `a` for
+       calculations. The input array will be modified by the call to
+       `median`. This will save memory when you do not need to preserve
+       the contents of the input array. Treat the input as undefined,
+       but it will probably be fully or partially sorted. Default is
+       False. If `overwrite_input` is ``True`` and `a` is not already an
+       `ndarray`, an error will be raised.
+    keepdims : bool, optional
+        If this is set to True, the axes which are reduced are left
+        in the result as dimensions with size one. With this option,
+        the result will broadcast correctly against the original `arr`.
+
+        .. versionadded:: 1.9.0
+
+    Returns
+    -------
+    median : ndarray
+        A new array holding the result. If the input contains integers
+        or floats smaller than ``float64``, then the output data-type is
+        ``np.float64``.  Otherwise, the data-type of the output is the
+        same as that of the input. If `out` is specified, that array is
+        returned instead.
+
+    See Also
+    --------
+    mean, percentile
+
+    Notes
+    -----
+    Given a vector ``V`` of length ``N``, the median of ``V`` is the
+    middle value of a sorted copy of ``V``, ``V_sorted`` - i
+    e., ``V_sorted[(N-1)/2]``, when ``N`` is odd, and the average of the
+    two middle values of ``V_sorted`` when ``N`` is even.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> a = np.array([[10, 7, 4], [3, 2, 1]])
+    >>> a
+    array([[10,  7,  4],
+           [ 3,  2,  1]])
+    >>> np.median(a)
+    np.float64(3.5)
+    >>> np.median(a, axis=0)
+    array([6.5, 4.5, 2.5])
+    >>> np.median(a, axis=1)
+    array([7.,  2.])
+    >>> np.median(a, axis=(0, 1))
+    np.float64(3.5)
+    >>> m = np.median(a, axis=0)
+    >>> out = np.zeros_like(m)
+    >>> np.median(a, axis=0, out=m)
+    array([6.5,  4.5,  2.5])
+    >>> m
+    array([6.5,  4.5,  2.5])
+    >>> b = a.copy()
+    >>> np.median(b, axis=1, overwrite_input=True)
+    array([7.,  2.])
+    >>> assert not np.all(a==b)
+    >>> b = a.copy()
+    >>> np.median(b, axis=None, overwrite_input=True)
+    np.float64(3.5)
+    >>> assert not np.all(a==b)
+
+    """
+    return _ureduce(a, func=_median, keepdims=keepdims, axis=axis, out=out,
+                    overwrite_input=overwrite_input)
+
+
+def _median(a, axis=None, out=None, overwrite_input=False):
+    # can't be reasonably be implemented in terms of percentile as we have to
+    # call mean to not break astropy
+    a = np.asanyarray(a)
+
+    # Set the partition indexes
+    if axis is None:
+        sz = a.size
+    else:
+        sz = a.shape[axis]
+    if sz % 2 == 0:
+        szh = sz // 2
+        kth = [szh - 1, szh]
+    else:
+        kth = [(sz - 1) // 2]
+
+    # We have to check for NaNs (as of writing 'M' doesn't actually work).
+    supports_nans = np.issubdtype(a.dtype, np.inexact) or a.dtype.kind in 'Mm'
+    if supports_nans:
+        kth.append(-1)
+
+    if overwrite_input:
+        if axis is None:
+            part = a.ravel()
+            part.partition(kth)
+        else:
+            a.partition(kth, axis=axis)
+            part = a
+    else:
+        part = partition(a, kth, axis=axis)
+
+    if part.shape == ():
+        # make 0-D arrays work
+        return part.item()
+    if axis is None:
+        axis = 0
+
+    indexer = [slice(None)] * part.ndim
+    index = part.shape[axis] // 2
+    if part.shape[axis] % 2 == 1:
+        # index with slice to allow mean (below) to work
+        indexer[axis] = slice(index, index+1)
+    else:
+        indexer[axis] = slice(index-1, index+1)
+    indexer = tuple(indexer)
+
+    # Use mean in both odd and even case to coerce data type,
+    # using out array if needed.
+    rout = mean(part[indexer], axis=axis, out=out)
+    if supports_nans and sz > 0:
+        # If nans are possible, warn and replace by nans like mean would.
+        rout = np.lib._utils_impl._median_nancheck(part, rout, axis)
+
+    return rout
+
+
+def _percentile_dispatcher(a, q, axis=None, out=None, overwrite_input=None,
+                           method=None, keepdims=None, *, weights=None,
+                           interpolation=None):
+    return (a, q, out, weights)
+
+
+@array_function_dispatch(_percentile_dispatcher)
+def percentile(a,
+               q,
+               axis=None,
+               out=None,
+               overwrite_input=False,
+               method="linear",
+               keepdims=False,
+               *,
+               weights=None,
+               interpolation=None):
+    """
+    Compute the q-th percentile of the data along the specified axis.
+
+    Returns the q-th percentile(s) of the array elements.
+
+    Parameters
+    ----------
+    a : array_like of real numbers
+        Input array or object that can be converted to an array.
+    q : array_like of float
+        Percentage or sequence of percentages for the percentiles to compute.
+        Values must be between 0 and 100 inclusive.
+    axis : {int, tuple of int, None}, optional
+        Axis or axes along which the percentiles are computed. The
+        default is to compute the percentile(s) along a flattened
+        version of the array.
+
+        .. versionchanged:: 1.9.0
+            A tuple of axes is supported
+    out : ndarray, optional
+        Alternative output array in which to place the result. It must
+        have the same shape and buffer length as the expected output,
+        but the type (of the output) will be cast if necessary.
+    overwrite_input : bool, optional
+        If True, then allow the input array `a` to be modified by intermediate
+        calculations, to save memory. In this case, the contents of the input
+        `a` after this function completes is undefined.
+    method : str, optional
+        This parameter specifies the method to use for estimating the
+        percentile.  There are many different methods, some unique to NumPy.
+        See the notes for explanation.  The options sorted by their R type
+        as summarized in the H&F paper [1]_ are:
+
+        1. 'inverted_cdf'
+        2. 'averaged_inverted_cdf'
+        3. 'closest_observation'
+        4. 'interpolated_inverted_cdf'
+        5. 'hazen'
+        6. 'weibull'
+        7. 'linear'  (default)
+        8. 'median_unbiased'
+        9. 'normal_unbiased'
+
+        The first three methods are discontinuous.  NumPy further defines the
+        following discontinuous variations of the default 'linear' (7.) option:
+
+        * 'lower'
+        * 'higher',
+        * 'midpoint'
+        * 'nearest'
+
+        .. versionchanged:: 1.22.0
+            This argument was previously called "interpolation" and only
+            offered the "linear" default and last four options.
+
+    keepdims : bool, optional
+        If this is set to True, the axes which are reduced are left in
+        the result as dimensions with size one. With this option, the
+        result will broadcast correctly against the original array `a`.
+
+        .. versionadded:: 1.9.0
+
+     weights : array_like, optional
+        An array of weights associated with the values in `a`. Each value in
+        `a` contributes to the percentile according to its associated weight.
+        The weights array can either be 1-D (in which case its length must be
+        the size of `a` along the given axis) or of the same shape as `a`.
+        If `weights=None`, then all data in `a` are assumed to have a
+        weight equal to one.
+        Only `method="inverted_cdf"` supports weights.
+        See the notes for more details.
+
+        .. versionadded:: 2.0.0
+
+    interpolation : str, optional
+        Deprecated name for the method keyword argument.
+
+        .. deprecated:: 1.22.0
+
+    Returns
+    -------
+    percentile : scalar or ndarray
+        If `q` is a single percentile and `axis=None`, then the result
+        is a scalar. If multiple percentiles are given, first axis of
+        the result corresponds to the percentiles. The other axes are
+        the axes that remain after the reduction of `a`. If the input
+        contains integers or floats smaller than ``float64``, the output
+        data-type is ``float64``. Otherwise, the output data-type is the
+        same as that of the input. If `out` is specified, that array is
+        returned instead.
+
+    See Also
+    --------
+    mean
+    median : equivalent to ``percentile(..., 50)``
+    nanpercentile
+    quantile : equivalent to percentile, except q in the range [0, 1].
+
+    Notes
+    -----
+    The behavior of `numpy.percentile` with percentage `q` is
+    that of `numpy.quantile` with argument ``q/100``.
+    For more information, please see `numpy.quantile`.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> a = np.array([[10, 7, 4], [3, 2, 1]])
+    >>> a
+    array([[10,  7,  4],
+           [ 3,  2,  1]])
+    >>> np.percentile(a, 50)
+    3.5
+    >>> np.percentile(a, 50, axis=0)
+    array([6.5, 4.5, 2.5])
+    >>> np.percentile(a, 50, axis=1)
+    array([7.,  2.])
+    >>> np.percentile(a, 50, axis=1, keepdims=True)
+    array([[7.],
+           [2.]])
+
+    >>> m = np.percentile(a, 50, axis=0)
+    >>> out = np.zeros_like(m)
+    >>> np.percentile(a, 50, axis=0, out=out)
+    array([6.5, 4.5, 2.5])
+    >>> m
+    array([6.5, 4.5, 2.5])
+
+    >>> b = a.copy()
+    >>> np.percentile(b, 50, axis=1, overwrite_input=True)
+    array([7.,  2.])
+    >>> assert not np.all(a == b)
+
+    The different methods can be visualized graphically:
+
+    .. plot::
+
+        import matplotlib.pyplot as plt
+
+        a = np.arange(4)
+        p = np.linspace(0, 100, 6001)
+        ax = plt.gca()
+        lines = [
+            ('linear', '-', 'C0'),
+            ('inverted_cdf', ':', 'C1'),
+            # Almost the same as `inverted_cdf`:
+            ('averaged_inverted_cdf', '-.', 'C1'),
+            ('closest_observation', ':', 'C2'),
+            ('interpolated_inverted_cdf', '--', 'C1'),
+            ('hazen', '--', 'C3'),
+            ('weibull', '-.', 'C4'),
+            ('median_unbiased', '--', 'C5'),
+            ('normal_unbiased', '-.', 'C6'),
+            ]
+        for method, style, color in lines:
+            ax.plot(
+                p, np.percentile(a, p, method=method),
+                label=method, linestyle=style, color=color)
+        ax.set(
+            title='Percentiles for different methods and data: ' + str(a),
+            xlabel='Percentile',
+            ylabel='Estimated percentile value',
+            yticks=a)
+        ax.legend(bbox_to_anchor=(1.03, 1))
+        plt.tight_layout()
+        plt.show()
+
+    References
+    ----------
+    .. [1] R. J. Hyndman and Y. Fan,
+       "Sample quantiles in statistical packages,"
+       The American Statistician, 50(4), pp. 361-365, 1996
+
+    """
+    if interpolation is not None:
+        method = _check_interpolation_as_method(
+            method, interpolation, "percentile")
+
+    a = np.asanyarray(a)
+    if a.dtype.kind == "c":
+        raise TypeError("a must be an array of real numbers")
+
+    # Use dtype of array if possible (e.g., if q is a python int or float)
+    # by making the divisor have the dtype of the data array.
+    q = np.true_divide(q, a.dtype.type(100) if a.dtype.kind == "f" else 100)
+    q = asanyarray(q)  # undo any decay that the ufunc performed (see gh-13105)
+    if not _quantile_is_valid(q):
+        raise ValueError("Percentiles must be in the range [0, 100]")
+
+    if weights is not None:
+        if method != "inverted_cdf":
+            msg = ("Only method 'inverted_cdf' supports weights. "
+                   f"Got: {method}.")
+            raise ValueError(msg)
+        if axis is not None:
+            axis = _nx.normalize_axis_tuple(axis, a.ndim, argname="axis")
+        weights = _weights_are_valid(weights=weights, a=a, axis=axis)
+        if np.any(weights < 0):
+            raise ValueError("Weights must be non-negative.")
+
+    return _quantile_unchecked(
+        a, q, axis, out, overwrite_input, method, keepdims, weights)
+
+
+def _quantile_dispatcher(a, q, axis=None, out=None, overwrite_input=None,
+                         method=None, keepdims=None, *, weights=None,
+                         interpolation=None):
+    return (a, q, out, weights)
+
+
+@array_function_dispatch(_quantile_dispatcher)
+def quantile(a,
+             q,
+             axis=None,
+             out=None,
+             overwrite_input=False,
+             method="linear",
+             keepdims=False,
+             *,
+             weights=None,
+             interpolation=None):
+    """
+    Compute the q-th quantile of the data along the specified axis.
+
+    .. versionadded:: 1.15.0
+
+    Parameters
+    ----------
+    a : array_like of real numbers
+        Input array or object that can be converted to an array.
+    q : array_like of float
+        Probability or sequence of probabilities of the quantiles to compute.
+        Values must be between 0 and 1 inclusive.
+    axis : {int, tuple of int, None}, optional
+        Axis or axes along which the quantiles are computed. The default is
+        to compute the quantile(s) along a flattened version of the array.
+    out : ndarray, optional
+        Alternative output array in which to place the result. It must have
+        the same shape and buffer length as the expected output, but the
+        type (of the output) will be cast if necessary.
+    overwrite_input : bool, optional
+        If True, then allow the input array `a` to be modified by
+        intermediate calculations, to save memory. In this case, the
+        contents of the input `a` after this function completes is
+        undefined.
+    method : str, optional
+        This parameter specifies the method to use for estimating the
+        quantile.  There are many different methods, some unique to NumPy.
+        The recommended options, numbered as they appear in [1]_, are:
+
+        1. 'inverted_cdf'
+        2. 'averaged_inverted_cdf'
+        3. 'closest_observation'
+        4. 'interpolated_inverted_cdf'
+        5. 'hazen'
+        6. 'weibull'
+        7. 'linear'  (default)
+        8. 'median_unbiased'
+        9. 'normal_unbiased'
+
+        The first three methods are discontinuous. For backward compatibility
+        with previous versions of NumPy, the following discontinuous variations
+        of the default 'linear' (7.) option are available:
+
+        * 'lower'
+        * 'higher',
+        * 'midpoint'
+        * 'nearest'
+
+        See Notes for details.
+
+        .. versionchanged:: 1.22.0
+            This argument was previously called "interpolation" and only
+            offered the "linear" default and last four options.
+
+    keepdims : bool, optional
+        If this is set to True, the axes which are reduced are left in
+        the result as dimensions with size one. With this option, the
+        result will broadcast correctly against the original array `a`.
+
+    weights : array_like, optional
+        An array of weights associated with the values in `a`. Each value in
+        `a` contributes to the quantile according to its associated weight.
+        The weights array can either be 1-D (in which case its length must be
+        the size of `a` along the given axis) or of the same shape as `a`.
+        If `weights=None`, then all data in `a` are assumed to have a
+        weight equal to one.
+        Only `method="inverted_cdf"` supports weights.
+        See the notes for more details.
+
+        .. versionadded:: 2.0.0
+
+    interpolation : str, optional
+        Deprecated name for the method keyword argument.
+
+        .. deprecated:: 1.22.0
+
+    Returns
+    -------
+    quantile : scalar or ndarray
+        If `q` is a single probability and `axis=None`, then the result
+        is a scalar. If multiple probability levels are given, first axis
+        of the result corresponds to the quantiles. The other axes are
+        the axes that remain after the reduction of `a`. If the input
+        contains integers or floats smaller than ``float64``, the output
+        data-type is ``float64``. Otherwise, the output data-type is the
+        same as that of the input. If `out` is specified, that array is
+        returned instead.
+
+    See Also
+    --------
+    mean
+    percentile : equivalent to quantile, but with q in the range [0, 100].
+    median : equivalent to ``quantile(..., 0.5)``
+    nanquantile
+
+    Notes
+    -----
+    Given a sample `a` from an underlying distribution, `quantile` provides a
+    nonparametric estimate of the inverse cumulative distribution function.
+
+    By default, this is done by interpolating between adjacent elements in
+    ``y``, a sorted copy of `a`::
+
+        (1-g)*y[j] + g*y[j+1]
+
+    where the index ``j`` and coefficient ``g`` are the integral and
+    fractional components of ``q * (n-1)``, and ``n`` is the number of
+    elements in the sample.
+
+    This is a special case of Equation 1 of H&F [1]_. More generally,
+
+    - ``j = (q*n + m - 1) // 1``, and
+    - ``g = (q*n + m - 1) % 1``,
+
+    where ``m`` may be defined according to several different conventions.
+    The preferred convention may be selected using the ``method`` parameter:
+
+    =============================== =============== ===============
+    ``method``                      number in H&F   ``m``
+    =============================== =============== ===============
+    ``interpolated_inverted_cdf``   4               ``0``
+    ``hazen``                       5               ``1/2``
+    ``weibull``                     6               ``q``
+    ``linear`` (default)            7               ``1 - q``
+    ``median_unbiased``             8               ``q/3 + 1/3``
+    ``normal_unbiased``             9               ``q/4 + 3/8``
+    =============================== =============== ===============
+
+    Note that indices ``j`` and ``j + 1`` are clipped to the range ``0`` to
+    ``n - 1`` when the results of the formula would be outside the allowed
+    range of non-negative indices. The ``- 1`` in the formulas for ``j`` and
+    ``g`` accounts for Python's 0-based indexing.
+
+    The table above includes only the estimators from H&F that are continuous
+    functions of probability `q` (estimators 4-9). NumPy also provides the
+    three discontinuous estimators from H&F (estimators 1-3), where ``j`` is
+    defined as above, ``m`` is defined as follows, and ``g`` is a function
+    of the real-valued ``index = q*n + m - 1`` and ``j``.
+
+    1. ``inverted_cdf``: ``m = 0`` and ``g = int(index - j > 0)``
+    2. ``averaged_inverted_cdf``: ``m = 0`` and
+       ``g = (1 + int(index - j > 0)) / 2``
+    3. ``closest_observation``: ``m = -1/2`` and
+       ``g = 1 - int((index == j) & (j%2 == 1))``
+
+    For backward compatibility with previous versions of NumPy, `quantile`
+    provides four additional discontinuous estimators. Like
+    ``method='linear'``, all have ``m = 1 - q`` so that ``j = q*(n-1) // 1``,
+    but ``g`` is defined as follows.
+
+    - ``lower``: ``g = 0``
+    - ``midpoint``: ``g = 0.5``
+    - ``higher``: ``g = 1``
+    - ``nearest``: ``g = (q*(n-1) % 1) > 0.5``
+
+    **Weighted quantiles:**
+    More formally, the quantile at probability level :math:`q` of a cumulative
+    distribution function :math:`F(y)=P(Y \\leq y)` with probability measure
+    :math:`P` is defined as any number :math:`x` that fulfills the
+    *coverage conditions*
+
+    .. math:: P(Y < x) \\leq q \\quad\\text{and}\\quad P(Y \\leq x) \\geq q
+
+    with random variable :math:`Y\\sim P`.
+    Sample quantiles, the result of `quantile`, provide nonparametric
+    estimation of the underlying population counterparts, represented by the
+    unknown :math:`F`, given a data vector `a` of length ``n``.
+
+    Some of the estimators above arise when one considers :math:`F` as the
+    empirical distribution function of the data, i.e.
+    :math:`F(y) = \\frac{1}{n} \\sum_i 1_{a_i \\leq y}`.
+    Then, different methods correspond to different choices of :math:`x` that
+    fulfill the above coverage conditions. Methods that follow this approach
+    are ``inverted_cdf`` and ``averaged_inverted_cdf``.
+
+    For weighted quantiles, the coverage conditions still hold. The
+    empirical cumulative distribution is simply replaced by its weighted
+    version, i.e. 
+    :math:`P(Y \\leq t) = \\frac{1}{\\sum_i w_i} \\sum_i w_i 1_{x_i \\leq t}`.
+    Only ``method="inverted_cdf"`` supports weights.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> a = np.array([[10, 7, 4], [3, 2, 1]])
+    >>> a
+    array([[10,  7,  4],
+           [ 3,  2,  1]])
+    >>> np.quantile(a, 0.5)
+    3.5
+    >>> np.quantile(a, 0.5, axis=0)
+    array([6.5, 4.5, 2.5])
+    >>> np.quantile(a, 0.5, axis=1)
+    array([7.,  2.])
+    >>> np.quantile(a, 0.5, axis=1, keepdims=True)
+    array([[7.],
+           [2.]])
+    >>> m = np.quantile(a, 0.5, axis=0)
+    >>> out = np.zeros_like(m)
+    >>> np.quantile(a, 0.5, axis=0, out=out)
+    array([6.5, 4.5, 2.5])
+    >>> m
+    array([6.5, 4.5, 2.5])
+    >>> b = a.copy()
+    >>> np.quantile(b, 0.5, axis=1, overwrite_input=True)
+    array([7.,  2.])
+    >>> assert not np.all(a == b)
+
+    See also `numpy.percentile` for a visualization of most methods.
+
+    References
+    ----------
+    .. [1] R. J. Hyndman and Y. Fan,
+       "Sample quantiles in statistical packages,"
+       The American Statistician, 50(4), pp. 361-365, 1996
+
+    """
+    if interpolation is not None:
+        method = _check_interpolation_as_method(
+            method, interpolation, "quantile")
+
+    a = np.asanyarray(a)
+    if a.dtype.kind == "c":
+        raise TypeError("a must be an array of real numbers")
+
+    # Use dtype of array if possible (e.g., if q is a python int or float).
+    if isinstance(q, (int, float)) and a.dtype.kind == "f":
+        q = np.asanyarray(q, dtype=a.dtype)
+    else:
+        q = np.asanyarray(q)
+
+    if not _quantile_is_valid(q):
+        raise ValueError("Quantiles must be in the range [0, 1]")
+
+    if weights is not None:
+        if method != "inverted_cdf":
+            msg = ("Only method 'inverted_cdf' supports weights. "
+                   f"Got: {method}.")
+            raise ValueError(msg)
+        if axis is not None:
+            axis = _nx.normalize_axis_tuple(axis, a.ndim, argname="axis")
+        weights = _weights_are_valid(weights=weights, a=a, axis=axis)
+        if np.any(weights < 0):
+            raise ValueError("Weights must be non-negative.")
+
+    return _quantile_unchecked(
+        a, q, axis, out, overwrite_input, method, keepdims, weights)
+
+
+def _quantile_unchecked(a,
+                        q,
+                        axis=None,
+                        out=None,
+                        overwrite_input=False,
+                        method="linear",
+                        keepdims=False,
+                        weights=None):
+    """Assumes that q is in [0, 1], and is an ndarray"""
+    return _ureduce(a,
+                    func=_quantile_ureduce_func,
+                    q=q,
+                    weights=weights,
+                    keepdims=keepdims,
+                    axis=axis,
+                    out=out,
+                    overwrite_input=overwrite_input,
+                    method=method)
+
+
+def _quantile_is_valid(q):
+    # avoid expensive reductions, relevant for arrays with < O(1000) elements
+    if q.ndim == 1 and q.size < 10:
+        for i in range(q.size):
+            if not (0.0 <= q[i] <= 1.0):
+                return False
+    else:
+        if not (q.min() >= 0 and q.max() <= 1):
+            return False
+    return True
+
+
+def _check_interpolation_as_method(method, interpolation, fname):
+    # Deprecated NumPy 1.22, 2021-11-08
+    warnings.warn(
+        f"the `interpolation=` argument to {fname} was renamed to "
+        "`method=`, which has additional options.\n"
+        "Users of the modes 'nearest', 'lower', 'higher', or "
+        "'midpoint' are encouraged to review the method they used. "
+        "(Deprecated NumPy 1.22)",
+        DeprecationWarning, stacklevel=4)
+    if method != "linear":
+        # sanity check, we assume this basically never happens
+        raise TypeError(
+            "You shall not pass both `method` and `interpolation`!\n"
+            "(`interpolation` is Deprecated in favor of `method`)")
+    return interpolation
+
+
+def _compute_virtual_index(n, quantiles, alpha: float, beta: float):
+    """
+    Compute the floating point indexes of an array for the linear
+    interpolation of quantiles.
+    n : array_like
+        The sample sizes.
+    quantiles : array_like
+        The quantiles values.
+    alpha : float
+        A constant used to correct the index computed.
+    beta : float
+        A constant used to correct the index computed.
+
+    alpha and beta values depend on the chosen method
+    (see quantile documentation)
+
+    Reference:
+    Hyndman&Fan paper "Sample Quantiles in Statistical Packages",
+    DOI: 10.1080/00031305.1996.10473566
+    """
+    return n * quantiles + (
+            alpha + quantiles * (1 - alpha - beta)
+    ) - 1
+
+
+def _get_gamma(virtual_indexes, previous_indexes, method):
+    """
+    Compute gamma (a.k.a 'm' or 'weight') for the linear interpolation
+    of quantiles.
+
+    virtual_indexes : array_like
+        The indexes where the percentile is supposed to be found in the sorted
+        sample.
+    previous_indexes : array_like
+        The floor values of virtual_indexes.
+    interpolation : dict
+        The interpolation method chosen, which may have a specific rule
+        modifying gamma.
+
+    gamma is usually the fractional part of virtual_indexes but can be modified
+    by the interpolation method.
+    """
+    gamma = np.asanyarray(virtual_indexes - previous_indexes)
+    gamma = method["fix_gamma"](gamma, virtual_indexes)
+    # Ensure both that we have an array, and that we keep the dtype
+    # (which may have been matched to the input array).
+    return np.asanyarray(gamma, dtype=virtual_indexes.dtype)
+
+
+def _lerp(a, b, t, out=None):
+    """
+    Compute the linear interpolation weighted by gamma on each point of
+    two same shape array.
+
+    a : array_like
+        Left bound.
+    b : array_like
+        Right bound.
+    t : array_like
+        The interpolation weight.
+    out : array_like
+        Output array.
+    """
+    diff_b_a = subtract(b, a)
+    # asanyarray is a stop-gap until gh-13105
+    lerp_interpolation = asanyarray(add(a, diff_b_a * t, out=out))
+    subtract(b, diff_b_a * (1 - t), out=lerp_interpolation, where=t >= 0.5,
+             casting='unsafe', dtype=type(lerp_interpolation.dtype))
+    if lerp_interpolation.ndim == 0 and out is None:
+        lerp_interpolation = lerp_interpolation[()]  # unpack 0d arrays
+    return lerp_interpolation
+
+
+def _get_gamma_mask(shape, default_value, conditioned_value, where):
+    out = np.full(shape, default_value)
+    np.copyto(out, conditioned_value, where=where, casting="unsafe")
+    return out
+
+
+def _discret_interpolation_to_boundaries(index, gamma_condition_fun):
+    previous = np.floor(index)
+    next = previous + 1
+    gamma = index - previous
+    res = _get_gamma_mask(shape=index.shape,
+                          default_value=next,
+                          conditioned_value=previous,
+                          where=gamma_condition_fun(gamma, index)
+                          ).astype(np.intp)
+    # Some methods can lead to out-of-bound integers, clip them:
+    res[res < 0] = 0
+    return res
+
+
+def _closest_observation(n, quantiles):
+    # "choose the nearest even order statistic at g=0" (H&F (1996) pp. 362).
+    # Order is 1-based so for zero-based indexing round to nearest odd index.
+    gamma_fun = lambda gamma, index: (gamma == 0) & (np.floor(index) % 2 == 1)
+    return _discret_interpolation_to_boundaries((n * quantiles) - 1 - 0.5,
+                                                gamma_fun)
+
+
+def _inverted_cdf(n, quantiles):
+    gamma_fun = lambda gamma, _: (gamma == 0)
+    return _discret_interpolation_to_boundaries((n * quantiles) - 1,
+                                                gamma_fun)
+
+
+def _quantile_ureduce_func(
+        a: np.array,
+        q: np.array,
+        weights: np.array,
+        axis: int = None,
+        out=None,
+        overwrite_input: bool = False,
+        method="linear",
+) -> np.array:
+    if q.ndim > 2:
+        # The code below works fine for nd, but it might not have useful
+        # semantics. For now, keep the supported dimensions the same as it was
+        # before.
+        raise ValueError("q must be a scalar or 1d")
+    if overwrite_input:
+        if axis is None:
+            axis = 0
+            arr = a.ravel()
+            wgt = None if weights is None else weights.ravel()
+        else:
+            arr = a
+            wgt = weights
+    else:
+        if axis is None:
+            axis = 0
+            arr = a.flatten()
+            wgt = None if weights is None else weights.flatten()
+        else:
+            arr = a.copy()
+            wgt = weights
+    result = _quantile(arr,
+                       quantiles=q,
+                       axis=axis,
+                       method=method,
+                       out=out,
+                       weights=wgt)
+    return result
+
+
+def _get_indexes(arr, virtual_indexes, valid_values_count):
+    """
+    Get the valid indexes of arr neighbouring virtual_indexes.
+    Note
+    This is a companion function to linear interpolation of
+    Quantiles
+
+    Returns
+    -------
+    (previous_indexes, next_indexes): Tuple
+        A Tuple of virtual_indexes neighbouring indexes
+    """
+    previous_indexes = np.asanyarray(np.floor(virtual_indexes))
+    next_indexes = np.asanyarray(previous_indexes + 1)
+    indexes_above_bounds = virtual_indexes >= valid_values_count - 1
+    # When indexes is above max index, take the max value of the array
+    if indexes_above_bounds.any():
+        previous_indexes[indexes_above_bounds] = -1
+        next_indexes[indexes_above_bounds] = -1
+    # When indexes is below min index, take the min value of the array
+    indexes_below_bounds = virtual_indexes < 0
+    if indexes_below_bounds.any():
+        previous_indexes[indexes_below_bounds] = 0
+        next_indexes[indexes_below_bounds] = 0
+    if np.issubdtype(arr.dtype, np.inexact):
+        # After the sort, slices having NaNs will have for last element a NaN
+        virtual_indexes_nans = np.isnan(virtual_indexes)
+        if virtual_indexes_nans.any():
+            previous_indexes[virtual_indexes_nans] = -1
+            next_indexes[virtual_indexes_nans] = -1
+    previous_indexes = previous_indexes.astype(np.intp)
+    next_indexes = next_indexes.astype(np.intp)
+    return previous_indexes, next_indexes
+
+
+def _quantile(
+        arr: np.array,
+        quantiles: np.array,
+        axis: int = -1,
+        method="linear",
+        out=None,
+        weights=None,
+):
+    """
+    Private function that doesn't support extended axis or keepdims.
+    These methods are extended to this function using _ureduce
+    See nanpercentile for parameter usage
+    It computes the quantiles of the array for the given axis.
+    A linear interpolation is performed based on the `interpolation`.
+
+    By default, the method is "linear" where alpha == beta == 1 which
+    performs the 7th method of Hyndman&Fan.
+    With "median_unbiased" we get alpha == beta == 1/3
+    thus the 8th method of Hyndman&Fan.
+    """
+    # --- Setup
+    arr = np.asanyarray(arr)
+    values_count = arr.shape[axis]
+    # The dimensions of `q` are prepended to the output shape, so we need the
+    # axis being sampled from `arr` to be last.
+    if axis != 0:  # But moveaxis is slow, so only call it if necessary.
+        arr = np.moveaxis(arr, axis, destination=0)
+    supports_nans = (
+        np.issubdtype(arr.dtype, np.inexact) or arr.dtype.kind in 'Mm'
+    )
+
+    if weights is None:
+        # --- Computation of indexes
+        # Index where to find the value in the sorted array.
+        # Virtual because it is a floating point value, not an valid index.
+        # The nearest neighbours are used for interpolation
+        try:
+            method_props = _QuantileMethods[method]
+        except KeyError:
+            raise ValueError(
+                f"{method!r} is not a valid method. Use one of: "
+                f"{_QuantileMethods.keys()}") from None
+        virtual_indexes = method_props["get_virtual_index"](values_count,
+                                                            quantiles)
+        virtual_indexes = np.asanyarray(virtual_indexes)
+
+        if method_props["fix_gamma"] is None:
+            supports_integers = True
+        else:
+            int_virtual_indices = np.issubdtype(virtual_indexes.dtype,
+                                                np.integer)
+            supports_integers = method == 'linear' and int_virtual_indices
+
+        if supports_integers:
+            # No interpolation needed, take the points along axis
+            if supports_nans:
+                # may contain nan, which would sort to the end
+                arr.partition(
+                    concatenate((virtual_indexes.ravel(), [-1])), axis=0,
+                )
+                slices_having_nans = np.isnan(arr[-1, ...])
+            else:
+                # cannot contain nan
+                arr.partition(virtual_indexes.ravel(), axis=0)
+                slices_having_nans = np.array(False, dtype=bool)
+            result = take(arr, virtual_indexes, axis=0, out=out)
+        else:
+            previous_indexes, next_indexes = _get_indexes(arr,
+                                                          virtual_indexes,
+                                                          values_count)
+            # --- Sorting
+            arr.partition(
+                np.unique(np.concatenate(([0, -1],
+                                          previous_indexes.ravel(),
+                                          next_indexes.ravel(),
+                                          ))),
+                axis=0)
+            if supports_nans:
+                slices_having_nans = np.isnan(arr[-1, ...])
+            else:
+                slices_having_nans = None
+            # --- Get values from indexes
+            previous = arr[previous_indexes]
+            next = arr[next_indexes]
+            # --- Linear interpolation
+            gamma = _get_gamma(virtual_indexes, previous_indexes, method_props)
+            result_shape = virtual_indexes.shape + (1,) * (arr.ndim - 1)
+            gamma = gamma.reshape(result_shape)
+            result = _lerp(previous,
+                        next,
+                        gamma,
+                        out=out)
+    else:
+        # Weighted case
+        # This implements method="inverted_cdf", the only supported weighted
+        # method, which needs to sort anyway.
+        weights = np.asanyarray(weights)
+        if axis != 0:
+            weights = np.moveaxis(weights, axis, destination=0)
+        index_array = np.argsort(arr, axis=0, kind="stable")
+
+        # arr = arr[index_array, ...]  # but this adds trailing dimensions of
+        # 1.
+        arr = np.take_along_axis(arr, index_array, axis=0)
+        if weights.shape == arr.shape:
+            weights = np.take_along_axis(weights, index_array, axis=0)
+        else:
+            # weights is 1d
+            weights = weights.reshape(-1)[index_array, ...]
+
+        if supports_nans:
+            # may contain nan, which would sort to the end
+            slices_having_nans = np.isnan(arr[-1, ...])
+        else:
+            # cannot contain nan
+            slices_having_nans = np.array(False, dtype=bool)
+
+        # We use the weights to calculate the empirical cumulative
+        # distribution function cdf
+        cdf = weights.cumsum(axis=0, dtype=np.float64)
+        cdf /= cdf[-1, ...]  # normalization to 1
+        # Search index i such that
+        #   sum(weights[j], j=0..i-1) < quantile <= sum(weights[j], j=0..i)
+        # is then equivalent to
+        #   cdf[i-1] < quantile <= cdf[i]
+        # Unfortunately, searchsorted only accepts 1-d arrays as first
+        # argument, so we will need to iterate over dimensions.
+
+        # Without the following cast, searchsorted can return surprising
+        # results, e.g.
+        #   np.searchsorted(np.array([0.2, 0.4, 0.6, 0.8, 1.]),
+        #                   np.array(0.4, dtype=np.float32), side="left")
+        # returns 2 instead of 1 because 0.4 is not binary representable.
+        if quantiles.dtype.kind == "f":
+            cdf = cdf.astype(quantiles.dtype)
+        # Weights must be non-negative, so we might have zero weights at the
+        # beginning leading to some leading zeros in cdf. The call to
+        # np.searchsorted for quantiles=0 will then pick the first element,
+        # but should pick the first one larger than zero. We
+        # therefore simply set 0 values in cdf to -1.
+        if np.any(cdf[0, ...] == 0):
+            cdf[cdf == 0] = -1
+
+        def find_cdf_1d(arr, cdf):
+            indices = np.searchsorted(cdf, quantiles, side="left")
+            # We might have reached the maximum with i = len(arr), e.g. for
+            # quantiles = 1, and need to cut it to len(arr) - 1.
+            indices = minimum(indices, values_count - 1)
+            result = take(arr, indices, axis=0)
+            return result
+
+        r_shape = arr.shape[1:]
+        if quantiles.ndim > 0: 
+            r_shape = quantiles.shape + r_shape
+        if out is None:
+            result = np.empty_like(arr, shape=r_shape)
+        else:
+            if out.shape != r_shape:
+                msg = (f"Wrong shape of argument 'out', shape={r_shape} is "
+                       f"required; got shape={out.shape}.")
+                raise ValueError(msg)
+            result = out
+
+        # See apply_along_axis, which we do for axis=0. Note that Ni = (,)
+        # always, so we remove it here.
+        Nk = arr.shape[1:]
+        for kk in np.ndindex(Nk):
+            result[(...,) + kk] = find_cdf_1d(
+                arr[np.s_[:, ] + kk], cdf[np.s_[:, ] + kk]
+            )
+
+        # Make result the same as in unweighted inverted_cdf.
+        if result.shape == () and result.dtype == np.dtype("O"):
+            result = result.item()
+
+    if np.any(slices_having_nans):
+        if result.ndim == 0 and out is None:
+            # can't write to a scalar, but indexing will be correct
+            result = arr[-1]
+        else:
+            np.copyto(result, arr[-1, ...], where=slices_having_nans)
+    return result
+
+
+def _trapezoid_dispatcher(y, x=None, dx=None, axis=None):
+    return (y, x)
+
+
+@array_function_dispatch(_trapezoid_dispatcher)
+def trapezoid(y, x=None, dx=1.0, axis=-1):
+    r"""
+    Integrate along the given axis using the composite trapezoidal rule.
+
+    If `x` is provided, the integration happens in sequence along its
+    elements - they are not sorted.
+
+    Integrate `y` (`x`) along each 1d slice on the given axis, compute
+    :math:`\int y(x) dx`.
+    When `x` is specified, this integrates along the parametric curve,
+    computing :math:`\int_t y(t) dt =
+    \int_t y(t) \left.\frac{dx}{dt}\right|_{x=x(t)} dt`.
+
+    .. versionadded:: 2.0.0
+
+    Parameters
+    ----------
+    y : array_like
+        Input array to integrate.
+    x : array_like, optional
+        The sample points corresponding to the `y` values. If `x` is None,
+        the sample points are assumed to be evenly spaced `dx` apart. The
+        default is None.
+    dx : scalar, optional
+        The spacing between sample points when `x` is None. The default is 1.
+    axis : int, optional
+        The axis along which to integrate.
+
+    Returns
+    -------
+    trapezoid : float or ndarray
+        Definite integral of `y` = n-dimensional array as approximated along
+        a single axis by the trapezoidal rule. If `y` is a 1-dimensional array,
+        then the result is a float. If `n` is greater than 1, then the result
+        is an `n`-1 dimensional array.
+
+    See Also
+    --------
+    sum, cumsum
+
+    Notes
+    -----
+    Image [2]_ illustrates trapezoidal rule -- y-axis locations of points
+    will be taken from `y` array, by default x-axis distances between
+    points will be 1.0, alternatively they can be provided with `x` array
+    or with `dx` scalar.  Return value will be equal to combined area under
+    the red lines.
+
+
+    References
+    ----------
+    .. [1] Wikipedia page: https://en.wikipedia.org/wiki/Trapezoidal_rule
+
+    .. [2] Illustration image:
+           https://en.wikipedia.org/wiki/File:Composite_trapezoidal_rule_illustration.png
+
+    Examples
+    --------
+    >>> import numpy as np
+
+    Use the trapezoidal rule on evenly spaced points:
+
+    >>> np.trapezoid([1, 2, 3])
+    4.0
+
+    The spacing between sample points can be selected by either the
+    ``x`` or ``dx`` arguments:
+
+    >>> np.trapezoid([1, 2, 3], x=[4, 6, 8])
+    8.0
+    >>> np.trapezoid([1, 2, 3], dx=2)
+    8.0
+
+    Using a decreasing ``x`` corresponds to integrating in reverse:
+
+    >>> np.trapezoid([1, 2, 3], x=[8, 6, 4])
+    -8.0
+
+    More generally ``x`` is used to integrate along a parametric curve. We can
+    estimate the integral :math:`\int_0^1 x^2 = 1/3` using:
+
+    >>> x = np.linspace(0, 1, num=50)
+    >>> y = x**2
+    >>> np.trapezoid(y, x)
+    0.33340274885464394
+
+    Or estimate the area of a circle, noting we repeat the sample which closes
+    the curve:
+
+    >>> theta = np.linspace(0, 2 * np.pi, num=1000, endpoint=True)
+    >>> np.trapezoid(np.cos(theta), x=np.sin(theta))
+    3.141571941375841
+
+    ``np.trapezoid`` can be applied along a specified axis to do multiple
+    computations in one call:
+
+    >>> a = np.arange(6).reshape(2, 3)
+    >>> a
+    array([[0, 1, 2],
+           [3, 4, 5]])
+    >>> np.trapezoid(a, axis=0)
+    array([1.5, 2.5, 3.5])
+    >>> np.trapezoid(a, axis=1)
+    array([2.,  8.])
+    """
+
+    y = asanyarray(y)
+    if x is None:
+        d = dx
+    else:
+        x = asanyarray(x)
+        if x.ndim == 1:
+            d = diff(x)
+            # reshape to correct shape
+            shape = [1]*y.ndim
+            shape[axis] = d.shape[0]
+            d = d.reshape(shape)
+        else:
+            d = diff(x, axis=axis)
+    nd = y.ndim
+    slice1 = [slice(None)]*nd
+    slice2 = [slice(None)]*nd
+    slice1[axis] = slice(1, None)
+    slice2[axis] = slice(None, -1)
+    try:
+        ret = (d * (y[tuple(slice1)] + y[tuple(slice2)]) / 2.0).sum(axis)
+    except ValueError:
+        # Operations didn't work, cast to ndarray
+        d = np.asarray(d)
+        y = np.asarray(y)
+        ret = add.reduce(d * (y[tuple(slice1)]+y[tuple(slice2)])/2.0, axis)
+    return ret
+
+
+@set_module('numpy')
+def trapz(y, x=None, dx=1.0, axis=-1):
+    """
+    `trapz` is deprecated in NumPy 2.0.
+
+    Please use `trapezoid` instead, or one of the numerical integration
+    functions in `scipy.integrate`.
+    """
+    # Deprecated in NumPy 2.0, 2023-08-18
+    warnings.warn(
+        "`trapz` is deprecated. Use `trapezoid` instead, or one of the "
+        "numerical integration functions in `scipy.integrate`.",
+        DeprecationWarning,
+        stacklevel=2
+    )
+    return trapezoid(y, x=x, dx=dx, axis=axis)
+
+
+def _meshgrid_dispatcher(*xi, copy=None, sparse=None, indexing=None):
+    return xi
+
+
+# Based on scitools meshgrid
+@array_function_dispatch(_meshgrid_dispatcher)
+def meshgrid(*xi, copy=True, sparse=False, indexing='xy'):
+    """
+    Return a tuple of coordinate matrices from coordinate vectors.
+
+    Make N-D coordinate arrays for vectorized evaluations of
+    N-D scalar/vector fields over N-D grids, given
+    one-dimensional coordinate arrays x1, x2,..., xn.
+
+    .. versionchanged:: 1.9
+       1-D and 0-D cases are allowed.
+
+    Parameters
+    ----------
+    x1, x2,..., xn : array_like
+        1-D arrays representing the coordinates of a grid.
+    indexing : {'xy', 'ij'}, optional
+        Cartesian ('xy', default) or matrix ('ij') indexing of output.
+        See Notes for more details.
+
+        .. versionadded:: 1.7.0
+    sparse : bool, optional
+        If True the shape of the returned coordinate array for dimension *i*
+        is reduced from ``(N1, ..., Ni, ... Nn)`` to
+        ``(1, ..., 1, Ni, 1, ..., 1)``.  These sparse coordinate grids are
+        intended to be use with :ref:`basics.broadcasting`.  When all
+        coordinates are used in an expression, broadcasting still leads to a
+        fully-dimensonal result array.
+
+        Default is False.
+
+        .. versionadded:: 1.7.0
+    copy : bool, optional
+        If False, a view into the original arrays are returned in order to
+        conserve memory.  Default is True.  Please note that
+        ``sparse=False, copy=False`` will likely return non-contiguous
+        arrays.  Furthermore, more than one element of a broadcast array
+        may refer to a single memory location.  If you need to write to the
+        arrays, make copies first.
+
+        .. versionadded:: 1.7.0
+
+    Returns
+    -------
+    X1, X2,..., XN : tuple of ndarrays
+        For vectors `x1`, `x2`,..., `xn` with lengths ``Ni=len(xi)``,
+        returns ``(N1, N2, N3,..., Nn)`` shaped arrays if indexing='ij'
+        or ``(N2, N1, N3,..., Nn)`` shaped arrays if indexing='xy'
+        with the elements of `xi` repeated to fill the matrix along
+        the first dimension for `x1`, the second for `x2` and so on.
+
+    Notes
+    -----
+    This function supports both indexing conventions through the indexing
+    keyword argument.  Giving the string 'ij' returns a meshgrid with
+    matrix indexing, while 'xy' returns a meshgrid with Cartesian indexing.
+    In the 2-D case with inputs of length M and N, the outputs are of shape
+    (N, M) for 'xy' indexing and (M, N) for 'ij' indexing.  In the 3-D case
+    with inputs of length M, N and P, outputs are of shape (N, M, P) for
+    'xy' indexing and (M, N, P) for 'ij' indexing.  The difference is
+    illustrated by the following code snippet::
+
+        xv, yv = np.meshgrid(x, y, indexing='ij')
+        for i in range(nx):
+            for j in range(ny):
+                # treat xv[i,j], yv[i,j]
+
+        xv, yv = np.meshgrid(x, y, indexing='xy')
+        for i in range(nx):
+            for j in range(ny):
+                # treat xv[j,i], yv[j,i]
+
+    In the 1-D and 0-D case, the indexing and sparse keywords have no effect.
+
+    See Also
+    --------
+    mgrid : Construct a multi-dimensional "meshgrid" using indexing notation.
+    ogrid : Construct an open multi-dimensional "meshgrid" using indexing
+            notation.
+    :ref:`how-to-index`
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> nx, ny = (3, 2)
+    >>> x = np.linspace(0, 1, nx)
+    >>> y = np.linspace(0, 1, ny)
+    >>> xv, yv = np.meshgrid(x, y)
+    >>> xv
+    array([[0. , 0.5, 1. ],
+           [0. , 0.5, 1. ]])
+    >>> yv
+    array([[0.,  0.,  0.],
+           [1.,  1.,  1.]])
+
+    The result of `meshgrid` is a coordinate grid:
+
+    >>> import matplotlib.pyplot as plt
+    >>> plt.plot(xv, yv, marker='o', color='k', linestyle='none')
+    >>> plt.show()
+
+    You can create sparse output arrays to save memory and computation time.
+
+    >>> xv, yv = np.meshgrid(x, y, sparse=True)
+    >>> xv
+    array([[0. ,  0.5,  1. ]])
+    >>> yv
+    array([[0.],
+           [1.]])
+
+    `meshgrid` is very useful to evaluate functions on a grid. If the
+    function depends on all coordinates, both dense and sparse outputs can be
+    used.
+
+    >>> x = np.linspace(-5, 5, 101)
+    >>> y = np.linspace(-5, 5, 101)
+    >>> # full coordinate arrays
+    >>> xx, yy = np.meshgrid(x, y)
+    >>> zz = np.sqrt(xx**2 + yy**2)
+    >>> xx.shape, yy.shape, zz.shape
+    ((101, 101), (101, 101), (101, 101))
+    >>> # sparse coordinate arrays
+    >>> xs, ys = np.meshgrid(x, y, sparse=True)
+    >>> zs = np.sqrt(xs**2 + ys**2)
+    >>> xs.shape, ys.shape, zs.shape
+    ((1, 101), (101, 1), (101, 101))
+    >>> np.array_equal(zz, zs)
+    True
+
+    >>> h = plt.contourf(x, y, zs)
+    >>> plt.axis('scaled')
+    >>> plt.colorbar()
+    >>> plt.show()
+    """
+    ndim = len(xi)
+
+    if indexing not in ['xy', 'ij']:
+        raise ValueError(
+            "Valid values for `indexing` are 'xy' and 'ij'.")
+
+    s0 = (1,) * ndim
+    output = [np.asanyarray(x).reshape(s0[:i] + (-1,) + s0[i + 1:])
+              for i, x in enumerate(xi)]
+
+    if indexing == 'xy' and ndim > 1:
+        # switch first and second axis
+        output[0].shape = (1, -1) + s0[2:]
+        output[1].shape = (-1, 1) + s0[2:]
+
+    if not sparse:
+        # Return the full N-D matrix (not only the 1-D vector)
+        output = np.broadcast_arrays(*output, subok=True)
+
+    if copy:
+        output = tuple(x.copy() for x in output)
+
+    return output
+
+
+def _delete_dispatcher(arr, obj, axis=None):
+    return (arr, obj)
+
+
+@array_function_dispatch(_delete_dispatcher)
+def delete(arr, obj, axis=None):
+    """
+    Return a new array with sub-arrays along an axis deleted. For a one
+    dimensional array, this returns those entries not returned by
+    `arr[obj]`.
+
+    Parameters
+    ----------
+    arr : array_like
+        Input array.
+    obj : slice, int or array of ints
+        Indicate indices of sub-arrays to remove along the specified axis.
+
+        .. versionchanged:: 1.19.0
+            Boolean indices are now treated as a mask of elements to remove,
+            rather than being cast to the integers 0 and 1.
+
+    axis : int, optional
+        The axis along which to delete the subarray defined by `obj`.
+        If `axis` is None, `obj` is applied to the flattened array.
+
+    Returns
+    -------
+    out : ndarray
+        A copy of `arr` with the elements specified by `obj` removed. Note
+        that `delete` does not occur in-place. If `axis` is None, `out` is
+        a flattened array.
+
+    See Also
+    --------
+    insert : Insert elements into an array.
+    append : Append elements at the end of an array.
+
+    Notes
+    -----
+    Often it is preferable to use a boolean mask. For example:
+
+    >>> arr = np.arange(12) + 1
+    >>> mask = np.ones(len(arr), dtype=bool)
+    >>> mask[[0,2,4]] = False
+    >>> result = arr[mask,...]
+
+    Is equivalent to ``np.delete(arr, [0,2,4], axis=0)``, but allows further
+    use of `mask`.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> arr = np.array([[1,2,3,4], [5,6,7,8], [9,10,11,12]])
+    >>> arr
+    array([[ 1,  2,  3,  4],
+           [ 5,  6,  7,  8],
+           [ 9, 10, 11, 12]])
+    >>> np.delete(arr, 1, 0)
+    array([[ 1,  2,  3,  4],
+           [ 9, 10, 11, 12]])
+
+    >>> np.delete(arr, np.s_[::2], 1)
+    array([[ 2,  4],
+           [ 6,  8],
+           [10, 12]])
+    >>> np.delete(arr, [1,3,5], None)
+    array([ 1,  3,  5,  7,  8,  9, 10, 11, 12])
+
+    """
+    conv = _array_converter(arr)
+    arr, = conv.as_arrays(subok=False)
+
+    ndim = arr.ndim
+    arrorder = 'F' if arr.flags.fnc else 'C'
+    if axis is None:
+        if ndim != 1:
+            arr = arr.ravel()
+        # needed for np.matrix, which is still not 1d after being ravelled
+        ndim = arr.ndim
+        axis = ndim - 1
+    else:
+        axis = normalize_axis_index(axis, ndim)
+
+    slobj = [slice(None)]*ndim
+    N = arr.shape[axis]
+    newshape = list(arr.shape)
+
+    if isinstance(obj, slice):
+        start, stop, step = obj.indices(N)
+        xr = range(start, stop, step)
+        numtodel = len(xr)
+
+        if numtodel <= 0:
+            return conv.wrap(arr.copy(order=arrorder), to_scalar=False)
+
+        # Invert if step is negative:
+        if step < 0:
+            step = -step
+            start = xr[-1]
+            stop = xr[0] + 1
+
+        newshape[axis] -= numtodel
+        new = empty(newshape, arr.dtype, arrorder)
+        # copy initial chunk
+        if start == 0:
+            pass
+        else:
+            slobj[axis] = slice(None, start)
+            new[tuple(slobj)] = arr[tuple(slobj)]
+        # copy end chunk
+        if stop == N:
+            pass
+        else:
+            slobj[axis] = slice(stop-numtodel, None)
+            slobj2 = [slice(None)]*ndim
+            slobj2[axis] = slice(stop, None)
+            new[tuple(slobj)] = arr[tuple(slobj2)]
+        # copy middle pieces
+        if step == 1:
+            pass
+        else:  # use array indexing.
+            keep = ones(stop-start, dtype=bool)
+            keep[:stop-start:step] = False
+            slobj[axis] = slice(start, stop-numtodel)
+            slobj2 = [slice(None)]*ndim
+            slobj2[axis] = slice(start, stop)
+            arr = arr[tuple(slobj2)]
+            slobj2[axis] = keep
+            new[tuple(slobj)] = arr[tuple(slobj2)]
+
+        return conv.wrap(new, to_scalar=False)
+
+    if isinstance(obj, (int, integer)) and not isinstance(obj, bool):
+        single_value = True
+    else:
+        single_value = False
+        _obj = obj
+        obj = np.asarray(obj)
+        # `size == 0` to allow empty lists similar to indexing, but (as there)
+        # is really too generic:
+        if obj.size == 0 and not isinstance(_obj, np.ndarray):
+            obj = obj.astype(intp)
+        elif obj.size == 1 and obj.dtype.kind in "ui":
+            # For a size 1 integer array we can use the single-value path
+            # (most dtypes, except boolean, should just fail later).
+            obj = obj.item()
+            single_value = True
+
+    if single_value:
+        # optimization for a single value
+        if (obj < -N or obj >= N):
+            raise IndexError(
+                "index %i is out of bounds for axis %i with "
+                "size %i" % (obj, axis, N))
+        if (obj < 0):
+            obj += N
+        newshape[axis] -= 1
+        new = empty(newshape, arr.dtype, arrorder)
+        slobj[axis] = slice(None, obj)
+        new[tuple(slobj)] = arr[tuple(slobj)]
+        slobj[axis] = slice(obj, None)
+        slobj2 = [slice(None)]*ndim
+        slobj2[axis] = slice(obj+1, None)
+        new[tuple(slobj)] = arr[tuple(slobj2)]
+    else:
+        if obj.dtype == bool:
+            if obj.shape != (N,):
+                raise ValueError('boolean array argument obj to delete '
+                                 'must be one dimensional and match the axis '
+                                 'length of {}'.format(N))
+
+            # optimization, the other branch is slower
+            keep = ~obj
+        else:
+            keep = ones(N, dtype=bool)
+            keep[obj,] = False
+
+        slobj[axis] = keep
+        new = arr[tuple(slobj)]
+
+    return conv.wrap(new, to_scalar=False)
+
+
+def _insert_dispatcher(arr, obj, values, axis=None):
+    return (arr, obj, values)
+
+
+@array_function_dispatch(_insert_dispatcher)
+def insert(arr, obj, values, axis=None):
+    """
+    Insert values along the given axis before the given indices.
+
+    Parameters
+    ----------
+    arr : array_like
+        Input array.
+    obj : int, slice or sequence of ints
+        Object that defines the index or indices before which `values` is
+        inserted.
+
+        .. versionadded:: 1.8.0
+
+        Support for multiple insertions when `obj` is a single scalar or a
+        sequence with one element (similar to calling insert multiple
+        times).
+    values : array_like
+        Values to insert into `arr`. If the type of `values` is different
+        from that of `arr`, `values` is converted to the type of `arr`.
+        `values` should be shaped so that ``arr[...,obj,...] = values``
+        is legal.
+    axis : int, optional
+        Axis along which to insert `values`.  If `axis` is None then `arr`
+        is flattened first.
+
+    Returns
+    -------
+    out : ndarray
+        A copy of `arr` with `values` inserted.  Note that `insert`
+        does not occur in-place: a new array is returned. If
+        `axis` is None, `out` is a flattened array.
+
+    See Also
+    --------
+    append : Append elements at the end of an array.
+    concatenate : Join a sequence of arrays along an existing axis.
+    delete : Delete elements from an array.
+
+    Notes
+    -----
+    Note that for higher dimensional inserts ``obj=0`` behaves very different
+    from ``obj=[0]`` just like ``arr[:,0,:] = values`` is different from
+    ``arr[:,[0],:] = values``. This is because of the difference between basic
+    and advanced :ref:`indexing `.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> a = np.arange(6).reshape(3, 2)
+    >>> a
+    array([[0, 1],
+           [2, 3],
+           [4, 5]])
+    >>> np.insert(a, 1, 6)
+    array([0, 6, 1, 2, 3, 4, 5])
+    >>> np.insert(a, 1, 6, axis=1)
+    array([[0, 6, 1],
+           [2, 6, 3],
+           [4, 6, 5]])
+
+    Difference between sequence and scalars,
+    showing how ``obj=[1]`` behaves different from ``obj=1``:
+
+    >>> np.insert(a, [1], [[7],[8],[9]], axis=1)
+    array([[0, 7, 1],
+           [2, 8, 3],
+           [4, 9, 5]])
+    >>> np.insert(a, 1, [[7],[8],[9]], axis=1)
+    array([[0, 7, 8, 9, 1],
+           [2, 7, 8, 9, 3],
+           [4, 7, 8, 9, 5]])
+    >>> np.array_equal(np.insert(a, 1, [7, 8, 9], axis=1),
+    ...                np.insert(a, [1], [[7],[8],[9]], axis=1))
+    True
+
+    >>> b = a.flatten()
+    >>> b
+    array([0, 1, 2, 3, 4, 5])
+    >>> np.insert(b, [2, 2], [6, 7])
+    array([0, 1, 6, 7, 2, 3, 4, 5])
+
+    >>> np.insert(b, slice(2, 4), [7, 8])
+    array([0, 1, 7, 2, 8, 3, 4, 5])
+
+    >>> np.insert(b, [2, 2], [7.13, False]) # type casting
+    array([0, 1, 7, 0, 2, 3, 4, 5])
+
+    >>> x = np.arange(8).reshape(2, 4)
+    >>> idx = (1, 3)
+    >>> np.insert(x, idx, 999, axis=1)
+    array([[  0, 999,   1,   2, 999,   3],
+           [  4, 999,   5,   6, 999,   7]])
+
+    """
+    conv = _array_converter(arr)
+    arr, = conv.as_arrays(subok=False)
+
+    ndim = arr.ndim
+    arrorder = 'F' if arr.flags.fnc else 'C'
+    if axis is None:
+        if ndim != 1:
+            arr = arr.ravel()
+        # needed for np.matrix, which is still not 1d after being ravelled
+        ndim = arr.ndim
+        axis = ndim - 1
+    else:
+        axis = normalize_axis_index(axis, ndim)
+    slobj = [slice(None)]*ndim
+    N = arr.shape[axis]
+    newshape = list(arr.shape)
+
+    if isinstance(obj, slice):
+        # turn it into a range object
+        indices = arange(*obj.indices(N), dtype=intp)
+    else:
+        # need to copy obj, because indices will be changed in-place
+        indices = np.array(obj)
+        if indices.dtype == bool:
+            # See also delete
+            # 2012-10-11, NumPy 1.8
+            warnings.warn(
+                "in the future insert will treat boolean arrays and "
+                "array-likes as a boolean index instead of casting it to "
+                "integer", FutureWarning, stacklevel=2)
+            indices = indices.astype(intp)
+            # Code after warning period:
+            #if obj.ndim != 1:
+            #    raise ValueError('boolean array argument obj to insert '
+            #                     'must be one dimensional')
+            #indices = np.flatnonzero(obj)
+        elif indices.ndim > 1:
+            raise ValueError(
+                "index array argument obj to insert must be one dimensional "
+                "or scalar")
+    if indices.size == 1:
+        index = indices.item()
+        if index < -N or index > N:
+            raise IndexError(f"index {obj} is out of bounds for axis {axis} "
+                             f"with size {N}")
+        if (index < 0):
+            index += N
+
+        # There are some object array corner cases here, but we cannot avoid
+        # that:
+        values = array(values, copy=None, ndmin=arr.ndim, dtype=arr.dtype)
+        if indices.ndim == 0:
+            # broadcasting is very different here, since a[:,0,:] = ... behaves
+            # very different from a[:,[0],:] = ...! This changes values so that
+            # it works likes the second case. (here a[:,0:1,:])
+            values = np.moveaxis(values, 0, axis)
+        numnew = values.shape[axis]
+        newshape[axis] += numnew
+        new = empty(newshape, arr.dtype, arrorder)
+        slobj[axis] = slice(None, index)
+        new[tuple(slobj)] = arr[tuple(slobj)]
+        slobj[axis] = slice(index, index+numnew)
+        new[tuple(slobj)] = values
+        slobj[axis] = slice(index+numnew, None)
+        slobj2 = [slice(None)] * ndim
+        slobj2[axis] = slice(index, None)
+        new[tuple(slobj)] = arr[tuple(slobj2)]
+
+        return conv.wrap(new, to_scalar=False)
+
+    elif indices.size == 0 and not isinstance(obj, np.ndarray):
+        # Can safely cast the empty list to intp
+        indices = indices.astype(intp)
+
+    indices[indices < 0] += N
+
+    numnew = len(indices)
+    order = indices.argsort(kind='mergesort')   # stable sort
+    indices[order] += np.arange(numnew)
+
+    newshape[axis] += numnew
+    old_mask = ones(newshape[axis], dtype=bool)
+    old_mask[indices] = False
+
+    new = empty(newshape, arr.dtype, arrorder)
+    slobj2 = [slice(None)]*ndim
+    slobj[axis] = indices
+    slobj2[axis] = old_mask
+    new[tuple(slobj)] = values
+    new[tuple(slobj2)] = arr
+
+    return conv.wrap(new, to_scalar=False)
+
+
+def _append_dispatcher(arr, values, axis=None):
+    return (arr, values)
+
+
+@array_function_dispatch(_append_dispatcher)
+def append(arr, values, axis=None):
+    """
+    Append values to the end of an array.
+
+    Parameters
+    ----------
+    arr : array_like
+        Values are appended to a copy of this array.
+    values : array_like
+        These values are appended to a copy of `arr`.  It must be of the
+        correct shape (the same shape as `arr`, excluding `axis`).  If
+        `axis` is not specified, `values` can be any shape and will be
+        flattened before use.
+    axis : int, optional
+        The axis along which `values` are appended.  If `axis` is not
+        given, both `arr` and `values` are flattened before use.
+
+    Returns
+    -------
+    append : ndarray
+        A copy of `arr` with `values` appended to `axis`.  Note that
+        `append` does not occur in-place: a new array is allocated and
+        filled.  If `axis` is None, `out` is a flattened array.
+
+    See Also
+    --------
+    insert : Insert elements into an array.
+    delete : Delete elements from an array.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> np.append([1, 2, 3], [[4, 5, 6], [7, 8, 9]])
+    array([1, 2, 3, ..., 7, 8, 9])
+
+    When `axis` is specified, `values` must have the correct shape.
+
+    >>> np.append([[1, 2, 3], [4, 5, 6]], [[7, 8, 9]], axis=0)
+    array([[1, 2, 3],
+           [4, 5, 6],
+           [7, 8, 9]])
+
+    >>> np.append([[1, 2, 3], [4, 5, 6]], [7, 8, 9], axis=0)
+    Traceback (most recent call last):
+        ...
+    ValueError: all the input arrays must have same number of dimensions, but
+    the array at index 0 has 2 dimension(s) and the array at index 1 has 1
+    dimension(s)
+
+    >>> a = np.array([1, 2], dtype=int)
+    >>> c = np.append(a, [])
+    >>> c
+    array([1., 2.])
+    >>> c.dtype
+    float64
+
+    Default dtype for empty ndarrays is `float64` thus making the output of dtype
+    `float64` when appended with dtype `int64`
+
+    """
+    arr = asanyarray(arr)
+    if axis is None:
+        if arr.ndim != 1:
+            arr = arr.ravel()
+        values = ravel(values)
+        axis = arr.ndim-1
+    return concatenate((arr, values), axis=axis)
+
+
+def _digitize_dispatcher(x, bins, right=None):
+    return (x, bins)
+
+
+@array_function_dispatch(_digitize_dispatcher)
+def digitize(x, bins, right=False):
+    """
+    Return the indices of the bins to which each value in input array belongs.
+
+    =========  =============  ============================
+    `right`    order of bins  returned index `i` satisfies
+    =========  =============  ============================
+    ``False``  increasing     ``bins[i-1] <= x < bins[i]``
+    ``True``   increasing     ``bins[i-1] < x <= bins[i]``
+    ``False``  decreasing     ``bins[i-1] > x >= bins[i]``
+    ``True``   decreasing     ``bins[i-1] >= x > bins[i]``
+    =========  =============  ============================
+
+    If values in `x` are beyond the bounds of `bins`, 0 or ``len(bins)`` is
+    returned as appropriate.
+
+    Parameters
+    ----------
+    x : array_like
+        Input array to be binned. Prior to NumPy 1.10.0, this array had to
+        be 1-dimensional, but can now have any shape.
+    bins : array_like
+        Array of bins. It has to be 1-dimensional and monotonic.
+    right : bool, optional
+        Indicating whether the intervals include the right or the left bin
+        edge. Default behavior is (right==False) indicating that the interval
+        does not include the right edge. The left bin end is open in this
+        case, i.e., bins[i-1] <= x < bins[i] is the default behavior for
+        monotonically increasing bins.
+
+    Returns
+    -------
+    indices : ndarray of ints
+        Output array of indices, of same shape as `x`.
+
+    Raises
+    ------
+    ValueError
+        If `bins` is not monotonic.
+    TypeError
+        If the type of the input is complex.
+
+    See Also
+    --------
+    bincount, histogram, unique, searchsorted
+
+    Notes
+    -----
+    If values in `x` are such that they fall outside the bin range,
+    attempting to index `bins` with the indices that `digitize` returns
+    will result in an IndexError.
+
+    .. versionadded:: 1.10.0
+
+    `numpy.digitize` is  implemented in terms of `numpy.searchsorted`.
+    This means that a binary search is used to bin the values, which scales
+    much better for larger number of bins than the previous linear search.
+    It also removes the requirement for the input array to be 1-dimensional.
+
+    For monotonically *increasing* `bins`, the following are equivalent::
+
+        np.digitize(x, bins, right=True)
+        np.searchsorted(bins, x, side='left')
+
+    Note that as the order of the arguments are reversed, the side must be too.
+    The `searchsorted` call is marginally faster, as it does not do any
+    monotonicity checks. Perhaps more importantly, it supports all dtypes.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> x = np.array([0.2, 6.4, 3.0, 1.6])
+    >>> bins = np.array([0.0, 1.0, 2.5, 4.0, 10.0])
+    >>> inds = np.digitize(x, bins)
+    >>> inds
+    array([1, 4, 3, 2])
+    >>> for n in range(x.size):
+    ...   print(bins[inds[n]-1], "<=", x[n], "<", bins[inds[n]])
+    ...
+    0.0 <= 0.2 < 1.0
+    4.0 <= 6.4 < 10.0
+    2.5 <= 3.0 < 4.0
+    1.0 <= 1.6 < 2.5
+
+    >>> x = np.array([1.2, 10.0, 12.4, 15.5, 20.])
+    >>> bins = np.array([0, 5, 10, 15, 20])
+    >>> np.digitize(x,bins,right=True)
+    array([1, 2, 3, 4, 4])
+    >>> np.digitize(x,bins,right=False)
+    array([1, 3, 3, 4, 5])
+    """
+    x = _nx.asarray(x)
+    bins = _nx.asarray(bins)
+
+    # here for compatibility, searchsorted below is happy to take this
+    if np.issubdtype(x.dtype, _nx.complexfloating):
+        raise TypeError("x may not be complex")
+
+    mono = _monotonicity(bins)
+    if mono == 0:
+        raise ValueError("bins must be monotonically increasing or decreasing")
+
+    # this is backwards because the arguments below are swapped
+    side = 'left' if right else 'right'
+    if mono == -1:
+        # reverse the bins, and invert the results
+        return len(bins) - _nx.searchsorted(bins[::-1], x, side=side)
+    else:
+        return _nx.searchsorted(bins, x, side=side)
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/_function_base_impl.pyi b/venv/lib/python3.12/site-packages/numpy/lib/_function_base_impl.pyi
new file mode 100644
index 00000000..5dee76e1
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/lib/_function_base_impl.pyi
@@ -0,0 +1,775 @@
+from collections.abc import Sequence, Iterator, Callable, Iterable
+from typing import (
+    Literal as L,
+    Any,
+    TypeVar,
+    overload,
+    Protocol,
+    SupportsIndex,
+    SupportsInt,
+    TypeGuard
+)
+
+from numpy import (
+    vectorize as vectorize,
+    generic,
+    integer,
+    floating,
+    complexfloating,
+    intp,
+    float64,
+    complex128,
+    timedelta64,
+    datetime64,
+    object_,
+    bool as bool_,
+    _OrderKACF,
+)
+
+from numpy._typing import (
+    NDArray,
+    ArrayLike,
+    DTypeLike,
+    _ShapeLike,
+    _ScalarLike_co,
+    _DTypeLike,
+    _ArrayLike,
+    _ArrayLikeInt_co,
+    _ArrayLikeFloat_co,
+    _ArrayLikeComplex_co,
+    _ArrayLikeTD64_co,
+    _ArrayLikeDT64_co,
+    _ArrayLikeObject_co,
+    _FloatLike_co,
+    _ComplexLike_co,
+)
+
+from numpy._core.multiarray import (
+    bincount as bincount,
+)
+
+_T = TypeVar("_T")
+_T_co = TypeVar("_T_co", covariant=True)
+_SCT = TypeVar("_SCT", bound=generic)
+_ArrayType = TypeVar("_ArrayType", bound=NDArray[Any])
+
+_2Tuple = tuple[_T, _T]
+
+class _TrimZerosSequence(Protocol[_T_co]):
+    def __len__(self) -> int: ...
+    def __getitem__(self, key: slice, /) -> _T_co: ...
+    def __iter__(self) -> Iterator[Any]: ...
+
+class _SupportsWriteFlush(Protocol):
+    def write(self, s: str, /) -> object: ...
+    def flush(self) -> object: ...
+
+__all__: list[str]
+
+@overload
+def rot90(
+    m: _ArrayLike[_SCT],
+    k: int = ...,
+    axes: tuple[int, int] = ...,
+) -> NDArray[_SCT]: ...
+@overload
+def rot90(
+    m: ArrayLike,
+    k: int = ...,
+    axes: tuple[int, int] = ...,
+) -> NDArray[Any]: ...
+
+@overload
+def flip(m: _SCT, axis: None = ...) -> _SCT: ...
+@overload
+def flip(m: _ScalarLike_co, axis: None = ...) -> Any: ...
+@overload
+def flip(m: _ArrayLike[_SCT], axis: None | _ShapeLike = ...) -> NDArray[_SCT]: ...
+@overload
+def flip(m: ArrayLike, axis: None | _ShapeLike = ...) -> NDArray[Any]: ...
+
+def iterable(y: object) -> TypeGuard[Iterable[Any]]: ...
+
+@overload
+def average(
+    a: _ArrayLikeFloat_co,
+    axis: None = ...,
+    weights: None | _ArrayLikeFloat_co= ...,
+    returned: L[False] = ...,
+    keepdims: L[False] = ...,
+) -> floating[Any]: ...
+@overload
+def average(
+    a: _ArrayLikeComplex_co,
+    axis: None = ...,
+    weights: None | _ArrayLikeComplex_co = ...,
+    returned: L[False] = ...,
+    keepdims: L[False] = ...,
+) -> complexfloating[Any, Any]: ...
+@overload
+def average(
+    a: _ArrayLikeObject_co,
+    axis: None = ...,
+    weights: None | Any = ...,
+    returned: L[False] = ...,
+    keepdims: L[False] = ...,
+) -> Any: ...
+@overload
+def average(
+    a: _ArrayLikeFloat_co,
+    axis: None = ...,
+    weights: None | _ArrayLikeFloat_co= ...,
+    returned: L[True] = ...,
+    keepdims: L[False] = ...,
+) -> _2Tuple[floating[Any]]: ...
+@overload
+def average(
+    a: _ArrayLikeComplex_co,
+    axis: None = ...,
+    weights: None | _ArrayLikeComplex_co = ...,
+    returned: L[True] = ...,
+    keepdims: L[False] = ...,
+) -> _2Tuple[complexfloating[Any, Any]]: ...
+@overload
+def average(
+    a: _ArrayLikeObject_co,
+    axis: None = ...,
+    weights: None | Any = ...,
+    returned: L[True] = ...,
+    keepdims: L[False] = ...,
+) -> _2Tuple[Any]: ...
+@overload
+def average(
+    a: _ArrayLikeComplex_co | _ArrayLikeObject_co,
+    axis: None | _ShapeLike = ...,
+    weights: None | Any = ...,
+    returned: L[False] = ...,
+    keepdims: bool = ...,
+) -> Any: ...
+@overload
+def average(
+    a: _ArrayLikeComplex_co | _ArrayLikeObject_co,
+    axis: None | _ShapeLike = ...,
+    weights: None | Any = ...,
+    returned: L[True] = ...,
+    keepdims: bool = ...,
+) -> _2Tuple[Any]: ...
+
+@overload
+def asarray_chkfinite(
+    a: _ArrayLike[_SCT],
+    dtype: None = ...,
+    order: _OrderKACF = ...,
+) -> NDArray[_SCT]: ...
+@overload
+def asarray_chkfinite(
+    a: object,
+    dtype: None = ...,
+    order: _OrderKACF = ...,
+) -> NDArray[Any]: ...
+@overload
+def asarray_chkfinite(
+    a: Any,
+    dtype: _DTypeLike[_SCT],
+    order: _OrderKACF = ...,
+) -> NDArray[_SCT]: ...
+@overload
+def asarray_chkfinite(
+    a: Any,
+    dtype: DTypeLike,
+    order: _OrderKACF = ...,
+) -> NDArray[Any]: ...
+
+# TODO: Use PEP 612 `ParamSpec` once mypy supports `Concatenate`
+# xref python/mypy#8645
+@overload
+def piecewise(
+    x: _ArrayLike[_SCT],
+    condlist: ArrayLike,
+    funclist: Sequence[Any | Callable[..., Any]],
+    *args: Any,
+    **kw: Any,
+) -> NDArray[_SCT]: ...
+@overload
+def piecewise(
+    x: ArrayLike,
+    condlist: ArrayLike,
+    funclist: Sequence[Any | Callable[..., Any]],
+    *args: Any,
+    **kw: Any,
+) -> NDArray[Any]: ...
+
+def select(
+    condlist: Sequence[ArrayLike],
+    choicelist: Sequence[ArrayLike],
+    default: ArrayLike = ...,
+) -> NDArray[Any]: ...
+
+@overload
+def copy(
+    a: _ArrayType,
+    order: _OrderKACF,
+    subok: L[True],
+) -> _ArrayType: ...
+@overload
+def copy(
+    a: _ArrayType,
+    order: _OrderKACF = ...,
+    *,
+    subok: L[True],
+) -> _ArrayType: ...
+@overload
+def copy(
+    a: _ArrayLike[_SCT],
+    order: _OrderKACF = ...,
+    subok: L[False] = ...,
+) -> NDArray[_SCT]: ...
+@overload
+def copy(
+    a: ArrayLike,
+    order: _OrderKACF = ...,
+    subok: L[False] = ...,
+) -> NDArray[Any]: ...
+
+def gradient(
+    f: ArrayLike,
+    *varargs: ArrayLike,
+    axis: None | _ShapeLike = ...,
+    edge_order: L[1, 2] = ...,
+) -> Any: ...
+
+@overload
+def diff(
+    a: _T,
+    n: L[0],
+    axis: SupportsIndex = ...,
+    prepend: ArrayLike = ...,
+    append: ArrayLike = ...,
+) -> _T: ...
+@overload
+def diff(
+    a: ArrayLike,
+    n: int = ...,
+    axis: SupportsIndex = ...,
+    prepend: ArrayLike = ...,
+    append: ArrayLike = ...,
+) -> NDArray[Any]: ...
+
+@overload
+def interp(
+    x: _ArrayLikeFloat_co,
+    xp: _ArrayLikeFloat_co,
+    fp: _ArrayLikeFloat_co,
+    left: None | _FloatLike_co = ...,
+    right: None | _FloatLike_co = ...,
+    period: None | _FloatLike_co = ...,
+) -> NDArray[float64]: ...
+@overload
+def interp(
+    x: _ArrayLikeFloat_co,
+    xp: _ArrayLikeFloat_co,
+    fp: _ArrayLikeComplex_co,
+    left: None | _ComplexLike_co = ...,
+    right: None | _ComplexLike_co = ...,
+    period: None | _FloatLike_co = ...,
+) -> NDArray[complex128]: ...
+
+@overload
+def angle(z: _ComplexLike_co, deg: bool = ...) -> floating[Any]: ...
+@overload
+def angle(z: object_, deg: bool = ...) -> Any: ...
+@overload
+def angle(z: _ArrayLikeComplex_co, deg: bool = ...) -> NDArray[floating[Any]]: ...
+@overload
+def angle(z: _ArrayLikeObject_co, deg: bool = ...) -> NDArray[object_]: ...
+
+@overload
+def unwrap(
+    p: _ArrayLikeFloat_co,
+    discont: None | float = ...,
+    axis: int = ...,
+    *,
+    period: float = ...,
+) -> NDArray[floating[Any]]: ...
+@overload
+def unwrap(
+    p: _ArrayLikeObject_co,
+    discont: None | float = ...,
+    axis: int = ...,
+    *,
+    period: float = ...,
+) -> NDArray[object_]: ...
+
+def sort_complex(a: ArrayLike) -> NDArray[complexfloating[Any, Any]]: ...
+
+def trim_zeros(
+    filt: _TrimZerosSequence[_T],
+    trim: L["f", "b", "fb", "bf"] = ...,
+) -> _T: ...
+
+@overload
+def extract(condition: ArrayLike, arr: _ArrayLike[_SCT]) -> NDArray[_SCT]: ...
+@overload
+def extract(condition: ArrayLike, arr: ArrayLike) -> NDArray[Any]: ...
+
+def place(arr: NDArray[Any], mask: ArrayLike, vals: Any) -> None: ...
+
+@overload
+def cov(
+    m: _ArrayLikeFloat_co,
+    y: None | _ArrayLikeFloat_co = ...,
+    rowvar: bool = ...,
+    bias: bool = ...,
+    ddof: None | SupportsIndex | SupportsInt = ...,
+    fweights: None | ArrayLike = ...,
+    aweights: None | ArrayLike = ...,
+    *,
+    dtype: None = ...,
+) -> NDArray[floating[Any]]: ...
+@overload
+def cov(
+    m: _ArrayLikeComplex_co,
+    y: None | _ArrayLikeComplex_co = ...,
+    rowvar: bool = ...,
+    bias: bool = ...,
+    ddof: None | SupportsIndex | SupportsInt = ...,
+    fweights: None | ArrayLike = ...,
+    aweights: None | ArrayLike = ...,
+    *,
+    dtype: None = ...,
+) -> NDArray[complexfloating[Any, Any]]: ...
+@overload
+def cov(
+    m: _ArrayLikeComplex_co,
+    y: None | _ArrayLikeComplex_co = ...,
+    rowvar: bool = ...,
+    bias: bool = ...,
+    ddof: None | SupportsIndex | SupportsInt = ...,
+    fweights: None | ArrayLike = ...,
+    aweights: None | ArrayLike = ...,
+    *,
+    dtype: _DTypeLike[_SCT],
+) -> NDArray[_SCT]: ...
+@overload
+def cov(
+    m: _ArrayLikeComplex_co,
+    y: None | _ArrayLikeComplex_co = ...,
+    rowvar: bool = ...,
+    bias: bool = ...,
+    ddof: None | SupportsIndex | SupportsInt = ...,
+    fweights: None | ArrayLike = ...,
+    aweights: None | ArrayLike = ...,
+    *,
+    dtype: DTypeLike,
+) -> NDArray[Any]: ...
+
+# NOTE `bias` and `ddof` have been deprecated
+@overload
+def corrcoef(
+    m: _ArrayLikeFloat_co,
+    y: None | _ArrayLikeFloat_co = ...,
+    rowvar: bool = ...,
+    *,
+    dtype: None = ...,
+) -> NDArray[floating[Any]]: ...
+@overload
+def corrcoef(
+    m: _ArrayLikeComplex_co,
+    y: None | _ArrayLikeComplex_co = ...,
+    rowvar: bool = ...,
+    *,
+    dtype: None = ...,
+) -> NDArray[complexfloating[Any, Any]]: ...
+@overload
+def corrcoef(
+    m: _ArrayLikeComplex_co,
+    y: None | _ArrayLikeComplex_co = ...,
+    rowvar: bool = ...,
+    *,
+    dtype: _DTypeLike[_SCT],
+) -> NDArray[_SCT]: ...
+@overload
+def corrcoef(
+    m: _ArrayLikeComplex_co,
+    y: None | _ArrayLikeComplex_co = ...,
+    rowvar: bool = ...,
+    *,
+    dtype: DTypeLike,
+) -> NDArray[Any]: ...
+
+def blackman(M: _FloatLike_co) -> NDArray[floating[Any]]: ...
+
+def bartlett(M: _FloatLike_co) -> NDArray[floating[Any]]: ...
+
+def hanning(M: _FloatLike_co) -> NDArray[floating[Any]]: ...
+
+def hamming(M: _FloatLike_co) -> NDArray[floating[Any]]: ...
+
+def i0(x: _ArrayLikeFloat_co) -> NDArray[floating[Any]]: ...
+
+def kaiser(
+    M: _FloatLike_co,
+    beta: _FloatLike_co,
+) -> NDArray[floating[Any]]: ...
+
+@overload
+def sinc(x: _FloatLike_co) -> floating[Any]: ...
+@overload
+def sinc(x: _ComplexLike_co) -> complexfloating[Any, Any]: ...
+@overload
+def sinc(x: _ArrayLikeFloat_co) -> NDArray[floating[Any]]: ...
+@overload
+def sinc(x: _ArrayLikeComplex_co) -> NDArray[complexfloating[Any, Any]]: ...
+
+@overload
+def median(
+    a: _ArrayLikeFloat_co,
+    axis: None = ...,
+    out: None = ...,
+    overwrite_input: bool = ...,
+    keepdims: L[False] = ...,
+) -> floating[Any]: ...
+@overload
+def median(
+    a: _ArrayLikeComplex_co,
+    axis: None = ...,
+    out: None = ...,
+    overwrite_input: bool = ...,
+    keepdims: L[False] = ...,
+) -> complexfloating[Any, Any]: ...
+@overload
+def median(
+    a: _ArrayLikeTD64_co,
+    axis: None = ...,
+    out: None = ...,
+    overwrite_input: bool = ...,
+    keepdims: L[False] = ...,
+) -> timedelta64: ...
+@overload
+def median(
+    a: _ArrayLikeObject_co,
+    axis: None = ...,
+    out: None = ...,
+    overwrite_input: bool = ...,
+    keepdims: L[False] = ...,
+) -> Any: ...
+@overload
+def median(
+    a: _ArrayLikeFloat_co | _ArrayLikeComplex_co | _ArrayLikeTD64_co | _ArrayLikeObject_co,
+    axis: None | _ShapeLike = ...,
+    out: None = ...,
+    overwrite_input: bool = ...,
+    keepdims: bool = ...,
+) -> Any: ...
+@overload
+def median(
+    a: _ArrayLikeFloat_co | _ArrayLikeComplex_co | _ArrayLikeTD64_co | _ArrayLikeObject_co,
+    axis: None | _ShapeLike,
+    out: _ArrayType,
+    /,
+    overwrite_input: bool = ...,
+    keepdims: bool = ...,
+) -> _ArrayType: ...
+@overload
+def median(
+    a: _ArrayLikeFloat_co | _ArrayLikeComplex_co | _ArrayLikeTD64_co | _ArrayLikeObject_co,
+    axis: None | _ShapeLike = ...,
+    *,
+    out: _ArrayType,
+    overwrite_input: bool = ...,
+    keepdims: bool = ...,
+) -> _ArrayType: ...
+
+_MethodKind = L[
+    "inverted_cdf",
+    "averaged_inverted_cdf",
+    "closest_observation",
+    "interpolated_inverted_cdf",
+    "hazen",
+    "weibull",
+    "linear",
+    "median_unbiased",
+    "normal_unbiased",
+    "lower",
+    "higher",
+    "midpoint",
+    "nearest",
+]
+
+@overload
+def percentile(
+    a: _ArrayLikeFloat_co,
+    q: _FloatLike_co,
+    axis: None = ...,
+    out: None = ...,
+    overwrite_input: bool = ...,
+    method: _MethodKind = ...,
+    keepdims: L[False] = ...,
+    *,
+    weights: None | _ArrayLikeFloat_co = ...,
+) -> floating[Any]: ...
+@overload
+def percentile(
+    a: _ArrayLikeComplex_co,
+    q: _FloatLike_co,
+    axis: None = ...,
+    out: None = ...,
+    overwrite_input: bool = ...,
+    method: _MethodKind = ...,
+    keepdims: L[False] = ...,
+    *,
+    weights: None | _ArrayLikeFloat_co = ...,
+) -> complexfloating[Any, Any]: ...
+@overload
+def percentile(
+    a: _ArrayLikeTD64_co,
+    q: _FloatLike_co,
+    axis: None = ...,
+    out: None = ...,
+    overwrite_input: bool = ...,
+    method: _MethodKind = ...,
+    keepdims: L[False] = ...,
+    *,
+    weights: None | _ArrayLikeFloat_co = ...,
+) -> timedelta64: ...
+@overload
+def percentile(
+    a: _ArrayLikeDT64_co,
+    q: _FloatLike_co,
+    axis: None = ...,
+    out: None = ...,
+    overwrite_input: bool = ...,
+    method: _MethodKind = ...,
+    keepdims: L[False] = ...,
+    *,
+    weights: None | _ArrayLikeFloat_co = ...,
+) -> datetime64: ...
+@overload
+def percentile(
+    a: _ArrayLikeObject_co,
+    q: _FloatLike_co,
+    axis: None = ...,
+    out: None = ...,
+    overwrite_input: bool = ...,
+    method: _MethodKind = ...,
+    keepdims: L[False] = ...,
+    *,
+    weights: None | _ArrayLikeFloat_co = ...,
+) -> Any: ...
+@overload
+def percentile(
+    a: _ArrayLikeFloat_co,
+    q: _ArrayLikeFloat_co,
+    axis: None = ...,
+    out: None = ...,
+    overwrite_input: bool = ...,
+    method: _MethodKind = ...,
+    keepdims: L[False] = ...,
+    *,
+    weights: None | _ArrayLikeFloat_co = ...,
+) -> NDArray[floating[Any]]: ...
+@overload
+def percentile(
+    a: _ArrayLikeComplex_co,
+    q: _ArrayLikeFloat_co,
+    axis: None = ...,
+    out: None = ...,
+    overwrite_input: bool = ...,
+    method: _MethodKind = ...,
+    keepdims: L[False] = ...,
+    *,
+    weights: None | _ArrayLikeFloat_co = ...,
+) -> NDArray[complexfloating[Any, Any]]: ...
+@overload
+def percentile(
+    a: _ArrayLikeTD64_co,
+    q: _ArrayLikeFloat_co,
+    axis: None = ...,
+    out: None = ...,
+    overwrite_input: bool = ...,
+    method: _MethodKind = ...,
+    keepdims: L[False] = ...,
+    *,
+    weights: None | _ArrayLikeFloat_co = ...,
+) -> NDArray[timedelta64]: ...
+@overload
+def percentile(
+    a: _ArrayLikeDT64_co,
+    q: _ArrayLikeFloat_co,
+    axis: None = ...,
+    out: None = ...,
+    overwrite_input: bool = ...,
+    method: _MethodKind = ...,
+    keepdims: L[False] = ...,
+    *,
+    weights: None | _ArrayLikeFloat_co = ...,
+) -> NDArray[datetime64]: ...
+@overload
+def percentile(
+    a: _ArrayLikeObject_co,
+    q: _ArrayLikeFloat_co,
+    axis: None = ...,
+    out: None = ...,
+    overwrite_input: bool = ...,
+    method: _MethodKind = ...,
+    keepdims: L[False] = ...,
+    *,
+    weights: None | _ArrayLikeFloat_co = ...,
+) -> NDArray[object_]: ...
+@overload
+def percentile(
+    a: _ArrayLikeComplex_co | _ArrayLikeTD64_co | _ArrayLikeTD64_co | _ArrayLikeObject_co,
+    q: _ArrayLikeFloat_co,
+    axis: None | _ShapeLike = ...,
+    out: None = ...,
+    overwrite_input: bool = ...,
+    method: _MethodKind = ...,
+    keepdims: bool = ...,
+    *,
+    weights: None | _ArrayLikeFloat_co = ...,
+) -> Any: ...
+@overload
+def percentile(
+    a: _ArrayLikeComplex_co | _ArrayLikeTD64_co | _ArrayLikeTD64_co | _ArrayLikeObject_co,
+    q: _ArrayLikeFloat_co,
+    axis: None | _ShapeLike,
+    out: _ArrayType,
+    /,
+    overwrite_input: bool = ...,
+    method: _MethodKind = ...,
+    keepdims: bool = ...,
+    *,
+    weights: None | _ArrayLikeFloat_co = ...,
+) -> _ArrayType: ...
+@overload
+def percentile(
+    a: _ArrayLikeComplex_co | _ArrayLikeTD64_co | _ArrayLikeTD64_co | _ArrayLikeObject_co,
+    q: _ArrayLikeFloat_co,
+    axis: None | _ShapeLike = ...,
+    *,
+    out: _ArrayType,
+    overwrite_input: bool = ...,
+    method: _MethodKind = ...,
+    keepdims: bool = ...,
+    weights: None | _ArrayLikeFloat_co = ...,
+) -> _ArrayType: ...
+
+# NOTE: Not an alias, but they do have identical signatures
+# (that we can reuse)
+quantile = percentile
+
+
+_SCT_fm = TypeVar(
+    "_SCT_fm",
+    bound=floating[Any] | complexfloating[Any, Any] | timedelta64,
+)
+
+class _SupportsRMulFloat(Protocol[_T_co]):
+    def __rmul__(self, other: float, /) -> _T_co: ...
+
+@overload
+def trapezoid(  # type: ignore[overload-overlap]
+    y: Sequence[_FloatLike_co],
+    x: Sequence[_FloatLike_co] | None = ...,
+    dx: float = ...,
+    axis: SupportsIndex = ...,
+) -> float64: ...
+@overload
+def trapezoid(
+    y: Sequence[_ComplexLike_co],
+    x: Sequence[_ComplexLike_co] | None = ...,
+    dx: float = ...,
+    axis: SupportsIndex = ...,
+) -> complex128: ...
+@overload
+def trapezoid(
+    y: _ArrayLike[bool_ | integer[Any]],
+    x: _ArrayLike[bool_ | integer[Any]] | None = ...,
+    dx: float = ...,
+    axis: SupportsIndex = ...,
+) -> float64 | NDArray[float64]: ...
+@overload
+def trapezoid(  # type: ignore[overload-overlap]
+    y: _ArrayLikeObject_co,
+    x: _ArrayLikeFloat_co | _ArrayLikeObject_co | None = ...,
+    dx: float = ...,
+    axis: SupportsIndex = ...,
+) -> float | NDArray[object_]: ...
+@overload
+def trapezoid(
+    y: _ArrayLike[_SCT_fm],
+    x: _ArrayLike[_SCT_fm] | _ArrayLikeInt_co | None = ...,
+    dx: float = ...,
+    axis: SupportsIndex = ...,
+) -> _SCT_fm | NDArray[_SCT_fm]: ...
+@overload
+def trapezoid(
+    y: Sequence[_SupportsRMulFloat[_T]],
+    x: Sequence[_SupportsRMulFloat[_T] | _T] | None = ...,
+    dx: float = ...,
+    axis: SupportsIndex = ...,
+) -> _T: ...
+@overload
+def trapezoid(
+    y: _ArrayLikeComplex_co | _ArrayLikeTD64_co | _ArrayLikeObject_co,
+    x: _ArrayLikeComplex_co | _ArrayLikeTD64_co | _ArrayLikeObject_co | None = ...,
+    dx: float = ...,
+    axis: SupportsIndex = ...,
+) -> (
+    floating[Any] | complexfloating[Any, Any] | timedelta64
+    | NDArray[floating[Any] | complexfloating[Any, Any] | timedelta64 | object_]
+): ...
+
+def meshgrid(
+    *xi: ArrayLike,
+    copy: bool = ...,
+    sparse: bool = ...,
+    indexing: L["xy", "ij"] = ...,
+) -> tuple[NDArray[Any], ...]: ...
+
+@overload
+def delete(
+    arr: _ArrayLike[_SCT],
+    obj: slice | _ArrayLikeInt_co,
+    axis: None | SupportsIndex = ...,
+) -> NDArray[_SCT]: ...
+@overload
+def delete(
+    arr: ArrayLike,
+    obj: slice | _ArrayLikeInt_co,
+    axis: None | SupportsIndex = ...,
+) -> NDArray[Any]: ...
+
+@overload
+def insert(
+    arr: _ArrayLike[_SCT],
+    obj: slice | _ArrayLikeInt_co,
+    values: ArrayLike,
+    axis: None | SupportsIndex = ...,
+) -> NDArray[_SCT]: ...
+@overload
+def insert(
+    arr: ArrayLike,
+    obj: slice | _ArrayLikeInt_co,
+    values: ArrayLike,
+    axis: None | SupportsIndex = ...,
+) -> NDArray[Any]: ...
+
+def append(
+    arr: ArrayLike,
+    values: ArrayLike,
+    axis: None | SupportsIndex = ...,
+) -> NDArray[Any]: ...
+
+@overload
+def digitize(
+    x: _FloatLike_co,
+    bins: _ArrayLikeFloat_co,
+    right: bool = ...,
+) -> intp: ...
+@overload
+def digitize(
+    x: _ArrayLikeFloat_co,
+    bins: _ArrayLikeFloat_co,
+    right: bool = ...,
+) -> NDArray[intp]: ...
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/_histograms_impl.py b/venv/lib/python3.12/site-packages/numpy/lib/_histograms_impl.py
new file mode 100644
index 00000000..45b6500e
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/lib/_histograms_impl.py
@@ -0,0 +1,1091 @@
+"""
+Histogram-related functions
+"""
+import contextlib
+import functools
+import operator
+import warnings
+
+import numpy as np
+from numpy._core import overrides
+
+__all__ = ['histogram', 'histogramdd', 'histogram_bin_edges']
+
+array_function_dispatch = functools.partial(
+    overrides.array_function_dispatch, module='numpy')
+
+# range is a keyword argument to many functions, so save the builtin so they can
+# use it.
+_range = range
+
+
+def _ptp(x):
+    """Peak-to-peak value of x.
+
+    This implementation avoids the problem of signed integer arrays having a
+    peak-to-peak value that cannot be represented with the array's data type.
+    This function returns an unsigned value for signed integer arrays.
+    """
+    return _unsigned_subtract(x.max(), x.min())
+
+
+def _hist_bin_sqrt(x, range):
+    """
+    Square root histogram bin estimator.
+
+    Bin width is inversely proportional to the data size. Used by many
+    programs for its simplicity.
+
+    Parameters
+    ----------
+    x : array_like
+        Input data that is to be histogrammed, trimmed to range. May not
+        be empty.
+
+    Returns
+    -------
+    h : An estimate of the optimal bin width for the given data.
+    """
+    del range  # unused
+    return _ptp(x) / np.sqrt(x.size)
+
+
+def _hist_bin_sturges(x, range):
+    """
+    Sturges histogram bin estimator.
+
+    A very simplistic estimator based on the assumption of normality of
+    the data. This estimator has poor performance for non-normal data,
+    which becomes especially obvious for large data sets. The estimate
+    depends only on size of the data.
+
+    Parameters
+    ----------
+    x : array_like
+        Input data that is to be histogrammed, trimmed to range. May not
+        be empty.
+
+    Returns
+    -------
+    h : An estimate of the optimal bin width for the given data.
+    """
+    del range  # unused
+    return _ptp(x) / (np.log2(x.size) + 1.0)
+
+
+def _hist_bin_rice(x, range):
+    """
+    Rice histogram bin estimator.
+
+    Another simple estimator with no normality assumption. It has better
+    performance for large data than Sturges, but tends to overestimate
+    the number of bins. The number of bins is proportional to the cube
+    root of data size (asymptotically optimal). The estimate depends
+    only on size of the data.
+
+    Parameters
+    ----------
+    x : array_like
+        Input data that is to be histogrammed, trimmed to range. May not
+        be empty.
+
+    Returns
+    -------
+    h : An estimate of the optimal bin width for the given data.
+    """
+    del range  # unused
+    return _ptp(x) / (2.0 * x.size ** (1.0 / 3))
+
+
+def _hist_bin_scott(x, range):
+    """
+    Scott histogram bin estimator.
+
+    The binwidth is proportional to the standard deviation of the data
+    and inversely proportional to the cube root of data size
+    (asymptotically optimal).
+
+    Parameters
+    ----------
+    x : array_like
+        Input data that is to be histogrammed, trimmed to range. May not
+        be empty.
+
+    Returns
+    -------
+    h : An estimate of the optimal bin width for the given data.
+    """
+    del range  # unused
+    return (24.0 * np.pi**0.5 / x.size)**(1.0 / 3.0) * np.std(x)
+
+
+def _hist_bin_stone(x, range):
+    """
+    Histogram bin estimator based on minimizing the estimated integrated squared error (ISE).
+
+    The number of bins is chosen by minimizing the estimated ISE against the unknown true distribution.
+    The ISE is estimated using cross-validation and can be regarded as a generalization of Scott's rule.
+    https://en.wikipedia.org/wiki/Histogram#Scott.27s_normal_reference_rule
+
+    This paper by Stone appears to be the origination of this rule.
+    https://digitalassets.lib.berkeley.edu/sdtr/ucb/text/34.pdf
+
+    Parameters
+    ----------
+    x : array_like
+        Input data that is to be histogrammed, trimmed to range. May not
+        be empty.
+    range : (float, float)
+        The lower and upper range of the bins.
+
+    Returns
+    -------
+    h : An estimate of the optimal bin width for the given data.
+    """
+
+    n = x.size
+    ptp_x = _ptp(x)
+    if n <= 1 or ptp_x == 0:
+        return 0
+
+    def jhat(nbins):
+        hh = ptp_x / nbins
+        p_k = np.histogram(x, bins=nbins, range=range)[0] / n
+        return (2 - (n + 1) * p_k.dot(p_k)) / hh
+
+    nbins_upper_bound = max(100, int(np.sqrt(n)))
+    nbins = min(_range(1, nbins_upper_bound + 1), key=jhat)
+    if nbins == nbins_upper_bound:
+        warnings.warn("The number of bins estimated may be suboptimal.",
+                      RuntimeWarning, stacklevel=3)
+    return ptp_x / nbins
+
+
+def _hist_bin_doane(x, range):
+    """
+    Doane's histogram bin estimator.
+
+    Improved version of Sturges' formula which works better for
+    non-normal data. See
+    stats.stackexchange.com/questions/55134/doanes-formula-for-histogram-binning
+
+    Parameters
+    ----------
+    x : array_like
+        Input data that is to be histogrammed, trimmed to range. May not
+        be empty.
+
+    Returns
+    -------
+    h : An estimate of the optimal bin width for the given data.
+    """
+    del range  # unused
+    if x.size > 2:
+        sg1 = np.sqrt(6.0 * (x.size - 2) / ((x.size + 1.0) * (x.size + 3)))
+        sigma = np.std(x)
+        if sigma > 0.0:
+            # These three operations add up to
+            # g1 = np.mean(((x - np.mean(x)) / sigma)**3)
+            # but use only one temp array instead of three
+            temp = x - np.mean(x)
+            np.true_divide(temp, sigma, temp)
+            np.power(temp, 3, temp)
+            g1 = np.mean(temp)
+            return _ptp(x) / (1.0 + np.log2(x.size) +
+                                    np.log2(1.0 + np.absolute(g1) / sg1))
+    return 0.0
+
+
+def _hist_bin_fd(x, range):
+    """
+    The Freedman-Diaconis histogram bin estimator.
+
+    The Freedman-Diaconis rule uses interquartile range (IQR) to
+    estimate binwidth. It is considered a variation of the Scott rule
+    with more robustness as the IQR is less affected by outliers than
+    the standard deviation. However, the IQR depends on fewer points
+    than the standard deviation, so it is less accurate, especially for
+    long tailed distributions.
+
+    If the IQR is 0, this function returns 0 for the bin width.
+    Binwidth is inversely proportional to the cube root of data size
+    (asymptotically optimal).
+
+    Parameters
+    ----------
+    x : array_like
+        Input data that is to be histogrammed, trimmed to range. May not
+        be empty.
+
+    Returns
+    -------
+    h : An estimate of the optimal bin width for the given data.
+    """
+    del range  # unused
+    iqr = np.subtract(*np.percentile(x, [75, 25]))
+    return 2.0 * iqr * x.size ** (-1.0 / 3.0)
+
+
+def _hist_bin_auto(x, range):
+    """
+    Histogram bin estimator that uses the minimum width of the
+    Freedman-Diaconis and Sturges estimators if the FD bin width is non-zero.
+    If the bin width from the FD estimator is 0, the Sturges estimator is used.
+
+    The FD estimator is usually the most robust method, but its width
+    estimate tends to be too large for small `x` and bad for data with limited
+    variance. The Sturges estimator is quite good for small (<1000) datasets
+    and is the default in the R language. This method gives good off-the-shelf
+    behaviour.
+
+    .. versionchanged:: 1.15.0
+    If there is limited variance the IQR can be 0, which results in the
+    FD bin width being 0 too. This is not a valid bin width, so
+    ``np.histogram_bin_edges`` chooses 1 bin instead, which may not be optimal.
+    If the IQR is 0, it's unlikely any variance-based estimators will be of
+    use, so we revert to the Sturges estimator, which only uses the size of the
+    dataset in its calculation.
+
+    Parameters
+    ----------
+    x : array_like
+        Input data that is to be histogrammed, trimmed to range. May not
+        be empty.
+
+    Returns
+    -------
+    h : An estimate of the optimal bin width for the given data.
+
+    See Also
+    --------
+    _hist_bin_fd, _hist_bin_sturges
+    """
+    fd_bw = _hist_bin_fd(x, range)
+    sturges_bw = _hist_bin_sturges(x, range)
+    del range  # unused
+    if fd_bw:
+        return min(fd_bw, sturges_bw)
+    else:
+        # limited variance, so we return a len dependent bw estimator
+        return sturges_bw
+
+# Private dict initialized at module load time
+_hist_bin_selectors = {'stone': _hist_bin_stone,
+                       'auto': _hist_bin_auto,
+                       'doane': _hist_bin_doane,
+                       'fd': _hist_bin_fd,
+                       'rice': _hist_bin_rice,
+                       'scott': _hist_bin_scott,
+                       'sqrt': _hist_bin_sqrt,
+                       'sturges': _hist_bin_sturges}
+
+
+def _ravel_and_check_weights(a, weights):
+    """ Check a and weights have matching shapes, and ravel both """
+    a = np.asarray(a)
+
+    # Ensure that the array is a "subtractable" dtype
+    if a.dtype == np.bool:
+        warnings.warn("Converting input from {} to {} for compatibility."
+                      .format(a.dtype, np.uint8),
+                      RuntimeWarning, stacklevel=3)
+        a = a.astype(np.uint8)
+
+    if weights is not None:
+        weights = np.asarray(weights)
+        if weights.shape != a.shape:
+            raise ValueError(
+                'weights should have the same shape as a.')
+        weights = weights.ravel()
+    a = a.ravel()
+    return a, weights
+
+
+def _get_outer_edges(a, range):
+    """
+    Determine the outer bin edges to use, from either the data or the range
+    argument
+    """
+    if range is not None:
+        first_edge, last_edge = range
+        if first_edge > last_edge:
+            raise ValueError(
+                'max must be larger than min in range parameter.')
+        if not (np.isfinite(first_edge) and np.isfinite(last_edge)):
+            raise ValueError(
+                "supplied range of [{}, {}] is not finite".format(first_edge, last_edge))
+    elif a.size == 0:
+        # handle empty arrays. Can't determine range, so use 0-1.
+        first_edge, last_edge = 0, 1
+    else:
+        first_edge, last_edge = a.min(), a.max()
+        if not (np.isfinite(first_edge) and np.isfinite(last_edge)):
+            raise ValueError(
+                "autodetected range of [{}, {}] is not finite".format(first_edge, last_edge))
+
+    # expand empty range to avoid divide by zero
+    if first_edge == last_edge:
+        first_edge = first_edge - 0.5
+        last_edge = last_edge + 0.5
+
+    return first_edge, last_edge
+
+
+def _unsigned_subtract(a, b):
+    """
+    Subtract two values where a >= b, and produce an unsigned result
+
+    This is needed when finding the difference between the upper and lower
+    bound of an int16 histogram
+    """
+    # coerce to a single type
+    signed_to_unsigned = {
+        np.byte: np.ubyte,
+        np.short: np.ushort,
+        np.intc: np.uintc,
+        np.int_: np.uint,
+        np.longlong: np.ulonglong
+    }
+    dt = np.result_type(a, b)
+    try:
+        unsigned_dt = signed_to_unsigned[dt.type]
+    except KeyError:
+        return np.subtract(a, b, dtype=dt)
+    else:
+        # we know the inputs are integers, and we are deliberately casting
+        # signed to unsigned.  The input may be negative python integers so
+        # ensure we pass in arrays with the initial dtype (related to NEP 50).
+        return np.subtract(np.asarray(a, dtype=dt), np.asarray(b, dtype=dt),
+                           casting='unsafe', dtype=unsigned_dt)
+
+
+def _get_bin_edges(a, bins, range, weights):
+    """
+    Computes the bins used internally by `histogram`.
+
+    Parameters
+    ==========
+    a : ndarray
+        Ravelled data array
+    bins, range
+        Forwarded arguments from `histogram`.
+    weights : ndarray, optional
+        Ravelled weights array, or None
+
+    Returns
+    =======
+    bin_edges : ndarray
+        Array of bin edges
+    uniform_bins : (Number, Number, int):
+        The upper bound, lowerbound, and number of bins, used in the optimized
+        implementation of `histogram` that works on uniform bins.
+    """
+    # parse the overloaded bins argument
+    n_equal_bins = None
+    bin_edges = None
+
+    if isinstance(bins, str):
+        bin_name = bins
+        # if `bins` is a string for an automatic method,
+        # this will replace it with the number of bins calculated
+        if bin_name not in _hist_bin_selectors:
+            raise ValueError(
+                "{!r} is not a valid estimator for `bins`".format(bin_name))
+        if weights is not None:
+            raise TypeError("Automated estimation of the number of "
+                            "bins is not supported for weighted data")
+
+        first_edge, last_edge = _get_outer_edges(a, range)
+
+        # truncate the range if needed
+        if range is not None:
+            keep = (a >= first_edge)
+            keep &= (a <= last_edge)
+            if not np.logical_and.reduce(keep):
+                a = a[keep]
+
+        if a.size == 0:
+            n_equal_bins = 1
+        else:
+            # Do not call selectors on empty arrays
+            width = _hist_bin_selectors[bin_name](a, (first_edge, last_edge))
+            if width:
+                if np.issubdtype(a.dtype, np.integer) and width < 1:
+                    width = 1
+                n_equal_bins = int(np.ceil(_unsigned_subtract(last_edge, first_edge) / width))
+            else:
+                # Width can be zero for some estimators, e.g. FD when
+                # the IQR of the data is zero.
+                n_equal_bins = 1
+
+    elif np.ndim(bins) == 0:
+        try:
+            n_equal_bins = operator.index(bins)
+        except TypeError as e:
+            raise TypeError(
+                '`bins` must be an integer, a string, or an array') from e
+        if n_equal_bins < 1:
+            raise ValueError('`bins` must be positive, when an integer')
+
+        first_edge, last_edge = _get_outer_edges(a, range)
+
+    elif np.ndim(bins) == 1:
+        bin_edges = np.asarray(bins)
+        if np.any(bin_edges[:-1] > bin_edges[1:]):
+            raise ValueError(
+                '`bins` must increase monotonically, when an array')
+
+    else:
+        raise ValueError('`bins` must be 1d, when an array')
+
+    if n_equal_bins is not None:
+        # gh-10322 means that type resolution rules are dependent on array
+        # shapes. To avoid this causing problems, we pick a type now and stick
+        # with it throughout.
+        bin_type = np.result_type(first_edge, last_edge, a)
+        if np.issubdtype(bin_type, np.integer):
+            bin_type = np.result_type(bin_type, float)
+
+        # bin edges must be computed
+        bin_edges = np.linspace(
+            first_edge, last_edge, n_equal_bins + 1,
+            endpoint=True, dtype=bin_type)
+        return bin_edges, (first_edge, last_edge, n_equal_bins)
+    else:
+        return bin_edges, None
+
+
+def _search_sorted_inclusive(a, v):
+    """
+    Like `searchsorted`, but where the last item in `v` is placed on the right.
+
+    In the context of a histogram, this makes the last bin edge inclusive
+    """
+    return np.concatenate((
+        a.searchsorted(v[:-1], 'left'),
+        a.searchsorted(v[-1:], 'right')
+    ))
+
+
+def _histogram_bin_edges_dispatcher(a, bins=None, range=None, weights=None):
+    return (a, bins, weights)
+
+
+@array_function_dispatch(_histogram_bin_edges_dispatcher)
+def histogram_bin_edges(a, bins=10, range=None, weights=None):
+    r"""
+    Function to calculate only the edges of the bins used by the `histogram`
+    function.
+
+    Parameters
+    ----------
+    a : array_like
+        Input data. The histogram is computed over the flattened array.
+    bins : int or sequence of scalars or str, optional
+        If `bins` is an int, it defines the number of equal-width
+        bins in the given range (10, by default). If `bins` is a
+        sequence, it defines the bin edges, including the rightmost
+        edge, allowing for non-uniform bin widths.
+
+        If `bins` is a string from the list below, `histogram_bin_edges` will
+        use the method chosen to calculate the optimal bin width and
+        consequently the number of bins (see the Notes section for more detail
+        on the estimators) from the data that falls within the requested range.
+        While the bin width will be optimal for the actual data
+        in the range, the number of bins will be computed to fill the
+        entire range, including the empty portions. For visualisation,
+        using the 'auto' option is suggested. Weighted data is not
+        supported for automated bin size selection.
+
+        'auto'
+            Minimum bin width between the 'sturges' and 'fd' estimators. 
+            Provides good all-around performance.
+
+        'fd' (Freedman Diaconis Estimator)
+            Robust (resilient to outliers) estimator that takes into
+            account data variability and data size.
+
+        'doane'
+            An improved version of Sturges' estimator that works better
+            with non-normal datasets.
+
+        'scott'
+            Less robust estimator that takes into account data variability
+            and data size.
+
+        'stone'
+            Estimator based on leave-one-out cross-validation estimate of
+            the integrated squared error. Can be regarded as a generalization
+            of Scott's rule.
+
+        'rice'
+            Estimator does not take variability into account, only data
+            size. Commonly overestimates number of bins required.
+
+        'sturges'
+            R's default method, only accounts for data size. Only
+            optimal for gaussian data and underestimates number of bins
+            for large non-gaussian datasets.
+
+        'sqrt'
+            Square root (of data size) estimator, used by Excel and
+            other programs for its speed and simplicity.
+
+    range : (float, float), optional
+        The lower and upper range of the bins.  If not provided, range
+        is simply ``(a.min(), a.max())``.  Values outside the range are
+        ignored. The first element of the range must be less than or
+        equal to the second. `range` affects the automatic bin
+        computation as well. While bin width is computed to be optimal
+        based on the actual data within `range`, the bin count will fill
+        the entire range including portions containing no data.
+
+    weights : array_like, optional
+        An array of weights, of the same shape as `a`.  Each value in
+        `a` only contributes its associated weight towards the bin count
+        (instead of 1). This is currently not used by any of the bin estimators,
+        but may be in the future.
+
+    Returns
+    -------
+    bin_edges : array of dtype float
+        The edges to pass into `histogram`
+
+    See Also
+    --------
+    histogram
+
+    Notes
+    -----
+    The methods to estimate the optimal number of bins are well founded
+    in literature, and are inspired by the choices R provides for
+    histogram visualisation. Note that having the number of bins
+    proportional to :math:`n^{1/3}` is asymptotically optimal, which is
+    why it appears in most estimators. These are simply plug-in methods
+    that give good starting points for number of bins. In the equations
+    below, :math:`h` is the binwidth and :math:`n_h` is the number of
+    bins. All estimators that compute bin counts are recast to bin width
+    using the `ptp` of the data. The final bin count is obtained from
+    ``np.round(np.ceil(range / h))``. The final bin width is often less
+    than what is returned by the estimators below.
+
+    'auto' (minimum bin width of the 'sturges' and 'fd' estimators)
+        A compromise to get a good value. For small datasets the Sturges
+        value will usually be chosen, while larger datasets will usually
+        default to FD.  Avoids the overly conservative behaviour of FD
+        and Sturges for small and large datasets respectively.
+        Switchover point is usually :math:`a.size \approx 1000`.
+
+    'fd' (Freedman Diaconis Estimator)
+        .. math:: h = 2 \frac{IQR}{n^{1/3}}
+
+        The binwidth is proportional to the interquartile range (IQR)
+        and inversely proportional to cube root of a.size. Can be too
+        conservative for small datasets, but is quite good for large
+        datasets. The IQR is very robust to outliers.
+
+    'scott'
+        .. math:: h = \sigma \sqrt[3]{\frac{24 \sqrt{\pi}}{n}}
+
+        The binwidth is proportional to the standard deviation of the
+        data and inversely proportional to cube root of ``x.size``. Can
+        be too conservative for small datasets, but is quite good for
+        large datasets. The standard deviation is not very robust to
+        outliers. Values are very similar to the Freedman-Diaconis
+        estimator in the absence of outliers.
+
+    'rice'
+        .. math:: n_h = 2n^{1/3}
+
+        The number of bins is only proportional to cube root of
+        ``a.size``. It tends to overestimate the number of bins and it
+        does not take into account data variability.
+
+    'sturges'
+        .. math:: n_h = \log _{2}(n) + 1
+
+        The number of bins is the base 2 log of ``a.size``.  This
+        estimator assumes normality of data and is too conservative for
+        larger, non-normal datasets. This is the default method in R's
+        ``hist`` method.
+
+    'doane'
+        .. math:: n_h = 1 + \log_{2}(n) +
+                        \log_{2}\left(1 + \frac{|g_1|}{\sigma_{g_1}}\right)
+
+            g_1 = mean\left[\left(\frac{x - \mu}{\sigma}\right)^3\right]
+
+            \sigma_{g_1} = \sqrt{\frac{6(n - 2)}{(n + 1)(n + 3)}}
+
+        An improved version of Sturges' formula that produces better
+        estimates for non-normal datasets. This estimator attempts to
+        account for the skew of the data.
+
+    'sqrt'
+        .. math:: n_h = \sqrt n
+
+        The simplest and fastest estimator. Only takes into account the
+        data size.
+
+    Additionally, if the data is of integer dtype, then the binwidth will never
+    be less than 1.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> arr = np.array([0, 0, 0, 1, 2, 3, 3, 4, 5])
+    >>> np.histogram_bin_edges(arr, bins='auto', range=(0, 1))
+    array([0.  , 0.25, 0.5 , 0.75, 1.  ])
+    >>> np.histogram_bin_edges(arr, bins=2)
+    array([0. , 2.5, 5. ])
+
+    For consistency with histogram, an array of pre-computed bins is
+    passed through unmodified:
+
+    >>> np.histogram_bin_edges(arr, [1, 2])
+    array([1, 2])
+
+    This function allows one set of bins to be computed, and reused across
+    multiple histograms:
+
+    >>> shared_bins = np.histogram_bin_edges(arr, bins='auto')
+    >>> shared_bins
+    array([0., 1., 2., 3., 4., 5.])
+
+    >>> group_id = np.array([0, 1, 1, 0, 1, 1, 0, 1, 1])
+    >>> hist_0, _ = np.histogram(arr[group_id == 0], bins=shared_bins)
+    >>> hist_1, _ = np.histogram(arr[group_id == 1], bins=shared_bins)
+
+    >>> hist_0; hist_1
+    array([1, 1, 0, 1, 0])
+    array([2, 0, 1, 1, 2])
+
+    Which gives more easily comparable results than using separate bins for
+    each histogram:
+
+    >>> hist_0, bins_0 = np.histogram(arr[group_id == 0], bins='auto')
+    >>> hist_1, bins_1 = np.histogram(arr[group_id == 1], bins='auto')
+    >>> hist_0; hist_1
+    array([1, 1, 1])
+    array([2, 1, 1, 2])
+    >>> bins_0; bins_1
+    array([0., 1., 2., 3.])
+    array([0.  , 1.25, 2.5 , 3.75, 5.  ])
+
+    """
+    a, weights = _ravel_and_check_weights(a, weights)
+    bin_edges, _ = _get_bin_edges(a, bins, range, weights)
+    return bin_edges
+
+
+def _histogram_dispatcher(
+        a, bins=None, range=None, density=None, weights=None):
+    return (a, bins, weights)
+
+
+@array_function_dispatch(_histogram_dispatcher)
+def histogram(a, bins=10, range=None, density=None, weights=None):
+    r"""
+    Compute the histogram of a dataset.
+
+    Parameters
+    ----------
+    a : array_like
+        Input data. The histogram is computed over the flattened array.
+    bins : int or sequence of scalars or str, optional
+        If `bins` is an int, it defines the number of equal-width
+        bins in the given range (10, by default). If `bins` is a
+        sequence, it defines a monotonically increasing array of bin edges,
+        including the rightmost edge, allowing for non-uniform bin widths.
+
+        .. versionadded:: 1.11.0
+
+        If `bins` is a string, it defines the method used to calculate the
+        optimal bin width, as defined by `histogram_bin_edges`.
+
+    range : (float, float), optional
+        The lower and upper range of the bins.  If not provided, range
+        is simply ``(a.min(), a.max())``.  Values outside the range are
+        ignored. The first element of the range must be less than or
+        equal to the second. `range` affects the automatic bin
+        computation as well. While bin width is computed to be optimal
+        based on the actual data within `range`, the bin count will fill
+        the entire range including portions containing no data.
+    weights : array_like, optional
+        An array of weights, of the same shape as `a`.  Each value in
+        `a` only contributes its associated weight towards the bin count
+        (instead of 1). If `density` is True, the weights are
+        normalized, so that the integral of the density over the range
+        remains 1.
+        Please note that the ``dtype`` of `weights` will also become the
+        ``dtype`` of the returned accumulator (`hist`), so it must be
+        large enough to hold accumulated values as well.
+    density : bool, optional
+        If ``False``, the result will contain the number of samples in
+        each bin. If ``True``, the result is the value of the
+        probability *density* function at the bin, normalized such that
+        the *integral* over the range is 1. Note that the sum of the
+        histogram values will not be equal to 1 unless bins of unity
+        width are chosen; it is not a probability *mass* function.
+
+    Returns
+    -------
+    hist : array
+        The values of the histogram. See `density` and `weights` for a
+        description of the possible semantics.  If `weights` are given,
+        ``hist.dtype`` will be taken from `weights`.
+    bin_edges : array of dtype float
+        Return the bin edges ``(length(hist)+1)``.
+
+
+    See Also
+    --------
+    histogramdd, bincount, searchsorted, digitize, histogram_bin_edges
+
+    Notes
+    -----
+    All but the last (righthand-most) bin is half-open.  In other words,
+    if `bins` is::
+
+      [1, 2, 3, 4]
+
+    then the first bin is ``[1, 2)`` (including 1, but excluding 2) and
+    the second ``[2, 3)``.  The last bin, however, is ``[3, 4]``, which
+    *includes* 4.
+
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> np.histogram([1, 2, 1], bins=[0, 1, 2, 3])
+    (array([0, 2, 1]), array([0, 1, 2, 3]))
+    >>> np.histogram(np.arange(4), bins=np.arange(5), density=True)
+    (array([0.25, 0.25, 0.25, 0.25]), array([0, 1, 2, 3, 4]))
+    >>> np.histogram([[1, 2, 1], [1, 0, 1]], bins=[0,1,2,3])
+    (array([1, 4, 1]), array([0, 1, 2, 3]))
+
+    >>> a = np.arange(5)
+    >>> hist, bin_edges = np.histogram(a, density=True)
+    >>> hist
+    array([0.5, 0. , 0.5, 0. , 0. , 0.5, 0. , 0.5, 0. , 0.5])
+    >>> hist.sum()
+    2.4999999999999996
+    >>> np.sum(hist * np.diff(bin_edges))
+    1.0
+
+    .. versionadded:: 1.11.0
+
+    Automated Bin Selection Methods example, using 2 peak random data
+    with 2000 points.
+
+    .. plot::
+        :include-source:
+
+        import matplotlib.pyplot as plt
+        import numpy as np
+
+        rng = np.random.RandomState(10)  # deterministic random data
+        a = np.hstack((rng.normal(size=1000),
+                       rng.normal(loc=5, scale=2, size=1000)))
+        plt.hist(a, bins='auto')  # arguments are passed to np.histogram
+        plt.title("Histogram with 'auto' bins")
+        plt.show()
+
+    """
+    a, weights = _ravel_and_check_weights(a, weights)
+
+    bin_edges, uniform_bins = _get_bin_edges(a, bins, range, weights)
+
+    # Histogram is an integer or a float array depending on the weights.
+    if weights is None:
+        ntype = np.dtype(np.intp)
+    else:
+        ntype = weights.dtype
+
+    # We set a block size, as this allows us to iterate over chunks when
+    # computing histograms, to minimize memory usage.
+    BLOCK = 65536
+
+    # The fast path uses bincount, but that only works for certain types
+    # of weight
+    simple_weights = (
+        weights is None or
+        np.can_cast(weights.dtype, np.double) or
+        np.can_cast(weights.dtype, complex)
+    )
+
+    if uniform_bins is not None and simple_weights:
+        # Fast algorithm for equal bins
+        # We now convert values of a to bin indices, under the assumption of
+        # equal bin widths (which is valid here).
+        first_edge, last_edge, n_equal_bins = uniform_bins
+
+        # Initialize empty histogram
+        n = np.zeros(n_equal_bins, ntype)
+
+        # Pre-compute histogram scaling factor
+        norm_numerator = n_equal_bins
+        norm_denom = _unsigned_subtract(last_edge, first_edge)
+
+        # We iterate over blocks here for two reasons: the first is that for
+        # large arrays, it is actually faster (for example for a 10^8 array it
+        # is 2x as fast) and it results in a memory footprint 3x lower in the
+        # limit of large arrays.
+        for i in _range(0, len(a), BLOCK):
+            tmp_a = a[i:i+BLOCK]
+            if weights is None:
+                tmp_w = None
+            else:
+                tmp_w = weights[i:i + BLOCK]
+
+            # Only include values in the right range
+            keep = (tmp_a >= first_edge)
+            keep &= (tmp_a <= last_edge)
+            if not np.logical_and.reduce(keep):
+                tmp_a = tmp_a[keep]
+                if tmp_w is not None:
+                    tmp_w = tmp_w[keep]
+
+            # This cast ensures no type promotions occur below, which gh-10322
+            # make unpredictable. Getting it wrong leads to precision errors
+            # like gh-8123.
+            tmp_a = tmp_a.astype(bin_edges.dtype, copy=False)
+
+            # Compute the bin indices, and for values that lie exactly on
+            # last_edge we need to subtract one
+            f_indices = ((_unsigned_subtract(tmp_a, first_edge) / norm_denom)
+                         * norm_numerator)
+            indices = f_indices.astype(np.intp)
+            indices[indices == n_equal_bins] -= 1
+
+            # The index computation is not guaranteed to give exactly
+            # consistent results within ~1 ULP of the bin edges.
+            decrement = tmp_a < bin_edges[indices]
+            indices[decrement] -= 1
+            # The last bin includes the right edge. The other bins do not.
+            increment = ((tmp_a >= bin_edges[indices + 1])
+                         & (indices != n_equal_bins - 1))
+            indices[increment] += 1
+
+            # We now compute the histogram using bincount
+            if ntype.kind == 'c':
+                n.real += np.bincount(indices, weights=tmp_w.real,
+                                      minlength=n_equal_bins)
+                n.imag += np.bincount(indices, weights=tmp_w.imag,
+                                      minlength=n_equal_bins)
+            else:
+                n += np.bincount(indices, weights=tmp_w,
+                                 minlength=n_equal_bins).astype(ntype)
+    else:
+        # Compute via cumulative histogram
+        cum_n = np.zeros(bin_edges.shape, ntype)
+        if weights is None:
+            for i in _range(0, len(a), BLOCK):
+                sa = np.sort(a[i:i+BLOCK])
+                cum_n += _search_sorted_inclusive(sa, bin_edges)
+        else:
+            zero = np.zeros(1, dtype=ntype)
+            for i in _range(0, len(a), BLOCK):
+                tmp_a = a[i:i+BLOCK]
+                tmp_w = weights[i:i+BLOCK]
+                sorting_index = np.argsort(tmp_a)
+                sa = tmp_a[sorting_index]
+                sw = tmp_w[sorting_index]
+                cw = np.concatenate((zero, sw.cumsum()))
+                bin_index = _search_sorted_inclusive(sa, bin_edges)
+                cum_n += cw[bin_index]
+
+        n = np.diff(cum_n)
+
+    if density:
+        db = np.array(np.diff(bin_edges), float)
+        return n/db/n.sum(), bin_edges
+
+    return n, bin_edges
+
+
+def _histogramdd_dispatcher(sample, bins=None, range=None, density=None,
+                            weights=None):
+    if hasattr(sample, 'shape'):  # same condition as used in histogramdd
+        yield sample
+    else:
+        yield from sample
+    with contextlib.suppress(TypeError):
+        yield from bins
+    yield weights
+
+
+@array_function_dispatch(_histogramdd_dispatcher)
+def histogramdd(sample, bins=10, range=None, density=None, weights=None):
+    """
+    Compute the multidimensional histogram of some data.
+
+    Parameters
+    ----------
+    sample : (N, D) array, or (N, D) array_like
+        The data to be histogrammed.
+
+        Note the unusual interpretation of sample when an array_like:
+
+        * When an array, each row is a coordinate in a D-dimensional space -
+          such as ``histogramdd(np.array([p1, p2, p3]))``.
+        * When an array_like, each element is the list of values for single
+          coordinate - such as ``histogramdd((X, Y, Z))``.
+
+        The first form should be preferred.
+
+    bins : sequence or int, optional
+        The bin specification:
+
+        * A sequence of arrays describing the monotonically increasing bin
+          edges along each dimension.
+        * The number of bins for each dimension (nx, ny, ... =bins)
+        * The number of bins for all dimensions (nx=ny=...=bins).
+
+    range : sequence, optional
+        A sequence of length D, each an optional (lower, upper) tuple giving
+        the outer bin edges to be used if the edges are not given explicitly in
+        `bins`.
+        An entry of None in the sequence results in the minimum and maximum
+        values being used for the corresponding dimension.
+        The default, None, is equivalent to passing a tuple of D None values.
+    density : bool, optional
+        If False, the default, returns the number of samples in each bin.
+        If True, returns the probability *density* function at the bin,
+        ``bin_count / sample_count / bin_volume``.
+    weights : (N,) array_like, optional
+        An array of values `w_i` weighing each sample `(x_i, y_i, z_i, ...)`.
+        Weights are normalized to 1 if density is True. If density is False,
+        the values of the returned histogram are equal to the sum of the
+        weights belonging to the samples falling into each bin.
+
+    Returns
+    -------
+    H : ndarray
+        The multidimensional histogram of sample x. See density and weights
+        for the different possible semantics.
+    edges : tuple of ndarrays
+        A tuple of D arrays describing the bin edges for each dimension.
+
+    See Also
+    --------
+    histogram: 1-D histogram
+    histogram2d: 2-D histogram
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> rng = np.random.default_rng()
+    >>> r = rng.normal(size=(100,3))
+    >>> H, edges = np.histogramdd(r, bins = (5, 8, 4))
+    >>> H.shape, edges[0].size, edges[1].size, edges[2].size
+    ((5, 8, 4), 6, 9, 5)
+
+    """
+
+    try:
+        # Sample is an ND-array.
+        N, D = sample.shape
+    except (AttributeError, ValueError):
+        # Sample is a sequence of 1D arrays.
+        sample = np.atleast_2d(sample).T
+        N, D = sample.shape
+
+    nbin = np.empty(D, np.intp)
+    edges = D*[None]
+    dedges = D*[None]
+    if weights is not None:
+        weights = np.asarray(weights)
+
+    try:
+        M = len(bins)
+        if M != D:
+            raise ValueError(
+                'The dimension of bins must be equal to the dimension of the '
+                'sample x.')
+    except TypeError:
+        # bins is an integer
+        bins = D*[bins]
+
+    # normalize the range argument
+    if range is None:
+        range = (None,) * D
+    elif len(range) != D:
+        raise ValueError('range argument must have one entry per dimension')
+
+    # Create edge arrays
+    for i in _range(D):
+        if np.ndim(bins[i]) == 0:
+            if bins[i] < 1:
+                raise ValueError(
+                    '`bins[{}]` must be positive, when an integer'.format(i))
+            smin, smax = _get_outer_edges(sample[:,i], range[i])
+            try:
+                n = operator.index(bins[i])
+
+            except TypeError as e:
+                raise TypeError(
+                	"`bins[{}]` must be an integer, when a scalar".format(i)
+                ) from e
+
+            edges[i] = np.linspace(smin, smax, n + 1)
+        elif np.ndim(bins[i]) == 1:
+            edges[i] = np.asarray(bins[i])
+            if np.any(edges[i][:-1] > edges[i][1:]):
+                raise ValueError(
+                    '`bins[{}]` must be monotonically increasing, when an array'
+                    .format(i))
+        else:
+            raise ValueError(
+                '`bins[{}]` must be a scalar or 1d array'.format(i))
+
+        nbin[i] = len(edges[i]) + 1  # includes an outlier on each end
+        dedges[i] = np.diff(edges[i])
+
+    # Compute the bin number each sample falls into.
+    Ncount = tuple(
+        # avoid np.digitize to work around gh-11022
+        np.searchsorted(edges[i], sample[:, i], side='right')
+        for i in _range(D)
+    )
+
+    # Using digitize, values that fall on an edge are put in the right bin.
+    # For the rightmost bin, we want values equal to the right edge to be
+    # counted in the last bin, and not as an outlier.
+    for i in _range(D):
+        # Find which points are on the rightmost edge.
+        on_edge = (sample[:, i] == edges[i][-1])
+        # Shift these points one bin to the left.
+        Ncount[i][on_edge] -= 1
+
+    # Compute the sample indices in the flattened histogram matrix.
+    # This raises an error if the array is too large.
+    xy = np.ravel_multi_index(Ncount, nbin)
+
+    # Compute the number of repetitions in xy and assign it to the
+    # flattened histmat.
+    hist = np.bincount(xy, weights, minlength=nbin.prod())
+
+    # Shape into a proper matrix
+    hist = hist.reshape(nbin)
+
+    # This preserves the (bad) behavior observed in gh-7845, for now.
+    hist = hist.astype(float, casting='safe')
+
+    # Remove outliers (indices 0 and -1 for each dimension).
+    core = D*(slice(1, -1),)
+    hist = hist[core]
+
+    if density:
+        # calculate the probability density function
+        s = hist.sum()
+        for i in _range(D):
+            shape = np.ones(D, int)
+            shape[i] = nbin[i] - 2
+            hist = hist / dedges[i].reshape(shape)
+        hist /= s
+
+    if (hist.shape != nbin - 2).any():
+        raise RuntimeError(
+            "Internal Shape Error")
+    return hist, edges
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/_histograms_impl.pyi b/venv/lib/python3.12/site-packages/numpy/lib/_histograms_impl.pyi
new file mode 100644
index 00000000..138cdb11
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/lib/_histograms_impl.pyi
@@ -0,0 +1,47 @@
+from collections.abc import Sequence
+from typing import (
+    Literal as L,
+    Any,
+    SupportsIndex,
+)
+
+from numpy._typing import (
+    NDArray,
+    ArrayLike,
+)
+
+_BinKind = L[
+    "stone",
+    "auto",
+    "doane",
+    "fd",
+    "rice",
+    "scott",
+    "sqrt",
+    "sturges",
+]
+
+__all__: list[str]
+
+def histogram_bin_edges(
+    a: ArrayLike,
+    bins: _BinKind | SupportsIndex | ArrayLike = ...,
+    range: None | tuple[float, float] = ...,
+    weights: None | ArrayLike = ...,
+) -> NDArray[Any]: ...
+
+def histogram(
+    a: ArrayLike,
+    bins: _BinKind | SupportsIndex | ArrayLike = ...,
+    range: None | tuple[float, float] = ...,
+    density: bool = ...,
+    weights: None | ArrayLike = ...,
+) -> tuple[NDArray[Any], NDArray[Any]]: ...
+
+def histogramdd(
+    sample: ArrayLike,
+    bins: SupportsIndex | ArrayLike = ...,
+    range: Sequence[tuple[float, float]] = ...,
+    density: None | bool = ...,
+    weights: None | ArrayLike = ...,
+) -> tuple[NDArray[Any], tuple[NDArray[Any], ...]]: ...
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/_index_tricks_impl.py b/venv/lib/python3.12/site-packages/numpy/lib/_index_tricks_impl.py
new file mode 100644
index 00000000..3014e461
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/lib/_index_tricks_impl.py
@@ -0,0 +1,1079 @@
+import functools
+import sys
+import math
+import warnings
+
+import numpy as np
+from .._utils import set_module
+import numpy._core.numeric as _nx
+from numpy._core.numeric import ScalarType, array
+from numpy._core.numerictypes import issubdtype
+
+import numpy.matrixlib as matrixlib
+from numpy._core.multiarray import ravel_multi_index, unravel_index
+from numpy._core import overrides, linspace
+from numpy.lib.stride_tricks import as_strided
+from numpy.lib._function_base_impl import diff
+
+
+array_function_dispatch = functools.partial(
+    overrides.array_function_dispatch, module='numpy')
+
+
+__all__ = [
+    'ravel_multi_index', 'unravel_index', 'mgrid', 'ogrid', 'r_', 'c_',
+    's_', 'index_exp', 'ix_', 'ndenumerate', 'ndindex', 'fill_diagonal',
+    'diag_indices', 'diag_indices_from'
+]
+
+
+def _ix__dispatcher(*args):
+    return args
+
+
+@array_function_dispatch(_ix__dispatcher)
+def ix_(*args):
+    """
+    Construct an open mesh from multiple sequences.
+
+    This function takes N 1-D sequences and returns N outputs with N
+    dimensions each, such that the shape is 1 in all but one dimension
+    and the dimension with the non-unit shape value cycles through all
+    N dimensions.
+
+    Using `ix_` one can quickly construct index arrays that will index
+    the cross product. ``a[np.ix_([1,3],[2,5])]`` returns the array
+    ``[[a[1,2] a[1,5]], [a[3,2] a[3,5]]]``.
+
+    Parameters
+    ----------
+    args : 1-D sequences
+        Each sequence should be of integer or boolean type.
+        Boolean sequences will be interpreted as boolean masks for the
+        corresponding dimension (equivalent to passing in
+        ``np.nonzero(boolean_sequence)``).
+
+    Returns
+    -------
+    out : tuple of ndarrays
+        N arrays with N dimensions each, with N the number of input
+        sequences. Together these arrays form an open mesh.
+
+    See Also
+    --------
+    ogrid, mgrid, meshgrid
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> a = np.arange(10).reshape(2, 5)
+    >>> a
+    array([[0, 1, 2, 3, 4],
+           [5, 6, 7, 8, 9]])
+    >>> ixgrid = np.ix_([0, 1], [2, 4])
+    >>> ixgrid
+    (array([[0],
+           [1]]), array([[2, 4]]))
+    >>> ixgrid[0].shape, ixgrid[1].shape
+    ((2, 1), (1, 2))
+    >>> a[ixgrid]
+    array([[2, 4],
+           [7, 9]])
+
+    >>> ixgrid = np.ix_([True, True], [2, 4])
+    >>> a[ixgrid]
+    array([[2, 4],
+           [7, 9]])
+    >>> ixgrid = np.ix_([True, True], [False, False, True, False, True])
+    >>> a[ixgrid]
+    array([[2, 4],
+           [7, 9]])
+
+    """
+    out = []
+    nd = len(args)
+    for k, new in enumerate(args):
+        if not isinstance(new, _nx.ndarray):
+            new = np.asarray(new)
+            if new.size == 0:
+                # Explicitly type empty arrays to avoid float default
+                new = new.astype(_nx.intp)
+        if new.ndim != 1:
+            raise ValueError("Cross index must be 1 dimensional")
+        if issubdtype(new.dtype, _nx.bool):
+            new, = new.nonzero()
+        new = new.reshape((1,)*k + (new.size,) + (1,)*(nd-k-1))
+        out.append(new)
+    return tuple(out)
+
+
+class nd_grid:
+    """
+    Construct a multi-dimensional "meshgrid".
+
+    ``grid = nd_grid()`` creates an instance which will return a mesh-grid
+    when indexed.  The dimension and number of the output arrays are equal
+    to the number of indexing dimensions.  If the step length is not a
+    complex number, then the stop is not inclusive.
+
+    However, if the step length is a **complex number** (e.g. 5j), then the
+    integer part of its magnitude is interpreted as specifying the
+    number of points to create between the start and stop values, where
+    the stop value **is inclusive**.
+
+    If instantiated with an argument of ``sparse=True``, the mesh-grid is
+    open (or not fleshed out) so that only one-dimension of each returned
+    argument is greater than 1.
+
+    Parameters
+    ----------
+    sparse : bool, optional
+        Whether the grid is sparse or not. Default is False.
+
+    Notes
+    -----
+    Two instances of `nd_grid` are made available in the NumPy namespace,
+    `mgrid` and `ogrid`, approximately defined as::
+
+        mgrid = nd_grid(sparse=False)
+        ogrid = nd_grid(sparse=True)
+
+    Users should use these pre-defined instances instead of using `nd_grid`
+    directly.
+    """
+    __slots__ = ('sparse',)
+
+    def __init__(self, sparse=False):
+        self.sparse = sparse
+
+    def __getitem__(self, key):
+        try:
+            size = []
+            # Mimic the behavior of `np.arange` and use a data type
+            # which is at least as large as `np.int_`
+            num_list = [0]
+            for k in range(len(key)):
+                step = key[k].step
+                start = key[k].start
+                stop = key[k].stop
+                if start is None:
+                    start = 0
+                if step is None:
+                    step = 1
+                if isinstance(step, (_nx.complexfloating, complex)):
+                    step = abs(step)
+                    size.append(int(step))
+                else:
+                    size.append(
+                        int(math.ceil((stop - start) / (step*1.0))))
+                num_list += [start, stop, step]
+            typ = _nx.result_type(*num_list)
+            if self.sparse:
+                nn = [_nx.arange(_x, dtype=_t)
+                      for _x, _t in zip(size, (typ,)*len(size))]
+            else:
+                nn = _nx.indices(size, typ)
+            for k, kk in enumerate(key):
+                step = kk.step
+                start = kk.start
+                if start is None:
+                    start = 0
+                if step is None:
+                    step = 1
+                if isinstance(step, (_nx.complexfloating, complex)):
+                    step = int(abs(step))
+                    if step != 1:
+                        step = (kk.stop - start) / float(step - 1)
+                nn[k] = (nn[k]*step+start)
+            if self.sparse:
+                slobj = [_nx.newaxis]*len(size)
+                for k in range(len(size)):
+                    slobj[k] = slice(None, None)
+                    nn[k] = nn[k][tuple(slobj)]
+                    slobj[k] = _nx.newaxis
+                return tuple(nn)  # ogrid -> tuple of arrays
+            return nn  # mgrid -> ndarray
+        except (IndexError, TypeError):
+            step = key.step
+            stop = key.stop
+            start = key.start
+            if start is None:
+                start = 0
+            if isinstance(step, (_nx.complexfloating, complex)):
+                # Prevent the (potential) creation of integer arrays
+                step_float = abs(step)
+                step = length = int(step_float)
+                if step != 1:
+                    step = (key.stop-start)/float(step-1)
+                typ = _nx.result_type(start, stop, step_float)
+                return _nx.arange(0, length, 1, dtype=typ)*step + start
+            else:
+                return _nx.arange(start, stop, step)
+
+
+class MGridClass(nd_grid):
+    """
+    An instance which returns a dense multi-dimensional "meshgrid".
+
+    An instance which returns a dense (or fleshed out) mesh-grid
+    when indexed, so that each returned argument has the same shape.
+    The dimensions and number of the output arrays are equal to the
+    number of indexing dimensions.  If the step length is not a complex
+    number, then the stop is not inclusive.
+
+    However, if the step length is a **complex number** (e.g. 5j), then
+    the integer part of its magnitude is interpreted as specifying the
+    number of points to create between the start and stop values, where
+    the stop value **is inclusive**.
+
+    Returns
+    -------
+    mesh-grid : ndarray
+        A single array, containing a set of `ndarray`\\ s all of the same
+        dimensions. stacked along the first axis.
+
+    See Also
+    --------
+    ogrid : like `mgrid` but returns open (not fleshed out) mesh grids
+    meshgrid: return coordinate matrices from coordinate vectors
+    r_ : array concatenator
+    :ref:`how-to-partition`
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> np.mgrid[0:5, 0:5]
+    array([[[0, 0, 0, 0, 0],
+            [1, 1, 1, 1, 1],
+            [2, 2, 2, 2, 2],
+            [3, 3, 3, 3, 3],
+            [4, 4, 4, 4, 4]],
+           [[0, 1, 2, 3, 4],
+            [0, 1, 2, 3, 4],
+            [0, 1, 2, 3, 4],
+            [0, 1, 2, 3, 4],
+            [0, 1, 2, 3, 4]]])
+    >>> np.mgrid[-1:1:5j]
+    array([-1. , -0.5,  0. ,  0.5,  1. ])
+
+    >>> np.mgrid[0:4].shape
+    (4,)
+    >>> np.mgrid[0:4, 0:5].shape
+    (2, 4, 5)
+    >>> np.mgrid[0:4, 0:5, 0:6].shape
+    (3, 4, 5, 6)
+
+    """
+    __slots__ = ()
+
+    def __init__(self):
+        super().__init__(sparse=False)
+
+
+mgrid = MGridClass()
+
+
+class OGridClass(nd_grid):
+    """
+    An instance which returns an open multi-dimensional "meshgrid".
+
+    An instance which returns an open (i.e. not fleshed out) mesh-grid
+    when indexed, so that only one dimension of each returned array is
+    greater than 1.  The dimension and number of the output arrays are
+    equal to the number of indexing dimensions.  If the step length is
+    not a complex number, then the stop is not inclusive.
+
+    However, if the step length is a **complex number** (e.g. 5j), then
+    the integer part of its magnitude is interpreted as specifying the
+    number of points to create between the start and stop values, where
+    the stop value **is inclusive**.
+
+    Returns
+    -------
+    mesh-grid : ndarray or tuple of ndarrays
+        If the input is a single slice, returns an array.
+        If the input is multiple slices, returns a tuple of arrays, with
+        only one dimension not equal to 1.
+
+    See Also
+    --------
+    mgrid : like `ogrid` but returns dense (or fleshed out) mesh grids
+    meshgrid: return coordinate matrices from coordinate vectors
+    r_ : array concatenator
+    :ref:`how-to-partition`
+
+    Examples
+    --------
+    >>> from numpy import ogrid
+    >>> ogrid[-1:1:5j]
+    array([-1. , -0.5,  0. ,  0.5,  1. ])
+    >>> ogrid[0:5, 0:5]
+    (array([[0],
+            [1],
+            [2],
+            [3],
+            [4]]),
+     array([[0, 1, 2, 3, 4]]))
+
+    """
+    __slots__ = ()
+
+    def __init__(self):
+        super().__init__(sparse=True)
+
+
+ogrid = OGridClass()
+
+
+class AxisConcatenator:
+    """
+    Translates slice objects to concatenation along an axis.
+
+    For detailed documentation on usage, see `r_`.
+    """
+    __slots__ = ('axis', 'matrix', 'trans1d', 'ndmin')
+
+    # allow ma.mr_ to override this
+    concatenate = staticmethod(_nx.concatenate)
+    makemat = staticmethod(matrixlib.matrix)
+
+    def __init__(self, axis=0, matrix=False, ndmin=1, trans1d=-1):
+        self.axis = axis
+        self.matrix = matrix
+        self.trans1d = trans1d
+        self.ndmin = ndmin
+
+    def __getitem__(self, key):
+        # handle matrix builder syntax
+        if isinstance(key, str):
+            frame = sys._getframe().f_back
+            mymat = matrixlib.bmat(key, frame.f_globals, frame.f_locals)
+            return mymat
+
+        if not isinstance(key, tuple):
+            key = (key,)
+
+        # copy attributes, since they can be overridden in the first argument
+        trans1d = self.trans1d
+        ndmin = self.ndmin
+        matrix = self.matrix
+        axis = self.axis
+
+        objs = []
+        # dtypes or scalars for weak scalar handling in result_type
+        result_type_objs = []
+
+        for k, item in enumerate(key):
+            scalar = False
+            if isinstance(item, slice):
+                step = item.step
+                start = item.start
+                stop = item.stop
+                if start is None:
+                    start = 0
+                if step is None:
+                    step = 1
+                if isinstance(step, (_nx.complexfloating, complex)):
+                    size = int(abs(step))
+                    newobj = linspace(start, stop, num=size)
+                else:
+                    newobj = _nx.arange(start, stop, step)
+                if ndmin > 1:
+                    newobj = array(newobj, copy=None, ndmin=ndmin)
+                    if trans1d != -1:
+                        newobj = newobj.swapaxes(-1, trans1d)
+            elif isinstance(item, str):
+                if k != 0:
+                    raise ValueError("special directives must be the "
+                                     "first entry.")
+                if item in ('r', 'c'):
+                    matrix = True
+                    col = (item == 'c')
+                    continue
+                if ',' in item:
+                    vec = item.split(',')
+                    try:
+                        axis, ndmin = [int(x) for x in vec[:2]]
+                        if len(vec) == 3:
+                            trans1d = int(vec[2])
+                        continue
+                    except Exception as e:
+                        raise ValueError(
+                            "unknown special directive {!r}".format(item)
+                        ) from e
+                try:
+                    axis = int(item)
+                    continue
+                except (ValueError, TypeError) as e:
+                    raise ValueError("unknown special directive") from e
+            elif type(item) in ScalarType:
+                scalar = True
+                newobj = item
+            else:
+                item_ndim = np.ndim(item)
+                newobj = array(item, copy=None, subok=True, ndmin=ndmin)
+                if trans1d != -1 and item_ndim < ndmin:
+                    k2 = ndmin - item_ndim
+                    k1 = trans1d
+                    if k1 < 0:
+                        k1 += k2 + 1
+                    defaxes = list(range(ndmin))
+                    axes = defaxes[:k1] + defaxes[k2:] + defaxes[k1:k2]
+                    newobj = newobj.transpose(axes)
+
+            objs.append(newobj)
+            if scalar:
+                result_type_objs.append(item)
+            else:
+                result_type_objs.append(newobj.dtype)
+
+        # Ensure that scalars won't up-cast unless warranted, for 0, drops
+        # through to error in concatenate.
+        if len(result_type_objs) != 0:
+            final_dtype = _nx.result_type(*result_type_objs)
+            # concatenate could do cast, but that can be overridden:
+            objs = [array(obj, copy=None, subok=True,
+                          ndmin=ndmin, dtype=final_dtype) for obj in objs]
+
+        res = self.concatenate(tuple(objs), axis=axis)
+
+        if matrix:
+            oldndim = res.ndim
+            res = self.makemat(res)
+            if oldndim == 1 and col:
+                res = res.T
+        return res
+
+    def __len__(self):
+        return 0
+
+# separate classes are used here instead of just making r_ = concatentor(0),
+# etc. because otherwise we couldn't get the doc string to come out right
+# in help(r_)
+
+
+class RClass(AxisConcatenator):
+    """
+    Translates slice objects to concatenation along the first axis.
+
+    This is a simple way to build up arrays quickly. There are two use cases.
+
+    1. If the index expression contains comma separated arrays, then stack
+       them along their first axis.
+    2. If the index expression contains slice notation or scalars then create
+       a 1-D array with a range indicated by the slice notation.
+
+    If slice notation is used, the syntax ``start:stop:step`` is equivalent
+    to ``np.arange(start, stop, step)`` inside of the brackets. However, if
+    ``step`` is an imaginary number (i.e. 100j) then its integer portion is
+    interpreted as a number-of-points desired and the start and stop are
+    inclusive. In other words ``start:stop:stepj`` is interpreted as
+    ``np.linspace(start, stop, step, endpoint=1)`` inside of the brackets.
+    After expansion of slice notation, all comma separated sequences are
+    concatenated together.
+
+    Optional character strings placed as the first element of the index
+    expression can be used to change the output. The strings 'r' or 'c' result
+    in matrix output. If the result is 1-D and 'r' is specified a 1 x N (row)
+    matrix is produced. If the result is 1-D and 'c' is specified, then a N x 1
+    (column) matrix is produced. If the result is 2-D then both provide the
+    same matrix result.
+
+    A string integer specifies which axis to stack multiple comma separated
+    arrays along. A string of two comma-separated integers allows indication
+    of the minimum number of dimensions to force each entry into as the
+    second integer (the axis to concatenate along is still the first integer).
+
+    A string with three comma-separated integers allows specification of the
+    axis to concatenate along, the minimum number of dimensions to force the
+    entries to, and which axis should contain the start of the arrays which
+    are less than the specified number of dimensions. In other words the third
+    integer allows you to specify where the 1's should be placed in the shape
+    of the arrays that have their shapes upgraded. By default, they are placed
+    in the front of the shape tuple. The third argument allows you to specify
+    where the start of the array should be instead. Thus, a third argument of
+    '0' would place the 1's at the end of the array shape. Negative integers
+    specify where in the new shape tuple the last dimension of upgraded arrays
+    should be placed, so the default is '-1'.
+
+    Parameters
+    ----------
+    Not a function, so takes no parameters
+
+
+    Returns
+    -------
+    A concatenated ndarray or matrix.
+
+    See Also
+    --------
+    concatenate : Join a sequence of arrays along an existing axis.
+    c_ : Translates slice objects to concatenation along the second axis.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> np.r_[np.array([1,2,3]), 0, 0, np.array([4,5,6])]
+    array([1, 2, 3, ..., 4, 5, 6])
+    >>> np.r_[-1:1:6j, [0]*3, 5, 6]
+    array([-1. , -0.6, -0.2,  0.2,  0.6,  1. ,  0. ,  0. ,  0. ,  5. ,  6. ])
+
+    String integers specify the axis to concatenate along or the minimum
+    number of dimensions to force entries into.
+
+    >>> a = np.array([[0, 1, 2], [3, 4, 5]])
+    >>> np.r_['-1', a, a] # concatenate along last axis
+    array([[0, 1, 2, 0, 1, 2],
+           [3, 4, 5, 3, 4, 5]])
+    >>> np.r_['0,2', [1,2,3], [4,5,6]] # concatenate along first axis, dim>=2
+    array([[1, 2, 3],
+           [4, 5, 6]])
+
+    >>> np.r_['0,2,0', [1,2,3], [4,5,6]]
+    array([[1],
+           [2],
+           [3],
+           [4],
+           [5],
+           [6]])
+    >>> np.r_['1,2,0', [1,2,3], [4,5,6]]
+    array([[1, 4],
+           [2, 5],
+           [3, 6]])
+
+    Using 'r' or 'c' as a first string argument creates a matrix.
+
+    >>> np.r_['r',[1,2,3], [4,5,6]]
+    matrix([[1, 2, 3, 4, 5, 6]])
+
+    """
+    __slots__ = ()
+
+    def __init__(self):
+        AxisConcatenator.__init__(self, 0)
+
+
+r_ = RClass()
+
+
+class CClass(AxisConcatenator):
+    """
+    Translates slice objects to concatenation along the second axis.
+
+    This is short-hand for ``np.r_['-1,2,0', index expression]``, which is
+    useful because of its common occurrence. In particular, arrays will be
+    stacked along their last axis after being upgraded to at least 2-D with
+    1's post-pended to the shape (column vectors made out of 1-D arrays).
+
+    See Also
+    --------
+    column_stack : Stack 1-D arrays as columns into a 2-D array.
+    r_ : For more detailed documentation.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> np.c_[np.array([1,2,3]), np.array([4,5,6])]
+    array([[1, 4],
+           [2, 5],
+           [3, 6]])
+    >>> np.c_[np.array([[1,2,3]]), 0, 0, np.array([[4,5,6]])]
+    array([[1, 2, 3, ..., 4, 5, 6]])
+
+    """
+    __slots__ = ()
+
+    def __init__(self):
+        AxisConcatenator.__init__(self, -1, ndmin=2, trans1d=0)
+
+
+c_ = CClass()
+
+
+@set_module('numpy')
+class ndenumerate:
+    """
+    Multidimensional index iterator.
+
+    Return an iterator yielding pairs of array coordinates and values.
+
+    Parameters
+    ----------
+    arr : ndarray
+      Input array.
+
+    See Also
+    --------
+    ndindex, flatiter
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> a = np.array([[1, 2], [3, 4]])
+    >>> for index, x in np.ndenumerate(a):
+    ...     print(index, x)
+    (0, 0) 1
+    (0, 1) 2
+    (1, 0) 3
+    (1, 1) 4
+
+    """
+
+    def __init__(self, arr):
+        self.iter = np.asarray(arr).flat
+
+    def __next__(self):
+        """
+        Standard iterator method, returns the index tuple and array value.
+
+        Returns
+        -------
+        coords : tuple of ints
+            The indices of the current iteration.
+        val : scalar
+            The array element of the current iteration.
+
+        """
+        return self.iter.coords, next(self.iter)
+
+    def __iter__(self):
+        return self
+
+
+@set_module('numpy')
+class ndindex:
+    """
+    An N-dimensional iterator object to index arrays.
+
+    Given the shape of an array, an `ndindex` instance iterates over
+    the N-dimensional index of the array. At each iteration a tuple
+    of indices is returned, the last dimension is iterated over first.
+
+    Parameters
+    ----------
+    shape : ints, or a single tuple of ints
+        The size of each dimension of the array can be passed as
+        individual parameters or as the elements of a tuple.
+
+    See Also
+    --------
+    ndenumerate, flatiter
+
+    Examples
+    --------
+    >>> import numpy as np
+
+    Dimensions as individual arguments
+
+    >>> for index in np.ndindex(3, 2, 1):
+    ...     print(index)
+    (0, 0, 0)
+    (0, 1, 0)
+    (1, 0, 0)
+    (1, 1, 0)
+    (2, 0, 0)
+    (2, 1, 0)
+
+    Same dimensions - but in a tuple ``(3, 2, 1)``
+
+    >>> for index in np.ndindex((3, 2, 1)):
+    ...     print(index)
+    (0, 0, 0)
+    (0, 1, 0)
+    (1, 0, 0)
+    (1, 1, 0)
+    (2, 0, 0)
+    (2, 1, 0)
+
+    """
+
+    def __init__(self, *shape):
+        if len(shape) == 1 and isinstance(shape[0], tuple):
+            shape = shape[0]
+        x = as_strided(_nx.zeros(1), shape=shape,
+                       strides=_nx.zeros_like(shape))
+        self._it = _nx.nditer(x, flags=['multi_index', 'zerosize_ok'],
+                              order='C')
+
+    def __iter__(self):
+        return self
+
+    def ndincr(self):
+        """
+        Increment the multi-dimensional index by one.
+
+        This method is for backward compatibility only: do not use.
+
+        .. deprecated:: 1.20.0
+            This method has been advised against since numpy 1.8.0, but only
+            started emitting DeprecationWarning as of this version.
+        """
+        # NumPy 1.20.0, 2020-09-08
+        warnings.warn(
+            "`ndindex.ndincr()` is deprecated, use `next(ndindex)` instead",
+            DeprecationWarning, stacklevel=2)
+        next(self)
+
+    def __next__(self):
+        """
+        Standard iterator method, updates the index and returns the index
+        tuple.
+
+        Returns
+        -------
+        val : tuple of ints
+            Returns a tuple containing the indices of the current
+            iteration.
+
+        """
+        next(self._it)
+        return self._it.multi_index
+
+
+# You can do all this with slice() plus a few special objects,
+# but there's a lot to remember. This version is simpler because
+# it uses the standard array indexing syntax.
+#
+# Written by Konrad Hinsen 
+# last revision: 1999-7-23
+#
+# Cosmetic changes by T. Oliphant 2001
+#
+#
+
+class IndexExpression:
+    """
+    A nicer way to build up index tuples for arrays.
+
+    .. note::
+       Use one of the two predefined instances ``index_exp`` or `s_`
+       rather than directly using `IndexExpression`.
+
+    For any index combination, including slicing and axis insertion,
+    ``a[indices]`` is the same as ``a[np.index_exp[indices]]`` for any
+    array `a`. However, ``np.index_exp[indices]`` can be used anywhere
+    in Python code and returns a tuple of slice objects that can be
+    used in the construction of complex index expressions.
+
+    Parameters
+    ----------
+    maketuple : bool
+        If True, always returns a tuple.
+
+    See Also
+    --------
+    s_ : Predefined instance without tuple conversion:
+       `s_ = IndexExpression(maketuple=False)`.
+       The ``index_exp`` is another predefined instance that
+       always returns a tuple:
+       `index_exp = IndexExpression(maketuple=True)`.
+
+    Notes
+    -----
+    You can do all this with :class:`slice` plus a few special objects,
+    but there's a lot to remember and this version is simpler because
+    it uses the standard array indexing syntax.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> np.s_[2::2]
+    slice(2, None, 2)
+    >>> np.index_exp[2::2]
+    (slice(2, None, 2),)
+
+    >>> np.array([0, 1, 2, 3, 4])[np.s_[2::2]]
+    array([2, 4])
+
+    """
+    __slots__ = ('maketuple',)
+
+    def __init__(self, maketuple):
+        self.maketuple = maketuple
+
+    def __getitem__(self, item):
+        if self.maketuple and not isinstance(item, tuple):
+            return (item,)
+        else:
+            return item
+
+
+index_exp = IndexExpression(maketuple=True)
+s_ = IndexExpression(maketuple=False)
+
+# End contribution from Konrad.
+
+
+# The following functions complement those in twodim_base, but are
+# applicable to N-dimensions.
+
+
+def _fill_diagonal_dispatcher(a, val, wrap=None):
+    return (a,)
+
+
+@array_function_dispatch(_fill_diagonal_dispatcher)
+def fill_diagonal(a, val, wrap=False):
+    """Fill the main diagonal of the given array of any dimensionality.
+
+    For an array `a` with ``a.ndim >= 2``, the diagonal is the list of
+    values ``a[i, ..., i]`` with indices ``i`` all identical.  This function
+    modifies the input array in-place without returning a value.
+
+    Parameters
+    ----------
+    a : array, at least 2-D.
+      Array whose diagonal is to be filled in-place.
+    val : scalar or array_like
+      Value(s) to write on the diagonal. If `val` is scalar, the value is
+      written along the diagonal. If array-like, the flattened `val` is
+      written along the diagonal, repeating if necessary to fill all
+      diagonal entries.
+
+    wrap : bool
+      For tall matrices in NumPy version up to 1.6.2, the
+      diagonal "wrapped" after N columns. You can have this behavior
+      with this option. This affects only tall matrices.
+
+    See also
+    --------
+    diag_indices, diag_indices_from
+
+    Notes
+    -----
+    .. versionadded:: 1.4.0
+
+    This functionality can be obtained via `diag_indices`, but internally
+    this version uses a much faster implementation that never constructs the
+    indices and uses simple slicing.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> a = np.zeros((3, 3), int)
+    >>> np.fill_diagonal(a, 5)
+    >>> a
+    array([[5, 0, 0],
+           [0, 5, 0],
+           [0, 0, 5]])
+
+    The same function can operate on a 4-D array:
+
+    >>> a = np.zeros((3, 3, 3, 3), int)
+    >>> np.fill_diagonal(a, 4)
+
+    We only show a few blocks for clarity:
+
+    >>> a[0, 0]
+    array([[4, 0, 0],
+           [0, 0, 0],
+           [0, 0, 0]])
+    >>> a[1, 1]
+    array([[0, 0, 0],
+           [0, 4, 0],
+           [0, 0, 0]])
+    >>> a[2, 2]
+    array([[0, 0, 0],
+           [0, 0, 0],
+           [0, 0, 4]])
+
+    The wrap option affects only tall matrices:
+
+    >>> # tall matrices no wrap
+    >>> a = np.zeros((5, 3), int)
+    >>> np.fill_diagonal(a, 4)
+    >>> a
+    array([[4, 0, 0],
+           [0, 4, 0],
+           [0, 0, 4],
+           [0, 0, 0],
+           [0, 0, 0]])
+
+    >>> # tall matrices wrap
+    >>> a = np.zeros((5, 3), int)
+    >>> np.fill_diagonal(a, 4, wrap=True)
+    >>> a
+    array([[4, 0, 0],
+           [0, 4, 0],
+           [0, 0, 4],
+           [0, 0, 0],
+           [4, 0, 0]])
+
+    >>> # wide matrices
+    >>> a = np.zeros((3, 5), int)
+    >>> np.fill_diagonal(a, 4, wrap=True)
+    >>> a
+    array([[4, 0, 0, 0, 0],
+           [0, 4, 0, 0, 0],
+           [0, 0, 4, 0, 0]])
+
+    The anti-diagonal can be filled by reversing the order of elements
+    using either `numpy.flipud` or `numpy.fliplr`.
+
+    >>> a = np.zeros((3, 3), int);
+    >>> np.fill_diagonal(np.fliplr(a), [1,2,3])  # Horizontal flip
+    >>> a
+    array([[0, 0, 1],
+           [0, 2, 0],
+           [3, 0, 0]])
+    >>> np.fill_diagonal(np.flipud(a), [1,2,3])  # Vertical flip
+    >>> a
+    array([[0, 0, 3],
+           [0, 2, 0],
+           [1, 0, 0]])
+
+    Note that the order in which the diagonal is filled varies depending
+    on the flip function.
+    """
+    if a.ndim < 2:
+        raise ValueError("array must be at least 2-d")
+    end = None
+    if a.ndim == 2:
+        # Explicit, fast formula for the common case.  For 2-d arrays, we
+        # accept rectangular ones.
+        step = a.shape[1] + 1
+        # This is needed to don't have tall matrix have the diagonal wrap.
+        if not wrap:
+            end = a.shape[1] * a.shape[1]
+    else:
+        # For more than d=2, the strided formula is only valid for arrays with
+        # all dimensions equal, so we check first.
+        if not np.all(diff(a.shape) == 0):
+            raise ValueError("All dimensions of input must be of equal length")
+        step = 1 + (np.cumprod(a.shape[:-1])).sum()
+
+    # Write the value out into the diagonal.
+    a.flat[:end:step] = val
+
+
+@set_module('numpy')
+def diag_indices(n, ndim=2):
+    """
+    Return the indices to access the main diagonal of an array.
+
+    This returns a tuple of indices that can be used to access the main
+    diagonal of an array `a` with ``a.ndim >= 2`` dimensions and shape
+    (n, n, ..., n). For ``a.ndim = 2`` this is the usual diagonal, for
+    ``a.ndim > 2`` this is the set of indices to access ``a[i, i, ..., i]``
+    for ``i = [0..n-1]``.
+
+    Parameters
+    ----------
+    n : int
+      The size, along each dimension, of the arrays for which the returned
+      indices can be used.
+
+    ndim : int, optional
+      The number of dimensions.
+
+    See Also
+    --------
+    diag_indices_from
+
+    Notes
+    -----
+    .. versionadded:: 1.4.0
+
+    Examples
+    --------
+    >>> import numpy as np
+
+    Create a set of indices to access the diagonal of a (4, 4) array:
+
+    >>> di = np.diag_indices(4)
+    >>> di
+    (array([0, 1, 2, 3]), array([0, 1, 2, 3]))
+    >>> a = np.arange(16).reshape(4, 4)
+    >>> a
+    array([[ 0,  1,  2,  3],
+           [ 4,  5,  6,  7],
+           [ 8,  9, 10, 11],
+           [12, 13, 14, 15]])
+    >>> a[di] = 100
+    >>> a
+    array([[100,   1,   2,   3],
+           [  4, 100,   6,   7],
+           [  8,   9, 100,  11],
+           [ 12,  13,  14, 100]])
+
+    Now, we create indices to manipulate a 3-D array:
+
+    >>> d3 = np.diag_indices(2, 3)
+    >>> d3
+    (array([0, 1]), array([0, 1]), array([0, 1]))
+
+    And use it to set the diagonal of an array of zeros to 1:
+
+    >>> a = np.zeros((2, 2, 2), dtype=int)
+    >>> a[d3] = 1
+    >>> a
+    array([[[1, 0],
+            [0, 0]],
+           [[0, 0],
+            [0, 1]]])
+
+    """
+    idx = np.arange(n)
+    return (idx,) * ndim
+
+
+def _diag_indices_from(arr):
+    return (arr,)
+
+
+@array_function_dispatch(_diag_indices_from)
+def diag_indices_from(arr):
+    """
+    Return the indices to access the main diagonal of an n-dimensional array.
+
+    See `diag_indices` for full details.
+
+    Parameters
+    ----------
+    arr : array, at least 2-D
+
+    See Also
+    --------
+    diag_indices
+
+    Notes
+    -----
+    .. versionadded:: 1.4.0
+
+    Examples
+    --------
+    >>> import numpy as np
+
+    Create a 4 by 4 array.
+
+    >>> a = np.arange(16).reshape(4, 4)
+    >>> a
+    array([[ 0,  1,  2,  3],
+           [ 4,  5,  6,  7],
+           [ 8,  9, 10, 11],
+           [12, 13, 14, 15]])
+
+    Get the indices of the diagonal elements.
+
+    >>> di = np.diag_indices_from(a)
+    >>> di
+    (array([0, 1, 2, 3]), array([0, 1, 2, 3]))
+
+    >>> a[di]
+    array([ 0,  5, 10, 15])
+
+    This is simply syntactic sugar for diag_indices.
+
+    >>> np.diag_indices(a.shape[0])
+    (array([0, 1, 2, 3]), array([0, 1, 2, 3]))
+
+    """
+
+    if not arr.ndim >= 2:
+        raise ValueError("input array must be at least 2-d")
+    # For more than d=2, the strided formula is only valid for arrays with
+    # all dimensions equal, so we check first.
+    if not np.all(diff(arr.shape) == 0):
+        raise ValueError("All dimensions of input must be of equal length")
+
+    return diag_indices(arr.shape[0], arr.ndim)
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/_index_tricks_impl.pyi b/venv/lib/python3.12/site-packages/numpy/lib/_index_tricks_impl.pyi
new file mode 100644
index 00000000..f13ab4d9
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/lib/_index_tricks_impl.pyi
@@ -0,0 +1,154 @@
+from collections.abc import Sequence
+from typing import (
+    Any,
+    TypeVar,
+    Generic,
+    overload,
+    Literal,
+    SupportsIndex,
+)
+
+import numpy as np
+from numpy import (
+    # Circumvent a naming conflict with `AxisConcatenator.matrix`
+    matrix as _Matrix,
+    ndenumerate as ndenumerate,
+    ndindex as ndindex,
+    ndarray,
+    dtype,
+    str_,
+    bytes_,
+    int_,
+    float64,
+    complex128,
+)
+from numpy._typing import (
+    # Arrays
+    ArrayLike,
+    _NestedSequence,
+    _FiniteNestedSequence,
+    NDArray,
+
+    # DTypes
+    DTypeLike,
+    _SupportsDType,
+)
+
+from numpy._core.multiarray import (
+    unravel_index as unravel_index,
+    ravel_multi_index as ravel_multi_index,
+)
+
+_T = TypeVar("_T")
+_DType = TypeVar("_DType", bound=dtype[Any])
+_BoolType = TypeVar("_BoolType", Literal[True], Literal[False])
+_TupType = TypeVar("_TupType", bound=tuple[Any, ...])
+_ArrayType = TypeVar("_ArrayType", bound=NDArray[Any])
+
+__all__: list[str]
+
+@overload
+def ix_(*args: _FiniteNestedSequence[_SupportsDType[_DType]]) -> tuple[ndarray[Any, _DType], ...]: ...
+@overload
+def ix_(*args: str | _NestedSequence[str]) -> tuple[NDArray[str_], ...]: ...
+@overload
+def ix_(*args: bytes | _NestedSequence[bytes]) -> tuple[NDArray[bytes_], ...]: ...
+@overload
+def ix_(*args: bool | _NestedSequence[bool]) -> tuple[NDArray[np.bool], ...]: ...
+@overload
+def ix_(*args: int | _NestedSequence[int]) -> tuple[NDArray[int_], ...]: ...
+@overload
+def ix_(*args: float | _NestedSequence[float]) -> tuple[NDArray[float64], ...]: ...
+@overload
+def ix_(*args: complex | _NestedSequence[complex]) -> tuple[NDArray[complex128], ...]: ...
+
+class nd_grid(Generic[_BoolType]):
+    sparse: _BoolType
+    def __init__(self, sparse: _BoolType = ...) -> None: ...
+    @overload
+    def __getitem__(
+        self: nd_grid[Literal[False]],
+        key: slice | Sequence[slice],
+    ) -> NDArray[Any]: ...
+    @overload
+    def __getitem__(
+        self: nd_grid[Literal[True]],
+        key: slice | Sequence[slice],
+    ) -> tuple[NDArray[Any], ...]: ...
+
+class MGridClass(nd_grid[Literal[False]]):
+    def __init__(self) -> None: ...
+
+mgrid: MGridClass
+
+class OGridClass(nd_grid[Literal[True]]):
+    def __init__(self) -> None: ...
+
+ogrid: OGridClass
+
+class AxisConcatenator:
+    axis: int
+    matrix: bool
+    ndmin: int
+    trans1d: int
+    def __init__(
+        self,
+        axis: int = ...,
+        matrix: bool = ...,
+        ndmin: int = ...,
+        trans1d: int = ...,
+    ) -> None: ...
+    @staticmethod
+    @overload
+    def concatenate(  # type: ignore[misc]
+        *a: ArrayLike, axis: SupportsIndex = ..., out: None = ...
+    ) -> NDArray[Any]: ...
+    @staticmethod
+    @overload
+    def concatenate(
+        *a: ArrayLike, axis: SupportsIndex = ..., out: _ArrayType = ...
+    ) -> _ArrayType: ...
+    @staticmethod
+    def makemat(
+        data: ArrayLike, dtype: DTypeLike = ..., copy: bool = ...
+    ) -> _Matrix[Any, Any]: ...
+
+    # TODO: Sort out this `__getitem__` method
+    def __getitem__(self, key: Any) -> Any: ...
+
+class RClass(AxisConcatenator):
+    axis: Literal[0]
+    matrix: Literal[False]
+    ndmin: Literal[1]
+    trans1d: Literal[-1]
+    def __init__(self) -> None: ...
+
+r_: RClass
+
+class CClass(AxisConcatenator):
+    axis: Literal[-1]
+    matrix: Literal[False]
+    ndmin: Literal[2]
+    trans1d: Literal[0]
+    def __init__(self) -> None: ...
+
+c_: CClass
+
+class IndexExpression(Generic[_BoolType]):
+    maketuple: _BoolType
+    def __init__(self, maketuple: _BoolType) -> None: ...
+    @overload
+    def __getitem__(self, item: _TupType) -> _TupType: ...  # type: ignore[misc]
+    @overload
+    def __getitem__(self: IndexExpression[Literal[True]], item: _T) -> tuple[_T]: ...
+    @overload
+    def __getitem__(self: IndexExpression[Literal[False]], item: _T) -> _T: ...
+
+index_exp: IndexExpression[Literal[True]]
+s_: IndexExpression[Literal[False]]
+
+def fill_diagonal(a: NDArray[Any], val: Any, wrap: bool = ...) -> None: ...
+def diag_indices(n: int, ndim: int = ...) -> tuple[NDArray[int_], ...]: ...
+def diag_indices_from(arr: ArrayLike) -> tuple[NDArray[int_], ...]: ...
+
+# NOTE: see `numpy/__init__.pyi` for `ndenumerate` and `ndindex`
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/_iotools.py b/venv/lib/python3.12/site-packages/numpy/lib/_iotools.py
new file mode 100644
index 00000000..908ca776
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/lib/_iotools.py
@@ -0,0 +1,899 @@
+"""A collection of functions designed to help I/O with ascii files.
+
+"""
+__docformat__ = "restructuredtext en"
+
+import numpy as np
+import numpy._core.numeric as nx
+from numpy._utils import asbytes, asunicode
+
+
+def _decode_line(line, encoding=None):
+    """Decode bytes from binary input streams.
+
+    Defaults to decoding from 'latin1'. That differs from the behavior of
+    np.compat.asunicode that decodes from 'ascii'.
+
+    Parameters
+    ----------
+    line : str or bytes
+         Line to be decoded.
+    encoding : str
+         Encoding used to decode `line`.
+
+    Returns
+    -------
+    decoded_line : str
+
+    """
+    if type(line) is bytes:
+        if encoding is None:
+            encoding = "latin1"
+        line = line.decode(encoding)
+
+    return line
+
+
+def _is_string_like(obj):
+    """
+    Check whether obj behaves like a string.
+    """
+    try:
+        obj + ''
+    except (TypeError, ValueError):
+        return False
+    return True
+
+
+def _is_bytes_like(obj):
+    """
+    Check whether obj behaves like a bytes object.
+    """
+    try:
+        obj + b''
+    except (TypeError, ValueError):
+        return False
+    return True
+
+
+def has_nested_fields(ndtype):
+    """
+    Returns whether one or several fields of a dtype are nested.
+
+    Parameters
+    ----------
+    ndtype : dtype
+        Data-type of a structured array.
+
+    Raises
+    ------
+    AttributeError
+        If `ndtype` does not have a `names` attribute.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> dt = np.dtype([('name', 'S4'), ('x', float), ('y', float)])
+    >>> np.lib._iotools.has_nested_fields(dt)
+    False
+
+    """
+    return any(ndtype[name].names is not None for name in ndtype.names or ())
+
+
+def flatten_dtype(ndtype, flatten_base=False):
+    """
+    Unpack a structured data-type by collapsing nested fields and/or fields
+    with a shape.
+
+    Note that the field names are lost.
+
+    Parameters
+    ----------
+    ndtype : dtype
+        The datatype to collapse
+    flatten_base : bool, optional
+       If True, transform a field with a shape into several fields. Default is
+       False.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> dt = np.dtype([('name', 'S4'), ('x', float), ('y', float),
+    ...                ('block', int, (2, 3))])
+    >>> np.lib._iotools.flatten_dtype(dt)
+    [dtype('S4'), dtype('float64'), dtype('float64'), dtype('int64')]
+    >>> np.lib._iotools.flatten_dtype(dt, flatten_base=True)
+    [dtype('S4'),
+     dtype('float64'),
+     dtype('float64'),
+     dtype('int64'),
+     dtype('int64'),
+     dtype('int64'),
+     dtype('int64'),
+     dtype('int64'),
+     dtype('int64')]
+
+    """
+    names = ndtype.names
+    if names is None:
+        if flatten_base:
+            return [ndtype.base] * int(np.prod(ndtype.shape))
+        return [ndtype.base]
+    else:
+        types = []
+        for field in names:
+            info = ndtype.fields[field]
+            flat_dt = flatten_dtype(info[0], flatten_base)
+            types.extend(flat_dt)
+        return types
+
+
+class LineSplitter:
+    """
+    Object to split a string at a given delimiter or at given places.
+
+    Parameters
+    ----------
+    delimiter : str, int, or sequence of ints, optional
+        If a string, character used to delimit consecutive fields.
+        If an integer or a sequence of integers, width(s) of each field.
+    comments : str, optional
+        Character used to mark the beginning of a comment. Default is '#'.
+    autostrip : bool, optional
+        Whether to strip each individual field. Default is True.
+
+    """
+
+    def autostrip(self, method):
+        """
+        Wrapper to strip each member of the output of `method`.
+
+        Parameters
+        ----------
+        method : function
+            Function that takes a single argument and returns a sequence of
+            strings.
+
+        Returns
+        -------
+        wrapped : function
+            The result of wrapping `method`. `wrapped` takes a single input
+            argument and returns a list of strings that are stripped of
+            white-space.
+
+        """
+        return lambda input: [_.strip() for _ in method(input)]
+
+    def __init__(self, delimiter=None, comments='#', autostrip=True,
+                 encoding=None):
+        delimiter = _decode_line(delimiter)
+        comments = _decode_line(comments)
+
+        self.comments = comments
+
+        # Delimiter is a character
+        if (delimiter is None) or isinstance(delimiter, str):
+            delimiter = delimiter or None
+            _handyman = self._delimited_splitter
+        # Delimiter is a list of field widths
+        elif hasattr(delimiter, '__iter__'):
+            _handyman = self._variablewidth_splitter
+            idx = np.cumsum([0] + list(delimiter))
+            delimiter = [slice(i, j) for (i, j) in zip(idx[:-1], idx[1:])]
+        # Delimiter is a single integer
+        elif int(delimiter):
+            (_handyman, delimiter) = (
+                    self._fixedwidth_splitter, int(delimiter))
+        else:
+            (_handyman, delimiter) = (self._delimited_splitter, None)
+        self.delimiter = delimiter
+        if autostrip:
+            self._handyman = self.autostrip(_handyman)
+        else:
+            self._handyman = _handyman
+        self.encoding = encoding
+
+    def _delimited_splitter(self, line):
+        """Chop off comments, strip, and split at delimiter. """
+        if self.comments is not None:
+            line = line.split(self.comments)[0]
+        line = line.strip(" \r\n")
+        if not line:
+            return []
+        return line.split(self.delimiter)
+
+    def _fixedwidth_splitter(self, line):
+        if self.comments is not None:
+            line = line.split(self.comments)[0]
+        line = line.strip("\r\n")
+        if not line:
+            return []
+        fixed = self.delimiter
+        slices = [slice(i, i + fixed) for i in range(0, len(line), fixed)]
+        return [line[s] for s in slices]
+
+    def _variablewidth_splitter(self, line):
+        if self.comments is not None:
+            line = line.split(self.comments)[0]
+        if not line:
+            return []
+        slices = self.delimiter
+        return [line[s] for s in slices]
+
+    def __call__(self, line):
+        return self._handyman(_decode_line(line, self.encoding))
+
+
+class NameValidator:
+    """
+    Object to validate a list of strings to use as field names.
+
+    The strings are stripped of any non alphanumeric character, and spaces
+    are replaced by '_'. During instantiation, the user can define a list
+    of names to exclude, as well as a list of invalid characters. Names in
+    the exclusion list are appended a '_' character.
+
+    Once an instance has been created, it can be called with a list of
+    names, and a list of valid names will be created.  The `__call__`
+    method accepts an optional keyword "default" that sets the default name
+    in case of ambiguity. By default this is 'f', so that names will
+    default to `f0`, `f1`, etc.
+
+    Parameters
+    ----------
+    excludelist : sequence, optional
+        A list of names to exclude. This list is appended to the default
+        list ['return', 'file', 'print']. Excluded names are appended an
+        underscore: for example, `file` becomes `file_` if supplied.
+    deletechars : str, optional
+        A string combining invalid characters that must be deleted from the
+        names.
+    case_sensitive : {True, False, 'upper', 'lower'}, optional
+        * If True, field names are case-sensitive.
+        * If False or 'upper', field names are converted to upper case.
+        * If 'lower', field names are converted to lower case.
+
+        The default value is True.
+    replace_space : '_', optional
+        Character(s) used in replacement of white spaces.
+
+    Notes
+    -----
+    Calling an instance of `NameValidator` is the same as calling its
+    method `validate`.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> validator = np.lib._iotools.NameValidator()
+    >>> validator(['file', 'field2', 'with space', 'CaSe'])
+    ('file_', 'field2', 'with_space', 'CaSe')
+
+    >>> validator = np.lib._iotools.NameValidator(excludelist=['excl'],
+    ...                                           deletechars='q',
+    ...                                           case_sensitive=False)
+    >>> validator(['excl', 'field2', 'no_q', 'with space', 'CaSe'])
+    ('EXCL', 'FIELD2', 'NO_Q', 'WITH_SPACE', 'CASE')
+
+    """
+
+    defaultexcludelist = ['return', 'file', 'print']
+    defaultdeletechars = set(r"""~!@#$%^&*()-=+~\|]}[{';: /?.>,<""")
+
+    def __init__(self, excludelist=None, deletechars=None,
+                 case_sensitive=None, replace_space='_'):
+        # Process the exclusion list ..
+        if excludelist is None:
+            excludelist = []
+        excludelist.extend(self.defaultexcludelist)
+        self.excludelist = excludelist
+        # Process the list of characters to delete
+        if deletechars is None:
+            delete = self.defaultdeletechars
+        else:
+            delete = set(deletechars)
+        delete.add('"')
+        self.deletechars = delete
+        # Process the case option .....
+        if (case_sensitive is None) or (case_sensitive is True):
+            self.case_converter = lambda x: x
+        elif (case_sensitive is False) or case_sensitive.startswith('u'):
+            self.case_converter = lambda x: x.upper()
+        elif case_sensitive.startswith('l'):
+            self.case_converter = lambda x: x.lower()
+        else:
+            msg = 'unrecognized case_sensitive value %s.' % case_sensitive
+            raise ValueError(msg)
+
+        self.replace_space = replace_space
+
+    def validate(self, names, defaultfmt="f%i", nbfields=None):
+        """
+        Validate a list of strings as field names for a structured array.
+
+        Parameters
+        ----------
+        names : sequence of str
+            Strings to be validated.
+        defaultfmt : str, optional
+            Default format string, used if validating a given string
+            reduces its length to zero.
+        nbfields : integer, optional
+            Final number of validated names, used to expand or shrink the
+            initial list of names.
+
+        Returns
+        -------
+        validatednames : list of str
+            The list of validated field names.
+
+        Notes
+        -----
+        A `NameValidator` instance can be called directly, which is the
+        same as calling `validate`. For examples, see `NameValidator`.
+
+        """
+        # Initial checks ..............
+        if (names is None):
+            if (nbfields is None):
+                return None
+            names = []
+        if isinstance(names, str):
+            names = [names, ]
+        if nbfields is not None:
+            nbnames = len(names)
+            if (nbnames < nbfields):
+                names = list(names) + [''] * (nbfields - nbnames)
+            elif (nbnames > nbfields):
+                names = names[:nbfields]
+        # Set some shortcuts ...........
+        deletechars = self.deletechars
+        excludelist = self.excludelist
+        case_converter = self.case_converter
+        replace_space = self.replace_space
+        # Initializes some variables ...
+        validatednames = []
+        seen = dict()
+        nbempty = 0
+
+        for item in names:
+            item = case_converter(item).strip()
+            if replace_space:
+                item = item.replace(' ', replace_space)
+            item = ''.join([c for c in item if c not in deletechars])
+            if item == '':
+                item = defaultfmt % nbempty
+                while item in names:
+                    nbempty += 1
+                    item = defaultfmt % nbempty
+                nbempty += 1
+            elif item in excludelist:
+                item += '_'
+            cnt = seen.get(item, 0)
+            if cnt > 0:
+                validatednames.append(item + '_%d' % cnt)
+            else:
+                validatednames.append(item)
+            seen[item] = cnt + 1
+        return tuple(validatednames)
+
+    def __call__(self, names, defaultfmt="f%i", nbfields=None):
+        return self.validate(names, defaultfmt=defaultfmt, nbfields=nbfields)
+
+
+def str2bool(value):
+    """
+    Tries to transform a string supposed to represent a boolean to a boolean.
+
+    Parameters
+    ----------
+    value : str
+        The string that is transformed to a boolean.
+
+    Returns
+    -------
+    boolval : bool
+        The boolean representation of `value`.
+
+    Raises
+    ------
+    ValueError
+        If the string is not 'True' or 'False' (case independent)
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> np.lib._iotools.str2bool('TRUE')
+    True
+    >>> np.lib._iotools.str2bool('false')
+    False
+
+    """
+    value = value.upper()
+    if value == 'TRUE':
+        return True
+    elif value == 'FALSE':
+        return False
+    else:
+        raise ValueError("Invalid boolean")
+
+
+class ConverterError(Exception):
+    """
+    Exception raised when an error occurs in a converter for string values.
+
+    """
+    pass
+
+
+class ConverterLockError(ConverterError):
+    """
+    Exception raised when an attempt is made to upgrade a locked converter.
+
+    """
+    pass
+
+
+class ConversionWarning(UserWarning):
+    """
+    Warning issued when a string converter has a problem.
+
+    Notes
+    -----
+    In `genfromtxt` a `ConversionWarning` is issued if raising exceptions
+    is explicitly suppressed with the "invalid_raise" keyword.
+
+    """
+    pass
+
+
+class StringConverter:
+    """
+    Factory class for function transforming a string into another object
+    (int, float).
+
+    After initialization, an instance can be called to transform a string
+    into another object. If the string is recognized as representing a
+    missing value, a default value is returned.
+
+    Attributes
+    ----------
+    func : function
+        Function used for the conversion.
+    default : any
+        Default value to return when the input corresponds to a missing
+        value.
+    type : type
+        Type of the output.
+    _status : int
+        Integer representing the order of the conversion.
+    _mapper : sequence of tuples
+        Sequence of tuples (dtype, function, default value) to evaluate in
+        order.
+    _locked : bool
+        Holds `locked` parameter.
+
+    Parameters
+    ----------
+    dtype_or_func : {None, dtype, function}, optional
+        If a `dtype`, specifies the input data type, used to define a basic
+        function and a default value for missing data. For example, when
+        `dtype` is float, the `func` attribute is set to `float` and the
+        default value to `np.nan`.  If a function, this function is used to
+        convert a string to another object. In this case, it is recommended
+        to give an associated default value as input.
+    default : any, optional
+        Value to return by default, that is, when the string to be
+        converted is flagged as missing. If not given, `StringConverter`
+        tries to supply a reasonable default value.
+    missing_values : {None, sequence of str}, optional
+        ``None`` or sequence of strings indicating a missing value. If ``None``
+        then missing values are indicated by empty entries. The default is
+        ``None``.
+    locked : bool, optional
+        Whether the StringConverter should be locked to prevent automatic
+        upgrade or not. Default is False.
+
+    """
+    _mapper = [(nx.bool, str2bool, False),
+               (nx.int_, int, -1),]
+
+    # On 32-bit systems, we need to make sure that we explicitly include
+    # nx.int64 since ns.int_ is nx.int32.
+    if nx.dtype(nx.int_).itemsize < nx.dtype(nx.int64).itemsize:
+        _mapper.append((nx.int64, int, -1))
+
+    _mapper.extend([(nx.float64, float, nx.nan),
+                    (nx.complex128, complex, nx.nan + 0j),
+                    (nx.longdouble, nx.longdouble, nx.nan),
+                    # If a non-default dtype is passed, fall back to generic
+                    # ones (should only be used for the converter)
+                    (nx.integer, int, -1),
+                    (nx.floating, float, nx.nan),
+                    (nx.complexfloating, complex, nx.nan + 0j),
+                    # Last, try with the string types (must be last, because
+                    # `_mapper[-1]` is used as default in some cases)
+                    (nx.str_, asunicode, '???'),
+                    (nx.bytes_, asbytes, '???'),
+                    ])
+
+    @classmethod
+    def _getdtype(cls, val):
+        """Returns the dtype of the input variable."""
+        return np.array(val).dtype
+
+    @classmethod
+    def _getsubdtype(cls, val):
+        """Returns the type of the dtype of the input variable."""
+        return np.array(val).dtype.type
+
+    @classmethod
+    def _dtypeortype(cls, dtype):
+        """Returns dtype for datetime64 and type of dtype otherwise."""
+
+        # This is a bit annoying. We want to return the "general" type in most
+        # cases (ie. "string" rather than "S10"), but we want to return the
+        # specific type for datetime64 (ie. "datetime64[us]" rather than
+        # "datetime64").
+        if dtype.type == np.datetime64:
+            return dtype
+        return dtype.type
+
+    @classmethod
+    def upgrade_mapper(cls, func, default=None):
+        """
+        Upgrade the mapper of a StringConverter by adding a new function and
+        its corresponding default.
+
+        The input function (or sequence of functions) and its associated
+        default value (if any) is inserted in penultimate position of the
+        mapper.  The corresponding type is estimated from the dtype of the
+        default value.
+
+        Parameters
+        ----------
+        func : var
+            Function, or sequence of functions
+
+        Examples
+        --------
+        >>> import dateutil.parser
+        >>> import datetime
+        >>> dateparser = dateutil.parser.parse
+        >>> defaultdate = datetime.date(2000, 1, 1)
+        >>> StringConverter.upgrade_mapper(dateparser, default=defaultdate)
+        """
+        # Func is a single functions
+        if callable(func):
+            cls._mapper.insert(-1, (cls._getsubdtype(default), func, default))
+            return
+        elif hasattr(func, '__iter__'):
+            if isinstance(func[0], (tuple, list)):
+                for _ in func:
+                    cls._mapper.insert(-1, _)
+                return
+            if default is None:
+                default = [None] * len(func)
+            else:
+                default = list(default)
+                default.append([None] * (len(func) - len(default)))
+            for fct, dft in zip(func, default):
+                cls._mapper.insert(-1, (cls._getsubdtype(dft), fct, dft))
+
+    @classmethod
+    def _find_map_entry(cls, dtype):
+        # if a converter for the specific dtype is available use that
+        for i, (deftype, func, default_def) in enumerate(cls._mapper):
+            if dtype.type == deftype:
+                return i, (deftype, func, default_def)
+
+        # otherwise find an inexact match
+        for i, (deftype, func, default_def) in enumerate(cls._mapper):
+            if np.issubdtype(dtype.type, deftype):
+                return i, (deftype, func, default_def)
+
+        raise LookupError
+
+    def __init__(self, dtype_or_func=None, default=None, missing_values=None,
+                 locked=False):
+        # Defines a lock for upgrade
+        self._locked = bool(locked)
+        # No input dtype: minimal initialization
+        if dtype_or_func is None:
+            self.func = str2bool
+            self._status = 0
+            self.default = default or False
+            dtype = np.dtype('bool')
+        else:
+            # Is the input a np.dtype ?
+            try:
+                self.func = None
+                dtype = np.dtype(dtype_or_func)
+            except TypeError:
+                # dtype_or_func must be a function, then
+                if not callable(dtype_or_func):
+                    errmsg = ("The input argument `dtype` is neither a"
+                              " function nor a dtype (got '%s' instead)")
+                    raise TypeError(errmsg % type(dtype_or_func))
+                # Set the function
+                self.func = dtype_or_func
+                # If we don't have a default, try to guess it or set it to
+                # None
+                if default is None:
+                    try:
+                        default = self.func('0')
+                    except ValueError:
+                        default = None
+                dtype = self._getdtype(default)
+
+            # find the best match in our mapper
+            try:
+                self._status, (_, func, default_def) = self._find_map_entry(dtype)
+            except LookupError:
+                # no match
+                self.default = default
+                _, func, _ = self._mapper[-1]
+                self._status = 0
+            else:
+                # use the found default only if we did not already have one
+                if default is None:
+                    self.default = default_def
+                else:
+                    self.default = default
+
+            # If the input was a dtype, set the function to the last we saw
+            if self.func is None:
+                self.func = func
+
+            # If the status is 1 (int), change the function to
+            # something more robust.
+            if self.func == self._mapper[1][1]:
+                if issubclass(dtype.type, np.uint64):
+                    self.func = np.uint64
+                elif issubclass(dtype.type, np.int64):
+                    self.func = np.int64
+                else:
+                    self.func = lambda x: int(float(x))
+        # Store the list of strings corresponding to missing values.
+        if missing_values is None:
+            self.missing_values = {''}
+        else:
+            if isinstance(missing_values, str):
+                missing_values = missing_values.split(",")
+            self.missing_values = set(list(missing_values) + [''])
+
+        self._callingfunction = self._strict_call
+        self.type = self._dtypeortype(dtype)
+        self._checked = False
+        self._initial_default = default
+
+    def _loose_call(self, value):
+        try:
+            return self.func(value)
+        except ValueError:
+            return self.default
+
+    def _strict_call(self, value):
+        try:
+
+            # We check if we can convert the value using the current function
+            new_value = self.func(value)
+
+            # In addition to having to check whether func can convert the
+            # value, we also have to make sure that we don't get overflow
+            # errors for integers.
+            if self.func is int:
+                try:
+                    np.array(value, dtype=self.type)
+                except OverflowError:
+                    raise ValueError
+
+            # We're still here so we can now return the new value
+            return new_value
+
+        except ValueError:
+            if value.strip() in self.missing_values:
+                if not self._status:
+                    self._checked = False
+                return self.default
+            raise ValueError("Cannot convert string '%s'" % value)
+
+    def __call__(self, value):
+        return self._callingfunction(value)
+
+    def _do_upgrade(self):
+        # Raise an exception if we locked the converter...
+        if self._locked:
+            errmsg = "Converter is locked and cannot be upgraded"
+            raise ConverterLockError(errmsg)
+        _statusmax = len(self._mapper)
+        # Complains if we try to upgrade by the maximum
+        _status = self._status
+        if _status == _statusmax:
+            errmsg = "Could not find a valid conversion function"
+            raise ConverterError(errmsg)
+        elif _status < _statusmax - 1:
+            _status += 1
+        self.type, self.func, default = self._mapper[_status]
+        self._status = _status
+        if self._initial_default is not None:
+            self.default = self._initial_default
+        else:
+            self.default = default
+
+    def upgrade(self, value):
+        """
+        Find the best converter for a given string, and return the result.
+
+        The supplied string `value` is converted by testing different
+        converters in order. First the `func` method of the
+        `StringConverter` instance is tried, if this fails other available
+        converters are tried.  The order in which these other converters
+        are tried is determined by the `_status` attribute of the instance.
+
+        Parameters
+        ----------
+        value : str
+            The string to convert.
+
+        Returns
+        -------
+        out : any
+            The result of converting `value` with the appropriate converter.
+
+        """
+        self._checked = True
+        try:
+            return self._strict_call(value)
+        except ValueError:
+            self._do_upgrade()
+            return self.upgrade(value)
+
+    def iterupgrade(self, value):
+        self._checked = True
+        if not hasattr(value, '__iter__'):
+            value = (value,)
+        _strict_call = self._strict_call
+        try:
+            for _m in value:
+                _strict_call(_m)
+        except ValueError:
+            self._do_upgrade()
+            self.iterupgrade(value)
+
+    def update(self, func, default=None, testing_value=None,
+               missing_values='', locked=False):
+        """
+        Set StringConverter attributes directly.
+
+        Parameters
+        ----------
+        func : function
+            Conversion function.
+        default : any, optional
+            Value to return by default, that is, when the string to be
+            converted is flagged as missing. If not given,
+            `StringConverter` tries to supply a reasonable default value.
+        testing_value : str, optional
+            A string representing a standard input value of the converter.
+            This string is used to help defining a reasonable default
+            value.
+        missing_values : {sequence of str, None}, optional
+            Sequence of strings indicating a missing value. If ``None``, then
+            the existing `missing_values` are cleared. The default is ``''``.
+        locked : bool, optional
+            Whether the StringConverter should be locked to prevent
+            automatic upgrade or not. Default is False.
+
+        Notes
+        -----
+        `update` takes the same parameters as the constructor of
+        `StringConverter`, except that `func` does not accept a `dtype`
+        whereas `dtype_or_func` in the constructor does.
+
+        """
+        self.func = func
+        self._locked = locked
+
+        # Don't reset the default to None if we can avoid it
+        if default is not None:
+            self.default = default
+            self.type = self._dtypeortype(self._getdtype(default))
+        else:
+            try:
+                tester = func(testing_value or '1')
+            except (TypeError, ValueError):
+                tester = None
+            self.type = self._dtypeortype(self._getdtype(tester))
+
+        # Add the missing values to the existing set or clear it.
+        if missing_values is None:
+            # Clear all missing values even though the ctor initializes it to
+            # set(['']) when the argument is None.
+            self.missing_values = set()
+        else:
+            if not np.iterable(missing_values):
+                missing_values = [missing_values]
+            if not all(isinstance(v, str) for v in missing_values):
+                raise TypeError("missing_values must be strings or unicode")
+            self.missing_values.update(missing_values)
+
+
+def easy_dtype(ndtype, names=None, defaultfmt="f%i", **validationargs):
+    """
+    Convenience function to create a `np.dtype` object.
+
+    The function processes the input `dtype` and matches it with the given
+    names.
+
+    Parameters
+    ----------
+    ndtype : var
+        Definition of the dtype. Can be any string or dictionary recognized
+        by the `np.dtype` function, or a sequence of types.
+    names : str or sequence, optional
+        Sequence of strings to use as field names for a structured dtype.
+        For convenience, `names` can be a string of a comma-separated list
+        of names.
+    defaultfmt : str, optional
+        Format string used to define missing names, such as ``"f%i"``
+        (default) or ``"fields_%02i"``.
+    validationargs : optional
+        A series of optional arguments used to initialize a
+        `NameValidator`.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> np.lib._iotools.easy_dtype(float)
+    dtype('float64')
+    >>> np.lib._iotools.easy_dtype("i4, f8")
+    dtype([('f0', '>> np.lib._iotools.easy_dtype("i4, f8", defaultfmt="field_%03i")
+    dtype([('field_000', '>> np.lib._iotools.easy_dtype((int, float, float), names="a,b,c")
+    dtype([('a', '>> np.lib._iotools.easy_dtype(float, names="a,b,c")
+    dtype([('a', '>> import numpy as np
+    >>> a = np.array([[1, 2], [3, np.nan]])
+    >>> np.nanmin(a)
+    1.0
+    >>> np.nanmin(a, axis=0)
+    array([1.,  2.])
+    >>> np.nanmin(a, axis=1)
+    array([1.,  3.])
+
+    When positive infinity and negative infinity are present:
+
+    >>> np.nanmin([1, 2, np.nan, np.inf])
+    1.0
+    >>> np.nanmin([1, 2, np.nan, -np.inf])
+    -inf
+
+    """
+    kwargs = {}
+    if keepdims is not np._NoValue:
+        kwargs['keepdims'] = keepdims
+    if initial is not np._NoValue:
+        kwargs['initial'] = initial
+    if where is not np._NoValue:
+        kwargs['where'] = where
+
+    if type(a) is np.ndarray and a.dtype != np.object_:
+        # Fast, but not safe for subclasses of ndarray, or object arrays,
+        # which do not implement isnan (gh-9009), or fmin correctly (gh-8975)
+        res = np.fmin.reduce(a, axis=axis, out=out, **kwargs)
+        if np.isnan(res).any():
+            warnings.warn("All-NaN slice encountered", RuntimeWarning,
+                          stacklevel=2)
+    else:
+        # Slow, but safe for subclasses of ndarray
+        a, mask = _replace_nan(a, +np.inf)
+        res = np.amin(a, axis=axis, out=out, **kwargs)
+        if mask is None:
+            return res
+
+        # Check for all-NaN axis
+        kwargs.pop("initial", None)
+        mask = np.all(mask, axis=axis, **kwargs)
+        if np.any(mask):
+            res = _copyto(res, np.nan, mask)
+            warnings.warn("All-NaN axis encountered", RuntimeWarning,
+                          stacklevel=2)
+    return res
+
+
+def _nanmax_dispatcher(a, axis=None, out=None, keepdims=None,
+                       initial=None, where=None):
+    return (a, out)
+
+
+@array_function_dispatch(_nanmax_dispatcher)
+def nanmax(a, axis=None, out=None, keepdims=np._NoValue, initial=np._NoValue,
+           where=np._NoValue):
+    """
+    Return the maximum of an array or maximum along an axis, ignoring any
+    NaNs.  When all-NaN slices are encountered a ``RuntimeWarning`` is
+    raised and NaN is returned for that slice.
+
+    Parameters
+    ----------
+    a : array_like
+        Array containing numbers whose maximum is desired. If `a` is not an
+        array, a conversion is attempted.
+    axis : {int, tuple of int, None}, optional
+        Axis or axes along which the maximum is computed. The default is to compute
+        the maximum of the flattened array.
+    out : ndarray, optional
+        Alternate output array in which to place the result.  The default
+        is ``None``; if provided, it must have the same shape as the
+        expected output, but the type will be cast if necessary. See
+        :ref:`ufuncs-output-type` for more details.
+
+        .. versionadded:: 1.8.0
+    keepdims : bool, optional
+        If this is set to True, the axes which are reduced are left
+        in the result as dimensions with size one. With this option,
+        the result will broadcast correctly against the original `a`.
+
+        If the value is anything but the default, then
+        `keepdims` will be passed through to the `max` method
+        of sub-classes of `ndarray`.  If the sub-classes methods
+        does not implement `keepdims` any exceptions will be raised.
+
+        .. versionadded:: 1.8.0
+    initial : scalar, optional
+        The minimum value of an output element. Must be present to allow
+        computation on empty slice. See `~numpy.ufunc.reduce` for details.
+
+        .. versionadded:: 1.22.0
+    where : array_like of bool, optional
+        Elements to compare for the maximum. See `~numpy.ufunc.reduce`
+        for details.
+
+        .. versionadded:: 1.22.0
+
+    Returns
+    -------
+    nanmax : ndarray
+        An array with the same shape as `a`, with the specified axis removed.
+        If `a` is a 0-d array, or if axis is None, an ndarray scalar is
+        returned.  The same dtype as `a` is returned.
+
+    See Also
+    --------
+    nanmin :
+        The minimum value of an array along a given axis, ignoring any NaNs.
+    amax :
+        The maximum value of an array along a given axis, propagating any NaNs.
+    fmax :
+        Element-wise maximum of two arrays, ignoring any NaNs.
+    maximum :
+        Element-wise maximum of two arrays, propagating any NaNs.
+    isnan :
+        Shows which elements are Not a Number (NaN).
+    isfinite:
+        Shows which elements are neither NaN nor infinity.
+
+    amin, fmin, minimum
+
+    Notes
+    -----
+    NumPy uses the IEEE Standard for Binary Floating-Point for Arithmetic
+    (IEEE 754). This means that Not a Number is not equivalent to infinity.
+    Positive infinity is treated as a very large number and negative
+    infinity is treated as a very small (i.e. negative) number.
+
+    If the input has a integer type the function is equivalent to np.max.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> a = np.array([[1, 2], [3, np.nan]])
+    >>> np.nanmax(a)
+    3.0
+    >>> np.nanmax(a, axis=0)
+    array([3.,  2.])
+    >>> np.nanmax(a, axis=1)
+    array([2.,  3.])
+
+    When positive infinity and negative infinity are present:
+
+    >>> np.nanmax([1, 2, np.nan, -np.inf])
+    2.0
+    >>> np.nanmax([1, 2, np.nan, np.inf])
+    inf
+
+    """
+    kwargs = {}
+    if keepdims is not np._NoValue:
+        kwargs['keepdims'] = keepdims
+    if initial is not np._NoValue:
+        kwargs['initial'] = initial
+    if where is not np._NoValue:
+        kwargs['where'] = where
+
+    if type(a) is np.ndarray and a.dtype != np.object_:
+        # Fast, but not safe for subclasses of ndarray, or object arrays,
+        # which do not implement isnan (gh-9009), or fmax correctly (gh-8975)
+        res = np.fmax.reduce(a, axis=axis, out=out, **kwargs)
+        if np.isnan(res).any():
+            warnings.warn("All-NaN slice encountered", RuntimeWarning,
+                          stacklevel=2)
+    else:
+        # Slow, but safe for subclasses of ndarray
+        a, mask = _replace_nan(a, -np.inf)
+        res = np.amax(a, axis=axis, out=out, **kwargs)
+        if mask is None:
+            return res
+
+        # Check for all-NaN axis
+        kwargs.pop("initial", None)
+        mask = np.all(mask, axis=axis, **kwargs)
+        if np.any(mask):
+            res = _copyto(res, np.nan, mask)
+            warnings.warn("All-NaN axis encountered", RuntimeWarning,
+                          stacklevel=2)
+    return res
+
+
+def _nanargmin_dispatcher(a, axis=None, out=None, *, keepdims=None):
+    return (a,)
+
+
+@array_function_dispatch(_nanargmin_dispatcher)
+def nanargmin(a, axis=None, out=None, *, keepdims=np._NoValue):
+    """
+    Return the indices of the minimum values in the specified axis ignoring
+    NaNs. For all-NaN slices ``ValueError`` is raised. Warning: the results
+    cannot be trusted if a slice contains only NaNs and Infs.
+
+    Parameters
+    ----------
+    a : array_like
+        Input data.
+    axis : int, optional
+        Axis along which to operate.  By default flattened input is used.
+    out : array, optional
+        If provided, the result will be inserted into this array. It should
+        be of the appropriate shape and dtype.
+
+        .. versionadded:: 1.22.0
+    keepdims : bool, optional
+        If this is set to True, the axes which are reduced are left
+        in the result as dimensions with size one. With this option,
+        the result will broadcast correctly against the array.
+
+        .. versionadded:: 1.22.0
+
+    Returns
+    -------
+    index_array : ndarray
+        An array of indices or a single index value.
+
+    See Also
+    --------
+    argmin, nanargmax
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> a = np.array([[np.nan, 4], [2, 3]])
+    >>> np.argmin(a)
+    0
+    >>> np.nanargmin(a)
+    2
+    >>> np.nanargmin(a, axis=0)
+    array([1, 1])
+    >>> np.nanargmin(a, axis=1)
+    array([1, 0])
+
+    """
+    a, mask = _replace_nan(a, np.inf)
+    if mask is not None and mask.size:
+        mask = np.all(mask, axis=axis)
+        if np.any(mask):
+            raise ValueError("All-NaN slice encountered")
+    res = np.argmin(a, axis=axis, out=out, keepdims=keepdims)
+    return res
+
+
+def _nanargmax_dispatcher(a, axis=None, out=None, *, keepdims=None):
+    return (a,)
+
+
+@array_function_dispatch(_nanargmax_dispatcher)
+def nanargmax(a, axis=None, out=None, *, keepdims=np._NoValue):
+    """
+    Return the indices of the maximum values in the specified axis ignoring
+    NaNs. For all-NaN slices ``ValueError`` is raised. Warning: the
+    results cannot be trusted if a slice contains only NaNs and -Infs.
+
+
+    Parameters
+    ----------
+    a : array_like
+        Input data.
+    axis : int, optional
+        Axis along which to operate.  By default flattened input is used.
+    out : array, optional
+        If provided, the result will be inserted into this array. It should
+        be of the appropriate shape and dtype.
+
+        .. versionadded:: 1.22.0
+    keepdims : bool, optional
+        If this is set to True, the axes which are reduced are left
+        in the result as dimensions with size one. With this option,
+        the result will broadcast correctly against the array.
+
+        .. versionadded:: 1.22.0
+
+    Returns
+    -------
+    index_array : ndarray
+        An array of indices or a single index value.
+
+    See Also
+    --------
+    argmax, nanargmin
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> a = np.array([[np.nan, 4], [2, 3]])
+    >>> np.argmax(a)
+    0
+    >>> np.nanargmax(a)
+    1
+    >>> np.nanargmax(a, axis=0)
+    array([1, 0])
+    >>> np.nanargmax(a, axis=1)
+    array([1, 1])
+
+    """
+    a, mask = _replace_nan(a, -np.inf)
+    if mask is not None and mask.size:
+        mask = np.all(mask, axis=axis)
+        if np.any(mask):
+            raise ValueError("All-NaN slice encountered")
+    res = np.argmax(a, axis=axis, out=out, keepdims=keepdims)
+    return res
+
+
+def _nansum_dispatcher(a, axis=None, dtype=None, out=None, keepdims=None,
+                       initial=None, where=None):
+    return (a, out)
+
+
+@array_function_dispatch(_nansum_dispatcher)
+def nansum(a, axis=None, dtype=None, out=None, keepdims=np._NoValue,
+           initial=np._NoValue, where=np._NoValue):
+    """
+    Return the sum of array elements over a given axis treating Not a
+    Numbers (NaNs) as zero.
+
+    In NumPy versions <= 1.9.0 Nan is returned for slices that are all-NaN or
+    empty. In later versions zero is returned.
+
+    Parameters
+    ----------
+    a : array_like
+        Array containing numbers whose sum is desired. If `a` is not an
+        array, a conversion is attempted.
+    axis : {int, tuple of int, None}, optional
+        Axis or axes along which the sum is computed. The default is to compute the
+        sum of the flattened array.
+    dtype : data-type, optional
+        The type of the returned array and of the accumulator in which the
+        elements are summed.  By default, the dtype of `a` is used.  An
+        exception is when `a` has an integer type with less precision than
+        the platform (u)intp. In that case, the default will be either
+        (u)int32 or (u)int64 depending on whether the platform is 32 or 64
+        bits. For inexact inputs, dtype must be inexact.
+
+        .. versionadded:: 1.8.0
+    out : ndarray, optional
+        Alternate output array in which to place the result.  The default
+        is ``None``. If provided, it must have the same shape as the
+        expected output, but the type will be cast if necessary.  See
+        :ref:`ufuncs-output-type` for more details. The casting of NaN to integer
+        can yield unexpected results.
+
+        .. versionadded:: 1.8.0
+    keepdims : bool, optional
+        If this is set to True, the axes which are reduced are left
+        in the result as dimensions with size one. With this option,
+        the result will broadcast correctly against the original `a`.
+
+
+        If the value is anything but the default, then
+        `keepdims` will be passed through to the `mean` or `sum` methods
+        of sub-classes of `ndarray`.  If the sub-classes methods
+        does not implement `keepdims` any exceptions will be raised.
+
+        .. versionadded:: 1.8.0
+    initial : scalar, optional
+        Starting value for the sum. See `~numpy.ufunc.reduce` for details.
+
+        .. versionadded:: 1.22.0
+    where : array_like of bool, optional
+        Elements to include in the sum. See `~numpy.ufunc.reduce` for details.
+
+        .. versionadded:: 1.22.0
+
+    Returns
+    -------
+    nansum : ndarray.
+        A new array holding the result is returned unless `out` is
+        specified, in which it is returned. The result has the same
+        size as `a`, and the same shape as `a` if `axis` is not None
+        or `a` is a 1-d array.
+
+    See Also
+    --------
+    numpy.sum : Sum across array propagating NaNs.
+    isnan : Show which elements are NaN.
+    isfinite : Show which elements are not NaN or +/-inf.
+
+    Notes
+    -----
+    If both positive and negative infinity are present, the sum will be Not
+    A Number (NaN).
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> np.nansum(1)
+    1
+    >>> np.nansum([1])
+    1
+    >>> np.nansum([1, np.nan])
+    1.0
+    >>> a = np.array([[1, 1], [1, np.nan]])
+    >>> np.nansum(a)
+    3.0
+    >>> np.nansum(a, axis=0)
+    array([2.,  1.])
+    >>> np.nansum([1, np.nan, np.inf])
+    inf
+    >>> np.nansum([1, np.nan, -np.inf])
+    -inf
+    >>> from numpy.testing import suppress_warnings
+    >>> with np.errstate(invalid="ignore"):
+    ...     np.nansum([1, np.nan, np.inf, -np.inf]) # both +/- infinity present
+    np.float64(nan)
+
+    """
+    a, mask = _replace_nan(a, 0)
+    return np.sum(a, axis=axis, dtype=dtype, out=out, keepdims=keepdims,
+                  initial=initial, where=where)
+
+
+def _nanprod_dispatcher(a, axis=None, dtype=None, out=None, keepdims=None,
+                        initial=None, where=None):
+    return (a, out)
+
+
+@array_function_dispatch(_nanprod_dispatcher)
+def nanprod(a, axis=None, dtype=None, out=None, keepdims=np._NoValue,
+            initial=np._NoValue, where=np._NoValue):
+    """
+    Return the product of array elements over a given axis treating Not a
+    Numbers (NaNs) as ones.
+
+    One is returned for slices that are all-NaN or empty.
+
+    .. versionadded:: 1.10.0
+
+    Parameters
+    ----------
+    a : array_like
+        Array containing numbers whose product is desired. If `a` is not an
+        array, a conversion is attempted.
+    axis : {int, tuple of int, None}, optional
+        Axis or axes along which the product is computed. The default is to compute
+        the product of the flattened array.
+    dtype : data-type, optional
+        The type of the returned array and of the accumulator in which the
+        elements are summed.  By default, the dtype of `a` is used.  An
+        exception is when `a` has an integer type with less precision than
+        the platform (u)intp. In that case, the default will be either
+        (u)int32 or (u)int64 depending on whether the platform is 32 or 64
+        bits. For inexact inputs, dtype must be inexact.
+    out : ndarray, optional
+        Alternate output array in which to place the result.  The default
+        is ``None``. If provided, it must have the same shape as the
+        expected output, but the type will be cast if necessary. See
+        :ref:`ufuncs-output-type` for more details. The casting of NaN to integer
+        can yield unexpected results.
+    keepdims : bool, optional
+        If True, the axes which are reduced are left in the result as
+        dimensions with size one. With this option, the result will
+        broadcast correctly against the original `arr`.
+    initial : scalar, optional
+        The starting value for this product. See `~numpy.ufunc.reduce`
+        for details.
+
+        .. versionadded:: 1.22.0
+    where : array_like of bool, optional
+        Elements to include in the product. See `~numpy.ufunc.reduce`
+        for details.
+
+        .. versionadded:: 1.22.0
+
+    Returns
+    -------
+    nanprod : ndarray
+        A new array holding the result is returned unless `out` is
+        specified, in which case it is returned.
+
+    See Also
+    --------
+    numpy.prod : Product across array propagating NaNs.
+    isnan : Show which elements are NaN.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> np.nanprod(1)
+    1
+    >>> np.nanprod([1])
+    1
+    >>> np.nanprod([1, np.nan])
+    1.0
+    >>> a = np.array([[1, 2], [3, np.nan]])
+    >>> np.nanprod(a)
+    6.0
+    >>> np.nanprod(a, axis=0)
+    array([3., 2.])
+
+    """
+    a, mask = _replace_nan(a, 1)
+    return np.prod(a, axis=axis, dtype=dtype, out=out, keepdims=keepdims,
+                   initial=initial, where=where)
+
+
+def _nancumsum_dispatcher(a, axis=None, dtype=None, out=None):
+    return (a, out)
+
+
+@array_function_dispatch(_nancumsum_dispatcher)
+def nancumsum(a, axis=None, dtype=None, out=None):
+    """
+    Return the cumulative sum of array elements over a given axis treating Not a
+    Numbers (NaNs) as zero.  The cumulative sum does not change when NaNs are
+    encountered and leading NaNs are replaced by zeros.
+
+    Zeros are returned for slices that are all-NaN or empty.
+
+    .. versionadded:: 1.12.0
+
+    Parameters
+    ----------
+    a : array_like
+        Input array.
+    axis : int, optional
+        Axis along which the cumulative sum is computed. The default
+        (None) is to compute the cumsum over the flattened array.
+    dtype : dtype, optional
+        Type of the returned array and of the accumulator in which the
+        elements are summed.  If `dtype` is not specified, it defaults
+        to the dtype of `a`, unless `a` has an integer dtype with a
+        precision less than that of the default platform integer.  In
+        that case, the default platform integer is used.
+    out : ndarray, optional
+        Alternative output array in which to place the result. It must
+        have the same shape and buffer length as the expected output
+        but the type will be cast if necessary. See :ref:`ufuncs-output-type` for
+        more details.
+
+    Returns
+    -------
+    nancumsum : ndarray.
+        A new array holding the result is returned unless `out` is
+        specified, in which it is returned. The result has the same
+        size as `a`, and the same shape as `a` if `axis` is not None
+        or `a` is a 1-d array.
+
+    See Also
+    --------
+    numpy.cumsum : Cumulative sum across array propagating NaNs.
+    isnan : Show which elements are NaN.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> np.nancumsum(1)
+    array([1])
+    >>> np.nancumsum([1])
+    array([1])
+    >>> np.nancumsum([1, np.nan])
+    array([1.,  1.])
+    >>> a = np.array([[1, 2], [3, np.nan]])
+    >>> np.nancumsum(a)
+    array([1.,  3.,  6.,  6.])
+    >>> np.nancumsum(a, axis=0)
+    array([[1.,  2.],
+           [4.,  2.]])
+    >>> np.nancumsum(a, axis=1)
+    array([[1.,  3.],
+           [3.,  3.]])
+
+    """
+    a, mask = _replace_nan(a, 0)
+    return np.cumsum(a, axis=axis, dtype=dtype, out=out)
+
+
+def _nancumprod_dispatcher(a, axis=None, dtype=None, out=None):
+    return (a, out)
+
+
+@array_function_dispatch(_nancumprod_dispatcher)
+def nancumprod(a, axis=None, dtype=None, out=None):
+    """
+    Return the cumulative product of array elements over a given axis treating Not a
+    Numbers (NaNs) as one.  The cumulative product does not change when NaNs are
+    encountered and leading NaNs are replaced by ones.
+
+    Ones are returned for slices that are all-NaN or empty.
+
+    .. versionadded:: 1.12.0
+
+    Parameters
+    ----------
+    a : array_like
+        Input array.
+    axis : int, optional
+        Axis along which the cumulative product is computed.  By default
+        the input is flattened.
+    dtype : dtype, optional
+        Type of the returned array, as well as of the accumulator in which
+        the elements are multiplied.  If *dtype* is not specified, it
+        defaults to the dtype of `a`, unless `a` has an integer dtype with
+        a precision less than that of the default platform integer.  In
+        that case, the default platform integer is used instead.
+    out : ndarray, optional
+        Alternative output array in which to place the result. It must
+        have the same shape and buffer length as the expected output
+        but the type of the resulting values will be cast if necessary.
+
+    Returns
+    -------
+    nancumprod : ndarray
+        A new array holding the result is returned unless `out` is
+        specified, in which case it is returned.
+
+    See Also
+    --------
+    numpy.cumprod : Cumulative product across array propagating NaNs.
+    isnan : Show which elements are NaN.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> np.nancumprod(1)
+    array([1])
+    >>> np.nancumprod([1])
+    array([1])
+    >>> np.nancumprod([1, np.nan])
+    array([1.,  1.])
+    >>> a = np.array([[1, 2], [3, np.nan]])
+    >>> np.nancumprod(a)
+    array([1.,  2.,  6.,  6.])
+    >>> np.nancumprod(a, axis=0)
+    array([[1.,  2.],
+           [3.,  2.]])
+    >>> np.nancumprod(a, axis=1)
+    array([[1.,  2.],
+           [3.,  3.]])
+
+    """
+    a, mask = _replace_nan(a, 1)
+    return np.cumprod(a, axis=axis, dtype=dtype, out=out)
+
+
+def _nanmean_dispatcher(a, axis=None, dtype=None, out=None, keepdims=None,
+                        *, where=None):
+    return (a, out)
+
+
+@array_function_dispatch(_nanmean_dispatcher)
+def nanmean(a, axis=None, dtype=None, out=None, keepdims=np._NoValue,
+            *, where=np._NoValue):
+    """
+    Compute the arithmetic mean along the specified axis, ignoring NaNs.
+
+    Returns the average of the array elements.  The average is taken over
+    the flattened array by default, otherwise over the specified axis.
+    `float64` intermediate and return values are used for integer inputs.
+
+    For all-NaN slices, NaN is returned and a `RuntimeWarning` is raised.
+
+    .. versionadded:: 1.8.0
+
+    Parameters
+    ----------
+    a : array_like
+        Array containing numbers whose mean is desired. If `a` is not an
+        array, a conversion is attempted.
+    axis : {int, tuple of int, None}, optional
+        Axis or axes along which the means are computed. The default is to compute
+        the mean of the flattened array.
+    dtype : data-type, optional
+        Type to use in computing the mean.  For integer inputs, the default
+        is `float64`; for inexact inputs, it is the same as the input
+        dtype.
+    out : ndarray, optional
+        Alternate output array in which to place the result.  The default
+        is ``None``; if provided, it must have the same shape as the
+        expected output, but the type will be cast if necessary.
+        See :ref:`ufuncs-output-type` for more details.
+    keepdims : bool, optional
+        If this is set to True, the axes which are reduced are left
+        in the result as dimensions with size one. With this option,
+        the result will broadcast correctly against the original `a`.
+
+        If the value is anything but the default, then
+        `keepdims` will be passed through to the `mean` or `sum` methods
+        of sub-classes of `ndarray`.  If the sub-classes methods
+        does not implement `keepdims` any exceptions will be raised.
+    where : array_like of bool, optional
+        Elements to include in the mean. See `~numpy.ufunc.reduce` for details.
+
+        .. versionadded:: 1.22.0
+
+    Returns
+    -------
+    m : ndarray, see dtype parameter above
+        If `out=None`, returns a new array containing the mean values,
+        otherwise a reference to the output array is returned. Nan is
+        returned for slices that contain only NaNs.
+
+    See Also
+    --------
+    average : Weighted average
+    mean : Arithmetic mean taken while not ignoring NaNs
+    var, nanvar
+
+    Notes
+    -----
+    The arithmetic mean is the sum of the non-NaN elements along the axis
+    divided by the number of non-NaN elements.
+
+    Note that for floating-point input, the mean is computed using the same
+    precision the input has.  Depending on the input data, this can cause
+    the results to be inaccurate, especially for `float32`.  Specifying a
+    higher-precision accumulator using the `dtype` keyword can alleviate
+    this issue.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> a = np.array([[1, np.nan], [3, 4]])
+    >>> np.nanmean(a)
+    2.6666666666666665
+    >>> np.nanmean(a, axis=0)
+    array([2.,  4.])
+    >>> np.nanmean(a, axis=1)
+    array([1.,  3.5]) # may vary
+
+    """
+    arr, mask = _replace_nan(a, 0)
+    if mask is None:
+        return np.mean(arr, axis=axis, dtype=dtype, out=out, keepdims=keepdims,
+                       where=where)
+
+    if dtype is not None:
+        dtype = np.dtype(dtype)
+    if dtype is not None and not issubclass(dtype.type, np.inexact):
+        raise TypeError("If a is inexact, then dtype must be inexact")
+    if out is not None and not issubclass(out.dtype.type, np.inexact):
+        raise TypeError("If a is inexact, then out must be inexact")
+
+    cnt = np.sum(~mask, axis=axis, dtype=np.intp, keepdims=keepdims,
+                 where=where)
+    tot = np.sum(arr, axis=axis, dtype=dtype, out=out, keepdims=keepdims,
+                 where=where)
+    avg = _divide_by_count(tot, cnt, out=out)
+
+    isbad = (cnt == 0)
+    if isbad.any():
+        warnings.warn("Mean of empty slice", RuntimeWarning, stacklevel=2)
+        # NaN is the only possible bad value, so no further
+        # action is needed to handle bad results.
+    return avg
+
+
+def _nanmedian1d(arr1d, overwrite_input=False):
+    """
+    Private function for rank 1 arrays. Compute the median ignoring NaNs.
+    See nanmedian for parameter usage
+    """
+    arr1d_parsed, _, overwrite_input = _remove_nan_1d(
+        arr1d, overwrite_input=overwrite_input,
+    )
+
+    if arr1d_parsed.size == 0:
+        # Ensure that a nan-esque scalar of the appropriate type (and unit)
+        # is returned for `timedelta64` and `complexfloating`
+        return arr1d[-1]
+
+    return np.median(arr1d_parsed, overwrite_input=overwrite_input)
+
+
+def _nanmedian(a, axis=None, out=None, overwrite_input=False):
+    """
+    Private function that doesn't support extended axis or keepdims.
+    These methods are extended to this function using _ureduce
+    See nanmedian for parameter usage
+
+    """
+    if axis is None or a.ndim == 1:
+        part = a.ravel()
+        if out is None:
+            return _nanmedian1d(part, overwrite_input)
+        else:
+            out[...] = _nanmedian1d(part, overwrite_input)
+            return out
+    else:
+        # for small medians use sort + indexing which is still faster than
+        # apply_along_axis
+        # benchmarked with shuffled (50, 50, x) containing a few NaN
+        if a.shape[axis] < 600:
+            return _nanmedian_small(a, axis, out, overwrite_input)
+        result = np.apply_along_axis(_nanmedian1d, axis, a, overwrite_input)
+        if out is not None:
+            out[...] = result
+        return result
+
+
+def _nanmedian_small(a, axis=None, out=None, overwrite_input=False):
+    """
+    sort + indexing median, faster for small medians along multiple
+    dimensions due to the high overhead of apply_along_axis
+
+    see nanmedian for parameter usage
+    """
+    a = np.ma.masked_array(a, np.isnan(a))
+    m = np.ma.median(a, axis=axis, overwrite_input=overwrite_input)
+    for i in range(np.count_nonzero(m.mask.ravel())):
+        warnings.warn("All-NaN slice encountered", RuntimeWarning,
+                      stacklevel=5)
+
+    fill_value = np.timedelta64("NaT") if m.dtype.kind == "m" else np.nan
+    if out is not None:
+        out[...] = m.filled(fill_value)
+        return out
+    return m.filled(fill_value)
+
+
+def _nanmedian_dispatcher(
+        a, axis=None, out=None, overwrite_input=None, keepdims=None):
+    return (a, out)
+
+
+@array_function_dispatch(_nanmedian_dispatcher)
+def nanmedian(a, axis=None, out=None, overwrite_input=False, keepdims=np._NoValue):
+    """
+    Compute the median along the specified axis, while ignoring NaNs.
+
+    Returns the median of the array elements.
+
+    .. versionadded:: 1.9.0
+
+    Parameters
+    ----------
+    a : array_like
+        Input array or object that can be converted to an array.
+    axis : {int, sequence of int, None}, optional
+        Axis or axes along which the medians are computed. The default
+        is to compute the median along a flattened version of the array.
+        A sequence of axes is supported since version 1.9.0.
+    out : ndarray, optional
+        Alternative output array in which to place the result. It must
+        have the same shape and buffer length as the expected output,
+        but the type (of the output) will be cast if necessary.
+    overwrite_input : bool, optional
+       If True, then allow use of memory of input array `a` for
+       calculations. The input array will be modified by the call to
+       `median`. This will save memory when you do not need to preserve
+       the contents of the input array. Treat the input as undefined,
+       but it will probably be fully or partially sorted. Default is
+       False. If `overwrite_input` is ``True`` and `a` is not already an
+       `ndarray`, an error will be raised.
+    keepdims : bool, optional
+        If this is set to True, the axes which are reduced are left
+        in the result as dimensions with size one. With this option,
+        the result will broadcast correctly against the original `a`.
+
+        If this is anything but the default value it will be passed
+        through (in the special case of an empty array) to the
+        `mean` function of the underlying array.  If the array is
+        a sub-class and `mean` does not have the kwarg `keepdims` this
+        will raise a RuntimeError.
+
+    Returns
+    -------
+    median : ndarray
+        A new array holding the result. If the input contains integers
+        or floats smaller than ``float64``, then the output data-type is
+        ``np.float64``.  Otherwise, the data-type of the output is the
+        same as that of the input. If `out` is specified, that array is
+        returned instead.
+
+    See Also
+    --------
+    mean, median, percentile
+
+    Notes
+    -----
+    Given a vector ``V`` of length ``N``, the median of ``V`` is the
+    middle value of a sorted copy of ``V``, ``V_sorted`` - i.e.,
+    ``V_sorted[(N-1)/2]``, when ``N`` is odd and the average of the two
+    middle values of ``V_sorted`` when ``N`` is even.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> a = np.array([[10.0, 7, 4], [3, 2, 1]])
+    >>> a[0, 1] = np.nan
+    >>> a
+    array([[10., nan,  4.],
+           [ 3.,  2.,  1.]])
+    >>> np.median(a)
+    np.float64(nan)
+    >>> np.nanmedian(a)
+    3.0
+    >>> np.nanmedian(a, axis=0)
+    array([6.5, 2. , 2.5])
+    >>> np.median(a, axis=1)
+    array([nan,  2.])
+    >>> b = a.copy()
+    >>> np.nanmedian(b, axis=1, overwrite_input=True)
+    array([7.,  2.])
+    >>> assert not np.all(a==b)
+    >>> b = a.copy()
+    >>> np.nanmedian(b, axis=None, overwrite_input=True)
+    3.0
+    >>> assert not np.all(a==b)
+
+    """
+    a = np.asanyarray(a)
+    # apply_along_axis in _nanmedian doesn't handle empty arrays well,
+    # so deal them upfront
+    if a.size == 0:
+        return np.nanmean(a, axis, out=out, keepdims=keepdims)
+
+    return fnb._ureduce(a, func=_nanmedian, keepdims=keepdims,
+                        axis=axis, out=out,
+                        overwrite_input=overwrite_input)
+
+
+def _nanpercentile_dispatcher(
+        a, q, axis=None, out=None, overwrite_input=None,
+        method=None, keepdims=None, *, weights=None, interpolation=None):
+    return (a, q, out, weights)
+
+
+@array_function_dispatch(_nanpercentile_dispatcher)
+def nanpercentile(
+        a,
+        q,
+        axis=None,
+        out=None,
+        overwrite_input=False,
+        method="linear",
+        keepdims=np._NoValue,
+        *,
+        weights=None,
+        interpolation=None,
+):
+    """
+    Compute the qth percentile of the data along the specified axis,
+    while ignoring nan values.
+
+    Returns the qth percentile(s) of the array elements.
+
+    .. versionadded:: 1.9.0
+
+    Parameters
+    ----------
+    a : array_like
+        Input array or object that can be converted to an array, containing
+        nan values to be ignored.
+    q : array_like of float
+        Percentile or sequence of percentiles to compute, which must be
+        between 0 and 100 inclusive.
+    axis : {int, tuple of int, None}, optional
+        Axis or axes along which the percentiles are computed. The default
+        is to compute the percentile(s) along a flattened version of the
+        array.
+    out : ndarray, optional
+        Alternative output array in which to place the result. It must have
+        the same shape and buffer length as the expected output, but the
+        type (of the output) will be cast if necessary.
+    overwrite_input : bool, optional
+        If True, then allow the input array `a` to be modified by
+        intermediate calculations, to save memory. In this case, the
+        contents of the input `a` after this function completes is
+        undefined.
+    method : str, optional
+        This parameter specifies the method to use for estimating the
+        percentile.  There are many different methods, some unique to NumPy.
+        See the notes for explanation.  The options sorted by their R type
+        as summarized in the H&F paper [1]_ are:
+
+        1. 'inverted_cdf'
+        2. 'averaged_inverted_cdf'
+        3. 'closest_observation'
+        4. 'interpolated_inverted_cdf'
+        5. 'hazen'
+        6. 'weibull'
+        7. 'linear'  (default)
+        8. 'median_unbiased'
+        9. 'normal_unbiased'
+
+        The first three methods are discontinuous.  NumPy further defines the
+        following discontinuous variations of the default 'linear' (7.) option:
+
+        * 'lower'
+        * 'higher',
+        * 'midpoint'
+        * 'nearest'
+
+        .. versionchanged:: 1.22.0
+            This argument was previously called "interpolation" and only
+            offered the "linear" default and last four options.
+
+    keepdims : bool, optional
+        If this is set to True, the axes which are reduced are left in
+        the result as dimensions with size one. With this option, the
+        result will broadcast correctly against the original array `a`.
+
+        If this is anything but the default value it will be passed
+        through (in the special case of an empty array) to the
+        `mean` function of the underlying array.  If the array is
+        a sub-class and `mean` does not have the kwarg `keepdims` this
+        will raise a RuntimeError.
+
+    weights : array_like, optional
+        An array of weights associated with the values in `a`. Each value in
+        `a` contributes to the percentile according to its associated weight.
+        The weights array can either be 1-D (in which case its length must be
+        the size of `a` along the given axis) or of the same shape as `a`.
+        If `weights=None`, then all data in `a` are assumed to have a
+        weight equal to one.
+        Only `method="inverted_cdf"` supports weights.
+
+        .. versionadded:: 2.0.0
+
+    interpolation : str, optional
+        Deprecated name for the method keyword argument.
+
+        .. deprecated:: 1.22.0
+
+    Returns
+    -------
+    percentile : scalar or ndarray
+        If `q` is a single percentile and `axis=None`, then the result
+        is a scalar. If multiple percentiles are given, first axis of
+        the result corresponds to the percentiles. The other axes are
+        the axes that remain after the reduction of `a`. If the input
+        contains integers or floats smaller than ``float64``, the output
+        data-type is ``float64``. Otherwise, the output data-type is the
+        same as that of the input. If `out` is specified, that array is
+        returned instead.
+
+    See Also
+    --------
+    nanmean
+    nanmedian : equivalent to ``nanpercentile(..., 50)``
+    percentile, median, mean
+    nanquantile : equivalent to nanpercentile, except q in range [0, 1].
+
+    Notes
+    -----
+    The behavior of `numpy.nanpercentile` with percentage `q` is that of
+    `numpy.quantile` with argument ``q/100`` (ignoring nan values).
+    For more information, please see `numpy.quantile`.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> a = np.array([[10., 7., 4.], [3., 2., 1.]])
+    >>> a[0][1] = np.nan
+    >>> a
+    array([[10.,  nan,   4.],
+          [ 3.,   2.,   1.]])
+    >>> np.percentile(a, 50)
+    np.float64(nan)
+    >>> np.nanpercentile(a, 50)
+    3.0
+    >>> np.nanpercentile(a, 50, axis=0)
+    array([6.5, 2. , 2.5])
+    >>> np.nanpercentile(a, 50, axis=1, keepdims=True)
+    array([[7.],
+           [2.]])
+    >>> m = np.nanpercentile(a, 50, axis=0)
+    >>> out = np.zeros_like(m)
+    >>> np.nanpercentile(a, 50, axis=0, out=out)
+    array([6.5, 2. , 2.5])
+    >>> m
+    array([6.5,  2. ,  2.5])
+
+    >>> b = a.copy()
+    >>> np.nanpercentile(b, 50, axis=1, overwrite_input=True)
+    array([7., 2.])
+    >>> assert not np.all(a==b)
+
+    References
+    ----------
+    .. [1] R. J. Hyndman and Y. Fan,
+       "Sample quantiles in statistical packages,"
+       The American Statistician, 50(4), pp. 361-365, 1996
+
+    """
+    if interpolation is not None:
+        method = fnb._check_interpolation_as_method(
+            method, interpolation, "nanpercentile")
+
+    a = np.asanyarray(a)
+    if a.dtype.kind == "c":
+        raise TypeError("a must be an array of real numbers")
+
+    q = np.true_divide(q, a.dtype.type(100) if a.dtype.kind == "f" else 100)
+    # undo any decay that the ufunc performed (see gh-13105)
+    q = np.asanyarray(q)
+    if not fnb._quantile_is_valid(q):
+        raise ValueError("Percentiles must be in the range [0, 100]")
+
+    if weights is not None:
+        if method != "inverted_cdf":
+            msg = ("Only method 'inverted_cdf' supports weights. "
+                   f"Got: {method}.")
+            raise ValueError(msg)
+        if axis is not None:
+            axis = _nx.normalize_axis_tuple(axis, a.ndim, argname="axis")
+        weights = _weights_are_valid(weights=weights, a=a, axis=axis)
+        if np.any(weights < 0):
+            raise ValueError("Weights must be non-negative.")
+
+    return _nanquantile_unchecked(
+        a, q, axis, out, overwrite_input, method, keepdims, weights)
+
+
+def _nanquantile_dispatcher(a, q, axis=None, out=None, overwrite_input=None,
+                            method=None, keepdims=None, *, weights=None,
+                            interpolation=None):
+    return (a, q, out, weights)
+
+
+@array_function_dispatch(_nanquantile_dispatcher)
+def nanquantile(
+        a,
+        q,
+        axis=None,
+        out=None,
+        overwrite_input=False,
+        method="linear",
+        keepdims=np._NoValue,
+        *,
+        weights=None,
+        interpolation=None,
+):
+    """
+    Compute the qth quantile of the data along the specified axis,
+    while ignoring nan values.
+    Returns the qth quantile(s) of the array elements.
+
+    .. versionadded:: 1.15.0
+
+    Parameters
+    ----------
+    a : array_like
+        Input array or object that can be converted to an array, containing
+        nan values to be ignored
+    q : array_like of float
+        Probability or sequence of probabilities for the quantiles to compute.
+        Values must be between 0 and 1 inclusive.
+    axis : {int, tuple of int, None}, optional
+        Axis or axes along which the quantiles are computed. The
+        default is to compute the quantile(s) along a flattened
+        version of the array.
+    out : ndarray, optional
+        Alternative output array in which to place the result. It must
+        have the same shape and buffer length as the expected output,
+        but the type (of the output) will be cast if necessary.
+    overwrite_input : bool, optional
+        If True, then allow the input array `a` to be modified by intermediate
+        calculations, to save memory. In this case, the contents of the input
+        `a` after this function completes is undefined.
+    method : str, optional
+        This parameter specifies the method to use for estimating the
+        quantile.  There are many different methods, some unique to NumPy.
+        See the notes for explanation.  The options sorted by their R type
+        as summarized in the H&F paper [1]_ are:
+
+        1. 'inverted_cdf'
+        2. 'averaged_inverted_cdf'
+        3. 'closest_observation'
+        4. 'interpolated_inverted_cdf'
+        5. 'hazen'
+        6. 'weibull'
+        7. 'linear'  (default)
+        8. 'median_unbiased'
+        9. 'normal_unbiased'
+
+        The first three methods are discontinuous.  NumPy further defines the
+        following discontinuous variations of the default 'linear' (7.) option:
+
+        * 'lower'
+        * 'higher',
+        * 'midpoint'
+        * 'nearest'
+
+        .. versionchanged:: 1.22.0
+            This argument was previously called "interpolation" and only
+            offered the "linear" default and last four options.
+
+    keepdims : bool, optional
+        If this is set to True, the axes which are reduced are left in
+        the result as dimensions with size one. With this option, the
+        result will broadcast correctly against the original array `a`.
+
+        If this is anything but the default value it will be passed
+        through (in the special case of an empty array) to the
+        `mean` function of the underlying array.  If the array is
+        a sub-class and `mean` does not have the kwarg `keepdims` this
+        will raise a RuntimeError.
+
+    weights : array_like, optional
+        An array of weights associated with the values in `a`. Each value in
+        `a` contributes to the quantile according to its associated weight.
+        The weights array can either be 1-D (in which case its length must be
+        the size of `a` along the given axis) or of the same shape as `a`.
+        If `weights=None`, then all data in `a` are assumed to have a
+        weight equal to one.
+        Only `method="inverted_cdf"` supports weights.
+
+        .. versionadded:: 2.0.0
+
+    interpolation : str, optional
+        Deprecated name for the method keyword argument.
+
+        .. deprecated:: 1.22.0
+
+    Returns
+    -------
+    quantile : scalar or ndarray
+        If `q` is a single probability and `axis=None`, then the result
+        is a scalar. If multiple probability levels are given, first axis of
+        the result corresponds to the quantiles. The other axes are
+        the axes that remain after the reduction of `a`. If the input
+        contains integers or floats smaller than ``float64``, the output
+        data-type is ``float64``. Otherwise, the output data-type is the
+        same as that of the input. If `out` is specified, that array is
+        returned instead.
+
+    See Also
+    --------
+    quantile
+    nanmean, nanmedian
+    nanmedian : equivalent to ``nanquantile(..., 0.5)``
+    nanpercentile : same as nanquantile, but with q in the range [0, 100].
+
+    Notes
+    -----
+    The behavior of `numpy.nanquantile` is the same as that of
+    `numpy.quantile` (ignoring nan values).
+    For more information, please see `numpy.quantile`.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> a = np.array([[10., 7., 4.], [3., 2., 1.]])
+    >>> a[0][1] = np.nan
+    >>> a
+    array([[10.,  nan,   4.],
+          [ 3.,   2.,   1.]])
+    >>> np.quantile(a, 0.5)
+    np.float64(nan)
+    >>> np.nanquantile(a, 0.5)
+    3.0
+    >>> np.nanquantile(a, 0.5, axis=0)
+    array([6.5, 2. , 2.5])
+    >>> np.nanquantile(a, 0.5, axis=1, keepdims=True)
+    array([[7.],
+           [2.]])
+    >>> m = np.nanquantile(a, 0.5, axis=0)
+    >>> out = np.zeros_like(m)
+    >>> np.nanquantile(a, 0.5, axis=0, out=out)
+    array([6.5, 2. , 2.5])
+    >>> m
+    array([6.5,  2. ,  2.5])
+    >>> b = a.copy()
+    >>> np.nanquantile(b, 0.5, axis=1, overwrite_input=True)
+    array([7., 2.])
+    >>> assert not np.all(a==b)
+
+    References
+    ----------
+    .. [1] R. J. Hyndman and Y. Fan,
+       "Sample quantiles in statistical packages,"
+       The American Statistician, 50(4), pp. 361-365, 1996
+
+    """
+
+    if interpolation is not None:
+        method = fnb._check_interpolation_as_method(
+            method, interpolation, "nanquantile")
+
+    a = np.asanyarray(a)
+    if a.dtype.kind == "c":
+        raise TypeError("a must be an array of real numbers")
+
+    # Use dtype of array if possible (e.g., if q is a python int or float).
+    if isinstance(q, (int, float)) and a.dtype.kind == "f":
+        q = np.asanyarray(q, dtype=a.dtype)
+    else:
+        q = np.asanyarray(q)
+
+    if not fnb._quantile_is_valid(q):
+        raise ValueError("Quantiles must be in the range [0, 1]")
+
+    if weights is not None:
+        if method != "inverted_cdf":
+            msg = ("Only method 'inverted_cdf' supports weights. "
+                   f"Got: {method}.")
+            raise ValueError(msg)
+        if axis is not None:
+            axis = _nx.normalize_axis_tuple(axis, a.ndim, argname="axis")
+        weights = _weights_are_valid(weights=weights, a=a, axis=axis)
+        if np.any(weights < 0):
+            raise ValueError("Weights must be non-negative.")
+
+    return _nanquantile_unchecked(
+        a, q, axis, out, overwrite_input, method, keepdims, weights)
+
+
+def _nanquantile_unchecked(
+        a,
+        q,
+        axis=None,
+        out=None,
+        overwrite_input=False,
+        method="linear",
+        keepdims=np._NoValue,
+        weights=None,
+):
+    """Assumes that q is in [0, 1], and is an ndarray"""
+    # apply_along_axis in _nanpercentile doesn't handle empty arrays well,
+    # so deal them upfront
+    if a.size == 0:
+        return np.nanmean(a, axis, out=out, keepdims=keepdims)
+    return fnb._ureduce(a,
+                        func=_nanquantile_ureduce_func,
+                        q=q,
+                        weights=weights,
+                        keepdims=keepdims,
+                        axis=axis,
+                        out=out,
+                        overwrite_input=overwrite_input,
+                        method=method)
+
+
+def _nanquantile_ureduce_func(
+        a: np.array,
+        q: np.array,
+        weights: np.array,
+        axis: int = None,
+        out=None,
+        overwrite_input: bool = False,
+        method="linear",
+):
+    """
+    Private function that doesn't support extended axis or keepdims.
+    These methods are extended to this function using _ureduce
+    See nanpercentile for parameter usage
+    """
+    if axis is None or a.ndim == 1:
+        part = a.ravel()
+        wgt = None if weights is None else weights.ravel()
+        result = _nanquantile_1d(part, q, overwrite_input, method, weights=wgt)
+    else:
+        # Note that this code could try to fill in `out` right away
+        if weights is None:
+            result = np.apply_along_axis(_nanquantile_1d, axis, a, q,
+                                         overwrite_input, method, weights)
+            # apply_along_axis fills in collapsed axis with results.
+            # Move those axes to the beginning to match percentile's
+            # convention.
+            if q.ndim != 0:
+                from_ax = [axis + i for i in range(q.ndim)]
+                result = np.moveaxis(result, from_ax, list(range(q.ndim)))
+        else:
+            # We need to apply along axis over 2 arrays, a and weights.
+            # move operation axes to end for simplicity:
+            a = np.moveaxis(a, axis, -1)
+            if weights is not None:
+                weights = np.moveaxis(weights, axis, -1)
+            if out is not None:
+                result = out
+            else:
+                # weights are limited to `inverted_cdf` so the result dtype
+                # is known to be identical to that of `a` here:
+                result = np.empty_like(a, shape=q.shape + a.shape[:-1])
+
+            for ii in np.ndindex(a.shape[:-1]):
+                result[(...,) + ii] = _nanquantile_1d(
+                        a[ii], q, weights=weights[ii],
+                        overwrite_input=overwrite_input, method=method,
+                )
+            # This path dealt with `out` already...
+            return result
+
+    if out is not None:
+        out[...] = result
+    return result
+
+
+def _nanquantile_1d(
+    arr1d, q, overwrite_input=False, method="linear", weights=None,
+):
+    """
+    Private function for rank 1 arrays. Compute quantile ignoring NaNs.
+    See nanpercentile for parameter usage
+    """
+    # TODO: What to do when arr1d = [1, np.nan] and weights = [0, 1]?
+    arr1d, weights, overwrite_input = _remove_nan_1d(arr1d,
+        second_arr1d=weights, overwrite_input=overwrite_input)
+    if arr1d.size == 0:
+        # convert to scalar
+        return np.full(q.shape, np.nan, dtype=arr1d.dtype)[()]
+
+    return fnb._quantile_unchecked(
+        arr1d,
+        q,
+        overwrite_input=overwrite_input,
+        method=method,
+        weights=weights,
+    )
+
+
+def _nanvar_dispatcher(a, axis=None, dtype=None, out=None, ddof=None,
+                       keepdims=None, *, where=None, mean=None,
+                       correction=None):
+    return (a, out)
+
+
+@array_function_dispatch(_nanvar_dispatcher)
+def nanvar(a, axis=None, dtype=None, out=None, ddof=0, keepdims=np._NoValue,
+           *, where=np._NoValue, mean=np._NoValue, correction=np._NoValue):
+    """
+    Compute the variance along the specified axis, while ignoring NaNs.
+
+    Returns the variance of the array elements, a measure of the spread of
+    a distribution.  The variance is computed for the flattened array by
+    default, otherwise over the specified axis.
+
+    For all-NaN slices or slices with zero degrees of freedom, NaN is
+    returned and a `RuntimeWarning` is raised.
+
+    .. versionadded:: 1.8.0
+
+    Parameters
+    ----------
+    a : array_like
+        Array containing numbers whose variance is desired.  If `a` is not an
+        array, a conversion is attempted.
+    axis : {int, tuple of int, None}, optional
+        Axis or axes along which the variance is computed.  The default is to compute
+        the variance of the flattened array.
+    dtype : data-type, optional
+        Type to use in computing the variance.  For arrays of integer type
+        the default is `float64`; for arrays of float types it is the same as
+        the array type.
+    out : ndarray, optional
+        Alternate output array in which to place the result.  It must have
+        the same shape as the expected output, but the type is cast if
+        necessary.
+    ddof : {int, float}, optional
+        "Delta Degrees of Freedom": the divisor used in the calculation is
+        ``N - ddof``, where ``N`` represents the number of non-NaN
+        elements. By default `ddof` is zero.
+    keepdims : bool, optional
+        If this is set to True, the axes which are reduced are left
+        in the result as dimensions with size one. With this option,
+        the result will broadcast correctly against the original `a`.
+    where : array_like of bool, optional
+        Elements to include in the variance. See `~numpy.ufunc.reduce` for
+        details.
+
+        .. versionadded:: 1.22.0
+
+    mean : array_like, optional
+        Provide the mean to prevent its recalculation. The mean should have
+        a shape as if it was calculated with ``keepdims=True``.
+        The axis for the calculation of the mean should be the same as used in
+        the call to this var function.
+
+        .. versionadded:: 1.26.0
+
+    correction : {int, float}, optional
+        Array API compatible name for the ``ddof`` parameter. Only one of them
+        can be provided at the same time.
+
+        .. versionadded:: 2.0.0
+
+    Returns
+    -------
+    variance : ndarray, see dtype parameter above
+        If `out` is None, return a new array containing the variance,
+        otherwise return a reference to the output array. If ddof is >= the
+        number of non-NaN elements in a slice or the slice contains only
+        NaNs, then the result for that slice is NaN.
+
+    See Also
+    --------
+    std : Standard deviation
+    mean : Average
+    var : Variance while not ignoring NaNs
+    nanstd, nanmean
+    :ref:`ufuncs-output-type`
+
+    Notes
+    -----
+    The variance is the average of the squared deviations from the mean,
+    i.e.,  ``var = mean(abs(x - x.mean())**2)``.
+
+    The mean is normally calculated as ``x.sum() / N``, where ``N = len(x)``.
+    If, however, `ddof` is specified, the divisor ``N - ddof`` is used
+    instead.  In standard statistical practice, ``ddof=1`` provides an
+    unbiased estimator of the variance of a hypothetical infinite
+    population.  ``ddof=0`` provides a maximum likelihood estimate of the
+    variance for normally distributed variables.
+
+    Note that for complex numbers, the absolute value is taken before
+    squaring, so that the result is always real and nonnegative.
+
+    For floating-point input, the variance is computed using the same
+    precision the input has.  Depending on the input data, this can cause
+    the results to be inaccurate, especially for `float32` (see example
+    below).  Specifying a higher-accuracy accumulator using the ``dtype``
+    keyword can alleviate this issue.
+
+    For this function to work on sub-classes of ndarray, they must define
+    `sum` with the kwarg `keepdims`
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> a = np.array([[1, np.nan], [3, 4]])
+    >>> np.nanvar(a)
+    1.5555555555555554
+    >>> np.nanvar(a, axis=0)
+    array([1.,  0.])
+    >>> np.nanvar(a, axis=1)
+    array([0.,  0.25])  # may vary
+
+    """
+    arr, mask = _replace_nan(a, 0)
+    if mask is None:
+        return np.var(arr, axis=axis, dtype=dtype, out=out, ddof=ddof,
+                      keepdims=keepdims, where=where, mean=mean,
+                      correction=correction)
+
+    if dtype is not None:
+        dtype = np.dtype(dtype)
+    if dtype is not None and not issubclass(dtype.type, np.inexact):
+        raise TypeError("If a is inexact, then dtype must be inexact")
+    if out is not None and not issubclass(out.dtype.type, np.inexact):
+        raise TypeError("If a is inexact, then out must be inexact")
+
+    if correction != np._NoValue:
+        if ddof != 0:
+            raise ValueError(
+                "ddof and correction can't be provided simultaneously."
+            )
+        else:
+            ddof = correction
+
+    # Compute mean
+    if type(arr) is np.matrix:
+        _keepdims = np._NoValue
+    else:
+        _keepdims = True
+
+    cnt = np.sum(~mask, axis=axis, dtype=np.intp, keepdims=_keepdims,
+                     where=where)
+
+    if mean is not np._NoValue:
+        avg = mean
+    else:
+        # we need to special case matrix for reverse compatibility
+        # in order for this to work, these sums need to be called with
+        # keepdims=True, however matrix now raises an error in this case, but
+        # the reason that it drops the keepdims kwarg is to force keepdims=True
+        # so this used to work by serendipity.
+        avg = np.sum(arr, axis=axis, dtype=dtype,
+                     keepdims=_keepdims, where=where)
+        avg = _divide_by_count(avg, cnt)
+
+    # Compute squared deviation from mean.
+    np.subtract(arr, avg, out=arr, casting='unsafe', where=where)
+    arr = _copyto(arr, 0, mask)
+    if issubclass(arr.dtype.type, np.complexfloating):
+        sqr = np.multiply(arr, arr.conj(), out=arr, where=where).real
+    else:
+        sqr = np.multiply(arr, arr, out=arr, where=where)
+
+    # Compute variance.
+    var = np.sum(sqr, axis=axis, dtype=dtype, out=out, keepdims=keepdims,
+                 where=where)
+
+    # Precaution against reduced object arrays
+    try:
+        var_ndim = var.ndim
+    except AttributeError:
+        var_ndim = np.ndim(var)
+    if var_ndim < cnt.ndim:
+        # Subclasses of ndarray may ignore keepdims, so check here.
+        cnt = cnt.squeeze(axis)
+    dof = cnt - ddof
+    var = _divide_by_count(var, dof)
+
+    isbad = (dof <= 0)
+    if np.any(isbad):
+        warnings.warn("Degrees of freedom <= 0 for slice.", RuntimeWarning,
+                      stacklevel=2)
+        # NaN, inf, or negative numbers are all possible bad
+        # values, so explicitly replace them with NaN.
+        var = _copyto(var, np.nan, isbad)
+    return var
+
+
+def _nanstd_dispatcher(a, axis=None, dtype=None, out=None, ddof=None,
+                       keepdims=None, *, where=None, mean=None,
+                       correction=None):
+    return (a, out)
+
+
+@array_function_dispatch(_nanstd_dispatcher)
+def nanstd(a, axis=None, dtype=None, out=None, ddof=0, keepdims=np._NoValue,
+           *, where=np._NoValue, mean=np._NoValue, correction=np._NoValue):
+    """
+    Compute the standard deviation along the specified axis, while
+    ignoring NaNs.
+
+    Returns the standard deviation, a measure of the spread of a
+    distribution, of the non-NaN array elements. The standard deviation is
+    computed for the flattened array by default, otherwise over the
+    specified axis.
+
+    For all-NaN slices or slices with zero degrees of freedom, NaN is
+    returned and a `RuntimeWarning` is raised.
+
+    .. versionadded:: 1.8.0
+
+    Parameters
+    ----------
+    a : array_like
+        Calculate the standard deviation of the non-NaN values.
+    axis : {int, tuple of int, None}, optional
+        Axis or axes along which the standard deviation is computed. The default is
+        to compute the standard deviation of the flattened array.
+    dtype : dtype, optional
+        Type to use in computing the standard deviation. For arrays of
+        integer type the default is float64, for arrays of float types it
+        is the same as the array type.
+    out : ndarray, optional
+        Alternative output array in which to place the result. It must have
+        the same shape as the expected output but the type (of the
+        calculated values) will be cast if necessary.
+    ddof : {int, float}, optional
+        Means Delta Degrees of Freedom.  The divisor used in calculations
+        is ``N - ddof``, where ``N`` represents the number of non-NaN
+        elements.  By default `ddof` is zero.
+
+    keepdims : bool, optional
+        If this is set to True, the axes which are reduced are left
+        in the result as dimensions with size one. With this option,
+        the result will broadcast correctly against the original `a`.
+
+        If this value is anything but the default it is passed through
+        as-is to the relevant functions of the sub-classes.  If these
+        functions do not have a `keepdims` kwarg, a RuntimeError will
+        be raised.
+    where : array_like of bool, optional
+        Elements to include in the standard deviation.
+        See `~numpy.ufunc.reduce` for details.
+
+        .. versionadded:: 1.22.0
+
+    mean : array_like, optional
+        Provide the mean to prevent its recalculation. The mean should have
+        a shape as if it was calculated with ``keepdims=True``.
+        The axis for the calculation of the mean should be the same as used in
+        the call to this std function.
+
+        .. versionadded:: 1.26.0
+
+    correction : {int, float}, optional
+        Array API compatible name for the ``ddof`` parameter. Only one of them
+        can be provided at the same time.
+
+        .. versionadded:: 2.0.0
+
+    Returns
+    -------
+    standard_deviation : ndarray, see dtype parameter above.
+        If `out` is None, return a new array containing the standard
+        deviation, otherwise return a reference to the output array. If
+        ddof is >= the number of non-NaN elements in a slice or the slice
+        contains only NaNs, then the result for that slice is NaN.
+
+    See Also
+    --------
+    var, mean, std
+    nanvar, nanmean
+    :ref:`ufuncs-output-type`
+
+    Notes
+    -----
+    The standard deviation is the square root of the average of the squared
+    deviations from the mean: ``std = sqrt(mean(abs(x - x.mean())**2))``.
+
+    The average squared deviation is normally calculated as
+    ``x.sum() / N``, where ``N = len(x)``.  If, however, `ddof` is
+    specified, the divisor ``N - ddof`` is used instead. In standard
+    statistical practice, ``ddof=1`` provides an unbiased estimator of the
+    variance of the infinite population. ``ddof=0`` provides a maximum
+    likelihood estimate of the variance for normally distributed variables.
+    The standard deviation computed in this function is the square root of
+    the estimated variance, so even with ``ddof=1``, it will not be an
+    unbiased estimate of the standard deviation per se.
+
+    Note that, for complex numbers, `std` takes the absolute value before
+    squaring, so that the result is always real and nonnegative.
+
+    For floating-point input, the *std* is computed using the same
+    precision the input has. Depending on the input data, this can cause
+    the results to be inaccurate, especially for float32 (see example
+    below).  Specifying a higher-accuracy accumulator using the `dtype`
+    keyword can alleviate this issue.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> a = np.array([[1, np.nan], [3, 4]])
+    >>> np.nanstd(a)
+    1.247219128924647
+    >>> np.nanstd(a, axis=0)
+    array([1., 0.])
+    >>> np.nanstd(a, axis=1)
+    array([0.,  0.5]) # may vary
+
+    """
+    var = nanvar(a, axis=axis, dtype=dtype, out=out, ddof=ddof,
+                 keepdims=keepdims, where=where, mean=mean,
+                 correction=correction)
+    if isinstance(var, np.ndarray):
+        std = np.sqrt(var, out=var)
+    elif hasattr(var, 'dtype'):
+        std = var.dtype.type(np.sqrt(var))
+    else:
+        std = np.sqrt(var)
+    return std
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/_nanfunctions_impl.pyi b/venv/lib/python3.12/site-packages/numpy/lib/_nanfunctions_impl.pyi
new file mode 100644
index 00000000..d81f883f
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/lib/_nanfunctions_impl.pyi
@@ -0,0 +1,38 @@
+from numpy._core.fromnumeric import (
+    amin,
+    amax,
+    argmin,
+    argmax,
+    sum,
+    prod,
+    cumsum,
+    cumprod,
+    mean,
+    var,
+    std
+)
+
+from numpy.lib._function_base_impl import (
+    median,
+    percentile,
+    quantile,
+)
+
+__all__: list[str]
+
+# NOTE: In reaility these functions are not aliases but distinct functions
+# with identical signatures.
+nanmin = amin
+nanmax = amax
+nanargmin = argmin
+nanargmax = argmax
+nansum = sum
+nanprod = prod
+nancumsum = cumsum
+nancumprod = cumprod
+nanmean = mean
+nanvar = var
+nanstd = std
+nanmedian = median
+nanpercentile = percentile
+nanquantile = quantile
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/_npyio_impl.py b/venv/lib/python3.12/site-packages/numpy/lib/_npyio_impl.py
new file mode 100644
index 00000000..a83c46b0
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/lib/_npyio_impl.py
@@ -0,0 +1,2612 @@
+"""
+IO related functions.
+"""
+import os
+import re
+import functools
+import itertools
+import warnings
+import weakref
+import contextlib
+import operator
+from operator import itemgetter, index as opindex, methodcaller
+from collections.abc import Mapping
+import pickle
+
+import numpy as np
+from . import format
+from ._datasource import DataSource
+from numpy._core import overrides
+from numpy._core.multiarray import packbits, unpackbits
+from numpy._core._multiarray_umath import _load_from_filelike
+from numpy._core.overrides import set_array_function_like_doc, set_module
+from ._iotools import (
+    LineSplitter, NameValidator, StringConverter, ConverterError,
+    ConverterLockError, ConversionWarning, _is_string_like,
+    has_nested_fields, flatten_dtype, easy_dtype, _decode_line
+    )
+from numpy._utils import asunicode, asbytes
+
+
+__all__ = [
+    'savetxt', 'loadtxt', 'genfromtxt', 'load', 'save', 'savez',
+    'savez_compressed', 'packbits', 'unpackbits', 'fromregex'
+    ]
+
+
+array_function_dispatch = functools.partial(
+    overrides.array_function_dispatch, module='numpy')
+
+
+class BagObj:
+    """
+    BagObj(obj)
+
+    Convert attribute look-ups to getitems on the object passed in.
+
+    Parameters
+    ----------
+    obj : class instance
+        Object on which attribute look-up is performed.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from numpy.lib._npyio_impl import BagObj as BO
+    >>> class BagDemo:
+    ...     def __getitem__(self, key): # An instance of BagObj(BagDemo)
+    ...                                 # will call this method when any
+    ...                                 # attribute look-up is required
+    ...         result = "Doesn't matter what you want, "
+    ...         return result + "you're gonna get this"
+    ...
+    >>> demo_obj = BagDemo()
+    >>> bagobj = BO(demo_obj)
+    >>> bagobj.hello_there
+    "Doesn't matter what you want, you're gonna get this"
+    >>> bagobj.I_can_be_anything
+    "Doesn't matter what you want, you're gonna get this"
+
+    """
+
+    def __init__(self, obj):
+        # Use weakref to make NpzFile objects collectable by refcount
+        self._obj = weakref.proxy(obj)
+
+    def __getattribute__(self, key):
+        try:
+            return object.__getattribute__(self, '_obj')[key]
+        except KeyError:
+            raise AttributeError(key) from None
+
+    def __dir__(self):
+        """
+        Enables dir(bagobj) to list the files in an NpzFile.
+
+        This also enables tab-completion in an interpreter or IPython.
+        """
+        return list(object.__getattribute__(self, '_obj').keys())
+
+
+def zipfile_factory(file, *args, **kwargs):
+    """
+    Create a ZipFile.
+
+    Allows for Zip64, and the `file` argument can accept file, str, or
+    pathlib.Path objects. `args` and `kwargs` are passed to the zipfile.ZipFile
+    constructor.
+    """
+    if not hasattr(file, 'read'):
+        file = os.fspath(file)
+    import zipfile
+    kwargs['allowZip64'] = True
+    return zipfile.ZipFile(file, *args, **kwargs)
+
+
+@set_module('numpy.lib.npyio')
+class NpzFile(Mapping):
+    """
+    NpzFile(fid)
+
+    A dictionary-like object with lazy-loading of files in the zipped
+    archive provided on construction.
+
+    `NpzFile` is used to load files in the NumPy ``.npz`` data archive
+    format. It assumes that files in the archive have a ``.npy`` extension,
+    other files are ignored.
+
+    The arrays and file strings are lazily loaded on either
+    getitem access using ``obj['key']`` or attribute lookup using
+    ``obj.f.key``. A list of all files (without ``.npy`` extensions) can
+    be obtained with ``obj.files`` and the ZipFile object itself using
+    ``obj.zip``.
+
+    Attributes
+    ----------
+    files : list of str
+        List of all files in the archive with a ``.npy`` extension.
+    zip : ZipFile instance
+        The ZipFile object initialized with the zipped archive.
+    f : BagObj instance
+        An object on which attribute can be performed as an alternative
+        to getitem access on the `NpzFile` instance itself.
+    allow_pickle : bool, optional
+        Allow loading pickled data. Default: False
+
+        .. versionchanged:: 1.16.3
+            Made default False in response to CVE-2019-6446.
+
+    pickle_kwargs : dict, optional
+        Additional keyword arguments to pass on to pickle.load.
+        These are only useful when loading object arrays saved on
+        Python 2 when using Python 3.
+    max_header_size : int, optional
+        Maximum allowed size of the header.  Large headers may not be safe
+        to load securely and thus require explicitly passing a larger value.
+        See :py:func:`ast.literal_eval()` for details.
+        This option is ignored when `allow_pickle` is passed.  In that case
+        the file is by definition trusted and the limit is unnecessary.
+
+    Parameters
+    ----------
+    fid : file, str, or pathlib.Path
+        The zipped archive to open. This is either a file-like object
+        or a string containing the path to the archive.
+    own_fid : bool, optional
+        Whether NpzFile should close the file handle.
+        Requires that `fid` is a file-like object.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from tempfile import TemporaryFile
+    >>> outfile = TemporaryFile()
+    >>> x = np.arange(10)
+    >>> y = np.sin(x)
+    >>> np.savez(outfile, x=x, y=y)
+    >>> _ = outfile.seek(0)
+
+    >>> npz = np.load(outfile)
+    >>> isinstance(npz, np.lib.npyio.NpzFile)
+    True
+    >>> npz
+    NpzFile 'object' with keys: x, y
+    >>> sorted(npz.files)
+    ['x', 'y']
+    >>> npz['x']  # getitem access
+    array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
+    >>> npz.f.x  # attribute lookup
+    array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
+
+    """
+    # Make __exit__ safe if zipfile_factory raises an exception
+    zip = None
+    fid = None
+    _MAX_REPR_ARRAY_COUNT = 5
+
+    def __init__(self, fid, own_fid=False, allow_pickle=False,
+                 pickle_kwargs=None, *,
+                 max_header_size=format._MAX_HEADER_SIZE):
+        # Import is postponed to here since zipfile depends on gzip, an
+        # optional component of the so-called standard library.
+        _zip = zipfile_factory(fid)
+        self._files = _zip.namelist()
+        self.files = []
+        self.allow_pickle = allow_pickle
+        self.max_header_size = max_header_size
+        self.pickle_kwargs = pickle_kwargs
+        for x in self._files:
+            if x.endswith('.npy'):
+                self.files.append(x[:-4])
+            else:
+                self.files.append(x)
+        self.zip = _zip
+        self.f = BagObj(self)
+        if own_fid:
+            self.fid = fid
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        self.close()
+
+    def close(self):
+        """
+        Close the file.
+
+        """
+        if self.zip is not None:
+            self.zip.close()
+            self.zip = None
+        if self.fid is not None:
+            self.fid.close()
+            self.fid = None
+        self.f = None  # break reference cycle
+
+    def __del__(self):
+        self.close()
+
+    # Implement the Mapping ABC
+    def __iter__(self):
+        return iter(self.files)
+
+    def __len__(self):
+        return len(self.files)
+
+    def __getitem__(self, key):
+        # FIXME: This seems like it will copy strings around
+        #   more than is strictly necessary.  The zipfile
+        #   will read the string and then
+        #   the format.read_array will copy the string
+        #   to another place in memory.
+        #   It would be better if the zipfile could read
+        #   (or at least uncompress) the data
+        #   directly into the array memory.
+        member = False
+        if key in self._files:
+            member = True
+        elif key in self.files:
+            member = True
+            key += '.npy'
+        if member:
+            bytes = self.zip.open(key)
+            magic = bytes.read(len(format.MAGIC_PREFIX))
+            bytes.close()
+            if magic == format.MAGIC_PREFIX:
+                bytes = self.zip.open(key)
+                return format.read_array(bytes,
+                                         allow_pickle=self.allow_pickle,
+                                         pickle_kwargs=self.pickle_kwargs,
+                                         max_header_size=self.max_header_size)
+            else:
+                return self.zip.read(key)
+        else:
+            raise KeyError(f"{key} is not a file in the archive")
+
+    def __contains__(self, key):
+        return (key in self._files or key in self.files)
+
+    def __repr__(self):
+        # Get filename or default to `object`
+        if isinstance(self.fid, str):
+            filename = self.fid
+        else:
+            filename = getattr(self.fid, "name", "object")
+
+        # Get the name of arrays
+        array_names = ', '.join(self.files[:self._MAX_REPR_ARRAY_COUNT])
+        if len(self.files) > self._MAX_REPR_ARRAY_COUNT:
+            array_names += "..."
+        return f"NpzFile {filename!r} with keys: {array_names}"
+
+    # Work around problems with the docstrings in the Mapping methods
+    # They contain a `->`, which confuses the type annotation interpretations
+    # of sphinx-docs. See gh-25964
+
+    def get(self, key, default=None, /):
+        """
+        D.get(k,[,d]) returns D[k] if k in D, else d.  d defaults to None.
+        """
+        return Mapping.get(self, key, default)
+
+    def items(self):
+        """
+        D.items() returns a set-like object providing a view on the items
+        """
+        return Mapping.items(self)
+
+    def keys(self):
+        """
+        D.keys() returns a set-like object providing a view on the keys
+        """
+        return Mapping.keys(self)
+
+    def values(self):
+        """
+        D.values() returns a set-like object providing a view on the values
+        """
+        return Mapping.values(self)
+
+
+@set_module('numpy')
+def load(file, mmap_mode=None, allow_pickle=False, fix_imports=True,
+         encoding='ASCII', *, max_header_size=format._MAX_HEADER_SIZE):
+    """
+    Load arrays or pickled objects from ``.npy``, ``.npz`` or pickled files.
+
+    .. warning:: Loading files that contain object arrays uses the ``pickle``
+                 module, which is not secure against erroneous or maliciously
+                 constructed data. Consider passing ``allow_pickle=False`` to
+                 load data that is known not to contain object arrays for the
+                 safer handling of untrusted sources.
+
+    Parameters
+    ----------
+    file : file-like object, string, or pathlib.Path
+        The file to read. File-like objects must support the
+        ``seek()`` and ``read()`` methods and must always
+        be opened in binary mode.  Pickled files require that the
+        file-like object support the ``readline()`` method as well.
+    mmap_mode : {None, 'r+', 'r', 'w+', 'c'}, optional
+        If not None, then memory-map the file, using the given mode (see
+        `numpy.memmap` for a detailed description of the modes).  A
+        memory-mapped array is kept on disk. However, it can be accessed
+        and sliced like any ndarray.  Memory mapping is especially useful
+        for accessing small fragments of large files without reading the
+        entire file into memory.
+    allow_pickle : bool, optional
+        Allow loading pickled object arrays stored in npy files. Reasons for
+        disallowing pickles include security, as loading pickled data can
+        execute arbitrary code. If pickles are disallowed, loading object
+        arrays will fail. Default: False
+
+        .. versionchanged:: 1.16.3
+            Made default False in response to CVE-2019-6446.
+
+    fix_imports : bool, optional
+        Only useful when loading Python 2 generated pickled files on Python 3,
+        which includes npy/npz files containing object arrays. If `fix_imports`
+        is True, pickle will try to map the old Python 2 names to the new names
+        used in Python 3.
+    encoding : str, optional
+        What encoding to use when reading Python 2 strings. Only useful when
+        loading Python 2 generated pickled files in Python 3, which includes
+        npy/npz files containing object arrays. Values other than 'latin1',
+        'ASCII', and 'bytes' are not allowed, as they can corrupt numerical
+        data. Default: 'ASCII'
+    max_header_size : int, optional
+        Maximum allowed size of the header.  Large headers may not be safe
+        to load securely and thus require explicitly passing a larger value.
+        See :py:func:`ast.literal_eval()` for details.
+        This option is ignored when `allow_pickle` is passed.  In that case
+        the file is by definition trusted and the limit is unnecessary.
+
+    Returns
+    -------
+    result : array, tuple, dict, etc.
+        Data stored in the file. For ``.npz`` files, the returned instance
+        of NpzFile class must be closed to avoid leaking file descriptors.
+
+    Raises
+    ------
+    OSError
+        If the input file does not exist or cannot be read.
+    UnpicklingError
+        If ``allow_pickle=True``, but the file cannot be loaded as a pickle.
+    ValueError
+        The file contains an object array, but ``allow_pickle=False`` given.
+    EOFError
+        When calling ``np.load`` multiple times on the same file handle,
+        if all data has already been read
+
+    See Also
+    --------
+    save, savez, savez_compressed, loadtxt
+    memmap : Create a memory-map to an array stored in a file on disk.
+    lib.format.open_memmap : Create or load a memory-mapped ``.npy`` file.
+
+    Notes
+    -----
+    - If the file contains pickle data, then whatever object is stored
+      in the pickle is returned.
+    - If the file is a ``.npy`` file, then a single array is returned.
+    - If the file is a ``.npz`` file, then a dictionary-like object is
+      returned, containing ``{filename: array}`` key-value pairs, one for
+      each file in the archive.
+    - If the file is a ``.npz`` file, the returned value supports the
+      context manager protocol in a similar fashion to the open function::
+
+        with load('foo.npz') as data:
+            a = data['a']
+
+      The underlying file descriptor is closed when exiting the 'with'
+      block.
+
+    Examples
+    --------
+    >>> import numpy as np
+
+    Store data to disk, and load it again:
+
+    >>> np.save('/tmp/123', np.array([[1, 2, 3], [4, 5, 6]]))
+    >>> np.load('/tmp/123.npy')
+    array([[1, 2, 3],
+           [4, 5, 6]])
+
+    Store compressed data to disk, and load it again:
+
+    >>> a=np.array([[1, 2, 3], [4, 5, 6]])
+    >>> b=np.array([1, 2])
+    >>> np.savez('/tmp/123.npz', a=a, b=b)
+    >>> data = np.load('/tmp/123.npz')
+    >>> data['a']
+    array([[1, 2, 3],
+           [4, 5, 6]])
+    >>> data['b']
+    array([1, 2])
+    >>> data.close()
+
+    Mem-map the stored array, and then access the second row
+    directly from disk:
+
+    >>> X = np.load('/tmp/123.npy', mmap_mode='r')
+    >>> X[1, :]
+    memmap([4, 5, 6])
+
+    """
+    if encoding not in ('ASCII', 'latin1', 'bytes'):
+        # The 'encoding' value for pickle also affects what encoding
+        # the serialized binary data of NumPy arrays is loaded
+        # in. Pickle does not pass on the encoding information to
+        # NumPy. The unpickling code in numpy._core.multiarray is
+        # written to assume that unicode data appearing where binary
+        # should be is in 'latin1'. 'bytes' is also safe, as is 'ASCII'.
+        #
+        # Other encoding values can corrupt binary data, and we
+        # purposefully disallow them. For the same reason, the errors=
+        # argument is not exposed, as values other than 'strict'
+        # result can similarly silently corrupt numerical data.
+        raise ValueError("encoding must be 'ASCII', 'latin1', or 'bytes'")
+
+    pickle_kwargs = dict(encoding=encoding, fix_imports=fix_imports)
+
+    with contextlib.ExitStack() as stack:
+        if hasattr(file, 'read'):
+            fid = file
+            own_fid = False
+        else:
+            fid = stack.enter_context(open(os.fspath(file), "rb"))
+            own_fid = True
+
+        # Code to distinguish from NumPy binary files and pickles.
+        _ZIP_PREFIX = b'PK\x03\x04'
+        _ZIP_SUFFIX = b'PK\x05\x06'  # empty zip files start with this
+        N = len(format.MAGIC_PREFIX)
+        magic = fid.read(N)
+        if not magic:
+            raise EOFError("No data left in file")
+        # If the file size is less than N, we need to make sure not
+        # to seek past the beginning of the file
+        fid.seek(-min(N, len(magic)), 1)  # back-up
+        if magic.startswith(_ZIP_PREFIX) or magic.startswith(_ZIP_SUFFIX):
+            # zip-file (assume .npz)
+            # Potentially transfer file ownership to NpzFile
+            stack.pop_all()
+            ret = NpzFile(fid, own_fid=own_fid, allow_pickle=allow_pickle,
+                          pickle_kwargs=pickle_kwargs,
+                          max_header_size=max_header_size)
+            return ret
+        elif magic == format.MAGIC_PREFIX:
+            # .npy file
+            if mmap_mode:
+                if allow_pickle:
+                    max_header_size = 2**64
+                return format.open_memmap(file, mode=mmap_mode,
+                                          max_header_size=max_header_size)
+            else:
+                return format.read_array(fid, allow_pickle=allow_pickle,
+                                         pickle_kwargs=pickle_kwargs,
+                                         max_header_size=max_header_size)
+        else:
+            # Try a pickle
+            if not allow_pickle:
+                raise ValueError("Cannot load file containing pickled data "
+                                 "when allow_pickle=False")
+            try:
+                return pickle.load(fid, **pickle_kwargs)
+            except Exception as e:
+                raise pickle.UnpicklingError(
+                    f"Failed to interpret file {file!r} as a pickle") from e
+
+
+def _save_dispatcher(file, arr, allow_pickle=None, fix_imports=None):
+    return (arr,)
+
+
+@array_function_dispatch(_save_dispatcher)
+def save(file, arr, allow_pickle=True, fix_imports=np._NoValue):
+    """
+    Save an array to a binary file in NumPy ``.npy`` format.
+
+    Parameters
+    ----------
+    file : file, str, or pathlib.Path
+        File or filename to which the data is saved. If file is a file-object,
+        then the filename is unchanged.  If file is a string or Path,
+        a ``.npy`` extension will be appended to the filename if it does not
+        already have one.
+    arr : array_like
+        Array data to be saved.
+    allow_pickle : bool, optional
+        Allow saving object arrays using Python pickles. Reasons for
+        disallowing pickles include security (loading pickled data can execute
+        arbitrary code) and portability (pickled objects may not be loadable
+        on different Python installations, for example if the stored objects
+        require libraries that are not available, and not all pickled data is
+        compatible between different versions of Python).
+        Default: True
+    fix_imports : bool, optional
+        The `fix_imports` flag is deprecated and has no effect.
+
+        .. deprecated:: 2.1
+            This flag is ignored since NumPy 1.17 and was only needed to
+            support loading some files in Python 2 written in Python 3.
+
+    See Also
+    --------
+    savez : Save several arrays into a ``.npz`` archive
+    savetxt, load
+
+    Notes
+    -----
+    For a description of the ``.npy`` format, see :py:mod:`numpy.lib.format`.
+
+    Any data saved to the file is appended to the end of the file.
+
+    Examples
+    --------
+    >>> import numpy as np
+
+    >>> from tempfile import TemporaryFile
+    >>> outfile = TemporaryFile()
+
+    >>> x = np.arange(10)
+    >>> np.save(outfile, x)
+
+    >>> _ = outfile.seek(0) # Only needed to simulate closing & reopening file
+    >>> np.load(outfile)
+    array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
+
+
+    >>> with open('test.npy', 'wb') as f:
+    ...     np.save(f, np.array([1, 2]))
+    ...     np.save(f, np.array([1, 3]))
+    >>> with open('test.npy', 'rb') as f:
+    ...     a = np.load(f)
+    ...     b = np.load(f)
+    >>> print(a, b)
+    # [1 2] [1 3]
+    """
+    if fix_imports is not np._NoValue:
+        # Deprecated 2024-05-16, NumPy 2.1
+        warnings.warn(
+            "The 'fix_imports' flag is deprecated and has no effect. "
+            "(Deprecated in NumPy 2.1)",
+            DeprecationWarning, stacklevel=2)
+    if hasattr(file, 'write'):
+        file_ctx = contextlib.nullcontext(file)
+    else:
+        file = os.fspath(file)
+        if not file.endswith('.npy'):
+            file = file + '.npy'
+        file_ctx = open(file, "wb")
+
+    with file_ctx as fid:
+        arr = np.asanyarray(arr)
+        format.write_array(fid, arr, allow_pickle=allow_pickle,
+                           pickle_kwargs=dict(fix_imports=fix_imports))
+
+
+def _savez_dispatcher(file, *args, **kwds):
+    yield from args
+    yield from kwds.values()
+
+
+@array_function_dispatch(_savez_dispatcher)
+def savez(file, *args, **kwds):
+    """Save several arrays into a single file in uncompressed ``.npz`` format.
+
+    Provide arrays as keyword arguments to store them under the
+    corresponding name in the output file: ``savez(fn, x=x, y=y)``.
+
+    If arrays are specified as positional arguments, i.e., ``savez(fn,
+    x, y)``, their names will be `arr_0`, `arr_1`, etc.
+
+    Parameters
+    ----------
+    file : file, str, or pathlib.Path
+        Either the filename (string) or an open file (file-like object)
+        where the data will be saved. If file is a string or a Path, the
+        ``.npz`` extension will be appended to the filename if it is not
+        already there.
+    args : Arguments, optional
+        Arrays to save to the file. Please use keyword arguments (see
+        `kwds` below) to assign names to arrays.  Arrays specified as
+        args will be named "arr_0", "arr_1", and so on.
+    kwds : Keyword arguments, optional
+        Arrays to save to the file. Each array will be saved to the
+        output file with its corresponding keyword name.
+
+    Returns
+    -------
+    None
+
+    See Also
+    --------
+    save : Save a single array to a binary file in NumPy format.
+    savetxt : Save an array to a file as plain text.
+    savez_compressed : Save several arrays into a compressed ``.npz`` archive
+
+    Notes
+    -----
+    The ``.npz`` file format is a zipped archive of files named after the
+    variables they contain.  The archive is not compressed and each file
+    in the archive contains one variable in ``.npy`` format. For a
+    description of the ``.npy`` format, see :py:mod:`numpy.lib.format`.
+
+    When opening the saved ``.npz`` file with `load` a `~lib.npyio.NpzFile`
+    object is returned. This is a dictionary-like object which can be queried
+    for its list of arrays (with the ``.files`` attribute), and for the arrays
+    themselves.
+
+    Keys passed in `kwds` are used as filenames inside the ZIP archive.
+    Therefore, keys should be valid filenames; e.g., avoid keys that begin with
+    ``/`` or contain ``.``.
+
+    When naming variables with keyword arguments, it is not possible to name a
+    variable ``file``, as this would cause the ``file`` argument to be defined
+    twice in the call to ``savez``.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from tempfile import TemporaryFile
+    >>> outfile = TemporaryFile()
+    >>> x = np.arange(10)
+    >>> y = np.sin(x)
+
+    Using `savez` with \\*args, the arrays are saved with default names.
+
+    >>> np.savez(outfile, x, y)
+    >>> _ = outfile.seek(0) # Only needed to simulate closing & reopening file
+    >>> npzfile = np.load(outfile)
+    >>> npzfile.files
+    ['arr_0', 'arr_1']
+    >>> npzfile['arr_0']
+    array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
+
+    Using `savez` with \\**kwds, the arrays are saved with the keyword names.
+
+    >>> outfile = TemporaryFile()
+    >>> np.savez(outfile, x=x, y=y)
+    >>> _ = outfile.seek(0)
+    >>> npzfile = np.load(outfile)
+    >>> sorted(npzfile.files)
+    ['x', 'y']
+    >>> npzfile['x']
+    array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
+
+    """
+    _savez(file, args, kwds, False)
+
+
+def _savez_compressed_dispatcher(file, *args, **kwds):
+    yield from args
+    yield from kwds.values()
+
+
+@array_function_dispatch(_savez_compressed_dispatcher)
+def savez_compressed(file, *args, **kwds):
+    """
+    Save several arrays into a single file in compressed ``.npz`` format.
+
+    Provide arrays as keyword arguments to store them under the
+    corresponding name in the output file: ``savez_compressed(fn, x=x, y=y)``.
+
+    If arrays are specified as positional arguments, i.e.,
+    ``savez_compressed(fn, x, y)``, their names will be `arr_0`, `arr_1`, etc.
+
+    Parameters
+    ----------
+    file : file, str, or pathlib.Path
+        Either the filename (string) or an open file (file-like object)
+        where the data will be saved. If file is a string or a Path, the
+        ``.npz`` extension will be appended to the filename if it is not
+        already there.
+    args : Arguments, optional
+        Arrays to save to the file. Please use keyword arguments (see
+        `kwds` below) to assign names to arrays.  Arrays specified as
+        args will be named "arr_0", "arr_1", and so on.
+    kwds : Keyword arguments, optional
+        Arrays to save to the file. Each array will be saved to the
+        output file with its corresponding keyword name.
+
+    Returns
+    -------
+    None
+
+    See Also
+    --------
+    numpy.save : Save a single array to a binary file in NumPy format.
+    numpy.savetxt : Save an array to a file as plain text.
+    numpy.savez : Save several arrays into an uncompressed ``.npz`` file format
+    numpy.load : Load the files created by savez_compressed.
+
+    Notes
+    -----
+    The ``.npz`` file format is a zipped archive of files named after the
+    variables they contain.  The archive is compressed with
+    ``zipfile.ZIP_DEFLATED`` and each file in the archive contains one variable
+    in ``.npy`` format. For a description of the ``.npy`` format, see
+    :py:mod:`numpy.lib.format`.
+
+
+    When opening the saved ``.npz`` file with `load` a `~lib.npyio.NpzFile`
+    object is returned. This is a dictionary-like object which can be queried
+    for its list of arrays (with the ``.files`` attribute), and for the arrays
+    themselves.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> test_array = np.random.rand(3, 2)
+    >>> test_vector = np.random.rand(4)
+    >>> np.savez_compressed('/tmp/123', a=test_array, b=test_vector)
+    >>> loaded = np.load('/tmp/123.npz')
+    >>> print(np.array_equal(test_array, loaded['a']))
+    True
+    >>> print(np.array_equal(test_vector, loaded['b']))
+    True
+
+    """
+    _savez(file, args, kwds, True)
+
+
+def _savez(file, args, kwds, compress, allow_pickle=True, pickle_kwargs=None):
+    # Import is postponed to here since zipfile depends on gzip, an optional
+    # component of the so-called standard library.
+    import zipfile
+
+    if not hasattr(file, 'write'):
+        file = os.fspath(file)
+        if not file.endswith('.npz'):
+            file = file + '.npz'
+
+    namedict = kwds
+    for i, val in enumerate(args):
+        key = 'arr_%d' % i
+        if key in namedict.keys():
+            raise ValueError(
+                "Cannot use un-named variables and keyword %s" % key)
+        namedict[key] = val
+
+    if compress:
+        compression = zipfile.ZIP_DEFLATED
+    else:
+        compression = zipfile.ZIP_STORED
+
+    zipf = zipfile_factory(file, mode="w", compression=compression)
+
+    for key, val in namedict.items():
+        fname = key + '.npy'
+        val = np.asanyarray(val)
+        # always force zip64, gh-10776
+        with zipf.open(fname, 'w', force_zip64=True) as fid:
+            format.write_array(fid, val,
+                               allow_pickle=allow_pickle,
+                               pickle_kwargs=pickle_kwargs)
+
+    zipf.close()
+
+
+def _ensure_ndmin_ndarray_check_param(ndmin):
+    """Just checks if the param ndmin is supported on
+        _ensure_ndmin_ndarray. It is intended to be used as
+        verification before running anything expensive.
+        e.g. loadtxt, genfromtxt
+    """
+    # Check correctness of the values of `ndmin`
+    if ndmin not in [0, 1, 2]:
+        raise ValueError(f"Illegal value of ndmin keyword: {ndmin}")
+
+def _ensure_ndmin_ndarray(a, *, ndmin: int):
+    """This is a helper function of loadtxt and genfromtxt to ensure
+        proper minimum dimension as requested
+
+        ndim : int. Supported values 1, 2, 3
+                    ^^ whenever this changes, keep in sync with
+                       _ensure_ndmin_ndarray_check_param
+    """
+    # Verify that the array has at least dimensions `ndmin`.
+    # Tweak the size and shape of the arrays - remove extraneous dimensions
+    if a.ndim > ndmin:
+        a = np.squeeze(a)
+    # and ensure we have the minimum number of dimensions asked for
+    # - has to be in this order for the odd case ndmin=1, a.squeeze().ndim=0
+    if a.ndim < ndmin:
+        if ndmin == 1:
+            a = np.atleast_1d(a)
+        elif ndmin == 2:
+            a = np.atleast_2d(a).T
+
+    return a
+
+
+# amount of lines loadtxt reads in one chunk, can be overridden for testing
+_loadtxt_chunksize = 50000
+
+
+def _check_nonneg_int(value, name="argument"):
+    try:
+        operator.index(value)
+    except TypeError:
+        raise TypeError(f"{name} must be an integer") from None
+    if value < 0:
+        raise ValueError(f"{name} must be nonnegative")
+
+
+def _preprocess_comments(iterable, comments, encoding):
+    """
+    Generator that consumes a line iterated iterable and strips out the
+    multiple (or multi-character) comments from lines.
+    This is a pre-processing step to achieve feature parity with loadtxt
+    (we assume that this feature is a nieche feature).
+    """
+    for line in iterable:
+        if isinstance(line, bytes):
+            # Need to handle conversion here, or the splitting would fail
+            line = line.decode(encoding)
+
+        for c in comments:
+            line = line.split(c, 1)[0]
+
+        yield line
+
+
+# The number of rows we read in one go if confronted with a parametric dtype
+_loadtxt_chunksize = 50000
+
+
+def _read(fname, *, delimiter=',', comment='#', quote='"',
+          imaginary_unit='j', usecols=None, skiplines=0,
+          max_rows=None, converters=None, ndmin=None, unpack=False,
+          dtype=np.float64, encoding=None):
+    r"""
+    Read a NumPy array from a text file.
+    This is a helper function for loadtxt.
+
+    Parameters
+    ----------
+    fname : file, str, or pathlib.Path
+        The filename or the file to be read.
+    delimiter : str, optional
+        Field delimiter of the fields in line of the file.
+        Default is a comma, ','.  If None any sequence of whitespace is
+        considered a delimiter.
+    comment : str or sequence of str or None, optional
+        Character that begins a comment.  All text from the comment
+        character to the end of the line is ignored.
+        Multiple comments or multiple-character comment strings are supported,
+        but may be slower and `quote` must be empty if used.
+        Use None to disable all use of comments.
+    quote : str or None, optional
+        Character that is used to quote string fields. Default is '"'
+        (a double quote). Use None to disable quote support.
+    imaginary_unit : str, optional
+        Character that represent the imaginary unit `sqrt(-1)`.
+        Default is 'j'.
+    usecols : array_like, optional
+        A one-dimensional array of integer column numbers.  These are the
+        columns from the file to be included in the array.  If this value
+        is not given, all the columns are used.
+    skiplines : int, optional
+        Number of lines to skip before interpreting the data in the file.
+    max_rows : int, optional
+        Maximum number of rows of data to read.  Default is to read the
+        entire file.
+    converters : dict or callable, optional
+        A function to parse all columns strings into the desired value, or
+        a dictionary mapping column number to a parser function.
+        E.g. if column 0 is a date string: ``converters = {0: datestr2num}``.
+        Converters can also be used to provide a default value for missing
+        data, e.g. ``converters = lambda s: float(s.strip() or 0)`` will
+        convert empty fields to 0.
+        Default: None
+    ndmin : int, optional
+        Minimum dimension of the array returned.
+        Allowed values are 0, 1 or 2.  Default is 0.
+    unpack : bool, optional
+        If True, the returned array is transposed, so that arguments may be
+        unpacked using ``x, y, z = read(...)``.  When used with a structured
+        data-type, arrays are returned for each field.  Default is False.
+    dtype : numpy data type
+        A NumPy dtype instance, can be a structured dtype to map to the
+        columns of the file.
+    encoding : str, optional
+        Encoding used to decode the inputfile. The special value 'bytes'
+        (the default) enables backwards-compatible behavior for `converters`,
+        ensuring that inputs to the converter functions are encoded
+        bytes objects. The special value 'bytes' has no additional effect if
+        ``converters=None``. If encoding is ``'bytes'`` or ``None``, the
+        default system encoding is used.
+
+    Returns
+    -------
+    ndarray
+        NumPy array.
+    """
+    # Handle special 'bytes' keyword for encoding
+    byte_converters = False
+    if encoding == 'bytes':
+        encoding = None
+        byte_converters = True
+
+    if dtype is None:
+        raise TypeError("a dtype must be provided.")
+    dtype = np.dtype(dtype)
+
+    read_dtype_via_object_chunks = None
+    if dtype.kind in 'SUM' and (
+            dtype == "S0" or dtype == "U0" or dtype == "M8" or dtype == 'm8'):
+        # This is a legacy "flexible" dtype.  We do not truly support
+        # parametric dtypes currently (no dtype discovery step in the core),
+        # but have to support these for backward compatibility.
+        read_dtype_via_object_chunks = dtype
+        dtype = np.dtype(object)
+
+    if usecols is not None:
+        # Allow usecols to be a single int or a sequence of ints, the C-code
+        # handles the rest
+        try:
+            usecols = list(usecols)
+        except TypeError:
+            usecols = [usecols]
+
+    _ensure_ndmin_ndarray_check_param(ndmin)
+
+    if comment is None:
+        comments = None
+    else:
+        # assume comments are a sequence of strings
+        if "" in comment:
+            raise ValueError(
+                "comments cannot be an empty string. Use comments=None to "
+                "disable comments."
+            )
+        comments = tuple(comment)
+        comment = None
+        if len(comments) == 0:
+            comments = None  # No comments at all
+        elif len(comments) == 1:
+            # If there is only one comment, and that comment has one character,
+            # the normal parsing can deal with it just fine.
+            if isinstance(comments[0], str) and len(comments[0]) == 1:
+                comment = comments[0]
+                comments = None
+        else:
+            # Input validation if there are multiple comment characters
+            if delimiter in comments:
+                raise TypeError(
+                    f"Comment characters '{comments}' cannot include the "
+                    f"delimiter '{delimiter}'"
+                )
+
+    # comment is now either a 1 or 0 character string or a tuple:
+    if comments is not None:
+        # Note: An earlier version support two character comments (and could
+        #       have been extended to multiple characters, we assume this is
+        #       rare enough to not optimize for.
+        if quote is not None:
+            raise ValueError(
+                "when multiple comments or a multi-character comment is "
+                "given, quotes are not supported.  In this case quotechar "
+                "must be set to None.")
+
+    if len(imaginary_unit) != 1:
+        raise ValueError('len(imaginary_unit) must be 1.')
+
+    _check_nonneg_int(skiplines)
+    if max_rows is not None:
+        _check_nonneg_int(max_rows)
+    else:
+        # Passing -1 to the C code means "read the entire file".
+        max_rows = -1
+
+    fh_closing_ctx = contextlib.nullcontext()
+    filelike = False
+    try:
+        if isinstance(fname, os.PathLike):
+            fname = os.fspath(fname)
+        if isinstance(fname, str):
+            fh = np.lib._datasource.open(fname, 'rt', encoding=encoding)
+            if encoding is None:
+                encoding = getattr(fh, 'encoding', 'latin1')
+
+            fh_closing_ctx = contextlib.closing(fh)
+            data = fh
+            filelike = True
+        else:
+            if encoding is None:
+                encoding = getattr(fname, 'encoding', 'latin1')
+            data = iter(fname)
+    except TypeError as e:
+        raise ValueError(
+            f"fname must be a string, filehandle, list of strings,\n"
+            f"or generator. Got {type(fname)} instead.") from e
+
+    with fh_closing_ctx:
+        if comments is not None:
+            if filelike:
+                data = iter(data)
+                filelike = False
+            data = _preprocess_comments(data, comments, encoding)
+
+        if read_dtype_via_object_chunks is None:
+            arr = _load_from_filelike(
+                data, delimiter=delimiter, comment=comment, quote=quote,
+                imaginary_unit=imaginary_unit,
+                usecols=usecols, skiplines=skiplines, max_rows=max_rows,
+                converters=converters, dtype=dtype,
+                encoding=encoding, filelike=filelike,
+                byte_converters=byte_converters)
+
+        else:
+            # This branch reads the file into chunks of object arrays and then
+            # casts them to the desired actual dtype.  This ensures correct
+            # string-length and datetime-unit discovery (like `arr.astype()`).
+            # Due to chunking, certain error reports are less clear, currently.
+            if filelike:
+                data = iter(data)  # cannot chunk when reading from file
+                filelike = False
+
+            c_byte_converters = False
+            if read_dtype_via_object_chunks == "S":
+                c_byte_converters = True  # Use latin1 rather than ascii
+
+            chunks = []
+            while max_rows != 0:
+                if max_rows < 0:
+                    chunk_size = _loadtxt_chunksize
+                else:
+                    chunk_size = min(_loadtxt_chunksize, max_rows)
+
+                next_arr = _load_from_filelike(
+                    data, delimiter=delimiter, comment=comment, quote=quote,
+                    imaginary_unit=imaginary_unit,
+                    usecols=usecols, skiplines=skiplines, max_rows=chunk_size,
+                    converters=converters, dtype=dtype,
+                    encoding=encoding, filelike=filelike,
+                    byte_converters=byte_converters,
+                    c_byte_converters=c_byte_converters)
+                # Cast here already.  We hope that this is better even for
+                # large files because the storage is more compact.  It could
+                # be adapted (in principle the concatenate could cast).
+                chunks.append(next_arr.astype(read_dtype_via_object_chunks))
+
+                skiprows = 0  # Only have to skip for first chunk
+                if max_rows >= 0:
+                    max_rows -= chunk_size
+                if len(next_arr) < chunk_size:
+                    # There was less data than requested, so we are done.
+                    break
+
+            # Need at least one chunk, but if empty, the last one may have
+            # the wrong shape.
+            if len(chunks) > 1 and len(chunks[-1]) == 0:
+                del chunks[-1]
+            if len(chunks) == 1:
+                arr = chunks[0]
+            else:
+                arr = np.concatenate(chunks, axis=0)
+
+    # NOTE: ndmin works as advertised for structured dtypes, but normally
+    #       these would return a 1D result plus the structured dimension,
+    #       so ndmin=2 adds a third dimension even when no squeezing occurs.
+    #       A `squeeze=False` could be a better solution (pandas uses squeeze).
+    arr = _ensure_ndmin_ndarray(arr, ndmin=ndmin)
+
+    if arr.shape:
+        if arr.shape[0] == 0:
+            warnings.warn(
+                f'loadtxt: input contained no data: "{fname}"',
+                category=UserWarning,
+                stacklevel=3
+            )
+
+    if unpack:
+        # Unpack structured dtypes if requested:
+        dt = arr.dtype
+        if dt.names is not None:
+            # For structured arrays, return an array for each field.
+            return [arr[field] for field in dt.names]
+        else:
+            return arr.T
+    else:
+        return arr
+
+
+@set_array_function_like_doc
+@set_module('numpy')
+def loadtxt(fname, dtype=float, comments='#', delimiter=None,
+            converters=None, skiprows=0, usecols=None, unpack=False,
+            ndmin=0, encoding=None, max_rows=None, *, quotechar=None,
+            like=None):
+    r"""
+    Load data from a text file.
+
+    Parameters
+    ----------
+    fname : file, str, pathlib.Path, list of str, generator
+        File, filename, list, or generator to read.  If the filename
+        extension is ``.gz`` or ``.bz2``, the file is first decompressed. Note
+        that generators must return bytes or strings. The strings
+        in a list or produced by a generator are treated as lines.
+    dtype : data-type, optional
+        Data-type of the resulting array; default: float.  If this is a
+        structured data-type, the resulting array will be 1-dimensional, and
+        each row will be interpreted as an element of the array.  In this
+        case, the number of columns used must match the number of fields in
+        the data-type.
+    comments : str or sequence of str or None, optional
+        The characters or list of characters used to indicate the start of a
+        comment. None implies no comments. For backwards compatibility, byte
+        strings will be decoded as 'latin1'. The default is '#'.
+    delimiter : str, optional
+        The character used to separate the values. For backwards compatibility,
+        byte strings will be decoded as 'latin1'. The default is whitespace.
+
+        .. versionchanged:: 1.23.0
+           Only single character delimiters are supported. Newline characters
+           cannot be used as the delimiter.
+
+    converters : dict or callable, optional
+        Converter functions to customize value parsing. If `converters` is
+        callable, the function is applied to all columns, else it must be a
+        dict that maps column number to a parser function.
+        See examples for further details.
+        Default: None.
+
+        .. versionchanged:: 1.23.0
+           The ability to pass a single callable to be applied to all columns
+           was added.
+
+    skiprows : int, optional
+        Skip the first `skiprows` lines, including comments; default: 0.
+    usecols : int or sequence, optional
+        Which columns to read, with 0 being the first. For example,
+        ``usecols = (1,4,5)`` will extract the 2nd, 5th and 6th columns.
+        The default, None, results in all columns being read.
+
+        .. versionchanged:: 1.11.0
+            When a single column has to be read it is possible to use
+            an integer instead of a tuple. E.g ``usecols = 3`` reads the
+            fourth column the same way as ``usecols = (3,)`` would.
+    unpack : bool, optional
+        If True, the returned array is transposed, so that arguments may be
+        unpacked using ``x, y, z = loadtxt(...)``.  When used with a
+        structured data-type, arrays are returned for each field.
+        Default is False.
+    ndmin : int, optional
+        The returned array will have at least `ndmin` dimensions.
+        Otherwise mono-dimensional axes will be squeezed.
+        Legal values: 0 (default), 1 or 2.
+
+        .. versionadded:: 1.6.0
+    encoding : str, optional
+        Encoding used to decode the inputfile. Does not apply to input streams.
+        The special value 'bytes' enables backward compatibility workarounds
+        that ensures you receive byte arrays as results if possible and passes
+        'latin1' encoded strings to converters. Override this value to receive
+        unicode arrays and pass strings as input to converters.  If set to None
+        the system default is used. The default value is 'bytes'.
+
+        .. versionadded:: 1.14.0
+        .. versionchanged:: 2.0
+            Before NumPy 2, the default was ``'bytes'`` for Python 2
+            compatibility. The default is now ``None``.
+
+    max_rows : int, optional
+        Read `max_rows` rows of content after `skiprows` lines. The default is
+        to read all the rows. Note that empty rows containing no data such as
+        empty lines and comment lines are not counted towards `max_rows`,
+        while such lines are counted in `skiprows`.
+
+        .. versionadded:: 1.16.0
+
+        .. versionchanged:: 1.23.0
+            Lines containing no data, including comment lines (e.g., lines
+            starting with '#' or as specified via `comments`) are not counted
+            towards `max_rows`.
+    quotechar : unicode character or None, optional
+        The character used to denote the start and end of a quoted item.
+        Occurrences of the delimiter or comment characters are ignored within
+        a quoted item. The default value is ``quotechar=None``, which means
+        quoting support is disabled.
+
+        If two consecutive instances of `quotechar` are found within a quoted
+        field, the first is treated as an escape character. See examples.
+
+        .. versionadded:: 1.23.0
+    ${ARRAY_FUNCTION_LIKE}
+
+        .. versionadded:: 1.20.0
+
+    Returns
+    -------
+    out : ndarray
+        Data read from the text file.
+
+    See Also
+    --------
+    load, fromstring, fromregex
+    genfromtxt : Load data with missing values handled as specified.
+    scipy.io.loadmat : reads MATLAB data files
+
+    Notes
+    -----
+    This function aims to be a fast reader for simply formatted files.  The
+    `genfromtxt` function provides more sophisticated handling of, e.g.,
+    lines with missing values.
+
+    Each row in the input text file must have the same number of values to be
+    able to read all values. If all rows do not have same number of values, a
+    subset of up to n columns (where n is the least number of values present
+    in all rows) can be read by specifying the columns via `usecols`.
+
+    .. versionadded:: 1.10.0
+
+    The strings produced by the Python float.hex method can be used as
+    input for floats.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from io import StringIO   # StringIO behaves like a file object
+    >>> c = StringIO("0 1\n2 3")
+    >>> np.loadtxt(c)
+    array([[0., 1.],
+           [2., 3.]])
+
+    >>> d = StringIO("M 21 72\nF 35 58")
+    >>> np.loadtxt(d, dtype={'names': ('gender', 'age', 'weight'),
+    ...                      'formats': ('S1', 'i4', 'f4')})
+    array([(b'M', 21, 72.), (b'F', 35, 58.)],
+          dtype=[('gender', 'S1'), ('age', '>> c = StringIO("1,0,2\n3,0,4")
+    >>> x, y = np.loadtxt(c, delimiter=',', usecols=(0, 2), unpack=True)
+    >>> x
+    array([1., 3.])
+    >>> y
+    array([2., 4.])
+
+    The `converters` argument is used to specify functions to preprocess the
+    text prior to parsing. `converters` can be a dictionary that maps
+    preprocessing functions to each column:
+
+    >>> s = StringIO("1.618, 2.296\n3.141, 4.669\n")
+    >>> conv = {
+    ...     0: lambda x: np.floor(float(x)),  # conversion fn for column 0
+    ...     1: lambda x: np.ceil(float(x)),  # conversion fn for column 1
+    ... }
+    >>> np.loadtxt(s, delimiter=",", converters=conv)
+    array([[1., 3.],
+           [3., 5.]])
+
+    `converters` can be a callable instead of a dictionary, in which case it
+    is applied to all columns:
+
+    >>> s = StringIO("0xDE 0xAD\n0xC0 0xDE")
+    >>> import functools
+    >>> conv = functools.partial(int, base=16)
+    >>> np.loadtxt(s, converters=conv)
+    array([[222., 173.],
+           [192., 222.]])
+
+    This example shows how `converters` can be used to convert a field
+    with a trailing minus sign into a negative number.
+
+    >>> s = StringIO("10.01 31.25-\n19.22 64.31\n17.57- 63.94")
+    >>> def conv(fld):
+    ...     return -float(fld[:-1]) if fld.endswith("-") else float(fld)
+    ...
+    >>> np.loadtxt(s, converters=conv)
+    array([[ 10.01, -31.25],
+           [ 19.22,  64.31],
+           [-17.57,  63.94]])
+
+    Using a callable as the converter can be particularly useful for handling
+    values with different formatting, e.g. floats with underscores:
+
+    >>> s = StringIO("1 2.7 100_000")
+    >>> np.loadtxt(s, converters=float)
+    array([1.e+00, 2.7e+00, 1.e+05])
+
+    This idea can be extended to automatically handle values specified in
+    many different formats, such as hex values:
+
+    >>> def conv(val):
+    ...     try:
+    ...         return float(val)
+    ...     except ValueError:
+    ...         return float.fromhex(val)
+    >>> s = StringIO("1, 2.5, 3_000, 0b4, 0x1.4000000000000p+2")
+    >>> np.loadtxt(s, delimiter=",", converters=conv)
+    array([1.0e+00, 2.5e+00, 3.0e+03, 1.8e+02, 5.0e+00])
+
+    Or a format where the ``-`` sign comes after the number:
+
+    >>> s = StringIO("10.01 31.25-\n19.22 64.31\n17.57- 63.94")
+    >>> conv = lambda x: -float(x[:-1]) if x.endswith("-") else float(x)
+    >>> np.loadtxt(s, converters=conv)
+    array([[ 10.01, -31.25],
+           [ 19.22,  64.31],
+           [-17.57,  63.94]])
+
+    Support for quoted fields is enabled with the `quotechar` parameter.
+    Comment and delimiter characters are ignored when they appear within a
+    quoted item delineated by `quotechar`:
+
+    >>> s = StringIO('"alpha, #42", 10.0\n"beta, #64", 2.0\n')
+    >>> dtype = np.dtype([("label", "U12"), ("value", float)])
+    >>> np.loadtxt(s, dtype=dtype, delimiter=",", quotechar='"')
+    array([('alpha, #42', 10.), ('beta, #64',  2.)],
+          dtype=[('label', '>> s = StringIO('"alpha, #42"       10.0\n"beta, #64" 2.0\n')
+    >>> dtype = np.dtype([("label", "U12"), ("value", float)])
+    >>> np.loadtxt(s, dtype=dtype, delimiter=None, quotechar='"')
+    array([('alpha, #42', 10.), ('beta, #64',  2.)],
+          dtype=[('label', '>> s = StringIO('"Hello, my name is ""Monty""!"')
+    >>> np.loadtxt(s, dtype="U", delimiter=",", quotechar='"')
+    array('Hello, my name is "Monty"!', dtype='>> d = StringIO("1 2\n2 4\n3 9 12\n4 16 20")
+    >>> np.loadtxt(d, usecols=(0, 1))
+    array([[ 1.,  2.],
+           [ 2.,  4.],
+           [ 3.,  9.],
+           [ 4., 16.]])
+
+    """
+
+    if like is not None:
+        return _loadtxt_with_like(
+            like, fname, dtype=dtype, comments=comments, delimiter=delimiter,
+            converters=converters, skiprows=skiprows, usecols=usecols,
+            unpack=unpack, ndmin=ndmin, encoding=encoding,
+            max_rows=max_rows
+        )
+
+    if isinstance(delimiter, bytes):
+        delimiter.decode("latin1")
+
+    if dtype is None:
+        dtype = np.float64
+
+    comment = comments
+    # Control character type conversions for Py3 convenience
+    if comment is not None:
+        if isinstance(comment, (str, bytes)):
+            comment = [comment]
+        comment = [
+            x.decode('latin1') if isinstance(x, bytes) else x for x in comment]
+    if isinstance(delimiter, bytes):
+        delimiter = delimiter.decode('latin1')
+
+    arr = _read(fname, dtype=dtype, comment=comment, delimiter=delimiter,
+                converters=converters, skiplines=skiprows, usecols=usecols,
+                unpack=unpack, ndmin=ndmin, encoding=encoding,
+                max_rows=max_rows, quote=quotechar)
+
+    return arr
+
+
+_loadtxt_with_like = array_function_dispatch()(loadtxt)
+
+
+def _savetxt_dispatcher(fname, X, fmt=None, delimiter=None, newline=None,
+                        header=None, footer=None, comments=None,
+                        encoding=None):
+    return (X,)
+
+
+@array_function_dispatch(_savetxt_dispatcher)
+def savetxt(fname, X, fmt='%.18e', delimiter=' ', newline='\n', header='',
+            footer='', comments='# ', encoding=None):
+    """
+    Save an array to a text file.
+
+    Parameters
+    ----------
+    fname : filename, file handle or pathlib.Path
+        If the filename ends in ``.gz``, the file is automatically saved in
+        compressed gzip format.  `loadtxt` understands gzipped files
+        transparently.
+    X : 1D or 2D array_like
+        Data to be saved to a text file.
+    fmt : str or sequence of strs, optional
+        A single format (%10.5f), a sequence of formats, or a
+        multi-format string, e.g. 'Iteration %d -- %10.5f', in which
+        case `delimiter` is ignored. For complex `X`, the legal options
+        for `fmt` are:
+
+        * a single specifier, ``fmt='%.4e'``, resulting in numbers formatted
+          like ``' (%s+%sj)' % (fmt, fmt)``
+        * a full string specifying every real and imaginary part, e.g.
+          ``' %.4e %+.4ej %.4e %+.4ej %.4e %+.4ej'`` for 3 columns
+        * a list of specifiers, one per column - in this case, the real
+          and imaginary part must have separate specifiers,
+          e.g. ``['%.3e + %.3ej', '(%.15e%+.15ej)']`` for 2 columns
+    delimiter : str, optional
+        String or character separating columns.
+    newline : str, optional
+        String or character separating lines.
+
+        .. versionadded:: 1.5.0
+    header : str, optional
+        String that will be written at the beginning of the file.
+
+        .. versionadded:: 1.7.0
+    footer : str, optional
+        String that will be written at the end of the file.
+
+        .. versionadded:: 1.7.0
+    comments : str, optional
+        String that will be prepended to the ``header`` and ``footer`` strings,
+        to mark them as comments. Default: '# ',  as expected by e.g.
+        ``numpy.loadtxt``.
+
+        .. versionadded:: 1.7.0
+    encoding : {None, str}, optional
+        Encoding used to encode the outputfile. Does not apply to output
+        streams. If the encoding is something other than 'bytes' or 'latin1'
+        you will not be able to load the file in NumPy versions < 1.14. Default
+        is 'latin1'.
+
+        .. versionadded:: 1.14.0
+
+
+    See Also
+    --------
+    save : Save an array to a binary file in NumPy ``.npy`` format
+    savez : Save several arrays into an uncompressed ``.npz`` archive
+    savez_compressed : Save several arrays into a compressed ``.npz`` archive
+
+    Notes
+    -----
+    Further explanation of the `fmt` parameter
+    (``%[flag]width[.precision]specifier``):
+
+    flags:
+        ``-`` : left justify
+
+        ``+`` : Forces to precede result with + or -.
+
+        ``0`` : Left pad the number with zeros instead of space (see width).
+
+    width:
+        Minimum number of characters to be printed. The value is not truncated
+        if it has more characters.
+
+    precision:
+        - For integer specifiers (eg. ``d,i,o,x``), the minimum number of
+          digits.
+        - For ``e, E`` and ``f`` specifiers, the number of digits to print
+          after the decimal point.
+        - For ``g`` and ``G``, the maximum number of significant digits.
+        - For ``s``, the maximum number of characters.
+
+    specifiers:
+        ``c`` : character
+
+        ``d`` or ``i`` : signed decimal integer
+
+        ``e`` or ``E`` : scientific notation with ``e`` or ``E``.
+
+        ``f`` : decimal floating point
+
+        ``g,G`` : use the shorter of ``e,E`` or ``f``
+
+        ``o`` : signed octal
+
+        ``s`` : string of characters
+
+        ``u`` : unsigned decimal integer
+
+        ``x,X`` : unsigned hexadecimal integer
+
+    This explanation of ``fmt`` is not complete, for an exhaustive
+    specification see [1]_.
+
+    References
+    ----------
+    .. [1] `Format Specification Mini-Language
+           `_,
+           Python Documentation.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> x = y = z = np.arange(0.0,5.0,1.0)
+    >>> np.savetxt('test.out', x, delimiter=',')   # X is an array
+    >>> np.savetxt('test.out', (x,y,z))   # x,y,z equal sized 1D arrays
+    >>> np.savetxt('test.out', x, fmt='%1.4e')   # use exponential notation
+
+    """
+
+    class WriteWrap:
+        """Convert to bytes on bytestream inputs.
+
+        """
+        def __init__(self, fh, encoding):
+            self.fh = fh
+            self.encoding = encoding
+            self.do_write = self.first_write
+
+        def close(self):
+            self.fh.close()
+
+        def write(self, v):
+            self.do_write(v)
+
+        def write_bytes(self, v):
+            if isinstance(v, bytes):
+                self.fh.write(v)
+            else:
+                self.fh.write(v.encode(self.encoding))
+
+        def write_normal(self, v):
+            self.fh.write(asunicode(v))
+
+        def first_write(self, v):
+            try:
+                self.write_normal(v)
+                self.write = self.write_normal
+            except TypeError:
+                # input is probably a bytestream
+                self.write_bytes(v)
+                self.write = self.write_bytes
+
+    own_fh = False
+    if isinstance(fname, os.PathLike):
+        fname = os.fspath(fname)
+    if _is_string_like(fname):
+        # datasource doesn't support creating a new file ...
+        open(fname, 'wt').close()
+        fh = np.lib._datasource.open(fname, 'wt', encoding=encoding)
+        own_fh = True
+    elif hasattr(fname, 'write'):
+        # wrap to handle byte output streams
+        fh = WriteWrap(fname, encoding or 'latin1')
+    else:
+        raise ValueError('fname must be a string or file handle')
+
+    try:
+        X = np.asarray(X)
+
+        # Handle 1-dimensional arrays
+        if X.ndim == 0 or X.ndim > 2:
+            raise ValueError(
+                "Expected 1D or 2D array, got %dD array instead" % X.ndim)
+        elif X.ndim == 1:
+            # Common case -- 1d array of numbers
+            if X.dtype.names is None:
+                X = np.atleast_2d(X).T
+                ncol = 1
+
+            # Complex dtype -- each field indicates a separate column
+            else:
+                ncol = len(X.dtype.names)
+        else:
+            ncol = X.shape[1]
+
+        iscomplex_X = np.iscomplexobj(X)
+        # `fmt` can be a string with multiple insertion points or a
+        # list of formats.  E.g. '%10.5f\t%10d' or ('%10.5f', '$10d')
+        if type(fmt) in (list, tuple):
+            if len(fmt) != ncol:
+                raise AttributeError('fmt has wrong shape.  %s' % str(fmt))
+            format = delimiter.join(fmt)
+        elif isinstance(fmt, str):
+            n_fmt_chars = fmt.count('%')
+            error = ValueError('fmt has wrong number of %% formats:  %s' % fmt)
+            if n_fmt_chars == 1:
+                if iscomplex_X:
+                    fmt = [' (%s+%sj)' % (fmt, fmt), ] * ncol
+                else:
+                    fmt = [fmt, ] * ncol
+                format = delimiter.join(fmt)
+            elif iscomplex_X and n_fmt_chars != (2 * ncol):
+                raise error
+            elif ((not iscomplex_X) and n_fmt_chars != ncol):
+                raise error
+            else:
+                format = fmt
+        else:
+            raise ValueError('invalid fmt: %r' % (fmt,))
+
+        if len(header) > 0:
+            header = header.replace('\n', '\n' + comments)
+            fh.write(comments + header + newline)
+        if iscomplex_X:
+            for row in X:
+                row2 = []
+                for number in row:
+                    row2.append(number.real)
+                    row2.append(number.imag)
+                s = format % tuple(row2) + newline
+                fh.write(s.replace('+-', '-'))
+        else:
+            for row in X:
+                try:
+                    v = format % tuple(row) + newline
+                except TypeError as e:
+                    raise TypeError("Mismatch between array dtype ('%s') and "
+                                    "format specifier ('%s')"
+                                    % (str(X.dtype), format)) from e
+                fh.write(v)
+
+        if len(footer) > 0:
+            footer = footer.replace('\n', '\n' + comments)
+            fh.write(comments + footer + newline)
+    finally:
+        if own_fh:
+            fh.close()
+
+
+@set_module('numpy')
+def fromregex(file, regexp, dtype, encoding=None):
+    r"""
+    Construct an array from a text file, using regular expression parsing.
+
+    The returned array is always a structured array, and is constructed from
+    all matches of the regular expression in the file. Groups in the regular
+    expression are converted to fields of the structured array.
+
+    Parameters
+    ----------
+    file : file, str, or pathlib.Path
+        Filename or file object to read.
+
+        .. versionchanged:: 1.22.0
+            Now accepts `os.PathLike` implementations.
+    regexp : str or regexp
+        Regular expression used to parse the file.
+        Groups in the regular expression correspond to fields in the dtype.
+    dtype : dtype or list of dtypes
+        Dtype for the structured array; must be a structured datatype.
+    encoding : str, optional
+        Encoding used to decode the inputfile. Does not apply to input streams.
+
+        .. versionadded:: 1.14.0
+
+    Returns
+    -------
+    output : ndarray
+        The output array, containing the part of the content of `file` that
+        was matched by `regexp`. `output` is always a structured array.
+
+    Raises
+    ------
+    TypeError
+        When `dtype` is not a valid dtype for a structured array.
+
+    See Also
+    --------
+    fromstring, loadtxt
+
+    Notes
+    -----
+    Dtypes for structured arrays can be specified in several forms, but all
+    forms specify at least the data type and field name. For details see
+    `basics.rec`.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from io import StringIO
+    >>> text = StringIO("1312 foo\n1534  bar\n444   qux")
+
+    >>> regexp = r"(\d+)\s+(...)"  # match [digits, whitespace, anything]
+    >>> output = np.fromregex(text, regexp,
+    ...                       [('num', np.int64), ('key', 'S3')])
+    >>> output
+    array([(1312, b'foo'), (1534, b'bar'), ( 444, b'qux')],
+          dtype=[('num', '>> output['num']
+    array([1312, 1534,  444])
+
+    """
+    own_fh = False
+    if not hasattr(file, "read"):
+        file = os.fspath(file)
+        file = np.lib._datasource.open(file, 'rt', encoding=encoding)
+        own_fh = True
+
+    try:
+        if not isinstance(dtype, np.dtype):
+            dtype = np.dtype(dtype)
+        if dtype.names is None:
+            raise TypeError('dtype must be a structured datatype.')
+
+        content = file.read()
+        if isinstance(content, bytes) and isinstance(regexp, str):
+            regexp = asbytes(regexp)
+
+        if not hasattr(regexp, 'match'):
+            regexp = re.compile(regexp)
+        seq = regexp.findall(content)
+        if seq and not isinstance(seq[0], tuple):
+            # Only one group is in the regexp.
+            # Create the new array as a single data-type and then
+            #   re-interpret as a single-field structured array.
+            newdtype = np.dtype(dtype[dtype.names[0]])
+            output = np.array(seq, dtype=newdtype)
+            output.dtype = dtype
+        else:
+            output = np.array(seq, dtype=dtype)
+
+        return output
+    finally:
+        if own_fh:
+            file.close()
+
+
+#####--------------------------------------------------------------------------
+#---- --- ASCII functions ---
+#####--------------------------------------------------------------------------
+
+
+@set_array_function_like_doc
+@set_module('numpy')
+def genfromtxt(fname, dtype=float, comments='#', delimiter=None,
+               skip_header=0, skip_footer=0, converters=None,
+               missing_values=None, filling_values=None, usecols=None,
+               names=None, excludelist=None,
+               deletechars=''.join(sorted(NameValidator.defaultdeletechars)),
+               replace_space='_', autostrip=False, case_sensitive=True,
+               defaultfmt="f%i", unpack=None, usemask=False, loose=True,
+               invalid_raise=True, max_rows=None, encoding=None,
+               *, ndmin=0, like=None):
+    """
+    Load data from a text file, with missing values handled as specified.
+
+    Each line past the first `skip_header` lines is split at the `delimiter`
+    character, and characters following the `comments` character are discarded.
+
+    Parameters
+    ----------
+    fname : file, str, pathlib.Path, list of str, generator
+        File, filename, list, or generator to read.  If the filename
+        extension is ``.gz`` or ``.bz2``, the file is first decompressed. Note
+        that generators must return bytes or strings. The strings
+        in a list or produced by a generator are treated as lines.
+    dtype : dtype, optional
+        Data type of the resulting array.
+        If None, the dtypes will be determined by the contents of each
+        column, individually.
+    comments : str, optional
+        The character used to indicate the start of a comment.
+        All the characters occurring on a line after a comment are discarded.
+    delimiter : str, int, or sequence, optional
+        The string used to separate values.  By default, any consecutive
+        whitespaces act as delimiter.  An integer or sequence of integers
+        can also be provided as width(s) of each field.
+    skiprows : int, optional
+        `skiprows` was removed in numpy 1.10. Please use `skip_header` instead.
+    skip_header : int, optional
+        The number of lines to skip at the beginning of the file.
+    skip_footer : int, optional
+        The number of lines to skip at the end of the file.
+    converters : variable, optional
+        The set of functions that convert the data of a column to a value.
+        The converters can also be used to provide a default value
+        for missing data: ``converters = {3: lambda s: float(s or 0)}``.
+    missing : variable, optional
+        `missing` was removed in numpy 1.10. Please use `missing_values`
+        instead.
+    missing_values : variable, optional
+        The set of strings corresponding to missing data.
+    filling_values : variable, optional
+        The set of values to be used as default when the data are missing.
+    usecols : sequence, optional
+        Which columns to read, with 0 being the first.  For example,
+        ``usecols = (1, 4, 5)`` will extract the 2nd, 5th and 6th columns.
+    names : {None, True, str, sequence}, optional
+        If `names` is True, the field names are read from the first line after
+        the first `skip_header` lines. This line can optionally be preceded
+        by a comment delimiter. Any content before the comment delimiter is
+        discarded. If `names` is a sequence or a single-string of
+        comma-separated names, the names will be used to define the field
+        names in a structured dtype. If `names` is None, the names of the
+        dtype fields will be used, if any.
+    excludelist : sequence, optional
+        A list of names to exclude. This list is appended to the default list
+        ['return','file','print']. Excluded names are appended with an
+        underscore: for example, `file` would become `file_`.
+    deletechars : str, optional
+        A string combining invalid characters that must be deleted from the
+        names.
+    defaultfmt : str, optional
+        A format used to define default field names, such as "f%i" or "f_%02i".
+    autostrip : bool, optional
+        Whether to automatically strip white spaces from the variables.
+    replace_space : char, optional
+        Character(s) used in replacement of white spaces in the variable
+        names. By default, use a '_'.
+    case_sensitive : {True, False, 'upper', 'lower'}, optional
+        If True, field names are case sensitive.
+        If False or 'upper', field names are converted to upper case.
+        If 'lower', field names are converted to lower case.
+    unpack : bool, optional
+        If True, the returned array is transposed, so that arguments may be
+        unpacked using ``x, y, z = genfromtxt(...)``.  When used with a
+        structured data-type, arrays are returned for each field.
+        Default is False.
+    usemask : bool, optional
+        If True, return a masked array.
+        If False, return a regular array.
+    loose : bool, optional
+        If True, do not raise errors for invalid values.
+    invalid_raise : bool, optional
+        If True, an exception is raised if an inconsistency is detected in the
+        number of columns.
+        If False, a warning is emitted and the offending lines are skipped.
+    max_rows : int,  optional
+        The maximum number of rows to read. Must not be used with skip_footer
+        at the same time.  If given, the value must be at least 1. Default is
+        to read the entire file.
+
+        .. versionadded:: 1.10.0
+    encoding : str, optional
+        Encoding used to decode the inputfile. Does not apply when `fname`
+        is a file object. The special value 'bytes' enables backward
+        compatibility workarounds that ensure that you receive byte arrays
+        when possible and passes latin1 encoded strings to converters.
+        Override this value to receive unicode arrays and pass strings
+        as input to converters.  If set to None the system default is used.
+        The default value is 'bytes'.
+
+        .. versionadded:: 1.14.0
+        .. versionchanged:: 2.0
+            Before NumPy 2, the default was ``'bytes'`` for Python 2
+            compatibility. The default is now ``None``.
+
+    ndmin : int, optional
+        Same parameter as `loadtxt`
+
+        .. versionadded:: 1.23.0
+    ${ARRAY_FUNCTION_LIKE}
+
+        .. versionadded:: 1.20.0
+
+    Returns
+    -------
+    out : ndarray
+        Data read from the text file. If `usemask` is True, this is a
+        masked array.
+
+    See Also
+    --------
+    numpy.loadtxt : equivalent function when no data is missing.
+
+    Notes
+    -----
+    * When spaces are used as delimiters, or when no delimiter has been given
+      as input, there should not be any missing data between two fields.
+    * When variables are named (either by a flexible dtype or with a `names`
+      sequence), there must not be any header in the file (else a ValueError
+      exception is raised).
+    * Individual values are not stripped of spaces by default.
+      When using a custom converter, make sure the function does remove spaces.
+    * Custom converters may receive unexpected values due to dtype
+      discovery.
+
+    References
+    ----------
+    .. [1] NumPy User Guide, section `I/O with NumPy
+           `_.
+
+    Examples
+    --------
+    >>> from io import StringIO
+    >>> import numpy as np
+
+    Comma delimited file with mixed dtype
+
+    >>> s = StringIO("1,1.3,abcde")
+    >>> data = np.genfromtxt(s, dtype=[('myint','i8'),('myfloat','f8'),
+    ... ('mystring','S5')], delimiter=",")
+    >>> data
+    array((1, 1.3, b'abcde'),
+          dtype=[('myint', '>> _ = s.seek(0) # needed for StringIO example only
+    >>> data = np.genfromtxt(s, dtype=None,
+    ... names = ['myint','myfloat','mystring'], delimiter=",")
+    >>> data
+    array((1, 1.3, 'abcde'),
+          dtype=[('myint', '>> _ = s.seek(0)
+    >>> data = np.genfromtxt(s, dtype="i8,f8,S5",
+    ... names=['myint','myfloat','mystring'], delimiter=",")
+    >>> data
+    array((1, 1.3, b'abcde'),
+          dtype=[('myint', '>> s = StringIO("11.3abcde")
+    >>> data = np.genfromtxt(s, dtype=None, names=['intvar','fltvar','strvar'],
+    ...     delimiter=[1,3,5])
+    >>> data
+    array((1, 1.3, 'abcde'),
+          dtype=[('intvar', '>> f = StringIO('''
+    ... text,# of chars
+    ... hello world,11
+    ... numpy,5''')
+    >>> np.genfromtxt(f, dtype='S12,S12', delimiter=',')
+    array([(b'text', b''), (b'hello world', b'11'), (b'numpy', b'5')],
+      dtype=[('f0', 'S12'), ('f1', 'S12')])
+
+    """
+
+    if like is not None:
+        return _genfromtxt_with_like(
+            like, fname, dtype=dtype, comments=comments, delimiter=delimiter,
+            skip_header=skip_header, skip_footer=skip_footer,
+            converters=converters, missing_values=missing_values,
+            filling_values=filling_values, usecols=usecols, names=names,
+            excludelist=excludelist, deletechars=deletechars,
+            replace_space=replace_space, autostrip=autostrip,
+            case_sensitive=case_sensitive, defaultfmt=defaultfmt,
+            unpack=unpack, usemask=usemask, loose=loose,
+            invalid_raise=invalid_raise, max_rows=max_rows, encoding=encoding,
+            ndmin=ndmin,
+        )
+
+    _ensure_ndmin_ndarray_check_param(ndmin)
+
+    if max_rows is not None:
+        if skip_footer:
+            raise ValueError(
+                    "The keywords 'skip_footer' and 'max_rows' can not be "
+                    "specified at the same time.")
+        if max_rows < 1:
+            raise ValueError("'max_rows' must be at least 1.")
+
+    if usemask:
+        from numpy.ma import MaskedArray, make_mask_descr
+    # Check the input dictionary of converters
+    user_converters = converters or {}
+    if not isinstance(user_converters, dict):
+        raise TypeError(
+            "The input argument 'converter' should be a valid dictionary "
+            "(got '%s' instead)" % type(user_converters))
+
+    if encoding == 'bytes':
+        encoding = None
+        byte_converters = True
+    else:
+        byte_converters = False
+
+    # Initialize the filehandle, the LineSplitter and the NameValidator
+    if isinstance(fname, os.PathLike):
+        fname = os.fspath(fname)
+    if isinstance(fname, str):
+        fid = np.lib._datasource.open(fname, 'rt', encoding=encoding)
+        fid_ctx = contextlib.closing(fid)
+    else:
+        fid = fname
+        fid_ctx = contextlib.nullcontext(fid)
+    try:
+        fhd = iter(fid)
+    except TypeError as e:
+        raise TypeError(
+            "fname must be a string, a filehandle, a sequence of strings,\n"
+            f"or an iterator of strings. Got {type(fname)} instead."
+        ) from e
+    with fid_ctx:
+        split_line = LineSplitter(delimiter=delimiter, comments=comments,
+                                  autostrip=autostrip, encoding=encoding)
+        validate_names = NameValidator(excludelist=excludelist,
+                                       deletechars=deletechars,
+                                       case_sensitive=case_sensitive,
+                                       replace_space=replace_space)
+
+        # Skip the first `skip_header` rows
+        try:
+            for i in range(skip_header):
+                next(fhd)
+
+            # Keep on until we find the first valid values
+            first_values = None
+
+            while not first_values:
+                first_line = _decode_line(next(fhd), encoding)
+                if (names is True) and (comments is not None):
+                    if comments in first_line:
+                        first_line = (
+                            ''.join(first_line.split(comments)[1:]))
+                first_values = split_line(first_line)
+        except StopIteration:
+            # return an empty array if the datafile is empty
+            first_line = ''
+            first_values = []
+            warnings.warn(
+                'genfromtxt: Empty input file: "%s"' % fname, stacklevel=2
+            )
+
+        # Should we take the first values as names ?
+        if names is True:
+            fval = first_values[0].strip()
+            if comments is not None:
+                if fval in comments:
+                    del first_values[0]
+
+        # Check the columns to use: make sure `usecols` is a list
+        if usecols is not None:
+            try:
+                usecols = [_.strip() for _ in usecols.split(",")]
+            except AttributeError:
+                try:
+                    usecols = list(usecols)
+                except TypeError:
+                    usecols = [usecols, ]
+        nbcols = len(usecols or first_values)
+
+        # Check the names and overwrite the dtype.names if needed
+        if names is True:
+            names = validate_names([str(_.strip()) for _ in first_values])
+            first_line = ''
+        elif _is_string_like(names):
+            names = validate_names([_.strip() for _ in names.split(',')])
+        elif names:
+            names = validate_names(names)
+        # Get the dtype
+        if dtype is not None:
+            dtype = easy_dtype(dtype, defaultfmt=defaultfmt, names=names,
+                               excludelist=excludelist,
+                               deletechars=deletechars,
+                               case_sensitive=case_sensitive,
+                               replace_space=replace_space)
+        # Make sure the names is a list (for 2.5)
+        if names is not None:
+            names = list(names)
+
+        if usecols:
+            for (i, current) in enumerate(usecols):
+                # if usecols is a list of names, convert to a list of indices
+                if _is_string_like(current):
+                    usecols[i] = names.index(current)
+                elif current < 0:
+                    usecols[i] = current + len(first_values)
+            # If the dtype is not None, make sure we update it
+            if (dtype is not None) and (len(dtype) > nbcols):
+                descr = dtype.descr
+                dtype = np.dtype([descr[_] for _ in usecols])
+                names = list(dtype.names)
+            # If `names` is not None, update the names
+            elif (names is not None) and (len(names) > nbcols):
+                names = [names[_] for _ in usecols]
+        elif (names is not None) and (dtype is not None):
+            names = list(dtype.names)
+
+        # Process the missing values ...............................
+        # Rename missing_values for convenience
+        user_missing_values = missing_values or ()
+        if isinstance(user_missing_values, bytes):
+            user_missing_values = user_missing_values.decode('latin1')
+
+        # Define the list of missing_values (one column: one list)
+        missing_values = [list(['']) for _ in range(nbcols)]
+
+        # We have a dictionary: process it field by field
+        if isinstance(user_missing_values, dict):
+            # Loop on the items
+            for (key, val) in user_missing_values.items():
+                # Is the key a string ?
+                if _is_string_like(key):
+                    try:
+                        # Transform it into an integer
+                        key = names.index(key)
+                    except ValueError:
+                        # We couldn't find it: the name must have been dropped
+                        continue
+                # Redefine the key as needed if it's a column number
+                if usecols:
+                    try:
+                        key = usecols.index(key)
+                    except ValueError:
+                        pass
+                # Transform the value as a list of string
+                if isinstance(val, (list, tuple)):
+                    val = [str(_) for _ in val]
+                else:
+                    val = [str(val), ]
+                # Add the value(s) to the current list of missing
+                if key is None:
+                    # None acts as default
+                    for miss in missing_values:
+                        miss.extend(val)
+                else:
+                    missing_values[key].extend(val)
+        # We have a sequence : each item matches a column
+        elif isinstance(user_missing_values, (list, tuple)):
+            for (value, entry) in zip(user_missing_values, missing_values):
+                value = str(value)
+                if value not in entry:
+                    entry.append(value)
+        # We have a string : apply it to all entries
+        elif isinstance(user_missing_values, str):
+            user_value = user_missing_values.split(",")
+            for entry in missing_values:
+                entry.extend(user_value)
+        # We have something else: apply it to all entries
+        else:
+            for entry in missing_values:
+                entry.extend([str(user_missing_values)])
+
+        # Process the filling_values ...............................
+        # Rename the input for convenience
+        user_filling_values = filling_values
+        if user_filling_values is None:
+            user_filling_values = []
+        # Define the default
+        filling_values = [None] * nbcols
+        # We have a dictionary : update each entry individually
+        if isinstance(user_filling_values, dict):
+            for (key, val) in user_filling_values.items():
+                if _is_string_like(key):
+                    try:
+                        # Transform it into an integer
+                        key = names.index(key)
+                    except ValueError:
+                        # We couldn't find it: the name must have been dropped
+                        continue
+                # Redefine the key if it's a column number
+                # and usecols is defined
+                if usecols:
+                    try:
+                        key = usecols.index(key)
+                    except ValueError:
+                        pass
+                # Add the value to the list
+                filling_values[key] = val
+        # We have a sequence : update on a one-to-one basis
+        elif isinstance(user_filling_values, (list, tuple)):
+            n = len(user_filling_values)
+            if (n <= nbcols):
+                filling_values[:n] = user_filling_values
+            else:
+                filling_values = user_filling_values[:nbcols]
+        # We have something else : use it for all entries
+        else:
+            filling_values = [user_filling_values] * nbcols
+
+        # Initialize the converters ................................
+        if dtype is None:
+            # Note: we can't use a [...]*nbcols, as we would have 3 times
+            # the same converter, instead of 3 different converters.
+            converters = [
+                StringConverter(None, missing_values=miss, default=fill)
+                for (miss, fill) in zip(missing_values, filling_values)
+            ]
+        else:
+            dtype_flat = flatten_dtype(dtype, flatten_base=True)
+            # Initialize the converters
+            if len(dtype_flat) > 1:
+                # Flexible type : get a converter from each dtype
+                zipit = zip(dtype_flat, missing_values, filling_values)
+                converters = [StringConverter(dt,
+                                              locked=True,
+                                              missing_values=miss,
+                                              default=fill)
+                              for (dt, miss, fill) in zipit]
+            else:
+                # Set to a default converter (but w/ different missing values)
+                zipit = zip(missing_values, filling_values)
+                converters = [StringConverter(dtype,
+                                              locked=True,
+                                              missing_values=miss,
+                                              default=fill)
+                              for (miss, fill) in zipit]
+        # Update the converters to use the user-defined ones
+        uc_update = []
+        for (j, conv) in user_converters.items():
+            # If the converter is specified by column names,
+            # use the index instead
+            if _is_string_like(j):
+                try:
+                    j = names.index(j)
+                    i = j
+                except ValueError:
+                    continue
+            elif usecols:
+                try:
+                    i = usecols.index(j)
+                except ValueError:
+                    # Unused converter specified
+                    continue
+            else:
+                i = j
+            # Find the value to test - first_line is not filtered by usecols:
+            if len(first_line):
+                testing_value = first_values[j]
+            else:
+                testing_value = None
+            if conv is bytes:
+                user_conv = asbytes
+            elif byte_converters:
+                # Converters may use decode to workaround numpy's old
+                # behavior, so encode the string again before passing
+                # to the user converter.
+                def tobytes_first(x, conv):
+                    if type(x) is bytes:
+                        return conv(x)
+                    return conv(x.encode("latin1"))
+                user_conv = functools.partial(tobytes_first, conv=conv)
+            else:
+                user_conv = conv
+            converters[i].update(user_conv, locked=True,
+                                 testing_value=testing_value,
+                                 default=filling_values[i],
+                                 missing_values=missing_values[i],)
+            uc_update.append((i, user_conv))
+        # Make sure we have the corrected keys in user_converters...
+        user_converters.update(uc_update)
+
+        # Fixme: possible error as following variable never used.
+        # miss_chars = [_.missing_values for _ in converters]
+
+        # Initialize the output lists ...
+        # ... rows
+        rows = []
+        append_to_rows = rows.append
+        # ... masks
+        if usemask:
+            masks = []
+            append_to_masks = masks.append
+        # ... invalid
+        invalid = []
+        append_to_invalid = invalid.append
+
+        # Parse each line
+        for (i, line) in enumerate(itertools.chain([first_line, ], fhd)):
+            values = split_line(line)
+            nbvalues = len(values)
+            # Skip an empty line
+            if nbvalues == 0:
+                continue
+            if usecols:
+                # Select only the columns we need
+                try:
+                    values = [values[_] for _ in usecols]
+                except IndexError:
+                    append_to_invalid((i + skip_header + 1, nbvalues))
+                    continue
+            elif nbvalues != nbcols:
+                append_to_invalid((i + skip_header + 1, nbvalues))
+                continue
+            # Store the values
+            append_to_rows(tuple(values))
+            if usemask:
+                append_to_masks(tuple([v.strip() in m
+                                       for (v, m) in zip(values,
+                                                         missing_values)]))
+            if len(rows) == max_rows:
+                break
+
+    # Upgrade the converters (if needed)
+    if dtype is None:
+        for (i, converter) in enumerate(converters):
+            current_column = [itemgetter(i)(_m) for _m in rows]
+            try:
+                converter.iterupgrade(current_column)
+            except ConverterLockError:
+                errmsg = "Converter #%i is locked and cannot be upgraded: " % i
+                current_column = map(itemgetter(i), rows)
+                for (j, value) in enumerate(current_column):
+                    try:
+                        converter.upgrade(value)
+                    except (ConverterError, ValueError):
+                        errmsg += "(occurred line #%i for value '%s')"
+                        errmsg %= (j + 1 + skip_header, value)
+                        raise ConverterError(errmsg)
+
+    # Check that we don't have invalid values
+    nbinvalid = len(invalid)
+    if nbinvalid > 0:
+        nbrows = len(rows) + nbinvalid - skip_footer
+        # Construct the error message
+        template = "    Line #%%i (got %%i columns instead of %i)" % nbcols
+        if skip_footer > 0:
+            nbinvalid_skipped = len([_ for _ in invalid
+                                     if _[0] > nbrows + skip_header])
+            invalid = invalid[:nbinvalid - nbinvalid_skipped]
+            skip_footer -= nbinvalid_skipped
+#
+#            nbrows -= skip_footer
+#            errmsg = [template % (i, nb)
+#                      for (i, nb) in invalid if i < nbrows]
+#        else:
+        errmsg = [template % (i, nb)
+                  for (i, nb) in invalid]
+        if len(errmsg):
+            errmsg.insert(0, "Some errors were detected !")
+            errmsg = "\n".join(errmsg)
+            # Raise an exception ?
+            if invalid_raise:
+                raise ValueError(errmsg)
+            # Issue a warning ?
+            else:
+                warnings.warn(errmsg, ConversionWarning, stacklevel=2)
+
+    # Strip the last skip_footer data
+    if skip_footer > 0:
+        rows = rows[:-skip_footer]
+        if usemask:
+            masks = masks[:-skip_footer]
+
+    # Convert each value according to the converter:
+    # We want to modify the list in place to avoid creating a new one...
+    if loose:
+        rows = list(
+            zip(*[[conv._loose_call(_r) for _r in map(itemgetter(i), rows)]
+                  for (i, conv) in enumerate(converters)]))
+    else:
+        rows = list(
+            zip(*[[conv._strict_call(_r) for _r in map(itemgetter(i), rows)]
+                  for (i, conv) in enumerate(converters)]))
+
+    # Reset the dtype
+    data = rows
+    if dtype is None:
+        # Get the dtypes from the types of the converters
+        column_types = [conv.type for conv in converters]
+        # Find the columns with strings...
+        strcolidx = [i for (i, v) in enumerate(column_types)
+                     if v == np.str_]
+
+        if byte_converters and strcolidx:
+            # convert strings back to bytes for backward compatibility
+            warnings.warn(
+                "Reading unicode strings without specifying the encoding "
+                "argument is deprecated. Set the encoding, use None for the "
+                "system default.",
+                np.exceptions.VisibleDeprecationWarning, stacklevel=2)
+
+            def encode_unicode_cols(row_tup):
+                row = list(row_tup)
+                for i in strcolidx:
+                    row[i] = row[i].encode('latin1')
+                return tuple(row)
+
+            try:
+                data = [encode_unicode_cols(r) for r in data]
+            except UnicodeEncodeError:
+                pass
+            else:
+                for i in strcolidx:
+                    column_types[i] = np.bytes_
+
+        # Update string types to be the right length
+        sized_column_types = column_types[:]
+        for i, col_type in enumerate(column_types):
+            if np.issubdtype(col_type, np.character):
+                n_chars = max(len(row[i]) for row in data)
+                sized_column_types[i] = (col_type, n_chars)
+
+        if names is None:
+            # If the dtype is uniform (before sizing strings)
+            base = {
+                c_type
+                for c, c_type in zip(converters, column_types)
+                if c._checked}
+            if len(base) == 1:
+                uniform_type, = base
+                (ddtype, mdtype) = (uniform_type, bool)
+            else:
+                ddtype = [(defaultfmt % i, dt)
+                          for (i, dt) in enumerate(sized_column_types)]
+                if usemask:
+                    mdtype = [(defaultfmt % i, bool)
+                              for (i, dt) in enumerate(sized_column_types)]
+        else:
+            ddtype = list(zip(names, sized_column_types))
+            mdtype = list(zip(names, [bool] * len(sized_column_types)))
+        output = np.array(data, dtype=ddtype)
+        if usemask:
+            outputmask = np.array(masks, dtype=mdtype)
+    else:
+        # Overwrite the initial dtype names if needed
+        if names and dtype.names is not None:
+            dtype.names = names
+        # Case 1. We have a structured type
+        if len(dtype_flat) > 1:
+            # Nested dtype, eg [('a', int), ('b', [('b0', int), ('b1', 'f4')])]
+            # First, create the array using a flattened dtype:
+            # [('a', int), ('b1', int), ('b2', float)]
+            # Then, view the array using the specified dtype.
+            if 'O' in (_.char for _ in dtype_flat):
+                if has_nested_fields(dtype):
+                    raise NotImplementedError(
+                        "Nested fields involving objects are not supported...")
+                else:
+                    output = np.array(data, dtype=dtype)
+            else:
+                rows = np.array(data, dtype=[('', _) for _ in dtype_flat])
+                output = rows.view(dtype)
+            # Now, process the rowmasks the same way
+            if usemask:
+                rowmasks = np.array(
+                    masks, dtype=np.dtype([('', bool) for t in dtype_flat]))
+                # Construct the new dtype
+                mdtype = make_mask_descr(dtype)
+                outputmask = rowmasks.view(mdtype)
+        # Case #2. We have a basic dtype
+        else:
+            # We used some user-defined converters
+            if user_converters:
+                ishomogeneous = True
+                descr = []
+                for i, ttype in enumerate([conv.type for conv in converters]):
+                    # Keep the dtype of the current converter
+                    if i in user_converters:
+                        ishomogeneous &= (ttype == dtype.type)
+                        if np.issubdtype(ttype, np.character):
+                            ttype = (ttype, max(len(row[i]) for row in data))
+                        descr.append(('', ttype))
+                    else:
+                        descr.append(('', dtype))
+                # So we changed the dtype ?
+                if not ishomogeneous:
+                    # We have more than one field
+                    if len(descr) > 1:
+                        dtype = np.dtype(descr)
+                    # We have only one field: drop the name if not needed.
+                    else:
+                        dtype = np.dtype(ttype)
+            #
+            output = np.array(data, dtype)
+            if usemask:
+                if dtype.names is not None:
+                    mdtype = [(_, bool) for _ in dtype.names]
+                else:
+                    mdtype = bool
+                outputmask = np.array(masks, dtype=mdtype)
+    # Try to take care of the missing data we missed
+    names = output.dtype.names
+    if usemask and names:
+        for (name, conv) in zip(names, converters):
+            missing_values = [conv(_) for _ in conv.missing_values
+                              if _ != '']
+            for mval in missing_values:
+                outputmask[name] |= (output[name] == mval)
+    # Construct the final array
+    if usemask:
+        output = output.view(MaskedArray)
+        output._mask = outputmask
+
+    output = _ensure_ndmin_ndarray(output, ndmin=ndmin)
+
+    if unpack:
+        if names is None:
+            return output.T
+        elif len(names) == 1:
+            # squeeze single-name dtypes too
+            return output[names[0]]
+        else:
+            # For structured arrays with multiple fields,
+            # return an array for each field.
+            return [output[field] for field in names]
+    return output
+
+
+_genfromtxt_with_like = array_function_dispatch()(genfromtxt)
+
+
+def recfromtxt(fname, **kwargs):
+    """
+    Load ASCII data from a file and return it in a record array.
+
+    If ``usemask=False`` a standard `recarray` is returned,
+    if ``usemask=True`` a MaskedRecords array is returned.
+
+    .. deprecated:: 2.0
+        Use `numpy.genfromtxt` instead.
+
+    Parameters
+    ----------
+    fname, kwargs : For a description of input parameters, see `genfromtxt`.
+
+    See Also
+    --------
+    numpy.genfromtxt : generic function
+
+    Notes
+    -----
+    By default, `dtype` is None, which means that the data-type of the output
+    array will be determined from the data.
+
+    """
+
+    # Deprecated in NumPy 2.0, 2023-07-11
+    warnings.warn(
+        "`recfromtxt` is deprecated, "
+        "use `numpy.genfromtxt` instead."
+        "(deprecated in NumPy 2.0)",
+        DeprecationWarning,
+        stacklevel=2
+    )
+
+    kwargs.setdefault("dtype", None)
+    usemask = kwargs.get('usemask', False)
+    output = genfromtxt(fname, **kwargs)
+    if usemask:
+        from numpy.ma.mrecords import MaskedRecords
+        output = output.view(MaskedRecords)
+    else:
+        output = output.view(np.recarray)
+    return output
+
+
+def recfromcsv(fname, **kwargs):
+    """
+    Load ASCII data stored in a comma-separated file.
+
+    The returned array is a record array (if ``usemask=False``, see
+    `recarray`) or a masked record array (if ``usemask=True``,
+    see `ma.mrecords.MaskedRecords`).
+
+    .. deprecated:: 2.0
+        Use `numpy.genfromtxt` with comma as `delimiter` instead.
+
+    Parameters
+    ----------
+    fname, kwargs : For a description of input parameters, see `genfromtxt`.
+
+    See Also
+    --------
+    numpy.genfromtxt : generic function to load ASCII data.
+
+    Notes
+    -----
+    By default, `dtype` is None, which means that the data-type of the output
+    array will be determined from the data.
+
+    """
+
+    # Deprecated in NumPy 2.0, 2023-07-11
+    warnings.warn(
+        "`recfromcsv` is deprecated, "
+        "use `numpy.genfromtxt` with comma as `delimiter` instead. "
+        "(deprecated in NumPy 2.0)",
+        DeprecationWarning,
+        stacklevel=2
+    )
+
+    # Set default kwargs for genfromtxt as relevant to csv import.
+    kwargs.setdefault("case_sensitive", "lower")
+    kwargs.setdefault("names", True)
+    kwargs.setdefault("delimiter", ",")
+    kwargs.setdefault("dtype", None)
+    output = genfromtxt(fname, **kwargs)
+
+    usemask = kwargs.get("usemask", False)
+    if usemask:
+        from numpy.ma.mrecords import MaskedRecords
+        output = output.view(MaskedRecords)
+    else:
+        output = output.view(np.recarray)
+    return output
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/_npyio_impl.pyi b/venv/lib/python3.12/site-packages/numpy/lib/_npyio_impl.pyi
new file mode 100644
index 00000000..f1dcbfd5
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/lib/_npyio_impl.pyi
@@ -0,0 +1,348 @@
+import os
+import sys
+import zipfile
+import types
+from re import Pattern
+from collections.abc import Collection, Mapping, Iterator, Sequence, Callable, Iterable
+from typing import (
+    Literal as L,
+    Any,
+    TypeVar,
+    Generic,
+    IO,
+    overload,
+    Protocol,
+)
+
+from numpy import (
+    ndarray,
+    recarray,
+    dtype,
+    generic,
+    float64,
+    void,
+    record,
+)
+
+from numpy.ma.mrecords import MaskedRecords
+from numpy._typing import (
+    ArrayLike,
+    DTypeLike,
+    NDArray,
+    _DTypeLike,
+    _SupportsArrayFunc,
+)
+
+from numpy._core.multiarray import (
+    packbits as packbits,
+    unpackbits as unpackbits,
+)
+
+_T = TypeVar("_T")
+_T_contra = TypeVar("_T_contra", contravariant=True)
+_T_co = TypeVar("_T_co", covariant=True)
+_SCT = TypeVar("_SCT", bound=generic)
+_CharType_co = TypeVar("_CharType_co", str, bytes, covariant=True)
+_CharType_contra = TypeVar("_CharType_contra", str, bytes, contravariant=True)
+
+class _SupportsGetItem(Protocol[_T_contra, _T_co]):
+    def __getitem__(self, key: _T_contra, /) -> _T_co: ...
+
+class _SupportsRead(Protocol[_CharType_co]):
+    def read(self) -> _CharType_co: ...
+
+class _SupportsReadSeek(Protocol[_CharType_co]):
+    def read(self, n: int, /) -> _CharType_co: ...
+    def seek(self, offset: int, whence: int, /) -> object: ...
+
+class _SupportsWrite(Protocol[_CharType_contra]):
+    def write(self, s: _CharType_contra, /) -> object: ...
+
+__all__: list[str]
+
+class BagObj(Generic[_T_co]):
+    def __init__(self, obj: _SupportsGetItem[str, _T_co]) -> None: ...
+    def __getattribute__(self, key: str) -> _T_co: ...
+    def __dir__(self) -> list[str]: ...
+
+class NpzFile(Mapping[str, NDArray[Any]]):
+    zip: zipfile.ZipFile
+    fid: None | IO[str]
+    files: list[str]
+    allow_pickle: bool
+    pickle_kwargs: None | Mapping[str, Any]
+    _MAX_REPR_ARRAY_COUNT: int
+    # Represent `f` as a mutable property so we can access the type of `self`
+    @property
+    def f(self: _T) -> BagObj[_T]: ...
+    @f.setter
+    def f(self: _T, value: BagObj[_T]) -> None: ...
+    def __init__(
+        self,
+        fid: IO[str],
+        own_fid: bool = ...,
+        allow_pickle: bool = ...,
+        pickle_kwargs: None | Mapping[str, Any] = ...,
+    ) -> None: ...
+    def __enter__(self: _T) -> _T: ...
+    def __exit__(
+        self,
+        exc_type: None | type[BaseException],
+        exc_value: None | BaseException,
+        traceback: None | types.TracebackType,
+        /,
+    ) -> None: ...
+    def close(self) -> None: ...
+    def __del__(self) -> None: ...
+    def __iter__(self) -> Iterator[str]: ...
+    def __len__(self) -> int: ...
+    def __getitem__(self, key: str) -> NDArray[Any]: ...
+    def __contains__(self, key: str) -> bool: ...
+    def __repr__(self) -> str: ...
+
+class DataSource:
+    def __init__(
+        self,
+        destpath: None | str | os.PathLike[str] = ...,
+    ) -> None: ...
+    def __del__(self) -> None: ...
+    def abspath(self, path: str) -> str: ...
+    def exists(self, path: str) -> bool: ...
+
+    # Whether the file-object is opened in string or bytes mode (by default)
+    # depends on the file-extension of `path`
+    def open(
+        self,
+        path: str,
+        mode: str = ...,
+        encoding: None | str = ...,
+        newline: None | str = ...,
+    ) -> IO[Any]: ...
+
+# NOTE: Returns a `NpzFile` if file is a zip file;
+# returns an `ndarray`/`memmap` otherwise
+def load(
+    file: str | bytes | os.PathLike[Any] | _SupportsReadSeek[bytes],
+    mmap_mode: L[None, "r+", "r", "w+", "c"] = ...,
+    allow_pickle: bool = ...,
+    fix_imports: bool = ...,
+    encoding: L["ASCII", "latin1", "bytes"] = ...,
+) -> Any: ...
+
+def save(
+    file: str | os.PathLike[str] | _SupportsWrite[bytes],
+    arr: ArrayLike,
+    allow_pickle: bool = ...,
+    fix_imports: bool = ...,
+) -> None: ...
+
+def savez(
+    file: str | os.PathLike[str] | _SupportsWrite[bytes],
+    *args: ArrayLike,
+    **kwds: ArrayLike,
+) -> None: ...
+
+def savez_compressed(
+    file: str | os.PathLike[str] | _SupportsWrite[bytes],
+    *args: ArrayLike,
+    **kwds: ArrayLike,
+) -> None: ...
+
+# File-like objects only have to implement `__iter__` and,
+# optionally, `encoding`
+@overload
+def loadtxt(
+    fname: str | os.PathLike[str] | Iterable[str] | Iterable[bytes],
+    dtype: None = ...,
+    comments: None | str | Sequence[str] = ...,
+    delimiter: None | str = ...,
+    converters: None | Mapping[int | str, Callable[[str], Any]] = ...,
+    skiprows: int = ...,
+    usecols: int | Sequence[int] | None = ...,
+    unpack: bool = ...,
+    ndmin: L[0, 1, 2] = ...,
+    encoding: None | str = ...,
+    max_rows: None | int = ...,
+    *,
+    quotechar: None | str = ...,
+    like: None | _SupportsArrayFunc = ...
+) -> NDArray[float64]: ...
+@overload
+def loadtxt(
+    fname: str | os.PathLike[str] | Iterable[str] | Iterable[bytes],
+    dtype: _DTypeLike[_SCT],
+    comments: None | str | Sequence[str] = ...,
+    delimiter: None | str = ...,
+    converters: None | Mapping[int | str, Callable[[str], Any]] = ...,
+    skiprows: int = ...,
+    usecols: int | Sequence[int] | None = ...,
+    unpack: bool = ...,
+    ndmin: L[0, 1, 2] = ...,
+    encoding: None | str = ...,
+    max_rows: None | int = ...,
+    *,
+    quotechar: None | str = ...,
+    like: None | _SupportsArrayFunc = ...
+) -> NDArray[_SCT]: ...
+@overload
+def loadtxt(
+    fname: str | os.PathLike[str] | Iterable[str] | Iterable[bytes],
+    dtype: DTypeLike,
+    comments: None | str | Sequence[str] = ...,
+    delimiter: None | str = ...,
+    converters: None | Mapping[int | str, Callable[[str], Any]] = ...,
+    skiprows: int = ...,
+    usecols: int | Sequence[int] | None = ...,
+    unpack: bool = ...,
+    ndmin: L[0, 1, 2] = ...,
+    encoding: None | str = ...,
+    max_rows: None | int = ...,
+    *,
+    quotechar: None | str = ...,
+    like: None | _SupportsArrayFunc = ...
+) -> NDArray[Any]: ...
+
+def savetxt(
+    fname: str | os.PathLike[str] | _SupportsWrite[str] | _SupportsWrite[bytes],
+    X: ArrayLike,
+    fmt: str | Sequence[str] = ...,
+    delimiter: str = ...,
+    newline: str = ...,
+    header: str = ...,
+    footer: str = ...,
+    comments: str = ...,
+    encoding: None | str = ...,
+) -> None: ...
+
+@overload
+def fromregex(
+    file: str | os.PathLike[str] | _SupportsRead[str] | _SupportsRead[bytes],
+    regexp: str | bytes | Pattern[Any],
+    dtype: _DTypeLike[_SCT],
+    encoding: None | str = ...
+) -> NDArray[_SCT]: ...
+@overload
+def fromregex(
+    file: str | os.PathLike[str] | _SupportsRead[str] | _SupportsRead[bytes],
+    regexp: str | bytes | Pattern[Any],
+    dtype: DTypeLike,
+    encoding: None | str = ...
+) -> NDArray[Any]: ...
+
+@overload
+def genfromtxt(
+    fname: str | os.PathLike[str] | Iterable[str] | Iterable[bytes],
+    dtype: None = ...,
+    comments: str = ...,
+    delimiter: None | str | int | Iterable[int] = ...,
+    skip_header: int = ...,
+    skip_footer: int = ...,
+    converters: None | Mapping[int | str, Callable[[str], Any]] = ...,
+    missing_values: Any = ...,
+    filling_values: Any = ...,
+    usecols: None | Sequence[int] = ...,
+    names: L[None, True] | str | Collection[str] = ...,
+    excludelist: None | Sequence[str] = ...,
+    deletechars: str = ...,
+    replace_space: str = ...,
+    autostrip: bool = ...,
+    case_sensitive: bool | L['upper', 'lower'] = ...,
+    defaultfmt: str = ...,
+    unpack: None | bool = ...,
+    usemask: bool = ...,
+    loose: bool = ...,
+    invalid_raise: bool = ...,
+    max_rows: None | int = ...,
+    encoding: str = ...,
+    *,
+    ndmin: L[0, 1, 2] = ...,
+    like: None | _SupportsArrayFunc = ...,
+) -> NDArray[Any]: ...
+@overload
+def genfromtxt(
+    fname: str | os.PathLike[str] | Iterable[str] | Iterable[bytes],
+    dtype: _DTypeLike[_SCT],
+    comments: str = ...,
+    delimiter: None | str | int | Iterable[int] = ...,
+    skip_header: int = ...,
+    skip_footer: int = ...,
+    converters: None | Mapping[int | str, Callable[[str], Any]] = ...,
+    missing_values: Any = ...,
+    filling_values: Any = ...,
+    usecols: None | Sequence[int] = ...,
+    names: L[None, True] | str | Collection[str] = ...,
+    excludelist: None | Sequence[str] = ...,
+    deletechars: str = ...,
+    replace_space: str = ...,
+    autostrip: bool = ...,
+    case_sensitive: bool | L['upper', 'lower'] = ...,
+    defaultfmt: str = ...,
+    unpack: None | bool = ...,
+    usemask: bool = ...,
+    loose: bool = ...,
+    invalid_raise: bool = ...,
+    max_rows: None | int = ...,
+    encoding: str = ...,
+    *,
+    ndmin: L[0, 1, 2] = ...,
+    like: None | _SupportsArrayFunc = ...,
+) -> NDArray[_SCT]: ...
+@overload
+def genfromtxt(
+    fname: str | os.PathLike[str] | Iterable[str] | Iterable[bytes],
+    dtype: DTypeLike,
+    comments: str = ...,
+    delimiter: None | str | int | Iterable[int] = ...,
+    skip_header: int = ...,
+    skip_footer: int = ...,
+    converters: None | Mapping[int | str, Callable[[str], Any]] = ...,
+    missing_values: Any = ...,
+    filling_values: Any = ...,
+    usecols: None | Sequence[int] = ...,
+    names: L[None, True] | str | Collection[str] = ...,
+    excludelist: None | Sequence[str] = ...,
+    deletechars: str = ...,
+    replace_space: str = ...,
+    autostrip: bool = ...,
+    case_sensitive: bool | L['upper', 'lower'] = ...,
+    defaultfmt: str = ...,
+    unpack: None | bool = ...,
+    usemask: bool = ...,
+    loose: bool = ...,
+    invalid_raise: bool = ...,
+    max_rows: None | int = ...,
+    encoding: str = ...,
+    *,
+    ndmin: L[0, 1, 2] = ...,
+    like: None | _SupportsArrayFunc = ...,
+) -> NDArray[Any]: ...
+
+@overload
+def recfromtxt(
+    fname: str | os.PathLike[str] | Iterable[str] | Iterable[bytes],
+    *,
+    usemask: L[False] = ...,
+    **kwargs: Any,
+) -> recarray[Any, dtype[record]]: ...
+@overload
+def recfromtxt(
+    fname: str | os.PathLike[str] | Iterable[str] | Iterable[bytes],
+    *,
+    usemask: L[True],
+    **kwargs: Any,
+) -> MaskedRecords[Any, dtype[void]]: ...
+
+@overload
+def recfromcsv(
+    fname: str | os.PathLike[str] | Iterable[str] | Iterable[bytes],
+    *,
+    usemask: L[False] = ...,
+    **kwargs: Any,
+) -> recarray[Any, dtype[record]]: ...
+@overload
+def recfromcsv(
+    fname: str | os.PathLike[str] | Iterable[str] | Iterable[bytes],
+    *,
+    usemask: L[True],
+    **kwargs: Any,
+) -> MaskedRecords[Any, dtype[void]]: ...
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/_polynomial_impl.py b/venv/lib/python3.12/site-packages/numpy/lib/_polynomial_impl.py
new file mode 100644
index 00000000..9bcf0a3d
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/lib/_polynomial_impl.py
@@ -0,0 +1,1458 @@
+"""
+Functions to operate on polynomials.
+
+"""
+__all__ = ['poly', 'roots', 'polyint', 'polyder', 'polyadd',
+           'polysub', 'polymul', 'polydiv', 'polyval', 'poly1d',
+           'polyfit']
+
+import functools
+import re
+import warnings
+
+from .._utils import set_module
+import numpy._core.numeric as NX
+
+from numpy._core import (isscalar, abs, finfo, atleast_1d, hstack, dot, array,
+                        ones)
+from numpy._core import overrides
+from numpy.exceptions import RankWarning
+from numpy.lib._twodim_base_impl import diag, vander
+from numpy.lib._function_base_impl import trim_zeros
+from numpy.lib._type_check_impl import iscomplex, real, imag, mintypecode
+from numpy.linalg import eigvals, lstsq, inv
+
+
+array_function_dispatch = functools.partial(
+    overrides.array_function_dispatch, module='numpy')
+
+
+def _poly_dispatcher(seq_of_zeros):
+    return seq_of_zeros
+
+
+@array_function_dispatch(_poly_dispatcher)
+def poly(seq_of_zeros):
+    """
+    Find the coefficients of a polynomial with the given sequence of roots.
+
+    .. note::
+       This forms part of the old polynomial API. Since version 1.4, the
+       new polynomial API defined in `numpy.polynomial` is preferred.
+       A summary of the differences can be found in the
+       :doc:`transition guide `.
+
+    Returns the coefficients of the polynomial whose leading coefficient
+    is one for the given sequence of zeros (multiple roots must be included
+    in the sequence as many times as their multiplicity; see Examples).
+    A square matrix (or array, which will be treated as a matrix) can also
+    be given, in which case the coefficients of the characteristic polynomial
+    of the matrix are returned.
+
+    Parameters
+    ----------
+    seq_of_zeros : array_like, shape (N,) or (N, N)
+        A sequence of polynomial roots, or a square array or matrix object.
+
+    Returns
+    -------
+    c : ndarray
+        1D array of polynomial coefficients from highest to lowest degree:
+
+        ``c[0] * x**(N) + c[1] * x**(N-1) + ... + c[N-1] * x + c[N]``
+        where c[0] always equals 1.
+
+    Raises
+    ------
+    ValueError
+        If input is the wrong shape (the input must be a 1-D or square
+        2-D array).
+
+    See Also
+    --------
+    polyval : Compute polynomial values.
+    roots : Return the roots of a polynomial.
+    polyfit : Least squares polynomial fit.
+    poly1d : A one-dimensional polynomial class.
+
+    Notes
+    -----
+    Specifying the roots of a polynomial still leaves one degree of
+    freedom, typically represented by an undetermined leading
+    coefficient. [1]_ In the case of this function, that coefficient -
+    the first one in the returned array - is always taken as one. (If
+    for some reason you have one other point, the only automatic way
+    presently to leverage that information is to use ``polyfit``.)
+
+    The characteristic polynomial, :math:`p_a(t)`, of an `n`-by-`n`
+    matrix **A** is given by
+
+    :math:`p_a(t) = \\mathrm{det}(t\\, \\mathbf{I} - \\mathbf{A})`,
+
+    where **I** is the `n`-by-`n` identity matrix. [2]_
+
+    References
+    ----------
+    .. [1] M. Sullivan and M. Sullivan, III, "Algebra and Trigonometry,
+       Enhanced With Graphing Utilities," Prentice-Hall, pg. 318, 1996.
+
+    .. [2] G. Strang, "Linear Algebra and Its Applications, 2nd Edition,"
+       Academic Press, pg. 182, 1980.
+
+    Examples
+    --------
+    Given a sequence of a polynomial's zeros:
+
+    >>> import numpy as np
+
+    >>> np.poly((0, 0, 0)) # Multiple root example
+    array([1., 0., 0., 0.])
+
+    The line above represents z**3 + 0*z**2 + 0*z + 0.
+
+    >>> np.poly((-1./2, 0, 1./2))
+    array([ 1.  ,  0.  , -0.25,  0.  ])
+
+    The line above represents z**3 - z/4
+
+    >>> np.poly((np.random.random(1)[0], 0, np.random.random(1)[0]))
+    array([ 1.        , -0.77086955,  0.08618131,  0.        ]) # random
+
+    Given a square array object:
+
+    >>> P = np.array([[0, 1./3], [-1./2, 0]])
+    >>> np.poly(P)
+    array([1.        , 0.        , 0.16666667])
+
+    Note how in all cases the leading coefficient is always 1.
+
+    """
+    seq_of_zeros = atleast_1d(seq_of_zeros)
+    sh = seq_of_zeros.shape
+
+    if len(sh) == 2 and sh[0] == sh[1] and sh[0] != 0:
+        seq_of_zeros = eigvals(seq_of_zeros)
+    elif len(sh) == 1:
+        dt = seq_of_zeros.dtype
+        # Let object arrays slip through, e.g. for arbitrary precision
+        if dt != object:
+            seq_of_zeros = seq_of_zeros.astype(mintypecode(dt.char))
+    else:
+        raise ValueError("input must be 1d or non-empty square 2d array.")
+
+    if len(seq_of_zeros) == 0:
+        return 1.0
+    dt = seq_of_zeros.dtype
+    a = ones((1,), dtype=dt)
+    for zero in seq_of_zeros:
+        a = NX.convolve(a, array([1, -zero], dtype=dt), mode='full')
+
+    if issubclass(a.dtype.type, NX.complexfloating):
+        # if complex roots are all complex conjugates, the roots are real.
+        roots = NX.asarray(seq_of_zeros, complex)
+        if NX.all(NX.sort(roots) == NX.sort(roots.conjugate())):
+            a = a.real.copy()
+
+    return a
+
+
+def _roots_dispatcher(p):
+    return p
+
+
+@array_function_dispatch(_roots_dispatcher)
+def roots(p):
+    """
+    Return the roots of a polynomial with coefficients given in p.
+
+    .. note::
+       This forms part of the old polynomial API. Since version 1.4, the
+       new polynomial API defined in `numpy.polynomial` is preferred.
+       A summary of the differences can be found in the
+       :doc:`transition guide `.
+
+    The values in the rank-1 array `p` are coefficients of a polynomial.
+    If the length of `p` is n+1 then the polynomial is described by::
+
+      p[0] * x**n + p[1] * x**(n-1) + ... + p[n-1]*x + p[n]
+
+    Parameters
+    ----------
+    p : array_like
+        Rank-1 array of polynomial coefficients.
+
+    Returns
+    -------
+    out : ndarray
+        An array containing the roots of the polynomial.
+
+    Raises
+    ------
+    ValueError
+        When `p` cannot be converted to a rank-1 array.
+
+    See also
+    --------
+    poly : Find the coefficients of a polynomial with a given sequence
+           of roots.
+    polyval : Compute polynomial values.
+    polyfit : Least squares polynomial fit.
+    poly1d : A one-dimensional polynomial class.
+
+    Notes
+    -----
+    The algorithm relies on computing the eigenvalues of the
+    companion matrix [1]_.
+
+    References
+    ----------
+    .. [1] R. A. Horn & C. R. Johnson, *Matrix Analysis*.  Cambridge, UK:
+        Cambridge University Press, 1999, pp. 146-7.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> coeff = [3.2, 2, 1]
+    >>> np.roots(coeff)
+    array([-0.3125+0.46351241j, -0.3125-0.46351241j])
+
+    """
+    # If input is scalar, this makes it an array
+    p = atleast_1d(p)
+    if p.ndim != 1:
+        raise ValueError("Input must be a rank-1 array.")
+
+    # find non-zero array entries
+    non_zero = NX.nonzero(NX.ravel(p))[0]
+
+    # Return an empty array if polynomial is all zeros
+    if len(non_zero) == 0:
+        return NX.array([])
+
+    # find the number of trailing zeros -- this is the number of roots at 0.
+    trailing_zeros = len(p) - non_zero[-1] - 1
+
+    # strip leading and trailing zeros
+    p = p[int(non_zero[0]):int(non_zero[-1])+1]
+
+    # casting: if incoming array isn't floating point, make it floating point.
+    if not issubclass(p.dtype.type, (NX.floating, NX.complexfloating)):
+        p = p.astype(float)
+
+    N = len(p)
+    if N > 1:
+        # build companion matrix and find its eigenvalues (the roots)
+        A = diag(NX.ones((N-2,), p.dtype), -1)
+        A[0,:] = -p[1:] / p[0]
+        roots = eigvals(A)
+    else:
+        roots = NX.array([])
+
+    # tack any zeros onto the back of the array
+    roots = hstack((roots, NX.zeros(trailing_zeros, roots.dtype)))
+    return roots
+
+
+def _polyint_dispatcher(p, m=None, k=None):
+    return (p,)
+
+
+@array_function_dispatch(_polyint_dispatcher)
+def polyint(p, m=1, k=None):
+    """
+    Return an antiderivative (indefinite integral) of a polynomial.
+
+    .. note::
+       This forms part of the old polynomial API. Since version 1.4, the
+       new polynomial API defined in `numpy.polynomial` is preferred.
+       A summary of the differences can be found in the
+       :doc:`transition guide `.
+
+    The returned order `m` antiderivative `P` of polynomial `p` satisfies
+    :math:`\\frac{d^m}{dx^m}P(x) = p(x)` and is defined up to `m - 1`
+    integration constants `k`. The constants determine the low-order
+    polynomial part
+
+    .. math:: \\frac{k_{m-1}}{0!} x^0 + \\ldots + \\frac{k_0}{(m-1)!}x^{m-1}
+
+    of `P` so that :math:`P^{(j)}(0) = k_{m-j-1}`.
+
+    Parameters
+    ----------
+    p : array_like or poly1d
+        Polynomial to integrate.
+        A sequence is interpreted as polynomial coefficients, see `poly1d`.
+    m : int, optional
+        Order of the antiderivative. (Default: 1)
+    k : list of `m` scalars or scalar, optional
+        Integration constants. They are given in the order of integration:
+        those corresponding to highest-order terms come first.
+
+        If ``None`` (default), all constants are assumed to be zero.
+        If `m = 1`, a single scalar can be given instead of a list.
+
+    See Also
+    --------
+    polyder : derivative of a polynomial
+    poly1d.integ : equivalent method
+
+    Examples
+    --------
+    The defining property of the antiderivative:
+
+    >>> import numpy as np
+
+    >>> p = np.poly1d([1,1,1])
+    >>> P = np.polyint(p)
+    >>> P
+     poly1d([ 0.33333333,  0.5       ,  1.        ,  0.        ]) # may vary
+    >>> np.polyder(P) == p
+    True
+
+    The integration constants default to zero, but can be specified:
+
+    >>> P = np.polyint(p, 3)
+    >>> P(0)
+    0.0
+    >>> np.polyder(P)(0)
+    0.0
+    >>> np.polyder(P, 2)(0)
+    0.0
+    >>> P = np.polyint(p, 3, k=[6,5,3])
+    >>> P
+    poly1d([ 0.01666667,  0.04166667,  0.16666667,  3. ,  5. ,  3. ]) # may vary
+
+    Note that 3 = 6 / 2!, and that the constants are given in the order of
+    integrations. Constant of the highest-order polynomial term comes first:
+
+    >>> np.polyder(P, 2)(0)
+    6.0
+    >>> np.polyder(P, 1)(0)
+    5.0
+    >>> P(0)
+    3.0
+
+    """
+    m = int(m)
+    if m < 0:
+        raise ValueError("Order of integral must be positive (see polyder)")
+    if k is None:
+        k = NX.zeros(m, float)
+    k = atleast_1d(k)
+    if len(k) == 1 and m > 1:
+        k = k[0]*NX.ones(m, float)
+    if len(k) < m:
+        raise ValueError(
+              "k must be a scalar or a rank-1 array of length 1 or >m.")
+
+    truepoly = isinstance(p, poly1d)
+    p = NX.asarray(p)
+    if m == 0:
+        if truepoly:
+            return poly1d(p)
+        return p
+    else:
+        # Note: this must work also with object and integer arrays
+        y = NX.concatenate((p.__truediv__(NX.arange(len(p), 0, -1)), [k[0]]))
+        val = polyint(y, m - 1, k=k[1:])
+        if truepoly:
+            return poly1d(val)
+        return val
+
+
+def _polyder_dispatcher(p, m=None):
+    return (p,)
+
+
+@array_function_dispatch(_polyder_dispatcher)
+def polyder(p, m=1):
+    """
+    Return the derivative of the specified order of a polynomial.
+
+    .. note::
+       This forms part of the old polynomial API. Since version 1.4, the
+       new polynomial API defined in `numpy.polynomial` is preferred.
+       A summary of the differences can be found in the
+       :doc:`transition guide `.
+
+    Parameters
+    ----------
+    p : poly1d or sequence
+        Polynomial to differentiate.
+        A sequence is interpreted as polynomial coefficients, see `poly1d`.
+    m : int, optional
+        Order of differentiation (default: 1)
+
+    Returns
+    -------
+    der : poly1d
+        A new polynomial representing the derivative.
+
+    See Also
+    --------
+    polyint : Anti-derivative of a polynomial.
+    poly1d : Class for one-dimensional polynomials.
+
+    Examples
+    --------
+    The derivative of the polynomial :math:`x^3 + x^2 + x^1 + 1` is:
+
+    >>> import numpy as np
+
+    >>> p = np.poly1d([1,1,1,1])
+    >>> p2 = np.polyder(p)
+    >>> p2
+    poly1d([3, 2, 1])
+
+    which evaluates to:
+
+    >>> p2(2.)
+    17.0
+
+    We can verify this, approximating the derivative with
+    ``(f(x + h) - f(x))/h``:
+
+    >>> (p(2. + 0.001) - p(2.)) / 0.001
+    17.007000999997857
+
+    The fourth-order derivative of a 3rd-order polynomial is zero:
+
+    >>> np.polyder(p, 2)
+    poly1d([6, 2])
+    >>> np.polyder(p, 3)
+    poly1d([6])
+    >>> np.polyder(p, 4)
+    poly1d([0])
+
+    """
+    m = int(m)
+    if m < 0:
+        raise ValueError("Order of derivative must be positive (see polyint)")
+
+    truepoly = isinstance(p, poly1d)
+    p = NX.asarray(p)
+    n = len(p) - 1
+    y = p[:-1] * NX.arange(n, 0, -1)
+    if m == 0:
+        val = p
+    else:
+        val = polyder(y, m - 1)
+    if truepoly:
+        val = poly1d(val)
+    return val
+
+
+def _polyfit_dispatcher(x, y, deg, rcond=None, full=None, w=None, cov=None):
+    return (x, y, w)
+
+
+@array_function_dispatch(_polyfit_dispatcher)
+def polyfit(x, y, deg, rcond=None, full=False, w=None, cov=False):
+    """
+    Least squares polynomial fit.
+
+    .. note::
+       This forms part of the old polynomial API. Since version 1.4, the
+       new polynomial API defined in `numpy.polynomial` is preferred.
+       A summary of the differences can be found in the
+       :doc:`transition guide `.
+
+    Fit a polynomial ``p(x) = p[0] * x**deg + ... + p[deg]`` of degree `deg`
+    to points `(x, y)`. Returns a vector of coefficients `p` that minimises
+    the squared error in the order `deg`, `deg-1`, ... `0`.
+
+    The `Polynomial.fit ` class
+    method is recommended for new code as it is more stable numerically. See
+    the documentation of the method for more information.
+
+    Parameters
+    ----------
+    x : array_like, shape (M,)
+        x-coordinates of the M sample points ``(x[i], y[i])``.
+    y : array_like, shape (M,) or (M, K)
+        y-coordinates of the sample points. Several data sets of sample
+        points sharing the same x-coordinates can be fitted at once by
+        passing in a 2D-array that contains one dataset per column.
+    deg : int
+        Degree of the fitting polynomial
+    rcond : float, optional
+        Relative condition number of the fit. Singular values smaller than
+        this relative to the largest singular value will be ignored. The
+        default value is len(x)*eps, where eps is the relative precision of
+        the float type, about 2e-16 in most cases.
+    full : bool, optional
+        Switch determining nature of return value. When it is False (the
+        default) just the coefficients are returned, when True diagnostic
+        information from the singular value decomposition is also returned.
+    w : array_like, shape (M,), optional
+        Weights. If not None, the weight ``w[i]`` applies to the unsquared
+        residual ``y[i] - y_hat[i]`` at ``x[i]``. Ideally the weights are
+        chosen so that the errors of the products ``w[i]*y[i]`` all have the
+        same variance.  When using inverse-variance weighting, use
+        ``w[i] = 1/sigma(y[i])``.  The default value is None.
+    cov : bool or str, optional
+        If given and not `False`, return not just the estimate but also its
+        covariance matrix. By default, the covariance are scaled by
+        chi2/dof, where dof = M - (deg + 1), i.e., the weights are presumed
+        to be unreliable except in a relative sense and everything is scaled
+        such that the reduced chi2 is unity. This scaling is omitted if
+        ``cov='unscaled'``, as is relevant for the case that the weights are
+        w = 1/sigma, with sigma known to be a reliable estimate of the
+        uncertainty.
+
+    Returns
+    -------
+    p : ndarray, shape (deg + 1,) or (deg + 1, K)
+        Polynomial coefficients, highest power first.  If `y` was 2-D, the
+        coefficients for `k`-th data set are in ``p[:,k]``.
+
+    residuals, rank, singular_values, rcond
+        These values are only returned if ``full == True``
+
+        - residuals -- sum of squared residuals of the least squares fit
+        - rank -- the effective rank of the scaled Vandermonde
+           coefficient matrix
+        - singular_values -- singular values of the scaled Vandermonde
+           coefficient matrix
+        - rcond -- value of `rcond`.
+
+        For more details, see `numpy.linalg.lstsq`.
+
+    V : ndarray, shape (deg + 1, deg + 1) or (deg + 1, deg + 1, K)
+        Present only if ``full == False`` and ``cov == True``.  The covariance
+        matrix of the polynomial coefficient estimates.  The diagonal of
+        this matrix are the variance estimates for each coefficient.  If y
+        is a 2-D array, then the covariance matrix for the `k`-th data set
+        are in ``V[:,:,k]``
+
+
+    Warns
+    -----
+    RankWarning
+        The rank of the coefficient matrix in the least-squares fit is
+        deficient. The warning is only raised if ``full == False``.
+
+        The warnings can be turned off by
+
+        >>> import warnings
+        >>> warnings.simplefilter('ignore', np.exceptions.RankWarning)
+
+    See Also
+    --------
+    polyval : Compute polynomial values.
+    linalg.lstsq : Computes a least-squares fit.
+    scipy.interpolate.UnivariateSpline : Computes spline fits.
+
+    Notes
+    -----
+    The solution minimizes the squared error
+
+    .. math::
+        E = \\sum_{j=0}^k |p(x_j) - y_j|^2
+
+    in the equations::
+
+        x[0]**n * p[0] + ... + x[0] * p[n-1] + p[n] = y[0]
+        x[1]**n * p[0] + ... + x[1] * p[n-1] + p[n] = y[1]
+        ...
+        x[k]**n * p[0] + ... + x[k] * p[n-1] + p[n] = y[k]
+
+    The coefficient matrix of the coefficients `p` is a Vandermonde matrix.
+
+    `polyfit` issues a `~exceptions.RankWarning` when the least-squares fit is
+    badly conditioned. This implies that the best fit is not well-defined due
+    to numerical error. The results may be improved by lowering the polynomial
+    degree or by replacing `x` by `x` - `x`.mean(). The `rcond` parameter
+    can also be set to a value smaller than its default, but the resulting
+    fit may be spurious: including contributions from the small singular
+    values can add numerical noise to the result.
+
+    Note that fitting polynomial coefficients is inherently badly conditioned
+    when the degree of the polynomial is large or the interval of sample points
+    is badly centered. The quality of the fit should always be checked in these
+    cases. When polynomial fits are not satisfactory, splines may be a good
+    alternative.
+
+    References
+    ----------
+    .. [1] Wikipedia, "Curve fitting",
+           https://en.wikipedia.org/wiki/Curve_fitting
+    .. [2] Wikipedia, "Polynomial interpolation",
+           https://en.wikipedia.org/wiki/Polynomial_interpolation
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> import warnings
+    >>> x = np.array([0.0, 1.0, 2.0, 3.0,  4.0,  5.0])
+    >>> y = np.array([0.0, 0.8, 0.9, 0.1, -0.8, -1.0])
+    >>> z = np.polyfit(x, y, 3)
+    >>> z
+    array([ 0.08703704, -0.81349206,  1.69312169, -0.03968254]) # may vary
+
+    It is convenient to use `poly1d` objects for dealing with polynomials:
+
+    >>> p = np.poly1d(z)
+    >>> p(0.5)
+    0.6143849206349179 # may vary
+    >>> p(3.5)
+    -0.34732142857143039 # may vary
+    >>> p(10)
+    22.579365079365115 # may vary
+
+    High-order polynomials may oscillate wildly:
+
+    >>> with warnings.catch_warnings():
+    ...     warnings.simplefilter('ignore', np.exceptions.RankWarning)
+    ...     p30 = np.poly1d(np.polyfit(x, y, 30))
+    ...
+    >>> p30(4)
+    -0.80000000000000204 # may vary
+    >>> p30(5)
+    -0.99999999999999445 # may vary
+    >>> p30(4.5)
+    -0.10547061179440398 # may vary
+
+    Illustration:
+
+    >>> import matplotlib.pyplot as plt
+    >>> xp = np.linspace(-2, 6, 100)
+    >>> _ = plt.plot(x, y, '.', xp, p(xp), '-', xp, p30(xp), '--')
+    >>> plt.ylim(-2,2)
+    (-2, 2)
+    >>> plt.show()
+
+    """
+    order = int(deg) + 1
+    x = NX.asarray(x) + 0.0
+    y = NX.asarray(y) + 0.0
+
+    # check arguments.
+    if deg < 0:
+        raise ValueError("expected deg >= 0")
+    if x.ndim != 1:
+        raise TypeError("expected 1D vector for x")
+    if x.size == 0:
+        raise TypeError("expected non-empty vector for x")
+    if y.ndim < 1 or y.ndim > 2:
+        raise TypeError("expected 1D or 2D array for y")
+    if x.shape[0] != y.shape[0]:
+        raise TypeError("expected x and y to have same length")
+
+    # set rcond
+    if rcond is None:
+        rcond = len(x)*finfo(x.dtype).eps
+
+    # set up least squares equation for powers of x
+    lhs = vander(x, order)
+    rhs = y
+
+    # apply weighting
+    if w is not None:
+        w = NX.asarray(w) + 0.0
+        if w.ndim != 1:
+            raise TypeError("expected a 1-d array for weights")
+        if w.shape[0] != y.shape[0]:
+            raise TypeError("expected w and y to have the same length")
+        lhs *= w[:, NX.newaxis]
+        if rhs.ndim == 2:
+            rhs *= w[:, NX.newaxis]
+        else:
+            rhs *= w
+
+    # scale lhs to improve condition number and solve
+    scale = NX.sqrt((lhs*lhs).sum(axis=0))
+    lhs /= scale
+    c, resids, rank, s = lstsq(lhs, rhs, rcond)
+    c = (c.T/scale).T  # broadcast scale coefficients
+
+    # warn on rank reduction, which indicates an ill conditioned matrix
+    if rank != order and not full:
+        msg = "Polyfit may be poorly conditioned"
+        warnings.warn(msg, RankWarning, stacklevel=2)
+
+    if full:
+        return c, resids, rank, s, rcond
+    elif cov:
+        Vbase = inv(dot(lhs.T, lhs))
+        Vbase /= NX.outer(scale, scale)
+        if cov == "unscaled":
+            fac = 1
+        else:
+            if len(x) <= order:
+                raise ValueError("the number of data points must exceed order "
+                                 "to scale the covariance matrix")
+            # note, this used to be: fac = resids / (len(x) - order - 2.0)
+            # it was decided that the "- 2" (originally justified by "Bayesian
+            # uncertainty analysis") is not what the user expects
+            # (see gh-11196 and gh-11197)
+            fac = resids / (len(x) - order)
+        if y.ndim == 1:
+            return c, Vbase * fac
+        else:
+            return c, Vbase[:,:, NX.newaxis] * fac
+    else:
+        return c
+
+
+def _polyval_dispatcher(p, x):
+    return (p, x)
+
+
+@array_function_dispatch(_polyval_dispatcher)
+def polyval(p, x):
+    """
+    Evaluate a polynomial at specific values.
+
+    .. note::
+       This forms part of the old polynomial API. Since version 1.4, the
+       new polynomial API defined in `numpy.polynomial` is preferred.
+       A summary of the differences can be found in the
+       :doc:`transition guide `.
+
+    If `p` is of length N, this function returns the value::
+
+        p[0]*x**(N-1) + p[1]*x**(N-2) + ... + p[N-2]*x + p[N-1]
+
+    If `x` is a sequence, then ``p(x)`` is returned for each element of ``x``.
+    If `x` is another polynomial then the composite polynomial ``p(x(t))``
+    is returned.
+
+    Parameters
+    ----------
+    p : array_like or poly1d object
+       1D array of polynomial coefficients (including coefficients equal
+       to zero) from highest degree to the constant term, or an
+       instance of poly1d.
+    x : array_like or poly1d object
+       A number, an array of numbers, or an instance of poly1d, at
+       which to evaluate `p`.
+
+    Returns
+    -------
+    values : ndarray or poly1d
+       If `x` is a poly1d instance, the result is the composition of the two
+       polynomials, i.e., `x` is "substituted" in `p` and the simplified
+       result is returned. In addition, the type of `x` - array_like or
+       poly1d - governs the type of the output: `x` array_like => `values`
+       array_like, `x` a poly1d object => `values` is also.
+
+    See Also
+    --------
+    poly1d: A polynomial class.
+
+    Notes
+    -----
+    Horner's scheme [1]_ is used to evaluate the polynomial. Even so,
+    for polynomials of high degree the values may be inaccurate due to
+    rounding errors. Use carefully.
+
+    If `x` is a subtype of `ndarray` the return value will be of the same type.
+
+    References
+    ----------
+    .. [1] I. N. Bronshtein, K. A. Semendyayev, and K. A. Hirsch (Eng.
+       trans. Ed.), *Handbook of Mathematics*, New York, Van Nostrand
+       Reinhold Co., 1985, pg. 720.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> np.polyval([3,0,1], 5)  # 3 * 5**2 + 0 * 5**1 + 1
+    76
+    >>> np.polyval([3,0,1], np.poly1d(5))
+    poly1d([76])
+    >>> np.polyval(np.poly1d([3,0,1]), 5)
+    76
+    >>> np.polyval(np.poly1d([3,0,1]), np.poly1d(5))
+    poly1d([76])
+
+    """
+    p = NX.asarray(p)
+    if isinstance(x, poly1d):
+        y = 0
+    else:
+        x = NX.asanyarray(x)
+        y = NX.zeros_like(x)
+    for pv in p:
+        y = y * x + pv
+    return y
+
+
+def _binary_op_dispatcher(a1, a2):
+    return (a1, a2)
+
+
+@array_function_dispatch(_binary_op_dispatcher)
+def polyadd(a1, a2):
+    """
+    Find the sum of two polynomials.
+
+    .. note::
+       This forms part of the old polynomial API. Since version 1.4, the
+       new polynomial API defined in `numpy.polynomial` is preferred.
+       A summary of the differences can be found in the
+       :doc:`transition guide `.
+
+    Returns the polynomial resulting from the sum of two input polynomials.
+    Each input must be either a poly1d object or a 1D sequence of polynomial
+    coefficients, from highest to lowest degree.
+
+    Parameters
+    ----------
+    a1, a2 : array_like or poly1d object
+        Input polynomials.
+
+    Returns
+    -------
+    out : ndarray or poly1d object
+        The sum of the inputs. If either input is a poly1d object, then the
+        output is also a poly1d object. Otherwise, it is a 1D array of
+        polynomial coefficients from highest to lowest degree.
+
+    See Also
+    --------
+    poly1d : A one-dimensional polynomial class.
+    poly, polyadd, polyder, polydiv, polyfit, polyint, polysub, polyval
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> np.polyadd([1, 2], [9, 5, 4])
+    array([9, 6, 6])
+
+    Using poly1d objects:
+
+    >>> p1 = np.poly1d([1, 2])
+    >>> p2 = np.poly1d([9, 5, 4])
+    >>> print(p1)
+    1 x + 2
+    >>> print(p2)
+       2
+    9 x + 5 x + 4
+    >>> print(np.polyadd(p1, p2))
+       2
+    9 x + 6 x + 6
+
+    """
+    truepoly = (isinstance(a1, poly1d) or isinstance(a2, poly1d))
+    a1 = atleast_1d(a1)
+    a2 = atleast_1d(a2)
+    diff = len(a2) - len(a1)
+    if diff == 0:
+        val = a1 + a2
+    elif diff > 0:
+        zr = NX.zeros(diff, a1.dtype)
+        val = NX.concatenate((zr, a1)) + a2
+    else:
+        zr = NX.zeros(abs(diff), a2.dtype)
+        val = a1 + NX.concatenate((zr, a2))
+    if truepoly:
+        val = poly1d(val)
+    return val
+
+
+@array_function_dispatch(_binary_op_dispatcher)
+def polysub(a1, a2):
+    """
+    Difference (subtraction) of two polynomials.
+
+    .. note::
+       This forms part of the old polynomial API. Since version 1.4, the
+       new polynomial API defined in `numpy.polynomial` is preferred.
+       A summary of the differences can be found in the
+       :doc:`transition guide `.
+
+    Given two polynomials `a1` and `a2`, returns ``a1 - a2``.
+    `a1` and `a2` can be either array_like sequences of the polynomials'
+    coefficients (including coefficients equal to zero), or `poly1d` objects.
+
+    Parameters
+    ----------
+    a1, a2 : array_like or poly1d
+        Minuend and subtrahend polynomials, respectively.
+
+    Returns
+    -------
+    out : ndarray or poly1d
+        Array or `poly1d` object of the difference polynomial's coefficients.
+
+    See Also
+    --------
+    polyval, polydiv, polymul, polyadd
+
+    Examples
+    --------
+    .. math:: (2 x^2 + 10 x - 2) - (3 x^2 + 10 x -4) = (-x^2 + 2)
+
+    >>> import numpy as np
+
+    >>> np.polysub([2, 10, -2], [3, 10, -4])
+    array([-1,  0,  2])
+
+    """
+    truepoly = (isinstance(a1, poly1d) or isinstance(a2, poly1d))
+    a1 = atleast_1d(a1)
+    a2 = atleast_1d(a2)
+    diff = len(a2) - len(a1)
+    if diff == 0:
+        val = a1 - a2
+    elif diff > 0:
+        zr = NX.zeros(diff, a1.dtype)
+        val = NX.concatenate((zr, a1)) - a2
+    else:
+        zr = NX.zeros(abs(diff), a2.dtype)
+        val = a1 - NX.concatenate((zr, a2))
+    if truepoly:
+        val = poly1d(val)
+    return val
+
+
+@array_function_dispatch(_binary_op_dispatcher)
+def polymul(a1, a2):
+    """
+    Find the product of two polynomials.
+
+    .. note::
+       This forms part of the old polynomial API. Since version 1.4, the
+       new polynomial API defined in `numpy.polynomial` is preferred.
+       A summary of the differences can be found in the
+       :doc:`transition guide `.
+
+    Finds the polynomial resulting from the multiplication of the two input
+    polynomials. Each input must be either a poly1d object or a 1D sequence
+    of polynomial coefficients, from highest to lowest degree.
+
+    Parameters
+    ----------
+    a1, a2 : array_like or poly1d object
+        Input polynomials.
+
+    Returns
+    -------
+    out : ndarray or poly1d object
+        The polynomial resulting from the multiplication of the inputs. If
+        either inputs is a poly1d object, then the output is also a poly1d
+        object. Otherwise, it is a 1D array of polynomial coefficients from
+        highest to lowest degree.
+
+    See Also
+    --------
+    poly1d : A one-dimensional polynomial class.
+    poly, polyadd, polyder, polydiv, polyfit, polyint, polysub, polyval
+    convolve : Array convolution. Same output as polymul, but has parameter
+               for overlap mode.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> np.polymul([1, 2, 3], [9, 5, 1])
+    array([ 9, 23, 38, 17,  3])
+
+    Using poly1d objects:
+
+    >>> p1 = np.poly1d([1, 2, 3])
+    >>> p2 = np.poly1d([9, 5, 1])
+    >>> print(p1)
+       2
+    1 x + 2 x + 3
+    >>> print(p2)
+       2
+    9 x + 5 x + 1
+    >>> print(np.polymul(p1, p2))
+       4      3      2
+    9 x + 23 x + 38 x + 17 x + 3
+
+    """
+    truepoly = (isinstance(a1, poly1d) or isinstance(a2, poly1d))
+    a1, a2 = poly1d(a1), poly1d(a2)
+    val = NX.convolve(a1, a2)
+    if truepoly:
+        val = poly1d(val)
+    return val
+
+
+def _polydiv_dispatcher(u, v):
+    return (u, v)
+
+
+@array_function_dispatch(_polydiv_dispatcher)
+def polydiv(u, v):
+    """
+    Returns the quotient and remainder of polynomial division.
+
+    .. note::
+       This forms part of the old polynomial API. Since version 1.4, the
+       new polynomial API defined in `numpy.polynomial` is preferred.
+       A summary of the differences can be found in the
+       :doc:`transition guide `.
+
+    The input arrays are the coefficients (including any coefficients
+    equal to zero) of the "numerator" (dividend) and "denominator"
+    (divisor) polynomials, respectively.
+
+    Parameters
+    ----------
+    u : array_like or poly1d
+        Dividend polynomial's coefficients.
+
+    v : array_like or poly1d
+        Divisor polynomial's coefficients.
+
+    Returns
+    -------
+    q : ndarray
+        Coefficients, including those equal to zero, of the quotient.
+    r : ndarray
+        Coefficients, including those equal to zero, of the remainder.
+
+    See Also
+    --------
+    poly, polyadd, polyder, polydiv, polyfit, polyint, polymul, polysub
+    polyval
+
+    Notes
+    -----
+    Both `u` and `v` must be 0-d or 1-d (ndim = 0 or 1), but `u.ndim` need
+    not equal `v.ndim`. In other words, all four possible combinations -
+    ``u.ndim = v.ndim = 0``, ``u.ndim = v.ndim = 1``,
+    ``u.ndim = 1, v.ndim = 0``, and ``u.ndim = 0, v.ndim = 1`` - work.
+
+    Examples
+    --------
+    .. math:: \\frac{3x^2 + 5x + 2}{2x + 1} = 1.5x + 1.75, remainder 0.25
+
+    >>> import numpy as np
+    >>> x = np.array([3.0, 5.0, 2.0])
+    >>> y = np.array([2.0, 1.0])
+    >>> np.polydiv(x, y)
+    (array([1.5 , 1.75]), array([0.25]))
+
+    """
+    truepoly = (isinstance(u, poly1d) or isinstance(v, poly1d))
+    u = atleast_1d(u) + 0.0
+    v = atleast_1d(v) + 0.0
+    # w has the common type
+    w = u[0] + v[0]
+    m = len(u) - 1
+    n = len(v) - 1
+    scale = 1. / v[0]
+    q = NX.zeros((max(m - n + 1, 1),), w.dtype)
+    r = u.astype(w.dtype)
+    for k in range(0, m-n+1):
+        d = scale * r[k]
+        q[k] = d
+        r[k:k+n+1] -= d*v
+    while NX.allclose(r[0], 0, rtol=1e-14) and (r.shape[-1] > 1):
+        r = r[1:]
+    if truepoly:
+        return poly1d(q), poly1d(r)
+    return q, r
+
+_poly_mat = re.compile(r"\*\*([0-9]*)")
+def _raise_power(astr, wrap=70):
+    n = 0
+    line1 = ''
+    line2 = ''
+    output = ' '
+    while True:
+        mat = _poly_mat.search(astr, n)
+        if mat is None:
+            break
+        span = mat.span()
+        power = mat.groups()[0]
+        partstr = astr[n:span[0]]
+        n = span[1]
+        toadd2 = partstr + ' '*(len(power)-1)
+        toadd1 = ' '*(len(partstr)-1) + power
+        if ((len(line2) + len(toadd2) > wrap) or
+                (len(line1) + len(toadd1) > wrap)):
+            output += line1 + "\n" + line2 + "\n "
+            line1 = toadd1
+            line2 = toadd2
+        else:
+            line2 += partstr + ' '*(len(power)-1)
+            line1 += ' '*(len(partstr)-1) + power
+    output += line1 + "\n" + line2
+    return output + astr[n:]
+
+
+@set_module('numpy')
+class poly1d:
+    """
+    A one-dimensional polynomial class.
+
+    .. note::
+       This forms part of the old polynomial API. Since version 1.4, the
+       new polynomial API defined in `numpy.polynomial` is preferred.
+       A summary of the differences can be found in the
+       :doc:`transition guide `.
+
+    A convenience class, used to encapsulate "natural" operations on
+    polynomials so that said operations may take on their customary
+    form in code (see Examples).
+
+    Parameters
+    ----------
+    c_or_r : array_like
+        The polynomial's coefficients, in decreasing powers, or if
+        the value of the second parameter is True, the polynomial's
+        roots (values where the polynomial evaluates to 0).  For example,
+        ``poly1d([1, 2, 3])`` returns an object that represents
+        :math:`x^2 + 2x + 3`, whereas ``poly1d([1, 2, 3], True)`` returns
+        one that represents :math:`(x-1)(x-2)(x-3) = x^3 - 6x^2 + 11x -6`.
+    r : bool, optional
+        If True, `c_or_r` specifies the polynomial's roots; the default
+        is False.
+    variable : str, optional
+        Changes the variable used when printing `p` from `x` to `variable`
+        (see Examples).
+
+    Examples
+    --------
+    Construct the polynomial :math:`x^2 + 2x + 3`:
+
+    >>> import numpy as np
+
+    >>> p = np.poly1d([1, 2, 3])
+    >>> print(np.poly1d(p))
+       2
+    1 x + 2 x + 3
+
+    Evaluate the polynomial at :math:`x = 0.5`:
+
+    >>> p(0.5)
+    4.25
+
+    Find the roots:
+
+    >>> p.r
+    array([-1.+1.41421356j, -1.-1.41421356j])
+    >>> p(p.r)
+    array([ -4.44089210e-16+0.j,  -4.44089210e-16+0.j]) # may vary
+
+    These numbers in the previous line represent (0, 0) to machine precision
+
+    Show the coefficients:
+
+    >>> p.c
+    array([1, 2, 3])
+
+    Display the order (the leading zero-coefficients are removed):
+
+    >>> p.order
+    2
+
+    Show the coefficient of the k-th power in the polynomial
+    (which is equivalent to ``p.c[-(i+1)]``):
+
+    >>> p[1]
+    2
+
+    Polynomials can be added, subtracted, multiplied, and divided
+    (returns quotient and remainder):
+
+    >>> p * p
+    poly1d([ 1,  4, 10, 12,  9])
+
+    >>> (p**3 + 4) / p
+    (poly1d([ 1.,  4., 10., 12.,  9.]), poly1d([4.]))
+
+    ``asarray(p)`` gives the coefficient array, so polynomials can be
+    used in all functions that accept arrays:
+
+    >>> p**2 # square of polynomial
+    poly1d([ 1,  4, 10, 12,  9])
+
+    >>> np.square(p) # square of individual coefficients
+    array([1, 4, 9])
+
+    The variable used in the string representation of `p` can be modified,
+    using the `variable` parameter:
+
+    >>> p = np.poly1d([1,2,3], variable='z')
+    >>> print(p)
+       2
+    1 z + 2 z + 3
+
+    Construct a polynomial from its roots:
+
+    >>> np.poly1d([1, 2], True)
+    poly1d([ 1., -3.,  2.])
+
+    This is the same polynomial as obtained by:
+
+    >>> np.poly1d([1, -1]) * np.poly1d([1, -2])
+    poly1d([ 1, -3,  2])
+
+    """
+    __hash__ = None
+
+    @property
+    def coeffs(self):
+        """ The polynomial coefficients """
+        return self._coeffs
+
+    @coeffs.setter
+    def coeffs(self, value):
+        # allowing this makes p.coeffs *= 2 legal
+        if value is not self._coeffs:
+            raise AttributeError("Cannot set attribute")
+
+    @property
+    def variable(self):
+        """ The name of the polynomial variable """
+        return self._variable
+
+    # calculated attributes
+    @property
+    def order(self):
+        """ The order or degree of the polynomial """
+        return len(self._coeffs) - 1
+
+    @property
+    def roots(self):
+        """ The roots of the polynomial, where self(x) == 0 """
+        return roots(self._coeffs)
+
+    # our internal _coeffs property need to be backed by __dict__['coeffs'] for
+    # scipy to work correctly.
+    @property
+    def _coeffs(self):
+        return self.__dict__['coeffs']
+    @_coeffs.setter
+    def _coeffs(self, coeffs):
+        self.__dict__['coeffs'] = coeffs
+
+    # alias attributes
+    r = roots
+    c = coef = coefficients = coeffs
+    o = order
+
+    def __init__(self, c_or_r, r=False, variable=None):
+        if isinstance(c_or_r, poly1d):
+            self._variable = c_or_r._variable
+            self._coeffs = c_or_r._coeffs
+
+            if set(c_or_r.__dict__) - set(self.__dict__):
+                msg = ("In the future extra properties will not be copied "
+                       "across when constructing one poly1d from another")
+                warnings.warn(msg, FutureWarning, stacklevel=2)
+                self.__dict__.update(c_or_r.__dict__)
+
+            if variable is not None:
+                self._variable = variable
+            return
+        if r:
+            c_or_r = poly(c_or_r)
+        c_or_r = atleast_1d(c_or_r)
+        if c_or_r.ndim > 1:
+            raise ValueError("Polynomial must be 1d only.")
+        c_or_r = trim_zeros(c_or_r, trim='f')
+        if len(c_or_r) == 0:
+            c_or_r = NX.array([0], dtype=c_or_r.dtype)
+        self._coeffs = c_or_r
+        if variable is None:
+            variable = 'x'
+        self._variable = variable
+
+    def __array__(self, t=None, copy=None):
+        if t:
+            return NX.asarray(self.coeffs, t, copy=copy)
+        else:
+            return NX.asarray(self.coeffs, copy=copy)
+
+    def __repr__(self):
+        vals = repr(self.coeffs)
+        vals = vals[6:-1]
+        return "poly1d(%s)" % vals
+
+    def __len__(self):
+        return self.order
+
+    def __str__(self):
+        thestr = "0"
+        var = self.variable
+
+        # Remove leading zeros
+        coeffs = self.coeffs[NX.logical_or.accumulate(self.coeffs != 0)]
+        N = len(coeffs)-1
+
+        def fmt_float(q):
+            s = '%.4g' % q
+            if s.endswith('.0000'):
+                s = s[:-5]
+            return s
+
+        for k, coeff in enumerate(coeffs):
+            if not iscomplex(coeff):
+                coefstr = fmt_float(real(coeff))
+            elif real(coeff) == 0:
+                coefstr = '%sj' % fmt_float(imag(coeff))
+            else:
+                coefstr = '(%s + %sj)' % (fmt_float(real(coeff)),
+                                          fmt_float(imag(coeff)))
+
+            power = (N-k)
+            if power == 0:
+                if coefstr != '0':
+                    newstr = '%s' % (coefstr,)
+                else:
+                    if k == 0:
+                        newstr = '0'
+                    else:
+                        newstr = ''
+            elif power == 1:
+                if coefstr == '0':
+                    newstr = ''
+                elif coefstr == 'b':
+                    newstr = var
+                else:
+                    newstr = '%s %s' % (coefstr, var)
+            else:
+                if coefstr == '0':
+                    newstr = ''
+                elif coefstr == 'b':
+                    newstr = '%s**%d' % (var, power,)
+                else:
+                    newstr = '%s %s**%d' % (coefstr, var, power)
+
+            if k > 0:
+                if newstr != '':
+                    if newstr.startswith('-'):
+                        thestr = "%s - %s" % (thestr, newstr[1:])
+                    else:
+                        thestr = "%s + %s" % (thestr, newstr)
+            else:
+                thestr = newstr
+        return _raise_power(thestr)
+
+    def __call__(self, val):
+        return polyval(self.coeffs, val)
+
+    def __neg__(self):
+        return poly1d(-self.coeffs)
+
+    def __pos__(self):
+        return self
+
+    def __mul__(self, other):
+        if isscalar(other):
+            return poly1d(self.coeffs * other)
+        else:
+            other = poly1d(other)
+            return poly1d(polymul(self.coeffs, other.coeffs))
+
+    def __rmul__(self, other):
+        if isscalar(other):
+            return poly1d(other * self.coeffs)
+        else:
+            other = poly1d(other)
+            return poly1d(polymul(self.coeffs, other.coeffs))
+
+    def __add__(self, other):
+        other = poly1d(other)
+        return poly1d(polyadd(self.coeffs, other.coeffs))
+
+    def __radd__(self, other):
+        other = poly1d(other)
+        return poly1d(polyadd(self.coeffs, other.coeffs))
+
+    def __pow__(self, val):
+        if not isscalar(val) or int(val) != val or val < 0:
+            raise ValueError("Power to non-negative integers only.")
+        res = [1]
+        for _ in range(val):
+            res = polymul(self.coeffs, res)
+        return poly1d(res)
+
+    def __sub__(self, other):
+        other = poly1d(other)
+        return poly1d(polysub(self.coeffs, other.coeffs))
+
+    def __rsub__(self, other):
+        other = poly1d(other)
+        return poly1d(polysub(other.coeffs, self.coeffs))
+
+    def __div__(self, other):
+        if isscalar(other):
+            return poly1d(self.coeffs/other)
+        else:
+            other = poly1d(other)
+            return polydiv(self, other)
+
+    __truediv__ = __div__
+
+    def __rdiv__(self, other):
+        if isscalar(other):
+            return poly1d(other/self.coeffs)
+        else:
+            other = poly1d(other)
+            return polydiv(other, self)
+
+    __rtruediv__ = __rdiv__
+
+    def __eq__(self, other):
+        if not isinstance(other, poly1d):
+            return NotImplemented
+        if self.coeffs.shape != other.coeffs.shape:
+            return False
+        return (self.coeffs == other.coeffs).all()
+
+    def __ne__(self, other):
+        if not isinstance(other, poly1d):
+            return NotImplemented
+        return not self.__eq__(other)
+
+
+    def __getitem__(self, val):
+        ind = self.order - val
+        if val > self.order:
+            return self.coeffs.dtype.type(0)
+        if val < 0:
+            return self.coeffs.dtype.type(0)
+        return self.coeffs[ind]
+
+    def __setitem__(self, key, val):
+        ind = self.order - key
+        if key < 0:
+            raise ValueError("Does not support negative powers.")
+        if key > self.order:
+            zr = NX.zeros(key-self.order, self.coeffs.dtype)
+            self._coeffs = NX.concatenate((zr, self.coeffs))
+            ind = 0
+        self._coeffs[ind] = val
+        return
+
+    def __iter__(self):
+        return iter(self.coeffs)
+
+    def integ(self, m=1, k=0):
+        """
+        Return an antiderivative (indefinite integral) of this polynomial.
+
+        Refer to `polyint` for full documentation.
+
+        See Also
+        --------
+        polyint : equivalent function
+
+        """
+        return poly1d(polyint(self.coeffs, m=m, k=k))
+
+    def deriv(self, m=1):
+        """
+        Return a derivative of this polynomial.
+
+        Refer to `polyder` for full documentation.
+
+        See Also
+        --------
+        polyder : equivalent function
+
+        """
+        return poly1d(polyder(self.coeffs, m=m))
+
+# Stuff to do on module import
+
+warnings.simplefilter('always', RankWarning)
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/_polynomial_impl.pyi b/venv/lib/python3.12/site-packages/numpy/lib/_polynomial_impl.pyi
new file mode 100644
index 00000000..123f3204
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/lib/_polynomial_impl.pyi
@@ -0,0 +1,302 @@
+from typing import (
+    Literal as L,
+    overload,
+    Any,
+    SupportsInt,
+    SupportsIndex,
+    TypeVar,
+    NoReturn,
+)
+
+import numpy as np
+from numpy import (
+    poly1d as poly1d,
+    unsignedinteger,
+    signedinteger,
+    floating,
+    complexfloating,
+    int32,
+    int64,
+    float64,
+    complex128,
+    object_,
+)
+
+from numpy._typing import (
+    NDArray,
+    ArrayLike,
+    _ArrayLikeBool_co,
+    _ArrayLikeUInt_co,
+    _ArrayLikeInt_co,
+    _ArrayLikeFloat_co,
+    _ArrayLikeComplex_co,
+    _ArrayLikeObject_co,
+)
+
+_T = TypeVar("_T")
+
+_2Tup = tuple[_T, _T]
+_5Tup = tuple[
+    _T,
+    NDArray[float64],
+    NDArray[int32],
+    NDArray[float64],
+    NDArray[float64],
+]
+
+__all__: list[str]
+
+def poly(seq_of_zeros: ArrayLike) -> NDArray[floating[Any]]: ...
+
+# Returns either a float or complex array depending on the input values.
+# See `np.linalg.eigvals`.
+def roots(p: ArrayLike) -> NDArray[complexfloating[Any, Any]] | NDArray[floating[Any]]: ...
+
+@overload
+def polyint(
+    p: poly1d,
+    m: SupportsInt | SupportsIndex = ...,
+    k: None | _ArrayLikeComplex_co | _ArrayLikeObject_co = ...,
+) -> poly1d: ...
+@overload
+def polyint(
+    p: _ArrayLikeFloat_co,
+    m: SupportsInt | SupportsIndex = ...,
+    k: None | _ArrayLikeFloat_co = ...,
+) -> NDArray[floating[Any]]: ...
+@overload
+def polyint(
+    p: _ArrayLikeComplex_co,
+    m: SupportsInt | SupportsIndex = ...,
+    k: None | _ArrayLikeComplex_co = ...,
+) -> NDArray[complexfloating[Any, Any]]: ...
+@overload
+def polyint(
+    p: _ArrayLikeObject_co,
+    m: SupportsInt | SupportsIndex = ...,
+    k: None | _ArrayLikeObject_co = ...,
+) -> NDArray[object_]: ...
+
+@overload
+def polyder(
+    p: poly1d,
+    m: SupportsInt | SupportsIndex = ...,
+) -> poly1d: ...
+@overload
+def polyder(
+    p: _ArrayLikeFloat_co,
+    m: SupportsInt | SupportsIndex = ...,
+) -> NDArray[floating[Any]]: ...
+@overload
+def polyder(
+    p: _ArrayLikeComplex_co,
+    m: SupportsInt | SupportsIndex = ...,
+) -> NDArray[complexfloating[Any, Any]]: ...
+@overload
+def polyder(
+    p: _ArrayLikeObject_co,
+    m: SupportsInt | SupportsIndex = ...,
+) -> NDArray[object_]: ...
+
+@overload
+def polyfit(
+    x: _ArrayLikeFloat_co,
+    y: _ArrayLikeFloat_co,
+    deg: SupportsIndex | SupportsInt,
+    rcond: None | float = ...,
+    full: L[False] = ...,
+    w: None | _ArrayLikeFloat_co = ...,
+    cov: L[False] = ...,
+) -> NDArray[float64]: ...
+@overload
+def polyfit(
+    x: _ArrayLikeComplex_co,
+    y: _ArrayLikeComplex_co,
+    deg: SupportsIndex | SupportsInt,
+    rcond: None | float = ...,
+    full: L[False] = ...,
+    w: None | _ArrayLikeFloat_co = ...,
+    cov: L[False] = ...,
+) -> NDArray[complex128]: ...
+@overload
+def polyfit(
+    x: _ArrayLikeFloat_co,
+    y: _ArrayLikeFloat_co,
+    deg: SupportsIndex | SupportsInt,
+    rcond: None | float = ...,
+    full: L[False] = ...,
+    w: None | _ArrayLikeFloat_co = ...,
+    cov: L[True, "unscaled"] = ...,
+) -> _2Tup[NDArray[float64]]: ...
+@overload
+def polyfit(
+    x: _ArrayLikeComplex_co,
+    y: _ArrayLikeComplex_co,
+    deg: SupportsIndex | SupportsInt,
+    rcond: None | float = ...,
+    full: L[False] = ...,
+    w: None | _ArrayLikeFloat_co = ...,
+    cov: L[True, "unscaled"] = ...,
+) -> _2Tup[NDArray[complex128]]: ...
+@overload
+def polyfit(
+    x: _ArrayLikeFloat_co,
+    y: _ArrayLikeFloat_co,
+    deg: SupportsIndex | SupportsInt,
+    rcond: None | float = ...,
+    full: L[True] = ...,
+    w: None | _ArrayLikeFloat_co = ...,
+    cov: bool | L["unscaled"] = ...,
+) -> _5Tup[NDArray[float64]]: ...
+@overload
+def polyfit(
+    x: _ArrayLikeComplex_co,
+    y: _ArrayLikeComplex_co,
+    deg: SupportsIndex | SupportsInt,
+    rcond: None | float = ...,
+    full: L[True] = ...,
+    w: None | _ArrayLikeFloat_co = ...,
+    cov: bool | L["unscaled"] = ...,
+) -> _5Tup[NDArray[complex128]]: ...
+
+@overload
+def polyval(
+    p: _ArrayLikeBool_co,
+    x: _ArrayLikeBool_co,
+) -> NDArray[int64]: ...
+@overload
+def polyval(
+    p: _ArrayLikeUInt_co,
+    x: _ArrayLikeUInt_co,
+) -> NDArray[unsignedinteger[Any]]: ...
+@overload
+def polyval(
+    p: _ArrayLikeInt_co,
+    x: _ArrayLikeInt_co,
+) -> NDArray[signedinteger[Any]]: ...
+@overload
+def polyval(
+    p: _ArrayLikeFloat_co,
+    x: _ArrayLikeFloat_co,
+) -> NDArray[floating[Any]]: ...
+@overload
+def polyval(
+    p: _ArrayLikeComplex_co,
+    x: _ArrayLikeComplex_co,
+) -> NDArray[complexfloating[Any, Any]]: ...
+@overload
+def polyval(
+    p: _ArrayLikeObject_co,
+    x: _ArrayLikeObject_co,
+) -> NDArray[object_]: ...
+
+@overload
+def polyadd(
+    a1: poly1d,
+    a2: _ArrayLikeComplex_co | _ArrayLikeObject_co,
+) -> poly1d: ...
+@overload
+def polyadd(
+    a1: _ArrayLikeComplex_co | _ArrayLikeObject_co,
+    a2: poly1d,
+) -> poly1d: ...
+@overload
+def polyadd(
+    a1: _ArrayLikeBool_co,
+    a2: _ArrayLikeBool_co,
+) -> NDArray[np.bool]: ...
+@overload
+def polyadd(
+    a1: _ArrayLikeUInt_co,
+    a2: _ArrayLikeUInt_co,
+) -> NDArray[unsignedinteger[Any]]: ...
+@overload
+def polyadd(
+    a1: _ArrayLikeInt_co,
+    a2: _ArrayLikeInt_co,
+) -> NDArray[signedinteger[Any]]: ...
+@overload
+def polyadd(
+    a1: _ArrayLikeFloat_co,
+    a2: _ArrayLikeFloat_co,
+) -> NDArray[floating[Any]]: ...
+@overload
+def polyadd(
+    a1: _ArrayLikeComplex_co,
+    a2: _ArrayLikeComplex_co,
+) -> NDArray[complexfloating[Any, Any]]: ...
+@overload
+def polyadd(
+    a1: _ArrayLikeObject_co,
+    a2: _ArrayLikeObject_co,
+) -> NDArray[object_]: ...
+
+@overload
+def polysub(
+    a1: poly1d,
+    a2: _ArrayLikeComplex_co | _ArrayLikeObject_co,
+) -> poly1d: ...
+@overload
+def polysub(
+    a1: _ArrayLikeComplex_co | _ArrayLikeObject_co,
+    a2: poly1d,
+) -> poly1d: ...
+@overload
+def polysub(
+    a1: _ArrayLikeBool_co,
+    a2: _ArrayLikeBool_co,
+) -> NoReturn: ...
+@overload
+def polysub(
+    a1: _ArrayLikeUInt_co,
+    a2: _ArrayLikeUInt_co,
+) -> NDArray[unsignedinteger[Any]]: ...
+@overload
+def polysub(
+    a1: _ArrayLikeInt_co,
+    a2: _ArrayLikeInt_co,
+) -> NDArray[signedinteger[Any]]: ...
+@overload
+def polysub(
+    a1: _ArrayLikeFloat_co,
+    a2: _ArrayLikeFloat_co,
+) -> NDArray[floating[Any]]: ...
+@overload
+def polysub(
+    a1: _ArrayLikeComplex_co,
+    a2: _ArrayLikeComplex_co,
+) -> NDArray[complexfloating[Any, Any]]: ...
+@overload
+def polysub(
+    a1: _ArrayLikeObject_co,
+    a2: _ArrayLikeObject_co,
+) -> NDArray[object_]: ...
+
+# NOTE: Not an alias, but they do have the same signature (that we can reuse)
+polymul = polyadd
+
+@overload
+def polydiv(
+    u: poly1d,
+    v: _ArrayLikeComplex_co | _ArrayLikeObject_co,
+) -> _2Tup[poly1d]: ...
+@overload
+def polydiv(
+    u: _ArrayLikeComplex_co | _ArrayLikeObject_co,
+    v: poly1d,
+) -> _2Tup[poly1d]: ...
+@overload
+def polydiv(
+    u: _ArrayLikeFloat_co,
+    v: _ArrayLikeFloat_co,
+) -> _2Tup[NDArray[floating[Any]]]: ...
+@overload
+def polydiv(
+    u: _ArrayLikeComplex_co,
+    v: _ArrayLikeComplex_co,
+) -> _2Tup[NDArray[complexfloating[Any, Any]]]: ...
+@overload
+def polydiv(
+    u: _ArrayLikeObject_co,
+    v: _ArrayLikeObject_co,
+) -> _2Tup[NDArray[Any]]: ...
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/_scimath_impl.py b/venv/lib/python3.12/site-packages/numpy/lib/_scimath_impl.py
new file mode 100644
index 00000000..d5492c64
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/lib/_scimath_impl.py
@@ -0,0 +1,650 @@
+"""
+Wrapper functions to more user-friendly calling of certain math functions
+whose output data-type is different than the input data-type in certain
+domains of the input.
+
+For example, for functions like `log` with branch cuts, the versions in this
+module provide the mathematically valid answers in the complex plane::
+
+  >>> import math
+  >>> np.emath.log(-math.exp(1)) == (1+1j*math.pi)
+  True
+
+Similarly, `sqrt`, other base logarithms, `power` and trig functions are
+correctly handled.  See their respective docstrings for specific examples.
+
+Functions
+---------
+
+.. autosummary::
+   :toctree: generated/
+
+   sqrt
+   log
+   log2
+   logn
+   log10
+   power
+   arccos
+   arcsin
+   arctanh
+
+"""
+import numpy._core.numeric as nx
+import numpy._core.numerictypes as nt
+from numpy._core.numeric import asarray, any
+from numpy._core.overrides import array_function_dispatch
+from numpy.lib._type_check_impl import isreal
+
+
+__all__ = [
+    'sqrt', 'log', 'log2', 'logn', 'log10', 'power', 'arccos', 'arcsin',
+    'arctanh'
+    ]
+
+
+_ln2 = nx.log(2.0)
+
+
+def _tocomplex(arr):
+    """Convert its input `arr` to a complex array.
+
+    The input is returned as a complex array of the smallest type that will fit
+    the original data: types like single, byte, short, etc. become csingle,
+    while others become cdouble.
+
+    A copy of the input is always made.
+
+    Parameters
+    ----------
+    arr : array
+
+    Returns
+    -------
+    array
+        An array with the same input data as the input but in complex form.
+
+    Examples
+    --------
+    >>> import numpy as np
+
+    First, consider an input of type short:
+
+    >>> a = np.array([1,2,3],np.short)
+
+    >>> ac = np.lib.scimath._tocomplex(a); ac
+    array([1.+0.j, 2.+0.j, 3.+0.j], dtype=complex64)
+
+    >>> ac.dtype
+    dtype('complex64')
+
+    If the input is of type double, the output is correspondingly of the
+    complex double type as well:
+
+    >>> b = np.array([1,2,3],np.double)
+
+    >>> bc = np.lib.scimath._tocomplex(b); bc
+    array([1.+0.j, 2.+0.j, 3.+0.j])
+
+    >>> bc.dtype
+    dtype('complex128')
+
+    Note that even if the input was complex to begin with, a copy is still
+    made, since the astype() method always copies:
+
+    >>> c = np.array([1,2,3],np.csingle)
+
+    >>> cc = np.lib.scimath._tocomplex(c); cc
+    array([1.+0.j,  2.+0.j,  3.+0.j], dtype=complex64)
+
+    >>> c *= 2; c
+    array([2.+0.j,  4.+0.j,  6.+0.j], dtype=complex64)
+
+    >>> cc
+    array([1.+0.j,  2.+0.j,  3.+0.j], dtype=complex64)
+    """
+    if issubclass(arr.dtype.type, (nt.single, nt.byte, nt.short, nt.ubyte,
+                                   nt.ushort, nt.csingle)):
+        return arr.astype(nt.csingle)
+    else:
+        return arr.astype(nt.cdouble)
+
+
+def _fix_real_lt_zero(x):
+    """Convert `x` to complex if it has real, negative components.
+
+    Otherwise, output is just the array version of the input (via asarray).
+
+    Parameters
+    ----------
+    x : array_like
+
+    Returns
+    -------
+    array
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> np.lib.scimath._fix_real_lt_zero([1,2])
+    array([1, 2])
+
+    >>> np.lib.scimath._fix_real_lt_zero([-1,2])
+    array([-1.+0.j,  2.+0.j])
+
+    """
+    x = asarray(x)
+    if any(isreal(x) & (x < 0)):
+        x = _tocomplex(x)
+    return x
+
+
+def _fix_int_lt_zero(x):
+    """Convert `x` to double if it has real, negative components.
+
+    Otherwise, output is just the array version of the input (via asarray).
+
+    Parameters
+    ----------
+    x : array_like
+
+    Returns
+    -------
+    array
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> np.lib.scimath._fix_int_lt_zero([1,2])
+    array([1, 2])
+
+    >>> np.lib.scimath._fix_int_lt_zero([-1,2])
+    array([-1.,  2.])
+    """
+    x = asarray(x)
+    if any(isreal(x) & (x < 0)):
+        x = x * 1.0
+    return x
+
+
+def _fix_real_abs_gt_1(x):
+    """Convert `x` to complex if it has real components x_i with abs(x_i)>1.
+
+    Otherwise, output is just the array version of the input (via asarray).
+
+    Parameters
+    ----------
+    x : array_like
+
+    Returns
+    -------
+    array
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> np.lib.scimath._fix_real_abs_gt_1([0,1])
+    array([0, 1])
+
+    >>> np.lib.scimath._fix_real_abs_gt_1([0,2])
+    array([0.+0.j, 2.+0.j])
+    """
+    x = asarray(x)
+    if any(isreal(x) & (abs(x) > 1)):
+        x = _tocomplex(x)
+    return x
+
+
+def _unary_dispatcher(x):
+    return (x,)
+
+
+@array_function_dispatch(_unary_dispatcher)
+def sqrt(x):
+    """
+    Compute the square root of x.
+
+    For negative input elements, a complex value is returned
+    (unlike `numpy.sqrt` which returns NaN).
+
+    Parameters
+    ----------
+    x : array_like
+       The input value(s).
+
+    Returns
+    -------
+    out : ndarray or scalar
+       The square root of `x`. If `x` was a scalar, so is `out`,
+       otherwise an array is returned.
+
+    See Also
+    --------
+    numpy.sqrt
+
+    Examples
+    --------
+    For real, non-negative inputs this works just like `numpy.sqrt`:
+
+    >>> import numpy as np
+
+    >>> np.emath.sqrt(1)
+    1.0
+    >>> np.emath.sqrt([1, 4])
+    array([1.,  2.])
+
+    But it automatically handles negative inputs:
+
+    >>> np.emath.sqrt(-1)
+    1j
+    >>> np.emath.sqrt([-1,4])
+    array([0.+1.j, 2.+0.j])
+
+    Different results are expected because:
+    floating point 0.0 and -0.0 are distinct.
+
+    For more control, explicitly use complex() as follows:
+
+    >>> np.emath.sqrt(complex(-4.0, 0.0))
+    2j
+    >>> np.emath.sqrt(complex(-4.0, -0.0))
+    -2j
+    """
+    x = _fix_real_lt_zero(x)
+    return nx.sqrt(x)
+
+
+@array_function_dispatch(_unary_dispatcher)
+def log(x):
+    """
+    Compute the natural logarithm of `x`.
+
+    Return the "principal value" (for a description of this, see `numpy.log`)
+    of :math:`log_e(x)`. For real `x > 0`, this is a real number (``log(0)``
+    returns ``-inf`` and ``log(np.inf)`` returns ``inf``). Otherwise, the
+    complex principle value is returned.
+
+    Parameters
+    ----------
+    x : array_like
+       The value(s) whose log is (are) required.
+
+    Returns
+    -------
+    out : ndarray or scalar
+       The log of the `x` value(s). If `x` was a scalar, so is `out`,
+       otherwise an array is returned.
+
+    See Also
+    --------
+    numpy.log
+
+    Notes
+    -----
+    For a log() that returns ``NAN`` when real `x < 0`, use `numpy.log`
+    (note, however, that otherwise `numpy.log` and this `log` are identical,
+    i.e., both return ``-inf`` for `x = 0`, ``inf`` for `x = inf`, and,
+    notably, the complex principle value if ``x.imag != 0``).
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> np.emath.log(np.exp(1))
+    1.0
+
+    Negative arguments are handled "correctly" (recall that
+    ``exp(log(x)) == x`` does *not* hold for real ``x < 0``):
+
+    >>> np.emath.log(-np.exp(1)) == (1 + np.pi * 1j)
+    True
+
+    """
+    x = _fix_real_lt_zero(x)
+    return nx.log(x)
+
+
+@array_function_dispatch(_unary_dispatcher)
+def log10(x):
+    """
+    Compute the logarithm base 10 of `x`.
+
+    Return the "principal value" (for a description of this, see
+    `numpy.log10`) of :math:`log_{10}(x)`. For real `x > 0`, this
+    is a real number (``log10(0)`` returns ``-inf`` and ``log10(np.inf)``
+    returns ``inf``). Otherwise, the complex principle value is returned.
+
+    Parameters
+    ----------
+    x : array_like or scalar
+       The value(s) whose log base 10 is (are) required.
+
+    Returns
+    -------
+    out : ndarray or scalar
+       The log base 10 of the `x` value(s). If `x` was a scalar, so is `out`,
+       otherwise an array object is returned.
+
+    See Also
+    --------
+    numpy.log10
+
+    Notes
+    -----
+    For a log10() that returns ``NAN`` when real `x < 0`, use `numpy.log10`
+    (note, however, that otherwise `numpy.log10` and this `log10` are
+    identical, i.e., both return ``-inf`` for `x = 0`, ``inf`` for `x = inf`,
+    and, notably, the complex principle value if ``x.imag != 0``).
+
+    Examples
+    --------
+    >>> import numpy as np
+
+    (We set the printing precision so the example can be auto-tested)
+
+    >>> np.set_printoptions(precision=4)
+
+    >>> np.emath.log10(10**1)
+    1.0
+
+    >>> np.emath.log10([-10**1, -10**2, 10**2])
+    array([1.+1.3644j, 2.+1.3644j, 2.+0.j    ])
+
+    """
+    x = _fix_real_lt_zero(x)
+    return nx.log10(x)
+
+
+def _logn_dispatcher(n, x):
+    return (n, x,)
+
+
+@array_function_dispatch(_logn_dispatcher)
+def logn(n, x):
+    """
+    Take log base n of x.
+
+    If `x` contains negative inputs, the answer is computed and returned in the
+    complex domain.
+
+    Parameters
+    ----------
+    n : array_like
+       The integer base(s) in which the log is taken.
+    x : array_like
+       The value(s) whose log base `n` is (are) required.
+
+    Returns
+    -------
+    out : ndarray or scalar
+       The log base `n` of the `x` value(s). If `x` was a scalar, so is
+       `out`, otherwise an array is returned.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> np.set_printoptions(precision=4)
+
+    >>> np.emath.logn(2, [4, 8])
+    array([2., 3.])
+    >>> np.emath.logn(2, [-4, -8, 8])
+    array([2.+4.5324j, 3.+4.5324j, 3.+0.j    ])
+
+    """
+    x = _fix_real_lt_zero(x)
+    n = _fix_real_lt_zero(n)
+    return nx.log(x)/nx.log(n)
+
+
+@array_function_dispatch(_unary_dispatcher)
+def log2(x):
+    """
+    Compute the logarithm base 2 of `x`.
+
+    Return the "principal value" (for a description of this, see
+    `numpy.log2`) of :math:`log_2(x)`. For real `x > 0`, this is
+    a real number (``log2(0)`` returns ``-inf`` and ``log2(np.inf)`` returns
+    ``inf``). Otherwise, the complex principle value is returned.
+
+    Parameters
+    ----------
+    x : array_like
+       The value(s) whose log base 2 is (are) required.
+
+    Returns
+    -------
+    out : ndarray or scalar
+       The log base 2 of the `x` value(s). If `x` was a scalar, so is `out`,
+       otherwise an array is returned.
+
+    See Also
+    --------
+    numpy.log2
+
+    Notes
+    -----
+    For a log2() that returns ``NAN`` when real `x < 0`, use `numpy.log2`
+    (note, however, that otherwise `numpy.log2` and this `log2` are
+    identical, i.e., both return ``-inf`` for `x = 0`, ``inf`` for `x = inf`,
+    and, notably, the complex principle value if ``x.imag != 0``).
+
+    Examples
+    --------
+
+    We set the printing precision so the example can be auto-tested:
+
+    >>> np.set_printoptions(precision=4)
+
+    >>> np.emath.log2(8)
+    3.0
+    >>> np.emath.log2([-4, -8, 8])
+    array([2.+4.5324j, 3.+4.5324j, 3.+0.j    ])
+
+    """
+    x = _fix_real_lt_zero(x)
+    return nx.log2(x)
+
+
+def _power_dispatcher(x, p):
+    return (x, p)
+
+
+@array_function_dispatch(_power_dispatcher)
+def power(x, p):
+    """
+    Return x to the power p, (x**p).
+
+    If `x` contains negative values, the output is converted to the
+    complex domain.
+
+    Parameters
+    ----------
+    x : array_like
+        The input value(s).
+    p : array_like of ints
+        The power(s) to which `x` is raised. If `x` contains multiple values,
+        `p` has to either be a scalar, or contain the same number of values
+        as `x`. In the latter case, the result is
+        ``x[0]**p[0], x[1]**p[1], ...``.
+
+    Returns
+    -------
+    out : ndarray or scalar
+        The result of ``x**p``. If `x` and `p` are scalars, so is `out`,
+        otherwise an array is returned.
+
+    See Also
+    --------
+    numpy.power
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> np.set_printoptions(precision=4)
+
+    >>> np.emath.power(2, 2)
+    4
+
+    >>> np.emath.power([2, 4], 2)
+    array([ 4, 16])
+
+    >>> np.emath.power([2, 4], -2)
+    array([0.25  ,  0.0625])
+
+    >>> np.emath.power([-2, 4], 2)
+    array([ 4.-0.j, 16.+0.j])
+
+    >>> np.emath.power([2, 4], [2, 4])
+    array([ 4, 256])
+
+    """
+    x = _fix_real_lt_zero(x)
+    p = _fix_int_lt_zero(p)
+    return nx.power(x, p)
+
+
+@array_function_dispatch(_unary_dispatcher)
+def arccos(x):
+    """
+    Compute the inverse cosine of x.
+
+    Return the "principal value" (for a description of this, see
+    `numpy.arccos`) of the inverse cosine of `x`. For real `x` such that
+    `abs(x) <= 1`, this is a real number in the closed interval
+    :math:`[0, \\pi]`.  Otherwise, the complex principle value is returned.
+
+    Parameters
+    ----------
+    x : array_like or scalar
+       The value(s) whose arccos is (are) required.
+
+    Returns
+    -------
+    out : ndarray or scalar
+       The inverse cosine(s) of the `x` value(s). If `x` was a scalar, so
+       is `out`, otherwise an array object is returned.
+
+    See Also
+    --------
+    numpy.arccos
+
+    Notes
+    -----
+    For an arccos() that returns ``NAN`` when real `x` is not in the
+    interval ``[-1,1]``, use `numpy.arccos`.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> np.set_printoptions(precision=4)
+
+    >>> np.emath.arccos(1) # a scalar is returned
+    0.0
+
+    >>> np.emath.arccos([1,2])
+    array([0.-0.j   , 0.-1.317j])
+
+    """
+    x = _fix_real_abs_gt_1(x)
+    return nx.arccos(x)
+
+
+@array_function_dispatch(_unary_dispatcher)
+def arcsin(x):
+    """
+    Compute the inverse sine of x.
+
+    Return the "principal value" (for a description of this, see
+    `numpy.arcsin`) of the inverse sine of `x`. For real `x` such that
+    `abs(x) <= 1`, this is a real number in the closed interval
+    :math:`[-\\pi/2, \\pi/2]`.  Otherwise, the complex principle value is
+    returned.
+
+    Parameters
+    ----------
+    x : array_like or scalar
+       The value(s) whose arcsin is (are) required.
+
+    Returns
+    -------
+    out : ndarray or scalar
+       The inverse sine(s) of the `x` value(s). If `x` was a scalar, so
+       is `out`, otherwise an array object is returned.
+
+    See Also
+    --------
+    numpy.arcsin
+
+    Notes
+    -----
+    For an arcsin() that returns ``NAN`` when real `x` is not in the
+    interval ``[-1,1]``, use `numpy.arcsin`.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> np.set_printoptions(precision=4)
+
+    >>> np.emath.arcsin(0)
+    0.0
+
+    >>> np.emath.arcsin([0,1])
+    array([0.    , 1.5708])
+
+    """
+    x = _fix_real_abs_gt_1(x)
+    return nx.arcsin(x)
+
+
+@array_function_dispatch(_unary_dispatcher)
+def arctanh(x):
+    """
+    Compute the inverse hyperbolic tangent of `x`.
+
+    Return the "principal value" (for a description of this, see
+    `numpy.arctanh`) of ``arctanh(x)``. For real `x` such that
+    ``abs(x) < 1``, this is a real number.  If `abs(x) > 1`, or if `x` is
+    complex, the result is complex. Finally, `x = 1` returns``inf`` and
+    ``x=-1`` returns ``-inf``.
+
+    Parameters
+    ----------
+    x : array_like
+       The value(s) whose arctanh is (are) required.
+
+    Returns
+    -------
+    out : ndarray or scalar
+       The inverse hyperbolic tangent(s) of the `x` value(s). If `x` was
+       a scalar so is `out`, otherwise an array is returned.
+
+
+    See Also
+    --------
+    numpy.arctanh
+
+    Notes
+    -----
+    For an arctanh() that returns ``NAN`` when real `x` is not in the
+    interval ``(-1,1)``, use `numpy.arctanh` (this latter, however, does
+    return +/-inf for ``x = +/-1``).
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> np.set_printoptions(precision=4)
+
+    >>> np.emath.arctanh(0.5)
+    0.5493061443340549
+
+    >>> from numpy.testing import suppress_warnings
+    >>> with suppress_warnings() as sup:
+    ...     sup.filter(RuntimeWarning)
+    ...     np.emath.arctanh(np.eye(2))
+    array([[inf,  0.],
+           [ 0., inf]])
+    >>> np.emath.arctanh([1j])
+    array([0.+0.7854j])
+
+    """
+    x = _fix_real_abs_gt_1(x)
+    return nx.arctanh(x)
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/_scimath_impl.pyi b/venv/lib/python3.12/site-packages/numpy/lib/_scimath_impl.pyi
new file mode 100644
index 00000000..589feb15
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/lib/_scimath_impl.pyi
@@ -0,0 +1,94 @@
+from typing import overload, Any
+
+from numpy import complexfloating
+
+from numpy._typing import (
+    NDArray,
+    _ArrayLikeFloat_co,
+    _ArrayLikeComplex_co,
+    _ComplexLike_co,
+    _FloatLike_co,
+)
+
+__all__: list[str]
+
+@overload
+def sqrt(x: _FloatLike_co) -> Any: ...
+@overload
+def sqrt(x: _ComplexLike_co) -> complexfloating[Any, Any]: ...
+@overload
+def sqrt(x: _ArrayLikeFloat_co) -> NDArray[Any]: ...
+@overload
+def sqrt(x: _ArrayLikeComplex_co) -> NDArray[complexfloating[Any, Any]]: ...
+
+@overload
+def log(x: _FloatLike_co) -> Any: ...
+@overload
+def log(x: _ComplexLike_co) -> complexfloating[Any, Any]: ...
+@overload
+def log(x: _ArrayLikeFloat_co) -> NDArray[Any]: ...
+@overload
+def log(x: _ArrayLikeComplex_co) -> NDArray[complexfloating[Any, Any]]: ...
+
+@overload
+def log10(x: _FloatLike_co) -> Any: ...
+@overload
+def log10(x: _ComplexLike_co) -> complexfloating[Any, Any]: ...
+@overload
+def log10(x: _ArrayLikeFloat_co) -> NDArray[Any]: ...
+@overload
+def log10(x: _ArrayLikeComplex_co) -> NDArray[complexfloating[Any, Any]]: ...
+
+@overload
+def log2(x: _FloatLike_co) -> Any: ...
+@overload
+def log2(x: _ComplexLike_co) -> complexfloating[Any, Any]: ...
+@overload
+def log2(x: _ArrayLikeFloat_co) -> NDArray[Any]: ...
+@overload
+def log2(x: _ArrayLikeComplex_co) -> NDArray[complexfloating[Any, Any]]: ...
+
+@overload
+def logn(n: _FloatLike_co, x: _FloatLike_co) -> Any: ...
+@overload
+def logn(n: _ComplexLike_co, x: _ComplexLike_co) -> complexfloating[Any, Any]: ...
+@overload
+def logn(n: _ArrayLikeFloat_co, x: _ArrayLikeFloat_co) -> NDArray[Any]: ...
+@overload
+def logn(n: _ArrayLikeComplex_co, x: _ArrayLikeComplex_co) -> NDArray[complexfloating[Any, Any]]: ...
+
+@overload
+def power(x: _FloatLike_co, p: _FloatLike_co) -> Any: ...
+@overload
+def power(x: _ComplexLike_co, p: _ComplexLike_co) -> complexfloating[Any, Any]: ...
+@overload
+def power(x: _ArrayLikeFloat_co, p: _ArrayLikeFloat_co) -> NDArray[Any]: ...
+@overload
+def power(x: _ArrayLikeComplex_co, p: _ArrayLikeComplex_co) -> NDArray[complexfloating[Any, Any]]: ...
+
+@overload
+def arccos(x: _FloatLike_co) -> Any: ...
+@overload
+def arccos(x: _ComplexLike_co) -> complexfloating[Any, Any]: ...
+@overload
+def arccos(x: _ArrayLikeFloat_co) -> NDArray[Any]: ...
+@overload
+def arccos(x: _ArrayLikeComplex_co) -> NDArray[complexfloating[Any, Any]]: ...
+
+@overload
+def arcsin(x: _FloatLike_co) -> Any: ...
+@overload
+def arcsin(x: _ComplexLike_co) -> complexfloating[Any, Any]: ...
+@overload
+def arcsin(x: _ArrayLikeFloat_co) -> NDArray[Any]: ...
+@overload
+def arcsin(x: _ArrayLikeComplex_co) -> NDArray[complexfloating[Any, Any]]: ...
+
+@overload
+def arctanh(x: _FloatLike_co) -> Any: ...
+@overload
+def arctanh(x: _ComplexLike_co) -> complexfloating[Any, Any]: ...
+@overload
+def arctanh(x: _ArrayLikeFloat_co) -> NDArray[Any]: ...
+@overload
+def arctanh(x: _ArrayLikeComplex_co) -> NDArray[complexfloating[Any, Any]]: ...
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/_shape_base_impl.py b/venv/lib/python3.12/site-packages/numpy/lib/_shape_base_impl.py
new file mode 100644
index 00000000..3e2f2ba7
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/lib/_shape_base_impl.py
@@ -0,0 +1,1306 @@
+import functools
+import warnings
+
+import numpy._core.numeric as _nx
+from numpy._core.numeric import asarray, zeros, zeros_like, array, asanyarray
+from numpy._core.fromnumeric import reshape, transpose
+from numpy._core.multiarray import normalize_axis_index
+from numpy._core._multiarray_umath import _array_converter
+from numpy._core import overrides
+from numpy._core import vstack, atleast_3d
+from numpy._core.numeric import normalize_axis_tuple
+from numpy._core.overrides import set_module
+from numpy._core.shape_base import _arrays_for_stack_dispatcher
+from numpy.lib._index_tricks_impl import ndindex
+from numpy.matrixlib.defmatrix import matrix  # this raises all the right alarm bells
+
+
+__all__ = [
+    'column_stack', 'row_stack', 'dstack', 'array_split', 'split',
+    'hsplit', 'vsplit', 'dsplit', 'apply_over_axes', 'expand_dims',
+    'apply_along_axis', 'kron', 'tile', 'take_along_axis',
+    'put_along_axis'
+    ]
+
+
+array_function_dispatch = functools.partial(
+    overrides.array_function_dispatch, module='numpy')
+
+
+def _make_along_axis_idx(arr_shape, indices, axis):
+    # compute dimensions to iterate over
+    if not _nx.issubdtype(indices.dtype, _nx.integer):
+        raise IndexError('`indices` must be an integer array')
+    if len(arr_shape) != indices.ndim:
+        raise ValueError(
+            "`indices` and `arr` must have the same number of dimensions")
+    shape_ones = (1,) * indices.ndim
+    dest_dims = list(range(axis)) + [None] + list(range(axis+1, indices.ndim))
+
+    # build a fancy index, consisting of orthogonal aranges, with the
+    # requested index inserted at the right location
+    fancy_index = []
+    for dim, n in zip(dest_dims, arr_shape):
+        if dim is None:
+            fancy_index.append(indices)
+        else:
+            ind_shape = shape_ones[:dim] + (-1,) + shape_ones[dim+1:]
+            fancy_index.append(_nx.arange(n).reshape(ind_shape))
+
+    return tuple(fancy_index)
+
+
+def _take_along_axis_dispatcher(arr, indices, axis):
+    return (arr, indices)
+
+
+@array_function_dispatch(_take_along_axis_dispatcher)
+def take_along_axis(arr, indices, axis):
+    """
+    Take values from the input array by matching 1d index and data slices.
+
+    This iterates over matching 1d slices oriented along the specified axis in
+    the index and data arrays, and uses the former to look up values in the
+    latter. These slices can be different lengths.
+
+    Functions returning an index along an axis, like `argsort` and
+    `argpartition`, produce suitable indices for this function.
+
+    .. versionadded:: 1.15.0
+
+    Parameters
+    ----------
+    arr : ndarray (Ni..., M, Nk...)
+        Source array
+    indices : ndarray (Ni..., J, Nk...)
+        Indices to take along each 1d slice of `arr`. This must match the
+        dimension of arr, but dimensions Ni and Nj only need to broadcast
+        against `arr`.
+    axis : int
+        The axis to take 1d slices along. If axis is None, the input array is
+        treated as if it had first been flattened to 1d, for consistency with
+        `sort` and `argsort`.
+
+    Returns
+    -------
+    out: ndarray (Ni..., J, Nk...)
+        The indexed result.
+
+    Notes
+    -----
+    This is equivalent to (but faster than) the following use of `ndindex` and
+    `s_`, which sets each of ``ii`` and ``kk`` to a tuple of indices::
+
+        Ni, M, Nk = a.shape[:axis], a.shape[axis], a.shape[axis+1:]
+        J = indices.shape[axis]  # Need not equal M
+        out = np.empty(Ni + (J,) + Nk)
+
+        for ii in ndindex(Ni):
+            for kk in ndindex(Nk):
+                a_1d       = a      [ii + s_[:,] + kk]
+                indices_1d = indices[ii + s_[:,] + kk]
+                out_1d     = out    [ii + s_[:,] + kk]
+                for j in range(J):
+                    out_1d[j] = a_1d[indices_1d[j]]
+
+    Equivalently, eliminating the inner loop, the last two lines would be::
+
+                out_1d[:] = a_1d[indices_1d]
+
+    See Also
+    --------
+    take : Take along an axis, using the same indices for every 1d slice
+    put_along_axis :
+        Put values into the destination array by matching 1d index and data slices
+
+    Examples
+    --------
+    >>> import numpy as np
+
+    For this sample array
+
+    >>> a = np.array([[10, 30, 20], [60, 40, 50]])
+
+    We can sort either by using sort directly, or argsort and this function
+
+    >>> np.sort(a, axis=1)
+    array([[10, 20, 30],
+           [40, 50, 60]])
+    >>> ai = np.argsort(a, axis=1)
+    >>> ai
+    array([[0, 2, 1],
+           [1, 2, 0]])
+    >>> np.take_along_axis(a, ai, axis=1)
+    array([[10, 20, 30],
+           [40, 50, 60]])
+
+    The same works for max and min, if you maintain the trivial dimension
+    with ``keepdims``:
+
+    >>> np.max(a, axis=1, keepdims=True)
+    array([[30],
+           [60]])
+    >>> ai = np.argmax(a, axis=1, keepdims=True)
+    >>> ai
+    array([[1],
+           [0]])
+    >>> np.take_along_axis(a, ai, axis=1)
+    array([[30],
+           [60]])
+
+    If we want to get the max and min at the same time, we can stack the
+    indices first
+
+    >>> ai_min = np.argmin(a, axis=1, keepdims=True)
+    >>> ai_max = np.argmax(a, axis=1, keepdims=True)
+    >>> ai = np.concatenate([ai_min, ai_max], axis=1)
+    >>> ai
+    array([[0, 1],
+           [1, 0]])
+    >>> np.take_along_axis(a, ai, axis=1)
+    array([[10, 30],
+           [40, 60]])
+    """
+    # normalize inputs
+    if axis is None:
+        if indices.ndim != 1:
+            raise ValueError(
+                'when axis=None, `indices` must have a single dimension.')
+        arr = arr.flat
+        arr_shape = (len(arr),)  # flatiter has no .shape
+        axis = 0
+    else:
+        axis = normalize_axis_index(axis, arr.ndim)
+        arr_shape = arr.shape
+
+    # use the fancy index
+    return arr[_make_along_axis_idx(arr_shape, indices, axis)]
+
+
+def _put_along_axis_dispatcher(arr, indices, values, axis):
+    return (arr, indices, values)
+
+
+@array_function_dispatch(_put_along_axis_dispatcher)
+def put_along_axis(arr, indices, values, axis):
+    """
+    Put values into the destination array by matching 1d index and data slices.
+
+    This iterates over matching 1d slices oriented along the specified axis in
+    the index and data arrays, and uses the former to place values into the
+    latter. These slices can be different lengths.
+
+    Functions returning an index along an axis, like `argsort` and
+    `argpartition`, produce suitable indices for this function.
+
+    .. versionadded:: 1.15.0
+
+    Parameters
+    ----------
+    arr : ndarray (Ni..., M, Nk...)
+        Destination array.
+    indices : ndarray (Ni..., J, Nk...)
+        Indices to change along each 1d slice of `arr`. This must match the
+        dimension of arr, but dimensions in Ni and Nj may be 1 to broadcast
+        against `arr`.
+    values : array_like (Ni..., J, Nk...)
+        values to insert at those indices. Its shape and dimension are
+        broadcast to match that of `indices`.
+    axis : int
+        The axis to take 1d slices along. If axis is None, the destination
+        array is treated as if a flattened 1d view had been created of it.
+
+    Notes
+    -----
+    This is equivalent to (but faster than) the following use of `ndindex` and
+    `s_`, which sets each of ``ii`` and ``kk`` to a tuple of indices::
+
+        Ni, M, Nk = a.shape[:axis], a.shape[axis], a.shape[axis+1:]
+        J = indices.shape[axis]  # Need not equal M
+
+        for ii in ndindex(Ni):
+            for kk in ndindex(Nk):
+                a_1d       = a      [ii + s_[:,] + kk]
+                indices_1d = indices[ii + s_[:,] + kk]
+                values_1d  = values [ii + s_[:,] + kk]
+                for j in range(J):
+                    a_1d[indices_1d[j]] = values_1d[j]
+
+    Equivalently, eliminating the inner loop, the last two lines would be::
+
+                a_1d[indices_1d] = values_1d
+
+    See Also
+    --------
+    take_along_axis :
+        Take values from the input array by matching 1d index and data slices
+
+    Examples
+    --------
+    >>> import numpy as np
+
+    For this sample array
+
+    >>> a = np.array([[10, 30, 20], [60, 40, 50]])
+
+    We can replace the maximum values with:
+
+    >>> ai = np.argmax(a, axis=1, keepdims=True)
+    >>> ai
+    array([[1],
+           [0]])
+    >>> np.put_along_axis(a, ai, 99, axis=1)
+    >>> a
+    array([[10, 99, 20],
+           [99, 40, 50]])
+
+    """
+    # normalize inputs
+    if axis is None:
+        if indices.ndim != 1:
+            raise ValueError(
+                'when axis=None, `indices` must have a single dimension.')
+        arr = arr.flat
+        axis = 0
+        arr_shape = (len(arr),)  # flatiter has no .shape
+    else:
+        axis = normalize_axis_index(axis, arr.ndim)
+        arr_shape = arr.shape
+
+    # use the fancy index
+    arr[_make_along_axis_idx(arr_shape, indices, axis)] = values
+
+
+def _apply_along_axis_dispatcher(func1d, axis, arr, *args, **kwargs):
+    return (arr,)
+
+
+@array_function_dispatch(_apply_along_axis_dispatcher)
+def apply_along_axis(func1d, axis, arr, *args, **kwargs):
+    """
+    Apply a function to 1-D slices along the given axis.
+
+    Execute `func1d(a, *args, **kwargs)` where `func1d` operates on 1-D arrays
+    and `a` is a 1-D slice of `arr` along `axis`.
+
+    This is equivalent to (but faster than) the following use of `ndindex` and
+    `s_`, which sets each of ``ii``, ``jj``, and ``kk`` to a tuple of indices::
+
+        Ni, Nk = a.shape[:axis], a.shape[axis+1:]
+        for ii in ndindex(Ni):
+            for kk in ndindex(Nk):
+                f = func1d(arr[ii + s_[:,] + kk])
+                Nj = f.shape
+                for jj in ndindex(Nj):
+                    out[ii + jj + kk] = f[jj]
+
+    Equivalently, eliminating the inner loop, this can be expressed as::
+
+        Ni, Nk = a.shape[:axis], a.shape[axis+1:]
+        for ii in ndindex(Ni):
+            for kk in ndindex(Nk):
+                out[ii + s_[...,] + kk] = func1d(arr[ii + s_[:,] + kk])
+
+    Parameters
+    ----------
+    func1d : function (M,) -> (Nj...)
+        This function should accept 1-D arrays. It is applied to 1-D
+        slices of `arr` along the specified axis.
+    axis : integer
+        Axis along which `arr` is sliced.
+    arr : ndarray (Ni..., M, Nk...)
+        Input array.
+    args : any
+        Additional arguments to `func1d`.
+    kwargs : any
+        Additional named arguments to `func1d`.
+
+        .. versionadded:: 1.9.0
+
+
+    Returns
+    -------
+    out : ndarray  (Ni..., Nj..., Nk...)
+        The output array. The shape of `out` is identical to the shape of
+        `arr`, except along the `axis` dimension. This axis is removed, and
+        replaced with new dimensions equal to the shape of the return value
+        of `func1d`. So if `func1d` returns a scalar `out` will have one
+        fewer dimensions than `arr`.
+
+    See Also
+    --------
+    apply_over_axes : Apply a function repeatedly over multiple axes.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> def my_func(a):
+    ...     \"\"\"Average first and last element of a 1-D array\"\"\"
+    ...     return (a[0] + a[-1]) * 0.5
+    >>> b = np.array([[1,2,3], [4,5,6], [7,8,9]])
+    >>> np.apply_along_axis(my_func, 0, b)
+    array([4., 5., 6.])
+    >>> np.apply_along_axis(my_func, 1, b)
+    array([2.,  5.,  8.])
+
+    For a function that returns a 1D array, the number of dimensions in
+    `outarr` is the same as `arr`.
+
+    >>> b = np.array([[8,1,7], [4,3,9], [5,2,6]])
+    >>> np.apply_along_axis(sorted, 1, b)
+    array([[1, 7, 8],
+           [3, 4, 9],
+           [2, 5, 6]])
+
+    For a function that returns a higher dimensional array, those dimensions
+    are inserted in place of the `axis` dimension.
+
+    >>> b = np.array([[1,2,3], [4,5,6], [7,8,9]])
+    >>> np.apply_along_axis(np.diag, -1, b)
+    array([[[1, 0, 0],
+            [0, 2, 0],
+            [0, 0, 3]],
+           [[4, 0, 0],
+            [0, 5, 0],
+            [0, 0, 6]],
+           [[7, 0, 0],
+            [0, 8, 0],
+            [0, 0, 9]]])
+    """
+    # handle negative axes
+    conv = _array_converter(arr)
+    arr = conv[0]
+
+    nd = arr.ndim
+    axis = normalize_axis_index(axis, nd)
+
+    # arr, with the iteration axis at the end
+    in_dims = list(range(nd))
+    inarr_view = transpose(arr, in_dims[:axis] + in_dims[axis+1:] + [axis])
+
+    # compute indices for the iteration axes, and append a trailing ellipsis to
+    # prevent 0d arrays decaying to scalars, which fixes gh-8642
+    inds = ndindex(inarr_view.shape[:-1])
+    inds = (ind + (Ellipsis,) for ind in inds)
+
+    # invoke the function on the first item
+    try:
+        ind0 = next(inds)
+    except StopIteration:
+        raise ValueError(
+            'Cannot apply_along_axis when any iteration dimensions are 0'
+        ) from None
+    res = asanyarray(func1d(inarr_view[ind0], *args, **kwargs))
+
+    # build a buffer for storing evaluations of func1d.
+    # remove the requested axis, and add the new ones on the end.
+    # laid out so that each write is contiguous.
+    # for a tuple index inds, buff[inds] = func1d(inarr_view[inds])
+    if not isinstance(res, matrix):
+        buff = zeros_like(res, shape=inarr_view.shape[:-1] + res.shape)
+    else:
+        # Matrices are nasty with reshaping, so do not preserve them here.
+        buff = zeros(inarr_view.shape[:-1] + res.shape, dtype=res.dtype)
+
+    # permutation of axes such that out = buff.transpose(buff_permute)
+    buff_dims = list(range(buff.ndim))
+    buff_permute = (
+        buff_dims[0 : axis] +
+        buff_dims[buff.ndim-res.ndim : buff.ndim] +
+        buff_dims[axis : buff.ndim-res.ndim]
+    )
+
+    # save the first result, then compute and save all remaining results
+    buff[ind0] = res
+    for ind in inds:
+        buff[ind] = asanyarray(func1d(inarr_view[ind], *args, **kwargs))
+
+    res = transpose(buff, buff_permute)
+    return conv.wrap(res)
+
+
+def _apply_over_axes_dispatcher(func, a, axes):
+    return (a,)
+
+
+@array_function_dispatch(_apply_over_axes_dispatcher)
+def apply_over_axes(func, a, axes):
+    """
+    Apply a function repeatedly over multiple axes.
+
+    `func` is called as `res = func(a, axis)`, where `axis` is the first
+    element of `axes`.  The result `res` of the function call must have
+    either the same dimensions as `a` or one less dimension.  If `res`
+    has one less dimension than `a`, a dimension is inserted before
+    `axis`.  The call to `func` is then repeated for each axis in `axes`,
+    with `res` as the first argument.
+
+    Parameters
+    ----------
+    func : function
+        This function must take two arguments, `func(a, axis)`.
+    a : array_like
+        Input array.
+    axes : array_like
+        Axes over which `func` is applied; the elements must be integers.
+
+    Returns
+    -------
+    apply_over_axis : ndarray
+        The output array.  The number of dimensions is the same as `a`,
+        but the shape can be different.  This depends on whether `func`
+        changes the shape of its output with respect to its input.
+
+    See Also
+    --------
+    apply_along_axis :
+        Apply a function to 1-D slices of an array along the given axis.
+
+    Notes
+    -----
+    This function is equivalent to tuple axis arguments to reorderable ufuncs
+    with keepdims=True. Tuple axis arguments to ufuncs have been available since
+    version 1.7.0.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> a = np.arange(24).reshape(2,3,4)
+    >>> a
+    array([[[ 0,  1,  2,  3],
+            [ 4,  5,  6,  7],
+            [ 8,  9, 10, 11]],
+           [[12, 13, 14, 15],
+            [16, 17, 18, 19],
+            [20, 21, 22, 23]]])
+
+    Sum over axes 0 and 2. The result has same number of dimensions
+    as the original array:
+
+    >>> np.apply_over_axes(np.sum, a, [0,2])
+    array([[[ 60],
+            [ 92],
+            [124]]])
+
+    Tuple axis arguments to ufuncs are equivalent:
+
+    >>> np.sum(a, axis=(0,2), keepdims=True)
+    array([[[ 60],
+            [ 92],
+            [124]]])
+
+    """
+    val = asarray(a)
+    N = a.ndim
+    if array(axes).ndim == 0:
+        axes = (axes,)
+    for axis in axes:
+        if axis < 0:
+            axis = N + axis
+        args = (val, axis)
+        res = func(*args)
+        if res.ndim == val.ndim:
+            val = res
+        else:
+            res = expand_dims(res, axis)
+            if res.ndim == val.ndim:
+                val = res
+            else:
+                raise ValueError("function is not returning "
+                                 "an array of the correct shape")
+    return val
+
+
+def _expand_dims_dispatcher(a, axis):
+    return (a,)
+
+
+@array_function_dispatch(_expand_dims_dispatcher)
+def expand_dims(a, axis):
+    """
+    Expand the shape of an array.
+
+    Insert a new axis that will appear at the `axis` position in the expanded
+    array shape.
+
+    Parameters
+    ----------
+    a : array_like
+        Input array.
+    axis : int or tuple of ints
+        Position in the expanded axes where the new axis (or axes) is placed.
+
+        .. deprecated:: 1.13.0
+            Passing an axis where ``axis > a.ndim`` will be treated as
+            ``axis == a.ndim``, and passing ``axis < -a.ndim - 1`` will
+            be treated as ``axis == 0``. This behavior is deprecated.
+
+        .. versionchanged:: 1.18.0
+            A tuple of axes is now supported.  Out of range axes as
+            described above are now forbidden and raise an
+            `~exceptions.AxisError`.
+
+    Returns
+    -------
+    result : ndarray
+        View of `a` with the number of dimensions increased.
+
+    See Also
+    --------
+    squeeze : The inverse operation, removing singleton dimensions
+    reshape : Insert, remove, and combine dimensions, and resize existing ones
+    atleast_1d, atleast_2d, atleast_3d
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> x = np.array([1, 2])
+    >>> x.shape
+    (2,)
+
+    The following is equivalent to ``x[np.newaxis, :]`` or ``x[np.newaxis]``:
+
+    >>> y = np.expand_dims(x, axis=0)
+    >>> y
+    array([[1, 2]])
+    >>> y.shape
+    (1, 2)
+
+    The following is equivalent to ``x[:, np.newaxis]``:
+
+    >>> y = np.expand_dims(x, axis=1)
+    >>> y
+    array([[1],
+           [2]])
+    >>> y.shape
+    (2, 1)
+
+    ``axis`` may also be a tuple:
+
+    >>> y = np.expand_dims(x, axis=(0, 1))
+    >>> y
+    array([[[1, 2]]])
+
+    >>> y = np.expand_dims(x, axis=(2, 0))
+    >>> y
+    array([[[1],
+            [2]]])
+
+    Note that some examples may use ``None`` instead of ``np.newaxis``.  These
+    are the same objects:
+
+    >>> np.newaxis is None
+    True
+
+    """
+    if isinstance(a, matrix):
+        a = asarray(a)
+    else:
+        a = asanyarray(a)
+
+    if type(axis) not in (tuple, list):
+        axis = (axis,)
+
+    out_ndim = len(axis) + a.ndim
+    axis = normalize_axis_tuple(axis, out_ndim)
+
+    shape_it = iter(a.shape)
+    shape = [1 if ax in axis else next(shape_it) for ax in range(out_ndim)]
+
+    return a.reshape(shape)
+
+
+# NOTE: Remove once deprecation period passes
+@set_module("numpy")
+def row_stack(tup, *, dtype=None, casting="same_kind"):
+    # Deprecated in NumPy 2.0, 2023-08-18
+    warnings.warn(
+        "`row_stack` alias is deprecated. "
+        "Use `np.vstack` directly.",
+        DeprecationWarning,
+        stacklevel=2
+    )
+    return vstack(tup, dtype=dtype, casting=casting)
+
+
+row_stack.__doc__ = vstack.__doc__
+
+
+def _column_stack_dispatcher(tup):
+    return _arrays_for_stack_dispatcher(tup)
+
+
+@array_function_dispatch(_column_stack_dispatcher)
+def column_stack(tup):
+    """
+    Stack 1-D arrays as columns into a 2-D array.
+
+    Take a sequence of 1-D arrays and stack them as columns
+    to make a single 2-D array. 2-D arrays are stacked as-is,
+    just like with `hstack`.  1-D arrays are turned into 2-D columns
+    first.
+
+    Parameters
+    ----------
+    tup : sequence of 1-D or 2-D arrays.
+        Arrays to stack. All of them must have the same first dimension.
+
+    Returns
+    -------
+    stacked : 2-D array
+        The array formed by stacking the given arrays.
+
+    See Also
+    --------
+    stack, hstack, vstack, concatenate
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> a = np.array((1,2,3))
+    >>> b = np.array((2,3,4))
+    >>> np.column_stack((a,b))
+    array([[1, 2],
+           [2, 3],
+           [3, 4]])
+
+    """
+    arrays = []
+    for v in tup:
+        arr = asanyarray(v)
+        if arr.ndim < 2:
+            arr = array(arr, copy=None, subok=True, ndmin=2).T
+        arrays.append(arr)
+    return _nx.concatenate(arrays, 1)
+
+
+def _dstack_dispatcher(tup):
+    return _arrays_for_stack_dispatcher(tup)
+
+
+@array_function_dispatch(_dstack_dispatcher)
+def dstack(tup):
+    """
+    Stack arrays in sequence depth wise (along third axis).
+
+    This is equivalent to concatenation along the third axis after 2-D arrays
+    of shape `(M,N)` have been reshaped to `(M,N,1)` and 1-D arrays of shape
+    `(N,)` have been reshaped to `(1,N,1)`. Rebuilds arrays divided by
+    `dsplit`.
+
+    This function makes most sense for arrays with up to 3 dimensions. For
+    instance, for pixel-data with a height (first axis), width (second axis),
+    and r/g/b channels (third axis). The functions `concatenate`, `stack` and
+    `block` provide more general stacking and concatenation operations.
+
+    Parameters
+    ----------
+    tup : sequence of arrays
+        The arrays must have the same shape along all but the third axis.
+        1-D or 2-D arrays must have the same shape.
+
+    Returns
+    -------
+    stacked : ndarray
+        The array formed by stacking the given arrays, will be at least 3-D.
+
+    See Also
+    --------
+    concatenate : Join a sequence of arrays along an existing axis.
+    stack : Join a sequence of arrays along a new axis.
+    block : Assemble an nd-array from nested lists of blocks.
+    vstack : Stack arrays in sequence vertically (row wise).
+    hstack : Stack arrays in sequence horizontally (column wise).
+    column_stack : Stack 1-D arrays as columns into a 2-D array.
+    dsplit : Split array along third axis.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> a = np.array((1,2,3))
+    >>> b = np.array((2,3,4))
+    >>> np.dstack((a,b))
+    array([[[1, 2],
+            [2, 3],
+            [3, 4]]])
+
+    >>> a = np.array([[1],[2],[3]])
+    >>> b = np.array([[2],[3],[4]])
+    >>> np.dstack((a,b))
+    array([[[1, 2]],
+           [[2, 3]],
+           [[3, 4]]])
+
+    """
+    arrs = atleast_3d(*tup)
+    if not isinstance(arrs, tuple):
+        arrs = (arrs,)
+    return _nx.concatenate(arrs, 2)
+
+
+def _replace_zero_by_x_arrays(sub_arys):
+    for i in range(len(sub_arys)):
+        if _nx.ndim(sub_arys[i]) == 0:
+            sub_arys[i] = _nx.empty(0, dtype=sub_arys[i].dtype)
+        elif _nx.sometrue(_nx.equal(_nx.shape(sub_arys[i]), 0)):
+            sub_arys[i] = _nx.empty(0, dtype=sub_arys[i].dtype)
+    return sub_arys
+
+
+def _array_split_dispatcher(ary, indices_or_sections, axis=None):
+    return (ary, indices_or_sections)
+
+
+@array_function_dispatch(_array_split_dispatcher)
+def array_split(ary, indices_or_sections, axis=0):
+    """
+    Split an array into multiple sub-arrays.
+
+    Please refer to the ``split`` documentation.  The only difference
+    between these functions is that ``array_split`` allows
+    `indices_or_sections` to be an integer that does *not* equally
+    divide the axis. For an array of length l that should be split
+    into n sections, it returns l % n sub-arrays of size l//n + 1
+    and the rest of size l//n.
+
+    See Also
+    --------
+    split : Split array into multiple sub-arrays of equal size.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> x = np.arange(8.0)
+    >>> np.array_split(x, 3)
+    [array([0.,  1.,  2.]), array([3.,  4.,  5.]), array([6.,  7.])]
+
+    >>> x = np.arange(9)
+    >>> np.array_split(x, 4)
+    [array([0, 1, 2]), array([3, 4]), array([5, 6]), array([7, 8])]
+
+    """
+    try:
+        Ntotal = ary.shape[axis]
+    except AttributeError:
+        Ntotal = len(ary)
+    try:
+        # handle array case.
+        Nsections = len(indices_or_sections) + 1
+        div_points = [0] + list(indices_or_sections) + [Ntotal]
+    except TypeError:
+        # indices_or_sections is a scalar, not an array.
+        Nsections = int(indices_or_sections)
+        if Nsections <= 0:
+            raise ValueError('number sections must be larger than 0.') from None
+        Neach_section, extras = divmod(Ntotal, Nsections)
+        section_sizes = ([0] +
+                         extras * [Neach_section+1] +
+                         (Nsections-extras) * [Neach_section])
+        div_points = _nx.array(section_sizes, dtype=_nx.intp).cumsum()
+
+    sub_arys = []
+    sary = _nx.swapaxes(ary, axis, 0)
+    for i in range(Nsections):
+        st = div_points[i]
+        end = div_points[i + 1]
+        sub_arys.append(_nx.swapaxes(sary[st:end], axis, 0))
+
+    return sub_arys
+
+
+def _split_dispatcher(ary, indices_or_sections, axis=None):
+    return (ary, indices_or_sections)
+
+
+@array_function_dispatch(_split_dispatcher)
+def split(ary, indices_or_sections, axis=0):
+    """
+    Split an array into multiple sub-arrays as views into `ary`.
+
+    Parameters
+    ----------
+    ary : ndarray
+        Array to be divided into sub-arrays.
+    indices_or_sections : int or 1-D array
+        If `indices_or_sections` is an integer, N, the array will be divided
+        into N equal arrays along `axis`.  If such a split is not possible,
+        an error is raised.
+
+        If `indices_or_sections` is a 1-D array of sorted integers, the entries
+        indicate where along `axis` the array is split.  For example,
+        ``[2, 3]`` would, for ``axis=0``, result in
+
+        - ary[:2]
+        - ary[2:3]
+        - ary[3:]
+
+        If an index exceeds the dimension of the array along `axis`,
+        an empty sub-array is returned correspondingly.
+    axis : int, optional
+        The axis along which to split, default is 0.
+
+    Returns
+    -------
+    sub-arrays : list of ndarrays
+        A list of sub-arrays as views into `ary`.
+
+    Raises
+    ------
+    ValueError
+        If `indices_or_sections` is given as an integer, but
+        a split does not result in equal division.
+
+    See Also
+    --------
+    array_split : Split an array into multiple sub-arrays of equal or
+                  near-equal size.  Does not raise an exception if
+                  an equal division cannot be made.
+    hsplit : Split array into multiple sub-arrays horizontally (column-wise).
+    vsplit : Split array into multiple sub-arrays vertically (row wise).
+    dsplit : Split array into multiple sub-arrays along the 3rd axis (depth).
+    concatenate : Join a sequence of arrays along an existing axis.
+    stack : Join a sequence of arrays along a new axis.
+    hstack : Stack arrays in sequence horizontally (column wise).
+    vstack : Stack arrays in sequence vertically (row wise).
+    dstack : Stack arrays in sequence depth wise (along third dimension).
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> x = np.arange(9.0)
+    >>> np.split(x, 3)
+    [array([0.,  1.,  2.]), array([3.,  4.,  5.]), array([6.,  7.,  8.])]
+
+    >>> x = np.arange(8.0)
+    >>> np.split(x, [3, 5, 6, 10])
+    [array([0.,  1.,  2.]),
+     array([3.,  4.]),
+     array([5.]),
+     array([6.,  7.]),
+     array([], dtype=float64)]
+
+    """
+    try:
+        len(indices_or_sections)
+    except TypeError:
+        sections = indices_or_sections
+        N = ary.shape[axis]
+        if N % sections:
+            raise ValueError(
+                'array split does not result in an equal division') from None
+    return array_split(ary, indices_or_sections, axis)
+
+
+def _hvdsplit_dispatcher(ary, indices_or_sections):
+    return (ary, indices_or_sections)
+
+
+@array_function_dispatch(_hvdsplit_dispatcher)
+def hsplit(ary, indices_or_sections):
+    """
+    Split an array into multiple sub-arrays horizontally (column-wise).
+
+    Please refer to the `split` documentation.  `hsplit` is equivalent
+    to `split` with ``axis=1``, the array is always split along the second
+    axis except for 1-D arrays, where it is split at ``axis=0``.
+
+    See Also
+    --------
+    split : Split an array into multiple sub-arrays of equal size.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> x = np.arange(16.0).reshape(4, 4)
+    >>> x
+    array([[ 0.,   1.,   2.,   3.],
+           [ 4.,   5.,   6.,   7.],
+           [ 8.,   9.,  10.,  11.],
+           [12.,  13.,  14.,  15.]])
+    >>> np.hsplit(x, 2)
+    [array([[  0.,   1.],
+           [  4.,   5.],
+           [  8.,   9.],
+           [12.,  13.]]),
+     array([[  2.,   3.],
+           [  6.,   7.],
+           [10.,  11.],
+           [14.,  15.]])]
+    >>> np.hsplit(x, np.array([3, 6]))
+    [array([[ 0.,   1.,   2.],
+           [ 4.,   5.,   6.],
+           [ 8.,   9.,  10.],
+           [12.,  13.,  14.]]),
+     array([[ 3.],
+           [ 7.],
+           [11.],
+           [15.]]),
+     array([], shape=(4, 0), dtype=float64)]
+
+    With a higher dimensional array the split is still along the second axis.
+
+    >>> x = np.arange(8.0).reshape(2, 2, 2)
+    >>> x
+    array([[[0.,  1.],
+            [2.,  3.]],
+           [[4.,  5.],
+            [6.,  7.]]])
+    >>> np.hsplit(x, 2)
+    [array([[[0.,  1.]],
+           [[4.,  5.]]]),
+     array([[[2.,  3.]],
+           [[6.,  7.]]])]
+
+    With a 1-D array, the split is along axis 0.
+
+    >>> x = np.array([0, 1, 2, 3, 4, 5])
+    >>> np.hsplit(x, 2)
+    [array([0, 1, 2]), array([3, 4, 5])]
+
+    """
+    if _nx.ndim(ary) == 0:
+        raise ValueError('hsplit only works on arrays of 1 or more dimensions')
+    if ary.ndim > 1:
+        return split(ary, indices_or_sections, 1)
+    else:
+        return split(ary, indices_or_sections, 0)
+
+
+@array_function_dispatch(_hvdsplit_dispatcher)
+def vsplit(ary, indices_or_sections):
+    """
+    Split an array into multiple sub-arrays vertically (row-wise).
+
+    Please refer to the ``split`` documentation.  ``vsplit`` is equivalent
+    to ``split`` with `axis=0` (default), the array is always split along the
+    first axis regardless of the array dimension.
+
+    See Also
+    --------
+    split : Split an array into multiple sub-arrays of equal size.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> x = np.arange(16.0).reshape(4, 4)
+    >>> x
+    array([[ 0.,   1.,   2.,   3.],
+           [ 4.,   5.,   6.,   7.],
+           [ 8.,   9.,  10.,  11.],
+           [12.,  13.,  14.,  15.]])
+    >>> np.vsplit(x, 2)
+    [array([[0., 1., 2., 3.],
+            [4., 5., 6., 7.]]),
+     array([[ 8.,  9., 10., 11.],
+            [12., 13., 14., 15.]])]
+    >>> np.vsplit(x, np.array([3, 6]))
+    [array([[ 0.,  1.,  2.,  3.],
+            [ 4.,  5.,  6.,  7.],
+            [ 8.,  9., 10., 11.]]),
+     array([[12., 13., 14., 15.]]),
+     array([], shape=(0, 4), dtype=float64)]
+
+    With a higher dimensional array the split is still along the first axis.
+
+    >>> x = np.arange(8.0).reshape(2, 2, 2)
+    >>> x
+    array([[[0.,  1.],
+            [2.,  3.]],
+           [[4.,  5.],
+            [6.,  7.]]])
+    >>> np.vsplit(x, 2)
+    [array([[[0., 1.],
+             [2., 3.]]]),
+     array([[[4., 5.],
+             [6., 7.]]])]
+
+    """
+    if _nx.ndim(ary) < 2:
+        raise ValueError('vsplit only works on arrays of 2 or more dimensions')
+    return split(ary, indices_or_sections, 0)
+
+
+@array_function_dispatch(_hvdsplit_dispatcher)
+def dsplit(ary, indices_or_sections):
+    """
+    Split array into multiple sub-arrays along the 3rd axis (depth).
+
+    Please refer to the `split` documentation.  `dsplit` is equivalent
+    to `split` with ``axis=2``, the array is always split along the third
+    axis provided the array dimension is greater than or equal to 3.
+
+    See Also
+    --------
+    split : Split an array into multiple sub-arrays of equal size.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> x = np.arange(16.0).reshape(2, 2, 4)
+    >>> x
+    array([[[ 0.,   1.,   2.,   3.],
+            [ 4.,   5.,   6.,   7.]],
+           [[ 8.,   9.,  10.,  11.],
+            [12.,  13.,  14.,  15.]]])
+    >>> np.dsplit(x, 2)
+    [array([[[ 0.,  1.],
+            [ 4.,  5.]],
+           [[ 8.,  9.],
+            [12., 13.]]]), array([[[ 2.,  3.],
+            [ 6.,  7.]],
+           [[10., 11.],
+            [14., 15.]]])]
+    >>> np.dsplit(x, np.array([3, 6]))
+    [array([[[ 0.,   1.,   2.],
+            [ 4.,   5.,   6.]],
+           [[ 8.,   9.,  10.],
+            [12.,  13.,  14.]]]),
+     array([[[ 3.],
+            [ 7.]],
+           [[11.],
+            [15.]]]),
+    array([], shape=(2, 2, 0), dtype=float64)]
+    """
+    if _nx.ndim(ary) < 3:
+        raise ValueError('dsplit only works on arrays of 3 or more dimensions')
+    return split(ary, indices_or_sections, 2)
+
+
+def get_array_wrap(*args):
+    """Find the wrapper for the array with the highest priority.
+
+    In case of ties, leftmost wins. If no wrapper is found, return None.
+
+    .. deprecated:: 2.0
+    """
+
+    # Deprecated in NumPy 2.0, 2023-07-11
+    warnings.warn(
+        "`get_array_wrap` is deprecated. "
+        "(deprecated in NumPy 2.0)",
+        DeprecationWarning,
+        stacklevel=2
+    )
+
+    wrappers = sorted((getattr(x, '__array_priority__', 0), -i,
+                 x.__array_wrap__) for i, x in enumerate(args)
+                                   if hasattr(x, '__array_wrap__'))
+    if wrappers:
+        return wrappers[-1][-1]
+    return None
+
+
+def _kron_dispatcher(a, b):
+    return (a, b)
+
+
+@array_function_dispatch(_kron_dispatcher)
+def kron(a, b):
+    """
+    Kronecker product of two arrays.
+
+    Computes the Kronecker product, a composite array made of blocks of the
+    second array scaled by the first.
+
+    Parameters
+    ----------
+    a, b : array_like
+
+    Returns
+    -------
+    out : ndarray
+
+    See Also
+    --------
+    outer : The outer product
+
+    Notes
+    -----
+    The function assumes that the number of dimensions of `a` and `b`
+    are the same, if necessary prepending the smallest with ones.
+    If ``a.shape = (r0,r1,..,rN)`` and ``b.shape = (s0,s1,...,sN)``,
+    the Kronecker product has shape ``(r0*s0, r1*s1, ..., rN*SN)``.
+    The elements are products of elements from `a` and `b`, organized
+    explicitly by::
+
+        kron(a,b)[k0,k1,...,kN] = a[i0,i1,...,iN] * b[j0,j1,...,jN]
+
+    where::
+
+        kt = it * st + jt,  t = 0,...,N
+
+    In the common 2-D case (N=1), the block structure can be visualized::
+
+        [[ a[0,0]*b,   a[0,1]*b,  ... , a[0,-1]*b  ],
+         [  ...                              ...   ],
+         [ a[-1,0]*b,  a[-1,1]*b, ... , a[-1,-1]*b ]]
+
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> np.kron([1,10,100], [5,6,7])
+    array([  5,   6,   7, ..., 500, 600, 700])
+    >>> np.kron([5,6,7], [1,10,100])
+    array([  5,  50, 500, ...,   7,  70, 700])
+
+    >>> np.kron(np.eye(2), np.ones((2,2)))
+    array([[1.,  1.,  0.,  0.],
+           [1.,  1.,  0.,  0.],
+           [0.,  0.,  1.,  1.],
+           [0.,  0.,  1.,  1.]])
+
+    >>> a = np.arange(100).reshape((2,5,2,5))
+    >>> b = np.arange(24).reshape((2,3,4))
+    >>> c = np.kron(a,b)
+    >>> c.shape
+    (2, 10, 6, 20)
+    >>> I = (1,3,0,2)
+    >>> J = (0,2,1)
+    >>> J1 = (0,) + J             # extend to ndim=4
+    >>> S1 = (1,) + b.shape
+    >>> K = tuple(np.array(I) * np.array(S1) + np.array(J1))
+    >>> c[K] == a[I]*b[J]
+    True
+
+    """
+    # Working:
+    # 1. Equalise the shapes by prepending smaller array with 1s
+    # 2. Expand shapes of both the arrays by adding new axes at
+    #    odd positions for 1st array and even positions for 2nd
+    # 3. Compute the product of the modified array
+    # 4. The inner most array elements now contain the rows of
+    #    the Kronecker product
+    # 5. Reshape the result to kron's shape, which is same as
+    #    product of shapes of the two arrays.
+    b = asanyarray(b)
+    a = array(a, copy=None, subok=True, ndmin=b.ndim)
+    is_any_mat = isinstance(a, matrix) or isinstance(b, matrix)
+    ndb, nda = b.ndim, a.ndim
+    nd = max(ndb, nda)
+
+    if (nda == 0 or ndb == 0):
+        return _nx.multiply(a, b)
+
+    as_ = a.shape
+    bs = b.shape
+    if not a.flags.contiguous:
+        a = reshape(a, as_)
+    if not b.flags.contiguous:
+        b = reshape(b, bs)
+
+    # Equalise the shapes by prepending smaller one with 1s
+    as_ = (1,)*max(0, ndb-nda) + as_
+    bs = (1,)*max(0, nda-ndb) + bs
+
+    # Insert empty dimensions
+    a_arr = expand_dims(a, axis=tuple(range(ndb-nda)))
+    b_arr = expand_dims(b, axis=tuple(range(nda-ndb)))
+
+    # Compute the product
+    a_arr = expand_dims(a_arr, axis=tuple(range(1, nd*2, 2)))
+    b_arr = expand_dims(b_arr, axis=tuple(range(0, nd*2, 2)))
+    # In case of `mat`, convert result to `array`
+    result = _nx.multiply(a_arr, b_arr, subok=(not is_any_mat))
+
+    # Reshape back
+    result = result.reshape(_nx.multiply(as_, bs))
+
+    return result if not is_any_mat else matrix(result, copy=False)
+
+
+def _tile_dispatcher(A, reps):
+    return (A, reps)
+
+
+@array_function_dispatch(_tile_dispatcher)
+def tile(A, reps):
+    """
+    Construct an array by repeating A the number of times given by reps.
+
+    If `reps` has length ``d``, the result will have dimension of
+    ``max(d, A.ndim)``.
+
+    If ``A.ndim < d``, `A` is promoted to be d-dimensional by prepending new
+    axes. So a shape (3,) array is promoted to (1, 3) for 2-D replication,
+    or shape (1, 1, 3) for 3-D replication. If this is not the desired
+    behavior, promote `A` to d-dimensions manually before calling this
+    function.
+
+    If ``A.ndim > d``, `reps` is promoted to `A`.ndim by prepending 1's to it.
+    Thus for an `A` of shape (2, 3, 4, 5), a `reps` of (2, 2) is treated as
+    (1, 1, 2, 2).
+
+    Note : Although tile may be used for broadcasting, it is strongly
+    recommended to use numpy's broadcasting operations and functions.
+
+    Parameters
+    ----------
+    A : array_like
+        The input array.
+    reps : array_like
+        The number of repetitions of `A` along each axis.
+
+    Returns
+    -------
+    c : ndarray
+        The tiled output array.
+
+    See Also
+    --------
+    repeat : Repeat elements of an array.
+    broadcast_to : Broadcast an array to a new shape
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> a = np.array([0, 1, 2])
+    >>> np.tile(a, 2)
+    array([0, 1, 2, 0, 1, 2])
+    >>> np.tile(a, (2, 2))
+    array([[0, 1, 2, 0, 1, 2],
+           [0, 1, 2, 0, 1, 2]])
+    >>> np.tile(a, (2, 1, 2))
+    array([[[0, 1, 2, 0, 1, 2]],
+           [[0, 1, 2, 0, 1, 2]]])
+
+    >>> b = np.array([[1, 2], [3, 4]])
+    >>> np.tile(b, 2)
+    array([[1, 2, 1, 2],
+           [3, 4, 3, 4]])
+    >>> np.tile(b, (2, 1))
+    array([[1, 2],
+           [3, 4],
+           [1, 2],
+           [3, 4]])
+
+    >>> c = np.array([1,2,3,4])
+    >>> np.tile(c,(4,1))
+    array([[1, 2, 3, 4],
+           [1, 2, 3, 4],
+           [1, 2, 3, 4],
+           [1, 2, 3, 4]])
+    """
+    try:
+        tup = tuple(reps)
+    except TypeError:
+        tup = (reps,)
+    d = len(tup)
+    if all(x == 1 for x in tup) and isinstance(A, _nx.ndarray):
+        # Fixes the problem that the function does not make a copy if A is a
+        # numpy array and the repetitions are 1 in all dimensions
+        return _nx.array(A, copy=True, subok=True, ndmin=d)
+    else:
+        # Note that no copy of zero-sized arrays is made. However since they
+        # have no data there is no risk of an inadvertent overwrite.
+        c = _nx.array(A, copy=None, subok=True, ndmin=d)
+    if (d < c.ndim):
+        tup = (1,)*(c.ndim-d) + tup
+    shape_out = tuple(s*t for s, t in zip(c.shape, tup))
+    n = c.size
+    if n > 0:
+        for dim_in, nrep in zip(c.shape, tup):
+            if nrep != 1:
+                c = c.reshape(-1, n).repeat(nrep, 0)
+            n //= dim_in
+    return c.reshape(shape_out)
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/_shape_base_impl.pyi b/venv/lib/python3.12/site-packages/numpy/lib/_shape_base_impl.pyi
new file mode 100644
index 00000000..c765e1e5
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/lib/_shape_base_impl.pyi
@@ -0,0 +1,204 @@
+from collections.abc import Callable, Sequence
+from typing import (
+    TypeVar,
+    Any,
+    overload,
+    SupportsIndex,
+    Protocol,
+    ParamSpec,
+    Concatenate,
+)
+
+import numpy as np
+from numpy import (
+    generic,
+    integer,
+    ufunc,
+    unsignedinteger,
+    signedinteger,
+    floating,
+    complexfloating,
+    object_,
+)
+
+from numpy._typing import (
+    ArrayLike,
+    NDArray,
+    _ShapeLike,
+    _ArrayLike,
+    _ArrayLikeBool_co,
+    _ArrayLikeUInt_co,
+    _ArrayLikeInt_co,
+    _ArrayLikeFloat_co,
+    _ArrayLikeComplex_co,
+    _ArrayLikeObject_co,
+)
+
+from numpy._core.shape_base import vstack
+
+_P = ParamSpec("_P")
+_SCT = TypeVar("_SCT", bound=generic)
+
+# Signature of `__array_wrap__`
+class _ArrayWrap(Protocol):
+    def __call__(
+        self,
+        array: NDArray[Any],
+        context: None | tuple[ufunc, tuple[Any, ...], int] = ...,
+        return_scalar: bool = ...,
+        /,
+    ) -> Any: ...
+
+class _SupportsArrayWrap(Protocol):
+    @property
+    def __array_wrap__(self) -> _ArrayWrap: ...
+
+
+__all__: list[str]
+
+def take_along_axis(
+    arr: _SCT | NDArray[_SCT],
+    indices: NDArray[integer[Any]],
+    axis: None | int,
+) -> NDArray[_SCT]: ...
+
+def put_along_axis(
+    arr: NDArray[_SCT],
+    indices: NDArray[integer[Any]],
+    values: ArrayLike,
+    axis: None | int,
+) -> None: ...
+
+@overload
+def apply_along_axis(
+    func1d: Callable[Concatenate[NDArray[Any], _P], _ArrayLike[_SCT]],
+    axis: SupportsIndex,
+    arr: ArrayLike,
+    *args: _P.args,
+    **kwargs: _P.kwargs,
+) -> NDArray[_SCT]: ...
+@overload
+def apply_along_axis(
+    func1d: Callable[Concatenate[NDArray[Any], _P], ArrayLike],
+    axis: SupportsIndex,
+    arr: ArrayLike,
+    *args: _P.args,
+    **kwargs: _P.kwargs,
+) -> NDArray[Any]: ...
+
+def apply_over_axes(
+    func: Callable[[NDArray[Any], int], NDArray[_SCT]],
+    a: ArrayLike,
+    axes: int | Sequence[int],
+) -> NDArray[_SCT]: ...
+
+@overload
+def expand_dims(
+    a: _ArrayLike[_SCT],
+    axis: _ShapeLike,
+) -> NDArray[_SCT]: ...
+@overload
+def expand_dims(
+    a: ArrayLike,
+    axis: _ShapeLike,
+) -> NDArray[Any]: ...
+
+@overload
+def column_stack(tup: Sequence[_ArrayLike[_SCT]]) -> NDArray[_SCT]: ...
+@overload
+def column_stack(tup: Sequence[ArrayLike]) -> NDArray[Any]: ...
+
+@overload
+def dstack(tup: Sequence[_ArrayLike[_SCT]]) -> NDArray[_SCT]: ...
+@overload
+def dstack(tup: Sequence[ArrayLike]) -> NDArray[Any]: ...
+
+@overload
+def array_split(
+    ary: _ArrayLike[_SCT],
+    indices_or_sections: _ShapeLike,
+    axis: SupportsIndex = ...,
+) -> list[NDArray[_SCT]]: ...
+@overload
+def array_split(
+    ary: ArrayLike,
+    indices_or_sections: _ShapeLike,
+    axis: SupportsIndex = ...,
+) -> list[NDArray[Any]]: ...
+
+@overload
+def split(
+    ary: _ArrayLike[_SCT],
+    indices_or_sections: _ShapeLike,
+    axis: SupportsIndex = ...,
+) -> list[NDArray[_SCT]]: ...
+@overload
+def split(
+    ary: ArrayLike,
+    indices_or_sections: _ShapeLike,
+    axis: SupportsIndex = ...,
+) -> list[NDArray[Any]]: ...
+
+@overload
+def hsplit(
+    ary: _ArrayLike[_SCT],
+    indices_or_sections: _ShapeLike,
+) -> list[NDArray[_SCT]]: ...
+@overload
+def hsplit(
+    ary: ArrayLike,
+    indices_or_sections: _ShapeLike,
+) -> list[NDArray[Any]]: ...
+
+@overload
+def vsplit(
+    ary: _ArrayLike[_SCT],
+    indices_or_sections: _ShapeLike,
+) -> list[NDArray[_SCT]]: ...
+@overload
+def vsplit(
+    ary: ArrayLike,
+    indices_or_sections: _ShapeLike,
+) -> list[NDArray[Any]]: ...
+
+@overload
+def dsplit(
+    ary: _ArrayLike[_SCT],
+    indices_or_sections: _ShapeLike,
+) -> list[NDArray[_SCT]]: ...
+@overload
+def dsplit(
+    ary: ArrayLike,
+    indices_or_sections: _ShapeLike,
+) -> list[NDArray[Any]]: ...
+
+@overload
+def get_array_wrap(*args: _SupportsArrayWrap) -> _ArrayWrap: ...
+@overload
+def get_array_wrap(*args: object) -> None | _ArrayWrap: ...
+
+@overload
+def kron(a: _ArrayLikeBool_co, b: _ArrayLikeBool_co) -> NDArray[np.bool]: ...  # type: ignore[misc]
+@overload
+def kron(a: _ArrayLikeUInt_co, b: _ArrayLikeUInt_co) -> NDArray[unsignedinteger[Any]]: ...  # type: ignore[misc]
+@overload
+def kron(a: _ArrayLikeInt_co, b: _ArrayLikeInt_co) -> NDArray[signedinteger[Any]]: ...  # type: ignore[misc]
+@overload
+def kron(a: _ArrayLikeFloat_co, b: _ArrayLikeFloat_co) -> NDArray[floating[Any]]: ...  # type: ignore[misc]
+@overload
+def kron(a: _ArrayLikeComplex_co, b: _ArrayLikeComplex_co) -> NDArray[complexfloating[Any, Any]]: ...
+@overload
+def kron(a: _ArrayLikeObject_co, b: Any) -> NDArray[object_]: ...
+@overload
+def kron(a: Any, b: _ArrayLikeObject_co) -> NDArray[object_]: ...
+
+@overload
+def tile(
+    A: _ArrayLike[_SCT],
+    reps: int | Sequence[int],
+) -> NDArray[_SCT]: ...
+@overload
+def tile(
+    A: ArrayLike,
+    reps: int | Sequence[int],
+) -> NDArray[Any]: ...
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/_stride_tricks_impl.py b/venv/lib/python3.12/site-packages/numpy/lib/_stride_tricks_impl.py
new file mode 100644
index 00000000..def62523
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/lib/_stride_tricks_impl.py
@@ -0,0 +1,563 @@
+"""
+Utilities that manipulate strides to achieve desirable effects.
+
+An explanation of strides can be found in the :ref:`arrays.ndarray`.
+
+Functions
+---------
+
+.. autosummary::
+   :toctree: generated/
+
+"""
+import numpy as np
+from numpy._core.numeric import normalize_axis_tuple
+from numpy._core.overrides import array_function_dispatch, set_module
+
+__all__ = ['broadcast_to', 'broadcast_arrays', 'broadcast_shapes']
+
+
+class DummyArray:
+    """Dummy object that just exists to hang __array_interface__ dictionaries
+    and possibly keep alive a reference to a base array.
+    """
+
+    def __init__(self, interface, base=None):
+        self.__array_interface__ = interface
+        self.base = base
+
+
+def _maybe_view_as_subclass(original_array, new_array):
+    if type(original_array) is not type(new_array):
+        # if input was an ndarray subclass and subclasses were OK,
+        # then view the result as that subclass.
+        new_array = new_array.view(type=type(original_array))
+        # Since we have done something akin to a view from original_array, we
+        # should let the subclass finalize (if it has it implemented, i.e., is
+        # not None).
+        if new_array.__array_finalize__:
+            new_array.__array_finalize__(original_array)
+    return new_array
+
+
+@set_module("numpy.lib.stride_tricks")
+def as_strided(x, shape=None, strides=None, subok=False, writeable=True):
+    """
+    Create a view into the array with the given shape and strides.
+
+    .. warning:: This function has to be used with extreme care, see notes.
+
+    Parameters
+    ----------
+    x : ndarray
+        Array to create a new.
+    shape : sequence of int, optional
+        The shape of the new array. Defaults to ``x.shape``.
+    strides : sequence of int, optional
+        The strides of the new array. Defaults to ``x.strides``.
+    subok : bool, optional
+        .. versionadded:: 1.10
+
+        If True, subclasses are preserved.
+    writeable : bool, optional
+        .. versionadded:: 1.12
+
+        If set to False, the returned array will always be readonly.
+        Otherwise it will be writable if the original array was. It
+        is advisable to set this to False if possible (see Notes).
+
+    Returns
+    -------
+    view : ndarray
+
+    See also
+    --------
+    broadcast_to : broadcast an array to a given shape.
+    reshape : reshape an array.
+    lib.stride_tricks.sliding_window_view :
+        userfriendly and safe function for a creation of sliding window views.
+
+    Notes
+    -----
+    ``as_strided`` creates a view into the array given the exact strides
+    and shape. This means it manipulates the internal data structure of
+    ndarray and, if done incorrectly, the array elements can point to
+    invalid memory and can corrupt results or crash your program.
+    It is advisable to always use the original ``x.strides`` when
+    calculating new strides to avoid reliance on a contiguous memory
+    layout.
+
+    Furthermore, arrays created with this function often contain self
+    overlapping memory, so that two elements are identical.
+    Vectorized write operations on such arrays will typically be
+    unpredictable. They may even give different results for small, large,
+    or transposed arrays.
+
+    Since writing to these arrays has to be tested and done with great
+    care, you may want to use ``writeable=False`` to avoid accidental write
+    operations.
+
+    For these reasons it is advisable to avoid ``as_strided`` when
+    possible.
+    """
+    # first convert input to array, possibly keeping subclass
+    x = np.array(x, copy=None, subok=subok)
+    interface = dict(x.__array_interface__)
+    if shape is not None:
+        interface['shape'] = tuple(shape)
+    if strides is not None:
+        interface['strides'] = tuple(strides)
+
+    array = np.asarray(DummyArray(interface, base=x))
+    # The route via `__interface__` does not preserve structured
+    # dtypes. Since dtype should remain unchanged, we set it explicitly.
+    array.dtype = x.dtype
+
+    view = _maybe_view_as_subclass(x, array)
+
+    if view.flags.writeable and not writeable:
+        view.flags.writeable = False
+
+    return view
+
+
+def _sliding_window_view_dispatcher(x, window_shape, axis=None, *,
+                                    subok=None, writeable=None):
+    return (x,)
+
+
+@array_function_dispatch(
+    _sliding_window_view_dispatcher, module="numpy.lib.stride_tricks"
+)
+def sliding_window_view(x, window_shape, axis=None, *,
+                        subok=False, writeable=False):
+    """
+    Create a sliding window view into the array with the given window shape.
+
+    Also known as rolling or moving window, the window slides across all
+    dimensions of the array and extracts subsets of the array at all window
+    positions.
+
+    .. versionadded:: 1.20.0
+
+    Parameters
+    ----------
+    x : array_like
+        Array to create the sliding window view from.
+    window_shape : int or tuple of int
+        Size of window over each axis that takes part in the sliding window.
+        If `axis` is not present, must have same length as the number of input
+        array dimensions. Single integers `i` are treated as if they were the
+        tuple `(i,)`.
+    axis : int or tuple of int, optional
+        Axis or axes along which the sliding window is applied.
+        By default, the sliding window is applied to all axes and
+        `window_shape[i]` will refer to axis `i` of `x`.
+        If `axis` is given as a `tuple of int`, `window_shape[i]` will refer to
+        the axis `axis[i]` of `x`.
+        Single integers `i` are treated as if they were the tuple `(i,)`.
+    subok : bool, optional
+        If True, sub-classes will be passed-through, otherwise the returned
+        array will be forced to be a base-class array (default).
+    writeable : bool, optional
+        When true, allow writing to the returned view. The default is false,
+        as this should be used with caution: the returned view contains the
+        same memory location multiple times, so writing to one location will
+        cause others to change.
+
+    Returns
+    -------
+    view : ndarray
+        Sliding window view of the array. The sliding window dimensions are
+        inserted at the end, and the original dimensions are trimmed as
+        required by the size of the sliding window.
+        That is, ``view.shape = x_shape_trimmed + window_shape``, where
+        ``x_shape_trimmed`` is ``x.shape`` with every entry reduced by one less
+        than the corresponding window size.
+
+    See Also
+    --------
+    lib.stride_tricks.as_strided: A lower-level and less safe routine for
+        creating arbitrary views from custom shape and strides.
+    broadcast_to: broadcast an array to a given shape.
+
+    Notes
+    -----
+    For many applications using a sliding window view can be convenient, but
+    potentially very slow. Often specialized solutions exist, for example:
+
+    - `scipy.signal.fftconvolve`
+
+    - filtering functions in `scipy.ndimage`
+
+    - moving window functions provided by
+      `bottleneck `_.
+
+    As a rough estimate, a sliding window approach with an input size of `N`
+    and a window size of `W` will scale as `O(N*W)` where frequently a special
+    algorithm can achieve `O(N)`. That means that the sliding window variant
+    for a window size of 100 can be a 100 times slower than a more specialized
+    version.
+
+    Nevertheless, for small window sizes, when no custom algorithm exists, or
+    as a prototyping and developing tool, this function can be a good solution.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from numpy.lib.stride_tricks import sliding_window_view
+    >>> x = np.arange(6)
+    >>> x.shape
+    (6,)
+    >>> v = sliding_window_view(x, 3)
+    >>> v.shape
+    (4, 3)
+    >>> v
+    array([[0, 1, 2],
+           [1, 2, 3],
+           [2, 3, 4],
+           [3, 4, 5]])
+
+    This also works in more dimensions, e.g.
+
+    >>> i, j = np.ogrid[:3, :4]
+    >>> x = 10*i + j
+    >>> x.shape
+    (3, 4)
+    >>> x
+    array([[ 0,  1,  2,  3],
+           [10, 11, 12, 13],
+           [20, 21, 22, 23]])
+    >>> shape = (2,2)
+    >>> v = sliding_window_view(x, shape)
+    >>> v.shape
+    (2, 3, 2, 2)
+    >>> v
+    array([[[[ 0,  1],
+             [10, 11]],
+            [[ 1,  2],
+             [11, 12]],
+            [[ 2,  3],
+             [12, 13]]],
+           [[[10, 11],
+             [20, 21]],
+            [[11, 12],
+             [21, 22]],
+            [[12, 13],
+             [22, 23]]]])
+
+    The axis can be specified explicitly:
+
+    >>> v = sliding_window_view(x, 3, 0)
+    >>> v.shape
+    (1, 4, 3)
+    >>> v
+    array([[[ 0, 10, 20],
+            [ 1, 11, 21],
+            [ 2, 12, 22],
+            [ 3, 13, 23]]])
+
+    The same axis can be used several times. In that case, every use reduces
+    the corresponding original dimension:
+
+    >>> v = sliding_window_view(x, (2, 3), (1, 1))
+    >>> v.shape
+    (3, 1, 2, 3)
+    >>> v
+    array([[[[ 0,  1,  2],
+             [ 1,  2,  3]]],
+           [[[10, 11, 12],
+             [11, 12, 13]]],
+           [[[20, 21, 22],
+             [21, 22, 23]]]])
+
+    Combining with stepped slicing (`::step`), this can be used to take sliding
+    views which skip elements:
+
+    >>> x = np.arange(7)
+    >>> sliding_window_view(x, 5)[:, ::2]
+    array([[0, 2, 4],
+           [1, 3, 5],
+           [2, 4, 6]])
+
+    or views which move by multiple elements
+
+    >>> x = np.arange(7)
+    >>> sliding_window_view(x, 3)[::2, :]
+    array([[0, 1, 2],
+           [2, 3, 4],
+           [4, 5, 6]])
+
+    A common application of `sliding_window_view` is the calculation of running
+    statistics. The simplest example is the
+    `moving average `_:
+
+    >>> x = np.arange(6)
+    >>> x.shape
+    (6,)
+    >>> v = sliding_window_view(x, 3)
+    >>> v.shape
+    (4, 3)
+    >>> v
+    array([[0, 1, 2],
+           [1, 2, 3],
+           [2, 3, 4],
+           [3, 4, 5]])
+    >>> moving_average = v.mean(axis=-1)
+    >>> moving_average
+    array([1., 2., 3., 4.])
+
+    Note that a sliding window approach is often **not** optimal (see Notes).
+    """
+    window_shape = (tuple(window_shape)
+                    if np.iterable(window_shape)
+                    else (window_shape,))
+    # first convert input to array, possibly keeping subclass
+    x = np.array(x, copy=None, subok=subok)
+
+    window_shape_array = np.array(window_shape)
+    if np.any(window_shape_array < 0):
+        raise ValueError('`window_shape` cannot contain negative values')
+
+    if axis is None:
+        axis = tuple(range(x.ndim))
+        if len(window_shape) != len(axis):
+            raise ValueError(f'Since axis is `None`, must provide '
+                             f'window_shape for all dimensions of `x`; '
+                             f'got {len(window_shape)} window_shape elements '
+                             f'and `x.ndim` is {x.ndim}.')
+    else:
+        axis = normalize_axis_tuple(axis, x.ndim, allow_duplicate=True)
+        if len(window_shape) != len(axis):
+            raise ValueError(f'Must provide matching length window_shape and '
+                             f'axis; got {len(window_shape)} window_shape '
+                             f'elements and {len(axis)} axes elements.')
+
+    out_strides = x.strides + tuple(x.strides[ax] for ax in axis)
+
+    # note: same axis can be windowed repeatedly
+    x_shape_trimmed = list(x.shape)
+    for ax, dim in zip(axis, window_shape):
+        if x_shape_trimmed[ax] < dim:
+            raise ValueError(
+                'window shape cannot be larger than input array shape')
+        x_shape_trimmed[ax] -= dim - 1
+    out_shape = tuple(x_shape_trimmed) + window_shape
+    return as_strided(x, strides=out_strides, shape=out_shape,
+                      subok=subok, writeable=writeable)
+
+
+def _broadcast_to(array, shape, subok, readonly):
+    shape = tuple(shape) if np.iterable(shape) else (shape,)
+    array = np.array(array, copy=None, subok=subok)
+    if not shape and array.shape:
+        raise ValueError('cannot broadcast a non-scalar to a scalar array')
+    if any(size < 0 for size in shape):
+        raise ValueError('all elements of broadcast shape must be non-'
+                         'negative')
+    extras = []
+    it = np.nditer(
+        (array,), flags=['multi_index', 'refs_ok', 'zerosize_ok'] + extras,
+        op_flags=['readonly'], itershape=shape, order='C')
+    with it:
+        # never really has writebackifcopy semantics
+        broadcast = it.itviews[0]
+    result = _maybe_view_as_subclass(array, broadcast)
+    # In a future version this will go away
+    if not readonly and array.flags._writeable_no_warn:
+        result.flags.writeable = True
+        result.flags._warn_on_write = True
+    return result
+
+
+def _broadcast_to_dispatcher(array, shape, subok=None):
+    return (array,)
+
+
+@array_function_dispatch(_broadcast_to_dispatcher, module='numpy')
+def broadcast_to(array, shape, subok=False):
+    """Broadcast an array to a new shape.
+
+    Parameters
+    ----------
+    array : array_like
+        The array to broadcast.
+    shape : tuple or int
+        The shape of the desired array. A single integer ``i`` is interpreted
+        as ``(i,)``.
+    subok : bool, optional
+        If True, then sub-classes will be passed-through, otherwise
+        the returned array will be forced to be a base-class array (default).
+
+    Returns
+    -------
+    broadcast : array
+        A readonly view on the original array with the given shape. It is
+        typically not contiguous. Furthermore, more than one element of a
+        broadcasted array may refer to a single memory location.
+
+    Raises
+    ------
+    ValueError
+        If the array is not compatible with the new shape according to NumPy's
+        broadcasting rules.
+
+    See Also
+    --------
+    broadcast
+    broadcast_arrays
+    broadcast_shapes
+
+    Notes
+    -----
+    .. versionadded:: 1.10.0
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> x = np.array([1, 2, 3])
+    >>> np.broadcast_to(x, (3, 3))
+    array([[1, 2, 3],
+           [1, 2, 3],
+           [1, 2, 3]])
+    """
+    return _broadcast_to(array, shape, subok=subok, readonly=True)
+
+
+def _broadcast_shape(*args):
+    """Returns the shape of the arrays that would result from broadcasting the
+    supplied arrays against each other.
+    """
+    # use the old-iterator because np.nditer does not handle size 0 arrays
+    # consistently
+    b = np.broadcast(*args[:32])
+    # unfortunately, it cannot handle 32 or more arguments directly
+    for pos in range(32, len(args), 31):
+        # ironically, np.broadcast does not properly handle np.broadcast
+        # objects (it treats them as scalars)
+        # use broadcasting to avoid allocating the full array
+        b = broadcast_to(0, b.shape)
+        b = np.broadcast(b, *args[pos:(pos + 31)])
+    return b.shape
+
+
+_size0_dtype = np.dtype([])
+
+
+@set_module('numpy')
+def broadcast_shapes(*args):
+    """
+    Broadcast the input shapes into a single shape.
+
+    :ref:`Learn more about broadcasting here `.
+
+    .. versionadded:: 1.20.0
+
+    Parameters
+    ----------
+    *args : tuples of ints, or ints
+        The shapes to be broadcast against each other.
+
+    Returns
+    -------
+    tuple
+        Broadcasted shape.
+
+    Raises
+    ------
+    ValueError
+        If the shapes are not compatible and cannot be broadcast according
+        to NumPy's broadcasting rules.
+
+    See Also
+    --------
+    broadcast
+    broadcast_arrays
+    broadcast_to
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> np.broadcast_shapes((1, 2), (3, 1), (3, 2))
+    (3, 2)
+
+    >>> np.broadcast_shapes((6, 7), (5, 6, 1), (7,), (5, 1, 7))
+    (5, 6, 7)
+    """
+    arrays = [np.empty(x, dtype=_size0_dtype) for x in args]
+    return _broadcast_shape(*arrays)
+
+
+def _broadcast_arrays_dispatcher(*args, subok=None):
+    return args
+
+
+@array_function_dispatch(_broadcast_arrays_dispatcher, module='numpy')
+def broadcast_arrays(*args, subok=False):
+    """
+    Broadcast any number of arrays against each other.
+
+    Parameters
+    ----------
+    *args : array_likes
+        The arrays to broadcast.
+
+    subok : bool, optional
+        If True, then sub-classes will be passed-through, otherwise
+        the returned arrays will be forced to be a base-class array (default).
+
+    Returns
+    -------
+    broadcasted : tuple of arrays
+        These arrays are views on the original arrays.  They are typically
+        not contiguous.  Furthermore, more than one element of a
+        broadcasted array may refer to a single memory location. If you need
+        to write to the arrays, make copies first. While you can set the
+        ``writable`` flag True, writing to a single output value may end up
+        changing more than one location in the output array.
+
+        .. deprecated:: 1.17
+            The output is currently marked so that if written to, a deprecation
+            warning will be emitted. A future version will set the
+            ``writable`` flag False so writing to it will raise an error.
+
+    See Also
+    --------
+    broadcast
+    broadcast_to
+    broadcast_shapes
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> x = np.array([[1,2,3]])
+    >>> y = np.array([[4],[5]])
+    >>> np.broadcast_arrays(x, y)
+    (array([[1, 2, 3],
+            [1, 2, 3]]),
+     array([[4, 4, 4],
+            [5, 5, 5]]))
+
+    Here is a useful idiom for getting contiguous copies instead of
+    non-contiguous views.
+
+    >>> [np.array(a) for a in np.broadcast_arrays(x, y)]
+    [array([[1, 2, 3],
+            [1, 2, 3]]),
+     array([[4, 4, 4],
+            [5, 5, 5]])]
+
+    """
+    # nditer is not used here to avoid the limit of 32 arrays.
+    # Otherwise, something like the following one-liner would suffice:
+    # return np.nditer(args, flags=['multi_index', 'zerosize_ok'],
+    #                  order='C').itviews
+
+    args = [np.array(_m, copy=None, subok=subok) for _m in args]
+
+    shape = _broadcast_shape(*args)
+
+    result = [array if array.shape == shape
+              else _broadcast_to(array, shape, subok=subok, readonly=False)
+                              for array in args]
+    return tuple(result)
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/_stride_tricks_impl.pyi b/venv/lib/python3.12/site-packages/numpy/lib/_stride_tricks_impl.pyi
new file mode 100644
index 00000000..cf635f1f
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/lib/_stride_tricks_impl.pyi
@@ -0,0 +1,80 @@
+from collections.abc import Iterable
+from typing import Any, TypeVar, overload, SupportsIndex
+
+from numpy import generic
+from numpy._typing import (
+    NDArray,
+    ArrayLike,
+    _ShapeLike,
+    _Shape,
+    _ArrayLike
+)
+
+_SCT = TypeVar("_SCT", bound=generic)
+
+__all__: list[str]
+
+class DummyArray:
+    __array_interface__: dict[str, Any]
+    base: None | NDArray[Any]
+    def __init__(
+        self,
+        interface: dict[str, Any],
+        base: None | NDArray[Any] = ...,
+    ) -> None: ...
+
+@overload
+def as_strided(
+    x: _ArrayLike[_SCT],
+    shape: None | Iterable[int] = ...,
+    strides: None | Iterable[int] = ...,
+    subok: bool = ...,
+    writeable: bool = ...,
+) -> NDArray[_SCT]: ...
+@overload
+def as_strided(
+    x: ArrayLike,
+    shape: None | Iterable[int] = ...,
+    strides: None | Iterable[int] = ...,
+    subok: bool = ...,
+    writeable: bool = ...,
+) -> NDArray[Any]: ...
+
+@overload
+def sliding_window_view(
+    x: _ArrayLike[_SCT],
+    window_shape: int | Iterable[int],
+    axis: None | SupportsIndex = ...,
+    *,
+    subok: bool = ...,
+    writeable: bool = ...,
+) -> NDArray[_SCT]: ...
+@overload
+def sliding_window_view(
+    x: ArrayLike,
+    window_shape: int | Iterable[int],
+    axis: None | SupportsIndex = ...,
+    *,
+    subok: bool = ...,
+    writeable: bool = ...,
+) -> NDArray[Any]: ...
+
+@overload
+def broadcast_to(
+    array: _ArrayLike[_SCT],
+    shape: int | Iterable[int],
+    subok: bool = ...,
+) -> NDArray[_SCT]: ...
+@overload
+def broadcast_to(
+    array: ArrayLike,
+    shape: int | Iterable[int],
+    subok: bool = ...,
+) -> NDArray[Any]: ...
+
+def broadcast_shapes(*args: _ShapeLike) -> _Shape: ...
+
+def broadcast_arrays(
+    *args: ArrayLike,
+    subok: bool = ...,
+) -> tuple[NDArray[Any], ...]: ...
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/_twodim_base_impl.py b/venv/lib/python3.12/site-packages/numpy/lib/_twodim_base_impl.py
new file mode 100644
index 00000000..584efbfc
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/lib/_twodim_base_impl.py
@@ -0,0 +1,1208 @@
+""" Basic functions for manipulating 2d arrays
+
+"""
+import functools
+import operator
+
+from numpy._core._multiarray_umath import _array_converter
+from numpy._core.numeric import (
+    asanyarray, arange, zeros, greater_equal, multiply, ones,
+    asarray, where, int8, int16, int32, int64, intp, empty, promote_types,
+    diagonal, nonzero, indices
+    )
+from numpy._core.overrides import set_array_function_like_doc, set_module
+from numpy._core import overrides
+from numpy._core import iinfo
+from numpy.lib._stride_tricks_impl import broadcast_to
+
+
+__all__ = [
+    'diag', 'diagflat', 'eye', 'fliplr', 'flipud', 'tri', 'triu',
+    'tril', 'vander', 'histogram2d', 'mask_indices', 'tril_indices',
+    'tril_indices_from', 'triu_indices', 'triu_indices_from', ]
+
+
+array_function_dispatch = functools.partial(
+    overrides.array_function_dispatch, module='numpy')
+
+
+i1 = iinfo(int8)
+i2 = iinfo(int16)
+i4 = iinfo(int32)
+
+
+def _min_int(low, high):
+    """ get small int that fits the range """
+    if high <= i1.max and low >= i1.min:
+        return int8
+    if high <= i2.max and low >= i2.min:
+        return int16
+    if high <= i4.max and low >= i4.min:
+        return int32
+    return int64
+
+
+def _flip_dispatcher(m):
+    return (m,)
+
+
+@array_function_dispatch(_flip_dispatcher)
+def fliplr(m):
+    """
+    Reverse the order of elements along axis 1 (left/right).
+
+    For a 2-D array, this flips the entries in each row in the left/right
+    direction. Columns are preserved, but appear in a different order than
+    before.
+
+    Parameters
+    ----------
+    m : array_like
+        Input array, must be at least 2-D.
+
+    Returns
+    -------
+    f : ndarray
+        A view of `m` with the columns reversed.  Since a view
+        is returned, this operation is :math:`\\mathcal O(1)`.
+
+    See Also
+    --------
+    flipud : Flip array in the up/down direction.
+    flip : Flip array in one or more dimensions.
+    rot90 : Rotate array counterclockwise.
+
+    Notes
+    -----
+    Equivalent to ``m[:,::-1]`` or ``np.flip(m, axis=1)``.
+    Requires the array to be at least 2-D.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> A = np.diag([1.,2.,3.])
+    >>> A
+    array([[1.,  0.,  0.],
+           [0.,  2.,  0.],
+           [0.,  0.,  3.]])
+    >>> np.fliplr(A)
+    array([[0.,  0.,  1.],
+           [0.,  2.,  0.],
+           [3.,  0.,  0.]])
+
+    >>> rng = np.random.default_rng()
+    >>> A = rng.normal(size=(2,3,5))
+    >>> np.all(np.fliplr(A) == A[:,::-1,...])
+    True
+
+    """
+    m = asanyarray(m)
+    if m.ndim < 2:
+        raise ValueError("Input must be >= 2-d.")
+    return m[:, ::-1]
+
+
+@array_function_dispatch(_flip_dispatcher)
+def flipud(m):
+    """
+    Reverse the order of elements along axis 0 (up/down).
+
+    For a 2-D array, this flips the entries in each column in the up/down
+    direction. Rows are preserved, but appear in a different order than before.
+
+    Parameters
+    ----------
+    m : array_like
+        Input array.
+
+    Returns
+    -------
+    out : array_like
+        A view of `m` with the rows reversed.  Since a view is
+        returned, this operation is :math:`\\mathcal O(1)`.
+
+    See Also
+    --------
+    fliplr : Flip array in the left/right direction.
+    flip : Flip array in one or more dimensions.
+    rot90 : Rotate array counterclockwise.
+
+    Notes
+    -----
+    Equivalent to ``m[::-1, ...]`` or ``np.flip(m, axis=0)``.
+    Requires the array to be at least 1-D.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> A = np.diag([1.0, 2, 3])
+    >>> A
+    array([[1.,  0.,  0.],
+           [0.,  2.,  0.],
+           [0.,  0.,  3.]])
+    >>> np.flipud(A)
+    array([[0.,  0.,  3.],
+           [0.,  2.,  0.],
+           [1.,  0.,  0.]])
+
+    >>> rng = np.random.default_rng()
+    >>> A = rng.normal(size=(2,3,5))
+    >>> np.all(np.flipud(A) == A[::-1,...])
+    True
+
+    >>> np.flipud([1,2])
+    array([2, 1])
+
+    """
+    m = asanyarray(m)
+    if m.ndim < 1:
+        raise ValueError("Input must be >= 1-d.")
+    return m[::-1, ...]
+
+
+@set_array_function_like_doc
+@set_module('numpy')
+def eye(N, M=None, k=0, dtype=float, order='C', *, device=None, like=None):
+    """
+    Return a 2-D array with ones on the diagonal and zeros elsewhere.
+
+    Parameters
+    ----------
+    N : int
+      Number of rows in the output.
+    M : int, optional
+      Number of columns in the output. If None, defaults to `N`.
+    k : int, optional
+      Index of the diagonal: 0 (the default) refers to the main diagonal,
+      a positive value refers to an upper diagonal, and a negative value
+      to a lower diagonal.
+    dtype : data-type, optional
+      Data-type of the returned array.
+    order : {'C', 'F'}, optional
+        Whether the output should be stored in row-major (C-style) or
+        column-major (Fortran-style) order in memory.
+
+        .. versionadded:: 1.14.0
+    device : str, optional
+        The device on which to place the created array. Default: None.
+        For Array-API interoperability only, so must be ``"cpu"`` if passed.
+
+        .. versionadded:: 2.0.0
+    ${ARRAY_FUNCTION_LIKE}
+
+        .. versionadded:: 1.20.0
+
+    Returns
+    -------
+    I : ndarray of shape (N,M)
+      An array where all elements are equal to zero, except for the `k`-th
+      diagonal, whose values are equal to one.
+
+    See Also
+    --------
+    identity : (almost) equivalent function
+    diag : diagonal 2-D array from a 1-D array specified by the user.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> np.eye(2, dtype=int)
+    array([[1, 0],
+           [0, 1]])
+    >>> np.eye(3, k=1)
+    array([[0.,  1.,  0.],
+           [0.,  0.,  1.],
+           [0.,  0.,  0.]])
+
+    """
+    if like is not None:
+        return _eye_with_like(
+            like, N, M=M, k=k, dtype=dtype, order=order, device=device
+        )
+    if M is None:
+        M = N
+    m = zeros((N, M), dtype=dtype, order=order, device=device)
+    if k >= M:
+        return m
+    # Ensure M and k are integers, so we don't get any surprise casting
+    # results in the expressions `M-k` and `M+1` used below.  This avoids
+    # a problem with inputs with type (for example) np.uint64.
+    M = operator.index(M)
+    k = operator.index(k)
+    if k >= 0:
+        i = k
+    else:
+        i = (-k) * M
+    m[:M-k].flat[i::M+1] = 1
+    return m
+
+
+_eye_with_like = array_function_dispatch()(eye)
+
+
+def _diag_dispatcher(v, k=None):
+    return (v,)
+
+
+@array_function_dispatch(_diag_dispatcher)
+def diag(v, k=0):
+    """
+    Extract a diagonal or construct a diagonal array.
+
+    See the more detailed documentation for ``numpy.diagonal`` if you use this
+    function to extract a diagonal and wish to write to the resulting array;
+    whether it returns a copy or a view depends on what version of numpy you
+    are using.
+
+    Parameters
+    ----------
+    v : array_like
+        If `v` is a 2-D array, return a copy of its `k`-th diagonal.
+        If `v` is a 1-D array, return a 2-D array with `v` on the `k`-th
+        diagonal.
+    k : int, optional
+        Diagonal in question. The default is 0. Use `k>0` for diagonals
+        above the main diagonal, and `k<0` for diagonals below the main
+        diagonal.
+
+    Returns
+    -------
+    out : ndarray
+        The extracted diagonal or constructed diagonal array.
+
+    See Also
+    --------
+    diagonal : Return specified diagonals.
+    diagflat : Create a 2-D array with the flattened input as a diagonal.
+    trace : Sum along diagonals.
+    triu : Upper triangle of an array.
+    tril : Lower triangle of an array.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> x = np.arange(9).reshape((3,3))
+    >>> x
+    array([[0, 1, 2],
+           [3, 4, 5],
+           [6, 7, 8]])
+
+    >>> np.diag(x)
+    array([0, 4, 8])
+    >>> np.diag(x, k=1)
+    array([1, 5])
+    >>> np.diag(x, k=-1)
+    array([3, 7])
+
+    >>> np.diag(np.diag(x))
+    array([[0, 0, 0],
+           [0, 4, 0],
+           [0, 0, 8]])
+
+    """
+    v = asanyarray(v)
+    s = v.shape
+    if len(s) == 1:
+        n = s[0]+abs(k)
+        res = zeros((n, n), v.dtype)
+        if k >= 0:
+            i = k
+        else:
+            i = (-k) * n
+        res[:n-k].flat[i::n+1] = v
+        return res
+    elif len(s) == 2:
+        return diagonal(v, k)
+    else:
+        raise ValueError("Input must be 1- or 2-d.")
+
+
+@array_function_dispatch(_diag_dispatcher)
+def diagflat(v, k=0):
+    """
+    Create a two-dimensional array with the flattened input as a diagonal.
+
+    Parameters
+    ----------
+    v : array_like
+        Input data, which is flattened and set as the `k`-th
+        diagonal of the output.
+    k : int, optional
+        Diagonal to set; 0, the default, corresponds to the "main" diagonal,
+        a positive (negative) `k` giving the number of the diagonal above
+        (below) the main.
+
+    Returns
+    -------
+    out : ndarray
+        The 2-D output array.
+
+    See Also
+    --------
+    diag : MATLAB work-alike for 1-D and 2-D arrays.
+    diagonal : Return specified diagonals.
+    trace : Sum along diagonals.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> np.diagflat([[1,2], [3,4]])
+    array([[1, 0, 0, 0],
+           [0, 2, 0, 0],
+           [0, 0, 3, 0],
+           [0, 0, 0, 4]])
+
+    >>> np.diagflat([1,2], 1)
+    array([[0, 1, 0],
+           [0, 0, 2],
+           [0, 0, 0]])
+
+    """
+    conv = _array_converter(v)
+    v, = conv.as_arrays(subok=False)
+    v = v.ravel()
+    s = len(v)
+    n = s + abs(k)
+    res = zeros((n, n), v.dtype)
+    if (k >= 0):
+        i = arange(0, n-k, dtype=intp)
+        fi = i+k+i*n
+    else:
+        i = arange(0, n+k, dtype=intp)
+        fi = i+(i-k)*n
+    res.flat[fi] = v
+
+    return conv.wrap(res)
+
+
+@set_array_function_like_doc
+@set_module('numpy')
+def tri(N, M=None, k=0, dtype=float, *, like=None):
+    """
+    An array with ones at and below the given diagonal and zeros elsewhere.
+
+    Parameters
+    ----------
+    N : int
+        Number of rows in the array.
+    M : int, optional
+        Number of columns in the array.
+        By default, `M` is taken equal to `N`.
+    k : int, optional
+        The sub-diagonal at and below which the array is filled.
+        `k` = 0 is the main diagonal, while `k` < 0 is below it,
+        and `k` > 0 is above.  The default is 0.
+    dtype : dtype, optional
+        Data type of the returned array.  The default is float.
+    ${ARRAY_FUNCTION_LIKE}
+
+        .. versionadded:: 1.20.0
+
+    Returns
+    -------
+    tri : ndarray of shape (N, M)
+        Array with its lower triangle filled with ones and zero elsewhere;
+        in other words ``T[i,j] == 1`` for ``j <= i + k``, 0 otherwise.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> np.tri(3, 5, 2, dtype=int)
+    array([[1, 1, 1, 0, 0],
+           [1, 1, 1, 1, 0],
+           [1, 1, 1, 1, 1]])
+
+    >>> np.tri(3, 5, -1)
+    array([[0.,  0.,  0.,  0.,  0.],
+           [1.,  0.,  0.,  0.,  0.],
+           [1.,  1.,  0.,  0.,  0.]])
+
+    """
+    if like is not None:
+        return _tri_with_like(like, N, M=M, k=k, dtype=dtype)
+
+    if M is None:
+        M = N
+
+    m = greater_equal.outer(arange(N, dtype=_min_int(0, N)),
+                            arange(-k, M-k, dtype=_min_int(-k, M - k)))
+
+    # Avoid making a copy if the requested type is already bool
+    m = m.astype(dtype, copy=False)
+
+    return m
+
+
+_tri_with_like = array_function_dispatch()(tri)
+
+
+def _trilu_dispatcher(m, k=None):
+    return (m,)
+
+
+@array_function_dispatch(_trilu_dispatcher)
+def tril(m, k=0):
+    """
+    Lower triangle of an array.
+
+    Return a copy of an array with elements above the `k`-th diagonal zeroed.
+    For arrays with ``ndim`` exceeding 2, `tril` will apply to the final two
+    axes.
+
+    Parameters
+    ----------
+    m : array_like, shape (..., M, N)
+        Input array.
+    k : int, optional
+        Diagonal above which to zero elements.  `k = 0` (the default) is the
+        main diagonal, `k < 0` is below it and `k > 0` is above.
+
+    Returns
+    -------
+    tril : ndarray, shape (..., M, N)
+        Lower triangle of `m`, of same shape and data-type as `m`.
+
+    See Also
+    --------
+    triu : same thing, only for the upper triangle
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> np.tril([[1,2,3],[4,5,6],[7,8,9],[10,11,12]], -1)
+    array([[ 0,  0,  0],
+           [ 4,  0,  0],
+           [ 7,  8,  0],
+           [10, 11, 12]])
+
+    >>> np.tril(np.arange(3*4*5).reshape(3, 4, 5))
+    array([[[ 0,  0,  0,  0,  0],
+            [ 5,  6,  0,  0,  0],
+            [10, 11, 12,  0,  0],
+            [15, 16, 17, 18,  0]],
+           [[20,  0,  0,  0,  0],
+            [25, 26,  0,  0,  0],
+            [30, 31, 32,  0,  0],
+            [35, 36, 37, 38,  0]],
+           [[40,  0,  0,  0,  0],
+            [45, 46,  0,  0,  0],
+            [50, 51, 52,  0,  0],
+            [55, 56, 57, 58,  0]]])
+
+    """
+    m = asanyarray(m)
+    mask = tri(*m.shape[-2:], k=k, dtype=bool)
+
+    return where(mask, m, zeros(1, m.dtype))
+
+
+@array_function_dispatch(_trilu_dispatcher)
+def triu(m, k=0):
+    """
+    Upper triangle of an array.
+
+    Return a copy of an array with the elements below the `k`-th diagonal
+    zeroed. For arrays with ``ndim`` exceeding 2, `triu` will apply to the
+    final two axes.
+
+    Please refer to the documentation for `tril` for further details.
+
+    See Also
+    --------
+    tril : lower triangle of an array
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> np.triu([[1,2,3],[4,5,6],[7,8,9],[10,11,12]], -1)
+    array([[ 1,  2,  3],
+           [ 4,  5,  6],
+           [ 0,  8,  9],
+           [ 0,  0, 12]])
+
+    >>> np.triu(np.arange(3*4*5).reshape(3, 4, 5))
+    array([[[ 0,  1,  2,  3,  4],
+            [ 0,  6,  7,  8,  9],
+            [ 0,  0, 12, 13, 14],
+            [ 0,  0,  0, 18, 19]],
+           [[20, 21, 22, 23, 24],
+            [ 0, 26, 27, 28, 29],
+            [ 0,  0, 32, 33, 34],
+            [ 0,  0,  0, 38, 39]],
+           [[40, 41, 42, 43, 44],
+            [ 0, 46, 47, 48, 49],
+            [ 0,  0, 52, 53, 54],
+            [ 0,  0,  0, 58, 59]]])
+
+    """
+    m = asanyarray(m)
+    mask = tri(*m.shape[-2:], k=k-1, dtype=bool)
+
+    return where(mask, zeros(1, m.dtype), m)
+
+
+def _vander_dispatcher(x, N=None, increasing=None):
+    return (x,)
+
+
+# Originally borrowed from John Hunter and matplotlib
+@array_function_dispatch(_vander_dispatcher)
+def vander(x, N=None, increasing=False):
+    """
+    Generate a Vandermonde matrix.
+
+    The columns of the output matrix are powers of the input vector. The
+    order of the powers is determined by the `increasing` boolean argument.
+    Specifically, when `increasing` is False, the `i`-th output column is
+    the input vector raised element-wise to the power of ``N - i - 1``. Such
+    a matrix with a geometric progression in each row is named for Alexandre-
+    Theophile Vandermonde.
+
+    Parameters
+    ----------
+    x : array_like
+        1-D input array.
+    N : int, optional
+        Number of columns in the output.  If `N` is not specified, a square
+        array is returned (``N = len(x)``).
+    increasing : bool, optional
+        Order of the powers of the columns.  If True, the powers increase
+        from left to right, if False (the default) they are reversed.
+
+        .. versionadded:: 1.9.0
+
+    Returns
+    -------
+    out : ndarray
+        Vandermonde matrix.  If `increasing` is False, the first column is
+        ``x^(N-1)``, the second ``x^(N-2)`` and so forth. If `increasing` is
+        True, the columns are ``x^0, x^1, ..., x^(N-1)``.
+
+    See Also
+    --------
+    polynomial.polynomial.polyvander
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> x = np.array([1, 2, 3, 5])
+    >>> N = 3
+    >>> np.vander(x, N)
+    array([[ 1,  1,  1],
+           [ 4,  2,  1],
+           [ 9,  3,  1],
+           [25,  5,  1]])
+
+    >>> np.column_stack([x**(N-1-i) for i in range(N)])
+    array([[ 1,  1,  1],
+           [ 4,  2,  1],
+           [ 9,  3,  1],
+           [25,  5,  1]])
+
+    >>> x = np.array([1, 2, 3, 5])
+    >>> np.vander(x)
+    array([[  1,   1,   1,   1],
+           [  8,   4,   2,   1],
+           [ 27,   9,   3,   1],
+           [125,  25,   5,   1]])
+    >>> np.vander(x, increasing=True)
+    array([[  1,   1,   1,   1],
+           [  1,   2,   4,   8],
+           [  1,   3,   9,  27],
+           [  1,   5,  25, 125]])
+
+    The determinant of a square Vandermonde matrix is the product
+    of the differences between the values of the input vector:
+
+    >>> np.linalg.det(np.vander(x))
+    48.000000000000043 # may vary
+    >>> (5-3)*(5-2)*(5-1)*(3-2)*(3-1)*(2-1)
+    48
+
+    """
+    x = asarray(x)
+    if x.ndim != 1:
+        raise ValueError("x must be a one-dimensional array or sequence.")
+    if N is None:
+        N = len(x)
+
+    v = empty((len(x), N), dtype=promote_types(x.dtype, int))
+    tmp = v[:, ::-1] if not increasing else v
+
+    if N > 0:
+        tmp[:, 0] = 1
+    if N > 1:
+        tmp[:, 1:] = x[:, None]
+        multiply.accumulate(tmp[:, 1:], out=tmp[:, 1:], axis=1)
+
+    return v
+
+
+def _histogram2d_dispatcher(x, y, bins=None, range=None, density=None,
+                            weights=None):
+    yield x
+    yield y
+
+    # This terrible logic is adapted from the checks in histogram2d
+    try:
+        N = len(bins)
+    except TypeError:
+        N = 1
+    if N == 2:
+        yield from bins  # bins=[x, y]
+    else:
+        yield bins
+
+    yield weights
+
+
+@array_function_dispatch(_histogram2d_dispatcher)
+def histogram2d(x, y, bins=10, range=None, density=None, weights=None):
+    """
+    Compute the bi-dimensional histogram of two data samples.
+
+    Parameters
+    ----------
+    x : array_like, shape (N,)
+        An array containing the x coordinates of the points to be
+        histogrammed.
+    y : array_like, shape (N,)
+        An array containing the y coordinates of the points to be
+        histogrammed.
+    bins : int or array_like or [int, int] or [array, array], optional
+        The bin specification:
+
+        * If int, the number of bins for the two dimensions (nx=ny=bins).
+        * If array_like, the bin edges for the two dimensions
+          (x_edges=y_edges=bins).
+        * If [int, int], the number of bins in each dimension
+          (nx, ny = bins).
+        * If [array, array], the bin edges in each dimension
+          (x_edges, y_edges = bins).
+        * A combination [int, array] or [array, int], where int
+          is the number of bins and array is the bin edges.
+
+    range : array_like, shape(2,2), optional
+        The leftmost and rightmost edges of the bins along each dimension
+        (if not specified explicitly in the `bins` parameters):
+        ``[[xmin, xmax], [ymin, ymax]]``. All values outside of this range
+        will be considered outliers and not tallied in the histogram.
+    density : bool, optional
+        If False, the default, returns the number of samples in each bin.
+        If True, returns the probability *density* function at the bin,
+        ``bin_count / sample_count / bin_area``.
+    weights : array_like, shape(N,), optional
+        An array of values ``w_i`` weighing each sample ``(x_i, y_i)``.
+        Weights are normalized to 1 if `density` is True. If `density` is
+        False, the values of the returned histogram are equal to the sum of
+        the weights belonging to the samples falling into each bin.
+
+    Returns
+    -------
+    H : ndarray, shape(nx, ny)
+        The bi-dimensional histogram of samples `x` and `y`. Values in `x`
+        are histogrammed along the first dimension and values in `y` are
+        histogrammed along the second dimension.
+    xedges : ndarray, shape(nx+1,)
+        The bin edges along the first dimension.
+    yedges : ndarray, shape(ny+1,)
+        The bin edges along the second dimension.
+
+    See Also
+    --------
+    histogram : 1D histogram
+    histogramdd : Multidimensional histogram
+
+    Notes
+    -----
+    When `density` is True, then the returned histogram is the sample
+    density, defined such that the sum over bins of the product
+    ``bin_value * bin_area`` is 1.
+
+    Please note that the histogram does not follow the Cartesian convention
+    where `x` values are on the abscissa and `y` values on the ordinate
+    axis.  Rather, `x` is histogrammed along the first dimension of the
+    array (vertical), and `y` along the second dimension of the array
+    (horizontal).  This ensures compatibility with `histogramdd`.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from matplotlib.image import NonUniformImage
+    >>> import matplotlib.pyplot as plt
+
+    Construct a 2-D histogram with variable bin width. First define the bin
+    edges:
+
+    >>> xedges = [0, 1, 3, 5]
+    >>> yedges = [0, 2, 3, 4, 6]
+
+    Next we create a histogram H with random bin content:
+
+    >>> x = np.random.normal(2, 1, 100)
+    >>> y = np.random.normal(1, 1, 100)
+    >>> H, xedges, yedges = np.histogram2d(x, y, bins=(xedges, yedges))
+    >>> # Histogram does not follow Cartesian convention (see Notes),
+    >>> # therefore transpose H for visualization purposes.
+    >>> H = H.T
+
+    :func:`imshow ` can only display square bins:
+
+    >>> fig = plt.figure(figsize=(7, 3))
+    >>> ax = fig.add_subplot(131, title='imshow: square bins')
+    >>> plt.imshow(H, interpolation='nearest', origin='lower',
+    ...         extent=[xedges[0], xedges[-1], yedges[0], yedges[-1]])
+    
+
+    :func:`pcolormesh ` can display actual edges:
+
+    >>> ax = fig.add_subplot(132, title='pcolormesh: actual edges',
+    ...         aspect='equal')
+    >>> X, Y = np.meshgrid(xedges, yedges)
+    >>> ax.pcolormesh(X, Y, H)
+    
+
+    :class:`NonUniformImage ` can be used to
+    display actual bin edges with interpolation:
+
+    >>> ax = fig.add_subplot(133, title='NonUniformImage: interpolated',
+    ...         aspect='equal', xlim=xedges[[0, -1]], ylim=yedges[[0, -1]])
+    >>> im = NonUniformImage(ax, interpolation='bilinear')
+    >>> xcenters = (xedges[:-1] + xedges[1:]) / 2
+    >>> ycenters = (yedges[:-1] + yedges[1:]) / 2
+    >>> im.set_data(xcenters, ycenters, H)
+    >>> ax.add_image(im)
+    >>> plt.show()
+
+    It is also possible to construct a 2-D histogram without specifying bin
+    edges:
+
+    >>> # Generate non-symmetric test data
+    >>> n = 10000
+    >>> x = np.linspace(1, 100, n)
+    >>> y = 2*np.log(x) + np.random.rand(n) - 0.5
+    >>> # Compute 2d histogram. Note the order of x/y and xedges/yedges
+    >>> H, yedges, xedges = np.histogram2d(y, x, bins=20)
+
+    Now we can plot the histogram using
+    :func:`pcolormesh `, and a
+    :func:`hexbin ` for comparison.
+
+    >>> # Plot histogram using pcolormesh
+    >>> fig, (ax1, ax2) = plt.subplots(ncols=2, sharey=True)
+    >>> ax1.pcolormesh(xedges, yedges, H, cmap='rainbow')
+    >>> ax1.plot(x, 2*np.log(x), 'k-')
+    >>> ax1.set_xlim(x.min(), x.max())
+    >>> ax1.set_ylim(y.min(), y.max())
+    >>> ax1.set_xlabel('x')
+    >>> ax1.set_ylabel('y')
+    >>> ax1.set_title('histogram2d')
+    >>> ax1.grid()
+
+    >>> # Create hexbin plot for comparison
+    >>> ax2.hexbin(x, y, gridsize=20, cmap='rainbow')
+    >>> ax2.plot(x, 2*np.log(x), 'k-')
+    >>> ax2.set_title('hexbin')
+    >>> ax2.set_xlim(x.min(), x.max())
+    >>> ax2.set_xlabel('x')
+    >>> ax2.grid()
+
+    >>> plt.show()
+    """
+    from numpy import histogramdd
+
+    if len(x) != len(y):
+        raise ValueError('x and y must have the same length.')
+
+    try:
+        N = len(bins)
+    except TypeError:
+        N = 1
+
+    if N != 1 and N != 2:
+        xedges = yedges = asarray(bins)
+        bins = [xedges, yedges]
+    hist, edges = histogramdd([x, y], bins, range, density, weights)
+    return hist, edges[0], edges[1]
+
+
+@set_module('numpy')
+def mask_indices(n, mask_func, k=0):
+    """
+    Return the indices to access (n, n) arrays, given a masking function.
+
+    Assume `mask_func` is a function that, for a square array a of size
+    ``(n, n)`` with a possible offset argument `k`, when called as
+    ``mask_func(a, k)`` returns a new array with zeros in certain locations
+    (functions like `triu` or `tril` do precisely this). Then this function
+    returns the indices where the non-zero values would be located.
+
+    Parameters
+    ----------
+    n : int
+        The returned indices will be valid to access arrays of shape (n, n).
+    mask_func : callable
+        A function whose call signature is similar to that of `triu`, `tril`.
+        That is, ``mask_func(x, k)`` returns a boolean array, shaped like `x`.
+        `k` is an optional argument to the function.
+    k : scalar
+        An optional argument which is passed through to `mask_func`. Functions
+        like `triu`, `tril` take a second argument that is interpreted as an
+        offset.
+
+    Returns
+    -------
+    indices : tuple of arrays.
+        The `n` arrays of indices corresponding to the locations where
+        ``mask_func(np.ones((n, n)), k)`` is True.
+
+    See Also
+    --------
+    triu, tril, triu_indices, tril_indices
+
+    Notes
+    -----
+    .. versionadded:: 1.4.0
+
+    Examples
+    --------
+    >>> import numpy as np
+
+    These are the indices that would allow you to access the upper triangular
+    part of any 3x3 array:
+
+    >>> iu = np.mask_indices(3, np.triu)
+
+    For example, if `a` is a 3x3 array:
+
+    >>> a = np.arange(9).reshape(3, 3)
+    >>> a
+    array([[0, 1, 2],
+           [3, 4, 5],
+           [6, 7, 8]])
+    >>> a[iu]
+    array([0, 1, 2, 4, 5, 8])
+
+    An offset can be passed also to the masking function.  This gets us the
+    indices starting on the first diagonal right of the main one:
+
+    >>> iu1 = np.mask_indices(3, np.triu, 1)
+
+    with which we now extract only three elements:
+
+    >>> a[iu1]
+    array([1, 2, 5])
+
+    """
+    m = ones((n, n), int)
+    a = mask_func(m, k)
+    return nonzero(a != 0)
+
+
+@set_module('numpy')
+def tril_indices(n, k=0, m=None):
+    """
+    Return the indices for the lower-triangle of an (n, m) array.
+
+    Parameters
+    ----------
+    n : int
+        The row dimension of the arrays for which the returned
+        indices will be valid.
+    k : int, optional
+        Diagonal offset (see `tril` for details).
+    m : int, optional
+        .. versionadded:: 1.9.0
+
+        The column dimension of the arrays for which the returned
+        arrays will be valid.
+        By default `m` is taken equal to `n`.
+
+
+    Returns
+    -------
+    inds : tuple of arrays
+        The indices for the triangle. The returned tuple contains two arrays,
+        each with the indices along one dimension of the array.
+
+    See also
+    --------
+    triu_indices : similar function, for upper-triangular.
+    mask_indices : generic function accepting an arbitrary mask function.
+    tril, triu
+
+    Notes
+    -----
+    .. versionadded:: 1.4.0
+
+    Examples
+    --------
+    >>> import numpy as np
+
+    Compute two different sets of indices to access 4x4 arrays, one for the
+    lower triangular part starting at the main diagonal, and one starting two
+    diagonals further right:
+
+    >>> il1 = np.tril_indices(4)
+    >>> il2 = np.tril_indices(4, 2)
+
+    Here is how they can be used with a sample array:
+
+    >>> a = np.arange(16).reshape(4, 4)
+    >>> a
+    array([[ 0,  1,  2,  3],
+           [ 4,  5,  6,  7],
+           [ 8,  9, 10, 11],
+           [12, 13, 14, 15]])
+
+    Both for indexing:
+
+    >>> a[il1]
+    array([ 0,  4,  5, ..., 13, 14, 15])
+
+    And for assigning values:
+
+    >>> a[il1] = -1
+    >>> a
+    array([[-1,  1,  2,  3],
+           [-1, -1,  6,  7],
+           [-1, -1, -1, 11],
+           [-1, -1, -1, -1]])
+
+    These cover almost the whole array (two diagonals right of the main one):
+
+    >>> a[il2] = -10
+    >>> a
+    array([[-10, -10, -10,   3],
+           [-10, -10, -10, -10],
+           [-10, -10, -10, -10],
+           [-10, -10, -10, -10]])
+
+    """
+    tri_ = tri(n, m, k=k, dtype=bool)
+
+    return tuple(broadcast_to(inds, tri_.shape)[tri_]
+                 for inds in indices(tri_.shape, sparse=True))
+
+
+def _trilu_indices_form_dispatcher(arr, k=None):
+    return (arr,)
+
+
+@array_function_dispatch(_trilu_indices_form_dispatcher)
+def tril_indices_from(arr, k=0):
+    """
+    Return the indices for the lower-triangle of arr.
+
+    See `tril_indices` for full details.
+
+    Parameters
+    ----------
+    arr : array_like
+        The indices will be valid for square arrays whose dimensions are
+        the same as arr.
+    k : int, optional
+        Diagonal offset (see `tril` for details).
+
+    Examples
+    --------
+    >>> import numpy as np
+
+    Create a 4 by 4 array
+
+    >>> a = np.arange(16).reshape(4, 4)
+    >>> a
+    array([[ 0,  1,  2,  3],
+           [ 4,  5,  6,  7],
+           [ 8,  9, 10, 11],
+           [12, 13, 14, 15]])
+
+    Pass the array to get the indices of the lower triangular elements.
+
+    >>> trili = np.tril_indices_from(a)
+    >>> trili
+    (array([0, 1, 1, 2, 2, 2, 3, 3, 3, 3]), array([0, 0, 1, 0, 1, 2, 0, 1, 2, 3]))
+
+    >>> a[trili]
+    array([ 0,  4,  5,  8,  9, 10, 12, 13, 14, 15])
+
+    This is syntactic sugar for tril_indices().
+
+    >>> np.tril_indices(a.shape[0])
+    (array([0, 1, 1, 2, 2, 2, 3, 3, 3, 3]), array([0, 0, 1, 0, 1, 2, 0, 1, 2, 3]))
+
+    Use the `k` parameter to return the indices for the lower triangular array
+    up to the k-th diagonal.
+
+    >>> trili1 = np.tril_indices_from(a, k=1)
+    >>> a[trili1]
+    array([ 0,  1,  4,  5,  6,  8,  9, 10, 11, 12, 13, 14, 15])
+
+    See Also
+    --------
+    tril_indices, tril, triu_indices_from
+
+    Notes
+    -----
+    .. versionadded:: 1.4.0
+
+    """
+    if arr.ndim != 2:
+        raise ValueError("input array must be 2-d")
+    return tril_indices(arr.shape[-2], k=k, m=arr.shape[-1])
+
+
+@set_module('numpy')
+def triu_indices(n, k=0, m=None):
+    """
+    Return the indices for the upper-triangle of an (n, m) array.
+
+    Parameters
+    ----------
+    n : int
+        The size of the arrays for which the returned indices will
+        be valid.
+    k : int, optional
+        Diagonal offset (see `triu` for details).
+    m : int, optional
+        .. versionadded:: 1.9.0
+
+        The column dimension of the arrays for which the returned
+        arrays will be valid.
+        By default `m` is taken equal to `n`.
+
+
+    Returns
+    -------
+    inds : tuple, shape(2) of ndarrays, shape(`n`)
+        The indices for the triangle. The returned tuple contains two arrays,
+        each with the indices along one dimension of the array.  Can be used
+        to slice a ndarray of shape(`n`, `n`).
+
+    See also
+    --------
+    tril_indices : similar function, for lower-triangular.
+    mask_indices : generic function accepting an arbitrary mask function.
+    triu, tril
+
+    Notes
+    -----
+    .. versionadded:: 1.4.0
+
+    Examples
+    --------
+    >>> import numpy as np
+
+    Compute two different sets of indices to access 4x4 arrays, one for the
+    upper triangular part starting at the main diagonal, and one starting two
+    diagonals further right:
+
+    >>> iu1 = np.triu_indices(4)
+    >>> iu2 = np.triu_indices(4, 2)
+
+    Here is how they can be used with a sample array:
+
+    >>> a = np.arange(16).reshape(4, 4)
+    >>> a
+    array([[ 0,  1,  2,  3],
+           [ 4,  5,  6,  7],
+           [ 8,  9, 10, 11],
+           [12, 13, 14, 15]])
+
+    Both for indexing:
+
+    >>> a[iu1]
+    array([ 0,  1,  2, ..., 10, 11, 15])
+
+    And for assigning values:
+
+    >>> a[iu1] = -1
+    >>> a
+    array([[-1, -1, -1, -1],
+           [ 4, -1, -1, -1],
+           [ 8,  9, -1, -1],
+           [12, 13, 14, -1]])
+
+    These cover only a small part of the whole array (two diagonals right
+    of the main one):
+
+    >>> a[iu2] = -10
+    >>> a
+    array([[ -1,  -1, -10, -10],
+           [  4,  -1,  -1, -10],
+           [  8,   9,  -1,  -1],
+           [ 12,  13,  14,  -1]])
+
+    """
+    tri_ = ~tri(n, m, k=k - 1, dtype=bool)
+
+    return tuple(broadcast_to(inds, tri_.shape)[tri_]
+                 for inds in indices(tri_.shape, sparse=True))
+
+
+@array_function_dispatch(_trilu_indices_form_dispatcher)
+def triu_indices_from(arr, k=0):
+    """
+    Return the indices for the upper-triangle of arr.
+
+    See `triu_indices` for full details.
+
+    Parameters
+    ----------
+    arr : ndarray, shape(N, N)
+        The indices will be valid for square arrays.
+    k : int, optional
+        Diagonal offset (see `triu` for details).
+
+    Returns
+    -------
+    triu_indices_from : tuple, shape(2) of ndarray, shape(N)
+        Indices for the upper-triangle of `arr`.
+
+    Examples
+    --------
+    >>> import numpy as np
+
+    Create a 4 by 4 array
+
+    >>> a = np.arange(16).reshape(4, 4)
+    >>> a
+    array([[ 0,  1,  2,  3],
+           [ 4,  5,  6,  7],
+           [ 8,  9, 10, 11],
+           [12, 13, 14, 15]])
+
+    Pass the array to get the indices of the upper triangular elements.
+
+    >>> triui = np.triu_indices_from(a)
+    >>> triui
+    (array([0, 0, 0, 0, 1, 1, 1, 2, 2, 3]), array([0, 1, 2, 3, 1, 2, 3, 2, 3, 3]))
+
+    >>> a[triui]
+    array([ 0,  1,  2,  3,  5,  6,  7, 10, 11, 15])
+
+    This is syntactic sugar for triu_indices().
+
+    >>> np.triu_indices(a.shape[0])
+    (array([0, 0, 0, 0, 1, 1, 1, 2, 2, 3]), array([0, 1, 2, 3, 1, 2, 3, 2, 3, 3]))
+
+    Use the `k` parameter to return the indices for the upper triangular array
+    from the k-th diagonal.
+
+    >>> triuim1 = np.triu_indices_from(a, k=1)
+    >>> a[triuim1]
+    array([ 1,  2,  3,  6,  7, 11])
+
+
+    See Also
+    --------
+    triu_indices, triu, tril_indices_from
+
+    Notes
+    -----
+    .. versionadded:: 1.4.0
+
+    """
+    if arr.ndim != 2:
+        raise ValueError("input array must be 2-d")
+    return triu_indices(arr.shape[-2], k=k, m=arr.shape[-1])
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/_twodim_base_impl.pyi b/venv/lib/python3.12/site-packages/numpy/lib/_twodim_base_impl.pyi
new file mode 100644
index 00000000..c4690a43
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/lib/_twodim_base_impl.pyi
@@ -0,0 +1,422 @@
+import builtins
+from collections.abc import Callable, Sequence
+from typing import (
+    Any,
+    TypeAlias,
+    overload,
+    TypeVar,
+    Literal as L,
+)
+
+import numpy as np
+from numpy import (
+    generic,
+    number,
+    timedelta64,
+    datetime64,
+    int_,
+    intp,
+    float64,
+    complex128,
+    signedinteger,
+    floating,
+    complexfloating,
+    object_,
+    _OrderCF,
+)
+
+from numpy._typing import (
+    DTypeLike,
+    _DTypeLike,
+    ArrayLike,
+    _ArrayLike,
+    NDArray,
+    _SupportsArray,
+    _SupportsArrayFunc,
+    _ArrayLikeInt_co,
+    _ArrayLikeFloat_co,
+    _ArrayLikeComplex_co,
+    _ArrayLikeObject_co,
+)
+
+_T = TypeVar("_T")
+_SCT = TypeVar("_SCT", bound=generic)
+
+# The returned arrays dtype must be compatible with `np.equal`
+_MaskFunc = Callable[
+    [NDArray[int_], _T],
+    NDArray[number[Any] | np.bool | timedelta64 | datetime64 | object_],
+]
+
+__all__: list[str]
+
+@overload
+def fliplr(m: _ArrayLike[_SCT]) -> NDArray[_SCT]: ...
+@overload
+def fliplr(m: ArrayLike) -> NDArray[Any]: ...
+
+@overload
+def flipud(m: _ArrayLike[_SCT]) -> NDArray[_SCT]: ...
+@overload
+def flipud(m: ArrayLike) -> NDArray[Any]: ...
+
+@overload
+def eye(
+    N: int,
+    M: None | int = ...,
+    k: int = ...,
+    dtype: None = ...,
+    order: _OrderCF = ...,
+    *,
+    device: None | L["cpu"] = ...,
+    like: None | _SupportsArrayFunc = ...,
+) -> NDArray[float64]: ...
+@overload
+def eye(
+    N: int,
+    M: None | int = ...,
+    k: int = ...,
+    dtype: _DTypeLike[_SCT] = ...,
+    order: _OrderCF = ...,
+    *,
+    device: None | L["cpu"] = ...,
+    like: None | _SupportsArrayFunc = ...,
+) -> NDArray[_SCT]: ...
+@overload
+def eye(
+    N: int,
+    M: None | int = ...,
+    k: int = ...,
+    dtype: DTypeLike = ...,
+    order: _OrderCF = ...,
+    *,
+    device: None | L["cpu"] = ...,
+    like: None | _SupportsArrayFunc = ...,
+) -> NDArray[Any]: ...
+
+@overload
+def diag(v: _ArrayLike[_SCT], k: int = ...) -> NDArray[_SCT]: ...
+@overload
+def diag(v: ArrayLike, k: int = ...) -> NDArray[Any]: ...
+
+@overload
+def diagflat(v: _ArrayLike[_SCT], k: int = ...) -> NDArray[_SCT]: ...
+@overload
+def diagflat(v: ArrayLike, k: int = ...) -> NDArray[Any]: ...
+
+@overload
+def tri(
+    N: int,
+    M: None | int = ...,
+    k: int = ...,
+    dtype: None = ...,
+    *,
+    like: None | _SupportsArrayFunc = ...
+) -> NDArray[float64]: ...
+@overload
+def tri(
+    N: int,
+    M: None | int = ...,
+    k: int = ...,
+    dtype: _DTypeLike[_SCT] = ...,
+    *,
+    like: None | _SupportsArrayFunc = ...
+) -> NDArray[_SCT]: ...
+@overload
+def tri(
+    N: int,
+    M: None | int = ...,
+    k: int = ...,
+    dtype: DTypeLike = ...,
+    *,
+    like: None | _SupportsArrayFunc = ...
+) -> NDArray[Any]: ...
+
+@overload
+def tril(v: _ArrayLike[_SCT], k: int = ...) -> NDArray[_SCT]: ...
+@overload
+def tril(v: ArrayLike, k: int = ...) -> NDArray[Any]: ...
+
+@overload
+def triu(v: _ArrayLike[_SCT], k: int = ...) -> NDArray[_SCT]: ...
+@overload
+def triu(v: ArrayLike, k: int = ...) -> NDArray[Any]: ...
+
+@overload
+def vander(  # type: ignore[misc]
+    x: _ArrayLikeInt_co,
+    N: None | int = ...,
+    increasing: bool = ...,
+) -> NDArray[signedinteger[Any]]: ...
+@overload
+def vander(  # type: ignore[misc]
+    x: _ArrayLikeFloat_co,
+    N: None | int = ...,
+    increasing: bool = ...,
+) -> NDArray[floating[Any]]: ...
+@overload
+def vander(
+    x: _ArrayLikeComplex_co,
+    N: None | int = ...,
+    increasing: bool = ...,
+) -> NDArray[complexfloating[Any, Any]]: ...
+@overload
+def vander(
+    x: _ArrayLikeObject_co,
+    N: None | int = ...,
+    increasing: bool = ...,
+) -> NDArray[object_]: ...
+
+
+_Int_co: TypeAlias = np.integer[Any] | np.bool
+_Float_co: TypeAlias = np.floating[Any] | _Int_co
+_Number_co: TypeAlias = np.number[Any] | np.bool
+
+_ArrayLike1D: TypeAlias = _SupportsArray[np.dtype[_SCT]] | Sequence[_SCT]
+_ArrayLike2D: TypeAlias = (
+    _SupportsArray[np.dtype[_SCT]]
+    | Sequence[_ArrayLike1D[_SCT]]
+)
+
+_ArrayLike1DInt_co = (
+    _SupportsArray[np.dtype[_Int_co]]
+    | Sequence[int | _Int_co]
+)
+_ArrayLike1DFloat_co = (
+    _SupportsArray[np.dtype[_Float_co]]
+    | Sequence[float | int | _Float_co]
+)
+_ArrayLike2DFloat_co = (
+    _SupportsArray[np.dtype[_Float_co]]
+    | Sequence[_ArrayLike1DFloat_co]
+)
+_ArrayLike1DNumber_co = (
+    _SupportsArray[np.dtype[_Number_co]]
+    | Sequence[int | float | complex | _Number_co]
+)
+
+_SCT_complex = TypeVar("_SCT_complex", bound=np.complexfloating[Any, Any])
+_SCT_inexact = TypeVar("_SCT_inexact", bound=np.inexact[Any])
+_SCT_number_co = TypeVar("_SCT_number_co", bound=_Number_co)
+
+@overload
+def histogram2d(
+    x: _ArrayLike1D[_SCT_complex],
+    y: _ArrayLike1D[_SCT_complex | _Float_co],
+    bins: int | Sequence[int] = ...,
+    range: None | _ArrayLike2DFloat_co = ...,
+    density: None | bool = ...,
+    weights: None | _ArrayLike1DFloat_co = ...,
+) -> tuple[
+    NDArray[float64],
+    NDArray[_SCT_complex],
+    NDArray[_SCT_complex],
+]: ...
+@overload
+def histogram2d(
+    x: _ArrayLike1D[_SCT_complex | _Float_co],
+    y: _ArrayLike1D[_SCT_complex],
+    bins: int | Sequence[int] = ...,
+    range: None | _ArrayLike2DFloat_co = ...,
+    density: None | bool = ...,
+    weights: None | _ArrayLike1DFloat_co = ...,
+) -> tuple[
+    NDArray[float64],
+    NDArray[_SCT_complex],
+    NDArray[_SCT_complex],
+]: ...
+@overload
+def histogram2d(
+    x: _ArrayLike1D[_SCT_inexact],
+    y: _ArrayLike1D[_SCT_inexact | _Int_co],
+    bins: int | Sequence[int] = ...,
+    range: None | _ArrayLike2DFloat_co = ...,
+    density: None | bool = ...,
+    weights: None | _ArrayLike1DFloat_co = ...,
+) -> tuple[
+    NDArray[float64],
+    NDArray[_SCT_inexact],
+    NDArray[_SCT_inexact],
+]: ...
+@overload
+def histogram2d(
+    x: _ArrayLike1D[_SCT_inexact | _Int_co],
+    y: _ArrayLike1D[_SCT_inexact],
+    bins: int | Sequence[int] = ...,
+    range: None | _ArrayLike2DFloat_co = ...,
+    density: None | bool = ...,
+    weights: None | _ArrayLike1DFloat_co = ...,
+) -> tuple[
+    NDArray[float64],
+    NDArray[_SCT_inexact],
+    NDArray[_SCT_inexact],
+]: ...
+@overload
+def histogram2d(
+    x: _ArrayLike1DInt_co | Sequence[float | int],
+    y: _ArrayLike1DInt_co | Sequence[float | int],
+    bins: int | Sequence[int] = ...,
+    range: None | _ArrayLike2DFloat_co = ...,
+    density: None | bool = ...,
+    weights: None | _ArrayLike1DFloat_co = ...,
+) -> tuple[
+    NDArray[float64],
+    NDArray[float64],
+    NDArray[float64],
+]: ...
+@overload
+def histogram2d(
+    x: Sequence[complex | float | int],
+    y: Sequence[complex | float | int],
+    bins: int | Sequence[int] = ...,
+    range: None | _ArrayLike2DFloat_co = ...,
+    density: None | bool = ...,
+    weights: None | _ArrayLike1DFloat_co = ...,
+) -> tuple[
+    NDArray[float64],
+    NDArray[complex128 | float64],
+    NDArray[complex128 | float64],
+]: ...
+@overload
+def histogram2d(
+    x: _ArrayLike1DNumber_co,
+    y: _ArrayLike1DNumber_co,
+    bins: _ArrayLike1D[_SCT_number_co] | Sequence[_ArrayLike1D[_SCT_number_co]],
+    range: None | _ArrayLike2DFloat_co = ...,
+    density: None | bool = ...,
+    weights: None | _ArrayLike1DFloat_co = ...,
+) -> tuple[
+    NDArray[float64],
+    NDArray[_SCT_number_co],
+    NDArray[_SCT_number_co],
+]: ...
+@overload
+def histogram2d(
+    x: _ArrayLike1D[_SCT_inexact],
+    y: _ArrayLike1D[_SCT_inexact],
+    bins: Sequence[_ArrayLike1D[_SCT_number_co] | int],
+    range: None | _ArrayLike2DFloat_co = ...,
+    density: None | bool = ...,
+    weights: None | _ArrayLike1DFloat_co = ...,
+) -> tuple[
+    NDArray[float64],
+    NDArray[_SCT_number_co | _SCT_inexact],
+    NDArray[_SCT_number_co | _SCT_inexact],
+]: ...
+@overload
+def histogram2d(
+    x: _ArrayLike1DInt_co | Sequence[float | int],
+    y: _ArrayLike1DInt_co | Sequence[float | int],
+    bins: Sequence[_ArrayLike1D[_SCT_number_co] | int],
+    range: None | _ArrayLike2DFloat_co = ...,
+    density: None | bool = ...,
+    weights: None | _ArrayLike1DFloat_co = ...,
+) -> tuple[
+    NDArray[float64],
+    NDArray[_SCT_number_co | float64],
+    NDArray[_SCT_number_co | float64],
+]: ...
+@overload
+def histogram2d(
+    x: Sequence[complex | float | int],
+    y: Sequence[complex | float | int],
+    bins: Sequence[_ArrayLike1D[_SCT_number_co] | int],
+    range: None | _ArrayLike2DFloat_co = ...,
+    density: None | bool = ...,
+    weights: None | _ArrayLike1DFloat_co = ...,
+) -> tuple[
+    NDArray[float64],
+    NDArray[_SCT_number_co | complex128 | float64],
+    NDArray[_SCT_number_co | complex128 | float64] ,
+]: ...
+
+@overload
+def histogram2d(
+    x: _ArrayLike1DNumber_co,
+    y: _ArrayLike1DNumber_co,
+    bins: Sequence[Sequence[bool]],
+    range: None | _ArrayLike2DFloat_co = ...,
+    density: None | bool = ...,
+    weights: None | _ArrayLike1DFloat_co = ...,
+) -> tuple[
+    NDArray[float64],
+    NDArray[np.bool],
+    NDArray[np.bool],
+]: ...
+@overload
+def histogram2d(
+    x: _ArrayLike1DNumber_co,
+    y: _ArrayLike1DNumber_co,
+    bins: Sequence[Sequence[int | bool]],
+    range: None | _ArrayLike2DFloat_co = ...,
+    density: None | bool = ...,
+    weights: None | _ArrayLike1DFloat_co = ...,
+) -> tuple[
+    NDArray[float64],
+    NDArray[np.int_ | np.bool],
+    NDArray[np.int_ | np.bool],
+]: ...
+@overload
+def histogram2d(
+    x: _ArrayLike1DNumber_co,
+    y: _ArrayLike1DNumber_co,
+    bins: Sequence[Sequence[float | int | bool]],
+    range: None | _ArrayLike2DFloat_co = ...,
+    density: None | bool = ...,
+    weights: None | _ArrayLike1DFloat_co = ...,
+) -> tuple[
+    NDArray[float64],
+    NDArray[np.float64 | np.int_ | np.bool],
+    NDArray[np.float64 | np.int_ | np.bool],
+]: ...
+@overload
+def histogram2d(
+    x: _ArrayLike1DNumber_co,
+    y: _ArrayLike1DNumber_co,
+    bins: Sequence[Sequence[complex | float | int | bool]],
+    range: None | _ArrayLike2DFloat_co = ...,
+    density: None | bool = ...,
+    weights: None | _ArrayLike1DFloat_co = ...,
+) -> tuple[
+    NDArray[float64],
+    NDArray[np.complex128 | np.float64 | np.int_ | np.bool],
+    NDArray[np.complex128 | np.float64 | np.int_ | np.bool],
+]: ...
+
+# NOTE: we're assuming/demanding here the `mask_func` returns
+# an ndarray of shape `(n, n)`; otherwise there is the possibility
+# of the output tuple having more or less than 2 elements
+@overload
+def mask_indices(
+    n: int,
+    mask_func: _MaskFunc[int],
+    k: int = ...,
+) -> tuple[NDArray[intp], NDArray[intp]]: ...
+@overload
+def mask_indices(
+    n: int,
+    mask_func: _MaskFunc[_T],
+    k: _T,
+) -> tuple[NDArray[intp], NDArray[intp]]: ...
+
+def tril_indices(
+    n: int,
+    k: int = ...,
+    m: None | int = ...,
+) -> tuple[NDArray[int_], NDArray[int_]]: ...
+
+def tril_indices_from(
+    arr: NDArray[Any],
+    k: int = ...,
+) -> tuple[NDArray[int_], NDArray[int_]]: ...
+
+def triu_indices(
+    n: int,
+    k: int = ...,
+    m: None | int = ...,
+) -> tuple[NDArray[int_], NDArray[int_]]: ...
+
+def triu_indices_from(
+    arr: NDArray[Any],
+    k: int = ...,
+) -> tuple[NDArray[int_], NDArray[int_]]: ...
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/_type_check_impl.py b/venv/lib/python3.12/site-packages/numpy/lib/_type_check_impl.py
new file mode 100644
index 00000000..5f662f6e
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/lib/_type_check_impl.py
@@ -0,0 +1,709 @@
+"""Automatically adapted for numpy Sep 19, 2005 by convertcode.py
+
+"""
+import functools
+
+__all__ = ['iscomplexobj', 'isrealobj', 'imag', 'iscomplex',
+           'isreal', 'nan_to_num', 'real', 'real_if_close',
+           'typename', 'mintypecode',
+           'common_type']
+
+from .._utils import set_module
+import numpy._core.numeric as _nx
+from numpy._core.numeric import asarray, asanyarray, isnan, zeros
+from numpy._core import overrides, getlimits
+from ._ufunclike_impl import isneginf, isposinf
+
+
+array_function_dispatch = functools.partial(
+    overrides.array_function_dispatch, module='numpy')
+
+
+_typecodes_by_elsize = 'GDFgdfQqLlIiHhBb?'
+
+
+@set_module('numpy')
+def mintypecode(typechars, typeset='GDFgdf', default='d'):
+    """
+    Return the character for the minimum-size type to which given types can
+    be safely cast.
+
+    The returned type character must represent the smallest size dtype such
+    that an array of the returned type can handle the data from an array of
+    all types in `typechars` (or if `typechars` is an array, then its
+    dtype.char).
+
+    Parameters
+    ----------
+    typechars : list of str or array_like
+        If a list of strings, each string should represent a dtype.
+        If array_like, the character representation of the array dtype is used.
+    typeset : str or list of str, optional
+        The set of characters that the returned character is chosen from.
+        The default set is 'GDFgdf'.
+    default : str, optional
+        The default character, this is returned if none of the characters in
+        `typechars` matches a character in `typeset`.
+
+    Returns
+    -------
+    typechar : str
+        The character representing the minimum-size type that was found.
+
+    See Also
+    --------
+    dtype
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> np.mintypecode(['d', 'f', 'S'])
+    'd'
+    >>> x = np.array([1.1, 2-3.j])
+    >>> np.mintypecode(x)
+    'D'
+
+    >>> np.mintypecode('abceh', default='G')
+    'G'
+
+    """
+    typecodes = ((isinstance(t, str) and t) or asarray(t).dtype.char
+                 for t in typechars)
+    intersection = set(t for t in typecodes if t in typeset)
+    if not intersection:
+        return default
+    if 'F' in intersection and 'd' in intersection:
+        return 'D'
+    return min(intersection, key=_typecodes_by_elsize.index)
+
+
+def _real_dispatcher(val):
+    return (val,)
+
+
+@array_function_dispatch(_real_dispatcher)
+def real(val):
+    """
+    Return the real part of the complex argument.
+
+    Parameters
+    ----------
+    val : array_like
+        Input array.
+
+    Returns
+    -------
+    out : ndarray or scalar
+        The real component of the complex argument. If `val` is real, the type
+        of `val` is used for the output.  If `val` has complex elements, the
+        returned type is float.
+
+    See Also
+    --------
+    real_if_close, imag, angle
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> a = np.array([1+2j, 3+4j, 5+6j])
+    >>> a.real
+    array([1.,  3.,  5.])
+    >>> a.real = 9
+    >>> a
+    array([9.+2.j,  9.+4.j,  9.+6.j])
+    >>> a.real = np.array([9, 8, 7])
+    >>> a
+    array([9.+2.j,  8.+4.j,  7.+6.j])
+    >>> np.real(1 + 1j)
+    1.0
+
+    """
+    try:
+        return val.real
+    except AttributeError:
+        return asanyarray(val).real
+
+
+def _imag_dispatcher(val):
+    return (val,)
+
+
+@array_function_dispatch(_imag_dispatcher)
+def imag(val):
+    """
+    Return the imaginary part of the complex argument.
+
+    Parameters
+    ----------
+    val : array_like
+        Input array.
+
+    Returns
+    -------
+    out : ndarray or scalar
+        The imaginary component of the complex argument. If `val` is real,
+        the type of `val` is used for the output.  If `val` has complex
+        elements, the returned type is float.
+
+    See Also
+    --------
+    real, angle, real_if_close
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> a = np.array([1+2j, 3+4j, 5+6j])
+    >>> a.imag
+    array([2.,  4.,  6.])
+    >>> a.imag = np.array([8, 10, 12])
+    >>> a
+    array([1. +8.j,  3.+10.j,  5.+12.j])
+    >>> np.imag(1 + 1j)
+    1.0
+
+    """
+    try:
+        return val.imag
+    except AttributeError:
+        return asanyarray(val).imag
+
+
+def _is_type_dispatcher(x):
+    return (x,)
+
+
+@array_function_dispatch(_is_type_dispatcher)
+def iscomplex(x):
+    """
+    Returns a bool array, where True if input element is complex.
+
+    What is tested is whether the input has a non-zero imaginary part, not if
+    the input type is complex.
+
+    Parameters
+    ----------
+    x : array_like
+        Input array.
+
+    Returns
+    -------
+    out : ndarray of bools
+        Output array.
+
+    See Also
+    --------
+    isreal
+    iscomplexobj : Return True if x is a complex type or an array of complex
+                   numbers.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> np.iscomplex([1+1j, 1+0j, 4.5, 3, 2, 2j])
+    array([ True, False, False, False, False,  True])
+
+    """
+    ax = asanyarray(x)
+    if issubclass(ax.dtype.type, _nx.complexfloating):
+        return ax.imag != 0
+    res = zeros(ax.shape, bool)
+    return res[()]   # convert to scalar if needed
+
+
+@array_function_dispatch(_is_type_dispatcher)
+def isreal(x):
+    """
+    Returns a bool array, where True if input element is real.
+
+    If element has complex type with zero imaginary part, the return value
+    for that element is True.
+
+    Parameters
+    ----------
+    x : array_like
+        Input array.
+
+    Returns
+    -------
+    out : ndarray, bool
+        Boolean array of same shape as `x`.
+
+    Notes
+    -----
+    `isreal` may behave unexpectedly for string or object arrays (see examples)
+
+    See Also
+    --------
+    iscomplex
+    isrealobj : Return True if x is not a complex type.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> a = np.array([1+1j, 1+0j, 4.5, 3, 2, 2j], dtype=complex)
+    >>> np.isreal(a)
+    array([False,  True,  True,  True,  True, False])
+
+    The function does not work on string arrays.
+
+    >>> a = np.array([2j, "a"], dtype="U")
+    >>> np.isreal(a)  # Warns about non-elementwise comparison
+    False
+
+    Returns True for all elements in input array of ``dtype=object`` even if
+    any of the elements is complex.
+
+    >>> a = np.array([1, "2", 3+4j], dtype=object)
+    >>> np.isreal(a)
+    array([ True,  True,  True])
+
+    isreal should not be used with object arrays
+
+    >>> a = np.array([1+2j, 2+1j], dtype=object)
+    >>> np.isreal(a)
+    array([ True,  True])
+
+    """
+    return imag(x) == 0
+
+
+@array_function_dispatch(_is_type_dispatcher)
+def iscomplexobj(x):
+    """
+    Check for a complex type or an array of complex numbers.
+
+    The type of the input is checked, not the value. Even if the input
+    has an imaginary part equal to zero, `iscomplexobj` evaluates to True.
+
+    Parameters
+    ----------
+    x : any
+        The input can be of any type and shape.
+
+    Returns
+    -------
+    iscomplexobj : bool
+        The return value, True if `x` is of a complex type or has at least
+        one complex element.
+
+    See Also
+    --------
+    isrealobj, iscomplex
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> np.iscomplexobj(1)
+    False
+    >>> np.iscomplexobj(1+0j)
+    True
+    >>> np.iscomplexobj([3, 1+0j, True])
+    True
+
+    """
+    try:
+        dtype = x.dtype
+        type_ = dtype.type
+    except AttributeError:
+        type_ = asarray(x).dtype.type
+    return issubclass(type_, _nx.complexfloating)
+
+
+@array_function_dispatch(_is_type_dispatcher)
+def isrealobj(x):
+    """
+    Return True if x is a not complex type or an array of complex numbers.
+
+    The type of the input is checked, not the value. So even if the input
+    has an imaginary part equal to zero, `isrealobj` evaluates to False
+    if the data type is complex.
+
+    Parameters
+    ----------
+    x : any
+        The input can be of any type and shape.
+
+    Returns
+    -------
+    y : bool
+        The return value, False if `x` is of a complex type.
+
+    See Also
+    --------
+    iscomplexobj, isreal
+
+    Notes
+    -----
+    The function is only meant for arrays with numerical values but it
+    accepts all other objects. Since it assumes array input, the return
+    value of other objects may be True.
+
+    >>> np.isrealobj('A string')
+    True
+    >>> np.isrealobj(False)
+    True
+    >>> np.isrealobj(None)
+    True
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> np.isrealobj(1)
+    True
+    >>> np.isrealobj(1+0j)
+    False
+    >>> np.isrealobj([3, 1+0j, True])
+    False
+
+    """
+    return not iscomplexobj(x)
+
+#-----------------------------------------------------------------------------
+
+def _getmaxmin(t):
+    from numpy._core import getlimits
+    f = getlimits.finfo(t)
+    return f.max, f.min
+
+
+def _nan_to_num_dispatcher(x, copy=None, nan=None, posinf=None, neginf=None):
+    return (x,)
+
+
+@array_function_dispatch(_nan_to_num_dispatcher)
+def nan_to_num(x, copy=True, nan=0.0, posinf=None, neginf=None):
+    """
+    Replace NaN with zero and infinity with large finite numbers (default
+    behaviour) or with the numbers defined by the user using the `nan`,
+    `posinf` and/or `neginf` keywords.
+
+    If `x` is inexact, NaN is replaced by zero or by the user defined value in
+    `nan` keyword, infinity is replaced by the largest finite floating point
+    values representable by ``x.dtype`` or by the user defined value in
+    `posinf` keyword and -infinity is replaced by the most negative finite
+    floating point values representable by ``x.dtype`` or by the user defined
+    value in `neginf` keyword.
+
+    For complex dtypes, the above is applied to each of the real and
+    imaginary components of `x` separately.
+
+    If `x` is not inexact, then no replacements are made.
+
+    Parameters
+    ----------
+    x : scalar or array_like
+        Input data.
+    copy : bool, optional
+        Whether to create a copy of `x` (True) or to replace values
+        in-place (False). The in-place operation only occurs if
+        casting to an array does not require a copy.
+        Default is True.
+
+        .. versionadded:: 1.13
+    nan : int, float, optional
+        Value to be used to fill NaN values. If no value is passed
+        then NaN values will be replaced with 0.0.
+
+        .. versionadded:: 1.17
+    posinf : int, float, optional
+        Value to be used to fill positive infinity values. If no value is
+        passed then positive infinity values will be replaced with a very
+        large number.
+
+        .. versionadded:: 1.17
+    neginf : int, float, optional
+        Value to be used to fill negative infinity values. If no value is
+        passed then negative infinity values will be replaced with a very
+        small (or negative) number.
+
+        .. versionadded:: 1.17
+
+
+
+    Returns
+    -------
+    out : ndarray
+        `x`, with the non-finite values replaced. If `copy` is False, this may
+        be `x` itself.
+
+    See Also
+    --------
+    isinf : Shows which elements are positive or negative infinity.
+    isneginf : Shows which elements are negative infinity.
+    isposinf : Shows which elements are positive infinity.
+    isnan : Shows which elements are Not a Number (NaN).
+    isfinite : Shows which elements are finite (not NaN, not infinity)
+
+    Notes
+    -----
+    NumPy uses the IEEE Standard for Binary Floating-Point for Arithmetic
+    (IEEE 754). This means that Not a Number is not equivalent to infinity.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> np.nan_to_num(np.inf)
+    1.7976931348623157e+308
+    >>> np.nan_to_num(-np.inf)
+    -1.7976931348623157e+308
+    >>> np.nan_to_num(np.nan)
+    0.0
+    >>> x = np.array([np.inf, -np.inf, np.nan, -128, 128])
+    >>> np.nan_to_num(x)
+    array([ 1.79769313e+308, -1.79769313e+308,  0.00000000e+000, # may vary
+           -1.28000000e+002,  1.28000000e+002])
+    >>> np.nan_to_num(x, nan=-9999, posinf=33333333, neginf=33333333)
+    array([ 3.3333333e+07,  3.3333333e+07, -9.9990000e+03,
+           -1.2800000e+02,  1.2800000e+02])
+    >>> y = np.array([complex(np.inf, np.nan), np.nan, complex(np.nan, np.inf)])
+    array([  1.79769313e+308,  -1.79769313e+308,   0.00000000e+000, # may vary
+         -1.28000000e+002,   1.28000000e+002])
+    >>> np.nan_to_num(y)
+    array([  1.79769313e+308 +0.00000000e+000j, # may vary
+             0.00000000e+000 +0.00000000e+000j,
+             0.00000000e+000 +1.79769313e+308j])
+    >>> np.nan_to_num(y, nan=111111, posinf=222222)
+    array([222222.+111111.j, 111111.     +0.j, 111111.+222222.j])
+    """
+    x = _nx.array(x, subok=True, copy=copy)
+    xtype = x.dtype.type
+
+    isscalar = (x.ndim == 0)
+
+    if not issubclass(xtype, _nx.inexact):
+        return x[()] if isscalar else x
+
+    iscomplex = issubclass(xtype, _nx.complexfloating)
+
+    dest = (x.real, x.imag) if iscomplex else (x,)
+    maxf, minf = _getmaxmin(x.real.dtype)
+    if posinf is not None:
+        maxf = posinf
+    if neginf is not None:
+        minf = neginf
+    for d in dest:
+        idx_nan = isnan(d)
+        idx_posinf = isposinf(d)
+        idx_neginf = isneginf(d)
+        _nx.copyto(d, nan, where=idx_nan)
+        _nx.copyto(d, maxf, where=idx_posinf)
+        _nx.copyto(d, minf, where=idx_neginf)
+    return x[()] if isscalar else x
+
+#-----------------------------------------------------------------------------
+
+def _real_if_close_dispatcher(a, tol=None):
+    return (a,)
+
+
+@array_function_dispatch(_real_if_close_dispatcher)
+def real_if_close(a, tol=100):
+    """
+    If input is complex with all imaginary parts close to zero, return
+    real parts.
+
+    "Close to zero" is defined as `tol` * (machine epsilon of the type for
+    `a`).
+
+    Parameters
+    ----------
+    a : array_like
+        Input array.
+    tol : float
+        Tolerance in machine epsilons for the complex part of the elements
+        in the array. If the tolerance is <=1, then the absolute tolerance
+        is used.
+
+    Returns
+    -------
+    out : ndarray
+        If `a` is real, the type of `a` is used for the output.  If `a`
+        has complex elements, the returned type is float.
+
+    See Also
+    --------
+    real, imag, angle
+
+    Notes
+    -----
+    Machine epsilon varies from machine to machine and between data types
+    but Python floats on most platforms have a machine epsilon equal to
+    2.2204460492503131e-16.  You can use 'np.finfo(float).eps' to print
+    out the machine epsilon for floats.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> np.finfo(float).eps
+    2.2204460492503131e-16 # may vary
+
+    >>> np.real_if_close([2.1 + 4e-14j, 5.2 + 3e-15j], tol=1000)
+    array([2.1, 5.2])
+    >>> np.real_if_close([2.1 + 4e-13j, 5.2 + 3e-15j], tol=1000)
+    array([2.1+4.e-13j, 5.2 + 3e-15j])
+
+    """
+    a = asanyarray(a)
+    type_ = a.dtype.type
+    if not issubclass(type_, _nx.complexfloating):
+        return a
+    if tol > 1:
+        f = getlimits.finfo(type_)
+        tol = f.eps * tol
+    if _nx.all(_nx.absolute(a.imag) < tol):
+        a = a.real
+    return a
+
+
+#-----------------------------------------------------------------------------
+
+_namefromtype = {'S1': 'character',
+                 '?': 'bool',
+                 'b': 'signed char',
+                 'B': 'unsigned char',
+                 'h': 'short',
+                 'H': 'unsigned short',
+                 'i': 'integer',
+                 'I': 'unsigned integer',
+                 'l': 'long integer',
+                 'L': 'unsigned long integer',
+                 'q': 'long long integer',
+                 'Q': 'unsigned long long integer',
+                 'f': 'single precision',
+                 'd': 'double precision',
+                 'g': 'long precision',
+                 'F': 'complex single precision',
+                 'D': 'complex double precision',
+                 'G': 'complex long double precision',
+                 'S': 'string',
+                 'U': 'unicode',
+                 'V': 'void',
+                 'O': 'object'
+                 }
+
+@set_module('numpy')
+def typename(char):
+    """
+    Return a description for the given data type code.
+
+    Parameters
+    ----------
+    char : str
+        Data type code.
+
+    Returns
+    -------
+    out : str
+        Description of the input data type code.
+
+    See Also
+    --------
+    dtype
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> typechars = ['S1', '?', 'B', 'D', 'G', 'F', 'I', 'H', 'L', 'O', 'Q',
+    ...              'S', 'U', 'V', 'b', 'd', 'g', 'f', 'i', 'h', 'l', 'q']
+    >>> for typechar in typechars:
+    ...     print(typechar, ' : ', np.typename(typechar))
+    ...
+    S1  :  character
+    ?  :  bool
+    B  :  unsigned char
+    D  :  complex double precision
+    G  :  complex long double precision
+    F  :  complex single precision
+    I  :  unsigned integer
+    H  :  unsigned short
+    L  :  unsigned long integer
+    O  :  object
+    Q  :  unsigned long long integer
+    S  :  string
+    U  :  unicode
+    V  :  void
+    b  :  signed char
+    d  :  double precision
+    g  :  long precision
+    f  :  single precision
+    i  :  integer
+    h  :  short
+    l  :  long integer
+    q  :  long long integer
+
+    """
+    return _namefromtype[char]
+
+#-----------------------------------------------------------------------------
+
+
+#determine the "minimum common type" for a group of arrays.
+array_type = [[_nx.float16, _nx.float32, _nx.float64, _nx.longdouble],
+              [None, _nx.complex64, _nx.complex128, _nx.clongdouble]]
+array_precision = {_nx.float16: 0,
+                   _nx.float32: 1,
+                   _nx.float64: 2,
+                   _nx.longdouble: 3,
+                   _nx.complex64: 1,
+                   _nx.complex128: 2,
+                   _nx.clongdouble: 3}
+
+
+def _common_type_dispatcher(*arrays):
+    return arrays
+
+
+@array_function_dispatch(_common_type_dispatcher)
+def common_type(*arrays):
+    """
+    Return a scalar type which is common to the input arrays.
+
+    The return type will always be an inexact (i.e. floating point) scalar
+    type, even if all the arrays are integer arrays. If one of the inputs is
+    an integer array, the minimum precision type that is returned is a
+    64-bit floating point dtype.
+
+    All input arrays except int64 and uint64 can be safely cast to the
+    returned dtype without loss of information.
+
+    Parameters
+    ----------
+    array1, array2, ... : ndarrays
+        Input arrays.
+
+    Returns
+    -------
+    out : data type code
+        Data type code.
+
+    See Also
+    --------
+    dtype, mintypecode
+
+    Examples
+    --------
+    >>> np.common_type(np.arange(2, dtype=np.float32))
+    
+    >>> np.common_type(np.arange(2, dtype=np.float32), np.arange(2))
+    
+    >>> np.common_type(np.arange(4), np.array([45, 6.j]), np.array([45.0]))
+    
+
+    """
+    is_complex = False
+    precision = 0
+    for a in arrays:
+        t = a.dtype.type
+        if iscomplexobj(a):
+            is_complex = True
+        if issubclass(t, _nx.integer):
+            p = 2  # array_precision[_nx.double]
+        else:
+            p = array_precision.get(t)
+            if p is None:
+                raise TypeError("can't get common type for non-numeric array")
+        precision = max(precision, p)
+    if is_complex:
+        return array_type[1][precision]
+    else:
+        return array_type[0][precision]
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/_type_check_impl.pyi b/venv/lib/python3.12/site-packages/numpy/lib/_type_check_impl.pyi
new file mode 100644
index 00000000..6cc5073b
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/lib/_type_check_impl.pyi
@@ -0,0 +1,204 @@
+from collections.abc import Container, Iterable
+from typing import (
+    Literal as L,
+    Any,
+    overload,
+    TypeVar,
+    Protocol,
+)
+
+import numpy as np
+from numpy import (
+    dtype,
+    generic,
+    floating,
+    float64,
+    complexfloating,
+    integer,
+)
+
+from numpy._typing import (
+    ArrayLike,
+    DTypeLike,
+    NBitBase,
+    NDArray,
+    _64Bit,
+    _SupportsDType,
+    _ScalarLike_co,
+    _ArrayLike,
+    _DTypeLikeComplex,
+)
+
+_T = TypeVar("_T")
+_T_co = TypeVar("_T_co", covariant=True)
+_SCT = TypeVar("_SCT", bound=generic)
+_NBit1 = TypeVar("_NBit1", bound=NBitBase)
+_NBit2 = TypeVar("_NBit2", bound=NBitBase)
+
+class _SupportsReal(Protocol[_T_co]):
+    @property
+    def real(self) -> _T_co: ...
+
+class _SupportsImag(Protocol[_T_co]):
+    @property
+    def imag(self) -> _T_co: ...
+
+__all__: list[str]
+
+def mintypecode(
+    typechars: Iterable[str | ArrayLike],
+    typeset: Container[str] = ...,
+    default: str = ...,
+) -> str: ...
+
+@overload
+def real(val: _SupportsReal[_T]) -> _T: ...
+@overload
+def real(val: ArrayLike) -> NDArray[Any]: ...
+
+@overload
+def imag(val: _SupportsImag[_T]) -> _T: ...
+@overload
+def imag(val: ArrayLike) -> NDArray[Any]: ...
+
+@overload
+def iscomplex(x: _ScalarLike_co) -> np.bool: ...  # type: ignore[misc]
+@overload
+def iscomplex(x: ArrayLike) -> NDArray[np.bool]: ...
+
+@overload
+def isreal(x: _ScalarLike_co) -> np.bool: ...  # type: ignore[misc]
+@overload
+def isreal(x: ArrayLike) -> NDArray[np.bool]: ...
+
+def iscomplexobj(x: _SupportsDType[dtype[Any]] | ArrayLike) -> bool: ...
+
+def isrealobj(x: _SupportsDType[dtype[Any]] | ArrayLike) -> bool: ...
+
+@overload
+def nan_to_num(  # type: ignore[misc]
+    x: _SCT,
+    copy: bool = ...,
+    nan: float = ...,
+    posinf: None | float = ...,
+    neginf: None | float = ...,
+) -> _SCT: ...
+@overload
+def nan_to_num(
+    x: _ScalarLike_co,
+    copy: bool = ...,
+    nan: float = ...,
+    posinf: None | float = ...,
+    neginf: None | float = ...,
+) -> Any: ...
+@overload
+def nan_to_num(
+    x: _ArrayLike[_SCT],
+    copy: bool = ...,
+    nan: float = ...,
+    posinf: None | float = ...,
+    neginf: None | float = ...,
+) -> NDArray[_SCT]: ...
+@overload
+def nan_to_num(
+    x: ArrayLike,
+    copy: bool = ...,
+    nan: float = ...,
+    posinf: None | float = ...,
+    neginf: None | float = ...,
+) -> NDArray[Any]: ...
+
+# If one passes a complex array to `real_if_close`, then one is reasonably
+# expected to verify the output dtype (so we can return an unsafe union here)
+
+@overload
+def real_if_close(  # type: ignore[misc]
+    a: _ArrayLike[complexfloating[_NBit1, _NBit1]],
+    tol: float = ...,
+) -> NDArray[floating[_NBit1]] | NDArray[complexfloating[_NBit1, _NBit1]]: ...
+@overload
+def real_if_close(
+    a: _ArrayLike[_SCT],
+    tol: float = ...,
+) -> NDArray[_SCT]: ...
+@overload
+def real_if_close(
+    a: ArrayLike,
+    tol: float = ...,
+) -> NDArray[Any]: ...
+
+@overload
+def typename(char: L['S1']) -> L['character']: ...
+@overload
+def typename(char: L['?']) -> L['bool']: ...
+@overload
+def typename(char: L['b']) -> L['signed char']: ...
+@overload
+def typename(char: L['B']) -> L['unsigned char']: ...
+@overload
+def typename(char: L['h']) -> L['short']: ...
+@overload
+def typename(char: L['H']) -> L['unsigned short']: ...
+@overload
+def typename(char: L['i']) -> L['integer']: ...
+@overload
+def typename(char: L['I']) -> L['unsigned integer']: ...
+@overload
+def typename(char: L['l']) -> L['long integer']: ...
+@overload
+def typename(char: L['L']) -> L['unsigned long integer']: ...
+@overload
+def typename(char: L['q']) -> L['long long integer']: ...
+@overload
+def typename(char: L['Q']) -> L['unsigned long long integer']: ...
+@overload
+def typename(char: L['f']) -> L['single precision']: ...
+@overload
+def typename(char: L['d']) -> L['double precision']: ...
+@overload
+def typename(char: L['g']) -> L['long precision']: ...
+@overload
+def typename(char: L['F']) -> L['complex single precision']: ...
+@overload
+def typename(char: L['D']) -> L['complex double precision']: ...
+@overload
+def typename(char: L['G']) -> L['complex long double precision']: ...
+@overload
+def typename(char: L['S']) -> L['string']: ...
+@overload
+def typename(char: L['U']) -> L['unicode']: ...
+@overload
+def typename(char: L['V']) -> L['void']: ...
+@overload
+def typename(char: L['O']) -> L['object']: ...
+
+@overload
+def common_type(  # type: ignore[misc]
+    *arrays: _SupportsDType[dtype[
+        integer[Any]
+    ]]
+) -> type[floating[_64Bit]]: ...
+@overload
+def common_type(  # type: ignore[misc]
+    *arrays: _SupportsDType[dtype[
+        floating[_NBit1]
+    ]]
+) -> type[floating[_NBit1]]: ...
+@overload
+def common_type(  # type: ignore[misc]
+    *arrays: _SupportsDType[dtype[
+        integer[Any] | floating[_NBit1]
+    ]]
+) -> type[floating[_NBit1 | _64Bit]]: ...
+@overload
+def common_type(  # type: ignore[misc]
+    *arrays: _SupportsDType[dtype[
+        floating[_NBit1] | complexfloating[_NBit2, _NBit2]
+    ]]
+) -> type[complexfloating[_NBit1 | _NBit2, _NBit1 | _NBit2]]: ...
+@overload
+def common_type(
+    *arrays: _SupportsDType[dtype[
+        integer[Any] | floating[_NBit1] | complexfloating[_NBit2, _NBit2]
+    ]]
+) -> type[complexfloating[_64Bit | _NBit1 | _NBit2, _64Bit | _NBit1 | _NBit2]]: ...
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/_ufunclike_impl.py b/venv/lib/python3.12/site-packages/numpy/lib/_ufunclike_impl.py
new file mode 100644
index 00000000..3f026a2c
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/lib/_ufunclike_impl.py
@@ -0,0 +1,209 @@
+"""
+Module of functions that are like ufuncs in acting on arrays and optionally
+storing results in an output array.
+
+"""
+__all__ = ['fix', 'isneginf', 'isposinf']
+
+import numpy._core.numeric as nx
+from numpy._core.overrides import array_function_dispatch
+import warnings
+import functools
+
+
+def _dispatcher(x, out=None):
+    return (x, out)
+
+
+@array_function_dispatch(_dispatcher, verify=False, module='numpy')
+def fix(x, out=None):
+    """
+    Round to nearest integer towards zero.
+
+    Round an array of floats element-wise to nearest integer towards zero.
+    The rounded values have the same data-type as the input.
+
+    Parameters
+    ----------
+    x : array_like
+        An array to be rounded
+    out : ndarray, optional
+        A location into which the result is stored. If provided, it must have
+        a shape that the input broadcasts to. If not provided or None, a
+        freshly-allocated array is returned.
+
+    Returns
+    -------
+    out : ndarray of floats
+        An array with the same dimensions and data-type as the input.
+        If second argument is not supplied then a new array is returned
+        with the rounded values.
+
+        If a second argument is supplied the result is stored there.
+        The return value ``out`` is then a reference to that array.
+
+    See Also
+    --------
+    rint, trunc, floor, ceil
+    around : Round to given number of decimals
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> np.fix(3.14)
+    3.0
+    >>> np.fix(3)
+    3
+    >>> np.fix([2.1, 2.9, -2.1, -2.9])
+    array([ 2.,  2., -2., -2.])
+
+    """
+    # promote back to an array if flattened
+    res = nx.asanyarray(nx.ceil(x, out=out))
+    res = nx.floor(x, out=res, where=nx.greater_equal(x, 0))
+
+    # when no out argument is passed and no subclasses are involved, flatten
+    # scalars
+    if out is None and type(res) is nx.ndarray:
+        res = res[()]
+    return res
+
+
+@array_function_dispatch(_dispatcher, verify=False, module='numpy')
+def isposinf(x, out=None):
+    """
+    Test element-wise for positive infinity, return result as bool array.
+
+    Parameters
+    ----------
+    x : array_like
+        The input array.
+    out : array_like, optional
+        A location into which the result is stored. If provided, it must have a
+        shape that the input broadcasts to. If not provided or None, a
+        freshly-allocated boolean array is returned.
+
+    Returns
+    -------
+    out : ndarray
+        A boolean array with the same dimensions as the input.
+        If second argument is not supplied then a boolean array is returned
+        with values True where the corresponding element of the input is
+        positive infinity and values False where the element of the input is
+        not positive infinity.
+
+        If a second argument is supplied the result is stored there. If the
+        type of that array is a numeric type the result is represented as zeros
+        and ones, if the type is boolean then as False and True.
+        The return value `out` is then a reference to that array.
+
+    See Also
+    --------
+    isinf, isneginf, isfinite, isnan
+
+    Notes
+    -----
+    NumPy uses the IEEE Standard for Binary Floating-Point for Arithmetic
+    (IEEE 754).
+
+    Errors result if the second argument is also supplied when x is a scalar
+    input, if first and second arguments have different shapes, or if the
+    first argument has complex values
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> np.isposinf(np.inf)
+    True
+    >>> np.isposinf(-np.inf)
+    False
+    >>> np.isposinf([-np.inf, 0., np.inf])
+    array([False, False,  True])
+
+    >>> x = np.array([-np.inf, 0., np.inf])
+    >>> y = np.array([2, 2, 2])
+    >>> np.isposinf(x, y)
+    array([0, 0, 1])
+    >>> y
+    array([0, 0, 1])
+
+    """
+    is_inf = nx.isinf(x)
+    try:
+        signbit = ~nx.signbit(x)
+    except TypeError as e:
+        dtype = nx.asanyarray(x).dtype
+        raise TypeError(f'This operation is not supported for {dtype} values '
+                        'because it would be ambiguous.') from e
+    else:
+        return nx.logical_and(is_inf, signbit, out)
+
+
+@array_function_dispatch(_dispatcher, verify=False, module='numpy')
+def isneginf(x, out=None):
+    """
+    Test element-wise for negative infinity, return result as bool array.
+
+    Parameters
+    ----------
+    x : array_like
+        The input array.
+    out : array_like, optional
+        A location into which the result is stored. If provided, it must have a
+        shape that the input broadcasts to. If not provided or None, a
+        freshly-allocated boolean array is returned.
+
+    Returns
+    -------
+    out : ndarray
+        A boolean array with the same dimensions as the input.
+        If second argument is not supplied then a numpy boolean array is
+        returned with values True where the corresponding element of the
+        input is negative infinity and values False where the element of
+        the input is not negative infinity.
+
+        If a second argument is supplied the result is stored there. If the
+        type of that array is a numeric type the result is represented as
+        zeros and ones, if the type is boolean then as False and True. The
+        return value `out` is then a reference to that array.
+
+    See Also
+    --------
+    isinf, isposinf, isnan, isfinite
+
+    Notes
+    -----
+    NumPy uses the IEEE Standard for Binary Floating-Point for Arithmetic
+    (IEEE 754).
+
+    Errors result if the second argument is also supplied when x is a scalar
+    input, if first and second arguments have different shapes, or if the
+    first argument has complex values.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> np.isneginf(-np.inf)
+    True
+    >>> np.isneginf(np.inf)
+    False
+    >>> np.isneginf([-np.inf, 0., np.inf])
+    array([ True, False, False])
+
+    >>> x = np.array([-np.inf, 0., np.inf])
+    >>> y = np.array([2, 2, 2])
+    >>> np.isneginf(x, y)
+    array([1, 0, 0])
+    >>> y
+    array([1, 0, 0])
+
+    """
+    is_inf = nx.isinf(x)
+    try:
+        signbit = nx.signbit(x)
+    except TypeError as e:
+        dtype = nx.asanyarray(x).dtype
+        raise TypeError(f'This operation is not supported for {dtype} values '
+                        'because it would be ambiguous.') from e
+    else:
+        return nx.logical_and(is_inf, signbit, out)
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/_ufunclike_impl.pyi b/venv/lib/python3.12/site-packages/numpy/lib/_ufunclike_impl.pyi
new file mode 100644
index 00000000..dd927bc6
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/lib/_ufunclike_impl.pyi
@@ -0,0 +1,67 @@
+from typing import Any, overload, TypeVar
+
+import numpy as np
+from numpy import floating, object_
+from numpy._typing import (
+    NDArray,
+    _FloatLike_co,
+    _ArrayLikeFloat_co,
+    _ArrayLikeObject_co,
+)
+
+_ArrayType = TypeVar("_ArrayType", bound=NDArray[Any])
+
+__all__: list[str]
+
+@overload
+def fix(  # type: ignore[misc]
+    x: _FloatLike_co,
+    out: None = ...,
+) -> floating[Any]: ...
+@overload
+def fix(
+    x: _ArrayLikeFloat_co,
+    out: None = ...,
+) -> NDArray[floating[Any]]: ...
+@overload
+def fix(
+    x: _ArrayLikeObject_co,
+    out: None = ...,
+) -> NDArray[object_]: ...
+@overload
+def fix(
+    x: _ArrayLikeFloat_co | _ArrayLikeObject_co,
+    out: _ArrayType,
+) -> _ArrayType: ...
+
+@overload
+def isposinf(  # type: ignore[misc]
+    x: _FloatLike_co,
+    out: None = ...,
+) -> np.bool: ...
+@overload
+def isposinf(
+    x: _ArrayLikeFloat_co,
+    out: None = ...,
+) -> NDArray[np.bool]: ...
+@overload
+def isposinf(
+    x: _ArrayLikeFloat_co,
+    out: _ArrayType,
+) -> _ArrayType: ...
+
+@overload
+def isneginf(  # type: ignore[misc]
+    x: _FloatLike_co,
+    out: None = ...,
+) -> np.bool: ...
+@overload
+def isneginf(
+    x: _ArrayLikeFloat_co,
+    out: None = ...,
+) -> NDArray[np.bool]: ...
+@overload
+def isneginf(
+    x: _ArrayLikeFloat_co,
+    out: _ArrayType,
+) -> _ArrayType: ...
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/_user_array_impl.py b/venv/lib/python3.12/site-packages/numpy/lib/_user_array_impl.py
new file mode 100644
index 00000000..c26fa443
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/lib/_user_array_impl.py
@@ -0,0 +1,289 @@
+"""
+Container class for backward compatibility with NumArray.
+
+The user_array.container class exists for backward compatibility with NumArray
+and is not meant to be used in new code. If you need to create an array
+container class, we recommend either creating a class that wraps an ndarray
+or subclasses ndarray.
+
+"""
+from numpy._core import (
+    array, asarray, absolute, add, subtract, multiply, divide,
+    remainder, power, left_shift, right_shift, bitwise_and, bitwise_or,
+    bitwise_xor, invert, less, less_equal, not_equal, equal, greater,
+    greater_equal, shape, reshape, arange, sin, sqrt, transpose
+)
+
+
+class container:
+    """
+    container(data, dtype=None, copy=True)
+
+    Standard container-class for easy multiple-inheritance.
+
+    Methods
+    -------
+    copy
+    tostring
+    byteswap
+    astype
+
+    """
+    def __init__(self, data, dtype=None, copy=True):
+        self.array = array(data, dtype, copy=copy)
+
+    def __repr__(self):
+        if self.ndim > 0:
+            return self.__class__.__name__ + repr(self.array)[len("array"):]
+        else:
+            return self.__class__.__name__ + "(" + repr(self.array) + ")"
+
+    def __array__(self, t=None):
+        if t:
+            return self.array.astype(t)
+        return self.array
+
+    # Array as sequence
+    def __len__(self):
+        return len(self.array)
+
+    def __getitem__(self, index):
+        return self._rc(self.array[index])
+
+    def __setitem__(self, index, value):
+        self.array[index] = asarray(value, self.dtype)
+
+    def __abs__(self):
+        return self._rc(absolute(self.array))
+
+    def __neg__(self):
+        return self._rc(-self.array)
+
+    def __add__(self, other):
+        return self._rc(self.array + asarray(other))
+
+    __radd__ = __add__
+
+    def __iadd__(self, other):
+        add(self.array, other, self.array)
+        return self
+
+    def __sub__(self, other):
+        return self._rc(self.array - asarray(other))
+
+    def __rsub__(self, other):
+        return self._rc(asarray(other) - self.array)
+
+    def __isub__(self, other):
+        subtract(self.array, other, self.array)
+        return self
+
+    def __mul__(self, other):
+        return self._rc(multiply(self.array, asarray(other)))
+
+    __rmul__ = __mul__
+
+    def __imul__(self, other):
+        multiply(self.array, other, self.array)
+        return self
+
+    def __div__(self, other):
+        return self._rc(divide(self.array, asarray(other)))
+
+    def __rdiv__(self, other):
+        return self._rc(divide(asarray(other), self.array))
+
+    def __idiv__(self, other):
+        divide(self.array, other, self.array)
+        return self
+
+    def __mod__(self, other):
+        return self._rc(remainder(self.array, other))
+
+    def __rmod__(self, other):
+        return self._rc(remainder(other, self.array))
+
+    def __imod__(self, other):
+        remainder(self.array, other, self.array)
+        return self
+
+    def __divmod__(self, other):
+        return (self._rc(divide(self.array, other)),
+                self._rc(remainder(self.array, other)))
+
+    def __rdivmod__(self, other):
+        return (self._rc(divide(other, self.array)),
+                self._rc(remainder(other, self.array)))
+
+    def __pow__(self, other):
+        return self._rc(power(self.array, asarray(other)))
+
+    def __rpow__(self, other):
+        return self._rc(power(asarray(other), self.array))
+
+    def __ipow__(self, other):
+        power(self.array, other, self.array)
+        return self
+
+    def __lshift__(self, other):
+        return self._rc(left_shift(self.array, other))
+
+    def __rshift__(self, other):
+        return self._rc(right_shift(self.array, other))
+
+    def __rlshift__(self, other):
+        return self._rc(left_shift(other, self.array))
+
+    def __rrshift__(self, other):
+        return self._rc(right_shift(other, self.array))
+
+    def __ilshift__(self, other):
+        left_shift(self.array, other, self.array)
+        return self
+
+    def __irshift__(self, other):
+        right_shift(self.array, other, self.array)
+        return self
+
+    def __and__(self, other):
+        return self._rc(bitwise_and(self.array, other))
+
+    def __rand__(self, other):
+        return self._rc(bitwise_and(other, self.array))
+
+    def __iand__(self, other):
+        bitwise_and(self.array, other, self.array)
+        return self
+
+    def __xor__(self, other):
+        return self._rc(bitwise_xor(self.array, other))
+
+    def __rxor__(self, other):
+        return self._rc(bitwise_xor(other, self.array))
+
+    def __ixor__(self, other):
+        bitwise_xor(self.array, other, self.array)
+        return self
+
+    def __or__(self, other):
+        return self._rc(bitwise_or(self.array, other))
+
+    def __ror__(self, other):
+        return self._rc(bitwise_or(other, self.array))
+
+    def __ior__(self, other):
+        bitwise_or(self.array, other, self.array)
+        return self
+
+    def __pos__(self):
+        return self._rc(self.array)
+
+    def __invert__(self):
+        return self._rc(invert(self.array))
+
+    def _scalarfunc(self, func):
+        if self.ndim == 0:
+            return func(self[0])
+        else:
+            raise TypeError(
+                "only rank-0 arrays can be converted to Python scalars.")
+
+    def __complex__(self):
+        return self._scalarfunc(complex)
+
+    def __float__(self):
+        return self._scalarfunc(float)
+
+    def __int__(self):
+        return self._scalarfunc(int)
+
+    def __hex__(self):
+        return self._scalarfunc(hex)
+
+    def __oct__(self):
+        return self._scalarfunc(oct)
+
+    def __lt__(self, other):
+        return self._rc(less(self.array, other))
+
+    def __le__(self, other):
+        return self._rc(less_equal(self.array, other))
+
+    def __eq__(self, other):
+        return self._rc(equal(self.array, other))
+
+    def __ne__(self, other):
+        return self._rc(not_equal(self.array, other))
+
+    def __gt__(self, other):
+        return self._rc(greater(self.array, other))
+
+    def __ge__(self, other):
+        return self._rc(greater_equal(self.array, other))
+
+    def copy(self):
+        ""
+        return self._rc(self.array.copy())
+
+    def tostring(self):
+        ""
+        return self.array.tostring()
+
+    def tobytes(self):
+        ""
+        return self.array.tobytes()
+
+    def byteswap(self):
+        ""
+        return self._rc(self.array.byteswap())
+
+    def astype(self, typecode):
+        ""
+        return self._rc(self.array.astype(typecode))
+
+    def _rc(self, a):
+        if len(shape(a)) == 0:
+            return a
+        else:
+            return self.__class__(a)
+
+    def __array_wrap__(self, *args):
+        return self.__class__(args[0])
+
+    def __setattr__(self, attr, value):
+        if attr == 'array':
+            object.__setattr__(self, attr, value)
+            return
+        try:
+            self.array.__setattr__(attr, value)
+        except AttributeError:
+            object.__setattr__(self, attr, value)
+
+    # Only called after other approaches fail.
+    def __getattr__(self, attr):
+        if (attr == 'array'):
+            return object.__getattribute__(self, attr)
+        return self.array.__getattribute__(attr)
+
+
+#############################################################
+# Test of class container
+#############################################################
+if __name__ == '__main__':
+    temp = reshape(arange(10000), (100, 100))
+
+    ua = container(temp)
+    # new object created begin test
+    print(dir(ua))
+    print(shape(ua), ua.shape)  # I have changed Numeric.py
+
+    ua_small = ua[:3, :5]
+    print(ua_small)
+    # this did not change ua[0,0], which is not normal behavior
+    ua_small[0, 0] = 10
+    print(ua_small[0, 0], ua[0, 0])
+    print(sin(ua_small) / 3. * 6. + sqrt(ua_small ** 2))
+    print(less(ua_small, 103), type(less(ua_small, 103)))
+    print(type(ua_small * reshape(arange(15), shape(ua_small))))
+    print(reshape(ua_small, (5, 3)))
+    print(transpose(ua_small))
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/_utils_impl.py b/venv/lib/python3.12/site-packages/numpy/lib/_utils_impl.py
new file mode 100644
index 00000000..0c5d08ee
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/lib/_utils_impl.py
@@ -0,0 +1,776 @@
+import os
+import sys
+import textwrap
+import types
+import re
+import warnings
+import functools
+import platform
+
+from numpy._core import ndarray
+from numpy._utils import set_module
+import numpy as np
+
+__all__ = [
+    'get_include', 'info', 'show_runtime'
+]
+
+
+@set_module('numpy')
+def show_runtime():
+    """
+    Print information about various resources in the system
+    including available intrinsic support and BLAS/LAPACK library
+    in use
+
+    .. versionadded:: 1.24.0
+
+    See Also
+    --------
+    show_config : Show libraries in the system on which NumPy was built.
+
+    Notes
+    -----
+    1. Information is derived with the help of `threadpoolctl `_
+       library if available.
+    2. SIMD related information is derived from ``__cpu_features__``,
+       ``__cpu_baseline__`` and ``__cpu_dispatch__``
+
+    """
+    from numpy._core._multiarray_umath import (
+        __cpu_features__, __cpu_baseline__, __cpu_dispatch__
+    )
+    from pprint import pprint
+    config_found = [{
+        "numpy_version": np.__version__,
+        "python": sys.version,
+        "uname": platform.uname(),
+        }]
+    features_found, features_not_found = [], []
+    for feature in __cpu_dispatch__:
+        if __cpu_features__[feature]:
+            features_found.append(feature)
+        else:
+            features_not_found.append(feature)
+    config_found.append({
+        "simd_extensions": {
+            "baseline": __cpu_baseline__,
+            "found": features_found,
+            "not_found": features_not_found
+        }
+    })
+    try:
+        from threadpoolctl import threadpool_info
+        config_found.extend(threadpool_info())
+    except ImportError:
+        print("WARNING: `threadpoolctl` not found in system!"
+              " Install it by `pip install threadpoolctl`."
+              " Once installed, try `np.show_runtime` again"
+              " for more detailed build information")
+    pprint(config_found)
+
+
+@set_module('numpy')
+def get_include():
+    """
+    Return the directory that contains the NumPy \\*.h header files.
+
+    Extension modules that need to compile against NumPy may need to use this
+    function to locate the appropriate include directory.
+
+    Notes
+    -----
+    When using ``setuptools``, for example in ``setup.py``::
+
+        import numpy as np
+        ...
+        Extension('extension_name', ...
+                  include_dirs=[np.get_include()])
+        ...
+
+    Note that a CLI tool ``numpy-config`` was introduced in NumPy 2.0, using
+    that is likely preferred for build systems other than ``setuptools``::
+
+        $ numpy-config --cflags
+        -I/path/to/site-packages/numpy/_core/include
+
+        # Or rely on pkg-config:
+        $ export PKG_CONFIG_PATH=$(numpy-config --pkgconfigdir)
+        $ pkg-config --cflags
+        -I/path/to/site-packages/numpy/_core/include
+
+    Examples
+    --------
+    >>> np.get_include()
+    '.../site-packages/numpy/core/include'  # may vary
+
+    """
+    import numpy
+    if numpy.show_config is None:
+        # running from numpy source directory
+        d = os.path.join(os.path.dirname(numpy.__file__), '_core', 'include')
+    else:
+        # using installed numpy core headers
+        import numpy._core as _core
+        d = os.path.join(os.path.dirname(_core.__file__), 'include')
+    return d
+
+
+class _Deprecate:
+    """
+    Decorator class to deprecate old functions.
+
+    Refer to `deprecate` for details.
+
+    See Also
+    --------
+    deprecate
+
+    """
+
+    def __init__(self, old_name=None, new_name=None, message=None):
+        self.old_name = old_name
+        self.new_name = new_name
+        self.message = message
+
+    def __call__(self, func, *args, **kwargs):
+        """
+        Decorator call.  Refer to ``decorate``.
+
+        """
+        old_name = self.old_name
+        new_name = self.new_name
+        message = self.message
+
+        if old_name is None:
+            old_name = func.__name__
+        if new_name is None:
+            depdoc = "`%s` is deprecated!" % old_name
+        else:
+            depdoc = "`%s` is deprecated, use `%s` instead!" % \
+                     (old_name, new_name)
+
+        if message is not None:
+            depdoc += "\n" + message
+
+        @functools.wraps(func)
+        def newfunc(*args, **kwds):
+            warnings.warn(depdoc, DeprecationWarning, stacklevel=2)
+            return func(*args, **kwds)
+
+        newfunc.__name__ = old_name
+        doc = func.__doc__
+        if doc is None:
+            doc = depdoc
+        else:
+            lines = doc.expandtabs().split('\n')
+            indent = _get_indent(lines[1:])
+            if lines[0].lstrip():
+                # Indent the original first line to let inspect.cleandoc()
+                # dedent the docstring despite the deprecation notice.
+                doc = indent * ' ' + doc
+            else:
+                # Remove the same leading blank lines as cleandoc() would.
+                skip = len(lines[0]) + 1
+                for line in lines[1:]:
+                    if len(line) > indent:
+                        break
+                    skip += len(line) + 1
+                doc = doc[skip:]
+            depdoc = textwrap.indent(depdoc, ' ' * indent)
+            doc = '\n\n'.join([depdoc, doc])
+        newfunc.__doc__ = doc
+
+        return newfunc
+
+
+def _get_indent(lines):
+    """
+    Determines the leading whitespace that could be removed from all the lines.
+    """
+    indent = sys.maxsize
+    for line in lines:
+        content = len(line.lstrip())
+        if content:
+            indent = min(indent, len(line) - content)
+    if indent == sys.maxsize:
+        indent = 0
+    return indent
+
+
+def deprecate(*args, **kwargs):
+    """
+    Issues a DeprecationWarning, adds warning to `old_name`'s
+    docstring, rebinds ``old_name.__name__`` and returns the new
+    function object.
+
+    This function may also be used as a decorator.
+
+    .. deprecated:: 2.0
+        Use `~warnings.warn` with :exc:`DeprecationWarning` instead.
+
+    Parameters
+    ----------
+    func : function
+        The function to be deprecated.
+    old_name : str, optional
+        The name of the function to be deprecated. Default is None, in
+        which case the name of `func` is used.
+    new_name : str, optional
+        The new name for the function. Default is None, in which case the
+        deprecation message is that `old_name` is deprecated. If given, the
+        deprecation message is that `old_name` is deprecated and `new_name`
+        should be used instead.
+    message : str, optional
+        Additional explanation of the deprecation.  Displayed in the
+        docstring after the warning.
+
+    Returns
+    -------
+    old_func : function
+        The deprecated function.
+
+    Examples
+    --------
+    Note that ``olduint`` returns a value after printing Deprecation
+    Warning:
+
+    >>> olduint = np.lib.utils.deprecate(np.uint)
+    DeprecationWarning: `uint64` is deprecated! # may vary
+    >>> olduint(6)
+    6
+
+    """
+    # Deprecate may be run as a function or as a decorator
+    # If run as a function, we initialise the decorator class
+    # and execute its __call__ method.
+
+    # Deprecated in NumPy 2.0, 2023-07-11
+    warnings.warn(
+        "`deprecate` is deprecated, "
+        "use `warn` with `DeprecationWarning` instead. "
+        "(deprecated in NumPy 2.0)",
+        DeprecationWarning,
+        stacklevel=2
+    )
+
+    if args:
+        fn = args[0]
+        args = args[1:]
+
+        return _Deprecate(*args, **kwargs)(fn)
+    else:
+        return _Deprecate(*args, **kwargs)
+
+
+def deprecate_with_doc(msg):
+    """
+    Deprecates a function and includes the deprecation in its docstring.
+
+    .. deprecated:: 2.0
+        Use `~warnings.warn` with :exc:`DeprecationWarning` instead.
+
+    This function is used as a decorator. It returns an object that can be
+    used to issue a DeprecationWarning, by passing the to-be decorated
+    function as argument, this adds warning to the to-be decorated function's
+    docstring and returns the new function object.
+
+    See Also
+    --------
+    deprecate : Decorate a function such that it issues a
+                :exc:`DeprecationWarning`
+
+    Parameters
+    ----------
+    msg : str
+        Additional explanation of the deprecation. Displayed in the
+        docstring after the warning.
+
+    Returns
+    -------
+    obj : object
+
+    """
+
+    # Deprecated in NumPy 2.0, 2023-07-11
+    warnings.warn(
+        "`deprecate` is deprecated, "
+        "use `warn` with `DeprecationWarning` instead. "
+        "(deprecated in NumPy 2.0)",
+        DeprecationWarning,
+        stacklevel=2
+    )
+
+    return _Deprecate(message=msg)
+
+
+#-----------------------------------------------------------------------------
+
+
+# NOTE:  pydoc defines a help function which works similarly to this
+#  except it uses a pager to take over the screen.
+
+# combine name and arguments and split to multiple lines of width
+# characters.  End lines on a comma and begin argument list indented with
+# the rest of the arguments.
+def _split_line(name, arguments, width):
+    firstwidth = len(name)
+    k = firstwidth
+    newstr = name
+    sepstr = ", "
+    arglist = arguments.split(sepstr)
+    for argument in arglist:
+        if k == firstwidth:
+            addstr = ""
+        else:
+            addstr = sepstr
+        k = k + len(argument) + len(addstr)
+        if k > width:
+            k = firstwidth + 1 + len(argument)
+            newstr = newstr + ",\n" + " "*(firstwidth+2) + argument
+        else:
+            newstr = newstr + addstr + argument
+    return newstr
+
+_namedict = None
+_dictlist = None
+
+# Traverse all module directories underneath globals
+# to see if something is defined
+def _makenamedict(module='numpy'):
+    module = __import__(module, globals(), locals(), [])
+    thedict = {module.__name__:module.__dict__}
+    dictlist = [module.__name__]
+    totraverse = [module.__dict__]
+    while True:
+        if len(totraverse) == 0:
+            break
+        thisdict = totraverse.pop(0)
+        for x in thisdict.keys():
+            if isinstance(thisdict[x], types.ModuleType):
+                modname = thisdict[x].__name__
+                if modname not in dictlist:
+                    moddict = thisdict[x].__dict__
+                    dictlist.append(modname)
+                    totraverse.append(moddict)
+                    thedict[modname] = moddict
+    return thedict, dictlist
+
+
+def _info(obj, output=None):
+    """Provide information about ndarray obj.
+
+    Parameters
+    ----------
+    obj : ndarray
+        Must be ndarray, not checked.
+    output
+        Where printed output goes.
+
+    Notes
+    -----
+    Copied over from the numarray module prior to its removal.
+    Adapted somewhat as only numpy is an option now.
+
+    Called by info.
+
+    """
+    extra = ""
+    tic = ""
+    bp = lambda x: x
+    cls = getattr(obj, '__class__', type(obj))
+    nm = getattr(cls, '__name__', cls)
+    strides = obj.strides
+    endian = obj.dtype.byteorder
+
+    if output is None:
+        output = sys.stdout
+
+    print("class: ", nm, file=output)
+    print("shape: ", obj.shape, file=output)
+    print("strides: ", strides, file=output)
+    print("itemsize: ", obj.itemsize, file=output)
+    print("aligned: ", bp(obj.flags.aligned), file=output)
+    print("contiguous: ", bp(obj.flags.contiguous), file=output)
+    print("fortran: ", obj.flags.fortran, file=output)
+    print(
+        "data pointer: %s%s" % (hex(obj.ctypes._as_parameter_.value), extra),
+        file=output
+        )
+    print("byteorder: ", end=' ', file=output)
+    if endian in ['|', '=']:
+        print("%s%s%s" % (tic, sys.byteorder, tic), file=output)
+        byteswap = False
+    elif endian == '>':
+        print("%sbig%s" % (tic, tic), file=output)
+        byteswap = sys.byteorder != "big"
+    else:
+        print("%slittle%s" % (tic, tic), file=output)
+        byteswap = sys.byteorder != "little"
+    print("byteswap: ", bp(byteswap), file=output)
+    print("type: %s" % obj.dtype, file=output)
+
+
+@set_module('numpy')
+def info(object=None, maxwidth=76, output=None, toplevel='numpy'):
+    """
+    Get help information for an array, function, class, or module.
+
+    Parameters
+    ----------
+    object : object or str, optional
+        Input object or name to get information about. If `object` is
+        an `ndarray` instance, information about the array is printed.
+        If `object` is a numpy object, its docstring is given. If it is
+        a string, available modules are searched for matching objects.
+        If None, information about `info` itself is returned.
+    maxwidth : int, optional
+        Printing width.
+    output : file like object, optional
+        File like object that the output is written to, default is
+        ``None``, in which case ``sys.stdout`` will be used.
+        The object has to be opened in 'w' or 'a' mode.
+    toplevel : str, optional
+        Start search at this level.
+
+    Notes
+    -----
+    When used interactively with an object, ``np.info(obj)`` is equivalent
+    to ``help(obj)`` on the Python prompt or ``obj?`` on the IPython
+    prompt.
+
+    Examples
+    --------
+    >>> np.info(np.polyval) # doctest: +SKIP
+       polyval(p, x)
+         Evaluate the polynomial p at x.
+         ...
+
+    When using a string for `object` it is possible to get multiple results.
+
+    >>> np.info('fft') # doctest: +SKIP
+         *** Found in numpy ***
+    Core FFT routines
+    ...
+         *** Found in numpy.fft ***
+     fft(a, n=None, axis=-1)
+    ...
+         *** Repeat reference found in numpy.fft.fftpack ***
+         *** Total of 3 references found. ***
+
+    When the argument is an array, information about the array is printed.
+
+    >>> a = np.array([[1 + 2j, 3, -4], [-5j, 6, 0]], dtype=np.complex64)
+    >>> np.info(a)
+    class:  ndarray
+    shape:  (2, 3)
+    strides:  (24, 8)
+    itemsize:  8
+    aligned:  True
+    contiguous:  True
+    fortran:  False
+    data pointer: 0x562b6e0d2860  # may vary
+    byteorder:  little
+    byteswap:  False
+    type: complex64
+
+    """
+    global _namedict, _dictlist
+    # Local import to speed up numpy's import time.
+    import pydoc
+    import inspect
+
+    if (hasattr(object, '_ppimport_importer') or
+           hasattr(object, '_ppimport_module')):
+        object = object._ppimport_module
+    elif hasattr(object, '_ppimport_attr'):
+        object = object._ppimport_attr
+
+    if output is None:
+        output = sys.stdout
+
+    if object is None:
+        info(info)
+    elif isinstance(object, ndarray):
+        _info(object, output=output)
+    elif isinstance(object, str):
+        if _namedict is None:
+            _namedict, _dictlist = _makenamedict(toplevel)
+        numfound = 0
+        objlist = []
+        for namestr in _dictlist:
+            try:
+                obj = _namedict[namestr][object]
+                if id(obj) in objlist:
+                    print("\n     "
+                          "*** Repeat reference found in %s *** " % namestr,
+                          file=output
+                          )
+                else:
+                    objlist.append(id(obj))
+                    print("     *** Found in %s ***" % namestr, file=output)
+                    info(obj)
+                    print("-"*maxwidth, file=output)
+                numfound += 1
+            except KeyError:
+                pass
+        if numfound == 0:
+            print("Help for %s not found." % object, file=output)
+        else:
+            print("\n     "
+                  "*** Total of %d references found. ***" % numfound,
+                  file=output
+                  )
+
+    elif inspect.isfunction(object) or inspect.ismethod(object):
+        name = object.__name__
+        try:
+            arguments = str(inspect.signature(object))
+        except Exception:
+            arguments = "()"
+
+        if len(name+arguments) > maxwidth:
+            argstr = _split_line(name, arguments, maxwidth)
+        else:
+            argstr = name + arguments
+
+        print(" " + argstr + "\n", file=output)
+        print(inspect.getdoc(object), file=output)
+
+    elif inspect.isclass(object):
+        name = object.__name__
+        try:
+            arguments = str(inspect.signature(object))
+        except Exception:
+            arguments = "()"
+
+        if len(name+arguments) > maxwidth:
+            argstr = _split_line(name, arguments, maxwidth)
+        else:
+            argstr = name + arguments
+
+        print(" " + argstr + "\n", file=output)
+        doc1 = inspect.getdoc(object)
+        if doc1 is None:
+            if hasattr(object, '__init__'):
+                print(inspect.getdoc(object.__init__), file=output)
+        else:
+            print(inspect.getdoc(object), file=output)
+
+        methods = pydoc.allmethods(object)
+
+        public_methods = [meth for meth in methods if meth[0] != '_']
+        if public_methods:
+            print("\n\nMethods:\n", file=output)
+            for meth in public_methods:
+                thisobj = getattr(object, meth, None)
+                if thisobj is not None:
+                    methstr, other = pydoc.splitdoc(
+                            inspect.getdoc(thisobj) or "None"
+                            )
+                print("  %s  --  %s" % (meth, methstr), file=output)
+
+    elif hasattr(object, '__doc__'):
+        print(inspect.getdoc(object), file=output)
+
+
+def safe_eval(source):
+    """
+    Protected string evaluation.
+
+    .. deprecated:: 2.0
+        Use `ast.literal_eval` instead.
+
+    Evaluate a string containing a Python literal expression without
+    allowing the execution of arbitrary non-literal code.
+
+    .. warning::
+
+        This function is identical to :py:meth:`ast.literal_eval` and
+        has the same security implications.  It may not always be safe
+        to evaluate large input strings.
+
+    Parameters
+    ----------
+    source : str
+        The string to evaluate.
+
+    Returns
+    -------
+    obj : object
+       The result of evaluating `source`.
+
+    Raises
+    ------
+    SyntaxError
+        If the code has invalid Python syntax, or if it contains
+        non-literal code.
+
+    Examples
+    --------
+    >>> np.safe_eval('1')
+    1
+    >>> np.safe_eval('[1, 2, 3]')
+    [1, 2, 3]
+    >>> np.safe_eval('{"foo": ("bar", 10.0)}')
+    {'foo': ('bar', 10.0)}
+
+    >>> np.safe_eval('import os')
+    Traceback (most recent call last):
+      ...
+    SyntaxError: invalid syntax
+
+    >>> np.safe_eval('open("/home/user/.ssh/id_dsa").read()')
+    Traceback (most recent call last):
+      ...
+    ValueError: malformed node or string: <_ast.Call object at 0x...>
+
+    """
+
+    # Deprecated in NumPy 2.0, 2023-07-11
+    warnings.warn(
+        "`safe_eval` is deprecated. Use `ast.literal_eval` instead. "
+        "Be aware of security implications, such as memory exhaustion "
+        "based attacks (deprecated in NumPy 2.0)",
+        DeprecationWarning,
+        stacklevel=2
+    )
+
+    # Local import to speed up numpy's import time.
+    import ast
+    return ast.literal_eval(source)
+
+
+def _median_nancheck(data, result, axis):
+    """
+    Utility function to check median result from data for NaN values at the end
+    and return NaN in that case. Input result can also be a MaskedArray.
+
+    Parameters
+    ----------
+    data : array
+        Sorted input data to median function
+    result : Array or MaskedArray
+        Result of median function.
+    axis : int
+        Axis along which the median was computed.
+
+    Returns
+    -------
+    result : scalar or ndarray
+        Median or NaN in axes which contained NaN in the input.  If the input
+        was an array, NaN will be inserted in-place.  If a scalar, either the
+        input itself or a scalar NaN.
+    """
+    if data.size == 0:
+        return result
+    potential_nans = data.take(-1, axis=axis)
+    n = np.isnan(potential_nans)
+    # masked NaN values are ok, although for masked the copyto may fail for
+    # unmasked ones (this was always broken) when the result is a scalar.
+    if np.ma.isMaskedArray(n):
+        n = n.filled(False)
+
+    if not n.any():
+        return result
+
+    # Without given output, it is possible that the current result is a
+    # numpy scalar, which is not writeable.  If so, just return nan.
+    if isinstance(result, np.generic):
+        return potential_nans
+
+    # Otherwise copy NaNs (if there are any)
+    np.copyto(result, potential_nans, where=n)
+    return result
+
+def _opt_info():
+    """
+    Returns a string containing the CPU features supported
+    by the current build.
+
+    The format of the string can be explained as follows:
+        - Dispatched features supported by the running machine end with `*`.
+        - Dispatched features not supported by the running machine
+          end with `?`.
+        - Remaining features represent the baseline.
+
+    Returns:
+        str: A formatted string indicating the supported CPU features.
+    """
+    from numpy._core._multiarray_umath import (
+        __cpu_features__, __cpu_baseline__, __cpu_dispatch__
+    )
+
+    if len(__cpu_baseline__) == 0 and len(__cpu_dispatch__) == 0:
+        return ''
+
+    enabled_features = ' '.join(__cpu_baseline__)
+    for feature in __cpu_dispatch__:
+        if __cpu_features__[feature]:
+            enabled_features += f" {feature}*"
+        else:
+            enabled_features += f" {feature}?"
+
+    return enabled_features
+
+def drop_metadata(dtype, /):
+    """
+    Returns the dtype unchanged if it contained no metadata or a copy of the
+    dtype if it (or any of its structure dtypes) contained metadata.
+
+    This utility is used by `np.save` and `np.savez` to drop metadata before
+    saving.
+
+    .. note::
+
+        Due to its limitation this function may move to a more appropriate
+        home or change in the future and is considered semi-public API only.
+
+    .. warning::
+
+        This function does not preserve more strange things like record dtypes
+        and user dtypes may simply return the wrong thing.  If you need to be
+        sure about the latter, check the result with:
+        ``np.can_cast(new_dtype, dtype, casting="no")``.
+
+    """
+    if dtype.fields is not None:
+        found_metadata = dtype.metadata is not None
+
+        names = []
+        formats = []
+        offsets = []
+        titles = []
+        for name, field in dtype.fields.items():
+            field_dt = drop_metadata(field[0])
+            if field_dt is not field[0]:
+                found_metadata = True
+
+            names.append(name)
+            formats.append(field_dt)
+            offsets.append(field[1])
+            titles.append(None if len(field) < 3 else field[2])
+
+        if not found_metadata:
+            return dtype
+
+        structure = dict(
+            names=names, formats=formats, offsets=offsets, titles=titles,
+            itemsize=dtype.itemsize)
+
+        # NOTE: Could pass (dtype.type, structure) to preserve record dtypes...
+        return np.dtype(structure, align=dtype.isalignedstruct)
+    elif dtype.subdtype is not None:
+        # subarray dtype
+        subdtype, shape = dtype.subdtype
+        new_subdtype = drop_metadata(subdtype)
+        if dtype.metadata is None and new_subdtype is subdtype:
+            return dtype
+
+        return np.dtype((new_subdtype, shape))
+    else:
+        # Normal unstructured dtype
+        if dtype.metadata is None:
+            return dtype
+        # Note that `dt.str` doesn't round-trip e.g. for user-dtypes.
+        return np.dtype(dtype.str)
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/_utils_impl.pyi b/venv/lib/python3.12/site-packages/numpy/lib/_utils_impl.pyi
new file mode 100644
index 00000000..b1453874
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/lib/_utils_impl.pyi
@@ -0,0 +1,33 @@
+from typing import (
+    Any,
+    TypeVar,
+    Protocol,
+)
+
+from numpy._core.numerictypes import (
+    issubdtype as issubdtype,
+)
+
+_T_contra = TypeVar("_T_contra", contravariant=True)
+
+# A file-like object opened in `w` mode
+class _SupportsWrite(Protocol[_T_contra]):
+    def write(self, s: _T_contra, /) -> Any: ...
+
+__all__: list[str]
+
+def get_include() -> str: ...
+
+def info(
+    object: object = ...,
+    maxwidth: int = ...,
+    output: None | _SupportsWrite[str] = ...,
+    toplevel: str = ...,
+) -> None: ...
+
+def source(
+    object: object,
+    output: None | _SupportsWrite[str] = ...,
+) -> None: ...
+
+def show_runtime() -> None: ...
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/_version.py b/venv/lib/python3.12/site-packages/numpy/lib/_version.py
new file mode 100644
index 00000000..7dec3243
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/lib/_version.py
@@ -0,0 +1,155 @@
+"""Utility to compare (NumPy) version strings.
+
+The NumpyVersion class allows properly comparing numpy version strings.
+The LooseVersion and StrictVersion classes that distutils provides don't
+work; they don't recognize anything like alpha/beta/rc/dev versions.
+
+"""
+import re
+
+
+__all__ = ['NumpyVersion']
+
+
+class NumpyVersion:
+    """Parse and compare numpy version strings.
+
+    NumPy has the following versioning scheme (numbers given are examples; they
+    can be > 9 in principle):
+
+    - Released version: '1.8.0', '1.8.1', etc.
+    - Alpha: '1.8.0a1', '1.8.0a2', etc.
+    - Beta: '1.8.0b1', '1.8.0b2', etc.
+    - Release candidates: '1.8.0rc1', '1.8.0rc2', etc.
+    - Development versions: '1.8.0.dev-f1234afa' (git commit hash appended)
+    - Development versions after a1: '1.8.0a1.dev-f1234afa',
+                                     '1.8.0b2.dev-f1234afa',
+                                     '1.8.1rc1.dev-f1234afa', etc.
+    - Development versions (no git hash available): '1.8.0.dev-Unknown'
+
+    Comparing needs to be done against a valid version string or other
+    `NumpyVersion` instance. Note that all development versions of the same
+    (pre-)release compare equal.
+
+    .. versionadded:: 1.9.0
+
+    Parameters
+    ----------
+    vstring : str
+        NumPy version string (``np.__version__``).
+
+    Examples
+    --------
+    >>> from numpy.lib import NumpyVersion
+    >>> if NumpyVersion(np.__version__) < '1.7.0':
+    ...     print('skip')
+    >>> # skip
+
+    >>> NumpyVersion('1.7')  # raises ValueError, add ".0"
+    Traceback (most recent call last):
+        ...
+    ValueError: Not a valid numpy version string
+
+    """
+
+    def __init__(self, vstring):
+        self.vstring = vstring
+        ver_main = re.match(r'\d+\.\d+\.\d+', vstring)
+        if not ver_main:
+            raise ValueError("Not a valid numpy version string")
+
+        self.version = ver_main.group()
+        self.major, self.minor, self.bugfix = [int(x) for x in
+            self.version.split('.')]
+        if len(vstring) == ver_main.end():
+            self.pre_release = 'final'
+        else:
+            alpha = re.match(r'a\d', vstring[ver_main.end():])
+            beta = re.match(r'b\d', vstring[ver_main.end():])
+            rc = re.match(r'rc\d', vstring[ver_main.end():])
+            pre_rel = [m for m in [alpha, beta, rc] if m is not None]
+            if pre_rel:
+                self.pre_release = pre_rel[0].group()
+            else:
+                self.pre_release = ''
+
+        self.is_devversion = bool(re.search(r'.dev', vstring))
+
+    def _compare_version(self, other):
+        """Compare major.minor.bugfix"""
+        if self.major == other.major:
+            if self.minor == other.minor:
+                if self.bugfix == other.bugfix:
+                    vercmp = 0
+                elif self.bugfix > other.bugfix:
+                    vercmp = 1
+                else:
+                    vercmp = -1
+            elif self.minor > other.minor:
+                vercmp = 1
+            else:
+                vercmp = -1
+        elif self.major > other.major:
+            vercmp = 1
+        else:
+            vercmp = -1
+
+        return vercmp
+
+    def _compare_pre_release(self, other):
+        """Compare alpha/beta/rc/final."""
+        if self.pre_release == other.pre_release:
+            vercmp = 0
+        elif self.pre_release == 'final':
+            vercmp = 1
+        elif other.pre_release == 'final':
+            vercmp = -1
+        elif self.pre_release > other.pre_release:
+            vercmp = 1
+        else:
+            vercmp = -1
+
+        return vercmp
+
+    def _compare(self, other):
+        if not isinstance(other, (str, NumpyVersion)):
+            raise ValueError("Invalid object to compare with NumpyVersion.")
+
+        if isinstance(other, str):
+            other = NumpyVersion(other)
+
+        vercmp = self._compare_version(other)
+        if vercmp == 0:
+            # Same x.y.z version, check for alpha/beta/rc
+            vercmp = self._compare_pre_release(other)
+            if vercmp == 0:
+                # Same version and same pre-release, check if dev version
+                if self.is_devversion is other.is_devversion:
+                    vercmp = 0
+                elif self.is_devversion:
+                    vercmp = -1
+                else:
+                    vercmp = 1
+
+        return vercmp
+
+    def __lt__(self, other):
+        return self._compare(other) < 0
+
+    def __le__(self, other):
+        return self._compare(other) <= 0
+
+    def __eq__(self, other):
+        return self._compare(other) == 0
+
+    def __ne__(self, other):
+        return self._compare(other) != 0
+
+    def __gt__(self, other):
+        return self._compare(other) > 0
+
+    def __ge__(self, other):
+        return self._compare(other) >= 0
+
+    def __repr__(self):
+        return "NumpyVersion(%s)" % self.vstring
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/_version.pyi b/venv/lib/python3.12/site-packages/numpy/lib/_version.pyi
new file mode 100644
index 00000000..1c82c99b
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/lib/_version.pyi
@@ -0,0 +1,17 @@
+__all__: list[str]
+
+class NumpyVersion:
+    vstring: str
+    version: str
+    major: int
+    minor: int
+    bugfix: int
+    pre_release: str
+    is_devversion: bool
+    def __init__(self, vstring: str) -> None: ...
+    def __lt__(self, other: str | NumpyVersion) -> bool: ...
+    def __le__(self, other: str | NumpyVersion) -> bool: ...
+    def __eq__(self, other: str | NumpyVersion) -> bool: ...  # type: ignore[override]
+    def __ne__(self, other: str | NumpyVersion) -> bool: ...  # type: ignore[override]
+    def __gt__(self, other: str | NumpyVersion) -> bool: ...
+    def __ge__(self, other: str | NumpyVersion) -> bool: ...
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/array_utils.py b/venv/lib/python3.12/site-packages/numpy/lib/array_utils.py
new file mode 100644
index 00000000..b4e79761
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/lib/array_utils.py
@@ -0,0 +1,7 @@
+from ._array_utils_impl import (
+    __all__,
+    __doc__,
+    byte_bounds,
+    normalize_axis_index,
+    normalize_axis_tuple,
+)
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/array_utils.pyi b/venv/lib/python3.12/site-packages/numpy/lib/array_utils.pyi
new file mode 100644
index 00000000..4b9ebe33
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/lib/array_utils.pyi
@@ -0,0 +1,6 @@
+from ._array_utils_impl import (
+    __all__ as __all__,
+    byte_bounds as byte_bounds,
+    normalize_axis_index as normalize_axis_index,
+    normalize_axis_tuple as normalize_axis_tuple,
+)
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/format.py b/venv/lib/python3.12/site-packages/numpy/lib/format.py
new file mode 100644
index 00000000..a9040345
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/lib/format.py
@@ -0,0 +1,1015 @@
+"""
+Binary serialization
+
+NPY format
+==========
+
+A simple format for saving numpy arrays to disk with the full
+information about them.
+
+The ``.npy`` format is the standard binary file format in NumPy for
+persisting a *single* arbitrary NumPy array on disk. The format stores all
+of the shape and dtype information necessary to reconstruct the array
+correctly even on another machine with a different architecture.
+The format is designed to be as simple as possible while achieving
+its limited goals.
+
+The ``.npz`` format is the standard format for persisting *multiple* NumPy
+arrays on disk. A ``.npz`` file is a zip file containing multiple ``.npy``
+files, one for each array.
+
+Capabilities
+------------
+
+- Can represent all NumPy arrays including nested record arrays and
+  object arrays.
+
+- Represents the data in its native binary form.
+
+- Supports Fortran-contiguous arrays directly.
+
+- Stores all of the necessary information to reconstruct the array
+  including shape and dtype on a machine of a different
+  architecture.  Both little-endian and big-endian arrays are
+  supported, and a file with little-endian numbers will yield
+  a little-endian array on any machine reading the file. The
+  types are described in terms of their actual sizes. For example,
+  if a machine with a 64-bit C "long int" writes out an array with
+  "long ints", a reading machine with 32-bit C "long ints" will yield
+  an array with 64-bit integers.
+
+- Is straightforward to reverse engineer. Datasets often live longer than
+  the programs that created them. A competent developer should be
+  able to create a solution in their preferred programming language to
+  read most ``.npy`` files that they have been given without much
+  documentation.
+
+- Allows memory-mapping of the data. See `open_memmap`.
+
+- Can be read from a filelike stream object instead of an actual file.
+
+- Stores object arrays, i.e. arrays containing elements that are arbitrary
+  Python objects. Files with object arrays are not to be mmapable, but
+  can be read and written to disk.
+
+Limitations
+-----------
+
+- Arbitrary subclasses of numpy.ndarray are not completely preserved.
+  Subclasses will be accepted for writing, but only the array data will
+  be written out. A regular numpy.ndarray object will be created
+  upon reading the file.
+
+.. warning::
+
+  Due to limitations in the interpretation of structured dtypes, dtypes
+  with fields with empty names will have the names replaced by 'f0', 'f1',
+  etc. Such arrays will not round-trip through the format entirely
+  accurately. The data is intact; only the field names will differ. We are
+  working on a fix for this. This fix will not require a change in the
+  file format. The arrays with such structures can still be saved and
+  restored, and the correct dtype may be restored by using the
+  ``loadedarray.view(correct_dtype)`` method.
+
+File extensions
+---------------
+
+We recommend using the ``.npy`` and ``.npz`` extensions for files saved
+in this format. This is by no means a requirement; applications may wish
+to use these file formats but use an extension specific to the
+application. In the absence of an obvious alternative, however,
+we suggest using ``.npy`` and ``.npz``.
+
+Version numbering
+-----------------
+
+The version numbering of these formats is independent of NumPy version
+numbering. If the format is upgraded, the code in `numpy.io` will still
+be able to read and write Version 1.0 files.
+
+Format Version 1.0
+------------------
+
+The first 6 bytes are a magic string: exactly ``\\x93NUMPY``.
+
+The next 1 byte is an unsigned byte: the major version number of the file
+format, e.g. ``\\x01``.
+
+The next 1 byte is an unsigned byte: the minor version number of the file
+format, e.g. ``\\x00``. Note: the version of the file format is not tied
+to the version of the numpy package.
+
+The next 2 bytes form a little-endian unsigned short int: the length of
+the header data HEADER_LEN.
+
+The next HEADER_LEN bytes form the header data describing the array's
+format. It is an ASCII string which contains a Python literal expression
+of a dictionary. It is terminated by a newline (``\\n``) and padded with
+spaces (``\\x20``) to make the total of
+``len(magic string) + 2 + len(length) + HEADER_LEN`` be evenly divisible
+by 64 for alignment purposes.
+
+The dictionary contains three keys:
+
+    "descr" : dtype.descr
+      An object that can be passed as an argument to the `numpy.dtype`
+      constructor to create the array's dtype.
+    "fortran_order" : bool
+      Whether the array data is Fortran-contiguous or not. Since
+      Fortran-contiguous arrays are a common form of non-C-contiguity,
+      we allow them to be written directly to disk for efficiency.
+    "shape" : tuple of int
+      The shape of the array.
+
+For repeatability and readability, the dictionary keys are sorted in
+alphabetic order. This is for convenience only. A writer SHOULD implement
+this if possible. A reader MUST NOT depend on this.
+
+Following the header comes the array data. If the dtype contains Python
+objects (i.e. ``dtype.hasobject is True``), then the data is a Python
+pickle of the array. Otherwise the data is the contiguous (either C-
+or Fortran-, depending on ``fortran_order``) bytes of the array.
+Consumers can figure out the number of bytes by multiplying the number
+of elements given by the shape (noting that ``shape=()`` means there is
+1 element) by ``dtype.itemsize``.
+
+Format Version 2.0
+------------------
+
+The version 1.0 format only allowed the array header to have a total size of
+65535 bytes.  This can be exceeded by structured arrays with a large number of
+columns.  The version 2.0 format extends the header size to 4 GiB.
+`numpy.save` will automatically save in 2.0 format if the data requires it,
+else it will always use the more compatible 1.0 format.
+
+The description of the fourth element of the header therefore has become:
+"The next 4 bytes form a little-endian unsigned int: the length of the header
+data HEADER_LEN."
+
+Format Version 3.0
+------------------
+
+This version replaces the ASCII string (which in practice was latin1) with
+a utf8-encoded string, so supports structured types with any unicode field
+names.
+
+Notes
+-----
+The ``.npy`` format, including motivation for creating it and a comparison of
+alternatives, is described in the
+:doc:`"npy-format" NEP `, however details have
+evolved with time and this document is more current.
+
+"""
+import io
+import os
+import pickle
+import warnings
+
+import numpy
+from numpy.lib._utils_impl import drop_metadata
+
+
+__all__ = []
+
+
+EXPECTED_KEYS = {'descr', 'fortran_order', 'shape'}
+MAGIC_PREFIX = b'\x93NUMPY'
+MAGIC_LEN = len(MAGIC_PREFIX) + 2
+ARRAY_ALIGN = 64 # plausible values are powers of 2 between 16 and 4096
+BUFFER_SIZE = 2**18  # size of buffer for reading npz files in bytes
+# allow growth within the address space of a 64 bit machine along one axis
+GROWTH_AXIS_MAX_DIGITS = 21  # = len(str(8*2**64-1)) hypothetical int1 dtype
+
+# difference between version 1.0 and 2.0 is a 4 byte (I) header length
+# instead of 2 bytes (H) allowing storage of large structured arrays
+_header_size_info = {
+    (1, 0): (' 255:
+        raise ValueError("major version must be 0 <= major < 256")
+    if minor < 0 or minor > 255:
+        raise ValueError("minor version must be 0 <= minor < 256")
+    return MAGIC_PREFIX + bytes([major, minor])
+
+def read_magic(fp):
+    """ Read the magic string to get the version of the file format.
+
+    Parameters
+    ----------
+    fp : filelike object
+
+    Returns
+    -------
+    major : int
+    minor : int
+    """
+    magic_str = _read_bytes(fp, MAGIC_LEN, "magic string")
+    if magic_str[:-2] != MAGIC_PREFIX:
+        msg = "the magic string is not correct; expected %r, got %r"
+        raise ValueError(msg % (MAGIC_PREFIX, magic_str[:-2]))
+    major, minor = magic_str[-2:]
+    return major, minor
+
+
+def dtype_to_descr(dtype):
+    """
+    Get a serializable descriptor from the dtype.
+
+    The .descr attribute of a dtype object cannot be round-tripped through
+    the dtype() constructor. Simple types, like dtype('float32'), have
+    a descr which looks like a record array with one field with '' as
+    a name. The dtype() constructor interprets this as a request to give
+    a default name.  Instead, we construct descriptor that can be passed to
+    dtype().
+
+    Parameters
+    ----------
+    dtype : dtype
+        The dtype of the array that will be written to disk.
+
+    Returns
+    -------
+    descr : object
+        An object that can be passed to `numpy.dtype()` in order to
+        replicate the input dtype.
+
+    """
+    # NOTE: that drop_metadata may not return the right dtype e.g. for user
+    #       dtypes.  In that case our code below would fail the same, though.
+    new_dtype = drop_metadata(dtype)
+    if new_dtype is not dtype:
+        warnings.warn("metadata on a dtype is not saved to an npy/npz. "
+                      "Use another format (such as pickle) to store it.",
+                      UserWarning, stacklevel=2)
+    dtype = new_dtype
+
+    if dtype.names is not None:
+        # This is a record array. The .descr is fine.  XXX: parts of the
+        # record array with an empty name, like padding bytes, still get
+        # fiddled with. This needs to be fixed in the C implementation of
+        # dtype().
+        return dtype.descr
+    elif not type(dtype)._legacy:
+        # this must be a user-defined dtype since numpy does not yet expose any
+        # non-legacy dtypes in the public API
+        #
+        # non-legacy dtypes don't yet have __array_interface__
+        # support. Instead, as a hack, we use pickle to save the array, and lie
+        # that the dtype is object. When the array is loaded, the descriptor is
+        # unpickled with the array and the object dtype in the header is
+        # discarded.
+        #
+        # a future NEP should define a way to serialize user-defined
+        # descriptors and ideally work out the possible security implications
+        warnings.warn("Custom dtypes are saved as python objects using the "
+                      "pickle protocol. Loading this file requires "
+                      "allow_pickle=True to be set.",
+                      UserWarning, stacklevel=2)
+        return "|O"
+    else:
+        return dtype.str
+
+def descr_to_dtype(descr):
+    """
+    Returns a dtype based off the given description.
+
+    This is essentially the reverse of `~lib.format.dtype_to_descr`. It will
+    remove the valueless padding fields created by, i.e. simple fields like
+    dtype('float32'), and then convert the description to its corresponding
+    dtype.
+
+    Parameters
+    ----------
+    descr : object
+        The object retrieved by dtype.descr. Can be passed to
+        `numpy.dtype` in order to replicate the input dtype.
+
+    Returns
+    -------
+    dtype : dtype
+        The dtype constructed by the description.
+
+    """
+    if isinstance(descr, str):
+        # No padding removal needed
+        return numpy.dtype(descr)
+    elif isinstance(descr, tuple):
+        # subtype, will always have a shape descr[1]
+        dt = descr_to_dtype(descr[0])
+        return numpy.dtype((dt, descr[1]))
+
+    titles = []
+    names = []
+    formats = []
+    offsets = []
+    offset = 0
+    for field in descr:
+        if len(field) == 2:
+            name, descr_str = field
+            dt = descr_to_dtype(descr_str)
+        else:
+            name, descr_str, shape = field
+            dt = numpy.dtype((descr_to_dtype(descr_str), shape))
+
+        # Ignore padding bytes, which will be void bytes with '' as name
+        # Once support for blank names is removed, only "if name == ''" needed)
+        is_pad = (name == '' and dt.type is numpy.void and dt.names is None)
+        if not is_pad:
+            title, name = name if isinstance(name, tuple) else (None, name)
+            titles.append(title)
+            names.append(name)
+            formats.append(dt)
+            offsets.append(offset)
+        offset += dt.itemsize
+
+    return numpy.dtype({'names': names, 'formats': formats, 'titles': titles,
+                        'offsets': offsets, 'itemsize': offset})
+
+def header_data_from_array_1_0(array):
+    """ Get the dictionary of header metadata from a numpy.ndarray.
+
+    Parameters
+    ----------
+    array : numpy.ndarray
+
+    Returns
+    -------
+    d : dict
+        This has the appropriate entries for writing its string representation
+        to the header of the file.
+    """
+    d = {'shape': array.shape}
+    if array.flags.c_contiguous:
+        d['fortran_order'] = False
+    elif array.flags.f_contiguous:
+        d['fortran_order'] = True
+    else:
+        # Totally non-contiguous data. We will have to make it C-contiguous
+        # before writing. Note that we need to test for C_CONTIGUOUS first
+        # because a 1-D array is both C_CONTIGUOUS and F_CONTIGUOUS.
+        d['fortran_order'] = False
+
+    d['descr'] = dtype_to_descr(array.dtype)
+    return d
+
+
+def _wrap_header(header, version):
+    """
+    Takes a stringified header, and attaches the prefix and padding to it
+    """
+    import struct
+    assert version is not None
+    fmt, encoding = _header_size_info[version]
+    header = header.encode(encoding)
+    hlen = len(header) + 1
+    padlen = ARRAY_ALIGN - ((MAGIC_LEN + struct.calcsize(fmt) + hlen) % ARRAY_ALIGN)
+    try:
+        header_prefix = magic(*version) + struct.pack(fmt, hlen + padlen)
+    except struct.error:
+        msg = "Header length {} too big for version={}".format(hlen, version)
+        raise ValueError(msg) from None
+
+    # Pad the header with spaces and a final newline such that the magic
+    # string, the header-length short and the header are aligned on a
+    # ARRAY_ALIGN byte boundary.  This supports memory mapping of dtypes
+    # aligned up to ARRAY_ALIGN on systems like Linux where mmap()
+    # offset must be page-aligned (i.e. the beginning of the file).
+    return header_prefix + header + b' '*padlen + b'\n'
+
+
+def _wrap_header_guess_version(header):
+    """
+    Like `_wrap_header`, but chooses an appropriate version given the contents
+    """
+    try:
+        return _wrap_header(header, (1, 0))
+    except ValueError:
+        pass
+
+    try:
+        ret = _wrap_header(header, (2, 0))
+    except UnicodeEncodeError:
+        pass
+    else:
+        warnings.warn("Stored array in format 2.0. It can only be"
+                      "read by NumPy >= 1.9", UserWarning, stacklevel=2)
+        return ret
+
+    header = _wrap_header(header, (3, 0))
+    warnings.warn("Stored array in format 3.0. It can only be "
+                  "read by NumPy >= 1.17", UserWarning, stacklevel=2)
+    return header
+
+
+def _write_array_header(fp, d, version=None):
+    """ Write the header for an array and returns the version used
+
+    Parameters
+    ----------
+    fp : filelike object
+    d : dict
+        This has the appropriate entries for writing its string representation
+        to the header of the file.
+    version : tuple or None
+        None means use oldest that works. Providing an explicit version will
+        raise a ValueError if the format does not allow saving this data.
+        Default: None
+    """
+    header = ["{"]
+    for key, value in sorted(d.items()):
+        # Need to use repr here, since we eval these when reading
+        header.append("'%s': %s, " % (key, repr(value)))
+    header.append("}")
+    header = "".join(header)
+
+    # Add some spare space so that the array header can be modified in-place
+    # when changing the array size, e.g. when growing it by appending data at
+    # the end.
+    shape = d['shape']
+    header += " " * ((GROWTH_AXIS_MAX_DIGITS - len(repr(
+        shape[-1 if d['fortran_order'] else 0]
+    ))) if len(shape) > 0 else 0)
+
+    if version is None:
+        header = _wrap_header_guess_version(header)
+    else:
+        header = _wrap_header(header, version)
+    fp.write(header)
+
+def write_array_header_1_0(fp, d):
+    """ Write the header for an array using the 1.0 format.
+
+    Parameters
+    ----------
+    fp : filelike object
+    d : dict
+        This has the appropriate entries for writing its string
+        representation to the header of the file.
+    """
+    _write_array_header(fp, d, (1, 0))
+
+
+def write_array_header_2_0(fp, d):
+    """ Write the header for an array using the 2.0 format.
+        The 2.0 format allows storing very large structured arrays.
+
+    .. versionadded:: 1.9.0
+
+    Parameters
+    ----------
+    fp : filelike object
+    d : dict
+        This has the appropriate entries for writing its string
+        representation to the header of the file.
+    """
+    _write_array_header(fp, d, (2, 0))
+
+def read_array_header_1_0(fp, max_header_size=_MAX_HEADER_SIZE):
+    """
+    Read an array header from a filelike object using the 1.0 file format
+    version.
+
+    This will leave the file object located just after the header.
+
+    Parameters
+    ----------
+    fp : filelike object
+        A file object or something with a `.read()` method like a file.
+
+    Returns
+    -------
+    shape : tuple of int
+        The shape of the array.
+    fortran_order : bool
+        The array data will be written out directly if it is either
+        C-contiguous or Fortran-contiguous. Otherwise, it will be made
+        contiguous before writing it out.
+    dtype : dtype
+        The dtype of the file's data.
+    max_header_size : int, optional
+        Maximum allowed size of the header.  Large headers may not be safe
+        to load securely and thus require explicitly passing a larger value.
+        See :py:func:`ast.literal_eval()` for details.
+
+    Raises
+    ------
+    ValueError
+        If the data is invalid.
+
+    """
+    return _read_array_header(
+            fp, version=(1, 0), max_header_size=max_header_size)
+
+def read_array_header_2_0(fp, max_header_size=_MAX_HEADER_SIZE):
+    """
+    Read an array header from a filelike object using the 2.0 file format
+    version.
+
+    This will leave the file object located just after the header.
+
+    .. versionadded:: 1.9.0
+
+    Parameters
+    ----------
+    fp : filelike object
+        A file object or something with a `.read()` method like a file.
+    max_header_size : int, optional
+        Maximum allowed size of the header.  Large headers may not be safe
+        to load securely and thus require explicitly passing a larger value.
+        See :py:func:`ast.literal_eval()` for details.
+
+    Returns
+    -------
+    shape : tuple of int
+        The shape of the array.
+    fortran_order : bool
+        The array data will be written out directly if it is either
+        C-contiguous or Fortran-contiguous. Otherwise, it will be made
+        contiguous before writing it out.
+    dtype : dtype
+        The dtype of the file's data.
+
+    Raises
+    ------
+    ValueError
+        If the data is invalid.
+
+    """
+    return _read_array_header(
+            fp, version=(2, 0), max_header_size=max_header_size)
+
+
+def _filter_header(s):
+    """Clean up 'L' in npz header ints.
+
+    Cleans up the 'L' in strings representing integers. Needed to allow npz
+    headers produced in Python2 to be read in Python3.
+
+    Parameters
+    ----------
+    s : string
+        Npy file header.
+
+    Returns
+    -------
+    header : str
+        Cleaned up header.
+
+    """
+    import tokenize
+    from io import StringIO
+
+    tokens = []
+    last_token_was_number = False
+    for token in tokenize.generate_tokens(StringIO(s).readline):
+        token_type = token[0]
+        token_string = token[1]
+        if (last_token_was_number and
+                token_type == tokenize.NAME and
+                token_string == "L"):
+            continue
+        else:
+            tokens.append(token)
+        last_token_was_number = (token_type == tokenize.NUMBER)
+    return tokenize.untokenize(tokens)
+
+
+def _read_array_header(fp, version, max_header_size=_MAX_HEADER_SIZE):
+    """
+    see read_array_header_1_0
+    """
+    # Read an unsigned, little-endian short int which has the length of the
+    # header.
+    import ast
+    import struct
+    hinfo = _header_size_info.get(version)
+    if hinfo is None:
+        raise ValueError("Invalid version {!r}".format(version))
+    hlength_type, encoding = hinfo
+
+    hlength_str = _read_bytes(fp, struct.calcsize(hlength_type), "array header length")
+    header_length = struct.unpack(hlength_type, hlength_str)[0]
+    header = _read_bytes(fp, header_length, "array header")
+    header = header.decode(encoding)
+    if len(header) > max_header_size:
+        raise ValueError(
+            f"Header info length ({len(header)}) is large and may not be safe "
+            "to load securely.\n"
+            "To allow loading, adjust `max_header_size` or fully trust "
+            "the `.npy` file using `allow_pickle=True`.\n"
+            "For safety against large resource use or crashes, sandboxing "
+            "may be necessary.")
+
+    # The header is a pretty-printed string representation of a literal
+    # Python dictionary with trailing newlines padded to a ARRAY_ALIGN byte
+    # boundary. The keys are strings.
+    #   "shape" : tuple of int
+    #   "fortran_order" : bool
+    #   "descr" : dtype.descr
+    # Versions (2, 0) and (1, 0) could have been created by a Python 2
+    # implementation before header filtering was implemented.
+    #
+    # For performance reasons, we try without _filter_header first though
+    try:
+        d = ast.literal_eval(header)
+    except SyntaxError as e:
+        if version <= (2, 0):
+            header = _filter_header(header)
+            try:
+                d = ast.literal_eval(header)
+            except SyntaxError as e2:
+                msg = "Cannot parse header: {!r}"
+                raise ValueError(msg.format(header)) from e2
+            else:
+                warnings.warn(
+                    "Reading `.npy` or `.npz` file required additional "
+                    "header parsing as it was created on Python 2. Save the "
+                    "file again to speed up loading and avoid this warning.",
+                    UserWarning, stacklevel=4)
+        else:
+            msg = "Cannot parse header: {!r}"
+            raise ValueError(msg.format(header)) from e
+    if not isinstance(d, dict):
+        msg = "Header is not a dictionary: {!r}"
+        raise ValueError(msg.format(d))
+
+    if EXPECTED_KEYS != d.keys():
+        keys = sorted(d.keys())
+        msg = "Header does not contain the correct keys: {!r}"
+        raise ValueError(msg.format(keys))
+
+    # Sanity-check the values.
+    if (not isinstance(d['shape'], tuple) or
+            not all(isinstance(x, int) for x in d['shape'])):
+        msg = "shape is not valid: {!r}"
+        raise ValueError(msg.format(d['shape']))
+    if not isinstance(d['fortran_order'], bool):
+        msg = "fortran_order is not a valid bool: {!r}"
+        raise ValueError(msg.format(d['fortran_order']))
+    try:
+        dtype = descr_to_dtype(d['descr'])
+    except TypeError as e:
+        msg = "descr is not a valid dtype descriptor: {!r}"
+        raise ValueError(msg.format(d['descr'])) from e
+
+    return d['shape'], d['fortran_order'], dtype
+
+def write_array(fp, array, version=None, allow_pickle=True, pickle_kwargs=None):
+    """
+    Write an array to an NPY file, including a header.
+
+    If the array is neither C-contiguous nor Fortran-contiguous AND the
+    file_like object is not a real file object, this function will have to
+    copy data in memory.
+
+    Parameters
+    ----------
+    fp : file_like object
+        An open, writable file object, or similar object with a
+        ``.write()`` method.
+    array : ndarray
+        The array to write to disk.
+    version : (int, int) or None, optional
+        The version number of the format. None means use the oldest
+        supported version that is able to store the data.  Default: None
+    allow_pickle : bool, optional
+        Whether to allow writing pickled data. Default: True
+    pickle_kwargs : dict, optional
+        Additional keyword arguments to pass to pickle.dump, excluding
+        'protocol'. These are only useful when pickling objects in object
+        arrays on Python 3 to Python 2 compatible format.
+
+    Raises
+    ------
+    ValueError
+        If the array cannot be persisted. This includes the case of
+        allow_pickle=False and array being an object array.
+    Various other errors
+        If the array contains Python objects as part of its dtype, the
+        process of pickling them may raise various errors if the objects
+        are not picklable.
+
+    """
+    _check_version(version)
+    _write_array_header(fp, header_data_from_array_1_0(array), version)
+
+    if array.itemsize == 0:
+        buffersize = 0
+    else:
+        # Set buffer size to 16 MiB to hide the Python loop overhead.
+        buffersize = max(16 * 1024 ** 2 // array.itemsize, 1)
+
+    dtype_class = type(array.dtype)
+
+    if array.dtype.hasobject or not dtype_class._legacy:
+        # We contain Python objects so we cannot write out the data
+        # directly.  Instead, we will pickle it out
+        if not allow_pickle:
+            if array.dtype.hasobject:
+                raise ValueError("Object arrays cannot be saved when "
+                                 "allow_pickle=False")
+            if not dtype_class._legacy:
+                raise ValueError("User-defined dtypes cannot be saved "
+                                 "when allow_pickle=False")
+        if pickle_kwargs is None:
+            pickle_kwargs = {}
+        pickle.dump(array, fp, protocol=4, **pickle_kwargs)
+    elif array.flags.f_contiguous and not array.flags.c_contiguous:
+        if isfileobj(fp):
+            array.T.tofile(fp)
+        else:
+            for chunk in numpy.nditer(
+                    array, flags=['external_loop', 'buffered', 'zerosize_ok'],
+                    buffersize=buffersize, order='F'):
+                fp.write(chunk.tobytes('C'))
+    else:
+        if isfileobj(fp):
+            array.tofile(fp)
+        else:
+            for chunk in numpy.nditer(
+                    array, flags=['external_loop', 'buffered', 'zerosize_ok'],
+                    buffersize=buffersize, order='C'):
+                fp.write(chunk.tobytes('C'))
+
+
+def read_array(fp, allow_pickle=False, pickle_kwargs=None, *,
+               max_header_size=_MAX_HEADER_SIZE):
+    """
+    Read an array from an NPY file.
+
+    Parameters
+    ----------
+    fp : file_like object
+        If this is not a real file object, then this may take extra memory
+        and time.
+    allow_pickle : bool, optional
+        Whether to allow writing pickled data. Default: False
+
+        .. versionchanged:: 1.16.3
+            Made default False in response to CVE-2019-6446.
+
+    pickle_kwargs : dict
+        Additional keyword arguments to pass to pickle.load. These are only
+        useful when loading object arrays saved on Python 2 when using
+        Python 3.
+    max_header_size : int, optional
+        Maximum allowed size of the header.  Large headers may not be safe
+        to load securely and thus require explicitly passing a larger value.
+        See :py:func:`ast.literal_eval()` for details.
+        This option is ignored when `allow_pickle` is passed.  In that case
+        the file is by definition trusted and the limit is unnecessary.
+
+    Returns
+    -------
+    array : ndarray
+        The array from the data on disk.
+
+    Raises
+    ------
+    ValueError
+        If the data is invalid, or allow_pickle=False and the file contains
+        an object array.
+
+    """
+    if allow_pickle:
+        # Effectively ignore max_header_size, since `allow_pickle` indicates
+        # that the input is fully trusted.
+        max_header_size = 2**64
+
+    version = read_magic(fp)
+    _check_version(version)
+    shape, fortran_order, dtype = _read_array_header(
+            fp, version, max_header_size=max_header_size)
+    if len(shape) == 0:
+        count = 1
+    else:
+        count = numpy.multiply.reduce(shape, dtype=numpy.int64)
+
+    # Now read the actual data.
+    if dtype.hasobject:
+        # The array contained Python objects. We need to unpickle the data.
+        if not allow_pickle:
+            raise ValueError("Object arrays cannot be loaded when "
+                             "allow_pickle=False")
+        if pickle_kwargs is None:
+            pickle_kwargs = {}
+        try:
+            array = pickle.load(fp, **pickle_kwargs)
+        except UnicodeError as err:
+            # Friendlier error message
+            raise UnicodeError("Unpickling a python object failed: %r\n"
+                               "You may need to pass the encoding= option "
+                               "to numpy.load" % (err,)) from err
+    else:
+        if isfileobj(fp):
+            # We can use the fast fromfile() function.
+            array = numpy.fromfile(fp, dtype=dtype, count=count)
+        else:
+            # This is not a real file. We have to read it the
+            # memory-intensive way.
+            # crc32 module fails on reads greater than 2 ** 32 bytes,
+            # breaking large reads from gzip streams. Chunk reads to
+            # BUFFER_SIZE bytes to avoid issue and reduce memory overhead
+            # of the read. In non-chunked case count < max_read_count, so
+            # only one read is performed.
+
+            # Use np.ndarray instead of np.empty since the latter does
+            # not correctly instantiate zero-width string dtypes; see
+            # https://github.com/numpy/numpy/pull/6430
+            array = numpy.ndarray(count, dtype=dtype)
+
+            if dtype.itemsize > 0:
+                # If dtype.itemsize == 0 then there's nothing more to read
+                max_read_count = BUFFER_SIZE // min(BUFFER_SIZE, dtype.itemsize)
+
+                for i in range(0, count, max_read_count):
+                    read_count = min(max_read_count, count - i)
+                    read_size = int(read_count * dtype.itemsize)
+                    data = _read_bytes(fp, read_size, "array data")
+                    array[i:i+read_count] = numpy.frombuffer(data, dtype=dtype,
+                                                             count=read_count)
+
+        if fortran_order:
+            array.shape = shape[::-1]
+            array = array.transpose()
+        else:
+            array.shape = shape
+
+    return array
+
+
+def open_memmap(filename, mode='r+', dtype=None, shape=None,
+                fortran_order=False, version=None, *,
+                max_header_size=_MAX_HEADER_SIZE):
+    """
+    Open a .npy file as a memory-mapped array.
+
+    This may be used to read an existing file or create a new one.
+
+    Parameters
+    ----------
+    filename : str or path-like
+        The name of the file on disk.  This may *not* be a file-like
+        object.
+    mode : str, optional
+        The mode in which to open the file; the default is 'r+'.  In
+        addition to the standard file modes, 'c' is also accepted to mean
+        "copy on write."  See `memmap` for the available mode strings.
+    dtype : data-type, optional
+        The data type of the array if we are creating a new file in "write"
+        mode, if not, `dtype` is ignored.  The default value is None, which
+        results in a data-type of `float64`.
+    shape : tuple of int
+        The shape of the array if we are creating a new file in "write"
+        mode, in which case this parameter is required.  Otherwise, this
+        parameter is ignored and is thus optional.
+    fortran_order : bool, optional
+        Whether the array should be Fortran-contiguous (True) or
+        C-contiguous (False, the default) if we are creating a new file in
+        "write" mode.
+    version : tuple of int (major, minor) or None
+        If the mode is a "write" mode, then this is the version of the file
+        format used to create the file.  None means use the oldest
+        supported version that is able to store the data.  Default: None
+    max_header_size : int, optional
+        Maximum allowed size of the header.  Large headers may not be safe
+        to load securely and thus require explicitly passing a larger value.
+        See :py:func:`ast.literal_eval()` for details.
+
+    Returns
+    -------
+    marray : memmap
+        The memory-mapped array.
+
+    Raises
+    ------
+    ValueError
+        If the data or the mode is invalid.
+    OSError
+        If the file is not found or cannot be opened correctly.
+
+    See Also
+    --------
+    numpy.memmap
+
+    """
+    if isfileobj(filename):
+        raise ValueError("Filename must be a string or a path-like object."
+                         "  Memmap cannot use existing file handles.")
+
+    if 'w' in mode:
+        # We are creating the file, not reading it.
+        # Check if we ought to create the file.
+        _check_version(version)
+        # Ensure that the given dtype is an authentic dtype object rather
+        # than just something that can be interpreted as a dtype object.
+        dtype = numpy.dtype(dtype)
+        if dtype.hasobject:
+            msg = "Array can't be memory-mapped: Python objects in dtype."
+            raise ValueError(msg)
+        d = dict(
+            descr=dtype_to_descr(dtype),
+            fortran_order=fortran_order,
+            shape=shape,
+        )
+        # If we got here, then it should be safe to create the file.
+        with open(os.fspath(filename), mode+'b') as fp:
+            _write_array_header(fp, d, version)
+            offset = fp.tell()
+    else:
+        # Read the header of the file first.
+        with open(os.fspath(filename), 'rb') as fp:
+            version = read_magic(fp)
+            _check_version(version)
+
+            shape, fortran_order, dtype = _read_array_header(
+                    fp, version, max_header_size=max_header_size)
+            if dtype.hasobject:
+                msg = "Array can't be memory-mapped: Python objects in dtype."
+                raise ValueError(msg)
+            offset = fp.tell()
+
+    if fortran_order:
+        order = 'F'
+    else:
+        order = 'C'
+
+    # We need to change a write-only mode to a read-write mode since we've
+    # already written data to the file.
+    if mode == 'w+':
+        mode = 'r+'
+
+    marray = numpy.memmap(filename, dtype=dtype, shape=shape, order=order,
+        mode=mode, offset=offset)
+
+    return marray
+
+
+def _read_bytes(fp, size, error_template="ran out of data"):
+    """
+    Read from file-like object until size bytes are read.
+    Raises ValueError if not EOF is encountered before size bytes are read.
+    Non-blocking objects only supported if they derive from io objects.
+
+    Required as e.g. ZipExtFile in python 2.6 can return less data than
+    requested.
+    """
+    data = bytes()
+    while True:
+        # io files (default in python3) return None or raise on
+        # would-block, python2 file will truncate, probably nothing can be
+        # done about that.  note that regular files can't be non-blocking
+        try:
+            r = fp.read(size - len(data))
+            data += r
+            if len(r) == 0 or len(data) == size:
+                break
+        except BlockingIOError:
+            pass
+    if len(data) != size:
+        msg = "EOF: reading %s, expected %d bytes got %d"
+        raise ValueError(msg % (error_template, size, len(data)))
+    else:
+        return data
+
+
+def isfileobj(f):
+    if not isinstance(f, (io.FileIO, io.BufferedReader, io.BufferedWriter)):
+        return False
+    try:
+        # BufferedReader/Writer may raise OSError when
+        # fetching `fileno()` (e.g. when wrapping BytesIO).
+        f.fileno()
+        return True
+    except OSError:
+        return False
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/format.pyi b/venv/lib/python3.12/site-packages/numpy/lib/format.pyi
new file mode 100644
index 00000000..a4468f52
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/lib/format.pyi
@@ -0,0 +1,22 @@
+from typing import Any, Literal, Final
+
+__all__: list[str]
+
+EXPECTED_KEYS: Final[set[str]]
+MAGIC_PREFIX: Final[bytes]
+MAGIC_LEN: Literal[8]
+ARRAY_ALIGN: Literal[64]
+BUFFER_SIZE: Literal[262144]  # 2**18
+
+def magic(major, minor): ...
+def read_magic(fp): ...
+def dtype_to_descr(dtype): ...
+def descr_to_dtype(descr): ...
+def header_data_from_array_1_0(array): ...
+def write_array_header_1_0(fp, d): ...
+def write_array_header_2_0(fp, d): ...
+def read_array_header_1_0(fp): ...
+def read_array_header_2_0(fp): ...
+def write_array(fp, array, version=..., allow_pickle=..., pickle_kwargs=...): ...
+def read_array(fp, allow_pickle=..., pickle_kwargs=...): ...
+def open_memmap(filename, mode=..., dtype=..., shape=..., fortran_order=..., version=...): ...
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/introspect.py b/venv/lib/python3.12/site-packages/numpy/lib/introspect.py
new file mode 100644
index 00000000..70e638d4
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/lib/introspect.py
@@ -0,0 +1,96 @@
+"""
+Introspection helper functions.
+"""
+import re
+
+__all__ = ['opt_func_info']
+
+
+def opt_func_info(func_name=None, signature=None):
+    """
+    Returns a dictionary containing the currently supported CPU dispatched
+    features for all optimized functions.
+
+    Parameters
+    ----------
+    func_name : str (optional)
+        Regular expression to filter by function name.
+
+    signature : str (optional)
+        Regular expression to filter by data type.
+
+    Returns
+    -------
+    dict
+        A dictionary where keys are optimized function names and values are
+        nested dictionaries indicating supported targets based on data types.
+
+    Examples
+    --------
+    Retrieve dispatch information for functions named 'add' or 'sub' and
+    data types 'float64' or 'float32':
+
+    >>> import numpy as np
+    >>> dict = np.lib.introspect.opt_func_info(
+    ...     func_name="add|abs", signature="float64|complex64"
+    ... )
+    >>> import json
+    >>> print(json.dumps(dict, indent=2))
+        {
+          "absolute": {
+            "dd": {
+              "current": "SSE41",
+              "available": "SSE41 baseline(SSE SSE2 SSE3)"
+            },
+            "Ff": {
+              "current": "FMA3__AVX2",
+              "available": "AVX512F FMA3__AVX2 baseline(SSE SSE2 SSE3)"
+            },
+            "Dd": {
+              "current": "FMA3__AVX2",
+              "available": "AVX512F FMA3__AVX2 baseline(SSE SSE2 SSE3)"
+            }
+          },
+          "add": {
+            "ddd": {
+              "current": "FMA3__AVX2",
+              "available": "FMA3__AVX2 baseline(SSE SSE2 SSE3)"
+            },
+            "FFF": {
+              "current": "FMA3__AVX2",
+              "available": "FMA3__AVX2 baseline(SSE SSE2 SSE3)"
+            }
+          }
+        }
+
+    """
+    from numpy._core._multiarray_umath import (
+        __cpu_targets_info__ as targets, dtype
+    )
+
+    if func_name is not None:
+        func_pattern = re.compile(func_name)
+        matching_funcs = {
+            k: v for k, v in targets.items()
+            if func_pattern.search(k)
+        }
+    else:
+        matching_funcs = targets
+
+    if signature is not None:
+        sig_pattern = re.compile(signature)
+        matching_sigs = {}
+        for k, v in matching_funcs.items():
+            matching_chars = {}
+            for chars, targets in v.items():
+                if any([
+                    sig_pattern.search(c) or
+                    sig_pattern.search(dtype(c).name)
+                    for c in chars
+                ]):
+                    matching_chars[chars] = targets
+            if matching_chars:
+                matching_sigs[k] = matching_chars
+    else:
+        matching_sigs = matching_funcs
+    return matching_sigs
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/mixins.py b/venv/lib/python3.12/site-packages/numpy/lib/mixins.py
new file mode 100644
index 00000000..a15bdeea
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/lib/mixins.py
@@ -0,0 +1,183 @@
+"""
+Mixin classes for custom array types that don't inherit from ndarray.
+"""
+from numpy._core import umath as um
+
+
+__all__ = ['NDArrayOperatorsMixin']
+
+
+def _disables_array_ufunc(obj):
+    """True when __array_ufunc__ is set to None."""
+    try:
+        return obj.__array_ufunc__ is None
+    except AttributeError:
+        return False
+
+
+def _binary_method(ufunc, name):
+    """Implement a forward binary method with a ufunc, e.g., __add__."""
+    def func(self, other):
+        if _disables_array_ufunc(other):
+            return NotImplemented
+        return ufunc(self, other)
+    func.__name__ = '__{}__'.format(name)
+    return func
+
+
+def _reflected_binary_method(ufunc, name):
+    """Implement a reflected binary method with a ufunc, e.g., __radd__."""
+    def func(self, other):
+        if _disables_array_ufunc(other):
+            return NotImplemented
+        return ufunc(other, self)
+    func.__name__ = '__r{}__'.format(name)
+    return func
+
+
+def _inplace_binary_method(ufunc, name):
+    """Implement an in-place binary method with a ufunc, e.g., __iadd__."""
+    def func(self, other):
+        return ufunc(self, other, out=(self,))
+    func.__name__ = '__i{}__'.format(name)
+    return func
+
+
+def _numeric_methods(ufunc, name):
+    """Implement forward, reflected and inplace binary methods with a ufunc."""
+    return (_binary_method(ufunc, name),
+            _reflected_binary_method(ufunc, name),
+            _inplace_binary_method(ufunc, name))
+
+
+def _unary_method(ufunc, name):
+    """Implement a unary special method with a ufunc."""
+    def func(self):
+        return ufunc(self)
+    func.__name__ = '__{}__'.format(name)
+    return func
+
+
+class NDArrayOperatorsMixin:
+    """Mixin defining all operator special methods using __array_ufunc__.
+
+    This class implements the special methods for almost all of Python's
+    builtin operators defined in the `operator` module, including comparisons
+    (``==``, ``>``, etc.) and arithmetic (``+``, ``*``, ``-``, etc.), by
+    deferring to the ``__array_ufunc__`` method, which subclasses must
+    implement.
+
+    It is useful for writing classes that do not inherit from `numpy.ndarray`,
+    but that should support arithmetic and numpy universal functions like
+    arrays as described in `A Mechanism for Overriding Ufuncs
+    `_.
+
+    As an trivial example, consider this implementation of an ``ArrayLike``
+    class that simply wraps a NumPy array and ensures that the result of any
+    arithmetic operation is also an ``ArrayLike`` object:
+
+        >>> import numbers
+        >>> class ArrayLike(np.lib.mixins.NDArrayOperatorsMixin):
+        ...     def __init__(self, value):
+        ...         self.value = np.asarray(value)
+        ...
+        ...     # One might also consider adding the built-in list type to this
+        ...     # list, to support operations like np.add(array_like, list)
+        ...     _HANDLED_TYPES = (np.ndarray, numbers.Number)
+        ...
+        ...     def __array_ufunc__(self, ufunc, method, *inputs, **kwargs):
+        ...         out = kwargs.get('out', ())
+        ...         for x in inputs + out:
+        ...             # Only support operations with instances of
+        ...             # _HANDLED_TYPES. Use ArrayLike instead of type(self)
+        ...             # for isinstance to allow subclasses that don't
+        ...             # override __array_ufunc__ to handle ArrayLike objects.
+        ...             if not isinstance(
+        ...                 x, self._HANDLED_TYPES + (ArrayLike,)
+        ...             ):
+        ...                 return NotImplemented
+        ...
+        ...         # Defer to the implementation of the ufunc
+        ...         # on unwrapped values.
+        ...         inputs = tuple(x.value if isinstance(x, ArrayLike) else x
+        ...                     for x in inputs)
+        ...         if out:
+        ...             kwargs['out'] = tuple(
+        ...                 x.value if isinstance(x, ArrayLike) else x
+        ...                 for x in out)
+        ...         result = getattr(ufunc, method)(*inputs, **kwargs)
+        ...
+        ...         if type(result) is tuple:
+        ...             # multiple return values
+        ...             return tuple(type(self)(x) for x in result)
+        ...         elif method == 'at':
+        ...             # no return value
+        ...             return None
+        ...         else:
+        ...             # one return value
+        ...             return type(self)(result)
+        ... 
+        ...     def __repr__(self):
+        ...         return '%s(%r)' % (type(self).__name__, self.value)
+
+    In interactions between ``ArrayLike`` objects and numbers or numpy arrays,
+    the result is always another ``ArrayLike``:
+
+        >>> x = ArrayLike([1, 2, 3])
+        >>> x - 1
+        ArrayLike(array([0, 1, 2]))
+        >>> 1 - x
+        ArrayLike(array([ 0, -1, -2]))
+        >>> np.arange(3) - x
+        ArrayLike(array([-1, -1, -1]))
+        >>> x - np.arange(3)
+        ArrayLike(array([1, 1, 1]))
+
+    Note that unlike ``numpy.ndarray``, ``ArrayLike`` does not allow operations
+    with arbitrary, unrecognized types. This ensures that interactions with
+    ArrayLike preserve a well-defined casting hierarchy.
+
+    .. versionadded:: 1.13
+    """
+    __slots__ = ()
+    # Like np.ndarray, this mixin class implements "Option 1" from the ufunc
+    # overrides NEP.
+
+    # comparisons don't have reflected and in-place versions
+    __lt__ = _binary_method(um.less, 'lt')
+    __le__ = _binary_method(um.less_equal, 'le')
+    __eq__ = _binary_method(um.equal, 'eq')
+    __ne__ = _binary_method(um.not_equal, 'ne')
+    __gt__ = _binary_method(um.greater, 'gt')
+    __ge__ = _binary_method(um.greater_equal, 'ge')
+
+    # numeric methods
+    __add__, __radd__, __iadd__ = _numeric_methods(um.add, 'add')
+    __sub__, __rsub__, __isub__ = _numeric_methods(um.subtract, 'sub')
+    __mul__, __rmul__, __imul__ = _numeric_methods(um.multiply, 'mul')
+    __matmul__, __rmatmul__, __imatmul__ = _numeric_methods(
+        um.matmul, 'matmul')
+    # Python 3 does not use __div__, __rdiv__, or __idiv__
+    __truediv__, __rtruediv__, __itruediv__ = _numeric_methods(
+        um.true_divide, 'truediv')
+    __floordiv__, __rfloordiv__, __ifloordiv__ = _numeric_methods(
+        um.floor_divide, 'floordiv')
+    __mod__, __rmod__, __imod__ = _numeric_methods(um.remainder, 'mod')
+    __divmod__ = _binary_method(um.divmod, 'divmod')
+    __rdivmod__ = _reflected_binary_method(um.divmod, 'divmod')
+    # __idivmod__ does not exist
+    # TODO: handle the optional third argument for __pow__?
+    __pow__, __rpow__, __ipow__ = _numeric_methods(um.power, 'pow')
+    __lshift__, __rlshift__, __ilshift__ = _numeric_methods(
+        um.left_shift, 'lshift')
+    __rshift__, __rrshift__, __irshift__ = _numeric_methods(
+        um.right_shift, 'rshift')
+    __and__, __rand__, __iand__ = _numeric_methods(um.bitwise_and, 'and')
+    __xor__, __rxor__, __ixor__ = _numeric_methods(um.bitwise_xor, 'xor')
+    __or__, __ror__, __ior__ = _numeric_methods(um.bitwise_or, 'or')
+
+    # unary methods
+    __neg__ = _unary_method(um.negative, 'neg')
+    __pos__ = _unary_method(um.positive, 'pos')
+    __abs__ = _unary_method(um.absolute, 'abs')
+    __invert__ = _unary_method(um.invert, 'invert')
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/mixins.pyi b/venv/lib/python3.12/site-packages/numpy/lib/mixins.pyi
new file mode 100644
index 00000000..dfabe3d8
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/lib/mixins.pyi
@@ -0,0 +1,74 @@
+from abc import ABCMeta, abstractmethod
+from typing import Literal as L, Any
+
+from numpy import ufunc
+
+__all__: list[str]
+
+# NOTE: `NDArrayOperatorsMixin` is not formally an abstract baseclass,
+# even though it's reliant on subclasses implementing `__array_ufunc__`
+
+# NOTE: The accepted input- and output-types of the various dunders are
+# completely dependent on how `__array_ufunc__` is implemented.
+# As such, only little type safety can be provided here.
+
+class NDArrayOperatorsMixin(metaclass=ABCMeta):
+    @abstractmethod
+    def __array_ufunc__(
+        self,
+        ufunc: ufunc,
+        method: L["__call__", "reduce", "reduceat", "accumulate", "outer", "at"],
+        *inputs: Any,
+        **kwargs: Any,
+    ) -> Any: ...
+    def __lt__(self, other: Any) -> Any: ...
+    def __le__(self, other: Any) -> Any: ...
+    def __eq__(self, other: Any) -> Any: ...
+    def __ne__(self, other: Any) -> Any: ...
+    def __gt__(self, other: Any) -> Any: ...
+    def __ge__(self, other: Any) -> Any: ...
+    def __add__(self, other: Any) -> Any: ...
+    def __radd__(self, other: Any) -> Any: ...
+    def __iadd__(self, other: Any) -> Any: ...
+    def __sub__(self, other: Any) -> Any: ...
+    def __rsub__(self, other: Any) -> Any: ...
+    def __isub__(self, other: Any) -> Any: ...
+    def __mul__(self, other: Any) -> Any: ...
+    def __rmul__(self, other: Any) -> Any: ...
+    def __imul__(self, other: Any) -> Any: ...
+    def __matmul__(self, other: Any) -> Any: ...
+    def __rmatmul__(self, other: Any) -> Any: ...
+    def __imatmul__(self, other: Any) -> Any: ...
+    def __truediv__(self, other: Any) -> Any: ...
+    def __rtruediv__(self, other: Any) -> Any: ...
+    def __itruediv__(self, other: Any) -> Any: ...
+    def __floordiv__(self, other: Any) -> Any: ...
+    def __rfloordiv__(self, other: Any) -> Any: ...
+    def __ifloordiv__(self, other: Any) -> Any: ...
+    def __mod__(self, other: Any) -> Any: ...
+    def __rmod__(self, other: Any) -> Any: ...
+    def __imod__(self, other: Any) -> Any: ...
+    def __divmod__(self, other: Any) -> Any: ...
+    def __rdivmod__(self, other: Any) -> Any: ...
+    def __pow__(self, other: Any) -> Any: ...
+    def __rpow__(self, other: Any) -> Any: ...
+    def __ipow__(self, other: Any) -> Any: ...
+    def __lshift__(self, other: Any) -> Any: ...
+    def __rlshift__(self, other: Any) -> Any: ...
+    def __ilshift__(self, other: Any) -> Any: ...
+    def __rshift__(self, other: Any) -> Any: ...
+    def __rrshift__(self, other: Any) -> Any: ...
+    def __irshift__(self, other: Any) -> Any: ...
+    def __and__(self, other: Any) -> Any: ...
+    def __rand__(self, other: Any) -> Any: ...
+    def __iand__(self, other: Any) -> Any: ...
+    def __xor__(self, other: Any) -> Any: ...
+    def __rxor__(self, other: Any) -> Any: ...
+    def __ixor__(self, other: Any) -> Any: ...
+    def __or__(self, other: Any) -> Any: ...
+    def __ror__(self, other: Any) -> Any: ...
+    def __ior__(self, other: Any) -> Any: ...
+    def __neg__(self) -> Any: ...
+    def __pos__(self) -> Any: ...
+    def __abs__(self) -> Any: ...
+    def __invert__(self) -> Any: ...
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/npyio.py b/venv/lib/python3.12/site-packages/numpy/lib/npyio.py
new file mode 100644
index 00000000..1003ef5b
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/lib/npyio.py
@@ -0,0 +1,3 @@
+from ._npyio_impl import (
+    __doc__, DataSource, NpzFile
+)
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/npyio.pyi b/venv/lib/python3.12/site-packages/numpy/lib/npyio.pyi
new file mode 100644
index 00000000..c3258e88
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/lib/npyio.pyi
@@ -0,0 +1,4 @@
+from numpy.lib._npyio_impl import (
+    DataSource as DataSource,
+    NpzFile as NpzFile,
+)
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/recfunctions.py b/venv/lib/python3.12/site-packages/numpy/lib/recfunctions.py
new file mode 100644
index 00000000..ab16d1f9
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/lib/recfunctions.py
@@ -0,0 +1,1690 @@
+"""
+Collection of utilities to manipulate structured arrays.
+
+Most of these functions were initially implemented by John Hunter for
+matplotlib.  They have been rewritten and extended for convenience.
+
+"""
+import itertools
+import numpy as np
+import numpy.ma as ma
+from numpy import ndarray
+from numpy.ma import MaskedArray
+from numpy.ma.mrecords import MaskedRecords
+from numpy._core.overrides import array_function_dispatch
+from numpy._core.records import recarray
+from numpy.lib._iotools import _is_string_like
+
+_check_fill_value = np.ma.core._check_fill_value
+
+
+__all__ = [
+    'append_fields', 'apply_along_fields', 'assign_fields_by_name',
+    'drop_fields', 'find_duplicates', 'flatten_descr',
+    'get_fieldstructure', 'get_names', 'get_names_flat',
+    'join_by', 'merge_arrays', 'rec_append_fields',
+    'rec_drop_fields', 'rec_join', 'recursive_fill_fields',
+    'rename_fields', 'repack_fields', 'require_fields',
+    'stack_arrays', 'structured_to_unstructured', 'unstructured_to_structured',
+    ]
+
+
+def _recursive_fill_fields_dispatcher(input, output):
+    return (input, output)
+
+
+@array_function_dispatch(_recursive_fill_fields_dispatcher)
+def recursive_fill_fields(input, output):
+    """
+    Fills fields from output with fields from input,
+    with support for nested structures.
+
+    Parameters
+    ----------
+    input : ndarray
+        Input array.
+    output : ndarray
+        Output array.
+
+    Notes
+    -----
+    * `output` should be at least the same size as `input`
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from numpy.lib import recfunctions as rfn
+    >>> a = np.array([(1, 10.), (2, 20.)], dtype=[('A', np.int64), ('B', np.float64)])
+    >>> b = np.zeros((3,), dtype=a.dtype)
+    >>> rfn.recursive_fill_fields(a, b)
+    array([(1, 10.), (2, 20.), (0,  0.)], dtype=[('A', '>> import numpy as np
+    >>> dt = np.dtype([(('a', 'A'), np.int64), ('b', np.double, 3)])
+    >>> dt.descr
+    [(('a', 'A'), '>> _get_fieldspec(dt)
+    [(('a', 'A'), dtype('int64')), ('b', dtype(('>> import numpy as np
+    >>> from numpy.lib import recfunctions as rfn
+    >>> rfn.get_names(np.empty((1,), dtype=[('A', int)]).dtype)
+    ('A',)
+    >>> rfn.get_names(np.empty((1,), dtype=[('A',int), ('B', float)]).dtype)
+    ('A', 'B')
+    >>> adtype = np.dtype([('a', int), ('b', [('ba', int), ('bb', int)])])
+    >>> rfn.get_names(adtype)
+    ('a', ('b', ('ba', 'bb')))
+    """
+    listnames = []
+    names = adtype.names
+    for name in names:
+        current = adtype[name]
+        if current.names is not None:
+            listnames.append((name, tuple(get_names(current))))
+        else:
+            listnames.append(name)
+    return tuple(listnames)
+
+
+def get_names_flat(adtype):
+    """
+    Returns the field names of the input datatype as a tuple. Input datatype
+    must have fields otherwise error is raised.
+    Nested structure are flattened beforehand.
+
+    Parameters
+    ----------
+    adtype : dtype
+        Input datatype
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from numpy.lib import recfunctions as rfn
+    >>> rfn.get_names_flat(np.empty((1,), dtype=[('A', int)]).dtype) is None
+    False
+    >>> rfn.get_names_flat(np.empty((1,), dtype=[('A',int), ('B', str)]).dtype)
+    ('A', 'B')
+    >>> adtype = np.dtype([('a', int), ('b', [('ba', int), ('bb', int)])])
+    >>> rfn.get_names_flat(adtype)
+    ('a', 'b', 'ba', 'bb')
+    """
+    listnames = []
+    names = adtype.names
+    for name in names:
+        listnames.append(name)
+        current = adtype[name]
+        if current.names is not None:
+            listnames.extend(get_names_flat(current))
+    return tuple(listnames)
+
+
+def flatten_descr(ndtype):
+    """
+    Flatten a structured data-type description.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from numpy.lib import recfunctions as rfn
+    >>> ndtype = np.dtype([('a', '>> rfn.flatten_descr(ndtype)
+    (('a', dtype('int32')), ('ba', dtype('float64')), ('bb', dtype('int32')))
+
+    """
+    names = ndtype.names
+    if names is None:
+        return (('', ndtype),)
+    else:
+        descr = []
+        for field in names:
+            (typ, _) = ndtype.fields[field]
+            if typ.names is not None:
+                descr.extend(flatten_descr(typ))
+            else:
+                descr.append((field, typ))
+        return tuple(descr)
+
+
+def _zip_dtype(seqarrays, flatten=False):
+    newdtype = []
+    if flatten:
+        for a in seqarrays:
+            newdtype.extend(flatten_descr(a.dtype))
+    else:
+        for a in seqarrays:
+            current = a.dtype
+            if current.names is not None and len(current.names) == 1:
+                # special case - dtypes of 1 field are flattened
+                newdtype.extend(_get_fieldspec(current))
+            else:
+                newdtype.append(('', current))
+    return np.dtype(newdtype)
+
+
+def _zip_descr(seqarrays, flatten=False):
+    """
+    Combine the dtype description of a series of arrays.
+
+    Parameters
+    ----------
+    seqarrays : sequence of arrays
+        Sequence of arrays
+    flatten : {boolean}, optional
+        Whether to collapse nested descriptions.
+    """
+    return _zip_dtype(seqarrays, flatten=flatten).descr
+
+
+def get_fieldstructure(adtype, lastname=None, parents=None,):
+    """
+    Returns a dictionary with fields indexing lists of their parent fields.
+
+    This function is used to simplify access to fields nested in other fields.
+
+    Parameters
+    ----------
+    adtype : np.dtype
+        Input datatype
+    lastname : optional
+        Last processed field name (used internally during recursion).
+    parents : dictionary
+        Dictionary of parent fields (used interbally during recursion).
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from numpy.lib import recfunctions as rfn
+    >>> ndtype =  np.dtype([('A', int),
+    ...                     ('B', [('BA', int),
+    ...                            ('BB', [('BBA', int), ('BBB', int)])])])
+    >>> rfn.get_fieldstructure(ndtype)
+    ... # XXX: possible regression, order of BBA and BBB is swapped
+    {'A': [], 'B': [], 'BA': ['B'], 'BB': ['B'], 'BBA': ['B', 'BB'], 'BBB': ['B', 'BB']}
+
+    """
+    if parents is None:
+        parents = {}
+    names = adtype.names
+    for name in names:
+        current = adtype[name]
+        if current.names is not None:
+            if lastname:
+                parents[name] = [lastname, ]
+            else:
+                parents[name] = []
+            parents.update(get_fieldstructure(current, name, parents))
+        else:
+            lastparent = [_ for _ in (parents.get(lastname, []) or [])]
+            if lastparent:
+                lastparent.append(lastname)
+            elif lastname:
+                lastparent = [lastname, ]
+            parents[name] = lastparent or []
+    return parents
+
+
+def _izip_fields_flat(iterable):
+    """
+    Returns an iterator of concatenated fields from a sequence of arrays,
+    collapsing any nested structure.
+
+    """
+    for element in iterable:
+        if isinstance(element, np.void):
+            yield from _izip_fields_flat(tuple(element))
+        else:
+            yield element
+
+
+def _izip_fields(iterable):
+    """
+    Returns an iterator of concatenated fields from a sequence of arrays.
+
+    """
+    for element in iterable:
+        if (hasattr(element, '__iter__') and
+                not isinstance(element, str)):
+            yield from _izip_fields(element)
+        elif isinstance(element, np.void) and len(tuple(element)) == 1:
+            # this statement is the same from the previous expression
+            yield from _izip_fields(element)
+        else:
+            yield element
+
+
+def _izip_records(seqarrays, fill_value=None, flatten=True):
+    """
+    Returns an iterator of concatenated items from a sequence of arrays.
+
+    Parameters
+    ----------
+    seqarrays : sequence of arrays
+        Sequence of arrays.
+    fill_value : {None, integer}
+        Value used to pad shorter iterables.
+    flatten : {True, False},
+        Whether to
+    """
+
+    # Should we flatten the items, or just use a nested approach
+    if flatten:
+        zipfunc = _izip_fields_flat
+    else:
+        zipfunc = _izip_fields
+
+    for tup in itertools.zip_longest(*seqarrays, fillvalue=fill_value):
+        yield tuple(zipfunc(tup))
+
+
+def _fix_output(output, usemask=True, asrecarray=False):
+    """
+    Private function: return a recarray, a ndarray, a MaskedArray
+    or a MaskedRecords depending on the input parameters
+    """
+    if not isinstance(output, MaskedArray):
+        usemask = False
+    if usemask:
+        if asrecarray:
+            output = output.view(MaskedRecords)
+    else:
+        output = ma.filled(output)
+        if asrecarray:
+            output = output.view(recarray)
+    return output
+
+
+def _fix_defaults(output, defaults=None):
+    """
+    Update the fill_value and masked data of `output`
+    from the default given in a dictionary defaults.
+    """
+    names = output.dtype.names
+    (data, mask, fill_value) = (output.data, output.mask, output.fill_value)
+    for (k, v) in (defaults or {}).items():
+        if k in names:
+            fill_value[k] = v
+            data[k][mask[k]] = v
+    return output
+
+
+def _merge_arrays_dispatcher(seqarrays, fill_value=None, flatten=None,
+                             usemask=None, asrecarray=None):
+    return seqarrays
+
+
+@array_function_dispatch(_merge_arrays_dispatcher)
+def merge_arrays(seqarrays, fill_value=-1, flatten=False,
+                 usemask=False, asrecarray=False):
+    """
+    Merge arrays field by field.
+
+    Parameters
+    ----------
+    seqarrays : sequence of ndarrays
+        Sequence of arrays
+    fill_value : {float}, optional
+        Filling value used to pad missing data on the shorter arrays.
+    flatten : {False, True}, optional
+        Whether to collapse nested fields.
+    usemask : {False, True}, optional
+        Whether to return a masked array or not.
+    asrecarray : {False, True}, optional
+        Whether to return a recarray (MaskedRecords) or not.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from numpy.lib import recfunctions as rfn
+    >>> rfn.merge_arrays((np.array([1, 2]), np.array([10., 20., 30.])))
+    array([( 1, 10.), ( 2, 20.), (-1, 30.)],
+          dtype=[('f0', '>> rfn.merge_arrays((np.array([1, 2], dtype=np.int64),
+    ...         np.array([10., 20., 30.])), usemask=False)
+     array([(1, 10.0), (2, 20.0), (-1, 30.0)],
+             dtype=[('f0', '>> rfn.merge_arrays((np.array([1, 2]).view([('a', np.int64)]),
+    ...               np.array([10., 20., 30.])),
+    ...              usemask=False, asrecarray=True)
+    rec.array([( 1, 10.), ( 2, 20.), (-1, 30.)],
+              dtype=[('a', '>> import numpy as np
+    >>> from numpy.lib import recfunctions as rfn
+    >>> a = np.array([(1, (2, 3.0)), (4, (5, 6.0))],
+    ...   dtype=[('a', np.int64), ('b', [('ba', np.double), ('bb', np.int64)])])
+    >>> rfn.drop_fields(a, 'a')
+    array([((2., 3),), ((5., 6),)],
+          dtype=[('b', [('ba', '>> rfn.drop_fields(a, 'ba')
+    array([(1, (3,)), (4, (6,))], dtype=[('a', '>> rfn.drop_fields(a, ['ba', 'bb'])
+    array([(1,), (4,)], dtype=[('a', '>> import numpy as np
+    >>> from numpy.lib import recfunctions as rfn
+    >>> a = np.array([(1, (2, [3.0, 30.])), (4, (5, [6.0, 60.]))],
+    ...   dtype=[('a', int),('b', [('ba', float), ('bb', (float, 2))])])
+    >>> rfn.rename_fields(a, {'a':'A', 'bb':'BB'})
+    array([(1, (2., [ 3., 30.])), (4, (5., [ 6., 60.]))],
+          dtype=[('A', ' 1:
+        data = merge_arrays(data, flatten=True, usemask=usemask,
+                            fill_value=fill_value)
+    else:
+        data = data.pop()
+    #
+    output = ma.masked_all(
+        max(len(base), len(data)),
+        dtype=_get_fieldspec(base.dtype) + _get_fieldspec(data.dtype))
+    output = recursive_fill_fields(base, output)
+    output = recursive_fill_fields(data, output)
+    #
+    return _fix_output(output, usemask=usemask, asrecarray=asrecarray)
+
+
+def _rec_append_fields_dispatcher(base, names, data, dtypes=None):
+    yield base
+    yield from data
+
+
+@array_function_dispatch(_rec_append_fields_dispatcher)
+def rec_append_fields(base, names, data, dtypes=None):
+    """
+    Add new fields to an existing array.
+
+    The names of the fields are given with the `names` arguments,
+    the corresponding values with the `data` arguments.
+    If a single field is appended, `names`, `data` and `dtypes` do not have
+    to be lists but just values.
+
+    Parameters
+    ----------
+    base : array
+        Input array to extend.
+    names : string, sequence
+        String or sequence of strings corresponding to the names
+        of the new fields.
+    data : array or sequence of arrays
+        Array or sequence of arrays storing the fields to add to the base.
+    dtypes : sequence of datatypes, optional
+        Datatype or sequence of datatypes.
+        If None, the datatypes are estimated from the `data`.
+
+    See Also
+    --------
+    append_fields
+
+    Returns
+    -------
+    appended_array : np.recarray
+    """
+    return append_fields(base, names, data=data, dtypes=dtypes,
+                         asrecarray=True, usemask=False)
+
+
+def _repack_fields_dispatcher(a, align=None, recurse=None):
+    return (a,)
+
+
+@array_function_dispatch(_repack_fields_dispatcher)
+def repack_fields(a, align=False, recurse=False):
+    """
+    Re-pack the fields of a structured array or dtype in memory.
+
+    The memory layout of structured datatypes allows fields at arbitrary
+    byte offsets. This means the fields can be separated by padding bytes,
+    their offsets can be non-monotonically increasing, and they can overlap.
+
+    This method removes any overlaps and reorders the fields in memory so they
+    have increasing byte offsets, and adds or removes padding bytes depending
+    on the `align` option, which behaves like the `align` option to
+    `numpy.dtype`.
+
+    If `align=False`, this method produces a "packed" memory layout in which
+    each field starts at the byte the previous field ended, and any padding
+    bytes are removed.
+
+    If `align=True`, this methods produces an "aligned" memory layout in which
+    each field's offset is a multiple of its alignment, and the total itemsize
+    is a multiple of the largest alignment, by adding padding bytes as needed.
+
+    Parameters
+    ----------
+    a : ndarray or dtype
+       array or dtype for which to repack the fields.
+    align : boolean
+       If true, use an "aligned" memory layout, otherwise use a "packed" layout.
+    recurse : boolean
+       If True, also repack nested structures.
+
+    Returns
+    -------
+    repacked : ndarray or dtype
+       Copy of `a` with fields repacked, or `a` itself if no repacking was
+       needed.
+
+    Examples
+    --------
+    >>> import numpy as np
+
+    >>> from numpy.lib import recfunctions as rfn
+    >>> def print_offsets(d):
+    ...     print("offsets:", [d.fields[name][1] for name in d.names])
+    ...     print("itemsize:", d.itemsize)
+    ...
+    >>> dt = np.dtype('u1, >> dt
+    dtype({'names': ['f0', 'f1', 'f2'], 'formats': ['u1', '>> print_offsets(dt)
+    offsets: [0, 8, 16]
+    itemsize: 24
+    >>> packed_dt = rfn.repack_fields(dt)
+    >>> packed_dt
+    dtype([('f0', 'u1'), ('f1', '>> print_offsets(packed_dt)
+    offsets: [0, 1, 9]
+    itemsize: 17
+
+    """
+    if not isinstance(a, np.dtype):
+        dt = repack_fields(a.dtype, align=align, recurse=recurse)
+        return a.astype(dt, copy=False)
+
+    if a.names is None:
+        return a
+
+    fieldinfo = []
+    for name in a.names:
+        tup = a.fields[name]
+        if recurse:
+            fmt = repack_fields(tup[0], align=align, recurse=True)
+        else:
+            fmt = tup[0]
+
+        if len(tup) == 3:
+            name = (tup[2], name)
+
+        fieldinfo.append((name, fmt))
+
+    dt = np.dtype(fieldinfo, align=align)
+    return np.dtype((a.type, dt))
+
+def _get_fields_and_offsets(dt, offset=0):
+    """
+    Returns a flat list of (dtype, count, offset) tuples of all the
+    scalar fields in the dtype "dt", including nested fields, in left
+    to right order.
+    """
+
+    # counts up elements in subarrays, including nested subarrays, and returns
+    # base dtype and count
+    def count_elem(dt):
+        count = 1
+        while dt.shape != ():
+            for size in dt.shape:
+                count *= size
+            dt = dt.base
+        return dt, count
+
+    fields = []
+    for name in dt.names:
+        field = dt.fields[name]
+        f_dt, f_offset = field[0], field[1]
+        f_dt, n = count_elem(f_dt)
+
+        if f_dt.names is None:
+            fields.append((np.dtype((f_dt, (n,))), n, f_offset + offset))
+        else:
+            subfields = _get_fields_and_offsets(f_dt, f_offset + offset)
+            size = f_dt.itemsize
+
+            for i in range(n):
+                if i == 0:
+                    # optimization: avoid list comprehension if no subarray
+                    fields.extend(subfields)
+                else:
+                    fields.extend([(d, c, o + i*size) for d, c, o in subfields])
+    return fields
+
+def _common_stride(offsets, counts, itemsize):
+    """
+    Returns the stride between the fields, or None if the stride is not
+    constant. The values in "counts" designate the lengths of
+    subarrays. Subarrays are treated as many contiguous fields, with
+    always positive stride.
+    """
+    if len(offsets) <= 1:
+        return itemsize
+
+    negative = offsets[1] < offsets[0]  # negative stride
+    if negative:
+        # reverse, so offsets will be ascending
+        it = zip(reversed(offsets), reversed(counts))
+    else:
+        it = zip(offsets, counts)
+
+    prev_offset = None
+    stride = None
+    for offset, count in it:
+        if count != 1:  # subarray: always c-contiguous
+            if negative:
+                return None  # subarrays can never have a negative stride
+            if stride is None:
+                stride = itemsize
+            if stride != itemsize:
+                return None
+            end_offset = offset + (count - 1) * itemsize
+        else:
+            end_offset = offset
+
+        if prev_offset is not None:
+            new_stride = offset - prev_offset
+            if stride is None:
+                stride = new_stride
+            if stride != new_stride:
+                return None
+
+        prev_offset = end_offset
+
+    if negative:
+        return -stride
+    return stride
+
+
+def _structured_to_unstructured_dispatcher(arr, dtype=None, copy=None,
+                                           casting=None):
+    return (arr,)
+
+@array_function_dispatch(_structured_to_unstructured_dispatcher)
+def structured_to_unstructured(arr, dtype=None, copy=False, casting='unsafe'):
+    """
+    Converts an n-D structured array into an (n+1)-D unstructured array.
+
+    The new array will have a new last dimension equal in size to the
+    number of field-elements of the input array. If not supplied, the output
+    datatype is determined from the numpy type promotion rules applied to all
+    the field datatypes.
+
+    Nested fields, as well as each element of any subarray fields, all count
+    as a single field-elements.
+
+    Parameters
+    ----------
+    arr : ndarray
+       Structured array or dtype to convert. Cannot contain object datatype.
+    dtype : dtype, optional
+       The dtype of the output unstructured array.
+    copy : bool, optional
+        If true, always return a copy. If false, a view is returned if
+        possible, such as when the `dtype` and strides of the fields are
+        suitable and the array subtype is one of `numpy.ndarray`,
+        `numpy.recarray` or `numpy.memmap`.
+
+        .. versionchanged:: 1.25.0
+            A view can now be returned if the fields are separated by a
+            uniform stride.
+
+    casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional
+        See casting argument of `numpy.ndarray.astype`. Controls what kind of
+        data casting may occur.
+
+    Returns
+    -------
+    unstructured : ndarray
+       Unstructured array with one more dimension.
+
+    Examples
+    --------
+    >>> import numpy as np
+
+    >>> from numpy.lib import recfunctions as rfn
+    >>> a = np.zeros(4, dtype=[('a', 'i4'), ('b', 'f4,u2'), ('c', 'f4', 2)])
+    >>> a
+    array([(0, (0., 0), [0., 0.]), (0, (0., 0), [0., 0.]),
+           (0, (0., 0), [0., 0.]), (0, (0., 0), [0., 0.])],
+          dtype=[('a', '>> rfn.structured_to_unstructured(a)
+    array([[0., 0., 0., 0., 0.],
+           [0., 0., 0., 0., 0.],
+           [0., 0., 0., 0., 0.],
+           [0., 0., 0., 0., 0.]])
+
+    >>> b = np.array([(1, 2, 5), (4, 5, 7), (7, 8 ,11), (10, 11, 12)],
+    ...              dtype=[('x', 'i4'), ('y', 'f4'), ('z', 'f8')])
+    >>> np.mean(rfn.structured_to_unstructured(b[['x', 'z']]), axis=-1)
+    array([ 3. ,  5.5,  9. , 11. ])
+
+    """
+    if arr.dtype.names is None:
+        raise ValueError('arr must be a structured array')
+
+    fields = _get_fields_and_offsets(arr.dtype)
+    n_fields = len(fields)
+    if n_fields == 0 and dtype is None:
+        raise ValueError("arr has no fields. Unable to guess dtype")
+    elif n_fields == 0:
+        # too many bugs elsewhere for this to work now
+        raise NotImplementedError("arr with no fields is not supported")
+
+    dts, counts, offsets = zip(*fields)
+    names = ['f{}'.format(n) for n in range(n_fields)]
+
+    if dtype is None:
+        out_dtype = np.result_type(*[dt.base for dt in dts])
+    else:
+        out_dtype = np.dtype(dtype)
+
+    # Use a series of views and casts to convert to an unstructured array:
+
+    # first view using flattened fields (doesn't work for object arrays)
+    # Note: dts may include a shape for subarrays
+    flattened_fields = np.dtype({'names': names,
+                                 'formats': dts,
+                                 'offsets': offsets,
+                                 'itemsize': arr.dtype.itemsize})
+    arr = arr.view(flattened_fields)
+
+    # we only allow a few types to be unstructured by manipulating the
+    # strides, because we know it won't work with, for example, np.matrix nor
+    # np.ma.MaskedArray.
+    can_view = type(arr) in (np.ndarray, np.recarray, np.memmap)
+    if (not copy) and can_view and all(dt.base == out_dtype for dt in dts):
+        # all elements have the right dtype already; if they have a common
+        # stride, we can just return a view
+        common_stride = _common_stride(offsets, counts, out_dtype.itemsize)
+        if common_stride is not None:
+            wrap = arr.__array_wrap__
+
+            new_shape = arr.shape + (sum(counts), out_dtype.itemsize)
+            new_strides = arr.strides + (abs(common_stride), 1)
+
+            arr = arr[..., np.newaxis].view(np.uint8)  # view as bytes
+            arr = arr[..., min(offsets):]  # remove the leading unused data
+            arr = np.lib.stride_tricks.as_strided(arr,
+                                                  new_shape,
+                                                  new_strides,
+                                                  subok=True)
+
+            # cast and drop the last dimension again
+            arr = arr.view(out_dtype)[..., 0]
+
+            if common_stride < 0:
+                arr = arr[..., ::-1]  # reverse, if the stride was negative
+            if type(arr) is not type(wrap.__self__):
+                # Some types (e.g. recarray) turn into an ndarray along the
+                # way, so we have to wrap it again in order to match the
+                # behavior with copy=True.
+                arr = wrap(arr)
+            return arr
+
+    # next cast to a packed format with all fields converted to new dtype
+    packed_fields = np.dtype({'names': names,
+                              'formats': [(out_dtype, dt.shape) for dt in dts]})
+    arr = arr.astype(packed_fields, copy=copy, casting=casting)
+
+    # finally is it safe to view the packed fields as the unstructured type
+    return arr.view((out_dtype, (sum(counts),)))
+
+
+def _unstructured_to_structured_dispatcher(arr, dtype=None, names=None,
+                                           align=None, copy=None, casting=None):
+    return (arr,)
+
+@array_function_dispatch(_unstructured_to_structured_dispatcher)
+def unstructured_to_structured(arr, dtype=None, names=None, align=False,
+                               copy=False, casting='unsafe'):
+    """
+    Converts an n-D unstructured array into an (n-1)-D structured array.
+
+    The last dimension of the input array is converted into a structure, with
+    number of field-elements equal to the size of the last dimension of the
+    input array. By default all output fields have the input array's dtype, but
+    an output structured dtype with an equal number of fields-elements can be
+    supplied instead.
+
+    Nested fields, as well as each element of any subarray fields, all count
+    towards the number of field-elements.
+
+    Parameters
+    ----------
+    arr : ndarray
+       Unstructured array or dtype to convert.
+    dtype : dtype, optional
+       The structured dtype of the output array
+    names : list of strings, optional
+       If dtype is not supplied, this specifies the field names for the output
+       dtype, in order. The field dtypes will be the same as the input array.
+    align : boolean, optional
+       Whether to create an aligned memory layout.
+    copy : bool, optional
+        See copy argument to `numpy.ndarray.astype`. If true, always return a
+        copy. If false, and `dtype` requirements are satisfied, a view is
+        returned.
+    casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional
+        See casting argument of `numpy.ndarray.astype`. Controls what kind of
+        data casting may occur.
+
+    Returns
+    -------
+    structured : ndarray
+       Structured array with fewer dimensions.
+
+    Examples
+    --------
+    >>> import numpy as np
+
+    >>> from numpy.lib import recfunctions as rfn
+    >>> dt = np.dtype([('a', 'i4'), ('b', 'f4,u2'), ('c', 'f4', 2)])
+    >>> a = np.arange(20).reshape((4,5))
+    >>> a
+    array([[ 0,  1,  2,  3,  4],
+           [ 5,  6,  7,  8,  9],
+           [10, 11, 12, 13, 14],
+           [15, 16, 17, 18, 19]])
+    >>> rfn.unstructured_to_structured(a, dt)
+    array([( 0, ( 1.,  2), [ 3.,  4.]), ( 5, ( 6.,  7), [ 8.,  9.]),
+           (10, (11., 12), [13., 14.]), (15, (16., 17), [18., 19.])],
+          dtype=[('a', '>> import numpy as np
+
+    >>> from numpy.lib import recfunctions as rfn
+    >>> b = np.array([(1, 2, 5), (4, 5, 7), (7, 8 ,11), (10, 11, 12)],
+    ...              dtype=[('x', 'i4'), ('y', 'f4'), ('z', 'f8')])
+    >>> rfn.apply_along_fields(np.mean, b)
+    array([ 2.66666667,  5.33333333,  8.66666667, 11.        ])
+    >>> rfn.apply_along_fields(np.mean, b[['x', 'z']])
+    array([ 3. ,  5.5,  9. , 11. ])
+
+    """
+    if arr.dtype.names is None:
+        raise ValueError('arr must be a structured array')
+
+    uarr = structured_to_unstructured(arr)
+    return func(uarr, axis=-1)
+    # works and avoids axis requirement, but very, very slow:
+    #return np.apply_along_axis(func, -1, uarr)
+
+def _assign_fields_by_name_dispatcher(dst, src, zero_unassigned=None):
+    return dst, src
+
+@array_function_dispatch(_assign_fields_by_name_dispatcher)
+def assign_fields_by_name(dst, src, zero_unassigned=True):
+    """
+    Assigns values from one structured array to another by field name.
+
+    Normally in numpy >= 1.14, assignment of one structured array to another
+    copies fields "by position", meaning that the first field from the src is
+    copied to the first field of the dst, and so on, regardless of field name.
+
+    This function instead copies "by field name", such that fields in the dst
+    are assigned from the identically named field in the src. This applies
+    recursively for nested structures. This is how structure assignment worked
+    in numpy >= 1.6 to <= 1.13.
+
+    Parameters
+    ----------
+    dst : ndarray
+    src : ndarray
+        The source and destination arrays during assignment.
+    zero_unassigned : bool, optional
+        If True, fields in the dst for which there was no matching
+        field in the src are filled with the value 0 (zero). This
+        was the behavior of numpy <= 1.13. If False, those fields
+        are not modified.
+    """
+
+    if dst.dtype.names is None:
+        dst[...] = src
+        return
+
+    for name in dst.dtype.names:
+        if name not in src.dtype.names:
+            if zero_unassigned:
+                dst[name] = 0
+        else:
+            assign_fields_by_name(dst[name], src[name],
+                                  zero_unassigned)
+
+def _require_fields_dispatcher(array, required_dtype):
+    return (array,)
+
+@array_function_dispatch(_require_fields_dispatcher)
+def require_fields(array, required_dtype):
+    """
+    Casts a structured array to a new dtype using assignment by field-name.
+
+    This function assigns from the old to the new array by name, so the
+    value of a field in the output array is the value of the field with the
+    same name in the source array. This has the effect of creating a new
+    ndarray containing only the fields "required" by the required_dtype.
+
+    If a field name in the required_dtype does not exist in the
+    input array, that field is created and set to 0 in the output array.
+
+    Parameters
+    ----------
+    a : ndarray
+       array to cast
+    required_dtype : dtype
+       datatype for output array
+
+    Returns
+    -------
+    out : ndarray
+        array with the new dtype, with field values copied from the fields in
+        the input array with the same name
+
+    Examples
+    --------
+    >>> import numpy as np
+
+    >>> from numpy.lib import recfunctions as rfn
+    >>> a = np.ones(4, dtype=[('a', 'i4'), ('b', 'f8'), ('c', 'u1')])
+    >>> rfn.require_fields(a, [('b', 'f4'), ('c', 'u1')])
+    array([(1., 1), (1., 1), (1., 1), (1., 1)],
+      dtype=[('b', '>> rfn.require_fields(a, [('b', 'f4'), ('newf', 'u1')])
+    array([(1., 0), (1., 0), (1., 0), (1., 0)],
+      dtype=[('b', '>> import numpy as np
+    >>> from numpy.lib import recfunctions as rfn
+    >>> x = np.array([1, 2,])
+    >>> rfn.stack_arrays(x) is x
+    True
+    >>> z = np.array([('A', 1), ('B', 2)], dtype=[('A', '|S3'), ('B', float)])
+    >>> zz = np.array([('a', 10., 100.), ('b', 20., 200.), ('c', 30., 300.)],
+    ...   dtype=[('A', '|S3'), ('B', np.double), ('C', np.double)])
+    >>> test = rfn.stack_arrays((z,zz))
+    >>> test
+    masked_array(data=[(b'A', 1.0, --), (b'B', 2.0, --), (b'a', 10.0, 100.0),
+                       (b'b', 20.0, 200.0), (b'c', 30.0, 300.0)],
+                 mask=[(False, False,  True), (False, False,  True),
+                       (False, False, False), (False, False, False),
+                       (False, False, False)],
+           fill_value=(b'N/A', 1e+20, 1e+20),
+                dtype=[('A', 'S3'), ('B', ' '%s'" %
+                                    (cdtype, fdtype))
+    # Only one field: use concatenate
+    if len(newdescr) == 1:
+        output = ma.concatenate(seqarrays)
+    else:
+        #
+        output = ma.masked_all((np.sum(nrecords),), newdescr)
+        offset = np.cumsum(np.r_[0, nrecords])
+        seen = []
+        for (a, n, i, j) in zip(seqarrays, fldnames, offset[:-1], offset[1:]):
+            names = a.dtype.names
+            if names is None:
+                output['f%i' % len(seen)][i:j] = a
+            else:
+                for name in n:
+                    output[name][i:j] = a[name]
+                    if name not in seen:
+                        seen.append(name)
+    #
+    return _fix_output(_fix_defaults(output, defaults),
+                       usemask=usemask, asrecarray=asrecarray)
+
+
+def _find_duplicates_dispatcher(
+        a, key=None, ignoremask=None, return_index=None):
+    return (a,)
+
+
+@array_function_dispatch(_find_duplicates_dispatcher)
+def find_duplicates(a, key=None, ignoremask=True, return_index=False):
+    """
+    Find the duplicates in a structured array along a given key
+
+    Parameters
+    ----------
+    a : array-like
+        Input array
+    key : {string, None}, optional
+        Name of the fields along which to check the duplicates.
+        If None, the search is performed by records
+    ignoremask : {True, False}, optional
+        Whether masked data should be discarded or considered as duplicates.
+    return_index : {False, True}, optional
+        Whether to return the indices of the duplicated values.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from numpy.lib import recfunctions as rfn
+    >>> ndtype = [('a', int)]
+    >>> a = np.ma.array([1, 1, 1, 2, 2, 3, 3],
+    ...         mask=[0, 0, 1, 0, 0, 0, 1]).view(ndtype)
+    >>> rfn.find_duplicates(a, ignoremask=True, return_index=True)
+    (masked_array(data=[(1,), (1,), (2,), (2,)],
+                 mask=[(False,), (False,), (False,), (False,)],
+           fill_value=(999999,),
+                dtype=[('a', '= nb1)] - nb1
+    (r1cmn, r2cmn) = (len(idx_1), len(idx_2))
+    if jointype == 'inner':
+        (r1spc, r2spc) = (0, 0)
+    elif jointype == 'outer':
+        idx_out = idx_sort[~flag_in]
+        idx_1 = np.concatenate((idx_1, idx_out[(idx_out < nb1)]))
+        idx_2 = np.concatenate((idx_2, idx_out[(idx_out >= nb1)] - nb1))
+        (r1spc, r2spc) = (len(idx_1) - r1cmn, len(idx_2) - r2cmn)
+    elif jointype == 'leftouter':
+        idx_out = idx_sort[~flag_in]
+        idx_1 = np.concatenate((idx_1, idx_out[(idx_out < nb1)]))
+        (r1spc, r2spc) = (len(idx_1) - r1cmn, 0)
+    # Select the entries from each input
+    (s1, s2) = (r1[idx_1], r2[idx_2])
+    #
+    # Build the new description of the output array .......
+    # Start with the key fields
+    ndtype = _get_fieldspec(r1k.dtype)
+
+    # Add the fields from r1
+    for fname, fdtype in _get_fieldspec(r1.dtype):
+        if fname not in key:
+            ndtype.append((fname, fdtype))
+
+    # Add the fields from r2
+    for fname, fdtype in _get_fieldspec(r2.dtype):
+        # Have we seen the current name already ?
+        # we need to rebuild this list every time
+        names = list(name for name, dtype in ndtype)
+        try:
+            nameidx = names.index(fname)
+        except ValueError:
+            #... we haven't: just add the description to the current list
+            ndtype.append((fname, fdtype))
+        else:
+            # collision
+            _, cdtype = ndtype[nameidx]
+            if fname in key:
+                # The current field is part of the key: take the largest dtype
+                ndtype[nameidx] = (fname, max(fdtype, cdtype))
+            else:
+                # The current field is not part of the key: add the suffixes,
+                # and place the new field adjacent to the old one
+                ndtype[nameidx:nameidx + 1] = [
+                    (fname + r1postfix, cdtype),
+                    (fname + r2postfix, fdtype)
+                ]
+    # Rebuild a dtype from the new fields
+    ndtype = np.dtype(ndtype)
+    # Find the largest nb of common fields :
+    # r1cmn and r2cmn should be equal, but...
+    cmn = max(r1cmn, r2cmn)
+    # Construct an empty array
+    output = ma.masked_all((cmn + r1spc + r2spc,), dtype=ndtype)
+    names = output.dtype.names
+    for f in r1names:
+        selected = s1[f]
+        if f not in names or (f in r2names and not r2postfix and f not in key):
+            f += r1postfix
+        current = output[f]
+        current[:r1cmn] = selected[:r1cmn]
+        if jointype in ('outer', 'leftouter'):
+            current[cmn:cmn + r1spc] = selected[r1cmn:]
+    for f in r2names:
+        selected = s2[f]
+        if f not in names or (f in r1names and not r1postfix and f not in key):
+            f += r2postfix
+        current = output[f]
+        current[:r2cmn] = selected[:r2cmn]
+        if (jointype == 'outer') and r2spc:
+            current[-r2spc:] = selected[r2cmn:]
+    # Sort and finalize the output
+    output.sort(order=key)
+    kwargs = dict(usemask=usemask, asrecarray=asrecarray)
+    return _fix_output(_fix_defaults(output, defaults), **kwargs)
+
+
+def _rec_join_dispatcher(
+        key, r1, r2, jointype=None, r1postfix=None, r2postfix=None,
+        defaults=None):
+    return (r1, r2)
+
+
+@array_function_dispatch(_rec_join_dispatcher)
+def rec_join(key, r1, r2, jointype='inner', r1postfix='1', r2postfix='2',
+             defaults=None):
+    """
+    Join arrays `r1` and `r2` on keys.
+    Alternative to join_by, that always returns a np.recarray.
+
+    See Also
+    --------
+    join_by : equivalent function
+    """
+    kwargs = dict(jointype=jointype, r1postfix=r1postfix, r2postfix=r2postfix,
+                  defaults=defaults, usemask=False, asrecarray=True)
+    return join_by(key, r1, r2, **kwargs)
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/scimath.py b/venv/lib/python3.12/site-packages/numpy/lib/scimath.py
new file mode 100644
index 00000000..ffd05ef9
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/lib/scimath.py
@@ -0,0 +1,4 @@
+from ._scimath_impl import (
+    __all__, __doc__, sqrt, log, log2, logn, log10, power, arccos, arcsin,
+    arctanh
+)
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/scimath.pyi b/venv/lib/python3.12/site-packages/numpy/lib/scimath.pyi
new file mode 100644
index 00000000..a149cdc3
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/lib/scimath.pyi
@@ -0,0 +1,12 @@
+from ._scimath_impl import (
+    __all__ as __all__,
+    sqrt as sqrt, 
+    log as log, 
+    log2 as log2, 
+    logn as logn, 
+    log10 as log10, 
+    power as power, 
+    arccos as arccos, 
+    arcsin as arcsin, 
+    arctanh as arctanh,
+)
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/stride_tricks.py b/venv/lib/python3.12/site-packages/numpy/lib/stride_tricks.py
new file mode 100644
index 00000000..ba567be0
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/lib/stride_tricks.py
@@ -0,0 +1,3 @@
+from ._stride_tricks_impl import (
+    __doc__, as_strided, sliding_window_view
+)
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/stride_tricks.pyi b/venv/lib/python3.12/site-packages/numpy/lib/stride_tricks.pyi
new file mode 100644
index 00000000..eb46f28a
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/lib/stride_tricks.pyi
@@ -0,0 +1,4 @@
+from numpy.lib._stride_tricks_impl import (
+    as_strided as as_strided,
+    sliding_window_view as sliding_window_view,
+)
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/tests/__init__.py b/venv/lib/python3.12/site-packages/numpy/lib/tests/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/tests/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/lib/tests/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 00000000..8d0390d0
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/lib/tests/__pycache__/__init__.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/tests/__pycache__/test__datasource.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/lib/tests/__pycache__/test__datasource.cpython-312.pyc
new file mode 100644
index 00000000..34be9190
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/lib/tests/__pycache__/test__datasource.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/tests/__pycache__/test__iotools.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/lib/tests/__pycache__/test__iotools.cpython-312.pyc
new file mode 100644
index 00000000..8dc3ee0b
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/lib/tests/__pycache__/test__iotools.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/tests/__pycache__/test__version.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/lib/tests/__pycache__/test__version.cpython-312.pyc
new file mode 100644
index 00000000..15251d39
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/lib/tests/__pycache__/test__version.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/tests/__pycache__/test_array_utils.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/lib/tests/__pycache__/test_array_utils.cpython-312.pyc
new file mode 100644
index 00000000..b804a0a3
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/lib/tests/__pycache__/test_array_utils.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/tests/__pycache__/test_arraypad.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/lib/tests/__pycache__/test_arraypad.cpython-312.pyc
new file mode 100644
index 00000000..b8976319
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/lib/tests/__pycache__/test_arraypad.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/tests/__pycache__/test_arraysetops.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/lib/tests/__pycache__/test_arraysetops.cpython-312.pyc
new file mode 100644
index 00000000..015cfa39
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/lib/tests/__pycache__/test_arraysetops.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/tests/__pycache__/test_arrayterator.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/lib/tests/__pycache__/test_arrayterator.cpython-312.pyc
new file mode 100644
index 00000000..0e719d85
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/lib/tests/__pycache__/test_arrayterator.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/tests/__pycache__/test_format.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/lib/tests/__pycache__/test_format.cpython-312.pyc
new file mode 100644
index 00000000..a83c497c
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/lib/tests/__pycache__/test_format.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/tests/__pycache__/test_function_base.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/lib/tests/__pycache__/test_function_base.cpython-312.pyc
new file mode 100644
index 00000000..503118fe
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/lib/tests/__pycache__/test_function_base.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/tests/__pycache__/test_histograms.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/lib/tests/__pycache__/test_histograms.cpython-312.pyc
new file mode 100644
index 00000000..9c314fb6
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/lib/tests/__pycache__/test_histograms.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/tests/__pycache__/test_index_tricks.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/lib/tests/__pycache__/test_index_tricks.cpython-312.pyc
new file mode 100644
index 00000000..9b4f3157
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/lib/tests/__pycache__/test_index_tricks.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/tests/__pycache__/test_io.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/lib/tests/__pycache__/test_io.cpython-312.pyc
new file mode 100644
index 00000000..21172348
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/lib/tests/__pycache__/test_io.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/tests/__pycache__/test_loadtxt.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/lib/tests/__pycache__/test_loadtxt.cpython-312.pyc
new file mode 100644
index 00000000..9f97500b
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/lib/tests/__pycache__/test_loadtxt.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/tests/__pycache__/test_mixins.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/lib/tests/__pycache__/test_mixins.cpython-312.pyc
new file mode 100644
index 00000000..578f6cce
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/lib/tests/__pycache__/test_mixins.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/tests/__pycache__/test_nanfunctions.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/lib/tests/__pycache__/test_nanfunctions.cpython-312.pyc
new file mode 100644
index 00000000..b08b2bfb
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/lib/tests/__pycache__/test_nanfunctions.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/tests/__pycache__/test_packbits.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/lib/tests/__pycache__/test_packbits.cpython-312.pyc
new file mode 100644
index 00000000..0632857d
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/lib/tests/__pycache__/test_packbits.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/tests/__pycache__/test_polynomial.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/lib/tests/__pycache__/test_polynomial.cpython-312.pyc
new file mode 100644
index 00000000..ddb19523
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/lib/tests/__pycache__/test_polynomial.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/tests/__pycache__/test_recfunctions.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/lib/tests/__pycache__/test_recfunctions.cpython-312.pyc
new file mode 100644
index 00000000..dd99370b
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/lib/tests/__pycache__/test_recfunctions.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/tests/__pycache__/test_regression.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/lib/tests/__pycache__/test_regression.cpython-312.pyc
new file mode 100644
index 00000000..63479336
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/lib/tests/__pycache__/test_regression.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/tests/__pycache__/test_shape_base.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/lib/tests/__pycache__/test_shape_base.cpython-312.pyc
new file mode 100644
index 00000000..e09942ea
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/lib/tests/__pycache__/test_shape_base.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/tests/__pycache__/test_stride_tricks.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/lib/tests/__pycache__/test_stride_tricks.cpython-312.pyc
new file mode 100644
index 00000000..4b876c36
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/lib/tests/__pycache__/test_stride_tricks.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/tests/__pycache__/test_twodim_base.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/lib/tests/__pycache__/test_twodim_base.cpython-312.pyc
new file mode 100644
index 00000000..591e0872
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/lib/tests/__pycache__/test_twodim_base.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/tests/__pycache__/test_type_check.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/lib/tests/__pycache__/test_type_check.cpython-312.pyc
new file mode 100644
index 00000000..16f8c00a
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/lib/tests/__pycache__/test_type_check.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/tests/__pycache__/test_ufunclike.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/lib/tests/__pycache__/test_ufunclike.cpython-312.pyc
new file mode 100644
index 00000000..d2b2c968
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/lib/tests/__pycache__/test_ufunclike.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/tests/__pycache__/test_utils.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/lib/tests/__pycache__/test_utils.cpython-312.pyc
new file mode 100644
index 00000000..ecd479bf
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/lib/tests/__pycache__/test_utils.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/tests/data/py2-np0-objarr.npy b/venv/lib/python3.12/site-packages/numpy/lib/tests/data/py2-np0-objarr.npy
new file mode 100644
index 00000000..a6e9e239
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/lib/tests/data/py2-np0-objarr.npy differ
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/tests/data/py2-objarr.npy b/venv/lib/python3.12/site-packages/numpy/lib/tests/data/py2-objarr.npy
new file mode 100644
index 00000000..12936c92
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/lib/tests/data/py2-objarr.npy differ
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/tests/data/py2-objarr.npz b/venv/lib/python3.12/site-packages/numpy/lib/tests/data/py2-objarr.npz
new file mode 100644
index 00000000..68a3b53a
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/lib/tests/data/py2-objarr.npz differ
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/tests/data/py3-objarr.npy b/venv/lib/python3.12/site-packages/numpy/lib/tests/data/py3-objarr.npy
new file mode 100644
index 00000000..c9f33b01
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/lib/tests/data/py3-objarr.npy differ
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/tests/data/py3-objarr.npz b/venv/lib/python3.12/site-packages/numpy/lib/tests/data/py3-objarr.npz
new file mode 100644
index 00000000..fd7d9d31
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/lib/tests/data/py3-objarr.npz differ
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/tests/data/python3.npy b/venv/lib/python3.12/site-packages/numpy/lib/tests/data/python3.npy
new file mode 100644
index 00000000..7c6997dd
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/lib/tests/data/python3.npy differ
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/tests/data/win64python2.npy b/venv/lib/python3.12/site-packages/numpy/lib/tests/data/win64python2.npy
new file mode 100644
index 00000000..d9bc36af
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/lib/tests/data/win64python2.npy differ
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/tests/test__datasource.py b/venv/lib/python3.12/site-packages/numpy/lib/tests/test__datasource.py
new file mode 100644
index 00000000..c8149abc
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/lib/tests/test__datasource.py
@@ -0,0 +1,350 @@
+import os
+import pytest
+from tempfile import mkdtemp, mkstemp, NamedTemporaryFile
+from shutil import rmtree
+
+import numpy.lib._datasource as datasource
+from numpy.testing import assert_, assert_equal, assert_raises
+
+import urllib.request as urllib_request
+from urllib.parse import urlparse
+from urllib.error import URLError
+
+
+def urlopen_stub(url, data=None):
+    '''Stub to replace urlopen for testing.'''
+    if url == valid_httpurl():
+        tmpfile = NamedTemporaryFile(prefix='urltmp_')
+        return tmpfile
+    else:
+        raise URLError('Name or service not known')
+
+# setup and teardown
+old_urlopen = None
+
+
+def setup_module():
+    global old_urlopen
+
+    old_urlopen = urllib_request.urlopen
+    urllib_request.urlopen = urlopen_stub
+
+
+def teardown_module():
+    urllib_request.urlopen = old_urlopen
+
+# A valid website for more robust testing
+http_path = 'http://www.google.com/'
+http_file = 'index.html'
+
+http_fakepath = 'http://fake.abc.web/site/'
+http_fakefile = 'fake.txt'
+
+malicious_files = ['/etc/shadow', '../../shadow',
+                   '..\\system.dat', 'c:\\windows\\system.dat']
+
+magic_line = b'three is the magic number'
+
+
+# Utility functions used by many tests
+def valid_textfile(filedir):
+    # Generate and return a valid temporary file.
+    fd, path = mkstemp(suffix='.txt', prefix='dstmp_', dir=filedir, text=True)
+    os.close(fd)
+    return path
+
+
+def invalid_textfile(filedir):
+    # Generate and return an invalid filename.
+    fd, path = mkstemp(suffix='.txt', prefix='dstmp_', dir=filedir)
+    os.close(fd)
+    os.remove(path)
+    return path
+
+
+def valid_httpurl():
+    return http_path+http_file
+
+
+def invalid_httpurl():
+    return http_fakepath+http_fakefile
+
+
+def valid_baseurl():
+    return http_path
+
+
+def invalid_baseurl():
+    return http_fakepath
+
+
+def valid_httpfile():
+    return http_file
+
+
+def invalid_httpfile():
+    return http_fakefile
+
+
+class TestDataSourceOpen:
+    def setup_method(self):
+        self.tmpdir = mkdtemp()
+        self.ds = datasource.DataSource(self.tmpdir)
+
+    def teardown_method(self):
+        rmtree(self.tmpdir)
+        del self.ds
+
+    def test_ValidHTTP(self):
+        fh = self.ds.open(valid_httpurl())
+        assert_(fh)
+        fh.close()
+
+    def test_InvalidHTTP(self):
+        url = invalid_httpurl()
+        assert_raises(OSError, self.ds.open, url)
+        try:
+            self.ds.open(url)
+        except OSError as e:
+            # Regression test for bug fixed in r4342.
+            assert_(e.errno is None)
+
+    def test_InvalidHTTPCacheURLError(self):
+        assert_raises(URLError, self.ds._cache, invalid_httpurl())
+
+    def test_ValidFile(self):
+        local_file = valid_textfile(self.tmpdir)
+        fh = self.ds.open(local_file)
+        assert_(fh)
+        fh.close()
+
+    def test_InvalidFile(self):
+        invalid_file = invalid_textfile(self.tmpdir)
+        assert_raises(OSError, self.ds.open, invalid_file)
+
+    def test_ValidGzipFile(self):
+        try:
+            import gzip
+        except ImportError:
+            # We don't have the gzip capabilities to test.
+            pytest.skip()
+        # Test datasource's internal file_opener for Gzip files.
+        filepath = os.path.join(self.tmpdir, 'foobar.txt.gz')
+        fp = gzip.open(filepath, 'w')
+        fp.write(magic_line)
+        fp.close()
+        fp = self.ds.open(filepath)
+        result = fp.readline()
+        fp.close()
+        assert_equal(magic_line, result)
+
+    def test_ValidBz2File(self):
+        try:
+            import bz2
+        except ImportError:
+            # We don't have the bz2 capabilities to test.
+            pytest.skip()
+        # Test datasource's internal file_opener for BZip2 files.
+        filepath = os.path.join(self.tmpdir, 'foobar.txt.bz2')
+        fp = bz2.BZ2File(filepath, 'w')
+        fp.write(magic_line)
+        fp.close()
+        fp = self.ds.open(filepath)
+        result = fp.readline()
+        fp.close()
+        assert_equal(magic_line, result)
+
+
+class TestDataSourceExists:
+    def setup_method(self):
+        self.tmpdir = mkdtemp()
+        self.ds = datasource.DataSource(self.tmpdir)
+
+    def teardown_method(self):
+        rmtree(self.tmpdir)
+        del self.ds
+
+    def test_ValidHTTP(self):
+        assert_(self.ds.exists(valid_httpurl()))
+
+    def test_InvalidHTTP(self):
+        assert_equal(self.ds.exists(invalid_httpurl()), False)
+
+    def test_ValidFile(self):
+        # Test valid file in destpath
+        tmpfile = valid_textfile(self.tmpdir)
+        assert_(self.ds.exists(tmpfile))
+        # Test valid local file not in destpath
+        localdir = mkdtemp()
+        tmpfile = valid_textfile(localdir)
+        assert_(self.ds.exists(tmpfile))
+        rmtree(localdir)
+
+    def test_InvalidFile(self):
+        tmpfile = invalid_textfile(self.tmpdir)
+        assert_equal(self.ds.exists(tmpfile), False)
+
+
+class TestDataSourceAbspath:
+    def setup_method(self):
+        self.tmpdir = os.path.abspath(mkdtemp())
+        self.ds = datasource.DataSource(self.tmpdir)
+
+    def teardown_method(self):
+        rmtree(self.tmpdir)
+        del self.ds
+
+    def test_ValidHTTP(self):
+        scheme, netloc, upath, pms, qry, frg = urlparse(valid_httpurl())
+        local_path = os.path.join(self.tmpdir, netloc,
+                                  upath.strip(os.sep).strip('/'))
+        assert_equal(local_path, self.ds.abspath(valid_httpurl()))
+
+    def test_ValidFile(self):
+        tmpfile = valid_textfile(self.tmpdir)
+        tmpfilename = os.path.split(tmpfile)[-1]
+        # Test with filename only
+        assert_equal(tmpfile, self.ds.abspath(tmpfilename))
+        # Test filename with complete path
+        assert_equal(tmpfile, self.ds.abspath(tmpfile))
+
+    def test_InvalidHTTP(self):
+        scheme, netloc, upath, pms, qry, frg = urlparse(invalid_httpurl())
+        invalidhttp = os.path.join(self.tmpdir, netloc,
+                                   upath.strip(os.sep).strip('/'))
+        assert_(invalidhttp != self.ds.abspath(valid_httpurl()))
+
+    def test_InvalidFile(self):
+        invalidfile = valid_textfile(self.tmpdir)
+        tmpfile = valid_textfile(self.tmpdir)
+        tmpfilename = os.path.split(tmpfile)[-1]
+        # Test with filename only
+        assert_(invalidfile != self.ds.abspath(tmpfilename))
+        # Test filename with complete path
+        assert_(invalidfile != self.ds.abspath(tmpfile))
+
+    def test_sandboxing(self):
+        tmpfile = valid_textfile(self.tmpdir)
+        tmpfilename = os.path.split(tmpfile)[-1]
+
+        tmp_path = lambda x: os.path.abspath(self.ds.abspath(x))
+
+        assert_(tmp_path(valid_httpurl()).startswith(self.tmpdir))
+        assert_(tmp_path(invalid_httpurl()).startswith(self.tmpdir))
+        assert_(tmp_path(tmpfile).startswith(self.tmpdir))
+        assert_(tmp_path(tmpfilename).startswith(self.tmpdir))
+        for fn in malicious_files:
+            assert_(tmp_path(http_path+fn).startswith(self.tmpdir))
+            assert_(tmp_path(fn).startswith(self.tmpdir))
+
+    def test_windows_os_sep(self):
+        orig_os_sep = os.sep
+        try:
+            os.sep = '\\'
+            self.test_ValidHTTP()
+            self.test_ValidFile()
+            self.test_InvalidHTTP()
+            self.test_InvalidFile()
+            self.test_sandboxing()
+        finally:
+            os.sep = orig_os_sep
+
+
+class TestRepositoryAbspath:
+    def setup_method(self):
+        self.tmpdir = os.path.abspath(mkdtemp())
+        self.repos = datasource.Repository(valid_baseurl(), self.tmpdir)
+
+    def teardown_method(self):
+        rmtree(self.tmpdir)
+        del self.repos
+
+    def test_ValidHTTP(self):
+        scheme, netloc, upath, pms, qry, frg = urlparse(valid_httpurl())
+        local_path = os.path.join(self.repos._destpath, netloc,
+                                  upath.strip(os.sep).strip('/'))
+        filepath = self.repos.abspath(valid_httpfile())
+        assert_equal(local_path, filepath)
+
+    def test_sandboxing(self):
+        tmp_path = lambda x: os.path.abspath(self.repos.abspath(x))
+        assert_(tmp_path(valid_httpfile()).startswith(self.tmpdir))
+        for fn in malicious_files:
+            assert_(tmp_path(http_path+fn).startswith(self.tmpdir))
+            assert_(tmp_path(fn).startswith(self.tmpdir))
+
+    def test_windows_os_sep(self):
+        orig_os_sep = os.sep
+        try:
+            os.sep = '\\'
+            self.test_ValidHTTP()
+            self.test_sandboxing()
+        finally:
+            os.sep = orig_os_sep
+
+
+class TestRepositoryExists:
+    def setup_method(self):
+        self.tmpdir = mkdtemp()
+        self.repos = datasource.Repository(valid_baseurl(), self.tmpdir)
+
+    def teardown_method(self):
+        rmtree(self.tmpdir)
+        del self.repos
+
+    def test_ValidFile(self):
+        # Create local temp file
+        tmpfile = valid_textfile(self.tmpdir)
+        assert_(self.repos.exists(tmpfile))
+
+    def test_InvalidFile(self):
+        tmpfile = invalid_textfile(self.tmpdir)
+        assert_equal(self.repos.exists(tmpfile), False)
+
+    def test_RemoveHTTPFile(self):
+        assert_(self.repos.exists(valid_httpurl()))
+
+    def test_CachedHTTPFile(self):
+        localfile = valid_httpurl()
+        # Create a locally cached temp file with an URL based
+        # directory structure.  This is similar to what Repository.open
+        # would do.
+        scheme, netloc, upath, pms, qry, frg = urlparse(localfile)
+        local_path = os.path.join(self.repos._destpath, netloc)
+        os.mkdir(local_path, 0o0700)
+        tmpfile = valid_textfile(local_path)
+        assert_(self.repos.exists(tmpfile))
+
+
+class TestOpenFunc:
+    def setup_method(self):
+        self.tmpdir = mkdtemp()
+
+    def teardown_method(self):
+        rmtree(self.tmpdir)
+
+    def test_DataSourceOpen(self):
+        local_file = valid_textfile(self.tmpdir)
+        # Test case where destpath is passed in
+        fp = datasource.open(local_file, destpath=self.tmpdir)
+        assert_(fp)
+        fp.close()
+        # Test case where default destpath is used
+        fp = datasource.open(local_file)
+        assert_(fp)
+        fp.close()
+
+def test_del_attr_handling():
+    # DataSource __del__ can be called
+    # even if __init__ fails when the
+    # Exception object is caught by the
+    # caller as happens in refguide_check
+    # is_deprecated() function
+
+    ds = datasource.DataSource()
+    # simulate failed __init__ by removing key attribute
+    # produced within __init__ and expected by __del__
+    del ds._istmpdest
+    # should not raise an AttributeError if __del__
+    # gracefully handles failed __init__:
+    ds.__del__()
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/tests/test__iotools.py b/venv/lib/python3.12/site-packages/numpy/lib/tests/test__iotools.py
new file mode 100644
index 00000000..396d4147
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/lib/tests/test__iotools.py
@@ -0,0 +1,353 @@
+import time
+from datetime import date
+
+import numpy as np
+from numpy.testing import (
+    assert_, assert_equal, assert_allclose, assert_raises,
+    )
+from numpy.lib._iotools import (
+    LineSplitter, NameValidator, StringConverter,
+    has_nested_fields, easy_dtype, flatten_dtype
+    )
+
+
+class TestLineSplitter:
+    "Tests the LineSplitter class."
+
+    def test_no_delimiter(self):
+        "Test LineSplitter w/o delimiter"
+        strg = " 1 2 3 4  5 # test"
+        test = LineSplitter()(strg)
+        assert_equal(test, ['1', '2', '3', '4', '5'])
+        test = LineSplitter('')(strg)
+        assert_equal(test, ['1', '2', '3', '4', '5'])
+
+    def test_space_delimiter(self):
+        "Test space delimiter"
+        strg = " 1 2 3 4  5 # test"
+        test = LineSplitter(' ')(strg)
+        assert_equal(test, ['1', '2', '3', '4', '', '5'])
+        test = LineSplitter('  ')(strg)
+        assert_equal(test, ['1 2 3 4', '5'])
+
+    def test_tab_delimiter(self):
+        "Test tab delimiter"
+        strg = " 1\t 2\t 3\t 4\t 5  6"
+        test = LineSplitter('\t')(strg)
+        assert_equal(test, ['1', '2', '3', '4', '5  6'])
+        strg = " 1  2\t 3  4\t 5  6"
+        test = LineSplitter('\t')(strg)
+        assert_equal(test, ['1  2', '3  4', '5  6'])
+
+    def test_other_delimiter(self):
+        "Test LineSplitter on delimiter"
+        strg = "1,2,3,4,,5"
+        test = LineSplitter(',')(strg)
+        assert_equal(test, ['1', '2', '3', '4', '', '5'])
+        #
+        strg = " 1,2,3,4,,5 # test"
+        test = LineSplitter(',')(strg)
+        assert_equal(test, ['1', '2', '3', '4', '', '5'])
+
+        # gh-11028 bytes comment/delimiters should get encoded
+        strg = b" 1,2,3,4,,5 % test"
+        test = LineSplitter(delimiter=b',', comments=b'%')(strg)
+        assert_equal(test, ['1', '2', '3', '4', '', '5'])
+
+    def test_constant_fixed_width(self):
+        "Test LineSplitter w/ fixed-width fields"
+        strg = "  1  2  3  4     5   # test"
+        test = LineSplitter(3)(strg)
+        assert_equal(test, ['1', '2', '3', '4', '', '5', ''])
+        #
+        strg = "  1     3  4  5  6# test"
+        test = LineSplitter(20)(strg)
+        assert_equal(test, ['1     3  4  5  6'])
+        #
+        strg = "  1     3  4  5  6# test"
+        test = LineSplitter(30)(strg)
+        assert_equal(test, ['1     3  4  5  6'])
+
+    def test_variable_fixed_width(self):
+        strg = "  1     3  4  5  6# test"
+        test = LineSplitter((3, 6, 6, 3))(strg)
+        assert_equal(test, ['1', '3', '4  5', '6'])
+        #
+        strg = "  1     3  4  5  6# test"
+        test = LineSplitter((6, 6, 9))(strg)
+        assert_equal(test, ['1', '3  4', '5  6'])
+
+# -----------------------------------------------------------------------------
+
+
+class TestNameValidator:
+
+    def test_case_sensitivity(self):
+        "Test case sensitivity"
+        names = ['A', 'a', 'b', 'c']
+        test = NameValidator().validate(names)
+        assert_equal(test, ['A', 'a', 'b', 'c'])
+        test = NameValidator(case_sensitive=False).validate(names)
+        assert_equal(test, ['A', 'A_1', 'B', 'C'])
+        test = NameValidator(case_sensitive='upper').validate(names)
+        assert_equal(test, ['A', 'A_1', 'B', 'C'])
+        test = NameValidator(case_sensitive='lower').validate(names)
+        assert_equal(test, ['a', 'a_1', 'b', 'c'])
+
+        # check exceptions
+        assert_raises(ValueError, NameValidator, case_sensitive='foobar')
+
+    def test_excludelist(self):
+        "Test excludelist"
+        names = ['dates', 'data', 'Other Data', 'mask']
+        validator = NameValidator(excludelist=['dates', 'data', 'mask'])
+        test = validator.validate(names)
+        assert_equal(test, ['dates_', 'data_', 'Other_Data', 'mask_'])
+
+    def test_missing_names(self):
+        "Test validate missing names"
+        namelist = ('a', 'b', 'c')
+        validator = NameValidator()
+        assert_equal(validator(namelist), ['a', 'b', 'c'])
+        namelist = ('', 'b', 'c')
+        assert_equal(validator(namelist), ['f0', 'b', 'c'])
+        namelist = ('a', 'b', '')
+        assert_equal(validator(namelist), ['a', 'b', 'f0'])
+        namelist = ('', 'f0', '')
+        assert_equal(validator(namelist), ['f1', 'f0', 'f2'])
+
+    def test_validate_nb_names(self):
+        "Test validate nb names"
+        namelist = ('a', 'b', 'c')
+        validator = NameValidator()
+        assert_equal(validator(namelist, nbfields=1), ('a',))
+        assert_equal(validator(namelist, nbfields=5, defaultfmt="g%i"),
+                     ['a', 'b', 'c', 'g0', 'g1'])
+
+    def test_validate_wo_names(self):
+        "Test validate no names"
+        namelist = None
+        validator = NameValidator()
+        assert_(validator(namelist) is None)
+        assert_equal(validator(namelist, nbfields=3), ['f0', 'f1', 'f2'])
+
+# -----------------------------------------------------------------------------
+
+
+def _bytes_to_date(s):
+    return date(*time.strptime(s, "%Y-%m-%d")[:3])
+
+
+class TestStringConverter:
+    "Test StringConverter"
+
+    def test_creation(self):
+        "Test creation of a StringConverter"
+        converter = StringConverter(int, -99999)
+        assert_equal(converter._status, 1)
+        assert_equal(converter.default, -99999)
+
+    def test_upgrade(self):
+        "Tests the upgrade method."
+
+        converter = StringConverter()
+        assert_equal(converter._status, 0)
+
+        # test int
+        assert_equal(converter.upgrade('0'), 0)
+        assert_equal(converter._status, 1)
+
+        # On systems where long defaults to 32-bit, the statuses will be
+        # offset by one, so we check for this here.
+        import numpy._core.numeric as nx
+        status_offset = int(nx.dtype(nx.int_).itemsize < nx.dtype(nx.int64).itemsize)
+
+        # test int > 2**32
+        assert_equal(converter.upgrade('17179869184'), 17179869184)
+        assert_equal(converter._status, 1 + status_offset)
+
+        # test float
+        assert_allclose(converter.upgrade('0.'), 0.0)
+        assert_equal(converter._status, 2 + status_offset)
+
+        # test complex
+        assert_equal(converter.upgrade('0j'), complex('0j'))
+        assert_equal(converter._status, 3 + status_offset)
+
+        # test str
+        # note that the longdouble type has been skipped, so the
+        # _status increases by 2. Everything should succeed with
+        # unicode conversion (8).
+        for s in ['a', b'a']:
+            res = converter.upgrade(s)
+            assert_(type(res) is str)
+            assert_equal(res, 'a')
+            assert_equal(converter._status, 8 + status_offset)
+
+    def test_missing(self):
+        "Tests the use of missing values."
+        converter = StringConverter(missing_values=('missing',
+                                                    'missed'))
+        converter.upgrade('0')
+        assert_equal(converter('0'), 0)
+        assert_equal(converter(''), converter.default)
+        assert_equal(converter('missing'), converter.default)
+        assert_equal(converter('missed'), converter.default)
+        try:
+            converter('miss')
+        except ValueError:
+            pass
+
+    def test_upgrademapper(self):
+        "Tests updatemapper"
+        dateparser = _bytes_to_date
+        _original_mapper = StringConverter._mapper[:]
+        try:
+            StringConverter.upgrade_mapper(dateparser, date(2000, 1, 1))
+            convert = StringConverter(dateparser, date(2000, 1, 1))
+            test = convert('2001-01-01')
+            assert_equal(test, date(2001, 1, 1))
+            test = convert('2009-01-01')
+            assert_equal(test, date(2009, 1, 1))
+            test = convert('')
+            assert_equal(test, date(2000, 1, 1))
+        finally:
+            StringConverter._mapper = _original_mapper
+
+    def test_string_to_object(self):
+        "Make sure that string-to-object functions are properly recognized"
+        old_mapper = StringConverter._mapper[:]  # copy of list
+        conv = StringConverter(_bytes_to_date)
+        assert_equal(conv._mapper, old_mapper)
+        assert_(hasattr(conv, 'default'))
+
+    def test_keep_default(self):
+        "Make sure we don't lose an explicit default"
+        converter = StringConverter(None, missing_values='',
+                                    default=-999)
+        converter.upgrade('3.14159265')
+        assert_equal(converter.default, -999)
+        assert_equal(converter.type, np.dtype(float))
+        #
+        converter = StringConverter(
+            None, missing_values='', default=0)
+        converter.upgrade('3.14159265')
+        assert_equal(converter.default, 0)
+        assert_equal(converter.type, np.dtype(float))
+
+    def test_keep_default_zero(self):
+        "Check that we don't lose a default of 0"
+        converter = StringConverter(int, default=0,
+                                    missing_values="N/A")
+        assert_equal(converter.default, 0)
+
+    def test_keep_missing_values(self):
+        "Check that we're not losing missing values"
+        converter = StringConverter(int, default=0,
+                                    missing_values="N/A")
+        assert_equal(
+            converter.missing_values, {'', 'N/A'})
+
+    def test_int64_dtype(self):
+        "Check that int64 integer types can be specified"
+        converter = StringConverter(np.int64, default=0)
+        val = "-9223372036854775807"
+        assert_(converter(val) == -9223372036854775807)
+        val = "9223372036854775807"
+        assert_(converter(val) == 9223372036854775807)
+
+    def test_uint64_dtype(self):
+        "Check that uint64 integer types can be specified"
+        converter = StringConverter(np.uint64, default=0)
+        val = "9223372043271415339"
+        assert_(converter(val) == 9223372043271415339)
+
+
+class TestMiscFunctions:
+
+    def test_has_nested_dtype(self):
+        "Test has_nested_dtype"
+        ndtype = np.dtype(float)
+        assert_equal(has_nested_fields(ndtype), False)
+        ndtype = np.dtype([('A', '|S3'), ('B', float)])
+        assert_equal(has_nested_fields(ndtype), False)
+        ndtype = np.dtype([('A', int), ('B', [('BA', float), ('BB', '|S1')])])
+        assert_equal(has_nested_fields(ndtype), True)
+
+    def test_easy_dtype(self):
+        "Test ndtype on dtypes"
+        # Simple case
+        ndtype = float
+        assert_equal(easy_dtype(ndtype), np.dtype(float))
+        # As string w/o names
+        ndtype = "i4, f8"
+        assert_equal(easy_dtype(ndtype),
+                     np.dtype([('f0', "i4"), ('f1', "f8")]))
+        # As string w/o names but different default format
+        assert_equal(easy_dtype(ndtype, defaultfmt="field_%03i"),
+                     np.dtype([('field_000', "i4"), ('field_001', "f8")]))
+        # As string w/ names
+        ndtype = "i4, f8"
+        assert_equal(easy_dtype(ndtype, names="a, b"),
+                     np.dtype([('a', "i4"), ('b', "f8")]))
+        # As string w/ names (too many)
+        ndtype = "i4, f8"
+        assert_equal(easy_dtype(ndtype, names="a, b, c"),
+                     np.dtype([('a', "i4"), ('b', "f8")]))
+        # As string w/ names (not enough)
+        ndtype = "i4, f8"
+        assert_equal(easy_dtype(ndtype, names=", b"),
+                     np.dtype([('f0', "i4"), ('b', "f8")]))
+        # ... (with different default format)
+        assert_equal(easy_dtype(ndtype, names="a", defaultfmt="f%02i"),
+                     np.dtype([('a', "i4"), ('f00', "f8")]))
+        # As list of tuples w/o names
+        ndtype = [('A', int), ('B', float)]
+        assert_equal(easy_dtype(ndtype), np.dtype([('A', int), ('B', float)]))
+        # As list of tuples w/ names
+        assert_equal(easy_dtype(ndtype, names="a,b"),
+                     np.dtype([('a', int), ('b', float)]))
+        # As list of tuples w/ not enough names
+        assert_equal(easy_dtype(ndtype, names="a"),
+                     np.dtype([('a', int), ('f0', float)]))
+        # As list of tuples w/ too many names
+        assert_equal(easy_dtype(ndtype, names="a,b,c"),
+                     np.dtype([('a', int), ('b', float)]))
+        # As list of types w/o names
+        ndtype = (int, float, float)
+        assert_equal(easy_dtype(ndtype),
+                     np.dtype([('f0', int), ('f1', float), ('f2', float)]))
+        # As list of types w names
+        ndtype = (int, float, float)
+        assert_equal(easy_dtype(ndtype, names="a, b, c"),
+                     np.dtype([('a', int), ('b', float), ('c', float)]))
+        # As simple dtype w/ names
+        ndtype = np.dtype(float)
+        assert_equal(easy_dtype(ndtype, names="a, b, c"),
+                     np.dtype([(_, float) for _ in ('a', 'b', 'c')]))
+        # As simple dtype w/o names (but multiple fields)
+        ndtype = np.dtype(float)
+        assert_equal(
+            easy_dtype(ndtype, names=['', '', ''], defaultfmt="f%02i"),
+            np.dtype([(_, float) for _ in ('f00', 'f01', 'f02')]))
+
+    def test_flatten_dtype(self):
+        "Testing flatten_dtype"
+        # Standard dtype
+        dt = np.dtype([("a", "f8"), ("b", "f8")])
+        dt_flat = flatten_dtype(dt)
+        assert_equal(dt_flat, [float, float])
+        # Recursive dtype
+        dt = np.dtype([("a", [("aa", '|S1'), ("ab", '|S2')]), ("b", int)])
+        dt_flat = flatten_dtype(dt)
+        assert_equal(dt_flat, [np.dtype('|S1'), np.dtype('|S2'), int])
+        # dtype with shaped fields
+        dt = np.dtype([("a", (float, 2)), ("b", (int, 3))])
+        dt_flat = flatten_dtype(dt)
+        assert_equal(dt_flat, [float, int])
+        dt_flat = flatten_dtype(dt, True)
+        assert_equal(dt_flat, [float] * 2 + [int] * 3)
+        # dtype w/ titles
+        dt = np.dtype([(("a", "A"), "f8"), (("b", "B"), "f8")])
+        dt_flat = flatten_dtype(dt)
+        assert_equal(dt_flat, [float, float])
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/tests/test__version.py b/venv/lib/python3.12/site-packages/numpy/lib/tests/test__version.py
new file mode 100644
index 00000000..e6d41ad9
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/lib/tests/test__version.py
@@ -0,0 +1,64 @@
+"""Tests for the NumpyVersion class.
+
+"""
+from numpy.testing import assert_, assert_raises
+from numpy.lib import NumpyVersion
+
+
+def test_main_versions():
+    assert_(NumpyVersion('1.8.0') == '1.8.0')
+    for ver in ['1.9.0', '2.0.0', '1.8.1', '10.0.1']:
+        assert_(NumpyVersion('1.8.0') < ver)
+
+    for ver in ['1.7.0', '1.7.1', '0.9.9']:
+        assert_(NumpyVersion('1.8.0') > ver)
+
+
+def test_version_1_point_10():
+    # regression test for gh-2998.
+    assert_(NumpyVersion('1.9.0') < '1.10.0')
+    assert_(NumpyVersion('1.11.0') < '1.11.1')
+    assert_(NumpyVersion('1.11.0') == '1.11.0')
+    assert_(NumpyVersion('1.99.11') < '1.99.12')
+
+
+def test_alpha_beta_rc():
+    assert_(NumpyVersion('1.8.0rc1') == '1.8.0rc1')
+    for ver in ['1.8.0', '1.8.0rc2']:
+        assert_(NumpyVersion('1.8.0rc1') < ver)
+
+    for ver in ['1.8.0a2', '1.8.0b3', '1.7.2rc4']:
+        assert_(NumpyVersion('1.8.0rc1') > ver)
+
+    assert_(NumpyVersion('1.8.0b1') > '1.8.0a2')
+
+
+def test_dev_version():
+    assert_(NumpyVersion('1.9.0.dev-Unknown') < '1.9.0')
+    for ver in ['1.9.0', '1.9.0a1', '1.9.0b2', '1.9.0b2.dev-ffffffff']:
+        assert_(NumpyVersion('1.9.0.dev-f16acvda') < ver)
+
+    assert_(NumpyVersion('1.9.0.dev-f16acvda') == '1.9.0.dev-11111111')
+
+
+def test_dev_a_b_rc_mixed():
+    assert_(NumpyVersion('1.9.0a2.dev-f16acvda') == '1.9.0a2.dev-11111111')
+    assert_(NumpyVersion('1.9.0a2.dev-6acvda54') < '1.9.0a2')
+
+
+def test_dev0_version():
+    assert_(NumpyVersion('1.9.0.dev0+Unknown') < '1.9.0')
+    for ver in ['1.9.0', '1.9.0a1', '1.9.0b2', '1.9.0b2.dev0+ffffffff']:
+        assert_(NumpyVersion('1.9.0.dev0+f16acvda') < ver)
+
+    assert_(NumpyVersion('1.9.0.dev0+f16acvda') == '1.9.0.dev0+11111111')
+
+
+def test_dev0_a_b_rc_mixed():
+    assert_(NumpyVersion('1.9.0a2.dev0+f16acvda') == '1.9.0a2.dev0+11111111')
+    assert_(NumpyVersion('1.9.0a2.dev0+6acvda54') < '1.9.0a2')
+
+
+def test_raises():
+    for ver in ['1.9', '1,9.0', '1.7.x']:
+        assert_raises(ValueError, NumpyVersion, ver)
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/tests/test_array_utils.py b/venv/lib/python3.12/site-packages/numpy/lib/tests/test_array_utils.py
new file mode 100644
index 00000000..3d8b2bd4
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/lib/tests/test_array_utils.py
@@ -0,0 +1,33 @@
+import numpy as np
+
+from numpy.lib import array_utils
+from numpy.testing import assert_equal
+
+
+class TestByteBounds:
+    def test_byte_bounds(self):
+        # pointer difference matches size * itemsize
+        # due to contiguity
+        a = np.arange(12).reshape(3, 4)
+        low, high = array_utils.byte_bounds(a)
+        assert_equal(high - low, a.size * a.itemsize)
+
+    def test_unusual_order_positive_stride(self):
+        a = np.arange(12).reshape(3, 4)
+        b = a.T
+        low, high = array_utils.byte_bounds(b)
+        assert_equal(high - low, b.size * b.itemsize)
+
+    def test_unusual_order_negative_stride(self):
+        a = np.arange(12).reshape(3, 4)
+        b = a.T[::-1]
+        low, high = array_utils.byte_bounds(b)
+        assert_equal(high - low, b.size * b.itemsize)
+
+    def test_strided(self):
+        a = np.arange(12)
+        b = a[::2]
+        low, high = array_utils.byte_bounds(b)
+        # the largest pointer address is lost (even numbers only in the
+        # stride), and compensate addresses for striding by 2
+        assert_equal(high - low, b.size * 2 * b.itemsize - b.itemsize)
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/tests/test_arraypad.py b/venv/lib/python3.12/site-packages/numpy/lib/tests/test_arraypad.py
new file mode 100644
index 00000000..ef3319e9
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/lib/tests/test_arraypad.py
@@ -0,0 +1,1416 @@
+"""Tests for the array padding functions.
+
+"""
+import pytest
+
+import numpy as np
+from numpy.testing import assert_array_equal, assert_allclose, assert_equal
+from numpy.lib._arraypad_impl import _as_pairs
+
+
+_numeric_dtypes = (
+    np._core.sctypes["uint"]
+    + np._core.sctypes["int"]
+    + np._core.sctypes["float"]
+    + np._core.sctypes["complex"]
+)
+_all_modes = {
+    'constant': {'constant_values': 0},
+    'edge': {},
+    'linear_ramp': {'end_values': 0},
+    'maximum': {'stat_length': None},
+    'mean': {'stat_length': None},
+    'median': {'stat_length': None},
+    'minimum': {'stat_length': None},
+    'reflect': {'reflect_type': 'even'},
+    'symmetric': {'reflect_type': 'even'},
+    'wrap': {},
+    'empty': {}
+}
+
+
+class TestAsPairs:
+    def test_single_value(self):
+        """Test casting for a single value."""
+        expected = np.array([[3, 3]] * 10)
+        for x in (3, [3], [[3]]):
+            result = _as_pairs(x, 10)
+            assert_equal(result, expected)
+        # Test with dtype=object
+        obj = object()
+        assert_equal(
+            _as_pairs(obj, 10),
+            np.array([[obj, obj]] * 10)
+        )
+
+    def test_two_values(self):
+        """Test proper casting for two different values."""
+        # Broadcasting in the first dimension with numbers
+        expected = np.array([[3, 4]] * 10)
+        for x in ([3, 4], [[3, 4]]):
+            result = _as_pairs(x, 10)
+            assert_equal(result, expected)
+        # and with dtype=object
+        obj = object()
+        assert_equal(
+            _as_pairs(["a", obj], 10),
+            np.array([["a", obj]] * 10)
+        )
+
+        # Broadcasting in the second / last dimension with numbers
+        assert_equal(
+            _as_pairs([[3], [4]], 2),
+            np.array([[3, 3], [4, 4]])
+        )
+        # and with dtype=object
+        assert_equal(
+            _as_pairs([["a"], [obj]], 2),
+            np.array([["a", "a"], [obj, obj]])
+        )
+
+    def test_with_none(self):
+        expected = ((None, None), (None, None), (None, None))
+        assert_equal(
+            _as_pairs(None, 3, as_index=False),
+            expected
+        )
+        assert_equal(
+            _as_pairs(None, 3, as_index=True),
+            expected
+        )
+
+    def test_pass_through(self):
+        """Test if `x` already matching desired output are passed through."""
+        expected = np.arange(12).reshape((6, 2))
+        assert_equal(
+            _as_pairs(expected, 6),
+            expected
+        )
+
+    def test_as_index(self):
+        """Test results if `as_index=True`."""
+        assert_equal(
+            _as_pairs([2.6, 3.3], 10, as_index=True),
+            np.array([[3, 3]] * 10, dtype=np.intp)
+        )
+        assert_equal(
+            _as_pairs([2.6, 4.49], 10, as_index=True),
+            np.array([[3, 4]] * 10, dtype=np.intp)
+        )
+        for x in (-3, [-3], [[-3]], [-3, 4], [3, -4], [[-3, 4]], [[4, -3]],
+                  [[1, 2]] * 9 + [[1, -2]]):
+            with pytest.raises(ValueError, match="negative values"):
+                _as_pairs(x, 10, as_index=True)
+
+    def test_exceptions(self):
+        """Ensure faulty usage is discovered."""
+        with pytest.raises(ValueError, match="more dimensions than allowed"):
+            _as_pairs([[[3]]], 10)
+        with pytest.raises(ValueError, match="could not be broadcast"):
+            _as_pairs([[1, 2], [3, 4]], 3)
+        with pytest.raises(ValueError, match="could not be broadcast"):
+            _as_pairs(np.ones((2, 3)), 3)
+
+
+class TestConditionalShortcuts:
+    @pytest.mark.parametrize("mode", _all_modes.keys())
+    def test_zero_padding_shortcuts(self, mode):
+        test = np.arange(120).reshape(4, 5, 6)
+        pad_amt = [(0, 0) for _ in test.shape]
+        assert_array_equal(test, np.pad(test, pad_amt, mode=mode))
+
+    @pytest.mark.parametrize("mode", ['maximum', 'mean', 'median', 'minimum',])
+    def test_shallow_statistic_range(self, mode):
+        test = np.arange(120).reshape(4, 5, 6)
+        pad_amt = [(1, 1) for _ in test.shape]
+        assert_array_equal(np.pad(test, pad_amt, mode='edge'),
+                           np.pad(test, pad_amt, mode=mode, stat_length=1))
+
+    @pytest.mark.parametrize("mode", ['maximum', 'mean', 'median', 'minimum',])
+    def test_clip_statistic_range(self, mode):
+        test = np.arange(30).reshape(5, 6)
+        pad_amt = [(3, 3) for _ in test.shape]
+        assert_array_equal(np.pad(test, pad_amt, mode=mode),
+                           np.pad(test, pad_amt, mode=mode, stat_length=30))
+
+
+class TestStatistic:
+    def test_check_mean_stat_length(self):
+        a = np.arange(100).astype('f')
+        a = np.pad(a, ((25, 20), ), 'mean', stat_length=((2, 3), ))
+        b = np.array(
+            [0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5,
+             0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5,
+             0.5, 0.5, 0.5, 0.5, 0.5,
+
+             0., 1., 2., 3., 4., 5., 6., 7., 8., 9.,
+             10., 11., 12., 13., 14., 15., 16., 17., 18., 19.,
+             20., 21., 22., 23., 24., 25., 26., 27., 28., 29.,
+             30., 31., 32., 33., 34., 35., 36., 37., 38., 39.,
+             40., 41., 42., 43., 44., 45., 46., 47., 48., 49.,
+             50., 51., 52., 53., 54., 55., 56., 57., 58., 59.,
+             60., 61., 62., 63., 64., 65., 66., 67., 68., 69.,
+             70., 71., 72., 73., 74., 75., 76., 77., 78., 79.,
+             80., 81., 82., 83., 84., 85., 86., 87., 88., 89.,
+             90., 91., 92., 93., 94., 95., 96., 97., 98., 99.,
+
+             98., 98., 98., 98., 98., 98., 98., 98., 98., 98.,
+             98., 98., 98., 98., 98., 98., 98., 98., 98., 98.
+             ])
+        assert_array_equal(a, b)
+
+    def test_check_maximum_1(self):
+        a = np.arange(100)
+        a = np.pad(a, (25, 20), 'maximum')
+        b = np.array(
+            [99, 99, 99, 99, 99, 99, 99, 99, 99, 99,
+             99, 99, 99, 99, 99, 99, 99, 99, 99, 99,
+             99, 99, 99, 99, 99,
+
+             0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
+             10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
+             20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
+             30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
+             40, 41, 42, 43, 44, 45, 46, 47, 48, 49,
+             50, 51, 52, 53, 54, 55, 56, 57, 58, 59,
+             60, 61, 62, 63, 64, 65, 66, 67, 68, 69,
+             70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
+             80, 81, 82, 83, 84, 85, 86, 87, 88, 89,
+             90, 91, 92, 93, 94, 95, 96, 97, 98, 99,
+
+             99, 99, 99, 99, 99, 99, 99, 99, 99, 99,
+             99, 99, 99, 99, 99, 99, 99, 99, 99, 99]
+            )
+        assert_array_equal(a, b)
+
+    def test_check_maximum_2(self):
+        a = np.arange(100) + 1
+        a = np.pad(a, (25, 20), 'maximum')
+        b = np.array(
+            [100, 100, 100, 100, 100, 100, 100, 100, 100, 100,
+             100, 100, 100, 100, 100, 100, 100, 100, 100, 100,
+             100, 100, 100, 100, 100,
+
+             1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
+             11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
+             21, 22, 23, 24, 25, 26, 27, 28, 29, 30,
+             31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
+             41, 42, 43, 44, 45, 46, 47, 48, 49, 50,
+             51, 52, 53, 54, 55, 56, 57, 58, 59, 60,
+             61, 62, 63, 64, 65, 66, 67, 68, 69, 70,
+             71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
+             81, 82, 83, 84, 85, 86, 87, 88, 89, 90,
+             91, 92, 93, 94, 95, 96, 97, 98, 99, 100,
+
+             100, 100, 100, 100, 100, 100, 100, 100, 100, 100,
+             100, 100, 100, 100, 100, 100, 100, 100, 100, 100]
+            )
+        assert_array_equal(a, b)
+
+    def test_check_maximum_stat_length(self):
+        a = np.arange(100) + 1
+        a = np.pad(a, (25, 20), 'maximum', stat_length=10)
+        b = np.array(
+            [10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
+             10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
+             10, 10, 10, 10, 10,
+
+              1,  2,  3,  4,  5,  6,  7,  8,  9, 10,
+             11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
+             21, 22, 23, 24, 25, 26, 27, 28, 29, 30,
+             31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
+             41, 42, 43, 44, 45, 46, 47, 48, 49, 50,
+             51, 52, 53, 54, 55, 56, 57, 58, 59, 60,
+             61, 62, 63, 64, 65, 66, 67, 68, 69, 70,
+             71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
+             81, 82, 83, 84, 85, 86, 87, 88, 89, 90,
+             91, 92, 93, 94, 95, 96, 97, 98, 99, 100,
+
+             100, 100, 100, 100, 100, 100, 100, 100, 100, 100,
+             100, 100, 100, 100, 100, 100, 100, 100, 100, 100]
+            )
+        assert_array_equal(a, b)
+
+    def test_check_minimum_1(self):
+        a = np.arange(100)
+        a = np.pad(a, (25, 20), 'minimum')
+        b = np.array(
+            [0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+             0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+             0, 0, 0, 0, 0,
+
+             0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
+             10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
+             20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
+             30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
+             40, 41, 42, 43, 44, 45, 46, 47, 48, 49,
+             50, 51, 52, 53, 54, 55, 56, 57, 58, 59,
+             60, 61, 62, 63, 64, 65, 66, 67, 68, 69,
+             70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
+             80, 81, 82, 83, 84, 85, 86, 87, 88, 89,
+             90, 91, 92, 93, 94, 95, 96, 97, 98, 99,
+
+             0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+             0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+            )
+        assert_array_equal(a, b)
+
+    def test_check_minimum_2(self):
+        a = np.arange(100) + 2
+        a = np.pad(a, (25, 20), 'minimum')
+        b = np.array(
+            [2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+             2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+             2, 2, 2, 2, 2,
+
+             2, 3, 4, 5, 6, 7, 8, 9, 10, 11,
+             12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
+             22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
+             32, 33, 34, 35, 36, 37, 38, 39, 40, 41,
+             42, 43, 44, 45, 46, 47, 48, 49, 50, 51,
+             52, 53, 54, 55, 56, 57, 58, 59, 60, 61,
+             62, 63, 64, 65, 66, 67, 68, 69, 70, 71,
+             72, 73, 74, 75, 76, 77, 78, 79, 80, 81,
+             82, 83, 84, 85, 86, 87, 88, 89, 90, 91,
+             92, 93, 94, 95, 96, 97, 98, 99, 100, 101,
+
+             2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+             2, 2, 2, 2, 2, 2, 2, 2, 2, 2]
+            )
+        assert_array_equal(a, b)
+
+    def test_check_minimum_stat_length(self):
+        a = np.arange(100) + 1
+        a = np.pad(a, (25, 20), 'minimum', stat_length=10)
+        b = np.array(
+            [ 1,  1,  1,  1,  1,  1,  1,  1,  1,  1,
+              1,  1,  1,  1,  1,  1,  1,  1,  1,  1,
+              1,  1,  1,  1,  1,
+
+              1,  2,  3,  4,  5,  6,  7,  8,  9, 10,
+             11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
+             21, 22, 23, 24, 25, 26, 27, 28, 29, 30,
+             31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
+             41, 42, 43, 44, 45, 46, 47, 48, 49, 50,
+             51, 52, 53, 54, 55, 56, 57, 58, 59, 60,
+             61, 62, 63, 64, 65, 66, 67, 68, 69, 70,
+             71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
+             81, 82, 83, 84, 85, 86, 87, 88, 89, 90,
+             91, 92, 93, 94, 95, 96, 97, 98, 99, 100,
+
+             91, 91, 91, 91, 91, 91, 91, 91, 91, 91,
+             91, 91, 91, 91, 91, 91, 91, 91, 91, 91]
+            )
+        assert_array_equal(a, b)
+
+    def test_check_median(self):
+        a = np.arange(100).astype('f')
+        a = np.pad(a, (25, 20), 'median')
+        b = np.array(
+            [49.5, 49.5, 49.5, 49.5, 49.5, 49.5, 49.5, 49.5, 49.5, 49.5,
+             49.5, 49.5, 49.5, 49.5, 49.5, 49.5, 49.5, 49.5, 49.5, 49.5,
+             49.5, 49.5, 49.5, 49.5, 49.5,
+
+             0., 1., 2., 3., 4., 5., 6., 7., 8., 9.,
+             10., 11., 12., 13., 14., 15., 16., 17., 18., 19.,
+             20., 21., 22., 23., 24., 25., 26., 27., 28., 29.,
+             30., 31., 32., 33., 34., 35., 36., 37., 38., 39.,
+             40., 41., 42., 43., 44., 45., 46., 47., 48., 49.,
+             50., 51., 52., 53., 54., 55., 56., 57., 58., 59.,
+             60., 61., 62., 63., 64., 65., 66., 67., 68., 69.,
+             70., 71., 72., 73., 74., 75., 76., 77., 78., 79.,
+             80., 81., 82., 83., 84., 85., 86., 87., 88., 89.,
+             90., 91., 92., 93., 94., 95., 96., 97., 98., 99.,
+
+             49.5, 49.5, 49.5, 49.5, 49.5, 49.5, 49.5, 49.5, 49.5, 49.5,
+             49.5, 49.5, 49.5, 49.5, 49.5, 49.5, 49.5, 49.5, 49.5, 49.5]
+            )
+        assert_array_equal(a, b)
+
+    def test_check_median_01(self):
+        a = np.array([[3, 1, 4], [4, 5, 9], [9, 8, 2]])
+        a = np.pad(a, 1, 'median')
+        b = np.array(
+            [[4, 4, 5, 4, 4],
+
+             [3, 3, 1, 4, 3],
+             [5, 4, 5, 9, 5],
+             [8, 9, 8, 2, 8],
+
+             [4, 4, 5, 4, 4]]
+            )
+        assert_array_equal(a, b)
+
+    def test_check_median_02(self):
+        a = np.array([[3, 1, 4], [4, 5, 9], [9, 8, 2]])
+        a = np.pad(a.T, 1, 'median').T
+        b = np.array(
+            [[5, 4, 5, 4, 5],
+
+             [3, 3, 1, 4, 3],
+             [5, 4, 5, 9, 5],
+             [8, 9, 8, 2, 8],
+
+             [5, 4, 5, 4, 5]]
+            )
+        assert_array_equal(a, b)
+
+    def test_check_median_stat_length(self):
+        a = np.arange(100).astype('f')
+        a[1] = 2.
+        a[97] = 96.
+        a = np.pad(a, (25, 20), 'median', stat_length=(3, 5))
+        b = np.array(
+            [ 2.,  2.,  2.,  2.,  2.,  2.,  2.,  2.,  2.,  2.,
+              2.,  2.,  2.,  2.,  2.,  2.,  2.,  2.,  2.,  2.,
+              2.,  2.,  2.,  2.,  2.,
+
+              0.,  2.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9.,
+             10., 11., 12., 13., 14., 15., 16., 17., 18., 19.,
+             20., 21., 22., 23., 24., 25., 26., 27., 28., 29.,
+             30., 31., 32., 33., 34., 35., 36., 37., 38., 39.,
+             40., 41., 42., 43., 44., 45., 46., 47., 48., 49.,
+             50., 51., 52., 53., 54., 55., 56., 57., 58., 59.,
+             60., 61., 62., 63., 64., 65., 66., 67., 68., 69.,
+             70., 71., 72., 73., 74., 75., 76., 77., 78., 79.,
+             80., 81., 82., 83., 84., 85., 86., 87., 88., 89.,
+             90., 91., 92., 93., 94., 95., 96., 96., 98., 99.,
+
+             96., 96., 96., 96., 96., 96., 96., 96., 96., 96.,
+             96., 96., 96., 96., 96., 96., 96., 96., 96., 96.]
+            )
+        assert_array_equal(a, b)
+
+    def test_check_mean_shape_one(self):
+        a = [[4, 5, 6]]
+        a = np.pad(a, (5, 7), 'mean', stat_length=2)
+        b = np.array(
+            [[4, 4, 4, 4, 4, 4, 5, 6, 6, 6, 6, 6, 6, 6, 6],
+             [4, 4, 4, 4, 4, 4, 5, 6, 6, 6, 6, 6, 6, 6, 6],
+             [4, 4, 4, 4, 4, 4, 5, 6, 6, 6, 6, 6, 6, 6, 6],
+             [4, 4, 4, 4, 4, 4, 5, 6, 6, 6, 6, 6, 6, 6, 6],
+             [4, 4, 4, 4, 4, 4, 5, 6, 6, 6, 6, 6, 6, 6, 6],
+
+             [4, 4, 4, 4, 4, 4, 5, 6, 6, 6, 6, 6, 6, 6, 6],
+
+             [4, 4, 4, 4, 4, 4, 5, 6, 6, 6, 6, 6, 6, 6, 6],
+             [4, 4, 4, 4, 4, 4, 5, 6, 6, 6, 6, 6, 6, 6, 6],
+             [4, 4, 4, 4, 4, 4, 5, 6, 6, 6, 6, 6, 6, 6, 6],
+             [4, 4, 4, 4, 4, 4, 5, 6, 6, 6, 6, 6, 6, 6, 6],
+             [4, 4, 4, 4, 4, 4, 5, 6, 6, 6, 6, 6, 6, 6, 6],
+             [4, 4, 4, 4, 4, 4, 5, 6, 6, 6, 6, 6, 6, 6, 6],
+             [4, 4, 4, 4, 4, 4, 5, 6, 6, 6, 6, 6, 6, 6, 6]]
+            )
+        assert_array_equal(a, b)
+
+    def test_check_mean_2(self):
+        a = np.arange(100).astype('f')
+        a = np.pad(a, (25, 20), 'mean')
+        b = np.array(
+            [49.5, 49.5, 49.5, 49.5, 49.5, 49.5, 49.5, 49.5, 49.5, 49.5,
+             49.5, 49.5, 49.5, 49.5, 49.5, 49.5, 49.5, 49.5, 49.5, 49.5,
+             49.5, 49.5, 49.5, 49.5, 49.5,
+
+             0., 1., 2., 3., 4., 5., 6., 7., 8., 9.,
+             10., 11., 12., 13., 14., 15., 16., 17., 18., 19.,
+             20., 21., 22., 23., 24., 25., 26., 27., 28., 29.,
+             30., 31., 32., 33., 34., 35., 36., 37., 38., 39.,
+             40., 41., 42., 43., 44., 45., 46., 47., 48., 49.,
+             50., 51., 52., 53., 54., 55., 56., 57., 58., 59.,
+             60., 61., 62., 63., 64., 65., 66., 67., 68., 69.,
+             70., 71., 72., 73., 74., 75., 76., 77., 78., 79.,
+             80., 81., 82., 83., 84., 85., 86., 87., 88., 89.,
+             90., 91., 92., 93., 94., 95., 96., 97., 98., 99.,
+
+             49.5, 49.5, 49.5, 49.5, 49.5, 49.5, 49.5, 49.5, 49.5, 49.5,
+             49.5, 49.5, 49.5, 49.5, 49.5, 49.5, 49.5, 49.5, 49.5, 49.5]
+            )
+        assert_array_equal(a, b)
+
+    @pytest.mark.parametrize("mode", [
+        "mean",
+        "median",
+        "minimum",
+        "maximum"
+    ])
+    def test_same_prepend_append(self, mode):
+        """ Test that appended and prepended values are equal """
+        # This test is constructed to trigger floating point rounding errors in
+        # a way that caused gh-11216 for mode=='mean'
+        a = np.array([-1, 2, -1]) + np.array([0, 1e-12, 0], dtype=np.float64)
+        a = np.pad(a, (1, 1), mode)
+        assert_equal(a[0], a[-1])
+
+    @pytest.mark.parametrize("mode", ["mean", "median", "minimum", "maximum"])
+    @pytest.mark.parametrize(
+        "stat_length", [-2, (-2,), (3, -1), ((5, 2), (-2, 3)), ((-4,), (2,))]
+    )
+    def test_check_negative_stat_length(self, mode, stat_length):
+        arr = np.arange(30).reshape((6, 5))
+        match = "index can't contain negative values"
+        with pytest.raises(ValueError, match=match):
+            np.pad(arr, 2, mode, stat_length=stat_length)
+
+    def test_simple_stat_length(self):
+        a = np.arange(30)
+        a = np.reshape(a, (6, 5))
+        a = np.pad(a, ((2, 3), (3, 2)), mode='mean', stat_length=(3,))
+        b = np.array(
+            [[6, 6, 6, 5, 6, 7, 8, 9, 8, 8],
+             [6, 6, 6, 5, 6, 7, 8, 9, 8, 8],
+
+             [1, 1, 1, 0, 1, 2, 3, 4, 3, 3],
+             [6, 6, 6, 5, 6, 7, 8, 9, 8, 8],
+             [11, 11, 11, 10, 11, 12, 13, 14, 13, 13],
+             [16, 16, 16, 15, 16, 17, 18, 19, 18, 18],
+             [21, 21, 21, 20, 21, 22, 23, 24, 23, 23],
+             [26, 26, 26, 25, 26, 27, 28, 29, 28, 28],
+
+             [21, 21, 21, 20, 21, 22, 23, 24, 23, 23],
+             [21, 21, 21, 20, 21, 22, 23, 24, 23, 23],
+             [21, 21, 21, 20, 21, 22, 23, 24, 23, 23]]
+            )
+        assert_array_equal(a, b)
+
+    @pytest.mark.filterwarnings("ignore:Mean of empty slice:RuntimeWarning")
+    @pytest.mark.filterwarnings(
+        "ignore:invalid value encountered in( scalar)? divide:RuntimeWarning"
+    )
+    @pytest.mark.parametrize("mode", ["mean", "median"])
+    def test_zero_stat_length_valid(self, mode):
+        arr = np.pad([1., 2.], (1, 2), mode, stat_length=0)
+        expected = np.array([np.nan, 1., 2., np.nan, np.nan])
+        assert_equal(arr, expected)
+
+    @pytest.mark.parametrize("mode", ["minimum", "maximum"])
+    def test_zero_stat_length_invalid(self, mode):
+        match = "stat_length of 0 yields no value for padding"
+        with pytest.raises(ValueError, match=match):
+            np.pad([1., 2.], 0, mode, stat_length=0)
+        with pytest.raises(ValueError, match=match):
+            np.pad([1., 2.], 0, mode, stat_length=(1, 0))
+        with pytest.raises(ValueError, match=match):
+            np.pad([1., 2.], 1, mode, stat_length=0)
+        with pytest.raises(ValueError, match=match):
+            np.pad([1., 2.], 1, mode, stat_length=(1, 0))
+
+
+class TestConstant:
+    def test_check_constant(self):
+        a = np.arange(100)
+        a = np.pad(a, (25, 20), 'constant', constant_values=(10, 20))
+        b = np.array(
+            [10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
+             10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
+             10, 10, 10, 10, 10,
+
+             0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
+             10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
+             20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
+             30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
+             40, 41, 42, 43, 44, 45, 46, 47, 48, 49,
+             50, 51, 52, 53, 54, 55, 56, 57, 58, 59,
+             60, 61, 62, 63, 64, 65, 66, 67, 68, 69,
+             70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
+             80, 81, 82, 83, 84, 85, 86, 87, 88, 89,
+             90, 91, 92, 93, 94, 95, 96, 97, 98, 99,
+
+             20, 20, 20, 20, 20, 20, 20, 20, 20, 20,
+             20, 20, 20, 20, 20, 20, 20, 20, 20, 20]
+            )
+        assert_array_equal(a, b)
+
+    def test_check_constant_zeros(self):
+        a = np.arange(100)
+        a = np.pad(a, (25, 20), 'constant')
+        b = np.array(
+            [ 0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+              0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+              0,  0,  0,  0,  0,
+
+             0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
+             10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
+             20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
+             30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
+             40, 41, 42, 43, 44, 45, 46, 47, 48, 49,
+             50, 51, 52, 53, 54, 55, 56, 57, 58, 59,
+             60, 61, 62, 63, 64, 65, 66, 67, 68, 69,
+             70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
+             80, 81, 82, 83, 84, 85, 86, 87, 88, 89,
+             90, 91, 92, 93, 94, 95, 96, 97, 98, 99,
+
+              0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+              0,  0,  0,  0,  0,  0,  0,  0,  0,  0]
+            )
+        assert_array_equal(a, b)
+
+    def test_check_constant_float(self):
+        # If input array is int, but constant_values are float, the dtype of
+        # the array to be padded is kept
+        arr = np.arange(30).reshape(5, 6)
+        test = np.pad(arr, (1, 2), mode='constant',
+                   constant_values=1.1)
+        expected = np.array(
+            [[ 1,  1,  1,  1,  1,  1,  1,  1,  1],
+
+             [ 1,  0,  1,  2,  3,  4,  5,  1,  1],
+             [ 1,  6,  7,  8,  9, 10, 11,  1,  1],
+             [ 1, 12, 13, 14, 15, 16, 17,  1,  1],
+             [ 1, 18, 19, 20, 21, 22, 23,  1,  1],
+             [ 1, 24, 25, 26, 27, 28, 29,  1,  1],
+
+             [ 1,  1,  1,  1,  1,  1,  1,  1,  1],
+             [ 1,  1,  1,  1,  1,  1,  1,  1,  1]]
+            )
+        assert_allclose(test, expected)
+
+    def test_check_constant_float2(self):
+        # If input array is float, and constant_values are float, the dtype of
+        # the array to be padded is kept - here retaining the float constants
+        arr = np.arange(30).reshape(5, 6)
+        arr_float = arr.astype(np.float64)
+        test = np.pad(arr_float, ((1, 2), (1, 2)), mode='constant',
+                   constant_values=1.1)
+        expected = np.array(
+            [[  1.1,   1.1,   1.1,   1.1,   1.1,   1.1,   1.1,   1.1,   1.1],
+
+             [  1.1,   0. ,   1. ,   2. ,   3. ,   4. ,   5. ,   1.1,   1.1],
+             [  1.1,   6. ,   7. ,   8. ,   9. ,  10. ,  11. ,   1.1,   1.1],
+             [  1.1,  12. ,  13. ,  14. ,  15. ,  16. ,  17. ,   1.1,   1.1],
+             [  1.1,  18. ,  19. ,  20. ,  21. ,  22. ,  23. ,   1.1,   1.1],
+             [  1.1,  24. ,  25. ,  26. ,  27. ,  28. ,  29. ,   1.1,   1.1],
+
+             [  1.1,   1.1,   1.1,   1.1,   1.1,   1.1,   1.1,   1.1,   1.1],
+             [  1.1,   1.1,   1.1,   1.1,   1.1,   1.1,   1.1,   1.1,   1.1]]
+            )
+        assert_allclose(test, expected)
+
+    def test_check_constant_float3(self):
+        a = np.arange(100, dtype=float)
+        a = np.pad(a, (25, 20), 'constant', constant_values=(-1.1, -1.2))
+        b = np.array(
+            [-1.1, -1.1, -1.1, -1.1, -1.1, -1.1, -1.1, -1.1, -1.1, -1.1,
+             -1.1, -1.1, -1.1, -1.1, -1.1, -1.1, -1.1, -1.1, -1.1, -1.1,
+             -1.1, -1.1, -1.1, -1.1, -1.1,
+
+             0,  1,  2,  3,  4,  5,  6,  7,  8,  9,
+             10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
+             20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
+             30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
+             40, 41, 42, 43, 44, 45, 46, 47, 48, 49,
+             50, 51, 52, 53, 54, 55, 56, 57, 58, 59,
+             60, 61, 62, 63, 64, 65, 66, 67, 68, 69,
+             70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
+             80, 81, 82, 83, 84, 85, 86, 87, 88, 89,
+             90, 91, 92, 93, 94, 95, 96, 97, 98, 99,
+
+             -1.2, -1.2, -1.2, -1.2, -1.2, -1.2, -1.2, -1.2, -1.2, -1.2,
+             -1.2, -1.2, -1.2, -1.2, -1.2, -1.2, -1.2, -1.2, -1.2, -1.2]
+            )
+        assert_allclose(a, b)
+
+    def test_check_constant_odd_pad_amount(self):
+        arr = np.arange(30).reshape(5, 6)
+        test = np.pad(arr, ((1,), (2,)), mode='constant',
+                   constant_values=3)
+        expected = np.array(
+            [[ 3,  3,  3,  3,  3,  3,  3,  3,  3,  3],
+
+             [ 3,  3,  0,  1,  2,  3,  4,  5,  3,  3],
+             [ 3,  3,  6,  7,  8,  9, 10, 11,  3,  3],
+             [ 3,  3, 12, 13, 14, 15, 16, 17,  3,  3],
+             [ 3,  3, 18, 19, 20, 21, 22, 23,  3,  3],
+             [ 3,  3, 24, 25, 26, 27, 28, 29,  3,  3],
+
+             [ 3,  3,  3,  3,  3,  3,  3,  3,  3,  3]]
+            )
+        assert_allclose(test, expected)
+
+    def test_check_constant_pad_2d(self):
+        arr = np.arange(4).reshape(2, 2)
+        test = np.pad(arr, ((1, 2), (1, 3)), mode='constant',
+                          constant_values=((1, 2), (3, 4)))
+        expected = np.array(
+            [[3, 1, 1, 4, 4, 4],
+             [3, 0, 1, 4, 4, 4],
+             [3, 2, 3, 4, 4, 4],
+             [3, 2, 2, 4, 4, 4],
+             [3, 2, 2, 4, 4, 4]]
+        )
+        assert_allclose(test, expected)
+
+    def test_check_large_integers(self):
+        uint64_max = 2 ** 64 - 1
+        arr = np.full(5, uint64_max, dtype=np.uint64)
+        test = np.pad(arr, 1, mode="constant", constant_values=arr.min())
+        expected = np.full(7, uint64_max, dtype=np.uint64)
+        assert_array_equal(test, expected)
+
+        int64_max = 2 ** 63 - 1
+        arr = np.full(5, int64_max, dtype=np.int64)
+        test = np.pad(arr, 1, mode="constant", constant_values=arr.min())
+        expected = np.full(7, int64_max, dtype=np.int64)
+        assert_array_equal(test, expected)
+
+    def test_check_object_array(self):
+        arr = np.empty(1, dtype=object)
+        obj_a = object()
+        arr[0] = obj_a
+        obj_b = object()
+        obj_c = object()
+        arr = np.pad(arr, pad_width=1, mode='constant',
+                     constant_values=(obj_b, obj_c))
+
+        expected = np.empty((3,), dtype=object)
+        expected[0] = obj_b
+        expected[1] = obj_a
+        expected[2] = obj_c
+
+        assert_array_equal(arr, expected)
+
+    def test_pad_empty_dimension(self):
+        arr = np.zeros((3, 0, 2))
+        result = np.pad(arr, [(0,), (2,), (1,)], mode="constant")
+        assert result.shape == (3, 4, 4)
+
+
+class TestLinearRamp:
+    def test_check_simple(self):
+        a = np.arange(100).astype('f')
+        a = np.pad(a, (25, 20), 'linear_ramp', end_values=(4, 5))
+        b = np.array(
+            [4.00, 3.84, 3.68, 3.52, 3.36, 3.20, 3.04, 2.88, 2.72, 2.56,
+             2.40, 2.24, 2.08, 1.92, 1.76, 1.60, 1.44, 1.28, 1.12, 0.96,
+             0.80, 0.64, 0.48, 0.32, 0.16,
+
+             0.00, 1.00, 2.00, 3.00, 4.00, 5.00, 6.00, 7.00, 8.00, 9.00,
+             10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0, 19.0,
+             20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0,
+             30.0, 31.0, 32.0, 33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0,
+             40.0, 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0, 49.0,
+             50.0, 51.0, 52.0, 53.0, 54.0, 55.0, 56.0, 57.0, 58.0, 59.0,
+             60.0, 61.0, 62.0, 63.0, 64.0, 65.0, 66.0, 67.0, 68.0, 69.0,
+             70.0, 71.0, 72.0, 73.0, 74.0, 75.0, 76.0, 77.0, 78.0, 79.0,
+             80.0, 81.0, 82.0, 83.0, 84.0, 85.0, 86.0, 87.0, 88.0, 89.0,
+             90.0, 91.0, 92.0, 93.0, 94.0, 95.0, 96.0, 97.0, 98.0, 99.0,
+
+             94.3, 89.6, 84.9, 80.2, 75.5, 70.8, 66.1, 61.4, 56.7, 52.0,
+             47.3, 42.6, 37.9, 33.2, 28.5, 23.8, 19.1, 14.4, 9.7, 5.]
+            )
+        assert_allclose(a, b, rtol=1e-5, atol=1e-5)
+
+    def test_check_2d(self):
+        arr = np.arange(20).reshape(4, 5).astype(np.float64)
+        test = np.pad(arr, (2, 2), mode='linear_ramp', end_values=(0, 0))
+        expected = np.array(
+            [[0.,   0.,   0.,   0.,   0.,   0.,   0.,    0.,   0.],
+             [0.,   0.,   0.,  0.5,   1.,  1.5,   2.,    1.,   0.],
+             [0.,   0.,   0.,   1.,   2.,   3.,   4.,    2.,   0.],
+             [0.,  2.5,   5.,   6.,   7.,   8.,   9.,   4.5,   0.],
+             [0.,   5.,  10.,  11.,  12.,  13.,  14.,    7.,   0.],
+             [0.,  7.5,  15.,  16.,  17.,  18.,  19.,   9.5,   0.],
+             [0., 3.75,  7.5,   8.,  8.5,   9.,  9.5,  4.75,   0.],
+             [0.,   0.,   0.,   0.,   0.,   0.,   0.,    0.,   0.]])
+        assert_allclose(test, expected)
+
+    @pytest.mark.xfail(exceptions=(AssertionError,))
+    def test_object_array(self):
+        from fractions import Fraction
+        arr = np.array([Fraction(1, 2), Fraction(-1, 2)])
+        actual = np.pad(arr, (2, 3), mode='linear_ramp', end_values=0)
+
+        # deliberately chosen to have a non-power-of-2 denominator such that
+        # rounding to floats causes a failure.
+        expected = np.array([
+            Fraction( 0, 12),
+            Fraction( 3, 12),
+            Fraction( 6, 12),
+            Fraction(-6, 12),
+            Fraction(-4, 12),
+            Fraction(-2, 12),
+            Fraction(-0, 12),
+        ])
+        assert_equal(actual, expected)
+
+    def test_end_values(self):
+        """Ensure that end values are exact."""
+        a = np.pad(np.ones(10).reshape(2, 5), (223, 123), mode="linear_ramp")
+        assert_equal(a[:, 0], 0.)
+        assert_equal(a[:, -1], 0.)
+        assert_equal(a[0, :], 0.)
+        assert_equal(a[-1, :], 0.)
+
+    @pytest.mark.parametrize("dtype", _numeric_dtypes)
+    def test_negative_difference(self, dtype):
+        """
+        Check correct behavior of unsigned dtypes if there is a negative
+        difference between the edge to pad and `end_values`. Check both cases
+        to be independent of implementation. Test behavior for all other dtypes
+        in case dtype casting interferes with complex dtypes. See gh-14191.
+        """
+        x = np.array([3], dtype=dtype)
+        result = np.pad(x, 3, mode="linear_ramp", end_values=0)
+        expected = np.array([0, 1, 2, 3, 2, 1, 0], dtype=dtype)
+        assert_equal(result, expected)
+
+        x = np.array([0], dtype=dtype)
+        result = np.pad(x, 3, mode="linear_ramp", end_values=3)
+        expected = np.array([3, 2, 1, 0, 1, 2, 3], dtype=dtype)
+        assert_equal(result, expected)
+
+
+class TestReflect:
+    def test_check_simple(self):
+        a = np.arange(100)
+        a = np.pad(a, (25, 20), 'reflect')
+        b = np.array(
+            [25, 24, 23, 22, 21, 20, 19, 18, 17, 16,
+             15, 14, 13, 12, 11, 10, 9, 8, 7, 6,
+             5, 4, 3, 2, 1,
+
+             0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
+             10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
+             20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
+             30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
+             40, 41, 42, 43, 44, 45, 46, 47, 48, 49,
+             50, 51, 52, 53, 54, 55, 56, 57, 58, 59,
+             60, 61, 62, 63, 64, 65, 66, 67, 68, 69,
+             70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
+             80, 81, 82, 83, 84, 85, 86, 87, 88, 89,
+             90, 91, 92, 93, 94, 95, 96, 97, 98, 99,
+
+             98, 97, 96, 95, 94, 93, 92, 91, 90, 89,
+             88, 87, 86, 85, 84, 83, 82, 81, 80, 79]
+            )
+        assert_array_equal(a, b)
+
+    def test_check_odd_method(self):
+        a = np.arange(100)
+        a = np.pad(a, (25, 20), 'reflect', reflect_type='odd')
+        b = np.array(
+            [-25, -24, -23, -22, -21, -20, -19, -18, -17, -16,
+             -15, -14, -13, -12, -11, -10, -9, -8, -7, -6,
+             -5, -4, -3, -2, -1,
+
+             0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
+             10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
+             20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
+             30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
+             40, 41, 42, 43, 44, 45, 46, 47, 48, 49,
+             50, 51, 52, 53, 54, 55, 56, 57, 58, 59,
+             60, 61, 62, 63, 64, 65, 66, 67, 68, 69,
+             70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
+             80, 81, 82, 83, 84, 85, 86, 87, 88, 89,
+             90, 91, 92, 93, 94, 95, 96, 97, 98, 99,
+
+             100, 101, 102, 103, 104, 105, 106, 107, 108, 109,
+             110, 111, 112, 113, 114, 115, 116, 117, 118, 119]
+            )
+        assert_array_equal(a, b)
+
+    def test_check_large_pad(self):
+        a = [[4, 5, 6], [6, 7, 8]]
+        a = np.pad(a, (5, 7), 'reflect')
+        b = np.array(
+            [[7, 6, 7, 8, 7, 6, 7, 8, 7, 6, 7, 8, 7, 6, 7],
+             [5, 4, 5, 6, 5, 4, 5, 6, 5, 4, 5, 6, 5, 4, 5],
+             [7, 6, 7, 8, 7, 6, 7, 8, 7, 6, 7, 8, 7, 6, 7],
+             [5, 4, 5, 6, 5, 4, 5, 6, 5, 4, 5, 6, 5, 4, 5],
+             [7, 6, 7, 8, 7, 6, 7, 8, 7, 6, 7, 8, 7, 6, 7],
+
+             [5, 4, 5, 6, 5, 4, 5, 6, 5, 4, 5, 6, 5, 4, 5],
+             [7, 6, 7, 8, 7, 6, 7, 8, 7, 6, 7, 8, 7, 6, 7],
+
+             [5, 4, 5, 6, 5, 4, 5, 6, 5, 4, 5, 6, 5, 4, 5],
+             [7, 6, 7, 8, 7, 6, 7, 8, 7, 6, 7, 8, 7, 6, 7],
+             [5, 4, 5, 6, 5, 4, 5, 6, 5, 4, 5, 6, 5, 4, 5],
+             [7, 6, 7, 8, 7, 6, 7, 8, 7, 6, 7, 8, 7, 6, 7],
+             [5, 4, 5, 6, 5, 4, 5, 6, 5, 4, 5, 6, 5, 4, 5],
+             [7, 6, 7, 8, 7, 6, 7, 8, 7, 6, 7, 8, 7, 6, 7],
+             [5, 4, 5, 6, 5, 4, 5, 6, 5, 4, 5, 6, 5, 4, 5]]
+            )
+        assert_array_equal(a, b)
+
+    def test_check_shape(self):
+        a = [[4, 5, 6]]
+        a = np.pad(a, (5, 7), 'reflect')
+        b = np.array(
+            [[5, 4, 5, 6, 5, 4, 5, 6, 5, 4, 5, 6, 5, 4, 5],
+             [5, 4, 5, 6, 5, 4, 5, 6, 5, 4, 5, 6, 5, 4, 5],
+             [5, 4, 5, 6, 5, 4, 5, 6, 5, 4, 5, 6, 5, 4, 5],
+             [5, 4, 5, 6, 5, 4, 5, 6, 5, 4, 5, 6, 5, 4, 5],
+             [5, 4, 5, 6, 5, 4, 5, 6, 5, 4, 5, 6, 5, 4, 5],
+
+             [5, 4, 5, 6, 5, 4, 5, 6, 5, 4, 5, 6, 5, 4, 5],
+
+             [5, 4, 5, 6, 5, 4, 5, 6, 5, 4, 5, 6, 5, 4, 5],
+             [5, 4, 5, 6, 5, 4, 5, 6, 5, 4, 5, 6, 5, 4, 5],
+             [5, 4, 5, 6, 5, 4, 5, 6, 5, 4, 5, 6, 5, 4, 5],
+             [5, 4, 5, 6, 5, 4, 5, 6, 5, 4, 5, 6, 5, 4, 5],
+             [5, 4, 5, 6, 5, 4, 5, 6, 5, 4, 5, 6, 5, 4, 5],
+             [5, 4, 5, 6, 5, 4, 5, 6, 5, 4, 5, 6, 5, 4, 5],
+             [5, 4, 5, 6, 5, 4, 5, 6, 5, 4, 5, 6, 5, 4, 5]]
+            )
+        assert_array_equal(a, b)
+
+    def test_check_01(self):
+        a = np.pad([1, 2, 3], 2, 'reflect')
+        b = np.array([3, 2, 1, 2, 3, 2, 1])
+        assert_array_equal(a, b)
+
+    def test_check_02(self):
+        a = np.pad([1, 2, 3], 3, 'reflect')
+        b = np.array([2, 3, 2, 1, 2, 3, 2, 1, 2])
+        assert_array_equal(a, b)
+
+    def test_check_03(self):
+        a = np.pad([1, 2, 3], 4, 'reflect')
+        b = np.array([1, 2, 3, 2, 1, 2, 3, 2, 1, 2, 3])
+        assert_array_equal(a, b)
+    
+    def test_check_04(self):
+        a = np.pad([1, 2, 3], [1, 10], 'reflect')
+        b = np.array([2, 1, 2, 3, 2, 1, 2, 3, 2, 1, 2, 3, 2, 1])
+        assert_array_equal(a, b)
+    
+    def test_check_05(self):
+        a = np.pad([1, 2, 3, 4], [45, 10], 'reflect')
+        b = np.array(
+            [4, 3, 2, 1, 2, 3, 4, 3, 2, 1,
+             2, 3, 4, 3, 2, 1, 2, 3, 4, 3,
+             2, 1, 2, 3, 4, 3, 2, 1, 2, 3,
+             4, 3, 2, 1, 2, 3, 4, 3, 2, 1,
+             2, 3, 4, 3, 2, 1, 2, 3, 4, 3,
+             2, 1, 2, 3, 4, 3, 2, 1, 2])
+        assert_array_equal(a, b)
+    
+    def test_check_06(self):
+        a = np.pad([1, 2, 3, 4], [15, 2], 'symmetric')
+        b = np.array(
+            [2, 3, 4, 4, 3, 2, 1, 1, 2, 3, 
+             4, 4, 3, 2, 1, 1, 2, 3, 4, 4, 
+             3]
+        )
+        assert_array_equal(a, b)
+
+    def test_check_07(self):
+        a = np.pad([1, 2, 3, 4, 5, 6], [45, 3], 'symmetric')
+        b = np.array(
+            [4, 5, 6, 6, 5, 4, 3, 2, 1, 1, 
+             2, 3, 4, 5, 6, 6, 5, 4, 3, 2, 
+             1, 1, 2, 3, 4, 5, 6, 6, 5, 4, 
+             3, 2, 1, 1, 2, 3, 4, 5, 6, 6, 
+             5, 4, 3, 2, 1, 1, 2, 3, 4, 5, 
+             6, 6, 5, 4])
+        assert_array_equal(a, b)
+
+
+class TestEmptyArray:
+    """Check how padding behaves on arrays with an empty dimension."""
+
+    @pytest.mark.parametrize(
+        # Keep parametrization ordered, otherwise pytest-xdist might believe
+        # that different tests were collected during parallelization
+        "mode", sorted(_all_modes.keys() - {"constant", "empty"})
+    )
+    def test_pad_empty_dimension(self, mode):
+        match = ("can't extend empty axis 0 using modes other than 'constant' "
+                 "or 'empty'")
+        with pytest.raises(ValueError, match=match):
+            np.pad([], 4, mode=mode)
+        with pytest.raises(ValueError, match=match):
+            np.pad(np.ndarray(0), 4, mode=mode)
+        with pytest.raises(ValueError, match=match):
+            np.pad(np.zeros((0, 3)), ((1,), (0,)), mode=mode)
+
+    @pytest.mark.parametrize("mode", _all_modes.keys())
+    def test_pad_non_empty_dimension(self, mode):
+        result = np.pad(np.ones((2, 0, 2)), ((3,), (0,), (1,)), mode=mode)
+        assert result.shape == (8, 0, 4)
+
+
+class TestSymmetric:
+    def test_check_simple(self):
+        a = np.arange(100)
+        a = np.pad(a, (25, 20), 'symmetric')
+        b = np.array(
+            [24, 23, 22, 21, 20, 19, 18, 17, 16, 15,
+             14, 13, 12, 11, 10, 9, 8, 7, 6, 5,
+             4, 3, 2, 1, 0,
+
+             0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
+             10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
+             20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
+             30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
+             40, 41, 42, 43, 44, 45, 46, 47, 48, 49,
+             50, 51, 52, 53, 54, 55, 56, 57, 58, 59,
+             60, 61, 62, 63, 64, 65, 66, 67, 68, 69,
+             70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
+             80, 81, 82, 83, 84, 85, 86, 87, 88, 89,
+             90, 91, 92, 93, 94, 95, 96, 97, 98, 99,
+
+             99, 98, 97, 96, 95, 94, 93, 92, 91, 90,
+             89, 88, 87, 86, 85, 84, 83, 82, 81, 80]
+            )
+        assert_array_equal(a, b)
+
+    def test_check_odd_method(self):
+        a = np.arange(100)
+        a = np.pad(a, (25, 20), 'symmetric', reflect_type='odd')
+        b = np.array(
+            [-24, -23, -22, -21, -20, -19, -18, -17, -16, -15,
+             -14, -13, -12, -11, -10, -9, -8, -7, -6, -5,
+             -4, -3, -2, -1, 0,
+
+             0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
+             10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
+             20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
+             30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
+             40, 41, 42, 43, 44, 45, 46, 47, 48, 49,
+             50, 51, 52, 53, 54, 55, 56, 57, 58, 59,
+             60, 61, 62, 63, 64, 65, 66, 67, 68, 69,
+             70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
+             80, 81, 82, 83, 84, 85, 86, 87, 88, 89,
+             90, 91, 92, 93, 94, 95, 96, 97, 98, 99,
+
+             99, 100, 101, 102, 103, 104, 105, 106, 107, 108,
+             109, 110, 111, 112, 113, 114, 115, 116, 117, 118]
+            )
+        assert_array_equal(a, b)
+
+    def test_check_large_pad(self):
+        a = [[4, 5, 6], [6, 7, 8]]
+        a = np.pad(a, (5, 7), 'symmetric')
+        b = np.array(
+            [[5, 6, 6, 5, 4, 4, 5, 6, 6, 5, 4, 4, 5, 6, 6],
+             [5, 6, 6, 5, 4, 4, 5, 6, 6, 5, 4, 4, 5, 6, 6],
+             [7, 8, 8, 7, 6, 6, 7, 8, 8, 7, 6, 6, 7, 8, 8],
+             [7, 8, 8, 7, 6, 6, 7, 8, 8, 7, 6, 6, 7, 8, 8],
+             [5, 6, 6, 5, 4, 4, 5, 6, 6, 5, 4, 4, 5, 6, 6],
+
+             [5, 6, 6, 5, 4, 4, 5, 6, 6, 5, 4, 4, 5, 6, 6],
+             [7, 8, 8, 7, 6, 6, 7, 8, 8, 7, 6, 6, 7, 8, 8],
+
+             [7, 8, 8, 7, 6, 6, 7, 8, 8, 7, 6, 6, 7, 8, 8],
+             [5, 6, 6, 5, 4, 4, 5, 6, 6, 5, 4, 4, 5, 6, 6],
+             [5, 6, 6, 5, 4, 4, 5, 6, 6, 5, 4, 4, 5, 6, 6],
+             [7, 8, 8, 7, 6, 6, 7, 8, 8, 7, 6, 6, 7, 8, 8],
+             [7, 8, 8, 7, 6, 6, 7, 8, 8, 7, 6, 6, 7, 8, 8],
+             [5, 6, 6, 5, 4, 4, 5, 6, 6, 5, 4, 4, 5, 6, 6],
+             [5, 6, 6, 5, 4, 4, 5, 6, 6, 5, 4, 4, 5, 6, 6]]
+            )
+
+        assert_array_equal(a, b)
+
+    def test_check_large_pad_odd(self):
+        a = [[4, 5, 6], [6, 7, 8]]
+        a = np.pad(a, (5, 7), 'symmetric', reflect_type='odd')
+        b = np.array(
+            [[-3, -2, -2, -1,  0,  0,  1,  2,  2,  3,  4,  4,  5,  6,  6],
+             [-3, -2, -2, -1,  0,  0,  1,  2,  2,  3,  4,  4,  5,  6,  6],
+             [-1,  0,  0,  1,  2,  2,  3,  4,  4,  5,  6,  6,  7,  8,  8],
+             [-1,  0,  0,  1,  2,  2,  3,  4,  4,  5,  6,  6,  7,  8,  8],
+             [ 1,  2,  2,  3,  4,  4,  5,  6,  6,  7,  8,  8,  9, 10, 10],
+
+             [ 1,  2,  2,  3,  4,  4,  5,  6,  6,  7,  8,  8,  9, 10, 10],
+             [ 3,  4,  4,  5,  6,  6,  7,  8,  8,  9, 10, 10, 11, 12, 12],
+
+             [ 3,  4,  4,  5,  6,  6,  7,  8,  8,  9, 10, 10, 11, 12, 12],
+             [ 5,  6,  6,  7,  8,  8,  9, 10, 10, 11, 12, 12, 13, 14, 14],
+             [ 5,  6,  6,  7,  8,  8,  9, 10, 10, 11, 12, 12, 13, 14, 14],
+             [ 7,  8,  8,  9, 10, 10, 11, 12, 12, 13, 14, 14, 15, 16, 16],
+             [ 7,  8,  8,  9, 10, 10, 11, 12, 12, 13, 14, 14, 15, 16, 16],
+             [ 9, 10, 10, 11, 12, 12, 13, 14, 14, 15, 16, 16, 17, 18, 18],
+             [ 9, 10, 10, 11, 12, 12, 13, 14, 14, 15, 16, 16, 17, 18, 18]]
+            )
+        assert_array_equal(a, b)
+
+    def test_check_shape(self):
+        a = [[4, 5, 6]]
+        a = np.pad(a, (5, 7), 'symmetric')
+        b = np.array(
+            [[5, 6, 6, 5, 4, 4, 5, 6, 6, 5, 4, 4, 5, 6, 6],
+             [5, 6, 6, 5, 4, 4, 5, 6, 6, 5, 4, 4, 5, 6, 6],
+             [5, 6, 6, 5, 4, 4, 5, 6, 6, 5, 4, 4, 5, 6, 6],
+             [5, 6, 6, 5, 4, 4, 5, 6, 6, 5, 4, 4, 5, 6, 6],
+             [5, 6, 6, 5, 4, 4, 5, 6, 6, 5, 4, 4, 5, 6, 6],
+
+             [5, 6, 6, 5, 4, 4, 5, 6, 6, 5, 4, 4, 5, 6, 6],
+             [5, 6, 6, 5, 4, 4, 5, 6, 6, 5, 4, 4, 5, 6, 6],
+
+             [5, 6, 6, 5, 4, 4, 5, 6, 6, 5, 4, 4, 5, 6, 6],
+             [5, 6, 6, 5, 4, 4, 5, 6, 6, 5, 4, 4, 5, 6, 6],
+             [5, 6, 6, 5, 4, 4, 5, 6, 6, 5, 4, 4, 5, 6, 6],
+             [5, 6, 6, 5, 4, 4, 5, 6, 6, 5, 4, 4, 5, 6, 6],
+             [5, 6, 6, 5, 4, 4, 5, 6, 6, 5, 4, 4, 5, 6, 6],
+             [5, 6, 6, 5, 4, 4, 5, 6, 6, 5, 4, 4, 5, 6, 6]]
+            )
+        assert_array_equal(a, b)
+
+    def test_check_01(self):
+        a = np.pad([1, 2, 3], 2, 'symmetric')
+        b = np.array([2, 1, 1, 2, 3, 3, 2])
+        assert_array_equal(a, b)
+
+    def test_check_02(self):
+        a = np.pad([1, 2, 3], 3, 'symmetric')
+        b = np.array([3, 2, 1, 1, 2, 3, 3, 2, 1])
+        assert_array_equal(a, b)
+
+    def test_check_03(self):
+        a = np.pad([1, 2, 3], 6, 'symmetric')
+        b = np.array([1, 2, 3, 3, 2, 1, 1, 2, 3, 3, 2, 1, 1, 2, 3])
+        assert_array_equal(a, b)
+
+
+class TestWrap:
+    def test_check_simple(self):
+        a = np.arange(100)
+        a = np.pad(a, (25, 20), 'wrap')
+        b = np.array(
+            [75, 76, 77, 78, 79, 80, 81, 82, 83, 84,
+             85, 86, 87, 88, 89, 90, 91, 92, 93, 94,
+             95, 96, 97, 98, 99,
+
+             0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
+             10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
+             20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
+             30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
+             40, 41, 42, 43, 44, 45, 46, 47, 48, 49,
+             50, 51, 52, 53, 54, 55, 56, 57, 58, 59,
+             60, 61, 62, 63, 64, 65, 66, 67, 68, 69,
+             70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
+             80, 81, 82, 83, 84, 85, 86, 87, 88, 89,
+             90, 91, 92, 93, 94, 95, 96, 97, 98, 99,
+
+             0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
+             10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
+            )
+        assert_array_equal(a, b)
+
+    def test_check_large_pad(self):
+        a = np.arange(12)
+        a = np.reshape(a, (3, 4))
+        a = np.pad(a, (10, 12), 'wrap')
+        b = np.array(
+            [[10, 11, 8, 9, 10, 11, 8, 9, 10, 11, 8, 9, 10, 11, 8, 9, 10,
+              11, 8, 9, 10, 11, 8, 9, 10, 11],
+             [2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2,
+              3, 0, 1, 2, 3, 0, 1, 2, 3],
+             [6, 7, 4, 5, 6, 7, 4, 5, 6, 7, 4, 5, 6, 7, 4, 5, 6,
+              7, 4, 5, 6, 7, 4, 5, 6, 7],
+             [10, 11, 8, 9, 10, 11, 8, 9, 10, 11, 8, 9, 10, 11, 8, 9, 10,
+              11, 8, 9, 10, 11, 8, 9, 10, 11],
+             [2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2,
+              3, 0, 1, 2, 3, 0, 1, 2, 3],
+             [6, 7, 4, 5, 6, 7, 4, 5, 6, 7, 4, 5, 6, 7, 4, 5, 6,
+              7, 4, 5, 6, 7, 4, 5, 6, 7],
+             [10, 11, 8, 9, 10, 11, 8, 9, 10, 11, 8, 9, 10, 11, 8, 9, 10,
+              11, 8, 9, 10, 11, 8, 9, 10, 11],
+             [2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2,
+              3, 0, 1, 2, 3, 0, 1, 2, 3],
+             [6, 7, 4, 5, 6, 7, 4, 5, 6, 7, 4, 5, 6, 7, 4, 5, 6,
+              7, 4, 5, 6, 7, 4, 5, 6, 7],
+             [10, 11, 8, 9, 10, 11, 8, 9, 10, 11, 8, 9, 10, 11, 8, 9, 10,
+              11, 8, 9, 10, 11, 8, 9, 10, 11],
+
+             [2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2,
+              3, 0, 1, 2, 3, 0, 1, 2, 3],
+             [6, 7, 4, 5, 6, 7, 4, 5, 6, 7, 4, 5, 6, 7, 4, 5, 6,
+              7, 4, 5, 6, 7, 4, 5, 6, 7],
+             [10, 11, 8, 9, 10, 11, 8, 9, 10, 11, 8, 9, 10, 11, 8, 9, 10,
+              11, 8, 9, 10, 11, 8, 9, 10, 11],
+
+             [2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2,
+              3, 0, 1, 2, 3, 0, 1, 2, 3],
+             [6, 7, 4, 5, 6, 7, 4, 5, 6, 7, 4, 5, 6, 7, 4, 5, 6,
+              7, 4, 5, 6, 7, 4, 5, 6, 7],
+             [10, 11, 8, 9, 10, 11, 8, 9, 10, 11, 8, 9, 10, 11, 8, 9, 10,
+              11, 8, 9, 10, 11, 8, 9, 10, 11],
+             [2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2,
+              3, 0, 1, 2, 3, 0, 1, 2, 3],
+             [6, 7, 4, 5, 6, 7, 4, 5, 6, 7, 4, 5, 6, 7, 4, 5, 6,
+              7, 4, 5, 6, 7, 4, 5, 6, 7],
+             [10, 11, 8, 9, 10, 11, 8, 9, 10, 11, 8, 9, 10, 11, 8, 9, 10,
+              11, 8, 9, 10, 11, 8, 9, 10, 11],
+             [2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2,
+              3, 0, 1, 2, 3, 0, 1, 2, 3],
+             [6, 7, 4, 5, 6, 7, 4, 5, 6, 7, 4, 5, 6, 7, 4, 5, 6,
+              7, 4, 5, 6, 7, 4, 5, 6, 7],
+             [10, 11, 8, 9, 10, 11, 8, 9, 10, 11, 8, 9, 10, 11, 8, 9, 10,
+              11, 8, 9, 10, 11, 8, 9, 10, 11],
+             [2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2,
+              3, 0, 1, 2, 3, 0, 1, 2, 3],
+             [6, 7, 4, 5, 6, 7, 4, 5, 6, 7, 4, 5, 6, 7, 4, 5, 6,
+              7, 4, 5, 6, 7, 4, 5, 6, 7],
+             [10, 11, 8, 9, 10, 11, 8, 9, 10, 11, 8, 9, 10, 11, 8, 9, 10,
+              11, 8, 9, 10, 11, 8, 9, 10, 11]]
+            )
+        assert_array_equal(a, b)
+
+    def test_check_01(self):
+        a = np.pad([1, 2, 3], 3, 'wrap')
+        b = np.array([1, 2, 3, 1, 2, 3, 1, 2, 3])
+        assert_array_equal(a, b)
+
+    def test_check_02(self):
+        a = np.pad([1, 2, 3], 4, 'wrap')
+        b = np.array([3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1])
+        assert_array_equal(a, b)
+
+    def test_pad_with_zero(self):
+        a = np.ones((3, 5))
+        b = np.pad(a, (0, 5), mode="wrap")
+        assert_array_equal(a, b[:-5, :-5])
+
+    def test_repeated_wrapping(self):
+        """
+        Check wrapping on each side individually if the wrapped area is longer
+        than the original array.
+        """
+        a = np.arange(5)
+        b = np.pad(a, (12, 0), mode="wrap")
+        assert_array_equal(np.r_[a, a, a, a][3:], b)
+
+        a = np.arange(5)
+        b = np.pad(a, (0, 12), mode="wrap")
+        assert_array_equal(np.r_[a, a, a, a][:-3], b)
+    
+    def test_repeated_wrapping_multiple_origin(self):
+        """
+        Assert that 'wrap' pads only with multiples of the original area if
+        the pad width is larger than the original array.
+        """
+        a = np.arange(4).reshape(2, 2)
+        a = np.pad(a, [(1, 3), (3, 1)], mode='wrap')
+        b = np.array(
+            [[3, 2, 3, 2, 3, 2],
+             [1, 0, 1, 0, 1, 0],
+             [3, 2, 3, 2, 3, 2],
+             [1, 0, 1, 0, 1, 0],
+             [3, 2, 3, 2, 3, 2],
+             [1, 0, 1, 0, 1, 0]]
+        )
+        assert_array_equal(a, b)
+
+
+class TestEdge:
+    def test_check_simple(self):
+        a = np.arange(12)
+        a = np.reshape(a, (4, 3))
+        a = np.pad(a, ((2, 3), (3, 2)), 'edge')
+        b = np.array(
+            [[0, 0, 0, 0, 1, 2, 2, 2],
+             [0, 0, 0, 0, 1, 2, 2, 2],
+
+             [0, 0, 0, 0, 1, 2, 2, 2],
+             [3, 3, 3, 3, 4, 5, 5, 5],
+             [6, 6, 6, 6, 7, 8, 8, 8],
+             [9, 9, 9, 9, 10, 11, 11, 11],
+
+             [9, 9, 9, 9, 10, 11, 11, 11],
+             [9, 9, 9, 9, 10, 11, 11, 11],
+             [9, 9, 9, 9, 10, 11, 11, 11]]
+            )
+        assert_array_equal(a, b)
+
+    def test_check_width_shape_1_2(self):
+        # Check a pad_width of the form ((1, 2),).
+        # Regression test for issue gh-7808.
+        a = np.array([1, 2, 3])
+        padded = np.pad(a, ((1, 2),), 'edge')
+        expected = np.array([1, 1, 2, 3, 3, 3])
+        assert_array_equal(padded, expected)
+
+        a = np.array([[1, 2, 3], [4, 5, 6]])
+        padded = np.pad(a, ((1, 2),), 'edge')
+        expected = np.pad(a, ((1, 2), (1, 2)), 'edge')
+        assert_array_equal(padded, expected)
+
+        a = np.arange(24).reshape(2, 3, 4)
+        padded = np.pad(a, ((1, 2),), 'edge')
+        expected = np.pad(a, ((1, 2), (1, 2), (1, 2)), 'edge')
+        assert_array_equal(padded, expected)
+
+
+class TestEmpty:
+    def test_simple(self):
+        arr = np.arange(24).reshape(4, 6)
+        result = np.pad(arr, [(2, 3), (3, 1)], mode="empty")
+        assert result.shape == (9, 10)
+        assert_equal(arr, result[2:-3, 3:-1])
+
+    def test_pad_empty_dimension(self):
+        arr = np.zeros((3, 0, 2))
+        result = np.pad(arr, [(0,), (2,), (1,)], mode="empty")
+        assert result.shape == (3, 4, 4)
+
+
+def test_legacy_vector_functionality():
+    def _padwithtens(vector, pad_width, iaxis, kwargs):
+        vector[:pad_width[0]] = 10
+        vector[-pad_width[1]:] = 10
+
+    a = np.arange(6).reshape(2, 3)
+    a = np.pad(a, 2, _padwithtens)
+    b = np.array(
+        [[10, 10, 10, 10, 10, 10, 10],
+         [10, 10, 10, 10, 10, 10, 10],
+
+         [10, 10,  0,  1,  2, 10, 10],
+         [10, 10,  3,  4,  5, 10, 10],
+
+         [10, 10, 10, 10, 10, 10, 10],
+         [10, 10, 10, 10, 10, 10, 10]]
+        )
+    assert_array_equal(a, b)
+
+
+def test_unicode_mode():
+    a = np.pad([1], 2, mode='constant')
+    b = np.array([0, 0, 1, 0, 0])
+    assert_array_equal(a, b)
+
+
+@pytest.mark.parametrize("mode", ["edge", "symmetric", "reflect", "wrap"])
+def test_object_input(mode):
+    # Regression test for issue gh-11395.
+    a = np.full((4, 3), fill_value=None)
+    pad_amt = ((2, 3), (3, 2))
+    b = np.full((9, 8), fill_value=None)
+    assert_array_equal(np.pad(a, pad_amt, mode=mode), b)
+
+
+class TestPadWidth:
+    @pytest.mark.parametrize("pad_width", [
+        (4, 5, 6, 7),
+        ((1,), (2,), (3,)),
+        ((1, 2), (3, 4), (5, 6)),
+        ((3, 4, 5), (0, 1, 2)),
+    ])
+    @pytest.mark.parametrize("mode", _all_modes.keys())
+    def test_misshaped_pad_width(self, pad_width, mode):
+        arr = np.arange(30).reshape((6, 5))
+        match = "operands could not be broadcast together"
+        with pytest.raises(ValueError, match=match):
+            np.pad(arr, pad_width, mode)
+
+    @pytest.mark.parametrize("mode", _all_modes.keys())
+    def test_misshaped_pad_width_2(self, mode):
+        arr = np.arange(30).reshape((6, 5))
+        match = ("input operand has more dimensions than allowed by the axis "
+                 "remapping")
+        with pytest.raises(ValueError, match=match):
+            np.pad(arr, (((3,), (4,), (5,)), ((0,), (1,), (2,))), mode)
+
+    @pytest.mark.parametrize(
+        "pad_width", [-2, (-2,), (3, -1), ((5, 2), (-2, 3)), ((-4,), (2,))])
+    @pytest.mark.parametrize("mode", _all_modes.keys())
+    def test_negative_pad_width(self, pad_width, mode):
+        arr = np.arange(30).reshape((6, 5))
+        match = "index can't contain negative values"
+        with pytest.raises(ValueError, match=match):
+            np.pad(arr, pad_width, mode)
+
+    @pytest.mark.parametrize("pad_width, dtype", [
+        ("3", None),
+        ("word", None),
+        (None, None),
+        (object(), None),
+        (3.4, None),
+        (((2, 3, 4), (3, 2)), object),
+        (complex(1, -1), None),
+        (((-2.1, 3), (3, 2)), None),
+    ])
+    @pytest.mark.parametrize("mode", _all_modes.keys())
+    def test_bad_type(self, pad_width, dtype, mode):
+        arr = np.arange(30).reshape((6, 5))
+        match = "`pad_width` must be of integral type."
+        if dtype is not None:
+            # avoid DeprecationWarning when not specifying dtype
+            with pytest.raises(TypeError, match=match):
+                np.pad(arr, np.array(pad_width, dtype=dtype), mode)
+        else:
+            with pytest.raises(TypeError, match=match):
+                np.pad(arr, pad_width, mode)
+            with pytest.raises(TypeError, match=match):
+                np.pad(arr, np.array(pad_width), mode)
+
+    def test_pad_width_as_ndarray(self):
+        a = np.arange(12)
+        a = np.reshape(a, (4, 3))
+        a = np.pad(a, np.array(((2, 3), (3, 2))), 'edge')
+        b = np.array(
+            [[0,  0,  0,    0,  1,  2,    2,  2],
+             [0,  0,  0,    0,  1,  2,    2,  2],
+
+             [0,  0,  0,    0,  1,  2,    2,  2],
+             [3,  3,  3,    3,  4,  5,    5,  5],
+             [6,  6,  6,    6,  7,  8,    8,  8],
+             [9,  9,  9,    9, 10, 11,   11, 11],
+
+             [9,  9,  9,    9, 10, 11,   11, 11],
+             [9,  9,  9,    9, 10, 11,   11, 11],
+             [9,  9,  9,    9, 10, 11,   11, 11]]
+            )
+        assert_array_equal(a, b)
+
+    @pytest.mark.parametrize("pad_width", [0, (0, 0), ((0, 0), (0, 0))])
+    @pytest.mark.parametrize("mode", _all_modes.keys())
+    def test_zero_pad_width(self, pad_width, mode):
+        arr = np.arange(30).reshape(6, 5)
+        assert_array_equal(arr, np.pad(arr, pad_width, mode=mode))
+
+
+@pytest.mark.parametrize("mode", _all_modes.keys())
+def test_kwargs(mode):
+    """Test behavior of pad's kwargs for the given mode."""
+    allowed = _all_modes[mode]
+    not_allowed = {}
+    for kwargs in _all_modes.values():
+        if kwargs != allowed:
+            not_allowed.update(kwargs)
+    # Test if allowed keyword arguments pass
+    np.pad([1, 2, 3], 1, mode, **allowed)
+    # Test if prohibited keyword arguments of other modes raise an error
+    for key, value in not_allowed.items():
+        match = "unsupported keyword arguments for mode '{}'".format(mode)
+        with pytest.raises(ValueError, match=match):
+            np.pad([1, 2, 3], 1, mode, **{key: value})
+
+
+def test_constant_zero_default():
+    arr = np.array([1, 1])
+    assert_array_equal(np.pad(arr, 2), [0, 0, 1, 1, 0, 0])
+
+
+@pytest.mark.parametrize("mode", [1, "const", object(), None, True, False])
+def test_unsupported_mode(mode):
+    match= "mode '{}' is not supported".format(mode)
+    with pytest.raises(ValueError, match=match):
+        np.pad([1, 2, 3], 4, mode=mode)
+
+
+@pytest.mark.parametrize("mode", _all_modes.keys())
+def test_non_contiguous_array(mode):
+    arr = np.arange(24).reshape(4, 6)[::2, ::2]
+    result = np.pad(arr, (2, 3), mode)
+    assert result.shape == (7, 8)
+    assert_equal(result[2:-3, 2:-3], arr)
+
+
+@pytest.mark.parametrize("mode", _all_modes.keys())
+def test_memory_layout_persistence(mode):
+    """Test if C and F order is preserved for all pad modes."""
+    x = np.ones((5, 10), order='C')
+    assert np.pad(x, 5, mode).flags["C_CONTIGUOUS"]
+    x = np.ones((5, 10), order='F')
+    assert np.pad(x, 5, mode).flags["F_CONTIGUOUS"]
+
+
+@pytest.mark.parametrize("dtype", _numeric_dtypes)
+@pytest.mark.parametrize("mode", _all_modes.keys())
+def test_dtype_persistence(dtype, mode):
+    arr = np.zeros((3, 2, 1), dtype=dtype)
+    result = np.pad(arr, 1, mode=mode)
+    assert result.dtype == dtype
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/tests/test_arraysetops.py b/venv/lib/python3.12/site-packages/numpy/lib/tests/test_arraysetops.py
new file mode 100644
index 00000000..b613fa3e
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/lib/tests/test_arraysetops.py
@@ -0,0 +1,1000 @@
+"""Test functions for 1D array set operations.
+
+"""
+import numpy as np
+
+from numpy import (
+    ediff1d, intersect1d, setxor1d, union1d, setdiff1d, unique, isin
+    )
+from numpy.exceptions import AxisError
+from numpy.testing import (assert_array_equal, assert_equal,
+                           assert_raises, assert_raises_regex)
+import pytest
+
+
+class TestSetOps:
+
+    def test_intersect1d(self):
+        # unique inputs
+        a = np.array([5, 7, 1, 2])
+        b = np.array([2, 4, 3, 1, 5])
+
+        ec = np.array([1, 2, 5])
+        c = intersect1d(a, b, assume_unique=True)
+        assert_array_equal(c, ec)
+
+        # non-unique inputs
+        a = np.array([5, 5, 7, 1, 2])
+        b = np.array([2, 1, 4, 3, 3, 1, 5])
+
+        ed = np.array([1, 2, 5])
+        c = intersect1d(a, b)
+        assert_array_equal(c, ed)
+        assert_array_equal([], intersect1d([], []))
+
+    def test_intersect1d_array_like(self):
+        # See gh-11772
+        class Test:
+            def __array__(self, dtype=None, copy=None):
+                return np.arange(3)
+
+        a = Test()
+        res = intersect1d(a, a)
+        assert_array_equal(res, a)
+        res = intersect1d([1, 2, 3], [1, 2, 3])
+        assert_array_equal(res, [1, 2, 3])
+
+    def test_intersect1d_indices(self):
+        # unique inputs
+        a = np.array([1, 2, 3, 4])
+        b = np.array([2, 1, 4, 6])
+        c, i1, i2 = intersect1d(a, b, assume_unique=True, return_indices=True)
+        ee = np.array([1, 2, 4])
+        assert_array_equal(c, ee)
+        assert_array_equal(a[i1], ee)
+        assert_array_equal(b[i2], ee)
+
+        # non-unique inputs
+        a = np.array([1, 2, 2, 3, 4, 3, 2])
+        b = np.array([1, 8, 4, 2, 2, 3, 2, 3])
+        c, i1, i2 = intersect1d(a, b, return_indices=True)
+        ef = np.array([1, 2, 3, 4])
+        assert_array_equal(c, ef)
+        assert_array_equal(a[i1], ef)
+        assert_array_equal(b[i2], ef)
+
+        # non1d, unique inputs
+        a = np.array([[2, 4, 5, 6], [7, 8, 1, 15]])
+        b = np.array([[3, 2, 7, 6], [10, 12, 8, 9]])
+        c, i1, i2 = intersect1d(a, b, assume_unique=True, return_indices=True)
+        ui1 = np.unravel_index(i1, a.shape)
+        ui2 = np.unravel_index(i2, b.shape)
+        ea = np.array([2, 6, 7, 8])
+        assert_array_equal(ea, a[ui1])
+        assert_array_equal(ea, b[ui2])
+
+        # non1d, not assumed to be uniqueinputs
+        a = np.array([[2, 4, 5, 6, 6], [4, 7, 8, 7, 2]])
+        b = np.array([[3, 2, 7, 7], [10, 12, 8, 7]])
+        c, i1, i2 = intersect1d(a, b, return_indices=True)
+        ui1 = np.unravel_index(i1, a.shape)
+        ui2 = np.unravel_index(i2, b.shape)
+        ea = np.array([2, 7, 8])
+        assert_array_equal(ea, a[ui1])
+        assert_array_equal(ea, b[ui2])
+
+    def test_setxor1d(self):
+        a = np.array([5, 7, 1, 2])
+        b = np.array([2, 4, 3, 1, 5])
+
+        ec = np.array([3, 4, 7])
+        c = setxor1d(a, b)
+        assert_array_equal(c, ec)
+
+        a = np.array([1, 2, 3])
+        b = np.array([6, 5, 4])
+
+        ec = np.array([1, 2, 3, 4, 5, 6])
+        c = setxor1d(a, b)
+        assert_array_equal(c, ec)
+
+        a = np.array([1, 8, 2, 3])
+        b = np.array([6, 5, 4, 8])
+
+        ec = np.array([1, 2, 3, 4, 5, 6])
+        c = setxor1d(a, b)
+        assert_array_equal(c, ec)
+
+        assert_array_equal([], setxor1d([], []))
+
+    def test_setxor1d_unique(self):
+        a = np.array([1, 8, 2, 3])
+        b = np.array([6, 5, 4, 8])
+
+        ec = np.array([1, 2, 3, 4, 5, 6])
+        c = setxor1d(a, b, assume_unique=True)
+        assert_array_equal(c, ec)
+
+        a = np.array([[1], [8], [2], [3]])
+        b = np.array([[6, 5], [4, 8]])
+
+        ec = np.array([1, 2, 3, 4, 5, 6])
+        c = setxor1d(a, b, assume_unique=True)
+        assert_array_equal(c, ec)
+
+    def test_ediff1d(self):
+        zero_elem = np.array([])
+        one_elem = np.array([1])
+        two_elem = np.array([1, 2])
+
+        assert_array_equal([], ediff1d(zero_elem))
+        assert_array_equal([0], ediff1d(zero_elem, to_begin=0))
+        assert_array_equal([0], ediff1d(zero_elem, to_end=0))
+        assert_array_equal([-1, 0], ediff1d(zero_elem, to_begin=-1, to_end=0))
+        assert_array_equal([], ediff1d(one_elem))
+        assert_array_equal([1], ediff1d(two_elem))
+        assert_array_equal([7, 1, 9], ediff1d(two_elem, to_begin=7, to_end=9))
+        assert_array_equal([5, 6, 1, 7, 8],
+                           ediff1d(two_elem, to_begin=[5, 6], to_end=[7, 8]))
+        assert_array_equal([1, 9], ediff1d(two_elem, to_end=9))
+        assert_array_equal([1, 7, 8], ediff1d(two_elem, to_end=[7, 8]))
+        assert_array_equal([7, 1], ediff1d(two_elem, to_begin=7))
+        assert_array_equal([5, 6, 1], ediff1d(two_elem, to_begin=[5, 6]))
+
+    @pytest.mark.parametrize("ary, prepend, append, expected", [
+        # should fail because trying to cast
+        # np.nan standard floating point value
+        # into an integer array:
+        (np.array([1, 2, 3], dtype=np.int64),
+         None,
+         np.nan,
+         'to_end'),
+        # should fail because attempting
+        # to downcast to int type:
+        (np.array([1, 2, 3], dtype=np.int64),
+         np.array([5, 7, 2], dtype=np.float32),
+         None,
+         'to_begin'),
+        # should fail because attempting to cast
+        # two special floating point values
+        # to integers (on both sides of ary),
+        # `to_begin` is in the error message as the impl checks this first:
+        (np.array([1., 3., 9.], dtype=np.int8),
+         np.nan,
+         np.nan,
+         'to_begin'),
+         ])
+    def test_ediff1d_forbidden_type_casts(self, ary, prepend, append, expected):
+        # verify resolution of gh-11490
+
+        # specifically, raise an appropriate
+        # Exception when attempting to append or
+        # prepend with an incompatible type
+        msg = 'dtype of `{}` must be compatible'.format(expected)
+        with assert_raises_regex(TypeError, msg):
+            ediff1d(ary=ary,
+                    to_end=append,
+                    to_begin=prepend)
+
+    @pytest.mark.parametrize(
+        "ary,prepend,append,expected",
+        [
+         (np.array([1, 2, 3], dtype=np.int16),
+          2**16,  # will be cast to int16 under same kind rule.
+          2**16 + 4,
+          np.array([0, 1, 1, 4], dtype=np.int16)),
+         (np.array([1, 2, 3], dtype=np.float32),
+          np.array([5], dtype=np.float64),
+          None,
+          np.array([5, 1, 1], dtype=np.float32)),
+         (np.array([1, 2, 3], dtype=np.int32),
+          0,
+          0,
+          np.array([0, 1, 1, 0], dtype=np.int32)),
+         (np.array([1, 2, 3], dtype=np.int64),
+          3,
+          -9,
+          np.array([3, 1, 1, -9], dtype=np.int64)),
+        ]
+    )
+    def test_ediff1d_scalar_handling(self,
+                                     ary,
+                                     prepend,
+                                     append,
+                                     expected):
+        # maintain backwards-compatibility
+        # of scalar prepend / append behavior
+        # in ediff1d following fix for gh-11490
+        actual = np.ediff1d(ary=ary,
+                            to_end=append,
+                            to_begin=prepend)
+        assert_equal(actual, expected)
+        assert actual.dtype == expected.dtype
+
+    @pytest.mark.parametrize("kind", [None, "sort", "table"])
+    def test_isin(self, kind):
+        def _isin_slow(a, b):
+            b = np.asarray(b).flatten().tolist()
+            return a in b
+        isin_slow = np.vectorize(_isin_slow, otypes=[bool], excluded={1})
+
+        def assert_isin_equal(a, b):
+            x = isin(a, b, kind=kind)
+            y = isin_slow(a, b)
+            assert_array_equal(x, y)
+
+        # multidimensional arrays in both arguments
+        a = np.arange(24).reshape([2, 3, 4])
+        b = np.array([[10, 20, 30], [0, 1, 3], [11, 22, 33]])
+        assert_isin_equal(a, b)
+
+        # array-likes as both arguments
+        c = [(9, 8), (7, 6)]
+        d = (9, 7)
+        assert_isin_equal(c, d)
+
+        # zero-d array:
+        f = np.array(3)
+        assert_isin_equal(f, b)
+        assert_isin_equal(a, f)
+        assert_isin_equal(f, f)
+
+        # scalar:
+        assert_isin_equal(5, b)
+        assert_isin_equal(a, 6)
+        assert_isin_equal(5, 6)
+
+        # empty array-like:
+        if kind != "table":
+            # An empty list will become float64,
+            # which is invalid for kind="table"
+            x = []
+            assert_isin_equal(x, b)
+            assert_isin_equal(a, x)
+            assert_isin_equal(x, x)
+
+        # empty array with various types:
+        for dtype in [bool, np.int64, np.float64]:
+            if kind == "table" and dtype == np.float64:
+                continue
+
+            if dtype in {np.int64, np.float64}:
+                ar = np.array([10, 20, 30], dtype=dtype)
+            elif dtype in {bool}:
+                ar = np.array([True, False, False])
+
+            empty_array = np.array([], dtype=dtype)
+
+            assert_isin_equal(empty_array, ar)
+            assert_isin_equal(ar, empty_array)
+            assert_isin_equal(empty_array, empty_array)
+
+    @pytest.mark.parametrize("kind", [None, "sort", "table"])
+    def test_isin(self, kind):
+        # we use two different sizes for the b array here to test the
+        # two different paths in isin().
+        for mult in (1, 10):
+            # One check without np.array to make sure lists are handled correct
+            a = [5, 7, 1, 2]
+            b = [2, 4, 3, 1, 5] * mult
+            ec = np.array([True, False, True, True])
+            c = isin(a, b, assume_unique=True, kind=kind)
+            assert_array_equal(c, ec)
+
+            a[0] = 8
+            ec = np.array([False, False, True, True])
+            c = isin(a, b, assume_unique=True, kind=kind)
+            assert_array_equal(c, ec)
+
+            a[0], a[3] = 4, 8
+            ec = np.array([True, False, True, False])
+            c = isin(a, b, assume_unique=True, kind=kind)
+            assert_array_equal(c, ec)
+
+            a = np.array([5, 4, 5, 3, 4, 4, 3, 4, 3, 5, 2, 1, 5, 5])
+            b = [2, 3, 4] * mult
+            ec = [False, True, False, True, True, True, True, True, True,
+                  False, True, False, False, False]
+            c = isin(a, b, kind=kind)
+            assert_array_equal(c, ec)
+
+            b = b + [5, 5, 4] * mult
+            ec = [True, True, True, True, True, True, True, True, True, True,
+                  True, False, True, True]
+            c = isin(a, b, kind=kind)
+            assert_array_equal(c, ec)
+
+            a = np.array([5, 7, 1, 2])
+            b = np.array([2, 4, 3, 1, 5] * mult)
+            ec = np.array([True, False, True, True])
+            c = isin(a, b, kind=kind)
+            assert_array_equal(c, ec)
+
+            a = np.array([5, 7, 1, 1, 2])
+            b = np.array([2, 4, 3, 3, 1, 5] * mult)
+            ec = np.array([True, False, True, True, True])
+            c = isin(a, b, kind=kind)
+            assert_array_equal(c, ec)
+
+            a = np.array([5, 5])
+            b = np.array([2, 2] * mult)
+            ec = np.array([False, False])
+            c = isin(a, b, kind=kind)
+            assert_array_equal(c, ec)
+
+        a = np.array([5])
+        b = np.array([2])
+        ec = np.array([False])
+        c = isin(a, b, kind=kind)
+        assert_array_equal(c, ec)
+
+        if kind in {None, "sort"}:
+            assert_array_equal(isin([], [], kind=kind), [])
+
+    def test_isin_char_array(self):
+        a = np.array(['a', 'b', 'c', 'd', 'e', 'c', 'e', 'b'])
+        b = np.array(['a', 'c'])
+
+        ec = np.array([True, False, True, False, False, True, False, False])
+        c = isin(a, b)
+
+        assert_array_equal(c, ec)
+
+    @pytest.mark.parametrize("kind", [None, "sort", "table"])
+    def test_isin_invert(self, kind):
+        "Test isin's invert parameter"
+        # We use two different sizes for the b array here to test the
+        # two different paths in isin().
+        for mult in (1, 10):
+            a = np.array([5, 4, 5, 3, 4, 4, 3, 4, 3, 5, 2, 1, 5, 5])
+            b = [2, 3, 4] * mult
+            assert_array_equal(np.invert(isin(a, b, kind=kind)),
+                               isin(a, b, invert=True, kind=kind))
+
+        # float:
+        if kind in {None, "sort"}:
+            for mult in (1, 10):
+                a = np.array([5, 4, 5, 3, 4, 4, 3, 4, 3, 5, 2, 1, 5, 5],
+                            dtype=np.float32)
+                b = [2, 3, 4] * mult
+                b = np.array(b, dtype=np.float32)
+                assert_array_equal(np.invert(isin(a, b, kind=kind)),
+                                   isin(a, b, invert=True, kind=kind))
+
+    def test_isin_hit_alternate_algorithm(self):
+        """Hit the standard isin code with integers"""
+        # Need extreme range to hit standard code
+        # This hits it without the use of kind='table'
+        a = np.array([5, 4, 5, 3, 4, 4, 1e9], dtype=np.int64)
+        b = np.array([2, 3, 4, 1e9], dtype=np.int64)
+        expected = np.array([0, 1, 0, 1, 1, 1, 1], dtype=bool)
+        assert_array_equal(expected, isin(a, b))
+        assert_array_equal(np.invert(expected), isin(a, b, invert=True))
+
+        a = np.array([5, 7, 1, 2], dtype=np.int64)
+        b = np.array([2, 4, 3, 1, 5, 1e9], dtype=np.int64)
+        ec = np.array([True, False, True, True])
+        c = isin(a, b, assume_unique=True)
+        assert_array_equal(c, ec)
+
+    @pytest.mark.parametrize("kind", [None, "sort", "table"])
+    def test_isin_boolean(self, kind):
+        """Test that isin works for boolean input"""
+        a = np.array([True, False])
+        b = np.array([False, False, False])
+        expected = np.array([False, True])
+        assert_array_equal(expected,
+                           isin(a, b, kind=kind))
+        assert_array_equal(np.invert(expected),
+                           isin(a, b, invert=True, kind=kind))
+
+    @pytest.mark.parametrize("kind", [None, "sort"])
+    def test_isin_timedelta(self, kind):
+        """Test that isin works for timedelta input"""
+        rstate = np.random.RandomState(0)
+        a = rstate.randint(0, 100, size=10)
+        b = rstate.randint(0, 100, size=10)
+        truth = isin(a, b)
+        a_timedelta = a.astype("timedelta64[s]")
+        b_timedelta = b.astype("timedelta64[s]")
+        assert_array_equal(truth, isin(a_timedelta, b_timedelta, kind=kind))
+
+    def test_isin_table_timedelta_fails(self):
+        a = np.array([0, 1, 2], dtype="timedelta64[s]")
+        b = a
+        # Make sure it raises a value error:
+        with pytest.raises(ValueError):
+            isin(a, b, kind="table")
+
+    @pytest.mark.parametrize(
+        "dtype1,dtype2",
+        [
+            (np.int8, np.int16),
+            (np.int16, np.int8),
+            (np.uint8, np.uint16),
+            (np.uint16, np.uint8),
+            (np.uint8, np.int16),
+            (np.int16, np.uint8),
+            (np.uint64, np.int64),
+        ]
+    )
+    @pytest.mark.parametrize("kind", [None, "sort", "table"])
+    def test_isin_mixed_dtype(self, dtype1, dtype2, kind):
+        """Test that isin works as expected for mixed dtype input."""
+        is_dtype2_signed = np.issubdtype(dtype2, np.signedinteger)
+        ar1 = np.array([0, 0, 1, 1], dtype=dtype1)
+
+        if is_dtype2_signed:
+            ar2 = np.array([-128, 0, 127], dtype=dtype2)
+        else:
+            ar2 = np.array([127, 0, 255], dtype=dtype2)
+
+        expected = np.array([True, True, False, False])
+
+        expect_failure = kind == "table" and (
+            dtype1 == np.int16 and dtype2 == np.int8)
+
+        if expect_failure:
+            with pytest.raises(RuntimeError, match="exceed the maximum"):
+                isin(ar1, ar2, kind=kind)
+        else:
+            assert_array_equal(isin(ar1, ar2, kind=kind), expected)
+
+    @pytest.mark.parametrize("data", [
+        np.array([2**63, 2**63+1], dtype=np.uint64),
+        np.array([-2**62, -2**62-1], dtype=np.int64),
+    ])
+    @pytest.mark.parametrize("kind", [None, "sort", "table"])
+    def test_isin_mixed_huge_vals(self, kind, data):
+        """Test values outside intp range (negative ones if 32bit system)"""
+        query = data[1]
+        res = np.isin(data, query, kind=kind)
+        assert_array_equal(res, [False, True])
+        # Also check that nothing weird happens for values can't possibly
+        # in range.
+        data = data.astype(np.int32)  # clearly different values
+        res = np.isin(data, query, kind=kind)
+        assert_array_equal(res, [False, False])
+
+    @pytest.mark.parametrize("kind", [None, "sort", "table"])
+    def test_isin_mixed_boolean(self, kind):
+        """Test that isin works as expected for bool/int input."""
+        for dtype in np.typecodes["AllInteger"]:
+            a = np.array([True, False, False], dtype=bool)
+            b = np.array([0, 0, 0, 0], dtype=dtype)
+            expected = np.array([False, True, True], dtype=bool)
+            assert_array_equal(isin(a, b, kind=kind), expected)
+
+            a, b = b, a
+            expected = np.array([True, True, True, True], dtype=bool)
+            assert_array_equal(isin(a, b, kind=kind), expected)
+
+    def test_isin_first_array_is_object(self):
+        ar1 = [None]
+        ar2 = np.array([1]*10)
+        expected = np.array([False])
+        result = np.isin(ar1, ar2)
+        assert_array_equal(result, expected)
+
+    def test_isin_second_array_is_object(self):
+        ar1 = 1
+        ar2 = np.array([None]*10)
+        expected = np.array([False])
+        result = np.isin(ar1, ar2)
+        assert_array_equal(result, expected)
+
+    def test_isin_both_arrays_are_object(self):
+        ar1 = [None]
+        ar2 = np.array([None]*10)
+        expected = np.array([True])
+        result = np.isin(ar1, ar2)
+        assert_array_equal(result, expected)
+
+    def test_isin_both_arrays_have_structured_dtype(self):
+        # Test arrays of a structured data type containing an integer field
+        # and a field of dtype `object` allowing for arbitrary Python objects
+        dt = np.dtype([('field1', int), ('field2', object)])
+        ar1 = np.array([(1, None)], dtype=dt)
+        ar2 = np.array([(1, None)]*10, dtype=dt)
+        expected = np.array([True])
+        result = np.isin(ar1, ar2)
+        assert_array_equal(result, expected)
+
+    def test_isin_with_arrays_containing_tuples(self):
+        ar1 = np.array([(1,), 2], dtype=object)
+        ar2 = np.array([(1,), 2], dtype=object)
+        expected = np.array([True, True])
+        result = np.isin(ar1, ar2)
+        assert_array_equal(result, expected)
+        result = np.isin(ar1, ar2, invert=True)
+        assert_array_equal(result, np.invert(expected))
+
+        # An integer is added at the end of the array to make sure
+        # that the array builder will create the array with tuples
+        # and after it's created the integer is removed.
+        # There's a bug in the array constructor that doesn't handle
+        # tuples properly and adding the integer fixes that.
+        ar1 = np.array([(1,), (2, 1), 1], dtype=object)
+        ar1 = ar1[:-1]
+        ar2 = np.array([(1,), (2, 1), 1], dtype=object)
+        ar2 = ar2[:-1]
+        expected = np.array([True, True])
+        result = np.isin(ar1, ar2)
+        assert_array_equal(result, expected)
+        result = np.isin(ar1, ar2, invert=True)
+        assert_array_equal(result, np.invert(expected))
+
+        ar1 = np.array([(1,), (2, 3), 1], dtype=object)
+        ar1 = ar1[:-1]
+        ar2 = np.array([(1,), 2], dtype=object)
+        expected = np.array([True, False])
+        result = np.isin(ar1, ar2)
+        assert_array_equal(result, expected)
+        result = np.isin(ar1, ar2, invert=True)
+        assert_array_equal(result, np.invert(expected))
+
+    def test_isin_errors(self):
+        """Test that isin raises expected errors."""
+
+        # Error 1: `kind` is not one of 'sort' 'table' or None.
+        ar1 = np.array([1, 2, 3, 4, 5])
+        ar2 = np.array([2, 4, 6, 8, 10])
+        assert_raises(ValueError, isin, ar1, ar2, kind='quicksort')
+
+        # Error 2: `kind="table"` does not work for non-integral arrays.
+        obj_ar1 = np.array([1, 'a', 3, 'b', 5], dtype=object)
+        obj_ar2 = np.array([1, 'a', 3, 'b', 5], dtype=object)
+        assert_raises(ValueError, isin, obj_ar1, obj_ar2, kind='table')
+
+        for dtype in [np.int32, np.int64]:
+            ar1 = np.array([-1, 2, 3, 4, 5], dtype=dtype)
+            # The range of this array will overflow:
+            overflow_ar2 = np.array([-1, np.iinfo(dtype).max], dtype=dtype)
+
+            # Error 3: `kind="table"` will trigger a runtime error
+            #  if there is an integer overflow expected when computing the
+            #  range of ar2
+            assert_raises(
+                RuntimeError,
+                isin, ar1, overflow_ar2, kind='table'
+            )
+
+            # Non-error: `kind=None` will *not* trigger a runtime error
+            #  if there is an integer overflow, it will switch to
+            #  the `sort` algorithm.
+            result = np.isin(ar1, overflow_ar2, kind=None)
+            assert_array_equal(result, [True] + [False] * 4)
+            result = np.isin(ar1, overflow_ar2, kind='sort')
+            assert_array_equal(result, [True] + [False] * 4)
+
+    def test_union1d(self):
+        a = np.array([5, 4, 7, 1, 2])
+        b = np.array([2, 4, 3, 3, 2, 1, 5])
+
+        ec = np.array([1, 2, 3, 4, 5, 7])
+        c = union1d(a, b)
+        assert_array_equal(c, ec)
+
+        # Tests gh-10340, arguments to union1d should be
+        # flattened if they are not already 1D
+        x = np.array([[0, 1, 2], [3, 4, 5]])
+        y = np.array([0, 1, 2, 3, 4])
+        ez = np.array([0, 1, 2, 3, 4, 5])
+        z = union1d(x, y)
+        assert_array_equal(z, ez)
+
+        assert_array_equal([], union1d([], []))
+
+    def test_setdiff1d(self):
+        a = np.array([6, 5, 4, 7, 1, 2, 7, 4])
+        b = np.array([2, 4, 3, 3, 2, 1, 5])
+
+        ec = np.array([6, 7])
+        c = setdiff1d(a, b)
+        assert_array_equal(c, ec)
+
+        a = np.arange(21)
+        b = np.arange(19)
+        ec = np.array([19, 20])
+        c = setdiff1d(a, b)
+        assert_array_equal(c, ec)
+
+        assert_array_equal([], setdiff1d([], []))
+        a = np.array((), np.uint32)
+        assert_equal(setdiff1d(a, []).dtype, np.uint32)
+
+    def test_setdiff1d_unique(self):
+        a = np.array([3, 2, 1])
+        b = np.array([7, 5, 2])
+        expected = np.array([3, 1])
+        actual = setdiff1d(a, b, assume_unique=True)
+        assert_equal(actual, expected)
+
+    def test_setdiff1d_char_array(self):
+        a = np.array(['a', 'b', 'c'])
+        b = np.array(['a', 'b', 's'])
+        assert_array_equal(setdiff1d(a, b), np.array(['c']))
+
+    def test_manyways(self):
+        a = np.array([5, 7, 1, 2, 8])
+        b = np.array([9, 8, 2, 4, 3, 1, 5])
+
+        c1 = setxor1d(a, b)
+        aux1 = intersect1d(a, b)
+        aux2 = union1d(a, b)
+        c2 = setdiff1d(aux2, aux1)
+        assert_array_equal(c1, c2)
+
+
+class TestUnique:
+
+    def test_unique_1d(self):
+
+        def check_all(a, b, i1, i2, c, dt):
+            base_msg = 'check {0} failed for type {1}'
+
+            msg = base_msg.format('values', dt)
+            v = unique(a)
+            assert_array_equal(v, b, msg)
+
+            msg = base_msg.format('return_index', dt)
+            v, j = unique(a, True, False, False)
+            assert_array_equal(v, b, msg)
+            assert_array_equal(j, i1, msg)
+
+            msg = base_msg.format('return_inverse', dt)
+            v, j = unique(a, False, True, False)
+            assert_array_equal(v, b, msg)
+            assert_array_equal(j, i2, msg)
+
+            msg = base_msg.format('return_counts', dt)
+            v, j = unique(a, False, False, True)
+            assert_array_equal(v, b, msg)
+            assert_array_equal(j, c, msg)
+
+            msg = base_msg.format('return_index and return_inverse', dt)
+            v, j1, j2 = unique(a, True, True, False)
+            assert_array_equal(v, b, msg)
+            assert_array_equal(j1, i1, msg)
+            assert_array_equal(j2, i2, msg)
+
+            msg = base_msg.format('return_index and return_counts', dt)
+            v, j1, j2 = unique(a, True, False, True)
+            assert_array_equal(v, b, msg)
+            assert_array_equal(j1, i1, msg)
+            assert_array_equal(j2, c, msg)
+
+            msg = base_msg.format('return_inverse and return_counts', dt)
+            v, j1, j2 = unique(a, False, True, True)
+            assert_array_equal(v, b, msg)
+            assert_array_equal(j1, i2, msg)
+            assert_array_equal(j2, c, msg)
+
+            msg = base_msg.format(('return_index, return_inverse '
+                                   'and return_counts'), dt)
+            v, j1, j2, j3 = unique(a, True, True, True)
+            assert_array_equal(v, b, msg)
+            assert_array_equal(j1, i1, msg)
+            assert_array_equal(j2, i2, msg)
+            assert_array_equal(j3, c, msg)
+
+        a = [5, 7, 1, 2, 1, 5, 7]*10
+        b = [1, 2, 5, 7]
+        i1 = [2, 3, 0, 1]
+        i2 = [2, 3, 0, 1, 0, 2, 3]*10
+        c = np.multiply([2, 1, 2, 2], 10)
+
+        # test for numeric arrays
+        types = []
+        types.extend(np.typecodes['AllInteger'])
+        types.extend(np.typecodes['AllFloat'])
+        types.append('datetime64[D]')
+        types.append('timedelta64[D]')
+        for dt in types:
+            aa = np.array(a, dt)
+            bb = np.array(b, dt)
+            check_all(aa, bb, i1, i2, c, dt)
+
+        # test for object arrays
+        dt = 'O'
+        aa = np.empty(len(a), dt)
+        aa[:] = a
+        bb = np.empty(len(b), dt)
+        bb[:] = b
+        check_all(aa, bb, i1, i2, c, dt)
+
+        # test for structured arrays
+        dt = [('', 'i'), ('', 'i')]
+        aa = np.array(list(zip(a, a)), dt)
+        bb = np.array(list(zip(b, b)), dt)
+        check_all(aa, bb, i1, i2, c, dt)
+
+        # test for ticket #2799
+        aa = [1. + 0.j, 1 - 1.j, 1]
+        assert_array_equal(np.unique(aa), [1. - 1.j, 1. + 0.j])
+
+        # test for ticket #4785
+        a = [(1, 2), (1, 2), (2, 3)]
+        unq = [1, 2, 3]
+        inv = [[0, 1], [0, 1], [1, 2]]
+        a1 = unique(a)
+        assert_array_equal(a1, unq)
+        a2, a2_inv = unique(a, return_inverse=True)
+        assert_array_equal(a2, unq)
+        assert_array_equal(a2_inv, inv)
+
+        # test for chararrays with return_inverse (gh-5099)
+        a = np.char.chararray(5)
+        a[...] = ''
+        a2, a2_inv = np.unique(a, return_inverse=True)
+        assert_array_equal(a2_inv, np.zeros(5))
+
+        # test for ticket #9137
+        a = []
+        a1_idx = np.unique(a, return_index=True)[1]
+        a2_inv = np.unique(a, return_inverse=True)[1]
+        a3_idx, a3_inv = np.unique(a, return_index=True,
+                                   return_inverse=True)[1:]
+        assert_equal(a1_idx.dtype, np.intp)
+        assert_equal(a2_inv.dtype, np.intp)
+        assert_equal(a3_idx.dtype, np.intp)
+        assert_equal(a3_inv.dtype, np.intp)
+
+        # test for ticket 2111 - float
+        a = [2.0, np.nan, 1.0, np.nan]
+        ua = [1.0, 2.0, np.nan]
+        ua_idx = [2, 0, 1]
+        ua_inv = [1, 2, 0, 2]
+        ua_cnt = [1, 1, 2]
+        assert_equal(np.unique(a), ua)
+        assert_equal(np.unique(a, return_index=True), (ua, ua_idx))
+        assert_equal(np.unique(a, return_inverse=True), (ua, ua_inv))
+        assert_equal(np.unique(a, return_counts=True), (ua, ua_cnt))
+
+        # test for ticket 2111 - complex
+        a = [2.0-1j, np.nan, 1.0+1j, complex(0.0, np.nan), complex(1.0, np.nan)]
+        ua = [1.0+1j, 2.0-1j, complex(0.0, np.nan)]
+        ua_idx = [2, 0, 3]
+        ua_inv = [1, 2, 0, 2, 2]
+        ua_cnt = [1, 1, 3]
+        assert_equal(np.unique(a), ua)
+        assert_equal(np.unique(a, return_index=True), (ua, ua_idx))
+        assert_equal(np.unique(a, return_inverse=True), (ua, ua_inv))
+        assert_equal(np.unique(a, return_counts=True), (ua, ua_cnt))
+
+        # test for ticket 2111 - datetime64
+        nat = np.datetime64('nat')
+        a = [np.datetime64('2020-12-26'), nat, np.datetime64('2020-12-24'), nat]
+        ua = [np.datetime64('2020-12-24'), np.datetime64('2020-12-26'), nat]
+        ua_idx = [2, 0, 1]
+        ua_inv = [1, 2, 0, 2]
+        ua_cnt = [1, 1, 2]
+        assert_equal(np.unique(a), ua)
+        assert_equal(np.unique(a, return_index=True), (ua, ua_idx))
+        assert_equal(np.unique(a, return_inverse=True), (ua, ua_inv))
+        assert_equal(np.unique(a, return_counts=True), (ua, ua_cnt))
+
+        # test for ticket 2111 - timedelta
+        nat = np.timedelta64('nat')
+        a = [np.timedelta64(1, 'D'), nat, np.timedelta64(1, 'h'), nat]
+        ua = [np.timedelta64(1, 'h'), np.timedelta64(1, 'D'), nat]
+        ua_idx = [2, 0, 1]
+        ua_inv = [1, 2, 0, 2]
+        ua_cnt = [1, 1, 2]
+        assert_equal(np.unique(a), ua)
+        assert_equal(np.unique(a, return_index=True), (ua, ua_idx))
+        assert_equal(np.unique(a, return_inverse=True), (ua, ua_inv))
+        assert_equal(np.unique(a, return_counts=True), (ua, ua_cnt))
+
+        # test for gh-19300
+        all_nans = [np.nan] * 4
+        ua = [np.nan]
+        ua_idx = [0]
+        ua_inv = [0, 0, 0, 0]
+        ua_cnt = [4]
+        assert_equal(np.unique(all_nans), ua)
+        assert_equal(np.unique(all_nans, return_index=True), (ua, ua_idx))
+        assert_equal(np.unique(all_nans, return_inverse=True), (ua, ua_inv))
+        assert_equal(np.unique(all_nans, return_counts=True), (ua, ua_cnt))
+
+    def test_unique_axis_errors(self):
+        assert_raises(TypeError, self._run_axis_tests, object)
+        assert_raises(TypeError, self._run_axis_tests,
+                      [('a', int), ('b', object)])
+
+        assert_raises(AxisError, unique, np.arange(10), axis=2)
+        assert_raises(AxisError, unique, np.arange(10), axis=-2)
+
+    def test_unique_axis_list(self):
+        msg = "Unique failed on list of lists"
+        inp = [[0, 1, 0], [0, 1, 0]]
+        inp_arr = np.asarray(inp)
+        assert_array_equal(unique(inp, axis=0), unique(inp_arr, axis=0), msg)
+        assert_array_equal(unique(inp, axis=1), unique(inp_arr, axis=1), msg)
+
+    def test_unique_axis(self):
+        types = []
+        types.extend(np.typecodes['AllInteger'])
+        types.extend(np.typecodes['AllFloat'])
+        types.append('datetime64[D]')
+        types.append('timedelta64[D]')
+        types.append([('a', int), ('b', int)])
+        types.append([('a', int), ('b', float)])
+
+        for dtype in types:
+            self._run_axis_tests(dtype)
+
+        msg = 'Non-bitwise-equal booleans test failed'
+        data = np.arange(10, dtype=np.uint8).reshape(-1, 2).view(bool)
+        result = np.array([[False, True], [True, True]], dtype=bool)
+        assert_array_equal(unique(data, axis=0), result, msg)
+
+        msg = 'Negative zero equality test failed'
+        data = np.array([[-0.0, 0.0], [0.0, -0.0], [-0.0, 0.0], [0.0, -0.0]])
+        result = np.array([[-0.0, 0.0]])
+        assert_array_equal(unique(data, axis=0), result, msg)
+
+    @pytest.mark.parametrize("axis", [0, -1])
+    def test_unique_1d_with_axis(self, axis):
+        x = np.array([4, 3, 2, 3, 2, 1, 2, 2])
+        uniq = unique(x, axis=axis)
+        assert_array_equal(uniq, [1, 2, 3, 4])
+
+    @pytest.mark.parametrize("axis", [None, 0, -1])
+    def test_unique_inverse_with_axis(self, axis):
+        x = np.array([[4, 4, 3], [2, 2, 1], [2, 2, 1], [4, 4, 3]])
+        uniq, inv = unique(x, return_inverse=True, axis=axis)
+        assert_equal(inv.ndim, x.ndim if axis is None else 1)
+        assert_array_equal(x, np.take(uniq, inv, axis=axis))
+
+    def test_unique_axis_zeros(self):
+        # issue 15559
+        single_zero = np.empty(shape=(2, 0), dtype=np.int8)
+        uniq, idx, inv, cnt = unique(single_zero, axis=0, return_index=True,
+                                     return_inverse=True, return_counts=True)
+
+        # there's 1 element of shape (0,) along axis 0
+        assert_equal(uniq.dtype, single_zero.dtype)
+        assert_array_equal(uniq, np.empty(shape=(1, 0)))
+        assert_array_equal(idx, np.array([0]))
+        assert_array_equal(inv, np.array([0, 0]))
+        assert_array_equal(cnt, np.array([2]))
+
+        # there's 0 elements of shape (2,) along axis 1
+        uniq, idx, inv, cnt = unique(single_zero, axis=1, return_index=True,
+                                     return_inverse=True, return_counts=True)
+
+        assert_equal(uniq.dtype, single_zero.dtype)
+        assert_array_equal(uniq, np.empty(shape=(2, 0)))
+        assert_array_equal(idx, np.array([]))
+        assert_array_equal(inv, np.array([]))
+        assert_array_equal(cnt, np.array([]))
+
+        # test a "complicated" shape
+        shape = (0, 2, 0, 3, 0, 4, 0)
+        multiple_zeros = np.empty(shape=shape)
+        for axis in range(len(shape)):
+            expected_shape = list(shape)
+            if shape[axis] == 0:
+                expected_shape[axis] = 0
+            else:
+                expected_shape[axis] = 1
+
+            assert_array_equal(unique(multiple_zeros, axis=axis),
+                               np.empty(shape=expected_shape))
+
+    def test_unique_masked(self):
+        # issue 8664
+        x = np.array([64, 0, 1, 2, 3, 63, 63, 0, 0, 0, 1, 2, 0, 63, 0],
+                     dtype='uint8')
+        y = np.ma.masked_equal(x, 0)
+
+        v = np.unique(y)
+        v2, i, c = np.unique(y, return_index=True, return_counts=True)
+
+        msg = 'Unique returned different results when asked for index'
+        assert_array_equal(v.data, v2.data, msg)
+        assert_array_equal(v.mask, v2.mask, msg)
+
+    def test_unique_sort_order_with_axis(self):
+        # These tests fail if sorting along axis is done by treating subarrays
+        # as unsigned byte strings.  See gh-10495.
+        fmt = "sort order incorrect for integer type '%s'"
+        for dt in 'bhilq':
+            a = np.array([[-1], [0]], dt)
+            b = np.unique(a, axis=0)
+            assert_array_equal(a, b, fmt % dt)
+
+    def _run_axis_tests(self, dtype):
+        data = np.array([[0, 1, 0, 0],
+                         [1, 0, 0, 0],
+                         [0, 1, 0, 0],
+                         [1, 0, 0, 0]]).astype(dtype)
+
+        msg = 'Unique with 1d array and axis=0 failed'
+        result = np.array([0, 1])
+        assert_array_equal(unique(data), result.astype(dtype), msg)
+
+        msg = 'Unique with 2d array and axis=0 failed'
+        result = np.array([[0, 1, 0, 0], [1, 0, 0, 0]])
+        assert_array_equal(unique(data, axis=0), result.astype(dtype), msg)
+
+        msg = 'Unique with 2d array and axis=1 failed'
+        result = np.array([[0, 0, 1], [0, 1, 0], [0, 0, 1], [0, 1, 0]])
+        assert_array_equal(unique(data, axis=1), result.astype(dtype), msg)
+
+        msg = 'Unique with 3d array and axis=2 failed'
+        data3d = np.array([[[1, 1],
+                            [1, 0]],
+                           [[0, 1],
+                            [0, 0]]]).astype(dtype)
+        result = np.take(data3d, [1, 0], axis=2)
+        assert_array_equal(unique(data3d, axis=2), result, msg)
+
+        uniq, idx, inv, cnt = unique(data, axis=0, return_index=True,
+                                     return_inverse=True, return_counts=True)
+        msg = "Unique's return_index=True failed with axis=0"
+        assert_array_equal(data[idx], uniq, msg)
+        msg = "Unique's return_inverse=True failed with axis=0"
+        assert_array_equal(np.take(uniq, inv, axis=0), data)
+        msg = "Unique's return_counts=True failed with axis=0"
+        assert_array_equal(cnt, np.array([2, 2]), msg)
+
+        uniq, idx, inv, cnt = unique(data, axis=1, return_index=True,
+                                     return_inverse=True, return_counts=True)
+        msg = "Unique's return_index=True failed with axis=1"
+        assert_array_equal(data[:, idx], uniq)
+        msg = "Unique's return_inverse=True failed with axis=1"
+        assert_array_equal(np.take(uniq, inv, axis=1), data)
+        msg = "Unique's return_counts=True failed with axis=1"
+        assert_array_equal(cnt, np.array([2, 1, 1]), msg)
+
+    def test_unique_nanequals(self):
+        # issue 20326
+        a = np.array([1, 1, np.nan, np.nan, np.nan])
+        unq = np.unique(a)
+        not_unq = np.unique(a, equal_nan=False)
+        assert_array_equal(unq, np.array([1, np.nan]))
+        assert_array_equal(not_unq, np.array([1, np.nan, np.nan, np.nan]))
+
+    def test_unique_array_api_functions(self):
+        arr = np.array([np.nan, 1, 4, 1, 3, 4, np.nan, 5, 1])
+
+        for res_unique_array_api, res_unique in [
+            (
+                np.unique_values(arr),
+                np.unique(arr, equal_nan=False)
+            ),
+            (
+                np.unique_counts(arr),
+                np.unique(arr, return_counts=True, equal_nan=False)
+            ),
+            (
+                np.unique_inverse(arr),
+                np.unique(arr, return_inverse=True, equal_nan=False)
+            ),
+            (
+                np.unique_all(arr),
+                np.unique(
+                    arr,
+                    return_index=True,
+                    return_inverse=True,
+                    return_counts=True,
+                    equal_nan=False
+                )
+            )
+        ]:
+            assert len(res_unique_array_api) == len(res_unique)
+            for actual, expected in zip(res_unique_array_api, res_unique):
+                assert_array_equal(actual, expected)
+
+    def test_unique_inverse_shape(self):
+        # Regression test for https://github.com/numpy/numpy/issues/25552
+        arr = np.array([[1, 2, 3], [2, 3, 1]])
+        expected_values, expected_inverse = np.unique(arr, return_inverse=True)
+        expected_inverse = expected_inverse.reshape(arr.shape)
+        for func in np.unique_inverse, np.unique_all:
+            result = func(arr)
+            assert_array_equal(expected_values, result.values)
+            assert_array_equal(expected_inverse, result.inverse_indices)
+            assert_array_equal(arr, result.values[result.inverse_indices])
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/tests/test_arrayterator.py b/venv/lib/python3.12/site-packages/numpy/lib/tests/test_arrayterator.py
new file mode 100644
index 00000000..c00ed13d
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/lib/tests/test_arrayterator.py
@@ -0,0 +1,46 @@
+from operator import mul
+from functools import reduce
+
+import numpy as np
+from numpy.random import randint
+from numpy.lib import Arrayterator
+from numpy.testing import assert_
+
+
+def test():
+    np.random.seed(np.arange(10))
+
+    # Create a random array
+    ndims = randint(5)+1
+    shape = tuple(randint(10)+1 for dim in range(ndims))
+    els = reduce(mul, shape)
+    a = np.arange(els)
+    a.shape = shape
+
+    buf_size = randint(2*els)
+    b = Arrayterator(a, buf_size)
+
+    # Check that each block has at most ``buf_size`` elements
+    for block in b:
+        assert_(len(block.flat) <= (buf_size or els))
+
+    # Check that all elements are iterated correctly
+    assert_(list(b.flat) == list(a.flat))
+
+    # Slice arrayterator
+    start = [randint(dim) for dim in shape]
+    stop = [randint(dim)+1 for dim in shape]
+    step = [randint(dim)+1 for dim in shape]
+    slice_ = tuple(slice(*t) for t in zip(start, stop, step))
+    c = b[slice_]
+    d = a[slice_]
+
+    # Check that each block has at most ``buf_size`` elements
+    for block in c:
+        assert_(len(block.flat) <= (buf_size or els))
+
+    # Check that the arrayterator is sliced correctly
+    assert_(np.all(c.__array__() == d))
+
+    # Check that all elements are iterated correctly
+    assert_(list(c.flat) == list(d.flat))
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/tests/test_format.py b/venv/lib/python3.12/site-packages/numpy/lib/tests/test_format.py
new file mode 100644
index 00000000..bb262e04
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/lib/tests/test_format.py
@@ -0,0 +1,1027 @@
+# doctest
+r''' Test the .npy file format.
+
+Set up:
+
+    >>> import sys
+    >>> from io import BytesIO
+    >>> from numpy.lib import format
+    >>>
+    >>> scalars = [
+    ...     np.uint8,
+    ...     np.int8,
+    ...     np.uint16,
+    ...     np.int16,
+    ...     np.uint32,
+    ...     np.int32,
+    ...     np.uint64,
+    ...     np.int64,
+    ...     np.float32,
+    ...     np.float64,
+    ...     np.complex64,
+    ...     np.complex128,
+    ...     object,
+    ... ]
+    >>>
+    >>> basic_arrays = []
+    >>>
+    >>> for scalar in scalars:
+    ...     for endian in '<>':
+    ...         dtype = np.dtype(scalar).newbyteorder(endian)
+    ...         basic = np.arange(15).astype(dtype)
+    ...         basic_arrays.extend([
+    ...             np.array([], dtype=dtype),
+    ...             np.array(10, dtype=dtype),
+    ...             basic,
+    ...             basic.reshape((3,5)),
+    ...             basic.reshape((3,5)).T,
+    ...             basic.reshape((3,5))[::-1,::2],
+    ...         ])
+    ...
+    >>>
+    >>> Pdescr = [
+    ...     ('x', 'i4', (2,)),
+    ...     ('y', 'f8', (2, 2)),
+    ...     ('z', 'u1')]
+    >>>
+    >>>
+    >>> PbufferT = [
+    ...     ([3,2], [[6.,4.],[6.,4.]], 8),
+    ...     ([4,3], [[7.,5.],[7.,5.]], 9),
+    ...     ]
+    >>>
+    >>>
+    >>> Ndescr = [
+    ...     ('x', 'i4', (2,)),
+    ...     ('Info', [
+    ...         ('value', 'c16'),
+    ...         ('y2', 'f8'),
+    ...         ('Info2', [
+    ...             ('name', 'S2'),
+    ...             ('value', 'c16', (2,)),
+    ...             ('y3', 'f8', (2,)),
+    ...             ('z3', 'u4', (2,))]),
+    ...         ('name', 'S2'),
+    ...         ('z2', 'b1')]),
+    ...     ('color', 'S2'),
+    ...     ('info', [
+    ...         ('Name', 'U8'),
+    ...         ('Value', 'c16')]),
+    ...     ('y', 'f8', (2, 2)),
+    ...     ('z', 'u1')]
+    >>>
+    >>>
+    >>> NbufferT = [
+    ...     ([3,2], (6j, 6., ('nn', [6j,4j], [6.,4.], [1,2]), 'NN', True), 'cc', ('NN', 6j), [[6.,4.],[6.,4.]], 8),
+    ...     ([4,3], (7j, 7., ('oo', [7j,5j], [7.,5.], [2,1]), 'OO', False), 'dd', ('OO', 7j), [[7.,5.],[7.,5.]], 9),
+    ...     ]
+    >>>
+    >>>
+    >>> record_arrays = [
+    ...     np.array(PbufferT, dtype=np.dtype(Pdescr).newbyteorder('<')),
+    ...     np.array(NbufferT, dtype=np.dtype(Ndescr).newbyteorder('<')),
+    ...     np.array(PbufferT, dtype=np.dtype(Pdescr).newbyteorder('>')),
+    ...     np.array(NbufferT, dtype=np.dtype(Ndescr).newbyteorder('>')),
+    ... ]
+
+Test the magic string writing.
+
+    >>> format.magic(1, 0)
+    '\x93NUMPY\x01\x00'
+    >>> format.magic(0, 0)
+    '\x93NUMPY\x00\x00'
+    >>> format.magic(255, 255)
+    '\x93NUMPY\xff\xff'
+    >>> format.magic(2, 5)
+    '\x93NUMPY\x02\x05'
+
+Test the magic string reading.
+
+    >>> format.read_magic(BytesIO(format.magic(1, 0)))
+    (1, 0)
+    >>> format.read_magic(BytesIO(format.magic(0, 0)))
+    (0, 0)
+    >>> format.read_magic(BytesIO(format.magic(255, 255)))
+    (255, 255)
+    >>> format.read_magic(BytesIO(format.magic(2, 5)))
+    (2, 5)
+
+Test the header writing.
+
+    >>> for arr in basic_arrays + record_arrays:
+    ...     f = BytesIO()
+    ...     format.write_array_header_1_0(f, arr)   # XXX: arr is not a dict, items gets called on it
+    ...     print(repr(f.getvalue()))
+    ...
+    "F\x00{'descr': '|u1', 'fortran_order': False, 'shape': (0,)}              \n"
+    "F\x00{'descr': '|u1', 'fortran_order': False, 'shape': ()}                \n"
+    "F\x00{'descr': '|u1', 'fortran_order': False, 'shape': (15,)}             \n"
+    "F\x00{'descr': '|u1', 'fortran_order': False, 'shape': (3, 5)}            \n"
+    "F\x00{'descr': '|u1', 'fortran_order': True, 'shape': (5, 3)}             \n"
+    "F\x00{'descr': '|u1', 'fortran_order': False, 'shape': (3, 3)}            \n"
+    "F\x00{'descr': '|u1', 'fortran_order': False, 'shape': (0,)}              \n"
+    "F\x00{'descr': '|u1', 'fortran_order': False, 'shape': ()}                \n"
+    "F\x00{'descr': '|u1', 'fortran_order': False, 'shape': (15,)}             \n"
+    "F\x00{'descr': '|u1', 'fortran_order': False, 'shape': (3, 5)}            \n"
+    "F\x00{'descr': '|u1', 'fortran_order': True, 'shape': (5, 3)}             \n"
+    "F\x00{'descr': '|u1', 'fortran_order': False, 'shape': (3, 3)}            \n"
+    "F\x00{'descr': '|i1', 'fortran_order': False, 'shape': (0,)}              \n"
+    "F\x00{'descr': '|i1', 'fortran_order': False, 'shape': ()}                \n"
+    "F\x00{'descr': '|i1', 'fortran_order': False, 'shape': (15,)}             \n"
+    "F\x00{'descr': '|i1', 'fortran_order': False, 'shape': (3, 5)}            \n"
+    "F\x00{'descr': '|i1', 'fortran_order': True, 'shape': (5, 3)}             \n"
+    "F\x00{'descr': '|i1', 'fortran_order': False, 'shape': (3, 3)}            \n"
+    "F\x00{'descr': '|i1', 'fortran_order': False, 'shape': (0,)}              \n"
+    "F\x00{'descr': '|i1', 'fortran_order': False, 'shape': ()}                \n"
+    "F\x00{'descr': '|i1', 'fortran_order': False, 'shape': (15,)}             \n"
+    "F\x00{'descr': '|i1', 'fortran_order': False, 'shape': (3, 5)}            \n"
+    "F\x00{'descr': '|i1', 'fortran_order': True, 'shape': (5, 3)}             \n"
+    "F\x00{'descr': '|i1', 'fortran_order': False, 'shape': (3, 3)}            \n"
+    "F\x00{'descr': 'u2', 'fortran_order': False, 'shape': (0,)}              \n"
+    "F\x00{'descr': '>u2', 'fortran_order': False, 'shape': ()}                \n"
+    "F\x00{'descr': '>u2', 'fortran_order': False, 'shape': (15,)}             \n"
+    "F\x00{'descr': '>u2', 'fortran_order': False, 'shape': (3, 5)}            \n"
+    "F\x00{'descr': '>u2', 'fortran_order': True, 'shape': (5, 3)}             \n"
+    "F\x00{'descr': '>u2', 'fortran_order': False, 'shape': (3, 3)}            \n"
+    "F\x00{'descr': 'i2', 'fortran_order': False, 'shape': (0,)}              \n"
+    "F\x00{'descr': '>i2', 'fortran_order': False, 'shape': ()}                \n"
+    "F\x00{'descr': '>i2', 'fortran_order': False, 'shape': (15,)}             \n"
+    "F\x00{'descr': '>i2', 'fortran_order': False, 'shape': (3, 5)}            \n"
+    "F\x00{'descr': '>i2', 'fortran_order': True, 'shape': (5, 3)}             \n"
+    "F\x00{'descr': '>i2', 'fortran_order': False, 'shape': (3, 3)}            \n"
+    "F\x00{'descr': 'u4', 'fortran_order': False, 'shape': (0,)}              \n"
+    "F\x00{'descr': '>u4', 'fortran_order': False, 'shape': ()}                \n"
+    "F\x00{'descr': '>u4', 'fortran_order': False, 'shape': (15,)}             \n"
+    "F\x00{'descr': '>u4', 'fortran_order': False, 'shape': (3, 5)}            \n"
+    "F\x00{'descr': '>u4', 'fortran_order': True, 'shape': (5, 3)}             \n"
+    "F\x00{'descr': '>u4', 'fortran_order': False, 'shape': (3, 3)}            \n"
+    "F\x00{'descr': 'i4', 'fortran_order': False, 'shape': (0,)}              \n"
+    "F\x00{'descr': '>i4', 'fortran_order': False, 'shape': ()}                \n"
+    "F\x00{'descr': '>i4', 'fortran_order': False, 'shape': (15,)}             \n"
+    "F\x00{'descr': '>i4', 'fortran_order': False, 'shape': (3, 5)}            \n"
+    "F\x00{'descr': '>i4', 'fortran_order': True, 'shape': (5, 3)}             \n"
+    "F\x00{'descr': '>i4', 'fortran_order': False, 'shape': (3, 3)}            \n"
+    "F\x00{'descr': 'u8', 'fortran_order': False, 'shape': (0,)}              \n"
+    "F\x00{'descr': '>u8', 'fortran_order': False, 'shape': ()}                \n"
+    "F\x00{'descr': '>u8', 'fortran_order': False, 'shape': (15,)}             \n"
+    "F\x00{'descr': '>u8', 'fortran_order': False, 'shape': (3, 5)}            \n"
+    "F\x00{'descr': '>u8', 'fortran_order': True, 'shape': (5, 3)}             \n"
+    "F\x00{'descr': '>u8', 'fortran_order': False, 'shape': (3, 3)}            \n"
+    "F\x00{'descr': 'i8', 'fortran_order': False, 'shape': (0,)}              \n"
+    "F\x00{'descr': '>i8', 'fortran_order': False, 'shape': ()}                \n"
+    "F\x00{'descr': '>i8', 'fortran_order': False, 'shape': (15,)}             \n"
+    "F\x00{'descr': '>i8', 'fortran_order': False, 'shape': (3, 5)}            \n"
+    "F\x00{'descr': '>i8', 'fortran_order': True, 'shape': (5, 3)}             \n"
+    "F\x00{'descr': '>i8', 'fortran_order': False, 'shape': (3, 3)}            \n"
+    "F\x00{'descr': 'f4', 'fortran_order': False, 'shape': (0,)}              \n"
+    "F\x00{'descr': '>f4', 'fortran_order': False, 'shape': ()}                \n"
+    "F\x00{'descr': '>f4', 'fortran_order': False, 'shape': (15,)}             \n"
+    "F\x00{'descr': '>f4', 'fortran_order': False, 'shape': (3, 5)}            \n"
+    "F\x00{'descr': '>f4', 'fortran_order': True, 'shape': (5, 3)}             \n"
+    "F\x00{'descr': '>f4', 'fortran_order': False, 'shape': (3, 3)}            \n"
+    "F\x00{'descr': 'f8', 'fortran_order': False, 'shape': (0,)}              \n"
+    "F\x00{'descr': '>f8', 'fortran_order': False, 'shape': ()}                \n"
+    "F\x00{'descr': '>f8', 'fortran_order': False, 'shape': (15,)}             \n"
+    "F\x00{'descr': '>f8', 'fortran_order': False, 'shape': (3, 5)}            \n"
+    "F\x00{'descr': '>f8', 'fortran_order': True, 'shape': (5, 3)}             \n"
+    "F\x00{'descr': '>f8', 'fortran_order': False, 'shape': (3, 3)}            \n"
+    "F\x00{'descr': 'c8', 'fortran_order': False, 'shape': (0,)}              \n"
+    "F\x00{'descr': '>c8', 'fortran_order': False, 'shape': ()}                \n"
+    "F\x00{'descr': '>c8', 'fortran_order': False, 'shape': (15,)}             \n"
+    "F\x00{'descr': '>c8', 'fortran_order': False, 'shape': (3, 5)}            \n"
+    "F\x00{'descr': '>c8', 'fortran_order': True, 'shape': (5, 3)}             \n"
+    "F\x00{'descr': '>c8', 'fortran_order': False, 'shape': (3, 3)}            \n"
+    "F\x00{'descr': 'c16', 'fortran_order': False, 'shape': (0,)}             \n"
+    "F\x00{'descr': '>c16', 'fortran_order': False, 'shape': ()}               \n"
+    "F\x00{'descr': '>c16', 'fortran_order': False, 'shape': (15,)}            \n"
+    "F\x00{'descr': '>c16', 'fortran_order': False, 'shape': (3, 5)}           \n"
+    "F\x00{'descr': '>c16', 'fortran_order': True, 'shape': (5, 3)}            \n"
+    "F\x00{'descr': '>c16', 'fortran_order': False, 'shape': (3, 3)}           \n"
+    "F\x00{'descr': 'O', 'fortran_order': False, 'shape': (0,)}              \n"
+    "F\x00{'descr': 'O', 'fortran_order': False, 'shape': ()}                \n"
+    "F\x00{'descr': 'O', 'fortran_order': False, 'shape': (15,)}             \n"
+    "F\x00{'descr': 'O', 'fortran_order': False, 'shape': (3, 5)}            \n"
+    "F\x00{'descr': 'O', 'fortran_order': True, 'shape': (5, 3)}             \n"
+    "F\x00{'descr': 'O', 'fortran_order': False, 'shape': (3, 3)}            \n"
+    "F\x00{'descr': 'O', 'fortran_order': False, 'shape': (0,)}              \n"
+    "F\x00{'descr': 'O', 'fortran_order': False, 'shape': ()}                \n"
+    "F\x00{'descr': 'O', 'fortran_order': False, 'shape': (15,)}             \n"
+    "F\x00{'descr': 'O', 'fortran_order': False, 'shape': (3, 5)}            \n"
+    "F\x00{'descr': 'O', 'fortran_order': True, 'shape': (5, 3)}             \n"
+    "F\x00{'descr': 'O', 'fortran_order': False, 'shape': (3, 3)}            \n"
+    "v\x00{'descr': [('x', 'i4', (2,)), ('y', '>f8', (2, 2)), ('z', '|u1')],\n 'fortran_order': False,\n 'shape': (2,)}         \n"
+    "\x16\x02{'descr': [('x', '>i4', (2,)),\n           ('Info',\n            [('value', '>c16'),\n             ('y2', '>f8'),\n             ('Info2',\n              [('name', '|S2'),\n               ('value', '>c16', (2,)),\n               ('y3', '>f8', (2,)),\n               ('z3', '>u4', (2,))]),\n             ('name', '|S2'),\n             ('z2', '|b1')]),\n           ('color', '|S2'),\n           ('info', [('Name', '>U8'), ('Value', '>c16')]),\n           ('y', '>f8', (2, 2)),\n           ('z', '|u1')],\n 'fortran_order': False,\n 'shape': (2,)}      \n"
+'''
+import sys
+import os
+import warnings
+import pytest
+from io import BytesIO
+
+import numpy as np
+from numpy.testing import (
+    assert_, assert_array_equal, assert_raises, assert_raises_regex,
+    assert_warns, IS_PYPY, IS_WASM
+    )
+from numpy.testing._private.utils import requires_memory
+from numpy.lib import format
+
+
+# Generate some basic arrays to test with.
+scalars = [
+    np.uint8,
+    np.int8,
+    np.uint16,
+    np.int16,
+    np.uint32,
+    np.int32,
+    np.uint64,
+    np.int64,
+    np.float32,
+    np.float64,
+    np.complex64,
+    np.complex128,
+    object,
+]
+basic_arrays = []
+for scalar in scalars:
+    for endian in '<>':
+        dtype = np.dtype(scalar).newbyteorder(endian)
+        basic = np.arange(1500).astype(dtype)
+        basic_arrays.extend([
+            # Empty
+            np.array([], dtype=dtype),
+            # Rank-0
+            np.array(10, dtype=dtype),
+            # 1-D
+            basic,
+            # 2-D C-contiguous
+            basic.reshape((30, 50)),
+            # 2-D F-contiguous
+            basic.reshape((30, 50)).T,
+            # 2-D non-contiguous
+            basic.reshape((30, 50))[::-1, ::2],
+        ])
+
+# More complicated record arrays.
+# This is the structure of the table used for plain objects:
+#
+# +-+-+-+
+# |x|y|z|
+# +-+-+-+
+
+# Structure of a plain array description:
+Pdescr = [
+    ('x', 'i4', (2,)),
+    ('y', 'f8', (2, 2)),
+    ('z', 'u1')]
+
+# A plain list of tuples with values for testing:
+PbufferT = [
+    # x     y                  z
+    ([3, 2], [[6., 4.], [6., 4.]], 8),
+    ([4, 3], [[7., 5.], [7., 5.]], 9),
+    ]
+
+
+# This is the structure of the table used for nested objects (DON'T PANIC!):
+#
+# +-+---------------------------------+-----+----------+-+-+
+# |x|Info                             |color|info      |y|z|
+# | +-----+--+----------------+----+--+     +----+-----+ | |
+# | |value|y2|Info2           |name|z2|     |Name|Value| | |
+# | |     |  +----+-----+--+--+    |  |     |    |     | | |
+# | |     |  |name|value|y3|z3|    |  |     |    |     | | |
+# +-+-----+--+----+-----+--+--+----+--+-----+----+-----+-+-+
+#
+
+# The corresponding nested array description:
+Ndescr = [
+    ('x', 'i4', (2,)),
+    ('Info', [
+        ('value', 'c16'),
+        ('y2', 'f8'),
+        ('Info2', [
+            ('name', 'S2'),
+            ('value', 'c16', (2,)),
+            ('y3', 'f8', (2,)),
+            ('z3', 'u4', (2,))]),
+        ('name', 'S2'),
+        ('z2', 'b1')]),
+    ('color', 'S2'),
+    ('info', [
+        ('Name', 'U8'),
+        ('Value', 'c16')]),
+    ('y', 'f8', (2, 2)),
+    ('z', 'u1')]
+
+NbufferT = [
+    # x     Info                                                color info        y                  z
+    #       value y2 Info2                            name z2         Name Value
+    #                name   value    y3       z3
+    ([3, 2], (6j, 6., ('nn', [6j, 4j], [6., 4.], [1, 2]), 'NN', True),
+     'cc', ('NN', 6j), [[6., 4.], [6., 4.]], 8),
+    ([4, 3], (7j, 7., ('oo', [7j, 5j], [7., 5.], [2, 1]), 'OO', False),
+     'dd', ('OO', 7j), [[7., 5.], [7., 5.]], 9),
+    ]
+
+record_arrays = [
+    np.array(PbufferT, dtype=np.dtype(Pdescr).newbyteorder('<')),
+    np.array(NbufferT, dtype=np.dtype(Ndescr).newbyteorder('<')),
+    np.array(PbufferT, dtype=np.dtype(Pdescr).newbyteorder('>')),
+    np.array(NbufferT, dtype=np.dtype(Ndescr).newbyteorder('>')),
+    np.zeros(1, dtype=[('c', ('= (3, 12), reason="see gh-23988")
+@pytest.mark.xfail(IS_WASM, reason="Emscripten NODEFS has a buggy dup")
+def test_python2_python3_interoperability():
+    fname = 'win64python2.npy'
+    path = os.path.join(os.path.dirname(__file__), 'data', fname)
+    with pytest.warns(UserWarning, match="Reading.*this warning\\."):
+        data = np.load(path)
+    assert_array_equal(data, np.ones(2))
+
+
+def test_pickle_python2_python3():
+    # Test that loading object arrays saved on Python 2 works both on
+    # Python 2 and Python 3 and vice versa
+    data_dir = os.path.join(os.path.dirname(__file__), 'data')
+
+    expected = np.array([None, range, '\u512a\u826f',
+                         b'\xe4\xb8\x8d\xe8\x89\xaf'],
+                        dtype=object)
+
+    for fname in ['py2-np0-objarr.npy', 'py2-objarr.npy', 'py2-objarr.npz',
+                  'py3-objarr.npy', 'py3-objarr.npz']:
+        path = os.path.join(data_dir, fname)
+
+        for encoding in ['bytes', 'latin1']:
+            data_f = np.load(path, allow_pickle=True, encoding=encoding)
+            if fname.endswith('.npz'):
+                data = data_f['x']
+                data_f.close()
+            else:
+                data = data_f
+
+            if encoding == 'latin1' and fname.startswith('py2'):
+                assert_(isinstance(data[3], str))
+                assert_array_equal(data[:-1], expected[:-1])
+                # mojibake occurs
+                assert_array_equal(data[-1].encode(encoding), expected[-1])
+            else:
+                assert_(isinstance(data[3], bytes))
+                assert_array_equal(data, expected)
+
+        if fname.startswith('py2'):
+            if fname.endswith('.npz'):
+                data = np.load(path, allow_pickle=True)
+                assert_raises(UnicodeError, data.__getitem__, 'x')
+                data.close()
+                data = np.load(path, allow_pickle=True, fix_imports=False,
+                               encoding='latin1')
+                assert_raises(ImportError, data.__getitem__, 'x')
+                data.close()
+            else:
+                assert_raises(UnicodeError, np.load, path,
+                              allow_pickle=True)
+                assert_raises(ImportError, np.load, path,
+                              allow_pickle=True, fix_imports=False,
+                              encoding='latin1')
+
+
+def test_pickle_disallow(tmpdir):
+    data_dir = os.path.join(os.path.dirname(__file__), 'data')
+
+    path = os.path.join(data_dir, 'py2-objarr.npy')
+    assert_raises(ValueError, np.load, path,
+                  allow_pickle=False, encoding='latin1')
+
+    path = os.path.join(data_dir, 'py2-objarr.npz')
+    with np.load(path, allow_pickle=False, encoding='latin1') as f:
+        assert_raises(ValueError, f.__getitem__, 'x')
+
+    path = os.path.join(tmpdir, 'pickle-disabled.npy')
+    assert_raises(ValueError, np.save, path, np.array([None], dtype=object),
+                  allow_pickle=False)
+
+@pytest.mark.parametrize('dt', [
+    np.dtype(np.dtype([('a', np.int8),
+                       ('b', np.int16),
+                       ('c', np.int32),
+                      ], align=True),
+             (3,)),
+    np.dtype([('x', np.dtype({'names':['a','b'],
+                              'formats':['i1','i1'],
+                              'offsets':[0,4],
+                              'itemsize':8,
+                             },
+                    (3,)),
+               (4,),
+             )]),
+    np.dtype([('x',
+                   (' 1, a)
+        assert_array_equal(b, [3, 2, 2, 3, 3])
+
+    def test_place(self):
+        # Make sure that non-np.ndarray objects
+        # raise an error instead of doing nothing
+        assert_raises(TypeError, place, [1, 2, 3], [True, False], [0, 1])
+
+        a = np.array([1, 4, 3, 2, 5, 8, 7])
+        place(a, [0, 1, 0, 1, 0, 1, 0], [2, 4, 6])
+        assert_array_equal(a, [1, 2, 3, 4, 5, 6, 7])
+
+        place(a, np.zeros(7), [])
+        assert_array_equal(a, np.arange(1, 8))
+
+        place(a, [1, 0, 1, 0, 1, 0, 1], [8, 9])
+        assert_array_equal(a, [8, 2, 9, 4, 8, 6, 9])
+        assert_raises_regex(ValueError, "Cannot insert from an empty array",
+                            lambda: place(a, [0, 0, 0, 0, 0, 1, 0], []))
+
+        # See Issue #6974
+        a = np.array(['12', '34'])
+        place(a, [0, 1], '9')
+        assert_array_equal(a, ['12', '9'])
+
+    def test_both(self):
+        a = rand(10)
+        mask = a > 0.5
+        ac = a.copy()
+        c = extract(mask, a)
+        place(a, mask, 0)
+        place(a, mask, c)
+        assert_array_equal(a, ac)
+
+
+# _foo1 and _foo2 are used in some tests in TestVectorize.
+
+def _foo1(x, y=1.0):
+    return y*math.floor(x)
+
+
+def _foo2(x, y=1.0, z=0.0):
+    return y*math.floor(x) + z
+
+
+class TestVectorize:
+
+    def test_simple(self):
+        def addsubtract(a, b):
+            if a > b:
+                return a - b
+            else:
+                return a + b
+
+        f = vectorize(addsubtract)
+        r = f([0, 3, 6, 9], [1, 3, 5, 7])
+        assert_array_equal(r, [1, 6, 1, 2])
+
+    def test_scalar(self):
+        def addsubtract(a, b):
+            if a > b:
+                return a - b
+            else:
+                return a + b
+
+        f = vectorize(addsubtract)
+        r = f([0, 3, 6, 9], 5)
+        assert_array_equal(r, [5, 8, 1, 4])
+
+    def test_large(self):
+        x = np.linspace(-3, 2, 10000)
+        f = vectorize(lambda x: x)
+        y = f(x)
+        assert_array_equal(y, x)
+
+    def test_ufunc(self):
+        f = vectorize(math.cos)
+        args = np.array([0, 0.5 * np.pi, np.pi, 1.5 * np.pi, 2 * np.pi])
+        r1 = f(args)
+        r2 = np.cos(args)
+        assert_array_almost_equal(r1, r2)
+
+    def test_keywords(self):
+
+        def foo(a, b=1):
+            return a + b
+
+        f = vectorize(foo)
+        args = np.array([1, 2, 3])
+        r1 = f(args)
+        r2 = np.array([2, 3, 4])
+        assert_array_equal(r1, r2)
+        r1 = f(args, 2)
+        r2 = np.array([3, 4, 5])
+        assert_array_equal(r1, r2)
+
+    def test_keywords_with_otypes_order1(self):
+        # gh-1620: The second call of f would crash with
+        # `ValueError: invalid number of arguments`.
+        f = vectorize(_foo1, otypes=[float])
+        # We're testing the caching of ufuncs by vectorize, so the order
+        # of these function calls is an important part of the test.
+        r1 = f(np.arange(3.0), 1.0)
+        r2 = f(np.arange(3.0))
+        assert_array_equal(r1, r2)
+
+    def test_keywords_with_otypes_order2(self):
+        # gh-1620: The second call of f would crash with
+        # `ValueError: non-broadcastable output operand with shape ()
+        # doesn't match the broadcast shape (3,)`.
+        f = vectorize(_foo1, otypes=[float])
+        # We're testing the caching of ufuncs by vectorize, so the order
+        # of these function calls is an important part of the test.
+        r1 = f(np.arange(3.0))
+        r2 = f(np.arange(3.0), 1.0)
+        assert_array_equal(r1, r2)
+
+    def test_keywords_with_otypes_order3(self):
+        # gh-1620: The third call of f would crash with
+        # `ValueError: invalid number of arguments`.
+        f = vectorize(_foo1, otypes=[float])
+        # We're testing the caching of ufuncs by vectorize, so the order
+        # of these function calls is an important part of the test.
+        r1 = f(np.arange(3.0))
+        r2 = f(np.arange(3.0), y=1.0)
+        r3 = f(np.arange(3.0))
+        assert_array_equal(r1, r2)
+        assert_array_equal(r1, r3)
+
+    def test_keywords_with_otypes_several_kwd_args1(self):
+        # gh-1620 Make sure different uses of keyword arguments
+        # don't break the vectorized function.
+        f = vectorize(_foo2, otypes=[float])
+        # We're testing the caching of ufuncs by vectorize, so the order
+        # of these function calls is an important part of the test.
+        r1 = f(10.4, z=100)
+        r2 = f(10.4, y=-1)
+        r3 = f(10.4)
+        assert_equal(r1, _foo2(10.4, z=100))
+        assert_equal(r2, _foo2(10.4, y=-1))
+        assert_equal(r3, _foo2(10.4))
+
+    def test_keywords_with_otypes_several_kwd_args2(self):
+        # gh-1620 Make sure different uses of keyword arguments
+        # don't break the vectorized function.
+        f = vectorize(_foo2, otypes=[float])
+        # We're testing the caching of ufuncs by vectorize, so the order
+        # of these function calls is an important part of the test.
+        r1 = f(z=100, x=10.4, y=-1)
+        r2 = f(1, 2, 3)
+        assert_equal(r1, _foo2(z=100, x=10.4, y=-1))
+        assert_equal(r2, _foo2(1, 2, 3))
+
+    def test_keywords_no_func_code(self):
+        # This needs to test a function that has keywords but
+        # no func_code attribute, since otherwise vectorize will
+        # inspect the func_code.
+        import random
+        try:
+            vectorize(random.randrange)  # Should succeed
+        except Exception:
+            raise AssertionError()
+
+    def test_keywords2_ticket_2100(self):
+        # Test kwarg support: enhancement ticket 2100
+
+        def foo(a, b=1):
+            return a + b
+
+        f = vectorize(foo)
+        args = np.array([1, 2, 3])
+        r1 = f(a=args)
+        r2 = np.array([2, 3, 4])
+        assert_array_equal(r1, r2)
+        r1 = f(b=1, a=args)
+        assert_array_equal(r1, r2)
+        r1 = f(args, b=2)
+        r2 = np.array([3, 4, 5])
+        assert_array_equal(r1, r2)
+
+    def test_keywords3_ticket_2100(self):
+        # Test excluded with mixed positional and kwargs: ticket 2100
+        def mypolyval(x, p):
+            _p = list(p)
+            res = _p.pop(0)
+            while _p:
+                res = res * x + _p.pop(0)
+            return res
+
+        vpolyval = np.vectorize(mypolyval, excluded=['p', 1])
+        ans = [3, 6]
+        assert_array_equal(ans, vpolyval(x=[0, 1], p=[1, 2, 3]))
+        assert_array_equal(ans, vpolyval([0, 1], p=[1, 2, 3]))
+        assert_array_equal(ans, vpolyval([0, 1], [1, 2, 3]))
+
+    def test_keywords4_ticket_2100(self):
+        # Test vectorizing function with no positional args.
+        @vectorize
+        def f(**kw):
+            res = 1.0
+            for _k in kw:
+                res *= kw[_k]
+            return res
+
+        assert_array_equal(f(a=[1, 2], b=[3, 4]), [3, 8])
+
+    def test_keywords5_ticket_2100(self):
+        # Test vectorizing function with no kwargs args.
+        @vectorize
+        def f(*v):
+            return np.prod(v)
+
+        assert_array_equal(f([1, 2], [3, 4]), [3, 8])
+
+    def test_coverage1_ticket_2100(self):
+        def foo():
+            return 1
+
+        f = vectorize(foo)
+        assert_array_equal(f(), 1)
+
+    def test_assigning_docstring(self):
+        def foo(x):
+            """Original documentation"""
+            return x
+
+        f = vectorize(foo)
+        assert_equal(f.__doc__, foo.__doc__)
+
+        doc = "Provided documentation"
+        f = vectorize(foo, doc=doc)
+        assert_equal(f.__doc__, doc)
+
+    def test_UnboundMethod_ticket_1156(self):
+        # Regression test for issue 1156
+        class Foo:
+            b = 2
+
+            def bar(self, a):
+                return a ** self.b
+
+        assert_array_equal(vectorize(Foo().bar)(np.arange(9)),
+                           np.arange(9) ** 2)
+        assert_array_equal(vectorize(Foo.bar)(Foo(), np.arange(9)),
+                           np.arange(9) ** 2)
+
+    def test_execution_order_ticket_1487(self):
+        # Regression test for dependence on execution order: issue 1487
+        f1 = vectorize(lambda x: x)
+        res1a = f1(np.arange(3))
+        res1b = f1(np.arange(0.1, 3))
+        f2 = vectorize(lambda x: x)
+        res2b = f2(np.arange(0.1, 3))
+        res2a = f2(np.arange(3))
+        assert_equal(res1a, res2a)
+        assert_equal(res1b, res2b)
+
+    def test_string_ticket_1892(self):
+        # Test vectorization over strings: issue 1892.
+        f = np.vectorize(lambda x: x)
+        s = '0123456789' * 10
+        assert_equal(s, f(s))
+
+    def test_cache(self):
+        # Ensure that vectorized func called exactly once per argument.
+        _calls = [0]
+
+        @vectorize
+        def f(x):
+            _calls[0] += 1
+            return x ** 2
+
+        f.cache = True
+        x = np.arange(5)
+        assert_array_equal(f(x), x * x)
+        assert_equal(_calls[0], len(x))
+
+    def test_otypes(self):
+        f = np.vectorize(lambda x: x)
+        f.otypes = 'i'
+        x = np.arange(5)
+        assert_array_equal(f(x), x)
+
+    def test_parse_gufunc_signature(self):
+        assert_equal(nfb._parse_gufunc_signature('(x)->()'), ([('x',)], [()]))
+        assert_equal(nfb._parse_gufunc_signature('(x,y)->()'),
+                     ([('x', 'y')], [()]))
+        assert_equal(nfb._parse_gufunc_signature('(x),(y)->()'),
+                     ([('x',), ('y',)], [()]))
+        assert_equal(nfb._parse_gufunc_signature('(x)->(y)'),
+                     ([('x',)], [('y',)]))
+        assert_equal(nfb._parse_gufunc_signature('(x)->(y),()'),
+                     ([('x',)], [('y',), ()]))
+        assert_equal(nfb._parse_gufunc_signature('(),(a,b,c),(d)->(d,e)'),
+                     ([(), ('a', 'b', 'c'), ('d',)], [('d', 'e')]))
+
+        # Tests to check if whitespaces are ignored
+        assert_equal(nfb._parse_gufunc_signature('(x )->()'), ([('x',)], [()]))
+        assert_equal(nfb._parse_gufunc_signature('( x , y )->(  )'),
+                     ([('x', 'y')], [()]))
+        assert_equal(nfb._parse_gufunc_signature('(x),( y) ->()'),
+                     ([('x',), ('y',)], [()]))
+        assert_equal(nfb._parse_gufunc_signature('(  x)-> (y )  '),
+                     ([('x',)], [('y',)]))
+        assert_equal(nfb._parse_gufunc_signature(' (x)->( y),( )'),
+                     ([('x',)], [('y',), ()]))
+        assert_equal(nfb._parse_gufunc_signature(
+                     '(  ), ( a,  b,c )  ,(  d)   ->   (d  ,  e)'),
+                     ([(), ('a', 'b', 'c'), ('d',)], [('d', 'e')]))
+
+        with assert_raises(ValueError):
+            nfb._parse_gufunc_signature('(x)(y)->()')
+        with assert_raises(ValueError):
+            nfb._parse_gufunc_signature('(x),(y)->')
+        with assert_raises(ValueError):
+            nfb._parse_gufunc_signature('((x))->(x)')
+
+    def test_signature_simple(self):
+        def addsubtract(a, b):
+            if a > b:
+                return a - b
+            else:
+                return a + b
+
+        f = vectorize(addsubtract, signature='(),()->()')
+        r = f([0, 3, 6, 9], [1, 3, 5, 7])
+        assert_array_equal(r, [1, 6, 1, 2])
+
+    def test_signature_mean_last(self):
+        def mean(a):
+            return a.mean()
+
+        f = vectorize(mean, signature='(n)->()')
+        r = f([[1, 3], [2, 4]])
+        assert_array_equal(r, [2, 3])
+
+    def test_signature_center(self):
+        def center(a):
+            return a - a.mean()
+
+        f = vectorize(center, signature='(n)->(n)')
+        r = f([[1, 3], [2, 4]])
+        assert_array_equal(r, [[-1, 1], [-1, 1]])
+
+    def test_signature_two_outputs(self):
+        f = vectorize(lambda x: (x, x), signature='()->(),()')
+        r = f([1, 2, 3])
+        assert_(isinstance(r, tuple) and len(r) == 2)
+        assert_array_equal(r[0], [1, 2, 3])
+        assert_array_equal(r[1], [1, 2, 3])
+
+    def test_signature_outer(self):
+        f = vectorize(np.outer, signature='(a),(b)->(a,b)')
+        r = f([1, 2], [1, 2, 3])
+        assert_array_equal(r, [[1, 2, 3], [2, 4, 6]])
+
+        r = f([[[1, 2]]], [1, 2, 3])
+        assert_array_equal(r, [[[[1, 2, 3], [2, 4, 6]]]])
+
+        r = f([[1, 0], [2, 0]], [1, 2, 3])
+        assert_array_equal(r, [[[1, 2, 3], [0, 0, 0]],
+                               [[2, 4, 6], [0, 0, 0]]])
+
+        r = f([1, 2], [[1, 2, 3], [0, 0, 0]])
+        assert_array_equal(r, [[[1, 2, 3], [2, 4, 6]],
+                               [[0, 0, 0], [0, 0, 0]]])
+
+    def test_signature_computed_size(self):
+        f = vectorize(lambda x: x[:-1], signature='(n)->(m)')
+        r = f([1, 2, 3])
+        assert_array_equal(r, [1, 2])
+
+        r = f([[1, 2, 3], [2, 3, 4]])
+        assert_array_equal(r, [[1, 2], [2, 3]])
+
+    def test_signature_excluded(self):
+
+        def foo(a, b=1):
+            return a + b
+
+        f = vectorize(foo, signature='()->()', excluded={'b'})
+        assert_array_equal(f([1, 2, 3]), [2, 3, 4])
+        assert_array_equal(f([1, 2, 3], b=0), [1, 2, 3])
+
+    def test_signature_otypes(self):
+        f = vectorize(lambda x: x, signature='(n)->(n)', otypes=['float64'])
+        r = f([1, 2, 3])
+        assert_equal(r.dtype, np.dtype('float64'))
+        assert_array_equal(r, [1, 2, 3])
+
+    def test_signature_invalid_inputs(self):
+        f = vectorize(operator.add, signature='(n),(n)->(n)')
+        with assert_raises_regex(TypeError, 'wrong number of positional'):
+            f([1, 2])
+        with assert_raises_regex(
+                ValueError, 'does not have enough dimensions'):
+            f(1, 2)
+        with assert_raises_regex(
+                ValueError, 'inconsistent size for core dimension'):
+            f([1, 2], [1, 2, 3])
+
+        f = vectorize(operator.add, signature='()->()')
+        with assert_raises_regex(TypeError, 'wrong number of positional'):
+            f(1, 2)
+
+    def test_signature_invalid_outputs(self):
+
+        f = vectorize(lambda x: x[:-1], signature='(n)->(n)')
+        with assert_raises_regex(
+                ValueError, 'inconsistent size for core dimension'):
+            f([1, 2, 3])
+
+        f = vectorize(lambda x: x, signature='()->(),()')
+        with assert_raises_regex(ValueError, 'wrong number of outputs'):
+            f(1)
+
+        f = vectorize(lambda x: (x, x), signature='()->()')
+        with assert_raises_regex(ValueError, 'wrong number of outputs'):
+            f([1, 2])
+
+    def test_size_zero_output(self):
+        # see issue 5868
+        f = np.vectorize(lambda x: x)
+        x = np.zeros([0, 5], dtype=int)
+        with assert_raises_regex(ValueError, 'otypes'):
+            f(x)
+
+        f.otypes = 'i'
+        assert_array_equal(f(x), x)
+
+        f = np.vectorize(lambda x: x, signature='()->()')
+        with assert_raises_regex(ValueError, 'otypes'):
+            f(x)
+
+        f = np.vectorize(lambda x: x, signature='()->()', otypes='i')
+        assert_array_equal(f(x), x)
+
+        f = np.vectorize(lambda x: x, signature='(n)->(n)', otypes='i')
+        assert_array_equal(f(x), x)
+
+        f = np.vectorize(lambda x: x, signature='(n)->(n)')
+        assert_array_equal(f(x.T), x.T)
+
+        f = np.vectorize(lambda x: [x], signature='()->(n)', otypes='i')
+        with assert_raises_regex(ValueError, 'new output dimensions'):
+            f(x)
+
+    def test_subclasses(self):
+        class subclass(np.ndarray):
+            pass
+
+        m = np.array([[1., 0., 0.],
+                      [0., 0., 1.],
+                      [0., 1., 0.]]).view(subclass)
+        v = np.array([[1., 2., 3.], [4., 5., 6.], [7., 8., 9.]]).view(subclass)
+        # generalized (gufunc)
+        matvec = np.vectorize(np.matmul, signature='(m,m),(m)->(m)')
+        r = matvec(m, v)
+        assert_equal(type(r), subclass)
+        assert_equal(r, [[1., 3., 2.], [4., 6., 5.], [7., 9., 8.]])
+
+        # element-wise (ufunc)
+        mult = np.vectorize(lambda x, y: x*y)
+        r = mult(m, v)
+        assert_equal(type(r), subclass)
+        assert_equal(r, m * v)
+
+    def test_name(self):
+        #See gh-23021
+        @np.vectorize
+        def f2(a, b):
+            return a + b
+
+        assert f2.__name__ == 'f2'
+
+    def test_decorator(self):
+        @vectorize
+        def addsubtract(a, b):
+            if a > b:
+                return a - b
+            else:
+                return a + b
+
+        r = addsubtract([0, 3, 6, 9], [1, 3, 5, 7])
+        assert_array_equal(r, [1, 6, 1, 2])
+
+    def test_docstring(self):
+        @vectorize
+        def f(x):
+            """Docstring"""
+            return x
+
+        if sys.flags.optimize < 2:
+            assert f.__doc__ == "Docstring"
+
+    def test_partial(self):
+        def foo(x, y):
+            return x + y
+
+        bar = partial(foo, 3)
+        vbar = np.vectorize(bar)
+        assert vbar(1) == 4
+
+    def test_signature_otypes_decorator(self):
+        @vectorize(signature='(n)->(n)', otypes=['float64'])
+        def f(x):
+            return x
+
+        r = f([1, 2, 3])
+        assert_equal(r.dtype, np.dtype('float64'))
+        assert_array_equal(r, [1, 2, 3])
+        assert f.__name__ == 'f'
+
+    def test_bad_input(self):
+        with assert_raises(TypeError):
+            A = np.vectorize(pyfunc = 3)
+
+    def test_no_keywords(self):
+        with assert_raises(TypeError):
+            @np.vectorize("string")
+            def foo():
+                return "bar"
+
+    def test_positional_regression_9477(self):
+        # This supplies the first keyword argument as a positional,
+        # to ensure that they are still properly forwarded after the
+        # enhancement for #9477
+        f = vectorize((lambda x: x), ['float64'])
+        r = f([2])
+        assert_equal(r.dtype, np.dtype('float64'))
+
+    def test_datetime_conversion(self):
+        otype = "datetime64[ns]"
+        arr = np.array(['2024-01-01', '2024-01-02', '2024-01-03'], 
+                       dtype='datetime64[ns]')
+        assert_array_equal(np.vectorize(lambda x: x, signature="(i)->(j)",
+                                        otypes=[otype])(arr), arr)
+
+
+class TestLeaks:
+    class A:
+        iters = 20
+
+        def bound(self, *args):
+            return 0
+
+        @staticmethod
+        def unbound(*args):
+            return 0
+
+    @pytest.mark.skipif(not HAS_REFCOUNT, reason="Python lacks refcounts")
+    @pytest.mark.skipif(NOGIL_BUILD,
+                        reason=("Functions are immortalized if a thread is "
+                                "launched, making this test flaky"))
+    @pytest.mark.parametrize('name, incr', [
+            ('bound', A.iters),
+            ('unbound', 0),
+            ])
+    def test_frompyfunc_leaks(self, name, incr):
+        # exposed in gh-11867 as np.vectorized, but the problem stems from
+        # frompyfunc.
+        # class.attribute = np.frompyfunc() creates a
+        # reference cycle if  is a bound class method. It requires a
+        # gc collection cycle to break the cycle (on CPython 3)
+        import gc
+        A_func = getattr(self.A, name)
+        gc.disable()
+        try:
+            refcount = sys.getrefcount(A_func)
+            for i in range(self.A.iters):
+                a = self.A()
+                a.f = np.frompyfunc(getattr(a, name), 1, 1)
+                out = a.f(np.arange(10))
+            a = None
+            # A.func is part of a reference cycle if incr is non-zero
+            assert_equal(sys.getrefcount(A_func), refcount + incr)
+            for i in range(5):
+                gc.collect()
+            assert_equal(sys.getrefcount(A_func), refcount)
+        finally:
+            gc.enable()
+
+
+class TestDigitize:
+
+    def test_forward(self):
+        x = np.arange(-6, 5)
+        bins = np.arange(-5, 5)
+        assert_array_equal(digitize(x, bins), np.arange(11))
+
+    def test_reverse(self):
+        x = np.arange(5, -6, -1)
+        bins = np.arange(5, -5, -1)
+        assert_array_equal(digitize(x, bins), np.arange(11))
+
+    def test_random(self):
+        x = rand(10)
+        bin = np.linspace(x.min(), x.max(), 10)
+        assert_(np.all(digitize(x, bin) != 0))
+
+    def test_right_basic(self):
+        x = [1, 5, 4, 10, 8, 11, 0]
+        bins = [1, 5, 10]
+        default_answer = [1, 2, 1, 3, 2, 3, 0]
+        assert_array_equal(digitize(x, bins), default_answer)
+        right_answer = [0, 1, 1, 2, 2, 3, 0]
+        assert_array_equal(digitize(x, bins, True), right_answer)
+
+    def test_right_open(self):
+        x = np.arange(-6, 5)
+        bins = np.arange(-6, 4)
+        assert_array_equal(digitize(x, bins, True), np.arange(11))
+
+    def test_right_open_reverse(self):
+        x = np.arange(5, -6, -1)
+        bins = np.arange(4, -6, -1)
+        assert_array_equal(digitize(x, bins, True), np.arange(11))
+
+    def test_right_open_random(self):
+        x = rand(10)
+        bins = np.linspace(x.min(), x.max(), 10)
+        assert_(np.all(digitize(x, bins, True) != 10))
+
+    def test_monotonic(self):
+        x = [-1, 0, 1, 2]
+        bins = [0, 0, 1]
+        assert_array_equal(digitize(x, bins, False), [0, 2, 3, 3])
+        assert_array_equal(digitize(x, bins, True), [0, 0, 2, 3])
+        bins = [1, 1, 0]
+        assert_array_equal(digitize(x, bins, False), [3, 2, 0, 0])
+        assert_array_equal(digitize(x, bins, True), [3, 3, 2, 0])
+        bins = [1, 1, 1, 1]
+        assert_array_equal(digitize(x, bins, False), [0, 0, 4, 4])
+        assert_array_equal(digitize(x, bins, True), [0, 0, 0, 4])
+        bins = [0, 0, 1, 0]
+        assert_raises(ValueError, digitize, x, bins)
+        bins = [1, 1, 0, 1]
+        assert_raises(ValueError, digitize, x, bins)
+
+    def test_casting_error(self):
+        x = [1, 2, 3 + 1.j]
+        bins = [1, 2, 3]
+        assert_raises(TypeError, digitize, x, bins)
+        x, bins = bins, x
+        assert_raises(TypeError, digitize, x, bins)
+
+    def test_return_type(self):
+        # Functions returning indices should always return base ndarrays
+        class A(np.ndarray):
+            pass
+        a = np.arange(5).view(A)
+        b = np.arange(1, 3).view(A)
+        assert_(not isinstance(digitize(b, a, False), A))
+        assert_(not isinstance(digitize(b, a, True), A))
+
+    def test_large_integers_increasing(self):
+        # gh-11022
+        x = 2**54  # loses precision in a float
+        assert_equal(np.digitize(x, [x - 1, x + 1]), 1)
+
+    @pytest.mark.xfail(
+        reason="gh-11022: np._core.multiarray._monoticity loses precision")
+    def test_large_integers_decreasing(self):
+        # gh-11022
+        x = 2**54  # loses precision in a float
+        assert_equal(np.digitize(x, [x + 1, x - 1]), 1)
+
+
+class TestUnwrap:
+
+    def test_simple(self):
+        # check that unwrap removes jumps greater that 2*pi
+        assert_array_equal(unwrap([1, 1 + 2 * np.pi]), [1, 1])
+        # check that unwrap maintains continuity
+        assert_(np.all(diff(unwrap(rand(10) * 100)) < np.pi))
+
+    def test_period(self):
+        # check that unwrap removes jumps greater that 255
+        assert_array_equal(unwrap([1, 1 + 256], period=255), [1, 2])
+        # check that unwrap maintains continuity
+        assert_(np.all(diff(unwrap(rand(10) * 1000, period=255)) < 255))
+        # check simple case
+        simple_seq = np.array([0, 75, 150, 225, 300])
+        wrap_seq = np.mod(simple_seq, 255)
+        assert_array_equal(unwrap(wrap_seq, period=255), simple_seq)
+        # check custom discont value
+        uneven_seq = np.array([0, 75, 150, 225, 300, 430])
+        wrap_uneven = np.mod(uneven_seq, 250)
+        no_discont = unwrap(wrap_uneven, period=250)
+        assert_array_equal(no_discont, [0, 75, 150, 225, 300, 180])
+        sm_discont = unwrap(wrap_uneven, period=250, discont=140)
+        assert_array_equal(sm_discont, [0, 75, 150, 225, 300, 430])
+        assert sm_discont.dtype == wrap_uneven.dtype
+
+
+@pytest.mark.parametrize(
+    "dtype", "O" + np.typecodes["AllInteger"] + np.typecodes["Float"]
+)
+@pytest.mark.parametrize("M", [0, 1, 10])
+class TestFilterwindows:
+
+    def test_hanning(self, dtype: str, M: int) -> None:
+        scalar = np.array(M, dtype=dtype)[()]
+
+        w = hanning(scalar)
+        if dtype == "O":
+            ref_dtype = np.float64
+        else:
+            ref_dtype = np.result_type(scalar.dtype, np.float64)
+        assert w.dtype == ref_dtype
+
+        # check symmetry
+        assert_equal(w, flipud(w))
+
+        # check known value
+        if scalar < 1:
+            assert_array_equal(w, np.array([]))
+        elif scalar == 1:
+            assert_array_equal(w, np.ones(1))
+        else:
+            assert_almost_equal(np.sum(w, axis=0), 4.500, 4)
+
+    def test_hamming(self, dtype: str, M: int) -> None:
+        scalar = np.array(M, dtype=dtype)[()]
+
+        w = hamming(scalar)
+        if dtype == "O":
+            ref_dtype = np.float64
+        else:
+            ref_dtype = np.result_type(scalar.dtype, np.float64)
+        assert w.dtype == ref_dtype
+
+        # check symmetry
+        assert_equal(w, flipud(w))
+
+        # check known value
+        if scalar < 1:
+            assert_array_equal(w, np.array([]))
+        elif scalar == 1:
+            assert_array_equal(w, np.ones(1))
+        else:
+            assert_almost_equal(np.sum(w, axis=0), 4.9400, 4)
+
+    def test_bartlett(self, dtype: str, M: int) -> None:
+        scalar = np.array(M, dtype=dtype)[()]
+
+        w = bartlett(scalar)
+        if dtype == "O":
+            ref_dtype = np.float64
+        else:
+            ref_dtype = np.result_type(scalar.dtype, np.float64)
+        assert w.dtype == ref_dtype
+
+        # check symmetry
+        assert_equal(w, flipud(w))
+
+        # check known value
+        if scalar < 1:
+            assert_array_equal(w, np.array([]))
+        elif scalar == 1:
+            assert_array_equal(w, np.ones(1))
+        else:
+            assert_almost_equal(np.sum(w, axis=0), 4.4444, 4)
+
+    def test_blackman(self, dtype: str, M: int) -> None:
+        scalar = np.array(M, dtype=dtype)[()]
+
+        w = blackman(scalar)
+        if dtype == "O":
+            ref_dtype = np.float64
+        else:
+            ref_dtype = np.result_type(scalar.dtype, np.float64)
+        assert w.dtype == ref_dtype
+
+        # check symmetry
+        assert_equal(w, flipud(w))
+
+        # check known value
+        if scalar < 1:
+            assert_array_equal(w, np.array([]))
+        elif scalar == 1:
+            assert_array_equal(w, np.ones(1))
+        else:
+            assert_almost_equal(np.sum(w, axis=0), 3.7800, 4)
+
+    def test_kaiser(self, dtype: str, M: int) -> None:
+        scalar = np.array(M, dtype=dtype)[()]
+
+        w = kaiser(scalar, 0)
+        if dtype == "O":
+            ref_dtype = np.float64
+        else:
+            ref_dtype = np.result_type(scalar.dtype, np.float64)
+        assert w.dtype == ref_dtype
+
+        # check symmetry
+        assert_equal(w, flipud(w))
+
+        # check known value
+        if scalar < 1:
+            assert_array_equal(w, np.array([]))
+        elif scalar == 1:
+            assert_array_equal(w, np.ones(1))
+        else:
+            assert_almost_equal(np.sum(w, axis=0), 10, 15)
+
+
+class TestTrapezoid:
+
+    def test_simple(self):
+        x = np.arange(-10, 10, .1)
+        r = trapezoid(np.exp(-.5 * x ** 2) / np.sqrt(2 * np.pi), dx=0.1)
+        # check integral of normal equals 1
+        assert_almost_equal(r, 1, 7)
+
+    def test_ndim(self):
+        x = np.linspace(0, 1, 3)
+        y = np.linspace(0, 2, 8)
+        z = np.linspace(0, 3, 13)
+
+        wx = np.ones_like(x) * (x[1] - x[0])
+        wx[0] /= 2
+        wx[-1] /= 2
+        wy = np.ones_like(y) * (y[1] - y[0])
+        wy[0] /= 2
+        wy[-1] /= 2
+        wz = np.ones_like(z) * (z[1] - z[0])
+        wz[0] /= 2
+        wz[-1] /= 2
+
+        q = x[:, None, None] + y[None,:, None] + z[None, None,:]
+
+        qx = (q * wx[:, None, None]).sum(axis=0)
+        qy = (q * wy[None, :, None]).sum(axis=1)
+        qz = (q * wz[None, None, :]).sum(axis=2)
+
+        # n-d `x`
+        r = trapezoid(q, x=x[:, None, None], axis=0)
+        assert_almost_equal(r, qx)
+        r = trapezoid(q, x=y[None, :, None], axis=1)
+        assert_almost_equal(r, qy)
+        r = trapezoid(q, x=z[None, None, :], axis=2)
+        assert_almost_equal(r, qz)
+
+        # 1-d `x`
+        r = trapezoid(q, x=x, axis=0)
+        assert_almost_equal(r, qx)
+        r = trapezoid(q, x=y, axis=1)
+        assert_almost_equal(r, qy)
+        r = trapezoid(q, x=z, axis=2)
+        assert_almost_equal(r, qz)
+
+    def test_masked(self):
+        # Testing that masked arrays behave as if the function is 0 where
+        # masked
+        x = np.arange(5)
+        y = x * x
+        mask = x == 2
+        ym = np.ma.array(y, mask=mask)
+        r = 13.0  # sum(0.5 * (0 + 1) * 1.0 + 0.5 * (9 + 16))
+        assert_almost_equal(trapezoid(ym, x), r)
+
+        xm = np.ma.array(x, mask=mask)
+        assert_almost_equal(trapezoid(ym, xm), r)
+
+        xm = np.ma.array(x, mask=mask)
+        assert_almost_equal(trapezoid(y, xm), r)
+
+
+class TestSinc:
+
+    def test_simple(self):
+        assert_(sinc(0) == 1)
+        w = sinc(np.linspace(-1, 1, 100))
+        # check symmetry
+        assert_array_almost_equal(w, flipud(w), 7)
+
+    def test_array_like(self):
+        x = [0, 0.5]
+        y1 = sinc(np.array(x))
+        y2 = sinc(list(x))
+        y3 = sinc(tuple(x))
+        assert_array_equal(y1, y2)
+        assert_array_equal(y1, y3)
+
+
+class TestUnique:
+
+    def test_simple(self):
+        x = np.array([4, 3, 2, 1, 1, 2, 3, 4, 0])
+        assert_(np.all(unique(x) == [0, 1, 2, 3, 4]))
+        assert_(unique(np.array([1, 1, 1, 1, 1])) == np.array([1]))
+        x = ['widget', 'ham', 'foo', 'bar', 'foo', 'ham']
+        assert_(np.all(unique(x) == ['bar', 'foo', 'ham', 'widget']))
+        x = np.array([5 + 6j, 1 + 1j, 1 + 10j, 10, 5 + 6j])
+        assert_(np.all(unique(x) == [1 + 1j, 1 + 10j, 5 + 6j, 10]))
+
+
+class TestCheckFinite:
+
+    def test_simple(self):
+        a = [1, 2, 3]
+        b = [1, 2, np.inf]
+        c = [1, 2, np.nan]
+        np.asarray_chkfinite(a)
+        assert_raises(ValueError, np.asarray_chkfinite, b)
+        assert_raises(ValueError, np.asarray_chkfinite, c)
+
+    def test_dtype_order(self):
+        # Regression test for missing dtype and order arguments
+        a = [1, 2, 3]
+        a = np.asarray_chkfinite(a, order='F', dtype=np.float64)
+        assert_(a.dtype == np.float64)
+
+
+class TestCorrCoef:
+    A = np.array(
+        [[0.15391142, 0.18045767, 0.14197213],
+         [0.70461506, 0.96474128, 0.27906989],
+         [0.9297531, 0.32296769, 0.19267156]])
+    B = np.array(
+        [[0.10377691, 0.5417086, 0.49807457],
+         [0.82872117, 0.77801674, 0.39226705],
+         [0.9314666, 0.66800209, 0.03538394]])
+    res1 = np.array(
+        [[1., 0.9379533, -0.04931983],
+         [0.9379533, 1., 0.30007991],
+         [-0.04931983, 0.30007991, 1.]])
+    res2 = np.array(
+        [[1., 0.9379533, -0.04931983, 0.30151751, 0.66318558, 0.51532523],
+         [0.9379533, 1., 0.30007991, -0.04781421, 0.88157256, 0.78052386],
+         [-0.04931983, 0.30007991, 1., -0.96717111, 0.71483595, 0.83053601],
+         [0.30151751, -0.04781421, -0.96717111, 1., -0.51366032, -0.66173113],
+         [0.66318558, 0.88157256, 0.71483595, -0.51366032, 1., 0.98317823],
+         [0.51532523, 0.78052386, 0.83053601, -0.66173113, 0.98317823, 1.]])
+
+    def test_non_array(self):
+        assert_almost_equal(np.corrcoef([0, 1, 0], [1, 0, 1]),
+                            [[1., -1.], [-1.,  1.]])
+
+    def test_simple(self):
+        tgt1 = corrcoef(self.A)
+        assert_almost_equal(tgt1, self.res1)
+        assert_(np.all(np.abs(tgt1) <= 1.0))
+
+        tgt2 = corrcoef(self.A, self.B)
+        assert_almost_equal(tgt2, self.res2)
+        assert_(np.all(np.abs(tgt2) <= 1.0))
+
+    def test_ddof(self):
+        # ddof raises DeprecationWarning
+        with suppress_warnings() as sup:
+            warnings.simplefilter("always")
+            assert_warns(DeprecationWarning, corrcoef, self.A, ddof=-1)
+            sup.filter(DeprecationWarning)
+            # ddof has no or negligible effect on the function
+            assert_almost_equal(corrcoef(self.A, ddof=-1), self.res1)
+            assert_almost_equal(corrcoef(self.A, self.B, ddof=-1), self.res2)
+            assert_almost_equal(corrcoef(self.A, ddof=3), self.res1)
+            assert_almost_equal(corrcoef(self.A, self.B, ddof=3), self.res2)
+
+    def test_bias(self):
+        # bias raises DeprecationWarning
+        with suppress_warnings() as sup:
+            warnings.simplefilter("always")
+            assert_warns(DeprecationWarning, corrcoef, self.A, self.B, 1, 0)
+            assert_warns(DeprecationWarning, corrcoef, self.A, bias=0)
+            sup.filter(DeprecationWarning)
+            # bias has no or negligible effect on the function
+            assert_almost_equal(corrcoef(self.A, bias=1), self.res1)
+
+    def test_complex(self):
+        x = np.array([[1, 2, 3], [1j, 2j, 3j]])
+        res = corrcoef(x)
+        tgt = np.array([[1., -1.j], [1.j, 1.]])
+        assert_allclose(res, tgt)
+        assert_(np.all(np.abs(res) <= 1.0))
+
+    def test_xy(self):
+        x = np.array([[1, 2, 3]])
+        y = np.array([[1j, 2j, 3j]])
+        assert_allclose(np.corrcoef(x, y), np.array([[1., -1.j], [1.j, 1.]]))
+
+    def test_empty(self):
+        with warnings.catch_warnings(record=True):
+            warnings.simplefilter('always', RuntimeWarning)
+            assert_array_equal(corrcoef(np.array([])), np.nan)
+            assert_array_equal(corrcoef(np.array([]).reshape(0, 2)),
+                               np.array([]).reshape(0, 0))
+            assert_array_equal(corrcoef(np.array([]).reshape(2, 0)),
+                               np.array([[np.nan, np.nan], [np.nan, np.nan]]))
+
+    def test_extreme(self):
+        x = [[1e-100, 1e100], [1e100, 1e-100]]
+        with np.errstate(all='raise'):
+            c = corrcoef(x)
+        assert_array_almost_equal(c, np.array([[1., -1.], [-1., 1.]]))
+        assert_(np.all(np.abs(c) <= 1.0))
+
+    @pytest.mark.parametrize("test_type", [np.half, np.single, np.double, np.longdouble])
+    def test_corrcoef_dtype(self, test_type):
+        cast_A = self.A.astype(test_type)
+        res = corrcoef(cast_A, dtype=test_type)
+        assert test_type == res.dtype
+
+
+class TestCov:
+    x1 = np.array([[0, 2], [1, 1], [2, 0]]).T
+    res1 = np.array([[1., -1.], [-1., 1.]])
+    x2 = np.array([0.0, 1.0, 2.0], ndmin=2)
+    frequencies = np.array([1, 4, 1])
+    x2_repeats = np.array([[0.0], [1.0], [1.0], [1.0], [1.0], [2.0]]).T
+    res2 = np.array([[0.4, -0.4], [-0.4, 0.4]])
+    unit_frequencies = np.ones(3, dtype=np.int_)
+    weights = np.array([1.0, 4.0, 1.0])
+    res3 = np.array([[2. / 3., -2. / 3.], [-2. / 3., 2. / 3.]])
+    unit_weights = np.ones(3)
+    x3 = np.array([0.3942, 0.5969, 0.7730, 0.9918, 0.7964])
+
+    def test_basic(self):
+        assert_allclose(cov(self.x1), self.res1)
+
+    def test_complex(self):
+        x = np.array([[1, 2, 3], [1j, 2j, 3j]])
+        res = np.array([[1., -1.j], [1.j, 1.]])
+        assert_allclose(cov(x), res)
+        assert_allclose(cov(x, aweights=np.ones(3)), res)
+
+    def test_xy(self):
+        x = np.array([[1, 2, 3]])
+        y = np.array([[1j, 2j, 3j]])
+        assert_allclose(cov(x, y), np.array([[1., -1.j], [1.j, 1.]]))
+
+    def test_empty(self):
+        with warnings.catch_warnings(record=True):
+            warnings.simplefilter('always', RuntimeWarning)
+            assert_array_equal(cov(np.array([])), np.nan)
+            assert_array_equal(cov(np.array([]).reshape(0, 2)),
+                               np.array([]).reshape(0, 0))
+            assert_array_equal(cov(np.array([]).reshape(2, 0)),
+                               np.array([[np.nan, np.nan], [np.nan, np.nan]]))
+
+    def test_wrong_ddof(self):
+        with warnings.catch_warnings(record=True):
+            warnings.simplefilter('always', RuntimeWarning)
+            assert_array_equal(cov(self.x1, ddof=5),
+                               np.array([[np.inf, -np.inf],
+                                         [-np.inf, np.inf]]))
+
+    def test_1D_rowvar(self):
+        assert_allclose(cov(self.x3), cov(self.x3, rowvar=False))
+        y = np.array([0.0780, 0.3107, 0.2111, 0.0334, 0.8501])
+        assert_allclose(cov(self.x3, y), cov(self.x3, y, rowvar=False))
+
+    def test_1D_variance(self):
+        assert_allclose(cov(self.x3, ddof=1), np.var(self.x3, ddof=1))
+
+    def test_fweights(self):
+        assert_allclose(cov(self.x2, fweights=self.frequencies),
+                        cov(self.x2_repeats))
+        assert_allclose(cov(self.x1, fweights=self.frequencies),
+                        self.res2)
+        assert_allclose(cov(self.x1, fweights=self.unit_frequencies),
+                        self.res1)
+        nonint = self.frequencies + 0.5
+        assert_raises(TypeError, cov, self.x1, fweights=nonint)
+        f = np.ones((2, 3), dtype=np.int_)
+        assert_raises(RuntimeError, cov, self.x1, fweights=f)
+        f = np.ones(2, dtype=np.int_)
+        assert_raises(RuntimeError, cov, self.x1, fweights=f)
+        f = -1 * np.ones(3, dtype=np.int_)
+        assert_raises(ValueError, cov, self.x1, fweights=f)
+
+    def test_aweights(self):
+        assert_allclose(cov(self.x1, aweights=self.weights), self.res3)
+        assert_allclose(cov(self.x1, aweights=3.0 * self.weights),
+                        cov(self.x1, aweights=self.weights))
+        assert_allclose(cov(self.x1, aweights=self.unit_weights), self.res1)
+        w = np.ones((2, 3))
+        assert_raises(RuntimeError, cov, self.x1, aweights=w)
+        w = np.ones(2)
+        assert_raises(RuntimeError, cov, self.x1, aweights=w)
+        w = -1.0 * np.ones(3)
+        assert_raises(ValueError, cov, self.x1, aweights=w)
+
+    def test_unit_fweights_and_aweights(self):
+        assert_allclose(cov(self.x2, fweights=self.frequencies,
+                            aweights=self.unit_weights),
+                        cov(self.x2_repeats))
+        assert_allclose(cov(self.x1, fweights=self.frequencies,
+                            aweights=self.unit_weights),
+                        self.res2)
+        assert_allclose(cov(self.x1, fweights=self.unit_frequencies,
+                            aweights=self.unit_weights),
+                        self.res1)
+        assert_allclose(cov(self.x1, fweights=self.unit_frequencies,
+                            aweights=self.weights),
+                        self.res3)
+        assert_allclose(cov(self.x1, fweights=self.unit_frequencies,
+                            aweights=3.0 * self.weights),
+                        cov(self.x1, aweights=self.weights))
+        assert_allclose(cov(self.x1, fweights=self.unit_frequencies,
+                            aweights=self.unit_weights),
+                        self.res1)
+
+    @pytest.mark.parametrize("test_type", [np.half, np.single, np.double, np.longdouble])
+    def test_cov_dtype(self, test_type):
+        cast_x1 = self.x1.astype(test_type)
+        res = cov(cast_x1, dtype=test_type)
+        assert test_type == res.dtype
+
+
+class Test_I0:
+
+    def test_simple(self):
+        assert_almost_equal(
+            i0(0.5),
+            np.array(1.0634833707413234))
+
+        # need at least one test above 8, as the implementation is piecewise
+        A = np.array([0.49842636, 0.6969809, 0.22011976, 0.0155549, 10.0])
+        expected = np.array([1.06307822, 1.12518299, 1.01214991, 1.00006049, 2815.71662847])
+        assert_almost_equal(i0(A), expected)
+        assert_almost_equal(i0(-A), expected)
+
+        B = np.array([[0.827002, 0.99959078],
+                      [0.89694769, 0.39298162],
+                      [0.37954418, 0.05206293],
+                      [0.36465447, 0.72446427],
+                      [0.48164949, 0.50324519]])
+        assert_almost_equal(
+            i0(B),
+            np.array([[1.17843223, 1.26583466],
+                      [1.21147086, 1.03898290],
+                      [1.03633899, 1.00067775],
+                      [1.03352052, 1.13557954],
+                      [1.05884290, 1.06432317]]))
+        # Regression test for gh-11205
+        i0_0 = np.i0([0.])
+        assert_equal(i0_0.shape, (1,))
+        assert_array_equal(np.i0([0.]), np.array([1.]))
+
+    def test_non_array(self):
+        a = np.arange(4)
+
+        class array_like:
+            __array_interface__ = a.__array_interface__
+
+            def __array_wrap__(self, arr, context, return_scalar):
+                return self
+
+        # E.g. pandas series survive ufunc calls through array-wrap:
+        assert isinstance(np.abs(array_like()), array_like)
+        exp = np.i0(a)
+        res = np.i0(array_like())
+
+        assert_array_equal(exp, res)
+
+    def test_complex(self):
+        a = np.array([0, 1 + 2j])
+        with pytest.raises(TypeError, match="i0 not supported for complex values"):
+            res = i0(a)
+
+
+class TestKaiser:
+
+    def test_simple(self):
+        assert_(np.isfinite(kaiser(1, 1.0)))
+        assert_almost_equal(kaiser(0, 1.0),
+                            np.array([]))
+        assert_almost_equal(kaiser(2, 1.0),
+                            np.array([0.78984831, 0.78984831]))
+        assert_almost_equal(kaiser(5, 1.0),
+                            np.array([0.78984831, 0.94503323, 1.,
+                                      0.94503323, 0.78984831]))
+        assert_almost_equal(kaiser(5, 1.56789),
+                            np.array([0.58285404, 0.88409679, 1.,
+                                      0.88409679, 0.58285404]))
+
+    def test_int_beta(self):
+        kaiser(3, 4)
+
+
+class TestMeshgrid:
+
+    def test_simple(self):
+        [X, Y] = meshgrid([1, 2, 3], [4, 5, 6, 7])
+        assert_array_equal(X, np.array([[1, 2, 3],
+                                        [1, 2, 3],
+                                        [1, 2, 3],
+                                        [1, 2, 3]]))
+        assert_array_equal(Y, np.array([[4, 4, 4],
+                                        [5, 5, 5],
+                                        [6, 6, 6],
+                                        [7, 7, 7]]))
+
+    def test_single_input(self):
+        [X] = meshgrid([1, 2, 3, 4])
+        assert_array_equal(X, np.array([1, 2, 3, 4]))
+
+    def test_no_input(self):
+        args = []
+        assert_array_equal([], meshgrid(*args))
+        assert_array_equal([], meshgrid(*args, copy=False))
+
+    def test_indexing(self):
+        x = [1, 2, 3]
+        y = [4, 5, 6, 7]
+        [X, Y] = meshgrid(x, y, indexing='ij')
+        assert_array_equal(X, np.array([[1, 1, 1, 1],
+                                        [2, 2, 2, 2],
+                                        [3, 3, 3, 3]]))
+        assert_array_equal(Y, np.array([[4, 5, 6, 7],
+                                        [4, 5, 6, 7],
+                                        [4, 5, 6, 7]]))
+
+        # Test expected shapes:
+        z = [8, 9]
+        assert_(meshgrid(x, y)[0].shape == (4, 3))
+        assert_(meshgrid(x, y, indexing='ij')[0].shape == (3, 4))
+        assert_(meshgrid(x, y, z)[0].shape == (4, 3, 2))
+        assert_(meshgrid(x, y, z, indexing='ij')[0].shape == (3, 4, 2))
+
+        assert_raises(ValueError, meshgrid, x, y, indexing='notvalid')
+
+    def test_sparse(self):
+        [X, Y] = meshgrid([1, 2, 3], [4, 5, 6, 7], sparse=True)
+        assert_array_equal(X, np.array([[1, 2, 3]]))
+        assert_array_equal(Y, np.array([[4], [5], [6], [7]]))
+
+    def test_invalid_arguments(self):
+        # Test that meshgrid complains about invalid arguments
+        # Regression test for issue #4755:
+        # https://github.com/numpy/numpy/issues/4755
+        assert_raises(TypeError, meshgrid,
+                      [1, 2, 3], [4, 5, 6, 7], indices='ij')
+
+    def test_return_type(self):
+        # Test for appropriate dtype in returned arrays.
+        # Regression test for issue #5297
+        # https://github.com/numpy/numpy/issues/5297
+        x = np.arange(0, 10, dtype=np.float32)
+        y = np.arange(10, 20, dtype=np.float64)
+
+        X, Y = np.meshgrid(x,y)
+
+        assert_(X.dtype == x.dtype)
+        assert_(Y.dtype == y.dtype)
+
+        # copy
+        X, Y = np.meshgrid(x,y, copy=True)
+
+        assert_(X.dtype == x.dtype)
+        assert_(Y.dtype == y.dtype)
+
+        # sparse
+        X, Y = np.meshgrid(x,y, sparse=True)
+
+        assert_(X.dtype == x.dtype)
+        assert_(Y.dtype == y.dtype)
+
+    def test_writeback(self):
+        # Issue 8561
+        X = np.array([1.1, 2.2])
+        Y = np.array([3.3, 4.4])
+        x, y = np.meshgrid(X, Y, sparse=False, copy=True)
+
+        x[0, :] = 0
+        assert_equal(x[0, :], 0)
+        assert_equal(x[1, :], X)
+
+    def test_nd_shape(self):
+        a, b, c, d, e = np.meshgrid(*([0] * i for i in range(1, 6)))
+        expected_shape = (2, 1, 3, 4, 5)
+        assert_equal(a.shape, expected_shape)
+        assert_equal(b.shape, expected_shape)
+        assert_equal(c.shape, expected_shape)
+        assert_equal(d.shape, expected_shape)
+        assert_equal(e.shape, expected_shape)
+
+    def test_nd_values(self):
+        a, b, c = np.meshgrid([0], [1, 2], [3, 4, 5])
+        assert_equal(a, [[[0, 0, 0]], [[0, 0, 0]]])
+        assert_equal(b, [[[1, 1, 1]], [[2, 2, 2]]])
+        assert_equal(c, [[[3, 4, 5]], [[3, 4, 5]]])
+
+    def test_nd_indexing(self):
+        a, b, c = np.meshgrid([0], [1, 2], [3, 4, 5], indexing='ij')
+        assert_equal(a, [[[0, 0, 0], [0, 0, 0]]])
+        assert_equal(b, [[[1, 1, 1], [2, 2, 2]]])
+        assert_equal(c, [[[3, 4, 5], [3, 4, 5]]])
+
+
+class TestPiecewise:
+
+    def test_simple(self):
+        # Condition is single bool list
+        x = piecewise([0, 0], [True, False], [1])
+        assert_array_equal(x, [1, 0])
+
+        # List of conditions: single bool list
+        x = piecewise([0, 0], [[True, False]], [1])
+        assert_array_equal(x, [1, 0])
+
+        # Conditions is single bool array
+        x = piecewise([0, 0], np.array([True, False]), [1])
+        assert_array_equal(x, [1, 0])
+
+        # Condition is single int array
+        x = piecewise([0, 0], np.array([1, 0]), [1])
+        assert_array_equal(x, [1, 0])
+
+        # List of conditions: int array
+        x = piecewise([0, 0], [np.array([1, 0])], [1])
+        assert_array_equal(x, [1, 0])
+
+        x = piecewise([0, 0], [[False, True]], [lambda x:-1])
+        assert_array_equal(x, [0, -1])
+
+        assert_raises_regex(ValueError, '1 or 2 functions are expected',
+            piecewise, [0, 0], [[False, True]], [])
+        assert_raises_regex(ValueError, '1 or 2 functions are expected',
+            piecewise, [0, 0], [[False, True]], [1, 2, 3])
+
+    def test_two_conditions(self):
+        x = piecewise([1, 2], [[True, False], [False, True]], [3, 4])
+        assert_array_equal(x, [3, 4])
+
+    def test_scalar_domains_three_conditions(self):
+        x = piecewise(3, [True, False, False], [4, 2, 0])
+        assert_equal(x, 4)
+
+    def test_default(self):
+        # No value specified for x[1], should be 0
+        x = piecewise([1, 2], [True, False], [2])
+        assert_array_equal(x, [2, 0])
+
+        # Should set x[1] to 3
+        x = piecewise([1, 2], [True, False], [2, 3])
+        assert_array_equal(x, [2, 3])
+
+    def test_0d(self):
+        x = np.array(3)
+        y = piecewise(x, x > 3, [4, 0])
+        assert_(y.ndim == 0)
+        assert_(y == 0)
+
+        x = 5
+        y = piecewise(x, [True, False], [1, 0])
+        assert_(y.ndim == 0)
+        assert_(y == 1)
+
+        # With 3 ranges (It was failing, before)
+        y = piecewise(x, [False, False, True], [1, 2, 3])
+        assert_array_equal(y, 3)
+
+    def test_0d_comparison(self):
+        x = 3
+        y = piecewise(x, [x <= 3, x > 3], [4, 0])  # Should succeed.
+        assert_equal(y, 4)
+
+        # With 3 ranges (It was failing, before)
+        x = 4
+        y = piecewise(x, [x <= 3, (x > 3) * (x <= 5), x > 5], [1, 2, 3])
+        assert_array_equal(y, 2)
+
+        assert_raises_regex(ValueError, '2 or 3 functions are expected',
+            piecewise, x, [x <= 3, x > 3], [1])
+        assert_raises_regex(ValueError, '2 or 3 functions are expected',
+            piecewise, x, [x <= 3, x > 3], [1, 1, 1, 1])
+
+    def test_0d_0d_condition(self):
+        x = np.array(3)
+        c = np.array(x > 3)
+        y = piecewise(x, [c], [1, 2])
+        assert_equal(y, 2)
+
+    def test_multidimensional_extrafunc(self):
+        x = np.array([[-2.5, -1.5, -0.5],
+                      [0.5, 1.5, 2.5]])
+        y = piecewise(x, [x < 0, x >= 2], [-1, 1, 3])
+        assert_array_equal(y, np.array([[-1., -1., -1.],
+                                        [3., 3., 1.]]))
+
+    def test_subclasses(self):
+        class subclass(np.ndarray):
+            pass
+        x = np.arange(5.).view(subclass)
+        r = piecewise(x, [x<2., x>=4], [-1., 1., 0.])
+        assert_equal(type(r), subclass)
+        assert_equal(r, [-1., -1., 0., 0., 1.])
+
+
+class TestBincount:
+
+    def test_simple(self):
+        y = np.bincount(np.arange(4))
+        assert_array_equal(y, np.ones(4))
+
+    def test_simple2(self):
+        y = np.bincount(np.array([1, 5, 2, 4, 1]))
+        assert_array_equal(y, np.array([0, 2, 1, 0, 1, 1]))
+
+    def test_simple_weight(self):
+        x = np.arange(4)
+        w = np.array([0.2, 0.3, 0.5, 0.1])
+        y = np.bincount(x, w)
+        assert_array_equal(y, w)
+
+    def test_simple_weight2(self):
+        x = np.array([1, 2, 4, 5, 2])
+        w = np.array([0.2, 0.3, 0.5, 0.1, 0.2])
+        y = np.bincount(x, w)
+        assert_array_equal(y, np.array([0, 0.2, 0.5, 0, 0.5, 0.1]))
+
+    def test_with_minlength(self):
+        x = np.array([0, 1, 0, 1, 1])
+        y = np.bincount(x, minlength=3)
+        assert_array_equal(y, np.array([2, 3, 0]))
+        x = []
+        y = np.bincount(x, minlength=0)
+        assert_array_equal(y, np.array([]))
+
+    def test_with_minlength_smaller_than_maxvalue(self):
+        x = np.array([0, 1, 1, 2, 2, 3, 3])
+        y = np.bincount(x, minlength=2)
+        assert_array_equal(y, np.array([1, 2, 2, 2]))
+        y = np.bincount(x, minlength=0)
+        assert_array_equal(y, np.array([1, 2, 2, 2]))
+
+    def test_with_minlength_and_weights(self):
+        x = np.array([1, 2, 4, 5, 2])
+        w = np.array([0.2, 0.3, 0.5, 0.1, 0.2])
+        y = np.bincount(x, w, 8)
+        assert_array_equal(y, np.array([0, 0.2, 0.5, 0, 0.5, 0.1, 0, 0]))
+
+    def test_empty(self):
+        x = np.array([], dtype=int)
+        y = np.bincount(x)
+        assert_array_equal(x, y)
+
+    def test_empty_with_minlength(self):
+        x = np.array([], dtype=int)
+        y = np.bincount(x, minlength=5)
+        assert_array_equal(y, np.zeros(5, dtype=int))
+
+    @pytest.mark.parametrize('minlength', [0, 3])
+    def test_empty_list(self, minlength):
+        assert_array_equal(np.bincount([], minlength=minlength),
+                           np.zeros(minlength, dtype=int))
+
+    def test_with_incorrect_minlength(self):
+        x = np.array([], dtype=int)
+        assert_raises_regex(TypeError,
+                            "'str' object cannot be interpreted",
+                            lambda: np.bincount(x, minlength="foobar"))
+        assert_raises_regex(ValueError,
+                            "must not be negative",
+                            lambda: np.bincount(x, minlength=-1))
+
+        x = np.arange(5)
+        assert_raises_regex(TypeError,
+                            "'str' object cannot be interpreted",
+                            lambda: np.bincount(x, minlength="foobar"))
+        assert_raises_regex(ValueError,
+                            "must not be negative",
+                            lambda: np.bincount(x, minlength=-1))
+
+    @pytest.mark.skipif(not HAS_REFCOUNT, reason="Python lacks refcounts")
+    def test_dtype_reference_leaks(self):
+        # gh-6805
+        intp_refcount = sys.getrefcount(np.dtype(np.intp))
+        double_refcount = sys.getrefcount(np.dtype(np.double))
+
+        for j in range(10):
+            np.bincount([1, 2, 3])
+        assert_equal(sys.getrefcount(np.dtype(np.intp)), intp_refcount)
+        assert_equal(sys.getrefcount(np.dtype(np.double)), double_refcount)
+
+        for j in range(10):
+            np.bincount([1, 2, 3], [4, 5, 6])
+        assert_equal(sys.getrefcount(np.dtype(np.intp)), intp_refcount)
+        assert_equal(sys.getrefcount(np.dtype(np.double)), double_refcount)
+
+    @pytest.mark.parametrize("vals", [[[2, 2]], 2])
+    def test_error_not_1d(self, vals):
+        # Test that values has to be 1-D (both as array and nested list)
+        vals_arr = np.asarray(vals)
+        with assert_raises(ValueError):
+            np.bincount(vals_arr)
+        with assert_raises(ValueError):
+            np.bincount(vals)
+
+
+class TestInterp:
+
+    def test_exceptions(self):
+        assert_raises(ValueError, interp, 0, [], [])
+        assert_raises(ValueError, interp, 0, [0], [1, 2])
+        assert_raises(ValueError, interp, 0, [0, 1], [1, 2], period=0)
+        assert_raises(ValueError, interp, 0, [], [], period=360)
+        assert_raises(ValueError, interp, 0, [0], [1, 2], period=360)
+
+    def test_basic(self):
+        x = np.linspace(0, 1, 5)
+        y = np.linspace(0, 1, 5)
+        x0 = np.linspace(0, 1, 50)
+        assert_almost_equal(np.interp(x0, x, y), x0)
+
+    def test_right_left_behavior(self):
+        # Needs range of sizes to test different code paths.
+        # size ==1 is special cased, 1 < size < 5 is linear search, and
+        # size >= 5 goes through local search and possibly binary search.
+        for size in range(1, 10):
+            xp = np.arange(size, dtype=np.double)
+            yp = np.ones(size, dtype=np.double)
+            incpts = np.array([-1, 0, size - 1, size], dtype=np.double)
+            decpts = incpts[::-1]
+
+            incres = interp(incpts, xp, yp)
+            decres = interp(decpts, xp, yp)
+            inctgt = np.array([1, 1, 1, 1], dtype=float)
+            dectgt = inctgt[::-1]
+            assert_equal(incres, inctgt)
+            assert_equal(decres, dectgt)
+
+            incres = interp(incpts, xp, yp, left=0)
+            decres = interp(decpts, xp, yp, left=0)
+            inctgt = np.array([0, 1, 1, 1], dtype=float)
+            dectgt = inctgt[::-1]
+            assert_equal(incres, inctgt)
+            assert_equal(decres, dectgt)
+
+            incres = interp(incpts, xp, yp, right=2)
+            decres = interp(decpts, xp, yp, right=2)
+            inctgt = np.array([1, 1, 1, 2], dtype=float)
+            dectgt = inctgt[::-1]
+            assert_equal(incres, inctgt)
+            assert_equal(decres, dectgt)
+
+            incres = interp(incpts, xp, yp, left=0, right=2)
+            decres = interp(decpts, xp, yp, left=0, right=2)
+            inctgt = np.array([0, 1, 1, 2], dtype=float)
+            dectgt = inctgt[::-1]
+            assert_equal(incres, inctgt)
+            assert_equal(decres, dectgt)
+
+    def test_scalar_interpolation_point(self):
+        x = np.linspace(0, 1, 5)
+        y = np.linspace(0, 1, 5)
+        x0 = 0
+        assert_almost_equal(np.interp(x0, x, y), x0)
+        x0 = .3
+        assert_almost_equal(np.interp(x0, x, y), x0)
+        x0 = np.float32(.3)
+        assert_almost_equal(np.interp(x0, x, y), x0)
+        x0 = np.float64(.3)
+        assert_almost_equal(np.interp(x0, x, y), x0)
+        x0 = np.nan
+        assert_almost_equal(np.interp(x0, x, y), x0)
+
+    def test_non_finite_behavior_exact_x(self):
+        x = [1, 2, 2.5, 3, 4]
+        xp = [1, 2, 3, 4]
+        fp = [1, 2, np.inf, 4]
+        assert_almost_equal(np.interp(x, xp, fp), [1, 2, np.inf, np.inf, 4])
+        fp = [1, 2, np.nan, 4]
+        assert_almost_equal(np.interp(x, xp, fp), [1, 2, np.nan, np.nan, 4])
+
+    @pytest.fixture(params=[
+        lambda x: np.float64(x),
+        lambda x: _make_complex(x, 0),
+        lambda x: _make_complex(0, x),
+        lambda x: _make_complex(x, np.multiply(x, -2))
+    ], ids=[
+        'real',
+        'complex-real',
+        'complex-imag',
+        'complex-both'
+    ])
+    def sc(self, request):
+        """ scale function used by the below tests """
+        return request.param
+
+    def test_non_finite_any_nan(self, sc):
+        """ test that nans are propagated """
+        assert_equal(np.interp(0.5, [np.nan,      1], sc([     0,     10])), sc(np.nan))
+        assert_equal(np.interp(0.5, [     0, np.nan], sc([     0,     10])), sc(np.nan))
+        assert_equal(np.interp(0.5, [     0,      1], sc([np.nan,     10])), sc(np.nan))
+        assert_equal(np.interp(0.5, [     0,      1], sc([     0, np.nan])), sc(np.nan))
+
+    def test_non_finite_inf(self, sc):
+        """ Test that interp between opposite infs gives nan """
+        assert_equal(np.interp(0.5, [-np.inf, +np.inf], sc([      0,      10])), sc(np.nan))
+        assert_equal(np.interp(0.5, [      0,       1], sc([-np.inf, +np.inf])), sc(np.nan))
+        assert_equal(np.interp(0.5, [      0,       1], sc([+np.inf, -np.inf])), sc(np.nan))
+
+        # unless the y values are equal
+        assert_equal(np.interp(0.5, [-np.inf, +np.inf], sc([     10,      10])), sc(10))
+
+    def test_non_finite_half_inf_xf(self, sc):
+        """ Test that interp where both axes have a bound at inf gives nan """
+        assert_equal(np.interp(0.5, [-np.inf,       1], sc([-np.inf,      10])), sc(np.nan))
+        assert_equal(np.interp(0.5, [-np.inf,       1], sc([+np.inf,      10])), sc(np.nan))
+        assert_equal(np.interp(0.5, [-np.inf,       1], sc([      0, -np.inf])), sc(np.nan))
+        assert_equal(np.interp(0.5, [-np.inf,       1], sc([      0, +np.inf])), sc(np.nan))
+        assert_equal(np.interp(0.5, [      0, +np.inf], sc([-np.inf,      10])), sc(np.nan))
+        assert_equal(np.interp(0.5, [      0, +np.inf], sc([+np.inf,      10])), sc(np.nan))
+        assert_equal(np.interp(0.5, [      0, +np.inf], sc([      0, -np.inf])), sc(np.nan))
+        assert_equal(np.interp(0.5, [      0, +np.inf], sc([      0, +np.inf])), sc(np.nan))
+
+    def test_non_finite_half_inf_x(self, sc):
+        """ Test interp where the x axis has a bound at inf """
+        assert_equal(np.interp(0.5, [-np.inf, -np.inf], sc([0, 10])), sc(10))
+        assert_equal(np.interp(0.5, [-np.inf, 1      ], sc([0, 10])), sc(10))
+        assert_equal(np.interp(0.5, [      0, +np.inf], sc([0, 10])), sc(0))
+        assert_equal(np.interp(0.5, [+np.inf, +np.inf], sc([0, 10])), sc(0))
+
+    def test_non_finite_half_inf_f(self, sc):
+        """ Test interp where the f axis has a bound at inf """
+        assert_equal(np.interp(0.5, [0, 1], sc([      0, -np.inf])), sc(-np.inf))
+        assert_equal(np.interp(0.5, [0, 1], sc([      0, +np.inf])), sc(+np.inf))
+        assert_equal(np.interp(0.5, [0, 1], sc([-np.inf,      10])), sc(-np.inf))
+        assert_equal(np.interp(0.5, [0, 1], sc([+np.inf,      10])), sc(+np.inf))
+        assert_equal(np.interp(0.5, [0, 1], sc([-np.inf, -np.inf])), sc(-np.inf))
+        assert_equal(np.interp(0.5, [0, 1], sc([+np.inf, +np.inf])), sc(+np.inf))
+
+    def test_complex_interp(self):
+        # test complex interpolation
+        x = np.linspace(0, 1, 5)
+        y = np.linspace(0, 1, 5) + (1 + np.linspace(0, 1, 5))*1.0j
+        x0 = 0.3
+        y0 = x0 + (1+x0)*1.0j
+        assert_almost_equal(np.interp(x0, x, y), y0)
+        # test complex left and right
+        x0 = -1
+        left = 2 + 3.0j
+        assert_almost_equal(np.interp(x0, x, y, left=left), left)
+        x0 = 2.0
+        right = 2 + 3.0j
+        assert_almost_equal(np.interp(x0, x, y, right=right), right)
+        # test complex non finite
+        x = [1, 2, 2.5, 3, 4]
+        xp = [1, 2, 3, 4]
+        fp = [1, 2+1j, np.inf, 4]
+        y = [1, 2+1j, np.inf+0.5j, np.inf, 4]
+        assert_almost_equal(np.interp(x, xp, fp), y)
+        # test complex periodic
+        x = [-180, -170, -185, 185, -10, -5, 0, 365]
+        xp = [190, -190, 350, -350]
+        fp = [5+1.0j, 10+2j, 3+3j, 4+4j]
+        y = [7.5+1.5j, 5.+1.0j, 8.75+1.75j, 6.25+1.25j, 3.+3j, 3.25+3.25j,
+             3.5+3.5j, 3.75+3.75j]
+        assert_almost_equal(np.interp(x, xp, fp, period=360), y)
+
+    def test_zero_dimensional_interpolation_point(self):
+        x = np.linspace(0, 1, 5)
+        y = np.linspace(0, 1, 5)
+        x0 = np.array(.3)
+        assert_almost_equal(np.interp(x0, x, y), x0)
+
+        xp = np.array([0, 2, 4])
+        fp = np.array([1, -1, 1])
+
+        actual = np.interp(np.array(1), xp, fp)
+        assert_equal(actual, 0)
+        assert_(isinstance(actual, np.float64))
+
+        actual = np.interp(np.array(4.5), xp, fp, period=4)
+        assert_equal(actual, 0.5)
+        assert_(isinstance(actual, np.float64))
+
+    def test_if_len_x_is_small(self):
+        xp = np.arange(0, 10, 0.0001)
+        fp = np.sin(xp)
+        assert_almost_equal(np.interp(np.pi, xp, fp), 0.0)
+
+    def test_period(self):
+        x = [-180, -170, -185, 185, -10, -5, 0, 365]
+        xp = [190, -190, 350, -350]
+        fp = [5, 10, 3, 4]
+        y = [7.5, 5., 8.75, 6.25, 3., 3.25, 3.5, 3.75]
+        assert_almost_equal(np.interp(x, xp, fp, period=360), y)
+        x = np.array(x, order='F').reshape(2, -1)
+        y = np.array(y, order='C').reshape(2, -1)
+        assert_almost_equal(np.interp(x, xp, fp, period=360), y)
+
+
+class TestPercentile:
+
+    def test_basic(self):
+        x = np.arange(8) * 0.5
+        assert_equal(np.percentile(x, 0), 0.)
+        assert_equal(np.percentile(x, 100), 3.5)
+        assert_equal(np.percentile(x, 50), 1.75)
+        x[1] = np.nan
+        assert_equal(np.percentile(x, 0), np.nan)
+        assert_equal(np.percentile(x, 0, method='nearest'), np.nan)
+        assert_equal(np.percentile(x, 0, method='inverted_cdf'), np.nan)
+        assert_equal(
+            np.percentile(x, 0, method='inverted_cdf',
+                          weights=np.ones_like(x)),
+            np.nan,
+        )
+
+    def test_fraction(self):
+        x = [Fraction(i, 2) for i in range(8)]
+
+        p = np.percentile(x, Fraction(0))
+        assert_equal(p, Fraction(0))
+        assert_equal(type(p), Fraction)
+
+        p = np.percentile(x, Fraction(100))
+        assert_equal(p, Fraction(7, 2))
+        assert_equal(type(p), Fraction)
+
+        p = np.percentile(x, Fraction(50))
+        assert_equal(p, Fraction(7, 4))
+        assert_equal(type(p), Fraction)
+
+        p = np.percentile(x, [Fraction(50)])
+        assert_equal(p, np.array([Fraction(7, 4)]))
+        assert_equal(type(p), np.ndarray)
+
+    def test_api(self):
+        d = np.ones(5)
+        np.percentile(d, 5, None, None, False)
+        np.percentile(d, 5, None, None, False, 'linear')
+        o = np.ones((1,))
+        np.percentile(d, 5, None, o, False, 'linear')
+
+    def test_complex(self):
+        arr_c = np.array([0.5+3.0j, 2.1+0.5j, 1.6+2.3j], dtype='G')
+        assert_raises(TypeError, np.percentile, arr_c, 0.5)
+        arr_c = np.array([0.5+3.0j, 2.1+0.5j, 1.6+2.3j], dtype='D')
+        assert_raises(TypeError, np.percentile, arr_c, 0.5)
+        arr_c = np.array([0.5+3.0j, 2.1+0.5j, 1.6+2.3j], dtype='F')
+        assert_raises(TypeError, np.percentile, arr_c, 0.5)
+
+    def test_2D(self):
+        x = np.array([[1, 1, 1],
+                      [1, 1, 1],
+                      [4, 4, 3],
+                      [1, 1, 1],
+                      [1, 1, 1]])
+        assert_array_equal(np.percentile(x, 50, axis=0), [1, 1, 1])
+
+    @pytest.mark.parametrize("dtype", np.typecodes["Float"])
+    def test_linear_nan_1D(self, dtype):
+        # METHOD 1 of H&F
+        arr = np.asarray([15.0, np.nan, 35.0, 40.0, 50.0], dtype=dtype)
+        res = np.percentile(
+            arr,
+            40.0,
+            method="linear")
+        np.testing.assert_equal(res, np.nan)
+        np.testing.assert_equal(res.dtype, arr.dtype)
+
+    H_F_TYPE_CODES = [(int_type, np.float64)
+                      for int_type in np.typecodes["AllInteger"]
+                      ] + [(np.float16, np.float16),
+                           (np.float32, np.float32),
+                           (np.float64, np.float64),
+                           (np.longdouble, np.longdouble),
+                           (np.dtype("O"), np.float64)]
+
+    @pytest.mark.parametrize(["function", "quantile"],
+                             [(np.quantile, 0.4),
+                              (np.percentile, 40.0)])
+    @pytest.mark.parametrize(["input_dtype", "expected_dtype"], H_F_TYPE_CODES)
+    @pytest.mark.parametrize(["method", "weighted", "expected"],
+                              [("inverted_cdf", False, 20),
+                              ("inverted_cdf", True, 20),
+                              ("averaged_inverted_cdf", False, 27.5),
+                              ("closest_observation", False, 20),
+                              ("interpolated_inverted_cdf", False, 20),
+                              ("hazen", False, 27.5),
+                              ("weibull", False, 26),
+                              ("linear", False, 29),
+                              ("median_unbiased", False, 27),
+                              ("normal_unbiased", False, 27.125),
+                               ])
+    def test_linear_interpolation(self,
+                                  function,
+                                  quantile,
+                                  method,
+                                  weighted,
+                                  expected,
+                                  input_dtype,
+                                  expected_dtype):
+        expected_dtype = np.dtype(expected_dtype)
+        if np._get_promotion_state() == "legacy":
+            expected_dtype = np.promote_types(expected_dtype, np.float64)
+
+        arr = np.asarray([15.0, 20.0, 35.0, 40.0, 50.0], dtype=input_dtype)
+        weights = np.ones_like(arr) if weighted else None
+        if input_dtype is np.longdouble:
+            if function is np.quantile:
+                # 0.4 is not exactly representable and it matters
+                # for "averaged_inverted_cdf", so we need to cheat.
+                quantile = input_dtype("0.4")
+            # We want to use nulp, but that does not work for longdouble
+            test_function = np.testing.assert_almost_equal
+        else:
+            test_function = np.testing.assert_array_almost_equal_nulp
+
+        actual = function(arr, quantile, method=method, weights=weights)
+
+        test_function(actual, expected_dtype.type(expected))
+
+        if method in ["inverted_cdf", "closest_observation"]:
+            if input_dtype == "O":
+                np.testing.assert_equal(np.asarray(actual).dtype, np.float64)
+            else:
+                np.testing.assert_equal(np.asarray(actual).dtype,
+                                        np.dtype(input_dtype))
+        else:
+            np.testing.assert_equal(np.asarray(actual).dtype,
+                                    np.dtype(expected_dtype))
+
+    TYPE_CODES = np.typecodes["AllInteger"] + np.typecodes["Float"] + "O"
+
+    @pytest.mark.parametrize("dtype", TYPE_CODES)
+    def test_lower_higher(self, dtype):
+        assert_equal(np.percentile(np.arange(10, dtype=dtype), 50,
+                                   method='lower'), 4)
+        assert_equal(np.percentile(np.arange(10, dtype=dtype), 50,
+                                   method='higher'), 5)
+
+    @pytest.mark.parametrize("dtype", TYPE_CODES)
+    def test_midpoint(self, dtype):
+        assert_equal(np.percentile(np.arange(10, dtype=dtype), 51,
+                                   method='midpoint'), 4.5)
+        assert_equal(np.percentile(np.arange(9, dtype=dtype) + 1, 50,
+                                   method='midpoint'), 5)
+        assert_equal(np.percentile(np.arange(11, dtype=dtype), 51,
+                                   method='midpoint'), 5.5)
+        assert_equal(np.percentile(np.arange(11, dtype=dtype), 50,
+                                   method='midpoint'), 5)
+
+    @pytest.mark.parametrize("dtype", TYPE_CODES)
+    def test_nearest(self, dtype):
+        assert_equal(np.percentile(np.arange(10, dtype=dtype), 51,
+                                   method='nearest'), 5)
+        assert_equal(np.percentile(np.arange(10, dtype=dtype), 49,
+                                   method='nearest'), 4)
+
+    def test_linear_interpolation_extrapolation(self):
+        arr = np.random.rand(5)
+
+        actual = np.percentile(arr, 100)
+        np.testing.assert_equal(actual, arr.max())
+
+        actual = np.percentile(arr, 0)
+        np.testing.assert_equal(actual, arr.min())
+
+    def test_sequence(self):
+        x = np.arange(8) * 0.5
+        assert_equal(np.percentile(x, [0, 100, 50]), [0, 3.5, 1.75])
+
+    def test_axis(self):
+        x = np.arange(12).reshape(3, 4)
+
+        assert_equal(np.percentile(x, (25, 50, 100)), [2.75, 5.5, 11.0])
+
+        r0 = [[2, 3, 4, 5], [4, 5, 6, 7], [8, 9, 10, 11]]
+        assert_equal(np.percentile(x, (25, 50, 100), axis=0), r0)
+
+        r1 = [[0.75, 1.5, 3], [4.75, 5.5, 7], [8.75, 9.5, 11]]
+        assert_equal(np.percentile(x, (25, 50, 100), axis=1), np.array(r1).T)
+
+        # ensure qth axis is always first as with np.array(old_percentile(..))
+        x = np.arange(3 * 4 * 5 * 6).reshape(3, 4, 5, 6)
+        assert_equal(np.percentile(x, (25, 50)).shape, (2,))
+        assert_equal(np.percentile(x, (25, 50, 75)).shape, (3,))
+        assert_equal(np.percentile(x, (25, 50), axis=0).shape, (2, 4, 5, 6))
+        assert_equal(np.percentile(x, (25, 50), axis=1).shape, (2, 3, 5, 6))
+        assert_equal(np.percentile(x, (25, 50), axis=2).shape, (2, 3, 4, 6))
+        assert_equal(np.percentile(x, (25, 50), axis=3).shape, (2, 3, 4, 5))
+        assert_equal(
+            np.percentile(x, (25, 50, 75), axis=1).shape, (3, 3, 5, 6))
+        assert_equal(np.percentile(x, (25, 50),
+                                   method="higher").shape, (2,))
+        assert_equal(np.percentile(x, (25, 50, 75),
+                                   method="higher").shape, (3,))
+        assert_equal(np.percentile(x, (25, 50), axis=0,
+                                   method="higher").shape, (2, 4, 5, 6))
+        assert_equal(np.percentile(x, (25, 50), axis=1,
+                                   method="higher").shape, (2, 3, 5, 6))
+        assert_equal(np.percentile(x, (25, 50), axis=2,
+                                   method="higher").shape, (2, 3, 4, 6))
+        assert_equal(np.percentile(x, (25, 50), axis=3,
+                                   method="higher").shape, (2, 3, 4, 5))
+        assert_equal(np.percentile(x, (25, 50, 75), axis=1,
+                                   method="higher").shape, (3, 3, 5, 6))
+
+    def test_scalar_q(self):
+        # test for no empty dimensions for compatibility with old percentile
+        x = np.arange(12).reshape(3, 4)
+        assert_equal(np.percentile(x, 50), 5.5)
+        assert_(np.isscalar(np.percentile(x, 50)))
+        r0 = np.array([4.,  5.,  6.,  7.])
+        assert_equal(np.percentile(x, 50, axis=0), r0)
+        assert_equal(np.percentile(x, 50, axis=0).shape, r0.shape)
+        r1 = np.array([1.5,  5.5,  9.5])
+        assert_almost_equal(np.percentile(x, 50, axis=1), r1)
+        assert_equal(np.percentile(x, 50, axis=1).shape, r1.shape)
+
+        out = np.empty(1)
+        assert_equal(np.percentile(x, 50, out=out), 5.5)
+        assert_equal(out, 5.5)
+        out = np.empty(4)
+        assert_equal(np.percentile(x, 50, axis=0, out=out), r0)
+        assert_equal(out, r0)
+        out = np.empty(3)
+        assert_equal(np.percentile(x, 50, axis=1, out=out), r1)
+        assert_equal(out, r1)
+
+        # test for no empty dimensions for compatibility with old percentile
+        x = np.arange(12).reshape(3, 4)
+        assert_equal(np.percentile(x, 50, method='lower'), 5.)
+        assert_(np.isscalar(np.percentile(x, 50)))
+        r0 = np.array([4.,  5.,  6.,  7.])
+        c0 = np.percentile(x, 50, method='lower', axis=0)
+        assert_equal(c0, r0)
+        assert_equal(c0.shape, r0.shape)
+        r1 = np.array([1.,  5.,  9.])
+        c1 = np.percentile(x, 50, method='lower', axis=1)
+        assert_almost_equal(c1, r1)
+        assert_equal(c1.shape, r1.shape)
+
+        out = np.empty((), dtype=x.dtype)
+        c = np.percentile(x, 50, method='lower', out=out)
+        assert_equal(c, 5)
+        assert_equal(out, 5)
+        out = np.empty(4, dtype=x.dtype)
+        c = np.percentile(x, 50, method='lower', axis=0, out=out)
+        assert_equal(c, r0)
+        assert_equal(out, r0)
+        out = np.empty(3, dtype=x.dtype)
+        c = np.percentile(x, 50, method='lower', axis=1, out=out)
+        assert_equal(c, r1)
+        assert_equal(out, r1)
+
+    def test_exception(self):
+        assert_raises(ValueError, np.percentile, [1, 2], 56,
+                      method='foobar')
+        assert_raises(ValueError, np.percentile, [1], 101)
+        assert_raises(ValueError, np.percentile, [1], -1)
+        assert_raises(ValueError, np.percentile, [1], list(range(50)) + [101])
+        assert_raises(ValueError, np.percentile, [1], list(range(50)) + [-0.1])
+
+    def test_percentile_list(self):
+        assert_equal(np.percentile([1, 2, 3], 0), 1)
+
+    @pytest.mark.parametrize(
+        "percentile, with_weights",
+        [
+            (np.percentile, False),
+            (partial(np.percentile, method="inverted_cdf"), True),
+        ]
+    )
+    def test_percentile_out(self, percentile, with_weights):
+        out_dtype = int if with_weights else float
+        x = np.array([1, 2, 3])
+        y = np.zeros((3,), dtype=out_dtype)
+        p = (1, 2, 3)
+        weights = np.ones_like(x) if with_weights else None
+        r = percentile(x, p, out=y, weights=weights)
+        assert r is y
+        assert_equal(percentile(x, p, weights=weights), y)
+
+        x = np.array([[1, 2, 3],
+                      [4, 5, 6]])
+        y = np.zeros((3, 3), dtype=out_dtype)
+        weights = np.ones_like(x) if with_weights else None
+        r = percentile(x, p, axis=0, out=y, weights=weights)
+        assert r is y
+        assert_equal(percentile(x, p, weights=weights, axis=0), y)
+
+        y = np.zeros((3, 2), dtype=out_dtype)
+        percentile(x, p, axis=1, out=y, weights=weights)
+        assert_equal(percentile(x, p, weights=weights, axis=1), y)
+
+        x = np.arange(12).reshape(3, 4)
+        # q.dim > 1, float
+        if with_weights:
+            r0 = np.array([[0, 1, 2, 3], [4, 5, 6, 7]])
+        else:
+            r0 = np.array([[2., 3., 4., 5.], [4., 5., 6., 7.]])
+        out = np.empty((2, 4), dtype=out_dtype)
+        weights = np.ones_like(x) if with_weights else None
+        assert_equal(
+            percentile(x, (25, 50), axis=0, out=out, weights=weights), r0
+        )
+        assert_equal(out, r0)
+        r1 = np.array([[0.75,  4.75,  8.75], [1.5,  5.5,  9.5]])
+        out = np.empty((2, 3))
+        assert_equal(np.percentile(x, (25, 50), axis=1, out=out), r1)
+        assert_equal(out, r1)
+
+        # q.dim > 1, int
+        r0 = np.array([[0,  1,  2, 3], [4, 5, 6, 7]])
+        out = np.empty((2, 4), dtype=x.dtype)
+        c = np.percentile(x, (25, 50), method='lower', axis=0, out=out)
+        assert_equal(c, r0)
+        assert_equal(out, r0)
+        r1 = np.array([[0,  4,  8], [1,  5,  9]])
+        out = np.empty((2, 3), dtype=x.dtype)
+        c = np.percentile(x, (25, 50), method='lower', axis=1, out=out)
+        assert_equal(c, r1)
+        assert_equal(out, r1)
+
+    def test_percentile_empty_dim(self):
+        # empty dims are preserved
+        d = np.arange(11 * 2).reshape(11, 1, 2, 1)
+        assert_array_equal(np.percentile(d, 50, axis=0).shape, (1, 2, 1))
+        assert_array_equal(np.percentile(d, 50, axis=1).shape, (11, 2, 1))
+        assert_array_equal(np.percentile(d, 50, axis=2).shape, (11, 1, 1))
+        assert_array_equal(np.percentile(d, 50, axis=3).shape, (11, 1, 2))
+        assert_array_equal(np.percentile(d, 50, axis=-1).shape, (11, 1, 2))
+        assert_array_equal(np.percentile(d, 50, axis=-2).shape, (11, 1, 1))
+        assert_array_equal(np.percentile(d, 50, axis=-3).shape, (11, 2, 1))
+        assert_array_equal(np.percentile(d, 50, axis=-4).shape, (1, 2, 1))
+
+        assert_array_equal(np.percentile(d, 50, axis=2,
+                                         method='midpoint').shape,
+                           (11, 1, 1))
+        assert_array_equal(np.percentile(d, 50, axis=-2,
+                                         method='midpoint').shape,
+                           (11, 1, 1))
+
+        assert_array_equal(np.array(np.percentile(d, [10, 50], axis=0)).shape,
+                           (2, 1, 2, 1))
+        assert_array_equal(np.array(np.percentile(d, [10, 50], axis=1)).shape,
+                           (2, 11, 2, 1))
+        assert_array_equal(np.array(np.percentile(d, [10, 50], axis=2)).shape,
+                           (2, 11, 1, 1))
+        assert_array_equal(np.array(np.percentile(d, [10, 50], axis=3)).shape,
+                           (2, 11, 1, 2))
+
+    def test_percentile_no_overwrite(self):
+        a = np.array([2, 3, 4, 1])
+        np.percentile(a, [50], overwrite_input=False)
+        assert_equal(a, np.array([2, 3, 4, 1]))
+
+        a = np.array([2, 3, 4, 1])
+        np.percentile(a, [50])
+        assert_equal(a, np.array([2, 3, 4, 1]))
+
+    def test_no_p_overwrite(self):
+        p = np.linspace(0., 100., num=5)
+        np.percentile(np.arange(100.), p, method="midpoint")
+        assert_array_equal(p, np.linspace(0., 100., num=5))
+        p = np.linspace(0., 100., num=5).tolist()
+        np.percentile(np.arange(100.), p, method="midpoint")
+        assert_array_equal(p, np.linspace(0., 100., num=5).tolist())
+
+    def test_percentile_overwrite(self):
+        a = np.array([2, 3, 4, 1])
+        b = np.percentile(a, [50], overwrite_input=True)
+        assert_equal(b, np.array([2.5]))
+
+        b = np.percentile([2, 3, 4, 1], [50], overwrite_input=True)
+        assert_equal(b, np.array([2.5]))
+
+    def test_extended_axis(self):
+        o = np.random.normal(size=(71, 23))
+        x = np.dstack([o] * 10)
+        assert_equal(np.percentile(x, 30, axis=(0, 1)), np.percentile(o, 30))
+        x = np.moveaxis(x, -1, 0)
+        assert_equal(np.percentile(x, 30, axis=(-2, -1)), np.percentile(o, 30))
+        x = x.swapaxes(0, 1).copy()
+        assert_equal(np.percentile(x, 30, axis=(0, -1)), np.percentile(o, 30))
+        x = x.swapaxes(0, 1).copy()
+
+        assert_equal(np.percentile(x, [25, 60], axis=(0, 1, 2)),
+                     np.percentile(x, [25, 60], axis=None))
+        assert_equal(np.percentile(x, [25, 60], axis=(0,)),
+                     np.percentile(x, [25, 60], axis=0))
+
+        d = np.arange(3 * 5 * 7 * 11).reshape((3, 5, 7, 11))
+        np.random.shuffle(d.ravel())
+        assert_equal(np.percentile(d, 25,  axis=(0, 1, 2))[0],
+                     np.percentile(d[:,:,:, 0].flatten(), 25))
+        assert_equal(np.percentile(d, [10, 90], axis=(0, 1, 3))[:, 1],
+                     np.percentile(d[:,:, 1,:].flatten(), [10, 90]))
+        assert_equal(np.percentile(d, 25, axis=(3, 1, -4))[2],
+                     np.percentile(d[:,:, 2,:].flatten(), 25))
+        assert_equal(np.percentile(d, 25, axis=(3, 1, 2))[2],
+                     np.percentile(d[2,:,:,:].flatten(), 25))
+        assert_equal(np.percentile(d, 25, axis=(3, 2))[2, 1],
+                     np.percentile(d[2, 1,:,:].flatten(), 25))
+        assert_equal(np.percentile(d, 25, axis=(1, -2))[2, 1],
+                     np.percentile(d[2,:,:, 1].flatten(), 25))
+        assert_equal(np.percentile(d, 25, axis=(1, 3))[2, 2],
+                     np.percentile(d[2,:, 2,:].flatten(), 25))
+
+    def test_extended_axis_invalid(self):
+        d = np.ones((3, 5, 7, 11))
+        assert_raises(AxisError, np.percentile, d, axis=-5, q=25)
+        assert_raises(AxisError, np.percentile, d, axis=(0, -5), q=25)
+        assert_raises(AxisError, np.percentile, d, axis=4, q=25)
+        assert_raises(AxisError, np.percentile, d, axis=(0, 4), q=25)
+        # each of these refers to the same axis twice
+        assert_raises(ValueError, np.percentile, d, axis=(1, 1), q=25)
+        assert_raises(ValueError, np.percentile, d, axis=(-1, -1), q=25)
+        assert_raises(ValueError, np.percentile, d, axis=(3, -1), q=25)
+
+    def test_keepdims(self):
+        d = np.ones((3, 5, 7, 11))
+        assert_equal(np.percentile(d, 7, axis=None, keepdims=True).shape,
+                     (1, 1, 1, 1))
+        assert_equal(np.percentile(d, 7, axis=(0, 1), keepdims=True).shape,
+                     (1, 1, 7, 11))
+        assert_equal(np.percentile(d, 7, axis=(0, 3), keepdims=True).shape,
+                     (1, 5, 7, 1))
+        assert_equal(np.percentile(d, 7, axis=(1,), keepdims=True).shape,
+                     (3, 1, 7, 11))
+        assert_equal(np.percentile(d, 7, (0, 1, 2, 3), keepdims=True).shape,
+                     (1, 1, 1, 1))
+        assert_equal(np.percentile(d, 7, axis=(0, 1, 3), keepdims=True).shape,
+                     (1, 1, 7, 1))
+
+        assert_equal(np.percentile(d, [1, 7], axis=(0, 1, 3),
+                                   keepdims=True).shape, (2, 1, 1, 7, 1))
+        assert_equal(np.percentile(d, [1, 7], axis=(0, 3),
+                                   keepdims=True).shape, (2, 1, 5, 7, 1))
+
+    @pytest.mark.parametrize('q', [7, [1, 7]])
+    @pytest.mark.parametrize(
+        argnames='axis',
+        argvalues=[
+            None,
+            1,
+            (1,),
+            (0, 1),
+            (-3, -1),
+        ]
+    )
+    def test_keepdims_out(self, q, axis):
+        d = np.ones((3, 5, 7, 11))
+        if axis is None:
+            shape_out = (1,) * d.ndim
+        else:
+            axis_norm = normalize_axis_tuple(axis, d.ndim)
+            shape_out = tuple(
+                1 if i in axis_norm else d.shape[i] for i in range(d.ndim))
+        shape_out = np.shape(q) + shape_out
+
+        out = np.empty(shape_out)
+        result = np.percentile(d, q, axis=axis, keepdims=True, out=out)
+        assert result is out
+        assert_equal(result.shape, shape_out)
+
+    def test_out(self):
+        o = np.zeros((4,))
+        d = np.ones((3, 4))
+        assert_equal(np.percentile(d, 0, 0, out=o), o)
+        assert_equal(np.percentile(d, 0, 0, method='nearest', out=o), o)
+        o = np.zeros((3,))
+        assert_equal(np.percentile(d, 1, 1, out=o), o)
+        assert_equal(np.percentile(d, 1, 1, method='nearest', out=o), o)
+
+        o = np.zeros(())
+        assert_equal(np.percentile(d, 2, out=o), o)
+        assert_equal(np.percentile(d, 2, method='nearest', out=o), o)
+
+    @pytest.mark.parametrize("method, weighted", [
+        ("linear", False),
+        ("nearest", False),
+        ("inverted_cdf", False),
+        ("inverted_cdf", True),
+    ])
+    def test_out_nan(self, method, weighted):
+        if weighted:
+            kwargs = {"weights": np.ones((3, 4)), "method": method}
+        else:
+            kwargs = {"method": method}
+        with warnings.catch_warnings(record=True):
+            warnings.filterwarnings('always', '', RuntimeWarning)
+            o = np.zeros((4,))
+            d = np.ones((3, 4))
+            d[2, 1] = np.nan
+            assert_equal(np.percentile(d, 0, 0, out=o, **kwargs), o)
+
+            o = np.zeros((3,))
+            assert_equal(np.percentile(d, 1, 1, out=o, **kwargs), o)
+
+            o = np.zeros(())
+            assert_equal(np.percentile(d, 1, out=o, **kwargs), o)
+
+    def test_nan_behavior(self):
+        a = np.arange(24, dtype=float)
+        a[2] = np.nan
+        assert_equal(np.percentile(a, 0.3), np.nan)
+        assert_equal(np.percentile(a, 0.3, axis=0), np.nan)
+        assert_equal(np.percentile(a, [0.3, 0.6], axis=0),
+                     np.array([np.nan] * 2))
+
+        a = np.arange(24, dtype=float).reshape(2, 3, 4)
+        a[1, 2, 3] = np.nan
+        a[1, 1, 2] = np.nan
+
+        # no axis
+        assert_equal(np.percentile(a, 0.3), np.nan)
+        assert_equal(np.percentile(a, 0.3).ndim, 0)
+
+        # axis0 zerod
+        b = np.percentile(np.arange(24, dtype=float).reshape(2, 3, 4), 0.3, 0)
+        b[2, 3] = np.nan
+        b[1, 2] = np.nan
+        assert_equal(np.percentile(a, 0.3, 0), b)
+
+        # axis0 not zerod
+        b = np.percentile(np.arange(24, dtype=float).reshape(2, 3, 4),
+                          [0.3, 0.6], 0)
+        b[:, 2, 3] = np.nan
+        b[:, 1, 2] = np.nan
+        assert_equal(np.percentile(a, [0.3, 0.6], 0), b)
+
+        # axis1 zerod
+        b = np.percentile(np.arange(24, dtype=float).reshape(2, 3, 4), 0.3, 1)
+        b[1, 3] = np.nan
+        b[1, 2] = np.nan
+        assert_equal(np.percentile(a, 0.3, 1), b)
+        # axis1 not zerod
+        b = np.percentile(
+            np.arange(24, dtype=float).reshape(2, 3, 4), [0.3, 0.6], 1)
+        b[:, 1, 3] = np.nan
+        b[:, 1, 2] = np.nan
+        assert_equal(np.percentile(a, [0.3, 0.6], 1), b)
+
+        # axis02 zerod
+        b = np.percentile(
+            np.arange(24, dtype=float).reshape(2, 3, 4), 0.3, (0, 2))
+        b[1] = np.nan
+        b[2] = np.nan
+        assert_equal(np.percentile(a, 0.3, (0, 2)), b)
+        # axis02 not zerod
+        b = np.percentile(np.arange(24, dtype=float).reshape(2, 3, 4),
+                          [0.3, 0.6], (0, 2))
+        b[:, 1] = np.nan
+        b[:, 2] = np.nan
+        assert_equal(np.percentile(a, [0.3, 0.6], (0, 2)), b)
+        # axis02 not zerod with method='nearest'
+        b = np.percentile(np.arange(24, dtype=float).reshape(2, 3, 4),
+                          [0.3, 0.6], (0, 2), method='nearest')
+        b[:, 1] = np.nan
+        b[:, 2] = np.nan
+        assert_equal(np.percentile(
+            a, [0.3, 0.6], (0, 2), method='nearest'), b)
+
+    def test_nan_q(self):
+        # GH18830
+        with pytest.raises(ValueError, match="Percentiles must be in"):
+            np.percentile([1, 2, 3, 4.0], np.nan)
+        with pytest.raises(ValueError, match="Percentiles must be in"):
+            np.percentile([1, 2, 3, 4.0], [np.nan])
+        q = np.linspace(1.0, 99.0, 16)
+        q[0] = np.nan
+        with pytest.raises(ValueError, match="Percentiles must be in"):
+            np.percentile([1, 2, 3, 4.0], q)
+
+    @pytest.mark.parametrize("dtype", ["m8[D]", "M8[s]"])
+    @pytest.mark.parametrize("pos", [0, 23, 10])
+    def test_nat_basic(self, dtype, pos):
+        # TODO: Note that times have dubious rounding as of fixing NaTs!
+        # NaT and NaN should behave the same, do basic tests for NaT:
+        a = np.arange(0, 24, dtype=dtype)
+        a[pos] = "NaT"
+        res = np.percentile(a, 30)
+        assert res.dtype == dtype
+        assert np.isnat(res)
+        res = np.percentile(a, [30, 60])
+        assert res.dtype == dtype
+        assert np.isnat(res).all()
+
+        a = np.arange(0, 24*3, dtype=dtype).reshape(-1, 3)
+        a[pos, 1] = "NaT"
+        res = np.percentile(a, 30, axis=0)
+        assert_array_equal(np.isnat(res), [False, True, False])
+
+
+quantile_methods = [
+    'inverted_cdf', 'averaged_inverted_cdf', 'closest_observation',
+    'interpolated_inverted_cdf', 'hazen', 'weibull', 'linear',
+    'median_unbiased', 'normal_unbiased', 'nearest', 'lower', 'higher',
+    'midpoint']
+
+
+methods_supporting_weights = ["inverted_cdf"]
+
+
+class TestQuantile:
+    # most of this is already tested by TestPercentile
+
+    def V(self, x, y, alpha):
+        # Identification function used in several tests.
+        return (x >= y) - alpha
+
+    def test_max_ulp(self):
+        x = [0.0, 0.2, 0.4]
+        a = np.quantile(x, 0.45)
+        # The default linear method would result in 0 + 0.2 * (0.45/2) = 0.18.
+        # 0.18 is not exactly representable and the formula leads to a 1 ULP
+        # different result. Ensure it is this exact within 1 ULP, see gh-20331.
+        np.testing.assert_array_max_ulp(a, 0.18, maxulp=1)
+
+    def test_basic(self):
+        x = np.arange(8) * 0.5
+        assert_equal(np.quantile(x, 0), 0.)
+        assert_equal(np.quantile(x, 1), 3.5)
+        assert_equal(np.quantile(x, 0.5), 1.75)
+
+    def test_correct_quantile_value(self):
+        a = np.array([True])
+        tf_quant = np.quantile(True, False)
+        assert_equal(tf_quant, a[0])
+        assert_equal(type(tf_quant), a.dtype)
+        a = np.array([False, True, True])
+        quant_res = np.quantile(a, a)
+        assert_array_equal(quant_res, a)
+        assert_equal(quant_res.dtype, a.dtype)
+
+    def test_fraction(self):
+        # fractional input, integral quantile
+        x = [Fraction(i, 2) for i in range(8)]
+        q = np.quantile(x, 0)
+        assert_equal(q, 0)
+        assert_equal(type(q), Fraction)
+
+        q = np.quantile(x, 1)
+        assert_equal(q, Fraction(7, 2))
+        assert_equal(type(q), Fraction)
+
+        q = np.quantile(x, .5)
+        assert_equal(q, 1.75)
+        assert_equal(type(q), np.float64)
+
+        q = np.quantile(x, Fraction(1, 2))
+        assert_equal(q, Fraction(7, 4))
+        assert_equal(type(q), Fraction)
+
+        q = np.quantile(x, [Fraction(1, 2)])
+        assert_equal(q, np.array([Fraction(7, 4)]))
+        assert_equal(type(q), np.ndarray)
+
+        q = np.quantile(x, [[Fraction(1, 2)]])
+        assert_equal(q, np.array([[Fraction(7, 4)]]))
+        assert_equal(type(q), np.ndarray)
+
+        # repeat with integral input but fractional quantile
+        x = np.arange(8)
+        assert_equal(np.quantile(x, Fraction(1, 2)), Fraction(7, 2))
+
+    def test_complex(self):
+        #See gh-22652
+        arr_c = np.array([0.5+3.0j, 2.1+0.5j, 1.6+2.3j], dtype='G')
+        assert_raises(TypeError, np.quantile, arr_c, 0.5)
+        arr_c = np.array([0.5+3.0j, 2.1+0.5j, 1.6+2.3j], dtype='D')
+        assert_raises(TypeError, np.quantile, arr_c, 0.5)
+        arr_c = np.array([0.5+3.0j, 2.1+0.5j, 1.6+2.3j], dtype='F')
+        assert_raises(TypeError, np.quantile, arr_c, 0.5)
+
+    def test_no_p_overwrite(self):
+        # this is worth retesting, because quantile does not make a copy
+        p0 = np.array([0, 0.75, 0.25, 0.5, 1.0])
+        p = p0.copy()
+        np.quantile(np.arange(100.), p, method="midpoint")
+        assert_array_equal(p, p0)
+
+        p0 = p0.tolist()
+        p = p.tolist()
+        np.quantile(np.arange(100.), p, method="midpoint")
+        assert_array_equal(p, p0)
+
+    @pytest.mark.parametrize("dtype", np.typecodes["AllInteger"])
+    def test_quantile_preserve_int_type(self, dtype):
+        res = np.quantile(np.array([1, 2], dtype=dtype), [0.5],
+                          method="nearest")
+        assert res.dtype == dtype
+
+    @pytest.mark.parametrize("method", quantile_methods)
+    def test_q_zero_one(self, method):
+        # gh-24710
+        arr = [10, 11, 12]
+        quantile = np.quantile(arr, q = [0, 1], method=method)
+        assert_equal(quantile,  np.array([10, 12]))
+
+    @pytest.mark.parametrize("method", quantile_methods)
+    def test_quantile_monotonic(self, method):
+        # GH 14685
+        # test that the return value of quantile is monotonic if p0 is ordered
+        # Also tests that the boundary values are not mishandled.
+        p0 = np.linspace(0, 1, 101)
+        quantile = np.quantile(np.array([0, 1, 1, 2, 2, 3, 3, 4, 5, 5, 1, 1, 9, 9, 9,
+                                         8, 8, 7]) * 0.1, p0, method=method)
+        assert_equal(np.sort(quantile), quantile)
+
+        # Also test one where the number of data points is clearly divisible:
+        quantile = np.quantile([0., 1., 2., 3.], p0, method=method)
+        assert_equal(np.sort(quantile), quantile)
+
+    @hypothesis.given(
+            arr=arrays(dtype=np.float64,
+                       shape=st.integers(min_value=3, max_value=1000),
+                       elements=st.floats(allow_infinity=False, allow_nan=False,
+                                          min_value=-1e300, max_value=1e300)))
+    def test_quantile_monotonic_hypo(self, arr):
+        p0 = np.arange(0, 1, 0.01)
+        quantile = np.quantile(arr, p0)
+        assert_equal(np.sort(quantile), quantile)
+
+    def test_quantile_scalar_nan(self):
+        a = np.array([[10., 7., 4.], [3., 2., 1.]])
+        a[0][1] = np.nan
+        actual = np.quantile(a, 0.5)
+        assert np.isscalar(actual)
+        assert_equal(np.quantile(a, 0.5), np.nan)
+
+    @pytest.mark.parametrize("weights", [False, True])
+    @pytest.mark.parametrize("method", quantile_methods)
+    @pytest.mark.parametrize("alpha", [0.2, 0.5, 0.9])
+    def test_quantile_identification_equation(self, weights, method, alpha):
+        # Test that the identification equation holds for the empirical
+        # CDF:
+        #   E[V(x, Y)] = 0  <=>  x is quantile
+        # with Y the random variable for which we have observed values and
+        # V(x, y) the canonical identification function for the quantile (at
+        # level alpha), see
+        # https://doi.org/10.48550/arXiv.0912.0902
+        if weights and method not in methods_supporting_weights:
+            pytest.skip("Weights not supported by method.")
+        rng = np.random.default_rng(4321)
+        # We choose n and alpha such that we cover 3 cases:
+        #  - n * alpha is an integer
+        #  - n * alpha is a float that gets rounded down
+        #  - n * alpha is a float that gest rounded up
+        n = 102  # n * alpha = 20.4, 51. , 91.8
+        y = rng.random(n)
+        w = rng.integers(low=0, high=10, size=n) if weights else None
+        x = np.quantile(y, alpha, method=method, weights=w)
+
+        if method in ("higher",):
+            # These methods do not fulfill the identification equation.
+            assert np.abs(np.mean(self.V(x, y, alpha))) > 0.1 / n
+        elif int(n * alpha) == n * alpha and not weights:
+            # We can expect exact results, up to machine precision.
+            assert_allclose(
+                np.average(self.V(x, y, alpha), weights=w), 0, atol=1e-14,
+            )
+        else:
+            # V = (x >= y) - alpha cannot sum to zero exactly but within
+            # "sample precision".
+            assert_allclose(np.average(self.V(x, y, alpha), weights=w), 0,
+                atol=1 / n / np.amin([alpha, 1 - alpha]))
+
+    @pytest.mark.parametrize("weights", [False, True])
+    @pytest.mark.parametrize("method", quantile_methods)
+    @pytest.mark.parametrize("alpha", [0.2, 0.5, 0.9])
+    def test_quantile_add_and_multiply_constant(self, weights, method, alpha):
+        # Test that
+        #  1. quantile(c + x) = c + quantile(x)
+        #  2. quantile(c * x) = c * quantile(x)
+        #  3. quantile(-x) = -quantile(x, 1 - alpha)
+        #     On empirical quantiles, this equation does not hold exactly.
+        # Koenker (2005) "Quantile Regression" Chapter 2.2.3 calls these
+        # properties equivariance.
+        if weights and method not in methods_supporting_weights:
+            pytest.skip("Weights not supported by method.")
+        rng = np.random.default_rng(4321)
+        # We choose n and alpha such that we have cases for
+        #  - n * alpha is an integer
+        #  - n * alpha is a float that gets rounded down
+        #  - n * alpha is a float that gest rounded up
+        n = 102  # n * alpha = 20.4, 51. , 91.8
+        y = rng.random(n)
+        w = rng.integers(low=0, high=10, size=n) if weights else None
+        q = np.quantile(y, alpha, method=method, weights=w)
+        c = 13.5
+
+        # 1
+        assert_allclose(np.quantile(c + y, alpha, method=method, weights=w),
+                        c + q)
+        # 2
+        assert_allclose(np.quantile(c * y, alpha, method=method, weights=w),
+                        c * q)
+        # 3
+        if weights:
+            # From here on, we would need more methods to support weights.
+            return
+        q = -np.quantile(-y, 1 - alpha, method=method)
+        if method == "inverted_cdf":
+            if (
+                n * alpha == int(n * alpha)
+                or np.round(n * alpha) == int(n * alpha) + 1
+            ):
+                assert_allclose(q, np.quantile(y, alpha, method="higher"))
+            else:
+                assert_allclose(q, np.quantile(y, alpha, method="lower"))
+        elif method == "closest_observation":
+            if n * alpha == int(n * alpha):
+                assert_allclose(q, np.quantile(y, alpha, method="higher"))
+            elif np.round(n * alpha) == int(n * alpha) + 1:
+                assert_allclose(
+                    q, np.quantile(y, alpha + 1/n, method="higher"))
+            else:
+                assert_allclose(q, np.quantile(y, alpha, method="lower"))
+        elif method == "interpolated_inverted_cdf":
+            assert_allclose(q, np.quantile(y, alpha + 1/n, method=method))
+        elif method == "nearest":
+            if n * alpha == int(n * alpha):
+                assert_allclose(q, np.quantile(y, alpha + 1/n, method=method))
+            else:
+                assert_allclose(q, np.quantile(y, alpha, method=method))
+        elif method == "lower":
+            assert_allclose(q, np.quantile(y, alpha, method="higher"))
+        elif method == "higher":
+            assert_allclose(q, np.quantile(y, alpha, method="lower"))
+        else:
+            # "averaged_inverted_cdf", "hazen", "weibull", "linear",
+            # "median_unbiased", "normal_unbiased", "midpoint"
+            assert_allclose(q, np.quantile(y, alpha, method=method))
+
+    @pytest.mark.parametrize("method", methods_supporting_weights)
+    @pytest.mark.parametrize("alpha", [0.2, 0.5, 0.9])
+    def test_quantile_constant_weights(self, method, alpha):
+        rng = np.random.default_rng(4321)
+        # We choose n and alpha such that we have cases for
+        #  - n * alpha is an integer
+        #  - n * alpha is a float that gets rounded down
+        #  - n * alpha is a float that gest rounded up
+        n = 102  # n * alpha = 20.4, 51. , 91.8
+        y = rng.random(n)
+        q = np.quantile(y, alpha, method=method)
+
+        w = np.ones_like(y)
+        qw = np.quantile(y, alpha, method=method, weights=w)
+        assert_allclose(qw, q)
+
+        w = 8.125 * np.ones_like(y)
+        qw = np.quantile(y, alpha, method=method, weights=w)
+        assert_allclose(qw, q)
+
+    @pytest.mark.parametrize("method", methods_supporting_weights)
+    @pytest.mark.parametrize("alpha", [0, 0.2, 0.5, 0.9, 1])
+    def test_quantile_with_integer_weights(self, method, alpha):
+        # Integer weights can be interpreted as repeated observations.
+        rng = np.random.default_rng(4321)
+        # We choose n and alpha such that we have cases for
+        #  - n * alpha is an integer
+        #  - n * alpha is a float that gets rounded down
+        #  - n * alpha is a float that gest rounded up
+        n = 102  # n * alpha = 20.4, 51. , 91.8
+        y = rng.random(n)
+        w = rng.integers(low=0, high=10, size=n, dtype=np.int32)
+
+        qw = np.quantile(y, alpha, method=method, weights=w)
+        q = np.quantile(np.repeat(y, w), alpha, method=method)
+        assert_allclose(qw, q)
+
+    @pytest.mark.parametrize("method", methods_supporting_weights)
+    def test_quantile_with_weights_and_axis(self, method):
+        rng = np.random.default_rng(4321)
+
+        # 1d weight and single alpha
+        y = rng.random((2, 10, 3))
+        w = np.abs(rng.random(10))
+        alpha = 0.5
+        q = np.quantile(y, alpha, weights=w, method=method, axis=1)
+        q_res = np.zeros(shape=(2, 3))
+        for i in range(2):
+            for j in range(3):
+                q_res[i, j] = np.quantile(
+                    y[i, :, j], alpha, method=method, weights=w
+                )
+        assert_allclose(q, q_res)
+
+        # 1d weight and 1d alpha
+        alpha = [0, 0.2, 0.4, 0.6, 0.8, 1]  # shape (6,)
+        q = np.quantile(y, alpha, weights=w, method=method, axis=1)
+        q_res = np.zeros(shape=(6, 2, 3))
+        for i in range(2):
+            for j in range(3):
+                q_res[:, i, j] = np.quantile(
+                    y[i, :, j], alpha, method=method, weights=w
+                )
+        assert_allclose(q, q_res)
+
+        # 1d weight and 2d alpha
+        alpha = [[0, 0.2], [0.4, 0.6], [0.8, 1]]  # shape (3, 2)
+        q = np.quantile(y, alpha, weights=w, method=method, axis=1)
+        q_res = q_res.reshape((3, 2, 2, 3))
+        assert_allclose(q, q_res)
+
+        # shape of weights equals shape of y
+        w = np.abs(rng.random((2, 10, 3)))
+        alpha = 0.5
+        q = np.quantile(y, alpha, weights=w, method=method, axis=1)
+        q_res = np.zeros(shape=(2, 3))
+        for i in range(2):
+            for j in range(3):
+                q_res[i, j] = np.quantile(
+                    y[i, :, j], alpha, method=method, weights=w[i, :, j]
+                )
+        assert_allclose(q, q_res)
+
+    @pytest.mark.parametrize("method", methods_supporting_weights)
+    def test_quantile_weights_min_max(self, method):
+        # Test weighted quantile at 0 and 1 with leading and trailing zero
+        # weights.
+        w = [0, 0, 1, 2, 3, 0]
+        y = np.arange(6)
+        y_min = np.quantile(y, 0, weights=w, method="inverted_cdf")
+        y_max = np.quantile(y, 1, weights=w, method="inverted_cdf")
+        assert y_min == y[2]  # == 2
+        assert y_max == y[4]  # == 4
+
+    def test_quantile_weights_raises_negative_weights(self):
+        y = [1, 2]
+        w = [-0.5, 1]
+        with pytest.raises(ValueError, match="Weights must be non-negative"):
+            np.quantile(y, 0.5, weights=w, method="inverted_cdf")
+
+    @pytest.mark.parametrize(
+            "method",
+            sorted(set(quantile_methods) - set(methods_supporting_weights)),
+    )
+    def test_quantile_weights_raises_unsupported_methods(self, method):
+        y = [1, 2]
+        w = [0.5, 1]
+        msg = "Only method 'inverted_cdf' supports weights"
+        with pytest.raises(ValueError, match=msg):
+            np.quantile(y, 0.5, weights=w, method=method)
+
+    def test_weibull_fraction(self):
+        arr = [Fraction(0, 1), Fraction(1, 10)]
+        quantile = np.quantile(arr, [0, ], method='weibull')
+        assert_equal(quantile, np.array(Fraction(0, 1)))
+        quantile = np.quantile(arr, [Fraction(1, 2)], method='weibull')
+        assert_equal(quantile, np.array(Fraction(1, 20)))
+
+    def test_closest_observation(self):
+        # Round ties to nearest even order statistic (see #26656)
+        m = 'closest_observation'
+        q = 0.5
+        arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+        assert_equal(2, np.quantile(arr[0:3], q, method=m))
+        assert_equal(2, np.quantile(arr[0:4], q, method=m))
+        assert_equal(2, np.quantile(arr[0:5], q, method=m))
+        assert_equal(3, np.quantile(arr[0:6], q, method=m))
+        assert_equal(4, np.quantile(arr[0:7], q, method=m))
+        assert_equal(4, np.quantile(arr[0:8], q, method=m))
+        assert_equal(4, np.quantile(arr[0:9], q, method=m))
+        assert_equal(5, np.quantile(arr, q, method=m))
+
+
+class TestLerp:
+    @hypothesis.given(t0=st.floats(allow_nan=False, allow_infinity=False,
+                                   min_value=0, max_value=1),
+                      t1=st.floats(allow_nan=False, allow_infinity=False,
+                                   min_value=0, max_value=1),
+                      a = st.floats(allow_nan=False, allow_infinity=False,
+                                    min_value=-1e300, max_value=1e300),
+                      b = st.floats(allow_nan=False, allow_infinity=False,
+                                    min_value=-1e300, max_value=1e300))
+    def test_linear_interpolation_formula_monotonic(self, t0, t1, a, b):
+        l0 = nfb._lerp(a, b, t0)
+        l1 = nfb._lerp(a, b, t1)
+        if t0 == t1 or a == b:
+            assert l0 == l1  # uninteresting
+        elif (t0 < t1) == (a < b):
+            assert l0 <= l1
+        else:
+            assert l0 >= l1
+
+    @hypothesis.given(t=st.floats(allow_nan=False, allow_infinity=False,
+                                  min_value=0, max_value=1),
+                      a=st.floats(allow_nan=False, allow_infinity=False,
+                                  min_value=-1e300, max_value=1e300),
+                      b=st.floats(allow_nan=False, allow_infinity=False,
+                                  min_value=-1e300, max_value=1e300))
+    def test_linear_interpolation_formula_bounded(self, t, a, b):
+        if a <= b:
+            assert a <= nfb._lerp(a, b, t) <= b
+        else:
+            assert b <= nfb._lerp(a, b, t) <= a
+
+    @hypothesis.given(t=st.floats(allow_nan=False, allow_infinity=False,
+                                  min_value=0, max_value=1),
+                      a=st.floats(allow_nan=False, allow_infinity=False,
+                                  min_value=-1e300, max_value=1e300),
+                      b=st.floats(allow_nan=False, allow_infinity=False,
+                                  min_value=-1e300, max_value=1e300))
+    def test_linear_interpolation_formula_symmetric(self, t, a, b):
+        # double subtraction is needed to remove the extra precision of t < 0.5
+        left = nfb._lerp(a, b, 1 - (1 - t))
+        right = nfb._lerp(b, a, 1 - t)
+        assert_allclose(left, right)
+
+    def test_linear_interpolation_formula_0d_inputs(self):
+        a = np.array(2)
+        b = np.array(5)
+        t = np.array(0.2)
+        assert nfb._lerp(a, b, t) == 2.6
+
+
+class TestMedian:
+
+    def test_basic(self):
+        a0 = np.array(1)
+        a1 = np.arange(2)
+        a2 = np.arange(6).reshape(2, 3)
+        assert_equal(np.median(a0), 1)
+        assert_allclose(np.median(a1), 0.5)
+        assert_allclose(np.median(a2), 2.5)
+        assert_allclose(np.median(a2, axis=0), [1.5,  2.5,  3.5])
+        assert_equal(np.median(a2, axis=1), [1, 4])
+        assert_allclose(np.median(a2, axis=None), 2.5)
+
+        a = np.array([0.0444502, 0.0463301, 0.141249, 0.0606775])
+        assert_almost_equal((a[1] + a[3]) / 2., np.median(a))
+        a = np.array([0.0463301, 0.0444502, 0.141249])
+        assert_equal(a[0], np.median(a))
+        a = np.array([0.0444502, 0.141249, 0.0463301])
+        assert_equal(a[-1], np.median(a))
+        # check array scalar result
+        assert_equal(np.median(a).ndim, 0)
+        a[1] = np.nan
+        assert_equal(np.median(a).ndim, 0)
+
+    def test_axis_keyword(self):
+        a3 = np.array([[2, 3],
+                       [0, 1],
+                       [6, 7],
+                       [4, 5]])
+        for a in [a3, np.random.randint(0, 100, size=(2, 3, 4))]:
+            orig = a.copy()
+            np.median(a, axis=None)
+            for ax in range(a.ndim):
+                np.median(a, axis=ax)
+            assert_array_equal(a, orig)
+
+        assert_allclose(np.median(a3, axis=0), [3,  4])
+        assert_allclose(np.median(a3.T, axis=1), [3,  4])
+        assert_allclose(np.median(a3), 3.5)
+        assert_allclose(np.median(a3, axis=None), 3.5)
+        assert_allclose(np.median(a3.T), 3.5)
+
+    def test_overwrite_keyword(self):
+        a3 = np.array([[2, 3],
+                       [0, 1],
+                       [6, 7],
+                       [4, 5]])
+        a0 = np.array(1)
+        a1 = np.arange(2)
+        a2 = np.arange(6).reshape(2, 3)
+        assert_allclose(np.median(a0.copy(), overwrite_input=True), 1)
+        assert_allclose(np.median(a1.copy(), overwrite_input=True), 0.5)
+        assert_allclose(np.median(a2.copy(), overwrite_input=True), 2.5)
+        assert_allclose(np.median(a2.copy(), overwrite_input=True, axis=0),
+                        [1.5,  2.5,  3.5])
+        assert_allclose(
+            np.median(a2.copy(), overwrite_input=True, axis=1), [1, 4])
+        assert_allclose(
+            np.median(a2.copy(), overwrite_input=True, axis=None), 2.5)
+        assert_allclose(
+            np.median(a3.copy(), overwrite_input=True, axis=0), [3,  4])
+        assert_allclose(np.median(a3.T.copy(), overwrite_input=True, axis=1),
+                        [3,  4])
+
+        a4 = np.arange(3 * 4 * 5, dtype=np.float32).reshape((3, 4, 5))
+        np.random.shuffle(a4.ravel())
+        assert_allclose(np.median(a4, axis=None),
+                        np.median(a4.copy(), axis=None, overwrite_input=True))
+        assert_allclose(np.median(a4, axis=0),
+                        np.median(a4.copy(), axis=0, overwrite_input=True))
+        assert_allclose(np.median(a4, axis=1),
+                        np.median(a4.copy(), axis=1, overwrite_input=True))
+        assert_allclose(np.median(a4, axis=2),
+                        np.median(a4.copy(), axis=2, overwrite_input=True))
+
+    def test_array_like(self):
+        x = [1, 2, 3]
+        assert_almost_equal(np.median(x), 2)
+        x2 = [x]
+        assert_almost_equal(np.median(x2), 2)
+        assert_allclose(np.median(x2, axis=0), x)
+
+    def test_subclass(self):
+        # gh-3846
+        class MySubClass(np.ndarray):
+
+            def __new__(cls, input_array, info=None):
+                obj = np.asarray(input_array).view(cls)
+                obj.info = info
+                return obj
+
+            def mean(self, axis=None, dtype=None, out=None):
+                return -7
+
+        a = MySubClass([1, 2, 3])
+        assert_equal(np.median(a), -7)
+
+    @pytest.mark.parametrize('arr',
+                             ([1., 2., 3.], [1., np.nan, 3.], np.nan, 0.))
+    def test_subclass2(self, arr):
+        """Check that we return subclasses, even if a NaN scalar."""
+        class MySubclass(np.ndarray):
+            pass
+
+        m = np.median(np.array(arr).view(MySubclass))
+        assert isinstance(m, MySubclass)
+
+    def test_out(self):
+        o = np.zeros((4,))
+        d = np.ones((3, 4))
+        assert_equal(np.median(d, 0, out=o), o)
+        o = np.zeros((3,))
+        assert_equal(np.median(d, 1, out=o), o)
+        o = np.zeros(())
+        assert_equal(np.median(d, out=o), o)
+
+    def test_out_nan(self):
+        with warnings.catch_warnings(record=True):
+            warnings.filterwarnings('always', '', RuntimeWarning)
+            o = np.zeros((4,))
+            d = np.ones((3, 4))
+            d[2, 1] = np.nan
+            assert_equal(np.median(d, 0, out=o), o)
+            o = np.zeros((3,))
+            assert_equal(np.median(d, 1, out=o), o)
+            o = np.zeros(())
+            assert_equal(np.median(d, out=o), o)
+
+    def test_nan_behavior(self):
+        a = np.arange(24, dtype=float)
+        a[2] = np.nan
+        assert_equal(np.median(a), np.nan)
+        assert_equal(np.median(a, axis=0), np.nan)
+
+        a = np.arange(24, dtype=float).reshape(2, 3, 4)
+        a[1, 2, 3] = np.nan
+        a[1, 1, 2] = np.nan
+
+        # no axis
+        assert_equal(np.median(a), np.nan)
+        assert_equal(np.median(a).ndim, 0)
+
+        # axis0
+        b = np.median(np.arange(24, dtype=float).reshape(2, 3, 4), 0)
+        b[2, 3] = np.nan
+        b[1, 2] = np.nan
+        assert_equal(np.median(a, 0), b)
+
+        # axis1
+        b = np.median(np.arange(24, dtype=float).reshape(2, 3, 4), 1)
+        b[1, 3] = np.nan
+        b[1, 2] = np.nan
+        assert_equal(np.median(a, 1), b)
+
+        # axis02
+        b = np.median(np.arange(24, dtype=float).reshape(2, 3, 4), (0, 2))
+        b[1] = np.nan
+        b[2] = np.nan
+        assert_equal(np.median(a, (0, 2)), b)
+
+    @pytest.mark.skipif(IS_WASM, reason="fp errors don't work correctly")
+    def test_empty(self):
+        # mean(empty array) emits two warnings: empty slice and divide by 0
+        a = np.array([], dtype=float)
+        with warnings.catch_warnings(record=True) as w:
+            warnings.filterwarnings('always', '', RuntimeWarning)
+            assert_equal(np.median(a), np.nan)
+            assert_(w[0].category is RuntimeWarning)
+            assert_equal(len(w), 2)
+
+        # multiple dimensions
+        a = np.array([], dtype=float, ndmin=3)
+        # no axis
+        with warnings.catch_warnings(record=True) as w:
+            warnings.filterwarnings('always', '', RuntimeWarning)
+            assert_equal(np.median(a), np.nan)
+            assert_(w[0].category is RuntimeWarning)
+
+        # axis 0 and 1
+        b = np.array([], dtype=float, ndmin=2)
+        assert_equal(np.median(a, axis=0), b)
+        assert_equal(np.median(a, axis=1), b)
+
+        # axis 2
+        b = np.array(np.nan, dtype=float, ndmin=2)
+        with warnings.catch_warnings(record=True) as w:
+            warnings.filterwarnings('always', '', RuntimeWarning)
+            assert_equal(np.median(a, axis=2), b)
+            assert_(w[0].category is RuntimeWarning)
+
+    def test_object(self):
+        o = np.arange(7.)
+        assert_(type(np.median(o.astype(object))), float)
+        o[2] = np.nan
+        assert_(type(np.median(o.astype(object))), float)
+
+    def test_extended_axis(self):
+        o = np.random.normal(size=(71, 23))
+        x = np.dstack([o] * 10)
+        assert_equal(np.median(x, axis=(0, 1)), np.median(o))
+        x = np.moveaxis(x, -1, 0)
+        assert_equal(np.median(x, axis=(-2, -1)), np.median(o))
+        x = x.swapaxes(0, 1).copy()
+        assert_equal(np.median(x, axis=(0, -1)), np.median(o))
+
+        assert_equal(np.median(x, axis=(0, 1, 2)), np.median(x, axis=None))
+        assert_equal(np.median(x, axis=(0, )), np.median(x, axis=0))
+        assert_equal(np.median(x, axis=(-1, )), np.median(x, axis=-1))
+
+        d = np.arange(3 * 5 * 7 * 11).reshape((3, 5, 7, 11))
+        np.random.shuffle(d.ravel())
+        assert_equal(np.median(d, axis=(0, 1, 2))[0],
+                     np.median(d[:,:,:, 0].flatten()))
+        assert_equal(np.median(d, axis=(0, 1, 3))[1],
+                     np.median(d[:,:, 1,:].flatten()))
+        assert_equal(np.median(d, axis=(3, 1, -4))[2],
+                     np.median(d[:,:, 2,:].flatten()))
+        assert_equal(np.median(d, axis=(3, 1, 2))[2],
+                     np.median(d[2,:,:,:].flatten()))
+        assert_equal(np.median(d, axis=(3, 2))[2, 1],
+                     np.median(d[2, 1,:,:].flatten()))
+        assert_equal(np.median(d, axis=(1, -2))[2, 1],
+                     np.median(d[2,:,:, 1].flatten()))
+        assert_equal(np.median(d, axis=(1, 3))[2, 2],
+                     np.median(d[2,:, 2,:].flatten()))
+
+    def test_extended_axis_invalid(self):
+        d = np.ones((3, 5, 7, 11))
+        assert_raises(AxisError, np.median, d, axis=-5)
+        assert_raises(AxisError, np.median, d, axis=(0, -5))
+        assert_raises(AxisError, np.median, d, axis=4)
+        assert_raises(AxisError, np.median, d, axis=(0, 4))
+        assert_raises(ValueError, np.median, d, axis=(1, 1))
+
+    def test_keepdims(self):
+        d = np.ones((3, 5, 7, 11))
+        assert_equal(np.median(d, axis=None, keepdims=True).shape,
+                     (1, 1, 1, 1))
+        assert_equal(np.median(d, axis=(0, 1), keepdims=True).shape,
+                     (1, 1, 7, 11))
+        assert_equal(np.median(d, axis=(0, 3), keepdims=True).shape,
+                     (1, 5, 7, 1))
+        assert_equal(np.median(d, axis=(1,), keepdims=True).shape,
+                     (3, 1, 7, 11))
+        assert_equal(np.median(d, axis=(0, 1, 2, 3), keepdims=True).shape,
+                     (1, 1, 1, 1))
+        assert_equal(np.median(d, axis=(0, 1, 3), keepdims=True).shape,
+                     (1, 1, 7, 1))
+
+    @pytest.mark.parametrize(
+        argnames='axis',
+        argvalues=[
+            None,
+            1,
+            (1, ),
+            (0, 1),
+            (-3, -1),
+        ]
+    )
+    def test_keepdims_out(self, axis):
+        d = np.ones((3, 5, 7, 11))
+        if axis is None:
+            shape_out = (1,) * d.ndim
+        else:
+            axis_norm = normalize_axis_tuple(axis, d.ndim)
+            shape_out = tuple(
+                1 if i in axis_norm else d.shape[i] for i in range(d.ndim))
+        out = np.empty(shape_out)
+        result = np.median(d, axis=axis, keepdims=True, out=out)
+        assert result is out
+        assert_equal(result.shape, shape_out)
+
+    @pytest.mark.parametrize("dtype", ["m8[s]"])
+    @pytest.mark.parametrize("pos", [0, 23, 10])
+    def test_nat_behavior(self, dtype, pos):
+        # TODO: Median does not support Datetime, due to `mean`.
+        # NaT and NaN should behave the same, do basic tests for NaT.
+        a = np.arange(0, 24, dtype=dtype)
+        a[pos] = "NaT"
+        res = np.median(a)
+        assert res.dtype == dtype
+        assert np.isnat(res)
+        res = np.percentile(a, [30, 60])
+        assert res.dtype == dtype
+        assert np.isnat(res).all()
+
+        a = np.arange(0, 24*3, dtype=dtype).reshape(-1, 3)
+        a[pos, 1] = "NaT"
+        res = np.median(a, axis=0)
+        assert_array_equal(np.isnat(res), [False, True, False])
+
+
+class TestSortComplex:
+
+    @pytest.mark.parametrize("type_in, type_out", [
+        ('l', 'D'),
+        ('h', 'F'),
+        ('H', 'F'),
+        ('b', 'F'),
+        ('B', 'F'),
+        ('g', 'G'),
+        ])
+    def test_sort_real(self, type_in, type_out):
+        # sort_complex() type casting for real input types
+        a = np.array([5, 3, 6, 2, 1], dtype=type_in)
+        actual = np.sort_complex(a)
+        expected = np.sort(a).astype(type_out)
+        assert_equal(actual, expected)
+        assert_equal(actual.dtype, expected.dtype)
+
+    def test_sort_complex(self):
+        # sort_complex() handling of complex input
+        a = np.array([2 + 3j, 1 - 2j, 1 - 3j, 2 + 1j], dtype='D')
+        expected = np.array([1 - 3j, 1 - 2j, 2 + 1j, 2 + 3j], dtype='D')
+        actual = np.sort_complex(a)
+        assert_equal(actual, expected)
+        assert_equal(actual.dtype, expected.dtype)
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/tests/test_histograms.py b/venv/lib/python3.12/site-packages/numpy/lib/tests/test_histograms.py
new file mode 100644
index 00000000..09a1a5ab
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/lib/tests/test_histograms.py
@@ -0,0 +1,837 @@
+import numpy as np
+
+from numpy import histogram, histogramdd, histogram_bin_edges
+from numpy.testing import (
+    assert_, assert_equal, assert_array_equal, assert_almost_equal,
+    assert_array_almost_equal, assert_raises, assert_allclose,
+    assert_array_max_ulp, assert_raises_regex, suppress_warnings,
+    )
+from numpy.testing._private.utils import requires_memory
+import pytest
+
+
+class TestHistogram:
+
+    def setup_method(self):
+        pass
+
+    def teardown_method(self):
+        pass
+
+    def test_simple(self):
+        n = 100
+        v = np.random.rand(n)
+        (a, b) = histogram(v)
+        # check if the sum of the bins equals the number of samples
+        assert_equal(np.sum(a, axis=0), n)
+        # check that the bin counts are evenly spaced when the data is from
+        # a linear function
+        (a, b) = histogram(np.linspace(0, 10, 100))
+        assert_array_equal(a, 10)
+
+    def test_one_bin(self):
+        # Ticket 632
+        hist, edges = histogram([1, 2, 3, 4], [1, 2])
+        assert_array_equal(hist, [2, ])
+        assert_array_equal(edges, [1, 2])
+        assert_raises(ValueError, histogram, [1, 2], bins=0)
+        h, e = histogram([1, 2], bins=1)
+        assert_equal(h, np.array([2]))
+        assert_allclose(e, np.array([1., 2.]))
+
+    def test_density(self):
+        # Check that the integral of the density equals 1.
+        n = 100
+        v = np.random.rand(n)
+        a, b = histogram(v, density=True)
+        area = np.sum(a * np.diff(b))
+        assert_almost_equal(area, 1)
+
+        # Check with non-constant bin widths
+        v = np.arange(10)
+        bins = [0, 1, 3, 6, 10]
+        a, b = histogram(v, bins, density=True)
+        assert_array_equal(a, .1)
+        assert_equal(np.sum(a * np.diff(b)), 1)
+
+        # Test that passing False works too
+        a, b = histogram(v, bins, density=False)
+        assert_array_equal(a, [1, 2, 3, 4])
+
+        # Variable bin widths are especially useful to deal with
+        # infinities.
+        v = np.arange(10)
+        bins = [0, 1, 3, 6, np.inf]
+        a, b = histogram(v, bins, density=True)
+        assert_array_equal(a, [.1, .1, .1, 0.])
+
+        # Taken from a bug report from N. Becker on the numpy-discussion
+        # mailing list Aug. 6, 2010.
+        counts, dmy = np.histogram(
+            [1, 2, 3, 4], [0.5, 1.5, np.inf], density=True)
+        assert_equal(counts, [.25, 0])
+
+    def test_outliers(self):
+        # Check that outliers are not tallied
+        a = np.arange(10) + .5
+
+        # Lower outliers
+        h, b = histogram(a, range=[0, 9])
+        assert_equal(h.sum(), 9)
+
+        # Upper outliers
+        h, b = histogram(a, range=[1, 10])
+        assert_equal(h.sum(), 9)
+
+        # Normalization
+        h, b = histogram(a, range=[1, 9], density=True)
+        assert_almost_equal((h * np.diff(b)).sum(), 1, decimal=15)
+
+        # Weights
+        w = np.arange(10) + .5
+        h, b = histogram(a, range=[1, 9], weights=w, density=True)
+        assert_equal((h * np.diff(b)).sum(), 1)
+
+        h, b = histogram(a, bins=8, range=[1, 9], weights=w)
+        assert_equal(h, w[1:-1])
+
+    def test_arr_weights_mismatch(self):
+        a = np.arange(10) + .5
+        w = np.arange(11) + .5
+        with assert_raises_regex(ValueError, "same shape as"):
+            h, b = histogram(a, range=[1, 9], weights=w, density=True)
+
+
+    def test_type(self):
+        # Check the type of the returned histogram
+        a = np.arange(10) + .5
+        h, b = histogram(a)
+        assert_(np.issubdtype(h.dtype, np.integer))
+
+        h, b = histogram(a, density=True)
+        assert_(np.issubdtype(h.dtype, np.floating))
+
+        h, b = histogram(a, weights=np.ones(10, int))
+        assert_(np.issubdtype(h.dtype, np.integer))
+
+        h, b = histogram(a, weights=np.ones(10, float))
+        assert_(np.issubdtype(h.dtype, np.floating))
+
+    def test_f32_rounding(self):
+        # gh-4799, check that the rounding of the edges works with float32
+        x = np.array([276.318359, -69.593948, 21.329449], dtype=np.float32)
+        y = np.array([5005.689453, 4481.327637, 6010.369629], dtype=np.float32)
+        counts_hist, xedges, yedges = np.histogram2d(x, y, bins=100)
+        assert_equal(counts_hist.sum(), 3.)
+
+    def test_bool_conversion(self):
+        # gh-12107
+        # Reference integer histogram
+        a = np.array([1, 1, 0], dtype=np.uint8)
+        int_hist, int_edges = np.histogram(a)
+
+        # Should raise an warning on booleans
+        # Ensure that the histograms are equivalent, need to suppress
+        # the warnings to get the actual outputs
+        with suppress_warnings() as sup:
+            rec = sup.record(RuntimeWarning, 'Converting input from .*')
+            hist, edges = np.histogram([True, True, False])
+            # A warning should be issued
+            assert_equal(len(rec), 1)
+            assert_array_equal(hist, int_hist)
+            assert_array_equal(edges, int_edges)
+
+    def test_weights(self):
+        v = np.random.rand(100)
+        w = np.ones(100) * 5
+        a, b = histogram(v)
+        na, nb = histogram(v, density=True)
+        wa, wb = histogram(v, weights=w)
+        nwa, nwb = histogram(v, weights=w, density=True)
+        assert_array_almost_equal(a * 5, wa)
+        assert_array_almost_equal(na, nwa)
+
+        # Check weights are properly applied.
+        v = np.linspace(0, 10, 10)
+        w = np.concatenate((np.zeros(5), np.ones(5)))
+        wa, wb = histogram(v, bins=np.arange(11), weights=w)
+        assert_array_almost_equal(wa, w)
+
+        # Check with integer weights
+        wa, wb = histogram([1, 2, 2, 4], bins=4, weights=[4, 3, 2, 1])
+        assert_array_equal(wa, [4, 5, 0, 1])
+        wa, wb = histogram(
+            [1, 2, 2, 4], bins=4, weights=[4, 3, 2, 1], density=True)
+        assert_array_almost_equal(wa, np.array([4, 5, 0, 1]) / 10. / 3. * 4)
+
+        # Check weights with non-uniform bin widths
+        a, b = histogram(
+            np.arange(9), [0, 1, 3, 6, 10],
+            weights=[2, 1, 1, 1, 1, 1, 1, 1, 1], density=True)
+        assert_almost_equal(a, [.2, .1, .1, .075])
+
+    def test_exotic_weights(self):
+
+        # Test the use of weights that are not integer or floats, but e.g.
+        # complex numbers or object types.
+
+        # Complex weights
+        values = np.array([1.3, 2.5, 2.3])
+        weights = np.array([1, -1, 2]) + 1j * np.array([2, 1, 2])
+
+        # Check with custom bins
+        wa, wb = histogram(values, bins=[0, 2, 3], weights=weights)
+        assert_array_almost_equal(wa, np.array([1, 1]) + 1j * np.array([2, 3]))
+
+        # Check with even bins
+        wa, wb = histogram(values, bins=2, range=[1, 3], weights=weights)
+        assert_array_almost_equal(wa, np.array([1, 1]) + 1j * np.array([2, 3]))
+
+        # Decimal weights
+        from decimal import Decimal
+        values = np.array([1.3, 2.5, 2.3])
+        weights = np.array([Decimal(1), Decimal(2), Decimal(3)])
+
+        # Check with custom bins
+        wa, wb = histogram(values, bins=[0, 2, 3], weights=weights)
+        assert_array_almost_equal(wa, [Decimal(1), Decimal(5)])
+
+        # Check with even bins
+        wa, wb = histogram(values, bins=2, range=[1, 3], weights=weights)
+        assert_array_almost_equal(wa, [Decimal(1), Decimal(5)])
+
+    def test_no_side_effects(self):
+        # This is a regression test that ensures that values passed to
+        # ``histogram`` are unchanged.
+        values = np.array([1.3, 2.5, 2.3])
+        np.histogram(values, range=[-10, 10], bins=100)
+        assert_array_almost_equal(values, [1.3, 2.5, 2.3])
+
+    def test_empty(self):
+        a, b = histogram([], bins=([0, 1]))
+        assert_array_equal(a, np.array([0]))
+        assert_array_equal(b, np.array([0, 1]))
+
+    def test_error_binnum_type (self):
+        # Tests if right Error is raised if bins argument is float
+        vals = np.linspace(0.0, 1.0, num=100)
+        histogram(vals, 5)
+        assert_raises(TypeError, histogram, vals, 2.4)
+
+    def test_finite_range(self):
+        # Normal ranges should be fine
+        vals = np.linspace(0.0, 1.0, num=100)
+        histogram(vals, range=[0.25,0.75])
+        assert_raises(ValueError, histogram, vals, range=[np.nan,0.75])
+        assert_raises(ValueError, histogram, vals, range=[0.25,np.inf])
+
+    def test_invalid_range(self):
+        # start of range must be < end of range
+        vals = np.linspace(0.0, 1.0, num=100)
+        with assert_raises_regex(ValueError, "max must be larger than"):
+            np.histogram(vals, range=[0.1, 0.01])
+
+    def test_bin_edge_cases(self):
+        # Ensure that floating-point computations correctly place edge cases.
+        arr = np.array([337, 404, 739, 806, 1007, 1811, 2012])
+        hist, edges = np.histogram(arr, bins=8296, range=(2, 2280))
+        mask = hist > 0
+        left_edges = edges[:-1][mask]
+        right_edges = edges[1:][mask]
+        for x, left, right in zip(arr, left_edges, right_edges):
+            assert_(x >= left)
+            assert_(x < right)
+
+    def test_last_bin_inclusive_range(self):
+        arr = np.array([0.,  0.,  0.,  1.,  2.,  3.,  3.,  4.,  5.])
+        hist, edges = np.histogram(arr, bins=30, range=(-0.5, 5))
+        assert_equal(hist[-1], 1)
+
+    def test_bin_array_dims(self):
+        # gracefully handle bins object > 1 dimension
+        vals = np.linspace(0.0, 1.0, num=100)
+        bins = np.array([[0, 0.5], [0.6, 1.0]])
+        with assert_raises_regex(ValueError, "must be 1d"):
+            np.histogram(vals, bins=bins)
+
+    def test_unsigned_monotonicity_check(self):
+        # Ensures ValueError is raised if bins not increasing monotonically
+        # when bins contain unsigned values (see #9222)
+        arr = np.array([2])
+        bins = np.array([1, 3, 1], dtype='uint64')
+        with assert_raises(ValueError):
+            hist, edges = np.histogram(arr, bins=bins)
+
+    def test_object_array_of_0d(self):
+        # gh-7864
+        assert_raises(ValueError,
+            histogram, [np.array(0.4) for i in range(10)] + [-np.inf])
+        assert_raises(ValueError,
+            histogram, [np.array(0.4) for i in range(10)] + [np.inf])
+
+        # these should not crash
+        np.histogram([np.array(0.5) for i in range(10)] + [.500000000000001])
+        np.histogram([np.array(0.5) for i in range(10)] + [.5])
+
+    def test_some_nan_values(self):
+        # gh-7503
+        one_nan = np.array([0, 1, np.nan])
+        all_nan = np.array([np.nan, np.nan])
+
+        # the internal comparisons with NaN give warnings
+        sup = suppress_warnings()
+        sup.filter(RuntimeWarning)
+        with sup:
+            # can't infer range with nan
+            assert_raises(ValueError, histogram, one_nan, bins='auto')
+            assert_raises(ValueError, histogram, all_nan, bins='auto')
+
+            # explicit range solves the problem
+            h, b = histogram(one_nan, bins='auto', range=(0, 1))
+            assert_equal(h.sum(), 2)  # nan is not counted
+            h, b = histogram(all_nan, bins='auto', range=(0, 1))
+            assert_equal(h.sum(), 0)  # nan is not counted
+
+            # as does an explicit set of bins
+            h, b = histogram(one_nan, bins=[0, 1])
+            assert_equal(h.sum(), 2)  # nan is not counted
+            h, b = histogram(all_nan, bins=[0, 1])
+            assert_equal(h.sum(), 0)  # nan is not counted
+
+    def test_datetime(self):
+        begin = np.datetime64('2000-01-01', 'D')
+        offsets = np.array([0, 0, 1, 1, 2, 3, 5, 10, 20])
+        bins = np.array([0, 2, 7, 20])
+        dates = begin + offsets
+        date_bins = begin + bins
+
+        td = np.dtype('timedelta64[D]')
+
+        # Results should be the same for integer offsets or datetime values.
+        # For now, only explicit bins are supported, since linspace does not
+        # work on datetimes or timedeltas
+        d_count, d_edge = histogram(dates, bins=date_bins)
+        t_count, t_edge = histogram(offsets.astype(td), bins=bins.astype(td))
+        i_count, i_edge = histogram(offsets, bins=bins)
+
+        assert_equal(d_count, i_count)
+        assert_equal(t_count, i_count)
+
+        assert_equal((d_edge - begin).astype(int), i_edge)
+        assert_equal(t_edge.astype(int), i_edge)
+
+        assert_equal(d_edge.dtype, dates.dtype)
+        assert_equal(t_edge.dtype, td)
+
+    def do_signed_overflow_bounds(self, dtype):
+        exponent = 8 * np.dtype(dtype).itemsize - 1
+        arr = np.array([-2**exponent + 4, 2**exponent - 4], dtype=dtype)
+        hist, e = histogram(arr, bins=2)
+        assert_equal(e, [-2**exponent + 4, 0, 2**exponent - 4])
+        assert_equal(hist, [1, 1])
+
+    def test_signed_overflow_bounds(self):
+        self.do_signed_overflow_bounds(np.byte)
+        self.do_signed_overflow_bounds(np.short)
+        self.do_signed_overflow_bounds(np.intc)
+        self.do_signed_overflow_bounds(np.int_)
+        self.do_signed_overflow_bounds(np.longlong)
+
+    def do_precision_lower_bound(self, float_small, float_large):
+        eps = np.finfo(float_large).eps
+
+        arr = np.array([1.0], float_small)
+        range = np.array([1.0 + eps, 2.0], float_large)
+
+        # test is looking for behavior when the bounds change between dtypes
+        if range.astype(float_small)[0] != 1:
+            return
+
+        # previously crashed
+        count, x_loc = np.histogram(arr, bins=1, range=range)
+        assert_equal(count, [0])
+        assert_equal(x_loc.dtype, float_large)
+
+    def do_precision_upper_bound(self, float_small, float_large):
+        eps = np.finfo(float_large).eps
+
+        arr = np.array([1.0], float_small)
+        range = np.array([0.0, 1.0 - eps], float_large)
+
+        # test is looking for behavior when the bounds change between dtypes
+        if range.astype(float_small)[-1] != 1:
+            return
+
+        # previously crashed
+        count, x_loc = np.histogram(arr, bins=1, range=range)
+        assert_equal(count, [0])
+
+        assert_equal(x_loc.dtype, float_large)
+
+    def do_precision(self, float_small, float_large):
+        self.do_precision_lower_bound(float_small, float_large)
+        self.do_precision_upper_bound(float_small, float_large)
+
+    def test_precision(self):
+        # not looping results in a useful stack trace upon failure
+        self.do_precision(np.half, np.single)
+        self.do_precision(np.half, np.double)
+        self.do_precision(np.half, np.longdouble)
+        self.do_precision(np.single, np.double)
+        self.do_precision(np.single, np.longdouble)
+        self.do_precision(np.double, np.longdouble)
+
+    def test_histogram_bin_edges(self):
+        hist, e = histogram([1, 2, 3, 4], [1, 2])
+        edges = histogram_bin_edges([1, 2, 3, 4], [1, 2])
+        assert_array_equal(edges, e)
+
+        arr = np.array([0.,  0.,  0.,  1.,  2.,  3.,  3.,  4.,  5.])
+        hist, e = histogram(arr, bins=30, range=(-0.5, 5))
+        edges = histogram_bin_edges(arr, bins=30, range=(-0.5, 5))
+        assert_array_equal(edges, e)
+
+        hist, e = histogram(arr, bins='auto', range=(0, 1))
+        edges = histogram_bin_edges(arr, bins='auto', range=(0, 1))
+        assert_array_equal(edges, e)
+
+    # @requires_memory(free_bytes=1e10)
+    # @pytest.mark.slow
+    @pytest.mark.skip(reason="Bad memory reports lead to OOM in ci testing")
+    def test_big_arrays(self):
+        sample = np.zeros([100000000, 3])
+        xbins = 400
+        ybins = 400
+        zbins = np.arange(16000)
+        hist = np.histogramdd(sample=sample, bins=(xbins, ybins, zbins))
+        assert_equal(type(hist), type((1, 2)))
+
+    def test_gh_23110(self):
+        hist, e = np.histogram(np.array([-0.9e-308], dtype='>f8'),
+                               bins=2,
+                               range=(-1e-308, -2e-313))
+        expected_hist = np.array([1, 0])
+        assert_array_equal(hist, expected_hist)
+
+
+class TestHistogramOptimBinNums:
+    """
+    Provide test coverage when using provided estimators for optimal number of
+    bins
+    """
+
+    def test_empty(self):
+        estimator_list = ['fd', 'scott', 'rice', 'sturges',
+                          'doane', 'sqrt', 'auto', 'stone']
+        # check it can deal with empty data
+        for estimator in estimator_list:
+            a, b = histogram([], bins=estimator)
+            assert_array_equal(a, np.array([0]))
+            assert_array_equal(b, np.array([0, 1]))
+
+    def test_simple(self):
+        """
+        Straightforward testing with a mixture of linspace data (for
+        consistency). All test values have been precomputed and the values
+        shouldn't change
+        """
+        # Some basic sanity checking, with some fixed data.
+        # Checking for the correct number of bins
+        basic_test = {50:   {'fd': 4,  'scott': 4,  'rice': 8,  'sturges': 7,
+                             'doane': 8, 'sqrt': 8, 'auto': 7, 'stone': 2},
+                      500:  {'fd': 8,  'scott': 8,  'rice': 16, 'sturges': 10,
+                             'doane': 12, 'sqrt': 23, 'auto': 10, 'stone': 9},
+                      5000: {'fd': 17, 'scott': 17, 'rice': 35, 'sturges': 14,
+                             'doane': 17, 'sqrt': 71, 'auto': 17, 'stone': 20}}
+
+        for testlen, expectedResults in basic_test.items():
+            # Create some sort of non uniform data to test with
+            # (2 peak uniform mixture)
+            x1 = np.linspace(-10, -1, testlen // 5 * 2)
+            x2 = np.linspace(1, 10, testlen // 5 * 3)
+            x = np.concatenate((x1, x2))
+            for estimator, numbins in expectedResults.items():
+                a, b = np.histogram(x, estimator)
+                assert_equal(len(a), numbins, err_msg="For the {0} estimator "
+                             "with datasize of {1}".format(estimator, testlen))
+
+    def test_small(self):
+        """
+        Smaller datasets have the potential to cause issues with the data
+        adaptive methods, especially the FD method. All bin numbers have been
+        precalculated.
+        """
+        small_dat = {1: {'fd': 1, 'scott': 1, 'rice': 1, 'sturges': 1,
+                         'doane': 1, 'sqrt': 1, 'stone': 1},
+                     2: {'fd': 2, 'scott': 1, 'rice': 3, 'sturges': 2,
+                         'doane': 1, 'sqrt': 2, 'stone': 1},
+                     3: {'fd': 2, 'scott': 2, 'rice': 3, 'sturges': 3,
+                         'doane': 3, 'sqrt': 2, 'stone': 1}}
+
+        for testlen, expectedResults in small_dat.items():
+            testdat = np.arange(testlen).astype(float)
+            for estimator, expbins in expectedResults.items():
+                a, b = np.histogram(testdat, estimator)
+                assert_equal(len(a), expbins, err_msg="For the {0} estimator "
+                             "with datasize of {1}".format(estimator, testlen))
+
+    def test_incorrect_methods(self):
+        """
+        Check a Value Error is thrown when an unknown string is passed in
+        """
+        check_list = ['mad', 'freeman', 'histograms', 'IQR']
+        for estimator in check_list:
+            assert_raises(ValueError, histogram, [1, 2, 3], estimator)
+
+    def test_novariance(self):
+        """
+        Check that methods handle no variance in data
+        Primarily for Scott and FD as the SD and IQR are both 0 in this case
+        """
+        novar_dataset = np.ones(100)
+        novar_resultdict = {'fd': 1, 'scott': 1, 'rice': 1, 'sturges': 1,
+                            'doane': 1, 'sqrt': 1, 'auto': 1, 'stone': 1}
+
+        for estimator, numbins in novar_resultdict.items():
+            a, b = np.histogram(novar_dataset, estimator)
+            assert_equal(len(a), numbins, err_msg="{0} estimator, "
+                         "No Variance test".format(estimator))
+
+    def test_limited_variance(self):
+        """
+        Check when IQR is 0, but variance exists, we return the sturges value
+        and not the fd value.
+        """
+        lim_var_data = np.ones(1000)
+        lim_var_data[:3] = 0
+        lim_var_data[-4:] = 100
+
+        edges_auto = histogram_bin_edges(lim_var_data, 'auto')
+        assert_equal(edges_auto, np.linspace(0, 100, 12))
+
+        edges_fd = histogram_bin_edges(lim_var_data, 'fd')
+        assert_equal(edges_fd, np.array([0, 100]))
+
+        edges_sturges = histogram_bin_edges(lim_var_data, 'sturges')
+        assert_equal(edges_sturges, np.linspace(0, 100, 12))
+
+    def test_outlier(self):
+        """
+        Check the FD, Scott and Doane with outliers.
+
+        The FD estimates a smaller binwidth since it's less affected by
+        outliers. Since the range is so (artificially) large, this means more
+        bins, most of which will be empty, but the data of interest usually is
+        unaffected. The Scott estimator is more affected and returns fewer bins,
+        despite most of the variance being in one area of the data. The Doane
+        estimator lies somewhere between the other two.
+        """
+        xcenter = np.linspace(-10, 10, 50)
+        outlier_dataset = np.hstack((np.linspace(-110, -100, 5), xcenter))
+
+        outlier_resultdict = {'fd': 21, 'scott': 5, 'doane': 11, 'stone': 6}
+
+        for estimator, numbins in outlier_resultdict.items():
+            a, b = np.histogram(outlier_dataset, estimator)
+            assert_equal(len(a), numbins)
+
+    def test_scott_vs_stone(self):
+        """Verify that Scott's rule and Stone's rule converges for normally distributed data"""
+
+        def nbins_ratio(seed, size):
+            rng = np.random.RandomState(seed)
+            x = rng.normal(loc=0, scale=2, size=size)
+            a, b = len(np.histogram(x, 'stone')[0]), len(np.histogram(x, 'scott')[0])
+            return a / (a + b)
+
+        ll = [[nbins_ratio(seed, size) for size in np.geomspace(start=10, stop=100, num=4).round().astype(int)]
+              for seed in range(10)]
+
+        # the average difference between the two methods decreases as the dataset size increases.
+        avg = abs(np.mean(ll, axis=0) - 0.5)
+        assert_almost_equal(avg, [0.15, 0.09, 0.08, 0.03], decimal=2)
+
+    def test_simple_range(self):
+        """
+        Straightforward testing with a mixture of linspace data (for
+        consistency). Adding in a 3rd mixture that will then be
+        completely ignored. All test values have been precomputed and
+        the shouldn't change.
+        """
+        # some basic sanity checking, with some fixed data.
+        # Checking for the correct number of bins
+        basic_test = {
+                      50:   {'fd': 8,  'scott': 8,  'rice': 15,
+                             'sturges': 14, 'auto': 14, 'stone': 8},
+                      500:  {'fd': 15, 'scott': 16, 'rice': 32,
+                             'sturges': 20, 'auto': 20, 'stone': 80},
+                      5000: {'fd': 33, 'scott': 33, 'rice': 69,
+                             'sturges': 27, 'auto': 33, 'stone': 80}
+                     }
+
+        for testlen, expectedResults in basic_test.items():
+            # create some sort of non uniform data to test with
+            # (3 peak uniform mixture)
+            x1 = np.linspace(-10, -1, testlen // 5 * 2)
+            x2 = np.linspace(1, 10, testlen // 5 * 3)
+            x3 = np.linspace(-100, -50, testlen)
+            x = np.hstack((x1, x2, x3))
+            for estimator, numbins in expectedResults.items():
+                a, b = np.histogram(x, estimator, range = (-20, 20))
+                msg = "For the {0} estimator".format(estimator)
+                msg += " with datasize of {0}".format(testlen)
+                assert_equal(len(a), numbins, err_msg=msg)
+
+    @pytest.mark.parametrize("bins", ['auto', 'fd', 'doane', 'scott',
+                                      'stone', 'rice', 'sturges'])
+    def test_signed_integer_data(self, bins):
+        # Regression test for gh-14379.
+        a = np.array([-2, 0, 127], dtype=np.int8)
+        hist, edges = np.histogram(a, bins=bins)
+        hist32, edges32 = np.histogram(a.astype(np.int32), bins=bins)
+        assert_array_equal(hist, hist32)
+        assert_array_equal(edges, edges32)
+
+    @pytest.mark.parametrize("bins", ['auto', 'fd', 'doane', 'scott',
+                                      'stone', 'rice', 'sturges'])
+    def test_integer(self, bins):
+        """
+        Test that bin width for integer data is at least 1.
+        """
+        with suppress_warnings() as sup:
+            if bins == 'stone':
+                sup.filter(RuntimeWarning)
+            assert_equal(
+                np.histogram_bin_edges(np.tile(np.arange(9), 1000), bins),
+                np.arange(9))
+
+    def test_integer_non_auto(self):
+        """
+        Test that the bin-width>=1 requirement *only* applies to auto binning.
+        """
+        assert_equal(
+            np.histogram_bin_edges(np.tile(np.arange(9), 1000), 16),
+            np.arange(17) / 2)
+        assert_equal(
+            np.histogram_bin_edges(np.tile(np.arange(9), 1000), [.1, .2]),
+            [.1, .2])
+
+    def test_simple_weighted(self):
+        """
+        Check that weighted data raises a TypeError
+        """
+        estimator_list = ['fd', 'scott', 'rice', 'sturges', 'auto']
+        for estimator in estimator_list:
+            assert_raises(TypeError, histogram, [1, 2, 3],
+                          estimator, weights=[1, 2, 3])
+
+
+class TestHistogramdd:
+
+    def test_simple(self):
+        x = np.array([[-.5, .5, 1.5], [-.5, 1.5, 2.5], [-.5, 2.5, .5],
+                      [.5,  .5, 1.5], [.5,  1.5, 2.5], [.5,  2.5, 2.5]])
+        H, edges = histogramdd(x, (2, 3, 3),
+                               range=[[-1, 1], [0, 3], [0, 3]])
+        answer = np.array([[[0, 1, 0], [0, 0, 1], [1, 0, 0]],
+                           [[0, 1, 0], [0, 0, 1], [0, 0, 1]]])
+        assert_array_equal(H, answer)
+
+        # Check normalization
+        ed = [[-2, 0, 2], [0, 1, 2, 3], [0, 1, 2, 3]]
+        H, edges = histogramdd(x, bins=ed, density=True)
+        assert_(np.all(H == answer / 12.))
+
+        # Check that H has the correct shape.
+        H, edges = histogramdd(x, (2, 3, 4),
+                               range=[[-1, 1], [0, 3], [0, 4]],
+                               density=True)
+        answer = np.array([[[0, 1, 0, 0], [0, 0, 1, 0], [1, 0, 0, 0]],
+                           [[0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 1, 0]]])
+        assert_array_almost_equal(H, answer / 6., 4)
+        # Check that a sequence of arrays is accepted and H has the correct
+        # shape.
+        z = [np.squeeze(y) for y in np.split(x, 3, axis=1)]
+        H, edges = histogramdd(
+            z, bins=(4, 3, 2), range=[[-2, 2], [0, 3], [0, 2]])
+        answer = np.array([[[0, 0], [0, 0], [0, 0]],
+                           [[0, 1], [0, 0], [1, 0]],
+                           [[0, 1], [0, 0], [0, 0]],
+                           [[0, 0], [0, 0], [0, 0]]])
+        assert_array_equal(H, answer)
+
+        Z = np.zeros((5, 5, 5))
+        Z[list(range(5)), list(range(5)), list(range(5))] = 1.
+        H, edges = histogramdd([np.arange(5), np.arange(5), np.arange(5)], 5)
+        assert_array_equal(H, Z)
+
+    def test_shape_3d(self):
+        # All possible permutations for bins of different lengths in 3D.
+        bins = ((5, 4, 6), (6, 4, 5), (5, 6, 4), (4, 6, 5), (6, 5, 4),
+                (4, 5, 6))
+        r = np.random.rand(10, 3)
+        for b in bins:
+            H, edges = histogramdd(r, b)
+            assert_(H.shape == b)
+
+    def test_shape_4d(self):
+        # All possible permutations for bins of different lengths in 4D.
+        bins = ((7, 4, 5, 6), (4, 5, 7, 6), (5, 6, 4, 7), (7, 6, 5, 4),
+                (5, 7, 6, 4), (4, 6, 7, 5), (6, 5, 7, 4), (7, 5, 4, 6),
+                (7, 4, 6, 5), (6, 4, 7, 5), (6, 7, 5, 4), (4, 6, 5, 7),
+                (4, 7, 5, 6), (5, 4, 6, 7), (5, 7, 4, 6), (6, 7, 4, 5),
+                (6, 5, 4, 7), (4, 7, 6, 5), (4, 5, 6, 7), (7, 6, 4, 5),
+                (5, 4, 7, 6), (5, 6, 7, 4), (6, 4, 5, 7), (7, 5, 6, 4))
+
+        r = np.random.rand(10, 4)
+        for b in bins:
+            H, edges = histogramdd(r, b)
+            assert_(H.shape == b)
+
+    def test_weights(self):
+        v = np.random.rand(100, 2)
+        hist, edges = histogramdd(v)
+        n_hist, edges = histogramdd(v, density=True)
+        w_hist, edges = histogramdd(v, weights=np.ones(100))
+        assert_array_equal(w_hist, hist)
+        w_hist, edges = histogramdd(v, weights=np.ones(100) * 2, density=True)
+        assert_array_equal(w_hist, n_hist)
+        w_hist, edges = histogramdd(v, weights=np.ones(100, int) * 2)
+        assert_array_equal(w_hist, 2 * hist)
+
+    def test_identical_samples(self):
+        x = np.zeros((10, 2), int)
+        hist, edges = histogramdd(x, bins=2)
+        assert_array_equal(edges[0], np.array([-0.5, 0., 0.5]))
+
+    def test_empty(self):
+        a, b = histogramdd([[], []], bins=([0, 1], [0, 1]))
+        assert_array_max_ulp(a, np.array([[0.]]))
+        a, b = np.histogramdd([[], [], []], bins=2)
+        assert_array_max_ulp(a, np.zeros((2, 2, 2)))
+
+    def test_bins_errors(self):
+        # There are two ways to specify bins. Check for the right errors
+        # when mixing those.
+        x = np.arange(8).reshape(2, 4)
+        assert_raises(ValueError, np.histogramdd, x, bins=[-1, 2, 4, 5])
+        assert_raises(ValueError, np.histogramdd, x, bins=[1, 0.99, 1, 1])
+        assert_raises(
+            ValueError, np.histogramdd, x, bins=[1, 1, 1, [1, 2, 3, -3]])
+        assert_(np.histogramdd(x, bins=[1, 1, 1, [1, 2, 3, 4]]))
+
+    def test_inf_edges(self):
+        # Test using +/-inf bin edges works. See #1788.
+        with np.errstate(invalid='ignore'):
+            x = np.arange(6).reshape(3, 2)
+            expected = np.array([[1, 0], [0, 1], [0, 1]])
+            h, e = np.histogramdd(x, bins=[3, [-np.inf, 2, 10]])
+            assert_allclose(h, expected)
+            h, e = np.histogramdd(x, bins=[3, np.array([-1, 2, np.inf])])
+            assert_allclose(h, expected)
+            h, e = np.histogramdd(x, bins=[3, [-np.inf, 3, np.inf]])
+            assert_allclose(h, expected)
+
+    def test_rightmost_binedge(self):
+        # Test event very close to rightmost binedge. See Github issue #4266
+        x = [0.9999999995]
+        bins = [[0., 0.5, 1.0]]
+        hist, _ = histogramdd(x, bins=bins)
+        assert_(hist[0] == 0.0)
+        assert_(hist[1] == 1.)
+        x = [1.0]
+        bins = [[0., 0.5, 1.0]]
+        hist, _ = histogramdd(x, bins=bins)
+        assert_(hist[0] == 0.0)
+        assert_(hist[1] == 1.)
+        x = [1.0000000001]
+        bins = [[0., 0.5, 1.0]]
+        hist, _ = histogramdd(x, bins=bins)
+        assert_(hist[0] == 0.0)
+        assert_(hist[1] == 0.0)
+        x = [1.0001]
+        bins = [[0., 0.5, 1.0]]
+        hist, _ = histogramdd(x, bins=bins)
+        assert_(hist[0] == 0.0)
+        assert_(hist[1] == 0.0)
+
+    def test_finite_range(self):
+        vals = np.random.random((100, 3))
+        histogramdd(vals, range=[[0.0, 1.0], [0.25, 0.75], [0.25, 0.5]])
+        assert_raises(ValueError, histogramdd, vals,
+                      range=[[0.0, 1.0], [0.25, 0.75], [0.25, np.inf]])
+        assert_raises(ValueError, histogramdd, vals,
+                      range=[[0.0, 1.0], [np.nan, 0.75], [0.25, 0.5]])
+
+    def test_equal_edges(self):
+        """ Test that adjacent entries in an edge array can be equal """
+        x = np.array([0, 1, 2])
+        y = np.array([0, 1, 2])
+        x_edges = np.array([0, 2, 2])
+        y_edges = 1
+        hist, edges = histogramdd((x, y), bins=(x_edges, y_edges))
+
+        hist_expected = np.array([
+            [2.],
+            [1.],  # x == 2 falls in the final bin
+        ])
+        assert_equal(hist, hist_expected)
+
+    def test_edge_dtype(self):
+        """ Test that if an edge array is input, its type is preserved """
+        x = np.array([0, 10, 20])
+        y = x / 10
+        x_edges = np.array([0, 5, 15, 20])
+        y_edges = x_edges / 10
+        hist, edges = histogramdd((x, y), bins=(x_edges, y_edges))
+
+        assert_equal(edges[0].dtype, x_edges.dtype)
+        assert_equal(edges[1].dtype, y_edges.dtype)
+
+    def test_large_integers(self):
+        big = 2**60  # Too large to represent with a full precision float
+
+        x = np.array([0], np.int64)
+        x_edges = np.array([-1, +1], np.int64)
+        y = big + x
+        y_edges = big + x_edges
+
+        hist, edges = histogramdd((x, y), bins=(x_edges, y_edges))
+
+        assert_equal(hist[0, 0], 1)
+
+    def test_density_non_uniform_2d(self):
+        # Defines the following grid:
+        #
+        #    0 2     8
+        #   0+-+-----+
+        #    + |     +
+        #    + |     +
+        #   6+-+-----+
+        #   8+-+-----+
+        x_edges = np.array([0, 2, 8])
+        y_edges = np.array([0, 6, 8])
+        relative_areas = np.array([
+            [3, 9],
+            [1, 3]])
+
+        # ensure the number of points in each region is proportional to its area
+        x = np.array([1] + [1]*3 + [7]*3 + [7]*9)
+        y = np.array([7] + [1]*3 + [7]*3 + [1]*9)
+
+        # sanity check that the above worked as intended
+        hist, edges = histogramdd((y, x), bins=(y_edges, x_edges))
+        assert_equal(hist, relative_areas)
+
+        # resulting histogram should be uniform, since counts and areas are proportional
+        hist, edges = histogramdd((y, x), bins=(y_edges, x_edges), density=True)
+        assert_equal(hist, 1 / (8*8))
+
+    def test_density_non_uniform_1d(self):
+        # compare to histogram to show the results are the same
+        v = np.arange(10)
+        bins = np.array([0, 1, 3, 6, 10])
+        hist, edges = histogram(v, bins, density=True)
+        hist_dd, edges_dd = histogramdd((v,), (bins,), density=True)
+        assert_equal(hist, hist_dd)
+        assert_equal(edges, edges_dd[0])
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/tests/test_index_tricks.py b/venv/lib/python3.12/site-packages/numpy/lib/tests/test_index_tricks.py
new file mode 100644
index 00000000..fe1cfce2
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/lib/tests/test_index_tricks.py
@@ -0,0 +1,553 @@
+import pytest
+
+import numpy as np
+from numpy.testing import (
+    assert_, assert_equal, assert_array_equal, assert_almost_equal,
+    assert_array_almost_equal, assert_raises, assert_raises_regex,
+    )
+from numpy.lib._index_tricks_impl import (
+    mgrid, ogrid, ndenumerate, fill_diagonal, diag_indices, diag_indices_from,
+    index_exp, ndindex, c_, r_, s_, ix_
+    )
+
+
+class TestRavelUnravelIndex:
+    def test_basic(self):
+        assert_equal(np.unravel_index(2, (2, 2)), (1, 0))
+
+        # test that new shape argument works properly
+        assert_equal(np.unravel_index(indices=2,
+                                      shape=(2, 2)),
+                                      (1, 0))
+
+        # test that an invalid second keyword argument
+        # is properly handled, including the old name `dims`.
+        with assert_raises(TypeError):
+            np.unravel_index(indices=2, hape=(2, 2))
+
+        with assert_raises(TypeError):
+            np.unravel_index(2, hape=(2, 2))
+
+        with assert_raises(TypeError):
+            np.unravel_index(254, ims=(17, 94))
+
+        with assert_raises(TypeError):
+            np.unravel_index(254, dims=(17, 94))
+
+        assert_equal(np.ravel_multi_index((1, 0), (2, 2)), 2)
+        assert_equal(np.unravel_index(254, (17, 94)), (2, 66))
+        assert_equal(np.ravel_multi_index((2, 66), (17, 94)), 254)
+        assert_raises(ValueError, np.unravel_index, -1, (2, 2))
+        assert_raises(TypeError, np.unravel_index, 0.5, (2, 2))
+        assert_raises(ValueError, np.unravel_index, 4, (2, 2))
+        assert_raises(ValueError, np.ravel_multi_index, (-3, 1), (2, 2))
+        assert_raises(ValueError, np.ravel_multi_index, (2, 1), (2, 2))
+        assert_raises(ValueError, np.ravel_multi_index, (0, -3), (2, 2))
+        assert_raises(ValueError, np.ravel_multi_index, (0, 2), (2, 2))
+        assert_raises(TypeError, np.ravel_multi_index, (0.1, 0.), (2, 2))
+
+        assert_equal(np.unravel_index((2*3 + 1)*6 + 4, (4, 3, 6)), [2, 1, 4])
+        assert_equal(
+            np.ravel_multi_index([2, 1, 4], (4, 3, 6)), (2*3 + 1)*6 + 4)
+
+        arr = np.array([[3, 6, 6], [4, 5, 1]])
+        assert_equal(np.ravel_multi_index(arr, (7, 6)), [22, 41, 37])
+        assert_equal(
+            np.ravel_multi_index(arr, (7, 6), order='F'), [31, 41, 13])
+        assert_equal(
+            np.ravel_multi_index(arr, (4, 6), mode='clip'), [22, 23, 19])
+        assert_equal(np.ravel_multi_index(arr, (4, 4), mode=('clip', 'wrap')),
+                     [12, 13, 13])
+        assert_equal(np.ravel_multi_index((3, 1, 4, 1), (6, 7, 8, 9)), 1621)
+
+        assert_equal(np.unravel_index(np.array([22, 41, 37]), (7, 6)),
+                     [[3, 6, 6], [4, 5, 1]])
+        assert_equal(
+            np.unravel_index(np.array([31, 41, 13]), (7, 6), order='F'),
+            [[3, 6, 6], [4, 5, 1]])
+        assert_equal(np.unravel_index(1621, (6, 7, 8, 9)), [3, 1, 4, 1])
+
+    def test_empty_indices(self):
+        msg1 = 'indices must be integral: the provided empty sequence was'
+        msg2 = 'only int indices permitted'
+        assert_raises_regex(TypeError, msg1, np.unravel_index, [], (10, 3, 5))
+        assert_raises_regex(TypeError, msg1, np.unravel_index, (), (10, 3, 5))
+        assert_raises_regex(TypeError, msg2, np.unravel_index, np.array([]),
+                            (10, 3, 5))
+        assert_equal(np.unravel_index(np.array([],dtype=int), (10, 3, 5)),
+                     [[], [], []])
+        assert_raises_regex(TypeError, msg1, np.ravel_multi_index, ([], []),
+                            (10, 3))
+        assert_raises_regex(TypeError, msg1, np.ravel_multi_index, ([], ['abc']),
+                            (10, 3))
+        assert_raises_regex(TypeError, msg2, np.ravel_multi_index,
+                    (np.array([]), np.array([])), (5, 3))
+        assert_equal(np.ravel_multi_index(
+                (np.array([], dtype=int), np.array([], dtype=int)), (5, 3)), [])
+        assert_equal(np.ravel_multi_index(np.array([[], []], dtype=int),
+                     (5, 3)), [])
+
+    def test_big_indices(self):
+        # ravel_multi_index for big indices (issue #7546)
+        if np.intp == np.int64:
+            arr = ([1, 29], [3, 5], [3, 117], [19, 2],
+                   [2379, 1284], [2, 2], [0, 1])
+            assert_equal(
+                np.ravel_multi_index(arr, (41, 7, 120, 36, 2706, 8, 6)),
+                [5627771580, 117259570957])
+
+        # test unravel_index for big indices (issue #9538)
+        assert_raises(ValueError, np.unravel_index, 1, (2**32-1, 2**31+1))
+
+        # test overflow checking for too big array (issue #7546)
+        dummy_arr = ([0],[0])
+        half_max = np.iinfo(np.intp).max // 2
+        assert_equal(
+            np.ravel_multi_index(dummy_arr, (half_max, 2)), [0])
+        assert_raises(ValueError,
+            np.ravel_multi_index, dummy_arr, (half_max+1, 2))
+        assert_equal(
+            np.ravel_multi_index(dummy_arr, (half_max, 2), order='F'), [0])
+        assert_raises(ValueError,
+            np.ravel_multi_index, dummy_arr, (half_max+1, 2), order='F')
+
+    def test_dtypes(self):
+        # Test with different data types
+        for dtype in [np.int16, np.uint16, np.int32,
+                      np.uint32, np.int64, np.uint64]:
+            coords = np.array(
+                [[1, 0, 1, 2, 3, 4], [1, 6, 1, 3, 2, 0]], dtype=dtype)
+            shape = (5, 8)
+            uncoords = 8*coords[0]+coords[1]
+            assert_equal(np.ravel_multi_index(coords, shape), uncoords)
+            assert_equal(coords, np.unravel_index(uncoords, shape))
+            uncoords = coords[0]+5*coords[1]
+            assert_equal(
+                np.ravel_multi_index(coords, shape, order='F'), uncoords)
+            assert_equal(coords, np.unravel_index(uncoords, shape, order='F'))
+
+            coords = np.array(
+                [[1, 0, 1, 2, 3, 4], [1, 6, 1, 3, 2, 0], [1, 3, 1, 0, 9, 5]],
+                dtype=dtype)
+            shape = (5, 8, 10)
+            uncoords = 10*(8*coords[0]+coords[1])+coords[2]
+            assert_equal(np.ravel_multi_index(coords, shape), uncoords)
+            assert_equal(coords, np.unravel_index(uncoords, shape))
+            uncoords = coords[0]+5*(coords[1]+8*coords[2])
+            assert_equal(
+                np.ravel_multi_index(coords, shape, order='F'), uncoords)
+            assert_equal(coords, np.unravel_index(uncoords, shape, order='F'))
+
+    def test_clipmodes(self):
+        # Test clipmodes
+        assert_equal(
+            np.ravel_multi_index([5, 1, -1, 2], (4, 3, 7, 12), mode='wrap'),
+            np.ravel_multi_index([1, 1, 6, 2], (4, 3, 7, 12)))
+        assert_equal(np.ravel_multi_index([5, 1, -1, 2], (4, 3, 7, 12),
+                                          mode=(
+                                              'wrap', 'raise', 'clip', 'raise')),
+                     np.ravel_multi_index([1, 1, 0, 2], (4, 3, 7, 12)))
+        assert_raises(
+            ValueError, np.ravel_multi_index, [5, 1, -1, 2], (4, 3, 7, 12))
+
+    def test_writeability(self):
+        # See gh-7269
+        x, y = np.unravel_index([1, 2, 3], (4, 5))
+        assert_(x.flags.writeable)
+        assert_(y.flags.writeable)
+
+    def test_0d(self):
+        # gh-580
+        x = np.unravel_index(0, ())
+        assert_equal(x, ())
+
+        assert_raises_regex(ValueError, "0d array", np.unravel_index, [0], ())
+        assert_raises_regex(
+            ValueError, "out of bounds", np.unravel_index, [1], ())
+
+    @pytest.mark.parametrize("mode", ["clip", "wrap", "raise"])
+    def test_empty_array_ravel(self, mode):
+        res = np.ravel_multi_index(
+                    np.zeros((3, 0), dtype=np.intp), (2, 1, 0), mode=mode)
+        assert(res.shape == (0,))
+
+        with assert_raises(ValueError):
+            np.ravel_multi_index(
+                    np.zeros((3, 1), dtype=np.intp), (2, 1, 0), mode=mode)
+
+    def test_empty_array_unravel(self):
+        res = np.unravel_index(np.zeros(0, dtype=np.intp), (2, 1, 0))
+        # res is a tuple of three empty arrays
+        assert(len(res) == 3)
+        assert(all(a.shape == (0,) for a in res))
+
+        with assert_raises(ValueError):
+            np.unravel_index([1], (2, 1, 0))
+
+class TestGrid:
+    def test_basic(self):
+        a = mgrid[-1:1:10j]
+        b = mgrid[-1:1:0.1]
+        assert_(a.shape == (10,))
+        assert_(b.shape == (20,))
+        assert_(a[0] == -1)
+        assert_almost_equal(a[-1], 1)
+        assert_(b[0] == -1)
+        assert_almost_equal(b[1]-b[0], 0.1, 11)
+        assert_almost_equal(b[-1], b[0]+19*0.1, 11)
+        assert_almost_equal(a[1]-a[0], 2.0/9.0, 11)
+
+    def test_linspace_equivalence(self):
+        y, st = np.linspace(2, 10, retstep=True)
+        assert_almost_equal(st, 8/49.0)
+        assert_array_almost_equal(y, mgrid[2:10:50j], 13)
+
+    def test_nd(self):
+        c = mgrid[-1:1:10j, -2:2:10j]
+        d = mgrid[-1:1:0.1, -2:2:0.2]
+        assert_(c.shape == (2, 10, 10))
+        assert_(d.shape == (2, 20, 20))
+        assert_array_equal(c[0][0, :], -np.ones(10, 'd'))
+        assert_array_equal(c[1][:, 0], -2*np.ones(10, 'd'))
+        assert_array_almost_equal(c[0][-1, :], np.ones(10, 'd'), 11)
+        assert_array_almost_equal(c[1][:, -1], 2*np.ones(10, 'd'), 11)
+        assert_array_almost_equal(d[0, 1, :] - d[0, 0, :],
+                                  0.1*np.ones(20, 'd'), 11)
+        assert_array_almost_equal(d[1, :, 1] - d[1, :, 0],
+                                  0.2*np.ones(20, 'd'), 11)
+
+    def test_sparse(self):
+        grid_full   = mgrid[-1:1:10j, -2:2:10j]
+        grid_sparse = ogrid[-1:1:10j, -2:2:10j]
+
+        # sparse grids can be made dense by broadcasting
+        grid_broadcast = np.broadcast_arrays(*grid_sparse)
+        for f, b in zip(grid_full, grid_broadcast):
+            assert_equal(f, b)
+
+    @pytest.mark.parametrize("start, stop, step, expected", [
+        (None, 10, 10j, (200, 10)),
+        (-10, 20, None, (1800, 30)),
+        ])
+    def test_mgrid_size_none_handling(self, start, stop, step, expected):
+        # regression test None value handling for
+        # start and step values used by mgrid;
+        # internally, this aims to cover previously
+        # unexplored code paths in nd_grid()
+        grid = mgrid[start:stop:step, start:stop:step]
+        # need a smaller grid to explore one of the
+        # untested code paths
+        grid_small = mgrid[start:stop:step]
+        assert_equal(grid.size, expected[0])
+        assert_equal(grid_small.size, expected[1])
+
+    def test_accepts_npfloating(self):
+        # regression test for #16466
+        grid64 = mgrid[0.1:0.33:0.1, ]
+        grid32 = mgrid[np.float32(0.1):np.float32(0.33):np.float32(0.1), ]
+        assert_array_almost_equal(grid64, grid32)
+        # At some point this was float64, but NEP 50 changed it:
+        assert grid32.dtype == np.float32
+        assert grid64.dtype == np.float64
+
+        # different code path for single slice
+        grid64 = mgrid[0.1:0.33:0.1]
+        grid32 = mgrid[np.float32(0.1):np.float32(0.33):np.float32(0.1)]
+        assert_(grid32.dtype == np.float64)
+        assert_array_almost_equal(grid64, grid32)
+
+    def test_accepts_longdouble(self):
+        # regression tests for #16945
+        grid64 = mgrid[0.1:0.33:0.1, ]
+        grid128 = mgrid[
+            np.longdouble(0.1):np.longdouble(0.33):np.longdouble(0.1),
+        ]
+        assert_(grid128.dtype == np.longdouble)
+        assert_array_almost_equal(grid64, grid128)
+
+        grid128c_a = mgrid[0:np.longdouble(1):3.4j]
+        grid128c_b = mgrid[0:np.longdouble(1):3.4j, ]
+        assert_(grid128c_a.dtype == grid128c_b.dtype == np.longdouble)
+        assert_array_equal(grid128c_a, grid128c_b[0])
+
+        # different code path for single slice
+        grid64 = mgrid[0.1:0.33:0.1]
+        grid128 = mgrid[
+            np.longdouble(0.1):np.longdouble(0.33):np.longdouble(0.1)
+        ]
+        assert_(grid128.dtype == np.longdouble)
+        assert_array_almost_equal(grid64, grid128)
+
+    def test_accepts_npcomplexfloating(self):
+        # Related to #16466
+        assert_array_almost_equal(
+            mgrid[0.1:0.3:3j, ], mgrid[0.1:0.3:np.complex64(3j), ]
+        )
+
+        # different code path for single slice
+        assert_array_almost_equal(
+            mgrid[0.1:0.3:3j], mgrid[0.1:0.3:np.complex64(3j)]
+        )
+
+        # Related to #16945
+        grid64_a = mgrid[0.1:0.3:3.3j]
+        grid64_b = mgrid[0.1:0.3:3.3j, ][0]
+        assert_(grid64_a.dtype == grid64_b.dtype == np.float64)
+        assert_array_equal(grid64_a, grid64_b)
+
+        grid128_a = mgrid[0.1:0.3:np.clongdouble(3.3j)]
+        grid128_b = mgrid[0.1:0.3:np.clongdouble(3.3j), ][0]
+        assert_(grid128_a.dtype == grid128_b.dtype == np.longdouble)
+        assert_array_equal(grid64_a, grid64_b)
+
+
+class TestConcatenator:
+    def test_1d(self):
+        assert_array_equal(r_[1, 2, 3, 4, 5, 6], np.array([1, 2, 3, 4, 5, 6]))
+        b = np.ones(5)
+        c = r_[b, 0, 0, b]
+        assert_array_equal(c, [1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1])
+
+    def test_mixed_type(self):
+        g = r_[10.1, 1:10]
+        assert_(g.dtype == 'f8')
+
+    def test_more_mixed_type(self):
+        g = r_[-10.1, np.array([1]), np.array([2, 3, 4]), 10.0]
+        assert_(g.dtype == 'f8')
+
+    def test_complex_step(self):
+        # Regression test for #12262
+        g = r_[0:36:100j]
+        assert_(g.shape == (100,))
+
+        # Related to #16466
+        g = r_[0:36:np.complex64(100j)]
+        assert_(g.shape == (100,))
+
+    def test_2d(self):
+        b = np.random.rand(5, 5)
+        c = np.random.rand(5, 5)
+        d = r_['1', b, c]  # append columns
+        assert_(d.shape == (5, 10))
+        assert_array_equal(d[:, :5], b)
+        assert_array_equal(d[:, 5:], c)
+        d = r_[b, c]
+        assert_(d.shape == (10, 5))
+        assert_array_equal(d[:5, :], b)
+        assert_array_equal(d[5:, :], c)
+
+    def test_0d(self):
+        assert_equal(r_[0, np.array(1), 2], [0, 1, 2])
+        assert_equal(r_[[0, 1, 2], np.array(3)], [0, 1, 2, 3])
+        assert_equal(r_[np.array(0), [1, 2, 3]], [0, 1, 2, 3])
+
+
+class TestNdenumerate:
+    def test_basic(self):
+        a = np.array([[1, 2], [3, 4]])
+        assert_equal(list(ndenumerate(a)),
+                     [((0, 0), 1), ((0, 1), 2), ((1, 0), 3), ((1, 1), 4)])
+
+
+class TestIndexExpression:
+    def test_regression_1(self):
+        # ticket #1196
+        a = np.arange(2)
+        assert_equal(a[:-1], a[s_[:-1]])
+        assert_equal(a[:-1], a[index_exp[:-1]])
+
+    def test_simple_1(self):
+        a = np.random.rand(4, 5, 6)
+
+        assert_equal(a[:, :3, [1, 2]], a[index_exp[:, :3, [1, 2]]])
+        assert_equal(a[:, :3, [1, 2]], a[s_[:, :3, [1, 2]]])
+
+
+class TestIx_:
+    def test_regression_1(self):
+        # Test empty untyped inputs create outputs of indexing type, gh-5804
+        a, = np.ix_(range(0))
+        assert_equal(a.dtype, np.intp)
+
+        a, = np.ix_([])
+        assert_equal(a.dtype, np.intp)
+
+        # but if the type is specified, don't change it
+        a, = np.ix_(np.array([], dtype=np.float32))
+        assert_equal(a.dtype, np.float32)
+
+    def test_shape_and_dtype(self):
+        sizes = (4, 5, 3, 2)
+        # Test both lists and arrays
+        for func in (range, np.arange):
+            arrays = np.ix_(*[func(sz) for sz in sizes])
+            for k, (a, sz) in enumerate(zip(arrays, sizes)):
+                assert_equal(a.shape[k], sz)
+                assert_(all(sh == 1 for j, sh in enumerate(a.shape) if j != k))
+                assert_(np.issubdtype(a.dtype, np.integer))
+
+    def test_bool(self):
+        bool_a = [True, False, True, True]
+        int_a, = np.nonzero(bool_a)
+        assert_equal(np.ix_(bool_a)[0], int_a)
+
+    def test_1d_only(self):
+        idx2d = [[1, 2, 3], [4, 5, 6]]
+        assert_raises(ValueError, np.ix_, idx2d)
+
+    def test_repeated_input(self):
+        length_of_vector = 5
+        x = np.arange(length_of_vector)
+        out = ix_(x, x)
+        assert_equal(out[0].shape, (length_of_vector, 1))
+        assert_equal(out[1].shape, (1, length_of_vector))
+        # check that input shape is not modified
+        assert_equal(x.shape, (length_of_vector,))
+
+
+def test_c_():
+    a = c_[np.array([[1, 2, 3]]), 0, 0, np.array([[4, 5, 6]])]
+    assert_equal(a, [[1, 2, 3, 0, 0, 4, 5, 6]])
+
+
+class TestFillDiagonal:
+    def test_basic(self):
+        a = np.zeros((3, 3), int)
+        fill_diagonal(a, 5)
+        assert_array_equal(
+            a, np.array([[5, 0, 0],
+                         [0, 5, 0],
+                         [0, 0, 5]])
+            )
+
+    def test_tall_matrix(self):
+        a = np.zeros((10, 3), int)
+        fill_diagonal(a, 5)
+        assert_array_equal(
+            a, np.array([[5, 0, 0],
+                         [0, 5, 0],
+                         [0, 0, 5],
+                         [0, 0, 0],
+                         [0, 0, 0],
+                         [0, 0, 0],
+                         [0, 0, 0],
+                         [0, 0, 0],
+                         [0, 0, 0],
+                         [0, 0, 0]])
+            )
+
+    def test_tall_matrix_wrap(self):
+        a = np.zeros((10, 3), int)
+        fill_diagonal(a, 5, True)
+        assert_array_equal(
+            a, np.array([[5, 0, 0],
+                         [0, 5, 0],
+                         [0, 0, 5],
+                         [0, 0, 0],
+                         [5, 0, 0],
+                         [0, 5, 0],
+                         [0, 0, 5],
+                         [0, 0, 0],
+                         [5, 0, 0],
+                         [0, 5, 0]])
+            )
+
+    def test_wide_matrix(self):
+        a = np.zeros((3, 10), int)
+        fill_diagonal(a, 5)
+        assert_array_equal(
+            a, np.array([[5, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+                         [0, 5, 0, 0, 0, 0, 0, 0, 0, 0],
+                         [0, 0, 5, 0, 0, 0, 0, 0, 0, 0]])
+            )
+
+    def test_operate_4d_array(self):
+        a = np.zeros((3, 3, 3, 3), int)
+        fill_diagonal(a, 4)
+        i = np.array([0, 1, 2])
+        assert_equal(np.where(a != 0), (i, i, i, i))
+
+    def test_low_dim_handling(self):
+        # raise error with low dimensionality
+        a = np.zeros(3, int)
+        with assert_raises_regex(ValueError, "at least 2-d"):
+            fill_diagonal(a, 5)
+
+    def test_hetero_shape_handling(self):
+        # raise error with high dimensionality and
+        # shape mismatch
+        a = np.zeros((3,3,7,3), int)
+        with assert_raises_regex(ValueError, "equal length"):
+            fill_diagonal(a, 2)
+
+
+def test_diag_indices():
+    di = diag_indices(4)
+    a = np.array([[1, 2, 3, 4],
+                  [5, 6, 7, 8],
+                  [9, 10, 11, 12],
+                  [13, 14, 15, 16]])
+    a[di] = 100
+    assert_array_equal(
+        a, np.array([[100, 2, 3, 4],
+                     [5, 100, 7, 8],
+                     [9, 10, 100, 12],
+                     [13, 14, 15, 100]])
+        )
+
+    # Now, we create indices to manipulate a 3-d array:
+    d3 = diag_indices(2, 3)
+
+    # And use it to set the diagonal of a zeros array to 1:
+    a = np.zeros((2, 2, 2), int)
+    a[d3] = 1
+    assert_array_equal(
+        a, np.array([[[1, 0],
+                      [0, 0]],
+                     [[0, 0],
+                      [0, 1]]])
+        )
+
+
+class TestDiagIndicesFrom:
+
+    def test_diag_indices_from(self):
+        x = np.random.random((4, 4))
+        r, c = diag_indices_from(x)
+        assert_array_equal(r, np.arange(4))
+        assert_array_equal(c, np.arange(4))
+
+    def test_error_small_input(self):
+        x = np.ones(7)
+        with assert_raises_regex(ValueError, "at least 2-d"):
+            diag_indices_from(x)
+
+    def test_error_shape_mismatch(self):
+        x = np.zeros((3, 3, 2, 3), int)
+        with assert_raises_regex(ValueError, "equal length"):
+            diag_indices_from(x)
+
+
+def test_ndindex():
+    x = list(ndindex(1, 2, 3))
+    expected = [ix for ix, e in ndenumerate(np.zeros((1, 2, 3)))]
+    assert_array_equal(x, expected)
+
+    x = list(ndindex((1, 2, 3)))
+    assert_array_equal(x, expected)
+
+    # Test use of scalars and tuples
+    x = list(ndindex((3,)))
+    assert_array_equal(x, list(ndindex(3)))
+
+    # Make sure size argument is optional
+    x = list(ndindex())
+    assert_equal(x, [()])
+
+    x = list(ndindex(()))
+    assert_equal(x, [()])
+
+    # Make sure 0-sized ndindex works correctly
+    x = list(ndindex(*[0]))
+    assert_equal(x, [])
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/tests/test_io.py b/venv/lib/python3.12/site-packages/numpy/lib/tests/test_io.py
new file mode 100644
index 00000000..38ded1f2
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/lib/tests/test_io.py
@@ -0,0 +1,2801 @@
+import sys
+import gc
+import gzip
+import os
+import threading
+import time
+import warnings
+import re
+import pytest
+from pathlib import Path
+from tempfile import NamedTemporaryFile
+from io import BytesIO, StringIO
+from datetime import datetime
+import locale
+from multiprocessing import Value, get_context
+from ctypes import c_bool
+
+import numpy as np
+import numpy.ma as ma
+from numpy.exceptions import VisibleDeprecationWarning
+from numpy.lib._iotools import ConverterError, ConversionWarning
+from numpy.lib import _npyio_impl
+from numpy.lib._npyio_impl import recfromcsv, recfromtxt
+from numpy.ma.testutils import assert_equal
+from numpy.testing import (
+    assert_warns, assert_, assert_raises_regex, assert_raises,
+    assert_allclose, assert_array_equal, temppath, tempdir, IS_PYPY,
+    HAS_REFCOUNT, suppress_warnings, assert_no_gc_cycles, assert_no_warnings,
+    break_cycles, IS_WASM
+    )
+from numpy.testing._private.utils import requires_memory
+from numpy._utils import asbytes
+
+
+class TextIO(BytesIO):
+    """Helper IO class.
+
+    Writes encode strings to bytes if needed, reads return bytes.
+    This makes it easier to emulate files opened in binary mode
+    without needing to explicitly convert strings to bytes in
+    setting up the test data.
+
+    """
+    def __init__(self, s=""):
+        BytesIO.__init__(self, asbytes(s))
+
+    def write(self, s):
+        BytesIO.write(self, asbytes(s))
+
+    def writelines(self, lines):
+        BytesIO.writelines(self, [asbytes(s) for s in lines])
+
+
+IS_64BIT = sys.maxsize > 2**32
+try:
+    import bz2
+    HAS_BZ2 = True
+except ImportError:
+    HAS_BZ2 = False
+try:
+    import lzma
+    HAS_LZMA = True
+except ImportError:
+    HAS_LZMA = False
+
+
+def strptime(s, fmt=None):
+    """
+    This function is available in the datetime module only from Python >=
+    2.5.
+
+    """
+    if type(s) == bytes:
+        s = s.decode("latin1")
+    return datetime(*time.strptime(s, fmt)[:3])
+
+
+class RoundtripTest:
+    def roundtrip(self, save_func, *args, **kwargs):
+        """
+        save_func : callable
+            Function used to save arrays to file.
+        file_on_disk : bool
+            If true, store the file on disk, instead of in a
+            string buffer.
+        save_kwds : dict
+            Parameters passed to `save_func`.
+        load_kwds : dict
+            Parameters passed to `numpy.load`.
+        args : tuple of arrays
+            Arrays stored to file.
+
+        """
+        save_kwds = kwargs.get('save_kwds', {})
+        load_kwds = kwargs.get('load_kwds', {"allow_pickle": True})
+        file_on_disk = kwargs.get('file_on_disk', False)
+
+        if file_on_disk:
+            target_file = NamedTemporaryFile(delete=False)
+            load_file = target_file.name
+        else:
+            target_file = BytesIO()
+            load_file = target_file
+
+        try:
+            arr = args
+
+            save_func(target_file, *arr, **save_kwds)
+            target_file.flush()
+            target_file.seek(0)
+
+            if sys.platform == 'win32' and not isinstance(target_file, BytesIO):
+                target_file.close()
+
+            arr_reloaded = np.load(load_file, **load_kwds)
+
+            self.arr = arr
+            self.arr_reloaded = arr_reloaded
+        finally:
+            if not isinstance(target_file, BytesIO):
+                target_file.close()
+                # holds an open file descriptor so it can't be deleted on win
+                if 'arr_reloaded' in locals():
+                    if not isinstance(arr_reloaded, np.lib.npyio.NpzFile):
+                        os.remove(target_file.name)
+
+    def check_roundtrips(self, a):
+        self.roundtrip(a)
+        self.roundtrip(a, file_on_disk=True)
+        self.roundtrip(np.asfortranarray(a))
+        self.roundtrip(np.asfortranarray(a), file_on_disk=True)
+        if a.shape[0] > 1:
+            # neither C nor Fortran contiguous for 2D arrays or more
+            self.roundtrip(np.asfortranarray(a)[1:])
+            self.roundtrip(np.asfortranarray(a)[1:], file_on_disk=True)
+
+    def test_array(self):
+        a = np.array([], float)
+        self.check_roundtrips(a)
+
+        a = np.array([[1, 2], [3, 4]], float)
+        self.check_roundtrips(a)
+
+        a = np.array([[1, 2], [3, 4]], int)
+        self.check_roundtrips(a)
+
+        a = np.array([[1 + 5j, 2 + 6j], [3 + 7j, 4 + 8j]], dtype=np.csingle)
+        self.check_roundtrips(a)
+
+        a = np.array([[1 + 5j, 2 + 6j], [3 + 7j, 4 + 8j]], dtype=np.cdouble)
+        self.check_roundtrips(a)
+
+    def test_array_object(self):
+        a = np.array([], object)
+        self.check_roundtrips(a)
+
+        a = np.array([[1, 2], [3, 4]], object)
+        self.check_roundtrips(a)
+
+    def test_1D(self):
+        a = np.array([1, 2, 3, 4], int)
+        self.roundtrip(a)
+
+    @pytest.mark.skipif(sys.platform == 'win32', reason="Fails on Win32")
+    def test_mmap(self):
+        a = np.array([[1, 2.5], [4, 7.3]])
+        self.roundtrip(a, file_on_disk=True, load_kwds={'mmap_mode': 'r'})
+
+        a = np.asfortranarray([[1, 2.5], [4, 7.3]])
+        self.roundtrip(a, file_on_disk=True, load_kwds={'mmap_mode': 'r'})
+
+    def test_record(self):
+        a = np.array([(1, 2), (3, 4)], dtype=[('x', 'i4'), ('y', 'i4')])
+        self.check_roundtrips(a)
+
+    @pytest.mark.slow
+    def test_format_2_0(self):
+        dt = [(("%d" % i) * 100, float) for i in range(500)]
+        a = np.ones(1000, dtype=dt)
+        with warnings.catch_warnings(record=True):
+            warnings.filterwarnings('always', '', UserWarning)
+            self.check_roundtrips(a)
+
+
+class TestSaveLoad(RoundtripTest):
+    def roundtrip(self, *args, **kwargs):
+        RoundtripTest.roundtrip(self, np.save, *args, **kwargs)
+        assert_equal(self.arr[0], self.arr_reloaded)
+        assert_equal(self.arr[0].dtype, self.arr_reloaded.dtype)
+        assert_equal(self.arr[0].flags.fnc, self.arr_reloaded.flags.fnc)
+
+
+class TestSavezLoad(RoundtripTest):
+    def roundtrip(self, *args, **kwargs):
+        RoundtripTest.roundtrip(self, np.savez, *args, **kwargs)
+        try:
+            for n, arr in enumerate(self.arr):
+                reloaded = self.arr_reloaded['arr_%d' % n]
+                assert_equal(arr, reloaded)
+                assert_equal(arr.dtype, reloaded.dtype)
+                assert_equal(arr.flags.fnc, reloaded.flags.fnc)
+        finally:
+            # delete tempfile, must be done here on windows
+            if self.arr_reloaded.fid:
+                self.arr_reloaded.fid.close()
+                os.remove(self.arr_reloaded.fid.name)
+
+    @pytest.mark.skipif(IS_PYPY, reason="Hangs on PyPy")
+    @pytest.mark.skipif(not IS_64BIT, reason="Needs 64bit platform")
+    @pytest.mark.slow
+    def test_big_arrays(self):
+        L = (1 << 31) + 100000
+        a = np.empty(L, dtype=np.uint8)
+        with temppath(prefix="numpy_test_big_arrays_", suffix=".npz") as tmp:
+            np.savez(tmp, a=a)
+            del a
+            npfile = np.load(tmp)
+            a = npfile['a']  # Should succeed
+            npfile.close()
+            del a  # Avoid pyflakes unused variable warning.
+
+    def test_multiple_arrays(self):
+        a = np.array([[1, 2], [3, 4]], float)
+        b = np.array([[1 + 2j, 2 + 7j], [3 - 6j, 4 + 12j]], complex)
+        self.roundtrip(a, b)
+
+    def test_named_arrays(self):
+        a = np.array([[1, 2], [3, 4]], float)
+        b = np.array([[1 + 2j, 2 + 7j], [3 - 6j, 4 + 12j]], complex)
+        c = BytesIO()
+        np.savez(c, file_a=a, file_b=b)
+        c.seek(0)
+        l = np.load(c)
+        assert_equal(a, l['file_a'])
+        assert_equal(b, l['file_b'])
+
+
+    def test_tuple_getitem_raises(self):
+        # gh-23748
+        a = np.array([1, 2, 3])
+        f = BytesIO()
+        np.savez(f, a=a)
+        f.seek(0)
+        l = np.load(f)
+        with pytest.raises(KeyError, match="(1, 2)"):
+            l[1, 2]
+
+    def test_BagObj(self):
+        a = np.array([[1, 2], [3, 4]], float)
+        b = np.array([[1 + 2j, 2 + 7j], [3 - 6j, 4 + 12j]], complex)
+        c = BytesIO()
+        np.savez(c, file_a=a, file_b=b)
+        c.seek(0)
+        l = np.load(c)
+        assert_equal(sorted(dir(l.f)), ['file_a','file_b'])
+        assert_equal(a, l.f.file_a)
+        assert_equal(b, l.f.file_b)
+
+    @pytest.mark.skipif(IS_WASM, reason="Cannot start thread")
+    def test_savez_filename_clashes(self):
+        # Test that issue #852 is fixed
+        # and savez functions in multithreaded environment
+
+        def writer(error_list):
+            with temppath(suffix='.npz') as tmp:
+                arr = np.random.randn(500, 500)
+                try:
+                    np.savez(tmp, arr=arr)
+                except OSError as err:
+                    error_list.append(err)
+
+        errors = []
+        threads = [threading.Thread(target=writer, args=(errors,))
+                   for j in range(3)]
+        for t in threads:
+            t.start()
+        for t in threads:
+            t.join()
+
+        if errors:
+            raise AssertionError(errors)
+
+    def test_not_closing_opened_fid(self):
+        # Test that issue #2178 is fixed:
+        # verify could seek on 'loaded' file
+        with temppath(suffix='.npz') as tmp:
+            with open(tmp, 'wb') as fp:
+                np.savez(fp, data='LOVELY LOAD')
+            with open(tmp, 'rb', 10000) as fp:
+                fp.seek(0)
+                assert_(not fp.closed)
+                np.load(fp)['data']
+                # fp must not get closed by .load
+                assert_(not fp.closed)
+                fp.seek(0)
+                assert_(not fp.closed)
+
+    @pytest.mark.slow_pypy
+    def test_closing_fid(self):
+        # Test that issue #1517 (too many opened files) remains closed
+        # It might be a "weak" test since failed to get triggered on
+        # e.g. Debian sid of 2012 Jul 05 but was reported to
+        # trigger the failure on Ubuntu 10.04:
+        # http://projects.scipy.org/numpy/ticket/1517#comment:2
+        with temppath(suffix='.npz') as tmp:
+            np.savez(tmp, data='LOVELY LOAD')
+            # We need to check if the garbage collector can properly close
+            # numpy npz file returned by np.load when their reference count
+            # goes to zero.  Python 3 running in debug mode raises a
+            # ResourceWarning when file closing is left to the garbage
+            # collector, so we catch the warnings.
+            with suppress_warnings() as sup:
+                sup.filter(ResourceWarning)  # TODO: specify exact message
+                for i in range(1, 1025):
+                    try:
+                        np.load(tmp)["data"]
+                    except Exception as e:
+                        msg = "Failed to load data from a file: %s" % e
+                        raise AssertionError(msg)
+                    finally:
+                        if IS_PYPY:
+                            gc.collect()
+
+    def test_closing_zipfile_after_load(self):
+        # Check that zipfile owns file and can close it.  This needs to
+        # pass a file name to load for the test. On windows failure will
+        # cause a second error will be raised when the attempt to remove
+        # the open file is made.
+        prefix = 'numpy_test_closing_zipfile_after_load_'
+        with temppath(suffix='.npz', prefix=prefix) as tmp:
+            np.savez(tmp, lab='place holder')
+            data = np.load(tmp)
+            fp = data.zip.fp
+            data.close()
+            assert_(fp.closed)
+
+    @pytest.mark.parametrize("count, expected_repr", [
+        (1, "NpzFile {fname!r} with keys: arr_0"),
+        (5, "NpzFile {fname!r} with keys: arr_0, arr_1, arr_2, arr_3, arr_4"),
+        # _MAX_REPR_ARRAY_COUNT is 5, so files with more than 5 keys are
+        # expected to end in '...'
+        (6, "NpzFile {fname!r} with keys: arr_0, arr_1, arr_2, arr_3, arr_4..."),
+    ])
+    def test_repr_lists_keys(self, count, expected_repr):
+        a = np.array([[1, 2], [3, 4]], float)
+        with temppath(suffix='.npz') as tmp:
+            np.savez(tmp, *[a]*count)
+            l = np.load(tmp)
+            assert repr(l) == expected_repr.format(fname=tmp)
+            l.close()
+
+
+class TestSaveTxt:
+    def test_array(self):
+        a = np.array([[1, 2], [3, 4]], float)
+        fmt = "%.18e"
+        c = BytesIO()
+        np.savetxt(c, a, fmt=fmt)
+        c.seek(0)
+        assert_equal(c.readlines(),
+                     [asbytes((fmt + ' ' + fmt + '\n') % (1, 2)),
+                      asbytes((fmt + ' ' + fmt + '\n') % (3, 4))])
+
+        a = np.array([[1, 2], [3, 4]], int)
+        c = BytesIO()
+        np.savetxt(c, a, fmt='%d')
+        c.seek(0)
+        assert_equal(c.readlines(), [b'1 2\n', b'3 4\n'])
+
+    def test_1D(self):
+        a = np.array([1, 2, 3, 4], int)
+        c = BytesIO()
+        np.savetxt(c, a, fmt='%d')
+        c.seek(0)
+        lines = c.readlines()
+        assert_equal(lines, [b'1\n', b'2\n', b'3\n', b'4\n'])
+
+    def test_0D_3D(self):
+        c = BytesIO()
+        assert_raises(ValueError, np.savetxt, c, np.array(1))
+        assert_raises(ValueError, np.savetxt, c, np.array([[[1], [2]]]))
+
+    def test_structured(self):
+        a = np.array([(1, 2), (3, 4)], dtype=[('x', 'i4'), ('y', 'i4')])
+        c = BytesIO()
+        np.savetxt(c, a, fmt='%d')
+        c.seek(0)
+        assert_equal(c.readlines(), [b'1 2\n', b'3 4\n'])
+
+    def test_structured_padded(self):
+        # gh-13297
+        a = np.array([(1, 2, 3),(4, 5, 6)], dtype=[
+            ('foo', 'i4'), ('bar', 'i4'), ('baz', 'i4')
+        ])
+        c = BytesIO()
+        np.savetxt(c, a[['foo', 'baz']], fmt='%d')
+        c.seek(0)
+        assert_equal(c.readlines(), [b'1 3\n', b'4 6\n'])
+
+    def test_multifield_view(self):
+        a = np.ones(1, dtype=[('x', 'i4'), ('y', 'i4'), ('z', 'f4')])
+        v = a[['x', 'z']]
+        with temppath(suffix='.npy') as path:
+            path = Path(path)
+            np.save(path, v)
+            data = np.load(path)
+            assert_array_equal(data, v)
+
+    def test_delimiter(self):
+        a = np.array([[1., 2.], [3., 4.]])
+        c = BytesIO()
+        np.savetxt(c, a, delimiter=',', fmt='%d')
+        c.seek(0)
+        assert_equal(c.readlines(), [b'1,2\n', b'3,4\n'])
+
+    def test_format(self):
+        a = np.array([(1, 2), (3, 4)])
+        c = BytesIO()
+        # Sequence of formats
+        np.savetxt(c, a, fmt=['%02d', '%3.1f'])
+        c.seek(0)
+        assert_equal(c.readlines(), [b'01 2.0\n', b'03 4.0\n'])
+
+        # A single multiformat string
+        c = BytesIO()
+        np.savetxt(c, a, fmt='%02d : %3.1f')
+        c.seek(0)
+        lines = c.readlines()
+        assert_equal(lines, [b'01 : 2.0\n', b'03 : 4.0\n'])
+
+        # Specify delimiter, should be overridden
+        c = BytesIO()
+        np.savetxt(c, a, fmt='%02d : %3.1f', delimiter=',')
+        c.seek(0)
+        lines = c.readlines()
+        assert_equal(lines, [b'01 : 2.0\n', b'03 : 4.0\n'])
+
+        # Bad fmt, should raise a ValueError
+        c = BytesIO()
+        assert_raises(ValueError, np.savetxt, c, a, fmt=99)
+
+    def test_header_footer(self):
+        # Test the functionality of the header and footer keyword argument.
+
+        c = BytesIO()
+        a = np.array([(1, 2), (3, 4)], dtype=int)
+        test_header_footer = 'Test header / footer'
+        # Test the header keyword argument
+        np.savetxt(c, a, fmt='%1d', header=test_header_footer)
+        c.seek(0)
+        assert_equal(c.read(),
+                     asbytes('# ' + test_header_footer + '\n1 2\n3 4\n'))
+        # Test the footer keyword argument
+        c = BytesIO()
+        np.savetxt(c, a, fmt='%1d', footer=test_header_footer)
+        c.seek(0)
+        assert_equal(c.read(),
+                     asbytes('1 2\n3 4\n# ' + test_header_footer + '\n'))
+        # Test the commentstr keyword argument used on the header
+        c = BytesIO()
+        commentstr = '% '
+        np.savetxt(c, a, fmt='%1d',
+                   header=test_header_footer, comments=commentstr)
+        c.seek(0)
+        assert_equal(c.read(),
+                     asbytes(commentstr + test_header_footer + '\n' + '1 2\n3 4\n'))
+        # Test the commentstr keyword argument used on the footer
+        c = BytesIO()
+        commentstr = '% '
+        np.savetxt(c, a, fmt='%1d',
+                   footer=test_header_footer, comments=commentstr)
+        c.seek(0)
+        assert_equal(c.read(),
+                     asbytes('1 2\n3 4\n' + commentstr + test_header_footer + '\n'))
+
+    @pytest.mark.parametrize("filename_type", [Path, str])
+    def test_file_roundtrip(self, filename_type):
+        with temppath() as name:
+            a = np.array([(1, 2), (3, 4)])
+            np.savetxt(filename_type(name), a)
+            b = np.loadtxt(filename_type(name))
+            assert_array_equal(a, b)
+
+    def test_complex_arrays(self):
+        ncols = 2
+        nrows = 2
+        a = np.zeros((ncols, nrows), dtype=np.complex128)
+        re = np.pi
+        im = np.e
+        a[:] = re + 1.0j * im
+
+        # One format only
+        c = BytesIO()
+        np.savetxt(c, a, fmt=' %+.3e')
+        c.seek(0)
+        lines = c.readlines()
+        assert_equal(
+            lines,
+            [b' ( +3.142e+00+ +2.718e+00j)  ( +3.142e+00+ +2.718e+00j)\n',
+             b' ( +3.142e+00+ +2.718e+00j)  ( +3.142e+00+ +2.718e+00j)\n'])
+
+        # One format for each real and imaginary part
+        c = BytesIO()
+        np.savetxt(c, a, fmt='  %+.3e' * 2 * ncols)
+        c.seek(0)
+        lines = c.readlines()
+        assert_equal(
+            lines,
+            [b'  +3.142e+00  +2.718e+00  +3.142e+00  +2.718e+00\n',
+             b'  +3.142e+00  +2.718e+00  +3.142e+00  +2.718e+00\n'])
+
+        # One format for each complex number
+        c = BytesIO()
+        np.savetxt(c, a, fmt=['(%.3e%+.3ej)'] * ncols)
+        c.seek(0)
+        lines = c.readlines()
+        assert_equal(
+            lines,
+            [b'(3.142e+00+2.718e+00j) (3.142e+00+2.718e+00j)\n',
+             b'(3.142e+00+2.718e+00j) (3.142e+00+2.718e+00j)\n'])
+
+    def test_complex_negative_exponent(self):
+        # Previous to 1.15, some formats generated x+-yj, gh 7895
+        ncols = 2
+        nrows = 2
+        a = np.zeros((ncols, nrows), dtype=np.complex128)
+        re = np.pi
+        im = np.e
+        a[:] = re - 1.0j * im
+        c = BytesIO()
+        np.savetxt(c, a, fmt='%.3e')
+        c.seek(0)
+        lines = c.readlines()
+        assert_equal(
+            lines,
+            [b' (3.142e+00-2.718e+00j)  (3.142e+00-2.718e+00j)\n',
+             b' (3.142e+00-2.718e+00j)  (3.142e+00-2.718e+00j)\n'])
+
+
+    def test_custom_writer(self):
+
+        class CustomWriter(list):
+            def write(self, text):
+                self.extend(text.split(b'\n'))
+
+        w = CustomWriter()
+        a = np.array([(1, 2), (3, 4)])
+        np.savetxt(w, a)
+        b = np.loadtxt(w)
+        assert_array_equal(a, b)
+
+    def test_unicode(self):
+        utf8 = b'\xcf\x96'.decode('UTF-8')
+        a = np.array([utf8], dtype=np.str_)
+        with tempdir() as tmpdir:
+            # set encoding as on windows it may not be unicode even on py3
+            np.savetxt(os.path.join(tmpdir, 'test.csv'), a, fmt=['%s'],
+                       encoding='UTF-8')
+
+    def test_unicode_roundtrip(self):
+        utf8 = b'\xcf\x96'.decode('UTF-8')
+        a = np.array([utf8], dtype=np.str_)
+        # our gz wrapper support encoding
+        suffixes = ['', '.gz']
+        if HAS_BZ2:
+            suffixes.append('.bz2')
+        if HAS_LZMA:
+            suffixes.extend(['.xz', '.lzma'])
+        with tempdir() as tmpdir:
+            for suffix in suffixes:
+                np.savetxt(os.path.join(tmpdir, 'test.csv' + suffix), a,
+                           fmt=['%s'], encoding='UTF-16-LE')
+                b = np.loadtxt(os.path.join(tmpdir, 'test.csv' + suffix),
+                               encoding='UTF-16-LE', dtype=np.str_)
+                assert_array_equal(a, b)
+
+    def test_unicode_bytestream(self):
+        utf8 = b'\xcf\x96'.decode('UTF-8')
+        a = np.array([utf8], dtype=np.str_)
+        s = BytesIO()
+        np.savetxt(s, a, fmt=['%s'], encoding='UTF-8')
+        s.seek(0)
+        assert_equal(s.read().decode('UTF-8'), utf8 + '\n')
+
+    def test_unicode_stringstream(self):
+        utf8 = b'\xcf\x96'.decode('UTF-8')
+        a = np.array([utf8], dtype=np.str_)
+        s = StringIO()
+        np.savetxt(s, a, fmt=['%s'], encoding='UTF-8')
+        s.seek(0)
+        assert_equal(s.read(), utf8 + '\n')
+
+    @pytest.mark.parametrize("iotype", [StringIO, BytesIO])
+    def test_unicode_and_bytes_fmt(self, iotype):
+        # string type of fmt should not matter, see also gh-4053
+        a = np.array([1.])
+        s = iotype()
+        np.savetxt(s, a, fmt="%f")
+        s.seek(0)
+        if iotype is StringIO:
+            assert_equal(s.read(), "%f\n" % 1.)
+        else:
+            assert_equal(s.read(), b"%f\n" % 1.)
+
+    @pytest.mark.skipif(sys.platform=='win32', reason="files>4GB may not work")
+    @pytest.mark.slow
+    @requires_memory(free_bytes=7e9)
+    def test_large_zip(self):
+        def check_large_zip(memoryerror_raised):
+            memoryerror_raised.value = False
+            try:
+                # The test takes at least 6GB of memory, writes a file larger
+                # than 4GB. This tests the ``allowZip64`` kwarg to ``zipfile``
+                test_data = np.asarray([np.random.rand(
+                                        np.random.randint(50,100),4)
+                                        for i in range(800000)], dtype=object)
+                with tempdir() as tmpdir:
+                    np.savez(os.path.join(tmpdir, 'test.npz'),
+                             test_data=test_data)
+            except MemoryError:
+                memoryerror_raised.value = True
+                raise
+        # run in a subprocess to ensure memory is released on PyPy, see gh-15775
+        # Use an object in shared memory to re-raise the MemoryError exception
+        # in our process if needed, see gh-16889
+        memoryerror_raised = Value(c_bool)
+
+        # Since Python 3.8, the default start method for multiprocessing has
+        # been changed from 'fork' to 'spawn' on macOS, causing inconsistency
+        # on memory sharing model, lead to failed test for check_large_zip
+        ctx = get_context('fork')
+        p = ctx.Process(target=check_large_zip, args=(memoryerror_raised,))
+        p.start()
+        p.join()
+        if memoryerror_raised.value:
+            raise MemoryError("Child process raised a MemoryError exception")
+        # -9 indicates a SIGKILL, probably an OOM.
+        if p.exitcode == -9:
+            pytest.xfail("subprocess got a SIGKILL, apparently free memory was not sufficient")
+        assert p.exitcode == 0
+
+class LoadTxtBase:
+    def check_compressed(self, fopen, suffixes):
+        # Test that we can load data from a compressed file
+        wanted = np.arange(6).reshape((2, 3))
+        linesep = ('\n', '\r\n', '\r')
+        for sep in linesep:
+            data = '0 1 2' + sep + '3 4 5'
+            for suffix in suffixes:
+                with temppath(suffix=suffix) as name:
+                    with fopen(name, mode='wt', encoding='UTF-32-LE') as f:
+                        f.write(data)
+                    res = self.loadfunc(name, encoding='UTF-32-LE')
+                    assert_array_equal(res, wanted)
+                    with fopen(name, "rt",  encoding='UTF-32-LE') as f:
+                        res = self.loadfunc(f)
+                    assert_array_equal(res, wanted)
+
+    def test_compressed_gzip(self):
+        self.check_compressed(gzip.open, ('.gz',))
+
+    @pytest.mark.skipif(not HAS_BZ2, reason="Needs bz2")
+    def test_compressed_bz2(self):
+        self.check_compressed(bz2.open, ('.bz2',))
+
+    @pytest.mark.skipif(not HAS_LZMA, reason="Needs lzma")
+    def test_compressed_lzma(self):
+        self.check_compressed(lzma.open, ('.xz', '.lzma'))
+
+    def test_encoding(self):
+        with temppath() as path:
+            with open(path, "wb") as f:
+                f.write('0.\n1.\n2.'.encode("UTF-16"))
+            x = self.loadfunc(path, encoding="UTF-16")
+            assert_array_equal(x, [0., 1., 2.])
+
+    def test_stringload(self):
+        # umlaute
+        nonascii = b'\xc3\xb6\xc3\xbc\xc3\xb6'.decode("UTF-8")
+        with temppath() as path:
+            with open(path, "wb") as f:
+                f.write(nonascii.encode("UTF-16"))
+            x = self.loadfunc(path, encoding="UTF-16", dtype=np.str_)
+            assert_array_equal(x, nonascii)
+
+    def test_binary_decode(self):
+        utf16 = b'\xff\xfeh\x04 \x00i\x04 \x00j\x04'
+        v = self.loadfunc(BytesIO(utf16), dtype=np.str_, encoding='UTF-16')
+        assert_array_equal(v, np.array(utf16.decode('UTF-16').split()))
+
+    def test_converters_decode(self):
+        # test converters that decode strings
+        c = TextIO()
+        c.write(b'\xcf\x96')
+        c.seek(0)
+        x = self.loadfunc(c, dtype=np.str_, encoding="bytes",
+                          converters={0: lambda x: x.decode('UTF-8')})
+        a = np.array([b'\xcf\x96'.decode('UTF-8')])
+        assert_array_equal(x, a)
+
+    def test_converters_nodecode(self):
+        # test native string converters enabled by setting an encoding
+        utf8 = b'\xcf\x96'.decode('UTF-8')
+        with temppath() as path:
+            with open(path, 'wt', encoding='UTF-8') as f:
+                f.write(utf8)
+            x = self.loadfunc(path, dtype=np.str_,
+                              converters={0: lambda x: x + 't'},
+                              encoding='UTF-8')
+            a = np.array([utf8 + 't'])
+            assert_array_equal(x, a)
+
+
+class TestLoadTxt(LoadTxtBase):
+    loadfunc = staticmethod(np.loadtxt)
+
+    def setup_method(self):
+        # lower chunksize for testing
+        self.orig_chunk = _npyio_impl._loadtxt_chunksize
+        _npyio_impl._loadtxt_chunksize = 1
+
+    def teardown_method(self):
+        _npyio_impl._loadtxt_chunksize = self.orig_chunk
+
+    def test_record(self):
+        c = TextIO()
+        c.write('1 2\n3 4')
+        c.seek(0)
+        x = np.loadtxt(c, dtype=[('x', np.int32), ('y', np.int32)])
+        a = np.array([(1, 2), (3, 4)], dtype=[('x', 'i4'), ('y', 'i4')])
+        assert_array_equal(x, a)
+
+        d = TextIO()
+        d.write('M 64 75.0\nF 25 60.0')
+        d.seek(0)
+        mydescriptor = {'names': ('gender', 'age', 'weight'),
+                        'formats': ('S1', 'i4', 'f4')}
+        b = np.array([('M', 64.0, 75.0),
+                      ('F', 25.0, 60.0)], dtype=mydescriptor)
+        y = np.loadtxt(d, dtype=mydescriptor)
+        assert_array_equal(y, b)
+
+    def test_array(self):
+        c = TextIO()
+        c.write('1 2\n3 4')
+
+        c.seek(0)
+        x = np.loadtxt(c, dtype=int)
+        a = np.array([[1, 2], [3, 4]], int)
+        assert_array_equal(x, a)
+
+        c.seek(0)
+        x = np.loadtxt(c, dtype=float)
+        a = np.array([[1, 2], [3, 4]], float)
+        assert_array_equal(x, a)
+
+    def test_1D(self):
+        c = TextIO()
+        c.write('1\n2\n3\n4\n')
+        c.seek(0)
+        x = np.loadtxt(c, dtype=int)
+        a = np.array([1, 2, 3, 4], int)
+        assert_array_equal(x, a)
+
+        c = TextIO()
+        c.write('1,2,3,4\n')
+        c.seek(0)
+        x = np.loadtxt(c, dtype=int, delimiter=',')
+        a = np.array([1, 2, 3, 4], int)
+        assert_array_equal(x, a)
+
+    def test_missing(self):
+        c = TextIO()
+        c.write('1,2,3,,5\n')
+        c.seek(0)
+        x = np.loadtxt(c, dtype=int, delimiter=',',
+                       converters={3: lambda s: int(s or - 999)})
+        a = np.array([1, 2, 3, -999, 5], int)
+        assert_array_equal(x, a)
+
+    def test_converters_with_usecols(self):
+        c = TextIO()
+        c.write('1,2,3,,5\n6,7,8,9,10\n')
+        c.seek(0)
+        x = np.loadtxt(c, dtype=int, delimiter=',',
+                       converters={3: lambda s: int(s or - 999)},
+                       usecols=(1, 3,))
+        a = np.array([[2, -999], [7, 9]], int)
+        assert_array_equal(x, a)
+
+    def test_comments_unicode(self):
+        c = TextIO()
+        c.write('# comment\n1,2,3,5\n')
+        c.seek(0)
+        x = np.loadtxt(c, dtype=int, delimiter=',',
+                       comments='#')
+        a = np.array([1, 2, 3, 5], int)
+        assert_array_equal(x, a)
+
+    def test_comments_byte(self):
+        c = TextIO()
+        c.write('# comment\n1,2,3,5\n')
+        c.seek(0)
+        x = np.loadtxt(c, dtype=int, delimiter=',',
+                       comments=b'#')
+        a = np.array([1, 2, 3, 5], int)
+        assert_array_equal(x, a)
+
+    def test_comments_multiple(self):
+        c = TextIO()
+        c.write('# comment\n1,2,3\n@ comment2\n4,5,6 // comment3')
+        c.seek(0)
+        x = np.loadtxt(c, dtype=int, delimiter=',',
+                       comments=['#', '@', '//'])
+        a = np.array([[1, 2, 3], [4, 5, 6]], int)
+        assert_array_equal(x, a)
+
+    @pytest.mark.skipif(IS_PYPY and sys.implementation.version <= (7, 3, 8),
+                        reason="PyPy bug in error formatting")
+    def test_comments_multi_chars(self):
+        c = TextIO()
+        c.write('/* comment\n1,2,3,5\n')
+        c.seek(0)
+        x = np.loadtxt(c, dtype=int, delimiter=',',
+                       comments='/*')
+        a = np.array([1, 2, 3, 5], int)
+        assert_array_equal(x, a)
+
+        # Check that '/*' is not transformed to ['/', '*']
+        c = TextIO()
+        c.write('*/ comment\n1,2,3,5\n')
+        c.seek(0)
+        assert_raises(ValueError, np.loadtxt, c, dtype=int, delimiter=',',
+                      comments='/*')
+
+    def test_skiprows(self):
+        c = TextIO()
+        c.write('comment\n1,2,3,5\n')
+        c.seek(0)
+        x = np.loadtxt(c, dtype=int, delimiter=',',
+                       skiprows=1)
+        a = np.array([1, 2, 3, 5], int)
+        assert_array_equal(x, a)
+
+        c = TextIO()
+        c.write('# comment\n1,2,3,5\n')
+        c.seek(0)
+        x = np.loadtxt(c, dtype=int, delimiter=',',
+                       skiprows=1)
+        a = np.array([1, 2, 3, 5], int)
+        assert_array_equal(x, a)
+
+    def test_usecols(self):
+        a = np.array([[1, 2], [3, 4]], float)
+        c = BytesIO()
+        np.savetxt(c, a)
+        c.seek(0)
+        x = np.loadtxt(c, dtype=float, usecols=(1,))
+        assert_array_equal(x, a[:, 1])
+
+        a = np.array([[1, 2, 3], [3, 4, 5]], float)
+        c = BytesIO()
+        np.savetxt(c, a)
+        c.seek(0)
+        x = np.loadtxt(c, dtype=float, usecols=(1, 2))
+        assert_array_equal(x, a[:, 1:])
+
+        # Testing with arrays instead of tuples.
+        c.seek(0)
+        x = np.loadtxt(c, dtype=float, usecols=np.array([1, 2]))
+        assert_array_equal(x, a[:, 1:])
+
+        # Testing with an integer instead of a sequence
+        for int_type in [int, np.int8, np.int16,
+                         np.int32, np.int64, np.uint8, np.uint16,
+                         np.uint32, np.uint64]:
+            to_read = int_type(1)
+            c.seek(0)
+            x = np.loadtxt(c, dtype=float, usecols=to_read)
+            assert_array_equal(x, a[:, 1])
+
+        # Testing with some crazy custom integer type
+        class CrazyInt:
+            def __index__(self):
+                return 1
+
+        crazy_int = CrazyInt()
+        c.seek(0)
+        x = np.loadtxt(c, dtype=float, usecols=crazy_int)
+        assert_array_equal(x, a[:, 1])
+
+        c.seek(0)
+        x = np.loadtxt(c, dtype=float, usecols=(crazy_int,))
+        assert_array_equal(x, a[:, 1])
+
+        # Checking with dtypes defined converters.
+        data = '''JOE 70.1 25.3
+                BOB 60.5 27.9
+                '''
+        c = TextIO(data)
+        names = ['stid', 'temp']
+        dtypes = ['S4', 'f8']
+        arr = np.loadtxt(c, usecols=(0, 2), dtype=list(zip(names, dtypes)))
+        assert_equal(arr['stid'], [b"JOE", b"BOB"])
+        assert_equal(arr['temp'], [25.3, 27.9])
+
+        # Testing non-ints in usecols
+        c.seek(0)
+        bogus_idx = 1.5
+        assert_raises_regex(
+            TypeError,
+            '^usecols must be.*%s' % type(bogus_idx).__name__,
+            np.loadtxt, c, usecols=bogus_idx
+            )
+
+        assert_raises_regex(
+            TypeError,
+            '^usecols must be.*%s' % type(bogus_idx).__name__,
+            np.loadtxt, c, usecols=[0, bogus_idx, 0]
+            )
+
+    def test_bad_usecols(self):
+        with pytest.raises(OverflowError):
+            np.loadtxt(["1\n"], usecols=[2**64], delimiter=",")
+        with pytest.raises((ValueError, OverflowError)):
+            # Overflow error on 32bit platforms
+            np.loadtxt(["1\n"], usecols=[2**62], delimiter=",")
+        with pytest.raises(TypeError,
+                match="If a structured dtype .*. But 1 usecols were given and "
+                      "the number of fields is 3."):
+            np.loadtxt(["1,1\n"], dtype="i,2i", usecols=[0], delimiter=",")
+
+    def test_fancy_dtype(self):
+        c = TextIO()
+        c.write('1,2,3.0\n4,5,6.0\n')
+        c.seek(0)
+        dt = np.dtype([('x', int), ('y', [('t', int), ('s', float)])])
+        x = np.loadtxt(c, dtype=dt, delimiter=',')
+        a = np.array([(1, (2, 3.0)), (4, (5, 6.0))], dt)
+        assert_array_equal(x, a)
+
+    def test_shaped_dtype(self):
+        c = TextIO("aaaa  1.0  8.0  1 2 3 4 5 6")
+        dt = np.dtype([('name', 'S4'), ('x', float), ('y', float),
+                       ('block', int, (2, 3))])
+        x = np.loadtxt(c, dtype=dt)
+        a = np.array([('aaaa', 1.0, 8.0, [[1, 2, 3], [4, 5, 6]])],
+                     dtype=dt)
+        assert_array_equal(x, a)
+
+    def test_3d_shaped_dtype(self):
+        c = TextIO("aaaa  1.0  8.0  1 2 3 4 5 6 7 8 9 10 11 12")
+        dt = np.dtype([('name', 'S4'), ('x', float), ('y', float),
+                       ('block', int, (2, 2, 3))])
+        x = np.loadtxt(c, dtype=dt)
+        a = np.array([('aaaa', 1.0, 8.0,
+                       [[[1, 2, 3], [4, 5, 6]], [[7, 8, 9], [10, 11, 12]]])],
+                     dtype=dt)
+        assert_array_equal(x, a)
+
+    def test_str_dtype(self):
+        # see gh-8033
+        c = ["str1", "str2"]
+
+        for dt in (str, np.bytes_):
+            a = np.array(["str1", "str2"], dtype=dt)
+            x = np.loadtxt(c, dtype=dt)
+            assert_array_equal(x, a)
+
+    def test_empty_file(self):
+        with pytest.warns(UserWarning, match="input contained no data"):
+            c = TextIO()
+            x = np.loadtxt(c)
+            assert_equal(x.shape, (0,))
+            x = np.loadtxt(c, dtype=np.int64)
+            assert_equal(x.shape, (0,))
+            assert_(x.dtype == np.int64)
+
+    def test_unused_converter(self):
+        c = TextIO()
+        c.writelines(['1 21\n', '3 42\n'])
+        c.seek(0)
+        data = np.loadtxt(c, usecols=(1,),
+                          converters={0: lambda s: int(s, 16)})
+        assert_array_equal(data, [21, 42])
+
+        c.seek(0)
+        data = np.loadtxt(c, usecols=(1,),
+                          converters={1: lambda s: int(s, 16)})
+        assert_array_equal(data, [33, 66])
+
+    def test_dtype_with_object(self):
+        # Test using an explicit dtype with an object
+        data = """ 1; 2001-01-01
+                   2; 2002-01-31 """
+        ndtype = [('idx', int), ('code', object)]
+        func = lambda s: strptime(s.strip(), "%Y-%m-%d")
+        converters = {1: func}
+        test = np.loadtxt(TextIO(data), delimiter=";", dtype=ndtype,
+                          converters=converters)
+        control = np.array(
+            [(1, datetime(2001, 1, 1)), (2, datetime(2002, 1, 31))],
+            dtype=ndtype)
+        assert_equal(test, control)
+
+    def test_uint64_type(self):
+        tgt = (9223372043271415339, 9223372043271415853)
+        c = TextIO()
+        c.write("%s %s" % tgt)
+        c.seek(0)
+        res = np.loadtxt(c, dtype=np.uint64)
+        assert_equal(res, tgt)
+
+    def test_int64_type(self):
+        tgt = (-9223372036854775807, 9223372036854775807)
+        c = TextIO()
+        c.write("%s %s" % tgt)
+        c.seek(0)
+        res = np.loadtxt(c, dtype=np.int64)
+        assert_equal(res, tgt)
+
+    def test_from_float_hex(self):
+        # IEEE doubles and floats only, otherwise the float32
+        # conversion may fail.
+        tgt = np.logspace(-10, 10, 5).astype(np.float32)
+        tgt = np.hstack((tgt, -tgt)).astype(float)
+        inp = '\n'.join(map(float.hex, tgt))
+        c = TextIO()
+        c.write(inp)
+        for dt in [float, np.float32]:
+            c.seek(0)
+            res = np.loadtxt(
+                c, dtype=dt, converters=float.fromhex, encoding="latin1")
+            assert_equal(res, tgt, err_msg="%s" % dt)
+
+    @pytest.mark.skipif(IS_PYPY and sys.implementation.version <= (7, 3, 8),
+                        reason="PyPy bug in error formatting")
+    def test_default_float_converter_no_default_hex_conversion(self):
+        """
+        Ensure that fromhex is only used for values with the correct prefix and
+        is not called by default. Regression test related to gh-19598.
+        """
+        c = TextIO("a b c")
+        with pytest.raises(ValueError,
+                match=".*convert string 'a' to float64 at row 0, column 1"):
+            np.loadtxt(c)
+
+    @pytest.mark.skipif(IS_PYPY and sys.implementation.version <= (7, 3, 8),
+                        reason="PyPy bug in error formatting")
+    def test_default_float_converter_exception(self):
+        """
+        Ensure that the exception message raised during failed floating point
+        conversion is correct. Regression test related to gh-19598.
+        """
+        c = TextIO("qrs tuv")  # Invalid values for default float converter
+        with pytest.raises(ValueError,
+                match="could not convert string 'qrs' to float64"):
+            np.loadtxt(c)
+
+    def test_from_complex(self):
+        tgt = (complex(1, 1), complex(1, -1))
+        c = TextIO()
+        c.write("%s %s" % tgt)
+        c.seek(0)
+        res = np.loadtxt(c, dtype=complex)
+        assert_equal(res, tgt)
+
+    def test_complex_misformatted(self):
+        # test for backward compatibility
+        # some complex formats used to generate x+-yj
+        a = np.zeros((2, 2), dtype=np.complex128)
+        re = np.pi
+        im = np.e
+        a[:] = re - 1.0j * im
+        c = BytesIO()
+        np.savetxt(c, a, fmt='%.16e')
+        c.seek(0)
+        txt = c.read()
+        c.seek(0)
+        # misformat the sign on the imaginary part, gh 7895
+        txt_bad = txt.replace(b'e+00-', b'e00+-')
+        assert_(txt_bad != txt)
+        c.write(txt_bad)
+        c.seek(0)
+        res = np.loadtxt(c, dtype=complex)
+        assert_equal(res, a)
+
+    def test_universal_newline(self):
+        with temppath() as name:
+            with open(name, 'w') as f:
+                f.write('1 21\r3 42\r')
+            data = np.loadtxt(name)
+        assert_array_equal(data, [[1, 21], [3, 42]])
+
+    def test_empty_field_after_tab(self):
+        c = TextIO()
+        c.write('1 \t2 \t3\tstart \n4\t5\t6\t  \n7\t8\t9.5\t')
+        c.seek(0)
+        dt = {'names': ('x', 'y', 'z', 'comment'),
+              'formats': (' num rows
+        c = TextIO()
+        c.write('comment\n1,2,3,5\n4,5,7,8\n2,1,4,5')
+        c.seek(0)
+        x = np.loadtxt(c, dtype=int, delimiter=',',
+                       skiprows=1, max_rows=6)
+        a = np.array([[1, 2, 3, 5], [4, 5, 7, 8], [2, 1, 4, 5]], int)
+        assert_array_equal(x, a)
+
+    @pytest.mark.parametrize(["skip", "data"], [
+            (1, ["ignored\n", "1,2\n", "\n", "3,4\n"]),
+            # "Bad" lines that do not end in newlines:
+            (1, ["ignored", "1,2", "", "3,4"]),
+            (1, StringIO("ignored\n1,2\n\n3,4")),
+            # Same as above, but do not skip any lines:
+            (0, ["-1,0\n", "1,2\n", "\n", "3,4\n"]),
+            (0, ["-1,0", "1,2", "", "3,4"]),
+            (0, StringIO("-1,0\n1,2\n\n3,4"))])
+    def test_max_rows_empty_lines(self, skip, data):
+        with pytest.warns(UserWarning,
+                    match=f"Input line 3.*max_rows={3-skip}"):
+            res = np.loadtxt(data, dtype=int, skiprows=skip, delimiter=",",
+                             max_rows=3-skip)
+            assert_array_equal(res, [[-1, 0], [1, 2], [3, 4]][skip:])
+
+        if isinstance(data, StringIO):
+            data.seek(0)
+
+        with warnings.catch_warnings():
+            warnings.simplefilter("error", UserWarning)
+            with pytest.raises(UserWarning):
+                np.loadtxt(data, dtype=int, skiprows=skip, delimiter=",",
+                           max_rows=3-skip)
+
+class Testfromregex:
+    def test_record(self):
+        c = TextIO()
+        c.write('1.312 foo\n1.534 bar\n4.444 qux')
+        c.seek(0)
+
+        dt = [('num', np.float64), ('val', 'S3')]
+        x = np.fromregex(c, r"([0-9.]+)\s+(...)", dt)
+        a = np.array([(1.312, 'foo'), (1.534, 'bar'), (4.444, 'qux')],
+                     dtype=dt)
+        assert_array_equal(x, a)
+
+    def test_record_2(self):
+        c = TextIO()
+        c.write('1312 foo\n1534 bar\n4444 qux')
+        c.seek(0)
+
+        dt = [('num', np.int32), ('val', 'S3')]
+        x = np.fromregex(c, r"(\d+)\s+(...)", dt)
+        a = np.array([(1312, 'foo'), (1534, 'bar'), (4444, 'qux')],
+                     dtype=dt)
+        assert_array_equal(x, a)
+
+    def test_record_3(self):
+        c = TextIO()
+        c.write('1312 foo\n1534 bar\n4444 qux')
+        c.seek(0)
+
+        dt = [('num', np.float64)]
+        x = np.fromregex(c, r"(\d+)\s+...", dt)
+        a = np.array([(1312,), (1534,), (4444,)], dtype=dt)
+        assert_array_equal(x, a)
+
+    @pytest.mark.parametrize("path_type", [str, Path])
+    def test_record_unicode(self, path_type):
+        utf8 = b'\xcf\x96'
+        with temppath() as str_path:
+            path = path_type(str_path)
+            with open(path, 'wb') as f:
+                f.write(b'1.312 foo' + utf8 + b' \n1.534 bar\n4.444 qux')
+
+            dt = [('num', np.float64), ('val', 'U4')]
+            x = np.fromregex(path, r"(?u)([0-9.]+)\s+(\w+)", dt, encoding='UTF-8')
+            a = np.array([(1.312, 'foo' + utf8.decode('UTF-8')), (1.534, 'bar'),
+                           (4.444, 'qux')], dtype=dt)
+            assert_array_equal(x, a)
+
+            regexp = re.compile(r"([0-9.]+)\s+(\w+)", re.UNICODE)
+            x = np.fromregex(path, regexp, dt, encoding='UTF-8')
+            assert_array_equal(x, a)
+
+    def test_compiled_bytes(self):
+        regexp = re.compile(b'(\\d)')
+        c = BytesIO(b'123')
+        dt = [('num', np.float64)]
+        a = np.array([1, 2, 3], dtype=dt)
+        x = np.fromregex(c, regexp, dt)
+        assert_array_equal(x, a)
+
+    def test_bad_dtype_not_structured(self):
+        regexp = re.compile(b'(\\d)')
+        c = BytesIO(b'123')
+        with pytest.raises(TypeError, match='structured datatype'):
+            np.fromregex(c, regexp, dtype=np.float64)
+
+
+#####--------------------------------------------------------------------------
+
+
+class TestFromTxt(LoadTxtBase):
+    loadfunc = staticmethod(np.genfromtxt)
+
+    def test_record(self):
+        # Test w/ explicit dtype
+        data = TextIO('1 2\n3 4')
+        test = np.genfromtxt(data, dtype=[('x', np.int32), ('y', np.int32)])
+        control = np.array([(1, 2), (3, 4)], dtype=[('x', 'i4'), ('y', 'i4')])
+        assert_equal(test, control)
+        #
+        data = TextIO('M 64.0 75.0\nF 25.0 60.0')
+        descriptor = {'names': ('gender', 'age', 'weight'),
+                      'formats': ('S1', 'i4', 'f4')}
+        control = np.array([('M', 64.0, 75.0), ('F', 25.0, 60.0)],
+                           dtype=descriptor)
+        test = np.genfromtxt(data, dtype=descriptor)
+        assert_equal(test, control)
+
+    def test_array(self):
+        # Test outputting a standard ndarray
+        data = TextIO('1 2\n3 4')
+        control = np.array([[1, 2], [3, 4]], dtype=int)
+        test = np.genfromtxt(data, dtype=int)
+        assert_array_equal(test, control)
+        #
+        data.seek(0)
+        control = np.array([[1, 2], [3, 4]], dtype=float)
+        test = np.loadtxt(data, dtype=float)
+        assert_array_equal(test, control)
+
+    def test_1D(self):
+        # Test squeezing to 1D
+        control = np.array([1, 2, 3, 4], int)
+        #
+        data = TextIO('1\n2\n3\n4\n')
+        test = np.genfromtxt(data, dtype=int)
+        assert_array_equal(test, control)
+        #
+        data = TextIO('1,2,3,4\n')
+        test = np.genfromtxt(data, dtype=int, delimiter=',')
+        assert_array_equal(test, control)
+
+    def test_comments(self):
+        # Test the stripping of comments
+        control = np.array([1, 2, 3, 5], int)
+        # Comment on its own line
+        data = TextIO('# comment\n1,2,3,5\n')
+        test = np.genfromtxt(data, dtype=int, delimiter=',', comments='#')
+        assert_equal(test, control)
+        # Comment at the end of a line
+        data = TextIO('1,2,3,5# comment\n')
+        test = np.genfromtxt(data, dtype=int, delimiter=',', comments='#')
+        assert_equal(test, control)
+
+    def test_skiprows(self):
+        # Test row skipping
+        control = np.array([1, 2, 3, 5], int)
+        kwargs = dict(dtype=int, delimiter=',')
+        #
+        data = TextIO('comment\n1,2,3,5\n')
+        test = np.genfromtxt(data, skip_header=1, **kwargs)
+        assert_equal(test, control)
+        #
+        data = TextIO('# comment\n1,2,3,5\n')
+        test = np.loadtxt(data, skiprows=1, **kwargs)
+        assert_equal(test, control)
+
+    def test_skip_footer(self):
+        data = ["# %i" % i for i in range(1, 6)]
+        data.append("A, B, C")
+        data.extend(["%i,%3.1f,%03s" % (i, i, i) for i in range(51)])
+        data[-1] = "99,99"
+        kwargs = dict(delimiter=",", names=True, skip_header=5, skip_footer=10)
+        test = np.genfromtxt(TextIO("\n".join(data)), **kwargs)
+        ctrl = np.array([("%f" % i, "%f" % i, "%f" % i) for i in range(41)],
+                        dtype=[(_, float) for _ in "ABC"])
+        assert_equal(test, ctrl)
+
+    def test_skip_footer_with_invalid(self):
+        with suppress_warnings() as sup:
+            sup.filter(ConversionWarning)
+            basestr = '1 1\n2 2\n3 3\n4 4\n5  \n6  \n7  \n'
+            # Footer too small to get rid of all invalid values
+            assert_raises(ValueError, np.genfromtxt,
+                          TextIO(basestr), skip_footer=1)
+    #        except ValueError:
+    #            pass
+            a = np.genfromtxt(
+                TextIO(basestr), skip_footer=1, invalid_raise=False)
+            assert_equal(a, np.array([[1., 1.], [2., 2.], [3., 3.], [4., 4.]]))
+            #
+            a = np.genfromtxt(TextIO(basestr), skip_footer=3)
+            assert_equal(a, np.array([[1., 1.], [2., 2.], [3., 3.], [4., 4.]]))
+            #
+            basestr = '1 1\n2  \n3 3\n4 4\n5  \n6 6\n7 7\n'
+            a = np.genfromtxt(
+                TextIO(basestr), skip_footer=1, invalid_raise=False)
+            assert_equal(a, np.array([[1., 1.], [3., 3.], [4., 4.], [6., 6.]]))
+            a = np.genfromtxt(
+                TextIO(basestr), skip_footer=3, invalid_raise=False)
+            assert_equal(a, np.array([[1., 1.], [3., 3.], [4., 4.]]))
+
+    def test_header(self):
+        # Test retrieving a header
+        data = TextIO('gender age weight\nM 64.0 75.0\nF 25.0 60.0')
+        with warnings.catch_warnings(record=True) as w:
+            warnings.filterwarnings('always', '', VisibleDeprecationWarning)
+            test = np.genfromtxt(data, dtype=None, names=True,
+                                 encoding='bytes')
+            assert_(w[0].category is VisibleDeprecationWarning)
+        control = {'gender': np.array([b'M', b'F']),
+                   'age': np.array([64.0, 25.0]),
+                   'weight': np.array([75.0, 60.0])}
+        assert_equal(test['gender'], control['gender'])
+        assert_equal(test['age'], control['age'])
+        assert_equal(test['weight'], control['weight'])
+
+    def test_auto_dtype(self):
+        # Test the automatic definition of the output dtype
+        data = TextIO('A 64 75.0 3+4j True\nBCD 25 60.0 5+6j False')
+        with warnings.catch_warnings(record=True) as w:
+            warnings.filterwarnings('always', '', VisibleDeprecationWarning)
+            test = np.genfromtxt(data, dtype=None, encoding='bytes')
+            assert_(w[0].category is VisibleDeprecationWarning)
+        control = [np.array([b'A', b'BCD']),
+                   np.array([64, 25]),
+                   np.array([75.0, 60.0]),
+                   np.array([3 + 4j, 5 + 6j]),
+                   np.array([True, False]), ]
+        assert_equal(test.dtype.names, ['f0', 'f1', 'f2', 'f3', 'f4'])
+        for (i, ctrl) in enumerate(control):
+            assert_equal(test['f%i' % i], ctrl)
+
+    def test_auto_dtype_uniform(self):
+        # Tests whether the output dtype can be uniformized
+        data = TextIO('1 2 3 4\n5 6 7 8\n')
+        test = np.genfromtxt(data, dtype=None)
+        control = np.array([[1, 2, 3, 4], [5, 6, 7, 8]])
+        assert_equal(test, control)
+
+    def test_fancy_dtype(self):
+        # Check that a nested dtype isn't MIA
+        data = TextIO('1,2,3.0\n4,5,6.0\n')
+        fancydtype = np.dtype([('x', int), ('y', [('t', int), ('s', float)])])
+        test = np.genfromtxt(data, dtype=fancydtype, delimiter=',')
+        control = np.array([(1, (2, 3.0)), (4, (5, 6.0))], dtype=fancydtype)
+        assert_equal(test, control)
+
+    def test_names_overwrite(self):
+        # Test overwriting the names of the dtype
+        descriptor = {'names': ('g', 'a', 'w'),
+                      'formats': ('S1', 'i4', 'f4')}
+        data = TextIO(b'M 64.0 75.0\nF 25.0 60.0')
+        names = ('gender', 'age', 'weight')
+        test = np.genfromtxt(data, dtype=descriptor, names=names)
+        descriptor['names'] = names
+        control = np.array([('M', 64.0, 75.0),
+                            ('F', 25.0, 60.0)], dtype=descriptor)
+        assert_equal(test, control)
+
+    def test_bad_fname(self):
+        with pytest.raises(TypeError, match='fname must be a string,'):
+            np.genfromtxt(123)
+
+    def test_commented_header(self):
+        # Check that names can be retrieved even if the line is commented out.
+        data = TextIO("""
+#gender age weight
+M   21  72.100000
+F   35  58.330000
+M   33  21.99
+        """)
+        # The # is part of the first name and should be deleted automatically.
+        with warnings.catch_warnings(record=True) as w:
+            warnings.filterwarnings('always', '', VisibleDeprecationWarning)
+            test = np.genfromtxt(data, names=True, dtype=None,
+                                 encoding="bytes")
+            assert_(w[0].category is VisibleDeprecationWarning)
+        ctrl = np.array([('M', 21, 72.1), ('F', 35, 58.33), ('M', 33, 21.99)],
+                        dtype=[('gender', '|S1'), ('age', int), ('weight', float)])
+        assert_equal(test, ctrl)
+        # Ditto, but we should get rid of the first element
+        data = TextIO(b"""
+# gender age weight
+M   21  72.100000
+F   35  58.330000
+M   33  21.99
+        """)
+        with warnings.catch_warnings(record=True) as w:
+            warnings.filterwarnings('always', '', VisibleDeprecationWarning)
+            test = np.genfromtxt(data, names=True, dtype=None,
+                                 encoding="bytes")
+            assert_(w[0].category is VisibleDeprecationWarning)
+        assert_equal(test, ctrl)
+
+    def test_names_and_comments_none(self):
+        # Tests case when names is true but comments is None (gh-10780)
+        data = TextIO('col1 col2\n 1 2\n 3 4')
+        test = np.genfromtxt(data, dtype=(int, int), comments=None, names=True)
+        control = np.array([(1, 2), (3, 4)], dtype=[('col1', int), ('col2', int)])
+        assert_equal(test, control)
+
+    def test_file_is_closed_on_error(self):
+        # gh-13200
+        with tempdir() as tmpdir:
+            fpath = os.path.join(tmpdir, "test.csv")
+            with open(fpath, "wb") as f:
+                f.write('\N{GREEK PI SYMBOL}'.encode())
+
+            # ResourceWarnings are emitted from a destructor, so won't be
+            # detected by regular propagation to errors.
+            with assert_no_warnings():
+                with pytest.raises(UnicodeDecodeError):
+                    np.genfromtxt(fpath, encoding="ascii")
+
+    def test_autonames_and_usecols(self):
+        # Tests names and usecols
+        data = TextIO('A B C D\n aaaa 121 45 9.1')
+        with warnings.catch_warnings(record=True) as w:
+            warnings.filterwarnings('always', '', VisibleDeprecationWarning)
+            test = np.genfromtxt(data, usecols=('A', 'C', 'D'),
+                                names=True, dtype=None, encoding="bytes")
+            assert_(w[0].category is VisibleDeprecationWarning)
+        control = np.array(('aaaa', 45, 9.1),
+                           dtype=[('A', '|S4'), ('C', int), ('D', float)])
+        assert_equal(test, control)
+
+    def test_converters_with_usecols(self):
+        # Test the combination user-defined converters and usecol
+        data = TextIO('1,2,3,,5\n6,7,8,9,10\n')
+        test = np.genfromtxt(data, dtype=int, delimiter=',',
+                            converters={3: lambda s: int(s or - 999)},
+                            usecols=(1, 3,))
+        control = np.array([[2, -999], [7, 9]], int)
+        assert_equal(test, control)
+
+    def test_converters_with_usecols_and_names(self):
+        # Tests names and usecols
+        data = TextIO('A B C D\n aaaa 121 45 9.1')
+        with warnings.catch_warnings(record=True) as w:
+            warnings.filterwarnings('always', '', VisibleDeprecationWarning)
+            test = np.genfromtxt(data, usecols=('A', 'C', 'D'), names=True,
+                                dtype=None, encoding="bytes",
+                                converters={'C': lambda s: 2 * int(s)})
+            assert_(w[0].category is VisibleDeprecationWarning)
+        control = np.array(('aaaa', 90, 9.1),
+                           dtype=[('A', '|S4'), ('C', int), ('D', float)])
+        assert_equal(test, control)
+
+    def test_converters_cornercases(self):
+        # Test the conversion to datetime.
+        converter = {
+            'date': lambda s: strptime(s, '%Y-%m-%d %H:%M:%SZ')}
+        data = TextIO('2009-02-03 12:00:00Z, 72214.0')
+        test = np.genfromtxt(data, delimiter=',', dtype=None,
+                            names=['date', 'stid'], converters=converter)
+        control = np.array((datetime(2009, 2, 3), 72214.),
+                           dtype=[('date', np.object_), ('stid', float)])
+        assert_equal(test, control)
+
+    def test_converters_cornercases2(self):
+        # Test the conversion to datetime64.
+        converter = {
+            'date': lambda s: np.datetime64(strptime(s, '%Y-%m-%d %H:%M:%SZ'))}
+        data = TextIO('2009-02-03 12:00:00Z, 72214.0')
+        test = np.genfromtxt(data, delimiter=',', dtype=None,
+                            names=['date', 'stid'], converters=converter)
+        control = np.array((datetime(2009, 2, 3), 72214.),
+                           dtype=[('date', 'datetime64[us]'), ('stid', float)])
+        assert_equal(test, control)
+
+    def test_unused_converter(self):
+        # Test whether unused converters are forgotten
+        data = TextIO("1 21\n  3 42\n")
+        test = np.genfromtxt(data, usecols=(1,),
+                            converters={0: lambda s: int(s, 16)})
+        assert_equal(test, [21, 42])
+        #
+        data.seek(0)
+        test = np.genfromtxt(data, usecols=(1,),
+                            converters={1: lambda s: int(s, 16)})
+        assert_equal(test, [33, 66])
+
+    def test_invalid_converter(self):
+        strip_rand = lambda x: float((b'r' in x.lower() and x.split()[-1]) or
+                                     (b'r' not in x.lower() and x.strip() or 0.0))
+        strip_per = lambda x: float((b'%' in x.lower() and x.split()[0]) or
+                                    (b'%' not in x.lower() and x.strip() or 0.0))
+        s = TextIO("D01N01,10/1/2003 ,1 %,R 75,400,600\r\n"
+                   "L24U05,12/5/2003, 2 %,1,300, 150.5\r\n"
+                   "D02N03,10/10/2004,R 1,,7,145.55")
+        kwargs = dict(
+            converters={2: strip_per, 3: strip_rand}, delimiter=",",
+            dtype=None, encoding="bytes")
+        assert_raises(ConverterError, np.genfromtxt, s, **kwargs)
+
+    def test_tricky_converter_bug1666(self):
+        # Test some corner cases
+        s = TextIO('q1,2\nq3,4')
+        cnv = lambda s: float(s[1:])
+        test = np.genfromtxt(s, delimiter=',', converters={0: cnv})
+        control = np.array([[1., 2.], [3., 4.]])
+        assert_equal(test, control)
+
+    def test_dtype_with_converters(self):
+        dstr = "2009; 23; 46"
+        test = np.genfromtxt(TextIO(dstr,),
+                            delimiter=";", dtype=float, converters={0: bytes})
+        control = np.array([('2009', 23., 46)],
+                           dtype=[('f0', '|S4'), ('f1', float), ('f2', float)])
+        assert_equal(test, control)
+        test = np.genfromtxt(TextIO(dstr,),
+                            delimiter=";", dtype=float, converters={0: float})
+        control = np.array([2009., 23., 46],)
+        assert_equal(test, control)
+
+    @pytest.mark.filterwarnings("ignore:.*recfromcsv.*:DeprecationWarning")
+    def test_dtype_with_converters_and_usecols(self):
+        dstr = "1,5,-1,1:1\n2,8,-1,1:n\n3,3,-2,m:n\n"
+        dmap = {'1:1':0, '1:n':1, 'm:1':2, 'm:n':3}
+        dtyp = [('e1','i4'),('e2','i4'),('e3','i2'),('n', 'i1')]
+        conv = {0: int, 1: int, 2: int, 3: lambda r: dmap[r.decode()]}
+        test = recfromcsv(TextIO(dstr,), dtype=dtyp, delimiter=',',
+                          names=None, converters=conv, encoding="bytes")
+        control = np.rec.array([(1,5,-1,0), (2,8,-1,1), (3,3,-2,3)], dtype=dtyp)
+        assert_equal(test, control)
+        dtyp = [('e1', 'i4'), ('e2', 'i4'), ('n', 'i1')]
+        test = recfromcsv(TextIO(dstr,), dtype=dtyp, delimiter=',',
+                          usecols=(0, 1, 3), names=None, converters=conv,
+                          encoding="bytes")
+        control = np.rec.array([(1,5,0), (2,8,1), (3,3,3)], dtype=dtyp)
+        assert_equal(test, control)
+
+    def test_dtype_with_object(self):
+        # Test using an explicit dtype with an object
+        data = """ 1; 2001-01-01
+                   2; 2002-01-31 """
+        ndtype = [('idx', int), ('code', object)]
+        func = lambda s: strptime(s.strip(), "%Y-%m-%d")
+        converters = {1: func}
+        test = np.genfromtxt(TextIO(data), delimiter=";", dtype=ndtype,
+                             converters=converters)
+        control = np.array(
+            [(1, datetime(2001, 1, 1)), (2, datetime(2002, 1, 31))],
+            dtype=ndtype)
+        assert_equal(test, control)
+
+        ndtype = [('nest', [('idx', int), ('code', object)])]
+        with assert_raises_regex(NotImplementedError,
+                                 'Nested fields.* not supported.*'):
+            test = np.genfromtxt(TextIO(data), delimiter=";",
+                                 dtype=ndtype, converters=converters)
+
+        # nested but empty fields also aren't supported
+        ndtype = [('idx', int), ('code', object), ('nest', [])]
+        with assert_raises_regex(NotImplementedError,
+                                 'Nested fields.* not supported.*'):
+            test = np.genfromtxt(TextIO(data), delimiter=";",
+                                 dtype=ndtype, converters=converters)
+
+    def test_dtype_with_object_no_converter(self):
+        # Object without a converter uses bytes:
+        parsed = np.genfromtxt(TextIO("1"), dtype=object)
+        assert parsed[()] == b"1"
+        parsed = np.genfromtxt(TextIO("string"), dtype=object)
+        assert parsed[()] == b"string"
+
+    def test_userconverters_with_explicit_dtype(self):
+        # Test user_converters w/ explicit (standard) dtype
+        data = TextIO('skip,skip,2001-01-01,1.0,skip')
+        test = np.genfromtxt(data, delimiter=",", names=None, dtype=float,
+                             usecols=(2, 3), converters={2: bytes})
+        control = np.array([('2001-01-01', 1.)],
+                           dtype=[('', '|S10'), ('', float)])
+        assert_equal(test, control)
+
+    def test_utf8_userconverters_with_explicit_dtype(self):
+        utf8 = b'\xcf\x96'
+        with temppath() as path:
+            with open(path, 'wb') as f:
+                f.write(b'skip,skip,2001-01-01' + utf8 + b',1.0,skip')
+            test = np.genfromtxt(path, delimiter=",", names=None, dtype=float,
+                                 usecols=(2, 3), converters={2: str},
+                                 encoding='UTF-8')
+        control = np.array([('2001-01-01' + utf8.decode('UTF-8'), 1.)],
+                           dtype=[('', '|U11'), ('', float)])
+        assert_equal(test, control)
+
+    def test_spacedelimiter(self):
+        # Test space delimiter
+        data = TextIO("1  2  3  4   5\n6  7  8  9  10")
+        test = np.genfromtxt(data)
+        control = np.array([[1., 2., 3., 4., 5.],
+                            [6., 7., 8., 9., 10.]])
+        assert_equal(test, control)
+
+    def test_integer_delimiter(self):
+        # Test using an integer for delimiter
+        data = "  1  2  3\n  4  5 67\n890123  4"
+        test = np.genfromtxt(TextIO(data), delimiter=3)
+        control = np.array([[1, 2, 3], [4, 5, 67], [890, 123, 4]])
+        assert_equal(test, control)
+
+    def test_missing(self):
+        data = TextIO('1,2,3,,5\n')
+        test = np.genfromtxt(data, dtype=int, delimiter=',',
+                            converters={3: lambda s: int(s or - 999)})
+        control = np.array([1, 2, 3, -999, 5], int)
+        assert_equal(test, control)
+
+    def test_missing_with_tabs(self):
+        # Test w/ a delimiter tab
+        txt = "1\t2\t3\n\t2\t\n1\t\t3"
+        test = np.genfromtxt(TextIO(txt), delimiter="\t",
+                             usemask=True,)
+        ctrl_d = np.array([(1, 2, 3), (np.nan, 2, np.nan), (1, np.nan, 3)],)
+        ctrl_m = np.array([(0, 0, 0), (1, 0, 1), (0, 1, 0)], dtype=bool)
+        assert_equal(test.data, ctrl_d)
+        assert_equal(test.mask, ctrl_m)
+
+    def test_usecols(self):
+        # Test the selection of columns
+        # Select 1 column
+        control = np.array([[1, 2], [3, 4]], float)
+        data = TextIO()
+        np.savetxt(data, control)
+        data.seek(0)
+        test = np.genfromtxt(data, dtype=float, usecols=(1,))
+        assert_equal(test, control[:, 1])
+        #
+        control = np.array([[1, 2, 3], [3, 4, 5]], float)
+        data = TextIO()
+        np.savetxt(data, control)
+        data.seek(0)
+        test = np.genfromtxt(data, dtype=float, usecols=(1, 2))
+        assert_equal(test, control[:, 1:])
+        # Testing with arrays instead of tuples.
+        data.seek(0)
+        test = np.genfromtxt(data, dtype=float, usecols=np.array([1, 2]))
+        assert_equal(test, control[:, 1:])
+
+    def test_usecols_as_css(self):
+        # Test giving usecols with a comma-separated string
+        data = "1 2 3\n4 5 6"
+        test = np.genfromtxt(TextIO(data),
+                             names="a, b, c", usecols="a, c")
+        ctrl = np.array([(1, 3), (4, 6)], dtype=[(_, float) for _ in "ac"])
+        assert_equal(test, ctrl)
+
+    def test_usecols_with_structured_dtype(self):
+        # Test usecols with an explicit structured dtype
+        data = TextIO("JOE 70.1 25.3\nBOB 60.5 27.9")
+        names = ['stid', 'temp']
+        dtypes = ['S4', 'f8']
+        test = np.genfromtxt(
+            data, usecols=(0, 2), dtype=list(zip(names, dtypes)))
+        assert_equal(test['stid'], [b"JOE", b"BOB"])
+        assert_equal(test['temp'], [25.3, 27.9])
+
+    def test_usecols_with_integer(self):
+        # Test usecols with an integer
+        test = np.genfromtxt(TextIO(b"1 2 3\n4 5 6"), usecols=0)
+        assert_equal(test, np.array([1., 4.]))
+
+    def test_usecols_with_named_columns(self):
+        # Test usecols with named columns
+        ctrl = np.array([(1, 3), (4, 6)], dtype=[('a', float), ('c', float)])
+        data = "1 2 3\n4 5 6"
+        kwargs = dict(names="a, b, c")
+        test = np.genfromtxt(TextIO(data), usecols=(0, -1), **kwargs)
+        assert_equal(test, ctrl)
+        test = np.genfromtxt(TextIO(data),
+                             usecols=('a', 'c'), **kwargs)
+        assert_equal(test, ctrl)
+
+    def test_empty_file(self):
+        # Test that an empty file raises the proper warning.
+        with suppress_warnings() as sup:
+            sup.filter(message="genfromtxt: Empty input file:")
+            data = TextIO()
+            test = np.genfromtxt(data)
+            assert_equal(test, np.array([]))
+
+            # when skip_header > 0
+            test = np.genfromtxt(data, skip_header=1)
+            assert_equal(test, np.array([]))
+
+    def test_fancy_dtype_alt(self):
+        # Check that a nested dtype isn't MIA
+        data = TextIO('1,2,3.0\n4,5,6.0\n')
+        fancydtype = np.dtype([('x', int), ('y', [('t', int), ('s', float)])])
+        test = np.genfromtxt(data, dtype=fancydtype, delimiter=',', usemask=True)
+        control = ma.array([(1, (2, 3.0)), (4, (5, 6.0))], dtype=fancydtype)
+        assert_equal(test, control)
+
+    def test_shaped_dtype(self):
+        c = TextIO("aaaa  1.0  8.0  1 2 3 4 5 6")
+        dt = np.dtype([('name', 'S4'), ('x', float), ('y', float),
+                       ('block', int, (2, 3))])
+        x = np.genfromtxt(c, dtype=dt)
+        a = np.array([('aaaa', 1.0, 8.0, [[1, 2, 3], [4, 5, 6]])],
+                     dtype=dt)
+        assert_array_equal(x, a)
+
+    def test_withmissing(self):
+        data = TextIO('A,B\n0,1\n2,N/A')
+        kwargs = dict(delimiter=",", missing_values="N/A", names=True)
+        test = np.genfromtxt(data, dtype=None, usemask=True, **kwargs)
+        control = ma.array([(0, 1), (2, -1)],
+                           mask=[(False, False), (False, True)],
+                           dtype=[('A', int), ('B', int)])
+        assert_equal(test, control)
+        assert_equal(test.mask, control.mask)
+        #
+        data.seek(0)
+        test = np.genfromtxt(data, usemask=True, **kwargs)
+        control = ma.array([(0, 1), (2, -1)],
+                           mask=[(False, False), (False, True)],
+                           dtype=[('A', float), ('B', float)])
+        assert_equal(test, control)
+        assert_equal(test.mask, control.mask)
+
+    def test_user_missing_values(self):
+        data = "A, B, C\n0, 0., 0j\n1, N/A, 1j\n-9, 2.2, N/A\n3, -99, 3j"
+        basekwargs = dict(dtype=None, delimiter=",", names=True,)
+        mdtype = [('A', int), ('B', float), ('C', complex)]
+        #
+        test = np.genfromtxt(TextIO(data), missing_values="N/A",
+                            **basekwargs)
+        control = ma.array([(0, 0.0, 0j), (1, -999, 1j),
+                            (-9, 2.2, -999j), (3, -99, 3j)],
+                           mask=[(0, 0, 0), (0, 1, 0), (0, 0, 1), (0, 0, 0)],
+                           dtype=mdtype)
+        assert_equal(test, control)
+        #
+        basekwargs['dtype'] = mdtype
+        test = np.genfromtxt(TextIO(data),
+                            missing_values={0: -9, 1: -99, 2: -999j}, usemask=True, **basekwargs)
+        control = ma.array([(0, 0.0, 0j), (1, -999, 1j),
+                            (-9, 2.2, -999j), (3, -99, 3j)],
+                           mask=[(0, 0, 0), (0, 1, 0), (1, 0, 1), (0, 1, 0)],
+                           dtype=mdtype)
+        assert_equal(test, control)
+        #
+        test = np.genfromtxt(TextIO(data),
+                            missing_values={0: -9, 'B': -99, 'C': -999j},
+                            usemask=True,
+                            **basekwargs)
+        control = ma.array([(0, 0.0, 0j), (1, -999, 1j),
+                            (-9, 2.2, -999j), (3, -99, 3j)],
+                           mask=[(0, 0, 0), (0, 1, 0), (1, 0, 1), (0, 1, 0)],
+                           dtype=mdtype)
+        assert_equal(test, control)
+
+    def test_user_filling_values(self):
+        # Test with missing and filling values
+        ctrl = np.array([(0, 3), (4, -999)], dtype=[('a', int), ('b', int)])
+        data = "N/A, 2, 3\n4, ,???"
+        kwargs = dict(delimiter=",",
+                      dtype=int,
+                      names="a,b,c",
+                      missing_values={0: "N/A", 'b': " ", 2: "???"},
+                      filling_values={0: 0, 'b': 0, 2: -999})
+        test = np.genfromtxt(TextIO(data), **kwargs)
+        ctrl = np.array([(0, 2, 3), (4, 0, -999)],
+                        dtype=[(_, int) for _ in "abc"])
+        assert_equal(test, ctrl)
+        #
+        test = np.genfromtxt(TextIO(data), usecols=(0, -1), **kwargs)
+        ctrl = np.array([(0, 3), (4, -999)], dtype=[(_, int) for _ in "ac"])
+        assert_equal(test, ctrl)
+
+        data2 = "1,2,*,4\n5,*,7,8\n"
+        test = np.genfromtxt(TextIO(data2), delimiter=',', dtype=int,
+                             missing_values="*", filling_values=0)
+        ctrl = np.array([[1, 2, 0, 4], [5, 0, 7, 8]])
+        assert_equal(test, ctrl)
+        test = np.genfromtxt(TextIO(data2), delimiter=',', dtype=int,
+                             missing_values="*", filling_values=-1)
+        ctrl = np.array([[1, 2, -1, 4], [5, -1, 7, 8]])
+        assert_equal(test, ctrl)
+
+    def test_withmissing_float(self):
+        data = TextIO('A,B\n0,1.5\n2,-999.00')
+        test = np.genfromtxt(data, dtype=None, delimiter=',',
+                            missing_values='-999.0', names=True, usemask=True)
+        control = ma.array([(0, 1.5), (2, -1.)],
+                           mask=[(False, False), (False, True)],
+                           dtype=[('A', int), ('B', float)])
+        assert_equal(test, control)
+        assert_equal(test.mask, control.mask)
+
+    def test_with_masked_column_uniform(self):
+        # Test masked column
+        data = TextIO('1 2 3\n4 5 6\n')
+        test = np.genfromtxt(data, dtype=None,
+                             missing_values='2,5', usemask=True)
+        control = ma.array([[1, 2, 3], [4, 5, 6]], mask=[[0, 1, 0], [0, 1, 0]])
+        assert_equal(test, control)
+
+    def test_with_masked_column_various(self):
+        # Test masked column
+        data = TextIO('True 2 3\nFalse 5 6\n')
+        test = np.genfromtxt(data, dtype=None,
+                             missing_values='2,5', usemask=True)
+        control = ma.array([(1, 2, 3), (0, 5, 6)],
+                           mask=[(0, 1, 0), (0, 1, 0)],
+                           dtype=[('f0', bool), ('f1', bool), ('f2', int)])
+        assert_equal(test, control)
+
+    def test_invalid_raise(self):
+        # Test invalid raise
+        data = ["1, 1, 1, 1, 1"] * 50
+        for i in range(5):
+            data[10 * i] = "2, 2, 2, 2 2"
+        data.insert(0, "a, b, c, d, e")
+        mdata = TextIO("\n".join(data))
+
+        kwargs = dict(delimiter=",", dtype=None, names=True)
+        def f():
+            return np.genfromtxt(mdata, invalid_raise=False, **kwargs)
+        mtest = assert_warns(ConversionWarning, f)
+        assert_equal(len(mtest), 45)
+        assert_equal(mtest, np.ones(45, dtype=[(_, int) for _ in 'abcde']))
+        #
+        mdata.seek(0)
+        assert_raises(ValueError, np.genfromtxt, mdata,
+                      delimiter=",", names=True)
+
+    def test_invalid_raise_with_usecols(self):
+        # Test invalid_raise with usecols
+        data = ["1, 1, 1, 1, 1"] * 50
+        for i in range(5):
+            data[10 * i] = "2, 2, 2, 2 2"
+        data.insert(0, "a, b, c, d, e")
+        mdata = TextIO("\n".join(data))
+
+        kwargs = dict(delimiter=",", dtype=None, names=True,
+                      invalid_raise=False)
+        def f():
+            return np.genfromtxt(mdata, usecols=(0, 4), **kwargs)
+        mtest = assert_warns(ConversionWarning, f)
+        assert_equal(len(mtest), 45)
+        assert_equal(mtest, np.ones(45, dtype=[(_, int) for _ in 'ae']))
+        #
+        mdata.seek(0)
+        mtest = np.genfromtxt(mdata, usecols=(0, 1), **kwargs)
+        assert_equal(len(mtest), 50)
+        control = np.ones(50, dtype=[(_, int) for _ in 'ab'])
+        control[[10 * _ for _ in range(5)]] = (2, 2)
+        assert_equal(mtest, control)
+
+    def test_inconsistent_dtype(self):
+        # Test inconsistent dtype
+        data = ["1, 1, 1, 1, -1.1"] * 50
+        mdata = TextIO("\n".join(data))
+
+        converters = {4: lambda x: "(%s)" % x.decode()}
+        kwargs = dict(delimiter=",", converters=converters,
+                      dtype=[(_, int) for _ in 'abcde'], encoding="bytes")
+        assert_raises(ValueError, np.genfromtxt, mdata, **kwargs)
+
+    def test_default_field_format(self):
+        # Test default format
+        data = "0, 1, 2.3\n4, 5, 6.7"
+        mtest = np.genfromtxt(TextIO(data),
+                             delimiter=",", dtype=None, defaultfmt="f%02i")
+        ctrl = np.array([(0, 1, 2.3), (4, 5, 6.7)],
+                        dtype=[("f00", int), ("f01", int), ("f02", float)])
+        assert_equal(mtest, ctrl)
+
+    def test_single_dtype_wo_names(self):
+        # Test single dtype w/o names
+        data = "0, 1, 2.3\n4, 5, 6.7"
+        mtest = np.genfromtxt(TextIO(data),
+                             delimiter=",", dtype=float, defaultfmt="f%02i")
+        ctrl = np.array([[0., 1., 2.3], [4., 5., 6.7]], dtype=float)
+        assert_equal(mtest, ctrl)
+
+    def test_single_dtype_w_explicit_names(self):
+        # Test single dtype w explicit names
+        data = "0, 1, 2.3\n4, 5, 6.7"
+        mtest = np.genfromtxt(TextIO(data),
+                             delimiter=",", dtype=float, names="a, b, c")
+        ctrl = np.array([(0., 1., 2.3), (4., 5., 6.7)],
+                        dtype=[(_, float) for _ in "abc"])
+        assert_equal(mtest, ctrl)
+
+    def test_single_dtype_w_implicit_names(self):
+        # Test single dtype w implicit names
+        data = "a, b, c\n0, 1, 2.3\n4, 5, 6.7"
+        mtest = np.genfromtxt(TextIO(data),
+                             delimiter=",", dtype=float, names=True)
+        ctrl = np.array([(0., 1., 2.3), (4., 5., 6.7)],
+                        dtype=[(_, float) for _ in "abc"])
+        assert_equal(mtest, ctrl)
+
+    def test_easy_structured_dtype(self):
+        # Test easy structured dtype
+        data = "0, 1, 2.3\n4, 5, 6.7"
+        mtest = np.genfromtxt(TextIO(data), delimiter=",",
+                             dtype=(int, float, float), defaultfmt="f_%02i")
+        ctrl = np.array([(0, 1., 2.3), (4, 5., 6.7)],
+                        dtype=[("f_00", int), ("f_01", float), ("f_02", float)])
+        assert_equal(mtest, ctrl)
+
+    def test_autostrip(self):
+        # Test autostrip
+        data = "01/01/2003  , 1.3,   abcde"
+        kwargs = dict(delimiter=",", dtype=None, encoding="bytes")
+        with warnings.catch_warnings(record=True) as w:
+            warnings.filterwarnings('always', '', VisibleDeprecationWarning)
+            mtest = np.genfromtxt(TextIO(data), **kwargs)
+            assert_(w[0].category is VisibleDeprecationWarning)
+        ctrl = np.array([('01/01/2003  ', 1.3, '   abcde')],
+                        dtype=[('f0', '|S12'), ('f1', float), ('f2', '|S8')])
+        assert_equal(mtest, ctrl)
+        with warnings.catch_warnings(record=True) as w:
+            warnings.filterwarnings('always', '', VisibleDeprecationWarning)
+            mtest = np.genfromtxt(TextIO(data), autostrip=True, **kwargs)
+            assert_(w[0].category is VisibleDeprecationWarning)
+        ctrl = np.array([('01/01/2003', 1.3, 'abcde')],
+                        dtype=[('f0', '|S10'), ('f1', float), ('f2', '|S5')])
+        assert_equal(mtest, ctrl)
+
+    def test_replace_space(self):
+        # Test the 'replace_space' option
+        txt = "A.A, B (B), C:C\n1, 2, 3.14"
+        # Test default: replace ' ' by '_' and delete non-alphanum chars
+        test = np.genfromtxt(TextIO(txt),
+                             delimiter=",", names=True, dtype=None)
+        ctrl_dtype = [("AA", int), ("B_B", int), ("CC", float)]
+        ctrl = np.array((1, 2, 3.14), dtype=ctrl_dtype)
+        assert_equal(test, ctrl)
+        # Test: no replace, no delete
+        test = np.genfromtxt(TextIO(txt),
+                             delimiter=",", names=True, dtype=None,
+                             replace_space='', deletechars='')
+        ctrl_dtype = [("A.A", int), ("B (B)", int), ("C:C", float)]
+        ctrl = np.array((1, 2, 3.14), dtype=ctrl_dtype)
+        assert_equal(test, ctrl)
+        # Test: no delete (spaces are replaced by _)
+        test = np.genfromtxt(TextIO(txt),
+                             delimiter=",", names=True, dtype=None,
+                             deletechars='')
+        ctrl_dtype = [("A.A", int), ("B_(B)", int), ("C:C", float)]
+        ctrl = np.array((1, 2, 3.14), dtype=ctrl_dtype)
+        assert_equal(test, ctrl)
+
+    def test_replace_space_known_dtype(self):
+        # Test the 'replace_space' (and related) options when dtype != None
+        txt = "A.A, B (B), C:C\n1, 2, 3"
+        # Test default: replace ' ' by '_' and delete non-alphanum chars
+        test = np.genfromtxt(TextIO(txt),
+                             delimiter=",", names=True, dtype=int)
+        ctrl_dtype = [("AA", int), ("B_B", int), ("CC", int)]
+        ctrl = np.array((1, 2, 3), dtype=ctrl_dtype)
+        assert_equal(test, ctrl)
+        # Test: no replace, no delete
+        test = np.genfromtxt(TextIO(txt),
+                             delimiter=",", names=True, dtype=int,
+                             replace_space='', deletechars='')
+        ctrl_dtype = [("A.A", int), ("B (B)", int), ("C:C", int)]
+        ctrl = np.array((1, 2, 3), dtype=ctrl_dtype)
+        assert_equal(test, ctrl)
+        # Test: no delete (spaces are replaced by _)
+        test = np.genfromtxt(TextIO(txt),
+                             delimiter=",", names=True, dtype=int,
+                             deletechars='')
+        ctrl_dtype = [("A.A", int), ("B_(B)", int), ("C:C", int)]
+        ctrl = np.array((1, 2, 3), dtype=ctrl_dtype)
+        assert_equal(test, ctrl)
+
+    def test_incomplete_names(self):
+        # Test w/ incomplete names
+        data = "A,,C\n0,1,2\n3,4,5"
+        kwargs = dict(delimiter=",", names=True)
+        # w/ dtype=None
+        ctrl = np.array([(0, 1, 2), (3, 4, 5)],
+                        dtype=[(_, int) for _ in ('A', 'f0', 'C')])
+        test = np.genfromtxt(TextIO(data), dtype=None, **kwargs)
+        assert_equal(test, ctrl)
+        # w/ default dtype
+        ctrl = np.array([(0, 1, 2), (3, 4, 5)],
+                        dtype=[(_, float) for _ in ('A', 'f0', 'C')])
+        test = np.genfromtxt(TextIO(data), **kwargs)
+
+    def test_names_auto_completion(self):
+        # Make sure that names are properly completed
+        data = "1 2 3\n 4 5 6"
+        test = np.genfromtxt(TextIO(data),
+                             dtype=(int, float, int), names="a")
+        ctrl = np.array([(1, 2, 3), (4, 5, 6)],
+                        dtype=[('a', int), ('f0', float), ('f1', int)])
+        assert_equal(test, ctrl)
+
+    def test_names_with_usecols_bug1636(self):
+        # Make sure we pick up the right names w/ usecols
+        data = "A,B,C,D,E\n0,1,2,3,4\n0,1,2,3,4\n0,1,2,3,4"
+        ctrl_names = ("A", "C", "E")
+        test = np.genfromtxt(TextIO(data),
+                             dtype=(int, int, int), delimiter=",",
+                             usecols=(0, 2, 4), names=True)
+        assert_equal(test.dtype.names, ctrl_names)
+        #
+        test = np.genfromtxt(TextIO(data),
+                             dtype=(int, int, int), delimiter=",",
+                             usecols=("A", "C", "E"), names=True)
+        assert_equal(test.dtype.names, ctrl_names)
+        #
+        test = np.genfromtxt(TextIO(data),
+                             dtype=int, delimiter=",",
+                             usecols=("A", "C", "E"), names=True)
+        assert_equal(test.dtype.names, ctrl_names)
+
+    def test_fixed_width_names(self):
+        # Test fix-width w/ names
+        data = "    A    B   C\n    0    1 2.3\n   45   67   9."
+        kwargs = dict(delimiter=(5, 5, 4), names=True, dtype=None)
+        ctrl = np.array([(0, 1, 2.3), (45, 67, 9.)],
+                        dtype=[('A', int), ('B', int), ('C', float)])
+        test = np.genfromtxt(TextIO(data), **kwargs)
+        assert_equal(test, ctrl)
+        #
+        kwargs = dict(delimiter=5, names=True, dtype=None)
+        ctrl = np.array([(0, 1, 2.3), (45, 67, 9.)],
+                        dtype=[('A', int), ('B', int), ('C', float)])
+        test = np.genfromtxt(TextIO(data), **kwargs)
+        assert_equal(test, ctrl)
+
+    def test_filling_values(self):
+        # Test missing values
+        data = b"1, 2, 3\n1, , 5\n0, 6, \n"
+        kwargs = dict(delimiter=",", dtype=None, filling_values=-999)
+        ctrl = np.array([[1, 2, 3], [1, -999, 5], [0, 6, -999]], dtype=int)
+        test = np.genfromtxt(TextIO(data), **kwargs)
+        assert_equal(test, ctrl)
+
+    def test_comments_is_none(self):
+        # Github issue 329 (None was previously being converted to 'None').
+        with warnings.catch_warnings(record=True) as w:
+            warnings.filterwarnings('always', '', VisibleDeprecationWarning)
+            test = np.genfromtxt(TextIO("test1,testNonetherestofthedata"),
+                                 dtype=None, comments=None, delimiter=',',
+                                 encoding="bytes")
+            assert_(w[0].category is VisibleDeprecationWarning)
+        assert_equal(test[1], b'testNonetherestofthedata')
+        with warnings.catch_warnings(record=True) as w:
+            warnings.filterwarnings('always', '', VisibleDeprecationWarning)
+            test = np.genfromtxt(TextIO("test1, testNonetherestofthedata"),
+                                 dtype=None, comments=None, delimiter=',',
+                                 encoding="bytes")
+            assert_(w[0].category is VisibleDeprecationWarning)
+        assert_equal(test[1], b' testNonetherestofthedata')
+
+    def test_latin1(self):
+        latin1 = b'\xf6\xfc\xf6'
+        norm = b"norm1,norm2,norm3\n"
+        enc = b"test1,testNonethe" + latin1 + b",test3\n"
+        s = norm + enc + norm
+        with warnings.catch_warnings(record=True) as w:
+            warnings.filterwarnings('always', '', VisibleDeprecationWarning)
+            test = np.genfromtxt(TextIO(s),
+                                 dtype=None, comments=None, delimiter=',',
+                                 encoding="bytes")
+            assert_(w[0].category is VisibleDeprecationWarning)
+        assert_equal(test[1, 0], b"test1")
+        assert_equal(test[1, 1], b"testNonethe" + latin1)
+        assert_equal(test[1, 2], b"test3")
+        test = np.genfromtxt(TextIO(s),
+                             dtype=None, comments=None, delimiter=',',
+                             encoding='latin1')
+        assert_equal(test[1, 0], "test1")
+        assert_equal(test[1, 1], "testNonethe" + latin1.decode('latin1'))
+        assert_equal(test[1, 2], "test3")
+
+        with warnings.catch_warnings(record=True) as w:
+            warnings.filterwarnings('always', '', VisibleDeprecationWarning)
+            test = np.genfromtxt(TextIO(b"0,testNonethe" + latin1),
+                                 dtype=None, comments=None, delimiter=',',
+                                 encoding="bytes")
+            assert_(w[0].category is VisibleDeprecationWarning)
+        assert_equal(test['f0'], 0)
+        assert_equal(test['f1'], b"testNonethe" + latin1)
+
+    def test_binary_decode_autodtype(self):
+        utf16 = b'\xff\xfeh\x04 \x00i\x04 \x00j\x04'
+        v = self.loadfunc(BytesIO(utf16), dtype=None, encoding='UTF-16')
+        assert_array_equal(v, np.array(utf16.decode('UTF-16').split()))
+
+    def test_utf8_byte_encoding(self):
+        utf8 = b"\xcf\x96"
+        norm = b"norm1,norm2,norm3\n"
+        enc = b"test1,testNonethe" + utf8 + b",test3\n"
+        s = norm + enc + norm
+        with warnings.catch_warnings(record=True) as w:
+            warnings.filterwarnings('always', '', VisibleDeprecationWarning)
+            test = np.genfromtxt(TextIO(s),
+                                 dtype=None, comments=None, delimiter=',',
+                                 encoding="bytes")
+            assert_(w[0].category is VisibleDeprecationWarning)
+        ctl = np.array([
+                 [b'norm1', b'norm2', b'norm3'],
+                 [b'test1', b'testNonethe' + utf8, b'test3'],
+                 [b'norm1', b'norm2', b'norm3']])
+        assert_array_equal(test, ctl)
+
+    def test_utf8_file(self):
+        utf8 = b"\xcf\x96"
+        with temppath() as path:
+            with open(path, "wb") as f:
+                f.write((b"test1,testNonethe" + utf8 + b",test3\n") * 2)
+            test = np.genfromtxt(path, dtype=None, comments=None,
+                                 delimiter=',', encoding="UTF-8")
+            ctl = np.array([
+                     ["test1", "testNonethe" + utf8.decode("UTF-8"), "test3"],
+                     ["test1", "testNonethe" + utf8.decode("UTF-8"), "test3"]],
+                     dtype=np.str_)
+            assert_array_equal(test, ctl)
+
+            # test a mixed dtype
+            with open(path, "wb") as f:
+                f.write(b"0,testNonethe" + utf8)
+            test = np.genfromtxt(path, dtype=None, comments=None,
+                                 delimiter=',', encoding="UTF-8")
+            assert_equal(test['f0'], 0)
+            assert_equal(test['f1'], "testNonethe" + utf8.decode("UTF-8"))
+
+    def test_utf8_file_nodtype_unicode(self):
+        # bytes encoding with non-latin1 -> unicode upcast
+        utf8 = '\u03d6'
+        latin1 = '\xf6\xfc\xf6'
+
+        # skip test if cannot encode utf8 test string with preferred
+        # encoding. The preferred encoding is assumed to be the default
+        # encoding of open. Will need to change this for PyTest, maybe
+        # using pytest.mark.xfail(raises=***).
+        try:
+            encoding = locale.getpreferredencoding()
+            utf8.encode(encoding)
+        except (UnicodeError, ImportError):
+            pytest.skip('Skipping test_utf8_file_nodtype_unicode, '
+                        'unable to encode utf8 in preferred encoding')
+
+        with temppath() as path:
+            with open(path, "wt") as f:
+                f.write("norm1,norm2,norm3\n")
+                f.write("norm1," + latin1 + ",norm3\n")
+                f.write("test1,testNonethe" + utf8 + ",test3\n")
+            with warnings.catch_warnings(record=True) as w:
+                warnings.filterwarnings('always', '',
+                                        VisibleDeprecationWarning)
+                test = np.genfromtxt(path, dtype=None, comments=None,
+                                     delimiter=',', encoding="bytes")
+                # Check for warning when encoding not specified.
+                assert_(w[0].category is VisibleDeprecationWarning)
+            ctl = np.array([
+                     ["norm1", "norm2", "norm3"],
+                     ["norm1", latin1, "norm3"],
+                     ["test1", "testNonethe" + utf8, "test3"]],
+                     dtype=np.str_)
+            assert_array_equal(test, ctl)
+
+    @pytest.mark.filterwarnings("ignore:.*recfromtxt.*:DeprecationWarning")
+    def test_recfromtxt(self):
+        #
+        data = TextIO('A,B\n0,1\n2,3')
+        kwargs = dict(delimiter=",", missing_values="N/A", names=True)
+        test = recfromtxt(data, **kwargs)
+        control = np.array([(0, 1), (2, 3)],
+                           dtype=[('A', int), ('B', int)])
+        assert_(isinstance(test, np.recarray))
+        assert_equal(test, control)
+        #
+        data = TextIO('A,B\n0,1\n2,N/A')
+        test = recfromtxt(data, dtype=None, usemask=True, **kwargs)
+        control = ma.array([(0, 1), (2, -1)],
+                           mask=[(False, False), (False, True)],
+                           dtype=[('A', int), ('B', int)])
+        assert_equal(test, control)
+        assert_equal(test.mask, control.mask)
+        assert_equal(test.A, [0, 2])
+
+    @pytest.mark.filterwarnings("ignore:.*recfromcsv.*:DeprecationWarning")
+    def test_recfromcsv(self):
+        #
+        data = TextIO('A,B\n0,1\n2,3')
+        kwargs = dict(missing_values="N/A", names=True, case_sensitive=True,
+                      encoding="bytes")
+        test = recfromcsv(data, dtype=None, **kwargs)
+        control = np.array([(0, 1), (2, 3)],
+                           dtype=[('A', int), ('B', int)])
+        assert_(isinstance(test, np.recarray))
+        assert_equal(test, control)
+        #
+        data = TextIO('A,B\n0,1\n2,N/A')
+        test = recfromcsv(data, dtype=None, usemask=True, **kwargs)
+        control = ma.array([(0, 1), (2, -1)],
+                           mask=[(False, False), (False, True)],
+                           dtype=[('A', int), ('B', int)])
+        assert_equal(test, control)
+        assert_equal(test.mask, control.mask)
+        assert_equal(test.A, [0, 2])
+        #
+        data = TextIO('A,B\n0,1\n2,3')
+        test = recfromcsv(data, missing_values='N/A',)
+        control = np.array([(0, 1), (2, 3)],
+                           dtype=[('a', int), ('b', int)])
+        assert_(isinstance(test, np.recarray))
+        assert_equal(test, control)
+        #
+        data = TextIO('A,B\n0,1\n2,3')
+        dtype = [('a', int), ('b', float)]
+        test = recfromcsv(data, missing_values='N/A', dtype=dtype)
+        control = np.array([(0, 1), (2, 3)],
+                           dtype=dtype)
+        assert_(isinstance(test, np.recarray))
+        assert_equal(test, control)
+
+        #gh-10394
+        data = TextIO('color\n"red"\n"blue"')
+        test = recfromcsv(data, converters={0: lambda x: x.strip('\"')})
+        control = np.array([('red',), ('blue',)], dtype=[('color', (str, 4))])
+        assert_equal(test.dtype, control.dtype)
+        assert_equal(test, control)
+
+    def test_max_rows(self):
+        # Test the `max_rows` keyword argument.
+        data = '1 2\n3 4\n5 6\n7 8\n9 10\n'
+        txt = TextIO(data)
+        a1 = np.genfromtxt(txt, max_rows=3)
+        a2 = np.genfromtxt(txt)
+        assert_equal(a1, [[1, 2], [3, 4], [5, 6]])
+        assert_equal(a2, [[7, 8], [9, 10]])
+
+        # max_rows must be at least 1.
+        assert_raises(ValueError, np.genfromtxt, TextIO(data), max_rows=0)
+
+        # An input with several invalid rows.
+        data = '1 1\n2 2\n0 \n3 3\n4 4\n5  \n6  \n7  \n'
+
+        test = np.genfromtxt(TextIO(data), max_rows=2)
+        control = np.array([[1., 1.], [2., 2.]])
+        assert_equal(test, control)
+
+        # Test keywords conflict
+        assert_raises(ValueError, np.genfromtxt, TextIO(data), skip_footer=1,
+                      max_rows=4)
+
+        # Test with invalid value
+        assert_raises(ValueError, np.genfromtxt, TextIO(data), max_rows=4)
+
+        # Test with invalid not raise
+        with suppress_warnings() as sup:
+            sup.filter(ConversionWarning)
+
+            test = np.genfromtxt(TextIO(data), max_rows=4, invalid_raise=False)
+            control = np.array([[1., 1.], [2., 2.], [3., 3.], [4., 4.]])
+            assert_equal(test, control)
+
+            test = np.genfromtxt(TextIO(data), max_rows=5, invalid_raise=False)
+            control = np.array([[1., 1.], [2., 2.], [3., 3.], [4., 4.]])
+            assert_equal(test, control)
+
+        # Structured array with field names.
+        data = 'a b\n#c d\n1 1\n2 2\n#0 \n3 3\n4 4\n5  5\n'
+
+        # Test with header, names and comments
+        txt = TextIO(data)
+        test = np.genfromtxt(txt, skip_header=1, max_rows=3, names=True)
+        control = np.array([(1.0, 1.0), (2.0, 2.0), (3.0, 3.0)],
+                      dtype=[('c', ' should convert to float
+        # 2**34 = 17179869184 => should convert to int64
+        # 2**10 = 1024 => should convert to int (int32 on 32-bit systems,
+        #                 int64 on 64-bit systems)
+
+        data = TextIO('73786976294838206464 17179869184 1024')
+
+        test = np.genfromtxt(data, dtype=None)
+
+        assert_equal(test.dtype.names, ['f0', 'f1', 'f2'])
+
+        assert_(test.dtype['f0'] == float)
+        assert_(test.dtype['f1'] == np.int64)
+        assert_(test.dtype['f2'] == np.int_)
+
+        assert_allclose(test['f0'], 73786976294838206464.)
+        assert_equal(test['f1'], 17179869184)
+        assert_equal(test['f2'], 1024)
+
+    def test_unpack_float_data(self):
+        txt = TextIO("1,2,3\n4,5,6\n7,8,9\n0.0,1.0,2.0")
+        a, b, c = np.loadtxt(txt, delimiter=",", unpack=True)
+        assert_array_equal(a, np.array([1.0, 4.0, 7.0, 0.0]))
+        assert_array_equal(b, np.array([2.0, 5.0, 8.0, 1.0]))
+        assert_array_equal(c, np.array([3.0, 6.0, 9.0, 2.0]))
+
+    def test_unpack_structured(self):
+        # Regression test for gh-4341
+        # Unpacking should work on structured arrays
+        txt = TextIO("M 21 72\nF 35 58")
+        dt = {'names': ('a', 'b', 'c'), 'formats': ('S1', 'i4', 'f4')}
+        a, b, c = np.genfromtxt(txt, dtype=dt, unpack=True)
+        assert_equal(a.dtype, np.dtype('S1'))
+        assert_equal(b.dtype, np.dtype('i4'))
+        assert_equal(c.dtype, np.dtype('f4'))
+        assert_array_equal(a, np.array([b'M', b'F']))
+        assert_array_equal(b, np.array([21, 35]))
+        assert_array_equal(c, np.array([72.,  58.]))
+
+    def test_unpack_auto_dtype(self):
+        # Regression test for gh-4341
+        # Unpacking should work when dtype=None
+        txt = TextIO("M 21 72.\nF 35 58.")
+        expected = (np.array(["M", "F"]), np.array([21, 35]), np.array([72., 58.]))
+        test = np.genfromtxt(txt, dtype=None, unpack=True, encoding="utf-8")
+        for arr, result in zip(expected, test):
+            assert_array_equal(arr, result)
+            assert_equal(arr.dtype, result.dtype)
+
+    def test_unpack_single_name(self):
+        # Regression test for gh-4341
+        # Unpacking should work when structured dtype has only one field
+        txt = TextIO("21\n35")
+        dt = {'names': ('a',), 'formats': ('i4',)}
+        expected = np.array([21, 35], dtype=np.int32)
+        test = np.genfromtxt(txt, dtype=dt, unpack=True)
+        assert_array_equal(expected, test)
+        assert_equal(expected.dtype, test.dtype)
+
+    def test_squeeze_scalar(self):
+        # Regression test for gh-4341
+        # Unpacking a scalar should give zero-dim output,
+        # even if dtype is structured
+        txt = TextIO("1")
+        dt = {'names': ('a',), 'formats': ('i4',)}
+        expected = np.array((1,), dtype=np.int32)
+        test = np.genfromtxt(txt, dtype=dt, unpack=True)
+        assert_array_equal(expected, test)
+        assert_equal((), test.shape)
+        assert_equal(expected.dtype, test.dtype)
+
+    @pytest.mark.parametrize("ndim", [0, 1, 2])
+    def test_ndmin_keyword(self, ndim: int):
+        # lets have the same behaviour of ndmin as loadtxt
+        # as they should be the same for non-missing values
+        txt = "42"
+
+        a = np.loadtxt(StringIO(txt), ndmin=ndim)
+        b = np.genfromtxt(StringIO(txt), ndmin=ndim)
+
+        assert_array_equal(a, b)
+
+
+class TestPathUsage:
+    # Test that pathlib.Path can be used
+    def test_loadtxt(self):
+        with temppath(suffix='.txt') as path:
+            path = Path(path)
+            a = np.array([[1.1, 2], [3, 4]])
+            np.savetxt(path, a)
+            x = np.loadtxt(path)
+            assert_array_equal(x, a)
+
+    def test_save_load(self):
+        # Test that pathlib.Path instances can be used with save.
+        with temppath(suffix='.npy') as path:
+            path = Path(path)
+            a = np.array([[1, 2], [3, 4]], int)
+            np.save(path, a)
+            data = np.load(path)
+            assert_array_equal(data, a)
+
+    def test_save_load_memmap(self):
+        # Test that pathlib.Path instances can be loaded mem-mapped.
+        with temppath(suffix='.npy') as path:
+            path = Path(path)
+            a = np.array([[1, 2], [3, 4]], int)
+            np.save(path, a)
+            data = np.load(path, mmap_mode='r')
+            assert_array_equal(data, a)
+            # close the mem-mapped file
+            del data
+            if IS_PYPY:
+                break_cycles()
+                break_cycles()
+
+    @pytest.mark.xfail(IS_WASM, reason="memmap doesn't work correctly")
+    @pytest.mark.parametrize("filename_type", [Path, str])
+    def test_save_load_memmap_readwrite(self, filename_type):
+        with temppath(suffix='.npy') as path:
+            path = filename_type(path)
+            a = np.array([[1, 2], [3, 4]], int)
+            np.save(path, a)
+            b = np.load(path, mmap_mode='r+')
+            a[0][0] = 5
+            b[0][0] = 5
+            del b  # closes the file
+            if IS_PYPY:
+                break_cycles()
+                break_cycles()
+            data = np.load(path)
+            assert_array_equal(data, a)
+
+    @pytest.mark.parametrize("filename_type", [Path, str])
+    def test_savez_load(self, filename_type):
+        with temppath(suffix='.npz') as path:
+            path = filename_type(path)
+            np.savez(path, lab='place holder')
+            with np.load(path) as data:
+                assert_array_equal(data['lab'], 'place holder')
+
+    @pytest.mark.parametrize("filename_type", [Path, str])
+    def test_savez_compressed_load(self, filename_type):
+        with temppath(suffix='.npz') as path:
+            path = filename_type(path)
+            np.savez_compressed(path, lab='place holder')
+            data = np.load(path)
+            assert_array_equal(data['lab'], 'place holder')
+            data.close()
+
+    @pytest.mark.parametrize("filename_type", [Path, str])
+    def test_genfromtxt(self, filename_type):
+        with temppath(suffix='.txt') as path:
+            path = filename_type(path)
+            a = np.array([(1, 2), (3, 4)])
+            np.savetxt(path, a)
+            data = np.genfromtxt(path)
+            assert_array_equal(a, data)
+
+    @pytest.mark.parametrize("filename_type", [Path, str])
+    @pytest.mark.filterwarnings("ignore:.*recfromtxt.*:DeprecationWarning")
+    def test_recfromtxt(self, filename_type):
+        with temppath(suffix='.txt') as path:
+            path = filename_type(path)
+            with open(path, 'w') as f:
+                f.write('A,B\n0,1\n2,3')
+
+            kwargs = dict(delimiter=",", missing_values="N/A", names=True)
+            test = recfromtxt(path, **kwargs)
+            control = np.array([(0, 1), (2, 3)],
+                               dtype=[('A', int), ('B', int)])
+            assert_(isinstance(test, np.recarray))
+            assert_equal(test, control)
+
+    @pytest.mark.parametrize("filename_type", [Path, str])
+    @pytest.mark.filterwarnings("ignore:.*recfromcsv.*:DeprecationWarning")
+    def test_recfromcsv(self, filename_type):
+        with temppath(suffix='.txt') as path:
+            path = filename_type(path)
+            with open(path, 'w') as f:
+                f.write('A,B\n0,1\n2,3')
+
+            kwargs = dict(
+                missing_values="N/A", names=True, case_sensitive=True
+            )
+            test = recfromcsv(path, dtype=None, **kwargs)
+            control = np.array([(0, 1), (2, 3)],
+                               dtype=[('A', int), ('B', int)])
+            assert_(isinstance(test, np.recarray))
+            assert_equal(test, control)
+
+
+def test_gzip_load():
+    a = np.random.random((5, 5))
+
+    s = BytesIO()
+    f = gzip.GzipFile(fileobj=s, mode="w")
+
+    np.save(f, a)
+    f.close()
+    s.seek(0)
+
+    f = gzip.GzipFile(fileobj=s, mode="r")
+    assert_array_equal(np.load(f), a)
+
+
+# These next two classes encode the minimal API needed to save()/load() arrays.
+# The `test_ducktyping` ensures they work correctly
+class JustWriter:
+    def __init__(self, base):
+        self.base = base
+
+    def write(self, s):
+        return self.base.write(s)
+
+    def flush(self):
+        return self.base.flush()
+
+class JustReader:
+    def __init__(self, base):
+        self.base = base
+
+    def read(self, n):
+        return self.base.read(n)
+
+    def seek(self, off, whence=0):
+        return self.base.seek(off, whence)
+
+
+def test_ducktyping():
+    a = np.random.random((5, 5))
+
+    s = BytesIO()
+    f = JustWriter(s)
+
+    np.save(f, a)
+    f.flush()
+    s.seek(0)
+
+    f = JustReader(s)
+    assert_array_equal(np.load(f), a)
+
+
+
+def test_gzip_loadtxt():
+    # Thanks to another windows brokenness, we can't use
+    # NamedTemporaryFile: a file created from this function cannot be
+    # reopened by another open call. So we first put the gzipped string
+    # of the test reference array, write it to a securely opened file,
+    # which is then read from by the loadtxt function
+    s = BytesIO()
+    g = gzip.GzipFile(fileobj=s, mode='w')
+    g.write(b'1 2 3\n')
+    g.close()
+
+    s.seek(0)
+    with temppath(suffix='.gz') as name:
+        with open(name, 'wb') as f:
+            f.write(s.read())
+        res = np.loadtxt(name)
+    s.close()
+
+    assert_array_equal(res, [1, 2, 3])
+
+
+def test_gzip_loadtxt_from_string():
+    s = BytesIO()
+    f = gzip.GzipFile(fileobj=s, mode="w")
+    f.write(b'1 2 3\n')
+    f.close()
+    s.seek(0)
+
+    f = gzip.GzipFile(fileobj=s, mode="r")
+    assert_array_equal(np.loadtxt(f), [1, 2, 3])
+
+
+def test_npzfile_dict():
+    s = BytesIO()
+    x = np.zeros((3, 3))
+    y = np.zeros((3, 3))
+
+    np.savez(s, x=x, y=y)
+    s.seek(0)
+
+    z = np.load(s)
+
+    assert_('x' in z)
+    assert_('y' in z)
+    assert_('x' in z.keys())
+    assert_('y' in z.keys())
+
+    for f, a in z.items():
+        assert_(f in ['x', 'y'])
+        assert_equal(a.shape, (3, 3))
+
+    for a in z.values():
+        assert_equal(a.shape, (3, 3))
+
+    assert_(len(z.items()) == 2)
+
+    for f in z:
+        assert_(f in ['x', 'y'])
+
+    assert_('x' in z.keys())
+    assert (z.get('x') == z['x']).all()
+
+
+@pytest.mark.skipif(not HAS_REFCOUNT, reason="Python lacks refcounts")
+def test_load_refcount():
+    # Check that objects returned by np.load are directly freed based on
+    # their refcount, rather than needing the gc to collect them.
+
+    f = BytesIO()
+    np.savez(f, [1, 2, 3])
+    f.seek(0)
+
+    with assert_no_gc_cycles():
+        np.load(f)
+
+    f.seek(0)
+    dt = [("a", 'u1', 2), ("b", 'u1', 2)]
+    with assert_no_gc_cycles():
+        x = np.loadtxt(TextIO("0 1 2 3"), dtype=dt)
+        assert_equal(x, np.array([((0, 1), (2, 3))], dtype=dt))
+
+def test_load_multiple_arrays_until_eof():
+    f = BytesIO()
+    np.save(f, 1)
+    np.save(f, 2)
+    f.seek(0)
+    assert np.load(f) == 1
+    assert np.load(f) == 2
+    with pytest.raises(EOFError):
+        np.load(f)
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/tests/test_loadtxt.py b/venv/lib/python3.12/site-packages/numpy/lib/tests/test_loadtxt.py
new file mode 100644
index 00000000..aba00c42
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/lib/tests/test_loadtxt.py
@@ -0,0 +1,1075 @@
+"""
+Tests specific to `np.loadtxt` added during the move of loadtxt to be backed
+by C code.
+These tests complement those found in `test_io.py`.
+"""
+
+import sys
+import os
+import pytest
+from tempfile import NamedTemporaryFile, mkstemp
+from io import StringIO
+
+import numpy as np
+from numpy.ma.testutils import assert_equal
+from numpy.testing import assert_array_equal, HAS_REFCOUNT, IS_PYPY
+
+
+def test_scientific_notation():
+    """Test that both 'e' and 'E' are parsed correctly."""
+    data = StringIO(
+        
+            "1.0e-1,2.0E1,3.0\n"
+            "4.0e-2,5.0E-1,6.0\n"
+            "7.0e-3,8.0E1,9.0\n"
+            "0.0e-4,1.0E-1,2.0"
+        
+    )
+    expected = np.array(
+        [[0.1, 20., 3.0], [0.04, 0.5, 6], [0.007, 80., 9], [0, 0.1, 2]]
+    )
+    assert_array_equal(np.loadtxt(data, delimiter=","), expected)
+
+
+@pytest.mark.parametrize("comment", ["..", "//", "@-", "this is a comment:"])
+def test_comment_multiple_chars(comment):
+    content = "# IGNORE\n1.5, 2.5# ABC\n3.0,4.0# XXX\n5.5,6.0\n"
+    txt = StringIO(content.replace("#", comment))
+    a = np.loadtxt(txt, delimiter=",", comments=comment)
+    assert_equal(a, [[1.5, 2.5], [3.0, 4.0], [5.5, 6.0]])
+
+
+@pytest.fixture
+def mixed_types_structured():
+    """
+    Fixture providing hetergeneous input data with a structured dtype, along
+    with the associated structured array.
+    """
+    data = StringIO(
+        
+            "1000;2.4;alpha;-34\n"
+            "2000;3.1;beta;29\n"
+            "3500;9.9;gamma;120\n"
+            "4090;8.1;delta;0\n"
+            "5001;4.4;epsilon;-99\n"
+            "6543;7.8;omega;-1\n"
+        
+    )
+    dtype = np.dtype(
+        [('f0', np.uint16), ('f1', np.float64), ('f2', 'S7'), ('f3', np.int8)]
+    )
+    expected = np.array(
+        [
+            (1000, 2.4, "alpha", -34),
+            (2000, 3.1, "beta", 29),
+            (3500, 9.9, "gamma", 120),
+            (4090, 8.1, "delta", 0),
+            (5001, 4.4, "epsilon", -99),
+            (6543, 7.8, "omega", -1)
+        ],
+        dtype=dtype
+    )
+    return data, dtype, expected
+
+
+@pytest.mark.parametrize('skiprows', [0, 1, 2, 3])
+def test_structured_dtype_and_skiprows_no_empty_lines(
+        skiprows, mixed_types_structured):
+    data, dtype, expected = mixed_types_structured
+    a = np.loadtxt(data, dtype=dtype, delimiter=";", skiprows=skiprows)
+    assert_array_equal(a, expected[skiprows:])
+
+
+def test_unpack_structured(mixed_types_structured):
+    data, dtype, expected = mixed_types_structured
+
+    a, b, c, d = np.loadtxt(data, dtype=dtype, delimiter=";", unpack=True)
+    assert_array_equal(a, expected["f0"])
+    assert_array_equal(b, expected["f1"])
+    assert_array_equal(c, expected["f2"])
+    assert_array_equal(d, expected["f3"])
+
+
+def test_structured_dtype_with_shape():
+    dtype = np.dtype([("a", "u1", 2), ("b", "u1", 2)])
+    data = StringIO("0,1,2,3\n6,7,8,9\n")
+    expected = np.array([((0, 1), (2, 3)), ((6, 7), (8, 9))], dtype=dtype)
+    assert_array_equal(np.loadtxt(data, delimiter=",", dtype=dtype), expected)
+
+
+def test_structured_dtype_with_multi_shape():
+    dtype = np.dtype([("a", "u1", (2, 2))])
+    data = StringIO("0 1 2 3\n")
+    expected = np.array([(((0, 1), (2, 3)),)], dtype=dtype)
+    assert_array_equal(np.loadtxt(data, dtype=dtype), expected)
+
+
+def test_nested_structured_subarray():
+    # Test from gh-16678
+    point = np.dtype([('x', float), ('y', float)])
+    dt = np.dtype([('code', int), ('points', point, (2,))])
+    data = StringIO("100,1,2,3,4\n200,5,6,7,8\n")
+    expected = np.array(
+        [
+            (100, [(1., 2.), (3., 4.)]),
+            (200, [(5., 6.), (7., 8.)]),
+        ],
+        dtype=dt
+    )
+    assert_array_equal(np.loadtxt(data, dtype=dt, delimiter=","), expected)
+
+
+def test_structured_dtype_offsets():
+    # An aligned structured dtype will have additional padding
+    dt = np.dtype("i1, i4, i1, i4, i1, i4", align=True)
+    data = StringIO("1,2,3,4,5,6\n7,8,9,10,11,12\n")
+    expected = np.array([(1, 2, 3, 4, 5, 6), (7, 8, 9, 10, 11, 12)], dtype=dt)
+    assert_array_equal(np.loadtxt(data, delimiter=",", dtype=dt), expected)
+
+
+@pytest.mark.parametrize("param", ("skiprows", "max_rows"))
+def test_exception_negative_row_limits(param):
+    """skiprows and max_rows should raise for negative parameters."""
+    with pytest.raises(ValueError, match="argument must be nonnegative"):
+        np.loadtxt("foo.bar", **{param: -3})
+
+
+@pytest.mark.parametrize("param", ("skiprows", "max_rows"))
+def test_exception_noninteger_row_limits(param):
+    with pytest.raises(TypeError, match="argument must be an integer"):
+        np.loadtxt("foo.bar", **{param: 1.0})
+
+
+@pytest.mark.parametrize(
+    "data, shape",
+    [
+        ("1 2 3 4 5\n", (1, 5)),  # Single row
+        ("1\n2\n3\n4\n5\n", (5, 1)),  # Single column
+    ]
+)
+def test_ndmin_single_row_or_col(data, shape):
+    arr = np.array([1, 2, 3, 4, 5])
+    arr2d = arr.reshape(shape)
+
+    assert_array_equal(np.loadtxt(StringIO(data), dtype=int), arr)
+    assert_array_equal(np.loadtxt(StringIO(data), dtype=int, ndmin=0), arr)
+    assert_array_equal(np.loadtxt(StringIO(data), dtype=int, ndmin=1), arr)
+    assert_array_equal(np.loadtxt(StringIO(data), dtype=int, ndmin=2), arr2d)
+
+
+@pytest.mark.parametrize("badval", [-1, 3, None, "plate of shrimp"])
+def test_bad_ndmin(badval):
+    with pytest.raises(ValueError, match="Illegal value of ndmin keyword"):
+        np.loadtxt("foo.bar", ndmin=badval)
+
+
+@pytest.mark.parametrize(
+    "ws",
+    (
+            " ",  # space
+            "\t",  # tab
+            "\u2003",  # em
+            "\u00A0",  # non-break
+            "\u3000",  # ideographic space
+    )
+)
+def test_blank_lines_spaces_delimit(ws):
+    txt = StringIO(
+        f"1 2{ws}30\n\n{ws}\n"
+        f"4 5 60{ws}\n  {ws}  \n"
+        f"7 8 {ws} 90\n  # comment\n"
+        f"3 2 1"
+    )
+    # NOTE: It is unclear that the `  # comment` should succeed. Except
+    #       for delimiter=None, which should use any whitespace (and maybe
+    #       should just be implemented closer to Python
+    expected = np.array([[1, 2, 30], [4, 5, 60], [7, 8, 90], [3, 2, 1]])
+    assert_equal(
+        np.loadtxt(txt, dtype=int, delimiter=None, comments="#"), expected
+    )
+
+
+def test_blank_lines_normal_delimiter():
+    txt = StringIO('1,2,30\n\n4,5,60\n\n7,8,90\n# comment\n3,2,1')
+    expected = np.array([[1, 2, 30], [4, 5, 60], [7, 8, 90], [3, 2, 1]])
+    assert_equal(
+        np.loadtxt(txt, dtype=int, delimiter=',', comments="#"), expected
+    )
+
+
+@pytest.mark.parametrize("dtype", (float, object))
+def test_maxrows_no_blank_lines(dtype):
+    txt = StringIO("1.5,2.5\n3.0,4.0\n5.5,6.0")
+    res = np.loadtxt(txt, dtype=dtype, delimiter=",", max_rows=2)
+    assert_equal(res.dtype, dtype)
+    assert_equal(res, np.array([["1.5", "2.5"], ["3.0", "4.0"]], dtype=dtype))
+
+
+@pytest.mark.skipif(IS_PYPY and sys.implementation.version <= (7, 3, 8),
+                    reason="PyPy bug in error formatting")
+@pytest.mark.parametrize("dtype", (np.dtype("f8"), np.dtype("i2")))
+def test_exception_message_bad_values(dtype):
+    txt = StringIO("1,2\n3,XXX\n5,6")
+    msg = f"could not convert string 'XXX' to {dtype} at row 1, column 2"
+    with pytest.raises(ValueError, match=msg):
+        np.loadtxt(txt, dtype=dtype, delimiter=",")
+
+
+def test_converters_negative_indices():
+    txt = StringIO('1.5,2.5\n3.0,XXX\n5.5,6.0')
+    conv = {-1: lambda s: np.nan if s == 'XXX' else float(s)}
+    expected = np.array([[1.5, 2.5], [3.0, np.nan], [5.5, 6.0]])
+    res = np.loadtxt(txt, dtype=np.float64, delimiter=",", converters=conv)
+    assert_equal(res, expected)
+
+
+def test_converters_negative_indices_with_usecols():
+    txt = StringIO('1.5,2.5,3.5\n3.0,4.0,XXX\n5.5,6.0,7.5\n')
+    conv = {-1: lambda s: np.nan if s == 'XXX' else float(s)}
+    expected = np.array([[1.5, 3.5], [3.0, np.nan], [5.5, 7.5]])
+    res = np.loadtxt(
+        txt,
+        dtype=np.float64,
+        delimiter=",",
+        converters=conv,
+        usecols=[0, -1],
+    )
+    assert_equal(res, expected)
+
+    # Second test with variable number of rows:
+    res = np.loadtxt(StringIO('''0,1,2\n0,1,2,3,4'''), delimiter=",",
+                     usecols=[0, -1], converters={-1: (lambda x: -1)})
+    assert_array_equal(res, [[0, -1], [0, -1]])
+
+
+def test_ragged_error():
+    rows = ["1,2,3", "1,2,3", "4,3,2,1"]
+    with pytest.raises(ValueError,
+            match="the number of columns changed from 3 to 4 at row 3"):
+        np.loadtxt(rows, delimiter=",")
+
+
+def test_ragged_usecols():
+    # usecols, and negative ones, work even with varying number of columns.
+    txt = StringIO("0,0,XXX\n0,XXX,0,XXX\n0,XXX,XXX,0,XXX\n")
+    expected = np.array([[0, 0], [0, 0], [0, 0]])
+    res = np.loadtxt(txt, dtype=float, delimiter=",", usecols=[0, -2])
+    assert_equal(res, expected)
+
+    txt = StringIO("0,0,XXX\n0\n0,XXX,XXX,0,XXX\n")
+    with pytest.raises(ValueError,
+                match="invalid column index -2 at row 2 with 1 columns"):
+        # There is no -2 column in the second row:
+        np.loadtxt(txt, dtype=float, delimiter=",", usecols=[0, -2])
+
+
+def test_empty_usecols():
+    txt = StringIO("0,0,XXX\n0,XXX,0,XXX\n0,XXX,XXX,0,XXX\n")
+    res = np.loadtxt(txt, dtype=np.dtype([]), delimiter=",", usecols=[])
+    assert res.shape == (3,)
+    assert res.dtype == np.dtype([])
+
+
+@pytest.mark.parametrize("c1", ["a", "の", "🫕"])
+@pytest.mark.parametrize("c2", ["a", "の", "🫕"])
+def test_large_unicode_characters(c1, c2):
+    # c1 and c2 span ascii, 16bit and 32bit range.
+    txt = StringIO(f"a,{c1},c,1.0\ne,{c2},2.0,g")
+    res = np.loadtxt(txt, dtype=np.dtype('U12'), delimiter=",")
+    expected = np.array(
+        [f"a,{c1},c,1.0".split(","), f"e,{c2},2.0,g".split(",")],
+        dtype=np.dtype('U12')
+    )
+    assert_equal(res, expected)
+
+
+def test_unicode_with_converter():
+    txt = StringIO("cat,dog\nαβγ,δεζ\nabc,def\n")
+    conv = {0: lambda s: s.upper()}
+    res = np.loadtxt(
+        txt,
+        dtype=np.dtype("U12"),
+        converters=conv,
+        delimiter=",",
+        encoding=None
+    )
+    expected = np.array([['CAT', 'dog'], ['ΑΒΓ', 'δεζ'], ['ABC', 'def']])
+    assert_equal(res, expected)
+
+
+def test_converter_with_structured_dtype():
+    txt = StringIO('1.5,2.5,Abc\n3.0,4.0,dEf\n5.5,6.0,ghI\n')
+    dt = np.dtype([('m', np.int32), ('r', np.float32), ('code', 'U8')])
+    conv = {0: lambda s: int(10*float(s)), -1: lambda s: s.upper()}
+    res = np.loadtxt(txt, dtype=dt, delimiter=",", converters=conv)
+    expected = np.array(
+        [(15, 2.5, 'ABC'), (30, 4.0, 'DEF'), (55, 6.0, 'GHI')], dtype=dt
+    )
+    assert_equal(res, expected)
+
+
+def test_converter_with_unicode_dtype():
+    """
+    With the 'bytes' encoding, tokens are encoded prior to being
+    passed to the converter. This means that the output of the converter may
+    be bytes instead of unicode as expected by `read_rows`.
+
+    This test checks that outputs from the above scenario are properly decoded
+    prior to parsing by `read_rows`.
+    """
+    txt = StringIO('abc,def\nrst,xyz')
+    conv = bytes.upper
+    res = np.loadtxt(
+            txt, dtype=np.dtype("U3"), converters=conv, delimiter=",",
+            encoding="bytes")
+    expected = np.array([['ABC', 'DEF'], ['RST', 'XYZ']])
+    assert_equal(res, expected)
+
+
+def test_read_huge_row():
+    row = "1.5, 2.5," * 50000
+    row = row[:-1] + "\n"
+    txt = StringIO(row * 2)
+    res = np.loadtxt(txt, delimiter=",", dtype=float)
+    assert_equal(res, np.tile([1.5, 2.5], (2, 50000)))
+
+
+@pytest.mark.parametrize("dtype", "edfgFDG")
+def test_huge_float(dtype):
+    # Covers a non-optimized path that is rarely taken:
+    field = "0" * 1000 + ".123456789"
+    dtype = np.dtype(dtype)
+    value = np.loadtxt([field], dtype=dtype)[()]
+    assert value == dtype.type("0.123456789")
+
+
+@pytest.mark.parametrize(
+    ("given_dtype", "expected_dtype"),
+    [
+        ("S", np.dtype("S5")),
+        ("U", np.dtype("U5")),
+    ],
+)
+def test_string_no_length_given(given_dtype, expected_dtype):
+    """
+    The given dtype is just 'S' or 'U' with no length. In these cases, the
+    length of the resulting dtype is determined by the longest string found
+    in the file.
+    """
+    txt = StringIO("AAA,5-1\nBBBBB,0-3\nC,4-9\n")
+    res = np.loadtxt(txt, dtype=given_dtype, delimiter=",")
+    expected = np.array(
+        [['AAA', '5-1'], ['BBBBB', '0-3'], ['C', '4-9']], dtype=expected_dtype
+    )
+    assert_equal(res, expected)
+    assert_equal(res.dtype, expected_dtype)
+
+
+def test_float_conversion():
+    """
+    Some tests that the conversion to float64 works as accurately as the
+    Python built-in `float` function. In a naive version of the float parser,
+    these strings resulted in values that were off by an ULP or two.
+    """
+    strings = [
+        '0.9999999999999999',
+        '9876543210.123456',
+        '5.43215432154321e+300',
+        '0.901',
+        '0.333',
+    ]
+    txt = StringIO('\n'.join(strings))
+    res = np.loadtxt(txt)
+    expected = np.array([float(s) for s in strings])
+    assert_equal(res, expected)
+
+
+def test_bool():
+    # Simple test for bool via integer
+    txt = StringIO("1, 0\n10, -1")
+    res = np.loadtxt(txt, dtype=bool, delimiter=",")
+    assert res.dtype == bool
+    assert_array_equal(res, [[True, False], [True, True]])
+    # Make sure we use only 1 and 0 on the byte level:
+    assert_array_equal(res.view(np.uint8), [[1, 0], [1, 1]])
+
+
+@pytest.mark.skipif(IS_PYPY and sys.implementation.version <= (7, 3, 8),
+                    reason="PyPy bug in error formatting")
+@pytest.mark.parametrize("dtype", np.typecodes["AllInteger"])
+@pytest.mark.filterwarnings("error:.*integer via a float.*:DeprecationWarning")
+def test_integer_signs(dtype):
+    dtype = np.dtype(dtype)
+    assert np.loadtxt(["+2"], dtype=dtype) == 2
+    if dtype.kind == "u":
+        with pytest.raises(ValueError):
+            np.loadtxt(["-1\n"], dtype=dtype)
+    else:
+        assert np.loadtxt(["-2\n"], dtype=dtype) == -2
+
+    for sign in ["++", "+-", "--", "-+"]:
+        with pytest.raises(ValueError):
+            np.loadtxt([f"{sign}2\n"], dtype=dtype)
+
+
+@pytest.mark.skipif(IS_PYPY and sys.implementation.version <= (7, 3, 8),
+                    reason="PyPy bug in error formatting")
+@pytest.mark.parametrize("dtype", np.typecodes["AllInteger"])
+@pytest.mark.filterwarnings("error:.*integer via a float.*:DeprecationWarning")
+def test_implicit_cast_float_to_int_fails(dtype):
+    txt = StringIO("1.0, 2.1, 3.7\n4, 5, 6")
+    with pytest.raises(ValueError):
+        np.loadtxt(txt, dtype=dtype, delimiter=",")
+
+@pytest.mark.parametrize("dtype", (np.complex64, np.complex128))
+@pytest.mark.parametrize("with_parens", (False, True))
+def test_complex_parsing(dtype, with_parens):
+    s = "(1.0-2.5j),3.75,(7+-5.0j)\n(4),(-19e2j),(0)"
+    if not with_parens:
+        s = s.replace("(", "").replace(")", "")
+
+    res = np.loadtxt(StringIO(s), dtype=dtype, delimiter=",")
+    expected = np.array(
+        [[1.0-2.5j, 3.75, 7-5j], [4.0, -1900j, 0]], dtype=dtype
+    )
+    assert_equal(res, expected)
+
+
+def test_read_from_generator():
+    def gen():
+        for i in range(4):
+            yield f"{i},{2*i},{i**2}"
+
+    res = np.loadtxt(gen(), dtype=int, delimiter=",")
+    expected = np.array([[0, 0, 0], [1, 2, 1], [2, 4, 4], [3, 6, 9]])
+    assert_equal(res, expected)
+
+
+def test_read_from_generator_multitype():
+    def gen():
+        for i in range(3):
+            yield f"{i} {i / 4}"
+
+    res = np.loadtxt(gen(), dtype="i, d", delimiter=" ")
+    expected = np.array([(0, 0.0), (1, 0.25), (2, 0.5)], dtype="i, d")
+    assert_equal(res, expected)
+
+
+def test_read_from_bad_generator():
+    def gen():
+        yield from ["1,2", b"3, 5", 12738]
+
+    with pytest.raises(
+            TypeError, match=r"non-string returned while reading data"):
+        np.loadtxt(gen(), dtype="i, i", delimiter=",")
+
+
+@pytest.mark.skipif(not HAS_REFCOUNT, reason="Python lacks refcounts")
+def test_object_cleanup_on_read_error():
+    sentinel = object()
+    already_read = 0
+
+    def conv(x):
+        nonlocal already_read
+        if already_read > 4999:
+            raise ValueError("failed half-way through!")
+        already_read += 1
+        return sentinel
+
+    txt = StringIO("x\n" * 10000)
+
+    with pytest.raises(ValueError, match="at row 5000, column 1"):
+        np.loadtxt(txt, dtype=object, converters={0: conv})
+
+    assert sys.getrefcount(sentinel) == 2
+
+
+@pytest.mark.skipif(IS_PYPY and sys.implementation.version <= (7, 3, 8),
+                    reason="PyPy bug in error formatting")
+def test_character_not_bytes_compatible():
+    """Test exception when a character cannot be encoded as 'S'."""
+    data = StringIO("–")  # == \u2013
+    with pytest.raises(ValueError):
+        np.loadtxt(data, dtype="S5")
+
+
+@pytest.mark.parametrize("conv", (0, [float], ""))
+def test_invalid_converter(conv):
+    msg = (
+        "converters must be a dictionary mapping columns to converter "
+        "functions or a single callable."
+    )
+    with pytest.raises(TypeError, match=msg):
+        np.loadtxt(StringIO("1 2\n3 4"), converters=conv)
+
+
+@pytest.mark.skipif(IS_PYPY and sys.implementation.version <= (7, 3, 8),
+                    reason="PyPy bug in error formatting")
+def test_converters_dict_raises_non_integer_key():
+    with pytest.raises(TypeError, match="keys of the converters dict"):
+        np.loadtxt(StringIO("1 2\n3 4"), converters={"a": int})
+    with pytest.raises(TypeError, match="keys of the converters dict"):
+        np.loadtxt(StringIO("1 2\n3 4"), converters={"a": int}, usecols=0)
+
+
+@pytest.mark.parametrize("bad_col_ind", (3, -3))
+def test_converters_dict_raises_non_col_key(bad_col_ind):
+    data = StringIO("1 2\n3 4")
+    with pytest.raises(ValueError, match="converter specified for column"):
+        np.loadtxt(data, converters={bad_col_ind: int})
+
+
+def test_converters_dict_raises_val_not_callable():
+    with pytest.raises(TypeError,
+                match="values of the converters dictionary must be callable"):
+        np.loadtxt(StringIO("1 2\n3 4"), converters={0: 1})
+
+
+@pytest.mark.parametrize("q", ('"', "'", "`"))
+def test_quoted_field(q):
+    txt = StringIO(
+        f"{q}alpha, x{q}, 2.5\n{q}beta, y{q}, 4.5\n{q}gamma, z{q}, 5.0\n"
+    )
+    dtype = np.dtype([('f0', 'U8'), ('f1', np.float64)])
+    expected = np.array(
+        [("alpha, x", 2.5), ("beta, y", 4.5), ("gamma, z", 5.0)], dtype=dtype
+    )
+
+    res = np.loadtxt(txt, dtype=dtype, delimiter=",", quotechar=q)
+    assert_array_equal(res, expected)
+
+
+@pytest.mark.parametrize("q", ('"', "'", "`"))
+def test_quoted_field_with_whitepace_delimiter(q):
+    txt = StringIO(
+        f"{q}alpha, x{q}     2.5\n{q}beta, y{q} 4.5\n{q}gamma, z{q}   5.0\n"
+    )
+    dtype = np.dtype([('f0', 'U8'), ('f1', np.float64)])
+    expected = np.array(
+        [("alpha, x", 2.5), ("beta, y", 4.5), ("gamma, z", 5.0)], dtype=dtype
+    )
+
+    res = np.loadtxt(txt, dtype=dtype, delimiter=None, quotechar=q)
+    assert_array_equal(res, expected)
+
+
+def test_quote_support_default():
+    """Support for quoted fields is disabled by default."""
+    txt = StringIO('"lat,long", 45, 30\n')
+    dtype = np.dtype([('f0', 'U24'), ('f1', np.float64), ('f2', np.float64)])
+
+    with pytest.raises(ValueError,
+            match="the dtype passed requires 3 columns but 4 were"):
+        np.loadtxt(txt, dtype=dtype, delimiter=",")
+
+    # Enable quoting support with non-None value for quotechar param
+    txt.seek(0)
+    expected = np.array([("lat,long", 45., 30.)], dtype=dtype)
+
+    res = np.loadtxt(txt, dtype=dtype, delimiter=",", quotechar='"')
+    assert_array_equal(res, expected)
+
+
+@pytest.mark.skipif(IS_PYPY and sys.implementation.version <= (7, 3, 8),
+                    reason="PyPy bug in error formatting")
+def test_quotechar_multichar_error():
+    txt = StringIO("1,2\n3,4")
+    msg = r".*must be a single unicode character or None"
+    with pytest.raises(TypeError, match=msg):
+        np.loadtxt(txt, delimiter=",", quotechar="''")
+
+
+def test_comment_multichar_error_with_quote():
+    txt = StringIO("1,2\n3,4")
+    msg = (
+        "when multiple comments or a multi-character comment is given, "
+        "quotes are not supported."
+    )
+    with pytest.raises(ValueError, match=msg):
+        np.loadtxt(txt, delimiter=",", comments="123", quotechar='"')
+    with pytest.raises(ValueError, match=msg):
+        np.loadtxt(txt, delimiter=",", comments=["#", "%"], quotechar='"')
+
+    # A single character string in a tuple is unpacked though:
+    res = np.loadtxt(txt, delimiter=",", comments=("#",), quotechar="'")
+    assert_equal(res, [[1, 2], [3, 4]])
+
+
+def test_structured_dtype_with_quotes():
+    data = StringIO(
+        
+            "1000;2.4;'alpha';-34\n"
+            "2000;3.1;'beta';29\n"
+            "3500;9.9;'gamma';120\n"
+            "4090;8.1;'delta';0\n"
+            "5001;4.4;'epsilon';-99\n"
+            "6543;7.8;'omega';-1\n"
+        
+    )
+    dtype = np.dtype(
+        [('f0', np.uint16), ('f1', np.float64), ('f2', 'S7'), ('f3', np.int8)]
+    )
+    expected = np.array(
+        [
+            (1000, 2.4, "alpha", -34),
+            (2000, 3.1, "beta", 29),
+            (3500, 9.9, "gamma", 120),
+            (4090, 8.1, "delta", 0),
+            (5001, 4.4, "epsilon", -99),
+            (6543, 7.8, "omega", -1)
+        ],
+        dtype=dtype
+    )
+    res = np.loadtxt(data, dtype=dtype, delimiter=";", quotechar="'")
+    assert_array_equal(res, expected)
+
+
+def test_quoted_field_is_not_empty():
+    txt = StringIO('1\n\n"4"\n""')
+    expected = np.array(["1", "4", ""], dtype="U1")
+    res = np.loadtxt(txt, delimiter=",", dtype="U1", quotechar='"')
+    assert_equal(res, expected)
+
+def test_quoted_field_is_not_empty_nonstrict():
+    # Same as test_quoted_field_is_not_empty but check that we are not strict
+    # about missing closing quote (this is the `csv.reader` default also)
+    txt = StringIO('1\n\n"4"\n"')
+    expected = np.array(["1", "4", ""], dtype="U1")
+    res = np.loadtxt(txt, delimiter=",", dtype="U1", quotechar='"')
+    assert_equal(res, expected)
+
+def test_consecutive_quotechar_escaped():
+    txt = StringIO('"Hello, my name is ""Monty""!"')
+    expected = np.array('Hello, my name is "Monty"!', dtype="U40")
+    res = np.loadtxt(txt, dtype="U40", delimiter=",", quotechar='"')
+    assert_equal(res, expected)
+
+
+@pytest.mark.parametrize("data", ("", "\n\n\n", "# 1 2 3\n# 4 5 6\n"))
+@pytest.mark.parametrize("ndmin", (0, 1, 2))
+@pytest.mark.parametrize("usecols", [None, (1, 2, 3)])
+def test_warn_on_no_data(data, ndmin, usecols):
+    """Check that a UserWarning is emitted when no data is read from input."""
+    if usecols is not None:
+        expected_shape = (0, 3)
+    elif ndmin == 2:
+        expected_shape = (0, 1)  # guess a single column?!
+    else:
+        expected_shape = (0,)
+
+    txt = StringIO(data)
+    with pytest.warns(UserWarning, match="input contained no data"):
+        res = np.loadtxt(txt, ndmin=ndmin, usecols=usecols)
+    assert res.shape == expected_shape
+
+    with NamedTemporaryFile(mode="w") as fh:
+        fh.write(data)
+        fh.seek(0)
+        with pytest.warns(UserWarning, match="input contained no data"):
+            res = np.loadtxt(txt, ndmin=ndmin, usecols=usecols)
+        assert res.shape == expected_shape
+
+@pytest.mark.parametrize("skiprows", (2, 3))
+def test_warn_on_skipped_data(skiprows):
+    data = "1 2 3\n4 5 6"
+    txt = StringIO(data)
+    with pytest.warns(UserWarning, match="input contained no data"):
+        np.loadtxt(txt, skiprows=skiprows)
+
+
+@pytest.mark.parametrize(["dtype", "value"], [
+        ("i2", 0x0001), ("u2", 0x0001),
+        ("i4", 0x00010203), ("u4", 0x00010203),
+        ("i8", 0x0001020304050607), ("u8", 0x0001020304050607),
+        # The following values are constructed to lead to unique bytes:
+        ("float16", 3.07e-05),
+        ("float32", 9.2557e-41), ("complex64", 9.2557e-41+2.8622554e-29j),
+        ("float64", -1.758571353180402e-24),
+        # Here and below, the repr side-steps a small loss of precision in
+        # complex `str` in PyPy (which is probably fine, as repr works):
+        ("complex128", repr(5.406409232372729e-29-1.758571353180402e-24j)),
+        # Use integer values that fit into double.  Everything else leads to
+        # problems due to longdoubles going via double and decimal strings
+        # causing rounding errors.
+        ("longdouble", 0x01020304050607),
+        ("clongdouble", repr(0x01020304050607 + (0x00121314151617 * 1j))),
+        ("U2", "\U00010203\U000a0b0c")])
+@pytest.mark.parametrize("swap", [True, False])
+def test_byteswapping_and_unaligned(dtype, value, swap):
+    # Try to create "interesting" values within the valid unicode range:
+    dtype = np.dtype(dtype)
+    data = [f"x,{value}\n"]  # repr as PyPy `str` truncates some
+    if swap:
+        dtype = dtype.newbyteorder()
+    full_dt = np.dtype([("a", "S1"), ("b", dtype)], align=False)
+    # The above ensures that the interesting "b" field is unaligned:
+    assert full_dt.fields["b"][1] == 1
+    res = np.loadtxt(data, dtype=full_dt, delimiter=",",
+                     max_rows=1)  # max-rows prevents over-allocation
+    assert res["b"] == dtype.type(value)
+
+
+@pytest.mark.parametrize("dtype",
+        np.typecodes["AllInteger"] + "efdFD" + "?")
+def test_unicode_whitespace_stripping(dtype):
+    # Test that all numeric types (and bool) strip whitespace correctly
+    # \u202F is a narrow no-break space, `\n` is just a whitespace if quoted.
+    # Currently, skip float128 as it did not always support this and has no
+    # "custom" parsing:
+    txt = StringIO(' 3 ,"\u202F2\n"')
+    res = np.loadtxt(txt, dtype=dtype, delimiter=",", quotechar='"')
+    assert_array_equal(res, np.array([3, 2]).astype(dtype))
+
+
+@pytest.mark.parametrize("dtype", "FD")
+def test_unicode_whitespace_stripping_complex(dtype):
+    # Complex has a few extra cases since it has two components and
+    # parentheses
+    line = " 1 , 2+3j , ( 4+5j ), ( 6+-7j )  , 8j , ( 9j ) \n"
+    data = [line, line.replace(" ", "\u202F")]
+    res = np.loadtxt(data, dtype=dtype, delimiter=',')
+    assert_array_equal(res, np.array([[1, 2+3j, 4+5j, 6-7j, 8j, 9j]] * 2))
+
+
+@pytest.mark.skipif(IS_PYPY and sys.implementation.version <= (7, 3, 8),
+                    reason="PyPy bug in error formatting")
+@pytest.mark.parametrize("dtype", "FD")
+@pytest.mark.parametrize("field",
+        ["1 +2j", "1+ 2j", "1+2 j", "1+-+3", "(1j", "(1", "(1+2j", "1+2j)"])
+def test_bad_complex(dtype, field):
+    with pytest.raises(ValueError):
+        np.loadtxt([field + "\n"], dtype=dtype, delimiter=",")
+
+
+@pytest.mark.skipif(IS_PYPY and sys.implementation.version <= (7, 3, 8),
+                    reason="PyPy bug in error formatting")
+@pytest.mark.parametrize("dtype",
+            np.typecodes["AllInteger"] + "efgdFDG" + "?")
+def test_nul_character_error(dtype):
+    # Test that a \0 character is correctly recognized as an error even if
+    # what comes before is valid (not everything gets parsed internally).
+    if dtype.lower() == "g":
+        pytest.xfail("longdouble/clongdouble assignment may misbehave.")
+    with pytest.raises(ValueError):
+        np.loadtxt(["1\000"], dtype=dtype, delimiter=",", quotechar='"')
+
+
+@pytest.mark.skipif(IS_PYPY and sys.implementation.version <= (7, 3, 8),
+                    reason="PyPy bug in error formatting")
+@pytest.mark.parametrize("dtype",
+        np.typecodes["AllInteger"] + "efgdFDG" + "?")
+def test_no_thousands_support(dtype):
+    # Mainly to document behaviour, Python supports thousands like 1_1.
+    # (e and G may end up using different conversion and support it, this is
+    # a bug but happens...)
+    if dtype == "e":
+        pytest.skip("half assignment currently uses Python float converter")
+    if dtype in "eG":
+        pytest.xfail("clongdouble assignment is buggy (uses `complex`?).")
+
+    assert int("1_1") == float("1_1") == complex("1_1") == 11
+    with pytest.raises(ValueError):
+        np.loadtxt(["1_1\n"], dtype=dtype)
+
+
+@pytest.mark.parametrize("data", [
+    ["1,2\n", "2\n,3\n"],
+    ["1,2\n", "2\r,3\n"]])
+def test_bad_newline_in_iterator(data):
+    # In NumPy <=1.22 this was accepted, because newlines were completely
+    # ignored when the input was an iterable.  This could be changed, but right
+    # now, we raise an error.
+    msg = "Found an unquoted embedded newline within a single line"
+    with pytest.raises(ValueError, match=msg):
+        np.loadtxt(data, delimiter=",")
+
+
+@pytest.mark.parametrize("data", [
+    ["1,2\n", "2,3\r\n"],  # a universal newline
+    ["1,2\n", "'2\n',3\n"],  # a quoted newline
+    ["1,2\n", "'2\r',3\n"],
+    ["1,2\n", "'2\r\n',3\n"],
+])
+def test_good_newline_in_iterator(data):
+    # The quoted newlines will be untransformed here, but are just whitespace.
+    res = np.loadtxt(data, delimiter=",", quotechar="'")
+    assert_array_equal(res, [[1., 2.], [2., 3.]])
+
+
+@pytest.mark.parametrize("newline", ["\n", "\r", "\r\n"])
+def test_universal_newlines_quoted(newline):
+    # Check that universal newline support within the tokenizer is not applied
+    # to quoted fields.  (note that lines must end in newline or quoted
+    # fields will not include a newline at all)
+    data = ['1,"2\n"\n', '3,"4\n', '1"\n']
+    data = [row.replace("\n", newline) for row in data]
+    res = np.loadtxt(data, dtype=object, delimiter=",", quotechar='"')
+    assert_array_equal(res, [['1', f'2{newline}'], ['3', f'4{newline}1']])
+
+
+def test_null_character():
+    # Basic tests to check that the NUL character is not special:
+    res = np.loadtxt(["1\0002\0003\n", "4\0005\0006"], delimiter="\000")
+    assert_array_equal(res, [[1, 2, 3], [4, 5, 6]])
+
+    # Also not as part of a field (avoid unicode/arrays as unicode strips \0)
+    res = np.loadtxt(["1\000,2\000,3\n", "4\000,5\000,6"],
+                     delimiter=",", dtype=object)
+    assert res.tolist() == [["1\000", "2\000", "3"], ["4\000", "5\000", "6"]]
+
+
+def test_iterator_fails_getting_next_line():
+    class BadSequence:
+        def __len__(self):
+            return 100
+
+        def __getitem__(self, item):
+            if item == 50:
+                raise RuntimeError("Bad things happened!")
+            return f"{item}, {item+1}"
+
+    with pytest.raises(RuntimeError, match="Bad things happened!"):
+        np.loadtxt(BadSequence(), dtype=int, delimiter=",")
+
+
+class TestCReaderUnitTests:
+    # These are internal tests for path that should not be possible to hit
+    # unless things go very very wrong somewhere.
+    def test_not_an_filelike(self):
+        with pytest.raises(AttributeError, match=".*read"):
+            np._core._multiarray_umath._load_from_filelike(
+                object(), dtype=np.dtype("i"), filelike=True)
+
+    def test_filelike_read_fails(self):
+        # Can only be reached if loadtxt opens the file, so it is hard to do
+        # via the public interface (although maybe not impossible considering
+        # the current "DataClass" backing).
+        class BadFileLike:
+            counter = 0
+
+            def read(self, size):
+                self.counter += 1
+                if self.counter > 20:
+                    raise RuntimeError("Bad bad bad!")
+                return "1,2,3\n"
+
+        with pytest.raises(RuntimeError, match="Bad bad bad!"):
+            np._core._multiarray_umath._load_from_filelike(
+                BadFileLike(), dtype=np.dtype("i"), filelike=True)
+
+    def test_filelike_bad_read(self):
+        # Can only be reached if loadtxt opens the file, so it is hard to do
+        # via the public interface (although maybe not impossible considering
+        # the current "DataClass" backing).
+
+        class BadFileLike:
+            counter = 0
+
+            def read(self, size):
+                return 1234  # not a string!
+
+        with pytest.raises(TypeError,
+                    match="non-string returned while reading data"):
+            np._core._multiarray_umath._load_from_filelike(
+                BadFileLike(), dtype=np.dtype("i"), filelike=True)
+
+    def test_not_an_iter(self):
+        with pytest.raises(TypeError,
+                    match="error reading from object, expected an iterable"):
+            np._core._multiarray_umath._load_from_filelike(
+                object(), dtype=np.dtype("i"), filelike=False)
+
+    def test_bad_type(self):
+        with pytest.raises(TypeError, match="internal error: dtype must"):
+            np._core._multiarray_umath._load_from_filelike(
+                object(), dtype="i", filelike=False)
+
+    def test_bad_encoding(self):
+        with pytest.raises(TypeError, match="encoding must be a unicode"):
+            np._core._multiarray_umath._load_from_filelike(
+                object(), dtype=np.dtype("i"), filelike=False, encoding=123)
+
+    @pytest.mark.parametrize("newline", ["\r", "\n", "\r\n"])
+    def test_manual_universal_newlines(self, newline):
+        # This is currently not available to users, because we should always
+        # open files with universal newlines enabled `newlines=None`.
+        # (And reading from an iterator uses slightly different code paths.)
+        # We have no real support for `newline="\r"` or `newline="\n" as the
+        # user cannot specify those options.
+        data = StringIO('0\n1\n"2\n"\n3\n4 #\n'.replace("\n", newline),
+                        newline="")
+
+        res = np._core._multiarray_umath._load_from_filelike(
+            data, dtype=np.dtype("U10"), filelike=True,
+            quote='"', comment="#", skiplines=1)
+        assert_array_equal(res[:, 0], ["1", f"2{newline}", "3", "4 "])
+
+
+def test_delimiter_comment_collision_raises():
+    with pytest.raises(TypeError, match=".*control characters.*incompatible"):
+        np.loadtxt(StringIO("1, 2, 3"), delimiter=",", comments=",")
+
+
+def test_delimiter_quotechar_collision_raises():
+    with pytest.raises(TypeError, match=".*control characters.*incompatible"):
+        np.loadtxt(StringIO("1, 2, 3"), delimiter=",", quotechar=",")
+
+
+def test_comment_quotechar_collision_raises():
+    with pytest.raises(TypeError, match=".*control characters.*incompatible"):
+        np.loadtxt(StringIO("1 2 3"), comments="#", quotechar="#")
+
+
+def test_delimiter_and_multiple_comments_collision_raises():
+    with pytest.raises(
+        TypeError, match="Comment characters.*cannot include the delimiter"
+    ):
+        np.loadtxt(StringIO("1, 2, 3"), delimiter=",", comments=["#", ","])
+
+
+@pytest.mark.parametrize(
+    "ws",
+    (
+        " ",  # space
+        "\t",  # tab
+        "\u2003",  # em
+        "\u00A0",  # non-break
+        "\u3000",  # ideographic space
+    )
+)
+def test_collision_with_default_delimiter_raises(ws):
+    with pytest.raises(TypeError, match=".*control characters.*incompatible"):
+        np.loadtxt(StringIO(f"1{ws}2{ws}3\n4{ws}5{ws}6\n"), comments=ws)
+    with pytest.raises(TypeError, match=".*control characters.*incompatible"):
+        np.loadtxt(StringIO(f"1{ws}2{ws}3\n4{ws}5{ws}6\n"), quotechar=ws)
+
+
+@pytest.mark.parametrize("nl", ("\n", "\r"))
+def test_control_character_newline_raises(nl):
+    txt = StringIO(f"1{nl}2{nl}3{nl}{nl}4{nl}5{nl}6{nl}{nl}")
+    msg = "control character.*cannot be a newline"
+    with pytest.raises(TypeError, match=msg):
+        np.loadtxt(txt, delimiter=nl)
+    with pytest.raises(TypeError, match=msg):
+        np.loadtxt(txt, comments=nl)
+    with pytest.raises(TypeError, match=msg):
+        np.loadtxt(txt, quotechar=nl)
+
+
+@pytest.mark.parametrize(
+    ("generic_data", "long_datum", "unitless_dtype", "expected_dtype"),
+    [
+        ("2012-03", "2013-01-15", "M8", "M8[D]"),  # Datetimes
+        ("spam-a-lot", "tis_but_a_scratch", "U", "U17"),  # str
+    ],
+)
+@pytest.mark.parametrize("nrows", (10, 50000, 60000))  # lt, eq, gt chunksize
+def test_parametric_unit_discovery(
+    generic_data, long_datum, unitless_dtype, expected_dtype, nrows
+):
+    """Check that the correct unit (e.g. month, day, second) is discovered from
+    the data when a user specifies a unitless datetime."""
+    # Unit should be "D" (days) due to last entry
+    data = [generic_data] * nrows + [long_datum]
+    expected = np.array(data, dtype=expected_dtype)
+    assert len(data) == nrows+1
+    assert len(data) == len(expected)
+
+    # file-like path
+    txt = StringIO("\n".join(data))
+    a = np.loadtxt(txt, dtype=unitless_dtype)
+    assert len(a) == len(expected)
+    assert a.dtype == expected.dtype
+    assert_equal(a, expected)
+
+    # file-obj path
+    fd, fname = mkstemp()
+    os.close(fd)
+    with open(fname, "w") as fh:
+        fh.write("\n".join(data)+"\n")
+    # loading the full file...
+    a = np.loadtxt(fname, dtype=unitless_dtype)
+    assert len(a) == len(expected)
+    assert a.dtype == expected.dtype
+    assert_equal(a, expected)
+    # loading half of the file...
+    a = np.loadtxt(fname, dtype=unitless_dtype, max_rows=int(nrows/2))
+    os.remove(fname)
+    assert len(a) == int(nrows/2)
+    assert_equal(a, expected[:int(nrows/2)])
+
+
+def test_str_dtype_unit_discovery_with_converter():
+    data = ["spam-a-lot"] * 60000 + ["XXXtis_but_a_scratch"]
+    expected = np.array(
+        ["spam-a-lot"] * 60000 + ["tis_but_a_scratch"], dtype="U17"
+    )
+    conv = lambda s: s.removeprefix("XXX")
+
+    # file-like path
+    txt = StringIO("\n".join(data))
+    a = np.loadtxt(txt, dtype="U", converters=conv)
+    assert a.dtype == expected.dtype
+    assert_equal(a, expected)
+
+    # file-obj path
+    fd, fname = mkstemp()
+    os.close(fd)
+    with open(fname, "w") as fh:
+        fh.write("\n".join(data))
+    a = np.loadtxt(fname, dtype="U", converters=conv)
+    os.remove(fname)
+    assert a.dtype == expected.dtype
+    assert_equal(a, expected)
+
+
+@pytest.mark.skipif(IS_PYPY and sys.implementation.version <= (7, 3, 8),
+                    reason="PyPy bug in error formatting")
+def test_control_character_empty():
+    with pytest.raises(TypeError, match="Text reading control character must"):
+        np.loadtxt(StringIO("1 2 3"), delimiter="")
+    with pytest.raises(TypeError, match="Text reading control character must"):
+        np.loadtxt(StringIO("1 2 3"), quotechar="")
+    with pytest.raises(ValueError, match="comments cannot be an empty string"):
+        np.loadtxt(StringIO("1 2 3"), comments="")
+    with pytest.raises(ValueError, match="comments cannot be an empty string"):
+        np.loadtxt(StringIO("1 2 3"), comments=["#", ""])
+
+
+def test_control_characters_as_bytes():
+    """Byte control characters (comments, delimiter) are supported."""
+    a = np.loadtxt(StringIO("#header\n1,2,3"), comments=b"#", delimiter=b",")
+    assert_equal(a, [1, 2, 3])
+
+
+@pytest.mark.filterwarnings('ignore::UserWarning')
+def test_field_growing_cases():
+    # Test empty field appending/growing (each field still takes 1 character)
+    # to see if the final field appending does not create issues.
+    res = np.loadtxt([""], delimiter=",", dtype=bytes)
+    assert len(res) == 0
+
+    for i in range(1, 1024):
+        res = np.loadtxt(["," * i], delimiter=",", dtype=bytes, max_rows=10)
+        assert len(res) == i+1
+
+@pytest.mark.parametrize("nmax", (10000, 50000, 55000, 60000))
+def test_maxrows_exceeding_chunksize(nmax):
+    # tries to read all of the file,
+    # or less, equal, greater than _loadtxt_chunksize
+    file_length = 60000
+
+    # file-like path
+    data = ["a 0.5 1"]*file_length
+    txt = StringIO("\n".join(data))
+    res = np.loadtxt(txt, dtype=str, delimiter=" ", max_rows=nmax)
+    assert len(res) == nmax
+
+    # file-obj path
+    fd, fname = mkstemp()
+    os.close(fd)
+    with open(fname, "w") as fh:
+        fh.write("\n".join(data))
+    res = np.loadtxt(fname, dtype=str, delimiter=" ", max_rows=nmax)
+    os.remove(fname)
+    assert len(res) == nmax
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/tests/test_mixins.py b/venv/lib/python3.12/site-packages/numpy/lib/tests/test_mixins.py
new file mode 100644
index 00000000..63205876
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/lib/tests/test_mixins.py
@@ -0,0 +1,216 @@
+import numbers
+import operator
+
+import numpy as np
+from numpy.testing import assert_, assert_equal, assert_raises
+
+
+# NOTE: This class should be kept as an exact copy of the example from the
+# docstring for NDArrayOperatorsMixin.
+
+class ArrayLike(np.lib.mixins.NDArrayOperatorsMixin):
+    def __init__(self, value):
+        self.value = np.asarray(value)
+
+    # One might also consider adding the built-in list type to this
+    # list, to support operations like np.add(array_like, list)
+    _HANDLED_TYPES = (np.ndarray, numbers.Number)
+
+    def __array_ufunc__(self, ufunc, method, *inputs, **kwargs):
+        out = kwargs.get('out', ())
+        for x in inputs + out:
+            # Only support operations with instances of _HANDLED_TYPES.
+            # Use ArrayLike instead of type(self) for isinstance to
+            # allow subclasses that don't override __array_ufunc__ to
+            # handle ArrayLike objects.
+            if not isinstance(x, self._HANDLED_TYPES + (ArrayLike,)):
+                return NotImplemented
+
+        # Defer to the implementation of the ufunc on unwrapped values.
+        inputs = tuple(x.value if isinstance(x, ArrayLike) else x
+                       for x in inputs)
+        if out:
+            kwargs['out'] = tuple(
+                x.value if isinstance(x, ArrayLike) else x
+                for x in out)
+        result = getattr(ufunc, method)(*inputs, **kwargs)
+
+        if type(result) is tuple:
+            # multiple return values
+            return tuple(type(self)(x) for x in result)
+        elif method == 'at':
+            # no return value
+            return None
+        else:
+            # one return value
+            return type(self)(result)
+
+    def __repr__(self):
+        return '%s(%r)' % (type(self).__name__, self.value)
+
+
+def wrap_array_like(result):
+    if type(result) is tuple:
+        return tuple(ArrayLike(r) for r in result)
+    else:
+        return ArrayLike(result)
+
+
+def _assert_equal_type_and_value(result, expected, err_msg=None):
+    assert_equal(type(result), type(expected), err_msg=err_msg)
+    if isinstance(result, tuple):
+        assert_equal(len(result), len(expected), err_msg=err_msg)
+        for result_item, expected_item in zip(result, expected):
+            _assert_equal_type_and_value(result_item, expected_item, err_msg)
+    else:
+        assert_equal(result.value, expected.value, err_msg=err_msg)
+        assert_equal(getattr(result.value, 'dtype', None),
+                     getattr(expected.value, 'dtype', None), err_msg=err_msg)
+
+
+_ALL_BINARY_OPERATORS = [
+    operator.lt,
+    operator.le,
+    operator.eq,
+    operator.ne,
+    operator.gt,
+    operator.ge,
+    operator.add,
+    operator.sub,
+    operator.mul,
+    operator.truediv,
+    operator.floordiv,
+    operator.mod,
+    divmod,
+    pow,
+    operator.lshift,
+    operator.rshift,
+    operator.and_,
+    operator.xor,
+    operator.or_,
+]
+
+
+class TestNDArrayOperatorsMixin:
+
+    def test_array_like_add(self):
+
+        def check(result):
+            _assert_equal_type_and_value(result, ArrayLike(0))
+
+        check(ArrayLike(0) + 0)
+        check(0 + ArrayLike(0))
+
+        check(ArrayLike(0) + np.array(0))
+        check(np.array(0) + ArrayLike(0))
+
+        check(ArrayLike(np.array(0)) + 0)
+        check(0 + ArrayLike(np.array(0)))
+
+        check(ArrayLike(np.array(0)) + np.array(0))
+        check(np.array(0) + ArrayLike(np.array(0)))
+
+    def test_inplace(self):
+        array_like = ArrayLike(np.array([0]))
+        array_like += 1
+        _assert_equal_type_and_value(array_like, ArrayLike(np.array([1])))
+
+        array = np.array([0])
+        array += ArrayLike(1)
+        _assert_equal_type_and_value(array, ArrayLike(np.array([1])))
+
+    def test_opt_out(self):
+
+        class OptOut:
+            """Object that opts out of __array_ufunc__."""
+            __array_ufunc__ = None
+
+            def __add__(self, other):
+                return self
+
+            def __radd__(self, other):
+                return self
+
+        array_like = ArrayLike(1)
+        opt_out = OptOut()
+
+        # supported operations
+        assert_(array_like + opt_out is opt_out)
+        assert_(opt_out + array_like is opt_out)
+
+        # not supported
+        with assert_raises(TypeError):
+            # don't use the Python default, array_like = array_like + opt_out
+            array_like += opt_out
+        with assert_raises(TypeError):
+            array_like - opt_out
+        with assert_raises(TypeError):
+            opt_out - array_like
+
+    def test_subclass(self):
+
+        class SubArrayLike(ArrayLike):
+            """Should take precedence over ArrayLike."""
+
+        x = ArrayLike(0)
+        y = SubArrayLike(1)
+        _assert_equal_type_and_value(x + y, y)
+        _assert_equal_type_and_value(y + x, y)
+
+    def test_object(self):
+        x = ArrayLike(0)
+        obj = object()
+        with assert_raises(TypeError):
+            x + obj
+        with assert_raises(TypeError):
+            obj + x
+        with assert_raises(TypeError):
+            x += obj
+
+    def test_unary_methods(self):
+        array = np.array([-1, 0, 1, 2])
+        array_like = ArrayLike(array)
+        for op in [operator.neg,
+                   operator.pos,
+                   abs,
+                   operator.invert]:
+            _assert_equal_type_and_value(op(array_like), ArrayLike(op(array)))
+
+    def test_forward_binary_methods(self):
+        array = np.array([-1, 0, 1, 2])
+        array_like = ArrayLike(array)
+        for op in _ALL_BINARY_OPERATORS:
+            expected = wrap_array_like(op(array, 1))
+            actual = op(array_like, 1)
+            err_msg = 'failed for operator {}'.format(op)
+            _assert_equal_type_and_value(expected, actual, err_msg=err_msg)
+
+    def test_reflected_binary_methods(self):
+        for op in _ALL_BINARY_OPERATORS:
+            expected = wrap_array_like(op(2, 1))
+            actual = op(2, ArrayLike(1))
+            err_msg = 'failed for operator {}'.format(op)
+            _assert_equal_type_and_value(expected, actual, err_msg=err_msg)
+
+    def test_matmul(self):
+        array = np.array([1, 2], dtype=np.float64)
+        array_like = ArrayLike(array)
+        expected = ArrayLike(np.float64(5))
+        _assert_equal_type_and_value(expected, np.matmul(array_like, array))
+        _assert_equal_type_and_value(
+            expected, operator.matmul(array_like, array))
+        _assert_equal_type_and_value(
+            expected, operator.matmul(array, array_like))
+
+    def test_ufunc_at(self):
+        array = ArrayLike(np.array([1, 2, 3, 4]))
+        assert_(np.negative.at(array, np.array([0, 1])) is None)
+        _assert_equal_type_and_value(array, ArrayLike([-1, -2, 3, 4]))
+
+    def test_ufunc_two_outputs(self):
+        mantissa, exponent = np.frexp(2 ** -3)
+        expected = (ArrayLike(mantissa), ArrayLike(exponent))
+        _assert_equal_type_and_value(
+            np.frexp(ArrayLike(2 ** -3)), expected)
+        _assert_equal_type_and_value(
+            np.frexp(ArrayLike(np.array(2 ** -3))), expected)
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/tests/test_nanfunctions.py b/venv/lib/python3.12/site-packages/numpy/lib/tests/test_nanfunctions.py
new file mode 100644
index 00000000..2a92cad2
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/lib/tests/test_nanfunctions.py
@@ -0,0 +1,1418 @@
+import warnings
+import pytest
+import inspect
+from functools import partial
+
+import numpy as np
+from numpy._core.numeric import normalize_axis_tuple
+from numpy.exceptions import AxisError, ComplexWarning
+from numpy.lib._nanfunctions_impl import _nan_mask, _replace_nan
+from numpy.testing import (
+    assert_, assert_equal, assert_almost_equal, assert_raises,
+    assert_raises_regex, assert_array_equal, suppress_warnings
+    )
+
+
+# Test data
+_ndat = np.array([[0.6244, np.nan, 0.2692, 0.0116, np.nan, 0.1170],
+                  [0.5351, -0.9403, np.nan, 0.2100, 0.4759, 0.2833],
+                  [np.nan, np.nan, np.nan, 0.1042, np.nan, -0.5954],
+                  [0.1610, np.nan, np.nan, 0.1859, 0.3146, np.nan]])
+
+
+# Rows of _ndat with nans removed
+_rdat = [np.array([0.6244, 0.2692, 0.0116, 0.1170]),
+         np.array([0.5351, -0.9403, 0.2100, 0.4759, 0.2833]),
+         np.array([0.1042, -0.5954]),
+         np.array([0.1610, 0.1859, 0.3146])]
+
+# Rows of _ndat with nans converted to ones
+_ndat_ones = np.array([[0.6244, 1.0, 0.2692, 0.0116, 1.0, 0.1170],
+                       [0.5351, -0.9403, 1.0, 0.2100, 0.4759, 0.2833],
+                       [1.0, 1.0, 1.0, 0.1042, 1.0, -0.5954],
+                       [0.1610, 1.0, 1.0, 0.1859, 0.3146, 1.0]])
+
+# Rows of _ndat with nans converted to zeros
+_ndat_zeros = np.array([[0.6244, 0.0, 0.2692, 0.0116, 0.0, 0.1170],
+                        [0.5351, -0.9403, 0.0, 0.2100, 0.4759, 0.2833],
+                        [0.0, 0.0, 0.0, 0.1042, 0.0, -0.5954],
+                        [0.1610, 0.0, 0.0, 0.1859, 0.3146, 0.0]])
+
+
+class TestSignatureMatch:
+    NANFUNCS = {
+        np.nanmin: np.amin,
+        np.nanmax: np.amax,
+        np.nanargmin: np.argmin,
+        np.nanargmax: np.argmax,
+        np.nansum: np.sum,
+        np.nanprod: np.prod,
+        np.nancumsum: np.cumsum,
+        np.nancumprod: np.cumprod,
+        np.nanmean: np.mean,
+        np.nanmedian: np.median,
+        np.nanpercentile: np.percentile,
+        np.nanquantile: np.quantile,
+        np.nanvar: np.var,
+        np.nanstd: np.std,
+    }
+    IDS = [k.__name__ for k in NANFUNCS]
+
+    @staticmethod
+    def get_signature(func, default="..."):
+        """Construct a signature and replace all default parameter-values."""
+        prm_list = []
+        signature = inspect.signature(func)
+        for prm in signature.parameters.values():
+            if prm.default is inspect.Parameter.empty:
+                prm_list.append(prm)
+            else:
+                prm_list.append(prm.replace(default=default))
+        return inspect.Signature(prm_list)
+
+    @pytest.mark.parametrize("nan_func,func", NANFUNCS.items(), ids=IDS)
+    def test_signature_match(self, nan_func, func):
+        # Ignore the default parameter-values as they can sometimes differ
+        # between the two functions (*e.g.* one has `False` while the other
+        # has `np._NoValue`)
+        signature = self.get_signature(func)
+        nan_signature = self.get_signature(nan_func)
+        np.testing.assert_equal(signature, nan_signature)
+
+    def test_exhaustiveness(self):
+        """Validate that all nan functions are actually tested."""
+        np.testing.assert_equal(
+            set(self.IDS), set(np.lib._nanfunctions_impl.__all__)
+        )
+
+
+class TestNanFunctions_MinMax:
+
+    nanfuncs = [np.nanmin, np.nanmax]
+    stdfuncs = [np.min, np.max]
+
+    def test_mutation(self):
+        # Check that passed array is not modified.
+        ndat = _ndat.copy()
+        for f in self.nanfuncs:
+            f(ndat)
+            assert_equal(ndat, _ndat)
+
+    def test_keepdims(self):
+        mat = np.eye(3)
+        for nf, rf in zip(self.nanfuncs, self.stdfuncs):
+            for axis in [None, 0, 1]:
+                tgt = rf(mat, axis=axis, keepdims=True)
+                res = nf(mat, axis=axis, keepdims=True)
+                assert_(res.ndim == tgt.ndim)
+
+    def test_out(self):
+        mat = np.eye(3)
+        for nf, rf in zip(self.nanfuncs, self.stdfuncs):
+            resout = np.zeros(3)
+            tgt = rf(mat, axis=1)
+            res = nf(mat, axis=1, out=resout)
+            assert_almost_equal(res, resout)
+            assert_almost_equal(res, tgt)
+
+    def test_dtype_from_input(self):
+        codes = 'efdgFDG'
+        for nf, rf in zip(self.nanfuncs, self.stdfuncs):
+            for c in codes:
+                mat = np.eye(3, dtype=c)
+                tgt = rf(mat, axis=1).dtype.type
+                res = nf(mat, axis=1).dtype.type
+                assert_(res is tgt)
+                # scalar case
+                tgt = rf(mat, axis=None).dtype.type
+                res = nf(mat, axis=None).dtype.type
+                assert_(res is tgt)
+
+    def test_result_values(self):
+        for nf, rf in zip(self.nanfuncs, self.stdfuncs):
+            tgt = [rf(d) for d in _rdat]
+            res = nf(_ndat, axis=1)
+            assert_almost_equal(res, tgt)
+
+    @pytest.mark.parametrize("axis", [None, 0, 1])
+    @pytest.mark.parametrize("dtype", np.typecodes["AllFloat"])
+    @pytest.mark.parametrize("array", [
+        np.array(np.nan),
+        np.full((3, 3), np.nan),
+    ], ids=["0d", "2d"])
+    def test_allnans(self, axis, dtype, array):
+        if axis is not None and array.ndim == 0:
+            pytest.skip(f"`axis != None` not supported for 0d arrays")
+
+        array = array.astype(dtype)
+        match = "All-NaN slice encountered"
+        for func in self.nanfuncs:
+            with pytest.warns(RuntimeWarning, match=match):
+                out = func(array, axis=axis)
+            assert np.isnan(out).all()
+            assert out.dtype == array.dtype
+
+    def test_masked(self):
+        mat = np.ma.fix_invalid(_ndat)
+        msk = mat._mask.copy()
+        for f in [np.nanmin]:
+            res = f(mat, axis=1)
+            tgt = f(_ndat, axis=1)
+            assert_equal(res, tgt)
+            assert_equal(mat._mask, msk)
+            assert_(not np.isinf(mat).any())
+
+    def test_scalar(self):
+        for f in self.nanfuncs:
+            assert_(f(0.) == 0.)
+
+    def test_subclass(self):
+        class MyNDArray(np.ndarray):
+            pass
+
+        # Check that it works and that type and
+        # shape are preserved
+        mine = np.eye(3).view(MyNDArray)
+        for f in self.nanfuncs:
+            res = f(mine, axis=0)
+            assert_(isinstance(res, MyNDArray))
+            assert_(res.shape == (3,))
+            res = f(mine, axis=1)
+            assert_(isinstance(res, MyNDArray))
+            assert_(res.shape == (3,))
+            res = f(mine)
+            assert_(res.shape == ())
+
+        # check that rows of nan are dealt with for subclasses (#4628)
+        mine[1] = np.nan
+        for f in self.nanfuncs:
+            with warnings.catch_warnings(record=True) as w:
+                warnings.simplefilter('always')
+                res = f(mine, axis=0)
+                assert_(isinstance(res, MyNDArray))
+                assert_(not np.any(np.isnan(res)))
+                assert_(len(w) == 0)
+
+            with warnings.catch_warnings(record=True) as w:
+                warnings.simplefilter('always')
+                res = f(mine, axis=1)
+                assert_(isinstance(res, MyNDArray))
+                assert_(np.isnan(res[1]) and not np.isnan(res[0])
+                        and not np.isnan(res[2]))
+                assert_(len(w) == 1, 'no warning raised')
+                assert_(issubclass(w[0].category, RuntimeWarning))
+
+            with warnings.catch_warnings(record=True) as w:
+                warnings.simplefilter('always')
+                res = f(mine)
+                assert_(res.shape == ())
+                assert_(res != np.nan)
+                assert_(len(w) == 0)
+
+    def test_object_array(self):
+        arr = np.array([[1.0, 2.0], [np.nan, 4.0], [np.nan, np.nan]], dtype=object)
+        assert_equal(np.nanmin(arr), 1.0)
+        assert_equal(np.nanmin(arr, axis=0), [1.0, 2.0])
+
+        with warnings.catch_warnings(record=True) as w:
+            warnings.simplefilter('always')
+            # assert_equal does not work on object arrays of nan
+            assert_equal(list(np.nanmin(arr, axis=1)), [1.0, 4.0, np.nan])
+            assert_(len(w) == 1, 'no warning raised')
+            assert_(issubclass(w[0].category, RuntimeWarning))
+
+    @pytest.mark.parametrize("dtype", np.typecodes["AllFloat"])
+    def test_initial(self, dtype):
+        class MyNDArray(np.ndarray):
+            pass
+
+        ar = np.arange(9).astype(dtype)
+        ar[:5] = np.nan
+
+        for f in self.nanfuncs:
+            initial = 100 if f is np.nanmax else 0
+
+            ret1 = f(ar, initial=initial)
+            assert ret1.dtype == dtype
+            assert ret1 == initial
+
+            ret2 = f(ar.view(MyNDArray), initial=initial)
+            assert ret2.dtype == dtype
+            assert ret2 == initial
+
+    @pytest.mark.parametrize("dtype", np.typecodes["AllFloat"])
+    def test_where(self, dtype):
+        class MyNDArray(np.ndarray):
+            pass
+
+        ar = np.arange(9).reshape(3, 3).astype(dtype)
+        ar[0, :] = np.nan
+        where = np.ones_like(ar, dtype=np.bool)
+        where[:, 0] = False
+
+        for f in self.nanfuncs:
+            reference = 4 if f is np.nanmin else 8
+
+            ret1 = f(ar, where=where, initial=5)
+            assert ret1.dtype == dtype
+            assert ret1 == reference
+
+            ret2 = f(ar.view(MyNDArray), where=where, initial=5)
+            assert ret2.dtype == dtype
+            assert ret2 == reference
+
+
+class TestNanFunctions_ArgminArgmax:
+
+    nanfuncs = [np.nanargmin, np.nanargmax]
+
+    def test_mutation(self):
+        # Check that passed array is not modified.
+        ndat = _ndat.copy()
+        for f in self.nanfuncs:
+            f(ndat)
+            assert_equal(ndat, _ndat)
+
+    def test_result_values(self):
+        for f, fcmp in zip(self.nanfuncs, [np.greater, np.less]):
+            for row in _ndat:
+                with suppress_warnings() as sup:
+                    sup.filter(RuntimeWarning, "invalid value encountered in")
+                    ind = f(row)
+                    val = row[ind]
+                    # comparing with NaN is tricky as the result
+                    # is always false except for NaN != NaN
+                    assert_(not np.isnan(val))
+                    assert_(not fcmp(val, row).any())
+                    assert_(not np.equal(val, row[:ind]).any())
+
+    @pytest.mark.parametrize("axis", [None, 0, 1])
+    @pytest.mark.parametrize("dtype", np.typecodes["AllFloat"])
+    @pytest.mark.parametrize("array", [
+        np.array(np.nan),
+        np.full((3, 3), np.nan),
+    ], ids=["0d", "2d"])
+    def test_allnans(self, axis, dtype, array):
+        if axis is not None and array.ndim == 0:
+            pytest.skip(f"`axis != None` not supported for 0d arrays")
+
+        array = array.astype(dtype)
+        for func in self.nanfuncs:
+            with pytest.raises(ValueError, match="All-NaN slice encountered"):
+                func(array, axis=axis)
+
+    def test_empty(self):
+        mat = np.zeros((0, 3))
+        for f in self.nanfuncs:
+            for axis in [0, None]:
+                assert_raises_regex(
+                        ValueError,
+                        "attempt to get argm.. of an empty sequence",
+                        f, mat, axis=axis)
+            for axis in [1]:
+                res = f(mat, axis=axis)
+                assert_equal(res, np.zeros(0))
+
+    def test_scalar(self):
+        for f in self.nanfuncs:
+            assert_(f(0.) == 0.)
+
+    def test_subclass(self):
+        class MyNDArray(np.ndarray):
+            pass
+
+        # Check that it works and that type and
+        # shape are preserved
+        mine = np.eye(3).view(MyNDArray)
+        for f in self.nanfuncs:
+            res = f(mine, axis=0)
+            assert_(isinstance(res, MyNDArray))
+            assert_(res.shape == (3,))
+            res = f(mine, axis=1)
+            assert_(isinstance(res, MyNDArray))
+            assert_(res.shape == (3,))
+            res = f(mine)
+            assert_(res.shape == ())
+
+    @pytest.mark.parametrize("dtype", np.typecodes["AllFloat"])
+    def test_keepdims(self, dtype):
+        ar = np.arange(9).astype(dtype)
+        ar[:5] = np.nan
+
+        for f in self.nanfuncs:
+            reference = 5 if f is np.nanargmin else 8
+            ret = f(ar, keepdims=True)
+            assert ret.ndim == ar.ndim
+            assert ret == reference
+
+    @pytest.mark.parametrize("dtype", np.typecodes["AllFloat"])
+    def test_out(self, dtype):
+        ar = np.arange(9).astype(dtype)
+        ar[:5] = np.nan
+
+        for f in self.nanfuncs:
+            out = np.zeros((), dtype=np.intp)
+            reference = 5 if f is np.nanargmin else 8
+            ret = f(ar, out=out)
+            assert ret is out
+            assert ret == reference
+
+
+
+_TEST_ARRAYS = {
+    "0d": np.array(5),
+    "1d": np.array([127, 39, 93, 87, 46])
+}
+for _v in _TEST_ARRAYS.values():
+    _v.setflags(write=False)
+
+
+@pytest.mark.parametrize(
+    "dtype",
+    np.typecodes["AllInteger"] + np.typecodes["AllFloat"] + "O",
+)
+@pytest.mark.parametrize("mat", _TEST_ARRAYS.values(), ids=_TEST_ARRAYS.keys())
+class TestNanFunctions_NumberTypes:
+    nanfuncs = {
+        np.nanmin: np.min,
+        np.nanmax: np.max,
+        np.nanargmin: np.argmin,
+        np.nanargmax: np.argmax,
+        np.nansum: np.sum,
+        np.nanprod: np.prod,
+        np.nancumsum: np.cumsum,
+        np.nancumprod: np.cumprod,
+        np.nanmean: np.mean,
+        np.nanmedian: np.median,
+        np.nanvar: np.var,
+        np.nanstd: np.std,
+    }
+    nanfunc_ids = [i.__name__ for i in nanfuncs]
+
+    @pytest.mark.parametrize("nanfunc,func", nanfuncs.items(), ids=nanfunc_ids)
+    @np.errstate(over="ignore")
+    def test_nanfunc(self, mat, dtype, nanfunc, func):
+        mat = mat.astype(dtype)
+        tgt = func(mat)
+        out = nanfunc(mat)
+
+        assert_almost_equal(out, tgt)
+        if dtype == "O":
+            assert type(out) is type(tgt)
+        else:
+            assert out.dtype == tgt.dtype
+
+    @pytest.mark.parametrize(
+        "nanfunc,func",
+        [(np.nanquantile, np.quantile), (np.nanpercentile, np.percentile)],
+        ids=["nanquantile", "nanpercentile"],
+    )
+    def test_nanfunc_q(self, mat, dtype, nanfunc, func):
+        mat = mat.astype(dtype)
+        if mat.dtype.kind == "c":
+            assert_raises(TypeError, func, mat, q=1)
+            assert_raises(TypeError, nanfunc, mat, q=1)
+
+        else:
+            tgt = func(mat, q=1)
+            out = nanfunc(mat, q=1)
+
+            assert_almost_equal(out, tgt)
+
+            if dtype == "O":
+                assert type(out) is type(tgt)
+            else:
+                assert out.dtype == tgt.dtype
+
+    @pytest.mark.parametrize(
+        "nanfunc,func",
+        [(np.nanvar, np.var), (np.nanstd, np.std)],
+        ids=["nanvar", "nanstd"],
+    )
+    def test_nanfunc_ddof(self, mat, dtype, nanfunc, func):
+        mat = mat.astype(dtype)
+        tgt = func(mat, ddof=0.5)
+        out = nanfunc(mat, ddof=0.5)
+
+        assert_almost_equal(out, tgt)
+        if dtype == "O":
+            assert type(out) is type(tgt)
+        else:
+            assert out.dtype == tgt.dtype
+
+    @pytest.mark.parametrize(
+        "nanfunc", [np.nanvar, np.nanstd]
+    )
+    def test_nanfunc_correction(self, mat, dtype, nanfunc):
+        mat = mat.astype(dtype)
+        assert_almost_equal(
+            nanfunc(mat, correction=0.5), nanfunc(mat, ddof=0.5)
+        )
+
+        err_msg = "ddof and correction can't be provided simultaneously."
+        with assert_raises_regex(ValueError, err_msg):
+            nanfunc(mat, ddof=0.5, correction=0.5)
+
+        with assert_raises_regex(ValueError, err_msg):
+            nanfunc(mat, ddof=1, correction=0)
+
+
+class SharedNanFunctionsTestsMixin:
+    def test_mutation(self):
+        # Check that passed array is not modified.
+        ndat = _ndat.copy()
+        for f in self.nanfuncs:
+            f(ndat)
+            assert_equal(ndat, _ndat)
+
+    def test_keepdims(self):
+        mat = np.eye(3)
+        for nf, rf in zip(self.nanfuncs, self.stdfuncs):
+            for axis in [None, 0, 1]:
+                tgt = rf(mat, axis=axis, keepdims=True)
+                res = nf(mat, axis=axis, keepdims=True)
+                assert_(res.ndim == tgt.ndim)
+
+    def test_out(self):
+        mat = np.eye(3)
+        for nf, rf in zip(self.nanfuncs, self.stdfuncs):
+            resout = np.zeros(3)
+            tgt = rf(mat, axis=1)
+            res = nf(mat, axis=1, out=resout)
+            assert_almost_equal(res, resout)
+            assert_almost_equal(res, tgt)
+
+    def test_dtype_from_dtype(self):
+        mat = np.eye(3)
+        codes = 'efdgFDG'
+        for nf, rf in zip(self.nanfuncs, self.stdfuncs):
+            for c in codes:
+                with suppress_warnings() as sup:
+                    if nf in {np.nanstd, np.nanvar} and c in 'FDG':
+                        # Giving the warning is a small bug, see gh-8000
+                        sup.filter(ComplexWarning)
+                    tgt = rf(mat, dtype=np.dtype(c), axis=1).dtype.type
+                    res = nf(mat, dtype=np.dtype(c), axis=1).dtype.type
+                    assert_(res is tgt)
+                    # scalar case
+                    tgt = rf(mat, dtype=np.dtype(c), axis=None).dtype.type
+                    res = nf(mat, dtype=np.dtype(c), axis=None).dtype.type
+                    assert_(res is tgt)
+
+    def test_dtype_from_char(self):
+        mat = np.eye(3)
+        codes = 'efdgFDG'
+        for nf, rf in zip(self.nanfuncs, self.stdfuncs):
+            for c in codes:
+                with suppress_warnings() as sup:
+                    if nf in {np.nanstd, np.nanvar} and c in 'FDG':
+                        # Giving the warning is a small bug, see gh-8000
+                        sup.filter(ComplexWarning)
+                    tgt = rf(mat, dtype=c, axis=1).dtype.type
+                    res = nf(mat, dtype=c, axis=1).dtype.type
+                    assert_(res is tgt)
+                    # scalar case
+                    tgt = rf(mat, dtype=c, axis=None).dtype.type
+                    res = nf(mat, dtype=c, axis=None).dtype.type
+                    assert_(res is tgt)
+
+    def test_dtype_from_input(self):
+        codes = 'efdgFDG'
+        for nf, rf in zip(self.nanfuncs, self.stdfuncs):
+            for c in codes:
+                mat = np.eye(3, dtype=c)
+                tgt = rf(mat, axis=1).dtype.type
+                res = nf(mat, axis=1).dtype.type
+                assert_(res is tgt, "res %s, tgt %s" % (res, tgt))
+                # scalar case
+                tgt = rf(mat, axis=None).dtype.type
+                res = nf(mat, axis=None).dtype.type
+                assert_(res is tgt)
+
+    def test_result_values(self):
+        for nf, rf in zip(self.nanfuncs, self.stdfuncs):
+            tgt = [rf(d) for d in _rdat]
+            res = nf(_ndat, axis=1)
+            assert_almost_equal(res, tgt)
+
+    def test_scalar(self):
+        for f in self.nanfuncs:
+            assert_(f(0.) == 0.)
+
+    def test_subclass(self):
+        class MyNDArray(np.ndarray):
+            pass
+
+        # Check that it works and that type and
+        # shape are preserved
+        array = np.eye(3)
+        mine = array.view(MyNDArray)
+        for f in self.nanfuncs:
+            expected_shape = f(array, axis=0).shape
+            res = f(mine, axis=0)
+            assert_(isinstance(res, MyNDArray))
+            assert_(res.shape == expected_shape)
+            expected_shape = f(array, axis=1).shape
+            res = f(mine, axis=1)
+            assert_(isinstance(res, MyNDArray))
+            assert_(res.shape == expected_shape)
+            expected_shape = f(array).shape
+            res = f(mine)
+            assert_(isinstance(res, MyNDArray))
+            assert_(res.shape == expected_shape)
+
+
+class TestNanFunctions_SumProd(SharedNanFunctionsTestsMixin):
+
+    nanfuncs = [np.nansum, np.nanprod]
+    stdfuncs = [np.sum, np.prod]
+
+    @pytest.mark.parametrize("axis", [None, 0, 1])
+    @pytest.mark.parametrize("dtype", np.typecodes["AllFloat"])
+    @pytest.mark.parametrize("array", [
+        np.array(np.nan),
+        np.full((3, 3), np.nan),
+    ], ids=["0d", "2d"])
+    def test_allnans(self, axis, dtype, array):
+        if axis is not None and array.ndim == 0:
+            pytest.skip(f"`axis != None` not supported for 0d arrays")
+
+        array = array.astype(dtype)
+        for func, identity in zip(self.nanfuncs, [0, 1]):
+            out = func(array, axis=axis)
+            assert np.all(out == identity)
+            assert out.dtype == array.dtype
+
+    def test_empty(self):
+        for f, tgt_value in zip([np.nansum, np.nanprod], [0, 1]):
+            mat = np.zeros((0, 3))
+            tgt = [tgt_value]*3
+            res = f(mat, axis=0)
+            assert_equal(res, tgt)
+            tgt = []
+            res = f(mat, axis=1)
+            assert_equal(res, tgt)
+            tgt = tgt_value
+            res = f(mat, axis=None)
+            assert_equal(res, tgt)
+
+    @pytest.mark.parametrize("dtype", np.typecodes["AllFloat"])
+    def test_initial(self, dtype):
+        ar = np.arange(9).astype(dtype)
+        ar[:5] = np.nan
+
+        for f in self.nanfuncs:
+            reference = 28 if f is np.nansum else 3360
+            ret = f(ar, initial=2)
+            assert ret.dtype == dtype
+            assert ret == reference
+
+    @pytest.mark.parametrize("dtype", np.typecodes["AllFloat"])
+    def test_where(self, dtype):
+        ar = np.arange(9).reshape(3, 3).astype(dtype)
+        ar[0, :] = np.nan
+        where = np.ones_like(ar, dtype=np.bool)
+        where[:, 0] = False
+
+        for f in self.nanfuncs:
+            reference = 26 if f is np.nansum else 2240
+            ret = f(ar, where=where, initial=2)
+            assert ret.dtype == dtype
+            assert ret == reference
+
+
+class TestNanFunctions_CumSumProd(SharedNanFunctionsTestsMixin):
+
+    nanfuncs = [np.nancumsum, np.nancumprod]
+    stdfuncs = [np.cumsum, np.cumprod]
+
+    @pytest.mark.parametrize("axis", [None, 0, 1])
+    @pytest.mark.parametrize("dtype", np.typecodes["AllFloat"])
+    @pytest.mark.parametrize("array", [
+        np.array(np.nan),
+        np.full((3, 3), np.nan)
+    ], ids=["0d", "2d"])
+    def test_allnans(self, axis, dtype, array):
+        if axis is not None and array.ndim == 0:
+            pytest.skip(f"`axis != None` not supported for 0d arrays")
+
+        array = array.astype(dtype)
+        for func, identity in zip(self.nanfuncs, [0, 1]):
+            out = func(array)
+            assert np.all(out == identity)
+            assert out.dtype == array.dtype
+
+    def test_empty(self):
+        for f, tgt_value in zip(self.nanfuncs, [0, 1]):
+            mat = np.zeros((0, 3))
+            tgt = tgt_value*np.ones((0, 3))
+            res = f(mat, axis=0)
+            assert_equal(res, tgt)
+            tgt = mat
+            res = f(mat, axis=1)
+            assert_equal(res, tgt)
+            tgt = np.zeros(0)
+            res = f(mat, axis=None)
+            assert_equal(res, tgt)
+
+    def test_keepdims(self):
+        for f, g in zip(self.nanfuncs, self.stdfuncs):
+            mat = np.eye(3)
+            for axis in [None, 0, 1]:
+                tgt = f(mat, axis=axis, out=None)
+                res = g(mat, axis=axis, out=None)
+                assert_(res.ndim == tgt.ndim)
+
+        for f in self.nanfuncs:
+            d = np.ones((3, 5, 7, 11))
+            # Randomly set some elements to NaN:
+            rs = np.random.RandomState(0)
+            d[rs.rand(*d.shape) < 0.5] = np.nan
+            res = f(d, axis=None)
+            assert_equal(res.shape, (1155,))
+            for axis in np.arange(4):
+                res = f(d, axis=axis)
+                assert_equal(res.shape, (3, 5, 7, 11))
+
+    def test_result_values(self):
+        for axis in (-2, -1, 0, 1, None):
+            tgt = np.cumprod(_ndat_ones, axis=axis)
+            res = np.nancumprod(_ndat, axis=axis)
+            assert_almost_equal(res, tgt)
+            tgt = np.cumsum(_ndat_zeros,axis=axis)
+            res = np.nancumsum(_ndat, axis=axis)
+            assert_almost_equal(res, tgt)
+
+    def test_out(self):
+        mat = np.eye(3)
+        for nf, rf in zip(self.nanfuncs, self.stdfuncs):
+            resout = np.eye(3)
+            for axis in (-2, -1, 0, 1):
+                tgt = rf(mat, axis=axis)
+                res = nf(mat, axis=axis, out=resout)
+                assert_almost_equal(res, resout)
+                assert_almost_equal(res, tgt)
+
+
+class TestNanFunctions_MeanVarStd(SharedNanFunctionsTestsMixin):
+
+    nanfuncs = [np.nanmean, np.nanvar, np.nanstd]
+    stdfuncs = [np.mean, np.var, np.std]
+
+    def test_dtype_error(self):
+        for f in self.nanfuncs:
+            for dtype in [np.bool, np.int_, np.object_]:
+                assert_raises(TypeError, f, _ndat, axis=1, dtype=dtype)
+
+    def test_out_dtype_error(self):
+        for f in self.nanfuncs:
+            for dtype in [np.bool, np.int_, np.object_]:
+                out = np.empty(_ndat.shape[0], dtype=dtype)
+                assert_raises(TypeError, f, _ndat, axis=1, out=out)
+
+    def test_ddof(self):
+        nanfuncs = [np.nanvar, np.nanstd]
+        stdfuncs = [np.var, np.std]
+        for nf, rf in zip(nanfuncs, stdfuncs):
+            for ddof in [0, 1]:
+                tgt = [rf(d, ddof=ddof) for d in _rdat]
+                res = nf(_ndat, axis=1, ddof=ddof)
+                assert_almost_equal(res, tgt)
+
+    def test_ddof_too_big(self):
+        nanfuncs = [np.nanvar, np.nanstd]
+        stdfuncs = [np.var, np.std]
+        dsize = [len(d) for d in _rdat]
+        for nf, rf in zip(nanfuncs, stdfuncs):
+            for ddof in range(5):
+                with suppress_warnings() as sup:
+                    sup.record(RuntimeWarning)
+                    sup.filter(ComplexWarning)
+                    tgt = [ddof >= d for d in dsize]
+                    res = nf(_ndat, axis=1, ddof=ddof)
+                    assert_equal(np.isnan(res), tgt)
+                    if any(tgt):
+                        assert_(len(sup.log) == 1)
+                    else:
+                        assert_(len(sup.log) == 0)
+
+    @pytest.mark.parametrize("axis", [None, 0, 1])
+    @pytest.mark.parametrize("dtype", np.typecodes["AllFloat"])
+    @pytest.mark.parametrize("array", [
+        np.array(np.nan),
+        np.full((3, 3), np.nan),
+    ], ids=["0d", "2d"])
+    def test_allnans(self, axis, dtype, array):
+        if axis is not None and array.ndim == 0:
+            pytest.skip(f"`axis != None` not supported for 0d arrays")
+
+        array = array.astype(dtype)
+        match = "(Degrees of freedom <= 0 for slice.)|(Mean of empty slice)"
+        for func in self.nanfuncs:
+            with pytest.warns(RuntimeWarning, match=match):
+                out = func(array, axis=axis)
+            assert np.isnan(out).all()
+
+            # `nanvar` and `nanstd` convert complex inputs to their
+            # corresponding floating dtype
+            if func is np.nanmean:
+                assert out.dtype == array.dtype
+            else:
+                assert out.dtype == np.abs(array).dtype
+
+    def test_empty(self):
+        mat = np.zeros((0, 3))
+        for f in self.nanfuncs:
+            for axis in [0, None]:
+                with warnings.catch_warnings(record=True) as w:
+                    warnings.simplefilter('always')
+                    assert_(np.isnan(f(mat, axis=axis)).all())
+                    assert_(len(w) == 1)
+                    assert_(issubclass(w[0].category, RuntimeWarning))
+            for axis in [1]:
+                with warnings.catch_warnings(record=True) as w:
+                    warnings.simplefilter('always')
+                    assert_equal(f(mat, axis=axis), np.zeros([]))
+                    assert_(len(w) == 0)
+
+    @pytest.mark.parametrize("dtype", np.typecodes["AllFloat"])
+    def test_where(self, dtype):
+        ar = np.arange(9).reshape(3, 3).astype(dtype)
+        ar[0, :] = np.nan
+        where = np.ones_like(ar, dtype=np.bool)
+        where[:, 0] = False
+
+        for f, f_std in zip(self.nanfuncs, self.stdfuncs):
+            reference = f_std(ar[where][2:])
+            dtype_reference = dtype if f is np.nanmean else ar.real.dtype
+
+            ret = f(ar, where=where)
+            assert ret.dtype == dtype_reference
+            np.testing.assert_allclose(ret, reference)
+
+    def test_nanstd_with_mean_keyword(self):
+        # Setting the seed to make the test reproducible
+        rng = np.random.RandomState(1234)
+        A = rng.randn(10, 20, 5) + 0.5
+        A[:, 5, :] = np.nan
+
+        mean_out = np.zeros((10, 1, 5))
+        std_out = np.zeros((10, 1, 5))
+
+        mean = np.nanmean(A,
+                       out=mean_out,
+                       axis=1,
+                       keepdims=True)
+
+        # The returned  object should be the object specified during calling
+        assert mean_out is mean
+
+        std = np.nanstd(A,
+                     out=std_out,
+                     axis=1,
+                     keepdims=True,
+                     mean=mean)
+
+        # The returned  object should be the object specified during calling
+        assert std_out is std
+
+        # Shape of returned mean and std should be same
+        assert std.shape == mean.shape
+        assert std.shape == (10, 1, 5)
+
+        # Output should be the same as from the individual algorithms
+        std_old = np.nanstd(A, axis=1, keepdims=True)
+
+        assert std_old.shape == mean.shape
+        assert_almost_equal(std, std_old)
+
+_TIME_UNITS = (
+    "Y", "M", "W", "D", "h", "m", "s", "ms", "us", "ns", "ps", "fs", "as"
+)
+
+# All `inexact` + `timdelta64` type codes
+_TYPE_CODES = list(np.typecodes["AllFloat"])
+_TYPE_CODES += [f"m8[{unit}]" for unit in _TIME_UNITS]
+
+
+class TestNanFunctions_Median:
+
+    def test_mutation(self):
+        # Check that passed array is not modified.
+        ndat = _ndat.copy()
+        np.nanmedian(ndat)
+        assert_equal(ndat, _ndat)
+
+    def test_keepdims(self):
+        mat = np.eye(3)
+        for axis in [None, 0, 1]:
+            tgt = np.median(mat, axis=axis, out=None, overwrite_input=False)
+            res = np.nanmedian(mat, axis=axis, out=None, overwrite_input=False)
+            assert_(res.ndim == tgt.ndim)
+
+        d = np.ones((3, 5, 7, 11))
+        # Randomly set some elements to NaN:
+        w = np.random.random((4, 200)) * np.array(d.shape)[:, None]
+        w = w.astype(np.intp)
+        d[tuple(w)] = np.nan
+        with suppress_warnings() as sup:
+            sup.filter(RuntimeWarning)
+            res = np.nanmedian(d, axis=None, keepdims=True)
+            assert_equal(res.shape, (1, 1, 1, 1))
+            res = np.nanmedian(d, axis=(0, 1), keepdims=True)
+            assert_equal(res.shape, (1, 1, 7, 11))
+            res = np.nanmedian(d, axis=(0, 3), keepdims=True)
+            assert_equal(res.shape, (1, 5, 7, 1))
+            res = np.nanmedian(d, axis=(1,), keepdims=True)
+            assert_equal(res.shape, (3, 1, 7, 11))
+            res = np.nanmedian(d, axis=(0, 1, 2, 3), keepdims=True)
+            assert_equal(res.shape, (1, 1, 1, 1))
+            res = np.nanmedian(d, axis=(0, 1, 3), keepdims=True)
+            assert_equal(res.shape, (1, 1, 7, 1))
+
+    @pytest.mark.parametrize(
+        argnames='axis',
+        argvalues=[
+            None,
+            1,
+            (1, ),
+            (0, 1),
+            (-3, -1),
+        ]
+    )
+    @pytest.mark.filterwarnings("ignore:All-NaN slice:RuntimeWarning")
+    def test_keepdims_out(self, axis):
+        d = np.ones((3, 5, 7, 11))
+        # Randomly set some elements to NaN:
+        w = np.random.random((4, 200)) * np.array(d.shape)[:, None]
+        w = w.astype(np.intp)
+        d[tuple(w)] = np.nan
+        if axis is None:
+            shape_out = (1,) * d.ndim
+        else:
+            axis_norm = normalize_axis_tuple(axis, d.ndim)
+            shape_out = tuple(
+                1 if i in axis_norm else d.shape[i] for i in range(d.ndim))
+        out = np.empty(shape_out)
+        result = np.nanmedian(d, axis=axis, keepdims=True, out=out)
+        assert result is out
+        assert_equal(result.shape, shape_out)
+
+    def test_out(self):
+        mat = np.random.rand(3, 3)
+        nan_mat = np.insert(mat, [0, 2], np.nan, axis=1)
+        resout = np.zeros(3)
+        tgt = np.median(mat, axis=1)
+        res = np.nanmedian(nan_mat, axis=1, out=resout)
+        assert_almost_equal(res, resout)
+        assert_almost_equal(res, tgt)
+        # 0-d output:
+        resout = np.zeros(())
+        tgt = np.median(mat, axis=None)
+        res = np.nanmedian(nan_mat, axis=None, out=resout)
+        assert_almost_equal(res, resout)
+        assert_almost_equal(res, tgt)
+        res = np.nanmedian(nan_mat, axis=(0, 1), out=resout)
+        assert_almost_equal(res, resout)
+        assert_almost_equal(res, tgt)
+
+    def test_small_large(self):
+        # test the small and large code paths, current cutoff 400 elements
+        for s in [5, 20, 51, 200, 1000]:
+            d = np.random.randn(4, s)
+            # Randomly set some elements to NaN:
+            w = np.random.randint(0, d.size, size=d.size // 5)
+            d.ravel()[w] = np.nan
+            d[:,0] = 1.  # ensure at least one good value
+            # use normal median without nans to compare
+            tgt = []
+            for x in d:
+                nonan = np.compress(~np.isnan(x), x)
+                tgt.append(np.median(nonan, overwrite_input=True))
+
+            assert_array_equal(np.nanmedian(d, axis=-1), tgt)
+
+    def test_result_values(self):
+            tgt = [np.median(d) for d in _rdat]
+            res = np.nanmedian(_ndat, axis=1)
+            assert_almost_equal(res, tgt)
+
+    @pytest.mark.parametrize("axis", [None, 0, 1])
+    @pytest.mark.parametrize("dtype", _TYPE_CODES)
+    def test_allnans(self, dtype, axis):
+        mat = np.full((3, 3), np.nan).astype(dtype)
+        with suppress_warnings() as sup:
+            sup.record(RuntimeWarning)
+
+            output = np.nanmedian(mat, axis=axis)
+            assert output.dtype == mat.dtype
+            assert np.isnan(output).all()
+
+            if axis is None:
+                assert_(len(sup.log) == 1)
+            else:
+                assert_(len(sup.log) == 3)
+
+            # Check scalar
+            scalar = np.array(np.nan).astype(dtype)[()]
+            output_scalar = np.nanmedian(scalar)
+            assert output_scalar.dtype == scalar.dtype
+            assert np.isnan(output_scalar)
+
+            if axis is None:
+                assert_(len(sup.log) == 2)
+            else:
+                assert_(len(sup.log) == 4)
+
+    def test_empty(self):
+        mat = np.zeros((0, 3))
+        for axis in [0, None]:
+            with warnings.catch_warnings(record=True) as w:
+                warnings.simplefilter('always')
+                assert_(np.isnan(np.nanmedian(mat, axis=axis)).all())
+                assert_(len(w) == 1)
+                assert_(issubclass(w[0].category, RuntimeWarning))
+        for axis in [1]:
+            with warnings.catch_warnings(record=True) as w:
+                warnings.simplefilter('always')
+                assert_equal(np.nanmedian(mat, axis=axis), np.zeros([]))
+                assert_(len(w) == 0)
+
+    def test_scalar(self):
+        assert_(np.nanmedian(0.) == 0.)
+
+    def test_extended_axis_invalid(self):
+        d = np.ones((3, 5, 7, 11))
+        assert_raises(AxisError, np.nanmedian, d, axis=-5)
+        assert_raises(AxisError, np.nanmedian, d, axis=(0, -5))
+        assert_raises(AxisError, np.nanmedian, d, axis=4)
+        assert_raises(AxisError, np.nanmedian, d, axis=(0, 4))
+        assert_raises(ValueError, np.nanmedian, d, axis=(1, 1))
+
+    def test_float_special(self):
+        with suppress_warnings() as sup:
+            sup.filter(RuntimeWarning)
+            for inf in [np.inf, -np.inf]:
+                a = np.array([[inf,  np.nan], [np.nan, np.nan]])
+                assert_equal(np.nanmedian(a, axis=0), [inf,  np.nan])
+                assert_equal(np.nanmedian(a, axis=1), [inf,  np.nan])
+                assert_equal(np.nanmedian(a), inf)
+
+                # minimum fill value check
+                a = np.array([[np.nan, np.nan, inf],
+                             [np.nan, np.nan, inf]])
+                assert_equal(np.nanmedian(a), inf)
+                assert_equal(np.nanmedian(a, axis=0), [np.nan, np.nan, inf])
+                assert_equal(np.nanmedian(a, axis=1), inf)
+
+                # no mask path
+                a = np.array([[inf, inf], [inf, inf]])
+                assert_equal(np.nanmedian(a, axis=1), inf)
+
+                a = np.array([[inf, 7, -inf, -9],
+                              [-10, np.nan, np.nan, 5],
+                              [4, np.nan, np.nan, inf]],
+                              dtype=np.float32)
+                if inf > 0:
+                    assert_equal(np.nanmedian(a, axis=0), [4., 7., -inf, 5.])
+                    assert_equal(np.nanmedian(a), 4.5)
+                else:
+                    assert_equal(np.nanmedian(a, axis=0), [-10., 7., -inf, -9.])
+                    assert_equal(np.nanmedian(a), -2.5)
+                assert_equal(np.nanmedian(a, axis=-1), [-1., -2.5, inf])
+
+                for i in range(0, 10):
+                    for j in range(1, 10):
+                        a = np.array([([np.nan] * i) + ([inf] * j)] * 2)
+                        assert_equal(np.nanmedian(a), inf)
+                        assert_equal(np.nanmedian(a, axis=1), inf)
+                        assert_equal(np.nanmedian(a, axis=0),
+                                     ([np.nan] * i) + [inf] * j)
+
+                        a = np.array([([np.nan] * i) + ([-inf] * j)] * 2)
+                        assert_equal(np.nanmedian(a), -inf)
+                        assert_equal(np.nanmedian(a, axis=1), -inf)
+                        assert_equal(np.nanmedian(a, axis=0),
+                                     ([np.nan] * i) + [-inf] * j)
+
+
+class TestNanFunctions_Percentile:
+
+    def test_mutation(self):
+        # Check that passed array is not modified.
+        ndat = _ndat.copy()
+        np.nanpercentile(ndat, 30)
+        assert_equal(ndat, _ndat)
+
+    def test_keepdims(self):
+        mat = np.eye(3)
+        for axis in [None, 0, 1]:
+            tgt = np.percentile(mat, 70, axis=axis, out=None,
+                                overwrite_input=False)
+            res = np.nanpercentile(mat, 70, axis=axis, out=None,
+                                   overwrite_input=False)
+            assert_(res.ndim == tgt.ndim)
+
+        d = np.ones((3, 5, 7, 11))
+        # Randomly set some elements to NaN:
+        w = np.random.random((4, 200)) * np.array(d.shape)[:, None]
+        w = w.astype(np.intp)
+        d[tuple(w)] = np.nan
+        with suppress_warnings() as sup:
+            sup.filter(RuntimeWarning)
+            res = np.nanpercentile(d, 90, axis=None, keepdims=True)
+            assert_equal(res.shape, (1, 1, 1, 1))
+            res = np.nanpercentile(d, 90, axis=(0, 1), keepdims=True)
+            assert_equal(res.shape, (1, 1, 7, 11))
+            res = np.nanpercentile(d, 90, axis=(0, 3), keepdims=True)
+            assert_equal(res.shape, (1, 5, 7, 1))
+            res = np.nanpercentile(d, 90, axis=(1,), keepdims=True)
+            assert_equal(res.shape, (3, 1, 7, 11))
+            res = np.nanpercentile(d, 90, axis=(0, 1, 2, 3), keepdims=True)
+            assert_equal(res.shape, (1, 1, 1, 1))
+            res = np.nanpercentile(d, 90, axis=(0, 1, 3), keepdims=True)
+            assert_equal(res.shape, (1, 1, 7, 1))
+
+    @pytest.mark.parametrize('q', [7, [1, 7]])
+    @pytest.mark.parametrize(
+        argnames='axis',
+        argvalues=[
+            None,
+            1,
+            (1,),
+            (0, 1),
+            (-3, -1),
+        ]
+    )
+    @pytest.mark.filterwarnings("ignore:All-NaN slice:RuntimeWarning")
+    def test_keepdims_out(self, q, axis):
+        d = np.ones((3, 5, 7, 11))
+        # Randomly set some elements to NaN:
+        w = np.random.random((4, 200)) * np.array(d.shape)[:, None]
+        w = w.astype(np.intp)
+        d[tuple(w)] = np.nan
+        if axis is None:
+            shape_out = (1,) * d.ndim
+        else:
+            axis_norm = normalize_axis_tuple(axis, d.ndim)
+            shape_out = tuple(
+                1 if i in axis_norm else d.shape[i] for i in range(d.ndim))
+        shape_out = np.shape(q) + shape_out
+
+        out = np.empty(shape_out)
+        result = np.nanpercentile(d, q, axis=axis, keepdims=True, out=out)
+        assert result is out
+        assert_equal(result.shape, shape_out)
+
+    @pytest.mark.parametrize("weighted", [False, True])
+    def test_out(self, weighted):
+        mat = np.random.rand(3, 3)
+        nan_mat = np.insert(mat, [0, 2], np.nan, axis=1)
+        resout = np.zeros(3)
+        if weighted:
+            w_args = {"weights": np.ones_like(mat), "method": "inverted_cdf"}
+            nan_w_args = {
+                "weights": np.ones_like(nan_mat), "method": "inverted_cdf"
+            }
+        else:
+            w_args = dict()
+            nan_w_args = dict()
+        tgt = np.percentile(mat, 42, axis=1, **w_args)
+        res = np.nanpercentile(nan_mat, 42, axis=1, out=resout, **nan_w_args)
+        assert_almost_equal(res, resout)
+        assert_almost_equal(res, tgt)
+        # 0-d output:
+        resout = np.zeros(())
+        tgt = np.percentile(mat, 42, axis=None, **w_args)
+        res = np.nanpercentile(
+            nan_mat, 42, axis=None, out=resout, **nan_w_args
+        )
+        assert_almost_equal(res, resout)
+        assert_almost_equal(res, tgt)
+        res = np.nanpercentile(
+            nan_mat, 42, axis=(0, 1), out=resout, **nan_w_args
+        )
+        assert_almost_equal(res, resout)
+        assert_almost_equal(res, tgt)
+
+    def test_complex(self):
+        arr_c = np.array([0.5+3.0j, 2.1+0.5j, 1.6+2.3j], dtype='G')
+        assert_raises(TypeError, np.nanpercentile, arr_c, 0.5)
+        arr_c = np.array([0.5+3.0j, 2.1+0.5j, 1.6+2.3j], dtype='D')
+        assert_raises(TypeError, np.nanpercentile, arr_c, 0.5)
+        arr_c = np.array([0.5+3.0j, 2.1+0.5j, 1.6+2.3j], dtype='F')
+        assert_raises(TypeError, np.nanpercentile, arr_c, 0.5)
+
+    @pytest.mark.parametrize("weighted", [False, True])
+    @pytest.mark.parametrize("use_out", [False, True])
+    def test_result_values(self, weighted, use_out):
+        if weighted:
+            percentile = partial(np.percentile, method="inverted_cdf")
+            nanpercentile = partial(np.nanpercentile, method="inverted_cdf")
+
+            def gen_weights(d):
+                return np.ones_like(d)
+
+        else:
+            percentile = np.percentile
+            nanpercentile = np.nanpercentile
+
+            def gen_weights(d):
+                return None
+
+        tgt = [percentile(d, 28, weights=gen_weights(d)) for d in _rdat]
+        out = np.empty_like(tgt) if use_out else None
+        res = nanpercentile(_ndat, 28, axis=1,
+                            weights=gen_weights(_ndat), out=out)
+        assert_almost_equal(res, tgt)
+        # Transpose the array to fit the output convention of numpy.percentile
+        tgt = np.transpose([percentile(d, (28, 98), weights=gen_weights(d))
+                            for d in _rdat])
+        out = np.empty_like(tgt) if use_out else None
+        res = nanpercentile(_ndat, (28, 98), axis=1,
+                            weights=gen_weights(_ndat), out=out)
+        assert_almost_equal(res, tgt)
+
+    @pytest.mark.parametrize("axis", [None, 0, 1])
+    @pytest.mark.parametrize("dtype", np.typecodes["Float"])
+    @pytest.mark.parametrize("array", [
+        np.array(np.nan),
+        np.full((3, 3), np.nan),
+    ], ids=["0d", "2d"])
+    def test_allnans(self, axis, dtype, array):
+        if axis is not None and array.ndim == 0:
+            pytest.skip(f"`axis != None` not supported for 0d arrays")
+
+        array = array.astype(dtype)
+        with pytest.warns(RuntimeWarning, match="All-NaN slice encountered"):
+            out = np.nanpercentile(array, 60, axis=axis)
+        assert np.isnan(out).all()
+        assert out.dtype == array.dtype
+
+    def test_empty(self):
+        mat = np.zeros((0, 3))
+        for axis in [0, None]:
+            with warnings.catch_warnings(record=True) as w:
+                warnings.simplefilter('always')
+                assert_(np.isnan(np.nanpercentile(mat, 40, axis=axis)).all())
+                assert_(len(w) == 1)
+                assert_(issubclass(w[0].category, RuntimeWarning))
+        for axis in [1]:
+            with warnings.catch_warnings(record=True) as w:
+                warnings.simplefilter('always')
+                assert_equal(np.nanpercentile(mat, 40, axis=axis), np.zeros([]))
+                assert_(len(w) == 0)
+
+    def test_scalar(self):
+        assert_equal(np.nanpercentile(0., 100), 0.)
+        a = np.arange(6)
+        r = np.nanpercentile(a, 50, axis=0)
+        assert_equal(r, 2.5)
+        assert_(np.isscalar(r))
+
+    def test_extended_axis_invalid(self):
+        d = np.ones((3, 5, 7, 11))
+        assert_raises(AxisError, np.nanpercentile, d, q=5, axis=-5)
+        assert_raises(AxisError, np.nanpercentile, d, q=5, axis=(0, -5))
+        assert_raises(AxisError, np.nanpercentile, d, q=5, axis=4)
+        assert_raises(AxisError, np.nanpercentile, d, q=5, axis=(0, 4))
+        assert_raises(ValueError, np.nanpercentile, d, q=5, axis=(1, 1))
+
+    def test_multiple_percentiles(self):
+        perc = [50, 100]
+        mat = np.ones((4, 3))
+        nan_mat = np.nan * mat
+        # For checking consistency in higher dimensional case
+        large_mat = np.ones((3, 4, 5))
+        large_mat[:, 0:2:4, :] = 0
+        large_mat[:, :, 3:] *= 2
+        for axis in [None, 0, 1]:
+            for keepdim in [False, True]:
+                with suppress_warnings() as sup:
+                    sup.filter(RuntimeWarning, "All-NaN slice encountered")
+                    val = np.percentile(mat, perc, axis=axis, keepdims=keepdim)
+                    nan_val = np.nanpercentile(nan_mat, perc, axis=axis,
+                                               keepdims=keepdim)
+                    assert_equal(nan_val.shape, val.shape)
+
+                    val = np.percentile(large_mat, perc, axis=axis,
+                                        keepdims=keepdim)
+                    nan_val = np.nanpercentile(large_mat, perc, axis=axis,
+                                               keepdims=keepdim)
+                    assert_equal(nan_val, val)
+
+        megamat = np.ones((3, 4, 5, 6))
+        assert_equal(
+            np.nanpercentile(megamat, perc, axis=(1, 2)).shape, (2, 3, 6)
+        )
+
+    @pytest.mark.parametrize("nan_weight", [0, 1, 2, 3, 1e200])
+    def test_nan_value_with_weight(self, nan_weight):
+        x = [1, np.nan, 2, 3]
+        result = np.float64(2.0)
+        q_unweighted = np.nanpercentile(x, 50, method="inverted_cdf")
+        assert_equal(q_unweighted, result)
+
+        # The weight value at the nan position should not matter.
+        w = [1.0, nan_weight, 1.0, 1.0]
+        q_weighted = np.nanpercentile(x, 50, weights=w, method="inverted_cdf")
+        assert_equal(q_weighted, result)
+
+    @pytest.mark.parametrize("axis", [0, 1, 2])
+    def test_nan_value_with_weight_ndim(self, axis):
+        # Create a multi-dimensional array to test
+        np.random.seed(1)
+        x_no_nan = np.random.random(size=(100, 99, 2))
+        # Set some places to NaN (not particularly smart) so there is always
+        # some non-Nan.
+        x = x_no_nan.copy()
+        x[np.arange(99), np.arange(99), 0] = np.nan
+
+        p = np.array([[20., 50., 30], [70, 33, 80]])
+
+        # We just use ones as weights, but replace it with 0 or 1e200 at the
+        # NaN positions below.
+        weights = np.ones_like(x)
+
+        # For comparison use weighted normal percentile with nan weights at
+        # 0 (and no NaNs); not sure this is strictly identical but should be
+        # sufficiently so (if a percentile lies exactly on a 0 value).
+        weights[np.isnan(x)] = 0
+        p_expected = np.percentile(
+            x_no_nan, p, axis=axis, weights=weights, method="inverted_cdf")
+
+        p_unweighted = np.nanpercentile(
+            x, p, axis=axis, method="inverted_cdf")
+        # The normal and unweighted versions should be identical:
+        assert_equal(p_unweighted, p_expected)
+
+        weights[np.isnan(x)] = 1e200  # huge value, shouldn't matter
+        p_weighted = np.nanpercentile(
+            x, p, axis=axis, weights=weights, method="inverted_cdf")
+        assert_equal(p_weighted, p_expected)
+        # Also check with out passed:
+        out = np.empty_like(p_weighted)
+        res = np.nanpercentile(
+            x, p, axis=axis, weights=weights, out=out, method="inverted_cdf")
+
+        assert res is out
+        assert_equal(out, p_expected)
+
+
+class TestNanFunctions_Quantile:
+    # most of this is already tested by TestPercentile
+
+    @pytest.mark.parametrize("weighted", [False, True])
+    def test_regression(self, weighted):
+        ar = np.arange(24).reshape(2, 3, 4).astype(float)
+        ar[0][1] = np.nan
+        if weighted:
+            w_args = {"weights": np.ones_like(ar), "method": "inverted_cdf"}
+        else:
+            w_args = dict()
+
+        assert_equal(np.nanquantile(ar, q=0.5, **w_args),
+                     np.nanpercentile(ar, q=50, **w_args))
+        assert_equal(np.nanquantile(ar, q=0.5, axis=0, **w_args),
+                     np.nanpercentile(ar, q=50, axis=0, **w_args))
+        assert_equal(np.nanquantile(ar, q=0.5, axis=1, **w_args),
+                     np.nanpercentile(ar, q=50, axis=1, **w_args))
+        assert_equal(np.nanquantile(ar, q=[0.5], axis=1, **w_args),
+                     np.nanpercentile(ar, q=[50], axis=1, **w_args))
+        assert_equal(np.nanquantile(ar, q=[0.25, 0.5, 0.75], axis=1, **w_args),
+                     np.nanpercentile(ar, q=[25, 50, 75], axis=1, **w_args))
+
+    def test_basic(self):
+        x = np.arange(8) * 0.5
+        assert_equal(np.nanquantile(x, 0), 0.)
+        assert_equal(np.nanquantile(x, 1), 3.5)
+        assert_equal(np.nanquantile(x, 0.5), 1.75)
+
+    def test_complex(self):
+        arr_c = np.array([0.5+3.0j, 2.1+0.5j, 1.6+2.3j], dtype='G')
+        assert_raises(TypeError, np.nanquantile, arr_c, 0.5)
+        arr_c = np.array([0.5+3.0j, 2.1+0.5j, 1.6+2.3j], dtype='D')
+        assert_raises(TypeError, np.nanquantile, arr_c, 0.5)
+        arr_c = np.array([0.5+3.0j, 2.1+0.5j, 1.6+2.3j], dtype='F')
+        assert_raises(TypeError, np.nanquantile, arr_c, 0.5)
+
+    def test_no_p_overwrite(self):
+        # this is worth retesting, because quantile does not make a copy
+        p0 = np.array([0, 0.75, 0.25, 0.5, 1.0])
+        p = p0.copy()
+        np.nanquantile(np.arange(100.), p, method="midpoint")
+        assert_array_equal(p, p0)
+
+        p0 = p0.tolist()
+        p = p.tolist()
+        np.nanquantile(np.arange(100.), p, method="midpoint")
+        assert_array_equal(p, p0)
+
+    @pytest.mark.parametrize("axis", [None, 0, 1])
+    @pytest.mark.parametrize("dtype", np.typecodes["Float"])
+    @pytest.mark.parametrize("array", [
+        np.array(np.nan),
+        np.full((3, 3), np.nan),
+    ], ids=["0d", "2d"])
+    def test_allnans(self, axis, dtype, array):
+        if axis is not None and array.ndim == 0:
+            pytest.skip(f"`axis != None` not supported for 0d arrays")
+
+        array = array.astype(dtype)
+        with pytest.warns(RuntimeWarning, match="All-NaN slice encountered"):
+            out = np.nanquantile(array, 1, axis=axis)
+        assert np.isnan(out).all()
+        assert out.dtype == array.dtype
+
+@pytest.mark.parametrize("arr, expected", [
+    # array of floats with some nans
+    (np.array([np.nan, 5.0, np.nan, np.inf]),
+     np.array([False, True, False, True])),
+    # int64 array that can't possibly have nans
+    (np.array([1, 5, 7, 9], dtype=np.int64),
+     True),
+    # bool array that can't possibly have nans
+    (np.array([False, True, False, True]),
+     True),
+    # 2-D complex array with nans
+    (np.array([[np.nan, 5.0],
+               [np.nan, np.inf]], dtype=np.complex64),
+     np.array([[False, True],
+               [False, True]])),
+    ])
+def test__nan_mask(arr, expected):
+    for out in [None, np.empty(arr.shape, dtype=np.bool)]:
+        actual = _nan_mask(arr, out=out)
+        assert_equal(actual, expected)
+        # the above won't distinguish between True proper
+        # and an array of True values; we want True proper
+        # for types that can't possibly contain NaN
+        if type(expected) is not np.ndarray:
+            assert actual is True
+
+
+def test__replace_nan():
+    """ Test that _replace_nan returns the original array if there are no
+    NaNs, not a copy.
+    """
+    for dtype in [np.bool, np.int32, np.int64]:
+        arr = np.array([0, 1], dtype=dtype)
+        result, mask = _replace_nan(arr, 0)
+        assert mask is None
+        # do not make a copy if there are no nans
+        assert result is arr
+
+    for dtype in [np.float32, np.float64]:
+        arr = np.array([0, 1], dtype=dtype)
+        result, mask = _replace_nan(arr, 2)
+        assert (mask == False).all()
+        # mask is not None, so we make a copy
+        assert result is not arr
+        assert_equal(result, arr)
+
+        arr_nan = np.array([0, 1, np.nan], dtype=dtype)
+        result_nan, mask_nan = _replace_nan(arr_nan, 2)
+        assert_equal(mask_nan, np.array([False, False, True]))
+        assert result_nan is not arr_nan
+        assert_equal(result_nan, np.array([0, 1, 2]))
+        assert np.isnan(arr_nan[-1])
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/tests/test_packbits.py b/venv/lib/python3.12/site-packages/numpy/lib/tests/test_packbits.py
new file mode 100644
index 00000000..a4461563
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/lib/tests/test_packbits.py
@@ -0,0 +1,376 @@
+import numpy as np
+from numpy.testing import assert_array_equal, assert_equal, assert_raises
+import pytest
+from itertools import chain
+
+def test_packbits():
+    # Copied from the docstring.
+    a = [[[1, 0, 1], [0, 1, 0]],
+         [[1, 1, 0], [0, 0, 1]]]
+    for dt in '?bBhHiIlLqQ':
+        arr = np.array(a, dtype=dt)
+        b = np.packbits(arr, axis=-1)
+        assert_equal(b.dtype, np.uint8)
+        assert_array_equal(b, np.array([[[160], [64]], [[192], [32]]]))
+
+    assert_raises(TypeError, np.packbits, np.array(a, dtype=float))
+
+
+def test_packbits_empty():
+    shapes = [
+        (0,), (10, 20, 0), (10, 0, 20), (0, 10, 20), (20, 0, 0), (0, 20, 0),
+        (0, 0, 20), (0, 0, 0),
+    ]
+    for dt in '?bBhHiIlLqQ':
+        for shape in shapes:
+            a = np.empty(shape, dtype=dt)
+            b = np.packbits(a)
+            assert_equal(b.dtype, np.uint8)
+            assert_equal(b.shape, (0,))
+
+
+def test_packbits_empty_with_axis():
+    # Original shapes and lists of packed shapes for different axes.
+    shapes = [
+        ((0,), [(0,)]),
+        ((10, 20, 0), [(2, 20, 0), (10, 3, 0), (10, 20, 0)]),
+        ((10, 0, 20), [(2, 0, 20), (10, 0, 20), (10, 0, 3)]),
+        ((0, 10, 20), [(0, 10, 20), (0, 2, 20), (0, 10, 3)]),
+        ((20, 0, 0), [(3, 0, 0), (20, 0, 0), (20, 0, 0)]),
+        ((0, 20, 0), [(0, 20, 0), (0, 3, 0), (0, 20, 0)]),
+        ((0, 0, 20), [(0, 0, 20), (0, 0, 20), (0, 0, 3)]),
+        ((0, 0, 0), [(0, 0, 0), (0, 0, 0), (0, 0, 0)]),
+    ]
+    for dt in '?bBhHiIlLqQ':
+        for in_shape, out_shapes in shapes:
+            for ax, out_shape in enumerate(out_shapes):
+                a = np.empty(in_shape, dtype=dt)
+                b = np.packbits(a, axis=ax)
+                assert_equal(b.dtype, np.uint8)
+                assert_equal(b.shape, out_shape)
+
+@pytest.mark.parametrize('bitorder', ('little', 'big'))
+def test_packbits_large(bitorder):
+    # test data large enough for 16 byte vectorization
+    a = np.array([1, 1, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 0, 0,
+                  0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 1,
+                  1, 1, 0, 1, 0, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 0, 0,
+                  1, 1, 0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 1, 0, 0, 1, 1, 1, 1, 1,
+                  1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1,
+                  1, 0, 1, 0, 1, 0, 1, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 1,
+                  1, 0, 0, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1, 1, 1,
+                  0, 1, 1, 0, 0, 0, 1, 1, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 1, 1,
+                  1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 0,
+                  1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 1, 0, 0, 0, 0, 0, 1, 1, 1,
+                  1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 0, 0, 0,
+                  0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 0, 0, 0, 1, 1, 0, 1,
+                  1, 1, 0, 1, 0, 1, 1, 1, 0, 0, 1, 0, 0, 0, 1, 0, 1, 1, 0, 0,
+                  1, 0, 0, 1, 0, 0, 0, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0,
+                  1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0, 1, 1, 0])
+    a = a.repeat(3)
+    for dtype in '?bBhHiIlLqQ':
+        arr = np.array(a, dtype=dtype)
+        b = np.packbits(arr, axis=None, bitorder=bitorder)
+        assert_equal(b.dtype, np.uint8)
+        r = [252, 127, 192, 3, 254, 7, 252, 0, 7, 31, 240, 0, 28, 1, 255, 252,
+             113, 248, 3, 255, 192, 28, 15, 192, 28, 126, 0, 224, 127, 255,
+             227, 142, 7, 31, 142, 63, 28, 126, 56, 227, 240, 0, 227, 128, 63,
+             224, 14, 56, 252, 112, 56, 255, 241, 248, 3, 240, 56, 224, 112,
+             63, 255, 255, 199, 224, 14, 0, 31, 143, 192, 3, 255, 199, 0, 1,
+             255, 224, 1, 255, 252, 126, 63, 0, 1, 192, 252, 14, 63, 0, 15,
+             199, 252, 113, 255, 3, 128, 56, 252, 14, 7, 0, 113, 255, 255, 142, 56, 227,
+             129, 248, 227, 129, 199, 31, 128]
+        if bitorder == 'big':
+            assert_array_equal(b, r)
+        # equal for size being multiple of 8
+        assert_array_equal(np.unpackbits(b, bitorder=bitorder)[:-4], a)
+
+        # check last byte of different remainders (16 byte vectorization)
+        b = [np.packbits(arr[:-i], axis=None)[-1] for i in range(1, 16)]
+        assert_array_equal(b, [128, 128, 128, 31, 30, 28, 24, 16, 0, 0, 0, 199,
+                               198, 196, 192])
+
+
+        arr = arr.reshape(36, 25)
+        b = np.packbits(arr, axis=0)
+        assert_equal(b.dtype, np.uint8)
+        assert_array_equal(b, [[190, 186, 178, 178, 150, 215, 87, 83, 83, 195,
+                                199, 206, 204, 204, 140, 140, 136, 136, 8, 40, 105,
+                                107, 75, 74, 88],
+                               [72, 216, 248, 241, 227, 195, 202, 90, 90, 83,
+                                83, 119, 127, 109, 73, 64, 208, 244, 189, 45,
+                                41, 104, 122, 90, 18],
+                               [113, 120, 248, 216, 152, 24, 60, 52, 182, 150,
+                                150, 150, 146, 210, 210, 246, 255, 255, 223,
+                                151, 21, 17, 17, 131, 163],
+                               [214, 210, 210, 64, 68, 5, 5, 1, 72, 88, 92,
+                                92, 78, 110, 39, 181, 149, 220, 222, 218, 218,
+                                202, 234, 170, 168],
+                               [0, 128, 128, 192, 80, 112, 48, 160, 160, 224,
+                                240, 208, 144, 128, 160, 224, 240, 208, 144,
+                                144, 176, 240, 224, 192, 128]])
+
+        b = np.packbits(arr, axis=1)
+        assert_equal(b.dtype, np.uint8)
+        assert_array_equal(b, [[252, 127, 192,   0],
+                               [  7, 252,  15, 128],
+                               [240,   0,  28,   0],
+                               [255, 128,   0, 128],
+                               [192,  31, 255, 128],
+                               [142,  63,   0,   0],
+                               [255, 240,   7,   0],
+                               [  7, 224,  14,   0],
+                               [126,   0, 224,   0],
+                               [255, 255, 199,   0],
+                               [ 56,  28, 126,   0],
+                               [113, 248, 227, 128],
+                               [227, 142,  63,   0],
+                               [  0,  28, 112,   0],
+                               [ 15, 248,   3, 128],
+                               [ 28, 126,  56,   0],
+                               [ 56, 255, 241, 128],
+                               [240,   7, 224,   0],
+                               [227, 129, 192, 128],
+                               [255, 255, 254,   0],
+                               [126,   0, 224,   0],
+                               [  3, 241, 248,   0],
+                               [  0, 255, 241, 128],
+                               [128,   0, 255, 128],
+                               [224,   1, 255, 128],
+                               [248, 252, 126,   0],
+                               [  0,   7,   3, 128],
+                               [224, 113, 248,   0],
+                               [  0, 252, 127, 128],
+                               [142,  63, 224,   0],
+                               [224,  14,  63,   0],
+                               [  7,   3, 128,   0],
+                               [113, 255, 255, 128],
+                               [ 28, 113, 199,   0],
+                               [  7, 227, 142,   0],
+                               [ 14,  56, 252,   0]])
+
+        arr = arr.T.copy()
+        b = np.packbits(arr, axis=0)
+        assert_equal(b.dtype, np.uint8)
+        assert_array_equal(b, [[252, 7, 240, 255, 192, 142, 255, 7, 126, 255,
+                                56, 113, 227, 0, 15, 28, 56, 240, 227, 255,
+                                126, 3, 0, 128, 224, 248, 0, 224, 0, 142, 224,
+                                7, 113, 28, 7, 14],
+                                [127, 252, 0, 128, 31, 63, 240, 224, 0, 255,
+                                 28, 248, 142, 28, 248, 126, 255, 7, 129, 255,
+                                 0, 241, 255, 0, 1, 252, 7, 113, 252, 63, 14,
+                                 3, 255, 113, 227, 56],
+                                [192, 15, 28, 0, 255, 0, 7, 14, 224, 199, 126,
+                                 227, 63, 112, 3, 56, 241, 224, 192, 254, 224,
+                                 248, 241, 255, 255, 126, 3, 248, 127, 224, 63,
+                                 128, 255, 199, 142, 252],
+                                [0, 128, 0, 128, 128, 0, 0, 0, 0, 0, 0, 128, 0,
+                                 0, 128, 0, 128, 0, 128, 0, 0, 0, 128, 128,
+                                 128, 0, 128, 0, 128, 0, 0, 0, 128, 0, 0, 0]])
+
+        b = np.packbits(arr, axis=1)
+        assert_equal(b.dtype, np.uint8)
+        assert_array_equal(b, [[190,  72, 113, 214,   0],
+                               [186, 216, 120, 210, 128],
+                               [178, 248, 248, 210, 128],
+                               [178, 241, 216,  64, 192],
+                               [150, 227, 152,  68,  80],
+                               [215, 195,  24,   5, 112],
+                               [ 87, 202,  60,   5,  48],
+                               [ 83,  90,  52,   1, 160],
+                               [ 83,  90, 182,  72, 160],
+                               [195,  83, 150,  88, 224],
+                               [199,  83, 150,  92, 240],
+                               [206, 119, 150,  92, 208],
+                               [204, 127, 146,  78, 144],
+                               [204, 109, 210, 110, 128],
+                               [140,  73, 210,  39, 160],
+                               [140,  64, 246, 181, 224],
+                               [136, 208, 255, 149, 240],
+                               [136, 244, 255, 220, 208],
+                               [  8, 189, 223, 222, 144],
+                               [ 40,  45, 151, 218, 144],
+                               [105,  41,  21, 218, 176],
+                               [107, 104,  17, 202, 240],
+                               [ 75, 122,  17, 234, 224],
+                               [ 74,  90, 131, 170, 192],
+                               [ 88,  18, 163, 168, 128]])
+
+
+    # result is the same if input is multiplied with a nonzero value
+    for dtype in 'bBhHiIlLqQ':
+        arr = np.array(a, dtype=dtype)
+        rnd = np.random.randint(low=np.iinfo(dtype).min,
+                                high=np.iinfo(dtype).max, size=arr.size,
+                                dtype=dtype)
+        rnd[rnd == 0] = 1
+        arr *= rnd.astype(dtype)
+        b = np.packbits(arr, axis=-1)
+        assert_array_equal(np.unpackbits(b)[:-4], a)
+
+    assert_raises(TypeError, np.packbits, np.array(a, dtype=float))
+
+
+def test_packbits_very_large():
+    # test some with a larger arrays gh-8637
+    # code is covered earlier but larger array makes crash on bug more likely
+    for s in range(950, 1050):
+        for dt in '?bBhHiIlLqQ':
+            x = np.ones((200, s), dtype=bool)
+            np.packbits(x, axis=1)
+
+
+def test_unpackbits():
+    # Copied from the docstring.
+    a = np.array([[2], [7], [23]], dtype=np.uint8)
+    b = np.unpackbits(a, axis=1)
+    assert_equal(b.dtype, np.uint8)
+    assert_array_equal(b, np.array([[0, 0, 0, 0, 0, 0, 1, 0],
+                                    [0, 0, 0, 0, 0, 1, 1, 1],
+                                    [0, 0, 0, 1, 0, 1, 1, 1]]))
+
+def test_pack_unpack_order():
+    a = np.array([[2], [7], [23]], dtype=np.uint8)
+    b = np.unpackbits(a, axis=1)
+    assert_equal(b.dtype, np.uint8)
+    b_little = np.unpackbits(a, axis=1, bitorder='little')
+    b_big = np.unpackbits(a, axis=1, bitorder='big')
+    assert_array_equal(b, b_big)
+    assert_array_equal(a, np.packbits(b_little, axis=1, bitorder='little'))
+    assert_array_equal(b[:,::-1], b_little)
+    assert_array_equal(a, np.packbits(b_big, axis=1, bitorder='big'))
+    assert_raises(ValueError, np.unpackbits, a, bitorder='r')
+    assert_raises(TypeError, np.unpackbits, a, bitorder=10)
+
+
+
+def test_unpackbits_empty():
+    a = np.empty((0,), dtype=np.uint8)
+    b = np.unpackbits(a)
+    assert_equal(b.dtype, np.uint8)
+    assert_array_equal(b, np.empty((0,)))
+
+
+def test_unpackbits_empty_with_axis():
+    # Lists of packed shapes for different axes and unpacked shapes.
+    shapes = [
+        ([(0,)], (0,)),
+        ([(2, 24, 0), (16, 3, 0), (16, 24, 0)], (16, 24, 0)),
+        ([(2, 0, 24), (16, 0, 24), (16, 0, 3)], (16, 0, 24)),
+        ([(0, 16, 24), (0, 2, 24), (0, 16, 3)], (0, 16, 24)),
+        ([(3, 0, 0), (24, 0, 0), (24, 0, 0)], (24, 0, 0)),
+        ([(0, 24, 0), (0, 3, 0), (0, 24, 0)], (0, 24, 0)),
+        ([(0, 0, 24), (0, 0, 24), (0, 0, 3)], (0, 0, 24)),
+        ([(0, 0, 0), (0, 0, 0), (0, 0, 0)], (0, 0, 0)),
+    ]
+    for in_shapes, out_shape in shapes:
+        for ax, in_shape in enumerate(in_shapes):
+            a = np.empty(in_shape, dtype=np.uint8)
+            b = np.unpackbits(a, axis=ax)
+            assert_equal(b.dtype, np.uint8)
+            assert_equal(b.shape, out_shape)
+
+
+def test_unpackbits_large():
+    # test all possible numbers via comparison to already tested packbits
+    d = np.arange(277, dtype=np.uint8)
+    assert_array_equal(np.packbits(np.unpackbits(d)), d)
+    assert_array_equal(np.packbits(np.unpackbits(d[::2])), d[::2])
+    d = np.tile(d, (3, 1))
+    assert_array_equal(np.packbits(np.unpackbits(d, axis=1), axis=1), d)
+    d = d.T.copy()
+    assert_array_equal(np.packbits(np.unpackbits(d, axis=0), axis=0), d)
+
+
+class TestCount:
+    x = np.array([
+        [1, 0, 1, 0, 0, 1, 0],
+        [0, 1, 1, 1, 0, 0, 0],
+        [0, 0, 1, 0, 0, 1, 1],
+        [1, 1, 0, 0, 0, 1, 1],
+        [1, 0, 1, 0, 1, 0, 1],
+        [0, 0, 1, 1, 1, 0, 0],
+        [0, 1, 0, 1, 0, 1, 0],
+    ], dtype=np.uint8)
+    padded1 = np.zeros(57, dtype=np.uint8)
+    padded1[:49] = x.ravel()
+    padded1b = np.zeros(57, dtype=np.uint8)
+    padded1b[:49] = x[::-1].copy().ravel()
+    padded2 = np.zeros((9, 9), dtype=np.uint8)
+    padded2[:7, :7] = x
+
+    @pytest.mark.parametrize('bitorder', ('little', 'big'))
+    @pytest.mark.parametrize('count', chain(range(58), range(-1, -57, -1)))
+    def test_roundtrip(self, bitorder, count):
+        if count < 0:
+            # one extra zero of padding
+            cutoff = count - 1
+        else:
+            cutoff = count
+        # test complete invertibility of packbits and unpackbits with count
+        packed = np.packbits(self.x, bitorder=bitorder)
+        unpacked = np.unpackbits(packed, count=count, bitorder=bitorder)
+        assert_equal(unpacked.dtype, np.uint8)
+        assert_array_equal(unpacked, self.padded1[:cutoff])
+
+    @pytest.mark.parametrize('kwargs', [
+                    {}, {'count': None},
+                    ])
+    def test_count(self, kwargs):
+        packed = np.packbits(self.x)
+        unpacked = np.unpackbits(packed, **kwargs)
+        assert_equal(unpacked.dtype, np.uint8)
+        assert_array_equal(unpacked, self.padded1[:-1])
+
+    @pytest.mark.parametrize('bitorder', ('little', 'big'))
+    # delta==-1 when count<0 because one extra zero of padding
+    @pytest.mark.parametrize('count', chain(range(8), range(-1, -9, -1)))
+    def test_roundtrip_axis(self, bitorder, count):
+        if count < 0:
+            # one extra zero of padding
+            cutoff = count - 1
+        else:
+            cutoff = count
+        packed0 = np.packbits(self.x, axis=0, bitorder=bitorder)
+        unpacked0 = np.unpackbits(packed0, axis=0, count=count,
+                                  bitorder=bitorder)
+        assert_equal(unpacked0.dtype, np.uint8)
+        assert_array_equal(unpacked0, self.padded2[:cutoff, :self.x.shape[1]])
+
+        packed1 = np.packbits(self.x, axis=1, bitorder=bitorder)
+        unpacked1 = np.unpackbits(packed1, axis=1, count=count,
+                                  bitorder=bitorder)
+        assert_equal(unpacked1.dtype, np.uint8)
+        assert_array_equal(unpacked1, self.padded2[:self.x.shape[0], :cutoff])
+
+    @pytest.mark.parametrize('kwargs', [
+                    {}, {'count': None},
+                    {'bitorder' : 'little'},
+                    {'bitorder': 'little', 'count': None},
+                    {'bitorder' : 'big'},
+                    {'bitorder': 'big', 'count': None},
+                    ])
+    def test_axis_count(self, kwargs):
+        packed0 = np.packbits(self.x, axis=0)
+        unpacked0 = np.unpackbits(packed0, axis=0, **kwargs)
+        assert_equal(unpacked0.dtype, np.uint8)
+        if kwargs.get('bitorder', 'big') == 'big':
+            assert_array_equal(unpacked0, self.padded2[:-1, :self.x.shape[1]])
+        else:
+            assert_array_equal(unpacked0[::-1, :], self.padded2[:-1, :self.x.shape[1]])
+
+        packed1 = np.packbits(self.x, axis=1)
+        unpacked1 = np.unpackbits(packed1, axis=1, **kwargs)
+        assert_equal(unpacked1.dtype, np.uint8)
+        if kwargs.get('bitorder', 'big') == 'big':
+            assert_array_equal(unpacked1, self.padded2[:self.x.shape[0], :-1])
+        else:
+            assert_array_equal(unpacked1[:, ::-1], self.padded2[:self.x.shape[0], :-1])
+
+    def test_bad_count(self):
+        packed0 = np.packbits(self.x, axis=0)
+        assert_raises(ValueError, np.unpackbits, packed0, axis=0, count=-9)
+        packed1 = np.packbits(self.x, axis=1)
+        assert_raises(ValueError, np.unpackbits, packed1, axis=1, count=-9)
+        packed = np.packbits(self.x)
+        assert_raises(ValueError, np.unpackbits, packed, count=-57)
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/tests/test_polynomial.py b/venv/lib/python3.12/site-packages/numpy/lib/tests/test_polynomial.py
new file mode 100644
index 00000000..5fface63
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/lib/tests/test_polynomial.py
@@ -0,0 +1,303 @@
+import numpy as np
+from numpy.testing import (
+    assert_, assert_equal, assert_array_equal, assert_almost_equal,
+    assert_array_almost_equal, assert_raises, assert_allclose
+    )
+
+import pytest
+
+# `poly1d` has some support for `np.bool` and `np.timedelta64`,
+# but it is limited and they are therefore excluded here
+TYPE_CODES = np.typecodes["AllInteger"] + np.typecodes["AllFloat"] + "O"
+
+
+class TestPolynomial:
+    def test_poly1d_str_and_repr(self):
+        p = np.poly1d([1., 2, 3])
+        assert_equal(repr(p), 'poly1d([1., 2., 3.])')
+        assert_equal(str(p),
+                     '   2\n'
+                     '1 x + 2 x + 3')
+
+        q = np.poly1d([3., 2, 1])
+        assert_equal(repr(q), 'poly1d([3., 2., 1.])')
+        assert_equal(str(q),
+                     '   2\n'
+                     '3 x + 2 x + 1')
+
+        r = np.poly1d([1.89999 + 2j, -3j, -5.12345678, 2 + 1j])
+        assert_equal(str(r),
+                     '            3      2\n'
+                     '(1.9 + 2j) x - 3j x - 5.123 x + (2 + 1j)')
+
+        assert_equal(str(np.poly1d([-3, -2, -1])),
+                     '    2\n'
+                     '-3 x - 2 x - 1')
+
+    def test_poly1d_resolution(self):
+        p = np.poly1d([1., 2, 3])
+        q = np.poly1d([3., 2, 1])
+        assert_equal(p(0), 3.0)
+        assert_equal(p(5), 38.0)
+        assert_equal(q(0), 1.0)
+        assert_equal(q(5), 86.0)
+
+    def test_poly1d_math(self):
+        # here we use some simple coeffs to make calculations easier
+        p = np.poly1d([1., 2, 4])
+        q = np.poly1d([4., 2, 1])
+        assert_equal(p/q, (np.poly1d([0.25]), np.poly1d([1.5, 3.75])))
+        assert_equal(p.integ(), np.poly1d([1/3, 1., 4., 0.]))
+        assert_equal(p.integ(1), np.poly1d([1/3, 1., 4., 0.]))
+
+        p = np.poly1d([1., 2, 3])
+        q = np.poly1d([3., 2, 1])
+        assert_equal(p * q, np.poly1d([3., 8., 14., 8., 3.]))
+        assert_equal(p + q, np.poly1d([4., 4., 4.]))
+        assert_equal(p - q, np.poly1d([-2., 0., 2.]))
+        assert_equal(p ** 4, np.poly1d([1., 8., 36., 104., 214., 312., 324., 216., 81.]))
+        assert_equal(p(q), np.poly1d([9., 12., 16., 8., 6.]))
+        assert_equal(q(p), np.poly1d([3., 12., 32., 40., 34.]))
+        assert_equal(p.deriv(), np.poly1d([2., 2.]))
+        assert_equal(p.deriv(2), np.poly1d([2.]))
+        assert_equal(np.polydiv(np.poly1d([1, 0, -1]), np.poly1d([1, 1])),
+                     (np.poly1d([1., -1.]), np.poly1d([0.])))
+
+    @pytest.mark.parametrize("type_code", TYPE_CODES)
+    def test_poly1d_misc(self, type_code: str) -> None:
+        dtype = np.dtype(type_code)
+        ar = np.array([1, 2, 3], dtype=dtype)
+        p = np.poly1d(ar)
+
+        # `__eq__`
+        assert_equal(np.asarray(p), ar)
+        assert_equal(np.asarray(p).dtype, dtype)
+        assert_equal(len(p), 2)
+
+        # `__getitem__`
+        comparison_dct = {-1: 0, 0: 3, 1: 2, 2: 1, 3: 0}
+        for index, ref in comparison_dct.items():
+            scalar = p[index]
+            assert_equal(scalar, ref)
+            if dtype == np.object_:
+                assert isinstance(scalar, int)
+            else:
+                assert_equal(scalar.dtype, dtype)
+
+    def test_poly1d_variable_arg(self):
+        q = np.poly1d([1., 2, 3], variable='y')
+        assert_equal(str(q),
+                     '   2\n'
+                     '1 y + 2 y + 3')
+        q = np.poly1d([1., 2, 3], variable='lambda')
+        assert_equal(str(q),
+                     '        2\n'
+                     '1 lambda + 2 lambda + 3')
+
+    def test_poly(self):
+        assert_array_almost_equal(np.poly([3, -np.sqrt(2), np.sqrt(2)]),
+                                  [1, -3, -2, 6])
+
+        # From matlab docs
+        A = [[1, 2, 3], [4, 5, 6], [7, 8, 0]]
+        assert_array_almost_equal(np.poly(A), [1, -6, -72, -27])
+
+        # Should produce real output for perfect conjugates
+        assert_(np.isrealobj(np.poly([+1.082j, +2.613j, -2.613j, -1.082j])))
+        assert_(np.isrealobj(np.poly([0+1j, -0+-1j, 1+2j,
+                                      1-2j, 1.+3.5j, 1-3.5j])))
+        assert_(np.isrealobj(np.poly([1j, -1j, 1+2j, 1-2j, 1+3j, 1-3.j])))
+        assert_(np.isrealobj(np.poly([1j, -1j, 1+2j, 1-2j])))
+        assert_(np.isrealobj(np.poly([1j, -1j, 2j, -2j])))
+        assert_(np.isrealobj(np.poly([1j, -1j])))
+        assert_(np.isrealobj(np.poly([1, -1])))
+
+        assert_(np.iscomplexobj(np.poly([1j, -1.0000001j])))
+
+        np.random.seed(42)
+        a = np.random.randn(100) + 1j*np.random.randn(100)
+        assert_(np.isrealobj(np.poly(np.concatenate((a, np.conjugate(a))))))
+
+    def test_roots(self):
+        assert_array_equal(np.roots([1, 0, 0]), [0, 0])
+
+    def test_str_leading_zeros(self):
+        p = np.poly1d([4, 3, 2, 1])
+        p[3] = 0
+        assert_equal(str(p),
+                     "   2\n"
+                     "3 x + 2 x + 1")
+
+        p = np.poly1d([1, 2])
+        p[0] = 0
+        p[1] = 0
+        assert_equal(str(p), " \n0")
+
+    def test_polyfit(self):
+        c = np.array([3., 2., 1.])
+        x = np.linspace(0, 2, 7)
+        y = np.polyval(c, x)
+        err = [1, -1, 1, -1, 1, -1, 1]
+        weights = np.arange(8, 1, -1)**2/7.0
+
+        # Check exception when too few points for variance estimate. Note that
+        # the estimate requires the number of data points to exceed
+        # degree + 1
+        assert_raises(ValueError, np.polyfit,
+                      [1], [1], deg=0, cov=True)
+
+        # check 1D case
+        m, cov = np.polyfit(x, y+err, 2, cov=True)
+        est = [3.8571, 0.2857, 1.619]
+        assert_almost_equal(est, m, decimal=4)
+        val0 = [[ 1.4694, -2.9388,  0.8163],
+                [-2.9388,  6.3673, -2.1224],
+                [ 0.8163, -2.1224,  1.161 ]]
+        assert_almost_equal(val0, cov, decimal=4)
+
+        m2, cov2 = np.polyfit(x, y+err, 2, w=weights, cov=True)
+        assert_almost_equal([4.8927, -1.0177, 1.7768], m2, decimal=4)
+        val = [[ 4.3964, -5.0052,  0.4878],
+               [-5.0052,  6.8067, -0.9089],
+               [ 0.4878, -0.9089,  0.3337]]
+        assert_almost_equal(val, cov2, decimal=4)
+
+        m3, cov3 = np.polyfit(x, y+err, 2, w=weights, cov="unscaled")
+        assert_almost_equal([4.8927, -1.0177, 1.7768], m3, decimal=4)
+        val = [[ 0.1473, -0.1677,  0.0163],
+               [-0.1677,  0.228 , -0.0304],
+               [ 0.0163, -0.0304,  0.0112]]
+        assert_almost_equal(val, cov3, decimal=4)
+
+        # check 2D (n,1) case
+        y = y[:, np.newaxis]
+        c = c[:, np.newaxis]
+        assert_almost_equal(c, np.polyfit(x, y, 2))
+        # check 2D (n,2) case
+        yy = np.concatenate((y, y), axis=1)
+        cc = np.concatenate((c, c), axis=1)
+        assert_almost_equal(cc, np.polyfit(x, yy, 2))
+
+        m, cov = np.polyfit(x, yy + np.array(err)[:, np.newaxis], 2, cov=True)
+        assert_almost_equal(est, m[:, 0], decimal=4)
+        assert_almost_equal(est, m[:, 1], decimal=4)
+        assert_almost_equal(val0, cov[:, :, 0], decimal=4)
+        assert_almost_equal(val0, cov[:, :, 1], decimal=4)
+
+        # check order 1 (deg=0) case, were the analytic results are simple
+        np.random.seed(123)
+        y = np.random.normal(size=(4, 10000))
+        mean, cov = np.polyfit(np.zeros(y.shape[0]), y, deg=0, cov=True)
+        # Should get sigma_mean = sigma/sqrt(N) = 1./sqrt(4) = 0.5.
+        assert_allclose(mean.std(), 0.5, atol=0.01)
+        assert_allclose(np.sqrt(cov.mean()), 0.5, atol=0.01)
+        # Without scaling, since reduced chi2 is 1, the result should be the same.
+        mean, cov = np.polyfit(np.zeros(y.shape[0]), y, w=np.ones(y.shape[0]),
+                               deg=0, cov="unscaled")
+        assert_allclose(mean.std(), 0.5, atol=0.01)
+        assert_almost_equal(np.sqrt(cov.mean()), 0.5)
+        # If we estimate our errors wrong, no change with scaling:
+        w = np.full(y.shape[0], 1./0.5)
+        mean, cov = np.polyfit(np.zeros(y.shape[0]), y, w=w, deg=0, cov=True)
+        assert_allclose(mean.std(), 0.5, atol=0.01)
+        assert_allclose(np.sqrt(cov.mean()), 0.5, atol=0.01)
+        # But if we do not scale, our estimate for the error in the mean will
+        # differ.
+        mean, cov = np.polyfit(np.zeros(y.shape[0]), y, w=w, deg=0, cov="unscaled")
+        assert_allclose(mean.std(), 0.5, atol=0.01)
+        assert_almost_equal(np.sqrt(cov.mean()), 0.25)
+
+    def test_objects(self):
+        from decimal import Decimal
+        p = np.poly1d([Decimal('4.0'), Decimal('3.0'), Decimal('2.0')])
+        p2 = p * Decimal('1.333333333333333')
+        assert_(p2[1] == Decimal("3.9999999999999990"))
+        p2 = p.deriv()
+        assert_(p2[1] == Decimal('8.0'))
+        p2 = p.integ()
+        assert_(p2[3] == Decimal("1.333333333333333333333333333"))
+        assert_(p2[2] == Decimal('1.5'))
+        assert_(np.issubdtype(p2.coeffs.dtype, np.object_))
+        p = np.poly([Decimal(1), Decimal(2)])
+        assert_equal(np.poly([Decimal(1), Decimal(2)]),
+                     [1, Decimal(-3), Decimal(2)])
+
+    def test_complex(self):
+        p = np.poly1d([3j, 2j, 1j])
+        p2 = p.integ()
+        assert_((p2.coeffs == [1j, 1j, 1j, 0]).all())
+        p2 = p.deriv()
+        assert_((p2.coeffs == [6j, 2j]).all())
+
+    def test_integ_coeffs(self):
+        p = np.poly1d([3, 2, 1])
+        p2 = p.integ(3, k=[9, 7, 6])
+        assert_(
+            (p2.coeffs == [1/4./5., 1/3./4., 1/2./3., 9/1./2., 7, 6]).all())
+
+    def test_zero_dims(self):
+        try:
+            np.poly(np.zeros((0, 0)))
+        except ValueError:
+            pass
+
+    def test_poly_int_overflow(self):
+        """
+        Regression test for gh-5096.
+        """
+        v = np.arange(1, 21)
+        assert_almost_equal(np.poly(v), np.poly(np.diag(v)))
+
+    def test_zero_poly_dtype(self):
+        """
+        Regression test for gh-16354.
+        """
+        z = np.array([0, 0, 0])
+        p = np.poly1d(z.astype(np.int64))
+        assert_equal(p.coeffs.dtype, np.int64)
+
+        p = np.poly1d(z.astype(np.float32))
+        assert_equal(p.coeffs.dtype, np.float32)
+
+        p = np.poly1d(z.astype(np.complex64))
+        assert_equal(p.coeffs.dtype, np.complex64)
+
+    def test_poly_eq(self):
+        p = np.poly1d([1, 2, 3])
+        p2 = np.poly1d([1, 2, 4])
+        assert_equal(p == None, False)
+        assert_equal(p != None, True)
+        assert_equal(p == p, True)
+        assert_equal(p == p2, False)
+        assert_equal(p != p2, True)
+
+    def test_polydiv(self):
+        b = np.poly1d([2, 6, 6, 1])
+        a = np.poly1d([-1j, (1+2j), -(2+1j), 1])
+        q, r = np.polydiv(b, a)
+        assert_equal(q.coeffs.dtype, np.complex128)
+        assert_equal(r.coeffs.dtype, np.complex128)
+        assert_equal(q*a + r, b)
+
+        c = [1, 2, 3]
+        d = np.poly1d([1, 2, 3])
+        s, t = np.polydiv(c, d)
+        assert isinstance(s, np.poly1d)
+        assert isinstance(t, np.poly1d)
+        u, v = np.polydiv(d, c)
+        assert isinstance(u, np.poly1d)
+        assert isinstance(v, np.poly1d)
+
+    def test_poly_coeffs_mutable(self):
+        """ Coefficients should be modifiable """
+        p = np.poly1d([1, 2, 3])
+
+        p.coeffs += 1
+        assert_equal(p.coeffs, [2, 3, 4])
+
+        p.coeffs[2] += 10
+        assert_equal(p.coeffs, [2, 3, 14])
+
+        # this never used to be allowed - let's not add features to deprecated
+        # APIs
+        assert_raises(AttributeError, setattr, p, 'coeffs', np.array(1))
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/tests/test_recfunctions.py b/venv/lib/python3.12/site-packages/numpy/lib/tests/test_recfunctions.py
new file mode 100644
index 00000000..98860dfd
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/lib/tests/test_recfunctions.py
@@ -0,0 +1,1043 @@
+import pytest
+
+import numpy as np
+import numpy.ma as ma
+from numpy.ma.mrecords import MaskedRecords
+from numpy.ma.testutils import assert_equal
+from numpy.testing import assert_, assert_raises
+from numpy.lib.recfunctions import (
+    drop_fields, rename_fields, get_fieldstructure, recursive_fill_fields,
+    find_duplicates, merge_arrays, append_fields, stack_arrays, join_by,
+    repack_fields, unstructured_to_structured, structured_to_unstructured,
+    apply_along_fields, require_fields, assign_fields_by_name)
+get_fieldspec = np.lib.recfunctions._get_fieldspec
+get_names = np.lib.recfunctions.get_names
+get_names_flat = np.lib.recfunctions.get_names_flat
+zip_descr = np.lib.recfunctions._zip_descr
+zip_dtype = np.lib.recfunctions._zip_dtype
+
+
+class TestRecFunctions:
+    # Misc tests
+
+    def setup_method(self):
+        x = np.array([1, 2, ])
+        y = np.array([10, 20, 30])
+        z = np.array([('A', 1.), ('B', 2.)],
+                     dtype=[('A', '|S3'), ('B', float)])
+        w = np.array([(1, (2, 3.0)), (4, (5, 6.0))],
+                     dtype=[('a', int), ('b', [('ba', float), ('bb', int)])])
+        self.data = (w, x, y, z)
+
+    def test_zip_descr(self):
+        # Test zip_descr
+        (w, x, y, z) = self.data
+
+        # Std array
+        test = zip_descr((x, x), flatten=True)
+        assert_equal(test,
+                     np.dtype([('', int), ('', int)]))
+        test = zip_descr((x, x), flatten=False)
+        assert_equal(test,
+                     np.dtype([('', int), ('', int)]))
+
+        # Std & flexible-dtype
+        test = zip_descr((x, z), flatten=True)
+        assert_equal(test,
+                     np.dtype([('', int), ('A', '|S3'), ('B', float)]))
+        test = zip_descr((x, z), flatten=False)
+        assert_equal(test,
+                     np.dtype([('', int),
+                               ('', [('A', '|S3'), ('B', float)])]))
+
+        # Standard & nested dtype
+        test = zip_descr((x, w), flatten=True)
+        assert_equal(test,
+                     np.dtype([('', int),
+                               ('a', int),
+                               ('ba', float), ('bb', int)]))
+        test = zip_descr((x, w), flatten=False)
+        assert_equal(test,
+                     np.dtype([('', int),
+                               ('', [('a', int),
+                                     ('b', [('ba', float), ('bb', int)])])]))
+
+    def test_drop_fields(self):
+        # Test drop_fields
+        a = np.array([(1, (2, 3.0)), (4, (5, 6.0))],
+                     dtype=[('a', int), ('b', [('ba', float), ('bb', int)])])
+
+        # A basic field
+        test = drop_fields(a, 'a')
+        control = np.array([((2, 3.0),), ((5, 6.0),)],
+                           dtype=[('b', [('ba', float), ('bb', int)])])
+        assert_equal(test, control)
+
+        # Another basic field (but nesting two fields)
+        test = drop_fields(a, 'b')
+        control = np.array([(1,), (4,)], dtype=[('a', int)])
+        assert_equal(test, control)
+
+        # A nested sub-field
+        test = drop_fields(a, ['ba', ])
+        control = np.array([(1, (3.0,)), (4, (6.0,))],
+                           dtype=[('a', int), ('b', [('bb', int)])])
+        assert_equal(test, control)
+
+        # All the nested sub-field from a field: zap that field
+        test = drop_fields(a, ['ba', 'bb'])
+        control = np.array([(1,), (4,)], dtype=[('a', int)])
+        assert_equal(test, control)
+
+        # dropping all fields results in an array with no fields
+        test = drop_fields(a, ['a', 'b'])
+        control = np.array([(), ()], dtype=[])
+        assert_equal(test, control)
+
+    def test_rename_fields(self):
+        # Test rename fields
+        a = np.array([(1, (2, [3.0, 30.])), (4, (5, [6.0, 60.]))],
+                     dtype=[('a', int),
+                            ('b', [('ba', float), ('bb', (float, 2))])])
+        test = rename_fields(a, {'a': 'A', 'bb': 'BB'})
+        newdtype = [('A', int), ('b', [('ba', float), ('BB', (float, 2))])]
+        control = a.view(newdtype)
+        assert_equal(test.dtype, newdtype)
+        assert_equal(test, control)
+
+    def test_get_names(self):
+        # Test get_names
+        ndtype = np.dtype([('A', '|S3'), ('B', float)])
+        test = get_names(ndtype)
+        assert_equal(test, ('A', 'B'))
+
+        ndtype = np.dtype([('a', int), ('b', [('ba', float), ('bb', int)])])
+        test = get_names(ndtype)
+        assert_equal(test, ('a', ('b', ('ba', 'bb'))))
+
+        ndtype = np.dtype([('a', int), ('b', [])])
+        test = get_names(ndtype)
+        assert_equal(test, ('a', ('b', ())))
+
+        ndtype = np.dtype([])
+        test = get_names(ndtype)
+        assert_equal(test, ())
+
+    def test_get_names_flat(self):
+        # Test get_names_flat
+        ndtype = np.dtype([('A', '|S3'), ('B', float)])
+        test = get_names_flat(ndtype)
+        assert_equal(test, ('A', 'B'))
+
+        ndtype = np.dtype([('a', int), ('b', [('ba', float), ('bb', int)])])
+        test = get_names_flat(ndtype)
+        assert_equal(test, ('a', 'b', 'ba', 'bb'))
+
+        ndtype = np.dtype([('a', int), ('b', [])])
+        test = get_names_flat(ndtype)
+        assert_equal(test, ('a', 'b'))
+
+        ndtype = np.dtype([])
+        test = get_names_flat(ndtype)
+        assert_equal(test, ())
+
+    def test_get_fieldstructure(self):
+        # Test get_fieldstructure
+
+        # No nested fields
+        ndtype = np.dtype([('A', '|S3'), ('B', float)])
+        test = get_fieldstructure(ndtype)
+        assert_equal(test, {'A': [], 'B': []})
+
+        # One 1-nested field
+        ndtype = np.dtype([('A', int), ('B', [('BA', float), ('BB', '|S1')])])
+        test = get_fieldstructure(ndtype)
+        assert_equal(test, {'A': [], 'B': [], 'BA': ['B', ], 'BB': ['B']})
+
+        # One 2-nested fields
+        ndtype = np.dtype([('A', int),
+                           ('B', [('BA', int),
+                                  ('BB', [('BBA', int), ('BBB', int)])])])
+        test = get_fieldstructure(ndtype)
+        control = {'A': [], 'B': [], 'BA': ['B'], 'BB': ['B'],
+                   'BBA': ['B', 'BB'], 'BBB': ['B', 'BB']}
+        assert_equal(test, control)
+
+        # 0 fields
+        ndtype = np.dtype([])
+        test = get_fieldstructure(ndtype)
+        assert_equal(test, {})
+
+    def test_find_duplicates(self):
+        # Test find_duplicates
+        a = ma.array([(2, (2., 'B')), (1, (2., 'B')), (2, (2., 'B')),
+                      (1, (1., 'B')), (2, (2., 'B')), (2, (2., 'C'))],
+                     mask=[(0, (0, 0)), (0, (0, 0)), (0, (0, 0)),
+                           (0, (0, 0)), (1, (0, 0)), (0, (1, 0))],
+                     dtype=[('A', int), ('B', [('BA', float), ('BB', '|S1')])])
+
+        test = find_duplicates(a, ignoremask=False, return_index=True)
+        control = [0, 2]
+        assert_equal(sorted(test[-1]), control)
+        assert_equal(test[0], a[test[-1]])
+
+        test = find_duplicates(a, key='A', return_index=True)
+        control = [0, 1, 2, 3, 5]
+        assert_equal(sorted(test[-1]), control)
+        assert_equal(test[0], a[test[-1]])
+
+        test = find_duplicates(a, key='B', return_index=True)
+        control = [0, 1, 2, 4]
+        assert_equal(sorted(test[-1]), control)
+        assert_equal(test[0], a[test[-1]])
+
+        test = find_duplicates(a, key='BA', return_index=True)
+        control = [0, 1, 2, 4]
+        assert_equal(sorted(test[-1]), control)
+        assert_equal(test[0], a[test[-1]])
+
+        test = find_duplicates(a, key='BB', return_index=True)
+        control = [0, 1, 2, 3, 4]
+        assert_equal(sorted(test[-1]), control)
+        assert_equal(test[0], a[test[-1]])
+
+    def test_find_duplicates_ignoremask(self):
+        # Test the ignoremask option of find_duplicates
+        ndtype = [('a', int)]
+        a = ma.array([1, 1, 1, 2, 2, 3, 3],
+                     mask=[0, 0, 1, 0, 0, 0, 1]).view(ndtype)
+        test = find_duplicates(a, ignoremask=True, return_index=True)
+        control = [0, 1, 3, 4]
+        assert_equal(sorted(test[-1]), control)
+        assert_equal(test[0], a[test[-1]])
+
+        test = find_duplicates(a, ignoremask=False, return_index=True)
+        control = [0, 1, 2, 3, 4, 6]
+        assert_equal(sorted(test[-1]), control)
+        assert_equal(test[0], a[test[-1]])
+
+    def test_repack_fields(self):
+        dt = np.dtype('u1,f4,i8', align=True)
+        a = np.zeros(2, dtype=dt)
+
+        assert_equal(repack_fields(dt), np.dtype('u1,f4,i8'))
+        assert_equal(repack_fields(a).itemsize, 13)
+        assert_equal(repack_fields(repack_fields(dt), align=True), dt)
+
+        # make sure type is preserved
+        dt = np.dtype((np.record, dt))
+        assert_(repack_fields(dt).type is np.record)
+
+    def test_structured_to_unstructured(self, tmp_path):
+        a = np.zeros(4, dtype=[('a', 'i4'), ('b', 'f4,u2'), ('c', 'f4', 2)])
+        out = structured_to_unstructured(a)
+        assert_equal(out, np.zeros((4,5), dtype='f8'))
+
+        b = np.array([(1, 2, 5), (4, 5, 7), (7, 8 ,11), (10, 11, 12)],
+                     dtype=[('x', 'i4'), ('y', 'f4'), ('z', 'f8')])
+        out = np.mean(structured_to_unstructured(b[['x', 'z']]), axis=-1)
+        assert_equal(out, np.array([ 3. ,  5.5,  9. , 11. ]))
+        out = np.mean(structured_to_unstructured(b[['x']]), axis=-1)
+        assert_equal(out, np.array([ 1. ,  4. ,  7. , 10. ]))
+
+        c = np.arange(20).reshape((4,5))
+        out = unstructured_to_structured(c, a.dtype)
+        want = np.array([( 0, ( 1.,  2), [ 3.,  4.]),
+                         ( 5, ( 6.,  7), [ 8.,  9.]),
+                         (10, (11., 12), [13., 14.]),
+                         (15, (16., 17), [18., 19.])],
+                     dtype=[('a', 'i4'),
+                            ('b', [('f0', 'f4'), ('f1', 'u2')]),
+                            ('c', 'f4', (2,))])
+        assert_equal(out, want)
+
+        d = np.array([(1, 2, 5), (4, 5, 7), (7, 8 ,11), (10, 11, 12)],
+                     dtype=[('x', 'i4'), ('y', 'f4'), ('z', 'f8')])
+        assert_equal(apply_along_fields(np.mean, d),
+                     np.array([ 8.0/3,  16.0/3,  26.0/3, 11. ]))
+        assert_equal(apply_along_fields(np.mean, d[['x', 'z']]),
+                     np.array([ 3. ,  5.5,  9. , 11. ]))
+
+        # check that for uniform field dtypes we get a view, not a copy:
+        d = np.array([(1, 2, 5), (4, 5, 7), (7, 8 ,11), (10, 11, 12)],
+                     dtype=[('x', 'i4'), ('y', 'i4'), ('z', 'i4')])
+        dd = structured_to_unstructured(d)
+        ddd = unstructured_to_structured(dd, d.dtype)
+        assert_(np.shares_memory(dd, d))
+        assert_(np.shares_memory(ddd, d))
+
+        # check that reversing the order of attributes works
+        dd_attrib_rev = structured_to_unstructured(d[['z', 'x']])
+        assert_equal(dd_attrib_rev, [[5, 1], [7, 4], [11, 7], [12, 10]])
+        assert_(np.shares_memory(dd_attrib_rev, d))
+
+        # including uniform fields with subarrays unpacked
+        d = np.array([(1, [2,  3], [[ 4,  5], [ 6,  7]]),
+                      (8, [9, 10], [[11, 12], [13, 14]])],
+                     dtype=[('x0', 'i4'), ('x1', ('i4', 2)),
+                            ('x2', ('i4', (2, 2)))])
+        dd = structured_to_unstructured(d)
+        ddd = unstructured_to_structured(dd, d.dtype)
+        assert_(np.shares_memory(dd, d))
+        assert_(np.shares_memory(ddd, d))
+
+        # check that reversing with sub-arrays works as expected
+        d_rev = d[::-1]
+        dd_rev = structured_to_unstructured(d_rev)
+        assert_equal(dd_rev, [[8, 9, 10, 11, 12, 13, 14],
+                              [1, 2, 3, 4, 5, 6, 7]])
+
+        # check that sub-arrays keep the order of their values
+        d_attrib_rev = d[['x2', 'x1', 'x0']]
+        dd_attrib_rev = structured_to_unstructured(d_attrib_rev)
+        assert_equal(dd_attrib_rev, [[4, 5, 6, 7, 2, 3, 1],
+                                     [11, 12, 13, 14, 9, 10, 8]])
+
+        # with ignored field at the end
+        d = np.array([(1, [2,  3], [[4, 5], [6, 7]], 32),
+                      (8, [9, 10], [[11, 12], [13, 14]], 64)],
+                     dtype=[('x0', 'i4'), ('x1', ('i4', 2)),
+                            ('x2', ('i4', (2, 2))), ('ignored', 'u1')])
+        dd = structured_to_unstructured(d[['x0', 'x1', 'x2']])
+        assert_(np.shares_memory(dd, d))
+        assert_equal(dd, [[1, 2, 3, 4, 5, 6, 7],
+                          [8, 9, 10, 11, 12, 13, 14]])
+
+        # test that nested fields with identical names don't break anything
+        point = np.dtype([('x', int), ('y', int)])
+        triangle = np.dtype([('a', point), ('b', point), ('c', point)])
+        arr = np.zeros(10, triangle)
+        res = structured_to_unstructured(arr, dtype=int)
+        assert_equal(res, np.zeros((10, 6), dtype=int))
+
+
+        # test nested combinations of subarrays and structured arrays, gh-13333
+        def subarray(dt, shape):
+            return np.dtype((dt, shape))
+
+        def structured(*dts):
+            return np.dtype([('x{}'.format(i), dt) for i, dt in enumerate(dts)])
+
+        def inspect(dt, dtype=None):
+            arr = np.zeros((), dt)
+            ret = structured_to_unstructured(arr, dtype=dtype)
+            backarr = unstructured_to_structured(ret, dt)
+            return ret.shape, ret.dtype, backarr.dtype
+
+        dt = structured(subarray(structured(np.int32, np.int32), 3))
+        assert_equal(inspect(dt), ((6,), np.int32, dt))
+
+        dt = structured(subarray(subarray(np.int32, 2), 2))
+        assert_equal(inspect(dt), ((4,), np.int32, dt))
+
+        dt = structured(np.int32)
+        assert_equal(inspect(dt), ((1,), np.int32, dt))
+
+        dt = structured(np.int32, subarray(subarray(np.int32, 2), 2))
+        assert_equal(inspect(dt), ((5,), np.int32, dt))
+
+        dt = structured()
+        assert_raises(ValueError, structured_to_unstructured, np.zeros(3, dt))
+
+        # these currently don't work, but we may make it work in the future
+        assert_raises(NotImplementedError, structured_to_unstructured,
+                                           np.zeros(3, dt), dtype=np.int32)
+        assert_raises(NotImplementedError, unstructured_to_structured,
+                                           np.zeros((3,0), dtype=np.int32))
+
+        # test supported ndarray subclasses
+        d_plain = np.array([(1, 2), (3, 4)], dtype=[('a', 'i4'), ('b', 'i4')])
+        dd_expected = structured_to_unstructured(d_plain, copy=True)
+
+        # recarray
+        d = d_plain.view(np.recarray)
+
+        dd = structured_to_unstructured(d, copy=False)
+        ddd = structured_to_unstructured(d, copy=True)
+        assert_(np.shares_memory(d, dd))
+        assert_(type(dd) is np.recarray)
+        assert_(type(ddd) is np.recarray)
+        assert_equal(dd, dd_expected)
+        assert_equal(ddd, dd_expected)
+
+        # memmap
+        d = np.memmap(tmp_path / 'memmap',
+                      mode='w+',
+                      dtype=d_plain.dtype,
+                      shape=d_plain.shape)
+        d[:] = d_plain
+        dd = structured_to_unstructured(d, copy=False)
+        ddd = structured_to_unstructured(d, copy=True)
+        assert_(np.shares_memory(d, dd))
+        assert_(type(dd) is np.memmap)
+        assert_(type(ddd) is np.memmap)
+        assert_equal(dd, dd_expected)
+        assert_equal(ddd, dd_expected)
+
+    def test_unstructured_to_structured(self):
+        # test if dtype is the args of np.dtype
+        a = np.zeros((20, 2))
+        test_dtype_args = [('x', float), ('y', float)]
+        test_dtype = np.dtype(test_dtype_args)
+        field1 = unstructured_to_structured(a, dtype=test_dtype_args)  # now
+        field2 = unstructured_to_structured(a, dtype=test_dtype)  # before
+        assert_equal(field1, field2)
+
+    def test_field_assignment_by_name(self):
+        a = np.ones(2, dtype=[('a', 'i4'), ('b', 'f8'), ('c', 'u1')])
+        newdt = [('b', 'f4'), ('c', 'u1')]
+
+        assert_equal(require_fields(a, newdt), np.ones(2, newdt))
+
+        b = np.array([(1,2), (3,4)], dtype=newdt)
+        assign_fields_by_name(a, b, zero_unassigned=False)
+        assert_equal(a, np.array([(1,1,2),(1,3,4)], dtype=a.dtype))
+        assign_fields_by_name(a, b)
+        assert_equal(a, np.array([(0,1,2),(0,3,4)], dtype=a.dtype))
+
+        # test nested fields
+        a = np.ones(2, dtype=[('a', [('b', 'f8'), ('c', 'u1')])])
+        newdt = [('a', [('c', 'u1')])]
+        assert_equal(require_fields(a, newdt), np.ones(2, newdt))
+        b = np.array([((2,),), ((3,),)], dtype=newdt)
+        assign_fields_by_name(a, b, zero_unassigned=False)
+        assert_equal(a, np.array([((1,2),), ((1,3),)], dtype=a.dtype))
+        assign_fields_by_name(a, b)
+        assert_equal(a, np.array([((0,2),), ((0,3),)], dtype=a.dtype))
+
+        # test unstructured code path for 0d arrays
+        a, b = np.array(3), np.array(0)
+        assign_fields_by_name(b, a)
+        assert_equal(b[()], 3)
+
+
+class TestRecursiveFillFields:
+    # Test recursive_fill_fields.
+    def test_simple_flexible(self):
+        # Test recursive_fill_fields on flexible-array
+        a = np.array([(1, 10.), (2, 20.)], dtype=[('A', int), ('B', float)])
+        b = np.zeros((3,), dtype=a.dtype)
+        test = recursive_fill_fields(a, b)
+        control = np.array([(1, 10.), (2, 20.), (0, 0.)],
+                           dtype=[('A', int), ('B', float)])
+        assert_equal(test, control)
+
+    def test_masked_flexible(self):
+        # Test recursive_fill_fields on masked flexible-array
+        a = ma.array([(1, 10.), (2, 20.)], mask=[(0, 1), (1, 0)],
+                     dtype=[('A', int), ('B', float)])
+        b = ma.zeros((3,), dtype=a.dtype)
+        test = recursive_fill_fields(a, b)
+        control = ma.array([(1, 10.), (2, 20.), (0, 0.)],
+                           mask=[(0, 1), (1, 0), (0, 0)],
+                           dtype=[('A', int), ('B', float)])
+        assert_equal(test, control)
+
+
+class TestMergeArrays:
+    # Test merge_arrays
+
+    def setup_method(self):
+        x = np.array([1, 2, ])
+        y = np.array([10, 20, 30])
+        z = np.array(
+            [('A', 1.), ('B', 2.)], dtype=[('A', '|S3'), ('B', float)])
+        w = np.array(
+            [(1, (2, 3.0, ())), (4, (5, 6.0, ()))],
+            dtype=[('a', int), ('b', [('ba', float), ('bb', int), ('bc', [])])])
+        self.data = (w, x, y, z)
+
+    def test_solo(self):
+        # Test merge_arrays on a single array.
+        (_, x, _, z) = self.data
+
+        test = merge_arrays(x)
+        control = np.array([(1,), (2,)], dtype=[('f0', int)])
+        assert_equal(test, control)
+        test = merge_arrays((x,))
+        assert_equal(test, control)
+
+        test = merge_arrays(z, flatten=False)
+        assert_equal(test, z)
+        test = merge_arrays(z, flatten=True)
+        assert_equal(test, z)
+
+    def test_solo_w_flatten(self):
+        # Test merge_arrays on a single array w & w/o flattening
+        w = self.data[0]
+        test = merge_arrays(w, flatten=False)
+        assert_equal(test, w)
+
+        test = merge_arrays(w, flatten=True)
+        control = np.array([(1, 2, 3.0), (4, 5, 6.0)],
+                           dtype=[('a', int), ('ba', float), ('bb', int)])
+        assert_equal(test, control)
+
+    def test_standard(self):
+        # Test standard & standard
+        # Test merge arrays
+        (_, x, y, _) = self.data
+        test = merge_arrays((x, y), usemask=False)
+        control = np.array([(1, 10), (2, 20), (-1, 30)],
+                           dtype=[('f0', int), ('f1', int)])
+        assert_equal(test, control)
+
+        test = merge_arrays((x, y), usemask=True)
+        control = ma.array([(1, 10), (2, 20), (-1, 30)],
+                           mask=[(0, 0), (0, 0), (1, 0)],
+                           dtype=[('f0', int), ('f1', int)])
+        assert_equal(test, control)
+        assert_equal(test.mask, control.mask)
+
+    def test_flatten(self):
+        # Test standard & flexible
+        (_, x, _, z) = self.data
+        test = merge_arrays((x, z), flatten=True)
+        control = np.array([(1, 'A', 1.), (2, 'B', 2.)],
+                           dtype=[('f0', int), ('A', '|S3'), ('B', float)])
+        assert_equal(test, control)
+
+        test = merge_arrays((x, z), flatten=False)
+        control = np.array([(1, ('A', 1.)), (2, ('B', 2.))],
+                           dtype=[('f0', int),
+                                  ('f1', [('A', '|S3'), ('B', float)])])
+        assert_equal(test, control)
+
+    def test_flatten_wflexible(self):
+        # Test flatten standard & nested
+        (w, x, _, _) = self.data
+        test = merge_arrays((x, w), flatten=True)
+        control = np.array([(1, 1, 2, 3.0), (2, 4, 5, 6.0)],
+                           dtype=[('f0', int),
+                                  ('a', int), ('ba', float), ('bb', int)])
+        assert_equal(test, control)
+
+        test = merge_arrays((x, w), flatten=False)
+        controldtype = [('f0', int),
+                                ('f1', [('a', int),
+                                        ('b', [('ba', float), ('bb', int), ('bc', [])])])]
+        control = np.array([(1., (1, (2, 3.0, ()))), (2, (4, (5, 6.0, ())))],
+                           dtype=controldtype)
+        assert_equal(test, control)
+
+    def test_wmasked_arrays(self):
+        # Test merge_arrays masked arrays
+        (_, x, _, _) = self.data
+        mx = ma.array([1, 2, 3], mask=[1, 0, 0])
+        test = merge_arrays((x, mx), usemask=True)
+        control = ma.array([(1, 1), (2, 2), (-1, 3)],
+                           mask=[(0, 1), (0, 0), (1, 0)],
+                           dtype=[('f0', int), ('f1', int)])
+        assert_equal(test, control)
+        test = merge_arrays((x, mx), usemask=True, asrecarray=True)
+        assert_equal(test, control)
+        assert_(isinstance(test, MaskedRecords))
+
+    def test_w_singlefield(self):
+        # Test single field
+        test = merge_arrays((np.array([1, 2]).view([('a', int)]),
+                             np.array([10., 20., 30.])),)
+        control = ma.array([(1, 10.), (2, 20.), (-1, 30.)],
+                           mask=[(0, 0), (0, 0), (1, 0)],
+                           dtype=[('a', int), ('f1', float)])
+        assert_equal(test, control)
+
+    def test_w_shorter_flex(self):
+        # Test merge_arrays w/ a shorter flexndarray.
+        z = self.data[-1]
+
+        # Fixme, this test looks incomplete and broken
+        #test = merge_arrays((z, np.array([10, 20, 30]).view([('C', int)])))
+        #control = np.array([('A', 1., 10), ('B', 2., 20), ('-1', -1, 20)],
+        #                   dtype=[('A', '|S3'), ('B', float), ('C', int)])
+        #assert_equal(test, control)
+
+        # Hack to avoid pyflakes warnings about unused variables
+        merge_arrays((z, np.array([10, 20, 30]).view([('C', int)])))
+        np.array([('A', 1., 10), ('B', 2., 20), ('-1', -1, 20)],
+                 dtype=[('A', '|S3'), ('B', float), ('C', int)])
+
+    def test_singlerecord(self):
+        (_, x, y, z) = self.data
+        test = merge_arrays((x[0], y[0], z[0]), usemask=False)
+        control = np.array([(1, 10, ('A', 1))],
+                           dtype=[('f0', int),
+                                  ('f1', int),
+                                  ('f2', [('A', '|S3'), ('B', float)])])
+        assert_equal(test, control)
+
+
+class TestAppendFields:
+    # Test append_fields
+
+    def setup_method(self):
+        x = np.array([1, 2, ])
+        y = np.array([10, 20, 30])
+        z = np.array(
+            [('A', 1.), ('B', 2.)], dtype=[('A', '|S3'), ('B', float)])
+        w = np.array([(1, (2, 3.0)), (4, (5, 6.0))],
+                     dtype=[('a', int), ('b', [('ba', float), ('bb', int)])])
+        self.data = (w, x, y, z)
+
+    def test_append_single(self):
+        # Test simple case
+        (_, x, _, _) = self.data
+        test = append_fields(x, 'A', data=[10, 20, 30])
+        control = ma.array([(1, 10), (2, 20), (-1, 30)],
+                           mask=[(0, 0), (0, 0), (1, 0)],
+                           dtype=[('f0', int), ('A', int)],)
+        assert_equal(test, control)
+
+    def test_append_double(self):
+        # Test simple case
+        (_, x, _, _) = self.data
+        test = append_fields(x, ('A', 'B'), data=[[10, 20, 30], [100, 200]])
+        control = ma.array([(1, 10, 100), (2, 20, 200), (-1, 30, -1)],
+                           mask=[(0, 0, 0), (0, 0, 0), (1, 0, 1)],
+                           dtype=[('f0', int), ('A', int), ('B', int)],)
+        assert_equal(test, control)
+
+    def test_append_on_flex(self):
+        # Test append_fields on flexible type arrays
+        z = self.data[-1]
+        test = append_fields(z, 'C', data=[10, 20, 30])
+        control = ma.array([('A', 1., 10), ('B', 2., 20), (-1, -1., 30)],
+                           mask=[(0, 0, 0), (0, 0, 0), (1, 1, 0)],
+                           dtype=[('A', '|S3'), ('B', float), ('C', int)],)
+        assert_equal(test, control)
+
+    def test_append_on_nested(self):
+        # Test append_fields on nested fields
+        w = self.data[0]
+        test = append_fields(w, 'C', data=[10, 20, 30])
+        control = ma.array([(1, (2, 3.0), 10),
+                            (4, (5, 6.0), 20),
+                            (-1, (-1, -1.), 30)],
+                           mask=[(
+                               0, (0, 0), 0), (0, (0, 0), 0), (1, (1, 1), 0)],
+                           dtype=[('a', int),
+                                  ('b', [('ba', float), ('bb', int)]),
+                                  ('C', int)],)
+        assert_equal(test, control)
+
+
+class TestStackArrays:
+    # Test stack_arrays
+    def setup_method(self):
+        x = np.array([1, 2, ])
+        y = np.array([10, 20, 30])
+        z = np.array(
+            [('A', 1.), ('B', 2.)], dtype=[('A', '|S3'), ('B', float)])
+        w = np.array([(1, (2, 3.0)), (4, (5, 6.0))],
+                     dtype=[('a', int), ('b', [('ba', float), ('bb', int)])])
+        self.data = (w, x, y, z)
+
+    def test_solo(self):
+        # Test stack_arrays on single arrays
+        (_, x, _, _) = self.data
+        test = stack_arrays((x,))
+        assert_equal(test, x)
+        assert_(test is x)
+
+        test = stack_arrays(x)
+        assert_equal(test, x)
+        assert_(test is x)
+
+    def test_unnamed_fields(self):
+        # Tests combinations of arrays w/o named fields
+        (_, x, y, _) = self.data
+
+        test = stack_arrays((x, x), usemask=False)
+        control = np.array([1, 2, 1, 2])
+        assert_equal(test, control)
+
+        test = stack_arrays((x, y), usemask=False)
+        control = np.array([1, 2, 10, 20, 30])
+        assert_equal(test, control)
+
+        test = stack_arrays((y, x), usemask=False)
+        control = np.array([10, 20, 30, 1, 2])
+        assert_equal(test, control)
+
+    def test_unnamed_and_named_fields(self):
+        # Test combination of arrays w/ & w/o named fields
+        (_, x, _, z) = self.data
+
+        test = stack_arrays((x, z))
+        control = ma.array([(1, -1, -1), (2, -1, -1),
+                            (-1, 'A', 1), (-1, 'B', 2)],
+                           mask=[(0, 1, 1), (0, 1, 1),
+                                 (1, 0, 0), (1, 0, 0)],
+                           dtype=[('f0', int), ('A', '|S3'), ('B', float)])
+        assert_equal(test, control)
+        assert_equal(test.mask, control.mask)
+
+        test = stack_arrays((z, x))
+        control = ma.array([('A', 1, -1), ('B', 2, -1),
+                            (-1, -1, 1), (-1, -1, 2), ],
+                           mask=[(0, 0, 1), (0, 0, 1),
+                                 (1, 1, 0), (1, 1, 0)],
+                           dtype=[('A', '|S3'), ('B', float), ('f2', int)])
+        assert_equal(test, control)
+        assert_equal(test.mask, control.mask)
+
+        test = stack_arrays((z, z, x))
+        control = ma.array([('A', 1, -1), ('B', 2, -1),
+                            ('A', 1, -1), ('B', 2, -1),
+                            (-1, -1, 1), (-1, -1, 2), ],
+                           mask=[(0, 0, 1), (0, 0, 1),
+                                 (0, 0, 1), (0, 0, 1),
+                                 (1, 1, 0), (1, 1, 0)],
+                           dtype=[('A', '|S3'), ('B', float), ('f2', int)])
+        assert_equal(test, control)
+
+    def test_matching_named_fields(self):
+        # Test combination of arrays w/ matching field names
+        (_, x, _, z) = self.data
+        zz = np.array([('a', 10., 100.), ('b', 20., 200.), ('c', 30., 300.)],
+                      dtype=[('A', '|S3'), ('B', float), ('C', float)])
+        test = stack_arrays((z, zz))
+        control = ma.array([('A', 1, -1), ('B', 2, -1),
+                            (
+                                'a', 10., 100.), ('b', 20., 200.), ('c', 30., 300.)],
+                           dtype=[('A', '|S3'), ('B', float), ('C', float)],
+                           mask=[(0, 0, 1), (0, 0, 1),
+                                 (0, 0, 0), (0, 0, 0), (0, 0, 0)])
+        assert_equal(test, control)
+        assert_equal(test.mask, control.mask)
+
+        test = stack_arrays((z, zz, x))
+        ndtype = [('A', '|S3'), ('B', float), ('C', float), ('f3', int)]
+        control = ma.array([('A', 1, -1, -1), ('B', 2, -1, -1),
+                            ('a', 10., 100., -1), ('b', 20., 200., -1),
+                            ('c', 30., 300., -1),
+                            (-1, -1, -1, 1), (-1, -1, -1, 2)],
+                           dtype=ndtype,
+                           mask=[(0, 0, 1, 1), (0, 0, 1, 1),
+                                 (0, 0, 0, 1), (0, 0, 0, 1), (0, 0, 0, 1),
+                                 (1, 1, 1, 0), (1, 1, 1, 0)])
+        assert_equal(test, control)
+        assert_equal(test.mask, control.mask)
+
+    def test_defaults(self):
+        # Test defaults: no exception raised if keys of defaults are not fields.
+        (_, _, _, z) = self.data
+        zz = np.array([('a', 10., 100.), ('b', 20., 200.), ('c', 30., 300.)],
+                      dtype=[('A', '|S3'), ('B', float), ('C', float)])
+        defaults = {'A': '???', 'B': -999., 'C': -9999., 'D': -99999.}
+        test = stack_arrays((z, zz), defaults=defaults)
+        control = ma.array([('A', 1, -9999.), ('B', 2, -9999.),
+                            (
+                                'a', 10., 100.), ('b', 20., 200.), ('c', 30., 300.)],
+                           dtype=[('A', '|S3'), ('B', float), ('C', float)],
+                           mask=[(0, 0, 1), (0, 0, 1),
+                                 (0, 0, 0), (0, 0, 0), (0, 0, 0)])
+        assert_equal(test, control)
+        assert_equal(test.data, control.data)
+        assert_equal(test.mask, control.mask)
+
+    def test_autoconversion(self):
+        # Tests autoconversion
+        adtype = [('A', int), ('B', bool), ('C', float)]
+        a = ma.array([(1, 2, 3)], mask=[(0, 1, 0)], dtype=adtype)
+        bdtype = [('A', int), ('B', float), ('C', float)]
+        b = ma.array([(4, 5, 6)], dtype=bdtype)
+        control = ma.array([(1, 2, 3), (4, 5, 6)], mask=[(0, 1, 0), (0, 0, 0)],
+                           dtype=bdtype)
+        test = stack_arrays((a, b), autoconvert=True)
+        assert_equal(test, control)
+        assert_equal(test.mask, control.mask)
+        with assert_raises(TypeError):
+            stack_arrays((a, b), autoconvert=False)
+
+    def test_checktitles(self):
+        # Test using titles in the field names
+        adtype = [(('a', 'A'), int), (('b', 'B'), bool), (('c', 'C'), float)]
+        a = ma.array([(1, 2, 3)], mask=[(0, 1, 0)], dtype=adtype)
+        bdtype = [(('a', 'A'), int), (('b', 'B'), bool), (('c', 'C'), float)]
+        b = ma.array([(4, 5, 6)], dtype=bdtype)
+        test = stack_arrays((a, b))
+        control = ma.array([(1, 2, 3), (4, 5, 6)], mask=[(0, 1, 0), (0, 0, 0)],
+                           dtype=bdtype)
+        assert_equal(test, control)
+        assert_equal(test.mask, control.mask)
+
+    def test_subdtype(self):
+        z = np.array([
+            ('A', 1), ('B', 2)
+        ], dtype=[('A', '|S3'), ('B', float, (1,))])
+        zz = np.array([
+            ('a', [10.], 100.), ('b', [20.], 200.), ('c', [30.], 300.)
+        ], dtype=[('A', '|S3'), ('B', float, (1,)), ('C', float)])
+
+        res = stack_arrays((z, zz))
+        expected = ma.array(
+            data=[
+                (b'A', [1.0], 0),
+                (b'B', [2.0], 0),
+                (b'a', [10.0], 100.0),
+                (b'b', [20.0], 200.0),
+                (b'c', [30.0], 300.0)],
+            mask=[
+                (False, [False],  True),
+                (False, [False],  True),
+                (False, [False], False),
+                (False, [False], False),
+                (False, [False], False)
+            ],
+            dtype=zz.dtype
+        )
+        assert_equal(res.dtype, expected.dtype)
+        assert_equal(res, expected)
+        assert_equal(res.mask, expected.mask)
+
+
+class TestJoinBy:
+    def setup_method(self):
+        self.a = np.array(list(zip(np.arange(10), np.arange(50, 60),
+                                   np.arange(100, 110))),
+                          dtype=[('a', int), ('b', int), ('c', int)])
+        self.b = np.array(list(zip(np.arange(5, 15), np.arange(65, 75),
+                                   np.arange(100, 110))),
+                          dtype=[('a', int), ('b', int), ('d', int)])
+
+    def test_inner_join(self):
+        # Basic test of join_by
+        a, b = self.a, self.b
+
+        test = join_by('a', a, b, jointype='inner')
+        control = np.array([(5, 55, 65, 105, 100), (6, 56, 66, 106, 101),
+                            (7, 57, 67, 107, 102), (8, 58, 68, 108, 103),
+                            (9, 59, 69, 109, 104)],
+                           dtype=[('a', int), ('b1', int), ('b2', int),
+                                  ('c', int), ('d', int)])
+        assert_equal(test, control)
+
+    def test_join(self):
+        a, b = self.a, self.b
+
+        # Fixme, this test is broken
+        #test = join_by(('a', 'b'), a, b)
+        #control = np.array([(5, 55, 105, 100), (6, 56, 106, 101),
+        #                    (7, 57, 107, 102), (8, 58, 108, 103),
+        #                    (9, 59, 109, 104)],
+        #                   dtype=[('a', int), ('b', int),
+        #                          ('c', int), ('d', int)])
+        #assert_equal(test, control)
+
+        # Hack to avoid pyflakes unused variable warnings
+        join_by(('a', 'b'), a, b)
+        np.array([(5, 55, 105, 100), (6, 56, 106, 101),
+                  (7, 57, 107, 102), (8, 58, 108, 103),
+                  (9, 59, 109, 104)],
+                  dtype=[('a', int), ('b', int),
+                         ('c', int), ('d', int)])
+
+    def test_join_subdtype(self):
+        # tests the bug in https://stackoverflow.com/q/44769632/102441
+        foo = np.array([(1,)],
+                       dtype=[('key', int)])
+        bar = np.array([(1, np.array([1,2,3]))],
+                       dtype=[('key', int), ('value', 'uint16', 3)])
+        res = join_by('key', foo, bar)
+        assert_equal(res, bar.view(ma.MaskedArray))
+
+    def test_outer_join(self):
+        a, b = self.a, self.b
+
+        test = join_by(('a', 'b'), a, b, 'outer')
+        control = ma.array([(0, 50, 100, -1), (1, 51, 101, -1),
+                            (2, 52, 102, -1), (3, 53, 103, -1),
+                            (4, 54, 104, -1), (5, 55, 105, -1),
+                            (5, 65, -1, 100), (6, 56, 106, -1),
+                            (6, 66, -1, 101), (7, 57, 107, -1),
+                            (7, 67, -1, 102), (8, 58, 108, -1),
+                            (8, 68, -1, 103), (9, 59, 109, -1),
+                            (9, 69, -1, 104), (10, 70, -1, 105),
+                            (11, 71, -1, 106), (12, 72, -1, 107),
+                            (13, 73, -1, 108), (14, 74, -1, 109)],
+                           mask=[(0, 0, 0, 1), (0, 0, 0, 1),
+                                 (0, 0, 0, 1), (0, 0, 0, 1),
+                                 (0, 0, 0, 1), (0, 0, 0, 1),
+                                 (0, 0, 1, 0), (0, 0, 0, 1),
+                                 (0, 0, 1, 0), (0, 0, 0, 1),
+                                 (0, 0, 1, 0), (0, 0, 0, 1),
+                                 (0, 0, 1, 0), (0, 0, 0, 1),
+                                 (0, 0, 1, 0), (0, 0, 1, 0),
+                                 (0, 0, 1, 0), (0, 0, 1, 0),
+                                 (0, 0, 1, 0), (0, 0, 1, 0)],
+                           dtype=[('a', int), ('b', int),
+                                  ('c', int), ('d', int)])
+        assert_equal(test, control)
+
+    def test_leftouter_join(self):
+        a, b = self.a, self.b
+
+        test = join_by(('a', 'b'), a, b, 'leftouter')
+        control = ma.array([(0, 50, 100, -1), (1, 51, 101, -1),
+                            (2, 52, 102, -1), (3, 53, 103, -1),
+                            (4, 54, 104, -1), (5, 55, 105, -1),
+                            (6, 56, 106, -1), (7, 57, 107, -1),
+                            (8, 58, 108, -1), (9, 59, 109, -1)],
+                           mask=[(0, 0, 0, 1), (0, 0, 0, 1),
+                                 (0, 0, 0, 1), (0, 0, 0, 1),
+                                 (0, 0, 0, 1), (0, 0, 0, 1),
+                                 (0, 0, 0, 1), (0, 0, 0, 1),
+                                 (0, 0, 0, 1), (0, 0, 0, 1)],
+                           dtype=[('a', int), ('b', int), ('c', int), ('d', int)])
+        assert_equal(test, control)
+
+    def test_different_field_order(self):
+        # gh-8940
+        a = np.zeros(3, dtype=[('a', 'i4'), ('b', 'f4'), ('c', 'u1')])
+        b = np.ones(3, dtype=[('c', 'u1'), ('b', 'f4'), ('a', 'i4')])
+        # this should not give a FutureWarning:
+        j = join_by(['c', 'b'], a, b, jointype='inner', usemask=False)
+        assert_equal(j.dtype.names, ['b', 'c', 'a1', 'a2'])
+
+    def test_duplicate_keys(self):
+        a = np.zeros(3, dtype=[('a', 'i4'), ('b', 'f4'), ('c', 'u1')])
+        b = np.ones(3, dtype=[('c', 'u1'), ('b', 'f4'), ('a', 'i4')])
+        assert_raises(ValueError, join_by, ['a', 'b', 'b'], a, b)
+
+    def test_same_name_different_dtypes_key(self):
+        a_dtype = np.dtype([('key', 'S5'), ('value', ' 2**32
+
+
+def _add_keepdims(func):
+    """ hack in keepdims behavior into a function taking an axis """
+    @functools.wraps(func)
+    def wrapped(a, axis, **kwargs):
+        res = func(a, axis=axis, **kwargs)
+        if axis is None:
+            axis = 0  # res is now a scalar, so we can insert this anywhere
+        return np.expand_dims(res, axis=axis)
+    return wrapped
+
+
+class TestTakeAlongAxis:
+    def test_argequivalent(self):
+        """ Test it translates from arg to  """
+        from numpy.random import rand
+        a = rand(3, 4, 5)
+
+        funcs = [
+            (np.sort, np.argsort, dict()),
+            (_add_keepdims(np.min), _add_keepdims(np.argmin), dict()),
+            (_add_keepdims(np.max), _add_keepdims(np.argmax), dict()),
+            #(np.partition, np.argpartition, dict(kth=2)),
+        ]
+
+        for func, argfunc, kwargs in funcs:
+            for axis in list(range(a.ndim)) + [None]:
+                a_func = func(a, axis=axis, **kwargs)
+                ai_func = argfunc(a, axis=axis, **kwargs)
+                assert_equal(a_func, take_along_axis(a, ai_func, axis=axis))
+
+    def test_invalid(self):
+        """ Test it errors when indices has too few dimensions """
+        a = np.ones((10, 10))
+        ai = np.ones((10, 2), dtype=np.intp)
+
+        # sanity check
+        take_along_axis(a, ai, axis=1)
+
+        # not enough indices
+        assert_raises(ValueError, take_along_axis, a, np.array(1), axis=1)
+        # bool arrays not allowed
+        assert_raises(IndexError, take_along_axis, a, ai.astype(bool), axis=1)
+        # float arrays not allowed
+        assert_raises(IndexError, take_along_axis, a, ai.astype(float), axis=1)
+        # invalid axis
+        assert_raises(AxisError, take_along_axis, a, ai, axis=10)
+        # invalid indices
+        assert_raises(ValueError, take_along_axis, a, ai, axis=None)
+
+    def test_empty(self):
+        """ Test everything is ok with empty results, even with inserted dims """
+        a  = np.ones((3, 4, 5))
+        ai = np.ones((3, 0, 5), dtype=np.intp)
+
+        actual = take_along_axis(a, ai, axis=1)
+        assert_equal(actual.shape, ai.shape)
+
+    def test_broadcast(self):
+        """ Test that non-indexing dimensions are broadcast in both directions """
+        a  = np.ones((3, 4, 1))
+        ai = np.ones((1, 2, 5), dtype=np.intp)
+        actual = take_along_axis(a, ai, axis=1)
+        assert_equal(actual.shape, (3, 2, 5))
+
+
+class TestPutAlongAxis:
+    def test_replace_max(self):
+        a_base = np.array([[10, 30, 20], [60, 40, 50]])
+
+        for axis in list(range(a_base.ndim)) + [None]:
+            # we mutate this in the loop
+            a = a_base.copy()
+
+            # replace the max with a small value
+            i_max = _add_keepdims(np.argmax)(a, axis=axis)
+            put_along_axis(a, i_max, -99, axis=axis)
+
+            # find the new minimum, which should max
+            i_min = _add_keepdims(np.argmin)(a, axis=axis)
+
+            assert_equal(i_min, i_max)
+
+    def test_broadcast(self):
+        """ Test that non-indexing dimensions are broadcast in both directions """
+        a  = np.ones((3, 4, 1))
+        ai = np.arange(10, dtype=np.intp).reshape((1, 2, 5)) % 4
+        put_along_axis(a, ai, 20, axis=1)
+        assert_equal(take_along_axis(a, ai, axis=1), 20)
+
+    def test_invalid(self):
+        """ Test invalid inputs """
+        a_base = np.array([[10, 30, 20], [60, 40, 50]])
+        indices = np.array([[0], [1]])
+        values = np.array([[2], [1]])
+
+        # sanity check
+        a = a_base.copy()
+        put_along_axis(a, indices, values, axis=0)
+        assert np.all(a == [[2, 2, 2], [1, 1, 1]])
+
+        # invalid indices
+        a = a_base.copy()
+        with assert_raises(ValueError) as exc:
+            put_along_axis(a, indices, values, axis=None)
+        assert "single dimension" in str(exc.exception)
+
+
+
+class TestApplyAlongAxis:
+    def test_simple(self):
+        a = np.ones((20, 10), 'd')
+        assert_array_equal(
+            apply_along_axis(len, 0, a), len(a)*np.ones(a.shape[1]))
+
+    def test_simple101(self):
+        a = np.ones((10, 101), 'd')
+        assert_array_equal(
+            apply_along_axis(len, 0, a), len(a)*np.ones(a.shape[1]))
+
+    def test_3d(self):
+        a = np.arange(27).reshape((3, 3, 3))
+        assert_array_equal(apply_along_axis(np.sum, 0, a),
+                           [[27, 30, 33], [36, 39, 42], [45, 48, 51]])
+
+    def test_preserve_subclass(self):
+        def double(row):
+            return row * 2
+
+        class MyNDArray(np.ndarray):
+            pass
+
+        m = np.array([[0, 1], [2, 3]]).view(MyNDArray)
+        expected = np.array([[0, 2], [4, 6]]).view(MyNDArray)
+
+        result = apply_along_axis(double, 0, m)
+        assert_(isinstance(result, MyNDArray))
+        assert_array_equal(result, expected)
+
+        result = apply_along_axis(double, 1, m)
+        assert_(isinstance(result, MyNDArray))
+        assert_array_equal(result, expected)
+
+    def test_subclass(self):
+        class MinimalSubclass(np.ndarray):
+            data = 1
+
+        def minimal_function(array):
+            return array.data
+
+        a = np.zeros((6, 3)).view(MinimalSubclass)
+
+        assert_array_equal(
+            apply_along_axis(minimal_function, 0, a), np.array([1, 1, 1])
+        )
+
+    def test_scalar_array(self, cls=np.ndarray):
+        a = np.ones((6, 3)).view(cls)
+        res = apply_along_axis(np.sum, 0, a)
+        assert_(isinstance(res, cls))
+        assert_array_equal(res, np.array([6, 6, 6]).view(cls))
+
+    def test_0d_array(self, cls=np.ndarray):
+        def sum_to_0d(x):
+            """ Sum x, returning a 0d array of the same class """
+            assert_equal(x.ndim, 1)
+            return np.squeeze(np.sum(x, keepdims=True))
+        a = np.ones((6, 3)).view(cls)
+        res = apply_along_axis(sum_to_0d, 0, a)
+        assert_(isinstance(res, cls))
+        assert_array_equal(res, np.array([6, 6, 6]).view(cls))
+
+        res = apply_along_axis(sum_to_0d, 1, a)
+        assert_(isinstance(res, cls))
+        assert_array_equal(res, np.array([3, 3, 3, 3, 3, 3]).view(cls))
+
+    def test_axis_insertion(self, cls=np.ndarray):
+        def f1to2(x):
+            """produces an asymmetric non-square matrix from x"""
+            assert_equal(x.ndim, 1)
+            return (x[::-1] * x[1:,None]).view(cls)
+
+        a2d = np.arange(6*3).reshape((6, 3))
+
+        # 2d insertion along first axis
+        actual = apply_along_axis(f1to2, 0, a2d)
+        expected = np.stack([
+            f1to2(a2d[:,i]) for i in range(a2d.shape[1])
+        ], axis=-1).view(cls)
+        assert_equal(type(actual), type(expected))
+        assert_equal(actual, expected)
+
+        # 2d insertion along last axis
+        actual = apply_along_axis(f1to2, 1, a2d)
+        expected = np.stack([
+            f1to2(a2d[i,:]) for i in range(a2d.shape[0])
+        ], axis=0).view(cls)
+        assert_equal(type(actual), type(expected))
+        assert_equal(actual, expected)
+
+        # 3d insertion along middle axis
+        a3d = np.arange(6*5*3).reshape((6, 5, 3))
+
+        actual = apply_along_axis(f1to2, 1, a3d)
+        expected = np.stack([
+            np.stack([
+                f1to2(a3d[i,:,j]) for i in range(a3d.shape[0])
+            ], axis=0)
+            for j in range(a3d.shape[2])
+        ], axis=-1).view(cls)
+        assert_equal(type(actual), type(expected))
+        assert_equal(actual, expected)
+
+    def test_subclass_preservation(self):
+        class MinimalSubclass(np.ndarray):
+            pass
+        self.test_scalar_array(MinimalSubclass)
+        self.test_0d_array(MinimalSubclass)
+        self.test_axis_insertion(MinimalSubclass)
+
+    def test_axis_insertion_ma(self):
+        def f1to2(x):
+            """produces an asymmetric non-square matrix from x"""
+            assert_equal(x.ndim, 1)
+            res = x[::-1] * x[1:,None]
+            return np.ma.masked_where(res%5==0, res)
+        a = np.arange(6*3).reshape((6, 3))
+        res = apply_along_axis(f1to2, 0, a)
+        assert_(isinstance(res, np.ma.masked_array))
+        assert_equal(res.ndim, 3)
+        assert_array_equal(res[:,:,0].mask, f1to2(a[:,0]).mask)
+        assert_array_equal(res[:,:,1].mask, f1to2(a[:,1]).mask)
+        assert_array_equal(res[:,:,2].mask, f1to2(a[:,2]).mask)
+
+    def test_tuple_func1d(self):
+        def sample_1d(x):
+            return x[1], x[0]
+        res = np.apply_along_axis(sample_1d, 1, np.array([[1, 2], [3, 4]]))
+        assert_array_equal(res, np.array([[2, 1], [4, 3]]))
+
+    def test_empty(self):
+        # can't apply_along_axis when there's no chance to call the function
+        def never_call(x):
+            assert_(False) # should never be reached
+
+        a = np.empty((0, 0))
+        assert_raises(ValueError, np.apply_along_axis, never_call, 0, a)
+        assert_raises(ValueError, np.apply_along_axis, never_call, 1, a)
+
+        # but it's sometimes ok with some non-zero dimensions
+        def empty_to_1(x):
+            assert_(len(x) == 0)
+            return 1
+
+        a = np.empty((10, 0))
+        actual = np.apply_along_axis(empty_to_1, 1, a)
+        assert_equal(actual, np.ones(10))
+        assert_raises(ValueError, np.apply_along_axis, empty_to_1, 0, a)
+
+    def test_with_iterable_object(self):
+        # from issue 5248
+        d = np.array([
+            [{1, 11}, {2, 22}, {3, 33}],
+            [{4, 44}, {5, 55}, {6, 66}]
+        ])
+        actual = np.apply_along_axis(lambda a: set.union(*a), 0, d)
+        expected = np.array([{1, 11, 4, 44}, {2, 22, 5, 55}, {3, 33, 6, 66}])
+
+        assert_equal(actual, expected)
+
+        # issue 8642 - assert_equal doesn't detect this!
+        for i in np.ndindex(actual.shape):
+            assert_equal(type(actual[i]), type(expected[i]))
+
+
+class TestApplyOverAxes:
+    def test_simple(self):
+        a = np.arange(24).reshape(2, 3, 4)
+        aoa_a = apply_over_axes(np.sum, a, [0, 2])
+        assert_array_equal(aoa_a, np.array([[[60], [92], [124]]]))
+
+
+class TestExpandDims:
+    def test_functionality(self):
+        s = (2, 3, 4, 5)
+        a = np.empty(s)
+        for axis in range(-5, 4):
+            b = expand_dims(a, axis)
+            assert_(b.shape[axis] == 1)
+            assert_(np.squeeze(b).shape == s)
+
+    def test_axis_tuple(self):
+        a = np.empty((3, 3, 3))
+        assert np.expand_dims(a, axis=(0, 1, 2)).shape == (1, 1, 1, 3, 3, 3)
+        assert np.expand_dims(a, axis=(0, -1, -2)).shape == (1, 3, 3, 3, 1, 1)
+        assert np.expand_dims(a, axis=(0, 3, 5)).shape == (1, 3, 3, 1, 3, 1)
+        assert np.expand_dims(a, axis=(0, -3, -5)).shape == (1, 1, 3, 1, 3, 3)
+
+    def test_axis_out_of_range(self):
+        s = (2, 3, 4, 5)
+        a = np.empty(s)
+        assert_raises(AxisError, expand_dims, a, -6)
+        assert_raises(AxisError, expand_dims, a, 5)
+
+        a = np.empty((3, 3, 3))
+        assert_raises(AxisError, expand_dims, a, (0, -6))
+        assert_raises(AxisError, expand_dims, a, (0, 5))
+
+    def test_repeated_axis(self):
+        a = np.empty((3, 3, 3))
+        assert_raises(ValueError, expand_dims, a, axis=(1, 1))
+
+    def test_subclasses(self):
+        a = np.arange(10).reshape((2, 5))
+        a = np.ma.array(a, mask=a%3 == 0)
+
+        expanded = np.expand_dims(a, axis=1)
+        assert_(isinstance(expanded, np.ma.MaskedArray))
+        assert_equal(expanded.shape, (2, 1, 5))
+        assert_equal(expanded.mask.shape, (2, 1, 5))
+
+
+class TestArraySplit:
+    def test_integer_0_split(self):
+        a = np.arange(10)
+        assert_raises(ValueError, array_split, a, 0)
+
+    def test_integer_split(self):
+        a = np.arange(10)
+        res = array_split(a, 1)
+        desired = [np.arange(10)]
+        compare_results(res, desired)
+
+        res = array_split(a, 2)
+        desired = [np.arange(5), np.arange(5, 10)]
+        compare_results(res, desired)
+
+        res = array_split(a, 3)
+        desired = [np.arange(4), np.arange(4, 7), np.arange(7, 10)]
+        compare_results(res, desired)
+
+        res = array_split(a, 4)
+        desired = [np.arange(3), np.arange(3, 6), np.arange(6, 8),
+                   np.arange(8, 10)]
+        compare_results(res, desired)
+
+        res = array_split(a, 5)
+        desired = [np.arange(2), np.arange(2, 4), np.arange(4, 6),
+                   np.arange(6, 8), np.arange(8, 10)]
+        compare_results(res, desired)
+
+        res = array_split(a, 6)
+        desired = [np.arange(2), np.arange(2, 4), np.arange(4, 6),
+                   np.arange(6, 8), np.arange(8, 9), np.arange(9, 10)]
+        compare_results(res, desired)
+
+        res = array_split(a, 7)
+        desired = [np.arange(2), np.arange(2, 4), np.arange(4, 6),
+                   np.arange(6, 7), np.arange(7, 8), np.arange(8, 9),
+                   np.arange(9, 10)]
+        compare_results(res, desired)
+
+        res = array_split(a, 8)
+        desired = [np.arange(2), np.arange(2, 4), np.arange(4, 5),
+                   np.arange(5, 6), np.arange(6, 7), np.arange(7, 8),
+                   np.arange(8, 9), np.arange(9, 10)]
+        compare_results(res, desired)
+
+        res = array_split(a, 9)
+        desired = [np.arange(2), np.arange(2, 3), np.arange(3, 4),
+                   np.arange(4, 5), np.arange(5, 6), np.arange(6, 7),
+                   np.arange(7, 8), np.arange(8, 9), np.arange(9, 10)]
+        compare_results(res, desired)
+
+        res = array_split(a, 10)
+        desired = [np.arange(1), np.arange(1, 2), np.arange(2, 3),
+                   np.arange(3, 4), np.arange(4, 5), np.arange(5, 6),
+                   np.arange(6, 7), np.arange(7, 8), np.arange(8, 9),
+                   np.arange(9, 10)]
+        compare_results(res, desired)
+
+        res = array_split(a, 11)
+        desired = [np.arange(1), np.arange(1, 2), np.arange(2, 3),
+                   np.arange(3, 4), np.arange(4, 5), np.arange(5, 6),
+                   np.arange(6, 7), np.arange(7, 8), np.arange(8, 9),
+                   np.arange(9, 10), np.array([])]
+        compare_results(res, desired)
+
+    def test_integer_split_2D_rows(self):
+        a = np.array([np.arange(10), np.arange(10)])
+        res = array_split(a, 3, axis=0)
+        tgt = [np.array([np.arange(10)]), np.array([np.arange(10)]),
+                   np.zeros((0, 10))]
+        compare_results(res, tgt)
+        assert_(a.dtype.type is res[-1].dtype.type)
+
+        # Same thing for manual splits:
+        res = array_split(a, [0, 1], axis=0)
+        tgt = [np.zeros((0, 10)), np.array([np.arange(10)]),
+               np.array([np.arange(10)])]
+        compare_results(res, tgt)
+        assert_(a.dtype.type is res[-1].dtype.type)
+
+    def test_integer_split_2D_cols(self):
+        a = np.array([np.arange(10), np.arange(10)])
+        res = array_split(a, 3, axis=-1)
+        desired = [np.array([np.arange(4), np.arange(4)]),
+                   np.array([np.arange(4, 7), np.arange(4, 7)]),
+                   np.array([np.arange(7, 10), np.arange(7, 10)])]
+        compare_results(res, desired)
+
+    def test_integer_split_2D_default(self):
+        """ This will fail if we change default axis
+        """
+        a = np.array([np.arange(10), np.arange(10)])
+        res = array_split(a, 3)
+        tgt = [np.array([np.arange(10)]), np.array([np.arange(10)]),
+                   np.zeros((0, 10))]
+        compare_results(res, tgt)
+        assert_(a.dtype.type is res[-1].dtype.type)
+        # perhaps should check higher dimensions
+
+    @pytest.mark.skipif(not IS_64BIT, reason="Needs 64bit platform")
+    def test_integer_split_2D_rows_greater_max_int32(self):
+        a = np.broadcast_to([0], (1 << 32, 2))
+        res = array_split(a, 4)
+        chunk = np.broadcast_to([0], (1 << 30, 2))
+        tgt = [chunk] * 4
+        for i in range(len(tgt)):
+            assert_equal(res[i].shape, tgt[i].shape)
+
+    def test_index_split_simple(self):
+        a = np.arange(10)
+        indices = [1, 5, 7]
+        res = array_split(a, indices, axis=-1)
+        desired = [np.arange(0, 1), np.arange(1, 5), np.arange(5, 7),
+                   np.arange(7, 10)]
+        compare_results(res, desired)
+
+    def test_index_split_low_bound(self):
+        a = np.arange(10)
+        indices = [0, 5, 7]
+        res = array_split(a, indices, axis=-1)
+        desired = [np.array([]), np.arange(0, 5), np.arange(5, 7),
+                   np.arange(7, 10)]
+        compare_results(res, desired)
+
+    def test_index_split_high_bound(self):
+        a = np.arange(10)
+        indices = [0, 5, 7, 10, 12]
+        res = array_split(a, indices, axis=-1)
+        desired = [np.array([]), np.arange(0, 5), np.arange(5, 7),
+                   np.arange(7, 10), np.array([]), np.array([])]
+        compare_results(res, desired)
+
+
+class TestSplit:
+    # The split function is essentially the same as array_split,
+    # except that it test if splitting will result in an
+    # equal split.  Only test for this case.
+
+    def test_equal_split(self):
+        a = np.arange(10)
+        res = split(a, 2)
+        desired = [np.arange(5), np.arange(5, 10)]
+        compare_results(res, desired)
+
+    def test_unequal_split(self):
+        a = np.arange(10)
+        assert_raises(ValueError, split, a, 3)
+
+
+class TestColumnStack:
+    def test_non_iterable(self):
+        assert_raises(TypeError, column_stack, 1)
+
+    def test_1D_arrays(self):
+        # example from docstring
+        a = np.array((1, 2, 3))
+        b = np.array((2, 3, 4))
+        expected = np.array([[1, 2],
+                             [2, 3],
+                             [3, 4]])
+        actual = np.column_stack((a, b))
+        assert_equal(actual, expected)
+
+    def test_2D_arrays(self):
+        # same as hstack 2D docstring example
+        a = np.array([[1], [2], [3]])
+        b = np.array([[2], [3], [4]])
+        expected = np.array([[1, 2],
+                             [2, 3],
+                             [3, 4]])
+        actual = np.column_stack((a, b))
+        assert_equal(actual, expected)
+
+    def test_generator(self):
+        with pytest.raises(TypeError, match="arrays to stack must be"):
+            column_stack(np.arange(3) for _ in range(2))
+
+
+class TestDstack:
+    def test_non_iterable(self):
+        assert_raises(TypeError, dstack, 1)
+
+    def test_0D_array(self):
+        a = np.array(1)
+        b = np.array(2)
+        res = dstack([a, b])
+        desired = np.array([[[1, 2]]])
+        assert_array_equal(res, desired)
+
+    def test_1D_array(self):
+        a = np.array([1])
+        b = np.array([2])
+        res = dstack([a, b])
+        desired = np.array([[[1, 2]]])
+        assert_array_equal(res, desired)
+
+    def test_2D_array(self):
+        a = np.array([[1], [2]])
+        b = np.array([[1], [2]])
+        res = dstack([a, b])
+        desired = np.array([[[1, 1]], [[2, 2, ]]])
+        assert_array_equal(res, desired)
+
+    def test_2D_array2(self):
+        a = np.array([1, 2])
+        b = np.array([1, 2])
+        res = dstack([a, b])
+        desired = np.array([[[1, 1], [2, 2]]])
+        assert_array_equal(res, desired)
+
+    def test_generator(self):
+        with pytest.raises(TypeError, match="arrays to stack must be"):
+            dstack(np.arange(3) for _ in range(2))
+
+
+# array_split has more comprehensive test of splitting.
+# only do simple test on hsplit, vsplit, and dsplit
+class TestHsplit:
+    """Only testing for integer splits.
+
+    """
+    def test_non_iterable(self):
+        assert_raises(ValueError, hsplit, 1, 1)
+
+    def test_0D_array(self):
+        a = np.array(1)
+        try:
+            hsplit(a, 2)
+            assert_(0)
+        except ValueError:
+            pass
+
+    def test_1D_array(self):
+        a = np.array([1, 2, 3, 4])
+        res = hsplit(a, 2)
+        desired = [np.array([1, 2]), np.array([3, 4])]
+        compare_results(res, desired)
+
+    def test_2D_array(self):
+        a = np.array([[1, 2, 3, 4],
+                  [1, 2, 3, 4]])
+        res = hsplit(a, 2)
+        desired = [np.array([[1, 2], [1, 2]]), np.array([[3, 4], [3, 4]])]
+        compare_results(res, desired)
+
+
+class TestVsplit:
+    """Only testing for integer splits.
+
+    """
+    def test_non_iterable(self):
+        assert_raises(ValueError, vsplit, 1, 1)
+
+    def test_0D_array(self):
+        a = np.array(1)
+        assert_raises(ValueError, vsplit, a, 2)
+
+    def test_1D_array(self):
+        a = np.array([1, 2, 3, 4])
+        try:
+            vsplit(a, 2)
+            assert_(0)
+        except ValueError:
+            pass
+
+    def test_2D_array(self):
+        a = np.array([[1, 2, 3, 4],
+                  [1, 2, 3, 4]])
+        res = vsplit(a, 2)
+        desired = [np.array([[1, 2, 3, 4]]), np.array([[1, 2, 3, 4]])]
+        compare_results(res, desired)
+
+
+class TestDsplit:
+    # Only testing for integer splits.
+    def test_non_iterable(self):
+        assert_raises(ValueError, dsplit, 1, 1)
+
+    def test_0D_array(self):
+        a = np.array(1)
+        assert_raises(ValueError, dsplit, a, 2)
+
+    def test_1D_array(self):
+        a = np.array([1, 2, 3, 4])
+        assert_raises(ValueError, dsplit, a, 2)
+
+    def test_2D_array(self):
+        a = np.array([[1, 2, 3, 4],
+                  [1, 2, 3, 4]])
+        try:
+            dsplit(a, 2)
+            assert_(0)
+        except ValueError:
+            pass
+
+    def test_3D_array(self):
+        a = np.array([[[1, 2, 3, 4],
+                   [1, 2, 3, 4]],
+                  [[1, 2, 3, 4],
+                   [1, 2, 3, 4]]])
+        res = dsplit(a, 2)
+        desired = [np.array([[[1, 2], [1, 2]], [[1, 2], [1, 2]]]),
+                   np.array([[[3, 4], [3, 4]], [[3, 4], [3, 4]]])]
+        compare_results(res, desired)
+
+
+class TestSqueeze:
+    def test_basic(self):
+        from numpy.random import rand
+
+        a = rand(20, 10, 10, 1, 1)
+        b = rand(20, 1, 10, 1, 20)
+        c = rand(1, 1, 20, 10)
+        assert_array_equal(np.squeeze(a), np.reshape(a, (20, 10, 10)))
+        assert_array_equal(np.squeeze(b), np.reshape(b, (20, 10, 20)))
+        assert_array_equal(np.squeeze(c), np.reshape(c, (20, 10)))
+
+        # Squeezing to 0-dim should still give an ndarray
+        a = [[[1.5]]]
+        res = np.squeeze(a)
+        assert_equal(res, 1.5)
+        assert_equal(res.ndim, 0)
+        assert_equal(type(res), np.ndarray)
+
+
+class TestKron:
+    def test_basic(self):
+        # Using 0-dimensional ndarray
+        a = np.array(1)
+        b = np.array([[1, 2], [3, 4]])
+        k = np.array([[1, 2], [3, 4]])
+        assert_array_equal(np.kron(a, b), k)
+        a = np.array([[1, 2], [3, 4]])
+        b = np.array(1)
+        assert_array_equal(np.kron(a, b), k)
+
+        # Using 1-dimensional ndarray
+        a = np.array([3])
+        b = np.array([[1, 2], [3, 4]])
+        k = np.array([[3, 6], [9, 12]])
+        assert_array_equal(np.kron(a, b), k)
+        a = np.array([[1, 2], [3, 4]])
+        b = np.array([3])
+        assert_array_equal(np.kron(a, b), k)
+
+        # Using 3-dimensional ndarray
+        a = np.array([[[1]], [[2]]])
+        b = np.array([[1, 2], [3, 4]])
+        k = np.array([[[1, 2], [3, 4]], [[2, 4], [6, 8]]])
+        assert_array_equal(np.kron(a, b), k)
+        a = np.array([[1, 2], [3, 4]])
+        b = np.array([[[1]], [[2]]])
+        k = np.array([[[1, 2], [3, 4]], [[2, 4], [6, 8]]])
+        assert_array_equal(np.kron(a, b), k)
+
+    def test_return_type(self):
+        class myarray(np.ndarray):
+            __array_priority__ = 1.0
+
+        a = np.ones([2, 2])
+        ma = myarray(a.shape, a.dtype, a.data)
+        assert_equal(type(kron(a, a)), np.ndarray)
+        assert_equal(type(kron(ma, ma)), myarray)
+        assert_equal(type(kron(a, ma)), myarray)
+        assert_equal(type(kron(ma, a)), myarray)
+
+    @pytest.mark.parametrize(
+        "array_class", [np.asarray, np.asmatrix]
+    )
+    def test_kron_smoke(self, array_class):
+        a = array_class(np.ones([3, 3]))
+        b = array_class(np.ones([3, 3]))
+        k = array_class(np.ones([9, 9]))
+
+        assert_array_equal(np.kron(a, b), k)
+
+    def test_kron_ma(self):
+        x = np.ma.array([[1, 2], [3, 4]], mask=[[0, 1], [1, 0]])
+        k = np.ma.array(np.diag([1, 4, 4, 16]),
+                mask=~np.array(np.identity(4), dtype=bool))
+
+        assert_array_equal(k, np.kron(x, x))
+
+    @pytest.mark.parametrize(
+        "shape_a,shape_b", [
+            ((1, 1), (1, 1)),
+            ((1, 2, 3), (4, 5, 6)),
+            ((2, 2), (2, 2, 2)),
+            ((1, 0), (1, 1)),
+            ((2, 0, 2), (2, 2)),
+            ((2, 0, 0, 2), (2, 0, 2)),
+        ])
+    def test_kron_shape(self, shape_a, shape_b):
+        a = np.ones(shape_a)
+        b = np.ones(shape_b)
+        normalised_shape_a = (1,) * max(0, len(shape_b)-len(shape_a)) + shape_a
+        normalised_shape_b = (1,) * max(0, len(shape_a)-len(shape_b)) + shape_b
+        expected_shape = np.multiply(normalised_shape_a, normalised_shape_b)
+
+        k = np.kron(a, b)
+        assert np.array_equal(
+                k.shape, expected_shape), "Unexpected shape from kron"
+
+
+class TestTile:
+    def test_basic(self):
+        a = np.array([0, 1, 2])
+        b = [[1, 2], [3, 4]]
+        assert_equal(tile(a, 2), [0, 1, 2, 0, 1, 2])
+        assert_equal(tile(a, (2, 2)), [[0, 1, 2, 0, 1, 2], [0, 1, 2, 0, 1, 2]])
+        assert_equal(tile(a, (1, 2)), [[0, 1, 2, 0, 1, 2]])
+        assert_equal(tile(b, 2), [[1, 2, 1, 2], [3, 4, 3, 4]])
+        assert_equal(tile(b, (2, 1)), [[1, 2], [3, 4], [1, 2], [3, 4]])
+        assert_equal(tile(b, (2, 2)), [[1, 2, 1, 2], [3, 4, 3, 4],
+                                       [1, 2, 1, 2], [3, 4, 3, 4]])
+
+    def test_tile_one_repetition_on_array_gh4679(self):
+        a = np.arange(5)
+        b = tile(a, 1)
+        b += 2
+        assert_equal(a, np.arange(5))
+
+    def test_empty(self):
+        a = np.array([[[]]])
+        b = np.array([[], []])
+        c = tile(b, 2).shape
+        d = tile(a, (3, 2, 5)).shape
+        assert_equal(c, (2, 0))
+        assert_equal(d, (3, 2, 0))
+
+    def test_kroncompare(self):
+        from numpy.random import randint
+
+        reps = [(2,), (1, 2), (2, 1), (2, 2), (2, 3, 2), (3, 2)]
+        shape = [(3,), (2, 3), (3, 4, 3), (3, 2, 3), (4, 3, 2, 4), (2, 2)]
+        for s in shape:
+            b = randint(0, 10, size=s)
+            for r in reps:
+                a = np.ones(r, b.dtype)
+                large = tile(b, r)
+                klarge = kron(a, b)
+                assert_equal(large, klarge)
+
+
+class TestMayShareMemory:
+    def test_basic(self):
+        d = np.ones((50, 60))
+        d2 = np.ones((30, 60, 6))
+        assert_(np.may_share_memory(d, d))
+        assert_(np.may_share_memory(d, d[::-1]))
+        assert_(np.may_share_memory(d, d[::2]))
+        assert_(np.may_share_memory(d, d[1:, ::-1]))
+
+        assert_(not np.may_share_memory(d[::-1], d2))
+        assert_(not np.may_share_memory(d[::2], d2))
+        assert_(not np.may_share_memory(d[1:, ::-1], d2))
+        assert_(np.may_share_memory(d2[1:, ::-1], d2))
+
+
+# Utility
+def compare_results(res, desired):
+    """Compare lists of arrays."""
+    if len(res) != len(desired):
+        raise ValueError("Iterables have different lengths")
+    # See also PEP 618 for Python 3.10
+    for x, y in zip(res, desired):
+        assert_array_equal(x, y)
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/tests/test_stride_tricks.py b/venv/lib/python3.12/site-packages/numpy/lib/tests/test_stride_tricks.py
new file mode 100644
index 00000000..3cbebbdd
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/lib/tests/test_stride_tricks.py
@@ -0,0 +1,647 @@
+import numpy as np
+from numpy._core._rational_tests import rational
+from numpy.testing import (
+    assert_equal, assert_array_equal, assert_raises, assert_,
+    assert_raises_regex, assert_warns,
+    )
+from numpy.lib._stride_tricks_impl import (
+    as_strided, broadcast_arrays, _broadcast_shape, broadcast_to,
+    broadcast_shapes, sliding_window_view,
+    )
+import pytest
+
+
+def assert_shapes_correct(input_shapes, expected_shape):
+    # Broadcast a list of arrays with the given input shapes and check the
+    # common output shape.
+
+    inarrays = [np.zeros(s) for s in input_shapes]
+    outarrays = broadcast_arrays(*inarrays)
+    outshapes = [a.shape for a in outarrays]
+    expected = [expected_shape] * len(inarrays)
+    assert_equal(outshapes, expected)
+
+
+def assert_incompatible_shapes_raise(input_shapes):
+    # Broadcast a list of arrays with the given (incompatible) input shapes
+    # and check that they raise a ValueError.
+
+    inarrays = [np.zeros(s) for s in input_shapes]
+    assert_raises(ValueError, broadcast_arrays, *inarrays)
+
+
+def assert_same_as_ufunc(shape0, shape1, transposed=False, flipped=False):
+    # Broadcast two shapes against each other and check that the data layout
+    # is the same as if a ufunc did the broadcasting.
+
+    x0 = np.zeros(shape0, dtype=int)
+    # Note that multiply.reduce's identity element is 1.0, so when shape1==(),
+    # this gives the desired n==1.
+    n = int(np.multiply.reduce(shape1))
+    x1 = np.arange(n).reshape(shape1)
+    if transposed:
+        x0 = x0.T
+        x1 = x1.T
+    if flipped:
+        x0 = x0[::-1]
+        x1 = x1[::-1]
+    # Use the add ufunc to do the broadcasting. Since we're adding 0s to x1, the
+    # result should be exactly the same as the broadcasted view of x1.
+    y = x0 + x1
+    b0, b1 = broadcast_arrays(x0, x1)
+    assert_array_equal(y, b1)
+
+
+def test_same():
+    x = np.arange(10)
+    y = np.arange(10)
+    bx, by = broadcast_arrays(x, y)
+    assert_array_equal(x, bx)
+    assert_array_equal(y, by)
+
+def test_broadcast_kwargs():
+    # ensure that a TypeError is appropriately raised when
+    # np.broadcast_arrays() is called with any keyword
+    # argument other than 'subok'
+    x = np.arange(10)
+    y = np.arange(10)
+
+    with assert_raises_regex(TypeError, 'got an unexpected keyword'):
+        broadcast_arrays(x, y, dtype='float64')
+
+
+def test_one_off():
+    x = np.array([[1, 2, 3]])
+    y = np.array([[1], [2], [3]])
+    bx, by = broadcast_arrays(x, y)
+    bx0 = np.array([[1, 2, 3], [1, 2, 3], [1, 2, 3]])
+    by0 = bx0.T
+    assert_array_equal(bx0, bx)
+    assert_array_equal(by0, by)
+
+
+def test_same_input_shapes():
+    # Check that the final shape is just the input shape.
+
+    data = [
+        (),
+        (1,),
+        (3,),
+        (0, 1),
+        (0, 3),
+        (1, 0),
+        (3, 0),
+        (1, 3),
+        (3, 1),
+        (3, 3),
+    ]
+    for shape in data:
+        input_shapes = [shape]
+        # Single input.
+        assert_shapes_correct(input_shapes, shape)
+        # Double input.
+        input_shapes2 = [shape, shape]
+        assert_shapes_correct(input_shapes2, shape)
+        # Triple input.
+        input_shapes3 = [shape, shape, shape]
+        assert_shapes_correct(input_shapes3, shape)
+
+
+def test_two_compatible_by_ones_input_shapes():
+    # Check that two different input shapes of the same length, but some have
+    # ones, broadcast to the correct shape.
+
+    data = [
+        [[(1,), (3,)], (3,)],
+        [[(1, 3), (3, 3)], (3, 3)],
+        [[(3, 1), (3, 3)], (3, 3)],
+        [[(1, 3), (3, 1)], (3, 3)],
+        [[(1, 1), (3, 3)], (3, 3)],
+        [[(1, 1), (1, 3)], (1, 3)],
+        [[(1, 1), (3, 1)], (3, 1)],
+        [[(1, 0), (0, 0)], (0, 0)],
+        [[(0, 1), (0, 0)], (0, 0)],
+        [[(1, 0), (0, 1)], (0, 0)],
+        [[(1, 1), (0, 0)], (0, 0)],
+        [[(1, 1), (1, 0)], (1, 0)],
+        [[(1, 1), (0, 1)], (0, 1)],
+    ]
+    for input_shapes, expected_shape in data:
+        assert_shapes_correct(input_shapes, expected_shape)
+        # Reverse the input shapes since broadcasting should be symmetric.
+        assert_shapes_correct(input_shapes[::-1], expected_shape)
+
+
+def test_two_compatible_by_prepending_ones_input_shapes():
+    # Check that two different input shapes (of different lengths) broadcast
+    # to the correct shape.
+
+    data = [
+        [[(), (3,)], (3,)],
+        [[(3,), (3, 3)], (3, 3)],
+        [[(3,), (3, 1)], (3, 3)],
+        [[(1,), (3, 3)], (3, 3)],
+        [[(), (3, 3)], (3, 3)],
+        [[(1, 1), (3,)], (1, 3)],
+        [[(1,), (3, 1)], (3, 1)],
+        [[(1,), (1, 3)], (1, 3)],
+        [[(), (1, 3)], (1, 3)],
+        [[(), (3, 1)], (3, 1)],
+        [[(), (0,)], (0,)],
+        [[(0,), (0, 0)], (0, 0)],
+        [[(0,), (0, 1)], (0, 0)],
+        [[(1,), (0, 0)], (0, 0)],
+        [[(), (0, 0)], (0, 0)],
+        [[(1, 1), (0,)], (1, 0)],
+        [[(1,), (0, 1)], (0, 1)],
+        [[(1,), (1, 0)], (1, 0)],
+        [[(), (1, 0)], (1, 0)],
+        [[(), (0, 1)], (0, 1)],
+    ]
+    for input_shapes, expected_shape in data:
+        assert_shapes_correct(input_shapes, expected_shape)
+        # Reverse the input shapes since broadcasting should be symmetric.
+        assert_shapes_correct(input_shapes[::-1], expected_shape)
+
+
+def test_incompatible_shapes_raise_valueerror():
+    # Check that a ValueError is raised for incompatible shapes.
+
+    data = [
+        [(3,), (4,)],
+        [(2, 3), (2,)],
+        [(3,), (3,), (4,)],
+        [(1, 3, 4), (2, 3, 3)],
+    ]
+    for input_shapes in data:
+        assert_incompatible_shapes_raise(input_shapes)
+        # Reverse the input shapes since broadcasting should be symmetric.
+        assert_incompatible_shapes_raise(input_shapes[::-1])
+
+
+def test_same_as_ufunc():
+    # Check that the data layout is the same as if a ufunc did the operation.
+
+    data = [
+        [[(1,), (3,)], (3,)],
+        [[(1, 3), (3, 3)], (3, 3)],
+        [[(3, 1), (3, 3)], (3, 3)],
+        [[(1, 3), (3, 1)], (3, 3)],
+        [[(1, 1), (3, 3)], (3, 3)],
+        [[(1, 1), (1, 3)], (1, 3)],
+        [[(1, 1), (3, 1)], (3, 1)],
+        [[(1, 0), (0, 0)], (0, 0)],
+        [[(0, 1), (0, 0)], (0, 0)],
+        [[(1, 0), (0, 1)], (0, 0)],
+        [[(1, 1), (0, 0)], (0, 0)],
+        [[(1, 1), (1, 0)], (1, 0)],
+        [[(1, 1), (0, 1)], (0, 1)],
+        [[(), (3,)], (3,)],
+        [[(3,), (3, 3)], (3, 3)],
+        [[(3,), (3, 1)], (3, 3)],
+        [[(1,), (3, 3)], (3, 3)],
+        [[(), (3, 3)], (3, 3)],
+        [[(1, 1), (3,)], (1, 3)],
+        [[(1,), (3, 1)], (3, 1)],
+        [[(1,), (1, 3)], (1, 3)],
+        [[(), (1, 3)], (1, 3)],
+        [[(), (3, 1)], (3, 1)],
+        [[(), (0,)], (0,)],
+        [[(0,), (0, 0)], (0, 0)],
+        [[(0,), (0, 1)], (0, 0)],
+        [[(1,), (0, 0)], (0, 0)],
+        [[(), (0, 0)], (0, 0)],
+        [[(1, 1), (0,)], (1, 0)],
+        [[(1,), (0, 1)], (0, 1)],
+        [[(1,), (1, 0)], (1, 0)],
+        [[(), (1, 0)], (1, 0)],
+        [[(), (0, 1)], (0, 1)],
+    ]
+    for input_shapes, expected_shape in data:
+        assert_same_as_ufunc(input_shapes[0], input_shapes[1],
+                             "Shapes: %s %s" % (input_shapes[0], input_shapes[1]))
+        # Reverse the input shapes since broadcasting should be symmetric.
+        assert_same_as_ufunc(input_shapes[1], input_shapes[0])
+        # Try them transposed, too.
+        assert_same_as_ufunc(input_shapes[0], input_shapes[1], True)
+        # ... and flipped for non-rank-0 inputs in order to test negative
+        # strides.
+        if () not in input_shapes:
+            assert_same_as_ufunc(input_shapes[0], input_shapes[1], False, True)
+            assert_same_as_ufunc(input_shapes[0], input_shapes[1], True, True)
+
+
+def test_broadcast_to_succeeds():
+    data = [
+        [np.array(0), (0,), np.array(0)],
+        [np.array(0), (1,), np.zeros(1)],
+        [np.array(0), (3,), np.zeros(3)],
+        [np.ones(1), (1,), np.ones(1)],
+        [np.ones(1), (2,), np.ones(2)],
+        [np.ones(1), (1, 2, 3), np.ones((1, 2, 3))],
+        [np.arange(3), (3,), np.arange(3)],
+        [np.arange(3), (1, 3), np.arange(3).reshape(1, -1)],
+        [np.arange(3), (2, 3), np.array([[0, 1, 2], [0, 1, 2]])],
+        # test if shape is not a tuple
+        [np.ones(0), 0, np.ones(0)],
+        [np.ones(1), 1, np.ones(1)],
+        [np.ones(1), 2, np.ones(2)],
+        # these cases with size 0 are strange, but they reproduce the behavior
+        # of broadcasting with ufuncs (see test_same_as_ufunc above)
+        [np.ones(1), (0,), np.ones(0)],
+        [np.ones((1, 2)), (0, 2), np.ones((0, 2))],
+        [np.ones((2, 1)), (2, 0), np.ones((2, 0))],
+    ]
+    for input_array, shape, expected in data:
+        actual = broadcast_to(input_array, shape)
+        assert_array_equal(expected, actual)
+
+
+def test_broadcast_to_raises():
+    data = [
+        [(0,), ()],
+        [(1,), ()],
+        [(3,), ()],
+        [(3,), (1,)],
+        [(3,), (2,)],
+        [(3,), (4,)],
+        [(1, 2), (2, 1)],
+        [(1, 1), (1,)],
+        [(1,), -1],
+        [(1,), (-1,)],
+        [(1, 2), (-1, 2)],
+    ]
+    for orig_shape, target_shape in data:
+        arr = np.zeros(orig_shape)
+        assert_raises(ValueError, lambda: broadcast_to(arr, target_shape))
+
+
+def test_broadcast_shape():
+    # tests internal _broadcast_shape
+    # _broadcast_shape is already exercised indirectly by broadcast_arrays
+    # _broadcast_shape is also exercised by the public broadcast_shapes function
+    assert_equal(_broadcast_shape(), ())
+    assert_equal(_broadcast_shape([1, 2]), (2,))
+    assert_equal(_broadcast_shape(np.ones((1, 1))), (1, 1))
+    assert_equal(_broadcast_shape(np.ones((1, 1)), np.ones((3, 4))), (3, 4))
+    assert_equal(_broadcast_shape(*([np.ones((1, 2))] * 32)), (1, 2))
+    assert_equal(_broadcast_shape(*([np.ones((1, 2))] * 100)), (1, 2))
+
+    # regression tests for gh-5862
+    assert_equal(_broadcast_shape(*([np.ones(2)] * 32 + [1])), (2,))
+    bad_args = [np.ones(2)] * 32 + [np.ones(3)] * 32
+    assert_raises(ValueError, lambda: _broadcast_shape(*bad_args))
+
+
+def test_broadcast_shapes_succeeds():
+    # tests public broadcast_shapes
+    data = [
+        [[], ()],
+        [[()], ()],
+        [[(7,)], (7,)],
+        [[(1, 2), (2,)], (1, 2)],
+        [[(1, 1)], (1, 1)],
+        [[(1, 1), (3, 4)], (3, 4)],
+        [[(6, 7), (5, 6, 1), (7,), (5, 1, 7)], (5, 6, 7)],
+        [[(5, 6, 1)], (5, 6, 1)],
+        [[(1, 3), (3, 1)], (3, 3)],
+        [[(1, 0), (0, 0)], (0, 0)],
+        [[(0, 1), (0, 0)], (0, 0)],
+        [[(1, 0), (0, 1)], (0, 0)],
+        [[(1, 1), (0, 0)], (0, 0)],
+        [[(1, 1), (1, 0)], (1, 0)],
+        [[(1, 1), (0, 1)], (0, 1)],
+        [[(), (0,)], (0,)],
+        [[(0,), (0, 0)], (0, 0)],
+        [[(0,), (0, 1)], (0, 0)],
+        [[(1,), (0, 0)], (0, 0)],
+        [[(), (0, 0)], (0, 0)],
+        [[(1, 1), (0,)], (1, 0)],
+        [[(1,), (0, 1)], (0, 1)],
+        [[(1,), (1, 0)], (1, 0)],
+        [[(), (1, 0)], (1, 0)],
+        [[(), (0, 1)], (0, 1)],
+        [[(1,), (3,)], (3,)],
+        [[2, (3, 2)], (3, 2)],
+    ]
+    for input_shapes, target_shape in data:
+        assert_equal(broadcast_shapes(*input_shapes), target_shape)
+
+    assert_equal(broadcast_shapes(*([(1, 2)] * 32)), (1, 2))
+    assert_equal(broadcast_shapes(*([(1, 2)] * 100)), (1, 2))
+
+    # regression tests for gh-5862
+    assert_equal(broadcast_shapes(*([(2,)] * 32)), (2,))
+
+
+def test_broadcast_shapes_raises():
+    # tests public broadcast_shapes
+    data = [
+        [(3,), (4,)],
+        [(2, 3), (2,)],
+        [(3,), (3,), (4,)],
+        [(1, 3, 4), (2, 3, 3)],
+        [(1, 2), (3, 1), (3, 2), (10, 5)],
+        [2, (2, 3)],
+    ]
+    for input_shapes in data:
+        assert_raises(ValueError, lambda: broadcast_shapes(*input_shapes))
+
+    bad_args = [(2,)] * 32 + [(3,)] * 32
+    assert_raises(ValueError, lambda: broadcast_shapes(*bad_args))
+
+
+def test_as_strided():
+    a = np.array([None])
+    a_view = as_strided(a)
+    expected = np.array([None])
+    assert_array_equal(a_view, np.array([None]))
+
+    a = np.array([1, 2, 3, 4])
+    a_view = as_strided(a, shape=(2,), strides=(2 * a.itemsize,))
+    expected = np.array([1, 3])
+    assert_array_equal(a_view, expected)
+
+    a = np.array([1, 2, 3, 4])
+    a_view = as_strided(a, shape=(3, 4), strides=(0, 1 * a.itemsize))
+    expected = np.array([[1, 2, 3, 4], [1, 2, 3, 4], [1, 2, 3, 4]])
+    assert_array_equal(a_view, expected)
+
+    # Regression test for gh-5081
+    dt = np.dtype([('num', 'i4'), ('obj', 'O')])
+    a = np.empty((4,), dtype=dt)
+    a['num'] = np.arange(1, 5)
+    a_view = as_strided(a, shape=(3, 4), strides=(0, a.itemsize))
+    expected_num = [[1, 2, 3, 4]] * 3
+    expected_obj = [[None]*4]*3
+    assert_equal(a_view.dtype, dt)
+    assert_array_equal(expected_num, a_view['num'])
+    assert_array_equal(expected_obj, a_view['obj'])
+
+    # Make sure that void types without fields are kept unchanged
+    a = np.empty((4,), dtype='V4')
+    a_view = as_strided(a, shape=(3, 4), strides=(0, a.itemsize))
+    assert_equal(a.dtype, a_view.dtype)
+
+    # Make sure that the only type that could fail is properly handled
+    dt = np.dtype({'names': [''], 'formats': ['V4']})
+    a = np.empty((4,), dtype=dt)
+    a_view = as_strided(a, shape=(3, 4), strides=(0, a.itemsize))
+    assert_equal(a.dtype, a_view.dtype)
+
+    # Custom dtypes should not be lost (gh-9161)
+    r = [rational(i) for i in range(4)]
+    a = np.array(r, dtype=rational)
+    a_view = as_strided(a, shape=(3, 4), strides=(0, a.itemsize))
+    assert_equal(a.dtype, a_view.dtype)
+    assert_array_equal([r] * 3, a_view)
+
+
+class TestSlidingWindowView:
+    def test_1d(self):
+        arr = np.arange(5)
+        arr_view = sliding_window_view(arr, 2)
+        expected = np.array([[0, 1],
+                             [1, 2],
+                             [2, 3],
+                             [3, 4]])
+        assert_array_equal(arr_view, expected)
+
+    def test_2d(self):
+        i, j = np.ogrid[:3, :4]
+        arr = 10*i + j
+        shape = (2, 2)
+        arr_view = sliding_window_view(arr, shape)
+        expected = np.array([[[[0, 1], [10, 11]],
+                              [[1, 2], [11, 12]],
+                              [[2, 3], [12, 13]]],
+                             [[[10, 11], [20, 21]],
+                              [[11, 12], [21, 22]],
+                              [[12, 13], [22, 23]]]])
+        assert_array_equal(arr_view, expected)
+
+    def test_2d_with_axis(self):
+        i, j = np.ogrid[:3, :4]
+        arr = 10*i + j
+        arr_view = sliding_window_view(arr, 3, 0)
+        expected = np.array([[[0, 10, 20],
+                              [1, 11, 21],
+                              [2, 12, 22],
+                              [3, 13, 23]]])
+        assert_array_equal(arr_view, expected)
+
+    def test_2d_repeated_axis(self):
+        i, j = np.ogrid[:3, :4]
+        arr = 10*i + j
+        arr_view = sliding_window_view(arr, (2, 3), (1, 1))
+        expected = np.array([[[[0, 1, 2],
+                               [1, 2, 3]]],
+                             [[[10, 11, 12],
+                               [11, 12, 13]]],
+                             [[[20, 21, 22],
+                               [21, 22, 23]]]])
+        assert_array_equal(arr_view, expected)
+
+    def test_2d_without_axis(self):
+        i, j = np.ogrid[:4, :4]
+        arr = 10*i + j
+        shape = (2, 3)
+        arr_view = sliding_window_view(arr, shape)
+        expected = np.array([[[[0, 1, 2], [10, 11, 12]],
+                              [[1, 2, 3], [11, 12, 13]]],
+                             [[[10, 11, 12], [20, 21, 22]],
+                              [[11, 12, 13], [21, 22, 23]]],
+                             [[[20, 21, 22], [30, 31, 32]],
+                              [[21, 22, 23], [31, 32, 33]]]])
+        assert_array_equal(arr_view, expected)
+
+    def test_errors(self):
+        i, j = np.ogrid[:4, :4]
+        arr = 10*i + j
+        with pytest.raises(ValueError, match='cannot contain negative values'):
+            sliding_window_view(arr, (-1, 3))
+        with pytest.raises(
+                ValueError,
+                match='must provide window_shape for all dimensions of `x`'):
+            sliding_window_view(arr, (1,))
+        with pytest.raises(
+                ValueError,
+                match='Must provide matching length window_shape and axis'):
+            sliding_window_view(arr, (1, 3, 4), axis=(0, 1))
+        with pytest.raises(
+                ValueError,
+                match='window shape cannot be larger than input array'):
+            sliding_window_view(arr, (5, 5))
+
+    def test_writeable(self):
+        arr = np.arange(5)
+        view = sliding_window_view(arr, 2, writeable=False)
+        assert_(not view.flags.writeable)
+        with pytest.raises(
+                ValueError,
+                match='assignment destination is read-only'):
+            view[0, 0] = 3
+        view = sliding_window_view(arr, 2, writeable=True)
+        assert_(view.flags.writeable)
+        view[0, 1] = 3
+        assert_array_equal(arr, np.array([0, 3, 2, 3, 4]))
+
+    def test_subok(self):
+        class MyArray(np.ndarray):
+            pass
+
+        arr = np.arange(5).view(MyArray)
+        assert_(not isinstance(sliding_window_view(arr, 2,
+                                                   subok=False),
+                               MyArray))
+        assert_(isinstance(sliding_window_view(arr, 2, subok=True), MyArray))
+        # Default behavior
+        assert_(not isinstance(sliding_window_view(arr, 2), MyArray))
+
+
+def as_strided_writeable():
+    arr = np.ones(10)
+    view = as_strided(arr, writeable=False)
+    assert_(not view.flags.writeable)
+
+    # Check that writeable also is fine:
+    view = as_strided(arr, writeable=True)
+    assert_(view.flags.writeable)
+    view[...] = 3
+    assert_array_equal(arr, np.full_like(arr, 3))
+
+    # Test that things do not break down for readonly:
+    arr.flags.writeable = False
+    view = as_strided(arr, writeable=False)
+    view = as_strided(arr, writeable=True)
+    assert_(not view.flags.writeable)
+
+
+class VerySimpleSubClass(np.ndarray):
+    def __new__(cls, *args, **kwargs):
+        return np.array(*args, subok=True, **kwargs).view(cls)
+
+
+class SimpleSubClass(VerySimpleSubClass):
+    def __new__(cls, *args, **kwargs):
+        self = np.array(*args, subok=True, **kwargs).view(cls)
+        self.info = 'simple'
+        return self
+
+    def __array_finalize__(self, obj):
+        self.info = getattr(obj, 'info', '') + ' finalized'
+
+
+def test_subclasses():
+    # test that subclass is preserved only if subok=True
+    a = VerySimpleSubClass([1, 2, 3, 4])
+    assert_(type(a) is VerySimpleSubClass)
+    a_view = as_strided(a, shape=(2,), strides=(2 * a.itemsize,))
+    assert_(type(a_view) is np.ndarray)
+    a_view = as_strided(a, shape=(2,), strides=(2 * a.itemsize,), subok=True)
+    assert_(type(a_view) is VerySimpleSubClass)
+    # test that if a subclass has __array_finalize__, it is used
+    a = SimpleSubClass([1, 2, 3, 4])
+    a_view = as_strided(a, shape=(2,), strides=(2 * a.itemsize,), subok=True)
+    assert_(type(a_view) is SimpleSubClass)
+    assert_(a_view.info == 'simple finalized')
+
+    # similar tests for broadcast_arrays
+    b = np.arange(len(a)).reshape(-1, 1)
+    a_view, b_view = broadcast_arrays(a, b)
+    assert_(type(a_view) is np.ndarray)
+    assert_(type(b_view) is np.ndarray)
+    assert_(a_view.shape == b_view.shape)
+    a_view, b_view = broadcast_arrays(a, b, subok=True)
+    assert_(type(a_view) is SimpleSubClass)
+    assert_(a_view.info == 'simple finalized')
+    assert_(type(b_view) is np.ndarray)
+    assert_(a_view.shape == b_view.shape)
+
+    # and for broadcast_to
+    shape = (2, 4)
+    a_view = broadcast_to(a, shape)
+    assert_(type(a_view) is np.ndarray)
+    assert_(a_view.shape == shape)
+    a_view = broadcast_to(a, shape, subok=True)
+    assert_(type(a_view) is SimpleSubClass)
+    assert_(a_view.info == 'simple finalized')
+    assert_(a_view.shape == shape)
+
+
+def test_writeable():
+    # broadcast_to should return a readonly array
+    original = np.array([1, 2, 3])
+    result = broadcast_to(original, (2, 3))
+    assert_equal(result.flags.writeable, False)
+    assert_raises(ValueError, result.__setitem__, slice(None), 0)
+
+    # but the result of broadcast_arrays needs to be writeable, to
+    # preserve backwards compatibility
+    test_cases = [((False,), broadcast_arrays(original,)),
+                  ((True, False), broadcast_arrays(0, original))]
+    for is_broadcast, results in test_cases:
+        for array_is_broadcast, result in zip(is_broadcast, results):
+            # This will change to False in a future version
+            if array_is_broadcast:
+                with assert_warns(FutureWarning):
+                    assert_equal(result.flags.writeable, True)
+                with assert_warns(DeprecationWarning):
+                    result[:] = 0
+                # Warning not emitted, writing to the array resets it
+                assert_equal(result.flags.writeable, True)
+            else:
+                # No warning:
+                assert_equal(result.flags.writeable, True)
+
+    for results in [broadcast_arrays(original),
+                    broadcast_arrays(0, original)]:
+        for result in results:
+            # resets the warn_on_write DeprecationWarning
+            result.flags.writeable = True
+            # check: no warning emitted
+            assert_equal(result.flags.writeable, True)
+            result[:] = 0
+
+    # keep readonly input readonly
+    original.flags.writeable = False
+    _, result = broadcast_arrays(0, original)
+    assert_equal(result.flags.writeable, False)
+
+    # regression test for GH6491
+    shape = (2,)
+    strides = [0]
+    tricky_array = as_strided(np.array(0), shape, strides)
+    other = np.zeros((1,))
+    first, second = broadcast_arrays(tricky_array, other)
+    assert_(first.shape == second.shape)
+
+
+def test_writeable_memoryview():
+    # The result of broadcast_arrays exports as a non-writeable memoryview
+    # because otherwise there is no good way to opt in to the new behaviour
+    # (i.e. you would need to set writeable to False explicitly).
+    # See gh-13929.
+    original = np.array([1, 2, 3])
+
+    test_cases = [((False, ), broadcast_arrays(original,)),
+                  ((True, False), broadcast_arrays(0, original))]
+    for is_broadcast, results in test_cases:
+        for array_is_broadcast, result in zip(is_broadcast, results):
+            # This will change to False in a future version
+            if array_is_broadcast:
+                # memoryview(result, writable=True) will give warning but cannot
+                # be tested using the python API.
+                assert memoryview(result).readonly
+            else:
+                assert not memoryview(result).readonly
+
+
+def test_reference_types():
+    input_array = np.array('a', dtype=object)
+    expected = np.array(['a'] * 3, dtype=object)
+    actual = broadcast_to(input_array, (3,))
+    assert_array_equal(expected, actual)
+
+    actual, _ = broadcast_arrays(input_array, np.ones(3))
+    assert_array_equal(expected, actual)
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/tests/test_twodim_base.py b/venv/lib/python3.12/site-packages/numpy/lib/tests/test_twodim_base.py
new file mode 100644
index 00000000..eb008c60
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/lib/tests/test_twodim_base.py
@@ -0,0 +1,541 @@
+"""Test functions for matrix module
+
+"""
+from numpy.testing import (
+    assert_equal, assert_array_equal, assert_array_max_ulp,
+    assert_array_almost_equal, assert_raises, assert_
+)
+from numpy import (
+    arange, add, fliplr, flipud, zeros, ones, eye, array, diag, histogram2d,
+    tri, mask_indices, triu_indices, triu_indices_from, tril_indices,
+    tril_indices_from, vander,
+)
+import numpy as np
+
+import pytest
+
+
+def get_mat(n):
+    data = arange(n)
+    data = add.outer(data, data)
+    return data
+
+
+class TestEye:
+    def test_basic(self):
+        assert_equal(eye(4),
+                     array([[1, 0, 0, 0],
+                            [0, 1, 0, 0],
+                            [0, 0, 1, 0],
+                            [0, 0, 0, 1]]))
+
+        assert_equal(eye(4, dtype='f'),
+                     array([[1, 0, 0, 0],
+                            [0, 1, 0, 0],
+                            [0, 0, 1, 0],
+                            [0, 0, 0, 1]], 'f'))
+
+        assert_equal(eye(3) == 1,
+                     eye(3, dtype=bool))
+
+    def test_uint64(self):
+        # Regression test for gh-9982
+        assert_equal(eye(np.uint64(2), dtype=int), array([[1, 0], [0, 1]]))
+        assert_equal(eye(np.uint64(2), M=np.uint64(4), k=np.uint64(1)),
+                     array([[0, 1, 0, 0], [0, 0, 1, 0]]))
+
+    def test_diag(self):
+        assert_equal(eye(4, k=1),
+                     array([[0, 1, 0, 0],
+                            [0, 0, 1, 0],
+                            [0, 0, 0, 1],
+                            [0, 0, 0, 0]]))
+
+        assert_equal(eye(4, k=-1),
+                     array([[0, 0, 0, 0],
+                            [1, 0, 0, 0],
+                            [0, 1, 0, 0],
+                            [0, 0, 1, 0]]))
+
+    def test_2d(self):
+        assert_equal(eye(4, 3),
+                     array([[1, 0, 0],
+                            [0, 1, 0],
+                            [0, 0, 1],
+                            [0, 0, 0]]))
+
+        assert_equal(eye(3, 4),
+                     array([[1, 0, 0, 0],
+                            [0, 1, 0, 0],
+                            [0, 0, 1, 0]]))
+
+    def test_diag2d(self):
+        assert_equal(eye(3, 4, k=2),
+                     array([[0, 0, 1, 0],
+                            [0, 0, 0, 1],
+                            [0, 0, 0, 0]]))
+
+        assert_equal(eye(4, 3, k=-2),
+                     array([[0, 0, 0],
+                            [0, 0, 0],
+                            [1, 0, 0],
+                            [0, 1, 0]]))
+
+    def test_eye_bounds(self):
+        assert_equal(eye(2, 2, 1), [[0, 1], [0, 0]])
+        assert_equal(eye(2, 2, -1), [[0, 0], [1, 0]])
+        assert_equal(eye(2, 2, 2), [[0, 0], [0, 0]])
+        assert_equal(eye(2, 2, -2), [[0, 0], [0, 0]])
+        assert_equal(eye(3, 2, 2), [[0, 0], [0, 0], [0, 0]])
+        assert_equal(eye(3, 2, 1), [[0, 1], [0, 0], [0, 0]])
+        assert_equal(eye(3, 2, -1), [[0, 0], [1, 0], [0, 1]])
+        assert_equal(eye(3, 2, -2), [[0, 0], [0, 0], [1, 0]])
+        assert_equal(eye(3, 2, -3), [[0, 0], [0, 0], [0, 0]])
+
+    def test_strings(self):
+        assert_equal(eye(2, 2, dtype='S3'),
+                     [[b'1', b''], [b'', b'1']])
+
+    def test_bool(self):
+        assert_equal(eye(2, 2, dtype=bool), [[True, False], [False, True]])
+
+    def test_order(self):
+        mat_c = eye(4, 3, k=-1)
+        mat_f = eye(4, 3, k=-1, order='F')
+        assert_equal(mat_c, mat_f)
+        assert mat_c.flags.c_contiguous
+        assert not mat_c.flags.f_contiguous
+        assert not mat_f.flags.c_contiguous
+        assert mat_f.flags.f_contiguous
+
+
+class TestDiag:
+    def test_vector(self):
+        vals = (100 * arange(5)).astype('l')
+        b = zeros((5, 5))
+        for k in range(5):
+            b[k, k] = vals[k]
+        assert_equal(diag(vals), b)
+        b = zeros((7, 7))
+        c = b.copy()
+        for k in range(5):
+            b[k, k + 2] = vals[k]
+            c[k + 2, k] = vals[k]
+        assert_equal(diag(vals, k=2), b)
+        assert_equal(diag(vals, k=-2), c)
+
+    def test_matrix(self, vals=None):
+        if vals is None:
+            vals = (100 * get_mat(5) + 1).astype('l')
+        b = zeros((5,))
+        for k in range(5):
+            b[k] = vals[k, k]
+        assert_equal(diag(vals), b)
+        b = b * 0
+        for k in range(3):
+            b[k] = vals[k, k + 2]
+        assert_equal(diag(vals, 2), b[:3])
+        for k in range(3):
+            b[k] = vals[k + 2, k]
+        assert_equal(diag(vals, -2), b[:3])
+
+    def test_fortran_order(self):
+        vals = array((100 * get_mat(5) + 1), order='F', dtype='l')
+        self.test_matrix(vals)
+
+    def test_diag_bounds(self):
+        A = [[1, 2], [3, 4], [5, 6]]
+        assert_equal(diag(A, k=2), [])
+        assert_equal(diag(A, k=1), [2])
+        assert_equal(diag(A, k=0), [1, 4])
+        assert_equal(diag(A, k=-1), [3, 6])
+        assert_equal(diag(A, k=-2), [5])
+        assert_equal(diag(A, k=-3), [])
+
+    def test_failure(self):
+        assert_raises(ValueError, diag, [[[1]]])
+
+
+class TestFliplr:
+    def test_basic(self):
+        assert_raises(ValueError, fliplr, ones(4))
+        a = get_mat(4)
+        b = a[:, ::-1]
+        assert_equal(fliplr(a), b)
+        a = [[0, 1, 2],
+             [3, 4, 5]]
+        b = [[2, 1, 0],
+             [5, 4, 3]]
+        assert_equal(fliplr(a), b)
+
+
+class TestFlipud:
+    def test_basic(self):
+        a = get_mat(4)
+        b = a[::-1, :]
+        assert_equal(flipud(a), b)
+        a = [[0, 1, 2],
+             [3, 4, 5]]
+        b = [[3, 4, 5],
+             [0, 1, 2]]
+        assert_equal(flipud(a), b)
+
+
+class TestHistogram2d:
+    def test_simple(self):
+        x = array(
+            [0.41702200, 0.72032449, 1.1437481e-4, 0.302332573, 0.146755891])
+        y = array(
+            [0.09233859, 0.18626021, 0.34556073, 0.39676747, 0.53881673])
+        xedges = np.linspace(0, 1, 10)
+        yedges = np.linspace(0, 1, 10)
+        H = histogram2d(x, y, (xedges, yedges))[0]
+        answer = array(
+            [[0, 0, 0, 1, 0, 0, 0, 0, 0],
+             [0, 0, 0, 0, 0, 0, 1, 0, 0],
+             [0, 0, 0, 0, 0, 0, 0, 0, 0],
+             [1, 0, 1, 0, 0, 0, 0, 0, 0],
+             [0, 1, 0, 0, 0, 0, 0, 0, 0],
+             [0, 0, 0, 0, 0, 0, 0, 0, 0],
+             [0, 0, 0, 0, 0, 0, 0, 0, 0],
+             [0, 0, 0, 0, 0, 0, 0, 0, 0],
+             [0, 0, 0, 0, 0, 0, 0, 0, 0]])
+        assert_array_equal(H.T, answer)
+        H = histogram2d(x, y, xedges)[0]
+        assert_array_equal(H.T, answer)
+        H, xedges, yedges = histogram2d(list(range(10)), list(range(10)))
+        assert_array_equal(H, eye(10, 10))
+        assert_array_equal(xedges, np.linspace(0, 9, 11))
+        assert_array_equal(yedges, np.linspace(0, 9, 11))
+
+    def test_asym(self):
+        x = array([1, 1, 2, 3, 4, 4, 4, 5])
+        y = array([1, 3, 2, 0, 1, 2, 3, 4])
+        H, xed, yed = histogram2d(
+            x, y, (6, 5), range=[[0, 6], [0, 5]], density=True)
+        answer = array(
+            [[0., 0, 0, 0, 0],
+             [0, 1, 0, 1, 0],
+             [0, 0, 1, 0, 0],
+             [1, 0, 0, 0, 0],
+             [0, 1, 1, 1, 0],
+             [0, 0, 0, 0, 1]])
+        assert_array_almost_equal(H, answer/8., 3)
+        assert_array_equal(xed, np.linspace(0, 6, 7))
+        assert_array_equal(yed, np.linspace(0, 5, 6))
+
+    def test_density(self):
+        x = array([1, 2, 3, 1, 2, 3, 1, 2, 3])
+        y = array([1, 1, 1, 2, 2, 2, 3, 3, 3])
+        H, xed, yed = histogram2d(
+            x, y, [[1, 2, 3, 5], [1, 2, 3, 5]], density=True)
+        answer = array([[1, 1, .5],
+                        [1, 1, .5],
+                        [.5, .5, .25]])/9.
+        assert_array_almost_equal(H, answer, 3)
+
+    def test_all_outliers(self):
+        r = np.random.rand(100) + 1. + 1e6  # histogramdd rounds by decimal=6
+        H, xed, yed = histogram2d(r, r, (4, 5), range=([0, 1], [0, 1]))
+        assert_array_equal(H, 0)
+
+    def test_empty(self):
+        a, edge1, edge2 = histogram2d([], [], bins=([0, 1], [0, 1]))
+        assert_array_max_ulp(a, array([[0.]]))
+
+        a, edge1, edge2 = histogram2d([], [], bins=4)
+        assert_array_max_ulp(a, np.zeros((4, 4)))
+
+    def test_binparameter_combination(self):
+        x = array(
+            [0, 0.09207008, 0.64575234, 0.12875982, 0.47390599,
+             0.59944483, 1])
+        y = array(
+            [0, 0.14344267, 0.48988575, 0.30558665, 0.44700682,
+             0.15886423, 1])
+        edges = (0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1)
+        H, xe, ye = histogram2d(x, y, (edges, 4))
+        answer = array(
+            [[2., 0., 0., 0.],
+             [0., 1., 0., 0.],
+             [0., 0., 0., 0.],
+             [0., 0., 0., 0.],
+             [0., 1., 0., 0.],
+             [1., 0., 0., 0.],
+             [0., 1., 0., 0.],
+             [0., 0., 0., 0.],
+             [0., 0., 0., 0.],
+             [0., 0., 0., 1.]])
+        assert_array_equal(H, answer)
+        assert_array_equal(ye, array([0., 0.25, 0.5, 0.75, 1]))
+        H, xe, ye = histogram2d(x, y, (4, edges))
+        answer = array(
+            [[1., 1., 0., 1., 0., 0., 0., 0., 0., 0.],
+             [0., 0., 0., 0., 1., 0., 0., 0., 0., 0.],
+             [0., 1., 0., 0., 1., 0., 0., 0., 0., 0.],
+             [0., 0., 0., 0., 0., 0., 0., 0., 0., 1.]])
+        assert_array_equal(H, answer)
+        assert_array_equal(xe, array([0., 0.25, 0.5, 0.75, 1]))
+
+    def test_dispatch(self):
+        class ShouldDispatch:
+            def __array_function__(self, function, types, args, kwargs):
+                return types, args, kwargs
+
+        xy = [1, 2]
+        s_d = ShouldDispatch()
+        r = histogram2d(s_d, xy)
+        # Cannot use assert_equal since that dispatches...
+        assert_(r == ((ShouldDispatch,), (s_d, xy), {}))
+        r = histogram2d(xy, s_d)
+        assert_(r == ((ShouldDispatch,), (xy, s_d), {}))
+        r = histogram2d(xy, xy, bins=s_d)
+        assert_(r, ((ShouldDispatch,), (xy, xy), dict(bins=s_d)))
+        r = histogram2d(xy, xy, bins=[s_d, 5])
+        assert_(r, ((ShouldDispatch,), (xy, xy), dict(bins=[s_d, 5])))
+        assert_raises(Exception, histogram2d, xy, xy, bins=[s_d])
+        r = histogram2d(xy, xy, weights=s_d)
+        assert_(r, ((ShouldDispatch,), (xy, xy), dict(weights=s_d)))
+
+    @pytest.mark.parametrize(("x_len", "y_len"), [(10, 11), (20, 19)])
+    def test_bad_length(self, x_len, y_len):
+        x, y = np.ones(x_len), np.ones(y_len)
+        with pytest.raises(ValueError,
+                           match='x and y must have the same length.'):
+            histogram2d(x, y)
+
+
+class TestTri:
+    def test_dtype(self):
+        out = array([[1, 0, 0],
+                     [1, 1, 0],
+                     [1, 1, 1]])
+        assert_array_equal(tri(3), out)
+        assert_array_equal(tri(3, dtype=bool), out.astype(bool))
+
+
+def test_tril_triu_ndim2():
+    for dtype in np.typecodes['AllFloat'] + np.typecodes['AllInteger']:
+        a = np.ones((2, 2), dtype=dtype)
+        b = np.tril(a)
+        c = np.triu(a)
+        assert_array_equal(b, [[1, 0], [1, 1]])
+        assert_array_equal(c, b.T)
+        # should return the same dtype as the original array
+        assert_equal(b.dtype, a.dtype)
+        assert_equal(c.dtype, a.dtype)
+
+
+def test_tril_triu_ndim3():
+    for dtype in np.typecodes['AllFloat'] + np.typecodes['AllInteger']:
+        a = np.array([
+            [[1, 1], [1, 1]],
+            [[1, 1], [1, 0]],
+            [[1, 1], [0, 0]],
+            ], dtype=dtype)
+        a_tril_desired = np.array([
+            [[1, 0], [1, 1]],
+            [[1, 0], [1, 0]],
+            [[1, 0], [0, 0]],
+            ], dtype=dtype)
+        a_triu_desired = np.array([
+            [[1, 1], [0, 1]],
+            [[1, 1], [0, 0]],
+            [[1, 1], [0, 0]],
+            ], dtype=dtype)
+        a_triu_observed = np.triu(a)
+        a_tril_observed = np.tril(a)
+        assert_array_equal(a_triu_observed, a_triu_desired)
+        assert_array_equal(a_tril_observed, a_tril_desired)
+        assert_equal(a_triu_observed.dtype, a.dtype)
+        assert_equal(a_tril_observed.dtype, a.dtype)
+
+
+def test_tril_triu_with_inf():
+    # Issue 4859
+    arr = np.array([[1, 1, np.inf],
+                    [1, 1, 1],
+                    [np.inf, 1, 1]])
+    out_tril = np.array([[1, 0, 0],
+                         [1, 1, 0],
+                         [np.inf, 1, 1]])
+    out_triu = out_tril.T
+    assert_array_equal(np.triu(arr), out_triu)
+    assert_array_equal(np.tril(arr), out_tril)
+
+
+def test_tril_triu_dtype():
+    # Issue 4916
+    # tril and triu should return the same dtype as input
+    for c in np.typecodes['All']:
+        if c == 'V':
+            continue
+        arr = np.zeros((3, 3), dtype=c)
+        assert_equal(np.triu(arr).dtype, arr.dtype)
+        assert_equal(np.tril(arr).dtype, arr.dtype)
+
+    # check special cases
+    arr = np.array([['2001-01-01T12:00', '2002-02-03T13:56'],
+                    ['2004-01-01T12:00', '2003-01-03T13:45']],
+                   dtype='datetime64')
+    assert_equal(np.triu(arr).dtype, arr.dtype)
+    assert_equal(np.tril(arr).dtype, arr.dtype)
+
+    arr = np.zeros((3, 3), dtype='f4,f4')
+    assert_equal(np.triu(arr).dtype, arr.dtype)
+    assert_equal(np.tril(arr).dtype, arr.dtype)
+
+
+def test_mask_indices():
+    # simple test without offset
+    iu = mask_indices(3, np.triu)
+    a = np.arange(9).reshape(3, 3)
+    assert_array_equal(a[iu], array([0, 1, 2, 4, 5, 8]))
+    # Now with an offset
+    iu1 = mask_indices(3, np.triu, 1)
+    assert_array_equal(a[iu1], array([1, 2, 5]))
+
+
+def test_tril_indices():
+    # indices without and with offset
+    il1 = tril_indices(4)
+    il2 = tril_indices(4, k=2)
+    il3 = tril_indices(4, m=5)
+    il4 = tril_indices(4, k=2, m=5)
+
+    a = np.array([[1, 2, 3, 4],
+                  [5, 6, 7, 8],
+                  [9, 10, 11, 12],
+                  [13, 14, 15, 16]])
+    b = np.arange(1, 21).reshape(4, 5)
+
+    # indexing:
+    assert_array_equal(a[il1],
+                       array([1, 5, 6, 9, 10, 11, 13, 14, 15, 16]))
+    assert_array_equal(b[il3],
+                       array([1, 6, 7, 11, 12, 13, 16, 17, 18, 19]))
+
+    # And for assigning values:
+    a[il1] = -1
+    assert_array_equal(a,
+                       array([[-1, 2, 3, 4],
+                              [-1, -1, 7, 8],
+                              [-1, -1, -1, 12],
+                              [-1, -1, -1, -1]]))
+    b[il3] = -1
+    assert_array_equal(b,
+                       array([[-1, 2, 3, 4, 5],
+                              [-1, -1, 8, 9, 10],
+                              [-1, -1, -1, 14, 15],
+                              [-1, -1, -1, -1, 20]]))
+    # These cover almost the whole array (two diagonals right of the main one):
+    a[il2] = -10
+    assert_array_equal(a,
+                       array([[-10, -10, -10, 4],
+                              [-10, -10, -10, -10],
+                              [-10, -10, -10, -10],
+                              [-10, -10, -10, -10]]))
+    b[il4] = -10
+    assert_array_equal(b,
+                       array([[-10, -10, -10, 4, 5],
+                              [-10, -10, -10, -10, 10],
+                              [-10, -10, -10, -10, -10],
+                              [-10, -10, -10, -10, -10]]))
+
+
+class TestTriuIndices:
+    def test_triu_indices(self):
+        iu1 = triu_indices(4)
+        iu2 = triu_indices(4, k=2)
+        iu3 = triu_indices(4, m=5)
+        iu4 = triu_indices(4, k=2, m=5)
+
+        a = np.array([[1, 2, 3, 4],
+                      [5, 6, 7, 8],
+                      [9, 10, 11, 12],
+                      [13, 14, 15, 16]])
+        b = np.arange(1, 21).reshape(4, 5)
+
+        # Both for indexing:
+        assert_array_equal(a[iu1],
+                           array([1, 2, 3, 4, 6, 7, 8, 11, 12, 16]))
+        assert_array_equal(b[iu3],
+                           array([1, 2, 3, 4, 5, 7, 8, 9,
+                                  10, 13, 14, 15, 19, 20]))
+
+        # And for assigning values:
+        a[iu1] = -1
+        assert_array_equal(a,
+                           array([[-1, -1, -1, -1],
+                                  [5, -1, -1, -1],
+                                  [9, 10, -1, -1],
+                                  [13, 14, 15, -1]]))
+        b[iu3] = -1
+        assert_array_equal(b,
+                           array([[-1, -1, -1, -1, -1],
+                                  [6, -1, -1, -1, -1],
+                                  [11, 12, -1, -1, -1],
+                                  [16, 17, 18, -1, -1]]))
+
+        # These cover almost the whole array (two diagonals right of the
+        # main one):
+        a[iu2] = -10
+        assert_array_equal(a,
+                           array([[-1, -1, -10, -10],
+                                  [5, -1, -1, -10],
+                                  [9, 10, -1, -1],
+                                  [13, 14, 15, -1]]))
+        b[iu4] = -10
+        assert_array_equal(b,
+                           array([[-1, -1, -10, -10, -10],
+                                  [6, -1, -1, -10, -10],
+                                  [11, 12, -1, -1, -10],
+                                  [16, 17, 18, -1, -1]]))
+
+
+class TestTrilIndicesFrom:
+    def test_exceptions(self):
+        assert_raises(ValueError, tril_indices_from, np.ones((2,)))
+        assert_raises(ValueError, tril_indices_from, np.ones((2, 2, 2)))
+        # assert_raises(ValueError, tril_indices_from, np.ones((2, 3)))
+
+
+class TestTriuIndicesFrom:
+    def test_exceptions(self):
+        assert_raises(ValueError, triu_indices_from, np.ones((2,)))
+        assert_raises(ValueError, triu_indices_from, np.ones((2, 2, 2)))
+        # assert_raises(ValueError, triu_indices_from, np.ones((2, 3)))
+
+
+class TestVander:
+    def test_basic(self):
+        c = np.array([0, 1, -2, 3])
+        v = vander(c)
+        powers = np.array([[0, 0, 0, 0, 1],
+                           [1, 1, 1, 1, 1],
+                           [16, -8, 4, -2, 1],
+                           [81, 27, 9, 3, 1]])
+        # Check default value of N:
+        assert_array_equal(v, powers[:, 1:])
+        # Check a range of N values, including 0 and 5 (greater than default)
+        m = powers.shape[1]
+        for n in range(6):
+            v = vander(c, N=n)
+            assert_array_equal(v, powers[:, m-n:m])
+
+    def test_dtypes(self):
+        c = array([11, -12, 13], dtype=np.int8)
+        v = vander(c)
+        expected = np.array([[121, 11, 1],
+                             [144, -12, 1],
+                             [169, 13, 1]])
+        assert_array_equal(v, expected)
+
+        c = array([1.0+1j, 1.0-1j])
+        v = vander(c, N=3)
+        expected = np.array([[2j, 1+1j, 1],
+                             [-2j, 1-1j, 1]])
+        # The data is floating point, but the values are small integers,
+        # so assert_array_equal *should* be safe here (rather than, say,
+        # assert_array_almost_equal).
+        assert_array_equal(v, expected)
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/tests/test_type_check.py b/venv/lib/python3.12/site-packages/numpy/lib/tests/test_type_check.py
new file mode 100644
index 00000000..e8e11c42
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/lib/tests/test_type_check.py
@@ -0,0 +1,465 @@
+import numpy as np
+from numpy import (
+    common_type, mintypecode, isreal, iscomplex, isposinf, isneginf,
+    nan_to_num, isrealobj, iscomplexobj, real_if_close
+    )
+from numpy.testing import (
+    assert_, assert_equal, assert_array_equal, assert_raises
+    )
+
+
+def assert_all(x):
+    assert_(np.all(x), x)
+
+
+class TestCommonType:
+    def test_basic(self):
+        ai32 = np.array([[1, 2], [3, 4]], dtype=np.int32)
+        af16 = np.array([[1, 2], [3, 4]], dtype=np.float16)
+        af32 = np.array([[1, 2], [3, 4]], dtype=np.float32)
+        af64 = np.array([[1, 2], [3, 4]], dtype=np.float64)
+        acs = np.array([[1+5j, 2+6j], [3+7j, 4+8j]], dtype=np.complex64)
+        acd = np.array([[1+5j, 2+6j], [3+7j, 4+8j]], dtype=np.complex128)
+        assert_(common_type(ai32) == np.float64)
+        assert_(common_type(af16) == np.float16)
+        assert_(common_type(af32) == np.float32)
+        assert_(common_type(af64) == np.float64)
+        assert_(common_type(acs) == np.complex64)
+        assert_(common_type(acd) == np.complex128)
+
+
+class TestMintypecode:
+
+    def test_default_1(self):
+        for itype in '1bcsuwil':
+            assert_equal(mintypecode(itype), 'd')
+        assert_equal(mintypecode('f'), 'f')
+        assert_equal(mintypecode('d'), 'd')
+        assert_equal(mintypecode('F'), 'F')
+        assert_equal(mintypecode('D'), 'D')
+
+    def test_default_2(self):
+        for itype in '1bcsuwil':
+            assert_equal(mintypecode(itype+'f'), 'f')
+            assert_equal(mintypecode(itype+'d'), 'd')
+            assert_equal(mintypecode(itype+'F'), 'F')
+            assert_equal(mintypecode(itype+'D'), 'D')
+        assert_equal(mintypecode('ff'), 'f')
+        assert_equal(mintypecode('fd'), 'd')
+        assert_equal(mintypecode('fF'), 'F')
+        assert_equal(mintypecode('fD'), 'D')
+        assert_equal(mintypecode('df'), 'd')
+        assert_equal(mintypecode('dd'), 'd')
+        #assert_equal(mintypecode('dF',savespace=1),'F')
+        assert_equal(mintypecode('dF'), 'D')
+        assert_equal(mintypecode('dD'), 'D')
+        assert_equal(mintypecode('Ff'), 'F')
+        #assert_equal(mintypecode('Fd',savespace=1),'F')
+        assert_equal(mintypecode('Fd'), 'D')
+        assert_equal(mintypecode('FF'), 'F')
+        assert_equal(mintypecode('FD'), 'D')
+        assert_equal(mintypecode('Df'), 'D')
+        assert_equal(mintypecode('Dd'), 'D')
+        assert_equal(mintypecode('DF'), 'D')
+        assert_equal(mintypecode('DD'), 'D')
+
+    def test_default_3(self):
+        assert_equal(mintypecode('fdF'), 'D')
+        #assert_equal(mintypecode('fdF',savespace=1),'F')
+        assert_equal(mintypecode('fdD'), 'D')
+        assert_equal(mintypecode('fFD'), 'D')
+        assert_equal(mintypecode('dFD'), 'D')
+
+        assert_equal(mintypecode('ifd'), 'd')
+        assert_equal(mintypecode('ifF'), 'F')
+        assert_equal(mintypecode('ifD'), 'D')
+        assert_equal(mintypecode('idF'), 'D')
+        #assert_equal(mintypecode('idF',savespace=1),'F')
+        assert_equal(mintypecode('idD'), 'D')
+
+
+class TestIsscalar:
+
+    def test_basic(self):
+        assert_(np.isscalar(3))
+        assert_(not np.isscalar([3]))
+        assert_(not np.isscalar((3,)))
+        assert_(np.isscalar(3j))
+        assert_(np.isscalar(4.0))
+
+
+class TestReal:
+
+    def test_real(self):
+        y = np.random.rand(10,)
+        assert_array_equal(y, np.real(y))
+
+        y = np.array(1)
+        out = np.real(y)
+        assert_array_equal(y, out)
+        assert_(isinstance(out, np.ndarray))
+
+        y = 1
+        out = np.real(y)
+        assert_equal(y, out)
+        assert_(not isinstance(out, np.ndarray))
+
+    def test_cmplx(self):
+        y = np.random.rand(10,)+1j*np.random.rand(10,)
+        assert_array_equal(y.real, np.real(y))
+
+        y = np.array(1 + 1j)
+        out = np.real(y)
+        assert_array_equal(y.real, out)
+        assert_(isinstance(out, np.ndarray))
+
+        y = 1 + 1j
+        out = np.real(y)
+        assert_equal(1.0, out)
+        assert_(not isinstance(out, np.ndarray))
+
+
+class TestImag:
+
+    def test_real(self):
+        y = np.random.rand(10,)
+        assert_array_equal(0, np.imag(y))
+
+        y = np.array(1)
+        out = np.imag(y)
+        assert_array_equal(0, out)
+        assert_(isinstance(out, np.ndarray))
+
+        y = 1
+        out = np.imag(y)
+        assert_equal(0, out)
+        assert_(not isinstance(out, np.ndarray))
+
+    def test_cmplx(self):
+        y = np.random.rand(10,)+1j*np.random.rand(10,)
+        assert_array_equal(y.imag, np.imag(y))
+
+        y = np.array(1 + 1j)
+        out = np.imag(y)
+        assert_array_equal(y.imag, out)
+        assert_(isinstance(out, np.ndarray))
+
+        y = 1 + 1j
+        out = np.imag(y)
+        assert_equal(1.0, out)
+        assert_(not isinstance(out, np.ndarray))
+
+
+class TestIscomplex:
+
+    def test_fail(self):
+        z = np.array([-1, 0, 1])
+        res = iscomplex(z)
+        assert_(not np.any(res, axis=0))
+
+    def test_pass(self):
+        z = np.array([-1j, 1, 0])
+        res = iscomplex(z)
+        assert_array_equal(res, [1, 0, 0])
+
+
+class TestIsreal:
+
+    def test_pass(self):
+        z = np.array([-1, 0, 1j])
+        res = isreal(z)
+        assert_array_equal(res, [1, 1, 0])
+
+    def test_fail(self):
+        z = np.array([-1j, 1, 0])
+        res = isreal(z)
+        assert_array_equal(res, [0, 1, 1])
+
+
+class TestIscomplexobj:
+
+    def test_basic(self):
+        z = np.array([-1, 0, 1])
+        assert_(not iscomplexobj(z))
+        z = np.array([-1j, 0, -1])
+        assert_(iscomplexobj(z))
+
+    def test_scalar(self):
+        assert_(not iscomplexobj(1.0))
+        assert_(iscomplexobj(1+0j))
+
+    def test_list(self):
+        assert_(iscomplexobj([3, 1+0j, True]))
+        assert_(not iscomplexobj([3, 1, True]))
+
+    def test_duck(self):
+        class DummyComplexArray:
+            @property
+            def dtype(self):
+                return np.dtype(complex)
+        dummy = DummyComplexArray()
+        assert_(iscomplexobj(dummy))
+
+    def test_pandas_duck(self):
+        # This tests a custom np.dtype duck-typed class, such as used by pandas
+        # (pandas.core.dtypes)
+        class PdComplex(np.complex128):
+            pass
+        class PdDtype:
+            name = 'category'
+            names = None
+            type = PdComplex
+            kind = 'c'
+            str = ' 1e10) and assert_all(np.isfinite(vals[2]))
+        assert_equal(type(vals), np.ndarray)
+        
+        # perform the same tests but with nan, posinf and neginf keywords
+        with np.errstate(divide='ignore', invalid='ignore'):
+            vals = nan_to_num(np.array((-1., 0, 1))/0., 
+                              nan=10, posinf=20, neginf=30)
+        assert_equal(vals, [30, 10, 20])
+        assert_all(np.isfinite(vals[[0, 2]]))
+        assert_equal(type(vals), np.ndarray)
+
+        # perform the same test but in-place
+        with np.errstate(divide='ignore', invalid='ignore'):
+            vals = np.array((-1., 0, 1))/0.
+        result = nan_to_num(vals, copy=False)
+
+        assert_(result is vals)
+        assert_all(vals[0] < -1e10) and assert_all(np.isfinite(vals[0]))
+        assert_(vals[1] == 0)
+        assert_all(vals[2] > 1e10) and assert_all(np.isfinite(vals[2]))
+        assert_equal(type(vals), np.ndarray)
+        
+        # perform the same test but in-place
+        with np.errstate(divide='ignore', invalid='ignore'):
+            vals = np.array((-1., 0, 1))/0.
+        result = nan_to_num(vals, copy=False, nan=10, posinf=20, neginf=30)
+
+        assert_(result is vals)
+        assert_equal(vals, [30, 10, 20])
+        assert_all(np.isfinite(vals[[0, 2]]))
+        assert_equal(type(vals), np.ndarray)
+
+    def test_array(self):
+        vals = nan_to_num([1])
+        assert_array_equal(vals, np.array([1], int))
+        assert_equal(type(vals), np.ndarray)
+        vals = nan_to_num([1], nan=10, posinf=20, neginf=30)
+        assert_array_equal(vals, np.array([1], int))
+        assert_equal(type(vals), np.ndarray)
+
+    def test_integer(self):
+        vals = nan_to_num(1)
+        assert_all(vals == 1)
+        assert_equal(type(vals), np.int_)
+        vals = nan_to_num(1, nan=10, posinf=20, neginf=30)
+        assert_all(vals == 1)
+        assert_equal(type(vals), np.int_)
+
+    def test_float(self):
+        vals = nan_to_num(1.0)
+        assert_all(vals == 1.0)
+        assert_equal(type(vals), np.float64)
+        vals = nan_to_num(1.1, nan=10, posinf=20, neginf=30)
+        assert_all(vals == 1.1)
+        assert_equal(type(vals), np.float64)
+
+    def test_complex_good(self):
+        vals = nan_to_num(1+1j)
+        assert_all(vals == 1+1j)
+        assert_equal(type(vals), np.complex128)
+        vals = nan_to_num(1+1j, nan=10, posinf=20, neginf=30)
+        assert_all(vals == 1+1j)
+        assert_equal(type(vals), np.complex128)
+
+    def test_complex_bad(self):
+        with np.errstate(divide='ignore', invalid='ignore'):
+            v = 1 + 1j
+            v += np.array(0+1.j)/0.
+        vals = nan_to_num(v)
+        # !! This is actually (unexpectedly) zero
+        assert_all(np.isfinite(vals))
+        assert_equal(type(vals), np.complex128)
+
+    def test_complex_bad2(self):
+        with np.errstate(divide='ignore', invalid='ignore'):
+            v = 1 + 1j
+            v += np.array(-1+1.j)/0.
+        vals = nan_to_num(v)
+        assert_all(np.isfinite(vals))
+        assert_equal(type(vals), np.complex128)
+        # Fixme
+        #assert_all(vals.imag > 1e10)  and assert_all(np.isfinite(vals))
+        # !! This is actually (unexpectedly) positive
+        # !! inf.  Comment out for now, and see if it
+        # !! changes
+        #assert_all(vals.real < -1e10) and assert_all(np.isfinite(vals))
+    
+    def test_do_not_rewrite_previous_keyword(self):
+        # This is done to test that when, for instance, nan=np.inf then these 
+        # values are not rewritten by posinf keyword to the posinf value.
+        with np.errstate(divide='ignore', invalid='ignore'):
+            vals = nan_to_num(np.array((-1., 0, 1))/0., nan=np.inf, posinf=999)
+        assert_all(np.isfinite(vals[[0, 2]]))
+        assert_all(vals[0] < -1e10)
+        assert_equal(vals[[1, 2]], [np.inf, 999])
+        assert_equal(type(vals), np.ndarray)
+
+
+class TestRealIfClose:
+
+    def test_basic(self):
+        a = np.random.rand(10)
+        b = real_if_close(a+1e-15j)
+        assert_all(isrealobj(b))
+        assert_array_equal(a, b)
+        b = real_if_close(a+1e-7j)
+        assert_all(iscomplexobj(b))
+        b = real_if_close(a+1e-7j, tol=1e-6)
+        assert_all(isrealobj(b))
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/tests/test_ufunclike.py b/venv/lib/python3.12/site-packages/numpy/lib/tests/test_ufunclike.py
new file mode 100644
index 00000000..4b5d1101
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/lib/tests/test_ufunclike.py
@@ -0,0 +1,100 @@
+import numpy as np
+
+from numpy import fix, isposinf, isneginf
+from numpy.testing import (
+    assert_, assert_equal, assert_array_equal, assert_raises
+)
+
+
+class TestUfunclike:
+
+    def test_isposinf(self):
+        a = np.array([np.inf, -np.inf, np.nan, 0.0, 3.0, -3.0])
+        out = np.zeros(a.shape, bool)
+        tgt = np.array([True, False, False, False, False, False])
+
+        res = isposinf(a)
+        assert_equal(res, tgt)
+        res = isposinf(a, out)
+        assert_equal(res, tgt)
+        assert_equal(out, tgt)
+
+        a = a.astype(np.complex128)
+        with assert_raises(TypeError):
+            isposinf(a)
+
+    def test_isneginf(self):
+        a = np.array([np.inf, -np.inf, np.nan, 0.0, 3.0, -3.0])
+        out = np.zeros(a.shape, bool)
+        tgt = np.array([False, True, False, False, False, False])
+
+        res = isneginf(a)
+        assert_equal(res, tgt)
+        res = isneginf(a, out)
+        assert_equal(res, tgt)
+        assert_equal(out, tgt)
+
+        a = a.astype(np.complex128)
+        with assert_raises(TypeError):
+            isneginf(a)
+
+    def test_fix(self):
+        a = np.array([[1.0, 1.1, 1.5, 1.8], [-1.0, -1.1, -1.5, -1.8]])
+        out = np.zeros(a.shape, float)
+        tgt = np.array([[1., 1., 1., 1.], [-1., -1., -1., -1.]])
+
+        res = fix(a)
+        assert_equal(res, tgt)
+        res = fix(a, out)
+        assert_equal(res, tgt)
+        assert_equal(out, tgt)
+        assert_equal(fix(3.14), 3)
+
+    def test_fix_with_subclass(self):
+        class MyArray(np.ndarray):
+            def __new__(cls, data, metadata=None):
+                res = np.array(data, copy=True).view(cls)
+                res.metadata = metadata
+                return res
+
+            def __array_wrap__(self, obj, context=None, return_scalar=False):
+                if not isinstance(obj, MyArray):
+                    obj = obj.view(MyArray)
+                if obj.metadata is None:
+                    obj.metadata = self.metadata
+                return obj
+
+            def __array_finalize__(self, obj):
+                self.metadata = getattr(obj, 'metadata', None)
+                return self
+
+        a = np.array([1.1, -1.1])
+        m = MyArray(a, metadata='foo')
+        f = fix(m)
+        assert_array_equal(f, np.array([1, -1]))
+        assert_(isinstance(f, MyArray))
+        assert_equal(f.metadata, 'foo')
+
+        # check 0d arrays don't decay to scalars
+        m0d = m[0,...]
+        m0d.metadata = 'bar'
+        f0d = fix(m0d)
+        assert_(isinstance(f0d, MyArray))
+        assert_equal(f0d.metadata, 'bar')
+
+    def test_scalar(self):
+        x = np.inf
+        actual = np.isposinf(x)
+        expected = np.True_
+        assert_equal(actual, expected)
+        assert_equal(type(actual), type(expected))
+
+        x = -3.4
+        actual = np.fix(x)
+        expected = np.float64(-3.0)
+        assert_equal(actual, expected)
+        assert_equal(type(actual), type(expected))
+
+        out = np.array(0.0)
+        actual = np.fix(x, out=out)
+        assert_(actual is out)
diff --git a/venv/lib/python3.12/site-packages/numpy/lib/tests/test_utils.py b/venv/lib/python3.12/site-packages/numpy/lib/tests/test_utils.py
new file mode 100644
index 00000000..644912d9
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/lib/tests/test_utils.py
@@ -0,0 +1,80 @@
+import pytest
+
+import numpy as np
+from numpy.testing import assert_raises_regex
+import numpy.lib._utils_impl as _utils_impl
+
+from io import StringIO
+
+
+def test_assert_raises_regex_context_manager():
+    with assert_raises_regex(ValueError, 'no deprecation warning'):
+        raise ValueError('no deprecation warning')
+
+
+def test_info_method_heading():
+    # info(class) should only print "Methods:" heading if methods exist
+
+    class NoPublicMethods:
+        pass
+
+    class WithPublicMethods:
+        def first_method():
+            pass
+
+    def _has_method_heading(cls):
+        out = StringIO()
+        np.info(cls, output=out)
+        return 'Methods:' in out.getvalue()
+
+    assert _has_method_heading(WithPublicMethods)
+    assert not _has_method_heading(NoPublicMethods)
+
+
+def test_drop_metadata():
+    def _compare_dtypes(dt1, dt2):
+        return np.can_cast(dt1, dt2, casting='no')
+
+    # structured dtype
+    dt = np.dtype([('l1', [('l2', np.dtype('S8', metadata={'msg': 'toto'}))])],
+                  metadata={'msg': 'titi'})
+    dt_m = _utils_impl.drop_metadata(dt)
+    assert _compare_dtypes(dt, dt_m) is True
+    assert dt_m.metadata is None
+    assert dt_m['l1'].metadata is None
+    assert dt_m['l1']['l2'].metadata is None
+
+    # alignment
+    dt = np.dtype([('x', '>> from numpy import linalg as LA
+    >>> LA.inv(np.zeros((2,2)))
+    Traceback (most recent call last):
+      File "", line 1, in 
+      File "...linalg.py", line 350,
+        in inv return wrap(solve(a, identity(a.shape[0], dtype=a.dtype)))
+      File "...linalg.py", line 249,
+        in solve
+        raise LinAlgError('Singular matrix')
+    numpy.linalg.LinAlgError: Singular matrix
+
+    """
+
+
+def _raise_linalgerror_singular(err, flag):
+    raise LinAlgError("Singular matrix")
+
+def _raise_linalgerror_nonposdef(err, flag):
+    raise LinAlgError("Matrix is not positive definite")
+
+def _raise_linalgerror_eigenvalues_nonconvergence(err, flag):
+    raise LinAlgError("Eigenvalues did not converge")
+
+def _raise_linalgerror_svd_nonconvergence(err, flag):
+    raise LinAlgError("SVD did not converge")
+
+def _raise_linalgerror_lstsq(err, flag):
+    raise LinAlgError("SVD did not converge in Linear Least Squares")
+
+def _raise_linalgerror_qr(err, flag):
+    raise LinAlgError("Incorrect argument found while performing "
+                      "QR factorization")
+
+
+def _makearray(a):
+    new = asarray(a)
+    wrap = getattr(a, "__array_wrap__", new.__array_wrap__)
+    return new, wrap
+
+def isComplexType(t):
+    return issubclass(t, complexfloating)
+
+
+_real_types_map = {single: single,
+                   double: double,
+                   csingle: single,
+                   cdouble: double}
+
+_complex_types_map = {single: csingle,
+                      double: cdouble,
+                      csingle: csingle,
+                      cdouble: cdouble}
+
+def _realType(t, default=double):
+    return _real_types_map.get(t, default)
+
+def _complexType(t, default=cdouble):
+    return _complex_types_map.get(t, default)
+
+def _commonType(*arrays):
+    # in lite version, use higher precision (always double or cdouble)
+    result_type = single
+    is_complex = False
+    for a in arrays:
+        type_ = a.dtype.type
+        if issubclass(type_, inexact):
+            if isComplexType(type_):
+                is_complex = True
+            rt = _realType(type_, default=None)
+            if rt is double:
+                result_type = double
+            elif rt is None:
+                # unsupported inexact scalar
+                raise TypeError("array type %s is unsupported in linalg" %
+                        (a.dtype.name,))
+        else:
+            result_type = double
+    if is_complex:
+        result_type = _complex_types_map[result_type]
+        return cdouble, result_type
+    else:
+        return double, result_type
+
+
+def _to_native_byte_order(*arrays):
+    ret = []
+    for arr in arrays:
+        if arr.dtype.byteorder not in ('=', '|'):
+            ret.append(asarray(arr, dtype=arr.dtype.newbyteorder('=')))
+        else:
+            ret.append(arr)
+    if len(ret) == 1:
+        return ret[0]
+    else:
+        return ret
+
+
+def _assert_2d(*arrays):
+    for a in arrays:
+        if a.ndim != 2:
+            raise LinAlgError('%d-dimensional array given. Array must be '
+                    'two-dimensional' % a.ndim)
+
+def _assert_stacked_2d(*arrays):
+    for a in arrays:
+        if a.ndim < 2:
+            raise LinAlgError('%d-dimensional array given. Array must be '
+                    'at least two-dimensional' % a.ndim)
+
+def _assert_stacked_square(*arrays):
+    for a in arrays:
+        m, n = a.shape[-2:]
+        if m != n:
+            raise LinAlgError('Last 2 dimensions of the array must be square')
+
+def _assert_finite(*arrays):
+    for a in arrays:
+        if not isfinite(a).all():
+            raise LinAlgError("Array must not contain infs or NaNs")
+
+def _is_empty_2d(arr):
+    # check size first for efficiency
+    return arr.size == 0 and prod(arr.shape[-2:]) == 0
+
+
+def transpose(a):
+    """
+    Transpose each matrix in a stack of matrices.
+
+    Unlike np.transpose, this only swaps the last two axes, rather than all of
+    them
+
+    Parameters
+    ----------
+    a : (...,M,N) array_like
+
+    Returns
+    -------
+    aT : (...,N,M) ndarray
+    """
+    return swapaxes(a, -1, -2)
+
+# Linear equations
+
+def _tensorsolve_dispatcher(a, b, axes=None):
+    return (a, b)
+
+
+@array_function_dispatch(_tensorsolve_dispatcher)
+def tensorsolve(a, b, axes=None):
+    """
+    Solve the tensor equation ``a x = b`` for x.
+
+    It is assumed that all indices of `x` are summed over in the product,
+    together with the rightmost indices of `a`, as is done in, for example,
+    ``tensordot(a, x, axes=x.ndim)``.
+
+    Parameters
+    ----------
+    a : array_like
+        Coefficient tensor, of shape ``b.shape + Q``. `Q`, a tuple, equals
+        the shape of that sub-tensor of `a` consisting of the appropriate
+        number of its rightmost indices, and must be such that
+        ``prod(Q) == prod(b.shape)`` (in which sense `a` is said to be
+        'square').
+    b : array_like
+        Right-hand tensor, which can be of any shape.
+    axes : tuple of ints, optional
+        Axes in `a` to reorder to the right, before inversion.
+        If None (default), no reordering is done.
+
+    Returns
+    -------
+    x : ndarray, shape Q
+
+    Raises
+    ------
+    LinAlgError
+        If `a` is singular or not 'square' (in the above sense).
+
+    See Also
+    --------
+    numpy.tensordot, tensorinv, numpy.einsum
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> a = np.eye(2*3*4)
+    >>> a.shape = (2*3, 4, 2, 3, 4)
+    >>> rng = np.random.default_rng()
+    >>> b = rng.normal(size=(2*3, 4))
+    >>> x = np.linalg.tensorsolve(a, b)
+    >>> x.shape
+    (2, 3, 4)
+    >>> np.allclose(np.tensordot(a, x, axes=3), b)
+    True
+
+    """
+    a, wrap = _makearray(a)
+    b = asarray(b)
+    an = a.ndim
+
+    if axes is not None:
+        allaxes = list(range(0, an))
+        for k in axes:
+            allaxes.remove(k)
+            allaxes.insert(an, k)
+        a = a.transpose(allaxes)
+
+    oldshape = a.shape[-(an-b.ndim):]
+    prod = 1
+    for k in oldshape:
+        prod *= k
+
+    if a.size != prod ** 2:
+        raise LinAlgError(
+            "Input arrays must satisfy the requirement \
+            prod(a.shape[b.ndim:]) == prod(a.shape[:b.ndim])"
+        )
+
+    a = a.reshape(prod, prod)
+    b = b.ravel()
+    res = wrap(solve(a, b))
+    res.shape = oldshape
+    return res
+
+
+def _solve_dispatcher(a, b):
+    return (a, b)
+
+
+@array_function_dispatch(_solve_dispatcher)
+def solve(a, b):
+    """
+    Solve a linear matrix equation, or system of linear scalar equations.
+
+    Computes the "exact" solution, `x`, of the well-determined, i.e., full
+    rank, linear matrix equation `ax = b`.
+
+    Parameters
+    ----------
+    a : (..., M, M) array_like
+        Coefficient matrix.
+    b : {(M,), (..., M, K)}, array_like
+        Ordinate or "dependent variable" values.
+
+    Returns
+    -------
+    x : {(..., M,), (..., M, K)} ndarray
+        Solution to the system a x = b.  Returned shape is (..., M) if b is
+        shape (M,) and (..., M, K) if b is (..., M, K), where the "..." part is
+        broadcasted between a and b.
+
+    Raises
+    ------
+    LinAlgError
+        If `a` is singular or not square.
+
+    See Also
+    --------
+    scipy.linalg.solve : Similar function in SciPy.
+
+    Notes
+    -----
+
+    .. versionadded:: 1.8.0
+
+    Broadcasting rules apply, see the `numpy.linalg` documentation for
+    details.
+
+    The solutions are computed using LAPACK routine ``_gesv``.
+
+    `a` must be square and of full-rank, i.e., all rows (or, equivalently,
+    columns) must be linearly independent; if either is not true, use
+    `lstsq` for the least-squares best "solution" of the
+    system/equation.
+
+    .. versionchanged:: 2.0
+
+       The b array is only treated as a shape (M,) column vector if it is
+       exactly 1-dimensional. In all other instances it is treated as a stack
+       of (M, K) matrices. Previously b would be treated as a stack of (M,)
+       vectors if b.ndim was equal to a.ndim - 1.
+
+    References
+    ----------
+    .. [1] G. Strang, *Linear Algebra and Its Applications*, 2nd Ed., Orlando,
+           FL, Academic Press, Inc., 1980, pg. 22.
+
+    Examples
+    --------
+    Solve the system of equations:
+    ``x0 + 2 * x1 = 1`` and
+    ``3 * x0 + 5 * x1 = 2``:
+
+    >>> import numpy as np
+    >>> a = np.array([[1, 2], [3, 5]])
+    >>> b = np.array([1, 2])
+    >>> x = np.linalg.solve(a, b)
+    >>> x
+    array([-1.,  1.])
+
+    Check that the solution is correct:
+
+    >>> np.allclose(np.dot(a, x), b)
+    True
+
+    """
+    a, _ = _makearray(a)
+    _assert_stacked_2d(a)
+    _assert_stacked_square(a)
+    b, wrap = _makearray(b)
+    t, result_t = _commonType(a, b)
+
+    # We use the b = (..., M,) logic, only if the number of extra dimensions
+    # match exactly
+    if b.ndim == 1:
+        gufunc = _umath_linalg.solve1
+    else:
+        gufunc = _umath_linalg.solve
+
+    signature = 'DD->D' if isComplexType(t) else 'dd->d'
+    with errstate(call=_raise_linalgerror_singular, invalid='call',
+                  over='ignore', divide='ignore', under='ignore'):
+        r = gufunc(a, b, signature=signature)
+
+    return wrap(r.astype(result_t, copy=False))
+
+
+def _tensorinv_dispatcher(a, ind=None):
+    return (a,)
+
+
+@array_function_dispatch(_tensorinv_dispatcher)
+def tensorinv(a, ind=2):
+    """
+    Compute the 'inverse' of an N-dimensional array.
+
+    The result is an inverse for `a` relative to the tensordot operation
+    ``tensordot(a, b, ind)``, i. e., up to floating-point accuracy,
+    ``tensordot(tensorinv(a), a, ind)`` is the "identity" tensor for the
+    tensordot operation.
+
+    Parameters
+    ----------
+    a : array_like
+        Tensor to 'invert'. Its shape must be 'square', i. e.,
+        ``prod(a.shape[:ind]) == prod(a.shape[ind:])``.
+    ind : int, optional
+        Number of first indices that are involved in the inverse sum.
+        Must be a positive integer, default is 2.
+
+    Returns
+    -------
+    b : ndarray
+        `a`'s tensordot inverse, shape ``a.shape[ind:] + a.shape[:ind]``.
+
+    Raises
+    ------
+    LinAlgError
+        If `a` is singular or not 'square' (in the above sense).
+
+    See Also
+    --------
+    numpy.tensordot, tensorsolve
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> a = np.eye(4*6)
+    >>> a.shape = (4, 6, 8, 3)
+    >>> ainv = np.linalg.tensorinv(a, ind=2)
+    >>> ainv.shape
+    (8, 3, 4, 6)
+    >>> rng = np.random.default_rng()
+    >>> b = rng.normal(size=(4, 6))
+    >>> np.allclose(np.tensordot(ainv, b), np.linalg.tensorsolve(a, b))
+    True
+
+    >>> a = np.eye(4*6)
+    >>> a.shape = (24, 8, 3)
+    >>> ainv = np.linalg.tensorinv(a, ind=1)
+    >>> ainv.shape
+    (8, 3, 24)
+    >>> rng = np.random.default_rng()
+    >>> b = rng.normal(size=24)
+    >>> np.allclose(np.tensordot(ainv, b, 1), np.linalg.tensorsolve(a, b))
+    True
+
+    """
+    a = asarray(a)
+    oldshape = a.shape
+    prod = 1
+    if ind > 0:
+        invshape = oldshape[ind:] + oldshape[:ind]
+        for k in oldshape[ind:]:
+            prod *= k
+    else:
+        raise ValueError("Invalid ind argument.")
+    a = a.reshape(prod, -1)
+    ia = inv(a)
+    return ia.reshape(*invshape)
+
+
+# Matrix inversion
+
+def _unary_dispatcher(a):
+    return (a,)
+
+
+@array_function_dispatch(_unary_dispatcher)
+def inv(a):
+    """
+    Compute the inverse of a matrix.
+
+    Given a square matrix `a`, return the matrix `ainv` satisfying
+    ``a @ ainv = ainv @ a = eye(a.shape[0])``.
+
+    Parameters
+    ----------
+    a : (..., M, M) array_like
+        Matrix to be inverted.
+
+    Returns
+    -------
+    ainv : (..., M, M) ndarray or matrix
+        Inverse of the matrix `a`.
+
+    Raises
+    ------
+    LinAlgError
+        If `a` is not square or inversion fails.
+
+    See Also
+    --------
+    scipy.linalg.inv : Similar function in SciPy.
+    numpy.linalg.cond : Compute the condition number of a matrix.
+    numpy.linalg.svd : Compute the singular value decomposition of a matrix.
+
+    Notes
+    -----
+
+    .. versionadded:: 1.8.0
+
+    Broadcasting rules apply, see the `numpy.linalg` documentation for
+    details.
+
+    If `a` is detected to be singular, a `LinAlgError` is raised. If `a` is
+    ill-conditioned, a `LinAlgError` may or may not be raised, and results may
+    be inaccurate due to floating-point errors.
+
+    References
+    ----------
+    .. [1] Wikipedia, "Condition number",
+           https://en.wikipedia.org/wiki/Condition_number
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from numpy.linalg import inv
+    >>> a = np.array([[1., 2.], [3., 4.]])
+    >>> ainv = inv(a)
+    >>> np.allclose(a @ ainv, np.eye(2))
+    True
+    >>> np.allclose(ainv @ a, np.eye(2))
+    True
+
+    If a is a matrix object, then the return value is a matrix as well:
+
+    >>> ainv = inv(np.matrix(a))
+    >>> ainv
+    matrix([[-2. ,  1. ],
+            [ 1.5, -0.5]])
+
+    Inverses of several matrices can be computed at once:
+
+    >>> a = np.array([[[1., 2.], [3., 4.]], [[1, 3], [3, 5]]])
+    >>> inv(a)
+    array([[[-2.  ,  1.  ],
+            [ 1.5 , -0.5 ]],
+           [[-1.25,  0.75],
+            [ 0.75, -0.25]]])
+
+    If a matrix is close to singular, the computed inverse may not satisfy
+    ``a @ ainv = ainv @ a = eye(a.shape[0])`` even if a `LinAlgError`
+    is not raised:
+
+    >>> a = np.array([[2,4,6],[2,0,2],[6,8,14]])
+    >>> inv(a)  # No errors raised
+    array([[-1.12589991e+15, -5.62949953e+14,  5.62949953e+14],
+       [-1.12589991e+15, -5.62949953e+14,  5.62949953e+14],
+       [ 1.12589991e+15,  5.62949953e+14, -5.62949953e+14]])
+    >>> a @ inv(a)
+    array([[ 0.   , -0.5  ,  0.   ],  # may vary
+           [-0.5  ,  0.625,  0.25 ],
+           [ 0.   ,  0.   ,  1.   ]])
+
+    To detect ill-conditioned matrices, you can use `numpy.linalg.cond` to
+    compute its *condition number* [1]_. The larger the condition number, the
+    more ill-conditioned the matrix is. As a rule of thumb, if the condition
+    number ``cond(a) = 10**k``, then you may lose up to ``k`` digits of
+    accuracy on top of what would be lost to the numerical method due to loss
+    of precision from arithmetic methods.
+
+    >>> from numpy.linalg import cond
+    >>> cond(a)
+    np.float64(8.659885634118668e+17)  # may vary
+
+    It is also possible to detect ill-conditioning by inspecting the matrix's
+    singular values directly. The ratio between the largest and the smallest
+    singular value is the condition number:
+
+    >>> from numpy.linalg import svd
+    >>> sigma = svd(a, compute_uv=False)  # Do not compute singular vectors
+    >>> sigma.max()/sigma.min()
+    8.659885634118668e+17  # may vary
+
+    """
+    a, wrap = _makearray(a)
+    _assert_stacked_2d(a)
+    _assert_stacked_square(a)
+    t, result_t = _commonType(a)
+
+    signature = 'D->D' if isComplexType(t) else 'd->d'
+    with errstate(call=_raise_linalgerror_singular, invalid='call',
+                  over='ignore', divide='ignore', under='ignore'):
+        ainv = _umath_linalg.inv(a, signature=signature)
+    return wrap(ainv.astype(result_t, copy=False))
+
+
+def _matrix_power_dispatcher(a, n):
+    return (a,)
+
+
+@array_function_dispatch(_matrix_power_dispatcher)
+def matrix_power(a, n):
+    """
+    Raise a square matrix to the (integer) power `n`.
+
+    For positive integers `n`, the power is computed by repeated matrix
+    squarings and matrix multiplications. If ``n == 0``, the identity matrix
+    of the same shape as M is returned. If ``n < 0``, the inverse
+    is computed and then raised to the ``abs(n)``.
+
+    .. note:: Stacks of object matrices are not currently supported.
+
+    Parameters
+    ----------
+    a : (..., M, M) array_like
+        Matrix to be "powered".
+    n : int
+        The exponent can be any integer or long integer, positive,
+        negative, or zero.
+
+    Returns
+    -------
+    a**n : (..., M, M) ndarray or matrix object
+        The return value is the same shape and type as `M`;
+        if the exponent is positive or zero then the type of the
+        elements is the same as those of `M`. If the exponent is
+        negative the elements are floating-point.
+
+    Raises
+    ------
+    LinAlgError
+        For matrices that are not square or that (for negative powers) cannot
+        be inverted numerically.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from numpy.linalg import matrix_power
+    >>> i = np.array([[0, 1], [-1, 0]]) # matrix equiv. of the imaginary unit
+    >>> matrix_power(i, 3) # should = -i
+    array([[ 0, -1],
+           [ 1,  0]])
+    >>> matrix_power(i, 0)
+    array([[1, 0],
+           [0, 1]])
+    >>> matrix_power(i, -3) # should = 1/(-i) = i, but w/ f.p. elements
+    array([[ 0.,  1.],
+           [-1.,  0.]])
+
+    Somewhat more sophisticated example
+
+    >>> q = np.zeros((4, 4))
+    >>> q[0:2, 0:2] = -i
+    >>> q[2:4, 2:4] = i
+    >>> q # one of the three quaternion units not equal to 1
+    array([[ 0., -1.,  0.,  0.],
+           [ 1.,  0.,  0.,  0.],
+           [ 0.,  0.,  0.,  1.],
+           [ 0.,  0., -1.,  0.]])
+    >>> matrix_power(q, 2) # = -np.eye(4)
+    array([[-1.,  0.,  0.,  0.],
+           [ 0., -1.,  0.,  0.],
+           [ 0.,  0., -1.,  0.],
+           [ 0.,  0.,  0., -1.]])
+
+    """
+    a = asanyarray(a)
+    _assert_stacked_2d(a)
+    _assert_stacked_square(a)
+
+    try:
+        n = operator.index(n)
+    except TypeError as e:
+        raise TypeError("exponent must be an integer") from e
+
+    # Fall back on dot for object arrays. Object arrays are not supported by
+    # the current implementation of matmul using einsum
+    if a.dtype != object:
+        fmatmul = matmul
+    elif a.ndim == 2:
+        fmatmul = dot
+    else:
+        raise NotImplementedError(
+            "matrix_power not supported for stacks of object arrays")
+
+    if n == 0:
+        a = empty_like(a)
+        a[...] = eye(a.shape[-2], dtype=a.dtype)
+        return a
+
+    elif n < 0:
+        a = inv(a)
+        n = abs(n)
+
+    # short-cuts.
+    if n == 1:
+        return a
+
+    elif n == 2:
+        return fmatmul(a, a)
+
+    elif n == 3:
+        return fmatmul(fmatmul(a, a), a)
+
+    # Use binary decomposition to reduce the number of matrix multiplications.
+    # Here, we iterate over the bits of n, from LSB to MSB, raise `a` to
+    # increasing powers of 2, and multiply into the result as needed.
+    z = result = None
+    while n > 0:
+        z = a if z is None else fmatmul(z, z)
+        n, bit = divmod(n, 2)
+        if bit:
+            result = z if result is None else fmatmul(result, z)
+
+    return result
+
+
+# Cholesky decomposition
+
+def _cholesky_dispatcher(a, /, *, upper=None):
+    return (a,)
+
+
+@array_function_dispatch(_cholesky_dispatcher)
+def cholesky(a, /, *, upper=False):
+    """
+    Cholesky decomposition.
+
+    Return the lower or upper Cholesky decomposition, ``L * L.H`` or
+    ``U.H * U``, of the square matrix ``a``, where ``L`` is lower-triangular,
+    ``U`` is upper-triangular, and ``.H`` is the conjugate transpose operator
+    (which is the ordinary transpose if ``a`` is real-valued). ``a`` must be
+    Hermitian (symmetric if real-valued) and positive-definite. No checking is
+    performed to verify whether ``a`` is Hermitian or not. In addition, only
+    the lower or upper-triangular and diagonal elements of ``a`` are used.
+    Only ``L`` or ``U`` is actually returned.
+
+    Parameters
+    ----------
+    a : (..., M, M) array_like
+        Hermitian (symmetric if all elements are real), positive-definite
+        input matrix.
+    upper : bool
+        If ``True``, the result must be the upper-triangular Cholesky factor.
+        If ``False``, the result must be the lower-triangular Cholesky factor.
+        Default: ``False``.
+
+    Returns
+    -------
+    L : (..., M, M) array_like
+        Lower or upper-triangular Cholesky factor of `a`. Returns a matrix
+        object if `a` is a matrix object.
+
+    Raises
+    ------
+    LinAlgError
+       If the decomposition fails, for example, if `a` is not
+       positive-definite.
+
+    See Also
+    --------
+    scipy.linalg.cholesky : Similar function in SciPy.
+    scipy.linalg.cholesky_banded : Cholesky decompose a banded Hermitian
+                                   positive-definite matrix.
+    scipy.linalg.cho_factor : Cholesky decomposition of a matrix, to use in
+                              `scipy.linalg.cho_solve`.
+
+    Notes
+    -----
+
+    .. versionadded:: 1.8.0
+
+    Broadcasting rules apply, see the `numpy.linalg` documentation for
+    details.
+
+    The Cholesky decomposition is often used as a fast way of solving
+
+    .. math:: A \\mathbf{x} = \\mathbf{b}
+
+    (when `A` is both Hermitian/symmetric and positive-definite).
+
+    First, we solve for :math:`\\mathbf{y}` in
+
+    .. math:: L \\mathbf{y} = \\mathbf{b},
+
+    and then for :math:`\\mathbf{x}` in
+
+    .. math:: L^{H} \\mathbf{x} = \\mathbf{y}.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> A = np.array([[1,-2j],[2j,5]])
+    >>> A
+    array([[ 1.+0.j, -0.-2.j],
+           [ 0.+2.j,  5.+0.j]])
+    >>> L = np.linalg.cholesky(A)
+    >>> L
+    array([[1.+0.j, 0.+0.j],
+           [0.+2.j, 1.+0.j]])
+    >>> np.dot(L, L.T.conj()) # verify that L * L.H = A
+    array([[1.+0.j, 0.-2.j],
+           [0.+2.j, 5.+0.j]])
+    >>> A = [[1,-2j],[2j,5]] # what happens if A is only array_like?
+    >>> np.linalg.cholesky(A) # an ndarray object is returned
+    array([[1.+0.j, 0.+0.j],
+           [0.+2.j, 1.+0.j]])
+    >>> # But a matrix object is returned if A is a matrix object
+    >>> np.linalg.cholesky(np.matrix(A))
+    matrix([[ 1.+0.j,  0.+0.j],
+            [ 0.+2.j,  1.+0.j]])
+    >>> # The upper-triangular Cholesky factor can also be obtained.
+    >>> np.linalg.cholesky(A, upper=True)
+    array([[1.-0.j, 0.-2.j],
+           [0.-0.j, 1.-0.j]])
+
+    """
+    gufunc = _umath_linalg.cholesky_up if upper else _umath_linalg.cholesky_lo
+    a, wrap = _makearray(a)
+    _assert_stacked_2d(a)
+    _assert_stacked_square(a)
+    t, result_t = _commonType(a)
+    signature = 'D->D' if isComplexType(t) else 'd->d'
+    with errstate(call=_raise_linalgerror_nonposdef, invalid='call',
+                  over='ignore', divide='ignore', under='ignore'):
+        r = gufunc(a, signature=signature)
+    return wrap(r.astype(result_t, copy=False))
+
+
+# outer product
+
+
+def _outer_dispatcher(x1, x2):
+    return (x1, x2)
+
+
+@array_function_dispatch(_outer_dispatcher)
+def outer(x1, x2, /):
+    """
+    Compute the outer product of two vectors.
+
+    This function is Array API compatible. Compared to ``np.outer``
+    it accepts 1-dimensional inputs only.
+
+    Parameters
+    ----------
+    x1 : (M,) array_like
+        One-dimensional input array of size ``N``.
+        Must have a numeric data type.
+    x2 : (N,) array_like
+        One-dimensional input array of size ``M``.
+        Must have a numeric data type.
+
+    Returns
+    -------
+    out : (M, N) ndarray
+        ``out[i, j] = a[i] * b[j]``
+
+    See also
+    --------
+    outer
+
+    Examples
+    --------
+    Make a (*very* coarse) grid for computing a Mandelbrot set:
+
+    >>> rl = np.linalg.outer(np.ones((5,)), np.linspace(-2, 2, 5))
+    >>> rl
+    array([[-2., -1.,  0.,  1.,  2.],
+           [-2., -1.,  0.,  1.,  2.],
+           [-2., -1.,  0.,  1.,  2.],
+           [-2., -1.,  0.,  1.,  2.],
+           [-2., -1.,  0.,  1.,  2.]])
+    >>> im = np.linalg.outer(1j*np.linspace(2, -2, 5), np.ones((5,)))
+    >>> im
+    array([[0.+2.j, 0.+2.j, 0.+2.j, 0.+2.j, 0.+2.j],
+           [0.+1.j, 0.+1.j, 0.+1.j, 0.+1.j, 0.+1.j],
+           [0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j],
+           [0.-1.j, 0.-1.j, 0.-1.j, 0.-1.j, 0.-1.j],
+           [0.-2.j, 0.-2.j, 0.-2.j, 0.-2.j, 0.-2.j]])
+    >>> grid = rl + im
+    >>> grid
+    array([[-2.+2.j, -1.+2.j,  0.+2.j,  1.+2.j,  2.+2.j],
+           [-2.+1.j, -1.+1.j,  0.+1.j,  1.+1.j,  2.+1.j],
+           [-2.+0.j, -1.+0.j,  0.+0.j,  1.+0.j,  2.+0.j],
+           [-2.-1.j, -1.-1.j,  0.-1.j,  1.-1.j,  2.-1.j],
+           [-2.-2.j, -1.-2.j,  0.-2.j,  1.-2.j,  2.-2.j]])
+
+    An example using a "vector" of letters:
+
+    >>> x = np.array(['a', 'b', 'c'], dtype=object)
+    >>> np.linalg.outer(x, [1, 2, 3])
+    array([['a', 'aa', 'aaa'],
+           ['b', 'bb', 'bbb'],
+           ['c', 'cc', 'ccc']], dtype=object)
+
+    """
+    x1 = asanyarray(x1)
+    x2 = asanyarray(x2)
+    if x1.ndim != 1 or x2.ndim != 1:
+        raise ValueError(
+            "Input arrays must be one-dimensional, but they are "
+            f"{x1.ndim=} and {x2.ndim=}."
+        )
+    return _core_outer(x1, x2, out=None)
+
+
+# QR decomposition
+
+
+def _qr_dispatcher(a, mode=None):
+    return (a,)
+
+
+@array_function_dispatch(_qr_dispatcher)
+def qr(a, mode='reduced'):
+    """
+    Compute the qr factorization of a matrix.
+
+    Factor the matrix `a` as *qr*, where `q` is orthonormal and `r` is
+    upper-triangular.
+
+    Parameters
+    ----------
+    a : array_like, shape (..., M, N)
+        An array-like object with the dimensionality of at least 2.
+    mode : {'reduced', 'complete', 'r', 'raw'}, optional, default: 'reduced'
+        If K = min(M, N), then
+
+        * 'reduced'  : returns Q, R with dimensions (..., M, K), (..., K, N)
+        * 'complete' : returns Q, R with dimensions (..., M, M), (..., M, N)
+        * 'r'        : returns R only with dimensions (..., K, N)
+        * 'raw'      : returns h, tau with dimensions (..., N, M), (..., K,)
+
+        The options 'reduced', 'complete, and 'raw' are new in numpy 1.8,
+        see the notes for more information. The default is 'reduced', and to
+        maintain backward compatibility with earlier versions of numpy both
+        it and the old default 'full' can be omitted. Note that array h
+        returned in 'raw' mode is transposed for calling Fortran. The
+        'economic' mode is deprecated.  The modes 'full' and 'economic' may
+        be passed using only the first letter for backwards compatibility,
+        but all others must be spelled out. See the Notes for more
+        explanation.
+
+
+    Returns
+    -------
+    When mode is 'reduced' or 'complete', the result will be a namedtuple with
+    the attributes `Q` and `R`.
+
+    Q : ndarray of float or complex, optional
+        A matrix with orthonormal columns. When mode = 'complete' the
+        result is an orthogonal/unitary matrix depending on whether or not
+        a is real/complex. The determinant may be either +/- 1 in that
+        case. In case the number of dimensions in the input array is
+        greater than 2 then a stack of the matrices with above properties
+        is returned.
+    R : ndarray of float or complex, optional
+        The upper-triangular matrix or a stack of upper-triangular
+        matrices if the number of dimensions in the input array is greater
+        than 2.
+    (h, tau) : ndarrays of np.double or np.cdouble, optional
+        The array h contains the Householder reflectors that generate q
+        along with r. The tau array contains scaling factors for the
+        reflectors. In the deprecated  'economic' mode only h is returned.
+
+    Raises
+    ------
+    LinAlgError
+        If factoring fails.
+
+    See Also
+    --------
+    scipy.linalg.qr : Similar function in SciPy.
+    scipy.linalg.rq : Compute RQ decomposition of a matrix.
+
+    Notes
+    -----
+    This is an interface to the LAPACK routines ``dgeqrf``, ``zgeqrf``,
+    ``dorgqr``, and ``zungqr``.
+
+    For more information on the qr factorization, see for example:
+    https://en.wikipedia.org/wiki/QR_factorization
+
+    Subclasses of `ndarray` are preserved except for the 'raw' mode. So if
+    `a` is of type `matrix`, all the return values will be matrices too.
+
+    New 'reduced', 'complete', and 'raw' options for mode were added in
+    NumPy 1.8.0 and the old option 'full' was made an alias of 'reduced'.  In
+    addition the options 'full' and 'economic' were deprecated.  Because
+    'full' was the previous default and 'reduced' is the new default,
+    backward compatibility can be maintained by letting `mode` default.
+    The 'raw' option was added so that LAPACK routines that can multiply
+    arrays by q using the Householder reflectors can be used. Note that in
+    this case the returned arrays are of type np.double or np.cdouble and
+    the h array is transposed to be FORTRAN compatible.  No routines using
+    the 'raw' return are currently exposed by numpy, but some are available
+    in lapack_lite and just await the necessary work.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> rng = np.random.default_rng()
+    >>> a = rng.normal(size=(9, 6))
+    >>> Q, R = np.linalg.qr(a)
+    >>> np.allclose(a, np.dot(Q, R))  # a does equal QR
+    True
+    >>> R2 = np.linalg.qr(a, mode='r')
+    >>> np.allclose(R, R2)  # mode='r' returns the same R as mode='full'
+    True
+    >>> a = np.random.normal(size=(3, 2, 2)) # Stack of 2 x 2 matrices as input
+    >>> Q, R = np.linalg.qr(a)
+    >>> Q.shape
+    (3, 2, 2)
+    >>> R.shape
+    (3, 2, 2)
+    >>> np.allclose(a, np.matmul(Q, R))
+    True
+
+    Example illustrating a common use of `qr`: solving of least squares
+    problems
+
+    What are the least-squares-best `m` and `y0` in ``y = y0 + mx`` for
+    the following data: {(0,1), (1,0), (1,2), (2,1)}. (Graph the points
+    and you'll see that it should be y0 = 0, m = 1.)  The answer is provided
+    by solving the over-determined matrix equation ``Ax = b``, where::
+
+      A = array([[0, 1], [1, 1], [1, 1], [2, 1]])
+      x = array([[y0], [m]])
+      b = array([[1], [0], [2], [1]])
+
+    If A = QR such that Q is orthonormal (which is always possible via
+    Gram-Schmidt), then ``x = inv(R) * (Q.T) * b``.  (In numpy practice,
+    however, we simply use `lstsq`.)
+
+    >>> A = np.array([[0, 1], [1, 1], [1, 1], [2, 1]])
+    >>> A
+    array([[0, 1],
+           [1, 1],
+           [1, 1],
+           [2, 1]])
+    >>> b = np.array([1, 2, 2, 3])
+    >>> Q, R = np.linalg.qr(A)
+    >>> p = np.dot(Q.T, b)
+    >>> np.dot(np.linalg.inv(R), p)
+    array([  1.,   1.])
+
+    """
+    if mode not in ('reduced', 'complete', 'r', 'raw'):
+        if mode in ('f', 'full'):
+            # 2013-04-01, 1.8
+            msg = "".join((
+                    "The 'full' option is deprecated in favor of 'reduced'.\n",
+                    "For backward compatibility let mode default."))
+            warnings.warn(msg, DeprecationWarning, stacklevel=2)
+            mode = 'reduced'
+        elif mode in ('e', 'economic'):
+            # 2013-04-01, 1.8
+            msg = "The 'economic' option is deprecated."
+            warnings.warn(msg, DeprecationWarning, stacklevel=2)
+            mode = 'economic'
+        else:
+            raise ValueError(f"Unrecognized mode '{mode}'")
+
+    a, wrap = _makearray(a)
+    _assert_stacked_2d(a)
+    m, n = a.shape[-2:]
+    t, result_t = _commonType(a)
+    a = a.astype(t, copy=True)
+    a = _to_native_byte_order(a)
+    mn = min(m, n)
+
+    signature = 'D->D' if isComplexType(t) else 'd->d'
+    with errstate(call=_raise_linalgerror_qr, invalid='call',
+                  over='ignore', divide='ignore', under='ignore'):
+        tau = _umath_linalg.qr_r_raw(a, signature=signature)
+
+    # handle modes that don't return q
+    if mode == 'r':
+        r = triu(a[..., :mn, :])
+        r = r.astype(result_t, copy=False)
+        return wrap(r)
+
+    if mode == 'raw':
+        q = transpose(a)
+        q = q.astype(result_t, copy=False)
+        tau = tau.astype(result_t, copy=False)
+        return wrap(q), tau
+
+    if mode == 'economic':
+        a = a.astype(result_t, copy=False)
+        return wrap(a)
+
+    # mc is the number of columns in the resulting q
+    # matrix. If the mode is complete then it is
+    # same as number of rows, and if the mode is reduced,
+    # then it is the minimum of number of rows and columns.
+    if mode == 'complete' and m > n:
+        mc = m
+        gufunc = _umath_linalg.qr_complete
+    else:
+        mc = mn
+        gufunc = _umath_linalg.qr_reduced
+
+    signature = 'DD->D' if isComplexType(t) else 'dd->d'
+    with errstate(call=_raise_linalgerror_qr, invalid='call',
+                  over='ignore', divide='ignore', under='ignore'):
+        q = gufunc(a, tau, signature=signature)
+    r = triu(a[..., :mc, :])
+
+    q = q.astype(result_t, copy=False)
+    r = r.astype(result_t, copy=False)
+
+    return QRResult(wrap(q), wrap(r))
+
+# Eigenvalues
+
+
+@array_function_dispatch(_unary_dispatcher)
+def eigvals(a):
+    """
+    Compute the eigenvalues of a general matrix.
+
+    Main difference between `eigvals` and `eig`: the eigenvectors aren't
+    returned.
+
+    Parameters
+    ----------
+    a : (..., M, M) array_like
+        A complex- or real-valued matrix whose eigenvalues will be computed.
+
+    Returns
+    -------
+    w : (..., M,) ndarray
+        The eigenvalues, each repeated according to its multiplicity.
+        They are not necessarily ordered, nor are they necessarily
+        real for real matrices.
+
+    Raises
+    ------
+    LinAlgError
+        If the eigenvalue computation does not converge.
+
+    See Also
+    --------
+    eig : eigenvalues and right eigenvectors of general arrays
+    eigvalsh : eigenvalues of real symmetric or complex Hermitian
+               (conjugate symmetric) arrays.
+    eigh : eigenvalues and eigenvectors of real symmetric or complex
+           Hermitian (conjugate symmetric) arrays.
+    scipy.linalg.eigvals : Similar function in SciPy.
+
+    Notes
+    -----
+
+    .. versionadded:: 1.8.0
+
+    Broadcasting rules apply, see the `numpy.linalg` documentation for
+    details.
+
+    This is implemented using the ``_geev`` LAPACK routines which compute
+    the eigenvalues and eigenvectors of general square arrays.
+
+    Examples
+    --------
+    Illustration, using the fact that the eigenvalues of a diagonal matrix
+    are its diagonal elements, that multiplying a matrix on the left
+    by an orthogonal matrix, `Q`, and on the right by `Q.T` (the transpose
+    of `Q`), preserves the eigenvalues of the "middle" matrix. In other words,
+    if `Q` is orthogonal, then ``Q * A * Q.T`` has the same eigenvalues as
+    ``A``:
+
+    >>> import numpy as np
+    >>> from numpy import linalg as LA
+    >>> x = np.random.random()
+    >>> Q = np.array([[np.cos(x), -np.sin(x)], [np.sin(x), np.cos(x)]])
+    >>> LA.norm(Q[0, :]), LA.norm(Q[1, :]), np.dot(Q[0, :],Q[1, :])
+    (1.0, 1.0, 0.0)
+
+    Now multiply a diagonal matrix by ``Q`` on one side and
+    by ``Q.T`` on the other:
+
+    >>> D = np.diag((-1,1))
+    >>> LA.eigvals(D)
+    array([-1.,  1.])
+    >>> A = np.dot(Q, D)
+    >>> A = np.dot(A, Q.T)
+    >>> LA.eigvals(A)
+    array([ 1., -1.]) # random
+
+    """
+    a, wrap = _makearray(a)
+    _assert_stacked_2d(a)
+    _assert_stacked_square(a)
+    _assert_finite(a)
+    t, result_t = _commonType(a)
+
+    signature = 'D->D' if isComplexType(t) else 'd->D'
+    with errstate(call=_raise_linalgerror_eigenvalues_nonconvergence,
+                  invalid='call', over='ignore', divide='ignore',
+                  under='ignore'):
+        w = _umath_linalg.eigvals(a, signature=signature)
+
+    if not isComplexType(t):
+        if all(w.imag == 0):
+            w = w.real
+            result_t = _realType(result_t)
+        else:
+            result_t = _complexType(result_t)
+
+    return w.astype(result_t, copy=False)
+
+
+def _eigvalsh_dispatcher(a, UPLO=None):
+    return (a,)
+
+
+@array_function_dispatch(_eigvalsh_dispatcher)
+def eigvalsh(a, UPLO='L'):
+    """
+    Compute the eigenvalues of a complex Hermitian or real symmetric matrix.
+
+    Main difference from eigh: the eigenvectors are not computed.
+
+    Parameters
+    ----------
+    a : (..., M, M) array_like
+        A complex- or real-valued matrix whose eigenvalues are to be
+        computed.
+    UPLO : {'L', 'U'}, optional
+        Specifies whether the calculation is done with the lower triangular
+        part of `a` ('L', default) or the upper triangular part ('U').
+        Irrespective of this value only the real parts of the diagonal will
+        be considered in the computation to preserve the notion of a Hermitian
+        matrix. It therefore follows that the imaginary part of the diagonal
+        will always be treated as zero.
+
+    Returns
+    -------
+    w : (..., M,) ndarray
+        The eigenvalues in ascending order, each repeated according to
+        its multiplicity.
+
+    Raises
+    ------
+    LinAlgError
+        If the eigenvalue computation does not converge.
+
+    See Also
+    --------
+    eigh : eigenvalues and eigenvectors of real symmetric or complex Hermitian
+           (conjugate symmetric) arrays.
+    eigvals : eigenvalues of general real or complex arrays.
+    eig : eigenvalues and right eigenvectors of general real or complex
+          arrays.
+    scipy.linalg.eigvalsh : Similar function in SciPy.
+
+    Notes
+    -----
+
+    .. versionadded:: 1.8.0
+
+    Broadcasting rules apply, see the `numpy.linalg` documentation for
+    details.
+
+    The eigenvalues are computed using LAPACK routines ``_syevd``, ``_heevd``.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from numpy import linalg as LA
+    >>> a = np.array([[1, -2j], [2j, 5]])
+    >>> LA.eigvalsh(a)
+    array([ 0.17157288,  5.82842712]) # may vary
+
+    >>> # demonstrate the treatment of the imaginary part of the diagonal
+    >>> a = np.array([[5+2j, 9-2j], [0+2j, 2-1j]])
+    >>> a
+    array([[5.+2.j, 9.-2.j],
+           [0.+2.j, 2.-1.j]])
+    >>> # with UPLO='L' this is numerically equivalent to using LA.eigvals()
+    >>> # with:
+    >>> b = np.array([[5.+0.j, 0.-2.j], [0.+2.j, 2.-0.j]])
+    >>> b
+    array([[5.+0.j, 0.-2.j],
+           [0.+2.j, 2.+0.j]])
+    >>> wa = LA.eigvalsh(a)
+    >>> wb = LA.eigvals(b)
+    >>> wa; wb
+    array([1., 6.])
+    array([6.+0.j, 1.+0.j])
+
+    """
+    UPLO = UPLO.upper()
+    if UPLO not in ('L', 'U'):
+        raise ValueError("UPLO argument must be 'L' or 'U'")
+
+    if UPLO == 'L':
+        gufunc = _umath_linalg.eigvalsh_lo
+    else:
+        gufunc = _umath_linalg.eigvalsh_up
+
+    a, wrap = _makearray(a)
+    _assert_stacked_2d(a)
+    _assert_stacked_square(a)
+    t, result_t = _commonType(a)
+    signature = 'D->d' if isComplexType(t) else 'd->d'
+    with errstate(call=_raise_linalgerror_eigenvalues_nonconvergence,
+                  invalid='call', over='ignore', divide='ignore',
+                  under='ignore'):
+        w = gufunc(a, signature=signature)
+    return w.astype(_realType(result_t), copy=False)
+
+def _convertarray(a):
+    t, result_t = _commonType(a)
+    a = a.astype(t).T.copy()
+    return a, t, result_t
+
+
+# Eigenvectors
+
+
+@array_function_dispatch(_unary_dispatcher)
+def eig(a):
+    """
+    Compute the eigenvalues and right eigenvectors of a square array.
+
+    Parameters
+    ----------
+    a : (..., M, M) array
+        Matrices for which the eigenvalues and right eigenvectors will
+        be computed
+
+    Returns
+    -------
+    A namedtuple with the following attributes:
+
+    eigenvalues : (..., M) array
+        The eigenvalues, each repeated according to its multiplicity.
+        The eigenvalues are not necessarily ordered. The resulting
+        array will be of complex type, unless the imaginary part is
+        zero in which case it will be cast to a real type. When `a`
+        is real the resulting eigenvalues will be real (0 imaginary
+        part) or occur in conjugate pairs
+
+    eigenvectors : (..., M, M) array
+        The normalized (unit "length") eigenvectors, such that the
+        column ``eigenvectors[:,i]`` is the eigenvector corresponding to the
+        eigenvalue ``eigenvalues[i]``.
+
+    Raises
+    ------
+    LinAlgError
+        If the eigenvalue computation does not converge.
+
+    See Also
+    --------
+    eigvals : eigenvalues of a non-symmetric array.
+    eigh : eigenvalues and eigenvectors of a real symmetric or complex
+           Hermitian (conjugate symmetric) array.
+    eigvalsh : eigenvalues of a real symmetric or complex Hermitian
+               (conjugate symmetric) array.
+    scipy.linalg.eig : Similar function in SciPy that also solves the
+                       generalized eigenvalue problem.
+    scipy.linalg.schur : Best choice for unitary and other non-Hermitian
+                         normal matrices.
+
+    Notes
+    -----
+
+    .. versionadded:: 1.8.0
+
+    Broadcasting rules apply, see the `numpy.linalg` documentation for
+    details.
+
+    This is implemented using the ``_geev`` LAPACK routines which compute
+    the eigenvalues and eigenvectors of general square arrays.
+
+    The number `w` is an eigenvalue of `a` if there exists a vector `v` such
+    that ``a @ v = w * v``. Thus, the arrays `a`, `eigenvalues`, and
+    `eigenvectors` satisfy the equations ``a @ eigenvectors[:,i] =
+    eigenvalues[i] * eigenvectors[:,i]`` for :math:`i \\in \\{0,...,M-1\\}`.
+
+    The array `eigenvectors` may not be of maximum rank, that is, some of the
+    columns may be linearly dependent, although round-off error may obscure
+    that fact. If the eigenvalues are all different, then theoretically the
+    eigenvectors are linearly independent and `a` can be diagonalized by a
+    similarity transformation using `eigenvectors`, i.e, ``inv(eigenvectors) @
+    a @ eigenvectors`` is diagonal.
+
+    For non-Hermitian normal matrices the SciPy function `scipy.linalg.schur`
+    is preferred because the matrix `eigenvectors` is guaranteed to be
+    unitary, which is not the case when using `eig`. The Schur factorization
+    produces an upper triangular matrix rather than a diagonal matrix, but for
+    normal matrices only the diagonal of the upper triangular matrix is
+    needed, the rest is roundoff error.
+
+    Finally, it is emphasized that `eigenvectors` consists of the *right* (as
+    in right-hand side) eigenvectors of `a`. A vector `y` satisfying ``y.T @ a
+    = z * y.T`` for some number `z` is called a *left* eigenvector of `a`,
+    and, in general, the left and right eigenvectors of a matrix are not
+    necessarily the (perhaps conjugate) transposes of each other.
+
+    References
+    ----------
+    G. Strang, *Linear Algebra and Its Applications*, 2nd Ed., Orlando, FL,
+    Academic Press, Inc., 1980, Various pp.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from numpy import linalg as LA
+
+    (Almost) trivial example with real eigenvalues and eigenvectors.
+
+    >>> eigenvalues, eigenvectors = LA.eig(np.diag((1, 2, 3)))
+    >>> eigenvalues
+    array([1., 2., 3.])
+    >>> eigenvectors
+    array([[1., 0., 0.],
+           [0., 1., 0.],
+           [0., 0., 1.]])
+
+    Real matrix possessing complex eigenvalues and eigenvectors;
+    note that the eigenvalues are complex conjugates of each other.
+
+    >>> eigenvalues, eigenvectors = LA.eig(np.array([[1, -1], [1, 1]]))
+    >>> eigenvalues
+    array([1.+1.j, 1.-1.j])
+    >>> eigenvectors
+    array([[0.70710678+0.j        , 0.70710678-0.j        ],
+           [0.        -0.70710678j, 0.        +0.70710678j]])
+
+    Complex-valued matrix with real eigenvalues (but complex-valued
+    eigenvectors); note that ``a.conj().T == a``, i.e., `a` is Hermitian.
+
+    >>> a = np.array([[1, 1j], [-1j, 1]])
+    >>> eigenvalues, eigenvectors = LA.eig(a)
+    >>> eigenvalues
+    array([2.+0.j, 0.+0.j])
+    >>> eigenvectors
+    array([[ 0.        +0.70710678j,  0.70710678+0.j        ], # may vary
+           [ 0.70710678+0.j        , -0.        +0.70710678j]])
+
+    Be careful about round-off error!
+
+    >>> a = np.array([[1 + 1e-9, 0], [0, 1 - 1e-9]])
+    >>> # Theor. eigenvalues are 1 +/- 1e-9
+    >>> eigenvalues, eigenvectors = LA.eig(a)
+    >>> eigenvalues
+    array([1., 1.])
+    >>> eigenvectors
+    array([[1., 0.],
+           [0., 1.]])
+
+    """
+    a, wrap = _makearray(a)
+    _assert_stacked_2d(a)
+    _assert_stacked_square(a)
+    _assert_finite(a)
+    t, result_t = _commonType(a)
+
+    signature = 'D->DD' if isComplexType(t) else 'd->DD'
+    with errstate(call=_raise_linalgerror_eigenvalues_nonconvergence,
+                  invalid='call', over='ignore', divide='ignore',
+                  under='ignore'):
+        w, vt = _umath_linalg.eig(a, signature=signature)
+
+    if not isComplexType(t) and all(w.imag == 0.0):
+        w = w.real
+        vt = vt.real
+        result_t = _realType(result_t)
+    else:
+        result_t = _complexType(result_t)
+
+    vt = vt.astype(result_t, copy=False)
+    return EigResult(w.astype(result_t, copy=False), wrap(vt))
+
+
+@array_function_dispatch(_eigvalsh_dispatcher)
+def eigh(a, UPLO='L'):
+    """
+    Return the eigenvalues and eigenvectors of a complex Hermitian
+    (conjugate symmetric) or a real symmetric matrix.
+
+    Returns two objects, a 1-D array containing the eigenvalues of `a`, and
+    a 2-D square array or matrix (depending on the input type) of the
+    corresponding eigenvectors (in columns).
+
+    Parameters
+    ----------
+    a : (..., M, M) array
+        Hermitian or real symmetric matrices whose eigenvalues and
+        eigenvectors are to be computed.
+    UPLO : {'L', 'U'}, optional
+        Specifies whether the calculation is done with the lower triangular
+        part of `a` ('L', default) or the upper triangular part ('U').
+        Irrespective of this value only the real parts of the diagonal will
+        be considered in the computation to preserve the notion of a Hermitian
+        matrix. It therefore follows that the imaginary part of the diagonal
+        will always be treated as zero.
+
+    Returns
+    -------
+    A namedtuple with the following attributes:
+
+    eigenvalues : (..., M) ndarray
+        The eigenvalues in ascending order, each repeated according to
+        its multiplicity.
+    eigenvectors : {(..., M, M) ndarray, (..., M, M) matrix}
+        The column ``eigenvectors[:, i]`` is the normalized eigenvector
+        corresponding to the eigenvalue ``eigenvalues[i]``.  Will return a
+        matrix object if `a` is a matrix object.
+
+    Raises
+    ------
+    LinAlgError
+        If the eigenvalue computation does not converge.
+
+    See Also
+    --------
+    eigvalsh : eigenvalues of real symmetric or complex Hermitian
+               (conjugate symmetric) arrays.
+    eig : eigenvalues and right eigenvectors for non-symmetric arrays.
+    eigvals : eigenvalues of non-symmetric arrays.
+    scipy.linalg.eigh : Similar function in SciPy (but also solves the
+                        generalized eigenvalue problem).
+
+    Notes
+    -----
+
+    .. versionadded:: 1.8.0
+
+    Broadcasting rules apply, see the `numpy.linalg` documentation for
+    details.
+
+    The eigenvalues/eigenvectors are computed using LAPACK routines ``_syevd``,
+    ``_heevd``.
+
+    The eigenvalues of real symmetric or complex Hermitian matrices are always
+    real. [1]_ The array `eigenvalues` of (column) eigenvectors is unitary and
+    `a`, `eigenvalues`, and `eigenvectors` satisfy the equations ``dot(a,
+    eigenvectors[:, i]) = eigenvalues[i] * eigenvectors[:, i]``.
+
+    References
+    ----------
+    .. [1] G. Strang, *Linear Algebra and Its Applications*, 2nd Ed., Orlando,
+           FL, Academic Press, Inc., 1980, pg. 222.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from numpy import linalg as LA
+    >>> a = np.array([[1, -2j], [2j, 5]])
+    >>> a
+    array([[ 1.+0.j, -0.-2.j],
+           [ 0.+2.j,  5.+0.j]])
+    >>> eigenvalues, eigenvectors = LA.eigh(a)
+    >>> eigenvalues
+    array([0.17157288, 5.82842712])
+    >>> eigenvectors
+    array([[-0.92387953+0.j        , -0.38268343+0.j        ], # may vary
+           [ 0.        +0.38268343j,  0.        -0.92387953j]])
+
+    >>> (np.dot(a, eigenvectors[:, 0]) -
+    ... eigenvalues[0] * eigenvectors[:, 0])  # verify 1st eigenval/vec pair
+    array([5.55111512e-17+0.0000000e+00j, 0.00000000e+00+1.2490009e-16j])
+    >>> (np.dot(a, eigenvectors[:, 1]) -
+    ... eigenvalues[1] * eigenvectors[:, 1])  # verify 2nd eigenval/vec pair
+    array([0.+0.j, 0.+0.j])
+
+    >>> A = np.matrix(a) # what happens if input is a matrix object
+    >>> A
+    matrix([[ 1.+0.j, -0.-2.j],
+            [ 0.+2.j,  5.+0.j]])
+    >>> eigenvalues, eigenvectors = LA.eigh(A)
+    >>> eigenvalues
+    array([0.17157288, 5.82842712])
+    >>> eigenvectors
+    matrix([[-0.92387953+0.j        , -0.38268343+0.j        ], # may vary
+            [ 0.        +0.38268343j,  0.        -0.92387953j]])
+
+    >>> # demonstrate the treatment of the imaginary part of the diagonal
+    >>> a = np.array([[5+2j, 9-2j], [0+2j, 2-1j]])
+    >>> a
+    array([[5.+2.j, 9.-2.j],
+           [0.+2.j, 2.-1.j]])
+    >>> # with UPLO='L' this is numerically equivalent to using LA.eig() with:
+    >>> b = np.array([[5.+0.j, 0.-2.j], [0.+2.j, 2.-0.j]])
+    >>> b
+    array([[5.+0.j, 0.-2.j],
+           [0.+2.j, 2.+0.j]])
+    >>> wa, va = LA.eigh(a)
+    >>> wb, vb = LA.eig(b)
+    >>> wa
+    array([1., 6.])
+    >>> wb
+    array([6.+0.j, 1.+0.j])
+    >>> va
+    array([[-0.4472136 +0.j        , -0.89442719+0.j        ], # may vary
+           [ 0.        +0.89442719j,  0.        -0.4472136j ]])
+    >>> vb
+    array([[ 0.89442719+0.j       , -0.        +0.4472136j],
+           [-0.        +0.4472136j,  0.89442719+0.j       ]])
+
+    """
+    UPLO = UPLO.upper()
+    if UPLO not in ('L', 'U'):
+        raise ValueError("UPLO argument must be 'L' or 'U'")
+
+    a, wrap = _makearray(a)
+    _assert_stacked_2d(a)
+    _assert_stacked_square(a)
+    t, result_t = _commonType(a)
+
+    if UPLO == 'L':
+        gufunc = _umath_linalg.eigh_lo
+    else:
+        gufunc = _umath_linalg.eigh_up
+
+    signature = 'D->dD' if isComplexType(t) else 'd->dd'
+    with errstate(call=_raise_linalgerror_eigenvalues_nonconvergence,
+                  invalid='call', over='ignore', divide='ignore',
+                  under='ignore'):
+        w, vt = gufunc(a, signature=signature)
+    w = w.astype(_realType(result_t), copy=False)
+    vt = vt.astype(result_t, copy=False)
+    return EighResult(w, wrap(vt))
+
+
+# Singular value decomposition
+
+def _svd_dispatcher(a, full_matrices=None, compute_uv=None, hermitian=None):
+    return (a,)
+
+
+@array_function_dispatch(_svd_dispatcher)
+def svd(a, full_matrices=True, compute_uv=True, hermitian=False):
+    """
+    Singular Value Decomposition.
+
+    When `a` is a 2D array, and ``full_matrices=False``, then it is
+    factorized as ``u @ np.diag(s) @ vh = (u * s) @ vh``, where
+    `u` and the Hermitian transpose of `vh` are 2D arrays with
+    orthonormal columns and `s` is a 1D array of `a`'s singular
+    values. When `a` is higher-dimensional, SVD is applied in
+    stacked mode as explained below.
+
+    Parameters
+    ----------
+    a : (..., M, N) array_like
+        A real or complex array with ``a.ndim >= 2``.
+    full_matrices : bool, optional
+        If True (default), `u` and `vh` have the shapes ``(..., M, M)`` and
+        ``(..., N, N)``, respectively.  Otherwise, the shapes are
+        ``(..., M, K)`` and ``(..., K, N)``, respectively, where
+        ``K = min(M, N)``.
+    compute_uv : bool, optional
+        Whether or not to compute `u` and `vh` in addition to `s`.  True
+        by default.
+    hermitian : bool, optional
+        If True, `a` is assumed to be Hermitian (symmetric if real-valued),
+        enabling a more efficient method for finding singular values.
+        Defaults to False.
+
+        .. versionadded:: 1.17.0
+
+    Returns
+    -------
+    When `compute_uv` is True, the result is a namedtuple with the following
+    attribute names:
+
+    U : { (..., M, M), (..., M, K) } array
+        Unitary array(s). The first ``a.ndim - 2`` dimensions have the same
+        size as those of the input `a`. The size of the last two dimensions
+        depends on the value of `full_matrices`. Only returned when
+        `compute_uv` is True.
+    S : (..., K) array
+        Vector(s) with the singular values, within each vector sorted in
+        descending order. The first ``a.ndim - 2`` dimensions have the same
+        size as those of the input `a`.
+    Vh : { (..., N, N), (..., K, N) } array
+        Unitary array(s). The first ``a.ndim - 2`` dimensions have the same
+        size as those of the input `a`. The size of the last two dimensions
+        depends on the value of `full_matrices`. Only returned when
+        `compute_uv` is True.
+
+    Raises
+    ------
+    LinAlgError
+        If SVD computation does not converge.
+
+    See Also
+    --------
+    scipy.linalg.svd : Similar function in SciPy.
+    scipy.linalg.svdvals : Compute singular values of a matrix.
+
+    Notes
+    -----
+
+    .. versionchanged:: 1.8.0
+       Broadcasting rules apply, see the `numpy.linalg` documentation for
+       details.
+
+    The decomposition is performed using LAPACK routine ``_gesdd``.
+
+    SVD is usually described for the factorization of a 2D matrix :math:`A`.
+    The higher-dimensional case will be discussed below. In the 2D case, SVD is
+    written as :math:`A = U S V^H`, where :math:`A = a`, :math:`U= u`,
+    :math:`S= \\mathtt{np.diag}(s)` and :math:`V^H = vh`. The 1D array `s`
+    contains the singular values of `a` and `u` and `vh` are unitary. The rows
+    of `vh` are the eigenvectors of :math:`A^H A` and the columns of `u` are
+    the eigenvectors of :math:`A A^H`. In both cases the corresponding
+    (possibly non-zero) eigenvalues are given by ``s**2``.
+
+    If `a` has more than two dimensions, then broadcasting rules apply, as
+    explained in :ref:`routines.linalg-broadcasting`. This means that SVD is
+    working in "stacked" mode: it iterates over all indices of the first
+    ``a.ndim - 2`` dimensions and for each combination SVD is applied to the
+    last two indices. The matrix `a` can be reconstructed from the
+    decomposition with either ``(u * s[..., None, :]) @ vh`` or
+    ``u @ (s[..., None] * vh)``. (The ``@`` operator can be replaced by the
+    function ``np.matmul`` for python versions below 3.5.)
+
+    If `a` is a ``matrix`` object (as opposed to an ``ndarray``), then so are
+    all the return values.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> rng = np.random.default_rng()
+    >>> a = rng.normal(size=(9, 6)) + 1j*rng.normal(size=(9, 6))
+    >>> b = rng.normal(size=(2, 7, 8, 3)) + 1j*rng.normal(size=(2, 7, 8, 3))
+
+
+    Reconstruction based on full SVD, 2D case:
+
+    >>> U, S, Vh = np.linalg.svd(a, full_matrices=True)
+    >>> U.shape, S.shape, Vh.shape
+    ((9, 9), (6,), (6, 6))
+    >>> np.allclose(a, np.dot(U[:, :6] * S, Vh))
+    True
+    >>> smat = np.zeros((9, 6), dtype=complex)
+    >>> smat[:6, :6] = np.diag(S)
+    >>> np.allclose(a, np.dot(U, np.dot(smat, Vh)))
+    True
+
+    Reconstruction based on reduced SVD, 2D case:
+
+    >>> U, S, Vh = np.linalg.svd(a, full_matrices=False)
+    >>> U.shape, S.shape, Vh.shape
+    ((9, 6), (6,), (6, 6))
+    >>> np.allclose(a, np.dot(U * S, Vh))
+    True
+    >>> smat = np.diag(S)
+    >>> np.allclose(a, np.dot(U, np.dot(smat, Vh)))
+    True
+
+    Reconstruction based on full SVD, 4D case:
+
+    >>> U, S, Vh = np.linalg.svd(b, full_matrices=True)
+    >>> U.shape, S.shape, Vh.shape
+    ((2, 7, 8, 8), (2, 7, 3), (2, 7, 3, 3))
+    >>> np.allclose(b, np.matmul(U[..., :3] * S[..., None, :], Vh))
+    True
+    >>> np.allclose(b, np.matmul(U[..., :3], S[..., None] * Vh))
+    True
+
+    Reconstruction based on reduced SVD, 4D case:
+
+    >>> U, S, Vh = np.linalg.svd(b, full_matrices=False)
+    >>> U.shape, S.shape, Vh.shape
+    ((2, 7, 8, 3), (2, 7, 3), (2, 7, 3, 3))
+    >>> np.allclose(b, np.matmul(U * S[..., None, :], Vh))
+    True
+    >>> np.allclose(b, np.matmul(U, S[..., None] * Vh))
+    True
+
+    """
+    import numpy as _nx
+    a, wrap = _makearray(a)
+
+    if hermitian:
+        # note: lapack svd returns eigenvalues with s ** 2 sorted descending,
+        # but eig returns s sorted ascending, so we re-order the eigenvalues
+        # and related arrays to have the correct order
+        if compute_uv:
+            s, u = eigh(a)
+            sgn = sign(s)
+            s = abs(s)
+            sidx = argsort(s)[..., ::-1]
+            sgn = _nx.take_along_axis(sgn, sidx, axis=-1)
+            s = _nx.take_along_axis(s, sidx, axis=-1)
+            u = _nx.take_along_axis(u, sidx[..., None, :], axis=-1)
+            # singular values are unsigned, move the sign into v
+            vt = transpose(u * sgn[..., None, :]).conjugate()
+            return SVDResult(wrap(u), s, wrap(vt))
+        else:
+            s = eigvalsh(a)
+            s = abs(s)
+            return sort(s)[..., ::-1]
+
+    _assert_stacked_2d(a)
+    t, result_t = _commonType(a)
+
+    m, n = a.shape[-2:]
+    if compute_uv:
+        if full_matrices:
+            gufunc = _umath_linalg.svd_f
+        else:
+            gufunc = _umath_linalg.svd_s
+
+        signature = 'D->DdD' if isComplexType(t) else 'd->ddd'
+        with errstate(call=_raise_linalgerror_svd_nonconvergence,
+                      invalid='call', over='ignore', divide='ignore',
+                      under='ignore'):
+            u, s, vh = gufunc(a, signature=signature)
+        u = u.astype(result_t, copy=False)
+        s = s.astype(_realType(result_t), copy=False)
+        vh = vh.astype(result_t, copy=False)
+        return SVDResult(wrap(u), s, wrap(vh))
+    else:
+        signature = 'D->d' if isComplexType(t) else 'd->d'
+        with errstate(call=_raise_linalgerror_svd_nonconvergence,
+                      invalid='call', over='ignore', divide='ignore',
+                      under='ignore'):
+            s = _umath_linalg.svd(a, signature=signature)
+        s = s.astype(_realType(result_t), copy=False)
+        return s
+
+
+def _svdvals_dispatcher(x):
+    return (x,)
+
+
+@array_function_dispatch(_svdvals_dispatcher)
+def svdvals(x, /):
+    """
+    Returns the singular values of a matrix (or a stack of matrices) ``x``.
+    When x is a stack of matrices, the function will compute the singular
+    values for each matrix in the stack.
+
+    This function is Array API compatible.
+
+    Calling ``np.svdvals(x)`` to get singular values is the same as
+    ``np.svd(x, compute_uv=False, hermitian=False)``.
+
+    Parameters
+    ----------
+    x : (..., M, N) array_like
+        Input array having shape (..., M, N) and whose last two
+        dimensions form matrices on which to perform singular value
+        decomposition. Should have a floating-point data type.
+
+    Returns
+    -------
+    out : ndarray
+        An array with shape (..., K) that contains the vector(s)
+        of singular values of length K, where K = min(M, N).
+
+    See Also
+    --------
+    scipy.linalg.svdvals : Compute singular values of a matrix.
+
+    Examples
+    --------
+
+    >>> np.linalg.svdvals([[1, 2, 3, 4, 5],
+    ...                    [1, 4, 9, 16, 25],
+    ...                    [1, 8, 27, 64, 125]])
+    array([146.68862757,   5.57510612,   0.60393245])
+
+    Determine the rank of a matrix using singular values:
+
+    >>> s = np.linalg.svdvals([[1, 2, 3],
+    ...                        [2, 4, 6],
+    ...                        [-1, 1, -1]]); s
+    array([8.38434191e+00, 1.64402274e+00, 2.31534378e-16])
+    >>> np.count_nonzero(s > 1e-10)  # Matrix of rank 2
+    2
+
+    """
+    return svd(x, compute_uv=False, hermitian=False)
+
+
+def _cond_dispatcher(x, p=None):
+    return (x,)
+
+
+@array_function_dispatch(_cond_dispatcher)
+def cond(x, p=None):
+    """
+    Compute the condition number of a matrix.
+
+    This function is capable of returning the condition number using
+    one of seven different norms, depending on the value of `p` (see
+    Parameters below).
+
+    Parameters
+    ----------
+    x : (..., M, N) array_like
+        The matrix whose condition number is sought.
+    p : {None, 1, -1, 2, -2, inf, -inf, 'fro'}, optional
+        Order of the norm used in the condition number computation:
+
+        =====  ============================
+        p      norm for matrices
+        =====  ============================
+        None   2-norm, computed directly using the ``SVD``
+        'fro'  Frobenius norm
+        inf    max(sum(abs(x), axis=1))
+        -inf   min(sum(abs(x), axis=1))
+        1      max(sum(abs(x), axis=0))
+        -1     min(sum(abs(x), axis=0))
+        2      2-norm (largest sing. value)
+        -2     smallest singular value
+        =====  ============================
+
+        inf means the `numpy.inf` object, and the Frobenius norm is
+        the root-of-sum-of-squares norm.
+
+    Returns
+    -------
+    c : {float, inf}
+        The condition number of the matrix. May be infinite.
+
+    See Also
+    --------
+    numpy.linalg.norm
+
+    Notes
+    -----
+    The condition number of `x` is defined as the norm of `x` times the
+    norm of the inverse of `x` [1]_; the norm can be the usual L2-norm
+    (root-of-sum-of-squares) or one of a number of other matrix norms.
+
+    References
+    ----------
+    .. [1] G. Strang, *Linear Algebra and Its Applications*, Orlando, FL,
+           Academic Press, Inc., 1980, pg. 285.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from numpy import linalg as LA
+    >>> a = np.array([[1, 0, -1], [0, 1, 0], [1, 0, 1]])
+    >>> a
+    array([[ 1,  0, -1],
+           [ 0,  1,  0],
+           [ 1,  0,  1]])
+    >>> LA.cond(a)
+    1.4142135623730951
+    >>> LA.cond(a, 'fro')
+    3.1622776601683795
+    >>> LA.cond(a, np.inf)
+    2.0
+    >>> LA.cond(a, -np.inf)
+    1.0
+    >>> LA.cond(a, 1)
+    2.0
+    >>> LA.cond(a, -1)
+    1.0
+    >>> LA.cond(a, 2)
+    1.4142135623730951
+    >>> LA.cond(a, -2)
+    0.70710678118654746 # may vary
+    >>> (min(LA.svd(a, compute_uv=False)) *
+    ... min(LA.svd(LA.inv(a), compute_uv=False)))
+    0.70710678118654746 # may vary
+
+    """
+    x = asarray(x)  # in case we have a matrix
+    if _is_empty_2d(x):
+        raise LinAlgError("cond is not defined on empty arrays")
+    if p is None or p == 2 or p == -2:
+        s = svd(x, compute_uv=False)
+        with errstate(all='ignore'):
+            if p == -2:
+                r = s[..., -1] / s[..., 0]
+            else:
+                r = s[..., 0] / s[..., -1]
+    else:
+        # Call inv(x) ignoring errors. The result array will
+        # contain nans in the entries where inversion failed.
+        _assert_stacked_2d(x)
+        _assert_stacked_square(x)
+        t, result_t = _commonType(x)
+        signature = 'D->D' if isComplexType(t) else 'd->d'
+        with errstate(all='ignore'):
+            invx = _umath_linalg.inv(x, signature=signature)
+            r = norm(x, p, axis=(-2, -1)) * norm(invx, p, axis=(-2, -1))
+        r = r.astype(result_t, copy=False)
+
+    # Convert nans to infs unless the original array had nan entries
+    r = asarray(r)
+    nan_mask = isnan(r)
+    if nan_mask.any():
+        nan_mask &= ~isnan(x).any(axis=(-2, -1))
+        if r.ndim > 0:
+            r[nan_mask] = inf
+        elif nan_mask:
+            r[()] = inf
+
+    # Convention is to return scalars instead of 0d arrays
+    if r.ndim == 0:
+        r = r[()]
+
+    return r
+
+
+def _matrix_rank_dispatcher(A, tol=None, hermitian=None, *, rtol=None):
+    return (A,)
+
+
+@array_function_dispatch(_matrix_rank_dispatcher)
+def matrix_rank(A, tol=None, hermitian=False, *, rtol=None):
+    """
+    Return matrix rank of array using SVD method
+
+    Rank of the array is the number of singular values of the array that are
+    greater than `tol`.
+
+    .. versionchanged:: 1.14
+       Can now operate on stacks of matrices
+
+    Parameters
+    ----------
+    A : {(M,), (..., M, N)} array_like
+        Input vector or stack of matrices.
+    tol : (...) array_like, float, optional
+        Threshold below which SVD values are considered zero. If `tol` is
+        None, and ``S`` is an array with singular values for `M`, and
+        ``eps`` is the epsilon value for datatype of ``S``, then `tol` is
+        set to ``S.max() * max(M, N) * eps``.
+
+        .. versionchanged:: 1.14
+           Broadcasted against the stack of matrices
+    hermitian : bool, optional
+        If True, `A` is assumed to be Hermitian (symmetric if real-valued),
+        enabling a more efficient method for finding singular values.
+        Defaults to False.
+
+        .. versionadded:: 1.14
+    rtol : (...) array_like, float, optional
+        Parameter for the relative tolerance component. Only ``tol`` or
+        ``rtol`` can be set at a time. Defaults to ``max(M, N) * eps``.
+
+        .. versionadded:: 2.0.0
+
+    Returns
+    -------
+    rank : (...) array_like
+        Rank of A.
+
+    Notes
+    -----
+    The default threshold to detect rank deficiency is a test on the magnitude
+    of the singular values of `A`.  By default, we identify singular values
+    less than ``S.max() * max(M, N) * eps`` as indicating rank deficiency
+    (with the symbols defined above). This is the algorithm MATLAB uses [1].
+    It also appears in *Numerical recipes* in the discussion of SVD solutions
+    for linear least squares [2].
+
+    This default threshold is designed to detect rank deficiency accounting
+    for the numerical errors of the SVD computation. Imagine that there
+    is a column in `A` that is an exact (in floating point) linear combination
+    of other columns in `A`. Computing the SVD on `A` will not produce
+    a singular value exactly equal to 0 in general: any difference of
+    the smallest SVD value from 0 will be caused by numerical imprecision
+    in the calculation of the SVD. Our threshold for small SVD values takes
+    this numerical imprecision into account, and the default threshold will
+    detect such numerical rank deficiency. The threshold may declare a matrix
+    `A` rank deficient even if the linear combination of some columns of `A`
+    is not exactly equal to another column of `A` but only numerically very
+    close to another column of `A`.
+
+    We chose our default threshold because it is in wide use. Other thresholds
+    are possible.  For example, elsewhere in the 2007 edition of *Numerical
+    recipes* there is an alternative threshold of ``S.max() *
+    np.finfo(A.dtype).eps / 2. * np.sqrt(m + n + 1.)``. The authors describe
+    this threshold as being based on "expected roundoff error" (p 71).
+
+    The thresholds above deal with floating point roundoff error in the
+    calculation of the SVD.  However, you may have more information about
+    the sources of error in `A` that would make you consider other tolerance
+    values to detect *effective* rank deficiency. The most useful measure
+    of the tolerance depends on the operations you intend to use on your
+    matrix. For example, if your data come from uncertain measurements with
+    uncertainties greater than floating point epsilon, choosing a tolerance
+    near that uncertainty may be preferable. The tolerance may be absolute
+    if the uncertainties are absolute rather than relative.
+
+    References
+    ----------
+    .. [1] MATLAB reference documentation, "Rank"
+           https://www.mathworks.com/help/techdoc/ref/rank.html
+    .. [2] W. H. Press, S. A. Teukolsky, W. T. Vetterling and B. P. Flannery,
+           "Numerical Recipes (3rd edition)", Cambridge University Press, 2007,
+           page 795.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from numpy.linalg import matrix_rank
+    >>> matrix_rank(np.eye(4)) # Full rank matrix
+    4
+    >>> I=np.eye(4); I[-1,-1] = 0. # rank deficient matrix
+    >>> matrix_rank(I)
+    3
+    >>> matrix_rank(np.ones((4,))) # 1 dimension - rank 1 unless all 0
+    1
+    >>> matrix_rank(np.zeros((4,)))
+    0
+    """
+    if rtol is not None and tol is not None:
+        raise ValueError("`tol` and `rtol` can't be both set.")
+
+    A = asarray(A)
+    if A.ndim < 2:
+        return int(not all(A == 0))
+    S = svd(A, compute_uv=False, hermitian=hermitian)
+
+    if tol is None:
+        if rtol is None:
+            rtol = max(A.shape[-2:]) * finfo(S.dtype).eps
+        else:
+            rtol = asarray(rtol)[..., newaxis]
+        tol = S.max(axis=-1, keepdims=True) * rtol
+    else:
+        tol = asarray(tol)[..., newaxis]
+
+    return count_nonzero(S > tol, axis=-1)
+
+
+# Generalized inverse
+
+def _pinv_dispatcher(a, rcond=None, hermitian=None, *, rtol=None):
+    return (a,)
+
+
+@array_function_dispatch(_pinv_dispatcher)
+def pinv(a, rcond=None, hermitian=False, *, rtol=_NoValue):
+    """
+    Compute the (Moore-Penrose) pseudo-inverse of a matrix.
+
+    Calculate the generalized inverse of a matrix using its
+    singular-value decomposition (SVD) and including all
+    *large* singular values.
+
+    .. versionchanged:: 1.14
+       Can now operate on stacks of matrices
+
+    Parameters
+    ----------
+    a : (..., M, N) array_like
+        Matrix or stack of matrices to be pseudo-inverted.
+    rcond : (...) array_like of float, optional
+        Cutoff for small singular values.
+        Singular values less than or equal to
+        ``rcond * largest_singular_value`` are set to zero.
+        Broadcasts against the stack of matrices. Default: ``1e-15``.
+    hermitian : bool, optional
+        If True, `a` is assumed to be Hermitian (symmetric if real-valued),
+        enabling a more efficient method for finding singular values.
+        Defaults to False.
+
+        .. versionadded:: 1.17.0
+    rtol : (...) array_like of float, optional
+        Same as `rcond`, but it's an Array API compatible parameter name.
+        Only `rcond` or `rtol` can be set at a time. If none of them are
+        provided then NumPy's ``1e-15`` default is used. If ``rtol=None``
+        is passed then the API standard default is used.
+
+        .. versionadded:: 2.0.0
+
+    Returns
+    -------
+    B : (..., N, M) ndarray
+        The pseudo-inverse of `a`. If `a` is a `matrix` instance, then so
+        is `B`.
+
+    Raises
+    ------
+    LinAlgError
+        If the SVD computation does not converge.
+
+    See Also
+    --------
+    scipy.linalg.pinv : Similar function in SciPy.
+    scipy.linalg.pinvh : Compute the (Moore-Penrose) pseudo-inverse of a
+                         Hermitian matrix.
+
+    Notes
+    -----
+    The pseudo-inverse of a matrix A, denoted :math:`A^+`, is
+    defined as: "the matrix that 'solves' [the least-squares problem]
+    :math:`Ax = b`," i.e., if :math:`\\bar{x}` is said solution, then
+    :math:`A^+` is that matrix such that :math:`\\bar{x} = A^+b`.
+
+    It can be shown that if :math:`Q_1 \\Sigma Q_2^T = A` is the singular
+    value decomposition of A, then
+    :math:`A^+ = Q_2 \\Sigma^+ Q_1^T`, where :math:`Q_{1,2}` are
+    orthogonal matrices, :math:`\\Sigma` is a diagonal matrix consisting
+    of A's so-called singular values, (followed, typically, by
+    zeros), and then :math:`\\Sigma^+` is simply the diagonal matrix
+    consisting of the reciprocals of A's singular values
+    (again, followed by zeros). [1]_
+
+    References
+    ----------
+    .. [1] G. Strang, *Linear Algebra and Its Applications*, 2nd Ed., Orlando,
+           FL, Academic Press, Inc., 1980, pp. 139-142.
+
+    Examples
+    --------
+    The following example checks that ``a * a+ * a == a`` and
+    ``a+ * a * a+ == a+``:
+
+    >>> import numpy as np
+    >>> rng = np.random.default_rng()
+    >>> a = rng.normal(size=(9, 6))
+    >>> B = np.linalg.pinv(a)
+    >>> np.allclose(a, np.dot(a, np.dot(B, a)))
+    True
+    >>> np.allclose(B, np.dot(B, np.dot(a, B)))
+    True
+
+    """
+    a, wrap = _makearray(a)
+    if rcond is None:
+        if rtol is _NoValue:
+            rcond = 1e-15
+        elif rtol is None:
+            rcond = max(a.shape[-2:]) * finfo(a.dtype).eps
+        else:
+            rcond = rtol
+    elif rtol is not _NoValue:
+        raise ValueError("`rtol` and `rcond` can't be both set.")
+    else:
+        # NOTE: Deprecate `rcond` in a few versions.
+        pass
+
+    rcond = asarray(rcond)
+    if _is_empty_2d(a):
+        m, n = a.shape[-2:]
+        res = empty(a.shape[:-2] + (n, m), dtype=a.dtype)
+        return wrap(res)
+    a = a.conjugate()
+    u, s, vt = svd(a, full_matrices=False, hermitian=hermitian)
+
+    # discard small singular values
+    cutoff = rcond[..., newaxis] * amax(s, axis=-1, keepdims=True)
+    large = s > cutoff
+    s = divide(1, s, where=large, out=s)
+    s[~large] = 0
+
+    res = matmul(transpose(vt), multiply(s[..., newaxis], transpose(u)))
+    return wrap(res)
+
+
+# Determinant
+
+
+@array_function_dispatch(_unary_dispatcher)
+def slogdet(a):
+    """
+    Compute the sign and (natural) logarithm of the determinant of an array.
+
+    If an array has a very small or very large determinant, then a call to
+    `det` may overflow or underflow. This routine is more robust against such
+    issues, because it computes the logarithm of the determinant rather than
+    the determinant itself.
+
+    Parameters
+    ----------
+    a : (..., M, M) array_like
+        Input array, has to be a square 2-D array.
+
+    Returns
+    -------
+    A namedtuple with the following attributes:
+
+    sign : (...) array_like
+        A number representing the sign of the determinant. For a real matrix,
+        this is 1, 0, or -1. For a complex matrix, this is a complex number
+        with absolute value 1 (i.e., it is on the unit circle), or else 0.
+    logabsdet : (...) array_like
+        The natural log of the absolute value of the determinant.
+
+    If the determinant is zero, then `sign` will be 0 and `logabsdet`
+    will be -inf. In all cases, the determinant is equal to
+    ``sign * np.exp(logabsdet)``.
+
+    See Also
+    --------
+    det
+
+    Notes
+    -----
+
+    .. versionadded:: 1.8.0
+
+    Broadcasting rules apply, see the `numpy.linalg` documentation for
+    details.
+
+    .. versionadded:: 1.6.0
+
+    The determinant is computed via LU factorization using the LAPACK
+    routine ``z/dgetrf``.
+
+
+    Examples
+    --------
+    The determinant of a 2-D array ``[[a, b], [c, d]]`` is ``ad - bc``:
+
+    >>> import numpy as np
+    >>> a = np.array([[1, 2], [3, 4]])
+    >>> (sign, logabsdet) = np.linalg.slogdet(a)
+    >>> (sign, logabsdet)
+    (-1, 0.69314718055994529) # may vary
+    >>> sign * np.exp(logabsdet)
+    -2.0
+
+    Computing log-determinants for a stack of matrices:
+
+    >>> a = np.array([ [[1, 2], [3, 4]], [[1, 2], [2, 1]], [[1, 3], [3, 1]] ])
+    >>> a.shape
+    (3, 2, 2)
+    >>> sign, logabsdet = np.linalg.slogdet(a)
+    >>> (sign, logabsdet)
+    (array([-1., -1., -1.]), array([ 0.69314718,  1.09861229,  2.07944154]))
+    >>> sign * np.exp(logabsdet)
+    array([-2., -3., -8.])
+
+    This routine succeeds where ordinary `det` does not:
+
+    >>> np.linalg.det(np.eye(500) * 0.1)
+    0.0
+    >>> np.linalg.slogdet(np.eye(500) * 0.1)
+    (1, -1151.2925464970228)
+
+    """
+    a = asarray(a)
+    _assert_stacked_2d(a)
+    _assert_stacked_square(a)
+    t, result_t = _commonType(a)
+    real_t = _realType(result_t)
+    signature = 'D->Dd' if isComplexType(t) else 'd->dd'
+    sign, logdet = _umath_linalg.slogdet(a, signature=signature)
+    sign = sign.astype(result_t, copy=False)
+    logdet = logdet.astype(real_t, copy=False)
+    return SlogdetResult(sign, logdet)
+
+
+@array_function_dispatch(_unary_dispatcher)
+def det(a):
+    """
+    Compute the determinant of an array.
+
+    Parameters
+    ----------
+    a : (..., M, M) array_like
+        Input array to compute determinants for.
+
+    Returns
+    -------
+    det : (...) array_like
+        Determinant of `a`.
+
+    See Also
+    --------
+    slogdet : Another way to represent the determinant, more suitable
+      for large matrices where underflow/overflow may occur.
+    scipy.linalg.det : Similar function in SciPy.
+
+    Notes
+    -----
+
+    .. versionadded:: 1.8.0
+
+    Broadcasting rules apply, see the `numpy.linalg` documentation for
+    details.
+
+    The determinant is computed via LU factorization using the LAPACK
+    routine ``z/dgetrf``.
+
+    Examples
+    --------
+    The determinant of a 2-D array [[a, b], [c, d]] is ad - bc:
+
+    >>> import numpy as np
+    >>> a = np.array([[1, 2], [3, 4]])
+    >>> np.linalg.det(a)
+    -2.0 # may vary
+
+    Computing determinants for a stack of matrices:
+
+    >>> a = np.array([ [[1, 2], [3, 4]], [[1, 2], [2, 1]], [[1, 3], [3, 1]] ])
+    >>> a.shape
+    (3, 2, 2)
+    >>> np.linalg.det(a)
+    array([-2., -3., -8.])
+
+    """
+    a = asarray(a)
+    _assert_stacked_2d(a)
+    _assert_stacked_square(a)
+    t, result_t = _commonType(a)
+    signature = 'D->D' if isComplexType(t) else 'd->d'
+    r = _umath_linalg.det(a, signature=signature)
+    r = r.astype(result_t, copy=False)
+    return r
+
+
+# Linear Least Squares
+
+def _lstsq_dispatcher(a, b, rcond=None):
+    return (a, b)
+
+
+@array_function_dispatch(_lstsq_dispatcher)
+def lstsq(a, b, rcond=None):
+    r"""
+    Return the least-squares solution to a linear matrix equation.
+
+    Computes the vector `x` that approximately solves the equation
+    ``a @ x = b``. The equation may be under-, well-, or over-determined
+    (i.e., the number of linearly independent rows of `a` can be less than,
+    equal to, or greater than its number of linearly independent columns).
+    If `a` is square and of full rank, then `x` (but for round-off error)
+    is the "exact" solution of the equation. Else, `x` minimizes the
+    Euclidean 2-norm :math:`||b - ax||`. If there are multiple minimizing
+    solutions, the one with the smallest 2-norm :math:`||x||` is returned.
+
+    Parameters
+    ----------
+    a : (M, N) array_like
+        "Coefficient" matrix.
+    b : {(M,), (M, K)} array_like
+        Ordinate or "dependent variable" values. If `b` is two-dimensional,
+        the least-squares solution is calculated for each of the `K` columns
+        of `b`.
+    rcond : float, optional
+        Cut-off ratio for small singular values of `a`.
+        For the purposes of rank determination, singular values are treated
+        as zero if they are smaller than `rcond` times the largest singular
+        value of `a`.
+        The default uses the machine precision times ``max(M, N)``.  Passing
+        ``-1`` will use machine precision.
+
+        .. versionchanged:: 2.0
+            Previously, the default was ``-1``, but a warning was given that
+            this would change.
+
+    Returns
+    -------
+    x : {(N,), (N, K)} ndarray
+        Least-squares solution. If `b` is two-dimensional,
+        the solutions are in the `K` columns of `x`.
+    residuals : {(1,), (K,), (0,)} ndarray
+        Sums of squared residuals: Squared Euclidean 2-norm for each column in
+        ``b - a @ x``.
+        If the rank of `a` is < N or M <= N, this is an empty array.
+        If `b` is 1-dimensional, this is a (1,) shape array.
+        Otherwise the shape is (K,).
+    rank : int
+        Rank of matrix `a`.
+    s : (min(M, N),) ndarray
+        Singular values of `a`.
+
+    Raises
+    ------
+    LinAlgError
+        If computation does not converge.
+
+    See Also
+    --------
+    scipy.linalg.lstsq : Similar function in SciPy.
+
+    Notes
+    -----
+    If `b` is a matrix, then all array results are returned as matrices.
+
+    Examples
+    --------
+    Fit a line, ``y = mx + c``, through some noisy data-points:
+
+    >>> import numpy as np
+    >>> x = np.array([0, 1, 2, 3])
+    >>> y = np.array([-1, 0.2, 0.9, 2.1])
+
+    By examining the coefficients, we see that the line should have a
+    gradient of roughly 1 and cut the y-axis at, more or less, -1.
+
+    We can rewrite the line equation as ``y = Ap``, where ``A = [[x 1]]``
+    and ``p = [[m], [c]]``.  Now use `lstsq` to solve for `p`:
+
+    >>> A = np.vstack([x, np.ones(len(x))]).T
+    >>> A
+    array([[ 0.,  1.],
+           [ 1.,  1.],
+           [ 2.,  1.],
+           [ 3.,  1.]])
+
+    >>> m, c = np.linalg.lstsq(A, y)[0]
+    >>> m, c
+    (1.0 -0.95) # may vary
+
+    Plot the data along with the fitted line:
+
+    >>> import matplotlib.pyplot as plt
+    >>> _ = plt.plot(x, y, 'o', label='Original data', markersize=10)
+    >>> _ = plt.plot(x, m*x + c, 'r', label='Fitted line')
+    >>> _ = plt.legend()
+    >>> plt.show()
+
+    """
+    a, _ = _makearray(a)
+    b, wrap = _makearray(b)
+    is_1d = b.ndim == 1
+    if is_1d:
+        b = b[:, newaxis]
+    _assert_2d(a, b)
+    m, n = a.shape[-2:]
+    m2, n_rhs = b.shape[-2:]
+    if m != m2:
+        raise LinAlgError('Incompatible dimensions')
+
+    t, result_t = _commonType(a, b)
+    result_real_t = _realType(result_t)
+
+    if rcond is None:
+        rcond = finfo(t).eps * max(n, m)
+
+    signature = 'DDd->Ddid' if isComplexType(t) else 'ddd->ddid'
+    if n_rhs == 0:
+        # lapack can't handle n_rhs = 0 - so allocate
+        # the array one larger in that axis
+        b = zeros(b.shape[:-2] + (m, n_rhs + 1), dtype=b.dtype)
+
+    with errstate(call=_raise_linalgerror_lstsq, invalid='call',
+                  over='ignore', divide='ignore', under='ignore'):
+        x, resids, rank, s = _umath_linalg.lstsq(a, b, rcond,
+                                                 signature=signature)
+    if m == 0:
+        x[...] = 0
+    if n_rhs == 0:
+        # remove the item we added
+        x = x[..., :n_rhs]
+        resids = resids[..., :n_rhs]
+
+    # remove the axis we added
+    if is_1d:
+        x = x.squeeze(axis=-1)
+        # we probably should squeeze resids too, but we can't
+        # without breaking compatibility.
+
+    # as documented
+    if rank != n or m <= n:
+        resids = array([], result_real_t)
+
+    # coerce output arrays
+    s = s.astype(result_real_t, copy=False)
+    resids = resids.astype(result_real_t, copy=False)
+    # Copying lets the memory in r_parts be freed
+    x = x.astype(result_t, copy=True)
+    return wrap(x), wrap(resids), rank, s
+
+
+def _multi_svd_norm(x, row_axis, col_axis, op):
+    """Compute a function of the singular values of the 2-D matrices in `x`.
+
+    This is a private utility function used by `numpy.linalg.norm()`.
+
+    Parameters
+    ----------
+    x : ndarray
+    row_axis, col_axis : int
+        The axes of `x` that hold the 2-D matrices.
+    op : callable
+        This should be either numpy.amin or `numpy.amax` or `numpy.sum`.
+
+    Returns
+    -------
+    result : float or ndarray
+        If `x` is 2-D, the return values is a float.
+        Otherwise, it is an array with ``x.ndim - 2`` dimensions.
+        The return values are either the minimum or maximum or sum of the
+        singular values of the matrices, depending on whether `op`
+        is `numpy.amin` or `numpy.amax` or `numpy.sum`.
+
+    """
+    y = moveaxis(x, (row_axis, col_axis), (-2, -1))
+    result = op(svd(y, compute_uv=False), axis=-1)
+    return result
+
+
+def _norm_dispatcher(x, ord=None, axis=None, keepdims=None):
+    return (x,)
+
+
+@array_function_dispatch(_norm_dispatcher)
+def norm(x, ord=None, axis=None, keepdims=False):
+    """
+    Matrix or vector norm.
+
+    This function is able to return one of eight different matrix norms,
+    or one of an infinite number of vector norms (described below), depending
+    on the value of the ``ord`` parameter.
+
+    Parameters
+    ----------
+    x : array_like
+        Input array.  If `axis` is None, `x` must be 1-D or 2-D, unless `ord`
+        is None. If both `axis` and `ord` are None, the 2-norm of
+        ``x.ravel`` will be returned.
+    ord : {non-zero int, inf, -inf, 'fro', 'nuc'}, optional
+        Order of the norm (see table under ``Notes``). inf means numpy's
+        `inf` object. The default is None.
+    axis : {None, int, 2-tuple of ints}, optional.
+        If `axis` is an integer, it specifies the axis of `x` along which to
+        compute the vector norms.  If `axis` is a 2-tuple, it specifies the
+        axes that hold 2-D matrices, and the matrix norms of these matrices
+        are computed.  If `axis` is None then either a vector norm (when `x`
+        is 1-D) or a matrix norm (when `x` is 2-D) is returned. The default
+        is None.
+
+        .. versionadded:: 1.8.0
+
+    keepdims : bool, optional
+        If this is set to True, the axes which are normed over are left in the
+        result as dimensions with size one.  With this option the result will
+        broadcast correctly against the original `x`.
+
+        .. versionadded:: 1.10.0
+
+    Returns
+    -------
+    n : float or ndarray
+        Norm of the matrix or vector(s).
+
+    See Also
+    --------
+    scipy.linalg.norm : Similar function in SciPy.
+
+    Notes
+    -----
+    For values of ``ord < 1``, the result is, strictly speaking, not a
+    mathematical 'norm', but it may still be useful for various numerical
+    purposes.
+
+    The following norms can be calculated:
+
+    =====  ============================  ==========================
+    ord    norm for matrices             norm for vectors
+    =====  ============================  ==========================
+    None   Frobenius norm                2-norm
+    'fro'  Frobenius norm                --
+    'nuc'  nuclear norm                  --
+    inf    max(sum(abs(x), axis=1))      max(abs(x))
+    -inf   min(sum(abs(x), axis=1))      min(abs(x))
+    0      --                            sum(x != 0)
+    1      max(sum(abs(x), axis=0))      as below
+    -1     min(sum(abs(x), axis=0))      as below
+    2      2-norm (largest sing. value)  as below
+    -2     smallest singular value       as below
+    other  --                            sum(abs(x)**ord)**(1./ord)
+    =====  ============================  ==========================
+
+    The Frobenius norm is given by [1]_:
+
+    :math:`||A||_F = [\\sum_{i,j} abs(a_{i,j})^2]^{1/2}`
+
+    The nuclear norm is the sum of the singular values.
+
+    Both the Frobenius and nuclear norm orders are only defined for
+    matrices and raise a ValueError when ``x.ndim != 2``.
+
+    References
+    ----------
+    .. [1] G. H. Golub and C. F. Van Loan, *Matrix Computations*,
+           Baltimore, MD, Johns Hopkins University Press, 1985, pg. 15
+
+    Examples
+    --------
+
+    >>> import numpy as np
+    >>> from numpy import linalg as LA
+    >>> a = np.arange(9) - 4
+    >>> a
+    array([-4, -3, -2, ...,  2,  3,  4])
+    >>> b = a.reshape((3, 3))
+    >>> b
+    array([[-4, -3, -2],
+           [-1,  0,  1],
+           [ 2,  3,  4]])
+
+    >>> LA.norm(a)
+    7.745966692414834
+    >>> LA.norm(b)
+    7.745966692414834
+    >>> LA.norm(b, 'fro')
+    7.745966692414834
+    >>> LA.norm(a, np.inf)
+    4.0
+    >>> LA.norm(b, np.inf)
+    9.0
+    >>> LA.norm(a, -np.inf)
+    0.0
+    >>> LA.norm(b, -np.inf)
+    2.0
+
+    >>> LA.norm(a, 1)
+    20.0
+    >>> LA.norm(b, 1)
+    7.0
+    >>> LA.norm(a, -1)
+    -4.6566128774142013e-010
+    >>> LA.norm(b, -1)
+    6.0
+    >>> LA.norm(a, 2)
+    7.745966692414834
+    >>> LA.norm(b, 2)
+    7.3484692283495345
+
+    >>> LA.norm(a, -2)
+    0.0
+    >>> LA.norm(b, -2)
+    1.8570331885190563e-016 # may vary
+    >>> LA.norm(a, 3)
+    5.8480354764257312 # may vary
+    >>> LA.norm(a, -3)
+    0.0
+
+    Using the `axis` argument to compute vector norms:
+
+    >>> c = np.array([[ 1, 2, 3],
+    ...               [-1, 1, 4]])
+    >>> LA.norm(c, axis=0)
+    array([ 1.41421356,  2.23606798,  5.        ])
+    >>> LA.norm(c, axis=1)
+    array([ 3.74165739,  4.24264069])
+    >>> LA.norm(c, ord=1, axis=1)
+    array([ 6.,  6.])
+
+    Using the `axis` argument to compute matrix norms:
+
+    >>> m = np.arange(8).reshape(2,2,2)
+    >>> LA.norm(m, axis=(1,2))
+    array([  3.74165739,  11.22497216])
+    >>> LA.norm(m[0, :, :]), LA.norm(m[1, :, :])
+    (3.7416573867739413, 11.224972160321824)
+
+    """
+    x = asarray(x)
+
+    if not issubclass(x.dtype.type, (inexact, object_)):
+        x = x.astype(float)
+
+    # Immediately handle some default, simple, fast, and common cases.
+    if axis is None:
+        ndim = x.ndim
+        if (
+            (ord is None) or
+            (ord in ('f', 'fro') and ndim == 2) or
+            (ord == 2 and ndim == 1)
+        ):
+            x = x.ravel(order='K')
+            if isComplexType(x.dtype.type):
+                x_real = x.real
+                x_imag = x.imag
+                sqnorm = x_real.dot(x_real) + x_imag.dot(x_imag)
+            else:
+                sqnorm = x.dot(x)
+            ret = sqrt(sqnorm)
+            if keepdims:
+                ret = ret.reshape(ndim*[1])
+            return ret
+
+    # Normalize the `axis` argument to a tuple.
+    nd = x.ndim
+    if axis is None:
+        axis = tuple(range(nd))
+    elif not isinstance(axis, tuple):
+        try:
+            axis = int(axis)
+        except Exception as e:
+            raise TypeError(
+                "'axis' must be None, an integer or a tuple of integers"
+            ) from e
+        axis = (axis,)
+
+    if len(axis) == 1:
+        if ord == inf:
+            return abs(x).max(axis=axis, keepdims=keepdims)
+        elif ord == -inf:
+            return abs(x).min(axis=axis, keepdims=keepdims)
+        elif ord == 0:
+            # Zero norm
+            return (
+                (x != 0)
+                .astype(x.real.dtype)
+                .sum(axis=axis, keepdims=keepdims)
+            )
+        elif ord == 1:
+            # special case for speedup
+            return add.reduce(abs(x), axis=axis, keepdims=keepdims)
+        elif ord is None or ord == 2:
+            # special case for speedup
+            s = (x.conj() * x).real
+            return sqrt(add.reduce(s, axis=axis, keepdims=keepdims))
+        # None of the str-type keywords for ord ('fro', 'nuc')
+        # are valid for vectors
+        elif isinstance(ord, str):
+            raise ValueError(f"Invalid norm order '{ord}' for vectors")
+        else:
+            absx = abs(x)
+            absx **= ord
+            ret = add.reduce(absx, axis=axis, keepdims=keepdims)
+            ret **= reciprocal(ord, dtype=ret.dtype)
+            return ret
+    elif len(axis) == 2:
+        row_axis, col_axis = axis
+        row_axis = normalize_axis_index(row_axis, nd)
+        col_axis = normalize_axis_index(col_axis, nd)
+        if row_axis == col_axis:
+            raise ValueError('Duplicate axes given.')
+        if ord == 2:
+            ret = _multi_svd_norm(x, row_axis, col_axis, amax)
+        elif ord == -2:
+            ret = _multi_svd_norm(x, row_axis, col_axis, amin)
+        elif ord == 1:
+            if col_axis > row_axis:
+                col_axis -= 1
+            ret = add.reduce(abs(x), axis=row_axis).max(axis=col_axis)
+        elif ord == inf:
+            if row_axis > col_axis:
+                row_axis -= 1
+            ret = add.reduce(abs(x), axis=col_axis).max(axis=row_axis)
+        elif ord == -1:
+            if col_axis > row_axis:
+                col_axis -= 1
+            ret = add.reduce(abs(x), axis=row_axis).min(axis=col_axis)
+        elif ord == -inf:
+            if row_axis > col_axis:
+                row_axis -= 1
+            ret = add.reduce(abs(x), axis=col_axis).min(axis=row_axis)
+        elif ord in [None, 'fro', 'f']:
+            ret = sqrt(add.reduce((x.conj() * x).real, axis=axis))
+        elif ord == 'nuc':
+            ret = _multi_svd_norm(x, row_axis, col_axis, sum)
+        else:
+            raise ValueError("Invalid norm order for matrices.")
+        if keepdims:
+            ret_shape = list(x.shape)
+            ret_shape[axis[0]] = 1
+            ret_shape[axis[1]] = 1
+            ret = ret.reshape(ret_shape)
+        return ret
+    else:
+        raise ValueError("Improper number of dimensions to norm.")
+
+
+# multi_dot
+
+def _multidot_dispatcher(arrays, *, out=None):
+    yield from arrays
+    yield out
+
+
+@array_function_dispatch(_multidot_dispatcher)
+def multi_dot(arrays, *, out=None):
+    """
+    Compute the dot product of two or more arrays in a single function call,
+    while automatically selecting the fastest evaluation order.
+
+    `multi_dot` chains `numpy.dot` and uses optimal parenthesization
+    of the matrices [1]_ [2]_. Depending on the shapes of the matrices,
+    this can speed up the multiplication a lot.
+
+    If the first argument is 1-D it is treated as a row vector.
+    If the last argument is 1-D it is treated as a column vector.
+    The other arguments must be 2-D.
+
+    Think of `multi_dot` as::
+
+        def multi_dot(arrays): return functools.reduce(np.dot, arrays)
+
+
+    Parameters
+    ----------
+    arrays : sequence of array_like
+        If the first argument is 1-D it is treated as row vector.
+        If the last argument is 1-D it is treated as column vector.
+        The other arguments must be 2-D.
+    out : ndarray, optional
+        Output argument. This must have the exact kind that would be returned
+        if it was not used. In particular, it must have the right type, must be
+        C-contiguous, and its dtype must be the dtype that would be returned
+        for `dot(a, b)`. This is a performance feature. Therefore, if these
+        conditions are not met, an exception is raised, instead of attempting
+        to be flexible.
+
+        .. versionadded:: 1.19.0
+
+    Returns
+    -------
+    output : ndarray
+        Returns the dot product of the supplied arrays.
+
+    See Also
+    --------
+    numpy.dot : dot multiplication with two arguments.
+
+    References
+    ----------
+
+    .. [1] Cormen, "Introduction to Algorithms", Chapter 15.2, p. 370-378
+    .. [2] https://en.wikipedia.org/wiki/Matrix_chain_multiplication
+
+    Examples
+    --------
+    `multi_dot` allows you to write::
+
+    >>> import numpy as np
+    >>> from numpy.linalg import multi_dot
+    >>> # Prepare some data
+    >>> A = np.random.random((10000, 100))
+    >>> B = np.random.random((100, 1000))
+    >>> C = np.random.random((1000, 5))
+    >>> D = np.random.random((5, 333))
+    >>> # the actual dot multiplication
+    >>> _ = multi_dot([A, B, C, D])
+
+    instead of::
+
+    >>> _ = np.dot(np.dot(np.dot(A, B), C), D)
+    >>> # or
+    >>> _ = A.dot(B).dot(C).dot(D)
+
+    Notes
+    -----
+    The cost for a matrix multiplication can be calculated with the
+    following function::
+
+        def cost(A, B):
+            return A.shape[0] * A.shape[1] * B.shape[1]
+
+    Assume we have three matrices
+    :math:`A_{10x100}, B_{100x5}, C_{5x50}`.
+
+    The costs for the two different parenthesizations are as follows::
+
+        cost((AB)C) = 10*100*5 + 10*5*50   = 5000 + 2500   = 7500
+        cost(A(BC)) = 10*100*50 + 100*5*50 = 50000 + 25000 = 75000
+
+    """
+    n = len(arrays)
+    # optimization only makes sense for len(arrays) > 2
+    if n < 2:
+        raise ValueError("Expecting at least two arrays.")
+    elif n == 2:
+        return dot(arrays[0], arrays[1], out=out)
+
+    arrays = [asanyarray(a) for a in arrays]
+
+    # save original ndim to reshape the result array into the proper form later
+    ndim_first, ndim_last = arrays[0].ndim, arrays[-1].ndim
+    # Explicitly convert vectors to 2D arrays to keep the logic of the internal
+    # _multi_dot_* functions as simple as possible.
+    if arrays[0].ndim == 1:
+        arrays[0] = atleast_2d(arrays[0])
+    if arrays[-1].ndim == 1:
+        arrays[-1] = atleast_2d(arrays[-1]).T
+    _assert_2d(*arrays)
+
+    # _multi_dot_three is much faster than _multi_dot_matrix_chain_order
+    if n == 3:
+        result = _multi_dot_three(arrays[0], arrays[1], arrays[2], out=out)
+    else:
+        order = _multi_dot_matrix_chain_order(arrays)
+        result = _multi_dot(arrays, order, 0, n - 1, out=out)
+
+    # return proper shape
+    if ndim_first == 1 and ndim_last == 1:
+        return result[0, 0]  # scalar
+    elif ndim_first == 1 or ndim_last == 1:
+        return result.ravel()  # 1-D
+    else:
+        return result
+
+
+def _multi_dot_three(A, B, C, out=None):
+    """
+    Find the best order for three arrays and do the multiplication.
+
+    For three arguments `_multi_dot_three` is approximately 15 times faster
+    than `_multi_dot_matrix_chain_order`
+
+    """
+    a0, a1b0 = A.shape
+    b1c0, c1 = C.shape
+    # cost1 = cost((AB)C) = a0*a1b0*b1c0 + a0*b1c0*c1
+    cost1 = a0 * b1c0 * (a1b0 + c1)
+    # cost2 = cost(A(BC)) = a1b0*b1c0*c1 + a0*a1b0*c1
+    cost2 = a1b0 * c1 * (a0 + b1c0)
+
+    if cost1 < cost2:
+        return dot(dot(A, B), C, out=out)
+    else:
+        return dot(A, dot(B, C), out=out)
+
+
+def _multi_dot_matrix_chain_order(arrays, return_costs=False):
+    """
+    Return a np.array that encodes the optimal order of multiplications.
+
+    The optimal order array is then used by `_multi_dot()` to do the
+    multiplication.
+
+    Also return the cost matrix if `return_costs` is `True`
+
+    The implementation CLOSELY follows Cormen, "Introduction to Algorithms",
+    Chapter 15.2, p. 370-378.  Note that Cormen uses 1-based indices.
+
+        cost[i, j] = min([
+            cost[prefix] + cost[suffix] + cost_mult(prefix, suffix)
+            for k in range(i, j)])
+
+    """
+    n = len(arrays)
+    # p stores the dimensions of the matrices
+    # Example for p: A_{10x100}, B_{100x5}, C_{5x50} --> p = [10, 100, 5, 50]
+    p = [a.shape[0] for a in arrays] + [arrays[-1].shape[1]]
+    # m is a matrix of costs of the subproblems
+    # m[i,j]: min number of scalar multiplications needed to compute A_{i..j}
+    m = zeros((n, n), dtype=double)
+    # s is the actual ordering
+    # s[i, j] is the value of k at which we split the product A_i..A_j
+    s = empty((n, n), dtype=intp)
+
+    for l in range(1, n):
+        for i in range(n - l):
+            j = i + l
+            m[i, j] = inf
+            for k in range(i, j):
+                q = m[i, k] + m[k+1, j] + p[i]*p[k+1]*p[j+1]
+                if q < m[i, j]:
+                    m[i, j] = q
+                    s[i, j] = k  # Note that Cormen uses 1-based index
+
+    return (s, m) if return_costs else s
+
+
+def _multi_dot(arrays, order, i, j, out=None):
+    """Actually do the multiplication with the given order."""
+    if i == j:
+        # the initial call with non-None out should never get here
+        assert out is None
+
+        return arrays[i]
+    else:
+        return dot(_multi_dot(arrays, order, i, order[i, j]),
+                   _multi_dot(arrays, order, order[i, j] + 1, j),
+                   out=out)
+
+
+# diagonal
+
+def _diagonal_dispatcher(x, /, *, offset=None):
+    return (x,)
+
+
+@array_function_dispatch(_diagonal_dispatcher)
+def diagonal(x, /, *, offset=0):
+    """
+    Returns specified diagonals of a matrix (or a stack of matrices) ``x``.
+
+    This function is Array API compatible, contrary to
+    :py:func:`numpy.diagonal`, the matrix is assumed
+    to be defined by the last two dimensions.
+
+    Parameters
+    ----------
+    x : (...,M,N) array_like
+        Input array having shape (..., M, N) and whose innermost two
+        dimensions form MxN matrices.
+    offset : int, optional
+        Offset specifying the off-diagonal relative to the main diagonal,
+        where::
+
+            * offset = 0: the main diagonal.
+            * offset > 0: off-diagonal above the main diagonal.
+            * offset < 0: off-diagonal below the main diagonal.
+
+    Returns
+    -------
+    out : (...,min(N,M)) ndarray
+        An array containing the diagonals and whose shape is determined by
+        removing the last two dimensions and appending a dimension equal to
+        the size of the resulting diagonals. The returned array must have
+        the same data type as ``x``.
+
+    See Also
+    --------
+    numpy.diagonal
+
+    Examples
+    --------
+    >>> a = np.arange(4).reshape(2, 2); a
+    array([[0, 1],
+           [2, 3]])
+    >>> np.linalg.diagonal(a)
+    array([0, 3])
+
+    A 3-D example:
+
+    >>> a = np.arange(8).reshape(2, 2, 2); a
+    array([[[0, 1],
+            [2, 3]],
+           [[4, 5],
+            [6, 7]]])
+    >>> np.linalg.diagonal(a)
+    array([[0, 3],
+           [4, 7]])
+
+    Diagonals adjacent to the main diagonal can be obtained by using the
+    `offset` argument:
+
+    >>> a = np.arange(9).reshape(3, 3)
+    >>> a
+    array([[0, 1, 2],
+           [3, 4, 5],
+           [6, 7, 8]])
+    >>> np.linalg.diagonal(a, offset=1)  # First superdiagonal
+    array([1, 5])
+    >>> np.linalg.diagonal(a, offset=2)  # Second superdiagonal
+    array([2])
+    >>> np.linalg.diagonal(a, offset=-1)  # First subdiagonal
+    array([3, 7])
+    >>> np.linalg.diagonal(a, offset=-2)  # Second subdiagonal
+    array([6])
+
+    The anti-diagonal can be obtained by reversing the order of elements
+    using either `numpy.flipud` or `numpy.fliplr`.
+
+    >>> a = np.arange(9).reshape(3, 3)
+    >>> a
+    array([[0, 1, 2],
+           [3, 4, 5],
+           [6, 7, 8]])
+    >>> np.linalg.diagonal(np.fliplr(a))  # Horizontal flip
+    array([2, 4, 6])
+    >>> np.linalg.diagonal(np.flipud(a))  # Vertical flip
+    array([6, 4, 2])
+
+    Note that the order in which the diagonal is retrieved varies depending
+    on the flip function.
+
+    """
+    return _core_diagonal(x, offset, axis1=-2, axis2=-1)
+
+
+# trace
+
+def _trace_dispatcher(x, /, *, offset=None, dtype=None):
+    return (x,)
+
+
+@array_function_dispatch(_trace_dispatcher)
+def trace(x, /, *, offset=0, dtype=None):
+    """
+    Returns the sum along the specified diagonals of a matrix
+    (or a stack of matrices) ``x``.
+
+    This function is Array API compatible, contrary to
+    :py:func:`numpy.trace`.
+
+    Parameters
+    ----------
+    x : (...,M,N) array_like
+        Input array having shape (..., M, N) and whose innermost two
+        dimensions form MxN matrices.
+    offset : int, optional
+        Offset specifying the off-diagonal relative to the main diagonal,
+        where::
+
+            * offset = 0: the main diagonal.
+            * offset > 0: off-diagonal above the main diagonal.
+            * offset < 0: off-diagonal below the main diagonal.
+
+    dtype : dtype, optional
+        Data type of the returned array.
+
+    Returns
+    -------
+    out : ndarray
+        An array containing the traces and whose shape is determined by
+        removing the last two dimensions and storing the traces in the last
+        array dimension. For example, if x has rank k and shape:
+        (I, J, K, ..., L, M, N), then an output array has rank k-2 and shape:
+        (I, J, K, ..., L) where::
+
+            out[i, j, k, ..., l] = trace(a[i, j, k, ..., l, :, :])
+
+        The returned array must have a data type as described by the dtype
+        parameter above.
+
+    See Also
+    --------
+    numpy.trace
+
+    Examples
+    --------
+    >>> np.linalg.trace(np.eye(3))
+    3.0
+    >>> a = np.arange(8).reshape((2, 2, 2))
+    >>> np.linalg.trace(a)
+    array([3, 11])
+
+    Trace is computed with the last two axes as the 2-d sub-arrays.
+    This behavior differs from :py:func:`numpy.trace` which uses the first two
+    axes by default.
+
+    >>> a = np.arange(24).reshape((3, 2, 2, 2))
+    >>> np.linalg.trace(a).shape
+    (3, 2)
+
+    Traces adjacent to the main diagonal can be obtained by using the
+    `offset` argument:
+
+    >>> a = np.arange(9).reshape((3, 3)); a
+    array([[0, 1, 2],
+           [3, 4, 5],
+           [6, 7, 8]])
+    >>> np.linalg.trace(a, offset=1)  # First superdiagonal
+    6
+    >>> np.linalg.trace(a, offset=2)  # Second superdiagonal
+    2
+    >>> np.linalg.trace(a, offset=-1)  # First subdiagonal
+    10
+    >>> np.linalg.trace(a, offset=-2)  # Second subdiagonal
+    6
+
+    """
+    return _core_trace(x, offset, axis1=-2, axis2=-1, dtype=dtype)
+
+
+# cross
+
+def _cross_dispatcher(x1, x2, /, *, axis=None):
+    return (x1, x2,)
+
+
+@array_function_dispatch(_cross_dispatcher)
+def cross(x1, x2, /, *, axis=-1):
+    """
+    Returns the cross product of 3-element vectors.
+
+    If ``x1`` and/or ``x2`` are multi-dimensional arrays, then
+    the cross-product of each pair of corresponding 3-element vectors
+    is independently computed.
+
+    This function is Array API compatible, contrary to
+    :func:`numpy.cross`.
+
+    Parameters
+    ----------
+    x1 : array_like
+        The first input array.
+    x2 : array_like
+        The second input array. Must be compatible with ``x1`` for all
+        non-compute axes. The size of the axis over which to compute
+        the cross-product must be the same size as the respective axis
+        in ``x1``.
+    axis : int, optional
+        The axis (dimension) of ``x1`` and ``x2`` containing the vectors for
+        which to compute the cross-product. Default: ``-1``.
+
+    Returns
+    -------
+    out : ndarray
+        An array containing the cross products.
+
+    See Also
+    --------
+    numpy.cross
+
+    Examples
+    --------
+    Vector cross-product.
+
+    >>> x = np.array([1, 2, 3])
+    >>> y = np.array([4, 5, 6])
+    >>> np.linalg.cross(x, y)
+    array([-3,  6, -3])
+
+    Multiple vector cross-products. Note that the direction of the cross
+    product vector is defined by the *right-hand rule*.
+
+    >>> x = np.array([[1,2,3], [4,5,6]])
+    >>> y = np.array([[4,5,6], [1,2,3]])
+    >>> np.linalg.cross(x, y)
+    array([[-3,  6, -3],
+           [ 3, -6,  3]])
+
+    >>> x = np.array([[1, 2], [3, 4], [5, 6]])
+    >>> y = np.array([[4, 5], [6, 1], [2, 3]])
+    >>> np.linalg.cross(x, y, axis=0)
+    array([[-24,  6],
+           [ 18, 24],
+           [-6,  -18]])
+
+    """
+    x1 = asanyarray(x1)
+    x2 = asanyarray(x2)
+
+    if x1.shape[axis] != 3 or x2.shape[axis] != 3:
+        raise ValueError(
+            "Both input arrays must be (arrays of) 3-dimensional vectors, "
+            f"but they are {x1.shape[axis]} and {x2.shape[axis]} "
+            "dimensional instead."
+        )
+
+    return _core_cross(x1, x2, axis=axis)
+
+
+# matmul
+
+def _matmul_dispatcher(x1, x2, /):
+    return (x1, x2)
+
+
+@array_function_dispatch(_matmul_dispatcher)
+def matmul(x1, x2, /):
+    """
+    Computes the matrix product.
+
+    This function is Array API compatible, contrary to
+    :func:`numpy.matmul`.
+
+    Parameters
+    ----------
+    x1 : array_like
+        The first input array.
+    x2 : array_like
+        The second input array.
+
+    Returns
+    -------
+    out : ndarray
+        The matrix product of the inputs.
+        This is a scalar only when both ``x1``, ``x2`` are 1-d vectors.
+
+    Raises
+    ------
+    ValueError
+        If the last dimension of ``x1`` is not the same size as
+        the second-to-last dimension of ``x2``.
+
+        If a scalar value is passed in.
+
+    See Also
+    --------
+    numpy.matmul
+
+    Examples
+    --------
+    For 2-D arrays it is the matrix product:
+
+    >>> a = np.array([[1, 0],
+    ...               [0, 1]])
+    >>> b = np.array([[4, 1],
+    ...               [2, 2]])
+    >>> np.linalg.matmul(a, b)
+    array([[4, 1],
+           [2, 2]])
+
+    For 2-D mixed with 1-D, the result is the usual.
+
+    >>> a = np.array([[1, 0],
+    ...               [0, 1]])
+    >>> b = np.array([1, 2])
+    >>> np.linalg.matmul(a, b)
+    array([1, 2])
+    >>> np.linalg.matmul(b, a)
+    array([1, 2])
+
+
+    Broadcasting is conventional for stacks of arrays
+
+    >>> a = np.arange(2 * 2 * 4).reshape((2, 2, 4))
+    >>> b = np.arange(2 * 2 * 4).reshape((2, 4, 2))
+    >>> np.linalg.matmul(a,b).shape
+    (2, 2, 2)
+    >>> np.linalg.matmul(a, b)[0, 1, 1]
+    98
+    >>> sum(a[0, 1, :] * b[0 , :, 1])
+    98
+
+    Vector, vector returns the scalar inner product, but neither argument
+    is complex-conjugated:
+
+    >>> np.linalg.matmul([2j, 3j], [2j, 3j])
+    (-13+0j)
+
+    Scalar multiplication raises an error.
+
+    >>> np.linalg.matmul([1,2], 3)
+    Traceback (most recent call last):
+    ...
+    ValueError: matmul: Input operand 1 does not have enough dimensions ...
+
+    """
+    return _core_matmul(x1, x2)
+
+
+# tensordot
+
+def _tensordot_dispatcher(x1, x2, /, *, axes=None):
+    return (x1, x2)
+
+
+@array_function_dispatch(_tensordot_dispatcher)
+def tensordot(x1, x2, /, *, axes=2):
+    return _core_tensordot(x1, x2, axes=axes)
+
+
+tensordot.__doc__ = _core_tensordot.__doc__
+
+
+# matrix_transpose
+
+def _matrix_transpose_dispatcher(x):
+    return (x,)
+
+@array_function_dispatch(_matrix_transpose_dispatcher)
+def matrix_transpose(x, /):
+    return _core_matrix_transpose(x)
+
+
+matrix_transpose.__doc__ = _core_matrix_transpose.__doc__
+
+
+# matrix_norm
+
+def _matrix_norm_dispatcher(x, /, *, keepdims=None, ord=None):
+    return (x,)
+
+@array_function_dispatch(_matrix_norm_dispatcher)
+def matrix_norm(x, /, *, keepdims=False, ord="fro"):
+    """
+    Computes the matrix norm of a matrix (or a stack of matrices) ``x``.
+
+    This function is Array API compatible.
+
+    Parameters
+    ----------
+    x : array_like
+        Input array having shape (..., M, N) and whose two innermost
+        dimensions form ``MxN`` matrices.
+    keepdims : bool, optional
+        If this is set to True, the axes which are normed over are left in
+        the result as dimensions with size one. Default: False.
+    ord : {1, -1, 2, -2, inf, -inf, 'fro', 'nuc'}, optional
+        The order of the norm. For details see the table under ``Notes``
+        in `numpy.linalg.norm`.
+
+    See Also
+    --------
+    numpy.linalg.norm : Generic norm function
+
+    Examples
+    --------
+    >>> from numpy import linalg as LA
+    >>> a = np.arange(9) - 4
+    >>> a
+    array([-4, -3, -2, ...,  2,  3,  4])
+    >>> b = a.reshape((3, 3))
+    >>> b
+    array([[-4, -3, -2],
+           [-1,  0,  1],
+           [ 2,  3,  4]])
+
+    >>> LA.matrix_norm(b)
+    7.745966692414834
+    >>> LA.matrix_norm(b, ord='fro')
+    7.745966692414834
+    >>> LA.matrix_norm(b, ord=np.inf)
+    9.0
+    >>> LA.matrix_norm(b, ord=-np.inf)
+    2.0
+
+    >>> LA.matrix_norm(b, ord=1)
+    7.0
+    >>> LA.matrix_norm(b, ord=-1)
+    6.0
+    >>> LA.matrix_norm(b, ord=2)
+    7.3484692283495345
+    >>> LA.matrix_norm(b, ord=-2)
+    1.8570331885190563e-016 # may vary
+
+    """
+    x = asanyarray(x)
+    return norm(x, axis=(-2, -1), keepdims=keepdims, ord=ord)
+
+
+# vector_norm
+
+def _vector_norm_dispatcher(x, /, *, axis=None, keepdims=None, ord=None):
+    return (x,)
+
+@array_function_dispatch(_vector_norm_dispatcher)
+def vector_norm(x, /, *, axis=None, keepdims=False, ord=2):
+    """
+    Computes the vector norm of a vector (or batch of vectors) ``x``.
+
+    This function is Array API compatible.
+
+    Parameters
+    ----------
+    x : array_like
+        Input array.
+    axis : {None, int, 2-tuple of ints}, optional
+        If an integer, ``axis`` specifies the axis (dimension) along which
+        to compute vector norms. If an n-tuple, ``axis`` specifies the axes
+        (dimensions) along which to compute batched vector norms. If ``None``,
+        the vector norm must be computed over all array values (i.e.,
+        equivalent to computing the vector norm of a flattened array).
+        Default: ``None``.
+    keepdims : bool, optional
+        If this is set to True, the axes which are normed over are left in
+        the result as dimensions with size one. Default: False.
+    ord : {1, -1, 2, -2, inf, -inf, 'fro', 'nuc'}, optional
+        The order of the norm. For details see the table under ``Notes``
+        in `numpy.linalg.norm`.
+
+    See Also
+    --------
+    numpy.linalg.norm : Generic norm function
+
+    Examples
+    --------
+    >>> from numpy import linalg as LA
+    >>> a = np.arange(9) + 1
+    >>> a
+    array([1, 2, 3, 4, 5, 6, 7, 8, 9])
+    >>> b = a.reshape((3, 3))
+    >>> b
+    array([[1, 2, 3],
+           [4, 5, 6],
+           [7, 8, 9]])
+
+    >>> LA.vector_norm(b)
+    16.881943016134134
+    >>> LA.vector_norm(b, ord=np.inf)
+    9.0
+    >>> LA.vector_norm(b, ord=-np.inf)
+    1.0
+
+    >>> LA.vector_norm(b, ord=1)
+    45.0
+    >>> LA.vector_norm(b, ord=-1)
+    0.3534857623790153
+    >>> LA.vector_norm(b, ord=2)
+    16.881943016134134
+    >>> LA.vector_norm(b, ord=-2)
+    0.8058837395885292
+
+    """
+    x = asanyarray(x)
+    shape = list(x.shape)
+    if axis is None:
+        # Note: np.linalg.norm() doesn't handle 0-D arrays
+        x = x.ravel()
+        _axis = 0
+    elif isinstance(axis, tuple):
+        # Note: The axis argument supports any number of axes, whereas
+        # np.linalg.norm() only supports a single axis for vector norm.
+        normalized_axis = normalize_axis_tuple(axis, x.ndim)
+        rest = tuple(i for i in range(x.ndim) if i not in normalized_axis)
+        newshape = axis + rest
+        x = _core_transpose(x, newshape).reshape(
+            (
+                prod([x.shape[i] for i in axis], dtype=int),
+                *[x.shape[i] for i in rest]
+            )
+        )
+        _axis = 0
+    else:
+        _axis = axis
+
+    res = norm(x, axis=_axis, ord=ord)
+
+    if keepdims:
+        # We can't reuse np.linalg.norm(keepdims) because of the reshape hacks
+        # above to avoid matrix norm logic.
+        _axis = normalize_axis_tuple(
+            range(len(shape)) if axis is None else axis, len(shape)
+        )
+        for i in _axis:
+            shape[i] = 1
+        res = res.reshape(tuple(shape))
+
+    return res
+
+
+# vecdot
+
+def _vecdot_dispatcher(x1, x2, /, *, axis=None):
+    return (x1, x2)
+
+@array_function_dispatch(_vecdot_dispatcher)
+def vecdot(x1, x2, /, *, axis=-1):
+    """
+    Computes the vector dot product.
+
+    This function is restricted to arguments compatible with the Array API,
+    contrary to :func:`numpy.vecdot`.
+
+    Let :math:`\\mathbf{a}` be a vector in ``x1`` and :math:`\\mathbf{b}` be
+    a corresponding vector in ``x2``. The dot product is defined as:
+
+    .. math::
+       \\mathbf{a} \\cdot \\mathbf{b} = \\sum_{i=0}^{n-1} \\overline{a_i}b_i
+
+    over the dimension specified by ``axis`` and where :math:`\\overline{a_i}`
+    denotes the complex conjugate if :math:`a_i` is complex and the identity
+    otherwise.
+
+    Parameters
+    ----------
+    x1 : array_like
+        First input array.
+    x2 : array_like
+        Second input array.
+    axis : int, optional
+        Axis over which to compute the dot product. Default: ``-1``.
+
+    Returns
+    -------
+    output : ndarray
+        The vector dot product of the input.
+
+    See Also
+    --------
+    numpy.vecdot
+
+    Examples
+    --------
+    Get the projected size along a given normal for an array of vectors.
+
+    >>> v = np.array([[0., 5., 0.], [0., 0., 10.], [0., 6., 8.]])
+    >>> n = np.array([0., 0.6, 0.8])
+    >>> np.linalg.vecdot(v, n)
+    array([ 3.,  8., 10.])
+
+    """
+    return _core_vecdot(x1, x2, axis=axis)
diff --git a/venv/lib/python3.12/site-packages/numpy/linalg/_linalg.pyi b/venv/lib/python3.12/site-packages/numpy/linalg/_linalg.pyi
new file mode 100644
index 00000000..0d431794
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/linalg/_linalg.pyi
@@ -0,0 +1,427 @@
+from collections.abc import Iterable
+from typing import (
+    Literal as L,
+    overload,
+    TypeAlias,
+    TypeVar,
+    Any,
+    SupportsIndex,
+    SupportsInt,
+    NamedTuple,
+    Generic,
+)
+
+import numpy as np
+from numpy import (
+    generic,
+    floating,
+    complexfloating,
+    signedinteger,
+    unsignedinteger,
+    timedelta64,
+    object_,
+    int32,
+    float64,
+    complex128,
+)
+
+from numpy.linalg import LinAlgError as LinAlgError
+
+from numpy._typing import (
+    NDArray,
+    ArrayLike,
+    _ArrayLikeUnknown,
+    _ArrayLikeBool_co,
+    _ArrayLikeInt_co,
+    _ArrayLikeUInt_co,
+    _ArrayLikeFloat_co,
+    _ArrayLikeComplex_co,
+    _ArrayLikeTD64_co,
+    _ArrayLikeObject_co,
+    DTypeLike,
+)
+
+_T = TypeVar("_T")
+_ArrayType = TypeVar("_ArrayType", bound=NDArray[Any])
+_SCT = TypeVar("_SCT", bound=generic, covariant=True)
+_SCT2 = TypeVar("_SCT2", bound=generic, covariant=True)
+
+_2Tuple: TypeAlias = tuple[_T, _T]
+_ModeKind: TypeAlias = L["reduced", "complete", "r", "raw"]
+
+__all__: list[str]
+
+class EigResult(NamedTuple):
+    eigenvalues: NDArray[Any]
+    eigenvectors: NDArray[Any]
+
+class EighResult(NamedTuple):
+    eigenvalues: NDArray[Any]
+    eigenvectors: NDArray[Any]
+
+class QRResult(NamedTuple):
+    Q: NDArray[Any]
+    R: NDArray[Any]
+
+class SlogdetResult(NamedTuple):
+    # TODO: `sign` and `logabsdet` are scalars for input 2D arrays and
+    # a `(x.ndim - 2)`` dimensionl arrays otherwise
+    sign: Any
+    logabsdet: Any
+
+class SVDResult(NamedTuple):
+    U: NDArray[Any]
+    S: NDArray[Any]
+    Vh: NDArray[Any]
+
+@overload
+def tensorsolve(
+    a: _ArrayLikeInt_co,
+    b: _ArrayLikeInt_co,
+    axes: None | Iterable[int] =...,
+) -> NDArray[float64]: ...
+@overload
+def tensorsolve(
+    a: _ArrayLikeFloat_co,
+    b: _ArrayLikeFloat_co,
+    axes: None | Iterable[int] =...,
+) -> NDArray[floating[Any]]: ...
+@overload
+def tensorsolve(
+    a: _ArrayLikeComplex_co,
+    b: _ArrayLikeComplex_co,
+    axes: None | Iterable[int] =...,
+) -> NDArray[complexfloating[Any, Any]]: ...
+
+@overload
+def solve(
+    a: _ArrayLikeInt_co,
+    b: _ArrayLikeInt_co,
+) -> NDArray[float64]: ...
+@overload
+def solve(
+    a: _ArrayLikeFloat_co,
+    b: _ArrayLikeFloat_co,
+) -> NDArray[floating[Any]]: ...
+@overload
+def solve(
+    a: _ArrayLikeComplex_co,
+    b: _ArrayLikeComplex_co,
+) -> NDArray[complexfloating[Any, Any]]: ...
+
+@overload
+def tensorinv(
+    a: _ArrayLikeInt_co,
+    ind: int = ...,
+) -> NDArray[float64]: ...
+@overload
+def tensorinv(
+    a: _ArrayLikeFloat_co,
+    ind: int = ...,
+) -> NDArray[floating[Any]]: ...
+@overload
+def tensorinv(
+    a: _ArrayLikeComplex_co,
+    ind: int = ...,
+) -> NDArray[complexfloating[Any, Any]]: ...
+
+@overload
+def inv(a: _ArrayLikeInt_co) -> NDArray[float64]: ...
+@overload
+def inv(a: _ArrayLikeFloat_co) -> NDArray[floating[Any]]: ...
+@overload
+def inv(a: _ArrayLikeComplex_co) -> NDArray[complexfloating[Any, Any]]: ...
+
+# TODO: The supported input and output dtypes are dependent on the value of `n`.
+# For example: `n < 0` always casts integer types to float64
+def matrix_power(
+    a: _ArrayLikeComplex_co | _ArrayLikeObject_co,
+    n: SupportsIndex,
+) -> NDArray[Any]: ...
+
+@overload
+def cholesky(a: _ArrayLikeInt_co) -> NDArray[float64]: ...
+@overload
+def cholesky(a: _ArrayLikeFloat_co) -> NDArray[floating[Any]]: ...
+@overload
+def cholesky(a: _ArrayLikeComplex_co) -> NDArray[complexfloating[Any, Any]]: ...
+
+@overload
+def outer(x1: _ArrayLikeUnknown, x2: _ArrayLikeUnknown) -> NDArray[Any]: ...
+@overload
+def outer(x1: _ArrayLikeBool_co, x2: _ArrayLikeBool_co) -> NDArray[np.bool]: ...
+@overload
+def outer(x1: _ArrayLikeUInt_co, x2: _ArrayLikeUInt_co) -> NDArray[unsignedinteger[Any]]: ...
+@overload
+def outer(x1: _ArrayLikeInt_co, x2: _ArrayLikeInt_co) -> NDArray[signedinteger[Any]]: ...
+@overload
+def outer(x1: _ArrayLikeFloat_co, x2: _ArrayLikeFloat_co) -> NDArray[floating[Any]]: ...
+@overload
+def outer(
+    x1: _ArrayLikeComplex_co,
+    x2: _ArrayLikeComplex_co,
+) -> NDArray[complexfloating[Any, Any]]: ...
+@overload
+def outer(
+    x1: _ArrayLikeTD64_co,
+    x2: _ArrayLikeTD64_co,
+    out: None = ...,
+) -> NDArray[timedelta64]: ...
+@overload
+def outer(x1: _ArrayLikeObject_co, x2: _ArrayLikeObject_co) -> NDArray[object_]: ...
+@overload
+def outer(
+    x1: _ArrayLikeComplex_co | _ArrayLikeTD64_co | _ArrayLikeObject_co,
+    x2: _ArrayLikeComplex_co | _ArrayLikeTD64_co | _ArrayLikeObject_co,
+) -> _ArrayType: ...
+
+@overload
+def qr(a: _ArrayLikeInt_co, mode: _ModeKind = ...) -> QRResult: ...
+@overload
+def qr(a: _ArrayLikeFloat_co, mode: _ModeKind = ...) -> QRResult: ...
+@overload
+def qr(a: _ArrayLikeComplex_co, mode: _ModeKind = ...) -> QRResult: ...
+
+@overload
+def eigvals(a: _ArrayLikeInt_co) -> NDArray[float64] | NDArray[complex128]: ...
+@overload
+def eigvals(a: _ArrayLikeFloat_co) -> NDArray[floating[Any]] | NDArray[complexfloating[Any, Any]]: ...
+@overload
+def eigvals(a: _ArrayLikeComplex_co) -> NDArray[complexfloating[Any, Any]]: ...
+
+@overload
+def eigvalsh(a: _ArrayLikeInt_co, UPLO: L["L", "U", "l", "u"] = ...) -> NDArray[float64]: ...
+@overload
+def eigvalsh(a: _ArrayLikeComplex_co, UPLO: L["L", "U", "l", "u"] = ...) -> NDArray[floating[Any]]: ...
+
+@overload
+def eig(a: _ArrayLikeInt_co) -> EigResult: ...
+@overload
+def eig(a: _ArrayLikeFloat_co) -> EigResult: ...
+@overload
+def eig(a: _ArrayLikeComplex_co) -> EigResult: ...
+
+@overload
+def eigh(
+    a: _ArrayLikeInt_co,
+    UPLO: L["L", "U", "l", "u"] = ...,
+) -> EighResult: ...
+@overload
+def eigh(
+    a: _ArrayLikeFloat_co,
+    UPLO: L["L", "U", "l", "u"] = ...,
+) -> EighResult: ...
+@overload
+def eigh(
+    a: _ArrayLikeComplex_co,
+    UPLO: L["L", "U", "l", "u"] = ...,
+) -> EighResult: ...
+
+@overload
+def svd(
+    a: _ArrayLikeInt_co,
+    full_matrices: bool = ...,
+    compute_uv: L[True] = ...,
+    hermitian: bool = ...,
+) -> SVDResult: ...
+@overload
+def svd(
+    a: _ArrayLikeFloat_co,
+    full_matrices: bool = ...,
+    compute_uv: L[True] = ...,
+    hermitian: bool = ...,
+) -> SVDResult: ...
+@overload
+def svd(
+    a: _ArrayLikeComplex_co,
+    full_matrices: bool = ...,
+    compute_uv: L[True] = ...,
+    hermitian: bool = ...,
+) -> SVDResult: ...
+@overload
+def svd(
+    a: _ArrayLikeInt_co,
+    full_matrices: bool = ...,
+    compute_uv: L[False] = ...,
+    hermitian: bool = ...,
+) -> NDArray[float64]: ...
+@overload
+def svd(
+    a: _ArrayLikeComplex_co,
+    full_matrices: bool = ...,
+    compute_uv: L[False] = ...,
+    hermitian: bool = ...,
+) -> NDArray[floating[Any]]: ...
+
+def svdvals(
+    x: _ArrayLikeInt_co | _ArrayLikeFloat_co | _ArrayLikeComplex_co
+) -> NDArray[floating[Any]]: ...
+
+# TODO: Returns a scalar for 2D arrays and
+# a `(x.ndim - 2)`` dimensionl array otherwise
+def cond(x: _ArrayLikeComplex_co, p: None | float | L["fro", "nuc"] = ...) -> Any: ...
+
+# TODO: Returns `int` for <2D arrays and `intp` otherwise
+def matrix_rank(
+    A: _ArrayLikeComplex_co,
+    tol: None | _ArrayLikeFloat_co = ...,
+    hermitian: bool = ...,
+    *,
+    rtol: None | _ArrayLikeFloat_co = ...,
+) -> Any: ...
+
+@overload
+def pinv(
+    a: _ArrayLikeInt_co,
+    rcond: _ArrayLikeFloat_co = ...,
+    hermitian: bool = ...,
+) -> NDArray[float64]: ...
+@overload
+def pinv(
+    a: _ArrayLikeFloat_co,
+    rcond: _ArrayLikeFloat_co = ...,
+    hermitian: bool = ...,
+) -> NDArray[floating[Any]]: ...
+@overload
+def pinv(
+    a: _ArrayLikeComplex_co,
+    rcond: _ArrayLikeFloat_co = ...,
+    hermitian: bool = ...,
+) -> NDArray[complexfloating[Any, Any]]: ...
+
+# TODO: Returns a 2-tuple of scalars for 2D arrays and
+# a 2-tuple of `(a.ndim - 2)`` dimensionl arrays otherwise
+def slogdet(a: _ArrayLikeComplex_co) -> SlogdetResult: ...
+
+# TODO: Returns a 2-tuple of scalars for 2D arrays and
+# a 2-tuple of `(a.ndim - 2)`` dimensionl arrays otherwise
+def det(a: _ArrayLikeComplex_co) -> Any: ...
+
+@overload
+def lstsq(a: _ArrayLikeInt_co, b: _ArrayLikeInt_co, rcond: None | float = ...) -> tuple[
+    NDArray[float64],
+    NDArray[float64],
+    int32,
+    NDArray[float64],
+]: ...
+@overload
+def lstsq(a: _ArrayLikeFloat_co, b: _ArrayLikeFloat_co, rcond: None | float = ...) -> tuple[
+    NDArray[floating[Any]],
+    NDArray[floating[Any]],
+    int32,
+    NDArray[floating[Any]],
+]: ...
+@overload
+def lstsq(a: _ArrayLikeComplex_co, b: _ArrayLikeComplex_co, rcond: None | float = ...) -> tuple[
+    NDArray[complexfloating[Any, Any]],
+    NDArray[floating[Any]],
+    int32,
+    NDArray[floating[Any]],
+]: ...
+
+@overload
+def norm(
+    x: ArrayLike,
+    ord: None | float | L["fro", "nuc"] = ...,
+    axis: None = ...,
+    keepdims: bool = ...,
+) -> floating[Any]: ...
+@overload
+def norm(
+    x: ArrayLike,
+    ord: None | float | L["fro", "nuc"] = ...,
+    axis: SupportsInt | SupportsIndex | tuple[int, ...] = ...,
+    keepdims: bool = ...,
+) -> Any: ...
+
+@overload
+def matrix_norm(
+    x: ArrayLike,
+    ord: None | float | L["fro", "nuc"] = ...,
+    keepdims: bool = ...,
+) -> floating[Any]: ...
+@overload
+def matrix_norm(
+    x: ArrayLike,
+    ord: None | float | L["fro", "nuc"] = ...,
+    keepdims: bool = ...,
+) -> Any: ...
+
+@overload
+def vector_norm(
+    x: ArrayLike,
+    axis: None = ...,
+    ord: None | float = ...,
+    keepdims: bool = ...,
+) -> floating[Any]: ...
+@overload
+def vector_norm(
+    x: ArrayLike,
+    axis: SupportsInt | SupportsIndex | tuple[int, ...] = ...,
+    ord: None | float = ...,
+    keepdims: bool = ...,
+) -> Any: ...
+
+# TODO: Returns a scalar or array
+def multi_dot(
+    arrays: Iterable[_ArrayLikeComplex_co | _ArrayLikeObject_co | _ArrayLikeTD64_co],
+    *,
+    out: None | NDArray[Any] = ...,
+) -> Any: ...
+
+def diagonal(
+    x: ArrayLike,  # >= 2D array
+    offset: SupportsIndex = ...,
+) -> NDArray[Any]: ...
+
+def trace(
+    x: ArrayLike,  # >= 2D array
+    offset: SupportsIndex = ...,
+    dtype: DTypeLike = ...,
+) -> Any: ...
+
+@overload
+def cross(
+    a: _ArrayLikeUInt_co,
+    b: _ArrayLikeUInt_co,
+    axis: int = ...,
+) -> NDArray[unsignedinteger[Any]]: ...
+@overload
+def cross(
+    a: _ArrayLikeInt_co,
+    b: _ArrayLikeInt_co,
+    axis: int = ...,
+) -> NDArray[signedinteger[Any]]: ...
+@overload
+def cross(
+    a: _ArrayLikeFloat_co,
+    b: _ArrayLikeFloat_co,
+    axis: int = ...,
+) -> NDArray[floating[Any]]: ...
+@overload
+def cross(
+    a: _ArrayLikeComplex_co,
+    b: _ArrayLikeComplex_co,
+    axis: int = ...,
+) -> NDArray[complexfloating[Any, Any]]: ...
+
+@overload
+def matmul(
+    x1: _ArrayLikeInt_co,
+    x2: _ArrayLikeInt_co,
+) -> NDArray[signedinteger[Any]]: ...
+@overload
+def matmul(
+    x1: _ArrayLikeUInt_co,
+    x2: _ArrayLikeUInt_co,
+) -> NDArray[unsignedinteger[Any]]: ...
+@overload
+def matmul(
+    x1: _ArrayLikeFloat_co,
+    x2: _ArrayLikeFloat_co,
+) -> NDArray[floating[Any]]: ...
+@overload
+def matmul(
+    x1: _ArrayLikeComplex_co,
+    x2: _ArrayLikeComplex_co,
+) -> NDArray[complexfloating[Any, Any]]: ...
diff --git a/venv/lib/python3.12/site-packages/numpy/linalg/_umath_linalg.cpython-312-darwin.so b/venv/lib/python3.12/site-packages/numpy/linalg/_umath_linalg.cpython-312-darwin.so
new file mode 100755
index 00000000..7f58017c
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/linalg/_umath_linalg.cpython-312-darwin.so differ
diff --git a/venv/lib/python3.12/site-packages/numpy/linalg/lapack_lite.cpython-312-darwin.so b/venv/lib/python3.12/site-packages/numpy/linalg/lapack_lite.cpython-312-darwin.so
new file mode 100755
index 00000000..3c766a02
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/linalg/lapack_lite.cpython-312-darwin.so differ
diff --git a/venv/lib/python3.12/site-packages/numpy/linalg/linalg.py b/venv/lib/python3.12/site-packages/numpy/linalg/linalg.py
new file mode 100644
index 00000000..d75b0734
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/linalg/linalg.py
@@ -0,0 +1,16 @@
+def __getattr__(attr_name):
+    import warnings
+    from numpy.linalg import _linalg
+    ret = getattr(_linalg, attr_name, None)
+    if ret is None:
+        raise AttributeError(
+            f"module 'numpy.linalg.linalg' has no attribute {attr_name}")
+    warnings.warn(
+        "The numpy.linalg.linalg has been made private and renamed to "
+        "numpy.linalg._linalg. All public functions exported by it are "
+        f"available from numpy.linalg. Please use numpy.linalg.{attr_name} "
+        "instead.",
+        DeprecationWarning,
+        stacklevel=3
+    )
+    return ret
diff --git a/venv/lib/python3.12/site-packages/numpy/linalg/tests/__init__.py b/venv/lib/python3.12/site-packages/numpy/linalg/tests/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/venv/lib/python3.12/site-packages/numpy/linalg/tests/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/linalg/tests/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 00000000..cd3b7d79
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/linalg/tests/__pycache__/__init__.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/linalg/tests/__pycache__/test_deprecations.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/linalg/tests/__pycache__/test_deprecations.cpython-312.pyc
new file mode 100644
index 00000000..246c17ec
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/linalg/tests/__pycache__/test_deprecations.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/linalg/tests/__pycache__/test_linalg.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/linalg/tests/__pycache__/test_linalg.cpython-312.pyc
new file mode 100644
index 00000000..607b78ea
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/linalg/tests/__pycache__/test_linalg.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/linalg/tests/__pycache__/test_regression.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/linalg/tests/__pycache__/test_regression.cpython-312.pyc
new file mode 100644
index 00000000..4ae55dae
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/linalg/tests/__pycache__/test_regression.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/linalg/tests/test_deprecations.py b/venv/lib/python3.12/site-packages/numpy/linalg/tests/test_deprecations.py
new file mode 100644
index 00000000..cd4c1083
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/linalg/tests/test_deprecations.py
@@ -0,0 +1,20 @@
+"""Test deprecation and future warnings.
+
+"""
+import numpy as np
+from numpy.testing import assert_warns
+
+
+def test_qr_mode_full_future_warning():
+    """Check mode='full' FutureWarning.
+
+    In numpy 1.8 the mode options 'full' and 'economic' in linalg.qr were
+    deprecated. The release date will probably be sometime in the summer
+    of 2013.
+
+    """
+    a = np.eye(2)
+    assert_warns(DeprecationWarning, np.linalg.qr, a, mode='full')
+    assert_warns(DeprecationWarning, np.linalg.qr, a, mode='f')
+    assert_warns(DeprecationWarning, np.linalg.qr, a, mode='economic')
+    assert_warns(DeprecationWarning, np.linalg.qr, a, mode='e')
diff --git a/venv/lib/python3.12/site-packages/numpy/linalg/tests/test_linalg.py b/venv/lib/python3.12/site-packages/numpy/linalg/tests/test_linalg.py
new file mode 100644
index 00000000..ffd9550e
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/linalg/tests/test_linalg.py
@@ -0,0 +1,2386 @@
+""" Test functions for linalg module
+
+"""
+import os
+import sys
+import itertools
+import threading
+import traceback
+import textwrap
+import subprocess
+import pytest
+
+import numpy as np
+from numpy import array, single, double, csingle, cdouble, dot, identity, matmul
+from numpy._core import swapaxes
+from numpy.exceptions import AxisError
+from numpy import multiply, atleast_2d, inf, asarray
+from numpy import linalg
+from numpy.linalg import matrix_power, norm, matrix_rank, multi_dot, LinAlgError
+from numpy.linalg._linalg import _multi_dot_matrix_chain_order
+from numpy.testing import (
+    assert_, assert_equal, assert_raises, assert_array_equal,
+    assert_almost_equal, assert_allclose, suppress_warnings,
+    assert_raises_regex, HAS_LAPACK64, IS_WASM
+    )
+try:
+    import numpy.linalg.lapack_lite
+except ImportError:
+    # May be broken when numpy was built without BLAS/LAPACK present
+    # If so, ensure we don't break the whole test suite - the `lapack_lite`
+    # submodule should be removed, it's only used in two tests in this file.
+    pass
+
+
+def consistent_subclass(out, in_):
+    # For ndarray subclass input, our output should have the same subclass
+    # (non-ndarray input gets converted to ndarray).
+    return type(out) is (type(in_) if isinstance(in_, np.ndarray)
+                         else np.ndarray)
+
+
+old_assert_almost_equal = assert_almost_equal
+
+
+def assert_almost_equal(a, b, single_decimal=6, double_decimal=12, **kw):
+    if asarray(a).dtype.type in (single, csingle):
+        decimal = single_decimal
+    else:
+        decimal = double_decimal
+    old_assert_almost_equal(a, b, decimal=decimal, **kw)
+
+
+def get_real_dtype(dtype):
+    return {single: single, double: double,
+            csingle: single, cdouble: double}[dtype]
+
+
+def get_complex_dtype(dtype):
+    return {single: csingle, double: cdouble,
+            csingle: csingle, cdouble: cdouble}[dtype]
+
+
+def get_rtol(dtype):
+    # Choose a safe rtol
+    if dtype in (single, csingle):
+        return 1e-5
+    else:
+        return 1e-11
+
+
+# used to categorize tests
+all_tags = {
+  'square', 'nonsquare', 'hermitian',  # mutually exclusive
+  'generalized', 'size-0', 'strided' # optional additions
+}
+
+
+class LinalgCase:
+    def __init__(self, name, a, b, tags=set()):
+        """
+        A bundle of arguments to be passed to a test case, with an identifying
+        name, the operands a and b, and a set of tags to filter the tests
+        """
+        assert_(isinstance(name, str))
+        self.name = name
+        self.a = a
+        self.b = b
+        self.tags = frozenset(tags)  # prevent shared tags
+
+    def check(self, do):
+        """
+        Run the function `do` on this test case, expanding arguments
+        """
+        do(self.a, self.b, tags=self.tags)
+
+    def __repr__(self):
+        return f''
+
+
+def apply_tag(tag, cases):
+    """
+    Add the given tag (a string) to each of the cases (a list of LinalgCase
+    objects)
+    """
+    assert tag in all_tags, "Invalid tag"
+    for case in cases:
+        case.tags = case.tags | {tag}
+    return cases
+
+
+#
+# Base test cases
+#
+
+np.random.seed(1234)
+
+CASES = []
+
+# square test cases
+CASES += apply_tag('square', [
+    LinalgCase("single",
+               array([[1., 2.], [3., 4.]], dtype=single),
+               array([2., 1.], dtype=single)),
+    LinalgCase("double",
+               array([[1., 2.], [3., 4.]], dtype=double),
+               array([2., 1.], dtype=double)),
+    LinalgCase("double_2",
+               array([[1., 2.], [3., 4.]], dtype=double),
+               array([[2., 1., 4.], [3., 4., 6.]], dtype=double)),
+    LinalgCase("csingle",
+               array([[1. + 2j, 2 + 3j], [3 + 4j, 4 + 5j]], dtype=csingle),
+               array([2. + 1j, 1. + 2j], dtype=csingle)),
+    LinalgCase("cdouble",
+               array([[1. + 2j, 2 + 3j], [3 + 4j, 4 + 5j]], dtype=cdouble),
+               array([2. + 1j, 1. + 2j], dtype=cdouble)),
+    LinalgCase("cdouble_2",
+               array([[1. + 2j, 2 + 3j], [3 + 4j, 4 + 5j]], dtype=cdouble),
+               array([[2. + 1j, 1. + 2j, 1 + 3j], [1 - 2j, 1 - 3j, 1 - 6j]], dtype=cdouble)),
+    LinalgCase("0x0",
+               np.empty((0, 0), dtype=double),
+               np.empty((0,), dtype=double),
+               tags={'size-0'}),
+    LinalgCase("8x8",
+               np.random.rand(8, 8),
+               np.random.rand(8)),
+    LinalgCase("1x1",
+               np.random.rand(1, 1),
+               np.random.rand(1)),
+    LinalgCase("nonarray",
+               [[1, 2], [3, 4]],
+               [2, 1]),
+])
+
+# non-square test-cases
+CASES += apply_tag('nonsquare', [
+    LinalgCase("single_nsq_1",
+               array([[1., 2., 3.], [3., 4., 6.]], dtype=single),
+               array([2., 1.], dtype=single)),
+    LinalgCase("single_nsq_2",
+               array([[1., 2.], [3., 4.], [5., 6.]], dtype=single),
+               array([2., 1., 3.], dtype=single)),
+    LinalgCase("double_nsq_1",
+               array([[1., 2., 3.], [3., 4., 6.]], dtype=double),
+               array([2., 1.], dtype=double)),
+    LinalgCase("double_nsq_2",
+               array([[1., 2.], [3., 4.], [5., 6.]], dtype=double),
+               array([2., 1., 3.], dtype=double)),
+    LinalgCase("csingle_nsq_1",
+               array(
+                   [[1. + 1j, 2. + 2j, 3. - 3j], [3. - 5j, 4. + 9j, 6. + 2j]], dtype=csingle),
+               array([2. + 1j, 1. + 2j], dtype=csingle)),
+    LinalgCase("csingle_nsq_2",
+               array(
+                   [[1. + 1j, 2. + 2j], [3. - 3j, 4. - 9j], [5. - 4j, 6. + 8j]], dtype=csingle),
+               array([2. + 1j, 1. + 2j, 3. - 3j], dtype=csingle)),
+    LinalgCase("cdouble_nsq_1",
+               array(
+                   [[1. + 1j, 2. + 2j, 3. - 3j], [3. - 5j, 4. + 9j, 6. + 2j]], dtype=cdouble),
+               array([2. + 1j, 1. + 2j], dtype=cdouble)),
+    LinalgCase("cdouble_nsq_2",
+               array(
+                   [[1. + 1j, 2. + 2j], [3. - 3j, 4. - 9j], [5. - 4j, 6. + 8j]], dtype=cdouble),
+               array([2. + 1j, 1. + 2j, 3. - 3j], dtype=cdouble)),
+    LinalgCase("cdouble_nsq_1_2",
+               array(
+                   [[1. + 1j, 2. + 2j, 3. - 3j], [3. - 5j, 4. + 9j, 6. + 2j]], dtype=cdouble),
+               array([[2. + 1j, 1. + 2j], [1 - 1j, 2 - 2j]], dtype=cdouble)),
+    LinalgCase("cdouble_nsq_2_2",
+               array(
+                   [[1. + 1j, 2. + 2j], [3. - 3j, 4. - 9j], [5. - 4j, 6. + 8j]], dtype=cdouble),
+               array([[2. + 1j, 1. + 2j], [1 - 1j, 2 - 2j], [1 - 1j, 2 - 2j]], dtype=cdouble)),
+    LinalgCase("8x11",
+               np.random.rand(8, 11),
+               np.random.rand(8)),
+    LinalgCase("1x5",
+               np.random.rand(1, 5),
+               np.random.rand(1)),
+    LinalgCase("5x1",
+               np.random.rand(5, 1),
+               np.random.rand(5)),
+    LinalgCase("0x4",
+               np.random.rand(0, 4),
+               np.random.rand(0),
+               tags={'size-0'}),
+    LinalgCase("4x0",
+               np.random.rand(4, 0),
+               np.random.rand(4),
+               tags={'size-0'}),
+])
+
+# hermitian test-cases
+CASES += apply_tag('hermitian', [
+    LinalgCase("hsingle",
+               array([[1., 2.], [2., 1.]], dtype=single),
+               None),
+    LinalgCase("hdouble",
+               array([[1., 2.], [2., 1.]], dtype=double),
+               None),
+    LinalgCase("hcsingle",
+               array([[1., 2 + 3j], [2 - 3j, 1]], dtype=csingle),
+               None),
+    LinalgCase("hcdouble",
+               array([[1., 2 + 3j], [2 - 3j, 1]], dtype=cdouble),
+               None),
+    LinalgCase("hempty",
+               np.empty((0, 0), dtype=double),
+               None,
+               tags={'size-0'}),
+    LinalgCase("hnonarray",
+               [[1, 2], [2, 1]],
+               None),
+    LinalgCase("matrix_b_only",
+               array([[1., 2.], [2., 1.]]),
+               None),
+    LinalgCase("hmatrix_1x1",
+               np.random.rand(1, 1),
+               None),
+])
+
+
+#
+# Gufunc test cases
+#
+def _make_generalized_cases():
+    new_cases = []
+
+    for case in CASES:
+        if not isinstance(case.a, np.ndarray):
+            continue
+
+        a = np.array([case.a, 2 * case.a, 3 * case.a])
+        if case.b is None:
+            b = None
+        elif case.b.ndim == 1:
+            b = case.b
+        else:
+            b = np.array([case.b, 7 * case.b, 6 * case.b])
+        new_case = LinalgCase(case.name + "_tile3", a, b,
+                              tags=case.tags | {'generalized'})
+        new_cases.append(new_case)
+
+        a = np.array([case.a] * 2 * 3).reshape((3, 2) + case.a.shape)
+        if case.b is None:
+            b = None
+        elif case.b.ndim == 1:
+            b = np.array([case.b] * 2 * 3 * a.shape[-1])\
+                  .reshape((3, 2) + case.a.shape[-2:])
+        else:
+            b = np.array([case.b] * 2 * 3).reshape((3, 2) + case.b.shape)
+        new_case = LinalgCase(case.name + "_tile213", a, b,
+                              tags=case.tags | {'generalized'})
+        new_cases.append(new_case)
+
+    return new_cases
+
+
+CASES += _make_generalized_cases()
+
+
+#
+# Generate stride combination variations of the above
+#
+def _stride_comb_iter(x):
+    """
+    Generate cartesian product of strides for all axes
+    """
+
+    if not isinstance(x, np.ndarray):
+        yield x, "nop"
+        return
+
+    stride_set = [(1,)] * x.ndim
+    stride_set[-1] = (1, 3, -4)
+    if x.ndim > 1:
+        stride_set[-2] = (1, 3, -4)
+    if x.ndim > 2:
+        stride_set[-3] = (1, -4)
+
+    for repeats in itertools.product(*tuple(stride_set)):
+        new_shape = [abs(a * b) for a, b in zip(x.shape, repeats)]
+        slices = tuple([slice(None, None, repeat) for repeat in repeats])
+
+        # new array with different strides, but same data
+        xi = np.empty(new_shape, dtype=x.dtype)
+        xi.view(np.uint32).fill(0xdeadbeef)
+        xi = xi[slices]
+        xi[...] = x
+        xi = xi.view(x.__class__)
+        assert_(np.all(xi == x))
+        yield xi, "stride_" + "_".join(["%+d" % j for j in repeats])
+
+        # generate also zero strides if possible
+        if x.ndim >= 1 and x.shape[-1] == 1:
+            s = list(x.strides)
+            s[-1] = 0
+            xi = np.lib.stride_tricks.as_strided(x, strides=s)
+            yield xi, "stride_xxx_0"
+        if x.ndim >= 2 and x.shape[-2] == 1:
+            s = list(x.strides)
+            s[-2] = 0
+            xi = np.lib.stride_tricks.as_strided(x, strides=s)
+            yield xi, "stride_xxx_0_x"
+        if x.ndim >= 2 and x.shape[:-2] == (1, 1):
+            s = list(x.strides)
+            s[-1] = 0
+            s[-2] = 0
+            xi = np.lib.stride_tricks.as_strided(x, strides=s)
+            yield xi, "stride_xxx_0_0"
+
+
+def _make_strided_cases():
+    new_cases = []
+    for case in CASES:
+        for a, a_label in _stride_comb_iter(case.a):
+            for b, b_label in _stride_comb_iter(case.b):
+                new_case = LinalgCase(case.name + "_" + a_label + "_" + b_label, a, b,
+                                      tags=case.tags | {'strided'})
+                new_cases.append(new_case)
+    return new_cases
+
+
+CASES += _make_strided_cases()
+
+
+#
+# Test different routines against the above cases
+#
+class LinalgTestCase:
+    TEST_CASES = CASES
+
+    def check_cases(self, require=set(), exclude=set()):
+        """
+        Run func on each of the cases with all of the tags in require, and none
+        of the tags in exclude
+        """
+        for case in self.TEST_CASES:
+            # filter by require and exclude
+            if case.tags & require != require:
+                continue
+            if case.tags & exclude:
+                continue
+
+            try:
+                case.check(self.do)
+            except Exception as e:
+                msg = f'In test case: {case!r}\n\n'
+                msg += traceback.format_exc()
+                raise AssertionError(msg) from e
+
+
+class LinalgSquareTestCase(LinalgTestCase):
+
+    def test_sq_cases(self):
+        self.check_cases(require={'square'},
+                         exclude={'generalized', 'size-0'})
+
+    def test_empty_sq_cases(self):
+        self.check_cases(require={'square', 'size-0'},
+                         exclude={'generalized'})
+
+
+class LinalgNonsquareTestCase(LinalgTestCase):
+
+    def test_nonsq_cases(self):
+        self.check_cases(require={'nonsquare'},
+                         exclude={'generalized', 'size-0'})
+
+    def test_empty_nonsq_cases(self):
+        self.check_cases(require={'nonsquare', 'size-0'},
+                         exclude={'generalized'})
+
+
+class HermitianTestCase(LinalgTestCase):
+
+    def test_herm_cases(self):
+        self.check_cases(require={'hermitian'},
+                         exclude={'generalized', 'size-0'})
+
+    def test_empty_herm_cases(self):
+        self.check_cases(require={'hermitian', 'size-0'},
+                         exclude={'generalized'})
+
+
+class LinalgGeneralizedSquareTestCase(LinalgTestCase):
+
+    @pytest.mark.slow
+    def test_generalized_sq_cases(self):
+        self.check_cases(require={'generalized', 'square'},
+                         exclude={'size-0'})
+
+    @pytest.mark.slow
+    def test_generalized_empty_sq_cases(self):
+        self.check_cases(require={'generalized', 'square', 'size-0'})
+
+
+class LinalgGeneralizedNonsquareTestCase(LinalgTestCase):
+
+    @pytest.mark.slow
+    def test_generalized_nonsq_cases(self):
+        self.check_cases(require={'generalized', 'nonsquare'},
+                         exclude={'size-0'})
+
+    @pytest.mark.slow
+    def test_generalized_empty_nonsq_cases(self):
+        self.check_cases(require={'generalized', 'nonsquare', 'size-0'})
+
+
+class HermitianGeneralizedTestCase(LinalgTestCase):
+
+    @pytest.mark.slow
+    def test_generalized_herm_cases(self):
+        self.check_cases(require={'generalized', 'hermitian'},
+                         exclude={'size-0'})
+
+    @pytest.mark.slow
+    def test_generalized_empty_herm_cases(self):
+        self.check_cases(require={'generalized', 'hermitian', 'size-0'},
+                         exclude={'none'})
+
+
+def identity_like_generalized(a):
+    a = asarray(a)
+    if a.ndim >= 3:
+        r = np.empty(a.shape, dtype=a.dtype)
+        r[...] = identity(a.shape[-2])
+        return r
+    else:
+        return identity(a.shape[0])
+
+
+class SolveCases(LinalgSquareTestCase, LinalgGeneralizedSquareTestCase):
+    # kept apart from TestSolve for use for testing with matrices.
+    def do(self, a, b, tags):
+        x = linalg.solve(a, b)
+        if np.array(b).ndim == 1:
+            # When a is (..., M, M) and b is (M,), it is the same as when b is
+            # (M, 1), except the result has shape (..., M)
+            adotx = matmul(a, x[..., None])[..., 0]
+            assert_almost_equal(np.broadcast_to(b, adotx.shape), adotx)
+        else:
+            adotx = matmul(a, x)
+            assert_almost_equal(b, adotx)
+        assert_(consistent_subclass(x, b))
+
+
+class TestSolve(SolveCases):
+    @pytest.mark.parametrize('dtype', [single, double, csingle, cdouble])
+    def test_types(self, dtype):
+        x = np.array([[1, 0.5], [0.5, 1]], dtype=dtype)
+        assert_equal(linalg.solve(x, x).dtype, dtype)
+
+    def test_1_d(self):
+        class ArraySubclass(np.ndarray):
+            pass
+        a = np.arange(8).reshape(2, 2, 2)
+        b = np.arange(2).view(ArraySubclass)
+        result = linalg.solve(a, b)
+        assert result.shape == (2, 2)
+
+        # If b is anything other than 1-D it should be treated as a stack of
+        # matrices
+        b = np.arange(4).reshape(2, 2).view(ArraySubclass)
+        result = linalg.solve(a, b)
+        assert result.shape == (2, 2, 2)
+
+        b = np.arange(2).reshape(1, 2).view(ArraySubclass)
+        assert_raises(ValueError, linalg.solve, a, b)
+
+    def test_0_size(self):
+        class ArraySubclass(np.ndarray):
+            pass
+        # Test system of 0x0 matrices
+        a = np.arange(8).reshape(2, 2, 2)
+        b = np.arange(6).reshape(1, 2, 3).view(ArraySubclass)
+
+        expected = linalg.solve(a, b)[:, 0:0, :]
+        result = linalg.solve(a[:, 0:0, 0:0], b[:, 0:0, :])
+        assert_array_equal(result, expected)
+        assert_(isinstance(result, ArraySubclass))
+
+        # Test errors for non-square and only b's dimension being 0
+        assert_raises(linalg.LinAlgError, linalg.solve, a[:, 0:0, 0:1], b)
+        assert_raises(ValueError, linalg.solve, a, b[:, 0:0, :])
+
+        # Test broadcasting error
+        b = np.arange(6).reshape(1, 3, 2)  # broadcasting error
+        assert_raises(ValueError, linalg.solve, a, b)
+        assert_raises(ValueError, linalg.solve, a[0:0], b[0:0])
+
+        # Test zero "single equations" with 0x0 matrices.
+        b = np.arange(2).view(ArraySubclass)
+        expected = linalg.solve(a, b)[:, 0:0]
+        result = linalg.solve(a[:, 0:0, 0:0], b[0:0])
+        assert_array_equal(result, expected)
+        assert_(isinstance(result, ArraySubclass))
+
+        b = np.arange(3).reshape(1, 3)
+        assert_raises(ValueError, linalg.solve, a, b)
+        assert_raises(ValueError, linalg.solve, a[0:0], b[0:0])
+        assert_raises(ValueError, linalg.solve, a[:, 0:0, 0:0], b)
+
+    def test_0_size_k(self):
+        # test zero multiple equation (K=0) case.
+        class ArraySubclass(np.ndarray):
+            pass
+        a = np.arange(4).reshape(1, 2, 2)
+        b = np.arange(6).reshape(3, 2, 1).view(ArraySubclass)
+
+        expected = linalg.solve(a, b)[:, :, 0:0]
+        result = linalg.solve(a, b[:, :, 0:0])
+        assert_array_equal(result, expected)
+        assert_(isinstance(result, ArraySubclass))
+
+        # test both zero.
+        expected = linalg.solve(a, b)[:, 0:0, 0:0]
+        result = linalg.solve(a[:, 0:0, 0:0], b[:, 0:0, 0:0])
+        assert_array_equal(result, expected)
+        assert_(isinstance(result, ArraySubclass))
+
+
+class InvCases(LinalgSquareTestCase, LinalgGeneralizedSquareTestCase):
+
+    def do(self, a, b, tags):
+        a_inv = linalg.inv(a)
+        assert_almost_equal(matmul(a, a_inv),
+                            identity_like_generalized(a))
+        assert_(consistent_subclass(a_inv, a))
+
+
+class TestInv(InvCases):
+    @pytest.mark.parametrize('dtype', [single, double, csingle, cdouble])
+    def test_types(self, dtype):
+        x = np.array([[1, 0.5], [0.5, 1]], dtype=dtype)
+        assert_equal(linalg.inv(x).dtype, dtype)
+
+    def test_0_size(self):
+        # Check that all kinds of 0-sized arrays work
+        class ArraySubclass(np.ndarray):
+            pass
+        a = np.zeros((0, 1, 1), dtype=np.int_).view(ArraySubclass)
+        res = linalg.inv(a)
+        assert_(res.dtype.type is np.float64)
+        assert_equal(a.shape, res.shape)
+        assert_(isinstance(res, ArraySubclass))
+
+        a = np.zeros((0, 0), dtype=np.complex64).view(ArraySubclass)
+        res = linalg.inv(a)
+        assert_(res.dtype.type is np.complex64)
+        assert_equal(a.shape, res.shape)
+        assert_(isinstance(res, ArraySubclass))
+
+
+class EigvalsCases(LinalgSquareTestCase, LinalgGeneralizedSquareTestCase):
+
+    def do(self, a, b, tags):
+        ev = linalg.eigvals(a)
+        evalues, evectors = linalg.eig(a)
+        assert_almost_equal(ev, evalues)
+
+
+class TestEigvals(EigvalsCases):
+    @pytest.mark.parametrize('dtype', [single, double, csingle, cdouble])
+    def test_types(self, dtype):
+        x = np.array([[1, 0.5], [0.5, 1]], dtype=dtype)
+        assert_equal(linalg.eigvals(x).dtype, dtype)
+        x = np.array([[1, 0.5], [-1, 1]], dtype=dtype)
+        assert_equal(linalg.eigvals(x).dtype, get_complex_dtype(dtype))
+
+    def test_0_size(self):
+        # Check that all kinds of 0-sized arrays work
+        class ArraySubclass(np.ndarray):
+            pass
+        a = np.zeros((0, 1, 1), dtype=np.int_).view(ArraySubclass)
+        res = linalg.eigvals(a)
+        assert_(res.dtype.type is np.float64)
+        assert_equal((0, 1), res.shape)
+        # This is just for documentation, it might make sense to change:
+        assert_(isinstance(res, np.ndarray))
+
+        a = np.zeros((0, 0), dtype=np.complex64).view(ArraySubclass)
+        res = linalg.eigvals(a)
+        assert_(res.dtype.type is np.complex64)
+        assert_equal((0,), res.shape)
+        # This is just for documentation, it might make sense to change:
+        assert_(isinstance(res, np.ndarray))
+
+
+class EigCases(LinalgSquareTestCase, LinalgGeneralizedSquareTestCase):
+
+    def do(self, a, b, tags):
+        res = linalg.eig(a)
+        eigenvalues, eigenvectors = res.eigenvalues, res.eigenvectors
+        assert_allclose(matmul(a, eigenvectors),
+                        np.asarray(eigenvectors) * np.asarray(eigenvalues)[..., None, :],
+                        rtol=get_rtol(eigenvalues.dtype))
+        assert_(consistent_subclass(eigenvectors, a))
+
+
+class TestEig(EigCases):
+    @pytest.mark.parametrize('dtype', [single, double, csingle, cdouble])
+    def test_types(self, dtype):
+        x = np.array([[1, 0.5], [0.5, 1]], dtype=dtype)
+        w, v = np.linalg.eig(x)
+        assert_equal(w.dtype, dtype)
+        assert_equal(v.dtype, dtype)
+
+        x = np.array([[1, 0.5], [-1, 1]], dtype=dtype)
+        w, v = np.linalg.eig(x)
+        assert_equal(w.dtype, get_complex_dtype(dtype))
+        assert_equal(v.dtype, get_complex_dtype(dtype))
+
+    def test_0_size(self):
+        # Check that all kinds of 0-sized arrays work
+        class ArraySubclass(np.ndarray):
+            pass
+        a = np.zeros((0, 1, 1), dtype=np.int_).view(ArraySubclass)
+        res, res_v = linalg.eig(a)
+        assert_(res_v.dtype.type is np.float64)
+        assert_(res.dtype.type is np.float64)
+        assert_equal(a.shape, res_v.shape)
+        assert_equal((0, 1), res.shape)
+        # This is just for documentation, it might make sense to change:
+        assert_(isinstance(a, np.ndarray))
+
+        a = np.zeros((0, 0), dtype=np.complex64).view(ArraySubclass)
+        res, res_v = linalg.eig(a)
+        assert_(res_v.dtype.type is np.complex64)
+        assert_(res.dtype.type is np.complex64)
+        assert_equal(a.shape, res_v.shape)
+        assert_equal((0,), res.shape)
+        # This is just for documentation, it might make sense to change:
+        assert_(isinstance(a, np.ndarray))
+
+
+class SVDBaseTests:
+    hermitian = False
+
+    @pytest.mark.parametrize('dtype', [single, double, csingle, cdouble])
+    def test_types(self, dtype):
+        x = np.array([[1, 0.5], [0.5, 1]], dtype=dtype)
+        res = linalg.svd(x)
+        U, S, Vh = res.U, res.S, res.Vh
+        assert_equal(U.dtype, dtype)
+        assert_equal(S.dtype, get_real_dtype(dtype))
+        assert_equal(Vh.dtype, dtype)
+        s = linalg.svd(x, compute_uv=False, hermitian=self.hermitian)
+        assert_equal(s.dtype, get_real_dtype(dtype))
+
+
+class SVDCases(LinalgSquareTestCase, LinalgGeneralizedSquareTestCase):
+
+    def do(self, a, b, tags):
+        u, s, vt = linalg.svd(a, False)
+        assert_allclose(a, matmul(np.asarray(u) * np.asarray(s)[..., None, :],
+                                           np.asarray(vt)),
+                        rtol=get_rtol(u.dtype))
+        assert_(consistent_subclass(u, a))
+        assert_(consistent_subclass(vt, a))
+
+
+class TestSVD(SVDCases, SVDBaseTests):
+    def test_empty_identity(self):
+        """ Empty input should put an identity matrix in u or vh """
+        x = np.empty((4, 0))
+        u, s, vh = linalg.svd(x, compute_uv=True, hermitian=self.hermitian)
+        assert_equal(u.shape, (4, 4))
+        assert_equal(vh.shape, (0, 0))
+        assert_equal(u, np.eye(4))
+
+        x = np.empty((0, 4))
+        u, s, vh = linalg.svd(x, compute_uv=True, hermitian=self.hermitian)
+        assert_equal(u.shape, (0, 0))
+        assert_equal(vh.shape, (4, 4))
+        assert_equal(vh, np.eye(4))
+
+    def test_svdvals(self):
+        x = np.array([[1, 0.5], [0.5, 1]])
+        s_from_svd = linalg.svd(x, compute_uv=False, hermitian=self.hermitian)
+        s_from_svdvals = linalg.svdvals(x)
+        assert_almost_equal(s_from_svd, s_from_svdvals)
+
+
+class SVDHermitianCases(HermitianTestCase, HermitianGeneralizedTestCase):
+
+    def do(self, a, b, tags):
+        u, s, vt = linalg.svd(a, False, hermitian=True)
+        assert_allclose(a, matmul(np.asarray(u) * np.asarray(s)[..., None, :],
+                                           np.asarray(vt)),
+                        rtol=get_rtol(u.dtype))
+        def hermitian(mat):
+            axes = list(range(mat.ndim))
+            axes[-1], axes[-2] = axes[-2], axes[-1]
+            return np.conj(np.transpose(mat, axes=axes))
+
+        assert_almost_equal(np.matmul(u, hermitian(u)), np.broadcast_to(np.eye(u.shape[-1]), u.shape))
+        assert_almost_equal(np.matmul(vt, hermitian(vt)), np.broadcast_to(np.eye(vt.shape[-1]), vt.shape))
+        assert_equal(np.sort(s)[..., ::-1], s)
+        assert_(consistent_subclass(u, a))
+        assert_(consistent_subclass(vt, a))
+
+
+class TestSVDHermitian(SVDHermitianCases, SVDBaseTests):
+    hermitian = True
+
+
+class CondCases(LinalgSquareTestCase, LinalgGeneralizedSquareTestCase):
+    # cond(x, p) for p in (None, 2, -2)
+
+    def do(self, a, b, tags):
+        c = asarray(a)  # a might be a matrix
+        if 'size-0' in tags:
+            assert_raises(LinAlgError, linalg.cond, c)
+            return
+
+        # +-2 norms
+        s = linalg.svd(c, compute_uv=False)
+        assert_almost_equal(
+            linalg.cond(a), s[..., 0] / s[..., -1],
+            single_decimal=5, double_decimal=11)
+        assert_almost_equal(
+            linalg.cond(a, 2), s[..., 0] / s[..., -1],
+            single_decimal=5, double_decimal=11)
+        assert_almost_equal(
+            linalg.cond(a, -2), s[..., -1] / s[..., 0],
+            single_decimal=5, double_decimal=11)
+
+        # Other norms
+        cinv = np.linalg.inv(c)
+        assert_almost_equal(
+            linalg.cond(a, 1),
+            abs(c).sum(-2).max(-1) * abs(cinv).sum(-2).max(-1),
+            single_decimal=5, double_decimal=11)
+        assert_almost_equal(
+            linalg.cond(a, -1),
+            abs(c).sum(-2).min(-1) * abs(cinv).sum(-2).min(-1),
+            single_decimal=5, double_decimal=11)
+        assert_almost_equal(
+            linalg.cond(a, np.inf),
+            abs(c).sum(-1).max(-1) * abs(cinv).sum(-1).max(-1),
+            single_decimal=5, double_decimal=11)
+        assert_almost_equal(
+            linalg.cond(a, -np.inf),
+            abs(c).sum(-1).min(-1) * abs(cinv).sum(-1).min(-1),
+            single_decimal=5, double_decimal=11)
+        assert_almost_equal(
+            linalg.cond(a, 'fro'),
+            np.sqrt((abs(c)**2).sum(-1).sum(-1)
+                    * (abs(cinv)**2).sum(-1).sum(-1)),
+            single_decimal=5, double_decimal=11)
+
+
+class TestCond(CondCases):
+    def test_basic_nonsvd(self):
+        # Smoketest the non-svd norms
+        A = array([[1., 0, 1], [0, -2., 0], [0, 0, 3.]])
+        assert_almost_equal(linalg.cond(A, inf), 4)
+        assert_almost_equal(linalg.cond(A, -inf), 2/3)
+        assert_almost_equal(linalg.cond(A, 1), 4)
+        assert_almost_equal(linalg.cond(A, -1), 0.5)
+        assert_almost_equal(linalg.cond(A, 'fro'), np.sqrt(265 / 12))
+
+    def test_singular(self):
+        # Singular matrices have infinite condition number for
+        # positive norms, and negative norms shouldn't raise
+        # exceptions
+        As = [np.zeros((2, 2)), np.ones((2, 2))]
+        p_pos = [None, 1, 2, 'fro']
+        p_neg = [-1, -2]
+        for A, p in itertools.product(As, p_pos):
+            # Inversion may not hit exact infinity, so just check the
+            # number is large
+            assert_(linalg.cond(A, p) > 1e15)
+        for A, p in itertools.product(As, p_neg):
+            linalg.cond(A, p)
+
+    @pytest.mark.xfail(True, run=False,
+                       reason="Platform/LAPACK-dependent failure, "
+                              "see gh-18914")
+    def test_nan(self):
+        # nans should be passed through, not converted to infs
+        ps = [None, 1, -1, 2, -2, 'fro']
+        p_pos = [None, 1, 2, 'fro']
+
+        A = np.ones((2, 2))
+        A[0,1] = np.nan
+        for p in ps:
+            c = linalg.cond(A, p)
+            assert_(isinstance(c, np.float64))
+            assert_(np.isnan(c))
+
+        A = np.ones((3, 2, 2))
+        A[1,0,1] = np.nan
+        for p in ps:
+            c = linalg.cond(A, p)
+            assert_(np.isnan(c[1]))
+            if p in p_pos:
+                assert_(c[0] > 1e15)
+                assert_(c[2] > 1e15)
+            else:
+                assert_(not np.isnan(c[0]))
+                assert_(not np.isnan(c[2]))
+
+    def test_stacked_singular(self):
+        # Check behavior when only some of the stacked matrices are
+        # singular
+        np.random.seed(1234)
+        A = np.random.rand(2, 2, 2, 2)
+        A[0,0] = 0
+        A[1,1] = 0
+
+        for p in (None, 1, 2, 'fro', -1, -2):
+            c = linalg.cond(A, p)
+            assert_equal(c[0,0], np.inf)
+            assert_equal(c[1,1], np.inf)
+            assert_(np.isfinite(c[0,1]))
+            assert_(np.isfinite(c[1,0]))
+
+
+class PinvCases(LinalgSquareTestCase,
+                LinalgNonsquareTestCase,
+                LinalgGeneralizedSquareTestCase,
+                LinalgGeneralizedNonsquareTestCase):
+
+    def do(self, a, b, tags):
+        a_ginv = linalg.pinv(a)
+        # `a @ a_ginv == I` does not hold if a is singular
+        dot = matmul
+        assert_almost_equal(dot(dot(a, a_ginv), a), a, single_decimal=5, double_decimal=11)
+        assert_(consistent_subclass(a_ginv, a))
+
+
+class TestPinv(PinvCases):
+    pass
+
+
+class PinvHermitianCases(HermitianTestCase, HermitianGeneralizedTestCase):
+
+    def do(self, a, b, tags):
+        a_ginv = linalg.pinv(a, hermitian=True)
+        # `a @ a_ginv == I` does not hold if a is singular
+        dot = matmul
+        assert_almost_equal(dot(dot(a, a_ginv), a), a, single_decimal=5, double_decimal=11)
+        assert_(consistent_subclass(a_ginv, a))
+
+
+class TestPinvHermitian(PinvHermitianCases):
+    pass
+
+
+def test_pinv_rtol_arg():
+    a = np.array([[1, 2, 3], [4, 1, 1], [2, 3, 1]])
+
+    assert_almost_equal(
+        np.linalg.pinv(a, rcond=0.5),
+        np.linalg.pinv(a, rtol=0.5),
+    )
+
+    with pytest.raises(
+        ValueError, match=r"`rtol` and `rcond` can't be both set."
+    ):
+        np.linalg.pinv(a, rcond=0.5, rtol=0.5)
+
+
+class DetCases(LinalgSquareTestCase, LinalgGeneralizedSquareTestCase):
+
+    def do(self, a, b, tags):
+        d = linalg.det(a)
+        res = linalg.slogdet(a)
+        s, ld = res.sign, res.logabsdet
+        if asarray(a).dtype.type in (single, double):
+            ad = asarray(a).astype(double)
+        else:
+            ad = asarray(a).astype(cdouble)
+        ev = linalg.eigvals(ad)
+        assert_almost_equal(d, multiply.reduce(ev, axis=-1))
+        assert_almost_equal(s * np.exp(ld), multiply.reduce(ev, axis=-1))
+
+        s = np.atleast_1d(s)
+        ld = np.atleast_1d(ld)
+        m = (s != 0)
+        assert_almost_equal(np.abs(s[m]), 1)
+        assert_equal(ld[~m], -inf)
+
+
+class TestDet(DetCases):
+    def test_zero(self):
+        assert_equal(linalg.det([[0.0]]), 0.0)
+        assert_equal(type(linalg.det([[0.0]])), double)
+        assert_equal(linalg.det([[0.0j]]), 0.0)
+        assert_equal(type(linalg.det([[0.0j]])), cdouble)
+
+        assert_equal(linalg.slogdet([[0.0]]), (0.0, -inf))
+        assert_equal(type(linalg.slogdet([[0.0]])[0]), double)
+        assert_equal(type(linalg.slogdet([[0.0]])[1]), double)
+        assert_equal(linalg.slogdet([[0.0j]]), (0.0j, -inf))
+        assert_equal(type(linalg.slogdet([[0.0j]])[0]), cdouble)
+        assert_equal(type(linalg.slogdet([[0.0j]])[1]), double)
+
+    @pytest.mark.parametrize('dtype', [single, double, csingle, cdouble])
+    def test_types(self, dtype):
+        x = np.array([[1, 0.5], [0.5, 1]], dtype=dtype)
+        assert_equal(np.linalg.det(x).dtype, dtype)
+        ph, s = np.linalg.slogdet(x)
+        assert_equal(s.dtype, get_real_dtype(dtype))
+        assert_equal(ph.dtype, dtype)
+
+    def test_0_size(self):
+        a = np.zeros((0, 0), dtype=np.complex64)
+        res = linalg.det(a)
+        assert_equal(res, 1.)
+        assert_(res.dtype.type is np.complex64)
+        res = linalg.slogdet(a)
+        assert_equal(res, (1, 0))
+        assert_(res[0].dtype.type is np.complex64)
+        assert_(res[1].dtype.type is np.float32)
+
+        a = np.zeros((0, 0), dtype=np.float64)
+        res = linalg.det(a)
+        assert_equal(res, 1.)
+        assert_(res.dtype.type is np.float64)
+        res = linalg.slogdet(a)
+        assert_equal(res, (1, 0))
+        assert_(res[0].dtype.type is np.float64)
+        assert_(res[1].dtype.type is np.float64)
+
+
+class LstsqCases(LinalgSquareTestCase, LinalgNonsquareTestCase):
+
+    def do(self, a, b, tags):
+        arr = np.asarray(a)
+        m, n = arr.shape
+        u, s, vt = linalg.svd(a, False)
+        x, residuals, rank, sv = linalg.lstsq(a, b, rcond=-1)
+        if m == 0:
+            assert_((x == 0).all())
+        if m <= n:
+            assert_almost_equal(b, dot(a, x))
+            assert_equal(rank, m)
+        else:
+            assert_equal(rank, n)
+        assert_almost_equal(sv, sv.__array_wrap__(s))
+        if rank == n and m > n:
+            expect_resids = (
+                np.asarray(abs(np.dot(a, x) - b)) ** 2).sum(axis=0)
+            expect_resids = np.asarray(expect_resids)
+            if np.asarray(b).ndim == 1:
+                expect_resids.shape = (1,)
+                assert_equal(residuals.shape, expect_resids.shape)
+        else:
+            expect_resids = np.array([]).view(type(x))
+        assert_almost_equal(residuals, expect_resids)
+        assert_(np.issubdtype(residuals.dtype, np.floating))
+        assert_(consistent_subclass(x, b))
+        assert_(consistent_subclass(residuals, b))
+
+
+class TestLstsq(LstsqCases):
+    def test_rcond(self):
+        a = np.array([[0., 1.,  0.,  1.,  2.,  0.],
+                      [0., 2.,  0.,  0.,  1.,  0.],
+                      [1., 0.,  1.,  0.,  0.,  4.],
+                      [0., 0.,  0.,  2.,  3.,  0.]]).T
+
+        b = np.array([1, 0, 0, 0, 0, 0])
+
+        x, residuals, rank, s = linalg.lstsq(a, b, rcond=-1)
+        assert_(rank == 4)
+        x, residuals, rank, s = linalg.lstsq(a, b)
+        assert_(rank == 3)
+        x, residuals, rank, s = linalg.lstsq(a, b, rcond=None)
+        assert_(rank == 3)
+
+    @pytest.mark.parametrize(["m", "n", "n_rhs"], [
+        (4, 2, 2),
+        (0, 4, 1),
+        (0, 4, 2),
+        (4, 0, 1),
+        (4, 0, 2),
+        (4, 2, 0),
+        (0, 0, 0)
+    ])
+    def test_empty_a_b(self, m, n, n_rhs):
+        a = np.arange(m * n).reshape(m, n)
+        b = np.ones((m, n_rhs))
+        x, residuals, rank, s = linalg.lstsq(a, b, rcond=None)
+        if m == 0:
+            assert_((x == 0).all())
+        assert_equal(x.shape, (n, n_rhs))
+        assert_equal(residuals.shape, ((n_rhs,) if m > n else (0,)))
+        if m > n and n_rhs > 0:
+            # residuals are exactly the squared norms of b's columns
+            r = b - np.dot(a, x)
+            assert_almost_equal(residuals, (r * r).sum(axis=-2))
+        assert_equal(rank, min(m, n))
+        assert_equal(s.shape, (min(m, n),))
+
+    def test_incompatible_dims(self):
+        # use modified version of docstring example
+        x = np.array([0, 1, 2, 3])
+        y = np.array([-1, 0.2, 0.9, 2.1, 3.3])
+        A = np.vstack([x, np.ones(len(x))]).T
+        with assert_raises_regex(LinAlgError, "Incompatible dimensions"):
+            linalg.lstsq(A, y, rcond=None)
+
+
+@pytest.mark.parametrize('dt', [np.dtype(c) for c in '?bBhHiIqQefdgFDGO'])
+class TestMatrixPower:
+
+    rshft_0 = np.eye(4)
+    rshft_1 = rshft_0[[3, 0, 1, 2]]
+    rshft_2 = rshft_0[[2, 3, 0, 1]]
+    rshft_3 = rshft_0[[1, 2, 3, 0]]
+    rshft_all = [rshft_0, rshft_1, rshft_2, rshft_3]
+    noninv = array([[1, 0], [0, 0]])
+    stacked = np.block([[[rshft_0]]]*2)
+    #FIXME the 'e' dtype might work in future
+    dtnoinv = [object, np.dtype('e'), np.dtype('g'), np.dtype('G')]
+
+    def test_large_power(self, dt):
+        rshft = self.rshft_1.astype(dt)
+        assert_equal(
+            matrix_power(rshft, 2**100 + 2**10 + 2**5 + 0), self.rshft_0)
+        assert_equal(
+            matrix_power(rshft, 2**100 + 2**10 + 2**5 + 1), self.rshft_1)
+        assert_equal(
+            matrix_power(rshft, 2**100 + 2**10 + 2**5 + 2), self.rshft_2)
+        assert_equal(
+            matrix_power(rshft, 2**100 + 2**10 + 2**5 + 3), self.rshft_3)
+
+    def test_power_is_zero(self, dt):
+        def tz(M):
+            mz = matrix_power(M, 0)
+            assert_equal(mz, identity_like_generalized(M))
+            assert_equal(mz.dtype, M.dtype)
+
+        for mat in self.rshft_all:
+            tz(mat.astype(dt))
+            if dt != object:
+                tz(self.stacked.astype(dt))
+
+    def test_power_is_one(self, dt):
+        def tz(mat):
+            mz = matrix_power(mat, 1)
+            assert_equal(mz, mat)
+            assert_equal(mz.dtype, mat.dtype)
+
+        for mat in self.rshft_all:
+            tz(mat.astype(dt))
+            if dt != object:
+                tz(self.stacked.astype(dt))
+
+    def test_power_is_two(self, dt):
+        def tz(mat):
+            mz = matrix_power(mat, 2)
+            mmul = matmul if mat.dtype != object else dot
+            assert_equal(mz, mmul(mat, mat))
+            assert_equal(mz.dtype, mat.dtype)
+
+        for mat in self.rshft_all:
+            tz(mat.astype(dt))
+            if dt != object:
+                tz(self.stacked.astype(dt))
+
+    def test_power_is_minus_one(self, dt):
+        def tz(mat):
+            invmat = matrix_power(mat, -1)
+            mmul = matmul if mat.dtype != object else dot
+            assert_almost_equal(
+                mmul(invmat, mat), identity_like_generalized(mat))
+
+        for mat in self.rshft_all:
+            if dt not in self.dtnoinv:
+                tz(mat.astype(dt))
+
+    def test_exceptions_bad_power(self, dt):
+        mat = self.rshft_0.astype(dt)
+        assert_raises(TypeError, matrix_power, mat, 1.5)
+        assert_raises(TypeError, matrix_power, mat, [1])
+
+    def test_exceptions_non_square(self, dt):
+        assert_raises(LinAlgError, matrix_power, np.array([1], dt), 1)
+        assert_raises(LinAlgError, matrix_power, np.array([[1], [2]], dt), 1)
+        assert_raises(LinAlgError, matrix_power, np.ones((4, 3, 2), dt), 1)
+
+    @pytest.mark.skipif(IS_WASM, reason="fp errors don't work in wasm")
+    def test_exceptions_not_invertible(self, dt):
+        if dt in self.dtnoinv:
+            return
+        mat = self.noninv.astype(dt)
+        assert_raises(LinAlgError, matrix_power, mat, -1)
+
+
+class TestEigvalshCases(HermitianTestCase, HermitianGeneralizedTestCase):
+
+    def do(self, a, b, tags):
+        # note that eigenvalue arrays returned by eig must be sorted since
+        # their order isn't guaranteed.
+        ev = linalg.eigvalsh(a, 'L')
+        evalues, evectors = linalg.eig(a)
+        evalues.sort(axis=-1)
+        assert_allclose(ev, evalues, rtol=get_rtol(ev.dtype))
+
+        ev2 = linalg.eigvalsh(a, 'U')
+        assert_allclose(ev2, evalues, rtol=get_rtol(ev.dtype))
+
+
+class TestEigvalsh:
+    @pytest.mark.parametrize('dtype', [single, double, csingle, cdouble])
+    def test_types(self, dtype):
+        x = np.array([[1, 0.5], [0.5, 1]], dtype=dtype)
+        w = np.linalg.eigvalsh(x)
+        assert_equal(w.dtype, get_real_dtype(dtype))
+
+    def test_invalid(self):
+        x = np.array([[1, 0.5], [0.5, 1]], dtype=np.float32)
+        assert_raises(ValueError, np.linalg.eigvalsh, x, UPLO="lrong")
+        assert_raises(ValueError, np.linalg.eigvalsh, x, "lower")
+        assert_raises(ValueError, np.linalg.eigvalsh, x, "upper")
+
+    def test_UPLO(self):
+        Klo = np.array([[0, 0], [1, 0]], dtype=np.double)
+        Kup = np.array([[0, 1], [0, 0]], dtype=np.double)
+        tgt = np.array([-1, 1], dtype=np.double)
+        rtol = get_rtol(np.double)
+
+        # Check default is 'L'
+        w = np.linalg.eigvalsh(Klo)
+        assert_allclose(w, tgt, rtol=rtol)
+        # Check 'L'
+        w = np.linalg.eigvalsh(Klo, UPLO='L')
+        assert_allclose(w, tgt, rtol=rtol)
+        # Check 'l'
+        w = np.linalg.eigvalsh(Klo, UPLO='l')
+        assert_allclose(w, tgt, rtol=rtol)
+        # Check 'U'
+        w = np.linalg.eigvalsh(Kup, UPLO='U')
+        assert_allclose(w, tgt, rtol=rtol)
+        # Check 'u'
+        w = np.linalg.eigvalsh(Kup, UPLO='u')
+        assert_allclose(w, tgt, rtol=rtol)
+
+    def test_0_size(self):
+        # Check that all kinds of 0-sized arrays work
+        class ArraySubclass(np.ndarray):
+            pass
+        a = np.zeros((0, 1, 1), dtype=np.int_).view(ArraySubclass)
+        res = linalg.eigvalsh(a)
+        assert_(res.dtype.type is np.float64)
+        assert_equal((0, 1), res.shape)
+        # This is just for documentation, it might make sense to change:
+        assert_(isinstance(res, np.ndarray))
+
+        a = np.zeros((0, 0), dtype=np.complex64).view(ArraySubclass)
+        res = linalg.eigvalsh(a)
+        assert_(res.dtype.type is np.float32)
+        assert_equal((0,), res.shape)
+        # This is just for documentation, it might make sense to change:
+        assert_(isinstance(res, np.ndarray))
+
+
+class TestEighCases(HermitianTestCase, HermitianGeneralizedTestCase):
+
+    def do(self, a, b, tags):
+        # note that eigenvalue arrays returned by eig must be sorted since
+        # their order isn't guaranteed.
+        res = linalg.eigh(a)
+        ev, evc = res.eigenvalues, res.eigenvectors
+        evalues, evectors = linalg.eig(a)
+        evalues.sort(axis=-1)
+        assert_almost_equal(ev, evalues)
+
+        assert_allclose(matmul(a, evc),
+                        np.asarray(ev)[..., None, :] * np.asarray(evc),
+                        rtol=get_rtol(ev.dtype))
+
+        ev2, evc2 = linalg.eigh(a, 'U')
+        assert_almost_equal(ev2, evalues)
+
+        assert_allclose(matmul(a, evc2),
+                        np.asarray(ev2)[..., None, :] * np.asarray(evc2),
+                        rtol=get_rtol(ev.dtype), err_msg=repr(a))
+
+
+class TestEigh:
+    @pytest.mark.parametrize('dtype', [single, double, csingle, cdouble])
+    def test_types(self, dtype):
+        x = np.array([[1, 0.5], [0.5, 1]], dtype=dtype)
+        w, v = np.linalg.eigh(x)
+        assert_equal(w.dtype, get_real_dtype(dtype))
+        assert_equal(v.dtype, dtype)
+
+    def test_invalid(self):
+        x = np.array([[1, 0.5], [0.5, 1]], dtype=np.float32)
+        assert_raises(ValueError, np.linalg.eigh, x, UPLO="lrong")
+        assert_raises(ValueError, np.linalg.eigh, x, "lower")
+        assert_raises(ValueError, np.linalg.eigh, x, "upper")
+
+    def test_UPLO(self):
+        Klo = np.array([[0, 0], [1, 0]], dtype=np.double)
+        Kup = np.array([[0, 1], [0, 0]], dtype=np.double)
+        tgt = np.array([-1, 1], dtype=np.double)
+        rtol = get_rtol(np.double)
+
+        # Check default is 'L'
+        w, v = np.linalg.eigh(Klo)
+        assert_allclose(w, tgt, rtol=rtol)
+        # Check 'L'
+        w, v = np.linalg.eigh(Klo, UPLO='L')
+        assert_allclose(w, tgt, rtol=rtol)
+        # Check 'l'
+        w, v = np.linalg.eigh(Klo, UPLO='l')
+        assert_allclose(w, tgt, rtol=rtol)
+        # Check 'U'
+        w, v = np.linalg.eigh(Kup, UPLO='U')
+        assert_allclose(w, tgt, rtol=rtol)
+        # Check 'u'
+        w, v = np.linalg.eigh(Kup, UPLO='u')
+        assert_allclose(w, tgt, rtol=rtol)
+
+    def test_0_size(self):
+        # Check that all kinds of 0-sized arrays work
+        class ArraySubclass(np.ndarray):
+            pass
+        a = np.zeros((0, 1, 1), dtype=np.int_).view(ArraySubclass)
+        res, res_v = linalg.eigh(a)
+        assert_(res_v.dtype.type is np.float64)
+        assert_(res.dtype.type is np.float64)
+        assert_equal(a.shape, res_v.shape)
+        assert_equal((0, 1), res.shape)
+        # This is just for documentation, it might make sense to change:
+        assert_(isinstance(a, np.ndarray))
+
+        a = np.zeros((0, 0), dtype=np.complex64).view(ArraySubclass)
+        res, res_v = linalg.eigh(a)
+        assert_(res_v.dtype.type is np.complex64)
+        assert_(res.dtype.type is np.float32)
+        assert_equal(a.shape, res_v.shape)
+        assert_equal((0,), res.shape)
+        # This is just for documentation, it might make sense to change:
+        assert_(isinstance(a, np.ndarray))
+
+
+class _TestNormBase:
+    dt = None
+    dec = None
+
+    @staticmethod
+    def check_dtype(x, res):
+        if issubclass(x.dtype.type, np.inexact):
+            assert_equal(res.dtype, x.real.dtype)
+        else:
+            # For integer input, don't have to test float precision of output.
+            assert_(issubclass(res.dtype.type, np.floating))
+
+
+class _TestNormGeneral(_TestNormBase):
+
+    def test_empty(self):
+        assert_equal(norm([]), 0.0)
+        assert_equal(norm(array([], dtype=self.dt)), 0.0)
+        assert_equal(norm(atleast_2d(array([], dtype=self.dt))), 0.0)
+
+    def test_vector_return_type(self):
+        a = np.array([1, 0, 1])
+
+        exact_types = np.typecodes['AllInteger']
+        inexact_types = np.typecodes['AllFloat']
+
+        all_types = exact_types + inexact_types
+
+        for each_type in all_types:
+            at = a.astype(each_type)
+
+            an = norm(at, -np.inf)
+            self.check_dtype(at, an)
+            assert_almost_equal(an, 0.0)
+
+            with suppress_warnings() as sup:
+                sup.filter(RuntimeWarning, "divide by zero encountered")
+                an = norm(at, -1)
+                self.check_dtype(at, an)
+                assert_almost_equal(an, 0.0)
+
+            an = norm(at, 0)
+            self.check_dtype(at, an)
+            assert_almost_equal(an, 2)
+
+            an = norm(at, 1)
+            self.check_dtype(at, an)
+            assert_almost_equal(an, 2.0)
+
+            an = norm(at, 2)
+            self.check_dtype(at, an)
+            assert_almost_equal(an, an.dtype.type(2.0)**an.dtype.type(1.0/2.0))
+
+            an = norm(at, 4)
+            self.check_dtype(at, an)
+            assert_almost_equal(an, an.dtype.type(2.0)**an.dtype.type(1.0/4.0))
+
+            an = norm(at, np.inf)
+            self.check_dtype(at, an)
+            assert_almost_equal(an, 1.0)
+
+    def test_vector(self):
+        a = [1, 2, 3, 4]
+        b = [-1, -2, -3, -4]
+        c = [-1, 2, -3, 4]
+
+        def _test(v):
+            np.testing.assert_almost_equal(norm(v), 30 ** 0.5,
+                                           decimal=self.dec)
+            np.testing.assert_almost_equal(norm(v, inf), 4.0,
+                                           decimal=self.dec)
+            np.testing.assert_almost_equal(norm(v, -inf), 1.0,
+                                           decimal=self.dec)
+            np.testing.assert_almost_equal(norm(v, 1), 10.0,
+                                           decimal=self.dec)
+            np.testing.assert_almost_equal(norm(v, -1), 12.0 / 25,
+                                           decimal=self.dec)
+            np.testing.assert_almost_equal(norm(v, 2), 30 ** 0.5,
+                                           decimal=self.dec)
+            np.testing.assert_almost_equal(norm(v, -2), ((205. / 144) ** -0.5),
+                                           decimal=self.dec)
+            np.testing.assert_almost_equal(norm(v, 0), 4,
+                                           decimal=self.dec)
+
+        for v in (a, b, c,):
+            _test(v)
+
+        for v in (array(a, dtype=self.dt), array(b, dtype=self.dt),
+                  array(c, dtype=self.dt)):
+            _test(v)
+
+    def test_axis(self):
+        # Vector norms.
+        # Compare the use of `axis` with computing the norm of each row
+        # or column separately.
+        A = array([[1, 2, 3], [4, 5, 6]], dtype=self.dt)
+        for order in [None, -1, 0, 1, 2, 3, np.inf, -np.inf]:
+            expected0 = [norm(A[:, k], ord=order) for k in range(A.shape[1])]
+            assert_almost_equal(norm(A, ord=order, axis=0), expected0)
+            expected1 = [norm(A[k, :], ord=order) for k in range(A.shape[0])]
+            assert_almost_equal(norm(A, ord=order, axis=1), expected1)
+
+        # Matrix norms.
+        B = np.arange(1, 25, dtype=self.dt).reshape(2, 3, 4)
+        nd = B.ndim
+        for order in [None, -2, 2, -1, 1, np.inf, -np.inf, 'fro']:
+            for axis in itertools.combinations(range(-nd, nd), 2):
+                row_axis, col_axis = axis
+                if row_axis < 0:
+                    row_axis += nd
+                if col_axis < 0:
+                    col_axis += nd
+                if row_axis == col_axis:
+                    assert_raises(ValueError, norm, B, ord=order, axis=axis)
+                else:
+                    n = norm(B, ord=order, axis=axis)
+
+                    # The logic using k_index only works for nd = 3.
+                    # This has to be changed if nd is increased.
+                    k_index = nd - (row_axis + col_axis)
+                    if row_axis < col_axis:
+                        expected = [norm(B[:].take(k, axis=k_index), ord=order)
+                                    for k in range(B.shape[k_index])]
+                    else:
+                        expected = [norm(B[:].take(k, axis=k_index).T, ord=order)
+                                    for k in range(B.shape[k_index])]
+                    assert_almost_equal(n, expected)
+
+    def test_keepdims(self):
+        A = np.arange(1, 25, dtype=self.dt).reshape(2, 3, 4)
+
+        allclose_err = 'order {0}, axis = {1}'
+        shape_err = 'Shape mismatch found {0}, expected {1}, order={2}, axis={3}'
+
+        # check the order=None, axis=None case
+        expected = norm(A, ord=None, axis=None)
+        found = norm(A, ord=None, axis=None, keepdims=True)
+        assert_allclose(np.squeeze(found), expected,
+                        err_msg=allclose_err.format(None, None))
+        expected_shape = (1, 1, 1)
+        assert_(found.shape == expected_shape,
+                shape_err.format(found.shape, expected_shape, None, None))
+
+        # Vector norms.
+        for order in [None, -1, 0, 1, 2, 3, np.inf, -np.inf]:
+            for k in range(A.ndim):
+                expected = norm(A, ord=order, axis=k)
+                found = norm(A, ord=order, axis=k, keepdims=True)
+                assert_allclose(np.squeeze(found), expected,
+                                err_msg=allclose_err.format(order, k))
+                expected_shape = list(A.shape)
+                expected_shape[k] = 1
+                expected_shape = tuple(expected_shape)
+                assert_(found.shape == expected_shape,
+                        shape_err.format(found.shape, expected_shape, order, k))
+
+        # Matrix norms.
+        for order in [None, -2, 2, -1, 1, np.inf, -np.inf, 'fro', 'nuc']:
+            for k in itertools.permutations(range(A.ndim), 2):
+                expected = norm(A, ord=order, axis=k)
+                found = norm(A, ord=order, axis=k, keepdims=True)
+                assert_allclose(np.squeeze(found), expected,
+                                err_msg=allclose_err.format(order, k))
+                expected_shape = list(A.shape)
+                expected_shape[k[0]] = 1
+                expected_shape[k[1]] = 1
+                expected_shape = tuple(expected_shape)
+                assert_(found.shape == expected_shape,
+                        shape_err.format(found.shape, expected_shape, order, k))
+
+
+class _TestNorm2D(_TestNormBase):
+    # Define the part for 2d arrays separately, so we can subclass this
+    # and run the tests using np.matrix in matrixlib.tests.test_matrix_linalg.
+    array = np.array
+
+    def test_matrix_empty(self):
+        assert_equal(norm(self.array([[]], dtype=self.dt)), 0.0)
+
+    def test_matrix_return_type(self):
+        a = self.array([[1, 0, 1], [0, 1, 1]])
+
+        exact_types = np.typecodes['AllInteger']
+
+        # float32, complex64, float64, complex128 types are the only types
+        # allowed by `linalg`, which performs the matrix operations used
+        # within `norm`.
+        inexact_types = 'fdFD'
+
+        all_types = exact_types + inexact_types
+
+        for each_type in all_types:
+            at = a.astype(each_type)
+
+            an = norm(at, -np.inf)
+            self.check_dtype(at, an)
+            assert_almost_equal(an, 2.0)
+
+            with suppress_warnings() as sup:
+                sup.filter(RuntimeWarning, "divide by zero encountered")
+                an = norm(at, -1)
+                self.check_dtype(at, an)
+                assert_almost_equal(an, 1.0)
+
+            an = norm(at, 1)
+            self.check_dtype(at, an)
+            assert_almost_equal(an, 2.0)
+
+            an = norm(at, 2)
+            self.check_dtype(at, an)
+            assert_almost_equal(an, 3.0**(1.0/2.0))
+
+            an = norm(at, -2)
+            self.check_dtype(at, an)
+            assert_almost_equal(an, 1.0)
+
+            an = norm(at, np.inf)
+            self.check_dtype(at, an)
+            assert_almost_equal(an, 2.0)
+
+            an = norm(at, 'fro')
+            self.check_dtype(at, an)
+            assert_almost_equal(an, 2.0)
+
+            an = norm(at, 'nuc')
+            self.check_dtype(at, an)
+            # Lower bar needed to support low precision floats.
+            # They end up being off by 1 in the 7th place.
+            np.testing.assert_almost_equal(an, 2.7320508075688772, decimal=6)
+
+    def test_matrix_2x2(self):
+        A = self.array([[1, 3], [5, 7]], dtype=self.dt)
+        assert_almost_equal(norm(A), 84 ** 0.5)
+        assert_almost_equal(norm(A, 'fro'), 84 ** 0.5)
+        assert_almost_equal(norm(A, 'nuc'), 10.0)
+        assert_almost_equal(norm(A, inf), 12.0)
+        assert_almost_equal(norm(A, -inf), 4.0)
+        assert_almost_equal(norm(A, 1), 10.0)
+        assert_almost_equal(norm(A, -1), 6.0)
+        assert_almost_equal(norm(A, 2), 9.1231056256176615)
+        assert_almost_equal(norm(A, -2), 0.87689437438234041)
+
+        assert_raises(ValueError, norm, A, 'nofro')
+        assert_raises(ValueError, norm, A, -3)
+        assert_raises(ValueError, norm, A, 0)
+
+    def test_matrix_3x3(self):
+        # This test has been added because the 2x2 example
+        # happened to have equal nuclear norm and induced 1-norm.
+        # The 1/10 scaling factor accommodates the absolute tolerance
+        # used in assert_almost_equal.
+        A = (1 / 10) * \
+            self.array([[1, 2, 3], [6, 0, 5], [3, 2, 1]], dtype=self.dt)
+        assert_almost_equal(norm(A), (1 / 10) * 89 ** 0.5)
+        assert_almost_equal(norm(A, 'fro'), (1 / 10) * 89 ** 0.5)
+        assert_almost_equal(norm(A, 'nuc'), 1.3366836911774836)
+        assert_almost_equal(norm(A, inf), 1.1)
+        assert_almost_equal(norm(A, -inf), 0.6)
+        assert_almost_equal(norm(A, 1), 1.0)
+        assert_almost_equal(norm(A, -1), 0.4)
+        assert_almost_equal(norm(A, 2), 0.88722940323461277)
+        assert_almost_equal(norm(A, -2), 0.19456584790481812)
+
+    def test_bad_args(self):
+        # Check that bad arguments raise the appropriate exceptions.
+
+        A = self.array([[1, 2, 3], [4, 5, 6]], dtype=self.dt)
+        B = np.arange(1, 25, dtype=self.dt).reshape(2, 3, 4)
+
+        # Using `axis=` or passing in a 1-D array implies vector
+        # norms are being computed, so also using `ord='fro'`
+        # or `ord='nuc'` or any other string raises a ValueError.
+        assert_raises(ValueError, norm, A, 'fro', 0)
+        assert_raises(ValueError, norm, A, 'nuc', 0)
+        assert_raises(ValueError, norm, [3, 4], 'fro', None)
+        assert_raises(ValueError, norm, [3, 4], 'nuc', None)
+        assert_raises(ValueError, norm, [3, 4], 'test', None)
+
+        # Similarly, norm should raise an exception when ord is any finite
+        # number other than 1, 2, -1 or -2 when computing matrix norms.
+        for order in [0, 3]:
+            assert_raises(ValueError, norm, A, order, None)
+            assert_raises(ValueError, norm, A, order, (0, 1))
+            assert_raises(ValueError, norm, B, order, (1, 2))
+
+        # Invalid axis
+        assert_raises(AxisError, norm, B, None, 3)
+        assert_raises(AxisError, norm, B, None, (2, 3))
+        assert_raises(ValueError, norm, B, None, (0, 1, 2))
+
+
+class _TestNorm(_TestNorm2D, _TestNormGeneral):
+    pass
+
+
+class TestNorm_NonSystematic:
+
+    def test_longdouble_norm(self):
+        # Non-regression test: p-norm of longdouble would previously raise
+        # UnboundLocalError.
+        x = np.arange(10, dtype=np.longdouble)
+        old_assert_almost_equal(norm(x, ord=3), 12.65, decimal=2)
+
+    def test_intmin(self):
+        # Non-regression test: p-norm of signed integer would previously do
+        # float cast and abs in the wrong order.
+        x = np.array([-2 ** 31], dtype=np.int32)
+        old_assert_almost_equal(norm(x, ord=3), 2 ** 31, decimal=5)
+
+    def test_complex_high_ord(self):
+        # gh-4156
+        d = np.empty((2,), dtype=np.clongdouble)
+        d[0] = 6 + 7j
+        d[1] = -6 + 7j
+        res = 11.615898132184
+        old_assert_almost_equal(np.linalg.norm(d, ord=3), res, decimal=10)
+        d = d.astype(np.complex128)
+        old_assert_almost_equal(np.linalg.norm(d, ord=3), res, decimal=9)
+        d = d.astype(np.complex64)
+        old_assert_almost_equal(np.linalg.norm(d, ord=3), res, decimal=5)
+
+
+# Separate definitions so we can use them for matrix tests.
+class _TestNormDoubleBase(_TestNormBase):
+    dt = np.double
+    dec = 12
+
+
+class _TestNormSingleBase(_TestNormBase):
+    dt = np.float32
+    dec = 6
+
+
+class _TestNormInt64Base(_TestNormBase):
+    dt = np.int64
+    dec = 12
+
+
+class TestNormDouble(_TestNorm, _TestNormDoubleBase):
+    pass
+
+
+class TestNormSingle(_TestNorm, _TestNormSingleBase):
+    pass
+
+
+class TestNormInt64(_TestNorm, _TestNormInt64Base):
+    pass
+
+
+class TestMatrixRank:
+
+    def test_matrix_rank(self):
+        # Full rank matrix
+        assert_equal(4, matrix_rank(np.eye(4)))
+        # rank deficient matrix
+        I = np.eye(4)
+        I[-1, -1] = 0.
+        assert_equal(matrix_rank(I), 3)
+        # All zeros - zero rank
+        assert_equal(matrix_rank(np.zeros((4, 4))), 0)
+        # 1 dimension - rank 1 unless all 0
+        assert_equal(matrix_rank([1, 0, 0, 0]), 1)
+        assert_equal(matrix_rank(np.zeros((4,))), 0)
+        # accepts array-like
+        assert_equal(matrix_rank([1]), 1)
+        # greater than 2 dimensions treated as stacked matrices
+        ms = np.array([I, np.eye(4), np.zeros((4,4))])
+        assert_equal(matrix_rank(ms), np.array([3, 4, 0]))
+        # works on scalar
+        assert_equal(matrix_rank(1), 1)
+
+        with assert_raises_regex(
+            ValueError, "`tol` and `rtol` can\'t be both set."
+        ):
+            matrix_rank(I, tol=0.01, rtol=0.01)
+
+    def test_symmetric_rank(self):
+        assert_equal(4, matrix_rank(np.eye(4), hermitian=True))
+        assert_equal(1, matrix_rank(np.ones((4, 4)), hermitian=True))
+        assert_equal(0, matrix_rank(np.zeros((4, 4)), hermitian=True))
+        # rank deficient matrix
+        I = np.eye(4)
+        I[-1, -1] = 0.
+        assert_equal(3, matrix_rank(I, hermitian=True))
+        # manually supplied tolerance
+        I[-1, -1] = 1e-8
+        assert_equal(4, matrix_rank(I, hermitian=True, tol=0.99e-8))
+        assert_equal(3, matrix_rank(I, hermitian=True, tol=1.01e-8))
+
+
+def test_reduced_rank():
+    # Test matrices with reduced rank
+    rng = np.random.RandomState(20120714)
+    for i in range(100):
+        # Make a rank deficient matrix
+        X = rng.normal(size=(40, 10))
+        X[:, 0] = X[:, 1] + X[:, 2]
+        # Assert that matrix_rank detected deficiency
+        assert_equal(matrix_rank(X), 9)
+        X[:, 3] = X[:, 4] + X[:, 5]
+        assert_equal(matrix_rank(X), 8)
+
+
+class TestQR:
+    # Define the array class here, so run this on matrices elsewhere.
+    array = np.array
+
+    def check_qr(self, a):
+        # This test expects the argument `a` to be an ndarray or
+        # a subclass of an ndarray of inexact type.
+        a_type = type(a)
+        a_dtype = a.dtype
+        m, n = a.shape
+        k = min(m, n)
+
+        # mode == 'complete'
+        res = linalg.qr(a, mode='complete')
+        Q, R = res.Q, res.R
+        assert_(Q.dtype == a_dtype)
+        assert_(R.dtype == a_dtype)
+        assert_(isinstance(Q, a_type))
+        assert_(isinstance(R, a_type))
+        assert_(Q.shape == (m, m))
+        assert_(R.shape == (m, n))
+        assert_almost_equal(dot(Q, R), a)
+        assert_almost_equal(dot(Q.T.conj(), Q), np.eye(m))
+        assert_almost_equal(np.triu(R), R)
+
+        # mode == 'reduced'
+        q1, r1 = linalg.qr(a, mode='reduced')
+        assert_(q1.dtype == a_dtype)
+        assert_(r1.dtype == a_dtype)
+        assert_(isinstance(q1, a_type))
+        assert_(isinstance(r1, a_type))
+        assert_(q1.shape == (m, k))
+        assert_(r1.shape == (k, n))
+        assert_almost_equal(dot(q1, r1), a)
+        assert_almost_equal(dot(q1.T.conj(), q1), np.eye(k))
+        assert_almost_equal(np.triu(r1), r1)
+
+        # mode == 'r'
+        r2 = linalg.qr(a, mode='r')
+        assert_(r2.dtype == a_dtype)
+        assert_(isinstance(r2, a_type))
+        assert_almost_equal(r2, r1)
+
+
+    @pytest.mark.parametrize(["m", "n"], [
+        (3, 0),
+        (0, 3),
+        (0, 0)
+    ])
+    def test_qr_empty(self, m, n):
+        k = min(m, n)
+        a = np.empty((m, n))
+
+        self.check_qr(a)
+
+        h, tau = np.linalg.qr(a, mode='raw')
+        assert_equal(h.dtype, np.double)
+        assert_equal(tau.dtype, np.double)
+        assert_equal(h.shape, (n, m))
+        assert_equal(tau.shape, (k,))
+
+    def test_mode_raw(self):
+        # The factorization is not unique and varies between libraries,
+        # so it is not possible to check against known values. Functional
+        # testing is a possibility, but awaits the exposure of more
+        # of the functions in lapack_lite. Consequently, this test is
+        # very limited in scope. Note that the results are in FORTRAN
+        # order, hence the h arrays are transposed.
+        a = self.array([[1, 2], [3, 4], [5, 6]], dtype=np.double)
+
+        # Test double
+        h, tau = linalg.qr(a, mode='raw')
+        assert_(h.dtype == np.double)
+        assert_(tau.dtype == np.double)
+        assert_(h.shape == (2, 3))
+        assert_(tau.shape == (2,))
+
+        h, tau = linalg.qr(a.T, mode='raw')
+        assert_(h.dtype == np.double)
+        assert_(tau.dtype == np.double)
+        assert_(h.shape == (3, 2))
+        assert_(tau.shape == (2,))
+
+    def test_mode_all_but_economic(self):
+        a = self.array([[1, 2], [3, 4]])
+        b = self.array([[1, 2], [3, 4], [5, 6]])
+        for dt in "fd":
+            m1 = a.astype(dt)
+            m2 = b.astype(dt)
+            self.check_qr(m1)
+            self.check_qr(m2)
+            self.check_qr(m2.T)
+
+        for dt in "fd":
+            m1 = 1 + 1j * a.astype(dt)
+            m2 = 1 + 1j * b.astype(dt)
+            self.check_qr(m1)
+            self.check_qr(m2)
+            self.check_qr(m2.T)
+
+    def check_qr_stacked(self, a):
+        # This test expects the argument `a` to be an ndarray or
+        # a subclass of an ndarray of inexact type.
+        a_type = type(a)
+        a_dtype = a.dtype
+        m, n = a.shape[-2:]
+        k = min(m, n)
+
+        # mode == 'complete'
+        q, r = linalg.qr(a, mode='complete')
+        assert_(q.dtype == a_dtype)
+        assert_(r.dtype == a_dtype)
+        assert_(isinstance(q, a_type))
+        assert_(isinstance(r, a_type))
+        assert_(q.shape[-2:] == (m, m))
+        assert_(r.shape[-2:] == (m, n))
+        assert_almost_equal(matmul(q, r), a)
+        I_mat = np.identity(q.shape[-1])
+        stack_I_mat = np.broadcast_to(I_mat,
+                        q.shape[:-2] + (q.shape[-1],)*2)
+        assert_almost_equal(matmul(swapaxes(q, -1, -2).conj(), q), stack_I_mat)
+        assert_almost_equal(np.triu(r[..., :, :]), r)
+
+        # mode == 'reduced'
+        q1, r1 = linalg.qr(a, mode='reduced')
+        assert_(q1.dtype == a_dtype)
+        assert_(r1.dtype == a_dtype)
+        assert_(isinstance(q1, a_type))
+        assert_(isinstance(r1, a_type))
+        assert_(q1.shape[-2:] == (m, k))
+        assert_(r1.shape[-2:] == (k, n))
+        assert_almost_equal(matmul(q1, r1), a)
+        I_mat = np.identity(q1.shape[-1])
+        stack_I_mat = np.broadcast_to(I_mat,
+                        q1.shape[:-2] + (q1.shape[-1],)*2)
+        assert_almost_equal(matmul(swapaxes(q1, -1, -2).conj(), q1),
+                            stack_I_mat)
+        assert_almost_equal(np.triu(r1[..., :, :]), r1)
+
+        # mode == 'r'
+        r2 = linalg.qr(a, mode='r')
+        assert_(r2.dtype == a_dtype)
+        assert_(isinstance(r2, a_type))
+        assert_almost_equal(r2, r1)
+
+    @pytest.mark.parametrize("size", [
+        (3, 4), (4, 3), (4, 4),
+        (3, 0), (0, 3)])
+    @pytest.mark.parametrize("outer_size", [
+        (2, 2), (2,), (2, 3, 4)])
+    @pytest.mark.parametrize("dt", [
+        np.single, np.double,
+        np.csingle, np.cdouble])
+    def test_stacked_inputs(self, outer_size, size, dt):
+
+        rng = np.random.default_rng(123)
+        A = rng.normal(size=outer_size + size).astype(dt)
+        B = rng.normal(size=outer_size + size).astype(dt)
+        self.check_qr_stacked(A)
+        self.check_qr_stacked(A + 1.j*B)
+
+
+class TestCholesky:
+
+    @pytest.mark.parametrize(
+        'shape', [(1, 1), (2, 2), (3, 3), (50, 50), (3, 10, 10)]
+    )
+    @pytest.mark.parametrize(
+        'dtype', (np.float32, np.float64, np.complex64, np.complex128)
+    )
+    @pytest.mark.parametrize(
+        'upper', [False, True])
+    def test_basic_property(self, shape, dtype, upper):
+        np.random.seed(1)
+        a = np.random.randn(*shape)
+        if np.issubdtype(dtype, np.complexfloating):
+            a = a + 1j*np.random.randn(*shape)
+
+        t = list(range(len(shape)))
+        t[-2:] = -1, -2
+
+        a = np.matmul(a.transpose(t).conj(), a)
+        a = np.asarray(a, dtype=dtype)
+
+        c = np.linalg.cholesky(a, upper=upper)
+
+        # Check A = L L^H or A = U^H U
+        if upper:
+            b = np.matmul(c.transpose(t).conj(), c)
+        else:
+            b = np.matmul(c, c.transpose(t).conj())
+        with np._no_nep50_warning():
+            atol = 500 * a.shape[0] * np.finfo(dtype).eps
+        assert_allclose(b, a, atol=atol, err_msg=f'{shape} {dtype}\n{a}\n{c}')
+
+        # Check diag(L or U) is real and positive
+        d = np.diagonal(c, axis1=-2, axis2=-1)
+        assert_(np.all(np.isreal(d)))
+        assert_(np.all(d >= 0))
+
+    def test_0_size(self):
+        class ArraySubclass(np.ndarray):
+            pass
+        a = np.zeros((0, 1, 1), dtype=np.int_).view(ArraySubclass)
+        res = linalg.cholesky(a)
+        assert_equal(a.shape, res.shape)
+        assert_(res.dtype.type is np.float64)
+        # for documentation purpose:
+        assert_(isinstance(res, np.ndarray))
+
+        a = np.zeros((1, 0, 0), dtype=np.complex64).view(ArraySubclass)
+        res = linalg.cholesky(a)
+        assert_equal(a.shape, res.shape)
+        assert_(res.dtype.type is np.complex64)
+        assert_(isinstance(res, np.ndarray))
+
+    def test_upper_lower_arg(self):
+        # Explicit test of upper argument that also checks the default.
+        a = np.array([[1+0j, 0-2j], [0+2j, 5+0j]])
+
+        assert_equal(linalg.cholesky(a), linalg.cholesky(a, upper=False))
+
+        assert_equal(
+            linalg.cholesky(a, upper=True),
+            linalg.cholesky(a).T.conj()
+        )
+
+
+class TestOuter:
+    arr1 = np.arange(3)
+    arr2 = np.arange(3)
+    expected = np.array(
+        [[0, 0, 0],
+         [0, 1, 2],
+         [0, 2, 4]]
+    )
+
+    assert_array_equal(np.linalg.outer(arr1, arr2), expected)
+
+    with assert_raises_regex(
+        ValueError, "Input arrays must be one-dimensional"
+    ):
+        np.linalg.outer(arr1[:, np.newaxis], arr2)
+
+
+def test_byteorder_check():
+    # Byte order check should pass for native order
+    if sys.byteorder == 'little':
+        native = '<'
+    else:
+        native = '>'
+
+    for dtt in (np.float32, np.float64):
+        arr = np.eye(4, dtype=dtt)
+        n_arr = arr.view(arr.dtype.newbyteorder(native))
+        sw_arr = arr.view(arr.dtype.newbyteorder("S")).byteswap()
+        assert_equal(arr.dtype.byteorder, '=')
+        for routine in (linalg.inv, linalg.det, linalg.pinv):
+            # Normal call
+            res = routine(arr)
+            # Native but not '='
+            assert_array_equal(res, routine(n_arr))
+            # Swapped
+            assert_array_equal(res, routine(sw_arr))
+
+
+@pytest.mark.skipif(IS_WASM, reason="fp errors don't work in wasm")
+def test_generalized_raise_multiloop():
+    # It should raise an error even if the error doesn't occur in the
+    # last iteration of the ufunc inner loop
+
+    invertible = np.array([[1, 2], [3, 4]])
+    non_invertible = np.array([[1, 1], [1, 1]])
+
+    x = np.zeros([4, 4, 2, 2])[1::2]
+    x[...] = invertible
+    x[0, 0] = non_invertible
+
+    assert_raises(np.linalg.LinAlgError, np.linalg.inv, x)
+
+@pytest.mark.skipif(
+    threading.active_count() > 1,
+    reason="skipping test that uses fork because there are multiple threads")
+def test_xerbla_override():
+    # Check that our xerbla has been successfully linked in. If it is not,
+    # the default xerbla routine is called, which prints a message to stdout
+    # and may, or may not, abort the process depending on the LAPACK package.
+
+    XERBLA_OK = 255
+
+    try:
+        pid = os.fork()
+    except (OSError, AttributeError):
+        # fork failed, or not running on POSIX
+        pytest.skip("Not POSIX or fork failed.")
+
+    if pid == 0:
+        # child; close i/o file handles
+        os.close(1)
+        os.close(0)
+        # Avoid producing core files.
+        import resource
+        resource.setrlimit(resource.RLIMIT_CORE, (0, 0))
+        # These calls may abort.
+        try:
+            np.linalg.lapack_lite.xerbla()
+        except ValueError:
+            pass
+        except Exception:
+            os._exit(os.EX_CONFIG)
+
+        try:
+            a = np.array([[1.]])
+            np.linalg.lapack_lite.dorgqr(
+                1, 1, 1, a,
+                0,  # <- invalid value
+                a, a, 0, 0)
+        except ValueError as e:
+            if "DORGQR parameter number 5" in str(e):
+                # success, reuse error code to mark success as
+                # FORTRAN STOP returns as success.
+                os._exit(XERBLA_OK)
+
+        # Did not abort, but our xerbla was not linked in.
+        os._exit(os.EX_CONFIG)
+    else:
+        # parent
+        pid, status = os.wait()
+        if os.WEXITSTATUS(status) != XERBLA_OK:
+            pytest.skip('Numpy xerbla not linked in.')
+
+
+@pytest.mark.skipif(IS_WASM, reason="Cannot start subprocess")
+@pytest.mark.slow
+def test_sdot_bug_8577():
+    # Regression test that loading certain other libraries does not
+    # result to wrong results in float32 linear algebra.
+    #
+    # There's a bug gh-8577 on OSX that can trigger this, and perhaps
+    # there are also other situations in which it occurs.
+    #
+    # Do the check in a separate process.
+
+    bad_libs = ['PyQt5.QtWidgets', 'IPython']
+
+    template = textwrap.dedent("""
+    import sys
+    {before}
+    try:
+        import {bad_lib}
+    except ImportError:
+        sys.exit(0)
+    {after}
+    x = np.ones(2, dtype=np.float32)
+    sys.exit(0 if np.allclose(x.dot(x), 2.0) else 1)
+    """)
+
+    for bad_lib in bad_libs:
+        code = template.format(before="import numpy as np", after="",
+                               bad_lib=bad_lib)
+        subprocess.check_call([sys.executable, "-c", code])
+
+        # Swapped import order
+        code = template.format(after="import numpy as np", before="",
+                               bad_lib=bad_lib)
+        subprocess.check_call([sys.executable, "-c", code])
+
+
+class TestMultiDot:
+
+    def test_basic_function_with_three_arguments(self):
+        # multi_dot with three arguments uses a fast hand coded algorithm to
+        # determine the optimal order. Therefore test it separately.
+        A = np.random.random((6, 2))
+        B = np.random.random((2, 6))
+        C = np.random.random((6, 2))
+
+        assert_almost_equal(multi_dot([A, B, C]), A.dot(B).dot(C))
+        assert_almost_equal(multi_dot([A, B, C]), np.dot(A, np.dot(B, C)))
+
+    def test_basic_function_with_two_arguments(self):
+        # separate code path with two arguments
+        A = np.random.random((6, 2))
+        B = np.random.random((2, 6))
+
+        assert_almost_equal(multi_dot([A, B]), A.dot(B))
+        assert_almost_equal(multi_dot([A, B]), np.dot(A, B))
+
+    def test_basic_function_with_dynamic_programming_optimization(self):
+        # multi_dot with four or more arguments uses the dynamic programming
+        # optimization and therefore deserve a separate
+        A = np.random.random((6, 2))
+        B = np.random.random((2, 6))
+        C = np.random.random((6, 2))
+        D = np.random.random((2, 1))
+        assert_almost_equal(multi_dot([A, B, C, D]), A.dot(B).dot(C).dot(D))
+
+    def test_vector_as_first_argument(self):
+        # The first argument can be 1-D
+        A1d = np.random.random(2)  # 1-D
+        B = np.random.random((2, 6))
+        C = np.random.random((6, 2))
+        D = np.random.random((2, 2))
+
+        # the result should be 1-D
+        assert_equal(multi_dot([A1d, B, C, D]).shape, (2,))
+
+    def test_vector_as_last_argument(self):
+        # The last argument can be 1-D
+        A = np.random.random((6, 2))
+        B = np.random.random((2, 6))
+        C = np.random.random((6, 2))
+        D1d = np.random.random(2)  # 1-D
+
+        # the result should be 1-D
+        assert_equal(multi_dot([A, B, C, D1d]).shape, (6,))
+
+    def test_vector_as_first_and_last_argument(self):
+        # The first and last arguments can be 1-D
+        A1d = np.random.random(2)  # 1-D
+        B = np.random.random((2, 6))
+        C = np.random.random((6, 2))
+        D1d = np.random.random(2)  # 1-D
+
+        # the result should be a scalar
+        assert_equal(multi_dot([A1d, B, C, D1d]).shape, ())
+
+    def test_three_arguments_and_out(self):
+        # multi_dot with three arguments uses a fast hand coded algorithm to
+        # determine the optimal order. Therefore test it separately.
+        A = np.random.random((6, 2))
+        B = np.random.random((2, 6))
+        C = np.random.random((6, 2))
+
+        out = np.zeros((6, 2))
+        ret = multi_dot([A, B, C], out=out)
+        assert out is ret
+        assert_almost_equal(out, A.dot(B).dot(C))
+        assert_almost_equal(out, np.dot(A, np.dot(B, C)))
+
+    def test_two_arguments_and_out(self):
+        # separate code path with two arguments
+        A = np.random.random((6, 2))
+        B = np.random.random((2, 6))
+        out = np.zeros((6, 6))
+        ret = multi_dot([A, B], out=out)
+        assert out is ret
+        assert_almost_equal(out, A.dot(B))
+        assert_almost_equal(out, np.dot(A, B))
+
+    def test_dynamic_programming_optimization_and_out(self):
+        # multi_dot with four or more arguments uses the dynamic programming
+        # optimization and therefore deserve a separate test
+        A = np.random.random((6, 2))
+        B = np.random.random((2, 6))
+        C = np.random.random((6, 2))
+        D = np.random.random((2, 1))
+        out = np.zeros((6, 1))
+        ret = multi_dot([A, B, C, D], out=out)
+        assert out is ret
+        assert_almost_equal(out, A.dot(B).dot(C).dot(D))
+
+    def test_dynamic_programming_logic(self):
+        # Test for the dynamic programming part
+        # This test is directly taken from Cormen page 376.
+        arrays = [np.random.random((30, 35)),
+                  np.random.random((35, 15)),
+                  np.random.random((15, 5)),
+                  np.random.random((5, 10)),
+                  np.random.random((10, 20)),
+                  np.random.random((20, 25))]
+        m_expected = np.array([[0., 15750., 7875., 9375., 11875., 15125.],
+                               [0.,     0., 2625., 4375.,  7125., 10500.],
+                               [0.,     0.,    0.,  750.,  2500.,  5375.],
+                               [0.,     0.,    0.,    0.,  1000.,  3500.],
+                               [0.,     0.,    0.,    0.,     0.,  5000.],
+                               [0.,     0.,    0.,    0.,     0.,     0.]])
+        s_expected = np.array([[0,  1,  1,  3,  3,  3],
+                               [0,  0,  2,  3,  3,  3],
+                               [0,  0,  0,  3,  3,  3],
+                               [0,  0,  0,  0,  4,  5],
+                               [0,  0,  0,  0,  0,  5],
+                               [0,  0,  0,  0,  0,  0]], dtype=int)
+        s_expected -= 1  # Cormen uses 1-based index, python does not.
+
+        s, m = _multi_dot_matrix_chain_order(arrays, return_costs=True)
+
+        # Only the upper triangular part (without the diagonal) is interesting.
+        assert_almost_equal(np.triu(s[:-1, 1:]),
+                            np.triu(s_expected[:-1, 1:]))
+        assert_almost_equal(np.triu(m), np.triu(m_expected))
+
+    def test_too_few_input_arrays(self):
+        assert_raises(ValueError, multi_dot, [])
+        assert_raises(ValueError, multi_dot, [np.random.random((3, 3))])
+
+
+class TestTensorinv:
+
+    @pytest.mark.parametrize("arr, ind", [
+        (np.ones((4, 6, 8, 2)), 2),
+        (np.ones((3, 3, 2)), 1),
+        ])
+    def test_non_square_handling(self, arr, ind):
+        with assert_raises(LinAlgError):
+            linalg.tensorinv(arr, ind=ind)
+
+    @pytest.mark.parametrize("shape, ind", [
+        # examples from docstring
+        ((4, 6, 8, 3), 2),
+        ((24, 8, 3), 1),
+        ])
+    def test_tensorinv_shape(self, shape, ind):
+        a = np.eye(24)
+        a.shape = shape
+        ainv = linalg.tensorinv(a=a, ind=ind)
+        expected = a.shape[ind:] + a.shape[:ind]
+        actual = ainv.shape
+        assert_equal(actual, expected)
+
+    @pytest.mark.parametrize("ind", [
+        0, -2,
+        ])
+    def test_tensorinv_ind_limit(self, ind):
+        a = np.eye(24)
+        a.shape = (4, 6, 8, 3)
+        with assert_raises(ValueError):
+            linalg.tensorinv(a=a, ind=ind)
+
+    def test_tensorinv_result(self):
+        # mimic a docstring example
+        a = np.eye(24)
+        a.shape = (24, 8, 3)
+        ainv = linalg.tensorinv(a, ind=1)
+        b = np.ones(24)
+        assert_allclose(np.tensordot(ainv, b, 1), np.linalg.tensorsolve(a, b))
+
+
+class TestTensorsolve:
+
+    @pytest.mark.parametrize("a, axes", [
+        (np.ones((4, 6, 8, 2)), None),
+        (np.ones((3, 3, 2)), (0, 2)),
+        ])
+    def test_non_square_handling(self, a, axes):
+        with assert_raises(LinAlgError):
+            b = np.ones(a.shape[:2])
+            linalg.tensorsolve(a, b, axes=axes)
+
+    @pytest.mark.parametrize("shape",
+        [(2, 3, 6), (3, 4, 4, 3), (0, 3, 3, 0)],
+    )
+    def test_tensorsolve_result(self, shape):
+        a = np.random.randn(*shape)
+        b = np.ones(a.shape[:2])
+        x = np.linalg.tensorsolve(a, b)
+        assert_allclose(np.tensordot(a, x, axes=len(x.shape)), b)
+
+
+def test_unsupported_commontype():
+    # linalg gracefully handles unsupported type
+    arr = np.array([[1, -2], [2, 5]], dtype='float16')
+    with assert_raises_regex(TypeError, "unsupported in linalg"):
+        linalg.cholesky(arr)
+
+
+#@pytest.mark.slow
+#@pytest.mark.xfail(not HAS_LAPACK64, run=False,
+#                   reason="Numpy not compiled with 64-bit BLAS/LAPACK")
+#@requires_memory(free_bytes=16e9)
+@pytest.mark.skip(reason="Bad memory reports lead to OOM in ci testing")
+def test_blas64_dot():
+    n = 2**32
+    a = np.zeros([1, n], dtype=np.float32)
+    b = np.ones([1, 1], dtype=np.float32)
+    a[0,-1] = 1
+    c = np.dot(b, a)
+    assert_equal(c[0,-1], 1)
+
+
+@pytest.mark.xfail(not HAS_LAPACK64,
+                   reason="Numpy not compiled with 64-bit BLAS/LAPACK")
+def test_blas64_geqrf_lwork_smoketest():
+    # Smoke test LAPACK geqrf lwork call with 64-bit integers
+    dtype = np.float64
+    lapack_routine = np.linalg.lapack_lite.dgeqrf
+
+    m = 2**32 + 1
+    n = 2**32 + 1
+    lda = m
+
+    # Dummy arrays, not referenced by the lapack routine, so don't
+    # need to be of the right size
+    a = np.zeros([1, 1], dtype=dtype)
+    work = np.zeros([1], dtype=dtype)
+    tau = np.zeros([1], dtype=dtype)
+
+    # Size query
+    results = lapack_routine(m, n, a, lda, tau, work, -1, 0)
+    assert_equal(results['info'], 0)
+    assert_equal(results['m'], m)
+    assert_equal(results['n'], m)
+
+    # Should result to an integer of a reasonable size
+    lwork = int(work.item())
+    assert_(2**32 < lwork < 2**42)
+
+
+def test_diagonal():
+    # Here we only test if selected axes are compatible
+    # with Array API (last two). Core implementation
+    # of `diagonal` is tested in `test_multiarray.py`.
+    x = np.arange(60).reshape((3, 4, 5))
+    actual = np.linalg.diagonal(x)
+    expected = np.array(
+        [
+            [0,  6, 12, 18],
+            [20, 26, 32, 38],
+            [40, 46, 52, 58],
+        ]
+    )
+    assert_equal(actual, expected)
+
+
+def test_trace():
+    # Here we only test if selected axes are compatible
+    # with Array API (last two). Core implementation
+    # of `trace` is tested in `test_multiarray.py`.
+    x = np.arange(60).reshape((3, 4, 5))
+    actual = np.linalg.trace(x)
+    expected = np.array([36, 116, 196])
+
+    assert_equal(actual, expected)
+
+
+def test_cross():
+    x = np.arange(9).reshape((3, 3))
+    actual = np.linalg.cross(x, x + 1)
+    expected = np.array([
+        [-1, 2, -1],
+        [-1, 2, -1],
+        [-1, 2, -1],
+    ])
+
+    assert_equal(actual, expected)
+
+    # We test that lists are converted to arrays.
+    u = [1, 2, 3]
+    v = [4, 5, 6]
+    actual = np.linalg.cross(u, v)
+    expected = array([-3,  6, -3])
+
+    assert_equal(actual, expected)
+
+    with assert_raises_regex(
+        ValueError,
+        r"input arrays must be \(arrays of\) 3-dimensional vectors"
+    ):
+        x_2dim = x[:, 1:]
+        np.linalg.cross(x_2dim, x_2dim)
+
+
+def test_tensordot():
+    # np.linalg.tensordot is just an alias for np.tensordot
+    x = np.arange(6).reshape((2, 3))
+
+    assert np.linalg.tensordot(x, x) == 55
+    assert np.linalg.tensordot(x, x, axes=[(0, 1), (0, 1)]) == 55
+
+
+def test_matmul():
+    # np.linalg.matmul and np.matmul only differs in the number
+    # of arguments in the signature
+    x = np.arange(6).reshape((2, 3))
+    actual = np.linalg.matmul(x, x.T)
+    expected = np.array([[5, 14], [14, 50]])
+
+    assert_equal(actual, expected)
+
+
+def test_matrix_transpose():
+    x = np.arange(6).reshape((2, 3))
+    actual = np.linalg.matrix_transpose(x)
+    expected = x.T
+
+    assert_equal(actual, expected)
+
+    with assert_raises_regex(
+        ValueError, "array must be at least 2-dimensional"
+    ):
+        np.linalg.matrix_transpose(x[:, 0])
+
+
+def test_matrix_norm():
+    x = np.arange(9).reshape((3, 3))
+    actual = np.linalg.matrix_norm(x)
+
+    assert_almost_equal(actual, np.float64(14.2828), double_decimal=3)
+
+    actual = np.linalg.matrix_norm(x, keepdims=True)
+
+    assert_almost_equal(actual, np.array([[14.2828]]), double_decimal=3)
+
+
+def test_vector_norm():
+    x = np.arange(9).reshape((3, 3))
+    actual = np.linalg.vector_norm(x)
+
+    assert_almost_equal(actual, np.float64(14.2828), double_decimal=3)
+
+    actual = np.linalg.vector_norm(x, axis=0)
+
+    assert_almost_equal(
+        actual, np.array([6.7082, 8.124, 9.6436]), double_decimal=3
+    )
+
+    actual = np.linalg.vector_norm(x, keepdims=True)
+    expected = np.full((1, 1), 14.2828, dtype='float64')
+    assert_equal(actual.shape, expected.shape)
+    assert_almost_equal(actual, expected, double_decimal=3)
diff --git a/venv/lib/python3.12/site-packages/numpy/linalg/tests/test_regression.py b/venv/lib/python3.12/site-packages/numpy/linalg/tests/test_regression.py
new file mode 100644
index 00000000..91051c0e
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/linalg/tests/test_regression.py
@@ -0,0 +1,178 @@
+""" Test functions for linalg module
+"""
+import warnings
+
+import pytest
+
+import numpy as np
+from numpy import linalg, arange, float64, array, dot, transpose
+from numpy.testing import (
+    assert_, assert_raises, assert_equal, assert_array_equal,
+    assert_array_almost_equal, assert_array_less
+)
+
+
+class TestRegression:
+
+    def test_eig_build(self):
+        # Ticket #652
+        rva = array([1.03221168e+02 + 0.j,
+                     -1.91843603e+01 + 0.j,
+                     -6.04004526e-01 + 15.84422474j,
+                     -6.04004526e-01 - 15.84422474j,
+                     -1.13692929e+01 + 0.j,
+                     -6.57612485e-01 + 10.41755503j,
+                     -6.57612485e-01 - 10.41755503j,
+                     1.82126812e+01 + 0.j,
+                     1.06011014e+01 + 0.j,
+                     7.80732773e+00 + 0.j,
+                     -7.65390898e-01 + 0.j,
+                     1.51971555e-15 + 0.j,
+                     -1.51308713e-15 + 0.j])
+        a = arange(13 * 13, dtype=float64)
+        a.shape = (13, 13)
+        a = a % 17
+        va, ve = linalg.eig(a)
+        va.sort()
+        rva.sort()
+        assert_array_almost_equal(va, rva)
+
+    def test_eigh_build(self):
+        # Ticket 662.
+        rvals = [68.60568999, 89.57756725, 106.67185574]
+
+        cov = array([[77.70273908,   3.51489954,  15.64602427],
+                     [3.51489954,  88.97013878,  -1.07431931],
+                     [15.64602427,  -1.07431931,  98.18223512]])
+
+        vals, vecs = linalg.eigh(cov)
+        assert_array_almost_equal(vals, rvals)
+
+    def test_svd_build(self):
+        # Ticket 627.
+        a = array([[0., 1.], [1., 1.], [2., 1.], [3., 1.]])
+        m, n = a.shape
+        u, s, vh = linalg.svd(a)
+
+        b = dot(transpose(u[:, n:]), a)
+
+        assert_array_almost_equal(b, np.zeros((2, 2)))
+
+    def test_norm_vector_badarg(self):
+        # Regression for #786: Frobenius norm for vectors raises
+        # ValueError.
+        assert_raises(ValueError, linalg.norm, array([1., 2., 3.]), 'fro')
+
+    def test_lapack_endian(self):
+        # For bug #1482
+        a = array([[5.7998084,  -2.1825367],
+                   [-2.1825367,   9.85910595]], dtype='>f8')
+        b = array(a, dtype=' 0.5)
+                assert_equal(c, 1)
+                assert_equal(np.linalg.matrix_rank(a), 1)
+                assert_array_less(1, np.linalg.norm(a, ord=2))
+
+                w_svdvals = linalg.svdvals(a)
+                assert_array_almost_equal(w, w_svdvals)
+
+    def test_norm_object_array(self):
+        # gh-7575
+        testvector = np.array([np.array([0, 1]), 0, 0], dtype=object)
+
+        norm = linalg.norm(testvector)
+        assert_array_equal(norm, [0, 1])
+        assert_(norm.dtype == np.dtype('float64'))
+
+        norm = linalg.norm(testvector, ord=1)
+        assert_array_equal(norm, [0, 1])
+        assert_(norm.dtype != np.dtype('float64'))
+
+        norm = linalg.norm(testvector, ord=2)
+        assert_array_equal(norm, [0, 1])
+        assert_(norm.dtype == np.dtype('float64'))
+
+        assert_raises(ValueError, linalg.norm, testvector, ord='fro')
+        assert_raises(ValueError, linalg.norm, testvector, ord='nuc')
+        assert_raises(ValueError, linalg.norm, testvector, ord=np.inf)
+        assert_raises(ValueError, linalg.norm, testvector, ord=-np.inf)
+        assert_raises(ValueError, linalg.norm, testvector, ord=0)
+        assert_raises(ValueError, linalg.norm, testvector, ord=-1)
+        assert_raises(ValueError, linalg.norm, testvector, ord=-2)
+
+        testmatrix = np.array([[np.array([0, 1]), 0, 0],
+                               [0,                0, 0]], dtype=object)
+
+        norm = linalg.norm(testmatrix)
+        assert_array_equal(norm, [0, 1])
+        assert_(norm.dtype == np.dtype('float64'))
+
+        norm = linalg.norm(testmatrix, ord='fro')
+        assert_array_equal(norm, [0, 1])
+        assert_(norm.dtype == np.dtype('float64'))
+
+        assert_raises(TypeError, linalg.norm, testmatrix, ord='nuc')
+        assert_raises(ValueError, linalg.norm, testmatrix, ord=np.inf)
+        assert_raises(ValueError, linalg.norm, testmatrix, ord=-np.inf)
+        assert_raises(ValueError, linalg.norm, testmatrix, ord=0)
+        assert_raises(ValueError, linalg.norm, testmatrix, ord=1)
+        assert_raises(ValueError, linalg.norm, testmatrix, ord=-1)
+        assert_raises(TypeError, linalg.norm, testmatrix, ord=2)
+        assert_raises(TypeError, linalg.norm, testmatrix, ord=-2)
+        assert_raises(ValueError, linalg.norm, testmatrix, ord=3)
+
+    def test_lstsq_complex_larger_rhs(self):
+        # gh-9891
+        size = 20
+        n_rhs = 70
+        G = np.random.randn(size, size) + 1j * np.random.randn(size, size)
+        u = np.random.randn(size, n_rhs) + 1j * np.random.randn(size, n_rhs)
+        b = G.dot(u)
+        # This should work without segmentation fault.
+        u_lstsq, res, rank, sv = linalg.lstsq(G, b, rcond=None)
+        # check results just in case
+        assert_array_almost_equal(u_lstsq, u)
+
+    @pytest.mark.parametrize("upper", [True, False])
+    def test_cholesky_empty_array(self, upper):
+        # gh-25840 - upper=True hung before.
+        res = np.linalg.cholesky(np.zeros((0, 0)), upper=upper)
+        assert res.size == 0
+
+    @pytest.mark.parametrize("rtol", [0.0, [0.0] * 4, np.zeros((4,))])
+    def test_matrix_rank_rtol_argument(self, rtol):
+        # gh-25877
+        x = np.zeros((4, 3, 2))
+        res = np.linalg.matrix_rank(x, rtol=rtol)
+        assert res.shape == (4,)
+
+    def test_openblas_threading(self):
+        # gh-27036
+        # Test whether matrix multiplication involving a large matrix always
+        # gives the same (correct) answer
+        x = np.arange(500000, dtype=np.float64)
+        src = np.vstack((x, -10*x)).T
+        matrix = np.array([[0, 1], [1, 0]])
+        expected = np.vstack((-10*x, x)).T  # src @ matrix
+        for i in range(200):
+            result = src @ matrix
+            mismatches = (~np.isclose(result, expected)).sum()
+            if mismatches != 0:
+                assert False, ("unexpected result from matmul, "
+                    "probably due to OpenBLAS threading issues")
diff --git a/venv/lib/python3.12/site-packages/numpy/ma/API_CHANGES.txt b/venv/lib/python3.12/site-packages/numpy/ma/API_CHANGES.txt
new file mode 100644
index 00000000..a3d792a1
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/ma/API_CHANGES.txt
@@ -0,0 +1,135 @@
+.. -*- rest -*-
+
+==================================================
+API changes in the new masked array implementation
+==================================================
+
+Masked arrays are subclasses of ndarray
+---------------------------------------
+
+Contrary to the original implementation, masked arrays are now regular
+ndarrays::
+
+  >>> x = masked_array([1,2,3],mask=[0,0,1])
+  >>> print isinstance(x, numpy.ndarray)
+  True
+
+
+``_data`` returns a view of the masked array
+--------------------------------------------
+
+Masked arrays are composed of a ``_data`` part and a ``_mask``. Accessing the
+``_data`` part will return a regular ndarray or any of its subclass, depending
+on the initial data::
+
+  >>> x = masked_array(numpy.matrix([[1,2],[3,4]]),mask=[[0,0],[0,1]])
+  >>> print x._data
+  [[1 2]
+   [3 4]]
+  >>> print type(x._data)
+  
+
+
+In practice, ``_data`` is implemented as a property, not as an attribute.
+Therefore, you cannot access it directly, and some simple tests such as the
+following one will fail::
+
+  >>>x._data is x._data
+  False
+
+
+``filled(x)`` can return a subclass of ndarray
+----------------------------------------------
+The function ``filled(a)`` returns an array of the same type as ``a._data``::
+
+  >>> x = masked_array(numpy.matrix([[1,2],[3,4]]),mask=[[0,0],[0,1]])
+  >>> y = filled(x)
+  >>> print type(y)
+  
+  >>> print y
+  matrix([[     1,      2],
+          [     3, 999999]])
+
+
+``put``, ``putmask`` behave like their ndarray counterparts
+-----------------------------------------------------------
+
+Previously, ``putmask`` was used like this::
+
+  mask = [False,True,True]
+  x = array([1,4,7],mask=mask)
+  putmask(x,mask,[3])
+
+which translated to::
+
+  x[~mask] = [3]
+
+(Note that a ``True``-value in a mask suppresses a value.)
+
+In other words, the mask had the same length as ``x``, whereas
+``values`` had ``sum(~mask)`` elements.
+
+Now, the behaviour is similar to that of ``ndarray.putmask``, where
+the mask and the values are both the same length as ``x``, i.e.
+
+::
+
+  putmask(x,mask,[3,0,0])
+
+
+``fill_value`` is a property
+----------------------------
+
+``fill_value`` is no longer a method, but a property::
+
+  >>> print x.fill_value
+  999999
+
+``cumsum`` and ``cumprod`` ignore missing values
+------------------------------------------------
+
+Missing values are assumed to be the identity element, i.e. 0 for
+``cumsum`` and 1 for ``cumprod``::
+
+  >>> x = N.ma.array([1,2,3,4],mask=[False,True,False,False])
+  >>> print x
+  [1 -- 3 4]
+  >>> print x.cumsum()
+  [1 -- 4 8]
+  >> print x.cumprod()
+  [1 -- 3 12]
+
+``bool(x)`` raises a ValueError
+-------------------------------
+
+Masked arrays now behave like regular ``ndarrays``, in that they cannot be
+converted to booleans:
+
+::
+
+  >>> x = N.ma.array([1,2,3])
+  >>> bool(x)
+  Traceback (most recent call last):
+    File "", line 1, in 
+  ValueError: The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()
+
+
+==================================
+New features (non exhaustive list)
+==================================
+
+``mr_``
+-------
+
+``mr_`` mimics the behavior of ``r_`` for masked arrays::
+
+  >>> np.ma.mr_[3,4,5]
+  masked_array(data = [3 4 5],
+        mask = False,
+        fill_value=999999)
+
+
+``anom``
+--------
+
+The ``anom`` method returns the deviations from the average (anomalies).
diff --git a/venv/lib/python3.12/site-packages/numpy/ma/LICENSE b/venv/lib/python3.12/site-packages/numpy/ma/LICENSE
new file mode 100644
index 00000000..b41aae0c
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/ma/LICENSE
@@ -0,0 +1,24 @@
+* Copyright (c) 2006, University of Georgia and Pierre G.F. Gerard-Marchant
+* All rights reserved.
+* Redistribution and use in source and binary forms, with or without
+* modification, are permitted provided that the following conditions are met:
+*
+*     * Redistributions of source code must retain the above copyright
+*       notice, this list of conditions and the following disclaimer.
+*     * Redistributions in binary form must reproduce the above copyright
+*       notice, this list of conditions and the following disclaimer in the
+*       documentation and/or other materials provided with the distribution.
+*     * Neither the name of the University of Georgia 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 REGENTS 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 REGENTS 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.
\ No newline at end of file
diff --git a/venv/lib/python3.12/site-packages/numpy/ma/README.rst b/venv/lib/python3.12/site-packages/numpy/ma/README.rst
new file mode 100644
index 00000000..cd101032
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/ma/README.rst
@@ -0,0 +1,236 @@
+==================================
+A guide to masked arrays in NumPy
+==================================
+
+.. Contents::
+
+See http://www.scipy.org/scipy/numpy/wiki/MaskedArray (dead link)
+for updates of this document.
+
+
+History
+-------
+
+As a regular user of MaskedArray, I (Pierre G.F. Gerard-Marchant) became
+increasingly frustrated with the subclassing of masked arrays (even if
+I can only blame my inexperience). I needed to develop a class of arrays
+that could store some additional information along with numerical values,
+while keeping the possibility for missing data (picture storing a series
+of dates along with measurements, what would later become the `TimeSeries
+Scikit `__
+(dead link).
+
+I started to implement such a class, but then quickly realized that
+any additional information disappeared when processing these subarrays
+(for example, adding a constant value to a subarray would erase its
+dates). I ended up writing the equivalent of *numpy.core.ma* for my
+particular class, ufuncs included. Everything went fine until I needed to
+subclass my new class, when more problems showed up: some attributes of
+the new subclass were lost during processing. I identified the culprit as
+MaskedArray, which returns masked ndarrays when I expected masked
+arrays of my class. I was preparing myself to rewrite *numpy.core.ma*
+when I forced myself to learn how to subclass ndarrays. As I became more
+familiar with the *__new__* and *__array_finalize__* methods,
+I started to wonder why masked arrays were objects, and not ndarrays,
+and whether it wouldn't be more convenient for subclassing if they did
+behave like regular ndarrays.
+
+The new *maskedarray* is what I eventually come up with. The
+main differences with the initial *numpy.core.ma* package are
+that MaskedArray is now a subclass of *ndarray* and that the
+*_data* section can now be any subclass of *ndarray*. Apart from a
+couple of issues listed below, the behavior of the new MaskedArray
+class reproduces the old one. Initially the *maskedarray*
+implementation was marginally slower than *numpy.ma* in some areas,
+but work is underway to speed it up; the expectation is that it can be
+made substantially faster than the present *numpy.ma*.
+
+
+Note that if the subclass has some special methods and
+attributes, they are not propagated to the masked version:
+this would require a modification of the *__getattribute__*
+method (first trying *ndarray.__getattribute__*, then trying
+*self._data.__getattribute__* if an exception is raised in the first
+place), which really slows things down.
+
+Main differences
+----------------
+
+ * The *_data* part of the masked array can be any subclass of ndarray (but not recarray, cf below).
+ * *fill_value* is now a property, not a function.
+ * in the majority of cases, the mask is forced to *nomask* when no value is actually masked. A notable exception is when a masked array (with no masked values) has just been unpickled.
+ * I got rid of the *share_mask* flag, I never understood its purpose.
+ * *put*, *putmask* and *take* now mimic the ndarray methods, to avoid unpleasant surprises. Moreover, *put* and *putmask* both update the mask when needed.  * if *a* is a masked array, *bool(a)* raises a *ValueError*, as it does with ndarrays.
+ * in the same way, the comparison of two masked arrays is a masked array, not a boolean
+ * *filled(a)* returns an array of the same subclass as *a._data*, and no test is performed on whether it is contiguous or not.
+ * the mask is always printed, even if it's *nomask*, which makes things easy (for me at least) to remember that a masked array is used.
+ * *cumsum* works as if the *_data* array was filled with 0. The mask is preserved, but not updated.
+ * *cumprod* works as if the *_data* array was filled with 1. The mask is preserved, but not updated.
+
+New features
+------------
+
+This list is non-exhaustive...
+
+ * the *mr_* function mimics *r_* for masked arrays.
+ * the *anom* method returns the anomalies (deviations from the average)
+
+Using the new package with numpy.core.ma
+----------------------------------------
+
+I tried to make sure that the new package can understand old masked
+arrays. Unfortunately, there's no upward compatibility.
+
+For example:
+
+>>> import numpy.core.ma as old_ma
+>>> import maskedarray as new_ma
+>>> x = old_ma.array([1,2,3,4,5], mask=[0,0,1,0,0])
+>>> x
+array(data =
+ [     1      2 999999      4      5],
+      mask =
+ [False False True False False],
+      fill_value=999999)
+>>> y = new_ma.array([1,2,3,4,5], mask=[0,0,1,0,0])
+>>> y
+array(data = [1 2 -- 4 5],
+      mask = [False False True False False],
+      fill_value=999999)
+>>> x==y
+array(data =
+ [True True True True True],
+      mask =
+ [False False True False False],
+      fill_value=?)
+>>> old_ma.getmask(x) == new_ma.getmask(x)
+array([True, True, True, True, True])
+>>> old_ma.getmask(y) == new_ma.getmask(y)
+array([True, True, False, True, True])
+>>> old_ma.getmask(y)
+False
+
+
+Using maskedarray with matplotlib
+---------------------------------
+
+Starting with matplotlib 0.91.2, the masked array importing will work with
+the maskedarray branch) as well as with earlier versions.
+
+By default matplotlib still uses numpy.ma, but there is an rcParams setting
+that you can use to select maskedarray instead.  In the matplotlibrc file
+you will find::
+
+  #maskedarray : False       # True to use external maskedarray module
+                             # instead of numpy.ma; this is a temporary #
+                             setting for testing maskedarray.
+
+
+Uncomment and set to True to select maskedarray everywhere.
+Alternatively, you can test a script with maskedarray by using a
+command-line option, e.g.::
+
+  python simple_plot.py --maskedarray
+
+
+Masked records
+--------------
+
+Like *numpy.ma.core*, the *ndarray*-based implementation
+of MaskedArray is limited when working with records: you can
+mask any record of the array, but not a field in a record. If you
+need this feature, you may want to give the *mrecords* package
+a try (available in the *maskedarray* directory in the scipy
+sandbox). This module defines a new class, *MaskedRecord*. An
+instance of this class accepts a *recarray* as data, and uses two
+masks: the *fieldmask* has as many entries as records in the array,
+each entry with the same fields as a record, but of boolean types:
+they indicate whether the field is masked or not; a record entry
+is flagged as masked in the *mask* array if all the fields are
+masked. A few examples in the file should give you an idea of what
+can be done. Note that *mrecords* is still experimental...
+
+Optimizing maskedarray
+----------------------
+
+Should masked arrays be filled before processing or not?
+--------------------------------------------------------
+
+In the current implementation, most operations on masked arrays involve
+the following steps:
+
+ * the input arrays are filled
+ * the operation is performed on the filled arrays
+ * the mask is set for the results, from the combination of the input masks and the mask corresponding to the domain of the operation.
+
+For example, consider the division of two masked arrays::
+
+  import numpy
+  import maskedarray as ma
+  x = ma.array([1,2,3,4],mask=[1,0,0,0], dtype=numpy.float64)
+  y = ma.array([-1,0,1,2], mask=[0,0,0,1], dtype=numpy.float64)
+
+The division of x by y is then computed as::
+
+  d1 = x.filled(0) # d1 = array([0., 2., 3., 4.])
+  d2 = y.filled(1) # array([-1.,  0.,  1.,  1.])
+  m = ma.mask_or(ma.getmask(x), ma.getmask(y)) # m =
+  array([True,False,False,True])
+  dm = ma.divide.domain(d1,d2) # array([False,  True, False, False])
+  result = (d1/d2).view(MaskedArray) # masked_array([-0. inf, 3., 4.])
+  result._mask = logical_or(m, dm)
+
+Note that a division by zero takes place. To avoid it, we can consider
+to fill the input arrays, taking the domain mask into account, so that::
+
+  d1 = x._data.copy() # d1 = array([1., 2., 3., 4.])
+  d2 = y._data.copy() # array([-1.,  0.,  1.,  2.])
+  dm = ma.divide.domain(d1,d2) # array([False,  True, False, False])
+  numpy.putmask(d2, dm, 1) # d2 = array([-1.,  1.,  1.,  2.])
+  m = ma.mask_or(ma.getmask(x), ma.getmask(y)) # m =
+  array([True,False,False,True])
+  result = (d1/d2).view(MaskedArray) # masked_array([-1. 0., 3., 2.])
+  result._mask = logical_or(m, dm)
+
+Note that the *.copy()* is required to avoid updating the inputs with
+*putmask*.  The *.filled()* method also involves a *.copy()*.
+
+A third possibility consists in avoid filling the arrays::
+
+  d1 = x._data # d1 = array([1., 2., 3., 4.])
+  d2 = y._data # array([-1.,  0.,  1.,  2.])
+  dm = ma.divide.domain(d1,d2) # array([False,  True, False, False])
+  m = ma.mask_or(ma.getmask(x), ma.getmask(y)) # m =
+  array([True,False,False,True])
+  result = (d1/d2).view(MaskedArray) # masked_array([-1. inf, 3., 2.])
+  result._mask = logical_or(m, dm)
+
+Note that here again the division by zero takes place.
+
+A quick benchmark gives the following results:
+
+ * *numpy.ma.divide*  : 2.69 ms per loop
+ * classical division     : 2.21 ms per loop
+ * division w/ prefilling : 2.34 ms per loop
+ * division w/o filling   : 1.55 ms per loop
+
+So, is it worth filling the arrays beforehand ? Yes, if we are interested
+in avoiding floating-point exceptions that may fill the result with infs
+and nans. No, if we are only interested into speed...
+
+
+Thanks
+------
+
+I'd like to thank Paul Dubois, Travis Oliphant and Sasha for the
+original masked array package: without you, I would never have started
+that (it might be argued that I shouldn't have anyway, but that's
+another story...).  I also wish to extend these thanks to Reggie Dugard
+and Eric Firing for their suggestions and numerous improvements.
+
+
+Revision notes
+--------------
+
+  * 08/25/2007 : Creation of this page
+  * 01/23/2007 : The package has been moved to the SciPy sandbox, and is regularly updated: please check out your SVN version!
diff --git a/venv/lib/python3.12/site-packages/numpy/ma/__init__.py b/venv/lib/python3.12/site-packages/numpy/ma/__init__.py
new file mode 100644
index 00000000..03e9fcd0
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/ma/__init__.py
@@ -0,0 +1,54 @@
+"""
+=============
+Masked Arrays
+=============
+
+Arrays sometimes contain invalid or missing data.  When doing operations
+on such arrays, we wish to suppress invalid values, which is the purpose masked
+arrays fulfill (an example of typical use is given below).
+
+For example, examine the following array:
+
+>>> x = np.array([2, 1, 3, np.nan, 5, 2, 3, np.nan])
+
+When we try to calculate the mean of the data, the result is undetermined:
+
+>>> np.mean(x)
+nan
+
+The mean is calculated using roughly ``np.sum(x)/len(x)``, but since
+any number added to ``NaN`` [1]_ produces ``NaN``, this doesn't work.  Enter
+masked arrays:
+
+>>> m = np.ma.masked_array(x, np.isnan(x))
+>>> m
+masked_array(data=[2.0, 1.0, 3.0, --, 5.0, 2.0, 3.0, --],
+             mask=[False, False, False, True, False, False, False, True],
+      fill_value=1e+20)
+
+Here, we construct a masked array that suppress all ``NaN`` values.  We
+may now proceed to calculate the mean of the other values:
+
+>>> np.mean(m)
+2.6666666666666665
+
+.. [1] Not-a-Number, a floating point value that is the result of an
+       invalid operation.
+
+.. moduleauthor:: Pierre Gerard-Marchant
+.. moduleauthor:: Jarrod Millman
+
+"""
+from . import core
+from .core import *
+
+from . import extras
+from .extras import *
+
+__all__ = ['core', 'extras']
+__all__ += core.__all__
+__all__ += extras.__all__
+
+from numpy._pytesttester import PytestTester
+test = PytestTester(__name__)
+del PytestTester
diff --git a/venv/lib/python3.12/site-packages/numpy/ma/__init__.pyi b/venv/lib/python3.12/site-packages/numpy/ma/__init__.pyi
new file mode 100644
index 00000000..805842a8
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/ma/__init__.pyi
@@ -0,0 +1,233 @@
+from numpy._pytesttester import PytestTester
+
+from numpy.ma import extras as extras
+
+from numpy.ma.core import (
+    MAError as MAError,
+    MaskError as MaskError,
+    MaskType as MaskType,
+    MaskedArray as MaskedArray,
+    abs as abs,
+    absolute as absolute,
+    add as add,
+    all as all,
+    allclose as allclose,
+    allequal as allequal,
+    alltrue as alltrue,
+    amax as amax,
+    amin as amin,
+    angle as angle,
+    anom as anom,
+    anomalies as anomalies,
+    any as any,
+    append as append,
+    arange as arange,
+    arccos as arccos,
+    arccosh as arccosh,
+    arcsin as arcsin,
+    arcsinh as arcsinh,
+    arctan as arctan,
+    arctan2 as arctan2,
+    arctanh as arctanh,
+    argmax as argmax,
+    argmin as argmin,
+    argsort as argsort,
+    around as around,
+    array as array,
+    asanyarray as asanyarray,
+    asarray as asarray,
+    bitwise_and as bitwise_and,
+    bitwise_or as bitwise_or,
+    bitwise_xor as bitwise_xor,
+    bool as bool,
+    ceil as ceil,
+    choose as choose,
+    clip as clip,
+    common_fill_value as common_fill_value,
+    compress as compress,
+    compressed as compressed,
+    concatenate as concatenate,
+    conjugate as conjugate,
+    convolve as convolve,
+    copy as copy,
+    correlate as correlate,
+    cos as cos,
+    cosh as cosh,
+    count as count,
+    cumprod as cumprod,
+    cumsum as cumsum,
+    default_fill_value as default_fill_value,
+    diag as diag,
+    diagonal as diagonal,
+    diff as diff,
+    divide as divide,
+    empty as empty,
+    empty_like as empty_like,
+    equal as equal,
+    exp as exp,
+    expand_dims as expand_dims,
+    fabs as fabs,
+    filled as filled,
+    fix_invalid as fix_invalid,
+    flatten_mask as flatten_mask,
+    flatten_structured_array as flatten_structured_array,
+    floor as floor,
+    floor_divide as floor_divide,
+    fmod as fmod,
+    frombuffer as frombuffer,
+    fromflex as fromflex,
+    fromfunction as fromfunction,
+    getdata as getdata,
+    getmask as getmask,
+    getmaskarray as getmaskarray,
+    greater as greater,
+    greater_equal as greater_equal,
+    harden_mask as harden_mask,
+    hypot as hypot,
+    identity as identity,
+    ids as ids,
+    indices as indices,
+    inner as inner,
+    innerproduct as innerproduct,
+    isMA as isMA,
+    isMaskedArray as isMaskedArray,
+    is_mask as is_mask,
+    is_masked as is_masked,
+    isarray as isarray,
+    left_shift as left_shift,
+    less as less,
+    less_equal as less_equal,
+    log as log,
+    log10 as log10,
+    log2 as log2,
+    logical_and as logical_and,
+    logical_not as logical_not,
+    logical_or as logical_or,
+    logical_xor as logical_xor,
+    make_mask as make_mask,
+    make_mask_descr as make_mask_descr,
+    make_mask_none as make_mask_none,
+    mask_or as mask_or,
+    masked as masked,
+    masked_array as masked_array,
+    masked_equal as masked_equal,
+    masked_greater as masked_greater,
+    masked_greater_equal as masked_greater_equal,
+    masked_inside as masked_inside,
+    masked_invalid as masked_invalid,
+    masked_less as masked_less,
+    masked_less_equal as masked_less_equal,
+    masked_not_equal as masked_not_equal,
+    masked_object as masked_object,
+    masked_outside as masked_outside,
+    masked_print_option as masked_print_option,
+    masked_singleton as masked_singleton,
+    masked_values as masked_values,
+    masked_where as masked_where,
+    max as max,
+    maximum as maximum,
+    maximum_fill_value as maximum_fill_value,
+    mean as mean,
+    min as min,
+    minimum as minimum,
+    minimum_fill_value as minimum_fill_value,
+    mod as mod,
+    multiply as multiply,
+    mvoid as mvoid,
+    ndim as ndim,
+    negative as negative,
+    nomask as nomask,
+    nonzero as nonzero,
+    not_equal as not_equal,
+    ones as ones,
+    outer as outer,
+    outerproduct as outerproduct,
+    power as power,
+    prod as prod,
+    product as product,
+    ptp as ptp,
+    put as put,
+    putmask as putmask,
+    ravel as ravel,
+    remainder as remainder,
+    repeat as repeat,
+    reshape as reshape,
+    resize as resize,
+    right_shift as right_shift,
+    round as round,
+    set_fill_value as set_fill_value,
+    shape as shape,
+    sin as sin,
+    sinh as sinh,
+    size as size,
+    soften_mask as soften_mask,
+    sometrue as sometrue,
+    sort as sort,
+    sqrt as sqrt,
+    squeeze as squeeze,
+    std as std,
+    subtract as subtract,
+    sum as sum,
+    swapaxes as swapaxes,
+    take as take,
+    tan as tan,
+    tanh as tanh,
+    trace as trace,
+    transpose as transpose,
+    true_divide as true_divide,
+    var as var,
+    where as where,
+    zeros as zeros,
+)
+
+from numpy.ma.extras import (
+    apply_along_axis as apply_along_axis,
+    apply_over_axes as apply_over_axes,
+    atleast_1d as atleast_1d,
+    atleast_2d as atleast_2d,
+    atleast_3d as atleast_3d,
+    average as average,
+    clump_masked as clump_masked,
+    clump_unmasked as clump_unmasked,
+    column_stack as column_stack,
+    compress_cols as compress_cols,
+    compress_nd as compress_nd,
+    compress_rowcols as compress_rowcols,
+    compress_rows as compress_rows,
+    count_masked as count_masked,
+    corrcoef as corrcoef,
+    cov as cov,
+    diagflat as diagflat,
+    dot as dot,
+    dstack as dstack,
+    ediff1d as ediff1d,
+    flatnotmasked_contiguous as flatnotmasked_contiguous,
+    flatnotmasked_edges as flatnotmasked_edges,
+    hsplit as hsplit,
+    hstack as hstack,
+    isin as isin,
+    in1d as in1d,
+    intersect1d as intersect1d,
+    mask_cols as mask_cols,
+    mask_rowcols as mask_rowcols,
+    mask_rows as mask_rows,
+    masked_all as masked_all,
+    masked_all_like as masked_all_like,
+    median as median,
+    mr_ as mr_,
+    ndenumerate as ndenumerate,
+    notmasked_contiguous as notmasked_contiguous,
+    notmasked_edges as notmasked_edges,
+    polyfit as polyfit,
+    row_stack as row_stack,
+    setdiff1d as setdiff1d,
+    setxor1d as setxor1d,
+    stack as stack,
+    unique as unique,
+    union1d as union1d,
+    vander as vander,
+    vstack as vstack,
+)
+
+__all__: list[str]
+test: PytestTester
diff --git a/venv/lib/python3.12/site-packages/numpy/ma/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/ma/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 00000000..1b5d92a0
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/ma/__pycache__/__init__.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/ma/__pycache__/core.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/ma/__pycache__/core.cpython-312.pyc
new file mode 100644
index 00000000..603bea5d
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/ma/__pycache__/core.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/ma/__pycache__/extras.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/ma/__pycache__/extras.cpython-312.pyc
new file mode 100644
index 00000000..8ea2b10c
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/ma/__pycache__/extras.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/ma/__pycache__/mrecords.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/ma/__pycache__/mrecords.cpython-312.pyc
new file mode 100644
index 00000000..fe263ab1
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/ma/__pycache__/mrecords.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/ma/__pycache__/testutils.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/ma/__pycache__/testutils.cpython-312.pyc
new file mode 100644
index 00000000..129a4fbb
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/ma/__pycache__/testutils.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/ma/__pycache__/timer_comparison.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/ma/__pycache__/timer_comparison.cpython-312.pyc
new file mode 100644
index 00000000..13663765
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/ma/__pycache__/timer_comparison.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/ma/core.py b/venv/lib/python3.12/site-packages/numpy/ma/core.py
new file mode 100644
index 00000000..01eb8f94
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/ma/core.py
@@ -0,0 +1,8899 @@
+"""
+numpy.ma : a package to handle missing or invalid values.
+
+This package was initially written for numarray by Paul F. Dubois
+at Lawrence Livermore National Laboratory.
+In 2006, the package was completely rewritten by Pierre Gerard-Marchant
+(University of Georgia) to make the MaskedArray class a subclass of ndarray,
+and to improve support of structured arrays.
+
+
+Copyright 1999, 2000, 2001 Regents of the University of California.
+Released for unlimited redistribution.
+
+* Adapted for numpy_core 2005 by Travis Oliphant and (mainly) Paul Dubois.
+* Subclassing of the base `ndarray` 2006 by Pierre Gerard-Marchant
+  (pgmdevlist_AT_gmail_DOT_com)
+* Improvements suggested by Reggie Dugard (reggie_AT_merfinllc_DOT_com)
+
+.. moduleauthor:: Pierre Gerard-Marchant
+
+"""
+# pylint: disable-msg=E1002
+import builtins
+import inspect
+import operator
+import warnings
+import textwrap
+import re
+from functools import reduce
+from typing import Dict
+
+import numpy as np
+import numpy._core.umath as umath
+import numpy._core.numerictypes as ntypes
+from numpy._core import multiarray as mu
+from numpy import ndarray, amax, amin, iscomplexobj, bool_, _NoValue, angle
+from numpy import array as narray, expand_dims, iinfo, finfo
+from numpy._core.numeric import normalize_axis_tuple
+from numpy._utils._inspect import getargspec, formatargspec
+from numpy._utils import set_module
+
+
+__all__ = [
+    'MAError', 'MaskError', 'MaskType', 'MaskedArray', 'abs', 'absolute',
+    'add', 'all', 'allclose', 'allequal', 'alltrue', 'amax', 'amin',
+    'angle', 'anom', 'anomalies', 'any', 'append', 'arange', 'arccos',
+    'arccosh', 'arcsin', 'arcsinh', 'arctan', 'arctan2', 'arctanh',
+    'argmax', 'argmin', 'argsort', 'around', 'array', 'asanyarray',
+    'asarray', 'bitwise_and', 'bitwise_or', 'bitwise_xor', 'bool_', 'ceil',
+    'choose', 'clip', 'common_fill_value', 'compress', 'compressed',
+    'concatenate', 'conjugate', 'convolve', 'copy', 'correlate', 'cos', 'cosh',
+    'count', 'cumprod', 'cumsum', 'default_fill_value', 'diag', 'diagonal',
+    'diff', 'divide', 'empty', 'empty_like', 'equal', 'exp',
+    'expand_dims', 'fabs', 'filled', 'fix_invalid', 'flatten_mask',
+    'flatten_structured_array', 'floor', 'floor_divide', 'fmod',
+    'frombuffer', 'fromflex', 'fromfunction', 'getdata', 'getmask',
+    'getmaskarray', 'greater', 'greater_equal', 'harden_mask', 'hypot',
+    'identity', 'ids', 'indices', 'inner', 'innerproduct', 'isMA',
+    'isMaskedArray', 'is_mask', 'is_masked', 'isarray', 'left_shift',
+    'less', 'less_equal', 'log', 'log10', 'log2',
+    'logical_and', 'logical_not', 'logical_or', 'logical_xor', 'make_mask',
+    'make_mask_descr', 'make_mask_none', 'mask_or', 'masked',
+    'masked_array', 'masked_equal', 'masked_greater',
+    'masked_greater_equal', 'masked_inside', 'masked_invalid',
+    'masked_less', 'masked_less_equal', 'masked_not_equal',
+    'masked_object', 'masked_outside', 'masked_print_option',
+    'masked_singleton', 'masked_values', 'masked_where', 'max', 'maximum',
+    'maximum_fill_value', 'mean', 'min', 'minimum', 'minimum_fill_value',
+    'mod', 'multiply', 'mvoid', 'ndim', 'negative', 'nomask', 'nonzero',
+    'not_equal', 'ones', 'ones_like', 'outer', 'outerproduct', 'power', 'prod',
+    'product', 'ptp', 'put', 'putmask', 'ravel', 'remainder',
+    'repeat', 'reshape', 'resize', 'right_shift', 'round', 'round_',
+    'set_fill_value', 'shape', 'sin', 'sinh', 'size', 'soften_mask',
+    'sometrue', 'sort', 'sqrt', 'squeeze', 'std', 'subtract', 'sum',
+    'swapaxes', 'take', 'tan', 'tanh', 'trace', 'transpose', 'true_divide',
+    'var', 'where', 'zeros', 'zeros_like',
+    ]
+
+MaskType = np.bool
+nomask = MaskType(0)
+
+class MaskedArrayFutureWarning(FutureWarning):
+    pass
+
+def _deprecate_argsort_axis(arr):
+    """
+    Adjust the axis passed to argsort, warning if necessary
+
+    Parameters
+    ----------
+    arr
+        The array which argsort was called on
+
+    np.ma.argsort has a long-term bug where the default of the axis argument
+    is wrong (gh-8701), which now must be kept for backwards compatibility.
+    Thankfully, this only makes a difference when arrays are 2- or more-
+    dimensional, so we only need a warning then.
+    """
+    if arr.ndim <= 1:
+        # no warning needed - but switch to -1 anyway, to avoid surprising
+        # subclasses, which are more likely to implement scalar axes.
+        return -1
+    else:
+        # 2017-04-11, Numpy 1.13.0, gh-8701: warn on axis default
+        warnings.warn(
+            "In the future the default for argsort will be axis=-1, not the "
+            "current None, to match its documentation and np.argsort. "
+            "Explicitly pass -1 or None to silence this warning.",
+            MaskedArrayFutureWarning, stacklevel=3)
+        return None
+
+
+def doc_note(initialdoc, note):
+    """
+    Adds a Notes section to an existing docstring.
+
+    """
+    if initialdoc is None:
+        return
+    if note is None:
+        return initialdoc
+
+    notesplit = re.split(r'\n\s*?Notes\n\s*?-----', inspect.cleandoc(initialdoc))
+    notedoc = "\n\nNotes\n-----\n%s\n" % inspect.cleandoc(note)
+
+    return ''.join(notesplit[:1] + [notedoc] + notesplit[1:])
+
+
+def get_object_signature(obj):
+    """
+    Get the signature from obj
+
+    """
+    try:
+        sig = formatargspec(*getargspec(obj))
+    except TypeError:
+        sig = ''
+    return sig
+
+
+###############################################################################
+#                              Exceptions                                     #
+###############################################################################
+
+
+class MAError(Exception):
+    """
+    Class for masked array related errors.
+
+    """
+    pass
+
+
+class MaskError(MAError):
+    """
+    Class for mask related errors.
+
+    """
+    pass
+
+
+###############################################################################
+#                           Filling options                                   #
+###############################################################################
+
+
+# b: boolean - c: complex - f: floats - i: integer - O: object - S: string
+default_filler = {'b': True,
+                  'c': 1.e20 + 0.0j,
+                  'f': 1.e20,
+                  'i': 999999,
+                  'O': '?',
+                  'S': b'N/A',
+                  'u': 999999,
+                  'V': b'???',
+                  'U': 'N/A'
+                  }
+
+# Add datetime64 and timedelta64 types
+for v in ["Y", "M", "W", "D", "h", "m", "s", "ms", "us", "ns", "ps",
+          "fs", "as"]:
+    default_filler["M8[" + v + "]"] = np.datetime64("NaT", v)
+    default_filler["m8[" + v + "]"] = np.timedelta64("NaT", v)
+
+float_types_list = [np.half, np.single, np.double, np.longdouble,
+                    np.csingle, np.cdouble, np.clongdouble]
+
+_minvals: Dict[type, int] = {}
+_maxvals: Dict[type, int] = {}
+
+for sctype in ntypes.sctypeDict.values():
+    scalar_dtype = np.dtype(sctype)
+
+    if scalar_dtype.kind in "Mm":
+        info = np.iinfo(np.int64)
+        min_val, max_val = info.min, info.max
+    elif np.issubdtype(scalar_dtype, np.integer):
+        info = np.iinfo(sctype)
+        min_val, max_val = info.min, info.max
+    elif np.issubdtype(scalar_dtype, np.floating):
+        info = np.finfo(sctype)
+        min_val, max_val = info.min, info.max
+    elif scalar_dtype.kind == "b":
+        min_val, max_val = 0, 1
+    else:
+        min_val, max_val = None, None
+
+    _minvals[sctype] = min_val
+    _maxvals[sctype] = max_val
+
+max_filler = _minvals
+max_filler.update([(k, -np.inf) for k in float_types_list[:4]])
+max_filler.update([(k, complex(-np.inf, -np.inf)) for k in float_types_list[-3:]])
+
+min_filler = _maxvals
+min_filler.update([(k,  +np.inf) for k in float_types_list[:4]])
+min_filler.update([(k, complex(+np.inf, +np.inf)) for k in float_types_list[-3:]])
+
+del float_types_list
+
+def _recursive_fill_value(dtype, f):
+    """
+    Recursively produce a fill value for `dtype`, calling f on scalar dtypes
+    """
+    if dtype.names is not None:
+        # We wrap into `array` here, which ensures we use NumPy cast rules
+        # for integer casts, this allows the use of 99999 as a fill value
+        # for int8.
+        # TODO: This is probably a mess, but should best preserve behavior?
+        vals = tuple(
+                np.array(_recursive_fill_value(dtype[name], f))
+                for name in dtype.names)
+        return np.array(vals, dtype=dtype)[()]  # decay to void scalar from 0d
+    elif dtype.subdtype:
+        subtype, shape = dtype.subdtype
+        subval = _recursive_fill_value(subtype, f)
+        return np.full(shape, subval)
+    else:
+        return f(dtype)
+
+
+def _get_dtype_of(obj):
+    """ Convert the argument for *_fill_value into a dtype """
+    if isinstance(obj, np.dtype):
+        return obj
+    elif hasattr(obj, 'dtype'):
+        return obj.dtype
+    else:
+        return np.asanyarray(obj).dtype
+
+
+def default_fill_value(obj):
+    """
+    Return the default fill value for the argument object.
+
+    The default filling value depends on the datatype of the input
+    array or the type of the input scalar:
+
+       ========  ========
+       datatype  default
+       ========  ========
+       bool      True
+       int       999999
+       float     1.e20
+       complex   1.e20+0j
+       object    '?'
+       string    'N/A'
+       ========  ========
+
+    For structured types, a structured scalar is returned, with each field the
+    default fill value for its type.
+
+    For subarray types, the fill value is an array of the same size containing
+    the default scalar fill value.
+
+    Parameters
+    ----------
+    obj : ndarray, dtype or scalar
+        The array data-type or scalar for which the default fill value
+        is returned.
+
+    Returns
+    -------
+    fill_value : scalar
+        The default fill value.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> np.ma.default_fill_value(1)
+    999999
+    >>> np.ma.default_fill_value(np.array([1.1, 2., np.pi]))
+    1e+20
+    >>> np.ma.default_fill_value(np.dtype(complex))
+    (1e+20+0j)
+
+    """
+    def _scalar_fill_value(dtype):
+        if dtype.kind in 'Mm':
+            return default_filler.get(dtype.str[1:], '?')
+        else:
+            return default_filler.get(dtype.kind, '?')
+
+    dtype = _get_dtype_of(obj)
+    return _recursive_fill_value(dtype, _scalar_fill_value)
+
+
+def _extremum_fill_value(obj, extremum, extremum_name):
+
+    def _scalar_fill_value(dtype):
+        try:
+            return extremum[dtype.type]
+        except KeyError as e:
+            raise TypeError(
+                f"Unsuitable type {dtype} for calculating {extremum_name}."
+            ) from None
+
+    dtype = _get_dtype_of(obj)
+    return _recursive_fill_value(dtype, _scalar_fill_value)
+
+
+def minimum_fill_value(obj):
+    """
+    Return the maximum value that can be represented by the dtype of an object.
+
+    This function is useful for calculating a fill value suitable for
+    taking the minimum of an array with a given dtype.
+
+    Parameters
+    ----------
+    obj : ndarray, dtype or scalar
+        An object that can be queried for it's numeric type.
+
+    Returns
+    -------
+    val : scalar
+        The maximum representable value.
+
+    Raises
+    ------
+    TypeError
+        If `obj` isn't a suitable numeric type.
+
+    See Also
+    --------
+    maximum_fill_value : The inverse function.
+    set_fill_value : Set the filling value of a masked array.
+    MaskedArray.fill_value : Return current fill value.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> import numpy.ma as ma
+    >>> a = np.int8()
+    >>> ma.minimum_fill_value(a)
+    127
+    >>> a = np.int32()
+    >>> ma.minimum_fill_value(a)
+    2147483647
+
+    An array of numeric data can also be passed.
+
+    >>> a = np.array([1, 2, 3], dtype=np.int8)
+    >>> ma.minimum_fill_value(a)
+    127
+    >>> a = np.array([1, 2, 3], dtype=np.float32)
+    >>> ma.minimum_fill_value(a)
+    inf
+
+    """
+    return _extremum_fill_value(obj, min_filler, "minimum")
+
+
+def maximum_fill_value(obj):
+    """
+    Return the minimum value that can be represented by the dtype of an object.
+
+    This function is useful for calculating a fill value suitable for
+    taking the maximum of an array with a given dtype.
+
+    Parameters
+    ----------
+    obj : ndarray, dtype or scalar
+        An object that can be queried for it's numeric type.
+
+    Returns
+    -------
+    val : scalar
+        The minimum representable value.
+
+    Raises
+    ------
+    TypeError
+        If `obj` isn't a suitable numeric type.
+
+    See Also
+    --------
+    minimum_fill_value : The inverse function.
+    set_fill_value : Set the filling value of a masked array.
+    MaskedArray.fill_value : Return current fill value.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> import numpy.ma as ma
+    >>> a = np.int8()
+    >>> ma.maximum_fill_value(a)
+    -128
+    >>> a = np.int32()
+    >>> ma.maximum_fill_value(a)
+    -2147483648
+
+    An array of numeric data can also be passed.
+
+    >>> a = np.array([1, 2, 3], dtype=np.int8)
+    >>> ma.maximum_fill_value(a)
+    -128
+    >>> a = np.array([1, 2, 3], dtype=np.float32)
+    >>> ma.maximum_fill_value(a)
+    -inf
+
+    """
+    return _extremum_fill_value(obj, max_filler, "maximum")
+
+
+def _recursive_set_fill_value(fillvalue, dt):
+    """
+    Create a fill value for a structured dtype.
+
+    Parameters
+    ----------
+    fillvalue : scalar or array_like
+        Scalar or array representing the fill value. If it is of shorter
+        length than the number of fields in dt, it will be resized.
+    dt : dtype
+        The structured dtype for which to create the fill value.
+
+    Returns
+    -------
+    val : tuple
+        A tuple of values corresponding to the structured fill value.
+
+    """
+    fillvalue = np.resize(fillvalue, len(dt.names))
+    output_value = []
+    for (fval, name) in zip(fillvalue, dt.names):
+        cdtype = dt[name]
+        if cdtype.subdtype:
+            cdtype = cdtype.subdtype[0]
+
+        if cdtype.names is not None:
+            output_value.append(tuple(_recursive_set_fill_value(fval, cdtype)))
+        else:
+            output_value.append(np.array(fval, dtype=cdtype).item())
+    return tuple(output_value)
+
+
+def _check_fill_value(fill_value, ndtype):
+    """
+    Private function validating the given `fill_value` for the given dtype.
+
+    If fill_value is None, it is set to the default corresponding to the dtype.
+
+    If fill_value is not None, its value is forced to the given dtype.
+
+    The result is always a 0d array.
+
+    """
+    ndtype = np.dtype(ndtype)
+    if fill_value is None:
+        fill_value = default_fill_value(ndtype)
+    elif ndtype.names is not None:
+        if isinstance(fill_value, (ndarray, np.void)):
+            try:
+                fill_value = np.asarray(fill_value, dtype=ndtype)
+            except ValueError as e:
+                err_msg = "Unable to transform %s to dtype %s"
+                raise ValueError(err_msg % (fill_value, ndtype)) from e
+        else:
+            fill_value = np.asarray(fill_value, dtype=object)
+            fill_value = np.array(_recursive_set_fill_value(fill_value, ndtype),
+                                  dtype=ndtype)
+    else:
+        if isinstance(fill_value, str) and (ndtype.char not in 'OSVU'):
+            # Note this check doesn't work if fill_value is not a scalar
+            err_msg = "Cannot set fill value of string with array of dtype %s"
+            raise TypeError(err_msg % ndtype)
+        else:
+            # In case we want to convert 1e20 to int.
+            # Also in case of converting string arrays.
+            try:
+                fill_value = np.asarray(fill_value, dtype=ndtype)
+            except (OverflowError, ValueError) as e:
+                # Raise TypeError instead of OverflowError or ValueError.
+                # OverflowError is seldom used, and the real problem here is
+                # that the passed fill_value is not compatible with the ndtype.
+                err_msg = "Cannot convert fill_value %s to dtype %s"
+                raise TypeError(err_msg % (fill_value, ndtype)) from e
+    return np.array(fill_value)
+
+
+def set_fill_value(a, fill_value):
+    """
+    Set the filling value of a, if a is a masked array.
+
+    This function changes the fill value of the masked array `a` in place.
+    If `a` is not a masked array, the function returns silently, without
+    doing anything.
+
+    Parameters
+    ----------
+    a : array_like
+        Input array.
+    fill_value : dtype
+        Filling value. A consistency test is performed to make sure
+        the value is compatible with the dtype of `a`.
+
+    Returns
+    -------
+    None
+        Nothing returned by this function.
+
+    See Also
+    --------
+    maximum_fill_value : Return the default fill value for a dtype.
+    MaskedArray.fill_value : Return current fill value.
+    MaskedArray.set_fill_value : Equivalent method.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> import numpy.ma as ma
+    >>> a = np.arange(5)
+    >>> a
+    array([0, 1, 2, 3, 4])
+    >>> a = ma.masked_where(a < 3, a)
+    >>> a
+    masked_array(data=[--, --, --, 3, 4],
+                 mask=[ True,  True,  True, False, False],
+           fill_value=999999)
+    >>> ma.set_fill_value(a, -999)
+    >>> a
+    masked_array(data=[--, --, --, 3, 4],
+                 mask=[ True,  True,  True, False, False],
+           fill_value=-999)
+
+    Nothing happens if `a` is not a masked array.
+
+    >>> a = list(range(5))
+    >>> a
+    [0, 1, 2, 3, 4]
+    >>> ma.set_fill_value(a, 100)
+    >>> a
+    [0, 1, 2, 3, 4]
+    >>> a = np.arange(5)
+    >>> a
+    array([0, 1, 2, 3, 4])
+    >>> ma.set_fill_value(a, 100)
+    >>> a
+    array([0, 1, 2, 3, 4])
+
+    """
+    if isinstance(a, MaskedArray):
+        a.set_fill_value(fill_value)
+    return
+
+
+def get_fill_value(a):
+    """
+    Return the filling value of a, if any.  Otherwise, returns the
+    default filling value for that type.
+
+    """
+    if isinstance(a, MaskedArray):
+        result = a.fill_value
+    else:
+        result = default_fill_value(a)
+    return result
+
+
+def common_fill_value(a, b):
+    """
+    Return the common filling value of two masked arrays, if any.
+
+    If ``a.fill_value == b.fill_value``, return the fill value,
+    otherwise return None.
+
+    Parameters
+    ----------
+    a, b : MaskedArray
+        The masked arrays for which to compare fill values.
+
+    Returns
+    -------
+    fill_value : scalar or None
+        The common fill value, or None.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> x = np.ma.array([0, 1.], fill_value=3)
+    >>> y = np.ma.array([0, 1.], fill_value=3)
+    >>> np.ma.common_fill_value(x, y)
+    3.0
+
+    """
+    t1 = get_fill_value(a)
+    t2 = get_fill_value(b)
+    if t1 == t2:
+        return t1
+    return None
+
+
+def filled(a, fill_value=None):
+    """
+    Return input as an `~numpy.ndarray`, with masked values replaced by
+    `fill_value`.
+
+    If `a` is not a `MaskedArray`, `a` itself is returned.
+    If `a` is a `MaskedArray` with no masked values, then ``a.data`` is
+    returned.
+    If `a` is a `MaskedArray` and `fill_value` is None, `fill_value` is set to
+    ``a.fill_value``.
+
+    Parameters
+    ----------
+    a : MaskedArray or array_like
+        An input object.
+    fill_value : array_like, optional.
+        Can be scalar or non-scalar. If non-scalar, the
+        resulting filled array should be broadcastable
+        over input array. Default is None.
+
+    Returns
+    -------
+    a : ndarray
+        The filled array.
+
+    See Also
+    --------
+    compressed
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> import numpy.ma as ma
+    >>> x = ma.array(np.arange(9).reshape(3, 3), mask=[[1, 0, 0],
+    ...                                                [1, 0, 0],
+    ...                                                [0, 0, 0]])
+    >>> x.filled()
+    array([[999999,      1,      2],
+           [999999,      4,      5],
+           [     6,      7,      8]])
+    >>> x.filled(fill_value=333)
+    array([[333,   1,   2],
+           [333,   4,   5],
+           [  6,   7,   8]])
+    >>> x.filled(fill_value=np.arange(3))
+    array([[0, 1, 2],
+           [0, 4, 5],
+           [6, 7, 8]])
+
+    """
+    if hasattr(a, 'filled'):
+        return a.filled(fill_value)
+
+    elif isinstance(a, ndarray):
+        # Should we check for contiguity ? and a.flags['CONTIGUOUS']:
+        return a
+    elif isinstance(a, dict):
+        return np.array(a, 'O')
+    else:
+        return np.array(a)
+
+
+def get_masked_subclass(*arrays):
+    """
+    Return the youngest subclass of MaskedArray from a list of (masked) arrays.
+
+    In case of siblings, the first listed takes over.
+
+    """
+    if len(arrays) == 1:
+        arr = arrays[0]
+        if isinstance(arr, MaskedArray):
+            rcls = type(arr)
+        else:
+            rcls = MaskedArray
+    else:
+        arrcls = [type(a) for a in arrays]
+        rcls = arrcls[0]
+        if not issubclass(rcls, MaskedArray):
+            rcls = MaskedArray
+        for cls in arrcls[1:]:
+            if issubclass(cls, rcls):
+                rcls = cls
+    # Don't return MaskedConstant as result: revert to MaskedArray
+    if rcls.__name__ == 'MaskedConstant':
+        return MaskedArray
+    return rcls
+
+
+def getdata(a, subok=True):
+    """
+    Return the data of a masked array as an ndarray.
+
+    Return the data of `a` (if any) as an ndarray if `a` is a ``MaskedArray``,
+    else return `a` as a ndarray or subclass (depending on `subok`) if not.
+
+    Parameters
+    ----------
+    a : array_like
+        Input ``MaskedArray``, alternatively a ndarray or a subclass thereof.
+    subok : bool
+        Whether to force the output to be a `pure` ndarray (False) or to
+        return a subclass of ndarray if appropriate (True, default).
+
+    See Also
+    --------
+    getmask : Return the mask of a masked array, or nomask.
+    getmaskarray : Return the mask of a masked array, or full array of False.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> import numpy.ma as ma
+    >>> a = ma.masked_equal([[1,2],[3,4]], 2)
+    >>> a
+    masked_array(
+      data=[[1, --],
+            [3, 4]],
+      mask=[[False,  True],
+            [False, False]],
+      fill_value=2)
+    >>> ma.getdata(a)
+    array([[1, 2],
+           [3, 4]])
+
+    Equivalently use the ``MaskedArray`` `data` attribute.
+
+    >>> a.data
+    array([[1, 2],
+           [3, 4]])
+
+    """
+    try:
+        data = a._data
+    except AttributeError:
+        data = np.array(a, copy=None, subok=subok)
+    if not subok:
+        return data.view(ndarray)
+    return data
+
+
+get_data = getdata
+
+
+def fix_invalid(a, mask=nomask, copy=True, fill_value=None):
+    """
+    Return input with invalid data masked and replaced by a fill value.
+
+    Invalid data means values of `nan`, `inf`, etc.
+
+    Parameters
+    ----------
+    a : array_like
+        Input array, a (subclass of) ndarray.
+    mask : sequence, optional
+        Mask. Must be convertible to an array of booleans with the same
+        shape as `data`. True indicates a masked (i.e. invalid) data.
+    copy : bool, optional
+        Whether to use a copy of `a` (True) or to fix `a` in place (False).
+        Default is True.
+    fill_value : scalar, optional
+        Value used for fixing invalid data. Default is None, in which case
+        the ``a.fill_value`` is used.
+
+    Returns
+    -------
+    b : MaskedArray
+        The input array with invalid entries fixed.
+
+    Notes
+    -----
+    A copy is performed by default.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> x = np.ma.array([1., -1, np.nan, np.inf], mask=[1] + [0]*3)
+    >>> x
+    masked_array(data=[--, -1.0, nan, inf],
+                 mask=[ True, False, False, False],
+           fill_value=1e+20)
+    >>> np.ma.fix_invalid(x)
+    masked_array(data=[--, -1.0, --, --],
+                 mask=[ True, False,  True,  True],
+           fill_value=1e+20)
+
+    >>> fixed = np.ma.fix_invalid(x)
+    >>> fixed.data
+    array([ 1.e+00, -1.e+00,  1.e+20,  1.e+20])
+    >>> x.data
+    array([ 1., -1., nan, inf])
+
+    """
+    a = masked_array(a, copy=copy, mask=mask, subok=True)
+    invalid = np.logical_not(np.isfinite(a._data))
+    if not invalid.any():
+        return a
+    a._mask |= invalid
+    if fill_value is None:
+        fill_value = a.fill_value
+    a._data[invalid] = fill_value
+    return a
+
+def is_string_or_list_of_strings(val):
+    return (isinstance(val, str) or
+            (isinstance(val, list) and val and
+             builtins.all(isinstance(s, str) for s in val)))
+
+###############################################################################
+#                                  Ufuncs                                     #
+###############################################################################
+
+
+ufunc_domain = {}
+ufunc_fills = {}
+
+
+class _DomainCheckInterval:
+    """
+    Define a valid interval, so that :
+
+    ``domain_check_interval(a,b)(x) == True`` where
+    ``x < a`` or ``x > b``.
+
+    """
+
+    def __init__(self, a, b):
+        "domain_check_interval(a,b)(x) = true where x < a or y > b"
+        if a > b:
+            (a, b) = (b, a)
+        self.a = a
+        self.b = b
+
+    def __call__(self, x):
+        "Execute the call behavior."
+        # nans at masked positions cause RuntimeWarnings, even though
+        # they are masked. To avoid this we suppress warnings.
+        with np.errstate(invalid='ignore'):
+            return umath.logical_or(umath.greater(x, self.b),
+                                    umath.less(x, self.a))
+
+
+class _DomainTan:
+    """
+    Define a valid interval for the `tan` function, so that:
+
+    ``domain_tan(eps) = True`` where ``abs(cos(x)) < eps``
+
+    """
+
+    def __init__(self, eps):
+        "domain_tan(eps) = true where abs(cos(x)) < eps)"
+        self.eps = eps
+
+    def __call__(self, x):
+        "Executes the call behavior."
+        with np.errstate(invalid='ignore'):
+            return umath.less(umath.absolute(umath.cos(x)), self.eps)
+
+
+class _DomainSafeDivide:
+    """
+    Define a domain for safe division.
+
+    """
+
+    def __init__(self, tolerance=None):
+        self.tolerance = tolerance
+
+    def __call__(self, a, b):
+        # Delay the selection of the tolerance to here in order to reduce numpy
+        # import times. The calculation of these parameters is a substantial
+        # component of numpy's import time.
+        if self.tolerance is None:
+            self.tolerance = np.finfo(float).tiny
+        # don't call ma ufuncs from __array_wrap__ which would fail for scalars
+        a, b = np.asarray(a), np.asarray(b)
+        with np.errstate(all='ignore'):
+            return umath.absolute(a) * self.tolerance >= umath.absolute(b)
+
+
+class _DomainGreater:
+    """
+    DomainGreater(v)(x) is True where x <= v.
+
+    """
+
+    def __init__(self, critical_value):
+        "DomainGreater(v)(x) = true where x <= v"
+        self.critical_value = critical_value
+
+    def __call__(self, x):
+        "Executes the call behavior."
+        with np.errstate(invalid='ignore'):
+            return umath.less_equal(x, self.critical_value)
+
+
+class _DomainGreaterEqual:
+    """
+    DomainGreaterEqual(v)(x) is True where x < v.
+
+    """
+
+    def __init__(self, critical_value):
+        "DomainGreaterEqual(v)(x) = true where x < v"
+        self.critical_value = critical_value
+
+    def __call__(self, x):
+        "Executes the call behavior."
+        with np.errstate(invalid='ignore'):
+            return umath.less(x, self.critical_value)
+
+
+class _MaskedUFunc:
+    def __init__(self, ufunc):
+        self.f = ufunc
+        self.__doc__ = ufunc.__doc__
+        self.__name__ = ufunc.__name__
+
+    def __str__(self):
+        return f"Masked version of {self.f}"
+
+
+class _MaskedUnaryOperation(_MaskedUFunc):
+    """
+    Defines masked version of unary operations, where invalid values are
+    pre-masked.
+
+    Parameters
+    ----------
+    mufunc : callable
+        The function for which to define a masked version. Made available
+        as ``_MaskedUnaryOperation.f``.
+    fill : scalar, optional
+        Filling value, default is 0.
+    domain : class instance
+        Domain for the function. Should be one of the ``_Domain*``
+        classes. Default is None.
+
+    """
+
+    def __init__(self, mufunc, fill=0, domain=None):
+        super().__init__(mufunc)
+        self.fill = fill
+        self.domain = domain
+        ufunc_domain[mufunc] = domain
+        ufunc_fills[mufunc] = fill
+
+    def __call__(self, a, *args, **kwargs):
+        """
+        Execute the call behavior.
+
+        """
+        d = getdata(a)
+        # Deal with domain
+        if self.domain is not None:
+            # Case 1.1. : Domained function
+            # nans at masked positions cause RuntimeWarnings, even though
+            # they are masked. To avoid this we suppress warnings.
+            with np.errstate(divide='ignore', invalid='ignore'):
+                result = self.f(d, *args, **kwargs)
+            # Make a mask
+            m = ~umath.isfinite(result)
+            m |= self.domain(d)
+            m |= getmask(a)
+        else:
+            # Case 1.2. : Function without a domain
+            # Get the result and the mask
+            with np.errstate(divide='ignore', invalid='ignore'):
+                result = self.f(d, *args, **kwargs)
+            m = getmask(a)
+
+        if not result.ndim:
+            # Case 2.1. : The result is scalarscalar
+            if m:
+                return masked
+            return result
+
+        if m is not nomask:
+            # Case 2.2. The result is an array
+            # We need to fill the invalid data back w/ the input Now,
+            # that's plain silly: in C, we would just skip the element and
+            # keep the original, but we do have to do it that way in Python
+
+            # In case result has a lower dtype than the inputs (as in
+            # equal)
+            try:
+                np.copyto(result, d, where=m)
+            except TypeError:
+                pass
+        # Transform to
+        masked_result = result.view(get_masked_subclass(a))
+        masked_result._mask = m
+        masked_result._update_from(a)
+        return masked_result
+
+
+class _MaskedBinaryOperation(_MaskedUFunc):
+    """
+    Define masked version of binary operations, where invalid
+    values are pre-masked.
+
+    Parameters
+    ----------
+    mbfunc : function
+        The function for which to define a masked version. Made available
+        as ``_MaskedBinaryOperation.f``.
+    domain : class instance
+        Default domain for the function. Should be one of the ``_Domain*``
+        classes. Default is None.
+    fillx : scalar, optional
+        Filling value for the first argument, default is 0.
+    filly : scalar, optional
+        Filling value for the second argument, default is 0.
+
+    """
+
+    def __init__(self, mbfunc, fillx=0, filly=0):
+        """
+        abfunc(fillx, filly) must be defined.
+
+        abfunc(x, filly) = x for all x to enable reduce.
+
+        """
+        super().__init__(mbfunc)
+        self.fillx = fillx
+        self.filly = filly
+        ufunc_domain[mbfunc] = None
+        ufunc_fills[mbfunc] = (fillx, filly)
+
+    def __call__(self, a, b, *args, **kwargs):
+        """
+        Execute the call behavior.
+
+        """
+        # Get the data, as ndarray
+        (da, db) = (getdata(a), getdata(b))
+        # Get the result
+        with np.errstate():
+            np.seterr(divide='ignore', invalid='ignore')
+            result = self.f(da, db, *args, **kwargs)
+        # Get the mask for the result
+        (ma, mb) = (getmask(a), getmask(b))
+        if ma is nomask:
+            if mb is nomask:
+                m = nomask
+            else:
+                m = umath.logical_or(getmaskarray(a), mb)
+        elif mb is nomask:
+            m = umath.logical_or(ma, getmaskarray(b))
+        else:
+            m = umath.logical_or(ma, mb)
+
+        # Case 1. : scalar
+        if not result.ndim:
+            if m:
+                return masked
+            return result
+
+        # Case 2. : array
+        # Revert result to da where masked
+        if m is not nomask and m.any():
+            # any errors, just abort; impossible to guarantee masked values
+            try:
+                np.copyto(result, da, casting='unsafe', where=m)
+            except Exception:
+                pass
+
+        # Transforms to a (subclass of) MaskedArray
+        masked_result = result.view(get_masked_subclass(a, b))
+        masked_result._mask = m
+        if isinstance(a, MaskedArray):
+            masked_result._update_from(a)
+        elif isinstance(b, MaskedArray):
+            masked_result._update_from(b)
+        return masked_result
+
+    def reduce(self, target, axis=0, dtype=None):
+        """
+        Reduce `target` along the given `axis`.
+
+        """
+        tclass = get_masked_subclass(target)
+        m = getmask(target)
+        t = filled(target, self.filly)
+        if t.shape == ():
+            t = t.reshape(1)
+            if m is not nomask:
+                m = make_mask(m, copy=True)
+                m.shape = (1,)
+
+        if m is nomask:
+            tr = self.f.reduce(t, axis)
+            mr = nomask
+        else:
+            tr = self.f.reduce(t, axis, dtype=dtype)
+            mr = umath.logical_and.reduce(m, axis)
+
+        if not tr.shape:
+            if mr:
+                return masked
+            else:
+                return tr
+        masked_tr = tr.view(tclass)
+        masked_tr._mask = mr
+        return masked_tr
+
+    def outer(self, a, b):
+        """
+        Return the function applied to the outer product of a and b.
+
+        """
+        (da, db) = (getdata(a), getdata(b))
+        d = self.f.outer(da, db)
+        ma = getmask(a)
+        mb = getmask(b)
+        if ma is nomask and mb is nomask:
+            m = nomask
+        else:
+            ma = getmaskarray(a)
+            mb = getmaskarray(b)
+            m = umath.logical_or.outer(ma, mb)
+        if (not m.ndim) and m:
+            return masked
+        if m is not nomask:
+            np.copyto(d, da, where=m)
+        if not d.shape:
+            return d
+        masked_d = d.view(get_masked_subclass(a, b))
+        masked_d._mask = m
+        return masked_d
+
+    def accumulate(self, target, axis=0):
+        """Accumulate `target` along `axis` after filling with y fill
+        value.
+
+        """
+        tclass = get_masked_subclass(target)
+        t = filled(target, self.filly)
+        result = self.f.accumulate(t, axis)
+        masked_result = result.view(tclass)
+        return masked_result
+
+
+
+class _DomainedBinaryOperation(_MaskedUFunc):
+    """
+    Define binary operations that have a domain, like divide.
+
+    They have no reduce, outer or accumulate.
+
+    Parameters
+    ----------
+    mbfunc : function
+        The function for which to define a masked version. Made available
+        as ``_DomainedBinaryOperation.f``.
+    domain : class instance
+        Default domain for the function. Should be one of the ``_Domain*``
+        classes.
+    fillx : scalar, optional
+        Filling value for the first argument, default is 0.
+    filly : scalar, optional
+        Filling value for the second argument, default is 0.
+
+    """
+
+    def __init__(self, dbfunc, domain, fillx=0, filly=0):
+        """abfunc(fillx, filly) must be defined.
+           abfunc(x, filly) = x for all x to enable reduce.
+        """
+        super().__init__(dbfunc)
+        self.domain = domain
+        self.fillx = fillx
+        self.filly = filly
+        ufunc_domain[dbfunc] = domain
+        ufunc_fills[dbfunc] = (fillx, filly)
+
+    def __call__(self, a, b, *args, **kwargs):
+        "Execute the call behavior."
+        # Get the data
+        (da, db) = (getdata(a), getdata(b))
+        # Get the result
+        with np.errstate(divide='ignore', invalid='ignore'):
+            result = self.f(da, db, *args, **kwargs)
+        # Get the mask as a combination of the source masks and invalid
+        m = ~umath.isfinite(result)
+        m |= getmask(a)
+        m |= getmask(b)
+        # Apply the domain
+        domain = ufunc_domain.get(self.f, None)
+        if domain is not None:
+            m |= domain(da, db)
+        # Take care of the scalar case first
+        if not m.ndim:
+            if m:
+                return masked
+            else:
+                return result
+        # When the mask is True, put back da if possible
+        # any errors, just abort; impossible to guarantee masked values
+        try:
+            np.copyto(result, 0, casting='unsafe', where=m)
+            # avoid using "*" since this may be overlaid
+            masked_da = umath.multiply(m, da)
+            # only add back if it can be cast safely
+            if np.can_cast(masked_da.dtype, result.dtype, casting='safe'):
+                result += masked_da
+        except Exception:
+            pass
+
+        # Transforms to a (subclass of) MaskedArray
+        masked_result = result.view(get_masked_subclass(a, b))
+        masked_result._mask = m
+        if isinstance(a, MaskedArray):
+            masked_result._update_from(a)
+        elif isinstance(b, MaskedArray):
+            masked_result._update_from(b)
+        return masked_result
+
+
+# Unary ufuncs
+exp = _MaskedUnaryOperation(umath.exp)
+conjugate = _MaskedUnaryOperation(umath.conjugate)
+sin = _MaskedUnaryOperation(umath.sin)
+cos = _MaskedUnaryOperation(umath.cos)
+arctan = _MaskedUnaryOperation(umath.arctan)
+arcsinh = _MaskedUnaryOperation(umath.arcsinh)
+sinh = _MaskedUnaryOperation(umath.sinh)
+cosh = _MaskedUnaryOperation(umath.cosh)
+tanh = _MaskedUnaryOperation(umath.tanh)
+abs = absolute = _MaskedUnaryOperation(umath.absolute)
+angle = _MaskedUnaryOperation(angle)
+fabs = _MaskedUnaryOperation(umath.fabs)
+negative = _MaskedUnaryOperation(umath.negative)
+floor = _MaskedUnaryOperation(umath.floor)
+ceil = _MaskedUnaryOperation(umath.ceil)
+around = _MaskedUnaryOperation(np.around)
+logical_not = _MaskedUnaryOperation(umath.logical_not)
+
+# Domained unary ufuncs
+sqrt = _MaskedUnaryOperation(umath.sqrt, 0.0,
+                             _DomainGreaterEqual(0.0))
+log = _MaskedUnaryOperation(umath.log, 1.0,
+                            _DomainGreater(0.0))
+log2 = _MaskedUnaryOperation(umath.log2, 1.0,
+                             _DomainGreater(0.0))
+log10 = _MaskedUnaryOperation(umath.log10, 1.0,
+                              _DomainGreater(0.0))
+tan = _MaskedUnaryOperation(umath.tan, 0.0,
+                            _DomainTan(1e-35))
+arcsin = _MaskedUnaryOperation(umath.arcsin, 0.0,
+                               _DomainCheckInterval(-1.0, 1.0))
+arccos = _MaskedUnaryOperation(umath.arccos, 0.0,
+                               _DomainCheckInterval(-1.0, 1.0))
+arccosh = _MaskedUnaryOperation(umath.arccosh, 1.0,
+                                _DomainGreaterEqual(1.0))
+arctanh = _MaskedUnaryOperation(umath.arctanh, 0.0,
+                                _DomainCheckInterval(-1.0 + 1e-15, 1.0 - 1e-15))
+
+# Binary ufuncs
+add = _MaskedBinaryOperation(umath.add)
+subtract = _MaskedBinaryOperation(umath.subtract)
+multiply = _MaskedBinaryOperation(umath.multiply, 1, 1)
+arctan2 = _MaskedBinaryOperation(umath.arctan2, 0.0, 1.0)
+equal = _MaskedBinaryOperation(umath.equal)
+equal.reduce = None
+not_equal = _MaskedBinaryOperation(umath.not_equal)
+not_equal.reduce = None
+less_equal = _MaskedBinaryOperation(umath.less_equal)
+less_equal.reduce = None
+greater_equal = _MaskedBinaryOperation(umath.greater_equal)
+greater_equal.reduce = None
+less = _MaskedBinaryOperation(umath.less)
+less.reduce = None
+greater = _MaskedBinaryOperation(umath.greater)
+greater.reduce = None
+logical_and = _MaskedBinaryOperation(umath.logical_and)
+alltrue = _MaskedBinaryOperation(umath.logical_and, 1, 1).reduce
+logical_or = _MaskedBinaryOperation(umath.logical_or)
+sometrue = logical_or.reduce
+logical_xor = _MaskedBinaryOperation(umath.logical_xor)
+bitwise_and = _MaskedBinaryOperation(umath.bitwise_and)
+bitwise_or = _MaskedBinaryOperation(umath.bitwise_or)
+bitwise_xor = _MaskedBinaryOperation(umath.bitwise_xor)
+hypot = _MaskedBinaryOperation(umath.hypot)
+
+# Domained binary ufuncs
+divide = _DomainedBinaryOperation(umath.divide, _DomainSafeDivide(), 0, 1)
+true_divide = _DomainedBinaryOperation(umath.true_divide,
+                                       _DomainSafeDivide(), 0, 1)
+floor_divide = _DomainedBinaryOperation(umath.floor_divide,
+                                        _DomainSafeDivide(), 0, 1)
+remainder = _DomainedBinaryOperation(umath.remainder,
+                                     _DomainSafeDivide(), 0, 1)
+fmod = _DomainedBinaryOperation(umath.fmod, _DomainSafeDivide(), 0, 1)
+mod = _DomainedBinaryOperation(umath.mod, _DomainSafeDivide(), 0, 1)
+
+
+###############################################################################
+#                        Mask creation functions                              #
+###############################################################################
+
+
+def _replace_dtype_fields_recursive(dtype, primitive_dtype):
+    "Private function allowing recursion in _replace_dtype_fields."
+    _recurse = _replace_dtype_fields_recursive
+
+    # Do we have some name fields ?
+    if dtype.names is not None:
+        descr = []
+        for name in dtype.names:
+            field = dtype.fields[name]
+            if len(field) == 3:
+                # Prepend the title to the name
+                name = (field[-1], name)
+            descr.append((name, _recurse(field[0], primitive_dtype)))
+        new_dtype = np.dtype(descr)
+
+    # Is this some kind of composite a la (float,2)
+    elif dtype.subdtype:
+        descr = list(dtype.subdtype)
+        descr[0] = _recurse(dtype.subdtype[0], primitive_dtype)
+        new_dtype = np.dtype(tuple(descr))
+
+    # this is a primitive type, so do a direct replacement
+    else:
+        new_dtype = primitive_dtype
+
+    # preserve identity of dtypes
+    if new_dtype == dtype:
+        new_dtype = dtype
+
+    return new_dtype
+
+
+def _replace_dtype_fields(dtype, primitive_dtype):
+    """
+    Construct a dtype description list from a given dtype.
+
+    Returns a new dtype object, with all fields and subtypes in the given type
+    recursively replaced with `primitive_dtype`.
+
+    Arguments are coerced to dtypes first.
+    """
+    dtype = np.dtype(dtype)
+    primitive_dtype = np.dtype(primitive_dtype)
+    return _replace_dtype_fields_recursive(dtype, primitive_dtype)
+
+
+def make_mask_descr(ndtype):
+    """
+    Construct a dtype description list from a given dtype.
+
+    Returns a new dtype object, with the type of all fields in `ndtype` to a
+    boolean type. Field names are not altered.
+
+    Parameters
+    ----------
+    ndtype : dtype
+        The dtype to convert.
+
+    Returns
+    -------
+    result : dtype
+        A dtype that looks like `ndtype`, the type of all fields is boolean.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> import numpy.ma as ma
+    >>> dtype = np.dtype({'names':['foo', 'bar'],
+    ...                   'formats':[np.float32, np.int64]})
+    >>> dtype
+    dtype([('foo', '>> ma.make_mask_descr(dtype)
+    dtype([('foo', '|b1'), ('bar', '|b1')])
+    >>> ma.make_mask_descr(np.float32)
+    dtype('bool')
+
+    """
+    return _replace_dtype_fields(ndtype, MaskType)
+
+
+def getmask(a):
+    """
+    Return the mask of a masked array, or nomask.
+
+    Return the mask of `a` as an ndarray if `a` is a `MaskedArray` and the
+    mask is not `nomask`, else return `nomask`. To guarantee a full array
+    of booleans of the same shape as a, use `getmaskarray`.
+
+    Parameters
+    ----------
+    a : array_like
+        Input `MaskedArray` for which the mask is required.
+
+    See Also
+    --------
+    getdata : Return the data of a masked array as an ndarray.
+    getmaskarray : Return the mask of a masked array, or full array of False.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> import numpy.ma as ma
+    >>> a = ma.masked_equal([[1,2],[3,4]], 2)
+    >>> a
+    masked_array(
+      data=[[1, --],
+            [3, 4]],
+      mask=[[False,  True],
+            [False, False]],
+      fill_value=2)
+    >>> ma.getmask(a)
+    array([[False,  True],
+           [False, False]])
+
+    Equivalently use the `MaskedArray` `mask` attribute.
+
+    >>> a.mask
+    array([[False,  True],
+           [False, False]])
+
+    Result when mask == `nomask`
+
+    >>> b = ma.masked_array([[1,2],[3,4]])
+    >>> b
+    masked_array(
+      data=[[1, 2],
+            [3, 4]],
+      mask=False,
+      fill_value=999999)
+    >>> ma.nomask
+    False
+    >>> ma.getmask(b) == ma.nomask
+    True
+    >>> b.mask == ma.nomask
+    True
+
+    """
+    return getattr(a, '_mask', nomask)
+
+
+get_mask = getmask
+
+
+def getmaskarray(arr):
+    """
+    Return the mask of a masked array, or full boolean array of False.
+
+    Return the mask of `arr` as an ndarray if `arr` is a `MaskedArray` and
+    the mask is not `nomask`, else return a full boolean array of False of
+    the same shape as `arr`.
+
+    Parameters
+    ----------
+    arr : array_like
+        Input `MaskedArray` for which the mask is required.
+
+    See Also
+    --------
+    getmask : Return the mask of a masked array, or nomask.
+    getdata : Return the data of a masked array as an ndarray.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> import numpy.ma as ma
+    >>> a = ma.masked_equal([[1,2],[3,4]], 2)
+    >>> a
+    masked_array(
+      data=[[1, --],
+            [3, 4]],
+      mask=[[False,  True],
+            [False, False]],
+      fill_value=2)
+    >>> ma.getmaskarray(a)
+    array([[False,  True],
+           [False, False]])
+
+    Result when mask == ``nomask``
+
+    >>> b = ma.masked_array([[1,2],[3,4]])
+    >>> b
+    masked_array(
+      data=[[1, 2],
+            [3, 4]],
+      mask=False,
+      fill_value=999999)
+    >>> ma.getmaskarray(b)
+    array([[False, False],
+           [False, False]])
+
+    """
+    mask = getmask(arr)
+    if mask is nomask:
+        mask = make_mask_none(np.shape(arr), getattr(arr, 'dtype', None))
+    return mask
+
+
+def is_mask(m):
+    """
+    Return True if m is a valid, standard mask.
+
+    This function does not check the contents of the input, only that the
+    type is MaskType. In particular, this function returns False if the
+    mask has a flexible dtype.
+
+    Parameters
+    ----------
+    m : array_like
+        Array to test.
+
+    Returns
+    -------
+    result : bool
+        True if `m.dtype.type` is MaskType, False otherwise.
+
+    See Also
+    --------
+    ma.isMaskedArray : Test whether input is an instance of MaskedArray.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> import numpy.ma as ma
+    >>> m = ma.masked_equal([0, 1, 0, 2, 3], 0)
+    >>> m
+    masked_array(data=[--, 1, --, 2, 3],
+                 mask=[ True, False,  True, False, False],
+           fill_value=0)
+    >>> ma.is_mask(m)
+    False
+    >>> ma.is_mask(m.mask)
+    True
+
+    Input must be an ndarray (or have similar attributes)
+    for it to be considered a valid mask.
+
+    >>> m = [False, True, False]
+    >>> ma.is_mask(m)
+    False
+    >>> m = np.array([False, True, False])
+    >>> m
+    array([False,  True, False])
+    >>> ma.is_mask(m)
+    True
+
+    Arrays with complex dtypes don't return True.
+
+    >>> dtype = np.dtype({'names':['monty', 'pithon'],
+    ...                   'formats':[bool, bool]})
+    >>> dtype
+    dtype([('monty', '|b1'), ('pithon', '|b1')])
+    >>> m = np.array([(True, False), (False, True), (True, False)],
+    ...              dtype=dtype)
+    >>> m
+    array([( True, False), (False,  True), ( True, False)],
+          dtype=[('monty', '?'), ('pithon', '?')])
+    >>> ma.is_mask(m)
+    False
+
+    """
+    try:
+        return m.dtype.type is MaskType
+    except AttributeError:
+        return False
+
+
+def _shrink_mask(m):
+    """
+    Shrink a mask to nomask if possible
+    """
+    if m.dtype.names is None and not m.any():
+        return nomask
+    else:
+        return m
+
+
+def make_mask(m, copy=False, shrink=True, dtype=MaskType):
+    """
+    Create a boolean mask from an array.
+
+    Return `m` as a boolean mask, creating a copy if necessary or requested.
+    The function can accept any sequence that is convertible to integers,
+    or ``nomask``.  Does not require that contents must be 0s and 1s, values
+    of 0 are interpreted as False, everything else as True.
+
+    Parameters
+    ----------
+    m : array_like
+        Potential mask.
+    copy : bool, optional
+        Whether to return a copy of `m` (True) or `m` itself (False).
+    shrink : bool, optional
+        Whether to shrink `m` to ``nomask`` if all its values are False.
+    dtype : dtype, optional
+        Data-type of the output mask. By default, the output mask has a
+        dtype of MaskType (bool). If the dtype is flexible, each field has
+        a boolean dtype. This is ignored when `m` is ``nomask``, in which
+        case ``nomask`` is always returned.
+
+    Returns
+    -------
+    result : ndarray
+        A boolean mask derived from `m`.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> import numpy.ma as ma
+    >>> m = [True, False, True, True]
+    >>> ma.make_mask(m)
+    array([ True, False,  True,  True])
+    >>> m = [1, 0, 1, 1]
+    >>> ma.make_mask(m)
+    array([ True, False,  True,  True])
+    >>> m = [1, 0, 2, -3]
+    >>> ma.make_mask(m)
+    array([ True, False,  True,  True])
+
+    Effect of the `shrink` parameter.
+
+    >>> m = np.zeros(4)
+    >>> m
+    array([0., 0., 0., 0.])
+    >>> ma.make_mask(m)
+    False
+    >>> ma.make_mask(m, shrink=False)
+    array([False, False, False, False])
+
+    Using a flexible `dtype`.
+
+    >>> m = [1, 0, 1, 1]
+    >>> n = [0, 1, 0, 0]
+    >>> arr = []
+    >>> for man, mouse in zip(m, n):
+    ...     arr.append((man, mouse))
+    >>> arr
+    [(1, 0), (0, 1), (1, 0), (1, 0)]
+    >>> dtype = np.dtype({'names':['man', 'mouse'],
+    ...                   'formats':[np.int64, np.int64]})
+    >>> arr = np.array(arr, dtype=dtype)
+    >>> arr
+    array([(1, 0), (0, 1), (1, 0), (1, 0)],
+          dtype=[('man', '>> ma.make_mask(arr, dtype=dtype)
+    array([(True, False), (False, True), (True, False), (True, False)],
+          dtype=[('man', '|b1'), ('mouse', '|b1')])
+
+    """
+    if m is nomask:
+        return nomask
+
+    # Make sure the input dtype is valid.
+    dtype = make_mask_descr(dtype)
+
+    # legacy boolean special case: "existence of fields implies true"
+    if isinstance(m, ndarray) and m.dtype.fields and dtype == np.bool:
+        return np.ones(m.shape, dtype=dtype)
+
+    # Fill the mask in case there are missing data; turn it into an ndarray.
+    copy = None if not copy else True
+    result = np.array(filled(m, True), copy=copy, dtype=dtype, subok=True)
+    # Bas les masques !
+    if shrink:
+        result = _shrink_mask(result)
+    return result
+
+
+def make_mask_none(newshape, dtype=None):
+    """
+    Return a boolean mask of the given shape, filled with False.
+
+    This function returns a boolean ndarray with all entries False, that can
+    be used in common mask manipulations. If a complex dtype is specified, the
+    type of each field is converted to a boolean type.
+
+    Parameters
+    ----------
+    newshape : tuple
+        A tuple indicating the shape of the mask.
+    dtype : {None, dtype}, optional
+        If None, use a MaskType instance. Otherwise, use a new datatype with
+        the same fields as `dtype`, converted to boolean types.
+
+    Returns
+    -------
+    result : ndarray
+        An ndarray of appropriate shape and dtype, filled with False.
+
+    See Also
+    --------
+    make_mask : Create a boolean mask from an array.
+    make_mask_descr : Construct a dtype description list from a given dtype.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> import numpy.ma as ma
+    >>> ma.make_mask_none((3,))
+    array([False, False, False])
+
+    Defining a more complex dtype.
+
+    >>> dtype = np.dtype({'names':['foo', 'bar'],
+    ...                   'formats':[np.float32, np.int64]})
+    >>> dtype
+    dtype([('foo', '>> ma.make_mask_none((3,), dtype=dtype)
+    array([(False, False), (False, False), (False, False)],
+          dtype=[('foo', '|b1'), ('bar', '|b1')])
+
+    """
+    if dtype is None:
+        result = np.zeros(newshape, dtype=MaskType)
+    else:
+        result = np.zeros(newshape, dtype=make_mask_descr(dtype))
+    return result
+
+
+def _recursive_mask_or(m1, m2, newmask):
+    names = m1.dtype.names
+    for name in names:
+        current1 = m1[name]
+        if current1.dtype.names is not None:
+            _recursive_mask_or(current1, m2[name], newmask[name])
+        else:
+            umath.logical_or(current1, m2[name], newmask[name])
+
+
+def mask_or(m1, m2, copy=False, shrink=True):
+    """
+    Combine two masks with the ``logical_or`` operator.
+
+    The result may be a view on `m1` or `m2` if the other is `nomask`
+    (i.e. False).
+
+    Parameters
+    ----------
+    m1, m2 : array_like
+        Input masks.
+    copy : bool, optional
+        If copy is False and one of the inputs is `nomask`, return a view
+        of the other input mask. Defaults to False.
+    shrink : bool, optional
+        Whether to shrink the output to `nomask` if all its values are
+        False. Defaults to True.
+
+    Returns
+    -------
+    mask : output mask
+        The result masks values that are masked in either `m1` or `m2`.
+
+    Raises
+    ------
+    ValueError
+        If `m1` and `m2` have different flexible dtypes.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> m1 = np.ma.make_mask([0, 1, 1, 0])
+    >>> m2 = np.ma.make_mask([1, 0, 0, 0])
+    >>> np.ma.mask_or(m1, m2)
+    array([ True,  True,  True, False])
+
+    """
+
+    if (m1 is nomask) or (m1 is False):
+        dtype = getattr(m2, 'dtype', MaskType)
+        return make_mask(m2, copy=copy, shrink=shrink, dtype=dtype)
+    if (m2 is nomask) or (m2 is False):
+        dtype = getattr(m1, 'dtype', MaskType)
+        return make_mask(m1, copy=copy, shrink=shrink, dtype=dtype)
+    if m1 is m2 and is_mask(m1):
+        return m1
+    (dtype1, dtype2) = (getattr(m1, 'dtype', None), getattr(m2, 'dtype', None))
+    if dtype1 != dtype2:
+        raise ValueError("Incompatible dtypes '%s'<>'%s'" % (dtype1, dtype2))
+    if dtype1.names is not None:
+        # Allocate an output mask array with the properly broadcast shape.
+        newmask = np.empty(np.broadcast(m1, m2).shape, dtype1)
+        _recursive_mask_or(m1, m2, newmask)
+        return newmask
+    return make_mask(umath.logical_or(m1, m2), copy=copy, shrink=shrink)
+
+
+def flatten_mask(mask):
+    """
+    Returns a completely flattened version of the mask, where nested fields
+    are collapsed.
+
+    Parameters
+    ----------
+    mask : array_like
+        Input array, which will be interpreted as booleans.
+
+    Returns
+    -------
+    flattened_mask : ndarray of bools
+        The flattened input.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> mask = np.array([0, 0, 1])
+    >>> np.ma.flatten_mask(mask)
+    array([False, False,  True])
+
+    >>> mask = np.array([(0, 0), (0, 1)], dtype=[('a', bool), ('b', bool)])
+    >>> np.ma.flatten_mask(mask)
+    array([False, False, False,  True])
+
+    >>> mdtype = [('a', bool), ('b', [('ba', bool), ('bb', bool)])]
+    >>> mask = np.array([(0, (0, 0)), (0, (0, 1))], dtype=mdtype)
+    >>> np.ma.flatten_mask(mask)
+    array([False, False, False, False, False,  True])
+
+    """
+
+    def _flatmask(mask):
+        "Flatten the mask and returns a (maybe nested) sequence of booleans."
+        mnames = mask.dtype.names
+        if mnames is not None:
+            return [flatten_mask(mask[name]) for name in mnames]
+        else:
+            return mask
+
+    def _flatsequence(sequence):
+        "Generates a flattened version of the sequence."
+        try:
+            for element in sequence:
+                if hasattr(element, '__iter__'):
+                    yield from _flatsequence(element)
+                else:
+                    yield element
+        except TypeError:
+            yield sequence
+
+    mask = np.asarray(mask)
+    flattened = _flatsequence(_flatmask(mask))
+    return np.array([_ for _ in flattened], dtype=bool)
+
+
+def _check_mask_axis(mask, axis, keepdims=np._NoValue):
+    "Check whether there are masked values along the given axis"
+    kwargs = {} if keepdims is np._NoValue else {'keepdims': keepdims}
+    if mask is not nomask:
+        return mask.all(axis=axis, **kwargs)
+    return nomask
+
+
+###############################################################################
+#                             Masking functions                               #
+###############################################################################
+
+def masked_where(condition, a, copy=True):
+    """
+    Mask an array where a condition is met.
+
+    Return `a` as an array masked where `condition` is True.
+    Any masked values of `a` or `condition` are also masked in the output.
+
+    Parameters
+    ----------
+    condition : array_like
+        Masking condition.  When `condition` tests floating point values for
+        equality, consider using ``masked_values`` instead.
+    a : array_like
+        Array to mask.
+    copy : bool
+        If True (default) make a copy of `a` in the result.  If False modify
+        `a` in place and return a view.
+
+    Returns
+    -------
+    result : MaskedArray
+        The result of masking `a` where `condition` is True.
+
+    See Also
+    --------
+    masked_values : Mask using floating point equality.
+    masked_equal : Mask where equal to a given value.
+    masked_not_equal : Mask where *not* equal to a given value.
+    masked_less_equal : Mask where less than or equal to a given value.
+    masked_greater_equal : Mask where greater than or equal to a given value.
+    masked_less : Mask where less than a given value.
+    masked_greater : Mask where greater than a given value.
+    masked_inside : Mask inside a given interval.
+    masked_outside : Mask outside a given interval.
+    masked_invalid : Mask invalid values (NaNs or infs).
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> import numpy.ma as ma
+    >>> a = np.arange(4)
+    >>> a
+    array([0, 1, 2, 3])
+    >>> ma.masked_where(a <= 2, a)
+    masked_array(data=[--, --, --, 3],
+                 mask=[ True,  True,  True, False],
+           fill_value=999999)
+
+    Mask array `b` conditional on `a`.
+
+    >>> b = ['a', 'b', 'c', 'd']
+    >>> ma.masked_where(a == 2, b)
+    masked_array(data=['a', 'b', --, 'd'],
+                 mask=[False, False,  True, False],
+           fill_value='N/A',
+                dtype='>> c = ma.masked_where(a <= 2, a)
+    >>> c
+    masked_array(data=[--, --, --, 3],
+                 mask=[ True,  True,  True, False],
+           fill_value=999999)
+    >>> c[0] = 99
+    >>> c
+    masked_array(data=[99, --, --, 3],
+                 mask=[False,  True,  True, False],
+           fill_value=999999)
+    >>> a
+    array([0, 1, 2, 3])
+    >>> c = ma.masked_where(a <= 2, a, copy=False)
+    >>> c[0] = 99
+    >>> c
+    masked_array(data=[99, --, --, 3],
+                 mask=[False,  True,  True, False],
+           fill_value=999999)
+    >>> a
+    array([99,  1,  2,  3])
+
+    When `condition` or `a` contain masked values.
+
+    >>> a = np.arange(4)
+    >>> a = ma.masked_where(a == 2, a)
+    >>> a
+    masked_array(data=[0, 1, --, 3],
+                 mask=[False, False,  True, False],
+           fill_value=999999)
+    >>> b = np.arange(4)
+    >>> b = ma.masked_where(b == 0, b)
+    >>> b
+    masked_array(data=[--, 1, 2, 3],
+                 mask=[ True, False, False, False],
+           fill_value=999999)
+    >>> ma.masked_where(a == 3, b)
+    masked_array(data=[--, 1, --, --],
+                 mask=[ True, False,  True,  True],
+           fill_value=999999)
+
+    """
+    # Make sure that condition is a valid standard-type mask.
+    cond = make_mask(condition, shrink=False)
+    a = np.array(a, copy=copy, subok=True)
+
+    (cshape, ashape) = (cond.shape, a.shape)
+    if cshape and cshape != ashape:
+        raise IndexError("Inconsistent shape between the condition and the input"
+                         " (got %s and %s)" % (cshape, ashape))
+    if hasattr(a, '_mask'):
+        cond = mask_or(cond, a._mask)
+        cls = type(a)
+    else:
+        cls = MaskedArray
+    result = a.view(cls)
+    # Assign to *.mask so that structured masks are handled correctly.
+    result.mask = _shrink_mask(cond)
+    # There is no view of a boolean so when 'a' is a MaskedArray with nomask
+    # the update to the result's mask has no effect.
+    if not copy and hasattr(a, '_mask') and getmask(a) is nomask:
+        a._mask = result._mask.view()
+    return result
+
+
+def masked_greater(x, value, copy=True):
+    """
+    Mask an array where greater than a given value.
+
+    This function is a shortcut to ``masked_where``, with
+    `condition` = (x > value).
+
+    See Also
+    --------
+    masked_where : Mask where a condition is met.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> import numpy.ma as ma
+    >>> a = np.arange(4)
+    >>> a
+    array([0, 1, 2, 3])
+    >>> ma.masked_greater(a, 2)
+    masked_array(data=[0, 1, 2, --],
+                 mask=[False, False, False,  True],
+           fill_value=999999)
+
+    """
+    return masked_where(greater(x, value), x, copy=copy)
+
+
+def masked_greater_equal(x, value, copy=True):
+    """
+    Mask an array where greater than or equal to a given value.
+
+    This function is a shortcut to ``masked_where``, with
+    `condition` = (x >= value).
+
+    See Also
+    --------
+    masked_where : Mask where a condition is met.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> import numpy.ma as ma
+    >>> a = np.arange(4)
+    >>> a
+    array([0, 1, 2, 3])
+    >>> ma.masked_greater_equal(a, 2)
+    masked_array(data=[0, 1, --, --],
+                 mask=[False, False,  True,  True],
+           fill_value=999999)
+
+    """
+    return masked_where(greater_equal(x, value), x, copy=copy)
+
+
+def masked_less(x, value, copy=True):
+    """
+    Mask an array where less than a given value.
+
+    This function is a shortcut to ``masked_where``, with
+    `condition` = (x < value).
+
+    See Also
+    --------
+    masked_where : Mask where a condition is met.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> import numpy.ma as ma
+    >>> a = np.arange(4)
+    >>> a
+    array([0, 1, 2, 3])
+    >>> ma.masked_less(a, 2)
+    masked_array(data=[--, --, 2, 3],
+                 mask=[ True,  True, False, False],
+           fill_value=999999)
+
+    """
+    return masked_where(less(x, value), x, copy=copy)
+
+
+def masked_less_equal(x, value, copy=True):
+    """
+    Mask an array where less than or equal to a given value.
+
+    This function is a shortcut to ``masked_where``, with
+    `condition` = (x <= value).
+
+    See Also
+    --------
+    masked_where : Mask where a condition is met.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> import numpy.ma as ma
+    >>> a = np.arange(4)
+    >>> a
+    array([0, 1, 2, 3])
+    >>> ma.masked_less_equal(a, 2)
+    masked_array(data=[--, --, --, 3],
+                 mask=[ True,  True,  True, False],
+           fill_value=999999)
+
+    """
+    return masked_where(less_equal(x, value), x, copy=copy)
+
+
+def masked_not_equal(x, value, copy=True):
+    """
+    Mask an array where *not* equal to a given value.
+
+    This function is a shortcut to ``masked_where``, with
+    `condition` = (x != value).
+
+    See Also
+    --------
+    masked_where : Mask where a condition is met.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> import numpy.ma as ma
+    >>> a = np.arange(4)
+    >>> a
+    array([0, 1, 2, 3])
+    >>> ma.masked_not_equal(a, 2)
+    masked_array(data=[--, --, 2, --],
+                 mask=[ True,  True, False,  True],
+           fill_value=999999)
+
+    """
+    return masked_where(not_equal(x, value), x, copy=copy)
+
+
+def masked_equal(x, value, copy=True):
+    """
+    Mask an array where equal to a given value.
+
+    Return a MaskedArray, masked where the data in array `x` are
+    equal to `value`. The fill_value of the returned MaskedArray
+    is set to `value`.
+
+    For floating point arrays, consider using ``masked_values(x, value)``.
+
+    See Also
+    --------
+    masked_where : Mask where a condition is met.
+    masked_values : Mask using floating point equality.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> import numpy.ma as ma
+    >>> a = np.arange(4)
+    >>> a
+    array([0, 1, 2, 3])
+    >>> ma.masked_equal(a, 2)
+    masked_array(data=[0, 1, --, 3],
+                 mask=[False, False,  True, False],
+           fill_value=2)
+
+    """
+    output = masked_where(equal(x, value), x, copy=copy)
+    output.fill_value = value
+    return output
+
+
+def masked_inside(x, v1, v2, copy=True):
+    """
+    Mask an array inside a given interval.
+
+    Shortcut to ``masked_where``, where `condition` is True for `x` inside
+    the interval [v1,v2] (v1 <= x <= v2).  The boundaries `v1` and `v2`
+    can be given in either order.
+
+    See Also
+    --------
+    masked_where : Mask where a condition is met.
+
+    Notes
+    -----
+    The array `x` is prefilled with its filling value.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> import numpy.ma as ma
+    >>> x = [0.31, 1.2, 0.01, 0.2, -0.4, -1.1]
+    >>> ma.masked_inside(x, -0.3, 0.3)
+    masked_array(data=[0.31, 1.2, --, --, -0.4, -1.1],
+                 mask=[False, False,  True,  True, False, False],
+           fill_value=1e+20)
+
+    The order of `v1` and `v2` doesn't matter.
+
+    >>> ma.masked_inside(x, 0.3, -0.3)
+    masked_array(data=[0.31, 1.2, --, --, -0.4, -1.1],
+                 mask=[False, False,  True,  True, False, False],
+           fill_value=1e+20)
+
+    """
+    if v2 < v1:
+        (v1, v2) = (v2, v1)
+    xf = filled(x)
+    condition = (xf >= v1) & (xf <= v2)
+    return masked_where(condition, x, copy=copy)
+
+
+def masked_outside(x, v1, v2, copy=True):
+    """
+    Mask an array outside a given interval.
+
+    Shortcut to ``masked_where``, where `condition` is True for `x` outside
+    the interval [v1,v2] (x < v1)|(x > v2).
+    The boundaries `v1` and `v2` can be given in either order.
+
+    See Also
+    --------
+    masked_where : Mask where a condition is met.
+
+    Notes
+    -----
+    The array `x` is prefilled with its filling value.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> import numpy.ma as ma
+    >>> x = [0.31, 1.2, 0.01, 0.2, -0.4, -1.1]
+    >>> ma.masked_outside(x, -0.3, 0.3)
+    masked_array(data=[--, --, 0.01, 0.2, --, --],
+                 mask=[ True,  True, False, False,  True,  True],
+           fill_value=1e+20)
+
+    The order of `v1` and `v2` doesn't matter.
+
+    >>> ma.masked_outside(x, 0.3, -0.3)
+    masked_array(data=[--, --, 0.01, 0.2, --, --],
+                 mask=[ True,  True, False, False,  True,  True],
+           fill_value=1e+20)
+
+    """
+    if v2 < v1:
+        (v1, v2) = (v2, v1)
+    xf = filled(x)
+    condition = (xf < v1) | (xf > v2)
+    return masked_where(condition, x, copy=copy)
+
+
+def masked_object(x, value, copy=True, shrink=True):
+    """
+    Mask the array `x` where the data are exactly equal to value.
+
+    This function is similar to `masked_values`, but only suitable
+    for object arrays: for floating point, use `masked_values` instead.
+
+    Parameters
+    ----------
+    x : array_like
+        Array to mask
+    value : object
+        Comparison value
+    copy : {True, False}, optional
+        Whether to return a copy of `x`.
+    shrink : {True, False}, optional
+        Whether to collapse a mask full of False to nomask
+
+    Returns
+    -------
+    result : MaskedArray
+        The result of masking `x` where equal to `value`.
+
+    See Also
+    --------
+    masked_where : Mask where a condition is met.
+    masked_equal : Mask where equal to a given value (integers).
+    masked_values : Mask using floating point equality.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> import numpy.ma as ma
+    >>> food = np.array(['green_eggs', 'ham'], dtype=object)
+    >>> # don't eat spoiled food
+    >>> eat = ma.masked_object(food, 'green_eggs')
+    >>> eat
+    masked_array(data=[--, 'ham'],
+                 mask=[ True, False],
+           fill_value='green_eggs',
+                dtype=object)
+    >>> # plain ol` ham is boring
+    >>> fresh_food = np.array(['cheese', 'ham', 'pineapple'], dtype=object)
+    >>> eat = ma.masked_object(fresh_food, 'green_eggs')
+    >>> eat
+    masked_array(data=['cheese', 'ham', 'pineapple'],
+                 mask=False,
+           fill_value='green_eggs',
+                dtype=object)
+
+    Note that `mask` is set to ``nomask`` if possible.
+
+    >>> eat
+    masked_array(data=['cheese', 'ham', 'pineapple'],
+                 mask=False,
+           fill_value='green_eggs',
+                dtype=object)
+
+    """
+    if isMaskedArray(x):
+        condition = umath.equal(x._data, value)
+        mask = x._mask
+    else:
+        condition = umath.equal(np.asarray(x), value)
+        mask = nomask
+    mask = mask_or(mask, make_mask(condition, shrink=shrink))
+    return masked_array(x, mask=mask, copy=copy, fill_value=value)
+
+
+def masked_values(x, value, rtol=1e-5, atol=1e-8, copy=True, shrink=True):
+    """
+    Mask using floating point equality.
+
+    Return a MaskedArray, masked where the data in array `x` are approximately
+    equal to `value`, determined using `isclose`. The default tolerances for
+    `masked_values` are the same as those for `isclose`.
+
+    For integer types, exact equality is used, in the same way as
+    `masked_equal`.
+
+    The fill_value is set to `value` and the mask is set to ``nomask`` if
+    possible.
+
+    Parameters
+    ----------
+    x : array_like
+        Array to mask.
+    value : float
+        Masking value.
+    rtol, atol : float, optional
+        Tolerance parameters passed on to `isclose`
+    copy : bool, optional
+        Whether to return a copy of `x`.
+    shrink : bool, optional
+        Whether to collapse a mask full of False to ``nomask``.
+
+    Returns
+    -------
+    result : MaskedArray
+        The result of masking `x` where approximately equal to `value`.
+
+    See Also
+    --------
+    masked_where : Mask where a condition is met.
+    masked_equal : Mask where equal to a given value (integers).
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> import numpy.ma as ma
+    >>> x = np.array([1, 1.1, 2, 1.1, 3])
+    >>> ma.masked_values(x, 1.1)
+    masked_array(data=[1.0, --, 2.0, --, 3.0],
+                 mask=[False,  True, False,  True, False],
+           fill_value=1.1)
+
+    Note that `mask` is set to ``nomask`` if possible.
+
+    >>> ma.masked_values(x, 2.1)
+    masked_array(data=[1. , 1.1, 2. , 1.1, 3. ],
+                 mask=False,
+           fill_value=2.1)
+
+    Unlike `masked_equal`, `masked_values` can perform approximate equalities.
+
+    >>> ma.masked_values(x, 2.1, atol=1e-1)
+    masked_array(data=[1.0, 1.1, --, 1.1, 3.0],
+                 mask=[False, False,  True, False, False],
+           fill_value=2.1)
+
+    """
+    xnew = filled(x, value)
+    if np.issubdtype(xnew.dtype, np.floating):
+        mask = np.isclose(xnew, value, atol=atol, rtol=rtol)
+    else:
+        mask = umath.equal(xnew, value)
+    ret = masked_array(xnew, mask=mask, copy=copy, fill_value=value)
+    if shrink:
+        ret.shrink_mask()
+    return ret
+
+
+def masked_invalid(a, copy=True):
+    """
+    Mask an array where invalid values occur (NaNs or infs).
+
+    This function is a shortcut to ``masked_where``, with
+    `condition` = ~(np.isfinite(a)). Any pre-existing mask is conserved.
+    Only applies to arrays with a dtype where NaNs or infs make sense
+    (i.e. floating point types), but accepts any array_like object.
+
+    See Also
+    --------
+    masked_where : Mask where a condition is met.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> import numpy.ma as ma
+    >>> a = np.arange(5, dtype=float)
+    >>> a[2] = np.nan
+    >>> a[3] = np.inf
+    >>> a
+    array([ 0.,  1., nan, inf,  4.])
+    >>> ma.masked_invalid(a)
+    masked_array(data=[0.0, 1.0, --, --, 4.0],
+                 mask=[False, False,  True,  True, False],
+           fill_value=1e+20)
+
+    """
+    a = np.array(a, copy=None, subok=True)
+    res = masked_where(~(np.isfinite(a)), a, copy=copy)
+    # masked_invalid previously never returned nomask as a mask and doing so
+    # threw off matplotlib (gh-22842).  So use shrink=False:
+    if res._mask is nomask:
+        res._mask = make_mask_none(res.shape, res.dtype)
+    return res
+
+###############################################################################
+#                            Printing options                                 #
+###############################################################################
+
+
+class _MaskedPrintOption:
+    """
+    Handle the string used to represent missing data in a masked array.
+
+    """
+
+    def __init__(self, display):
+        """
+        Create the masked_print_option object.
+
+        """
+        self._display = display
+        self._enabled = True
+
+    def display(self):
+        """
+        Display the string to print for masked values.
+
+        """
+        return self._display
+
+    def set_display(self, s):
+        """
+        Set the string to print for masked values.
+
+        """
+        self._display = s
+
+    def enabled(self):
+        """
+        Is the use of the display value enabled?
+
+        """
+        return self._enabled
+
+    def enable(self, shrink=1):
+        """
+        Set the enabling shrink to `shrink`.
+
+        """
+        self._enabled = shrink
+
+    def __str__(self):
+        return str(self._display)
+
+    __repr__ = __str__
+
+# if you single index into a masked location you get this object.
+masked_print_option = _MaskedPrintOption('--')
+
+
+def _recursive_printoption(result, mask, printopt):
+    """
+    Puts printoptions in result where mask is True.
+
+    Private function allowing for recursion
+
+    """
+    names = result.dtype.names
+    if names is not None:
+        for name in names:
+            curdata = result[name]
+            curmask = mask[name]
+            _recursive_printoption(curdata, curmask, printopt)
+    else:
+        np.copyto(result, printopt, where=mask)
+    return
+
+# For better or worse, these end in a newline
+_legacy_print_templates = dict(
+    long_std=textwrap.dedent("""\
+        masked_%(name)s(data =
+         %(data)s,
+        %(nlen)s        mask =
+         %(mask)s,
+        %(nlen)s  fill_value = %(fill)s)
+        """),
+    long_flx=textwrap.dedent("""\
+        masked_%(name)s(data =
+         %(data)s,
+        %(nlen)s        mask =
+         %(mask)s,
+        %(nlen)s  fill_value = %(fill)s,
+        %(nlen)s       dtype = %(dtype)s)
+        """),
+    short_std=textwrap.dedent("""\
+        masked_%(name)s(data = %(data)s,
+        %(nlen)s        mask = %(mask)s,
+        %(nlen)s  fill_value = %(fill)s)
+        """),
+    short_flx=textwrap.dedent("""\
+        masked_%(name)s(data = %(data)s,
+        %(nlen)s        mask = %(mask)s,
+        %(nlen)s  fill_value = %(fill)s,
+        %(nlen)s       dtype = %(dtype)s)
+        """)
+)
+
+###############################################################################
+#                          MaskedArray class                                  #
+###############################################################################
+
+
+def _recursive_filled(a, mask, fill_value):
+    """
+    Recursively fill `a` with `fill_value`.
+
+    """
+    names = a.dtype.names
+    for name in names:
+        current = a[name]
+        if current.dtype.names is not None:
+            _recursive_filled(current, mask[name], fill_value[name])
+        else:
+            np.copyto(current, fill_value[name], where=mask[name])
+
+
+def flatten_structured_array(a):
+    """
+    Flatten a structured array.
+
+    The data type of the output is chosen such that it can represent all of the
+    (nested) fields.
+
+    Parameters
+    ----------
+    a : structured array
+
+    Returns
+    -------
+    output : masked array or ndarray
+        A flattened masked array if the input is a masked array, otherwise a
+        standard ndarray.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> ndtype = [('a', int), ('b', float)]
+    >>> a = np.array([(1, 1), (2, 2)], dtype=ndtype)
+    >>> np.ma.flatten_structured_array(a)
+    array([[1., 1.],
+           [2., 2.]])
+
+    """
+
+    def flatten_sequence(iterable):
+        """
+        Flattens a compound of nested iterables.
+
+        """
+        for elm in iter(iterable):
+            if hasattr(elm, '__iter__'):
+                yield from flatten_sequence(elm)
+            else:
+                yield elm
+
+    a = np.asanyarray(a)
+    inishape = a.shape
+    a = a.ravel()
+    if isinstance(a, MaskedArray):
+        out = np.array([tuple(flatten_sequence(d.item())) for d in a._data])
+        out = out.view(MaskedArray)
+        out._mask = np.array([tuple(flatten_sequence(d.item()))
+                              for d in getmaskarray(a)])
+    else:
+        out = np.array([tuple(flatten_sequence(d.item())) for d in a])
+    if len(inishape) > 1:
+        newshape = list(out.shape)
+        newshape[0] = inishape
+        out.shape = tuple(flatten_sequence(newshape))
+    return out
+
+
+def _arraymethod(funcname, onmask=True):
+    """
+    Return a class method wrapper around a basic array method.
+
+    Creates a class method which returns a masked array, where the new
+    ``_data`` array is the output of the corresponding basic method called
+    on the original ``_data``.
+
+    If `onmask` is True, the new mask is the output of the method called
+    on the initial mask. Otherwise, the new mask is just a reference
+    to the initial mask.
+
+    Parameters
+    ----------
+    funcname : str
+        Name of the function to apply on data.
+    onmask : bool
+        Whether the mask must be processed also (True) or left
+        alone (False). Default is True. Make available as `_onmask`
+        attribute.
+
+    Returns
+    -------
+    method : instancemethod
+        Class method wrapper of the specified basic array method.
+
+    """
+    def wrapped_method(self, *args, **params):
+        result = getattr(self._data, funcname)(*args, **params)
+        result = result.view(type(self))
+        result._update_from(self)
+        mask = self._mask
+        if not onmask:
+            result.__setmask__(mask)
+        elif mask is not nomask:
+            # __setmask__ makes a copy, which we don't want
+            result._mask = getattr(mask, funcname)(*args, **params)
+        return result
+    methdoc = getattr(ndarray, funcname, None) or getattr(np, funcname, None)
+    if methdoc is not None:
+        wrapped_method.__doc__ = methdoc.__doc__
+    wrapped_method.__name__ = funcname
+    return wrapped_method
+
+
+class MaskedIterator:
+    """
+    Flat iterator object to iterate over masked arrays.
+
+    A `MaskedIterator` iterator is returned by ``x.flat`` for any masked array
+    `x`. It allows iterating over the array as if it were a 1-D array,
+    either in a for-loop or by calling its `next` method.
+
+    Iteration is done in C-contiguous style, with the last index varying the
+    fastest. The iterator can also be indexed using basic slicing or
+    advanced indexing.
+
+    See Also
+    --------
+    MaskedArray.flat : Return a flat iterator over an array.
+    MaskedArray.flatten : Returns a flattened copy of an array.
+
+    Notes
+    -----
+    `MaskedIterator` is not exported by the `ma` module. Instead of
+    instantiating a `MaskedIterator` directly, use `MaskedArray.flat`.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> x = np.ma.array(arange(6).reshape(2, 3))
+    >>> fl = x.flat
+    >>> type(fl)
+    
+    >>> for item in fl:
+    ...     print(item)
+    ...
+    0
+    1
+    2
+    3
+    4
+    5
+
+    Extracting more than a single element b indexing the `MaskedIterator`
+    returns a masked array:
+
+    >>> fl[2:4]
+    masked_array(data = [2 3],
+                 mask = False,
+           fill_value = 999999)
+
+    """
+
+    def __init__(self, ma):
+        self.ma = ma
+        self.dataiter = ma._data.flat
+
+        if ma._mask is nomask:
+            self.maskiter = None
+        else:
+            self.maskiter = ma._mask.flat
+
+    def __iter__(self):
+        return self
+
+    def __getitem__(self, indx):
+        result = self.dataiter.__getitem__(indx).view(type(self.ma))
+        if self.maskiter is not None:
+            _mask = self.maskiter.__getitem__(indx)
+            if isinstance(_mask, ndarray):
+                # set shape to match that of data; this is needed for matrices
+                _mask.shape = result.shape
+                result._mask = _mask
+            elif isinstance(_mask, np.void):
+                return mvoid(result, mask=_mask, hardmask=self.ma._hardmask)
+            elif _mask:  # Just a scalar, masked
+                return masked
+        return result
+
+    # This won't work if ravel makes a copy
+    def __setitem__(self, index, value):
+        self.dataiter[index] = getdata(value)
+        if self.maskiter is not None:
+            self.maskiter[index] = getmaskarray(value)
+
+    def __next__(self):
+        """
+        Return the next value, or raise StopIteration.
+
+        Examples
+        --------
+        >>> import numpy as np
+        >>> x = np.ma.array([3, 2], mask=[0, 1])
+        >>> fl = x.flat
+        >>> next(fl)
+        3
+        >>> next(fl)
+        masked
+        >>> next(fl)
+        Traceback (most recent call last):
+          ...
+        StopIteration
+
+        """
+        d = next(self.dataiter)
+        if self.maskiter is not None:
+            m = next(self.maskiter)
+            if isinstance(m, np.void):
+                return mvoid(d, mask=m, hardmask=self.ma._hardmask)
+            elif m:  # Just a scalar, masked
+                return masked
+        return d
+
+
+@set_module("numpy.ma")
+class MaskedArray(ndarray):
+    """
+    An array class with possibly masked values.
+
+    Masked values of True exclude the corresponding element from any
+    computation.
+
+    Construction::
+
+      x = MaskedArray(data, mask=nomask, dtype=None, copy=False, subok=True,
+                      ndmin=0, fill_value=None, keep_mask=True, hard_mask=None,
+                      shrink=True, order=None)
+
+    Parameters
+    ----------
+    data : array_like
+        Input data.
+    mask : sequence, optional
+        Mask. Must be convertible to an array of booleans with the same
+        shape as `data`. True indicates a masked (i.e. invalid) data.
+    dtype : dtype, optional
+        Data type of the output.
+        If `dtype` is None, the type of the data argument (``data.dtype``)
+        is used. If `dtype` is not None and different from ``data.dtype``,
+        a copy is performed.
+    copy : bool, optional
+        Whether to copy the input data (True), or to use a reference instead.
+        Default is False.
+    subok : bool, optional
+        Whether to return a subclass of `MaskedArray` if possible (True) or a
+        plain `MaskedArray`. Default is True.
+    ndmin : int, optional
+        Minimum number of dimensions. Default is 0.
+    fill_value : scalar, optional
+        Value used to fill in the masked values when necessary.
+        If None, a default based on the data-type is used.
+    keep_mask : bool, optional
+        Whether to combine `mask` with the mask of the input data, if any
+        (True), or to use only `mask` for the output (False). Default is True.
+    hard_mask : bool, optional
+        Whether to use a hard mask or not. With a hard mask, masked values
+        cannot be unmasked. Default is False.
+    shrink : bool, optional
+        Whether to force compression of an empty mask. Default is True.
+    order : {'C', 'F', 'A'}, optional
+        Specify the order of the array.  If order is 'C', then the array
+        will be in C-contiguous order (last-index varies the fastest).
+        If order is 'F', then the returned array will be in
+        Fortran-contiguous order (first-index varies the fastest).
+        If order is 'A' (default), then the returned array may be
+        in any order (either C-, Fortran-contiguous, or even discontiguous),
+        unless a copy is required, in which case it will be C-contiguous.
+
+    Examples
+    --------
+    >>> import numpy as np
+
+    The ``mask`` can be initialized with an array of boolean values
+    with the same shape as ``data``.
+
+    >>> data = np.arange(6).reshape((2, 3))
+    >>> np.ma.MaskedArray(data, mask=[[False, True, False],
+    ...                               [False, False, True]])
+    masked_array(
+      data=[[0, --, 2],
+            [3, 4, --]],
+      mask=[[False,  True, False],
+            [False, False,  True]],
+      fill_value=999999)
+
+    Alternatively, the ``mask`` can be initialized to homogeneous boolean
+    array with the same shape as ``data`` by passing in a scalar
+    boolean value:
+
+    >>> np.ma.MaskedArray(data, mask=False)
+    masked_array(
+      data=[[0, 1, 2],
+            [3, 4, 5]],
+      mask=[[False, False, False],
+            [False, False, False]],
+      fill_value=999999)
+
+    >>> np.ma.MaskedArray(data, mask=True)
+    masked_array(
+      data=[[--, --, --],
+            [--, --, --]],
+      mask=[[ True,  True,  True],
+            [ True,  True,  True]],
+      fill_value=999999,
+      dtype=int64)
+
+    .. note::
+        The recommended practice for initializing ``mask`` with a scalar
+        boolean value is to use ``True``/``False`` rather than
+        ``np.True_``/``np.False_``. The reason is :attr:`nomask`
+        is represented internally as ``np.False_``.
+
+        >>> np.False_ is np.ma.nomask
+        True
+
+    """
+
+    __array_priority__ = 15
+    _defaultmask = nomask
+    _defaulthardmask = False
+    _baseclass = ndarray
+
+    # Maximum number of elements per axis used when printing an array. The
+    # 1d case is handled separately because we need more values in this case.
+    _print_width = 100
+    _print_width_1d = 1500
+
+    def __new__(cls, data=None, mask=nomask, dtype=None, copy=False,
+                subok=True, ndmin=0, fill_value=None, keep_mask=True,
+                hard_mask=None, shrink=True, order=None):
+        """
+        Create a new masked array from scratch.
+
+        Notes
+        -----
+        A masked array can also be created by taking a .view(MaskedArray).
+
+        """
+        # Process data.
+        copy = None if not copy else True
+        _data = np.array(data, dtype=dtype, copy=copy,
+                         order=order, subok=True, ndmin=ndmin)
+        _baseclass = getattr(data, '_baseclass', type(_data))
+        # Check that we're not erasing the mask.
+        if isinstance(data, MaskedArray) and (data.shape != _data.shape):
+            copy = True
+
+        # Here, we copy the _view_, so that we can attach new properties to it
+        # we must never do .view(MaskedConstant), as that would create a new
+        # instance of np.ma.masked, which make identity comparison fail
+        if isinstance(data, cls) and subok and not isinstance(data, MaskedConstant):
+            _data = ndarray.view(_data, type(data))
+        else:
+            _data = ndarray.view(_data, cls)
+
+        # Handle the case where data is not a subclass of ndarray, but
+        # still has the _mask attribute like MaskedArrays
+        if hasattr(data, '_mask') and not isinstance(data, ndarray):
+            _data._mask = data._mask
+            # FIXME: should we set `_data._sharedmask = True`?
+        # Process mask.
+        # Type of the mask
+        mdtype = make_mask_descr(_data.dtype)
+        if mask is nomask:
+            # Case 1. : no mask in input.
+            # Erase the current mask ?
+            if not keep_mask:
+                # With a reduced version
+                if shrink:
+                    _data._mask = nomask
+                # With full version
+                else:
+                    _data._mask = np.zeros(_data.shape, dtype=mdtype)
+            # Check whether we missed something
+            elif isinstance(data, (tuple, list)):
+                try:
+                    # If data is a sequence of masked array
+                    mask = np.array(
+                        [getmaskarray(np.asanyarray(m, dtype=_data.dtype))
+                         for m in data], dtype=mdtype)
+                except (ValueError, TypeError):
+                    # If data is nested
+                    mask = nomask
+                # Force shrinking of the mask if needed (and possible)
+                if (mdtype == MaskType) and mask.any():
+                    _data._mask = mask
+                    _data._sharedmask = False
+            else:
+                _data._sharedmask = not copy
+                if copy:
+                    _data._mask = _data._mask.copy()
+                    # Reset the shape of the original mask
+                    if getmask(data) is not nomask:
+                        # gh-21022 encounters an issue here
+                        # because data._mask.shape is not writeable, but
+                        # the op was also pointless in that case, because
+                        # the shapes were the same, so we can at least
+                        # avoid that path
+                        if data._mask.shape != data.shape:
+                            data._mask.shape = data.shape
+        else:
+            # Case 2. : With a mask in input.
+            # If mask is boolean, create an array of True or False
+
+            # if users pass `mask=None` be forgiving here and cast it False
+            # for speed; although the default is `mask=nomask` and can differ.
+            if mask is None:
+                mask = False
+
+            if mask is True and mdtype == MaskType:
+                mask = np.ones(_data.shape, dtype=mdtype)
+            elif mask is False and mdtype == MaskType:
+                mask = np.zeros(_data.shape, dtype=mdtype)
+            else:
+                # Read the mask with the current mdtype
+                try:
+                    mask = np.array(mask, copy=copy, dtype=mdtype)
+                # Or assume it's a sequence of bool/int
+                except TypeError:
+                    mask = np.array([tuple([m] * len(mdtype)) for m in mask],
+                                    dtype=mdtype)
+            # Make sure the mask and the data have the same shape
+            if mask.shape != _data.shape:
+                (nd, nm) = (_data.size, mask.size)
+                if nm == 1:
+                    mask = np.resize(mask, _data.shape)
+                elif nm == nd:
+                    mask = np.reshape(mask, _data.shape)
+                else:
+                    msg = "Mask and data not compatible: data size is %i, " + \
+                          "mask size is %i."
+                    raise MaskError(msg % (nd, nm))
+                copy = True
+            # Set the mask to the new value
+            if _data._mask is nomask:
+                _data._mask = mask
+                _data._sharedmask = not copy
+            else:
+                if not keep_mask:
+                    _data._mask = mask
+                    _data._sharedmask = not copy
+                else:
+                    if _data.dtype.names is not None:
+                        def _recursive_or(a, b):
+                            "do a|=b on each field of a, recursively"
+                            for name in a.dtype.names:
+                                (af, bf) = (a[name], b[name])
+                                if af.dtype.names is not None:
+                                    _recursive_or(af, bf)
+                                else:
+                                    af |= bf
+
+                        _recursive_or(_data._mask, mask)
+                    else:
+                        _data._mask = np.logical_or(mask, _data._mask)
+                    _data._sharedmask = False
+
+        # Update fill_value.
+        if fill_value is None:
+            fill_value = getattr(data, '_fill_value', None)
+        # But don't run the check unless we have something to check.
+        if fill_value is not None:
+            _data._fill_value = _check_fill_value(fill_value, _data.dtype)
+        # Process extra options ..
+        if hard_mask is None:
+            _data._hardmask = getattr(data, '_hardmask', False)
+        else:
+            _data._hardmask = hard_mask
+        _data._baseclass = _baseclass
+        return _data
+
+
+    def _update_from(self, obj):
+        """
+        Copies some attributes of obj to self.
+
+        """
+        if isinstance(obj, ndarray):
+            _baseclass = type(obj)
+        else:
+            _baseclass = ndarray
+        # We need to copy the _basedict to avoid backward propagation
+        _optinfo = {}
+        _optinfo.update(getattr(obj, '_optinfo', {}))
+        _optinfo.update(getattr(obj, '_basedict', {}))
+        if not isinstance(obj, MaskedArray):
+            _optinfo.update(getattr(obj, '__dict__', {}))
+        _dict = dict(_fill_value=getattr(obj, '_fill_value', None),
+                     _hardmask=getattr(obj, '_hardmask', False),
+                     _sharedmask=getattr(obj, '_sharedmask', False),
+                     _isfield=getattr(obj, '_isfield', False),
+                     _baseclass=getattr(obj, '_baseclass', _baseclass),
+                     _optinfo=_optinfo,
+                     _basedict=_optinfo)
+        self.__dict__.update(_dict)
+        self.__dict__.update(_optinfo)
+        return
+
+    def __array_finalize__(self, obj):
+        """
+        Finalizes the masked array.
+
+        """
+        # Get main attributes.
+        self._update_from(obj)
+
+        # We have to decide how to initialize self.mask, based on
+        # obj.mask. This is very difficult.  There might be some
+        # correspondence between the elements in the array we are being
+        # created from (= obj) and us. Or there might not. This method can
+        # be called in all kinds of places for all kinds of reasons -- could
+        # be empty_like, could be slicing, could be a ufunc, could be a view.
+        # The numpy subclassing interface simply doesn't give us any way
+        # to know, which means that at best this method will be based on
+        # guesswork and heuristics. To make things worse, there isn't even any
+        # clear consensus about what the desired behavior is. For instance,
+        # most users think that np.empty_like(marr) -- which goes via this
+        # method -- should return a masked array with an empty mask (see
+        # gh-3404 and linked discussions), but others disagree, and they have
+        # existing code which depends on empty_like returning an array that
+        # matches the input mask.
+        #
+        # Historically our algorithm was: if the template object mask had the
+        # same *number of elements* as us, then we used *it's mask object
+        # itself* as our mask, so that writes to us would also write to the
+        # original array. This is horribly broken in multiple ways.
+        #
+        # Now what we do instead is, if the template object mask has the same
+        # number of elements as us, and we do not have the same base pointer
+        # as the template object (b/c views like arr[...] should keep the same
+        # mask), then we make a copy of the template object mask and use
+        # that. This is also horribly broken but somewhat less so. Maybe.
+        if isinstance(obj, ndarray):
+            # XX: This looks like a bug -- shouldn't it check self.dtype
+            # instead?
+            if obj.dtype.names is not None:
+                _mask = getmaskarray(obj)
+            else:
+                _mask = getmask(obj)
+
+            # If self and obj point to exactly the same data, then probably
+            # self is a simple view of obj (e.g., self = obj[...]), so they
+            # should share the same mask. (This isn't 100% reliable, e.g. self
+            # could be the first row of obj, or have strange strides, but as a
+            # heuristic it's not bad.) In all other cases, we make a copy of
+            # the mask, so that future modifications to 'self' do not end up
+            # side-effecting 'obj' as well.
+            if (_mask is not nomask and obj.__array_interface__["data"][0]
+                    != self.__array_interface__["data"][0]):
+                # We should make a copy. But we could get here via astype,
+                # in which case the mask might need a new dtype as well
+                # (e.g., changing to or from a structured dtype), and the
+                # order could have changed. So, change the mask type if
+                # needed and use astype instead of copy.
+                if self.dtype == obj.dtype:
+                    _mask_dtype = _mask.dtype
+                else:
+                    _mask_dtype = make_mask_descr(self.dtype)
+
+                if self.flags.c_contiguous:
+                    order = "C"
+                elif self.flags.f_contiguous:
+                    order = "F"
+                else:
+                    order = "K"
+
+                _mask = _mask.astype(_mask_dtype, order)
+            else:
+                # Take a view so shape changes, etc., do not propagate back.
+                _mask = _mask.view()
+        else:
+            _mask = nomask
+
+        self._mask = _mask
+        # Finalize the mask
+        if self._mask is not nomask:
+            try:
+                self._mask.shape = self.shape
+            except ValueError:
+                self._mask = nomask
+            except (TypeError, AttributeError):
+                # When _mask.shape is not writable (because it's a void)
+                pass
+
+        # Finalize the fill_value
+        if self._fill_value is not None:
+            self._fill_value = _check_fill_value(self._fill_value, self.dtype)
+        elif self.dtype.names is not None:
+            # Finalize the default fill_value for structured arrays
+            self._fill_value = _check_fill_value(None, self.dtype)
+
+    def __array_wrap__(self, obj, context=None, return_scalar=False):
+        """
+        Special hook for ufuncs.
+
+        Wraps the numpy array and sets the mask according to context.
+
+        """
+        if obj is self:  # for in-place operations
+            result = obj
+        else:
+            result = obj.view(type(self))
+            result._update_from(self)
+
+        if context is not None:
+            result._mask = result._mask.copy()
+            func, args, out_i = context
+            # args sometimes contains outputs (gh-10459), which we don't want
+            input_args = args[:func.nin]
+            m = reduce(mask_or, [getmaskarray(arg) for arg in input_args])
+            # Get the domain mask
+            domain = ufunc_domain.get(func)
+            if domain is not None:
+                # Take the domain, and make sure it's a ndarray
+                with np.errstate(divide='ignore', invalid='ignore'):
+                    d = filled(domain(*input_args), True)
+
+                if d.any():
+                    # Fill the result where the domain is wrong
+                    try:
+                        # Binary domain: take the last value
+                        fill_value = ufunc_fills[func][-1]
+                    except TypeError:
+                        # Unary domain: just use this one
+                        fill_value = ufunc_fills[func]
+                    except KeyError:
+                        # Domain not recognized, use fill_value instead
+                        fill_value = self.fill_value
+
+                    np.copyto(result, fill_value, where=d)
+
+                    # Update the mask
+                    if m is nomask:
+                        m = d
+                    else:
+                        # Don't modify inplace, we risk back-propagation
+                        m = (m | d)
+
+            # Make sure the mask has the proper size
+            if result is not self and result.shape == () and m:
+                return masked
+            else:
+                result._mask = m
+                result._sharedmask = False
+
+        return result
+
+    def view(self, dtype=None, type=None, fill_value=None):
+        """
+        Return a view of the MaskedArray data.
+
+        Parameters
+        ----------
+        dtype : data-type or ndarray sub-class, optional
+            Data-type descriptor of the returned view, e.g., float32 or int16.
+            The default, None, results in the view having the same data-type
+            as `a`. As with ``ndarray.view``, dtype can also be specified as
+            an ndarray sub-class, which then specifies the type of the
+            returned object (this is equivalent to setting the ``type``
+            parameter).
+        type : Python type, optional
+            Type of the returned view, either ndarray or a subclass.  The
+            default None results in type preservation.
+        fill_value : scalar, optional
+            The value to use for invalid entries (None by default).
+            If None, then this argument is inferred from the passed `dtype`, or
+            in its absence the original array, as discussed in the notes below.
+
+        See Also
+        --------
+        numpy.ndarray.view : Equivalent method on ndarray object.
+
+        Notes
+        -----
+
+        ``a.view()`` is used two different ways:
+
+        ``a.view(some_dtype)`` or ``a.view(dtype=some_dtype)`` constructs a view
+        of the array's memory with a different data-type.  This can cause a
+        reinterpretation of the bytes of memory.
+
+        ``a.view(ndarray_subclass)`` or ``a.view(type=ndarray_subclass)`` just
+        returns an instance of `ndarray_subclass` that looks at the same array
+        (same shape, dtype, etc.)  This does not cause a reinterpretation of the
+        memory.
+
+        If `fill_value` is not specified, but `dtype` is specified (and is not
+        an ndarray sub-class), the `fill_value` of the MaskedArray will be
+        reset. If neither `fill_value` nor `dtype` are specified (or if
+        `dtype` is an ndarray sub-class), then the fill value is preserved.
+        Finally, if `fill_value` is specified, but `dtype` is not, the fill
+        value is set to the specified value.
+
+        For ``a.view(some_dtype)``, if ``some_dtype`` has a different number of
+        bytes per entry than the previous dtype (for example, converting a
+        regular array to a structured array), then the behavior of the view
+        cannot be predicted just from the superficial appearance of ``a`` (shown
+        by ``print(a)``). It also depends on exactly how ``a`` is stored in
+        memory. Therefore if ``a`` is C-ordered versus fortran-ordered, versus
+        defined as a slice or transpose, etc., the view may give different
+        results.
+        """
+
+        if dtype is None:
+            if type is None:
+                output = ndarray.view(self)
+            else:
+                output = ndarray.view(self, type)
+        elif type is None:
+            try:
+                if issubclass(dtype, ndarray):
+                    output = ndarray.view(self, dtype)
+                    dtype = None
+                else:
+                    output = ndarray.view(self, dtype)
+            except TypeError:
+                output = ndarray.view(self, dtype)
+        else:
+            output = ndarray.view(self, dtype, type)
+
+        # also make the mask be a view (so attr changes to the view's
+        # mask do no affect original object's mask)
+        # (especially important to avoid affecting np.masked singleton)
+        if getmask(output) is not nomask:
+            output._mask = output._mask.view()
+
+        # Make sure to reset the _fill_value if needed
+        if getattr(output, '_fill_value', None) is not None:
+            if fill_value is None:
+                if dtype is None:
+                    pass  # leave _fill_value as is
+                else:
+                    output._fill_value = None
+            else:
+                output.fill_value = fill_value
+        return output
+
+    def __getitem__(self, indx):
+        """
+        x.__getitem__(y) <==> x[y]
+
+        Return the item described by i, as a masked array.
+
+        """
+        # We could directly use ndarray.__getitem__ on self.
+        # But then we would have to modify __array_finalize__ to prevent the
+        # mask of being reshaped if it hasn't been set up properly yet
+        # So it's easier to stick to the current version
+        dout = self.data[indx]
+        _mask = self._mask
+
+        def _is_scalar(m):
+            return not isinstance(m, np.ndarray)
+
+        def _scalar_heuristic(arr, elem):
+            """
+            Return whether `elem` is a scalar result of indexing `arr`, or None
+            if undecidable without promoting nomask to a full mask
+            """
+            # obviously a scalar
+            if not isinstance(elem, np.ndarray):
+                return True
+
+            # object array scalar indexing can return anything
+            elif arr.dtype.type is np.object_:
+                if arr.dtype is not elem.dtype:
+                    # elem is an array, but dtypes do not match, so must be
+                    # an element
+                    return True
+
+            # well-behaved subclass that only returns 0d arrays when
+            # expected - this is not a scalar
+            elif type(arr).__getitem__ == ndarray.__getitem__:
+                return False
+
+            return None
+
+        if _mask is not nomask:
+            # _mask cannot be a subclass, so it tells us whether we should
+            # expect a scalar. It also cannot be of dtype object.
+            mout = _mask[indx]
+            scalar_expected = _is_scalar(mout)
+
+        else:
+            # attempt to apply the heuristic to avoid constructing a full mask
+            mout = nomask
+            scalar_expected = _scalar_heuristic(self.data, dout)
+            if scalar_expected is None:
+                # heuristics have failed
+                # construct a full array, so we can be certain. This is costly.
+                # we could also fall back on ndarray.__getitem__(self.data, indx)
+                scalar_expected = _is_scalar(getmaskarray(self)[indx])
+
+        # Did we extract a single item?
+        if scalar_expected:
+            # A record
+            if isinstance(dout, np.void):
+                # We should always re-cast to mvoid, otherwise users can
+                # change masks on rows that already have masked values, but not
+                # on rows that have no masked values, which is inconsistent.
+                return mvoid(dout, mask=mout, hardmask=self._hardmask)
+
+            # special case introduced in gh-5962
+            elif (self.dtype.type is np.object_ and
+                  isinstance(dout, np.ndarray) and
+                  dout is not masked):
+                # If masked, turn into a MaskedArray, with everything masked.
+                if mout:
+                    return MaskedArray(dout, mask=True)
+                else:
+                    return dout
+
+            # Just a scalar
+            else:
+                if mout:
+                    return masked
+                else:
+                    return dout
+        else:
+            # Force dout to MA
+            dout = dout.view(type(self))
+            # Inherit attributes from self
+            dout._update_from(self)
+            # Check the fill_value
+            if is_string_or_list_of_strings(indx):
+                if self._fill_value is not None:
+                    dout._fill_value = self._fill_value[indx]
+
+                    # Something like gh-15895 has happened if this check fails.
+                    # _fill_value should always be an ndarray.
+                    if not isinstance(dout._fill_value, np.ndarray):
+                        raise RuntimeError('Internal NumPy error.')
+                    # If we're indexing a multidimensional field in a
+                    # structured array (such as dtype("(2,)i2,(2,)i1")),
+                    # dimensionality goes up (M[field].ndim == M.ndim +
+                    # M.dtype[field].ndim).  That's fine for
+                    # M[field] but problematic for M[field].fill_value
+                    # which should have shape () to avoid breaking several
+                    # methods. There is no great way out, so set to
+                    # first element. See issue #6723.
+                    if dout._fill_value.ndim > 0:
+                        if not (dout._fill_value ==
+                                dout._fill_value.flat[0]).all():
+                            warnings.warn(
+                                "Upon accessing multidimensional field "
+                                f"{indx!s}, need to keep dimensionality "
+                                "of fill_value at 0. Discarding "
+                                "heterogeneous fill_value and setting "
+                                f"all to {dout._fill_value[0]!s}.",
+                                stacklevel=2)
+                        # Need to use `.flat[0:1].squeeze(...)` instead of just
+                        # `.flat[0]` to ensure the result is a 0d array and not
+                        # a scalar.
+                        dout._fill_value = dout._fill_value.flat[0:1].squeeze(axis=0)
+                dout._isfield = True
+            # Update the mask if needed
+            if mout is not nomask:
+                # set shape to match that of data; this is needed for matrices
+                dout._mask = reshape(mout, dout.shape)
+                dout._sharedmask = True
+                # Note: Don't try to check for m.any(), that'll take too long
+        return dout
+
+    # setitem may put NaNs into integer arrays or occasionally overflow a
+    # float.  But this may happen in masked values, so avoid otherwise
+    # correct warnings (as is typical also in masked calculations).
+    @np.errstate(over='ignore', invalid='ignore')
+    def __setitem__(self, indx, value):
+        """
+        x.__setitem__(i, y) <==> x[i]=y
+
+        Set item described by index. If value is masked, masks those
+        locations.
+
+        """
+        if self is masked:
+            raise MaskError('Cannot alter the masked element.')
+        _data = self._data
+        _mask = self._mask
+        if isinstance(indx, str):
+            _data[indx] = value
+            if _mask is nomask:
+                self._mask = _mask = make_mask_none(self.shape, self.dtype)
+            _mask[indx] = getmask(value)
+            return
+
+        _dtype = _data.dtype
+
+        if value is masked:
+            # The mask wasn't set: create a full version.
+            if _mask is nomask:
+                _mask = self._mask = make_mask_none(self.shape, _dtype)
+            # Now, set the mask to its value.
+            if _dtype.names is not None:
+                _mask[indx] = tuple([True] * len(_dtype.names))
+            else:
+                _mask[indx] = True
+            return
+
+        # Get the _data part of the new value
+        dval = getattr(value, '_data', value)
+        # Get the _mask part of the new value
+        mval = getmask(value)
+        if _dtype.names is not None and mval is nomask:
+            mval = tuple([False] * len(_dtype.names))
+        if _mask is nomask:
+            # Set the data, then the mask
+            _data[indx] = dval
+            if mval is not nomask:
+                _mask = self._mask = make_mask_none(self.shape, _dtype)
+                _mask[indx] = mval
+        elif not self._hardmask:
+            # Set the data, then the mask
+            if (isinstance(indx, masked_array) and
+                    not isinstance(value, masked_array)):
+                _data[indx.data] = dval
+            else:
+                _data[indx] = dval
+                _mask[indx] = mval
+        elif hasattr(indx, 'dtype') and (indx.dtype == MaskType):
+            indx = indx * umath.logical_not(_mask)
+            _data[indx] = dval
+        else:
+            if _dtype.names is not None:
+                err_msg = "Flexible 'hard' masks are not yet supported."
+                raise NotImplementedError(err_msg)
+            mindx = mask_or(_mask[indx], mval, copy=True)
+            dindx = self._data[indx]
+            if dindx.size > 1:
+                np.copyto(dindx, dval, where=~mindx)
+            elif mindx is nomask:
+                dindx = dval
+            _data[indx] = dindx
+            _mask[indx] = mindx
+        return
+
+    # Define so that we can overwrite the setter.
+    @property
+    def dtype(self):
+        return super().dtype
+
+    @dtype.setter
+    def dtype(self, dtype):
+        super(MaskedArray, type(self)).dtype.__set__(self, dtype)
+        if self._mask is not nomask:
+            self._mask = self._mask.view(make_mask_descr(dtype), ndarray)
+            # Try to reset the shape of the mask (if we don't have a void).
+            # This raises a ValueError if the dtype change won't work.
+            try:
+                self._mask.shape = self.shape
+            except (AttributeError, TypeError):
+                pass
+
+    @property
+    def shape(self):
+        return super().shape
+
+    @shape.setter
+    def shape(self, shape):
+        super(MaskedArray, type(self)).shape.__set__(self, shape)
+        # Cannot use self._mask, since it may not (yet) exist when a
+        # masked matrix sets the shape.
+        if getmask(self) is not nomask:
+            self._mask.shape = self.shape
+
+    def __setmask__(self, mask, copy=False):
+        """
+        Set the mask.
+
+        """
+        idtype = self.dtype
+        current_mask = self._mask
+        if mask is masked:
+            mask = True
+
+        if current_mask is nomask:
+            # Make sure the mask is set
+            # Just don't do anything if there's nothing to do.
+            if mask is nomask:
+                return
+            current_mask = self._mask = make_mask_none(self.shape, idtype)
+
+        if idtype.names is None:
+            # No named fields.
+            # Hardmask: don't unmask the data
+            if self._hardmask:
+                current_mask |= mask
+            # Softmask: set everything to False
+            # If it's obviously a compatible scalar, use a quick update
+            # method.
+            elif isinstance(mask, (int, float, np.bool, np.number)):
+                current_mask[...] = mask
+            # Otherwise fall back to the slower, general purpose way.
+            else:
+                current_mask.flat = mask
+        else:
+            # Named fields w/
+            mdtype = current_mask.dtype
+            mask = np.asarray(mask)
+            # Mask is a singleton
+            if not mask.ndim:
+                # It's a boolean : make a record
+                if mask.dtype.kind == 'b':
+                    mask = np.array(tuple([mask.item()] * len(mdtype)),
+                                    dtype=mdtype)
+                # It's a record: make sure the dtype is correct
+                else:
+                    mask = mask.astype(mdtype)
+            # Mask is a sequence
+            else:
+                # Make sure the new mask is a ndarray with the proper dtype
+                try:
+                    copy = None if not copy else True
+                    mask = np.array(mask, copy=copy, dtype=mdtype)
+                # Or assume it's a sequence of bool/int
+                except TypeError:
+                    mask = np.array([tuple([m] * len(mdtype)) for m in mask],
+                                    dtype=mdtype)
+            # Hardmask: don't unmask the data
+            if self._hardmask:
+                for n in idtype.names:
+                    current_mask[n] |= mask[n]
+            # Softmask: set everything to False
+            # If it's obviously a compatible scalar, use a quick update
+            # method.
+            elif isinstance(mask, (int, float, np.bool, np.number)):
+                current_mask[...] = mask
+            # Otherwise fall back to the slower, general purpose way.
+            else:
+                current_mask.flat = mask
+        # Reshape if needed
+        if current_mask.shape:
+            current_mask.shape = self.shape
+        return
+
+    _set_mask = __setmask__
+
+    @property
+    def mask(self):
+        """ Current mask. """
+
+        # We could try to force a reshape, but that wouldn't work in some
+        # cases.
+        # Return a view so that the dtype and shape cannot be changed in place
+        # This still preserves nomask by identity
+        return self._mask.view()
+
+    @mask.setter
+    def mask(self, value):
+        self.__setmask__(value)
+
+    @property
+    def recordmask(self):
+        """
+        Get or set the mask of the array if it has no named fields. For
+        structured arrays, returns a ndarray of booleans where entries are
+        ``True`` if **all** the fields are masked, ``False`` otherwise:
+
+        >>> x = np.ma.array([(1, 1), (2, 2), (3, 3), (4, 4), (5, 5)],
+        ...         mask=[(0, 0), (1, 0), (1, 1), (0, 1), (0, 0)],
+        ...        dtype=[('a', int), ('b', int)])
+        >>> x.recordmask
+        array([False, False,  True, False, False])
+        """
+
+        _mask = self._mask.view(ndarray)
+        if _mask.dtype.names is None:
+            return _mask
+        return np.all(flatten_structured_array(_mask), axis=-1)
+
+    @recordmask.setter
+    def recordmask(self, mask):
+        raise NotImplementedError("Coming soon: setting the mask per records!")
+
+    def harden_mask(self):
+        """
+        Force the mask to hard, preventing unmasking by assignment.
+
+        Whether the mask of a masked array is hard or soft is determined by
+        its `~ma.MaskedArray.hardmask` property. `harden_mask` sets
+        `~ma.MaskedArray.hardmask` to ``True`` (and returns the modified
+        self).
+
+        See Also
+        --------
+        ma.MaskedArray.hardmask
+        ma.MaskedArray.soften_mask
+
+        """
+        self._hardmask = True
+        return self
+
+    def soften_mask(self):
+        """
+        Force the mask to soft (default), allowing unmasking by assignment.
+
+        Whether the mask of a masked array is hard or soft is determined by
+        its `~ma.MaskedArray.hardmask` property. `soften_mask` sets
+        `~ma.MaskedArray.hardmask` to ``False`` (and returns the modified
+        self).
+
+        See Also
+        --------
+        ma.MaskedArray.hardmask
+        ma.MaskedArray.harden_mask
+
+        """
+        self._hardmask = False
+        return self
+
+    @property
+    def hardmask(self):
+        """
+        Specifies whether values can be unmasked through assignments.
+
+        By default, assigning definite values to masked array entries will
+        unmask them.  When `hardmask` is ``True``, the mask will not change
+        through assignments.
+
+        See Also
+        --------
+        ma.MaskedArray.harden_mask
+        ma.MaskedArray.soften_mask
+
+        Examples
+        --------
+        >>> import numpy as np
+        >>> x = np.arange(10)
+        >>> m = np.ma.masked_array(x, x>5)
+        >>> assert not m.hardmask
+
+        Since `m` has a soft mask, assigning an element value unmasks that
+        element:
+
+        >>> m[8] = 42
+        >>> m
+        masked_array(data=[0, 1, 2, 3, 4, 5, --, --, 42, --],
+                     mask=[False, False, False, False, False, False,
+                           True, True, False, True],
+               fill_value=999999)
+
+        After hardening, the mask is not affected by assignments:
+
+        >>> hardened = np.ma.harden_mask(m)
+        >>> assert m.hardmask and hardened is m
+        >>> m[:] = 23
+        >>> m
+        masked_array(data=[23, 23, 23, 23, 23, 23, --, --, 23, --],
+                     mask=[False, False, False, False, False, False,
+                           True, True, False, True],
+               fill_value=999999)
+
+        """
+        return self._hardmask
+
+    def unshare_mask(self):
+        """
+        Copy the mask and set the `sharedmask` flag to ``False``.
+
+        Whether the mask is shared between masked arrays can be seen from
+        the `sharedmask` property. `unshare_mask` ensures the mask is not
+        shared. A copy of the mask is only made if it was shared.
+
+        See Also
+        --------
+        sharedmask
+
+        """
+        if self._sharedmask:
+            self._mask = self._mask.copy()
+            self._sharedmask = False
+        return self
+
+    @property
+    def sharedmask(self):
+        """ Share status of the mask (read-only). """
+        return self._sharedmask
+
+    def shrink_mask(self):
+        """
+        Reduce a mask to nomask when possible.
+
+        Parameters
+        ----------
+        None
+
+        Returns
+        -------
+        None
+
+        Examples
+        --------
+        >>> import numpy as np
+        >>> x = np.ma.array([[1,2 ], [3, 4]], mask=[0]*4)
+        >>> x.mask
+        array([[False, False],
+               [False, False]])
+        >>> x.shrink_mask()
+        masked_array(
+          data=[[1, 2],
+                [3, 4]],
+          mask=False,
+          fill_value=999999)
+        >>> x.mask
+        False
+
+        """
+        self._mask = _shrink_mask(self._mask)
+        return self
+
+    @property
+    def baseclass(self):
+        """ Class of the underlying data (read-only). """
+        return self._baseclass
+
+    def _get_data(self):
+        """
+        Returns the underlying data, as a view of the masked array.
+
+        If the underlying data is a subclass of :class:`numpy.ndarray`, it is
+        returned as such.
+
+        >>> x = np.ma.array(np.matrix([[1, 2], [3, 4]]), mask=[[0, 1], [1, 0]])
+        >>> x.data
+        matrix([[1, 2],
+                [3, 4]])
+
+        The type of the data can be accessed through the :attr:`baseclass`
+        attribute.
+        """
+        return ndarray.view(self, self._baseclass)
+
+    _data = property(fget=_get_data)
+    data = property(fget=_get_data)
+
+    @property
+    def flat(self):
+        """ Return a flat iterator, or set a flattened version of self to value. """
+        return MaskedIterator(self)
+
+    @flat.setter
+    def flat(self, value):
+        y = self.ravel()
+        y[:] = value
+
+    @property
+    def fill_value(self):
+        """
+        The filling value of the masked array is a scalar. When setting, None
+        will set to a default based on the data type.
+
+        Examples
+        --------
+        >>> import numpy as np
+        >>> for dt in [np.int32, np.int64, np.float64, np.complex128]:
+        ...     np.ma.array([0, 1], dtype=dt).get_fill_value()
+        ...
+        np.int64(999999)
+        np.int64(999999)
+        np.float64(1e+20)
+        np.complex128(1e+20+0j)
+
+        >>> x = np.ma.array([0, 1.], fill_value=-np.inf)
+        >>> x.fill_value
+        np.float64(-inf)
+        >>> x.fill_value = np.pi
+        >>> x.fill_value
+        np.float64(3.1415926535897931)
+
+        Reset to default:
+
+        >>> x.fill_value = None
+        >>> x.fill_value
+        np.float64(1e+20)
+
+        """
+        if self._fill_value is None:
+            self._fill_value = _check_fill_value(None, self.dtype)
+
+        # Temporary workaround to account for the fact that str and bytes
+        # scalars cannot be indexed with (), whereas all other numpy
+        # scalars can. See issues #7259 and #7267.
+        # The if-block can be removed after #7267 has been fixed.
+        if isinstance(self._fill_value, ndarray):
+            return self._fill_value[()]
+        return self._fill_value
+
+    @fill_value.setter
+    def fill_value(self, value=None):
+        target = _check_fill_value(value, self.dtype)
+        if not target.ndim == 0:
+            # 2019-11-12, 1.18.0
+            warnings.warn(
+                "Non-scalar arrays for the fill value are deprecated. Use "
+                "arrays with scalar values instead. The filled function "
+                "still supports any array as `fill_value`.",
+                DeprecationWarning, stacklevel=2)
+
+        _fill_value = self._fill_value
+        if _fill_value is None:
+            # Create the attribute if it was undefined
+            self._fill_value = target
+        else:
+            # Don't overwrite the attribute, just fill it (for propagation)
+            _fill_value[()] = target
+
+    # kept for compatibility
+    get_fill_value = fill_value.fget
+    set_fill_value = fill_value.fset
+
+    def filled(self, fill_value=None):
+        """
+        Return a copy of self, with masked values filled with a given value.
+        **However**, if there are no masked values to fill, self will be
+        returned instead as an ndarray.
+
+        Parameters
+        ----------
+        fill_value : array_like, optional
+            The value to use for invalid entries. Can be scalar or non-scalar.
+            If non-scalar, the resulting ndarray must be broadcastable over
+            input array. Default is None, in which case, the `fill_value`
+            attribute of the array is used instead.
+
+        Returns
+        -------
+        filled_array : ndarray
+            A copy of ``self`` with invalid entries replaced by *fill_value*
+            (be it the function argument or the attribute of ``self``), or
+            ``self`` itself as an ndarray if there are no invalid entries to
+            be replaced.
+
+        Notes
+        -----
+        The result is **not** a MaskedArray!
+
+        Examples
+        --------
+        >>> import numpy as np
+        >>> x = np.ma.array([1,2,3,4,5], mask=[0,0,1,0,1], fill_value=-999)
+        >>> x.filled()
+        array([   1,    2, -999,    4, -999])
+        >>> x.filled(fill_value=1000)
+        array([   1,    2, 1000,    4, 1000])
+        >>> type(x.filled())
+        
+
+        Subclassing is preserved. This means that if, e.g., the data part of
+        the masked array is a recarray, `filled` returns a recarray:
+
+        >>> x = np.array([(-1, 2), (-3, 4)], dtype='i8,i8').view(np.recarray)
+        >>> m = np.ma.array(x, mask=[(True, False), (False, True)])
+        >>> m.filled()
+        rec.array([(999999,      2), (    -3, 999999)],
+                  dtype=[('f0', '>> import numpy as np
+        >>> x = np.ma.array(np.arange(5), mask=[0]*2 + [1]*3)
+        >>> x.compressed()
+        array([0, 1])
+        >>> type(x.compressed())
+        
+
+        N-D arrays are compressed to 1-D.
+
+        >>> arr = [[1, 2], [3, 4]]
+        >>> mask = [[1, 0], [0, 1]]
+        >>> x = np.ma.array(arr, mask=mask)
+        >>> x.compressed()
+        array([2, 3])
+
+        """
+        data = ndarray.ravel(self._data)
+        if self._mask is not nomask:
+            data = data.compress(np.logical_not(ndarray.ravel(self._mask)))
+        return data
+
+    def compress(self, condition, axis=None, out=None):
+        """
+        Return `a` where condition is ``True``.
+
+        If condition is a `~ma.MaskedArray`, missing values are considered
+        as ``False``.
+
+        Parameters
+        ----------
+        condition : var
+            Boolean 1-d array selecting which entries to return. If len(condition)
+            is less than the size of a along the axis, then output is truncated
+            to length of condition array.
+        axis : {None, int}, optional
+            Axis along which the operation must be performed.
+        out : {None, ndarray}, optional
+            Alternative output array in which to place the result. It must have
+            the same shape as the expected output but the type will be cast if
+            necessary.
+
+        Returns
+        -------
+        result : MaskedArray
+            A :class:`~ma.MaskedArray` object.
+
+        Notes
+        -----
+        Please note the difference with :meth:`compressed` !
+        The output of :meth:`compress` has a mask, the output of
+        :meth:`compressed` does not.
+
+        Examples
+        --------
+        >>> import numpy as np
+        >>> x = np.ma.array([[1,2,3],[4,5,6],[7,8,9]], mask=[0] + [1,0]*4)
+        >>> x
+        masked_array(
+          data=[[1, --, 3],
+                [--, 5, --],
+                [7, --, 9]],
+          mask=[[False,  True, False],
+                [ True, False,  True],
+                [False,  True, False]],
+          fill_value=999999)
+        >>> x.compress([1, 0, 1])
+        masked_array(data=[1, 3],
+                     mask=[False, False],
+               fill_value=999999)
+
+        >>> x.compress([1, 0, 1], axis=1)
+        masked_array(
+          data=[[1, 3],
+                [--, --],
+                [7, 9]],
+          mask=[[False, False],
+                [ True,  True],
+                [False, False]],
+          fill_value=999999)
+
+        """
+        # Get the basic components
+        (_data, _mask) = (self._data, self._mask)
+
+        # Force the condition to a regular ndarray and forget the missing
+        # values.
+        condition = np.asarray(condition)
+
+        _new = _data.compress(condition, axis=axis, out=out).view(type(self))
+        _new._update_from(self)
+        if _mask is not nomask:
+            _new._mask = _mask.compress(condition, axis=axis)
+        return _new
+
+    def _insert_masked_print(self):
+        """
+        Replace masked values with masked_print_option, casting all innermost
+        dtypes to object.
+        """
+        if masked_print_option.enabled():
+            mask = self._mask
+            if mask is nomask:
+                res = self._data
+            else:
+                # convert to object array to make filled work
+                data = self._data
+                # For big arrays, to avoid a costly conversion to the
+                # object dtype, extract the corners before the conversion.
+                print_width = (self._print_width if self.ndim > 1
+                               else self._print_width_1d)
+                for axis in range(self.ndim):
+                    if data.shape[axis] > print_width:
+                        ind = print_width // 2
+                        arr = np.split(data, (ind, -ind), axis=axis)
+                        data = np.concatenate((arr[0], arr[2]), axis=axis)
+                        arr = np.split(mask, (ind, -ind), axis=axis)
+                        mask = np.concatenate((arr[0], arr[2]), axis=axis)
+
+                rdtype = _replace_dtype_fields(self.dtype, "O")
+                res = data.astype(rdtype)
+                _recursive_printoption(res, mask, masked_print_option)
+        else:
+            res = self.filled(self.fill_value)
+        return res
+
+    def __str__(self):
+        return str(self._insert_masked_print())
+
+    def __repr__(self):
+        """
+        Literal string representation.
+
+        """
+        if self._baseclass is np.ndarray:
+            name = 'array'
+        else:
+            name = self._baseclass.__name__
+
+
+        # 2016-11-19: Demoted to legacy format
+        if np._core.arrayprint._get_legacy_print_mode() <= 113:
+            is_long = self.ndim > 1
+            parameters = dict(
+                name=name,
+                nlen=" " * len(name),
+                data=str(self),
+                mask=str(self._mask),
+                fill=str(self.fill_value),
+                dtype=str(self.dtype)
+            )
+            is_structured = bool(self.dtype.names)
+            key = '{}_{}'.format(
+                'long' if is_long else 'short',
+                'flx' if is_structured else 'std'
+            )
+            return _legacy_print_templates[key] % parameters
+
+        prefix = f"masked_{name}("
+
+        dtype_needed = (
+            not np._core.arrayprint.dtype_is_implied(self.dtype) or
+            np.all(self.mask) or
+            self.size == 0
+        )
+
+        # determine which keyword args need to be shown
+        keys = ['data', 'mask', 'fill_value']
+        if dtype_needed:
+            keys.append('dtype')
+
+        # array has only one row (non-column)
+        is_one_row = builtins.all(dim == 1 for dim in self.shape[:-1])
+
+        # choose what to indent each keyword with
+        min_indent = 2
+        if is_one_row:
+            # first key on the same line as the type, remaining keys
+            # aligned by equals
+            indents = {}
+            indents[keys[0]] = prefix
+            for k in keys[1:]:
+                n = builtins.max(min_indent, len(prefix + keys[0]) - len(k))
+                indents[k] = ' ' * n
+            prefix = ''  # absorbed into the first indent
+        else:
+            # each key on its own line, indented by two spaces
+            indents = {k: ' ' * min_indent for k in keys}
+            prefix = prefix + '\n'  # first key on the next line
+
+        # format the field values
+        reprs = {}
+        reprs['data'] = np.array2string(
+            self._insert_masked_print(),
+            separator=", ",
+            prefix=indents['data'] + 'data=',
+            suffix=',')
+        reprs['mask'] = np.array2string(
+            self._mask,
+            separator=", ",
+            prefix=indents['mask'] + 'mask=',
+            suffix=',')
+
+        if self._fill_value is None:
+            self.fill_value  # initialize fill_value
+
+        if (self._fill_value.dtype.kind in ("S", "U")
+                and self.dtype.kind == self._fill_value.dtype.kind):
+            # Allow strings: "N/A" has length 3 so would mismatch.
+            fill_repr = repr(self.fill_value.item())
+        elif self._fill_value.dtype == self.dtype and not self.dtype == object:
+            # Guess that it is OK to use the string as item repr.  To really
+            # fix this, it needs new logic (shared with structured scalars)
+            fill_repr = str(self.fill_value)
+        else:
+            fill_repr = repr(self.fill_value)
+
+        reprs['fill_value'] = fill_repr
+        if dtype_needed:
+            reprs['dtype'] = np._core.arrayprint.dtype_short_repr(self.dtype)
+
+        # join keys with values and indentations
+        result = ',\n'.join(
+            '{}{}={}'.format(indents[k], k, reprs[k])
+            for k in keys
+        )
+        return prefix + result + ')'
+
+    def _delegate_binop(self, other):
+        # This emulates the logic in
+        #     private/binop_override.h:forward_binop_should_defer
+        if isinstance(other, type(self)):
+            return False
+        array_ufunc = getattr(other, "__array_ufunc__", False)
+        if array_ufunc is False:
+            other_priority = getattr(other, "__array_priority__", -1000000)
+            return self.__array_priority__ < other_priority
+        else:
+            # If array_ufunc is not None, it will be called inside the ufunc;
+            # None explicitly tells us to not call the ufunc, i.e., defer.
+            return array_ufunc is None
+
+    def _comparison(self, other, compare):
+        """Compare self with other using operator.eq or operator.ne.
+
+        When either of the elements is masked, the result is masked as well,
+        but the underlying boolean data are still set, with self and other
+        considered equal if both are masked, and unequal otherwise.
+
+        For structured arrays, all fields are combined, with masked values
+        ignored. The result is masked if all fields were masked, with self
+        and other considered equal only if both were fully masked.
+        """
+        omask = getmask(other)
+        smask = self.mask
+        mask = mask_or(smask, omask, copy=True)
+
+        odata = getdata(other)
+        if mask.dtype.names is not None:
+            # only == and != are reasonably defined for structured dtypes,
+            # so give up early for all other comparisons:
+            if compare not in (operator.eq, operator.ne):
+                return NotImplemented
+            # For possibly masked structured arrays we need to be careful,
+            # since the standard structured array comparison will use all
+            # fields, masked or not. To avoid masked fields influencing the
+            # outcome, we set all masked fields in self to other, so they'll
+            # count as equal.  To prepare, we ensure we have the right shape.
+            broadcast_shape = np.broadcast(self, odata).shape
+            sbroadcast = np.broadcast_to(self, broadcast_shape, subok=True)
+            sbroadcast._mask = mask
+            sdata = sbroadcast.filled(odata)
+            # Now take care of the mask; the merged mask should have an item
+            # masked if all fields were masked (in one and/or other).
+            mask = (mask == np.ones((), mask.dtype))
+            # Ensure we can compare masks below if other was not masked.
+            if omask is np.False_:
+                omask = np.zeros((), smask.dtype)
+
+        else:
+            # For regular arrays, just use the data as they come.
+            sdata = self.data
+
+        check = compare(sdata, odata)
+
+        if isinstance(check, (np.bool, bool)):
+            return masked if mask else check
+
+        if mask is not nomask:
+            if compare in (operator.eq, operator.ne):
+                # Adjust elements that were masked, which should be treated
+                # as equal if masked in both, unequal if masked in one.
+                # Note that this works automatically for structured arrays too.
+                # Ignore this for operations other than `==` and `!=`
+                check = np.where(mask, compare(smask, omask), check)
+
+            if mask.shape != check.shape:
+                # Guarantee consistency of the shape, making a copy since the
+                # the mask may need to get written to later.
+                mask = np.broadcast_to(mask, check.shape).copy()
+
+        check = check.view(type(self))
+        check._update_from(self)
+        check._mask = mask
+
+        # Cast fill value to np.bool if needed. If it cannot be cast, the
+        # default boolean fill value is used.
+        if check._fill_value is not None:
+            try:
+                fill = _check_fill_value(check._fill_value, np.bool)
+            except (TypeError, ValueError):
+                fill = _check_fill_value(None, np.bool)
+            check._fill_value = fill
+
+        return check
+
+    def __eq__(self, other):
+        """Check whether other equals self elementwise.
+
+        When either of the elements is masked, the result is masked as well,
+        but the underlying boolean data are still set, with self and other
+        considered equal if both are masked, and unequal otherwise.
+
+        For structured arrays, all fields are combined, with masked values
+        ignored. The result is masked if all fields were masked, with self
+        and other considered equal only if both were fully masked.
+        """
+        return self._comparison(other, operator.eq)
+
+    def __ne__(self, other):
+        """Check whether other does not equal self elementwise.
+
+        When either of the elements is masked, the result is masked as well,
+        but the underlying boolean data are still set, with self and other
+        considered equal if both are masked, and unequal otherwise.
+
+        For structured arrays, all fields are combined, with masked values
+        ignored. The result is masked if all fields were masked, with self
+        and other considered equal only if both were fully masked.
+        """
+        return self._comparison(other, operator.ne)
+
+    # All other comparisons:
+    def __le__(self, other):
+        return self._comparison(other, operator.le)
+
+    def __lt__(self, other):
+        return self._comparison(other, operator.lt)
+
+    def __ge__(self, other):
+        return self._comparison(other, operator.ge)
+
+    def __gt__(self, other):
+        return self._comparison(other, operator.gt)
+
+    def __add__(self, other):
+        """
+        Add self to other, and return a new masked array.
+
+        """
+        if self._delegate_binop(other):
+            return NotImplemented
+        return add(self, other)
+
+    def __radd__(self, other):
+        """
+        Add other to self, and return a new masked array.
+
+        """
+        # In analogy with __rsub__ and __rdiv__, use original order:
+        # we get here from `other + self`.
+        return add(other, self)
+
+    def __sub__(self, other):
+        """
+        Subtract other from self, and return a new masked array.
+
+        """
+        if self._delegate_binop(other):
+            return NotImplemented
+        return subtract(self, other)
+
+    def __rsub__(self, other):
+        """
+        Subtract self from other, and return a new masked array.
+
+        """
+        return subtract(other, self)
+
+    def __mul__(self, other):
+        "Multiply self by other, and return a new masked array."
+        if self._delegate_binop(other):
+            return NotImplemented
+        return multiply(self, other)
+
+    def __rmul__(self, other):
+        """
+        Multiply other by self, and return a new masked array.
+
+        """
+        # In analogy with __rsub__ and __rdiv__, use original order:
+        # we get here from `other * self`.
+        return multiply(other, self)
+
+    def __div__(self, other):
+        """
+        Divide other into self, and return a new masked array.
+
+        """
+        if self._delegate_binop(other):
+            return NotImplemented
+        return divide(self, other)
+
+    def __truediv__(self, other):
+        """
+        Divide other into self, and return a new masked array.
+
+        """
+        if self._delegate_binop(other):
+            return NotImplemented
+        return true_divide(self, other)
+
+    def __rtruediv__(self, other):
+        """
+        Divide self into other, and return a new masked array.
+
+        """
+        return true_divide(other, self)
+
+    def __floordiv__(self, other):
+        """
+        Divide other into self, and return a new masked array.
+
+        """
+        if self._delegate_binop(other):
+            return NotImplemented
+        return floor_divide(self, other)
+
+    def __rfloordiv__(self, other):
+        """
+        Divide self into other, and return a new masked array.
+
+        """
+        return floor_divide(other, self)
+
+    def __pow__(self, other):
+        """
+        Raise self to the power other, masking the potential NaNs/Infs
+
+        """
+        if self._delegate_binop(other):
+            return NotImplemented
+        return power(self, other)
+
+    def __rpow__(self, other):
+        """
+        Raise other to the power self, masking the potential NaNs/Infs
+
+        """
+        return power(other, self)
+
+    def __iadd__(self, other):
+        """
+        Add other to self in-place.
+
+        """
+        m = getmask(other)
+        if self._mask is nomask:
+            if m is not nomask and m.any():
+                self._mask = make_mask_none(self.shape, self.dtype)
+                self._mask += m
+        else:
+            if m is not nomask:
+                self._mask += m
+        other_data = getdata(other)
+        other_data = np.where(self._mask, other_data.dtype.type(0), other_data)
+        self._data.__iadd__(other_data)
+        return self
+
+    def __isub__(self, other):
+        """
+        Subtract other from self in-place.
+
+        """
+        m = getmask(other)
+        if self._mask is nomask:
+            if m is not nomask and m.any():
+                self._mask = make_mask_none(self.shape, self.dtype)
+                self._mask += m
+        elif m is not nomask:
+            self._mask += m
+        other_data = getdata(other)
+        other_data = np.where(self._mask, other_data.dtype.type(0), other_data)
+        self._data.__isub__(other_data)
+        return self
+
+    def __imul__(self, other):
+        """
+        Multiply self by other in-place.
+
+        """
+        m = getmask(other)
+        if self._mask is nomask:
+            if m is not nomask and m.any():
+                self._mask = make_mask_none(self.shape, self.dtype)
+                self._mask += m
+        elif m is not nomask:
+            self._mask += m
+        other_data = getdata(other)
+        other_data = np.where(self._mask, other_data.dtype.type(1), other_data)
+        self._data.__imul__(other_data)
+        return self
+
+    def __idiv__(self, other):
+        """
+        Divide self by other in-place.
+
+        """
+        other_data = getdata(other)
+        dom_mask = _DomainSafeDivide().__call__(self._data, other_data)
+        other_mask = getmask(other)
+        new_mask = mask_or(other_mask, dom_mask)
+        # The following 4 lines control the domain filling
+        if dom_mask.any():
+            (_, fval) = ufunc_fills[np.divide]
+            other_data = np.where(
+                    dom_mask, other_data.dtype.type(fval), other_data)
+        self._mask |= new_mask
+        other_data = np.where(self._mask, other_data.dtype.type(1), other_data)
+        self._data.__idiv__(other_data)
+        return self
+
+    def __ifloordiv__(self, other):
+        """
+        Floor divide self by other in-place.
+
+        """
+        other_data = getdata(other)
+        dom_mask = _DomainSafeDivide().__call__(self._data, other_data)
+        other_mask = getmask(other)
+        new_mask = mask_or(other_mask, dom_mask)
+        # The following 3 lines control the domain filling
+        if dom_mask.any():
+            (_, fval) = ufunc_fills[np.floor_divide]
+            other_data = np.where(
+                    dom_mask, other_data.dtype.type(fval), other_data)
+        self._mask |= new_mask
+        other_data = np.where(self._mask, other_data.dtype.type(1), other_data)
+        self._data.__ifloordiv__(other_data)
+        return self
+
+    def __itruediv__(self, other):
+        """
+        True divide self by other in-place.
+
+        """
+        other_data = getdata(other)
+        dom_mask = _DomainSafeDivide().__call__(self._data, other_data)
+        other_mask = getmask(other)
+        new_mask = mask_or(other_mask, dom_mask)
+        # The following 3 lines control the domain filling
+        if dom_mask.any():
+            (_, fval) = ufunc_fills[np.true_divide]
+            other_data = np.where(
+                    dom_mask, other_data.dtype.type(fval), other_data)
+        self._mask |= new_mask
+        other_data = np.where(self._mask, other_data.dtype.type(1), other_data)
+        self._data.__itruediv__(other_data)
+        return self
+
+    def __ipow__(self, other):
+        """
+        Raise self to the power other, in place.
+
+        """
+        other_data = getdata(other)
+        other_data = np.where(self._mask, other_data.dtype.type(1), other_data)
+        other_mask = getmask(other)
+        with np.errstate(divide='ignore', invalid='ignore'):
+            self._data.__ipow__(other_data)
+        invalid = np.logical_not(np.isfinite(self._data))
+        if invalid.any():
+            if self._mask is not nomask:
+                self._mask |= invalid
+            else:
+                self._mask = invalid
+            np.copyto(self._data, self.fill_value, where=invalid)
+        new_mask = mask_or(other_mask, invalid)
+        self._mask = mask_or(self._mask, new_mask)
+        return self
+
+    def __float__(self):
+        """
+        Convert to float.
+
+        """
+        if self.size > 1:
+            raise TypeError("Only length-1 arrays can be converted "
+                            "to Python scalars")
+        elif self._mask:
+            warnings.warn("Warning: converting a masked element to nan.", stacklevel=2)
+            return np.nan
+        return float(self.item())
+
+    def __int__(self):
+        """
+        Convert to int.
+
+        """
+        if self.size > 1:
+            raise TypeError("Only length-1 arrays can be converted "
+                            "to Python scalars")
+        elif self._mask:
+            raise MaskError('Cannot convert masked element to a Python int.')
+        return int(self.item())
+
+    @property
+    def imag(self):
+        """
+        The imaginary part of the masked array.
+
+        This property is a view on the imaginary part of this `MaskedArray`.
+
+        See Also
+        --------
+        real
+
+        Examples
+        --------
+        >>> import numpy as np
+        >>> x = np.ma.array([1+1.j, -2j, 3.45+1.6j], mask=[False, True, False])
+        >>> x.imag
+        masked_array(data=[1.0, --, 1.6],
+                     mask=[False,  True, False],
+               fill_value=1e+20)
+
+        """
+        result = self._data.imag.view(type(self))
+        result.__setmask__(self._mask)
+        return result
+
+    # kept for compatibility
+    get_imag = imag.fget
+
+    @property
+    def real(self):
+        """
+        The real part of the masked array.
+
+        This property is a view on the real part of this `MaskedArray`.
+
+        See Also
+        --------
+        imag
+
+        Examples
+        --------
+        >>> import numpy as np
+        >>> x = np.ma.array([1+1.j, -2j, 3.45+1.6j], mask=[False, True, False])
+        >>> x.real
+        masked_array(data=[1.0, --, 3.45],
+                     mask=[False,  True, False],
+               fill_value=1e+20)
+
+        """
+        result = self._data.real.view(type(self))
+        result.__setmask__(self._mask)
+        return result
+
+    # kept for compatibility
+    get_real = real.fget
+
+    def count(self, axis=None, keepdims=np._NoValue):
+        """
+        Count the non-masked elements of the array along the given axis.
+
+        Parameters
+        ----------
+        axis : None or int or tuple of ints, optional
+            Axis or axes along which the count is performed.
+            The default, None, performs the count over all
+            the dimensions of the input array. `axis` may be negative, in
+            which case it counts from the last to the first axis.
+
+            .. versionadded:: 1.10.0
+
+            If this is a tuple of ints, the count is performed on multiple
+            axes, instead of a single axis or all the axes as before.
+        keepdims : bool, optional
+            If this is set to True, the axes which are reduced are left
+            in the result as dimensions with size one. With this option,
+            the result will broadcast correctly against the array.
+
+        Returns
+        -------
+        result : ndarray or scalar
+            An array with the same shape as the input array, with the specified
+            axis removed. If the array is a 0-d array, or if `axis` is None, a
+            scalar is returned.
+
+        See Also
+        --------
+        ma.count_masked : Count masked elements in array or along a given axis.
+
+        Examples
+        --------
+        >>> import numpy.ma as ma
+        >>> a = ma.arange(6).reshape((2, 3))
+        >>> a[1, :] = ma.masked
+        >>> a
+        masked_array(
+          data=[[0, 1, 2],
+                [--, --, --]],
+          mask=[[False, False, False],
+                [ True,  True,  True]],
+          fill_value=999999)
+        >>> a.count()
+        3
+
+        When the `axis` keyword is specified an array of appropriate size is
+        returned.
+
+        >>> a.count(axis=0)
+        array([1, 1, 1])
+        >>> a.count(axis=1)
+        array([3, 0])
+
+        """
+        kwargs = {} if keepdims is np._NoValue else {'keepdims': keepdims}
+
+        m = self._mask
+        # special case for matrices (we assume no other subclasses modify
+        # their dimensions)
+        if isinstance(self.data, np.matrix):
+            if m is nomask:
+                m = np.zeros(self.shape, dtype=np.bool)
+            m = m.view(type(self.data))
+
+        if m is nomask:
+            # compare to _count_reduce_items in _methods.py
+
+            if self.shape == ():
+                if axis not in (None, 0):
+                    raise np.exceptions.AxisError(axis=axis, ndim=self.ndim)
+                return 1
+            elif axis is None:
+                if kwargs.get('keepdims', False):
+                    return np.array(self.size, dtype=np.intp, ndmin=self.ndim)
+                return self.size
+
+            axes = normalize_axis_tuple(axis, self.ndim)
+            items = 1
+            for ax in axes:
+                items *= self.shape[ax]
+
+            if kwargs.get('keepdims', False):
+                out_dims = list(self.shape)
+                for a in axes:
+                    out_dims[a] = 1
+            else:
+                out_dims = [d for n, d in enumerate(self.shape)
+                            if n not in axes]
+            # make sure to return a 0-d array if axis is supplied
+            return np.full(out_dims, items, dtype=np.intp)
+
+        # take care of the masked singleton
+        if self is masked:
+            return 0
+
+        return (~m).sum(axis=axis, dtype=np.intp, **kwargs)
+
+    def ravel(self, order='C'):
+        """
+        Returns a 1D version of self, as a view.
+
+        Parameters
+        ----------
+        order : {'C', 'F', 'A', 'K'}, optional
+            The elements of `a` are read using this index order. 'C' means to
+            index the elements in C-like order, with the last axis index
+            changing fastest, back to the first axis index changing slowest.
+            'F' means to index the elements in Fortran-like index order, with
+            the first index changing fastest, and the last index changing
+            slowest. Note that the 'C' and 'F' options take no account of the
+            memory layout of the underlying array, and only refer to the order
+            of axis indexing.  'A' means to read the elements in Fortran-like
+            index order if `m` is Fortran *contiguous* in memory, C-like order
+            otherwise.  'K' means to read the elements in the order they occur
+            in memory, except for reversing the data when strides are negative.
+            By default, 'C' index order is used.
+            (Masked arrays currently use 'A' on the data when 'K' is passed.)
+
+        Returns
+        -------
+        MaskedArray
+            Output view is of shape ``(self.size,)`` (or
+            ``(np.ma.product(self.shape),)``).
+
+        Examples
+        --------
+        >>> import numpy as np
+        >>> x = np.ma.array([[1,2,3],[4,5,6],[7,8,9]], mask=[0] + [1,0]*4)
+        >>> x
+        masked_array(
+          data=[[1, --, 3],
+                [--, 5, --],
+                [7, --, 9]],
+          mask=[[False,  True, False],
+                [ True, False,  True],
+                [False,  True, False]],
+          fill_value=999999)
+        >>> x.ravel()
+        masked_array(data=[1, --, 3, --, 5, --, 7, --, 9],
+                     mask=[False,  True, False,  True, False,  True, False,  True,
+                           False],
+               fill_value=999999)
+
+        """
+        # The order of _data and _mask could be different (it shouldn't be
+        # normally).  Passing order `K` or `A` would be incorrect.
+        # So we ignore the mask memory order.
+        # TODO: We don't actually support K, so use A instead.  We could
+        #       try to guess this correct by sorting strides or deprecate.
+        if order in "kKaA":
+            order = "F" if self._data.flags.fnc else "C"
+        r = ndarray.ravel(self._data, order=order).view(type(self))
+        r._update_from(self)
+        if self._mask is not nomask:
+            r._mask = ndarray.ravel(self._mask, order=order).reshape(r.shape)
+        else:
+            r._mask = nomask
+        return r
+
+
+    def reshape(self, *s, **kwargs):
+        """
+        Give a new shape to the array without changing its data.
+
+        Returns a masked array containing the same data, but with a new shape.
+        The result is a view on the original array; if this is not possible, a
+        ValueError is raised.
+
+        Parameters
+        ----------
+        shape : int or tuple of ints
+            The new shape should be compatible with the original shape. If an
+            integer is supplied, then the result will be a 1-D array of that
+            length.
+        order : {'C', 'F'}, optional
+            Determines whether the array data should be viewed as in C
+            (row-major) or FORTRAN (column-major) order.
+
+        Returns
+        -------
+        reshaped_array : array
+            A new view on the array.
+
+        See Also
+        --------
+        reshape : Equivalent function in the masked array module.
+        numpy.ndarray.reshape : Equivalent method on ndarray object.
+        numpy.reshape : Equivalent function in the NumPy module.
+
+        Notes
+        -----
+        The reshaping operation cannot guarantee that a copy will not be made,
+        to modify the shape in place, use ``a.shape = s``
+
+        Examples
+        --------
+        >>> import numpy as np
+        >>> x = np.ma.array([[1,2],[3,4]], mask=[1,0,0,1])
+        >>> x
+        masked_array(
+          data=[[--, 2],
+                [3, --]],
+          mask=[[ True, False],
+                [False,  True]],
+          fill_value=999999)
+        >>> x = x.reshape((4,1))
+        >>> x
+        masked_array(
+          data=[[--],
+                [2],
+                [3],
+                [--]],
+          mask=[[ True],
+                [False],
+                [False],
+                [ True]],
+          fill_value=999999)
+
+        """
+        kwargs.update(order=kwargs.get('order', 'C'))
+        result = self._data.reshape(*s, **kwargs).view(type(self))
+        result._update_from(self)
+        mask = self._mask
+        if mask is not nomask:
+            result._mask = mask.reshape(*s, **kwargs)
+        return result
+
+    def resize(self, newshape, refcheck=True, order=False):
+        """
+        .. warning::
+
+            This method does nothing, except raise a ValueError exception. A
+            masked array does not own its data and therefore cannot safely be
+            resized in place. Use the `numpy.ma.resize` function instead.
+
+        This method is difficult to implement safely and may be deprecated in
+        future releases of NumPy.
+
+        """
+        # Note : the 'order' keyword looks broken, let's just drop it
+        errmsg = "A masked array does not own its data "\
+                 "and therefore cannot be resized.\n" \
+                 "Use the numpy.ma.resize function instead."
+        raise ValueError(errmsg)
+
+    def put(self, indices, values, mode='raise'):
+        """
+        Set storage-indexed locations to corresponding values.
+
+        Sets self._data.flat[n] = values[n] for each n in indices.
+        If `values` is shorter than `indices` then it will repeat.
+        If `values` has some masked values, the initial mask is updated
+        in consequence, else the corresponding values are unmasked.
+
+        Parameters
+        ----------
+        indices : 1-D array_like
+            Target indices, interpreted as integers.
+        values : array_like
+            Values to place in self._data copy at target indices.
+        mode : {'raise', 'wrap', 'clip'}, optional
+            Specifies how out-of-bounds indices will behave.
+            'raise' : raise an error.
+            'wrap' : wrap around.
+            'clip' : clip to the range.
+
+        Notes
+        -----
+        `values` can be a scalar or length 1 array.
+
+        Examples
+        --------
+        >>> import numpy as np
+        >>> x = np.ma.array([[1,2,3],[4,5,6],[7,8,9]], mask=[0] + [1,0]*4)
+        >>> x
+        masked_array(
+          data=[[1, --, 3],
+                [--, 5, --],
+                [7, --, 9]],
+          mask=[[False,  True, False],
+                [ True, False,  True],
+                [False,  True, False]],
+          fill_value=999999)
+        >>> x.put([0,4,8],[10,20,30])
+        >>> x
+        masked_array(
+          data=[[10, --, 3],
+                [--, 20, --],
+                [7, --, 30]],
+          mask=[[False,  True, False],
+                [ True, False,  True],
+                [False,  True, False]],
+          fill_value=999999)
+
+        >>> x.put(4,999)
+        >>> x
+        masked_array(
+          data=[[10, --, 3],
+                [--, 999, --],
+                [7, --, 30]],
+          mask=[[False,  True, False],
+                [ True, False,  True],
+                [False,  True, False]],
+          fill_value=999999)
+
+        """
+        # Hard mask: Get rid of the values/indices that fall on masked data
+        if self._hardmask and self._mask is not nomask:
+            mask = self._mask[indices]
+            indices = narray(indices, copy=None)
+            values = narray(values, copy=None, subok=True)
+            values.resize(indices.shape)
+            indices = indices[~mask]
+            values = values[~mask]
+
+        self._data.put(indices, values, mode=mode)
+
+        # short circuit if neither self nor values are masked
+        if self._mask is nomask and getmask(values) is nomask:
+            return
+
+        m = getmaskarray(self)
+
+        if getmask(values) is nomask:
+            m.put(indices, False, mode=mode)
+        else:
+            m.put(indices, values._mask, mode=mode)
+        m = make_mask(m, copy=False, shrink=True)
+        self._mask = m
+        return
+
+    def ids(self):
+        """
+        Return the addresses of the data and mask areas.
+
+        Parameters
+        ----------
+        None
+
+        Examples
+        --------
+        >>> import numpy as np
+        >>> x = np.ma.array([1, 2, 3], mask=[0, 1, 1])
+        >>> x.ids()
+        (166670640, 166659832) # may vary
+
+        If the array has no mask, the address of `nomask` is returned. This address
+        is typically not close to the data in memory:
+
+        >>> x = np.ma.array([1, 2, 3])
+        >>> x.ids()
+        (166691080, 3083169284) # may vary
+
+        """
+        if self._mask is nomask:
+            return (self.ctypes.data, id(nomask))
+        return (self.ctypes.data, self._mask.ctypes.data)
+
+    def iscontiguous(self):
+        """
+        Return a boolean indicating whether the data is contiguous.
+
+        Parameters
+        ----------
+        None
+
+        Examples
+        --------
+        >>> import numpy as np
+        >>> x = np.ma.array([1, 2, 3])
+        >>> x.iscontiguous()
+        True
+
+        `iscontiguous` returns one of the flags of the masked array:
+
+        >>> x.flags
+          C_CONTIGUOUS : True
+          F_CONTIGUOUS : True
+          OWNDATA : False
+          WRITEABLE : True
+          ALIGNED : True
+          WRITEBACKIFCOPY : False
+
+        """
+        return self.flags['CONTIGUOUS']
+
+    def all(self, axis=None, out=None, keepdims=np._NoValue):
+        """
+        Returns True if all elements evaluate to True.
+
+        The output array is masked where all the values along the given axis
+        are masked: if the output would have been a scalar and that all the
+        values are masked, then the output is `masked`.
+
+        Refer to `numpy.all` for full documentation.
+
+        See Also
+        --------
+        numpy.ndarray.all : corresponding function for ndarrays
+        numpy.all : equivalent function
+
+        Examples
+        --------
+        >>> import numpy as np
+        >>> np.ma.array([1,2,3]).all()
+        True
+        >>> a = np.ma.array([1,2,3], mask=True)
+        >>> (a.all() is np.ma.masked)
+        True
+
+        """
+        kwargs = {} if keepdims is np._NoValue else {'keepdims': keepdims}
+
+        mask = _check_mask_axis(self._mask, axis, **kwargs)
+        if out is None:
+            d = self.filled(True).all(axis=axis, **kwargs).view(type(self))
+            if d.ndim:
+                d.__setmask__(mask)
+            elif mask:
+                return masked
+            return d
+        self.filled(True).all(axis=axis, out=out, **kwargs)
+        if isinstance(out, MaskedArray):
+            if out.ndim or mask:
+                out.__setmask__(mask)
+        return out
+
+    def any(self, axis=None, out=None, keepdims=np._NoValue):
+        """
+        Returns True if any of the elements of `a` evaluate to True.
+
+        Masked values are considered as False during computation.
+
+        Refer to `numpy.any` for full documentation.
+
+        See Also
+        --------
+        numpy.ndarray.any : corresponding function for ndarrays
+        numpy.any : equivalent function
+
+        """
+        kwargs = {} if keepdims is np._NoValue else {'keepdims': keepdims}
+
+        mask = _check_mask_axis(self._mask, axis, **kwargs)
+        if out is None:
+            d = self.filled(False).any(axis=axis, **kwargs).view(type(self))
+            if d.ndim:
+                d.__setmask__(mask)
+            elif mask:
+                d = masked
+            return d
+        self.filled(False).any(axis=axis, out=out, **kwargs)
+        if isinstance(out, MaskedArray):
+            if out.ndim or mask:
+                out.__setmask__(mask)
+        return out
+
+    def nonzero(self):
+        """
+        Return the indices of unmasked elements that are not zero.
+
+        Returns a tuple of arrays, one for each dimension, containing the
+        indices of the non-zero elements in that dimension. The corresponding
+        non-zero values can be obtained with::
+
+            a[a.nonzero()]
+
+        To group the indices by element, rather than dimension, use
+        instead::
+
+            np.transpose(a.nonzero())
+
+        The result of this is always a 2d array, with a row for each non-zero
+        element.
+
+        Parameters
+        ----------
+        None
+
+        Returns
+        -------
+        tuple_of_arrays : tuple
+            Indices of elements that are non-zero.
+
+        See Also
+        --------
+        numpy.nonzero :
+            Function operating on ndarrays.
+        flatnonzero :
+            Return indices that are non-zero in the flattened version of the input
+            array.
+        numpy.ndarray.nonzero :
+            Equivalent ndarray method.
+        count_nonzero :
+            Counts the number of non-zero elements in the input array.
+
+        Examples
+        --------
+        >>> import numpy as np
+        >>> import numpy.ma as ma
+        >>> x = ma.array(np.eye(3))
+        >>> x
+        masked_array(
+          data=[[1., 0., 0.],
+                [0., 1., 0.],
+                [0., 0., 1.]],
+          mask=False,
+          fill_value=1e+20)
+        >>> x.nonzero()
+        (array([0, 1, 2]), array([0, 1, 2]))
+
+        Masked elements are ignored.
+
+        >>> x[1, 1] = ma.masked
+        >>> x
+        masked_array(
+          data=[[1.0, 0.0, 0.0],
+                [0.0, --, 0.0],
+                [0.0, 0.0, 1.0]],
+          mask=[[False, False, False],
+                [False,  True, False],
+                [False, False, False]],
+          fill_value=1e+20)
+        >>> x.nonzero()
+        (array([0, 2]), array([0, 2]))
+
+        Indices can also be grouped by element.
+
+        >>> np.transpose(x.nonzero())
+        array([[0, 0],
+               [2, 2]])
+
+        A common use for ``nonzero`` is to find the indices of an array, where
+        a condition is True.  Given an array `a`, the condition `a` > 3 is a
+        boolean array and since False is interpreted as 0, ma.nonzero(a > 3)
+        yields the indices of the `a` where the condition is true.
+
+        >>> a = ma.array([[1,2,3],[4,5,6],[7,8,9]])
+        >>> a > 3
+        masked_array(
+          data=[[False, False, False],
+                [ True,  True,  True],
+                [ True,  True,  True]],
+          mask=False,
+          fill_value=True)
+        >>> ma.nonzero(a > 3)
+        (array([1, 1, 1, 2, 2, 2]), array([0, 1, 2, 0, 1, 2]))
+
+        The ``nonzero`` method of the condition array can also be called.
+
+        >>> (a > 3).nonzero()
+        (array([1, 1, 1, 2, 2, 2]), array([0, 1, 2, 0, 1, 2]))
+
+        """
+        return np.asarray(self.filled(0)).nonzero()
+
+    def trace(self, offset=0, axis1=0, axis2=1, dtype=None, out=None):
+        """
+        (this docstring should be overwritten)
+        """
+        #!!!: implement out + test!
+        m = self._mask
+        if m is nomask:
+            result = super().trace(offset=offset, axis1=axis1, axis2=axis2,
+                                   out=out)
+            return result.astype(dtype)
+        else:
+            D = self.diagonal(offset=offset, axis1=axis1, axis2=axis2)
+            return D.astype(dtype).filled(0).sum(axis=-1, out=out)
+    trace.__doc__ = ndarray.trace.__doc__
+
+    def dot(self, b, out=None, strict=False):
+        """
+        a.dot(b, out=None)
+
+        Masked dot product of two arrays. Note that `out` and `strict` are
+        located in different positions than in `ma.dot`. In order to
+        maintain compatibility with the functional version, it is
+        recommended that the optional arguments be treated as keyword only.
+        At some point that may be mandatory.
+
+        .. versionadded:: 1.10.0
+
+        Parameters
+        ----------
+        b : masked_array_like
+            Inputs array.
+        out : masked_array, optional
+            Output argument. This must have the exact kind that would be
+            returned if it was not used. In particular, it must have the
+            right type, must be C-contiguous, and its dtype must be the
+            dtype that would be returned for `ma.dot(a,b)`. This is a
+            performance feature. Therefore, if these conditions are not
+            met, an exception is raised, instead of attempting to be
+            flexible.
+        strict : bool, optional
+            Whether masked data are propagated (True) or set to 0 (False)
+            for the computation. Default is False.  Propagating the mask
+            means that if a masked value appears in a row or column, the
+            whole row or column is considered masked.
+
+            .. versionadded:: 1.10.2
+
+        See Also
+        --------
+        numpy.ma.dot : equivalent function
+
+        """
+        return dot(self, b, out=out, strict=strict)
+
+    def sum(self, axis=None, dtype=None, out=None, keepdims=np._NoValue):
+        """
+        Return the sum of the array elements over the given axis.
+
+        Masked elements are set to 0 internally.
+
+        Refer to `numpy.sum` for full documentation.
+
+        See Also
+        --------
+        numpy.ndarray.sum : corresponding function for ndarrays
+        numpy.sum : equivalent function
+
+        Examples
+        --------
+        >>> import numpy as np
+        >>> x = np.ma.array([[1,2,3],[4,5,6],[7,8,9]], mask=[0] + [1,0]*4)
+        >>> x
+        masked_array(
+          data=[[1, --, 3],
+                [--, 5, --],
+                [7, --, 9]],
+          mask=[[False,  True, False],
+                [ True, False,  True],
+                [False,  True, False]],
+          fill_value=999999)
+        >>> x.sum()
+        25
+        >>> x.sum(axis=1)
+        masked_array(data=[4, 5, 16],
+                     mask=[False, False, False],
+               fill_value=999999)
+        >>> x.sum(axis=0)
+        masked_array(data=[8, 5, 12],
+                     mask=[False, False, False],
+               fill_value=999999)
+        >>> print(type(x.sum(axis=0, dtype=np.int64)[0]))
+        
+
+        """
+        kwargs = {} if keepdims is np._NoValue else {'keepdims': keepdims}
+
+        _mask = self._mask
+        newmask = _check_mask_axis(_mask, axis, **kwargs)
+        # No explicit output
+        if out is None:
+            result = self.filled(0).sum(axis, dtype=dtype, **kwargs)
+            rndim = getattr(result, 'ndim', 0)
+            if rndim:
+                result = result.view(type(self))
+                result.__setmask__(newmask)
+            elif newmask:
+                result = masked
+            return result
+        # Explicit output
+        result = self.filled(0).sum(axis, dtype=dtype, out=out, **kwargs)
+        if isinstance(out, MaskedArray):
+            outmask = getmask(out)
+            if outmask is nomask:
+                outmask = out._mask = make_mask_none(out.shape)
+            outmask.flat = newmask
+        return out
+
+    def cumsum(self, axis=None, dtype=None, out=None):
+        """
+        Return the cumulative sum of the array elements over the given axis.
+
+        Masked values are set to 0 internally during the computation.
+        However, their position is saved, and the result will be masked at
+        the same locations.
+
+        Refer to `numpy.cumsum` for full documentation.
+
+        Notes
+        -----
+        The mask is lost if `out` is not a valid :class:`ma.MaskedArray` !
+
+        Arithmetic is modular when using integer types, and no error is
+        raised on overflow.
+
+        See Also
+        --------
+        numpy.ndarray.cumsum : corresponding function for ndarrays
+        numpy.cumsum : equivalent function
+
+        Examples
+        --------
+        >>> import numpy as np
+        >>> marr = np.ma.array(np.arange(10), mask=[0,0,0,1,1,1,0,0,0,0])
+        >>> marr.cumsum()
+        masked_array(data=[0, 1, 3, --, --, --, 9, 16, 24, 33],
+                     mask=[False, False, False,  True,  True,  True, False, False,
+                           False, False],
+               fill_value=999999)
+
+        """
+        result = self.filled(0).cumsum(axis=axis, dtype=dtype, out=out)
+        if out is not None:
+            if isinstance(out, MaskedArray):
+                out.__setmask__(self.mask)
+            return out
+        result = result.view(type(self))
+        result.__setmask__(self._mask)
+        return result
+
+    def prod(self, axis=None, dtype=None, out=None, keepdims=np._NoValue):
+        """
+        Return the product of the array elements over the given axis.
+
+        Masked elements are set to 1 internally for computation.
+
+        Refer to `numpy.prod` for full documentation.
+
+        Notes
+        -----
+        Arithmetic is modular when using integer types, and no error is raised
+        on overflow.
+
+        See Also
+        --------
+        numpy.ndarray.prod : corresponding function for ndarrays
+        numpy.prod : equivalent function
+        """
+        kwargs = {} if keepdims is np._NoValue else {'keepdims': keepdims}
+
+        _mask = self._mask
+        newmask = _check_mask_axis(_mask, axis, **kwargs)
+        # No explicit output
+        if out is None:
+            result = self.filled(1).prod(axis, dtype=dtype, **kwargs)
+            rndim = getattr(result, 'ndim', 0)
+            if rndim:
+                result = result.view(type(self))
+                result.__setmask__(newmask)
+            elif newmask:
+                result = masked
+            return result
+        # Explicit output
+        result = self.filled(1).prod(axis, dtype=dtype, out=out, **kwargs)
+        if isinstance(out, MaskedArray):
+            outmask = getmask(out)
+            if outmask is nomask:
+                outmask = out._mask = make_mask_none(out.shape)
+            outmask.flat = newmask
+        return out
+    product = prod
+
+    def cumprod(self, axis=None, dtype=None, out=None):
+        """
+        Return the cumulative product of the array elements over the given axis.
+
+        Masked values are set to 1 internally during the computation.
+        However, their position is saved, and the result will be masked at
+        the same locations.
+
+        Refer to `numpy.cumprod` for full documentation.
+
+        Notes
+        -----
+        The mask is lost if `out` is not a valid MaskedArray !
+
+        Arithmetic is modular when using integer types, and no error is
+        raised on overflow.
+
+        See Also
+        --------
+        numpy.ndarray.cumprod : corresponding function for ndarrays
+        numpy.cumprod : equivalent function
+        """
+        result = self.filled(1).cumprod(axis=axis, dtype=dtype, out=out)
+        if out is not None:
+            if isinstance(out, MaskedArray):
+                out.__setmask__(self._mask)
+            return out
+        result = result.view(type(self))
+        result.__setmask__(self._mask)
+        return result
+
+    def mean(self, axis=None, dtype=None, out=None, keepdims=np._NoValue):
+        """
+        Returns the average of the array elements along given axis.
+
+        Masked entries are ignored, and result elements which are not
+        finite will be masked.
+
+        Refer to `numpy.mean` for full documentation.
+
+        See Also
+        --------
+        numpy.ndarray.mean : corresponding function for ndarrays
+        numpy.mean : Equivalent function
+        numpy.ma.average : Weighted average.
+
+        Examples
+        --------
+        >>> import numpy as np
+        >>> a = np.ma.array([1,2,3], mask=[False, False, True])
+        >>> a
+        masked_array(data=[1, 2, --],
+                     mask=[False, False,  True],
+               fill_value=999999)
+        >>> a.mean()
+        1.5
+
+        """
+        kwargs = {} if keepdims is np._NoValue else {'keepdims': keepdims}
+        if self._mask is nomask:
+            result = super().mean(axis=axis, dtype=dtype, **kwargs)[()]
+        else:
+            is_float16_result = False
+            if dtype is None:
+                if issubclass(self.dtype.type, (ntypes.integer, ntypes.bool)):
+                    dtype = mu.dtype('f8')
+                elif issubclass(self.dtype.type, ntypes.float16):
+                    dtype = mu.dtype('f4')
+                    is_float16_result = True
+            dsum = self.sum(axis=axis, dtype=dtype, **kwargs)
+            cnt = self.count(axis=axis, **kwargs)
+            if cnt.shape == () and (cnt == 0):
+                result = masked
+            elif is_float16_result:
+                result = self.dtype.type(dsum * 1. / cnt)
+            else:
+                result = dsum * 1. / cnt
+        if out is not None:
+            out.flat = result
+            if isinstance(out, MaskedArray):
+                outmask = getmask(out)
+                if outmask is nomask:
+                    outmask = out._mask = make_mask_none(out.shape)
+                outmask.flat = getmask(result)
+            return out
+        return result
+
+    def anom(self, axis=None, dtype=None):
+        """
+        Compute the anomalies (deviations from the arithmetic mean)
+        along the given axis.
+
+        Returns an array of anomalies, with the same shape as the input and
+        where the arithmetic mean is computed along the given axis.
+
+        Parameters
+        ----------
+        axis : int, optional
+            Axis over which the anomalies are taken.
+            The default is to use the mean of the flattened array as reference.
+        dtype : dtype, optional
+            Type to use in computing the variance. For arrays of integer type
+             the default is float32; for arrays of float types it is the same as
+             the array type.
+
+        See Also
+        --------
+        mean : Compute the mean of the array.
+
+        Examples
+        --------
+        >>> import numpy as np
+        >>> a = np.ma.array([1,2,3])
+        >>> a.anom()
+        masked_array(data=[-1.,  0.,  1.],
+                     mask=False,
+               fill_value=1e+20)
+
+        """
+        m = self.mean(axis, dtype)
+        if not axis:
+            return self - m
+        else:
+            return self - expand_dims(m, axis)
+
+    def var(self, axis=None, dtype=None, out=None, ddof=0,
+            keepdims=np._NoValue, mean=np._NoValue):
+        """
+        Returns the variance of the array elements along given axis.
+
+        Masked entries are ignored, and result elements which are not
+        finite will be masked.
+
+        Refer to `numpy.var` for full documentation.
+
+        See Also
+        --------
+        numpy.ndarray.var : corresponding function for ndarrays
+        numpy.var : Equivalent function
+        """
+        kwargs = {}
+
+        if keepdims is not np._NoValue:
+            kwargs['keepdims'] = keepdims
+
+        # Easy case: nomask, business as usual
+        if self._mask is nomask:
+
+            if mean is not np._NoValue:
+                kwargs['mean'] = mean
+
+            ret = super().var(axis=axis, dtype=dtype, out=out, ddof=ddof,
+                              **kwargs)[()]
+            if out is not None:
+                if isinstance(out, MaskedArray):
+                    out.__setmask__(nomask)
+                return out
+            return ret
+
+        # Some data are masked, yay!
+        cnt = self.count(axis=axis, **kwargs) - ddof
+
+        if mean is not np._NoValue:
+            danom = self - mean
+        else:
+            danom = self - self.mean(axis, dtype, keepdims=True)
+
+        if iscomplexobj(self):
+            danom = umath.absolute(danom) ** 2
+        else:
+            danom *= danom
+        dvar = divide(danom.sum(axis, **kwargs), cnt).view(type(self))
+        # Apply the mask if it's not a scalar
+        if dvar.ndim:
+            dvar._mask = mask_or(self._mask.all(axis, **kwargs), (cnt <= 0))
+            dvar._update_from(self)
+        elif getmask(dvar):
+            # Make sure that masked is returned when the scalar is masked.
+            dvar = masked
+            if out is not None:
+                if isinstance(out, MaskedArray):
+                    out.flat = 0
+                    out.__setmask__(True)
+                elif out.dtype.kind in 'biu':
+                    errmsg = "Masked data information would be lost in one or "\
+                             "more location."
+                    raise MaskError(errmsg)
+                else:
+                    out.flat = np.nan
+                return out
+        # In case with have an explicit output
+        if out is not None:
+            # Set the data
+            out.flat = dvar
+            # Set the mask if needed
+            if isinstance(out, MaskedArray):
+                out.__setmask__(dvar.mask)
+            return out
+        return dvar
+    var.__doc__ = np.var.__doc__
+
+    def std(self, axis=None, dtype=None, out=None, ddof=0,
+            keepdims=np._NoValue, mean=np._NoValue):
+        """
+        Returns the standard deviation of the array elements along given axis.
+
+        Masked entries are ignored.
+
+        Refer to `numpy.std` for full documentation.
+
+        See Also
+        --------
+        numpy.ndarray.std : corresponding function for ndarrays
+        numpy.std : Equivalent function
+        """
+        kwargs = {} if keepdims is np._NoValue else {'keepdims': keepdims}
+
+        dvar = self.var(axis, dtype, out, ddof, **kwargs)
+        if dvar is not masked:
+            if out is not None:
+                np.power(out, 0.5, out=out, casting='unsafe')
+                return out
+            dvar = sqrt(dvar)
+        return dvar
+
+    def round(self, decimals=0, out=None):
+        """
+        Return each element rounded to the given number of decimals.
+
+        Refer to `numpy.around` for full documentation.
+
+        See Also
+        --------
+        numpy.ndarray.round : corresponding function for ndarrays
+        numpy.around : equivalent function
+
+        Examples
+        --------
+        >>> import numpy as np
+        >>> import numpy.ma as ma
+        >>> x = ma.array([1.35, 2.5, 1.5, 1.75, 2.25, 2.75],
+        ...              mask=[0, 0, 0, 1, 0, 0])
+        >>> ma.round(x)
+        masked_array(data=[1.0, 2.0, 2.0, --, 2.0, 3.0],
+                     mask=[False, False, False,  True, False, False],
+                fill_value=1e+20)
+
+        """
+        result = self._data.round(decimals=decimals, out=out).view(type(self))
+        if result.ndim > 0:
+            result._mask = self._mask
+            result._update_from(self)
+        elif self._mask:
+            # Return masked when the scalar is masked
+            result = masked
+        # No explicit output: we're done
+        if out is None:
+            return result
+        if isinstance(out, MaskedArray):
+            out.__setmask__(self._mask)
+        return out
+
+    def argsort(self, axis=np._NoValue, kind=None, order=None, endwith=True,
+                fill_value=None, *, stable=False):
+        """
+        Return an ndarray of indices that sort the array along the
+        specified axis.  Masked values are filled beforehand to
+        `fill_value`.
+
+        Parameters
+        ----------
+        axis : int, optional
+            Axis along which to sort. If None, the default, the flattened array
+            is used.
+
+            ..  versionchanged:: 1.13.0
+                Previously, the default was documented to be -1, but that was
+                in error. At some future date, the default will change to -1, as
+                originally intended.
+                Until then, the axis should be given explicitly when
+                ``arr.ndim > 1``, to avoid a FutureWarning.
+        kind : {'quicksort', 'mergesort', 'heapsort', 'stable'}, optional
+            The sorting algorithm used.
+        order : list, optional
+            When `a` is an array with fields defined, this argument specifies
+            which fields to compare first, second, etc.  Not all fields need be
+            specified.
+        endwith : {True, False}, optional
+            Whether missing values (if any) should be treated as the largest values
+            (True) or the smallest values (False)
+            When the array contains unmasked values at the same extremes of the
+            datatype, the ordering of these values and the masked values is
+            undefined.
+        fill_value : scalar or None, optional
+            Value used internally for the masked values.
+            If ``fill_value`` is not None, it supersedes ``endwith``.
+        stable : bool, optional
+            Only for compatibility with ``np.argsort``. Ignored.
+
+        Returns
+        -------
+        index_array : ndarray, int
+            Array of indices that sort `a` along the specified axis.
+            In other words, ``a[index_array]`` yields a sorted `a`.
+
+        See Also
+        --------
+        ma.MaskedArray.sort : Describes sorting algorithms used.
+        lexsort : Indirect stable sort with multiple keys.
+        numpy.ndarray.sort : Inplace sort.
+
+        Notes
+        -----
+        See `sort` for notes on the different sorting algorithms.
+
+        Examples
+        --------
+        >>> import numpy as np
+        >>> a = np.ma.array([3,2,1], mask=[False, False, True])
+        >>> a
+        masked_array(data=[3, 2, --],
+                     mask=[False, False,  True],
+               fill_value=999999)
+        >>> a.argsort()
+        array([1, 0, 2])
+
+        """
+        if stable:
+            raise ValueError(
+                "`stable` parameter is not supported for masked arrays."
+            )
+
+        # 2017-04-11, Numpy 1.13.0, gh-8701: warn on axis default
+        if axis is np._NoValue:
+            axis = _deprecate_argsort_axis(self)
+
+        if fill_value is None:
+            if endwith:
+                # nan > inf
+                if np.issubdtype(self.dtype, np.floating):
+                    fill_value = np.nan
+                else:
+                    fill_value = minimum_fill_value(self)
+            else:
+                fill_value = maximum_fill_value(self)
+
+        filled = self.filled(fill_value)
+        return filled.argsort(axis=axis, kind=kind, order=order)
+
+    def argmin(self, axis=None, fill_value=None, out=None, *,
+                keepdims=np._NoValue):
+        """
+        Return array of indices to the minimum values along the given axis.
+
+        Parameters
+        ----------
+        axis : {None, integer}
+            If None, the index is into the flattened array, otherwise along
+            the specified axis
+        fill_value : scalar or None, optional
+            Value used to fill in the masked values.  If None, the output of
+            minimum_fill_value(self._data) is used instead.
+        out : {None, array}, optional
+            Array into which the result can be placed. Its type is preserved
+            and it must be of the right shape to hold the output.
+
+        Returns
+        -------
+        ndarray or scalar
+            If multi-dimension input, returns a new ndarray of indices to the
+            minimum values along the given axis.  Otherwise, returns a scalar
+            of index to the minimum values along the given axis.
+
+        Examples
+        --------
+        >>> import numpy as np
+        >>> x = np.ma.array(np.arange(4), mask=[1,1,0,0])
+        >>> x.shape = (2,2)
+        >>> x
+        masked_array(
+          data=[[--, --],
+                [2, 3]],
+          mask=[[ True,  True],
+                [False, False]],
+          fill_value=999999)
+        >>> x.argmin(axis=0, fill_value=-1)
+        array([0, 0])
+        >>> x.argmin(axis=0, fill_value=9)
+        array([1, 1])
+
+        """
+        if fill_value is None:
+            fill_value = minimum_fill_value(self)
+        d = self.filled(fill_value).view(ndarray)
+        keepdims = False if keepdims is np._NoValue else bool(keepdims)
+        return d.argmin(axis, out=out, keepdims=keepdims)
+
+    def argmax(self, axis=None, fill_value=None, out=None, *,
+                keepdims=np._NoValue):
+        """
+        Returns array of indices of the maximum values along the given axis.
+        Masked values are treated as if they had the value fill_value.
+
+        Parameters
+        ----------
+        axis : {None, integer}
+            If None, the index is into the flattened array, otherwise along
+            the specified axis
+        fill_value : scalar or None, optional
+            Value used to fill in the masked values.  If None, the output of
+            maximum_fill_value(self._data) is used instead.
+        out : {None, array}, optional
+            Array into which the result can be placed. Its type is preserved
+            and it must be of the right shape to hold the output.
+
+        Returns
+        -------
+        index_array : {integer_array}
+
+        Examples
+        --------
+        >>> import numpy as np
+        >>> a = np.arange(6).reshape(2,3)
+        >>> a.argmax()
+        5
+        >>> a.argmax(0)
+        array([1, 1, 1])
+        >>> a.argmax(1)
+        array([2, 2])
+
+        """
+        if fill_value is None:
+            fill_value = maximum_fill_value(self._data)
+        d = self.filled(fill_value).view(ndarray)
+        keepdims = False if keepdims is np._NoValue else bool(keepdims)
+        return d.argmax(axis, out=out, keepdims=keepdims)
+
+    def sort(self, axis=-1, kind=None, order=None, endwith=True,
+             fill_value=None, *, stable=False):
+        """
+        Sort the array, in-place
+
+        Parameters
+        ----------
+        a : array_like
+            Array to be sorted.
+        axis : int, optional
+            Axis along which to sort. If None, the array is flattened before
+            sorting. The default is -1, which sorts along the last axis.
+        kind : {'quicksort', 'mergesort', 'heapsort', 'stable'}, optional
+            The sorting algorithm used.
+        order : list, optional
+            When `a` is a structured array, this argument specifies which fields
+            to compare first, second, and so on.  This list does not need to
+            include all of the fields.
+        endwith : {True, False}, optional
+            Whether missing values (if any) should be treated as the largest values
+            (True) or the smallest values (False)
+            When the array contains unmasked values sorting at the same extremes of the
+            datatype, the ordering of these values and the masked values is
+            undefined.
+        fill_value : scalar or None, optional
+            Value used internally for the masked values.
+            If ``fill_value`` is not None, it supersedes ``endwith``.
+        stable : bool, optional
+            Only for compatibility with ``np.sort``. Ignored.
+
+        Returns
+        -------
+        sorted_array : ndarray
+            Array of the same type and shape as `a`.
+
+        See Also
+        --------
+        numpy.ndarray.sort : Method to sort an array in-place.
+        argsort : Indirect sort.
+        lexsort : Indirect stable sort on multiple keys.
+        searchsorted : Find elements in a sorted array.
+
+        Notes
+        -----
+        See ``sort`` for notes on the different sorting algorithms.
+
+        Examples
+        --------
+        >>> import numpy as np
+        >>> a = np.ma.array([1, 2, 5, 4, 3],mask=[0, 1, 0, 1, 0])
+        >>> # Default
+        >>> a.sort()
+        >>> a
+        masked_array(data=[1, 3, 5, --, --],
+                     mask=[False, False, False,  True,  True],
+               fill_value=999999)
+
+        >>> a = np.ma.array([1, 2, 5, 4, 3],mask=[0, 1, 0, 1, 0])
+        >>> # Put missing values in the front
+        >>> a.sort(endwith=False)
+        >>> a
+        masked_array(data=[--, --, 1, 3, 5],
+                     mask=[ True,  True, False, False, False],
+               fill_value=999999)
+
+        >>> a = np.ma.array([1, 2, 5, 4, 3],mask=[0, 1, 0, 1, 0])
+        >>> # fill_value takes over endwith
+        >>> a.sort(endwith=False, fill_value=3)
+        >>> a
+        masked_array(data=[1, --, --, 3, 5],
+                     mask=[False,  True,  True, False, False],
+               fill_value=999999)
+
+        """
+        if stable:
+            raise ValueError(
+                "`stable` parameter is not supported for masked arrays."
+            )
+
+        if self._mask is nomask:
+            ndarray.sort(self, axis=axis, kind=kind, order=order)
+            return
+
+        if self is masked:
+            return
+
+        sidx = self.argsort(axis=axis, kind=kind, order=order,
+                            fill_value=fill_value, endwith=endwith)
+
+        self[...] = np.take_along_axis(self, sidx, axis=axis)
+
+    def min(self, axis=None, out=None, fill_value=None, keepdims=np._NoValue):
+        """
+        Return the minimum along a given axis.
+
+        Parameters
+        ----------
+        axis : None or int or tuple of ints, optional
+            Axis along which to operate.  By default, ``axis`` is None and the
+            flattened input is used.
+            .. versionadded:: 1.7.0
+            If this is a tuple of ints, the minimum is selected over multiple
+            axes, instead of a single axis or all the axes as before.
+        out : array_like, optional
+            Alternative output array in which to place the result.  Must be of
+            the same shape and buffer length as the expected output.
+        fill_value : scalar or None, optional
+            Value used to fill in the masked values.
+            If None, use the output of `minimum_fill_value`.
+        keepdims : bool, optional
+            If this is set to True, the axes which are reduced are left
+            in the result as dimensions with size one. With this option,
+            the result will broadcast correctly against the array.
+
+        Returns
+        -------
+        amin : array_like
+            New array holding the result.
+            If ``out`` was specified, ``out`` is returned.
+
+        See Also
+        --------
+        ma.minimum_fill_value
+            Returns the minimum filling value for a given datatype.
+
+        Examples
+        --------
+        >>> import numpy.ma as ma
+        >>> x = [[1., -2., 3.], [0.2, -0.7, 0.1]]
+        >>> mask = [[1, 1, 0], [0, 0, 1]]
+        >>> masked_x = ma.masked_array(x, mask)
+        >>> masked_x
+        masked_array(
+          data=[[--, --, 3.0],
+                [0.2, -0.7, --]],
+          mask=[[ True,  True, False],
+                [False, False,  True]],
+          fill_value=1e+20)
+        >>> ma.min(masked_x)
+        -0.7
+        >>> ma.min(masked_x, axis=-1)
+        masked_array(data=[3.0, -0.7],
+                     mask=[False, False],
+                fill_value=1e+20)
+        >>> ma.min(masked_x, axis=0, keepdims=True)
+        masked_array(data=[[0.2, -0.7, 3.0]],
+                     mask=[[False, False, False]],
+                fill_value=1e+20)
+        >>> mask = [[1, 1, 1,], [1, 1, 1]]
+        >>> masked_x = ma.masked_array(x, mask)
+        >>> ma.min(masked_x, axis=0)
+        masked_array(data=[--, --, --],
+                     mask=[ True,  True,  True],
+                fill_value=1e+20,
+                    dtype=float64)
+        """
+        kwargs = {} if keepdims is np._NoValue else {'keepdims': keepdims}
+
+        _mask = self._mask
+        newmask = _check_mask_axis(_mask, axis, **kwargs)
+        if fill_value is None:
+            fill_value = minimum_fill_value(self)
+        # No explicit output
+        if out is None:
+            result = self.filled(fill_value).min(
+                axis=axis, out=out, **kwargs).view(type(self))
+            if result.ndim:
+                # Set the mask
+                result.__setmask__(newmask)
+                # Get rid of Infs
+                if newmask.ndim:
+                    np.copyto(result, result.fill_value, where=newmask)
+            elif newmask:
+                result = masked
+            return result
+        # Explicit output
+        result = self.filled(fill_value).min(axis=axis, out=out, **kwargs)
+        if isinstance(out, MaskedArray):
+            outmask = getmask(out)
+            if outmask is nomask:
+                outmask = out._mask = make_mask_none(out.shape)
+            outmask.flat = newmask
+        else:
+            if out.dtype.kind in 'biu':
+                errmsg = "Masked data information would be lost in one or more"\
+                         " location."
+                raise MaskError(errmsg)
+            np.copyto(out, np.nan, where=newmask)
+        return out
+
+    def max(self, axis=None, out=None, fill_value=None, keepdims=np._NoValue):
+        """
+        Return the maximum along a given axis.
+
+        Parameters
+        ----------
+        axis : None or int or tuple of ints, optional
+            Axis along which to operate.  By default, ``axis`` is None and the
+            flattened input is used.
+            .. versionadded:: 1.7.0
+            If this is a tuple of ints, the maximum is selected over multiple
+            axes, instead of a single axis or all the axes as before.
+        out : array_like, optional
+            Alternative output array in which to place the result.  Must
+            be of the same shape and buffer length as the expected output.
+        fill_value : scalar or None, optional
+            Value used to fill in the masked values.
+            If None, use the output of maximum_fill_value().
+        keepdims : bool, optional
+            If this is set to True, the axes which are reduced are left
+            in the result as dimensions with size one. With this option,
+            the result will broadcast correctly against the array.
+
+        Returns
+        -------
+        amax : array_like
+            New array holding the result.
+            If ``out`` was specified, ``out`` is returned.
+
+        See Also
+        --------
+        ma.maximum_fill_value
+            Returns the maximum filling value for a given datatype.
+
+        Examples
+        --------
+        >>> import numpy.ma as ma
+        >>> x = [[-1., 2.5], [4., -2.], [3., 0.]]
+        >>> mask = [[0, 0], [1, 0], [1, 0]]
+        >>> masked_x = ma.masked_array(x, mask)
+        >>> masked_x
+        masked_array(
+          data=[[-1.0, 2.5],
+                [--, -2.0],
+                [--, 0.0]],
+          mask=[[False, False],
+                [ True, False],
+                [ True, False]],
+          fill_value=1e+20)
+        >>> ma.max(masked_x)
+        2.5
+        >>> ma.max(masked_x, axis=0)
+        masked_array(data=[-1.0, 2.5],
+                     mask=[False, False],
+               fill_value=1e+20)
+        >>> ma.max(masked_x, axis=1, keepdims=True)
+        masked_array(
+          data=[[2.5],
+                [-2.0],
+                [0.0]],
+          mask=[[False],
+                [False],
+                [False]],
+          fill_value=1e+20)
+        >>> mask = [[1, 1], [1, 1], [1, 1]]
+        >>> masked_x = ma.masked_array(x, mask)
+        >>> ma.max(masked_x, axis=1)
+        masked_array(data=[--, --, --],
+                     mask=[ True,  True,  True],
+               fill_value=1e+20,
+                    dtype=float64)
+        """
+        kwargs = {} if keepdims is np._NoValue else {'keepdims': keepdims}
+
+        _mask = self._mask
+        newmask = _check_mask_axis(_mask, axis, **kwargs)
+        if fill_value is None:
+            fill_value = maximum_fill_value(self)
+        # No explicit output
+        if out is None:
+            result = self.filled(fill_value).max(
+                axis=axis, out=out, **kwargs).view(type(self))
+            if result.ndim:
+                # Set the mask
+                result.__setmask__(newmask)
+                # Get rid of Infs
+                if newmask.ndim:
+                    np.copyto(result, result.fill_value, where=newmask)
+            elif newmask:
+                result = masked
+            return result
+        # Explicit output
+        result = self.filled(fill_value).max(axis=axis, out=out, **kwargs)
+        if isinstance(out, MaskedArray):
+            outmask = getmask(out)
+            if outmask is nomask:
+                outmask = out._mask = make_mask_none(out.shape)
+            outmask.flat = newmask
+        else:
+
+            if out.dtype.kind in 'biu':
+                errmsg = "Masked data information would be lost in one or more"\
+                         " location."
+                raise MaskError(errmsg)
+            np.copyto(out, np.nan, where=newmask)
+        return out
+
+    def ptp(self, axis=None, out=None, fill_value=None, keepdims=False):
+        """
+        Return (maximum - minimum) along the given dimension
+        (i.e. peak-to-peak value).
+
+        .. warning::
+            `ptp` preserves the data type of the array. This means the
+            return value for an input of signed integers with n bits
+            (e.g. `np.int8`, `np.int16`, etc) is also a signed integer
+            with n bits.  In that case, peak-to-peak values greater than
+            ``2**(n-1)-1`` will be returned as negative values. An example
+            with a work-around is shown below.
+
+        Parameters
+        ----------
+        axis : {None, int}, optional
+            Axis along which to find the peaks.  If None (default) the
+            flattened array is used.
+        out : {None, array_like}, optional
+            Alternative output array in which to place the result. It must
+            have the same shape and buffer length as the expected output
+            but the type will be cast if necessary.
+        fill_value : scalar or None, optional
+            Value used to fill in the masked values.
+        keepdims : bool, optional
+            If this is set to True, the axes which are reduced are left
+            in the result as dimensions with size one. With this option,
+            the result will broadcast correctly against the array.
+
+        Returns
+        -------
+        ptp : ndarray.
+            A new array holding the result, unless ``out`` was
+            specified, in which case a reference to ``out`` is returned.
+
+        Examples
+        --------
+        >>> import numpy as np
+        >>> x = np.ma.MaskedArray([[4, 9, 2, 10],
+        ...                        [6, 9, 7, 12]])
+
+        >>> x.ptp(axis=1)
+        masked_array(data=[8, 6],
+                     mask=False,
+               fill_value=999999)
+
+        >>> x.ptp(axis=0)
+        masked_array(data=[2, 0, 5, 2],
+                     mask=False,
+               fill_value=999999)
+
+        >>> x.ptp()
+        10
+
+        This example shows that a negative value can be returned when
+        the input is an array of signed integers.
+
+        >>> y = np.ma.MaskedArray([[1, 127],
+        ...                        [0, 127],
+        ...                        [-1, 127],
+        ...                        [-2, 127]], dtype=np.int8)
+        >>> y.ptp(axis=1)
+        masked_array(data=[ 126,  127, -128, -127],
+                     mask=False,
+               fill_value=np.int64(999999),
+                    dtype=int8)
+
+        A work-around is to use the `view()` method to view the result as
+        unsigned integers with the same bit width:
+
+        >>> y.ptp(axis=1).view(np.uint8)
+        masked_array(data=[126, 127, 128, 129],
+                     mask=False,
+               fill_value=np.int64(999999),
+                    dtype=uint8)
+        """
+        if out is None:
+            result = self.max(axis=axis, fill_value=fill_value,
+                              keepdims=keepdims)
+            result -= self.min(axis=axis, fill_value=fill_value,
+                               keepdims=keepdims)
+            return result
+        out.flat = self.max(axis=axis, out=out, fill_value=fill_value,
+                            keepdims=keepdims)
+        min_value = self.min(axis=axis, fill_value=fill_value,
+                             keepdims=keepdims)
+        np.subtract(out, min_value, out=out, casting='unsafe')
+        return out
+
+    def partition(self, *args, **kwargs):
+        warnings.warn("Warning: 'partition' will ignore the 'mask' "
+                      f"of the {self.__class__.__name__}.",
+                      stacklevel=2)
+        return super().partition(*args, **kwargs)
+
+    def argpartition(self, *args, **kwargs):
+        warnings.warn("Warning: 'argpartition' will ignore the 'mask' "
+                      f"of the {self.__class__.__name__}.",
+                      stacklevel=2)
+        return super().argpartition(*args, **kwargs)
+
+    def take(self, indices, axis=None, out=None, mode='raise'):
+        """
+        """
+        (_data, _mask) = (self._data, self._mask)
+        cls = type(self)
+        # Make sure the indices are not masked
+        maskindices = getmask(indices)
+        if maskindices is not nomask:
+            indices = indices.filled(0)
+        # Get the data, promoting scalars to 0d arrays with [...] so that
+        # .view works correctly
+        if out is None:
+            out = _data.take(indices, axis=axis, mode=mode)[...].view(cls)
+        else:
+            np.take(_data, indices, axis=axis, mode=mode, out=out)
+        # Get the mask
+        if isinstance(out, MaskedArray):
+            if _mask is nomask:
+                outmask = maskindices
+            else:
+                outmask = _mask.take(indices, axis=axis, mode=mode)
+                outmask |= maskindices
+            out.__setmask__(outmask)
+        # demote 0d arrays back to scalars, for consistency with ndarray.take
+        return out[()]
+
+    # Array methods
+    copy = _arraymethod('copy')
+    diagonal = _arraymethod('diagonal')
+    flatten = _arraymethod('flatten')
+    repeat = _arraymethod('repeat')
+    squeeze = _arraymethod('squeeze')
+    swapaxes = _arraymethod('swapaxes')
+    T = property(fget=lambda self: self.transpose())
+    transpose = _arraymethod('transpose')
+
+    @property
+    def mT(self):
+        """
+        Return the matrix-transpose of the masked array.
+
+        The matrix transpose is the transpose of the last two dimensions, even
+        if the array is of higher dimension.
+
+        .. versionadded:: 2.0
+
+        Returns
+        -------
+        result: MaskedArray
+            The masked array with the last two dimensions transposed
+
+        Raises
+        ------
+        ValueError
+            If the array is of dimension less than 2.
+
+        See Also
+        --------
+        ndarray.mT:
+            Equivalent method for arrays
+        """
+
+        if self.ndim < 2:
+            raise ValueError("matrix transpose with ndim < 2 is undefined")
+
+        if self._mask is nomask:
+            return masked_array(data=self._data.mT)
+        else:
+            return masked_array(data=self.data.mT, mask=self.mask.mT)
+
+
+    def tolist(self, fill_value=None):
+        """
+        Return the data portion of the masked array as a hierarchical Python list.
+
+        Data items are converted to the nearest compatible Python type.
+        Masked values are converted to `fill_value`. If `fill_value` is None,
+        the corresponding entries in the output list will be ``None``.
+
+        Parameters
+        ----------
+        fill_value : scalar, optional
+            The value to use for invalid entries. Default is None.
+
+        Returns
+        -------
+        result : list
+            The Python list representation of the masked array.
+
+        Examples
+        --------
+        >>> import numpy as np
+        >>> x = np.ma.array([[1,2,3], [4,5,6], [7,8,9]], mask=[0] + [1,0]*4)
+        >>> x.tolist()
+        [[1, None, 3], [None, 5, None], [7, None, 9]]
+        >>> x.tolist(-999)
+        [[1, -999, 3], [-999, 5, -999], [7, -999, 9]]
+
+        """
+        _mask = self._mask
+        # No mask ? Just return .data.tolist ?
+        if _mask is nomask:
+            return self._data.tolist()
+        # Explicit fill_value: fill the array and get the list
+        if fill_value is not None:
+            return self.filled(fill_value).tolist()
+        # Structured array.
+        names = self.dtype.names
+        if names:
+            result = self._data.astype([(_, object) for _ in names])
+            for n in names:
+                result[n][_mask[n]] = None
+            return result.tolist()
+        # Standard arrays.
+        if _mask is nomask:
+            return [None]
+        # Set temps to save time when dealing w/ marrays.
+        inishape = self.shape
+        result = np.array(self._data.ravel(), dtype=object)
+        result[_mask.ravel()] = None
+        result.shape = inishape
+        return result.tolist()
+
+    def tostring(self, fill_value=None, order='C'):
+        r"""
+        A compatibility alias for `tobytes`, with exactly the same behavior.
+
+        Despite its name, it returns `bytes` not `str`\ s.
+
+        .. deprecated:: 1.19.0
+        """
+        # 2020-03-30, Numpy 1.19.0
+        warnings.warn(
+            "tostring() is deprecated. Use tobytes() instead.",
+            DeprecationWarning, stacklevel=2)
+
+        return self.tobytes(fill_value, order=order)
+
+    def tobytes(self, fill_value=None, order='C'):
+        """
+        Return the array data as a string containing the raw bytes in the array.
+
+        The array is filled with a fill value before the string conversion.
+
+        .. versionadded:: 1.9.0
+
+        Parameters
+        ----------
+        fill_value : scalar, optional
+            Value used to fill in the masked values. Default is None, in which
+            case `MaskedArray.fill_value` is used.
+        order : {'C','F','A'}, optional
+            Order of the data item in the copy. Default is 'C'.
+
+            - 'C'   -- C order (row major).
+            - 'F'   -- Fortran order (column major).
+            - 'A'   -- Any, current order of array.
+            - None  -- Same as 'A'.
+
+        See Also
+        --------
+        numpy.ndarray.tobytes
+        tolist, tofile
+
+        Notes
+        -----
+        As for `ndarray.tobytes`, information about the shape, dtype, etc.,
+        but also about `fill_value`, will be lost.
+
+        Examples
+        --------
+        >>> import numpy as np
+        >>> x = np.ma.array(np.array([[1, 2], [3, 4]]), mask=[[0, 1], [1, 0]])
+        >>> x.tobytes()
+        b'\\x01\\x00\\x00\\x00\\x00\\x00\\x00\\x00?B\\x0f\\x00\\x00\\x00\\x00\\x00?B\\x0f\\x00\\x00\\x00\\x00\\x00\\x04\\x00\\x00\\x00\\x00\\x00\\x00\\x00'
+
+        """
+        return self.filled(fill_value).tobytes(order=order)
+
+    def tofile(self, fid, sep="", format="%s"):
+        """
+        Save a masked array to a file in binary format.
+
+        .. warning::
+          This function is not implemented yet.
+
+        Raises
+        ------
+        NotImplementedError
+            When `tofile` is called.
+
+        """
+        raise NotImplementedError("MaskedArray.tofile() not implemented yet.")
+
+    def toflex(self):
+        """
+        Transforms a masked array into a flexible-type array.
+
+        The flexible type array that is returned will have two fields:
+
+        * the ``_data`` field stores the ``_data`` part of the array.
+        * the ``_mask`` field stores the ``_mask`` part of the array.
+
+        Parameters
+        ----------
+        None
+
+        Returns
+        -------
+        record : ndarray
+            A new flexible-type `ndarray` with two fields: the first element
+            containing a value, the second element containing the corresponding
+            mask boolean. The returned record shape matches self.shape.
+
+        Notes
+        -----
+        A side-effect of transforming a masked array into a flexible `ndarray` is
+        that meta information (``fill_value``, ...) will be lost.
+
+        Examples
+        --------
+        >>> import numpy as np
+        >>> x = np.ma.array([[1,2,3],[4,5,6],[7,8,9]], mask=[0] + [1,0]*4)
+        >>> x
+        masked_array(
+          data=[[1, --, 3],
+                [--, 5, --],
+                [7, --, 9]],
+          mask=[[False,  True, False],
+                [ True, False,  True],
+                [False,  True, False]],
+          fill_value=999999)
+        >>> x.toflex()
+        array([[(1, False), (2,  True), (3, False)],
+               [(4,  True), (5, False), (6,  True)],
+               [(7, False), (8,  True), (9, False)]],
+              dtype=[('_data', 'i2", (2,))])
+            # x = A[0]; y = x["A"]; then y.mask["A"].size==2
+            # and we can not say masked/unmasked.
+            # The result is no longer mvoid!
+            # See also issue #6724.
+            return masked_array(
+                data=self._data[indx], mask=m[indx],
+                fill_value=self._fill_value[indx],
+                hard_mask=self._hardmask)
+        if m is not nomask and m[indx]:
+            return masked
+        return self._data[indx]
+
+    def __setitem__(self, indx, value):
+        self._data[indx] = value
+        if self._hardmask:
+            self._mask[indx] |= getattr(value, "_mask", False)
+        else:
+            self._mask[indx] = getattr(value, "_mask", False)
+
+    def __str__(self):
+        m = self._mask
+        if m is nomask:
+            return str(self._data)
+
+        rdtype = _replace_dtype_fields(self._data.dtype, "O")
+        data_arr = super()._data
+        res = data_arr.astype(rdtype)
+        _recursive_printoption(res, self._mask, masked_print_option)
+        return str(res)
+
+    __repr__ = __str__
+
+    def __iter__(self):
+        "Defines an iterator for mvoid"
+        (_data, _mask) = (self._data, self._mask)
+        if _mask is nomask:
+            yield from _data
+        else:
+            for (d, m) in zip(_data, _mask):
+                if m:
+                    yield masked
+                else:
+                    yield d
+
+    def __len__(self):
+        return self._data.__len__()
+
+    def filled(self, fill_value=None):
+        """
+        Return a copy with masked fields filled with a given value.
+
+        Parameters
+        ----------
+        fill_value : array_like, optional
+            The value to use for invalid entries. Can be scalar or
+            non-scalar. If latter is the case, the filled array should
+            be broadcastable over input array. Default is None, in
+            which case the `fill_value` attribute is used instead.
+
+        Returns
+        -------
+        filled_void
+            A `np.void` object
+
+        See Also
+        --------
+        MaskedArray.filled
+
+        """
+        return asarray(self).filled(fill_value)[()]
+
+    def tolist(self):
+        """
+    Transforms the mvoid object into a tuple.
+
+    Masked fields are replaced by None.
+
+    Returns
+    -------
+    returned_tuple
+        Tuple of fields
+        """
+        _mask = self._mask
+        if _mask is nomask:
+            return self._data.tolist()
+        result = []
+        for (d, m) in zip(self._data, self._mask):
+            if m:
+                result.append(None)
+            else:
+                # .item() makes sure we return a standard Python object
+                result.append(d.item())
+        return tuple(result)
+
+
+##############################################################################
+#                                Shortcuts                                   #
+##############################################################################
+
+
+def isMaskedArray(x):
+    """
+    Test whether input is an instance of MaskedArray.
+
+    This function returns True if `x` is an instance of MaskedArray
+    and returns False otherwise.  Any object is accepted as input.
+
+    Parameters
+    ----------
+    x : object
+        Object to test.
+
+    Returns
+    -------
+    result : bool
+        True if `x` is a MaskedArray.
+
+    See Also
+    --------
+    isMA : Alias to isMaskedArray.
+    isarray : Alias to isMaskedArray.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> import numpy.ma as ma
+    >>> a = np.eye(3, 3)
+    >>> a
+    array([[ 1.,  0.,  0.],
+           [ 0.,  1.,  0.],
+           [ 0.,  0.,  1.]])
+    >>> m = ma.masked_values(a, 0)
+    >>> m
+    masked_array(
+      data=[[1.0, --, --],
+            [--, 1.0, --],
+            [--, --, 1.0]],
+      mask=[[False,  True,  True],
+            [ True, False,  True],
+            [ True,  True, False]],
+      fill_value=0.0)
+    >>> ma.isMaskedArray(a)
+    False
+    >>> ma.isMaskedArray(m)
+    True
+    >>> ma.isMaskedArray([0, 1, 2])
+    False
+
+    """
+    return isinstance(x, MaskedArray)
+
+
+isarray = isMaskedArray
+isMA = isMaskedArray  # backward compatibility
+
+
+class MaskedConstant(MaskedArray):
+    # the lone np.ma.masked instance
+    __singleton = None
+
+    @classmethod
+    def __has_singleton(cls):
+        # second case ensures `cls.__singleton` is not just a view on the
+        # superclass singleton
+        return cls.__singleton is not None and type(cls.__singleton) is cls
+
+    def __new__(cls):
+        if not cls.__has_singleton():
+            # We define the masked singleton as a float for higher precedence.
+            # Note that it can be tricky sometimes w/ type comparison
+            data = np.array(0.)
+            mask = np.array(True)
+
+            # prevent any modifications
+            data.flags.writeable = False
+            mask.flags.writeable = False
+
+            # don't fall back on MaskedArray.__new__(MaskedConstant), since
+            # that might confuse it - this way, the construction is entirely
+            # within our control
+            cls.__singleton = MaskedArray(data, mask=mask).view(cls)
+
+        return cls.__singleton
+
+    def __array_finalize__(self, obj):
+        if not self.__has_singleton():
+            # this handles the `.view` in __new__, which we want to copy across
+            # properties normally
+            return super().__array_finalize__(obj)
+        elif self is self.__singleton:
+            # not clear how this can happen, play it safe
+            pass
+        else:
+            # everywhere else, we want to downcast to MaskedArray, to prevent a
+            # duplicate maskedconstant.
+            self.__class__ = MaskedArray
+            MaskedArray.__array_finalize__(self, obj)
+
+    def __array_wrap__(self, obj, context=None, return_scalar=False):
+        return self.view(MaskedArray).__array_wrap__(obj, context)
+
+    def __str__(self):
+        return str(masked_print_option._display)
+
+    def __repr__(self):
+        if self is MaskedConstant.__singleton:
+            return 'masked'
+        else:
+            # it's a subclass, or something is wrong, make it obvious
+            return object.__repr__(self)
+
+    def __format__(self, format_spec):
+        # Replace ndarray.__format__ with the default, which supports no format characters.
+        # Supporting format characters is unwise here, because we do not know what type
+        # the user was expecting - better to not guess.
+        try:
+            return object.__format__(self, format_spec)
+        except TypeError:
+            # 2020-03-23, NumPy 1.19.0
+            warnings.warn(
+                "Format strings passed to MaskedConstant are ignored, but in future may "
+                "error or produce different behavior",
+                FutureWarning, stacklevel=2
+            )
+            return object.__format__(self, "")
+
+    def __reduce__(self):
+        """Override of MaskedArray's __reduce__.
+        """
+        return (self.__class__, ())
+
+    # inplace operations have no effect. We have to override them to avoid
+    # trying to modify the readonly data and mask arrays
+    def __iop__(self, other):
+        return self
+    __iadd__ = \
+    __isub__ = \
+    __imul__ = \
+    __ifloordiv__ = \
+    __itruediv__ = \
+    __ipow__ = \
+        __iop__
+    del __iop__  # don't leave this around
+
+    def copy(self, *args, **kwargs):
+        """ Copy is a no-op on the maskedconstant, as it is a scalar """
+        # maskedconstant is a scalar, so copy doesn't need to copy. There's
+        # precedent for this with `np.bool` scalars.
+        return self
+
+    def __copy__(self):
+        return self
+
+    def __deepcopy__(self, memo):
+        return self
+
+    def __setattr__(self, attr, value):
+        if not self.__has_singleton():
+            # allow the singleton to be initialized
+            return super().__setattr__(attr, value)
+        elif self is self.__singleton:
+            raise AttributeError(
+                f"attributes of {self!r} are not writeable")
+        else:
+            # duplicate instance - we can end up here from __array_finalize__,
+            # where we set the __class__ attribute
+            return super().__setattr__(attr, value)
+
+
+masked = masked_singleton = MaskedConstant()
+masked_array = MaskedArray
+
+
+def array(data, dtype=None, copy=False, order=None,
+          mask=nomask, fill_value=None, keep_mask=True,
+          hard_mask=False, shrink=True, subok=True, ndmin=0):
+    """
+    Shortcut to MaskedArray.
+
+    The options are in a different order for convenience and backwards
+    compatibility.
+
+    """
+    return MaskedArray(data, mask=mask, dtype=dtype, copy=copy,
+                       subok=subok, keep_mask=keep_mask,
+                       hard_mask=hard_mask, fill_value=fill_value,
+                       ndmin=ndmin, shrink=shrink, order=order)
+array.__doc__ = masked_array.__doc__
+
+
+def is_masked(x):
+    """
+    Determine whether input has masked values.
+
+    Accepts any object as input, but always returns False unless the
+    input is a MaskedArray containing masked values.
+
+    Parameters
+    ----------
+    x : array_like
+        Array to check for masked values.
+
+    Returns
+    -------
+    result : bool
+        True if `x` is a MaskedArray with masked values, False otherwise.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> import numpy.ma as ma
+    >>> x = ma.masked_equal([0, 1, 0, 2, 3], 0)
+    >>> x
+    masked_array(data=[--, 1, --, 2, 3],
+                 mask=[ True, False,  True, False, False],
+           fill_value=0)
+    >>> ma.is_masked(x)
+    True
+    >>> x = ma.masked_equal([0, 1, 0, 2, 3], 42)
+    >>> x
+    masked_array(data=[0, 1, 0, 2, 3],
+                 mask=False,
+           fill_value=42)
+    >>> ma.is_masked(x)
+    False
+
+    Always returns False if `x` isn't a MaskedArray.
+
+    >>> x = [False, True, False]
+    >>> ma.is_masked(x)
+    False
+    >>> x = 'a string'
+    >>> ma.is_masked(x)
+    False
+
+    """
+    m = getmask(x)
+    if m is nomask:
+        return False
+    elif m.any():
+        return True
+    return False
+
+
+##############################################################################
+#                             Extrema functions                              #
+##############################################################################
+
+
+class _extrema_operation(_MaskedUFunc):
+    """
+    Generic class for maximum/minimum functions.
+
+    .. note::
+      This is the base class for `_maximum_operation` and
+      `_minimum_operation`.
+
+    """
+    def __init__(self, ufunc, compare, fill_value):
+        super().__init__(ufunc)
+        self.compare = compare
+        self.fill_value_func = fill_value
+
+    def __call__(self, a, b):
+        "Executes the call behavior."
+
+        return where(self.compare(a, b), a, b)
+
+    def reduce(self, target, axis=np._NoValue):
+        "Reduce target along the given axis."
+        target = narray(target, copy=None, subok=True)
+        m = getmask(target)
+
+        if axis is np._NoValue and target.ndim > 1:
+            # 2017-05-06, Numpy 1.13.0: warn on axis default
+            warnings.warn(
+                f"In the future the default for ma.{self.__name__}.reduce will be axis=0, "
+                f"not the current None, to match np.{self.__name__}.reduce. "
+                "Explicitly pass 0 or None to silence this warning.",
+                MaskedArrayFutureWarning, stacklevel=2)
+            axis = None
+
+        if axis is not np._NoValue:
+            kwargs = dict(axis=axis)
+        else:
+            kwargs = dict()
+
+        if m is nomask:
+            t = self.f.reduce(target, **kwargs)
+        else:
+            target = target.filled(
+                self.fill_value_func(target)).view(type(target))
+            t = self.f.reduce(target, **kwargs)
+            m = umath.logical_and.reduce(m, **kwargs)
+            if hasattr(t, '_mask'):
+                t._mask = m
+            elif m:
+                t = masked
+        return t
+
+    def outer(self, a, b):
+        "Return the function applied to the outer product of a and b."
+        ma = getmask(a)
+        mb = getmask(b)
+        if ma is nomask and mb is nomask:
+            m = nomask
+        else:
+            ma = getmaskarray(a)
+            mb = getmaskarray(b)
+            m = logical_or.outer(ma, mb)
+        result = self.f.outer(filled(a), filled(b))
+        if not isinstance(result, MaskedArray):
+            result = result.view(MaskedArray)
+        result._mask = m
+        return result
+
+def min(obj, axis=None, out=None, fill_value=None, keepdims=np._NoValue):
+    kwargs = {} if keepdims is np._NoValue else {'keepdims': keepdims}
+
+    try:
+        return obj.min(axis=axis, fill_value=fill_value, out=out, **kwargs)
+    except (AttributeError, TypeError):
+        # If obj doesn't have a min method, or if the method doesn't accept a
+        # fill_value argument
+        return asanyarray(obj).min(axis=axis, fill_value=fill_value,
+                                   out=out, **kwargs)
+min.__doc__ = MaskedArray.min.__doc__
+
+def max(obj, axis=None, out=None, fill_value=None, keepdims=np._NoValue):
+    kwargs = {} if keepdims is np._NoValue else {'keepdims': keepdims}
+
+    try:
+        return obj.max(axis=axis, fill_value=fill_value, out=out, **kwargs)
+    except (AttributeError, TypeError):
+        # If obj doesn't have a max method, or if the method doesn't accept a
+        # fill_value argument
+        return asanyarray(obj).max(axis=axis, fill_value=fill_value,
+                                   out=out, **kwargs)
+max.__doc__ = MaskedArray.max.__doc__
+
+
+def ptp(obj, axis=None, out=None, fill_value=None, keepdims=np._NoValue):
+    kwargs = {} if keepdims is np._NoValue else {'keepdims': keepdims}
+    try:
+        return obj.ptp(axis, out=out, fill_value=fill_value, **kwargs)
+    except (AttributeError, TypeError):
+        # If obj doesn't have a ptp method or if the method doesn't accept
+        # a fill_value argument
+        return asanyarray(obj).ptp(axis=axis, fill_value=fill_value,
+                                   out=out, **kwargs)
+ptp.__doc__ = MaskedArray.ptp.__doc__
+
+
+##############################################################################
+#           Definition of functions from the corresponding methods           #
+##############################################################################
+
+
+class _frommethod:
+    """
+    Define functions from existing MaskedArray methods.
+
+    Parameters
+    ----------
+    methodname : str
+        Name of the method to transform.
+
+    """
+
+    def __init__(self, methodname, reversed=False):
+        self.__name__ = methodname
+        self.__doc__ = self.getdoc()
+        self.reversed = reversed
+
+    def getdoc(self):
+        "Return the doc of the function (from the doc of the method)."
+        meth = getattr(MaskedArray, self.__name__, None) or\
+            getattr(np, self.__name__, None)
+        signature = self.__name__ + get_object_signature(meth)
+        if meth is not None:
+            doc = """    %s\n%s""" % (
+                signature, getattr(meth, '__doc__', None))
+            return doc
+
+    def __call__(self, a, *args, **params):
+        if self.reversed:
+            args = list(args)
+            a, args[0] = args[0], a
+
+        marr = asanyarray(a)
+        method_name = self.__name__
+        method = getattr(type(marr), method_name, None)
+        if method is None:
+            # use the corresponding np function
+            method = getattr(np, method_name)
+
+        return method(marr, *args, **params)
+
+
+all = _frommethod('all')
+anomalies = anom = _frommethod('anom')
+any = _frommethod('any')
+compress = _frommethod('compress', reversed=True)
+cumprod = _frommethod('cumprod')
+cumsum = _frommethod('cumsum')
+copy = _frommethod('copy')
+diagonal = _frommethod('diagonal')
+harden_mask = _frommethod('harden_mask')
+ids = _frommethod('ids')
+maximum = _extrema_operation(umath.maximum, greater, maximum_fill_value)
+mean = _frommethod('mean')
+minimum = _extrema_operation(umath.minimum, less, minimum_fill_value)
+nonzero = _frommethod('nonzero')
+prod = _frommethod('prod')
+product = _frommethod('prod')
+ravel = _frommethod('ravel')
+repeat = _frommethod('repeat')
+shrink_mask = _frommethod('shrink_mask')
+soften_mask = _frommethod('soften_mask')
+std = _frommethod('std')
+sum = _frommethod('sum')
+swapaxes = _frommethod('swapaxes')
+#take = _frommethod('take')
+trace = _frommethod('trace')
+var = _frommethod('var')
+
+count = _frommethod('count')
+
+def take(a, indices, axis=None, out=None, mode='raise'):
+    """
+    """
+    a = masked_array(a)
+    return a.take(indices, axis=axis, out=out, mode=mode)
+
+
+def power(a, b, third=None):
+    """
+    Returns element-wise base array raised to power from second array.
+
+    This is the masked array version of `numpy.power`. For details see
+    `numpy.power`.
+
+    See Also
+    --------
+    numpy.power
+
+    Notes
+    -----
+    The *out* argument to `numpy.power` is not supported, `third` has to be
+    None.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> import numpy.ma as ma
+    >>> x = [11.2, -3.973, 0.801, -1.41]
+    >>> mask = [0, 0, 0, 1]
+    >>> masked_x = ma.masked_array(x, mask)
+    >>> masked_x
+    masked_array(data=[11.2, -3.973, 0.801, --],
+             mask=[False, False, False,  True],
+       fill_value=1e+20)
+    >>> ma.power(masked_x, 2)
+    masked_array(data=[125.43999999999998, 15.784728999999999,
+                   0.6416010000000001, --],
+             mask=[False, False, False,  True],
+       fill_value=1e+20)
+    >>> y = [-0.5, 2, 0, 17]
+    >>> masked_y = ma.masked_array(y, mask)
+    >>> masked_y
+    masked_array(data=[-0.5, 2.0, 0.0, --],
+             mask=[False, False, False,  True],
+       fill_value=1e+20)
+    >>> ma.power(masked_x, masked_y)
+    masked_array(data=[0.2988071523335984, 15.784728999999999, 1.0, --],
+             mask=[False, False, False,  True],
+       fill_value=1e+20)
+
+    """
+    if third is not None:
+        raise MaskError("3-argument power not supported.")
+    # Get the masks
+    ma = getmask(a)
+    mb = getmask(b)
+    m = mask_or(ma, mb)
+    # Get the rawdata
+    fa = getdata(a)
+    fb = getdata(b)
+    # Get the type of the result (so that we preserve subclasses)
+    if isinstance(a, MaskedArray):
+        basetype = type(a)
+    else:
+        basetype = MaskedArray
+    # Get the result and view it as a (subclass of) MaskedArray
+    with np.errstate(divide='ignore', invalid='ignore'):
+        result = np.where(m, fa, umath.power(fa, fb)).view(basetype)
+    result._update_from(a)
+    # Find where we're in trouble w/ NaNs and Infs
+    invalid = np.logical_not(np.isfinite(result.view(ndarray)))
+    # Add the initial mask
+    if m is not nomask:
+        if not result.ndim:
+            return masked
+        result._mask = np.logical_or(m, invalid)
+    # Fix the invalid parts
+    if invalid.any():
+        if not result.ndim:
+            return masked
+        elif result._mask is nomask:
+            result._mask = invalid
+        result._data[invalid] = result.fill_value
+    return result
+
+argmin = _frommethod('argmin')
+argmax = _frommethod('argmax')
+
+def argsort(a, axis=np._NoValue, kind=None, order=None, endwith=True,
+            fill_value=None, *, stable=None):
+    "Function version of the eponymous method."
+    a = np.asanyarray(a)
+
+    # 2017-04-11, Numpy 1.13.0, gh-8701: warn on axis default
+    if axis is np._NoValue:
+        axis = _deprecate_argsort_axis(a)
+
+    if isinstance(a, MaskedArray):
+        return a.argsort(axis=axis, kind=kind, order=order, endwith=endwith,
+                         fill_value=fill_value, stable=None)
+    else:
+        return a.argsort(axis=axis, kind=kind, order=order, stable=None)
+argsort.__doc__ = MaskedArray.argsort.__doc__
+
+def sort(a, axis=-1, kind=None, order=None, endwith=True, fill_value=None, *,
+         stable=None):
+    """
+    Return a sorted copy of the masked array.
+
+    Equivalent to creating a copy of the array
+    and applying the  MaskedArray ``sort()`` method.
+
+    Refer to ``MaskedArray.sort`` for the full documentation
+
+    See Also
+    --------
+    MaskedArray.sort : equivalent method
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> import numpy.ma as ma
+    >>> x = [11.2, -3.973, 0.801, -1.41]
+    >>> mask = [0, 0, 0, 1]
+    >>> masked_x = ma.masked_array(x, mask)
+    >>> masked_x
+    masked_array(data=[11.2, -3.973, 0.801, --],
+                 mask=[False, False, False,  True],
+           fill_value=1e+20)
+    >>> ma.sort(masked_x)
+    masked_array(data=[-3.973, 0.801, 11.2, --],
+                 mask=[False, False, False,  True],
+           fill_value=1e+20)
+    """
+    a = np.array(a, copy=True, subok=True)
+    if axis is None:
+        a = a.flatten()
+        axis = 0
+
+    if isinstance(a, MaskedArray):
+        a.sort(axis=axis, kind=kind, order=order, endwith=endwith,
+               fill_value=fill_value, stable=stable)
+    else:
+        a.sort(axis=axis, kind=kind, order=order, stable=stable)
+    return a
+
+
+def compressed(x):
+    """
+    Return all the non-masked data as a 1-D array.
+
+    This function is equivalent to calling the "compressed" method of a
+    `ma.MaskedArray`, see `ma.MaskedArray.compressed` for details.
+
+    See Also
+    --------
+    ma.MaskedArray.compressed : Equivalent method.
+
+    Examples
+    --------
+    >>> import numpy as np
+
+    Create an array with negative values masked:
+
+    >>> import numpy as np
+    >>> x = np.array([[1, -1, 0], [2, -1, 3], [7, 4, -1]])
+    >>> masked_x = np.ma.masked_array(x, mask=x < 0)
+    >>> masked_x
+    masked_array(
+      data=[[1, --, 0],
+            [2, --, 3],
+            [7, 4, --]],
+      mask=[[False,  True, False],
+            [False,  True, False],
+            [False, False,  True]],
+      fill_value=999999)
+
+    Compress the masked array into a 1-D array of non-masked values:
+
+    >>> np.ma.compressed(masked_x)
+    array([1, 0, 2, 3, 7, 4])
+
+    """
+    return asanyarray(x).compressed()
+
+
+def concatenate(arrays, axis=0):
+    """
+    Concatenate a sequence of arrays along the given axis.
+
+    Parameters
+    ----------
+    arrays : sequence of array_like
+        The arrays must have the same shape, except in the dimension
+        corresponding to `axis` (the first, by default).
+    axis : int, optional
+        The axis along which the arrays will be joined. Default is 0.
+
+    Returns
+    -------
+    result : MaskedArray
+        The concatenated array with any masked entries preserved.
+
+    See Also
+    --------
+    numpy.concatenate : Equivalent function in the top-level NumPy module.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> import numpy.ma as ma
+    >>> a = ma.arange(3)
+    >>> a[1] = ma.masked
+    >>> b = ma.arange(2, 5)
+    >>> a
+    masked_array(data=[0, --, 2],
+                 mask=[False,  True, False],
+           fill_value=999999)
+    >>> b
+    masked_array(data=[2, 3, 4],
+                 mask=False,
+           fill_value=999999)
+    >>> ma.concatenate([a, b])
+    masked_array(data=[0, --, 2, 2, 3, 4],
+                 mask=[False,  True, False, False, False, False],
+           fill_value=999999)
+
+    """
+    d = np.concatenate([getdata(a) for a in arrays], axis)
+    rcls = get_masked_subclass(*arrays)
+    data = d.view(rcls)
+    # Check whether one of the arrays has a non-empty mask.
+    for x in arrays:
+        if getmask(x) is not nomask:
+            break
+    else:
+        return data
+    # OK, so we have to concatenate the masks
+    dm = np.concatenate([getmaskarray(a) for a in arrays], axis)
+    dm = dm.reshape(d.shape)
+
+    # If we decide to keep a '_shrinkmask' option, we want to check that
+    # all of them are True, and then check for dm.any()
+    data._mask = _shrink_mask(dm)
+    return data
+
+
+def diag(v, k=0):
+    """
+    Extract a diagonal or construct a diagonal array.
+
+    This function is the equivalent of `numpy.diag` that takes masked
+    values into account, see `numpy.diag` for details.
+
+    See Also
+    --------
+    numpy.diag : Equivalent function for ndarrays.
+
+    Examples
+    --------
+    >>> import numpy as np
+
+    Create an array with negative values masked:
+
+    >>> import numpy as np
+    >>> x = np.array([[11.2, -3.973, 18], [0.801, -1.41, 12], [7, 33, -12]])
+    >>> masked_x = np.ma.masked_array(x, mask=x < 0)
+    >>> masked_x
+    masked_array(
+      data=[[11.2, --, 18.0],
+            [0.801, --, 12.0],
+            [7.0, 33.0, --]],
+      mask=[[False,  True, False],
+            [False,  True, False],
+            [False, False,  True]],
+      fill_value=1e+20)
+
+    Isolate the main diagonal from the masked array:
+
+    >>> np.ma.diag(masked_x)
+    masked_array(data=[11.2, --, --],
+                 mask=[False,  True,  True],
+           fill_value=1e+20)
+
+    Isolate the first diagonal below the main diagonal:
+
+    >>> np.ma.diag(masked_x, -1)
+    masked_array(data=[0.801, 33.0],
+                 mask=[False, False],
+           fill_value=1e+20)
+
+    """
+    output = np.diag(v, k).view(MaskedArray)
+    if getmask(v) is not nomask:
+        output._mask = np.diag(v._mask, k)
+    return output
+
+
+def left_shift(a, n):
+    """
+    Shift the bits of an integer to the left.
+
+    This is the masked array version of `numpy.left_shift`, for details
+    see that function.
+
+    See Also
+    --------
+    numpy.left_shift
+
+    Examples
+    --------
+    Shift with a masked array:
+
+    >>> arr = np.ma.array([10, 20, 30], mask=[False, True, False])
+    >>> np.ma.left_shift(arr, 1)
+    masked_array(data=[20, --, 60],
+                 mask=[False,  True, False],
+           fill_value=999999)
+
+    Large shift:
+
+    >>> np.ma.left_shift(10, 10)
+    masked_array(data=10240,
+                 mask=False,
+           fill_value=999999)
+
+    Shift with a scalar and an array:
+
+    >>> scalar = 10
+    >>> arr = np.ma.array([1, 2, 3], mask=[False, True, False])
+    >>> np.ma.left_shift(scalar, arr)
+    masked_array(data=[20, --, 80],
+                 mask=[False,  True, False],
+           fill_value=999999)
+
+
+    """
+    m = getmask(a)
+    if m is nomask:
+        d = umath.left_shift(filled(a), n)
+        return masked_array(d)
+    else:
+        d = umath.left_shift(filled(a, 0), n)
+        return masked_array(d, mask=m)
+
+
+def right_shift(a, n):
+    """
+    Shift the bits of an integer to the right.
+
+    This is the masked array version of `numpy.right_shift`, for details
+    see that function.
+
+    See Also
+    --------
+    numpy.right_shift
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> import numpy.ma as ma
+    >>> x = [11, 3, 8, 1]
+    >>> mask = [0, 0, 0, 1]
+    >>> masked_x = ma.masked_array(x, mask)
+    >>> masked_x
+    masked_array(data=[11, 3, 8, --],
+                 mask=[False, False, False,  True],
+           fill_value=999999)
+    >>> ma.right_shift(masked_x,1)
+    masked_array(data=[5, 1, 4, --],
+                 mask=[False, False, False,  True],
+           fill_value=999999)
+
+    """
+    m = getmask(a)
+    if m is nomask:
+        d = umath.right_shift(filled(a), n)
+        return masked_array(d)
+    else:
+        d = umath.right_shift(filled(a, 0), n)
+        return masked_array(d, mask=m)
+
+
+def put(a, indices, values, mode='raise'):
+    """
+    Set storage-indexed locations to corresponding values.
+
+    This function is equivalent to `MaskedArray.put`, see that method
+    for details.
+
+    See Also
+    --------
+    MaskedArray.put
+
+    Examples
+    --------
+    Putting values in a masked array:
+
+    >>> a = np.ma.array([1, 2, 3, 4], mask=[False, True, False, False])
+    >>> np.ma.put(a, [1, 3], [10, 30])
+    >>> a
+    masked_array(data=[ 1, 10,  3, 30],
+                 mask=False,
+           fill_value=999999)
+
+    Using put with a 2D array:
+
+    >>> b = np.ma.array([[1, 2], [3, 4]], mask=[[False, True], [False, False]])
+    >>> np.ma.put(b, [[0, 1], [1, 0]], [[10, 20], [30, 40]])
+    >>> b
+    masked_array(
+      data=[[40, 30],
+            [ 3,  4]],
+      mask=False,
+      fill_value=999999)
+
+    """
+    # We can't use 'frommethod', the order of arguments is different
+    try:
+        return a.put(indices, values, mode=mode)
+    except AttributeError:
+        return np.asarray(a).put(indices, values, mode=mode)
+
+
+def putmask(a, mask, values):  # , mode='raise'):
+    """
+    Changes elements of an array based on conditional and input values.
+
+    This is the masked array version of `numpy.putmask`, for details see
+    `numpy.putmask`.
+
+    See Also
+    --------
+    numpy.putmask
+
+    Notes
+    -----
+    Using a masked array as `values` will **not** transform a `ndarray` into
+    a `MaskedArray`.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> arr = [[1, 2], [3, 4]]
+    >>> mask = [[1, 0], [0, 0]]
+    >>> x = np.ma.array(arr, mask=mask)
+    >>> np.ma.putmask(x, x < 4, 10*x)
+    >>> x
+    masked_array(
+      data=[[--, 20],
+            [30, 4]],
+      mask=[[ True, False],
+            [False, False]],
+      fill_value=999999)
+    >>> x.data
+    array([[10, 20],
+           [30,  4]])
+
+    """
+    # We can't use 'frommethod', the order of arguments is different
+    if not isinstance(a, MaskedArray):
+        a = a.view(MaskedArray)
+    (valdata, valmask) = (getdata(values), getmask(values))
+    if getmask(a) is nomask:
+        if valmask is not nomask:
+            a._sharedmask = True
+            a._mask = make_mask_none(a.shape, a.dtype)
+            np.copyto(a._mask, valmask, where=mask)
+    elif a._hardmask:
+        if valmask is not nomask:
+            m = a._mask.copy()
+            np.copyto(m, valmask, where=mask)
+            a.mask |= m
+    else:
+        if valmask is nomask:
+            valmask = getmaskarray(values)
+        np.copyto(a._mask, valmask, where=mask)
+    np.copyto(a._data, valdata, where=mask)
+    return
+
+
+def transpose(a, axes=None):
+    """
+    Permute the dimensions of an array.
+
+    This function is exactly equivalent to `numpy.transpose`.
+
+    See Also
+    --------
+    numpy.transpose : Equivalent function in top-level NumPy module.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> import numpy.ma as ma
+    >>> x = ma.arange(4).reshape((2,2))
+    >>> x[1, 1] = ma.masked
+    >>> x
+    masked_array(
+      data=[[0, 1],
+            [2, --]],
+      mask=[[False, False],
+            [False,  True]],
+      fill_value=999999)
+
+    >>> ma.transpose(x)
+    masked_array(
+      data=[[0, 2],
+            [1, --]],
+      mask=[[False, False],
+            [False,  True]],
+      fill_value=999999)
+    """
+    # We can't use 'frommethod', as 'transpose' doesn't take keywords
+    try:
+        return a.transpose(axes)
+    except AttributeError:
+        return np.asarray(a).transpose(axes).view(MaskedArray)
+
+
+def reshape(a, new_shape, order='C'):
+    """
+    Returns an array containing the same data with a new shape.
+
+    Refer to `MaskedArray.reshape` for full documentation.
+
+    See Also
+    --------
+    MaskedArray.reshape : equivalent function
+
+    Examples
+    --------
+    Reshaping a 1-D array:
+
+    >>> a = np.ma.array([1, 2, 3, 4])
+    >>> np.ma.reshape(a, (2, 2))
+    masked_array(
+      data=[[1, 2],
+            [3, 4]],
+      mask=False,
+      fill_value=999999)
+
+    Reshaping a 2-D array:
+
+    >>> b = np.ma.array([[1, 2], [3, 4]])
+    >>> np.ma.reshape(b, (1, 4))
+    masked_array(data=[[1, 2, 3, 4]],
+                 mask=False,
+           fill_value=999999)
+
+    Reshaping a 1-D array with a mask:
+
+    >>> c = np.ma.array([1, 2, 3, 4], mask=[False, True, False, False])
+    >>> np.ma.reshape(c, (2, 2))
+    masked_array(
+      data=[[1, --],
+            [3, 4]],
+      mask=[[False,  True],
+            [False, False]],
+      fill_value=999999)
+
+    """
+    # We can't use 'frommethod', it whine about some parameters. Dmmit.
+    try:
+        return a.reshape(new_shape, order=order)
+    except AttributeError:
+        _tmp = np.asarray(a).reshape(new_shape, order=order)
+        return _tmp.view(MaskedArray)
+
+
+def resize(x, new_shape):
+    """
+    Return a new masked array with the specified size and shape.
+
+    This is the masked equivalent of the `numpy.resize` function. The new
+    array is filled with repeated copies of `x` (in the order that the
+    data are stored in memory). If `x` is masked, the new array will be
+    masked, and the new mask will be a repetition of the old one.
+
+    See Also
+    --------
+    numpy.resize : Equivalent function in the top level NumPy module.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> import numpy.ma as ma
+    >>> a = ma.array([[1, 2] ,[3, 4]])
+    >>> a[0, 1] = ma.masked
+    >>> a
+    masked_array(
+      data=[[1, --],
+            [3, 4]],
+      mask=[[False,  True],
+            [False, False]],
+      fill_value=999999)
+    >>> np.resize(a, (3, 3))
+    masked_array(
+      data=[[1, 2, 3],
+            [4, 1, 2],
+            [3, 4, 1]],
+      mask=False,
+      fill_value=999999)
+    >>> ma.resize(a, (3, 3))
+    masked_array(
+      data=[[1, --, 3],
+            [4, 1, --],
+            [3, 4, 1]],
+      mask=[[False,  True, False],
+            [False, False,  True],
+            [False, False, False]],
+      fill_value=999999)
+
+    A MaskedArray is always returned, regardless of the input type.
+
+    >>> a = np.array([[1, 2] ,[3, 4]])
+    >>> ma.resize(a, (3, 3))
+    masked_array(
+      data=[[1, 2, 3],
+            [4, 1, 2],
+            [3, 4, 1]],
+      mask=False,
+      fill_value=999999)
+
+    """
+    # We can't use _frommethods here, as N.resize is notoriously whiny.
+    m = getmask(x)
+    if m is not nomask:
+        m = np.resize(m, new_shape)
+    result = np.resize(x, new_shape).view(get_masked_subclass(x))
+    if result.ndim:
+        result._mask = m
+    return result
+
+
+def ndim(obj):
+    """
+    maskedarray version of the numpy function.
+
+    """
+    return np.ndim(getdata(obj))
+
+ndim.__doc__ = np.ndim.__doc__
+
+
+def shape(obj):
+    "maskedarray version of the numpy function."
+    return np.shape(getdata(obj))
+shape.__doc__ = np.shape.__doc__
+
+
+def size(obj, axis=None):
+    "maskedarray version of the numpy function."
+    return np.size(getdata(obj), axis)
+size.__doc__ = np.size.__doc__
+
+
+def diff(a, /, n=1, axis=-1, prepend=np._NoValue, append=np._NoValue):
+    """
+    Calculate the n-th discrete difference along the given axis.
+    The first difference is given by ``out[i] = a[i+1] - a[i]`` along
+    the given axis, higher differences are calculated by using `diff`
+    recursively.
+    Preserves the input mask.
+
+    Parameters
+    ----------
+    a : array_like
+        Input array
+    n : int, optional
+        The number of times values are differenced. If zero, the input
+        is returned as-is.
+    axis : int, optional
+        The axis along which the difference is taken, default is the
+        last axis.
+    prepend, append : array_like, optional
+        Values to prepend or append to `a` along axis prior to
+        performing the difference.  Scalar values are expanded to
+        arrays with length 1 in the direction of axis and the shape
+        of the input array in along all other axes.  Otherwise the
+        dimension and shape must match `a` except along axis.
+
+    Returns
+    -------
+    diff : MaskedArray
+        The n-th differences. The shape of the output is the same as `a`
+        except along `axis` where the dimension is smaller by `n`. The
+        type of the output is the same as the type of the difference
+        between any two elements of `a`. This is the same as the type of
+        `a` in most cases. A notable exception is `datetime64`, which
+        results in a `timedelta64` output array.
+
+    See Also
+    --------
+    numpy.diff : Equivalent function in the top-level NumPy module.
+
+    Notes
+    -----
+    Type is preserved for boolean arrays, so the result will contain
+    `False` when consecutive elements are the same and `True` when they
+    differ.
+
+    For unsigned integer arrays, the results will also be unsigned. This
+    should not be surprising, as the result is consistent with
+    calculating the difference directly:
+
+    >>> u8_arr = np.array([1, 0], dtype=np.uint8)
+    >>> np.ma.diff(u8_arr)
+    masked_array(data=[255],
+                 mask=False,
+           fill_value=np.int64(999999),
+                dtype=uint8)
+    >>> u8_arr[1,...] - u8_arr[0,...]
+    255
+
+    If this is not desirable, then the array should be cast to a larger
+    integer type first:
+
+    >>> i16_arr = u8_arr.astype(np.int16)
+    >>> np.ma.diff(i16_arr)
+    masked_array(data=[-1],
+                 mask=False,
+           fill_value=np.int64(999999),
+                dtype=int16)
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> a = np.array([1, 2, 3, 4, 7, 0, 2, 3])
+    >>> x = np.ma.masked_where(a < 2, a)
+    >>> np.ma.diff(x)
+    masked_array(data=[--, 1, 1, 3, --, --, 1],
+            mask=[ True, False, False, False,  True,  True, False],
+        fill_value=999999)
+
+    >>> np.ma.diff(x, n=2)
+    masked_array(data=[--, 0, 2, --, --, --],
+                mask=[ True, False, False,  True,  True,  True],
+        fill_value=999999)
+
+    >>> a = np.array([[1, 3, 1, 5, 10], [0, 1, 5, 6, 8]])
+    >>> x = np.ma.masked_equal(a, value=1)
+    >>> np.ma.diff(x)
+    masked_array(
+        data=[[--, --, --, 5],
+                [--, --, 1, 2]],
+        mask=[[ True,  True,  True, False],
+                [ True,  True, False, False]],
+        fill_value=1)
+
+    >>> np.ma.diff(x, axis=0)
+    masked_array(data=[[--, --, --, 1, -2]],
+            mask=[[ True,  True,  True, False, False]],
+        fill_value=1)
+
+    """
+    if n == 0:
+        return a
+    if n < 0:
+        raise ValueError("order must be non-negative but got " + repr(n))
+
+    a = np.ma.asanyarray(a)
+    if a.ndim == 0:
+        raise ValueError(
+            "diff requires input that is at least one dimensional"
+            )
+
+    combined = []
+    if prepend is not np._NoValue:
+        prepend = np.ma.asanyarray(prepend)
+        if prepend.ndim == 0:
+            shape = list(a.shape)
+            shape[axis] = 1
+            prepend = np.broadcast_to(prepend, tuple(shape))
+        combined.append(prepend)
+
+    combined.append(a)
+
+    if append is not np._NoValue:
+        append = np.ma.asanyarray(append)
+        if append.ndim == 0:
+            shape = list(a.shape)
+            shape[axis] = 1
+            append = np.broadcast_to(append, tuple(shape))
+        combined.append(append)
+
+    if len(combined) > 1:
+        a = np.ma.concatenate(combined, axis)
+
+    # GH 22465 np.diff without prepend/append preserves the mask
+    return np.diff(a, n, axis)
+
+
+##############################################################################
+#                            Extra functions                                 #
+##############################################################################
+
+
+def where(condition, x=_NoValue, y=_NoValue):
+    """
+    Return a masked array with elements from `x` or `y`, depending on condition.
+
+    .. note::
+        When only `condition` is provided, this function is identical to
+        `nonzero`. The rest of this documentation covers only the case where
+        all three arguments are provided.
+
+    Parameters
+    ----------
+    condition : array_like, bool
+        Where True, yield `x`, otherwise yield `y`.
+    x, y : array_like, optional
+        Values from which to choose. `x`, `y` and `condition` need to be
+        broadcastable to some shape.
+
+    Returns
+    -------
+    out : MaskedArray
+        An masked array with `masked` elements where the condition is masked,
+        elements from `x` where `condition` is True, and elements from `y`
+        elsewhere.
+
+    See Also
+    --------
+    numpy.where : Equivalent function in the top-level NumPy module.
+    nonzero : The function that is called when x and y are omitted
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> x = np.ma.array(np.arange(9.).reshape(3, 3), mask=[[0, 1, 0],
+    ...                                                    [1, 0, 1],
+    ...                                                    [0, 1, 0]])
+    >>> x
+    masked_array(
+      data=[[0.0, --, 2.0],
+            [--, 4.0, --],
+            [6.0, --, 8.0]],
+      mask=[[False,  True, False],
+            [ True, False,  True],
+            [False,  True, False]],
+      fill_value=1e+20)
+    >>> np.ma.where(x > 5, x, -3.1416)
+    masked_array(
+      data=[[-3.1416, --, -3.1416],
+            [--, -3.1416, --],
+            [6.0, --, 8.0]],
+      mask=[[False,  True, False],
+            [ True, False,  True],
+            [False,  True, False]],
+      fill_value=1e+20)
+
+    """
+
+    # handle the single-argument case
+    missing = (x is _NoValue, y is _NoValue).count(True)
+    if missing == 1:
+        raise ValueError("Must provide both 'x' and 'y' or neither.")
+    if missing == 2:
+        return nonzero(condition)
+
+    # we only care if the condition is true - false or masked pick y
+    cf = filled(condition, False)
+    xd = getdata(x)
+    yd = getdata(y)
+
+    # we need the full arrays here for correct final dimensions
+    cm = getmaskarray(condition)
+    xm = getmaskarray(x)
+    ym = getmaskarray(y)
+
+    # deal with the fact that masked.dtype == float64, but we don't actually
+    # want to treat it as that.
+    if x is masked and y is not masked:
+        xd = np.zeros((), dtype=yd.dtype)
+        xm = np.ones((),  dtype=ym.dtype)
+    elif y is masked and x is not masked:
+        yd = np.zeros((), dtype=xd.dtype)
+        ym = np.ones((),  dtype=xm.dtype)
+
+    data = np.where(cf, xd, yd)
+    mask = np.where(cf, xm, ym)
+    mask = np.where(cm, np.ones((), dtype=mask.dtype), mask)
+
+    # collapse the mask, for backwards compatibility
+    mask = _shrink_mask(mask)
+
+    return masked_array(data, mask=mask)
+
+
+def choose(indices, choices, out=None, mode='raise'):
+    """
+    Use an index array to construct a new array from a list of choices.
+
+    Given an array of integers and a list of n choice arrays, this method
+    will create a new array that merges each of the choice arrays.  Where a
+    value in `index` is i, the new array will have the value that choices[i]
+    contains in the same place.
+
+    Parameters
+    ----------
+    indices : ndarray of ints
+        This array must contain integers in ``[0, n-1]``, where n is the
+        number of choices.
+    choices : sequence of arrays
+        Choice arrays. The index array and all of the choices should be
+        broadcastable to the same shape.
+    out : array, optional
+        If provided, the result will be inserted into this array. It should
+        be of the appropriate shape and `dtype`.
+    mode : {'raise', 'wrap', 'clip'}, optional
+        Specifies how out-of-bounds indices will behave.
+
+        * 'raise' : raise an error
+        * 'wrap' : wrap around
+        * 'clip' : clip to the range
+
+    Returns
+    -------
+    merged_array : array
+
+    See Also
+    --------
+    choose : equivalent function
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> choice = np.array([[1,1,1], [2,2,2], [3,3,3]])
+    >>> a = np.array([2, 1, 0])
+    >>> np.ma.choose(a, choice)
+    masked_array(data=[3, 2, 1],
+                 mask=False,
+           fill_value=999999)
+
+    """
+    def fmask(x):
+        "Returns the filled array, or True if masked."
+        if x is masked:
+            return True
+        return filled(x)
+
+    def nmask(x):
+        "Returns the mask, True if ``masked``, False if ``nomask``."
+        if x is masked:
+            return True
+        return getmask(x)
+    # Get the indices.
+    c = filled(indices, 0)
+    # Get the masks.
+    masks = [nmask(x) for x in choices]
+    data = [fmask(x) for x in choices]
+    # Construct the mask
+    outputmask = np.choose(c, masks, mode=mode)
+    outputmask = make_mask(mask_or(outputmask, getmask(indices)),
+                           copy=False, shrink=True)
+    # Get the choices.
+    d = np.choose(c, data, mode=mode, out=out).view(MaskedArray)
+    if out is not None:
+        if isinstance(out, MaskedArray):
+            out.__setmask__(outputmask)
+        return out
+    d.__setmask__(outputmask)
+    return d
+
+
+def round_(a, decimals=0, out=None):
+    """
+    Return a copy of a, rounded to 'decimals' places.
+
+    When 'decimals' is negative, it specifies the number of positions
+    to the left of the decimal point.  The real and imaginary parts of
+    complex numbers are rounded separately. Nothing is done if the
+    array is not of float type and 'decimals' is greater than or equal
+    to 0.
+
+    Parameters
+    ----------
+    decimals : int
+        Number of decimals to round to. May be negative.
+    out : array_like
+        Existing array to use for output.
+        If not given, returns a default copy of a.
+
+    Notes
+    -----
+    If out is given and does not have a mask attribute, the mask of a
+    is lost!
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> import numpy.ma as ma
+    >>> x = [11.2, -3.973, 0.801, -1.41]
+    >>> mask = [0, 0, 0, 1]
+    >>> masked_x = ma.masked_array(x, mask)
+    >>> masked_x
+    masked_array(data=[11.2, -3.973, 0.801, --],
+                 mask=[False, False, False, True],
+        fill_value=1e+20)
+    >>> ma.round_(masked_x)
+    masked_array(data=[11.0, -4.0, 1.0, --],
+                 mask=[False, False, False, True],
+        fill_value=1e+20)
+    >>> ma.round(masked_x, decimals=1)
+    masked_array(data=[11.2, -4.0, 0.8, --],
+                 mask=[False, False, False, True],
+        fill_value=1e+20)
+    >>> ma.round_(masked_x, decimals=-1)
+    masked_array(data=[10.0, -0.0, 0.0, --],
+                 mask=[False, False, False, True],
+        fill_value=1e+20)
+    """
+    if out is None:
+        return np.round(a, decimals, out)
+    else:
+        np.round(getdata(a), decimals, out)
+        if hasattr(out, '_mask'):
+            out._mask = getmask(a)
+        return out
+round = round_
+
+
+def _mask_propagate(a, axis):
+    """
+    Mask whole 1-d vectors of an array that contain masked values.
+    """
+    a = array(a, subok=False)
+    m = getmask(a)
+    if m is nomask or not m.any() or axis is None:
+        return a
+    a._mask = a._mask.copy()
+    axes = normalize_axis_tuple(axis, a.ndim)
+    for ax in axes:
+        a._mask |= m.any(axis=ax, keepdims=True)
+    return a
+
+
+# Include masked dot here to avoid import problems in getting it from
+# extras.py. Note that it is not included in __all__, but rather exported
+# from extras in order to avoid backward compatibility problems.
+def dot(a, b, strict=False, out=None):
+    """
+    Return the dot product of two arrays.
+
+    This function is the equivalent of `numpy.dot` that takes masked values
+    into account. Note that `strict` and `out` are in different position
+    than in the method version. In order to maintain compatibility with the
+    corresponding method, it is recommended that the optional arguments be
+    treated as keyword only.  At some point that may be mandatory.
+
+    Parameters
+    ----------
+    a, b : masked_array_like
+        Inputs arrays.
+    strict : bool, optional
+        Whether masked data are propagated (True) or set to 0 (False) for
+        the computation. Default is False.  Propagating the mask means that
+        if a masked value appears in a row or column, the whole row or
+        column is considered masked.
+    out : masked_array, optional
+        Output argument. This must have the exact kind that would be returned
+        if it was not used. In particular, it must have the right type, must be
+        C-contiguous, and its dtype must be the dtype that would be returned
+        for `dot(a,b)`. This is a performance feature. Therefore, if these
+        conditions are not met, an exception is raised, instead of attempting
+        to be flexible.
+
+        .. versionadded:: 1.10.2
+
+    See Also
+    --------
+    numpy.dot : Equivalent function for ndarrays.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> a = np.ma.array([[1, 2, 3], [4, 5, 6]], mask=[[1, 0, 0], [0, 0, 0]])
+    >>> b = np.ma.array([[1, 2], [3, 4], [5, 6]], mask=[[1, 0], [0, 0], [0, 0]])
+    >>> np.ma.dot(a, b)
+    masked_array(
+      data=[[21, 26],
+            [45, 64]],
+      mask=[[False, False],
+            [False, False]],
+      fill_value=999999)
+    >>> np.ma.dot(a, b, strict=True)
+    masked_array(
+      data=[[--, --],
+            [--, 64]],
+      mask=[[ True,  True],
+            [ True, False]],
+      fill_value=999999)
+
+    """
+    if strict is True:
+        if np.ndim(a) == 0 or np.ndim(b) == 0:
+            pass
+        elif b.ndim == 1:
+            a = _mask_propagate(a, a.ndim - 1)
+            b = _mask_propagate(b, b.ndim - 1)
+        else:
+            a = _mask_propagate(a, a.ndim - 1)
+            b = _mask_propagate(b, b.ndim - 2)
+    am = ~getmaskarray(a)
+    bm = ~getmaskarray(b)
+
+    if out is None:
+        d = np.dot(filled(a, 0), filled(b, 0))
+        m = ~np.dot(am, bm)
+        if np.ndim(d) == 0:
+            d = np.asarray(d)
+        r = d.view(get_masked_subclass(a, b))
+        r.__setmask__(m)
+        return r
+    else:
+        d = np.dot(filled(a, 0), filled(b, 0), out._data)
+        if out.mask.shape != d.shape:
+            out._mask = np.empty(d.shape, MaskType)
+        np.dot(am, bm, out._mask)
+        np.logical_not(out._mask, out._mask)
+        return out
+
+
+def inner(a, b):
+    """
+    Returns the inner product of a and b for arrays of floating point types.
+
+    Like the generic NumPy equivalent the product sum is over the last dimension
+    of a and b. The first argument is not conjugated.
+
+    """
+    fa = filled(a, 0)
+    fb = filled(b, 0)
+    if fa.ndim == 0:
+        fa.shape = (1,)
+    if fb.ndim == 0:
+        fb.shape = (1,)
+    return np.inner(fa, fb).view(MaskedArray)
+inner.__doc__ = doc_note(np.inner.__doc__,
+                         "Masked values are replaced by 0.")
+innerproduct = inner
+
+
+def outer(a, b):
+    "maskedarray version of the numpy function."
+    fa = filled(a, 0).ravel()
+    fb = filled(b, 0).ravel()
+    d = np.outer(fa, fb)
+    ma = getmask(a)
+    mb = getmask(b)
+    if ma is nomask and mb is nomask:
+        return masked_array(d)
+    ma = getmaskarray(a)
+    mb = getmaskarray(b)
+    m = make_mask(1 - np.outer(1 - ma, 1 - mb), copy=False)
+    return masked_array(d, mask=m)
+outer.__doc__ = doc_note(np.outer.__doc__,
+                         "Masked values are replaced by 0.")
+outerproduct = outer
+
+
+def _convolve_or_correlate(f, a, v, mode, propagate_mask):
+    """
+    Helper function for ma.correlate and ma.convolve
+    """
+    if propagate_mask:
+        # results which are contributed to by either item in any pair being invalid
+        mask = (
+            f(getmaskarray(a), np.ones(np.shape(v), dtype=bool), mode=mode)
+          | f(np.ones(np.shape(a), dtype=bool), getmaskarray(v), mode=mode)
+        )
+        data = f(getdata(a), getdata(v), mode=mode)
+    else:
+        # results which are not contributed to by any pair of valid elements
+        mask = ~f(~getmaskarray(a), ~getmaskarray(v), mode=mode)
+        data = f(filled(a, 0), filled(v, 0), mode=mode)
+
+    return masked_array(data, mask=mask)
+
+
+def correlate(a, v, mode='valid', propagate_mask=True):
+    """
+    Cross-correlation of two 1-dimensional sequences.
+
+    Parameters
+    ----------
+    a, v : array_like
+        Input sequences.
+    mode : {'valid', 'same', 'full'}, optional
+        Refer to the `np.convolve` docstring.  Note that the default
+        is 'valid', unlike `convolve`, which uses 'full'.
+    propagate_mask : bool
+        If True, then a result element is masked if any masked element contributes towards it.
+        If False, then a result element is only masked if no non-masked element
+        contribute towards it
+
+    Returns
+    -------
+    out : MaskedArray
+        Discrete cross-correlation of `a` and `v`.
+
+    See Also
+    --------
+    numpy.correlate : Equivalent function in the top-level NumPy module.
+
+    Examples
+    --------
+    Basic correlation:
+
+    >>> a = np.ma.array([1, 2, 3])
+    >>> v = np.ma.array([0, 1, 0])
+    >>> np.ma.correlate(a, v, mode='valid')
+    masked_array(data=[2],
+                 mask=[False],
+           fill_value=999999)
+
+    Correlation with masked elements:
+
+    >>> a = np.ma.array([1, 2, 3], mask=[False, True, False])
+    >>> v = np.ma.array([0, 1, 0])
+    >>> np.ma.correlate(a, v, mode='valid', propagate_mask=True)
+    masked_array(data=[--],
+                 mask=[ True],
+           fill_value=999999,
+                dtype=int64)
+
+    Correlation with different modes and mixed array types:
+
+    >>> a = np.ma.array([1, 2, 3])
+    >>> v = np.ma.array([0, 1, 0])
+    >>> np.ma.correlate(a, v, mode='full')
+    masked_array(data=[0, 1, 2, 3, 0],
+                 mask=[False, False, False, False, False],
+           fill_value=999999)
+
+    """
+    return _convolve_or_correlate(np.correlate, a, v, mode, propagate_mask)
+
+
+def convolve(a, v, mode='full', propagate_mask=True):
+    """
+    Returns the discrete, linear convolution of two one-dimensional sequences.
+
+    Parameters
+    ----------
+    a, v : array_like
+        Input sequences.
+    mode : {'valid', 'same', 'full'}, optional
+        Refer to the `np.convolve` docstring.
+    propagate_mask : bool
+        If True, then if any masked element is included in the sum for a result
+        element, then the result is masked.
+        If False, then the result element is only masked if no non-masked cells
+        contribute towards it
+
+    Returns
+    -------
+    out : MaskedArray
+        Discrete, linear convolution of `a` and `v`.
+
+    See Also
+    --------
+    numpy.convolve : Equivalent function in the top-level NumPy module.
+    """
+    return _convolve_or_correlate(np.convolve, a, v, mode, propagate_mask)
+
+
+def allequal(a, b, fill_value=True):
+    """
+    Return True if all entries of a and b are equal, using
+    fill_value as a truth value where either or both are masked.
+
+    Parameters
+    ----------
+    a, b : array_like
+        Input arrays to compare.
+    fill_value : bool, optional
+        Whether masked values in a or b are considered equal (True) or not
+        (False).
+
+    Returns
+    -------
+    y : bool
+        Returns True if the two arrays are equal within the given
+        tolerance, False otherwise. If either array contains NaN,
+        then False is returned.
+
+    See Also
+    --------
+    all, any
+    numpy.ma.allclose
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> a = np.ma.array([1e10, 1e-7, 42.0], mask=[0, 0, 1])
+    >>> a
+    masked_array(data=[10000000000.0, 1e-07, --],
+                 mask=[False, False,  True],
+           fill_value=1e+20)
+
+    >>> b = np.array([1e10, 1e-7, -42.0])
+    >>> b
+    array([  1.00000000e+10,   1.00000000e-07,  -4.20000000e+01])
+    >>> np.ma.allequal(a, b, fill_value=False)
+    False
+    >>> np.ma.allequal(a, b)
+    True
+
+    """
+    m = mask_or(getmask(a), getmask(b))
+    if m is nomask:
+        x = getdata(a)
+        y = getdata(b)
+        d = umath.equal(x, y)
+        return d.all()
+    elif fill_value:
+        x = getdata(a)
+        y = getdata(b)
+        d = umath.equal(x, y)
+        dm = array(d, mask=m, copy=False)
+        return dm.filled(True).all(None)
+    else:
+        return False
+
+
+def allclose(a, b, masked_equal=True, rtol=1e-5, atol=1e-8):
+    """
+    Returns True if two arrays are element-wise equal within a tolerance.
+
+    This function is equivalent to `allclose` except that masked values
+    are treated as equal (default) or unequal, depending on the `masked_equal`
+    argument.
+
+    Parameters
+    ----------
+    a, b : array_like
+        Input arrays to compare.
+    masked_equal : bool, optional
+        Whether masked values in `a` and `b` are considered equal (True) or not
+        (False). They are considered equal by default.
+    rtol : float, optional
+        Relative tolerance. The relative difference is equal to ``rtol * b``.
+        Default is 1e-5.
+    atol : float, optional
+        Absolute tolerance. The absolute difference is equal to `atol`.
+        Default is 1e-8.
+
+    Returns
+    -------
+    y : bool
+        Returns True if the two arrays are equal within the given
+        tolerance, False otherwise. If either array contains NaN, then
+        False is returned.
+
+    See Also
+    --------
+    all, any
+    numpy.allclose : the non-masked `allclose`.
+
+    Notes
+    -----
+    If the following equation is element-wise True, then `allclose` returns
+    True::
+
+      absolute(`a` - `b`) <= (`atol` + `rtol` * absolute(`b`))
+
+    Return True if all elements of `a` and `b` are equal subject to
+    given tolerances.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> a = np.ma.array([1e10, 1e-7, 42.0], mask=[0, 0, 1])
+    >>> a
+    masked_array(data=[10000000000.0, 1e-07, --],
+                 mask=[False, False,  True],
+           fill_value=1e+20)
+    >>> b = np.ma.array([1e10, 1e-8, -42.0], mask=[0, 0, 1])
+    >>> np.ma.allclose(a, b)
+    False
+
+    >>> a = np.ma.array([1e10, 1e-8, 42.0], mask=[0, 0, 1])
+    >>> b = np.ma.array([1.00001e10, 1e-9, -42.0], mask=[0, 0, 1])
+    >>> np.ma.allclose(a, b)
+    True
+    >>> np.ma.allclose(a, b, masked_equal=False)
+    False
+
+    Masked values are not compared directly.
+
+    >>> a = np.ma.array([1e10, 1e-8, 42.0], mask=[0, 0, 1])
+    >>> b = np.ma.array([1.00001e10, 1e-9, 42.0], mask=[0, 0, 1])
+    >>> np.ma.allclose(a, b)
+    True
+    >>> np.ma.allclose(a, b, masked_equal=False)
+    False
+
+    """
+    x = masked_array(a, copy=False)
+    y = masked_array(b, copy=False)
+
+    # make sure y is an inexact type to avoid abs(MIN_INT); will cause
+    # casting of x later.
+    # NOTE: We explicitly allow timedelta, which used to work. This could
+    #       possibly be deprecated. See also gh-18286.
+    #       timedelta works if `atol` is an integer or also a timedelta.
+    #       Although, the default tolerances are unlikely to be useful
+    if y.dtype.kind != "m":
+        dtype = np.result_type(y, 1.)
+        if y.dtype != dtype:
+            y = masked_array(y, dtype=dtype, copy=False)
+
+    m = mask_or(getmask(x), getmask(y))
+    xinf = np.isinf(masked_array(x, copy=False, mask=m)).filled(False)
+    # If we have some infs, they should fall at the same place.
+    if not np.all(xinf == filled(np.isinf(y), False)):
+        return False
+    # No infs at all
+    if not np.any(xinf):
+        d = filled(less_equal(absolute(x - y), atol + rtol * absolute(y)),
+                   masked_equal)
+        return np.all(d)
+
+    if not np.all(filled(x[xinf] == y[xinf], masked_equal)):
+        return False
+    x = x[~xinf]
+    y = y[~xinf]
+
+    d = filled(less_equal(absolute(x - y), atol + rtol * absolute(y)),
+               masked_equal)
+
+    return np.all(d)
+
+
+def asarray(a, dtype=None, order=None):
+    """
+    Convert the input to a masked array of the given data-type.
+
+    No copy is performed if the input is already an `ndarray`. If `a` is
+    a subclass of `MaskedArray`, a base class `MaskedArray` is returned.
+
+    Parameters
+    ----------
+    a : array_like
+        Input data, in any form that can be converted to a masked array. This
+        includes lists, lists of tuples, tuples, tuples of tuples, tuples
+        of lists, ndarrays and masked arrays.
+    dtype : dtype, optional
+        By default, the data-type is inferred from the input data.
+    order : {'C', 'F'}, optional
+        Whether to use row-major ('C') or column-major ('FORTRAN') memory
+        representation.  Default is 'C'.
+
+    Returns
+    -------
+    out : MaskedArray
+        Masked array interpretation of `a`.
+
+    See Also
+    --------
+    asanyarray : Similar to `asarray`, but conserves subclasses.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> x = np.arange(10.).reshape(2, 5)
+    >>> x
+    array([[0., 1., 2., 3., 4.],
+           [5., 6., 7., 8., 9.]])
+    >>> np.ma.asarray(x)
+    masked_array(
+      data=[[0., 1., 2., 3., 4.],
+            [5., 6., 7., 8., 9.]],
+      mask=False,
+      fill_value=1e+20)
+    >>> type(np.ma.asarray(x))
+    
+
+    """
+    order = order or 'C'
+    return masked_array(a, dtype=dtype, copy=False, keep_mask=True,
+                        subok=False, order=order)
+
+
+def asanyarray(a, dtype=None):
+    """
+    Convert the input to a masked array, conserving subclasses.
+
+    If `a` is a subclass of `MaskedArray`, its class is conserved.
+    No copy is performed if the input is already an `ndarray`.
+
+    Parameters
+    ----------
+    a : array_like
+        Input data, in any form that can be converted to an array.
+    dtype : dtype, optional
+        By default, the data-type is inferred from the input data.
+    order : {'C', 'F'}, optional
+        Whether to use row-major ('C') or column-major ('FORTRAN') memory
+        representation.  Default is 'C'.
+
+    Returns
+    -------
+    out : MaskedArray
+        MaskedArray interpretation of `a`.
+
+    See Also
+    --------
+    asarray : Similar to `asanyarray`, but does not conserve subclass.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> x = np.arange(10.).reshape(2, 5)
+    >>> x
+    array([[0., 1., 2., 3., 4.],
+           [5., 6., 7., 8., 9.]])
+    >>> np.ma.asanyarray(x)
+    masked_array(
+      data=[[0., 1., 2., 3., 4.],
+            [5., 6., 7., 8., 9.]],
+      mask=False,
+      fill_value=1e+20)
+    >>> type(np.ma.asanyarray(x))
+    
+
+    """
+    # workaround for #8666, to preserve identity. Ideally the bottom line
+    # would handle this for us.
+    if isinstance(a, MaskedArray) and (dtype is None or dtype == a.dtype):
+        return a
+    return masked_array(a, dtype=dtype, copy=False, keep_mask=True, subok=True)
+
+
+##############################################################################
+#                               Pickling                                     #
+##############################################################################
+
+
+def fromfile(file, dtype=float, count=-1, sep=''):
+    raise NotImplementedError(
+        "fromfile() not yet implemented for a MaskedArray.")
+
+
+def fromflex(fxarray):
+    """
+    Build a masked array from a suitable flexible-type array.
+
+    The input array has to have a data-type with ``_data`` and ``_mask``
+    fields. This type of array is output by `MaskedArray.toflex`.
+
+    Parameters
+    ----------
+    fxarray : ndarray
+        The structured input array, containing ``_data`` and ``_mask``
+        fields. If present, other fields are discarded.
+
+    Returns
+    -------
+    result : MaskedArray
+        The constructed masked array.
+
+    See Also
+    --------
+    MaskedArray.toflex : Build a flexible-type array from a masked array.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> x = np.ma.array(np.arange(9).reshape(3, 3), mask=[0] + [1, 0] * 4)
+    >>> rec = x.toflex()
+    >>> rec
+    array([[(0, False), (1,  True), (2, False)],
+           [(3,  True), (4, False), (5,  True)],
+           [(6, False), (7,  True), (8, False)]],
+          dtype=[('_data', '>> x2 = np.ma.fromflex(rec)
+    >>> x2
+    masked_array(
+      data=[[0, --, 2],
+            [--, 4, --],
+            [6, --, 8]],
+      mask=[[False,  True, False],
+            [ True, False,  True],
+            [False,  True, False]],
+      fill_value=999999)
+
+    Extra fields can be present in the structured array but are discarded:
+
+    >>> dt = [('_data', '>> rec2 = np.zeros((2, 2), dtype=dt)
+    >>> rec2
+    array([[(0, False, 0.), (0, False, 0.)],
+           [(0, False, 0.), (0, False, 0.)]],
+          dtype=[('_data', '>> y = np.ma.fromflex(rec2)
+    >>> y
+    masked_array(
+      data=[[0, 0],
+            [0, 0]],
+      mask=[[False, False],
+            [False, False]],
+      fill_value=np.int64(999999),
+      dtype=int32)
+
+    """
+    return masked_array(fxarray['_data'], mask=fxarray['_mask'])
+
+
+class _convert2ma:
+
+    """
+    Convert functions from numpy to numpy.ma.
+
+    Parameters
+    ----------
+        _methodname : string
+            Name of the method to transform.
+
+    """
+    __doc__ = None
+
+    def __init__(self, funcname, np_ret, np_ma_ret, params=None):
+        self._func = getattr(np, funcname)
+        self.__doc__ = self.getdoc(np_ret, np_ma_ret)
+        self._extras = params or {}
+
+    def getdoc(self, np_ret, np_ma_ret):
+        "Return the doc of the function (from the doc of the method)."
+        doc = getattr(self._func, '__doc__', None)
+        sig = get_object_signature(self._func)
+        if doc:
+            doc = self._replace_return_type(doc, np_ret, np_ma_ret)
+            # Add the signature of the function at the beginning of the doc
+            if sig:
+                sig = "%s%s\n" % (self._func.__name__, sig)
+            doc = sig + doc
+        return doc
+
+    def _replace_return_type(self, doc, np_ret, np_ma_ret):
+        """
+        Replace documentation of ``np`` function's return type.
+
+        Replaces it with the proper type for the ``np.ma`` function.
+
+        Parameters
+        ----------
+        doc : str
+            The documentation of the ``np`` method.
+        np_ret : str
+            The return type string of the ``np`` method that we want to
+            replace. (e.g. "out : ndarray")
+        np_ma_ret : str
+            The return type string of the ``np.ma`` method.
+            (e.g. "out : MaskedArray")
+        """
+        if np_ret not in doc:
+            raise RuntimeError(
+                f"Failed to replace `{np_ret}` with `{np_ma_ret}`. "
+                f"The documentation string for return type, {np_ret}, is not "
+                f"found in the docstring for `np.{self._func.__name__}`. "
+                f"Fix the docstring for `np.{self._func.__name__}` or "
+                "update the expected string for return type."
+            )
+
+        return doc.replace(np_ret, np_ma_ret)
+
+    def __call__(self, *args, **params):
+        # Find the common parameters to the call and the definition
+        _extras = self._extras
+        common_params = set(params).intersection(_extras)
+        # Drop the common parameters from the call
+        for p in common_params:
+            _extras[p] = params.pop(p)
+        # Get the result
+        result = self._func.__call__(*args, **params).view(MaskedArray)
+        if "fill_value" in common_params:
+            result.fill_value = _extras.get("fill_value", None)
+        if "hardmask" in common_params:
+            result._hardmask = bool(_extras.get("hard_mask", False))
+        return result
+
+
+arange = _convert2ma(
+    'arange',
+    params=dict(fill_value=None, hardmask=False),
+    np_ret='arange : ndarray',
+    np_ma_ret='arange : MaskedArray',
+)
+clip = _convert2ma(
+    'clip',
+    params=dict(fill_value=None, hardmask=False),
+    np_ret='clipped_array : ndarray',
+    np_ma_ret='clipped_array : MaskedArray',
+)
+empty = _convert2ma(
+    'empty',
+    params=dict(fill_value=None, hardmask=False),
+    np_ret='out : ndarray',
+    np_ma_ret='out : MaskedArray',
+)
+empty_like = _convert2ma(
+    'empty_like',
+    np_ret='out : ndarray',
+    np_ma_ret='out : MaskedArray',
+)
+frombuffer = _convert2ma(
+    'frombuffer',
+    np_ret='out : ndarray',
+    np_ma_ret='out: MaskedArray',
+)
+fromfunction = _convert2ma(
+   'fromfunction',
+   np_ret='fromfunction : any',
+   np_ma_ret='fromfunction: MaskedArray',
+)
+identity = _convert2ma(
+    'identity',
+    params=dict(fill_value=None, hardmask=False),
+    np_ret='out : ndarray',
+    np_ma_ret='out : MaskedArray',
+)
+indices = _convert2ma(
+    'indices',
+    params=dict(fill_value=None, hardmask=False),
+    np_ret='grid : one ndarray or tuple of ndarrays',
+    np_ma_ret='grid : one MaskedArray or tuple of MaskedArrays',
+)
+ones = _convert2ma(
+    'ones',
+    params=dict(fill_value=None, hardmask=False),
+    np_ret='out : ndarray',
+    np_ma_ret='out : MaskedArray',
+)
+ones_like = _convert2ma(
+    'ones_like',
+    np_ret='out : ndarray',
+    np_ma_ret='out : MaskedArray',
+)
+squeeze = _convert2ma(
+    'squeeze',
+    params=dict(fill_value=None, hardmask=False),
+    np_ret='squeezed : ndarray',
+    np_ma_ret='squeezed : MaskedArray',
+)
+zeros = _convert2ma(
+    'zeros',
+    params=dict(fill_value=None, hardmask=False),
+    np_ret='out : ndarray',
+    np_ma_ret='out : MaskedArray',
+)
+zeros_like = _convert2ma(
+    'zeros_like',
+    np_ret='out : ndarray',
+    np_ma_ret='out : MaskedArray',
+)
+
+
+def append(a, b, axis=None):
+    """Append values to the end of an array.
+
+    .. versionadded:: 1.9.0
+
+    Parameters
+    ----------
+    a : array_like
+        Values are appended to a copy of this array.
+    b : array_like
+        These values are appended to a copy of `a`.  It must be of the
+        correct shape (the same shape as `a`, excluding `axis`).  If `axis`
+        is not specified, `b` can be any shape and will be flattened
+        before use.
+    axis : int, optional
+        The axis along which `v` are appended.  If `axis` is not given,
+        both `a` and `b` are flattened before use.
+
+    Returns
+    -------
+    append : MaskedArray
+        A copy of `a` with `b` appended to `axis`.  Note that `append`
+        does not occur in-place: a new array is allocated and filled.  If
+        `axis` is None, the result is a flattened array.
+
+    See Also
+    --------
+    numpy.append : Equivalent function in the top-level NumPy module.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> import numpy.ma as ma
+    >>> a = ma.masked_values([1, 2, 3], 2)
+    >>> b = ma.masked_values([[4, 5, 6], [7, 8, 9]], 7)
+    >>> ma.append(a, b)
+    masked_array(data=[1, --, 3, 4, 5, 6, --, 8, 9],
+                 mask=[False,  True, False, False, False, False,  True, False,
+                       False],
+           fill_value=999999)
+    """
+    return concatenate([a, b], axis)
diff --git a/venv/lib/python3.12/site-packages/numpy/ma/core.pyi b/venv/lib/python3.12/site-packages/numpy/ma/core.pyi
new file mode 100644
index 00000000..826250d4
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/ma/core.pyi
@@ -0,0 +1,467 @@
+from collections.abc import Callable
+from typing import Any, TypeVar
+from numpy import ndarray, dtype, float64
+
+from numpy import (
+    amax as amax,
+    amin as amin,
+    bool as bool,
+    expand_dims as expand_dims,
+    clip as clip,
+    indices as indices,
+    ones_like as ones_like,
+    squeeze as squeeze,
+    zeros_like as zeros_like,
+    angle as angle
+)
+
+_ShapeType_co = TypeVar("_ShapeType_co", bound=tuple[int, ...], covariant=True)
+_DType_co = TypeVar("_DType_co", bound=dtype[Any], covariant=True)
+
+__all__: list[str]
+
+MaskType = bool
+nomask: bool
+
+class MaskedArrayFutureWarning(FutureWarning): ...
+class MAError(Exception): ...
+class MaskError(MAError): ...
+
+def default_fill_value(obj): ...
+def minimum_fill_value(obj): ...
+def maximum_fill_value(obj): ...
+def set_fill_value(a, fill_value): ...
+def common_fill_value(a, b): ...
+def filled(a, fill_value=...): ...
+def getdata(a, subok=...): ...
+get_data = getdata
+
+def fix_invalid(a, mask=..., copy=..., fill_value=...): ...
+
+class _MaskedUFunc:
+    f: Any
+    __doc__: Any
+    __name__: Any
+    def __init__(self, ufunc): ...
+
+class _MaskedUnaryOperation(_MaskedUFunc):
+    fill: Any
+    domain: Any
+    def __init__(self, mufunc, fill=..., domain=...): ...
+    def __call__(self, a, *args, **kwargs): ...
+
+class _MaskedBinaryOperation(_MaskedUFunc):
+    fillx: Any
+    filly: Any
+    def __init__(self, mbfunc, fillx=..., filly=...): ...
+    def __call__(self, a, b, *args, **kwargs): ...
+    def reduce(self, target, axis=..., dtype=...): ...
+    def outer(self, a, b): ...
+    def accumulate(self, target, axis=...): ...
+
+class _DomainedBinaryOperation(_MaskedUFunc):
+    domain: Any
+    fillx: Any
+    filly: Any
+    def __init__(self, dbfunc, domain, fillx=..., filly=...): ...
+    def __call__(self, a, b, *args, **kwargs): ...
+
+exp: _MaskedUnaryOperation
+conjugate: _MaskedUnaryOperation
+sin: _MaskedUnaryOperation
+cos: _MaskedUnaryOperation
+arctan: _MaskedUnaryOperation
+arcsinh: _MaskedUnaryOperation
+sinh: _MaskedUnaryOperation
+cosh: _MaskedUnaryOperation
+tanh: _MaskedUnaryOperation
+abs: _MaskedUnaryOperation
+absolute: _MaskedUnaryOperation
+fabs: _MaskedUnaryOperation
+negative: _MaskedUnaryOperation
+floor: _MaskedUnaryOperation
+ceil: _MaskedUnaryOperation
+around: _MaskedUnaryOperation
+logical_not: _MaskedUnaryOperation
+sqrt: _MaskedUnaryOperation
+log: _MaskedUnaryOperation
+log2: _MaskedUnaryOperation
+log10: _MaskedUnaryOperation
+tan: _MaskedUnaryOperation
+arcsin: _MaskedUnaryOperation
+arccos: _MaskedUnaryOperation
+arccosh: _MaskedUnaryOperation
+arctanh: _MaskedUnaryOperation
+
+add: _MaskedBinaryOperation
+subtract: _MaskedBinaryOperation
+multiply: _MaskedBinaryOperation
+arctan2: _MaskedBinaryOperation
+equal: _MaskedBinaryOperation
+not_equal: _MaskedBinaryOperation
+less_equal: _MaskedBinaryOperation
+greater_equal: _MaskedBinaryOperation
+less: _MaskedBinaryOperation
+greater: _MaskedBinaryOperation
+logical_and: _MaskedBinaryOperation
+alltrue: _MaskedBinaryOperation
+logical_or: _MaskedBinaryOperation
+sometrue: Callable[..., Any]
+logical_xor: _MaskedBinaryOperation
+bitwise_and: _MaskedBinaryOperation
+bitwise_or: _MaskedBinaryOperation
+bitwise_xor: _MaskedBinaryOperation
+hypot: _MaskedBinaryOperation
+divide: _MaskedBinaryOperation
+true_divide: _MaskedBinaryOperation
+floor_divide: _MaskedBinaryOperation
+remainder: _MaskedBinaryOperation
+fmod: _MaskedBinaryOperation
+mod: _MaskedBinaryOperation
+
+def make_mask_descr(ndtype): ...
+def getmask(a): ...
+get_mask = getmask
+
+def getmaskarray(arr): ...
+def is_mask(m): ...
+def make_mask(m, copy=..., shrink=..., dtype=...): ...
+def make_mask_none(newshape, dtype=...): ...
+def mask_or(m1, m2, copy=..., shrink=...): ...
+def flatten_mask(mask): ...
+def masked_where(condition, a, copy=...): ...
+def masked_greater(x, value, copy=...): ...
+def masked_greater_equal(x, value, copy=...): ...
+def masked_less(x, value, copy=...): ...
+def masked_less_equal(x, value, copy=...): ...
+def masked_not_equal(x, value, copy=...): ...
+def masked_equal(x, value, copy=...): ...
+def masked_inside(x, v1, v2, copy=...): ...
+def masked_outside(x, v1, v2, copy=...): ...
+def masked_object(x, value, copy=..., shrink=...): ...
+def masked_values(x, value, rtol=..., atol=..., copy=..., shrink=...): ...
+def masked_invalid(a, copy=...): ...
+
+class _MaskedPrintOption:
+    def __init__(self, display): ...
+    def display(self): ...
+    def set_display(self, s): ...
+    def enabled(self): ...
+    def enable(self, shrink=...): ...
+
+masked_print_option: _MaskedPrintOption
+
+def flatten_structured_array(a): ...
+
+class MaskedIterator:
+    ma: Any
+    dataiter: Any
+    maskiter: Any
+    def __init__(self, ma): ...
+    def __iter__(self): ...
+    def __getitem__(self, indx): ...
+    def __setitem__(self, index, value): ...
+    def __next__(self): ...
+
+class MaskedArray(ndarray[_ShapeType_co, _DType_co]):
+    __array_priority__: Any
+    def __new__(cls, data=..., mask=..., dtype=..., copy=..., subok=..., ndmin=..., fill_value=..., keep_mask=..., hard_mask=..., shrink=..., order=...): ...
+    def __array_finalize__(self, obj): ...
+    def __array_wrap__(self, obj, context=..., return_scalar=...): ...
+    def view(self, dtype=..., type=..., fill_value=...): ...
+    def __getitem__(self, indx): ...
+    def __setitem__(self, indx, value): ...
+    @property
+    def dtype(self): ...
+    @dtype.setter
+    def dtype(self, dtype): ...
+    @property
+    def shape(self): ...
+    @shape.setter
+    def shape(self, shape): ...
+    def __setmask__(self, mask, copy=...): ...
+    @property
+    def mask(self): ...
+    @mask.setter
+    def mask(self, value): ...
+    @property
+    def recordmask(self): ...
+    @recordmask.setter
+    def recordmask(self, mask): ...
+    def harden_mask(self): ...
+    def soften_mask(self): ...
+    @property
+    def hardmask(self): ...
+    def unshare_mask(self): ...
+    @property
+    def sharedmask(self): ...
+    def shrink_mask(self): ...
+    @property
+    def baseclass(self): ...
+    data: Any
+    @property
+    def flat(self): ...
+    @flat.setter
+    def flat(self, value): ...
+    @property
+    def fill_value(self): ...
+    @fill_value.setter
+    def fill_value(self, value=...): ...
+    get_fill_value: Any
+    set_fill_value: Any
+    def filled(self, fill_value=...): ...
+    def compressed(self): ...
+    def compress(self, condition, axis=..., out=...): ...
+    def __eq__(self, other): ...
+    def __ne__(self, other): ...
+    def __ge__(self, other): ...
+    def __gt__(self, other): ...
+    def __le__(self, other): ...
+    def __lt__(self, other): ...
+    def __add__(self, other): ...
+    def __radd__(self, other): ...
+    def __sub__(self, other): ...
+    def __rsub__(self, other): ...
+    def __mul__(self, other): ...
+    def __rmul__(self, other): ...
+    def __div__(self, other): ...
+    def __truediv__(self, other): ...
+    def __rtruediv__(self, other): ...
+    def __floordiv__(self, other): ...
+    def __rfloordiv__(self, other): ...
+    def __pow__(self, other): ...
+    def __rpow__(self, other): ...
+    def __iadd__(self, other): ...
+    def __isub__(self, other): ...
+    def __imul__(self, other): ...
+    def __idiv__(self, other): ...
+    def __ifloordiv__(self, other): ...
+    def __itruediv__(self, other): ...
+    def __ipow__(self, other): ...
+    def __float__(self): ...
+    def __int__(self): ...
+    @property  # type: ignore[misc]
+    def imag(self): ...
+    get_imag: Any
+    @property  # type: ignore[misc]
+    def real(self): ...
+    get_real: Any
+    def count(self, axis=..., keepdims=...): ...
+    def ravel(self, order=...): ...
+    def reshape(self, *s, **kwargs): ...
+    def resize(self, newshape, refcheck=..., order=...): ...
+    def put(self, indices, values, mode=...): ...
+    def ids(self): ...
+    def iscontiguous(self): ...
+    def all(self, axis=..., out=..., keepdims=...): ...
+    def any(self, axis=..., out=..., keepdims=...): ...
+    def nonzero(self): ...
+    def trace(self, offset=..., axis1=..., axis2=..., dtype=..., out=...): ...
+    def dot(self, b, out=..., strict=...): ...
+    def sum(self, axis=..., dtype=..., out=..., keepdims=...): ...
+    def cumsum(self, axis=..., dtype=..., out=...): ...
+    def prod(self, axis=..., dtype=..., out=..., keepdims=...): ...
+    product: Any
+    def cumprod(self, axis=..., dtype=..., out=...): ...
+    def mean(self, axis=..., dtype=..., out=..., keepdims=...): ...
+    def anom(self, axis=..., dtype=...): ...
+    def var(self, axis=..., dtype=..., out=..., ddof=..., keepdims=...): ...
+    def std(self, axis=..., dtype=..., out=..., ddof=..., keepdims=...): ...
+    def round(self, decimals=..., out=...): ...
+    def argsort(self, axis=..., kind=..., order=..., endwith=..., fill_value=..., stable=...): ...
+    def argmin(self, axis=..., fill_value=..., out=..., *, keepdims=...): ...
+    def argmax(self, axis=..., fill_value=..., out=..., *, keepdims=...): ...
+    def sort(self, axis=..., kind=..., order=..., endwith=..., fill_value=..., stable=...): ...
+    def min(self, axis=..., out=..., fill_value=..., keepdims=...): ...
+    # NOTE: deprecated
+    # def tostring(self, fill_value=..., order=...): ...
+    def max(self, axis=..., out=..., fill_value=..., keepdims=...): ...
+    def ptp(self, axis=..., out=..., fill_value=..., keepdims=...): ...
+    def partition(self, *args, **kwargs): ...
+    def argpartition(self, *args, **kwargs): ...
+    def take(self, indices, axis=..., out=..., mode=...): ...
+    copy: Any
+    diagonal: Any
+    flatten: Any
+    repeat: Any
+    squeeze: Any
+    swapaxes: Any
+    T: Any
+    transpose: Any
+    @property  # type: ignore[misc]
+    def mT(self): ...
+    def tolist(self, fill_value=...): ...
+    def tobytes(self, fill_value=..., order=...): ...
+    def tofile(self, fid, sep=..., format=...): ...
+    def toflex(self): ...
+    torecords: Any
+    def __reduce__(self): ...
+    def __deepcopy__(self, memo=...): ...
+
+class mvoid(MaskedArray[_ShapeType_co, _DType_co]):
+    def __new__(
+        self,
+        data,
+        mask=...,
+        dtype=...,
+        fill_value=...,
+        hardmask=...,
+        copy=...,
+        subok=...,
+    ): ...
+    def __getitem__(self, indx): ...
+    def __setitem__(self, indx, value): ...
+    def __iter__(self): ...
+    def __len__(self): ...
+    def filled(self, fill_value=...): ...
+    def tolist(self): ...
+
+def isMaskedArray(x): ...
+isarray = isMaskedArray
+isMA = isMaskedArray
+
+# 0D float64 array
+class MaskedConstant(MaskedArray[Any, dtype[float64]]):
+    def __new__(cls): ...
+    __class__: Any
+    def __array_finalize__(self, obj): ...
+    def __array_wrap__(self, obj, context=..., return_scalar=...): ...
+    def __format__(self, format_spec): ...
+    def __reduce__(self): ...
+    def __iop__(self, other): ...
+    __iadd__: Any
+    __isub__: Any
+    __imul__: Any
+    __ifloordiv__: Any
+    __itruediv__: Any
+    __ipow__: Any
+    def copy(self, *args, **kwargs): ...
+    def __copy__(self): ...
+    def __deepcopy__(self, memo): ...
+    def __setattr__(self, attr, value): ...
+
+masked: MaskedConstant
+masked_singleton: MaskedConstant
+masked_array = MaskedArray
+
+def array(
+    data,
+    dtype=...,
+    copy=...,
+    order=...,
+    mask=...,
+    fill_value=...,
+    keep_mask=...,
+    hard_mask=...,
+    shrink=...,
+    subok=...,
+    ndmin=...,
+): ...
+def is_masked(x): ...
+
+class _extrema_operation(_MaskedUFunc):
+    compare: Any
+    fill_value_func: Any
+    def __init__(self, ufunc, compare, fill_value): ...
+    # NOTE: in practice `b` has a default value, but users should
+    # explicitly provide a value here as the default is deprecated
+    def __call__(self, a, b): ...
+    def reduce(self, target, axis=...): ...
+    def outer(self, a, b): ...
+
+def min(obj, axis=..., out=..., fill_value=..., keepdims=...): ...
+def max(obj, axis=..., out=..., fill_value=..., keepdims=...): ...
+def ptp(obj, axis=..., out=..., fill_value=..., keepdims=...): ...
+
+class _frommethod:
+    __name__: Any
+    __doc__: Any
+    reversed: Any
+    def __init__(self, methodname, reversed=...): ...
+    def getdoc(self): ...
+    def __call__(self, a, *args, **params): ...
+
+all: _frommethod
+anomalies: _frommethod
+anom: _frommethod
+any: _frommethod
+compress: _frommethod
+cumprod: _frommethod
+cumsum: _frommethod
+copy: _frommethod
+diagonal: _frommethod
+harden_mask: _frommethod
+ids: _frommethod
+mean: _frommethod
+nonzero: _frommethod
+prod: _frommethod
+product: _frommethod
+ravel: _frommethod
+repeat: _frommethod
+soften_mask: _frommethod
+std: _frommethod
+sum: _frommethod
+swapaxes: _frommethod
+trace: _frommethod
+var: _frommethod
+count: _frommethod
+argmin: _frommethod
+argmax: _frommethod
+
+minimum: _extrema_operation
+maximum: _extrema_operation
+
+def take(a, indices, axis=..., out=..., mode=...): ...
+def power(a, b, third=...): ...
+def argsort(a, axis=..., kind=..., order=..., endwith=..., fill_value=..., stable=...): ...
+def sort(a, axis=..., kind=..., order=..., endwith=..., fill_value=..., stable=...): ...
+def compressed(x): ...
+def concatenate(arrays, axis=...): ...
+def diag(v, k=...): ...
+def left_shift(a, n): ...
+def right_shift(a, n): ...
+def put(a, indices, values, mode=...): ...
+def putmask(a, mask, values): ...
+def transpose(a, axes=...): ...
+def reshape(a, new_shape, order=...): ...
+def resize(x, new_shape): ...
+def ndim(obj): ...
+def shape(obj): ...
+def size(obj, axis=...): ...
+def diff(a, /, n=..., axis=..., prepend=..., append=...): ...
+def where(condition, x=..., y=...): ...
+def choose(indices, choices, out=..., mode=...): ...
+def round(a, decimals=..., out=...): ...
+
+def inner(a, b): ...
+innerproduct = inner
+
+def outer(a, b): ...
+outerproduct = outer
+
+def correlate(a, v, mode=..., propagate_mask=...): ...
+def convolve(a, v, mode=..., propagate_mask=...): ...
+def allequal(a, b, fill_value=...): ...
+def allclose(a, b, masked_equal=..., rtol=..., atol=...): ...
+def asarray(a, dtype=..., order=...): ...
+def asanyarray(a, dtype=...): ...
+def fromflex(fxarray): ...
+
+class _convert2ma:
+    __doc__: Any
+    def __init__(self, funcname, params=...): ...
+    def getdoc(self): ...
+    def __call__(self, *args, **params): ...
+
+arange: _convert2ma
+empty: _convert2ma
+empty_like: _convert2ma
+frombuffer: _convert2ma
+fromfunction: _convert2ma
+identity: _convert2ma
+ones: _convert2ma
+zeros: _convert2ma
+
+def append(a, b, axis=...): ...
+def dot(a, b, strict=..., out=...): ...
+def mask_rowcols(a, axis=...): ...
diff --git a/venv/lib/python3.12/site-packages/numpy/ma/extras.py b/venv/lib/python3.12/site-packages/numpy/ma/extras.py
new file mode 100644
index 00000000..8d41e939
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/ma/extras.py
@@ -0,0 +1,2344 @@
+"""
+Masked arrays add-ons.
+
+A collection of utilities for `numpy.ma`.
+
+:author: Pierre Gerard-Marchant
+:contact: pierregm_at_uga_dot_edu
+:version: $Id: extras.py 3473 2007-10-29 15:18:13Z jarrod.millman $
+
+"""
+__all__ = [
+    'apply_along_axis', 'apply_over_axes', 'atleast_1d', 'atleast_2d',
+    'atleast_3d', 'average', 'clump_masked', 'clump_unmasked', 'column_stack',
+    'compress_cols', 'compress_nd', 'compress_rowcols', 'compress_rows',
+    'count_masked', 'corrcoef', 'cov', 'diagflat', 'dot', 'dstack', 'ediff1d',
+    'flatnotmasked_contiguous', 'flatnotmasked_edges', 'hsplit', 'hstack',
+    'isin', 'in1d', 'intersect1d', 'mask_cols', 'mask_rowcols', 'mask_rows',
+    'masked_all', 'masked_all_like', 'median', 'mr_', 'ndenumerate',
+    'notmasked_contiguous', 'notmasked_edges', 'polyfit', 'row_stack',
+    'setdiff1d', 'setxor1d', 'stack', 'unique', 'union1d', 'vander', 'vstack',
+    ]
+
+import itertools
+import warnings
+
+from . import core as ma
+from .core import (
+    MaskedArray, MAError, add, array, asarray, concatenate, filled, count,
+    getmask, getmaskarray, make_mask_descr, masked, masked_array, mask_or,
+    nomask, ones, sort, zeros, getdata, get_masked_subclass, dot
+    )
+
+import numpy as np
+from numpy import ndarray, array as nxarray
+from numpy.lib.array_utils import normalize_axis_index, normalize_axis_tuple
+from numpy.lib._function_base_impl import _ureduce
+from numpy.lib._index_tricks_impl import AxisConcatenator
+from numpy._core.numeric import normalize_axis_tuple
+
+
+def issequence(seq):
+    """
+    Is seq a sequence (ndarray, list or tuple)?
+
+    """
+    return isinstance(seq, (ndarray, tuple, list))
+
+
+def count_masked(arr, axis=None):
+    """
+    Count the number of masked elements along the given axis.
+
+    Parameters
+    ----------
+    arr : array_like
+        An array with (possibly) masked elements.
+    axis : int, optional
+        Axis along which to count. If None (default), a flattened
+        version of the array is used.
+
+    Returns
+    -------
+    count : int, ndarray
+        The total number of masked elements (axis=None) or the number
+        of masked elements along each slice of the given axis.
+
+    See Also
+    --------
+    MaskedArray.count : Count non-masked elements.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> a = np.arange(9).reshape((3,3))
+    >>> a = np.ma.array(a)
+    >>> a[1, 0] = np.ma.masked
+    >>> a[1, 2] = np.ma.masked
+    >>> a[2, 1] = np.ma.masked
+    >>> a
+    masked_array(
+      data=[[0, 1, 2],
+            [--, 4, --],
+            [6, --, 8]],
+      mask=[[False, False, False],
+            [ True, False,  True],
+            [False,  True, False]],
+      fill_value=999999)
+    >>> np.ma.count_masked(a)
+    3
+
+    When the `axis` keyword is used an array is returned.
+
+    >>> np.ma.count_masked(a, axis=0)
+    array([1, 1, 1])
+    >>> np.ma.count_masked(a, axis=1)
+    array([0, 2, 1])
+
+    """
+    m = getmaskarray(arr)
+    return m.sum(axis)
+
+
+def masked_all(shape, dtype=float):
+    """
+    Empty masked array with all elements masked.
+
+    Return an empty masked array of the given shape and dtype, where all the
+    data are masked.
+
+    Parameters
+    ----------
+    shape : int or tuple of ints
+        Shape of the required MaskedArray, e.g., ``(2, 3)`` or ``2``.
+    dtype : dtype, optional
+        Data type of the output.
+
+    Returns
+    -------
+    a : MaskedArray
+        A masked array with all data masked.
+
+    See Also
+    --------
+    masked_all_like : Empty masked array modelled on an existing array.
+
+    Notes
+    -----
+    Unlike other masked array creation functions (e.g. `numpy.ma.zeros`,
+    `numpy.ma.ones`, `numpy.ma.full`), `masked_all` does not initialize the
+    values of the array, and may therefore be marginally faster. However,
+    the values stored in the newly allocated array are arbitrary. For
+    reproducible behavior, be sure to set each element of the array before
+    reading.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> np.ma.masked_all((3, 3))
+    masked_array(
+      data=[[--, --, --],
+            [--, --, --],
+            [--, --, --]],
+      mask=[[ True,  True,  True],
+            [ True,  True,  True],
+            [ True,  True,  True]],
+      fill_value=1e+20,
+      dtype=float64)
+
+    The `dtype` parameter defines the underlying data type.
+
+    >>> a = np.ma.masked_all((3, 3))
+    >>> a.dtype
+    dtype('float64')
+    >>> a = np.ma.masked_all((3, 3), dtype=np.int32)
+    >>> a.dtype
+    dtype('int32')
+
+    """
+    a = masked_array(np.empty(shape, dtype),
+                     mask=np.ones(shape, make_mask_descr(dtype)))
+    return a
+
+
+def masked_all_like(arr):
+    """
+    Empty masked array with the properties of an existing array.
+
+    Return an empty masked array of the same shape and dtype as
+    the array `arr`, where all the data are masked.
+
+    Parameters
+    ----------
+    arr : ndarray
+        An array describing the shape and dtype of the required MaskedArray.
+
+    Returns
+    -------
+    a : MaskedArray
+        A masked array with all data masked.
+
+    Raises
+    ------
+    AttributeError
+        If `arr` doesn't have a shape attribute (i.e. not an ndarray)
+
+    See Also
+    --------
+    masked_all : Empty masked array with all elements masked.
+
+    Notes
+    -----
+    Unlike other masked array creation functions (e.g. `numpy.ma.zeros_like`,
+    `numpy.ma.ones_like`, `numpy.ma.full_like`), `masked_all_like` does not
+    initialize the values of the array, and may therefore be marginally
+    faster. However, the values stored in the newly allocated array are
+    arbitrary. For reproducible behavior, be sure to set each element of the
+    array before reading.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> arr = np.zeros((2, 3), dtype=np.float32)
+    >>> arr
+    array([[0., 0., 0.],
+           [0., 0., 0.]], dtype=float32)
+    >>> np.ma.masked_all_like(arr)
+    masked_array(
+      data=[[--, --, --],
+            [--, --, --]],
+      mask=[[ True,  True,  True],
+            [ True,  True,  True]],
+      fill_value=np.float64(1e+20),
+      dtype=float32)
+
+    The dtype of the masked array matches the dtype of `arr`.
+
+    >>> arr.dtype
+    dtype('float32')
+    >>> np.ma.masked_all_like(arr).dtype
+    dtype('float32')
+
+    """
+    a = np.empty_like(arr).view(MaskedArray)
+    a._mask = np.ones(a.shape, dtype=make_mask_descr(a.dtype))
+    return a
+
+
+#####--------------------------------------------------------------------------
+#---- --- Standard functions ---
+#####--------------------------------------------------------------------------
+class _fromnxfunction:
+    """
+    Defines a wrapper to adapt NumPy functions to masked arrays.
+
+
+    An instance of `_fromnxfunction` can be called with the same parameters
+    as the wrapped NumPy function. The docstring of `newfunc` is adapted from
+    the wrapped function as well, see `getdoc`.
+
+    This class should not be used directly. Instead, one of its extensions that
+    provides support for a specific type of input should be used.
+
+    Parameters
+    ----------
+    funcname : str
+        The name of the function to be adapted. The function should be
+        in the NumPy namespace (i.e. ``np.funcname``).
+
+    """
+
+    def __init__(self, funcname):
+        self.__name__ = funcname
+        self.__doc__ = self.getdoc()
+
+    def getdoc(self):
+        """
+        Retrieve the docstring and signature from the function.
+
+        The ``__doc__`` attribute of the function is used as the docstring for
+        the new masked array version of the function. A note on application
+        of the function to the mask is appended.
+
+        Parameters
+        ----------
+        None
+
+        """
+        npfunc = getattr(np, self.__name__, None)
+        doc = getattr(npfunc, '__doc__', None)
+        if doc:
+            sig = ma.get_object_signature(npfunc)
+            doc = ma.doc_note(doc, "The function is applied to both the _data "
+                                   "and the _mask, if any.")
+            if sig:
+                sig = self.__name__ + sig + "\n\n"
+            return sig + doc
+        return
+
+    def __call__(self, *args, **params):
+        pass
+
+
+class _fromnxfunction_single(_fromnxfunction):
+    """
+    A version of `_fromnxfunction` that is called with a single array
+    argument followed by auxiliary args that are passed verbatim for
+    both the data and mask calls.
+    """
+    def __call__(self, x, *args, **params):
+        func = getattr(np, self.__name__)
+        if isinstance(x, ndarray):
+            _d = func(x.__array__(), *args, **params)
+            _m = func(getmaskarray(x), *args, **params)
+            return masked_array(_d, mask=_m)
+        else:
+            _d = func(np.asarray(x), *args, **params)
+            _m = func(getmaskarray(x), *args, **params)
+            return masked_array(_d, mask=_m)
+
+
+class _fromnxfunction_seq(_fromnxfunction):
+    """
+    A version of `_fromnxfunction` that is called with a single sequence
+    of arrays followed by auxiliary args that are passed verbatim for
+    both the data and mask calls.
+    """
+    def __call__(self, x, *args, **params):
+        func = getattr(np, self.__name__)
+        _d = func(tuple([np.asarray(a) for a in x]), *args, **params)
+        _m = func(tuple([getmaskarray(a) for a in x]), *args, **params)
+        return masked_array(_d, mask=_m)
+
+
+class _fromnxfunction_args(_fromnxfunction):
+    """
+    A version of `_fromnxfunction` that is called with multiple array
+    arguments. The first non-array-like input marks the beginning of the
+    arguments that are passed verbatim for both the data and mask calls.
+    Array arguments are processed independently and the results are
+    returned in a list. If only one array is found, the return value is
+    just the processed array instead of a list.
+    """
+    def __call__(self, *args, **params):
+        func = getattr(np, self.__name__)
+        arrays = []
+        args = list(args)
+        while len(args) > 0 and issequence(args[0]):
+            arrays.append(args.pop(0))
+        res = []
+        for x in arrays:
+            _d = func(np.asarray(x), *args, **params)
+            _m = func(getmaskarray(x), *args, **params)
+            res.append(masked_array(_d, mask=_m))
+        if len(arrays) == 1:
+            return res[0]
+        return res
+
+
+class _fromnxfunction_allargs(_fromnxfunction):
+    """
+    A version of `_fromnxfunction` that is called with multiple array
+    arguments. Similar to `_fromnxfunction_args` except that all args
+    are converted to arrays even if they are not so already. This makes
+    it possible to process scalars as 1-D arrays. Only keyword arguments
+    are passed through verbatim for the data and mask calls. Arrays
+    arguments are processed independently and the results are returned
+    in a list. If only one arg is present, the return value is just the
+    processed array instead of a list.
+    """
+    def __call__(self, *args, **params):
+        func = getattr(np, self.__name__)
+        res = []
+        for x in args:
+            _d = func(np.asarray(x), **params)
+            _m = func(getmaskarray(x), **params)
+            res.append(masked_array(_d, mask=_m))
+        if len(args) == 1:
+            return res[0]
+        return res
+
+
+atleast_1d = _fromnxfunction_allargs('atleast_1d')
+atleast_2d = _fromnxfunction_allargs('atleast_2d')
+atleast_3d = _fromnxfunction_allargs('atleast_3d')
+
+vstack = row_stack = _fromnxfunction_seq('vstack')
+hstack = _fromnxfunction_seq('hstack')
+column_stack = _fromnxfunction_seq('column_stack')
+dstack = _fromnxfunction_seq('dstack')
+stack = _fromnxfunction_seq('stack')
+
+hsplit = _fromnxfunction_single('hsplit')
+
+diagflat = _fromnxfunction_single('diagflat')
+
+
+#####--------------------------------------------------------------------------
+#----
+#####--------------------------------------------------------------------------
+def flatten_inplace(seq):
+    """Flatten a sequence in place."""
+    k = 0
+    while (k != len(seq)):
+        while hasattr(seq[k], '__iter__'):
+            seq[k:(k + 1)] = seq[k]
+        k += 1
+    return seq
+
+
+def apply_along_axis(func1d, axis, arr, *args, **kwargs):
+    """
+    (This docstring should be overwritten)
+    """
+    arr = array(arr, copy=False, subok=True)
+    nd = arr.ndim
+    axis = normalize_axis_index(axis, nd)
+    ind = [0] * (nd - 1)
+    i = np.zeros(nd, 'O')
+    indlist = list(range(nd))
+    indlist.remove(axis)
+    i[axis] = slice(None, None)
+    outshape = np.asarray(arr.shape).take(indlist)
+    i.put(indlist, ind)
+    res = func1d(arr[tuple(i.tolist())], *args, **kwargs)
+    #  if res is a number, then we have a smaller output array
+    asscalar = np.isscalar(res)
+    if not asscalar:
+        try:
+            len(res)
+        except TypeError:
+            asscalar = True
+    # Note: we shouldn't set the dtype of the output from the first result
+    # so we force the type to object, and build a list of dtypes.  We'll
+    # just take the largest, to avoid some downcasting
+    dtypes = []
+    if asscalar:
+        dtypes.append(np.asarray(res).dtype)
+        outarr = zeros(outshape, object)
+        outarr[tuple(ind)] = res
+        Ntot = np.prod(outshape)
+        k = 1
+        while k < Ntot:
+            # increment the index
+            ind[-1] += 1
+            n = -1
+            while (ind[n] >= outshape[n]) and (n > (1 - nd)):
+                ind[n - 1] += 1
+                ind[n] = 0
+                n -= 1
+            i.put(indlist, ind)
+            res = func1d(arr[tuple(i.tolist())], *args, **kwargs)
+            outarr[tuple(ind)] = res
+            dtypes.append(asarray(res).dtype)
+            k += 1
+    else:
+        res = array(res, copy=False, subok=True)
+        j = i.copy()
+        j[axis] = ([slice(None, None)] * res.ndim)
+        j.put(indlist, ind)
+        Ntot = np.prod(outshape)
+        holdshape = outshape
+        outshape = list(arr.shape)
+        outshape[axis] = res.shape
+        dtypes.append(asarray(res).dtype)
+        outshape = flatten_inplace(outshape)
+        outarr = zeros(outshape, object)
+        outarr[tuple(flatten_inplace(j.tolist()))] = res
+        k = 1
+        while k < Ntot:
+            # increment the index
+            ind[-1] += 1
+            n = -1
+            while (ind[n] >= holdshape[n]) and (n > (1 - nd)):
+                ind[n - 1] += 1
+                ind[n] = 0
+                n -= 1
+            i.put(indlist, ind)
+            j.put(indlist, ind)
+            res = func1d(arr[tuple(i.tolist())], *args, **kwargs)
+            outarr[tuple(flatten_inplace(j.tolist()))] = res
+            dtypes.append(asarray(res).dtype)
+            k += 1
+    max_dtypes = np.dtype(np.asarray(dtypes).max())
+    if not hasattr(arr, '_mask'):
+        result = np.asarray(outarr, dtype=max_dtypes)
+    else:
+        result = asarray(outarr, dtype=max_dtypes)
+        result.fill_value = ma.default_fill_value(result)
+    return result
+apply_along_axis.__doc__ = np.apply_along_axis.__doc__
+
+
+def apply_over_axes(func, a, axes):
+    """
+    (This docstring will be overwritten)
+    """
+    val = asarray(a)
+    N = a.ndim
+    if array(axes).ndim == 0:
+        axes = (axes,)
+    for axis in axes:
+        if axis < 0:
+            axis = N + axis
+        args = (val, axis)
+        res = func(*args)
+        if res.ndim == val.ndim:
+            val = res
+        else:
+            res = ma.expand_dims(res, axis)
+            if res.ndim == val.ndim:
+                val = res
+            else:
+                raise ValueError("function is not returning "
+                        "an array of the correct shape")
+    return val
+
+
+if apply_over_axes.__doc__ is not None:
+    apply_over_axes.__doc__ = np.apply_over_axes.__doc__[
+        :np.apply_over_axes.__doc__.find('Notes')].rstrip() + \
+    """
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> a = np.ma.arange(24).reshape(2,3,4)
+    >>> a[:,0,1] = np.ma.masked
+    >>> a[:,1,:] = np.ma.masked
+    >>> a
+    masked_array(
+      data=[[[0, --, 2, 3],
+             [--, --, --, --],
+             [8, 9, 10, 11]],
+            [[12, --, 14, 15],
+             [--, --, --, --],
+             [20, 21, 22, 23]]],
+      mask=[[[False,  True, False, False],
+             [ True,  True,  True,  True],
+             [False, False, False, False]],
+            [[False,  True, False, False],
+             [ True,  True,  True,  True],
+             [False, False, False, False]]],
+      fill_value=999999)
+    >>> np.ma.apply_over_axes(np.ma.sum, a, [0,2])
+    masked_array(
+      data=[[[46],
+             [--],
+             [124]]],
+      mask=[[[False],
+             [ True],
+             [False]]],
+      fill_value=999999)
+
+    Tuple axis arguments to ufuncs are equivalent:
+
+    >>> np.ma.sum(a, axis=(0,2)).reshape((1,-1,1))
+    masked_array(
+      data=[[[46],
+             [--],
+             [124]]],
+      mask=[[[False],
+             [ True],
+             [False]]],
+      fill_value=999999)
+    """
+
+
+def average(a, axis=None, weights=None, returned=False, *,
+            keepdims=np._NoValue):
+    """
+    Return the weighted average of array over the given axis.
+
+    Parameters
+    ----------
+    a : array_like
+        Data to be averaged.
+        Masked entries are not taken into account in the computation.
+    axis : None or int or tuple of ints, optional
+        Axis or axes along which to average `a`.  The default,
+        `axis=None`, will average over all of the elements of the input array.
+        If axis is a tuple of ints, averaging is performed on all of the axes
+        specified in the tuple instead of a single axis or all the axes as
+        before.
+    weights : array_like, optional
+        An array of weights associated with the values in `a`. Each value in
+        `a` contributes to the average according to its associated weight.
+        The array of weights must be the same shape as `a` if no axis is
+        specified, otherwise the weights must have dimensions and shape
+        consistent with `a` along the specified axis.
+        If `weights=None`, then all data in `a` are assumed to have a
+        weight equal to one.
+        The calculation is::
+
+            avg = sum(a * weights) / sum(weights)
+
+        where the sum is over all included elements.
+        The only constraint on the values of `weights` is that `sum(weights)`
+        must not be 0.
+    returned : bool, optional
+        Flag indicating whether a tuple ``(result, sum of weights)``
+        should be returned as output (True), or just the result (False).
+        Default is False.
+    keepdims : bool, optional
+        If this is set to True, the axes which are reduced are left
+        in the result as dimensions with size one. With this option,
+        the result will broadcast correctly against the original `a`.
+        *Note:* `keepdims` will not work with instances of `numpy.matrix`
+        or other classes whose methods do not support `keepdims`.
+
+        .. versionadded:: 1.23.0
+
+    Returns
+    -------
+    average, [sum_of_weights] : (tuple of) scalar or MaskedArray
+        The average along the specified axis. When returned is `True`,
+        return a tuple with the average as the first element and the sum
+        of the weights as the second element. The return type is `np.float64`
+        if `a` is of integer type and floats smaller than `float64`, or the
+        input data-type, otherwise. If returned, `sum_of_weights` is always
+        `float64`.
+
+    Raises
+    ------
+    ZeroDivisionError
+        When all weights along axis are zero. See `numpy.ma.average` for a
+        version robust to this type of error.
+    TypeError
+        When `weights` does not have the same shape as `a`, and `axis=None`.
+    ValueError
+        When `weights` does not have dimensions and shape consistent with `a`
+        along specified `axis`.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> a = np.ma.array([1., 2., 3., 4.], mask=[False, False, True, True])
+    >>> np.ma.average(a, weights=[3, 1, 0, 0])
+    1.25
+
+    >>> x = np.ma.arange(6.).reshape(3, 2)
+    >>> x
+    masked_array(
+      data=[[0., 1.],
+            [2., 3.],
+            [4., 5.]],
+      mask=False,
+      fill_value=1e+20)
+    >>> data = np.arange(8).reshape((2, 2, 2))
+    >>> data
+    array([[[0, 1],
+            [2, 3]],
+           [[4, 5],
+            [6, 7]]])
+    >>> np.ma.average(data, axis=(0, 1), weights=[[1./4, 3./4], [1., 1./2]])
+    masked_array(data=[3.4, 4.4],
+             mask=[False, False],
+       fill_value=1e+20)
+    >>> np.ma.average(data, axis=0, weights=[[1./4, 3./4], [1., 1./2]])
+    Traceback (most recent call last):
+        ...
+    ValueError: Shape of weights must be consistent
+    with shape of a along specified axis.
+
+    >>> avg, sumweights = np.ma.average(x, axis=0, weights=[1, 2, 3],
+    ...                                 returned=True)
+    >>> avg
+    masked_array(data=[2.6666666666666665, 3.6666666666666665],
+                 mask=[False, False],
+           fill_value=1e+20)
+
+    With ``keepdims=True``, the following result has shape (3, 1).
+
+    >>> np.ma.average(x, axis=1, keepdims=True)
+    masked_array(
+      data=[[0.5],
+            [2.5],
+            [4.5]],
+      mask=False,
+      fill_value=1e+20)
+    """
+    a = asarray(a)
+    m = getmask(a)
+
+    if axis is not None:
+        axis = normalize_axis_tuple(axis, a.ndim, argname="axis")
+
+    if keepdims is np._NoValue:
+        # Don't pass on the keepdims argument if one wasn't given.
+        keepdims_kw = {}
+    else:
+        keepdims_kw = {'keepdims': keepdims}
+
+    if weights is None:
+        avg = a.mean(axis, **keepdims_kw)
+        scl = avg.dtype.type(a.count(axis))
+    else:
+        wgt = asarray(weights)
+
+        if issubclass(a.dtype.type, (np.integer, np.bool)):
+            result_dtype = np.result_type(a.dtype, wgt.dtype, 'f8')
+        else:
+            result_dtype = np.result_type(a.dtype, wgt.dtype)
+
+        # Sanity checks
+        if a.shape != wgt.shape:
+            if axis is None:
+                raise TypeError(
+                    "Axis must be specified when shapes of a and weights "
+                    "differ.")
+            if wgt.shape != tuple(a.shape[ax] for ax in axis):
+                raise ValueError(
+                    "Shape of weights must be consistent with "
+                    "shape of a along specified axis.")
+
+            # setup wgt to broadcast along axis
+            wgt = wgt.transpose(np.argsort(axis))
+            wgt = wgt.reshape(tuple((s if ax in axis else 1)
+                                    for ax, s in enumerate(a.shape)))
+
+        if m is not nomask:
+            wgt = wgt*(~a.mask)
+            wgt.mask |= a.mask
+
+        scl = wgt.sum(axis=axis, dtype=result_dtype, **keepdims_kw)
+        avg = np.multiply(a, wgt,
+                          dtype=result_dtype).sum(axis, **keepdims_kw) / scl
+
+    if returned:
+        if scl.shape != avg.shape:
+            scl = np.broadcast_to(scl, avg.shape).copy()
+        return avg, scl
+    else:
+        return avg
+
+
+def median(a, axis=None, out=None, overwrite_input=False, keepdims=False):
+    """
+    Compute the median along the specified axis.
+
+    Returns the median of the array elements.
+
+    Parameters
+    ----------
+    a : array_like
+        Input array or object that can be converted to an array.
+    axis : int, optional
+        Axis along which the medians are computed. The default (None) is
+        to compute the median along a flattened version of the array.
+    out : ndarray, optional
+        Alternative output array in which to place the result. It must
+        have the same shape and buffer length as the expected output
+        but the type will be cast if necessary.
+    overwrite_input : bool, optional
+        If True, then allow use of memory of input array (a) for
+        calculations. The input array will be modified by the call to
+        median. This will save memory when you do not need to preserve
+        the contents of the input array. Treat the input as undefined,
+        but it will probably be fully or partially sorted. Default is
+        False. Note that, if `overwrite_input` is True, and the input
+        is not already an `ndarray`, an error will be raised.
+    keepdims : bool, optional
+        If this is set to True, the axes which are reduced are left
+        in the result as dimensions with size one. With this option,
+        the result will broadcast correctly against the input array.
+
+        .. versionadded:: 1.10.0
+
+    Returns
+    -------
+    median : ndarray
+        A new array holding the result is returned unless out is
+        specified, in which case a reference to out is returned.
+        Return data-type is `float64` for integers and floats smaller than
+        `float64`, or the input data-type, otherwise.
+
+    See Also
+    --------
+    mean
+
+    Notes
+    -----
+    Given a vector ``V`` with ``N`` non masked values, the median of ``V``
+    is the middle value of a sorted copy of ``V`` (``Vs``) - i.e.
+    ``Vs[(N-1)/2]``, when ``N`` is odd, or ``{Vs[N/2 - 1] + Vs[N/2]}/2``
+    when ``N`` is even.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> x = np.ma.array(np.arange(8), mask=[0]*4 + [1]*4)
+    >>> np.ma.median(x)
+    1.5
+
+    >>> x = np.ma.array(np.arange(10).reshape(2, 5), mask=[0]*6 + [1]*4)
+    >>> np.ma.median(x)
+    2.5
+    >>> np.ma.median(x, axis=-1, overwrite_input=True)
+    masked_array(data=[2.0, 5.0],
+                 mask=[False, False],
+           fill_value=1e+20)
+
+    """
+    if not hasattr(a, 'mask'):
+        m = np.median(getdata(a, subok=True), axis=axis,
+                      out=out, overwrite_input=overwrite_input,
+                      keepdims=keepdims)
+        if isinstance(m, np.ndarray) and 1 <= m.ndim:
+            return masked_array(m, copy=False)
+        else:
+            return m
+
+    return _ureduce(a, func=_median, keepdims=keepdims, axis=axis, out=out,
+                    overwrite_input=overwrite_input)
+
+
+def _median(a, axis=None, out=None, overwrite_input=False):
+    # when an unmasked NaN is present return it, so we need to sort the NaN
+    # values behind the mask
+    if np.issubdtype(a.dtype, np.inexact):
+        fill_value = np.inf
+    else:
+        fill_value = None
+    if overwrite_input:
+        if axis is None:
+            asorted = a.ravel()
+            asorted.sort(fill_value=fill_value)
+        else:
+            a.sort(axis=axis, fill_value=fill_value)
+            asorted = a
+    else:
+        asorted = sort(a, axis=axis, fill_value=fill_value)
+
+    if axis is None:
+        axis = 0
+    else:
+        axis = normalize_axis_index(axis, asorted.ndim)
+
+    if asorted.shape[axis] == 0:
+        # for empty axis integer indices fail so use slicing to get same result
+        # as median (which is mean of empty slice = nan)
+        indexer = [slice(None)] * asorted.ndim
+        indexer[axis] = slice(0, 0)
+        indexer = tuple(indexer)
+        return np.ma.mean(asorted[indexer], axis=axis, out=out)
+
+    if asorted.ndim == 1:
+        idx, odd = divmod(count(asorted), 2)
+        mid = asorted[idx + odd - 1:idx + 1]
+        if np.issubdtype(asorted.dtype, np.inexact) and asorted.size > 0:
+            # avoid inf / x = masked
+            s = mid.sum(out=out)
+            if not odd:
+                s = np.true_divide(s, 2., casting='safe', out=out)
+            s = np.lib._utils_impl._median_nancheck(asorted, s, axis)
+        else:
+            s = mid.mean(out=out)
+
+        # if result is masked either the input contained enough
+        # minimum_fill_value so that it would be the median or all values
+        # masked
+        if np.ma.is_masked(s) and not np.all(asorted.mask):
+            return np.ma.minimum_fill_value(asorted)
+        return s
+
+    counts = count(asorted, axis=axis, keepdims=True)
+    h = counts // 2
+
+    # duplicate high if odd number of elements so mean does nothing
+    odd = counts % 2 == 1
+    l = np.where(odd, h, h-1)
+
+    lh = np.concatenate([l,h], axis=axis)
+
+    # get low and high median
+    low_high = np.take_along_axis(asorted, lh, axis=axis)
+
+    def replace_masked(s):
+        # Replace masked entries with minimum_full_value unless it all values
+        # are masked. This is required as the sort order of values equal or
+        # larger than the fill value is undefined and a valid value placed
+        # elsewhere, e.g. [4, --, inf].
+        if np.ma.is_masked(s):
+            rep = (~np.all(asorted.mask, axis=axis, keepdims=True)) & s.mask
+            s.data[rep] = np.ma.minimum_fill_value(asorted)
+            s.mask[rep] = False
+
+    replace_masked(low_high)
+
+    if np.issubdtype(asorted.dtype, np.inexact):
+        # avoid inf / x = masked
+        s = np.ma.sum(low_high, axis=axis, out=out)
+        np.true_divide(s.data, 2., casting='unsafe', out=s.data)
+
+        s = np.lib._utils_impl._median_nancheck(asorted, s, axis)
+    else:
+        s = np.ma.mean(low_high, axis=axis, out=out)
+
+    return s
+
+
+def compress_nd(x, axis=None):
+    """Suppress slices from multiple dimensions which contain masked values.
+
+    Parameters
+    ----------
+    x : array_like, MaskedArray
+        The array to operate on. If not a MaskedArray instance (or if no array
+        elements are masked), `x` is interpreted as a MaskedArray with `mask`
+        set to `nomask`.
+    axis : tuple of ints or int, optional
+        Which dimensions to suppress slices from can be configured with this
+        parameter.
+        - If axis is a tuple of ints, those are the axes to suppress slices from.
+        - If axis is an int, then that is the only axis to suppress slices from.
+        - If axis is None, all axis are selected.
+
+    Returns
+    -------
+    compress_array : ndarray
+        The compressed array.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> arr = [[1, 2], [3, 4]]
+    >>> mask = [[0, 1], [0, 0]]
+    >>> x = np.ma.array(arr, mask=mask)
+    >>> np.ma.compress_nd(x, axis=0)
+    array([[3, 4]])
+    >>> np.ma.compress_nd(x, axis=1)
+    array([[1],
+           [3]])
+    >>> np.ma.compress_nd(x)
+    array([[3]])
+
+    """
+    x = asarray(x)
+    m = getmask(x)
+    # Set axis to tuple of ints
+    if axis is None:
+        axis = tuple(range(x.ndim))
+    else:
+        axis = normalize_axis_tuple(axis, x.ndim)
+
+    # Nothing is masked: return x
+    if m is nomask or not m.any():
+        return x._data
+    # All is masked: return empty
+    if m.all():
+        return nxarray([])
+    # Filter elements through boolean indexing
+    data = x._data
+    for ax in axis:
+        axes = tuple(list(range(ax)) + list(range(ax + 1, x.ndim)))
+        data = data[(slice(None),)*ax + (~m.any(axis=axes),)]
+    return data
+
+
+def compress_rowcols(x, axis=None):
+    """
+    Suppress the rows and/or columns of a 2-D array that contain
+    masked values.
+
+    The suppression behavior is selected with the `axis` parameter.
+
+    - If axis is None, both rows and columns are suppressed.
+    - If axis is 0, only rows are suppressed.
+    - If axis is 1 or -1, only columns are suppressed.
+
+    Parameters
+    ----------
+    x : array_like, MaskedArray
+        The array to operate on.  If not a MaskedArray instance (or if no array
+        elements are masked), `x` is interpreted as a MaskedArray with
+        `mask` set to `nomask`. Must be a 2D array.
+    axis : int, optional
+        Axis along which to perform the operation. Default is None.
+
+    Returns
+    -------
+    compressed_array : ndarray
+        The compressed array.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> x = np.ma.array(np.arange(9).reshape(3, 3), mask=[[1, 0, 0],
+    ...                                                   [1, 0, 0],
+    ...                                                   [0, 0, 0]])
+    >>> x
+    masked_array(
+      data=[[--, 1, 2],
+            [--, 4, 5],
+            [6, 7, 8]],
+      mask=[[ True, False, False],
+            [ True, False, False],
+            [False, False, False]],
+      fill_value=999999)
+
+    >>> np.ma.compress_rowcols(x)
+    array([[7, 8]])
+    >>> np.ma.compress_rowcols(x, 0)
+    array([[6, 7, 8]])
+    >>> np.ma.compress_rowcols(x, 1)
+    array([[1, 2],
+           [4, 5],
+           [7, 8]])
+
+    """
+    if asarray(x).ndim != 2:
+        raise NotImplementedError("compress_rowcols works for 2D arrays only.")
+    return compress_nd(x, axis=axis)
+
+
+def compress_rows(a):
+    """
+    Suppress whole rows of a 2-D array that contain masked values.
+
+    This is equivalent to ``np.ma.compress_rowcols(a, 0)``, see
+    `compress_rowcols` for details.
+
+    Parameters
+    ----------
+    x : array_like, MaskedArray
+        The array to operate on. If not a MaskedArray instance (or if no array
+        elements are masked), `x` is interpreted as a MaskedArray with
+        `mask` set to `nomask`. Must be a 2D array.
+
+    Returns
+    -------
+    compressed_array : ndarray
+        The compressed array.
+
+    See Also
+    --------
+    compress_rowcols
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> a = np.ma.array(np.arange(9).reshape(3, 3), mask=[[1, 0, 0],
+    ...                                                   [1, 0, 0],
+    ...                                                   [0, 0, 0]])
+    >>> np.ma.compress_rows(a)
+    array([[6, 7, 8]])
+
+    """
+    a = asarray(a)
+    if a.ndim != 2:
+        raise NotImplementedError("compress_rows works for 2D arrays only.")
+    return compress_rowcols(a, 0)
+
+
+def compress_cols(a):
+    """
+    Suppress whole columns of a 2-D array that contain masked values.
+
+    This is equivalent to ``np.ma.compress_rowcols(a, 1)``, see
+    `compress_rowcols` for details.
+
+    Parameters
+    ----------
+    x : array_like, MaskedArray
+        The array to operate on.  If not a MaskedArray instance (or if no array
+        elements are masked), `x` is interpreted as a MaskedArray with
+        `mask` set to `nomask`. Must be a 2D array.
+
+    Returns
+    -------
+    compressed_array : ndarray
+        The compressed array.
+
+    See Also
+    --------
+    compress_rowcols
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> a = np.ma.array(np.arange(9).reshape(3, 3), mask=[[1, 0, 0],
+    ...                                                   [1, 0, 0],
+    ...                                                   [0, 0, 0]])
+    >>> np.ma.compress_cols(a)
+    array([[1, 2],
+           [4, 5],
+           [7, 8]])
+
+    """
+    a = asarray(a)
+    if a.ndim != 2:
+        raise NotImplementedError("compress_cols works for 2D arrays only.")
+    return compress_rowcols(a, 1)
+
+
+def mask_rowcols(a, axis=None):
+    """
+    Mask rows and/or columns of a 2D array that contain masked values.
+
+    Mask whole rows and/or columns of a 2D array that contain
+    masked values.  The masking behavior is selected using the
+    `axis` parameter.
+
+      - If `axis` is None, rows *and* columns are masked.
+      - If `axis` is 0, only rows are masked.
+      - If `axis` is 1 or -1, only columns are masked.
+
+    Parameters
+    ----------
+    a : array_like, MaskedArray
+        The array to mask.  If not a MaskedArray instance (or if no array
+        elements are masked), the result is a MaskedArray with `mask` set
+        to `nomask` (False). Must be a 2D array.
+    axis : int, optional
+        Axis along which to perform the operation. If None, applies to a
+        flattened version of the array.
+
+    Returns
+    -------
+    a : MaskedArray
+        A modified version of the input array, masked depending on the value
+        of the `axis` parameter.
+
+    Raises
+    ------
+    NotImplementedError
+        If input array `a` is not 2D.
+
+    See Also
+    --------
+    mask_rows : Mask rows of a 2D array that contain masked values.
+    mask_cols : Mask cols of a 2D array that contain masked values.
+    masked_where : Mask where a condition is met.
+
+    Notes
+    -----
+    The input array's mask is modified by this function.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> a = np.zeros((3, 3), dtype=int)
+    >>> a[1, 1] = 1
+    >>> a
+    array([[0, 0, 0],
+           [0, 1, 0],
+           [0, 0, 0]])
+    >>> a = np.ma.masked_equal(a, 1)
+    >>> a
+    masked_array(
+      data=[[0, 0, 0],
+            [0, --, 0],
+            [0, 0, 0]],
+      mask=[[False, False, False],
+            [False,  True, False],
+            [False, False, False]],
+      fill_value=1)
+    >>> np.ma.mask_rowcols(a)
+    masked_array(
+      data=[[0, --, 0],
+            [--, --, --],
+            [0, --, 0]],
+      mask=[[False,  True, False],
+            [ True,  True,  True],
+            [False,  True, False]],
+      fill_value=1)
+
+    """
+    a = array(a, subok=False)
+    if a.ndim != 2:
+        raise NotImplementedError("mask_rowcols works for 2D arrays only.")
+    m = getmask(a)
+    # Nothing is masked: return a
+    if m is nomask or not m.any():
+        return a
+    maskedval = m.nonzero()
+    a._mask = a._mask.copy()
+    if not axis:
+        a[np.unique(maskedval[0])] = masked
+    if axis in [None, 1, -1]:
+        a[:, np.unique(maskedval[1])] = masked
+    return a
+
+
+def mask_rows(a, axis=np._NoValue):
+    """
+    Mask rows of a 2D array that contain masked values.
+
+    This function is a shortcut to ``mask_rowcols`` with `axis` equal to 0.
+
+    See Also
+    --------
+    mask_rowcols : Mask rows and/or columns of a 2D array.
+    masked_where : Mask where a condition is met.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> a = np.zeros((3, 3), dtype=int)
+    >>> a[1, 1] = 1
+    >>> a
+    array([[0, 0, 0],
+           [0, 1, 0],
+           [0, 0, 0]])
+    >>> a = np.ma.masked_equal(a, 1)
+    >>> a
+    masked_array(
+      data=[[0, 0, 0],
+            [0, --, 0],
+            [0, 0, 0]],
+      mask=[[False, False, False],
+            [False,  True, False],
+            [False, False, False]],
+      fill_value=1)
+
+    >>> np.ma.mask_rows(a)
+    masked_array(
+      data=[[0, 0, 0],
+            [--, --, --],
+            [0, 0, 0]],
+      mask=[[False, False, False],
+            [ True,  True,  True],
+            [False, False, False]],
+      fill_value=1)
+
+    """
+    if axis is not np._NoValue:
+        # remove the axis argument when this deprecation expires
+        # NumPy 1.18.0, 2019-11-28
+        warnings.warn(
+            "The axis argument has always been ignored, in future passing it "
+            "will raise TypeError", DeprecationWarning, stacklevel=2)
+    return mask_rowcols(a, 0)
+
+
+def mask_cols(a, axis=np._NoValue):
+    """
+    Mask columns of a 2D array that contain masked values.
+
+    This function is a shortcut to ``mask_rowcols`` with `axis` equal to 1.
+
+    See Also
+    --------
+    mask_rowcols : Mask rows and/or columns of a 2D array.
+    masked_where : Mask where a condition is met.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> a = np.zeros((3, 3), dtype=int)
+    >>> a[1, 1] = 1
+    >>> a
+    array([[0, 0, 0],
+           [0, 1, 0],
+           [0, 0, 0]])
+    >>> a = np.ma.masked_equal(a, 1)
+    >>> a
+    masked_array(
+      data=[[0, 0, 0],
+            [0, --, 0],
+            [0, 0, 0]],
+      mask=[[False, False, False],
+            [False,  True, False],
+            [False, False, False]],
+      fill_value=1)
+    >>> np.ma.mask_cols(a)
+    masked_array(
+      data=[[0, --, 0],
+            [0, --, 0],
+            [0, --, 0]],
+      mask=[[False,  True, False],
+            [False,  True, False],
+            [False,  True, False]],
+      fill_value=1)
+
+    """
+    if axis is not np._NoValue:
+        # remove the axis argument when this deprecation expires
+        # NumPy 1.18.0, 2019-11-28
+        warnings.warn(
+            "The axis argument has always been ignored, in future passing it "
+            "will raise TypeError", DeprecationWarning, stacklevel=2)
+    return mask_rowcols(a, 1)
+
+
+#####--------------------------------------------------------------------------
+#---- --- arraysetops ---
+#####--------------------------------------------------------------------------
+
+def ediff1d(arr, to_end=None, to_begin=None):
+    """
+    Compute the differences between consecutive elements of an array.
+
+    This function is the equivalent of `numpy.ediff1d` that takes masked
+    values into account, see `numpy.ediff1d` for details.
+
+    See Also
+    --------
+    numpy.ediff1d : Equivalent function for ndarrays.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> arr = np.ma.array([1, 2, 4, 7, 0])
+    >>> np.ma.ediff1d(arr)
+    masked_array(data=[ 1,  2,  3, -7],
+                 mask=False,
+           fill_value=999999)
+
+    """
+    arr = ma.asanyarray(arr).flat
+    ed = arr[1:] - arr[:-1]
+    arrays = [ed]
+    #
+    if to_begin is not None:
+        arrays.insert(0, to_begin)
+    if to_end is not None:
+        arrays.append(to_end)
+    #
+    if len(arrays) != 1:
+        # We'll save ourselves a copy of a potentially large array in the common
+        # case where neither to_begin or to_end was given.
+        ed = hstack(arrays)
+    #
+    return ed
+
+
+def unique(ar1, return_index=False, return_inverse=False):
+    """
+    Finds the unique elements of an array.
+
+    Masked values are considered the same element (masked). The output array
+    is always a masked array. See `numpy.unique` for more details.
+
+    See Also
+    --------
+    numpy.unique : Equivalent function for ndarrays.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> a = [1, 2, 1000, 2, 3]
+    >>> mask = [0, 0, 1, 0, 0]
+    >>> masked_a = np.ma.masked_array(a, mask)
+    >>> masked_a
+    masked_array(data=[1, 2, --, 2, 3],
+                mask=[False, False,  True, False, False],
+        fill_value=999999)
+    >>> np.ma.unique(masked_a)
+    masked_array(data=[1, 2, 3, --],
+                mask=[False, False, False,  True],
+        fill_value=999999)
+    >>> np.ma.unique(masked_a, return_index=True)
+    (masked_array(data=[1, 2, 3, --],
+                mask=[False, False, False,  True],
+        fill_value=999999), array([0, 1, 4, 2]))
+    >>> np.ma.unique(masked_a, return_inverse=True)
+    (masked_array(data=[1, 2, 3, --],
+                mask=[False, False, False,  True],
+        fill_value=999999), array([0, 1, 3, 1, 2]))
+    >>> np.ma.unique(masked_a, return_index=True, return_inverse=True)
+    (masked_array(data=[1, 2, 3, --],
+                mask=[False, False, False,  True],
+        fill_value=999999), array([0, 1, 4, 2]), array([0, 1, 3, 1, 2]))
+    """
+    output = np.unique(ar1,
+                       return_index=return_index,
+                       return_inverse=return_inverse)
+    if isinstance(output, tuple):
+        output = list(output)
+        output[0] = output[0].view(MaskedArray)
+        output = tuple(output)
+    else:
+        output = output.view(MaskedArray)
+    return output
+
+
+def intersect1d(ar1, ar2, assume_unique=False):
+    """
+    Returns the unique elements common to both arrays.
+
+    Masked values are considered equal one to the other.
+    The output is always a masked array.
+
+    See `numpy.intersect1d` for more details.
+
+    See Also
+    --------
+    numpy.intersect1d : Equivalent function for ndarrays.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> x = np.ma.array([1, 3, 3, 3], mask=[0, 0, 0, 1])
+    >>> y = np.ma.array([3, 1, 1, 1], mask=[0, 0, 0, 1])
+    >>> np.ma.intersect1d(x, y)
+    masked_array(data=[1, 3, --],
+                 mask=[False, False,  True],
+           fill_value=999999)
+
+    """
+    if assume_unique:
+        aux = ma.concatenate((ar1, ar2))
+    else:
+        # Might be faster than unique( intersect1d( ar1, ar2 ) )?
+        aux = ma.concatenate((unique(ar1), unique(ar2)))
+    aux.sort()
+    return aux[:-1][aux[1:] == aux[:-1]]
+
+
+def setxor1d(ar1, ar2, assume_unique=False):
+    """
+    Set exclusive-or of 1-D arrays with unique elements.
+
+    The output is always a masked array. See `numpy.setxor1d` for more details.
+
+    See Also
+    --------
+    numpy.setxor1d : Equivalent function for ndarrays.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> ar1 = np.ma.array([1, 2, 3, 2, 4])
+    >>> ar2 = np.ma.array([2, 3, 5, 7, 5])
+    >>> np.ma.setxor1d(ar1, ar2)
+    masked_array(data=[1, 4, 5, 7],
+                 mask=False,
+           fill_value=999999)
+
+    """
+    if not assume_unique:
+        ar1 = unique(ar1)
+        ar2 = unique(ar2)
+
+    aux = ma.concatenate((ar1, ar2), axis=None)
+    if aux.size == 0:
+        return aux
+    aux.sort()
+    auxf = aux.filled()
+#    flag = ediff1d( aux, to_end = 1, to_begin = 1 ) == 0
+    flag = ma.concatenate(([True], (auxf[1:] != auxf[:-1]), [True]))
+#    flag2 = ediff1d( flag ) == 0
+    flag2 = (flag[1:] == flag[:-1])
+    return aux[flag2]
+
+
+def in1d(ar1, ar2, assume_unique=False, invert=False):
+    """
+    Test whether each element of an array is also present in a second
+    array.
+
+    The output is always a masked array. See `numpy.in1d` for more details.
+
+    We recommend using :func:`isin` instead of `in1d` for new code.
+
+    See Also
+    --------
+    isin       : Version of this function that preserves the shape of ar1.
+    numpy.in1d : Equivalent function for ndarrays.
+
+    Notes
+    -----
+    .. versionadded:: 1.4.0
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> ar1 = np.ma.array([0, 1, 2, 5, 0])
+    >>> ar2 = [0, 2]
+    >>> np.ma.in1d(ar1, ar2)
+    masked_array(data=[ True, False,  True, False,  True],
+                 mask=False,
+           fill_value=True)
+
+    """
+    if not assume_unique:
+        ar1, rev_idx = unique(ar1, return_inverse=True)
+        ar2 = unique(ar2)
+
+    ar = ma.concatenate((ar1, ar2))
+    # We need this to be a stable sort, so always use 'mergesort'
+    # here. The values from the first array should always come before
+    # the values from the second array.
+    order = ar.argsort(kind='mergesort')
+    sar = ar[order]
+    if invert:
+        bool_ar = (sar[1:] != sar[:-1])
+    else:
+        bool_ar = (sar[1:] == sar[:-1])
+    flag = ma.concatenate((bool_ar, [invert]))
+    indx = order.argsort(kind='mergesort')[:len(ar1)]
+
+    if assume_unique:
+        return flag[indx]
+    else:
+        return flag[indx][rev_idx]
+
+
+def isin(element, test_elements, assume_unique=False, invert=False):
+    """
+    Calculates `element in test_elements`, broadcasting over
+    `element` only.
+
+    The output is always a masked array of the same shape as `element`.
+    See `numpy.isin` for more details.
+
+    See Also
+    --------
+    in1d       : Flattened version of this function.
+    numpy.isin : Equivalent function for ndarrays.
+
+    Notes
+    -----
+    .. versionadded:: 1.13.0
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> element = np.ma.array([1, 2, 3, 4, 5, 6])
+    >>> test_elements = [0, 2]
+    >>> np.ma.isin(element, test_elements)
+    masked_array(data=[False,  True, False, False, False, False],
+                 mask=False,
+           fill_value=True)
+
+    """
+    element = ma.asarray(element)
+    return in1d(element, test_elements, assume_unique=assume_unique,
+                invert=invert).reshape(element.shape)
+
+
+def union1d(ar1, ar2):
+    """
+    Union of two arrays.
+
+    The output is always a masked array. See `numpy.union1d` for more details.
+
+    See Also
+    --------
+    numpy.union1d : Equivalent function for ndarrays.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> ar1 = np.ma.array([1, 2, 3, 4])
+    >>> ar2 = np.ma.array([3, 4, 5, 6])
+    >>> np.ma.union1d(ar1, ar2)
+    masked_array(data=[1, 2, 3, 4, 5, 6],
+             mask=False,
+       fill_value=999999)
+
+    """
+    return unique(ma.concatenate((ar1, ar2), axis=None))
+
+
+def setdiff1d(ar1, ar2, assume_unique=False):
+    """
+    Set difference of 1D arrays with unique elements.
+
+    The output is always a masked array. See `numpy.setdiff1d` for more
+    details.
+
+    See Also
+    --------
+    numpy.setdiff1d : Equivalent function for ndarrays.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> x = np.ma.array([1, 2, 3, 4], mask=[0, 1, 0, 1])
+    >>> np.ma.setdiff1d(x, [1, 2])
+    masked_array(data=[3, --],
+                 mask=[False,  True],
+           fill_value=999999)
+
+    """
+    if assume_unique:
+        ar1 = ma.asarray(ar1).ravel()
+    else:
+        ar1 = unique(ar1)
+        ar2 = unique(ar2)
+    return ar1[in1d(ar1, ar2, assume_unique=True, invert=True)]
+
+
+###############################################################################
+#                                Covariance                                   #
+###############################################################################
+
+
+def _covhelper(x, y=None, rowvar=True, allow_masked=True):
+    """
+    Private function for the computation of covariance and correlation
+    coefficients.
+
+    """
+    x = ma.array(x, ndmin=2, copy=True, dtype=float)
+    xmask = ma.getmaskarray(x)
+    # Quick exit if we can't process masked data
+    if not allow_masked and xmask.any():
+        raise ValueError("Cannot process masked data.")
+    #
+    if x.shape[0] == 1:
+        rowvar = True
+    # Make sure that rowvar is either 0 or 1
+    rowvar = int(bool(rowvar))
+    axis = 1 - rowvar
+    if rowvar:
+        tup = (slice(None), None)
+    else:
+        tup = (None, slice(None))
+    #
+    if y is None:
+        # Check if we can guarantee that the integers in the (N - ddof)
+        # normalisation can be accurately represented with single-precision
+        # before computing the dot product.
+        if x.shape[0] > 2 ** 24 or x.shape[1] > 2 ** 24:
+            xnm_dtype = np.float64
+        else:
+            xnm_dtype = np.float32
+        xnotmask = np.logical_not(xmask).astype(xnm_dtype)
+    else:
+        y = array(y, copy=False, ndmin=2, dtype=float)
+        ymask = ma.getmaskarray(y)
+        if not allow_masked and ymask.any():
+            raise ValueError("Cannot process masked data.")
+        if xmask.any() or ymask.any():
+            if y.shape == x.shape:
+                # Define some common mask
+                common_mask = np.logical_or(xmask, ymask)
+                if common_mask is not nomask:
+                    xmask = x._mask = y._mask = ymask = common_mask
+                    x._sharedmask = False
+                    y._sharedmask = False
+        x = ma.concatenate((x, y), axis)
+        # Check if we can guarantee that the integers in the (N - ddof)
+        # normalisation can be accurately represented with single-precision
+        # before computing the dot product.
+        if x.shape[0] > 2 ** 24 or x.shape[1] > 2 ** 24:
+            xnm_dtype = np.float64
+        else:
+            xnm_dtype = np.float32
+        xnotmask = np.logical_not(np.concatenate((xmask, ymask), axis)).astype(
+            xnm_dtype
+        )
+    x -= x.mean(axis=rowvar)[tup]
+    return (x, xnotmask, rowvar)
+
+
+def cov(x, y=None, rowvar=True, bias=False, allow_masked=True, ddof=None):
+    """
+    Estimate the covariance matrix.
+
+    Except for the handling of missing data this function does the same as
+    `numpy.cov`. For more details and examples, see `numpy.cov`.
+
+    By default, masked values are recognized as such. If `x` and `y` have the
+    same shape, a common mask is allocated: if ``x[i,j]`` is masked, then
+    ``y[i,j]`` will also be masked.
+    Setting `allow_masked` to False will raise an exception if values are
+    missing in either of the input arrays.
+
+    Parameters
+    ----------
+    x : array_like
+        A 1-D or 2-D array containing multiple variables and observations.
+        Each row of `x` represents a variable, and each column a single
+        observation of all those variables. Also see `rowvar` below.
+    y : array_like, optional
+        An additional set of variables and observations. `y` has the same
+        shape as `x`.
+    rowvar : bool, optional
+        If `rowvar` is True (default), then each row represents a
+        variable, with observations in the columns. Otherwise, the relationship
+        is transposed: each column represents a variable, while the rows
+        contain observations.
+    bias : bool, optional
+        Default normalization (False) is by ``(N-1)``, where ``N`` is the
+        number of observations given (unbiased estimate). If `bias` is True,
+        then normalization is by ``N``. This keyword can be overridden by
+        the keyword ``ddof`` in numpy versions >= 1.5.
+    allow_masked : bool, optional
+        If True, masked values are propagated pair-wise: if a value is masked
+        in `x`, the corresponding value is masked in `y`.
+        If False, raises a `ValueError` exception when some values are missing.
+    ddof : {None, int}, optional
+        If not ``None`` normalization is by ``(N - ddof)``, where ``N`` is
+        the number of observations; this overrides the value implied by
+        ``bias``. The default value is ``None``.
+
+        .. versionadded:: 1.5
+
+    Raises
+    ------
+    ValueError
+        Raised if some values are missing and `allow_masked` is False.
+
+    See Also
+    --------
+    numpy.cov
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> x = np.ma.array([[0, 1], [1, 1]], mask=[0, 1, 0, 1])
+    >>> y = np.ma.array([[1, 0], [0, 1]], mask=[0, 0, 1, 1])
+    >>> np.ma.cov(x, y)
+    masked_array(
+    data=[[--, --, --, --],
+          [--, --, --, --],
+          [--, --, --, --],
+          [--, --, --, --]],
+    mask=[[ True,  True,  True,  True],
+          [ True,  True,  True,  True],
+          [ True,  True,  True,  True],
+          [ True,  True,  True,  True]],
+    fill_value=1e+20,
+    dtype=float64)
+
+    """
+    # Check inputs
+    if ddof is not None and ddof != int(ddof):
+        raise ValueError("ddof must be an integer")
+    # Set up ddof
+    if ddof is None:
+        if bias:
+            ddof = 0
+        else:
+            ddof = 1
+
+    (x, xnotmask, rowvar) = _covhelper(x, y, rowvar, allow_masked)
+    if not rowvar:
+        fact = np.dot(xnotmask.T, xnotmask) - ddof
+        mask = np.less_equal(fact, 0, dtype=bool)
+        with np.errstate(divide="ignore", invalid="ignore"):
+            data = np.dot(filled(x.T, 0), filled(x.conj(), 0)) / fact
+        result = ma.array(data, mask=mask).squeeze()
+    else:
+        fact = np.dot(xnotmask, xnotmask.T) - ddof
+        mask = np.less_equal(fact, 0, dtype=bool)
+        with np.errstate(divide="ignore", invalid="ignore"):
+            data = np.dot(filled(x, 0), filled(x.T.conj(), 0)) / fact
+        result = ma.array(data, mask=mask).squeeze()
+    return result
+
+
+def corrcoef(x, y=None, rowvar=True, bias=np._NoValue, allow_masked=True,
+             ddof=np._NoValue):
+    """
+    Return Pearson product-moment correlation coefficients.
+
+    Except for the handling of missing data this function does the same as
+    `numpy.corrcoef`. For more details and examples, see `numpy.corrcoef`.
+
+    Parameters
+    ----------
+    x : array_like
+        A 1-D or 2-D array containing multiple variables and observations.
+        Each row of `x` represents a variable, and each column a single
+        observation of all those variables. Also see `rowvar` below.
+    y : array_like, optional
+        An additional set of variables and observations. `y` has the same
+        shape as `x`.
+    rowvar : bool, optional
+        If `rowvar` is True (default), then each row represents a
+        variable, with observations in the columns. Otherwise, the relationship
+        is transposed: each column represents a variable, while the rows
+        contain observations.
+    bias : _NoValue, optional
+        Has no effect, do not use.
+
+        .. deprecated:: 1.10.0
+    allow_masked : bool, optional
+        If True, masked values are propagated pair-wise: if a value is masked
+        in `x`, the corresponding value is masked in `y`.
+        If False, raises an exception.  Because `bias` is deprecated, this
+        argument needs to be treated as keyword only to avoid a warning.
+    ddof : _NoValue, optional
+        Has no effect, do not use.
+
+        .. deprecated:: 1.10.0
+
+    See Also
+    --------
+    numpy.corrcoef : Equivalent function in top-level NumPy module.
+    cov : Estimate the covariance matrix.
+
+    Notes
+    -----
+    This function accepts but discards arguments `bias` and `ddof`.  This is
+    for backwards compatibility with previous versions of this function.  These
+    arguments had no effect on the return values of the function and can be
+    safely ignored in this and previous versions of numpy.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> x = np.ma.array([[0, 1], [1, 1]], mask=[0, 1, 0, 1])
+    >>> np.ma.corrcoef(x)
+    masked_array(
+      data=[[--, --],
+            [--, --]],
+      mask=[[ True,  True],
+            [ True,  True]],
+      fill_value=1e+20,
+      dtype=float64)
+
+    """
+    msg = 'bias and ddof have no effect and are deprecated'
+    if bias is not np._NoValue or ddof is not np._NoValue:
+        # 2015-03-15, 1.10
+        warnings.warn(msg, DeprecationWarning, stacklevel=2)
+    # Estimate the covariance matrix.
+    corr = cov(x, y, rowvar, allow_masked=allow_masked)
+    # The non-masked version returns a masked value for a scalar.
+    try:
+        std = ma.sqrt(ma.diagonal(corr))
+    except ValueError:
+        return ma.MaskedConstant()
+    corr /= ma.multiply.outer(std, std)
+    return corr
+
+#####--------------------------------------------------------------------------
+#---- --- Concatenation helpers ---
+#####--------------------------------------------------------------------------
+
+class MAxisConcatenator(AxisConcatenator):
+    """
+    Translate slice objects to concatenation along an axis.
+
+    For documentation on usage, see `mr_class`.
+
+    See Also
+    --------
+    mr_class
+
+    """
+    __slots__ = ()
+
+    concatenate = staticmethod(concatenate)
+
+    @classmethod
+    def makemat(cls, arr):
+        # There used to be a view as np.matrix here, but we may eventually
+        # deprecate that class. In preparation, we use the unmasked version
+        # to construct the matrix (with copy=False for backwards compatibility
+        # with the .view)
+        data = super().makemat(arr.data, copy=False)
+        return array(data, mask=arr.mask)
+
+    def __getitem__(self, key):
+        # matrix builder syntax, like 'a, b; c, d'
+        if isinstance(key, str):
+            raise MAError("Unavailable for masked array.")
+
+        return super().__getitem__(key)
+
+
+class mr_class(MAxisConcatenator):
+    """
+    Translate slice objects to concatenation along the first axis.
+
+    This is the masked array version of `r_`.
+
+    See Also
+    --------
+    r_
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> np.ma.mr_[np.ma.array([1,2,3]), 0, 0, np.ma.array([4,5,6])]
+    masked_array(data=[1, 2, 3, ..., 4, 5, 6],
+                 mask=False,
+           fill_value=999999)
+
+    """
+    __slots__ = ()
+
+    def __init__(self):
+        MAxisConcatenator.__init__(self, 0)
+
+mr_ = mr_class()
+
+
+#####--------------------------------------------------------------------------
+#---- Find unmasked data ---
+#####--------------------------------------------------------------------------
+
+def ndenumerate(a, compressed=True):
+    """
+    Multidimensional index iterator.
+
+    Return an iterator yielding pairs of array coordinates and values,
+    skipping elements that are masked. With `compressed=False`,
+    `ma.masked` is yielded as the value of masked elements. This
+    behavior differs from that of `numpy.ndenumerate`, which yields the
+    value of the underlying data array.
+
+    Notes
+    -----
+    .. versionadded:: 1.23.0
+
+    Parameters
+    ----------
+    a : array_like
+        An array with (possibly) masked elements.
+    compressed : bool, optional
+        If True (default), masked elements are skipped.
+
+    See Also
+    --------
+    numpy.ndenumerate : Equivalent function ignoring any mask.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> a = np.ma.arange(9).reshape((3, 3))
+    >>> a[1, 0] = np.ma.masked
+    >>> a[1, 2] = np.ma.masked
+    >>> a[2, 1] = np.ma.masked
+    >>> a
+    masked_array(
+      data=[[0, 1, 2],
+            [--, 4, --],
+            [6, --, 8]],
+      mask=[[False, False, False],
+            [ True, False,  True],
+            [False,  True, False]],
+      fill_value=999999)
+    >>> for index, x in np.ma.ndenumerate(a):
+    ...     print(index, x)
+    (0, 0) 0
+    (0, 1) 1
+    (0, 2) 2
+    (1, 1) 4
+    (2, 0) 6
+    (2, 2) 8
+
+    >>> for index, x in np.ma.ndenumerate(a, compressed=False):
+    ...     print(index, x)
+    (0, 0) 0
+    (0, 1) 1
+    (0, 2) 2
+    (1, 0) --
+    (1, 1) 4
+    (1, 2) --
+    (2, 0) 6
+    (2, 1) --
+    (2, 2) 8
+    """
+    for it, mask in zip(np.ndenumerate(a), getmaskarray(a).flat):
+        if not mask:
+            yield it
+        elif not compressed:
+            yield it[0], masked
+
+
+def flatnotmasked_edges(a):
+    """
+    Find the indices of the first and last unmasked values.
+
+    Expects a 1-D `MaskedArray`, returns None if all values are masked.
+
+    Parameters
+    ----------
+    a : array_like
+        Input 1-D `MaskedArray`
+
+    Returns
+    -------
+    edges : ndarray or None
+        The indices of first and last non-masked value in the array.
+        Returns None if all values are masked.
+
+    See Also
+    --------
+    flatnotmasked_contiguous, notmasked_contiguous, notmasked_edges
+    clump_masked, clump_unmasked
+
+    Notes
+    -----
+    Only accepts 1-D arrays.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> a = np.ma.arange(10)
+    >>> np.ma.flatnotmasked_edges(a)
+    array([0, 9])
+
+    >>> mask = (a < 3) | (a > 8) | (a == 5)
+    >>> a[mask] = np.ma.masked
+    >>> np.array(a[~a.mask])
+    array([3, 4, 6, 7, 8])
+
+    >>> np.ma.flatnotmasked_edges(a)
+    array([3, 8])
+
+    >>> a[:] = np.ma.masked
+    >>> print(np.ma.flatnotmasked_edges(a))
+    None
+
+    """
+    m = getmask(a)
+    if m is nomask or not np.any(m):
+        return np.array([0, a.size - 1])
+    unmasked = np.flatnonzero(~m)
+    if len(unmasked) > 0:
+        return unmasked[[0, -1]]
+    else:
+        return None
+
+
+def notmasked_edges(a, axis=None):
+    """
+    Find the indices of the first and last unmasked values along an axis.
+
+    If all values are masked, return None.  Otherwise, return a list
+    of two tuples, corresponding to the indices of the first and last
+    unmasked values respectively.
+
+    Parameters
+    ----------
+    a : array_like
+        The input array.
+    axis : int, optional
+        Axis along which to perform the operation.
+        If None (default), applies to a flattened version of the array.
+
+    Returns
+    -------
+    edges : ndarray or list
+        An array of start and end indexes if there are any masked data in
+        the array. If there are no masked data in the array, `edges` is a
+        list of the first and last index.
+
+    See Also
+    --------
+    flatnotmasked_contiguous, flatnotmasked_edges, notmasked_contiguous
+    clump_masked, clump_unmasked
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> a = np.arange(9).reshape((3, 3))
+    >>> m = np.zeros_like(a)
+    >>> m[1:, 1:] = 1
+
+    >>> am = np.ma.array(a, mask=m)
+    >>> np.array(am[~am.mask])
+    array([0, 1, 2, 3, 6])
+
+    >>> np.ma.notmasked_edges(am)
+    array([0, 6])
+
+    """
+    a = asarray(a)
+    if axis is None or a.ndim == 1:
+        return flatnotmasked_edges(a)
+    m = getmaskarray(a)
+    idx = array(np.indices(a.shape), mask=np.asarray([m] * a.ndim))
+    return [tuple([idx[i].min(axis).compressed() for i in range(a.ndim)]),
+            tuple([idx[i].max(axis).compressed() for i in range(a.ndim)]), ]
+
+
+def flatnotmasked_contiguous(a):
+    """
+    Find contiguous unmasked data in a masked array.
+
+    Parameters
+    ----------
+    a : array_like
+        The input array.
+
+    Returns
+    -------
+    slice_list : list
+        A sorted sequence of `slice` objects (start index, end index).
+
+        .. versionchanged:: 1.15.0
+            Now returns an empty list instead of None for a fully masked array
+
+    See Also
+    --------
+    flatnotmasked_edges, notmasked_contiguous, notmasked_edges
+    clump_masked, clump_unmasked
+
+    Notes
+    -----
+    Only accepts 2-D arrays at most.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> a = np.ma.arange(10)
+    >>> np.ma.flatnotmasked_contiguous(a)
+    [slice(0, 10, None)]
+
+    >>> mask = (a < 3) | (a > 8) | (a == 5)
+    >>> a[mask] = np.ma.masked
+    >>> np.array(a[~a.mask])
+    array([3, 4, 6, 7, 8])
+
+    >>> np.ma.flatnotmasked_contiguous(a)
+    [slice(3, 5, None), slice(6, 9, None)]
+    >>> a[:] = np.ma.masked
+    >>> np.ma.flatnotmasked_contiguous(a)
+    []
+
+    """
+    m = getmask(a)
+    if m is nomask:
+        return [slice(0, a.size)]
+    i = 0
+    result = []
+    for (k, g) in itertools.groupby(m.ravel()):
+        n = len(list(g))
+        if not k:
+            result.append(slice(i, i + n))
+        i += n
+    return result
+
+
+def notmasked_contiguous(a, axis=None):
+    """
+    Find contiguous unmasked data in a masked array along the given axis.
+
+    Parameters
+    ----------
+    a : array_like
+        The input array.
+    axis : int, optional
+        Axis along which to perform the operation.
+        If None (default), applies to a flattened version of the array, and this
+        is the same as `flatnotmasked_contiguous`.
+
+    Returns
+    -------
+    endpoints : list
+        A list of slices (start and end indexes) of unmasked indexes
+        in the array.
+
+        If the input is 2d and axis is specified, the result is a list of lists.
+
+    See Also
+    --------
+    flatnotmasked_edges, flatnotmasked_contiguous, notmasked_edges
+    clump_masked, clump_unmasked
+
+    Notes
+    -----
+    Only accepts 2-D arrays at most.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> a = np.arange(12).reshape((3, 4))
+    >>> mask = np.zeros_like(a)
+    >>> mask[1:, :-1] = 1; mask[0, 1] = 1; mask[-1, 0] = 0
+    >>> ma = np.ma.array(a, mask=mask)
+    >>> ma
+    masked_array(
+      data=[[0, --, 2, 3],
+            [--, --, --, 7],
+            [8, --, --, 11]],
+      mask=[[False,  True, False, False],
+            [ True,  True,  True, False],
+            [False,  True,  True, False]],
+      fill_value=999999)
+    >>> np.array(ma[~ma.mask])
+    array([ 0,  2,  3,  7, 8, 11])
+
+    >>> np.ma.notmasked_contiguous(ma)
+    [slice(0, 1, None), slice(2, 4, None), slice(7, 9, None), slice(11, 12, None)]
+
+    >>> np.ma.notmasked_contiguous(ma, axis=0)
+    [[slice(0, 1, None), slice(2, 3, None)], [], [slice(0, 1, None)], [slice(0, 3, None)]]
+
+    >>> np.ma.notmasked_contiguous(ma, axis=1)
+    [[slice(0, 1, None), slice(2, 4, None)], [slice(3, 4, None)], [slice(0, 1, None), slice(3, 4, None)]]
+
+    """
+    a = asarray(a)
+    nd = a.ndim
+    if nd > 2:
+        raise NotImplementedError("Currently limited to at most 2D array.")
+    if axis is None or nd == 1:
+        return flatnotmasked_contiguous(a)
+    #
+    result = []
+    #
+    other = (axis + 1) % 2
+    idx = [0, 0]
+    idx[axis] = slice(None, None)
+    #
+    for i in range(a.shape[other]):
+        idx[other] = i
+        result.append(flatnotmasked_contiguous(a[tuple(idx)]))
+    return result
+
+
+def _ezclump(mask):
+    """
+    Finds the clumps (groups of data with the same values) for a 1D bool array.
+
+    Returns a series of slices.
+    """
+    if mask.ndim > 1:
+        mask = mask.ravel()
+    idx = (mask[1:] ^ mask[:-1]).nonzero()
+    idx = idx[0] + 1
+
+    if mask[0]:
+        if len(idx) == 0:
+            return [slice(0, mask.size)]
+
+        r = [slice(0, idx[0])]
+        r.extend((slice(left, right)
+                  for left, right in zip(idx[1:-1:2], idx[2::2])))
+    else:
+        if len(idx) == 0:
+            return []
+
+        r = [slice(left, right) for left, right in zip(idx[:-1:2], idx[1::2])]
+
+    if mask[-1]:
+        r.append(slice(idx[-1], mask.size))
+    return r
+
+
+def clump_unmasked(a):
+    """
+    Return list of slices corresponding to the unmasked clumps of a 1-D array.
+    (A "clump" is defined as a contiguous region of the array).
+
+    Parameters
+    ----------
+    a : ndarray
+        A one-dimensional masked array.
+
+    Returns
+    -------
+    slices : list of slice
+        The list of slices, one for each continuous region of unmasked
+        elements in `a`.
+
+    Notes
+    -----
+    .. versionadded:: 1.4.0
+
+    See Also
+    --------
+    flatnotmasked_edges, flatnotmasked_contiguous, notmasked_edges
+    notmasked_contiguous, clump_masked
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> a = np.ma.masked_array(np.arange(10))
+    >>> a[[0, 1, 2, 6, 8, 9]] = np.ma.masked
+    >>> np.ma.clump_unmasked(a)
+    [slice(3, 6, None), slice(7, 8, None)]
+
+    """
+    mask = getattr(a, '_mask', nomask)
+    if mask is nomask:
+        return [slice(0, a.size)]
+    return _ezclump(~mask)
+
+
+def clump_masked(a):
+    """
+    Returns a list of slices corresponding to the masked clumps of a 1-D array.
+    (A "clump" is defined as a contiguous region of the array).
+
+    Parameters
+    ----------
+    a : ndarray
+        A one-dimensional masked array.
+
+    Returns
+    -------
+    slices : list of slice
+        The list of slices, one for each continuous region of masked elements
+        in `a`.
+
+    Notes
+    -----
+    .. versionadded:: 1.4.0
+
+    See Also
+    --------
+    flatnotmasked_edges, flatnotmasked_contiguous, notmasked_edges
+    notmasked_contiguous, clump_unmasked
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> a = np.ma.masked_array(np.arange(10))
+    >>> a[[0, 1, 2, 6, 8, 9]] = np.ma.masked
+    >>> np.ma.clump_masked(a)
+    [slice(0, 3, None), slice(6, 7, None), slice(8, 10, None)]
+
+    """
+    mask = ma.getmask(a)
+    if mask is nomask:
+        return []
+    return _ezclump(mask)
+
+
+###############################################################################
+#                              Polynomial fit                                 #
+###############################################################################
+
+
+def vander(x, n=None):
+    """
+    Masked values in the input array result in rows of zeros.
+
+    """
+    _vander = np.vander(x, n)
+    m = getmask(x)
+    if m is not nomask:
+        _vander[m] = 0
+    return _vander
+
+vander.__doc__ = ma.doc_note(np.vander.__doc__, vander.__doc__)
+
+
+def polyfit(x, y, deg, rcond=None, full=False, w=None, cov=False):
+    """
+    Any masked values in x is propagated in y, and vice-versa.
+
+    """
+    x = asarray(x)
+    y = asarray(y)
+
+    m = getmask(x)
+    if y.ndim == 1:
+        m = mask_or(m, getmask(y))
+    elif y.ndim == 2:
+        my = getmask(mask_rows(y))
+        if my is not nomask:
+            m = mask_or(m, my[:, 0])
+    else:
+        raise TypeError("Expected a 1D or 2D array for y!")
+
+    if w is not None:
+        w = asarray(w)
+        if w.ndim != 1:
+            raise TypeError("expected a 1-d array for weights")
+        if w.shape[0] != y.shape[0]:
+            raise TypeError("expected w and y to have the same length")
+        m = mask_or(m, getmask(w))
+
+    if m is not nomask:
+        not_m = ~m
+        if w is not None:
+            w = w[not_m]
+        return np.polyfit(x[not_m], y[not_m], deg, rcond, full, w, cov)
+    else:
+        return np.polyfit(x, y, deg, rcond, full, w, cov)
+
+polyfit.__doc__ = ma.doc_note(np.polyfit.__doc__, polyfit.__doc__)
diff --git a/venv/lib/python3.12/site-packages/numpy/ma/extras.pyi b/venv/lib/python3.12/site-packages/numpy/ma/extras.pyi
new file mode 100644
index 00000000..8e458fe1
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/ma/extras.pyi
@@ -0,0 +1,86 @@
+from typing import Any
+
+from numpy.lib._index_tricks_impl import AxisConcatenator
+
+from numpy.ma.core import (
+    dot as dot,
+    mask_rowcols as mask_rowcols,
+)
+
+__all__: list[str]
+
+def count_masked(arr, axis=...): ...
+def masked_all(shape, dtype = ...): ...
+def masked_all_like(arr): ...
+
+class _fromnxfunction:
+    __name__: Any
+    __doc__: Any
+    def __init__(self, funcname): ...
+    def getdoc(self): ...
+    def __call__(self, *args, **params): ...
+
+class _fromnxfunction_single(_fromnxfunction):
+    def __call__(self, x, *args, **params): ...
+
+class _fromnxfunction_seq(_fromnxfunction):
+    def __call__(self, x, *args, **params): ...
+
+class _fromnxfunction_allargs(_fromnxfunction):
+    def __call__(self, *args, **params): ...
+
+atleast_1d: _fromnxfunction_allargs
+atleast_2d: _fromnxfunction_allargs
+atleast_3d: _fromnxfunction_allargs
+
+vstack: _fromnxfunction_seq
+row_stack: _fromnxfunction_seq
+hstack: _fromnxfunction_seq
+column_stack: _fromnxfunction_seq
+dstack: _fromnxfunction_seq
+stack: _fromnxfunction_seq
+
+hsplit: _fromnxfunction_single
+diagflat: _fromnxfunction_single
+
+def apply_along_axis(func1d, axis, arr, *args, **kwargs): ...
+def apply_over_axes(func, a, axes): ...
+def average(a, axis=..., weights=..., returned=..., keepdims=...): ...
+def median(a, axis=..., out=..., overwrite_input=..., keepdims=...): ...
+def compress_nd(x, axis=...): ...
+def compress_rowcols(x, axis=...): ...
+def compress_rows(a): ...
+def compress_cols(a): ...
+def mask_rows(a, axis = ...): ...
+def mask_cols(a, axis = ...): ...
+def ediff1d(arr, to_end=..., to_begin=...): ...
+def unique(ar1, return_index=..., return_inverse=...): ...
+def intersect1d(ar1, ar2, assume_unique=...): ...
+def setxor1d(ar1, ar2, assume_unique=...): ...
+def in1d(ar1, ar2, assume_unique=..., invert=...): ...
+def isin(element, test_elements, assume_unique=..., invert=...): ...
+def union1d(ar1, ar2): ...
+def setdiff1d(ar1, ar2, assume_unique=...): ...
+def cov(x, y=..., rowvar=..., bias=..., allow_masked=..., ddof=...): ...
+def corrcoef(x, y=..., rowvar=..., bias = ..., allow_masked=..., ddof = ...): ...
+
+class MAxisConcatenator(AxisConcatenator):
+    concatenate: Any
+    @classmethod
+    def makemat(cls, arr): ...
+    def __getitem__(self, key): ...
+
+class mr_class(MAxisConcatenator):
+    def __init__(self): ...
+
+mr_: mr_class
+
+def ndenumerate(a, compressed=...): ...
+def flatnotmasked_edges(a): ...
+def notmasked_edges(a, axis=...): ...
+def flatnotmasked_contiguous(a): ...
+def notmasked_contiguous(a, axis=...): ...
+def clump_unmasked(a): ...
+def clump_masked(a): ...
+def vander(x, n=...): ...
+def polyfit(x, y, deg, rcond=..., full=..., w=..., cov=...): ...
diff --git a/venv/lib/python3.12/site-packages/numpy/ma/mrecords.py b/venv/lib/python3.12/site-packages/numpy/ma/mrecords.py
new file mode 100644
index 00000000..4eb92b6b
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/ma/mrecords.py
@@ -0,0 +1,782 @@
+""":mod:`numpy.ma..mrecords`
+
+Defines the equivalent of :class:`numpy.recarrays` for masked arrays,
+where fields can be accessed as attributes.
+Note that :class:`numpy.ma.MaskedArray` already supports structured datatypes
+and the masking of individual fields.
+
+.. moduleauthor:: Pierre Gerard-Marchant
+
+"""
+#  We should make sure that no field is called '_mask','mask','_fieldmask',
+#  or whatever restricted keywords.  An idea would be to no bother in the
+#  first place, and then rename the invalid fields with a trailing
+#  underscore. Maybe we could just overload the parser function ?
+
+from numpy.ma import (
+    MAError, MaskedArray, masked, nomask, masked_array, getdata,
+    getmaskarray, filled
+)
+import numpy.ma as ma
+import warnings
+
+import numpy as np
+from numpy import dtype, ndarray, array as narray
+
+from numpy._core.records import (
+    recarray, fromarrays as recfromarrays, fromrecords as recfromrecords
+)
+
+_byteorderconv = np._core.records._byteorderconv
+
+
+_check_fill_value = ma.core._check_fill_value
+
+
+__all__ = [
+    'MaskedRecords', 'mrecarray', 'fromarrays', 'fromrecords',
+    'fromtextfile', 'addfield',
+]
+
+reserved_fields = ['_data', '_mask', '_fieldmask', 'dtype']
+
+
+def _checknames(descr, names=None):
+    """
+    Checks that field names ``descr`` are not reserved keywords.
+
+    If this is the case, a default 'f%i' is substituted.  If the argument
+    `names` is not None, updates the field names to valid names.
+
+    """
+    ndescr = len(descr)
+    default_names = ['f%i' % i for i in range(ndescr)]
+    if names is None:
+        new_names = default_names
+    else:
+        if isinstance(names, (tuple, list)):
+            new_names = names
+        elif isinstance(names, str):
+            new_names = names.split(',')
+        else:
+            raise NameError(f'illegal input names {names!r}')
+        nnames = len(new_names)
+        if nnames < ndescr:
+            new_names += default_names[nnames:]
+    ndescr = []
+    for (n, d, t) in zip(new_names, default_names, descr.descr):
+        if n in reserved_fields:
+            if t[0] in reserved_fields:
+                ndescr.append((d, t[1]))
+            else:
+                ndescr.append(t)
+        else:
+            ndescr.append((n, t[1]))
+    return np.dtype(ndescr)
+
+
+def _get_fieldmask(self):
+    mdescr = [(n, '|b1') for n in self.dtype.names]
+    fdmask = np.empty(self.shape, dtype=mdescr)
+    fdmask.flat = tuple([False] * len(mdescr))
+    return fdmask
+
+
+class MaskedRecords(MaskedArray):
+    """
+
+    Attributes
+    ----------
+    _data : recarray
+        Underlying data, as a record array.
+    _mask : boolean array
+        Mask of the records. A record is masked when all its fields are
+        masked.
+    _fieldmask : boolean recarray
+        Record array of booleans, setting the mask of each individual field
+        of each record.
+    _fill_value : record
+        Filling values for each field.
+
+    """
+
+    def __new__(cls, shape, dtype=None, buf=None, offset=0, strides=None,
+                formats=None, names=None, titles=None,
+                byteorder=None, aligned=False,
+                mask=nomask, hard_mask=False, fill_value=None, keep_mask=True,
+                copy=False,
+                **options):
+
+        self = recarray.__new__(cls, shape, dtype=dtype, buf=buf, offset=offset,
+                                strides=strides, formats=formats, names=names,
+                                titles=titles, byteorder=byteorder,
+                                aligned=aligned,)
+
+        mdtype = ma.make_mask_descr(self.dtype)
+        if mask is nomask or not np.size(mask):
+            if not keep_mask:
+                self._mask = tuple([False] * len(mdtype))
+        else:
+            mask = np.array(mask, copy=copy)
+            if mask.shape != self.shape:
+                (nd, nm) = (self.size, mask.size)
+                if nm == 1:
+                    mask = np.resize(mask, self.shape)
+                elif nm == nd:
+                    mask = np.reshape(mask, self.shape)
+                else:
+                    msg = "Mask and data not compatible: data size is %i, " + \
+                          "mask size is %i."
+                    raise MAError(msg % (nd, nm))
+            if not keep_mask:
+                self.__setmask__(mask)
+                self._sharedmask = True
+            else:
+                if mask.dtype == mdtype:
+                    _mask = mask
+                else:
+                    _mask = np.array([tuple([m] * len(mdtype)) for m in mask],
+                                     dtype=mdtype)
+                self._mask = _mask
+        return self
+
+    def __array_finalize__(self, obj):
+        # Make sure we have a _fieldmask by default
+        _mask = getattr(obj, '_mask', None)
+        if _mask is None:
+            objmask = getattr(obj, '_mask', nomask)
+            _dtype = ndarray.__getattribute__(self, 'dtype')
+            if objmask is nomask:
+                _mask = ma.make_mask_none(self.shape, dtype=_dtype)
+            else:
+                mdescr = ma.make_mask_descr(_dtype)
+                _mask = narray([tuple([m] * len(mdescr)) for m in objmask],
+                               dtype=mdescr).view(recarray)
+        # Update some of the attributes
+        _dict = self.__dict__
+        _dict.update(_mask=_mask)
+        self._update_from(obj)
+        if _dict['_baseclass'] == ndarray:
+            _dict['_baseclass'] = recarray
+        return
+
+    @property
+    def _data(self):
+        """
+        Returns the data as a recarray.
+
+        """
+        return ndarray.view(self, recarray)
+
+    @property
+    def _fieldmask(self):
+        """
+        Alias to mask.
+
+        """
+        return self._mask
+
+    def __len__(self):
+        """
+        Returns the length
+
+        """
+        # We have more than one record
+        if self.ndim:
+            return len(self._data)
+        # We have only one record: return the nb of fields
+        return len(self.dtype)
+
+    def __getattribute__(self, attr):
+        try:
+            return object.__getattribute__(self, attr)
+        except AttributeError:
+            # attr must be a fieldname
+            pass
+        fielddict = ndarray.__getattribute__(self, 'dtype').fields
+        try:
+            res = fielddict[attr][:2]
+        except (TypeError, KeyError) as e:
+            raise AttributeError(
+                f'record array has no attribute {attr}') from e
+        # So far, so good
+        _localdict = ndarray.__getattribute__(self, '__dict__')
+        _data = ndarray.view(self, _localdict['_baseclass'])
+        obj = _data.getfield(*res)
+        if obj.dtype.names is not None:
+            raise NotImplementedError("MaskedRecords is currently limited to"
+                                      "simple records.")
+        # Get some special attributes
+        # Reset the object's mask
+        hasmasked = False
+        _mask = _localdict.get('_mask', None)
+        if _mask is not None:
+            try:
+                _mask = _mask[attr]
+            except IndexError:
+                # Couldn't find a mask: use the default (nomask)
+                pass
+            tp_len = len(_mask.dtype)
+            hasmasked = _mask.view((bool, ((tp_len,) if tp_len else ()))).any()
+        if (obj.shape or hasmasked):
+            obj = obj.view(MaskedArray)
+            obj._baseclass = ndarray
+            obj._isfield = True
+            obj._mask = _mask
+            # Reset the field values
+            _fill_value = _localdict.get('_fill_value', None)
+            if _fill_value is not None:
+                try:
+                    obj._fill_value = _fill_value[attr]
+                except ValueError:
+                    obj._fill_value = None
+        else:
+            obj = obj.item()
+        return obj
+
+    def __setattr__(self, attr, val):
+        """
+        Sets the attribute attr to the value val.
+
+        """
+        # Should we call __setmask__ first ?
+        if attr in ['mask', 'fieldmask']:
+            self.__setmask__(val)
+            return
+        # Create a shortcut (so that we don't have to call getattr all the time)
+        _localdict = object.__getattribute__(self, '__dict__')
+        # Check whether we're creating a new field
+        newattr = attr not in _localdict
+        try:
+            # Is attr a generic attribute ?
+            ret = object.__setattr__(self, attr, val)
+        except Exception:
+            # Not a generic attribute: exit if it's not a valid field
+            fielddict = ndarray.__getattribute__(self, 'dtype').fields or {}
+            optinfo = ndarray.__getattribute__(self, '_optinfo') or {}
+            if not (attr in fielddict or attr in optinfo):
+                raise
+        else:
+            # Get the list of names
+            fielddict = ndarray.__getattribute__(self, 'dtype').fields or {}
+            # Check the attribute
+            if attr not in fielddict:
+                return ret
+            if newattr:
+                # We just added this one or this setattr worked on an
+                # internal attribute.
+                try:
+                    object.__delattr__(self, attr)
+                except Exception:
+                    return ret
+        # Let's try to set the field
+        try:
+            res = fielddict[attr][:2]
+        except (TypeError, KeyError) as e:
+            raise AttributeError(
+                f'record array has no attribute {attr}') from e
+
+        if val is masked:
+            _fill_value = _localdict['_fill_value']
+            if _fill_value is not None:
+                dval = _localdict['_fill_value'][attr]
+            else:
+                dval = val
+            mval = True
+        else:
+            dval = filled(val)
+            mval = getmaskarray(val)
+        obj = ndarray.__getattribute__(self, '_data').setfield(dval, *res)
+        _localdict['_mask'].__setitem__(attr, mval)
+        return obj
+
+    def __getitem__(self, indx):
+        """
+        Returns all the fields sharing the same fieldname base.
+
+        The fieldname base is either `_data` or `_mask`.
+
+        """
+        _localdict = self.__dict__
+        _mask = ndarray.__getattribute__(self, '_mask')
+        _data = ndarray.view(self, _localdict['_baseclass'])
+        # We want a field
+        if isinstance(indx, str):
+            # Make sure _sharedmask is True to propagate back to _fieldmask
+            # Don't use _set_mask, there are some copies being made that
+            # break propagation Don't force the mask to nomask, that wreaks
+            # easy masking
+            obj = _data[indx].view(MaskedArray)
+            obj._mask = _mask[indx]
+            obj._sharedmask = True
+            fval = _localdict['_fill_value']
+            if fval is not None:
+                obj._fill_value = fval[indx]
+            # Force to masked if the mask is True
+            if not obj.ndim and obj._mask:
+                return masked
+            return obj
+        # We want some elements.
+        # First, the data.
+        obj = np.asarray(_data[indx]).view(mrecarray)
+        obj._mask = np.asarray(_mask[indx]).view(recarray)
+        return obj
+
+    def __setitem__(self, indx, value):
+        """
+        Sets the given record to value.
+
+        """
+        MaskedArray.__setitem__(self, indx, value)
+        if isinstance(indx, str):
+            self._mask[indx] = ma.getmaskarray(value)
+
+    def __str__(self):
+        """
+        Calculates the string representation.
+
+        """
+        if self.size > 1:
+            mstr = [f"({','.join([str(i) for i in s])})"
+                    for s in zip(*[getattr(self, f) for f in self.dtype.names])]
+            return f"[{', '.join(mstr)}]"
+        else:
+            mstr = [f"{','.join([str(i) for i in s])}"
+                    for s in zip([getattr(self, f) for f in self.dtype.names])]
+            return f"({', '.join(mstr)})"
+
+    def __repr__(self):
+        """
+        Calculates the repr representation.
+
+        """
+        _names = self.dtype.names
+        fmt = "%%%is : %%s" % (max([len(n) for n in _names]) + 4,)
+        reprstr = [fmt % (f, getattr(self, f)) for f in self.dtype.names]
+        reprstr.insert(0, 'masked_records(')
+        reprstr.extend([fmt % ('    fill_value', self.fill_value),
+                        '              )'])
+        return str("\n".join(reprstr))
+
+    def view(self, dtype=None, type=None):
+        """
+        Returns a view of the mrecarray.
+
+        """
+        # OK, basic copy-paste from MaskedArray.view.
+        if dtype is None:
+            if type is None:
+                output = ndarray.view(self)
+            else:
+                output = ndarray.view(self, type)
+        # Here again.
+        elif type is None:
+            try:
+                if issubclass(dtype, ndarray):
+                    output = ndarray.view(self, dtype)
+                else:
+                    output = ndarray.view(self, dtype)
+            # OK, there's the change
+            except TypeError:
+                dtype = np.dtype(dtype)
+                # we need to revert to MaskedArray, but keeping the possibility
+                # of subclasses (eg, TimeSeriesRecords), so we'll force a type
+                # set to the first parent
+                if dtype.fields is None:
+                    basetype = self.__class__.__bases__[0]
+                    output = self.__array__().view(dtype, basetype)
+                    output._update_from(self)
+                else:
+                    output = ndarray.view(self, dtype)
+                output._fill_value = None
+        else:
+            output = ndarray.view(self, dtype, type)
+        # Update the mask, just like in MaskedArray.view
+        if (getattr(output, '_mask', nomask) is not nomask):
+            mdtype = ma.make_mask_descr(output.dtype)
+            output._mask = self._mask.view(mdtype, ndarray)
+            output._mask.shape = output.shape
+        return output
+
+    def harden_mask(self):
+        """
+        Forces the mask to hard.
+
+        """
+        self._hardmask = True
+
+    def soften_mask(self):
+        """
+        Forces the mask to soft
+
+        """
+        self._hardmask = False
+
+    def copy(self):
+        """
+        Returns a copy of the masked record.
+
+        """
+        copied = self._data.copy().view(type(self))
+        copied._mask = self._mask.copy()
+        return copied
+
+    def tolist(self, fill_value=None):
+        """
+        Return the data portion of the array as a list.
+
+        Data items are converted to the nearest compatible Python type.
+        Masked values are converted to fill_value. If fill_value is None,
+        the corresponding entries in the output list will be ``None``.
+
+        """
+        if fill_value is not None:
+            return self.filled(fill_value).tolist()
+        result = narray(self.filled().tolist(), dtype=object)
+        mask = narray(self._mask.tolist())
+        result[mask] = None
+        return result.tolist()
+
+    def __getstate__(self):
+        """Return the internal state of the masked array.
+
+        This is for pickling.
+
+        """
+        state = (1,
+                 self.shape,
+                 self.dtype,
+                 self.flags.fnc,
+                 self._data.tobytes(),
+                 self._mask.tobytes(),
+                 self._fill_value,
+                 )
+        return state
+
+    def __setstate__(self, state):
+        """
+        Restore the internal state of the masked array.
+
+        This is for pickling.  ``state`` is typically the output of the
+        ``__getstate__`` output, and is a 5-tuple:
+
+        - class name
+        - a tuple giving the shape of the data
+        - a typecode for the data
+        - a binary string for the data
+        - a binary string for the mask.
+
+        """
+        (ver, shp, typ, isf, raw, msk, flv) = state
+        ndarray.__setstate__(self, (shp, typ, isf, raw))
+        mdtype = dtype([(k, np.bool) for (k, _) in self.dtype.descr])
+        self.__dict__['_mask'].__setstate__((shp, mdtype, isf, msk))
+        self.fill_value = flv
+
+    def __reduce__(self):
+        """
+        Return a 3-tuple for pickling a MaskedArray.
+
+        """
+        return (_mrreconstruct,
+                (self.__class__, self._baseclass, (0,), 'b',),
+                self.__getstate__())
+
+
+def _mrreconstruct(subtype, baseclass, baseshape, basetype,):
+    """
+    Build a new MaskedArray from the information stored in a pickle.
+
+    """
+    _data = ndarray.__new__(baseclass, baseshape, basetype).view(subtype)
+    _mask = ndarray.__new__(ndarray, baseshape, 'b1')
+    return subtype.__new__(subtype, _data, mask=_mask, dtype=basetype,)
+
+mrecarray = MaskedRecords
+
+
+###############################################################################
+#                             Constructors                                    #
+###############################################################################
+
+
+def fromarrays(arraylist, dtype=None, shape=None, formats=None,
+               names=None, titles=None, aligned=False, byteorder=None,
+               fill_value=None):
+    """
+    Creates a mrecarray from a (flat) list of masked arrays.
+
+    Parameters
+    ----------
+    arraylist : sequence
+        A list of (masked) arrays. Each element of the sequence is first converted
+        to a masked array if needed. If a 2D array is passed as argument, it is
+        processed line by line
+    dtype : {None, dtype}, optional
+        Data type descriptor.
+    shape : {None, integer}, optional
+        Number of records. If None, shape is defined from the shape of the
+        first array in the list.
+    formats : {None, sequence}, optional
+        Sequence of formats for each individual field. If None, the formats will
+        be autodetected by inspecting the fields and selecting the highest dtype
+        possible.
+    names : {None, sequence}, optional
+        Sequence of the names of each field.
+    fill_value : {None, sequence}, optional
+        Sequence of data to be used as filling values.
+
+    Notes
+    -----
+    Lists of tuples should be preferred over lists of lists for faster processing.
+
+    """
+    datalist = [getdata(x) for x in arraylist]
+    masklist = [np.atleast_1d(getmaskarray(x)) for x in arraylist]
+    _array = recfromarrays(datalist,
+                           dtype=dtype, shape=shape, formats=formats,
+                           names=names, titles=titles, aligned=aligned,
+                           byteorder=byteorder).view(mrecarray)
+    _array._mask.flat = list(zip(*masklist))
+    if fill_value is not None:
+        _array.fill_value = fill_value
+    return _array
+
+
+def fromrecords(reclist, dtype=None, shape=None, formats=None, names=None,
+                titles=None, aligned=False, byteorder=None,
+                fill_value=None, mask=nomask):
+    """
+    Creates a MaskedRecords from a list of records.
+
+    Parameters
+    ----------
+    reclist : sequence
+        A list of records. Each element of the sequence is first converted
+        to a masked array if needed. If a 2D array is passed as argument, it is
+        processed line by line
+    dtype : {None, dtype}, optional
+        Data type descriptor.
+    shape : {None,int}, optional
+        Number of records. If None, ``shape`` is defined from the shape of the
+        first array in the list.
+    formats : {None, sequence}, optional
+        Sequence of formats for each individual field. If None, the formats will
+        be autodetected by inspecting the fields and selecting the highest dtype
+        possible.
+    names : {None, sequence}, optional
+        Sequence of the names of each field.
+    fill_value : {None, sequence}, optional
+        Sequence of data to be used as filling values.
+    mask : {nomask, sequence}, optional.
+        External mask to apply on the data.
+
+    Notes
+    -----
+    Lists of tuples should be preferred over lists of lists for faster processing.
+
+    """
+    # Grab the initial _fieldmask, if needed:
+    _mask = getattr(reclist, '_mask', None)
+    # Get the list of records.
+    if isinstance(reclist, ndarray):
+        # Make sure we don't have some hidden mask
+        if isinstance(reclist, MaskedArray):
+            reclist = reclist.filled().view(ndarray)
+        # Grab the initial dtype, just in case
+        if dtype is None:
+            dtype = reclist.dtype
+        reclist = reclist.tolist()
+    mrec = recfromrecords(reclist, dtype=dtype, shape=shape, formats=formats,
+                          names=names, titles=titles,
+                          aligned=aligned, byteorder=byteorder).view(mrecarray)
+    # Set the fill_value if needed
+    if fill_value is not None:
+        mrec.fill_value = fill_value
+    # Now, let's deal w/ the mask
+    if mask is not nomask:
+        mask = np.asarray(mask)
+        maskrecordlength = len(mask.dtype)
+        if maskrecordlength:
+            mrec._mask.flat = mask
+        elif mask.ndim == 2:
+            mrec._mask.flat = [tuple(m) for m in mask]
+        else:
+            mrec.__setmask__(mask)
+    if _mask is not None:
+        mrec._mask[:] = _mask
+    return mrec
+
+
+def _guessvartypes(arr):
+    """
+    Tries to guess the dtypes of the str_ ndarray `arr`.
+
+    Guesses by testing element-wise conversion. Returns a list of dtypes.
+    The array is first converted to ndarray. If the array is 2D, the test
+    is performed on the first line. An exception is raised if the file is
+    3D or more.
+
+    """
+    vartypes = []
+    arr = np.asarray(arr)
+    if arr.ndim == 2:
+        arr = arr[0]
+    elif arr.ndim > 2:
+        raise ValueError("The array should be 2D at most!")
+    # Start the conversion loop.
+    for f in arr:
+        try:
+            int(f)
+        except (ValueError, TypeError):
+            try:
+                float(f)
+            except (ValueError, TypeError):
+                try:
+                    complex(f)
+                except (ValueError, TypeError):
+                    vartypes.append(arr.dtype)
+                else:
+                    vartypes.append(np.dtype(complex))
+            else:
+                vartypes.append(np.dtype(float))
+        else:
+            vartypes.append(np.dtype(int))
+    return vartypes
+
+
+def openfile(fname):
+    """
+    Opens the file handle of file `fname`.
+
+    """
+    # A file handle
+    if hasattr(fname, 'readline'):
+        return fname
+    # Try to open the file and guess its type
+    try:
+        f = open(fname)
+    except FileNotFoundError as e:
+        raise FileNotFoundError(f"No such file: '{fname}'") from e
+    if f.readline()[:2] != "\\x":
+        f.seek(0, 0)
+        return f
+    f.close()
+    raise NotImplementedError("Wow, binary file")
+
+
+def fromtextfile(fname, delimiter=None, commentchar='#', missingchar='',
+                 varnames=None, vartypes=None,
+                 *, delimitor=np._NoValue):  # backwards compatibility
+    """
+    Creates a mrecarray from data stored in the file `filename`.
+
+    Parameters
+    ----------
+    fname : {file name/handle}
+        Handle of an opened file.
+    delimiter : {None, string}, optional
+        Alphanumeric character used to separate columns in the file.
+        If None, any (group of) white spacestring(s) will be used.
+    commentchar : {'#', string}, optional
+        Alphanumeric character used to mark the start of a comment.
+    missingchar : {'', string}, optional
+        String indicating missing data, and used to create the masks.
+    varnames : {None, sequence}, optional
+        Sequence of the variable names. If None, a list will be created from
+        the first non empty line of the file.
+    vartypes : {None, sequence}, optional
+        Sequence of the variables dtypes. If None, it will be estimated from
+        the first non-commented line.
+
+
+    Ultra simple: the varnames are in the header, one line"""
+    if delimitor is not np._NoValue:
+        if delimiter is not None:
+            raise TypeError("fromtextfile() got multiple values for argument "
+                            "'delimiter'")
+        # NumPy 1.22.0, 2021-09-23
+        warnings.warn("The 'delimitor' keyword argument of "
+                      "numpy.ma.mrecords.fromtextfile() is deprecated "
+                      "since NumPy 1.22.0, use 'delimiter' instead.",
+                      DeprecationWarning, stacklevel=2)
+        delimiter = delimitor
+
+    # Try to open the file.
+    ftext = openfile(fname)
+
+    # Get the first non-empty line as the varnames
+    while True:
+        line = ftext.readline()
+        firstline = line[:line.find(commentchar)].strip()
+        _varnames = firstline.split(delimiter)
+        if len(_varnames) > 1:
+            break
+    if varnames is None:
+        varnames = _varnames
+
+    # Get the data.
+    _variables = masked_array([line.strip().split(delimiter) for line in ftext
+                               if line[0] != commentchar and len(line) > 1])
+    (_, nfields) = _variables.shape
+    ftext.close()
+
+    # Try to guess the dtype.
+    if vartypes is None:
+        vartypes = _guessvartypes(_variables[0])
+    else:
+        vartypes = [np.dtype(v) for v in vartypes]
+        if len(vartypes) != nfields:
+            msg = "Attempting to %i dtypes for %i fields!"
+            msg += " Reverting to default."
+            warnings.warn(msg % (len(vartypes), nfields), stacklevel=2)
+            vartypes = _guessvartypes(_variables[0])
+
+    # Construct the descriptor.
+    mdescr = [(n, f) for (n, f) in zip(varnames, vartypes)]
+    mfillv = [ma.default_fill_value(f) for f in vartypes]
+
+    # Get the data and the mask.
+    # We just need a list of masked_arrays. It's easier to create it like that:
+    _mask = (_variables.T == missingchar)
+    _datalist = [masked_array(a, mask=m, dtype=t, fill_value=f)
+                 for (a, m, t, f) in zip(_variables.T, _mask, vartypes, mfillv)]
+
+    return fromarrays(_datalist, dtype=mdescr)
+
+
+def addfield(mrecord, newfield, newfieldname=None):
+    """Adds a new field to the masked record array
+
+    Uses `newfield` as data and `newfieldname` as name. If `newfieldname`
+    is None, the new field name is set to 'fi', where `i` is the number of
+    existing fields.
+
+    """
+    _data = mrecord._data
+    _mask = mrecord._mask
+    if newfieldname is None or newfieldname in reserved_fields:
+        newfieldname = 'f%i' % len(_data.dtype)
+    newfield = ma.array(newfield)
+    # Get the new data.
+    # Create a new empty recarray
+    newdtype = np.dtype(_data.dtype.descr + [(newfieldname, newfield.dtype)])
+    newdata = recarray(_data.shape, newdtype)
+    # Add the existing field
+    [newdata.setfield(_data.getfield(*f), *f)
+     for f in _data.dtype.fields.values()]
+    # Add the new field
+    newdata.setfield(newfield._data, *newdata.dtype.fields[newfieldname])
+    newdata = newdata.view(MaskedRecords)
+    # Get the new mask
+    # Create a new empty recarray
+    newmdtype = np.dtype([(n, np.bool) for n in newdtype.names])
+    newmask = recarray(_data.shape, newmdtype)
+    # Add the old masks
+    [newmask.setfield(_mask.getfield(*f), *f)
+     for f in _mask.dtype.fields.values()]
+    # Add the mask of the new field
+    newmask.setfield(getmaskarray(newfield),
+                     *newmask.dtype.fields[newfieldname])
+    newdata._mask = newmask
+    return newdata
diff --git a/venv/lib/python3.12/site-packages/numpy/ma/mrecords.pyi b/venv/lib/python3.12/site-packages/numpy/ma/mrecords.pyi
new file mode 100644
index 00000000..85714420
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/ma/mrecords.pyi
@@ -0,0 +1,88 @@
+from typing import Any, TypeVar
+
+from numpy import dtype
+from numpy.ma import MaskedArray
+
+__all__: list[str]
+
+_ShapeType_co = TypeVar("_ShapeType_co", covariant=True, bound=tuple[int, ...])
+_DType_co = TypeVar("_DType_co", bound=dtype[Any], covariant=True)
+
+class MaskedRecords(MaskedArray[_ShapeType_co, _DType_co]):
+    def __new__(
+        cls,
+        shape,
+        dtype=...,
+        buf=...,
+        offset=...,
+        strides=...,
+        formats=...,
+        names=...,
+        titles=...,
+        byteorder=...,
+        aligned=...,
+        mask=...,
+        hard_mask=...,
+        fill_value=...,
+        keep_mask=...,
+        copy=...,
+        **options,
+    ): ...
+    _mask: Any
+    _fill_value: Any
+    @property
+    def _data(self): ...
+    @property
+    def _fieldmask(self): ...
+    def __array_finalize__(self, obj): ...
+    def __len__(self): ...
+    def __getattribute__(self, attr): ...
+    def __setattr__(self, attr, val): ...
+    def __getitem__(self, indx): ...
+    def __setitem__(self, indx, value): ...
+    def view(self, dtype=..., type=...): ...
+    def harden_mask(self): ...
+    def soften_mask(self): ...
+    def copy(self): ...
+    def tolist(self, fill_value=...): ...
+    def __reduce__(self): ...
+
+mrecarray = MaskedRecords
+
+def fromarrays(
+    arraylist,
+    dtype=...,
+    shape=...,
+    formats=...,
+    names=...,
+    titles=...,
+    aligned=...,
+    byteorder=...,
+    fill_value=...,
+): ...
+
+def fromrecords(
+    reclist,
+    dtype=...,
+    shape=...,
+    formats=...,
+    names=...,
+    titles=...,
+    aligned=...,
+    byteorder=...,
+    fill_value=...,
+    mask=...,
+): ...
+
+def fromtextfile(
+    fname,
+    delimiter=...,
+    commentchar=...,
+    missingchar=...,
+    varnames=...,
+    vartypes=...,
+    # NOTE: deprecated: NumPy 1.22.0, 2021-09-23
+    # delimitor=...,
+): ...
+
+def addfield(mrecord, newfield, newfieldname=...): ...
diff --git a/venv/lib/python3.12/site-packages/numpy/ma/tests/__init__.py b/venv/lib/python3.12/site-packages/numpy/ma/tests/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/venv/lib/python3.12/site-packages/numpy/ma/tests/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/ma/tests/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 00000000..d018b292
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/ma/tests/__pycache__/__init__.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/ma/tests/__pycache__/test_arrayobject.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/ma/tests/__pycache__/test_arrayobject.cpython-312.pyc
new file mode 100644
index 00000000..9fa7a89e
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/ma/tests/__pycache__/test_arrayobject.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/ma/tests/__pycache__/test_core.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/ma/tests/__pycache__/test_core.cpython-312.pyc
new file mode 100644
index 00000000..2f3656ee
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/ma/tests/__pycache__/test_core.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/ma/tests/__pycache__/test_deprecations.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/ma/tests/__pycache__/test_deprecations.cpython-312.pyc
new file mode 100644
index 00000000..16b73fc3
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/ma/tests/__pycache__/test_deprecations.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/ma/tests/__pycache__/test_extras.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/ma/tests/__pycache__/test_extras.cpython-312.pyc
new file mode 100644
index 00000000..eed83428
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/ma/tests/__pycache__/test_extras.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/ma/tests/__pycache__/test_mrecords.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/ma/tests/__pycache__/test_mrecords.cpython-312.pyc
new file mode 100644
index 00000000..32472ee6
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/ma/tests/__pycache__/test_mrecords.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/ma/tests/__pycache__/test_old_ma.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/ma/tests/__pycache__/test_old_ma.cpython-312.pyc
new file mode 100644
index 00000000..423b4db6
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/ma/tests/__pycache__/test_old_ma.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/ma/tests/__pycache__/test_regression.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/ma/tests/__pycache__/test_regression.cpython-312.pyc
new file mode 100644
index 00000000..be525e60
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/ma/tests/__pycache__/test_regression.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/ma/tests/__pycache__/test_subclassing.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/ma/tests/__pycache__/test_subclassing.cpython-312.pyc
new file mode 100644
index 00000000..d127aefe
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/ma/tests/__pycache__/test_subclassing.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/ma/tests/test_arrayobject.py b/venv/lib/python3.12/site-packages/numpy/ma/tests/test_arrayobject.py
new file mode 100644
index 00000000..2000cea2
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/ma/tests/test_arrayobject.py
@@ -0,0 +1,40 @@
+import pytest
+
+import numpy as np
+from numpy.ma import masked_array
+from numpy.testing import assert_array_equal
+
+
+def test_matrix_transpose_raises_error_for_1d():
+    msg = "matrix transpose with ndim < 2 is undefined"
+    ma_arr = masked_array(data=[1, 2, 3, 4, 5, 6],
+                          mask=[1, 0, 1, 1, 1, 0])
+    with pytest.raises(ValueError, match=msg):
+        ma_arr.mT
+
+
+def test_matrix_transpose_equals_transpose_2d():
+    ma_arr = masked_array(data=[[1, 2, 3], [4, 5, 6]],
+                          mask=[[1, 0, 1], [1, 1, 0]])
+    assert_array_equal(ma_arr.T, ma_arr.mT)
+
+
+ARRAY_SHAPES_TO_TEST = (
+    (5, 2),
+    (5, 2, 3),
+    (5, 2, 3, 4),
+)
+
+
+@pytest.mark.parametrize("shape", ARRAY_SHAPES_TO_TEST)
+def test_matrix_transpose_equals_swapaxes(shape):
+    num_of_axes = len(shape)
+    vec = np.arange(shape[-1])
+    arr = np.broadcast_to(vec, shape)
+
+    rng = np.random.default_rng(42)
+    mask = rng.choice([0, 1], size=shape)
+    ma_arr = masked_array(data=arr, mask=mask)
+
+    tgt = np.swapaxes(arr, num_of_axes - 2, num_of_axes - 1)
+    assert_array_equal(tgt, ma_arr.mT)
diff --git a/venv/lib/python3.12/site-packages/numpy/ma/tests/test_core.py b/venv/lib/python3.12/site-packages/numpy/ma/tests/test_core.py
new file mode 100644
index 00000000..970ae287
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/ma/tests/test_core.py
@@ -0,0 +1,5709 @@
+# pylint: disable-msg=W0400,W0511,W0611,W0612,W0614,R0201,E1102
+"""Tests suite for MaskedArray & subclassing.
+
+:author: Pierre Gerard-Marchant
+:contact: pierregm_at_uga_dot_edu
+"""
+__author__ = "Pierre GF Gerard-Marchant"
+
+import sys
+import warnings
+import copy
+import operator
+import itertools
+import textwrap
+import pickle
+from functools import reduce
+
+import pytest
+
+import numpy as np
+import numpy.ma.core
+import numpy._core.fromnumeric as fromnumeric
+import numpy._core.umath as umath
+from numpy.exceptions import AxisError
+from numpy.testing import (
+    assert_raises, assert_warns, suppress_warnings, IS_WASM
+    )
+from numpy.testing._private.utils import requires_memory
+from numpy import ndarray
+from numpy._utils import asbytes
+from numpy.ma.testutils import (
+    assert_, assert_array_equal, assert_equal, assert_almost_equal,
+    assert_equal_records, fail_if_equal, assert_not_equal,
+    assert_mask_equal
+    )
+from numpy.ma.core import (
+    MAError, MaskError, MaskType, MaskedArray, abs, absolute, add, all,
+    allclose, allequal, alltrue, angle, anom, arange, arccos, arccosh, arctan2,
+    arcsin, arctan, argsort, array, asarray, choose, concatenate,
+    conjugate, cos, cosh, count, default_fill_value, diag, divide, doc_note,
+    empty, empty_like, equal, exp, flatten_mask, filled, fix_invalid,
+    flatten_structured_array, fromflex, getmask, getmaskarray, greater,
+    greater_equal, identity, inner, isMaskedArray, less, less_equal, log,
+    log10, make_mask, make_mask_descr, mask_or, masked, masked_array,
+    masked_equal, masked_greater, masked_greater_equal, masked_inside,
+    masked_less, masked_less_equal, masked_not_equal, masked_outside,
+    masked_print_option, masked_values, masked_where, max, maximum,
+    maximum_fill_value, min, minimum, minimum_fill_value, mod, multiply,
+    mvoid, nomask, not_equal, ones, ones_like, outer, power, product, put,
+    putmask, ravel, repeat, reshape, resize, shape, sin, sinh, sometrue, sort,
+    sqrt, subtract, sum, take, tan, tanh, transpose, where, zeros, zeros_like,
+    )
+
+pi = np.pi
+
+
+suppress_copy_mask_on_assignment = suppress_warnings()
+suppress_copy_mask_on_assignment.filter(
+    numpy.ma.core.MaskedArrayFutureWarning,
+    "setting an item on a masked array which has a shared mask will not copy")
+
+
+# For parametrized numeric testing
+num_dts = [np.dtype(dt_) for dt_ in '?bhilqBHILQefdgFD']
+num_ids = [dt_.char for dt_ in num_dts]
+
+
+class TestMaskedArray:
+    # Base test class for MaskedArrays.
+
+    def setup_method(self):
+        # Base data definition.
+        x = np.array([1., 1., 1., -2., pi/2.0, 4., 5., -10., 10., 1., 2., 3.])
+        y = np.array([5., 0., 3., 2., -1., -4., 0., -10., 10., 1., 0., 3.])
+        a10 = 10.
+        m1 = [1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0]
+        m2 = [0, 0, 1, 0, 0, 1, 1, 0, 0, 0, 0, 1]
+        xm = masked_array(x, mask=m1)
+        ym = masked_array(y, mask=m2)
+        z = np.array([-.5, 0., .5, .8])
+        zm = masked_array(z, mask=[0, 1, 0, 0])
+        xf = np.where(m1, 1e+20, x)
+        xm.set_fill_value(1e+20)
+        self.d = (x, y, a10, m1, m2, xm, ym, z, zm, xf)
+
+    def test_basicattributes(self):
+        # Tests some basic array attributes.
+        a = array([1, 3, 2])
+        b = array([1, 3, 2], mask=[1, 0, 1])
+        assert_equal(a.ndim, 1)
+        assert_equal(b.ndim, 1)
+        assert_equal(a.size, 3)
+        assert_equal(b.size, 3)
+        assert_equal(a.shape, (3,))
+        assert_equal(b.shape, (3,))
+
+    def test_basic0d(self):
+        # Checks masking a scalar
+        x = masked_array(0)
+        assert_equal(str(x), '0')
+        x = masked_array(0, mask=True)
+        assert_equal(str(x), str(masked_print_option))
+        x = masked_array(0, mask=False)
+        assert_equal(str(x), '0')
+        x = array(0, mask=1)
+        assert_(x.filled().dtype is x._data.dtype)
+
+    def test_basic1d(self):
+        # Test of basic array creation and properties in 1 dimension.
+        (x, y, a10, m1, m2, xm, ym, z, zm, xf) = self.d
+        assert_(not isMaskedArray(x))
+        assert_(isMaskedArray(xm))
+        assert_((xm - ym).filled(0).any())
+        fail_if_equal(xm.mask.astype(int), ym.mask.astype(int))
+        s = x.shape
+        assert_equal(np.shape(xm), s)
+        assert_equal(xm.shape, s)
+        assert_equal(xm.dtype, x.dtype)
+        assert_equal(zm.dtype, z.dtype)
+        assert_equal(xm.size, reduce(lambda x, y:x * y, s))
+        assert_equal(count(xm), len(m1) - reduce(lambda x, y:x + y, m1))
+        assert_array_equal(xm, xf)
+        assert_array_equal(filled(xm, 1.e20), xf)
+        assert_array_equal(x, xm)
+
+    def test_basic2d(self):
+        # Test of basic array creation and properties in 2 dimensions.
+        (x, y, a10, m1, m2, xm, ym, z, zm, xf) = self.d
+        for s in [(4, 3), (6, 2)]:
+            x.shape = s
+            y.shape = s
+            xm.shape = s
+            ym.shape = s
+            xf.shape = s
+
+            assert_(not isMaskedArray(x))
+            assert_(isMaskedArray(xm))
+            assert_equal(shape(xm), s)
+            assert_equal(xm.shape, s)
+            assert_equal(xm.size, reduce(lambda x, y:x * y, s))
+            assert_equal(count(xm), len(m1) - reduce(lambda x, y:x + y, m1))
+            assert_equal(xm, xf)
+            assert_equal(filled(xm, 1.e20), xf)
+            assert_equal(x, xm)
+
+    def test_concatenate_basic(self):
+        # Tests concatenations.
+        (x, y, a10, m1, m2, xm, ym, z, zm, xf) = self.d
+        # basic concatenation
+        assert_equal(np.concatenate((x, y)), concatenate((xm, ym)))
+        assert_equal(np.concatenate((x, y)), concatenate((x, y)))
+        assert_equal(np.concatenate((x, y)), concatenate((xm, y)))
+        assert_equal(np.concatenate((x, y, x)), concatenate((x, ym, x)))
+
+    def test_concatenate_alongaxis(self):
+        # Tests concatenations.
+        (x, y, a10, m1, m2, xm, ym, z, zm, xf) = self.d
+        # Concatenation along an axis
+        s = (3, 4)
+        x.shape = y.shape = xm.shape = ym.shape = s
+        assert_equal(xm.mask, np.reshape(m1, s))
+        assert_equal(ym.mask, np.reshape(m2, s))
+        xmym = concatenate((xm, ym), 1)
+        assert_equal(np.concatenate((x, y), 1), xmym)
+        assert_equal(np.concatenate((xm.mask, ym.mask), 1), xmym._mask)
+
+        x = zeros(2)
+        y = array(ones(2), mask=[False, True])
+        z = concatenate((x, y))
+        assert_array_equal(z, [0, 0, 1, 1])
+        assert_array_equal(z.mask, [False, False, False, True])
+        z = concatenate((y, x))
+        assert_array_equal(z, [1, 1, 0, 0])
+        assert_array_equal(z.mask, [False, True, False, False])
+
+    def test_concatenate_flexible(self):
+        # Tests the concatenation on flexible arrays.
+        data = masked_array(list(zip(np.random.rand(10),
+                                     np.arange(10))),
+                            dtype=[('a', float), ('b', int)])
+
+        test = concatenate([data[:5], data[5:]])
+        assert_equal_records(test, data)
+
+    def test_creation_ndmin(self):
+        # Check the use of ndmin
+        x = array([1, 2, 3], mask=[1, 0, 0], ndmin=2)
+        assert_equal(x.shape, (1, 3))
+        assert_equal(x._data, [[1, 2, 3]])
+        assert_equal(x._mask, [[1, 0, 0]])
+
+    def test_creation_ndmin_from_maskedarray(self):
+        # Make sure we're not losing the original mask w/ ndmin
+        x = array([1, 2, 3])
+        x[-1] = masked
+        xx = array(x, ndmin=2, dtype=float)
+        assert_equal(x.shape, x._mask.shape)
+        assert_equal(xx.shape, xx._mask.shape)
+
+    def test_creation_maskcreation(self):
+        # Tests how masks are initialized at the creation of Maskedarrays.
+        data = arange(24, dtype=float)
+        data[[3, 6, 15]] = masked
+        dma_1 = MaskedArray(data)
+        assert_equal(dma_1.mask, data.mask)
+        dma_2 = MaskedArray(dma_1)
+        assert_equal(dma_2.mask, dma_1.mask)
+        dma_3 = MaskedArray(dma_1, mask=[1, 0, 0, 0] * 6)
+        fail_if_equal(dma_3.mask, dma_1.mask)
+
+        x = array([1, 2, 3], mask=True)
+        assert_equal(x._mask, [True, True, True])
+        x = array([1, 2, 3], mask=False)
+        assert_equal(x._mask, [False, False, False])
+        y = array([1, 2, 3], mask=x._mask, copy=False)
+        assert_(np.may_share_memory(x.mask, y.mask))
+        y = array([1, 2, 3], mask=x._mask, copy=True)
+        assert_(not np.may_share_memory(x.mask, y.mask))
+        x = array([1, 2, 3], mask=None)
+        assert_equal(x._mask, [False, False, False])
+
+    def test_masked_singleton_array_creation_warns(self):
+        # The first works, but should not (ideally), there may be no way
+        # to solve this, however, as long as `np.ma.masked` is an ndarray.
+        np.array(np.ma.masked)
+        with pytest.warns(UserWarning):
+            # Tries to create a float array, using `float(np.ma.masked)`.
+            # We may want to define this is invalid behaviour in the future!
+            # (requiring np.ma.masked to be a known NumPy scalar probably
+            # with a DType.)
+            np.array([3., np.ma.masked])
+
+    def test_creation_with_list_of_maskedarrays(self):
+        # Tests creating a masked array from a list of masked arrays.
+        x = array(np.arange(5), mask=[1, 0, 0, 0, 0])
+        data = array((x, x[::-1]))
+        assert_equal(data, [[0, 1, 2, 3, 4], [4, 3, 2, 1, 0]])
+        assert_equal(data._mask, [[1, 0, 0, 0, 0], [0, 0, 0, 0, 1]])
+
+        x.mask = nomask
+        data = array((x, x[::-1]))
+        assert_equal(data, [[0, 1, 2, 3, 4], [4, 3, 2, 1, 0]])
+        assert_(data.mask is nomask)
+
+    def test_creation_with_list_of_maskedarrays_no_bool_cast(self):
+        # Tests the regression in gh-18551
+        masked_str = np.ma.masked_array(['a', 'b'], mask=[True, False])
+        normal_int = np.arange(2)
+        res = np.ma.asarray([masked_str, normal_int], dtype="U21")
+        assert_array_equal(res.mask, [[True, False], [False, False]])
+
+        # The above only failed due a long chain of oddity, try also with
+        # an object array that cannot be converted to bool always:
+        class NotBool:
+            def __bool__(self):
+                raise ValueError("not a bool!")
+        masked_obj = np.ma.masked_array([NotBool(), 'b'], mask=[True, False])
+        # Check that the NotBool actually fails like we would expect:
+        with pytest.raises(ValueError, match="not a bool!"):
+            np.asarray([masked_obj], dtype=bool)
+
+        res = np.ma.asarray([masked_obj, normal_int])
+        assert_array_equal(res.mask, [[True, False], [False, False]])
+
+    def test_creation_from_ndarray_with_padding(self):
+        x = np.array([('A', 0)], dtype={'names':['f0','f1'],
+                                        'formats':['S4','i8'],
+                                        'offsets':[0,8]})
+        array(x)  # used to fail due to 'V' padding field in x.dtype.descr
+
+    def test_unknown_keyword_parameter(self):
+        with pytest.raises(TypeError, match="unexpected keyword argument"):
+            MaskedArray([1, 2, 3], maks=[0, 1, 0])  # `mask` is misspelled.
+
+    def test_asarray(self):
+        (x, y, a10, m1, m2, xm, ym, z, zm, xf) = self.d
+        xm.fill_value = -9999
+        xm._hardmask = True
+        xmm = asarray(xm)
+        assert_equal(xmm._data, xm._data)
+        assert_equal(xmm._mask, xm._mask)
+        assert_equal(xmm.fill_value, xm.fill_value)
+        assert_equal(xmm._hardmask, xm._hardmask)
+
+    def test_asarray_default_order(self):
+        # See Issue #6646
+        m = np.eye(3).T
+        assert_(not m.flags.c_contiguous)
+
+        new_m = asarray(m)
+        assert_(new_m.flags.c_contiguous)
+
+    def test_asarray_enforce_order(self):
+        # See Issue #6646
+        m = np.eye(3).T
+        assert_(not m.flags.c_contiguous)
+
+        new_m = asarray(m, order='C')
+        assert_(new_m.flags.c_contiguous)
+
+    def test_fix_invalid(self):
+        # Checks fix_invalid.
+        with np.errstate(invalid='ignore'):
+            data = masked_array([np.nan, 0., 1.], mask=[0, 0, 1])
+            data_fixed = fix_invalid(data)
+            assert_equal(data_fixed._data, [data.fill_value, 0., 1.])
+            assert_equal(data_fixed._mask, [1., 0., 1.])
+
+    def test_maskedelement(self):
+        # Test of masked element
+        x = arange(6)
+        x[1] = masked
+        assert_(str(masked) == '--')
+        assert_(x[1] is masked)
+        assert_equal(filled(x[1], 0), 0)
+
+    def test_set_element_as_object(self):
+        # Tests setting elements with object
+        a = empty(1, dtype=object)
+        x = (1, 2, 3, 4, 5)
+        a[0] = x
+        assert_equal(a[0], x)
+        assert_(a[0] is x)
+
+        import datetime
+        dt = datetime.datetime.now()
+        a[0] = dt
+        assert_(a[0] is dt)
+
+    def test_indexing(self):
+        # Tests conversions and indexing
+        x1 = np.array([1, 2, 4, 3])
+        x2 = array(x1, mask=[1, 0, 0, 0])
+        x3 = array(x1, mask=[0, 1, 0, 1])
+        x4 = array(x1)
+        # test conversion to strings
+        str(x2)  # raises?
+        repr(x2)  # raises?
+        assert_equal(np.sort(x1), sort(x2, endwith=False))
+        # tests of indexing
+        assert_(type(x2[1]) is type(x1[1]))
+        assert_(x1[1] == x2[1])
+        assert_(x2[0] is masked)
+        assert_equal(x1[2], x2[2])
+        assert_equal(x1[2:5], x2[2:5])
+        assert_equal(x1[:], x2[:])
+        assert_equal(x1[1:], x3[1:])
+        x1[2] = 9
+        x2[2] = 9
+        assert_equal(x1, x2)
+        x1[1:3] = 99
+        x2[1:3] = 99
+        assert_equal(x1, x2)
+        x2[1] = masked
+        assert_equal(x1, x2)
+        x2[1:3] = masked
+        assert_equal(x1, x2)
+        x2[:] = x1
+        x2[1] = masked
+        assert_(allequal(getmask(x2), array([0, 1, 0, 0])))
+        x3[:] = masked_array([1, 2, 3, 4], [0, 1, 1, 0])
+        assert_(allequal(getmask(x3), array([0, 1, 1, 0])))
+        x4[:] = masked_array([1, 2, 3, 4], [0, 1, 1, 0])
+        assert_(allequal(getmask(x4), array([0, 1, 1, 0])))
+        assert_(allequal(x4, array([1, 2, 3, 4])))
+        x1 = np.arange(5) * 1.0
+        x2 = masked_values(x1, 3.0)
+        assert_equal(x1, x2)
+        assert_(allequal(array([0, 0, 0, 1, 0], MaskType), x2.mask))
+        assert_equal(3.0, x2.fill_value)
+        x1 = array([1, 'hello', 2, 3], object)
+        x2 = np.array([1, 'hello', 2, 3], object)
+        s1 = x1[1]
+        s2 = x2[1]
+        assert_equal(type(s2), str)
+        assert_equal(type(s1), str)
+        assert_equal(s1, s2)
+        assert_(x1[1:1].shape == (0,))
+
+    def test_setitem_no_warning(self):
+        # Setitem shouldn't warn, because the assignment might be masked
+        # and warning for a masked assignment is weird (see gh-23000)
+        # (When the value is masked, otherwise a warning would be acceptable
+        # but is not given currently.)
+        x = np.ma.arange(60).reshape((6, 10))
+        index = (slice(1, 5, 2), [7, 5])
+        value = np.ma.masked_all((2, 2))
+        value._data[...] = np.inf  # not a valid integer...
+        x[index] = value
+        # The masked scalar is special cased, but test anyway (it's NaN):
+        x[...] = np.ma.masked
+        # Finally, a large value that cannot be cast to the float32 `x`
+        x = np.ma.arange(3., dtype=np.float32)
+        value = np.ma.array([2e234, 1, 1], mask=[True, False, False])
+        x[...] = value
+        x[[0, 1, 2]] = value
+
+    @suppress_copy_mask_on_assignment
+    def test_copy(self):
+        # Tests of some subtle points of copying and sizing.
+        n = [0, 0, 1, 0, 0]
+        m = make_mask(n)
+        m2 = make_mask(m)
+        assert_(m is m2)
+        m3 = make_mask(m, copy=True)
+        assert_(m is not m3)
+
+        x1 = np.arange(5)
+        y1 = array(x1, mask=m)
+        assert_equal(y1._data.__array_interface__, x1.__array_interface__)
+        assert_(allequal(x1, y1.data))
+        assert_equal(y1._mask.__array_interface__, m.__array_interface__)
+
+        y1a = array(y1)
+        # Default for masked array is not to copy; see gh-10318.
+        assert_(y1a._data.__array_interface__ ==
+                        y1._data.__array_interface__)
+        assert_(y1a._mask.__array_interface__ ==
+                        y1._mask.__array_interface__)
+
+        y2 = array(x1, mask=m3)
+        assert_(y2._data.__array_interface__ == x1.__array_interface__)
+        assert_(y2._mask.__array_interface__ == m3.__array_interface__)
+        assert_(y2[2] is masked)
+        y2[2] = 9
+        assert_(y2[2] is not masked)
+        assert_(y2._mask.__array_interface__ == m3.__array_interface__)
+        assert_(allequal(y2.mask, 0))
+
+        y2a = array(x1, mask=m, copy=1)
+        assert_(y2a._data.__array_interface__ != x1.__array_interface__)
+        #assert_( y2a._mask is not m)
+        assert_(y2a._mask.__array_interface__ != m.__array_interface__)
+        assert_(y2a[2] is masked)
+        y2a[2] = 9
+        assert_(y2a[2] is not masked)
+        #assert_( y2a._mask is not m)
+        assert_(y2a._mask.__array_interface__ != m.__array_interface__)
+        assert_(allequal(y2a.mask, 0))
+
+        y3 = array(x1 * 1.0, mask=m)
+        assert_(filled(y3).dtype is (x1 * 1.0).dtype)
+
+        x4 = arange(4)
+        x4[2] = masked
+        y4 = resize(x4, (8,))
+        assert_equal(concatenate([x4, x4]), y4)
+        assert_equal(getmask(y4), [0, 0, 1, 0, 0, 0, 1, 0])
+        y5 = repeat(x4, (2, 2, 2, 2), axis=0)
+        assert_equal(y5, [0, 0, 1, 1, 2, 2, 3, 3])
+        y6 = repeat(x4, 2, axis=0)
+        assert_equal(y5, y6)
+        y7 = x4.repeat((2, 2, 2, 2), axis=0)
+        assert_equal(y5, y7)
+        y8 = x4.repeat(2, 0)
+        assert_equal(y5, y8)
+
+        y9 = x4.copy()
+        assert_equal(y9._data, x4._data)
+        assert_equal(y9._mask, x4._mask)
+
+        x = masked_array([1, 2, 3], mask=[0, 1, 0])
+        # Copy is False by default
+        y = masked_array(x)
+        assert_equal(y._data.ctypes.data, x._data.ctypes.data)
+        assert_equal(y._mask.ctypes.data, x._mask.ctypes.data)
+        y = masked_array(x, copy=True)
+        assert_not_equal(y._data.ctypes.data, x._data.ctypes.data)
+        assert_not_equal(y._mask.ctypes.data, x._mask.ctypes.data)
+
+    def test_copy_0d(self):
+        # gh-9430
+        x = np.ma.array(43, mask=True)
+        xc = x.copy()
+        assert_equal(xc.mask, True)
+
+    def test_copy_on_python_builtins(self):
+        # Tests copy works on python builtins (issue#8019)
+        assert_(isMaskedArray(np.ma.copy([1,2,3])))
+        assert_(isMaskedArray(np.ma.copy((1,2,3))))
+
+    def test_copy_immutable(self):
+        # Tests that the copy method is immutable, GitHub issue #5247
+        a = np.ma.array([1, 2, 3])
+        b = np.ma.array([4, 5, 6])
+        a_copy_method = a.copy
+        b.copy
+        assert_equal(a_copy_method(), [1, 2, 3])
+
+    def test_deepcopy(self):
+        from copy import deepcopy
+        a = array([0, 1, 2], mask=[False, True, False])
+        copied = deepcopy(a)
+        assert_equal(copied.mask, a.mask)
+        assert_not_equal(id(a._mask), id(copied._mask))
+
+        copied[1] = 1
+        assert_equal(copied.mask, [0, 0, 0])
+        assert_equal(a.mask, [0, 1, 0])
+
+        copied = deepcopy(a)
+        assert_equal(copied.mask, a.mask)
+        copied.mask[1] = False
+        assert_equal(copied.mask, [0, 0, 0])
+        assert_equal(a.mask, [0, 1, 0])
+
+    def test_format(self):
+        a = array([0, 1, 2], mask=[False, True, False])
+        assert_equal(format(a), "[0 -- 2]")
+        assert_equal(format(masked), "--")
+        assert_equal(format(masked, ""), "--")
+
+        # Postponed from PR #15410, perhaps address in the future.
+        # assert_equal(format(masked, " >5"), "   --")
+        # assert_equal(format(masked, " <5"), "--   ")
+
+        # Expect a FutureWarning for using format_spec with MaskedElement
+        with assert_warns(FutureWarning):
+            with_format_string = format(masked, " >5")
+        assert_equal(with_format_string, "--")
+
+    def test_str_repr(self):
+        a = array([0, 1, 2], mask=[False, True, False])
+        assert_equal(str(a), '[0 -- 2]')
+        assert_equal(
+            repr(a),
+            textwrap.dedent('''\
+            masked_array(data=[0, --, 2],
+                         mask=[False,  True, False],
+                   fill_value=999999)''')
+        )
+
+        # arrays with a continuation
+        a = np.ma.arange(2000)
+        a[1:50] = np.ma.masked
+        assert_equal(
+            repr(a),
+            textwrap.dedent('''\
+            masked_array(data=[0, --, --, ..., 1997, 1998, 1999],
+                         mask=[False,  True,  True, ..., False, False, False],
+                   fill_value=999999)''')
+        )
+
+        # line-wrapped 1d arrays are correctly aligned
+        a = np.ma.arange(20)
+        assert_equal(
+            repr(a),
+            textwrap.dedent('''\
+            masked_array(data=[ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13,
+                               14, 15, 16, 17, 18, 19],
+                         mask=False,
+                   fill_value=999999)''')
+        )
+
+        # 2d arrays cause wrapping
+        a = array([[1, 2, 3], [4, 5, 6]], dtype=np.int8)
+        a[1,1] = np.ma.masked
+        assert_equal(
+            repr(a),
+            textwrap.dedent(f'''\
+            masked_array(
+              data=[[1, 2, 3],
+                    [4, --, 6]],
+              mask=[[False, False, False],
+                    [False,  True, False]],
+              fill_value={np.array(999999)[()]!r},
+              dtype=int8)''')
+        )
+
+        # but not it they're a row vector
+        assert_equal(
+            repr(a[:1]),
+            textwrap.dedent(f'''\
+            masked_array(data=[[1, 2, 3]],
+                         mask=[[False, False, False]],
+                   fill_value={np.array(999999)[()]!r},
+                        dtype=int8)''')
+        )
+
+        # dtype=int is implied, so not shown
+        assert_equal(
+            repr(a.astype(int)),
+            textwrap.dedent('''\
+            masked_array(
+              data=[[1, 2, 3],
+                    [4, --, 6]],
+              mask=[[False, False, False],
+                    [False,  True, False]],
+              fill_value=999999)''')
+        )
+
+    def test_str_repr_legacy(self):
+        oldopts = np.get_printoptions()
+        np.set_printoptions(legacy='1.13')
+        try:
+            a = array([0, 1, 2], mask=[False, True, False])
+            assert_equal(str(a), '[0 -- 2]')
+            assert_equal(repr(a), 'masked_array(data = [0 -- 2],\n'
+                                  '             mask = [False  True False],\n'
+                                  '       fill_value = 999999)\n')
+
+            a = np.ma.arange(2000)
+            a[1:50] = np.ma.masked
+            assert_equal(
+                repr(a),
+                'masked_array(data = [0 -- -- ..., 1997 1998 1999],\n'
+                '             mask = [False  True  True ..., False False False],\n'
+                '       fill_value = 999999)\n'
+            )
+        finally:
+            np.set_printoptions(**oldopts)
+
+    def test_0d_unicode(self):
+        u = 'caf\xe9'
+        utype = type(u)
+
+        arr_nomask = np.ma.array(u)
+        arr_masked = np.ma.array(u, mask=True)
+
+        assert_equal(utype(arr_nomask), u)
+        assert_equal(utype(arr_masked), '--')
+
+    def test_pickling(self):
+        # Tests pickling
+        for dtype in (int, float, str, object):
+            a = arange(10).astype(dtype)
+            a.fill_value = 999
+
+            masks = ([0, 0, 0, 1, 0, 1, 0, 1, 0, 1],  # partially masked
+                     True,                            # Fully masked
+                     False)                           # Fully unmasked
+
+            for proto in range(2, pickle.HIGHEST_PROTOCOL + 1):
+                for mask in masks:
+                    a.mask = mask
+                    a_pickled = pickle.loads(pickle.dumps(a, protocol=proto))
+                    assert_equal(a_pickled._mask, a._mask)
+                    assert_equal(a_pickled._data, a._data)
+                    if dtype in (object, int):
+                        assert_equal(a_pickled.fill_value, 999)
+                    else:
+                        assert_equal(a_pickled.fill_value, dtype(999))
+                    assert_array_equal(a_pickled.mask, mask)
+
+    def test_pickling_subbaseclass(self):
+        # Test pickling w/ a subclass of ndarray
+        x = np.array([(1.0, 2), (3.0, 4)],
+                     dtype=[('x', float), ('y', int)]).view(np.recarray)
+        a = masked_array(x, mask=[(True, False), (False, True)])
+        for proto in range(2, pickle.HIGHEST_PROTOCOL + 1):
+            a_pickled = pickle.loads(pickle.dumps(a, protocol=proto))
+            assert_equal(a_pickled._mask, a._mask)
+            assert_equal(a_pickled, a)
+            assert_(isinstance(a_pickled._data, np.recarray))
+
+    def test_pickling_maskedconstant(self):
+        # Test pickling MaskedConstant
+        mc = np.ma.masked
+        for proto in range(2, pickle.HIGHEST_PROTOCOL + 1):
+            mc_pickled = pickle.loads(pickle.dumps(mc, protocol=proto))
+            assert_equal(mc_pickled._baseclass, mc._baseclass)
+            assert_equal(mc_pickled._mask, mc._mask)
+            assert_equal(mc_pickled._data, mc._data)
+
+    def test_pickling_wstructured(self):
+        # Tests pickling w/ structured array
+        a = array([(1, 1.), (2, 2.)], mask=[(0, 0), (0, 1)],
+                  dtype=[('a', int), ('b', float)])
+        for proto in range(2, pickle.HIGHEST_PROTOCOL + 1):
+            a_pickled = pickle.loads(pickle.dumps(a, protocol=proto))
+            assert_equal(a_pickled._mask, a._mask)
+            assert_equal(a_pickled, a)
+
+    def test_pickling_keepalignment(self):
+        # Tests pickling w/ F_CONTIGUOUS arrays
+        a = arange(10)
+        a.shape = (-1, 2)
+        b = a.T
+        for proto in range(2, pickle.HIGHEST_PROTOCOL + 1):
+            test = pickle.loads(pickle.dumps(b, protocol=proto))
+            assert_equal(test, b)
+
+    def test_single_element_subscript(self):
+        # Tests single element subscripts of Maskedarrays.
+        a = array([1, 3, 2])
+        b = array([1, 3, 2], mask=[1, 0, 1])
+        assert_equal(a[0].shape, ())
+        assert_equal(b[0].shape, ())
+        assert_equal(b[1].shape, ())
+
+    def test_topython(self):
+        # Tests some communication issues with Python.
+        assert_equal(1, int(array(1)))
+        assert_equal(1.0, float(array(1)))
+        assert_equal(1, int(array([[[1]]])))
+        assert_equal(1.0, float(array([[1]])))
+        assert_raises(TypeError, float, array([1, 1]))
+
+        with suppress_warnings() as sup:
+            sup.filter(UserWarning, 'Warning: converting a masked element')
+            assert_(np.isnan(float(array([1], mask=[1]))))
+
+            a = array([1, 2, 3], mask=[1, 0, 0])
+            assert_raises(TypeError, lambda: float(a))
+            assert_equal(float(a[-1]), 3.)
+            assert_(np.isnan(float(a[0])))
+        assert_raises(TypeError, int, a)
+        assert_equal(int(a[-1]), 3)
+        assert_raises(MAError, lambda:int(a[0]))
+
+    def test_oddfeatures_1(self):
+        # Test of other odd features
+        x = arange(20)
+        x = x.reshape(4, 5)
+        x.flat[5] = 12
+        assert_(x[1, 0] == 12)
+        z = x + 10j * x
+        assert_equal(z.real, x)
+        assert_equal(z.imag, 10 * x)
+        assert_equal((z * conjugate(z)).real, 101 * x * x)
+        z.imag[...] = 0.0
+
+        x = arange(10)
+        x[3] = masked
+        assert_(str(x[3]) == str(masked))
+        c = x >= 8
+        assert_(count(where(c, masked, masked)) == 0)
+        assert_(shape(where(c, masked, masked)) == c.shape)
+
+        z = masked_where(c, x)
+        assert_(z.dtype is x.dtype)
+        assert_(z[3] is masked)
+        assert_(z[4] is not masked)
+        assert_(z[7] is not masked)
+        assert_(z[8] is masked)
+        assert_(z[9] is masked)
+        assert_equal(x, z)
+
+    def test_oddfeatures_2(self):
+        # Tests some more features.
+        x = array([1., 2., 3., 4., 5.])
+        c = array([1, 1, 1, 0, 0])
+        x[2] = masked
+        z = where(c, x, -x)
+        assert_equal(z, [1., 2., 0., -4., -5])
+        c[0] = masked
+        z = where(c, x, -x)
+        assert_equal(z, [1., 2., 0., -4., -5])
+        assert_(z[0] is masked)
+        assert_(z[1] is not masked)
+        assert_(z[2] is masked)
+
+    @suppress_copy_mask_on_assignment
+    def test_oddfeatures_3(self):
+        # Tests some generic features
+        atest = array([10], mask=True)
+        btest = array([20])
+        idx = atest.mask
+        atest[idx] = btest[idx]
+        assert_equal(atest, [20])
+
+    def test_filled_with_object_dtype(self):
+        a = np.ma.masked_all(1, dtype='O')
+        assert_equal(a.filled('x')[0], 'x')
+
+    def test_filled_with_flexible_dtype(self):
+        # Test filled w/ flexible dtype
+        flexi = array([(1, 1, 1)],
+                      dtype=[('i', int), ('s', '|S8'), ('f', float)])
+        flexi[0] = masked
+        assert_equal(flexi.filled(),
+                     np.array([(default_fill_value(0),
+                                default_fill_value('0'),
+                                default_fill_value(0.),)], dtype=flexi.dtype))
+        flexi[0] = masked
+        assert_equal(flexi.filled(1),
+                     np.array([(1, '1', 1.)], dtype=flexi.dtype))
+
+    def test_filled_with_mvoid(self):
+        # Test filled w/ mvoid
+        ndtype = [('a', int), ('b', float)]
+        a = mvoid((1, 2.), mask=[(0, 1)], dtype=ndtype)
+        # Filled using default
+        test = a.filled()
+        assert_equal(tuple(test), (1, default_fill_value(1.)))
+        # Explicit fill_value
+        test = a.filled((-1, -1))
+        assert_equal(tuple(test), (1, -1))
+        # Using predefined filling values
+        a.fill_value = (-999, -999)
+        assert_equal(tuple(a.filled()), (1, -999))
+
+    def test_filled_with_nested_dtype(self):
+        # Test filled w/ nested dtype
+        ndtype = [('A', int), ('B', [('BA', int), ('BB', int)])]
+        a = array([(1, (1, 1)), (2, (2, 2))],
+                  mask=[(0, (1, 0)), (0, (0, 1))], dtype=ndtype)
+        test = a.filled(0)
+        control = np.array([(1, (0, 1)), (2, (2, 0))], dtype=ndtype)
+        assert_equal(test, control)
+
+        test = a['B'].filled(0)
+        control = np.array([(0, 1), (2, 0)], dtype=a['B'].dtype)
+        assert_equal(test, control)
+
+        # test if mask gets set correctly (see #6760)
+        Z = numpy.ma.zeros(2, numpy.dtype([("A", "(2,2)i1,(2,2)i1", (2,2))]))
+        assert_equal(Z.data.dtype, numpy.dtype([('A', [('f0', 'i1', (2, 2)),
+                                          ('f1', 'i1', (2, 2))], (2, 2))]))
+        assert_equal(Z.mask.dtype, numpy.dtype([('A', [('f0', '?', (2, 2)),
+                                          ('f1', '?', (2, 2))], (2, 2))]))
+
+    def test_filled_with_f_order(self):
+        # Test filled w/ F-contiguous array
+        a = array(np.array([(0, 1, 2), (4, 5, 6)], order='F'),
+                  mask=np.array([(0, 0, 1), (1, 0, 0)], order='F'),
+                  order='F')  # this is currently ignored
+        assert_(a.flags['F_CONTIGUOUS'])
+        assert_(a.filled(0).flags['F_CONTIGUOUS'])
+
+    def test_optinfo_propagation(self):
+        # Checks that _optinfo dictionary isn't back-propagated
+        x = array([1, 2, 3, ], dtype=float)
+        x._optinfo['info'] = '???'
+        y = x.copy()
+        assert_equal(y._optinfo['info'], '???')
+        y._optinfo['info'] = '!!!'
+        assert_equal(x._optinfo['info'], '???')
+
+    def test_optinfo_forward_propagation(self):
+        a = array([1,2,2,4])
+        a._optinfo["key"] = "value"
+        assert_equal(a._optinfo["key"], (a == 2)._optinfo["key"])
+        assert_equal(a._optinfo["key"], (a != 2)._optinfo["key"])
+        assert_equal(a._optinfo["key"], (a > 2)._optinfo["key"])
+        assert_equal(a._optinfo["key"], (a >= 2)._optinfo["key"])
+        assert_equal(a._optinfo["key"], (a <= 2)._optinfo["key"])
+        assert_equal(a._optinfo["key"], (a + 2)._optinfo["key"])
+        assert_equal(a._optinfo["key"], (a - 2)._optinfo["key"])
+        assert_equal(a._optinfo["key"], (a * 2)._optinfo["key"])
+        assert_equal(a._optinfo["key"], (a / 2)._optinfo["key"])
+        assert_equal(a._optinfo["key"], a[:2]._optinfo["key"])
+        assert_equal(a._optinfo["key"], a[[0,0,2]]._optinfo["key"])
+        assert_equal(a._optinfo["key"], np.exp(a)._optinfo["key"])
+        assert_equal(a._optinfo["key"], np.abs(a)._optinfo["key"])
+        assert_equal(a._optinfo["key"], array(a, copy=True)._optinfo["key"])
+        assert_equal(a._optinfo["key"], np.zeros_like(a)._optinfo["key"])
+
+    def test_fancy_printoptions(self):
+        # Test printing a masked array w/ fancy dtype.
+        fancydtype = np.dtype([('x', int), ('y', [('t', int), ('s', float)])])
+        test = array([(1, (2, 3.0)), (4, (5, 6.0))],
+                     mask=[(1, (0, 1)), (0, (1, 0))],
+                     dtype=fancydtype)
+        control = "[(--, (2, --)) (4, (--, 6.0))]"
+        assert_equal(str(test), control)
+
+        # Test 0-d array with multi-dimensional dtype
+        t_2d0 = masked_array(data = (0, [[0.0, 0.0, 0.0],
+                                        [0.0, 0.0, 0.0]],
+                                    0.0),
+                             mask = (False, [[True, False, True],
+                                             [False, False, True]],
+                                     False),
+                             dtype = "int, (2,3)float, float")
+        control = "(0, [[--, 0.0, --], [0.0, 0.0, --]], 0.0)"
+        assert_equal(str(t_2d0), control)
+
+    def test_flatten_structured_array(self):
+        # Test flatten_structured_array on arrays
+        # On ndarray
+        ndtype = [('a', int), ('b', float)]
+        a = np.array([(1, 1), (2, 2)], dtype=ndtype)
+        test = flatten_structured_array(a)
+        control = np.array([[1., 1.], [2., 2.]], dtype=float)
+        assert_equal(test, control)
+        assert_equal(test.dtype, control.dtype)
+        # On masked_array
+        a = array([(1, 1), (2, 2)], mask=[(0, 1), (1, 0)], dtype=ndtype)
+        test = flatten_structured_array(a)
+        control = array([[1., 1.], [2., 2.]],
+                        mask=[[0, 1], [1, 0]], dtype=float)
+        assert_equal(test, control)
+        assert_equal(test.dtype, control.dtype)
+        assert_equal(test.mask, control.mask)
+        # On masked array with nested structure
+        ndtype = [('a', int), ('b', [('ba', int), ('bb', float)])]
+        a = array([(1, (1, 1.1)), (2, (2, 2.2))],
+                  mask=[(0, (1, 0)), (1, (0, 1))], dtype=ndtype)
+        test = flatten_structured_array(a)
+        control = array([[1., 1., 1.1], [2., 2., 2.2]],
+                        mask=[[0, 1, 0], [1, 0, 1]], dtype=float)
+        assert_equal(test, control)
+        assert_equal(test.dtype, control.dtype)
+        assert_equal(test.mask, control.mask)
+        # Keeping the initial shape
+        ndtype = [('a', int), ('b', float)]
+        a = np.array([[(1, 1), ], [(2, 2), ]], dtype=ndtype)
+        test = flatten_structured_array(a)
+        control = np.array([[[1., 1.], ], [[2., 2.], ]], dtype=float)
+        assert_equal(test, control)
+        assert_equal(test.dtype, control.dtype)
+
+    def test_void0d(self):
+        # Test creating a mvoid object
+        ndtype = [('a', int), ('b', int)]
+        a = np.array([(1, 2,)], dtype=ndtype)[0]
+        f = mvoid(a)
+        assert_(isinstance(f, mvoid))
+
+        a = masked_array([(1, 2)], mask=[(1, 0)], dtype=ndtype)[0]
+        assert_(isinstance(a, mvoid))
+
+        a = masked_array([(1, 2), (1, 2)], mask=[(1, 0), (0, 0)], dtype=ndtype)
+        f = mvoid(a._data[0], a._mask[0])
+        assert_(isinstance(f, mvoid))
+
+    def test_mvoid_getitem(self):
+        # Test mvoid.__getitem__
+        ndtype = [('a', int), ('b', int)]
+        a = masked_array([(1, 2,), (3, 4)], mask=[(0, 0), (1, 0)],
+                         dtype=ndtype)
+        # w/o mask
+        f = a[0]
+        assert_(isinstance(f, mvoid))
+        assert_equal((f[0], f['a']), (1, 1))
+        assert_equal(f['b'], 2)
+        # w/ mask
+        f = a[1]
+        assert_(isinstance(f, mvoid))
+        assert_(f[0] is masked)
+        assert_(f['a'] is masked)
+        assert_equal(f[1], 4)
+
+        # exotic dtype
+        A = masked_array(data=[([0,1],)],
+                         mask=[([True, False],)],
+                         dtype=[("A", ">i2", (2,))])
+        assert_equal(A[0]["A"], A["A"][0])
+        assert_equal(A[0]["A"], masked_array(data=[0, 1],
+                         mask=[True, False], dtype=">i2"))
+
+    def test_mvoid_iter(self):
+        # Test iteration on __getitem__
+        ndtype = [('a', int), ('b', int)]
+        a = masked_array([(1, 2,), (3, 4)], mask=[(0, 0), (1, 0)],
+                         dtype=ndtype)
+        # w/o mask
+        assert_equal(list(a[0]), [1, 2])
+        # w/ mask
+        assert_equal(list(a[1]), [masked, 4])
+
+    def test_mvoid_print(self):
+        # Test printing a mvoid
+        mx = array([(1, 1), (2, 2)], dtype=[('a', int), ('b', int)])
+        assert_equal(str(mx[0]), "(1, 1)")
+        mx['b'][0] = masked
+        ini_display = masked_print_option._display
+        masked_print_option.set_display("-X-")
+        try:
+            assert_equal(str(mx[0]), "(1, -X-)")
+            assert_equal(repr(mx[0]), "(1, -X-)")
+        finally:
+            masked_print_option.set_display(ini_display)
+
+        # also check if there are object datatypes (see gh-7493)
+        mx = array([(1,), (2,)], dtype=[('a', 'O')])
+        assert_equal(str(mx[0]), "(1,)")
+
+    def test_mvoid_multidim_print(self):
+
+        # regression test for gh-6019
+        t_ma = masked_array(data = [([1, 2, 3],)],
+                            mask = [([False, True, False],)],
+                            fill_value = ([999999, 999999, 999999],),
+                            dtype = [('a', ' 1:
+            assert_equal(np.concatenate((x, y), 1), concatenate((xm, ym), 1))
+            assert_equal(np.add.reduce(x, 1), add.reduce(x, 1))
+            assert_equal(np.sum(x, 1), sum(x, 1))
+            assert_equal(np.prod(x, 1), product(x, 1))
+
+    def test_binops_d2D(self):
+        # Test binary operations on 2D data
+        a = array([[1.], [2.], [3.]], mask=[[False], [True], [True]])
+        b = array([[2., 3.], [4., 5.], [6., 7.]])
+
+        test = a * b
+        control = array([[2., 3.], [2., 2.], [3., 3.]],
+                        mask=[[0, 0], [1, 1], [1, 1]])
+        assert_equal(test, control)
+        assert_equal(test.data, control.data)
+        assert_equal(test.mask, control.mask)
+
+        test = b * a
+        control = array([[2., 3.], [4., 5.], [6., 7.]],
+                        mask=[[0, 0], [1, 1], [1, 1]])
+        assert_equal(test, control)
+        assert_equal(test.data, control.data)
+        assert_equal(test.mask, control.mask)
+
+        a = array([[1.], [2.], [3.]])
+        b = array([[2., 3.], [4., 5.], [6., 7.]],
+                  mask=[[0, 0], [0, 0], [0, 1]])
+        test = a * b
+        control = array([[2, 3], [8, 10], [18, 3]],
+                        mask=[[0, 0], [0, 0], [0, 1]])
+        assert_equal(test, control)
+        assert_equal(test.data, control.data)
+        assert_equal(test.mask, control.mask)
+
+        test = b * a
+        control = array([[2, 3], [8, 10], [18, 7]],
+                        mask=[[0, 0], [0, 0], [0, 1]])
+        assert_equal(test, control)
+        assert_equal(test.data, control.data)
+        assert_equal(test.mask, control.mask)
+
+    def test_domained_binops_d2D(self):
+        # Test domained binary operations on 2D data
+        a = array([[1.], [2.], [3.]], mask=[[False], [True], [True]])
+        b = array([[2., 3.], [4., 5.], [6., 7.]])
+
+        test = a / b
+        control = array([[1. / 2., 1. / 3.], [2., 2.], [3., 3.]],
+                        mask=[[0, 0], [1, 1], [1, 1]])
+        assert_equal(test, control)
+        assert_equal(test.data, control.data)
+        assert_equal(test.mask, control.mask)
+
+        test = b / a
+        control = array([[2. / 1., 3. / 1.], [4., 5.], [6., 7.]],
+                        mask=[[0, 0], [1, 1], [1, 1]])
+        assert_equal(test, control)
+        assert_equal(test.data, control.data)
+        assert_equal(test.mask, control.mask)
+
+        a = array([[1.], [2.], [3.]])
+        b = array([[2., 3.], [4., 5.], [6., 7.]],
+                  mask=[[0, 0], [0, 0], [0, 1]])
+        test = a / b
+        control = array([[1. / 2, 1. / 3], [2. / 4, 2. / 5], [3. / 6, 3]],
+                        mask=[[0, 0], [0, 0], [0, 1]])
+        assert_equal(test, control)
+        assert_equal(test.data, control.data)
+        assert_equal(test.mask, control.mask)
+
+        test = b / a
+        control = array([[2 / 1., 3 / 1.], [4 / 2., 5 / 2.], [6 / 3., 7]],
+                        mask=[[0, 0], [0, 0], [0, 1]])
+        assert_equal(test, control)
+        assert_equal(test.data, control.data)
+        assert_equal(test.mask, control.mask)
+
+    def test_noshrinking(self):
+        # Check that we don't shrink a mask when not wanted
+        # Binary operations
+        a = masked_array([1., 2., 3.], mask=[False, False, False],
+                         shrink=False)
+        b = a + 1
+        assert_equal(b.mask, [0, 0, 0])
+        # In place binary operation
+        a += 1
+        assert_equal(a.mask, [0, 0, 0])
+        # Domained binary operation
+        b = a / 1.
+        assert_equal(b.mask, [0, 0, 0])
+        # In place binary operation
+        a /= 1.
+        assert_equal(a.mask, [0, 0, 0])
+
+    def test_ufunc_nomask(self):
+        # check the case ufuncs should set the mask to false
+        m = np.ma.array([1])
+        # check we don't get array([False], dtype=bool)
+        assert_equal(np.true_divide(m, 5).mask.shape, ())
+
+    def test_noshink_on_creation(self):
+        # Check that the mask is not shrunk on array creation when not wanted
+        a = np.ma.masked_values([1., 2.5, 3.1], 1.5, shrink=False)
+        assert_equal(a.mask, [0, 0, 0])
+
+    def test_mod(self):
+        # Tests mod
+        (x, y, a10, m1, m2, xm, ym, z, zm, xf) = self.d
+        assert_equal(mod(x, y), mod(xm, ym))
+        test = mod(ym, xm)
+        assert_equal(test, np.mod(ym, xm))
+        assert_equal(test.mask, mask_or(xm.mask, ym.mask))
+        test = mod(xm, ym)
+        assert_equal(test, np.mod(xm, ym))
+        assert_equal(test.mask, mask_or(mask_or(xm.mask, ym.mask), (ym == 0)))
+
+    def test_TakeTransposeInnerOuter(self):
+        # Test of take, transpose, inner, outer products
+        x = arange(24)
+        y = np.arange(24)
+        x[5:6] = masked
+        x = x.reshape(2, 3, 4)
+        y = y.reshape(2, 3, 4)
+        assert_equal(np.transpose(y, (2, 0, 1)), transpose(x, (2, 0, 1)))
+        assert_equal(np.take(y, (2, 0, 1), 1), take(x, (2, 0, 1), 1))
+        assert_equal(np.inner(filled(x, 0), filled(y, 0)),
+                     inner(x, y))
+        assert_equal(np.outer(filled(x, 0), filled(y, 0)),
+                     outer(x, y))
+        y = array(['abc', 1, 'def', 2, 3], object)
+        y[2] = masked
+        t = take(y, [0, 3, 4])
+        assert_(t[0] == 'abc')
+        assert_(t[1] == 2)
+        assert_(t[2] == 3)
+
+    def test_imag_real(self):
+        # Check complex
+        xx = array([1 + 10j, 20 + 2j], mask=[1, 0])
+        assert_equal(xx.imag, [10, 2])
+        assert_equal(xx.imag.filled(), [1e+20, 2])
+        assert_equal(xx.imag.dtype, xx._data.imag.dtype)
+        assert_equal(xx.real, [1, 20])
+        assert_equal(xx.real.filled(), [1e+20, 20])
+        assert_equal(xx.real.dtype, xx._data.real.dtype)
+
+    def test_methods_with_output(self):
+        xm = array(np.random.uniform(0, 10, 12)).reshape(3, 4)
+        xm[:, 0] = xm[0] = xm[-1, -1] = masked
+
+        funclist = ('sum', 'prod', 'var', 'std', 'max', 'min', 'ptp', 'mean',)
+
+        for funcname in funclist:
+            npfunc = getattr(np, funcname)
+            xmmeth = getattr(xm, funcname)
+            # A ndarray as explicit input
+            output = np.empty(4, dtype=float)
+            output.fill(-9999)
+            result = npfunc(xm, axis=0, out=output)
+            # ... the result should be the given output
+            assert_(result is output)
+            assert_equal(result, xmmeth(axis=0, out=output))
+
+            output = empty(4, dtype=int)
+            result = xmmeth(axis=0, out=output)
+            assert_(result is output)
+            assert_(output[0] is masked)
+
+    def test_eq_on_structured(self):
+        # Test the equality of structured arrays
+        ndtype = [('A', int), ('B', int)]
+        a = array([(1, 1), (2, 2)], mask=[(0, 1), (0, 0)], dtype=ndtype)
+
+        test = (a == a)
+        assert_equal(test.data, [True, True])
+        assert_equal(test.mask, [False, False])
+        assert_(test.fill_value == True)
+
+        test = (a == a[0])
+        assert_equal(test.data, [True, False])
+        assert_equal(test.mask, [False, False])
+        assert_(test.fill_value == True)
+
+        b = array([(1, 1), (2, 2)], mask=[(1, 0), (0, 0)], dtype=ndtype)
+        test = (a == b)
+        assert_equal(test.data, [False, True])
+        assert_equal(test.mask, [True, False])
+        assert_(test.fill_value == True)
+
+        test = (a[0] == b)
+        assert_equal(test.data, [False, False])
+        assert_equal(test.mask, [True, False])
+        assert_(test.fill_value == True)
+
+        b = array([(1, 1), (2, 2)], mask=[(0, 1), (1, 0)], dtype=ndtype)
+        test = (a == b)
+        assert_equal(test.data, [True, True])
+        assert_equal(test.mask, [False, False])
+        assert_(test.fill_value == True)
+
+        # complicated dtype, 2-dimensional array.
+        ndtype = [('A', int), ('B', [('BA', int), ('BB', int)])]
+        a = array([[(1, (1, 1)), (2, (2, 2))],
+                   [(3, (3, 3)), (4, (4, 4))]],
+                  mask=[[(0, (1, 0)), (0, (0, 1))],
+                        [(1, (0, 0)), (1, (1, 1))]], dtype=ndtype)
+        test = (a[0, 0] == a)
+        assert_equal(test.data, [[True, False], [False, False]])
+        assert_equal(test.mask, [[False, False], [False, True]])
+        assert_(test.fill_value == True)
+
+    def test_ne_on_structured(self):
+        # Test the equality of structured arrays
+        ndtype = [('A', int), ('B', int)]
+        a = array([(1, 1), (2, 2)], mask=[(0, 1), (0, 0)], dtype=ndtype)
+
+        test = (a != a)
+        assert_equal(test.data, [False, False])
+        assert_equal(test.mask, [False, False])
+        assert_(test.fill_value == True)
+
+        test = (a != a[0])
+        assert_equal(test.data, [False, True])
+        assert_equal(test.mask, [False, False])
+        assert_(test.fill_value == True)
+
+        b = array([(1, 1), (2, 2)], mask=[(1, 0), (0, 0)], dtype=ndtype)
+        test = (a != b)
+        assert_equal(test.data, [True, False])
+        assert_equal(test.mask, [True, False])
+        assert_(test.fill_value == True)
+
+        test = (a[0] != b)
+        assert_equal(test.data, [True, True])
+        assert_equal(test.mask, [True, False])
+        assert_(test.fill_value == True)
+
+        b = array([(1, 1), (2, 2)], mask=[(0, 1), (1, 0)], dtype=ndtype)
+        test = (a != b)
+        assert_equal(test.data, [False, False])
+        assert_equal(test.mask, [False, False])
+        assert_(test.fill_value == True)
+
+        # complicated dtype, 2-dimensional array.
+        ndtype = [('A', int), ('B', [('BA', int), ('BB', int)])]
+        a = array([[(1, (1, 1)), (2, (2, 2))],
+                   [(3, (3, 3)), (4, (4, 4))]],
+                  mask=[[(0, (1, 0)), (0, (0, 1))],
+                        [(1, (0, 0)), (1, (1, 1))]], dtype=ndtype)
+        test = (a[0, 0] != a)
+        assert_equal(test.data, [[False, True], [True, True]])
+        assert_equal(test.mask, [[False, False], [False, True]])
+        assert_(test.fill_value == True)
+
+    def test_eq_ne_structured_with_non_masked(self):
+        a = array([(1, 1), (2, 2), (3, 4)],
+                  mask=[(0, 1), (0, 0), (1, 1)], dtype='i4,i4')
+        eq = a == a.data
+        ne = a.data != a
+        # Test the obvious.
+        assert_(np.all(eq))
+        assert_(not np.any(ne))
+        # Expect the mask set only for items with all fields masked.
+        expected_mask = a.mask == np.ones((), a.mask.dtype)
+        assert_array_equal(eq.mask, expected_mask)
+        assert_array_equal(ne.mask, expected_mask)
+        # The masked element will indicated not equal, because the
+        # masks did not match.
+        assert_equal(eq.data, [True, True, False])
+        assert_array_equal(eq.data, ~ne.data)
+
+    def test_eq_ne_structured_extra(self):
+        # ensure simple examples are symmetric and make sense.
+        # from https://github.com/numpy/numpy/pull/8590#discussion_r101126465
+        dt = np.dtype('i4,i4')
+        for m1 in (mvoid((1, 2), mask=(0, 0), dtype=dt),
+                   mvoid((1, 2), mask=(0, 1), dtype=dt),
+                   mvoid((1, 2), mask=(1, 0), dtype=dt),
+                   mvoid((1, 2), mask=(1, 1), dtype=dt)):
+            ma1 = m1.view(MaskedArray)
+            r1 = ma1.view('2i4')
+            for m2 in (np.array((1, 1), dtype=dt),
+                       mvoid((1, 1), dtype=dt),
+                       mvoid((1, 0), mask=(0, 1), dtype=dt),
+                       mvoid((3, 2), mask=(0, 1), dtype=dt)):
+                ma2 = m2.view(MaskedArray)
+                r2 = ma2.view('2i4')
+                eq_expected = (r1 == r2).all()
+                assert_equal(m1 == m2, eq_expected)
+                assert_equal(m2 == m1, eq_expected)
+                assert_equal(ma1 == m2, eq_expected)
+                assert_equal(m1 == ma2, eq_expected)
+                assert_equal(ma1 == ma2, eq_expected)
+                # Also check it is the same if we do it element by element.
+                el_by_el = [m1[name] == m2[name] for name in dt.names]
+                assert_equal(array(el_by_el, dtype=bool).all(), eq_expected)
+                ne_expected = (r1 != r2).any()
+                assert_equal(m1 != m2, ne_expected)
+                assert_equal(m2 != m1, ne_expected)
+                assert_equal(ma1 != m2, ne_expected)
+                assert_equal(m1 != ma2, ne_expected)
+                assert_equal(ma1 != ma2, ne_expected)
+                el_by_el = [m1[name] != m2[name] for name in dt.names]
+                assert_equal(array(el_by_el, dtype=bool).any(), ne_expected)
+
+    @pytest.mark.parametrize('dt', ['S', 'U'])
+    @pytest.mark.parametrize('fill', [None, 'A'])
+    def test_eq_for_strings(self, dt, fill):
+        # Test the equality of structured arrays
+        a = array(['a', 'b'], dtype=dt, mask=[0, 1], fill_value=fill)
+
+        test = (a == a)
+        assert_equal(test.data, [True, True])
+        assert_equal(test.mask, [False, True])
+        assert_(test.fill_value == True)
+
+        test = (a == a[0])
+        assert_equal(test.data, [True, False])
+        assert_equal(test.mask, [False, True])
+        assert_(test.fill_value == True)
+
+        b = array(['a', 'b'], dtype=dt, mask=[1, 0], fill_value=fill)
+        test = (a == b)
+        assert_equal(test.data, [False, False])
+        assert_equal(test.mask, [True, True])
+        assert_(test.fill_value == True)
+
+        test = (a[0] == b)
+        assert_equal(test.data, [False, False])
+        assert_equal(test.mask, [True, False])
+        assert_(test.fill_value == True)
+
+        test = (b == a[0])
+        assert_equal(test.data, [False, False])
+        assert_equal(test.mask, [True, False])
+        assert_(test.fill_value == True)
+
+    @pytest.mark.parametrize('dt', ['S', 'U'])
+    @pytest.mark.parametrize('fill', [None, 'A'])
+    def test_ne_for_strings(self, dt, fill):
+        # Test the equality of structured arrays
+        a = array(['a', 'b'], dtype=dt, mask=[0, 1], fill_value=fill)
+
+        test = (a != a)
+        assert_equal(test.data, [False, False])
+        assert_equal(test.mask, [False, True])
+        assert_(test.fill_value == True)
+
+        test = (a != a[0])
+        assert_equal(test.data, [False, True])
+        assert_equal(test.mask, [False, True])
+        assert_(test.fill_value == True)
+
+        b = array(['a', 'b'], dtype=dt, mask=[1, 0], fill_value=fill)
+        test = (a != b)
+        assert_equal(test.data, [True, True])
+        assert_equal(test.mask, [True, True])
+        assert_(test.fill_value == True)
+
+        test = (a[0] != b)
+        assert_equal(test.data, [True, True])
+        assert_equal(test.mask, [True, False])
+        assert_(test.fill_value == True)
+
+        test = (b != a[0])
+        assert_equal(test.data, [True, True])
+        assert_equal(test.mask, [True, False])
+        assert_(test.fill_value == True)
+
+    @pytest.mark.parametrize('dt1', num_dts, ids=num_ids)
+    @pytest.mark.parametrize('dt2', num_dts, ids=num_ids)
+    @pytest.mark.parametrize('fill', [None, 1])
+    def test_eq_for_numeric(self, dt1, dt2, fill):
+        # Test the equality of structured arrays
+        a = array([0, 1], dtype=dt1, mask=[0, 1], fill_value=fill)
+
+        test = (a == a)
+        assert_equal(test.data, [True, True])
+        assert_equal(test.mask, [False, True])
+        assert_(test.fill_value == True)
+
+        test = (a == a[0])
+        assert_equal(test.data, [True, False])
+        assert_equal(test.mask, [False, True])
+        assert_(test.fill_value == True)
+
+        b = array([0, 1], dtype=dt2, mask=[1, 0], fill_value=fill)
+        test = (a == b)
+        assert_equal(test.data, [False, False])
+        assert_equal(test.mask, [True, True])
+        assert_(test.fill_value == True)
+
+        test = (a[0] == b)
+        assert_equal(test.data, [False, False])
+        assert_equal(test.mask, [True, False])
+        assert_(test.fill_value == True)
+
+        test = (b == a[0])
+        assert_equal(test.data, [False, False])
+        assert_equal(test.mask, [True, False])
+        assert_(test.fill_value == True)
+
+    @pytest.mark.parametrize("op", [operator.eq, operator.lt])
+    def test_eq_broadcast_with_unmasked(self, op):
+        a = array([0, 1], mask=[0, 1])
+        b = np.arange(10).reshape(5, 2)
+        result = op(a, b)
+        assert_(result.mask.shape == b.shape)
+        assert_equal(result.mask, np.zeros(b.shape, bool) | a.mask)
+
+    @pytest.mark.parametrize("op", [operator.eq, operator.gt])
+    def test_comp_no_mask_not_broadcast(self, op):
+        # Regression test for failing doctest in MaskedArray.nonzero
+        # after gh-24556.
+        a = array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
+        result = op(a, 3)
+        assert_(not result.mask.shape)
+        assert_(result.mask is nomask)
+
+    @pytest.mark.parametrize('dt1', num_dts, ids=num_ids)
+    @pytest.mark.parametrize('dt2', num_dts, ids=num_ids)
+    @pytest.mark.parametrize('fill', [None, 1])
+    def test_ne_for_numeric(self, dt1, dt2, fill):
+        # Test the equality of structured arrays
+        a = array([0, 1], dtype=dt1, mask=[0, 1], fill_value=fill)
+
+        test = (a != a)
+        assert_equal(test.data, [False, False])
+        assert_equal(test.mask, [False, True])
+        assert_(test.fill_value == True)
+
+        test = (a != a[0])
+        assert_equal(test.data, [False, True])
+        assert_equal(test.mask, [False, True])
+        assert_(test.fill_value == True)
+
+        b = array([0, 1], dtype=dt2, mask=[1, 0], fill_value=fill)
+        test = (a != b)
+        assert_equal(test.data, [True, True])
+        assert_equal(test.mask, [True, True])
+        assert_(test.fill_value == True)
+
+        test = (a[0] != b)
+        assert_equal(test.data, [True, True])
+        assert_equal(test.mask, [True, False])
+        assert_(test.fill_value == True)
+
+        test = (b != a[0])
+        assert_equal(test.data, [True, True])
+        assert_equal(test.mask, [True, False])
+        assert_(test.fill_value == True)
+
+    @pytest.mark.parametrize('dt1', num_dts, ids=num_ids)
+    @pytest.mark.parametrize('dt2', num_dts, ids=num_ids)
+    @pytest.mark.parametrize('fill', [None, 1])
+    @pytest.mark.parametrize('op',
+            [operator.le, operator.lt, operator.ge, operator.gt])
+    def test_comparisons_for_numeric(self, op, dt1, dt2, fill):
+        # Test the equality of structured arrays
+        a = array([0, 1], dtype=dt1, mask=[0, 1], fill_value=fill)
+
+        test = op(a, a)
+        assert_equal(test.data, op(a._data, a._data))
+        assert_equal(test.mask, [False, True])
+        assert_(test.fill_value == True)
+
+        test = op(a, a[0])
+        assert_equal(test.data, op(a._data, a._data[0]))
+        assert_equal(test.mask, [False, True])
+        assert_(test.fill_value == True)
+
+        b = array([0, 1], dtype=dt2, mask=[1, 0], fill_value=fill)
+        test = op(a, b)
+        assert_equal(test.data, op(a._data, b._data))
+        assert_equal(test.mask, [True, True])
+        assert_(test.fill_value == True)
+
+        test = op(a[0], b)
+        assert_equal(test.data, op(a._data[0], b._data))
+        assert_equal(test.mask, [True, False])
+        assert_(test.fill_value == True)
+
+        test = op(b, a[0])
+        assert_equal(test.data, op(b._data, a._data[0]))
+        assert_equal(test.mask, [True, False])
+        assert_(test.fill_value == True)
+
+    @pytest.mark.parametrize('op',
+            [operator.le, operator.lt, operator.ge, operator.gt])
+    @pytest.mark.parametrize('fill', [None, "N/A"])
+    def test_comparisons_strings(self, op, fill):
+        # See gh-21770, mask propagation is broken for strings (and some other
+        # cases) so we explicitly test strings here.
+        # In principle only == and != may need special handling...
+        ma1 = masked_array(["a", "b", "cde"], mask=[0, 1, 0], fill_value=fill)
+        ma2 = masked_array(["cde", "b", "a"], mask=[0, 1, 0], fill_value=fill)
+        assert_equal(op(ma1, ma2)._data, op(ma1._data, ma2._data))
+
+    def test_eq_with_None(self):
+        # Really, comparisons with None should not be done, but check them
+        # anyway. Note that pep8 will flag these tests.
+        # Deprecation is in place for arrays, and when it happens this
+        # test will fail (and have to be changed accordingly).
+
+        # With partial mask
+        with suppress_warnings() as sup:
+            sup.filter(FutureWarning, "Comparison to `None`")
+            a = array([None, 1], mask=[0, 1])
+            assert_equal(a == None, array([True, False], mask=[0, 1]))
+            assert_equal(a.data == None, [True, False])
+            assert_equal(a != None, array([False, True], mask=[0, 1]))
+            # With nomask
+            a = array([None, 1], mask=False)
+            assert_equal(a == None, [True, False])
+            assert_equal(a != None, [False, True])
+            # With complete mask
+            a = array([None, 2], mask=True)
+            assert_equal(a == None, array([False, True], mask=True))
+            assert_equal(a != None, array([True, False], mask=True))
+            # Fully masked, even comparison to None should return "masked"
+            a = masked
+            assert_equal(a == None, masked)
+
+    def test_eq_with_scalar(self):
+        a = array(1)
+        assert_equal(a == 1, True)
+        assert_equal(a == 0, False)
+        assert_equal(a != 1, False)
+        assert_equal(a != 0, True)
+        b = array(1, mask=True)
+        assert_equal(b == 0, masked)
+        assert_equal(b == 1, masked)
+        assert_equal(b != 0, masked)
+        assert_equal(b != 1, masked)
+
+    def test_eq_different_dimensions(self):
+        m1 = array([1, 1], mask=[0, 1])
+        # test comparison with both masked and regular arrays.
+        for m2 in (array([[0, 1], [1, 2]]),
+                   np.array([[0, 1], [1, 2]])):
+            test = (m1 == m2)
+            assert_equal(test.data, [[False, False],
+                                     [True, False]])
+            assert_equal(test.mask, [[False, True],
+                                     [False, True]])
+
+    def test_numpyarithmetic(self):
+        # Check that the mask is not back-propagated when using numpy functions
+        a = masked_array([-1, 0, 1, 2, 3], mask=[0, 0, 0, 0, 1])
+        control = masked_array([np.nan, np.nan, 0, np.log(2), -1],
+                               mask=[1, 1, 0, 0, 1])
+
+        test = log(a)
+        assert_equal(test, control)
+        assert_equal(test.mask, control.mask)
+        assert_equal(a.mask, [0, 0, 0, 0, 1])
+
+        test = np.log(a)
+        assert_equal(test, control)
+        assert_equal(test.mask, control.mask)
+        assert_equal(a.mask, [0, 0, 0, 0, 1])
+
+
+class TestMaskedArrayAttributes:
+
+    def test_keepmask(self):
+        # Tests the keep mask flag
+        x = masked_array([1, 2, 3], mask=[1, 0, 0])
+        mx = masked_array(x)
+        assert_equal(mx.mask, x.mask)
+        mx = masked_array(x, mask=[0, 1, 0], keep_mask=False)
+        assert_equal(mx.mask, [0, 1, 0])
+        mx = masked_array(x, mask=[0, 1, 0], keep_mask=True)
+        assert_equal(mx.mask, [1, 1, 0])
+        # We default to true
+        mx = masked_array(x, mask=[0, 1, 0])
+        assert_equal(mx.mask, [1, 1, 0])
+
+    def test_hardmask(self):
+        # Test hard_mask
+        d = arange(5)
+        n = [0, 0, 0, 1, 1]
+        m = make_mask(n)
+        xh = array(d, mask=m, hard_mask=True)
+        # We need to copy, to avoid updating d in xh !
+        xs = array(d, mask=m, hard_mask=False, copy=True)
+        xh[[1, 4]] = [10, 40]
+        xs[[1, 4]] = [10, 40]
+        assert_equal(xh._data, [0, 10, 2, 3, 4])
+        assert_equal(xs._data, [0, 10, 2, 3, 40])
+        assert_equal(xs.mask, [0, 0, 0, 1, 0])
+        assert_(xh._hardmask)
+        assert_(not xs._hardmask)
+        xh[1:4] = [10, 20, 30]
+        xs[1:4] = [10, 20, 30]
+        assert_equal(xh._data, [0, 10, 20, 3, 4])
+        assert_equal(xs._data, [0, 10, 20, 30, 40])
+        assert_equal(xs.mask, nomask)
+        xh[0] = masked
+        xs[0] = masked
+        assert_equal(xh.mask, [1, 0, 0, 1, 1])
+        assert_equal(xs.mask, [1, 0, 0, 0, 0])
+        xh[:] = 1
+        xs[:] = 1
+        assert_equal(xh._data, [0, 1, 1, 3, 4])
+        assert_equal(xs._data, [1, 1, 1, 1, 1])
+        assert_equal(xh.mask, [1, 0, 0, 1, 1])
+        assert_equal(xs.mask, nomask)
+        # Switch to soft mask
+        xh.soften_mask()
+        xh[:] = arange(5)
+        assert_equal(xh._data, [0, 1, 2, 3, 4])
+        assert_equal(xh.mask, nomask)
+        # Switch back to hard mask
+        xh.harden_mask()
+        xh[xh < 3] = masked
+        assert_equal(xh._data, [0, 1, 2, 3, 4])
+        assert_equal(xh._mask, [1, 1, 1, 0, 0])
+        xh[filled(xh > 1, False)] = 5
+        assert_equal(xh._data, [0, 1, 2, 5, 5])
+        assert_equal(xh._mask, [1, 1, 1, 0, 0])
+
+        xh = array([[1, 2], [3, 4]], mask=[[1, 0], [0, 0]], hard_mask=True)
+        xh[0] = 0
+        assert_equal(xh._data, [[1, 0], [3, 4]])
+        assert_equal(xh._mask, [[1, 0], [0, 0]])
+        xh[-1, -1] = 5
+        assert_equal(xh._data, [[1, 0], [3, 5]])
+        assert_equal(xh._mask, [[1, 0], [0, 0]])
+        xh[filled(xh < 5, False)] = 2
+        assert_equal(xh._data, [[1, 2], [2, 5]])
+        assert_equal(xh._mask, [[1, 0], [0, 0]])
+
+    def test_hardmask_again(self):
+        # Another test of hardmask
+        d = arange(5)
+        n = [0, 0, 0, 1, 1]
+        m = make_mask(n)
+        xh = array(d, mask=m, hard_mask=True)
+        xh[4:5] = 999
+        xh[0:1] = 999
+        assert_equal(xh._data, [999, 1, 2, 3, 4])
+
+    def test_hardmask_oncemore_yay(self):
+        # OK, yet another test of hardmask
+        # Make sure that harden_mask/soften_mask//unshare_mask returns self
+        a = array([1, 2, 3], mask=[1, 0, 0])
+        b = a.harden_mask()
+        assert_equal(a, b)
+        b[0] = 0
+        assert_equal(a, b)
+        assert_equal(b, array([1, 2, 3], mask=[1, 0, 0]))
+        a = b.soften_mask()
+        a[0] = 0
+        assert_equal(a, b)
+        assert_equal(b, array([0, 2, 3], mask=[0, 0, 0]))
+
+    def test_smallmask(self):
+        # Checks the behaviour of _smallmask
+        a = arange(10)
+        a[1] = masked
+        a[1] = 1
+        assert_equal(a._mask, nomask)
+        a = arange(10)
+        a._smallmask = False
+        a[1] = masked
+        a[1] = 1
+        assert_equal(a._mask, zeros(10))
+
+    def test_shrink_mask(self):
+        # Tests .shrink_mask()
+        a = array([1, 2, 3], mask=[0, 0, 0])
+        b = a.shrink_mask()
+        assert_equal(a, b)
+        assert_equal(a.mask, nomask)
+
+        # Mask cannot be shrunk on structured types, so is a no-op
+        a = np.ma.array([(1, 2.0)], [('a', int), ('b', float)])
+        b = a.copy()
+        a.shrink_mask()
+        assert_equal(a.mask, b.mask)
+
+    def test_flat(self):
+        # Test that flat can return all types of items [#4585, #4615]
+        # test 2-D record array
+        # ... on structured array w/ masked records
+        x = array([[(1, 1.1, 'one'), (2, 2.2, 'two'), (3, 3.3, 'thr')],
+                   [(4, 4.4, 'fou'), (5, 5.5, 'fiv'), (6, 6.6, 'six')]],
+                  dtype=[('a', int), ('b', float), ('c', '|S8')])
+        x['a'][0, 1] = masked
+        x['b'][1, 0] = masked
+        x['c'][0, 2] = masked
+        x[-1, -1] = masked
+        xflat = x.flat
+        assert_equal(xflat[0], x[0, 0])
+        assert_equal(xflat[1], x[0, 1])
+        assert_equal(xflat[2], x[0, 2])
+        assert_equal(xflat[:3], x[0])
+        assert_equal(xflat[3], x[1, 0])
+        assert_equal(xflat[4], x[1, 1])
+        assert_equal(xflat[5], x[1, 2])
+        assert_equal(xflat[3:], x[1])
+        assert_equal(xflat[-1], x[-1, -1])
+        i = 0
+        j = 0
+        for xf in xflat:
+            assert_equal(xf, x[j, i])
+            i += 1
+            if i >= x.shape[-1]:
+                i = 0
+                j += 1
+
+    def test_assign_dtype(self):
+        # check that the mask's dtype is updated when dtype is changed
+        a = np.zeros(4, dtype='f4,i4')
+
+        m = np.ma.array(a)
+        m.dtype = np.dtype('f4')
+        repr(m)  # raises?
+        assert_equal(m.dtype, np.dtype('f4'))
+
+        # check that dtype changes that change shape of mask too much
+        # are not allowed
+        def assign():
+            m = np.ma.array(a)
+            m.dtype = np.dtype('f8')
+        assert_raises(ValueError, assign)
+
+        b = a.view(dtype='f4', type=np.ma.MaskedArray)  # raises?
+        assert_equal(b.dtype, np.dtype('f4'))
+
+        # check that nomask is preserved
+        a = np.zeros(4, dtype='f4')
+        m = np.ma.array(a)
+        m.dtype = np.dtype('f4,i4')
+        assert_equal(m.dtype, np.dtype('f4,i4'))
+        assert_equal(m._mask, np.ma.nomask)
+
+
+class TestFillingValues:
+
+    def test_check_on_scalar(self):
+        # Test _check_fill_value set to valid and invalid values
+        _check_fill_value = np.ma.core._check_fill_value
+
+        fval = _check_fill_value(0, int)
+        assert_equal(fval, 0)
+        fval = _check_fill_value(None, int)
+        assert_equal(fval, default_fill_value(0))
+
+        fval = _check_fill_value(0, "|S3")
+        assert_equal(fval, b"0")
+        fval = _check_fill_value(None, "|S3")
+        assert_equal(fval, default_fill_value(b"camelot!"))
+        assert_raises(TypeError, _check_fill_value, 1e+20, int)
+        assert_raises(TypeError, _check_fill_value, 'stuff', int)
+
+    def test_check_on_fields(self):
+        # Tests _check_fill_value with records
+        _check_fill_value = np.ma.core._check_fill_value
+        ndtype = [('a', int), ('b', float), ('c', "|S3")]
+        # A check on a list should return a single record
+        fval = _check_fill_value([-999, -12345678.9, "???"], ndtype)
+        assert_(isinstance(fval, ndarray))
+        assert_equal(fval.item(), [-999, -12345678.9, b"???"])
+        # A check on None should output the defaults
+        fval = _check_fill_value(None, ndtype)
+        assert_(isinstance(fval, ndarray))
+        assert_equal(fval.item(), [default_fill_value(0),
+                                   default_fill_value(0.),
+                                   asbytes(default_fill_value("0"))])
+        #.....Using a structured type as fill_value should work
+        fill_val = np.array((-999, -12345678.9, "???"), dtype=ndtype)
+        fval = _check_fill_value(fill_val, ndtype)
+        assert_(isinstance(fval, ndarray))
+        assert_equal(fval.item(), [-999, -12345678.9, b"???"])
+
+        #.....Using a flexible type w/ a different type shouldn't matter
+        # BEHAVIOR in 1.5 and earlier, and 1.13 and later: match structured
+        # types by position
+        fill_val = np.array((-999, -12345678.9, "???"),
+                            dtype=[("A", int), ("B", float), ("C", "|S3")])
+        fval = _check_fill_value(fill_val, ndtype)
+        assert_(isinstance(fval, ndarray))
+        assert_equal(fval.item(), [-999, -12345678.9, b"???"])
+
+        #.....Using an object-array shouldn't matter either
+        fill_val = np.ndarray(shape=(1,), dtype=object)
+        fill_val[0] = (-999, -12345678.9, b"???")
+        fval = _check_fill_value(fill_val, object)
+        assert_(isinstance(fval, ndarray))
+        assert_equal(fval.item(), [-999, -12345678.9, b"???"])
+        # NOTE: This test was never run properly as "fill_value" rather than
+        # "fill_val" was assigned.  Written properly, it fails.
+        #fill_val = np.array((-999, -12345678.9, "???"))
+        #fval = _check_fill_value(fill_val, ndtype)
+        #assert_(isinstance(fval, ndarray))
+        #assert_equal(fval.item(), [-999, -12345678.9, b"???"])
+        #.....One-field-only flexible type should work as well
+        ndtype = [("a", int)]
+        fval = _check_fill_value(-999999999, ndtype)
+        assert_(isinstance(fval, ndarray))
+        assert_equal(fval.item(), (-999999999,))
+
+    def test_fillvalue_conversion(self):
+        # Tests the behavior of fill_value during conversion
+        # We had a tailored comment to make sure special attributes are
+        # properly dealt with
+        a = array([b'3', b'4', b'5'])
+        a._optinfo.update({'comment':"updated!"})
+
+        b = array(a, dtype=int)
+        assert_equal(b._data, [3, 4, 5])
+        assert_equal(b.fill_value, default_fill_value(0))
+
+        b = array(a, dtype=float)
+        assert_equal(b._data, [3, 4, 5])
+        assert_equal(b.fill_value, default_fill_value(0.))
+
+        b = a.astype(int)
+        assert_equal(b._data, [3, 4, 5])
+        assert_equal(b.fill_value, default_fill_value(0))
+        assert_equal(b._optinfo['comment'], "updated!")
+
+        b = a.astype([('a', '|S3')])
+        assert_equal(b['a']._data, a._data)
+        assert_equal(b['a'].fill_value, a.fill_value)
+
+    def test_default_fill_value(self):
+        # check all calling conventions
+        f1 = default_fill_value(1.)
+        f2 = default_fill_value(np.array(1.))
+        f3 = default_fill_value(np.array(1.).dtype)
+        assert_equal(f1, f2)
+        assert_equal(f1, f3)
+
+    def test_default_fill_value_structured(self):
+        fields = array([(1, 1, 1)],
+                      dtype=[('i', int), ('s', '|S8'), ('f', float)])
+
+        f1 = default_fill_value(fields)
+        f2 = default_fill_value(fields.dtype)
+        expected = np.array((default_fill_value(0),
+                             default_fill_value('0'),
+                             default_fill_value(0.)), dtype=fields.dtype)
+        assert_equal(f1, expected)
+        assert_equal(f2, expected)
+
+    def test_default_fill_value_void(self):
+        dt = np.dtype([('v', 'V7')])
+        f = default_fill_value(dt)
+        assert_equal(f['v'], np.array(default_fill_value(dt['v']), dt['v']))
+
+    def test_fillvalue(self):
+        # Yet more fun with the fill_value
+        data = masked_array([1, 2, 3], fill_value=-999)
+        series = data[[0, 2, 1]]
+        assert_equal(series._fill_value, data._fill_value)
+
+        mtype = [('f', float), ('s', '|S3')]
+        x = array([(1, 'a'), (2, 'b'), (pi, 'pi')], dtype=mtype)
+        x.fill_value = 999
+        assert_equal(x.fill_value.item(), [999., b'999'])
+        assert_equal(x['f'].fill_value, 999)
+        assert_equal(x['s'].fill_value, b'999')
+
+        x.fill_value = (9, '???')
+        assert_equal(x.fill_value.item(), (9, b'???'))
+        assert_equal(x['f'].fill_value, 9)
+        assert_equal(x['s'].fill_value, b'???')
+
+        x = array([1, 2, 3.1])
+        x.fill_value = 999
+        assert_equal(np.asarray(x.fill_value).dtype, float)
+        assert_equal(x.fill_value, 999.)
+        assert_equal(x._fill_value, np.array(999.))
+
+    def test_subarray_fillvalue(self):
+        # gh-10483   test multi-field index fill value
+        fields = array([(1, 1, 1)],
+                      dtype=[('i', int), ('s', '|S8'), ('f', float)])
+        with suppress_warnings() as sup:
+            sup.filter(FutureWarning, "Numpy has detected")
+            subfields = fields[['i', 'f']]
+            assert_equal(tuple(subfields.fill_value), (999999, 1.e+20))
+            # test comparison does not raise:
+            subfields[1:] == subfields[:-1]
+
+    def test_fillvalue_exotic_dtype(self):
+        # Tests yet more exotic flexible dtypes
+        _check_fill_value = np.ma.core._check_fill_value
+        ndtype = [('i', int), ('s', '|S8'), ('f', float)]
+        control = np.array((default_fill_value(0),
+                            default_fill_value('0'),
+                            default_fill_value(0.),),
+                           dtype=ndtype)
+        assert_equal(_check_fill_value(None, ndtype), control)
+        # The shape shouldn't matter
+        ndtype = [('f0', float, (2, 2))]
+        control = np.array((default_fill_value(0.),),
+                           dtype=[('f0', float)]).astype(ndtype)
+        assert_equal(_check_fill_value(None, ndtype), control)
+        control = np.array((0,), dtype=[('f0', float)]).astype(ndtype)
+        assert_equal(_check_fill_value(0, ndtype), control)
+
+        ndtype = np.dtype("int, (2,3)float, float")
+        control = np.array((default_fill_value(0),
+                            default_fill_value(0.),
+                            default_fill_value(0.),),
+                           dtype="int, float, float").astype(ndtype)
+        test = _check_fill_value(None, ndtype)
+        assert_equal(test, control)
+        control = np.array((0, 0, 0), dtype="int, float, float").astype(ndtype)
+        assert_equal(_check_fill_value(0, ndtype), control)
+        # but when indexing, fill value should become scalar not tuple
+        # See issue #6723
+        M = masked_array(control)
+        assert_equal(M["f1"].fill_value.ndim, 0)
+
+    def test_fillvalue_datetime_timedelta(self):
+        # Test default fillvalue for datetime64 and timedelta64 types.
+        # See issue #4476, this would return '?' which would cause errors
+        # elsewhere
+
+        for timecode in ("as", "fs", "ps", "ns", "us", "ms", "s", "m",
+                         "h", "D", "W", "M", "Y"):
+            control = numpy.datetime64("NaT", timecode)
+            test = default_fill_value(numpy.dtype(" 0
+
+            # test different unary domains
+            sqrt(m)
+            log(m)
+            tan(m)
+            arcsin(m)
+            arccos(m)
+            arccosh(m)
+
+            # test binary domains
+            divide(m, 2)
+
+            # also check that allclose uses ma ufuncs, to avoid warning
+            allclose(m, 0.5)
+
+    def test_masked_array_underflow(self):
+        x = np.arange(0, 3, 0.1)
+        X = np.ma.array(x)
+        with np.errstate(under="raise"):
+            X2 = X/2.0
+            np.testing.assert_array_equal(X2, x/2)
+
+class TestMaskedArrayInPlaceArithmetic:
+    # Test MaskedArray Arithmetic
+
+    def setup_method(self):
+        x = arange(10)
+        y = arange(10)
+        xm = arange(10)
+        xm[2] = masked
+        self.intdata = (x, y, xm)
+        self.floatdata = (x.astype(float), y.astype(float), xm.astype(float))
+        self.othertypes = np.typecodes['AllInteger'] + np.typecodes['AllFloat']
+        self.othertypes = [np.dtype(_).type for _ in self.othertypes]
+        self.uint8data = (
+            x.astype(np.uint8),
+            y.astype(np.uint8),
+            xm.astype(np.uint8)
+        )
+
+    def test_inplace_addition_scalar(self):
+        # Test of inplace additions
+        (x, y, xm) = self.intdata
+        xm[2] = masked
+        x += 1
+        assert_equal(x, y + 1)
+        xm += 1
+        assert_equal(xm, y + 1)
+
+        (x, _, xm) = self.floatdata
+        id1 = x.data.ctypes.data
+        x += 1.
+        assert_(id1 == x.data.ctypes.data)
+        assert_equal(x, y + 1.)
+
+    def test_inplace_addition_array(self):
+        # Test of inplace additions
+        (x, y, xm) = self.intdata
+        m = xm.mask
+        a = arange(10, dtype=np.int16)
+        a[-1] = masked
+        x += a
+        xm += a
+        assert_equal(x, y + a)
+        assert_equal(xm, y + a)
+        assert_equal(xm.mask, mask_or(m, a.mask))
+
+    def test_inplace_subtraction_scalar(self):
+        # Test of inplace subtractions
+        (x, y, xm) = self.intdata
+        x -= 1
+        assert_equal(x, y - 1)
+        xm -= 1
+        assert_equal(xm, y - 1)
+
+    def test_inplace_subtraction_array(self):
+        # Test of inplace subtractions
+        (x, y, xm) = self.floatdata
+        m = xm.mask
+        a = arange(10, dtype=float)
+        a[-1] = masked
+        x -= a
+        xm -= a
+        assert_equal(x, y - a)
+        assert_equal(xm, y - a)
+        assert_equal(xm.mask, mask_or(m, a.mask))
+
+    def test_inplace_multiplication_scalar(self):
+        # Test of inplace multiplication
+        (x, y, xm) = self.floatdata
+        x *= 2.0
+        assert_equal(x, y * 2)
+        xm *= 2.0
+        assert_equal(xm, y * 2)
+
+    def test_inplace_multiplication_array(self):
+        # Test of inplace multiplication
+        (x, y, xm) = self.floatdata
+        m = xm.mask
+        a = arange(10, dtype=float)
+        a[-1] = masked
+        x *= a
+        xm *= a
+        assert_equal(x, y * a)
+        assert_equal(xm, y * a)
+        assert_equal(xm.mask, mask_or(m, a.mask))
+
+    def test_inplace_division_scalar_int(self):
+        # Test of inplace division
+        (x, y, xm) = self.intdata
+        x = arange(10) * 2
+        xm = arange(10) * 2
+        xm[2] = masked
+        x //= 2
+        assert_equal(x, y)
+        xm //= 2
+        assert_equal(xm, y)
+
+    def test_inplace_division_scalar_float(self):
+        # Test of inplace division
+        (x, y, xm) = self.floatdata
+        x /= 2.0
+        assert_equal(x, y / 2.0)
+        xm /= arange(10)
+        assert_equal(xm, ones((10,)))
+
+    def test_inplace_division_array_float(self):
+        # Test of inplace division
+        (x, y, xm) = self.floatdata
+        m = xm.mask
+        a = arange(10, dtype=float)
+        a[-1] = masked
+        x /= a
+        xm /= a
+        assert_equal(x, y / a)
+        assert_equal(xm, y / a)
+        assert_equal(xm.mask, mask_or(mask_or(m, a.mask), (a == 0)))
+
+    def test_inplace_division_misc(self):
+
+        x = [1., 1., 1., -2., pi / 2., 4., 5., -10., 10., 1., 2., 3.]
+        y = [5., 0., 3., 2., -1., -4., 0., -10., 10., 1., 0., 3.]
+        m1 = [1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0]
+        m2 = [0, 0, 1, 0, 0, 1, 1, 0, 0, 0, 0, 1]
+        xm = masked_array(x, mask=m1)
+        ym = masked_array(y, mask=m2)
+
+        z = xm / ym
+        assert_equal(z._mask, [1, 1, 1, 0, 0, 1, 1, 0, 0, 0, 1, 1])
+        assert_equal(z._data,
+                     [1., 1., 1., -1., -pi / 2., 4., 5., 1., 1., 1., 2., 3.])
+
+        xm = xm.copy()
+        xm /= ym
+        assert_equal(xm._mask, [1, 1, 1, 0, 0, 1, 1, 0, 0, 0, 1, 1])
+        assert_equal(z._data,
+                     [1., 1., 1., -1., -pi / 2., 4., 5., 1., 1., 1., 2., 3.])
+
+    def test_datafriendly_add(self):
+        # Test keeping data w/ (inplace) addition
+        x = array([1, 2, 3], mask=[0, 0, 1])
+        # Test add w/ scalar
+        xx = x + 1
+        assert_equal(xx.data, [2, 3, 3])
+        assert_equal(xx.mask, [0, 0, 1])
+        # Test iadd w/ scalar
+        x += 1
+        assert_equal(x.data, [2, 3, 3])
+        assert_equal(x.mask, [0, 0, 1])
+        # Test add w/ array
+        x = array([1, 2, 3], mask=[0, 0, 1])
+        xx = x + array([1, 2, 3], mask=[1, 0, 0])
+        assert_equal(xx.data, [1, 4, 3])
+        assert_equal(xx.mask, [1, 0, 1])
+        # Test iadd w/ array
+        x = array([1, 2, 3], mask=[0, 0, 1])
+        x += array([1, 2, 3], mask=[1, 0, 0])
+        assert_equal(x.data, [1, 4, 3])
+        assert_equal(x.mask, [1, 0, 1])
+
+    def test_datafriendly_sub(self):
+        # Test keeping data w/ (inplace) subtraction
+        # Test sub w/ scalar
+        x = array([1, 2, 3], mask=[0, 0, 1])
+        xx = x - 1
+        assert_equal(xx.data, [0, 1, 3])
+        assert_equal(xx.mask, [0, 0, 1])
+        # Test isub w/ scalar
+        x = array([1, 2, 3], mask=[0, 0, 1])
+        x -= 1
+        assert_equal(x.data, [0, 1, 3])
+        assert_equal(x.mask, [0, 0, 1])
+        # Test sub w/ array
+        x = array([1, 2, 3], mask=[0, 0, 1])
+        xx = x - array([1, 2, 3], mask=[1, 0, 0])
+        assert_equal(xx.data, [1, 0, 3])
+        assert_equal(xx.mask, [1, 0, 1])
+        # Test isub w/ array
+        x = array([1, 2, 3], mask=[0, 0, 1])
+        x -= array([1, 2, 3], mask=[1, 0, 0])
+        assert_equal(x.data, [1, 0, 3])
+        assert_equal(x.mask, [1, 0, 1])
+
+    def test_datafriendly_mul(self):
+        # Test keeping data w/ (inplace) multiplication
+        # Test mul w/ scalar
+        x = array([1, 2, 3], mask=[0, 0, 1])
+        xx = x * 2
+        assert_equal(xx.data, [2, 4, 3])
+        assert_equal(xx.mask, [0, 0, 1])
+        # Test imul w/ scalar
+        x = array([1, 2, 3], mask=[0, 0, 1])
+        x *= 2
+        assert_equal(x.data, [2, 4, 3])
+        assert_equal(x.mask, [0, 0, 1])
+        # Test mul w/ array
+        x = array([1, 2, 3], mask=[0, 0, 1])
+        xx = x * array([10, 20, 30], mask=[1, 0, 0])
+        assert_equal(xx.data, [1, 40, 3])
+        assert_equal(xx.mask, [1, 0, 1])
+        # Test imul w/ array
+        x = array([1, 2, 3], mask=[0, 0, 1])
+        x *= array([10, 20, 30], mask=[1, 0, 0])
+        assert_equal(x.data, [1, 40, 3])
+        assert_equal(x.mask, [1, 0, 1])
+
+    def test_datafriendly_div(self):
+        # Test keeping data w/ (inplace) division
+        # Test div on scalar
+        x = array([1, 2, 3], mask=[0, 0, 1])
+        xx = x / 2.
+        assert_equal(xx.data, [1 / 2., 2 / 2., 3])
+        assert_equal(xx.mask, [0, 0, 1])
+        # Test idiv on scalar
+        x = array([1., 2., 3.], mask=[0, 0, 1])
+        x /= 2.
+        assert_equal(x.data, [1 / 2., 2 / 2., 3])
+        assert_equal(x.mask, [0, 0, 1])
+        # Test div on array
+        x = array([1., 2., 3.], mask=[0, 0, 1])
+        xx = x / array([10., 20., 30.], mask=[1, 0, 0])
+        assert_equal(xx.data, [1., 2. / 20., 3.])
+        assert_equal(xx.mask, [1, 0, 1])
+        # Test idiv on array
+        x = array([1., 2., 3.], mask=[0, 0, 1])
+        x /= array([10., 20., 30.], mask=[1, 0, 0])
+        assert_equal(x.data, [1., 2 / 20., 3.])
+        assert_equal(x.mask, [1, 0, 1])
+
+    def test_datafriendly_pow(self):
+        # Test keeping data w/ (inplace) power
+        # Test pow on scalar
+        x = array([1., 2., 3.], mask=[0, 0, 1])
+        xx = x ** 2.5
+        assert_equal(xx.data, [1., 2. ** 2.5, 3.])
+        assert_equal(xx.mask, [0, 0, 1])
+        # Test ipow on scalar
+        x **= 2.5
+        assert_equal(x.data, [1., 2. ** 2.5, 3])
+        assert_equal(x.mask, [0, 0, 1])
+
+    def test_datafriendly_add_arrays(self):
+        a = array([[1, 1], [3, 3]])
+        b = array([1, 1], mask=[0, 0])
+        a += b
+        assert_equal(a, [[2, 2], [4, 4]])
+        if a.mask is not nomask:
+            assert_equal(a.mask, [[0, 0], [0, 0]])
+
+        a = array([[1, 1], [3, 3]])
+        b = array([1, 1], mask=[0, 1])
+        a += b
+        assert_equal(a, [[2, 2], [4, 4]])
+        assert_equal(a.mask, [[0, 1], [0, 1]])
+
+    def test_datafriendly_sub_arrays(self):
+        a = array([[1, 1], [3, 3]])
+        b = array([1, 1], mask=[0, 0])
+        a -= b
+        assert_equal(a, [[0, 0], [2, 2]])
+        if a.mask is not nomask:
+            assert_equal(a.mask, [[0, 0], [0, 0]])
+
+        a = array([[1, 1], [3, 3]])
+        b = array([1, 1], mask=[0, 1])
+        a -= b
+        assert_equal(a, [[0, 0], [2, 2]])
+        assert_equal(a.mask, [[0, 1], [0, 1]])
+
+    def test_datafriendly_mul_arrays(self):
+        a = array([[1, 1], [3, 3]])
+        b = array([1, 1], mask=[0, 0])
+        a *= b
+        assert_equal(a, [[1, 1], [3, 3]])
+        if a.mask is not nomask:
+            assert_equal(a.mask, [[0, 0], [0, 0]])
+
+        a = array([[1, 1], [3, 3]])
+        b = array([1, 1], mask=[0, 1])
+        a *= b
+        assert_equal(a, [[1, 1], [3, 3]])
+        assert_equal(a.mask, [[0, 1], [0, 1]])
+
+    def test_inplace_addition_scalar_type(self):
+        # Test of inplace additions
+        for t in self.othertypes:
+            with warnings.catch_warnings():
+                warnings.filterwarnings("error")
+                (x, y, xm) = (_.astype(t) for _ in self.uint8data)
+                xm[2] = masked
+                x += t(1)
+                assert_equal(x, y + t(1))
+                xm += t(1)
+                assert_equal(xm, y + t(1))
+
+    def test_inplace_addition_array_type(self):
+        # Test of inplace additions
+        for t in self.othertypes:
+            with warnings.catch_warnings():
+                warnings.filterwarnings("error")
+                (x, y, xm) = (_.astype(t) for _ in self.uint8data)
+                m = xm.mask
+                a = arange(10, dtype=t)
+                a[-1] = masked
+                x += a
+                xm += a
+                assert_equal(x, y + a)
+                assert_equal(xm, y + a)
+                assert_equal(xm.mask, mask_or(m, a.mask))
+
+    def test_inplace_subtraction_scalar_type(self):
+        # Test of inplace subtractions
+        for t in self.othertypes:
+            with warnings.catch_warnings():
+                warnings.filterwarnings("error")
+                (x, y, xm) = (_.astype(t) for _ in self.uint8data)
+                x -= t(1)
+                assert_equal(x, y - t(1))
+                xm -= t(1)
+                assert_equal(xm, y - t(1))
+
+    def test_inplace_subtraction_array_type(self):
+        # Test of inplace subtractions
+        for t in self.othertypes:
+            with warnings.catch_warnings():
+                warnings.filterwarnings("error")
+                (x, y, xm) = (_.astype(t) for _ in self.uint8data)
+                m = xm.mask
+                a = arange(10, dtype=t)
+                a[-1] = masked
+                x -= a
+                xm -= a
+                assert_equal(x, y - a)
+                assert_equal(xm, y - a)
+                assert_equal(xm.mask, mask_or(m, a.mask))
+
+    def test_inplace_multiplication_scalar_type(self):
+        # Test of inplace multiplication
+        for t in self.othertypes:
+            with warnings.catch_warnings():
+                warnings.filterwarnings("error")
+                (x, y, xm) = (_.astype(t) for _ in self.uint8data)
+                x *= t(2)
+                assert_equal(x, y * t(2))
+                xm *= t(2)
+                assert_equal(xm, y * t(2))
+
+    def test_inplace_multiplication_array_type(self):
+        # Test of inplace multiplication
+        for t in self.othertypes:
+            with warnings.catch_warnings():
+                warnings.filterwarnings("error")
+                (x, y, xm) = (_.astype(t) for _ in self.uint8data)
+                m = xm.mask
+                a = arange(10, dtype=t)
+                a[-1] = masked
+                x *= a
+                xm *= a
+                assert_equal(x, y * a)
+                assert_equal(xm, y * a)
+                assert_equal(xm.mask, mask_or(m, a.mask))
+
+    def test_inplace_floor_division_scalar_type(self):
+        # Test of inplace division
+        # Check for TypeError in case of unsupported types
+        unsupported = {np.dtype(t).type for t in np.typecodes["Complex"]}
+        for t in self.othertypes:
+            with warnings.catch_warnings():
+                warnings.filterwarnings("error")
+                (x, y, xm) = (_.astype(t) for _ in self.uint8data)
+                x = arange(10, dtype=t) * t(2)
+                xm = arange(10, dtype=t) * t(2)
+                xm[2] = masked
+                try:
+                    x //= t(2)
+                    xm //= t(2)
+                    assert_equal(x, y)
+                    assert_equal(xm, y)
+                except TypeError:
+                    msg = f"Supported type {t} throwing TypeError"
+                    assert t in unsupported, msg
+
+    def test_inplace_floor_division_array_type(self):
+        # Test of inplace division
+        # Check for TypeError in case of unsupported types
+        unsupported = {np.dtype(t).type for t in np.typecodes["Complex"]}
+        for t in self.othertypes:
+            with warnings.catch_warnings():
+                warnings.filterwarnings("error")
+                (x, y, xm) = (_.astype(t) for _ in self.uint8data)
+                m = xm.mask
+                a = arange(10, dtype=t)
+                a[-1] = masked
+                try:
+                    x //= a
+                    xm //= a
+                    assert_equal(x, y // a)
+                    assert_equal(xm, y // a)
+                    assert_equal(
+                        xm.mask,
+                        mask_or(mask_or(m, a.mask), (a == t(0)))
+                    )
+                except TypeError:
+                    msg = f"Supported type {t} throwing TypeError"
+                    assert t in unsupported, msg
+
+    def test_inplace_division_scalar_type(self):
+        # Test of inplace division
+        for t in self.othertypes:
+            with suppress_warnings() as sup:
+                sup.record(UserWarning)
+
+                (x, y, xm) = (_.astype(t) for _ in self.uint8data)
+                x = arange(10, dtype=t) * t(2)
+                xm = arange(10, dtype=t) * t(2)
+                xm[2] = masked
+
+                # May get a DeprecationWarning or a TypeError.
+                #
+                # This is a consequence of the fact that this is true divide
+                # and will require casting to float for calculation and
+                # casting back to the original type. This will only be raised
+                # with integers. Whether it is an error or warning is only
+                # dependent on how stringent the casting rules are.
+                #
+                # Will handle the same way.
+                try:
+                    x /= t(2)
+                    assert_equal(x, y)
+                except (DeprecationWarning, TypeError) as e:
+                    warnings.warn(str(e), stacklevel=1)
+                try:
+                    xm /= t(2)
+                    assert_equal(xm, y)
+                except (DeprecationWarning, TypeError) as e:
+                    warnings.warn(str(e), stacklevel=1)
+
+                if issubclass(t, np.integer):
+                    assert_equal(len(sup.log), 2, f'Failed on type={t}.')
+                else:
+                    assert_equal(len(sup.log), 0, f'Failed on type={t}.')
+
+    def test_inplace_division_array_type(self):
+        # Test of inplace division
+        for t in self.othertypes:
+            with suppress_warnings() as sup:
+                sup.record(UserWarning)
+                (x, y, xm) = (_.astype(t) for _ in self.uint8data)
+                m = xm.mask
+                a = arange(10, dtype=t)
+                a[-1] = masked
+
+                # May get a DeprecationWarning or a TypeError.
+                #
+                # This is a consequence of the fact that this is true divide
+                # and will require casting to float for calculation and
+                # casting back to the original type. This will only be raised
+                # with integers. Whether it is an error or warning is only
+                # dependent on how stringent the casting rules are.
+                #
+                # Will handle the same way.
+                try:
+                    x /= a
+                    assert_equal(x, y / a)
+                except (DeprecationWarning, TypeError) as e:
+                    warnings.warn(str(e), stacklevel=1)
+                try:
+                    xm /= a
+                    assert_equal(xm, y / a)
+                    assert_equal(
+                        xm.mask,
+                        mask_or(mask_or(m, a.mask), (a == t(0)))
+                    )
+                except (DeprecationWarning, TypeError) as e:
+                    warnings.warn(str(e), stacklevel=1)
+
+                if issubclass(t, np.integer):
+                    assert_equal(len(sup.log), 2, f'Failed on type={t}.')
+                else:
+                    assert_equal(len(sup.log), 0, f'Failed on type={t}.')
+
+    def test_inplace_pow_type(self):
+        # Test keeping data w/ (inplace) power
+        for t in self.othertypes:
+            with warnings.catch_warnings():
+                warnings.filterwarnings("error")
+                # Test pow on scalar
+                x = array([1, 2, 3], mask=[0, 0, 1], dtype=t)
+                xx = x ** t(2)
+                xx_r = array([1, 2 ** 2, 3], mask=[0, 0, 1], dtype=t)
+                assert_equal(xx.data, xx_r.data)
+                assert_equal(xx.mask, xx_r.mask)
+                # Test ipow on scalar
+                x **= t(2)
+                assert_equal(x.data, xx_r.data)
+                assert_equal(x.mask, xx_r.mask)
+
+
+class TestMaskedArrayMethods:
+    # Test class for miscellaneous MaskedArrays methods.
+    def setup_method(self):
+        # Base data definition.
+        x = np.array([8.375, 7.545, 8.828, 8.5, 1.757, 5.928,
+                      8.43, 7.78, 9.865, 5.878, 8.979, 4.732,
+                      3.012, 6.022, 5.095, 3.116, 5.238, 3.957,
+                      6.04, 9.63, 7.712, 3.382, 4.489, 6.479,
+                      7.189, 9.645, 5.395, 4.961, 9.894, 2.893,
+                      7.357, 9.828, 6.272, 3.758, 6.693, 0.993])
+        X = x.reshape(6, 6)
+        XX = x.reshape(3, 2, 2, 3)
+
+        m = np.array([0, 1, 0, 1, 0, 0,
+                     1, 0, 1, 1, 0, 1,
+                     0, 0, 0, 1, 0, 1,
+                     0, 0, 0, 1, 1, 1,
+                     1, 0, 0, 1, 0, 0,
+                     0, 0, 1, 0, 1, 0])
+        mx = array(data=x, mask=m)
+        mX = array(data=X, mask=m.reshape(X.shape))
+        mXX = array(data=XX, mask=m.reshape(XX.shape))
+
+        m2 = np.array([1, 1, 0, 1, 0, 0,
+                      1, 1, 1, 1, 0, 1,
+                      0, 0, 1, 1, 0, 1,
+                      0, 0, 0, 1, 1, 1,
+                      1, 0, 0, 1, 1, 0,
+                      0, 0, 1, 0, 1, 1])
+        m2x = array(data=x, mask=m2)
+        m2X = array(data=X, mask=m2.reshape(X.shape))
+        m2XX = array(data=XX, mask=m2.reshape(XX.shape))
+        self.d = (x, X, XX, m, mx, mX, mXX, m2x, m2X, m2XX)
+
+    def test_generic_methods(self):
+        # Tests some MaskedArray methods.
+        a = array([1, 3, 2])
+        assert_equal(a.any(), a._data.any())
+        assert_equal(a.all(), a._data.all())
+        assert_equal(a.argmax(), a._data.argmax())
+        assert_equal(a.argmin(), a._data.argmin())
+        assert_equal(a.choose(0, 1, 2, 3, 4), a._data.choose(0, 1, 2, 3, 4))
+        assert_equal(a.compress([1, 0, 1]), a._data.compress([1, 0, 1]))
+        assert_equal(a.conj(), a._data.conj())
+        assert_equal(a.conjugate(), a._data.conjugate())
+
+        m = array([[1, 2], [3, 4]])
+        assert_equal(m.diagonal(), m._data.diagonal())
+        assert_equal(a.sum(), a._data.sum())
+        assert_equal(a.take([1, 2]), a._data.take([1, 2]))
+        assert_equal(m.transpose(), m._data.transpose())
+
+    def test_allclose(self):
+        # Tests allclose on arrays
+        a = np.random.rand(10)
+        b = a + np.random.rand(10) * 1e-8
+        assert_(allclose(a, b))
+        # Test allclose w/ infs
+        a[0] = np.inf
+        assert_(not allclose(a, b))
+        b[0] = np.inf
+        assert_(allclose(a, b))
+        # Test allclose w/ masked
+        a = masked_array(a)
+        a[-1] = masked
+        assert_(allclose(a, b, masked_equal=True))
+        assert_(not allclose(a, b, masked_equal=False))
+        # Test comparison w/ scalar
+        a *= 1e-8
+        a[0] = 0
+        assert_(allclose(a, 0, masked_equal=True))
+
+        # Test that the function works for MIN_INT integer typed arrays
+        a = masked_array([np.iinfo(np.int_).min], dtype=np.int_)
+        assert_(allclose(a, a))
+
+    def test_allclose_timedelta(self):
+        # Allclose currently works for timedelta64 as long as `atol` is
+        # an integer or also a timedelta64
+        a = np.array([[1, 2, 3, 4]], dtype="m8[ns]")
+        assert allclose(a, a, atol=0)
+        assert allclose(a, a, atol=np.timedelta64(1, "ns"))
+
+    def test_allany(self):
+        # Checks the any/all methods/functions.
+        x = np.array([[0.13, 0.26, 0.90],
+                      [0.28, 0.33, 0.63],
+                      [0.31, 0.87, 0.70]])
+        m = np.array([[True, False, False],
+                      [False, False, False],
+                      [True, True, False]], dtype=np.bool)
+        mx = masked_array(x, mask=m)
+        mxbig = (mx > 0.5)
+        mxsmall = (mx < 0.5)
+
+        assert_(not mxbig.all())
+        assert_(mxbig.any())
+        assert_equal(mxbig.all(0), [False, False, True])
+        assert_equal(mxbig.all(1), [False, False, True])
+        assert_equal(mxbig.any(0), [False, False, True])
+        assert_equal(mxbig.any(1), [True, True, True])
+
+        assert_(not mxsmall.all())
+        assert_(mxsmall.any())
+        assert_equal(mxsmall.all(0), [True, True, False])
+        assert_equal(mxsmall.all(1), [False, False, False])
+        assert_equal(mxsmall.any(0), [True, True, False])
+        assert_equal(mxsmall.any(1), [True, True, False])
+
+    def test_allany_oddities(self):
+        # Some fun with all and any
+        store = empty((), dtype=bool)
+        full = array([1, 2, 3], mask=True)
+
+        assert_(full.all() is masked)
+        full.all(out=store)
+        assert_(store)
+        assert_(store._mask, True)
+        assert_(store is not masked)
+
+        store = empty((), dtype=bool)
+        assert_(full.any() is masked)
+        full.any(out=store)
+        assert_(not store)
+        assert_(store._mask, True)
+        assert_(store is not masked)
+
+    def test_argmax_argmin(self):
+        # Tests argmin & argmax on MaskedArrays.
+        (x, X, XX, m, mx, mX, mXX, m2x, m2X, m2XX) = self.d
+
+        assert_equal(mx.argmin(), 35)
+        assert_equal(mX.argmin(), 35)
+        assert_equal(m2x.argmin(), 4)
+        assert_equal(m2X.argmin(), 4)
+        assert_equal(mx.argmax(), 28)
+        assert_equal(mX.argmax(), 28)
+        assert_equal(m2x.argmax(), 31)
+        assert_equal(m2X.argmax(), 31)
+
+        assert_equal(mX.argmin(0), [2, 2, 2, 5, 0, 5])
+        assert_equal(m2X.argmin(0), [2, 2, 4, 5, 0, 4])
+        assert_equal(mX.argmax(0), [0, 5, 0, 5, 4, 0])
+        assert_equal(m2X.argmax(0), [5, 5, 0, 5, 1, 0])
+
+        assert_equal(mX.argmin(1), [4, 1, 0, 0, 5, 5, ])
+        assert_equal(m2X.argmin(1), [4, 4, 0, 0, 5, 3])
+        assert_equal(mX.argmax(1), [2, 4, 1, 1, 4, 1])
+        assert_equal(m2X.argmax(1), [2, 4, 1, 1, 1, 1])
+
+    def test_clip(self):
+        # Tests clip on MaskedArrays.
+        x = np.array([8.375, 7.545, 8.828, 8.5, 1.757, 5.928,
+                      8.43, 7.78, 9.865, 5.878, 8.979, 4.732,
+                      3.012, 6.022, 5.095, 3.116, 5.238, 3.957,
+                      6.04, 9.63, 7.712, 3.382, 4.489, 6.479,
+                      7.189, 9.645, 5.395, 4.961, 9.894, 2.893,
+                      7.357, 9.828, 6.272, 3.758, 6.693, 0.993])
+        m = np.array([0, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 1,
+                      0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 1, 1,
+                      1, 0, 0, 1, 0, 0, 0, 0, 1, 0, 1, 0])
+        mx = array(x, mask=m)
+        clipped = mx.clip(2, 8)
+        assert_equal(clipped.mask, mx.mask)
+        assert_equal(clipped._data, x.clip(2, 8))
+        assert_equal(clipped._data, mx._data.clip(2, 8))
+
+    def test_clip_out(self):
+        # gh-14140
+        a = np.arange(10)
+        m = np.ma.MaskedArray(a, mask=[0, 1] * 5)
+        m.clip(0, 5, out=m)
+        assert_equal(m.mask, [0, 1] * 5)
+
+    def test_compress(self):
+        # test compress
+        a = masked_array([1., 2., 3., 4., 5.], fill_value=9999)
+        condition = (a > 1.5) & (a < 3.5)
+        assert_equal(a.compress(condition), [2., 3.])
+
+        a[[2, 3]] = masked
+        b = a.compress(condition)
+        assert_equal(b._data, [2., 3.])
+        assert_equal(b._mask, [0, 1])
+        assert_equal(b.fill_value, 9999)
+        assert_equal(b, a[condition])
+
+        condition = (a < 4.)
+        b = a.compress(condition)
+        assert_equal(b._data, [1., 2., 3.])
+        assert_equal(b._mask, [0, 0, 1])
+        assert_equal(b.fill_value, 9999)
+        assert_equal(b, a[condition])
+
+        a = masked_array([[10, 20, 30], [40, 50, 60]],
+                         mask=[[0, 0, 1], [1, 0, 0]])
+        b = a.compress(a.ravel() >= 22)
+        assert_equal(b._data, [30, 40, 50, 60])
+        assert_equal(b._mask, [1, 1, 0, 0])
+
+        x = np.array([3, 1, 2])
+        b = a.compress(x >= 2, axis=1)
+        assert_equal(b._data, [[10, 30], [40, 60]])
+        assert_equal(b._mask, [[0, 1], [1, 0]])
+
+    def test_compressed(self):
+        # Tests compressed
+        a = array([1, 2, 3, 4], mask=[0, 0, 0, 0])
+        b = a.compressed()
+        assert_equal(b, a)
+        a[0] = masked
+        b = a.compressed()
+        assert_equal(b, [2, 3, 4])
+
+    def test_empty(self):
+        # Tests empty/like
+        datatype = [('a', int), ('b', float), ('c', '|S8')]
+        a = masked_array([(1, 1.1, '1.1'), (2, 2.2, '2.2'), (3, 3.3, '3.3')],
+                         dtype=datatype)
+        assert_equal(len(a.fill_value.item()), len(datatype))
+
+        b = empty_like(a)
+        assert_equal(b.shape, a.shape)
+        assert_equal(b.fill_value, a.fill_value)
+
+        b = empty(len(a), dtype=datatype)
+        assert_equal(b.shape, a.shape)
+        assert_equal(b.fill_value, a.fill_value)
+
+        # check empty_like mask handling
+        a = masked_array([1, 2, 3], mask=[False, True, False])
+        b = empty_like(a)
+        assert_(not np.may_share_memory(a.mask, b.mask))
+        b = a.view(masked_array)
+        assert_(np.may_share_memory(a.mask, b.mask))
+
+    def test_zeros(self):
+        # Tests zeros/like
+        datatype = [('a', int), ('b', float), ('c', '|S8')]
+        a = masked_array([(1, 1.1, '1.1'), (2, 2.2, '2.2'), (3, 3.3, '3.3')],
+                         dtype=datatype)
+        assert_equal(len(a.fill_value.item()), len(datatype))
+
+        b = zeros(len(a), dtype=datatype)
+        assert_equal(b.shape, a.shape)
+        assert_equal(b.fill_value, a.fill_value)
+
+        b = zeros_like(a)
+        assert_equal(b.shape, a.shape)
+        assert_equal(b.fill_value, a.fill_value)
+
+        # check zeros_like mask handling
+        a = masked_array([1, 2, 3], mask=[False, True, False])
+        b = zeros_like(a)
+        assert_(not np.may_share_memory(a.mask, b.mask))
+        b = a.view()
+        assert_(np.may_share_memory(a.mask, b.mask))
+
+    def test_ones(self):
+        # Tests ones/like
+        datatype = [('a', int), ('b', float), ('c', '|S8')]
+        a = masked_array([(1, 1.1, '1.1'), (2, 2.2, '2.2'), (3, 3.3, '3.3')],
+                         dtype=datatype)
+        assert_equal(len(a.fill_value.item()), len(datatype))
+
+        b = ones(len(a), dtype=datatype)
+        assert_equal(b.shape, a.shape)
+        assert_equal(b.fill_value, a.fill_value)
+
+        b = ones_like(a)
+        assert_equal(b.shape, a.shape)
+        assert_equal(b.fill_value, a.fill_value)
+
+        # check ones_like mask handling
+        a = masked_array([1, 2, 3], mask=[False, True, False])
+        b = ones_like(a)
+        assert_(not np.may_share_memory(a.mask, b.mask))
+        b = a.view()
+        assert_(np.may_share_memory(a.mask, b.mask))
+
+    @suppress_copy_mask_on_assignment
+    def test_put(self):
+        # Tests put.
+        d = arange(5)
+        n = [0, 0, 0, 1, 1]
+        m = make_mask(n)
+        x = array(d, mask=m)
+        assert_(x[3] is masked)
+        assert_(x[4] is masked)
+        x[[1, 4]] = [10, 40]
+        assert_(x[3] is masked)
+        assert_(x[4] is not masked)
+        assert_equal(x, [0, 10, 2, -1, 40])
+
+        x = masked_array(arange(10), mask=[1, 0, 0, 0, 0] * 2)
+        i = [0, 2, 4, 6]
+        x.put(i, [6, 4, 2, 0])
+        assert_equal(x, asarray([6, 1, 4, 3, 2, 5, 0, 7, 8, 9, ]))
+        assert_equal(x.mask, [0, 0, 0, 0, 0, 1, 0, 0, 0, 0])
+        x.put(i, masked_array([0, 2, 4, 6], [1, 0, 1, 0]))
+        assert_array_equal(x, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, ])
+        assert_equal(x.mask, [1, 0, 0, 0, 1, 1, 0, 0, 0, 0])
+
+        x = masked_array(arange(10), mask=[1, 0, 0, 0, 0] * 2)
+        put(x, i, [6, 4, 2, 0])
+        assert_equal(x, asarray([6, 1, 4, 3, 2, 5, 0, 7, 8, 9, ]))
+        assert_equal(x.mask, [0, 0, 0, 0, 0, 1, 0, 0, 0, 0])
+        put(x, i, masked_array([0, 2, 4, 6], [1, 0, 1, 0]))
+        assert_array_equal(x, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, ])
+        assert_equal(x.mask, [1, 0, 0, 0, 1, 1, 0, 0, 0, 0])
+
+    def test_put_nomask(self):
+        # GitHub issue 6425
+        x = zeros(10)
+        z = array([3., -1.], mask=[False, True])
+
+        x.put([1, 2], z)
+        assert_(x[0] is not masked)
+        assert_equal(x[0], 0)
+        assert_(x[1] is not masked)
+        assert_equal(x[1], 3)
+        assert_(x[2] is masked)
+        assert_(x[3] is not masked)
+        assert_equal(x[3], 0)
+
+    def test_put_hardmask(self):
+        # Tests put on hardmask
+        d = arange(5)
+        n = [0, 0, 0, 1, 1]
+        m = make_mask(n)
+        xh = array(d + 1, mask=m, hard_mask=True, copy=True)
+        xh.put([4, 2, 0, 1, 3], [1, 2, 3, 4, 5])
+        assert_equal(xh._data, [3, 4, 2, 4, 5])
+
+    def test_putmask(self):
+        x = arange(6) + 1
+        mx = array(x, mask=[0, 0, 0, 1, 1, 1])
+        mask = [0, 0, 1, 0, 0, 1]
+        # w/o mask, w/o masked values
+        xx = x.copy()
+        putmask(xx, mask, 99)
+        assert_equal(xx, [1, 2, 99, 4, 5, 99])
+        # w/ mask, w/o masked values
+        mxx = mx.copy()
+        putmask(mxx, mask, 99)
+        assert_equal(mxx._data, [1, 2, 99, 4, 5, 99])
+        assert_equal(mxx._mask, [0, 0, 0, 1, 1, 0])
+        # w/o mask, w/ masked values
+        values = array([10, 20, 30, 40, 50, 60], mask=[1, 1, 1, 0, 0, 0])
+        xx = x.copy()
+        putmask(xx, mask, values)
+        assert_equal(xx._data, [1, 2, 30, 4, 5, 60])
+        assert_equal(xx._mask, [0, 0, 1, 0, 0, 0])
+        # w/ mask, w/ masked values
+        mxx = mx.copy()
+        putmask(mxx, mask, values)
+        assert_equal(mxx._data, [1, 2, 30, 4, 5, 60])
+        assert_equal(mxx._mask, [0, 0, 1, 1, 1, 0])
+        # w/ mask, w/ masked values + hardmask
+        mxx = mx.copy()
+        mxx.harden_mask()
+        putmask(mxx, mask, values)
+        assert_equal(mxx, [1, 2, 30, 4, 5, 60])
+
+    def test_ravel(self):
+        # Tests ravel
+        a = array([[1, 2, 3, 4, 5]], mask=[[0, 1, 0, 0, 0]])
+        aravel = a.ravel()
+        assert_equal(aravel._mask.shape, aravel.shape)
+        a = array([0, 0], mask=[1, 1])
+        aravel = a.ravel()
+        assert_equal(aravel._mask.shape, a.shape)
+        # Checks that small_mask is preserved
+        a = array([1, 2, 3, 4], mask=[0, 0, 0, 0], shrink=False)
+        assert_equal(a.ravel()._mask, [0, 0, 0, 0])
+        # Test that the fill_value is preserved
+        a.fill_value = -99
+        a.shape = (2, 2)
+        ar = a.ravel()
+        assert_equal(ar._mask, [0, 0, 0, 0])
+        assert_equal(ar._data, [1, 2, 3, 4])
+        assert_equal(ar.fill_value, -99)
+        # Test index ordering
+        assert_equal(a.ravel(order='C'), [1, 2, 3, 4])
+        assert_equal(a.ravel(order='F'), [1, 3, 2, 4])
+
+    @pytest.mark.parametrize("order", "AKCF")
+    @pytest.mark.parametrize("data_order", "CF")
+    def test_ravel_order(self, order, data_order):
+        # Ravelling must ravel mask and data in the same order always to avoid
+        # misaligning the two in the ravel result.
+        arr = np.ones((5, 10), order=data_order)
+        arr[0, :] = 0
+        mask = np.ones((10, 5), dtype=bool, order=data_order).T
+        mask[0, :] = False
+        x = array(arr, mask=mask)
+        assert x._data.flags.fnc != x._mask.flags.fnc
+        assert (x.filled(0) == 0).all()
+        raveled = x.ravel(order)
+        assert (raveled.filled(0) == 0).all()
+
+        # NOTE: Can be wrong if arr order is neither C nor F and `order="K"`
+        assert_array_equal(arr.ravel(order), x.ravel(order)._data)
+
+    def test_reshape(self):
+        # Tests reshape
+        x = arange(4)
+        x[0] = masked
+        y = x.reshape(2, 2)
+        assert_equal(y.shape, (2, 2,))
+        assert_equal(y._mask.shape, (2, 2,))
+        assert_equal(x.shape, (4,))
+        assert_equal(x._mask.shape, (4,))
+
+    def test_sort(self):
+        # Test sort
+        x = array([1, 4, 2, 3], mask=[0, 1, 0, 0], dtype=np.uint8)
+
+        sortedx = sort(x)
+        assert_equal(sortedx._data, [1, 2, 3, 4])
+        assert_equal(sortedx._mask, [0, 0, 0, 1])
+
+        sortedx = sort(x, endwith=False)
+        assert_equal(sortedx._data, [4, 1, 2, 3])
+        assert_equal(sortedx._mask, [1, 0, 0, 0])
+
+        x.sort()
+        assert_equal(x._data, [1, 2, 3, 4])
+        assert_equal(x._mask, [0, 0, 0, 1])
+
+        x = array([1, 4, 2, 3], mask=[0, 1, 0, 0], dtype=np.uint8)
+        x.sort(endwith=False)
+        assert_equal(x._data, [4, 1, 2, 3])
+        assert_equal(x._mask, [1, 0, 0, 0])
+
+        x = [1, 4, 2, 3]
+        sortedx = sort(x)
+        assert_(not isinstance(sorted, MaskedArray))
+
+        x = array([0, 1, -1, -2, 2], mask=nomask, dtype=np.int8)
+        sortedx = sort(x, endwith=False)
+        assert_equal(sortedx._data, [-2, -1, 0, 1, 2])
+        x = array([0, 1, -1, -2, 2], mask=[0, 1, 0, 0, 1], dtype=np.int8)
+        sortedx = sort(x, endwith=False)
+        assert_equal(sortedx._data, [1, 2, -2, -1, 0])
+        assert_equal(sortedx._mask, [1, 1, 0, 0, 0])
+
+        x = array([0, -1], dtype=np.int8)
+        sortedx = sort(x, kind="stable")
+        assert_equal(sortedx, array([-1, 0], dtype=np.int8))
+
+    def test_stable_sort(self):
+        x = array([1, 2, 3, 1, 2, 3], dtype=np.uint8)
+        expected = array([0, 3, 1, 4, 2, 5])
+        computed = argsort(x, kind='stable')
+        assert_equal(computed, expected)
+
+    def test_argsort_matches_sort(self):
+        x = array([1, 4, 2, 3], mask=[0, 1, 0, 0], dtype=np.uint8)
+
+        for kwargs in [dict(),
+                       dict(endwith=True),
+                       dict(endwith=False),
+                       dict(fill_value=2),
+                       dict(fill_value=2, endwith=True),
+                       dict(fill_value=2, endwith=False)]:
+            sortedx = sort(x, **kwargs)
+            argsortedx = x[argsort(x, **kwargs)]
+            assert_equal(sortedx._data, argsortedx._data)
+            assert_equal(sortedx._mask, argsortedx._mask)
+
+    def test_sort_2d(self):
+        # Check sort of 2D array.
+        # 2D array w/o mask
+        a = masked_array([[8, 4, 1], [2, 0, 9]])
+        a.sort(0)
+        assert_equal(a, [[2, 0, 1], [8, 4, 9]])
+        a = masked_array([[8, 4, 1], [2, 0, 9]])
+        a.sort(1)
+        assert_equal(a, [[1, 4, 8], [0, 2, 9]])
+        # 2D array w/mask
+        a = masked_array([[8, 4, 1], [2, 0, 9]], mask=[[1, 0, 0], [0, 0, 1]])
+        a.sort(0)
+        assert_equal(a, [[2, 0, 1], [8, 4, 9]])
+        assert_equal(a._mask, [[0, 0, 0], [1, 0, 1]])
+        a = masked_array([[8, 4, 1], [2, 0, 9]], mask=[[1, 0, 0], [0, 0, 1]])
+        a.sort(1)
+        assert_equal(a, [[1, 4, 8], [0, 2, 9]])
+        assert_equal(a._mask, [[0, 0, 1], [0, 0, 1]])
+        # 3D
+        a = masked_array([[[7, 8, 9], [4, 5, 6], [1, 2, 3]],
+                          [[1, 2, 3], [7, 8, 9], [4, 5, 6]],
+                          [[7, 8, 9], [1, 2, 3], [4, 5, 6]],
+                          [[4, 5, 6], [1, 2, 3], [7, 8, 9]]])
+        a[a % 4 == 0] = masked
+        am = a.copy()
+        an = a.filled(99)
+        am.sort(0)
+        an.sort(0)
+        assert_equal(am, an)
+        am = a.copy()
+        an = a.filled(99)
+        am.sort(1)
+        an.sort(1)
+        assert_equal(am, an)
+        am = a.copy()
+        an = a.filled(99)
+        am.sort(2)
+        an.sort(2)
+        assert_equal(am, an)
+
+    def test_sort_flexible(self):
+        # Test sort on structured dtype.
+        a = array(
+            data=[(3, 3), (3, 2), (2, 2), (2, 1), (1, 0), (1, 1), (1, 2)],
+            mask=[(0, 0), (0, 1), (0, 0), (0, 0), (1, 0), (0, 0), (0, 0)],
+            dtype=[('A', int), ('B', int)])
+        mask_last = array(
+            data=[(1, 1), (1, 2), (2, 1), (2, 2), (3, 3), (3, 2), (1, 0)],
+            mask=[(0, 0), (0, 0), (0, 0), (0, 0), (0, 0), (0, 1), (1, 0)],
+            dtype=[('A', int), ('B', int)])
+        mask_first = array(
+            data=[(1, 0), (1, 1), (1, 2), (2, 1), (2, 2), (3, 2), (3, 3)],
+            mask=[(1, 0), (0, 0), (0, 0), (0, 0), (0, 0), (0, 1), (0, 0)],
+            dtype=[('A', int), ('B', int)])
+
+        test = sort(a)
+        assert_equal(test, mask_last)
+        assert_equal(test.mask, mask_last.mask)
+
+        test = sort(a, endwith=False)
+        assert_equal(test, mask_first)
+        assert_equal(test.mask, mask_first.mask)
+
+        # Test sort on dtype with subarray (gh-8069)
+        # Just check that the sort does not error, structured array subarrays
+        # are treated as byte strings and that leads to differing behavior
+        # depending on endianness and `endwith`.
+        dt = np.dtype([('v', int, 2)])
+        a = a.view(dt)
+        test = sort(a)
+        test = sort(a, endwith=False)
+
+    def test_argsort(self):
+        # Test argsort
+        a = array([1, 5, 2, 4, 3], mask=[1, 0, 0, 1, 0])
+        assert_equal(np.argsort(a), argsort(a))
+
+    def test_squeeze(self):
+        # Check squeeze
+        data = masked_array([[1, 2, 3]])
+        assert_equal(data.squeeze(), [1, 2, 3])
+        data = masked_array([[1, 2, 3]], mask=[[1, 1, 1]])
+        assert_equal(data.squeeze(), [1, 2, 3])
+        assert_equal(data.squeeze()._mask, [1, 1, 1])
+
+        # normal ndarrays return a view
+        arr = np.array([[1]])
+        arr_sq = arr.squeeze()
+        assert_equal(arr_sq, 1)
+        arr_sq[...] = 2
+        assert_equal(arr[0,0], 2)
+
+        # so maskedarrays should too
+        m_arr = masked_array([[1]], mask=True)
+        m_arr_sq = m_arr.squeeze()
+        assert_(m_arr_sq is not np.ma.masked)
+        assert_equal(m_arr_sq.mask, True)
+        m_arr_sq[...] = 2
+        assert_equal(m_arr[0,0], 2)
+
+    def test_swapaxes(self):
+        # Tests swapaxes on MaskedArrays.
+        x = np.array([8.375, 7.545, 8.828, 8.5, 1.757, 5.928,
+                      8.43, 7.78, 9.865, 5.878, 8.979, 4.732,
+                      3.012, 6.022, 5.095, 3.116, 5.238, 3.957,
+                      6.04, 9.63, 7.712, 3.382, 4.489, 6.479,
+                      7.189, 9.645, 5.395, 4.961, 9.894, 2.893,
+                      7.357, 9.828, 6.272, 3.758, 6.693, 0.993])
+        m = np.array([0, 1, 0, 1, 0, 0,
+                      1, 0, 1, 1, 0, 1,
+                      0, 0, 0, 1, 0, 1,
+                      0, 0, 0, 1, 1, 1,
+                      1, 0, 0, 1, 0, 0,
+                      0, 0, 1, 0, 1, 0])
+        mX = array(x, mask=m).reshape(6, 6)
+        mXX = mX.reshape(3, 2, 2, 3)
+
+        mXswapped = mX.swapaxes(0, 1)
+        assert_equal(mXswapped[-1], mX[:, -1])
+
+        mXXswapped = mXX.swapaxes(0, 2)
+        assert_equal(mXXswapped.shape, (2, 2, 3, 3))
+
+    def test_take(self):
+        # Tests take
+        x = masked_array([10, 20, 30, 40], [0, 1, 0, 1])
+        assert_equal(x.take([0, 0, 3]), masked_array([10, 10, 40], [0, 0, 1]))
+        assert_equal(x.take([0, 0, 3]), x[[0, 0, 3]])
+        assert_equal(x.take([[0, 1], [0, 1]]),
+                     masked_array([[10, 20], [10, 20]], [[0, 1], [0, 1]]))
+
+        # assert_equal crashes when passed np.ma.mask
+        assert_(x[1] is np.ma.masked)
+        assert_(x.take(1) is np.ma.masked)
+
+        x = array([[10, 20, 30], [40, 50, 60]], mask=[[0, 0, 1], [1, 0, 0, ]])
+        assert_equal(x.take([0, 2], axis=1),
+                     array([[10, 30], [40, 60]], mask=[[0, 1], [1, 0]]))
+        assert_equal(take(x, [0, 2], axis=1),
+                     array([[10, 30], [40, 60]], mask=[[0, 1], [1, 0]]))
+
+    def test_take_masked_indices(self):
+        # Test take w/ masked indices
+        a = np.array((40, 18, 37, 9, 22))
+        indices = np.arange(3)[None,:] + np.arange(5)[:, None]
+        mindices = array(indices, mask=(indices >= len(a)))
+        # No mask
+        test = take(a, mindices, mode='clip')
+        ctrl = array([[40, 18, 37],
+                      [18, 37, 9],
+                      [37, 9, 22],
+                      [9, 22, 22],
+                      [22, 22, 22]])
+        assert_equal(test, ctrl)
+        # Masked indices
+        test = take(a, mindices)
+        ctrl = array([[40, 18, 37],
+                      [18, 37, 9],
+                      [37, 9, 22],
+                      [9, 22, 40],
+                      [22, 40, 40]])
+        ctrl[3, 2] = ctrl[4, 1] = ctrl[4, 2] = masked
+        assert_equal(test, ctrl)
+        assert_equal(test.mask, ctrl.mask)
+        # Masked input + masked indices
+        a = array((40, 18, 37, 9, 22), mask=(0, 1, 0, 0, 0))
+        test = take(a, mindices)
+        ctrl[0, 1] = ctrl[1, 0] = masked
+        assert_equal(test, ctrl)
+        assert_equal(test.mask, ctrl.mask)
+
+    def test_tolist(self):
+        # Tests to list
+        # ... on 1D
+        x = array(np.arange(12))
+        x[[1, -2]] = masked
+        xlist = x.tolist()
+        assert_(xlist[1] is None)
+        assert_(xlist[-2] is None)
+        # ... on 2D
+        x.shape = (3, 4)
+        xlist = x.tolist()
+        ctrl = [[0, None, 2, 3], [4, 5, 6, 7], [8, 9, None, 11]]
+        assert_equal(xlist[0], [0, None, 2, 3])
+        assert_equal(xlist[1], [4, 5, 6, 7])
+        assert_equal(xlist[2], [8, 9, None, 11])
+        assert_equal(xlist, ctrl)
+        # ... on structured array w/ masked records
+        x = array(list(zip([1, 2, 3],
+                           [1.1, 2.2, 3.3],
+                           ['one', 'two', 'thr'])),
+                  dtype=[('a', int), ('b', float), ('c', '|S8')])
+        x[-1] = masked
+        assert_equal(x.tolist(),
+                     [(1, 1.1, b'one'),
+                      (2, 2.2, b'two'),
+                      (None, None, None)])
+        # ... on structured array w/ masked fields
+        a = array([(1, 2,), (3, 4)], mask=[(0, 1), (0, 0)],
+                  dtype=[('a', int), ('b', int)])
+        test = a.tolist()
+        assert_equal(test, [[1, None], [3, 4]])
+        # ... on mvoid
+        a = a[0]
+        test = a.tolist()
+        assert_equal(test, [1, None])
+
+    def test_tolist_specialcase(self):
+        # Test mvoid.tolist: make sure we return a standard Python object
+        a = array([(0, 1), (2, 3)], dtype=[('a', int), ('b', int)])
+        # w/o mask: each entry is a np.void whose elements are standard Python
+        for entry in a:
+            for item in entry.tolist():
+                assert_(not isinstance(item, np.generic))
+        # w/ mask: each entry is a ma.void whose elements should be
+        # standard Python
+        a.mask[0] = (0, 1)
+        for entry in a:
+            for item in entry.tolist():
+                assert_(not isinstance(item, np.generic))
+
+    def test_toflex(self):
+        # Test the conversion to records
+        data = arange(10)
+        record = data.toflex()
+        assert_equal(record['_data'], data._data)
+        assert_equal(record['_mask'], data._mask)
+
+        data[[0, 1, 2, -1]] = masked
+        record = data.toflex()
+        assert_equal(record['_data'], data._data)
+        assert_equal(record['_mask'], data._mask)
+
+        ndtype = [('i', int), ('s', '|S3'), ('f', float)]
+        data = array([(i, s, f) for (i, s, f) in zip(np.arange(10),
+                                                     'ABCDEFGHIJKLM',
+                                                     np.random.rand(10))],
+                     dtype=ndtype)
+        data[[0, 1, 2, -1]] = masked
+        record = data.toflex()
+        assert_equal(record['_data'], data._data)
+        assert_equal(record['_mask'], data._mask)
+
+        ndtype = np.dtype("int, (2,3)float, float")
+        data = array([(i, f, ff) for (i, f, ff) in zip(np.arange(10),
+                                                       np.random.rand(10),
+                                                       np.random.rand(10))],
+                     dtype=ndtype)
+        data[[0, 1, 2, -1]] = masked
+        record = data.toflex()
+        assert_equal_records(record['_data'], data._data)
+        assert_equal_records(record['_mask'], data._mask)
+
+    def test_fromflex(self):
+        # Test the reconstruction of a masked_array from a record
+        a = array([1, 2, 3])
+        test = fromflex(a.toflex())
+        assert_equal(test, a)
+        assert_equal(test.mask, a.mask)
+
+        a = array([1, 2, 3], mask=[0, 0, 1])
+        test = fromflex(a.toflex())
+        assert_equal(test, a)
+        assert_equal(test.mask, a.mask)
+
+        a = array([(1, 1.), (2, 2.), (3, 3.)], mask=[(1, 0), (0, 0), (0, 1)],
+                  dtype=[('A', int), ('B', float)])
+        test = fromflex(a.toflex())
+        assert_equal(test, a)
+        assert_equal(test.data, a.data)
+
+    def test_arraymethod(self):
+        # Test a _arraymethod w/ n argument
+        marray = masked_array([[1, 2, 3, 4, 5]], mask=[0, 0, 1, 0, 0])
+        control = masked_array([[1], [2], [3], [4], [5]],
+                               mask=[0, 0, 1, 0, 0])
+        assert_equal(marray.T, control)
+        assert_equal(marray.transpose(), control)
+
+        assert_equal(MaskedArray.cumsum(marray.T, 0), control.cumsum(0))
+
+    def test_arraymethod_0d(self):
+        # gh-9430
+        x = np.ma.array(42, mask=True)
+        assert_equal(x.T.mask, x.mask)
+        assert_equal(x.T.data, x.data)
+
+    def test_transpose_view(self):
+        x = np.ma.array([[1, 2, 3], [4, 5, 6]])
+        x[0,1] = np.ma.masked
+        xt = x.T
+
+        xt[1,0] = 10
+        xt[0,1] = np.ma.masked
+
+        assert_equal(x.data, xt.T.data)
+        assert_equal(x.mask, xt.T.mask)
+
+    def test_diagonal_view(self):
+        x = np.ma.zeros((3,3))
+        x[0,0] = 10
+        x[1,1] = np.ma.masked
+        x[2,2] = 20
+        xd = x.diagonal()
+        x[1,1] = 15
+        assert_equal(xd.mask, x.diagonal().mask)
+        assert_equal(xd.data, x.diagonal().data)
+
+
+class TestMaskedArrayMathMethods:
+
+    def setup_method(self):
+        # Base data definition.
+        x = np.array([8.375, 7.545, 8.828, 8.5, 1.757, 5.928,
+                      8.43, 7.78, 9.865, 5.878, 8.979, 4.732,
+                      3.012, 6.022, 5.095, 3.116, 5.238, 3.957,
+                      6.04, 9.63, 7.712, 3.382, 4.489, 6.479,
+                      7.189, 9.645, 5.395, 4.961, 9.894, 2.893,
+                      7.357, 9.828, 6.272, 3.758, 6.693, 0.993])
+        X = x.reshape(6, 6)
+        XX = x.reshape(3, 2, 2, 3)
+
+        m = np.array([0, 1, 0, 1, 0, 0,
+                     1, 0, 1, 1, 0, 1,
+                     0, 0, 0, 1, 0, 1,
+                     0, 0, 0, 1, 1, 1,
+                     1, 0, 0, 1, 0, 0,
+                     0, 0, 1, 0, 1, 0])
+        mx = array(data=x, mask=m)
+        mX = array(data=X, mask=m.reshape(X.shape))
+        mXX = array(data=XX, mask=m.reshape(XX.shape))
+
+        m2 = np.array([1, 1, 0, 1, 0, 0,
+                      1, 1, 1, 1, 0, 1,
+                      0, 0, 1, 1, 0, 1,
+                      0, 0, 0, 1, 1, 1,
+                      1, 0, 0, 1, 1, 0,
+                      0, 0, 1, 0, 1, 1])
+        m2x = array(data=x, mask=m2)
+        m2X = array(data=X, mask=m2.reshape(X.shape))
+        m2XX = array(data=XX, mask=m2.reshape(XX.shape))
+        self.d = (x, X, XX, m, mx, mX, mXX, m2x, m2X, m2XX)
+
+    def test_cumsumprod(self):
+        # Tests cumsum & cumprod on MaskedArrays.
+        (x, X, XX, m, mx, mX, mXX, m2x, m2X, m2XX) = self.d
+        mXcp = mX.cumsum(0)
+        assert_equal(mXcp._data, mX.filled(0).cumsum(0))
+        mXcp = mX.cumsum(1)
+        assert_equal(mXcp._data, mX.filled(0).cumsum(1))
+
+        mXcp = mX.cumprod(0)
+        assert_equal(mXcp._data, mX.filled(1).cumprod(0))
+        mXcp = mX.cumprod(1)
+        assert_equal(mXcp._data, mX.filled(1).cumprod(1))
+
+    def test_cumsumprod_with_output(self):
+        # Tests cumsum/cumprod w/ output
+        xm = array(np.random.uniform(0, 10, 12)).reshape(3, 4)
+        xm[:, 0] = xm[0] = xm[-1, -1] = masked
+
+        for funcname in ('cumsum', 'cumprod'):
+            npfunc = getattr(np, funcname)
+            xmmeth = getattr(xm, funcname)
+
+            # A ndarray as explicit input
+            output = np.empty((3, 4), dtype=float)
+            output.fill(-9999)
+            result = npfunc(xm, axis=0, out=output)
+            # ... the result should be the given output
+            assert_(result is output)
+            assert_equal(result, xmmeth(axis=0, out=output))
+
+            output = empty((3, 4), dtype=int)
+            result = xmmeth(axis=0, out=output)
+            assert_(result is output)
+
+    def test_ptp(self):
+        # Tests ptp on MaskedArrays.
+        (x, X, XX, m, mx, mX, mXX, m2x, m2X, m2XX) = self.d
+        (n, m) = X.shape
+        assert_equal(mx.ptp(), np.ptp(mx.compressed()))
+        rows = np.zeros(n, float)
+        cols = np.zeros(m, float)
+        for k in range(m):
+            cols[k] = np.ptp(mX[:, k].compressed())
+        for k in range(n):
+            rows[k] = np.ptp(mX[k].compressed())
+        assert_equal(mX.ptp(0), cols)
+        assert_equal(mX.ptp(1), rows)
+
+    def test_add_object(self):
+        x = masked_array(['a', 'b'], mask=[1, 0], dtype=object)
+        y = x + 'x'
+        assert_equal(y[1], 'bx')
+        assert_(y.mask[0])
+
+    def test_sum_object(self):
+        # Test sum on object dtype
+        a = masked_array([1, 2, 3], mask=[1, 0, 0], dtype=object)
+        assert_equal(a.sum(), 5)
+        a = masked_array([[1, 2, 3], [4, 5, 6]], dtype=object)
+        assert_equal(a.sum(axis=0), [5, 7, 9])
+
+    def test_prod_object(self):
+        # Test prod on object dtype
+        a = masked_array([1, 2, 3], mask=[1, 0, 0], dtype=object)
+        assert_equal(a.prod(), 2 * 3)
+        a = masked_array([[1, 2, 3], [4, 5, 6]], dtype=object)
+        assert_equal(a.prod(axis=0), [4, 10, 18])
+
+    def test_meananom_object(self):
+        # Test mean/anom on object dtype
+        a = masked_array([1, 2, 3], dtype=object)
+        assert_equal(a.mean(), 2)
+        assert_equal(a.anom(), [-1, 0, 1])
+
+    def test_anom_shape(self):
+        a = masked_array([1, 2, 3])
+        assert_equal(a.anom().shape, a.shape)
+        a.mask = True
+        assert_equal(a.anom().shape, a.shape)
+        assert_(np.ma.is_masked(a.anom()))
+
+    def test_anom(self):
+        a = masked_array(np.arange(1, 7).reshape(2, 3))
+        assert_almost_equal(a.anom(),
+                            [[-2.5, -1.5, -0.5], [0.5, 1.5, 2.5]])
+        assert_almost_equal(a.anom(axis=0),
+                            [[-1.5, -1.5, -1.5], [1.5, 1.5, 1.5]])
+        assert_almost_equal(a.anom(axis=1),
+                            [[-1., 0., 1.], [-1., 0., 1.]])
+        a.mask = [[0, 0, 1], [0, 1, 0]]
+        mval = -99
+        assert_almost_equal(a.anom().filled(mval),
+                            [[-2.25, -1.25, mval], [0.75, mval, 2.75]])
+        assert_almost_equal(a.anom(axis=0).filled(mval),
+                            [[-1.5, 0.0, mval], [1.5, mval, 0.0]])
+        assert_almost_equal(a.anom(axis=1).filled(mval),
+                            [[-0.5, 0.5, mval], [-1.0, mval, 1.0]])
+
+    def test_trace(self):
+        # Tests trace on MaskedArrays.
+        (x, X, XX, m, mx, mX, mXX, m2x, m2X, m2XX) = self.d
+        mXdiag = mX.diagonal()
+        assert_equal(mX.trace(), mX.diagonal().compressed().sum())
+        assert_almost_equal(mX.trace(),
+                            X.trace() - sum(mXdiag.mask * X.diagonal(),
+                                            axis=0))
+        assert_equal(np.trace(mX), mX.trace())
+
+        # gh-5560
+        arr = np.arange(2*4*4).reshape(2,4,4)
+        m_arr = np.ma.masked_array(arr, False)
+        assert_equal(arr.trace(axis1=1, axis2=2), m_arr.trace(axis1=1, axis2=2))
+
+    def test_dot(self):
+        # Tests dot on MaskedArrays.
+        (x, X, XX, m, mx, mX, mXX, m2x, m2X, m2XX) = self.d
+        fx = mx.filled(0)
+        r = mx.dot(mx)
+        assert_almost_equal(r.filled(0), fx.dot(fx))
+        assert_(r.mask is nomask)
+
+        fX = mX.filled(0)
+        r = mX.dot(mX)
+        assert_almost_equal(r.filled(0), fX.dot(fX))
+        assert_(r.mask[1,3])
+        r1 = empty_like(r)
+        mX.dot(mX, out=r1)
+        assert_almost_equal(r, r1)
+
+        mYY = mXX.swapaxes(-1, -2)
+        fXX, fYY = mXX.filled(0), mYY.filled(0)
+        r = mXX.dot(mYY)
+        assert_almost_equal(r.filled(0), fXX.dot(fYY))
+        r1 = empty_like(r)
+        mXX.dot(mYY, out=r1)
+        assert_almost_equal(r, r1)
+
+    def test_dot_shape_mismatch(self):
+        # regression test
+        x = masked_array([[1,2],[3,4]], mask=[[0,1],[0,0]])
+        y = masked_array([[1,2],[3,4]], mask=[[0,1],[0,0]])
+        z = masked_array([[0,1],[3,3]])
+        x.dot(y, out=z)
+        assert_almost_equal(z.filled(0), [[1, 0], [15, 16]])
+        assert_almost_equal(z.mask, [[0, 1], [0, 0]])
+
+    def test_varmean_nomask(self):
+        # gh-5769
+        foo = array([1,2,3,4], dtype='f8')
+        bar = array([1,2,3,4], dtype='f8')
+        assert_equal(type(foo.mean()), np.float64)
+        assert_equal(type(foo.var()), np.float64)
+        assert((foo.mean() == bar.mean()) is np.bool(True))
+
+        # check array type is preserved and out works
+        foo = array(np.arange(16).reshape((4,4)), dtype='f8')
+        bar = empty(4, dtype='f4')
+        assert_equal(type(foo.mean(axis=1)), MaskedArray)
+        assert_equal(type(foo.var(axis=1)), MaskedArray)
+        assert_(foo.mean(axis=1, out=bar) is bar)
+        assert_(foo.var(axis=1, out=bar) is bar)
+
+    def test_varstd(self):
+        # Tests var & std on MaskedArrays.
+        (x, X, XX, m, mx, mX, mXX, m2x, m2X, m2XX) = self.d
+        assert_almost_equal(mX.var(axis=None), mX.compressed().var())
+        assert_almost_equal(mX.std(axis=None), mX.compressed().std())
+        assert_almost_equal(mX.std(axis=None, ddof=1),
+                            mX.compressed().std(ddof=1))
+        assert_almost_equal(mX.var(axis=None, ddof=1),
+                            mX.compressed().var(ddof=1))
+        assert_equal(mXX.var(axis=3).shape, XX.var(axis=3).shape)
+        assert_equal(mX.var().shape, X.var().shape)
+        (mXvar0, mXvar1) = (mX.var(axis=0), mX.var(axis=1))
+        assert_almost_equal(mX.var(axis=None, ddof=2),
+                            mX.compressed().var(ddof=2))
+        assert_almost_equal(mX.std(axis=None, ddof=2),
+                            mX.compressed().std(ddof=2))
+        for k in range(6):
+            assert_almost_equal(mXvar1[k], mX[k].compressed().var())
+            assert_almost_equal(mXvar0[k], mX[:, k].compressed().var())
+            assert_almost_equal(np.sqrt(mXvar0[k]),
+                                mX[:, k].compressed().std())
+
+    @suppress_copy_mask_on_assignment
+    def test_varstd_specialcases(self):
+        # Test a special case for var
+        nout = np.array(-1, dtype=float)
+        mout = array(-1, dtype=float)
+
+        x = array(arange(10), mask=True)
+        for methodname in ('var', 'std'):
+            method = getattr(x, methodname)
+            assert_(method() is masked)
+            assert_(method(0) is masked)
+            assert_(method(-1) is masked)
+            # Using a masked array as explicit output
+            method(out=mout)
+            assert_(mout is not masked)
+            assert_equal(mout.mask, True)
+            # Using a ndarray as explicit output
+            method(out=nout)
+            assert_(np.isnan(nout))
+
+        x = array(arange(10), mask=True)
+        x[-1] = 9
+        for methodname in ('var', 'std'):
+            method = getattr(x, methodname)
+            assert_(method(ddof=1) is masked)
+            assert_(method(0, ddof=1) is masked)
+            assert_(method(-1, ddof=1) is masked)
+            # Using a masked array as explicit output
+            method(out=mout, ddof=1)
+            assert_(mout is not masked)
+            assert_equal(mout.mask, True)
+            # Using a ndarray as explicit output
+            method(out=nout, ddof=1)
+            assert_(np.isnan(nout))
+
+    def test_varstd_ddof(self):
+        a = array([[1, 1, 0], [1, 1, 0]], mask=[[0, 0, 1], [0, 0, 1]])
+        test = a.std(axis=0, ddof=0)
+        assert_equal(test.filled(0), [0, 0, 0])
+        assert_equal(test.mask, [0, 0, 1])
+        test = a.std(axis=0, ddof=1)
+        assert_equal(test.filled(0), [0, 0, 0])
+        assert_equal(test.mask, [0, 0, 1])
+        test = a.std(axis=0, ddof=2)
+        assert_equal(test.filled(0), [0, 0, 0])
+        assert_equal(test.mask, [1, 1, 1])
+
+    def test_diag(self):
+        # Test diag
+        x = arange(9).reshape((3, 3))
+        x[1, 1] = masked
+        out = np.diag(x)
+        assert_equal(out, [0, 4, 8])
+        out = diag(x)
+        assert_equal(out, [0, 4, 8])
+        assert_equal(out.mask, [0, 1, 0])
+        out = diag(out)
+        control = array([[0, 0, 0], [0, 4, 0], [0, 0, 8]],
+                        mask=[[0, 0, 0], [0, 1, 0], [0, 0, 0]])
+        assert_equal(out, control)
+
+    def test_axis_methods_nomask(self):
+        # Test the combination nomask & methods w/ axis
+        a = array([[1, 2, 3], [4, 5, 6]])
+
+        assert_equal(a.sum(0), [5, 7, 9])
+        assert_equal(a.sum(-1), [6, 15])
+        assert_equal(a.sum(1), [6, 15])
+
+        assert_equal(a.prod(0), [4, 10, 18])
+        assert_equal(a.prod(-1), [6, 120])
+        assert_equal(a.prod(1), [6, 120])
+
+        assert_equal(a.min(0), [1, 2, 3])
+        assert_equal(a.min(-1), [1, 4])
+        assert_equal(a.min(1), [1, 4])
+
+        assert_equal(a.max(0), [4, 5, 6])
+        assert_equal(a.max(-1), [3, 6])
+        assert_equal(a.max(1), [3, 6])
+
+    @requires_memory(free_bytes=2 * 10000 * 1000 * 2)
+    def test_mean_overflow(self):
+        # Test overflow in masked arrays
+        # gh-20272
+        a = masked_array(np.full((10000, 10000), 65535, dtype=np.uint16),
+                         mask=np.zeros((10000, 10000)))
+        assert_equal(a.mean(), 65535.0)
+
+    def test_diff_with_prepend(self):
+        # GH 22465
+        x = np.array([1, 2, 2, 3, 4, 2, 1, 1])
+
+        a = np.ma.masked_equal(x[3:], value=2)
+        a_prep = np.ma.masked_equal(x[:3], value=2)
+        diff1 = np.ma.diff(a, prepend=a_prep, axis=0)
+
+        b = np.ma.masked_equal(x, value=2)
+        diff2 = np.ma.diff(b, axis=0)
+
+        assert_(np.ma.allequal(diff1, diff2))
+
+    def test_diff_with_append(self):
+        # GH 22465
+        x = np.array([1, 2, 2, 3, 4, 2, 1, 1])
+
+        a = np.ma.masked_equal(x[:3], value=2)
+        a_app = np.ma.masked_equal(x[3:], value=2)
+        diff1 = np.ma.diff(a, append=a_app, axis=0)
+
+        b = np.ma.masked_equal(x, value=2)
+        diff2 = np.ma.diff(b, axis=0)
+
+        assert_(np.ma.allequal(diff1, diff2))
+
+    def test_diff_with_dim_0(self):
+        with pytest.raises(
+            ValueError,
+            match="diff requires input that is at least one dimensional"
+            ):
+            np.ma.diff(np.array(1))
+
+    def test_diff_with_n_0(self):
+        a = np.ma.masked_equal([1, 2, 2, 3, 4, 2, 1, 1], value=2)
+        diff = np.ma.diff(a, n=0, axis=0)
+
+        assert_(np.ma.allequal(a, diff))
+
+
+class TestMaskedArrayMathMethodsComplex:
+    # Test class for miscellaneous MaskedArrays methods.
+    def setup_method(self):
+        # Base data definition.
+        x = np.array([8.375j, 7.545j, 8.828j, 8.5j, 1.757j, 5.928,
+                      8.43, 7.78, 9.865, 5.878, 8.979, 4.732,
+                      3.012, 6.022, 5.095, 3.116, 5.238, 3.957,
+                      6.04, 9.63, 7.712, 3.382, 4.489, 6.479j,
+                      7.189j, 9.645, 5.395, 4.961, 9.894, 2.893,
+                      7.357, 9.828, 6.272, 3.758, 6.693, 0.993j])
+        X = x.reshape(6, 6)
+        XX = x.reshape(3, 2, 2, 3)
+
+        m = np.array([0, 1, 0, 1, 0, 0,
+                     1, 0, 1, 1, 0, 1,
+                     0, 0, 0, 1, 0, 1,
+                     0, 0, 0, 1, 1, 1,
+                     1, 0, 0, 1, 0, 0,
+                     0, 0, 1, 0, 1, 0])
+        mx = array(data=x, mask=m)
+        mX = array(data=X, mask=m.reshape(X.shape))
+        mXX = array(data=XX, mask=m.reshape(XX.shape))
+
+        m2 = np.array([1, 1, 0, 1, 0, 0,
+                      1, 1, 1, 1, 0, 1,
+                      0, 0, 1, 1, 0, 1,
+                      0, 0, 0, 1, 1, 1,
+                      1, 0, 0, 1, 1, 0,
+                      0, 0, 1, 0, 1, 1])
+        m2x = array(data=x, mask=m2)
+        m2X = array(data=X, mask=m2.reshape(X.shape))
+        m2XX = array(data=XX, mask=m2.reshape(XX.shape))
+        self.d = (x, X, XX, m, mx, mX, mXX, m2x, m2X, m2XX)
+
+    def test_varstd(self):
+        # Tests var & std on MaskedArrays.
+        (x, X, XX, m, mx, mX, mXX, m2x, m2X, m2XX) = self.d
+        assert_almost_equal(mX.var(axis=None), mX.compressed().var())
+        assert_almost_equal(mX.std(axis=None), mX.compressed().std())
+        assert_equal(mXX.var(axis=3).shape, XX.var(axis=3).shape)
+        assert_equal(mX.var().shape, X.var().shape)
+        (mXvar0, mXvar1) = (mX.var(axis=0), mX.var(axis=1))
+        assert_almost_equal(mX.var(axis=None, ddof=2),
+                            mX.compressed().var(ddof=2))
+        assert_almost_equal(mX.std(axis=None, ddof=2),
+                            mX.compressed().std(ddof=2))
+        for k in range(6):
+            assert_almost_equal(mXvar1[k], mX[k].compressed().var())
+            assert_almost_equal(mXvar0[k], mX[:, k].compressed().var())
+            assert_almost_equal(np.sqrt(mXvar0[k]),
+                                mX[:, k].compressed().std())
+
+
+class TestMaskedArrayFunctions:
+    # Test class for miscellaneous functions.
+
+    def setup_method(self):
+        x = np.array([1., 1., 1., -2., pi/2.0, 4., 5., -10., 10., 1., 2., 3.])
+        y = np.array([5., 0., 3., 2., -1., -4., 0., -10., 10., 1., 0., 3.])
+        m1 = [1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0]
+        m2 = [0, 0, 1, 0, 0, 1, 1, 0, 0, 0, 0, 1]
+        xm = masked_array(x, mask=m1)
+        ym = masked_array(y, mask=m2)
+        xm.set_fill_value(1e+20)
+        self.info = (xm, ym)
+
+    def test_masked_where_bool(self):
+        x = [1, 2]
+        y = masked_where(False, x)
+        assert_equal(y, [1, 2])
+        assert_equal(y[1], 2)
+
+    def test_masked_equal_wlist(self):
+        x = [1, 2, 3]
+        mx = masked_equal(x, 3)
+        assert_equal(mx, x)
+        assert_equal(mx._mask, [0, 0, 1])
+        mx = masked_not_equal(x, 3)
+        assert_equal(mx, x)
+        assert_equal(mx._mask, [1, 1, 0])
+
+    def test_masked_equal_fill_value(self):
+        x = [1, 2, 3]
+        mx = masked_equal(x, 3)
+        assert_equal(mx._mask, [0, 0, 1])
+        assert_equal(mx.fill_value, 3)
+
+    def test_masked_where_condition(self):
+        # Tests masking functions.
+        x = array([1., 2., 3., 4., 5.])
+        x[2] = masked
+        assert_equal(masked_where(greater(x, 2), x), masked_greater(x, 2))
+        assert_equal(masked_where(greater_equal(x, 2), x),
+                     masked_greater_equal(x, 2))
+        assert_equal(masked_where(less(x, 2), x), masked_less(x, 2))
+        assert_equal(masked_where(less_equal(x, 2), x),
+                     masked_less_equal(x, 2))
+        assert_equal(masked_where(not_equal(x, 2), x), masked_not_equal(x, 2))
+        assert_equal(masked_where(equal(x, 2), x), masked_equal(x, 2))
+        assert_equal(masked_where(not_equal(x, 2), x), masked_not_equal(x, 2))
+        assert_equal(masked_where([1, 1, 0, 0, 0], [1, 2, 3, 4, 5]),
+                     [99, 99, 3, 4, 5])
+
+    def test_masked_where_oddities(self):
+        # Tests some generic features.
+        atest = ones((10, 10, 10), dtype=float)
+        btest = zeros(atest.shape, MaskType)
+        ctest = masked_where(btest, atest)
+        assert_equal(atest, ctest)
+
+    def test_masked_where_shape_constraint(self):
+        a = arange(10)
+        with assert_raises(IndexError):
+            masked_equal(1, a)
+        test = masked_equal(a, 1)
+        assert_equal(test.mask, [0, 1, 0, 0, 0, 0, 0, 0, 0, 0])
+
+    def test_masked_where_structured(self):
+        # test that masked_where on a structured array sets a structured
+        # mask (see issue #2972)
+        a = np.zeros(10, dtype=[("A", " 6, x)
+
+    def test_masked_otherfunctions(self):
+        assert_equal(masked_inside(list(range(5)), 1, 3),
+                     [0, 199, 199, 199, 4])
+        assert_equal(masked_outside(list(range(5)), 1, 3), [199, 1, 2, 3, 199])
+        assert_equal(masked_inside(array(list(range(5)),
+                                         mask=[1, 0, 0, 0, 0]), 1, 3).mask,
+                     [1, 1, 1, 1, 0])
+        assert_equal(masked_outside(array(list(range(5)),
+                                          mask=[0, 1, 0, 0, 0]), 1, 3).mask,
+                     [1, 1, 0, 0, 1])
+        assert_equal(masked_equal(array(list(range(5)),
+                                        mask=[1, 0, 0, 0, 0]), 2).mask,
+                     [1, 0, 1, 0, 0])
+        assert_equal(masked_not_equal(array([2, 2, 1, 2, 1],
+                                            mask=[1, 0, 0, 0, 0]), 2).mask,
+                     [1, 0, 1, 0, 1])
+
+    def test_round(self):
+        a = array([1.23456, 2.34567, 3.45678, 4.56789, 5.67890],
+                  mask=[0, 1, 0, 0, 0])
+        assert_equal(a.round(), [1., 2., 3., 5., 6.])
+        assert_equal(a.round(1), [1.2, 2.3, 3.5, 4.6, 5.7])
+        assert_equal(a.round(3), [1.235, 2.346, 3.457, 4.568, 5.679])
+        b = empty_like(a)
+        a.round(out=b)
+        assert_equal(b, [1., 2., 3., 5., 6.])
+
+        x = array([1., 2., 3., 4., 5.])
+        c = array([1, 1, 1, 0, 0])
+        x[2] = masked
+        z = where(c, x, -x)
+        assert_equal(z, [1., 2., 0., -4., -5])
+        c[0] = masked
+        z = where(c, x, -x)
+        assert_equal(z, [1., 2., 0., -4., -5])
+        assert_(z[0] is masked)
+        assert_(z[1] is not masked)
+        assert_(z[2] is masked)
+
+    def test_round_with_output(self):
+        # Testing round with an explicit output
+
+        xm = array(np.random.uniform(0, 10, 12)).reshape(3, 4)
+        xm[:, 0] = xm[0] = xm[-1, -1] = masked
+
+        # A ndarray as explicit input
+        output = np.empty((3, 4), dtype=float)
+        output.fill(-9999)
+        result = np.round(xm, decimals=2, out=output)
+        # ... the result should be the given output
+        assert_(result is output)
+        assert_equal(result, xm.round(decimals=2, out=output))
+
+        output = empty((3, 4), dtype=float)
+        result = xm.round(decimals=2, out=output)
+        assert_(result is output)
+
+    def test_round_with_scalar(self):
+        # Testing round with scalar/zero dimension input
+        # GH issue 2244
+        a = array(1.1, mask=[False])
+        assert_equal(a.round(), 1)
+
+        a = array(1.1, mask=[True])
+        assert_(a.round() is masked)
+
+        a = array(1.1, mask=[False])
+        output = np.empty(1, dtype=float)
+        output.fill(-9999)
+        a.round(out=output)
+        assert_equal(output, 1)
+
+        a = array(1.1, mask=[False])
+        output = array(-9999., mask=[True])
+        a.round(out=output)
+        assert_equal(output[()], 1)
+
+        a = array(1.1, mask=[True])
+        output = array(-9999., mask=[False])
+        a.round(out=output)
+        assert_(output[()] is masked)
+
+    def test_identity(self):
+        a = identity(5)
+        assert_(isinstance(a, MaskedArray))
+        assert_equal(a, np.identity(5))
+
+    def test_power(self):
+        x = -1.1
+        assert_almost_equal(power(x, 2.), 1.21)
+        assert_(power(x, masked) is masked)
+        x = array([-1.1, -1.1, 1.1, 1.1, 0.])
+        b = array([0.5, 2., 0.5, 2., -1.], mask=[0, 0, 0, 0, 1])
+        y = power(x, b)
+        assert_almost_equal(y, [0, 1.21, 1.04880884817, 1.21, 0.])
+        assert_equal(y._mask, [1, 0, 0, 0, 1])
+        b.mask = nomask
+        y = power(x, b)
+        assert_equal(y._mask, [1, 0, 0, 0, 1])
+        z = x ** b
+        assert_equal(z._mask, y._mask)
+        assert_almost_equal(z, y)
+        assert_almost_equal(z._data, y._data)
+        x **= b
+        assert_equal(x._mask, y._mask)
+        assert_almost_equal(x, y)
+        assert_almost_equal(x._data, y._data)
+
+    def test_power_with_broadcasting(self):
+        # Test power w/ broadcasting
+        a2 = np.array([[1., 2., 3.], [4., 5., 6.]])
+        a2m = array(a2, mask=[[1, 0, 0], [0, 0, 1]])
+        b1 = np.array([2, 4, 3])
+        b2 = np.array([b1, b1])
+        b2m = array(b2, mask=[[0, 1, 0], [0, 1, 0]])
+
+        ctrl = array([[1 ** 2, 2 ** 4, 3 ** 3], [4 ** 2, 5 ** 4, 6 ** 3]],
+                     mask=[[1, 1, 0], [0, 1, 1]])
+        # No broadcasting, base & exp w/ mask
+        test = a2m ** b2m
+        assert_equal(test, ctrl)
+        assert_equal(test.mask, ctrl.mask)
+        # No broadcasting, base w/ mask, exp w/o mask
+        test = a2m ** b2
+        assert_equal(test, ctrl)
+        assert_equal(test.mask, a2m.mask)
+        # No broadcasting, base w/o mask, exp w/ mask
+        test = a2 ** b2m
+        assert_equal(test, ctrl)
+        assert_equal(test.mask, b2m.mask)
+
+        ctrl = array([[2 ** 2, 4 ** 4, 3 ** 3], [2 ** 2, 4 ** 4, 3 ** 3]],
+                     mask=[[0, 1, 0], [0, 1, 0]])
+        test = b1 ** b2m
+        assert_equal(test, ctrl)
+        assert_equal(test.mask, ctrl.mask)
+        test = b2m ** b1
+        assert_equal(test, ctrl)
+        assert_equal(test.mask, ctrl.mask)
+
+    @pytest.mark.skipif(IS_WASM, reason="fp errors don't work in wasm")
+    def test_where(self):
+        # Test the where function
+        x = np.array([1., 1., 1., -2., pi/2.0, 4., 5., -10., 10., 1., 2., 3.])
+        y = np.array([5., 0., 3., 2., -1., -4., 0., -10., 10., 1., 0., 3.])
+        m1 = [1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0]
+        m2 = [0, 0, 1, 0, 0, 1, 1, 0, 0, 0, 0, 1]
+        xm = masked_array(x, mask=m1)
+        ym = masked_array(y, mask=m2)
+        xm.set_fill_value(1e+20)
+
+        d = where(xm > 2, xm, -9)
+        assert_equal(d, [-9., -9., -9., -9., -9., 4.,
+                         -9., -9., 10., -9., -9., 3.])
+        assert_equal(d._mask, xm._mask)
+        d = where(xm > 2, -9, ym)
+        assert_equal(d, [5., 0., 3., 2., -1., -9.,
+                         -9., -10., -9., 1., 0., -9.])
+        assert_equal(d._mask, [1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0])
+        d = where(xm > 2, xm, masked)
+        assert_equal(d, [-9., -9., -9., -9., -9., 4.,
+                         -9., -9., 10., -9., -9., 3.])
+        tmp = xm._mask.copy()
+        tmp[(xm <= 2).filled(True)] = True
+        assert_equal(d._mask, tmp)
+
+        with np.errstate(invalid="warn"):
+            # The fill value is 1e20, it cannot be converted to `int`:
+            with pytest.warns(RuntimeWarning, match="invalid value"):
+                ixm = xm.astype(int)
+        d = where(ixm > 2, ixm, masked)
+        assert_equal(d, [-9, -9, -9, -9, -9, 4, -9, -9, 10, -9, -9, 3])
+        assert_equal(d.dtype, ixm.dtype)
+
+    def test_where_object(self):
+        a = np.array(None)
+        b = masked_array(None)
+        r = b.copy()
+        assert_equal(np.ma.where(True, a, a), r)
+        assert_equal(np.ma.where(True, b, b), r)
+
+    def test_where_with_masked_choice(self):
+        x = arange(10)
+        x[3] = masked
+        c = x >= 8
+        # Set False to masked
+        z = where(c, x, masked)
+        assert_(z.dtype is x.dtype)
+        assert_(z[3] is masked)
+        assert_(z[4] is masked)
+        assert_(z[7] is masked)
+        assert_(z[8] is not masked)
+        assert_(z[9] is not masked)
+        assert_equal(x, z)
+        # Set True to masked
+        z = where(c, masked, x)
+        assert_(z.dtype is x.dtype)
+        assert_(z[3] is masked)
+        assert_(z[4] is not masked)
+        assert_(z[7] is not masked)
+        assert_(z[8] is masked)
+        assert_(z[9] is masked)
+
+    def test_where_with_masked_condition(self):
+        x = array([1., 2., 3., 4., 5.])
+        c = array([1, 1, 1, 0, 0])
+        x[2] = masked
+        z = where(c, x, -x)
+        assert_equal(z, [1., 2., 0., -4., -5])
+        c[0] = masked
+        z = where(c, x, -x)
+        assert_equal(z, [1., 2., 0., -4., -5])
+        assert_(z[0] is masked)
+        assert_(z[1] is not masked)
+        assert_(z[2] is masked)
+
+        x = arange(1, 6)
+        x[-1] = masked
+        y = arange(1, 6) * 10
+        y[2] = masked
+        c = array([1, 1, 1, 0, 0], mask=[1, 0, 0, 0, 0])
+        cm = c.filled(1)
+        z = where(c, x, y)
+        zm = where(cm, x, y)
+        assert_equal(z, zm)
+        assert_(getmask(zm) is nomask)
+        assert_equal(zm, [1, 2, 3, 40, 50])
+        z = where(c, masked, 1)
+        assert_equal(z, [99, 99, 99, 1, 1])
+        z = where(c, 1, masked)
+        assert_equal(z, [99, 1, 1, 99, 99])
+
+    def test_where_type(self):
+        # Test the type conservation with where
+        x = np.arange(4, dtype=np.int32)
+        y = np.arange(4, dtype=np.float32) * 2.2
+        test = where(x > 1.5, y, x).dtype
+        control = np.result_type(np.int32, np.float32)
+        assert_equal(test, control)
+
+    def test_where_broadcast(self):
+        # Issue 8599
+        x = np.arange(9).reshape(3, 3)
+        y = np.zeros(3)
+        core = np.where([1, 0, 1], x, y)
+        ma = where([1, 0, 1], x, y)
+
+        assert_equal(core, ma)
+        assert_equal(core.dtype, ma.dtype)
+
+    def test_where_structured(self):
+        # Issue 8600
+        dt = np.dtype([('a', int), ('b', int)])
+        x = np.array([(1, 2), (3, 4), (5, 6)], dtype=dt)
+        y = np.array((10, 20), dtype=dt)
+        core = np.where([0, 1, 1], x, y)
+        ma = np.where([0, 1, 1], x, y)
+
+        assert_equal(core, ma)
+        assert_equal(core.dtype, ma.dtype)
+
+    def test_where_structured_masked(self):
+        dt = np.dtype([('a', int), ('b', int)])
+        x = np.array([(1, 2), (3, 4), (5, 6)], dtype=dt)
+
+        ma = where([0, 1, 1], x, masked)
+        expected = masked_where([1, 0, 0], x)
+
+        assert_equal(ma.dtype, expected.dtype)
+        assert_equal(ma, expected)
+        assert_equal(ma.mask, expected.mask)
+
+    def test_masked_invalid_error(self):
+        a = np.arange(5, dtype=object)
+        a[3] = np.inf
+        a[2] = np.nan
+        with pytest.raises(TypeError,
+                           match="not supported for the input types"):
+            np.ma.masked_invalid(a)
+
+    def test_masked_invalid_pandas(self):
+        # getdata() used to be bad for pandas series due to its _data
+        # attribute.  This test is a regression test mainly and may be
+        # removed if getdata() is adjusted.
+        class Series:
+            _data = "nonsense"
+
+            def __array__(self, dtype=None, copy=None):
+                return np.array([5, np.nan, np.inf])
+
+        arr = np.ma.masked_invalid(Series())
+        assert_array_equal(arr._data, np.array(Series()))
+        assert_array_equal(arr._mask, [False, True, True])
+
+    @pytest.mark.parametrize("copy", [True, False])
+    def test_masked_invalid_full_mask(self, copy):
+        # Matplotlib relied on masked_invalid always returning a full mask
+        # (Also astropy projects, but were ok with it gh-22720 and gh-22842)
+        a = np.ma.array([1, 2, 3, 4])
+        assert a._mask is nomask
+        res = np.ma.masked_invalid(a, copy=copy)
+        assert res.mask is not nomask
+        # mask of a should not be mutated
+        assert a.mask is nomask
+        assert np.may_share_memory(a._data, res._data) != copy
+
+    def test_choose(self):
+        # Test choose
+        choices = [[0, 1, 2, 3], [10, 11, 12, 13],
+                   [20, 21, 22, 23], [30, 31, 32, 33]]
+        chosen = choose([2, 3, 1, 0], choices)
+        assert_equal(chosen, array([20, 31, 12, 3]))
+        chosen = choose([2, 4, 1, 0], choices, mode='clip')
+        assert_equal(chosen, array([20, 31, 12, 3]))
+        chosen = choose([2, 4, 1, 0], choices, mode='wrap')
+        assert_equal(chosen, array([20, 1, 12, 3]))
+        # Check with some masked indices
+        indices_ = array([2, 4, 1, 0], mask=[1, 0, 0, 1])
+        chosen = choose(indices_, choices, mode='wrap')
+        assert_equal(chosen, array([99, 1, 12, 99]))
+        assert_equal(chosen.mask, [1, 0, 0, 1])
+        # Check with some masked choices
+        choices = array(choices, mask=[[0, 0, 0, 1], [1, 1, 0, 1],
+                                       [1, 0, 0, 0], [0, 0, 0, 0]])
+        indices_ = [2, 3, 1, 0]
+        chosen = choose(indices_, choices, mode='wrap')
+        assert_equal(chosen, array([20, 31, 12, 3]))
+        assert_equal(chosen.mask, [1, 0, 0, 1])
+
+    def test_choose_with_out(self):
+        # Test choose with an explicit out keyword
+        choices = [[0, 1, 2, 3], [10, 11, 12, 13],
+                   [20, 21, 22, 23], [30, 31, 32, 33]]
+        store = empty(4, dtype=int)
+        chosen = choose([2, 3, 1, 0], choices, out=store)
+        assert_equal(store, array([20, 31, 12, 3]))
+        assert_(store is chosen)
+        # Check with some masked indices + out
+        store = empty(4, dtype=int)
+        indices_ = array([2, 3, 1, 0], mask=[1, 0, 0, 1])
+        chosen = choose(indices_, choices, mode='wrap', out=store)
+        assert_equal(store, array([99, 31, 12, 99]))
+        assert_equal(store.mask, [1, 0, 0, 1])
+        # Check with some masked choices + out ina ndarray !
+        choices = array(choices, mask=[[0, 0, 0, 1], [1, 1, 0, 1],
+                                       [1, 0, 0, 0], [0, 0, 0, 0]])
+        indices_ = [2, 3, 1, 0]
+        store = empty(4, dtype=int).view(ndarray)
+        chosen = choose(indices_, choices, mode='wrap', out=store)
+        assert_equal(store, array([999999, 31, 12, 999999]))
+
+    def test_reshape(self):
+        a = arange(10)
+        a[0] = masked
+        # Try the default
+        b = a.reshape((5, 2))
+        assert_equal(b.shape, (5, 2))
+        assert_(b.flags['C'])
+        # Try w/ arguments as list instead of tuple
+        b = a.reshape(5, 2)
+        assert_equal(b.shape, (5, 2))
+        assert_(b.flags['C'])
+        # Try w/ order
+        b = a.reshape((5, 2), order='F')
+        assert_equal(b.shape, (5, 2))
+        assert_(b.flags['F'])
+        # Try w/ order
+        b = a.reshape(5, 2, order='F')
+        assert_equal(b.shape, (5, 2))
+        assert_(b.flags['F'])
+
+        c = np.reshape(a, (2, 5))
+        assert_(isinstance(c, MaskedArray))
+        assert_equal(c.shape, (2, 5))
+        assert_(c[0, 0] is masked)
+        assert_(c.flags['C'])
+
+    def test_make_mask_descr(self):
+        # Flexible
+        ntype = [('a', float), ('b', float)]
+        test = make_mask_descr(ntype)
+        assert_equal(test, [('a', bool), ('b', bool)])
+        assert_(test is make_mask_descr(test))
+
+        # Standard w/ shape
+        ntype = (float, 2)
+        test = make_mask_descr(ntype)
+        assert_equal(test, (bool, 2))
+        assert_(test is make_mask_descr(test))
+
+        # Standard standard
+        ntype = float
+        test = make_mask_descr(ntype)
+        assert_equal(test, np.dtype(bool))
+        assert_(test is make_mask_descr(test))
+
+        # Nested
+        ntype = [('a', float), ('b', [('ba', float), ('bb', float)])]
+        test = make_mask_descr(ntype)
+        control = np.dtype([('a', 'b1'), ('b', [('ba', 'b1'), ('bb', 'b1')])])
+        assert_equal(test, control)
+        assert_(test is make_mask_descr(test))
+
+        # Named+ shape
+        ntype = [('a', (float, 2))]
+        test = make_mask_descr(ntype)
+        assert_equal(test, np.dtype([('a', (bool, 2))]))
+        assert_(test is make_mask_descr(test))
+
+        # 2 names
+        ntype = [(('A', 'a'), float)]
+        test = make_mask_descr(ntype)
+        assert_equal(test, np.dtype([(('A', 'a'), bool)]))
+        assert_(test is make_mask_descr(test))
+
+        # nested boolean types should preserve identity
+        base_type = np.dtype([('a', int, 3)])
+        base_mtype = make_mask_descr(base_type)
+        sub_type = np.dtype([('a', int), ('b', base_mtype)])
+        test = make_mask_descr(sub_type)
+        assert_equal(test, np.dtype([('a', bool), ('b', [('a', bool, 3)])]))
+        assert_(test.fields['b'][0] is base_mtype)
+
+    def test_make_mask(self):
+        # Test make_mask
+        # w/ a list as an input
+        mask = [0, 1]
+        test = make_mask(mask)
+        assert_equal(test.dtype, MaskType)
+        assert_equal(test, [0, 1])
+        # w/ a ndarray as an input
+        mask = np.array([0, 1], dtype=bool)
+        test = make_mask(mask)
+        assert_equal(test.dtype, MaskType)
+        assert_equal(test, [0, 1])
+        # w/ a flexible-type ndarray as an input - use default
+        mdtype = [('a', bool), ('b', bool)]
+        mask = np.array([(0, 0), (0, 1)], dtype=mdtype)
+        test = make_mask(mask)
+        assert_equal(test.dtype, MaskType)
+        assert_equal(test, [1, 1])
+        # w/ a flexible-type ndarray as an input - use input dtype
+        mdtype = [('a', bool), ('b', bool)]
+        mask = np.array([(0, 0), (0, 1)], dtype=mdtype)
+        test = make_mask(mask, dtype=mask.dtype)
+        assert_equal(test.dtype, mdtype)
+        assert_equal(test, mask)
+        # w/ a flexible-type ndarray as an input - use input dtype
+        mdtype = [('a', float), ('b', float)]
+        bdtype = [('a', bool), ('b', bool)]
+        mask = np.array([(0, 0), (0, 1)], dtype=mdtype)
+        test = make_mask(mask, dtype=mask.dtype)
+        assert_equal(test.dtype, bdtype)
+        assert_equal(test, np.array([(0, 0), (0, 1)], dtype=bdtype))
+        # Ensure this also works for void
+        mask = np.array((False, True), dtype='?,?')[()]
+        assert_(isinstance(mask, np.void))
+        test = make_mask(mask, dtype=mask.dtype)
+        assert_equal(test, mask)
+        assert_(test is not mask)
+        mask = np.array((0, 1), dtype='i4,i4')[()]
+        test2 = make_mask(mask, dtype=mask.dtype)
+        assert_equal(test2, test)
+        # test that nomask is returned when m is nomask.
+        bools = [True, False]
+        dtypes = [MaskType, float]
+        msgformat = 'copy=%s, shrink=%s, dtype=%s'
+        for cpy, shr, dt in itertools.product(bools, bools, dtypes):
+            res = make_mask(nomask, copy=cpy, shrink=shr, dtype=dt)
+            assert_(res is nomask, msgformat % (cpy, shr, dt))
+
+    def test_mask_or(self):
+        # Initialize
+        mtype = [('a', bool), ('b', bool)]
+        mask = np.array([(0, 0), (0, 1), (1, 0), (0, 0)], dtype=mtype)
+        # Test using nomask as input
+        test = mask_or(mask, nomask)
+        assert_equal(test, mask)
+        test = mask_or(nomask, mask)
+        assert_equal(test, mask)
+        # Using False as input
+        test = mask_or(mask, False)
+        assert_equal(test, mask)
+        # Using another array w / the same dtype
+        other = np.array([(0, 1), (0, 1), (0, 1), (0, 1)], dtype=mtype)
+        test = mask_or(mask, other)
+        control = np.array([(0, 1), (0, 1), (1, 1), (0, 1)], dtype=mtype)
+        assert_equal(test, control)
+        # Using another array w / a different dtype
+        othertype = [('A', bool), ('B', bool)]
+        other = np.array([(0, 1), (0, 1), (0, 1), (0, 1)], dtype=othertype)
+        try:
+            test = mask_or(mask, other)
+        except ValueError:
+            pass
+        # Using nested arrays
+        dtype = [('a', bool), ('b', [('ba', bool), ('bb', bool)])]
+        amask = np.array([(0, (1, 0)), (0, (1, 0))], dtype=dtype)
+        bmask = np.array([(1, (0, 1)), (0, (0, 0))], dtype=dtype)
+        cntrl = np.array([(1, (1, 1)), (0, (1, 0))], dtype=dtype)
+        assert_equal(mask_or(amask, bmask), cntrl)
+
+    def test_flatten_mask(self):
+        # Tests flatten mask
+        # Standard dtype
+        mask = np.array([0, 0, 1], dtype=bool)
+        assert_equal(flatten_mask(mask), mask)
+        # Flexible dtype
+        mask = np.array([(0, 0), (0, 1)], dtype=[('a', bool), ('b', bool)])
+        test = flatten_mask(mask)
+        control = np.array([0, 0, 0, 1], dtype=bool)
+        assert_equal(test, control)
+
+        mdtype = [('a', bool), ('b', [('ba', bool), ('bb', bool)])]
+        data = [(0, (0, 0)), (0, (0, 1))]
+        mask = np.array(data, dtype=mdtype)
+        test = flatten_mask(mask)
+        control = np.array([0, 0, 0, 0, 0, 1], dtype=bool)
+        assert_equal(test, control)
+
+    def test_on_ndarray(self):
+        # Test functions on ndarrays
+        a = np.array([1, 2, 3, 4])
+        m = array(a, mask=False)
+        test = anom(a)
+        assert_equal(test, m.anom())
+        test = reshape(a, (2, 2))
+        assert_equal(test, m.reshape(2, 2))
+
+    def test_compress(self):
+        # Test compress function on ndarray and masked array
+        # Address Github #2495.
+        arr = np.arange(8)
+        arr.shape = 4, 2
+        cond = np.array([True, False, True, True])
+        control = arr[[0, 2, 3]]
+        test = np.ma.compress(cond, arr, axis=0)
+        assert_equal(test, control)
+        marr = np.ma.array(arr)
+        test = np.ma.compress(cond, marr, axis=0)
+        assert_equal(test, control)
+
+    def test_compressed(self):
+        # Test ma.compressed function.
+        # Address gh-4026
+        a = np.ma.array([1, 2])
+        test = np.ma.compressed(a)
+        assert_(type(test) is np.ndarray)
+
+        # Test case when input data is ndarray subclass
+        class A(np.ndarray):
+            pass
+
+        a = np.ma.array(A(shape=0))
+        test = np.ma.compressed(a)
+        assert_(type(test) is A)
+
+        # Test that compress flattens
+        test = np.ma.compressed([[1],[2]])
+        assert_equal(test.ndim, 1)
+        test = np.ma.compressed([[[[[1]]]]])
+        assert_equal(test.ndim, 1)
+
+        # Test case when input is MaskedArray subclass
+        class M(MaskedArray):
+            pass
+
+        test = np.ma.compressed(M([[[]], [[]]]))
+        assert_equal(test.ndim, 1)
+
+        # with .compressed() overridden
+        class M(MaskedArray):
+            def compressed(self):
+                return 42
+
+        test = np.ma.compressed(M([[[]], [[]]]))
+        assert_equal(test, 42)
+
+    def test_convolve(self):
+        a = masked_equal(np.arange(5), 2)
+        b = np.array([1, 1])
+
+        result = masked_equal([0, 1, -1, -1, 7, 4], -1)
+        test = np.ma.convolve(a, b, mode='full')
+        assert_equal(test, result)
+
+        test = np.ma.convolve(a, b, mode='same')
+        assert_equal(test, result[:-1])
+
+        test = np.ma.convolve(a, b, mode='valid')
+        assert_equal(test, result[1:-1])
+
+        result = masked_equal([0, 1, 1, 3, 7, 4], -1)
+        test = np.ma.convolve(a, b, mode='full', propagate_mask=False)
+        assert_equal(test, result)
+
+        test = np.ma.convolve(a, b, mode='same', propagate_mask=False)
+        assert_equal(test, result[:-1])
+
+        test = np.ma.convolve(a, b, mode='valid', propagate_mask=False)
+        assert_equal(test, result[1:-1])
+
+        test = np.ma.convolve([1, 1], [1, 1, 1])
+        assert_equal(test, masked_equal([1, 2, 2, 1], -1))
+
+        a = [1, 1]
+        b = masked_equal([1, -1, -1, 1], -1)
+        test = np.ma.convolve(a, b, propagate_mask=False)
+        assert_equal(test, masked_equal([1, 1, -1, 1, 1], -1))
+        test = np.ma.convolve(a, b, propagate_mask=True)
+        assert_equal(test, masked_equal([-1, -1, -1, -1, -1], -1))
+
+
+class TestMaskedFields:
+
+    def setup_method(self):
+        ilist = [1, 2, 3, 4, 5]
+        flist = [1.1, 2.2, 3.3, 4.4, 5.5]
+        slist = ['one', 'two', 'three', 'four', 'five']
+        ddtype = [('a', int), ('b', float), ('c', '|S8')]
+        mdtype = [('a', bool), ('b', bool), ('c', bool)]
+        mask = [0, 1, 0, 0, 1]
+        base = array(list(zip(ilist, flist, slist)), mask=mask, dtype=ddtype)
+        self.data = dict(base=base, mask=mask, ddtype=ddtype, mdtype=mdtype)
+
+    def test_set_records_masks(self):
+        base = self.data['base']
+        mdtype = self.data['mdtype']
+        # Set w/ nomask or masked
+        base.mask = nomask
+        assert_equal_records(base._mask, np.zeros(base.shape, dtype=mdtype))
+        base.mask = masked
+        assert_equal_records(base._mask, np.ones(base.shape, dtype=mdtype))
+        # Set w/ simple boolean
+        base.mask = False
+        assert_equal_records(base._mask, np.zeros(base.shape, dtype=mdtype))
+        base.mask = True
+        assert_equal_records(base._mask, np.ones(base.shape, dtype=mdtype))
+        # Set w/ list
+        base.mask = [0, 0, 0, 1, 1]
+        assert_equal_records(base._mask,
+                             np.array([(x, x, x) for x in [0, 0, 0, 1, 1]],
+                                      dtype=mdtype))
+
+    def test_set_record_element(self):
+        # Check setting an element of a record)
+        base = self.data['base']
+        (base_a, base_b, base_c) = (base['a'], base['b'], base['c'])
+        base[0] = (pi, pi, 'pi')
+
+        assert_equal(base_a.dtype, int)
+        assert_equal(base_a._data, [3, 2, 3, 4, 5])
+
+        assert_equal(base_b.dtype, float)
+        assert_equal(base_b._data, [pi, 2.2, 3.3, 4.4, 5.5])
+
+        assert_equal(base_c.dtype, '|S8')
+        assert_equal(base_c._data,
+                     [b'pi', b'two', b'three', b'four', b'five'])
+
+    def test_set_record_slice(self):
+        base = self.data['base']
+        (base_a, base_b, base_c) = (base['a'], base['b'], base['c'])
+        base[:3] = (pi, pi, 'pi')
+
+        assert_equal(base_a.dtype, int)
+        assert_equal(base_a._data, [3, 3, 3, 4, 5])
+
+        assert_equal(base_b.dtype, float)
+        assert_equal(base_b._data, [pi, pi, pi, 4.4, 5.5])
+
+        assert_equal(base_c.dtype, '|S8')
+        assert_equal(base_c._data,
+                     [b'pi', b'pi', b'pi', b'four', b'five'])
+
+    def test_mask_element(self):
+        "Check record access"
+        base = self.data['base']
+        base[0] = masked
+
+        for n in ('a', 'b', 'c'):
+            assert_equal(base[n].mask, [1, 1, 0, 0, 1])
+            assert_equal(base[n]._data, base._data[n])
+
+    def test_getmaskarray(self):
+        # Test getmaskarray on flexible dtype
+        ndtype = [('a', int), ('b', float)]
+        test = empty(3, dtype=ndtype)
+        assert_equal(getmaskarray(test),
+                     np.array([(0, 0), (0, 0), (0, 0)],
+                              dtype=[('a', '|b1'), ('b', '|b1')]))
+        test[:] = masked
+        assert_equal(getmaskarray(test),
+                     np.array([(1, 1), (1, 1), (1, 1)],
+                              dtype=[('a', '|b1'), ('b', '|b1')]))
+
+    def test_view(self):
+        # Test view w/ flexible dtype
+        iterator = list(zip(np.arange(10), np.random.rand(10)))
+        data = np.array(iterator)
+        a = array(iterator, dtype=[('a', float), ('b', float)])
+        a.mask[0] = (1, 0)
+        controlmask = np.array([1] + 19 * [0], dtype=bool)
+        # Transform globally to simple dtype
+        test = a.view(float)
+        assert_equal(test, data.ravel())
+        assert_equal(test.mask, controlmask)
+        # Transform globally to dty
+        test = a.view((float, 2))
+        assert_equal(test, data)
+        assert_equal(test.mask, controlmask.reshape(-1, 2))
+
+    def test_getitem(self):
+        ndtype = [('a', float), ('b', float)]
+        a = array(list(zip(np.random.rand(10), np.arange(10))), dtype=ndtype)
+        a.mask = np.array(list(zip([0, 0, 0, 0, 0, 0, 0, 0, 1, 1],
+                                   [1, 0, 0, 0, 0, 0, 0, 0, 1, 0])),
+                          dtype=[('a', bool), ('b', bool)])
+
+        def _test_index(i):
+            assert_equal(type(a[i]), mvoid)
+            assert_equal_records(a[i]._data, a._data[i])
+            assert_equal_records(a[i]._mask, a._mask[i])
+
+            assert_equal(type(a[i, ...]), MaskedArray)
+            assert_equal_records(a[i,...]._data, a._data[i,...])
+            assert_equal_records(a[i,...]._mask, a._mask[i,...])
+
+        _test_index(1)   # No mask
+        _test_index(0)   # One element masked
+        _test_index(-2)  # All element masked
+
+    def test_setitem(self):
+        # Issue 4866: check that one can set individual items in [record][col]
+        # and [col][record] order
+        ndtype = np.dtype([('a', float), ('b', int)])
+        ma = np.ma.MaskedArray([(1.0, 1), (2.0, 2)], dtype=ndtype)
+        ma['a'][1] = 3.0
+        assert_equal(ma['a'], np.array([1.0, 3.0]))
+        ma[1]['a'] = 4.0
+        assert_equal(ma['a'], np.array([1.0, 4.0]))
+        # Issue 2403
+        mdtype = np.dtype([('a', bool), ('b', bool)])
+        # soft mask
+        control = np.array([(False, True), (True, True)], dtype=mdtype)
+        a = np.ma.masked_all((2,), dtype=ndtype)
+        a['a'][0] = 2
+        assert_equal(a.mask, control)
+        a = np.ma.masked_all((2,), dtype=ndtype)
+        a[0]['a'] = 2
+        assert_equal(a.mask, control)
+        # hard mask
+        control = np.array([(True, True), (True, True)], dtype=mdtype)
+        a = np.ma.masked_all((2,), dtype=ndtype)
+        a.harden_mask()
+        a['a'][0] = 2
+        assert_equal(a.mask, control)
+        a = np.ma.masked_all((2,), dtype=ndtype)
+        a.harden_mask()
+        a[0]['a'] = 2
+        assert_equal(a.mask, control)
+
+    def test_setitem_scalar(self):
+        # 8510
+        mask_0d = np.ma.masked_array(1, mask=True)
+        arr = np.ma.arange(3)
+        arr[0] = mask_0d
+        assert_array_equal(arr.mask, [True, False, False])
+
+    def test_element_len(self):
+        # check that len() works for mvoid (Github issue #576)
+        for rec in self.data['base']:
+            assert_equal(len(rec), len(self.data['ddtype']))
+
+
+class TestMaskedObjectArray:
+
+    def test_getitem(self):
+        arr = np.ma.array([None, None])
+        for dt in [float, object]:
+            a0 = np.eye(2).astype(dt)
+            a1 = np.eye(3).astype(dt)
+            arr[0] = a0
+            arr[1] = a1
+
+            assert_(arr[0] is a0)
+            assert_(arr[1] is a1)
+            assert_(isinstance(arr[0,...], MaskedArray))
+            assert_(isinstance(arr[1,...], MaskedArray))
+            assert_(arr[0,...][()] is a0)
+            assert_(arr[1,...][()] is a1)
+
+            arr[0] = np.ma.masked
+
+            assert_(arr[1] is a1)
+            assert_(isinstance(arr[0,...], MaskedArray))
+            assert_(isinstance(arr[1,...], MaskedArray))
+            assert_equal(arr[0,...].mask, True)
+            assert_(arr[1,...][()] is a1)
+
+            # gh-5962 - object arrays of arrays do something special
+            assert_equal(arr[0].data, a0)
+            assert_equal(arr[0].mask, True)
+            assert_equal(arr[0,...][()].data, a0)
+            assert_equal(arr[0,...][()].mask, True)
+
+    def test_nested_ma(self):
+
+        arr = np.ma.array([None, None])
+        # set the first object to be an unmasked masked constant. A little fiddly
+        arr[0,...] = np.array([np.ma.masked], object)[0,...]
+
+        # check the above line did what we were aiming for
+        assert_(arr.data[0] is np.ma.masked)
+
+        # test that getitem returned the value by identity
+        assert_(arr[0] is np.ma.masked)
+
+        # now mask the masked value!
+        arr[0] = np.ma.masked
+        assert_(arr[0] is np.ma.masked)
+
+
+class TestMaskedView:
+
+    def setup_method(self):
+        iterator = list(zip(np.arange(10), np.random.rand(10)))
+        data = np.array(iterator)
+        a = array(iterator, dtype=[('a', float), ('b', float)])
+        a.mask[0] = (1, 0)
+        controlmask = np.array([1] + 19 * [0], dtype=bool)
+        self.data = (data, a, controlmask)
+
+    def test_view_to_nothing(self):
+        (data, a, controlmask) = self.data
+        test = a.view()
+        assert_(isinstance(test, MaskedArray))
+        assert_equal(test._data, a._data)
+        assert_equal(test._mask, a._mask)
+
+    def test_view_to_type(self):
+        (data, a, controlmask) = self.data
+        test = a.view(np.ndarray)
+        assert_(not isinstance(test, MaskedArray))
+        assert_equal(test, a._data)
+        assert_equal_records(test, data.view(a.dtype).squeeze())
+
+    def test_view_to_simple_dtype(self):
+        (data, a, controlmask) = self.data
+        # View globally
+        test = a.view(float)
+        assert_(isinstance(test, MaskedArray))
+        assert_equal(test, data.ravel())
+        assert_equal(test.mask, controlmask)
+
+    def test_view_to_flexible_dtype(self):
+        (data, a, controlmask) = self.data
+
+        test = a.view([('A', float), ('B', float)])
+        assert_equal(test.mask.dtype.names, ('A', 'B'))
+        assert_equal(test['A'], a['a'])
+        assert_equal(test['B'], a['b'])
+
+        test = a[0].view([('A', float), ('B', float)])
+        assert_(isinstance(test, MaskedArray))
+        assert_equal(test.mask.dtype.names, ('A', 'B'))
+        assert_equal(test['A'], a['a'][0])
+        assert_equal(test['B'], a['b'][0])
+
+        test = a[-1].view([('A', float), ('B', float)])
+        assert_(isinstance(test, MaskedArray))
+        assert_equal(test.dtype.names, ('A', 'B'))
+        assert_equal(test['A'], a['a'][-1])
+        assert_equal(test['B'], a['b'][-1])
+
+    def test_view_to_subdtype(self):
+        (data, a, controlmask) = self.data
+        # View globally
+        test = a.view((float, 2))
+        assert_(isinstance(test, MaskedArray))
+        assert_equal(test, data)
+        assert_equal(test.mask, controlmask.reshape(-1, 2))
+        # View on 1 masked element
+        test = a[0].view((float, 2))
+        assert_(isinstance(test, MaskedArray))
+        assert_equal(test, data[0])
+        assert_equal(test.mask, (1, 0))
+        # View on 1 unmasked element
+        test = a[-1].view((float, 2))
+        assert_(isinstance(test, MaskedArray))
+        assert_equal(test, data[-1])
+
+    def test_view_to_dtype_and_type(self):
+        (data, a, controlmask) = self.data
+
+        test = a.view((float, 2), np.recarray)
+        assert_equal(test, data)
+        assert_(isinstance(test, np.recarray))
+        assert_(not isinstance(test, MaskedArray))
+
+
+class TestOptionalArgs:
+    def test_ndarrayfuncs(self):
+        # test axis arg behaves the same as ndarray (including multiple axes)
+
+        d = np.arange(24.0).reshape((2,3,4))
+        m = np.zeros(24, dtype=bool).reshape((2,3,4))
+        # mask out last element of last dimension
+        m[:,:,-1] = True
+        a = np.ma.array(d, mask=m)
+
+        def testaxis(f, a, d):
+            numpy_f = numpy.__getattribute__(f)
+            ma_f = np.ma.__getattribute__(f)
+
+            # test axis arg
+            assert_equal(ma_f(a, axis=1)[...,:-1], numpy_f(d[...,:-1], axis=1))
+            assert_equal(ma_f(a, axis=(0,1))[...,:-1],
+                         numpy_f(d[...,:-1], axis=(0,1)))
+
+        def testkeepdims(f, a, d):
+            numpy_f = numpy.__getattribute__(f)
+            ma_f = np.ma.__getattribute__(f)
+
+            # test keepdims arg
+            assert_equal(ma_f(a, keepdims=True).shape,
+                         numpy_f(d, keepdims=True).shape)
+            assert_equal(ma_f(a, keepdims=False).shape,
+                         numpy_f(d, keepdims=False).shape)
+
+            # test both at once
+            assert_equal(ma_f(a, axis=1, keepdims=True)[...,:-1],
+                         numpy_f(d[...,:-1], axis=1, keepdims=True))
+            assert_equal(ma_f(a, axis=(0,1), keepdims=True)[...,:-1],
+                         numpy_f(d[...,:-1], axis=(0,1), keepdims=True))
+
+        for f in ['sum', 'prod', 'mean', 'var', 'std']:
+            testaxis(f, a, d)
+            testkeepdims(f, a, d)
+
+        for f in ['min', 'max']:
+            testaxis(f, a, d)
+
+        d = (np.arange(24).reshape((2,3,4))%2 == 0)
+        a = np.ma.array(d, mask=m)
+        for f in ['all', 'any']:
+            testaxis(f, a, d)
+            testkeepdims(f, a, d)
+
+    def test_count(self):
+        # test np.ma.count specially
+
+        d = np.arange(24.0).reshape((2,3,4))
+        m = np.zeros(24, dtype=bool).reshape((2,3,4))
+        m[:,0,:] = True
+        a = np.ma.array(d, mask=m)
+
+        assert_equal(count(a), 16)
+        assert_equal(count(a, axis=1), 2*ones((2,4)))
+        assert_equal(count(a, axis=(0,1)), 4*ones((4,)))
+        assert_equal(count(a, keepdims=True), 16*ones((1,1,1)))
+        assert_equal(count(a, axis=1, keepdims=True), 2*ones((2,1,4)))
+        assert_equal(count(a, axis=(0,1), keepdims=True), 4*ones((1,1,4)))
+        assert_equal(count(a, axis=-2), 2*ones((2,4)))
+        assert_raises(ValueError, count, a, axis=(1,1))
+        assert_raises(AxisError, count, a, axis=3)
+
+        # check the 'nomask' path
+        a = np.ma.array(d, mask=nomask)
+
+        assert_equal(count(a), 24)
+        assert_equal(count(a, axis=1), 3*ones((2,4)))
+        assert_equal(count(a, axis=(0,1)), 6*ones((4,)))
+        assert_equal(count(a, keepdims=True), 24*ones((1,1,1)))
+        assert_equal(np.ndim(count(a, keepdims=True)), 3)
+        assert_equal(count(a, axis=1, keepdims=True), 3*ones((2,1,4)))
+        assert_equal(count(a, axis=(0,1), keepdims=True), 6*ones((1,1,4)))
+        assert_equal(count(a, axis=-2), 3*ones((2,4)))
+        assert_raises(ValueError, count, a, axis=(1,1))
+        assert_raises(AxisError, count, a, axis=3)
+
+        # check the 'masked' singleton
+        assert_equal(count(np.ma.masked), 0)
+
+        # check 0-d arrays do not allow axis > 0
+        assert_raises(AxisError, count, np.ma.array(1), axis=1)
+
+
+class TestMaskedConstant:
+    def _do_add_test(self, add):
+        # sanity check
+        assert_(add(np.ma.masked, 1) is np.ma.masked)
+
+        # now try with a vector
+        vector = np.array([1, 2, 3])
+        result = add(np.ma.masked, vector)
+
+        # lots of things could go wrong here
+        assert_(result is not np.ma.masked)
+        assert_(not isinstance(result, np.ma.core.MaskedConstant))
+        assert_equal(result.shape, vector.shape)
+        assert_equal(np.ma.getmask(result), np.ones(vector.shape, dtype=bool))
+
+    def test_ufunc(self):
+        self._do_add_test(np.add)
+
+    def test_operator(self):
+        self._do_add_test(lambda a, b: a + b)
+
+    def test_ctor(self):
+        m = np.ma.array(np.ma.masked)
+
+        # most importantly, we do not want to create a new MaskedConstant
+        # instance
+        assert_(not isinstance(m, np.ma.core.MaskedConstant))
+        assert_(m is not np.ma.masked)
+
+    def test_repr(self):
+        # copies should not exist, but if they do, it should be obvious that
+        # something is wrong
+        assert_equal(repr(np.ma.masked), 'masked')
+
+        # create a new instance in a weird way
+        masked2 = np.ma.MaskedArray.__new__(np.ma.core.MaskedConstant)
+        assert_not_equal(repr(masked2), 'masked')
+
+    def test_pickle(self):
+        from io import BytesIO
+
+        for proto in range(2, pickle.HIGHEST_PROTOCOL + 1):
+            with BytesIO() as f:
+                pickle.dump(np.ma.masked, f, protocol=proto)
+                f.seek(0)
+                res = pickle.load(f)
+            assert_(res is np.ma.masked)
+
+    def test_copy(self):
+        # gh-9328
+        # copy is a no-op, like it is with np.True_
+        assert_equal(
+            np.ma.masked.copy() is np.ma.masked,
+            np.True_.copy() is np.True_)
+
+    def test__copy(self):
+        import copy
+        assert_(
+            copy.copy(np.ma.masked) is np.ma.masked)
+
+    def test_deepcopy(self):
+        import copy
+        assert_(
+            copy.deepcopy(np.ma.masked) is np.ma.masked)
+
+    def test_immutable(self):
+        orig = np.ma.masked
+        assert_raises(np.ma.core.MaskError, operator.setitem, orig, (), 1)
+        assert_raises(ValueError,operator.setitem, orig.data, (), 1)
+        assert_raises(ValueError, operator.setitem, orig.mask, (), False)
+
+        view = np.ma.masked.view(np.ma.MaskedArray)
+        assert_raises(ValueError, operator.setitem, view, (), 1)
+        assert_raises(ValueError, operator.setitem, view.data, (), 1)
+        assert_raises(ValueError, operator.setitem, view.mask, (), False)
+
+    def test_coercion_int(self):
+        a_i = np.zeros((), int)
+        assert_raises(MaskError, operator.setitem, a_i, (), np.ma.masked)
+        assert_raises(MaskError, int, np.ma.masked)
+
+    def test_coercion_float(self):
+        a_f = np.zeros((), float)
+        assert_warns(UserWarning, operator.setitem, a_f, (), np.ma.masked)
+        assert_(np.isnan(a_f[()]))
+
+    @pytest.mark.xfail(reason="See gh-9750")
+    def test_coercion_unicode(self):
+        a_u = np.zeros((), 'U10')
+        a_u[()] = np.ma.masked
+        assert_equal(a_u[()], '--')
+
+    @pytest.mark.xfail(reason="See gh-9750")
+    def test_coercion_bytes(self):
+        a_b = np.zeros((), 'S10')
+        a_b[()] = np.ma.masked
+        assert_equal(a_b[()], b'--')
+
+    def test_subclass(self):
+        # https://github.com/astropy/astropy/issues/6645
+        class Sub(type(np.ma.masked)): pass
+
+        a = Sub()
+        assert_(a is Sub())
+        assert_(a is not np.ma.masked)
+        assert_not_equal(repr(a), 'masked')
+
+    def test_attributes_readonly(self):
+        assert_raises(AttributeError, setattr, np.ma.masked, 'shape', (1,))
+        assert_raises(AttributeError, setattr, np.ma.masked, 'dtype', np.int64)
+
+
+class TestMaskedWhereAliases:
+
+    # TODO: Test masked_object, masked_equal, ...
+
+    def test_masked_values(self):
+        res = masked_values(np.array([-32768.0]), np.int16(-32768))
+        assert_equal(res.mask, [True])
+
+        res = masked_values(np.inf, np.inf)
+        assert_equal(res.mask, True)
+
+        res = np.ma.masked_values(np.inf, -np.inf)
+        assert_equal(res.mask, False)
+
+        res = np.ma.masked_values([1, 2, 3, 4], 5, shrink=True)
+        assert_(res.mask is np.ma.nomask)
+
+        res = np.ma.masked_values([1, 2, 3, 4], 5, shrink=False)
+        assert_equal(res.mask, [False] * 4)
+
+
+def test_masked_array():
+    a = np.ma.array([0, 1, 2, 3], mask=[0, 0, 1, 0])
+    assert_equal(np.argwhere(a), [[1], [3]])
+
+def test_masked_array_no_copy():
+    # check nomask array is updated in place
+    a = np.ma.array([1, 2, 3, 4])
+    _ = np.ma.masked_where(a == 3, a, copy=False)
+    assert_array_equal(a.mask, [False, False, True, False])
+    # check masked array is updated in place
+    a = np.ma.array([1, 2, 3, 4], mask=[1, 0, 0, 0])
+    _ = np.ma.masked_where(a == 3, a, copy=False)
+    assert_array_equal(a.mask, [True, False, True, False])
+    # check masked array with masked_invalid is updated in place
+    a = np.ma.array([np.inf, 1, 2, 3, 4])
+    _ = np.ma.masked_invalid(a, copy=False)
+    assert_array_equal(a.mask, [True, False, False, False, False])
+
+def test_append_masked_array():
+    a = np.ma.masked_equal([1,2,3], value=2)
+    b = np.ma.masked_equal([4,3,2], value=2)
+
+    result = np.ma.append(a, b)
+    expected_data = [1, 2, 3, 4, 3, 2]
+    expected_mask = [False, True, False, False, False, True]
+    assert_array_equal(result.data, expected_data)
+    assert_array_equal(result.mask, expected_mask)
+
+    a = np.ma.masked_all((2,2))
+    b = np.ma.ones((3,1))
+
+    result = np.ma.append(a, b)
+    expected_data = [1] * 3
+    expected_mask = [True] * 4 + [False] * 3
+    assert_array_equal(result.data[-3], expected_data)
+    assert_array_equal(result.mask, expected_mask)
+
+    result = np.ma.append(a, b, axis=None)
+    assert_array_equal(result.data[-3], expected_data)
+    assert_array_equal(result.mask, expected_mask)
+
+
+def test_append_masked_array_along_axis():
+    a = np.ma.masked_equal([1,2,3], value=2)
+    b = np.ma.masked_values([[4, 5, 6], [7, 8, 9]], 7)
+
+    # When `axis` is specified, `values` must have the correct shape.
+    assert_raises(ValueError, np.ma.append, a, b, axis=0)
+
+    result = np.ma.append(a[np.newaxis,:], b, axis=0)
+    expected = np.ma.arange(1, 10)
+    expected[[1, 6]] = np.ma.masked
+    expected = expected.reshape((3,3))
+    assert_array_equal(result.data, expected.data)
+    assert_array_equal(result.mask, expected.mask)
+
+def test_default_fill_value_complex():
+    # regression test for Python 3, where 'unicode' was not defined
+    assert_(default_fill_value(1 + 1j) == 1.e20 + 0.0j)
+
+
+def test_ufunc_with_output():
+    # check that giving an output argument always returns that output.
+    # Regression test for gh-8416.
+    x = array([1., 2., 3.], mask=[0, 0, 1])
+    y = np.add(x, 1., out=x)
+    assert_(y is x)
+
+
+def test_ufunc_with_out_varied():
+    """ Test that masked arrays are immune to gh-10459 """
+    # the mask of the output should not affect the result, however it is passed
+    a        = array([ 1,  2,  3], mask=[1, 0, 0])
+    b        = array([10, 20, 30], mask=[1, 0, 0])
+    out      = array([ 0,  0,  0], mask=[0, 0, 1])
+    expected = array([11, 22, 33], mask=[1, 0, 0])
+
+    out_pos = out.copy()
+    res_pos = np.add(a, b, out_pos)
+
+    out_kw = out.copy()
+    res_kw = np.add(a, b, out=out_kw)
+
+    out_tup = out.copy()
+    res_tup = np.add(a, b, out=(out_tup,))
+
+    assert_equal(res_kw.mask,  expected.mask)
+    assert_equal(res_kw.data,  expected.data)
+    assert_equal(res_tup.mask, expected.mask)
+    assert_equal(res_tup.data, expected.data)
+    assert_equal(res_pos.mask, expected.mask)
+    assert_equal(res_pos.data, expected.data)
+
+
+def test_astype_mask_ordering():
+    descr = np.dtype([('v', int, 3), ('x', [('y', float)])])
+    x = array([
+        [([1, 2, 3], (1.0,)),  ([1, 2, 3], (2.0,))],
+        [([1, 2, 3], (3.0,)),  ([1, 2, 3], (4.0,))]], dtype=descr)
+    x[0]['v'][0] = np.ma.masked
+
+    x_a = x.astype(descr)
+    assert x_a.dtype.names == np.dtype(descr).names
+    assert x_a.mask.dtype.names == np.dtype(descr).names
+    assert_equal(x, x_a)
+
+    assert_(x is x.astype(x.dtype, copy=False))
+    assert_equal(type(x.astype(x.dtype, subok=False)), np.ndarray)
+
+    x_f = x.astype(x.dtype, order='F')
+    assert_(x_f.flags.f_contiguous)
+    assert_(x_f.mask.flags.f_contiguous)
+
+    # Also test the same indirectly, via np.array
+    x_a2 = np.array(x, dtype=descr, subok=True)
+    assert x_a2.dtype.names == np.dtype(descr).names
+    assert x_a2.mask.dtype.names == np.dtype(descr).names
+    assert_equal(x, x_a2)
+
+    assert_(x is np.array(x, dtype=descr, copy=None, subok=True))
+
+    x_f2 = np.array(x, dtype=x.dtype, order='F', subok=True)
+    assert_(x_f2.flags.f_contiguous)
+    assert_(x_f2.mask.flags.f_contiguous)
+
+
+@pytest.mark.parametrize('dt1', num_dts, ids=num_ids)
+@pytest.mark.parametrize('dt2', num_dts, ids=num_ids)
+@pytest.mark.filterwarnings('ignore::numpy.exceptions.ComplexWarning')
+def test_astype_basic(dt1, dt2):
+    # See gh-12070
+    src = np.ma.array(ones(3, dt1), fill_value=1)
+    dst = src.astype(dt2)
+
+    assert_(src.fill_value == 1)
+    assert_(src.dtype == dt1)
+    assert_(src.fill_value.dtype == dt1)
+
+    assert_(dst.fill_value == 1)
+    assert_(dst.dtype == dt2)
+    assert_(dst.fill_value.dtype == dt2)
+
+    assert_equal(src, dst)
+
+
+def test_fieldless_void():
+    dt = np.dtype([])  # a void dtype with no fields
+    x = np.empty(4, dt)
+
+    # these arrays contain no values, so there's little to test - but this
+    # shouldn't crash
+    mx = np.ma.array(x)
+    assert_equal(mx.dtype, x.dtype)
+    assert_equal(mx.shape, x.shape)
+
+    mx = np.ma.array(x, mask=x)
+    assert_equal(mx.dtype, x.dtype)
+    assert_equal(mx.shape, x.shape)
+
+
+def test_mask_shape_assignment_does_not_break_masked():
+    a = np.ma.masked
+    b = np.ma.array(1, mask=a.mask)
+    b.shape = (1,)
+    assert_equal(a.mask.shape, ())
+
+@pytest.mark.skipif(sys.flags.optimize > 1,
+                    reason="no docstrings present to inspect when PYTHONOPTIMIZE/Py_OptimizeFlag > 1")
+def test_doc_note():
+    def method(self):
+        """This docstring
+
+        Has multiple lines
+
+        And notes
+
+        Notes
+        -----
+        original note
+        """
+        pass
+
+    expected_doc = """This docstring
+
+Has multiple lines
+
+And notes
+
+Notes
+-----
+note
+
+original note"""
+
+    assert_equal(np.ma.core.doc_note(method.__doc__, "note"), expected_doc)
+
+
+def test_gh_22556():
+    source = np.ma.array([0, [0, 1, 2]], dtype=object)
+    deepcopy = copy.deepcopy(source)
+    deepcopy[1].append('this should not appear in source')
+    assert len(source[1]) == 3
+
+
+def test_gh_21022():
+    # testing for absence of reported error
+    source = np.ma.masked_array(data=[-1, -1], mask=True, dtype=np.float64)
+    axis = np.array(0)
+    result = np.prod(source, axis=axis, keepdims=False)
+    result = np.ma.masked_array(result,
+                                mask=np.ones(result.shape, dtype=np.bool))
+    array = np.ma.masked_array(data=-1, mask=True, dtype=np.float64)
+    copy.deepcopy(array)
+    copy.deepcopy(result)
+
+
+def test_deepcopy_2d_obj():
+    source = np.ma.array([[0, "dog"],
+                          [1, 1],
+                          [[1, 2], "cat"]],
+                        mask=[[0, 1],
+                              [0, 0],
+                              [0, 0]],
+                        dtype=object)
+    deepcopy = copy.deepcopy(source)
+    deepcopy[2, 0].extend(['this should not appear in source', 3])
+    assert len(source[2, 0]) == 2
+    assert len(deepcopy[2, 0]) == 4
+    assert_equal(deepcopy._mask, source._mask)
+    deepcopy._mask[0, 0] = 1
+    assert source._mask[0, 0] == 0
+
+
+def test_deepcopy_0d_obj():
+    source = np.ma.array(0, mask=[0], dtype=object)
+    deepcopy = copy.deepcopy(source)
+    deepcopy[...] = 17
+    assert_equal(source, 0)
+    assert_equal(deepcopy, 17)
diff --git a/venv/lib/python3.12/site-packages/numpy/ma/tests/test_deprecations.py b/venv/lib/python3.12/site-packages/numpy/ma/tests/test_deprecations.py
new file mode 100644
index 00000000..40c8418f
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/ma/tests/test_deprecations.py
@@ -0,0 +1,84 @@
+"""Test deprecation and future warnings.
+
+"""
+import pytest
+import numpy as np
+from numpy.testing import assert_warns
+from numpy.ma.testutils import assert_equal
+from numpy.ma.core import MaskedArrayFutureWarning
+import io
+import textwrap
+
+class TestArgsort:
+    """ gh-8701 """
+    def _test_base(self, argsort, cls):
+        arr_0d = np.array(1).view(cls)
+        argsort(arr_0d)
+
+        arr_1d = np.array([1, 2, 3]).view(cls)
+        argsort(arr_1d)
+
+        # argsort has a bad default for >1d arrays
+        arr_2d = np.array([[1, 2], [3, 4]]).view(cls)
+        result = assert_warns(
+            np.ma.core.MaskedArrayFutureWarning, argsort, arr_2d)
+        assert_equal(result, argsort(arr_2d, axis=None))
+
+        # should be no warnings for explicitly specifying it
+        argsort(arr_2d, axis=None)
+        argsort(arr_2d, axis=-1)
+
+    def test_function_ndarray(self):
+        return self._test_base(np.ma.argsort, np.ndarray)
+
+    def test_function_maskedarray(self):
+        return self._test_base(np.ma.argsort, np.ma.MaskedArray)
+
+    def test_method(self):
+        return self._test_base(np.ma.MaskedArray.argsort, np.ma.MaskedArray)
+
+
+class TestMinimumMaximum:
+
+    def test_axis_default(self):
+        # NumPy 1.13, 2017-05-06
+
+        data1d = np.ma.arange(6)
+        data2d = data1d.reshape(2, 3)
+
+        ma_min = np.ma.minimum.reduce
+        ma_max = np.ma.maximum.reduce
+
+        # check that the default axis is still None, but warns on 2d arrays
+        result = assert_warns(MaskedArrayFutureWarning, ma_max, data2d)
+        assert_equal(result, ma_max(data2d, axis=None))
+
+        result = assert_warns(MaskedArrayFutureWarning, ma_min, data2d)
+        assert_equal(result, ma_min(data2d, axis=None))
+
+        # no warnings on 1d, as both new and old defaults are equivalent
+        result = ma_min(data1d)
+        assert_equal(result, ma_min(data1d, axis=None))
+        assert_equal(result, ma_min(data1d, axis=0))
+
+        result = ma_max(data1d)
+        assert_equal(result, ma_max(data1d, axis=None))
+        assert_equal(result, ma_max(data1d, axis=0))
+
+
+class TestFromtextfile:
+    def test_fromtextfile_delimitor(self):
+        # NumPy 1.22.0, 2021-09-23
+
+        textfile = io.StringIO(textwrap.dedent(
+            """
+            A,B,C,D
+            'string 1';1;1.0;'mixed column'
+            'string 2';2;2.0;
+            'string 3';3;3.0;123
+            'string 4';4;4.0;3.14
+            """
+        ))
+
+        with pytest.warns(DeprecationWarning):
+            result = np.ma.mrecords.fromtextfile(textfile, delimitor=';')
diff --git a/venv/lib/python3.12/site-packages/numpy/ma/tests/test_extras.py b/venv/lib/python3.12/site-packages/numpy/ma/tests/test_extras.py
new file mode 100644
index 00000000..daf376b7
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/ma/tests/test_extras.py
@@ -0,0 +1,1960 @@
+# pylint: disable-msg=W0611, W0612, W0511
+"""Tests suite for MaskedArray.
+Adapted from the original test_ma by Pierre Gerard-Marchant
+
+:author: Pierre Gerard-Marchant
+:contact: pierregm_at_uga_dot_edu
+:version: $Id: test_extras.py 3473 2007-10-29 15:18:13Z jarrod.millman $
+
+"""
+import warnings
+import itertools
+import pytest
+
+import numpy as np
+from numpy._core.numeric import normalize_axis_tuple
+from numpy.testing import (
+    assert_warns, suppress_warnings
+    )
+from numpy.ma.testutils import (
+    assert_, assert_array_equal, assert_equal, assert_almost_equal
+    )
+from numpy.ma.core import (
+    array, arange, masked, MaskedArray, masked_array, getmaskarray, shape,
+    nomask, ones, zeros, count
+    )
+from numpy.ma.extras import (
+    atleast_1d, atleast_2d, atleast_3d, mr_, dot, polyfit, cov, corrcoef,
+    median, average, unique, setxor1d, setdiff1d, union1d, intersect1d, in1d,
+    ediff1d, apply_over_axes, apply_along_axis, compress_nd, compress_rowcols,
+    mask_rowcols, clump_masked, clump_unmasked, flatnotmasked_contiguous,
+    notmasked_contiguous, notmasked_edges, masked_all, masked_all_like, isin,
+    diagflat, ndenumerate, stack, vstack, _covhelper
+    )
+
+
+class TestGeneric:
+    #
+    def test_masked_all(self):
+        # Tests masked_all
+        # Standard dtype
+        test = masked_all((2,), dtype=float)
+        control = array([1, 1], mask=[1, 1], dtype=float)
+        assert_equal(test, control)
+        # Flexible dtype
+        dt = np.dtype({'names': ['a', 'b'], 'formats': ['f', 'f']})
+        test = masked_all((2,), dtype=dt)
+        control = array([(0, 0), (0, 0)], mask=[(1, 1), (1, 1)], dtype=dt)
+        assert_equal(test, control)
+        test = masked_all((2, 2), dtype=dt)
+        control = array([[(0, 0), (0, 0)], [(0, 0), (0, 0)]],
+                        mask=[[(1, 1), (1, 1)], [(1, 1), (1, 1)]],
+                        dtype=dt)
+        assert_equal(test, control)
+        # Nested dtype
+        dt = np.dtype([('a', 'f'), ('b', [('ba', 'f'), ('bb', 'f')])])
+        test = masked_all((2,), dtype=dt)
+        control = array([(1, (1, 1)), (1, (1, 1))],
+                        mask=[(1, (1, 1)), (1, (1, 1))], dtype=dt)
+        assert_equal(test, control)
+        test = masked_all((2,), dtype=dt)
+        control = array([(1, (1, 1)), (1, (1, 1))],
+                        mask=[(1, (1, 1)), (1, (1, 1))], dtype=dt)
+        assert_equal(test, control)
+        test = masked_all((1, 1), dtype=dt)
+        control = array([[(1, (1, 1))]], mask=[[(1, (1, 1))]], dtype=dt)
+        assert_equal(test, control)
+
+    def test_masked_all_with_object_nested(self):
+        # Test masked_all works with nested array with dtype of an 'object'
+        # refers to issue #15895
+        my_dtype = np.dtype([('b', ([('c', object)], (1,)))])
+        masked_arr = np.ma.masked_all((1,), my_dtype)
+
+        assert_equal(type(masked_arr['b']), np.ma.core.MaskedArray)
+        assert_equal(type(masked_arr['b']['c']), np.ma.core.MaskedArray)
+        assert_equal(len(masked_arr['b']['c']), 1)
+        assert_equal(masked_arr['b']['c'].shape, (1, 1))
+        assert_equal(masked_arr['b']['c']._fill_value.shape, ())
+
+    def test_masked_all_with_object(self):
+        # same as above except that the array is not nested
+        my_dtype = np.dtype([('b', (object, (1,)))])
+        masked_arr = np.ma.masked_all((1,), my_dtype)
+
+        assert_equal(type(masked_arr['b']), np.ma.core.MaskedArray)
+        assert_equal(len(masked_arr['b']), 1)
+        assert_equal(masked_arr['b'].shape, (1, 1))
+        assert_equal(masked_arr['b']._fill_value.shape, ())
+
+    def test_masked_all_like(self):
+        # Tests masked_all
+        # Standard dtype
+        base = array([1, 2], dtype=float)
+        test = masked_all_like(base)
+        control = array([1, 1], mask=[1, 1], dtype=float)
+        assert_equal(test, control)
+        # Flexible dtype
+        dt = np.dtype({'names': ['a', 'b'], 'formats': ['f', 'f']})
+        base = array([(0, 0), (0, 0)], mask=[(1, 1), (1, 1)], dtype=dt)
+        test = masked_all_like(base)
+        control = array([(10, 10), (10, 10)], mask=[(1, 1), (1, 1)], dtype=dt)
+        assert_equal(test, control)
+        # Nested dtype
+        dt = np.dtype([('a', 'f'), ('b', [('ba', 'f'), ('bb', 'f')])])
+        control = array([(1, (1, 1)), (1, (1, 1))],
+                        mask=[(1, (1, 1)), (1, (1, 1))], dtype=dt)
+        test = masked_all_like(control)
+        assert_equal(test, control)
+
+    def check_clump(self, f):
+        for i in range(1, 7):
+            for j in range(2**i):
+                k = np.arange(i, dtype=int)
+                ja = np.full(i, j, dtype=int)
+                a = masked_array(2**k)
+                a.mask = (ja & (2**k)) != 0
+                s = 0
+                for sl in f(a):
+                    s += a.data[sl].sum()
+                if f == clump_unmasked:
+                    assert_equal(a.compressed().sum(), s)
+                else:
+                    a.mask = ~a.mask
+                    assert_equal(a.compressed().sum(), s)
+
+    def test_clump_masked(self):
+        # Test clump_masked
+        a = masked_array(np.arange(10))
+        a[[0, 1, 2, 6, 8, 9]] = masked
+        #
+        test = clump_masked(a)
+        control = [slice(0, 3), slice(6, 7), slice(8, 10)]
+        assert_equal(test, control)
+
+        self.check_clump(clump_masked)
+
+    def test_clump_unmasked(self):
+        # Test clump_unmasked
+        a = masked_array(np.arange(10))
+        a[[0, 1, 2, 6, 8, 9]] = masked
+        test = clump_unmasked(a)
+        control = [slice(3, 6), slice(7, 8), ]
+        assert_equal(test, control)
+
+        self.check_clump(clump_unmasked)
+
+    def test_flatnotmasked_contiguous(self):
+        # Test flatnotmasked_contiguous
+        a = arange(10)
+        # No mask
+        test = flatnotmasked_contiguous(a)
+        assert_equal(test, [slice(0, a.size)])
+        # mask of all false
+        a.mask = np.zeros(10, dtype=bool)
+        assert_equal(test, [slice(0, a.size)])
+        # Some mask
+        a[(a < 3) | (a > 8) | (a == 5)] = masked
+        test = flatnotmasked_contiguous(a)
+        assert_equal(test, [slice(3, 5), slice(6, 9)])
+        #
+        a[:] = masked
+        test = flatnotmasked_contiguous(a)
+        assert_equal(test, [])
+
+
+class TestAverage:
+    # Several tests of average. Why so many ? Good point...
+    def test_testAverage1(self):
+        # Test of average.
+        ott = array([0., 1., 2., 3.], mask=[True, False, False, False])
+        assert_equal(2.0, average(ott, axis=0))
+        assert_equal(2.0, average(ott, weights=[1., 1., 2., 1.]))
+        result, wts = average(ott, weights=[1., 1., 2., 1.], returned=True)
+        assert_equal(2.0, result)
+        assert_(wts == 4.0)
+        ott[:] = masked
+        assert_equal(average(ott, axis=0).mask, [True])
+        ott = array([0., 1., 2., 3.], mask=[True, False, False, False])
+        ott = ott.reshape(2, 2)
+        ott[:, 1] = masked
+        assert_equal(average(ott, axis=0), [2.0, 0.0])
+        assert_equal(average(ott, axis=1).mask[0], [True])
+        assert_equal([2., 0.], average(ott, axis=0))
+        result, wts = average(ott, axis=0, returned=True)
+        assert_equal(wts, [1., 0.])
+
+    def test_testAverage2(self):
+        # More tests of average.
+        w1 = [0, 1, 1, 1, 1, 0]
+        w2 = [[0, 1, 1, 1, 1, 0], [1, 0, 0, 0, 0, 1]]
+        x = arange(6, dtype=np.float64)
+        assert_equal(average(x, axis=0), 2.5)
+        assert_equal(average(x, axis=0, weights=w1), 2.5)
+        y = array([arange(6, dtype=np.float64), 2.0 * arange(6)])
+        assert_equal(average(y, None), np.add.reduce(np.arange(6)) * 3. / 12.)
+        assert_equal(average(y, axis=0), np.arange(6) * 3. / 2.)
+        assert_equal(average(y, axis=1),
+                     [average(x, axis=0), average(x, axis=0) * 2.0])
+        assert_equal(average(y, None, weights=w2), 20. / 6.)
+        assert_equal(average(y, axis=0, weights=w2),
+                     [0., 1., 2., 3., 4., 10.])
+        assert_equal(average(y, axis=1),
+                     [average(x, axis=0), average(x, axis=0) * 2.0])
+        m1 = zeros(6)
+        m2 = [0, 0, 1, 1, 0, 0]
+        m3 = [[0, 0, 1, 1, 0, 0], [0, 1, 1, 1, 1, 0]]
+        m4 = ones(6)
+        m5 = [0, 1, 1, 1, 1, 1]
+        assert_equal(average(masked_array(x, m1), axis=0), 2.5)
+        assert_equal(average(masked_array(x, m2), axis=0), 2.5)
+        assert_equal(average(masked_array(x, m4), axis=0).mask, [True])
+        assert_equal(average(masked_array(x, m5), axis=0), 0.0)
+        assert_equal(count(average(masked_array(x, m4), axis=0)), 0)
+        z = masked_array(y, m3)
+        assert_equal(average(z, None), 20. / 6.)
+        assert_equal(average(z, axis=0), [0., 1., 99., 99., 4.0, 7.5])
+        assert_equal(average(z, axis=1), [2.5, 5.0])
+        assert_equal(average(z, axis=0, weights=w2),
+                     [0., 1., 99., 99., 4.0, 10.0])
+
+    def test_testAverage3(self):
+        # Yet more tests of average!
+        a = arange(6)
+        b = arange(6) * 3
+        r1, w1 = average([[a, b], [b, a]], axis=1, returned=True)
+        assert_equal(shape(r1), shape(w1))
+        assert_equal(r1.shape, w1.shape)
+        r2, w2 = average(ones((2, 2, 3)), axis=0, weights=[3, 1], returned=True)
+        assert_equal(shape(w2), shape(r2))
+        r2, w2 = average(ones((2, 2, 3)), returned=True)
+        assert_equal(shape(w2), shape(r2))
+        r2, w2 = average(ones((2, 2, 3)), weights=ones((2, 2, 3)), returned=True)
+        assert_equal(shape(w2), shape(r2))
+        a2d = array([[1, 2], [0, 4]], float)
+        a2dm = masked_array(a2d, [[False, False], [True, False]])
+        a2da = average(a2d, axis=0)
+        assert_equal(a2da, [0.5, 3.0])
+        a2dma = average(a2dm, axis=0)
+        assert_equal(a2dma, [1.0, 3.0])
+        a2dma = average(a2dm, axis=None)
+        assert_equal(a2dma, 7. / 3.)
+        a2dma = average(a2dm, axis=1)
+        assert_equal(a2dma, [1.5, 4.0])
+
+    def test_testAverage4(self):
+        # Test that `keepdims` works with average
+        x = np.array([2, 3, 4]).reshape(3, 1)
+        b = np.ma.array(x, mask=[[False], [False], [True]])
+        w = np.array([4, 5, 6]).reshape(3, 1)
+        actual = average(b, weights=w, axis=1, keepdims=True)
+        desired = masked_array([[2.], [3.], [4.]], [[False], [False], [True]])
+        assert_equal(actual, desired)
+
+    def test_weight_and_input_dims_different(self):
+        # this test mirrors a test for np.average()
+        # in lib/test/test_function_base.py
+        y = np.arange(12).reshape(2, 2, 3)
+        w = np.array([0., 0., 1., .5, .5, 0., 0., .5, .5, 1., 0., 0.])\
+            .reshape(2, 2, 3)
+
+        m = np.full((2, 2, 3), False)
+        yma = np.ma.array(y, mask=m)
+        subw0 = w[:, :, 0]
+
+        actual = average(yma, axis=(0, 1), weights=subw0)
+        desired = masked_array([7., 8., 9.], mask=[False, False, False])
+        assert_almost_equal(actual, desired)
+
+        m = np.full((2, 2, 3), False)
+        m[:, :, 0] = True
+        m[0, 0, 1] = True
+        yma = np.ma.array(y, mask=m)
+        actual = average(yma, axis=(0, 1), weights=subw0)
+        desired = masked_array(
+            [np.nan, 8., 9.],
+            mask=[True, False, False])
+        assert_almost_equal(actual, desired)
+
+        m = np.full((2, 2, 3), False)
+        yma = np.ma.array(y, mask=m)
+
+        subw1 = w[1, :, :]
+        actual = average(yma, axis=(1, 2), weights=subw1)
+        desired = masked_array([2.25, 8.25], mask=[False, False])
+        assert_almost_equal(actual, desired)
+
+        # here the weights have the wrong shape for the specified axes
+        with pytest.raises(
+                ValueError,
+                match="Shape of weights must be consistent with "
+                      "shape of a along specified axis"):
+            average(yma, axis=(0, 1, 2), weights=subw0)
+
+        with pytest.raises(
+                ValueError,
+                match="Shape of weights must be consistent with "
+                      "shape of a along specified axis"):
+            average(yma, axis=(0, 1), weights=subw1)
+
+        # swapping the axes should be same as transposing weights
+        actual = average(yma, axis=(1, 0), weights=subw0)
+        desired = average(yma, axis=(0, 1), weights=subw0.T)
+        assert_almost_equal(actual, desired)
+
+    def test_onintegers_with_mask(self):
+        # Test average on integers with mask
+        a = average(array([1, 2]))
+        assert_equal(a, 1.5)
+        a = average(array([1, 2, 3, 4], mask=[False, False, True, True]))
+        assert_equal(a, 1.5)
+
+    def test_complex(self):
+        # Test with complex data.
+        # (Regression test for https://github.com/numpy/numpy/issues/2684)
+        mask = np.array([[0, 0, 0, 1, 0],
+                         [0, 1, 0, 0, 0]], dtype=bool)
+        a = masked_array([[0, 1+2j, 3+4j, 5+6j, 7+8j],
+                          [9j, 0+1j, 2+3j, 4+5j, 7+7j]],
+                         mask=mask)
+
+        av = average(a)
+        expected = np.average(a.compressed())
+        assert_almost_equal(av.real, expected.real)
+        assert_almost_equal(av.imag, expected.imag)
+
+        av0 = average(a, axis=0)
+        expected0 = average(a.real, axis=0) + average(a.imag, axis=0)*1j
+        assert_almost_equal(av0.real, expected0.real)
+        assert_almost_equal(av0.imag, expected0.imag)
+
+        av1 = average(a, axis=1)
+        expected1 = average(a.real, axis=1) + average(a.imag, axis=1)*1j
+        assert_almost_equal(av1.real, expected1.real)
+        assert_almost_equal(av1.imag, expected1.imag)
+
+        # Test with the 'weights' argument.
+        wts = np.array([[0.5, 1.0, 2.0, 1.0, 0.5],
+                        [1.0, 1.0, 1.0, 1.0, 1.0]])
+        wav = average(a, weights=wts)
+        expected = np.average(a.compressed(), weights=wts[~mask])
+        assert_almost_equal(wav.real, expected.real)
+        assert_almost_equal(wav.imag, expected.imag)
+
+        wav0 = average(a, weights=wts, axis=0)
+        expected0 = (average(a.real, weights=wts, axis=0) +
+                     average(a.imag, weights=wts, axis=0)*1j)
+        assert_almost_equal(wav0.real, expected0.real)
+        assert_almost_equal(wav0.imag, expected0.imag)
+
+        wav1 = average(a, weights=wts, axis=1)
+        expected1 = (average(a.real, weights=wts, axis=1) +
+                     average(a.imag, weights=wts, axis=1)*1j)
+        assert_almost_equal(wav1.real, expected1.real)
+        assert_almost_equal(wav1.imag, expected1.imag)
+
+    @pytest.mark.parametrize(
+        'x, axis, expected_avg, weights, expected_wavg, expected_wsum',
+        [([1, 2, 3], None, [2.0], [3, 4, 1], [1.75], [8.0]),
+         ([[1, 2, 5], [1, 6, 11]], 0, [[1.0, 4.0, 8.0]],
+          [1, 3], [[1.0, 5.0, 9.5]], [[4, 4, 4]])],
+    )
+    def test_basic_keepdims(self, x, axis, expected_avg,
+                            weights, expected_wavg, expected_wsum):
+        avg = np.ma.average(x, axis=axis, keepdims=True)
+        assert avg.shape == np.shape(expected_avg)
+        assert_array_equal(avg, expected_avg)
+
+        wavg = np.ma.average(x, axis=axis, weights=weights, keepdims=True)
+        assert wavg.shape == np.shape(expected_wavg)
+        assert_array_equal(wavg, expected_wavg)
+
+        wavg, wsum = np.ma.average(x, axis=axis, weights=weights,
+                                   returned=True, keepdims=True)
+        assert wavg.shape == np.shape(expected_wavg)
+        assert_array_equal(wavg, expected_wavg)
+        assert wsum.shape == np.shape(expected_wsum)
+        assert_array_equal(wsum, expected_wsum)
+
+    def test_masked_weights(self):
+        # Test with masked weights.
+        # (Regression test for https://github.com/numpy/numpy/issues/10438)
+        a = np.ma.array(np.arange(9).reshape(3, 3),
+                        mask=[[1, 0, 0], [1, 0, 0], [0, 0, 0]])
+        weights_unmasked = masked_array([5, 28, 31], mask=False)
+        weights_masked = masked_array([5, 28, 31], mask=[1, 0, 0])
+
+        avg_unmasked = average(a, axis=0,
+                               weights=weights_unmasked, returned=False)
+        expected_unmasked = np.array([6.0, 5.21875, 6.21875])
+        assert_almost_equal(avg_unmasked, expected_unmasked)
+
+        avg_masked = average(a, axis=0, weights=weights_masked, returned=False)
+        expected_masked = np.array([6.0, 5.576271186440678, 6.576271186440678])
+        assert_almost_equal(avg_masked, expected_masked)
+
+        # weights should be masked if needed
+        # depending on the array mask. This is to avoid summing
+        # masked nan or other values that are not cancelled by a zero
+        a = np.ma.array([1.0,   2.0,   3.0,  4.0],
+                   mask=[False, False, True, True])
+        avg_unmasked = average(a, weights=[1, 1, 1, np.nan])
+
+        assert_almost_equal(avg_unmasked, 1.5)
+
+        a = np.ma.array([
+            [1.0, 2.0, 3.0, 4.0],
+            [5.0, 6.0, 7.0, 8.0],
+            [9.0, 1.0, 2.0, 3.0],
+        ], mask=[
+            [False, True, True, False],
+            [True, False, True, True],
+            [True, False, True, False],
+        ])
+
+        avg_masked = np.ma.average(a, weights=[1, np.nan, 1], axis=0)
+        avg_expected = np.ma.array([1.0, np.nan, np.nan, 3.5],
+                              mask=[False, True, True, False])
+
+        assert_almost_equal(avg_masked, avg_expected)
+        assert_equal(avg_masked.mask, avg_expected.mask)
+
+
+class TestConcatenator:
+    # Tests for mr_, the equivalent of r_ for masked arrays.
+
+    def test_1d(self):
+        # Tests mr_ on 1D arrays.
+        assert_array_equal(mr_[1, 2, 3, 4, 5, 6], array([1, 2, 3, 4, 5, 6]))
+        b = ones(5)
+        m = [1, 0, 0, 0, 0]
+        d = masked_array(b, mask=m)
+        c = mr_[d, 0, 0, d]
+        assert_(isinstance(c, MaskedArray))
+        assert_array_equal(c, [1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1])
+        assert_array_equal(c.mask, mr_[m, 0, 0, m])
+
+    def test_2d(self):
+        # Tests mr_ on 2D arrays.
+        a_1 = np.random.rand(5, 5)
+        a_2 = np.random.rand(5, 5)
+        m_1 = np.round(np.random.rand(5, 5), 0)
+        m_2 = np.round(np.random.rand(5, 5), 0)
+        b_1 = masked_array(a_1, mask=m_1)
+        b_2 = masked_array(a_2, mask=m_2)
+        # append columns
+        d = mr_['1', b_1, b_2]
+        assert_(d.shape == (5, 10))
+        assert_array_equal(d[:, :5], b_1)
+        assert_array_equal(d[:, 5:], b_2)
+        assert_array_equal(d.mask, np.r_['1', m_1, m_2])
+        d = mr_[b_1, b_2]
+        assert_(d.shape == (10, 5))
+        assert_array_equal(d[:5,:], b_1)
+        assert_array_equal(d[5:,:], b_2)
+        assert_array_equal(d.mask, np.r_[m_1, m_2])
+
+    def test_masked_constant(self):
+        actual = mr_[np.ma.masked, 1]
+        assert_equal(actual.mask, [True, False])
+        assert_equal(actual.data[1], 1)
+
+        actual = mr_[[1, 2], np.ma.masked]
+        assert_equal(actual.mask, [False, False, True])
+        assert_equal(actual.data[:2], [1, 2])
+
+
+class TestNotMasked:
+    # Tests notmasked_edges and notmasked_contiguous.
+
+    def test_edges(self):
+        # Tests unmasked_edges
+        data = masked_array(np.arange(25).reshape(5, 5),
+                            mask=[[0, 0, 1, 0, 0],
+                                  [0, 0, 0, 1, 1],
+                                  [1, 1, 0, 0, 0],
+                                  [0, 0, 0, 0, 0],
+                                  [1, 1, 1, 0, 0]],)
+        test = notmasked_edges(data, None)
+        assert_equal(test, [0, 24])
+        test = notmasked_edges(data, 0)
+        assert_equal(test[0], [(0, 0, 1, 0, 0), (0, 1, 2, 3, 4)])
+        assert_equal(test[1], [(3, 3, 3, 4, 4), (0, 1, 2, 3, 4)])
+        test = notmasked_edges(data, 1)
+        assert_equal(test[0], [(0, 1, 2, 3, 4), (0, 0, 2, 0, 3)])
+        assert_equal(test[1], [(0, 1, 2, 3, 4), (4, 2, 4, 4, 4)])
+        #
+        test = notmasked_edges(data.data, None)
+        assert_equal(test, [0, 24])
+        test = notmasked_edges(data.data, 0)
+        assert_equal(test[0], [(0, 0, 0, 0, 0), (0, 1, 2, 3, 4)])
+        assert_equal(test[1], [(4, 4, 4, 4, 4), (0, 1, 2, 3, 4)])
+        test = notmasked_edges(data.data, -1)
+        assert_equal(test[0], [(0, 1, 2, 3, 4), (0, 0, 0, 0, 0)])
+        assert_equal(test[1], [(0, 1, 2, 3, 4), (4, 4, 4, 4, 4)])
+        #
+        data[-2] = masked
+        test = notmasked_edges(data, 0)
+        assert_equal(test[0], [(0, 0, 1, 0, 0), (0, 1, 2, 3, 4)])
+        assert_equal(test[1], [(1, 1, 2, 4, 4), (0, 1, 2, 3, 4)])
+        test = notmasked_edges(data, -1)
+        assert_equal(test[0], [(0, 1, 2, 4), (0, 0, 2, 3)])
+        assert_equal(test[1], [(0, 1, 2, 4), (4, 2, 4, 4)])
+
+    def test_contiguous(self):
+        # Tests notmasked_contiguous
+        a = masked_array(np.arange(24).reshape(3, 8),
+                         mask=[[0, 0, 0, 0, 1, 1, 1, 1],
+                               [1, 1, 1, 1, 1, 1, 1, 1],
+                               [0, 0, 0, 0, 0, 0, 1, 0]])
+        tmp = notmasked_contiguous(a, None)
+        assert_equal(tmp, [
+            slice(0, 4, None),
+            slice(16, 22, None),
+            slice(23, 24, None)
+        ])
+
+        tmp = notmasked_contiguous(a, 0)
+        assert_equal(tmp, [
+            [slice(0, 1, None), slice(2, 3, None)],
+            [slice(0, 1, None), slice(2, 3, None)],
+            [slice(0, 1, None), slice(2, 3, None)],
+            [slice(0, 1, None), slice(2, 3, None)],
+            [slice(2, 3, None)],
+            [slice(2, 3, None)],
+            [],
+            [slice(2, 3, None)]
+        ])
+        #
+        tmp = notmasked_contiguous(a, 1)
+        assert_equal(tmp, [
+            [slice(0, 4, None)],
+            [],
+            [slice(0, 6, None), slice(7, 8, None)]
+        ])
+
+
+class TestCompressFunctions:
+
+    def test_compress_nd(self):
+        # Tests compress_nd
+        x = np.array(list(range(3*4*5))).reshape(3, 4, 5)
+        m = np.zeros((3,4,5)).astype(bool)
+        m[1,1,1] = True
+        x = array(x, mask=m)
+
+        # axis=None
+        a = compress_nd(x)
+        assert_equal(a, [[[ 0,  2,  3,  4],
+                          [10, 12, 13, 14],
+                          [15, 17, 18, 19]],
+                         [[40, 42, 43, 44],
+                          [50, 52, 53, 54],
+                          [55, 57, 58, 59]]])
+
+        # axis=0
+        a = compress_nd(x, 0)
+        assert_equal(a, [[[ 0,  1,  2,  3,  4],
+                          [ 5,  6,  7,  8,  9],
+                          [10, 11, 12, 13, 14],
+                          [15, 16, 17, 18, 19]],
+                         [[40, 41, 42, 43, 44],
+                          [45, 46, 47, 48, 49],
+                          [50, 51, 52, 53, 54],
+                          [55, 56, 57, 58, 59]]])
+
+        # axis=1
+        a = compress_nd(x, 1)
+        assert_equal(a, [[[ 0,  1,  2,  3,  4],
+                          [10, 11, 12, 13, 14],
+                          [15, 16, 17, 18, 19]],
+                         [[20, 21, 22, 23, 24],
+                          [30, 31, 32, 33, 34],
+                          [35, 36, 37, 38, 39]],
+                         [[40, 41, 42, 43, 44],
+                          [50, 51, 52, 53, 54],
+                          [55, 56, 57, 58, 59]]])
+
+        a2 = compress_nd(x, (1,))
+        a3 = compress_nd(x, -2)
+        a4 = compress_nd(x, (-2,))
+        assert_equal(a, a2)
+        assert_equal(a, a3)
+        assert_equal(a, a4)
+
+        # axis=2
+        a = compress_nd(x, 2)
+        assert_equal(a, [[[ 0, 2,  3,  4],
+                          [ 5, 7,  8,  9],
+                          [10, 12, 13, 14],
+                          [15, 17, 18, 19]],
+                         [[20, 22, 23, 24],
+                          [25, 27, 28, 29],
+                          [30, 32, 33, 34],
+                          [35, 37, 38, 39]],
+                         [[40, 42, 43, 44],
+                          [45, 47, 48, 49],
+                          [50, 52, 53, 54],
+                          [55, 57, 58, 59]]])
+
+        a2 = compress_nd(x, (2,))
+        a3 = compress_nd(x, -1)
+        a4 = compress_nd(x, (-1,))
+        assert_equal(a, a2)
+        assert_equal(a, a3)
+        assert_equal(a, a4)
+
+        # axis=(0, 1)
+        a = compress_nd(x, (0, 1))
+        assert_equal(a, [[[ 0,  1,  2,  3,  4],
+                          [10, 11, 12, 13, 14],
+                          [15, 16, 17, 18, 19]],
+                         [[40, 41, 42, 43, 44],
+                          [50, 51, 52, 53, 54],
+                          [55, 56, 57, 58, 59]]])
+        a2 = compress_nd(x, (0, -2))
+        assert_equal(a, a2)
+
+        # axis=(1, 2)
+        a = compress_nd(x, (1, 2))
+        assert_equal(a, [[[ 0,  2,  3,  4],
+                          [10, 12, 13, 14],
+                          [15, 17, 18, 19]],
+                         [[20, 22, 23, 24],
+                          [30, 32, 33, 34],
+                          [35, 37, 38, 39]],
+                         [[40, 42, 43, 44],
+                          [50, 52, 53, 54],
+                          [55, 57, 58, 59]]])
+
+        a2 = compress_nd(x, (-2, 2))
+        a3 = compress_nd(x, (1, -1))
+        a4 = compress_nd(x, (-2, -1))
+        assert_equal(a, a2)
+        assert_equal(a, a3)
+        assert_equal(a, a4)
+
+        # axis=(0, 2)
+        a = compress_nd(x, (0, 2))
+        assert_equal(a, [[[ 0,  2,  3,  4],
+                          [ 5,  7,  8,  9],
+                          [10, 12, 13, 14],
+                          [15, 17, 18, 19]],
+                         [[40, 42, 43, 44],
+                          [45, 47, 48, 49],
+                          [50, 52, 53, 54],
+                          [55, 57, 58, 59]]])
+
+        a2 = compress_nd(x, (0, -1))
+        assert_equal(a, a2)
+
+    def test_compress_rowcols(self):
+        # Tests compress_rowcols
+        x = array(np.arange(9).reshape(3, 3),
+                  mask=[[1, 0, 0], [0, 0, 0], [0, 0, 0]])
+        assert_equal(compress_rowcols(x), [[4, 5], [7, 8]])
+        assert_equal(compress_rowcols(x, 0), [[3, 4, 5], [6, 7, 8]])
+        assert_equal(compress_rowcols(x, 1), [[1, 2], [4, 5], [7, 8]])
+        x = array(x._data, mask=[[0, 0, 0], [0, 1, 0], [0, 0, 0]])
+        assert_equal(compress_rowcols(x), [[0, 2], [6, 8]])
+        assert_equal(compress_rowcols(x, 0), [[0, 1, 2], [6, 7, 8]])
+        assert_equal(compress_rowcols(x, 1), [[0, 2], [3, 5], [6, 8]])
+        x = array(x._data, mask=[[1, 0, 0], [0, 1, 0], [0, 0, 0]])
+        assert_equal(compress_rowcols(x), [[8]])
+        assert_equal(compress_rowcols(x, 0), [[6, 7, 8]])
+        assert_equal(compress_rowcols(x, 1,), [[2], [5], [8]])
+        x = array(x._data, mask=[[1, 0, 0], [0, 1, 0], [0, 0, 1]])
+        assert_equal(compress_rowcols(x).size, 0)
+        assert_equal(compress_rowcols(x, 0).size, 0)
+        assert_equal(compress_rowcols(x, 1).size, 0)
+
+    def test_mask_rowcols(self):
+        # Tests mask_rowcols.
+        x = array(np.arange(9).reshape(3, 3),
+                  mask=[[1, 0, 0], [0, 0, 0], [0, 0, 0]])
+        assert_equal(mask_rowcols(x).mask,
+                     [[1, 1, 1], [1, 0, 0], [1, 0, 0]])
+        assert_equal(mask_rowcols(x, 0).mask,
+                     [[1, 1, 1], [0, 0, 0], [0, 0, 0]])
+        assert_equal(mask_rowcols(x, 1).mask,
+                     [[1, 0, 0], [1, 0, 0], [1, 0, 0]])
+        x = array(x._data, mask=[[0, 0, 0], [0, 1, 0], [0, 0, 0]])
+        assert_equal(mask_rowcols(x).mask,
+                     [[0, 1, 0], [1, 1, 1], [0, 1, 0]])
+        assert_equal(mask_rowcols(x, 0).mask,
+                     [[0, 0, 0], [1, 1, 1], [0, 0, 0]])
+        assert_equal(mask_rowcols(x, 1).mask,
+                     [[0, 1, 0], [0, 1, 0], [0, 1, 0]])
+        x = array(x._data, mask=[[1, 0, 0], [0, 1, 0], [0, 0, 0]])
+        assert_equal(mask_rowcols(x).mask,
+                     [[1, 1, 1], [1, 1, 1], [1, 1, 0]])
+        assert_equal(mask_rowcols(x, 0).mask,
+                     [[1, 1, 1], [1, 1, 1], [0, 0, 0]])
+        assert_equal(mask_rowcols(x, 1,).mask,
+                     [[1, 1, 0], [1, 1, 0], [1, 1, 0]])
+        x = array(x._data, mask=[[1, 0, 0], [0, 1, 0], [0, 0, 1]])
+        assert_(mask_rowcols(x).all() is masked)
+        assert_(mask_rowcols(x, 0).all() is masked)
+        assert_(mask_rowcols(x, 1).all() is masked)
+        assert_(mask_rowcols(x).mask.all())
+        assert_(mask_rowcols(x, 0).mask.all())
+        assert_(mask_rowcols(x, 1).mask.all())
+
+    @pytest.mark.parametrize("axis", [None, 0, 1])
+    @pytest.mark.parametrize(["func", "rowcols_axis"],
+                             [(np.ma.mask_rows, 0), (np.ma.mask_cols, 1)])
+    def test_mask_row_cols_axis_deprecation(self, axis, func, rowcols_axis):
+        # Test deprecation of the axis argument to `mask_rows` and `mask_cols`
+        x = array(np.arange(9).reshape(3, 3),
+                  mask=[[1, 0, 0], [0, 0, 0], [0, 0, 0]])
+
+        with assert_warns(DeprecationWarning):
+            res = func(x, axis=axis)
+            assert_equal(res, mask_rowcols(x, rowcols_axis))
+
+    def test_dot(self):
+        # Tests dot product
+        n = np.arange(1, 7)
+        #
+        m = [1, 0, 0, 0, 0, 0]
+        a = masked_array(n, mask=m).reshape(2, 3)
+        b = masked_array(n, mask=m).reshape(3, 2)
+        c = dot(a, b, strict=True)
+        assert_equal(c.mask, [[1, 1], [1, 0]])
+        c = dot(b, a, strict=True)
+        assert_equal(c.mask, [[1, 1, 1], [1, 0, 0], [1, 0, 0]])
+        c = dot(a, b, strict=False)
+        assert_equal(c, np.dot(a.filled(0), b.filled(0)))
+        c = dot(b, a, strict=False)
+        assert_equal(c, np.dot(b.filled(0), a.filled(0)))
+        #
+        m = [0, 0, 0, 0, 0, 1]
+        a = masked_array(n, mask=m).reshape(2, 3)
+        b = masked_array(n, mask=m).reshape(3, 2)
+        c = dot(a, b, strict=True)
+        assert_equal(c.mask, [[0, 1], [1, 1]])
+        c = dot(b, a, strict=True)
+        assert_equal(c.mask, [[0, 0, 1], [0, 0, 1], [1, 1, 1]])
+        c = dot(a, b, strict=False)
+        assert_equal(c, np.dot(a.filled(0), b.filled(0)))
+        assert_equal(c, dot(a, b))
+        c = dot(b, a, strict=False)
+        assert_equal(c, np.dot(b.filled(0), a.filled(0)))
+        #
+        m = [0, 0, 0, 0, 0, 0]
+        a = masked_array(n, mask=m).reshape(2, 3)
+        b = masked_array(n, mask=m).reshape(3, 2)
+        c = dot(a, b)
+        assert_equal(c.mask, nomask)
+        c = dot(b, a)
+        assert_equal(c.mask, nomask)
+        #
+        a = masked_array(n, mask=[1, 0, 0, 0, 0, 0]).reshape(2, 3)
+        b = masked_array(n, mask=[0, 0, 0, 0, 0, 0]).reshape(3, 2)
+        c = dot(a, b, strict=True)
+        assert_equal(c.mask, [[1, 1], [0, 0]])
+        c = dot(a, b, strict=False)
+        assert_equal(c, np.dot(a.filled(0), b.filled(0)))
+        c = dot(b, a, strict=True)
+        assert_equal(c.mask, [[1, 0, 0], [1, 0, 0], [1, 0, 0]])
+        c = dot(b, a, strict=False)
+        assert_equal(c, np.dot(b.filled(0), a.filled(0)))
+        #
+        a = masked_array(n, mask=[0, 0, 0, 0, 0, 1]).reshape(2, 3)
+        b = masked_array(n, mask=[0, 0, 0, 0, 0, 0]).reshape(3, 2)
+        c = dot(a, b, strict=True)
+        assert_equal(c.mask, [[0, 0], [1, 1]])
+        c = dot(a, b)
+        assert_equal(c, np.dot(a.filled(0), b.filled(0)))
+        c = dot(b, a, strict=True)
+        assert_equal(c.mask, [[0, 0, 1], [0, 0, 1], [0, 0, 1]])
+        c = dot(b, a, strict=False)
+        assert_equal(c, np.dot(b.filled(0), a.filled(0)))
+        #
+        a = masked_array(n, mask=[0, 0, 0, 0, 0, 1]).reshape(2, 3)
+        b = masked_array(n, mask=[0, 0, 1, 0, 0, 0]).reshape(3, 2)
+        c = dot(a, b, strict=True)
+        assert_equal(c.mask, [[1, 0], [1, 1]])
+        c = dot(a, b, strict=False)
+        assert_equal(c, np.dot(a.filled(0), b.filled(0)))
+        c = dot(b, a, strict=True)
+        assert_equal(c.mask, [[0, 0, 1], [1, 1, 1], [0, 0, 1]])
+        c = dot(b, a, strict=False)
+        assert_equal(c, np.dot(b.filled(0), a.filled(0)))
+        #
+        a = masked_array(np.arange(8).reshape(2, 2, 2),
+                         mask=[[[1, 0], [0, 0]], [[0, 0], [0, 0]]])
+        b = masked_array(np.arange(8).reshape(2, 2, 2),
+                         mask=[[[0, 0], [0, 0]], [[0, 0], [0, 1]]])
+        c = dot(a, b, strict=True)
+        assert_equal(c.mask,
+                     [[[[1, 1], [1, 1]], [[0, 0], [0, 1]]],
+                      [[[0, 0], [0, 1]], [[0, 0], [0, 1]]]])
+        c = dot(a, b, strict=False)
+        assert_equal(c.mask,
+                     [[[[0, 0], [0, 1]], [[0, 0], [0, 0]]],
+                      [[[0, 0], [0, 0]], [[0, 0], [0, 0]]]])
+        c = dot(b, a, strict=True)
+        assert_equal(c.mask,
+                     [[[[1, 0], [0, 0]], [[1, 0], [0, 0]]],
+                      [[[1, 0], [0, 0]], [[1, 1], [1, 1]]]])
+        c = dot(b, a, strict=False)
+        assert_equal(c.mask,
+                     [[[[0, 0], [0, 0]], [[0, 0], [0, 0]]],
+                      [[[0, 0], [0, 0]], [[1, 0], [0, 0]]]])
+        #
+        a = masked_array(np.arange(8).reshape(2, 2, 2),
+                         mask=[[[1, 0], [0, 0]], [[0, 0], [0, 0]]])
+        b = 5.
+        c = dot(a, b, strict=True)
+        assert_equal(c.mask, [[[1, 0], [0, 0]], [[0, 0], [0, 0]]])
+        c = dot(a, b, strict=False)
+        assert_equal(c.mask, [[[1, 0], [0, 0]], [[0, 0], [0, 0]]])
+        c = dot(b, a, strict=True)
+        assert_equal(c.mask, [[[1, 0], [0, 0]], [[0, 0], [0, 0]]])
+        c = dot(b, a, strict=False)
+        assert_equal(c.mask, [[[1, 0], [0, 0]], [[0, 0], [0, 0]]])
+        #
+        a = masked_array(np.arange(8).reshape(2, 2, 2),
+                         mask=[[[1, 0], [0, 0]], [[0, 0], [0, 0]]])
+        b = masked_array(np.arange(2), mask=[0, 1])
+        c = dot(a, b, strict=True)
+        assert_equal(c.mask, [[1, 1], [1, 1]])
+        c = dot(a, b, strict=False)
+        assert_equal(c.mask, [[1, 0], [0, 0]])
+
+    def test_dot_returns_maskedarray(self):
+        # See gh-6611
+        a = np.eye(3)
+        b = array(a)
+        assert_(type(dot(a, a)) is MaskedArray)
+        assert_(type(dot(a, b)) is MaskedArray)
+        assert_(type(dot(b, a)) is MaskedArray)
+        assert_(type(dot(b, b)) is MaskedArray)
+
+    def test_dot_out(self):
+        a = array(np.eye(3))
+        out = array(np.zeros((3, 3)))
+        res = dot(a, a, out=out)
+        assert_(res is out)
+        assert_equal(a, res)
+
+
+class TestApplyAlongAxis:
+    # Tests 2D functions
+    def test_3d(self):
+        a = arange(12.).reshape(2, 2, 3)
+
+        def myfunc(b):
+            return b[1]
+
+        xa = apply_along_axis(myfunc, 2, a)
+        assert_equal(xa, [[1, 4], [7, 10]])
+
+    # Tests kwargs functions
+    def test_3d_kwargs(self):
+        a = arange(12).reshape(2, 2, 3)
+
+        def myfunc(b, offset=0):
+            return b[1+offset]
+
+        xa = apply_along_axis(myfunc, 2, a, offset=1)
+        assert_equal(xa, [[2, 5], [8, 11]])
+
+
+class TestApplyOverAxes:
+    # Tests apply_over_axes
+    def test_basic(self):
+        a = arange(24).reshape(2, 3, 4)
+        test = apply_over_axes(np.sum, a, [0, 2])
+        ctrl = np.array([[[60], [92], [124]]])
+        assert_equal(test, ctrl)
+        a[(a % 2).astype(bool)] = masked
+        test = apply_over_axes(np.sum, a, [0, 2])
+        ctrl = np.array([[[28], [44], [60]]])
+        assert_equal(test, ctrl)
+
+
+class TestMedian:
+    def test_pytype(self):
+        r = np.ma.median([[np.inf, np.inf], [np.inf, np.inf]], axis=-1)
+        assert_equal(r, np.inf)
+
+    def test_inf(self):
+        # test that even which computes handles inf / x = masked
+        r = np.ma.median(np.ma.masked_array([[np.inf, np.inf],
+                                             [np.inf, np.inf]]), axis=-1)
+        assert_equal(r, np.inf)
+        r = np.ma.median(np.ma.masked_array([[np.inf, np.inf],
+                                             [np.inf, np.inf]]), axis=None)
+        assert_equal(r, np.inf)
+        # all masked
+        r = np.ma.median(np.ma.masked_array([[np.inf, np.inf],
+                                             [np.inf, np.inf]], mask=True),
+                         axis=-1)
+        assert_equal(r.mask, True)
+        r = np.ma.median(np.ma.masked_array([[np.inf, np.inf],
+                                             [np.inf, np.inf]], mask=True),
+                         axis=None)
+        assert_equal(r.mask, True)
+
+    def test_non_masked(self):
+        x = np.arange(9)
+        assert_equal(np.ma.median(x), 4.)
+        assert_(type(np.ma.median(x)) is not MaskedArray)
+        x = range(8)
+        assert_equal(np.ma.median(x), 3.5)
+        assert_(type(np.ma.median(x)) is not MaskedArray)
+        x = 5
+        assert_equal(np.ma.median(x), 5.)
+        assert_(type(np.ma.median(x)) is not MaskedArray)
+        # integer
+        x = np.arange(9 * 8).reshape(9, 8)
+        assert_equal(np.ma.median(x, axis=0), np.median(x, axis=0))
+        assert_equal(np.ma.median(x, axis=1), np.median(x, axis=1))
+        assert_(np.ma.median(x, axis=1) is not MaskedArray)
+        # float
+        x = np.arange(9 * 8.).reshape(9, 8)
+        assert_equal(np.ma.median(x, axis=0), np.median(x, axis=0))
+        assert_equal(np.ma.median(x, axis=1), np.median(x, axis=1))
+        assert_(np.ma.median(x, axis=1) is not MaskedArray)
+
+    def test_docstring_examples(self):
+        "test the examples given in the docstring of ma.median"
+        x = array(np.arange(8), mask=[0]*4 + [1]*4)
+        assert_equal(np.ma.median(x), 1.5)
+        assert_equal(np.ma.median(x).shape, (), "shape mismatch")
+        assert_(type(np.ma.median(x)) is not MaskedArray)
+        x = array(np.arange(10).reshape(2, 5), mask=[0]*6 + [1]*4)
+        assert_equal(np.ma.median(x), 2.5)
+        assert_equal(np.ma.median(x).shape, (), "shape mismatch")
+        assert_(type(np.ma.median(x)) is not MaskedArray)
+        ma_x = np.ma.median(x, axis=-1, overwrite_input=True)
+        assert_equal(ma_x, [2., 5.])
+        assert_equal(ma_x.shape, (2,), "shape mismatch")
+        assert_(type(ma_x) is MaskedArray)
+
+    def test_axis_argument_errors(self):
+        msg = "mask = %s, ndim = %s, axis = %s, overwrite_input = %s"
+        for ndmin in range(5):
+            for mask in [False, True]:
+                x = array(1, ndmin=ndmin, mask=mask)
+
+                # Valid axis values should not raise exception
+                args = itertools.product(range(-ndmin, ndmin), [False, True])
+                for axis, over in args:
+                    try:
+                        np.ma.median(x, axis=axis, overwrite_input=over)
+                    except Exception:
+                        raise AssertionError(msg % (mask, ndmin, axis, over))
+
+                # Invalid axis values should raise exception
+                args = itertools.product([-(ndmin + 1), ndmin], [False, True])
+                for axis, over in args:
+                    try:
+                        np.ma.median(x, axis=axis, overwrite_input=over)
+                    except np.exceptions.AxisError:
+                        pass
+                    else:
+                        raise AssertionError(msg % (mask, ndmin, axis, over))
+
+    def test_masked_0d(self):
+        # Check values
+        x = array(1, mask=False)
+        assert_equal(np.ma.median(x), 1)
+        x = array(1, mask=True)
+        assert_equal(np.ma.median(x), np.ma.masked)
+
+    def test_masked_1d(self):
+        x = array(np.arange(5), mask=True)
+        assert_equal(np.ma.median(x), np.ma.masked)
+        assert_equal(np.ma.median(x).shape, (), "shape mismatch")
+        assert_(type(np.ma.median(x)) is np.ma.core.MaskedConstant)
+        x = array(np.arange(5), mask=False)
+        assert_equal(np.ma.median(x), 2.)
+        assert_equal(np.ma.median(x).shape, (), "shape mismatch")
+        assert_(type(np.ma.median(x)) is not MaskedArray)
+        x = array(np.arange(5), mask=[0,1,0,0,0])
+        assert_equal(np.ma.median(x), 2.5)
+        assert_equal(np.ma.median(x).shape, (), "shape mismatch")
+        assert_(type(np.ma.median(x)) is not MaskedArray)
+        x = array(np.arange(5), mask=[0,1,1,1,1])
+        assert_equal(np.ma.median(x), 0.)
+        assert_equal(np.ma.median(x).shape, (), "shape mismatch")
+        assert_(type(np.ma.median(x)) is not MaskedArray)
+        # integer
+        x = array(np.arange(5), mask=[0,1,1,0,0])
+        assert_equal(np.ma.median(x), 3.)
+        assert_equal(np.ma.median(x).shape, (), "shape mismatch")
+        assert_(type(np.ma.median(x)) is not MaskedArray)
+        # float
+        x = array(np.arange(5.), mask=[0,1,1,0,0])
+        assert_equal(np.ma.median(x), 3.)
+        assert_equal(np.ma.median(x).shape, (), "shape mismatch")
+        assert_(type(np.ma.median(x)) is not MaskedArray)
+        # integer
+        x = array(np.arange(6), mask=[0,1,1,1,1,0])
+        assert_equal(np.ma.median(x), 2.5)
+        assert_equal(np.ma.median(x).shape, (), "shape mismatch")
+        assert_(type(np.ma.median(x)) is not MaskedArray)
+        # float
+        x = array(np.arange(6.), mask=[0,1,1,1,1,0])
+        assert_equal(np.ma.median(x), 2.5)
+        assert_equal(np.ma.median(x).shape, (), "shape mismatch")
+        assert_(type(np.ma.median(x)) is not MaskedArray)
+
+    def test_1d_shape_consistency(self):
+        assert_equal(np.ma.median(array([1,2,3],mask=[0,0,0])).shape,
+                     np.ma.median(array([1,2,3],mask=[0,1,0])).shape )
+
+    def test_2d(self):
+        # Tests median w/ 2D
+        (n, p) = (101, 30)
+        x = masked_array(np.linspace(-1., 1., n),)
+        x[:10] = x[-10:] = masked
+        z = masked_array(np.empty((n, p), dtype=float))
+        z[:, 0] = x[:]
+        idx = np.arange(len(x))
+        for i in range(1, p):
+            np.random.shuffle(idx)
+            z[:, i] = x[idx]
+        assert_equal(median(z[:, 0]), 0)
+        assert_equal(median(z), 0)
+        assert_equal(median(z, axis=0), np.zeros(p))
+        assert_equal(median(z.T, axis=1), np.zeros(p))
+
+    def test_2d_waxis(self):
+        # Tests median w/ 2D arrays and different axis.
+        x = masked_array(np.arange(30).reshape(10, 3))
+        x[:3] = x[-3:] = masked
+        assert_equal(median(x), 14.5)
+        assert_(type(np.ma.median(x)) is not MaskedArray)
+        assert_equal(median(x, axis=0), [13.5, 14.5, 15.5])
+        assert_(type(np.ma.median(x, axis=0)) is MaskedArray)
+        assert_equal(median(x, axis=1), [0, 0, 0, 10, 13, 16, 19, 0, 0, 0])
+        assert_(type(np.ma.median(x, axis=1)) is MaskedArray)
+        assert_equal(median(x, axis=1).mask, [1, 1, 1, 0, 0, 0, 0, 1, 1, 1])
+
+    def test_3d(self):
+        # Tests median w/ 3D
+        x = np.ma.arange(24).reshape(3, 4, 2)
+        x[x % 3 == 0] = masked
+        assert_equal(median(x, 0), [[12, 9], [6, 15], [12, 9], [18, 15]])
+        x.shape = (4, 3, 2)
+        assert_equal(median(x, 0), [[99, 10], [11, 99], [13, 14]])
+        x = np.ma.arange(24).reshape(4, 3, 2)
+        x[x % 5 == 0] = masked
+        assert_equal(median(x, 0), [[12, 10], [8, 9], [16, 17]])
+
+    def test_neg_axis(self):
+        x = masked_array(np.arange(30).reshape(10, 3))
+        x[:3] = x[-3:] = masked
+        assert_equal(median(x, axis=-1), median(x, axis=1))
+
+    def test_out_1d(self):
+        # integer float even odd
+        for v in (30, 30., 31, 31.):
+            x = masked_array(np.arange(v))
+            x[:3] = x[-3:] = masked
+            out = masked_array(np.ones(()))
+            r = median(x, out=out)
+            if v == 30:
+                assert_equal(out, 14.5)
+            else:
+                assert_equal(out, 15.)
+            assert_(r is out)
+            assert_(type(r) is MaskedArray)
+
+    def test_out(self):
+        # integer float even odd
+        for v in (40, 40., 30, 30.):
+            x = masked_array(np.arange(v).reshape(10, -1))
+            x[:3] = x[-3:] = masked
+            out = masked_array(np.ones(10))
+            r = median(x, axis=1, out=out)
+            if v == 30:
+                e = masked_array([0.]*3 + [10, 13, 16, 19] + [0.]*3,
+                                 mask=[True] * 3 + [False] * 4 + [True] * 3)
+            else:
+                e = masked_array([0.]*3 + [13.5, 17.5, 21.5, 25.5] + [0.]*3,
+                                 mask=[True]*3 + [False]*4 + [True]*3)
+            assert_equal(r, e)
+            assert_(r is out)
+            assert_(type(r) is MaskedArray)
+
+    @pytest.mark.parametrize(
+        argnames='axis',
+        argvalues=[
+            None,
+            1,
+            (1, ),
+            (0, 1),
+            (-3, -1),
+        ]
+    )
+    def test_keepdims_out(self, axis):
+        mask = np.zeros((3, 5, 7, 11), dtype=bool)
+        # Randomly set some elements to True:
+        w = np.random.random((4, 200)) * np.array(mask.shape)[:, None]
+        w = w.astype(np.intp)
+        mask[tuple(w)] = np.nan
+        d = masked_array(np.ones(mask.shape), mask=mask)
+        if axis is None:
+            shape_out = (1,) * d.ndim
+        else:
+            axis_norm = normalize_axis_tuple(axis, d.ndim)
+            shape_out = tuple(
+                1 if i in axis_norm else d.shape[i] for i in range(d.ndim))
+        out = masked_array(np.empty(shape_out))
+        result = median(d, axis=axis, keepdims=True, out=out)
+        assert result is out
+        assert_equal(result.shape, shape_out)
+
+    def test_single_non_masked_value_on_axis(self):
+        data = [[1., 0.],
+                [0., 3.],
+                [0., 0.]]
+        masked_arr = np.ma.masked_equal(data, 0)
+        expected = [1., 3.]
+        assert_array_equal(np.ma.median(masked_arr, axis=0),
+                           expected)
+
+    def test_nan(self):
+        for mask in (False, np.zeros(6, dtype=bool)):
+            dm = np.ma.array([[1, np.nan, 3], [1, 2, 3]])
+            dm.mask = mask
+
+            # scalar result
+            r = np.ma.median(dm, axis=None)
+            assert_(np.isscalar(r))
+            assert_array_equal(r, np.nan)
+            r = np.ma.median(dm.ravel(), axis=0)
+            assert_(np.isscalar(r))
+            assert_array_equal(r, np.nan)
+
+            r = np.ma.median(dm, axis=0)
+            assert_equal(type(r), MaskedArray)
+            assert_array_equal(r, [1, np.nan, 3])
+            r = np.ma.median(dm, axis=1)
+            assert_equal(type(r), MaskedArray)
+            assert_array_equal(r, [np.nan, 2])
+            r = np.ma.median(dm, axis=-1)
+            assert_equal(type(r), MaskedArray)
+            assert_array_equal(r, [np.nan, 2])
+
+        dm = np.ma.array([[1, np.nan, 3], [1, 2, 3]])
+        dm[:, 2] = np.ma.masked
+        assert_array_equal(np.ma.median(dm, axis=None), np.nan)
+        assert_array_equal(np.ma.median(dm, axis=0), [1, np.nan, 3])
+        assert_array_equal(np.ma.median(dm, axis=1), [np.nan, 1.5])
+
+    def test_out_nan(self):
+        o = np.ma.masked_array(np.zeros((4,)))
+        d = np.ma.masked_array(np.ones((3, 4)))
+        d[2, 1] = np.nan
+        d[2, 2] = np.ma.masked
+        assert_equal(np.ma.median(d, 0, out=o), o)
+        o = np.ma.masked_array(np.zeros((3,)))
+        assert_equal(np.ma.median(d, 1, out=o), o)
+        o = np.ma.masked_array(np.zeros(()))
+        assert_equal(np.ma.median(d, out=o), o)
+
+    def test_nan_behavior(self):
+        a = np.ma.masked_array(np.arange(24, dtype=float))
+        a[::3] = np.ma.masked
+        a[2] = np.nan
+        assert_array_equal(np.ma.median(a), np.nan)
+        assert_array_equal(np.ma.median(a, axis=0), np.nan)
+
+        a = np.ma.masked_array(np.arange(24, dtype=float).reshape(2, 3, 4))
+        a.mask = np.arange(a.size) % 2 == 1
+        aorig = a.copy()
+        a[1, 2, 3] = np.nan
+        a[1, 1, 2] = np.nan
+
+        # no axis
+        assert_array_equal(np.ma.median(a), np.nan)
+        assert_(np.isscalar(np.ma.median(a)))
+
+        # axis0
+        b = np.ma.median(aorig, axis=0)
+        b[2, 3] = np.nan
+        b[1, 2] = np.nan
+        assert_equal(np.ma.median(a, 0), b)
+
+        # axis1
+        b = np.ma.median(aorig, axis=1)
+        b[1, 3] = np.nan
+        b[1, 2] = np.nan
+        assert_equal(np.ma.median(a, 1), b)
+
+        # axis02
+        b = np.ma.median(aorig, axis=(0, 2))
+        b[1] = np.nan
+        b[2] = np.nan
+        assert_equal(np.ma.median(a, (0, 2)), b)
+
+    def test_ambigous_fill(self):
+        # 255 is max value, used as filler for sort
+        a = np.array([[3, 3, 255], [3, 3, 255]], dtype=np.uint8)
+        a = np.ma.masked_array(a, mask=a == 3)
+        assert_array_equal(np.ma.median(a, axis=1), 255)
+        assert_array_equal(np.ma.median(a, axis=1).mask, False)
+        assert_array_equal(np.ma.median(a, axis=0), a[0])
+        assert_array_equal(np.ma.median(a), 255)
+
+    def test_special(self):
+        for inf in [np.inf, -np.inf]:
+            a = np.array([[inf,  np.nan], [np.nan, np.nan]])
+            a = np.ma.masked_array(a, mask=np.isnan(a))
+            assert_equal(np.ma.median(a, axis=0), [inf,  np.nan])
+            assert_equal(np.ma.median(a, axis=1), [inf,  np.nan])
+            assert_equal(np.ma.median(a), inf)
+
+            a = np.array([[np.nan, np.nan, inf], [np.nan, np.nan, inf]])
+            a = np.ma.masked_array(a, mask=np.isnan(a))
+            assert_array_equal(np.ma.median(a, axis=1), inf)
+            assert_array_equal(np.ma.median(a, axis=1).mask, False)
+            assert_array_equal(np.ma.median(a, axis=0), a[0])
+            assert_array_equal(np.ma.median(a), inf)
+
+            # no mask
+            a = np.array([[inf, inf], [inf, inf]])
+            assert_equal(np.ma.median(a), inf)
+            assert_equal(np.ma.median(a, axis=0), inf)
+            assert_equal(np.ma.median(a, axis=1), inf)
+
+            a = np.array([[inf, 7, -inf, -9],
+                          [-10, np.nan, np.nan, 5],
+                          [4, np.nan, np.nan, inf]],
+                          dtype=np.float32)
+            a = np.ma.masked_array(a, mask=np.isnan(a))
+            if inf > 0:
+                assert_equal(np.ma.median(a, axis=0), [4., 7., -inf, 5.])
+                assert_equal(np.ma.median(a), 4.5)
+            else:
+                assert_equal(np.ma.median(a, axis=0), [-10., 7., -inf, -9.])
+                assert_equal(np.ma.median(a), -2.5)
+            assert_equal(np.ma.median(a, axis=1), [-1., -2.5, inf])
+
+            for i in range(0, 10):
+                for j in range(1, 10):
+                    a = np.array([([np.nan] * i) + ([inf] * j)] * 2)
+                    a = np.ma.masked_array(a, mask=np.isnan(a))
+                    assert_equal(np.ma.median(a), inf)
+                    assert_equal(np.ma.median(a, axis=1), inf)
+                    assert_equal(np.ma.median(a, axis=0),
+                                 ([np.nan] * i) + [inf] * j)
+
+    def test_empty(self):
+        # empty arrays
+        a = np.ma.masked_array(np.array([], dtype=float))
+        with suppress_warnings() as w:
+            w.record(RuntimeWarning)
+            assert_array_equal(np.ma.median(a), np.nan)
+            assert_(w.log[0].category is RuntimeWarning)
+
+        # multiple dimensions
+        a = np.ma.masked_array(np.array([], dtype=float, ndmin=3))
+        # no axis
+        with suppress_warnings() as w:
+            w.record(RuntimeWarning)
+            warnings.filterwarnings('always', '', RuntimeWarning)
+            assert_array_equal(np.ma.median(a), np.nan)
+            assert_(w.log[0].category is RuntimeWarning)
+
+        # axis 0 and 1
+        b = np.ma.masked_array(np.array([], dtype=float, ndmin=2))
+        assert_equal(np.ma.median(a, axis=0), b)
+        assert_equal(np.ma.median(a, axis=1), b)
+
+        # axis 2
+        b = np.ma.masked_array(np.array(np.nan, dtype=float, ndmin=2))
+        with warnings.catch_warnings(record=True) as w:
+            warnings.filterwarnings('always', '', RuntimeWarning)
+            assert_equal(np.ma.median(a, axis=2), b)
+            assert_(w[0].category is RuntimeWarning)
+
+    def test_object(self):
+        o = np.ma.masked_array(np.arange(7.))
+        assert_(type(np.ma.median(o.astype(object))), float)
+        o[2] = np.nan
+        assert_(type(np.ma.median(o.astype(object))), float)
+
+
+class TestCov:
+
+    def setup_method(self):
+        self.data = array(np.random.rand(12))
+
+    def test_covhelper(self):
+        x = self.data
+        # Test not mask output type is a float.
+        assert_(_covhelper(x, rowvar=True)[1].dtype, np.float32)
+        assert_(_covhelper(x, y=x, rowvar=False)[1].dtype, np.float32)
+        # Test not mask output is equal after casting to float.
+        mask = x > 0.5
+        assert_array_equal(
+            _covhelper(
+                np.ma.masked_array(x, mask), rowvar=True
+            )[1].astype(bool),
+            ~mask.reshape(1, -1),
+        )
+        assert_array_equal(
+            _covhelper(
+                np.ma.masked_array(x, mask), y=x, rowvar=False
+            )[1].astype(bool),
+            np.vstack((~mask, ~mask)),
+        )
+
+    def test_1d_without_missing(self):
+        # Test cov on 1D variable w/o missing values
+        x = self.data
+        assert_almost_equal(np.cov(x), cov(x))
+        assert_almost_equal(np.cov(x, rowvar=False), cov(x, rowvar=False))
+        assert_almost_equal(np.cov(x, rowvar=False, bias=True),
+                            cov(x, rowvar=False, bias=True))
+
+    def test_2d_without_missing(self):
+        # Test cov on 1 2D variable w/o missing values
+        x = self.data.reshape(3, 4)
+        assert_almost_equal(np.cov(x), cov(x))
+        assert_almost_equal(np.cov(x, rowvar=False), cov(x, rowvar=False))
+        assert_almost_equal(np.cov(x, rowvar=False, bias=True),
+                            cov(x, rowvar=False, bias=True))
+
+    def test_1d_with_missing(self):
+        # Test cov 1 1D variable w/missing values
+        x = self.data
+        x[-1] = masked
+        x -= x.mean()
+        nx = x.compressed()
+        assert_almost_equal(np.cov(nx), cov(x))
+        assert_almost_equal(np.cov(nx, rowvar=False), cov(x, rowvar=False))
+        assert_almost_equal(np.cov(nx, rowvar=False, bias=True),
+                            cov(x, rowvar=False, bias=True))
+        #
+        try:
+            cov(x, allow_masked=False)
+        except ValueError:
+            pass
+        #
+        # 2 1D variables w/ missing values
+        nx = x[1:-1]
+        assert_almost_equal(np.cov(nx, nx[::-1]), cov(x, x[::-1]))
+        assert_almost_equal(np.cov(nx, nx[::-1], rowvar=False),
+                            cov(x, x[::-1], rowvar=False))
+        assert_almost_equal(np.cov(nx, nx[::-1], rowvar=False, bias=True),
+                            cov(x, x[::-1], rowvar=False, bias=True))
+
+    def test_2d_with_missing(self):
+        # Test cov on 2D variable w/ missing value
+        x = self.data
+        x[-1] = masked
+        x = x.reshape(3, 4)
+        valid = np.logical_not(getmaskarray(x)).astype(int)
+        frac = np.dot(valid, valid.T)
+        xf = (x - x.mean(1)[:, None]).filled(0)
+        assert_almost_equal(cov(x),
+                            np.cov(xf) * (x.shape[1] - 1) / (frac - 1.))
+        assert_almost_equal(cov(x, bias=True),
+                            np.cov(xf, bias=True) * x.shape[1] / frac)
+        frac = np.dot(valid.T, valid)
+        xf = (x - x.mean(0)).filled(0)
+        assert_almost_equal(cov(x, rowvar=False),
+                            (np.cov(xf, rowvar=False) *
+                             (x.shape[0] - 1) / (frac - 1.)))
+        assert_almost_equal(cov(x, rowvar=False, bias=True),
+                            (np.cov(xf, rowvar=False, bias=True) *
+                             x.shape[0] / frac))
+
+
+class TestCorrcoef:
+
+    def setup_method(self):
+        self.data = array(np.random.rand(12))
+        self.data2 = array(np.random.rand(12))
+
+    def test_ddof(self):
+        # ddof raises DeprecationWarning
+        x, y = self.data, self.data2
+        expected = np.corrcoef(x)
+        expected2 = np.corrcoef(x, y)
+        with suppress_warnings() as sup:
+            warnings.simplefilter("always")
+            assert_warns(DeprecationWarning, corrcoef, x, ddof=-1)
+            sup.filter(DeprecationWarning, "bias and ddof have no effect")
+            # ddof has no or negligible effect on the function
+            assert_almost_equal(np.corrcoef(x, ddof=0), corrcoef(x, ddof=0))
+            assert_almost_equal(corrcoef(x, ddof=-1), expected)
+            assert_almost_equal(corrcoef(x, y, ddof=-1), expected2)
+            assert_almost_equal(corrcoef(x, ddof=3), expected)
+            assert_almost_equal(corrcoef(x, y, ddof=3), expected2)
+
+    def test_bias(self):
+        x, y = self.data, self.data2
+        expected = np.corrcoef(x)
+        # bias raises DeprecationWarning
+        with suppress_warnings() as sup:
+            warnings.simplefilter("always")
+            assert_warns(DeprecationWarning, corrcoef, x, y, True, False)
+            assert_warns(DeprecationWarning, corrcoef, x, y, True, True)
+            assert_warns(DeprecationWarning, corrcoef, x, bias=False)
+            sup.filter(DeprecationWarning, "bias and ddof have no effect")
+            # bias has no or negligible effect on the function
+            assert_almost_equal(corrcoef(x, bias=1), expected)
+
+    def test_1d_without_missing(self):
+        # Test cov on 1D variable w/o missing values
+        x = self.data
+        assert_almost_equal(np.corrcoef(x), corrcoef(x))
+        assert_almost_equal(np.corrcoef(x, rowvar=False),
+                            corrcoef(x, rowvar=False))
+        with suppress_warnings() as sup:
+            sup.filter(DeprecationWarning, "bias and ddof have no effect")
+            assert_almost_equal(np.corrcoef(x, rowvar=False, bias=True),
+                                corrcoef(x, rowvar=False, bias=True))
+
+    def test_2d_without_missing(self):
+        # Test corrcoef on 1 2D variable w/o missing values
+        x = self.data.reshape(3, 4)
+        assert_almost_equal(np.corrcoef(x), corrcoef(x))
+        assert_almost_equal(np.corrcoef(x, rowvar=False),
+                            corrcoef(x, rowvar=False))
+        with suppress_warnings() as sup:
+            sup.filter(DeprecationWarning, "bias and ddof have no effect")
+            assert_almost_equal(np.corrcoef(x, rowvar=False, bias=True),
+                                corrcoef(x, rowvar=False, bias=True))
+
+    def test_1d_with_missing(self):
+        # Test corrcoef 1 1D variable w/missing values
+        x = self.data
+        x[-1] = masked
+        x -= x.mean()
+        nx = x.compressed()
+        assert_almost_equal(np.corrcoef(nx), corrcoef(x))
+        assert_almost_equal(np.corrcoef(nx, rowvar=False),
+                            corrcoef(x, rowvar=False))
+        with suppress_warnings() as sup:
+            sup.filter(DeprecationWarning, "bias and ddof have no effect")
+            assert_almost_equal(np.corrcoef(nx, rowvar=False, bias=True),
+                                corrcoef(x, rowvar=False, bias=True))
+        try:
+            corrcoef(x, allow_masked=False)
+        except ValueError:
+            pass
+        # 2 1D variables w/ missing values
+        nx = x[1:-1]
+        assert_almost_equal(np.corrcoef(nx, nx[::-1]), corrcoef(x, x[::-1]))
+        assert_almost_equal(np.corrcoef(nx, nx[::-1], rowvar=False),
+                            corrcoef(x, x[::-1], rowvar=False))
+        with suppress_warnings() as sup:
+            sup.filter(DeprecationWarning, "bias and ddof have no effect")
+            # ddof and bias have no or negligible effect on the function
+            assert_almost_equal(np.corrcoef(nx, nx[::-1]),
+                                corrcoef(x, x[::-1], bias=1))
+            assert_almost_equal(np.corrcoef(nx, nx[::-1]),
+                                corrcoef(x, x[::-1], ddof=2))
+
+    def test_2d_with_missing(self):
+        # Test corrcoef on 2D variable w/ missing value
+        x = self.data
+        x[-1] = masked
+        x = x.reshape(3, 4)
+
+        test = corrcoef(x)
+        control = np.corrcoef(x)
+        assert_almost_equal(test[:-1, :-1], control[:-1, :-1])
+        with suppress_warnings() as sup:
+            sup.filter(DeprecationWarning, "bias and ddof have no effect")
+            # ddof and bias have no or negligible effect on the function
+            assert_almost_equal(corrcoef(x, ddof=-2)[:-1, :-1],
+                                control[:-1, :-1])
+            assert_almost_equal(corrcoef(x, ddof=3)[:-1, :-1],
+                                control[:-1, :-1])
+            assert_almost_equal(corrcoef(x, bias=1)[:-1, :-1],
+                                control[:-1, :-1])
+
+
+class TestPolynomial:
+    #
+    def test_polyfit(self):
+        # Tests polyfit
+        # On ndarrays
+        x = np.random.rand(10)
+        y = np.random.rand(20).reshape(-1, 2)
+        assert_almost_equal(polyfit(x, y, 3), np.polyfit(x, y, 3))
+        # ON 1D maskedarrays
+        x = x.view(MaskedArray)
+        x[0] = masked
+        y = y.view(MaskedArray)
+        y[0, 0] = y[-1, -1] = masked
+        #
+        (C, R, K, S, D) = polyfit(x, y[:, 0], 3, full=True)
+        (c, r, k, s, d) = np.polyfit(x[1:], y[1:, 0].compressed(), 3,
+                                     full=True)
+        for (a, a_) in zip((C, R, K, S, D), (c, r, k, s, d)):
+            assert_almost_equal(a, a_)
+        #
+        (C, R, K, S, D) = polyfit(x, y[:, -1], 3, full=True)
+        (c, r, k, s, d) = np.polyfit(x[1:-1], y[1:-1, -1], 3, full=True)
+        for (a, a_) in zip((C, R, K, S, D), (c, r, k, s, d)):
+            assert_almost_equal(a, a_)
+        #
+        (C, R, K, S, D) = polyfit(x, y, 3, full=True)
+        (c, r, k, s, d) = np.polyfit(x[1:-1], y[1:-1,:], 3, full=True)
+        for (a, a_) in zip((C, R, K, S, D), (c, r, k, s, d)):
+            assert_almost_equal(a, a_)
+        #
+        w = np.random.rand(10) + 1
+        wo = w.copy()
+        xs = x[1:-1]
+        ys = y[1:-1]
+        ws = w[1:-1]
+        (C, R, K, S, D) = polyfit(x, y, 3, full=True, w=w)
+        (c, r, k, s, d) = np.polyfit(xs, ys, 3, full=True, w=ws)
+        assert_equal(w, wo)
+        for (a, a_) in zip((C, R, K, S, D), (c, r, k, s, d)):
+            assert_almost_equal(a, a_)
+
+    def test_polyfit_with_masked_NaNs(self):
+        x = np.random.rand(10)
+        y = np.random.rand(20).reshape(-1, 2)
+
+        x[0] = np.nan
+        y[-1,-1] = np.nan
+        x = x.view(MaskedArray)
+        y = y.view(MaskedArray)
+        x[0] = masked
+        y[-1,-1] = masked
+
+        (C, R, K, S, D) = polyfit(x, y, 3, full=True)
+        (c, r, k, s, d) = np.polyfit(x[1:-1], y[1:-1,:], 3, full=True)
+        for (a, a_) in zip((C, R, K, S, D), (c, r, k, s, d)):
+            assert_almost_equal(a, a_)
+
+
+class TestArraySetOps:
+
+    def test_unique_onlist(self):
+        # Test unique on list
+        data = [1, 1, 1, 2, 2, 3]
+        test = unique(data, return_index=True, return_inverse=True)
+        assert_(isinstance(test[0], MaskedArray))
+        assert_equal(test[0], masked_array([1, 2, 3], mask=[0, 0, 0]))
+        assert_equal(test[1], [0, 3, 5])
+        assert_equal(test[2], [0, 0, 0, 1, 1, 2])
+
+    def test_unique_onmaskedarray(self):
+        # Test unique on masked data w/use_mask=True
+        data = masked_array([1, 1, 1, 2, 2, 3], mask=[0, 0, 1, 0, 1, 0])
+        test = unique(data, return_index=True, return_inverse=True)
+        assert_equal(test[0], masked_array([1, 2, 3, -1], mask=[0, 0, 0, 1]))
+        assert_equal(test[1], [0, 3, 5, 2])
+        assert_equal(test[2], [0, 0, 3, 1, 3, 2])
+        #
+        data.fill_value = 3
+        data = masked_array(data=[1, 1, 1, 2, 2, 3],
+                            mask=[0, 0, 1, 0, 1, 0], fill_value=3)
+        test = unique(data, return_index=True, return_inverse=True)
+        assert_equal(test[0], masked_array([1, 2, 3, -1], mask=[0, 0, 0, 1]))
+        assert_equal(test[1], [0, 3, 5, 2])
+        assert_equal(test[2], [0, 0, 3, 1, 3, 2])
+
+    def test_unique_allmasked(self):
+        # Test all masked
+        data = masked_array([1, 1, 1], mask=True)
+        test = unique(data, return_index=True, return_inverse=True)
+        assert_equal(test[0], masked_array([1, ], mask=[True]))
+        assert_equal(test[1], [0])
+        assert_equal(test[2], [0, 0, 0])
+        #
+        # Test masked
+        data = masked
+        test = unique(data, return_index=True, return_inverse=True)
+        assert_equal(test[0], masked_array(masked))
+        assert_equal(test[1], [0])
+        assert_equal(test[2], [0])
+
+    def test_ediff1d(self):
+        # Tests mediff1d
+        x = masked_array(np.arange(5), mask=[1, 0, 0, 0, 1])
+        control = array([1, 1, 1, 4], mask=[1, 0, 0, 1])
+        test = ediff1d(x)
+        assert_equal(test, control)
+        assert_equal(test.filled(0), control.filled(0))
+        assert_equal(test.mask, control.mask)
+
+    def test_ediff1d_tobegin(self):
+        # Test ediff1d w/ to_begin
+        x = masked_array(np.arange(5), mask=[1, 0, 0, 0, 1])
+        test = ediff1d(x, to_begin=masked)
+        control = array([0, 1, 1, 1, 4], mask=[1, 1, 0, 0, 1])
+        assert_equal(test, control)
+        assert_equal(test.filled(0), control.filled(0))
+        assert_equal(test.mask, control.mask)
+        #
+        test = ediff1d(x, to_begin=[1, 2, 3])
+        control = array([1, 2, 3, 1, 1, 1, 4], mask=[0, 0, 0, 1, 0, 0, 1])
+        assert_equal(test, control)
+        assert_equal(test.filled(0), control.filled(0))
+        assert_equal(test.mask, control.mask)
+
+    def test_ediff1d_toend(self):
+        # Test ediff1d w/ to_end
+        x = masked_array(np.arange(5), mask=[1, 0, 0, 0, 1])
+        test = ediff1d(x, to_end=masked)
+        control = array([1, 1, 1, 4, 0], mask=[1, 0, 0, 1, 1])
+        assert_equal(test, control)
+        assert_equal(test.filled(0), control.filled(0))
+        assert_equal(test.mask, control.mask)
+        #
+        test = ediff1d(x, to_end=[1, 2, 3])
+        control = array([1, 1, 1, 4, 1, 2, 3], mask=[1, 0, 0, 1, 0, 0, 0])
+        assert_equal(test, control)
+        assert_equal(test.filled(0), control.filled(0))
+        assert_equal(test.mask, control.mask)
+
+    def test_ediff1d_tobegin_toend(self):
+        # Test ediff1d w/ to_begin and to_end
+        x = masked_array(np.arange(5), mask=[1, 0, 0, 0, 1])
+        test = ediff1d(x, to_end=masked, to_begin=masked)
+        control = array([0, 1, 1, 1, 4, 0], mask=[1, 1, 0, 0, 1, 1])
+        assert_equal(test, control)
+        assert_equal(test.filled(0), control.filled(0))
+        assert_equal(test.mask, control.mask)
+        #
+        test = ediff1d(x, to_end=[1, 2, 3], to_begin=masked)
+        control = array([0, 1, 1, 1, 4, 1, 2, 3],
+                        mask=[1, 1, 0, 0, 1, 0, 0, 0])
+        assert_equal(test, control)
+        assert_equal(test.filled(0), control.filled(0))
+        assert_equal(test.mask, control.mask)
+
+    def test_ediff1d_ndarray(self):
+        # Test ediff1d w/ a ndarray
+        x = np.arange(5)
+        test = ediff1d(x)
+        control = array([1, 1, 1, 1], mask=[0, 0, 0, 0])
+        assert_equal(test, control)
+        assert_(isinstance(test, MaskedArray))
+        assert_equal(test.filled(0), control.filled(0))
+        assert_equal(test.mask, control.mask)
+        #
+        test = ediff1d(x, to_end=masked, to_begin=masked)
+        control = array([0, 1, 1, 1, 1, 0], mask=[1, 0, 0, 0, 0, 1])
+        assert_(isinstance(test, MaskedArray))
+        assert_equal(test.filled(0), control.filled(0))
+        assert_equal(test.mask, control.mask)
+
+    def test_intersect1d(self):
+        # Test intersect1d
+        x = array([1, 3, 3, 3], mask=[0, 0, 0, 1])
+        y = array([3, 1, 1, 1], mask=[0, 0, 0, 1])
+        test = intersect1d(x, y)
+        control = array([1, 3, -1], mask=[0, 0, 1])
+        assert_equal(test, control)
+
+    def test_setxor1d(self):
+        # Test setxor1d
+        a = array([1, 2, 5, 7, -1], mask=[0, 0, 0, 0, 1])
+        b = array([1, 2, 3, 4, 5, -1], mask=[0, 0, 0, 0, 0, 1])
+        test = setxor1d(a, b)
+        assert_equal(test, array([3, 4, 7]))
+        #
+        a = array([1, 2, 5, 7, -1], mask=[0, 0, 0, 0, 1])
+        b = [1, 2, 3, 4, 5]
+        test = setxor1d(a, b)
+        assert_equal(test, array([3, 4, 7, -1], mask=[0, 0, 0, 1]))
+        #
+        a = array([1, 2, 3])
+        b = array([6, 5, 4])
+        test = setxor1d(a, b)
+        assert_(isinstance(test, MaskedArray))
+        assert_equal(test, [1, 2, 3, 4, 5, 6])
+        #
+        a = array([1, 8, 2, 3], mask=[0, 1, 0, 0])
+        b = array([6, 5, 4, 8], mask=[0, 0, 0, 1])
+        test = setxor1d(a, b)
+        assert_(isinstance(test, MaskedArray))
+        assert_equal(test, [1, 2, 3, 4, 5, 6])
+        #
+        assert_array_equal([], setxor1d([], []))
+
+    def test_setxor1d_unique(self):
+        # Test setxor1d with assume_unique=True
+        a = array([1, 2, 5, 7, -1], mask=[0, 0, 0, 0, 1])
+        b = [1, 2, 3, 4, 5]
+        test = setxor1d(a, b, assume_unique=True)
+        assert_equal(test, array([3, 4, 7, -1], mask=[0, 0, 0, 1]))
+        #
+        a = array([1, 8, 2, 3], mask=[0, 1, 0, 0])
+        b = array([6, 5, 4, 8], mask=[0, 0, 0, 1])
+        test = setxor1d(a, b, assume_unique=True)
+        assert_(isinstance(test, MaskedArray))
+        assert_equal(test, [1, 2, 3, 4, 5, 6])
+        #
+        a = array([[1], [8], [2], [3]])
+        b = array([[6, 5], [4, 8]])
+        test = setxor1d(a, b, assume_unique=True)
+        assert_(isinstance(test, MaskedArray))
+        assert_equal(test, [1, 2, 3, 4, 5, 6])
+
+    def test_isin(self):
+        # the tests for in1d cover most of isin's behavior
+        # if in1d is removed, would need to change those tests to test
+        # isin instead.
+        a = np.arange(24).reshape([2, 3, 4])
+        mask = np.zeros([2, 3, 4])
+        mask[1, 2, 0] = 1
+        a = array(a, mask=mask)
+        b = array(data=[0, 10, 20, 30,  1,  3, 11, 22, 33],
+                  mask=[0,  1,  0,  1,  0,  1,  0,  1,  0])
+        ec = zeros((2, 3, 4), dtype=bool)
+        ec[0, 0, 0] = True
+        ec[0, 0, 1] = True
+        ec[0, 2, 3] = True
+        c = isin(a, b)
+        assert_(isinstance(c, MaskedArray))
+        assert_array_equal(c, ec)
+        #compare results of np.isin to ma.isin
+        d = np.isin(a, b[~b.mask]) & ~a.mask
+        assert_array_equal(c, d)
+
+    def test_in1d(self):
+        # Test in1d
+        a = array([1, 2, 5, 7, -1], mask=[0, 0, 0, 0, 1])
+        b = array([1, 2, 3, 4, 5, -1], mask=[0, 0, 0, 0, 0, 1])
+        test = in1d(a, b)
+        assert_equal(test, [True, True, True, False, True])
+        #
+        a = array([5, 5, 2, 1, -1], mask=[0, 0, 0, 0, 1])
+        b = array([1, 5, -1], mask=[0, 0, 1])
+        test = in1d(a, b)
+        assert_equal(test, [True, True, False, True, True])
+        #
+        assert_array_equal([], in1d([], []))
+
+    def test_in1d_invert(self):
+        # Test in1d's invert parameter
+        a = array([1, 2, 5, 7, -1], mask=[0, 0, 0, 0, 1])
+        b = array([1, 2, 3, 4, 5, -1], mask=[0, 0, 0, 0, 0, 1])
+        assert_equal(np.invert(in1d(a, b)), in1d(a, b, invert=True))
+
+        a = array([5, 5, 2, 1, -1], mask=[0, 0, 0, 0, 1])
+        b = array([1, 5, -1], mask=[0, 0, 1])
+        assert_equal(np.invert(in1d(a, b)), in1d(a, b, invert=True))
+
+        assert_array_equal([], in1d([], [], invert=True))
+
+    def test_union1d(self):
+        # Test union1d
+        a = array([1, 2, 5, 7, 5, -1], mask=[0, 0, 0, 0, 0, 1])
+        b = array([1, 2, 3, 4, 5, -1], mask=[0, 0, 0, 0, 0, 1])
+        test = union1d(a, b)
+        control = array([1, 2, 3, 4, 5, 7, -1], mask=[0, 0, 0, 0, 0, 0, 1])
+        assert_equal(test, control)
+
+        # Tests gh-10340, arguments to union1d should be
+        # flattened if they are not already 1D
+        x = array([[0, 1, 2], [3, 4, 5]], mask=[[0, 0, 0], [0, 0, 1]])
+        y = array([0, 1, 2, 3, 4], mask=[0, 0, 0, 0, 1])
+        ez = array([0, 1, 2, 3, 4, 5], mask=[0, 0, 0, 0, 0, 1])
+        z = union1d(x, y)
+        assert_equal(z, ez)
+        #
+        assert_array_equal([], union1d([], []))
+
+    def test_setdiff1d(self):
+        # Test setdiff1d
+        a = array([6, 5, 4, 7, 7, 1, 2, 1], mask=[0, 0, 0, 0, 0, 0, 0, 1])
+        b = array([2, 4, 3, 3, 2, 1, 5])
+        test = setdiff1d(a, b)
+        assert_equal(test, array([6, 7, -1], mask=[0, 0, 1]))
+        #
+        a = arange(10)
+        b = arange(8)
+        assert_equal(setdiff1d(a, b), array([8, 9]))
+        a = array([], np.uint32, mask=[])
+        assert_equal(setdiff1d(a, []).dtype, np.uint32)
+
+    def test_setdiff1d_char_array(self):
+        # Test setdiff1d_charray
+        a = np.array(['a', 'b', 'c'])
+        b = np.array(['a', 'b', 's'])
+        assert_array_equal(setdiff1d(a, b), np.array(['c']))
+
+
+class TestShapeBase:
+
+    def test_atleast_2d(self):
+        # Test atleast_2d
+        a = masked_array([0, 1, 2], mask=[0, 1, 0])
+        b = atleast_2d(a)
+        assert_equal(b.shape, (1, 3))
+        assert_equal(b.mask.shape, b.data.shape)
+        assert_equal(a.shape, (3,))
+        assert_equal(a.mask.shape, a.data.shape)
+        assert_equal(b.mask.shape, b.data.shape)
+
+    def test_shape_scalar(self):
+        # the atleast and diagflat function should work with scalars
+        # GitHub issue #3367
+        # Additionally, the atleast functions should accept multiple scalars
+        # correctly
+        b = atleast_1d(1.0)
+        assert_equal(b.shape, (1,))
+        assert_equal(b.mask.shape, b.shape)
+        assert_equal(b.data.shape, b.shape)
+
+        b = atleast_1d(1.0, 2.0)
+        for a in b:
+            assert_equal(a.shape, (1,))
+            assert_equal(a.mask.shape, a.shape)
+            assert_equal(a.data.shape, a.shape)
+
+        b = atleast_2d(1.0)
+        assert_equal(b.shape, (1, 1))
+        assert_equal(b.mask.shape, b.shape)
+        assert_equal(b.data.shape, b.shape)
+
+        b = atleast_2d(1.0, 2.0)
+        for a in b:
+            assert_equal(a.shape, (1, 1))
+            assert_equal(a.mask.shape, a.shape)
+            assert_equal(a.data.shape, a.shape)
+
+        b = atleast_3d(1.0)
+        assert_equal(b.shape, (1, 1, 1))
+        assert_equal(b.mask.shape, b.shape)
+        assert_equal(b.data.shape, b.shape)
+
+        b = atleast_3d(1.0, 2.0)
+        for a in b:
+            assert_equal(a.shape, (1, 1, 1))
+            assert_equal(a.mask.shape, a.shape)
+            assert_equal(a.data.shape, a.shape)
+
+        b = diagflat(1.0)
+        assert_equal(b.shape, (1, 1))
+        assert_equal(b.mask.shape, b.data.shape)
+
+
+class TestNDEnumerate:
+
+    def test_ndenumerate_nomasked(self):
+        ordinary = np.arange(6.).reshape((1, 3, 2))
+        empty_mask = np.zeros_like(ordinary, dtype=bool)
+        with_mask = masked_array(ordinary, mask=empty_mask)
+        assert_equal(list(np.ndenumerate(ordinary)),
+                     list(ndenumerate(ordinary)))
+        assert_equal(list(ndenumerate(ordinary)),
+                     list(ndenumerate(with_mask)))
+        assert_equal(list(ndenumerate(with_mask)),
+                     list(ndenumerate(with_mask, compressed=False)))
+
+    def test_ndenumerate_allmasked(self):
+        a = masked_all(())
+        b = masked_all((100,))
+        c = masked_all((2, 3, 4))
+        assert_equal(list(ndenumerate(a)), [])
+        assert_equal(list(ndenumerate(b)), [])
+        assert_equal(list(ndenumerate(b, compressed=False)),
+                     list(zip(np.ndindex((100,)), 100 * [masked])))
+        assert_equal(list(ndenumerate(c)), [])
+        assert_equal(list(ndenumerate(c, compressed=False)),
+                     list(zip(np.ndindex((2, 3, 4)), 2 * 3 * 4 * [masked])))
+
+    def test_ndenumerate_mixedmasked(self):
+        a = masked_array(np.arange(12).reshape((3, 4)),
+                         mask=[[1, 1, 1, 1],
+                               [1, 1, 0, 1],
+                               [0, 0, 0, 0]])
+        items = [((1, 2), 6),
+                 ((2, 0), 8), ((2, 1), 9), ((2, 2), 10), ((2, 3), 11)]
+        assert_equal(list(ndenumerate(a)), items)
+        assert_equal(len(list(ndenumerate(a, compressed=False))), a.size)
+        for coordinate, value in ndenumerate(a, compressed=False):
+            assert_equal(a[coordinate], value)
+
+
+class TestStack:
+
+    def test_stack_1d(self):
+        a = masked_array([0, 1, 2], mask=[0, 1, 0])
+        b = masked_array([9, 8, 7], mask=[1, 0, 0])
+
+        c = stack([a, b], axis=0)
+        assert_equal(c.shape, (2, 3))
+        assert_array_equal(a.mask, c[0].mask)
+        assert_array_equal(b.mask, c[1].mask)
+
+        d = vstack([a, b])
+        assert_array_equal(c.data, d.data)
+        assert_array_equal(c.mask, d.mask)
+
+        c = stack([a, b], axis=1)
+        assert_equal(c.shape, (3, 2))
+        assert_array_equal(a.mask, c[:, 0].mask)
+        assert_array_equal(b.mask, c[:, 1].mask)
+
+    def test_stack_masks(self):
+        a = masked_array([0, 1, 2], mask=True)
+        b = masked_array([9, 8, 7], mask=False)
+
+        c = stack([a, b], axis=0)
+        assert_equal(c.shape, (2, 3))
+        assert_array_equal(a.mask, c[0].mask)
+        assert_array_equal(b.mask, c[1].mask)
+
+        d = vstack([a, b])
+        assert_array_equal(c.data, d.data)
+        assert_array_equal(c.mask, d.mask)
+
+        c = stack([a, b], axis=1)
+        assert_equal(c.shape, (3, 2))
+        assert_array_equal(a.mask, c[:, 0].mask)
+        assert_array_equal(b.mask, c[:, 1].mask)
+
+    def test_stack_nd(self):
+        # 2D
+        shp = (3, 2)
+        d1 = np.random.randint(0, 10, shp)
+        d2 = np.random.randint(0, 10, shp)
+        m1 = np.random.randint(0, 2, shp).astype(bool)
+        m2 = np.random.randint(0, 2, shp).astype(bool)
+        a1 = masked_array(d1, mask=m1)
+        a2 = masked_array(d2, mask=m2)
+
+        c = stack([a1, a2], axis=0)
+        c_shp = (2,) + shp
+        assert_equal(c.shape, c_shp)
+        assert_array_equal(a1.mask, c[0].mask)
+        assert_array_equal(a2.mask, c[1].mask)
+
+        c = stack([a1, a2], axis=-1)
+        c_shp = shp + (2,)
+        assert_equal(c.shape, c_shp)
+        assert_array_equal(a1.mask, c[..., 0].mask)
+        assert_array_equal(a2.mask, c[..., 1].mask)
+
+        # 4D
+        shp = (3, 2, 4, 5,)
+        d1 = np.random.randint(0, 10, shp)
+        d2 = np.random.randint(0, 10, shp)
+        m1 = np.random.randint(0, 2, shp).astype(bool)
+        m2 = np.random.randint(0, 2, shp).astype(bool)
+        a1 = masked_array(d1, mask=m1)
+        a2 = masked_array(d2, mask=m2)
+
+        c = stack([a1, a2], axis=0)
+        c_shp = (2,) + shp
+        assert_equal(c.shape, c_shp)
+        assert_array_equal(a1.mask, c[0].mask)
+        assert_array_equal(a2.mask, c[1].mask)
+
+        c = stack([a1, a2], axis=-1)
+        c_shp = shp + (2,)
+        assert_equal(c.shape, c_shp)
+        assert_array_equal(a1.mask, c[..., 0].mask)
+        assert_array_equal(a2.mask, c[..., 1].mask)
diff --git a/venv/lib/python3.12/site-packages/numpy/ma/tests/test_mrecords.py b/venv/lib/python3.12/site-packages/numpy/ma/tests/test_mrecords.py
new file mode 100644
index 00000000..a364268a
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/ma/tests/test_mrecords.py
@@ -0,0 +1,493 @@
+# pylint: disable-msg=W0611, W0612, W0511,R0201
+"""Tests suite for mrecords.
+
+:author: Pierre Gerard-Marchant
+:contact: pierregm_at_uga_dot_edu
+
+"""
+import pickle
+
+import numpy as np
+import numpy.ma as ma
+from numpy.ma import masked, nomask
+from numpy.testing import temppath
+from numpy._core.records import (
+    recarray, fromrecords as recfromrecords, fromarrays as recfromarrays
+    )
+from numpy.ma.mrecords import (
+    MaskedRecords, mrecarray, fromarrays, fromtextfile, fromrecords,
+    addfield
+    )
+from numpy.ma.testutils import (
+    assert_, assert_equal,
+    assert_equal_records,
+    )
+
+
+class TestMRecords:
+
+    ilist = [1, 2, 3, 4, 5]
+    flist = [1.1, 2.2, 3.3, 4.4, 5.5]
+    slist = [b'one', b'two', b'three', b'four', b'five']
+    ddtype = [('a', int), ('b', float), ('c', '|S8')]
+    mask = [0, 1, 0, 0, 1]
+    base = ma.array(list(zip(ilist, flist, slist)), mask=mask, dtype=ddtype)
+
+    def test_byview(self):
+        # Test creation by view
+        base = self.base
+        mbase = base.view(mrecarray)
+        assert_equal(mbase.recordmask, base.recordmask)
+        assert_equal_records(mbase._mask, base._mask)
+        assert_(isinstance(mbase._data, recarray))
+        assert_equal_records(mbase._data, base._data.view(recarray))
+        for field in ('a', 'b', 'c'):
+            assert_equal(base[field], mbase[field])
+        assert_equal_records(mbase.view(mrecarray), mbase)
+
+    def test_get(self):
+        # Tests fields retrieval
+        base = self.base.copy()
+        mbase = base.view(mrecarray)
+        # As fields..........
+        for field in ('a', 'b', 'c'):
+            assert_equal(getattr(mbase, field), mbase[field])
+            assert_equal(base[field], mbase[field])
+        # as elements .......
+        mbase_first = mbase[0]
+        assert_(isinstance(mbase_first, mrecarray))
+        assert_equal(mbase_first.dtype, mbase.dtype)
+        assert_equal(mbase_first.tolist(), (1, 1.1, b'one'))
+        # Used to be mask, now it's recordmask
+        assert_equal(mbase_first.recordmask, nomask)
+        assert_equal(mbase_first._mask.item(), (False, False, False))
+        assert_equal(mbase_first['a'], mbase['a'][0])
+        mbase_last = mbase[-1]
+        assert_(isinstance(mbase_last, mrecarray))
+        assert_equal(mbase_last.dtype, mbase.dtype)
+        assert_equal(mbase_last.tolist(), (None, None, None))
+        # Used to be mask, now it's recordmask
+        assert_equal(mbase_last.recordmask, True)
+        assert_equal(mbase_last._mask.item(), (True, True, True))
+        assert_equal(mbase_last['a'], mbase['a'][-1])
+        assert_(mbase_last['a'] is masked)
+        # as slice ..........
+        mbase_sl = mbase[:2]
+        assert_(isinstance(mbase_sl, mrecarray))
+        assert_equal(mbase_sl.dtype, mbase.dtype)
+        # Used to be mask, now it's recordmask
+        assert_equal(mbase_sl.recordmask, [0, 1])
+        assert_equal_records(mbase_sl.mask,
+                             np.array([(False, False, False),
+                                       (True, True, True)],
+                                      dtype=mbase._mask.dtype))
+        assert_equal_records(mbase_sl, base[:2].view(mrecarray))
+        for field in ('a', 'b', 'c'):
+            assert_equal(getattr(mbase_sl, field), base[:2][field])
+
+    def test_set_fields(self):
+        # Tests setting fields.
+        base = self.base.copy()
+        mbase = base.view(mrecarray)
+        mbase = mbase.copy()
+        mbase.fill_value = (999999, 1e20, 'N/A')
+        # Change the data, the mask should be conserved
+        mbase.a._data[:] = 5
+        assert_equal(mbase['a']._data, [5, 5, 5, 5, 5])
+        assert_equal(mbase['a']._mask, [0, 1, 0, 0, 1])
+        # Change the elements, and the mask will follow
+        mbase.a = 1
+        assert_equal(mbase['a']._data, [1]*5)
+        assert_equal(ma.getmaskarray(mbase['a']), [0]*5)
+        # Use to be _mask, now it's recordmask
+        assert_equal(mbase.recordmask, [False]*5)
+        assert_equal(mbase._mask.tolist(),
+                     np.array([(0, 0, 0),
+                               (0, 1, 1),
+                               (0, 0, 0),
+                               (0, 0, 0),
+                               (0, 1, 1)],
+                              dtype=bool))
+        # Set a field to mask ........................
+        mbase.c = masked
+        # Use to be mask, and now it's still mask !
+        assert_equal(mbase.c.mask, [1]*5)
+        assert_equal(mbase.c.recordmask, [1]*5)
+        assert_equal(ma.getmaskarray(mbase['c']), [1]*5)
+        assert_equal(ma.getdata(mbase['c']), [b'N/A']*5)
+        assert_equal(mbase._mask.tolist(),
+                     np.array([(0, 0, 1),
+                               (0, 1, 1),
+                               (0, 0, 1),
+                               (0, 0, 1),
+                               (0, 1, 1)],
+                              dtype=bool))
+        # Set fields by slices .......................
+        mbase = base.view(mrecarray).copy()
+        mbase.a[3:] = 5
+        assert_equal(mbase.a, [1, 2, 3, 5, 5])
+        assert_equal(mbase.a._mask, [0, 1, 0, 0, 0])
+        mbase.b[3:] = masked
+        assert_equal(mbase.b, base['b'])
+        assert_equal(mbase.b._mask, [0, 1, 0, 1, 1])
+        # Set fields globally..........................
+        ndtype = [('alpha', '|S1'), ('num', int)]
+        data = ma.array([('a', 1), ('b', 2), ('c', 3)], dtype=ndtype)
+        rdata = data.view(MaskedRecords)
+        val = ma.array([10, 20, 30], mask=[1, 0, 0])
+
+        rdata['num'] = val
+        assert_equal(rdata.num, val)
+        assert_equal(rdata.num.mask, [1, 0, 0])
+
+    def test_set_fields_mask(self):
+        # Tests setting the mask of a field.
+        base = self.base.copy()
+        # This one has already a mask....
+        mbase = base.view(mrecarray)
+        mbase['a'][-2] = masked
+        assert_equal(mbase.a, [1, 2, 3, 4, 5])
+        assert_equal(mbase.a._mask, [0, 1, 0, 1, 1])
+        # This one has not yet
+        mbase = fromarrays([np.arange(5), np.random.rand(5)],
+                           dtype=[('a', int), ('b', float)])
+        mbase['a'][-2] = masked
+        assert_equal(mbase.a, [0, 1, 2, 3, 4])
+        assert_equal(mbase.a._mask, [0, 0, 0, 1, 0])
+
+    def test_set_mask(self):
+        base = self.base.copy()
+        mbase = base.view(mrecarray)
+        # Set the mask to True .......................
+        mbase.mask = masked
+        assert_equal(ma.getmaskarray(mbase['b']), [1]*5)
+        assert_equal(mbase['a']._mask, mbase['b']._mask)
+        assert_equal(mbase['a']._mask, mbase['c']._mask)
+        assert_equal(mbase._mask.tolist(),
+                     np.array([(1, 1, 1)]*5, dtype=bool))
+        # Delete the mask ............................
+        mbase.mask = nomask
+        assert_equal(ma.getmaskarray(mbase['c']), [0]*5)
+        assert_equal(mbase._mask.tolist(),
+                     np.array([(0, 0, 0)]*5, dtype=bool))
+
+    def test_set_mask_fromarray(self):
+        base = self.base.copy()
+        mbase = base.view(mrecarray)
+        # Sets the mask w/ an array
+        mbase.mask = [1, 0, 0, 0, 1]
+        assert_equal(mbase.a.mask, [1, 0, 0, 0, 1])
+        assert_equal(mbase.b.mask, [1, 0, 0, 0, 1])
+        assert_equal(mbase.c.mask, [1, 0, 0, 0, 1])
+        # Yay, once more !
+        mbase.mask = [0, 0, 0, 0, 1]
+        assert_equal(mbase.a.mask, [0, 0, 0, 0, 1])
+        assert_equal(mbase.b.mask, [0, 0, 0, 0, 1])
+        assert_equal(mbase.c.mask, [0, 0, 0, 0, 1])
+
+    def test_set_mask_fromfields(self):
+        mbase = self.base.copy().view(mrecarray)
+
+        nmask = np.array(
+            [(0, 1, 0), (0, 1, 0), (1, 0, 1), (1, 0, 1), (0, 0, 0)],
+            dtype=[('a', bool), ('b', bool), ('c', bool)])
+        mbase.mask = nmask
+        assert_equal(mbase.a.mask, [0, 0, 1, 1, 0])
+        assert_equal(mbase.b.mask, [1, 1, 0, 0, 0])
+        assert_equal(mbase.c.mask, [0, 0, 1, 1, 0])
+        # Reinitialize and redo
+        mbase.mask = False
+        mbase.fieldmask = nmask
+        assert_equal(mbase.a.mask, [0, 0, 1, 1, 0])
+        assert_equal(mbase.b.mask, [1, 1, 0, 0, 0])
+        assert_equal(mbase.c.mask, [0, 0, 1, 1, 0])
+
+    def test_set_elements(self):
+        base = self.base.copy()
+        # Set an element to mask .....................
+        mbase = base.view(mrecarray).copy()
+        mbase[-2] = masked
+        assert_equal(
+            mbase._mask.tolist(),
+            np.array([(0, 0, 0), (1, 1, 1), (0, 0, 0), (1, 1, 1), (1, 1, 1)],
+                     dtype=bool))
+        # Used to be mask, now it's recordmask!
+        assert_equal(mbase.recordmask, [0, 1, 0, 1, 1])
+        # Set slices .................................
+        mbase = base.view(mrecarray).copy()
+        mbase[:2] = (5, 5, 5)
+        assert_equal(mbase.a._data, [5, 5, 3, 4, 5])
+        assert_equal(mbase.a._mask, [0, 0, 0, 0, 1])
+        assert_equal(mbase.b._data, [5., 5., 3.3, 4.4, 5.5])
+        assert_equal(mbase.b._mask, [0, 0, 0, 0, 1])
+        assert_equal(mbase.c._data,
+                     [b'5', b'5', b'three', b'four', b'five'])
+        assert_equal(mbase.b._mask, [0, 0, 0, 0, 1])
+
+        mbase = base.view(mrecarray).copy()
+        mbase[:2] = masked
+        assert_equal(mbase.a._data, [1, 2, 3, 4, 5])
+        assert_equal(mbase.a._mask, [1, 1, 0, 0, 1])
+        assert_equal(mbase.b._data, [1.1, 2.2, 3.3, 4.4, 5.5])
+        assert_equal(mbase.b._mask, [1, 1, 0, 0, 1])
+        assert_equal(mbase.c._data,
+                     [b'one', b'two', b'three', b'four', b'five'])
+        assert_equal(mbase.b._mask, [1, 1, 0, 0, 1])
+
+    def test_setslices_hardmask(self):
+        # Tests setting slices w/ hardmask.
+        base = self.base.copy()
+        mbase = base.view(mrecarray)
+        mbase.harden_mask()
+        try:
+            mbase[-2:] = (5, 5, 5)
+            assert_equal(mbase.a._data, [1, 2, 3, 5, 5])
+            assert_equal(mbase.b._data, [1.1, 2.2, 3.3, 5, 5.5])
+            assert_equal(mbase.c._data,
+                         [b'one', b'two', b'three', b'5', b'five'])
+            assert_equal(mbase.a._mask, [0, 1, 0, 0, 1])
+            assert_equal(mbase.b._mask, mbase.a._mask)
+            assert_equal(mbase.b._mask, mbase.c._mask)
+        except NotImplementedError:
+            # OK, not implemented yet...
+            pass
+        except AssertionError:
+            raise
+        else:
+            raise Exception("Flexible hard masks should be supported !")
+        # Not using a tuple should crash
+        try:
+            mbase[-2:] = 3
+        except (NotImplementedError, TypeError):
+            pass
+        else:
+            raise TypeError("Should have expected a readable buffer object!")
+
+    def test_hardmask(self):
+        # Test hardmask
+        base = self.base.copy()
+        mbase = base.view(mrecarray)
+        mbase.harden_mask()
+        assert_(mbase._hardmask)
+        mbase.mask = nomask
+        assert_equal_records(mbase._mask, base._mask)
+        mbase.soften_mask()
+        assert_(not mbase._hardmask)
+        mbase.mask = nomask
+        # So, the mask of a field is no longer set to nomask...
+        assert_equal_records(mbase._mask,
+                             ma.make_mask_none(base.shape, base.dtype))
+        assert_(ma.make_mask(mbase['b']._mask) is nomask)
+        assert_equal(mbase['a']._mask, mbase['b']._mask)
+
+    def test_pickling(self):
+        # Test pickling
+        base = self.base.copy()
+        mrec = base.view(mrecarray)
+        for proto in range(2, pickle.HIGHEST_PROTOCOL + 1):
+            _ = pickle.dumps(mrec, protocol=proto)
+            mrec_ = pickle.loads(_)
+            assert_equal(mrec_.dtype, mrec.dtype)
+            assert_equal_records(mrec_._data, mrec._data)
+            assert_equal(mrec_._mask, mrec._mask)
+            assert_equal_records(mrec_._mask, mrec._mask)
+
+    def test_filled(self):
+        # Test filling the array
+        _a = ma.array([1, 2, 3], mask=[0, 0, 1], dtype=int)
+        _b = ma.array([1.1, 2.2, 3.3], mask=[0, 0, 1], dtype=float)
+        _c = ma.array(['one', 'two', 'three'], mask=[0, 0, 1], dtype='|S8')
+        ddtype = [('a', int), ('b', float), ('c', '|S8')]
+        mrec = fromarrays([_a, _b, _c], dtype=ddtype,
+                          fill_value=(99999, 99999., 'N/A'))
+        mrecfilled = mrec.filled()
+        assert_equal(mrecfilled['a'], np.array((1, 2, 99999), dtype=int))
+        assert_equal(mrecfilled['b'], np.array((1.1, 2.2, 99999.),
+                                               dtype=float))
+        assert_equal(mrecfilled['c'], np.array(('one', 'two', 'N/A'),
+                                               dtype='|S8'))
+
+    def test_tolist(self):
+        # Test tolist.
+        _a = ma.array([1, 2, 3], mask=[0, 0, 1], dtype=int)
+        _b = ma.array([1.1, 2.2, 3.3], mask=[0, 0, 1], dtype=float)
+        _c = ma.array(['one', 'two', 'three'], mask=[1, 0, 0], dtype='|S8')
+        ddtype = [('a', int), ('b', float), ('c', '|S8')]
+        mrec = fromarrays([_a, _b, _c], dtype=ddtype,
+                          fill_value=(99999, 99999., 'N/A'))
+
+        assert_equal(mrec.tolist(),
+                     [(1, 1.1, None), (2, 2.2, b'two'),
+                      (None, None, b'three')])
+
+    def test_withnames(self):
+        # Test the creation w/ format and names
+        x = mrecarray(1, formats=float, names='base')
+        x[0]['base'] = 10
+        assert_equal(x['base'][0], 10)
+
+    def test_exotic_formats(self):
+        # Test that 'exotic' formats are processed properly
+        easy = mrecarray(1, dtype=[('i', int), ('s', '|S8'), ('f', float)])
+        easy[0] = masked
+        assert_equal(easy.filled(1).item(), (1, b'1', 1.))
+
+        solo = mrecarray(1, dtype=[('f0', ' 1:
+            assert_(eq(np.concatenate((x, y), 1),
+                               concatenate((xm, ym), 1)))
+            assert_(eq(np.add.reduce(x, 1), add.reduce(x, 1)))
+            assert_(eq(np.sum(x, 1), sum(x, 1)))
+            assert_(eq(np.prod(x, 1), product(x, 1)))
+
+    def test_testCI(self):
+        # Test of conversions and indexing
+        x1 = np.array([1, 2, 4, 3])
+        x2 = array(x1, mask=[1, 0, 0, 0])
+        x3 = array(x1, mask=[0, 1, 0, 1])
+        x4 = array(x1)
+        # test conversion to strings
+        str(x2)  # raises?
+        repr(x2)  # raises?
+        assert_(eq(np.sort(x1), sort(x2, fill_value=0)))
+        # tests of indexing
+        assert_(type(x2[1]) is type(x1[1]))
+        assert_(x1[1] == x2[1])
+        assert_(x2[0] is masked)
+        assert_(eq(x1[2], x2[2]))
+        assert_(eq(x1[2:5], x2[2:5]))
+        assert_(eq(x1[:], x2[:]))
+        assert_(eq(x1[1:], x3[1:]))
+        x1[2] = 9
+        x2[2] = 9
+        assert_(eq(x1, x2))
+        x1[1:3] = 99
+        x2[1:3] = 99
+        assert_(eq(x1, x2))
+        x2[1] = masked
+        assert_(eq(x1, x2))
+        x2[1:3] = masked
+        assert_(eq(x1, x2))
+        x2[:] = x1
+        x2[1] = masked
+        assert_(allequal(getmask(x2), array([0, 1, 0, 0])))
+        x3[:] = masked_array([1, 2, 3, 4], [0, 1, 1, 0])
+        assert_(allequal(getmask(x3), array([0, 1, 1, 0])))
+        x4[:] = masked_array([1, 2, 3, 4], [0, 1, 1, 0])
+        assert_(allequal(getmask(x4), array([0, 1, 1, 0])))
+        assert_(allequal(x4, array([1, 2, 3, 4])))
+        x1 = np.arange(5) * 1.0
+        x2 = masked_values(x1, 3.0)
+        assert_(eq(x1, x2))
+        assert_(allequal(array([0, 0, 0, 1, 0], MaskType), x2.mask))
+        assert_(eq(3.0, x2.fill_value))
+        x1 = array([1, 'hello', 2, 3], object)
+        x2 = np.array([1, 'hello', 2, 3], object)
+        s1 = x1[1]
+        s2 = x2[1]
+        assert_equal(type(s2), str)
+        assert_equal(type(s1), str)
+        assert_equal(s1, s2)
+        assert_(x1[1:1].shape == (0,))
+
+    def test_testCopySize(self):
+        # Tests of some subtle points of copying and sizing.
+        n = [0, 0, 1, 0, 0]
+        m = make_mask(n)
+        m2 = make_mask(m)
+        assert_(m is m2)
+        m3 = make_mask(m, copy=True)
+        assert_(m is not m3)
+
+        x1 = np.arange(5)
+        y1 = array(x1, mask=m)
+        assert_(y1._data is not x1)
+        assert_(allequal(x1, y1._data))
+        assert_(y1._mask is m)
+
+        y1a = array(y1, copy=0)
+        # For copy=False, one might expect that the array would just
+        # passed on, i.e., that it would be "is" instead of "==".
+        # See gh-4043 for discussion.
+        assert_(y1a._mask.__array_interface__ ==
+                y1._mask.__array_interface__)
+
+        y2 = array(x1, mask=m3, copy=0)
+        assert_(y2._mask is m3)
+        assert_(y2[2] is masked)
+        y2[2] = 9
+        assert_(y2[2] is not masked)
+        assert_(y2._mask is m3)
+        assert_(allequal(y2.mask, 0))
+
+        y2a = array(x1, mask=m, copy=1)
+        assert_(y2a._mask is not m)
+        assert_(y2a[2] is masked)
+        y2a[2] = 9
+        assert_(y2a[2] is not masked)
+        assert_(y2a._mask is not m)
+        assert_(allequal(y2a.mask, 0))
+
+        y3 = array(x1 * 1.0, mask=m)
+        assert_(filled(y3).dtype is (x1 * 1.0).dtype)
+
+        x4 = arange(4)
+        x4[2] = masked
+        y4 = resize(x4, (8,))
+        assert_(eq(concatenate([x4, x4]), y4))
+        assert_(eq(getmask(y4), [0, 0, 1, 0, 0, 0, 1, 0]))
+        y5 = repeat(x4, (2, 2, 2, 2), axis=0)
+        assert_(eq(y5, [0, 0, 1, 1, 2, 2, 3, 3]))
+        y6 = repeat(x4, 2, axis=0)
+        assert_(eq(y5, y6))
+
+    def test_testPut(self):
+        # Test of put
+        d = arange(5)
+        n = [0, 0, 0, 1, 1]
+        m = make_mask(n)
+        m2 = m.copy()
+        x = array(d, mask=m)
+        assert_(x[3] is masked)
+        assert_(x[4] is masked)
+        x[[1, 4]] = [10, 40]
+        assert_(x._mask is m)
+        assert_(x[3] is masked)
+        assert_(x[4] is not masked)
+        assert_(eq(x, [0, 10, 2, -1, 40]))
+
+        x = array(d, mask=m2, copy=True)
+        x.put([0, 1, 2], [-1, 100, 200])
+        assert_(x._mask is not m2)
+        assert_(x[3] is masked)
+        assert_(x[4] is masked)
+        assert_(eq(x, [-1, 100, 200, 0, 0]))
+
+    def test_testPut2(self):
+        # Test of put
+        d = arange(5)
+        x = array(d, mask=[0, 0, 0, 0, 0])
+        z = array([10, 40], mask=[1, 0])
+        assert_(x[2] is not masked)
+        assert_(x[3] is not masked)
+        x[2:4] = z
+        assert_(x[2] is masked)
+        assert_(x[3] is not masked)
+        assert_(eq(x, [0, 1, 10, 40, 4]))
+
+        d = arange(5)
+        x = array(d, mask=[0, 0, 0, 0, 0])
+        y = x[2:4]
+        z = array([10, 40], mask=[1, 0])
+        assert_(x[2] is not masked)
+        assert_(x[3] is not masked)
+        y[:] = z
+        assert_(y[0] is masked)
+        assert_(y[1] is not masked)
+        assert_(eq(y, [10, 40]))
+        assert_(x[2] is masked)
+        assert_(x[3] is not masked)
+        assert_(eq(x, [0, 1, 10, 40, 4]))
+
+    def test_testMaPut(self):
+        (x, y, a10, m1, m2, xm, ym, z, zm, xf, s) = self.d
+        m = [1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 1]
+        i = np.nonzero(m)[0]
+        put(ym, i, zm)
+        assert_(all(take(ym, i, axis=0) == zm))
+
+    def test_testOddFeatures(self):
+        # Test of other odd features
+        x = arange(20)
+        x = x.reshape(4, 5)
+        x.flat[5] = 12
+        assert_(x[1, 0] == 12)
+        z = x + 10j * x
+        assert_(eq(z.real, x))
+        assert_(eq(z.imag, 10 * x))
+        assert_(eq((z * conjugate(z)).real, 101 * x * x))
+        z.imag[...] = 0.0
+
+        x = arange(10)
+        x[3] = masked
+        assert_(str(x[3]) == str(masked))
+        c = x >= 8
+        assert_(count(where(c, masked, masked)) == 0)
+        assert_(shape(where(c, masked, masked)) == c.shape)
+        z = where(c, x, masked)
+        assert_(z.dtype is x.dtype)
+        assert_(z[3] is masked)
+        assert_(z[4] is masked)
+        assert_(z[7] is masked)
+        assert_(z[8] is not masked)
+        assert_(z[9] is not masked)
+        assert_(eq(x, z))
+        z = where(c, masked, x)
+        assert_(z.dtype is x.dtype)
+        assert_(z[3] is masked)
+        assert_(z[4] is not masked)
+        assert_(z[7] is not masked)
+        assert_(z[8] is masked)
+        assert_(z[9] is masked)
+        z = masked_where(c, x)
+        assert_(z.dtype is x.dtype)
+        assert_(z[3] is masked)
+        assert_(z[4] is not masked)
+        assert_(z[7] is not masked)
+        assert_(z[8] is masked)
+        assert_(z[9] is masked)
+        assert_(eq(x, z))
+        x = array([1., 2., 3., 4., 5.])
+        c = array([1, 1, 1, 0, 0])
+        x[2] = masked
+        z = where(c, x, -x)
+        assert_(eq(z, [1., 2., 0., -4., -5]))
+        c[0] = masked
+        z = where(c, x, -x)
+        assert_(eq(z, [1., 2., 0., -4., -5]))
+        assert_(z[0] is masked)
+        assert_(z[1] is not masked)
+        assert_(z[2] is masked)
+        assert_(eq(masked_where(greater(x, 2), x), masked_greater(x, 2)))
+        assert_(eq(masked_where(greater_equal(x, 2), x),
+                   masked_greater_equal(x, 2)))
+        assert_(eq(masked_where(less(x, 2), x), masked_less(x, 2)))
+        assert_(eq(masked_where(less_equal(x, 2), x), masked_less_equal(x, 2)))
+        assert_(eq(masked_where(not_equal(x, 2), x), masked_not_equal(x, 2)))
+        assert_(eq(masked_where(equal(x, 2), x), masked_equal(x, 2)))
+        assert_(eq(masked_where(not_equal(x, 2), x), masked_not_equal(x, 2)))
+        assert_(eq(masked_inside(list(range(5)), 1, 3), [0, 199, 199, 199, 4]))
+        assert_(eq(masked_outside(list(range(5)), 1, 3), [199, 1, 2, 3, 199]))
+        assert_(eq(masked_inside(array(list(range(5)),
+                                       mask=[1, 0, 0, 0, 0]), 1, 3).mask,
+                   [1, 1, 1, 1, 0]))
+        assert_(eq(masked_outside(array(list(range(5)),
+                                        mask=[0, 1, 0, 0, 0]), 1, 3).mask,
+                   [1, 1, 0, 0, 1]))
+        assert_(eq(masked_equal(array(list(range(5)),
+                                      mask=[1, 0, 0, 0, 0]), 2).mask,
+                   [1, 0, 1, 0, 0]))
+        assert_(eq(masked_not_equal(array([2, 2, 1, 2, 1],
+                                          mask=[1, 0, 0, 0, 0]), 2).mask,
+                   [1, 0, 1, 0, 1]))
+        assert_(eq(masked_where([1, 1, 0, 0, 0], [1, 2, 3, 4, 5]),
+                   [99, 99, 3, 4, 5]))
+        atest = ones((10, 10, 10), dtype=np.float32)
+        btest = zeros(atest.shape, MaskType)
+        ctest = masked_where(btest, atest)
+        assert_(eq(atest, ctest))
+        z = choose(c, (-x, x))
+        assert_(eq(z, [1., 2., 0., -4., -5]))
+        assert_(z[0] is masked)
+        assert_(z[1] is not masked)
+        assert_(z[2] is masked)
+        x = arange(6)
+        x[5] = masked
+        y = arange(6) * 10
+        y[2] = masked
+        c = array([1, 1, 1, 0, 0, 0], mask=[1, 0, 0, 0, 0, 0])
+        cm = c.filled(1)
+        z = where(c, x, y)
+        zm = where(cm, x, y)
+        assert_(eq(z, zm))
+        assert_(getmask(zm) is nomask)
+        assert_(eq(zm, [0, 1, 2, 30, 40, 50]))
+        z = where(c, masked, 1)
+        assert_(eq(z, [99, 99, 99, 1, 1, 1]))
+        z = where(c, 1, masked)
+        assert_(eq(z, [99, 1, 1, 99, 99, 99]))
+
+    def test_testMinMax2(self):
+        # Test of minimum, maximum.
+        assert_(eq(minimum([1, 2, 3], [4, 0, 9]), [1, 0, 3]))
+        assert_(eq(maximum([1, 2, 3], [4, 0, 9]), [4, 2, 9]))
+        x = arange(5)
+        y = arange(5) - 2
+        x[3] = masked
+        y[0] = masked
+        assert_(eq(minimum(x, y), where(less(x, y), x, y)))
+        assert_(eq(maximum(x, y), where(greater(x, y), x, y)))
+        assert_(minimum.reduce(x) == 0)
+        assert_(maximum.reduce(x) == 4)
+
+    def test_testTakeTransposeInnerOuter(self):
+        # Test of take, transpose, inner, outer products
+        x = arange(24)
+        y = np.arange(24)
+        x[5:6] = masked
+        x = x.reshape(2, 3, 4)
+        y = y.reshape(2, 3, 4)
+        assert_(eq(np.transpose(y, (2, 0, 1)), transpose(x, (2, 0, 1))))
+        assert_(eq(np.take(y, (2, 0, 1), 1), take(x, (2, 0, 1), 1)))
+        assert_(eq(np.inner(filled(x, 0), filled(y, 0)),
+                   inner(x, y)))
+        assert_(eq(np.outer(filled(x, 0), filled(y, 0)),
+                   outer(x, y)))
+        y = array(['abc', 1, 'def', 2, 3], object)
+        y[2] = masked
+        t = take(y, [0, 3, 4])
+        assert_(t[0] == 'abc')
+        assert_(t[1] == 2)
+        assert_(t[2] == 3)
+
+    def test_testInplace(self):
+        # Test of inplace operations and rich comparisons
+        y = arange(10)
+
+        x = arange(10)
+        xm = arange(10)
+        xm[2] = masked
+        x += 1
+        assert_(eq(x, y + 1))
+        xm += 1
+        assert_(eq(x, y + 1))
+
+        x = arange(10)
+        xm = arange(10)
+        xm[2] = masked
+        x -= 1
+        assert_(eq(x, y - 1))
+        xm -= 1
+        assert_(eq(xm, y - 1))
+
+        x = arange(10) * 1.0
+        xm = arange(10) * 1.0
+        xm[2] = masked
+        x *= 2.0
+        assert_(eq(x, y * 2))
+        xm *= 2.0
+        assert_(eq(xm, y * 2))
+
+        x = arange(10) * 2
+        xm = arange(10)
+        xm[2] = masked
+        x //= 2
+        assert_(eq(x, y))
+        xm //= 2
+        assert_(eq(x, y))
+
+        x = arange(10) * 1.0
+        xm = arange(10) * 1.0
+        xm[2] = masked
+        x /= 2.0
+        assert_(eq(x, y / 2.0))
+        xm /= arange(10)
+        assert_(eq(xm, ones((10,))))
+
+        x = arange(10).astype(np.float32)
+        xm = arange(10)
+        xm[2] = masked
+        x += 1.
+        assert_(eq(x, y + 1.))
+
+    def test_testPickle(self):
+        # Test of pickling
+        x = arange(12)
+        x[4:10:2] = masked
+        x = x.reshape(4, 3)
+        for proto in range(2, pickle.HIGHEST_PROTOCOL + 1):
+            s = pickle.dumps(x, protocol=proto)
+            y = pickle.loads(s)
+            assert_(eq(x, y))
+
+    def test_testMasked(self):
+        # Test of masked element
+        xx = arange(6)
+        xx[1] = masked
+        assert_(str(masked) == '--')
+        assert_(xx[1] is masked)
+        assert_equal(filled(xx[1], 0), 0)
+
+    def test_testAverage1(self):
+        # Test of average.
+        ott = array([0., 1., 2., 3.], mask=[1, 0, 0, 0])
+        assert_(eq(2.0, average(ott, axis=0)))
+        assert_(eq(2.0, average(ott, weights=[1., 1., 2., 1.])))
+        result, wts = average(ott, weights=[1., 1., 2., 1.], returned=True)
+        assert_(eq(2.0, result))
+        assert_(wts == 4.0)
+        ott[:] = masked
+        assert_(average(ott, axis=0) is masked)
+        ott = array([0., 1., 2., 3.], mask=[1, 0, 0, 0])
+        ott = ott.reshape(2, 2)
+        ott[:, 1] = masked
+        assert_(eq(average(ott, axis=0), [2.0, 0.0]))
+        assert_(average(ott, axis=1)[0] is masked)
+        assert_(eq([2., 0.], average(ott, axis=0)))
+        result, wts = average(ott, axis=0, returned=True)
+        assert_(eq(wts, [1., 0.]))
+
+    def test_testAverage2(self):
+        # More tests of average.
+        w1 = [0, 1, 1, 1, 1, 0]
+        w2 = [[0, 1, 1, 1, 1, 0], [1, 0, 0, 0, 0, 1]]
+        x = arange(6)
+        assert_(allclose(average(x, axis=0), 2.5))
+        assert_(allclose(average(x, axis=0, weights=w1), 2.5))
+        y = array([arange(6), 2.0 * arange(6)])
+        assert_(allclose(average(y, None),
+                                 np.add.reduce(np.arange(6)) * 3. / 12.))
+        assert_(allclose(average(y, axis=0), np.arange(6) * 3. / 2.))
+        assert_(allclose(average(y, axis=1),
+                                 [average(x, axis=0), average(x, axis=0)*2.0]))
+        assert_(allclose(average(y, None, weights=w2), 20. / 6.))
+        assert_(allclose(average(y, axis=0, weights=w2),
+                                 [0., 1., 2., 3., 4., 10.]))
+        assert_(allclose(average(y, axis=1),
+                                 [average(x, axis=0), average(x, axis=0)*2.0]))
+        m1 = zeros(6)
+        m2 = [0, 0, 1, 1, 0, 0]
+        m3 = [[0, 0, 1, 1, 0, 0], [0, 1, 1, 1, 1, 0]]
+        m4 = ones(6)
+        m5 = [0, 1, 1, 1, 1, 1]
+        assert_(allclose(average(masked_array(x, m1), axis=0), 2.5))
+        assert_(allclose(average(masked_array(x, m2), axis=0), 2.5))
+        assert_(average(masked_array(x, m4), axis=0) is masked)
+        assert_equal(average(masked_array(x, m5), axis=0), 0.0)
+        assert_equal(count(average(masked_array(x, m4), axis=0)), 0)
+        z = masked_array(y, m3)
+        assert_(allclose(average(z, None), 20. / 6.))
+        assert_(allclose(average(z, axis=0),
+                                 [0., 1., 99., 99., 4.0, 7.5]))
+        assert_(allclose(average(z, axis=1), [2.5, 5.0]))
+        assert_(allclose(average(z, axis=0, weights=w2),
+                                 [0., 1., 99., 99., 4.0, 10.0]))
+
+        a = arange(6)
+        b = arange(6) * 3
+        r1, w1 = average([[a, b], [b, a]], axis=1, returned=True)
+        assert_equal(shape(r1), shape(w1))
+        assert_equal(r1.shape, w1.shape)
+        r2, w2 = average(ones((2, 2, 3)), axis=0, weights=[3, 1], returned=True)
+        assert_equal(shape(w2), shape(r2))
+        r2, w2 = average(ones((2, 2, 3)), returned=True)
+        assert_equal(shape(w2), shape(r2))
+        r2, w2 = average(ones((2, 2, 3)), weights=ones((2, 2, 3)), returned=True)
+        assert_(shape(w2) == shape(r2))
+        a2d = array([[1, 2], [0, 4]], float)
+        a2dm = masked_array(a2d, [[0, 0], [1, 0]])
+        a2da = average(a2d, axis=0)
+        assert_(eq(a2da, [0.5, 3.0]))
+        a2dma = average(a2dm, axis=0)
+        assert_(eq(a2dma, [1.0, 3.0]))
+        a2dma = average(a2dm, axis=None)
+        assert_(eq(a2dma, 7. / 3.))
+        a2dma = average(a2dm, axis=1)
+        assert_(eq(a2dma, [1.5, 4.0]))
+
+    def test_testToPython(self):
+        assert_equal(1, int(array(1)))
+        assert_equal(1.0, float(array(1)))
+        assert_equal(1, int(array([[[1]]])))
+        assert_equal(1.0, float(array([[1]])))
+        assert_raises(TypeError, float, array([1, 1]))
+        assert_raises(ValueError, bool, array([0, 1]))
+        assert_raises(ValueError, bool, array([0, 0], mask=[0, 1]))
+
+    def test_testScalarArithmetic(self):
+        xm = array(0, mask=1)
+        #TODO FIXME: Find out what the following raises a warning in r8247
+        with np.errstate(divide='ignore'):
+            assert_((1 / array(0)).mask)
+        assert_((1 + xm).mask)
+        assert_((-xm).mask)
+        assert_((-xm).mask)
+        assert_(maximum(xm, xm).mask)
+        assert_(minimum(xm, xm).mask)
+        assert_(xm.filled().dtype is xm._data.dtype)
+        x = array(0, mask=0)
+        assert_(x.filled() == x._data)
+        assert_equal(str(xm), str(masked_print_option))
+
+    def test_testArrayMethods(self):
+        a = array([1, 3, 2])
+        assert_(eq(a.any(), a._data.any()))
+        assert_(eq(a.all(), a._data.all()))
+        assert_(eq(a.argmax(), a._data.argmax()))
+        assert_(eq(a.argmin(), a._data.argmin()))
+        assert_(eq(a.choose(0, 1, 2, 3, 4),
+                           a._data.choose(0, 1, 2, 3, 4)))
+        assert_(eq(a.compress([1, 0, 1]), a._data.compress([1, 0, 1])))
+        assert_(eq(a.conj(), a._data.conj()))
+        assert_(eq(a.conjugate(), a._data.conjugate()))
+        m = array([[1, 2], [3, 4]])
+        assert_(eq(m.diagonal(), m._data.diagonal()))
+        assert_(eq(a.sum(), a._data.sum()))
+        assert_(eq(a.take([1, 2]), a._data.take([1, 2])))
+        assert_(eq(m.transpose(), m._data.transpose()))
+
+    def test_testArrayAttributes(self):
+        a = array([1, 3, 2])
+        assert_equal(a.ndim, 1)
+
+    def test_testAPI(self):
+        assert_(not [m for m in dir(np.ndarray)
+                     if m not in dir(MaskedArray) and
+                     not m.startswith('_')])
+
+    def test_testSingleElementSubscript(self):
+        a = array([1, 3, 2])
+        b = array([1, 3, 2], mask=[1, 0, 1])
+        assert_equal(a[0].shape, ())
+        assert_equal(b[0].shape, ())
+        assert_equal(b[1].shape, ())
+
+    def test_assignment_by_condition(self):
+        # Test for gh-18951
+        a = array([1, 2, 3, 4], mask=[1, 0, 1, 0])
+        c = a >= 3
+        a[c] = 5
+        assert_(a[2] is masked)
+
+    def test_assignment_by_condition_2(self):
+        # gh-19721
+        a = masked_array([0, 1], mask=[False, False])
+        b = masked_array([0, 1], mask=[True, True])
+        mask = a < 1
+        b[mask] = a[mask]
+        expected_mask = [False, True]
+        assert_equal(b.mask, expected_mask)
+
+
+class TestUfuncs:
+    def setup_method(self):
+        self.d = (array([1.0, 0, -1, pi / 2] * 2, mask=[0, 1] + [0] * 6),
+                  array([1.0, 0, -1, pi / 2] * 2, mask=[1, 0] + [0] * 6),)
+
+    def test_testUfuncRegression(self):
+        f_invalid_ignore = [
+            'sqrt', 'arctanh', 'arcsin', 'arccos',
+            'arccosh', 'arctanh', 'log', 'log10', 'divide',
+            'true_divide', 'floor_divide', 'remainder', 'fmod']
+        for f in ['sqrt', 'log', 'log10', 'exp', 'conjugate',
+                  'sin', 'cos', 'tan',
+                  'arcsin', 'arccos', 'arctan',
+                  'sinh', 'cosh', 'tanh',
+                  'arcsinh',
+                  'arccosh',
+                  'arctanh',
+                  'absolute', 'fabs', 'negative',
+                  'floor', 'ceil',
+                  'logical_not',
+                  'add', 'subtract', 'multiply',
+                  'divide', 'true_divide', 'floor_divide',
+                  'remainder', 'fmod', 'hypot', 'arctan2',
+                  'equal', 'not_equal', 'less_equal', 'greater_equal',
+                  'less', 'greater',
+                  'logical_and', 'logical_or', 'logical_xor']:
+            try:
+                uf = getattr(umath, f)
+            except AttributeError:
+                uf = getattr(fromnumeric, f)
+            mf = getattr(np.ma, f)
+            args = self.d[:uf.nin]
+            with np.errstate():
+                if f in f_invalid_ignore:
+                    np.seterr(invalid='ignore')
+                if f in ['arctanh', 'log', 'log10']:
+                    np.seterr(divide='ignore')
+                ur = uf(*args)
+                mr = mf(*args)
+            assert_(eq(ur.filled(0), mr.filled(0), f))
+            assert_(eqmask(ur.mask, mr.mask))
+
+    def test_reduce(self):
+        a = self.d[0]
+        assert_(not alltrue(a, axis=0))
+        assert_(sometrue(a, axis=0))
+        assert_equal(sum(a[:3], axis=0), 0)
+        assert_equal(product(a, axis=0), 0)
+
+    def test_minmax(self):
+        a = arange(1, 13).reshape(3, 4)
+        amask = masked_where(a < 5, a)
+        assert_equal(amask.max(), a.max())
+        assert_equal(amask.min(), 5)
+        assert_((amask.max(0) == a.max(0)).all())
+        assert_((amask.min(0) == [5, 6, 7, 8]).all())
+        assert_(amask.max(1)[0].mask)
+        assert_(amask.min(1)[0].mask)
+
+    def test_nonzero(self):
+        for t in "?bhilqpBHILQPfdgFDGO":
+            x = array([1, 0, 2, 0], mask=[0, 0, 1, 1])
+            assert_(eq(nonzero(x), [0]))
+
+
+class TestArrayMethods:
+
+    def setup_method(self):
+        x = np.array([8.375, 7.545, 8.828, 8.5, 1.757, 5.928,
+                      8.43, 7.78, 9.865, 5.878, 8.979, 4.732,
+                      3.012, 6.022, 5.095, 3.116, 5.238, 3.957,
+                      6.04, 9.63, 7.712, 3.382, 4.489, 6.479,
+                      7.189, 9.645, 5.395, 4.961, 9.894, 2.893,
+                      7.357, 9.828, 6.272, 3.758, 6.693, 0.993])
+        X = x.reshape(6, 6)
+        XX = x.reshape(3, 2, 2, 3)
+
+        m = np.array([0, 1, 0, 1, 0, 0,
+                      1, 0, 1, 1, 0, 1,
+                      0, 0, 0, 1, 0, 1,
+                      0, 0, 0, 1, 1, 1,
+                      1, 0, 0, 1, 0, 0,
+                      0, 0, 1, 0, 1, 0])
+        mx = array(data=x, mask=m)
+        mX = array(data=X, mask=m.reshape(X.shape))
+        mXX = array(data=XX, mask=m.reshape(XX.shape))
+
+        self.d = (x, X, XX, m, mx, mX, mXX)
+
+    def test_trace(self):
+        (x, X, XX, m, mx, mX, mXX,) = self.d
+        mXdiag = mX.diagonal()
+        assert_equal(mX.trace(), mX.diagonal().compressed().sum())
+        assert_(eq(mX.trace(),
+                           X.trace() - sum(mXdiag.mask * X.diagonal(),
+                                           axis=0)))
+
+    def test_clip(self):
+        (x, X, XX, m, mx, mX, mXX,) = self.d
+        clipped = mx.clip(2, 8)
+        assert_(eq(clipped.mask, mx.mask))
+        assert_(eq(clipped._data, x.clip(2, 8)))
+        assert_(eq(clipped._data, mx._data.clip(2, 8)))
+
+    def test_ptp(self):
+        (x, X, XX, m, mx, mX, mXX,) = self.d
+        (n, m) = X.shape
+        # print(type(mx), mx.compressed())
+        # raise Exception()
+        assert_equal(mx.ptp(), np.ptp(mx.compressed()))
+        rows = np.zeros(n, np.float64)
+        cols = np.zeros(m, np.float64)
+        for k in range(m):
+            cols[k] = np.ptp(mX[:, k].compressed())
+        for k in range(n):
+            rows[k] = np.ptp(mX[k].compressed())
+        assert_(eq(mX.ptp(0), cols))
+        assert_(eq(mX.ptp(1), rows))
+
+    def test_swapaxes(self):
+        (x, X, XX, m, mx, mX, mXX,) = self.d
+        mXswapped = mX.swapaxes(0, 1)
+        assert_(eq(mXswapped[-1], mX[:, -1]))
+        mXXswapped = mXX.swapaxes(0, 2)
+        assert_equal(mXXswapped.shape, (2, 2, 3, 3))
+
+    def test_cumprod(self):
+        (x, X, XX, m, mx, mX, mXX,) = self.d
+        mXcp = mX.cumprod(0)
+        assert_(eq(mXcp._data, mX.filled(1).cumprod(0)))
+        mXcp = mX.cumprod(1)
+        assert_(eq(mXcp._data, mX.filled(1).cumprod(1)))
+
+    def test_cumsum(self):
+        (x, X, XX, m, mx, mX, mXX,) = self.d
+        mXcp = mX.cumsum(0)
+        assert_(eq(mXcp._data, mX.filled(0).cumsum(0)))
+        mXcp = mX.cumsum(1)
+        assert_(eq(mXcp._data, mX.filled(0).cumsum(1)))
+
+    def test_varstd(self):
+        (x, X, XX, m, mx, mX, mXX,) = self.d
+        assert_(eq(mX.var(axis=None), mX.compressed().var()))
+        assert_(eq(mX.std(axis=None), mX.compressed().std()))
+        assert_(eq(mXX.var(axis=3).shape, XX.var(axis=3).shape))
+        assert_(eq(mX.var().shape, X.var().shape))
+        (mXvar0, mXvar1) = (mX.var(axis=0), mX.var(axis=1))
+        for k in range(6):
+            assert_(eq(mXvar1[k], mX[k].compressed().var()))
+            assert_(eq(mXvar0[k], mX[:, k].compressed().var()))
+            assert_(eq(np.sqrt(mXvar0[k]),
+                               mX[:, k].compressed().std()))
+
+
+def eqmask(m1, m2):
+    if m1 is nomask:
+        return m2 is nomask
+    if m2 is nomask:
+        return m1 is nomask
+    return (m1 == m2).all()
diff --git a/venv/lib/python3.12/site-packages/numpy/ma/tests/test_regression.py b/venv/lib/python3.12/site-packages/numpy/ma/tests/test_regression.py
new file mode 100644
index 00000000..f4f32cc7
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/ma/tests/test_regression.py
@@ -0,0 +1,97 @@
+import numpy as np
+from numpy.testing import (
+    assert_, assert_array_equal, assert_allclose, suppress_warnings
+    )
+
+
+class TestRegression:
+    def test_masked_array_create(self):
+        # Ticket #17
+        x = np.ma.masked_array([0, 1, 2, 3, 0, 4, 5, 6],
+                               mask=[0, 0, 0, 1, 1, 1, 0, 0])
+        assert_array_equal(np.ma.nonzero(x), [[1, 2, 6, 7]])
+
+    def test_masked_array(self):
+        # Ticket #61
+        np.ma.array(1, mask=[1])
+
+    def test_mem_masked_where(self):
+        # Ticket #62
+        from numpy.ma import masked_where, MaskType
+        a = np.zeros((1, 1))
+        b = np.zeros(a.shape, MaskType)
+        c = masked_where(b, a)
+        a-c
+
+    def test_masked_array_multiply(self):
+        # Ticket #254
+        a = np.ma.zeros((4, 1))
+        a[2, 0] = np.ma.masked
+        b = np.zeros((4, 2))
+        a*b
+        b*a
+
+    def test_masked_array_repeat(self):
+        # Ticket #271
+        np.ma.array([1], mask=False).repeat(10)
+
+    def test_masked_array_repr_unicode(self):
+        # Ticket #1256
+        repr(np.ma.array("Unicode"))
+
+    def test_atleast_2d(self):
+        # Ticket #1559
+        a = np.ma.masked_array([0.0, 1.2, 3.5], mask=[False, True, False])
+        b = np.atleast_2d(a)
+        assert_(a.mask.ndim == 1)
+        assert_(b.mask.ndim == 2)
+
+    def test_set_fill_value_unicode_py3(self):
+        # Ticket #2733
+        a = np.ma.masked_array(['a', 'b', 'c'], mask=[1, 0, 0])
+        a.fill_value = 'X'
+        assert_(a.fill_value == 'X')
+
+    def test_var_sets_maskedarray_scalar(self):
+        # Issue gh-2757
+        a = np.ma.array(np.arange(5), mask=True)
+        mout = np.ma.array(-1, dtype=float)
+        a.var(out=mout)
+        assert_(mout._data == 0)
+
+    def test_ddof_corrcoef(self):
+        # See gh-3336
+        x = np.ma.masked_equal([1, 2, 3, 4, 5], 4)
+        y = np.array([2, 2.5, 3.1, 3, 5])
+        # this test can be removed after deprecation.
+        with suppress_warnings() as sup:
+            sup.filter(DeprecationWarning, "bias and ddof have no effect")
+            r0 = np.ma.corrcoef(x, y, ddof=0)
+            r1 = np.ma.corrcoef(x, y, ddof=1)
+            # ddof should not have an effect (it gets cancelled out)
+            assert_allclose(r0.data, r1.data)
+
+    def test_mask_not_backmangled(self):
+        # See gh-10314.  Test case taken from gh-3140.
+        a = np.ma.MaskedArray([1., 2.], mask=[False, False])
+        assert_(a.mask.shape == (2,))
+        b = np.tile(a, (2, 1))
+        # Check that the above no longer changes a.shape to (1, 2)
+        assert_(a.mask.shape == (2,))
+        assert_(b.shape == (2, 2))
+        assert_(b.mask.shape == (2, 2))
+
+    def test_empty_list_on_structured(self):
+        # See gh-12464. Indexing with empty list should give empty result.
+        ma = np.ma.MaskedArray([(1, 1.), (2, 2.), (3, 3.)], dtype='i4,f4')
+        assert_array_equal(ma[[]], ma[:0])
+
+    def test_masked_array_tobytes_fortran(self):
+        ma = np.ma.arange(4).reshape((2,2))
+        assert_array_equal(ma.tobytes(order='F'), ma.T.tobytes())
+
+    def test_structured_array(self):
+        # see gh-22041
+        np.ma.array((1, (b"", b"")),
+                    dtype=[("x", np.int_),
+                          ("y", [("i", np.void), ("j", np.void)])])
diff --git a/venv/lib/python3.12/site-packages/numpy/ma/tests/test_subclassing.py b/venv/lib/python3.12/site-packages/numpy/ma/tests/test_subclassing.py
new file mode 100644
index 00000000..a627245f
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/ma/tests/test_subclassing.py
@@ -0,0 +1,460 @@
+# pylint: disable-msg=W0611, W0612, W0511,R0201
+"""Tests suite for MaskedArray & subclassing.
+
+:author: Pierre Gerard-Marchant
+:contact: pierregm_at_uga_dot_edu
+:version: $Id: test_subclassing.py 3473 2007-10-29 15:18:13Z jarrod.millman $
+
+"""
+import numpy as np
+from numpy.lib.mixins import NDArrayOperatorsMixin
+from numpy.testing import assert_, assert_raises
+from numpy.ma.testutils import assert_equal
+from numpy.ma.core import (
+    array, arange, masked, MaskedArray, masked_array, log, add, hypot,
+    divide, asarray, asanyarray, nomask
+    )
+# from numpy.ma.core import (
+
+def assert_startswith(a, b):
+    # produces a better error message than assert_(a.startswith(b))
+    assert_equal(a[:len(b)], b)
+
+class SubArray(np.ndarray):
+    # Defines a generic np.ndarray subclass, that stores some metadata
+    # in the  dictionary `info`.
+    def __new__(cls,arr,info={}):
+        x = np.asanyarray(arr).view(cls)
+        x.info = info.copy()
+        return x
+
+    def __array_finalize__(self, obj):
+        super().__array_finalize__(obj)
+        self.info = getattr(obj, 'info', {}).copy()
+        return
+
+    def __add__(self, other):
+        result = super().__add__(other)
+        result.info['added'] = result.info.get('added', 0) + 1
+        return result
+
+    def __iadd__(self, other):
+        result = super().__iadd__(other)
+        result.info['iadded'] = result.info.get('iadded', 0) + 1
+        return result
+
+
+subarray = SubArray
+
+
+class SubMaskedArray(MaskedArray):
+    """Pure subclass of MaskedArray, keeping some info on subclass."""
+    def __new__(cls, info=None, **kwargs):
+        obj = super().__new__(cls, **kwargs)
+        obj._optinfo['info'] = info
+        return obj
+
+
+class MSubArray(SubArray, MaskedArray):
+
+    def __new__(cls, data, info={}, mask=nomask):
+        subarr = SubArray(data, info)
+        _data = MaskedArray.__new__(cls, data=subarr, mask=mask)
+        _data.info = subarr.info
+        return _data
+
+    @property
+    def _series(self):
+        _view = self.view(MaskedArray)
+        _view._sharedmask = False
+        return _view
+
+msubarray = MSubArray
+
+
+# Also a subclass that overrides __str__, __repr__ and __setitem__, disallowing
+# setting to non-class values (and thus np.ma.core.masked_print_option)
+# and overrides __array_wrap__, updating the info dict, to check that this
+# doesn't get destroyed by MaskedArray._update_from.  But this one also needs
+# its own iterator...
+class CSAIterator:
+    """
+    Flat iterator object that uses its own setter/getter
+    (works around ndarray.flat not propagating subclass setters/getters
+    see https://github.com/numpy/numpy/issues/4564)
+    roughly following MaskedIterator
+    """
+    def __init__(self, a):
+        self._original = a
+        self._dataiter = a.view(np.ndarray).flat
+
+    def __iter__(self):
+        return self
+
+    def __getitem__(self, indx):
+        out = self._dataiter.__getitem__(indx)
+        if not isinstance(out, np.ndarray):
+            out = out.__array__()
+        out = out.view(type(self._original))
+        return out
+
+    def __setitem__(self, index, value):
+        self._dataiter[index] = self._original._validate_input(value)
+
+    def __next__(self):
+        return next(self._dataiter).__array__().view(type(self._original))
+
+
+class ComplicatedSubArray(SubArray):
+
+    def __str__(self):
+        return f'myprefix {self.view(SubArray)} mypostfix'
+
+    def __repr__(self):
+        # Return a repr that does not start with 'name('
+        return f'<{self.__class__.__name__} {self}>'
+
+    def _validate_input(self, value):
+        if not isinstance(value, ComplicatedSubArray):
+            raise ValueError("Can only set to MySubArray values")
+        return value
+
+    def __setitem__(self, item, value):
+        # validation ensures direct assignment with ndarray or
+        # masked_print_option will fail
+        super().__setitem__(item, self._validate_input(value))
+
+    def __getitem__(self, item):
+        # ensure getter returns our own class also for scalars
+        value = super().__getitem__(item)
+        if not isinstance(value, np.ndarray):  # scalar
+            value = value.__array__().view(ComplicatedSubArray)
+        return value
+
+    @property
+    def flat(self):
+        return CSAIterator(self)
+
+    @flat.setter
+    def flat(self, value):
+        y = self.ravel()
+        y[:] = value
+
+    def __array_wrap__(self, obj, context=None, return_scalar=False):
+        obj = super().__array_wrap__(obj, context, return_scalar)
+        if context is not None and context[0] is np.multiply:
+            obj.info['multiplied'] = obj.info.get('multiplied', 0) + 1
+
+        return obj
+
+
+class WrappedArray(NDArrayOperatorsMixin):
+    """
+    Wrapping a MaskedArray rather than subclassing to test that
+    ufunc deferrals are commutative.
+    See: https://github.com/numpy/numpy/issues/15200)
+    """
+    __slots__ = ('_array', 'attrs')
+    __array_priority__ = 20
+
+    def __init__(self, array, **attrs):
+        self._array = array
+        self.attrs = attrs
+
+    def __repr__(self):
+        return f"{self.__class__.__name__}(\n{self._array}\n{self.attrs}\n)"
+
+    def __array__(self, dtype=None, copy=None):
+        return np.asarray(self._array)
+
+    def __array_ufunc__(self, ufunc, method, *inputs, **kwargs):
+        if method == '__call__':
+            inputs = [arg._array if isinstance(arg, self.__class__) else arg
+                      for arg in inputs]
+            return self.__class__(ufunc(*inputs, **kwargs), **self.attrs)
+        else:
+            return NotImplemented
+
+
+class TestSubclassing:
+    # Test suite for masked subclasses of ndarray.
+
+    def setup_method(self):
+        x = np.arange(5, dtype='float')
+        mx = msubarray(x, mask=[0, 1, 0, 0, 0])
+        self.data = (x, mx)
+
+    def test_data_subclassing(self):
+        # Tests whether the subclass is kept.
+        x = np.arange(5)
+        m = [0, 0, 1, 0, 0]
+        xsub = SubArray(x)
+        xmsub = masked_array(xsub, mask=m)
+        assert_(isinstance(xmsub, MaskedArray))
+        assert_equal(xmsub._data, xsub)
+        assert_(isinstance(xmsub._data, SubArray))
+
+    def test_maskedarray_subclassing(self):
+        # Tests subclassing MaskedArray
+        (x, mx) = self.data
+        assert_(isinstance(mx._data, subarray))
+
+    def test_masked_unary_operations(self):
+        # Tests masked_unary_operation
+        (x, mx) = self.data
+        with np.errstate(divide='ignore'):
+            assert_(isinstance(log(mx), msubarray))
+            assert_equal(log(x), np.log(x))
+
+    def test_masked_binary_operations(self):
+        # Tests masked_binary_operation
+        (x, mx) = self.data
+        # Result should be a msubarray
+        assert_(isinstance(add(mx, mx), msubarray))
+        assert_(isinstance(add(mx, x), msubarray))
+        # Result should work
+        assert_equal(add(mx, x), mx+x)
+        assert_(isinstance(add(mx, mx)._data, subarray))
+        assert_(isinstance(add.outer(mx, mx), msubarray))
+        assert_(isinstance(hypot(mx, mx), msubarray))
+        assert_(isinstance(hypot(mx, x), msubarray))
+
+    def test_masked_binary_operations2(self):
+        # Tests domained_masked_binary_operation
+        (x, mx) = self.data
+        xmx = masked_array(mx.data.__array__(), mask=mx.mask)
+        assert_(isinstance(divide(mx, mx), msubarray))
+        assert_(isinstance(divide(mx, x), msubarray))
+        assert_equal(divide(mx, mx), divide(xmx, xmx))
+
+    def test_attributepropagation(self):
+        x = array(arange(5), mask=[0]+[1]*4)
+        my = masked_array(subarray(x))
+        ym = msubarray(x)
+        #
+        z = (my+1)
+        assert_(isinstance(z, MaskedArray))
+        assert_(not isinstance(z, MSubArray))
+        assert_(isinstance(z._data, SubArray))
+        assert_equal(z._data.info, {})
+        #
+        z = (ym+1)
+        assert_(isinstance(z, MaskedArray))
+        assert_(isinstance(z, MSubArray))
+        assert_(isinstance(z._data, SubArray))
+        assert_(z._data.info['added'] > 0)
+        # Test that inplace methods from data get used (gh-4617)
+        ym += 1
+        assert_(isinstance(ym, MaskedArray))
+        assert_(isinstance(ym, MSubArray))
+        assert_(isinstance(ym._data, SubArray))
+        assert_(ym._data.info['iadded'] > 0)
+        #
+        ym._set_mask([1, 0, 0, 0, 1])
+        assert_equal(ym._mask, [1, 0, 0, 0, 1])
+        ym._series._set_mask([0, 0, 0, 0, 1])
+        assert_equal(ym._mask, [0, 0, 0, 0, 1])
+        #
+        xsub = subarray(x, info={'name':'x'})
+        mxsub = masked_array(xsub)
+        assert_(hasattr(mxsub, 'info'))
+        assert_equal(mxsub.info, xsub.info)
+
+    def test_subclasspreservation(self):
+        # Checks that masked_array(...,subok=True) preserves the class.
+        x = np.arange(5)
+        m = [0, 0, 1, 0, 0]
+        xinfo = [(i, j) for (i, j) in zip(x, m)]
+        xsub = MSubArray(x, mask=m, info={'xsub':xinfo})
+        #
+        mxsub = masked_array(xsub, subok=False)
+        assert_(not isinstance(mxsub, MSubArray))
+        assert_(isinstance(mxsub, MaskedArray))
+        assert_equal(mxsub._mask, m)
+        #
+        mxsub = asarray(xsub)
+        assert_(not isinstance(mxsub, MSubArray))
+        assert_(isinstance(mxsub, MaskedArray))
+        assert_equal(mxsub._mask, m)
+        #
+        mxsub = masked_array(xsub, subok=True)
+        assert_(isinstance(mxsub, MSubArray))
+        assert_equal(mxsub.info, xsub.info)
+        assert_equal(mxsub._mask, xsub._mask)
+        #
+        mxsub = asanyarray(xsub)
+        assert_(isinstance(mxsub, MSubArray))
+        assert_equal(mxsub.info, xsub.info)
+        assert_equal(mxsub._mask, m)
+
+    def test_subclass_items(self):
+        """test that getter and setter go via baseclass"""
+        x = np.arange(5)
+        xcsub = ComplicatedSubArray(x)
+        mxcsub = masked_array(xcsub, mask=[True, False, True, False, False])
+        # getter should  return a ComplicatedSubArray, even for single item
+        # first check we wrote ComplicatedSubArray correctly
+        assert_(isinstance(xcsub[1], ComplicatedSubArray))
+        assert_(isinstance(xcsub[1,...], ComplicatedSubArray))
+        assert_(isinstance(xcsub[1:4], ComplicatedSubArray))
+
+        # now that it propagates inside the MaskedArray
+        assert_(isinstance(mxcsub[1], ComplicatedSubArray))
+        assert_(isinstance(mxcsub[1,...].data, ComplicatedSubArray))
+        assert_(mxcsub[0] is masked)
+        assert_(isinstance(mxcsub[0,...].data, ComplicatedSubArray))
+        assert_(isinstance(mxcsub[1:4].data, ComplicatedSubArray))
+
+        # also for flattened version (which goes via MaskedIterator)
+        assert_(isinstance(mxcsub.flat[1].data, ComplicatedSubArray))
+        assert_(mxcsub.flat[0] is masked)
+        assert_(isinstance(mxcsub.flat[1:4].base, ComplicatedSubArray))
+
+        # setter should only work with ComplicatedSubArray input
+        # first check we wrote ComplicatedSubArray correctly
+        assert_raises(ValueError, xcsub.__setitem__, 1, x[4])
+        # now that it propagates inside the MaskedArray
+        assert_raises(ValueError, mxcsub.__setitem__, 1, x[4])
+        assert_raises(ValueError, mxcsub.__setitem__, slice(1, 4), x[1:4])
+        mxcsub[1] = xcsub[4]
+        mxcsub[1:4] = xcsub[1:4]
+        # also for flattened version (which goes via MaskedIterator)
+        assert_raises(ValueError, mxcsub.flat.__setitem__, 1, x[4])
+        assert_raises(ValueError, mxcsub.flat.__setitem__, slice(1, 4), x[1:4])
+        mxcsub.flat[1] = xcsub[4]
+        mxcsub.flat[1:4] = xcsub[1:4]
+
+    def test_subclass_nomask_items(self):
+        x = np.arange(5)
+        xcsub = ComplicatedSubArray(x)
+        mxcsub_nomask = masked_array(xcsub)
+
+        assert_(isinstance(mxcsub_nomask[1,...].data, ComplicatedSubArray))
+        assert_(isinstance(mxcsub_nomask[0,...].data, ComplicatedSubArray))
+
+        assert_(isinstance(mxcsub_nomask[1], ComplicatedSubArray))
+        assert_(isinstance(mxcsub_nomask[0], ComplicatedSubArray))
+
+    def test_subclass_repr(self):
+        """test that repr uses the name of the subclass
+        and 'array' for np.ndarray"""
+        x = np.arange(5)
+        mx = masked_array(x, mask=[True, False, True, False, False])
+        assert_startswith(repr(mx), 'masked_array')
+        xsub = SubArray(x)
+        mxsub = masked_array(xsub, mask=[True, False, True, False, False])
+        assert_startswith(repr(mxsub),
+            f'masked_{SubArray.__name__}(data=[--, 1, --, 3, 4]')
+
+    def test_subclass_str(self):
+        """test str with subclass that has overridden str, setitem"""
+        # first without override
+        x = np.arange(5)
+        xsub = SubArray(x)
+        mxsub = masked_array(xsub, mask=[True, False, True, False, False])
+        assert_equal(str(mxsub), '[-- 1 -- 3 4]')
+
+        xcsub = ComplicatedSubArray(x)
+        assert_raises(ValueError, xcsub.__setitem__, 0,
+                      np.ma.core.masked_print_option)
+        mxcsub = masked_array(xcsub, mask=[True, False, True, False, False])
+        assert_equal(str(mxcsub), 'myprefix [-- 1 -- 3 4] mypostfix')
+
+    def test_pure_subclass_info_preservation(self):
+        # Test that ufuncs and methods conserve extra information consistently;
+        # see gh-7122.
+        arr1 = SubMaskedArray('test', data=[1,2,3,4,5,6])
+        arr2 = SubMaskedArray(data=[0,1,2,3,4,5])
+        diff1 = np.subtract(arr1, arr2)
+        assert_('info' in diff1._optinfo)
+        assert_(diff1._optinfo['info'] == 'test')
+        diff2 = arr1 - arr2
+        assert_('info' in diff2._optinfo)
+        assert_(diff2._optinfo['info'] == 'test')
+
+
+class ArrayNoInheritance:
+    """Quantity-like class that does not inherit from ndarray"""
+    def __init__(self, data, units):
+        self.magnitude = data
+        self.units = units
+
+    def __getattr__(self, attr):
+        return getattr(self.magnitude, attr)
+
+
+def test_array_no_inheritance():
+    data_masked = np.ma.array([1, 2, 3], mask=[True, False, True])
+    data_masked_units = ArrayNoInheritance(data_masked, 'meters')
+
+    # Get the masked representation of the Quantity-like class
+    new_array = np.ma.array(data_masked_units)
+    assert_equal(data_masked.data, new_array.data)
+    assert_equal(data_masked.mask, new_array.mask)
+    # Test sharing the mask
+    data_masked.mask = [True, False, False]
+    assert_equal(data_masked.mask, new_array.mask)
+    assert_(new_array.sharedmask)
+
+    # Get the masked representation of the Quantity-like class
+    new_array = np.ma.array(data_masked_units, copy=True)
+    assert_equal(data_masked.data, new_array.data)
+    assert_equal(data_masked.mask, new_array.mask)
+    # Test that the mask is not shared when copy=True
+    data_masked.mask = [True, False, True]
+    assert_equal([True, False, False], new_array.mask)
+    assert_(not new_array.sharedmask)
+
+    # Get the masked representation of the Quantity-like class
+    new_array = np.ma.array(data_masked_units, keep_mask=False)
+    assert_equal(data_masked.data, new_array.data)
+    # The change did not affect the original mask
+    assert_equal(data_masked.mask, [True, False, True])
+    # Test that the mask is False and not shared when keep_mask=False
+    assert_(not new_array.mask)
+    assert_(not new_array.sharedmask)
+
+
+class TestClassWrapping:
+    # Test suite for classes that wrap MaskedArrays
+
+    def setup_method(self):
+        m = np.ma.masked_array([1, 3, 5], mask=[False, True, False])
+        wm = WrappedArray(m)
+        self.data = (m, wm)
+
+    def test_masked_unary_operations(self):
+        # Tests masked_unary_operation
+        (m, wm) = self.data
+        with np.errstate(divide='ignore'):
+            assert_(isinstance(np.log(wm), WrappedArray))
+
+    def test_masked_binary_operations(self):
+        # Tests masked_binary_operation
+        (m, wm) = self.data
+        # Result should be a WrappedArray
+        assert_(isinstance(np.add(wm, wm), WrappedArray))
+        assert_(isinstance(np.add(m, wm), WrappedArray))
+        assert_(isinstance(np.add(wm, m), WrappedArray))
+        # add and '+' should call the same ufunc
+        assert_equal(np.add(m, wm), m + wm)
+        assert_(isinstance(np.hypot(m, wm), WrappedArray))
+        assert_(isinstance(np.hypot(wm, m), WrappedArray))
+        # Test domained binary operations
+        assert_(isinstance(np.divide(wm, m), WrappedArray))
+        assert_(isinstance(np.divide(m, wm), WrappedArray))
+        assert_equal(np.divide(wm, m) * m, np.divide(m, m) * wm)
+        # Test broadcasting
+        m2 = np.stack([m, m])
+        assert_(isinstance(np.divide(wm, m2), WrappedArray))
+        assert_(isinstance(np.divide(m2, wm), WrappedArray))
+        assert_equal(np.divide(m2, wm), np.divide(wm, m2))
+
+    def test_mixins_have_slots(self):
+        mixin = NDArrayOperatorsMixin()
+        # Should raise an error
+        assert_raises(AttributeError, mixin.__setattr__, "not_a_real_attr", 1)
+
+        m = np.ma.masked_array([1, 3, 5], mask=[False, True, False])
+        wm = WrappedArray(m)
+        assert_raises(AttributeError, wm.__setattr__, "not_an_attr", 2)
diff --git a/venv/lib/python3.12/site-packages/numpy/ma/testutils.py b/venv/lib/python3.12/site-packages/numpy/ma/testutils.py
new file mode 100644
index 00000000..c5125604
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/ma/testutils.py
@@ -0,0 +1,292 @@
+"""Miscellaneous functions for testing masked arrays and subclasses
+
+:author: Pierre Gerard-Marchant
+:contact: pierregm_at_uga_dot_edu
+:version: $Id: testutils.py 3529 2007-11-13 08:01:14Z jarrod.millman $
+
+"""
+import operator
+
+import numpy as np
+from numpy import ndarray
+import numpy._core.umath as umath
+import numpy.testing
+from numpy.testing import (
+    assert_, assert_allclose, assert_array_almost_equal_nulp,
+    assert_raises, build_err_msg
+    )
+from .core import mask_or, getmask, masked_array, nomask, masked, filled
+
+__all__masked = [
+    'almost', 'approx', 'assert_almost_equal', 'assert_array_almost_equal',
+    'assert_array_approx_equal', 'assert_array_compare',
+    'assert_array_equal', 'assert_array_less', 'assert_close',
+    'assert_equal', 'assert_equal_records', 'assert_mask_equal',
+    'assert_not_equal', 'fail_if_array_equal',
+    ]
+
+# Include some normal test functions to avoid breaking other projects who
+# have mistakenly included them from this file. SciPy is one. That is
+# unfortunate, as some of these functions are not intended to work with
+# masked arrays. But there was no way to tell before.
+from unittest import TestCase
+__some__from_testing = [
+    'TestCase', 'assert_', 'assert_allclose', 'assert_array_almost_equal_nulp',
+    'assert_raises'
+    ]
+
+__all__ = __all__masked + __some__from_testing
+
+
+def approx(a, b, fill_value=True, rtol=1e-5, atol=1e-8):
+    """
+    Returns true if all components of a and b are equal to given tolerances.
+
+    If fill_value is True, masked values considered equal. Otherwise,
+    masked values are considered unequal.  The relative error rtol should
+    be positive and << 1.0 The absolute error atol comes into play for
+    those elements of b that are very small or zero; it says how small a
+    must be also.
+
+    """
+    m = mask_or(getmask(a), getmask(b))
+    d1 = filled(a)
+    d2 = filled(b)
+    if d1.dtype.char == "O" or d2.dtype.char == "O":
+        return np.equal(d1, d2).ravel()
+    x = filled(
+        masked_array(d1, copy=False, mask=m), fill_value
+    ).astype(np.float64)
+    y = filled(masked_array(d2, copy=False, mask=m), 1).astype(np.float64)
+    d = np.less_equal(umath.absolute(x - y), atol + rtol * umath.absolute(y))
+    return d.ravel()
+
+
+def almost(a, b, decimal=6, fill_value=True):
+    """
+    Returns True if a and b are equal up to decimal places.
+
+    If fill_value is True, masked values considered equal. Otherwise,
+    masked values are considered unequal.
+
+    """
+    m = mask_or(getmask(a), getmask(b))
+    d1 = filled(a)
+    d2 = filled(b)
+    if d1.dtype.char == "O" or d2.dtype.char == "O":
+        return np.equal(d1, d2).ravel()
+    x = filled(
+        masked_array(d1, copy=False, mask=m), fill_value
+    ).astype(np.float64)
+    y = filled(masked_array(d2, copy=False, mask=m), 1).astype(np.float64)
+    d = np.around(np.abs(x - y), decimal) <= 10.0 ** (-decimal)
+    return d.ravel()
+
+
+def _assert_equal_on_sequences(actual, desired, err_msg=''):
+    """
+    Asserts the equality of two non-array sequences.
+
+    """
+    assert_equal(len(actual), len(desired), err_msg)
+    for k in range(len(desired)):
+        assert_equal(actual[k], desired[k], f'item={k!r}\n{err_msg}')
+    return
+
+
+def assert_equal_records(a, b):
+    """
+    Asserts that two records are equal.
+
+    Pretty crude for now.
+
+    """
+    assert_equal(a.dtype, b.dtype)
+    for f in a.dtype.names:
+        (af, bf) = (operator.getitem(a, f), operator.getitem(b, f))
+        if not (af is masked) and not (bf is masked):
+            assert_equal(operator.getitem(a, f), operator.getitem(b, f))
+    return
+
+
+def assert_equal(actual, desired, err_msg=''):
+    """
+    Asserts that two items are equal.
+
+    """
+    # Case #1: dictionary .....
+    if isinstance(desired, dict):
+        if not isinstance(actual, dict):
+            raise AssertionError(repr(type(actual)))
+        assert_equal(len(actual), len(desired), err_msg)
+        for k, i in desired.items():
+            if k not in actual:
+                raise AssertionError(f"{k} not in {actual}")
+            assert_equal(actual[k], desired[k], f'key={k!r}\n{err_msg}')
+        return
+    # Case #2: lists .....
+    if isinstance(desired, (list, tuple)) and isinstance(actual, (list, tuple)):
+        return _assert_equal_on_sequences(actual, desired, err_msg='')
+    if not (isinstance(actual, ndarray) or isinstance(desired, ndarray)):
+        msg = build_err_msg([actual, desired], err_msg,)
+        if not desired == actual:
+            raise AssertionError(msg)
+        return
+    # Case #4. arrays or equivalent
+    if ((actual is masked) and not (desired is masked)) or \
+            ((desired is masked) and not (actual is masked)):
+        msg = build_err_msg([actual, desired],
+                            err_msg, header='', names=('x', 'y'))
+        raise ValueError(msg)
+    actual = np.asanyarray(actual)
+    desired = np.asanyarray(desired)
+    (actual_dtype, desired_dtype) = (actual.dtype, desired.dtype)
+    if actual_dtype.char == "S" and desired_dtype.char == "S":
+        return _assert_equal_on_sequences(actual.tolist(),
+                                          desired.tolist(),
+                                          err_msg='')
+    return assert_array_equal(actual, desired, err_msg)
+
+
+def fail_if_equal(actual, desired, err_msg='',):
+    """
+    Raises an assertion error if two items are equal.
+
+    """
+    if isinstance(desired, dict):
+        if not isinstance(actual, dict):
+            raise AssertionError(repr(type(actual)))
+        fail_if_equal(len(actual), len(desired), err_msg)
+        for k, i in desired.items():
+            if k not in actual:
+                raise AssertionError(repr(k))
+            fail_if_equal(actual[k], desired[k], f'key={k!r}\n{err_msg}')
+        return
+    if isinstance(desired, (list, tuple)) and isinstance(actual, (list, tuple)):
+        fail_if_equal(len(actual), len(desired), err_msg)
+        for k in range(len(desired)):
+            fail_if_equal(actual[k], desired[k], f'item={k!r}\n{err_msg}')
+        return
+    if isinstance(actual, np.ndarray) or isinstance(desired, np.ndarray):
+        return fail_if_array_equal(actual, desired, err_msg)
+    msg = build_err_msg([actual, desired], err_msg)
+    if not desired != actual:
+        raise AssertionError(msg)
+
+
+assert_not_equal = fail_if_equal
+
+
+def assert_almost_equal(actual, desired, decimal=7, err_msg='', verbose=True):
+    """
+    Asserts that two items are almost equal.
+
+    The test is equivalent to abs(desired-actual) < 0.5 * 10**(-decimal).
+
+    """
+    if isinstance(actual, np.ndarray) or isinstance(desired, np.ndarray):
+        return assert_array_almost_equal(actual, desired, decimal=decimal,
+                                         err_msg=err_msg, verbose=verbose)
+    msg = build_err_msg([actual, desired],
+                        err_msg=err_msg, verbose=verbose)
+    if not round(abs(desired - actual), decimal) == 0:
+        raise AssertionError(msg)
+
+
+assert_close = assert_almost_equal
+
+
+def assert_array_compare(comparison, x, y, err_msg='', verbose=True, header='',
+                         fill_value=True):
+    """
+    Asserts that comparison between two masked arrays is satisfied.
+
+    The comparison is elementwise.
+
+    """
+    # Allocate a common mask and refill
+    m = mask_or(getmask(x), getmask(y))
+    x = masked_array(x, copy=False, mask=m, keep_mask=False, subok=False)
+    y = masked_array(y, copy=False, mask=m, keep_mask=False, subok=False)
+    if ((x is masked) and not (y is masked)) or \
+            ((y is masked) and not (x is masked)):
+        msg = build_err_msg([x, y], err_msg=err_msg, verbose=verbose,
+                            header=header, names=('x', 'y'))
+        raise ValueError(msg)
+    # OK, now run the basic tests on filled versions
+    return np.testing.assert_array_compare(comparison,
+                                           x.filled(fill_value),
+                                           y.filled(fill_value),
+                                           err_msg=err_msg,
+                                           verbose=verbose, header=header)
+
+
+def assert_array_equal(x, y, err_msg='', verbose=True):
+    """
+    Checks the elementwise equality of two masked arrays.
+
+    """
+    assert_array_compare(operator.__eq__, x, y,
+                         err_msg=err_msg, verbose=verbose,
+                         header='Arrays are not equal')
+
+
+def fail_if_array_equal(x, y, err_msg='', verbose=True):
+    """
+    Raises an assertion error if two masked arrays are not equal elementwise.
+
+    """
+    def compare(x, y):
+        return (not np.all(approx(x, y)))
+    assert_array_compare(compare, x, y, err_msg=err_msg, verbose=verbose,
+                         header='Arrays are not equal')
+
+
+def assert_array_approx_equal(x, y, decimal=6, err_msg='', verbose=True):
+    """
+    Checks the equality of two masked arrays, up to given number odecimals.
+
+    The equality is checked elementwise.
+
+    """
+    def compare(x, y):
+        "Returns the result of the loose comparison between x and y)."
+        return approx(x, y, rtol=10. ** -decimal)
+    assert_array_compare(compare, x, y, err_msg=err_msg, verbose=verbose,
+                         header='Arrays are not almost equal')
+
+
+def assert_array_almost_equal(x, y, decimal=6, err_msg='', verbose=True):
+    """
+    Checks the equality of two masked arrays, up to given number odecimals.
+
+    The equality is checked elementwise.
+
+    """
+    def compare(x, y):
+        "Returns the result of the loose comparison between x and y)."
+        return almost(x, y, decimal)
+    assert_array_compare(compare, x, y, err_msg=err_msg, verbose=verbose,
+                         header='Arrays are not almost equal')
+
+
+def assert_array_less(x, y, err_msg='', verbose=True):
+    """
+    Checks that x is smaller than y elementwise.
+
+    """
+    assert_array_compare(operator.__lt__, x, y,
+                         err_msg=err_msg, verbose=verbose,
+                         header='Arrays are not less-ordered')
+
+
+def assert_mask_equal(m1, m2, err_msg=''):
+    """
+    Asserts the equality of two masks.
+
+    """
+    if m1 is nomask:
+        assert_(m2 is nomask)
+    if m2 is nomask:
+        assert_(m1 is nomask)
+    assert_array_equal(m1, m2, err_msg=err_msg)
diff --git a/venv/lib/python3.12/site-packages/numpy/ma/timer_comparison.py b/venv/lib/python3.12/site-packages/numpy/ma/timer_comparison.py
new file mode 100644
index 00000000..9ae4c63c
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/ma/timer_comparison.py
@@ -0,0 +1,442 @@
+import timeit
+from functools import reduce
+
+import numpy as np
+import numpy._core.fromnumeric as fromnumeric
+
+from numpy.testing import build_err_msg
+
+
+pi = np.pi
+
+class ModuleTester:
+    def __init__(self, module):
+        self.module = module
+        self.allequal = module.allequal
+        self.arange = module.arange
+        self.array = module.array
+        self.concatenate = module.concatenate
+        self.count = module.count
+        self.equal = module.equal
+        self.filled = module.filled
+        self.getmask = module.getmask
+        self.getmaskarray = module.getmaskarray
+        self.id = id
+        self.inner = module.inner
+        self.make_mask = module.make_mask
+        self.masked = module.masked
+        self.masked_array = module.masked_array
+        self.masked_values = module.masked_values
+        self.mask_or = module.mask_or
+        self.nomask = module.nomask
+        self.ones = module.ones
+        self.outer = module.outer
+        self.repeat = module.repeat
+        self.resize = module.resize
+        self.sort = module.sort
+        self.take = module.take
+        self.transpose = module.transpose
+        self.zeros = module.zeros
+        self.MaskType = module.MaskType
+        try:
+            self.umath = module.umath
+        except AttributeError:
+            self.umath = module.core.umath
+        self.testnames = []
+
+    def assert_array_compare(self, comparison, x, y, err_msg='', header='',
+                         fill_value=True):
+        """
+        Assert that a comparison of two masked arrays is satisfied elementwise.
+
+        """
+        xf = self.filled(x)
+        yf = self.filled(y)
+        m = self.mask_or(self.getmask(x), self.getmask(y))
+
+        x = self.filled(self.masked_array(xf, mask=m), fill_value)
+        y = self.filled(self.masked_array(yf, mask=m), fill_value)
+        if (x.dtype.char != "O"):
+            x = x.astype(np.float64)
+            if isinstance(x, np.ndarray) and x.size > 1:
+                x[np.isnan(x)] = 0
+            elif np.isnan(x):
+                x = 0
+        if (y.dtype.char != "O"):
+            y = y.astype(np.float64)
+            if isinstance(y, np.ndarray) and y.size > 1:
+                y[np.isnan(y)] = 0
+            elif np.isnan(y):
+                y = 0
+        try:
+            cond = (x.shape == () or y.shape == ()) or x.shape == y.shape
+            if not cond:
+                msg = build_err_msg([x, y],
+                                    err_msg
+                                    + f'\n(shapes {x.shape}, {y.shape} mismatch)',
+                                    header=header,
+                                    names=('x', 'y'))
+                assert cond, msg
+            val = comparison(x, y)
+            if m is not self.nomask and fill_value:
+                val = self.masked_array(val, mask=m)
+            if isinstance(val, bool):
+                cond = val
+                reduced = [0]
+            else:
+                reduced = val.ravel()
+                cond = reduced.all()
+                reduced = reduced.tolist()
+            if not cond:
+                match = 100-100.0*reduced.count(1)/len(reduced)
+                msg = build_err_msg([x, y],
+                                    err_msg
+                                    + '\n(mismatch %s%%)' % (match,),
+                                    header=header,
+                                    names=('x', 'y'))
+                assert cond, msg
+        except ValueError as e:
+            msg = build_err_msg([x, y], err_msg, header=header, names=('x', 'y'))
+            raise ValueError(msg) from e
+
+    def assert_array_equal(self, x, y, err_msg=''):
+        """
+        Checks the elementwise equality of two masked arrays.
+
+        """
+        self.assert_array_compare(self.equal, x, y, err_msg=err_msg,
+                                  header='Arrays are not equal')
+
+    @np.errstate(all='ignore')
+    def test_0(self):
+        """
+        Tests creation
+
+        """
+        x = np.array([1., 1., 1., -2., pi/2.0, 4., 5., -10., 10., 1., 2., 3.])
+        m = [1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0]
+        xm = self.masked_array(x, mask=m)
+        xm[0]
+
+    @np.errstate(all='ignore')
+    def test_1(self):
+        """
+        Tests creation
+
+        """
+        x = np.array([1., 1., 1., -2., pi/2.0, 4., 5., -10., 10., 1., 2., 3.])
+        y = np.array([5., 0., 3., 2., -1., -4., 0., -10., 10., 1., 0., 3.])
+        m1 = [1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0]
+        m2 = [0, 0, 1, 0, 0, 1, 1, 0, 0, 0, 0, 1]
+        xm = self.masked_array(x, mask=m1)
+        ym = self.masked_array(y, mask=m2)
+        xf = np.where(m1, 1.e+20, x)
+        xm.set_fill_value(1.e+20)
+
+        assert((xm-ym).filled(0).any())
+        s = x.shape
+        assert(xm.size == reduce(lambda x, y:x*y, s))
+        assert(self.count(xm) == len(m1) - reduce(lambda x, y:x+y, m1))
+
+        for s in [(4, 3), (6, 2)]:
+            x.shape = s
+            y.shape = s
+            xm.shape = s
+            ym.shape = s
+            xf.shape = s
+            assert(self.count(xm) == len(m1) - reduce(lambda x, y:x+y, m1))
+
+    @np.errstate(all='ignore')
+    def test_2(self):
+        """
+        Tests conversions and indexing.
+
+        """
+        x1 = np.array([1, 2, 4, 3])
+        x2 = self.array(x1, mask=[1, 0, 0, 0])
+        x3 = self.array(x1, mask=[0, 1, 0, 1])
+        x4 = self.array(x1)
+        # test conversion to strings, no errors
+        str(x2)
+        repr(x2)
+        # tests of indexing
+        assert type(x2[1]) is type(x1[1])
+        assert x1[1] == x2[1]
+        x1[2] = 9
+        x2[2] = 9
+        self.assert_array_equal(x1, x2)
+        x1[1:3] = 99
+        x2[1:3] = 99
+        x2[1] = self.masked
+        x2[1:3] = self.masked
+        x2[:] = x1
+        x2[1] = self.masked
+        x3[:] = self.masked_array([1, 2, 3, 4], [0, 1, 1, 0])
+        x4[:] = self.masked_array([1, 2, 3, 4], [0, 1, 1, 0])
+        x1 = np.arange(5)*1.0
+        x2 = self.masked_values(x1, 3.0)
+        x1 = self.array([1, 'hello', 2, 3], object)
+        x2 = np.array([1, 'hello', 2, 3], object)
+        # check that no error occurs.
+        x1[1]
+        x2[1]
+        assert x1[1:1].shape == (0,)
+        # Tests copy-size
+        n = [0, 0, 1, 0, 0]
+        m = self.make_mask(n)
+        m2 = self.make_mask(m)
+        assert(m is m2)
+        m3 = self.make_mask(m, copy=1)
+        assert(m is not m3)
+
+    @np.errstate(all='ignore')
+    def test_3(self):
+        """
+        Tests resize/repeat
+
+        """
+        x4 = self.arange(4)
+        x4[2] = self.masked
+        y4 = self.resize(x4, (8,))
+        assert self.allequal(self.concatenate([x4, x4]), y4)
+        assert self.allequal(self.getmask(y4), [0, 0, 1, 0, 0, 0, 1, 0])
+        y5 = self.repeat(x4, (2, 2, 2, 2), axis=0)
+        self.assert_array_equal(y5, [0, 0, 1, 1, 2, 2, 3, 3])
+        y6 = self.repeat(x4, 2, axis=0)
+        assert self.allequal(y5, y6)
+        y7 = x4.repeat((2, 2, 2, 2), axis=0)
+        assert self.allequal(y5, y7)
+        y8 = x4.repeat(2, 0)
+        assert self.allequal(y5, y8)
+
+    @np.errstate(all='ignore')
+    def test_4(self):
+        """
+        Test of take, transpose, inner, outer products.
+
+        """
+        x = self.arange(24)
+        y = np.arange(24)
+        x[5:6] = self.masked
+        x = x.reshape(2, 3, 4)
+        y = y.reshape(2, 3, 4)
+        assert self.allequal(np.transpose(y, (2, 0, 1)), self.transpose(x, (2, 0, 1)))
+        assert self.allequal(np.take(y, (2, 0, 1), 1), self.take(x, (2, 0, 1), 1))
+        assert self.allequal(np.inner(self.filled(x, 0), self.filled(y, 0)),
+                            self.inner(x, y))
+        assert self.allequal(np.outer(self.filled(x, 0), self.filled(y, 0)),
+                            self.outer(x, y))
+        y = self.array(['abc', 1, 'def', 2, 3], object)
+        y[2] = self.masked
+        t = self.take(y, [0, 3, 4])
+        assert t[0] == 'abc'
+        assert t[1] == 2
+        assert t[2] == 3
+
+    @np.errstate(all='ignore')
+    def test_5(self):
+        """
+        Tests inplace w/ scalar
+
+        """
+        x = self.arange(10)
+        y = self.arange(10)
+        xm = self.arange(10)
+        xm[2] = self.masked
+        x += 1
+        assert self.allequal(x, y+1)
+        xm += 1
+        assert self.allequal(xm, y+1)
+
+        x = self.arange(10)
+        xm = self.arange(10)
+        xm[2] = self.masked
+        x -= 1
+        assert self.allequal(x, y-1)
+        xm -= 1
+        assert self.allequal(xm, y-1)
+
+        x = self.arange(10)*1.0
+        xm = self.arange(10)*1.0
+        xm[2] = self.masked
+        x *= 2.0
+        assert self.allequal(x, y*2)
+        xm *= 2.0
+        assert self.allequal(xm, y*2)
+
+        x = self.arange(10)*2
+        xm = self.arange(10)*2
+        xm[2] = self.masked
+        x /= 2
+        assert self.allequal(x, y)
+        xm /= 2
+        assert self.allequal(xm, y)
+
+        x = self.arange(10)*1.0
+        xm = self.arange(10)*1.0
+        xm[2] = self.masked
+        x /= 2.0
+        assert self.allequal(x, y/2.0)
+        xm /= self.arange(10)
+        self.assert_array_equal(xm, self.ones((10,)))
+
+        x = self.arange(10).astype(np.float64)
+        xm = self.arange(10)
+        xm[2] = self.masked
+        x += 1.
+        assert self.allequal(x, y + 1.)
+
+    @np.errstate(all='ignore')
+    def test_6(self):
+        """
+        Tests inplace w/ array
+
+        """
+        x = self.arange(10, dtype=np.float64)
+        y = self.arange(10)
+        xm = self.arange(10, dtype=np.float64)
+        xm[2] = self.masked
+        m = xm.mask
+        a = self.arange(10, dtype=np.float64)
+        a[-1] = self.masked
+        x += a
+        xm += a
+        assert self.allequal(x, y+a)
+        assert self.allequal(xm, y+a)
+        assert self.allequal(xm.mask, self.mask_or(m, a.mask))
+
+        x = self.arange(10, dtype=np.float64)
+        xm = self.arange(10, dtype=np.float64)
+        xm[2] = self.masked
+        m = xm.mask
+        a = self.arange(10, dtype=np.float64)
+        a[-1] = self.masked
+        x -= a
+        xm -= a
+        assert self.allequal(x, y-a)
+        assert self.allequal(xm, y-a)
+        assert self.allequal(xm.mask, self.mask_or(m, a.mask))
+
+        x = self.arange(10, dtype=np.float64)
+        xm = self.arange(10, dtype=np.float64)
+        xm[2] = self.masked
+        m = xm.mask
+        a = self.arange(10, dtype=np.float64)
+        a[-1] = self.masked
+        x *= a
+        xm *= a
+        assert self.allequal(x, y*a)
+        assert self.allequal(xm, y*a)
+        assert self.allequal(xm.mask, self.mask_or(m, a.mask))
+
+        x = self.arange(10, dtype=np.float64)
+        xm = self.arange(10, dtype=np.float64)
+        xm[2] = self.masked
+        m = xm.mask
+        a = self.arange(10, dtype=np.float64)
+        a[-1] = self.masked
+        x /= a
+        xm /= a
+
+    @np.errstate(all='ignore')
+    def test_7(self):
+        "Tests ufunc"
+        d = (self.array([1.0, 0, -1, pi/2]*2, mask=[0, 1]+[0]*6),
+             self.array([1.0, 0, -1, pi/2]*2, mask=[1, 0]+[0]*6),)
+        for f in ['sqrt', 'log', 'log10', 'exp', 'conjugate',
+#                  'sin', 'cos', 'tan',
+#                  'arcsin', 'arccos', 'arctan',
+#                  'sinh', 'cosh', 'tanh',
+#                  'arcsinh',
+#                  'arccosh',
+#                  'arctanh',
+#                  'absolute', 'fabs', 'negative',
+#                  # 'nonzero', 'around',
+#                  'floor', 'ceil',
+#                  # 'sometrue', 'alltrue',
+#                  'logical_not',
+#                  'add', 'subtract', 'multiply',
+#                  'divide', 'true_divide', 'floor_divide',
+#                  'remainder', 'fmod', 'hypot', 'arctan2',
+#                  'equal', 'not_equal', 'less_equal', 'greater_equal',
+#                  'less', 'greater',
+#                  'logical_and', 'logical_or', 'logical_xor',
+                  ]:
+            try:
+                uf = getattr(self.umath, f)
+            except AttributeError:
+                uf = getattr(fromnumeric, f)
+            mf = getattr(self.module, f)
+            args = d[:uf.nin]
+            ur = uf(*args)
+            mr = mf(*args)
+            self.assert_array_equal(ur.filled(0), mr.filled(0), f)
+            self.assert_array_equal(ur._mask, mr._mask)
+
+    @np.errstate(all='ignore')
+    def test_99(self):
+        # test average
+        ott = self.array([0., 1., 2., 3.], mask=[1, 0, 0, 0])
+        self.assert_array_equal(2.0, self.average(ott, axis=0))
+        self.assert_array_equal(2.0, self.average(ott, weights=[1., 1., 2., 1.]))
+        result, wts = self.average(ott, weights=[1., 1., 2., 1.], returned=1)
+        self.assert_array_equal(2.0, result)
+        assert(wts == 4.0)
+        ott[:] = self.masked
+        assert(self.average(ott, axis=0) is self.masked)
+        ott = self.array([0., 1., 2., 3.], mask=[1, 0, 0, 0])
+        ott = ott.reshape(2, 2)
+        ott[:, 1] = self.masked
+        self.assert_array_equal(self.average(ott, axis=0), [2.0, 0.0])
+        assert(self.average(ott, axis=1)[0] is self.masked)
+        self.assert_array_equal([2., 0.], self.average(ott, axis=0))
+        result, wts = self.average(ott, axis=0, returned=1)
+        self.assert_array_equal(wts, [1., 0.])
+        w1 = [0, 1, 1, 1, 1, 0]
+        w2 = [[0, 1, 1, 1, 1, 0], [1, 0, 0, 0, 0, 1]]
+        x = self.arange(6)
+        self.assert_array_equal(self.average(x, axis=0), 2.5)
+        self.assert_array_equal(self.average(x, axis=0, weights=w1), 2.5)
+        y = self.array([self.arange(6), 2.0*self.arange(6)])
+        self.assert_array_equal(self.average(y, None), np.add.reduce(np.arange(6))*3./12.)
+        self.assert_array_equal(self.average(y, axis=0), np.arange(6) * 3./2.)
+        self.assert_array_equal(self.average(y, axis=1), [self.average(x, axis=0), self.average(x, axis=0) * 2.0])
+        self.assert_array_equal(self.average(y, None, weights=w2), 20./6.)
+        self.assert_array_equal(self.average(y, axis=0, weights=w2), [0., 1., 2., 3., 4., 10.])
+        self.assert_array_equal(self.average(y, axis=1), [self.average(x, axis=0), self.average(x, axis=0) * 2.0])
+        m1 = self.zeros(6)
+        m2 = [0, 0, 1, 1, 0, 0]
+        m3 = [[0, 0, 1, 1, 0, 0], [0, 1, 1, 1, 1, 0]]
+        m4 = self.ones(6)
+        m5 = [0, 1, 1, 1, 1, 1]
+        self.assert_array_equal(self.average(self.masked_array(x, m1), axis=0), 2.5)
+        self.assert_array_equal(self.average(self.masked_array(x, m2), axis=0), 2.5)
+        self.assert_array_equal(self.average(self.masked_array(x, m5), axis=0), 0.0)
+        self.assert_array_equal(self.count(self.average(self.masked_array(x, m4), axis=0)), 0)
+        z = self.masked_array(y, m3)
+        self.assert_array_equal(self.average(z, None), 20./6.)
+        self.assert_array_equal(self.average(z, axis=0), [0., 1., 99., 99., 4.0, 7.5])
+        self.assert_array_equal(self.average(z, axis=1), [2.5, 5.0])
+        self.assert_array_equal(self.average(z, axis=0, weights=w2), [0., 1., 99., 99., 4.0, 10.0])
+
+    @np.errstate(all='ignore')
+    def test_A(self):
+        x = self.arange(24)
+        x[5:6] = self.masked
+        x = x.reshape(2, 3, 4)
+
+
+if __name__ == '__main__':
+    setup_base = ("from __main__ import ModuleTester \n"
+                  "import numpy\n"
+                  "tester = ModuleTester(module)\n")
+    setup_cur = "import numpy.ma.core as module\n" + setup_base
+    (nrepeat, nloop) = (10, 10)
+
+    for i in range(1, 8):
+        func = 'tester.test_%i()' % i
+        cur = timeit.Timer(func, setup_cur).repeat(nrepeat, nloop*10)
+        cur = np.sort(cur)
+        print("#%i" % i + 50*'.')
+        print(eval("ModuleTester.test_%i.__doc__" % i))
+        print(f'core_current : {cur[0]:.3f} - {cur[1]:.3f}')
diff --git a/venv/lib/python3.12/site-packages/numpy/matlib.py b/venv/lib/python3.12/site-packages/numpy/matlib.py
new file mode 100644
index 00000000..95f573ab
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/matlib.py
@@ -0,0 +1,381 @@
+import warnings
+
+# 2018-05-29, PendingDeprecationWarning added to matrix.__new__
+# 2020-01-23, numpy 1.19.0 PendingDeprecatonWarning
+warnings.warn("Importing from numpy.matlib is deprecated since 1.19.0. "
+              "The matrix subclass is not the recommended way to represent "
+              "matrices or deal with linear algebra (see "
+              "https://docs.scipy.org/doc/numpy/user/numpy-for-matlab-users.html). "
+              "Please adjust your code to use regular ndarray. ",
+              PendingDeprecationWarning, stacklevel=2)
+
+import numpy as np
+from numpy.matrixlib.defmatrix import matrix, asmatrix
+# Matlib.py contains all functions in the numpy namespace with a few
+# replacements. See doc/source/reference/routines.matlib.rst for details.
+# Need * as we're copying the numpy namespace.
+from numpy import *  # noqa: F403
+
+__version__ = np.__version__
+
+__all__ = np.__all__[:] # copy numpy namespace
+__all__ += ['rand', 'randn', 'repmat']
+
+def empty(shape, dtype=None, order='C'):
+    """Return a new matrix of given shape and type, without initializing entries.
+
+    Parameters
+    ----------
+    shape : int or tuple of int
+        Shape of the empty matrix.
+    dtype : data-type, optional
+        Desired output data-type.
+    order : {'C', 'F'}, optional
+        Whether to store multi-dimensional data in row-major
+        (C-style) or column-major (Fortran-style) order in
+        memory.
+
+    See Also
+    --------
+    numpy.empty : Equivalent array function.
+    matlib.zeros : Return a matrix of zeros.
+    matlib.ones : Return a matrix of ones.
+
+    Notes
+    -----
+    Unlike other matrix creation functions (e.g. `matlib.zeros`,
+    `matlib.ones`), `matlib.empty` does not initialize the values of the
+    matrix, and may therefore be marginally faster. However, the values
+    stored in the newly allocated matrix are arbitrary. For reproducible
+    behavior, be sure to set each element of the matrix before reading.
+
+    Examples
+    --------
+    >>> import numpy.matlib
+    >>> np.matlib.empty((2, 2))    # filled with random data
+    matrix([[  6.76425276e-320,   9.79033856e-307], # random
+            [  7.39337286e-309,   3.22135945e-309]])
+    >>> np.matlib.empty((2, 2), dtype=int)
+    matrix([[ 6600475,        0], # random
+            [ 6586976, 22740995]])
+
+    """
+    return ndarray.__new__(matrix, shape, dtype, order=order)
+
+def ones(shape, dtype=None, order='C'):
+    """
+    Matrix of ones.
+
+    Return a matrix of given shape and type, filled with ones.
+
+    Parameters
+    ----------
+    shape : {sequence of ints, int}
+        Shape of the matrix
+    dtype : data-type, optional
+        The desired data-type for the matrix, default is np.float64.
+    order : {'C', 'F'}, optional
+        Whether to store matrix in C- or Fortran-contiguous order,
+        default is 'C'.
+
+    Returns
+    -------
+    out : matrix
+        Matrix of ones of given shape, dtype, and order.
+
+    See Also
+    --------
+    ones : Array of ones.
+    matlib.zeros : Zero matrix.
+
+    Notes
+    -----
+    If `shape` has length one i.e. ``(N,)``, or is a scalar ``N``,
+    `out` becomes a single row matrix of shape ``(1,N)``.
+
+    Examples
+    --------
+    >>> np.matlib.ones((2,3))
+    matrix([[1.,  1.,  1.],
+            [1.,  1.,  1.]])
+
+    >>> np.matlib.ones(2)
+    matrix([[1.,  1.]])
+
+    """
+    a = ndarray.__new__(matrix, shape, dtype, order=order)
+    a.fill(1)
+    return a
+
+def zeros(shape, dtype=None, order='C'):
+    """
+    Return a matrix of given shape and type, filled with zeros.
+
+    Parameters
+    ----------
+    shape : int or sequence of ints
+        Shape of the matrix
+    dtype : data-type, optional
+        The desired data-type for the matrix, default is float.
+    order : {'C', 'F'}, optional
+        Whether to store the result in C- or Fortran-contiguous order,
+        default is 'C'.
+
+    Returns
+    -------
+    out : matrix
+        Zero matrix of given shape, dtype, and order.
+
+    See Also
+    --------
+    numpy.zeros : Equivalent array function.
+    matlib.ones : Return a matrix of ones.
+
+    Notes
+    -----
+    If `shape` has length one i.e. ``(N,)``, or is a scalar ``N``,
+    `out` becomes a single row matrix of shape ``(1,N)``.
+
+    Examples
+    --------
+    >>> import numpy.matlib
+    >>> np.matlib.zeros((2, 3))
+    matrix([[0.,  0.,  0.],
+            [0.,  0.,  0.]])
+
+    >>> np.matlib.zeros(2)
+    matrix([[0.,  0.]])
+
+    """
+    a = ndarray.__new__(matrix, shape, dtype, order=order)
+    a.fill(0)
+    return a
+
+def identity(n,dtype=None):
+    """
+    Returns the square identity matrix of given size.
+
+    Parameters
+    ----------
+    n : int
+        Size of the returned identity matrix.
+    dtype : data-type, optional
+        Data-type of the output. Defaults to ``float``.
+
+    Returns
+    -------
+    out : matrix
+        `n` x `n` matrix with its main diagonal set to one,
+        and all other elements zero.
+
+    See Also
+    --------
+    numpy.identity : Equivalent array function.
+    matlib.eye : More general matrix identity function.
+
+    Examples
+    --------
+    >>> import numpy.matlib
+    >>> np.matlib.identity(3, dtype=int)
+    matrix([[1, 0, 0],
+            [0, 1, 0],
+            [0, 0, 1]])
+
+    """
+    a = array([1]+n*[0], dtype=dtype)
+    b = empty((n, n), dtype=dtype)
+    b.flat = a
+    return b
+
+def eye(n,M=None, k=0, dtype=float, order='C'):
+    """
+    Return a matrix with ones on the diagonal and zeros elsewhere.
+
+    Parameters
+    ----------
+    n : int
+        Number of rows in the output.
+    M : int, optional
+        Number of columns in the output, defaults to `n`.
+    k : int, optional
+        Index of the diagonal: 0 refers to the main diagonal,
+        a positive value refers to an upper diagonal,
+        and a negative value to a lower diagonal.
+    dtype : dtype, optional
+        Data-type of the returned matrix.
+    order : {'C', 'F'}, optional
+        Whether the output should be stored in row-major (C-style) or
+        column-major (Fortran-style) order in memory.
+
+        .. versionadded:: 1.14.0
+
+    Returns
+    -------
+    I : matrix
+        A `n` x `M` matrix where all elements are equal to zero,
+        except for the `k`-th diagonal, whose values are equal to one.
+
+    See Also
+    --------
+    numpy.eye : Equivalent array function.
+    identity : Square identity matrix.
+
+    Examples
+    --------
+    >>> import numpy.matlib
+    >>> np.matlib.eye(3, k=1, dtype=float)
+    matrix([[0.,  1.,  0.],
+            [0.,  0.,  1.],
+            [0.,  0.,  0.]])
+
+    """
+    return asmatrix(np.eye(n, M=M, k=k, dtype=dtype, order=order))
+
+def rand(*args):
+    """
+    Return a matrix of random values with given shape.
+
+    Create a matrix of the given shape and propagate it with
+    random samples from a uniform distribution over ``[0, 1)``.
+
+    Parameters
+    ----------
+    \\*args : Arguments
+        Shape of the output.
+        If given as N integers, each integer specifies the size of one
+        dimension.
+        If given as a tuple, this tuple gives the complete shape.
+
+    Returns
+    -------
+    out : ndarray
+        The matrix of random values with shape given by `\\*args`.
+
+    See Also
+    --------
+    randn, numpy.random.RandomState.rand
+
+    Examples
+    --------
+    >>> np.random.seed(123)
+    >>> import numpy.matlib
+    >>> np.matlib.rand(2, 3)
+    matrix([[0.69646919, 0.28613933, 0.22685145],
+            [0.55131477, 0.71946897, 0.42310646]])
+    >>> np.matlib.rand((2, 3))
+    matrix([[0.9807642 , 0.68482974, 0.4809319 ],
+            [0.39211752, 0.34317802, 0.72904971]])
+
+    If the first argument is a tuple, other arguments are ignored:
+
+    >>> np.matlib.rand((2, 3), 4)
+    matrix([[0.43857224, 0.0596779 , 0.39804426],
+            [0.73799541, 0.18249173, 0.17545176]])
+
+    """
+    if isinstance(args[0], tuple):
+        args = args[0]
+    return asmatrix(np.random.rand(*args))
+
+def randn(*args):
+    """
+    Return a random matrix with data from the "standard normal" distribution.
+
+    `randn` generates a matrix filled with random floats sampled from a
+    univariate "normal" (Gaussian) distribution of mean 0 and variance 1.
+
+    Parameters
+    ----------
+    \\*args : Arguments
+        Shape of the output.
+        If given as N integers, each integer specifies the size of one
+        dimension. If given as a tuple, this tuple gives the complete shape.
+
+    Returns
+    -------
+    Z : matrix of floats
+        A matrix of floating-point samples drawn from the standard normal
+        distribution.
+
+    See Also
+    --------
+    rand, numpy.random.RandomState.randn
+
+    Notes
+    -----
+    For random samples from the normal distribution with mean ``mu`` and
+    standard deviation ``sigma``, use::
+
+        sigma * np.matlib.randn(...) + mu
+
+    Examples
+    --------
+    >>> np.random.seed(123)
+    >>> import numpy.matlib
+    >>> np.matlib.randn(1)
+    matrix([[-1.0856306]])
+    >>> np.matlib.randn(1, 2, 3)
+    matrix([[ 0.99734545,  0.2829785 , -1.50629471],
+            [-0.57860025,  1.65143654, -2.42667924]])
+
+    Two-by-four matrix of samples from the normal distribution with
+    mean 3 and standard deviation 2.5:
+
+    >>> 2.5 * np.matlib.randn((2, 4)) + 3
+    matrix([[1.92771843, 6.16484065, 0.83314899, 1.30278462],
+            [2.76322758, 6.72847407, 1.40274501, 1.8900451 ]])
+
+    """
+    if isinstance(args[0], tuple):
+        args = args[0]
+    return asmatrix(np.random.randn(*args))
+
+def repmat(a, m, n):
+    """
+    Repeat a 0-D to 2-D array or matrix MxN times.
+
+    Parameters
+    ----------
+    a : array_like
+        The array or matrix to be repeated.
+    m, n : int
+        The number of times `a` is repeated along the first and second axes.
+
+    Returns
+    -------
+    out : ndarray
+        The result of repeating `a`.
+
+    Examples
+    --------
+    >>> import numpy.matlib
+    >>> a0 = np.array(1)
+    >>> np.matlib.repmat(a0, 2, 3)
+    array([[1, 1, 1],
+           [1, 1, 1]])
+
+    >>> a1 = np.arange(4)
+    >>> np.matlib.repmat(a1, 2, 2)
+    array([[0, 1, 2, 3, 0, 1, 2, 3],
+           [0, 1, 2, 3, 0, 1, 2, 3]])
+
+    >>> a2 = np.asmatrix(np.arange(6).reshape(2, 3))
+    >>> np.matlib.repmat(a2, 2, 3)
+    matrix([[0, 1, 2, 0, 1, 2, 0, 1, 2],
+            [3, 4, 5, 3, 4, 5, 3, 4, 5],
+            [0, 1, 2, 0, 1, 2, 0, 1, 2],
+            [3, 4, 5, 3, 4, 5, 3, 4, 5]])
+
+    """
+    a = asanyarray(a)
+    ndim = a.ndim
+    if ndim == 0:
+        origrows, origcols = (1, 1)
+    elif ndim == 1:
+        origrows, origcols = (1, a.shape[0])
+    else:
+        origrows, origcols = a.shape
+    rows = origrows * m
+    cols = origcols * n
+    c = a.reshape(1, a.size).repeat(m, 0).reshape(rows, origcols).repeat(n, 0)
+    return c.reshape(rows, cols)
diff --git a/venv/lib/python3.12/site-packages/numpy/matrixlib/__init__.py b/venv/lib/python3.12/site-packages/numpy/matrixlib/__init__.py
new file mode 100644
index 00000000..8a7597d3
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/matrixlib/__init__.py
@@ -0,0 +1,11 @@
+"""Sub-package containing the matrix class and related functions.
+
+"""
+from . import defmatrix
+from .defmatrix import *
+
+__all__ = defmatrix.__all__
+
+from numpy._pytesttester import PytestTester
+test = PytestTester(__name__)
+del PytestTester
diff --git a/venv/lib/python3.12/site-packages/numpy/matrixlib/__init__.pyi b/venv/lib/python3.12/site-packages/numpy/matrixlib/__init__.pyi
new file mode 100644
index 00000000..a7efab58
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/matrixlib/__init__.pyi
@@ -0,0 +1,14 @@
+from numpy._pytesttester import PytestTester
+
+from numpy import (
+    matrix as matrix,
+)
+
+from numpy.matrixlib.defmatrix import (
+    bmat as bmat,
+    mat as mat,
+    asmatrix as asmatrix,
+)
+
+__all__: list[str]
+test: PytestTester
diff --git a/venv/lib/python3.12/site-packages/numpy/matrixlib/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/matrixlib/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 00000000..3a3889b1
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/matrixlib/__pycache__/__init__.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/matrixlib/__pycache__/defmatrix.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/matrixlib/__pycache__/defmatrix.cpython-312.pyc
new file mode 100644
index 00000000..825d97b9
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/matrixlib/__pycache__/defmatrix.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/matrixlib/defmatrix.py b/venv/lib/python3.12/site-packages/numpy/matrixlib/defmatrix.py
new file mode 100644
index 00000000..99c07fcf
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/matrixlib/defmatrix.py
@@ -0,0 +1,1115 @@
+__all__ = ['matrix', 'bmat', 'asmatrix']
+
+import sys
+import warnings
+import ast
+
+from .._utils import set_module
+import numpy._core.numeric as N
+from numpy._core.numeric import concatenate, isscalar
+# While not in __all__, matrix_power used to be defined here, so we import
+# it for backward compatibility.
+from numpy.linalg import matrix_power
+
+
+def _convert_from_string(data):
+    for char in '[]':
+        data = data.replace(char, '')
+
+    rows = data.split(';')
+    newdata = []
+    for count, row in enumerate(rows):
+        trow = row.split(',')
+        newrow = []
+        for col in trow:
+            temp = col.split()
+            newrow.extend(map(ast.literal_eval, temp))
+        if count == 0:
+            Ncols = len(newrow)
+        elif len(newrow) != Ncols:
+            raise ValueError("Rows not the same size.")
+        newdata.append(newrow)
+    return newdata
+
+
+@set_module('numpy')
+def asmatrix(data, dtype=None):
+    """
+    Interpret the input as a matrix.
+
+    Unlike `matrix`, `asmatrix` does not make a copy if the input is already
+    a matrix or an ndarray.  Equivalent to ``matrix(data, copy=False)``.
+
+    Parameters
+    ----------
+    data : array_like
+        Input data.
+    dtype : data-type
+       Data-type of the output matrix.
+
+    Returns
+    -------
+    mat : matrix
+        `data` interpreted as a matrix.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> x = np.array([[1, 2], [3, 4]])
+
+    >>> m = np.asmatrix(x)
+
+    >>> x[0,0] = 5
+
+    >>> m
+    matrix([[5, 2],
+            [3, 4]])
+
+    """
+    return matrix(data, dtype=dtype, copy=False)
+
+
+@set_module('numpy')
+class matrix(N.ndarray):
+    """
+    matrix(data, dtype=None, copy=True)
+
+    Returns a matrix from an array-like object, or from a string of data.
+
+    A matrix is a specialized 2-D array that retains its 2-D nature
+    through operations.  It has certain special operators, such as ``*``
+    (matrix multiplication) and ``**`` (matrix power).
+
+    .. note:: It is no longer recommended to use this class, even for linear
+              algebra. Instead use regular arrays. The class may be removed
+              in the future.
+
+    Parameters
+    ----------
+    data : array_like or string
+       If `data` is a string, it is interpreted as a matrix with commas
+       or spaces separating columns, and semicolons separating rows.
+    dtype : data-type
+       Data-type of the output matrix.
+    copy : bool
+       If `data` is already an `ndarray`, then this flag determines
+       whether the data is copied (the default), or whether a view is
+       constructed.
+
+    See Also
+    --------
+    array
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> a = np.matrix('1 2; 3 4')
+    >>> a
+    matrix([[1, 2],
+            [3, 4]])
+
+    >>> np.matrix([[1, 2], [3, 4]])
+    matrix([[1, 2],
+            [3, 4]])
+
+    """
+    __array_priority__ = 10.0
+    def __new__(subtype, data, dtype=None, copy=True):
+        warnings.warn('the matrix subclass is not the recommended way to '
+                      'represent matrices or deal with linear algebra (see '
+                      'https://docs.scipy.org/doc/numpy/user/'
+                      'numpy-for-matlab-users.html). '
+                      'Please adjust your code to use regular ndarray.',
+                      PendingDeprecationWarning, stacklevel=2)
+        if isinstance(data, matrix):
+            dtype2 = data.dtype
+            if (dtype is None):
+                dtype = dtype2
+            if (dtype2 == dtype) and (not copy):
+                return data
+            return data.astype(dtype)
+
+        if isinstance(data, N.ndarray):
+            if dtype is None:
+                intype = data.dtype
+            else:
+                intype = N.dtype(dtype)
+            new = data.view(subtype)
+            if intype != data.dtype:
+                return new.astype(intype)
+            if copy: return new.copy()
+            else: return new
+
+        if isinstance(data, str):
+            data = _convert_from_string(data)
+
+        # now convert data to an array
+        copy = None if not copy else True
+        arr = N.array(data, dtype=dtype, copy=copy)
+        ndim = arr.ndim
+        shape = arr.shape
+        if (ndim > 2):
+            raise ValueError("matrix must be 2-dimensional")
+        elif ndim == 0:
+            shape = (1, 1)
+        elif ndim == 1:
+            shape = (1, shape[0])
+
+        order = 'C'
+        if (ndim == 2) and arr.flags.fortran:
+            order = 'F'
+
+        if not (order or arr.flags.contiguous):
+            arr = arr.copy()
+
+        ret = N.ndarray.__new__(subtype, shape, arr.dtype,
+                                buffer=arr,
+                                order=order)
+        return ret
+
+    def __array_finalize__(self, obj):
+        self._getitem = False
+        if (isinstance(obj, matrix) and obj._getitem): return
+        ndim = self.ndim
+        if (ndim == 2):
+            return
+        if (ndim > 2):
+            newshape = tuple([x for x in self.shape if x > 1])
+            ndim = len(newshape)
+            if ndim == 2:
+                self.shape = newshape
+                return
+            elif (ndim > 2):
+                raise ValueError("shape too large to be a matrix.")
+        else:
+            newshape = self.shape
+        if ndim == 0:
+            self.shape = (1, 1)
+        elif ndim == 1:
+            self.shape = (1, newshape[0])
+        return
+
+    def __getitem__(self, index):
+        self._getitem = True
+
+        try:
+            out = N.ndarray.__getitem__(self, index)
+        finally:
+            self._getitem = False
+
+        if not isinstance(out, N.ndarray):
+            return out
+
+        if out.ndim == 0:
+            return out[()]
+        if out.ndim == 1:
+            sh = out.shape[0]
+            # Determine when we should have a column array
+            try:
+                n = len(index)
+            except Exception:
+                n = 0
+            if n > 1 and isscalar(index[1]):
+                out.shape = (sh, 1)
+            else:
+                out.shape = (1, sh)
+        return out
+
+    def __mul__(self, other):
+        if isinstance(other, (N.ndarray, list, tuple)) :
+            # This promotes 1-D vectors to row vectors
+            return N.dot(self, asmatrix(other))
+        if isscalar(other) or not hasattr(other, '__rmul__') :
+            return N.dot(self, other)
+        return NotImplemented
+
+    def __rmul__(self, other):
+        return N.dot(other, self)
+
+    def __imul__(self, other):
+        self[:] = self * other
+        return self
+
+    def __pow__(self, other):
+        return matrix_power(self, other)
+
+    def __ipow__(self, other):
+        self[:] = self ** other
+        return self
+
+    def __rpow__(self, other):
+        return NotImplemented
+
+    def _align(self, axis):
+        """A convenience function for operations that need to preserve axis
+        orientation.
+        """
+        if axis is None:
+            return self[0, 0]
+        elif axis==0:
+            return self
+        elif axis==1:
+            return self.transpose()
+        else:
+            raise ValueError("unsupported axis")
+
+    def _collapse(self, axis):
+        """A convenience function for operations that want to collapse
+        to a scalar like _align, but are using keepdims=True
+        """
+        if axis is None:
+            return self[0, 0]
+        else:
+            return self
+
+    # Necessary because base-class tolist expects dimension
+    #  reduction by x[0]
+    def tolist(self):
+        """
+        Return the matrix as a (possibly nested) list.
+
+        See `ndarray.tolist` for full documentation.
+
+        See Also
+        --------
+        ndarray.tolist
+
+        Examples
+        --------
+        >>> x = np.matrix(np.arange(12).reshape((3,4))); x
+        matrix([[ 0,  1,  2,  3],
+                [ 4,  5,  6,  7],
+                [ 8,  9, 10, 11]])
+        >>> x.tolist()
+        [[0, 1, 2, 3], [4, 5, 6, 7], [8, 9, 10, 11]]
+
+        """
+        return self.__array__().tolist()
+
+    # To preserve orientation of result...
+    def sum(self, axis=None, dtype=None, out=None):
+        """
+        Returns the sum of the matrix elements, along the given axis.
+
+        Refer to `numpy.sum` for full documentation.
+
+        See Also
+        --------
+        numpy.sum
+
+        Notes
+        -----
+        This is the same as `ndarray.sum`, except that where an `ndarray` would
+        be returned, a `matrix` object is returned instead.
+
+        Examples
+        --------
+        >>> x = np.matrix([[1, 2], [4, 3]])
+        >>> x.sum()
+        10
+        >>> x.sum(axis=1)
+        matrix([[3],
+                [7]])
+        >>> x.sum(axis=1, dtype='float')
+        matrix([[3.],
+                [7.]])
+        >>> out = np.zeros((2, 1), dtype='float')
+        >>> x.sum(axis=1, dtype='float', out=np.asmatrix(out))
+        matrix([[3.],
+                [7.]])
+
+        """
+        return N.ndarray.sum(self, axis, dtype, out, keepdims=True)._collapse(axis)
+
+
+    # To update docstring from array to matrix...
+    def squeeze(self, axis=None):
+        """
+        Return a possibly reshaped matrix.
+
+        Refer to `numpy.squeeze` for more documentation.
+
+        Parameters
+        ----------
+        axis : None or int or tuple of ints, optional
+            Selects a subset of the axes of length one in the shape.
+            If an axis is selected with shape entry greater than one,
+            an error is raised.
+
+        Returns
+        -------
+        squeezed : matrix
+            The matrix, but as a (1, N) matrix if it had shape (N, 1).
+
+        See Also
+        --------
+        numpy.squeeze : related function
+
+        Notes
+        -----
+        If `m` has a single column then that column is returned
+        as the single row of a matrix.  Otherwise `m` is returned.
+        The returned matrix is always either `m` itself or a view into `m`.
+        Supplying an axis keyword argument will not affect the returned matrix
+        but it may cause an error to be raised.
+
+        Examples
+        --------
+        >>> c = np.matrix([[1], [2]])
+        >>> c
+        matrix([[1],
+                [2]])
+        >>> c.squeeze()
+        matrix([[1, 2]])
+        >>> r = c.T
+        >>> r
+        matrix([[1, 2]])
+        >>> r.squeeze()
+        matrix([[1, 2]])
+        >>> m = np.matrix([[1, 2], [3, 4]])
+        >>> m.squeeze()
+        matrix([[1, 2],
+                [3, 4]])
+
+        """
+        return N.ndarray.squeeze(self, axis=axis)
+
+
+    # To update docstring from array to matrix...
+    def flatten(self, order='C'):
+        """
+        Return a flattened copy of the matrix.
+
+        All `N` elements of the matrix are placed into a single row.
+
+        Parameters
+        ----------
+        order : {'C', 'F', 'A', 'K'}, optional
+            'C' means to flatten in row-major (C-style) order. 'F' means to
+            flatten in column-major (Fortran-style) order. 'A' means to
+            flatten in column-major order if `m` is Fortran *contiguous* in
+            memory, row-major order otherwise. 'K' means to flatten `m` in
+            the order the elements occur in memory. The default is 'C'.
+
+        Returns
+        -------
+        y : matrix
+            A copy of the matrix, flattened to a `(1, N)` matrix where `N`
+            is the number of elements in the original matrix.
+
+        See Also
+        --------
+        ravel : Return a flattened array.
+        flat : A 1-D flat iterator over the matrix.
+
+        Examples
+        --------
+        >>> m = np.matrix([[1,2], [3,4]])
+        >>> m.flatten()
+        matrix([[1, 2, 3, 4]])
+        >>> m.flatten('F')
+        matrix([[1, 3, 2, 4]])
+
+        """
+        return N.ndarray.flatten(self, order=order)
+
+    def mean(self, axis=None, dtype=None, out=None):
+        """
+        Returns the average of the matrix elements along the given axis.
+
+        Refer to `numpy.mean` for full documentation.
+
+        See Also
+        --------
+        numpy.mean
+
+        Notes
+        -----
+        Same as `ndarray.mean` except that, where that returns an `ndarray`,
+        this returns a `matrix` object.
+
+        Examples
+        --------
+        >>> x = np.matrix(np.arange(12).reshape((3, 4)))
+        >>> x
+        matrix([[ 0,  1,  2,  3],
+                [ 4,  5,  6,  7],
+                [ 8,  9, 10, 11]])
+        >>> x.mean()
+        5.5
+        >>> x.mean(0)
+        matrix([[4., 5., 6., 7.]])
+        >>> x.mean(1)
+        matrix([[ 1.5],
+                [ 5.5],
+                [ 9.5]])
+
+        """
+        return N.ndarray.mean(self, axis, dtype, out, keepdims=True)._collapse(axis)
+
+    def std(self, axis=None, dtype=None, out=None, ddof=0):
+        """
+        Return the standard deviation of the array elements along the given axis.
+
+        Refer to `numpy.std` for full documentation.
+
+        See Also
+        --------
+        numpy.std
+
+        Notes
+        -----
+        This is the same as `ndarray.std`, except that where an `ndarray` would
+        be returned, a `matrix` object is returned instead.
+
+        Examples
+        --------
+        >>> x = np.matrix(np.arange(12).reshape((3, 4)))
+        >>> x
+        matrix([[ 0,  1,  2,  3],
+                [ 4,  5,  6,  7],
+                [ 8,  9, 10, 11]])
+        >>> x.std()
+        3.4520525295346629 # may vary
+        >>> x.std(0)
+        matrix([[ 3.26598632,  3.26598632,  3.26598632,  3.26598632]]) # may vary
+        >>> x.std(1)
+        matrix([[ 1.11803399],
+                [ 1.11803399],
+                [ 1.11803399]])
+
+        """
+        return N.ndarray.std(self, axis, dtype, out, ddof, keepdims=True)._collapse(axis)
+
+    def var(self, axis=None, dtype=None, out=None, ddof=0):
+        """
+        Returns the variance of the matrix elements, along the given axis.
+
+        Refer to `numpy.var` for full documentation.
+
+        See Also
+        --------
+        numpy.var
+
+        Notes
+        -----
+        This is the same as `ndarray.var`, except that where an `ndarray` would
+        be returned, a `matrix` object is returned instead.
+
+        Examples
+        --------
+        >>> x = np.matrix(np.arange(12).reshape((3, 4)))
+        >>> x
+        matrix([[ 0,  1,  2,  3],
+                [ 4,  5,  6,  7],
+                [ 8,  9, 10, 11]])
+        >>> x.var()
+        11.916666666666666
+        >>> x.var(0)
+        matrix([[ 10.66666667,  10.66666667,  10.66666667,  10.66666667]]) # may vary
+        >>> x.var(1)
+        matrix([[1.25],
+                [1.25],
+                [1.25]])
+
+        """
+        return N.ndarray.var(self, axis, dtype, out, ddof, keepdims=True)._collapse(axis)
+
+    def prod(self, axis=None, dtype=None, out=None):
+        """
+        Return the product of the array elements over the given axis.
+
+        Refer to `prod` for full documentation.
+
+        See Also
+        --------
+        prod, ndarray.prod
+
+        Notes
+        -----
+        Same as `ndarray.prod`, except, where that returns an `ndarray`, this
+        returns a `matrix` object instead.
+
+        Examples
+        --------
+        >>> x = np.matrix(np.arange(12).reshape((3,4))); x
+        matrix([[ 0,  1,  2,  3],
+                [ 4,  5,  6,  7],
+                [ 8,  9, 10, 11]])
+        >>> x.prod()
+        0
+        >>> x.prod(0)
+        matrix([[  0,  45, 120, 231]])
+        >>> x.prod(1)
+        matrix([[   0],
+                [ 840],
+                [7920]])
+
+        """
+        return N.ndarray.prod(self, axis, dtype, out, keepdims=True)._collapse(axis)
+
+    def any(self, axis=None, out=None):
+        """
+        Test whether any array element along a given axis evaluates to True.
+
+        Refer to `numpy.any` for full documentation.
+
+        Parameters
+        ----------
+        axis : int, optional
+            Axis along which logical OR is performed
+        out : ndarray, optional
+            Output to existing array instead of creating new one, must have
+            same shape as expected output
+
+        Returns
+        -------
+            any : bool, ndarray
+                Returns a single bool if `axis` is ``None``; otherwise,
+                returns `ndarray`
+
+        """
+        return N.ndarray.any(self, axis, out, keepdims=True)._collapse(axis)
+
+    def all(self, axis=None, out=None):
+        """
+        Test whether all matrix elements along a given axis evaluate to True.
+
+        Parameters
+        ----------
+        See `numpy.all` for complete descriptions
+
+        See Also
+        --------
+        numpy.all
+
+        Notes
+        -----
+        This is the same as `ndarray.all`, but it returns a `matrix` object.
+
+        Examples
+        --------
+        >>> x = np.matrix(np.arange(12).reshape((3,4))); x
+        matrix([[ 0,  1,  2,  3],
+                [ 4,  5,  6,  7],
+                [ 8,  9, 10, 11]])
+        >>> y = x[0]; y
+        matrix([[0, 1, 2, 3]])
+        >>> (x == y)
+        matrix([[ True,  True,  True,  True],
+                [False, False, False, False],
+                [False, False, False, False]])
+        >>> (x == y).all()
+        False
+        >>> (x == y).all(0)
+        matrix([[False, False, False, False]])
+        >>> (x == y).all(1)
+        matrix([[ True],
+                [False],
+                [False]])
+
+        """
+        return N.ndarray.all(self, axis, out, keepdims=True)._collapse(axis)
+
+    def max(self, axis=None, out=None):
+        """
+        Return the maximum value along an axis.
+
+        Parameters
+        ----------
+        See `amax` for complete descriptions
+
+        See Also
+        --------
+        amax, ndarray.max
+
+        Notes
+        -----
+        This is the same as `ndarray.max`, but returns a `matrix` object
+        where `ndarray.max` would return an ndarray.
+
+        Examples
+        --------
+        >>> x = np.matrix(np.arange(12).reshape((3,4))); x
+        matrix([[ 0,  1,  2,  3],
+                [ 4,  5,  6,  7],
+                [ 8,  9, 10, 11]])
+        >>> x.max()
+        11
+        >>> x.max(0)
+        matrix([[ 8,  9, 10, 11]])
+        >>> x.max(1)
+        matrix([[ 3],
+                [ 7],
+                [11]])
+
+        """
+        return N.ndarray.max(self, axis, out, keepdims=True)._collapse(axis)
+
+    def argmax(self, axis=None, out=None):
+        """
+        Indexes of the maximum values along an axis.
+
+        Return the indexes of the first occurrences of the maximum values
+        along the specified axis.  If axis is None, the index is for the
+        flattened matrix.
+
+        Parameters
+        ----------
+        See `numpy.argmax` for complete descriptions
+
+        See Also
+        --------
+        numpy.argmax
+
+        Notes
+        -----
+        This is the same as `ndarray.argmax`, but returns a `matrix` object
+        where `ndarray.argmax` would return an `ndarray`.
+
+        Examples
+        --------
+        >>> x = np.matrix(np.arange(12).reshape((3,4))); x
+        matrix([[ 0,  1,  2,  3],
+                [ 4,  5,  6,  7],
+                [ 8,  9, 10, 11]])
+        >>> x.argmax()
+        11
+        >>> x.argmax(0)
+        matrix([[2, 2, 2, 2]])
+        >>> x.argmax(1)
+        matrix([[3],
+                [3],
+                [3]])
+
+        """
+        return N.ndarray.argmax(self, axis, out)._align(axis)
+
+    def min(self, axis=None, out=None):
+        """
+        Return the minimum value along an axis.
+
+        Parameters
+        ----------
+        See `amin` for complete descriptions.
+
+        See Also
+        --------
+        amin, ndarray.min
+
+        Notes
+        -----
+        This is the same as `ndarray.min`, but returns a `matrix` object
+        where `ndarray.min` would return an ndarray.
+
+        Examples
+        --------
+        >>> x = -np.matrix(np.arange(12).reshape((3,4))); x
+        matrix([[  0,  -1,  -2,  -3],
+                [ -4,  -5,  -6,  -7],
+                [ -8,  -9, -10, -11]])
+        >>> x.min()
+        -11
+        >>> x.min(0)
+        matrix([[ -8,  -9, -10, -11]])
+        >>> x.min(1)
+        matrix([[ -3],
+                [ -7],
+                [-11]])
+
+        """
+        return N.ndarray.min(self, axis, out, keepdims=True)._collapse(axis)
+
+    def argmin(self, axis=None, out=None):
+        """
+        Indexes of the minimum values along an axis.
+
+        Return the indexes of the first occurrences of the minimum values
+        along the specified axis.  If axis is None, the index is for the
+        flattened matrix.
+
+        Parameters
+        ----------
+        See `numpy.argmin` for complete descriptions.
+
+        See Also
+        --------
+        numpy.argmin
+
+        Notes
+        -----
+        This is the same as `ndarray.argmin`, but returns a `matrix` object
+        where `ndarray.argmin` would return an `ndarray`.
+
+        Examples
+        --------
+        >>> x = -np.matrix(np.arange(12).reshape((3,4))); x
+        matrix([[  0,  -1,  -2,  -3],
+                [ -4,  -5,  -6,  -7],
+                [ -8,  -9, -10, -11]])
+        >>> x.argmin()
+        11
+        >>> x.argmin(0)
+        matrix([[2, 2, 2, 2]])
+        >>> x.argmin(1)
+        matrix([[3],
+                [3],
+                [3]])
+
+        """
+        return N.ndarray.argmin(self, axis, out)._align(axis)
+
+    def ptp(self, axis=None, out=None):
+        """
+        Peak-to-peak (maximum - minimum) value along the given axis.
+
+        Refer to `numpy.ptp` for full documentation.
+
+        See Also
+        --------
+        numpy.ptp
+
+        Notes
+        -----
+        Same as `ndarray.ptp`, except, where that would return an `ndarray` object,
+        this returns a `matrix` object.
+
+        Examples
+        --------
+        >>> x = np.matrix(np.arange(12).reshape((3,4))); x
+        matrix([[ 0,  1,  2,  3],
+                [ 4,  5,  6,  7],
+                [ 8,  9, 10, 11]])
+        >>> x.ptp()
+        11
+        >>> x.ptp(0)
+        matrix([[8, 8, 8, 8]])
+        >>> x.ptp(1)
+        matrix([[3],
+                [3],
+                [3]])
+
+        """
+        return N.ptp(self, axis, out)._align(axis)
+
+    @property
+    def I(self):
+        """
+        Returns the (multiplicative) inverse of invertible `self`.
+
+        Parameters
+        ----------
+        None
+
+        Returns
+        -------
+        ret : matrix object
+            If `self` is non-singular, `ret` is such that ``ret * self`` ==
+            ``self * ret`` == ``np.matrix(np.eye(self[0,:].size))`` all return
+            ``True``.
+
+        Raises
+        ------
+        numpy.linalg.LinAlgError: Singular matrix
+            If `self` is singular.
+
+        See Also
+        --------
+        linalg.inv
+
+        Examples
+        --------
+        >>> m = np.matrix('[1, 2; 3, 4]'); m
+        matrix([[1, 2],
+                [3, 4]])
+        >>> m.getI()
+        matrix([[-2. ,  1. ],
+                [ 1.5, -0.5]])
+        >>> m.getI() * m
+        matrix([[ 1.,  0.], # may vary
+                [ 0.,  1.]])
+
+        """
+        M, N = self.shape
+        if M == N:
+            from numpy.linalg import inv as func
+        else:
+            from numpy.linalg import pinv as func
+        return asmatrix(func(self))
+
+    @property
+    def A(self):
+        """
+        Return `self` as an `ndarray` object.
+
+        Equivalent to ``np.asarray(self)``.
+
+        Parameters
+        ----------
+        None
+
+        Returns
+        -------
+        ret : ndarray
+            `self` as an `ndarray`
+
+        Examples
+        --------
+        >>> x = np.matrix(np.arange(12).reshape((3,4))); x
+        matrix([[ 0,  1,  2,  3],
+                [ 4,  5,  6,  7],
+                [ 8,  9, 10, 11]])
+        >>> x.getA()
+        array([[ 0,  1,  2,  3],
+               [ 4,  5,  6,  7],
+               [ 8,  9, 10, 11]])
+
+        """
+        return self.__array__()
+
+    @property
+    def A1(self):
+        """
+        Return `self` as a flattened `ndarray`.
+
+        Equivalent to ``np.asarray(x).ravel()``
+
+        Parameters
+        ----------
+        None
+
+        Returns
+        -------
+        ret : ndarray
+            `self`, 1-D, as an `ndarray`
+
+        Examples
+        --------
+        >>> x = np.matrix(np.arange(12).reshape((3,4))); x
+        matrix([[ 0,  1,  2,  3],
+                [ 4,  5,  6,  7],
+                [ 8,  9, 10, 11]])
+        >>> x.getA1()
+        array([ 0,  1,  2, ...,  9, 10, 11])
+
+
+        """
+        return self.__array__().ravel()
+
+
+    def ravel(self, order='C'):
+        """
+        Return a flattened matrix.
+
+        Refer to `numpy.ravel` for more documentation.
+
+        Parameters
+        ----------
+        order : {'C', 'F', 'A', 'K'}, optional
+            The elements of `m` are read using this index order. 'C' means to
+            index the elements in C-like order, with the last axis index
+            changing fastest, back to the first axis index changing slowest.
+            'F' means to index the elements in Fortran-like index order, with
+            the first index changing fastest, and the last index changing
+            slowest. Note that the 'C' and 'F' options take no account of the
+            memory layout of the underlying array, and only refer to the order
+            of axis indexing.  'A' means to read the elements in Fortran-like
+            index order if `m` is Fortran *contiguous* in memory, C-like order
+            otherwise.  'K' means to read the elements in the order they occur
+            in memory, except for reversing the data when strides are negative.
+            By default, 'C' index order is used.
+
+        Returns
+        -------
+        ret : matrix
+            Return the matrix flattened to shape `(1, N)` where `N`
+            is the number of elements in the original matrix.
+            A copy is made only if necessary.
+
+        See Also
+        --------
+        matrix.flatten : returns a similar output matrix but always a copy
+        matrix.flat : a flat iterator on the array.
+        numpy.ravel : related function which returns an ndarray
+
+        """
+        return N.ndarray.ravel(self, order=order)
+
+    @property
+    def T(self):
+        """
+        Returns the transpose of the matrix.
+
+        Does *not* conjugate!  For the complex conjugate transpose, use ``.H``.
+
+        Parameters
+        ----------
+        None
+
+        Returns
+        -------
+        ret : matrix object
+            The (non-conjugated) transpose of the matrix.
+
+        See Also
+        --------
+        transpose, getH
+
+        Examples
+        --------
+        >>> m = np.matrix('[1, 2; 3, 4]')
+        >>> m
+        matrix([[1, 2],
+                [3, 4]])
+        >>> m.getT()
+        matrix([[1, 3],
+                [2, 4]])
+
+        """
+        return self.transpose()
+
+    @property
+    def H(self):
+        """
+        Returns the (complex) conjugate transpose of `self`.
+
+        Equivalent to ``np.transpose(self)`` if `self` is real-valued.
+
+        Parameters
+        ----------
+        None
+
+        Returns
+        -------
+        ret : matrix object
+            complex conjugate transpose of `self`
+
+        Examples
+        --------
+        >>> x = np.matrix(np.arange(12).reshape((3,4)))
+        >>> z = x - 1j*x; z
+        matrix([[  0. +0.j,   1. -1.j,   2. -2.j,   3. -3.j],
+                [  4. -4.j,   5. -5.j,   6. -6.j,   7. -7.j],
+                [  8. -8.j,   9. -9.j,  10.-10.j,  11.-11.j]])
+        >>> z.getH()
+        matrix([[ 0. -0.j,  4. +4.j,  8. +8.j],
+                [ 1. +1.j,  5. +5.j,  9. +9.j],
+                [ 2. +2.j,  6. +6.j, 10.+10.j],
+                [ 3. +3.j,  7. +7.j, 11.+11.j]])
+
+        """
+        if issubclass(self.dtype.type, N.complexfloating):
+            return self.transpose().conjugate()
+        else:
+            return self.transpose()
+
+    # kept for compatibility
+    getT = T.fget
+    getA = A.fget
+    getA1 = A1.fget
+    getH = H.fget
+    getI = I.fget
+
+def _from_string(str, gdict, ldict):
+    rows = str.split(';')
+    rowtup = []
+    for row in rows:
+        trow = row.split(',')
+        newrow = []
+        for x in trow:
+            newrow.extend(x.split())
+        trow = newrow
+        coltup = []
+        for col in trow:
+            col = col.strip()
+            try:
+                thismat = ldict[col]
+            except KeyError:
+                try:
+                    thismat = gdict[col]
+                except KeyError as e:
+                    raise NameError(f"name {col!r} is not defined") from None
+
+            coltup.append(thismat)
+        rowtup.append(concatenate(coltup, axis=-1))
+    return concatenate(rowtup, axis=0)
+
+
+@set_module('numpy')
+def bmat(obj, ldict=None, gdict=None):
+    """
+    Build a matrix object from a string, nested sequence, or array.
+
+    Parameters
+    ----------
+    obj : str or array_like
+        Input data. If a string, variables in the current scope may be
+        referenced by name.
+    ldict : dict, optional
+        A dictionary that replaces local operands in current frame.
+        Ignored if `obj` is not a string or `gdict` is None.
+    gdict : dict, optional
+        A dictionary that replaces global operands in current frame.
+        Ignored if `obj` is not a string.
+
+    Returns
+    -------
+    out : matrix
+        Returns a matrix object, which is a specialized 2-D array.
+
+    See Also
+    --------
+    block :
+        A generalization of this function for N-d arrays, that returns normal
+        ndarrays.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> A = np.asmatrix('1 1; 1 1')
+    >>> B = np.asmatrix('2 2; 2 2')
+    >>> C = np.asmatrix('3 4; 5 6')
+    >>> D = np.asmatrix('7 8; 9 0')
+
+    All the following expressions construct the same block matrix:
+
+    >>> np.bmat([[A, B], [C, D]])
+    matrix([[1, 1, 2, 2],
+            [1, 1, 2, 2],
+            [3, 4, 7, 8],
+            [5, 6, 9, 0]])
+    >>> np.bmat(np.r_[np.c_[A, B], np.c_[C, D]])
+    matrix([[1, 1, 2, 2],
+            [1, 1, 2, 2],
+            [3, 4, 7, 8],
+            [5, 6, 9, 0]])
+    >>> np.bmat('A,B; C,D')
+    matrix([[1, 1, 2, 2],
+            [1, 1, 2, 2],
+            [3, 4, 7, 8],
+            [5, 6, 9, 0]])
+
+    """
+    if isinstance(obj, str):
+        if gdict is None:
+            # get previous frame
+            frame = sys._getframe().f_back
+            glob_dict = frame.f_globals
+            loc_dict = frame.f_locals
+        else:
+            glob_dict = gdict
+            loc_dict = ldict
+
+        return matrix(_from_string(obj, glob_dict, loc_dict))
+
+    if isinstance(obj, (tuple, list)):
+        # [[A,B],[C,D]]
+        arr_rows = []
+        for row in obj:
+            if isinstance(row, N.ndarray):  # not 2-d
+                return matrix(concatenate(obj, axis=-1))
+            else:
+                arr_rows.append(concatenate(row, axis=-1))
+        return matrix(concatenate(arr_rows, axis=0))
+    if isinstance(obj, N.ndarray):
+        return matrix(obj)
diff --git a/venv/lib/python3.12/site-packages/numpy/matrixlib/defmatrix.pyi b/venv/lib/python3.12/site-packages/numpy/matrixlib/defmatrix.pyi
new file mode 100644
index 00000000..9d0d1ee5
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/matrixlib/defmatrix.pyi
@@ -0,0 +1,16 @@
+from collections.abc import Sequence, Mapping
+from typing import Any
+from numpy import matrix as matrix
+from numpy._typing import ArrayLike, DTypeLike, NDArray
+
+__all__: list[str]
+
+def bmat(
+    obj: str | Sequence[ArrayLike] | NDArray[Any],
+    ldict: None | Mapping[str, Any] = ...,
+    gdict: None | Mapping[str, Any] = ...,
+) -> matrix[Any, Any]: ...
+
+def asmatrix(data: ArrayLike, dtype: DTypeLike = ...) -> matrix[Any, Any]: ...
+
+mat = asmatrix
diff --git a/venv/lib/python3.12/site-packages/numpy/matrixlib/tests/__init__.py b/venv/lib/python3.12/site-packages/numpy/matrixlib/tests/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/venv/lib/python3.12/site-packages/numpy/matrixlib/tests/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/matrixlib/tests/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 00000000..30029163
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/matrixlib/tests/__pycache__/__init__.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/matrixlib/tests/__pycache__/test_defmatrix.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/matrixlib/tests/__pycache__/test_defmatrix.cpython-312.pyc
new file mode 100644
index 00000000..4dda2326
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/matrixlib/tests/__pycache__/test_defmatrix.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/matrixlib/tests/__pycache__/test_interaction.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/matrixlib/tests/__pycache__/test_interaction.cpython-312.pyc
new file mode 100644
index 00000000..c30951d2
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/matrixlib/tests/__pycache__/test_interaction.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/matrixlib/tests/__pycache__/test_masked_matrix.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/matrixlib/tests/__pycache__/test_masked_matrix.cpython-312.pyc
new file mode 100644
index 00000000..ef267001
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/matrixlib/tests/__pycache__/test_masked_matrix.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/matrixlib/tests/__pycache__/test_matrix_linalg.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/matrixlib/tests/__pycache__/test_matrix_linalg.cpython-312.pyc
new file mode 100644
index 00000000..ca3d03f3
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/matrixlib/tests/__pycache__/test_matrix_linalg.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/matrixlib/tests/__pycache__/test_multiarray.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/matrixlib/tests/__pycache__/test_multiarray.cpython-312.pyc
new file mode 100644
index 00000000..576e92e7
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/matrixlib/tests/__pycache__/test_multiarray.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/matrixlib/tests/__pycache__/test_numeric.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/matrixlib/tests/__pycache__/test_numeric.cpython-312.pyc
new file mode 100644
index 00000000..582482ac
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/matrixlib/tests/__pycache__/test_numeric.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/matrixlib/tests/__pycache__/test_regression.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/matrixlib/tests/__pycache__/test_regression.cpython-312.pyc
new file mode 100644
index 00000000..5799029b
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/matrixlib/tests/__pycache__/test_regression.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/matrixlib/tests/test_defmatrix.py b/venv/lib/python3.12/site-packages/numpy/matrixlib/tests/test_defmatrix.py
new file mode 100644
index 00000000..81d955e8
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/matrixlib/tests/test_defmatrix.py
@@ -0,0 +1,453 @@
+import collections.abc
+
+import numpy as np
+from numpy import matrix, asmatrix, bmat
+from numpy.testing import (
+    assert_, assert_equal, assert_almost_equal, assert_array_equal,
+    assert_array_almost_equal, assert_raises
+    )
+from numpy.linalg import matrix_power
+
+class TestCtor:
+    def test_basic(self):
+        A = np.array([[1, 2], [3, 4]])
+        mA = matrix(A)
+        assert_(np.all(mA.A == A))
+
+        B = bmat("A,A;A,A")
+        C = bmat([[A, A], [A, A]])
+        D = np.array([[1, 2, 1, 2],
+                      [3, 4, 3, 4],
+                      [1, 2, 1, 2],
+                      [3, 4, 3, 4]])
+        assert_(np.all(B.A == D))
+        assert_(np.all(C.A == D))
+
+        E = np.array([[5, 6], [7, 8]])
+        AEresult = matrix([[1, 2, 5, 6], [3, 4, 7, 8]])
+        assert_(np.all(bmat([A, E]) == AEresult))
+
+        vec = np.arange(5)
+        mvec = matrix(vec)
+        assert_(mvec.shape == (1, 5))
+
+    def test_exceptions(self):
+        # Check for ValueError when called with invalid string data.
+        assert_raises(ValueError, matrix, "invalid")
+
+    def test_bmat_nondefault_str(self):
+        A = np.array([[1, 2], [3, 4]])
+        B = np.array([[5, 6], [7, 8]])
+        Aresult = np.array([[1, 2, 1, 2],
+                            [3, 4, 3, 4],
+                            [1, 2, 1, 2],
+                            [3, 4, 3, 4]])
+        mixresult = np.array([[1, 2, 5, 6],
+                              [3, 4, 7, 8],
+                              [5, 6, 1, 2],
+                              [7, 8, 3, 4]])
+        assert_(np.all(bmat("A,A;A,A") == Aresult))
+        assert_(np.all(bmat("A,A;A,A", ldict={'A':B}) == Aresult))
+        assert_raises(TypeError, bmat, "A,A;A,A", gdict={'A':B})
+        assert_(
+            np.all(bmat("A,A;A,A", ldict={'A':A}, gdict={'A':B}) == Aresult))
+        b2 = bmat("A,B;C,D", ldict={'A':A,'B':B}, gdict={'C':B,'D':A})
+        assert_(np.all(b2 == mixresult))
+
+
+class TestProperties:
+    def test_sum(self):
+        """Test whether matrix.sum(axis=1) preserves orientation.
+        Fails in NumPy <= 0.9.6.2127.
+        """
+        M = matrix([[1, 2, 0, 0],
+                   [3, 4, 0, 0],
+                   [1, 2, 1, 2],
+                   [3, 4, 3, 4]])
+        sum0 = matrix([8, 12, 4, 6])
+        sum1 = matrix([3, 7, 6, 14]).T
+        sumall = 30
+        assert_array_equal(sum0, M.sum(axis=0))
+        assert_array_equal(sum1, M.sum(axis=1))
+        assert_equal(sumall, M.sum())
+
+        assert_array_equal(sum0, np.sum(M, axis=0))
+        assert_array_equal(sum1, np.sum(M, axis=1))
+        assert_equal(sumall, np.sum(M))
+
+    def test_prod(self):
+        x = matrix([[1, 2, 3], [4, 5, 6]])
+        assert_equal(x.prod(), 720)
+        assert_equal(x.prod(0), matrix([[4, 10, 18]]))
+        assert_equal(x.prod(1), matrix([[6], [120]]))
+
+        assert_equal(np.prod(x), 720)
+        assert_equal(np.prod(x, axis=0), matrix([[4, 10, 18]]))
+        assert_equal(np.prod(x, axis=1), matrix([[6], [120]]))
+
+        y = matrix([0, 1, 3])
+        assert_(y.prod() == 0)
+
+    def test_max(self):
+        x = matrix([[1, 2, 3], [4, 5, 6]])
+        assert_equal(x.max(), 6)
+        assert_equal(x.max(0), matrix([[4, 5, 6]]))
+        assert_equal(x.max(1), matrix([[3], [6]]))
+
+        assert_equal(np.max(x), 6)
+        assert_equal(np.max(x, axis=0), matrix([[4, 5, 6]]))
+        assert_equal(np.max(x, axis=1), matrix([[3], [6]]))
+
+    def test_min(self):
+        x = matrix([[1, 2, 3], [4, 5, 6]])
+        assert_equal(x.min(), 1)
+        assert_equal(x.min(0), matrix([[1, 2, 3]]))
+        assert_equal(x.min(1), matrix([[1], [4]]))
+
+        assert_equal(np.min(x), 1)
+        assert_equal(np.min(x, axis=0), matrix([[1, 2, 3]]))
+        assert_equal(np.min(x, axis=1), matrix([[1], [4]]))
+
+    def test_ptp(self):
+        x = np.arange(4).reshape((2, 2))
+        mx = x.view(np.matrix)
+        assert_(mx.ptp() == 3)
+        assert_(np.all(mx.ptp(0) == np.array([2, 2])))
+        assert_(np.all(mx.ptp(1) == np.array([1, 1])))
+
+    def test_var(self):
+        x = np.arange(9).reshape((3, 3))
+        mx = x.view(np.matrix)
+        assert_equal(x.var(ddof=0), mx.var(ddof=0))
+        assert_equal(x.var(ddof=1), mx.var(ddof=1))
+
+    def test_basic(self):
+        import numpy.linalg as linalg
+
+        A = np.array([[1., 2.],
+                      [3., 4.]])
+        mA = matrix(A)
+        assert_(np.allclose(linalg.inv(A), mA.I))
+        assert_(np.all(np.array(np.transpose(A) == mA.T)))
+        assert_(np.all(np.array(np.transpose(A) == mA.H)))
+        assert_(np.all(A == mA.A))
+
+        B = A + 2j*A
+        mB = matrix(B)
+        assert_(np.allclose(linalg.inv(B), mB.I))
+        assert_(np.all(np.array(np.transpose(B) == mB.T)))
+        assert_(np.all(np.array(np.transpose(B).conj() == mB.H)))
+
+    def test_pinv(self):
+        x = matrix(np.arange(6).reshape(2, 3))
+        xpinv = matrix([[-0.77777778,  0.27777778],
+                        [-0.11111111,  0.11111111],
+                        [ 0.55555556, -0.05555556]])
+        assert_almost_equal(x.I, xpinv)
+
+    def test_comparisons(self):
+        A = np.arange(100).reshape(10, 10)
+        mA = matrix(A)
+        mB = matrix(A) + 0.1
+        assert_(np.all(mB == A+0.1))
+        assert_(np.all(mB == matrix(A+0.1)))
+        assert_(not np.any(mB == matrix(A-0.1)))
+        assert_(np.all(mA < mB))
+        assert_(np.all(mA <= mB))
+        assert_(np.all(mA <= mA))
+        assert_(not np.any(mA < mA))
+
+        assert_(not np.any(mB < mA))
+        assert_(np.all(mB >= mA))
+        assert_(np.all(mB >= mB))
+        assert_(not np.any(mB > mB))
+
+        assert_(np.all(mA == mA))
+        assert_(not np.any(mA == mB))
+        assert_(np.all(mB != mA))
+
+        assert_(not np.all(abs(mA) > 0))
+        assert_(np.all(abs(mB > 0)))
+
+    def test_asmatrix(self):
+        A = np.arange(100).reshape(10, 10)
+        mA = asmatrix(A)
+        A[0, 0] = -10
+        assert_(A[0, 0] == mA[0, 0])
+
+    def test_noaxis(self):
+        A = matrix([[1, 0], [0, 1]])
+        assert_(A.sum() == matrix(2))
+        assert_(A.mean() == matrix(0.5))
+
+    def test_repr(self):
+        A = matrix([[1, 0], [0, 1]])
+        assert_(repr(A) == "matrix([[1, 0],\n        [0, 1]])")
+
+    def test_make_bool_matrix_from_str(self):
+        A = matrix('True; True; False')
+        B = matrix([[True], [True], [False]])
+        assert_array_equal(A, B)
+
+class TestCasting:
+    def test_basic(self):
+        A = np.arange(100).reshape(10, 10)
+        mA = matrix(A)
+
+        mB = mA.copy()
+        O = np.ones((10, 10), np.float64) * 0.1
+        mB = mB + O
+        assert_(mB.dtype.type == np.float64)
+        assert_(np.all(mA != mB))
+        assert_(np.all(mB == mA+0.1))
+
+        mC = mA.copy()
+        O = np.ones((10, 10), np.complex128)
+        mC = mC * O
+        assert_(mC.dtype.type == np.complex128)
+        assert_(np.all(mA != mB))
+
+
+class TestAlgebra:
+    def test_basic(self):
+        import numpy.linalg as linalg
+
+        A = np.array([[1., 2.], [3., 4.]])
+        mA = matrix(A)
+
+        B = np.identity(2)
+        for i in range(6):
+            assert_(np.allclose((mA ** i).A, B))
+            B = np.dot(B, A)
+
+        Ainv = linalg.inv(A)
+        B = np.identity(2)
+        for i in range(6):
+            assert_(np.allclose((mA ** -i).A, B))
+            B = np.dot(B, Ainv)
+
+        assert_(np.allclose((mA * mA).A, np.dot(A, A)))
+        assert_(np.allclose((mA + mA).A, (A + A)))
+        assert_(np.allclose((3*mA).A, (3*A)))
+
+        mA2 = matrix(A)
+        mA2 *= 3
+        assert_(np.allclose(mA2.A, 3*A))
+
+    def test_pow(self):
+        """Test raising a matrix to an integer power works as expected."""
+        m = matrix("1. 2.; 3. 4.")
+        m2 = m.copy()
+        m2 **= 2
+        mi = m.copy()
+        mi **= -1
+        m4 = m2.copy()
+        m4 **= 2
+        assert_array_almost_equal(m2, m**2)
+        assert_array_almost_equal(m4, np.dot(m2, m2))
+        assert_array_almost_equal(np.dot(mi, m), np.eye(2))
+
+    def test_scalar_type_pow(self):
+        m = matrix([[1, 2], [3, 4]])
+        for scalar_t in [np.int8, np.uint8]:
+            two = scalar_t(2)
+            assert_array_almost_equal(m ** 2, m ** two)
+
+    def test_notimplemented(self):
+        '''Check that 'not implemented' operations produce a failure.'''
+        A = matrix([[1., 2.],
+                    [3., 4.]])
+
+        # __rpow__
+        with assert_raises(TypeError):
+            1.0**A
+
+        # __mul__ with something not a list, ndarray, tuple, or scalar
+        with assert_raises(TypeError):
+            A*object()
+
+
+class TestMatrixReturn:
+    def test_instance_methods(self):
+        a = matrix([1.0], dtype='f8')
+        methodargs = {
+            'astype': ('intc',),
+            'clip': (0.0, 1.0),
+            'compress': ([1],),
+            'repeat': (1,),
+            'reshape': (1,),
+            'swapaxes': (0, 0),
+            'dot': np.array([1.0]),
+            }
+        excluded_methods = [
+            'argmin', 'choose', 'dump', 'dumps', 'fill', 'getfield',
+            'getA', 'getA1', 'item', 'nonzero', 'put', 'putmask', 'resize',
+            'searchsorted', 'setflags', 'setfield', 'sort',
+            'partition', 'argpartition', 'newbyteorder', 'to_device',
+            'take', 'tofile', 'tolist', 'tostring', 'tobytes', 'all', 'any',
+            'sum', 'argmax', 'argmin', 'min', 'max', 'mean', 'var', 'ptp',
+            'prod', 'std', 'ctypes', 'itemset', 'bitwise_count',
+            ]
+        for attrib in dir(a):
+            if attrib.startswith('_') or attrib in excluded_methods:
+                continue
+            f = getattr(a, attrib)
+            if isinstance(f, collections.abc.Callable):
+                # reset contents of a
+                a.astype('f8')
+                a.fill(1.0)
+                if attrib in methodargs:
+                    args = methodargs[attrib]
+                else:
+                    args = ()
+                b = f(*args)
+                assert_(type(b) is matrix, "%s" % attrib)
+        assert_(type(a.real) is matrix)
+        assert_(type(a.imag) is matrix)
+        c, d = matrix([0.0]).nonzero()
+        assert_(type(c) is np.ndarray)
+        assert_(type(d) is np.ndarray)
+
+
+class TestIndexing:
+    def test_basic(self):
+        x = asmatrix(np.zeros((3, 2), float))
+        y = np.zeros((3, 1), float)
+        y[:, 0] = [0.8, 0.2, 0.3]
+        x[:, 1] = y > 0.5
+        assert_equal(x, [[0, 1], [0, 0], [0, 0]])
+
+
+class TestNewScalarIndexing:
+    a = matrix([[1, 2], [3, 4]])
+
+    def test_dimesions(self):
+        a = self.a
+        x = a[0]
+        assert_equal(x.ndim, 2)
+
+    def test_array_from_matrix_list(self):
+        a = self.a
+        x = np.array([a, a])
+        assert_equal(x.shape, [2, 2, 2])
+
+    def test_array_to_list(self):
+        a = self.a
+        assert_equal(a.tolist(), [[1, 2], [3, 4]])
+
+    def test_fancy_indexing(self):
+        a = self.a
+        x = a[1, [0, 1, 0]]
+        assert_(isinstance(x, matrix))
+        assert_equal(x, matrix([[3,  4,  3]]))
+        x = a[[1, 0]]
+        assert_(isinstance(x, matrix))
+        assert_equal(x, matrix([[3,  4], [1, 2]]))
+        x = a[[[1], [0]], [[1, 0], [0, 1]]]
+        assert_(isinstance(x, matrix))
+        assert_equal(x, matrix([[4,  3], [1,  2]]))
+
+    def test_matrix_element(self):
+        x = matrix([[1, 2, 3], [4, 5, 6]])
+        assert_equal(x[0][0], matrix([[1, 2, 3]]))
+        assert_equal(x[0][0].shape, (1, 3))
+        assert_equal(x[0].shape, (1, 3))
+        assert_equal(x[:, 0].shape, (2, 1))
+
+        x = matrix(0)
+        assert_equal(x[0, 0], 0)
+        assert_equal(x[0], 0)
+        assert_equal(x[:, 0].shape, x.shape)
+
+    def test_scalar_indexing(self):
+        x = asmatrix(np.zeros((3, 2), float))
+        assert_equal(x[0, 0], x[0][0])
+
+    def test_row_column_indexing(self):
+        x = asmatrix(np.eye(2))
+        assert_array_equal(x[0,:], [[1, 0]])
+        assert_array_equal(x[1,:], [[0, 1]])
+        assert_array_equal(x[:, 0], [[1], [0]])
+        assert_array_equal(x[:, 1], [[0], [1]])
+
+    def test_boolean_indexing(self):
+        A = np.arange(6)
+        A.shape = (3, 2)
+        x = asmatrix(A)
+        assert_array_equal(x[:, np.array([True, False])], x[:, 0])
+        assert_array_equal(x[np.array([True, False, False]),:], x[0,:])
+
+    def test_list_indexing(self):
+        A = np.arange(6)
+        A.shape = (3, 2)
+        x = asmatrix(A)
+        assert_array_equal(x[:, [1, 0]], x[:, ::-1])
+        assert_array_equal(x[[2, 1, 0],:], x[::-1,:])
+
+
+class TestPower:
+    def test_returntype(self):
+        a = np.array([[0, 1], [0, 0]])
+        assert_(type(matrix_power(a, 2)) is np.ndarray)
+        a = asmatrix(a)
+        assert_(type(matrix_power(a, 2)) is matrix)
+
+    def test_list(self):
+        assert_array_equal(matrix_power([[0, 1], [0, 0]], 2), [[0, 0], [0, 0]])
+
+
+class TestShape:
+
+    a = np.array([[1], [2]])
+    m = matrix([[1], [2]])
+
+    def test_shape(self):
+        assert_equal(self.a.shape, (2, 1))
+        assert_equal(self.m.shape, (2, 1))
+
+    def test_numpy_ravel(self):
+        assert_equal(np.ravel(self.a).shape, (2,))
+        assert_equal(np.ravel(self.m).shape, (2,))
+
+    def test_member_ravel(self):
+        assert_equal(self.a.ravel().shape, (2,))
+        assert_equal(self.m.ravel().shape, (1, 2))
+
+    def test_member_flatten(self):
+        assert_equal(self.a.flatten().shape, (2,))
+        assert_equal(self.m.flatten().shape, (1, 2))
+
+    def test_numpy_ravel_order(self):
+        x = np.array([[1, 2, 3], [4, 5, 6]])
+        assert_equal(np.ravel(x), [1, 2, 3, 4, 5, 6])
+        assert_equal(np.ravel(x, order='F'), [1, 4, 2, 5, 3, 6])
+        assert_equal(np.ravel(x.T), [1, 4, 2, 5, 3, 6])
+        assert_equal(np.ravel(x.T, order='A'), [1, 2, 3, 4, 5, 6])
+        x = matrix([[1, 2, 3], [4, 5, 6]])
+        assert_equal(np.ravel(x), [1, 2, 3, 4, 5, 6])
+        assert_equal(np.ravel(x, order='F'), [1, 4, 2, 5, 3, 6])
+        assert_equal(np.ravel(x.T), [1, 4, 2, 5, 3, 6])
+        assert_equal(np.ravel(x.T, order='A'), [1, 2, 3, 4, 5, 6])
+
+    def test_matrix_ravel_order(self):
+        x = matrix([[1, 2, 3], [4, 5, 6]])
+        assert_equal(x.ravel(), [[1, 2, 3, 4, 5, 6]])
+        assert_equal(x.ravel(order='F'), [[1, 4, 2, 5, 3, 6]])
+        assert_equal(x.T.ravel(), [[1, 4, 2, 5, 3, 6]])
+        assert_equal(x.T.ravel(order='A'), [[1, 2, 3, 4, 5, 6]])
+
+    def test_array_memory_sharing(self):
+        assert_(np.may_share_memory(self.a, self.a.ravel()))
+        assert_(not np.may_share_memory(self.a, self.a.flatten()))
+
+    def test_matrix_memory_sharing(self):
+        assert_(np.may_share_memory(self.m, self.m.ravel()))
+        assert_(not np.may_share_memory(self.m, self.m.flatten()))
+
+    def test_expand_dims_matrix(self):
+        # matrices are always 2d - so expand_dims only makes sense when the
+        # type is changed away from matrix.
+        a = np.arange(10).reshape((2, 5)).view(np.matrix)
+        expanded = np.expand_dims(a, axis=1)
+        assert_equal(expanded.ndim, 3)
+        assert_(not isinstance(expanded, np.matrix))
diff --git a/venv/lib/python3.12/site-packages/numpy/matrixlib/tests/test_interaction.py b/venv/lib/python3.12/site-packages/numpy/matrixlib/tests/test_interaction.py
new file mode 100644
index 00000000..0c6bf210
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/matrixlib/tests/test_interaction.py
@@ -0,0 +1,354 @@
+"""Tests of interaction of matrix with other parts of numpy.
+
+Note that tests with MaskedArray and linalg are done in separate files.
+"""
+import pytest
+
+import textwrap
+import warnings
+
+import numpy as np
+from numpy.testing import (assert_, assert_equal, assert_raises,
+                           assert_raises_regex, assert_array_equal,
+                           assert_almost_equal, assert_array_almost_equal)
+
+
+def test_fancy_indexing():
+    # The matrix class messes with the shape. While this is always
+    # weird (getitem is not used, it does not have setitem nor knows
+    # about fancy indexing), this tests gh-3110
+    # 2018-04-29: moved here from core.tests.test_index.
+    m = np.matrix([[1, 2], [3, 4]])
+
+    assert_(isinstance(m[[0, 1, 0], :], np.matrix))
+
+    # gh-3110. Note the transpose currently because matrices do *not*
+    # support dimension fixing for fancy indexing correctly.
+    x = np.asmatrix(np.arange(50).reshape(5, 10))
+    assert_equal(x[:2, np.array(-1)], x[:2, -1].T)
+
+
+def test_polynomial_mapdomain():
+    # test that polynomial preserved matrix subtype.
+    # 2018-04-29: moved here from polynomial.tests.polyutils.
+    dom1 = [0, 4]
+    dom2 = [1, 3]
+    x = np.matrix([dom1, dom1])
+    res = np.polynomial.polyutils.mapdomain(x, dom1, dom2)
+    assert_(isinstance(res, np.matrix))
+
+
+def test_sort_matrix_none():
+    # 2018-04-29: moved here from core.tests.test_multiarray
+    a = np.matrix([[2, 1, 0]])
+    actual = np.sort(a, axis=None)
+    expected = np.matrix([[0, 1, 2]])
+    assert_equal(actual, expected)
+    assert_(type(expected) is np.matrix)
+
+
+def test_partition_matrix_none():
+    # gh-4301
+    # 2018-04-29: moved here from core.tests.test_multiarray
+    a = np.matrix([[2, 1, 0]])
+    actual = np.partition(a, 1, axis=None)
+    expected = np.matrix([[0, 1, 2]])
+    assert_equal(actual, expected)
+    assert_(type(expected) is np.matrix)
+
+
+def test_dot_scalar_and_matrix_of_objects():
+    # Ticket #2469
+    # 2018-04-29: moved here from core.tests.test_multiarray
+    arr = np.matrix([1, 2], dtype=object)
+    desired = np.matrix([[3, 6]], dtype=object)
+    assert_equal(np.dot(arr, 3), desired)
+    assert_equal(np.dot(3, arr), desired)
+
+
+def test_inner_scalar_and_matrix():
+    # 2018-04-29: moved here from core.tests.test_multiarray
+    for dt in np.typecodes['AllInteger'] + np.typecodes['AllFloat'] + '?':
+        sca = np.array(3, dtype=dt)[()]
+        arr = np.matrix([[1, 2], [3, 4]], dtype=dt)
+        desired = np.matrix([[3, 6], [9, 12]], dtype=dt)
+        assert_equal(np.inner(arr, sca), desired)
+        assert_equal(np.inner(sca, arr), desired)
+
+
+def test_inner_scalar_and_matrix_of_objects():
+    # Ticket #4482
+    # 2018-04-29: moved here from core.tests.test_multiarray
+    arr = np.matrix([1, 2], dtype=object)
+    desired = np.matrix([[3, 6]], dtype=object)
+    assert_equal(np.inner(arr, 3), desired)
+    assert_equal(np.inner(3, arr), desired)
+
+
+def test_iter_allocate_output_subtype():
+    # Make sure that the subtype with priority wins
+    # 2018-04-29: moved here from core.tests.test_nditer, given the
+    # matrix specific shape test.
+
+    # matrix vs ndarray
+    a = np.matrix([[1, 2], [3, 4]])
+    b = np.arange(4).reshape(2, 2).T
+    i = np.nditer([a, b, None], [],
+                  [['readonly'], ['readonly'], ['writeonly', 'allocate']])
+    assert_(type(i.operands[2]) is np.matrix)
+    assert_(type(i.operands[2]) is not np.ndarray)
+    assert_equal(i.operands[2].shape, (2, 2))
+
+    # matrix always wants things to be 2D
+    b = np.arange(4).reshape(1, 2, 2)
+    assert_raises(RuntimeError, np.nditer, [a, b, None], [],
+                  [['readonly'], ['readonly'], ['writeonly', 'allocate']])
+    # but if subtypes are disabled, the result can still work
+    i = np.nditer([a, b, None], [],
+                  [['readonly'], ['readonly'],
+                   ['writeonly', 'allocate', 'no_subtype']])
+    assert_(type(i.operands[2]) is np.ndarray)
+    assert_(type(i.operands[2]) is not np.matrix)
+    assert_equal(i.operands[2].shape, (1, 2, 2))
+
+
+def like_function():
+    # 2018-04-29: moved here from core.tests.test_numeric
+    a = np.matrix([[1, 2], [3, 4]])
+    for like_function in np.zeros_like, np.ones_like, np.empty_like:
+        b = like_function(a)
+        assert_(type(b) is np.matrix)
+
+        c = like_function(a, subok=False)
+        assert_(type(c) is not np.matrix)
+
+
+def test_array_astype():
+    # 2018-04-29: copied here from core.tests.test_api
+    # subok=True passes through a matrix
+    a = np.matrix([[0, 1, 2], [3, 4, 5]], dtype='f4')
+    b = a.astype('f4', subok=True, copy=False)
+    assert_(a is b)
+
+    # subok=True is default, and creates a subtype on a cast
+    b = a.astype('i4', copy=False)
+    assert_equal(a, b)
+    assert_equal(type(b), np.matrix)
+
+    # subok=False never returns a matrix
+    b = a.astype('f4', subok=False, copy=False)
+    assert_equal(a, b)
+    assert_(not (a is b))
+    assert_(type(b) is not np.matrix)
+
+
+def test_stack():
+    # 2018-04-29: copied here from core.tests.test_shape_base
+    # check np.matrix cannot be stacked
+    m = np.matrix([[1, 2], [3, 4]])
+    assert_raises_regex(ValueError, 'shape too large to be a matrix',
+                        np.stack, [m, m])
+
+
+def test_object_scalar_multiply():
+    # Tickets #2469 and #4482
+    # 2018-04-29: moved here from core.tests.test_ufunc
+    arr = np.matrix([1, 2], dtype=object)
+    desired = np.matrix([[3, 6]], dtype=object)
+    assert_equal(np.multiply(arr, 3), desired)
+    assert_equal(np.multiply(3, arr), desired)
+
+
+def test_nanfunctions_matrices():
+    # Check that it works and that type and
+    # shape are preserved
+    # 2018-04-29: moved here from core.tests.test_nanfunctions
+    mat = np.matrix(np.eye(3))
+    for f in [np.nanmin, np.nanmax]:
+        res = f(mat, axis=0)
+        assert_(isinstance(res, np.matrix))
+        assert_(res.shape == (1, 3))
+        res = f(mat, axis=1)
+        assert_(isinstance(res, np.matrix))
+        assert_(res.shape == (3, 1))
+        res = f(mat)
+        assert_(np.isscalar(res))
+    # check that rows of nan are dealt with for subclasses (#4628)
+    mat[1] = np.nan
+    for f in [np.nanmin, np.nanmax]:
+        with warnings.catch_warnings(record=True) as w:
+            warnings.simplefilter('always')
+            res = f(mat, axis=0)
+            assert_(isinstance(res, np.matrix))
+            assert_(not np.any(np.isnan(res)))
+            assert_(len(w) == 0)
+
+        with warnings.catch_warnings(record=True) as w:
+            warnings.simplefilter('always')
+            res = f(mat, axis=1)
+            assert_(isinstance(res, np.matrix))
+            assert_(np.isnan(res[1, 0]) and not np.isnan(res[0, 0])
+                    and not np.isnan(res[2, 0]))
+            assert_(len(w) == 1, 'no warning raised')
+            assert_(issubclass(w[0].category, RuntimeWarning))
+
+        with warnings.catch_warnings(record=True) as w:
+            warnings.simplefilter('always')
+            res = f(mat)
+            assert_(np.isscalar(res))
+            assert_(res != np.nan)
+            assert_(len(w) == 0)
+
+
+def test_nanfunctions_matrices_general():
+    # Check that it works and that type and
+    # shape are preserved
+    # 2018-04-29: moved here from core.tests.test_nanfunctions
+    mat = np.matrix(np.eye(3))
+    for f in (np.nanargmin, np.nanargmax, np.nansum, np.nanprod,
+              np.nanmean, np.nanvar, np.nanstd):
+        res = f(mat, axis=0)
+        assert_(isinstance(res, np.matrix))
+        assert_(res.shape == (1, 3))
+        res = f(mat, axis=1)
+        assert_(isinstance(res, np.matrix))
+        assert_(res.shape == (3, 1))
+        res = f(mat)
+        assert_(np.isscalar(res))
+
+    for f in np.nancumsum, np.nancumprod:
+        res = f(mat, axis=0)
+        assert_(isinstance(res, np.matrix))
+        assert_(res.shape == (3, 3))
+        res = f(mat, axis=1)
+        assert_(isinstance(res, np.matrix))
+        assert_(res.shape == (3, 3))
+        res = f(mat)
+        assert_(isinstance(res, np.matrix))
+        assert_(res.shape == (1, 3*3))
+
+
+def test_average_matrix():
+    # 2018-04-29: moved here from core.tests.test_function_base.
+    y = np.matrix(np.random.rand(5, 5))
+    assert_array_equal(y.mean(0), np.average(y, 0))
+
+    a = np.matrix([[1, 2], [3, 4]])
+    w = np.matrix([[1, 2], [3, 4]])
+
+    r = np.average(a, axis=0, weights=w)
+    assert_equal(type(r), np.matrix)
+    assert_equal(r, [[2.5, 10.0/3]])
+
+
+def test_dot_matrix():
+    # Test to make sure matrices give the same answer as ndarrays
+    # 2018-04-29: moved here from core.tests.test_function_base.
+    x = np.linspace(0, 5)
+    y = np.linspace(-5, 0)
+    mx = np.matrix(x)
+    my = np.matrix(y)
+    r = np.dot(x, y)
+    mr = np.dot(mx, my.T)
+    assert_almost_equal(mr, r)
+
+
+def test_ediff1d_matrix():
+    # 2018-04-29: moved here from core.tests.test_arraysetops.
+    assert(isinstance(np.ediff1d(np.matrix(1)), np.matrix))
+    assert(isinstance(np.ediff1d(np.matrix(1), to_begin=1), np.matrix))
+
+
+def test_apply_along_axis_matrix():
+    # this test is particularly malicious because matrix
+    # refuses to become 1d
+    # 2018-04-29: moved here from core.tests.test_shape_base.
+    def double(row):
+        return row * 2
+
+    m = np.matrix([[0, 1], [2, 3]])
+    expected = np.matrix([[0, 2], [4, 6]])
+
+    result = np.apply_along_axis(double, 0, m)
+    assert_(isinstance(result, np.matrix))
+    assert_array_equal(result, expected)
+
+    result = np.apply_along_axis(double, 1, m)
+    assert_(isinstance(result, np.matrix))
+    assert_array_equal(result, expected)
+
+
+def test_kron_matrix():
+    # 2018-04-29: moved here from core.tests.test_shape_base.
+    a = np.ones([2, 2])
+    m = np.asmatrix(a)
+    assert_equal(type(np.kron(a, a)), np.ndarray)
+    assert_equal(type(np.kron(m, m)), np.matrix)
+    assert_equal(type(np.kron(a, m)), np.matrix)
+    assert_equal(type(np.kron(m, a)), np.matrix)
+
+
+class TestConcatenatorMatrix:
+    # 2018-04-29: moved here from core.tests.test_index_tricks.
+    def test_matrix(self):
+        a = [1, 2]
+        b = [3, 4]
+
+        ab_r = np.r_['r', a, b]
+        ab_c = np.r_['c', a, b]
+
+        assert_equal(type(ab_r), np.matrix)
+        assert_equal(type(ab_c), np.matrix)
+
+        assert_equal(np.array(ab_r), [[1, 2, 3, 4]])
+        assert_equal(np.array(ab_c), [[1], [2], [3], [4]])
+
+        assert_raises(ValueError, lambda: np.r_['rc', a, b])
+
+    def test_matrix_scalar(self):
+        r = np.r_['r', [1, 2], 3]
+        assert_equal(type(r), np.matrix)
+        assert_equal(np.array(r), [[1, 2, 3]])
+
+    def test_matrix_builder(self):
+        a = np.array([1])
+        b = np.array([2])
+        c = np.array([3])
+        d = np.array([4])
+        actual = np.r_['a, b; c, d']
+        expected = np.bmat([[a, b], [c, d]])
+
+        assert_equal(actual, expected)
+        assert_equal(type(actual), type(expected))
+
+
+def test_array_equal_error_message_matrix():
+    # 2018-04-29: moved here from testing.tests.test_utils.
+    with pytest.raises(AssertionError) as exc_info:
+        assert_equal(np.array([1, 2]), np.matrix([1, 2]))
+    msg = str(exc_info.value)
+    msg_reference = textwrap.dedent("""\
+
+    Arrays are not equal
+
+    (shapes (2,), (1, 2) mismatch)
+     ACTUAL: array([1, 2])
+     DESIRED: matrix([[1, 2]])""")
+    assert_equal(msg, msg_reference)
+
+
+def test_array_almost_equal_matrix():
+    # Matrix slicing keeps things 2-D, while array does not necessarily.
+    # See gh-8452.
+    # 2018-04-29: moved here from testing.tests.test_utils.
+    m1 = np.matrix([[1., 2.]])
+    m2 = np.matrix([[1., np.nan]])
+    m3 = np.matrix([[1., -np.inf]])
+    m4 = np.matrix([[np.nan, np.inf]])
+    m5 = np.matrix([[1., 2.], [np.nan, np.inf]])
+    for assert_func in assert_array_almost_equal, assert_almost_equal:
+        for m in m1, m2, m3, m4, m5:
+            assert_func(m, m)
+            a = np.array(m)
+            assert_func(a, m)
+            assert_func(m, a)
diff --git a/venv/lib/python3.12/site-packages/numpy/matrixlib/tests/test_masked_matrix.py b/venv/lib/python3.12/site-packages/numpy/matrixlib/tests/test_masked_matrix.py
new file mode 100644
index 00000000..5303e6ce
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/matrixlib/tests/test_masked_matrix.py
@@ -0,0 +1,232 @@
+import pickle
+
+import numpy as np
+from numpy.testing import assert_warns
+from numpy.ma.testutils import (assert_, assert_equal, assert_raises,
+                                assert_array_equal)
+from numpy.ma.core import (masked_array, masked_values, masked, allequal,
+                           MaskType, getmask, MaskedArray, nomask,
+                           log, add, hypot, divide)
+from numpy.ma.extras import mr_
+
+
+class MMatrix(MaskedArray, np.matrix,):
+
+    def __new__(cls, data, mask=nomask):
+        mat = np.matrix(data)
+        _data = MaskedArray.__new__(cls, data=mat, mask=mask)
+        return _data
+
+    def __array_finalize__(self, obj):
+        np.matrix.__array_finalize__(self, obj)
+        MaskedArray.__array_finalize__(self, obj)
+        return
+
+    @property
+    def _series(self):
+        _view = self.view(MaskedArray)
+        _view._sharedmask = False
+        return _view
+
+
+class TestMaskedMatrix:
+    def test_matrix_indexing(self):
+        # Tests conversions and indexing
+        x1 = np.matrix([[1, 2, 3], [4, 3, 2]])
+        x2 = masked_array(x1, mask=[[1, 0, 0], [0, 1, 0]])
+        x3 = masked_array(x1, mask=[[0, 1, 0], [1, 0, 0]])
+        x4 = masked_array(x1)
+        # test conversion to strings
+        str(x2)  # raises?
+        repr(x2)  # raises?
+        # tests of indexing
+        assert_(type(x2[1, 0]) is type(x1[1, 0]))
+        assert_(x1[1, 0] == x2[1, 0])
+        assert_(x2[1, 1] is masked)
+        assert_equal(x1[0, 2], x2[0, 2])
+        assert_equal(x1[0, 1:], x2[0, 1:])
+        assert_equal(x1[:, 2], x2[:, 2])
+        assert_equal(x1[:], x2[:])
+        assert_equal(x1[1:], x3[1:])
+        x1[0, 2] = 9
+        x2[0, 2] = 9
+        assert_equal(x1, x2)
+        x1[0, 1:] = 99
+        x2[0, 1:] = 99
+        assert_equal(x1, x2)
+        x2[0, 1] = masked
+        assert_equal(x1, x2)
+        x2[0, 1:] = masked
+        assert_equal(x1, x2)
+        x2[0, :] = x1[0, :]
+        x2[0, 1] = masked
+        assert_(allequal(getmask(x2), np.array([[0, 1, 0], [0, 1, 0]])))
+        x3[1, :] = masked_array([1, 2, 3], [1, 1, 0])
+        assert_(allequal(getmask(x3)[1], masked_array([1, 1, 0])))
+        assert_(allequal(getmask(x3[1]), masked_array([1, 1, 0])))
+        x4[1, :] = masked_array([1, 2, 3], [1, 1, 0])
+        assert_(allequal(getmask(x4[1]), masked_array([1, 1, 0])))
+        assert_(allequal(x4[1], masked_array([1, 2, 3])))
+        x1 = np.matrix(np.arange(5) * 1.0)
+        x2 = masked_values(x1, 3.0)
+        assert_equal(x1, x2)
+        assert_(allequal(masked_array([0, 0, 0, 1, 0], dtype=MaskType),
+                         x2.mask))
+        assert_equal(3.0, x2.fill_value)
+
+    def test_pickling_subbaseclass(self):
+        # Test pickling w/ a subclass of ndarray
+        a = masked_array(np.matrix(list(range(10))), mask=[1, 0, 1, 0, 0] * 2)
+        for proto in range(2, pickle.HIGHEST_PROTOCOL + 1):
+            a_pickled = pickle.loads(pickle.dumps(a, protocol=proto))
+            assert_equal(a_pickled._mask, a._mask)
+            assert_equal(a_pickled, a)
+            assert_(isinstance(a_pickled._data, np.matrix))
+
+    def test_count_mean_with_matrix(self):
+        m = masked_array(np.matrix([[1, 2], [3, 4]]), mask=np.zeros((2, 2)))
+
+        assert_equal(m.count(axis=0).shape, (1, 2))
+        assert_equal(m.count(axis=1).shape, (2, 1))
+
+        # Make sure broadcasting inside mean and var work
+        assert_equal(m.mean(axis=0), [[2., 3.]])
+        assert_equal(m.mean(axis=1), [[1.5], [3.5]])
+
+    def test_flat(self):
+        # Test that flat can return items even for matrices [#4585, #4615]
+        # test simple access
+        test = masked_array(np.matrix([[1, 2, 3]]), mask=[0, 0, 1])
+        assert_equal(test.flat[1], 2)
+        assert_equal(test.flat[2], masked)
+        assert_(np.all(test.flat[0:2] == test[0, 0:2]))
+        # Test flat on masked_matrices
+        test = masked_array(np.matrix([[1, 2, 3]]), mask=[0, 0, 1])
+        test.flat = masked_array([3, 2, 1], mask=[1, 0, 0])
+        control = masked_array(np.matrix([[3, 2, 1]]), mask=[1, 0, 0])
+        assert_equal(test, control)
+        # Test setting
+        test = masked_array(np.matrix([[1, 2, 3]]), mask=[0, 0, 1])
+        testflat = test.flat
+        testflat[:] = testflat[[2, 1, 0]]
+        assert_equal(test, control)
+        testflat[0] = 9
+        # test that matrices keep the correct shape (#4615)
+        a = masked_array(np.matrix(np.eye(2)), mask=0)
+        b = a.flat
+        b01 = b[:2]
+        assert_equal(b01.data, np.array([[1., 0.]]))
+        assert_equal(b01.mask, np.array([[False, False]]))
+
+    def test_allany_onmatrices(self):
+        x = np.array([[0.13, 0.26, 0.90],
+                      [0.28, 0.33, 0.63],
+                      [0.31, 0.87, 0.70]])
+        X = np.matrix(x)
+        m = np.array([[True, False, False],
+                      [False, False, False],
+                      [True, True, False]], dtype=np.bool)
+        mX = masked_array(X, mask=m)
+        mXbig = (mX > 0.5)
+        mXsmall = (mX < 0.5)
+
+        assert_(not mXbig.all())
+        assert_(mXbig.any())
+        assert_equal(mXbig.all(0), np.matrix([False, False, True]))
+        assert_equal(mXbig.all(1), np.matrix([False, False, True]).T)
+        assert_equal(mXbig.any(0), np.matrix([False, False, True]))
+        assert_equal(mXbig.any(1), np.matrix([True, True, True]).T)
+
+        assert_(not mXsmall.all())
+        assert_(mXsmall.any())
+        assert_equal(mXsmall.all(0), np.matrix([True, True, False]))
+        assert_equal(mXsmall.all(1), np.matrix([False, False, False]).T)
+        assert_equal(mXsmall.any(0), np.matrix([True, True, False]))
+        assert_equal(mXsmall.any(1), np.matrix([True, True, False]).T)
+
+    def test_compressed(self):
+        a = masked_array(np.matrix([1, 2, 3, 4]), mask=[0, 0, 0, 0])
+        b = a.compressed()
+        assert_equal(b, a)
+        assert_(isinstance(b, np.matrix))
+        a[0, 0] = masked
+        b = a.compressed()
+        assert_equal(b, [[2, 3, 4]])
+
+    def test_ravel(self):
+        a = masked_array(np.matrix([1, 2, 3, 4, 5]), mask=[[0, 1, 0, 0, 0]])
+        aravel = a.ravel()
+        assert_equal(aravel.shape, (1, 5))
+        assert_equal(aravel._mask.shape, a.shape)
+
+    def test_view(self):
+        # Test view w/ flexible dtype
+        iterator = list(zip(np.arange(10), np.random.rand(10)))
+        data = np.array(iterator)
+        a = masked_array(iterator, dtype=[('a', float), ('b', float)])
+        a.mask[0] = (1, 0)
+        test = a.view((float, 2), np.matrix)
+        assert_equal(test, data)
+        assert_(isinstance(test, np.matrix))
+        assert_(not isinstance(test, MaskedArray))
+
+
+class TestSubclassing:
+    # Test suite for masked subclasses of ndarray.
+
+    def setup_method(self):
+        x = np.arange(5, dtype='float')
+        mx = MMatrix(x, mask=[0, 1, 0, 0, 0])
+        self.data = (x, mx)
+
+    def test_maskedarray_subclassing(self):
+        # Tests subclassing MaskedArray
+        (x, mx) = self.data
+        assert_(isinstance(mx._data, np.matrix))
+
+    def test_masked_unary_operations(self):
+        # Tests masked_unary_operation
+        (x, mx) = self.data
+        with np.errstate(divide='ignore'):
+            assert_(isinstance(log(mx), MMatrix))
+            assert_equal(log(x), np.log(x))
+
+    def test_masked_binary_operations(self):
+        # Tests masked_binary_operation
+        (x, mx) = self.data
+        # Result should be a MMatrix
+        assert_(isinstance(add(mx, mx), MMatrix))
+        assert_(isinstance(add(mx, x), MMatrix))
+        # Result should work
+        assert_equal(add(mx, x), mx+x)
+        assert_(isinstance(add(mx, mx)._data, np.matrix))
+        with assert_warns(DeprecationWarning):
+            assert_(isinstance(add.outer(mx, mx), MMatrix))
+        assert_(isinstance(hypot(mx, mx), MMatrix))
+        assert_(isinstance(hypot(mx, x), MMatrix))
+
+    def test_masked_binary_operations2(self):
+        # Tests domained_masked_binary_operation
+        (x, mx) = self.data
+        xmx = masked_array(mx.data.__array__(), mask=mx.mask)
+        assert_(isinstance(divide(mx, mx), MMatrix))
+        assert_(isinstance(divide(mx, x), MMatrix))
+        assert_equal(divide(mx, mx), divide(xmx, xmx))
+
+class TestConcatenator:
+    # Tests for mr_, the equivalent of r_ for masked arrays.
+
+    def test_matrix_builder(self):
+        assert_raises(np.ma.MAError, lambda: mr_['1, 2; 3, 4'])
+
+    def test_matrix(self):
+        # Test consistency with unmasked version.  If we ever deprecate
+        # matrix, this test should either still pass, or both actual and
+        # expected should fail to be build.
+        actual = mr_['r', 1, 2, 3]
+        expected = np.ma.array(np.r_['r', 1, 2, 3])
+        assert_array_equal(actual, expected)
+
+        # outer type is masked array, inner type is matrix
+        assert_equal(type(actual), type(expected))
+        assert_equal(type(actual.data), type(expected.data))
diff --git a/venv/lib/python3.12/site-packages/numpy/matrixlib/tests/test_matrix_linalg.py b/venv/lib/python3.12/site-packages/numpy/matrixlib/tests/test_matrix_linalg.py
new file mode 100644
index 00000000..106c2e38
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/matrixlib/tests/test_matrix_linalg.py
@@ -0,0 +1,93 @@
+""" Test functions for linalg module using the matrix class."""
+import numpy as np
+
+from numpy.linalg.tests.test_linalg import (
+    LinalgCase, apply_tag, TestQR as _TestQR, LinalgTestCase,
+    _TestNorm2D, _TestNormDoubleBase, _TestNormSingleBase, _TestNormInt64Base,
+    SolveCases, InvCases, EigvalsCases, EigCases, SVDCases, CondCases,
+    PinvCases, DetCases, LstsqCases)
+
+
+CASES = []
+
+# square test cases
+CASES += apply_tag('square', [
+    LinalgCase("0x0_matrix",
+               np.empty((0, 0), dtype=np.double).view(np.matrix),
+               np.empty((0, 1), dtype=np.double).view(np.matrix),
+               tags={'size-0'}),
+    LinalgCase("matrix_b_only",
+               np.array([[1., 2.], [3., 4.]]),
+               np.matrix([2., 1.]).T),
+    LinalgCase("matrix_a_and_b",
+               np.matrix([[1., 2.], [3., 4.]]),
+               np.matrix([2., 1.]).T),
+])
+
+# hermitian test-cases
+CASES += apply_tag('hermitian', [
+    LinalgCase("hmatrix_a_and_b",
+               np.matrix([[1., 2.], [2., 1.]]),
+               None),
+])
+# No need to make generalized or strided cases for matrices.
+
+
+class MatrixTestCase(LinalgTestCase):
+    TEST_CASES = CASES
+
+
+class TestSolveMatrix(SolveCases, MatrixTestCase):
+    pass
+
+
+class TestInvMatrix(InvCases, MatrixTestCase):
+    pass
+
+
+class TestEigvalsMatrix(EigvalsCases, MatrixTestCase):
+    pass
+
+
+class TestEigMatrix(EigCases, MatrixTestCase):
+    pass
+
+
+class TestSVDMatrix(SVDCases, MatrixTestCase):
+    pass
+
+
+class TestCondMatrix(CondCases, MatrixTestCase):
+    pass
+
+
+class TestPinvMatrix(PinvCases, MatrixTestCase):
+    pass
+
+
+class TestDetMatrix(DetCases, MatrixTestCase):
+    pass
+
+
+class TestLstsqMatrix(LstsqCases, MatrixTestCase):
+    pass
+
+
+class _TestNorm2DMatrix(_TestNorm2D):
+    array = np.matrix
+
+
+class TestNormDoubleMatrix(_TestNorm2DMatrix, _TestNormDoubleBase):
+    pass
+
+
+class TestNormSingleMatrix(_TestNorm2DMatrix, _TestNormSingleBase):
+    pass
+
+
+class TestNormInt64Matrix(_TestNorm2DMatrix, _TestNormInt64Base):
+    pass
+
+
+class TestQRMatrix(_TestQR):
+    array = np.matrix
diff --git a/venv/lib/python3.12/site-packages/numpy/matrixlib/tests/test_multiarray.py b/venv/lib/python3.12/site-packages/numpy/matrixlib/tests/test_multiarray.py
new file mode 100644
index 00000000..638d0d15
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/matrixlib/tests/test_multiarray.py
@@ -0,0 +1,16 @@
+import numpy as np
+from numpy.testing import assert_, assert_equal, assert_array_equal
+
+class TestView:
+    def test_type(self):
+        x = np.array([1, 2, 3])
+        assert_(isinstance(x.view(np.matrix), np.matrix))
+
+    def test_keywords(self):
+        x = np.array([(1, 2)], dtype=[('a', np.int8), ('b', np.int8)])
+        # We must be specific about the endianness here:
+        y = x.view(dtype='>> from numpy.polynomial import Chebyshev
+    >>> xdata = [1, 2, 3, 4]
+    >>> ydata = [1, 4, 9, 16]
+    >>> c = Chebyshev.fit(xdata, ydata, deg=1)
+
+is preferred over the `chebyshev.chebfit` function from the
+``np.polynomial.chebyshev`` module::
+
+    >>> from numpy.polynomial.chebyshev import chebfit
+    >>> c = chebfit(xdata, ydata, deg=1)
+
+See :doc:`routines.polynomials.classes` for more details.
+
+Convenience Classes
+===================
+
+The following lists the various constants and methods common to all of
+the classes representing the various kinds of polynomials. In the following,
+the term ``Poly`` represents any one of the convenience classes (e.g.
+`~polynomial.Polynomial`, `~chebyshev.Chebyshev`, `~hermite.Hermite`, etc.)
+while the lowercase ``p`` represents an **instance** of a polynomial class.
+
+Constants
+---------
+
+- ``Poly.domain``     -- Default domain
+- ``Poly.window``     -- Default window
+- ``Poly.basis_name`` -- String used to represent the basis
+- ``Poly.maxpower``   -- Maximum value ``n`` such that ``p**n`` is allowed
+- ``Poly.nickname``   -- String used in printing
+
+Creation
+--------
+
+Methods for creating polynomial instances.
+
+- ``Poly.basis(degree)``    -- Basis polynomial of given degree
+- ``Poly.identity()``       -- ``p`` where ``p(x) = x`` for all ``x``
+- ``Poly.fit(x, y, deg)``   -- ``p`` of degree ``deg`` with coefficients
+  determined by the least-squares fit to the data ``x``, ``y``
+- ``Poly.fromroots(roots)`` -- ``p`` with specified roots
+- ``p.copy()``              -- Create a copy of ``p``
+
+Conversion
+----------
+
+Methods for converting a polynomial instance of one kind to another.
+
+- ``p.cast(Poly)``    -- Convert ``p`` to instance of kind ``Poly``
+- ``p.convert(Poly)`` -- Convert ``p`` to instance of kind ``Poly`` or map
+  between ``domain`` and ``window``
+
+Calculus
+--------
+- ``p.deriv()`` -- Take the derivative of ``p``
+- ``p.integ()`` -- Integrate ``p``
+
+Validation
+----------
+- ``Poly.has_samecoef(p1, p2)``   -- Check if coefficients match
+- ``Poly.has_samedomain(p1, p2)`` -- Check if domains match
+- ``Poly.has_sametype(p1, p2)``   -- Check if types match
+- ``Poly.has_samewindow(p1, p2)`` -- Check if windows match
+
+Misc
+----
+- ``p.linspace()`` -- Return ``x, p(x)`` at equally-spaced points in ``domain``
+- ``p.mapparms()`` -- Return the parameters for the linear mapping between
+  ``domain`` and ``window``.
+- ``p.roots()``    -- Return the roots of ``p``.
+- ``p.trim()``     -- Remove trailing coefficients.
+- ``p.cutdeg(degree)`` -- Truncate ``p`` to given degree
+- ``p.truncate(size)`` -- Truncate ``p`` to given size
+
+"""
+from .polynomial import Polynomial
+from .chebyshev import Chebyshev
+from .legendre import Legendre
+from .hermite import Hermite
+from .hermite_e import HermiteE
+from .laguerre import Laguerre
+
+__all__ = [
+    "set_default_printstyle",
+    "polynomial", "Polynomial",
+    "chebyshev", "Chebyshev",
+    "legendre", "Legendre",
+    "hermite", "Hermite",
+    "hermite_e", "HermiteE",
+    "laguerre", "Laguerre",
+]
+
+
+def set_default_printstyle(style):
+    """
+    Set the default format for the string representation of polynomials.
+
+    Values for ``style`` must be valid inputs to ``__format__``, i.e. 'ascii'
+    or 'unicode'.
+
+    Parameters
+    ----------
+    style : str
+        Format string for default printing style. Must be either 'ascii' or
+        'unicode'.
+
+    Notes
+    -----
+    The default format depends on the platform: 'unicode' is used on
+    Unix-based systems and 'ascii' on Windows. This determination is based on
+    default font support for the unicode superscript and subscript ranges.
+
+    Examples
+    --------
+    >>> p = np.polynomial.Polynomial([1, 2, 3])
+    >>> c = np.polynomial.Chebyshev([1, 2, 3])
+    >>> np.polynomial.set_default_printstyle('unicode')
+    >>> print(p)
+    1.0 + 2.0·x + 3.0·x²
+    >>> print(c)
+    1.0 + 2.0·T₁(x) + 3.0·T₂(x)
+    >>> np.polynomial.set_default_printstyle('ascii')
+    >>> print(p)
+    1.0 + 2.0 x + 3.0 x**2
+    >>> print(c)
+    1.0 + 2.0 T_1(x) + 3.0 T_2(x)
+    >>> # Formatting supersedes all class/package-level defaults
+    >>> print(f"{p:unicode}")
+    1.0 + 2.0·x + 3.0·x²
+    """
+    if style not in ('unicode', 'ascii'):
+        raise ValueError(
+            f"Unsupported format string '{style}'. Valid options are 'ascii' "
+            f"and 'unicode'"
+        )
+    _use_unicode = True
+    if style == 'ascii':
+        _use_unicode = False
+    from ._polybase import ABCPolyBase
+    ABCPolyBase._use_unicode = _use_unicode
+
+
+from numpy._pytesttester import PytestTester
+test = PytestTester(__name__)
+del PytestTester
diff --git a/venv/lib/python3.12/site-packages/numpy/polynomial/__init__.pyi b/venv/lib/python3.12/site-packages/numpy/polynomial/__init__.pyi
new file mode 100644
index 00000000..d36605b8
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/polynomial/__init__.pyi
@@ -0,0 +1,23 @@
+from typing import Final, Literal
+
+from .polynomial import Polynomial
+from .chebyshev import Chebyshev
+from .legendre import Legendre
+from .hermite import Hermite
+from .hermite_e import HermiteE
+from .laguerre import Laguerre
+
+__all__ = [
+    "set_default_printstyle",
+    "polynomial", "Polynomial",
+    "chebyshev", "Chebyshev",
+    "legendre", "Legendre",
+    "hermite", "Hermite",
+    "hermite_e", "HermiteE",
+    "laguerre", "Laguerre",
+]
+
+def set_default_printstyle(style: Literal["ascii", "unicode"]) -> None: ...
+
+from numpy._pytesttester import PytestTester as _PytestTester
+test: Final[_PytestTester]
diff --git a/venv/lib/python3.12/site-packages/numpy/polynomial/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/polynomial/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 00000000..c78bbb96
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/polynomial/__pycache__/__init__.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/polynomial/__pycache__/_polybase.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/polynomial/__pycache__/_polybase.cpython-312.pyc
new file mode 100644
index 00000000..d53f142f
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/polynomial/__pycache__/_polybase.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/polynomial/__pycache__/chebyshev.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/polynomial/__pycache__/chebyshev.cpython-312.pyc
new file mode 100644
index 00000000..fc2d1493
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/polynomial/__pycache__/chebyshev.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/polynomial/__pycache__/hermite.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/polynomial/__pycache__/hermite.cpython-312.pyc
new file mode 100644
index 00000000..311520e1
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/polynomial/__pycache__/hermite.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/polynomial/__pycache__/hermite_e.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/polynomial/__pycache__/hermite_e.cpython-312.pyc
new file mode 100644
index 00000000..9217aaa9
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/polynomial/__pycache__/hermite_e.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/polynomial/__pycache__/laguerre.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/polynomial/__pycache__/laguerre.cpython-312.pyc
new file mode 100644
index 00000000..198490de
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/polynomial/__pycache__/laguerre.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/polynomial/__pycache__/legendre.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/polynomial/__pycache__/legendre.cpython-312.pyc
new file mode 100644
index 00000000..aefa9cbc
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/polynomial/__pycache__/legendre.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/polynomial/__pycache__/polynomial.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/polynomial/__pycache__/polynomial.cpython-312.pyc
new file mode 100644
index 00000000..df47ee78
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/polynomial/__pycache__/polynomial.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/polynomial/__pycache__/polyutils.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/polynomial/__pycache__/polyutils.cpython-312.pyc
new file mode 100644
index 00000000..433a773b
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/polynomial/__pycache__/polyutils.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/polynomial/_polybase.py b/venv/lib/python3.12/site-packages/numpy/polynomial/_polybase.py
new file mode 100644
index 00000000..65c3ff43
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/polynomial/_polybase.py
@@ -0,0 +1,1223 @@
+"""
+Abstract base class for the various polynomial Classes.
+
+The ABCPolyBase class provides the methods needed to implement the common API
+for the various polynomial classes. It operates as a mixin, but uses the
+abc module from the stdlib, hence it is only available for Python >= 2.6.
+
+"""
+import os
+import abc
+import numbers
+from typing import Callable
+
+import numpy as np
+from . import polyutils as pu
+
+__all__ = ['ABCPolyBase']
+
+class ABCPolyBase(abc.ABC):
+    """An abstract base class for immutable series classes.
+
+    ABCPolyBase provides the standard Python numerical methods
+    '+', '-', '*', '//', '%', 'divmod', '**', and '()' along with the
+    methods listed below.
+
+    .. versionadded:: 1.9.0
+
+    Parameters
+    ----------
+    coef : array_like
+        Series coefficients in order of increasing degree, i.e.,
+        ``(1, 2, 3)`` gives ``1*P_0(x) + 2*P_1(x) + 3*P_2(x)``, where
+        ``P_i`` is the basis polynomials of degree ``i``.
+    domain : (2,) array_like, optional
+        Domain to use. The interval ``[domain[0], domain[1]]`` is mapped
+        to the interval ``[window[0], window[1]]`` by shifting and scaling.
+        The default value is the derived class domain.
+    window : (2,) array_like, optional
+        Window, see domain for its use. The default value is the
+        derived class window.
+    symbol : str, optional
+        Symbol used to represent the independent variable in string 
+        representations of the polynomial expression, e.g. for printing.
+        The symbol must be a valid Python identifier. Default value is 'x'.
+
+        .. versionadded:: 1.24
+
+    Attributes
+    ----------
+    coef : (N,) ndarray
+        Series coefficients in order of increasing degree.
+    domain : (2,) ndarray
+        Domain that is mapped to window.
+    window : (2,) ndarray
+        Window that domain is mapped to.
+    symbol : str
+        Symbol representing the independent variable.
+
+    Class Attributes
+    ----------------
+    maxpower : int
+        Maximum power allowed, i.e., the largest number ``n`` such that
+        ``p(x)**n`` is allowed. This is to limit runaway polynomial size.
+    domain : (2,) ndarray
+        Default domain of the class.
+    window : (2,) ndarray
+        Default window of the class.
+
+    """
+
+    # Not hashable
+    __hash__ = None
+
+    # Opt out of numpy ufuncs and Python ops with ndarray subclasses.
+    __array_ufunc__ = None
+
+    # Limit runaway size. T_n^m has degree n*m
+    maxpower = 100
+
+    # Unicode character mappings for improved __str__
+    _superscript_mapping = str.maketrans({
+        "0": "⁰",
+        "1": "¹",
+        "2": "²",
+        "3": "³",
+        "4": "⁴",
+        "5": "⁵",
+        "6": "⁶",
+        "7": "⁷",
+        "8": "⁸",
+        "9": "⁹"
+    })
+    _subscript_mapping = str.maketrans({
+        "0": "₀",
+        "1": "₁",
+        "2": "₂",
+        "3": "₃",
+        "4": "₄",
+        "5": "₅",
+        "6": "₆",
+        "7": "₇",
+        "8": "₈",
+        "9": "₉"
+    })
+    # Some fonts don't support full unicode character ranges necessary for
+    # the full set of superscripts and subscripts, including common/default
+    # fonts in Windows shells/terminals. Therefore, default to ascii-only
+    # printing on windows.
+    _use_unicode = not os.name == 'nt'
+
+    @property
+    def symbol(self):
+        return self._symbol
+
+    @property
+    @abc.abstractmethod
+    def domain(self):
+        pass
+
+    @property
+    @abc.abstractmethod
+    def window(self):
+        pass
+
+    @property
+    @abc.abstractmethod
+    def basis_name(self):
+        pass
+
+    @staticmethod
+    @abc.abstractmethod
+    def _add(c1, c2):
+        pass
+
+    @staticmethod
+    @abc.abstractmethod
+    def _sub(c1, c2):
+        pass
+
+    @staticmethod
+    @abc.abstractmethod
+    def _mul(c1, c2):
+        pass
+
+    @staticmethod
+    @abc.abstractmethod
+    def _div(c1, c2):
+        pass
+
+    @staticmethod
+    @abc.abstractmethod
+    def _pow(c, pow, maxpower=None):
+        pass
+
+    @staticmethod
+    @abc.abstractmethod
+    def _val(x, c):
+        pass
+
+    @staticmethod
+    @abc.abstractmethod
+    def _int(c, m, k, lbnd, scl):
+        pass
+
+    @staticmethod
+    @abc.abstractmethod
+    def _der(c, m, scl):
+        pass
+
+    @staticmethod
+    @abc.abstractmethod
+    def _fit(x, y, deg, rcond, full):
+        pass
+
+    @staticmethod
+    @abc.abstractmethod
+    def _line(off, scl):
+        pass
+
+    @staticmethod
+    @abc.abstractmethod
+    def _roots(c):
+        pass
+
+    @staticmethod
+    @abc.abstractmethod
+    def _fromroots(r):
+        pass
+
+    def has_samecoef(self, other):
+        """Check if coefficients match.
+
+        .. versionadded:: 1.6.0
+
+        Parameters
+        ----------
+        other : class instance
+            The other class must have the ``coef`` attribute.
+
+        Returns
+        -------
+        bool : boolean
+            True if the coefficients are the same, False otherwise.
+
+        """
+        if len(self.coef) != len(other.coef):
+            return False
+        elif not np.all(self.coef == other.coef):
+            return False
+        else:
+            return True
+
+    def has_samedomain(self, other):
+        """Check if domains match.
+
+        .. versionadded:: 1.6.0
+
+        Parameters
+        ----------
+        other : class instance
+            The other class must have the ``domain`` attribute.
+
+        Returns
+        -------
+        bool : boolean
+            True if the domains are the same, False otherwise.
+
+        """
+        return np.all(self.domain == other.domain)
+
+    def has_samewindow(self, other):
+        """Check if windows match.
+
+        .. versionadded:: 1.6.0
+
+        Parameters
+        ----------
+        other : class instance
+            The other class must have the ``window`` attribute.
+
+        Returns
+        -------
+        bool : boolean
+            True if the windows are the same, False otherwise.
+
+        """
+        return np.all(self.window == other.window)
+
+    def has_sametype(self, other):
+        """Check if types match.
+
+        .. versionadded:: 1.7.0
+
+        Parameters
+        ----------
+        other : object
+            Class instance.
+
+        Returns
+        -------
+        bool : boolean
+            True if other is same class as self
+
+        """
+        return isinstance(other, self.__class__)
+
+    def _get_coefficients(self, other):
+        """Interpret other as polynomial coefficients.
+
+        The `other` argument is checked to see if it is of the same
+        class as self with identical domain and window. If so,
+        return its coefficients, otherwise return `other`.
+
+        .. versionadded:: 1.9.0
+
+        Parameters
+        ----------
+        other : anything
+            Object to be checked.
+
+        Returns
+        -------
+        coef
+            The coefficients of`other` if it is a compatible instance,
+            of ABCPolyBase, otherwise `other`.
+
+        Raises
+        ------
+        TypeError
+            When `other` is an incompatible instance of ABCPolyBase.
+
+        """
+        if isinstance(other, ABCPolyBase):
+            if not isinstance(other, self.__class__):
+                raise TypeError("Polynomial types differ")
+            elif not np.all(self.domain == other.domain):
+                raise TypeError("Domains differ")
+            elif not np.all(self.window == other.window):
+                raise TypeError("Windows differ")
+            elif self.symbol != other.symbol:
+                raise ValueError("Polynomial symbols differ")
+            return other.coef
+        return other
+
+    def __init__(self, coef, domain=None, window=None, symbol='x'):
+        [coef] = pu.as_series([coef], trim=False)
+        self.coef = coef
+
+        if domain is not None:
+            [domain] = pu.as_series([domain], trim=False)
+            if len(domain) != 2:
+                raise ValueError("Domain has wrong number of elements.")
+            self.domain = domain
+
+        if window is not None:
+            [window] = pu.as_series([window], trim=False)
+            if len(window) != 2:
+                raise ValueError("Window has wrong number of elements.")
+            self.window = window
+
+        # Validation for symbol
+        try:
+            if not symbol.isidentifier():
+                raise ValueError(
+                    "Symbol string must be a valid Python identifier"
+                )
+        # If a user passes in something other than a string, the above
+        # results in an AttributeError. Catch this and raise a more
+        # informative exception
+        except AttributeError:
+            raise TypeError("Symbol must be a non-empty string")
+
+        self._symbol = symbol
+
+    def __repr__(self):
+        coef = repr(self.coef)[6:-1]
+        domain = repr(self.domain)[6:-1]
+        window = repr(self.window)[6:-1]
+        name = self.__class__.__name__
+        return (f"{name}({coef}, domain={domain}, window={window}, "
+                f"symbol='{self.symbol}')")
+
+    def __format__(self, fmt_str):
+        if fmt_str == '':
+            return self.__str__()
+        if fmt_str not in ('ascii', 'unicode'):
+            raise ValueError(
+                f"Unsupported format string '{fmt_str}' passed to "
+                f"{self.__class__}.__format__. Valid options are "
+                f"'ascii' and 'unicode'"
+            )
+        if fmt_str == 'ascii':
+            return self._generate_string(self._str_term_ascii)
+        return self._generate_string(self._str_term_unicode)
+
+    def __str__(self):
+        if self._use_unicode:
+            return self._generate_string(self._str_term_unicode)
+        return self._generate_string(self._str_term_ascii)
+
+    def _generate_string(self, term_method):
+        """
+        Generate the full string representation of the polynomial, using
+        ``term_method`` to generate each polynomial term.
+        """
+        # Get configuration for line breaks
+        linewidth = np.get_printoptions().get('linewidth', 75)
+        if linewidth < 1:
+            linewidth = 1
+        out = pu.format_float(self.coef[0])
+
+        off, scale = self.mapparms()
+
+        scaled_symbol, needs_parens = self._format_term(pu.format_float,
+                                                        off, scale)
+        if needs_parens:
+            scaled_symbol = '(' + scaled_symbol + ')'
+
+        for i, coef in enumerate(self.coef[1:]):
+            out += " "
+            power = str(i + 1)
+            # Polynomial coefficient
+            # The coefficient array can be an object array with elements that
+            # will raise a TypeError with >= 0 (e.g. strings or Python
+            # complex). In this case, represent the coefficient as-is.
+            try:
+                if coef >= 0:
+                    next_term = "+ " + pu.format_float(coef, parens=True)
+                else:
+                    next_term = "- " + pu.format_float(-coef, parens=True)
+            except TypeError:
+                next_term = f"+ {coef}"
+            # Polynomial term
+            next_term += term_method(power, scaled_symbol)
+            # Length of the current line with next term added
+            line_len = len(out.split('\n')[-1]) + len(next_term)
+            # If not the last term in the polynomial, it will be two
+            # characters longer due to the +/- with the next term
+            if i < len(self.coef[1:]) - 1:
+                line_len += 2
+            # Handle linebreaking
+            if line_len >= linewidth:
+                next_term = next_term.replace(" ", "\n", 1)
+            out += next_term
+        return out
+
+    @classmethod
+    def _str_term_unicode(cls, i, arg_str):
+        """
+        String representation of single polynomial term using unicode
+        characters for superscripts and subscripts.
+        """
+        if cls.basis_name is None:
+            raise NotImplementedError(
+                "Subclasses must define either a basis_name, or override "
+                "_str_term_unicode(cls, i, arg_str)"
+            )
+        return (f"·{cls.basis_name}{i.translate(cls._subscript_mapping)}"
+                f"({arg_str})")
+
+    @classmethod
+    def _str_term_ascii(cls, i, arg_str):
+        """
+        String representation of a single polynomial term using ** and _ to
+        represent superscripts and subscripts, respectively.
+        """
+        if cls.basis_name is None:
+            raise NotImplementedError(
+                "Subclasses must define either a basis_name, or override "
+                "_str_term_ascii(cls, i, arg_str)"
+            )
+        return f" {cls.basis_name}_{i}({arg_str})"
+
+    @classmethod
+    def _repr_latex_term(cls, i, arg_str, needs_parens):
+        if cls.basis_name is None:
+            raise NotImplementedError(
+                "Subclasses must define either a basis name, or override "
+                "_repr_latex_term(i, arg_str, needs_parens)")
+        # since we always add parens, we don't care if the expression needs them
+        return f"{{{cls.basis_name}}}_{{{i}}}({arg_str})"
+
+    @staticmethod
+    def _repr_latex_scalar(x, parens=False):
+        # TODO: we're stuck with disabling math formatting until we handle
+        # exponents in this function
+        return r'\text{{{}}}'.format(pu.format_float(x, parens=parens))
+
+    def _format_term(self, scalar_format: Callable, off: float, scale: float):
+        """ Format a single term in the expansion """
+        if off == 0 and scale == 1:
+            term = self.symbol
+            needs_parens = False
+        elif scale == 1:
+            term = f"{scalar_format(off)} + {self.symbol}"
+            needs_parens = True
+        elif off == 0:
+            term = f"{scalar_format(scale)}{self.symbol}"
+            needs_parens = True
+        else:
+            term = (
+                f"{scalar_format(off)} + "
+                f"{scalar_format(scale)}{self.symbol}"
+            )
+            needs_parens = True
+        return term, needs_parens
+    
+    def _repr_latex_(self):
+        # get the scaled argument string to the basis functions
+        off, scale = self.mapparms()
+        term, needs_parens = self._format_term(self._repr_latex_scalar,
+                                               off, scale)
+
+        mute = r"\color{{LightGray}}{{{}}}".format
+
+        parts = []
+        for i, c in enumerate(self.coef):
+            # prevent duplication of + and - signs
+            if i == 0:
+                coef_str = f"{self._repr_latex_scalar(c)}"
+            elif not isinstance(c, numbers.Real):
+                coef_str = f" + ({self._repr_latex_scalar(c)})"
+            elif c >= 0:
+                coef_str = f" + {self._repr_latex_scalar(c, parens=True)}"
+            else:
+                coef_str = f" - {self._repr_latex_scalar(-c, parens=True)}"
+
+            # produce the string for the term
+            term_str = self._repr_latex_term(i, term, needs_parens)
+            if term_str == '1':
+                part = coef_str
+            else:
+                part = rf"{coef_str}\,{term_str}"
+
+            if c == 0:
+                part = mute(part)
+
+            parts.append(part)
+
+        if parts:
+            body = ''.join(parts)
+        else:
+            # in case somehow there are no coefficients at all
+            body = '0'
+
+        return rf"${self.symbol} \mapsto {body}$"
+
+
+
+    # Pickle and copy
+
+    def __getstate__(self):
+        ret = self.__dict__.copy()
+        ret['coef'] = self.coef.copy()
+        ret['domain'] = self.domain.copy()
+        ret['window'] = self.window.copy()
+        ret['symbol'] = self.symbol
+        return ret
+
+    def __setstate__(self, dict):
+        self.__dict__ = dict
+
+    # Call
+
+    def __call__(self, arg):
+        arg = pu.mapdomain(arg, self.domain, self.window)
+        return self._val(arg, self.coef)
+
+    def __iter__(self):
+        return iter(self.coef)
+
+    def __len__(self):
+        return len(self.coef)
+
+    # Numeric properties.
+
+    def __neg__(self):
+        return self.__class__(
+            -self.coef, self.domain, self.window, self.symbol
+        )
+
+    def __pos__(self):
+        return self
+
+    def __add__(self, other):
+        othercoef = self._get_coefficients(other)
+        try:
+            coef = self._add(self.coef, othercoef)
+        except Exception:
+            return NotImplemented
+        return self.__class__(coef, self.domain, self.window, self.symbol)
+
+    def __sub__(self, other):
+        othercoef = self._get_coefficients(other)
+        try:
+            coef = self._sub(self.coef, othercoef)
+        except Exception:
+            return NotImplemented
+        return self.__class__(coef, self.domain, self.window, self.symbol)
+
+    def __mul__(self, other):
+        othercoef = self._get_coefficients(other)
+        try:
+            coef = self._mul(self.coef, othercoef)
+        except Exception:
+            return NotImplemented
+        return self.__class__(coef, self.domain, self.window, self.symbol)
+
+    def __truediv__(self, other):
+        # there is no true divide if the rhs is not a Number, although it
+        # could return the first n elements of an infinite series.
+        # It is hard to see where n would come from, though.
+        if not isinstance(other, numbers.Number) or isinstance(other, bool):
+            raise TypeError(
+                f"unsupported types for true division: "
+                f"'{type(self)}', '{type(other)}'"
+            )
+        return self.__floordiv__(other)
+
+    def __floordiv__(self, other):
+        res = self.__divmod__(other)
+        if res is NotImplemented:
+            return res
+        return res[0]
+
+    def __mod__(self, other):
+        res = self.__divmod__(other)
+        if res is NotImplemented:
+            return res
+        return res[1]
+
+    def __divmod__(self, other):
+        othercoef = self._get_coefficients(other)
+        try:
+            quo, rem = self._div(self.coef, othercoef)
+        except ZeroDivisionError:
+            raise
+        except Exception:
+            return NotImplemented
+        quo = self.__class__(quo, self.domain, self.window, self.symbol)
+        rem = self.__class__(rem, self.domain, self.window, self.symbol)
+        return quo, rem
+
+    def __pow__(self, other):
+        coef = self._pow(self.coef, other, maxpower=self.maxpower)
+        res = self.__class__(coef, self.domain, self.window, self.symbol)
+        return res
+
+    def __radd__(self, other):
+        try:
+            coef = self._add(other, self.coef)
+        except Exception:
+            return NotImplemented
+        return self.__class__(coef, self.domain, self.window, self.symbol)
+
+    def __rsub__(self, other):
+        try:
+            coef = self._sub(other, self.coef)
+        except Exception:
+            return NotImplemented
+        return self.__class__(coef, self.domain, self.window, self.symbol)
+
+    def __rmul__(self, other):
+        try:
+            coef = self._mul(other, self.coef)
+        except Exception:
+            return NotImplemented
+        return self.__class__(coef, self.domain, self.window, self.symbol)
+
+    def __rdiv__(self, other):
+        # set to __floordiv__ /.
+        return self.__rfloordiv__(other)
+
+    def __rtruediv__(self, other):
+        # An instance of ABCPolyBase is not considered a
+        # Number.
+        return NotImplemented
+
+    def __rfloordiv__(self, other):
+        res = self.__rdivmod__(other)
+        if res is NotImplemented:
+            return res
+        return res[0]
+
+    def __rmod__(self, other):
+        res = self.__rdivmod__(other)
+        if res is NotImplemented:
+            return res
+        return res[1]
+
+    def __rdivmod__(self, other):
+        try:
+            quo, rem = self._div(other, self.coef)
+        except ZeroDivisionError:
+            raise
+        except Exception:
+            return NotImplemented
+        quo = self.__class__(quo, self.domain, self.window, self.symbol)
+        rem = self.__class__(rem, self.domain, self.window, self.symbol)
+        return quo, rem
+
+    def __eq__(self, other):
+        res = (isinstance(other, self.__class__) and
+               np.all(self.domain == other.domain) and
+               np.all(self.window == other.window) and
+               (self.coef.shape == other.coef.shape) and
+               np.all(self.coef == other.coef) and
+               (self.symbol == other.symbol))
+        return res
+
+    def __ne__(self, other):
+        return not self.__eq__(other)
+
+    #
+    # Extra methods.
+    #
+
+    def copy(self):
+        """Return a copy.
+
+        Returns
+        -------
+        new_series : series
+            Copy of self.
+
+        """
+        return self.__class__(self.coef, self.domain, self.window, self.symbol)
+
+    def degree(self):
+        """The degree of the series.
+
+        .. versionadded:: 1.5.0
+
+        Returns
+        -------
+        degree : int
+            Degree of the series, one less than the number of coefficients.
+
+        Examples
+        --------
+
+        Create a polynomial object for ``1 + 7*x + 4*x**2``:
+
+        >>> poly = np.polynomial.Polynomial([1, 7, 4])
+        >>> print(poly)
+        1.0 + 7.0·x + 4.0·x²
+        >>> poly.degree()
+        2
+
+        Note that this method does not check for non-zero coefficients.
+        You must trim the polynomial to remove any trailing zeroes:
+
+        >>> poly = np.polynomial.Polynomial([1, 7, 0])
+        >>> print(poly)
+        1.0 + 7.0·x + 0.0·x²
+        >>> poly.degree()
+        2
+        >>> poly.trim().degree()
+        1
+
+        """
+        return len(self) - 1
+
+    def cutdeg(self, deg):
+        """Truncate series to the given degree.
+
+        Reduce the degree of the series to `deg` by discarding the
+        high order terms. If `deg` is greater than the current degree a
+        copy of the current series is returned. This can be useful in least
+        squares where the coefficients of the high degree terms may be very
+        small.
+
+        .. versionadded:: 1.5.0
+
+        Parameters
+        ----------
+        deg : non-negative int
+            The series is reduced to degree `deg` by discarding the high
+            order terms. The value of `deg` must be a non-negative integer.
+
+        Returns
+        -------
+        new_series : series
+            New instance of series with reduced degree.
+
+        """
+        return self.truncate(deg + 1)
+
+    def trim(self, tol=0):
+        """Remove trailing coefficients
+
+        Remove trailing coefficients until a coefficient is reached whose
+        absolute value greater than `tol` or the beginning of the series is
+        reached. If all the coefficients would be removed the series is set
+        to ``[0]``. A new series instance is returned with the new
+        coefficients.  The current instance remains unchanged.
+
+        Parameters
+        ----------
+        tol : non-negative number.
+            All trailing coefficients less than `tol` will be removed.
+
+        Returns
+        -------
+        new_series : series
+            New instance of series with trimmed coefficients.
+
+        """
+        coef = pu.trimcoef(self.coef, tol)
+        return self.__class__(coef, self.domain, self.window, self.symbol)
+
+    def truncate(self, size):
+        """Truncate series to length `size`.
+
+        Reduce the series to length `size` by discarding the high
+        degree terms. The value of `size` must be a positive integer. This
+        can be useful in least squares where the coefficients of the
+        high degree terms may be very small.
+
+        Parameters
+        ----------
+        size : positive int
+            The series is reduced to length `size` by discarding the high
+            degree terms. The value of `size` must be a positive integer.
+
+        Returns
+        -------
+        new_series : series
+            New instance of series with truncated coefficients.
+
+        """
+        isize = int(size)
+        if isize != size or isize < 1:
+            raise ValueError("size must be a positive integer")
+        if isize >= len(self.coef):
+            coef = self.coef
+        else:
+            coef = self.coef[:isize]
+        return self.__class__(coef, self.domain, self.window, self.symbol)
+
+    def convert(self, domain=None, kind=None, window=None):
+        """Convert series to a different kind and/or domain and/or window.
+
+        Parameters
+        ----------
+        domain : array_like, optional
+            The domain of the converted series. If the value is None,
+            the default domain of `kind` is used.
+        kind : class, optional
+            The polynomial series type class to which the current instance
+            should be converted. If kind is None, then the class of the
+            current instance is used.
+        window : array_like, optional
+            The window of the converted series. If the value is None,
+            the default window of `kind` is used.
+
+        Returns
+        -------
+        new_series : series
+            The returned class can be of different type than the current
+            instance and/or have a different domain and/or different
+            window.
+
+        Notes
+        -----
+        Conversion between domains and class types can result in
+        numerically ill defined series.
+
+        """
+        if kind is None:
+            kind = self.__class__
+        if domain is None:
+            domain = kind.domain
+        if window is None:
+            window = kind.window
+        return self(kind.identity(domain, window=window, symbol=self.symbol))
+
+    def mapparms(self):
+        """Return the mapping parameters.
+
+        The returned values define a linear map ``off + scl*x`` that is
+        applied to the input arguments before the series is evaluated. The
+        map depends on the ``domain`` and ``window``; if the current
+        ``domain`` is equal to the ``window`` the resulting map is the
+        identity.  If the coefficients of the series instance are to be
+        used by themselves outside this class, then the linear function
+        must be substituted for the ``x`` in the standard representation of
+        the base polynomials.
+
+        Returns
+        -------
+        off, scl : float or complex
+            The mapping function is defined by ``off + scl*x``.
+
+        Notes
+        -----
+        If the current domain is the interval ``[l1, r1]`` and the window
+        is ``[l2, r2]``, then the linear mapping function ``L`` is
+        defined by the equations::
+
+            L(l1) = l2
+            L(r1) = r2
+
+        """
+        return pu.mapparms(self.domain, self.window)
+
+    def integ(self, m=1, k=[], lbnd=None):
+        """Integrate.
+
+        Return a series instance that is the definite integral of the
+        current series.
+
+        Parameters
+        ----------
+        m : non-negative int
+            The number of integrations to perform.
+        k : array_like
+            Integration constants. The first constant is applied to the
+            first integration, the second to the second, and so on. The
+            list of values must less than or equal to `m` in length and any
+            missing values are set to zero.
+        lbnd : Scalar
+            The lower bound of the definite integral.
+
+        Returns
+        -------
+        new_series : series
+            A new series representing the integral. The domain is the same
+            as the domain of the integrated series.
+
+        """
+        off, scl = self.mapparms()
+        if lbnd is None:
+            lbnd = 0
+        else:
+            lbnd = off + scl*lbnd
+        coef = self._int(self.coef, m, k, lbnd, 1./scl)
+        return self.__class__(coef, self.domain, self.window, self.symbol)
+
+    def deriv(self, m=1):
+        """Differentiate.
+
+        Return a series instance of that is the derivative of the current
+        series.
+
+        Parameters
+        ----------
+        m : non-negative int
+            Find the derivative of order `m`.
+
+        Returns
+        -------
+        new_series : series
+            A new series representing the derivative. The domain is the same
+            as the domain of the differentiated series.
+
+        """
+        off, scl = self.mapparms()
+        coef = self._der(self.coef, m, scl)
+        return self.__class__(coef, self.domain, self.window, self.symbol)
+
+    def roots(self):
+        """Return the roots of the series polynomial.
+
+        Compute the roots for the series. Note that the accuracy of the
+        roots decreases the further outside the `domain` they lie.
+
+        Returns
+        -------
+        roots : ndarray
+            Array containing the roots of the series.
+
+        """
+        roots = self._roots(self.coef)
+        return pu.mapdomain(roots, self.window, self.domain)
+
+    def linspace(self, n=100, domain=None):
+        """Return x, y values at equally spaced points in domain.
+
+        Returns the x, y values at `n` linearly spaced points across the
+        domain.  Here y is the value of the polynomial at the points x. By
+        default the domain is the same as that of the series instance.
+        This method is intended mostly as a plotting aid.
+
+        .. versionadded:: 1.5.0
+
+        Parameters
+        ----------
+        n : int, optional
+            Number of point pairs to return. The default value is 100.
+        domain : {None, array_like}, optional
+            If not None, the specified domain is used instead of that of
+            the calling instance. It should be of the form ``[beg,end]``.
+            The default is None which case the class domain is used.
+
+        Returns
+        -------
+        x, y : ndarray
+            x is equal to linspace(self.domain[0], self.domain[1], n) and
+            y is the series evaluated at element of x.
+
+        """
+        if domain is None:
+            domain = self.domain
+        x = np.linspace(domain[0], domain[1], n)
+        y = self(x)
+        return x, y
+
+    @classmethod
+    def fit(cls, x, y, deg, domain=None, rcond=None, full=False, w=None,
+        window=None, symbol='x'):
+        """Least squares fit to data.
+
+        Return a series instance that is the least squares fit to the data
+        `y` sampled at `x`. The domain of the returned instance can be
+        specified and this will often result in a superior fit with less
+        chance of ill conditioning.
+
+        Parameters
+        ----------
+        x : array_like, shape (M,)
+            x-coordinates of the M sample points ``(x[i], y[i])``.
+        y : array_like, shape (M,)
+            y-coordinates of the M sample points ``(x[i], y[i])``.
+        deg : int or 1-D array_like
+            Degree(s) of the fitting polynomials. If `deg` is a single integer
+            all terms up to and including the `deg`'th term are included in the
+            fit. For NumPy versions >= 1.11.0 a list of integers specifying the
+            degrees of the terms to include may be used instead.
+        domain : {None, [beg, end], []}, optional
+            Domain to use for the returned series. If ``None``,
+            then a minimal domain that covers the points `x` is chosen.  If
+            ``[]`` the class domain is used. The default value was the
+            class domain in NumPy 1.4 and ``None`` in later versions.
+            The ``[]`` option was added in numpy 1.5.0.
+        rcond : float, optional
+            Relative condition number of the fit. Singular values smaller
+            than this relative to the largest singular value will be
+            ignored. The default value is ``len(x)*eps``, where eps is the
+            relative precision of the float type, about 2e-16 in most
+            cases.
+        full : bool, optional
+            Switch determining nature of return value. When it is False
+            (the default) just the coefficients are returned, when True
+            diagnostic information from the singular value decomposition is
+            also returned.
+        w : array_like, shape (M,), optional
+            Weights. If not None, the weight ``w[i]`` applies to the unsquared
+            residual ``y[i] - y_hat[i]`` at ``x[i]``. Ideally the weights are
+            chosen so that the errors of the products ``w[i]*y[i]`` all have
+            the same variance.  When using inverse-variance weighting, use
+            ``w[i] = 1/sigma(y[i])``.  The default value is None.
+
+            .. versionadded:: 1.5.0
+        window : {[beg, end]}, optional
+            Window to use for the returned series. The default
+            value is the default class domain
+
+            .. versionadded:: 1.6.0
+        symbol : str, optional
+            Symbol representing the independent variable. Default is 'x'.
+
+        Returns
+        -------
+        new_series : series
+            A series that represents the least squares fit to the data and
+            has the domain and window specified in the call. If the
+            coefficients for the unscaled and unshifted basis polynomials are
+            of interest, do ``new_series.convert().coef``.
+
+        [resid, rank, sv, rcond] : list
+            These values are only returned if ``full == True``
+
+            - resid -- sum of squared residuals of the least squares fit
+            - rank -- the numerical rank of the scaled Vandermonde matrix
+            - sv -- singular values of the scaled Vandermonde matrix
+            - rcond -- value of `rcond`.
+
+            For more details, see `linalg.lstsq`.
+
+        """
+        if domain is None:
+            domain = pu.getdomain(x)
+            if domain[0] == domain[1]:
+                domain[0] -= 1
+                domain[1] += 1   
+        elif type(domain) is list and len(domain) == 0:
+            domain = cls.domain
+
+        if window is None:
+            window = cls.window
+
+        xnew = pu.mapdomain(x, domain, window)
+        res = cls._fit(xnew, y, deg, w=w, rcond=rcond, full=full)
+        if full:
+            [coef, status] = res
+            return (
+                cls(coef, domain=domain, window=window, symbol=symbol), status
+            )
+        else:
+            coef = res
+            return cls(coef, domain=domain, window=window, symbol=symbol)
+
+    @classmethod
+    def fromroots(cls, roots, domain=[], window=None, symbol='x'):
+        """Return series instance that has the specified roots.
+
+        Returns a series representing the product
+        ``(x - r[0])*(x - r[1])*...*(x - r[n-1])``, where ``r`` is a
+        list of roots.
+
+        Parameters
+        ----------
+        roots : array_like
+            List of roots.
+        domain : {[], None, array_like}, optional
+            Domain for the resulting series. If None the domain is the
+            interval from the smallest root to the largest. If [] the
+            domain is the class domain. The default is [].
+        window : {None, array_like}, optional
+            Window for the returned series. If None the class window is
+            used. The default is None.
+        symbol : str, optional
+            Symbol representing the independent variable. Default is 'x'.
+
+        Returns
+        -------
+        new_series : series
+            Series with the specified roots.
+
+        """
+        [roots] = pu.as_series([roots], trim=False)
+        if domain is None:
+            domain = pu.getdomain(roots)
+        elif type(domain) is list and len(domain) == 0:
+            domain = cls.domain
+
+        if window is None:
+            window = cls.window
+
+        deg = len(roots)
+        off, scl = pu.mapparms(domain, window)
+        rnew = off + scl*roots
+        coef = cls._fromroots(rnew) / scl**deg
+        return cls(coef, domain=domain, window=window, symbol=symbol)
+
+    @classmethod
+    def identity(cls, domain=None, window=None, symbol='x'):
+        """Identity function.
+
+        If ``p`` is the returned series, then ``p(x) == x`` for all
+        values of x.
+
+        Parameters
+        ----------
+        domain : {None, array_like}, optional
+            If given, the array must be of the form ``[beg, end]``, where
+            ``beg`` and ``end`` are the endpoints of the domain. If None is
+            given then the class domain is used. The default is None.
+        window : {None, array_like}, optional
+            If given, the resulting array must be if the form
+            ``[beg, end]``, where ``beg`` and ``end`` are the endpoints of
+            the window. If None is given then the class window is used. The
+            default is None.
+        symbol : str, optional
+            Symbol representing the independent variable. Default is 'x'.
+
+        Returns
+        -------
+        new_series : series
+             Series of representing the identity.
+
+        """
+        if domain is None:
+            domain = cls.domain
+        if window is None:
+            window = cls.window
+        off, scl = pu.mapparms(window, domain)
+        coef = cls._line(off, scl)
+        return cls(coef, domain, window, symbol)
+
+    @classmethod
+    def basis(cls, deg, domain=None, window=None, symbol='x'):
+        """Series basis polynomial of degree `deg`.
+
+        Returns the series representing the basis polynomial of degree `deg`.
+
+        .. versionadded:: 1.7.0
+
+        Parameters
+        ----------
+        deg : int
+            Degree of the basis polynomial for the series. Must be >= 0.
+        domain : {None, array_like}, optional
+            If given, the array must be of the form ``[beg, end]``, where
+            ``beg`` and ``end`` are the endpoints of the domain. If None is
+            given then the class domain is used. The default is None.
+        window : {None, array_like}, optional
+            If given, the resulting array must be if the form
+            ``[beg, end]``, where ``beg`` and ``end`` are the endpoints of
+            the window. If None is given then the class window is used. The
+            default is None.
+        symbol : str, optional
+            Symbol representing the independent variable. Default is 'x'.
+
+        Returns
+        -------
+        new_series : series
+            A series with the coefficient of the `deg` term set to one and
+            all others zero.
+
+        """
+        if domain is None:
+            domain = cls.domain
+        if window is None:
+            window = cls.window
+        ideg = int(deg)
+
+        if ideg != deg or ideg < 0:
+            raise ValueError("deg must be non-negative integer")
+        return cls([0]*ideg + [1], domain, window, symbol)
+
+    @classmethod
+    def cast(cls, series, domain=None, window=None):
+        """Convert series to series of this class.
+
+        The `series` is expected to be an instance of some polynomial
+        series of one of the types supported by by the numpy.polynomial
+        module, but could be some other class that supports the convert
+        method.
+
+        .. versionadded:: 1.7.0
+
+        Parameters
+        ----------
+        series : series
+            The series instance to be converted.
+        domain : {None, array_like}, optional
+            If given, the array must be of the form ``[beg, end]``, where
+            ``beg`` and ``end`` are the endpoints of the domain. If None is
+            given then the class domain is used. The default is None.
+        window : {None, array_like}, optional
+            If given, the resulting array must be if the form
+            ``[beg, end]``, where ``beg`` and ``end`` are the endpoints of
+            the window. If None is given then the class window is used. The
+            default is None.
+
+        Returns
+        -------
+        new_series : series
+            A series of the same kind as the calling class and equal to
+            `series` when evaluated.
+
+        See Also
+        --------
+        convert : similar instance method
+
+        """
+        if domain is None:
+            domain = cls.domain
+        if window is None:
+            window = cls.window
+        return series.convert(domain, cls, window)
diff --git a/venv/lib/python3.12/site-packages/numpy/polynomial/_polybase.pyi b/venv/lib/python3.12/site-packages/numpy/polynomial/_polybase.pyi
new file mode 100644
index 00000000..7519a755
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/polynomial/_polybase.pyi
@@ -0,0 +1,297 @@
+import abc
+import decimal
+import numbers
+import sys
+from collections.abc import Iterator, Mapping, Sequence
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    ClassVar,
+    Final,
+    Generic,
+    Literal,
+    SupportsIndex,
+    TypeAlias,
+    TypeGuard,
+    TypeVar,
+    overload,
+)
+
+import numpy as np
+import numpy.typing as npt
+from numpy._typing import (
+    _FloatLike_co,
+    _NumberLike_co,
+
+    _ArrayLikeFloat_co,
+    _ArrayLikeComplex_co,
+)
+
+from ._polytypes import (
+    _AnyInt,
+    _CoefLike_co,
+
+    _Array2,
+    _Tuple2,
+
+    _Series,
+    _CoefSeries,
+
+    _SeriesLikeInt_co,
+    _SeriesLikeCoef_co,
+
+    _ArrayLikeCoefObject_co,
+    _ArrayLikeCoef_co,
+)
+
+if sys.version_info >= (3, 11):
+    from typing import LiteralString
+elif TYPE_CHECKING:
+    from typing_extensions import LiteralString
+else:
+    LiteralString: TypeAlias = str
+
+
+__all__: Final[Sequence[str]] = ("ABCPolyBase",)
+
+
+_NameCo = TypeVar("_NameCo", bound=None | LiteralString, covariant=True)
+_Self = TypeVar("_Self", bound="ABCPolyBase")
+_Other = TypeVar("_Other", bound="ABCPolyBase")
+
+_AnyOther: TypeAlias = ABCPolyBase | _CoefLike_co | _SeriesLikeCoef_co
+_Hundred: TypeAlias = Literal[100]
+
+
+class ABCPolyBase(Generic[_NameCo], metaclass=abc.ABCMeta):
+    __hash__: ClassVar[None]  # type: ignore[assignment]
+    __array_ufunc__: ClassVar[None]
+
+    maxpower: ClassVar[_Hundred]
+    _superscript_mapping: ClassVar[Mapping[int, str]]
+    _subscript_mapping: ClassVar[Mapping[int, str]]
+    _use_unicode: ClassVar[bool]
+
+    basis_name: _NameCo
+    coef: _CoefSeries
+    domain: _Array2[np.inexact[Any] | np.object_]
+    window: _Array2[np.inexact[Any] | np.object_]
+
+    _symbol: LiteralString
+    @property
+    def symbol(self, /) -> LiteralString: ...
+
+    def __init__(
+        self,
+        /,
+        coef: _SeriesLikeCoef_co,
+        domain: None | _SeriesLikeCoef_co = ...,
+        window: None | _SeriesLikeCoef_co = ...,
+        symbol: str = ...,
+    ) -> None: ...
+
+    @overload
+    def __call__(self, /, arg: _Other) -> _Other: ...
+    # TODO: Once `_ShapeType@ndarray` is covariant and bounded (see #26081),
+    # additionally include 0-d arrays as input types with scalar return type.
+    @overload
+    def __call__(
+        self,
+        /,
+        arg: _FloatLike_co | decimal.Decimal | numbers.Real | np.object_,
+    ) -> np.float64 | np.complex128: ...
+    @overload
+    def __call__(
+        self,
+        /,
+        arg: _NumberLike_co | numbers.Complex,
+    ) -> np.complex128: ...
+    @overload
+    def __call__(self, /, arg: _ArrayLikeFloat_co) -> (
+        npt.NDArray[np.float64]
+        | npt.NDArray[np.complex128]
+        | npt.NDArray[np.object_]
+    ): ...
+    @overload
+    def __call__(
+        self,
+        /,
+        arg: _ArrayLikeComplex_co,
+    ) -> npt.NDArray[np.complex128] | npt.NDArray[np.object_]: ...
+    @overload
+    def __call__(
+        self,
+        /,
+        arg: _ArrayLikeCoefObject_co,
+    ) -> npt.NDArray[np.object_]: ...
+
+    def __str__(self, /) -> str: ...
+    def __repr__(self, /) -> str: ...
+    def __format__(self, fmt_str: str, /) -> str: ...
+    def __eq__(self, x: object, /) -> bool: ...
+    def __ne__(self, x: object, /) -> bool: ...
+    def __neg__(self: _Self, /) -> _Self: ...
+    def __pos__(self: _Self, /) -> _Self: ...
+    def __add__(self: _Self, x: _AnyOther, /) -> _Self: ...
+    def __sub__(self: _Self, x: _AnyOther, /) -> _Self: ...
+    def __mul__(self: _Self, x: _AnyOther, /) -> _Self: ...
+    def __truediv__(self: _Self, x: _AnyOther, /) -> _Self: ...
+    def __floordiv__(self: _Self, x: _AnyOther, /) -> _Self: ...
+    def __mod__(self: _Self, x: _AnyOther, /) -> _Self: ...
+    def __divmod__(self: _Self, x: _AnyOther, /) -> _Tuple2[_Self]: ...
+    def __pow__(self: _Self, x: _AnyOther, /) -> _Self: ...
+    def __radd__(self: _Self, x: _AnyOther, /) -> _Self: ...
+    def __rsub__(self: _Self, x: _AnyOther, /) -> _Self: ...
+    def __rmul__(self: _Self, x: _AnyOther, /) -> _Self: ...
+    def __rtruediv__(self: _Self, x: _AnyOther, /) -> _Self: ...
+    def __rfloordiv__(self: _Self, x: _AnyOther, /) -> _Self: ...
+    def __rmod__(self: _Self, x: _AnyOther, /) -> _Self: ...
+    def __rdivmod__(self: _Self, x: _AnyOther, /) -> _Tuple2[_Self]: ...
+    def __len__(self, /) -> int: ...
+    def __iter__(self, /) -> Iterator[np.inexact[Any] | object]: ...
+    def __getstate__(self, /) -> dict[str, Any]: ...
+    def __setstate__(self, dict: dict[str, Any], /) -> None: ...
+
+    def has_samecoef(self, /, other: ABCPolyBase) -> bool: ...
+    def has_samedomain(self, /, other: ABCPolyBase) -> bool: ...
+    def has_samewindow(self, /, other: ABCPolyBase) -> bool: ...
+    @overload
+    def has_sametype(self: _Self, /, other: ABCPolyBase) -> TypeGuard[_Self]: ...
+    @overload
+    def has_sametype(self, /, other: object) -> Literal[False]: ...
+
+    def copy(self: _Self, /) -> _Self: ...
+    def degree(self, /) -> int: ...
+    def cutdeg(self: _Self, /) -> _Self: ...
+    def trim(self: _Self, /, tol: _FloatLike_co = ...) -> _Self: ...
+    def truncate(self: _Self, /, size: _AnyInt) -> _Self: ...
+
+    @overload
+    def convert(
+        self,
+        domain: None | _SeriesLikeCoef_co,
+        kind: type[_Other],
+        /,
+        window: None | _SeriesLikeCoef_co = ...,
+    ) -> _Other: ...
+    @overload
+    def convert(
+        self,
+        /,
+        domain: None | _SeriesLikeCoef_co = ...,
+        *,
+        kind: type[_Other],
+        window: None | _SeriesLikeCoef_co = ...,
+    ) -> _Other: ...
+    @overload
+    def convert(
+        self: _Self,
+        /,
+        domain: None | _SeriesLikeCoef_co = ...,
+        kind: type[_Self] = ...,
+        window: None | _SeriesLikeCoef_co = ...,
+    ) -> _Self: ...
+
+    def mapparms(self, /) -> _Tuple2[Any]: ...
+
+    def integ(
+        self: _Self, /,
+        m: SupportsIndex = ...,
+        k: _CoefLike_co | _SeriesLikeCoef_co = ...,
+        lbnd: None | _CoefLike_co = ...,
+    ) -> _Self: ...
+
+    def deriv(self: _Self, /, m: SupportsIndex = ...) -> _Self: ...
+
+    def roots(self, /) -> _CoefSeries: ...
+
+    def linspace(
+        self, /,
+        n: SupportsIndex = ...,
+        domain: None | _SeriesLikeCoef_co = ...,
+    ) -> _Tuple2[_Series[np.float64 | np.complex128]]: ...
+
+    @overload
+    @classmethod
+    def fit(
+        cls: type[_Self], /,
+        x: _SeriesLikeCoef_co,
+        y: _SeriesLikeCoef_co,
+        deg: int | _SeriesLikeInt_co,
+        domain: None | _SeriesLikeCoef_co = ...,
+        rcond: _FloatLike_co = ...,
+        full: Literal[False] = ...,
+        w: None | _SeriesLikeCoef_co = ...,
+        window: None | _SeriesLikeCoef_co = ...,
+        symbol: str = ...,
+    ) -> _Self: ...
+    @overload
+    @classmethod
+    def fit(
+        cls: type[_Self], /,
+        x: _SeriesLikeCoef_co,
+        y: _SeriesLikeCoef_co,
+        deg: int | _SeriesLikeInt_co,
+        domain: None | _SeriesLikeCoef_co = ...,
+        rcond: _FloatLike_co = ...,
+        *,
+        full: Literal[True],
+        w: None | _SeriesLikeCoef_co = ...,
+        window: None | _SeriesLikeCoef_co = ...,
+        symbol: str = ...,
+    ) -> tuple[_Self, Sequence[np.inexact[Any] | np.int32]]: ...
+    @overload
+    @classmethod
+    def fit(
+        cls: type[_Self],
+        x: _SeriesLikeCoef_co,
+        y: _SeriesLikeCoef_co,
+        deg: int | _SeriesLikeInt_co,
+        domain: None | _SeriesLikeCoef_co,
+        rcond: _FloatLike_co,
+        full: Literal[True], /,
+        w: None | _SeriesLikeCoef_co = ...,
+        window: None | _SeriesLikeCoef_co = ...,
+        symbol: str = ...,
+    ) -> tuple[_Self, Sequence[np.inexact[Any] | np.int32]]: ...
+
+    @classmethod
+    def fromroots(
+        cls: type[_Self], /,
+        roots: _ArrayLikeCoef_co,
+        domain: None | _SeriesLikeCoef_co = ...,
+        window: None | _SeriesLikeCoef_co = ...,
+        symbol: str = ...,
+    ) -> _Self: ...
+
+    @classmethod
+    def identity(
+        cls: type[_Self], /,
+        domain: None | _SeriesLikeCoef_co = ...,
+        window: None | _SeriesLikeCoef_co = ...,
+        symbol: str = ...,
+    ) -> _Self: ...
+
+    @classmethod
+    def basis(
+        cls: type[_Self], /,
+        deg: _AnyInt,
+        domain: None | _SeriesLikeCoef_co = ...,
+        window: None | _SeriesLikeCoef_co = ...,
+        symbol: str = ...,
+    ) -> _Self: ...
+
+    @classmethod
+    def cast(
+        cls: type[_Self], /,
+        series: ABCPolyBase,
+        domain: None | _SeriesLikeCoef_co = ...,
+        window: None | _SeriesLikeCoef_co = ...,
+    ) -> _Self: ...
+
+    @classmethod
+    def _str_term_unicode(cls, i: str, arg_str: str) -> str: ...
+    @staticmethod
+    def _str_term_ascii(i: str, arg_str: str) -> str: ...
+    @staticmethod
+    def _repr_latex_term(i: str, arg_str: str, needs_parens: bool) -> str: ...
diff --git a/venv/lib/python3.12/site-packages/numpy/polynomial/_polytypes.pyi b/venv/lib/python3.12/site-packages/numpy/polynomial/_polytypes.pyi
new file mode 100644
index 00000000..54771c05
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/polynomial/_polytypes.pyi
@@ -0,0 +1,912 @@
+import sys
+from collections.abc import Callable, Sequence
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Literal,
+    NoReturn,
+    Protocol,
+    SupportsIndex,
+    SupportsInt,
+    TypeAlias,
+    TypeVar,
+    final,
+    overload,
+)
+
+import numpy as np
+import numpy.typing as npt
+from numpy._typing import (
+    # array-likes
+    _ArrayLikeFloat_co,
+    _ArrayLikeComplex_co,
+    _ArrayLikeNumber_co,
+    _ArrayLikeObject_co,
+    _NestedSequence,
+
+    # scalar-likes
+    _IntLike_co,
+    _FloatLike_co,
+    _ComplexLike_co,
+    _NumberLike_co,
+)
+
+if sys.version_info >= (3, 11):
+    from typing import LiteralString
+elif TYPE_CHECKING:
+    from typing_extensions import LiteralString
+else:
+    LiteralString: TypeAlias = str
+
+_T = TypeVar("_T")
+_T_contra = TypeVar("_T_contra", contravariant=True)
+
+_Tuple2: TypeAlias = tuple[_T, _T]
+
+_V = TypeVar("_V")
+_V_co = TypeVar("_V_co", covariant=True)
+_Self = TypeVar("_Self", bound=object)
+
+_SCT = TypeVar("_SCT", bound=np.number[Any] | np.bool | np.object_)
+_SCT_co = TypeVar(
+    "_SCT_co",
+    bound=np.number[Any] | np.bool | np.object_,
+    covariant=True,
+)
+
+@final
+class _SupportsArray(Protocol[_SCT_co]):
+    def __array__(self ,) -> npt.NDArray[_SCT_co]: ...
+
+@final
+class _SupportsCoefOps(Protocol[_T_contra]):
+    # compatible with e.g. `int`, `float`, `complex`, `Decimal`, `Fraction`,
+    # and `ABCPolyBase`
+    def __eq__(self, x: object, /) -> bool: ...
+    def __ne__(self, x: object, /) -> bool: ...
+
+    def __neg__(self: _Self, /) -> _Self: ...
+    def __pos__(self: _Self, /) -> _Self: ...
+
+    def __add__(self: _Self, x: _T_contra, /) -> _Self: ...
+    def __sub__(self: _Self, x: _T_contra, /) -> _Self: ...
+    def __mul__(self: _Self, x: _T_contra, /) -> _Self: ...
+    def __truediv__(self: _Self, x: _T_contra, /) -> _Self | float: ...
+    def __pow__(self: _Self, x: _T_contra, /) -> _Self | float: ...
+
+    def __radd__(self: _Self, x: _T_contra, /) -> _Self: ...
+    def __rsub__(self: _Self, x: _T_contra, /) -> _Self: ...
+    def __rmul__(self: _Self, x: _T_contra, /) -> _Self: ...
+    def __rtruediv__(self: _Self, x: _T_contra, /) -> _Self | float: ...
+
+_Series: TypeAlias = np.ndarray[tuple[int], np.dtype[_SCT]]
+
+_FloatSeries: TypeAlias = _Series[np.floating[Any]]
+_ComplexSeries: TypeAlias = _Series[np.complexfloating[Any, Any]]
+_NumberSeries: TypeAlias = _Series[np.number[Any]]
+_ObjectSeries: TypeAlias = _Series[np.object_]
+_CoefSeries: TypeAlias = _Series[np.inexact[Any] | np.object_]
+
+_FloatArray: TypeAlias = npt.NDArray[np.floating[Any]]
+_ComplexArray: TypeAlias = npt.NDArray[np.complexfloating[Any, Any]]
+_ObjectArray: TypeAlias = npt.NDArray[np.object_]
+_CoefArray: TypeAlias = npt.NDArray[np.inexact[Any] | np.object_]
+
+_Array1: TypeAlias = np.ndarray[tuple[Literal[1]], np.dtype[_SCT]]
+_Array2: TypeAlias = np.ndarray[tuple[Literal[2]], np.dtype[_SCT]]
+
+_AnyInt: TypeAlias = SupportsInt | SupportsIndex
+
+_CoefObjectLike_co: TypeAlias = np.object_ | _SupportsCoefOps
+_CoefLike_co: TypeAlias = _NumberLike_co | _CoefObjectLike_co
+
+# The term "series" is used here to refer to 1-d arrays of numeric scalars.
+_SeriesLikeBool_co: TypeAlias = (
+    _SupportsArray[np.bool]
+    | Sequence[bool | np.bool]
+)
+_SeriesLikeInt_co: TypeAlias = (
+    _SupportsArray[np.integer[Any] | np.bool]
+    | Sequence[_IntLike_co]
+)
+_SeriesLikeFloat_co: TypeAlias = (
+    _SupportsArray[np.floating[Any] | np.integer[Any] | np.bool]
+    | Sequence[_FloatLike_co]
+)
+_SeriesLikeComplex_co: TypeAlias = (
+    _SupportsArray[np.integer[Any] | np.inexact[Any] | np.bool]
+    | Sequence[_ComplexLike_co]
+)
+_SeriesLikeObject_co: TypeAlias = (
+    _SupportsArray[np.object_]
+    | Sequence[_CoefObjectLike_co]
+)
+_SeriesLikeCoef_co: TypeAlias = (
+    # npt.NDArray[np.number[Any] | np.bool | np.object_]
+    _SupportsArray[np.number[Any] | np.bool | np.object_]
+    | Sequence[_CoefLike_co]
+)
+
+_ArrayLikeCoefObject_co: TypeAlias = (
+    _CoefObjectLike_co
+    | _SeriesLikeObject_co
+    | _NestedSequence[_SeriesLikeObject_co]
+)
+_ArrayLikeCoef_co: TypeAlias = (
+    npt.NDArray[np.number[Any] | np.bool | np.object_]
+    | _ArrayLikeNumber_co
+    | _ArrayLikeCoefObject_co
+)
+
+_Name_co = TypeVar("_Name_co", bound=LiteralString, covariant=True)
+
+class _Named(Protocol[_Name_co]):
+    @property
+    def __name__(self, /) -> _Name_co: ...
+
+_Line: TypeAlias = np.ndarray[tuple[Literal[1, 2]], np.dtype[_SCT]]
+
+@final
+class _FuncLine(_Named[_Name_co], Protocol[_Name_co]):
+    @overload
+    def __call__(self, /, off: _SCT, scl: _SCT) -> _Line[_SCT]: ...
+    @overload
+    def __call__(self, /, off: int, scl: int) -> _Line[np.int_] : ...
+    @overload
+    def __call__(self, /, off: float, scl: float) -> _Line[np.float64]: ...
+    @overload
+    def __call__(
+        self,
+        /,
+        off: complex,
+        scl: complex,
+    ) -> _Line[np.complex128]: ...
+    @overload
+    def __call__(
+        self,
+        /,
+        off: _SupportsCoefOps,
+        scl: _SupportsCoefOps,
+    ) -> _Line[np.object_]: ...
+
+@final
+class _FuncFromRoots(_Named[_Name_co], Protocol[_Name_co]):
+    @overload
+    def __call__(self, /, roots: _SeriesLikeFloat_co) -> _FloatSeries: ...
+    @overload
+    def __call__(self, /, roots: _SeriesLikeComplex_co) -> _ComplexSeries: ...
+    @overload
+    def __call__(self, /, roots: _SeriesLikeCoef_co) -> _ObjectSeries: ...
+
+@final
+class _FuncBinOp(_Named[_Name_co], Protocol[_Name_co]):
+    @overload
+    def __call__(
+        self,
+        /,
+        c1: _SeriesLikeBool_co,
+        c2: _SeriesLikeBool_co,
+    ) -> NoReturn: ...
+    @overload
+    def __call__(
+        self,
+        /,
+        c1: _SeriesLikeFloat_co,
+        c2: _SeriesLikeFloat_co,
+    ) -> _FloatSeries: ...
+    @overload
+    def __call__(
+        self,
+        /,
+        c1: _SeriesLikeComplex_co,
+        c2: _SeriesLikeComplex_co,
+    ) -> _ComplexSeries: ...
+    @overload
+    def __call__(
+        self,
+        /,
+        c1: _SeriesLikeCoef_co,
+        c2: _SeriesLikeCoef_co,
+    ) -> _ObjectSeries: ...
+
+@final
+class _FuncUnOp(_Named[_Name_co], Protocol[_Name_co]):
+    @overload
+    def __call__(self, /, c: _SeriesLikeFloat_co) -> _FloatSeries: ...
+    @overload
+    def __call__(self, /, c: _SeriesLikeComplex_co) -> _ComplexSeries: ...
+    @overload
+    def __call__(self, /, c: _SeriesLikeCoef_co) -> _ObjectSeries: ...
+
+@final
+class _FuncPoly2Ortho(_Named[_Name_co], Protocol[_Name_co]):
+    @overload
+    def __call__(self, /, pol: _SeriesLikeFloat_co) -> _FloatSeries: ...
+    @overload
+    def __call__(self, /, pol: _SeriesLikeComplex_co) -> _ComplexSeries: ...
+    @overload
+    def __call__(self, /, pol: _SeriesLikeCoef_co) -> _ObjectSeries: ...
+
+@final
+class _FuncPow(_Named[_Name_co], Protocol[_Name_co]):
+    @overload
+    def __call__(
+        self,
+        /,
+        c: _SeriesLikeFloat_co,
+        pow: _IntLike_co,
+        maxpower: None | _IntLike_co = ...,
+    ) -> _FloatSeries: ...
+    @overload
+    def __call__(
+        self,
+        /,
+        c: _SeriesLikeComplex_co,
+        pow: _IntLike_co,
+        maxpower: None | _IntLike_co = ...,
+    ) -> _ComplexSeries: ...
+    @overload
+    def __call__(
+        self,
+        /,
+        c: _SeriesLikeCoef_co,
+        pow: _IntLike_co,
+        maxpower: None | _IntLike_co = ...,
+    ) -> _ObjectSeries: ...
+
+@final
+class _FuncDer(_Named[_Name_co], Protocol[_Name_co]):
+    @overload
+    def __call__(
+        self,
+        /,
+        c: _ArrayLikeFloat_co,
+        m: SupportsIndex = ...,
+        scl: _FloatLike_co = ...,
+        axis: SupportsIndex = ...,
+    ) -> _FloatArray: ...
+    @overload
+    def __call__(
+        self,
+        /,
+        c: _ArrayLikeComplex_co,
+        m: SupportsIndex = ...,
+        scl: _ComplexLike_co = ...,
+        axis: SupportsIndex = ...,
+    ) -> _ComplexArray: ...
+    @overload
+    def __call__(
+        self,
+        /,
+        c: _ArrayLikeCoef_co,
+        m: SupportsIndex = ...,
+        scl: _CoefLike_co = ...,
+        axis: SupportsIndex = ...,
+    ) -> _ObjectArray: ...
+
+@final
+class _FuncInteg(_Named[_Name_co], Protocol[_Name_co]):
+    @overload
+    def __call__(
+        self,
+        /,
+        c: _ArrayLikeFloat_co,
+        m: SupportsIndex = ...,
+        k: _FloatLike_co | _SeriesLikeFloat_co = ...,
+        lbnd: _FloatLike_co = ...,
+        scl: _FloatLike_co = ...,
+        axis: SupportsIndex = ...,
+    ) -> _FloatArray: ...
+    @overload
+    def __call__(
+        self,
+        /,
+        c: _ArrayLikeComplex_co,
+        m: SupportsIndex = ...,
+        k: _ComplexLike_co | _SeriesLikeComplex_co = ...,
+        lbnd: _ComplexLike_co = ...,
+        scl: _ComplexLike_co = ...,
+        axis: SupportsIndex = ...,
+    ) -> _ComplexArray: ...
+    @overload
+    def __call__(
+        self,
+        /,
+        c: _ArrayLikeCoef_co,
+        m: SupportsIndex = ...,
+        k: _SeriesLikeCoef_co | _SeriesLikeCoef_co = ...,
+        lbnd: _CoefLike_co = ...,
+        scl: _CoefLike_co = ...,
+        axis: SupportsIndex = ...,
+    ) -> _ObjectArray: ...
+
+@final
+class _FuncValFromRoots(_Named[_Name_co], Protocol[_Name_co]):
+    @overload
+    def __call__(
+        self,
+        /,
+        x: _FloatLike_co,
+        r: _FloatLike_co,
+        tensor: bool = ...,
+    ) -> np.floating[Any]: ...
+    @overload
+    def __call__(
+        self,
+        /,
+        x: _NumberLike_co,
+        r: _NumberLike_co,
+        tensor: bool = ...,
+    ) -> np.complexfloating[Any, Any]: ...
+    @overload
+    def __call__(
+        self,
+        /,
+        x: _FloatLike_co | _ArrayLikeFloat_co,
+        r: _ArrayLikeFloat_co,
+        tensor: bool = ...,
+    ) -> _FloatArray: ...
+    @overload
+    def __call__(
+        self,
+        /,
+        x: _NumberLike_co | _ArrayLikeComplex_co,
+        r: _ArrayLikeComplex_co,
+        tensor: bool = ...,
+    ) -> _ComplexArray: ...
+    @overload
+    def __call__(
+        self,
+        /,
+        x: _CoefLike_co | _ArrayLikeCoef_co,
+        r: _ArrayLikeCoef_co,
+        tensor: bool = ...,
+    ) -> _ObjectArray: ...
+    @overload
+    def __call__(
+        self,
+        /,
+        x: _CoefLike_co,
+        r: _CoefLike_co,
+        tensor: bool = ...,
+    ) -> _SupportsCoefOps: ...
+
+@final
+class _FuncVal(_Named[_Name_co], Protocol[_Name_co]):
+    @overload
+    def __call__(
+        self,
+        /,
+        x: _FloatLike_co,
+        c: _SeriesLikeFloat_co,
+        tensor: bool = ...,
+    ) -> np.floating[Any]: ...
+    @overload
+    def __call__(
+        self,
+        /,
+        x: _NumberLike_co,
+        c: _SeriesLikeComplex_co,
+        tensor: bool = ...,
+    ) -> np.complexfloating[Any, Any]: ...
+    @overload
+    def __call__(
+        self,
+        /,
+        x: _ArrayLikeFloat_co,
+        c: _ArrayLikeFloat_co,
+        tensor: bool = ...,
+    ) -> _FloatArray: ...
+    @overload
+    def __call__(
+        self,
+        /,
+        x: _ArrayLikeComplex_co,
+        c: _ArrayLikeComplex_co,
+        tensor: bool = ...,
+    ) -> _ComplexArray: ...
+    @overload
+    def __call__(
+        self,
+        /,
+        x: _ArrayLikeCoef_co,
+        c: _ArrayLikeCoef_co,
+        tensor: bool = ...,
+    ) -> _ObjectArray: ...
+    @overload
+    def __call__(
+        self,
+        /,
+        x: _CoefLike_co,
+        c: _SeriesLikeObject_co,
+        tensor: bool = ...,
+    ) -> _SupportsCoefOps: ...
+
+@final
+class _FuncVal2D(_Named[_Name_co], Protocol[_Name_co]):
+    @overload
+    def __call__(
+        self,
+        /,
+        x: _FloatLike_co,
+        y: _FloatLike_co,
+        c: _SeriesLikeFloat_co,
+    ) -> np.floating[Any]: ...
+    @overload
+    def __call__(
+        self,
+        /,
+        x: _NumberLike_co,
+        y: _NumberLike_co,
+        c: _SeriesLikeComplex_co,
+    ) -> np.complexfloating[Any, Any]: ...
+    @overload
+    def __call__(
+        self,
+        /,
+        x: _ArrayLikeFloat_co,
+        y: _ArrayLikeFloat_co,
+        c: _ArrayLikeFloat_co,
+    ) -> _FloatArray: ...
+    @overload
+    def __call__(
+        self,
+        /,
+        x: _ArrayLikeComplex_co,
+        y: _ArrayLikeComplex_co,
+        c: _ArrayLikeComplex_co,
+    ) -> _ComplexArray: ...
+    @overload
+    def __call__(
+        self,
+        /,
+        x: _ArrayLikeCoef_co,
+        y: _ArrayLikeCoef_co,
+        c: _ArrayLikeCoef_co,
+    ) -> _ObjectArray: ...
+    @overload
+    def __call__(
+        self,
+        /,
+        x: _CoefLike_co,
+        y: _CoefLike_co,
+        c: _SeriesLikeCoef_co,
+    ) -> _SupportsCoefOps: ...
+
+@final
+class _FuncVal3D(_Named[_Name_co], Protocol[_Name_co]):
+    @overload
+    def __call__(
+        self,
+        /,
+        x: _FloatLike_co,
+        y: _FloatLike_co,
+        z: _FloatLike_co,
+        c: _SeriesLikeFloat_co
+    ) -> np.floating[Any]: ...
+    @overload
+    def __call__(
+        self,
+        /,
+        x: _NumberLike_co,
+        y: _NumberLike_co,
+        z: _NumberLike_co,
+        c: _SeriesLikeComplex_co,
+    ) -> np.complexfloating[Any, Any]: ...
+    @overload
+    def __call__(
+        self,
+        /,
+        x: _ArrayLikeFloat_co,
+        y: _ArrayLikeFloat_co,
+        z: _ArrayLikeFloat_co,
+        c: _ArrayLikeFloat_co,
+    ) -> _FloatArray: ...
+    @overload
+    def __call__(
+        self,
+        /,
+        x: _ArrayLikeComplex_co,
+        y: _ArrayLikeComplex_co,
+        z: _ArrayLikeComplex_co,
+        c: _ArrayLikeComplex_co,
+    ) -> _ComplexArray: ...
+    @overload
+    def __call__(
+        self,
+        /,
+        x: _ArrayLikeCoef_co,
+        y: _ArrayLikeCoef_co,
+        z: _ArrayLikeCoef_co,
+        c: _ArrayLikeCoef_co,
+    ) -> _ObjectArray: ...
+    @overload
+    def __call__(
+        self,
+        /,
+        x: _CoefLike_co,
+        y: _CoefLike_co,
+        z: _CoefLike_co,
+        c: _SeriesLikeCoef_co,
+    ) -> _SupportsCoefOps: ...
+
+_AnyValF: TypeAlias = Callable[
+    [npt.ArrayLike, npt.ArrayLike, bool],
+    _CoefArray,
+]
+
+@final
+class _FuncValND(_Named[_Name_co], Protocol[_Name_co]):
+    @overload
+    def __call__(
+        self,
+        val_f: _AnyValF,
+        c: _SeriesLikeFloat_co,
+        /,
+        *args: _FloatLike_co,
+    ) -> np.floating[Any]: ...
+    @overload
+    def __call__(
+        self,
+        val_f: _AnyValF,
+        c: _SeriesLikeComplex_co,
+        /,
+        *args: _NumberLike_co,
+    ) -> np.complexfloating[Any, Any]: ...
+    @overload
+    def __call__(
+        self,
+        val_f: _AnyValF,
+        c: _ArrayLikeFloat_co,
+        /,
+        *args: _ArrayLikeFloat_co,
+    ) -> _FloatArray: ...
+    @overload
+    def __call__(
+        self,
+        val_f: _AnyValF,
+        c: _ArrayLikeComplex_co,
+        /,
+        *args: _ArrayLikeComplex_co,
+    ) -> _ComplexArray: ...
+    @overload
+    def __call__(
+        self,
+        val_f: _AnyValF,
+        c: _ArrayLikeCoef_co,
+        /,
+        *args: _ArrayLikeCoef_co,
+    ) -> _ObjectArray: ...
+    @overload
+    def __call__(
+        self,
+        val_f: _AnyValF,
+        c: _SeriesLikeObject_co,
+        /,
+        *args: _CoefObjectLike_co,
+    ) -> _SupportsCoefOps: ...
+
+@final
+class _FuncVander(_Named[_Name_co], Protocol[_Name_co]):
+    @overload
+    def __call__(
+        self,
+        /,
+        x: _ArrayLikeFloat_co,
+        deg: SupportsIndex,
+    ) -> _FloatArray: ...
+    @overload
+    def __call__(
+        self,
+        /,
+        x: _ArrayLikeComplex_co,
+        deg: SupportsIndex,
+    ) -> _ComplexArray: ...
+    @overload
+    def __call__(
+        self,
+        /,
+        x: _ArrayLikeCoef_co,
+        deg: SupportsIndex,
+    ) -> _ObjectArray: ...
+    @overload
+    def __call__(
+        self,
+        /,
+        x: npt.ArrayLike,
+        deg: SupportsIndex,
+    ) -> _CoefArray: ...
+
+_AnyDegrees: TypeAlias = Sequence[SupportsIndex]
+
+@final
+class _FuncVander2D(_Named[_Name_co], Protocol[_Name_co]):
+    @overload
+    def __call__(
+        self,
+        /,
+        x: _ArrayLikeFloat_co,
+        y: _ArrayLikeFloat_co,
+        deg: _AnyDegrees,
+    ) -> _FloatArray: ...
+    @overload
+    def __call__(
+        self,
+        /,
+        x: _ArrayLikeComplex_co,
+        y: _ArrayLikeComplex_co,
+        deg: _AnyDegrees,
+    ) -> _ComplexArray: ...
+    @overload
+    def __call__(
+        self,
+        /,
+        x: _ArrayLikeCoef_co,
+        y: _ArrayLikeCoef_co,
+        deg: _AnyDegrees,
+    ) -> _ObjectArray: ...
+    @overload
+    def __call__(
+        self,
+        /,
+        x: npt.ArrayLike,
+        y: npt.ArrayLike,
+        deg: _AnyDegrees,
+    ) -> _CoefArray: ...
+
+@final
+class _FuncVander3D(_Named[_Name_co], Protocol[_Name_co]):
+    @overload
+    def __call__(
+        self,
+        /,
+        x: _ArrayLikeFloat_co,
+        y: _ArrayLikeFloat_co,
+        z: _ArrayLikeFloat_co,
+        deg: _AnyDegrees,
+    ) -> _FloatArray: ...
+    @overload
+    def __call__(
+        self,
+        /,
+        x: _ArrayLikeComplex_co,
+        y: _ArrayLikeComplex_co,
+        z: _ArrayLikeComplex_co,
+        deg: _AnyDegrees,
+    ) -> _ComplexArray: ...
+    @overload
+    def __call__(
+        self,
+        /,
+        x: _ArrayLikeCoef_co,
+        y: _ArrayLikeCoef_co,
+        z: _ArrayLikeCoef_co,
+        deg: _AnyDegrees,
+    ) -> _ObjectArray: ...
+    @overload
+    def __call__(
+        self,
+        /,
+        x: npt.ArrayLike,
+        y: npt.ArrayLike,
+        z: npt.ArrayLike,
+        deg: _AnyDegrees,
+    ) -> _CoefArray: ...
+
+# keep in sync with the broadest overload of `._FuncVander`
+_AnyFuncVander: TypeAlias = Callable[
+    [npt.ArrayLike, SupportsIndex],
+    _CoefArray,
+]
+
+@final
+class _FuncVanderND(_Named[_Name_co], Protocol[_Name_co]):
+    @overload
+    def __call__(
+        self,
+        /,
+        vander_fs: Sequence[_AnyFuncVander],
+        points: Sequence[_ArrayLikeFloat_co],
+        degrees: Sequence[SupportsIndex],
+    ) -> _FloatArray: ...
+    @overload
+    def __call__(
+        self,
+        /,
+        vander_fs: Sequence[_AnyFuncVander],
+        points: Sequence[_ArrayLikeComplex_co],
+        degrees: Sequence[SupportsIndex],
+    ) -> _ComplexArray: ...
+    @overload
+    def __call__(
+        self,
+        /,
+        vander_fs: Sequence[_AnyFuncVander],
+        points: Sequence[
+            _ArrayLikeObject_co | _ArrayLikeComplex_co,
+        ],
+        degrees: Sequence[SupportsIndex],
+    ) -> _ObjectArray: ...
+    @overload
+    def __call__(
+        self,
+        /,
+        vander_fs: Sequence[_AnyFuncVander],
+        points: Sequence[npt.ArrayLike],
+        degrees: Sequence[SupportsIndex],
+    ) -> _CoefArray: ...
+
+_FullFitResult: TypeAlias = Sequence[np.inexact[Any] | np.int32]
+
+@final
+class _FuncFit(_Named[_Name_co], Protocol[_Name_co]):
+    @overload
+    def __call__(
+        self,
+        /,
+        x: _SeriesLikeFloat_co,
+        y: _ArrayLikeFloat_co,
+        deg: int | _SeriesLikeInt_co,
+        rcond: None | float = ...,
+        full: Literal[False] = ...,
+        w: None | _SeriesLikeFloat_co = ...,
+    ) -> _FloatArray: ...
+    @overload
+    def __call__(
+        self,
+        x: _SeriesLikeFloat_co,
+        y: _ArrayLikeFloat_co,
+        deg: int | _SeriesLikeInt_co,
+        rcond: None | float,
+        full: Literal[True],
+        /,
+        w: None | _SeriesLikeFloat_co = ...,
+    ) -> tuple[_FloatArray, _FullFitResult]: ...
+    @overload
+    def __call__(
+        self,
+        /,
+        x: _SeriesLikeFloat_co,
+        y: _ArrayLikeFloat_co,
+        deg: int | _SeriesLikeInt_co,
+        rcond: None | float = ...,
+        *,
+        full: Literal[True],
+        w: None | _SeriesLikeFloat_co = ...,
+    ) -> tuple[_FloatArray, _FullFitResult]: ...
+
+    @overload
+    def __call__(
+        self,
+        /,
+        x: _SeriesLikeComplex_co,
+        y: _ArrayLikeComplex_co,
+        deg: int | _SeriesLikeInt_co,
+        rcond: None | float = ...,
+        full: Literal[False] = ...,
+        w: None | _SeriesLikeFloat_co = ...,
+    ) -> _ComplexArray: ...
+    @overload
+    def __call__(
+        self,
+        x: _SeriesLikeComplex_co,
+        y: _ArrayLikeComplex_co,
+        deg: int | _SeriesLikeInt_co,
+        rcond: None | float,
+        full: Literal[True],
+        /,
+        w: None | _SeriesLikeFloat_co = ...,
+    ) -> tuple[_ComplexArray, _FullFitResult]: ...
+    @overload
+    def __call__(
+        self,
+        /,
+        x: _SeriesLikeComplex_co,
+        y: _ArrayLikeComplex_co,
+        deg: int | _SeriesLikeInt_co,
+        rcond: None | float = ...,
+        *,
+        full: Literal[True],
+        w: None | _SeriesLikeFloat_co = ...,
+    ) -> tuple[_ComplexArray, _FullFitResult]: ...
+
+    @overload
+    def __call__(
+        self,
+        /,
+        x: _SeriesLikeComplex_co,
+        y: _ArrayLikeCoef_co,
+        deg: int | _SeriesLikeInt_co,
+        rcond: None | float = ...,
+        full: Literal[False] = ...,
+        w: None | _SeriesLikeFloat_co = ...,
+    ) -> _ObjectArray: ...
+    @overload
+    def __call__(
+        self,
+        x: _SeriesLikeComplex_co,
+        y: _ArrayLikeCoef_co,
+        deg: int | _SeriesLikeInt_co,
+        rcond: None | float,
+        full: Literal[True],
+        /,
+        w: None | _SeriesLikeFloat_co = ...,
+    ) -> tuple[_ObjectArray, _FullFitResult]: ...
+    @overload
+    def __call__(
+        self,
+        /,
+        x: _SeriesLikeComplex_co,
+        y: _ArrayLikeCoef_co,
+        deg: int | _SeriesLikeInt_co,
+        rcond: None | float = ...,
+        *,
+        full: Literal[True],
+        w: None | _SeriesLikeFloat_co = ...,
+    ) -> tuple[_ObjectArray, _FullFitResult]: ...
+
+@final
+class _FuncRoots(_Named[_Name_co], Protocol[_Name_co]):
+    @overload
+    def __call__(
+        self,
+        /,
+        c: _SeriesLikeFloat_co,
+    ) -> _Series[np.float64]: ...
+    @overload
+    def __call__(
+        self,
+        /,
+        c: _SeriesLikeComplex_co,
+    ) -> _Series[np.complex128]: ...
+    @overload
+    def __call__(self, /, c: _SeriesLikeCoef_co) -> _ObjectSeries: ...
+
+
+_Companion: TypeAlias = np.ndarray[tuple[int, int], np.dtype[_SCT]]
+
+@final
+class _FuncCompanion(_Named[_Name_co], Protocol[_Name_co]):
+    @overload
+    def __call__(
+        self,
+        /,
+        c: _SeriesLikeFloat_co,
+    ) -> _Companion[np.float64]: ...
+    @overload
+    def __call__(
+        self,
+        /,
+        c: _SeriesLikeComplex_co,
+    ) -> _Companion[np.complex128]: ...
+    @overload
+    def __call__(self, /, c: _SeriesLikeCoef_co) -> _Companion[np.object_]: ...
+
+@final
+class _FuncGauss(_Named[_Name_co], Protocol[_Name_co]):
+    def __call__(
+        self,
+        /,
+        deg: SupportsIndex,
+    ) -> _Tuple2[_Series[np.float64]]: ...
+
+@final
+class _FuncWeight(_Named[_Name_co], Protocol[_Name_co]):
+    @overload
+    def __call__(
+        self,
+        /,
+        c: _ArrayLikeFloat_co,
+    ) -> npt.NDArray[np.float64]: ...
+    @overload
+    def __call__(
+        self,
+        /,
+        c: _ArrayLikeComplex_co,
+    ) -> npt.NDArray[np.complex128]: ...
+    @overload
+    def __call__(self, /, c: _ArrayLikeCoef_co) -> _ObjectArray: ...
+
+@final
+class _FuncPts(_Named[_Name_co], Protocol[_Name_co]):
+    def __call__(self, /, npts: _AnyInt) -> _Series[np.float64]: ...
diff --git a/venv/lib/python3.12/site-packages/numpy/polynomial/chebyshev.py b/venv/lib/python3.12/site-packages/numpy/polynomial/chebyshev.py
new file mode 100644
index 00000000..66fe7d60
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/polynomial/chebyshev.py
@@ -0,0 +1,2086 @@
+"""
+====================================================
+Chebyshev Series (:mod:`numpy.polynomial.chebyshev`)
+====================================================
+
+This module provides a number of objects (mostly functions) useful for
+dealing with Chebyshev series, including a `Chebyshev` class that
+encapsulates the usual arithmetic operations.  (General information
+on how this module represents and works with such polynomials is in the
+docstring for its "parent" sub-package, `numpy.polynomial`).
+
+Classes
+-------
+
+.. autosummary::
+   :toctree: generated/
+
+   Chebyshev
+
+
+Constants
+---------
+
+.. autosummary::
+   :toctree: generated/
+
+   chebdomain
+   chebzero
+   chebone
+   chebx
+
+Arithmetic
+----------
+
+.. autosummary::
+   :toctree: generated/
+
+   chebadd
+   chebsub
+   chebmulx
+   chebmul
+   chebdiv
+   chebpow
+   chebval
+   chebval2d
+   chebval3d
+   chebgrid2d
+   chebgrid3d
+
+Calculus
+--------
+
+.. autosummary::
+   :toctree: generated/
+
+   chebder
+   chebint
+
+Misc Functions
+--------------
+
+.. autosummary::
+   :toctree: generated/
+
+   chebfromroots
+   chebroots
+   chebvander
+   chebvander2d
+   chebvander3d
+   chebgauss
+   chebweight
+   chebcompanion
+   chebfit
+   chebpts1
+   chebpts2
+   chebtrim
+   chebline
+   cheb2poly
+   poly2cheb
+   chebinterpolate
+
+See also
+--------
+`numpy.polynomial`
+
+Notes
+-----
+The implementations of multiplication, division, integration, and
+differentiation use the algebraic identities [1]_:
+
+.. math::
+    T_n(x) = \\frac{z^n + z^{-n}}{2} \\\\
+    z\\frac{dx}{dz} = \\frac{z - z^{-1}}{2}.
+
+where
+
+.. math:: x = \\frac{z + z^{-1}}{2}.
+
+These identities allow a Chebyshev series to be expressed as a finite,
+symmetric Laurent series.  In this module, this sort of Laurent series
+is referred to as a "z-series."
+
+References
+----------
+.. [1] A. T. Benjamin, et al., "Combinatorial Trigonometry with Chebyshev
+  Polynomials," *Journal of Statistical Planning and Inference 14*, 2008
+  (https://web.archive.org/web/20080221202153/https://www.math.hmc.edu/~benjamin/papers/CombTrig.pdf, pg. 4)
+
+"""
+import numpy as np
+import numpy.linalg as la
+from numpy.lib.array_utils import normalize_axis_index
+
+from . import polyutils as pu
+from ._polybase import ABCPolyBase
+
+__all__ = [
+    'chebzero', 'chebone', 'chebx', 'chebdomain', 'chebline', 'chebadd',
+    'chebsub', 'chebmulx', 'chebmul', 'chebdiv', 'chebpow', 'chebval',
+    'chebder', 'chebint', 'cheb2poly', 'poly2cheb', 'chebfromroots',
+    'chebvander', 'chebfit', 'chebtrim', 'chebroots', 'chebpts1',
+    'chebpts2', 'Chebyshev', 'chebval2d', 'chebval3d', 'chebgrid2d',
+    'chebgrid3d', 'chebvander2d', 'chebvander3d', 'chebcompanion',
+    'chebgauss', 'chebweight', 'chebinterpolate']
+
+chebtrim = pu.trimcoef
+
+#
+# A collection of functions for manipulating z-series. These are private
+# functions and do minimal error checking.
+#
+
+def _cseries_to_zseries(c):
+    """Convert Chebyshev series to z-series.
+
+    Convert a Chebyshev series to the equivalent z-series. The result is
+    never an empty array. The dtype of the return is the same as that of
+    the input. No checks are run on the arguments as this routine is for
+    internal use.
+
+    Parameters
+    ----------
+    c : 1-D ndarray
+        Chebyshev coefficients, ordered from low to high
+
+    Returns
+    -------
+    zs : 1-D ndarray
+        Odd length symmetric z-series, ordered from  low to high.
+
+    """
+    n = c.size
+    zs = np.zeros(2*n-1, dtype=c.dtype)
+    zs[n-1:] = c/2
+    return zs + zs[::-1]
+
+
+def _zseries_to_cseries(zs):
+    """Convert z-series to a Chebyshev series.
+
+    Convert a z series to the equivalent Chebyshev series. The result is
+    never an empty array. The dtype of the return is the same as that of
+    the input. No checks are run on the arguments as this routine is for
+    internal use.
+
+    Parameters
+    ----------
+    zs : 1-D ndarray
+        Odd length symmetric z-series, ordered from  low to high.
+
+    Returns
+    -------
+    c : 1-D ndarray
+        Chebyshev coefficients, ordered from  low to high.
+
+    """
+    n = (zs.size + 1)//2
+    c = zs[n-1:].copy()
+    c[1:n] *= 2
+    return c
+
+
+def _zseries_mul(z1, z2):
+    """Multiply two z-series.
+
+    Multiply two z-series to produce a z-series.
+
+    Parameters
+    ----------
+    z1, z2 : 1-D ndarray
+        The arrays must be 1-D but this is not checked.
+
+    Returns
+    -------
+    product : 1-D ndarray
+        The product z-series.
+
+    Notes
+    -----
+    This is simply convolution. If symmetric/anti-symmetric z-series are
+    denoted by S/A then the following rules apply:
+
+    S*S, A*A -> S
+    S*A, A*S -> A
+
+    """
+    return np.convolve(z1, z2)
+
+
+def _zseries_div(z1, z2):
+    """Divide the first z-series by the second.
+
+    Divide `z1` by `z2` and return the quotient and remainder as z-series.
+    Warning: this implementation only applies when both z1 and z2 have the
+    same symmetry, which is sufficient for present purposes.
+
+    Parameters
+    ----------
+    z1, z2 : 1-D ndarray
+        The arrays must be 1-D and have the same symmetry, but this is not
+        checked.
+
+    Returns
+    -------
+
+    (quotient, remainder) : 1-D ndarrays
+        Quotient and remainder as z-series.
+
+    Notes
+    -----
+    This is not the same as polynomial division on account of the desired form
+    of the remainder. If symmetric/anti-symmetric z-series are denoted by S/A
+    then the following rules apply:
+
+    S/S -> S,S
+    A/A -> S,A
+
+    The restriction to types of the same symmetry could be fixed but seems like
+    unneeded generality. There is no natural form for the remainder in the case
+    where there is no symmetry.
+
+    """
+    z1 = z1.copy()
+    z2 = z2.copy()
+    lc1 = len(z1)
+    lc2 = len(z2)
+    if lc2 == 1:
+        z1 /= z2
+        return z1, z1[:1]*0
+    elif lc1 < lc2:
+        return z1[:1]*0, z1
+    else:
+        dlen = lc1 - lc2
+        scl = z2[0]
+        z2 /= scl
+        quo = np.empty(dlen + 1, dtype=z1.dtype)
+        i = 0
+        j = dlen
+        while i < j:
+            r = z1[i]
+            quo[i] = z1[i]
+            quo[dlen - i] = r
+            tmp = r*z2
+            z1[i:i+lc2] -= tmp
+            z1[j:j+lc2] -= tmp
+            i += 1
+            j -= 1
+        r = z1[i]
+        quo[i] = r
+        tmp = r*z2
+        z1[i:i+lc2] -= tmp
+        quo /= scl
+        rem = z1[i+1:i-1+lc2].copy()
+        return quo, rem
+
+
+def _zseries_der(zs):
+    """Differentiate a z-series.
+
+    The derivative is with respect to x, not z. This is achieved using the
+    chain rule and the value of dx/dz given in the module notes.
+
+    Parameters
+    ----------
+    zs : z-series
+        The z-series to differentiate.
+
+    Returns
+    -------
+    derivative : z-series
+        The derivative
+
+    Notes
+    -----
+    The zseries for x (ns) has been multiplied by two in order to avoid
+    using floats that are incompatible with Decimal and likely other
+    specialized scalar types. This scaling has been compensated by
+    multiplying the value of zs by two also so that the two cancels in the
+    division.
+
+    """
+    n = len(zs)//2
+    ns = np.array([-1, 0, 1], dtype=zs.dtype)
+    zs *= np.arange(-n, n+1)*2
+    d, r = _zseries_div(zs, ns)
+    return d
+
+
+def _zseries_int(zs):
+    """Integrate a z-series.
+
+    The integral is with respect to x, not z. This is achieved by a change
+    of variable using dx/dz given in the module notes.
+
+    Parameters
+    ----------
+    zs : z-series
+        The z-series to integrate
+
+    Returns
+    -------
+    integral : z-series
+        The indefinite integral
+
+    Notes
+    -----
+    The zseries for x (ns) has been multiplied by two in order to avoid
+    using floats that are incompatible with Decimal and likely other
+    specialized scalar types. This scaling has been compensated by
+    dividing the resulting zs by two.
+
+    """
+    n = 1 + len(zs)//2
+    ns = np.array([-1, 0, 1], dtype=zs.dtype)
+    zs = _zseries_mul(zs, ns)
+    div = np.arange(-n, n+1)*2
+    zs[:n] /= div[:n]
+    zs[n+1:] /= div[n+1:]
+    zs[n] = 0
+    return zs
+
+#
+# Chebyshev series functions
+#
+
+
+def poly2cheb(pol):
+    """
+    Convert a polynomial to a Chebyshev series.
+
+    Convert an array representing the coefficients of a polynomial (relative
+    to the "standard" basis) ordered from lowest degree to highest, to an
+    array of the coefficients of the equivalent Chebyshev series, ordered
+    from lowest to highest degree.
+
+    Parameters
+    ----------
+    pol : array_like
+        1-D array containing the polynomial coefficients
+
+    Returns
+    -------
+    c : ndarray
+        1-D array containing the coefficients of the equivalent Chebyshev
+        series.
+
+    See Also
+    --------
+    cheb2poly
+
+    Notes
+    -----
+    The easy way to do conversions between polynomial basis sets
+    is to use the convert method of a class instance.
+
+    Examples
+    --------
+    >>> from numpy import polynomial as P
+    >>> p = P.Polynomial(range(4))
+    >>> p
+    Polynomial([0., 1., 2., 3.], domain=[-1.,  1.], window=[-1.,  1.], symbol='x')
+    >>> c = p.convert(kind=P.Chebyshev)
+    >>> c
+    Chebyshev([1.  , 3.25, 1.  , 0.75], domain=[-1.,  1.], window=[-1., ...
+    >>> P.chebyshev.poly2cheb(range(4))
+    array([1.  , 3.25, 1.  , 0.75])
+
+    """
+    [pol] = pu.as_series([pol])
+    deg = len(pol) - 1
+    res = 0
+    for i in range(deg, -1, -1):
+        res = chebadd(chebmulx(res), pol[i])
+    return res
+
+
+def cheb2poly(c):
+    """
+    Convert a Chebyshev series to a polynomial.
+
+    Convert an array representing the coefficients of a Chebyshev series,
+    ordered from lowest degree to highest, to an array of the coefficients
+    of the equivalent polynomial (relative to the "standard" basis) ordered
+    from lowest to highest degree.
+
+    Parameters
+    ----------
+    c : array_like
+        1-D array containing the Chebyshev series coefficients, ordered
+        from lowest order term to highest.
+
+    Returns
+    -------
+    pol : ndarray
+        1-D array containing the coefficients of the equivalent polynomial
+        (relative to the "standard" basis) ordered from lowest order term
+        to highest.
+
+    See Also
+    --------
+    poly2cheb
+
+    Notes
+    -----
+    The easy way to do conversions between polynomial basis sets
+    is to use the convert method of a class instance.
+
+    Examples
+    --------
+    >>> from numpy import polynomial as P
+    >>> c = P.Chebyshev(range(4))
+    >>> c
+    Chebyshev([0., 1., 2., 3.], domain=[-1.,  1.], window=[-1.,  1.], symbol='x')
+    >>> p = c.convert(kind=P.Polynomial)
+    >>> p
+    Polynomial([-2., -8.,  4., 12.], domain=[-1.,  1.], window=[-1.,  1.], ...
+    >>> P.chebyshev.cheb2poly(range(4))
+    array([-2.,  -8.,   4.,  12.])
+
+    """
+    from .polynomial import polyadd, polysub, polymulx
+
+    [c] = pu.as_series([c])
+    n = len(c)
+    if n < 3:
+        return c
+    else:
+        c0 = c[-2]
+        c1 = c[-1]
+        # i is the current degree of c1
+        for i in range(n - 1, 1, -1):
+            tmp = c0
+            c0 = polysub(c[i - 2], c1)
+            c1 = polyadd(tmp, polymulx(c1)*2)
+        return polyadd(c0, polymulx(c1))
+
+
+#
+# These are constant arrays are of integer type so as to be compatible
+# with the widest range of other types, such as Decimal.
+#
+
+# Chebyshev default domain.
+chebdomain = np.array([-1., 1.])
+
+# Chebyshev coefficients representing zero.
+chebzero = np.array([0])
+
+# Chebyshev coefficients representing one.
+chebone = np.array([1])
+
+# Chebyshev coefficients representing the identity x.
+chebx = np.array([0, 1])
+
+
+def chebline(off, scl):
+    """
+    Chebyshev series whose graph is a straight line.
+
+    Parameters
+    ----------
+    off, scl : scalars
+        The specified line is given by ``off + scl*x``.
+
+    Returns
+    -------
+    y : ndarray
+        This module's representation of the Chebyshev series for
+        ``off + scl*x``.
+
+    See Also
+    --------
+    numpy.polynomial.polynomial.polyline
+    numpy.polynomial.legendre.legline
+    numpy.polynomial.laguerre.lagline
+    numpy.polynomial.hermite.hermline
+    numpy.polynomial.hermite_e.hermeline
+
+    Examples
+    --------
+    >>> import numpy.polynomial.chebyshev as C
+    >>> C.chebline(3,2)
+    array([3, 2])
+    >>> C.chebval(-3, C.chebline(3,2)) # should be -3
+    -3.0
+
+    """
+    if scl != 0:
+        return np.array([off, scl])
+    else:
+        return np.array([off])
+
+
+def chebfromroots(roots):
+    """
+    Generate a Chebyshev series with given roots.
+
+    The function returns the coefficients of the polynomial
+
+    .. math:: p(x) = (x - r_0) * (x - r_1) * ... * (x - r_n),
+
+    in Chebyshev form, where the :math:`r_n` are the roots specified in
+    `roots`.  If a zero has multiplicity n, then it must appear in `roots`
+    n times.  For instance, if 2 is a root of multiplicity three and 3 is a
+    root of multiplicity 2, then `roots` looks something like [2, 2, 2, 3, 3].
+    The roots can appear in any order.
+
+    If the returned coefficients are `c`, then
+
+    .. math:: p(x) = c_0 + c_1 * T_1(x) + ... +  c_n * T_n(x)
+
+    The coefficient of the last term is not generally 1 for monic
+    polynomials in Chebyshev form.
+
+    Parameters
+    ----------
+    roots : array_like
+        Sequence containing the roots.
+
+    Returns
+    -------
+    out : ndarray
+        1-D array of coefficients.  If all roots are real then `out` is a
+        real array, if some of the roots are complex, then `out` is complex
+        even if all the coefficients in the result are real (see Examples
+        below).
+
+    See Also
+    --------
+    numpy.polynomial.polynomial.polyfromroots
+    numpy.polynomial.legendre.legfromroots
+    numpy.polynomial.laguerre.lagfromroots
+    numpy.polynomial.hermite.hermfromroots
+    numpy.polynomial.hermite_e.hermefromroots
+
+    Examples
+    --------
+    >>> import numpy.polynomial.chebyshev as C
+    >>> C.chebfromroots((-1,0,1)) # x^3 - x relative to the standard basis
+    array([ 0.  , -0.25,  0.  ,  0.25])
+    >>> j = complex(0,1)
+    >>> C.chebfromroots((-j,j)) # x^2 + 1 relative to the standard basis
+    array([1.5+0.j, 0. +0.j, 0.5+0.j])
+
+    """
+    return pu._fromroots(chebline, chebmul, roots)
+
+
+def chebadd(c1, c2):
+    """
+    Add one Chebyshev series to another.
+
+    Returns the sum of two Chebyshev series `c1` + `c2`.  The arguments
+    are sequences of coefficients ordered from lowest order term to
+    highest, i.e., [1,2,3] represents the series ``T_0 + 2*T_1 + 3*T_2``.
+
+    Parameters
+    ----------
+    c1, c2 : array_like
+        1-D arrays of Chebyshev series coefficients ordered from low to
+        high.
+
+    Returns
+    -------
+    out : ndarray
+        Array representing the Chebyshev series of their sum.
+
+    See Also
+    --------
+    chebsub, chebmulx, chebmul, chebdiv, chebpow
+
+    Notes
+    -----
+    Unlike multiplication, division, etc., the sum of two Chebyshev series
+    is a Chebyshev series (without having to "reproject" the result onto
+    the basis set) so addition, just like that of "standard" polynomials,
+    is simply "component-wise."
+
+    Examples
+    --------
+    >>> from numpy.polynomial import chebyshev as C
+    >>> c1 = (1,2,3)
+    >>> c2 = (3,2,1)
+    >>> C.chebadd(c1,c2)
+    array([4., 4., 4.])
+
+    """
+    return pu._add(c1, c2)
+
+
+def chebsub(c1, c2):
+    """
+    Subtract one Chebyshev series from another.
+
+    Returns the difference of two Chebyshev series `c1` - `c2`.  The
+    sequences of coefficients are from lowest order term to highest, i.e.,
+    [1,2,3] represents the series ``T_0 + 2*T_1 + 3*T_2``.
+
+    Parameters
+    ----------
+    c1, c2 : array_like
+        1-D arrays of Chebyshev series coefficients ordered from low to
+        high.
+
+    Returns
+    -------
+    out : ndarray
+        Of Chebyshev series coefficients representing their difference.
+
+    See Also
+    --------
+    chebadd, chebmulx, chebmul, chebdiv, chebpow
+
+    Notes
+    -----
+    Unlike multiplication, division, etc., the difference of two Chebyshev
+    series is a Chebyshev series (without having to "reproject" the result
+    onto the basis set) so subtraction, just like that of "standard"
+    polynomials, is simply "component-wise."
+
+    Examples
+    --------
+    >>> from numpy.polynomial import chebyshev as C
+    >>> c1 = (1,2,3)
+    >>> c2 = (3,2,1)
+    >>> C.chebsub(c1,c2)
+    array([-2.,  0.,  2.])
+    >>> C.chebsub(c2,c1) # -C.chebsub(c1,c2)
+    array([ 2.,  0., -2.])
+
+    """
+    return pu._sub(c1, c2)
+
+
+def chebmulx(c):
+    """Multiply a Chebyshev series by x.
+
+    Multiply the polynomial `c` by x, where x is the independent
+    variable.
+
+
+    Parameters
+    ----------
+    c : array_like
+        1-D array of Chebyshev series coefficients ordered from low to
+        high.
+
+    Returns
+    -------
+    out : ndarray
+        Array representing the result of the multiplication.
+
+    See Also
+    --------
+    chebadd, chebsub, chebmul, chebdiv, chebpow
+
+    Notes
+    -----
+
+    .. versionadded:: 1.5.0
+
+    Examples
+    --------
+    >>> from numpy.polynomial import chebyshev as C
+    >>> C.chebmulx([1,2,3])
+    array([1. , 2.5, 1. , 1.5])
+
+    """
+    # c is a trimmed copy
+    [c] = pu.as_series([c])
+    # The zero series needs special treatment
+    if len(c) == 1 and c[0] == 0:
+        return c
+
+    prd = np.empty(len(c) + 1, dtype=c.dtype)
+    prd[0] = c[0]*0
+    prd[1] = c[0]
+    if len(c) > 1:
+        tmp = c[1:]/2
+        prd[2:] = tmp
+        prd[0:-2] += tmp
+    return prd
+
+
+def chebmul(c1, c2):
+    """
+    Multiply one Chebyshev series by another.
+
+    Returns the product of two Chebyshev series `c1` * `c2`.  The arguments
+    are sequences of coefficients, from lowest order "term" to highest,
+    e.g., [1,2,3] represents the series ``T_0 + 2*T_1 + 3*T_2``.
+
+    Parameters
+    ----------
+    c1, c2 : array_like
+        1-D arrays of Chebyshev series coefficients ordered from low to
+        high.
+
+    Returns
+    -------
+    out : ndarray
+        Of Chebyshev series coefficients representing their product.
+
+    See Also
+    --------
+    chebadd, chebsub, chebmulx, chebdiv, chebpow
+
+    Notes
+    -----
+    In general, the (polynomial) product of two C-series results in terms
+    that are not in the Chebyshev polynomial basis set.  Thus, to express
+    the product as a C-series, it is typically necessary to "reproject"
+    the product onto said basis set, which typically produces
+    "unintuitive live" (but correct) results; see Examples section below.
+
+    Examples
+    --------
+    >>> from numpy.polynomial import chebyshev as C
+    >>> c1 = (1,2,3)
+    >>> c2 = (3,2,1)
+    >>> C.chebmul(c1,c2) # multiplication requires "reprojection"
+    array([  6.5,  12. ,  12. ,   4. ,   1.5])
+
+    """
+    # c1, c2 are trimmed copies
+    [c1, c2] = pu.as_series([c1, c2])
+    z1 = _cseries_to_zseries(c1)
+    z2 = _cseries_to_zseries(c2)
+    prd = _zseries_mul(z1, z2)
+    ret = _zseries_to_cseries(prd)
+    return pu.trimseq(ret)
+
+
+def chebdiv(c1, c2):
+    """
+    Divide one Chebyshev series by another.
+
+    Returns the quotient-with-remainder of two Chebyshev series
+    `c1` / `c2`.  The arguments are sequences of coefficients from lowest
+    order "term" to highest, e.g., [1,2,3] represents the series
+    ``T_0 + 2*T_1 + 3*T_2``.
+
+    Parameters
+    ----------
+    c1, c2 : array_like
+        1-D arrays of Chebyshev series coefficients ordered from low to
+        high.
+
+    Returns
+    -------
+    [quo, rem] : ndarrays
+        Of Chebyshev series coefficients representing the quotient and
+        remainder.
+
+    See Also
+    --------
+    chebadd, chebsub, chebmulx, chebmul, chebpow
+
+    Notes
+    -----
+    In general, the (polynomial) division of one C-series by another
+    results in quotient and remainder terms that are not in the Chebyshev
+    polynomial basis set.  Thus, to express these results as C-series, it
+    is typically necessary to "reproject" the results onto said basis
+    set, which typically produces "unintuitive" (but correct) results;
+    see Examples section below.
+
+    Examples
+    --------
+    >>> from numpy.polynomial import chebyshev as C
+    >>> c1 = (1,2,3)
+    >>> c2 = (3,2,1)
+    >>> C.chebdiv(c1,c2) # quotient "intuitive," remainder not
+    (array([3.]), array([-8., -4.]))
+    >>> c2 = (0,1,2,3)
+    >>> C.chebdiv(c2,c1) # neither "intuitive"
+    (array([0., 2.]), array([-2., -4.]))
+
+    """
+    # c1, c2 are trimmed copies
+    [c1, c2] = pu.as_series([c1, c2])
+    if c2[-1] == 0:
+        raise ZeroDivisionError()
+
+    # note: this is more efficient than `pu._div(chebmul, c1, c2)`
+    lc1 = len(c1)
+    lc2 = len(c2)
+    if lc1 < lc2:
+        return c1[:1]*0, c1
+    elif lc2 == 1:
+        return c1/c2[-1], c1[:1]*0
+    else:
+        z1 = _cseries_to_zseries(c1)
+        z2 = _cseries_to_zseries(c2)
+        quo, rem = _zseries_div(z1, z2)
+        quo = pu.trimseq(_zseries_to_cseries(quo))
+        rem = pu.trimseq(_zseries_to_cseries(rem))
+        return quo, rem
+
+
+def chebpow(c, pow, maxpower=16):
+    """Raise a Chebyshev series to a power.
+
+    Returns the Chebyshev series `c` raised to the power `pow`. The
+    argument `c` is a sequence of coefficients ordered from low to high.
+    i.e., [1,2,3] is the series  ``T_0 + 2*T_1 + 3*T_2.``
+
+    Parameters
+    ----------
+    c : array_like
+        1-D array of Chebyshev series coefficients ordered from low to
+        high.
+    pow : integer
+        Power to which the series will be raised
+    maxpower : integer, optional
+        Maximum power allowed. This is mainly to limit growth of the series
+        to unmanageable size. Default is 16
+
+    Returns
+    -------
+    coef : ndarray
+        Chebyshev series of power.
+
+    See Also
+    --------
+    chebadd, chebsub, chebmulx, chebmul, chebdiv
+
+    Examples
+    --------
+    >>> from numpy.polynomial import chebyshev as C
+    >>> C.chebpow([1, 2, 3, 4], 2)
+    array([15.5, 22. , 16. , ..., 12.5, 12. ,  8. ])
+
+    """
+    # note: this is more efficient than `pu._pow(chebmul, c1, c2)`, as it
+    # avoids converting between z and c series repeatedly
+
+    # c is a trimmed copy
+    [c] = pu.as_series([c])
+    power = int(pow)
+    if power != pow or power < 0:
+        raise ValueError("Power must be a non-negative integer.")
+    elif maxpower is not None and power > maxpower:
+        raise ValueError("Power is too large")
+    elif power == 0:
+        return np.array([1], dtype=c.dtype)
+    elif power == 1:
+        return c
+    else:
+        # This can be made more efficient by using powers of two
+        # in the usual way.
+        zs = _cseries_to_zseries(c)
+        prd = zs
+        for i in range(2, power + 1):
+            prd = np.convolve(prd, zs)
+        return _zseries_to_cseries(prd)
+
+
+def chebder(c, m=1, scl=1, axis=0):
+    """
+    Differentiate a Chebyshev series.
+
+    Returns the Chebyshev series coefficients `c` differentiated `m` times
+    along `axis`.  At each iteration the result is multiplied by `scl` (the
+    scaling factor is for use in a linear change of variable). The argument
+    `c` is an array of coefficients from low to high degree along each
+    axis, e.g., [1,2,3] represents the series ``1*T_0 + 2*T_1 + 3*T_2``
+    while [[1,2],[1,2]] represents ``1*T_0(x)*T_0(y) + 1*T_1(x)*T_0(y) +
+    2*T_0(x)*T_1(y) + 2*T_1(x)*T_1(y)`` if axis=0 is ``x`` and axis=1 is
+    ``y``.
+
+    Parameters
+    ----------
+    c : array_like
+        Array of Chebyshev series coefficients. If c is multidimensional
+        the different axis correspond to different variables with the
+        degree in each axis given by the corresponding index.
+    m : int, optional
+        Number of derivatives taken, must be non-negative. (Default: 1)
+    scl : scalar, optional
+        Each differentiation is multiplied by `scl`.  The end result is
+        multiplication by ``scl**m``.  This is for use in a linear change of
+        variable. (Default: 1)
+    axis : int, optional
+        Axis over which the derivative is taken. (Default: 0).
+
+        .. versionadded:: 1.7.0
+
+    Returns
+    -------
+    der : ndarray
+        Chebyshev series of the derivative.
+
+    See Also
+    --------
+    chebint
+
+    Notes
+    -----
+    In general, the result of differentiating a C-series needs to be
+    "reprojected" onto the C-series basis set. Thus, typically, the
+    result of this function is "unintuitive," albeit correct; see Examples
+    section below.
+
+    Examples
+    --------
+    >>> from numpy.polynomial import chebyshev as C
+    >>> c = (1,2,3,4)
+    >>> C.chebder(c)
+    array([14., 12., 24.])
+    >>> C.chebder(c,3)
+    array([96.])
+    >>> C.chebder(c,scl=-1)
+    array([-14., -12., -24.])
+    >>> C.chebder(c,2,-1)
+    array([12.,  96.])
+
+    """
+    c = np.array(c, ndmin=1, copy=True)
+    if c.dtype.char in '?bBhHiIlLqQpP':
+        c = c.astype(np.double)
+    cnt = pu._as_int(m, "the order of derivation")
+    iaxis = pu._as_int(axis, "the axis")
+    if cnt < 0:
+        raise ValueError("The order of derivation must be non-negative")
+    iaxis = normalize_axis_index(iaxis, c.ndim)
+
+    if cnt == 0:
+        return c
+
+    c = np.moveaxis(c, iaxis, 0)
+    n = len(c)
+    if cnt >= n:
+        c = c[:1]*0
+    else:
+        for i in range(cnt):
+            n = n - 1
+            c *= scl
+            der = np.empty((n,) + c.shape[1:], dtype=c.dtype)
+            for j in range(n, 2, -1):
+                der[j - 1] = (2*j)*c[j]
+                c[j - 2] += (j*c[j])/(j - 2)
+            if n > 1:
+                der[1] = 4*c[2]
+            der[0] = c[1]
+            c = der
+    c = np.moveaxis(c, 0, iaxis)
+    return c
+
+
+def chebint(c, m=1, k=[], lbnd=0, scl=1, axis=0):
+    """
+    Integrate a Chebyshev series.
+
+    Returns the Chebyshev series coefficients `c` integrated `m` times from
+    `lbnd` along `axis`. At each iteration the resulting series is
+    **multiplied** by `scl` and an integration constant, `k`, is added.
+    The scaling factor is for use in a linear change of variable.  ("Buyer
+    beware": note that, depending on what one is doing, one may want `scl`
+    to be the reciprocal of what one might expect; for more information,
+    see the Notes section below.)  The argument `c` is an array of
+    coefficients from low to high degree along each axis, e.g., [1,2,3]
+    represents the series ``T_0 + 2*T_1 + 3*T_2`` while [[1,2],[1,2]]
+    represents ``1*T_0(x)*T_0(y) + 1*T_1(x)*T_0(y) + 2*T_0(x)*T_1(y) +
+    2*T_1(x)*T_1(y)`` if axis=0 is ``x`` and axis=1 is ``y``.
+
+    Parameters
+    ----------
+    c : array_like
+        Array of Chebyshev series coefficients. If c is multidimensional
+        the different axis correspond to different variables with the
+        degree in each axis given by the corresponding index.
+    m : int, optional
+        Order of integration, must be positive. (Default: 1)
+    k : {[], list, scalar}, optional
+        Integration constant(s).  The value of the first integral at zero
+        is the first value in the list, the value of the second integral
+        at zero is the second value, etc.  If ``k == []`` (the default),
+        all constants are set to zero.  If ``m == 1``, a single scalar can
+        be given instead of a list.
+    lbnd : scalar, optional
+        The lower bound of the integral. (Default: 0)
+    scl : scalar, optional
+        Following each integration the result is *multiplied* by `scl`
+        before the integration constant is added. (Default: 1)
+    axis : int, optional
+        Axis over which the integral is taken. (Default: 0).
+
+        .. versionadded:: 1.7.0
+
+    Returns
+    -------
+    S : ndarray
+        C-series coefficients of the integral.
+
+    Raises
+    ------
+    ValueError
+        If ``m < 1``, ``len(k) > m``, ``np.ndim(lbnd) != 0``, or
+        ``np.ndim(scl) != 0``.
+
+    See Also
+    --------
+    chebder
+
+    Notes
+    -----
+    Note that the result of each integration is *multiplied* by `scl`.
+    Why is this important to note?  Say one is making a linear change of
+    variable :math:`u = ax + b` in an integral relative to `x`.  Then
+    :math:`dx = du/a`, so one will need to set `scl` equal to
+    :math:`1/a`- perhaps not what one would have first thought.
+
+    Also note that, in general, the result of integrating a C-series needs
+    to be "reprojected" onto the C-series basis set.  Thus, typically,
+    the result of this function is "unintuitive," albeit correct; see
+    Examples section below.
+
+    Examples
+    --------
+    >>> from numpy.polynomial import chebyshev as C
+    >>> c = (1,2,3)
+    >>> C.chebint(c)
+    array([ 0.5, -0.5,  0.5,  0.5])
+    >>> C.chebint(c,3)
+    array([ 0.03125   , -0.1875    ,  0.04166667, -0.05208333,  0.01041667, # may vary
+        0.00625   ])
+    >>> C.chebint(c, k=3)
+    array([ 3.5, -0.5,  0.5,  0.5])
+    >>> C.chebint(c,lbnd=-2)
+    array([ 8.5, -0.5,  0.5,  0.5])
+    >>> C.chebint(c,scl=-2)
+    array([-1.,  1., -1., -1.])
+
+    """
+    c = np.array(c, ndmin=1, copy=True)
+    if c.dtype.char in '?bBhHiIlLqQpP':
+        c = c.astype(np.double)
+    if not np.iterable(k):
+        k = [k]
+    cnt = pu._as_int(m, "the order of integration")
+    iaxis = pu._as_int(axis, "the axis")
+    if cnt < 0:
+        raise ValueError("The order of integration must be non-negative")
+    if len(k) > cnt:
+        raise ValueError("Too many integration constants")
+    if np.ndim(lbnd) != 0:
+        raise ValueError("lbnd must be a scalar.")
+    if np.ndim(scl) != 0:
+        raise ValueError("scl must be a scalar.")
+    iaxis = normalize_axis_index(iaxis, c.ndim)
+
+    if cnt == 0:
+        return c
+
+    c = np.moveaxis(c, iaxis, 0)
+    k = list(k) + [0]*(cnt - len(k))
+    for i in range(cnt):
+        n = len(c)
+        c *= scl
+        if n == 1 and np.all(c[0] == 0):
+            c[0] += k[i]
+        else:
+            tmp = np.empty((n + 1,) + c.shape[1:], dtype=c.dtype)
+            tmp[0] = c[0]*0
+            tmp[1] = c[0]
+            if n > 1:
+                tmp[2] = c[1]/4
+            for j in range(2, n):
+                tmp[j + 1] = c[j]/(2*(j + 1))
+                tmp[j - 1] -= c[j]/(2*(j - 1))
+            tmp[0] += k[i] - chebval(lbnd, tmp)
+            c = tmp
+    c = np.moveaxis(c, 0, iaxis)
+    return c
+
+
+def chebval(x, c, tensor=True):
+    """
+    Evaluate a Chebyshev series at points x.
+
+    If `c` is of length `n + 1`, this function returns the value:
+
+    .. math:: p(x) = c_0 * T_0(x) + c_1 * T_1(x) + ... + c_n * T_n(x)
+
+    The parameter `x` is converted to an array only if it is a tuple or a
+    list, otherwise it is treated as a scalar. In either case, either `x`
+    or its elements must support multiplication and addition both with
+    themselves and with the elements of `c`.
+
+    If `c` is a 1-D array, then ``p(x)`` will have the same shape as `x`.  If
+    `c` is multidimensional, then the shape of the result depends on the
+    value of `tensor`. If `tensor` is true the shape will be c.shape[1:] +
+    x.shape. If `tensor` is false the shape will be c.shape[1:]. Note that
+    scalars have shape (,).
+
+    Trailing zeros in the coefficients will be used in the evaluation, so
+    they should be avoided if efficiency is a concern.
+
+    Parameters
+    ----------
+    x : array_like, compatible object
+        If `x` is a list or tuple, it is converted to an ndarray, otherwise
+        it is left unchanged and treated as a scalar. In either case, `x`
+        or its elements must support addition and multiplication with
+        themselves and with the elements of `c`.
+    c : array_like
+        Array of coefficients ordered so that the coefficients for terms of
+        degree n are contained in c[n]. If `c` is multidimensional the
+        remaining indices enumerate multiple polynomials. In the two
+        dimensional case the coefficients may be thought of as stored in
+        the columns of `c`.
+    tensor : boolean, optional
+        If True, the shape of the coefficient array is extended with ones
+        on the right, one for each dimension of `x`. Scalars have dimension 0
+        for this action. The result is that every column of coefficients in
+        `c` is evaluated for every element of `x`. If False, `x` is broadcast
+        over the columns of `c` for the evaluation.  This keyword is useful
+        when `c` is multidimensional. The default value is True.
+
+        .. versionadded:: 1.7.0
+
+    Returns
+    -------
+    values : ndarray, algebra_like
+        The shape of the return value is described above.
+
+    See Also
+    --------
+    chebval2d, chebgrid2d, chebval3d, chebgrid3d
+
+    Notes
+    -----
+    The evaluation uses Clenshaw recursion, aka synthetic division.
+
+    """
+    c = np.array(c, ndmin=1, copy=True)
+    if c.dtype.char in '?bBhHiIlLqQpP':
+        c = c.astype(np.double)
+    if isinstance(x, (tuple, list)):
+        x = np.asarray(x)
+    if isinstance(x, np.ndarray) and tensor:
+        c = c.reshape(c.shape + (1,)*x.ndim)
+
+    if len(c) == 1:
+        c0 = c[0]
+        c1 = 0
+    elif len(c) == 2:
+        c0 = c[0]
+        c1 = c[1]
+    else:
+        x2 = 2*x
+        c0 = c[-2]
+        c1 = c[-1]
+        for i in range(3, len(c) + 1):
+            tmp = c0
+            c0 = c[-i] - c1
+            c1 = tmp + c1*x2
+    return c0 + c1*x
+
+
+def chebval2d(x, y, c):
+    """
+    Evaluate a 2-D Chebyshev series at points (x, y).
+
+    This function returns the values:
+
+    .. math:: p(x,y) = \\sum_{i,j} c_{i,j} * T_i(x) * T_j(y)
+
+    The parameters `x` and `y` are converted to arrays only if they are
+    tuples or a lists, otherwise they are treated as a scalars and they
+    must have the same shape after conversion. In either case, either `x`
+    and `y` or their elements must support multiplication and addition both
+    with themselves and with the elements of `c`.
+
+    If `c` is a 1-D array a one is implicitly appended to its shape to make
+    it 2-D. The shape of the result will be c.shape[2:] + x.shape.
+
+    Parameters
+    ----------
+    x, y : array_like, compatible objects
+        The two dimensional series is evaluated at the points ``(x, y)``,
+        where `x` and `y` must have the same shape. If `x` or `y` is a list
+        or tuple, it is first converted to an ndarray, otherwise it is left
+        unchanged and if it isn't an ndarray it is treated as a scalar.
+    c : array_like
+        Array of coefficients ordered so that the coefficient of the term
+        of multi-degree i,j is contained in ``c[i,j]``. If `c` has
+        dimension greater than 2 the remaining indices enumerate multiple
+        sets of coefficients.
+
+    Returns
+    -------
+    values : ndarray, compatible object
+        The values of the two dimensional Chebyshev series at points formed
+        from pairs of corresponding values from `x` and `y`.
+
+    See Also
+    --------
+    chebval, chebgrid2d, chebval3d, chebgrid3d
+
+    Notes
+    -----
+
+    .. versionadded:: 1.7.0
+
+    """
+    return pu._valnd(chebval, c, x, y)
+
+
+def chebgrid2d(x, y, c):
+    """
+    Evaluate a 2-D Chebyshev series on the Cartesian product of x and y.
+
+    This function returns the values:
+
+    .. math:: p(a,b) = \\sum_{i,j} c_{i,j} * T_i(a) * T_j(b),
+
+    where the points `(a, b)` consist of all pairs formed by taking
+    `a` from `x` and `b` from `y`. The resulting points form a grid with
+    `x` in the first dimension and `y` in the second.
+
+    The parameters `x` and `y` are converted to arrays only if they are
+    tuples or a lists, otherwise they are treated as a scalars. In either
+    case, either `x` and `y` or their elements must support multiplication
+    and addition both with themselves and with the elements of `c`.
+
+    If `c` has fewer than two dimensions, ones are implicitly appended to
+    its shape to make it 2-D. The shape of the result will be c.shape[2:] +
+    x.shape + y.shape.
+
+    Parameters
+    ----------
+    x, y : array_like, compatible objects
+        The two dimensional series is evaluated at the points in the
+        Cartesian product of `x` and `y`.  If `x` or `y` is a list or
+        tuple, it is first converted to an ndarray, otherwise it is left
+        unchanged and, if it isn't an ndarray, it is treated as a scalar.
+    c : array_like
+        Array of coefficients ordered so that the coefficient of the term of
+        multi-degree i,j is contained in ``c[i,j]``. If `c` has dimension
+        greater than two the remaining indices enumerate multiple sets of
+        coefficients.
+
+    Returns
+    -------
+    values : ndarray, compatible object
+        The values of the two dimensional Chebyshev series at points in the
+        Cartesian product of `x` and `y`.
+
+    See Also
+    --------
+    chebval, chebval2d, chebval3d, chebgrid3d
+
+    Notes
+    -----
+
+    .. versionadded:: 1.7.0
+
+    """
+    return pu._gridnd(chebval, c, x, y)
+
+
+def chebval3d(x, y, z, c):
+    """
+    Evaluate a 3-D Chebyshev series at points (x, y, z).
+
+    This function returns the values:
+
+    .. math:: p(x,y,z) = \\sum_{i,j,k} c_{i,j,k} * T_i(x) * T_j(y) * T_k(z)
+
+    The parameters `x`, `y`, and `z` are converted to arrays only if
+    they are tuples or a lists, otherwise they are treated as a scalars and
+    they must have the same shape after conversion. In either case, either
+    `x`, `y`, and `z` or their elements must support multiplication and
+    addition both with themselves and with the elements of `c`.
+
+    If `c` has fewer than 3 dimensions, ones are implicitly appended to its
+    shape to make it 3-D. The shape of the result will be c.shape[3:] +
+    x.shape.
+
+    Parameters
+    ----------
+    x, y, z : array_like, compatible object
+        The three dimensional series is evaluated at the points
+        ``(x, y, z)``, where `x`, `y`, and `z` must have the same shape.  If
+        any of `x`, `y`, or `z` is a list or tuple, it is first converted
+        to an ndarray, otherwise it is left unchanged and if it isn't an
+        ndarray it is  treated as a scalar.
+    c : array_like
+        Array of coefficients ordered so that the coefficient of the term of
+        multi-degree i,j,k is contained in ``c[i,j,k]``. If `c` has dimension
+        greater than 3 the remaining indices enumerate multiple sets of
+        coefficients.
+
+    Returns
+    -------
+    values : ndarray, compatible object
+        The values of the multidimensional polynomial on points formed with
+        triples of corresponding values from `x`, `y`, and `z`.
+
+    See Also
+    --------
+    chebval, chebval2d, chebgrid2d, chebgrid3d
+
+    Notes
+    -----
+
+    .. versionadded:: 1.7.0
+
+    """
+    return pu._valnd(chebval, c, x, y, z)
+
+
+def chebgrid3d(x, y, z, c):
+    """
+    Evaluate a 3-D Chebyshev series on the Cartesian product of x, y, and z.
+
+    This function returns the values:
+
+    .. math:: p(a,b,c) = \\sum_{i,j,k} c_{i,j,k} * T_i(a) * T_j(b) * T_k(c)
+
+    where the points ``(a, b, c)`` consist of all triples formed by taking
+    `a` from `x`, `b` from `y`, and `c` from `z`. The resulting points form
+    a grid with `x` in the first dimension, `y` in the second, and `z` in
+    the third.
+
+    The parameters `x`, `y`, and `z` are converted to arrays only if they
+    are tuples or a lists, otherwise they are treated as a scalars. In
+    either case, either `x`, `y`, and `z` or their elements must support
+    multiplication and addition both with themselves and with the elements
+    of `c`.
+
+    If `c` has fewer than three dimensions, ones are implicitly appended to
+    its shape to make it 3-D. The shape of the result will be c.shape[3:] +
+    x.shape + y.shape + z.shape.
+
+    Parameters
+    ----------
+    x, y, z : array_like, compatible objects
+        The three dimensional series is evaluated at the points in the
+        Cartesian product of `x`, `y`, and `z`.  If `x`, `y`, or `z` is a
+        list or tuple, it is first converted to an ndarray, otherwise it is
+        left unchanged and, if it isn't an ndarray, it is treated as a
+        scalar.
+    c : array_like
+        Array of coefficients ordered so that the coefficients for terms of
+        degree i,j are contained in ``c[i,j]``. If `c` has dimension
+        greater than two the remaining indices enumerate multiple sets of
+        coefficients.
+
+    Returns
+    -------
+    values : ndarray, compatible object
+        The values of the two dimensional polynomial at points in the Cartesian
+        product of `x` and `y`.
+
+    See Also
+    --------
+    chebval, chebval2d, chebgrid2d, chebval3d
+
+    Notes
+    -----
+
+    .. versionadded:: 1.7.0
+
+    """
+    return pu._gridnd(chebval, c, x, y, z)
+
+
+def chebvander(x, deg):
+    """Pseudo-Vandermonde matrix of given degree.
+
+    Returns the pseudo-Vandermonde matrix of degree `deg` and sample points
+    `x`. The pseudo-Vandermonde matrix is defined by
+
+    .. math:: V[..., i] = T_i(x),
+
+    where ``0 <= i <= deg``. The leading indices of `V` index the elements of
+    `x` and the last index is the degree of the Chebyshev polynomial.
+
+    If `c` is a 1-D array of coefficients of length ``n + 1`` and `V` is the
+    matrix ``V = chebvander(x, n)``, then ``np.dot(V, c)`` and
+    ``chebval(x, c)`` are the same up to roundoff.  This equivalence is
+    useful both for least squares fitting and for the evaluation of a large
+    number of Chebyshev series of the same degree and sample points.
+
+    Parameters
+    ----------
+    x : array_like
+        Array of points. The dtype is converted to float64 or complex128
+        depending on whether any of the elements are complex. If `x` is
+        scalar it is converted to a 1-D array.
+    deg : int
+        Degree of the resulting matrix.
+
+    Returns
+    -------
+    vander : ndarray
+        The pseudo Vandermonde matrix. The shape of the returned matrix is
+        ``x.shape + (deg + 1,)``, where The last index is the degree of the
+        corresponding Chebyshev polynomial.  The dtype will be the same as
+        the converted `x`.
+
+    """
+    ideg = pu._as_int(deg, "deg")
+    if ideg < 0:
+        raise ValueError("deg must be non-negative")
+
+    x = np.array(x, copy=None, ndmin=1) + 0.0
+    dims = (ideg + 1,) + x.shape
+    dtyp = x.dtype
+    v = np.empty(dims, dtype=dtyp)
+    # Use forward recursion to generate the entries.
+    v[0] = x*0 + 1
+    if ideg > 0:
+        x2 = 2*x
+        v[1] = x
+        for i in range(2, ideg + 1):
+            v[i] = v[i-1]*x2 - v[i-2]
+    return np.moveaxis(v, 0, -1)
+
+
+def chebvander2d(x, y, deg):
+    """Pseudo-Vandermonde matrix of given degrees.
+
+    Returns the pseudo-Vandermonde matrix of degrees `deg` and sample
+    points ``(x, y)``. The pseudo-Vandermonde matrix is defined by
+
+    .. math:: V[..., (deg[1] + 1)*i + j] = T_i(x) * T_j(y),
+
+    where ``0 <= i <= deg[0]`` and ``0 <= j <= deg[1]``. The leading indices of
+    `V` index the points ``(x, y)`` and the last index encodes the degrees of
+    the Chebyshev polynomials.
+
+    If ``V = chebvander2d(x, y, [xdeg, ydeg])``, then the columns of `V`
+    correspond to the elements of a 2-D coefficient array `c` of shape
+    (xdeg + 1, ydeg + 1) in the order
+
+    .. math:: c_{00}, c_{01}, c_{02} ... , c_{10}, c_{11}, c_{12} ...
+
+    and ``np.dot(V, c.flat)`` and ``chebval2d(x, y, c)`` will be the same
+    up to roundoff. This equivalence is useful both for least squares
+    fitting and for the evaluation of a large number of 2-D Chebyshev
+    series of the same degrees and sample points.
+
+    Parameters
+    ----------
+    x, y : array_like
+        Arrays of point coordinates, all of the same shape. The dtypes
+        will be converted to either float64 or complex128 depending on
+        whether any of the elements are complex. Scalars are converted to
+        1-D arrays.
+    deg : list of ints
+        List of maximum degrees of the form [x_deg, y_deg].
+
+    Returns
+    -------
+    vander2d : ndarray
+        The shape of the returned matrix is ``x.shape + (order,)``, where
+        :math:`order = (deg[0]+1)*(deg[1]+1)`.  The dtype will be the same
+        as the converted `x` and `y`.
+
+    See Also
+    --------
+    chebvander, chebvander3d, chebval2d, chebval3d
+
+    Notes
+    -----
+
+    .. versionadded:: 1.7.0
+
+    """
+    return pu._vander_nd_flat((chebvander, chebvander), (x, y), deg)
+
+
+def chebvander3d(x, y, z, deg):
+    """Pseudo-Vandermonde matrix of given degrees.
+
+    Returns the pseudo-Vandermonde matrix of degrees `deg` and sample
+    points ``(x, y, z)``. If `l`, `m`, `n` are the given degrees in `x`, `y`, `z`,
+    then The pseudo-Vandermonde matrix is defined by
+
+    .. math:: V[..., (m+1)(n+1)i + (n+1)j + k] = T_i(x)*T_j(y)*T_k(z),
+
+    where ``0 <= i <= l``, ``0 <= j <= m``, and ``0 <= j <= n``.  The leading
+    indices of `V` index the points ``(x, y, z)`` and the last index encodes
+    the degrees of the Chebyshev polynomials.
+
+    If ``V = chebvander3d(x, y, z, [xdeg, ydeg, zdeg])``, then the columns
+    of `V` correspond to the elements of a 3-D coefficient array `c` of
+    shape (xdeg + 1, ydeg + 1, zdeg + 1) in the order
+
+    .. math:: c_{000}, c_{001}, c_{002},... , c_{010}, c_{011}, c_{012},...
+
+    and ``np.dot(V, c.flat)`` and ``chebval3d(x, y, z, c)`` will be the
+    same up to roundoff. This equivalence is useful both for least squares
+    fitting and for the evaluation of a large number of 3-D Chebyshev
+    series of the same degrees and sample points.
+
+    Parameters
+    ----------
+    x, y, z : array_like
+        Arrays of point coordinates, all of the same shape. The dtypes will
+        be converted to either float64 or complex128 depending on whether
+        any of the elements are complex. Scalars are converted to 1-D
+        arrays.
+    deg : list of ints
+        List of maximum degrees of the form [x_deg, y_deg, z_deg].
+
+    Returns
+    -------
+    vander3d : ndarray
+        The shape of the returned matrix is ``x.shape + (order,)``, where
+        :math:`order = (deg[0]+1)*(deg[1]+1)*(deg[2]+1)`.  The dtype will
+        be the same as the converted `x`, `y`, and `z`.
+
+    See Also
+    --------
+    chebvander, chebvander3d, chebval2d, chebval3d
+
+    Notes
+    -----
+
+    .. versionadded:: 1.7.0
+
+    """
+    return pu._vander_nd_flat((chebvander, chebvander, chebvander), (x, y, z), deg)
+
+
+def chebfit(x, y, deg, rcond=None, full=False, w=None):
+    """
+    Least squares fit of Chebyshev series to data.
+
+    Return the coefficients of a Chebyshev series of degree `deg` that is the
+    least squares fit to the data values `y` given at points `x`. If `y` is
+    1-D the returned coefficients will also be 1-D. If `y` is 2-D multiple
+    fits are done, one for each column of `y`, and the resulting
+    coefficients are stored in the corresponding columns of a 2-D return.
+    The fitted polynomial(s) are in the form
+
+    .. math::  p(x) = c_0 + c_1 * T_1(x) + ... + c_n * T_n(x),
+
+    where `n` is `deg`.
+
+    Parameters
+    ----------
+    x : array_like, shape (M,)
+        x-coordinates of the M sample points ``(x[i], y[i])``.
+    y : array_like, shape (M,) or (M, K)
+        y-coordinates of the sample points. Several data sets of sample
+        points sharing the same x-coordinates can be fitted at once by
+        passing in a 2D-array that contains one dataset per column.
+    deg : int or 1-D array_like
+        Degree(s) of the fitting polynomials. If `deg` is a single integer,
+        all terms up to and including the `deg`'th term are included in the
+        fit. For NumPy versions >= 1.11.0 a list of integers specifying the
+        degrees of the terms to include may be used instead.
+    rcond : float, optional
+        Relative condition number of the fit. Singular values smaller than
+        this relative to the largest singular value will be ignored. The
+        default value is ``len(x)*eps``, where eps is the relative precision of
+        the float type, about 2e-16 in most cases.
+    full : bool, optional
+        Switch determining nature of return value. When it is False (the
+        default) just the coefficients are returned, when True diagnostic
+        information from the singular value decomposition is also returned.
+    w : array_like, shape (`M`,), optional
+        Weights. If not None, the weight ``w[i]`` applies to the unsquared
+        residual ``y[i] - y_hat[i]`` at ``x[i]``. Ideally the weights are
+        chosen so that the errors of the products ``w[i]*y[i]`` all have the
+        same variance.  When using inverse-variance weighting, use
+        ``w[i] = 1/sigma(y[i])``.  The default value is None.
+
+        .. versionadded:: 1.5.0
+
+    Returns
+    -------
+    coef : ndarray, shape (M,) or (M, K)
+        Chebyshev coefficients ordered from low to high. If `y` was 2-D,
+        the coefficients for the data in column k  of `y` are in column
+        `k`.
+
+    [residuals, rank, singular_values, rcond] : list
+        These values are only returned if ``full == True``
+
+        - residuals -- sum of squared residuals of the least squares fit
+        - rank -- the numerical rank of the scaled Vandermonde matrix
+        - singular_values -- singular values of the scaled Vandermonde matrix
+        - rcond -- value of `rcond`.
+
+        For more details, see `numpy.linalg.lstsq`.
+
+    Warns
+    -----
+    RankWarning
+        The rank of the coefficient matrix in the least-squares fit is
+        deficient. The warning is only raised if ``full == False``.  The
+        warnings can be turned off by
+
+        >>> import warnings
+        >>> warnings.simplefilter('ignore', np.exceptions.RankWarning)
+
+    See Also
+    --------
+    numpy.polynomial.polynomial.polyfit
+    numpy.polynomial.legendre.legfit
+    numpy.polynomial.laguerre.lagfit
+    numpy.polynomial.hermite.hermfit
+    numpy.polynomial.hermite_e.hermefit
+    chebval : Evaluates a Chebyshev series.
+    chebvander : Vandermonde matrix of Chebyshev series.
+    chebweight : Chebyshev weight function.
+    numpy.linalg.lstsq : Computes a least-squares fit from the matrix.
+    scipy.interpolate.UnivariateSpline : Computes spline fits.
+
+    Notes
+    -----
+    The solution is the coefficients of the Chebyshev series `p` that
+    minimizes the sum of the weighted squared errors
+
+    .. math:: E = \\sum_j w_j^2 * |y_j - p(x_j)|^2,
+
+    where :math:`w_j` are the weights. This problem is solved by setting up
+    as the (typically) overdetermined matrix equation
+
+    .. math:: V(x) * c = w * y,
+
+    where `V` is the weighted pseudo Vandermonde matrix of `x`, `c` are the
+    coefficients to be solved for, `w` are the weights, and `y` are the
+    observed values.  This equation is then solved using the singular value
+    decomposition of `V`.
+
+    If some of the singular values of `V` are so small that they are
+    neglected, then a `~exceptions.RankWarning` will be issued. This means that
+    the coefficient values may be poorly determined. Using a lower order fit
+    will usually get rid of the warning.  The `rcond` parameter can also be
+    set to a value smaller than its default, but the resulting fit may be
+    spurious and have large contributions from roundoff error.
+
+    Fits using Chebyshev series are usually better conditioned than fits
+    using power series, but much can depend on the distribution of the
+    sample points and the smoothness of the data. If the quality of the fit
+    is inadequate splines may be a good alternative.
+
+    References
+    ----------
+    .. [1] Wikipedia, "Curve fitting",
+           https://en.wikipedia.org/wiki/Curve_fitting
+
+    Examples
+    --------
+
+    """
+    return pu._fit(chebvander, x, y, deg, rcond, full, w)
+
+
+def chebcompanion(c):
+    """Return the scaled companion matrix of c.
+
+    The basis polynomials are scaled so that the companion matrix is
+    symmetric when `c` is a Chebyshev basis polynomial. This provides
+    better eigenvalue estimates than the unscaled case and for basis
+    polynomials the eigenvalues are guaranteed to be real if
+    `numpy.linalg.eigvalsh` is used to obtain them.
+
+    Parameters
+    ----------
+    c : array_like
+        1-D array of Chebyshev series coefficients ordered from low to high
+        degree.
+
+    Returns
+    -------
+    mat : ndarray
+        Scaled companion matrix of dimensions (deg, deg).
+
+    Notes
+    -----
+
+    .. versionadded:: 1.7.0
+
+    """
+    # c is a trimmed copy
+    [c] = pu.as_series([c])
+    if len(c) < 2:
+        raise ValueError('Series must have maximum degree of at least 1.')
+    if len(c) == 2:
+        return np.array([[-c[0]/c[1]]])
+
+    n = len(c) - 1
+    mat = np.zeros((n, n), dtype=c.dtype)
+    scl = np.array([1.] + [np.sqrt(.5)]*(n-1))
+    top = mat.reshape(-1)[1::n+1]
+    bot = mat.reshape(-1)[n::n+1]
+    top[0] = np.sqrt(.5)
+    top[1:] = 1/2
+    bot[...] = top
+    mat[:, -1] -= (c[:-1]/c[-1])*(scl/scl[-1])*.5
+    return mat
+
+
+def chebroots(c):
+    """
+    Compute the roots of a Chebyshev series.
+
+    Return the roots (a.k.a. "zeros") of the polynomial
+
+    .. math:: p(x) = \\sum_i c[i] * T_i(x).
+
+    Parameters
+    ----------
+    c : 1-D array_like
+        1-D array of coefficients.
+
+    Returns
+    -------
+    out : ndarray
+        Array of the roots of the series. If all the roots are real,
+        then `out` is also real, otherwise it is complex.
+
+    See Also
+    --------
+    numpy.polynomial.polynomial.polyroots
+    numpy.polynomial.legendre.legroots
+    numpy.polynomial.laguerre.lagroots
+    numpy.polynomial.hermite.hermroots
+    numpy.polynomial.hermite_e.hermeroots
+
+    Notes
+    -----
+    The root estimates are obtained as the eigenvalues of the companion
+    matrix, Roots far from the origin of the complex plane may have large
+    errors due to the numerical instability of the series for such
+    values. Roots with multiplicity greater than 1 will also show larger
+    errors as the value of the series near such points is relatively
+    insensitive to errors in the roots. Isolated roots near the origin can
+    be improved by a few iterations of Newton's method.
+
+    The Chebyshev series basis polynomials aren't powers of `x` so the
+    results of this function may seem unintuitive.
+
+    Examples
+    --------
+    >>> import numpy.polynomial.chebyshev as cheb
+    >>> cheb.chebroots((-1, 1,-1, 1)) # T3 - T2 + T1 - T0 has real roots
+    array([ -5.00000000e-01,   2.60860684e-17,   1.00000000e+00]) # may vary
+
+    """
+    # c is a trimmed copy
+    [c] = pu.as_series([c])
+    if len(c) < 2:
+        return np.array([], dtype=c.dtype)
+    if len(c) == 2:
+        return np.array([-c[0]/c[1]])
+
+    # rotated companion matrix reduces error
+    m = chebcompanion(c)[::-1,::-1]
+    r = la.eigvals(m)
+    r.sort()
+    return r
+
+
+def chebinterpolate(func, deg, args=()):
+    """Interpolate a function at the Chebyshev points of the first kind.
+
+    Returns the Chebyshev series that interpolates `func` at the Chebyshev
+    points of the first kind in the interval [-1, 1]. The interpolating
+    series tends to a minmax approximation to `func` with increasing `deg`
+    if the function is continuous in the interval.
+
+    .. versionadded:: 1.14.0
+
+    Parameters
+    ----------
+    func : function
+        The function to be approximated. It must be a function of a single
+        variable of the form ``f(x, a, b, c...)``, where ``a, b, c...`` are
+        extra arguments passed in the `args` parameter.
+    deg : int
+        Degree of the interpolating polynomial
+    args : tuple, optional
+        Extra arguments to be used in the function call. Default is no extra
+        arguments.
+
+    Returns
+    -------
+    coef : ndarray, shape (deg + 1,)
+        Chebyshev coefficients of the interpolating series ordered from low to
+        high.
+
+    Examples
+    --------
+    >>> import numpy.polynomial.chebyshev as C
+    >>> C.chebinterpolate(lambda x: np.tanh(x) + 0.5, 8)
+    array([  5.00000000e-01,   8.11675684e-01,  -9.86864911e-17,
+            -5.42457905e-02,  -2.71387850e-16,   4.51658839e-03,
+             2.46716228e-17,  -3.79694221e-04,  -3.26899002e-16])
+
+    Notes
+    -----
+
+    The Chebyshev polynomials used in the interpolation are orthogonal when
+    sampled at the Chebyshev points of the first kind. If it is desired to
+    constrain some of the coefficients they can simply be set to the desired
+    value after the interpolation, no new interpolation or fit is needed. This
+    is especially useful if it is known apriori that some of coefficients are
+    zero. For instance, if the function is even then the coefficients of the
+    terms of odd degree in the result can be set to zero.
+
+    """
+    deg = np.asarray(deg)
+
+    # check arguments.
+    if deg.ndim > 0 or deg.dtype.kind not in 'iu' or deg.size == 0:
+        raise TypeError("deg must be an int")
+    if deg < 0:
+        raise ValueError("expected deg >= 0")
+
+    order = deg + 1
+    xcheb = chebpts1(order)
+    yfunc = func(xcheb, *args)
+    m = chebvander(xcheb, deg)
+    c = np.dot(m.T, yfunc)
+    c[0] /= order
+    c[1:] /= 0.5*order
+
+    return c
+
+
+def chebgauss(deg):
+    """
+    Gauss-Chebyshev quadrature.
+
+    Computes the sample points and weights for Gauss-Chebyshev quadrature.
+    These sample points and weights will correctly integrate polynomials of
+    degree :math:`2*deg - 1` or less over the interval :math:`[-1, 1]` with
+    the weight function :math:`f(x) = 1/\\sqrt{1 - x^2}`.
+
+    Parameters
+    ----------
+    deg : int
+        Number of sample points and weights. It must be >= 1.
+
+    Returns
+    -------
+    x : ndarray
+        1-D ndarray containing the sample points.
+    y : ndarray
+        1-D ndarray containing the weights.
+
+    Notes
+    -----
+
+    .. versionadded:: 1.7.0
+
+    The results have only been tested up to degree 100, higher degrees may
+    be problematic. For Gauss-Chebyshev there are closed form solutions for
+    the sample points and weights. If n = `deg`, then
+
+    .. math:: x_i = \\cos(\\pi (2 i - 1) / (2 n))
+
+    .. math:: w_i = \\pi / n
+
+    """
+    ideg = pu._as_int(deg, "deg")
+    if ideg <= 0:
+        raise ValueError("deg must be a positive integer")
+
+    x = np.cos(np.pi * np.arange(1, 2*ideg, 2) / (2.0*ideg))
+    w = np.ones(ideg)*(np.pi/ideg)
+
+    return x, w
+
+
+def chebweight(x):
+    """
+    The weight function of the Chebyshev polynomials.
+
+    The weight function is :math:`1/\\sqrt{1 - x^2}` and the interval of
+    integration is :math:`[-1, 1]`. The Chebyshev polynomials are
+    orthogonal, but not normalized, with respect to this weight function.
+
+    Parameters
+    ----------
+    x : array_like
+       Values at which the weight function will be computed.
+
+    Returns
+    -------
+    w : ndarray
+       The weight function at `x`.
+
+    Notes
+    -----
+
+    .. versionadded:: 1.7.0
+
+    """
+    w = 1./(np.sqrt(1. + x) * np.sqrt(1. - x))
+    return w
+
+
+def chebpts1(npts):
+    """
+    Chebyshev points of the first kind.
+
+    The Chebyshev points of the first kind are the points ``cos(x)``,
+    where ``x = [pi*(k + .5)/npts for k in range(npts)]``.
+
+    Parameters
+    ----------
+    npts : int
+        Number of sample points desired.
+
+    Returns
+    -------
+    pts : ndarray
+        The Chebyshev points of the first kind.
+
+    See Also
+    --------
+    chebpts2
+
+    Notes
+    -----
+
+    .. versionadded:: 1.5.0
+
+    """
+    _npts = int(npts)
+    if _npts != npts:
+        raise ValueError("npts must be integer")
+    if _npts < 1:
+        raise ValueError("npts must be >= 1")
+
+    x = 0.5 * np.pi / _npts * np.arange(-_npts+1, _npts+1, 2)
+    return np.sin(x)
+
+
+def chebpts2(npts):
+    """
+    Chebyshev points of the second kind.
+
+    The Chebyshev points of the second kind are the points ``cos(x)``,
+    where ``x = [pi*k/(npts - 1) for k in range(npts)]`` sorted in ascending
+    order.
+
+    Parameters
+    ----------
+    npts : int
+        Number of sample points desired.
+
+    Returns
+    -------
+    pts : ndarray
+        The Chebyshev points of the second kind.
+
+    Notes
+    -----
+
+    .. versionadded:: 1.5.0
+
+    """
+    _npts = int(npts)
+    if _npts != npts:
+        raise ValueError("npts must be integer")
+    if _npts < 2:
+        raise ValueError("npts must be >= 2")
+
+    x = np.linspace(-np.pi, 0, _npts)
+    return np.cos(x)
+
+
+#
+# Chebyshev series class
+#
+
+class Chebyshev(ABCPolyBase):
+    """A Chebyshev series class.
+
+    The Chebyshev class provides the standard Python numerical methods
+    '+', '-', '*', '//', '%', 'divmod', '**', and '()' as well as the
+    attributes and methods listed below.
+
+    Parameters
+    ----------
+    coef : array_like
+        Chebyshev coefficients in order of increasing degree, i.e.,
+        ``(1, 2, 3)`` gives ``1*T_0(x) + 2*T_1(x) + 3*T_2(x)``.
+    domain : (2,) array_like, optional
+        Domain to use. The interval ``[domain[0], domain[1]]`` is mapped
+        to the interval ``[window[0], window[1]]`` by shifting and scaling.
+        The default value is [-1., 1.].
+    window : (2,) array_like, optional
+        Window, see `domain` for its use. The default value is [-1., 1.].
+
+        .. versionadded:: 1.6.0
+    symbol : str, optional
+        Symbol used to represent the independent variable in string
+        representations of the polynomial expression, e.g. for printing.
+        The symbol must be a valid Python identifier. Default value is 'x'.
+
+        .. versionadded:: 1.24
+
+    """
+    # Virtual Functions
+    _add = staticmethod(chebadd)
+    _sub = staticmethod(chebsub)
+    _mul = staticmethod(chebmul)
+    _div = staticmethod(chebdiv)
+    _pow = staticmethod(chebpow)
+    _val = staticmethod(chebval)
+    _int = staticmethod(chebint)
+    _der = staticmethod(chebder)
+    _fit = staticmethod(chebfit)
+    _line = staticmethod(chebline)
+    _roots = staticmethod(chebroots)
+    _fromroots = staticmethod(chebfromroots)
+
+    @classmethod
+    def interpolate(cls, func, deg, domain=None, args=()):
+        """Interpolate a function at the Chebyshev points of the first kind.
+
+        Returns the series that interpolates `func` at the Chebyshev points of
+        the first kind scaled and shifted to the `domain`. The resulting series
+        tends to a minmax approximation of `func` when the function is
+        continuous in the domain.
+
+        .. versionadded:: 1.14.0
+
+        Parameters
+        ----------
+        func : function
+            The function to be interpolated. It must be a function of a single
+            variable of the form ``f(x, a, b, c...)``, where ``a, b, c...`` are
+            extra arguments passed in the `args` parameter.
+        deg : int
+            Degree of the interpolating polynomial.
+        domain : {None, [beg, end]}, optional
+            Domain over which `func` is interpolated. The default is None, in
+            which case the domain is [-1, 1].
+        args : tuple, optional
+            Extra arguments to be used in the function call. Default is no
+            extra arguments.
+
+        Returns
+        -------
+        polynomial : Chebyshev instance
+            Interpolating Chebyshev instance.
+
+        Notes
+        -----
+        See `numpy.polynomial.chebinterpolate` for more details.
+
+        """
+        if domain is None:
+            domain = cls.domain
+        xfunc = lambda x: func(pu.mapdomain(x, cls.window, domain), *args)
+        coef = chebinterpolate(xfunc, deg)
+        return cls(coef, domain=domain)
+
+    # Virtual properties
+    domain = np.array(chebdomain)
+    window = np.array(chebdomain)
+    basis_name = 'T'
diff --git a/venv/lib/python3.12/site-packages/numpy/polynomial/chebyshev.pyi b/venv/lib/python3.12/site-packages/numpy/polynomial/chebyshev.pyi
new file mode 100644
index 00000000..067af81d
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/polynomial/chebyshev.pyi
@@ -0,0 +1,192 @@
+from collections.abc import Callable, Iterable
+from typing import (
+    Any,
+    Concatenate,
+    Final,
+    Literal as L,
+    TypeVar,
+    overload,
+)
+
+import numpy as np
+import numpy.typing as npt
+from numpy._typing import _IntLike_co
+
+from ._polybase import ABCPolyBase
+from ._polytypes import (
+    _SeriesLikeCoef_co,
+    _Array1,
+    _Series,
+    _Array2,
+    _CoefSeries,
+    _FuncBinOp,
+    _FuncCompanion,
+    _FuncDer,
+    _FuncFit,
+    _FuncFromRoots,
+    _FuncGauss,
+    _FuncInteg,
+    _FuncLine,
+    _FuncPoly2Ortho,
+    _FuncPow,
+    _FuncPts,
+    _FuncRoots,
+    _FuncUnOp,
+    _FuncVal,
+    _FuncVal2D,
+    _FuncVal3D,
+    _FuncValFromRoots,
+    _FuncVander,
+    _FuncVander2D,
+    _FuncVander3D,
+    _FuncWeight,
+)
+from .polyutils import trimcoef as chebtrim
+
+__all__ = [
+    "chebzero",
+    "chebone",
+    "chebx",
+    "chebdomain",
+    "chebline",
+    "chebadd",
+    "chebsub",
+    "chebmulx",
+    "chebmul",
+    "chebdiv",
+    "chebpow",
+    "chebval",
+    "chebder",
+    "chebint",
+    "cheb2poly",
+    "poly2cheb",
+    "chebfromroots",
+    "chebvander",
+    "chebfit",
+    "chebtrim",
+    "chebroots",
+    "chebpts1",
+    "chebpts2",
+    "Chebyshev",
+    "chebval2d",
+    "chebval3d",
+    "chebgrid2d",
+    "chebgrid3d",
+    "chebvander2d",
+    "chebvander3d",
+    "chebcompanion",
+    "chebgauss",
+    "chebweight",
+    "chebinterpolate",
+]
+
+_SCT = TypeVar("_SCT", bound=np.number[Any] | np.object_)
+def _cseries_to_zseries(c: npt.NDArray[_SCT]) -> _Series[_SCT]: ...
+def _zseries_to_cseries(zs: npt.NDArray[_SCT]) -> _Series[_SCT]: ...
+def _zseries_mul(
+    z1: npt.NDArray[_SCT],
+    z2: npt.NDArray[_SCT],
+) -> _Series[_SCT]: ...
+def _zseries_div(
+    z1: npt.NDArray[_SCT],
+    z2: npt.NDArray[_SCT],
+) -> _Series[_SCT]: ...
+def _zseries_der(zs: npt.NDArray[_SCT]) -> _Series[_SCT]: ...
+def _zseries_int(zs: npt.NDArray[_SCT]) -> _Series[_SCT]: ...
+
+poly2cheb: _FuncPoly2Ortho[L["poly2cheb"]]
+cheb2poly: _FuncUnOp[L["cheb2poly"]]
+
+chebdomain: Final[_Array2[np.float64]]
+chebzero: Final[_Array1[np.int_]]
+chebone: Final[_Array1[np.int_]]
+chebx: Final[_Array2[np.int_]]
+
+chebline: _FuncLine[L["chebline"]]
+chebfromroots: _FuncFromRoots[L["chebfromroots"]]
+chebadd: _FuncBinOp[L["chebadd"]]
+chebsub: _FuncBinOp[L["chebsub"]]
+chebmulx: _FuncUnOp[L["chebmulx"]]
+chebmul: _FuncBinOp[L["chebmul"]]
+chebdiv: _FuncBinOp[L["chebdiv"]]
+chebpow: _FuncPow[L["chebpow"]]
+chebder: _FuncDer[L["chebder"]]
+chebint: _FuncInteg[L["chebint"]]
+chebval: _FuncVal[L["chebval"]]
+chebval2d: _FuncVal2D[L["chebval2d"]]
+chebval3d: _FuncVal3D[L["chebval3d"]]
+chebvalfromroots: _FuncValFromRoots[L["chebvalfromroots"]]
+chebgrid2d: _FuncVal2D[L["chebgrid2d"]]
+chebgrid3d: _FuncVal3D[L["chebgrid3d"]]
+chebvander: _FuncVander[L["chebvander"]]
+chebvander2d: _FuncVander2D[L["chebvander2d"]]
+chebvander3d: _FuncVander3D[L["chebvander3d"]]
+chebfit: _FuncFit[L["chebfit"]]
+chebcompanion: _FuncCompanion[L["chebcompanion"]]
+chebroots: _FuncRoots[L["chebroots"]]
+chebgauss: _FuncGauss[L["chebgauss"]]
+chebweight: _FuncWeight[L["chebweight"]]
+chebpts1: _FuncPts[L["chebpts1"]]
+chebpts2: _FuncPts[L["chebpts2"]]
+
+# keep in sync with `Chebyshev.interpolate`
+_RT = TypeVar("_RT", bound=np.number[Any] | np.bool | np.object_)
+@overload
+def chebinterpolate(
+    func: np.ufunc,
+    deg: _IntLike_co,
+    args: tuple[()] = ...,
+) -> npt.NDArray[np.float64 | np.complex128 | np.object_]: ...
+@overload
+def chebinterpolate(
+    func: Callable[[npt.NDArray[np.float64]], _RT],
+    deg: _IntLike_co,
+    args: tuple[()] = ...,
+) -> npt.NDArray[_RT]: ...
+@overload
+def chebinterpolate(
+    func: Callable[Concatenate[npt.NDArray[np.float64], ...], _RT],
+    deg: _IntLike_co,
+    args: Iterable[Any],
+) -> npt.NDArray[_RT]: ...
+
+_Self = TypeVar("_Self", bound=object)
+
+class Chebyshev(ABCPolyBase[L["T"]]):
+    @overload
+    @classmethod
+    def interpolate(
+        cls: type[_Self],
+        /,
+        func: Callable[[npt.NDArray[np.float64]], _CoefSeries],
+        deg: _IntLike_co,
+        domain: None | _SeriesLikeCoef_co = ...,
+        args: tuple[()] = ...,
+    ) -> _Self: ...
+    @overload
+    @classmethod
+    def interpolate(
+        cls: type[_Self],
+        /,
+        func: Callable[
+            Concatenate[npt.NDArray[np.float64], ...],
+            _CoefSeries,
+        ],
+        deg: _IntLike_co,
+        domain: None | _SeriesLikeCoef_co = ...,
+        *,
+        args: Iterable[Any],
+    ) -> _Self: ...
+    @overload
+    @classmethod
+    def interpolate(
+        cls: type[_Self],
+        func: Callable[
+            Concatenate[npt.NDArray[np.float64], ...],
+            _CoefSeries,
+        ],
+        deg: _IntLike_co,
+        domain: None | _SeriesLikeCoef_co,
+        args: Iterable[Any],
+        /,
+    ) -> _Self: ...
diff --git a/venv/lib/python3.12/site-packages/numpy/polynomial/hermite.py b/venv/lib/python3.12/site-packages/numpy/polynomial/hermite.py
new file mode 100644
index 00000000..656ab567
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/polynomial/hermite.py
@@ -0,0 +1,1793 @@
+"""
+==============================================================
+Hermite Series, "Physicists" (:mod:`numpy.polynomial.hermite`)
+==============================================================
+
+This module provides a number of objects (mostly functions) useful for
+dealing with Hermite series, including a `Hermite` class that
+encapsulates the usual arithmetic operations.  (General information
+on how this module represents and works with such polynomials is in the
+docstring for its "parent" sub-package, `numpy.polynomial`).
+
+Classes
+-------
+.. autosummary::
+   :toctree: generated/
+
+   Hermite
+
+Constants
+---------
+.. autosummary::
+   :toctree: generated/
+
+   hermdomain
+   hermzero
+   hermone
+   hermx
+
+Arithmetic
+----------
+.. autosummary::
+   :toctree: generated/
+
+   hermadd
+   hermsub
+   hermmulx
+   hermmul
+   hermdiv
+   hermpow
+   hermval
+   hermval2d
+   hermval3d
+   hermgrid2d
+   hermgrid3d
+
+Calculus
+--------
+.. autosummary::
+   :toctree: generated/
+
+   hermder
+   hermint
+
+Misc Functions
+--------------
+.. autosummary::
+   :toctree: generated/
+
+   hermfromroots
+   hermroots
+   hermvander
+   hermvander2d
+   hermvander3d
+   hermgauss
+   hermweight
+   hermcompanion
+   hermfit
+   hermtrim
+   hermline
+   herm2poly
+   poly2herm
+
+See also
+--------
+`numpy.polynomial`
+
+"""
+import numpy as np
+import numpy.linalg as la
+from numpy.lib.array_utils import normalize_axis_index
+
+from . import polyutils as pu
+from ._polybase import ABCPolyBase
+
+__all__ = [
+    'hermzero', 'hermone', 'hermx', 'hermdomain', 'hermline', 'hermadd',
+    'hermsub', 'hermmulx', 'hermmul', 'hermdiv', 'hermpow', 'hermval',
+    'hermder', 'hermint', 'herm2poly', 'poly2herm', 'hermfromroots',
+    'hermvander', 'hermfit', 'hermtrim', 'hermroots', 'Hermite',
+    'hermval2d', 'hermval3d', 'hermgrid2d', 'hermgrid3d', 'hermvander2d',
+    'hermvander3d', 'hermcompanion', 'hermgauss', 'hermweight']
+
+hermtrim = pu.trimcoef
+
+
+def poly2herm(pol):
+    """
+    poly2herm(pol)
+
+    Convert a polynomial to a Hermite series.
+
+    Convert an array representing the coefficients of a polynomial (relative
+    to the "standard" basis) ordered from lowest degree to highest, to an
+    array of the coefficients of the equivalent Hermite series, ordered
+    from lowest to highest degree.
+
+    Parameters
+    ----------
+    pol : array_like
+        1-D array containing the polynomial coefficients
+
+    Returns
+    -------
+    c : ndarray
+        1-D array containing the coefficients of the equivalent Hermite
+        series.
+
+    See Also
+    --------
+    herm2poly
+
+    Notes
+    -----
+    The easy way to do conversions between polynomial basis sets
+    is to use the convert method of a class instance.
+
+    Examples
+    --------
+    >>> from numpy.polynomial.hermite import poly2herm
+    >>> poly2herm(np.arange(4))
+    array([1.   ,  2.75 ,  0.5  ,  0.375])
+
+    """
+    [pol] = pu.as_series([pol])
+    deg = len(pol) - 1
+    res = 0
+    for i in range(deg, -1, -1):
+        res = hermadd(hermmulx(res), pol[i])
+    return res
+
+
+def herm2poly(c):
+    """
+    Convert a Hermite series to a polynomial.
+
+    Convert an array representing the coefficients of a Hermite series,
+    ordered from lowest degree to highest, to an array of the coefficients
+    of the equivalent polynomial (relative to the "standard" basis) ordered
+    from lowest to highest degree.
+
+    Parameters
+    ----------
+    c : array_like
+        1-D array containing the Hermite series coefficients, ordered
+        from lowest order term to highest.
+
+    Returns
+    -------
+    pol : ndarray
+        1-D array containing the coefficients of the equivalent polynomial
+        (relative to the "standard" basis) ordered from lowest order term
+        to highest.
+
+    See Also
+    --------
+    poly2herm
+
+    Notes
+    -----
+    The easy way to do conversions between polynomial basis sets
+    is to use the convert method of a class instance.
+
+    Examples
+    --------
+    >>> from numpy.polynomial.hermite import herm2poly
+    >>> herm2poly([ 1.   ,  2.75 ,  0.5  ,  0.375])
+    array([0., 1., 2., 3.])
+
+    """
+    from .polynomial import polyadd, polysub, polymulx
+
+    [c] = pu.as_series([c])
+    n = len(c)
+    if n == 1:
+        return c
+    if n == 2:
+        c[1] *= 2
+        return c
+    else:
+        c0 = c[-2]
+        c1 = c[-1]
+        # i is the current degree of c1
+        for i in range(n - 1, 1, -1):
+            tmp = c0
+            c0 = polysub(c[i - 2], c1*(2*(i - 1)))
+            c1 = polyadd(tmp, polymulx(c1)*2)
+        return polyadd(c0, polymulx(c1)*2)
+
+
+#
+# These are constant arrays are of integer type so as to be compatible
+# with the widest range of other types, such as Decimal.
+#
+
+# Hermite
+hermdomain = np.array([-1., 1.])
+
+# Hermite coefficients representing zero.
+hermzero = np.array([0])
+
+# Hermite coefficients representing one.
+hermone = np.array([1])
+
+# Hermite coefficients representing the identity x.
+hermx = np.array([0, 1/2])
+
+
+def hermline(off, scl):
+    """
+    Hermite series whose graph is a straight line.
+
+
+
+    Parameters
+    ----------
+    off, scl : scalars
+        The specified line is given by ``off + scl*x``.
+
+    Returns
+    -------
+    y : ndarray
+        This module's representation of the Hermite series for
+        ``off + scl*x``.
+
+    See Also
+    --------
+    numpy.polynomial.polynomial.polyline
+    numpy.polynomial.chebyshev.chebline
+    numpy.polynomial.legendre.legline
+    numpy.polynomial.laguerre.lagline
+    numpy.polynomial.hermite_e.hermeline
+
+    Examples
+    --------
+    >>> from numpy.polynomial.hermite import hermline, hermval
+    >>> hermval(0,hermline(3, 2))
+    3.0
+    >>> hermval(1,hermline(3, 2))
+    5.0
+
+    """
+    if scl != 0:
+        return np.array([off, scl/2])
+    else:
+        return np.array([off])
+
+
+def hermfromroots(roots):
+    """
+    Generate a Hermite series with given roots.
+
+    The function returns the coefficients of the polynomial
+
+    .. math:: p(x) = (x - r_0) * (x - r_1) * ... * (x - r_n),
+
+    in Hermite form, where the :math:`r_n` are the roots specified in `roots`.
+    If a zero has multiplicity n, then it must appear in `roots` n times.
+    For instance, if 2 is a root of multiplicity three and 3 is a root of
+    multiplicity 2, then `roots` looks something like [2, 2, 2, 3, 3]. The
+    roots can appear in any order.
+
+    If the returned coefficients are `c`, then
+
+    .. math:: p(x) = c_0 + c_1 * H_1(x) + ... +  c_n * H_n(x)
+
+    The coefficient of the last term is not generally 1 for monic
+    polynomials in Hermite form.
+
+    Parameters
+    ----------
+    roots : array_like
+        Sequence containing the roots.
+
+    Returns
+    -------
+    out : ndarray
+        1-D array of coefficients.  If all roots are real then `out` is a
+        real array, if some of the roots are complex, then `out` is complex
+        even if all the coefficients in the result are real (see Examples
+        below).
+
+    See Also
+    --------
+    numpy.polynomial.polynomial.polyfromroots
+    numpy.polynomial.legendre.legfromroots
+    numpy.polynomial.laguerre.lagfromroots
+    numpy.polynomial.chebyshev.chebfromroots
+    numpy.polynomial.hermite_e.hermefromroots
+
+    Examples
+    --------
+    >>> from numpy.polynomial.hermite import hermfromroots, hermval
+    >>> coef = hermfromroots((-1, 0, 1))
+    >>> hermval((-1, 0, 1), coef)
+    array([0.,  0.,  0.])
+    >>> coef = hermfromroots((-1j, 1j))
+    >>> hermval((-1j, 1j), coef)
+    array([0.+0.j, 0.+0.j])
+
+    """
+    return pu._fromroots(hermline, hermmul, roots)
+
+
+def hermadd(c1, c2):
+    """
+    Add one Hermite series to another.
+
+    Returns the sum of two Hermite series `c1` + `c2`.  The arguments
+    are sequences of coefficients ordered from lowest order term to
+    highest, i.e., [1,2,3] represents the series ``P_0 + 2*P_1 + 3*P_2``.
+
+    Parameters
+    ----------
+    c1, c2 : array_like
+        1-D arrays of Hermite series coefficients ordered from low to
+        high.
+
+    Returns
+    -------
+    out : ndarray
+        Array representing the Hermite series of their sum.
+
+    See Also
+    --------
+    hermsub, hermmulx, hermmul, hermdiv, hermpow
+
+    Notes
+    -----
+    Unlike multiplication, division, etc., the sum of two Hermite series
+    is a Hermite series (without having to "reproject" the result onto
+    the basis set) so addition, just like that of "standard" polynomials,
+    is simply "component-wise."
+
+    Examples
+    --------
+    >>> from numpy.polynomial.hermite import hermadd
+    >>> hermadd([1, 2, 3], [1, 2, 3, 4])
+    array([2., 4., 6., 4.])
+
+    """
+    return pu._add(c1, c2)
+
+
+def hermsub(c1, c2):
+    """
+    Subtract one Hermite series from another.
+
+    Returns the difference of two Hermite series `c1` - `c2`.  The
+    sequences of coefficients are from lowest order term to highest, i.e.,
+    [1,2,3] represents the series ``P_0 + 2*P_1 + 3*P_2``.
+
+    Parameters
+    ----------
+    c1, c2 : array_like
+        1-D arrays of Hermite series coefficients ordered from low to
+        high.
+
+    Returns
+    -------
+    out : ndarray
+        Of Hermite series coefficients representing their difference.
+
+    See Also
+    --------
+    hermadd, hermmulx, hermmul, hermdiv, hermpow
+
+    Notes
+    -----
+    Unlike multiplication, division, etc., the difference of two Hermite
+    series is a Hermite series (without having to "reproject" the result
+    onto the basis set) so subtraction, just like that of "standard"
+    polynomials, is simply "component-wise."
+
+    Examples
+    --------
+    >>> from numpy.polynomial.hermite import hermsub
+    >>> hermsub([1, 2, 3, 4], [1, 2, 3])
+    array([0.,  0.,  0.,  4.])
+
+    """
+    return pu._sub(c1, c2)
+
+
+def hermmulx(c):
+    """Multiply a Hermite series by x.
+
+    Multiply the Hermite series `c` by x, where x is the independent
+    variable.
+
+
+    Parameters
+    ----------
+    c : array_like
+        1-D array of Hermite series coefficients ordered from low to
+        high.
+
+    Returns
+    -------
+    out : ndarray
+        Array representing the result of the multiplication.
+
+    See Also
+    --------
+    hermadd, hermsub, hermmul, hermdiv, hermpow
+
+    Notes
+    -----
+    The multiplication uses the recursion relationship for Hermite
+    polynomials in the form
+
+    .. math::
+
+        xP_i(x) = (P_{i + 1}(x)/2 + i*P_{i - 1}(x))
+
+    Examples
+    --------
+    >>> from numpy.polynomial.hermite import hermmulx
+    >>> hermmulx([1, 2, 3])
+    array([2. , 6.5, 1. , 1.5])
+
+    """
+    # c is a trimmed copy
+    [c] = pu.as_series([c])
+    # The zero series needs special treatment
+    if len(c) == 1 and c[0] == 0:
+        return c
+
+    prd = np.empty(len(c) + 1, dtype=c.dtype)
+    prd[0] = c[0]*0
+    prd[1] = c[0]/2
+    for i in range(1, len(c)):
+        prd[i + 1] = c[i]/2
+        prd[i - 1] += c[i]*i
+    return prd
+
+
+def hermmul(c1, c2):
+    """
+    Multiply one Hermite series by another.
+
+    Returns the product of two Hermite series `c1` * `c2`.  The arguments
+    are sequences of coefficients, from lowest order "term" to highest,
+    e.g., [1,2,3] represents the series ``P_0 + 2*P_1 + 3*P_2``.
+
+    Parameters
+    ----------
+    c1, c2 : array_like
+        1-D arrays of Hermite series coefficients ordered from low to
+        high.
+
+    Returns
+    -------
+    out : ndarray
+        Of Hermite series coefficients representing their product.
+
+    See Also
+    --------
+    hermadd, hermsub, hermmulx, hermdiv, hermpow
+
+    Notes
+    -----
+    In general, the (polynomial) product of two C-series results in terms
+    that are not in the Hermite polynomial basis set.  Thus, to express
+    the product as a Hermite series, it is necessary to "reproject" the
+    product onto said basis set, which may produce "unintuitive" (but
+    correct) results; see Examples section below.
+
+    Examples
+    --------
+    >>> from numpy.polynomial.hermite import hermmul
+    >>> hermmul([1, 2, 3], [0, 1, 2])
+    array([52.,  29.,  52.,   7.,   6.])
+
+    """
+    # s1, s2 are trimmed copies
+    [c1, c2] = pu.as_series([c1, c2])
+
+    if len(c1) > len(c2):
+        c = c2
+        xs = c1
+    else:
+        c = c1
+        xs = c2
+
+    if len(c) == 1:
+        c0 = c[0]*xs
+        c1 = 0
+    elif len(c) == 2:
+        c0 = c[0]*xs
+        c1 = c[1]*xs
+    else:
+        nd = len(c)
+        c0 = c[-2]*xs
+        c1 = c[-1]*xs
+        for i in range(3, len(c) + 1):
+            tmp = c0
+            nd = nd - 1
+            c0 = hermsub(c[-i]*xs, c1*(2*(nd - 1)))
+            c1 = hermadd(tmp, hermmulx(c1)*2)
+    return hermadd(c0, hermmulx(c1)*2)
+
+
+def hermdiv(c1, c2):
+    """
+    Divide one Hermite series by another.
+
+    Returns the quotient-with-remainder of two Hermite series
+    `c1` / `c2`.  The arguments are sequences of coefficients from lowest
+    order "term" to highest, e.g., [1,2,3] represents the series
+    ``P_0 + 2*P_1 + 3*P_2``.
+
+    Parameters
+    ----------
+    c1, c2 : array_like
+        1-D arrays of Hermite series coefficients ordered from low to
+        high.
+
+    Returns
+    -------
+    [quo, rem] : ndarrays
+        Of Hermite series coefficients representing the quotient and
+        remainder.
+
+    See Also
+    --------
+    hermadd, hermsub, hermmulx, hermmul, hermpow
+
+    Notes
+    -----
+    In general, the (polynomial) division of one Hermite series by another
+    results in quotient and remainder terms that are not in the Hermite
+    polynomial basis set.  Thus, to express these results as a Hermite
+    series, it is necessary to "reproject" the results onto the Hermite
+    basis set, which may produce "unintuitive" (but correct) results; see
+    Examples section below.
+
+    Examples
+    --------
+    >>> from numpy.polynomial.hermite import hermdiv
+    >>> hermdiv([ 52.,  29.,  52.,   7.,   6.], [0, 1, 2])
+    (array([1., 2., 3.]), array([0.]))
+    >>> hermdiv([ 54.,  31.,  52.,   7.,   6.], [0, 1, 2])
+    (array([1., 2., 3.]), array([2., 2.]))
+    >>> hermdiv([ 53.,  30.,  52.,   7.,   6.], [0, 1, 2])
+    (array([1., 2., 3.]), array([1., 1.]))
+
+    """
+    return pu._div(hermmul, c1, c2)
+
+
+def hermpow(c, pow, maxpower=16):
+    """Raise a Hermite series to a power.
+
+    Returns the Hermite series `c` raised to the power `pow`. The
+    argument `c` is a sequence of coefficients ordered from low to high.
+    i.e., [1,2,3] is the series  ``P_0 + 2*P_1 + 3*P_2.``
+
+    Parameters
+    ----------
+    c : array_like
+        1-D array of Hermite series coefficients ordered from low to
+        high.
+    pow : integer
+        Power to which the series will be raised
+    maxpower : integer, optional
+        Maximum power allowed. This is mainly to limit growth of the series
+        to unmanageable size. Default is 16
+
+    Returns
+    -------
+    coef : ndarray
+        Hermite series of power.
+
+    See Also
+    --------
+    hermadd, hermsub, hermmulx, hermmul, hermdiv
+
+    Examples
+    --------
+    >>> from numpy.polynomial.hermite import hermpow
+    >>> hermpow([1, 2, 3], 2)
+    array([81.,  52.,  82.,  12.,   9.])
+
+    """
+    return pu._pow(hermmul, c, pow, maxpower)
+
+
+def hermder(c, m=1, scl=1, axis=0):
+    """
+    Differentiate a Hermite series.
+
+    Returns the Hermite series coefficients `c` differentiated `m` times
+    along `axis`.  At each iteration the result is multiplied by `scl` (the
+    scaling factor is for use in a linear change of variable). The argument
+    `c` is an array of coefficients from low to high degree along each
+    axis, e.g., [1,2,3] represents the series ``1*H_0 + 2*H_1 + 3*H_2``
+    while [[1,2],[1,2]] represents ``1*H_0(x)*H_0(y) + 1*H_1(x)*H_0(y) +
+    2*H_0(x)*H_1(y) + 2*H_1(x)*H_1(y)`` if axis=0 is ``x`` and axis=1 is
+    ``y``.
+
+    Parameters
+    ----------
+    c : array_like
+        Array of Hermite series coefficients. If `c` is multidimensional the
+        different axis correspond to different variables with the degree in
+        each axis given by the corresponding index.
+    m : int, optional
+        Number of derivatives taken, must be non-negative. (Default: 1)
+    scl : scalar, optional
+        Each differentiation is multiplied by `scl`.  The end result is
+        multiplication by ``scl**m``.  This is for use in a linear change of
+        variable. (Default: 1)
+    axis : int, optional
+        Axis over which the derivative is taken. (Default: 0).
+
+        .. versionadded:: 1.7.0
+
+    Returns
+    -------
+    der : ndarray
+        Hermite series of the derivative.
+
+    See Also
+    --------
+    hermint
+
+    Notes
+    -----
+    In general, the result of differentiating a Hermite series does not
+    resemble the same operation on a power series. Thus the result of this
+    function may be "unintuitive," albeit correct; see Examples section
+    below.
+
+    Examples
+    --------
+    >>> from numpy.polynomial.hermite import hermder
+    >>> hermder([ 1. ,  0.5,  0.5,  0.5])
+    array([1., 2., 3.])
+    >>> hermder([-0.5,  1./2.,  1./8.,  1./12.,  1./16.], m=2)
+    array([1., 2., 3.])
+
+    """
+    c = np.array(c, ndmin=1, copy=True)
+    if c.dtype.char in '?bBhHiIlLqQpP':
+        c = c.astype(np.double)
+    cnt = pu._as_int(m, "the order of derivation")
+    iaxis = pu._as_int(axis, "the axis")
+    if cnt < 0:
+        raise ValueError("The order of derivation must be non-negative")
+    iaxis = normalize_axis_index(iaxis, c.ndim)
+
+    if cnt == 0:
+        return c
+
+    c = np.moveaxis(c, iaxis, 0)
+    n = len(c)
+    if cnt >= n:
+        c = c[:1]*0
+    else:
+        for i in range(cnt):
+            n = n - 1
+            c *= scl
+            der = np.empty((n,) + c.shape[1:], dtype=c.dtype)
+            for j in range(n, 0, -1):
+                der[j - 1] = (2*j)*c[j]
+            c = der
+    c = np.moveaxis(c, 0, iaxis)
+    return c
+
+
+def hermint(c, m=1, k=[], lbnd=0, scl=1, axis=0):
+    """
+    Integrate a Hermite series.
+
+    Returns the Hermite series coefficients `c` integrated `m` times from
+    `lbnd` along `axis`. At each iteration the resulting series is
+    **multiplied** by `scl` and an integration constant, `k`, is added.
+    The scaling factor is for use in a linear change of variable.  ("Buyer
+    beware": note that, depending on what one is doing, one may want `scl`
+    to be the reciprocal of what one might expect; for more information,
+    see the Notes section below.)  The argument `c` is an array of
+    coefficients from low to high degree along each axis, e.g., [1,2,3]
+    represents the series ``H_0 + 2*H_1 + 3*H_2`` while [[1,2],[1,2]]
+    represents ``1*H_0(x)*H_0(y) + 1*H_1(x)*H_0(y) + 2*H_0(x)*H_1(y) +
+    2*H_1(x)*H_1(y)`` if axis=0 is ``x`` and axis=1 is ``y``.
+
+    Parameters
+    ----------
+    c : array_like
+        Array of Hermite series coefficients. If c is multidimensional the
+        different axis correspond to different variables with the degree in
+        each axis given by the corresponding index.
+    m : int, optional
+        Order of integration, must be positive. (Default: 1)
+    k : {[], list, scalar}, optional
+        Integration constant(s).  The value of the first integral at
+        ``lbnd`` is the first value in the list, the value of the second
+        integral at ``lbnd`` is the second value, etc.  If ``k == []`` (the
+        default), all constants are set to zero.  If ``m == 1``, a single
+        scalar can be given instead of a list.
+    lbnd : scalar, optional
+        The lower bound of the integral. (Default: 0)
+    scl : scalar, optional
+        Following each integration the result is *multiplied* by `scl`
+        before the integration constant is added. (Default: 1)
+    axis : int, optional
+        Axis over which the integral is taken. (Default: 0).
+
+        .. versionadded:: 1.7.0
+
+    Returns
+    -------
+    S : ndarray
+        Hermite series coefficients of the integral.
+
+    Raises
+    ------
+    ValueError
+        If ``m < 0``, ``len(k) > m``, ``np.ndim(lbnd) != 0``, or
+        ``np.ndim(scl) != 0``.
+
+    See Also
+    --------
+    hermder
+
+    Notes
+    -----
+    Note that the result of each integration is *multiplied* by `scl`.
+    Why is this important to note?  Say one is making a linear change of
+    variable :math:`u = ax + b` in an integral relative to `x`.  Then
+    :math:`dx = du/a`, so one will need to set `scl` equal to
+    :math:`1/a` - perhaps not what one would have first thought.
+
+    Also note that, in general, the result of integrating a C-series needs
+    to be "reprojected" onto the C-series basis set.  Thus, typically,
+    the result of this function is "unintuitive," albeit correct; see
+    Examples section below.
+
+    Examples
+    --------
+    >>> from numpy.polynomial.hermite import hermint
+    >>> hermint([1,2,3]) # integrate once, value 0 at 0.
+    array([1. , 0.5, 0.5, 0.5])
+    >>> hermint([1,2,3], m=2) # integrate twice, value & deriv 0 at 0
+    array([-0.5       ,  0.5       ,  0.125     ,  0.08333333,  0.0625    ]) # may vary
+    >>> hermint([1,2,3], k=1) # integrate once, value 1 at 0.
+    array([2. , 0.5, 0.5, 0.5])
+    >>> hermint([1,2,3], lbnd=-1) # integrate once, value 0 at -1
+    array([-2. ,  0.5,  0.5,  0.5])
+    >>> hermint([1,2,3], m=2, k=[1,2], lbnd=-1)
+    array([ 1.66666667, -0.5       ,  0.125     ,  0.08333333,  0.0625    ]) # may vary
+
+    """
+    c = np.array(c, ndmin=1, copy=True)
+    if c.dtype.char in '?bBhHiIlLqQpP':
+        c = c.astype(np.double)
+    if not np.iterable(k):
+        k = [k]
+    cnt = pu._as_int(m, "the order of integration")
+    iaxis = pu._as_int(axis, "the axis")
+    if cnt < 0:
+        raise ValueError("The order of integration must be non-negative")
+    if len(k) > cnt:
+        raise ValueError("Too many integration constants")
+    if np.ndim(lbnd) != 0:
+        raise ValueError("lbnd must be a scalar.")
+    if np.ndim(scl) != 0:
+        raise ValueError("scl must be a scalar.")
+    iaxis = normalize_axis_index(iaxis, c.ndim)
+
+    if cnt == 0:
+        return c
+
+    c = np.moveaxis(c, iaxis, 0)
+    k = list(k) + [0]*(cnt - len(k))
+    for i in range(cnt):
+        n = len(c)
+        c *= scl
+        if n == 1 and np.all(c[0] == 0):
+            c[0] += k[i]
+        else:
+            tmp = np.empty((n + 1,) + c.shape[1:], dtype=c.dtype)
+            tmp[0] = c[0]*0
+            tmp[1] = c[0]/2
+            for j in range(1, n):
+                tmp[j + 1] = c[j]/(2*(j + 1))
+            tmp[0] += k[i] - hermval(lbnd, tmp)
+            c = tmp
+    c = np.moveaxis(c, 0, iaxis)
+    return c
+
+
+def hermval(x, c, tensor=True):
+    """
+    Evaluate an Hermite series at points x.
+
+    If `c` is of length ``n + 1``, this function returns the value:
+
+    .. math:: p(x) = c_0 * H_0(x) + c_1 * H_1(x) + ... + c_n * H_n(x)
+
+    The parameter `x` is converted to an array only if it is a tuple or a
+    list, otherwise it is treated as a scalar. In either case, either `x`
+    or its elements must support multiplication and addition both with
+    themselves and with the elements of `c`.
+
+    If `c` is a 1-D array, then ``p(x)`` will have the same shape as `x`.  If
+    `c` is multidimensional, then the shape of the result depends on the
+    value of `tensor`. If `tensor` is true the shape will be c.shape[1:] +
+    x.shape. If `tensor` is false the shape will be c.shape[1:]. Note that
+    scalars have shape (,).
+
+    Trailing zeros in the coefficients will be used in the evaluation, so
+    they should be avoided if efficiency is a concern.
+
+    Parameters
+    ----------
+    x : array_like, compatible object
+        If `x` is a list or tuple, it is converted to an ndarray, otherwise
+        it is left unchanged and treated as a scalar. In either case, `x`
+        or its elements must support addition and multiplication with
+        themselves and with the elements of `c`.
+    c : array_like
+        Array of coefficients ordered so that the coefficients for terms of
+        degree n are contained in c[n]. If `c` is multidimensional the
+        remaining indices enumerate multiple polynomials. In the two
+        dimensional case the coefficients may be thought of as stored in
+        the columns of `c`.
+    tensor : boolean, optional
+        If True, the shape of the coefficient array is extended with ones
+        on the right, one for each dimension of `x`. Scalars have dimension 0
+        for this action. The result is that every column of coefficients in
+        `c` is evaluated for every element of `x`. If False, `x` is broadcast
+        over the columns of `c` for the evaluation.  This keyword is useful
+        when `c` is multidimensional. The default value is True.
+
+        .. versionadded:: 1.7.0
+
+    Returns
+    -------
+    values : ndarray, algebra_like
+        The shape of the return value is described above.
+
+    See Also
+    --------
+    hermval2d, hermgrid2d, hermval3d, hermgrid3d
+
+    Notes
+    -----
+    The evaluation uses Clenshaw recursion, aka synthetic division.
+
+    Examples
+    --------
+    >>> from numpy.polynomial.hermite import hermval
+    >>> coef = [1,2,3]
+    >>> hermval(1, coef)
+    11.0
+    >>> hermval([[1,2],[3,4]], coef)
+    array([[ 11.,   51.],
+           [115.,  203.]])
+
+    """
+    c = np.array(c, ndmin=1, copy=None)
+    if c.dtype.char in '?bBhHiIlLqQpP':
+        c = c.astype(np.double)
+    if isinstance(x, (tuple, list)):
+        x = np.asarray(x)
+    if isinstance(x, np.ndarray) and tensor:
+        c = c.reshape(c.shape + (1,)*x.ndim)
+
+    x2 = x*2
+    if len(c) == 1:
+        c0 = c[0]
+        c1 = 0
+    elif len(c) == 2:
+        c0 = c[0]
+        c1 = c[1]
+    else:
+        nd = len(c)
+        c0 = c[-2]
+        c1 = c[-1]
+        for i in range(3, len(c) + 1):
+            tmp = c0
+            nd = nd - 1
+            c0 = c[-i] - c1*(2*(nd - 1))
+            c1 = tmp + c1*x2
+    return c0 + c1*x2
+
+
+def hermval2d(x, y, c):
+    """
+    Evaluate a 2-D Hermite series at points (x, y).
+
+    This function returns the values:
+
+    .. math:: p(x,y) = \\sum_{i,j} c_{i,j} * H_i(x) * H_j(y)
+
+    The parameters `x` and `y` are converted to arrays only if they are
+    tuples or a lists, otherwise they are treated as a scalars and they
+    must have the same shape after conversion. In either case, either `x`
+    and `y` or their elements must support multiplication and addition both
+    with themselves and with the elements of `c`.
+
+    If `c` is a 1-D array a one is implicitly appended to its shape to make
+    it 2-D. The shape of the result will be c.shape[2:] + x.shape.
+
+    Parameters
+    ----------
+    x, y : array_like, compatible objects
+        The two dimensional series is evaluated at the points ``(x, y)``,
+        where `x` and `y` must have the same shape. If `x` or `y` is a list
+        or tuple, it is first converted to an ndarray, otherwise it is left
+        unchanged and if it isn't an ndarray it is treated as a scalar.
+    c : array_like
+        Array of coefficients ordered so that the coefficient of the term
+        of multi-degree i,j is contained in ``c[i,j]``. If `c` has
+        dimension greater than two the remaining indices enumerate multiple
+        sets of coefficients.
+
+    Returns
+    -------
+    values : ndarray, compatible object
+        The values of the two dimensional polynomial at points formed with
+        pairs of corresponding values from `x` and `y`.
+
+    See Also
+    --------
+    hermval, hermgrid2d, hermval3d, hermgrid3d
+
+    Notes
+    -----
+
+    .. versionadded:: 1.7.0
+
+    Examples
+    --------
+    >>> from numpy.polynomial.hermite import hermval2d
+    >>> x = [1, 2]
+    >>> y = [4, 5]
+    >>> c = [[1, 2, 3], [4, 5, 6]]
+    >>> hermval2d(x, y, c)
+    array([1035., 2883.])
+
+    """
+    return pu._valnd(hermval, c, x, y)
+
+
+def hermgrid2d(x, y, c):
+    """
+    Evaluate a 2-D Hermite series on the Cartesian product of x and y.
+
+    This function returns the values:
+
+    .. math:: p(a,b) = \\sum_{i,j} c_{i,j} * H_i(a) * H_j(b)
+
+    where the points ``(a, b)`` consist of all pairs formed by taking
+    `a` from `x` and `b` from `y`. The resulting points form a grid with
+    `x` in the first dimension and `y` in the second.
+
+    The parameters `x` and `y` are converted to arrays only if they are
+    tuples or a lists, otherwise they are treated as a scalars. In either
+    case, either `x` and `y` or their elements must support multiplication
+    and addition both with themselves and with the elements of `c`.
+
+    If `c` has fewer than two dimensions, ones are implicitly appended to
+    its shape to make it 2-D. The shape of the result will be c.shape[2:] +
+    x.shape.
+
+    Parameters
+    ----------
+    x, y : array_like, compatible objects
+        The two dimensional series is evaluated at the points in the
+        Cartesian product of `x` and `y`.  If `x` or `y` is a list or
+        tuple, it is first converted to an ndarray, otherwise it is left
+        unchanged and, if it isn't an ndarray, it is treated as a scalar.
+    c : array_like
+        Array of coefficients ordered so that the coefficients for terms of
+        degree i,j are contained in ``c[i,j]``. If `c` has dimension
+        greater than two the remaining indices enumerate multiple sets of
+        coefficients.
+
+    Returns
+    -------
+    values : ndarray, compatible object
+        The values of the two dimensional polynomial at points in the Cartesian
+        product of `x` and `y`.
+
+    See Also
+    --------
+    hermval, hermval2d, hermval3d, hermgrid3d
+
+    Notes
+    -----
+
+    .. versionadded:: 1.7.0
+
+    Examples
+    --------
+    >>> from numpy.polynomial.hermite import hermgrid2d
+    >>> x = [1, 2, 3]
+    >>> y = [4, 5]
+    >>> c = [[1, 2, 3], [4, 5, 6]]
+    >>> hermgrid2d(x, y, c)
+    array([[1035., 1599.],
+           [1867., 2883.],
+           [2699., 4167.]])
+
+    """
+    return pu._gridnd(hermval, c, x, y)
+
+
+def hermval3d(x, y, z, c):
+    """
+    Evaluate a 3-D Hermite series at points (x, y, z).
+
+    This function returns the values:
+
+    .. math:: p(x,y,z) = \\sum_{i,j,k} c_{i,j,k} * H_i(x) * H_j(y) * H_k(z)
+
+    The parameters `x`, `y`, and `z` are converted to arrays only if
+    they are tuples or a lists, otherwise they are treated as a scalars and
+    they must have the same shape after conversion. In either case, either
+    `x`, `y`, and `z` or their elements must support multiplication and
+    addition both with themselves and with the elements of `c`.
+
+    If `c` has fewer than 3 dimensions, ones are implicitly appended to its
+    shape to make it 3-D. The shape of the result will be c.shape[3:] +
+    x.shape.
+
+    Parameters
+    ----------
+    x, y, z : array_like, compatible object
+        The three dimensional series is evaluated at the points
+        ``(x, y, z)``, where `x`, `y`, and `z` must have the same shape.  If
+        any of `x`, `y`, or `z` is a list or tuple, it is first converted
+        to an ndarray, otherwise it is left unchanged and if it isn't an
+        ndarray it is  treated as a scalar.
+    c : array_like
+        Array of coefficients ordered so that the coefficient of the term of
+        multi-degree i,j,k is contained in ``c[i,j,k]``. If `c` has dimension
+        greater than 3 the remaining indices enumerate multiple sets of
+        coefficients.
+
+    Returns
+    -------
+    values : ndarray, compatible object
+        The values of the multidimensional polynomial on points formed with
+        triples of corresponding values from `x`, `y`, and `z`.
+
+    See Also
+    --------
+    hermval, hermval2d, hermgrid2d, hermgrid3d
+
+    Notes
+    -----
+
+    .. versionadded:: 1.7.0
+
+    Examples
+    --------
+    >>> from numpy.polynomial.hermite import hermval3d
+    >>> x = [1, 2]
+    >>> y = [4, 5]
+    >>> z = [6, 7]
+    >>> c = [[[1, 2, 3], [4, 5, 6]], [[7, 8, 9], [10, 11, 12]]]
+    >>> hermval3d(x, y, z, c)
+    array([ 40077., 120131.])
+
+    """
+    return pu._valnd(hermval, c, x, y, z)
+
+
+def hermgrid3d(x, y, z, c):
+    """
+    Evaluate a 3-D Hermite series on the Cartesian product of x, y, and z.
+
+    This function returns the values:
+
+    .. math:: p(a,b,c) = \\sum_{i,j,k} c_{i,j,k} * H_i(a) * H_j(b) * H_k(c)
+
+    where the points ``(a, b, c)`` consist of all triples formed by taking
+    `a` from `x`, `b` from `y`, and `c` from `z`. The resulting points form
+    a grid with `x` in the first dimension, `y` in the second, and `z` in
+    the third.
+
+    The parameters `x`, `y`, and `z` are converted to arrays only if they
+    are tuples or a lists, otherwise they are treated as a scalars. In
+    either case, either `x`, `y`, and `z` or their elements must support
+    multiplication and addition both with themselves and with the elements
+    of `c`.
+
+    If `c` has fewer than three dimensions, ones are implicitly appended to
+    its shape to make it 3-D. The shape of the result will be c.shape[3:] +
+    x.shape + y.shape + z.shape.
+
+    Parameters
+    ----------
+    x, y, z : array_like, compatible objects
+        The three dimensional series is evaluated at the points in the
+        Cartesian product of `x`, `y`, and `z`.  If `x`, `y`, or `z` is a
+        list or tuple, it is first converted to an ndarray, otherwise it is
+        left unchanged and, if it isn't an ndarray, it is treated as a
+        scalar.
+    c : array_like
+        Array of coefficients ordered so that the coefficients for terms of
+        degree i,j are contained in ``c[i,j]``. If `c` has dimension
+        greater than two the remaining indices enumerate multiple sets of
+        coefficients.
+
+    Returns
+    -------
+    values : ndarray, compatible object
+        The values of the two dimensional polynomial at points in the Cartesian
+        product of `x` and `y`.
+
+    See Also
+    --------
+    hermval, hermval2d, hermgrid2d, hermval3d
+
+    Notes
+    -----
+
+    .. versionadded:: 1.7.0
+
+    Examples
+    --------
+    >>> from numpy.polynomial.hermite import hermgrid3d
+    >>> x = [1, 2]
+    >>> y = [4, 5]
+    >>> z = [6, 7]
+    >>> c = [[[1, 2, 3], [4, 5, 6]], [[7, 8, 9], [10, 11, 12]]]
+    >>> hermgrid3d(x, y, z, c)
+    array([[[ 40077.,  54117.],
+            [ 49293.,  66561.]],
+           [[ 72375.,  97719.],
+            [ 88975., 120131.]]])
+
+    """
+    return pu._gridnd(hermval, c, x, y, z)
+
+
+def hermvander(x, deg):
+    """Pseudo-Vandermonde matrix of given degree.
+
+    Returns the pseudo-Vandermonde matrix of degree `deg` and sample points
+    `x`. The pseudo-Vandermonde matrix is defined by
+
+    .. math:: V[..., i] = H_i(x),
+
+    where ``0 <= i <= deg``. The leading indices of `V` index the elements of
+    `x` and the last index is the degree of the Hermite polynomial.
+
+    If `c` is a 1-D array of coefficients of length ``n + 1`` and `V` is the
+    array ``V = hermvander(x, n)``, then ``np.dot(V, c)`` and
+    ``hermval(x, c)`` are the same up to roundoff. This equivalence is
+    useful both for least squares fitting and for the evaluation of a large
+    number of Hermite series of the same degree and sample points.
+
+    Parameters
+    ----------
+    x : array_like
+        Array of points. The dtype is converted to float64 or complex128
+        depending on whether any of the elements are complex. If `x` is
+        scalar it is converted to a 1-D array.
+    deg : int
+        Degree of the resulting matrix.
+
+    Returns
+    -------
+    vander : ndarray
+        The pseudo-Vandermonde matrix. The shape of the returned matrix is
+        ``x.shape + (deg + 1,)``, where The last index is the degree of the
+        corresponding Hermite polynomial.  The dtype will be the same as
+        the converted `x`.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from numpy.polynomial.hermite import hermvander
+    >>> x = np.array([-1, 0, 1])
+    >>> hermvander(x, 3)
+    array([[ 1., -2.,  2.,  4.],
+           [ 1.,  0., -2., -0.],
+           [ 1.,  2.,  2., -4.]])
+
+    """
+    ideg = pu._as_int(deg, "deg")
+    if ideg < 0:
+        raise ValueError("deg must be non-negative")
+
+    x = np.array(x, copy=None, ndmin=1) + 0.0
+    dims = (ideg + 1,) + x.shape
+    dtyp = x.dtype
+    v = np.empty(dims, dtype=dtyp)
+    v[0] = x*0 + 1
+    if ideg > 0:
+        x2 = x*2
+        v[1] = x2
+        for i in range(2, ideg + 1):
+            v[i] = (v[i-1]*x2 - v[i-2]*(2*(i - 1)))
+    return np.moveaxis(v, 0, -1)
+
+
+def hermvander2d(x, y, deg):
+    """Pseudo-Vandermonde matrix of given degrees.
+
+    Returns the pseudo-Vandermonde matrix of degrees `deg` and sample
+    points ``(x, y)``. The pseudo-Vandermonde matrix is defined by
+
+    .. math:: V[..., (deg[1] + 1)*i + j] = H_i(x) * H_j(y),
+
+    where ``0 <= i <= deg[0]`` and ``0 <= j <= deg[1]``. The leading indices of
+    `V` index the points ``(x, y)`` and the last index encodes the degrees of
+    the Hermite polynomials.
+
+    If ``V = hermvander2d(x, y, [xdeg, ydeg])``, then the columns of `V`
+    correspond to the elements of a 2-D coefficient array `c` of shape
+    (xdeg + 1, ydeg + 1) in the order
+
+    .. math:: c_{00}, c_{01}, c_{02} ... , c_{10}, c_{11}, c_{12} ...
+
+    and ``np.dot(V, c.flat)`` and ``hermval2d(x, y, c)`` will be the same
+    up to roundoff. This equivalence is useful both for least squares
+    fitting and for the evaluation of a large number of 2-D Hermite
+    series of the same degrees and sample points.
+
+    Parameters
+    ----------
+    x, y : array_like
+        Arrays of point coordinates, all of the same shape. The dtypes
+        will be converted to either float64 or complex128 depending on
+        whether any of the elements are complex. Scalars are converted to 1-D
+        arrays.
+    deg : list of ints
+        List of maximum degrees of the form [x_deg, y_deg].
+
+    Returns
+    -------
+    vander2d : ndarray
+        The shape of the returned matrix is ``x.shape + (order,)``, where
+        :math:`order = (deg[0]+1)*(deg[1]+1)`.  The dtype will be the same
+        as the converted `x` and `y`.
+
+    See Also
+    --------
+    hermvander, hermvander3d, hermval2d, hermval3d
+
+    Notes
+    -----
+
+    .. versionadded:: 1.7.0
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from numpy.polynomial.hermite import hermvander2d
+    >>> x = np.array([-1, 0, 1])
+    >>> y = np.array([-1, 0, 1])
+    >>> hermvander2d(x, y, [2, 2])
+    array([[ 1., -2.,  2., -2.,  4., -4.,  2., -4.,  4.],
+           [ 1.,  0., -2.,  0.,  0., -0., -2., -0.,  4.],
+           [ 1.,  2.,  2.,  2.,  4.,  4.,  2.,  4.,  4.]])
+
+    """
+    return pu._vander_nd_flat((hermvander, hermvander), (x, y), deg)
+
+
+def hermvander3d(x, y, z, deg):
+    """Pseudo-Vandermonde matrix of given degrees.
+
+    Returns the pseudo-Vandermonde matrix of degrees `deg` and sample
+    points ``(x, y, z)``. If `l`, `m`, `n` are the given degrees in `x`, `y`, `z`,
+    then The pseudo-Vandermonde matrix is defined by
+
+    .. math:: V[..., (m+1)(n+1)i + (n+1)j + k] = H_i(x)*H_j(y)*H_k(z),
+
+    where ``0 <= i <= l``, ``0 <= j <= m``, and ``0 <= j <= n``.  The leading
+    indices of `V` index the points ``(x, y, z)`` and the last index encodes
+    the degrees of the Hermite polynomials.
+
+    If ``V = hermvander3d(x, y, z, [xdeg, ydeg, zdeg])``, then the columns
+    of `V` correspond to the elements of a 3-D coefficient array `c` of
+    shape (xdeg + 1, ydeg + 1, zdeg + 1) in the order
+
+    .. math:: c_{000}, c_{001}, c_{002},... , c_{010}, c_{011}, c_{012},...
+
+    and  ``np.dot(V, c.flat)`` and ``hermval3d(x, y, z, c)`` will be the
+    same up to roundoff. This equivalence is useful both for least squares
+    fitting and for the evaluation of a large number of 3-D Hermite
+    series of the same degrees and sample points.
+
+    Parameters
+    ----------
+    x, y, z : array_like
+        Arrays of point coordinates, all of the same shape. The dtypes will
+        be converted to either float64 or complex128 depending on whether
+        any of the elements are complex. Scalars are converted to 1-D
+        arrays.
+    deg : list of ints
+        List of maximum degrees of the form [x_deg, y_deg, z_deg].
+
+    Returns
+    -------
+    vander3d : ndarray
+        The shape of the returned matrix is ``x.shape + (order,)``, where
+        :math:`order = (deg[0]+1)*(deg[1]+1)*(deg[2]+1)`.  The dtype will
+        be the same as the converted `x`, `y`, and `z`.
+
+    See Also
+    --------
+    hermvander, hermvander3d, hermval2d, hermval3d
+
+    Notes
+    -----
+
+    .. versionadded:: 1.7.0
+
+    Examples
+    --------
+    >>> from numpy.polynomial.hermite import hermvander3d
+    >>> x = np.array([-1, 0, 1])
+    >>> y = np.array([-1, 0, 1])
+    >>> z = np.array([-1, 0, 1])
+    >>> hermvander3d(x, y, z, [0, 1, 2])
+    array([[ 1., -2.,  2., -2.,  4., -4.],
+           [ 1.,  0., -2.,  0.,  0., -0.],
+           [ 1.,  2.,  2.,  2.,  4.,  4.]])
+
+    """
+    return pu._vander_nd_flat((hermvander, hermvander, hermvander), (x, y, z), deg)
+
+
+def hermfit(x, y, deg, rcond=None, full=False, w=None):
+    """
+    Least squares fit of Hermite series to data.
+
+    Return the coefficients of a Hermite series of degree `deg` that is the
+    least squares fit to the data values `y` given at points `x`. If `y` is
+    1-D the returned coefficients will also be 1-D. If `y` is 2-D multiple
+    fits are done, one for each column of `y`, and the resulting
+    coefficients are stored in the corresponding columns of a 2-D return.
+    The fitted polynomial(s) are in the form
+
+    .. math::  p(x) = c_0 + c_1 * H_1(x) + ... + c_n * H_n(x),
+
+    where `n` is `deg`.
+
+    Parameters
+    ----------
+    x : array_like, shape (M,)
+        x-coordinates of the M sample points ``(x[i], y[i])``.
+    y : array_like, shape (M,) or (M, K)
+        y-coordinates of the sample points. Several data sets of sample
+        points sharing the same x-coordinates can be fitted at once by
+        passing in a 2D-array that contains one dataset per column.
+    deg : int or 1-D array_like
+        Degree(s) of the fitting polynomials. If `deg` is a single integer
+        all terms up to and including the `deg`'th term are included in the
+        fit. For NumPy versions >= 1.11.0 a list of integers specifying the
+        degrees of the terms to include may be used instead.
+    rcond : float, optional
+        Relative condition number of the fit. Singular values smaller than
+        this relative to the largest singular value will be ignored. The
+        default value is len(x)*eps, where eps is the relative precision of
+        the float type, about 2e-16 in most cases.
+    full : bool, optional
+        Switch determining nature of return value. When it is False (the
+        default) just the coefficients are returned, when True diagnostic
+        information from the singular value decomposition is also returned.
+    w : array_like, shape (`M`,), optional
+        Weights. If not None, the weight ``w[i]`` applies to the unsquared
+        residual ``y[i] - y_hat[i]`` at ``x[i]``. Ideally the weights are
+        chosen so that the errors of the products ``w[i]*y[i]`` all have the
+        same variance.  When using inverse-variance weighting, use
+        ``w[i] = 1/sigma(y[i])``.  The default value is None.
+
+    Returns
+    -------
+    coef : ndarray, shape (M,) or (M, K)
+        Hermite coefficients ordered from low to high. If `y` was 2-D,
+        the coefficients for the data in column k  of `y` are in column
+        `k`.
+
+    [residuals, rank, singular_values, rcond] : list
+        These values are only returned if ``full == True``
+
+        - residuals -- sum of squared residuals of the least squares fit
+        - rank -- the numerical rank of the scaled Vandermonde matrix
+        - singular_values -- singular values of the scaled Vandermonde matrix
+        - rcond -- value of `rcond`.
+
+        For more details, see `numpy.linalg.lstsq`.
+
+    Warns
+    -----
+    RankWarning
+        The rank of the coefficient matrix in the least-squares fit is
+        deficient. The warning is only raised if ``full == False``.  The
+        warnings can be turned off by
+
+        >>> import warnings
+        >>> warnings.simplefilter('ignore', np.exceptions.RankWarning)
+
+    See Also
+    --------
+    numpy.polynomial.chebyshev.chebfit
+    numpy.polynomial.legendre.legfit
+    numpy.polynomial.laguerre.lagfit
+    numpy.polynomial.polynomial.polyfit
+    numpy.polynomial.hermite_e.hermefit
+    hermval : Evaluates a Hermite series.
+    hermvander : Vandermonde matrix of Hermite series.
+    hermweight : Hermite weight function
+    numpy.linalg.lstsq : Computes a least-squares fit from the matrix.
+    scipy.interpolate.UnivariateSpline : Computes spline fits.
+
+    Notes
+    -----
+    The solution is the coefficients of the Hermite series `p` that
+    minimizes the sum of the weighted squared errors
+
+    .. math:: E = \\sum_j w_j^2 * |y_j - p(x_j)|^2,
+
+    where the :math:`w_j` are the weights. This problem is solved by
+    setting up the (typically) overdetermined matrix equation
+
+    .. math:: V(x) * c = w * y,
+
+    where `V` is the weighted pseudo Vandermonde matrix of `x`, `c` are the
+    coefficients to be solved for, `w` are the weights, `y` are the
+    observed values.  This equation is then solved using the singular value
+    decomposition of `V`.
+
+    If some of the singular values of `V` are so small that they are
+    neglected, then a `~exceptions.RankWarning` will be issued. This means that
+    the coefficient values may be poorly determined. Using a lower order fit
+    will usually get rid of the warning.  The `rcond` parameter can also be
+    set to a value smaller than its default, but the resulting fit may be
+    spurious and have large contributions from roundoff error.
+
+    Fits using Hermite series are probably most useful when the data can be
+    approximated by ``sqrt(w(x)) * p(x)``, where ``w(x)`` is the Hermite
+    weight. In that case the weight ``sqrt(w(x[i]))`` should be used
+    together with data values ``y[i]/sqrt(w(x[i]))``. The weight function is
+    available as `hermweight`.
+
+    References
+    ----------
+    .. [1] Wikipedia, "Curve fitting",
+           https://en.wikipedia.org/wiki/Curve_fitting
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from numpy.polynomial.hermite import hermfit, hermval
+    >>> x = np.linspace(-10, 10)
+    >>> rng = np.random.default_rng()
+    >>> err = rng.normal(scale=1./10, size=len(x))
+    >>> y = hermval(x, [1, 2, 3]) + err
+    >>> hermfit(x, y, 2)
+    array([1.02294967, 2.00016403, 2.99994614]) # may vary
+
+    """
+    return pu._fit(hermvander, x, y, deg, rcond, full, w)
+
+
+def hermcompanion(c):
+    """Return the scaled companion matrix of c.
+
+    The basis polynomials are scaled so that the companion matrix is
+    symmetric when `c` is an Hermite basis polynomial. This provides
+    better eigenvalue estimates than the unscaled case and for basis
+    polynomials the eigenvalues are guaranteed to be real if
+    `numpy.linalg.eigvalsh` is used to obtain them.
+
+    Parameters
+    ----------
+    c : array_like
+        1-D array of Hermite series coefficients ordered from low to high
+        degree.
+
+    Returns
+    -------
+    mat : ndarray
+        Scaled companion matrix of dimensions (deg, deg).
+
+    Notes
+    -----
+
+    .. versionadded:: 1.7.0
+
+    Examples
+    --------
+    >>> from numpy.polynomial.hermite import hermcompanion
+    >>> hermcompanion([1, 0, 1])
+    array([[0.        , 0.35355339],
+           [0.70710678, 0.        ]])
+
+    """
+    # c is a trimmed copy
+    [c] = pu.as_series([c])
+    if len(c) < 2:
+        raise ValueError('Series must have maximum degree of at least 1.')
+    if len(c) == 2:
+        return np.array([[-.5*c[0]/c[1]]])
+
+    n = len(c) - 1
+    mat = np.zeros((n, n), dtype=c.dtype)
+    scl = np.hstack((1., 1./np.sqrt(2.*np.arange(n - 1, 0, -1))))
+    scl = np.multiply.accumulate(scl)[::-1]
+    top = mat.reshape(-1)[1::n+1]
+    bot = mat.reshape(-1)[n::n+1]
+    top[...] = np.sqrt(.5*np.arange(1, n))
+    bot[...] = top
+    mat[:, -1] -= scl*c[:-1]/(2.0*c[-1])
+    return mat
+
+
+def hermroots(c):
+    """
+    Compute the roots of a Hermite series.
+
+    Return the roots (a.k.a. "zeros") of the polynomial
+
+    .. math:: p(x) = \\sum_i c[i] * H_i(x).
+
+    Parameters
+    ----------
+    c : 1-D array_like
+        1-D array of coefficients.
+
+    Returns
+    -------
+    out : ndarray
+        Array of the roots of the series. If all the roots are real,
+        then `out` is also real, otherwise it is complex.
+
+    See Also
+    --------
+    numpy.polynomial.polynomial.polyroots
+    numpy.polynomial.legendre.legroots
+    numpy.polynomial.laguerre.lagroots
+    numpy.polynomial.chebyshev.chebroots
+    numpy.polynomial.hermite_e.hermeroots
+
+    Notes
+    -----
+    The root estimates are obtained as the eigenvalues of the companion
+    matrix, Roots far from the origin of the complex plane may have large
+    errors due to the numerical instability of the series for such
+    values. Roots with multiplicity greater than 1 will also show larger
+    errors as the value of the series near such points is relatively
+    insensitive to errors in the roots. Isolated roots near the origin can
+    be improved by a few iterations of Newton's method.
+
+    The Hermite series basis polynomials aren't powers of `x` so the
+    results of this function may seem unintuitive.
+
+    Examples
+    --------
+    >>> from numpy.polynomial.hermite import hermroots, hermfromroots
+    >>> coef = hermfromroots([-1, 0, 1])
+    >>> coef
+    array([0.   ,  0.25 ,  0.   ,  0.125])
+    >>> hermroots(coef)
+    array([-1.00000000e+00, -1.38777878e-17,  1.00000000e+00])
+
+    """
+    # c is a trimmed copy
+    [c] = pu.as_series([c])
+    if len(c) <= 1:
+        return np.array([], dtype=c.dtype)
+    if len(c) == 2:
+        return np.array([-.5*c[0]/c[1]])
+
+    # rotated companion matrix reduces error
+    m = hermcompanion(c)[::-1,::-1]
+    r = la.eigvals(m)
+    r.sort()
+    return r
+
+
+def _normed_hermite_n(x, n):
+    """
+    Evaluate a normalized Hermite polynomial.
+
+    Compute the value of the normalized Hermite polynomial of degree ``n``
+    at the points ``x``.
+
+
+    Parameters
+    ----------
+    x : ndarray of double.
+        Points at which to evaluate the function
+    n : int
+        Degree of the normalized Hermite function to be evaluated.
+
+    Returns
+    -------
+    values : ndarray
+        The shape of the return value is described above.
+
+    Notes
+    -----
+    .. versionadded:: 1.10.0
+
+    This function is needed for finding the Gauss points and integration
+    weights for high degrees. The values of the standard Hermite functions
+    overflow when n >= 207.
+
+    """
+    if n == 0:
+        return np.full(x.shape, 1/np.sqrt(np.sqrt(np.pi)))
+
+    c0 = 0.
+    c1 = 1./np.sqrt(np.sqrt(np.pi))
+    nd = float(n)
+    for i in range(n - 1):
+        tmp = c0
+        c0 = -c1*np.sqrt((nd - 1.)/nd)
+        c1 = tmp + c1*x*np.sqrt(2./nd)
+        nd = nd - 1.0
+    return c0 + c1*x*np.sqrt(2)
+
+
+def hermgauss(deg):
+    """
+    Gauss-Hermite quadrature.
+
+    Computes the sample points and weights for Gauss-Hermite quadrature.
+    These sample points and weights will correctly integrate polynomials of
+    degree :math:`2*deg - 1` or less over the interval :math:`[-\\inf, \\inf]`
+    with the weight function :math:`f(x) = \\exp(-x^2)`.
+
+    Parameters
+    ----------
+    deg : int
+        Number of sample points and weights. It must be >= 1.
+
+    Returns
+    -------
+    x : ndarray
+        1-D ndarray containing the sample points.
+    y : ndarray
+        1-D ndarray containing the weights.
+
+    Notes
+    -----
+
+    .. versionadded:: 1.7.0
+
+    The results have only been tested up to degree 100, higher degrees may
+    be problematic. The weights are determined by using the fact that
+
+    .. math:: w_k = c / (H'_n(x_k) * H_{n-1}(x_k))
+
+    where :math:`c` is a constant independent of :math:`k` and :math:`x_k`
+    is the k'th root of :math:`H_n`, and then scaling the results to get
+    the right value when integrating 1.
+
+    Examples
+    --------
+    >>> from numpy.polynomial.hermite import hermgauss
+    >>> hermgauss(2)
+    (array([-0.70710678,  0.70710678]), array([0.88622693, 0.88622693]))
+
+    """
+    ideg = pu._as_int(deg, "deg")
+    if ideg <= 0:
+        raise ValueError("deg must be a positive integer")
+
+    # first approximation of roots. We use the fact that the companion
+    # matrix is symmetric in this case in order to obtain better zeros.
+    c = np.array([0]*deg + [1], dtype=np.float64)
+    m = hermcompanion(c)
+    x = la.eigvalsh(m)
+
+    # improve roots by one application of Newton
+    dy = _normed_hermite_n(x, ideg)
+    df = _normed_hermite_n(x, ideg - 1) * np.sqrt(2*ideg)
+    x -= dy/df
+
+    # compute the weights. We scale the factor to avoid possible numerical
+    # overflow.
+    fm = _normed_hermite_n(x, ideg - 1)
+    fm /= np.abs(fm).max()
+    w = 1/(fm * fm)
+
+    # for Hermite we can also symmetrize
+    w = (w + w[::-1])/2
+    x = (x - x[::-1])/2
+
+    # scale w to get the right value
+    w *= np.sqrt(np.pi) / w.sum()
+
+    return x, w
+
+
+def hermweight(x):
+    """
+    Weight function of the Hermite polynomials.
+
+    The weight function is :math:`\\exp(-x^2)` and the interval of
+    integration is :math:`[-\\inf, \\inf]`. the Hermite polynomials are
+    orthogonal, but not normalized, with respect to this weight function.
+
+    Parameters
+    ----------
+    x : array_like
+       Values at which the weight function will be computed.
+
+    Returns
+    -------
+    w : ndarray
+       The weight function at `x`.
+
+    Notes
+    -----
+
+    .. versionadded:: 1.7.0
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from numpy.polynomial.hermite import hermweight
+    >>> x = np.arange(-2, 2)
+    >>> hermweight(x)
+    array([0.01831564, 0.36787944, 1.        , 0.36787944])
+
+    """
+    w = np.exp(-x**2)
+    return w
+
+
+#
+# Hermite series class
+#
+
+class Hermite(ABCPolyBase):
+    """An Hermite series class.
+
+    The Hermite class provides the standard Python numerical methods
+    '+', '-', '*', '//', '%', 'divmod', '**', and '()' as well as the
+    attributes and methods listed below.
+
+    Parameters
+    ----------
+    coef : array_like
+        Hermite coefficients in order of increasing degree, i.e,
+        ``(1, 2, 3)`` gives ``1*H_0(x) + 2*H_1(x) + 3*H_2(x)``.
+    domain : (2,) array_like, optional
+        Domain to use. The interval ``[domain[0], domain[1]]`` is mapped
+        to the interval ``[window[0], window[1]]`` by shifting and scaling.
+        The default value is [-1., 1.].
+    window : (2,) array_like, optional
+        Window, see `domain` for its use. The default value is [-1., 1.].
+
+        .. versionadded:: 1.6.0
+    symbol : str, optional
+        Symbol used to represent the independent variable in string
+        representations of the polynomial expression, e.g. for printing.
+        The symbol must be a valid Python identifier. Default value is 'x'.
+
+        .. versionadded:: 1.24
+
+    """
+    # Virtual Functions
+    _add = staticmethod(hermadd)
+    _sub = staticmethod(hermsub)
+    _mul = staticmethod(hermmul)
+    _div = staticmethod(hermdiv)
+    _pow = staticmethod(hermpow)
+    _val = staticmethod(hermval)
+    _int = staticmethod(hermint)
+    _der = staticmethod(hermder)
+    _fit = staticmethod(hermfit)
+    _line = staticmethod(hermline)
+    _roots = staticmethod(hermroots)
+    _fromroots = staticmethod(hermfromroots)
+
+    # Virtual properties
+    domain = np.array(hermdomain)
+    window = np.array(hermdomain)
+    basis_name = 'H'
diff --git a/venv/lib/python3.12/site-packages/numpy/polynomial/hermite.pyi b/venv/lib/python3.12/site-packages/numpy/polynomial/hermite.pyi
new file mode 100644
index 00000000..07db43d0
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/polynomial/hermite.pyi
@@ -0,0 +1,106 @@
+from typing import Any, Final, Literal as L, TypeVar
+
+import numpy as np
+
+from ._polybase import ABCPolyBase
+from ._polytypes import (
+    _Array1,
+    _Array2,
+    _FuncBinOp,
+    _FuncCompanion,
+    _FuncDer,
+    _FuncFit,
+    _FuncFromRoots,
+    _FuncGauss,
+    _FuncInteg,
+    _FuncLine,
+    _FuncPoly2Ortho,
+    _FuncPow,
+    _FuncRoots,
+    _FuncUnOp,
+    _FuncVal,
+    _FuncVal2D,
+    _FuncVal3D,
+    _FuncValFromRoots,
+    _FuncVander,
+    _FuncVander2D,
+    _FuncVander3D,
+    _FuncWeight,
+)
+from .polyutils import trimcoef as hermtrim
+
+__all__ = [
+    "hermzero",
+    "hermone",
+    "hermx",
+    "hermdomain",
+    "hermline",
+    "hermadd",
+    "hermsub",
+    "hermmulx",
+    "hermmul",
+    "hermdiv",
+    "hermpow",
+    "hermval",
+    "hermder",
+    "hermint",
+    "herm2poly",
+    "poly2herm",
+    "hermfromroots",
+    "hermvander",
+    "hermfit",
+    "hermtrim",
+    "hermroots",
+    "Hermite",
+    "hermval2d",
+    "hermval3d",
+    "hermgrid2d",
+    "hermgrid3d",
+    "hermvander2d",
+    "hermvander3d",
+    "hermcompanion",
+    "hermgauss",
+    "hermweight",
+]
+
+poly2herm: _FuncPoly2Ortho[L["poly2herm"]]
+herm2poly: _FuncUnOp[L["herm2poly"]]
+
+hermdomain: Final[_Array2[np.float64]]
+hermzero: Final[_Array1[np.int_]]
+hermone: Final[_Array1[np.int_]]
+hermx: Final[_Array2[np.int_]]
+
+hermline: _FuncLine[L["hermline"]]
+hermfromroots: _FuncFromRoots[L["hermfromroots"]]
+hermadd: _FuncBinOp[L["hermadd"]]
+hermsub: _FuncBinOp[L["hermsub"]]
+hermmulx: _FuncUnOp[L["hermmulx"]]
+hermmul: _FuncBinOp[L["hermmul"]]
+hermdiv: _FuncBinOp[L["hermdiv"]]
+hermpow: _FuncPow[L["hermpow"]]
+hermder: _FuncDer[L["hermder"]]
+hermint: _FuncInteg[L["hermint"]]
+hermval: _FuncVal[L["hermval"]]
+hermval2d: _FuncVal2D[L["hermval2d"]]
+hermval3d: _FuncVal3D[L["hermval3d"]]
+hermvalfromroots: _FuncValFromRoots[L["hermvalfromroots"]]
+hermgrid2d: _FuncVal2D[L["hermgrid2d"]]
+hermgrid3d: _FuncVal3D[L["hermgrid3d"]]
+hermvander: _FuncVander[L["hermvander"]]
+hermvander2d: _FuncVander2D[L["hermvander2d"]]
+hermvander3d: _FuncVander3D[L["hermvander3d"]]
+hermfit: _FuncFit[L["hermfit"]]
+hermcompanion: _FuncCompanion[L["hermcompanion"]]
+hermroots: _FuncRoots[L["hermroots"]]
+
+_ND = TypeVar("_ND", bound=Any)
+def _normed_hermite_n(
+    x: np.ndarray[_ND, np.dtype[np.float64]],
+    n: int | np.intp,
+) -> np.ndarray[_ND, np.dtype[np.float64]]: ...
+
+hermgauss: _FuncGauss[L["hermgauss"]]
+hermweight: _FuncWeight[L["hermweight"]]
+
+class Hermite(ABCPolyBase[L["H"]]): ...
diff --git a/venv/lib/python3.12/site-packages/numpy/polynomial/hermite_e.py b/venv/lib/python3.12/site-packages/numpy/polynomial/hermite_e.py
new file mode 100644
index 00000000..48b76894
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/polynomial/hermite_e.py
@@ -0,0 +1,1703 @@
+"""
+===================================================================
+HermiteE Series, "Probabilists" (:mod:`numpy.polynomial.hermite_e`)
+===================================================================
+
+This module provides a number of objects (mostly functions) useful for
+dealing with Hermite_e series, including a `HermiteE` class that
+encapsulates the usual arithmetic operations.  (General information
+on how this module represents and works with such polynomials is in the
+docstring for its "parent" sub-package, `numpy.polynomial`).
+
+Classes
+-------
+.. autosummary::
+   :toctree: generated/
+
+   HermiteE
+
+Constants
+---------
+.. autosummary::
+   :toctree: generated/
+
+   hermedomain
+   hermezero
+   hermeone
+   hermex
+
+Arithmetic
+----------
+.. autosummary::
+   :toctree: generated/
+
+   hermeadd
+   hermesub
+   hermemulx
+   hermemul
+   hermediv
+   hermepow
+   hermeval
+   hermeval2d
+   hermeval3d
+   hermegrid2d
+   hermegrid3d
+
+Calculus
+--------
+.. autosummary::
+   :toctree: generated/
+
+   hermeder
+   hermeint
+
+Misc Functions
+--------------
+.. autosummary::
+   :toctree: generated/
+
+   hermefromroots
+   hermeroots
+   hermevander
+   hermevander2d
+   hermevander3d
+   hermegauss
+   hermeweight
+   hermecompanion
+   hermefit
+   hermetrim
+   hermeline
+   herme2poly
+   poly2herme
+
+See also
+--------
+`numpy.polynomial`
+
+"""
+import numpy as np
+import numpy.linalg as la
+from numpy.lib.array_utils import normalize_axis_index
+
+from . import polyutils as pu
+from ._polybase import ABCPolyBase
+
+__all__ = [
+    'hermezero', 'hermeone', 'hermex', 'hermedomain', 'hermeline',
+    'hermeadd', 'hermesub', 'hermemulx', 'hermemul', 'hermediv',
+    'hermepow', 'hermeval', 'hermeder', 'hermeint', 'herme2poly',
+    'poly2herme', 'hermefromroots', 'hermevander', 'hermefit', 'hermetrim',
+    'hermeroots', 'HermiteE', 'hermeval2d', 'hermeval3d', 'hermegrid2d',
+    'hermegrid3d', 'hermevander2d', 'hermevander3d', 'hermecompanion',
+    'hermegauss', 'hermeweight']
+
+hermetrim = pu.trimcoef
+
+
+def poly2herme(pol):
+    """
+    poly2herme(pol)
+
+    Convert a polynomial to a Hermite series.
+
+    Convert an array representing the coefficients of a polynomial (relative
+    to the "standard" basis) ordered from lowest degree to highest, to an
+    array of the coefficients of the equivalent Hermite series, ordered
+    from lowest to highest degree.
+
+    Parameters
+    ----------
+    pol : array_like
+        1-D array containing the polynomial coefficients
+
+    Returns
+    -------
+    c : ndarray
+        1-D array containing the coefficients of the equivalent Hermite
+        series.
+
+    See Also
+    --------
+    herme2poly
+
+    Notes
+    -----
+    The easy way to do conversions between polynomial basis sets
+    is to use the convert method of a class instance.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from numpy.polynomial.hermite_e import poly2herme
+    >>> poly2herme(np.arange(4))
+    array([  2.,  10.,   2.,   3.])
+
+    """
+    [pol] = pu.as_series([pol])
+    deg = len(pol) - 1
+    res = 0
+    for i in range(deg, -1, -1):
+        res = hermeadd(hermemulx(res), pol[i])
+    return res
+
+
+def herme2poly(c):
+    """
+    Convert a Hermite series to a polynomial.
+
+    Convert an array representing the coefficients of a Hermite series,
+    ordered from lowest degree to highest, to an array of the coefficients
+    of the equivalent polynomial (relative to the "standard" basis) ordered
+    from lowest to highest degree.
+
+    Parameters
+    ----------
+    c : array_like
+        1-D array containing the Hermite series coefficients, ordered
+        from lowest order term to highest.
+
+    Returns
+    -------
+    pol : ndarray
+        1-D array containing the coefficients of the equivalent polynomial
+        (relative to the "standard" basis) ordered from lowest order term
+        to highest.
+
+    See Also
+    --------
+    poly2herme
+
+    Notes
+    -----
+    The easy way to do conversions between polynomial basis sets
+    is to use the convert method of a class instance.
+
+    Examples
+    --------
+    >>> from numpy.polynomial.hermite_e import herme2poly
+    >>> herme2poly([  2.,  10.,   2.,   3.])
+    array([0.,  1.,  2.,  3.])
+
+    """
+    from .polynomial import polyadd, polysub, polymulx
+
+    [c] = pu.as_series([c])
+    n = len(c)
+    if n == 1:
+        return c
+    if n == 2:
+        return c
+    else:
+        c0 = c[-2]
+        c1 = c[-1]
+        # i is the current degree of c1
+        for i in range(n - 1, 1, -1):
+            tmp = c0
+            c0 = polysub(c[i - 2], c1*(i - 1))
+            c1 = polyadd(tmp, polymulx(c1))
+        return polyadd(c0, polymulx(c1))
+
+
+#
+# These are constant arrays are of integer type so as to be compatible
+# with the widest range of other types, such as Decimal.
+#
+
+# Hermite
+hermedomain = np.array([-1., 1.])
+
+# Hermite coefficients representing zero.
+hermezero = np.array([0])
+
+# Hermite coefficients representing one.
+hermeone = np.array([1])
+
+# Hermite coefficients representing the identity x.
+hermex = np.array([0, 1])
+
+
+def hermeline(off, scl):
+    """
+    Hermite series whose graph is a straight line.
+
+    Parameters
+    ----------
+    off, scl : scalars
+        The specified line is given by ``off + scl*x``.
+
+    Returns
+    -------
+    y : ndarray
+        This module's representation of the Hermite series for
+        ``off + scl*x``.
+
+    See Also
+    --------
+    numpy.polynomial.polynomial.polyline
+    numpy.polynomial.chebyshev.chebline
+    numpy.polynomial.legendre.legline
+    numpy.polynomial.laguerre.lagline
+    numpy.polynomial.hermite.hermline
+
+    Examples
+    --------
+    >>> from numpy.polynomial.hermite_e import hermeline
+    >>> from numpy.polynomial.hermite_e import hermeline, hermeval
+    >>> hermeval(0,hermeline(3, 2))
+    3.0
+    >>> hermeval(1,hermeline(3, 2))
+    5.0
+
+    """
+    if scl != 0:
+        return np.array([off, scl])
+    else:
+        return np.array([off])
+
+
+def hermefromroots(roots):
+    """
+    Generate a HermiteE series with given roots.
+
+    The function returns the coefficients of the polynomial
+
+    .. math:: p(x) = (x - r_0) * (x - r_1) * ... * (x - r_n),
+
+    in HermiteE form, where the :math:`r_n` are the roots specified in `roots`.
+    If a zero has multiplicity n, then it must appear in `roots` n times.
+    For instance, if 2 is a root of multiplicity three and 3 is a root of
+    multiplicity 2, then `roots` looks something like [2, 2, 2, 3, 3]. The
+    roots can appear in any order.
+
+    If the returned coefficients are `c`, then
+
+    .. math:: p(x) = c_0 + c_1 * He_1(x) + ... +  c_n * He_n(x)
+
+    The coefficient of the last term is not generally 1 for monic
+    polynomials in HermiteE form.
+
+    Parameters
+    ----------
+    roots : array_like
+        Sequence containing the roots.
+
+    Returns
+    -------
+    out : ndarray
+        1-D array of coefficients.  If all roots are real then `out` is a
+        real array, if some of the roots are complex, then `out` is complex
+        even if all the coefficients in the result are real (see Examples
+        below).
+
+    See Also
+    --------
+    numpy.polynomial.polynomial.polyfromroots
+    numpy.polynomial.legendre.legfromroots
+    numpy.polynomial.laguerre.lagfromroots
+    numpy.polynomial.hermite.hermfromroots
+    numpy.polynomial.chebyshev.chebfromroots
+
+    Examples
+    --------
+    >>> from numpy.polynomial.hermite_e import hermefromroots, hermeval
+    >>> coef = hermefromroots((-1, 0, 1))
+    >>> hermeval((-1, 0, 1), coef)
+    array([0., 0., 0.])
+    >>> coef = hermefromroots((-1j, 1j))
+    >>> hermeval((-1j, 1j), coef)
+    array([0.+0.j, 0.+0.j])
+
+    """
+    return pu._fromroots(hermeline, hermemul, roots)
+
+
+def hermeadd(c1, c2):
+    """
+    Add one Hermite series to another.
+
+    Returns the sum of two Hermite series `c1` + `c2`.  The arguments
+    are sequences of coefficients ordered from lowest order term to
+    highest, i.e., [1,2,3] represents the series ``P_0 + 2*P_1 + 3*P_2``.
+
+    Parameters
+    ----------
+    c1, c2 : array_like
+        1-D arrays of Hermite series coefficients ordered from low to
+        high.
+
+    Returns
+    -------
+    out : ndarray
+        Array representing the Hermite series of their sum.
+
+    See Also
+    --------
+    hermesub, hermemulx, hermemul, hermediv, hermepow
+
+    Notes
+    -----
+    Unlike multiplication, division, etc., the sum of two Hermite series
+    is a Hermite series (without having to "reproject" the result onto
+    the basis set) so addition, just like that of "standard" polynomials,
+    is simply "component-wise."
+
+    Examples
+    --------
+    >>> from numpy.polynomial.hermite_e import hermeadd
+    >>> hermeadd([1, 2, 3], [1, 2, 3, 4])
+    array([2.,  4.,  6.,  4.])
+
+    """
+    return pu._add(c1, c2)
+
+
+def hermesub(c1, c2):
+    """
+    Subtract one Hermite series from another.
+
+    Returns the difference of two Hermite series `c1` - `c2`.  The
+    sequences of coefficients are from lowest order term to highest, i.e.,
+    [1,2,3] represents the series ``P_0 + 2*P_1 + 3*P_2``.
+
+    Parameters
+    ----------
+    c1, c2 : array_like
+        1-D arrays of Hermite series coefficients ordered from low to
+        high.
+
+    Returns
+    -------
+    out : ndarray
+        Of Hermite series coefficients representing their difference.
+
+    See Also
+    --------
+    hermeadd, hermemulx, hermemul, hermediv, hermepow
+
+    Notes
+    -----
+    Unlike multiplication, division, etc., the difference of two Hermite
+    series is a Hermite series (without having to "reproject" the result
+    onto the basis set) so subtraction, just like that of "standard"
+    polynomials, is simply "component-wise."
+
+    Examples
+    --------
+    >>> from numpy.polynomial.hermite_e import hermesub
+    >>> hermesub([1, 2, 3, 4], [1, 2, 3])
+    array([0., 0., 0., 4.])
+
+    """
+    return pu._sub(c1, c2)
+
+
+def hermemulx(c):
+    """Multiply a Hermite series by x.
+
+    Multiply the Hermite series `c` by x, where x is the independent
+    variable.
+
+
+    Parameters
+    ----------
+    c : array_like
+        1-D array of Hermite series coefficients ordered from low to
+        high.
+
+    Returns
+    -------
+    out : ndarray
+        Array representing the result of the multiplication.
+
+    See Also
+    --------
+    hermeadd, hermesub, hermemul, hermediv, hermepow
+
+    Notes
+    -----
+    The multiplication uses the recursion relationship for Hermite
+    polynomials in the form
+
+    .. math::
+
+        xP_i(x) = (P_{i + 1}(x) + iP_{i - 1}(x)))
+
+    Examples
+    --------
+    >>> from numpy.polynomial.hermite_e import hermemulx
+    >>> hermemulx([1, 2, 3])
+    array([2.,  7.,  2.,  3.])
+
+    """
+    # c is a trimmed copy
+    [c] = pu.as_series([c])
+    # The zero series needs special treatment
+    if len(c) == 1 and c[0] == 0:
+        return c
+
+    prd = np.empty(len(c) + 1, dtype=c.dtype)
+    prd[0] = c[0]*0
+    prd[1] = c[0]
+    for i in range(1, len(c)):
+        prd[i + 1] = c[i]
+        prd[i - 1] += c[i]*i
+    return prd
+
+
+def hermemul(c1, c2):
+    """
+    Multiply one Hermite series by another.
+
+    Returns the product of two Hermite series `c1` * `c2`.  The arguments
+    are sequences of coefficients, from lowest order "term" to highest,
+    e.g., [1,2,3] represents the series ``P_0 + 2*P_1 + 3*P_2``.
+
+    Parameters
+    ----------
+    c1, c2 : array_like
+        1-D arrays of Hermite series coefficients ordered from low to
+        high.
+
+    Returns
+    -------
+    out : ndarray
+        Of Hermite series coefficients representing their product.
+
+    See Also
+    --------
+    hermeadd, hermesub, hermemulx, hermediv, hermepow
+
+    Notes
+    -----
+    In general, the (polynomial) product of two C-series results in terms
+    that are not in the Hermite polynomial basis set.  Thus, to express
+    the product as a Hermite series, it is necessary to "reproject" the
+    product onto said basis set, which may produce "unintuitive" (but
+    correct) results; see Examples section below.
+
+    Examples
+    --------
+    >>> from numpy.polynomial.hermite_e import hermemul
+    >>> hermemul([1, 2, 3], [0, 1, 2])
+    array([14.,  15.,  28.,   7.,   6.])
+
+    """
+    # s1, s2 are trimmed copies
+    [c1, c2] = pu.as_series([c1, c2])
+
+    if len(c1) > len(c2):
+        c = c2
+        xs = c1
+    else:
+        c = c1
+        xs = c2
+
+    if len(c) == 1:
+        c0 = c[0]*xs
+        c1 = 0
+    elif len(c) == 2:
+        c0 = c[0]*xs
+        c1 = c[1]*xs
+    else:
+        nd = len(c)
+        c0 = c[-2]*xs
+        c1 = c[-1]*xs
+        for i in range(3, len(c) + 1):
+            tmp = c0
+            nd = nd - 1
+            c0 = hermesub(c[-i]*xs, c1*(nd - 1))
+            c1 = hermeadd(tmp, hermemulx(c1))
+    return hermeadd(c0, hermemulx(c1))
+
+
+def hermediv(c1, c2):
+    """
+    Divide one Hermite series by another.
+
+    Returns the quotient-with-remainder of two Hermite series
+    `c1` / `c2`.  The arguments are sequences of coefficients from lowest
+    order "term" to highest, e.g., [1,2,3] represents the series
+    ``P_0 + 2*P_1 + 3*P_2``.
+
+    Parameters
+    ----------
+    c1, c2 : array_like
+        1-D arrays of Hermite series coefficients ordered from low to
+        high.
+
+    Returns
+    -------
+    [quo, rem] : ndarrays
+        Of Hermite series coefficients representing the quotient and
+        remainder.
+
+    See Also
+    --------
+    hermeadd, hermesub, hermemulx, hermemul, hermepow
+
+    Notes
+    -----
+    In general, the (polynomial) division of one Hermite series by another
+    results in quotient and remainder terms that are not in the Hermite
+    polynomial basis set.  Thus, to express these results as a Hermite
+    series, it is necessary to "reproject" the results onto the Hermite
+    basis set, which may produce "unintuitive" (but correct) results; see
+    Examples section below.
+
+    Examples
+    --------
+    >>> from numpy.polynomial.hermite_e import hermediv
+    >>> hermediv([ 14.,  15.,  28.,   7.,   6.], [0, 1, 2])
+    (array([1., 2., 3.]), array([0.]))
+    >>> hermediv([ 15.,  17.,  28.,   7.,   6.], [0, 1, 2])
+    (array([1., 2., 3.]), array([1., 2.]))
+
+    """
+    return pu._div(hermemul, c1, c2)
+
+
+def hermepow(c, pow, maxpower=16):
+    """Raise a Hermite series to a power.
+
+    Returns the Hermite series `c` raised to the power `pow`. The
+    argument `c` is a sequence of coefficients ordered from low to high.
+    i.e., [1,2,3] is the series  ``P_0 + 2*P_1 + 3*P_2.``
+
+    Parameters
+    ----------
+    c : array_like
+        1-D array of Hermite series coefficients ordered from low to
+        high.
+    pow : integer
+        Power to which the series will be raised
+    maxpower : integer, optional
+        Maximum power allowed. This is mainly to limit growth of the series
+        to unmanageable size. Default is 16
+
+    Returns
+    -------
+    coef : ndarray
+        Hermite series of power.
+
+    See Also
+    --------
+    hermeadd, hermesub, hermemulx, hermemul, hermediv
+
+    Examples
+    --------
+    >>> from numpy.polynomial.hermite_e import hermepow
+    >>> hermepow([1, 2, 3], 2)
+    array([23.,  28.,  46.,  12.,   9.])
+
+    """
+    return pu._pow(hermemul, c, pow, maxpower)
+
+
+def hermeder(c, m=1, scl=1, axis=0):
+    """
+    Differentiate a Hermite_e series.
+
+    Returns the series coefficients `c` differentiated `m` times along
+    `axis`.  At each iteration the result is multiplied by `scl` (the
+    scaling factor is for use in a linear change of variable). The argument
+    `c` is an array of coefficients from low to high degree along each
+    axis, e.g., [1,2,3] represents the series ``1*He_0 + 2*He_1 + 3*He_2``
+    while [[1,2],[1,2]] represents ``1*He_0(x)*He_0(y) + 1*He_1(x)*He_0(y)
+    + 2*He_0(x)*He_1(y) + 2*He_1(x)*He_1(y)`` if axis=0 is ``x`` and axis=1
+    is ``y``.
+
+    Parameters
+    ----------
+    c : array_like
+        Array of Hermite_e series coefficients. If `c` is multidimensional
+        the different axis correspond to different variables with the
+        degree in each axis given by the corresponding index.
+    m : int, optional
+        Number of derivatives taken, must be non-negative. (Default: 1)
+    scl : scalar, optional
+        Each differentiation is multiplied by `scl`.  The end result is
+        multiplication by ``scl**m``.  This is for use in a linear change of
+        variable. (Default: 1)
+    axis : int, optional
+        Axis over which the derivative is taken. (Default: 0).
+
+        .. versionadded:: 1.7.0
+
+    Returns
+    -------
+    der : ndarray
+        Hermite series of the derivative.
+
+    See Also
+    --------
+    hermeint
+
+    Notes
+    -----
+    In general, the result of differentiating a Hermite series does not
+    resemble the same operation on a power series. Thus the result of this
+    function may be "unintuitive," albeit correct; see Examples section
+    below.
+
+    Examples
+    --------
+    >>> from numpy.polynomial.hermite_e import hermeder
+    >>> hermeder([ 1.,  1.,  1.,  1.])
+    array([1.,  2.,  3.])
+    >>> hermeder([-0.25,  1.,  1./2.,  1./3.,  1./4 ], m=2)
+    array([1.,  2.,  3.])
+
+    """
+    c = np.array(c, ndmin=1, copy=True)
+    if c.dtype.char in '?bBhHiIlLqQpP':
+        c = c.astype(np.double)
+    cnt = pu._as_int(m, "the order of derivation")
+    iaxis = pu._as_int(axis, "the axis")
+    if cnt < 0:
+        raise ValueError("The order of derivation must be non-negative")
+    iaxis = normalize_axis_index(iaxis, c.ndim)
+
+    if cnt == 0:
+        return c
+
+    c = np.moveaxis(c, iaxis, 0)
+    n = len(c)
+    if cnt >= n:
+        return c[:1]*0
+    else:
+        for i in range(cnt):
+            n = n - 1
+            c *= scl
+            der = np.empty((n,) + c.shape[1:], dtype=c.dtype)
+            for j in range(n, 0, -1):
+                der[j - 1] = j*c[j]
+            c = der
+    c = np.moveaxis(c, 0, iaxis)
+    return c
+
+
+def hermeint(c, m=1, k=[], lbnd=0, scl=1, axis=0):
+    """
+    Integrate a Hermite_e series.
+
+    Returns the Hermite_e series coefficients `c` integrated `m` times from
+    `lbnd` along `axis`. At each iteration the resulting series is
+    **multiplied** by `scl` and an integration constant, `k`, is added.
+    The scaling factor is for use in a linear change of variable.  ("Buyer
+    beware": note that, depending on what one is doing, one may want `scl`
+    to be the reciprocal of what one might expect; for more information,
+    see the Notes section below.)  The argument `c` is an array of
+    coefficients from low to high degree along each axis, e.g., [1,2,3]
+    represents the series ``H_0 + 2*H_1 + 3*H_2`` while [[1,2],[1,2]]
+    represents ``1*H_0(x)*H_0(y) + 1*H_1(x)*H_0(y) + 2*H_0(x)*H_1(y) +
+    2*H_1(x)*H_1(y)`` if axis=0 is ``x`` and axis=1 is ``y``.
+
+    Parameters
+    ----------
+    c : array_like
+        Array of Hermite_e series coefficients. If c is multidimensional
+        the different axis correspond to different variables with the
+        degree in each axis given by the corresponding index.
+    m : int, optional
+        Order of integration, must be positive. (Default: 1)
+    k : {[], list, scalar}, optional
+        Integration constant(s).  The value of the first integral at
+        ``lbnd`` is the first value in the list, the value of the second
+        integral at ``lbnd`` is the second value, etc.  If ``k == []`` (the
+        default), all constants are set to zero.  If ``m == 1``, a single
+        scalar can be given instead of a list.
+    lbnd : scalar, optional
+        The lower bound of the integral. (Default: 0)
+    scl : scalar, optional
+        Following each integration the result is *multiplied* by `scl`
+        before the integration constant is added. (Default: 1)
+    axis : int, optional
+        Axis over which the integral is taken. (Default: 0).
+
+        .. versionadded:: 1.7.0
+
+    Returns
+    -------
+    S : ndarray
+        Hermite_e series coefficients of the integral.
+
+    Raises
+    ------
+    ValueError
+        If ``m < 0``, ``len(k) > m``, ``np.ndim(lbnd) != 0``, or
+        ``np.ndim(scl) != 0``.
+
+    See Also
+    --------
+    hermeder
+
+    Notes
+    -----
+    Note that the result of each integration is *multiplied* by `scl`.
+    Why is this important to note?  Say one is making a linear change of
+    variable :math:`u = ax + b` in an integral relative to `x`.  Then
+    :math:`dx = du/a`, so one will need to set `scl` equal to
+    :math:`1/a` - perhaps not what one would have first thought.
+
+    Also note that, in general, the result of integrating a C-series needs
+    to be "reprojected" onto the C-series basis set.  Thus, typically,
+    the result of this function is "unintuitive," albeit correct; see
+    Examples section below.
+
+    Examples
+    --------
+    >>> from numpy.polynomial.hermite_e import hermeint
+    >>> hermeint([1, 2, 3]) # integrate once, value 0 at 0.
+    array([1., 1., 1., 1.])
+    >>> hermeint([1, 2, 3], m=2) # integrate twice, value & deriv 0 at 0
+    array([-0.25      ,  1.        ,  0.5       ,  0.33333333,  0.25      ]) # may vary
+    >>> hermeint([1, 2, 3], k=1) # integrate once, value 1 at 0.
+    array([2., 1., 1., 1.])
+    >>> hermeint([1, 2, 3], lbnd=-1) # integrate once, value 0 at -1
+    array([-1.,  1.,  1.,  1.])
+    >>> hermeint([1, 2, 3], m=2, k=[1, 2], lbnd=-1)
+    array([ 1.83333333,  0.        ,  0.5       ,  0.33333333,  0.25      ]) # may vary
+
+    """
+    c = np.array(c, ndmin=1, copy=True)
+    if c.dtype.char in '?bBhHiIlLqQpP':
+        c = c.astype(np.double)
+    if not np.iterable(k):
+        k = [k]
+    cnt = pu._as_int(m, "the order of integration")
+    iaxis = pu._as_int(axis, "the axis")
+    if cnt < 0:
+        raise ValueError("The order of integration must be non-negative")
+    if len(k) > cnt:
+        raise ValueError("Too many integration constants")
+    if np.ndim(lbnd) != 0:
+        raise ValueError("lbnd must be a scalar.")
+    if np.ndim(scl) != 0:
+        raise ValueError("scl must be a scalar.")
+    iaxis = normalize_axis_index(iaxis, c.ndim)
+
+    if cnt == 0:
+        return c
+
+    c = np.moveaxis(c, iaxis, 0)
+    k = list(k) + [0]*(cnt - len(k))
+    for i in range(cnt):
+        n = len(c)
+        c *= scl
+        if n == 1 and np.all(c[0] == 0):
+            c[0] += k[i]
+        else:
+            tmp = np.empty((n + 1,) + c.shape[1:], dtype=c.dtype)
+            tmp[0] = c[0]*0
+            tmp[1] = c[0]
+            for j in range(1, n):
+                tmp[j + 1] = c[j]/(j + 1)
+            tmp[0] += k[i] - hermeval(lbnd, tmp)
+            c = tmp
+    c = np.moveaxis(c, 0, iaxis)
+    return c
+
+
+def hermeval(x, c, tensor=True):
+    """
+    Evaluate an HermiteE series at points x.
+
+    If `c` is of length ``n + 1``, this function returns the value:
+
+    .. math:: p(x) = c_0 * He_0(x) + c_1 * He_1(x) + ... + c_n * He_n(x)
+
+    The parameter `x` is converted to an array only if it is a tuple or a
+    list, otherwise it is treated as a scalar. In either case, either `x`
+    or its elements must support multiplication and addition both with
+    themselves and with the elements of `c`.
+
+    If `c` is a 1-D array, then ``p(x)`` will have the same shape as `x`.  If
+    `c` is multidimensional, then the shape of the result depends on the
+    value of `tensor`. If `tensor` is true the shape will be c.shape[1:] +
+    x.shape. If `tensor` is false the shape will be c.shape[1:]. Note that
+    scalars have shape (,).
+
+    Trailing zeros in the coefficients will be used in the evaluation, so
+    they should be avoided if efficiency is a concern.
+
+    Parameters
+    ----------
+    x : array_like, compatible object
+        If `x` is a list or tuple, it is converted to an ndarray, otherwise
+        it is left unchanged and treated as a scalar. In either case, `x`
+        or its elements must support addition and multiplication with
+        with themselves and with the elements of `c`.
+    c : array_like
+        Array of coefficients ordered so that the coefficients for terms of
+        degree n are contained in c[n]. If `c` is multidimensional the
+        remaining indices enumerate multiple polynomials. In the two
+        dimensional case the coefficients may be thought of as stored in
+        the columns of `c`.
+    tensor : boolean, optional
+        If True, the shape of the coefficient array is extended with ones
+        on the right, one for each dimension of `x`. Scalars have dimension 0
+        for this action. The result is that every column of coefficients in
+        `c` is evaluated for every element of `x`. If False, `x` is broadcast
+        over the columns of `c` for the evaluation.  This keyword is useful
+        when `c` is multidimensional. The default value is True.
+
+        .. versionadded:: 1.7.0
+
+    Returns
+    -------
+    values : ndarray, algebra_like
+        The shape of the return value is described above.
+
+    See Also
+    --------
+    hermeval2d, hermegrid2d, hermeval3d, hermegrid3d
+
+    Notes
+    -----
+    The evaluation uses Clenshaw recursion, aka synthetic division.
+
+    Examples
+    --------
+    >>> from numpy.polynomial.hermite_e import hermeval
+    >>> coef = [1,2,3]
+    >>> hermeval(1, coef)
+    3.0
+    >>> hermeval([[1,2],[3,4]], coef)
+    array([[ 3., 14.],
+           [31., 54.]])
+
+    """
+    c = np.array(c, ndmin=1, copy=None)
+    if c.dtype.char in '?bBhHiIlLqQpP':
+        c = c.astype(np.double)
+    if isinstance(x, (tuple, list)):
+        x = np.asarray(x)
+    if isinstance(x, np.ndarray) and tensor:
+        c = c.reshape(c.shape + (1,)*x.ndim)
+
+    if len(c) == 1:
+        c0 = c[0]
+        c1 = 0
+    elif len(c) == 2:
+        c0 = c[0]
+        c1 = c[1]
+    else:
+        nd = len(c)
+        c0 = c[-2]
+        c1 = c[-1]
+        for i in range(3, len(c) + 1):
+            tmp = c0
+            nd = nd - 1
+            c0 = c[-i] - c1*(nd - 1)
+            c1 = tmp + c1*x
+    return c0 + c1*x
+
+
+def hermeval2d(x, y, c):
+    """
+    Evaluate a 2-D HermiteE series at points (x, y).
+
+    This function returns the values:
+
+    .. math:: p(x,y) = \\sum_{i,j} c_{i,j} * He_i(x) * He_j(y)
+
+    The parameters `x` and `y` are converted to arrays only if they are
+    tuples or a lists, otherwise they are treated as a scalars and they
+    must have the same shape after conversion. In either case, either `x`
+    and `y` or their elements must support multiplication and addition both
+    with themselves and with the elements of `c`.
+
+    If `c` is a 1-D array a one is implicitly appended to its shape to make
+    it 2-D. The shape of the result will be c.shape[2:] + x.shape.
+
+    Parameters
+    ----------
+    x, y : array_like, compatible objects
+        The two dimensional series is evaluated at the points ``(x, y)``,
+        where `x` and `y` must have the same shape. If `x` or `y` is a list
+        or tuple, it is first converted to an ndarray, otherwise it is left
+        unchanged and if it isn't an ndarray it is treated as a scalar.
+    c : array_like
+        Array of coefficients ordered so that the coefficient of the term
+        of multi-degree i,j is contained in ``c[i,j]``. If `c` has
+        dimension greater than two the remaining indices enumerate multiple
+        sets of coefficients.
+
+    Returns
+    -------
+    values : ndarray, compatible object
+        The values of the two dimensional polynomial at points formed with
+        pairs of corresponding values from `x` and `y`.
+
+    See Also
+    --------
+    hermeval, hermegrid2d, hermeval3d, hermegrid3d
+
+    Notes
+    -----
+
+    .. versionadded:: 1.7.0
+
+    """
+    return pu._valnd(hermeval, c, x, y)
+
+
+def hermegrid2d(x, y, c):
+    """
+    Evaluate a 2-D HermiteE series on the Cartesian product of x and y.
+
+    This function returns the values:
+
+    .. math:: p(a,b) = \\sum_{i,j} c_{i,j} * H_i(a) * H_j(b)
+
+    where the points ``(a, b)`` consist of all pairs formed by taking
+    `a` from `x` and `b` from `y`. The resulting points form a grid with
+    `x` in the first dimension and `y` in the second.
+
+    The parameters `x` and `y` are converted to arrays only if they are
+    tuples or a lists, otherwise they are treated as a scalars. In either
+    case, either `x` and `y` or their elements must support multiplication
+    and addition both with themselves and with the elements of `c`.
+
+    If `c` has fewer than two dimensions, ones are implicitly appended to
+    its shape to make it 2-D. The shape of the result will be c.shape[2:] +
+    x.shape.
+
+    Parameters
+    ----------
+    x, y : array_like, compatible objects
+        The two dimensional series is evaluated at the points in the
+        Cartesian product of `x` and `y`.  If `x` or `y` is a list or
+        tuple, it is first converted to an ndarray, otherwise it is left
+        unchanged and, if it isn't an ndarray, it is treated as a scalar.
+    c : array_like
+        Array of coefficients ordered so that the coefficients for terms of
+        degree i,j are contained in ``c[i,j]``. If `c` has dimension
+        greater than two the remaining indices enumerate multiple sets of
+        coefficients.
+
+    Returns
+    -------
+    values : ndarray, compatible object
+        The values of the two dimensional polynomial at points in the Cartesian
+        product of `x` and `y`.
+
+    See Also
+    --------
+    hermeval, hermeval2d, hermeval3d, hermegrid3d
+
+    Notes
+    -----
+
+    .. versionadded:: 1.7.0
+
+    """
+    return pu._gridnd(hermeval, c, x, y)
+
+
+def hermeval3d(x, y, z, c):
+    """
+    Evaluate a 3-D Hermite_e series at points (x, y, z).
+
+    This function returns the values:
+
+    .. math:: p(x,y,z) = \\sum_{i,j,k} c_{i,j,k} * He_i(x) * He_j(y) * He_k(z)
+
+    The parameters `x`, `y`, and `z` are converted to arrays only if
+    they are tuples or a lists, otherwise they are treated as a scalars and
+    they must have the same shape after conversion. In either case, either
+    `x`, `y`, and `z` or their elements must support multiplication and
+    addition both with themselves and with the elements of `c`.
+
+    If `c` has fewer than 3 dimensions, ones are implicitly appended to its
+    shape to make it 3-D. The shape of the result will be c.shape[3:] +
+    x.shape.
+
+    Parameters
+    ----------
+    x, y, z : array_like, compatible object
+        The three dimensional series is evaluated at the points
+        `(x, y, z)`, where `x`, `y`, and `z` must have the same shape.  If
+        any of `x`, `y`, or `z` is a list or tuple, it is first converted
+        to an ndarray, otherwise it is left unchanged and if it isn't an
+        ndarray it is  treated as a scalar.
+    c : array_like
+        Array of coefficients ordered so that the coefficient of the term of
+        multi-degree i,j,k is contained in ``c[i,j,k]``. If `c` has dimension
+        greater than 3 the remaining indices enumerate multiple sets of
+        coefficients.
+
+    Returns
+    -------
+    values : ndarray, compatible object
+        The values of the multidimensional polynomial on points formed with
+        triples of corresponding values from `x`, `y`, and `z`.
+
+    See Also
+    --------
+    hermeval, hermeval2d, hermegrid2d, hermegrid3d
+
+    Notes
+    -----
+
+    .. versionadded:: 1.7.0
+
+    """
+    return pu._valnd(hermeval, c, x, y, z)
+
+
+def hermegrid3d(x, y, z, c):
+    """
+    Evaluate a 3-D HermiteE series on the Cartesian product of x, y, and z.
+
+    This function returns the values:
+
+    .. math:: p(a,b,c) = \\sum_{i,j,k} c_{i,j,k} * He_i(a) * He_j(b) * He_k(c)
+
+    where the points ``(a, b, c)`` consist of all triples formed by taking
+    `a` from `x`, `b` from `y`, and `c` from `z`. The resulting points form
+    a grid with `x` in the first dimension, `y` in the second, and `z` in
+    the third.
+
+    The parameters `x`, `y`, and `z` are converted to arrays only if they
+    are tuples or a lists, otherwise they are treated as a scalars. In
+    either case, either `x`, `y`, and `z` or their elements must support
+    multiplication and addition both with themselves and with the elements
+    of `c`.
+
+    If `c` has fewer than three dimensions, ones are implicitly appended to
+    its shape to make it 3-D. The shape of the result will be c.shape[3:] +
+    x.shape + y.shape + z.shape.
+
+    Parameters
+    ----------
+    x, y, z : array_like, compatible objects
+        The three dimensional series is evaluated at the points in the
+        Cartesian product of `x`, `y`, and `z`.  If `x`, `y`, or `z` is a
+        list or tuple, it is first converted to an ndarray, otherwise it is
+        left unchanged and, if it isn't an ndarray, it is treated as a
+        scalar.
+    c : array_like
+        Array of coefficients ordered so that the coefficients for terms of
+        degree i,j are contained in ``c[i,j]``. If `c` has dimension
+        greater than two the remaining indices enumerate multiple sets of
+        coefficients.
+
+    Returns
+    -------
+    values : ndarray, compatible object
+        The values of the two dimensional polynomial at points in the Cartesian
+        product of `x` and `y`.
+
+    See Also
+    --------
+    hermeval, hermeval2d, hermegrid2d, hermeval3d
+
+    Notes
+    -----
+
+    .. versionadded:: 1.7.0
+
+    """
+    return pu._gridnd(hermeval, c, x, y, z)
+
+
+def hermevander(x, deg):
+    """Pseudo-Vandermonde matrix of given degree.
+
+    Returns the pseudo-Vandermonde matrix of degree `deg` and sample points
+    `x`. The pseudo-Vandermonde matrix is defined by
+
+    .. math:: V[..., i] = He_i(x),
+
+    where ``0 <= i <= deg``. The leading indices of `V` index the elements of
+    `x` and the last index is the degree of the HermiteE polynomial.
+
+    If `c` is a 1-D array of coefficients of length ``n + 1`` and `V` is the
+    array ``V = hermevander(x, n)``, then ``np.dot(V, c)`` and
+    ``hermeval(x, c)`` are the same up to roundoff. This equivalence is
+    useful both for least squares fitting and for the evaluation of a large
+    number of HermiteE series of the same degree and sample points.
+
+    Parameters
+    ----------
+    x : array_like
+        Array of points. The dtype is converted to float64 or complex128
+        depending on whether any of the elements are complex. If `x` is
+        scalar it is converted to a 1-D array.
+    deg : int
+        Degree of the resulting matrix.
+
+    Returns
+    -------
+    vander : ndarray
+        The pseudo-Vandermonde matrix. The shape of the returned matrix is
+        ``x.shape + (deg + 1,)``, where The last index is the degree of the
+        corresponding HermiteE polynomial.  The dtype will be the same as
+        the converted `x`.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from numpy.polynomial.hermite_e import hermevander
+    >>> x = np.array([-1, 0, 1])
+    >>> hermevander(x, 3)
+    array([[ 1., -1.,  0.,  2.],
+           [ 1.,  0., -1., -0.],
+           [ 1.,  1.,  0., -2.]])
+
+    """
+    ideg = pu._as_int(deg, "deg")
+    if ideg < 0:
+        raise ValueError("deg must be non-negative")
+
+    x = np.array(x, copy=None, ndmin=1) + 0.0
+    dims = (ideg + 1,) + x.shape
+    dtyp = x.dtype
+    v = np.empty(dims, dtype=dtyp)
+    v[0] = x*0 + 1
+    if ideg > 0:
+        v[1] = x
+        for i in range(2, ideg + 1):
+            v[i] = (v[i-1]*x - v[i-2]*(i - 1))
+    return np.moveaxis(v, 0, -1)
+
+
+def hermevander2d(x, y, deg):
+    """Pseudo-Vandermonde matrix of given degrees.
+
+    Returns the pseudo-Vandermonde matrix of degrees `deg` and sample
+    points ``(x, y)``. The pseudo-Vandermonde matrix is defined by
+
+    .. math:: V[..., (deg[1] + 1)*i + j] = He_i(x) * He_j(y),
+
+    where ``0 <= i <= deg[0]`` and ``0 <= j <= deg[1]``. The leading indices of
+    `V` index the points ``(x, y)`` and the last index encodes the degrees of
+    the HermiteE polynomials.
+
+    If ``V = hermevander2d(x, y, [xdeg, ydeg])``, then the columns of `V`
+    correspond to the elements of a 2-D coefficient array `c` of shape
+    (xdeg + 1, ydeg + 1) in the order
+
+    .. math:: c_{00}, c_{01}, c_{02} ... , c_{10}, c_{11}, c_{12} ...
+
+    and ``np.dot(V, c.flat)`` and ``hermeval2d(x, y, c)`` will be the same
+    up to roundoff. This equivalence is useful both for least squares
+    fitting and for the evaluation of a large number of 2-D HermiteE
+    series of the same degrees and sample points.
+
+    Parameters
+    ----------
+    x, y : array_like
+        Arrays of point coordinates, all of the same shape. The dtypes
+        will be converted to either float64 or complex128 depending on
+        whether any of the elements are complex. Scalars are converted to
+        1-D arrays.
+    deg : list of ints
+        List of maximum degrees of the form [x_deg, y_deg].
+
+    Returns
+    -------
+    vander2d : ndarray
+        The shape of the returned matrix is ``x.shape + (order,)``, where
+        :math:`order = (deg[0]+1)*(deg[1]+1)`.  The dtype will be the same
+        as the converted `x` and `y`.
+
+    See Also
+    --------
+    hermevander, hermevander3d, hermeval2d, hermeval3d
+
+    Notes
+    -----
+
+    .. versionadded:: 1.7.0
+
+    """
+    return pu._vander_nd_flat((hermevander, hermevander), (x, y), deg)
+
+
+def hermevander3d(x, y, z, deg):
+    """Pseudo-Vandermonde matrix of given degrees.
+
+    Returns the pseudo-Vandermonde matrix of degrees `deg` and sample
+    points ``(x, y, z)``. If `l`, `m`, `n` are the given degrees in `x`, `y`, `z`,
+    then Hehe pseudo-Vandermonde matrix is defined by
+
+    .. math:: V[..., (m+1)(n+1)i + (n+1)j + k] = He_i(x)*He_j(y)*He_k(z),
+
+    where ``0 <= i <= l``, ``0 <= j <= m``, and ``0 <= j <= n``.  The leading
+    indices of `V` index the points ``(x, y, z)`` and the last index encodes
+    the degrees of the HermiteE polynomials.
+
+    If ``V = hermevander3d(x, y, z, [xdeg, ydeg, zdeg])``, then the columns
+    of `V` correspond to the elements of a 3-D coefficient array `c` of
+    shape (xdeg + 1, ydeg + 1, zdeg + 1) in the order
+
+    .. math:: c_{000}, c_{001}, c_{002},... , c_{010}, c_{011}, c_{012},...
+
+    and  ``np.dot(V, c.flat)`` and ``hermeval3d(x, y, z, c)`` will be the
+    same up to roundoff. This equivalence is useful both for least squares
+    fitting and for the evaluation of a large number of 3-D HermiteE
+    series of the same degrees and sample points.
+
+    Parameters
+    ----------
+    x, y, z : array_like
+        Arrays of point coordinates, all of the same shape. The dtypes will
+        be converted to either float64 or complex128 depending on whether
+        any of the elements are complex. Scalars are converted to 1-D
+        arrays.
+    deg : list of ints
+        List of maximum degrees of the form [x_deg, y_deg, z_deg].
+
+    Returns
+    -------
+    vander3d : ndarray
+        The shape of the returned matrix is ``x.shape + (order,)``, where
+        :math:`order = (deg[0]+1)*(deg[1]+1)*(deg[2]+1)`.  The dtype will
+        be the same as the converted `x`, `y`, and `z`.
+
+    See Also
+    --------
+    hermevander, hermevander3d, hermeval2d, hermeval3d
+
+    Notes
+    -----
+
+    .. versionadded:: 1.7.0
+
+    """
+    return pu._vander_nd_flat((hermevander, hermevander, hermevander), (x, y, z), deg)
+
+
+def hermefit(x, y, deg, rcond=None, full=False, w=None):
+    """
+    Least squares fit of Hermite series to data.
+
+    Return the coefficients of a HermiteE series of degree `deg` that is
+    the least squares fit to the data values `y` given at points `x`. If
+    `y` is 1-D the returned coefficients will also be 1-D. If `y` is 2-D
+    multiple fits are done, one for each column of `y`, and the resulting
+    coefficients are stored in the corresponding columns of a 2-D return.
+    The fitted polynomial(s) are in the form
+
+    .. math::  p(x) = c_0 + c_1 * He_1(x) + ... + c_n * He_n(x),
+
+    where `n` is `deg`.
+
+    Parameters
+    ----------
+    x : array_like, shape (M,)
+        x-coordinates of the M sample points ``(x[i], y[i])``.
+    y : array_like, shape (M,) or (M, K)
+        y-coordinates of the sample points. Several data sets of sample
+        points sharing the same x-coordinates can be fitted at once by
+        passing in a 2D-array that contains one dataset per column.
+    deg : int or 1-D array_like
+        Degree(s) of the fitting polynomials. If `deg` is a single integer
+        all terms up to and including the `deg`'th term are included in the
+        fit. For NumPy versions >= 1.11.0 a list of integers specifying the
+        degrees of the terms to include may be used instead.
+    rcond : float, optional
+        Relative condition number of the fit. Singular values smaller than
+        this relative to the largest singular value will be ignored. The
+        default value is len(x)*eps, where eps is the relative precision of
+        the float type, about 2e-16 in most cases.
+    full : bool, optional
+        Switch determining nature of return value. When it is False (the
+        default) just the coefficients are returned, when True diagnostic
+        information from the singular value decomposition is also returned.
+    w : array_like, shape (`M`,), optional
+        Weights. If not None, the weight ``w[i]`` applies to the unsquared
+        residual ``y[i] - y_hat[i]`` at ``x[i]``. Ideally the weights are
+        chosen so that the errors of the products ``w[i]*y[i]`` all have the
+        same variance.  When using inverse-variance weighting, use
+        ``w[i] = 1/sigma(y[i])``.  The default value is None.
+
+    Returns
+    -------
+    coef : ndarray, shape (M,) or (M, K)
+        Hermite coefficients ordered from low to high. If `y` was 2-D,
+        the coefficients for the data in column k  of `y` are in column
+        `k`.
+
+    [residuals, rank, singular_values, rcond] : list
+        These values are only returned if ``full == True``
+
+        - residuals -- sum of squared residuals of the least squares fit
+        - rank -- the numerical rank of the scaled Vandermonde matrix
+        - singular_values -- singular values of the scaled Vandermonde matrix
+        - rcond -- value of `rcond`.
+
+        For more details, see `numpy.linalg.lstsq`.
+
+    Warns
+    -----
+    RankWarning
+        The rank of the coefficient matrix in the least-squares fit is
+        deficient. The warning is only raised if ``full = False``.  The
+        warnings can be turned off by
+
+        >>> import warnings
+        >>> warnings.simplefilter('ignore', np.exceptions.RankWarning)
+
+    See Also
+    --------
+    numpy.polynomial.chebyshev.chebfit
+    numpy.polynomial.legendre.legfit
+    numpy.polynomial.polynomial.polyfit
+    numpy.polynomial.hermite.hermfit
+    numpy.polynomial.laguerre.lagfit
+    hermeval : Evaluates a Hermite series.
+    hermevander : pseudo Vandermonde matrix of Hermite series.
+    hermeweight : HermiteE weight function.
+    numpy.linalg.lstsq : Computes a least-squares fit from the matrix.
+    scipy.interpolate.UnivariateSpline : Computes spline fits.
+
+    Notes
+    -----
+    The solution is the coefficients of the HermiteE series `p` that
+    minimizes the sum of the weighted squared errors
+
+    .. math:: E = \\sum_j w_j^2 * |y_j - p(x_j)|^2,
+
+    where the :math:`w_j` are the weights. This problem is solved by
+    setting up the (typically) overdetermined matrix equation
+
+    .. math:: V(x) * c = w * y,
+
+    where `V` is the pseudo Vandermonde matrix of `x`, the elements of `c`
+    are the coefficients to be solved for, and the elements of `y` are the
+    observed values.  This equation is then solved using the singular value
+    decomposition of `V`.
+
+    If some of the singular values of `V` are so small that they are
+    neglected, then a `~exceptions.RankWarning` will be issued. This means that
+    the coefficient values may be poorly determined. Using a lower order fit
+    will usually get rid of the warning.  The `rcond` parameter can also be
+    set to a value smaller than its default, but the resulting fit may be
+    spurious and have large contributions from roundoff error.
+
+    Fits using HermiteE series are probably most useful when the data can
+    be approximated by ``sqrt(w(x)) * p(x)``, where ``w(x)`` is the HermiteE
+    weight. In that case the weight ``sqrt(w(x[i]))`` should be used
+    together with data values ``y[i]/sqrt(w(x[i]))``. The weight function is
+    available as `hermeweight`.
+
+    References
+    ----------
+    .. [1] Wikipedia, "Curve fitting",
+           https://en.wikipedia.org/wiki/Curve_fitting
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from numpy.polynomial.hermite_e import hermefit, hermeval
+    >>> x = np.linspace(-10, 10)
+    >>> rng = np.random.default_rng()
+    >>> err = rng.normal(scale=1./10, size=len(x))
+    >>> y = hermeval(x, [1, 2, 3]) + err
+    >>> hermefit(x, y, 2)
+    array([1.02284196, 2.00032805, 2.99978457]) # may vary
+
+    """
+    return pu._fit(hermevander, x, y, deg, rcond, full, w)
+
+
+def hermecompanion(c):
+    """
+    Return the scaled companion matrix of c.
+
+    The basis polynomials are scaled so that the companion matrix is
+    symmetric when `c` is an HermiteE basis polynomial. This provides
+    better eigenvalue estimates than the unscaled case and for basis
+    polynomials the eigenvalues are guaranteed to be real if
+    `numpy.linalg.eigvalsh` is used to obtain them.
+
+    Parameters
+    ----------
+    c : array_like
+        1-D array of HermiteE series coefficients ordered from low to high
+        degree.
+
+    Returns
+    -------
+    mat : ndarray
+        Scaled companion matrix of dimensions (deg, deg).
+
+    Notes
+    -----
+
+    .. versionadded:: 1.7.0
+
+    """
+    # c is a trimmed copy
+    [c] = pu.as_series([c])
+    if len(c) < 2:
+        raise ValueError('Series must have maximum degree of at least 1.')
+    if len(c) == 2:
+        return np.array([[-c[0]/c[1]]])
+
+    n = len(c) - 1
+    mat = np.zeros((n, n), dtype=c.dtype)
+    scl = np.hstack((1., 1./np.sqrt(np.arange(n - 1, 0, -1))))
+    scl = np.multiply.accumulate(scl)[::-1]
+    top = mat.reshape(-1)[1::n+1]
+    bot = mat.reshape(-1)[n::n+1]
+    top[...] = np.sqrt(np.arange(1, n))
+    bot[...] = top
+    mat[:, -1] -= scl*c[:-1]/c[-1]
+    return mat
+
+
+def hermeroots(c):
+    """
+    Compute the roots of a HermiteE series.
+
+    Return the roots (a.k.a. "zeros") of the polynomial
+
+    .. math:: p(x) = \\sum_i c[i] * He_i(x).
+
+    Parameters
+    ----------
+    c : 1-D array_like
+        1-D array of coefficients.
+
+    Returns
+    -------
+    out : ndarray
+        Array of the roots of the series. If all the roots are real,
+        then `out` is also real, otherwise it is complex.
+
+    See Also
+    --------
+    numpy.polynomial.polynomial.polyroots
+    numpy.polynomial.legendre.legroots
+    numpy.polynomial.laguerre.lagroots
+    numpy.polynomial.hermite.hermroots
+    numpy.polynomial.chebyshev.chebroots
+
+    Notes
+    -----
+    The root estimates are obtained as the eigenvalues of the companion
+    matrix, Roots far from the origin of the complex plane may have large
+    errors due to the numerical instability of the series for such
+    values. Roots with multiplicity greater than 1 will also show larger
+    errors as the value of the series near such points is relatively
+    insensitive to errors in the roots. Isolated roots near the origin can
+    be improved by a few iterations of Newton's method.
+
+    The HermiteE series basis polynomials aren't powers of `x` so the
+    results of this function may seem unintuitive.
+
+    Examples
+    --------
+    >>> from numpy.polynomial.hermite_e import hermeroots, hermefromroots
+    >>> coef = hermefromroots([-1, 0, 1])
+    >>> coef
+    array([0., 2., 0., 1.])
+    >>> hermeroots(coef)
+    array([-1.,  0.,  1.]) # may vary
+
+    """
+    # c is a trimmed copy
+    [c] = pu.as_series([c])
+    if len(c) <= 1:
+        return np.array([], dtype=c.dtype)
+    if len(c) == 2:
+        return np.array([-c[0]/c[1]])
+
+    # rotated companion matrix reduces error
+    m = hermecompanion(c)[::-1,::-1]
+    r = la.eigvals(m)
+    r.sort()
+    return r
+
+
+def _normed_hermite_e_n(x, n):
+    """
+    Evaluate a normalized HermiteE polynomial.
+
+    Compute the value of the normalized HermiteE polynomial of degree ``n``
+    at the points ``x``.
+
+
+    Parameters
+    ----------
+    x : ndarray of double.
+        Points at which to evaluate the function
+    n : int
+        Degree of the normalized HermiteE function to be evaluated.
+
+    Returns
+    -------
+    values : ndarray
+        The shape of the return value is described above.
+
+    Notes
+    -----
+    .. versionadded:: 1.10.0
+
+    This function is needed for finding the Gauss points and integration
+    weights for high degrees. The values of the standard HermiteE functions
+    overflow when n >= 207.
+
+    """
+    if n == 0:
+        return np.full(x.shape, 1/np.sqrt(np.sqrt(2*np.pi)))
+
+    c0 = 0.
+    c1 = 1./np.sqrt(np.sqrt(2*np.pi))
+    nd = float(n)
+    for i in range(n - 1):
+        tmp = c0
+        c0 = -c1*np.sqrt((nd - 1.)/nd)
+        c1 = tmp + c1*x*np.sqrt(1./nd)
+        nd = nd - 1.0
+    return c0 + c1*x
+
+
+def hermegauss(deg):
+    """
+    Gauss-HermiteE quadrature.
+
+    Computes the sample points and weights for Gauss-HermiteE quadrature.
+    These sample points and weights will correctly integrate polynomials of
+    degree :math:`2*deg - 1` or less over the interval :math:`[-\\inf, \\inf]`
+    with the weight function :math:`f(x) = \\exp(-x^2/2)`.
+
+    Parameters
+    ----------
+    deg : int
+        Number of sample points and weights. It must be >= 1.
+
+    Returns
+    -------
+    x : ndarray
+        1-D ndarray containing the sample points.
+    y : ndarray
+        1-D ndarray containing the weights.
+
+    Notes
+    -----
+
+    .. versionadded:: 1.7.0
+
+    The results have only been tested up to degree 100, higher degrees may
+    be problematic. The weights are determined by using the fact that
+
+    .. math:: w_k = c / (He'_n(x_k) * He_{n-1}(x_k))
+
+    where :math:`c` is a constant independent of :math:`k` and :math:`x_k`
+    is the k'th root of :math:`He_n`, and then scaling the results to get
+    the right value when integrating 1.
+
+    """
+    ideg = pu._as_int(deg, "deg")
+    if ideg <= 0:
+        raise ValueError("deg must be a positive integer")
+
+    # first approximation of roots. We use the fact that the companion
+    # matrix is symmetric in this case in order to obtain better zeros.
+    c = np.array([0]*deg + [1])
+    m = hermecompanion(c)
+    x = la.eigvalsh(m)
+
+    # improve roots by one application of Newton
+    dy = _normed_hermite_e_n(x, ideg)
+    df = _normed_hermite_e_n(x, ideg - 1) * np.sqrt(ideg)
+    x -= dy/df
+
+    # compute the weights. We scale the factor to avoid possible numerical
+    # overflow.
+    fm = _normed_hermite_e_n(x, ideg - 1)
+    fm /= np.abs(fm).max()
+    w = 1/(fm * fm)
+
+    # for Hermite_e we can also symmetrize
+    w = (w + w[::-1])/2
+    x = (x - x[::-1])/2
+
+    # scale w to get the right value
+    w *= np.sqrt(2*np.pi) / w.sum()
+
+    return x, w
+
+
+def hermeweight(x):
+    """Weight function of the Hermite_e polynomials.
+
+    The weight function is :math:`\\exp(-x^2/2)` and the interval of
+    integration is :math:`[-\\inf, \\inf]`. the HermiteE polynomials are
+    orthogonal, but not normalized, with respect to this weight function.
+
+    Parameters
+    ----------
+    x : array_like
+       Values at which the weight function will be computed.
+
+    Returns
+    -------
+    w : ndarray
+       The weight function at `x`.
+
+    Notes
+    -----
+
+    .. versionadded:: 1.7.0
+
+    """
+    w = np.exp(-.5*x**2)
+    return w
+
+
+#
+# HermiteE series class
+#
+
+class HermiteE(ABCPolyBase):
+    """An HermiteE series class.
+
+    The HermiteE class provides the standard Python numerical methods
+    '+', '-', '*', '//', '%', 'divmod', '**', and '()' as well as the
+    attributes and methods listed below.
+
+    Parameters
+    ----------
+    coef : array_like
+        HermiteE coefficients in order of increasing degree, i.e,
+        ``(1, 2, 3)`` gives ``1*He_0(x) + 2*He_1(X) + 3*He_2(x)``.
+    domain : (2,) array_like, optional
+        Domain to use. The interval ``[domain[0], domain[1]]`` is mapped
+        to the interval ``[window[0], window[1]]`` by shifting and scaling.
+        The default value is [-1., 1.].
+    window : (2,) array_like, optional
+        Window, see `domain` for its use. The default value is [-1., 1.].
+
+        .. versionadded:: 1.6.0
+    symbol : str, optional
+        Symbol used to represent the independent variable in string
+        representations of the polynomial expression, e.g. for printing.
+        The symbol must be a valid Python identifier. Default value is 'x'.
+
+        .. versionadded:: 1.24
+
+    """
+    # Virtual Functions
+    _add = staticmethod(hermeadd)
+    _sub = staticmethod(hermesub)
+    _mul = staticmethod(hermemul)
+    _div = staticmethod(hermediv)
+    _pow = staticmethod(hermepow)
+    _val = staticmethod(hermeval)
+    _int = staticmethod(hermeint)
+    _der = staticmethod(hermeder)
+    _fit = staticmethod(hermefit)
+    _line = staticmethod(hermeline)
+    _roots = staticmethod(hermeroots)
+    _fromroots = staticmethod(hermefromroots)
+
+    # Virtual properties
+    domain = np.array(hermedomain)
+    window = np.array(hermedomain)
+    basis_name = 'He'
diff --git a/venv/lib/python3.12/site-packages/numpy/polynomial/hermite_e.pyi b/venv/lib/python3.12/site-packages/numpy/polynomial/hermite_e.pyi
new file mode 100644
index 00000000..94ad7248
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/polynomial/hermite_e.pyi
@@ -0,0 +1,106 @@
+from typing import Any, Final, Literal as L, TypeVar
+
+import numpy as np
+
+from ._polybase import ABCPolyBase
+from ._polytypes import (
+    _Array1,
+    _Array2,
+    _FuncBinOp,
+    _FuncCompanion,
+    _FuncDer,
+    _FuncFit,
+    _FuncFromRoots,
+    _FuncGauss,
+    _FuncInteg,
+    _FuncLine,
+    _FuncPoly2Ortho,
+    _FuncPow,
+    _FuncRoots,
+    _FuncUnOp,
+    _FuncVal,
+    _FuncVal2D,
+    _FuncVal3D,
+    _FuncValFromRoots,
+    _FuncVander,
+    _FuncVander2D,
+    _FuncVander3D,
+    _FuncWeight,
+)
+from .polyutils import trimcoef as hermetrim
+
+__all__ = [
+    "hermezero",
+    "hermeone",
+    "hermex",
+    "hermedomain",
+    "hermeline",
+    "hermeadd",
+    "hermesub",
+    "hermemulx",
+    "hermemul",
+    "hermediv",
+    "hermepow",
+    "hermeval",
+    "hermeder",
+    "hermeint",
+    "herme2poly",
+    "poly2herme",
+    "hermefromroots",
+    "hermevander",
+    "hermefit",
+    "hermetrim",
+    "hermeroots",
+    "HermiteE",
+    "hermeval2d",
+    "hermeval3d",
+    "hermegrid2d",
+    "hermegrid3d",
+    "hermevander2d",
+    "hermevander3d",
+    "hermecompanion",
+    "hermegauss",
+    "hermeweight",
+]
+
+poly2herme: _FuncPoly2Ortho[L["poly2herme"]]
+herme2poly: _FuncUnOp[L["herme2poly"]]
+
+hermedomain: Final[_Array2[np.float64]]
+hermezero: Final[_Array1[np.int_]]
+hermeone: Final[_Array1[np.int_]]
+hermex: Final[_Array2[np.int_]]
+
+hermeline: _FuncLine[L["hermeline"]]
+hermefromroots: _FuncFromRoots[L["hermefromroots"]]
+hermeadd: _FuncBinOp[L["hermeadd"]]
+hermesub: _FuncBinOp[L["hermesub"]]
+hermemulx: _FuncUnOp[L["hermemulx"]]
+hermemul: _FuncBinOp[L["hermemul"]]
+hermediv: _FuncBinOp[L["hermediv"]]
+hermepow: _FuncPow[L["hermepow"]]
+hermeder: _FuncDer[L["hermeder"]]
+hermeint: _FuncInteg[L["hermeint"]]
+hermeval: _FuncVal[L["hermeval"]]
+hermeval2d: _FuncVal2D[L["hermeval2d"]]
+hermeval3d: _FuncVal3D[L["hermeval3d"]]
+hermevalfromroots: _FuncValFromRoots[L["hermevalfromroots"]]
+hermegrid2d: _FuncVal2D[L["hermegrid2d"]]
+hermegrid3d: _FuncVal3D[L["hermegrid3d"]]
+hermevander: _FuncVander[L["hermevander"]]
+hermevander2d: _FuncVander2D[L["hermevander2d"]]
+hermevander3d: _FuncVander3D[L["hermevander3d"]]
+hermefit: _FuncFit[L["hermefit"]]
+hermecompanion: _FuncCompanion[L["hermecompanion"]]
+hermeroots: _FuncRoots[L["hermeroots"]]
+
+_ND = TypeVar("_ND", bound=Any)
+def _normed_hermite_e_n(
+    x: np.ndarray[_ND, np.dtype[np.float64]],
+    n: int | np.intp,
+) -> np.ndarray[_ND, np.dtype[np.float64]]: ...
+
+hermegauss: _FuncGauss[L["hermegauss"]]
+hermeweight: _FuncWeight[L["hermeweight"]]
+
+class HermiteE(ABCPolyBase[L["He"]]): ...
diff --git a/venv/lib/python3.12/site-packages/numpy/polynomial/laguerre.py b/venv/lib/python3.12/site-packages/numpy/polynomial/laguerre.py
new file mode 100644
index 00000000..87f3ffa6
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/polynomial/laguerre.py
@@ -0,0 +1,1726 @@
+"""
+==================================================
+Laguerre Series (:mod:`numpy.polynomial.laguerre`)
+==================================================
+
+This module provides a number of objects (mostly functions) useful for
+dealing with Laguerre series, including a `Laguerre` class that
+encapsulates the usual arithmetic operations.  (General information
+on how this module represents and works with such polynomials is in the
+docstring for its "parent" sub-package, `numpy.polynomial`).
+
+Classes
+-------
+.. autosummary::
+   :toctree: generated/
+
+   Laguerre
+
+Constants
+---------
+.. autosummary::
+   :toctree: generated/
+
+   lagdomain
+   lagzero
+   lagone
+   lagx
+
+Arithmetic
+----------
+.. autosummary::
+   :toctree: generated/
+
+   lagadd
+   lagsub
+   lagmulx
+   lagmul
+   lagdiv
+   lagpow
+   lagval
+   lagval2d
+   lagval3d
+   laggrid2d
+   laggrid3d
+
+Calculus
+--------
+.. autosummary::
+   :toctree: generated/
+
+   lagder
+   lagint
+
+Misc Functions
+--------------
+.. autosummary::
+   :toctree: generated/
+
+   lagfromroots
+   lagroots
+   lagvander
+   lagvander2d
+   lagvander3d
+   laggauss
+   lagweight
+   lagcompanion
+   lagfit
+   lagtrim
+   lagline
+   lag2poly
+   poly2lag
+
+See also
+--------
+`numpy.polynomial`
+
+"""
+import numpy as np
+import numpy.linalg as la
+from numpy.lib.array_utils import normalize_axis_index
+
+from . import polyutils as pu
+from ._polybase import ABCPolyBase
+
+__all__ = [
+    'lagzero', 'lagone', 'lagx', 'lagdomain', 'lagline', 'lagadd',
+    'lagsub', 'lagmulx', 'lagmul', 'lagdiv', 'lagpow', 'lagval', 'lagder',
+    'lagint', 'lag2poly', 'poly2lag', 'lagfromroots', 'lagvander',
+    'lagfit', 'lagtrim', 'lagroots', 'Laguerre', 'lagval2d', 'lagval3d',
+    'laggrid2d', 'laggrid3d', 'lagvander2d', 'lagvander3d', 'lagcompanion',
+    'laggauss', 'lagweight']
+
+lagtrim = pu.trimcoef
+
+
+def poly2lag(pol):
+    """
+    poly2lag(pol)
+
+    Convert a polynomial to a Laguerre series.
+
+    Convert an array representing the coefficients of a polynomial (relative
+    to the "standard" basis) ordered from lowest degree to highest, to an
+    array of the coefficients of the equivalent Laguerre series, ordered
+    from lowest to highest degree.
+
+    Parameters
+    ----------
+    pol : array_like
+        1-D array containing the polynomial coefficients
+
+    Returns
+    -------
+    c : ndarray
+        1-D array containing the coefficients of the equivalent Laguerre
+        series.
+
+    See Also
+    --------
+    lag2poly
+
+    Notes
+    -----
+    The easy way to do conversions between polynomial basis sets
+    is to use the convert method of a class instance.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from numpy.polynomial.laguerre import poly2lag
+    >>> poly2lag(np.arange(4))
+    array([ 23., -63.,  58., -18.])
+
+    """
+    [pol] = pu.as_series([pol])
+    res = 0
+    for p in pol[::-1]:
+        res = lagadd(lagmulx(res), p)
+    return res
+
+
+def lag2poly(c):
+    """
+    Convert a Laguerre series to a polynomial.
+
+    Convert an array representing the coefficients of a Laguerre series,
+    ordered from lowest degree to highest, to an array of the coefficients
+    of the equivalent polynomial (relative to the "standard" basis) ordered
+    from lowest to highest degree.
+
+    Parameters
+    ----------
+    c : array_like
+        1-D array containing the Laguerre series coefficients, ordered
+        from lowest order term to highest.
+
+    Returns
+    -------
+    pol : ndarray
+        1-D array containing the coefficients of the equivalent polynomial
+        (relative to the "standard" basis) ordered from lowest order term
+        to highest.
+
+    See Also
+    --------
+    poly2lag
+
+    Notes
+    -----
+    The easy way to do conversions between polynomial basis sets
+    is to use the convert method of a class instance.
+
+    Examples
+    --------
+    >>> from numpy.polynomial.laguerre import lag2poly
+    >>> lag2poly([ 23., -63.,  58., -18.])
+    array([0., 1., 2., 3.])
+
+    """
+    from .polynomial import polyadd, polysub, polymulx
+
+    [c] = pu.as_series([c])
+    n = len(c)
+    if n == 1:
+        return c
+    else:
+        c0 = c[-2]
+        c1 = c[-1]
+        # i is the current degree of c1
+        for i in range(n - 1, 1, -1):
+            tmp = c0
+            c0 = polysub(c[i - 2], (c1*(i - 1))/i)
+            c1 = polyadd(tmp, polysub((2*i - 1)*c1, polymulx(c1))/i)
+        return polyadd(c0, polysub(c1, polymulx(c1)))
+
+
+#
+# These are constant arrays are of integer type so as to be compatible
+# with the widest range of other types, such as Decimal.
+#
+
+# Laguerre
+lagdomain = np.array([0., 1.])
+
+# Laguerre coefficients representing zero.
+lagzero = np.array([0])
+
+# Laguerre coefficients representing one.
+lagone = np.array([1])
+
+# Laguerre coefficients representing the identity x.
+lagx = np.array([1, -1])
+
+
+def lagline(off, scl):
+    """
+    Laguerre series whose graph is a straight line.
+
+    Parameters
+    ----------
+    off, scl : scalars
+        The specified line is given by ``off + scl*x``.
+
+    Returns
+    -------
+    y : ndarray
+        This module's representation of the Laguerre series for
+        ``off + scl*x``.
+
+    See Also
+    --------
+    numpy.polynomial.polynomial.polyline
+    numpy.polynomial.chebyshev.chebline
+    numpy.polynomial.legendre.legline
+    numpy.polynomial.hermite.hermline
+    numpy.polynomial.hermite_e.hermeline
+
+    Examples
+    --------
+    >>> from numpy.polynomial.laguerre import lagline, lagval
+    >>> lagval(0,lagline(3, 2))
+    3.0
+    >>> lagval(1,lagline(3, 2))
+    5.0
+
+    """
+    if scl != 0:
+        return np.array([off + scl, -scl])
+    else:
+        return np.array([off])
+
+
+def lagfromroots(roots):
+    """
+    Generate a Laguerre series with given roots.
+
+    The function returns the coefficients of the polynomial
+
+    .. math:: p(x) = (x - r_0) * (x - r_1) * ... * (x - r_n),
+
+    in Laguerre form, where the :math:`r_n` are the roots specified in `roots`.
+    If a zero has multiplicity n, then it must appear in `roots` n times.
+    For instance, if 2 is a root of multiplicity three and 3 is a root of
+    multiplicity 2, then `roots` looks something like [2, 2, 2, 3, 3]. The
+    roots can appear in any order.
+
+    If the returned coefficients are `c`, then
+
+    .. math:: p(x) = c_0 + c_1 * L_1(x) + ... +  c_n * L_n(x)
+
+    The coefficient of the last term is not generally 1 for monic
+    polynomials in Laguerre form.
+
+    Parameters
+    ----------
+    roots : array_like
+        Sequence containing the roots.
+
+    Returns
+    -------
+    out : ndarray
+        1-D array of coefficients.  If all roots are real then `out` is a
+        real array, if some of the roots are complex, then `out` is complex
+        even if all the coefficients in the result are real (see Examples
+        below).
+
+    See Also
+    --------
+    numpy.polynomial.polynomial.polyfromroots
+    numpy.polynomial.legendre.legfromroots
+    numpy.polynomial.chebyshev.chebfromroots
+    numpy.polynomial.hermite.hermfromroots
+    numpy.polynomial.hermite_e.hermefromroots
+
+    Examples
+    --------
+    >>> from numpy.polynomial.laguerre import lagfromroots, lagval
+    >>> coef = lagfromroots((-1, 0, 1))
+    >>> lagval((-1, 0, 1), coef)
+    array([0.,  0.,  0.])
+    >>> coef = lagfromroots((-1j, 1j))
+    >>> lagval((-1j, 1j), coef)
+    array([0.+0.j, 0.+0.j])
+
+    """
+    return pu._fromroots(lagline, lagmul, roots)
+
+
+def lagadd(c1, c2):
+    """
+    Add one Laguerre series to another.
+
+    Returns the sum of two Laguerre series `c1` + `c2`.  The arguments
+    are sequences of coefficients ordered from lowest order term to
+    highest, i.e., [1,2,3] represents the series ``P_0 + 2*P_1 + 3*P_2``.
+
+    Parameters
+    ----------
+    c1, c2 : array_like
+        1-D arrays of Laguerre series coefficients ordered from low to
+        high.
+
+    Returns
+    -------
+    out : ndarray
+        Array representing the Laguerre series of their sum.
+
+    See Also
+    --------
+    lagsub, lagmulx, lagmul, lagdiv, lagpow
+
+    Notes
+    -----
+    Unlike multiplication, division, etc., the sum of two Laguerre series
+    is a Laguerre series (without having to "reproject" the result onto
+    the basis set) so addition, just like that of "standard" polynomials,
+    is simply "component-wise."
+
+    Examples
+    --------
+    >>> from numpy.polynomial.laguerre import lagadd
+    >>> lagadd([1, 2, 3], [1, 2, 3, 4])
+    array([2.,  4.,  6.,  4.])
+
+    """
+    return pu._add(c1, c2)
+
+
+def lagsub(c1, c2):
+    """
+    Subtract one Laguerre series from another.
+
+    Returns the difference of two Laguerre series `c1` - `c2`.  The
+    sequences of coefficients are from lowest order term to highest, i.e.,
+    [1,2,3] represents the series ``P_0 + 2*P_1 + 3*P_2``.
+
+    Parameters
+    ----------
+    c1, c2 : array_like
+        1-D arrays of Laguerre series coefficients ordered from low to
+        high.
+
+    Returns
+    -------
+    out : ndarray
+        Of Laguerre series coefficients representing their difference.
+
+    See Also
+    --------
+    lagadd, lagmulx, lagmul, lagdiv, lagpow
+
+    Notes
+    -----
+    Unlike multiplication, division, etc., the difference of two Laguerre
+    series is a Laguerre series (without having to "reproject" the result
+    onto the basis set) so subtraction, just like that of "standard"
+    polynomials, is simply "component-wise."
+
+    Examples
+    --------
+    >>> from numpy.polynomial.laguerre import lagsub
+    >>> lagsub([1, 2, 3, 4], [1, 2, 3])
+    array([0.,  0.,  0.,  4.])
+
+    """
+    return pu._sub(c1, c2)
+
+
+def lagmulx(c):
+    """Multiply a Laguerre series by x.
+
+    Multiply the Laguerre series `c` by x, where x is the independent
+    variable.
+
+
+    Parameters
+    ----------
+    c : array_like
+        1-D array of Laguerre series coefficients ordered from low to
+        high.
+
+    Returns
+    -------
+    out : ndarray
+        Array representing the result of the multiplication.
+
+    See Also
+    --------
+    lagadd, lagsub, lagmul, lagdiv, lagpow
+
+    Notes
+    -----
+    The multiplication uses the recursion relationship for Laguerre
+    polynomials in the form
+
+    .. math::
+
+        xP_i(x) = (-(i + 1)*P_{i + 1}(x) + (2i + 1)P_{i}(x) - iP_{i - 1}(x))
+
+    Examples
+    --------
+    >>> from numpy.polynomial.laguerre import lagmulx
+    >>> lagmulx([1, 2, 3])
+    array([-1.,  -1.,  11.,  -9.])
+
+    """
+    # c is a trimmed copy
+    [c] = pu.as_series([c])
+    # The zero series needs special treatment
+    if len(c) == 1 and c[0] == 0:
+        return c
+
+    prd = np.empty(len(c) + 1, dtype=c.dtype)
+    prd[0] = c[0]
+    prd[1] = -c[0]
+    for i in range(1, len(c)):
+        prd[i + 1] = -c[i]*(i + 1)
+        prd[i] += c[i]*(2*i + 1)
+        prd[i - 1] -= c[i]*i
+    return prd
+
+
+def lagmul(c1, c2):
+    """
+    Multiply one Laguerre series by another.
+
+    Returns the product of two Laguerre series `c1` * `c2`.  The arguments
+    are sequences of coefficients, from lowest order "term" to highest,
+    e.g., [1,2,3] represents the series ``P_0 + 2*P_1 + 3*P_2``.
+
+    Parameters
+    ----------
+    c1, c2 : array_like
+        1-D arrays of Laguerre series coefficients ordered from low to
+        high.
+
+    Returns
+    -------
+    out : ndarray
+        Of Laguerre series coefficients representing their product.
+
+    See Also
+    --------
+    lagadd, lagsub, lagmulx, lagdiv, lagpow
+
+    Notes
+    -----
+    In general, the (polynomial) product of two C-series results in terms
+    that are not in the Laguerre polynomial basis set.  Thus, to express
+    the product as a Laguerre series, it is necessary to "reproject" the
+    product onto said basis set, which may produce "unintuitive" (but
+    correct) results; see Examples section below.
+
+    Examples
+    --------
+    >>> from numpy.polynomial.laguerre import lagmul
+    >>> lagmul([1, 2, 3], [0, 1, 2])
+    array([  8., -13.,  38., -51.,  36.])
+
+    """
+    # s1, s2 are trimmed copies
+    [c1, c2] = pu.as_series([c1, c2])
+
+    if len(c1) > len(c2):
+        c = c2
+        xs = c1
+    else:
+        c = c1
+        xs = c2
+
+    if len(c) == 1:
+        c0 = c[0]*xs
+        c1 = 0
+    elif len(c) == 2:
+        c0 = c[0]*xs
+        c1 = c[1]*xs
+    else:
+        nd = len(c)
+        c0 = c[-2]*xs
+        c1 = c[-1]*xs
+        for i in range(3, len(c) + 1):
+            tmp = c0
+            nd = nd - 1
+            c0 = lagsub(c[-i]*xs, (c1*(nd - 1))/nd)
+            c1 = lagadd(tmp, lagsub((2*nd - 1)*c1, lagmulx(c1))/nd)
+    return lagadd(c0, lagsub(c1, lagmulx(c1)))
+
+
+def lagdiv(c1, c2):
+    """
+    Divide one Laguerre series by another.
+
+    Returns the quotient-with-remainder of two Laguerre series
+    `c1` / `c2`.  The arguments are sequences of coefficients from lowest
+    order "term" to highest, e.g., [1,2,3] represents the series
+    ``P_0 + 2*P_1 + 3*P_2``.
+
+    Parameters
+    ----------
+    c1, c2 : array_like
+        1-D arrays of Laguerre series coefficients ordered from low to
+        high.
+
+    Returns
+    -------
+    [quo, rem] : ndarrays
+        Of Laguerre series coefficients representing the quotient and
+        remainder.
+
+    See Also
+    --------
+    lagadd, lagsub, lagmulx, lagmul, lagpow
+
+    Notes
+    -----
+    In general, the (polynomial) division of one Laguerre series by another
+    results in quotient and remainder terms that are not in the Laguerre
+    polynomial basis set.  Thus, to express these results as a Laguerre
+    series, it is necessary to "reproject" the results onto the Laguerre
+    basis set, which may produce "unintuitive" (but correct) results; see
+    Examples section below.
+
+    Examples
+    --------
+    >>> from numpy.polynomial.laguerre import lagdiv
+    >>> lagdiv([  8., -13.,  38., -51.,  36.], [0, 1, 2])
+    (array([1., 2., 3.]), array([0.]))
+    >>> lagdiv([  9., -12.,  38., -51.,  36.], [0, 1, 2])
+    (array([1., 2., 3.]), array([1., 1.]))
+
+    """
+    return pu._div(lagmul, c1, c2)
+
+
+def lagpow(c, pow, maxpower=16):
+    """Raise a Laguerre series to a power.
+
+    Returns the Laguerre series `c` raised to the power `pow`. The
+    argument `c` is a sequence of coefficients ordered from low to high.
+    i.e., [1,2,3] is the series  ``P_0 + 2*P_1 + 3*P_2.``
+
+    Parameters
+    ----------
+    c : array_like
+        1-D array of Laguerre series coefficients ordered from low to
+        high.
+    pow : integer
+        Power to which the series will be raised
+    maxpower : integer, optional
+        Maximum power allowed. This is mainly to limit growth of the series
+        to unmanageable size. Default is 16
+
+    Returns
+    -------
+    coef : ndarray
+        Laguerre series of power.
+
+    See Also
+    --------
+    lagadd, lagsub, lagmulx, lagmul, lagdiv
+
+    Examples
+    --------
+    >>> from numpy.polynomial.laguerre import lagpow
+    >>> lagpow([1, 2, 3], 2)
+    array([ 14., -16.,  56., -72.,  54.])
+
+    """
+    return pu._pow(lagmul, c, pow, maxpower)
+
+
+def lagder(c, m=1, scl=1, axis=0):
+    """
+    Differentiate a Laguerre series.
+
+    Returns the Laguerre series coefficients `c` differentiated `m` times
+    along `axis`.  At each iteration the result is multiplied by `scl` (the
+    scaling factor is for use in a linear change of variable). The argument
+    `c` is an array of coefficients from low to high degree along each
+    axis, e.g., [1,2,3] represents the series ``1*L_0 + 2*L_1 + 3*L_2``
+    while [[1,2],[1,2]] represents ``1*L_0(x)*L_0(y) + 1*L_1(x)*L_0(y) +
+    2*L_0(x)*L_1(y) + 2*L_1(x)*L_1(y)`` if axis=0 is ``x`` and axis=1 is
+    ``y``.
+
+    Parameters
+    ----------
+    c : array_like
+        Array of Laguerre series coefficients. If `c` is multidimensional
+        the different axis correspond to different variables with the
+        degree in each axis given by the corresponding index.
+    m : int, optional
+        Number of derivatives taken, must be non-negative. (Default: 1)
+    scl : scalar, optional
+        Each differentiation is multiplied by `scl`.  The end result is
+        multiplication by ``scl**m``.  This is for use in a linear change of
+        variable. (Default: 1)
+    axis : int, optional
+        Axis over which the derivative is taken. (Default: 0).
+
+        .. versionadded:: 1.7.0
+
+    Returns
+    -------
+    der : ndarray
+        Laguerre series of the derivative.
+
+    See Also
+    --------
+    lagint
+
+    Notes
+    -----
+    In general, the result of differentiating a Laguerre series does not
+    resemble the same operation on a power series. Thus the result of this
+    function may be "unintuitive," albeit correct; see Examples section
+    below.
+
+    Examples
+    --------
+    >>> from numpy.polynomial.laguerre import lagder
+    >>> lagder([ 1.,  1.,  1., -3.])
+    array([1.,  2.,  3.])
+    >>> lagder([ 1.,  0.,  0., -4.,  3.], m=2)
+    array([1.,  2.,  3.])
+
+    """
+    c = np.array(c, ndmin=1, copy=True)
+    if c.dtype.char in '?bBhHiIlLqQpP':
+        c = c.astype(np.double)
+
+    cnt = pu._as_int(m, "the order of derivation")
+    iaxis = pu._as_int(axis, "the axis")
+    if cnt < 0:
+        raise ValueError("The order of derivation must be non-negative")
+    iaxis = normalize_axis_index(iaxis, c.ndim)
+
+    if cnt == 0:
+        return c
+
+    c = np.moveaxis(c, iaxis, 0)
+    n = len(c)
+    if cnt >= n:
+        c = c[:1]*0
+    else:
+        for i in range(cnt):
+            n = n - 1
+            c *= scl
+            der = np.empty((n,) + c.shape[1:], dtype=c.dtype)
+            for j in range(n, 1, -1):
+                der[j - 1] = -c[j]
+                c[j - 1] += c[j]
+            der[0] = -c[1]
+            c = der
+    c = np.moveaxis(c, 0, iaxis)
+    return c
+
+
+def lagint(c, m=1, k=[], lbnd=0, scl=1, axis=0):
+    """
+    Integrate a Laguerre series.
+
+    Returns the Laguerre series coefficients `c` integrated `m` times from
+    `lbnd` along `axis`. At each iteration the resulting series is
+    **multiplied** by `scl` and an integration constant, `k`, is added.
+    The scaling factor is for use in a linear change of variable.  ("Buyer
+    beware": note that, depending on what one is doing, one may want `scl`
+    to be the reciprocal of what one might expect; for more information,
+    see the Notes section below.)  The argument `c` is an array of
+    coefficients from low to high degree along each axis, e.g., [1,2,3]
+    represents the series ``L_0 + 2*L_1 + 3*L_2`` while [[1,2],[1,2]]
+    represents ``1*L_0(x)*L_0(y) + 1*L_1(x)*L_0(y) + 2*L_0(x)*L_1(y) +
+    2*L_1(x)*L_1(y)`` if axis=0 is ``x`` and axis=1 is ``y``.
+
+
+    Parameters
+    ----------
+    c : array_like
+        Array of Laguerre series coefficients. If `c` is multidimensional
+        the different axis correspond to different variables with the
+        degree in each axis given by the corresponding index.
+    m : int, optional
+        Order of integration, must be positive. (Default: 1)
+    k : {[], list, scalar}, optional
+        Integration constant(s).  The value of the first integral at
+        ``lbnd`` is the first value in the list, the value of the second
+        integral at ``lbnd`` is the second value, etc.  If ``k == []`` (the
+        default), all constants are set to zero.  If ``m == 1``, a single
+        scalar can be given instead of a list.
+    lbnd : scalar, optional
+        The lower bound of the integral. (Default: 0)
+    scl : scalar, optional
+        Following each integration the result is *multiplied* by `scl`
+        before the integration constant is added. (Default: 1)
+    axis : int, optional
+        Axis over which the integral is taken. (Default: 0).
+
+        .. versionadded:: 1.7.0
+
+    Returns
+    -------
+    S : ndarray
+        Laguerre series coefficients of the integral.
+
+    Raises
+    ------
+    ValueError
+        If ``m < 0``, ``len(k) > m``, ``np.ndim(lbnd) != 0``, or
+        ``np.ndim(scl) != 0``.
+
+    See Also
+    --------
+    lagder
+
+    Notes
+    -----
+    Note that the result of each integration is *multiplied* by `scl`.
+    Why is this important to note?  Say one is making a linear change of
+    variable :math:`u = ax + b` in an integral relative to `x`.  Then
+    :math:`dx = du/a`, so one will need to set `scl` equal to
+    :math:`1/a` - perhaps not what one would have first thought.
+
+    Also note that, in general, the result of integrating a C-series needs
+    to be "reprojected" onto the C-series basis set.  Thus, typically,
+    the result of this function is "unintuitive," albeit correct; see
+    Examples section below.
+
+    Examples
+    --------
+    >>> from numpy.polynomial.laguerre import lagint
+    >>> lagint([1,2,3])
+    array([ 1.,  1.,  1., -3.])
+    >>> lagint([1,2,3], m=2)
+    array([ 1.,  0.,  0., -4.,  3.])
+    >>> lagint([1,2,3], k=1)
+    array([ 2.,  1.,  1., -3.])
+    >>> lagint([1,2,3], lbnd=-1)
+    array([11.5,  1. ,  1. , -3. ])
+    >>> lagint([1,2], m=2, k=[1,2], lbnd=-1)
+    array([ 11.16666667,  -5.        ,  -3.        ,   2.        ]) # may vary
+
+    """
+    c = np.array(c, ndmin=1, copy=True)
+    if c.dtype.char in '?bBhHiIlLqQpP':
+        c = c.astype(np.double)
+    if not np.iterable(k):
+        k = [k]
+    cnt = pu._as_int(m, "the order of integration")
+    iaxis = pu._as_int(axis, "the axis")
+    if cnt < 0:
+        raise ValueError("The order of integration must be non-negative")
+    if len(k) > cnt:
+        raise ValueError("Too many integration constants")
+    if np.ndim(lbnd) != 0:
+        raise ValueError("lbnd must be a scalar.")
+    if np.ndim(scl) != 0:
+        raise ValueError("scl must be a scalar.")
+    iaxis = normalize_axis_index(iaxis, c.ndim)
+
+    if cnt == 0:
+        return c
+
+    c = np.moveaxis(c, iaxis, 0)
+    k = list(k) + [0]*(cnt - len(k))
+    for i in range(cnt):
+        n = len(c)
+        c *= scl
+        if n == 1 and np.all(c[0] == 0):
+            c[0] += k[i]
+        else:
+            tmp = np.empty((n + 1,) + c.shape[1:], dtype=c.dtype)
+            tmp[0] = c[0]
+            tmp[1] = -c[0]
+            for j in range(1, n):
+                tmp[j] += c[j]
+                tmp[j + 1] = -c[j]
+            tmp[0] += k[i] - lagval(lbnd, tmp)
+            c = tmp
+    c = np.moveaxis(c, 0, iaxis)
+    return c
+
+
+def lagval(x, c, tensor=True):
+    """
+    Evaluate a Laguerre series at points x.
+
+    If `c` is of length ``n + 1``, this function returns the value:
+
+    .. math:: p(x) = c_0 * L_0(x) + c_1 * L_1(x) + ... + c_n * L_n(x)
+
+    The parameter `x` is converted to an array only if it is a tuple or a
+    list, otherwise it is treated as a scalar. In either case, either `x`
+    or its elements must support multiplication and addition both with
+    themselves and with the elements of `c`.
+
+    If `c` is a 1-D array, then ``p(x)`` will have the same shape as `x`.  If
+    `c` is multidimensional, then the shape of the result depends on the
+    value of `tensor`. If `tensor` is true the shape will be c.shape[1:] +
+    x.shape. If `tensor` is false the shape will be c.shape[1:]. Note that
+    scalars have shape (,).
+
+    Trailing zeros in the coefficients will be used in the evaluation, so
+    they should be avoided if efficiency is a concern.
+
+    Parameters
+    ----------
+    x : array_like, compatible object
+        If `x` is a list or tuple, it is converted to an ndarray, otherwise
+        it is left unchanged and treated as a scalar. In either case, `x`
+        or its elements must support addition and multiplication with
+        themselves and with the elements of `c`.
+    c : array_like
+        Array of coefficients ordered so that the coefficients for terms of
+        degree n are contained in c[n]. If `c` is multidimensional the
+        remaining indices enumerate multiple polynomials. In the two
+        dimensional case the coefficients may be thought of as stored in
+        the columns of `c`.
+    tensor : boolean, optional
+        If True, the shape of the coefficient array is extended with ones
+        on the right, one for each dimension of `x`. Scalars have dimension 0
+        for this action. The result is that every column of coefficients in
+        `c` is evaluated for every element of `x`. If False, `x` is broadcast
+        over the columns of `c` for the evaluation.  This keyword is useful
+        when `c` is multidimensional. The default value is True.
+
+        .. versionadded:: 1.7.0
+
+    Returns
+    -------
+    values : ndarray, algebra_like
+        The shape of the return value is described above.
+
+    See Also
+    --------
+    lagval2d, laggrid2d, lagval3d, laggrid3d
+
+    Notes
+    -----
+    The evaluation uses Clenshaw recursion, aka synthetic division.
+
+    Examples
+    --------
+    >>> from numpy.polynomial.laguerre import lagval
+    >>> coef = [1, 2, 3]
+    >>> lagval(1, coef)
+    -0.5
+    >>> lagval([[1, 2],[3, 4]], coef)
+    array([[-0.5, -4. ],
+           [-4.5, -2. ]])
+
+    """
+    c = np.array(c, ndmin=1, copy=None)
+    if c.dtype.char in '?bBhHiIlLqQpP':
+        c = c.astype(np.double)
+    if isinstance(x, (tuple, list)):
+        x = np.asarray(x)
+    if isinstance(x, np.ndarray) and tensor:
+        c = c.reshape(c.shape + (1,)*x.ndim)
+
+    if len(c) == 1:
+        c0 = c[0]
+        c1 = 0
+    elif len(c) == 2:
+        c0 = c[0]
+        c1 = c[1]
+    else:
+        nd = len(c)
+        c0 = c[-2]
+        c1 = c[-1]
+        for i in range(3, len(c) + 1):
+            tmp = c0
+            nd = nd - 1
+            c0 = c[-i] - (c1*(nd - 1))/nd
+            c1 = tmp + (c1*((2*nd - 1) - x))/nd
+    return c0 + c1*(1 - x)
+
+
+def lagval2d(x, y, c):
+    """
+    Evaluate a 2-D Laguerre series at points (x, y).
+
+    This function returns the values:
+
+    .. math:: p(x,y) = \\sum_{i,j} c_{i,j} * L_i(x) * L_j(y)
+
+    The parameters `x` and `y` are converted to arrays only if they are
+    tuples or a lists, otherwise they are treated as a scalars and they
+    must have the same shape after conversion. In either case, either `x`
+    and `y` or their elements must support multiplication and addition both
+    with themselves and with the elements of `c`.
+
+    If `c` is a 1-D array a one is implicitly appended to its shape to make
+    it 2-D. The shape of the result will be c.shape[2:] + x.shape.
+
+    Parameters
+    ----------
+    x, y : array_like, compatible objects
+        The two dimensional series is evaluated at the points ``(x, y)``,
+        where `x` and `y` must have the same shape. If `x` or `y` is a list
+        or tuple, it is first converted to an ndarray, otherwise it is left
+        unchanged and if it isn't an ndarray it is treated as a scalar.
+    c : array_like
+        Array of coefficients ordered so that the coefficient of the term
+        of multi-degree i,j is contained in ``c[i,j]``. If `c` has
+        dimension greater than two the remaining indices enumerate multiple
+        sets of coefficients.
+
+    Returns
+    -------
+    values : ndarray, compatible object
+        The values of the two dimensional polynomial at points formed with
+        pairs of corresponding values from `x` and `y`.
+
+    See Also
+    --------
+    lagval, laggrid2d, lagval3d, laggrid3d
+
+    Notes
+    -----
+
+    .. versionadded:: 1.7.0
+
+    Examples
+    --------
+    >>> from numpy.polynomial.laguerre import lagval2d
+    >>> c = [[1, 2],[3, 4]]
+    >>> lagval2d(1, 1, c)
+    1.0
+    """
+    return pu._valnd(lagval, c, x, y)
+
+
+def laggrid2d(x, y, c):
+    """
+    Evaluate a 2-D Laguerre series on the Cartesian product of x and y.
+
+    This function returns the values:
+
+    .. math:: p(a,b) = \\sum_{i,j} c_{i,j} * L_i(a) * L_j(b)
+
+    where the points ``(a, b)`` consist of all pairs formed by taking
+    `a` from `x` and `b` from `y`. The resulting points form a grid with
+    `x` in the first dimension and `y` in the second.
+
+    The parameters `x` and `y` are converted to arrays only if they are
+    tuples or a lists, otherwise they are treated as a scalars. In either
+    case, either `x` and `y` or their elements must support multiplication
+    and addition both with themselves and with the elements of `c`.
+
+    If `c` has fewer than two dimensions, ones are implicitly appended to
+    its shape to make it 2-D. The shape of the result will be c.shape[2:] +
+    x.shape + y.shape.
+
+    Parameters
+    ----------
+    x, y : array_like, compatible objects
+        The two dimensional series is evaluated at the points in the
+        Cartesian product of `x` and `y`.  If `x` or `y` is a list or
+        tuple, it is first converted to an ndarray, otherwise it is left
+        unchanged and, if it isn't an ndarray, it is treated as a scalar.
+    c : array_like
+        Array of coefficients ordered so that the coefficient of the term of
+        multi-degree i,j is contained in ``c[i,j]``. If `c` has dimension
+        greater than two the remaining indices enumerate multiple sets of
+        coefficients.
+
+    Returns
+    -------
+    values : ndarray, compatible object
+        The values of the two dimensional Chebyshev series at points in the
+        Cartesian product of `x` and `y`.
+
+    See Also
+    --------
+    lagval, lagval2d, lagval3d, laggrid3d
+
+    Notes
+    -----
+
+    .. versionadded:: 1.7.0
+
+    Examples
+    --------
+    >>> from numpy.polynomial.laguerre import laggrid2d
+    >>> c = [[1, 2], [3, 4]]
+    >>> laggrid2d([0, 1], [0, 1], c)
+    array([[10.,  4.],
+           [ 3.,  1.]])
+
+    """
+    return pu._gridnd(lagval, c, x, y)
+
+
+def lagval3d(x, y, z, c):
+    """
+    Evaluate a 3-D Laguerre series at points (x, y, z).
+
+    This function returns the values:
+
+    .. math:: p(x,y,z) = \\sum_{i,j,k} c_{i,j,k} * L_i(x) * L_j(y) * L_k(z)
+
+    The parameters `x`, `y`, and `z` are converted to arrays only if
+    they are tuples or a lists, otherwise they are treated as a scalars and
+    they must have the same shape after conversion. In either case, either
+    `x`, `y`, and `z` or their elements must support multiplication and
+    addition both with themselves and with the elements of `c`.
+
+    If `c` has fewer than 3 dimensions, ones are implicitly appended to its
+    shape to make it 3-D. The shape of the result will be c.shape[3:] +
+    x.shape.
+
+    Parameters
+    ----------
+    x, y, z : array_like, compatible object
+        The three dimensional series is evaluated at the points
+        ``(x, y, z)``, where `x`, `y`, and `z` must have the same shape.  If
+        any of `x`, `y`, or `z` is a list or tuple, it is first converted
+        to an ndarray, otherwise it is left unchanged and if it isn't an
+        ndarray it is  treated as a scalar.
+    c : array_like
+        Array of coefficients ordered so that the coefficient of the term of
+        multi-degree i,j,k is contained in ``c[i,j,k]``. If `c` has dimension
+        greater than 3 the remaining indices enumerate multiple sets of
+        coefficients.
+
+    Returns
+    -------
+    values : ndarray, compatible object
+        The values of the multidimensional polynomial on points formed with
+        triples of corresponding values from `x`, `y`, and `z`.
+
+    See Also
+    --------
+    lagval, lagval2d, laggrid2d, laggrid3d
+
+    Notes
+    -----
+
+    .. versionadded:: 1.7.0
+
+    Examples
+    --------
+    >>> from numpy.polynomial.laguerre import lagval3d
+    >>> c = [[[1, 2], [3, 4]], [[5, 6], [7, 8]]]
+    >>> lagval3d(1, 1, 2, c)
+    -1.0
+
+    """
+    return pu._valnd(lagval, c, x, y, z)
+
+
+def laggrid3d(x, y, z, c):
+    """
+    Evaluate a 3-D Laguerre series on the Cartesian product of x, y, and z.
+
+    This function returns the values:
+
+    .. math:: p(a,b,c) = \\sum_{i,j,k} c_{i,j,k} * L_i(a) * L_j(b) * L_k(c)
+
+    where the points ``(a, b, c)`` consist of all triples formed by taking
+    `a` from `x`, `b` from `y`, and `c` from `z`. The resulting points form
+    a grid with `x` in the first dimension, `y` in the second, and `z` in
+    the third.
+
+    The parameters `x`, `y`, and `z` are converted to arrays only if they
+    are tuples or a lists, otherwise they are treated as a scalars. In
+    either case, either `x`, `y`, and `z` or their elements must support
+    multiplication and addition both with themselves and with the elements
+    of `c`.
+
+    If `c` has fewer than three dimensions, ones are implicitly appended to
+    its shape to make it 3-D. The shape of the result will be c.shape[3:] +
+    x.shape + y.shape + z.shape.
+
+    Parameters
+    ----------
+    x, y, z : array_like, compatible objects
+        The three dimensional series is evaluated at the points in the
+        Cartesian product of `x`, `y`, and `z`.  If `x`, `y`, or `z` is a
+        list or tuple, it is first converted to an ndarray, otherwise it is
+        left unchanged and, if it isn't an ndarray, it is treated as a
+        scalar.
+    c : array_like
+        Array of coefficients ordered so that the coefficients for terms of
+        degree i,j are contained in ``c[i,j]``. If `c` has dimension
+        greater than two the remaining indices enumerate multiple sets of
+        coefficients.
+
+    Returns
+    -------
+    values : ndarray, compatible object
+        The values of the two dimensional polynomial at points in the Cartesian
+        product of `x` and `y`.
+
+    See Also
+    --------
+    lagval, lagval2d, laggrid2d, lagval3d
+
+    Notes
+    -----
+
+    .. versionadded:: 1.7.0
+
+    Examples
+    --------
+    >>> from numpy.polynomial.laguerre import laggrid3d
+    >>> c = [[[1, 2], [3, 4]], [[5, 6], [7, 8]]]
+    >>> laggrid3d([0, 1], [0, 1], [2, 4], c)
+    array([[[ -4., -44.],
+            [ -2., -18.]],
+           [[ -2., -14.],
+            [ -1.,  -5.]]])
+
+    """
+    return pu._gridnd(lagval, c, x, y, z)
+
+
+def lagvander(x, deg):
+    """Pseudo-Vandermonde matrix of given degree.
+
+    Returns the pseudo-Vandermonde matrix of degree `deg` and sample points
+    `x`. The pseudo-Vandermonde matrix is defined by
+
+    .. math:: V[..., i] = L_i(x)
+
+    where ``0 <= i <= deg``. The leading indices of `V` index the elements of
+    `x` and the last index is the degree of the Laguerre polynomial.
+
+    If `c` is a 1-D array of coefficients of length ``n + 1`` and `V` is the
+    array ``V = lagvander(x, n)``, then ``np.dot(V, c)`` and
+    ``lagval(x, c)`` are the same up to roundoff. This equivalence is
+    useful both for least squares fitting and for the evaluation of a large
+    number of Laguerre series of the same degree and sample points.
+
+    Parameters
+    ----------
+    x : array_like
+        Array of points. The dtype is converted to float64 or complex128
+        depending on whether any of the elements are complex. If `x` is
+        scalar it is converted to a 1-D array.
+    deg : int
+        Degree of the resulting matrix.
+
+    Returns
+    -------
+    vander : ndarray
+        The pseudo-Vandermonde matrix. The shape of the returned matrix is
+        ``x.shape + (deg + 1,)``, where The last index is the degree of the
+        corresponding Laguerre polynomial.  The dtype will be the same as
+        the converted `x`.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from numpy.polynomial.laguerre import lagvander
+    >>> x = np.array([0, 1, 2])
+    >>> lagvander(x, 3)
+    array([[ 1.        ,  1.        ,  1.        ,  1.        ],
+           [ 1.        ,  0.        , -0.5       , -0.66666667],
+           [ 1.        , -1.        , -1.        , -0.33333333]])
+
+    """
+    ideg = pu._as_int(deg, "deg")
+    if ideg < 0:
+        raise ValueError("deg must be non-negative")
+
+    x = np.array(x, copy=None, ndmin=1) + 0.0
+    dims = (ideg + 1,) + x.shape
+    dtyp = x.dtype
+    v = np.empty(dims, dtype=dtyp)
+    v[0] = x*0 + 1
+    if ideg > 0:
+        v[1] = 1 - x
+        for i in range(2, ideg + 1):
+            v[i] = (v[i-1]*(2*i - 1 - x) - v[i-2]*(i - 1))/i
+    return np.moveaxis(v, 0, -1)
+
+
+def lagvander2d(x, y, deg):
+    """Pseudo-Vandermonde matrix of given degrees.
+
+    Returns the pseudo-Vandermonde matrix of degrees `deg` and sample
+    points ``(x, y)``. The pseudo-Vandermonde matrix is defined by
+
+    .. math:: V[..., (deg[1] + 1)*i + j] = L_i(x) * L_j(y),
+
+    where ``0 <= i <= deg[0]`` and ``0 <= j <= deg[1]``. The leading indices of
+    `V` index the points ``(x, y)`` and the last index encodes the degrees of
+    the Laguerre polynomials.
+
+    If ``V = lagvander2d(x, y, [xdeg, ydeg])``, then the columns of `V`
+    correspond to the elements of a 2-D coefficient array `c` of shape
+    (xdeg + 1, ydeg + 1) in the order
+
+    .. math:: c_{00}, c_{01}, c_{02} ... , c_{10}, c_{11}, c_{12} ...
+
+    and ``np.dot(V, c.flat)`` and ``lagval2d(x, y, c)`` will be the same
+    up to roundoff. This equivalence is useful both for least squares
+    fitting and for the evaluation of a large number of 2-D Laguerre
+    series of the same degrees and sample points.
+
+    Parameters
+    ----------
+    x, y : array_like
+        Arrays of point coordinates, all of the same shape. The dtypes
+        will be converted to either float64 or complex128 depending on
+        whether any of the elements are complex. Scalars are converted to
+        1-D arrays.
+    deg : list of ints
+        List of maximum degrees of the form [x_deg, y_deg].
+
+    Returns
+    -------
+    vander2d : ndarray
+        The shape of the returned matrix is ``x.shape + (order,)``, where
+        :math:`order = (deg[0]+1)*(deg[1]+1)`.  The dtype will be the same
+        as the converted `x` and `y`.
+
+    See Also
+    --------
+    lagvander, lagvander3d, lagval2d, lagval3d
+
+    Notes
+    -----
+
+    .. versionadded:: 1.7.0
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from numpy.polynomial.laguerre import lagvander2d
+    >>> x = np.array([0])
+    >>> y = np.array([2])
+    >>> lagvander2d(x, y, [2, 1])
+    array([[ 1., -1.,  1., -1.,  1., -1.]])
+
+    """
+    return pu._vander_nd_flat((lagvander, lagvander), (x, y), deg)
+
+
+def lagvander3d(x, y, z, deg):
+    """Pseudo-Vandermonde matrix of given degrees.
+
+    Returns the pseudo-Vandermonde matrix of degrees `deg` and sample
+    points ``(x, y, z)``. If `l`, `m`, `n` are the given degrees in `x`, `y`, `z`,
+    then The pseudo-Vandermonde matrix is defined by
+
+    .. math:: V[..., (m+1)(n+1)i + (n+1)j + k] = L_i(x)*L_j(y)*L_k(z),
+
+    where ``0 <= i <= l``, ``0 <= j <= m``, and ``0 <= j <= n``.  The leading
+    indices of `V` index the points ``(x, y, z)`` and the last index encodes
+    the degrees of the Laguerre polynomials.
+
+    If ``V = lagvander3d(x, y, z, [xdeg, ydeg, zdeg])``, then the columns
+    of `V` correspond to the elements of a 3-D coefficient array `c` of
+    shape (xdeg + 1, ydeg + 1, zdeg + 1) in the order
+
+    .. math:: c_{000}, c_{001}, c_{002},... , c_{010}, c_{011}, c_{012},...
+
+    and  ``np.dot(V, c.flat)`` and ``lagval3d(x, y, z, c)`` will be the
+    same up to roundoff. This equivalence is useful both for least squares
+    fitting and for the evaluation of a large number of 3-D Laguerre
+    series of the same degrees and sample points.
+
+    Parameters
+    ----------
+    x, y, z : array_like
+        Arrays of point coordinates, all of the same shape. The dtypes will
+        be converted to either float64 or complex128 depending on whether
+        any of the elements are complex. Scalars are converted to 1-D
+        arrays.
+    deg : list of ints
+        List of maximum degrees of the form [x_deg, y_deg, z_deg].
+
+    Returns
+    -------
+    vander3d : ndarray
+        The shape of the returned matrix is ``x.shape + (order,)``, where
+        :math:`order = (deg[0]+1)*(deg[1]+1)*(deg[2]+1)`.  The dtype will
+        be the same as the converted `x`, `y`, and `z`.
+
+    See Also
+    --------
+    lagvander, lagvander3d, lagval2d, lagval3d
+
+    Notes
+    -----
+
+    .. versionadded:: 1.7.0
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from numpy.polynomial.laguerre import lagvander3d
+    >>> x = np.array([0])
+    >>> y = np.array([2])
+    >>> z = np.array([0])
+    >>> lagvander3d(x, y, z, [2, 1, 3])
+    array([[ 1.,  1.,  1.,  1., -1., -1., -1., -1.,  1.,  1.,  1.,  1., -1.,
+            -1., -1., -1.,  1.,  1.,  1.,  1., -1., -1., -1., -1.]])
+
+    """
+    return pu._vander_nd_flat((lagvander, lagvander, lagvander), (x, y, z), deg)
+
+
+def lagfit(x, y, deg, rcond=None, full=False, w=None):
+    """
+    Least squares fit of Laguerre series to data.
+
+    Return the coefficients of a Laguerre series of degree `deg` that is the
+    least squares fit to the data values `y` given at points `x`. If `y` is
+    1-D the returned coefficients will also be 1-D. If `y` is 2-D multiple
+    fits are done, one for each column of `y`, and the resulting
+    coefficients are stored in the corresponding columns of a 2-D return.
+    The fitted polynomial(s) are in the form
+
+    .. math::  p(x) = c_0 + c_1 * L_1(x) + ... + c_n * L_n(x),
+
+    where ``n`` is `deg`.
+
+    Parameters
+    ----------
+    x : array_like, shape (M,)
+        x-coordinates of the M sample points ``(x[i], y[i])``.
+    y : array_like, shape (M,) or (M, K)
+        y-coordinates of the sample points. Several data sets of sample
+        points sharing the same x-coordinates can be fitted at once by
+        passing in a 2D-array that contains one dataset per column.
+    deg : int or 1-D array_like
+        Degree(s) of the fitting polynomials. If `deg` is a single integer
+        all terms up to and including the `deg`'th term are included in the
+        fit. For NumPy versions >= 1.11.0 a list of integers specifying the
+        degrees of the terms to include may be used instead.
+    rcond : float, optional
+        Relative condition number of the fit. Singular values smaller than
+        this relative to the largest singular value will be ignored. The
+        default value is len(x)*eps, where eps is the relative precision of
+        the float type, about 2e-16 in most cases.
+    full : bool, optional
+        Switch determining nature of return value. When it is False (the
+        default) just the coefficients are returned, when True diagnostic
+        information from the singular value decomposition is also returned.
+    w : array_like, shape (`M`,), optional
+        Weights. If not None, the weight ``w[i]`` applies to the unsquared
+        residual ``y[i] - y_hat[i]`` at ``x[i]``. Ideally the weights are
+        chosen so that the errors of the products ``w[i]*y[i]`` all have the
+        same variance.  When using inverse-variance weighting, use
+        ``w[i] = 1/sigma(y[i])``.  The default value is None.
+
+    Returns
+    -------
+    coef : ndarray, shape (M,) or (M, K)
+        Laguerre coefficients ordered from low to high. If `y` was 2-D,
+        the coefficients for the data in column *k*  of `y` are in column
+        *k*.
+
+    [residuals, rank, singular_values, rcond] : list
+        These values are only returned if ``full == True``
+
+        - residuals -- sum of squared residuals of the least squares fit
+        - rank -- the numerical rank of the scaled Vandermonde matrix
+        - singular_values -- singular values of the scaled Vandermonde matrix
+        - rcond -- value of `rcond`.
+
+        For more details, see `numpy.linalg.lstsq`.
+
+    Warns
+    -----
+    RankWarning
+        The rank of the coefficient matrix in the least-squares fit is
+        deficient. The warning is only raised if ``full == False``.  The
+        warnings can be turned off by
+
+        >>> import warnings
+        >>> warnings.simplefilter('ignore', np.exceptions.RankWarning)
+
+    See Also
+    --------
+    numpy.polynomial.polynomial.polyfit
+    numpy.polynomial.legendre.legfit
+    numpy.polynomial.chebyshev.chebfit
+    numpy.polynomial.hermite.hermfit
+    numpy.polynomial.hermite_e.hermefit
+    lagval : Evaluates a Laguerre series.
+    lagvander : pseudo Vandermonde matrix of Laguerre series.
+    lagweight : Laguerre weight function.
+    numpy.linalg.lstsq : Computes a least-squares fit from the matrix.
+    scipy.interpolate.UnivariateSpline : Computes spline fits.
+
+    Notes
+    -----
+    The solution is the coefficients of the Laguerre series ``p`` that
+    minimizes the sum of the weighted squared errors
+
+    .. math:: E = \\sum_j w_j^2 * |y_j - p(x_j)|^2,
+
+    where the :math:`w_j` are the weights. This problem is solved by
+    setting up as the (typically) overdetermined matrix equation
+
+    .. math:: V(x) * c = w * y,
+
+    where ``V`` is the weighted pseudo Vandermonde matrix of `x`, ``c`` are the
+    coefficients to be solved for, `w` are the weights, and `y` are the
+    observed values.  This equation is then solved using the singular value
+    decomposition of ``V``.
+
+    If some of the singular values of `V` are so small that they are
+    neglected, then a `~exceptions.RankWarning` will be issued. This means that
+    the coefficient values may be poorly determined. Using a lower order fit
+    will usually get rid of the warning.  The `rcond` parameter can also be
+    set to a value smaller than its default, but the resulting fit may be
+    spurious and have large contributions from roundoff error.
+
+    Fits using Laguerre series are probably most useful when the data can
+    be approximated by ``sqrt(w(x)) * p(x)``, where ``w(x)`` is the Laguerre
+    weight. In that case the weight ``sqrt(w(x[i]))`` should be used
+    together with data values ``y[i]/sqrt(w(x[i]))``. The weight function is
+    available as `lagweight`.
+
+    References
+    ----------
+    .. [1] Wikipedia, "Curve fitting",
+           https://en.wikipedia.org/wiki/Curve_fitting
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from numpy.polynomial.laguerre import lagfit, lagval
+    >>> x = np.linspace(0, 10)
+    >>> rng = np.random.default_rng()
+    >>> err = rng.normal(scale=1./10, size=len(x))
+    >>> y = lagval(x, [1, 2, 3]) + err
+    >>> lagfit(x, y, 2)
+    array([1.00578369, 1.99417356, 2.99827656]) # may vary
+
+    """
+    return pu._fit(lagvander, x, y, deg, rcond, full, w)
+
+
+def lagcompanion(c):
+    """
+    Return the companion matrix of c.
+
+    The usual companion matrix of the Laguerre polynomials is already
+    symmetric when `c` is a basis Laguerre polynomial, so no scaling is
+    applied.
+
+    Parameters
+    ----------
+    c : array_like
+        1-D array of Laguerre series coefficients ordered from low to high
+        degree.
+
+    Returns
+    -------
+    mat : ndarray
+        Companion matrix of dimensions (deg, deg).
+
+    Notes
+    -----
+
+    .. versionadded:: 1.7.0
+
+    Examples
+    --------
+    >>> from numpy.polynomial.laguerre import lagcompanion
+    >>> lagcompanion([1, 2, 3])
+    array([[ 1.        , -0.33333333],
+           [-1.        ,  4.33333333]])
+
+    """
+    # c is a trimmed copy
+    [c] = pu.as_series([c])
+    if len(c) < 2:
+        raise ValueError('Series must have maximum degree of at least 1.')
+    if len(c) == 2:
+        return np.array([[1 + c[0]/c[1]]])
+
+    n = len(c) - 1
+    mat = np.zeros((n, n), dtype=c.dtype)
+    top = mat.reshape(-1)[1::n+1]
+    mid = mat.reshape(-1)[0::n+1]
+    bot = mat.reshape(-1)[n::n+1]
+    top[...] = -np.arange(1, n)
+    mid[...] = 2.*np.arange(n) + 1.
+    bot[...] = top
+    mat[:, -1] += (c[:-1]/c[-1])*n
+    return mat
+
+
+def lagroots(c):
+    """
+    Compute the roots of a Laguerre series.
+
+    Return the roots (a.k.a. "zeros") of the polynomial
+
+    .. math:: p(x) = \\sum_i c[i] * L_i(x).
+
+    Parameters
+    ----------
+    c : 1-D array_like
+        1-D array of coefficients.
+
+    Returns
+    -------
+    out : ndarray
+        Array of the roots of the series. If all the roots are real,
+        then `out` is also real, otherwise it is complex.
+
+    See Also
+    --------
+    numpy.polynomial.polynomial.polyroots
+    numpy.polynomial.legendre.legroots
+    numpy.polynomial.chebyshev.chebroots
+    numpy.polynomial.hermite.hermroots
+    numpy.polynomial.hermite_e.hermeroots
+
+    Notes
+    -----
+    The root estimates are obtained as the eigenvalues of the companion
+    matrix, Roots far from the origin of the complex plane may have large
+    errors due to the numerical instability of the series for such
+    values. Roots with multiplicity greater than 1 will also show larger
+    errors as the value of the series near such points is relatively
+    insensitive to errors in the roots. Isolated roots near the origin can
+    be improved by a few iterations of Newton's method.
+
+    The Laguerre series basis polynomials aren't powers of `x` so the
+    results of this function may seem unintuitive.
+
+    Examples
+    --------
+    >>> from numpy.polynomial.laguerre import lagroots, lagfromroots
+    >>> coef = lagfromroots([0, 1, 2])
+    >>> coef
+    array([  2.,  -8.,  12.,  -6.])
+    >>> lagroots(coef)
+    array([-4.4408921e-16,  1.0000000e+00,  2.0000000e+00])
+
+    """
+    # c is a trimmed copy
+    [c] = pu.as_series([c])
+    if len(c) <= 1:
+        return np.array([], dtype=c.dtype)
+    if len(c) == 2:
+        return np.array([1 + c[0]/c[1]])
+
+    # rotated companion matrix reduces error
+    m = lagcompanion(c)[::-1,::-1]
+    r = la.eigvals(m)
+    r.sort()
+    return r
+
+
+def laggauss(deg):
+    """
+    Gauss-Laguerre quadrature.
+
+    Computes the sample points and weights for Gauss-Laguerre quadrature.
+    These sample points and weights will correctly integrate polynomials of
+    degree :math:`2*deg - 1` or less over the interval :math:`[0, \\inf]`
+    with the weight function :math:`f(x) = \\exp(-x)`.
+
+    Parameters
+    ----------
+    deg : int
+        Number of sample points and weights. It must be >= 1.
+
+    Returns
+    -------
+    x : ndarray
+        1-D ndarray containing the sample points.
+    y : ndarray
+        1-D ndarray containing the weights.
+
+    Notes
+    -----
+
+    .. versionadded:: 1.7.0
+
+    The results have only been tested up to degree 100 higher degrees may
+    be problematic. The weights are determined by using the fact that
+
+    .. math:: w_k = c / (L'_n(x_k) * L_{n-1}(x_k))
+
+    where :math:`c` is a constant independent of :math:`k` and :math:`x_k`
+    is the k'th root of :math:`L_n`, and then scaling the results to get
+    the right value when integrating 1.
+
+    Examples
+    --------
+    >>> from numpy.polynomial.laguerre import laggauss
+    >>> laggauss(2)
+    (array([0.58578644, 3.41421356]), array([0.85355339, 0.14644661]))
+
+    """
+    ideg = pu._as_int(deg, "deg")
+    if ideg <= 0:
+        raise ValueError("deg must be a positive integer")
+
+    # first approximation of roots. We use the fact that the companion
+    # matrix is symmetric in this case in order to obtain better zeros.
+    c = np.array([0]*deg + [1])
+    m = lagcompanion(c)
+    x = la.eigvalsh(m)
+
+    # improve roots by one application of Newton
+    dy = lagval(x, c)
+    df = lagval(x, lagder(c))
+    x -= dy/df
+
+    # compute the weights. We scale the factor to avoid possible numerical
+    # overflow.
+    fm = lagval(x, c[1:])
+    fm /= np.abs(fm).max()
+    df /= np.abs(df).max()
+    w = 1/(fm * df)
+
+    # scale w to get the right value, 1 in this case
+    w /= w.sum()
+
+    return x, w
+
+
+def lagweight(x):
+    """Weight function of the Laguerre polynomials.
+
+    The weight function is :math:`exp(-x)` and the interval of integration
+    is :math:`[0, \\inf]`. The Laguerre polynomials are orthogonal, but not
+    normalized, with respect to this weight function.
+
+    Parameters
+    ----------
+    x : array_like
+       Values at which the weight function will be computed.
+
+    Returns
+    -------
+    w : ndarray
+       The weight function at `x`.
+
+    Notes
+    -----
+
+    .. versionadded:: 1.7.0
+
+    Examples
+    --------
+    >>> from numpy.polynomial.laguerre import lagweight
+    >>> x = np.array([0, 1, 2])
+    >>> lagweight(x)
+    array([1.        , 0.36787944, 0.13533528])
+
+    """
+    w = np.exp(-x)
+    return w
+
+#
+# Laguerre series class
+#
+
+class Laguerre(ABCPolyBase):
+    """A Laguerre series class.
+
+    The Laguerre class provides the standard Python numerical methods
+    '+', '-', '*', '//', '%', 'divmod', '**', and '()' as well as the
+    attributes and methods listed below.
+
+    Parameters
+    ----------
+    coef : array_like
+        Laguerre coefficients in order of increasing degree, i.e,
+        ``(1, 2, 3)`` gives ``1*L_0(x) + 2*L_1(X) + 3*L_2(x)``.
+    domain : (2,) array_like, optional
+        Domain to use. The interval ``[domain[0], domain[1]]`` is mapped
+        to the interval ``[window[0], window[1]]`` by shifting and scaling.
+        The default value is [0., 1.].
+    window : (2,) array_like, optional
+        Window, see `domain` for its use. The default value is [0., 1.].
+
+        .. versionadded:: 1.6.0
+    symbol : str, optional
+        Symbol used to represent the independent variable in string
+        representations of the polynomial expression, e.g. for printing.
+        The symbol must be a valid Python identifier. Default value is 'x'.
+
+        .. versionadded:: 1.24
+
+    """
+    # Virtual Functions
+    _add = staticmethod(lagadd)
+    _sub = staticmethod(lagsub)
+    _mul = staticmethod(lagmul)
+    _div = staticmethod(lagdiv)
+    _pow = staticmethod(lagpow)
+    _val = staticmethod(lagval)
+    _int = staticmethod(lagint)
+    _der = staticmethod(lagder)
+    _fit = staticmethod(lagfit)
+    _line = staticmethod(lagline)
+    _roots = staticmethod(lagroots)
+    _fromroots = staticmethod(lagfromroots)
+
+    # Virtual properties
+    domain = np.array(lagdomain)
+    window = np.array(lagdomain)
+    basis_name = 'L'
diff --git a/venv/lib/python3.12/site-packages/numpy/polynomial/laguerre.pyi b/venv/lib/python3.12/site-packages/numpy/polynomial/laguerre.pyi
new file mode 100644
index 00000000..ee811579
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/polynomial/laguerre.pyi
@@ -0,0 +1,100 @@
+from typing import Final, Literal as L
+
+import numpy as np
+
+from ._polybase import ABCPolyBase
+from ._polytypes import (
+    _Array1,
+    _Array2,
+    _FuncBinOp,
+    _FuncCompanion,
+    _FuncDer,
+    _FuncFit,
+    _FuncFromRoots,
+    _FuncGauss,
+    _FuncInteg,
+    _FuncLine,
+    _FuncPoly2Ortho,
+    _FuncPow,
+    _FuncRoots,
+    _FuncUnOp,
+    _FuncVal,
+    _FuncVal2D,
+    _FuncVal3D,
+    _FuncValFromRoots,
+    _FuncVander,
+    _FuncVander2D,
+    _FuncVander3D,
+    _FuncWeight,
+)
+from .polyutils import trimcoef as lagtrim
+
+__all__ = [
+    "lagzero",
+    "lagone",
+    "lagx",
+    "lagdomain",
+    "lagline",
+    "lagadd",
+    "lagsub",
+    "lagmulx",
+    "lagmul",
+    "lagdiv",
+    "lagpow",
+    "lagval",
+    "lagder",
+    "lagint",
+    "lag2poly",
+    "poly2lag",
+    "lagfromroots",
+    "lagvander",
+    "lagfit",
+    "lagtrim",
+    "lagroots",
+    "Laguerre",
+    "lagval2d",
+    "lagval3d",
+    "laggrid2d",
+    "laggrid3d",
+    "lagvander2d",
+    "lagvander3d",
+    "lagcompanion",
+    "laggauss",
+    "lagweight",
+]
+
+poly2lag: _FuncPoly2Ortho[L["poly2lag"]]
+lag2poly: _FuncUnOp[L["lag2poly"]]
+
+lagdomain: Final[_Array2[np.float64]]
+lagzero: Final[_Array1[np.int_]]
+lagone: Final[_Array1[np.int_]]
+lagx: Final[_Array2[np.int_]]
+
+lagline: _FuncLine[L["lagline"]]
+lagfromroots: _FuncFromRoots[L["lagfromroots"]]
+lagadd: _FuncBinOp[L["lagadd"]]
+lagsub: _FuncBinOp[L["lagsub"]]
+lagmulx: _FuncUnOp[L["lagmulx"]]
+lagmul: _FuncBinOp[L["lagmul"]]
+lagdiv: _FuncBinOp[L["lagdiv"]]
+lagpow: _FuncPow[L["lagpow"]]
+lagder: _FuncDer[L["lagder"]]
+lagint: _FuncInteg[L["lagint"]]
+lagval: _FuncVal[L["lagval"]]
+lagval2d: _FuncVal2D[L["lagval2d"]]
+lagval3d: _FuncVal3D[L["lagval3d"]]
+lagvalfromroots: _FuncValFromRoots[L["lagvalfromroots"]]
+laggrid2d: _FuncVal2D[L["laggrid2d"]]
+laggrid3d: _FuncVal3D[L["laggrid3d"]]
+lagvander: _FuncVander[L["lagvander"]]
+lagvander2d: _FuncVander2D[L["lagvander2d"]]
+lagvander3d: _FuncVander3D[L["lagvander3d"]]
+lagfit: _FuncFit[L["lagfit"]]
+lagcompanion: _FuncCompanion[L["lagcompanion"]]
+lagroots: _FuncRoots[L["lagroots"]]
+laggauss: _FuncGauss[L["laggauss"]]
+lagweight: _FuncWeight[L["lagweight"]]
+
+
+class Laguerre(ABCPolyBase[L["L"]]): ...
diff --git a/venv/lib/python3.12/site-packages/numpy/polynomial/legendre.py b/venv/lib/python3.12/site-packages/numpy/polynomial/legendre.py
new file mode 100644
index 00000000..674b7f1b
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/polynomial/legendre.py
@@ -0,0 +1,1666 @@
+"""
+==================================================
+Legendre Series (:mod:`numpy.polynomial.legendre`)
+==================================================
+
+This module provides a number of objects (mostly functions) useful for
+dealing with Legendre series, including a `Legendre` class that
+encapsulates the usual arithmetic operations.  (General information
+on how this module represents and works with such polynomials is in the
+docstring for its "parent" sub-package, `numpy.polynomial`).
+
+Classes
+-------
+.. autosummary::
+   :toctree: generated/
+
+    Legendre
+
+Constants
+---------
+
+.. autosummary::
+   :toctree: generated/
+
+   legdomain
+   legzero
+   legone
+   legx
+
+Arithmetic
+----------
+
+.. autosummary::
+   :toctree: generated/
+
+   legadd
+   legsub
+   legmulx
+   legmul
+   legdiv
+   legpow
+   legval
+   legval2d
+   legval3d
+   leggrid2d
+   leggrid3d
+
+Calculus
+--------
+
+.. autosummary::
+   :toctree: generated/
+
+   legder
+   legint
+
+Misc Functions
+--------------
+
+.. autosummary::
+   :toctree: generated/
+
+   legfromroots
+   legroots
+   legvander
+   legvander2d
+   legvander3d
+   leggauss
+   legweight
+   legcompanion
+   legfit
+   legtrim
+   legline
+   leg2poly
+   poly2leg
+
+See also
+--------
+numpy.polynomial
+
+"""
+import numpy as np
+import numpy.linalg as la
+from numpy.lib.array_utils import normalize_axis_index
+
+from . import polyutils as pu
+from ._polybase import ABCPolyBase
+
+__all__ = [
+    'legzero', 'legone', 'legx', 'legdomain', 'legline', 'legadd',
+    'legsub', 'legmulx', 'legmul', 'legdiv', 'legpow', 'legval', 'legder',
+    'legint', 'leg2poly', 'poly2leg', 'legfromroots', 'legvander',
+    'legfit', 'legtrim', 'legroots', 'Legendre', 'legval2d', 'legval3d',
+    'leggrid2d', 'leggrid3d', 'legvander2d', 'legvander3d', 'legcompanion',
+    'leggauss', 'legweight']
+
+legtrim = pu.trimcoef
+
+
+def poly2leg(pol):
+    """
+    Convert a polynomial to a Legendre series.
+
+    Convert an array representing the coefficients of a polynomial (relative
+    to the "standard" basis) ordered from lowest degree to highest, to an
+    array of the coefficients of the equivalent Legendre series, ordered
+    from lowest to highest degree.
+
+    Parameters
+    ----------
+    pol : array_like
+        1-D array containing the polynomial coefficients
+
+    Returns
+    -------
+    c : ndarray
+        1-D array containing the coefficients of the equivalent Legendre
+        series.
+
+    See Also
+    --------
+    leg2poly
+
+    Notes
+    -----
+    The easy way to do conversions between polynomial basis sets
+    is to use the convert method of a class instance.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from numpy import polynomial as P
+    >>> p = P.Polynomial(np.arange(4))
+    >>> p
+    Polynomial([0.,  1.,  2.,  3.], domain=[-1.,  1.], window=[-1.,  1.], ...
+    >>> c = P.Legendre(P.legendre.poly2leg(p.coef))
+    >>> c
+    Legendre([ 1.  ,  3.25,  1.  ,  0.75], domain=[-1,  1], window=[-1,  1]) # may vary
+
+    """
+    [pol] = pu.as_series([pol])
+    deg = len(pol) - 1
+    res = 0
+    for i in range(deg, -1, -1):
+        res = legadd(legmulx(res), pol[i])
+    return res
+
+
+def leg2poly(c):
+    """
+    Convert a Legendre series to a polynomial.
+
+    Convert an array representing the coefficients of a Legendre series,
+    ordered from lowest degree to highest, to an array of the coefficients
+    of the equivalent polynomial (relative to the "standard" basis) ordered
+    from lowest to highest degree.
+
+    Parameters
+    ----------
+    c : array_like
+        1-D array containing the Legendre series coefficients, ordered
+        from lowest order term to highest.
+
+    Returns
+    -------
+    pol : ndarray
+        1-D array containing the coefficients of the equivalent polynomial
+        (relative to the "standard" basis) ordered from lowest order term
+        to highest.
+
+    See Also
+    --------
+    poly2leg
+
+    Notes
+    -----
+    The easy way to do conversions between polynomial basis sets
+    is to use the convert method of a class instance.
+
+    Examples
+    --------
+    >>> from numpy import polynomial as P
+    >>> c = P.Legendre(range(4))
+    >>> c
+    Legendre([0., 1., 2., 3.], domain=[-1.,  1.], window=[-1.,  1.], symbol='x')
+    >>> p = c.convert(kind=P.Polynomial)
+    >>> p
+    Polynomial([-1. , -3.5,  3. ,  7.5], domain=[-1.,  1.], window=[-1., ...
+    >>> P.legendre.leg2poly(range(4))
+    array([-1. , -3.5,  3. ,  7.5])
+
+
+    """
+    from .polynomial import polyadd, polysub, polymulx
+
+    [c] = pu.as_series([c])
+    n = len(c)
+    if n < 3:
+        return c
+    else:
+        c0 = c[-2]
+        c1 = c[-1]
+        # i is the current degree of c1
+        for i in range(n - 1, 1, -1):
+            tmp = c0
+            c0 = polysub(c[i - 2], (c1*(i - 1))/i)
+            c1 = polyadd(tmp, (polymulx(c1)*(2*i - 1))/i)
+        return polyadd(c0, polymulx(c1))
+
+
+#
+# These are constant arrays are of integer type so as to be compatible
+# with the widest range of other types, such as Decimal.
+#
+
+# Legendre
+legdomain = np.array([-1., 1.])
+
+# Legendre coefficients representing zero.
+legzero = np.array([0])
+
+# Legendre coefficients representing one.
+legone = np.array([1])
+
+# Legendre coefficients representing the identity x.
+legx = np.array([0, 1])
+
+
+def legline(off, scl):
+    """
+    Legendre series whose graph is a straight line.
+
+
+
+    Parameters
+    ----------
+    off, scl : scalars
+        The specified line is given by ``off + scl*x``.
+
+    Returns
+    -------
+    y : ndarray
+        This module's representation of the Legendre series for
+        ``off + scl*x``.
+
+    See Also
+    --------
+    numpy.polynomial.polynomial.polyline
+    numpy.polynomial.chebyshev.chebline
+    numpy.polynomial.laguerre.lagline
+    numpy.polynomial.hermite.hermline
+    numpy.polynomial.hermite_e.hermeline
+
+    Examples
+    --------
+    >>> import numpy.polynomial.legendre as L
+    >>> L.legline(3,2)
+    array([3, 2])
+    >>> L.legval(-3, L.legline(3,2)) # should be -3
+    -3.0
+
+    """
+    if scl != 0:
+        return np.array([off, scl])
+    else:
+        return np.array([off])
+
+
+def legfromroots(roots):
+    """
+    Generate a Legendre series with given roots.
+
+    The function returns the coefficients of the polynomial
+
+    .. math:: p(x) = (x - r_0) * (x - r_1) * ... * (x - r_n),
+
+    in Legendre form, where the :math:`r_n` are the roots specified in `roots`.
+    If a zero has multiplicity n, then it must appear in `roots` n times.
+    For instance, if 2 is a root of multiplicity three and 3 is a root of
+    multiplicity 2, then `roots` looks something like [2, 2, 2, 3, 3]. The
+    roots can appear in any order.
+
+    If the returned coefficients are `c`, then
+
+    .. math:: p(x) = c_0 + c_1 * L_1(x) + ... +  c_n * L_n(x)
+
+    The coefficient of the last term is not generally 1 for monic
+    polynomials in Legendre form.
+
+    Parameters
+    ----------
+    roots : array_like
+        Sequence containing the roots.
+
+    Returns
+    -------
+    out : ndarray
+        1-D array of coefficients.  If all roots are real then `out` is a
+        real array, if some of the roots are complex, then `out` is complex
+        even if all the coefficients in the result are real (see Examples
+        below).
+
+    See Also
+    --------
+    numpy.polynomial.polynomial.polyfromroots
+    numpy.polynomial.chebyshev.chebfromroots
+    numpy.polynomial.laguerre.lagfromroots
+    numpy.polynomial.hermite.hermfromroots
+    numpy.polynomial.hermite_e.hermefromroots
+
+    Examples
+    --------
+    >>> import numpy.polynomial.legendre as L
+    >>> L.legfromroots((-1,0,1)) # x^3 - x relative to the standard basis
+    array([ 0. , -0.4,  0. ,  0.4])
+    >>> j = complex(0,1)
+    >>> L.legfromroots((-j,j)) # x^2 + 1 relative to the standard basis
+    array([ 1.33333333+0.j,  0.00000000+0.j,  0.66666667+0.j]) # may vary
+
+    """
+    return pu._fromroots(legline, legmul, roots)
+
+
+def legadd(c1, c2):
+    """
+    Add one Legendre series to another.
+
+    Returns the sum of two Legendre series `c1` + `c2`.  The arguments
+    are sequences of coefficients ordered from lowest order term to
+    highest, i.e., [1,2,3] represents the series ``P_0 + 2*P_1 + 3*P_2``.
+
+    Parameters
+    ----------
+    c1, c2 : array_like
+        1-D arrays of Legendre series coefficients ordered from low to
+        high.
+
+    Returns
+    -------
+    out : ndarray
+        Array representing the Legendre series of their sum.
+
+    See Also
+    --------
+    legsub, legmulx, legmul, legdiv, legpow
+
+    Notes
+    -----
+    Unlike multiplication, division, etc., the sum of two Legendre series
+    is a Legendre series (without having to "reproject" the result onto
+    the basis set) so addition, just like that of "standard" polynomials,
+    is simply "component-wise."
+
+    Examples
+    --------
+    >>> from numpy.polynomial import legendre as L
+    >>> c1 = (1,2,3)
+    >>> c2 = (3,2,1)
+    >>> L.legadd(c1,c2)
+    array([4.,  4.,  4.])
+
+    """
+    return pu._add(c1, c2)
+
+
+def legsub(c1, c2):
+    """
+    Subtract one Legendre series from another.
+
+    Returns the difference of two Legendre series `c1` - `c2`.  The
+    sequences of coefficients are from lowest order term to highest, i.e.,
+    [1,2,3] represents the series ``P_0 + 2*P_1 + 3*P_2``.
+
+    Parameters
+    ----------
+    c1, c2 : array_like
+        1-D arrays of Legendre series coefficients ordered from low to
+        high.
+
+    Returns
+    -------
+    out : ndarray
+        Of Legendre series coefficients representing their difference.
+
+    See Also
+    --------
+    legadd, legmulx, legmul, legdiv, legpow
+
+    Notes
+    -----
+    Unlike multiplication, division, etc., the difference of two Legendre
+    series is a Legendre series (without having to "reproject" the result
+    onto the basis set) so subtraction, just like that of "standard"
+    polynomials, is simply "component-wise."
+
+    Examples
+    --------
+    >>> from numpy.polynomial import legendre as L
+    >>> c1 = (1,2,3)
+    >>> c2 = (3,2,1)
+    >>> L.legsub(c1,c2)
+    array([-2.,  0.,  2.])
+    >>> L.legsub(c2,c1) # -C.legsub(c1,c2)
+    array([ 2.,  0., -2.])
+
+    """
+    return pu._sub(c1, c2)
+
+
+def legmulx(c):
+    """Multiply a Legendre series by x.
+
+    Multiply the Legendre series `c` by x, where x is the independent
+    variable.
+
+
+    Parameters
+    ----------
+    c : array_like
+        1-D array of Legendre series coefficients ordered from low to
+        high.
+
+    Returns
+    -------
+    out : ndarray
+        Array representing the result of the multiplication.
+
+    See Also
+    --------
+    legadd, legsub, legmul, legdiv, legpow
+
+    Notes
+    -----
+    The multiplication uses the recursion relationship for Legendre
+    polynomials in the form
+
+    .. math::
+
+      xP_i(x) = ((i + 1)*P_{i + 1}(x) + i*P_{i - 1}(x))/(2i + 1)
+
+    Examples
+    --------
+    >>> from numpy.polynomial import legendre as L
+    >>> L.legmulx([1,2,3])
+    array([ 0.66666667, 2.2, 1.33333333, 1.8]) # may vary
+
+    """
+    # c is a trimmed copy
+    [c] = pu.as_series([c])
+    # The zero series needs special treatment
+    if len(c) == 1 and c[0] == 0:
+        return c
+
+    prd = np.empty(len(c) + 1, dtype=c.dtype)
+    prd[0] = c[0]*0
+    prd[1] = c[0]
+    for i in range(1, len(c)):
+        j = i + 1
+        k = i - 1
+        s = i + j
+        prd[j] = (c[i]*j)/s
+        prd[k] += (c[i]*i)/s
+    return prd
+
+
+def legmul(c1, c2):
+    """
+    Multiply one Legendre series by another.
+
+    Returns the product of two Legendre series `c1` * `c2`.  The arguments
+    are sequences of coefficients, from lowest order "term" to highest,
+    e.g., [1,2,3] represents the series ``P_0 + 2*P_1 + 3*P_2``.
+
+    Parameters
+    ----------
+    c1, c2 : array_like
+        1-D arrays of Legendre series coefficients ordered from low to
+        high.
+
+    Returns
+    -------
+    out : ndarray
+        Of Legendre series coefficients representing their product.
+
+    See Also
+    --------
+    legadd, legsub, legmulx, legdiv, legpow
+
+    Notes
+    -----
+    In general, the (polynomial) product of two C-series results in terms
+    that are not in the Legendre polynomial basis set.  Thus, to express
+    the product as a Legendre series, it is necessary to "reproject" the
+    product onto said basis set, which may produce "unintuitive" (but
+    correct) results; see Examples section below.
+
+    Examples
+    --------
+    >>> from numpy.polynomial import legendre as L
+    >>> c1 = (1,2,3)
+    >>> c2 = (3,2)
+    >>> L.legmul(c1,c2) # multiplication requires "reprojection"
+    array([  4.33333333,  10.4       ,  11.66666667,   3.6       ]) # may vary
+
+    """
+    # s1, s2 are trimmed copies
+    [c1, c2] = pu.as_series([c1, c2])
+
+    if len(c1) > len(c2):
+        c = c2
+        xs = c1
+    else:
+        c = c1
+        xs = c2
+
+    if len(c) == 1:
+        c0 = c[0]*xs
+        c1 = 0
+    elif len(c) == 2:
+        c0 = c[0]*xs
+        c1 = c[1]*xs
+    else:
+        nd = len(c)
+        c0 = c[-2]*xs
+        c1 = c[-1]*xs
+        for i in range(3, len(c) + 1):
+            tmp = c0
+            nd = nd - 1
+            c0 = legsub(c[-i]*xs, (c1*(nd - 1))/nd)
+            c1 = legadd(tmp, (legmulx(c1)*(2*nd - 1))/nd)
+    return legadd(c0, legmulx(c1))
+
+
+def legdiv(c1, c2):
+    """
+    Divide one Legendre series by another.
+
+    Returns the quotient-with-remainder of two Legendre series
+    `c1` / `c2`.  The arguments are sequences of coefficients from lowest
+    order "term" to highest, e.g., [1,2,3] represents the series
+    ``P_0 + 2*P_1 + 3*P_2``.
+
+    Parameters
+    ----------
+    c1, c2 : array_like
+        1-D arrays of Legendre series coefficients ordered from low to
+        high.
+
+    Returns
+    -------
+    quo, rem : ndarrays
+        Of Legendre series coefficients representing the quotient and
+        remainder.
+
+    See Also
+    --------
+    legadd, legsub, legmulx, legmul, legpow
+
+    Notes
+    -----
+    In general, the (polynomial) division of one Legendre series by another
+    results in quotient and remainder terms that are not in the Legendre
+    polynomial basis set.  Thus, to express these results as a Legendre
+    series, it is necessary to "reproject" the results onto the Legendre
+    basis set, which may produce "unintuitive" (but correct) results; see
+    Examples section below.
+
+    Examples
+    --------
+    >>> from numpy.polynomial import legendre as L
+    >>> c1 = (1,2,3)
+    >>> c2 = (3,2,1)
+    >>> L.legdiv(c1,c2) # quotient "intuitive," remainder not
+    (array([3.]), array([-8., -4.]))
+    >>> c2 = (0,1,2,3)
+    >>> L.legdiv(c2,c1) # neither "intuitive"
+    (array([-0.07407407,  1.66666667]), array([-1.03703704, -2.51851852])) # may vary
+
+    """
+    return pu._div(legmul, c1, c2)
+
+
+def legpow(c, pow, maxpower=16):
+    """Raise a Legendre series to a power.
+
+    Returns the Legendre series `c` raised to the power `pow`. The
+    argument `c` is a sequence of coefficients ordered from low to high.
+    i.e., [1,2,3] is the series  ``P_0 + 2*P_1 + 3*P_2.``
+
+    Parameters
+    ----------
+    c : array_like
+        1-D array of Legendre series coefficients ordered from low to
+        high.
+    pow : integer
+        Power to which the series will be raised
+    maxpower : integer, optional
+        Maximum power allowed. This is mainly to limit growth of the series
+        to unmanageable size. Default is 16
+
+    Returns
+    -------
+    coef : ndarray
+        Legendre series of power.
+
+    See Also
+    --------
+    legadd, legsub, legmulx, legmul, legdiv
+
+    """
+    return pu._pow(legmul, c, pow, maxpower)
+
+
+def legder(c, m=1, scl=1, axis=0):
+    """
+    Differentiate a Legendre series.
+
+    Returns the Legendre series coefficients `c` differentiated `m` times
+    along `axis`.  At each iteration the result is multiplied by `scl` (the
+    scaling factor is for use in a linear change of variable). The argument
+    `c` is an array of coefficients from low to high degree along each
+    axis, e.g., [1,2,3] represents the series ``1*L_0 + 2*L_1 + 3*L_2``
+    while [[1,2],[1,2]] represents ``1*L_0(x)*L_0(y) + 1*L_1(x)*L_0(y) +
+    2*L_0(x)*L_1(y) + 2*L_1(x)*L_1(y)`` if axis=0 is ``x`` and axis=1 is
+    ``y``.
+
+    Parameters
+    ----------
+    c : array_like
+        Array of Legendre series coefficients. If c is multidimensional the
+        different axis correspond to different variables with the degree in
+        each axis given by the corresponding index.
+    m : int, optional
+        Number of derivatives taken, must be non-negative. (Default: 1)
+    scl : scalar, optional
+        Each differentiation is multiplied by `scl`.  The end result is
+        multiplication by ``scl**m``.  This is for use in a linear change of
+        variable. (Default: 1)
+    axis : int, optional
+        Axis over which the derivative is taken. (Default: 0).
+
+        .. versionadded:: 1.7.0
+
+    Returns
+    -------
+    der : ndarray
+        Legendre series of the derivative.
+
+    See Also
+    --------
+    legint
+
+    Notes
+    -----
+    In general, the result of differentiating a Legendre series does not
+    resemble the same operation on a power series. Thus the result of this
+    function may be "unintuitive," albeit correct; see Examples section
+    below.
+
+    Examples
+    --------
+    >>> from numpy.polynomial import legendre as L
+    >>> c = (1,2,3,4)
+    >>> L.legder(c)
+    array([  6.,   9.,  20.])
+    >>> L.legder(c, 3)
+    array([60.])
+    >>> L.legder(c, scl=-1)
+    array([ -6.,  -9., -20.])
+    >>> L.legder(c, 2,-1)
+    array([  9.,  60.])
+
+    """
+    c = np.array(c, ndmin=1, copy=True)
+    if c.dtype.char in '?bBhHiIlLqQpP':
+        c = c.astype(np.double)
+    cnt = pu._as_int(m, "the order of derivation")
+    iaxis = pu._as_int(axis, "the axis")
+    if cnt < 0:
+        raise ValueError("The order of derivation must be non-negative")
+    iaxis = normalize_axis_index(iaxis, c.ndim)
+
+    if cnt == 0:
+        return c
+
+    c = np.moveaxis(c, iaxis, 0)
+    n = len(c)
+    if cnt >= n:
+        c = c[:1]*0
+    else:
+        for i in range(cnt):
+            n = n - 1
+            c *= scl
+            der = np.empty((n,) + c.shape[1:], dtype=c.dtype)
+            for j in range(n, 2, -1):
+                der[j - 1] = (2*j - 1)*c[j]
+                c[j - 2] += c[j]
+            if n > 1:
+                der[1] = 3*c[2]
+            der[0] = c[1]
+            c = der
+    c = np.moveaxis(c, 0, iaxis)
+    return c
+
+
+def legint(c, m=1, k=[], lbnd=0, scl=1, axis=0):
+    """
+    Integrate a Legendre series.
+
+    Returns the Legendre series coefficients `c` integrated `m` times from
+    `lbnd` along `axis`. At each iteration the resulting series is
+    **multiplied** by `scl` and an integration constant, `k`, is added.
+    The scaling factor is for use in a linear change of variable.  ("Buyer
+    beware": note that, depending on what one is doing, one may want `scl`
+    to be the reciprocal of what one might expect; for more information,
+    see the Notes section below.)  The argument `c` is an array of
+    coefficients from low to high degree along each axis, e.g., [1,2,3]
+    represents the series ``L_0 + 2*L_1 + 3*L_2`` while [[1,2],[1,2]]
+    represents ``1*L_0(x)*L_0(y) + 1*L_1(x)*L_0(y) + 2*L_0(x)*L_1(y) +
+    2*L_1(x)*L_1(y)`` if axis=0 is ``x`` and axis=1 is ``y``.
+
+    Parameters
+    ----------
+    c : array_like
+        Array of Legendre series coefficients. If c is multidimensional the
+        different axis correspond to different variables with the degree in
+        each axis given by the corresponding index.
+    m : int, optional
+        Order of integration, must be positive. (Default: 1)
+    k : {[], list, scalar}, optional
+        Integration constant(s).  The value of the first integral at
+        ``lbnd`` is the first value in the list, the value of the second
+        integral at ``lbnd`` is the second value, etc.  If ``k == []`` (the
+        default), all constants are set to zero.  If ``m == 1``, a single
+        scalar can be given instead of a list.
+    lbnd : scalar, optional
+        The lower bound of the integral. (Default: 0)
+    scl : scalar, optional
+        Following each integration the result is *multiplied* by `scl`
+        before the integration constant is added. (Default: 1)
+    axis : int, optional
+        Axis over which the integral is taken. (Default: 0).
+
+        .. versionadded:: 1.7.0
+
+    Returns
+    -------
+    S : ndarray
+        Legendre series coefficient array of the integral.
+
+    Raises
+    ------
+    ValueError
+        If ``m < 0``, ``len(k) > m``, ``np.ndim(lbnd) != 0``, or
+        ``np.ndim(scl) != 0``.
+
+    See Also
+    --------
+    legder
+
+    Notes
+    -----
+    Note that the result of each integration is *multiplied* by `scl`.
+    Why is this important to note?  Say one is making a linear change of
+    variable :math:`u = ax + b` in an integral relative to `x`.  Then
+    :math:`dx = du/a`, so one will need to set `scl` equal to
+    :math:`1/a` - perhaps not what one would have first thought.
+
+    Also note that, in general, the result of integrating a C-series needs
+    to be "reprojected" onto the C-series basis set.  Thus, typically,
+    the result of this function is "unintuitive," albeit correct; see
+    Examples section below.
+
+    Examples
+    --------
+    >>> from numpy.polynomial import legendre as L
+    >>> c = (1,2,3)
+    >>> L.legint(c)
+    array([ 0.33333333,  0.4       ,  0.66666667,  0.6       ]) # may vary
+    >>> L.legint(c, 3)
+    array([  1.66666667e-02,  -1.78571429e-02,   4.76190476e-02, # may vary
+             -1.73472348e-18,   1.90476190e-02,   9.52380952e-03])
+    >>> L.legint(c, k=3)
+     array([ 3.33333333,  0.4       ,  0.66666667,  0.6       ]) # may vary
+    >>> L.legint(c, lbnd=-2)
+    array([ 7.33333333,  0.4       ,  0.66666667,  0.6       ]) # may vary
+    >>> L.legint(c, scl=2)
+    array([ 0.66666667,  0.8       ,  1.33333333,  1.2       ]) # may vary
+
+    """
+    c = np.array(c, ndmin=1, copy=True)
+    if c.dtype.char in '?bBhHiIlLqQpP':
+        c = c.astype(np.double)
+    if not np.iterable(k):
+        k = [k]
+    cnt = pu._as_int(m, "the order of integration")
+    iaxis = pu._as_int(axis, "the axis")
+    if cnt < 0:
+        raise ValueError("The order of integration must be non-negative")
+    if len(k) > cnt:
+        raise ValueError("Too many integration constants")
+    if np.ndim(lbnd) != 0:
+        raise ValueError("lbnd must be a scalar.")
+    if np.ndim(scl) != 0:
+        raise ValueError("scl must be a scalar.")
+    iaxis = normalize_axis_index(iaxis, c.ndim)
+
+    if cnt == 0:
+        return c
+
+    c = np.moveaxis(c, iaxis, 0)
+    k = list(k) + [0]*(cnt - len(k))
+    for i in range(cnt):
+        n = len(c)
+        c *= scl
+        if n == 1 and np.all(c[0] == 0):
+            c[0] += k[i]
+        else:
+            tmp = np.empty((n + 1,) + c.shape[1:], dtype=c.dtype)
+            tmp[0] = c[0]*0
+            tmp[1] = c[0]
+            if n > 1:
+                tmp[2] = c[1]/3
+            for j in range(2, n):
+                t = c[j]/(2*j + 1)
+                tmp[j + 1] = t
+                tmp[j - 1] -= t
+            tmp[0] += k[i] - legval(lbnd, tmp)
+            c = tmp
+    c = np.moveaxis(c, 0, iaxis)
+    return c
+
+
+def legval(x, c, tensor=True):
+    """
+    Evaluate a Legendre series at points x.
+
+    If `c` is of length ``n + 1``, this function returns the value:
+
+    .. math:: p(x) = c_0 * L_0(x) + c_1 * L_1(x) + ... + c_n * L_n(x)
+
+    The parameter `x` is converted to an array only if it is a tuple or a
+    list, otherwise it is treated as a scalar. In either case, either `x`
+    or its elements must support multiplication and addition both with
+    themselves and with the elements of `c`.
+
+    If `c` is a 1-D array, then ``p(x)`` will have the same shape as `x`.  If
+    `c` is multidimensional, then the shape of the result depends on the
+    value of `tensor`. If `tensor` is true the shape will be c.shape[1:] +
+    x.shape. If `tensor` is false the shape will be c.shape[1:]. Note that
+    scalars have shape (,).
+
+    Trailing zeros in the coefficients will be used in the evaluation, so
+    they should be avoided if efficiency is a concern.
+
+    Parameters
+    ----------
+    x : array_like, compatible object
+        If `x` is a list or tuple, it is converted to an ndarray, otherwise
+        it is left unchanged and treated as a scalar. In either case, `x`
+        or its elements must support addition and multiplication with
+        themselves and with the elements of `c`.
+    c : array_like
+        Array of coefficients ordered so that the coefficients for terms of
+        degree n are contained in c[n]. If `c` is multidimensional the
+        remaining indices enumerate multiple polynomials. In the two
+        dimensional case the coefficients may be thought of as stored in
+        the columns of `c`.
+    tensor : boolean, optional
+        If True, the shape of the coefficient array is extended with ones
+        on the right, one for each dimension of `x`. Scalars have dimension 0
+        for this action. The result is that every column of coefficients in
+        `c` is evaluated for every element of `x`. If False, `x` is broadcast
+        over the columns of `c` for the evaluation.  This keyword is useful
+        when `c` is multidimensional. The default value is True.
+
+        .. versionadded:: 1.7.0
+
+    Returns
+    -------
+    values : ndarray, algebra_like
+        The shape of the return value is described above.
+
+    See Also
+    --------
+    legval2d, leggrid2d, legval3d, leggrid3d
+
+    Notes
+    -----
+    The evaluation uses Clenshaw recursion, aka synthetic division.
+
+    """
+    c = np.array(c, ndmin=1, copy=None)
+    if c.dtype.char in '?bBhHiIlLqQpP':
+        c = c.astype(np.double)
+    if isinstance(x, (tuple, list)):
+        x = np.asarray(x)
+    if isinstance(x, np.ndarray) and tensor:
+        c = c.reshape(c.shape + (1,)*x.ndim)
+
+    if len(c) == 1:
+        c0 = c[0]
+        c1 = 0
+    elif len(c) == 2:
+        c0 = c[0]
+        c1 = c[1]
+    else:
+        nd = len(c)
+        c0 = c[-2]
+        c1 = c[-1]
+        for i in range(3, len(c) + 1):
+            tmp = c0
+            nd = nd - 1
+            c0 = c[-i] - (c1*(nd - 1))/nd
+            c1 = tmp + (c1*x*(2*nd - 1))/nd
+    return c0 + c1*x
+
+
+def legval2d(x, y, c):
+    """
+    Evaluate a 2-D Legendre series at points (x, y).
+
+    This function returns the values:
+
+    .. math:: p(x,y) = \\sum_{i,j} c_{i,j} * L_i(x) * L_j(y)
+
+    The parameters `x` and `y` are converted to arrays only if they are
+    tuples or a lists, otherwise they are treated as a scalars and they
+    must have the same shape after conversion. In either case, either `x`
+    and `y` or their elements must support multiplication and addition both
+    with themselves and with the elements of `c`.
+
+    If `c` is a 1-D array a one is implicitly appended to its shape to make
+    it 2-D. The shape of the result will be c.shape[2:] + x.shape.
+
+    Parameters
+    ----------
+    x, y : array_like, compatible objects
+        The two dimensional series is evaluated at the points ``(x, y)``,
+        where `x` and `y` must have the same shape. If `x` or `y` is a list
+        or tuple, it is first converted to an ndarray, otherwise it is left
+        unchanged and if it isn't an ndarray it is treated as a scalar.
+    c : array_like
+        Array of coefficients ordered so that the coefficient of the term
+        of multi-degree i,j is contained in ``c[i,j]``. If `c` has
+        dimension greater than two the remaining indices enumerate multiple
+        sets of coefficients.
+
+    Returns
+    -------
+    values : ndarray, compatible object
+        The values of the two dimensional Legendre series at points formed
+        from pairs of corresponding values from `x` and `y`.
+
+    See Also
+    --------
+    legval, leggrid2d, legval3d, leggrid3d
+
+    Notes
+    -----
+
+    .. versionadded:: 1.7.0
+
+    """
+    return pu._valnd(legval, c, x, y)
+
+
+def leggrid2d(x, y, c):
+    """
+    Evaluate a 2-D Legendre series on the Cartesian product of x and y.
+
+    This function returns the values:
+
+    .. math:: p(a,b) = \\sum_{i,j} c_{i,j} * L_i(a) * L_j(b)
+
+    where the points ``(a, b)`` consist of all pairs formed by taking
+    `a` from `x` and `b` from `y`. The resulting points form a grid with
+    `x` in the first dimension and `y` in the second.
+
+    The parameters `x` and `y` are converted to arrays only if they are
+    tuples or a lists, otherwise they are treated as a scalars. In either
+    case, either `x` and `y` or their elements must support multiplication
+    and addition both with themselves and with the elements of `c`.
+
+    If `c` has fewer than two dimensions, ones are implicitly appended to
+    its shape to make it 2-D. The shape of the result will be c.shape[2:] +
+    x.shape + y.shape.
+
+    Parameters
+    ----------
+    x, y : array_like, compatible objects
+        The two dimensional series is evaluated at the points in the
+        Cartesian product of `x` and `y`.  If `x` or `y` is a list or
+        tuple, it is first converted to an ndarray, otherwise it is left
+        unchanged and, if it isn't an ndarray, it is treated as a scalar.
+    c : array_like
+        Array of coefficients ordered so that the coefficient of the term of
+        multi-degree i,j is contained in ``c[i,j]``. If `c` has dimension
+        greater than two the remaining indices enumerate multiple sets of
+        coefficients.
+
+    Returns
+    -------
+    values : ndarray, compatible object
+        The values of the two dimensional Chebyshev series at points in the
+        Cartesian product of `x` and `y`.
+
+    See Also
+    --------
+    legval, legval2d, legval3d, leggrid3d
+
+    Notes
+    -----
+
+    .. versionadded:: 1.7.0
+
+    """
+    return pu._gridnd(legval, c, x, y)
+
+
+def legval3d(x, y, z, c):
+    """
+    Evaluate a 3-D Legendre series at points (x, y, z).
+
+    This function returns the values:
+
+    .. math:: p(x,y,z) = \\sum_{i,j,k} c_{i,j,k} * L_i(x) * L_j(y) * L_k(z)
+
+    The parameters `x`, `y`, and `z` are converted to arrays only if
+    they are tuples or a lists, otherwise they are treated as a scalars and
+    they must have the same shape after conversion. In either case, either
+    `x`, `y`, and `z` or their elements must support multiplication and
+    addition both with themselves and with the elements of `c`.
+
+    If `c` has fewer than 3 dimensions, ones are implicitly appended to its
+    shape to make it 3-D. The shape of the result will be c.shape[3:] +
+    x.shape.
+
+    Parameters
+    ----------
+    x, y, z : array_like, compatible object
+        The three dimensional series is evaluated at the points
+        ``(x, y, z)``, where `x`, `y`, and `z` must have the same shape.  If
+        any of `x`, `y`, or `z` is a list or tuple, it is first converted
+        to an ndarray, otherwise it is left unchanged and if it isn't an
+        ndarray it is  treated as a scalar.
+    c : array_like
+        Array of coefficients ordered so that the coefficient of the term of
+        multi-degree i,j,k is contained in ``c[i,j,k]``. If `c` has dimension
+        greater than 3 the remaining indices enumerate multiple sets of
+        coefficients.
+
+    Returns
+    -------
+    values : ndarray, compatible object
+        The values of the multidimensional polynomial on points formed with
+        triples of corresponding values from `x`, `y`, and `z`.
+
+    See Also
+    --------
+    legval, legval2d, leggrid2d, leggrid3d
+
+    Notes
+    -----
+
+    .. versionadded:: 1.7.0
+
+    """
+    return pu._valnd(legval, c, x, y, z)
+
+
+def leggrid3d(x, y, z, c):
+    """
+    Evaluate a 3-D Legendre series on the Cartesian product of x, y, and z.
+
+    This function returns the values:
+
+    .. math:: p(a,b,c) = \\sum_{i,j,k} c_{i,j,k} * L_i(a) * L_j(b) * L_k(c)
+
+    where the points ``(a, b, c)`` consist of all triples formed by taking
+    `a` from `x`, `b` from `y`, and `c` from `z`. The resulting points form
+    a grid with `x` in the first dimension, `y` in the second, and `z` in
+    the third.
+
+    The parameters `x`, `y`, and `z` are converted to arrays only if they
+    are tuples or a lists, otherwise they are treated as a scalars. In
+    either case, either `x`, `y`, and `z` or their elements must support
+    multiplication and addition both with themselves and with the elements
+    of `c`.
+
+    If `c` has fewer than three dimensions, ones are implicitly appended to
+    its shape to make it 3-D. The shape of the result will be c.shape[3:] +
+    x.shape + y.shape + z.shape.
+
+    Parameters
+    ----------
+    x, y, z : array_like, compatible objects
+        The three dimensional series is evaluated at the points in the
+        Cartesian product of `x`, `y`, and `z`.  If `x`, `y`, or `z` is a
+        list or tuple, it is first converted to an ndarray, otherwise it is
+        left unchanged and, if it isn't an ndarray, it is treated as a
+        scalar.
+    c : array_like
+        Array of coefficients ordered so that the coefficients for terms of
+        degree i,j are contained in ``c[i,j]``. If `c` has dimension
+        greater than two the remaining indices enumerate multiple sets of
+        coefficients.
+
+    Returns
+    -------
+    values : ndarray, compatible object
+        The values of the two dimensional polynomial at points in the Cartesian
+        product of `x` and `y`.
+
+    See Also
+    --------
+    legval, legval2d, leggrid2d, legval3d
+
+    Notes
+    -----
+
+    .. versionadded:: 1.7.0
+
+    """
+    return pu._gridnd(legval, c, x, y, z)
+
+
+def legvander(x, deg):
+    """Pseudo-Vandermonde matrix of given degree.
+
+    Returns the pseudo-Vandermonde matrix of degree `deg` and sample points
+    `x`. The pseudo-Vandermonde matrix is defined by
+
+    .. math:: V[..., i] = L_i(x)
+
+    where ``0 <= i <= deg``. The leading indices of `V` index the elements of
+    `x` and the last index is the degree of the Legendre polynomial.
+
+    If `c` is a 1-D array of coefficients of length ``n + 1`` and `V` is the
+    array ``V = legvander(x, n)``, then ``np.dot(V, c)`` and
+    ``legval(x, c)`` are the same up to roundoff. This equivalence is
+    useful both for least squares fitting and for the evaluation of a large
+    number of Legendre series of the same degree and sample points.
+
+    Parameters
+    ----------
+    x : array_like
+        Array of points. The dtype is converted to float64 or complex128
+        depending on whether any of the elements are complex. If `x` is
+        scalar it is converted to a 1-D array.
+    deg : int
+        Degree of the resulting matrix.
+
+    Returns
+    -------
+    vander : ndarray
+        The pseudo-Vandermonde matrix. The shape of the returned matrix is
+        ``x.shape + (deg + 1,)``, where The last index is the degree of the
+        corresponding Legendre polynomial.  The dtype will be the same as
+        the converted `x`.
+
+    """
+    ideg = pu._as_int(deg, "deg")
+    if ideg < 0:
+        raise ValueError("deg must be non-negative")
+
+    x = np.array(x, copy=None, ndmin=1) + 0.0
+    dims = (ideg + 1,) + x.shape
+    dtyp = x.dtype
+    v = np.empty(dims, dtype=dtyp)
+    # Use forward recursion to generate the entries. This is not as accurate
+    # as reverse recursion in this application but it is more efficient.
+    v[0] = x*0 + 1
+    if ideg > 0:
+        v[1] = x
+        for i in range(2, ideg + 1):
+            v[i] = (v[i-1]*x*(2*i - 1) - v[i-2]*(i - 1))/i
+    return np.moveaxis(v, 0, -1)
+
+
+def legvander2d(x, y, deg):
+    """Pseudo-Vandermonde matrix of given degrees.
+
+    Returns the pseudo-Vandermonde matrix of degrees `deg` and sample
+    points ``(x, y)``. The pseudo-Vandermonde matrix is defined by
+
+    .. math:: V[..., (deg[1] + 1)*i + j] = L_i(x) * L_j(y),
+
+    where ``0 <= i <= deg[0]`` and ``0 <= j <= deg[1]``. The leading indices of
+    `V` index the points ``(x, y)`` and the last index encodes the degrees of
+    the Legendre polynomials.
+
+    If ``V = legvander2d(x, y, [xdeg, ydeg])``, then the columns of `V`
+    correspond to the elements of a 2-D coefficient array `c` of shape
+    (xdeg + 1, ydeg + 1) in the order
+
+    .. math:: c_{00}, c_{01}, c_{02} ... , c_{10}, c_{11}, c_{12} ...
+
+    and ``np.dot(V, c.flat)`` and ``legval2d(x, y, c)`` will be the same
+    up to roundoff. This equivalence is useful both for least squares
+    fitting and for the evaluation of a large number of 2-D Legendre
+    series of the same degrees and sample points.
+
+    Parameters
+    ----------
+    x, y : array_like
+        Arrays of point coordinates, all of the same shape. The dtypes
+        will be converted to either float64 or complex128 depending on
+        whether any of the elements are complex. Scalars are converted to
+        1-D arrays.
+    deg : list of ints
+        List of maximum degrees of the form [x_deg, y_deg].
+
+    Returns
+    -------
+    vander2d : ndarray
+        The shape of the returned matrix is ``x.shape + (order,)``, where
+        :math:`order = (deg[0]+1)*(deg[1]+1)`.  The dtype will be the same
+        as the converted `x` and `y`.
+
+    See Also
+    --------
+    legvander, legvander3d, legval2d, legval3d
+
+    Notes
+    -----
+
+    .. versionadded:: 1.7.0
+
+    """
+    return pu._vander_nd_flat((legvander, legvander), (x, y), deg)
+
+
+def legvander3d(x, y, z, deg):
+    """Pseudo-Vandermonde matrix of given degrees.
+
+    Returns the pseudo-Vandermonde matrix of degrees `deg` and sample
+    points ``(x, y, z)``. If `l`, `m`, `n` are the given degrees in `x`, `y`, `z`,
+    then The pseudo-Vandermonde matrix is defined by
+
+    .. math:: V[..., (m+1)(n+1)i + (n+1)j + k] = L_i(x)*L_j(y)*L_k(z),
+
+    where ``0 <= i <= l``, ``0 <= j <= m``, and ``0 <= j <= n``.  The leading
+    indices of `V` index the points ``(x, y, z)`` and the last index encodes
+    the degrees of the Legendre polynomials.
+
+    If ``V = legvander3d(x, y, z, [xdeg, ydeg, zdeg])``, then the columns
+    of `V` correspond to the elements of a 3-D coefficient array `c` of
+    shape (xdeg + 1, ydeg + 1, zdeg + 1) in the order
+
+    .. math:: c_{000}, c_{001}, c_{002},... , c_{010}, c_{011}, c_{012},...
+
+    and ``np.dot(V, c.flat)`` and ``legval3d(x, y, z, c)`` will be the
+    same up to roundoff. This equivalence is useful both for least squares
+    fitting and for the evaluation of a large number of 3-D Legendre
+    series of the same degrees and sample points.
+
+    Parameters
+    ----------
+    x, y, z : array_like
+        Arrays of point coordinates, all of the same shape. The dtypes will
+        be converted to either float64 or complex128 depending on whether
+        any of the elements are complex. Scalars are converted to 1-D
+        arrays.
+    deg : list of ints
+        List of maximum degrees of the form [x_deg, y_deg, z_deg].
+
+    Returns
+    -------
+    vander3d : ndarray
+        The shape of the returned matrix is ``x.shape + (order,)``, where
+        :math:`order = (deg[0]+1)*(deg[1]+1)*(deg[2]+1)`.  The dtype will
+        be the same as the converted `x`, `y`, and `z`.
+
+    See Also
+    --------
+    legvander, legvander3d, legval2d, legval3d
+
+    Notes
+    -----
+
+    .. versionadded:: 1.7.0
+
+    """
+    return pu._vander_nd_flat((legvander, legvander, legvander), (x, y, z), deg)
+
+
+def legfit(x, y, deg, rcond=None, full=False, w=None):
+    """
+    Least squares fit of Legendre series to data.
+
+    Return the coefficients of a Legendre series of degree `deg` that is the
+    least squares fit to the data values `y` given at points `x`. If `y` is
+    1-D the returned coefficients will also be 1-D. If `y` is 2-D multiple
+    fits are done, one for each column of `y`, and the resulting
+    coefficients are stored in the corresponding columns of a 2-D return.
+    The fitted polynomial(s) are in the form
+
+    .. math::  p(x) = c_0 + c_1 * L_1(x) + ... + c_n * L_n(x),
+
+    where `n` is `deg`.
+
+    Parameters
+    ----------
+    x : array_like, shape (M,)
+        x-coordinates of the M sample points ``(x[i], y[i])``.
+    y : array_like, shape (M,) or (M, K)
+        y-coordinates of the sample points. Several data sets of sample
+        points sharing the same x-coordinates can be fitted at once by
+        passing in a 2D-array that contains one dataset per column.
+    deg : int or 1-D array_like
+        Degree(s) of the fitting polynomials. If `deg` is a single integer
+        all terms up to and including the `deg`'th term are included in the
+        fit. For NumPy versions >= 1.11.0 a list of integers specifying the
+        degrees of the terms to include may be used instead.
+    rcond : float, optional
+        Relative condition number of the fit. Singular values smaller than
+        this relative to the largest singular value will be ignored. The
+        default value is len(x)*eps, where eps is the relative precision of
+        the float type, about 2e-16 in most cases.
+    full : bool, optional
+        Switch determining nature of return value. When it is False (the
+        default) just the coefficients are returned, when True diagnostic
+        information from the singular value decomposition is also returned.
+    w : array_like, shape (`M`,), optional
+        Weights. If not None, the weight ``w[i]`` applies to the unsquared
+        residual ``y[i] - y_hat[i]`` at ``x[i]``. Ideally the weights are
+        chosen so that the errors of the products ``w[i]*y[i]`` all have the
+        same variance.  When using inverse-variance weighting, use
+        ``w[i] = 1/sigma(y[i])``.  The default value is None.
+
+        .. versionadded:: 1.5.0
+
+    Returns
+    -------
+    coef : ndarray, shape (M,) or (M, K)
+        Legendre coefficients ordered from low to high. If `y` was
+        2-D, the coefficients for the data in column k of `y` are in
+        column `k`. If `deg` is specified as a list, coefficients for
+        terms not included in the fit are set equal to zero in the
+        returned `coef`.
+
+    [residuals, rank, singular_values, rcond] : list
+        These values are only returned if ``full == True``
+
+        - residuals -- sum of squared residuals of the least squares fit
+        - rank -- the numerical rank of the scaled Vandermonde matrix
+        - singular_values -- singular values of the scaled Vandermonde matrix
+        - rcond -- value of `rcond`.
+
+        For more details, see `numpy.linalg.lstsq`.
+
+    Warns
+    -----
+    RankWarning
+        The rank of the coefficient matrix in the least-squares fit is
+        deficient. The warning is only raised if ``full == False``.  The
+        warnings can be turned off by
+
+        >>> import warnings
+        >>> warnings.simplefilter('ignore', np.exceptions.RankWarning)
+
+    See Also
+    --------
+    numpy.polynomial.polynomial.polyfit
+    numpy.polynomial.chebyshev.chebfit
+    numpy.polynomial.laguerre.lagfit
+    numpy.polynomial.hermite.hermfit
+    numpy.polynomial.hermite_e.hermefit
+    legval : Evaluates a Legendre series.
+    legvander : Vandermonde matrix of Legendre series.
+    legweight : Legendre weight function (= 1).
+    numpy.linalg.lstsq : Computes a least-squares fit from the matrix.
+    scipy.interpolate.UnivariateSpline : Computes spline fits.
+
+    Notes
+    -----
+    The solution is the coefficients of the Legendre series `p` that
+    minimizes the sum of the weighted squared errors
+
+    .. math:: E = \\sum_j w_j^2 * |y_j - p(x_j)|^2,
+
+    where :math:`w_j` are the weights. This problem is solved by setting up
+    as the (typically) overdetermined matrix equation
+
+    .. math:: V(x) * c = w * y,
+
+    where `V` is the weighted pseudo Vandermonde matrix of `x`, `c` are the
+    coefficients to be solved for, `w` are the weights, and `y` are the
+    observed values.  This equation is then solved using the singular value
+    decomposition of `V`.
+
+    If some of the singular values of `V` are so small that they are
+    neglected, then a `~exceptions.RankWarning` will be issued. This means that
+    the coefficient values may be poorly determined. Using a lower order fit
+    will usually get rid of the warning.  The `rcond` parameter can also be
+    set to a value smaller than its default, but the resulting fit may be
+    spurious and have large contributions from roundoff error.
+
+    Fits using Legendre series are usually better conditioned than fits
+    using power series, but much can depend on the distribution of the
+    sample points and the smoothness of the data. If the quality of the fit
+    is inadequate splines may be a good alternative.
+
+    References
+    ----------
+    .. [1] Wikipedia, "Curve fitting",
+           https://en.wikipedia.org/wiki/Curve_fitting
+
+    Examples
+    --------
+
+    """
+    return pu._fit(legvander, x, y, deg, rcond, full, w)
+
+
+def legcompanion(c):
+    """Return the scaled companion matrix of c.
+
+    The basis polynomials are scaled so that the companion matrix is
+    symmetric when `c` is an Legendre basis polynomial. This provides
+    better eigenvalue estimates than the unscaled case and for basis
+    polynomials the eigenvalues are guaranteed to be real if
+    `numpy.linalg.eigvalsh` is used to obtain them.
+
+    Parameters
+    ----------
+    c : array_like
+        1-D array of Legendre series coefficients ordered from low to high
+        degree.
+
+    Returns
+    -------
+    mat : ndarray
+        Scaled companion matrix of dimensions (deg, deg).
+
+    Notes
+    -----
+
+    .. versionadded:: 1.7.0
+
+    """
+    # c is a trimmed copy
+    [c] = pu.as_series([c])
+    if len(c) < 2:
+        raise ValueError('Series must have maximum degree of at least 1.')
+    if len(c) == 2:
+        return np.array([[-c[0]/c[1]]])
+
+    n = len(c) - 1
+    mat = np.zeros((n, n), dtype=c.dtype)
+    scl = 1./np.sqrt(2*np.arange(n) + 1)
+    top = mat.reshape(-1)[1::n+1]
+    bot = mat.reshape(-1)[n::n+1]
+    top[...] = np.arange(1, n)*scl[:n-1]*scl[1:n]
+    bot[...] = top
+    mat[:, -1] -= (c[:-1]/c[-1])*(scl/scl[-1])*(n/(2*n - 1))
+    return mat
+
+
+def legroots(c):
+    """
+    Compute the roots of a Legendre series.
+
+    Return the roots (a.k.a. "zeros") of the polynomial
+
+    .. math:: p(x) = \\sum_i c[i] * L_i(x).
+
+    Parameters
+    ----------
+    c : 1-D array_like
+        1-D array of coefficients.
+
+    Returns
+    -------
+    out : ndarray
+        Array of the roots of the series. If all the roots are real,
+        then `out` is also real, otherwise it is complex.
+
+    See Also
+    --------
+    numpy.polynomial.polynomial.polyroots
+    numpy.polynomial.chebyshev.chebroots
+    numpy.polynomial.laguerre.lagroots
+    numpy.polynomial.hermite.hermroots
+    numpy.polynomial.hermite_e.hermeroots
+
+    Notes
+    -----
+    The root estimates are obtained as the eigenvalues of the companion
+    matrix, Roots far from the origin of the complex plane may have large
+    errors due to the numerical instability of the series for such values.
+    Roots with multiplicity greater than 1 will also show larger errors as
+    the value of the series near such points is relatively insensitive to
+    errors in the roots. Isolated roots near the origin can be improved by
+    a few iterations of Newton's method.
+
+    The Legendre series basis polynomials aren't powers of ``x`` so the
+    results of this function may seem unintuitive.
+
+    Examples
+    --------
+    >>> import numpy.polynomial.legendre as leg
+    >>> leg.legroots((1, 2, 3, 4)) # 4L_3 + 3L_2 + 2L_1 + 1L_0, all real roots
+    array([-0.85099543, -0.11407192,  0.51506735]) # may vary
+
+    """
+    # c is a trimmed copy
+    [c] = pu.as_series([c])
+    if len(c) < 2:
+        return np.array([], dtype=c.dtype)
+    if len(c) == 2:
+        return np.array([-c[0]/c[1]])
+
+    # rotated companion matrix reduces error
+    m = legcompanion(c)[::-1,::-1]
+    r = la.eigvals(m)
+    r.sort()
+    return r
+
+
+def leggauss(deg):
+    """
+    Gauss-Legendre quadrature.
+
+    Computes the sample points and weights for Gauss-Legendre quadrature.
+    These sample points and weights will correctly integrate polynomials of
+    degree :math:`2*deg - 1` or less over the interval :math:`[-1, 1]` with
+    the weight function :math:`f(x) = 1`.
+
+    Parameters
+    ----------
+    deg : int
+        Number of sample points and weights. It must be >= 1.
+
+    Returns
+    -------
+    x : ndarray
+        1-D ndarray containing the sample points.
+    y : ndarray
+        1-D ndarray containing the weights.
+
+    Notes
+    -----
+
+    .. versionadded:: 1.7.0
+
+    The results have only been tested up to degree 100, higher degrees may
+    be problematic. The weights are determined by using the fact that
+
+    .. math:: w_k = c / (L'_n(x_k) * L_{n-1}(x_k))
+
+    where :math:`c` is a constant independent of :math:`k` and :math:`x_k`
+    is the k'th root of :math:`L_n`, and then scaling the results to get
+    the right value when integrating 1.
+
+    """
+    ideg = pu._as_int(deg, "deg")
+    if ideg <= 0:
+        raise ValueError("deg must be a positive integer")
+
+    # first approximation of roots. We use the fact that the companion
+    # matrix is symmetric in this case in order to obtain better zeros.
+    c = np.array([0]*deg + [1])
+    m = legcompanion(c)
+    x = la.eigvalsh(m)
+
+    # improve roots by one application of Newton
+    dy = legval(x, c)
+    df = legval(x, legder(c))
+    x -= dy/df
+
+    # compute the weights. We scale the factor to avoid possible numerical
+    # overflow.
+    fm = legval(x, c[1:])
+    fm /= np.abs(fm).max()
+    df /= np.abs(df).max()
+    w = 1/(fm * df)
+
+    # for Legendre we can also symmetrize
+    w = (w + w[::-1])/2
+    x = (x - x[::-1])/2
+
+    # scale w to get the right value
+    w *= 2. / w.sum()
+
+    return x, w
+
+
+def legweight(x):
+    """
+    Weight function of the Legendre polynomials.
+
+    The weight function is :math:`1` and the interval of integration is
+    :math:`[-1, 1]`. The Legendre polynomials are orthogonal, but not
+    normalized, with respect to this weight function.
+
+    Parameters
+    ----------
+    x : array_like
+       Values at which the weight function will be computed.
+
+    Returns
+    -------
+    w : ndarray
+       The weight function at `x`.
+
+    Notes
+    -----
+
+    .. versionadded:: 1.7.0
+
+    """
+    w = x*0.0 + 1.0
+    return w
+
+#
+# Legendre series class
+#
+
+class Legendre(ABCPolyBase):
+    """A Legendre series class.
+
+    The Legendre class provides the standard Python numerical methods
+    '+', '-', '*', '//', '%', 'divmod', '**', and '()' as well as the
+    attributes and methods listed below.
+
+    Parameters
+    ----------
+    coef : array_like
+        Legendre coefficients in order of increasing degree, i.e.,
+        ``(1, 2, 3)`` gives ``1*P_0(x) + 2*P_1(x) + 3*P_2(x)``.
+    domain : (2,) array_like, optional
+        Domain to use. The interval ``[domain[0], domain[1]]`` is mapped
+        to the interval ``[window[0], window[1]]`` by shifting and scaling.
+        The default value is [-1., 1.].
+    window : (2,) array_like, optional
+        Window, see `domain` for its use. The default value is [-1., 1.].
+
+        .. versionadded:: 1.6.0
+    symbol : str, optional
+        Symbol used to represent the independent variable in string
+        representations of the polynomial expression, e.g. for printing.
+        The symbol must be a valid Python identifier. Default value is 'x'.
+
+        .. versionadded:: 1.24
+
+    """
+    # Virtual Functions
+    _add = staticmethod(legadd)
+    _sub = staticmethod(legsub)
+    _mul = staticmethod(legmul)
+    _div = staticmethod(legdiv)
+    _pow = staticmethod(legpow)
+    _val = staticmethod(legval)
+    _int = staticmethod(legint)
+    _der = staticmethod(legder)
+    _fit = staticmethod(legfit)
+    _line = staticmethod(legline)
+    _roots = staticmethod(legroots)
+    _fromroots = staticmethod(legfromroots)
+
+    # Virtual properties
+    domain = np.array(legdomain)
+    window = np.array(legdomain)
+    basis_name = 'P'
diff --git a/venv/lib/python3.12/site-packages/numpy/polynomial/legendre.pyi b/venv/lib/python3.12/site-packages/numpy/polynomial/legendre.pyi
new file mode 100644
index 00000000..d81f3e6f
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/polynomial/legendre.pyi
@@ -0,0 +1,99 @@
+from typing import Final, Literal as L
+
+import numpy as np
+
+from ._polybase import ABCPolyBase
+from ._polytypes import (
+    _Array1,
+    _Array2,
+    _FuncBinOp,
+    _FuncCompanion,
+    _FuncDer,
+    _FuncFit,
+    _FuncFromRoots,
+    _FuncGauss,
+    _FuncInteg,
+    _FuncLine,
+    _FuncPoly2Ortho,
+    _FuncPow,
+    _FuncRoots,
+    _FuncUnOp,
+    _FuncVal,
+    _FuncVal2D,
+    _FuncVal3D,
+    _FuncValFromRoots,
+    _FuncVander,
+    _FuncVander2D,
+    _FuncVander3D,
+    _FuncWeight,
+)
+from .polyutils import trimcoef as legtrim
+
+__all__ = [
+    "legzero",
+    "legone",
+    "legx",
+    "legdomain",
+    "legline",
+    "legadd",
+    "legsub",
+    "legmulx",
+    "legmul",
+    "legdiv",
+    "legpow",
+    "legval",
+    "legder",
+    "legint",
+    "leg2poly",
+    "poly2leg",
+    "legfromroots",
+    "legvander",
+    "legfit",
+    "legtrim",
+    "legroots",
+    "Legendre",
+    "legval2d",
+    "legval3d",
+    "leggrid2d",
+    "leggrid3d",
+    "legvander2d",
+    "legvander3d",
+    "legcompanion",
+    "leggauss",
+    "legweight",
+]
+
+poly2leg: _FuncPoly2Ortho[L["poly2leg"]]
+leg2poly: _FuncUnOp[L["leg2poly"]]
+
+legdomain: Final[_Array2[np.float64]]
+legzero: Final[_Array1[np.int_]]
+legone: Final[_Array1[np.int_]]
+legx: Final[_Array2[np.int_]]
+
+legline: _FuncLine[L["legline"]]
+legfromroots: _FuncFromRoots[L["legfromroots"]]
+legadd: _FuncBinOp[L["legadd"]]
+legsub: _FuncBinOp[L["legsub"]]
+legmulx: _FuncUnOp[L["legmulx"]]
+legmul: _FuncBinOp[L["legmul"]]
+legdiv: _FuncBinOp[L["legdiv"]]
+legpow: _FuncPow[L["legpow"]]
+legder: _FuncDer[L["legder"]]
+legint: _FuncInteg[L["legint"]]
+legval: _FuncVal[L["legval"]]
+legval2d: _FuncVal2D[L["legval2d"]]
+legval3d: _FuncVal3D[L["legval3d"]]
+legvalfromroots: _FuncValFromRoots[L["legvalfromroots"]]
+leggrid2d: _FuncVal2D[L["leggrid2d"]]
+leggrid3d: _FuncVal3D[L["leggrid3d"]]
+legvander: _FuncVander[L["legvander"]]
+legvander2d: _FuncVander2D[L["legvander2d"]]
+legvander3d: _FuncVander3D[L["legvander3d"]]
+legfit: _FuncFit[L["legfit"]]
+legcompanion: _FuncCompanion[L["legcompanion"]]
+legroots: _FuncRoots[L["legroots"]]
+leggauss: _FuncGauss[L["leggauss"]]
+legweight: _FuncWeight[L["legweight"]]
+
+class Legendre(ABCPolyBase[L["P"]]): ...
diff --git a/venv/lib/python3.12/site-packages/numpy/polynomial/polynomial.py b/venv/lib/python3.12/site-packages/numpy/polynomial/polynomial.py
new file mode 100644
index 00000000..12ab1ba3
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/polynomial/polynomial.py
@@ -0,0 +1,1664 @@
+"""
+=================================================
+Power Series (:mod:`numpy.polynomial.polynomial`)
+=================================================
+
+This module provides a number of objects (mostly functions) useful for
+dealing with polynomials, including a `Polynomial` class that
+encapsulates the usual arithmetic operations.  (General information
+on how this module represents and works with polynomial objects is in
+the docstring for its "parent" sub-package, `numpy.polynomial`).
+
+Classes
+-------
+.. autosummary::
+   :toctree: generated/
+
+   Polynomial
+
+Constants
+---------
+.. autosummary::
+   :toctree: generated/
+
+   polydomain
+   polyzero
+   polyone
+   polyx
+
+Arithmetic
+----------
+.. autosummary::
+   :toctree: generated/
+
+   polyadd
+   polysub
+   polymulx
+   polymul
+   polydiv
+   polypow
+   polyval
+   polyval2d
+   polyval3d
+   polygrid2d
+   polygrid3d
+
+Calculus
+--------
+.. autosummary::
+   :toctree: generated/
+
+   polyder
+   polyint
+
+Misc Functions
+--------------
+.. autosummary::
+   :toctree: generated/
+
+   polyfromroots
+   polyroots
+   polyvalfromroots
+   polyvander
+   polyvander2d
+   polyvander3d
+   polycompanion
+   polyfit
+   polytrim
+   polyline
+
+See Also
+--------
+`numpy.polynomial`
+
+"""
+__all__ = [
+    'polyzero', 'polyone', 'polyx', 'polydomain', 'polyline', 'polyadd',
+    'polysub', 'polymulx', 'polymul', 'polydiv', 'polypow', 'polyval',
+    'polyvalfromroots', 'polyder', 'polyint', 'polyfromroots', 'polyvander',
+    'polyfit', 'polytrim', 'polyroots', 'Polynomial', 'polyval2d', 'polyval3d',
+    'polygrid2d', 'polygrid3d', 'polyvander2d', 'polyvander3d',
+    'polycompanion']
+
+import numpy as np
+import numpy.linalg as la
+from numpy.lib.array_utils import normalize_axis_index
+
+from . import polyutils as pu
+from ._polybase import ABCPolyBase
+
+polytrim = pu.trimcoef
+
+#
+# These are constant arrays are of integer type so as to be compatible
+# with the widest range of other types, such as Decimal.
+#
+
+# Polynomial default domain.
+polydomain = np.array([-1., 1.])
+
+# Polynomial coefficients representing zero.
+polyzero = np.array([0])
+
+# Polynomial coefficients representing one.
+polyone = np.array([1])
+
+# Polynomial coefficients representing the identity x.
+polyx = np.array([0, 1])
+
+#
+# Polynomial series functions
+#
+
+
+def polyline(off, scl):
+    """
+    Returns an array representing a linear polynomial.
+
+    Parameters
+    ----------
+    off, scl : scalars
+        The "y-intercept" and "slope" of the line, respectively.
+
+    Returns
+    -------
+    y : ndarray
+        This module's representation of the linear polynomial ``off +
+        scl*x``.
+
+    See Also
+    --------
+    numpy.polynomial.chebyshev.chebline
+    numpy.polynomial.legendre.legline
+    numpy.polynomial.laguerre.lagline
+    numpy.polynomial.hermite.hermline
+    numpy.polynomial.hermite_e.hermeline
+
+    Examples
+    --------
+    >>> from numpy.polynomial import polynomial as P
+    >>> P.polyline(1, -1)
+    array([ 1, -1])
+    >>> P.polyval(1, P.polyline(1, -1))  # should be 0
+    0.0
+
+    """
+    if scl != 0:
+        return np.array([off, scl])
+    else:
+        return np.array([off])
+
+
+def polyfromroots(roots):
+    """
+    Generate a monic polynomial with given roots.
+
+    Return the coefficients of the polynomial
+
+    .. math:: p(x) = (x - r_0) * (x - r_1) * ... * (x - r_n),
+
+    where the :math:`r_n` are the roots specified in `roots`.  If a zero has
+    multiplicity n, then it must appear in `roots` n times. For instance,
+    if 2 is a root of multiplicity three and 3 is a root of multiplicity 2,
+    then `roots` looks something like [2, 2, 2, 3, 3]. The roots can appear
+    in any order.
+
+    If the returned coefficients are `c`, then
+
+    .. math:: p(x) = c_0 + c_1 * x + ... +  x^n
+
+    The coefficient of the last term is 1 for monic polynomials in this
+    form.
+
+    Parameters
+    ----------
+    roots : array_like
+        Sequence containing the roots.
+
+    Returns
+    -------
+    out : ndarray
+        1-D array of the polynomial's coefficients If all the roots are
+        real, then `out` is also real, otherwise it is complex.  (see
+        Examples below).
+
+    See Also
+    --------
+    numpy.polynomial.chebyshev.chebfromroots
+    numpy.polynomial.legendre.legfromroots
+    numpy.polynomial.laguerre.lagfromroots
+    numpy.polynomial.hermite.hermfromroots
+    numpy.polynomial.hermite_e.hermefromroots
+
+    Notes
+    -----
+    The coefficients are determined by multiplying together linear factors
+    of the form ``(x - r_i)``, i.e.
+
+    .. math:: p(x) = (x - r_0) (x - r_1) ... (x - r_n)
+
+    where ``n == len(roots) - 1``; note that this implies that ``1`` is always
+    returned for :math:`a_n`.
+
+    Examples
+    --------
+    >>> from numpy.polynomial import polynomial as P
+    >>> P.polyfromroots((-1,0,1))  # x(x - 1)(x + 1) = x^3 - x
+    array([ 0., -1.,  0.,  1.])
+    >>> j = complex(0,1)
+    >>> P.polyfromroots((-j,j))  # complex returned, though values are real
+    array([1.+0.j,  0.+0.j,  1.+0.j])
+
+    """
+    return pu._fromroots(polyline, polymul, roots)
+
+
+def polyadd(c1, c2):
+    """
+    Add one polynomial to another.
+
+    Returns the sum of two polynomials `c1` + `c2`.  The arguments are
+    sequences of coefficients from lowest order term to highest, i.e.,
+    [1,2,3] represents the polynomial ``1 + 2*x + 3*x**2``.
+
+    Parameters
+    ----------
+    c1, c2 : array_like
+        1-D arrays of polynomial coefficients ordered from low to high.
+
+    Returns
+    -------
+    out : ndarray
+        The coefficient array representing their sum.
+
+    See Also
+    --------
+    polysub, polymulx, polymul, polydiv, polypow
+
+    Examples
+    --------
+    >>> from numpy.polynomial import polynomial as P
+    >>> c1 = (1, 2, 3)
+    >>> c2 = (3, 2, 1)
+    >>> sum = P.polyadd(c1,c2); sum
+    array([4.,  4.,  4.])
+    >>> P.polyval(2, sum)  # 4 + 4(2) + 4(2**2)
+    28.0
+
+    """
+    return pu._add(c1, c2)
+
+
+def polysub(c1, c2):
+    """
+    Subtract one polynomial from another.
+
+    Returns the difference of two polynomials `c1` - `c2`.  The arguments
+    are sequences of coefficients from lowest order term to highest, i.e.,
+    [1,2,3] represents the polynomial ``1 + 2*x + 3*x**2``.
+
+    Parameters
+    ----------
+    c1, c2 : array_like
+        1-D arrays of polynomial coefficients ordered from low to
+        high.
+
+    Returns
+    -------
+    out : ndarray
+        Of coefficients representing their difference.
+
+    See Also
+    --------
+    polyadd, polymulx, polymul, polydiv, polypow
+
+    Examples
+    --------
+    >>> from numpy.polynomial import polynomial as P
+    >>> c1 = (1, 2, 3)
+    >>> c2 = (3, 2, 1)
+    >>> P.polysub(c1,c2)
+    array([-2.,  0.,  2.])
+    >>> P.polysub(c2, c1)  # -P.polysub(c1,c2)
+    array([ 2.,  0., -2.])
+
+    """
+    return pu._sub(c1, c2)
+
+
+def polymulx(c):
+    """Multiply a polynomial by x.
+
+    Multiply the polynomial `c` by x, where x is the independent
+    variable.
+
+
+    Parameters
+    ----------
+    c : array_like
+        1-D array of polynomial coefficients ordered from low to
+        high.
+
+    Returns
+    -------
+    out : ndarray
+        Array representing the result of the multiplication.
+
+    See Also
+    --------
+    polyadd, polysub, polymul, polydiv, polypow
+
+    Notes
+    -----
+
+    .. versionadded:: 1.5.0
+
+    Examples
+    --------
+    >>> from numpy.polynomial import polynomial as P
+    >>> c = (1, 2, 3)
+    >>> P.polymulx(c)
+    array([0., 1., 2., 3.])
+
+    """
+    # c is a trimmed copy
+    [c] = pu.as_series([c])
+    # The zero series needs special treatment
+    if len(c) == 1 and c[0] == 0:
+        return c
+
+    prd = np.empty(len(c) + 1, dtype=c.dtype)
+    prd[0] = c[0]*0
+    prd[1:] = c
+    return prd
+
+
+def polymul(c1, c2):
+    """
+    Multiply one polynomial by another.
+
+    Returns the product of two polynomials `c1` * `c2`.  The arguments are
+    sequences of coefficients, from lowest order term to highest, e.g.,
+    [1,2,3] represents the polynomial ``1 + 2*x + 3*x**2.``
+
+    Parameters
+    ----------
+    c1, c2 : array_like
+        1-D arrays of coefficients representing a polynomial, relative to the
+        "standard" basis, and ordered from lowest order term to highest.
+
+    Returns
+    -------
+    out : ndarray
+        Of the coefficients of their product.
+
+    See Also
+    --------
+    polyadd, polysub, polymulx, polydiv, polypow
+
+    Examples
+    --------
+    >>> from numpy.polynomial import polynomial as P
+    >>> c1 = (1, 2, 3)
+    >>> c2 = (3, 2, 1)
+    >>> P.polymul(c1, c2)
+    array([  3.,   8.,  14.,   8.,   3.])
+
+    """
+    # c1, c2 are trimmed copies
+    [c1, c2] = pu.as_series([c1, c2])
+    ret = np.convolve(c1, c2)
+    return pu.trimseq(ret)
+
+
+def polydiv(c1, c2):
+    """
+    Divide one polynomial by another.
+
+    Returns the quotient-with-remainder of two polynomials `c1` / `c2`.
+    The arguments are sequences of coefficients, from lowest order term
+    to highest, e.g., [1,2,3] represents ``1 + 2*x + 3*x**2``.
+
+    Parameters
+    ----------
+    c1, c2 : array_like
+        1-D arrays of polynomial coefficients ordered from low to high.
+
+    Returns
+    -------
+    [quo, rem] : ndarrays
+        Of coefficient series representing the quotient and remainder.
+
+    See Also
+    --------
+    polyadd, polysub, polymulx, polymul, polypow
+
+    Examples
+    --------
+    >>> from numpy.polynomial import polynomial as P
+    >>> c1 = (1, 2, 3)
+    >>> c2 = (3, 2, 1)
+    >>> P.polydiv(c1, c2)
+    (array([3.]), array([-8., -4.]))
+    >>> P.polydiv(c2, c1)
+    (array([ 0.33333333]), array([ 2.66666667,  1.33333333]))  # may vary
+
+    """
+    # c1, c2 are trimmed copies
+    [c1, c2] = pu.as_series([c1, c2])
+    if c2[-1] == 0:
+        raise ZeroDivisionError()
+
+    # note: this is more efficient than `pu._div(polymul, c1, c2)`
+    lc1 = len(c1)
+    lc2 = len(c2)
+    if lc1 < lc2:
+        return c1[:1]*0, c1
+    elif lc2 == 1:
+        return c1/c2[-1], c1[:1]*0
+    else:
+        dlen = lc1 - lc2
+        scl = c2[-1]
+        c2 = c2[:-1]/scl
+        i = dlen
+        j = lc1 - 1
+        while i >= 0:
+            c1[i:j] -= c2*c1[j]
+            i -= 1
+            j -= 1
+        return c1[j+1:]/scl, pu.trimseq(c1[:j+1])
+
+
+def polypow(c, pow, maxpower=None):
+    """Raise a polynomial to a power.
+
+    Returns the polynomial `c` raised to the power `pow`. The argument
+    `c` is a sequence of coefficients ordered from low to high. i.e.,
+    [1,2,3] is the series  ``1 + 2*x + 3*x**2.``
+
+    Parameters
+    ----------
+    c : array_like
+        1-D array of array of series coefficients ordered from low to
+        high degree.
+    pow : integer
+        Power to which the series will be raised
+    maxpower : integer, optional
+        Maximum power allowed. This is mainly to limit growth of the series
+        to unmanageable size. Default is 16
+
+    Returns
+    -------
+    coef : ndarray
+        Power series of power.
+
+    See Also
+    --------
+    polyadd, polysub, polymulx, polymul, polydiv
+
+    Examples
+    --------
+    >>> from numpy.polynomial import polynomial as P
+    >>> P.polypow([1, 2, 3], 2)
+    array([ 1., 4., 10., 12., 9.])
+
+    """
+    # note: this is more efficient than `pu._pow(polymul, c1, c2)`, as it
+    # avoids calling `as_series` repeatedly
+    return pu._pow(np.convolve, c, pow, maxpower)
+
+
+def polyder(c, m=1, scl=1, axis=0):
+    """
+    Differentiate a polynomial.
+
+    Returns the polynomial coefficients `c` differentiated `m` times along
+    `axis`.  At each iteration the result is multiplied by `scl` (the
+    scaling factor is for use in a linear change of variable).  The
+    argument `c` is an array of coefficients from low to high degree along
+    each axis, e.g., [1,2,3] represents the polynomial ``1 + 2*x + 3*x**2``
+    while [[1,2],[1,2]] represents ``1 + 1*x + 2*y + 2*x*y`` if axis=0 is
+    ``x`` and axis=1 is ``y``.
+
+    Parameters
+    ----------
+    c : array_like
+        Array of polynomial coefficients. If c is multidimensional the
+        different axis correspond to different variables with the degree
+        in each axis given by the corresponding index.
+    m : int, optional
+        Number of derivatives taken, must be non-negative. (Default: 1)
+    scl : scalar, optional
+        Each differentiation is multiplied by `scl`.  The end result is
+        multiplication by ``scl**m``.  This is for use in a linear change
+        of variable. (Default: 1)
+    axis : int, optional
+        Axis over which the derivative is taken. (Default: 0).
+
+        .. versionadded:: 1.7.0
+
+    Returns
+    -------
+    der : ndarray
+        Polynomial coefficients of the derivative.
+
+    See Also
+    --------
+    polyint
+
+    Examples
+    --------
+    >>> from numpy.polynomial import polynomial as P
+    >>> c = (1, 2, 3, 4)
+    >>> P.polyder(c)  # (d/dx)(c)
+    array([  2.,   6.,  12.])
+    >>> P.polyder(c, 3)  # (d**3/dx**3)(c)
+    array([24.])
+    >>> P.polyder(c, scl=-1)  # (d/d(-x))(c)
+    array([ -2.,  -6., -12.])
+    >>> P.polyder(c, 2, -1)  # (d**2/d(-x)**2)(c)
+    array([  6.,  24.])
+
+    """
+    c = np.array(c, ndmin=1, copy=True)
+    if c.dtype.char in '?bBhHiIlLqQpP':
+        # astype fails with NA
+        c = c + 0.0
+    cdt = c.dtype
+    cnt = pu._as_int(m, "the order of derivation")
+    iaxis = pu._as_int(axis, "the axis")
+    if cnt < 0:
+        raise ValueError("The order of derivation must be non-negative")
+    iaxis = normalize_axis_index(iaxis, c.ndim)
+
+    if cnt == 0:
+        return c
+
+    c = np.moveaxis(c, iaxis, 0)
+    n = len(c)
+    if cnt >= n:
+        c = c[:1]*0
+    else:
+        for i in range(cnt):
+            n = n - 1
+            c *= scl
+            der = np.empty((n,) + c.shape[1:], dtype=cdt)
+            for j in range(n, 0, -1):
+                der[j - 1] = j*c[j]
+            c = der
+    c = np.moveaxis(c, 0, iaxis)
+    return c
+
+
+def polyint(c, m=1, k=[], lbnd=0, scl=1, axis=0):
+    """
+    Integrate a polynomial.
+
+    Returns the polynomial coefficients `c` integrated `m` times from
+    `lbnd` along `axis`.  At each iteration the resulting series is
+    **multiplied** by `scl` and an integration constant, `k`, is added.
+    The scaling factor is for use in a linear change of variable.  ("Buyer
+    beware": note that, depending on what one is doing, one may want `scl`
+    to be the reciprocal of what one might expect; for more information,
+    see the Notes section below.) The argument `c` is an array of
+    coefficients, from low to high degree along each axis, e.g., [1,2,3]
+    represents the polynomial ``1 + 2*x + 3*x**2`` while [[1,2],[1,2]]
+    represents ``1 + 1*x + 2*y + 2*x*y`` if axis=0 is ``x`` and axis=1 is
+    ``y``.
+
+    Parameters
+    ----------
+    c : array_like
+        1-D array of polynomial coefficients, ordered from low to high.
+    m : int, optional
+        Order of integration, must be positive. (Default: 1)
+    k : {[], list, scalar}, optional
+        Integration constant(s).  The value of the first integral at zero
+        is the first value in the list, the value of the second integral
+        at zero is the second value, etc.  If ``k == []`` (the default),
+        all constants are set to zero.  If ``m == 1``, a single scalar can
+        be given instead of a list.
+    lbnd : scalar, optional
+        The lower bound of the integral. (Default: 0)
+    scl : scalar, optional
+        Following each integration the result is *multiplied* by `scl`
+        before the integration constant is added. (Default: 1)
+    axis : int, optional
+        Axis over which the integral is taken. (Default: 0).
+
+        .. versionadded:: 1.7.0
+
+    Returns
+    -------
+    S : ndarray
+        Coefficient array of the integral.
+
+    Raises
+    ------
+    ValueError
+        If ``m < 1``, ``len(k) > m``, ``np.ndim(lbnd) != 0``, or
+        ``np.ndim(scl) != 0``.
+
+    See Also
+    --------
+    polyder
+
+    Notes
+    -----
+    Note that the result of each integration is *multiplied* by `scl`.  Why
+    is this important to note?  Say one is making a linear change of
+    variable :math:`u = ax + b` in an integral relative to `x`. Then
+    :math:`dx = du/a`, so one will need to set `scl` equal to
+    :math:`1/a` - perhaps not what one would have first thought.
+
+    Examples
+    --------
+    >>> from numpy.polynomial import polynomial as P
+    >>> c = (1, 2, 3)
+    >>> P.polyint(c)  # should return array([0, 1, 1, 1])
+    array([0.,  1.,  1.,  1.])
+    >>> P.polyint(c, 3)  # should return array([0, 0, 0, 1/6, 1/12, 1/20])
+     array([ 0.        ,  0.        ,  0.        ,  0.16666667,  0.08333333, # may vary
+             0.05      ])
+    >>> P.polyint(c, k=3)  # should return array([3, 1, 1, 1])
+    array([3.,  1.,  1.,  1.])
+    >>> P.polyint(c,lbnd=-2)  # should return array([6, 1, 1, 1])
+    array([6.,  1.,  1.,  1.])
+    >>> P.polyint(c,scl=-2)  # should return array([0, -2, -2, -2])
+    array([ 0., -2., -2., -2.])
+
+    """
+    c = np.array(c, ndmin=1, copy=True)
+    if c.dtype.char in '?bBhHiIlLqQpP':
+        # astype doesn't preserve mask attribute.
+        c = c + 0.0
+    cdt = c.dtype
+    if not np.iterable(k):
+        k = [k]
+    cnt = pu._as_int(m, "the order of integration")
+    iaxis = pu._as_int(axis, "the axis")
+    if cnt < 0:
+        raise ValueError("The order of integration must be non-negative")
+    if len(k) > cnt:
+        raise ValueError("Too many integration constants")
+    if np.ndim(lbnd) != 0:
+        raise ValueError("lbnd must be a scalar.")
+    if np.ndim(scl) != 0:
+        raise ValueError("scl must be a scalar.")
+    iaxis = normalize_axis_index(iaxis, c.ndim)
+
+    if cnt == 0:
+        return c
+
+    k = list(k) + [0]*(cnt - len(k))
+    c = np.moveaxis(c, iaxis, 0)
+    for i in range(cnt):
+        n = len(c)
+        c *= scl
+        if n == 1 and np.all(c[0] == 0):
+            c[0] += k[i]
+        else:
+            tmp = np.empty((n + 1,) + c.shape[1:], dtype=cdt)
+            tmp[0] = c[0]*0
+            tmp[1] = c[0]
+            for j in range(1, n):
+                tmp[j + 1] = c[j]/(j + 1)
+            tmp[0] += k[i] - polyval(lbnd, tmp)
+            c = tmp
+    c = np.moveaxis(c, 0, iaxis)
+    return c
+
+
+def polyval(x, c, tensor=True):
+    """
+    Evaluate a polynomial at points x.
+
+    If `c` is of length ``n + 1``, this function returns the value
+
+    .. math:: p(x) = c_0 + c_1 * x + ... + c_n * x^n
+
+    The parameter `x` is converted to an array only if it is a tuple or a
+    list, otherwise it is treated as a scalar. In either case, either `x`
+    or its elements must support multiplication and addition both with
+    themselves and with the elements of `c`.
+
+    If `c` is a 1-D array, then ``p(x)`` will have the same shape as `x`.  If
+    `c` is multidimensional, then the shape of the result depends on the
+    value of `tensor`. If `tensor` is true the shape will be c.shape[1:] +
+    x.shape. If `tensor` is false the shape will be c.shape[1:]. Note that
+    scalars have shape (,).
+
+    Trailing zeros in the coefficients will be used in the evaluation, so
+    they should be avoided if efficiency is a concern.
+
+    Parameters
+    ----------
+    x : array_like, compatible object
+        If `x` is a list or tuple, it is converted to an ndarray, otherwise
+        it is left unchanged and treated as a scalar. In either case, `x`
+        or its elements must support addition and multiplication with
+        with themselves and with the elements of `c`.
+    c : array_like
+        Array of coefficients ordered so that the coefficients for terms of
+        degree n are contained in c[n]. If `c` is multidimensional the
+        remaining indices enumerate multiple polynomials. In the two
+        dimensional case the coefficients may be thought of as stored in
+        the columns of `c`.
+    tensor : boolean, optional
+        If True, the shape of the coefficient array is extended with ones
+        on the right, one for each dimension of `x`. Scalars have dimension 0
+        for this action. The result is that every column of coefficients in
+        `c` is evaluated for every element of `x`. If False, `x` is broadcast
+        over the columns of `c` for the evaluation.  This keyword is useful
+        when `c` is multidimensional. The default value is True.
+
+        .. versionadded:: 1.7.0
+
+    Returns
+    -------
+    values : ndarray, compatible object
+        The shape of the returned array is described above.
+
+    See Also
+    --------
+    polyval2d, polygrid2d, polyval3d, polygrid3d
+
+    Notes
+    -----
+    The evaluation uses Horner's method.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from numpy.polynomial.polynomial import polyval
+    >>> polyval(1, [1,2,3])
+    6.0
+    >>> a = np.arange(4).reshape(2,2)
+    >>> a
+    array([[0, 1],
+           [2, 3]])
+    >>> polyval(a, [1, 2, 3])
+    array([[ 1.,   6.],
+           [17.,  34.]])
+    >>> coef = np.arange(4).reshape(2, 2)  # multidimensional coefficients
+    >>> coef
+    array([[0, 1],
+           [2, 3]])
+    >>> polyval([1, 2], coef, tensor=True)
+    array([[2.,  4.],
+           [4.,  7.]])
+    >>> polyval([1, 2], coef, tensor=False)
+    array([2.,  7.])
+
+    """
+    c = np.array(c, ndmin=1, copy=None)
+    if c.dtype.char in '?bBhHiIlLqQpP':
+        # astype fails with NA
+        c = c + 0.0
+    if isinstance(x, (tuple, list)):
+        x = np.asarray(x)
+    if isinstance(x, np.ndarray) and tensor:
+        c = c.reshape(c.shape + (1,)*x.ndim)
+
+    c0 = c[-1] + x*0
+    for i in range(2, len(c) + 1):
+        c0 = c[-i] + c0*x
+    return c0
+
+
+def polyvalfromroots(x, r, tensor=True):
+    """
+    Evaluate a polynomial specified by its roots at points x.
+
+    If `r` is of length ``N``, this function returns the value
+
+    .. math:: p(x) = \\prod_{n=1}^{N} (x - r_n)
+
+    The parameter `x` is converted to an array only if it is a tuple or a
+    list, otherwise it is treated as a scalar. In either case, either `x`
+    or its elements must support multiplication and addition both with
+    themselves and with the elements of `r`.
+
+    If `r` is a 1-D array, then ``p(x)`` will have the same shape as `x`.  If `r`
+    is multidimensional, then the shape of the result depends on the value of
+    `tensor`. If `tensor` is ``True`` the shape will be r.shape[1:] + x.shape;
+    that is, each polynomial is evaluated at every value of `x`. If `tensor` is
+    ``False``, the shape will be r.shape[1:]; that is, each polynomial is
+    evaluated only for the corresponding broadcast value of `x`. Note that
+    scalars have shape (,).
+
+    .. versionadded:: 1.12
+
+    Parameters
+    ----------
+    x : array_like, compatible object
+        If `x` is a list or tuple, it is converted to an ndarray, otherwise
+        it is left unchanged and treated as a scalar. In either case, `x`
+        or its elements must support addition and multiplication with
+        with themselves and with the elements of `r`.
+    r : array_like
+        Array of roots. If `r` is multidimensional the first index is the
+        root index, while the remaining indices enumerate multiple
+        polynomials. For instance, in the two dimensional case the roots
+        of each polynomial may be thought of as stored in the columns of `r`.
+    tensor : boolean, optional
+        If True, the shape of the roots array is extended with ones on the
+        right, one for each dimension of `x`. Scalars have dimension 0 for this
+        action. The result is that every column of coefficients in `r` is
+        evaluated for every element of `x`. If False, `x` is broadcast over the
+        columns of `r` for the evaluation.  This keyword is useful when `r` is
+        multidimensional. The default value is True.
+
+    Returns
+    -------
+    values : ndarray, compatible object
+        The shape of the returned array is described above.
+
+    See Also
+    --------
+    polyroots, polyfromroots, polyval
+
+    Examples
+    --------
+    >>> from numpy.polynomial.polynomial import polyvalfromroots
+    >>> polyvalfromroots(1, [1, 2, 3])
+    0.0
+    >>> a = np.arange(4).reshape(2, 2)
+    >>> a
+    array([[0, 1],
+           [2, 3]])
+    >>> polyvalfromroots(a, [-1, 0, 1])
+    array([[-0.,   0.],
+           [ 6.,  24.]])
+    >>> r = np.arange(-2, 2).reshape(2,2)  # multidimensional coefficients
+    >>> r # each column of r defines one polynomial
+    array([[-2, -1],
+           [ 0,  1]])
+    >>> b = [-2, 1]
+    >>> polyvalfromroots(b, r, tensor=True)
+    array([[-0.,  3.],
+           [ 3., 0.]])
+    >>> polyvalfromroots(b, r, tensor=False)
+    array([-0.,  0.])
+
+    """
+    r = np.array(r, ndmin=1, copy=None)
+    if r.dtype.char in '?bBhHiIlLqQpP':
+        r = r.astype(np.double)
+    if isinstance(x, (tuple, list)):
+        x = np.asarray(x)
+    if isinstance(x, np.ndarray):
+        if tensor:
+            r = r.reshape(r.shape + (1,)*x.ndim)
+        elif x.ndim >= r.ndim:
+            raise ValueError("x.ndim must be < r.ndim when tensor == False")
+    return np.prod(x - r, axis=0)
+
+
+def polyval2d(x, y, c):
+    """
+    Evaluate a 2-D polynomial at points (x, y).
+
+    This function returns the value
+
+    .. math:: p(x,y) = \\sum_{i,j} c_{i,j} * x^i * y^j
+
+    The parameters `x` and `y` are converted to arrays only if they are
+    tuples or a lists, otherwise they are treated as a scalars and they
+    must have the same shape after conversion. In either case, either `x`
+    and `y` or their elements must support multiplication and addition both
+    with themselves and with the elements of `c`.
+
+    If `c` has fewer than two dimensions, ones are implicitly appended to
+    its shape to make it 2-D. The shape of the result will be c.shape[2:] +
+    x.shape.
+
+    Parameters
+    ----------
+    x, y : array_like, compatible objects
+        The two dimensional series is evaluated at the points ``(x, y)``,
+        where `x` and `y` must have the same shape. If `x` or `y` is a list
+        or tuple, it is first converted to an ndarray, otherwise it is left
+        unchanged and, if it isn't an ndarray, it is treated as a scalar.
+    c : array_like
+        Array of coefficients ordered so that the coefficient of the term
+        of multi-degree i,j is contained in ``c[i,j]``. If `c` has
+        dimension greater than two the remaining indices enumerate multiple
+        sets of coefficients.
+
+    Returns
+    -------
+    values : ndarray, compatible object
+        The values of the two dimensional polynomial at points formed with
+        pairs of corresponding values from `x` and `y`.
+
+    See Also
+    --------
+    polyval, polygrid2d, polyval3d, polygrid3d
+
+    Notes
+    -----
+
+    .. versionadded:: 1.7.0
+
+    Examples
+    --------
+    >>> from numpy.polynomial import polynomial as P
+    >>> c = ((1, 2, 3), (4, 5, 6))
+    >>> P.polyval2d(1, 1, c) 
+    21.0
+
+    """
+    return pu._valnd(polyval, c, x, y)
+
+
+def polygrid2d(x, y, c):
+    """
+    Evaluate a 2-D polynomial on the Cartesian product of x and y.
+
+    This function returns the values:
+
+    .. math:: p(a,b) = \\sum_{i,j} c_{i,j} * a^i * b^j
+
+    where the points ``(a, b)`` consist of all pairs formed by taking
+    `a` from `x` and `b` from `y`. The resulting points form a grid with
+    `x` in the first dimension and `y` in the second.
+
+    The parameters `x` and `y` are converted to arrays only if they are
+    tuples or a lists, otherwise they are treated as a scalars. In either
+    case, either `x` and `y` or their elements must support multiplication
+    and addition both with themselves and with the elements of `c`.
+
+    If `c` has fewer than two dimensions, ones are implicitly appended to
+    its shape to make it 2-D. The shape of the result will be c.shape[2:] +
+    x.shape + y.shape.
+
+    Parameters
+    ----------
+    x, y : array_like, compatible objects
+        The two dimensional series is evaluated at the points in the
+        Cartesian product of `x` and `y`.  If `x` or `y` is a list or
+        tuple, it is first converted to an ndarray, otherwise it is left
+        unchanged and, if it isn't an ndarray, it is treated as a scalar.
+    c : array_like
+        Array of coefficients ordered so that the coefficients for terms of
+        degree i,j are contained in ``c[i,j]``. If `c` has dimension
+        greater than two the remaining indices enumerate multiple sets of
+        coefficients.
+
+    Returns
+    -------
+    values : ndarray, compatible object
+        The values of the two dimensional polynomial at points in the Cartesian
+        product of `x` and `y`.
+
+    See Also
+    --------
+    polyval, polyval2d, polyval3d, polygrid3d
+
+    Notes
+    -----
+
+    .. versionadded:: 1.7.0
+
+    Examples
+    --------
+    >>> from numpy.polynomial import polynomial as P
+    >>> c = ((1, 2, 3), (4, 5, 6))
+    >>> P.polygrid2d([0, 1], [0, 1], c)
+    array([[ 1.,  6.],
+           [ 5., 21.]])
+
+    """
+    return pu._gridnd(polyval, c, x, y)
+
+
+def polyval3d(x, y, z, c):
+    """
+    Evaluate a 3-D polynomial at points (x, y, z).
+
+    This function returns the values:
+
+    .. math:: p(x,y,z) = \\sum_{i,j,k} c_{i,j,k} * x^i * y^j * z^k
+
+    The parameters `x`, `y`, and `z` are converted to arrays only if
+    they are tuples or a lists, otherwise they are treated as a scalars and
+    they must have the same shape after conversion. In either case, either
+    `x`, `y`, and `z` or their elements must support multiplication and
+    addition both with themselves and with the elements of `c`.
+
+    If `c` has fewer than 3 dimensions, ones are implicitly appended to its
+    shape to make it 3-D. The shape of the result will be c.shape[3:] +
+    x.shape.
+
+    Parameters
+    ----------
+    x, y, z : array_like, compatible object
+        The three dimensional series is evaluated at the points
+        ``(x, y, z)``, where `x`, `y`, and `z` must have the same shape.  If
+        any of `x`, `y`, or `z` is a list or tuple, it is first converted
+        to an ndarray, otherwise it is left unchanged and if it isn't an
+        ndarray it is  treated as a scalar.
+    c : array_like
+        Array of coefficients ordered so that the coefficient of the term of
+        multi-degree i,j,k is contained in ``c[i,j,k]``. If `c` has dimension
+        greater than 3 the remaining indices enumerate multiple sets of
+        coefficients.
+
+    Returns
+    -------
+    values : ndarray, compatible object
+        The values of the multidimensional polynomial on points formed with
+        triples of corresponding values from `x`, `y`, and `z`.
+
+    See Also
+    --------
+    polyval, polyval2d, polygrid2d, polygrid3d
+
+    Notes
+    -----
+
+    .. versionadded:: 1.7.0
+
+    Examples
+    --------
+    >>> from numpy.polynomial import polynomial as P
+    >>> c = ((1, 2, 3), (4, 5, 6), (7, 8, 9))
+    >>> P.polyval3d(1, 1, 1, c)
+    45.0
+
+    """
+    return pu._valnd(polyval, c, x, y, z)
+
+
+def polygrid3d(x, y, z, c):
+    """
+    Evaluate a 3-D polynomial on the Cartesian product of x, y and z.
+
+    This function returns the values:
+
+    .. math:: p(a,b,c) = \\sum_{i,j,k} c_{i,j,k} * a^i * b^j * c^k
+
+    where the points ``(a, b, c)`` consist of all triples formed by taking
+    `a` from `x`, `b` from `y`, and `c` from `z`. The resulting points form
+    a grid with `x` in the first dimension, `y` in the second, and `z` in
+    the third.
+
+    The parameters `x`, `y`, and `z` are converted to arrays only if they
+    are tuples or a lists, otherwise they are treated as a scalars. In
+    either case, either `x`, `y`, and `z` or their elements must support
+    multiplication and addition both with themselves and with the elements
+    of `c`.
+
+    If `c` has fewer than three dimensions, ones are implicitly appended to
+    its shape to make it 3-D. The shape of the result will be c.shape[3:] +
+    x.shape + y.shape + z.shape.
+
+    Parameters
+    ----------
+    x, y, z : array_like, compatible objects
+        The three dimensional series is evaluated at the points in the
+        Cartesian product of `x`, `y`, and `z`.  If `x`, `y`, or `z` is a
+        list or tuple, it is first converted to an ndarray, otherwise it is
+        left unchanged and, if it isn't an ndarray, it is treated as a
+        scalar.
+    c : array_like
+        Array of coefficients ordered so that the coefficients for terms of
+        degree i,j are contained in ``c[i,j]``. If `c` has dimension
+        greater than two the remaining indices enumerate multiple sets of
+        coefficients.
+
+    Returns
+    -------
+    values : ndarray, compatible object
+        The values of the two dimensional polynomial at points in the Cartesian
+        product of `x` and `y`.
+
+    See Also
+    --------
+    polyval, polyval2d, polygrid2d, polyval3d
+
+    Notes
+    -----
+
+    .. versionadded:: 1.7.0
+
+    Examples
+    --------
+    >>> from numpy.polynomial import polynomial as P
+    >>> c = ((1, 2, 3), (4, 5, 6), (7, 8, 9))
+    >>> P.polygrid3d([0, 1], [0, 1], [0, 1], c)
+    array([[ 1., 13.],
+           [ 6., 51.]])
+
+    """
+    return pu._gridnd(polyval, c, x, y, z)
+
+
+def polyvander(x, deg):
+    """Vandermonde matrix of given degree.
+
+    Returns the Vandermonde matrix of degree `deg` and sample points
+    `x`. The Vandermonde matrix is defined by
+
+    .. math:: V[..., i] = x^i,
+
+    where ``0 <= i <= deg``. The leading indices of `V` index the elements of
+    `x` and the last index is the power of `x`.
+
+    If `c` is a 1-D array of coefficients of length ``n + 1`` and `V` is the
+    matrix ``V = polyvander(x, n)``, then ``np.dot(V, c)`` and
+    ``polyval(x, c)`` are the same up to roundoff. This equivalence is
+    useful both for least squares fitting and for the evaluation of a large
+    number of polynomials of the same degree and sample points.
+
+    Parameters
+    ----------
+    x : array_like
+        Array of points. The dtype is converted to float64 or complex128
+        depending on whether any of the elements are complex. If `x` is
+        scalar it is converted to a 1-D array.
+    deg : int
+        Degree of the resulting matrix.
+
+    Returns
+    -------
+    vander : ndarray.
+        The Vandermonde matrix. The shape of the returned matrix is
+        ``x.shape + (deg + 1,)``, where the last index is the power of `x`.
+        The dtype will be the same as the converted `x`.
+
+    See Also
+    --------
+    polyvander2d, polyvander3d
+
+    Examples
+    --------
+    The Vandermonde matrix of degree ``deg = 5`` and sample points
+    ``x = [-1, 2, 3]`` contains the element-wise powers of `x` 
+    from 0 to 5 as its columns.
+
+    >>> from numpy.polynomial import polynomial as P
+    >>> x, deg = [-1, 2, 3], 5
+    >>> P.polyvander(x=x, deg=deg)
+    array([[  1.,  -1.,   1.,  -1.,   1.,  -1.],
+           [  1.,   2.,   4.,   8.,  16.,  32.],
+           [  1.,   3.,   9.,  27.,  81., 243.]])
+
+    """
+    ideg = pu._as_int(deg, "deg")
+    if ideg < 0:
+        raise ValueError("deg must be non-negative")
+
+    x = np.array(x, copy=None, ndmin=1) + 0.0
+    dims = (ideg + 1,) + x.shape
+    dtyp = x.dtype
+    v = np.empty(dims, dtype=dtyp)
+    v[0] = x*0 + 1
+    if ideg > 0:
+        v[1] = x
+        for i in range(2, ideg + 1):
+            v[i] = v[i-1]*x
+    return np.moveaxis(v, 0, -1)
+
+
+def polyvander2d(x, y, deg):
+    """Pseudo-Vandermonde matrix of given degrees.
+
+    Returns the pseudo-Vandermonde matrix of degrees `deg` and sample
+    points ``(x, y)``. The pseudo-Vandermonde matrix is defined by
+
+    .. math:: V[..., (deg[1] + 1)*i + j] = x^i * y^j,
+
+    where ``0 <= i <= deg[0]`` and ``0 <= j <= deg[1]``. The leading indices of
+    `V` index the points ``(x, y)`` and the last index encodes the powers of
+    `x` and `y`.
+
+    If ``V = polyvander2d(x, y, [xdeg, ydeg])``, then the columns of `V`
+    correspond to the elements of a 2-D coefficient array `c` of shape
+    (xdeg + 1, ydeg + 1) in the order
+
+    .. math:: c_{00}, c_{01}, c_{02} ... , c_{10}, c_{11}, c_{12} ...
+
+    and ``np.dot(V, c.flat)`` and ``polyval2d(x, y, c)`` will be the same
+    up to roundoff. This equivalence is useful both for least squares
+    fitting and for the evaluation of a large number of 2-D polynomials
+    of the same degrees and sample points.
+
+    Parameters
+    ----------
+    x, y : array_like
+        Arrays of point coordinates, all of the same shape. The dtypes
+        will be converted to either float64 or complex128 depending on
+        whether any of the elements are complex. Scalars are converted to
+        1-D arrays.
+    deg : list of ints
+        List of maximum degrees of the form [x_deg, y_deg].
+
+    Returns
+    -------
+    vander2d : ndarray
+        The shape of the returned matrix is ``x.shape + (order,)``, where
+        :math:`order = (deg[0]+1)*(deg([1]+1)`.  The dtype will be the same
+        as the converted `x` and `y`.
+
+    See Also
+    --------
+    polyvander, polyvander3d, polyval2d, polyval3d
+
+    Examples
+    --------
+    >>> import numpy as np
+
+    The 2-D pseudo-Vandermonde matrix of degree ``[1, 2]`` and sample
+    points ``x = [-1, 2]`` and ``y = [1, 3]`` is as follows:
+
+    >>> from numpy.polynomial import polynomial as P
+    >>> x = np.array([-1, 2])
+    >>> y = np.array([1, 3])
+    >>> m, n = 1, 2
+    >>> deg = np.array([m, n])
+    >>> V = P.polyvander2d(x=x, y=y, deg=deg)
+    >>> V
+    array([[ 1.,  1.,  1., -1., -1., -1.],
+           [ 1.,  3.,  9.,  2.,  6., 18.]])
+
+    We can verify the columns for any ``0 <= i <= m`` and ``0 <= j <= n``:
+
+    >>> i, j = 0, 1
+    >>> V[:, (deg[1]+1)*i + j] == x**i * y**j
+    array([ True,  True])
+
+    The (1D) Vandermonde matrix of sample points ``x`` and degree ``m`` is a
+    special case of the (2D) pseudo-Vandermonde matrix with ``y`` points all
+    zero and degree ``[m, 0]``.
+
+    >>> P.polyvander2d(x=x, y=0*x, deg=(m, 0)) == P.polyvander(x=x, deg=m)
+    array([[ True,  True],
+           [ True,  True]])
+    
+    """
+    return pu._vander_nd_flat((polyvander, polyvander), (x, y), deg)
+
+
+def polyvander3d(x, y, z, deg):
+    """Pseudo-Vandermonde matrix of given degrees.
+
+    Returns the pseudo-Vandermonde matrix of degrees `deg` and sample
+    points ``(x, y, z)``. If `l`, `m`, `n` are the given degrees in `x`, `y`, `z`,
+    then The pseudo-Vandermonde matrix is defined by
+
+    .. math:: V[..., (m+1)(n+1)i + (n+1)j + k] = x^i * y^j * z^k,
+
+    where ``0 <= i <= l``, ``0 <= j <= m``, and ``0 <= j <= n``.  The leading
+    indices of `V` index the points ``(x, y, z)`` and the last index encodes
+    the powers of `x`, `y`, and `z`.
+
+    If ``V = polyvander3d(x, y, z, [xdeg, ydeg, zdeg])``, then the columns
+    of `V` correspond to the elements of a 3-D coefficient array `c` of
+    shape (xdeg + 1, ydeg + 1, zdeg + 1) in the order
+
+    .. math:: c_{000}, c_{001}, c_{002},... , c_{010}, c_{011}, c_{012},...
+
+    and  ``np.dot(V, c.flat)`` and ``polyval3d(x, y, z, c)`` will be the
+    same up to roundoff. This equivalence is useful both for least squares
+    fitting and for the evaluation of a large number of 3-D polynomials
+    of the same degrees and sample points.
+
+    Parameters
+    ----------
+    x, y, z : array_like
+        Arrays of point coordinates, all of the same shape. The dtypes will
+        be converted to either float64 or complex128 depending on whether
+        any of the elements are complex. Scalars are converted to 1-D
+        arrays.
+    deg : list of ints
+        List of maximum degrees of the form [x_deg, y_deg, z_deg].
+
+    Returns
+    -------
+    vander3d : ndarray
+        The shape of the returned matrix is ``x.shape + (order,)``, where
+        :math:`order = (deg[0]+1)*(deg([1]+1)*(deg[2]+1)`.  The dtype will
+        be the same as the converted `x`, `y`, and `z`.
+
+    See Also
+    --------
+    polyvander, polyvander3d, polyval2d, polyval3d
+
+    Notes
+    -----
+
+    .. versionadded:: 1.7.0
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from numpy.polynomial import polynomial as P
+    >>> x = np.asarray([-1, 2, 1])
+    >>> y = np.asarray([1, -2, -3])
+    >>> z = np.asarray([2, 2, 5])
+    >>> l, m, n = [2, 2, 1]
+    >>> deg = [l, m, n]
+    >>> V = P.polyvander3d(x=x, y=y, z=z, deg=deg)
+    >>> V
+    array([[  1.,   2.,   1.,   2.,   1.,   2.,  -1.,  -2.,  -1.,
+             -2.,  -1.,  -2.,   1.,   2.,   1.,   2.,   1.,   2.],
+           [  1.,   2.,  -2.,  -4.,   4.,   8.,   2.,   4.,  -4.,
+             -8.,   8.,  16.,   4.,   8.,  -8., -16.,  16.,  32.],
+           [  1.,   5.,  -3., -15.,   9.,  45.,   1.,   5.,  -3.,
+            -15.,   9.,  45.,   1.,   5.,  -3., -15.,   9.,  45.]])
+    
+    We can verify the columns for any ``0 <= i <= l``, ``0 <= j <= m``,
+    and ``0 <= k <= n``
+
+    >>> i, j, k = 2, 1, 0
+    >>> V[:, (m+1)*(n+1)*i + (n+1)*j + k] == x**i * y**j * z**k
+    array([ True,  True,  True])
+
+    """
+    return pu._vander_nd_flat((polyvander, polyvander, polyvander), (x, y, z), deg)
+
+
+def polyfit(x, y, deg, rcond=None, full=False, w=None):
+    """
+    Least-squares fit of a polynomial to data.
+
+    Return the coefficients of a polynomial of degree `deg` that is the
+    least squares fit to the data values `y` given at points `x`. If `y` is
+    1-D the returned coefficients will also be 1-D. If `y` is 2-D multiple
+    fits are done, one for each column of `y`, and the resulting
+    coefficients are stored in the corresponding columns of a 2-D return.
+    The fitted polynomial(s) are in the form
+
+    .. math::  p(x) = c_0 + c_1 * x + ... + c_n * x^n,
+
+    where `n` is `deg`.
+
+    Parameters
+    ----------
+    x : array_like, shape (`M`,)
+        x-coordinates of the `M` sample (data) points ``(x[i], y[i])``.
+    y : array_like, shape (`M`,) or (`M`, `K`)
+        y-coordinates of the sample points.  Several sets of sample points
+        sharing the same x-coordinates can be (independently) fit with one
+        call to `polyfit` by passing in for `y` a 2-D array that contains
+        one data set per column.
+    deg : int or 1-D array_like
+        Degree(s) of the fitting polynomials. If `deg` is a single integer
+        all terms up to and including the `deg`'th term are included in the
+        fit. For NumPy versions >= 1.11.0 a list of integers specifying the
+        degrees of the terms to include may be used instead.
+    rcond : float, optional
+        Relative condition number of the fit.  Singular values smaller
+        than `rcond`, relative to the largest singular value, will be
+        ignored.  The default value is ``len(x)*eps``, where `eps` is the
+        relative precision of the platform's float type, about 2e-16 in
+        most cases.
+    full : bool, optional
+        Switch determining the nature of the return value.  When ``False``
+        (the default) just the coefficients are returned; when ``True``,
+        diagnostic information from the singular value decomposition (used
+        to solve the fit's matrix equation) is also returned.
+    w : array_like, shape (`M`,), optional
+        Weights. If not None, the weight ``w[i]`` applies to the unsquared
+        residual ``y[i] - y_hat[i]`` at ``x[i]``. Ideally the weights are
+        chosen so that the errors of the products ``w[i]*y[i]`` all have the
+        same variance.  When using inverse-variance weighting, use
+        ``w[i] = 1/sigma(y[i])``.  The default value is None.
+
+        .. versionadded:: 1.5.0
+
+    Returns
+    -------
+    coef : ndarray, shape (`deg` + 1,) or (`deg` + 1, `K`)
+        Polynomial coefficients ordered from low to high.  If `y` was 2-D,
+        the coefficients in column `k` of `coef` represent the polynomial
+        fit to the data in `y`'s `k`-th column.
+
+    [residuals, rank, singular_values, rcond] : list
+        These values are only returned if ``full == True``
+
+        - residuals -- sum of squared residuals of the least squares fit
+        - rank -- the numerical rank of the scaled Vandermonde matrix
+        - singular_values -- singular values of the scaled Vandermonde matrix
+        - rcond -- value of `rcond`.
+
+        For more details, see `numpy.linalg.lstsq`.
+
+    Raises
+    ------
+    RankWarning
+        Raised if the matrix in the least-squares fit is rank deficient.
+        The warning is only raised if ``full == False``.  The warnings can
+        be turned off by:
+
+        >>> import warnings
+        >>> warnings.simplefilter('ignore', np.exceptions.RankWarning)
+
+    See Also
+    --------
+    numpy.polynomial.chebyshev.chebfit
+    numpy.polynomial.legendre.legfit
+    numpy.polynomial.laguerre.lagfit
+    numpy.polynomial.hermite.hermfit
+    numpy.polynomial.hermite_e.hermefit
+    polyval : Evaluates a polynomial.
+    polyvander : Vandermonde matrix for powers.
+    numpy.linalg.lstsq : Computes a least-squares fit from the matrix.
+    scipy.interpolate.UnivariateSpline : Computes spline fits.
+
+    Notes
+    -----
+    The solution is the coefficients of the polynomial `p` that minimizes
+    the sum of the weighted squared errors
+
+    .. math:: E = \\sum_j w_j^2 * |y_j - p(x_j)|^2,
+
+    where the :math:`w_j` are the weights. This problem is solved by
+    setting up the (typically) over-determined matrix equation:
+
+    .. math:: V(x) * c = w * y,
+
+    where `V` is the weighted pseudo Vandermonde matrix of `x`, `c` are the
+    coefficients to be solved for, `w` are the weights, and `y` are the
+    observed values.  This equation is then solved using the singular value
+    decomposition of `V`.
+
+    If some of the singular values of `V` are so small that they are
+    neglected (and `full` == ``False``), a `~exceptions.RankWarning` will be
+    raised.  This means that the coefficient values may be poorly determined.
+    Fitting to a lower order polynomial will usually get rid of the warning
+    (but may not be what you want, of course; if you have independent
+    reason(s) for choosing the degree which isn't working, you may have to:
+    a) reconsider those reasons, and/or b) reconsider the quality of your
+    data).  The `rcond` parameter can also be set to a value smaller than
+    its default, but the resulting fit may be spurious and have large
+    contributions from roundoff error.
+
+    Polynomial fits using double precision tend to "fail" at about
+    (polynomial) degree 20. Fits using Chebyshev or Legendre series are
+    generally better conditioned, but much can still depend on the
+    distribution of the sample points and the smoothness of the data.  If
+    the quality of the fit is inadequate, splines may be a good
+    alternative.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from numpy.polynomial import polynomial as P
+    >>> x = np.linspace(-1,1,51)  # x "data": [-1, -0.96, ..., 0.96, 1]
+    >>> rng = np.random.default_rng()
+    >>> err = rng.normal(size=len(x))
+    >>> y = x**3 - x + err  # x^3 - x + Gaussian noise
+    >>> c, stats = P.polyfit(x,y,3,full=True)
+    >>> c # c[0], c[1] approx. -1, c[2] should be approx. 0, c[3] approx. 1
+    array([ 0.23111996, -1.02785049, -0.2241444 ,  1.08405657]) # may vary
+    >>> stats # note the large SSR, explaining the rather poor results
+    [array([48.312088]),                                        # may vary
+     4,
+     array([1.38446749, 1.32119158, 0.50443316, 0.28853036]),
+     1.1324274851176597e-14]
+
+    Same thing without the added noise
+
+    >>> y = x**3 - x
+    >>> c, stats = P.polyfit(x,y,3,full=True)
+    >>> c # c[0], c[1] ~= -1, c[2] should be "very close to 0", c[3] ~= 1
+    array([-6.73496154e-17, -1.00000000e+00,  0.00000000e+00,  1.00000000e+00])
+    >>> stats # note the minuscule SSR
+    [array([8.79579319e-31]),
+     4,
+     array([1.38446749, 1.32119158, 0.50443316, 0.28853036]),
+     1.1324274851176597e-14]
+
+    """
+    return pu._fit(polyvander, x, y, deg, rcond, full, w)
+
+
+def polycompanion(c):
+    """
+    Return the companion matrix of c.
+
+    The companion matrix for power series cannot be made symmetric by
+    scaling the basis, so this function differs from those for the
+    orthogonal polynomials.
+
+    Parameters
+    ----------
+    c : array_like
+        1-D array of polynomial coefficients ordered from low to high
+        degree.
+
+    Returns
+    -------
+    mat : ndarray
+        Companion matrix of dimensions (deg, deg).
+
+    Notes
+    -----
+
+    .. versionadded:: 1.7.0
+
+    Examples
+    --------
+    >>> from numpy.polynomial import polynomial as P
+    >>> c = (1, 2, 3)
+    >>> P.polycompanion(c)
+    array([[ 0.        , -0.33333333],
+           [ 1.        , -0.66666667]])
+
+    """
+    # c is a trimmed copy
+    [c] = pu.as_series([c])
+    if len(c) < 2:
+        raise ValueError('Series must have maximum degree of at least 1.')
+    if len(c) == 2:
+        return np.array([[-c[0]/c[1]]])
+
+    n = len(c) - 1
+    mat = np.zeros((n, n), dtype=c.dtype)
+    bot = mat.reshape(-1)[n::n+1]
+    bot[...] = 1
+    mat[:, -1] -= c[:-1]/c[-1]
+    return mat
+
+
+def polyroots(c):
+    """
+    Compute the roots of a polynomial.
+
+    Return the roots (a.k.a. "zeros") of the polynomial
+
+    .. math:: p(x) = \\sum_i c[i] * x^i.
+
+    Parameters
+    ----------
+    c : 1-D array_like
+        1-D array of polynomial coefficients.
+
+    Returns
+    -------
+    out : ndarray
+        Array of the roots of the polynomial. If all the roots are real,
+        then `out` is also real, otherwise it is complex.
+
+    See Also
+    --------
+    numpy.polynomial.chebyshev.chebroots
+    numpy.polynomial.legendre.legroots
+    numpy.polynomial.laguerre.lagroots
+    numpy.polynomial.hermite.hermroots
+    numpy.polynomial.hermite_e.hermeroots
+
+    Notes
+    -----
+    The root estimates are obtained as the eigenvalues of the companion
+    matrix, Roots far from the origin of the complex plane may have large
+    errors due to the numerical instability of the power series for such
+    values. Roots with multiplicity greater than 1 will also show larger
+    errors as the value of the series near such points is relatively
+    insensitive to errors in the roots. Isolated roots near the origin can
+    be improved by a few iterations of Newton's method.
+
+    Examples
+    --------
+    >>> import numpy.polynomial.polynomial as poly
+    >>> poly.polyroots(poly.polyfromroots((-1,0,1)))
+    array([-1.,  0.,  1.])
+    >>> poly.polyroots(poly.polyfromroots((-1,0,1))).dtype
+    dtype('float64')
+    >>> j = complex(0,1)
+    >>> poly.polyroots(poly.polyfromroots((-j,0,j)))
+    array([  0.00000000e+00+0.j,   0.00000000e+00+1.j,   2.77555756e-17-1.j])  # may vary
+
+    """  # noqa: E501
+    # c is a trimmed copy
+    [c] = pu.as_series([c])
+    if len(c) < 2:
+        return np.array([], dtype=c.dtype)
+    if len(c) == 2:
+        return np.array([-c[0]/c[1]])
+
+    # rotated companion matrix reduces error
+    m = polycompanion(c)[::-1,::-1]
+    r = la.eigvals(m)
+    r.sort()
+    return r
+
+
+#
+# polynomial class
+#
+
+class Polynomial(ABCPolyBase):
+    """A power series class.
+
+    The Polynomial class provides the standard Python numerical methods
+    '+', '-', '*', '//', '%', 'divmod', '**', and '()' as well as the
+    attributes and methods listed below.
+
+    Parameters
+    ----------
+    coef : array_like
+        Polynomial coefficients in order of increasing degree, i.e.,
+        ``(1, 2, 3)`` give ``1 + 2*x + 3*x**2``.
+    domain : (2,) array_like, optional
+        Domain to use. The interval ``[domain[0], domain[1]]`` is mapped
+        to the interval ``[window[0], window[1]]`` by shifting and scaling.
+        The default value is [-1., 1.].
+    window : (2,) array_like, optional
+        Window, see `domain` for its use. The default value is [-1., 1.].
+
+        .. versionadded:: 1.6.0
+    symbol : str, optional
+        Symbol used to represent the independent variable in string
+        representations of the polynomial expression, e.g. for printing.
+        The symbol must be a valid Python identifier. Default value is 'x'.
+
+        .. versionadded:: 1.24
+
+    """
+    # Virtual Functions
+    _add = staticmethod(polyadd)
+    _sub = staticmethod(polysub)
+    _mul = staticmethod(polymul)
+    _div = staticmethod(polydiv)
+    _pow = staticmethod(polypow)
+    _val = staticmethod(polyval)
+    _int = staticmethod(polyint)
+    _der = staticmethod(polyder)
+    _fit = staticmethod(polyfit)
+    _line = staticmethod(polyline)
+    _roots = staticmethod(polyroots)
+    _fromroots = staticmethod(polyfromroots)
+
+    # Virtual properties
+    domain = np.array(polydomain)
+    window = np.array(polydomain)
+    basis_name = None
+
+    @classmethod
+    def _str_term_unicode(cls, i, arg_str):
+        if i == '1':
+            return f"·{arg_str}"
+        else:
+            return f"·{arg_str}{i.translate(cls._superscript_mapping)}"
+
+    @staticmethod
+    def _str_term_ascii(i, arg_str):
+        if i == '1':
+            return f" {arg_str}"
+        else:
+            return f" {arg_str}**{i}"
+
+    @staticmethod
+    def _repr_latex_term(i, arg_str, needs_parens):
+        if needs_parens:
+            arg_str = rf"\left({arg_str}\right)"
+        if i == 0:
+            return '1'
+        elif i == 1:
+            return arg_str
+        else:
+            return f"{arg_str}^{{{i}}}"
diff --git a/venv/lib/python3.12/site-packages/numpy/polynomial/polynomial.pyi b/venv/lib/python3.12/site-packages/numpy/polynomial/polynomial.pyi
new file mode 100644
index 00000000..89a8b571
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/polynomial/polynomial.pyi
@@ -0,0 +1,87 @@
+from typing import Final, Literal as L
+
+import numpy as np
+from ._polybase import ABCPolyBase
+from ._polytypes import (
+    _Array1,
+    _Array2,
+    _FuncVal2D,
+    _FuncVal3D,
+    _FuncBinOp,
+    _FuncCompanion,
+    _FuncDer,
+    _FuncFit,
+    _FuncFromRoots,
+    _FuncInteg,
+    _FuncLine,
+    _FuncPow,
+    _FuncRoots,
+    _FuncUnOp,
+    _FuncVal,
+    _FuncVander,
+    _FuncVander2D,
+    _FuncVander3D,
+    _FuncValFromRoots,
+)
+from .polyutils import trimcoef as polytrim
+
+__all__ = [
+    "polyzero",
+    "polyone",
+    "polyx",
+    "polydomain",
+    "polyline",
+    "polyadd",
+    "polysub",
+    "polymulx",
+    "polymul",
+    "polydiv",
+    "polypow",
+    "polyval",
+    "polyvalfromroots",
+    "polyder",
+    "polyint",
+    "polyfromroots",
+    "polyvander",
+    "polyfit",
+    "polytrim",
+    "polyroots",
+    "Polynomial",
+    "polyval2d",
+    "polyval3d",
+    "polygrid2d",
+    "polygrid3d",
+    "polyvander2d",
+    "polyvander3d",
+    "polycompanion",
+]
+
+polydomain: Final[_Array2[np.float64]]
+polyzero: Final[_Array1[np.int_]]
+polyone: Final[_Array1[np.int_]]
+polyx: Final[_Array2[np.int_]]
+
+polyline: _FuncLine[L["Polyline"]]
+polyfromroots: _FuncFromRoots[L["polyfromroots"]]
+polyadd: _FuncBinOp[L["polyadd"]]
+polysub: _FuncBinOp[L["polysub"]]
+polymulx: _FuncUnOp[L["polymulx"]]
+polymul: _FuncBinOp[L["polymul"]]
+polydiv: _FuncBinOp[L["polydiv"]]
+polypow: _FuncPow[L["polypow"]]
+polyder: _FuncDer[L["polyder"]]
+polyint: _FuncInteg[L["polyint"]]
+polyval: _FuncVal[L["polyval"]]
+polyval2d: _FuncVal2D[L["polyval2d"]]
+polyval3d: _FuncVal3D[L["polyval3d"]]
+polyvalfromroots: _FuncValFromRoots[L["polyvalfromroots"]]
+polygrid2d: _FuncVal2D[L["polygrid2d"]]
+polygrid3d: _FuncVal3D[L["polygrid3d"]]
+polyvander: _FuncVander[L["polyvander"]]
+polyvander2d: _FuncVander2D[L["polyvander2d"]]
+polyvander3d: _FuncVander3D[L["polyvander3d"]]
+polyfit: _FuncFit[L["polyfit"]]
+polycompanion: _FuncCompanion[L["polycompanion"]]
+polyroots: _FuncRoots[L["polyroots"]]
+
+class Polynomial(ABCPolyBase[None]): ...
diff --git a/venv/lib/python3.12/site-packages/numpy/polynomial/polyutils.py b/venv/lib/python3.12/site-packages/numpy/polynomial/polyutils.py
new file mode 100644
index 00000000..b3987d0c
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/polynomial/polyutils.py
@@ -0,0 +1,757 @@
+"""
+Utility classes and functions for the polynomial modules.
+
+This module provides: error and warning objects; a polynomial base class;
+and some routines used in both the `polynomial` and `chebyshev` modules.
+
+Functions
+---------
+
+.. autosummary::
+   :toctree: generated/
+
+   as_series    convert list of array_likes into 1-D arrays of common type.
+   trimseq      remove trailing zeros.
+   trimcoef     remove small trailing coefficients.
+   getdomain    return the domain appropriate for a given set of abscissae.
+   mapdomain    maps points between domains.
+   mapparms     parameters of the linear map between domains.
+
+"""
+import operator
+import functools
+import warnings
+
+import numpy as np
+
+from numpy._core.multiarray import dragon4_positional, dragon4_scientific
+from numpy.exceptions import RankWarning
+
+__all__ = [
+    'as_series', 'trimseq', 'trimcoef', 'getdomain', 'mapdomain', 'mapparms',
+    'format_float']
+
+#
+# Helper functions to convert inputs to 1-D arrays
+#
+def trimseq(seq):
+    """Remove small Poly series coefficients.
+
+    Parameters
+    ----------
+    seq : sequence
+        Sequence of Poly series coefficients.
+
+    Returns
+    -------
+    series : sequence
+        Subsequence with trailing zeros removed. If the resulting sequence
+        would be empty, return the first element. The returned sequence may
+        or may not be a view.
+
+    Notes
+    -----
+    Do not lose the type info if the sequence contains unknown objects.
+
+    """
+    if len(seq) == 0 or seq[-1] != 0:
+        return seq
+    else:
+        for i in range(len(seq) - 1, -1, -1):
+            if seq[i] != 0:
+                break
+        return seq[:i+1]
+
+
+def as_series(alist, trim=True):
+    """
+    Return argument as a list of 1-d arrays.
+
+    The returned list contains array(s) of dtype double, complex double, or
+    object.  A 1-d argument of shape ``(N,)`` is parsed into ``N`` arrays of
+    size one; a 2-d argument of shape ``(M,N)`` is parsed into ``M`` arrays
+    of size ``N`` (i.e., is "parsed by row"); and a higher dimensional array
+    raises a Value Error if it is not first reshaped into either a 1-d or 2-d
+    array.
+
+    Parameters
+    ----------
+    alist : array_like
+        A 1- or 2-d array_like
+    trim : boolean, optional
+        When True, trailing zeros are removed from the inputs.
+        When False, the inputs are passed through intact.
+
+    Returns
+    -------
+    [a1, a2,...] : list of 1-D arrays
+        A copy of the input data as a list of 1-d arrays.
+
+    Raises
+    ------
+    ValueError
+        Raised when `as_series` cannot convert its input to 1-d arrays, or at
+        least one of the resulting arrays is empty.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from numpy.polynomial import polyutils as pu
+    >>> a = np.arange(4)
+    >>> pu.as_series(a)
+    [array([0.]), array([1.]), array([2.]), array([3.])]
+    >>> b = np.arange(6).reshape((2,3))
+    >>> pu.as_series(b)
+    [array([0., 1., 2.]), array([3., 4., 5.])]
+
+    >>> pu.as_series((1, np.arange(3), np.arange(2, dtype=np.float16)))
+    [array([1.]), array([0., 1., 2.]), array([0., 1.])]
+
+    >>> pu.as_series([2, [1.1, 0.]])
+    [array([2.]), array([1.1])]
+
+    >>> pu.as_series([2, [1.1, 0.]], trim=False)
+    [array([2.]), array([1.1, 0. ])]
+
+    """
+    arrays = [np.array(a, ndmin=1, copy=None) for a in alist]
+    for a in arrays:
+        if a.size == 0:
+            raise ValueError("Coefficient array is empty")
+    if any(a.ndim != 1 for a in arrays):
+        raise ValueError("Coefficient array is not 1-d")
+    if trim:
+        arrays = [trimseq(a) for a in arrays]
+
+    if any(a.dtype == np.dtype(object) for a in arrays):
+        ret = []
+        for a in arrays:
+            if a.dtype != np.dtype(object):
+                tmp = np.empty(len(a), dtype=np.dtype(object))
+                tmp[:] = a[:]
+                ret.append(tmp)
+            else:
+                ret.append(a.copy())
+    else:
+        try:
+            dtype = np.common_type(*arrays)
+        except Exception as e:
+            raise ValueError("Coefficient arrays have no common type") from e
+        ret = [np.array(a, copy=True, dtype=dtype) for a in arrays]
+    return ret
+
+
+def trimcoef(c, tol=0):
+    """
+    Remove "small" "trailing" coefficients from a polynomial.
+
+    "Small" means "small in absolute value" and is controlled by the
+    parameter `tol`; "trailing" means highest order coefficient(s), e.g., in
+    ``[0, 1, 1, 0, 0]`` (which represents ``0 + x + x**2 + 0*x**3 + 0*x**4``)
+    both the 3-rd and 4-th order coefficients would be "trimmed."
+
+    Parameters
+    ----------
+    c : array_like
+        1-d array of coefficients, ordered from lowest order to highest.
+    tol : number, optional
+        Trailing (i.e., highest order) elements with absolute value less
+        than or equal to `tol` (default value is zero) are removed.
+
+    Returns
+    -------
+    trimmed : ndarray
+        1-d array with trailing zeros removed.  If the resulting series
+        would be empty, a series containing a single zero is returned.
+
+    Raises
+    ------
+    ValueError
+        If `tol` < 0
+
+    Examples
+    --------
+    >>> from numpy.polynomial import polyutils as pu
+    >>> pu.trimcoef((0,0,3,0,5,0,0))
+    array([0.,  0.,  3.,  0.,  5.])
+    >>> pu.trimcoef((0,0,1e-3,0,1e-5,0,0),1e-3) # item == tol is trimmed
+    array([0.])
+    >>> i = complex(0,1) # works for complex
+    >>> pu.trimcoef((3e-4,1e-3*(1-i),5e-4,2e-5*(1+i)), 1e-3)
+    array([0.0003+0.j   , 0.001 -0.001j])
+
+    """
+    if tol < 0:
+        raise ValueError("tol must be non-negative")
+
+    [c] = as_series([c])
+    [ind] = np.nonzero(np.abs(c) > tol)
+    if len(ind) == 0:
+        return c[:1]*0
+    else:
+        return c[:ind[-1] + 1].copy()
+
+def getdomain(x):
+    """
+    Return a domain suitable for given abscissae.
+
+    Find a domain suitable for a polynomial or Chebyshev series
+    defined at the values supplied.
+
+    Parameters
+    ----------
+    x : array_like
+        1-d array of abscissae whose domain will be determined.
+
+    Returns
+    -------
+    domain : ndarray
+        1-d array containing two values.  If the inputs are complex, then
+        the two returned points are the lower left and upper right corners
+        of the smallest rectangle (aligned with the axes) in the complex
+        plane containing the points `x`. If the inputs are real, then the
+        two points are the ends of the smallest interval containing the
+        points `x`.
+
+    See Also
+    --------
+    mapparms, mapdomain
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from numpy.polynomial import polyutils as pu
+    >>> points = np.arange(4)**2 - 5; points
+    array([-5, -4, -1,  4])
+    >>> pu.getdomain(points)
+    array([-5.,  4.])
+    >>> c = np.exp(complex(0,1)*np.pi*np.arange(12)/6) # unit circle
+    >>> pu.getdomain(c)
+    array([-1.-1.j,  1.+1.j])
+
+    """
+    [x] = as_series([x], trim=False)
+    if x.dtype.char in np.typecodes['Complex']:
+        rmin, rmax = x.real.min(), x.real.max()
+        imin, imax = x.imag.min(), x.imag.max()
+        return np.array((complex(rmin, imin), complex(rmax, imax)))
+    else:
+        return np.array((x.min(), x.max()))
+
+def mapparms(old, new):
+    """
+    Linear map parameters between domains.
+
+    Return the parameters of the linear map ``offset + scale*x`` that maps
+    `old` to `new` such that ``old[i] -> new[i]``, ``i = 0, 1``.
+
+    Parameters
+    ----------
+    old, new : array_like
+        Domains. Each domain must (successfully) convert to a 1-d array
+        containing precisely two values.
+
+    Returns
+    -------
+    offset, scale : scalars
+        The map ``L(x) = offset + scale*x`` maps the first domain to the
+        second.
+
+    See Also
+    --------
+    getdomain, mapdomain
+
+    Notes
+    -----
+    Also works for complex numbers, and thus can be used to calculate the
+    parameters required to map any line in the complex plane to any other
+    line therein.
+
+    Examples
+    --------
+    >>> from numpy.polynomial import polyutils as pu
+    >>> pu.mapparms((-1,1),(-1,1))
+    (0.0, 1.0)
+    >>> pu.mapparms((1,-1),(-1,1))
+    (-0.0, -1.0)
+    >>> i = complex(0,1)
+    >>> pu.mapparms((-i,-1),(1,i))
+    ((1+1j), (1-0j))
+
+    """
+    oldlen = old[1] - old[0]
+    newlen = new[1] - new[0]
+    off = (old[1]*new[0] - old[0]*new[1])/oldlen
+    scl = newlen/oldlen
+    return off, scl
+
+def mapdomain(x, old, new):
+    """
+    Apply linear map to input points.
+
+    The linear map ``offset + scale*x`` that maps the domain `old` to
+    the domain `new` is applied to the points `x`.
+
+    Parameters
+    ----------
+    x : array_like
+        Points to be mapped. If `x` is a subtype of ndarray the subtype
+        will be preserved.
+    old, new : array_like
+        The two domains that determine the map.  Each must (successfully)
+        convert to 1-d arrays containing precisely two values.
+
+    Returns
+    -------
+    x_out : ndarray
+        Array of points of the same shape as `x`, after application of the
+        linear map between the two domains.
+
+    See Also
+    --------
+    getdomain, mapparms
+
+    Notes
+    -----
+    Effectively, this implements:
+
+    .. math::
+        x\\_out = new[0] + m(x - old[0])
+
+    where
+
+    .. math::
+        m = \\frac{new[1]-new[0]}{old[1]-old[0]}
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from numpy.polynomial import polyutils as pu
+    >>> old_domain = (-1,1)
+    >>> new_domain = (0,2*np.pi)
+    >>> x = np.linspace(-1,1,6); x
+    array([-1. , -0.6, -0.2,  0.2,  0.6,  1. ])
+    >>> x_out = pu.mapdomain(x, old_domain, new_domain); x_out
+    array([ 0.        ,  1.25663706,  2.51327412,  3.76991118,  5.02654825, # may vary
+            6.28318531])
+    >>> x - pu.mapdomain(x_out, new_domain, old_domain)
+    array([0., 0., 0., 0., 0., 0.])
+
+    Also works for complex numbers (and thus can be used to map any line in
+    the complex plane to any other line therein).
+
+    >>> i = complex(0,1)
+    >>> old = (-1 - i, 1 + i)
+    >>> new = (-1 + i, 1 - i)
+    >>> z = np.linspace(old[0], old[1], 6); z
+    array([-1. -1.j , -0.6-0.6j, -0.2-0.2j,  0.2+0.2j,  0.6+0.6j,  1. +1.j ])
+    >>> new_z = pu.mapdomain(z, old, new); new_z
+    array([-1.0+1.j , -0.6+0.6j, -0.2+0.2j,  0.2-0.2j,  0.6-0.6j,  1.0-1.j ]) # may vary
+
+    """
+    if type(x) not in (int, float, complex) and not isinstance(x, np.generic):
+        x = np.asanyarray(x)
+    off, scl = mapparms(old, new)
+    return off + scl*x
+
+
+def _nth_slice(i, ndim):
+    sl = [np.newaxis] * ndim
+    sl[i] = slice(None)
+    return tuple(sl)
+
+
+def _vander_nd(vander_fs, points, degrees):
+    r"""
+    A generalization of the Vandermonde matrix for N dimensions
+
+    The result is built by combining the results of 1d Vandermonde matrices,
+
+    .. math::
+        W[i_0, \ldots, i_M, j_0, \ldots, j_N] = \prod_{k=0}^N{V_k(x_k)[i_0, \ldots, i_M, j_k]}
+
+    where
+
+    .. math::
+        N &= \texttt{len(points)} = \texttt{len(degrees)} = \texttt{len(vander\_fs)} \\
+        M &= \texttt{points[k].ndim} \\
+        V_k &= \texttt{vander\_fs[k]} \\
+        x_k &= \texttt{points[k]} \\
+        0 \le j_k &\le \texttt{degrees[k]}
+
+    Expanding the one-dimensional :math:`V_k` functions gives:
+
+    .. math::
+        W[i_0, \ldots, i_M, j_0, \ldots, j_N] = \prod_{k=0}^N{B_{k, j_k}(x_k[i_0, \ldots, i_M])}
+
+    where :math:`B_{k,m}` is the m'th basis of the polynomial construction used along
+    dimension :math:`k`. For a regular polynomial, :math:`B_{k, m}(x) = P_m(x) = x^m`.
+
+    Parameters
+    ----------
+    vander_fs : Sequence[function(array_like, int) -> ndarray]
+        The 1d vander function to use for each axis, such as ``polyvander``
+    points : Sequence[array_like]
+        Arrays of point coordinates, all of the same shape. The dtypes
+        will be converted to either float64 or complex128 depending on
+        whether any of the elements are complex. Scalars are converted to
+        1-D arrays.
+        This must be the same length as `vander_fs`.
+    degrees : Sequence[int]
+        The maximum degree (inclusive) to use for each axis.
+        This must be the same length as `vander_fs`.
+
+    Returns
+    -------
+    vander_nd : ndarray
+        An array of shape ``points[0].shape + tuple(d + 1 for d in degrees)``.
+    """
+    n_dims = len(vander_fs)
+    if n_dims != len(points):
+        raise ValueError(
+            f"Expected {n_dims} dimensions of sample points, got {len(points)}")
+    if n_dims != len(degrees):
+        raise ValueError(
+            f"Expected {n_dims} dimensions of degrees, got {len(degrees)}")
+    if n_dims == 0:
+        raise ValueError("Unable to guess a dtype or shape when no points are given")
+
+    # convert to the same shape and type
+    points = tuple(np.asarray(tuple(points)) + 0.0)
+
+    # produce the vandermonde matrix for each dimension, placing the last
+    # axis of each in an independent trailing axis of the output
+    vander_arrays = (
+        vander_fs[i](points[i], degrees[i])[(...,) + _nth_slice(i, n_dims)]
+        for i in range(n_dims)
+    )
+
+    # we checked this wasn't empty already, so no `initial` needed
+    return functools.reduce(operator.mul, vander_arrays)
+
+
+def _vander_nd_flat(vander_fs, points, degrees):
+    """
+    Like `_vander_nd`, but flattens the last ``len(degrees)`` axes into a single axis
+
+    Used to implement the public ``vanderd`` functions.
+    """
+    v = _vander_nd(vander_fs, points, degrees)
+    return v.reshape(v.shape[:-len(degrees)] + (-1,))
+
+
+def _fromroots(line_f, mul_f, roots):
+    """
+    Helper function used to implement the ``fromroots`` functions.
+
+    Parameters
+    ----------
+    line_f : function(float, float) -> ndarray
+        The ``line`` function, such as ``polyline``
+    mul_f : function(array_like, array_like) -> ndarray
+        The ``mul`` function, such as ``polymul``
+    roots
+        See the ``fromroots`` functions for more detail
+    """
+    if len(roots) == 0:
+        return np.ones(1)
+    else:
+        [roots] = as_series([roots], trim=False)
+        roots.sort()
+        p = [line_f(-r, 1) for r in roots]
+        n = len(p)
+        while n > 1:
+            m, r = divmod(n, 2)
+            tmp = [mul_f(p[i], p[i+m]) for i in range(m)]
+            if r:
+                tmp[0] = mul_f(tmp[0], p[-1])
+            p = tmp
+            n = m
+        return p[0]
+
+
+def _valnd(val_f, c, *args):
+    """
+    Helper function used to implement the ``vald`` functions.
+
+    Parameters
+    ----------
+    val_f : function(array_like, array_like, tensor: bool) -> array_like
+        The ``val`` function, such as ``polyval``
+    c, args
+        See the ``vald`` functions for more detail
+    """
+    args = [np.asanyarray(a) for a in args]
+    shape0 = args[0].shape
+    if not all(a.shape == shape0 for a in args[1:]):
+        if len(args) == 3:
+            raise ValueError('x, y, z are incompatible')
+        elif len(args) == 2:
+            raise ValueError('x, y are incompatible')
+        else:
+            raise ValueError('ordinates are incompatible')
+    it = iter(args)
+    x0 = next(it)
+
+    # use tensor on only the first
+    c = val_f(x0, c)
+    for xi in it:
+        c = val_f(xi, c, tensor=False)
+    return c
+
+
+def _gridnd(val_f, c, *args):
+    """
+    Helper function used to implement the ``gridd`` functions.
+
+    Parameters
+    ----------
+    val_f : function(array_like, array_like, tensor: bool) -> array_like
+        The ``val`` function, such as ``polyval``
+    c, args
+        See the ``gridd`` functions for more detail
+    """
+    for xi in args:
+        c = val_f(xi, c)
+    return c
+
+
+def _div(mul_f, c1, c2):
+    """
+    Helper function used to implement the ``div`` functions.
+
+    Implementation uses repeated subtraction of c2 multiplied by the nth basis.
+    For some polynomial types, a more efficient approach may be possible.
+
+    Parameters
+    ----------
+    mul_f : function(array_like, array_like) -> array_like
+        The ``mul`` function, such as ``polymul``
+    c1, c2
+        See the ``div`` functions for more detail
+    """
+    # c1, c2 are trimmed copies
+    [c1, c2] = as_series([c1, c2])
+    if c2[-1] == 0:
+        raise ZeroDivisionError()
+
+    lc1 = len(c1)
+    lc2 = len(c2)
+    if lc1 < lc2:
+        return c1[:1]*0, c1
+    elif lc2 == 1:
+        return c1/c2[-1], c1[:1]*0
+    else:
+        quo = np.empty(lc1 - lc2 + 1, dtype=c1.dtype)
+        rem = c1
+        for i in range(lc1 - lc2, - 1, -1):
+            p = mul_f([0]*i + [1], c2)
+            q = rem[-1]/p[-1]
+            rem = rem[:-1] - q*p[:-1]
+            quo[i] = q
+        return quo, trimseq(rem)
+
+
+def _add(c1, c2):
+    """ Helper function used to implement the ``add`` functions. """
+    # c1, c2 are trimmed copies
+    [c1, c2] = as_series([c1, c2])
+    if len(c1) > len(c2):
+        c1[:c2.size] += c2
+        ret = c1
+    else:
+        c2[:c1.size] += c1
+        ret = c2
+    return trimseq(ret)
+
+
+def _sub(c1, c2):
+    """ Helper function used to implement the ``sub`` functions. """
+    # c1, c2 are trimmed copies
+    [c1, c2] = as_series([c1, c2])
+    if len(c1) > len(c2):
+        c1[:c2.size] -= c2
+        ret = c1
+    else:
+        c2 = -c2
+        c2[:c1.size] += c1
+        ret = c2
+    return trimseq(ret)
+
+
+def _fit(vander_f, x, y, deg, rcond=None, full=False, w=None):
+    """
+    Helper function used to implement the ``fit`` functions.
+
+    Parameters
+    ----------
+    vander_f : function(array_like, int) -> ndarray
+        The 1d vander function, such as ``polyvander``
+    c1, c2
+        See the ``fit`` functions for more detail
+    """
+    x = np.asarray(x) + 0.0
+    y = np.asarray(y) + 0.0
+    deg = np.asarray(deg)
+
+    # check arguments.
+    if deg.ndim > 1 or deg.dtype.kind not in 'iu' or deg.size == 0:
+        raise TypeError("deg must be an int or non-empty 1-D array of int")
+    if deg.min() < 0:
+        raise ValueError("expected deg >= 0")
+    if x.ndim != 1:
+        raise TypeError("expected 1D vector for x")
+    if x.size == 0:
+        raise TypeError("expected non-empty vector for x")
+    if y.ndim < 1 or y.ndim > 2:
+        raise TypeError("expected 1D or 2D array for y")
+    if len(x) != len(y):
+        raise TypeError("expected x and y to have same length")
+
+    if deg.ndim == 0:
+        lmax = deg
+        order = lmax + 1
+        van = vander_f(x, lmax)
+    else:
+        deg = np.sort(deg)
+        lmax = deg[-1]
+        order = len(deg)
+        van = vander_f(x, lmax)[:, deg]
+
+    # set up the least squares matrices in transposed form
+    lhs = van.T
+    rhs = y.T
+    if w is not None:
+        w = np.asarray(w) + 0.0
+        if w.ndim != 1:
+            raise TypeError("expected 1D vector for w")
+        if len(x) != len(w):
+            raise TypeError("expected x and w to have same length")
+        # apply weights. Don't use inplace operations as they
+        # can cause problems with NA.
+        lhs = lhs * w
+        rhs = rhs * w
+
+    # set rcond
+    if rcond is None:
+        rcond = len(x)*np.finfo(x.dtype).eps
+
+    # Determine the norms of the design matrix columns.
+    if issubclass(lhs.dtype.type, np.complexfloating):
+        scl = np.sqrt((np.square(lhs.real) + np.square(lhs.imag)).sum(1))
+    else:
+        scl = np.sqrt(np.square(lhs).sum(1))
+    scl[scl == 0] = 1
+
+    # Solve the least squares problem.
+    c, resids, rank, s = np.linalg.lstsq(lhs.T/scl, rhs.T, rcond)
+    c = (c.T/scl).T
+
+    # Expand c to include non-fitted coefficients which are set to zero
+    if deg.ndim > 0:
+        if c.ndim == 2:
+            cc = np.zeros((lmax+1, c.shape[1]), dtype=c.dtype)
+        else:
+            cc = np.zeros(lmax+1, dtype=c.dtype)
+        cc[deg] = c
+        c = cc
+
+    # warn on rank reduction
+    if rank != order and not full:
+        msg = "The fit may be poorly conditioned"
+        warnings.warn(msg, RankWarning, stacklevel=2)
+
+    if full:
+        return c, [resids, rank, s, rcond]
+    else:
+        return c
+
+
+def _pow(mul_f, c, pow, maxpower):
+    """
+    Helper function used to implement the ``pow`` functions.
+
+    Parameters
+    ----------
+    mul_f : function(array_like, array_like) -> ndarray
+        The ``mul`` function, such as ``polymul``
+    c : array_like
+        1-D array of array of series coefficients
+    pow, maxpower
+        See the ``pow`` functions for more detail
+    """
+    # c is a trimmed copy
+    [c] = as_series([c])
+    power = int(pow)
+    if power != pow or power < 0:
+        raise ValueError("Power must be a non-negative integer.")
+    elif maxpower is not None and power > maxpower:
+        raise ValueError("Power is too large")
+    elif power == 0:
+        return np.array([1], dtype=c.dtype)
+    elif power == 1:
+        return c
+    else:
+        # This can be made more efficient by using powers of two
+        # in the usual way.
+        prd = c
+        for i in range(2, power + 1):
+            prd = mul_f(prd, c)
+        return prd
+
+
+def _as_int(x, desc):
+    """
+    Like `operator.index`, but emits a custom exception when passed an 
+    incorrect type
+
+    Parameters
+    ----------
+    x : int-like
+        Value to interpret as an integer
+    desc : str
+        description to include in any error message
+
+    Raises
+    ------
+    TypeError : if x is a float or non-numeric
+    """
+    try:
+        return operator.index(x)
+    except TypeError as e:
+        raise TypeError(f"{desc} must be an integer, received {x}") from e
+
+
+def format_float(x, parens=False):
+    if not np.issubdtype(type(x), np.floating):
+        return str(x)
+
+    opts = np.get_printoptions()
+
+    if np.isnan(x):
+        return opts['nanstr']
+    elif np.isinf(x):
+        return opts['infstr']
+
+    exp_format = False
+    if x != 0:
+        a = np.abs(x)
+        if a >= 1.e8 or a < 10**min(0, -(opts['precision']-1)//2):
+            exp_format = True
+
+    trim, unique = '0', True
+    if opts['floatmode'] == 'fixed':
+        trim, unique = 'k', False
+
+    if exp_format:
+        s = dragon4_scientific(x, precision=opts['precision'],
+                               unique=unique, trim=trim, 
+                               sign=opts['sign'] == '+')
+        if parens:
+            s = '(' + s + ')'
+    else:
+        s = dragon4_positional(x, precision=opts['precision'],
+                               fractional=True,
+                               unique=unique, trim=trim,
+                               sign=opts['sign'] == '+')
+    return s
diff --git a/venv/lib/python3.12/site-packages/numpy/polynomial/polyutils.pyi b/venv/lib/python3.12/site-packages/numpy/polynomial/polyutils.pyi
new file mode 100644
index 00000000..9299b239
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/polynomial/polyutils.pyi
@@ -0,0 +1,431 @@
+from collections.abc import Callable, Iterable, Sequence
+from typing import (
+    Any,
+    Final,
+    Literal,
+    SupportsIndex,
+    TypeAlias,
+    TypeVar,
+    overload,
+)
+
+import numpy as np
+import numpy.typing as npt
+from numpy._typing import (
+    _FloatLike_co,
+    _NumberLike_co,
+
+    _ArrayLikeFloat_co,
+    _ArrayLikeComplex_co,
+)
+
+from ._polytypes import (
+    _AnyInt,
+    _CoefLike_co,
+
+    _Array2,
+    _Tuple2,
+
+    _FloatSeries,
+    _CoefSeries,
+    _ComplexSeries,
+    _ObjectSeries,
+
+    _ComplexArray,
+    _FloatArray,
+    _CoefArray,
+    _ObjectArray,
+
+    _SeriesLikeInt_co,
+    _SeriesLikeFloat_co,
+    _SeriesLikeComplex_co,
+    _SeriesLikeCoef_co,
+
+    _ArrayLikeCoef_co,
+
+    _FuncBinOp,
+    _FuncValND,
+    _FuncVanderND,
+)
+
+__all__: Final[Sequence[str]] = [
+    "as_series",
+    "format_float",
+    "getdomain",
+    "mapdomain",
+    "mapparms",
+    "trimcoef",
+    "trimseq",
+]
+
+_AnyLineF: TypeAlias = Callable[
+    [_CoefLike_co, _CoefLike_co],
+    _CoefArray,
+]
+_AnyMulF: TypeAlias = Callable[
+    [npt.ArrayLike, npt.ArrayLike],
+    _CoefArray,
+]
+_AnyVanderF: TypeAlias = Callable[
+    [npt.ArrayLike, SupportsIndex],
+    _CoefArray,
+]
+
+@overload
+def as_series(
+    alist: npt.NDArray[np.integer[Any]] | _FloatArray,
+    trim: bool = ...,
+) -> list[_FloatSeries]: ...
+@overload
+def as_series(
+    alist: _ComplexArray,
+    trim: bool = ...,
+) -> list[_ComplexSeries]: ...
+@overload
+def as_series(
+    alist: _ObjectArray,
+    trim: bool = ...,
+) -> list[_ObjectSeries]: ...
+@overload
+def as_series(  # type: ignore[overload-overlap]
+    alist: Iterable[_FloatArray | npt.NDArray[np.integer[Any]]],
+    trim: bool = ...,
+) -> list[_FloatSeries]: ...
+@overload
+def as_series(
+    alist: Iterable[_ComplexArray],
+    trim: bool = ...,
+) -> list[_ComplexSeries]: ...
+@overload
+def as_series(
+    alist: Iterable[_ObjectArray],
+    trim: bool = ...,
+) -> list[_ObjectSeries]: ...
+@overload
+def as_series(  # type: ignore[overload-overlap]
+    alist: Iterable[_SeriesLikeFloat_co | float],
+    trim: bool = ...,
+) -> list[_FloatSeries]: ...
+@overload
+def as_series(
+    alist: Iterable[_SeriesLikeComplex_co | complex],
+    trim: bool = ...,
+) -> list[_ComplexSeries]: ...
+@overload
+def as_series(
+    alist: Iterable[_SeriesLikeCoef_co | object],
+    trim: bool = ...,
+) -> list[_ObjectSeries]: ...
+
+_T_seq = TypeVar("_T_seq", bound=_CoefArray | Sequence[_CoefLike_co])
+def trimseq(seq: _T_seq) -> _T_seq: ...
+
+@overload
+def trimcoef(  # type: ignore[overload-overlap]
+    c: npt.NDArray[np.integer[Any]] | _FloatArray,
+    tol: _FloatLike_co = ...,
+) -> _FloatSeries: ...
+@overload
+def trimcoef(
+    c: _ComplexArray,
+    tol: _FloatLike_co = ...,
+) -> _ComplexSeries: ...
+@overload
+def trimcoef(
+    c: _ObjectArray,
+    tol: _FloatLike_co = ...,
+) -> _ObjectSeries: ...
+@overload
+def trimcoef(  # type: ignore[overload-overlap]
+    c: _SeriesLikeFloat_co | float,
+    tol: _FloatLike_co = ...,
+) -> _FloatSeries: ...
+@overload
+def trimcoef(
+    c: _SeriesLikeComplex_co | complex,
+    tol: _FloatLike_co = ...,
+) -> _ComplexSeries: ...
+@overload
+def trimcoef(
+    c: _SeriesLikeCoef_co | object,
+    tol: _FloatLike_co = ...,
+) -> _ObjectSeries: ...
+
+@overload
+def getdomain(  # type: ignore[overload-overlap]
+    x: _FloatArray | npt.NDArray[np.integer[Any]],
+) -> _Array2[np.float64]: ...
+@overload
+def getdomain(
+    x: _ComplexArray,
+) -> _Array2[np.complex128]: ...
+@overload
+def getdomain(
+    x: _ObjectArray,
+) -> _Array2[np.object_]: ...
+@overload
+def getdomain(  # type: ignore[overload-overlap]
+    x: _SeriesLikeFloat_co | float,
+) -> _Array2[np.float64]: ...
+@overload
+def getdomain(
+    x: _SeriesLikeComplex_co | complex,
+) -> _Array2[np.complex128]: ...
+@overload
+def getdomain(
+    x: _SeriesLikeCoef_co | object,
+) -> _Array2[np.object_]: ...
+
+@overload
+def mapparms(  # type: ignore[overload-overlap]
+    old: npt.NDArray[np.floating[Any] | np.integer[Any]],
+    new: npt.NDArray[np.floating[Any] | np.integer[Any]],
+) -> _Tuple2[np.floating[Any]]: ...
+@overload
+def mapparms(
+    old: npt.NDArray[np.number[Any]],
+    new: npt.NDArray[np.number[Any]],
+) -> _Tuple2[np.complexfloating[Any, Any]]: ...
+@overload
+def mapparms(
+    old: npt.NDArray[np.object_ | np.number[Any]],
+    new: npt.NDArray[np.object_ | np.number[Any]],
+) -> _Tuple2[object]: ...
+@overload
+def mapparms(  # type: ignore[overload-overlap]
+    old: Sequence[float],
+    new: Sequence[float],
+) -> _Tuple2[float]: ...
+@overload
+def mapparms(
+    old: Sequence[complex],
+    new: Sequence[complex],
+) -> _Tuple2[complex]: ...
+@overload
+def mapparms(
+    old: _SeriesLikeFloat_co,
+    new: _SeriesLikeFloat_co,
+) -> _Tuple2[np.floating[Any]]: ...
+@overload
+def mapparms(
+    old: _SeriesLikeComplex_co,
+    new: _SeriesLikeComplex_co,
+) -> _Tuple2[np.complexfloating[Any, Any]]: ...
+@overload
+def mapparms(
+    old: _SeriesLikeCoef_co,
+    new: _SeriesLikeCoef_co,
+) -> _Tuple2[object]: ...
+
+@overload
+def mapdomain(  # type: ignore[overload-overlap]
+    x: _FloatLike_co,
+    old: _SeriesLikeFloat_co,
+    new: _SeriesLikeFloat_co,
+) -> np.floating[Any]: ...
+@overload
+def mapdomain(
+    x: _NumberLike_co,
+    old: _SeriesLikeComplex_co,
+    new: _SeriesLikeComplex_co,
+) -> np.complexfloating[Any, Any]: ...
+@overload
+def mapdomain(  # type: ignore[overload-overlap]
+    x: npt.NDArray[np.floating[Any] | np.integer[Any]],
+    old: npt.NDArray[np.floating[Any] | np.integer[Any]],
+    new: npt.NDArray[np.floating[Any] | np.integer[Any]],
+) -> _FloatSeries: ...
+@overload
+def mapdomain(
+    x: npt.NDArray[np.number[Any]],
+    old: npt.NDArray[np.number[Any]],
+    new: npt.NDArray[np.number[Any]],
+) -> _ComplexSeries: ...
+@overload
+def mapdomain(
+    x: npt.NDArray[np.object_ | np.number[Any]],
+    old: npt.NDArray[np.object_ | np.number[Any]],
+    new: npt.NDArray[np.object_ | np.number[Any]],
+) -> _ObjectSeries: ...
+@overload
+def mapdomain(  # type: ignore[overload-overlap]
+    x: _SeriesLikeFloat_co,
+    old: _SeriesLikeFloat_co,
+    new: _SeriesLikeFloat_co,
+) -> _FloatSeries: ...
+@overload
+def mapdomain(
+    x: _SeriesLikeComplex_co,
+    old: _SeriesLikeComplex_co,
+    new: _SeriesLikeComplex_co,
+) -> _ComplexSeries: ...
+@overload
+def mapdomain(
+    x: _SeriesLikeCoef_co,
+    old:_SeriesLikeCoef_co,
+    new: _SeriesLikeCoef_co,
+) -> _ObjectSeries: ...
+@overload
+def mapdomain(
+    x: _CoefLike_co,
+    old: _SeriesLikeCoef_co,
+    new: _SeriesLikeCoef_co,
+) -> object: ...
+
+def _nth_slice(
+    i: SupportsIndex,
+    ndim: SupportsIndex,
+) -> tuple[None | slice, ...]: ...
+
+_vander_nd: _FuncVanderND[Literal["_vander_nd"]]
+_vander_nd_flat: _FuncVanderND[Literal["_vander_nd_flat"]]
+
+# keep in sync with `._polytypes._FuncFromRoots`
+@overload
+def _fromroots(  # type: ignore[overload-overlap]
+    line_f: _AnyLineF,
+    mul_f: _AnyMulF,
+    roots: _SeriesLikeFloat_co,
+) -> _FloatSeries: ...
+@overload
+def _fromroots(
+    line_f: _AnyLineF,
+    mul_f: _AnyMulF,
+    roots: _SeriesLikeComplex_co,
+) -> _ComplexSeries: ...
+@overload
+def _fromroots(
+    line_f: _AnyLineF,
+    mul_f: _AnyMulF,
+    roots: _SeriesLikeCoef_co,
+) -> _ObjectSeries: ...
+@overload
+def _fromroots(
+    line_f: _AnyLineF,
+    mul_f: _AnyMulF,
+    roots: _SeriesLikeCoef_co,
+) -> _CoefSeries: ...
+
+_valnd: _FuncValND[Literal["_valnd"]]
+_gridnd: _FuncValND[Literal["_gridnd"]]
+
+# keep in sync with `_polytypes._FuncBinOp`
+@overload
+def _div(  # type: ignore[overload-overlap]
+    mul_f: _AnyMulF,
+    c1: _SeriesLikeFloat_co,
+    c2: _SeriesLikeFloat_co,
+) -> _Tuple2[_FloatSeries]: ...
+@overload
+def _div(
+    mul_f: _AnyMulF,
+    c1: _SeriesLikeComplex_co,
+    c2: _SeriesLikeComplex_co,
+) -> _Tuple2[_ComplexSeries]: ...
+@overload
+def _div(
+    mul_f: _AnyMulF,
+    c1: _SeriesLikeCoef_co,
+    c2: _SeriesLikeCoef_co,
+) -> _Tuple2[_ObjectSeries]: ...
+@overload
+def _div(
+    mul_f: _AnyMulF,
+    c1: _SeriesLikeCoef_co,
+    c2: _SeriesLikeCoef_co,
+) -> _Tuple2[_CoefSeries]: ...
+
+_add: Final[_FuncBinOp]
+_sub: Final[_FuncBinOp]
+
+# keep in sync with `_polytypes._FuncPow`
+@overload
+def _pow(  # type: ignore[overload-overlap]
+    mul_f: _AnyMulF,
+    c: _SeriesLikeFloat_co,
+    pow: _AnyInt,
+    maxpower: None | _AnyInt = ...,
+) -> _FloatSeries: ...
+@overload
+def _pow(
+    mul_f: _AnyMulF,
+    c: _SeriesLikeComplex_co,
+    pow: _AnyInt,
+    maxpower: None | _AnyInt = ...,
+) -> _ComplexSeries: ...
+@overload
+def _pow(
+    mul_f: _AnyMulF,
+    c: _SeriesLikeCoef_co,
+    pow: _AnyInt,
+    maxpower: None | _AnyInt = ...,
+) -> _ObjectSeries: ...
+@overload
+def _pow(
+    mul_f: _AnyMulF,
+    c: _SeriesLikeCoef_co,
+    pow: _AnyInt,
+    maxpower: None | _AnyInt = ...,
+) -> _CoefSeries: ...
+
+# keep in sync with `_polytypes._FuncFit`
+@overload
+def _fit(  # type: ignore[overload-overlap]
+    vander_f: _AnyVanderF,
+    x: _SeriesLikeFloat_co,
+    y: _ArrayLikeFloat_co,
+    deg: _SeriesLikeInt_co,
+    domain: None | _SeriesLikeFloat_co = ...,
+    rcond: None | _FloatLike_co = ...,
+    full: Literal[False] = ...,
+    w: None | _SeriesLikeFloat_co = ...,
+) -> _FloatArray: ...
+@overload
+def _fit(
+    vander_f: _AnyVanderF,
+    x: _SeriesLikeComplex_co,
+    y: _ArrayLikeComplex_co,
+    deg: _SeriesLikeInt_co,
+    domain: None | _SeriesLikeComplex_co = ...,
+    rcond: None | _FloatLike_co = ...,
+    full: Literal[False] = ...,
+    w: None | _SeriesLikeComplex_co = ...,
+) -> _ComplexArray: ...
+@overload
+def _fit(
+    vander_f: _AnyVanderF,
+    x: _SeriesLikeCoef_co,
+    y: _ArrayLikeCoef_co,
+    deg: _SeriesLikeInt_co,
+    domain: None | _SeriesLikeCoef_co = ...,
+    rcond: None | _FloatLike_co = ...,
+    full: Literal[False] = ...,
+    w: None | _SeriesLikeCoef_co = ...,
+) -> _CoefArray: ...
+@overload
+def _fit(
+    vander_f: _AnyVanderF,
+    x: _SeriesLikeCoef_co,
+    y: _SeriesLikeCoef_co,
+    deg: _SeriesLikeInt_co,
+    domain: None | _SeriesLikeCoef_co,
+    rcond: None | _FloatLike_co ,
+    full: Literal[True],
+    /,
+    w: None | _SeriesLikeCoef_co = ...,
+) -> tuple[_CoefSeries, Sequence[np.inexact[Any] | np.int32]]: ...
+@overload
+def _fit(
+    vander_f: _AnyVanderF,
+    x: _SeriesLikeCoef_co,
+    y: _SeriesLikeCoef_co,
+    deg: _SeriesLikeInt_co,
+    domain: None | _SeriesLikeCoef_co = ...,
+    rcond: None | _FloatLike_co = ...,
+    *,
+    full: Literal[True],
+    w: None | _SeriesLikeCoef_co = ...,
+) -> tuple[_CoefSeries, Sequence[np.inexact[Any] | np.int32]]: ...
+
+def _as_int(x: SupportsIndex, desc: str) -> int: ...
+def format_float(x: _FloatLike_co, parens: bool = ...) -> str: ...
diff --git a/venv/lib/python3.12/site-packages/numpy/polynomial/tests/__init__.py b/venv/lib/python3.12/site-packages/numpy/polynomial/tests/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/venv/lib/python3.12/site-packages/numpy/polynomial/tests/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/polynomial/tests/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 00000000..91d38d91
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/polynomial/tests/__pycache__/__init__.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/polynomial/tests/__pycache__/test_chebyshev.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/polynomial/tests/__pycache__/test_chebyshev.cpython-312.pyc
new file mode 100644
index 00000000..f3e154b9
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/polynomial/tests/__pycache__/test_chebyshev.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/polynomial/tests/__pycache__/test_classes.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/polynomial/tests/__pycache__/test_classes.cpython-312.pyc
new file mode 100644
index 00000000..a31ccb3f
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/polynomial/tests/__pycache__/test_classes.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/polynomial/tests/__pycache__/test_hermite.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/polynomial/tests/__pycache__/test_hermite.cpython-312.pyc
new file mode 100644
index 00000000..3322dea9
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/polynomial/tests/__pycache__/test_hermite.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/polynomial/tests/__pycache__/test_hermite_e.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/polynomial/tests/__pycache__/test_hermite_e.cpython-312.pyc
new file mode 100644
index 00000000..4b797eb2
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/polynomial/tests/__pycache__/test_hermite_e.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/polynomial/tests/__pycache__/test_laguerre.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/polynomial/tests/__pycache__/test_laguerre.cpython-312.pyc
new file mode 100644
index 00000000..e0ea59e4
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/polynomial/tests/__pycache__/test_laguerre.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/polynomial/tests/__pycache__/test_legendre.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/polynomial/tests/__pycache__/test_legendre.cpython-312.pyc
new file mode 100644
index 00000000..13c6e5b0
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/polynomial/tests/__pycache__/test_legendre.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/polynomial/tests/__pycache__/test_polynomial.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/polynomial/tests/__pycache__/test_polynomial.cpython-312.pyc
new file mode 100644
index 00000000..962eb10c
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/polynomial/tests/__pycache__/test_polynomial.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/polynomial/tests/__pycache__/test_polyutils.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/polynomial/tests/__pycache__/test_polyutils.cpython-312.pyc
new file mode 100644
index 00000000..2a3b9fb4
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/polynomial/tests/__pycache__/test_polyutils.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/polynomial/tests/__pycache__/test_printing.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/polynomial/tests/__pycache__/test_printing.cpython-312.pyc
new file mode 100644
index 00000000..c00a8a77
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/polynomial/tests/__pycache__/test_printing.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/polynomial/tests/__pycache__/test_symbol.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/polynomial/tests/__pycache__/test_symbol.cpython-312.pyc
new file mode 100644
index 00000000..13ce1ec8
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/polynomial/tests/__pycache__/test_symbol.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/polynomial/tests/test_chebyshev.py b/venv/lib/python3.12/site-packages/numpy/polynomial/tests/test_chebyshev.py
new file mode 100644
index 00000000..2f54bebf
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/polynomial/tests/test_chebyshev.py
@@ -0,0 +1,619 @@
+"""Tests for chebyshev module.
+
+"""
+from functools import reduce
+
+import numpy as np
+import numpy.polynomial.chebyshev as cheb
+from numpy.polynomial.polynomial import polyval
+from numpy.testing import (
+    assert_almost_equal, assert_raises, assert_equal, assert_,
+    )
+
+
+def trim(x):
+    return cheb.chebtrim(x, tol=1e-6)
+
+T0 = [1]
+T1 = [0, 1]
+T2 = [-1, 0, 2]
+T3 = [0, -3, 0, 4]
+T4 = [1, 0, -8, 0, 8]
+T5 = [0, 5, 0, -20, 0, 16]
+T6 = [-1, 0, 18, 0, -48, 0, 32]
+T7 = [0, -7, 0, 56, 0, -112, 0, 64]
+T8 = [1, 0, -32, 0, 160, 0, -256, 0, 128]
+T9 = [0, 9, 0, -120, 0, 432, 0, -576, 0, 256]
+
+Tlist = [T0, T1, T2, T3, T4, T5, T6, T7, T8, T9]
+
+
+class TestPrivate:
+
+    def test__cseries_to_zseries(self):
+        for i in range(5):
+            inp = np.array([2] + [1]*i, np.double)
+            tgt = np.array([.5]*i + [2] + [.5]*i, np.double)
+            res = cheb._cseries_to_zseries(inp)
+            assert_equal(res, tgt)
+
+    def test__zseries_to_cseries(self):
+        for i in range(5):
+            inp = np.array([.5]*i + [2] + [.5]*i, np.double)
+            tgt = np.array([2] + [1]*i, np.double)
+            res = cheb._zseries_to_cseries(inp)
+            assert_equal(res, tgt)
+
+
+class TestConstants:
+
+    def test_chebdomain(self):
+        assert_equal(cheb.chebdomain, [-1, 1])
+
+    def test_chebzero(self):
+        assert_equal(cheb.chebzero, [0])
+
+    def test_chebone(self):
+        assert_equal(cheb.chebone, [1])
+
+    def test_chebx(self):
+        assert_equal(cheb.chebx, [0, 1])
+
+
+class TestArithmetic:
+
+    def test_chebadd(self):
+        for i in range(5):
+            for j in range(5):
+                msg = f"At i={i}, j={j}"
+                tgt = np.zeros(max(i, j) + 1)
+                tgt[i] += 1
+                tgt[j] += 1
+                res = cheb.chebadd([0]*i + [1], [0]*j + [1])
+                assert_equal(trim(res), trim(tgt), err_msg=msg)
+
+    def test_chebsub(self):
+        for i in range(5):
+            for j in range(5):
+                msg = f"At i={i}, j={j}"
+                tgt = np.zeros(max(i, j) + 1)
+                tgt[i] += 1
+                tgt[j] -= 1
+                res = cheb.chebsub([0]*i + [1], [0]*j + [1])
+                assert_equal(trim(res), trim(tgt), err_msg=msg)
+
+    def test_chebmulx(self):
+        assert_equal(cheb.chebmulx([0]), [0])
+        assert_equal(cheb.chebmulx([1]), [0, 1])
+        for i in range(1, 5):
+            ser = [0]*i + [1]
+            tgt = [0]*(i - 1) + [.5, 0, .5]
+            assert_equal(cheb.chebmulx(ser), tgt)
+
+    def test_chebmul(self):
+        for i in range(5):
+            for j in range(5):
+                msg = f"At i={i}, j={j}"
+                tgt = np.zeros(i + j + 1)
+                tgt[i + j] += .5
+                tgt[abs(i - j)] += .5
+                res = cheb.chebmul([0]*i + [1], [0]*j + [1])
+                assert_equal(trim(res), trim(tgt), err_msg=msg)
+
+    def test_chebdiv(self):
+        for i in range(5):
+            for j in range(5):
+                msg = f"At i={i}, j={j}"
+                ci = [0]*i + [1]
+                cj = [0]*j + [1]
+                tgt = cheb.chebadd(ci, cj)
+                quo, rem = cheb.chebdiv(tgt, ci)
+                res = cheb.chebadd(cheb.chebmul(quo, ci), rem)
+                assert_equal(trim(res), trim(tgt), err_msg=msg)
+
+    def test_chebpow(self):
+        for i in range(5):
+            for j in range(5):
+                msg = f"At i={i}, j={j}"
+                c = np.arange(i + 1)
+                tgt = reduce(cheb.chebmul, [c]*j, np.array([1]))
+                res = cheb.chebpow(c, j)
+                assert_equal(trim(res), trim(tgt), err_msg=msg)
+
+
+class TestEvaluation:
+    # coefficients of 1 + 2*x + 3*x**2
+    c1d = np.array([2.5, 2., 1.5])
+    c2d = np.einsum('i,j->ij', c1d, c1d)
+    c3d = np.einsum('i,j,k->ijk', c1d, c1d, c1d)
+
+    # some random values in [-1, 1)
+    x = np.random.random((3, 5))*2 - 1
+    y = polyval(x, [1., 2., 3.])
+
+    def test_chebval(self):
+        #check empty input
+        assert_equal(cheb.chebval([], [1]).size, 0)
+
+        #check normal input)
+        x = np.linspace(-1, 1)
+        y = [polyval(x, c) for c in Tlist]
+        for i in range(10):
+            msg = f"At i={i}"
+            tgt = y[i]
+            res = cheb.chebval(x, [0]*i + [1])
+            assert_almost_equal(res, tgt, err_msg=msg)
+
+        #check that shape is preserved
+        for i in range(3):
+            dims = [2]*i
+            x = np.zeros(dims)
+            assert_equal(cheb.chebval(x, [1]).shape, dims)
+            assert_equal(cheb.chebval(x, [1, 0]).shape, dims)
+            assert_equal(cheb.chebval(x, [1, 0, 0]).shape, dims)
+
+    def test_chebval2d(self):
+        x1, x2, x3 = self.x
+        y1, y2, y3 = self.y
+
+        #test exceptions
+        assert_raises(ValueError, cheb.chebval2d, x1, x2[:2], self.c2d)
+
+        #test values
+        tgt = y1*y2
+        res = cheb.chebval2d(x1, x2, self.c2d)
+        assert_almost_equal(res, tgt)
+
+        #test shape
+        z = np.ones((2, 3))
+        res = cheb.chebval2d(z, z, self.c2d)
+        assert_(res.shape == (2, 3))
+
+    def test_chebval3d(self):
+        x1, x2, x3 = self.x
+        y1, y2, y3 = self.y
+
+        #test exceptions
+        assert_raises(ValueError, cheb.chebval3d, x1, x2, x3[:2], self.c3d)
+
+        #test values
+        tgt = y1*y2*y3
+        res = cheb.chebval3d(x1, x2, x3, self.c3d)
+        assert_almost_equal(res, tgt)
+
+        #test shape
+        z = np.ones((2, 3))
+        res = cheb.chebval3d(z, z, z, self.c3d)
+        assert_(res.shape == (2, 3))
+
+    def test_chebgrid2d(self):
+        x1, x2, x3 = self.x
+        y1, y2, y3 = self.y
+
+        #test values
+        tgt = np.einsum('i,j->ij', y1, y2)
+        res = cheb.chebgrid2d(x1, x2, self.c2d)
+        assert_almost_equal(res, tgt)
+
+        #test shape
+        z = np.ones((2, 3))
+        res = cheb.chebgrid2d(z, z, self.c2d)
+        assert_(res.shape == (2, 3)*2)
+
+    def test_chebgrid3d(self):
+        x1, x2, x3 = self.x
+        y1, y2, y3 = self.y
+
+        #test values
+        tgt = np.einsum('i,j,k->ijk', y1, y2, y3)
+        res = cheb.chebgrid3d(x1, x2, x3, self.c3d)
+        assert_almost_equal(res, tgt)
+
+        #test shape
+        z = np.ones((2, 3))
+        res = cheb.chebgrid3d(z, z, z, self.c3d)
+        assert_(res.shape == (2, 3)*3)
+
+
+class TestIntegral:
+
+    def test_chebint(self):
+        # check exceptions
+        assert_raises(TypeError, cheb.chebint, [0], .5)
+        assert_raises(ValueError, cheb.chebint, [0], -1)
+        assert_raises(ValueError, cheb.chebint, [0], 1, [0, 0])
+        assert_raises(ValueError, cheb.chebint, [0], lbnd=[0])
+        assert_raises(ValueError, cheb.chebint, [0], scl=[0])
+        assert_raises(TypeError, cheb.chebint, [0], axis=.5)
+
+        # test integration of zero polynomial
+        for i in range(2, 5):
+            k = [0]*(i - 2) + [1]
+            res = cheb.chebint([0], m=i, k=k)
+            assert_almost_equal(res, [0, 1])
+
+        # check single integration with integration constant
+        for i in range(5):
+            scl = i + 1
+            pol = [0]*i + [1]
+            tgt = [i] + [0]*i + [1/scl]
+            chebpol = cheb.poly2cheb(pol)
+            chebint = cheb.chebint(chebpol, m=1, k=[i])
+            res = cheb.cheb2poly(chebint)
+            assert_almost_equal(trim(res), trim(tgt))
+
+        # check single integration with integration constant and lbnd
+        for i in range(5):
+            scl = i + 1
+            pol = [0]*i + [1]
+            chebpol = cheb.poly2cheb(pol)
+            chebint = cheb.chebint(chebpol, m=1, k=[i], lbnd=-1)
+            assert_almost_equal(cheb.chebval(-1, chebint), i)
+
+        # check single integration with integration constant and scaling
+        for i in range(5):
+            scl = i + 1
+            pol = [0]*i + [1]
+            tgt = [i] + [0]*i + [2/scl]
+            chebpol = cheb.poly2cheb(pol)
+            chebint = cheb.chebint(chebpol, m=1, k=[i], scl=2)
+            res = cheb.cheb2poly(chebint)
+            assert_almost_equal(trim(res), trim(tgt))
+
+        # check multiple integrations with default k
+        for i in range(5):
+            for j in range(2, 5):
+                pol = [0]*i + [1]
+                tgt = pol[:]
+                for k in range(j):
+                    tgt = cheb.chebint(tgt, m=1)
+                res = cheb.chebint(pol, m=j)
+                assert_almost_equal(trim(res), trim(tgt))
+
+        # check multiple integrations with defined k
+        for i in range(5):
+            for j in range(2, 5):
+                pol = [0]*i + [1]
+                tgt = pol[:]
+                for k in range(j):
+                    tgt = cheb.chebint(tgt, m=1, k=[k])
+                res = cheb.chebint(pol, m=j, k=list(range(j)))
+                assert_almost_equal(trim(res), trim(tgt))
+
+        # check multiple integrations with lbnd
+        for i in range(5):
+            for j in range(2, 5):
+                pol = [0]*i + [1]
+                tgt = pol[:]
+                for k in range(j):
+                    tgt = cheb.chebint(tgt, m=1, k=[k], lbnd=-1)
+                res = cheb.chebint(pol, m=j, k=list(range(j)), lbnd=-1)
+                assert_almost_equal(trim(res), trim(tgt))
+
+        # check multiple integrations with scaling
+        for i in range(5):
+            for j in range(2, 5):
+                pol = [0]*i + [1]
+                tgt = pol[:]
+                for k in range(j):
+                    tgt = cheb.chebint(tgt, m=1, k=[k], scl=2)
+                res = cheb.chebint(pol, m=j, k=list(range(j)), scl=2)
+                assert_almost_equal(trim(res), trim(tgt))
+
+    def test_chebint_axis(self):
+        # check that axis keyword works
+        c2d = np.random.random((3, 4))
+
+        tgt = np.vstack([cheb.chebint(c) for c in c2d.T]).T
+        res = cheb.chebint(c2d, axis=0)
+        assert_almost_equal(res, tgt)
+
+        tgt = np.vstack([cheb.chebint(c) for c in c2d])
+        res = cheb.chebint(c2d, axis=1)
+        assert_almost_equal(res, tgt)
+
+        tgt = np.vstack([cheb.chebint(c, k=3) for c in c2d])
+        res = cheb.chebint(c2d, k=3, axis=1)
+        assert_almost_equal(res, tgt)
+
+
+class TestDerivative:
+
+    def test_chebder(self):
+        # check exceptions
+        assert_raises(TypeError, cheb.chebder, [0], .5)
+        assert_raises(ValueError, cheb.chebder, [0], -1)
+
+        # check that zeroth derivative does nothing
+        for i in range(5):
+            tgt = [0]*i + [1]
+            res = cheb.chebder(tgt, m=0)
+            assert_equal(trim(res), trim(tgt))
+
+        # check that derivation is the inverse of integration
+        for i in range(5):
+            for j in range(2, 5):
+                tgt = [0]*i + [1]
+                res = cheb.chebder(cheb.chebint(tgt, m=j), m=j)
+                assert_almost_equal(trim(res), trim(tgt))
+
+        # check derivation with scaling
+        for i in range(5):
+            for j in range(2, 5):
+                tgt = [0]*i + [1]
+                res = cheb.chebder(cheb.chebint(tgt, m=j, scl=2), m=j, scl=.5)
+                assert_almost_equal(trim(res), trim(tgt))
+
+    def test_chebder_axis(self):
+        # check that axis keyword works
+        c2d = np.random.random((3, 4))
+
+        tgt = np.vstack([cheb.chebder(c) for c in c2d.T]).T
+        res = cheb.chebder(c2d, axis=0)
+        assert_almost_equal(res, tgt)
+
+        tgt = np.vstack([cheb.chebder(c) for c in c2d])
+        res = cheb.chebder(c2d, axis=1)
+        assert_almost_equal(res, tgt)
+
+
+class TestVander:
+    # some random values in [-1, 1)
+    x = np.random.random((3, 5))*2 - 1
+
+    def test_chebvander(self):
+        # check for 1d x
+        x = np.arange(3)
+        v = cheb.chebvander(x, 3)
+        assert_(v.shape == (3, 4))
+        for i in range(4):
+            coef = [0]*i + [1]
+            assert_almost_equal(v[..., i], cheb.chebval(x, coef))
+
+        # check for 2d x
+        x = np.array([[1, 2], [3, 4], [5, 6]])
+        v = cheb.chebvander(x, 3)
+        assert_(v.shape == (3, 2, 4))
+        for i in range(4):
+            coef = [0]*i + [1]
+            assert_almost_equal(v[..., i], cheb.chebval(x, coef))
+
+    def test_chebvander2d(self):
+        # also tests chebval2d for non-square coefficient array
+        x1, x2, x3 = self.x
+        c = np.random.random((2, 3))
+        van = cheb.chebvander2d(x1, x2, [1, 2])
+        tgt = cheb.chebval2d(x1, x2, c)
+        res = np.dot(van, c.flat)
+        assert_almost_equal(res, tgt)
+
+        # check shape
+        van = cheb.chebvander2d([x1], [x2], [1, 2])
+        assert_(van.shape == (1, 5, 6))
+
+    def test_chebvander3d(self):
+        # also tests chebval3d for non-square coefficient array
+        x1, x2, x3 = self.x
+        c = np.random.random((2, 3, 4))
+        van = cheb.chebvander3d(x1, x2, x3, [1, 2, 3])
+        tgt = cheb.chebval3d(x1, x2, x3, c)
+        res = np.dot(van, c.flat)
+        assert_almost_equal(res, tgt)
+
+        # check shape
+        van = cheb.chebvander3d([x1], [x2], [x3], [1, 2, 3])
+        assert_(van.shape == (1, 5, 24))
+
+
+class TestFitting:
+
+    def test_chebfit(self):
+        def f(x):
+            return x*(x - 1)*(x - 2)
+
+        def f2(x):
+            return x**4 + x**2 + 1
+
+        # Test exceptions
+        assert_raises(ValueError, cheb.chebfit, [1], [1], -1)
+        assert_raises(TypeError, cheb.chebfit, [[1]], [1], 0)
+        assert_raises(TypeError, cheb.chebfit, [], [1], 0)
+        assert_raises(TypeError, cheb.chebfit, [1], [[[1]]], 0)
+        assert_raises(TypeError, cheb.chebfit, [1, 2], [1], 0)
+        assert_raises(TypeError, cheb.chebfit, [1], [1, 2], 0)
+        assert_raises(TypeError, cheb.chebfit, [1], [1], 0, w=[[1]])
+        assert_raises(TypeError, cheb.chebfit, [1], [1], 0, w=[1, 1])
+        assert_raises(ValueError, cheb.chebfit, [1], [1], [-1,])
+        assert_raises(ValueError, cheb.chebfit, [1], [1], [2, -1, 6])
+        assert_raises(TypeError, cheb.chebfit, [1], [1], [])
+
+        # Test fit
+        x = np.linspace(0, 2)
+        y = f(x)
+        #
+        coef3 = cheb.chebfit(x, y, 3)
+        assert_equal(len(coef3), 4)
+        assert_almost_equal(cheb.chebval(x, coef3), y)
+        coef3 = cheb.chebfit(x, y, [0, 1, 2, 3])
+        assert_equal(len(coef3), 4)
+        assert_almost_equal(cheb.chebval(x, coef3), y)
+        #
+        coef4 = cheb.chebfit(x, y, 4)
+        assert_equal(len(coef4), 5)
+        assert_almost_equal(cheb.chebval(x, coef4), y)
+        coef4 = cheb.chebfit(x, y, [0, 1, 2, 3, 4])
+        assert_equal(len(coef4), 5)
+        assert_almost_equal(cheb.chebval(x, coef4), y)
+        # check things still work if deg is not in strict increasing
+        coef4 = cheb.chebfit(x, y, [2, 3, 4, 1, 0])
+        assert_equal(len(coef4), 5)
+        assert_almost_equal(cheb.chebval(x, coef4), y)
+        #
+        coef2d = cheb.chebfit(x, np.array([y, y]).T, 3)
+        assert_almost_equal(coef2d, np.array([coef3, coef3]).T)
+        coef2d = cheb.chebfit(x, np.array([y, y]).T, [0, 1, 2, 3])
+        assert_almost_equal(coef2d, np.array([coef3, coef3]).T)
+        # test weighting
+        w = np.zeros_like(x)
+        yw = y.copy()
+        w[1::2] = 1
+        y[0::2] = 0
+        wcoef3 = cheb.chebfit(x, yw, 3, w=w)
+        assert_almost_equal(wcoef3, coef3)
+        wcoef3 = cheb.chebfit(x, yw, [0, 1, 2, 3], w=w)
+        assert_almost_equal(wcoef3, coef3)
+        #
+        wcoef2d = cheb.chebfit(x, np.array([yw, yw]).T, 3, w=w)
+        assert_almost_equal(wcoef2d, np.array([coef3, coef3]).T)
+        wcoef2d = cheb.chebfit(x, np.array([yw, yw]).T, [0, 1, 2, 3], w=w)
+        assert_almost_equal(wcoef2d, np.array([coef3, coef3]).T)
+        # test scaling with complex values x points whose square
+        # is zero when summed.
+        x = [1, 1j, -1, -1j]
+        assert_almost_equal(cheb.chebfit(x, x, 1), [0, 1])
+        assert_almost_equal(cheb.chebfit(x, x, [0, 1]), [0, 1])
+        # test fitting only even polynomials
+        x = np.linspace(-1, 1)
+        y = f2(x)
+        coef1 = cheb.chebfit(x, y, 4)
+        assert_almost_equal(cheb.chebval(x, coef1), y)
+        coef2 = cheb.chebfit(x, y, [0, 2, 4])
+        assert_almost_equal(cheb.chebval(x, coef2), y)
+        assert_almost_equal(coef1, coef2)
+
+
+class TestInterpolate:
+
+    def f(self, x):
+        return x * (x - 1) * (x - 2)
+
+    def test_raises(self):
+        assert_raises(ValueError, cheb.chebinterpolate, self.f, -1)
+        assert_raises(TypeError, cheb.chebinterpolate, self.f, 10.)
+
+    def test_dimensions(self):
+        for deg in range(1, 5):
+            assert_(cheb.chebinterpolate(self.f, deg).shape == (deg + 1,))
+
+    def test_approximation(self):
+
+        def powx(x, p):
+            return x**p
+
+        x = np.linspace(-1, 1, 10)
+        for deg in range(0, 10):
+            for p in range(0, deg + 1):
+                c = cheb.chebinterpolate(powx, deg, (p,))
+                assert_almost_equal(cheb.chebval(x, c), powx(x, p), decimal=12)
+
+
+class TestCompanion:
+
+    def test_raises(self):
+        assert_raises(ValueError, cheb.chebcompanion, [])
+        assert_raises(ValueError, cheb.chebcompanion, [1])
+
+    def test_dimensions(self):
+        for i in range(1, 5):
+            coef = [0]*i + [1]
+            assert_(cheb.chebcompanion(coef).shape == (i, i))
+
+    def test_linear_root(self):
+        assert_(cheb.chebcompanion([1, 2])[0, 0] == -.5)
+
+
+class TestGauss:
+
+    def test_100(self):
+        x, w = cheb.chebgauss(100)
+
+        # test orthogonality. Note that the results need to be normalized,
+        # otherwise the huge values that can arise from fast growing
+        # functions like Laguerre can be very confusing.
+        v = cheb.chebvander(x, 99)
+        vv = np.dot(v.T * w, v)
+        vd = 1/np.sqrt(vv.diagonal())
+        vv = vd[:, None] * vv * vd
+        assert_almost_equal(vv, np.eye(100))
+
+        # check that the integral of 1 is correct
+        tgt = np.pi
+        assert_almost_equal(w.sum(), tgt)
+
+
+class TestMisc:
+
+    def test_chebfromroots(self):
+        res = cheb.chebfromroots([])
+        assert_almost_equal(trim(res), [1])
+        for i in range(1, 5):
+            roots = np.cos(np.linspace(-np.pi, 0, 2*i + 1)[1::2])
+            tgt = [0]*i + [1]
+            res = cheb.chebfromroots(roots)*2**(i-1)
+            assert_almost_equal(trim(res), trim(tgt))
+
+    def test_chebroots(self):
+        assert_almost_equal(cheb.chebroots([1]), [])
+        assert_almost_equal(cheb.chebroots([1, 2]), [-.5])
+        for i in range(2, 5):
+            tgt = np.linspace(-1, 1, i)
+            res = cheb.chebroots(cheb.chebfromroots(tgt))
+            assert_almost_equal(trim(res), trim(tgt))
+
+    def test_chebtrim(self):
+        coef = [2, -1, 1, 0]
+
+        # Test exceptions
+        assert_raises(ValueError, cheb.chebtrim, coef, -1)
+
+        # Test results
+        assert_equal(cheb.chebtrim(coef), coef[:-1])
+        assert_equal(cheb.chebtrim(coef, 1), coef[:-3])
+        assert_equal(cheb.chebtrim(coef, 2), [0])
+
+    def test_chebline(self):
+        assert_equal(cheb.chebline(3, 4), [3, 4])
+
+    def test_cheb2poly(self):
+        for i in range(10):
+            assert_almost_equal(cheb.cheb2poly([0]*i + [1]), Tlist[i])
+
+    def test_poly2cheb(self):
+        for i in range(10):
+            assert_almost_equal(cheb.poly2cheb(Tlist[i]), [0]*i + [1])
+
+    def test_weight(self):
+        x = np.linspace(-1, 1, 11)[1:-1]
+        tgt = 1./(np.sqrt(1 + x) * np.sqrt(1 - x))
+        res = cheb.chebweight(x)
+        assert_almost_equal(res, tgt)
+
+    def test_chebpts1(self):
+        #test exceptions
+        assert_raises(ValueError, cheb.chebpts1, 1.5)
+        assert_raises(ValueError, cheb.chebpts1, 0)
+
+        #test points
+        tgt = [0]
+        assert_almost_equal(cheb.chebpts1(1), tgt)
+        tgt = [-0.70710678118654746, 0.70710678118654746]
+        assert_almost_equal(cheb.chebpts1(2), tgt)
+        tgt = [-0.86602540378443871, 0, 0.86602540378443871]
+        assert_almost_equal(cheb.chebpts1(3), tgt)
+        tgt = [-0.9238795325, -0.3826834323, 0.3826834323, 0.9238795325]
+        assert_almost_equal(cheb.chebpts1(4), tgt)
+
+    def test_chebpts2(self):
+        #test exceptions
+        assert_raises(ValueError, cheb.chebpts2, 1.5)
+        assert_raises(ValueError, cheb.chebpts2, 1)
+
+        #test points
+        tgt = [-1, 1]
+        assert_almost_equal(cheb.chebpts2(2), tgt)
+        tgt = [-1, 0, 1]
+        assert_almost_equal(cheb.chebpts2(3), tgt)
+        tgt = [-1, -0.5, .5, 1]
+        assert_almost_equal(cheb.chebpts2(4), tgt)
+        tgt = [-1.0, -0.707106781187, 0, 0.707106781187, 1.0]
+        assert_almost_equal(cheb.chebpts2(5), tgt)
diff --git a/venv/lib/python3.12/site-packages/numpy/polynomial/tests/test_classes.py b/venv/lib/python3.12/site-packages/numpy/polynomial/tests/test_classes.py
new file mode 100644
index 00000000..75672a14
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/polynomial/tests/test_classes.py
@@ -0,0 +1,607 @@
+"""Test inter-conversion of different polynomial classes.
+
+This tests the convert and cast methods of all the polynomial classes.
+
+"""
+import operator as op
+from numbers import Number
+
+import pytest
+import numpy as np
+from numpy.polynomial import (
+    Polynomial, Legendre, Chebyshev, Laguerre, Hermite, HermiteE)
+from numpy.testing import (
+    assert_almost_equal, assert_raises, assert_equal, assert_,
+    )
+from numpy.exceptions import RankWarning
+
+#
+# fixtures
+#
+
+classes = (
+    Polynomial, Legendre, Chebyshev, Laguerre,
+    Hermite, HermiteE
+    )
+classids = tuple(cls.__name__ for cls in classes)
+
+@pytest.fixture(params=classes, ids=classids)
+def Poly(request):
+    return request.param
+
+#
+# helper functions
+#
+random = np.random.random
+
+
+def assert_poly_almost_equal(p1, p2, msg=""):
+    try:
+        assert_(np.all(p1.domain == p2.domain))
+        assert_(np.all(p1.window == p2.window))
+        assert_almost_equal(p1.coef, p2.coef)
+    except AssertionError:
+        msg = f"Result: {p1}\nTarget: {p2}"
+        raise AssertionError(msg)
+
+
+#
+# Test conversion methods that depend on combinations of two classes.
+#
+
+Poly1 = Poly
+Poly2 = Poly
+
+
+def test_conversion(Poly1, Poly2):
+    x = np.linspace(0, 1, 10)
+    coef = random((3,))
+
+    d1 = Poly1.domain + random((2,))*.25
+    w1 = Poly1.window + random((2,))*.25
+    p1 = Poly1(coef, domain=d1, window=w1)
+
+    d2 = Poly2.domain + random((2,))*.25
+    w2 = Poly2.window + random((2,))*.25
+    p2 = p1.convert(kind=Poly2, domain=d2, window=w2)
+
+    assert_almost_equal(p2.domain, d2)
+    assert_almost_equal(p2.window, w2)
+    assert_almost_equal(p2(x), p1(x))
+
+
+def test_cast(Poly1, Poly2):
+    x = np.linspace(0, 1, 10)
+    coef = random((3,))
+
+    d1 = Poly1.domain + random((2,))*.25
+    w1 = Poly1.window + random((2,))*.25
+    p1 = Poly1(coef, domain=d1, window=w1)
+
+    d2 = Poly2.domain + random((2,))*.25
+    w2 = Poly2.window + random((2,))*.25
+    p2 = Poly2.cast(p1, domain=d2, window=w2)
+
+    assert_almost_equal(p2.domain, d2)
+    assert_almost_equal(p2.window, w2)
+    assert_almost_equal(p2(x), p1(x))
+
+
+#
+# test methods that depend on one class
+#
+
+
+def test_identity(Poly):
+    d = Poly.domain + random((2,))*.25
+    w = Poly.window + random((2,))*.25
+    x = np.linspace(d[0], d[1], 11)
+    p = Poly.identity(domain=d, window=w)
+    assert_equal(p.domain, d)
+    assert_equal(p.window, w)
+    assert_almost_equal(p(x), x)
+
+
+def test_basis(Poly):
+    d = Poly.domain + random((2,))*.25
+    w = Poly.window + random((2,))*.25
+    p = Poly.basis(5, domain=d, window=w)
+    assert_equal(p.domain, d)
+    assert_equal(p.window, w)
+    assert_equal(p.coef, [0]*5 + [1])
+
+
+def test_fromroots(Poly):
+    # check that requested roots are zeros of a polynomial
+    # of correct degree, domain, and window.
+    d = Poly.domain + random((2,))*.25
+    w = Poly.window + random((2,))*.25
+    r = random((5,))
+    p1 = Poly.fromroots(r, domain=d, window=w)
+    assert_equal(p1.degree(), len(r))
+    assert_equal(p1.domain, d)
+    assert_equal(p1.window, w)
+    assert_almost_equal(p1(r), 0)
+
+    # check that polynomial is monic
+    pdom = Polynomial.domain
+    pwin = Polynomial.window
+    p2 = Polynomial.cast(p1, domain=pdom, window=pwin)
+    assert_almost_equal(p2.coef[-1], 1)
+
+
+def test_bad_conditioned_fit(Poly):
+
+    x = [0., 0., 1.]
+    y = [1., 2., 3.]
+
+    # check RankWarning is raised
+    with pytest.warns(RankWarning) as record:
+        Poly.fit(x, y, 2)
+    assert record[0].message.args[0] == "The fit may be poorly conditioned"
+
+
+def test_fit(Poly):
+
+    def f(x):
+        return x*(x - 1)*(x - 2)
+    x = np.linspace(0, 3)
+    y = f(x)
+
+    # check default value of domain and window
+    p = Poly.fit(x, y, 3)
+    assert_almost_equal(p.domain, [0, 3])
+    assert_almost_equal(p(x), y)
+    assert_equal(p.degree(), 3)
+
+    # check with given domains and window
+    d = Poly.domain + random((2,))*.25
+    w = Poly.window + random((2,))*.25
+    p = Poly.fit(x, y, 3, domain=d, window=w)
+    assert_almost_equal(p(x), y)
+    assert_almost_equal(p.domain, d)
+    assert_almost_equal(p.window, w)
+    p = Poly.fit(x, y, [0, 1, 2, 3], domain=d, window=w)
+    assert_almost_equal(p(x), y)
+    assert_almost_equal(p.domain, d)
+    assert_almost_equal(p.window, w)
+
+    # check with class domain default
+    p = Poly.fit(x, y, 3, [])
+    assert_equal(p.domain, Poly.domain)
+    assert_equal(p.window, Poly.window)
+    p = Poly.fit(x, y, [0, 1, 2, 3], [])
+    assert_equal(p.domain, Poly.domain)
+    assert_equal(p.window, Poly.window)
+
+    # check that fit accepts weights.
+    w = np.zeros_like(x)
+    z = y + random(y.shape)*.25
+    w[::2] = 1
+    p1 = Poly.fit(x[::2], z[::2], 3)
+    p2 = Poly.fit(x, z, 3, w=w)
+    p3 = Poly.fit(x, z, [0, 1, 2, 3], w=w)
+    assert_almost_equal(p1(x), p2(x))
+    assert_almost_equal(p2(x), p3(x))
+
+
+def test_equal(Poly):
+    p1 = Poly([1, 2, 3], domain=[0, 1], window=[2, 3])
+    p2 = Poly([1, 1, 1], domain=[0, 1], window=[2, 3])
+    p3 = Poly([1, 2, 3], domain=[1, 2], window=[2, 3])
+    p4 = Poly([1, 2, 3], domain=[0, 1], window=[1, 2])
+    assert_(p1 == p1)
+    assert_(not p1 == p2)
+    assert_(not p1 == p3)
+    assert_(not p1 == p4)
+
+
+def test_not_equal(Poly):
+    p1 = Poly([1, 2, 3], domain=[0, 1], window=[2, 3])
+    p2 = Poly([1, 1, 1], domain=[0, 1], window=[2, 3])
+    p3 = Poly([1, 2, 3], domain=[1, 2], window=[2, 3])
+    p4 = Poly([1, 2, 3], domain=[0, 1], window=[1, 2])
+    assert_(not p1 != p1)
+    assert_(p1 != p2)
+    assert_(p1 != p3)
+    assert_(p1 != p4)
+
+
+def test_add(Poly):
+    # This checks commutation, not numerical correctness
+    c1 = list(random((4,)) + .5)
+    c2 = list(random((3,)) + .5)
+    p1 = Poly(c1)
+    p2 = Poly(c2)
+    p3 = p1 + p2
+    assert_poly_almost_equal(p2 + p1, p3)
+    assert_poly_almost_equal(p1 + c2, p3)
+    assert_poly_almost_equal(c2 + p1, p3)
+    assert_poly_almost_equal(p1 + tuple(c2), p3)
+    assert_poly_almost_equal(tuple(c2) + p1, p3)
+    assert_poly_almost_equal(p1 + np.array(c2), p3)
+    assert_poly_almost_equal(np.array(c2) + p1, p3)
+    assert_raises(TypeError, op.add, p1, Poly([0], domain=Poly.domain + 1))
+    assert_raises(TypeError, op.add, p1, Poly([0], window=Poly.window + 1))
+    if Poly is Polynomial:
+        assert_raises(TypeError, op.add, p1, Chebyshev([0]))
+    else:
+        assert_raises(TypeError, op.add, p1, Polynomial([0]))
+
+
+def test_sub(Poly):
+    # This checks commutation, not numerical correctness
+    c1 = list(random((4,)) + .5)
+    c2 = list(random((3,)) + .5)
+    p1 = Poly(c1)
+    p2 = Poly(c2)
+    p3 = p1 - p2
+    assert_poly_almost_equal(p2 - p1, -p3)
+    assert_poly_almost_equal(p1 - c2, p3)
+    assert_poly_almost_equal(c2 - p1, -p3)
+    assert_poly_almost_equal(p1 - tuple(c2), p3)
+    assert_poly_almost_equal(tuple(c2) - p1, -p3)
+    assert_poly_almost_equal(p1 - np.array(c2), p3)
+    assert_poly_almost_equal(np.array(c2) - p1, -p3)
+    assert_raises(TypeError, op.sub, p1, Poly([0], domain=Poly.domain + 1))
+    assert_raises(TypeError, op.sub, p1, Poly([0], window=Poly.window + 1))
+    if Poly is Polynomial:
+        assert_raises(TypeError, op.sub, p1, Chebyshev([0]))
+    else:
+        assert_raises(TypeError, op.sub, p1, Polynomial([0]))
+
+
+def test_mul(Poly):
+    c1 = list(random((4,)) + .5)
+    c2 = list(random((3,)) + .5)
+    p1 = Poly(c1)
+    p2 = Poly(c2)
+    p3 = p1 * p2
+    assert_poly_almost_equal(p2 * p1, p3)
+    assert_poly_almost_equal(p1 * c2, p3)
+    assert_poly_almost_equal(c2 * p1, p3)
+    assert_poly_almost_equal(p1 * tuple(c2), p3)
+    assert_poly_almost_equal(tuple(c2) * p1, p3)
+    assert_poly_almost_equal(p1 * np.array(c2), p3)
+    assert_poly_almost_equal(np.array(c2) * p1, p3)
+    assert_poly_almost_equal(p1 * 2, p1 * Poly([2]))
+    assert_poly_almost_equal(2 * p1, p1 * Poly([2]))
+    assert_raises(TypeError, op.mul, p1, Poly([0], domain=Poly.domain + 1))
+    assert_raises(TypeError, op.mul, p1, Poly([0], window=Poly.window + 1))
+    if Poly is Polynomial:
+        assert_raises(TypeError, op.mul, p1, Chebyshev([0]))
+    else:
+        assert_raises(TypeError, op.mul, p1, Polynomial([0]))
+
+
+def test_floordiv(Poly):
+    c1 = list(random((4,)) + .5)
+    c2 = list(random((3,)) + .5)
+    c3 = list(random((2,)) + .5)
+    p1 = Poly(c1)
+    p2 = Poly(c2)
+    p3 = Poly(c3)
+    p4 = p1 * p2 + p3
+    c4 = list(p4.coef)
+    assert_poly_almost_equal(p4 // p2, p1)
+    assert_poly_almost_equal(p4 // c2, p1)
+    assert_poly_almost_equal(c4 // p2, p1)
+    assert_poly_almost_equal(p4 // tuple(c2), p1)
+    assert_poly_almost_equal(tuple(c4) // p2, p1)
+    assert_poly_almost_equal(p4 // np.array(c2), p1)
+    assert_poly_almost_equal(np.array(c4) // p2, p1)
+    assert_poly_almost_equal(2 // p2, Poly([0]))
+    assert_poly_almost_equal(p2 // 2, 0.5*p2)
+    assert_raises(
+        TypeError, op.floordiv, p1, Poly([0], domain=Poly.domain + 1))
+    assert_raises(
+        TypeError, op.floordiv, p1, Poly([0], window=Poly.window + 1))
+    if Poly is Polynomial:
+        assert_raises(TypeError, op.floordiv, p1, Chebyshev([0]))
+    else:
+        assert_raises(TypeError, op.floordiv, p1, Polynomial([0]))
+
+
+def test_truediv(Poly):
+    # true division is valid only if the denominator is a Number and
+    # not a python bool.
+    p1 = Poly([1,2,3])
+    p2 = p1 * 5
+
+    for stype in np.ScalarType:
+        if not issubclass(stype, Number) or issubclass(stype, bool):
+            continue
+        s = stype(5)
+        assert_poly_almost_equal(op.truediv(p2, s), p1)
+        assert_raises(TypeError, op.truediv, s, p2)
+    for stype in (int, float):
+        s = stype(5)
+        assert_poly_almost_equal(op.truediv(p2, s), p1)
+        assert_raises(TypeError, op.truediv, s, p2)
+    for stype in [complex]:
+        s = stype(5, 0)
+        assert_poly_almost_equal(op.truediv(p2, s), p1)
+        assert_raises(TypeError, op.truediv, s, p2)
+    for s in [tuple(), list(), dict(), bool(), np.array([1])]:
+        assert_raises(TypeError, op.truediv, p2, s)
+        assert_raises(TypeError, op.truediv, s, p2)
+    for ptype in classes:
+        assert_raises(TypeError, op.truediv, p2, ptype(1))
+
+
+def test_mod(Poly):
+    # This checks commutation, not numerical correctness
+    c1 = list(random((4,)) + .5)
+    c2 = list(random((3,)) + .5)
+    c3 = list(random((2,)) + .5)
+    p1 = Poly(c1)
+    p2 = Poly(c2)
+    p3 = Poly(c3)
+    p4 = p1 * p2 + p3
+    c4 = list(p4.coef)
+    assert_poly_almost_equal(p4 % p2, p3)
+    assert_poly_almost_equal(p4 % c2, p3)
+    assert_poly_almost_equal(c4 % p2, p3)
+    assert_poly_almost_equal(p4 % tuple(c2), p3)
+    assert_poly_almost_equal(tuple(c4) % p2, p3)
+    assert_poly_almost_equal(p4 % np.array(c2), p3)
+    assert_poly_almost_equal(np.array(c4) % p2, p3)
+    assert_poly_almost_equal(2 % p2, Poly([2]))
+    assert_poly_almost_equal(p2 % 2, Poly([0]))
+    assert_raises(TypeError, op.mod, p1, Poly([0], domain=Poly.domain + 1))
+    assert_raises(TypeError, op.mod, p1, Poly([0], window=Poly.window + 1))
+    if Poly is Polynomial:
+        assert_raises(TypeError, op.mod, p1, Chebyshev([0]))
+    else:
+        assert_raises(TypeError, op.mod, p1, Polynomial([0]))
+
+
+def test_divmod(Poly):
+    # This checks commutation, not numerical correctness
+    c1 = list(random((4,)) + .5)
+    c2 = list(random((3,)) + .5)
+    c3 = list(random((2,)) + .5)
+    p1 = Poly(c1)
+    p2 = Poly(c2)
+    p3 = Poly(c3)
+    p4 = p1 * p2 + p3
+    c4 = list(p4.coef)
+    quo, rem = divmod(p4, p2)
+    assert_poly_almost_equal(quo, p1)
+    assert_poly_almost_equal(rem, p3)
+    quo, rem = divmod(p4, c2)
+    assert_poly_almost_equal(quo, p1)
+    assert_poly_almost_equal(rem, p3)
+    quo, rem = divmod(c4, p2)
+    assert_poly_almost_equal(quo, p1)
+    assert_poly_almost_equal(rem, p3)
+    quo, rem = divmod(p4, tuple(c2))
+    assert_poly_almost_equal(quo, p1)
+    assert_poly_almost_equal(rem, p3)
+    quo, rem = divmod(tuple(c4), p2)
+    assert_poly_almost_equal(quo, p1)
+    assert_poly_almost_equal(rem, p3)
+    quo, rem = divmod(p4, np.array(c2))
+    assert_poly_almost_equal(quo, p1)
+    assert_poly_almost_equal(rem, p3)
+    quo, rem = divmod(np.array(c4), p2)
+    assert_poly_almost_equal(quo, p1)
+    assert_poly_almost_equal(rem, p3)
+    quo, rem = divmod(p2, 2)
+    assert_poly_almost_equal(quo, 0.5*p2)
+    assert_poly_almost_equal(rem, Poly([0]))
+    quo, rem = divmod(2, p2)
+    assert_poly_almost_equal(quo, Poly([0]))
+    assert_poly_almost_equal(rem, Poly([2]))
+    assert_raises(TypeError, divmod, p1, Poly([0], domain=Poly.domain + 1))
+    assert_raises(TypeError, divmod, p1, Poly([0], window=Poly.window + 1))
+    if Poly is Polynomial:
+        assert_raises(TypeError, divmod, p1, Chebyshev([0]))
+    else:
+        assert_raises(TypeError, divmod, p1, Polynomial([0]))
+
+
+def test_roots(Poly):
+    d = Poly.domain * 1.25 + .25
+    w = Poly.window
+    tgt = np.linspace(d[0], d[1], 5)
+    res = np.sort(Poly.fromroots(tgt, domain=d, window=w).roots())
+    assert_almost_equal(res, tgt)
+    # default domain and window
+    res = np.sort(Poly.fromroots(tgt).roots())
+    assert_almost_equal(res, tgt)
+
+
+def test_degree(Poly):
+    p = Poly.basis(5)
+    assert_equal(p.degree(), 5)
+
+
+def test_copy(Poly):
+    p1 = Poly.basis(5)
+    p2 = p1.copy()
+    assert_(p1 == p2)
+    assert_(p1 is not p2)
+    assert_(p1.coef is not p2.coef)
+    assert_(p1.domain is not p2.domain)
+    assert_(p1.window is not p2.window)
+
+
+def test_integ(Poly):
+    P = Polynomial
+    # Check defaults
+    p0 = Poly.cast(P([1*2, 2*3, 3*4]))
+    p1 = P.cast(p0.integ())
+    p2 = P.cast(p0.integ(2))
+    assert_poly_almost_equal(p1, P([0, 2, 3, 4]))
+    assert_poly_almost_equal(p2, P([0, 0, 1, 1, 1]))
+    # Check with k
+    p0 = Poly.cast(P([1*2, 2*3, 3*4]))
+    p1 = P.cast(p0.integ(k=1))
+    p2 = P.cast(p0.integ(2, k=[1, 1]))
+    assert_poly_almost_equal(p1, P([1, 2, 3, 4]))
+    assert_poly_almost_equal(p2, P([1, 1, 1, 1, 1]))
+    # Check with lbnd
+    p0 = Poly.cast(P([1*2, 2*3, 3*4]))
+    p1 = P.cast(p0.integ(lbnd=1))
+    p2 = P.cast(p0.integ(2, lbnd=1))
+    assert_poly_almost_equal(p1, P([-9, 2, 3, 4]))
+    assert_poly_almost_equal(p2, P([6, -9, 1, 1, 1]))
+    # Check scaling
+    d = 2*Poly.domain
+    p0 = Poly.cast(P([1*2, 2*3, 3*4]), domain=d)
+    p1 = P.cast(p0.integ())
+    p2 = P.cast(p0.integ(2))
+    assert_poly_almost_equal(p1, P([0, 2, 3, 4]))
+    assert_poly_almost_equal(p2, P([0, 0, 1, 1, 1]))
+
+
+def test_deriv(Poly):
+    # Check that the derivative is the inverse of integration. It is
+    # assumes that the integration has been checked elsewhere.
+    d = Poly.domain + random((2,))*.25
+    w = Poly.window + random((2,))*.25
+    p1 = Poly([1, 2, 3], domain=d, window=w)
+    p2 = p1.integ(2, k=[1, 2])
+    p3 = p1.integ(1, k=[1])
+    assert_almost_equal(p2.deriv(1).coef, p3.coef)
+    assert_almost_equal(p2.deriv(2).coef, p1.coef)
+    # default domain and window
+    p1 = Poly([1, 2, 3])
+    p2 = p1.integ(2, k=[1, 2])
+    p3 = p1.integ(1, k=[1])
+    assert_almost_equal(p2.deriv(1).coef, p3.coef)
+    assert_almost_equal(p2.deriv(2).coef, p1.coef)
+
+
+def test_linspace(Poly):
+    d = Poly.domain + random((2,))*.25
+    w = Poly.window + random((2,))*.25
+    p = Poly([1, 2, 3], domain=d, window=w)
+    # check default domain
+    xtgt = np.linspace(d[0], d[1], 20)
+    ytgt = p(xtgt)
+    xres, yres = p.linspace(20)
+    assert_almost_equal(xres, xtgt)
+    assert_almost_equal(yres, ytgt)
+    # check specified domain
+    xtgt = np.linspace(0, 2, 20)
+    ytgt = p(xtgt)
+    xres, yres = p.linspace(20, domain=[0, 2])
+    assert_almost_equal(xres, xtgt)
+    assert_almost_equal(yres, ytgt)
+
+
+def test_pow(Poly):
+    d = Poly.domain + random((2,))*.25
+    w = Poly.window + random((2,))*.25
+    tgt = Poly([1], domain=d, window=w)
+    tst = Poly([1, 2, 3], domain=d, window=w)
+    for i in range(5):
+        assert_poly_almost_equal(tst**i, tgt)
+        tgt = tgt * tst
+    # default domain and window
+    tgt = Poly([1])
+    tst = Poly([1, 2, 3])
+    for i in range(5):
+        assert_poly_almost_equal(tst**i, tgt)
+        tgt = tgt * tst
+    # check error for invalid powers
+    assert_raises(ValueError, op.pow, tgt, 1.5)
+    assert_raises(ValueError, op.pow, tgt, -1)
+
+
+def test_call(Poly):
+    P = Polynomial
+    d = Poly.domain
+    x = np.linspace(d[0], d[1], 11)
+
+    # Check defaults
+    p = Poly.cast(P([1, 2, 3]))
+    tgt = 1 + x*(2 + 3*x)
+    res = p(x)
+    assert_almost_equal(res, tgt)
+
+
+def test_call_with_list(Poly):
+    p = Poly([1, 2, 3])
+    x = [-1, 0, 2]
+    res = p(x)
+    assert_equal(res, p(np.array(x)))
+
+
+def test_cutdeg(Poly):
+    p = Poly([1, 2, 3])
+    assert_raises(ValueError, p.cutdeg, .5)
+    assert_raises(ValueError, p.cutdeg, -1)
+    assert_equal(len(p.cutdeg(3)), 3)
+    assert_equal(len(p.cutdeg(2)), 3)
+    assert_equal(len(p.cutdeg(1)), 2)
+    assert_equal(len(p.cutdeg(0)), 1)
+
+
+def test_truncate(Poly):
+    p = Poly([1, 2, 3])
+    assert_raises(ValueError, p.truncate, .5)
+    assert_raises(ValueError, p.truncate, 0)
+    assert_equal(len(p.truncate(4)), 3)
+    assert_equal(len(p.truncate(3)), 3)
+    assert_equal(len(p.truncate(2)), 2)
+    assert_equal(len(p.truncate(1)), 1)
+
+
+def test_trim(Poly):
+    c = [1, 1e-6, 1e-12, 0]
+    p = Poly(c)
+    assert_equal(p.trim().coef, c[:3])
+    assert_equal(p.trim(1e-10).coef, c[:2])
+    assert_equal(p.trim(1e-5).coef, c[:1])
+
+
+def test_mapparms(Poly):
+    # check with defaults. Should be identity.
+    d = Poly.domain
+    w = Poly.window
+    p = Poly([1], domain=d, window=w)
+    assert_almost_equal([0, 1], p.mapparms())
+    #
+    w = 2*d + 1
+    p = Poly([1], domain=d, window=w)
+    assert_almost_equal([1, 2], p.mapparms())
+
+
+def test_ufunc_override(Poly):
+    p = Poly([1, 2, 3])
+    x = np.ones(3)
+    assert_raises(TypeError, np.add, p, x)
+    assert_raises(TypeError, np.add, x, p)
+
+
+#
+# Test class method that only exists for some classes
+#
+
+
+class TestInterpolate:
+
+    def f(self, x):
+        return x * (x - 1) * (x - 2)
+
+    def test_raises(self):
+        assert_raises(ValueError, Chebyshev.interpolate, self.f, -1)
+        assert_raises(TypeError, Chebyshev.interpolate, self.f, 10.)
+
+    def test_dimensions(self):
+        for deg in range(1, 5):
+            assert_(Chebyshev.interpolate(self.f, deg).degree() == deg)
+
+    def test_approximation(self):
+
+        def powx(x, p):
+            return x**p
+
+        x = np.linspace(0, 2, 10)
+        for deg in range(0, 10):
+            for t in range(0, deg + 1):
+                p = Chebyshev.interpolate(powx, deg, domain=[0, 2], args=(t,))
+                assert_almost_equal(p(x), powx(x, t), decimal=11)
diff --git a/venv/lib/python3.12/site-packages/numpy/polynomial/tests/test_hermite.py b/venv/lib/python3.12/site-packages/numpy/polynomial/tests/test_hermite.py
new file mode 100644
index 00000000..53ee0844
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/polynomial/tests/test_hermite.py
@@ -0,0 +1,555 @@
+"""Tests for hermite module.
+
+"""
+from functools import reduce
+
+import numpy as np
+import numpy.polynomial.hermite as herm
+from numpy.polynomial.polynomial import polyval
+from numpy.testing import (
+    assert_almost_equal, assert_raises, assert_equal, assert_,
+    )
+
+H0 = np.array([1])
+H1 = np.array([0, 2])
+H2 = np.array([-2, 0, 4])
+H3 = np.array([0, -12, 0, 8])
+H4 = np.array([12, 0, -48, 0, 16])
+H5 = np.array([0, 120, 0, -160, 0, 32])
+H6 = np.array([-120, 0, 720, 0, -480, 0, 64])
+H7 = np.array([0, -1680, 0, 3360, 0, -1344, 0, 128])
+H8 = np.array([1680, 0, -13440, 0, 13440, 0, -3584, 0, 256])
+H9 = np.array([0, 30240, 0, -80640, 0, 48384, 0, -9216, 0, 512])
+
+Hlist = [H0, H1, H2, H3, H4, H5, H6, H7, H8, H9]
+
+
+def trim(x):
+    return herm.hermtrim(x, tol=1e-6)
+
+
+class TestConstants:
+
+    def test_hermdomain(self):
+        assert_equal(herm.hermdomain, [-1, 1])
+
+    def test_hermzero(self):
+        assert_equal(herm.hermzero, [0])
+
+    def test_hermone(self):
+        assert_equal(herm.hermone, [1])
+
+    def test_hermx(self):
+        assert_equal(herm.hermx, [0, .5])
+
+
+class TestArithmetic:
+    x = np.linspace(-3, 3, 100)
+
+    def test_hermadd(self):
+        for i in range(5):
+            for j in range(5):
+                msg = f"At i={i}, j={j}"
+                tgt = np.zeros(max(i, j) + 1)
+                tgt[i] += 1
+                tgt[j] += 1
+                res = herm.hermadd([0]*i + [1], [0]*j + [1])
+                assert_equal(trim(res), trim(tgt), err_msg=msg)
+
+    def test_hermsub(self):
+        for i in range(5):
+            for j in range(5):
+                msg = f"At i={i}, j={j}"
+                tgt = np.zeros(max(i, j) + 1)
+                tgt[i] += 1
+                tgt[j] -= 1
+                res = herm.hermsub([0]*i + [1], [0]*j + [1])
+                assert_equal(trim(res), trim(tgt), err_msg=msg)
+
+    def test_hermmulx(self):
+        assert_equal(herm.hermmulx([0]), [0])
+        assert_equal(herm.hermmulx([1]), [0, .5])
+        for i in range(1, 5):
+            ser = [0]*i + [1]
+            tgt = [0]*(i - 1) + [i, 0, .5]
+            assert_equal(herm.hermmulx(ser), tgt)
+
+    def test_hermmul(self):
+        # check values of result
+        for i in range(5):
+            pol1 = [0]*i + [1]
+            val1 = herm.hermval(self.x, pol1)
+            for j in range(5):
+                msg = f"At i={i}, j={j}"
+                pol2 = [0]*j + [1]
+                val2 = herm.hermval(self.x, pol2)
+                pol3 = herm.hermmul(pol1, pol2)
+                val3 = herm.hermval(self.x, pol3)
+                assert_(len(pol3) == i + j + 1, msg)
+                assert_almost_equal(val3, val1*val2, err_msg=msg)
+
+    def test_hermdiv(self):
+        for i in range(5):
+            for j in range(5):
+                msg = f"At i={i}, j={j}"
+                ci = [0]*i + [1]
+                cj = [0]*j + [1]
+                tgt = herm.hermadd(ci, cj)
+                quo, rem = herm.hermdiv(tgt, ci)
+                res = herm.hermadd(herm.hermmul(quo, ci), rem)
+                assert_equal(trim(res), trim(tgt), err_msg=msg)
+
+    def test_hermpow(self):
+        for i in range(5):
+            for j in range(5):
+                msg = f"At i={i}, j={j}"
+                c = np.arange(i + 1)
+                tgt = reduce(herm.hermmul, [c]*j, np.array([1]))
+                res = herm.hermpow(c, j) 
+                assert_equal(trim(res), trim(tgt), err_msg=msg)
+
+
+class TestEvaluation:
+    # coefficients of 1 + 2*x + 3*x**2
+    c1d = np.array([2.5, 1., .75])
+    c2d = np.einsum('i,j->ij', c1d, c1d)
+    c3d = np.einsum('i,j,k->ijk', c1d, c1d, c1d)
+
+    # some random values in [-1, 1)
+    x = np.random.random((3, 5))*2 - 1
+    y = polyval(x, [1., 2., 3.])
+
+    def test_hermval(self):
+        #check empty input
+        assert_equal(herm.hermval([], [1]).size, 0)
+
+        #check normal input)
+        x = np.linspace(-1, 1)
+        y = [polyval(x, c) for c in Hlist]
+        for i in range(10):
+            msg = f"At i={i}"
+            tgt = y[i]
+            res = herm.hermval(x, [0]*i + [1])
+            assert_almost_equal(res, tgt, err_msg=msg)
+
+        #check that shape is preserved
+        for i in range(3):
+            dims = [2]*i
+            x = np.zeros(dims)
+            assert_equal(herm.hermval(x, [1]).shape, dims)
+            assert_equal(herm.hermval(x, [1, 0]).shape, dims)
+            assert_equal(herm.hermval(x, [1, 0, 0]).shape, dims)
+
+    def test_hermval2d(self):
+        x1, x2, x3 = self.x
+        y1, y2, y3 = self.y
+
+        #test exceptions
+        assert_raises(ValueError, herm.hermval2d, x1, x2[:2], self.c2d)
+
+        #test values
+        tgt = y1*y2
+        res = herm.hermval2d(x1, x2, self.c2d)
+        assert_almost_equal(res, tgt)
+
+        #test shape
+        z = np.ones((2, 3))
+        res = herm.hermval2d(z, z, self.c2d)
+        assert_(res.shape == (2, 3))
+
+    def test_hermval3d(self):
+        x1, x2, x3 = self.x
+        y1, y2, y3 = self.y
+
+        #test exceptions
+        assert_raises(ValueError, herm.hermval3d, x1, x2, x3[:2], self.c3d)
+
+        #test values
+        tgt = y1*y2*y3
+        res = herm.hermval3d(x1, x2, x3, self.c3d)
+        assert_almost_equal(res, tgt)
+
+        #test shape
+        z = np.ones((2, 3))
+        res = herm.hermval3d(z, z, z, self.c3d)
+        assert_(res.shape == (2, 3))
+
+    def test_hermgrid2d(self):
+        x1, x2, x3 = self.x
+        y1, y2, y3 = self.y
+
+        #test values
+        tgt = np.einsum('i,j->ij', y1, y2)
+        res = herm.hermgrid2d(x1, x2, self.c2d)
+        assert_almost_equal(res, tgt)
+
+        #test shape
+        z = np.ones((2, 3))
+        res = herm.hermgrid2d(z, z, self.c2d)
+        assert_(res.shape == (2, 3)*2)
+
+    def test_hermgrid3d(self):
+        x1, x2, x3 = self.x
+        y1, y2, y3 = self.y
+
+        #test values
+        tgt = np.einsum('i,j,k->ijk', y1, y2, y3)
+        res = herm.hermgrid3d(x1, x2, x3, self.c3d)
+        assert_almost_equal(res, tgt)
+
+        #test shape
+        z = np.ones((2, 3))
+        res = herm.hermgrid3d(z, z, z, self.c3d)
+        assert_(res.shape == (2, 3)*3)
+
+
+class TestIntegral:
+
+    def test_hermint(self):
+        # check exceptions
+        assert_raises(TypeError, herm.hermint, [0], .5)
+        assert_raises(ValueError, herm.hermint, [0], -1)
+        assert_raises(ValueError, herm.hermint, [0], 1, [0, 0])
+        assert_raises(ValueError, herm.hermint, [0], lbnd=[0])
+        assert_raises(ValueError, herm.hermint, [0], scl=[0])
+        assert_raises(TypeError, herm.hermint, [0], axis=.5)
+
+        # test integration of zero polynomial
+        for i in range(2, 5):
+            k = [0]*(i - 2) + [1]
+            res = herm.hermint([0], m=i, k=k)
+            assert_almost_equal(res, [0, .5])
+
+        # check single integration with integration constant
+        for i in range(5):
+            scl = i + 1
+            pol = [0]*i + [1]
+            tgt = [i] + [0]*i + [1/scl]
+            hermpol = herm.poly2herm(pol)
+            hermint = herm.hermint(hermpol, m=1, k=[i])
+            res = herm.herm2poly(hermint)
+            assert_almost_equal(trim(res), trim(tgt))
+
+        # check single integration with integration constant and lbnd
+        for i in range(5):
+            scl = i + 1
+            pol = [0]*i + [1]
+            hermpol = herm.poly2herm(pol)
+            hermint = herm.hermint(hermpol, m=1, k=[i], lbnd=-1)
+            assert_almost_equal(herm.hermval(-1, hermint), i)
+
+        # check single integration with integration constant and scaling
+        for i in range(5):
+            scl = i + 1
+            pol = [0]*i + [1]
+            tgt = [i] + [0]*i + [2/scl]
+            hermpol = herm.poly2herm(pol)
+            hermint = herm.hermint(hermpol, m=1, k=[i], scl=2)
+            res = herm.herm2poly(hermint)
+            assert_almost_equal(trim(res), trim(tgt))
+
+        # check multiple integrations with default k
+        for i in range(5):
+            for j in range(2, 5):
+                pol = [0]*i + [1]
+                tgt = pol[:]
+                for k in range(j):
+                    tgt = herm.hermint(tgt, m=1)
+                res = herm.hermint(pol, m=j)
+                assert_almost_equal(trim(res), trim(tgt))
+
+        # check multiple integrations with defined k
+        for i in range(5):
+            for j in range(2, 5):
+                pol = [0]*i + [1]
+                tgt = pol[:]
+                for k in range(j):
+                    tgt = herm.hermint(tgt, m=1, k=[k])
+                res = herm.hermint(pol, m=j, k=list(range(j)))
+                assert_almost_equal(trim(res), trim(tgt))
+
+        # check multiple integrations with lbnd
+        for i in range(5):
+            for j in range(2, 5):
+                pol = [0]*i + [1]
+                tgt = pol[:]
+                for k in range(j):
+                    tgt = herm.hermint(tgt, m=1, k=[k], lbnd=-1)
+                res = herm.hermint(pol, m=j, k=list(range(j)), lbnd=-1)
+                assert_almost_equal(trim(res), trim(tgt))
+
+        # check multiple integrations with scaling
+        for i in range(5):
+            for j in range(2, 5):
+                pol = [0]*i + [1]
+                tgt = pol[:]
+                for k in range(j):
+                    tgt = herm.hermint(tgt, m=1, k=[k], scl=2)
+                res = herm.hermint(pol, m=j, k=list(range(j)), scl=2)
+                assert_almost_equal(trim(res), trim(tgt))
+
+    def test_hermint_axis(self):
+        # check that axis keyword works
+        c2d = np.random.random((3, 4))
+
+        tgt = np.vstack([herm.hermint(c) for c in c2d.T]).T
+        res = herm.hermint(c2d, axis=0)
+        assert_almost_equal(res, tgt)
+
+        tgt = np.vstack([herm.hermint(c) for c in c2d])
+        res = herm.hermint(c2d, axis=1)
+        assert_almost_equal(res, tgt)
+
+        tgt = np.vstack([herm.hermint(c, k=3) for c in c2d])
+        res = herm.hermint(c2d, k=3, axis=1)
+        assert_almost_equal(res, tgt)
+
+
+class TestDerivative:
+
+    def test_hermder(self):
+        # check exceptions
+        assert_raises(TypeError, herm.hermder, [0], .5)
+        assert_raises(ValueError, herm.hermder, [0], -1)
+
+        # check that zeroth derivative does nothing
+        for i in range(5):
+            tgt = [0]*i + [1]
+            res = herm.hermder(tgt, m=0)
+            assert_equal(trim(res), trim(tgt))
+
+        # check that derivation is the inverse of integration
+        for i in range(5):
+            for j in range(2, 5):
+                tgt = [0]*i + [1]
+                res = herm.hermder(herm.hermint(tgt, m=j), m=j)
+                assert_almost_equal(trim(res), trim(tgt))
+
+        # check derivation with scaling
+        for i in range(5):
+            for j in range(2, 5):
+                tgt = [0]*i + [1]
+                res = herm.hermder(herm.hermint(tgt, m=j, scl=2), m=j, scl=.5)
+                assert_almost_equal(trim(res), trim(tgt))
+
+    def test_hermder_axis(self):
+        # check that axis keyword works
+        c2d = np.random.random((3, 4))
+
+        tgt = np.vstack([herm.hermder(c) for c in c2d.T]).T
+        res = herm.hermder(c2d, axis=0)
+        assert_almost_equal(res, tgt)
+
+        tgt = np.vstack([herm.hermder(c) for c in c2d])
+        res = herm.hermder(c2d, axis=1)
+        assert_almost_equal(res, tgt)
+
+
+class TestVander:
+    # some random values in [-1, 1)
+    x = np.random.random((3, 5))*2 - 1
+
+    def test_hermvander(self):
+        # check for 1d x
+        x = np.arange(3)
+        v = herm.hermvander(x, 3)
+        assert_(v.shape == (3, 4))
+        for i in range(4):
+            coef = [0]*i + [1]
+            assert_almost_equal(v[..., i], herm.hermval(x, coef))
+
+        # check for 2d x
+        x = np.array([[1, 2], [3, 4], [5, 6]])
+        v = herm.hermvander(x, 3)
+        assert_(v.shape == (3, 2, 4))
+        for i in range(4):
+            coef = [0]*i + [1]
+            assert_almost_equal(v[..., i], herm.hermval(x, coef))
+
+    def test_hermvander2d(self):
+        # also tests hermval2d for non-square coefficient array
+        x1, x2, x3 = self.x
+        c = np.random.random((2, 3))
+        van = herm.hermvander2d(x1, x2, [1, 2])
+        tgt = herm.hermval2d(x1, x2, c)
+        res = np.dot(van, c.flat)
+        assert_almost_equal(res, tgt)
+
+        # check shape
+        van = herm.hermvander2d([x1], [x2], [1, 2])
+        assert_(van.shape == (1, 5, 6))
+
+    def test_hermvander3d(self):
+        # also tests hermval3d for non-square coefficient array
+        x1, x2, x3 = self.x
+        c = np.random.random((2, 3, 4))
+        van = herm.hermvander3d(x1, x2, x3, [1, 2, 3])
+        tgt = herm.hermval3d(x1, x2, x3, c)
+        res = np.dot(van, c.flat)
+        assert_almost_equal(res, tgt)
+
+        # check shape
+        van = herm.hermvander3d([x1], [x2], [x3], [1, 2, 3])
+        assert_(van.shape == (1, 5, 24))
+
+
+class TestFitting:
+
+    def test_hermfit(self):
+        def f(x):
+            return x*(x - 1)*(x - 2)
+
+        def f2(x):
+            return x**4 + x**2 + 1
+
+        # Test exceptions
+        assert_raises(ValueError, herm.hermfit, [1], [1], -1)
+        assert_raises(TypeError, herm.hermfit, [[1]], [1], 0)
+        assert_raises(TypeError, herm.hermfit, [], [1], 0)
+        assert_raises(TypeError, herm.hermfit, [1], [[[1]]], 0)
+        assert_raises(TypeError, herm.hermfit, [1, 2], [1], 0)
+        assert_raises(TypeError, herm.hermfit, [1], [1, 2], 0)
+        assert_raises(TypeError, herm.hermfit, [1], [1], 0, w=[[1]])
+        assert_raises(TypeError, herm.hermfit, [1], [1], 0, w=[1, 1])
+        assert_raises(ValueError, herm.hermfit, [1], [1], [-1,])
+        assert_raises(ValueError, herm.hermfit, [1], [1], [2, -1, 6])
+        assert_raises(TypeError, herm.hermfit, [1], [1], [])
+
+        # Test fit
+        x = np.linspace(0, 2)
+        y = f(x)
+        #
+        coef3 = herm.hermfit(x, y, 3)
+        assert_equal(len(coef3), 4)
+        assert_almost_equal(herm.hermval(x, coef3), y)
+        coef3 = herm.hermfit(x, y, [0, 1, 2, 3])
+        assert_equal(len(coef3), 4)
+        assert_almost_equal(herm.hermval(x, coef3), y)
+        #
+        coef4 = herm.hermfit(x, y, 4)
+        assert_equal(len(coef4), 5)
+        assert_almost_equal(herm.hermval(x, coef4), y)
+        coef4 = herm.hermfit(x, y, [0, 1, 2, 3, 4])
+        assert_equal(len(coef4), 5)
+        assert_almost_equal(herm.hermval(x, coef4), y)
+        # check things still work if deg is not in strict increasing
+        coef4 = herm.hermfit(x, y, [2, 3, 4, 1, 0])
+        assert_equal(len(coef4), 5)
+        assert_almost_equal(herm.hermval(x, coef4), y)
+        #
+        coef2d = herm.hermfit(x, np.array([y, y]).T, 3)
+        assert_almost_equal(coef2d, np.array([coef3, coef3]).T)
+        coef2d = herm.hermfit(x, np.array([y, y]).T, [0, 1, 2, 3])
+        assert_almost_equal(coef2d, np.array([coef3, coef3]).T)
+        # test weighting
+        w = np.zeros_like(x)
+        yw = y.copy()
+        w[1::2] = 1
+        y[0::2] = 0
+        wcoef3 = herm.hermfit(x, yw, 3, w=w)
+        assert_almost_equal(wcoef3, coef3)
+        wcoef3 = herm.hermfit(x, yw, [0, 1, 2, 3], w=w)
+        assert_almost_equal(wcoef3, coef3)
+        #
+        wcoef2d = herm.hermfit(x, np.array([yw, yw]).T, 3, w=w)
+        assert_almost_equal(wcoef2d, np.array([coef3, coef3]).T)
+        wcoef2d = herm.hermfit(x, np.array([yw, yw]).T, [0, 1, 2, 3], w=w)
+        assert_almost_equal(wcoef2d, np.array([coef3, coef3]).T)
+        # test scaling with complex values x points whose square
+        # is zero when summed.
+        x = [1, 1j, -1, -1j]
+        assert_almost_equal(herm.hermfit(x, x, 1), [0, .5])
+        assert_almost_equal(herm.hermfit(x, x, [0, 1]), [0, .5])
+        # test fitting only even Legendre polynomials
+        x = np.linspace(-1, 1)
+        y = f2(x)
+        coef1 = herm.hermfit(x, y, 4)
+        assert_almost_equal(herm.hermval(x, coef1), y)
+        coef2 = herm.hermfit(x, y, [0, 2, 4])
+        assert_almost_equal(herm.hermval(x, coef2), y)
+        assert_almost_equal(coef1, coef2)
+
+
+class TestCompanion:
+
+    def test_raises(self):
+        assert_raises(ValueError, herm.hermcompanion, [])
+        assert_raises(ValueError, herm.hermcompanion, [1])
+
+    def test_dimensions(self):
+        for i in range(1, 5):
+            coef = [0]*i + [1]
+            assert_(herm.hermcompanion(coef).shape == (i, i))
+
+    def test_linear_root(self):
+        assert_(herm.hermcompanion([1, 2])[0, 0] == -.25)
+
+
+class TestGauss:
+
+    def test_100(self):
+        x, w = herm.hermgauss(100)
+
+        # test orthogonality. Note that the results need to be normalized,
+        # otherwise the huge values that can arise from fast growing
+        # functions like Laguerre can be very confusing.
+        v = herm.hermvander(x, 99)
+        vv = np.dot(v.T * w, v)
+        vd = 1/np.sqrt(vv.diagonal())
+        vv = vd[:, None] * vv * vd
+        assert_almost_equal(vv, np.eye(100))
+
+        # check that the integral of 1 is correct
+        tgt = np.sqrt(np.pi)
+        assert_almost_equal(w.sum(), tgt)
+
+
+class TestMisc:
+
+    def test_hermfromroots(self):
+        res = herm.hermfromroots([])
+        assert_almost_equal(trim(res), [1])
+        for i in range(1, 5):
+            roots = np.cos(np.linspace(-np.pi, 0, 2*i + 1)[1::2])
+            pol = herm.hermfromroots(roots)
+            res = herm.hermval(roots, pol)
+            tgt = 0
+            assert_(len(pol) == i + 1)
+            assert_almost_equal(herm.herm2poly(pol)[-1], 1)
+            assert_almost_equal(res, tgt)
+
+    def test_hermroots(self):
+        assert_almost_equal(herm.hermroots([1]), [])
+        assert_almost_equal(herm.hermroots([1, 1]), [-.5])
+        for i in range(2, 5):
+            tgt = np.linspace(-1, 1, i)
+            res = herm.hermroots(herm.hermfromroots(tgt))
+            assert_almost_equal(trim(res), trim(tgt))
+
+    def test_hermtrim(self):
+        coef = [2, -1, 1, 0]
+
+        # Test exceptions
+        assert_raises(ValueError, herm.hermtrim, coef, -1)
+
+        # Test results
+        assert_equal(herm.hermtrim(coef), coef[:-1])
+        assert_equal(herm.hermtrim(coef, 1), coef[:-3])
+        assert_equal(herm.hermtrim(coef, 2), [0])
+
+    def test_hermline(self):
+        assert_equal(herm.hermline(3, 4), [3, 2])
+
+    def test_herm2poly(self):
+        for i in range(10):
+            assert_almost_equal(herm.herm2poly([0]*i + [1]), Hlist[i])
+
+    def test_poly2herm(self):
+        for i in range(10):
+            assert_almost_equal(herm.poly2herm(Hlist[i]), [0]*i + [1])
+
+    def test_weight(self):
+        x = np.linspace(-5, 5, 11)
+        tgt = np.exp(-x**2)
+        res = herm.hermweight(x)
+        assert_almost_equal(res, tgt)
diff --git a/venv/lib/python3.12/site-packages/numpy/polynomial/tests/test_hermite_e.py b/venv/lib/python3.12/site-packages/numpy/polynomial/tests/test_hermite_e.py
new file mode 100644
index 00000000..2d262a33
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/polynomial/tests/test_hermite_e.py
@@ -0,0 +1,556 @@
+"""Tests for hermite_e module.
+
+"""
+from functools import reduce
+
+import numpy as np
+import numpy.polynomial.hermite_e as herme
+from numpy.polynomial.polynomial import polyval
+from numpy.testing import (
+    assert_almost_equal, assert_raises, assert_equal, assert_,
+    )
+
+He0 = np.array([1])
+He1 = np.array([0, 1])
+He2 = np.array([-1, 0, 1])
+He3 = np.array([0, -3, 0, 1])
+He4 = np.array([3, 0, -6, 0, 1])
+He5 = np.array([0, 15, 0, -10, 0, 1])
+He6 = np.array([-15, 0, 45, 0, -15, 0, 1])
+He7 = np.array([0, -105, 0, 105, 0, -21, 0, 1])
+He8 = np.array([105, 0, -420, 0, 210, 0, -28, 0, 1])
+He9 = np.array([0, 945, 0, -1260, 0, 378, 0, -36, 0, 1])
+
+Helist = [He0, He1, He2, He3, He4, He5, He6, He7, He8, He9]
+
+
+def trim(x):
+    return herme.hermetrim(x, tol=1e-6)
+
+
+class TestConstants:
+
+    def test_hermedomain(self):
+        assert_equal(herme.hermedomain, [-1, 1])
+
+    def test_hermezero(self):
+        assert_equal(herme.hermezero, [0])
+
+    def test_hermeone(self):
+        assert_equal(herme.hermeone, [1])
+
+    def test_hermex(self):
+        assert_equal(herme.hermex, [0, 1])
+
+
+class TestArithmetic:
+    x = np.linspace(-3, 3, 100)
+
+    def test_hermeadd(self):
+        for i in range(5):
+            for j in range(5):
+                msg = f"At i={i}, j={j}"
+                tgt = np.zeros(max(i, j) + 1)
+                tgt[i] += 1
+                tgt[j] += 1
+                res = herme.hermeadd([0]*i + [1], [0]*j + [1])
+                assert_equal(trim(res), trim(tgt), err_msg=msg)
+
+    def test_hermesub(self):
+        for i in range(5):
+            for j in range(5):
+                msg = f"At i={i}, j={j}"
+                tgt = np.zeros(max(i, j) + 1)
+                tgt[i] += 1
+                tgt[j] -= 1
+                res = herme.hermesub([0]*i + [1], [0]*j + [1])
+                assert_equal(trim(res), trim(tgt), err_msg=msg)
+
+    def test_hermemulx(self):
+        assert_equal(herme.hermemulx([0]), [0])
+        assert_equal(herme.hermemulx([1]), [0, 1])
+        for i in range(1, 5):
+            ser = [0]*i + [1]
+            tgt = [0]*(i - 1) + [i, 0, 1]
+            assert_equal(herme.hermemulx(ser), tgt)
+
+    def test_hermemul(self):
+        # check values of result
+        for i in range(5):
+            pol1 = [0]*i + [1]
+            val1 = herme.hermeval(self.x, pol1)
+            for j in range(5):
+                msg = f"At i={i}, j={j}"
+                pol2 = [0]*j + [1]
+                val2 = herme.hermeval(self.x, pol2)
+                pol3 = herme.hermemul(pol1, pol2)
+                val3 = herme.hermeval(self.x, pol3)
+                assert_(len(pol3) == i + j + 1, msg)
+                assert_almost_equal(val3, val1*val2, err_msg=msg)
+
+    def test_hermediv(self):
+        for i in range(5):
+            for j in range(5):
+                msg = f"At i={i}, j={j}"
+                ci = [0]*i + [1]
+                cj = [0]*j + [1]
+                tgt = herme.hermeadd(ci, cj)
+                quo, rem = herme.hermediv(tgt, ci)
+                res = herme.hermeadd(herme.hermemul(quo, ci), rem)
+                assert_equal(trim(res), trim(tgt), err_msg=msg)
+
+    def test_hermepow(self):
+        for i in range(5):
+            for j in range(5):
+                msg = f"At i={i}, j={j}"
+                c = np.arange(i + 1)
+                tgt = reduce(herme.hermemul, [c]*j, np.array([1]))
+                res = herme.hermepow(c, j)
+                assert_equal(trim(res), trim(tgt), err_msg=msg)
+
+
+class TestEvaluation:
+    # coefficients of 1 + 2*x + 3*x**2
+    c1d = np.array([4., 2., 3.])
+    c2d = np.einsum('i,j->ij', c1d, c1d)
+    c3d = np.einsum('i,j,k->ijk', c1d, c1d, c1d)
+
+    # some random values in [-1, 1)
+    x = np.random.random((3, 5))*2 - 1
+    y = polyval(x, [1., 2., 3.])
+
+    def test_hermeval(self):
+        #check empty input
+        assert_equal(herme.hermeval([], [1]).size, 0)
+
+        #check normal input)
+        x = np.linspace(-1, 1)
+        y = [polyval(x, c) for c in Helist]
+        for i in range(10):
+            msg = f"At i={i}"
+            tgt = y[i]
+            res = herme.hermeval(x, [0]*i + [1])
+            assert_almost_equal(res, tgt, err_msg=msg)
+
+        #check that shape is preserved
+        for i in range(3):
+            dims = [2]*i
+            x = np.zeros(dims)
+            assert_equal(herme.hermeval(x, [1]).shape, dims)
+            assert_equal(herme.hermeval(x, [1, 0]).shape, dims)
+            assert_equal(herme.hermeval(x, [1, 0, 0]).shape, dims)
+
+    def test_hermeval2d(self):
+        x1, x2, x3 = self.x
+        y1, y2, y3 = self.y
+
+        #test exceptions
+        assert_raises(ValueError, herme.hermeval2d, x1, x2[:2], self.c2d)
+
+        #test values
+        tgt = y1*y2
+        res = herme.hermeval2d(x1, x2, self.c2d)
+        assert_almost_equal(res, tgt)
+
+        #test shape
+        z = np.ones((2, 3))
+        res = herme.hermeval2d(z, z, self.c2d)
+        assert_(res.shape == (2, 3))
+
+    def test_hermeval3d(self):
+        x1, x2, x3 = self.x
+        y1, y2, y3 = self.y
+
+        #test exceptions
+        assert_raises(ValueError, herme.hermeval3d, x1, x2, x3[:2], self.c3d)
+
+        #test values
+        tgt = y1*y2*y3
+        res = herme.hermeval3d(x1, x2, x3, self.c3d)
+        assert_almost_equal(res, tgt)
+
+        #test shape
+        z = np.ones((2, 3))
+        res = herme.hermeval3d(z, z, z, self.c3d)
+        assert_(res.shape == (2, 3))
+
+    def test_hermegrid2d(self):
+        x1, x2, x3 = self.x
+        y1, y2, y3 = self.y
+
+        #test values
+        tgt = np.einsum('i,j->ij', y1, y2)
+        res = herme.hermegrid2d(x1, x2, self.c2d)
+        assert_almost_equal(res, tgt)
+
+        #test shape
+        z = np.ones((2, 3))
+        res = herme.hermegrid2d(z, z, self.c2d)
+        assert_(res.shape == (2, 3)*2)
+
+    def test_hermegrid3d(self):
+        x1, x2, x3 = self.x
+        y1, y2, y3 = self.y
+
+        #test values
+        tgt = np.einsum('i,j,k->ijk', y1, y2, y3)
+        res = herme.hermegrid3d(x1, x2, x3, self.c3d)
+        assert_almost_equal(res, tgt)
+
+        #test shape
+        z = np.ones((2, 3))
+        res = herme.hermegrid3d(z, z, z, self.c3d)
+        assert_(res.shape == (2, 3)*3)
+
+
+class TestIntegral:
+
+    def test_hermeint(self):
+        # check exceptions
+        assert_raises(TypeError, herme.hermeint, [0], .5)
+        assert_raises(ValueError, herme.hermeint, [0], -1)
+        assert_raises(ValueError, herme.hermeint, [0], 1, [0, 0])
+        assert_raises(ValueError, herme.hermeint, [0], lbnd=[0])
+        assert_raises(ValueError, herme.hermeint, [0], scl=[0])
+        assert_raises(TypeError, herme.hermeint, [0], axis=.5)
+
+        # test integration of zero polynomial
+        for i in range(2, 5):
+            k = [0]*(i - 2) + [1]
+            res = herme.hermeint([0], m=i, k=k)
+            assert_almost_equal(res, [0, 1])
+
+        # check single integration with integration constant
+        for i in range(5):
+            scl = i + 1
+            pol = [0]*i + [1]
+            tgt = [i] + [0]*i + [1/scl]
+            hermepol = herme.poly2herme(pol)
+            hermeint = herme.hermeint(hermepol, m=1, k=[i])
+            res = herme.herme2poly(hermeint)
+            assert_almost_equal(trim(res), trim(tgt))
+
+        # check single integration with integration constant and lbnd
+        for i in range(5):
+            scl = i + 1
+            pol = [0]*i + [1]
+            hermepol = herme.poly2herme(pol)
+            hermeint = herme.hermeint(hermepol, m=1, k=[i], lbnd=-1)
+            assert_almost_equal(herme.hermeval(-1, hermeint), i)
+
+        # check single integration with integration constant and scaling
+        for i in range(5):
+            scl = i + 1
+            pol = [0]*i + [1]
+            tgt = [i] + [0]*i + [2/scl]
+            hermepol = herme.poly2herme(pol)
+            hermeint = herme.hermeint(hermepol, m=1, k=[i], scl=2)
+            res = herme.herme2poly(hermeint)
+            assert_almost_equal(trim(res), trim(tgt))
+
+        # check multiple integrations with default k
+        for i in range(5):
+            for j in range(2, 5):
+                pol = [0]*i + [1]
+                tgt = pol[:]
+                for k in range(j):
+                    tgt = herme.hermeint(tgt, m=1)
+                res = herme.hermeint(pol, m=j)
+                assert_almost_equal(trim(res), trim(tgt))
+
+        # check multiple integrations with defined k
+        for i in range(5):
+            for j in range(2, 5):
+                pol = [0]*i + [1]
+                tgt = pol[:]
+                for k in range(j):
+                    tgt = herme.hermeint(tgt, m=1, k=[k])
+                res = herme.hermeint(pol, m=j, k=list(range(j)))
+                assert_almost_equal(trim(res), trim(tgt))
+
+        # check multiple integrations with lbnd
+        for i in range(5):
+            for j in range(2, 5):
+                pol = [0]*i + [1]
+                tgt = pol[:]
+                for k in range(j):
+                    tgt = herme.hermeint(tgt, m=1, k=[k], lbnd=-1)
+                res = herme.hermeint(pol, m=j, k=list(range(j)), lbnd=-1)
+                assert_almost_equal(trim(res), trim(tgt))
+
+        # check multiple integrations with scaling
+        for i in range(5):
+            for j in range(2, 5):
+                pol = [0]*i + [1]
+                tgt = pol[:]
+                for k in range(j):
+                    tgt = herme.hermeint(tgt, m=1, k=[k], scl=2)
+                res = herme.hermeint(pol, m=j, k=list(range(j)), scl=2)
+                assert_almost_equal(trim(res), trim(tgt))
+
+    def test_hermeint_axis(self):
+        # check that axis keyword works
+        c2d = np.random.random((3, 4))
+
+        tgt = np.vstack([herme.hermeint(c) for c in c2d.T]).T
+        res = herme.hermeint(c2d, axis=0)
+        assert_almost_equal(res, tgt)
+
+        tgt = np.vstack([herme.hermeint(c) for c in c2d])
+        res = herme.hermeint(c2d, axis=1)
+        assert_almost_equal(res, tgt)
+
+        tgt = np.vstack([herme.hermeint(c, k=3) for c in c2d])
+        res = herme.hermeint(c2d, k=3, axis=1)
+        assert_almost_equal(res, tgt)
+
+
+class TestDerivative:
+
+    def test_hermeder(self):
+        # check exceptions
+        assert_raises(TypeError, herme.hermeder, [0], .5)
+        assert_raises(ValueError, herme.hermeder, [0], -1)
+
+        # check that zeroth derivative does nothing
+        for i in range(5):
+            tgt = [0]*i + [1]
+            res = herme.hermeder(tgt, m=0)
+            assert_equal(trim(res), trim(tgt))
+
+        # check that derivation is the inverse of integration
+        for i in range(5):
+            for j in range(2, 5):
+                tgt = [0]*i + [1]
+                res = herme.hermeder(herme.hermeint(tgt, m=j), m=j)
+                assert_almost_equal(trim(res), trim(tgt))
+
+        # check derivation with scaling
+        for i in range(5):
+            for j in range(2, 5):
+                tgt = [0]*i + [1]
+                res = herme.hermeder(
+                    herme.hermeint(tgt, m=j, scl=2), m=j, scl=.5)
+                assert_almost_equal(trim(res), trim(tgt))
+
+    def test_hermeder_axis(self):
+        # check that axis keyword works
+        c2d = np.random.random((3, 4))
+
+        tgt = np.vstack([herme.hermeder(c) for c in c2d.T]).T
+        res = herme.hermeder(c2d, axis=0)
+        assert_almost_equal(res, tgt)
+
+        tgt = np.vstack([herme.hermeder(c) for c in c2d])
+        res = herme.hermeder(c2d, axis=1)
+        assert_almost_equal(res, tgt)
+
+
+class TestVander:
+    # some random values in [-1, 1)
+    x = np.random.random((3, 5))*2 - 1
+
+    def test_hermevander(self):
+        # check for 1d x
+        x = np.arange(3)
+        v = herme.hermevander(x, 3)
+        assert_(v.shape == (3, 4))
+        for i in range(4):
+            coef = [0]*i + [1]
+            assert_almost_equal(v[..., i], herme.hermeval(x, coef))
+
+        # check for 2d x
+        x = np.array([[1, 2], [3, 4], [5, 6]])
+        v = herme.hermevander(x, 3)
+        assert_(v.shape == (3, 2, 4))
+        for i in range(4):
+            coef = [0]*i + [1]
+            assert_almost_equal(v[..., i], herme.hermeval(x, coef))
+
+    def test_hermevander2d(self):
+        # also tests hermeval2d for non-square coefficient array
+        x1, x2, x3 = self.x
+        c = np.random.random((2, 3))
+        van = herme.hermevander2d(x1, x2, [1, 2])
+        tgt = herme.hermeval2d(x1, x2, c)
+        res = np.dot(van, c.flat)
+        assert_almost_equal(res, tgt)
+
+        # check shape
+        van = herme.hermevander2d([x1], [x2], [1, 2])
+        assert_(van.shape == (1, 5, 6))
+
+    def test_hermevander3d(self):
+        # also tests hermeval3d for non-square coefficient array
+        x1, x2, x3 = self.x
+        c = np.random.random((2, 3, 4))
+        van = herme.hermevander3d(x1, x2, x3, [1, 2, 3])
+        tgt = herme.hermeval3d(x1, x2, x3, c)
+        res = np.dot(van, c.flat)
+        assert_almost_equal(res, tgt)
+
+        # check shape
+        van = herme.hermevander3d([x1], [x2], [x3], [1, 2, 3])
+        assert_(van.shape == (1, 5, 24))
+
+
+class TestFitting:
+
+    def test_hermefit(self):
+        def f(x):
+            return x*(x - 1)*(x - 2)
+
+        def f2(x):
+            return x**4 + x**2 + 1
+
+        # Test exceptions
+        assert_raises(ValueError, herme.hermefit, [1], [1], -1)
+        assert_raises(TypeError, herme.hermefit, [[1]], [1], 0)
+        assert_raises(TypeError, herme.hermefit, [], [1], 0)
+        assert_raises(TypeError, herme.hermefit, [1], [[[1]]], 0)
+        assert_raises(TypeError, herme.hermefit, [1, 2], [1], 0)
+        assert_raises(TypeError, herme.hermefit, [1], [1, 2], 0)
+        assert_raises(TypeError, herme.hermefit, [1], [1], 0, w=[[1]])
+        assert_raises(TypeError, herme.hermefit, [1], [1], 0, w=[1, 1])
+        assert_raises(ValueError, herme.hermefit, [1], [1], [-1,])
+        assert_raises(ValueError, herme.hermefit, [1], [1], [2, -1, 6])
+        assert_raises(TypeError, herme.hermefit, [1], [1], [])
+
+        # Test fit
+        x = np.linspace(0, 2)
+        y = f(x)
+        #
+        coef3 = herme.hermefit(x, y, 3)
+        assert_equal(len(coef3), 4)
+        assert_almost_equal(herme.hermeval(x, coef3), y)
+        coef3 = herme.hermefit(x, y, [0, 1, 2, 3])
+        assert_equal(len(coef3), 4)
+        assert_almost_equal(herme.hermeval(x, coef3), y)
+        #
+        coef4 = herme.hermefit(x, y, 4)
+        assert_equal(len(coef4), 5)
+        assert_almost_equal(herme.hermeval(x, coef4), y)
+        coef4 = herme.hermefit(x, y, [0, 1, 2, 3, 4])
+        assert_equal(len(coef4), 5)
+        assert_almost_equal(herme.hermeval(x, coef4), y)
+        # check things still work if deg is not in strict increasing
+        coef4 = herme.hermefit(x, y, [2, 3, 4, 1, 0])
+        assert_equal(len(coef4), 5)
+        assert_almost_equal(herme.hermeval(x, coef4), y)
+        #
+        coef2d = herme.hermefit(x, np.array([y, y]).T, 3)
+        assert_almost_equal(coef2d, np.array([coef3, coef3]).T)
+        coef2d = herme.hermefit(x, np.array([y, y]).T, [0, 1, 2, 3])
+        assert_almost_equal(coef2d, np.array([coef3, coef3]).T)
+        # test weighting
+        w = np.zeros_like(x)
+        yw = y.copy()
+        w[1::2] = 1
+        y[0::2] = 0
+        wcoef3 = herme.hermefit(x, yw, 3, w=w)
+        assert_almost_equal(wcoef3, coef3)
+        wcoef3 = herme.hermefit(x, yw, [0, 1, 2, 3], w=w)
+        assert_almost_equal(wcoef3, coef3)
+        #
+        wcoef2d = herme.hermefit(x, np.array([yw, yw]).T, 3, w=w)
+        assert_almost_equal(wcoef2d, np.array([coef3, coef3]).T)
+        wcoef2d = herme.hermefit(x, np.array([yw, yw]).T, [0, 1, 2, 3], w=w)
+        assert_almost_equal(wcoef2d, np.array([coef3, coef3]).T)
+        # test scaling with complex values x points whose square
+        # is zero when summed.
+        x = [1, 1j, -1, -1j]
+        assert_almost_equal(herme.hermefit(x, x, 1), [0, 1])
+        assert_almost_equal(herme.hermefit(x, x, [0, 1]), [0, 1])
+        # test fitting only even Legendre polynomials
+        x = np.linspace(-1, 1)
+        y = f2(x)
+        coef1 = herme.hermefit(x, y, 4)
+        assert_almost_equal(herme.hermeval(x, coef1), y)
+        coef2 = herme.hermefit(x, y, [0, 2, 4])
+        assert_almost_equal(herme.hermeval(x, coef2), y)
+        assert_almost_equal(coef1, coef2)
+
+
+class TestCompanion:
+
+    def test_raises(self):
+        assert_raises(ValueError, herme.hermecompanion, [])
+        assert_raises(ValueError, herme.hermecompanion, [1])
+
+    def test_dimensions(self):
+        for i in range(1, 5):
+            coef = [0]*i + [1]
+            assert_(herme.hermecompanion(coef).shape == (i, i))
+
+    def test_linear_root(self):
+        assert_(herme.hermecompanion([1, 2])[0, 0] == -.5)
+
+
+class TestGauss:
+
+    def test_100(self):
+        x, w = herme.hermegauss(100)
+
+        # test orthogonality. Note that the results need to be normalized,
+        # otherwise the huge values that can arise from fast growing
+        # functions like Laguerre can be very confusing.
+        v = herme.hermevander(x, 99)
+        vv = np.dot(v.T * w, v)
+        vd = 1/np.sqrt(vv.diagonal())
+        vv = vd[:, None] * vv * vd
+        assert_almost_equal(vv, np.eye(100))
+
+        # check that the integral of 1 is correct
+        tgt = np.sqrt(2*np.pi)
+        assert_almost_equal(w.sum(), tgt)
+
+
+class TestMisc:
+
+    def test_hermefromroots(self):
+        res = herme.hermefromroots([])
+        assert_almost_equal(trim(res), [1])
+        for i in range(1, 5):
+            roots = np.cos(np.linspace(-np.pi, 0, 2*i + 1)[1::2])
+            pol = herme.hermefromroots(roots)
+            res = herme.hermeval(roots, pol)
+            tgt = 0
+            assert_(len(pol) == i + 1)
+            assert_almost_equal(herme.herme2poly(pol)[-1], 1)
+            assert_almost_equal(res, tgt)
+
+    def test_hermeroots(self):
+        assert_almost_equal(herme.hermeroots([1]), [])
+        assert_almost_equal(herme.hermeroots([1, 1]), [-1])
+        for i in range(2, 5):
+            tgt = np.linspace(-1, 1, i)
+            res = herme.hermeroots(herme.hermefromroots(tgt))
+            assert_almost_equal(trim(res), trim(tgt))
+
+    def test_hermetrim(self):
+        coef = [2, -1, 1, 0]
+
+        # Test exceptions
+        assert_raises(ValueError, herme.hermetrim, coef, -1)
+
+        # Test results
+        assert_equal(herme.hermetrim(coef), coef[:-1])
+        assert_equal(herme.hermetrim(coef, 1), coef[:-3])
+        assert_equal(herme.hermetrim(coef, 2), [0])
+
+    def test_hermeline(self):
+        assert_equal(herme.hermeline(3, 4), [3, 4])
+
+    def test_herme2poly(self):
+        for i in range(10):
+            assert_almost_equal(herme.herme2poly([0]*i + [1]), Helist[i])
+
+    def test_poly2herme(self):
+        for i in range(10):
+            assert_almost_equal(herme.poly2herme(Helist[i]), [0]*i + [1])
+
+    def test_weight(self):
+        x = np.linspace(-5, 5, 11)
+        tgt = np.exp(-.5*x**2)
+        res = herme.hermeweight(x)
+        assert_almost_equal(res, tgt)
diff --git a/venv/lib/python3.12/site-packages/numpy/polynomial/tests/test_laguerre.py b/venv/lib/python3.12/site-packages/numpy/polynomial/tests/test_laguerre.py
new file mode 100644
index 00000000..227ef3c5
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/polynomial/tests/test_laguerre.py
@@ -0,0 +1,537 @@
+"""Tests for laguerre module.
+
+"""
+from functools import reduce
+
+import numpy as np
+import numpy.polynomial.laguerre as lag
+from numpy.polynomial.polynomial import polyval
+from numpy.testing import (
+    assert_almost_equal, assert_raises, assert_equal, assert_,
+    )
+
+L0 = np.array([1])/1
+L1 = np.array([1, -1])/1
+L2 = np.array([2, -4, 1])/2
+L3 = np.array([6, -18, 9, -1])/6
+L4 = np.array([24, -96, 72, -16, 1])/24
+L5 = np.array([120, -600, 600, -200, 25, -1])/120
+L6 = np.array([720, -4320, 5400, -2400, 450, -36, 1])/720
+
+Llist = [L0, L1, L2, L3, L4, L5, L6]
+
+
+def trim(x):
+    return lag.lagtrim(x, tol=1e-6)
+
+
+class TestConstants:
+
+    def test_lagdomain(self):
+        assert_equal(lag.lagdomain, [0, 1])
+
+    def test_lagzero(self):
+        assert_equal(lag.lagzero, [0])
+
+    def test_lagone(self):
+        assert_equal(lag.lagone, [1])
+
+    def test_lagx(self):
+        assert_equal(lag.lagx, [1, -1])
+
+
+class TestArithmetic:
+    x = np.linspace(-3, 3, 100)
+
+    def test_lagadd(self):
+        for i in range(5):
+            for j in range(5):
+                msg = f"At i={i}, j={j}"
+                tgt = np.zeros(max(i, j) + 1)
+                tgt[i] += 1
+                tgt[j] += 1
+                res = lag.lagadd([0]*i + [1], [0]*j + [1])
+                assert_equal(trim(res), trim(tgt), err_msg=msg)
+
+    def test_lagsub(self):
+        for i in range(5):
+            for j in range(5):
+                msg = f"At i={i}, j={j}"
+                tgt = np.zeros(max(i, j) + 1)
+                tgt[i] += 1
+                tgt[j] -= 1
+                res = lag.lagsub([0]*i + [1], [0]*j + [1])
+                assert_equal(trim(res), trim(tgt), err_msg=msg)
+
+    def test_lagmulx(self):
+        assert_equal(lag.lagmulx([0]), [0])
+        assert_equal(lag.lagmulx([1]), [1, -1])
+        for i in range(1, 5):
+            ser = [0]*i + [1]
+            tgt = [0]*(i - 1) + [-i, 2*i + 1, -(i + 1)]
+            assert_almost_equal(lag.lagmulx(ser), tgt)
+
+    def test_lagmul(self):
+        # check values of result
+        for i in range(5):
+            pol1 = [0]*i + [1]
+            val1 = lag.lagval(self.x, pol1)
+            for j in range(5):
+                msg = f"At i={i}, j={j}"
+                pol2 = [0]*j + [1]
+                val2 = lag.lagval(self.x, pol2)
+                pol3 = lag.lagmul(pol1, pol2)
+                val3 = lag.lagval(self.x, pol3)
+                assert_(len(pol3) == i + j + 1, msg)
+                assert_almost_equal(val3, val1*val2, err_msg=msg)
+
+    def test_lagdiv(self):
+        for i in range(5):
+            for j in range(5):
+                msg = f"At i={i}, j={j}"
+                ci = [0]*i + [1]
+                cj = [0]*j + [1]
+                tgt = lag.lagadd(ci, cj)
+                quo, rem = lag.lagdiv(tgt, ci)
+                res = lag.lagadd(lag.lagmul(quo, ci), rem)
+                assert_almost_equal(trim(res), trim(tgt), err_msg=msg)
+
+    def test_lagpow(self):
+        for i in range(5):
+            for j in range(5):
+                msg = f"At i={i}, j={j}"
+                c = np.arange(i + 1)
+                tgt = reduce(lag.lagmul, [c]*j, np.array([1]))
+                res = lag.lagpow(c, j) 
+                assert_equal(trim(res), trim(tgt), err_msg=msg)
+
+
+class TestEvaluation:
+    # coefficients of 1 + 2*x + 3*x**2
+    c1d = np.array([9., -14., 6.])
+    c2d = np.einsum('i,j->ij', c1d, c1d)
+    c3d = np.einsum('i,j,k->ijk', c1d, c1d, c1d)
+
+    # some random values in [-1, 1)
+    x = np.random.random((3, 5))*2 - 1
+    y = polyval(x, [1., 2., 3.])
+
+    def test_lagval(self):
+        #check empty input
+        assert_equal(lag.lagval([], [1]).size, 0)
+
+        #check normal input)
+        x = np.linspace(-1, 1)
+        y = [polyval(x, c) for c in Llist]
+        for i in range(7):
+            msg = f"At i={i}"
+            tgt = y[i]
+            res = lag.lagval(x, [0]*i + [1])
+            assert_almost_equal(res, tgt, err_msg=msg)
+
+        #check that shape is preserved
+        for i in range(3):
+            dims = [2]*i
+            x = np.zeros(dims)
+            assert_equal(lag.lagval(x, [1]).shape, dims)
+            assert_equal(lag.lagval(x, [1, 0]).shape, dims)
+            assert_equal(lag.lagval(x, [1, 0, 0]).shape, dims)
+
+    def test_lagval2d(self):
+        x1, x2, x3 = self.x
+        y1, y2, y3 = self.y
+
+        #test exceptions
+        assert_raises(ValueError, lag.lagval2d, x1, x2[:2], self.c2d)
+
+        #test values
+        tgt = y1*y2
+        res = lag.lagval2d(x1, x2, self.c2d)
+        assert_almost_equal(res, tgt)
+
+        #test shape
+        z = np.ones((2, 3))
+        res = lag.lagval2d(z, z, self.c2d)
+        assert_(res.shape == (2, 3))
+
+    def test_lagval3d(self):
+        x1, x2, x3 = self.x
+        y1, y2, y3 = self.y
+
+        #test exceptions
+        assert_raises(ValueError, lag.lagval3d, x1, x2, x3[:2], self.c3d)
+
+        #test values
+        tgt = y1*y2*y3
+        res = lag.lagval3d(x1, x2, x3, self.c3d)
+        assert_almost_equal(res, tgt)
+
+        #test shape
+        z = np.ones((2, 3))
+        res = lag.lagval3d(z, z, z, self.c3d)
+        assert_(res.shape == (2, 3))
+
+    def test_laggrid2d(self):
+        x1, x2, x3 = self.x
+        y1, y2, y3 = self.y
+
+        #test values
+        tgt = np.einsum('i,j->ij', y1, y2)
+        res = lag.laggrid2d(x1, x2, self.c2d)
+        assert_almost_equal(res, tgt)
+
+        #test shape
+        z = np.ones((2, 3))
+        res = lag.laggrid2d(z, z, self.c2d)
+        assert_(res.shape == (2, 3)*2)
+
+    def test_laggrid3d(self):
+        x1, x2, x3 = self.x
+        y1, y2, y3 = self.y
+
+        #test values
+        tgt = np.einsum('i,j,k->ijk', y1, y2, y3)
+        res = lag.laggrid3d(x1, x2, x3, self.c3d)
+        assert_almost_equal(res, tgt)
+
+        #test shape
+        z = np.ones((2, 3))
+        res = lag.laggrid3d(z, z, z, self.c3d)
+        assert_(res.shape == (2, 3)*3)
+
+
+class TestIntegral:
+
+    def test_lagint(self):
+        # check exceptions
+        assert_raises(TypeError, lag.lagint, [0], .5)
+        assert_raises(ValueError, lag.lagint, [0], -1)
+        assert_raises(ValueError, lag.lagint, [0], 1, [0, 0])
+        assert_raises(ValueError, lag.lagint, [0], lbnd=[0])
+        assert_raises(ValueError, lag.lagint, [0], scl=[0])
+        assert_raises(TypeError, lag.lagint, [0], axis=.5)
+
+        # test integration of zero polynomial
+        for i in range(2, 5):
+            k = [0]*(i - 2) + [1]
+            res = lag.lagint([0], m=i, k=k)
+            assert_almost_equal(res, [1, -1])
+
+        # check single integration with integration constant
+        for i in range(5):
+            scl = i + 1
+            pol = [0]*i + [1]
+            tgt = [i] + [0]*i + [1/scl]
+            lagpol = lag.poly2lag(pol)
+            lagint = lag.lagint(lagpol, m=1, k=[i])
+            res = lag.lag2poly(lagint)
+            assert_almost_equal(trim(res), trim(tgt))
+
+        # check single integration with integration constant and lbnd
+        for i in range(5):
+            scl = i + 1
+            pol = [0]*i + [1]
+            lagpol = lag.poly2lag(pol)
+            lagint = lag.lagint(lagpol, m=1, k=[i], lbnd=-1)
+            assert_almost_equal(lag.lagval(-1, lagint), i)
+
+        # check single integration with integration constant and scaling
+        for i in range(5):
+            scl = i + 1
+            pol = [0]*i + [1]
+            tgt = [i] + [0]*i + [2/scl]
+            lagpol = lag.poly2lag(pol)
+            lagint = lag.lagint(lagpol, m=1, k=[i], scl=2)
+            res = lag.lag2poly(lagint)
+            assert_almost_equal(trim(res), trim(tgt))
+
+        # check multiple integrations with default k
+        for i in range(5):
+            for j in range(2, 5):
+                pol = [0]*i + [1]
+                tgt = pol[:]
+                for k in range(j):
+                    tgt = lag.lagint(tgt, m=1)
+                res = lag.lagint(pol, m=j)
+                assert_almost_equal(trim(res), trim(tgt))
+
+        # check multiple integrations with defined k
+        for i in range(5):
+            for j in range(2, 5):
+                pol = [0]*i + [1]
+                tgt = pol[:]
+                for k in range(j):
+                    tgt = lag.lagint(tgt, m=1, k=[k])
+                res = lag.lagint(pol, m=j, k=list(range(j)))
+                assert_almost_equal(trim(res), trim(tgt))
+
+        # check multiple integrations with lbnd
+        for i in range(5):
+            for j in range(2, 5):
+                pol = [0]*i + [1]
+                tgt = pol[:]
+                for k in range(j):
+                    tgt = lag.lagint(tgt, m=1, k=[k], lbnd=-1)
+                res = lag.lagint(pol, m=j, k=list(range(j)), lbnd=-1)
+                assert_almost_equal(trim(res), trim(tgt))
+
+        # check multiple integrations with scaling
+        for i in range(5):
+            for j in range(2, 5):
+                pol = [0]*i + [1]
+                tgt = pol[:]
+                for k in range(j):
+                    tgt = lag.lagint(tgt, m=1, k=[k], scl=2)
+                res = lag.lagint(pol, m=j, k=list(range(j)), scl=2)
+                assert_almost_equal(trim(res), trim(tgt))
+
+    def test_lagint_axis(self):
+        # check that axis keyword works
+        c2d = np.random.random((3, 4))
+
+        tgt = np.vstack([lag.lagint(c) for c in c2d.T]).T
+        res = lag.lagint(c2d, axis=0)
+        assert_almost_equal(res, tgt)
+
+        tgt = np.vstack([lag.lagint(c) for c in c2d])
+        res = lag.lagint(c2d, axis=1)
+        assert_almost_equal(res, tgt)
+
+        tgt = np.vstack([lag.lagint(c, k=3) for c in c2d])
+        res = lag.lagint(c2d, k=3, axis=1)
+        assert_almost_equal(res, tgt)
+
+
+class TestDerivative:
+
+    def test_lagder(self):
+        # check exceptions
+        assert_raises(TypeError, lag.lagder, [0], .5)
+        assert_raises(ValueError, lag.lagder, [0], -1)
+
+        # check that zeroth derivative does nothing
+        for i in range(5):
+            tgt = [0]*i + [1]
+            res = lag.lagder(tgt, m=0)
+            assert_equal(trim(res), trim(tgt))
+
+        # check that derivation is the inverse of integration
+        for i in range(5):
+            for j in range(2, 5):
+                tgt = [0]*i + [1]
+                res = lag.lagder(lag.lagint(tgt, m=j), m=j)
+                assert_almost_equal(trim(res), trim(tgt))
+
+        # check derivation with scaling
+        for i in range(5):
+            for j in range(2, 5):
+                tgt = [0]*i + [1]
+                res = lag.lagder(lag.lagint(tgt, m=j, scl=2), m=j, scl=.5)
+                assert_almost_equal(trim(res), trim(tgt))
+
+    def test_lagder_axis(self):
+        # check that axis keyword works
+        c2d = np.random.random((3, 4))
+
+        tgt = np.vstack([lag.lagder(c) for c in c2d.T]).T
+        res = lag.lagder(c2d, axis=0)
+        assert_almost_equal(res, tgt)
+
+        tgt = np.vstack([lag.lagder(c) for c in c2d])
+        res = lag.lagder(c2d, axis=1)
+        assert_almost_equal(res, tgt)
+
+
+class TestVander:
+    # some random values in [-1, 1)
+    x = np.random.random((3, 5))*2 - 1
+
+    def test_lagvander(self):
+        # check for 1d x
+        x = np.arange(3)
+        v = lag.lagvander(x, 3)
+        assert_(v.shape == (3, 4))
+        for i in range(4):
+            coef = [0]*i + [1]
+            assert_almost_equal(v[..., i], lag.lagval(x, coef))
+
+        # check for 2d x
+        x = np.array([[1, 2], [3, 4], [5, 6]])
+        v = lag.lagvander(x, 3)
+        assert_(v.shape == (3, 2, 4))
+        for i in range(4):
+            coef = [0]*i + [1]
+            assert_almost_equal(v[..., i], lag.lagval(x, coef))
+
+    def test_lagvander2d(self):
+        # also tests lagval2d for non-square coefficient array
+        x1, x2, x3 = self.x
+        c = np.random.random((2, 3))
+        van = lag.lagvander2d(x1, x2, [1, 2])
+        tgt = lag.lagval2d(x1, x2, c)
+        res = np.dot(van, c.flat)
+        assert_almost_equal(res, tgt)
+
+        # check shape
+        van = lag.lagvander2d([x1], [x2], [1, 2])
+        assert_(van.shape == (1, 5, 6))
+
+    def test_lagvander3d(self):
+        # also tests lagval3d for non-square coefficient array
+        x1, x2, x3 = self.x
+        c = np.random.random((2, 3, 4))
+        van = lag.lagvander3d(x1, x2, x3, [1, 2, 3])
+        tgt = lag.lagval3d(x1, x2, x3, c)
+        res = np.dot(van, c.flat)
+        assert_almost_equal(res, tgt)
+
+        # check shape
+        van = lag.lagvander3d([x1], [x2], [x3], [1, 2, 3])
+        assert_(van.shape == (1, 5, 24))
+
+
+class TestFitting:
+
+    def test_lagfit(self):
+        def f(x):
+            return x*(x - 1)*(x - 2)
+
+        # Test exceptions
+        assert_raises(ValueError, lag.lagfit, [1], [1], -1)
+        assert_raises(TypeError, lag.lagfit, [[1]], [1], 0)
+        assert_raises(TypeError, lag.lagfit, [], [1], 0)
+        assert_raises(TypeError, lag.lagfit, [1], [[[1]]], 0)
+        assert_raises(TypeError, lag.lagfit, [1, 2], [1], 0)
+        assert_raises(TypeError, lag.lagfit, [1], [1, 2], 0)
+        assert_raises(TypeError, lag.lagfit, [1], [1], 0, w=[[1]])
+        assert_raises(TypeError, lag.lagfit, [1], [1], 0, w=[1, 1])
+        assert_raises(ValueError, lag.lagfit, [1], [1], [-1,])
+        assert_raises(ValueError, lag.lagfit, [1], [1], [2, -1, 6])
+        assert_raises(TypeError, lag.lagfit, [1], [1], [])
+
+        # Test fit
+        x = np.linspace(0, 2)
+        y = f(x)
+        #
+        coef3 = lag.lagfit(x, y, 3)
+        assert_equal(len(coef3), 4)
+        assert_almost_equal(lag.lagval(x, coef3), y)
+        coef3 = lag.lagfit(x, y, [0, 1, 2, 3])
+        assert_equal(len(coef3), 4)
+        assert_almost_equal(lag.lagval(x, coef3), y)
+        #
+        coef4 = lag.lagfit(x, y, 4)
+        assert_equal(len(coef4), 5)
+        assert_almost_equal(lag.lagval(x, coef4), y)
+        coef4 = lag.lagfit(x, y, [0, 1, 2, 3, 4])
+        assert_equal(len(coef4), 5)
+        assert_almost_equal(lag.lagval(x, coef4), y)
+        #
+        coef2d = lag.lagfit(x, np.array([y, y]).T, 3)
+        assert_almost_equal(coef2d, np.array([coef3, coef3]).T)
+        coef2d = lag.lagfit(x, np.array([y, y]).T, [0, 1, 2, 3])
+        assert_almost_equal(coef2d, np.array([coef3, coef3]).T)
+        # test weighting
+        w = np.zeros_like(x)
+        yw = y.copy()
+        w[1::2] = 1
+        y[0::2] = 0
+        wcoef3 = lag.lagfit(x, yw, 3, w=w)
+        assert_almost_equal(wcoef3, coef3)
+        wcoef3 = lag.lagfit(x, yw, [0, 1, 2, 3], w=w)
+        assert_almost_equal(wcoef3, coef3)
+        #
+        wcoef2d = lag.lagfit(x, np.array([yw, yw]).T, 3, w=w)
+        assert_almost_equal(wcoef2d, np.array([coef3, coef3]).T)
+        wcoef2d = lag.lagfit(x, np.array([yw, yw]).T, [0, 1, 2, 3], w=w)
+        assert_almost_equal(wcoef2d, np.array([coef3, coef3]).T)
+        # test scaling with complex values x points whose square
+        # is zero when summed.
+        x = [1, 1j, -1, -1j]
+        assert_almost_equal(lag.lagfit(x, x, 1), [1, -1])
+        assert_almost_equal(lag.lagfit(x, x, [0, 1]), [1, -1])
+
+
+class TestCompanion:
+
+    def test_raises(self):
+        assert_raises(ValueError, lag.lagcompanion, [])
+        assert_raises(ValueError, lag.lagcompanion, [1])
+
+    def test_dimensions(self):
+        for i in range(1, 5):
+            coef = [0]*i + [1]
+            assert_(lag.lagcompanion(coef).shape == (i, i))
+
+    def test_linear_root(self):
+        assert_(lag.lagcompanion([1, 2])[0, 0] == 1.5)
+
+
+class TestGauss:
+
+    def test_100(self):
+        x, w = lag.laggauss(100)
+
+        # test orthogonality. Note that the results need to be normalized,
+        # otherwise the huge values that can arise from fast growing
+        # functions like Laguerre can be very confusing.
+        v = lag.lagvander(x, 99)
+        vv = np.dot(v.T * w, v)
+        vd = 1/np.sqrt(vv.diagonal())
+        vv = vd[:, None] * vv * vd
+        assert_almost_equal(vv, np.eye(100))
+
+        # check that the integral of 1 is correct
+        tgt = 1.0
+        assert_almost_equal(w.sum(), tgt)
+
+
+class TestMisc:
+
+    def test_lagfromroots(self):
+        res = lag.lagfromroots([])
+        assert_almost_equal(trim(res), [1])
+        for i in range(1, 5):
+            roots = np.cos(np.linspace(-np.pi, 0, 2*i + 1)[1::2])
+            pol = lag.lagfromroots(roots)
+            res = lag.lagval(roots, pol)
+            tgt = 0
+            assert_(len(pol) == i + 1)
+            assert_almost_equal(lag.lag2poly(pol)[-1], 1)
+            assert_almost_equal(res, tgt)
+
+    def test_lagroots(self):
+        assert_almost_equal(lag.lagroots([1]), [])
+        assert_almost_equal(lag.lagroots([0, 1]), [1])
+        for i in range(2, 5):
+            tgt = np.linspace(0, 3, i)
+            res = lag.lagroots(lag.lagfromroots(tgt))
+            assert_almost_equal(trim(res), trim(tgt))
+
+    def test_lagtrim(self):
+        coef = [2, -1, 1, 0]
+
+        # Test exceptions
+        assert_raises(ValueError, lag.lagtrim, coef, -1)
+
+        # Test results
+        assert_equal(lag.lagtrim(coef), coef[:-1])
+        assert_equal(lag.lagtrim(coef, 1), coef[:-3])
+        assert_equal(lag.lagtrim(coef, 2), [0])
+
+    def test_lagline(self):
+        assert_equal(lag.lagline(3, 4), [7, -4])
+
+    def test_lag2poly(self):
+        for i in range(7):
+            assert_almost_equal(lag.lag2poly([0]*i + [1]), Llist[i])
+
+    def test_poly2lag(self):
+        for i in range(7):
+            assert_almost_equal(lag.poly2lag(Llist[i]), [0]*i + [1])
+
+    def test_weight(self):
+        x = np.linspace(0, 10, 11)
+        tgt = np.exp(-x)
+        res = lag.lagweight(x)
+        assert_almost_equal(res, tgt)
diff --git a/venv/lib/python3.12/site-packages/numpy/polynomial/tests/test_legendre.py b/venv/lib/python3.12/site-packages/numpy/polynomial/tests/test_legendre.py
new file mode 100644
index 00000000..92399c16
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/polynomial/tests/test_legendre.py
@@ -0,0 +1,568 @@
+"""Tests for legendre module.
+
+"""
+from functools import reduce
+
+import numpy as np
+import numpy.polynomial.legendre as leg
+from numpy.polynomial.polynomial import polyval
+from numpy.testing import (
+    assert_almost_equal, assert_raises, assert_equal, assert_,
+    )
+
+L0 = np.array([1])
+L1 = np.array([0, 1])
+L2 = np.array([-1, 0, 3])/2
+L3 = np.array([0, -3, 0, 5])/2
+L4 = np.array([3, 0, -30, 0, 35])/8
+L5 = np.array([0, 15, 0, -70, 0, 63])/8
+L6 = np.array([-5, 0, 105, 0, -315, 0, 231])/16
+L7 = np.array([0, -35, 0, 315, 0, -693, 0, 429])/16
+L8 = np.array([35, 0, -1260, 0, 6930, 0, -12012, 0, 6435])/128
+L9 = np.array([0, 315, 0, -4620, 0, 18018, 0, -25740, 0, 12155])/128
+
+Llist = [L0, L1, L2, L3, L4, L5, L6, L7, L8, L9]
+
+
+def trim(x):
+    return leg.legtrim(x, tol=1e-6)
+
+
+class TestConstants:
+
+    def test_legdomain(self):
+        assert_equal(leg.legdomain, [-1, 1])
+
+    def test_legzero(self):
+        assert_equal(leg.legzero, [0])
+
+    def test_legone(self):
+        assert_equal(leg.legone, [1])
+
+    def test_legx(self):
+        assert_equal(leg.legx, [0, 1])
+
+
+class TestArithmetic:
+    x = np.linspace(-1, 1, 100)
+
+    def test_legadd(self):
+        for i in range(5):
+            for j in range(5):
+                msg = f"At i={i}, j={j}"
+                tgt = np.zeros(max(i, j) + 1)
+                tgt[i] += 1
+                tgt[j] += 1
+                res = leg.legadd([0]*i + [1], [0]*j + [1])
+                assert_equal(trim(res), trim(tgt), err_msg=msg)
+
+    def test_legsub(self):
+        for i in range(5):
+            for j in range(5):
+                msg = f"At i={i}, j={j}"
+                tgt = np.zeros(max(i, j) + 1)
+                tgt[i] += 1
+                tgt[j] -= 1
+                res = leg.legsub([0]*i + [1], [0]*j + [1])
+                assert_equal(trim(res), trim(tgt), err_msg=msg)
+
+    def test_legmulx(self):
+        assert_equal(leg.legmulx([0]), [0])
+        assert_equal(leg.legmulx([1]), [0, 1])
+        for i in range(1, 5):
+            tmp = 2*i + 1
+            ser = [0]*i + [1]
+            tgt = [0]*(i - 1) + [i/tmp, 0, (i + 1)/tmp]
+            assert_equal(leg.legmulx(ser), tgt)
+
+    def test_legmul(self):
+        # check values of result
+        for i in range(5):
+            pol1 = [0]*i + [1]
+            val1 = leg.legval(self.x, pol1)
+            for j in range(5):
+                msg = f"At i={i}, j={j}"
+                pol2 = [0]*j + [1]
+                val2 = leg.legval(self.x, pol2)
+                pol3 = leg.legmul(pol1, pol2)
+                val3 = leg.legval(self.x, pol3)
+                assert_(len(pol3) == i + j + 1, msg)
+                assert_almost_equal(val3, val1*val2, err_msg=msg)
+
+    def test_legdiv(self):
+        for i in range(5):
+            for j in range(5):
+                msg = f"At i={i}, j={j}"
+                ci = [0]*i + [1]
+                cj = [0]*j + [1]
+                tgt = leg.legadd(ci, cj)
+                quo, rem = leg.legdiv(tgt, ci)
+                res = leg.legadd(leg.legmul(quo, ci), rem)
+                assert_equal(trim(res), trim(tgt), err_msg=msg)
+
+    def test_legpow(self):
+        for i in range(5):
+            for j in range(5):
+                msg = f"At i={i}, j={j}"
+                c = np.arange(i + 1)
+                tgt = reduce(leg.legmul, [c]*j, np.array([1]))
+                res = leg.legpow(c, j) 
+                assert_equal(trim(res), trim(tgt), err_msg=msg)
+
+
+class TestEvaluation:
+    # coefficients of 1 + 2*x + 3*x**2
+    c1d = np.array([2., 2., 2.])
+    c2d = np.einsum('i,j->ij', c1d, c1d)
+    c3d = np.einsum('i,j,k->ijk', c1d, c1d, c1d)
+
+    # some random values in [-1, 1)
+    x = np.random.random((3, 5))*2 - 1
+    y = polyval(x, [1., 2., 3.])
+
+    def test_legval(self):
+        #check empty input
+        assert_equal(leg.legval([], [1]).size, 0)
+
+        #check normal input)
+        x = np.linspace(-1, 1)
+        y = [polyval(x, c) for c in Llist]
+        for i in range(10):
+            msg = f"At i={i}"
+            tgt = y[i]
+            res = leg.legval(x, [0]*i + [1])
+            assert_almost_equal(res, tgt, err_msg=msg)
+
+        #check that shape is preserved
+        for i in range(3):
+            dims = [2]*i
+            x = np.zeros(dims)
+            assert_equal(leg.legval(x, [1]).shape, dims)
+            assert_equal(leg.legval(x, [1, 0]).shape, dims)
+            assert_equal(leg.legval(x, [1, 0, 0]).shape, dims)
+
+    def test_legval2d(self):
+        x1, x2, x3 = self.x
+        y1, y2, y3 = self.y
+
+        #test exceptions
+        assert_raises(ValueError, leg.legval2d, x1, x2[:2], self.c2d)
+
+        #test values
+        tgt = y1*y2
+        res = leg.legval2d(x1, x2, self.c2d)
+        assert_almost_equal(res, tgt)
+
+        #test shape
+        z = np.ones((2, 3))
+        res = leg.legval2d(z, z, self.c2d)
+        assert_(res.shape == (2, 3))
+
+    def test_legval3d(self):
+        x1, x2, x3 = self.x
+        y1, y2, y3 = self.y
+
+        #test exceptions
+        assert_raises(ValueError, leg.legval3d, x1, x2, x3[:2], self.c3d)
+
+        #test values
+        tgt = y1*y2*y3
+        res = leg.legval3d(x1, x2, x3, self.c3d)
+        assert_almost_equal(res, tgt)
+
+        #test shape
+        z = np.ones((2, 3))
+        res = leg.legval3d(z, z, z, self.c3d)
+        assert_(res.shape == (2, 3))
+
+    def test_leggrid2d(self):
+        x1, x2, x3 = self.x
+        y1, y2, y3 = self.y
+
+        #test values
+        tgt = np.einsum('i,j->ij', y1, y2)
+        res = leg.leggrid2d(x1, x2, self.c2d)
+        assert_almost_equal(res, tgt)
+
+        #test shape
+        z = np.ones((2, 3))
+        res = leg.leggrid2d(z, z, self.c2d)
+        assert_(res.shape == (2, 3)*2)
+
+    def test_leggrid3d(self):
+        x1, x2, x3 = self.x
+        y1, y2, y3 = self.y
+
+        #test values
+        tgt = np.einsum('i,j,k->ijk', y1, y2, y3)
+        res = leg.leggrid3d(x1, x2, x3, self.c3d)
+        assert_almost_equal(res, tgt)
+
+        #test shape
+        z = np.ones((2, 3))
+        res = leg.leggrid3d(z, z, z, self.c3d)
+        assert_(res.shape == (2, 3)*3)
+
+
+class TestIntegral:
+
+    def test_legint(self):
+        # check exceptions
+        assert_raises(TypeError, leg.legint, [0], .5)
+        assert_raises(ValueError, leg.legint, [0], -1)
+        assert_raises(ValueError, leg.legint, [0], 1, [0, 0])
+        assert_raises(ValueError, leg.legint, [0], lbnd=[0])
+        assert_raises(ValueError, leg.legint, [0], scl=[0])
+        assert_raises(TypeError, leg.legint, [0], axis=.5)
+
+        # test integration of zero polynomial
+        for i in range(2, 5):
+            k = [0]*(i - 2) + [1]
+            res = leg.legint([0], m=i, k=k)
+            assert_almost_equal(res, [0, 1])
+
+        # check single integration with integration constant
+        for i in range(5):
+            scl = i + 1
+            pol = [0]*i + [1]
+            tgt = [i] + [0]*i + [1/scl]
+            legpol = leg.poly2leg(pol)
+            legint = leg.legint(legpol, m=1, k=[i])
+            res = leg.leg2poly(legint)
+            assert_almost_equal(trim(res), trim(tgt))
+
+        # check single integration with integration constant and lbnd
+        for i in range(5):
+            scl = i + 1
+            pol = [0]*i + [1]
+            legpol = leg.poly2leg(pol)
+            legint = leg.legint(legpol, m=1, k=[i], lbnd=-1)
+            assert_almost_equal(leg.legval(-1, legint), i)
+
+        # check single integration with integration constant and scaling
+        for i in range(5):
+            scl = i + 1
+            pol = [0]*i + [1]
+            tgt = [i] + [0]*i + [2/scl]
+            legpol = leg.poly2leg(pol)
+            legint = leg.legint(legpol, m=1, k=[i], scl=2)
+            res = leg.leg2poly(legint)
+            assert_almost_equal(trim(res), trim(tgt))
+
+        # check multiple integrations with default k
+        for i in range(5):
+            for j in range(2, 5):
+                pol = [0]*i + [1]
+                tgt = pol[:]
+                for k in range(j):
+                    tgt = leg.legint(tgt, m=1)
+                res = leg.legint(pol, m=j)
+                assert_almost_equal(trim(res), trim(tgt))
+
+        # check multiple integrations with defined k
+        for i in range(5):
+            for j in range(2, 5):
+                pol = [0]*i + [1]
+                tgt = pol[:]
+                for k in range(j):
+                    tgt = leg.legint(tgt, m=1, k=[k])
+                res = leg.legint(pol, m=j, k=list(range(j)))
+                assert_almost_equal(trim(res), trim(tgt))
+
+        # check multiple integrations with lbnd
+        for i in range(5):
+            for j in range(2, 5):
+                pol = [0]*i + [1]
+                tgt = pol[:]
+                for k in range(j):
+                    tgt = leg.legint(tgt, m=1, k=[k], lbnd=-1)
+                res = leg.legint(pol, m=j, k=list(range(j)), lbnd=-1)
+                assert_almost_equal(trim(res), trim(tgt))
+
+        # check multiple integrations with scaling
+        for i in range(5):
+            for j in range(2, 5):
+                pol = [0]*i + [1]
+                tgt = pol[:]
+                for k in range(j):
+                    tgt = leg.legint(tgt, m=1, k=[k], scl=2)
+                res = leg.legint(pol, m=j, k=list(range(j)), scl=2)
+                assert_almost_equal(trim(res), trim(tgt))
+
+    def test_legint_axis(self):
+        # check that axis keyword works
+        c2d = np.random.random((3, 4))
+
+        tgt = np.vstack([leg.legint(c) for c in c2d.T]).T
+        res = leg.legint(c2d, axis=0)
+        assert_almost_equal(res, tgt)
+
+        tgt = np.vstack([leg.legint(c) for c in c2d])
+        res = leg.legint(c2d, axis=1)
+        assert_almost_equal(res, tgt)
+
+        tgt = np.vstack([leg.legint(c, k=3) for c in c2d])
+        res = leg.legint(c2d, k=3, axis=1)
+        assert_almost_equal(res, tgt)
+
+    def test_legint_zerointord(self):
+        assert_equal(leg.legint((1, 2, 3), 0), (1, 2, 3))
+
+
+class TestDerivative:
+
+    def test_legder(self):
+        # check exceptions
+        assert_raises(TypeError, leg.legder, [0], .5)
+        assert_raises(ValueError, leg.legder, [0], -1)
+
+        # check that zeroth derivative does nothing
+        for i in range(5):
+            tgt = [0]*i + [1]
+            res = leg.legder(tgt, m=0)
+            assert_equal(trim(res), trim(tgt))
+
+        # check that derivation is the inverse of integration
+        for i in range(5):
+            for j in range(2, 5):
+                tgt = [0]*i + [1]
+                res = leg.legder(leg.legint(tgt, m=j), m=j)
+                assert_almost_equal(trim(res), trim(tgt))
+
+        # check derivation with scaling
+        for i in range(5):
+            for j in range(2, 5):
+                tgt = [0]*i + [1]
+                res = leg.legder(leg.legint(tgt, m=j, scl=2), m=j, scl=.5)
+                assert_almost_equal(trim(res), trim(tgt))
+
+    def test_legder_axis(self):
+        # check that axis keyword works
+        c2d = np.random.random((3, 4))
+
+        tgt = np.vstack([leg.legder(c) for c in c2d.T]).T
+        res = leg.legder(c2d, axis=0)
+        assert_almost_equal(res, tgt)
+
+        tgt = np.vstack([leg.legder(c) for c in c2d])
+        res = leg.legder(c2d, axis=1)
+        assert_almost_equal(res, tgt)
+
+    def test_legder_orderhigherthancoeff(self):
+        c = (1, 2, 3, 4)
+        assert_equal(leg.legder(c, 4), [0])
+
+class TestVander:
+    # some random values in [-1, 1)
+    x = np.random.random((3, 5))*2 - 1
+
+    def test_legvander(self):
+        # check for 1d x
+        x = np.arange(3)
+        v = leg.legvander(x, 3)
+        assert_(v.shape == (3, 4))
+        for i in range(4):
+            coef = [0]*i + [1]
+            assert_almost_equal(v[..., i], leg.legval(x, coef))
+
+        # check for 2d x
+        x = np.array([[1, 2], [3, 4], [5, 6]])
+        v = leg.legvander(x, 3)
+        assert_(v.shape == (3, 2, 4))
+        for i in range(4):
+            coef = [0]*i + [1]
+            assert_almost_equal(v[..., i], leg.legval(x, coef))
+
+    def test_legvander2d(self):
+        # also tests polyval2d for non-square coefficient array
+        x1, x2, x3 = self.x
+        c = np.random.random((2, 3))
+        van = leg.legvander2d(x1, x2, [1, 2])
+        tgt = leg.legval2d(x1, x2, c)
+        res = np.dot(van, c.flat)
+        assert_almost_equal(res, tgt)
+
+        # check shape
+        van = leg.legvander2d([x1], [x2], [1, 2])
+        assert_(van.shape == (1, 5, 6))
+
+    def test_legvander3d(self):
+        # also tests polyval3d for non-square coefficient array
+        x1, x2, x3 = self.x
+        c = np.random.random((2, 3, 4))
+        van = leg.legvander3d(x1, x2, x3, [1, 2, 3])
+        tgt = leg.legval3d(x1, x2, x3, c)
+        res = np.dot(van, c.flat)
+        assert_almost_equal(res, tgt)
+
+        # check shape
+        van = leg.legvander3d([x1], [x2], [x3], [1, 2, 3])
+        assert_(van.shape == (1, 5, 24))
+
+    def test_legvander_negdeg(self):
+        assert_raises(ValueError, leg.legvander, (1, 2, 3), -1)
+
+
+class TestFitting:
+
+    def test_legfit(self):
+        def f(x):
+            return x*(x - 1)*(x - 2)
+
+        def f2(x):
+            return x**4 + x**2 + 1
+
+        # Test exceptions
+        assert_raises(ValueError, leg.legfit, [1], [1], -1)
+        assert_raises(TypeError, leg.legfit, [[1]], [1], 0)
+        assert_raises(TypeError, leg.legfit, [], [1], 0)
+        assert_raises(TypeError, leg.legfit, [1], [[[1]]], 0)
+        assert_raises(TypeError, leg.legfit, [1, 2], [1], 0)
+        assert_raises(TypeError, leg.legfit, [1], [1, 2], 0)
+        assert_raises(TypeError, leg.legfit, [1], [1], 0, w=[[1]])
+        assert_raises(TypeError, leg.legfit, [1], [1], 0, w=[1, 1])
+        assert_raises(ValueError, leg.legfit, [1], [1], [-1,])
+        assert_raises(ValueError, leg.legfit, [1], [1], [2, -1, 6])
+        assert_raises(TypeError, leg.legfit, [1], [1], [])
+
+        # Test fit
+        x = np.linspace(0, 2)
+        y = f(x)
+        #
+        coef3 = leg.legfit(x, y, 3)
+        assert_equal(len(coef3), 4)
+        assert_almost_equal(leg.legval(x, coef3), y)
+        coef3 = leg.legfit(x, y, [0, 1, 2, 3])
+        assert_equal(len(coef3), 4)
+        assert_almost_equal(leg.legval(x, coef3), y)
+        #
+        coef4 = leg.legfit(x, y, 4)
+        assert_equal(len(coef4), 5)
+        assert_almost_equal(leg.legval(x, coef4), y)
+        coef4 = leg.legfit(x, y, [0, 1, 2, 3, 4])
+        assert_equal(len(coef4), 5)
+        assert_almost_equal(leg.legval(x, coef4), y)
+        # check things still work if deg is not in strict increasing
+        coef4 = leg.legfit(x, y, [2, 3, 4, 1, 0])
+        assert_equal(len(coef4), 5)
+        assert_almost_equal(leg.legval(x, coef4), y)
+        #
+        coef2d = leg.legfit(x, np.array([y, y]).T, 3)
+        assert_almost_equal(coef2d, np.array([coef3, coef3]).T)
+        coef2d = leg.legfit(x, np.array([y, y]).T, [0, 1, 2, 3])
+        assert_almost_equal(coef2d, np.array([coef3, coef3]).T)
+        # test weighting
+        w = np.zeros_like(x)
+        yw = y.copy()
+        w[1::2] = 1
+        y[0::2] = 0
+        wcoef3 = leg.legfit(x, yw, 3, w=w)
+        assert_almost_equal(wcoef3, coef3)
+        wcoef3 = leg.legfit(x, yw, [0, 1, 2, 3], w=w)
+        assert_almost_equal(wcoef3, coef3)
+        #
+        wcoef2d = leg.legfit(x, np.array([yw, yw]).T, 3, w=w)
+        assert_almost_equal(wcoef2d, np.array([coef3, coef3]).T)
+        wcoef2d = leg.legfit(x, np.array([yw, yw]).T, [0, 1, 2, 3], w=w)
+        assert_almost_equal(wcoef2d, np.array([coef3, coef3]).T)
+        # test scaling with complex values x points whose square
+        # is zero when summed.
+        x = [1, 1j, -1, -1j]
+        assert_almost_equal(leg.legfit(x, x, 1), [0, 1])
+        assert_almost_equal(leg.legfit(x, x, [0, 1]), [0, 1])
+        # test fitting only even Legendre polynomials
+        x = np.linspace(-1, 1)
+        y = f2(x)
+        coef1 = leg.legfit(x, y, 4)
+        assert_almost_equal(leg.legval(x, coef1), y)
+        coef2 = leg.legfit(x, y, [0, 2, 4])
+        assert_almost_equal(leg.legval(x, coef2), y)
+        assert_almost_equal(coef1, coef2)
+
+
+class TestCompanion:
+
+    def test_raises(self):
+        assert_raises(ValueError, leg.legcompanion, [])
+        assert_raises(ValueError, leg.legcompanion, [1])
+
+    def test_dimensions(self):
+        for i in range(1, 5):
+            coef = [0]*i + [1]
+            assert_(leg.legcompanion(coef).shape == (i, i))
+
+    def test_linear_root(self):
+        assert_(leg.legcompanion([1, 2])[0, 0] == -.5)
+
+
+class TestGauss:
+
+    def test_100(self):
+        x, w = leg.leggauss(100)
+
+        # test orthogonality. Note that the results need to be normalized,
+        # otherwise the huge values that can arise from fast growing
+        # functions like Laguerre can be very confusing.
+        v = leg.legvander(x, 99)
+        vv = np.dot(v.T * w, v)
+        vd = 1/np.sqrt(vv.diagonal())
+        vv = vd[:, None] * vv * vd
+        assert_almost_equal(vv, np.eye(100))
+
+        # check that the integral of 1 is correct
+        tgt = 2.0
+        assert_almost_equal(w.sum(), tgt)
+
+
+class TestMisc:
+
+    def test_legfromroots(self):
+        res = leg.legfromroots([])
+        assert_almost_equal(trim(res), [1])
+        for i in range(1, 5):
+            roots = np.cos(np.linspace(-np.pi, 0, 2*i + 1)[1::2])
+            pol = leg.legfromroots(roots)
+            res = leg.legval(roots, pol)
+            tgt = 0
+            assert_(len(pol) == i + 1)
+            assert_almost_equal(leg.leg2poly(pol)[-1], 1)
+            assert_almost_equal(res, tgt)
+
+    def test_legroots(self):
+        assert_almost_equal(leg.legroots([1]), [])
+        assert_almost_equal(leg.legroots([1, 2]), [-.5])
+        for i in range(2, 5):
+            tgt = np.linspace(-1, 1, i)
+            res = leg.legroots(leg.legfromroots(tgt))
+            assert_almost_equal(trim(res), trim(tgt))
+
+    def test_legtrim(self):
+        coef = [2, -1, 1, 0]
+
+        # Test exceptions
+        assert_raises(ValueError, leg.legtrim, coef, -1)
+
+        # Test results
+        assert_equal(leg.legtrim(coef), coef[:-1])
+        assert_equal(leg.legtrim(coef, 1), coef[:-3])
+        assert_equal(leg.legtrim(coef, 2), [0])
+
+    def test_legline(self):
+        assert_equal(leg.legline(3, 4), [3, 4])
+
+    def test_legline_zeroscl(self):
+        assert_equal(leg.legline(3, 0), [3])
+
+    def test_leg2poly(self):
+        for i in range(10):
+            assert_almost_equal(leg.leg2poly([0]*i + [1]), Llist[i])
+
+    def test_poly2leg(self):
+        for i in range(10):
+            assert_almost_equal(leg.poly2leg(Llist[i]), [0]*i + [1])
+
+    def test_weight(self):
+        x = np.linspace(-1, 1, 11)
+        tgt = 1.
+        res = leg.legweight(x)
+        assert_almost_equal(res, tgt)
diff --git a/venv/lib/python3.12/site-packages/numpy/polynomial/tests/test_polynomial.py b/venv/lib/python3.12/site-packages/numpy/polynomial/tests/test_polynomial.py
new file mode 100644
index 00000000..162cb0a9
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/polynomial/tests/test_polynomial.py
@@ -0,0 +1,647 @@
+"""Tests for polynomial module.
+
+"""
+from functools import reduce
+from fractions import Fraction
+import numpy as np
+import numpy.polynomial.polynomial as poly
+import numpy.polynomial.polyutils as pu
+import pickle
+from copy import deepcopy
+from numpy.testing import (
+    assert_almost_equal, assert_raises, assert_equal, assert_,
+    assert_array_equal, assert_raises_regex, assert_warns)
+
+
+def trim(x):
+    return poly.polytrim(x, tol=1e-6)
+
+T0 = [1]
+T1 = [0, 1]
+T2 = [-1, 0, 2]
+T3 = [0, -3, 0, 4]
+T4 = [1, 0, -8, 0, 8]
+T5 = [0, 5, 0, -20, 0, 16]
+T6 = [-1, 0, 18, 0, -48, 0, 32]
+T7 = [0, -7, 0, 56, 0, -112, 0, 64]
+T8 = [1, 0, -32, 0, 160, 0, -256, 0, 128]
+T9 = [0, 9, 0, -120, 0, 432, 0, -576, 0, 256]
+
+Tlist = [T0, T1, T2, T3, T4, T5, T6, T7, T8, T9]
+
+
+class TestConstants:
+
+    def test_polydomain(self):
+        assert_equal(poly.polydomain, [-1, 1])
+
+    def test_polyzero(self):
+        assert_equal(poly.polyzero, [0])
+
+    def test_polyone(self):
+        assert_equal(poly.polyone, [1])
+
+    def test_polyx(self):
+        assert_equal(poly.polyx, [0, 1])
+
+    def test_copy(self):
+        x = poly.Polynomial([1, 2, 3])
+        y = deepcopy(x)
+        assert_equal(x, y)
+
+    def test_pickle(self):
+        x = poly.Polynomial([1, 2, 3])
+        y = pickle.loads(pickle.dumps(x))
+        assert_equal(x, y)
+
+class TestArithmetic:
+
+    def test_polyadd(self):
+        for i in range(5):
+            for j in range(5):
+                msg = f"At i={i}, j={j}"
+                tgt = np.zeros(max(i, j) + 1)
+                tgt[i] += 1
+                tgt[j] += 1
+                res = poly.polyadd([0]*i + [1], [0]*j + [1])
+                assert_equal(trim(res), trim(tgt), err_msg=msg)
+
+    def test_polysub(self):
+        for i in range(5):
+            for j in range(5):
+                msg = f"At i={i}, j={j}"
+                tgt = np.zeros(max(i, j) + 1)
+                tgt[i] += 1
+                tgt[j] -= 1
+                res = poly.polysub([0]*i + [1], [0]*j + [1])
+                assert_equal(trim(res), trim(tgt), err_msg=msg)
+
+    def test_polymulx(self):
+        assert_equal(poly.polymulx([0]), [0])
+        assert_equal(poly.polymulx([1]), [0, 1])
+        for i in range(1, 5):
+            ser = [0]*i + [1]
+            tgt = [0]*(i + 1) + [1]
+            assert_equal(poly.polymulx(ser), tgt)
+
+    def test_polymul(self):
+        for i in range(5):
+            for j in range(5):
+                msg = f"At i={i}, j={j}"
+                tgt = np.zeros(i + j + 1)
+                tgt[i + j] += 1
+                res = poly.polymul([0]*i + [1], [0]*j + [1])
+                assert_equal(trim(res), trim(tgt), err_msg=msg)
+
+    def test_polydiv(self):
+        # check zero division
+        assert_raises(ZeroDivisionError, poly.polydiv, [1], [0])
+
+        # check scalar division
+        quo, rem = poly.polydiv([2], [2])
+        assert_equal((quo, rem), (1, 0))
+        quo, rem = poly.polydiv([2, 2], [2])
+        assert_equal((quo, rem), ((1, 1), 0))
+
+        # check rest.
+        for i in range(5):
+            for j in range(5):
+                msg = f"At i={i}, j={j}"
+                ci = [0]*i + [1, 2]
+                cj = [0]*j + [1, 2]
+                tgt = poly.polyadd(ci, cj)
+                quo, rem = poly.polydiv(tgt, ci)
+                res = poly.polyadd(poly.polymul(quo, ci), rem)
+                assert_equal(res, tgt, err_msg=msg)
+
+    def test_polypow(self):
+        for i in range(5):
+            for j in range(5):
+                msg = f"At i={i}, j={j}"
+                c = np.arange(i + 1)
+                tgt = reduce(poly.polymul, [c]*j, np.array([1]))
+                res = poly.polypow(c, j) 
+                assert_equal(trim(res), trim(tgt), err_msg=msg)
+
+class TestFraction:
+
+    def test_Fraction(self):
+        # assert we can use Polynomials with coefficients of object dtype
+        f = Fraction(2, 3)
+        one = Fraction(1, 1)
+        zero = Fraction(0, 1)
+        p = poly.Polynomial([f, f], domain=[zero, one], window=[zero, one])
+        
+        x = 2 * p + p ** 2
+        assert_equal(x.coef, np.array([Fraction(16, 9), Fraction(20, 9),
+                                       Fraction(4, 9)], dtype=object))
+        assert_equal(p.domain, [zero, one])
+        assert_equal(p.coef.dtype, np.dtypes.ObjectDType())
+        assert_(isinstance(p(f), Fraction))
+        assert_equal(p(f), Fraction(10, 9))
+        p_deriv = poly.Polynomial([Fraction(2, 3)], domain=[zero, one],
+                                  window=[zero, one])
+        assert_equal(p.deriv(), p_deriv)
+
+class TestEvaluation:
+    # coefficients of 1 + 2*x + 3*x**2
+    c1d = np.array([1., 2., 3.])
+    c2d = np.einsum('i,j->ij', c1d, c1d)
+    c3d = np.einsum('i,j,k->ijk', c1d, c1d, c1d)
+
+    # some random values in [-1, 1)
+    x = np.random.random((3, 5))*2 - 1
+    y = poly.polyval(x, [1., 2., 3.])
+
+    def test_polyval(self):
+        #check empty input
+        assert_equal(poly.polyval([], [1]).size, 0)
+
+        #check normal input)
+        x = np.linspace(-1, 1)
+        y = [x**i for i in range(5)]
+        for i in range(5):
+            tgt = y[i]
+            res = poly.polyval(x, [0]*i + [1])
+            assert_almost_equal(res, tgt)
+        tgt = x*(x**2 - 1)
+        res = poly.polyval(x, [0, -1, 0, 1])
+        assert_almost_equal(res, tgt)
+
+        #check that shape is preserved
+        for i in range(3):
+            dims = [2]*i
+            x = np.zeros(dims)
+            assert_equal(poly.polyval(x, [1]).shape, dims)
+            assert_equal(poly.polyval(x, [1, 0]).shape, dims)
+            assert_equal(poly.polyval(x, [1, 0, 0]).shape, dims)
+
+        #check masked arrays are processed correctly
+        mask = [False, True, False]
+        mx = np.ma.array([1, 2, 3], mask=mask)
+        res = np.polyval([7, 5, 3], mx)
+        assert_array_equal(res.mask, mask)
+
+        #check subtypes of ndarray are preserved
+        class C(np.ndarray):
+            pass
+
+        cx = np.array([1, 2, 3]).view(C)
+        assert_equal(type(np.polyval([2, 3, 4], cx)), C)
+
+    def test_polyvalfromroots(self):
+        # check exception for broadcasting x values over root array with
+        # too few dimensions
+        assert_raises(ValueError, poly.polyvalfromroots,
+                      [1], [1], tensor=False)
+
+        # check empty input
+        assert_equal(poly.polyvalfromroots([], [1]).size, 0)
+        assert_(poly.polyvalfromroots([], [1]).shape == (0,))
+
+        # check empty input + multidimensional roots
+        assert_equal(poly.polyvalfromroots([], [[1] * 5]).size, 0)
+        assert_(poly.polyvalfromroots([], [[1] * 5]).shape == (5, 0))
+
+        # check scalar input
+        assert_equal(poly.polyvalfromroots(1, 1), 0)
+        assert_(poly.polyvalfromroots(1, np.ones((3, 3))).shape == (3,))
+
+        # check normal input)
+        x = np.linspace(-1, 1)
+        y = [x**i for i in range(5)]
+        for i in range(1, 5):
+            tgt = y[i]
+            res = poly.polyvalfromroots(x, [0]*i)
+            assert_almost_equal(res, tgt)
+        tgt = x*(x - 1)*(x + 1)
+        res = poly.polyvalfromroots(x, [-1, 0, 1])
+        assert_almost_equal(res, tgt)
+
+        # check that shape is preserved
+        for i in range(3):
+            dims = [2]*i
+            x = np.zeros(dims)
+            assert_equal(poly.polyvalfromroots(x, [1]).shape, dims)
+            assert_equal(poly.polyvalfromroots(x, [1, 0]).shape, dims)
+            assert_equal(poly.polyvalfromroots(x, [1, 0, 0]).shape, dims)
+
+        # check compatibility with factorization
+        ptest = [15, 2, -16, -2, 1]
+        r = poly.polyroots(ptest)
+        x = np.linspace(-1, 1)
+        assert_almost_equal(poly.polyval(x, ptest),
+                            poly.polyvalfromroots(x, r))
+
+        # check multidimensional arrays of roots and values
+        # check tensor=False
+        rshape = (3, 5)
+        x = np.arange(-3, 2)
+        r = np.random.randint(-5, 5, size=rshape)
+        res = poly.polyvalfromroots(x, r, tensor=False)
+        tgt = np.empty(r.shape[1:])
+        for ii in range(tgt.size):
+            tgt[ii] = poly.polyvalfromroots(x[ii], r[:, ii])
+        assert_equal(res, tgt)
+
+        # check tensor=True
+        x = np.vstack([x, 2*x])
+        res = poly.polyvalfromroots(x, r, tensor=True)
+        tgt = np.empty(r.shape[1:] + x.shape)
+        for ii in range(r.shape[1]):
+            for jj in range(x.shape[0]):
+                tgt[ii, jj, :] = poly.polyvalfromroots(x[jj], r[:, ii])
+        assert_equal(res, tgt)
+
+    def test_polyval2d(self):
+        x1, x2, x3 = self.x
+        y1, y2, y3 = self.y
+
+        #test exceptions
+        assert_raises_regex(ValueError, 'incompatible',
+                            poly.polyval2d, x1, x2[:2], self.c2d)
+
+        #test values
+        tgt = y1*y2
+        res = poly.polyval2d(x1, x2, self.c2d)
+        assert_almost_equal(res, tgt)
+
+        #test shape
+        z = np.ones((2, 3))
+        res = poly.polyval2d(z, z, self.c2d)
+        assert_(res.shape == (2, 3))
+
+    def test_polyval3d(self):
+        x1, x2, x3 = self.x
+        y1, y2, y3 = self.y
+
+        #test exceptions
+        assert_raises_regex(ValueError, 'incompatible',
+                      poly.polyval3d, x1, x2, x3[:2], self.c3d)
+
+        #test values
+        tgt = y1*y2*y3
+        res = poly.polyval3d(x1, x2, x3, self.c3d)
+        assert_almost_equal(res, tgt)
+
+        #test shape
+        z = np.ones((2, 3))
+        res = poly.polyval3d(z, z, z, self.c3d)
+        assert_(res.shape == (2, 3))
+
+    def test_polygrid2d(self):
+        x1, x2, x3 = self.x
+        y1, y2, y3 = self.y
+
+        #test values
+        tgt = np.einsum('i,j->ij', y1, y2)
+        res = poly.polygrid2d(x1, x2, self.c2d)
+        assert_almost_equal(res, tgt)
+
+        #test shape
+        z = np.ones((2, 3))
+        res = poly.polygrid2d(z, z, self.c2d)
+        assert_(res.shape == (2, 3)*2)
+
+    def test_polygrid3d(self):
+        x1, x2, x3 = self.x
+        y1, y2, y3 = self.y
+
+        #test values
+        tgt = np.einsum('i,j,k->ijk', y1, y2, y3)
+        res = poly.polygrid3d(x1, x2, x3, self.c3d)
+        assert_almost_equal(res, tgt)
+
+        #test shape
+        z = np.ones((2, 3))
+        res = poly.polygrid3d(z, z, z, self.c3d)
+        assert_(res.shape == (2, 3)*3)
+
+
+class TestIntegral:
+
+    def test_polyint(self):
+        # check exceptions
+        assert_raises(TypeError, poly.polyint, [0], .5)
+        assert_raises(ValueError, poly.polyint, [0], -1)
+        assert_raises(ValueError, poly.polyint, [0], 1, [0, 0])
+        assert_raises(ValueError, poly.polyint, [0], lbnd=[0])
+        assert_raises(ValueError, poly.polyint, [0], scl=[0])
+        assert_raises(TypeError, poly.polyint, [0], axis=.5)
+        assert_raises(TypeError, poly.polyint, [1, 1], 1.)
+
+        # test integration of zero polynomial
+        for i in range(2, 5):
+            k = [0]*(i - 2) + [1]
+            res = poly.polyint([0], m=i, k=k)
+            assert_almost_equal(res, [0, 1])
+
+        # check single integration with integration constant
+        for i in range(5):
+            scl = i + 1
+            pol = [0]*i + [1]
+            tgt = [i] + [0]*i + [1/scl]
+            res = poly.polyint(pol, m=1, k=[i])
+            assert_almost_equal(trim(res), trim(tgt))
+
+        # check single integration with integration constant and lbnd
+        for i in range(5):
+            scl = i + 1
+            pol = [0]*i + [1]
+            res = poly.polyint(pol, m=1, k=[i], lbnd=-1)
+            assert_almost_equal(poly.polyval(-1, res), i)
+
+        # check single integration with integration constant and scaling
+        for i in range(5):
+            scl = i + 1
+            pol = [0]*i + [1]
+            tgt = [i] + [0]*i + [2/scl]
+            res = poly.polyint(pol, m=1, k=[i], scl=2)
+            assert_almost_equal(trim(res), trim(tgt))
+
+        # check multiple integrations with default k
+        for i in range(5):
+            for j in range(2, 5):
+                pol = [0]*i + [1]
+                tgt = pol[:]
+                for k in range(j):
+                    tgt = poly.polyint(tgt, m=1)
+                res = poly.polyint(pol, m=j)
+                assert_almost_equal(trim(res), trim(tgt))
+
+        # check multiple integrations with defined k
+        for i in range(5):
+            for j in range(2, 5):
+                pol = [0]*i + [1]
+                tgt = pol[:]
+                for k in range(j):
+                    tgt = poly.polyint(tgt, m=1, k=[k])
+                res = poly.polyint(pol, m=j, k=list(range(j)))
+                assert_almost_equal(trim(res), trim(tgt))
+
+        # check multiple integrations with lbnd
+        for i in range(5):
+            for j in range(2, 5):
+                pol = [0]*i + [1]
+                tgt = pol[:]
+                for k in range(j):
+                    tgt = poly.polyint(tgt, m=1, k=[k], lbnd=-1)
+                res = poly.polyint(pol, m=j, k=list(range(j)), lbnd=-1)
+                assert_almost_equal(trim(res), trim(tgt))
+
+        # check multiple integrations with scaling
+        for i in range(5):
+            for j in range(2, 5):
+                pol = [0]*i + [1]
+                tgt = pol[:]
+                for k in range(j):
+                    tgt = poly.polyint(tgt, m=1, k=[k], scl=2)
+                res = poly.polyint(pol, m=j, k=list(range(j)), scl=2)
+                assert_almost_equal(trim(res), trim(tgt))
+
+    def test_polyint_axis(self):
+        # check that axis keyword works
+        c2d = np.random.random((3, 4))
+
+        tgt = np.vstack([poly.polyint(c) for c in c2d.T]).T
+        res = poly.polyint(c2d, axis=0)
+        assert_almost_equal(res, tgt)
+
+        tgt = np.vstack([poly.polyint(c) for c in c2d])
+        res = poly.polyint(c2d, axis=1)
+        assert_almost_equal(res, tgt)
+
+        tgt = np.vstack([poly.polyint(c, k=3) for c in c2d])
+        res = poly.polyint(c2d, k=3, axis=1)
+        assert_almost_equal(res, tgt)
+
+
+class TestDerivative:
+
+    def test_polyder(self):
+        # check exceptions
+        assert_raises(TypeError, poly.polyder, [0], .5)
+        assert_raises(ValueError, poly.polyder, [0], -1)
+
+        # check that zeroth derivative does nothing
+        for i in range(5):
+            tgt = [0]*i + [1]
+            res = poly.polyder(tgt, m=0)
+            assert_equal(trim(res), trim(tgt))
+
+        # check that derivation is the inverse of integration
+        for i in range(5):
+            for j in range(2, 5):
+                tgt = [0]*i + [1]
+                res = poly.polyder(poly.polyint(tgt, m=j), m=j)
+                assert_almost_equal(trim(res), trim(tgt))
+
+        # check derivation with scaling
+        for i in range(5):
+            for j in range(2, 5):
+                tgt = [0]*i + [1]
+                res = poly.polyder(poly.polyint(tgt, m=j, scl=2), m=j, scl=.5)
+                assert_almost_equal(trim(res), trim(tgt))
+
+    def test_polyder_axis(self):
+        # check that axis keyword works
+        c2d = np.random.random((3, 4))
+
+        tgt = np.vstack([poly.polyder(c) for c in c2d.T]).T
+        res = poly.polyder(c2d, axis=0)
+        assert_almost_equal(res, tgt)
+
+        tgt = np.vstack([poly.polyder(c) for c in c2d])
+        res = poly.polyder(c2d, axis=1)
+        assert_almost_equal(res, tgt)
+
+
+class TestVander:
+    # some random values in [-1, 1)
+    x = np.random.random((3, 5))*2 - 1
+
+    def test_polyvander(self):
+        # check for 1d x
+        x = np.arange(3)
+        v = poly.polyvander(x, 3)
+        assert_(v.shape == (3, 4))
+        for i in range(4):
+            coef = [0]*i + [1]
+            assert_almost_equal(v[..., i], poly.polyval(x, coef))
+
+        # check for 2d x
+        x = np.array([[1, 2], [3, 4], [5, 6]])
+        v = poly.polyvander(x, 3)
+        assert_(v.shape == (3, 2, 4))
+        for i in range(4):
+            coef = [0]*i + [1]
+            assert_almost_equal(v[..., i], poly.polyval(x, coef))
+
+    def test_polyvander2d(self):
+        # also tests polyval2d for non-square coefficient array
+        x1, x2, x3 = self.x
+        c = np.random.random((2, 3))
+        van = poly.polyvander2d(x1, x2, [1, 2])
+        tgt = poly.polyval2d(x1, x2, c)
+        res = np.dot(van, c.flat)
+        assert_almost_equal(res, tgt)
+
+        # check shape
+        van = poly.polyvander2d([x1], [x2], [1, 2])
+        assert_(van.shape == (1, 5, 6))
+
+    def test_polyvander3d(self):
+        # also tests polyval3d for non-square coefficient array
+        x1, x2, x3 = self.x
+        c = np.random.random((2, 3, 4))
+        van = poly.polyvander3d(x1, x2, x3, [1, 2, 3])
+        tgt = poly.polyval3d(x1, x2, x3, c)
+        res = np.dot(van, c.flat)
+        assert_almost_equal(res, tgt)
+
+        # check shape
+        van = poly.polyvander3d([x1], [x2], [x3], [1, 2, 3])
+        assert_(van.shape == (1, 5, 24))
+
+    def test_polyvandernegdeg(self):
+        x = np.arange(3)
+        assert_raises(ValueError, poly.polyvander, x, -1)
+
+
+class TestCompanion:
+
+    def test_raises(self):
+        assert_raises(ValueError, poly.polycompanion, [])
+        assert_raises(ValueError, poly.polycompanion, [1])
+
+    def test_dimensions(self):
+        for i in range(1, 5):
+            coef = [0]*i + [1]
+            assert_(poly.polycompanion(coef).shape == (i, i))
+
+    def test_linear_root(self):
+        assert_(poly.polycompanion([1, 2])[0, 0] == -.5)
+
+
+class TestMisc:
+
+    def test_polyfromroots(self):
+        res = poly.polyfromroots([])
+        assert_almost_equal(trim(res), [1])
+        for i in range(1, 5):
+            roots = np.cos(np.linspace(-np.pi, 0, 2*i + 1)[1::2])
+            tgt = Tlist[i]
+            res = poly.polyfromroots(roots)*2**(i-1)
+            assert_almost_equal(trim(res), trim(tgt))
+
+    def test_polyroots(self):
+        assert_almost_equal(poly.polyroots([1]), [])
+        assert_almost_equal(poly.polyroots([1, 2]), [-.5])
+        for i in range(2, 5):
+            tgt = np.linspace(-1, 1, i)
+            res = poly.polyroots(poly.polyfromroots(tgt))
+            assert_almost_equal(trim(res), trim(tgt))
+
+    def test_polyfit(self):
+        def f(x):
+            return x*(x - 1)*(x - 2)
+
+        def f2(x):
+            return x**4 + x**2 + 1
+
+        # Test exceptions
+        assert_raises(ValueError, poly.polyfit, [1], [1], -1)
+        assert_raises(TypeError, poly.polyfit, [[1]], [1], 0)
+        assert_raises(TypeError, poly.polyfit, [], [1], 0)
+        assert_raises(TypeError, poly.polyfit, [1], [[[1]]], 0)
+        assert_raises(TypeError, poly.polyfit, [1, 2], [1], 0)
+        assert_raises(TypeError, poly.polyfit, [1], [1, 2], 0)
+        assert_raises(TypeError, poly.polyfit, [1], [1], 0, w=[[1]])
+        assert_raises(TypeError, poly.polyfit, [1], [1], 0, w=[1, 1])
+        assert_raises(ValueError, poly.polyfit, [1], [1], [-1,])
+        assert_raises(ValueError, poly.polyfit, [1], [1], [2, -1, 6])
+        assert_raises(TypeError, poly.polyfit, [1], [1], [])
+
+        # Test fit
+        x = np.linspace(0, 2)
+        y = f(x)
+        #
+        coef3 = poly.polyfit(x, y, 3)
+        assert_equal(len(coef3), 4)
+        assert_almost_equal(poly.polyval(x, coef3), y)
+        coef3 = poly.polyfit(x, y, [0, 1, 2, 3])
+        assert_equal(len(coef3), 4)
+        assert_almost_equal(poly.polyval(x, coef3), y)
+        #
+        coef4 = poly.polyfit(x, y, 4)
+        assert_equal(len(coef4), 5)
+        assert_almost_equal(poly.polyval(x, coef4), y)
+        coef4 = poly.polyfit(x, y, [0, 1, 2, 3, 4])
+        assert_equal(len(coef4), 5)
+        assert_almost_equal(poly.polyval(x, coef4), y)
+        #
+        coef2d = poly.polyfit(x, np.array([y, y]).T, 3)
+        assert_almost_equal(coef2d, np.array([coef3, coef3]).T)
+        coef2d = poly.polyfit(x, np.array([y, y]).T, [0, 1, 2, 3])
+        assert_almost_equal(coef2d, np.array([coef3, coef3]).T)
+        # test weighting
+        w = np.zeros_like(x)
+        yw = y.copy()
+        w[1::2] = 1
+        yw[0::2] = 0
+        wcoef3 = poly.polyfit(x, yw, 3, w=w)
+        assert_almost_equal(wcoef3, coef3)
+        wcoef3 = poly.polyfit(x, yw, [0, 1, 2, 3], w=w)
+        assert_almost_equal(wcoef3, coef3)
+        #
+        wcoef2d = poly.polyfit(x, np.array([yw, yw]).T, 3, w=w)
+        assert_almost_equal(wcoef2d, np.array([coef3, coef3]).T)
+        wcoef2d = poly.polyfit(x, np.array([yw, yw]).T, [0, 1, 2, 3], w=w)
+        assert_almost_equal(wcoef2d, np.array([coef3, coef3]).T)
+        # test scaling with complex values x points whose square
+        # is zero when summed.
+        x = [1, 1j, -1, -1j]
+        assert_almost_equal(poly.polyfit(x, x, 1), [0, 1])
+        assert_almost_equal(poly.polyfit(x, x, [0, 1]), [0, 1])
+        # test fitting only even Polyendre polynomials
+        x = np.linspace(-1, 1)
+        y = f2(x)
+        coef1 = poly.polyfit(x, y, 4)
+        assert_almost_equal(poly.polyval(x, coef1), y)
+        coef2 = poly.polyfit(x, y, [0, 2, 4])
+        assert_almost_equal(poly.polyval(x, coef2), y)
+        assert_almost_equal(coef1, coef2)
+
+    def test_polytrim(self):
+        coef = [2, -1, 1, 0]
+
+        # Test exceptions
+        assert_raises(ValueError, poly.polytrim, coef, -1)
+
+        # Test results
+        assert_equal(poly.polytrim(coef), coef[:-1])
+        assert_equal(poly.polytrim(coef, 1), coef[:-3])
+        assert_equal(poly.polytrim(coef, 2), [0])
+
+    def test_polyline(self):
+        assert_equal(poly.polyline(3, 4), [3, 4])
+
+    def test_polyline_zero(self):
+        assert_equal(poly.polyline(3, 0), [3])
+
+    def test_fit_degenerate_domain(self):
+        p = poly.Polynomial.fit([1], [2], deg=0)
+        assert_equal(p.coef, [2.])
+        p = poly.Polynomial.fit([1, 1], [2, 2.1], deg=0)
+        assert_almost_equal(p.coef, [2.05])
+        with assert_warns(pu.RankWarning):
+            p = poly.Polynomial.fit([1, 1], [2, 2.1], deg=1)
+
+    def test_result_type(self):
+        w = np.array([-1, 1], dtype=np.float32)
+        p = np.polynomial.Polynomial(w, domain=w, window=w)
+        v = p(2)
+        assert_equal(v.dtype, np.float32)
+
+        arr = np.polydiv(1, np.float32(1))
+        assert_equal(arr[0].dtype, np.float64)
diff --git a/venv/lib/python3.12/site-packages/numpy/polynomial/tests/test_polyutils.py b/venv/lib/python3.12/site-packages/numpy/polynomial/tests/test_polyutils.py
new file mode 100644
index 00000000..e5143ed5
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/polynomial/tests/test_polyutils.py
@@ -0,0 +1,125 @@
+"""Tests for polyutils module.
+
+"""
+import numpy as np
+import numpy.polynomial.polyutils as pu
+from numpy.testing import (
+    assert_almost_equal, assert_raises, assert_equal, assert_,
+    )
+
+
+class TestMisc:
+
+    def test_trimseq(self):
+        tgt = [1]
+        for num_trailing_zeros in range(5):
+            res = pu.trimseq([1] + [0] * num_trailing_zeros)
+            assert_equal(res, tgt)
+
+    def test_trimseq_empty_input(self):
+        for empty_seq in [[], np.array([], dtype=np.int32)]:
+            assert_equal(pu.trimseq(empty_seq), empty_seq)
+
+    def test_as_series(self):
+        # check exceptions
+        assert_raises(ValueError, pu.as_series, [[]])
+        assert_raises(ValueError, pu.as_series, [[[1, 2]]])
+        assert_raises(ValueError, pu.as_series, [[1], ['a']])
+        # check common types
+        types = ['i', 'd', 'O']
+        for i in range(len(types)):
+            for j in range(i):
+                ci = np.ones(1, types[i])
+                cj = np.ones(1, types[j])
+                [resi, resj] = pu.as_series([ci, cj])
+                assert_(resi.dtype.char == resj.dtype.char)
+                assert_(resj.dtype.char == types[i])
+
+    def test_trimcoef(self):
+        coef = [2, -1, 1, 0]
+        # Test exceptions
+        assert_raises(ValueError, pu.trimcoef, coef, -1)
+        # Test results
+        assert_equal(pu.trimcoef(coef), coef[:-1])
+        assert_equal(pu.trimcoef(coef, 1), coef[:-3])
+        assert_equal(pu.trimcoef(coef, 2), [0])
+
+    def test_vander_nd_exception(self):
+        # n_dims != len(points)
+        assert_raises(ValueError, pu._vander_nd, (), (1, 2, 3), [90])
+        # n_dims != len(degrees)
+        assert_raises(ValueError, pu._vander_nd, (), (), [90.65])
+        # n_dims == 0
+        assert_raises(ValueError, pu._vander_nd, (), (), [])
+
+    def test_div_zerodiv(self):
+        # c2[-1] == 0
+        assert_raises(ZeroDivisionError, pu._div, pu._div, (1, 2, 3), [0])
+
+    def test_pow_too_large(self):
+        # power > maxpower
+        assert_raises(ValueError, pu._pow, (), [1, 2, 3], 5, 4)
+
+class TestDomain:
+
+    def test_getdomain(self):
+        # test for real values
+        x = [1, 10, 3, -1]
+        tgt = [-1, 10]
+        res = pu.getdomain(x)
+        assert_almost_equal(res, tgt)
+
+        # test for complex values
+        x = [1 + 1j, 1 - 1j, 0, 2]
+        tgt = [-1j, 2 + 1j]
+        res = pu.getdomain(x)
+        assert_almost_equal(res, tgt)
+
+    def test_mapdomain(self):
+        # test for real values
+        dom1 = [0, 4]
+        dom2 = [1, 3]
+        tgt = dom2
+        res = pu.mapdomain(dom1, dom1, dom2)
+        assert_almost_equal(res, tgt)
+
+        # test for complex values
+        dom1 = [0 - 1j, 2 + 1j]
+        dom2 = [-2, 2]
+        tgt = dom2
+        x = dom1
+        res = pu.mapdomain(x, dom1, dom2)
+        assert_almost_equal(res, tgt)
+
+        # test for multidimensional arrays
+        dom1 = [0, 4]
+        dom2 = [1, 3]
+        tgt = np.array([dom2, dom2])
+        x = np.array([dom1, dom1])
+        res = pu.mapdomain(x, dom1, dom2)
+        assert_almost_equal(res, tgt)
+
+        # test that subtypes are preserved.
+        class MyNDArray(np.ndarray):
+            pass
+
+        dom1 = [0, 4]
+        dom2 = [1, 3]
+        x = np.array([dom1, dom1]).view(MyNDArray)
+        res = pu.mapdomain(x, dom1, dom2)
+        assert_(isinstance(res, MyNDArray))
+
+    def test_mapparms(self):
+        # test for real values
+        dom1 = [0, 4]
+        dom2 = [1, 3]
+        tgt = [1, .5]
+        res = pu. mapparms(dom1, dom2)
+        assert_almost_equal(res, tgt)
+
+        # test for complex values
+        dom1 = [0 - 1j, 2 + 1j]
+        dom2 = [-2, 2]
+        tgt = [-1 + 1j, 1 - 1j]
+        res = pu.mapparms(dom1, dom2)
+        assert_almost_equal(res, tgt)
diff --git a/venv/lib/python3.12/site-packages/numpy/polynomial/tests/test_printing.py b/venv/lib/python3.12/site-packages/numpy/polynomial/tests/test_printing.py
new file mode 100644
index 00000000..95dec549
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/polynomial/tests/test_printing.py
@@ -0,0 +1,552 @@
+from math import nan, inf
+import pytest
+from numpy._core import array, arange, printoptions
+import numpy.polynomial as poly
+from numpy.testing import assert_equal, assert_
+
+# For testing polynomial printing with object arrays
+from fractions import Fraction
+from decimal import Decimal
+
+
+class TestStrUnicodeSuperSubscripts:
+
+    @pytest.fixture(scope='class', autouse=True)
+    def use_unicode(self):
+        poly.set_default_printstyle('unicode')
+
+    @pytest.mark.parametrize(('inp', 'tgt'), (
+        ([1, 2, 3], "1.0 + 2.0·x + 3.0·x²"),
+        ([-1, 0, 3, -1], "-1.0 + 0.0·x + 3.0·x² - 1.0·x³"),
+        (arange(12), ("0.0 + 1.0·x + 2.0·x² + 3.0·x³ + 4.0·x⁴ + 5.0·x⁵ + "
+                      "6.0·x⁶ + 7.0·x⁷ +\n8.0·x⁸ + 9.0·x⁹ + 10.0·x¹⁰ + "
+                      "11.0·x¹¹")),
+    ))
+    def test_polynomial_str(self, inp, tgt):
+        p = poly.Polynomial(inp)
+        res = str(p)
+        assert_equal(res, tgt)
+
+    @pytest.mark.parametrize(('inp', 'tgt'), (
+        ([1, 2, 3], "1.0 + 2.0·T₁(x) + 3.0·T₂(x)"),
+        ([-1, 0, 3, -1], "-1.0 + 0.0·T₁(x) + 3.0·T₂(x) - 1.0·T₃(x)"),
+        (arange(12), ("0.0 + 1.0·T₁(x) + 2.0·T₂(x) + 3.0·T₃(x) + 4.0·T₄(x) + "
+                      "5.0·T₅(x) +\n6.0·T₆(x) + 7.0·T₇(x) + 8.0·T₈(x) + "
+                      "9.0·T₉(x) + 10.0·T₁₀(x) + 11.0·T₁₁(x)")),
+    ))
+    def test_chebyshev_str(self, inp, tgt):
+        res = str(poly.Chebyshev(inp))
+        assert_equal(res, tgt)
+
+    @pytest.mark.parametrize(('inp', 'tgt'), (
+        ([1, 2, 3], "1.0 + 2.0·P₁(x) + 3.0·P₂(x)"),
+        ([-1, 0, 3, -1], "-1.0 + 0.0·P₁(x) + 3.0·P₂(x) - 1.0·P₃(x)"),
+        (arange(12), ("0.0 + 1.0·P₁(x) + 2.0·P₂(x) + 3.0·P₃(x) + 4.0·P₄(x) + "
+                      "5.0·P₅(x) +\n6.0·P₆(x) + 7.0·P₇(x) + 8.0·P₈(x) + "
+                      "9.0·P₉(x) + 10.0·P₁₀(x) + 11.0·P₁₁(x)")),
+    ))
+    def test_legendre_str(self, inp, tgt):
+        res = str(poly.Legendre(inp))
+        assert_equal(res, tgt)
+
+    @pytest.mark.parametrize(('inp', 'tgt'), (
+        ([1, 2, 3], "1.0 + 2.0·H₁(x) + 3.0·H₂(x)"),
+        ([-1, 0, 3, -1], "-1.0 + 0.0·H₁(x) + 3.0·H₂(x) - 1.0·H₃(x)"),
+        (arange(12), ("0.0 + 1.0·H₁(x) + 2.0·H₂(x) + 3.0·H₃(x) + 4.0·H₄(x) + "
+                      "5.0·H₅(x) +\n6.0·H₆(x) + 7.0·H₇(x) + 8.0·H₈(x) + "
+                      "9.0·H₉(x) + 10.0·H₁₀(x) + 11.0·H₁₁(x)")),
+    ))
+    def test_hermite_str(self, inp, tgt):
+        res = str(poly.Hermite(inp))
+        assert_equal(res, tgt)
+
+    @pytest.mark.parametrize(('inp', 'tgt'), (
+        ([1, 2, 3], "1.0 + 2.0·He₁(x) + 3.0·He₂(x)"),
+        ([-1, 0, 3, -1], "-1.0 + 0.0·He₁(x) + 3.0·He₂(x) - 1.0·He₃(x)"),
+        (arange(12), ("0.0 + 1.0·He₁(x) + 2.0·He₂(x) + 3.0·He₃(x) + "
+                      "4.0·He₄(x) + 5.0·He₅(x) +\n6.0·He₆(x) + 7.0·He₇(x) + "
+                      "8.0·He₈(x) + 9.0·He₉(x) + 10.0·He₁₀(x) +\n"
+                      "11.0·He₁₁(x)")),
+    ))
+    def test_hermiteE_str(self, inp, tgt):
+        res = str(poly.HermiteE(inp))
+        assert_equal(res, tgt)
+
+    @pytest.mark.parametrize(('inp', 'tgt'), (
+        ([1, 2, 3], "1.0 + 2.0·L₁(x) + 3.0·L₂(x)"),
+        ([-1, 0, 3, -1], "-1.0 + 0.0·L₁(x) + 3.0·L₂(x) - 1.0·L₃(x)"),
+        (arange(12), ("0.0 + 1.0·L₁(x) + 2.0·L₂(x) + 3.0·L₃(x) + 4.0·L₄(x) + "
+                      "5.0·L₅(x) +\n6.0·L₆(x) + 7.0·L₇(x) + 8.0·L₈(x) + "
+                      "9.0·L₉(x) + 10.0·L₁₀(x) + 11.0·L₁₁(x)")),
+    ))
+    def test_laguerre_str(self, inp, tgt):
+        res = str(poly.Laguerre(inp))
+        assert_equal(res, tgt)
+
+    def test_polynomial_str_domains(self):
+        res = str(poly.Polynomial([0, 1]))
+        tgt = '0.0 + 1.0·x'
+        assert_equal(res, tgt)
+
+        res = str(poly.Polynomial([0, 1], domain=[1, 2]))
+        tgt = '0.0 + 1.0·(-3.0 + 2.0x)'
+        assert_equal(res, tgt)
+
+class TestStrAscii:
+
+    @pytest.fixture(scope='class', autouse=True)
+    def use_ascii(self):
+        poly.set_default_printstyle('ascii')
+
+    @pytest.mark.parametrize(('inp', 'tgt'), (
+        ([1, 2, 3], "1.0 + 2.0 x + 3.0 x**2"),
+        ([-1, 0, 3, -1], "-1.0 + 0.0 x + 3.0 x**2 - 1.0 x**3"),
+        (arange(12), ("0.0 + 1.0 x + 2.0 x**2 + 3.0 x**3 + 4.0 x**4 + "
+                      "5.0 x**5 + 6.0 x**6 +\n7.0 x**7 + 8.0 x**8 + "
+                      "9.0 x**9 + 10.0 x**10 + 11.0 x**11")),
+    ))
+    def test_polynomial_str(self, inp, tgt):
+        res = str(poly.Polynomial(inp))
+        assert_equal(res, tgt)
+
+    @pytest.mark.parametrize(('inp', 'tgt'), (
+        ([1, 2, 3], "1.0 + 2.0 T_1(x) + 3.0 T_2(x)"),
+        ([-1, 0, 3, -1], "-1.0 + 0.0 T_1(x) + 3.0 T_2(x) - 1.0 T_3(x)"),
+        (arange(12), ("0.0 + 1.0 T_1(x) + 2.0 T_2(x) + 3.0 T_3(x) + "
+                      "4.0 T_4(x) + 5.0 T_5(x) +\n6.0 T_6(x) + 7.0 T_7(x) + "
+                      "8.0 T_8(x) + 9.0 T_9(x) + 10.0 T_10(x) +\n"
+                      "11.0 T_11(x)")),
+    ))
+    def test_chebyshev_str(self, inp, tgt):
+        res = str(poly.Chebyshev(inp))
+        assert_equal(res, tgt)
+
+    @pytest.mark.parametrize(('inp', 'tgt'), (
+        ([1, 2, 3], "1.0 + 2.0 P_1(x) + 3.0 P_2(x)"),
+        ([-1, 0, 3, -1], "-1.0 + 0.0 P_1(x) + 3.0 P_2(x) - 1.0 P_3(x)"),
+        (arange(12), ("0.0 + 1.0 P_1(x) + 2.0 P_2(x) + 3.0 P_3(x) + "
+                      "4.0 P_4(x) + 5.0 P_5(x) +\n6.0 P_6(x) + 7.0 P_7(x) + "
+                      "8.0 P_8(x) + 9.0 P_9(x) + 10.0 P_10(x) +\n"
+                      "11.0 P_11(x)")),
+    ))
+    def test_legendre_str(self, inp, tgt):
+        res = str(poly.Legendre(inp))
+        assert_equal(res, tgt)
+
+    @pytest.mark.parametrize(('inp', 'tgt'), (
+        ([1, 2, 3], "1.0 + 2.0 H_1(x) + 3.0 H_2(x)"),
+        ([-1, 0, 3, -1], "-1.0 + 0.0 H_1(x) + 3.0 H_2(x) - 1.0 H_3(x)"),
+        (arange(12), ("0.0 + 1.0 H_1(x) + 2.0 H_2(x) + 3.0 H_3(x) + "
+                      "4.0 H_4(x) + 5.0 H_5(x) +\n6.0 H_6(x) + 7.0 H_7(x) + "
+                      "8.0 H_8(x) + 9.0 H_9(x) + 10.0 H_10(x) +\n"
+                      "11.0 H_11(x)")),
+    ))
+    def test_hermite_str(self, inp, tgt):
+        res = str(poly.Hermite(inp))
+        assert_equal(res, tgt)
+
+    @pytest.mark.parametrize(('inp', 'tgt'), (
+        ([1, 2, 3], "1.0 + 2.0 He_1(x) + 3.0 He_2(x)"),
+        ([-1, 0, 3, -1], "-1.0 + 0.0 He_1(x) + 3.0 He_2(x) - 1.0 He_3(x)"),
+        (arange(12), ("0.0 + 1.0 He_1(x) + 2.0 He_2(x) + 3.0 He_3(x) + "
+                      "4.0 He_4(x) +\n5.0 He_5(x) + 6.0 He_6(x) + "
+                      "7.0 He_7(x) + 8.0 He_8(x) + 9.0 He_9(x) +\n"
+                      "10.0 He_10(x) + 11.0 He_11(x)")),
+    ))
+    def test_hermiteE_str(self, inp, tgt):
+        res = str(poly.HermiteE(inp))
+        assert_equal(res, tgt)
+
+    @pytest.mark.parametrize(('inp', 'tgt'), (
+        ([1, 2, 3], "1.0 + 2.0 L_1(x) + 3.0 L_2(x)"),
+        ([-1, 0, 3, -1], "-1.0 + 0.0 L_1(x) + 3.0 L_2(x) - 1.0 L_3(x)"),
+        (arange(12), ("0.0 + 1.0 L_1(x) + 2.0 L_2(x) + 3.0 L_3(x) + "
+                      "4.0 L_4(x) + 5.0 L_5(x) +\n6.0 L_6(x) + 7.0 L_7(x) + "
+                      "8.0 L_8(x) + 9.0 L_9(x) + 10.0 L_10(x) +\n"
+                      "11.0 L_11(x)")),
+    ))
+    def test_laguerre_str(self, inp, tgt):
+        res = str(poly.Laguerre(inp))
+        assert_equal(res, tgt)
+
+    def test_polynomial_str_domains(self):
+        res = str(poly.Polynomial([0, 1]))
+        tgt = '0.0 + 1.0 x'
+        assert_equal(res, tgt)
+
+        res = str(poly.Polynomial([0, 1], domain=[1, 2]))
+        tgt = '0.0 + 1.0 (-3.0 + 2.0x)'
+        assert_equal(res, tgt)
+
+class TestLinebreaking:
+
+    @pytest.fixture(scope='class', autouse=True)
+    def use_ascii(self):
+        poly.set_default_printstyle('ascii')
+
+    def test_single_line_one_less(self):
+        # With 'ascii' style, len(str(p)) is default linewidth - 1 (i.e. 74)
+        p = poly.Polynomial([12345678, 12345678, 12345678, 12345678, 123])
+        assert_equal(len(str(p)), 74)
+        assert_equal(str(p), (
+            '12345678.0 + 12345678.0 x + 12345678.0 x**2 + '
+            '12345678.0 x**3 + 123.0 x**4'
+        ))
+
+    def test_num_chars_is_linewidth(self):
+        # len(str(p)) == default linewidth == 75
+        p = poly.Polynomial([12345678, 12345678, 12345678, 12345678, 1234])
+        assert_equal(len(str(p)), 75)
+        assert_equal(str(p), (
+            '12345678.0 + 12345678.0 x + 12345678.0 x**2 + '
+            '12345678.0 x**3 +\n1234.0 x**4'
+        ))
+
+    def test_first_linebreak_multiline_one_less_than_linewidth(self):
+        # Multiline str where len(first_line) + len(next_term) == lw - 1 == 74
+        p = poly.Polynomial(
+                [12345678, 12345678, 12345678, 12345678, 1, 12345678]
+            )
+        assert_equal(len(str(p).split('\n')[0]), 74)
+        assert_equal(str(p), (
+            '12345678.0 + 12345678.0 x + 12345678.0 x**2 + '
+            '12345678.0 x**3 + 1.0 x**4 +\n12345678.0 x**5'
+        ))
+
+    def test_first_linebreak_multiline_on_linewidth(self):
+        # First line is one character longer than previous test
+        p = poly.Polynomial(
+                [12345678, 12345678, 12345678, 12345678.12, 1, 12345678]
+            )
+        assert_equal(str(p), (
+            '12345678.0 + 12345678.0 x + 12345678.0 x**2 + '
+            '12345678.12 x**3 +\n1.0 x**4 + 12345678.0 x**5'
+        ))
+
+    @pytest.mark.parametrize(('lw', 'tgt'), (
+        (75, ('0.0 + 10.0 x + 200.0 x**2 + 3000.0 x**3 + 40000.0 x**4 + '
+              '500000.0 x**5 +\n600000.0 x**6 + 70000.0 x**7 + 8000.0 x**8 + '
+              '900.0 x**9')),
+        (45, ('0.0 + 10.0 x + 200.0 x**2 + 3000.0 x**3 +\n40000.0 x**4 + '
+              '500000.0 x**5 +\n600000.0 x**6 + 70000.0 x**7 + 8000.0 x**8 +\n'
+              '900.0 x**9')),
+        (132, ('0.0 + 10.0 x + 200.0 x**2 + 3000.0 x**3 + 40000.0 x**4 + '
+               '500000.0 x**5 + 600000.0 x**6 + 70000.0 x**7 + 8000.0 x**8 + '
+               '900.0 x**9')),
+    ))
+    def test_linewidth_printoption(self, lw, tgt):
+        p = poly.Polynomial(
+            [0, 10, 200, 3000, 40000, 500000, 600000, 70000, 8000, 900]
+        )
+        with printoptions(linewidth=lw):
+            assert_equal(str(p), tgt)
+            for line in str(p).split('\n'):
+                assert_(len(line) < lw)
+
+
+def test_set_default_printoptions():
+    p = poly.Polynomial([1, 2, 3])
+    c = poly.Chebyshev([1, 2, 3])
+    poly.set_default_printstyle('ascii')
+    assert_equal(str(p), "1.0 + 2.0 x + 3.0 x**2")
+    assert_equal(str(c), "1.0 + 2.0 T_1(x) + 3.0 T_2(x)")
+    poly.set_default_printstyle('unicode')
+    assert_equal(str(p), "1.0 + 2.0·x + 3.0·x²")
+    assert_equal(str(c), "1.0 + 2.0·T₁(x) + 3.0·T₂(x)")
+    with pytest.raises(ValueError):
+        poly.set_default_printstyle('invalid_input')
+
+
+def test_complex_coefficients():
+    """Test both numpy and built-in complex."""
+    coefs = [0+1j, 1+1j, -2+2j, 3+0j]
+    # numpy complex
+    p1 = poly.Polynomial(coefs)
+    # Python complex
+    p2 = poly.Polynomial(array(coefs, dtype=object))
+    poly.set_default_printstyle('unicode')
+    assert_equal(str(p1), "1j + (1+1j)·x - (2-2j)·x² + (3+0j)·x³")
+    assert_equal(str(p2), "1j + (1+1j)·x + (-2+2j)·x² + (3+0j)·x³")
+    poly.set_default_printstyle('ascii')
+    assert_equal(str(p1), "1j + (1+1j) x - (2-2j) x**2 + (3+0j) x**3")
+    assert_equal(str(p2), "1j + (1+1j) x + (-2+2j) x**2 + (3+0j) x**3")
+
+
+@pytest.mark.parametrize(('coefs', 'tgt'), (
+    (array([Fraction(1, 2), Fraction(3, 4)], dtype=object), (
+        "1/2 + 3/4·x"
+    )),
+    (array([1, 2, Fraction(5, 7)], dtype=object), (
+        "1 + 2·x + 5/7·x²"
+    )),
+    (array([Decimal('1.00'), Decimal('2.2'), 3], dtype=object), (
+        "1.00 + 2.2·x + 3·x²"
+    )),
+))
+def test_numeric_object_coefficients(coefs, tgt):
+    p = poly.Polynomial(coefs)
+    poly.set_default_printstyle('unicode')
+    assert_equal(str(p), tgt)
+
+
+@pytest.mark.parametrize(('coefs', 'tgt'), (
+    (array([1, 2, 'f'], dtype=object), '1 + 2·x + f·x²'),
+    (array([1, 2, [3, 4]], dtype=object), '1 + 2·x + [3, 4]·x²'),
+))
+def test_nonnumeric_object_coefficients(coefs, tgt):
+    """
+    Test coef fallback for object arrays of non-numeric coefficients.
+    """
+    p = poly.Polynomial(coefs)
+    poly.set_default_printstyle('unicode')
+    assert_equal(str(p), tgt)
+
+
+class TestFormat:
+    def test_format_unicode(self):
+        poly.set_default_printstyle('ascii')
+        p = poly.Polynomial([1, 2, 0, -1])
+        assert_equal(format(p, 'unicode'), "1.0 + 2.0·x + 0.0·x² - 1.0·x³")
+
+    def test_format_ascii(self):
+        poly.set_default_printstyle('unicode')
+        p = poly.Polynomial([1, 2, 0, -1])
+        assert_equal(
+            format(p, 'ascii'), "1.0 + 2.0 x + 0.0 x**2 - 1.0 x**3"
+        )
+
+    def test_empty_formatstr(self):
+        poly.set_default_printstyle('ascii')
+        p = poly.Polynomial([1, 2, 3])
+        assert_equal(format(p), "1.0 + 2.0 x + 3.0 x**2")
+        assert_equal(f"{p}", "1.0 + 2.0 x + 3.0 x**2")
+
+    def test_bad_formatstr(self):
+        p = poly.Polynomial([1, 2, 0, -1])
+        with pytest.raises(ValueError):
+            format(p, '.2f')
+
+
+@pytest.mark.parametrize(('poly', 'tgt'), (
+    (poly.Polynomial, '1.0 + 2.0·z + 3.0·z²'),
+    (poly.Chebyshev, '1.0 + 2.0·T₁(z) + 3.0·T₂(z)'),
+    (poly.Hermite, '1.0 + 2.0·H₁(z) + 3.0·H₂(z)'),
+    (poly.HermiteE, '1.0 + 2.0·He₁(z) + 3.0·He₂(z)'),
+    (poly.Laguerre, '1.0 + 2.0·L₁(z) + 3.0·L₂(z)'),
+    (poly.Legendre, '1.0 + 2.0·P₁(z) + 3.0·P₂(z)'),
+))
+def test_symbol(poly, tgt):
+    p = poly([1, 2, 3], symbol='z')
+    assert_equal(f"{p:unicode}", tgt)
+
+
+class TestRepr:
+    def test_polynomial_repr(self):
+        res = repr(poly.Polynomial([0, 1]))
+        tgt = (
+            "Polynomial([0., 1.], domain=[-1.,  1.], window=[-1.,  1.], "
+            "symbol='x')"
+        )
+        assert_equal(res, tgt)
+
+    def test_chebyshev_repr(self):
+        res = repr(poly.Chebyshev([0, 1]))
+        tgt = (
+            "Chebyshev([0., 1.], domain=[-1.,  1.], window=[-1.,  1.], "
+            "symbol='x')"
+        )
+        assert_equal(res, tgt)
+
+    def test_legendre_repr(self):
+        res = repr(poly.Legendre([0, 1]))
+        tgt = (
+            "Legendre([0., 1.], domain=[-1.,  1.], window=[-1.,  1.], "
+            "symbol='x')"
+        )
+        assert_equal(res, tgt)
+
+    def test_hermite_repr(self):
+        res = repr(poly.Hermite([0, 1]))
+        tgt = (
+            "Hermite([0., 1.], domain=[-1.,  1.], window=[-1.,  1.], "
+            "symbol='x')"
+        )
+        assert_equal(res, tgt)
+
+    def test_hermiteE_repr(self):
+        res = repr(poly.HermiteE([0, 1]))
+        tgt = (
+            "HermiteE([0., 1.], domain=[-1.,  1.], window=[-1.,  1.], "
+            "symbol='x')"
+        )
+        assert_equal(res, tgt)
+
+    def test_laguerre_repr(self):
+        res = repr(poly.Laguerre([0, 1]))
+        tgt = (
+            "Laguerre([0., 1.], domain=[0., 1.], window=[0., 1.], "
+            "symbol='x')"
+        )
+        assert_equal(res, tgt)
+
+
+class TestLatexRepr:
+    """Test the latex repr used by Jupyter"""
+
+    @staticmethod
+    def as_latex(obj):
+        # right now we ignore the formatting of scalars in our tests, since
+        # it makes them too verbose. Ideally, the formatting of scalars will
+        # be fixed such that tests below continue to pass
+        obj._repr_latex_scalar = lambda x, parens=False: str(x)
+        try:
+            return obj._repr_latex_()
+        finally:
+            del obj._repr_latex_scalar
+
+    def test_simple_polynomial(self):
+        # default input
+        p = poly.Polynomial([1, 2, 3])
+        assert_equal(self.as_latex(p),
+            r'$x \mapsto 1.0 + 2.0\,x + 3.0\,x^{2}$')
+
+        # translated input
+        p = poly.Polynomial([1, 2, 3], domain=[-2, 0])
+        assert_equal(self.as_latex(p),
+            r'$x \mapsto 1.0 + 2.0\,\left(1.0 + x\right) + 3.0\,\left(1.0 + x\right)^{2}$')
+
+        # scaled input
+        p = poly.Polynomial([1, 2, 3], domain=[-0.5, 0.5])
+        assert_equal(self.as_latex(p),
+            r'$x \mapsto 1.0 + 2.0\,\left(2.0x\right) + 3.0\,\left(2.0x\right)^{2}$')
+
+        # affine input
+        p = poly.Polynomial([1, 2, 3], domain=[-1, 0])
+        assert_equal(self.as_latex(p),
+            r'$x \mapsto 1.0 + 2.0\,\left(1.0 + 2.0x\right) + 3.0\,\left(1.0 + 2.0x\right)^{2}$')
+
+    def test_basis_func(self):
+        p = poly.Chebyshev([1, 2, 3])
+        assert_equal(self.as_latex(p),
+            r'$x \mapsto 1.0\,{T}_{0}(x) + 2.0\,{T}_{1}(x) + 3.0\,{T}_{2}(x)$')
+        # affine input - check no surplus parens are added
+        p = poly.Chebyshev([1, 2, 3], domain=[-1, 0])
+        assert_equal(self.as_latex(p),
+            r'$x \mapsto 1.0\,{T}_{0}(1.0 + 2.0x) + 2.0\,{T}_{1}(1.0 + 2.0x) + 3.0\,{T}_{2}(1.0 + 2.0x)$')
+
+    def test_multichar_basis_func(self):
+        p = poly.HermiteE([1, 2, 3])
+        assert_equal(self.as_latex(p),
+            r'$x \mapsto 1.0\,{He}_{0}(x) + 2.0\,{He}_{1}(x) + 3.0\,{He}_{2}(x)$')
+
+    def test_symbol_basic(self):
+        # default input
+        p = poly.Polynomial([1, 2, 3], symbol='z')
+        assert_equal(self.as_latex(p),
+            r'$z \mapsto 1.0 + 2.0\,z + 3.0\,z^{2}$')
+
+        # translated input
+        p = poly.Polynomial([1, 2, 3], domain=[-2, 0], symbol='z')
+        assert_equal(
+            self.as_latex(p),
+            (
+                r'$z \mapsto 1.0 + 2.0\,\left(1.0 + z\right) + 3.0\,'
+                r'\left(1.0 + z\right)^{2}$'
+            ),
+        )
+
+        # scaled input
+        p = poly.Polynomial([1, 2, 3], domain=[-0.5, 0.5], symbol='z')
+        assert_equal(
+            self.as_latex(p),
+            (
+                r'$z \mapsto 1.0 + 2.0\,\left(2.0z\right) + 3.0\,'
+                r'\left(2.0z\right)^{2}$'
+            ),
+        )
+
+        # affine input
+        p = poly.Polynomial([1, 2, 3], domain=[-1, 0], symbol='z')
+        assert_equal(
+            self.as_latex(p),
+            (
+                r'$z \mapsto 1.0 + 2.0\,\left(1.0 + 2.0z\right) + 3.0\,'
+                r'\left(1.0 + 2.0z\right)^{2}$'
+            ),
+        )
+
+    def test_numeric_object_coefficients(self):
+        coefs = array([Fraction(1, 2), Fraction(1)])
+        p = poly.Polynomial(coefs)
+        assert_equal(self.as_latex(p), '$x \\mapsto 1/2 + 1\\,x$')
+
+SWITCH_TO_EXP = (
+    '1.0 + (1.0e-01) x + (1.0e-02) x**2',
+    '1.2 + (1.2e-01) x + (1.2e-02) x**2',
+    '1.23 + 0.12 x + (1.23e-02) x**2 + (1.23e-03) x**3',
+    '1.235 + 0.123 x + (1.235e-02) x**2 + (1.235e-03) x**3',
+    '1.2346 + 0.1235 x + 0.0123 x**2 + (1.2346e-03) x**3 + (1.2346e-04) x**4',
+    '1.23457 + 0.12346 x + 0.01235 x**2 + (1.23457e-03) x**3 + '
+    '(1.23457e-04) x**4',
+    '1.234568 + 0.123457 x + 0.012346 x**2 + 0.001235 x**3 + '
+    '(1.234568e-04) x**4 + (1.234568e-05) x**5',
+    '1.2345679 + 0.1234568 x + 0.0123457 x**2 + 0.0012346 x**3 + '
+    '(1.2345679e-04) x**4 + (1.2345679e-05) x**5')
+
+class TestPrintOptions:
+    """
+    Test the output is properly configured via printoptions.
+    The exponential notation is enabled automatically when the values 
+    are too small or too large.
+    """
+
+    @pytest.fixture(scope='class', autouse=True)
+    def use_ascii(self):
+        poly.set_default_printstyle('ascii')
+
+    def test_str(self):
+        p = poly.Polynomial([1/2, 1/7, 1/7*10**8, 1/7*10**9])
+        assert_equal(str(p), '0.5 + 0.14285714 x + 14285714.28571429 x**2 '
+                             '+ (1.42857143e+08) x**3')
+
+        with printoptions(precision=3):
+            assert_equal(str(p), '0.5 + 0.143 x + 14285714.286 x**2 '
+                                 '+ (1.429e+08) x**3')
+
+    def test_latex(self):
+        p = poly.Polynomial([1/2, 1/7, 1/7*10**8, 1/7*10**9])
+        assert_equal(p._repr_latex_(),
+            r'$x \mapsto \text{0.5} + \text{0.14285714}\,x + '
+            r'\text{14285714.28571429}\,x^{2} + '
+            r'\text{(1.42857143e+08)}\,x^{3}$')
+        
+        with printoptions(precision=3):
+            assert_equal(p._repr_latex_(),
+                r'$x \mapsto \text{0.5} + \text{0.143}\,x + '
+                r'\text{14285714.286}\,x^{2} + \text{(1.429e+08)}\,x^{3}$')
+
+    def test_fixed(self):
+        p = poly.Polynomial([1/2])
+        assert_equal(str(p), '0.5')
+        
+        with printoptions(floatmode='fixed'):
+            assert_equal(str(p), '0.50000000')
+        
+        with printoptions(floatmode='fixed', precision=4):
+            assert_equal(str(p), '0.5000')
+
+    def test_switch_to_exp(self):
+        for i, s in enumerate(SWITCH_TO_EXP):
+            with printoptions(precision=i):
+                p = poly.Polynomial([1.23456789*10**-i 
+                                     for i in range(i//2+3)])
+                assert str(p).replace('\n', ' ') == s 
+    
+    def test_non_finite(self):
+        p = poly.Polynomial([nan, inf])
+        assert str(p) == 'nan + inf x'
+        assert p._repr_latex_() == r'$x \mapsto \text{nan} + \text{inf}\,x$'
+        with printoptions(nanstr='NAN', infstr='INF'):
+            assert str(p) == 'NAN + INF x'
+            assert p._repr_latex_() == \
+                r'$x \mapsto \text{NAN} + \text{INF}\,x$'
diff --git a/venv/lib/python3.12/site-packages/numpy/polynomial/tests/test_symbol.py b/venv/lib/python3.12/site-packages/numpy/polynomial/tests/test_symbol.py
new file mode 100644
index 00000000..f985533f
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/polynomial/tests/test_symbol.py
@@ -0,0 +1,216 @@
+"""
+Tests related to the ``symbol`` attribute of the ABCPolyBase class.
+"""
+
+import pytest
+import numpy.polynomial as poly
+from numpy._core import array
+from numpy.testing import assert_equal, assert_raises, assert_
+
+
+class TestInit:
+    """
+    Test polynomial creation with symbol kwarg.
+    """
+    c = [1, 2, 3]
+
+    def test_default_symbol(self):
+        p = poly.Polynomial(self.c)
+        assert_equal(p.symbol, 'x')
+
+    @pytest.mark.parametrize(('bad_input', 'exception'), (
+        ('', ValueError),
+        ('3', ValueError),
+        (None, TypeError),
+        (1, TypeError),
+    ))
+    def test_symbol_bad_input(self, bad_input, exception):
+        with pytest.raises(exception):
+            p = poly.Polynomial(self.c, symbol=bad_input)
+
+    @pytest.mark.parametrize('symbol', (
+        'x',
+        'x_1',
+        'A',
+        'xyz',
+        'β',
+    ))
+    def test_valid_symbols(self, symbol):
+        """
+        Values for symbol that should pass input validation.
+        """
+        p = poly.Polynomial(self.c, symbol=symbol)
+        assert_equal(p.symbol, symbol)
+
+    def test_property(self):
+        """
+        'symbol' attribute is read only.
+        """
+        p = poly.Polynomial(self.c, symbol='x')
+        with pytest.raises(AttributeError):
+            p.symbol = 'z'
+
+    def test_change_symbol(self):
+        p = poly.Polynomial(self.c, symbol='y')
+        # Create new polynomial from p with different symbol
+        pt = poly.Polynomial(p.coef, symbol='t')
+        assert_equal(pt.symbol, 't')
+
+
+class TestUnaryOperators:
+    p = poly.Polynomial([1, 2, 3], symbol='z')
+
+    def test_neg(self):
+        n = -self.p
+        assert_equal(n.symbol, 'z')
+
+    def test_scalarmul(self):
+        out = self.p * 10
+        assert_equal(out.symbol, 'z')
+
+    def test_rscalarmul(self):
+        out = 10 * self.p
+        assert_equal(out.symbol, 'z')
+
+    def test_pow(self):
+        out = self.p ** 3
+        assert_equal(out.symbol, 'z')
+
+
+@pytest.mark.parametrize(
+    'rhs',
+    (
+        poly.Polynomial([4, 5, 6], symbol='z'),
+        array([4, 5, 6]),
+    ),
+)
+class TestBinaryOperatorsSameSymbol:
+    """
+    Ensure symbol is preserved for numeric operations on polynomials with
+    the same symbol
+    """
+    p = poly.Polynomial([1, 2, 3], symbol='z')
+
+    def test_add(self, rhs):
+        out = self.p + rhs
+        assert_equal(out.symbol, 'z')
+
+    def test_sub(self, rhs):
+        out = self.p - rhs
+        assert_equal(out.symbol, 'z')
+
+    def test_polymul(self, rhs):
+        out = self.p * rhs
+        assert_equal(out.symbol, 'z')
+
+    def test_divmod(self, rhs):
+        for out in divmod(self.p, rhs):
+            assert_equal(out.symbol, 'z')
+
+    def test_radd(self, rhs):
+        out = rhs + self.p
+        assert_equal(out.symbol, 'z')
+
+    def test_rsub(self, rhs):
+        out = rhs - self.p
+        assert_equal(out.symbol, 'z')
+
+    def test_rmul(self, rhs):
+        out = rhs * self.p
+        assert_equal(out.symbol, 'z')
+
+    def test_rdivmod(self, rhs):
+        for out in divmod(rhs, self.p):
+            assert_equal(out.symbol, 'z')
+
+
+class TestBinaryOperatorsDifferentSymbol:
+    p = poly.Polynomial([1, 2, 3], symbol='x')
+    other = poly.Polynomial([4, 5, 6], symbol='y')
+    ops = (p.__add__, p.__sub__, p.__mul__, p.__floordiv__, p.__mod__)
+
+    @pytest.mark.parametrize('f', ops)
+    def test_binops_fails(self, f):
+        assert_raises(ValueError, f, self.other)
+
+
+class TestEquality:
+    p = poly.Polynomial([1, 2, 3], symbol='x')
+
+    def test_eq(self):
+        other = poly.Polynomial([1, 2, 3], symbol='x')
+        assert_(self.p == other)
+
+    def test_neq(self):
+        other = poly.Polynomial([1, 2, 3], symbol='y')
+        assert_(not self.p == other)
+
+
+class TestExtraMethods:
+    """
+    Test other methods for manipulating/creating polynomial objects.
+    """
+    p = poly.Polynomial([1, 2, 3, 0], symbol='z')
+
+    def test_copy(self):
+        other = self.p.copy()
+        assert_equal(other.symbol, 'z')
+
+    def test_trim(self):
+        other = self.p.trim()
+        assert_equal(other.symbol, 'z')
+
+    def test_truncate(self):
+        other = self.p.truncate(2)
+        assert_equal(other.symbol, 'z')
+
+    @pytest.mark.parametrize('kwarg', (
+        {'domain': [-10, 10]},
+        {'window': [-10, 10]},
+        {'kind': poly.Chebyshev},
+    ))
+    def test_convert(self, kwarg):
+        other = self.p.convert(**kwarg)
+        assert_equal(other.symbol, 'z')
+
+    def test_integ(self):
+        other = self.p.integ()
+        assert_equal(other.symbol, 'z')
+
+    def test_deriv(self):
+        other = self.p.deriv()
+        assert_equal(other.symbol, 'z')
+
+
+def test_composition():
+    p = poly.Polynomial([3, 2, 1], symbol="t")
+    q = poly.Polynomial([5, 1, 0, -1], symbol="λ_1")
+    r = p(q)
+    assert r.symbol == "λ_1"
+
+
+#
+# Class methods that result in new polynomial class instances
+#
+
+
+def test_fit():
+    x, y = (range(10),)*2
+    p = poly.Polynomial.fit(x, y, deg=1, symbol='z')
+    assert_equal(p.symbol, 'z')
+
+
+def test_froomroots():
+    roots = [-2, 2]
+    p = poly.Polynomial.fromroots(roots, symbol='z')
+    assert_equal(p.symbol, 'z')
+
+
+def test_identity():
+    p = poly.Polynomial.identity(domain=[-1, 1], window=[5, 20], symbol='z')
+    assert_equal(p.symbol, 'z')
+
+
+def test_basis():
+    p = poly.Polynomial.basis(3, symbol='z')
+    assert_equal(p.symbol, 'z')
diff --git a/venv/lib/python3.12/site-packages/numpy/py.typed b/venv/lib/python3.12/site-packages/numpy/py.typed
new file mode 100644
index 00000000..e69de29b
diff --git a/venv/lib/python3.12/site-packages/numpy/random/LICENSE.md b/venv/lib/python3.12/site-packages/numpy/random/LICENSE.md
new file mode 100644
index 00000000..a6cf1b17
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/random/LICENSE.md
@@ -0,0 +1,71 @@
+**This software is dual-licensed under the The University of Illinois/NCSA
+Open Source License (NCSA) and The 3-Clause BSD License**
+
+# NCSA Open Source License
+**Copyright (c) 2019 Kevin Sheppard. All rights reserved.**
+
+Developed by: Kevin Sheppard (,
+)
+[http://www.kevinsheppard.com](http://www.kevinsheppard.com)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal with
+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:
+
+Redistributions of source code must retain the above copyright notice, this
+list of conditions and the following disclaimers.
+
+Redistributions in binary form must reproduce the above copyright notice, this
+list of conditions and the following disclaimers in the documentation and/or
+other materials provided with the distribution.
+
+Neither the names of Kevin Sheppard, nor the names of any contributors may be
+used to endorse or promote products derived from this Software without specific
+prior written permission.
+
+**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
+CONTRIBUTORS 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 WITH
+THE SOFTWARE.**
+
+
+# 3-Clause BSD License
+**Copyright (c) 2019 Kevin Sheppard. 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.**
+
+# Components
+
+Many parts of this module have been derived from original sources, 
+often the algorithm's designer. Component licenses are located with 
+the component code.
diff --git a/venv/lib/python3.12/site-packages/numpy/random/__init__.pxd b/venv/lib/python3.12/site-packages/numpy/random/__init__.pxd
new file mode 100644
index 00000000..1f905729
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/random/__init__.pxd
@@ -0,0 +1,14 @@
+cimport numpy as np
+from libc.stdint cimport uint32_t, uint64_t
+
+cdef extern from "numpy/random/bitgen.h":
+    struct bitgen:
+        void *state
+        uint64_t (*next_uint64)(void *st) nogil
+        uint32_t (*next_uint32)(void *st) nogil
+        double (*next_double)(void *st) nogil
+        uint64_t (*next_raw)(void *st) nogil
+
+    ctypedef bitgen bitgen_t
+
+from numpy.random.bit_generator cimport BitGenerator, SeedSequence
diff --git a/venv/lib/python3.12/site-packages/numpy/random/__init__.py b/venv/lib/python3.12/site-packages/numpy/random/__init__.py
new file mode 100644
index 00000000..2e8f99fe
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/random/__init__.py
@@ -0,0 +1,215 @@
+"""
+========================
+Random Number Generation
+========================
+
+Use ``default_rng()`` to create a `Generator` and call its methods.
+
+=============== =========================================================
+Generator
+--------------- ---------------------------------------------------------
+Generator       Class implementing all of the random number distributions
+default_rng     Default constructor for ``Generator``
+=============== =========================================================
+
+============================================= ===
+BitGenerator Streams that work with Generator
+--------------------------------------------- ---
+MT19937
+PCG64
+PCG64DXSM
+Philox
+SFC64
+============================================= ===
+
+============================================= ===
+Getting entropy to initialize a BitGenerator
+--------------------------------------------- ---
+SeedSequence
+============================================= ===
+
+
+Legacy
+------
+
+For backwards compatibility with previous versions of numpy before 1.17, the
+various aliases to the global `RandomState` methods are left alone and do not
+use the new `Generator` API.
+
+==================== =========================================================
+Utility functions
+-------------------- ---------------------------------------------------------
+random               Uniformly distributed floats over ``[0, 1)``
+bytes                Uniformly distributed random bytes.
+permutation          Randomly permute a sequence / generate a random sequence.
+shuffle              Randomly permute a sequence in place.
+choice               Random sample from 1-D array.
+==================== =========================================================
+
+==================== =========================================================
+Compatibility
+functions - removed
+in the new API
+-------------------- ---------------------------------------------------------
+rand                 Uniformly distributed values.
+randn                Normally distributed values.
+ranf                 Uniformly distributed floating point numbers.
+random_integers      Uniformly distributed integers in a given range.
+                     (deprecated, use ``integers(..., closed=True)`` instead)
+random_sample        Alias for `random_sample`
+randint              Uniformly distributed integers in a given range
+seed                 Seed the legacy random number generator.
+==================== =========================================================
+
+==================== =========================================================
+Univariate
+distributions
+-------------------- ---------------------------------------------------------
+beta                 Beta distribution over ``[0, 1]``.
+binomial             Binomial distribution.
+chisquare            :math:`\\chi^2` distribution.
+exponential          Exponential distribution.
+f                    F (Fisher-Snedecor) distribution.
+gamma                Gamma distribution.
+geometric            Geometric distribution.
+gumbel               Gumbel distribution.
+hypergeometric       Hypergeometric distribution.
+laplace              Laplace distribution.
+logistic             Logistic distribution.
+lognormal            Log-normal distribution.
+logseries            Logarithmic series distribution.
+negative_binomial    Negative binomial distribution.
+noncentral_chisquare Non-central chi-square distribution.
+noncentral_f         Non-central F distribution.
+normal               Normal / Gaussian distribution.
+pareto               Pareto distribution.
+poisson              Poisson distribution.
+power                Power distribution.
+rayleigh             Rayleigh distribution.
+triangular           Triangular distribution.
+uniform              Uniform distribution.
+vonmises             Von Mises circular distribution.
+wald                 Wald (inverse Gaussian) distribution.
+weibull              Weibull distribution.
+zipf                 Zipf's distribution over ranked data.
+==================== =========================================================
+
+==================== ==========================================================
+Multivariate
+distributions
+-------------------- ----------------------------------------------------------
+dirichlet            Multivariate generalization of Beta distribution.
+multinomial          Multivariate generalization of the binomial distribution.
+multivariate_normal  Multivariate generalization of the normal distribution.
+==================== ==========================================================
+
+==================== =========================================================
+Standard
+distributions
+-------------------- ---------------------------------------------------------
+standard_cauchy      Standard Cauchy-Lorentz distribution.
+standard_exponential Standard exponential distribution.
+standard_gamma       Standard Gamma distribution.
+standard_normal      Standard normal distribution.
+standard_t           Standard Student's t-distribution.
+==================== =========================================================
+
+==================== =========================================================
+Internal functions
+-------------------- ---------------------------------------------------------
+get_state            Get tuple representing internal state of generator.
+set_state            Set state of generator.
+==================== =========================================================
+
+
+"""
+__all__ = [
+    'beta',
+    'binomial',
+    'bytes',
+    'chisquare',
+    'choice',
+    'dirichlet',
+    'exponential',
+    'f',
+    'gamma',
+    'geometric',
+    'get_state',
+    'gumbel',
+    'hypergeometric',
+    'laplace',
+    'logistic',
+    'lognormal',
+    'logseries',
+    'multinomial',
+    'multivariate_normal',
+    'negative_binomial',
+    'noncentral_chisquare',
+    'noncentral_f',
+    'normal',
+    'pareto',
+    'permutation',
+    'poisson',
+    'power',
+    'rand',
+    'randint',
+    'randn',
+    'random',
+    'random_integers',
+    'random_sample',
+    'ranf',
+    'rayleigh',
+    'sample',
+    'seed',
+    'set_state',
+    'shuffle',
+    'standard_cauchy',
+    'standard_exponential',
+    'standard_gamma',
+    'standard_normal',
+    'standard_t',
+    'triangular',
+    'uniform',
+    'vonmises',
+    'wald',
+    'weibull',
+    'zipf',
+]
+
+# add these for module-freeze analysis (like PyInstaller)
+from . import _pickle
+from . import _common
+from . import _bounded_integers
+
+from ._generator import Generator, default_rng
+from .bit_generator import SeedSequence, BitGenerator
+from ._mt19937 import MT19937
+from ._pcg64 import PCG64, PCG64DXSM
+from ._philox import Philox
+from ._sfc64 import SFC64
+from .mtrand import *
+
+__all__ += ['Generator', 'RandomState', 'SeedSequence', 'MT19937',
+            'Philox', 'PCG64', 'PCG64DXSM', 'SFC64', 'default_rng',
+            'BitGenerator']
+
+
+def __RandomState_ctor():
+    """Return a RandomState instance.
+
+    This function exists solely to assist (un)pickling.
+
+    Note that the state of the RandomState returned here is irrelevant, as this
+    function's entire purpose is to return a newly allocated RandomState whose
+    state pickle can set.  Consequently the RandomState returned by this function
+    is a freshly allocated copy with a seed=0.
+
+    See https://github.com/numpy/numpy/issues/4763 for a detailed discussion
+
+    """
+    return RandomState(seed=0)
+
+
+from numpy._pytesttester import PytestTester
+test = PytestTester(__name__)
+del PytestTester
diff --git a/venv/lib/python3.12/site-packages/numpy/random/__init__.pyi b/venv/lib/python3.12/site-packages/numpy/random/__init__.pyi
new file mode 100644
index 00000000..26cba3c9
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/random/__init__.pyi
@@ -0,0 +1,71 @@
+from numpy._pytesttester import PytestTester
+
+from numpy.random._generator import Generator as Generator
+from numpy.random._generator import default_rng as default_rng
+from numpy.random._mt19937 import MT19937 as MT19937
+from numpy.random._pcg64 import (
+    PCG64 as PCG64,
+    PCG64DXSM as PCG64DXSM,
+)
+from numpy.random._philox import Philox as Philox
+from numpy.random._sfc64 import SFC64 as SFC64
+from numpy.random.bit_generator import BitGenerator as BitGenerator
+from numpy.random.bit_generator import SeedSequence as SeedSequence
+from numpy.random.mtrand import (
+    RandomState as RandomState,
+    beta as beta,
+    binomial as binomial,
+    bytes as bytes,
+    chisquare as chisquare,
+    choice as choice,
+    dirichlet as dirichlet,
+    exponential as exponential,
+    f as f,
+    gamma as gamma,
+    geometric as geometric,
+    get_bit_generator as get_bit_generator,
+    get_state as get_state,
+    gumbel as gumbel,
+    hypergeometric as hypergeometric,
+    laplace as laplace,
+    logistic as logistic,
+    lognormal as lognormal,
+    logseries as logseries,
+    multinomial as multinomial,
+    multivariate_normal as multivariate_normal,
+    negative_binomial as negative_binomial,
+    noncentral_chisquare as noncentral_chisquare,
+    noncentral_f as noncentral_f,
+    normal as normal,
+    pareto as pareto,
+    permutation as permutation,
+    poisson as poisson,
+    power as power,
+    rand as rand,
+    randint as randint,
+    randn as randn,
+    random as random,
+    random_integers as random_integers,
+    random_sample as random_sample,
+    ranf as ranf,
+    rayleigh as rayleigh,
+    sample as sample,
+    seed as seed,
+    set_bit_generator as set_bit_generator,
+    set_state as set_state,
+    shuffle as shuffle,
+    standard_cauchy as standard_cauchy,
+    standard_exponential as standard_exponential,
+    standard_gamma as standard_gamma,
+    standard_normal as standard_normal,
+    standard_t as standard_t,
+    triangular as triangular,
+    uniform as uniform,
+    vonmises as vonmises,
+    wald as wald,
+    weibull as weibull,
+    zipf as zipf,
+)
+
+__all__: list[str]
+test: PytestTester
diff --git a/venv/lib/python3.12/site-packages/numpy/random/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/random/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 00000000..7eaa0aef
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/random/__pycache__/__init__.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/random/__pycache__/_pickle.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/random/__pycache__/_pickle.cpython-312.pyc
new file mode 100644
index 00000000..66ed5c00
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/random/__pycache__/_pickle.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/random/_bounded_integers.cpython-312-darwin.so b/venv/lib/python3.12/site-packages/numpy/random/_bounded_integers.cpython-312-darwin.so
new file mode 100755
index 00000000..8860fae4
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/random/_bounded_integers.cpython-312-darwin.so differ
diff --git a/venv/lib/python3.12/site-packages/numpy/random/_bounded_integers.pxd b/venv/lib/python3.12/site-packages/numpy/random/_bounded_integers.pxd
new file mode 100644
index 00000000..607014cb
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/random/_bounded_integers.pxd
@@ -0,0 +1,29 @@
+from libc.stdint cimport (uint8_t, uint16_t, uint32_t, uint64_t,
+                          int8_t, int16_t, int32_t, int64_t, intptr_t)
+import numpy as np
+cimport numpy as np
+ctypedef np.npy_bool bool_t
+
+from numpy.random cimport bitgen_t
+
+cdef inline uint64_t _gen_mask(uint64_t max_val) noexcept nogil:
+    """Mask generator for use in bounded random numbers"""
+    # Smallest bit mask >= max
+    cdef uint64_t mask = max_val
+    mask |= mask >> 1
+    mask |= mask >> 2
+    mask |= mask >> 4
+    mask |= mask >> 8
+    mask |= mask >> 16
+    mask |= mask >> 32
+    return mask
+
+cdef object _rand_uint64(object low, object high, object size, bint use_masked, bint closed, bitgen_t *state, object lock)
+cdef object _rand_uint32(object low, object high, object size, bint use_masked, bint closed, bitgen_t *state, object lock)
+cdef object _rand_uint16(object low, object high, object size, bint use_masked, bint closed, bitgen_t *state, object lock)
+cdef object _rand_uint8(object low, object high, object size, bint use_masked, bint closed, bitgen_t *state, object lock)
+cdef object _rand_bool(object low, object high, object size, bint use_masked, bint closed, bitgen_t *state, object lock)
+cdef object _rand_int64(object low, object high, object size, bint use_masked, bint closed, bitgen_t *state, object lock)
+cdef object _rand_int32(object low, object high, object size, bint use_masked, bint closed, bitgen_t *state, object lock)
+cdef object _rand_int16(object low, object high, object size, bint use_masked, bint closed, bitgen_t *state, object lock)
+cdef object _rand_int8(object low, object high, object size, bint use_masked, bint closed, bitgen_t *state, object lock)
diff --git a/venv/lib/python3.12/site-packages/numpy/random/_common.cpython-312-darwin.so b/venv/lib/python3.12/site-packages/numpy/random/_common.cpython-312-darwin.so
new file mode 100755
index 00000000..4a662804
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/random/_common.cpython-312-darwin.so differ
diff --git a/venv/lib/python3.12/site-packages/numpy/random/_common.pxd b/venv/lib/python3.12/site-packages/numpy/random/_common.pxd
new file mode 100644
index 00000000..0de4456d
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/random/_common.pxd
@@ -0,0 +1,107 @@
+#cython: language_level=3
+
+from libc.stdint cimport uint32_t, uint64_t, int32_t, int64_t
+
+import numpy as np
+cimport numpy as np
+
+from numpy.random cimport bitgen_t
+
+cdef double POISSON_LAM_MAX
+cdef double LEGACY_POISSON_LAM_MAX
+cdef uint64_t MAXSIZE
+
+cdef enum ConstraintType:
+    CONS_NONE
+    CONS_NON_NEGATIVE
+    CONS_POSITIVE
+    CONS_POSITIVE_NOT_NAN
+    CONS_BOUNDED_0_1
+    CONS_BOUNDED_GT_0_1
+    CONS_BOUNDED_LT_0_1
+    CONS_GT_1
+    CONS_GTE_1
+    CONS_POISSON
+    LEGACY_CONS_POISSON
+    LEGACY_CONS_NON_NEGATIVE_INBOUNDS_LONG
+
+ctypedef ConstraintType constraint_type
+
+cdef object benchmark(bitgen_t *bitgen, object lock, Py_ssize_t cnt, object method)
+cdef object random_raw(bitgen_t *bitgen, object lock, object size, object output)
+cdef object prepare_cffi(bitgen_t *bitgen)
+cdef object prepare_ctypes(bitgen_t *bitgen)
+cdef int check_constraint(double val, object name, constraint_type cons) except -1
+cdef int check_array_constraint(np.ndarray val, object name, constraint_type cons) except -1
+
+cdef extern from "include/aligned_malloc.h":
+    cdef void *PyArray_realloc_aligned(void *p, size_t n)
+    cdef void *PyArray_malloc_aligned(size_t n)
+    cdef void *PyArray_calloc_aligned(size_t n, size_t s)
+    cdef void PyArray_free_aligned(void *p)
+
+ctypedef void (*random_double_fill)(bitgen_t *state, np.npy_intp count, double* out)  noexcept nogil
+ctypedef double (*random_double_0)(void *state)  noexcept nogil
+ctypedef double (*random_double_1)(void *state, double a)  noexcept nogil
+ctypedef double (*random_double_2)(void *state, double a, double b)  noexcept nogil
+ctypedef double (*random_double_3)(void *state, double a, double b, double c)  noexcept nogil
+
+ctypedef void (*random_float_fill)(bitgen_t *state, np.npy_intp count, float* out)  noexcept nogil
+ctypedef float (*random_float_0)(bitgen_t *state)  noexcept nogil
+ctypedef float (*random_float_1)(bitgen_t *state, float a)  noexcept nogil
+
+ctypedef int64_t (*random_uint_0)(void *state)  noexcept nogil
+ctypedef int64_t (*random_uint_d)(void *state, double a)  noexcept nogil
+ctypedef int64_t (*random_uint_dd)(void *state, double a, double b)  noexcept nogil
+ctypedef int64_t (*random_uint_di)(void *state, double a, uint64_t b)  noexcept nogil
+ctypedef int64_t (*random_uint_i)(void *state, int64_t a)  noexcept nogil
+ctypedef int64_t (*random_uint_iii)(void *state, int64_t a, int64_t b, int64_t c)  noexcept nogil
+
+ctypedef uint32_t (*random_uint_0_32)(bitgen_t *state)  noexcept nogil
+ctypedef uint32_t (*random_uint_1_i_32)(bitgen_t *state, uint32_t a)  noexcept nogil
+
+ctypedef int32_t (*random_int_2_i_32)(bitgen_t *state, int32_t a, int32_t b)  noexcept nogil
+ctypedef int64_t (*random_int_2_i)(bitgen_t *state, int64_t a, int64_t b)  noexcept nogil
+
+cdef double kahan_sum(double *darr, np.npy_intp n) noexcept
+
+cdef inline double uint64_to_double(uint64_t rnd) noexcept nogil:
+    return (rnd >> 11) * (1.0 / 9007199254740992.0)
+
+cdef object double_fill(void *func, bitgen_t *state, object size, object lock, object out)
+
+cdef object float_fill(void *func, bitgen_t *state, object size, object lock, object out)
+
+cdef object float_fill_from_double(void *func, bitgen_t *state, object size, object lock, object out)
+
+cdef object wrap_int(object val, object bits)
+
+cdef np.ndarray int_to_array(object value, object name, object bits, object uint_size)
+
+cdef validate_output_shape(iter_shape, np.ndarray output)
+
+cdef object cont(void *func, void *state, object size, object lock, int narg,
+                 object a, object a_name, constraint_type a_constraint,
+                 object b, object b_name, constraint_type b_constraint,
+                 object c, object c_name, constraint_type c_constraint,
+                 object out)
+
+cdef object disc(void *func, void *state, object size, object lock,
+                 int narg_double, int narg_int64,
+                 object a, object a_name, constraint_type a_constraint,
+                 object b, object b_name, constraint_type b_constraint,
+                 object c, object c_name, constraint_type c_constraint)
+
+cdef object cont_f(void *func, bitgen_t *state, object size, object lock,
+                   object a, object a_name, constraint_type a_constraint,
+                   object out)
+
+cdef object cont_broadcast_3(void *func, void *state, object size, object lock,
+                             np.ndarray a_arr, object a_name, constraint_type a_constraint,
+                             np.ndarray b_arr, object b_name, constraint_type b_constraint,
+                             np.ndarray c_arr, object c_name, constraint_type c_constraint)
+
+cdef object discrete_broadcast_iii(void *func, void *state, object size, object lock,
+                                   np.ndarray a_arr, object a_name, constraint_type a_constraint,
+                                   np.ndarray b_arr, object b_name, constraint_type b_constraint,
+                                   np.ndarray c_arr, object c_name, constraint_type c_constraint)
diff --git a/venv/lib/python3.12/site-packages/numpy/random/_examples/cffi/__pycache__/extending.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/random/_examples/cffi/__pycache__/extending.cpython-312.pyc
new file mode 100644
index 00000000..19cdbcd9
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/random/_examples/cffi/__pycache__/extending.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/random/_examples/cffi/__pycache__/parse.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/random/_examples/cffi/__pycache__/parse.cpython-312.pyc
new file mode 100644
index 00000000..c90b042b
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/random/_examples/cffi/__pycache__/parse.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/random/_examples/cffi/extending.py b/venv/lib/python3.12/site-packages/numpy/random/_examples/cffi/extending.py
new file mode 100644
index 00000000..8440d400
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/random/_examples/cffi/extending.py
@@ -0,0 +1,40 @@
+"""
+Use cffi to access any of the underlying C functions from distributions.h
+"""
+import os
+import numpy as np
+import cffi
+from .parse import parse_distributions_h
+ffi = cffi.FFI()
+
+inc_dir = os.path.join(np.get_include(), 'numpy')
+
+# Basic numpy types
+ffi.cdef('''
+    typedef intptr_t npy_intp;
+    typedef unsigned char npy_bool;
+
+''')
+
+parse_distributions_h(ffi, inc_dir)
+
+lib = ffi.dlopen(np.random._generator.__file__)
+
+# Compare the distributions.h random_standard_normal_fill to
+# Generator.standard_random
+bit_gen = np.random.PCG64()
+rng = np.random.Generator(bit_gen)
+state = bit_gen.state
+
+interface = rng.bit_generator.cffi
+n = 100
+vals_cffi = ffi.new('double[%d]' % n)
+lib.random_standard_normal_fill(interface.bit_generator, n, vals_cffi)
+
+# reset the state
+bit_gen.state = state
+
+vals = rng.standard_normal(n)
+
+for i in range(n):
+    assert vals[i] == vals_cffi[i]
diff --git a/venv/lib/python3.12/site-packages/numpy/random/_examples/cffi/parse.py b/venv/lib/python3.12/site-packages/numpy/random/_examples/cffi/parse.py
new file mode 100644
index 00000000..d41c4c2d
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/random/_examples/cffi/parse.py
@@ -0,0 +1,54 @@
+import os
+
+
+def parse_distributions_h(ffi, inc_dir):
+    """
+    Parse distributions.h located in inc_dir for CFFI, filling in the ffi.cdef
+
+    Read the function declarations without the "#define ..." macros that will
+    be filled in when loading the library.
+    """
+
+    with open(os.path.join(inc_dir, 'random', 'bitgen.h')) as fid:
+        s = []
+        for line in fid:
+            # massage the include file
+            if line.strip().startswith('#'):
+                continue
+            s.append(line)
+        ffi.cdef('\n'.join(s))
+
+    with open(os.path.join(inc_dir, 'random', 'distributions.h')) as fid:
+        s = []
+        in_skip = 0
+        ignoring = False
+        for line in fid:
+            # check for and remove extern "C" guards
+            if ignoring:
+                if line.strip().startswith('#endif'):
+                    ignoring = False
+                continue
+            if line.strip().startswith('#ifdef __cplusplus'):
+                ignoring = True
+            
+            # massage the include file
+            if line.strip().startswith('#'):
+                continue
+    
+            # skip any inlined function definition
+            # which starts with 'static inline xxx(...) {'
+            # and ends with a closing '}'
+            if line.strip().startswith('static inline'):
+                in_skip += line.count('{')
+                continue
+            elif in_skip > 0:
+                in_skip += line.count('{')
+                in_skip -= line.count('}')
+                continue
+    
+            # replace defines with their value or remove them
+            line = line.replace('DECLDIR', '')
+            line = line.replace('RAND_INT_TYPE', 'int64_t')
+            s.append(line)
+        ffi.cdef('\n'.join(s))
+
diff --git a/venv/lib/python3.12/site-packages/numpy/random/_examples/cython/extending.pyx b/venv/lib/python3.12/site-packages/numpy/random/_examples/cython/extending.pyx
new file mode 100644
index 00000000..30efd744
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/random/_examples/cython/extending.pyx
@@ -0,0 +1,78 @@
+#!/usr/bin/env python3
+#cython: language_level=3
+
+from libc.stdint cimport uint32_t
+from cpython.pycapsule cimport PyCapsule_IsValid, PyCapsule_GetPointer
+
+import numpy as np
+cimport numpy as np
+cimport cython
+
+from numpy.random cimport bitgen_t
+from numpy.random import PCG64
+
+np.import_array()
+
+
+@cython.boundscheck(False)
+@cython.wraparound(False)
+def uniform_mean(Py_ssize_t n):
+    cdef Py_ssize_t i
+    cdef bitgen_t *rng
+    cdef const char *capsule_name = "BitGenerator"
+    cdef double[::1] random_values
+    cdef np.ndarray randoms
+
+    x = PCG64()
+    capsule = x.capsule
+    if not PyCapsule_IsValid(capsule, capsule_name):
+        raise ValueError("Invalid pointer to anon_func_state")
+    rng =  PyCapsule_GetPointer(capsule, capsule_name)
+    random_values = np.empty(n)
+    # Best practice is to acquire the lock whenever generating random values.
+    # This prevents other threads from modifying the state. Acquiring the lock
+    # is only necessary if the GIL is also released, as in this example.
+    with x.lock, nogil:
+        for i in range(n):
+            random_values[i] = rng.next_double(rng.state)
+    randoms = np.asarray(random_values)
+    return randoms.mean()
+
+
+# This function is declared nogil so it can be used without the GIL below
+cdef uint32_t bounded_uint(uint32_t lb, uint32_t ub, bitgen_t *rng) nogil:
+    cdef uint32_t mask, delta, val
+    mask = delta = ub - lb
+    mask |= mask >> 1
+    mask |= mask >> 2
+    mask |= mask >> 4
+    mask |= mask >> 8
+    mask |= mask >> 16
+
+    val = rng.next_uint32(rng.state) & mask
+    while val > delta:
+        val = rng.next_uint32(rng.state) & mask
+
+    return lb + val
+
+
+@cython.boundscheck(False)
+@cython.wraparound(False)
+def bounded_uints(uint32_t lb, uint32_t ub, Py_ssize_t n):
+    cdef Py_ssize_t i
+    cdef bitgen_t *rng
+    cdef uint32_t[::1] out
+    cdef const char *capsule_name = "BitGenerator"
+
+    x = PCG64()
+    out = np.empty(n, dtype=np.uint32)
+    capsule = x.capsule
+
+    if not PyCapsule_IsValid(capsule, capsule_name):
+        raise ValueError("Invalid pointer to anon_func_state")
+    rng = PyCapsule_GetPointer(capsule, capsule_name)
+
+    with x.lock, nogil:
+        for i in range(n):
+            out[i] = bounded_uint(lb, ub, rng)
+    return np.asarray(out)
diff --git a/venv/lib/python3.12/site-packages/numpy/random/_examples/cython/extending_distributions.pyx b/venv/lib/python3.12/site-packages/numpy/random/_examples/cython/extending_distributions.pyx
new file mode 100644
index 00000000..d908e92d
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/random/_examples/cython/extending_distributions.pyx
@@ -0,0 +1,117 @@
+#!/usr/bin/env python3
+#cython: language_level=3
+"""
+This file shows how the to use a BitGenerator to create a distribution.
+"""
+import numpy as np
+cimport numpy as np
+cimport cython
+from cpython.pycapsule cimport PyCapsule_IsValid, PyCapsule_GetPointer
+from libc.stdint cimport uint16_t, uint64_t
+from numpy.random cimport bitgen_t
+from numpy.random import PCG64
+from numpy.random.c_distributions cimport (
+      random_standard_uniform_fill, random_standard_uniform_fill_f)
+
+
+@cython.boundscheck(False)
+@cython.wraparound(False)
+def uniforms(Py_ssize_t n):
+    """
+    Create an array of `n` uniformly distributed doubles.
+    A 'real' distribution would want to process the values into
+    some non-uniform distribution
+    """
+    cdef Py_ssize_t i
+    cdef bitgen_t *rng
+    cdef const char *capsule_name = "BitGenerator"
+    cdef double[::1] random_values
+
+    x = PCG64()
+    capsule = x.capsule
+    # Optional check that the capsule if from a BitGenerator
+    if not PyCapsule_IsValid(capsule, capsule_name):
+        raise ValueError("Invalid pointer to anon_func_state")
+    # Cast the pointer
+    rng =  PyCapsule_GetPointer(capsule, capsule_name)
+    random_values = np.empty(n, dtype='float64')
+    with x.lock, nogil:
+        for i in range(n):
+            # Call the function
+            random_values[i] = rng.next_double(rng.state)
+    randoms = np.asarray(random_values)
+
+    return randoms
+
+# cython example 2
+@cython.boundscheck(False)
+@cython.wraparound(False)
+def uint10_uniforms(Py_ssize_t n):
+    """Uniform 10 bit integers stored as 16-bit unsigned integers"""
+    cdef Py_ssize_t i
+    cdef bitgen_t *rng
+    cdef const char *capsule_name = "BitGenerator"
+    cdef uint16_t[::1] random_values
+    cdef int bits_remaining
+    cdef int width = 10
+    cdef uint64_t buff, mask = 0x3FF
+
+    x = PCG64()
+    capsule = x.capsule
+    if not PyCapsule_IsValid(capsule, capsule_name):
+        raise ValueError("Invalid pointer to anon_func_state")
+    rng =  PyCapsule_GetPointer(capsule, capsule_name)
+    random_values = np.empty(n, dtype='uint16')
+    # Best practice is to release GIL and acquire the lock
+    bits_remaining = 0
+    with x.lock, nogil:
+        for i in range(n):
+            if bits_remaining < width:
+                buff = rng.next_uint64(rng.state)
+            random_values[i] = buff & mask
+            buff >>= width
+
+    randoms = np.asarray(random_values)
+    return randoms
+
+# cython example 3
+def uniforms_ex(bit_generator, Py_ssize_t n, dtype=np.float64):
+    """
+    Create an array of `n` uniformly distributed doubles via a "fill" function.
+
+    A 'real' distribution would want to process the values into
+    some non-uniform distribution
+
+    Parameters
+    ----------
+    bit_generator: BitGenerator instance
+    n: int
+        Output vector length
+    dtype: {str, dtype}, optional
+        Desired dtype, either 'd' (or 'float64') or 'f' (or 'float32'). The
+        default dtype value is 'd'
+    """
+    cdef Py_ssize_t i
+    cdef bitgen_t *rng
+    cdef const char *capsule_name = "BitGenerator"
+    cdef np.ndarray randoms
+
+    capsule = bit_generator.capsule
+    # Optional check that the capsule if from a BitGenerator
+    if not PyCapsule_IsValid(capsule, capsule_name):
+        raise ValueError("Invalid pointer to anon_func_state")
+    # Cast the pointer
+    rng =  PyCapsule_GetPointer(capsule, capsule_name)
+
+    _dtype = np.dtype(dtype)
+    randoms = np.empty(n, dtype=_dtype)
+    if _dtype == np.float32:
+        with bit_generator.lock:
+            random_standard_uniform_fill_f(rng, n, np.PyArray_DATA(randoms))
+    elif _dtype == np.float64:
+        with bit_generator.lock:
+            random_standard_uniform_fill(rng, n, np.PyArray_DATA(randoms))
+    else:
+        raise TypeError('Unsupported dtype %r for random' % _dtype)
+    return randoms
+
diff --git a/venv/lib/python3.12/site-packages/numpy/random/_examples/cython/meson.build b/venv/lib/python3.12/site-packages/numpy/random/_examples/cython/meson.build
new file mode 100644
index 00000000..7aa367d1
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/random/_examples/cython/meson.build
@@ -0,0 +1,53 @@
+project('random-build-examples', 'c', 'cpp', 'cython')
+
+py_mod = import('python')
+py3 = py_mod.find_installation(pure: false)
+
+cc = meson.get_compiler('c')
+cy = meson.get_compiler('cython')
+
+# Keep synced with pyproject.toml
+if not cy.version().version_compare('>=3.0.6')
+  error('tests requires Cython >= 3.0.6')
+endif
+
+base_cython_args = []
+if cy.version().version_compare('>=3.1.0')
+  base_cython_args += ['-Xfreethreading_compatible=True']
+endif
+
+_numpy_abs = run_command(py3, ['-c',
+               'import os; os.chdir(".."); import numpy; print(os.path.abspath(numpy.get_include() + "../../.."))'],
+                         check: true).stdout().strip()
+
+npymath_path = _numpy_abs / '_core' / 'lib'
+npy_include_path = _numpy_abs / '_core' / 'include'
+npyrandom_path = _numpy_abs / 'random' / 'lib'
+npymath_lib = cc.find_library('npymath', dirs: npymath_path)
+npyrandom_lib = cc.find_library('npyrandom', dirs: npyrandom_path)
+
+py3.extension_module(
+    'extending_distributions',
+    'extending_distributions.pyx',
+    install: false,
+    include_directories: [npy_include_path],
+    dependencies: [npyrandom_lib, npymath_lib],
+    cython_args: base_cython_args,
+)
+py3.extension_module(
+    'extending',
+    'extending.pyx',
+    install: false,
+    include_directories: [npy_include_path],
+    dependencies: [npyrandom_lib, npymath_lib],
+    cython_args: base_cython_args,
+)
+py3.extension_module(
+    'extending_cpp',
+    'extending_distributions.pyx',
+    install: false,
+    override_options : ['cython_language=cpp'],
+    cython_args: base_cython_args + ['--module-name', 'extending_cpp'],
+    include_directories: [npy_include_path],
+    dependencies: [npyrandom_lib, npymath_lib],
+)
diff --git a/venv/lib/python3.12/site-packages/numpy/random/_examples/numba/__pycache__/extending.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/random/_examples/numba/__pycache__/extending.cpython-312.pyc
new file mode 100644
index 00000000..7da15491
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/random/_examples/numba/__pycache__/extending.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/random/_examples/numba/__pycache__/extending_distributions.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/random/_examples/numba/__pycache__/extending_distributions.cpython-312.pyc
new file mode 100644
index 00000000..165a5a6e
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/random/_examples/numba/__pycache__/extending_distributions.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/random/_examples/numba/extending.py b/venv/lib/python3.12/site-packages/numpy/random/_examples/numba/extending.py
new file mode 100644
index 00000000..f387db69
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/random/_examples/numba/extending.py
@@ -0,0 +1,84 @@
+import numpy as np
+import numba as nb
+
+from numpy.random import PCG64
+from timeit import timeit
+
+bit_gen = PCG64()
+next_d = bit_gen.cffi.next_double
+state_addr = bit_gen.cffi.state_address
+
+def normals(n, state):
+    out = np.empty(n)
+    for i in range((n + 1) // 2):
+        x1 = 2.0 * next_d(state) - 1.0
+        x2 = 2.0 * next_d(state) - 1.0
+        r2 = x1 * x1 + x2 * x2
+        while r2 >= 1.0 or r2 == 0.0:
+            x1 = 2.0 * next_d(state) - 1.0
+            x2 = 2.0 * next_d(state) - 1.0
+            r2 = x1 * x1 + x2 * x2
+        f = np.sqrt(-2.0 * np.log(r2) / r2)
+        out[2 * i] = f * x1
+        if 2 * i + 1 < n:
+            out[2 * i + 1] = f * x2
+    return out
+
+# Compile using Numba
+normalsj = nb.jit(normals, nopython=True)
+# Must use state address not state with numba
+n = 10000
+
+def numbacall():
+    return normalsj(n, state_addr)
+
+rg = np.random.Generator(PCG64())
+
+def numpycall():
+    return rg.normal(size=n)
+
+# Check that the functions work
+r1 = numbacall()
+r2 = numpycall()
+assert r1.shape == (n,)
+assert r1.shape == r2.shape
+
+t1 = timeit(numbacall, number=1000)
+print(f'{t1:.2f} secs for {n} PCG64 (Numba/PCG64) gaussian randoms')
+t2 = timeit(numpycall, number=1000)
+print(f'{t2:.2f} secs for {n} PCG64 (NumPy/PCG64) gaussian randoms')
+
+# example 2
+
+next_u32 = bit_gen.ctypes.next_uint32
+ctypes_state = bit_gen.ctypes.state
+
+@nb.jit(nopython=True)
+def bounded_uint(lb, ub, state):
+    mask = delta = ub - lb
+    mask |= mask >> 1
+    mask |= mask >> 2
+    mask |= mask >> 4
+    mask |= mask >> 8
+    mask |= mask >> 16
+
+    val = next_u32(state) & mask
+    while val > delta:
+        val = next_u32(state) & mask
+
+    return lb + val
+
+
+print(bounded_uint(323, 2394691, ctypes_state.value))
+
+
+@nb.jit(nopython=True)
+def bounded_uints(lb, ub, n, state):
+    out = np.empty(n, dtype=np.uint32)
+    for i in range(n):
+        out[i] = bounded_uint(lb, ub, state)
+
+
+bounded_uints(323, 2394691, 10000000, ctypes_state.value)
+
+
diff --git a/venv/lib/python3.12/site-packages/numpy/random/_examples/numba/extending_distributions.py b/venv/lib/python3.12/site-packages/numpy/random/_examples/numba/extending_distributions.py
new file mode 100644
index 00000000..7ef0753d
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/random/_examples/numba/extending_distributions.py
@@ -0,0 +1,67 @@
+r"""
+Building the required library in this example requires a source distribution
+of NumPy or clone of the NumPy git repository since distributions.c is not
+included in binary distributions.
+
+On *nix, execute in numpy/random/src/distributions
+
+export ${PYTHON_VERSION}=3.8 # Python version
+export PYTHON_INCLUDE=#path to Python's include folder, usually \
+    ${PYTHON_HOME}/include/python${PYTHON_VERSION}m
+export NUMPY_INCLUDE=#path to numpy's include folder, usually \
+    ${PYTHON_HOME}/lib/python${PYTHON_VERSION}/site-packages/numpy/_core/include
+gcc -shared -o libdistributions.so -fPIC distributions.c \
+    -I${NUMPY_INCLUDE} -I${PYTHON_INCLUDE}
+mv libdistributions.so ../../_examples/numba/
+
+On Windows
+
+rem PYTHON_HOME and PYTHON_VERSION are setup dependent, this is an example
+set PYTHON_HOME=c:\Anaconda
+set PYTHON_VERSION=38
+cl.exe /LD .\distributions.c -DDLL_EXPORT \
+    -I%PYTHON_HOME%\lib\site-packages\numpy\_core\include \
+    -I%PYTHON_HOME%\include %PYTHON_HOME%\libs\python%PYTHON_VERSION%.lib
+move distributions.dll ../../_examples/numba/
+"""
+import os
+
+import numba as nb
+import numpy as np
+from cffi import FFI
+
+from numpy.random import PCG64
+
+ffi = FFI()
+if os.path.exists('./distributions.dll'):
+    lib = ffi.dlopen('./distributions.dll')
+elif os.path.exists('./libdistributions.so'):
+    lib = ffi.dlopen('./libdistributions.so')
+else:
+    raise RuntimeError('Required DLL/so file was not found.')
+
+ffi.cdef("""
+double random_standard_normal(void *bitgen_state);
+""")
+x = PCG64()
+xffi = x.cffi
+bit_generator = xffi.bit_generator
+
+random_standard_normal = lib.random_standard_normal
+
+
+def normals(n, bit_generator):
+    out = np.empty(n)
+    for i in range(n):
+        out[i] = random_standard_normal(bit_generator)
+    return out
+
+
+normalsj = nb.jit(normals, nopython=True)
+
+# Numba requires a memory address for void *
+# Can also get address from x.ctypes.bit_generator.value
+bit_generator_address = int(ffi.cast('uintptr_t', bit_generator))
+
+norm = normalsj(1000, bit_generator_address)
+print(norm[:12])
diff --git a/venv/lib/python3.12/site-packages/numpy/random/_generator.cpython-312-darwin.so b/venv/lib/python3.12/site-packages/numpy/random/_generator.cpython-312-darwin.so
new file mode 100755
index 00000000..b9104493
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/random/_generator.cpython-312-darwin.so differ
diff --git a/venv/lib/python3.12/site-packages/numpy/random/_generator.pyi b/venv/lib/python3.12/site-packages/numpy/random/_generator.pyi
new file mode 100644
index 00000000..16a0e5e0
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/random/_generator.pyi
@@ -0,0 +1,784 @@
+from collections.abc import Callable
+from typing import Any, overload, TypeVar, Literal
+
+import numpy as np
+from numpy import (
+    dtype,
+    float32,
+    float64,
+    int8,
+    int16,
+    int32,
+    int64,
+    int_,
+    uint,
+    uint8,
+    uint16,
+    uint32,
+    uint64,
+)
+from numpy.random import BitGenerator, SeedSequence
+from numpy._typing import (
+    ArrayLike,
+    NDArray,
+    _ArrayLikeFloat_co,
+    _ArrayLikeInt_co,
+    _DoubleCodes,
+    _DTypeLikeBool,
+    _DTypeLikeInt,
+    _DTypeLikeUInt,
+    _Float32Codes,
+    _Float64Codes,
+    _FloatLike_co,
+    _Int8Codes,
+    _Int16Codes,
+    _Int32Codes,
+    _Int64Codes,
+    _IntCodes,
+    _ShapeLike,
+    _SingleCodes,
+    _SupportsDType,
+    _UInt8Codes,
+    _UInt16Codes,
+    _UInt32Codes,
+    _UInt64Codes,
+    _UIntCodes,
+)
+
+_ArrayType = TypeVar("_ArrayType", bound=NDArray[Any])
+
+_DTypeLikeFloat32 = (
+    dtype[float32]
+    | _SupportsDType[dtype[float32]]
+    | type[float32]
+    | _Float32Codes
+    | _SingleCodes
+)
+
+_DTypeLikeFloat64 = (
+    dtype[float64]
+    | _SupportsDType[dtype[float64]]
+    | type[float]
+    | type[float64]
+    | _Float64Codes
+    | _DoubleCodes
+)
+
+class Generator:
+    def __init__(self, bit_generator: BitGenerator) -> None: ...
+    def __repr__(self) -> str: ...
+    def __str__(self) -> str: ...
+    def __getstate__(self) -> None: ...
+    def __setstate__(self, state: dict[str, Any] | None) -> None: ...
+    def __reduce__(self) -> tuple[
+        Callable[[BitGenerator], Generator],
+        tuple[BitGenerator],
+        None]: ...
+    @property
+    def bit_generator(self) -> BitGenerator: ...
+    def spawn(self, n_children: int) -> list[Generator]: ...
+    def bytes(self, length: int) -> bytes: ...
+    @overload
+    def standard_normal(  # type: ignore[misc]
+        self,
+        size: None = ...,
+        dtype: _DTypeLikeFloat32 | _DTypeLikeFloat64 = ...,
+        out: None = ...,
+    ) -> float: ...
+    @overload
+    def standard_normal(  # type: ignore[misc]
+        self,
+        size: _ShapeLike = ...,
+    ) -> NDArray[float64]: ...
+    @overload
+    def standard_normal(  # type: ignore[misc]
+        self,
+        *,
+        out: NDArray[float64] = ...,
+    ) -> NDArray[float64]: ...
+    @overload
+    def standard_normal(  # type: ignore[misc]
+        self,
+        size: _ShapeLike = ...,
+        dtype: _DTypeLikeFloat32 = ...,
+        out: None | NDArray[float32] = ...,
+    ) -> NDArray[float32]: ...
+    @overload
+    def standard_normal(  # type: ignore[misc]
+        self,
+        size: _ShapeLike = ...,
+        dtype: _DTypeLikeFloat64 = ...,
+        out: None | NDArray[float64] = ...,
+    ) -> NDArray[float64]: ...
+    @overload
+    def permutation(self, x: int, axis: int = ...) -> NDArray[int64]: ...
+    @overload
+    def permutation(self, x: ArrayLike, axis: int = ...) -> NDArray[Any]: ...
+    @overload
+    def standard_exponential(  # type: ignore[misc]
+        self,
+        size: None = ...,
+        dtype: _DTypeLikeFloat32 | _DTypeLikeFloat64 = ...,
+        method: Literal["zig", "inv"] = ...,
+        out: None = ...,
+    ) -> float: ...
+    @overload
+    def standard_exponential(
+        self,
+        size: _ShapeLike = ...,
+    ) -> NDArray[float64]: ...
+    @overload
+    def standard_exponential(
+        self,
+        *,
+        out: NDArray[float64] = ...,
+    ) -> NDArray[float64]: ...
+    @overload
+    def standard_exponential(
+        self,
+        size: _ShapeLike = ...,
+        *,
+        method: Literal["zig", "inv"] = ...,
+        out: None | NDArray[float64] = ...,
+    ) -> NDArray[float64]: ...
+    @overload
+    def standard_exponential(
+        self,
+        size: _ShapeLike = ...,
+        dtype: _DTypeLikeFloat32 = ...,
+        method: Literal["zig", "inv"] = ...,
+        out: None | NDArray[float32] = ...,
+    ) -> NDArray[float32]: ...
+    @overload
+    def standard_exponential(
+        self,
+        size: _ShapeLike = ...,
+        dtype: _DTypeLikeFloat64 = ...,
+        method: Literal["zig", "inv"] = ...,
+        out: None | NDArray[float64] = ...,
+    ) -> NDArray[float64]: ...
+    @overload
+    def random(  # type: ignore[misc]
+        self,
+        size: None = ...,
+        dtype: _DTypeLikeFloat32 | _DTypeLikeFloat64 = ...,
+        out: None = ...,
+    ) -> float: ...
+    @overload
+    def random(
+        self,
+        *,
+        out: NDArray[float64] = ...,
+    ) -> NDArray[float64]: ...
+    @overload
+    def random(
+        self,
+        size: _ShapeLike = ...,
+        *,
+        out: None | NDArray[float64] = ...,
+    ) -> NDArray[float64]: ...
+    @overload
+    def random(
+        self,
+        size: _ShapeLike = ...,
+        dtype: _DTypeLikeFloat32 = ...,
+        out: None | NDArray[float32] = ...,
+    ) -> NDArray[float32]: ...
+    @overload
+    def random(
+        self,
+        size: _ShapeLike = ...,
+        dtype: _DTypeLikeFloat64 = ...,
+        out: None | NDArray[float64] = ...,
+    ) -> NDArray[float64]: ...
+    @overload
+    def beta(
+        self,
+        a: _FloatLike_co,
+        b: _FloatLike_co,
+        size: None = ...,
+    ) -> float: ...  # type: ignore[misc]
+    @overload
+    def beta(
+        self, a: _ArrayLikeFloat_co, b: _ArrayLikeFloat_co, size: None | _ShapeLike = ...
+    ) -> NDArray[float64]: ...
+    @overload
+    def exponential(self, scale: _FloatLike_co = ..., size: None = ...) -> float: ...  # type: ignore[misc]
+    @overload
+    def exponential(
+        self, scale: _ArrayLikeFloat_co = ..., size: None | _ShapeLike = ...
+    ) -> NDArray[float64]: ...
+    @overload
+    def integers(  # type: ignore[misc]
+        self,
+        low: int,
+        high: None | int = ...,
+        size: None = ...,
+    ) -> int: ...
+    @overload
+    def integers(  # type: ignore[misc]
+        self,
+        low: int,
+        high: None | int = ...,
+        size: None = ...,
+        dtype: type[bool] = ...,
+        endpoint: bool = ...,
+    ) -> bool: ...
+    @overload
+    def integers(  # type: ignore[misc]
+        self,
+        low: int,
+        high: None | int = ...,
+        size: None = ...,
+        dtype: type[np.bool] = ...,
+        endpoint: bool = ...,
+    ) -> np.bool: ...
+    @overload
+    def integers(  # type: ignore[misc]
+        self,
+        low: int,
+        high: None | int = ...,
+        size: None = ...,
+        dtype: type[int] = ...,
+        endpoint: bool = ...,
+    ) -> int: ...
+    @overload
+    def integers(  # type: ignore[misc]
+        self,
+        low: int,
+        high: None | int = ...,
+        size: None = ...,
+        dtype: dtype[uint8] | type[uint8] | _UInt8Codes | _SupportsDType[dtype[uint8]] = ...,
+        endpoint: bool = ...,
+    ) -> uint8: ...
+    @overload
+    def integers(  # type: ignore[misc]
+        self,
+        low: int,
+        high: None | int = ...,
+        size: None = ...,
+        dtype: dtype[uint16] | type[uint16] | _UInt16Codes | _SupportsDType[dtype[uint16]] = ...,
+        endpoint: bool = ...,
+    ) -> uint16: ...
+    @overload
+    def integers(  # type: ignore[misc]
+        self,
+        low: int,
+        high: None | int = ...,
+        size: None = ...,
+        dtype: dtype[uint32] | type[uint32] | _UInt32Codes | _SupportsDType[dtype[uint32]] = ...,
+        endpoint: bool = ...,
+    ) -> uint32: ...
+    @overload
+    def integers(  # type: ignore[misc]
+        self,
+        low: int,
+        high: None | int = ...,
+        size: None = ...,
+        dtype: dtype[uint] | type[uint] | _UIntCodes | _SupportsDType[dtype[uint]] = ...,
+        endpoint: bool = ...,
+    ) -> uint: ...
+    @overload
+    def integers(  # type: ignore[misc]
+        self,
+        low: int,
+        high: None | int = ...,
+        size: None = ...,
+        dtype: dtype[uint64] | type[uint64] | _UInt64Codes | _SupportsDType[dtype[uint64]] = ...,
+        endpoint: bool = ...,
+    ) -> uint64: ...
+    @overload
+    def integers(  # type: ignore[misc]
+        self,
+        low: int,
+        high: None | int = ...,
+        size: None = ...,
+        dtype: dtype[int8] | type[int8] | _Int8Codes | _SupportsDType[dtype[int8]] = ...,
+        endpoint: bool = ...,
+    ) -> int8: ...
+    @overload
+    def integers(  # type: ignore[misc]
+        self,
+        low: int,
+        high: None | int = ...,
+        size: None = ...,
+        dtype: dtype[int16] | type[int16] | _Int16Codes | _SupportsDType[dtype[int16]] = ...,
+        endpoint: bool = ...,
+    ) -> int16: ...
+    @overload
+    def integers(  # type: ignore[misc]
+        self,
+        low: int,
+        high: None | int = ...,
+        size: None = ...,
+        dtype: dtype[int32] | type[int32] | _Int32Codes | _SupportsDType[dtype[int32]] = ...,
+        endpoint: bool = ...,
+    ) -> int32: ...
+    @overload
+    def integers(  # type: ignore[misc]
+        self,
+        low: int,
+        high: None | int = ...,
+        size: None = ...,
+        dtype: dtype[int_] | type[int] | type[int_] | _IntCodes | _SupportsDType[dtype[int_]] = ...,
+        endpoint: bool = ...,
+    ) -> int_: ...
+    @overload
+    def integers(  # type: ignore[misc]
+        self,
+        low: int,
+        high: None | int = ...,
+        size: None = ...,
+        dtype: dtype[int64] | type[int64] | _Int64Codes | _SupportsDType[dtype[int64]] = ...,
+        endpoint: bool = ...,
+    ) -> int64: ...
+    @overload
+    def integers(  # type: ignore[misc]
+        self,
+        low: _ArrayLikeInt_co,
+        high: None | _ArrayLikeInt_co = ...,
+        size: None | _ShapeLike = ...,
+    ) -> NDArray[int64]: ...
+    @overload
+    def integers(  # type: ignore[misc]
+        self,
+        low: _ArrayLikeInt_co,
+        high: None | _ArrayLikeInt_co = ...,
+        size: None | _ShapeLike = ...,
+        dtype: _DTypeLikeBool = ...,
+        endpoint: bool = ...,
+    ) -> NDArray[np.bool]: ...
+    @overload
+    def integers(  # type: ignore[misc]
+        self,
+        low: _ArrayLikeInt_co,
+        high: None | _ArrayLikeInt_co = ...,
+        size: None | _ShapeLike = ...,
+        dtype: dtype[int8] | type[int8] | _Int8Codes | _SupportsDType[dtype[int8]] = ...,
+        endpoint: bool = ...,
+    ) -> NDArray[int8]: ...
+    @overload
+    def integers(  # type: ignore[misc]
+        self,
+        low: _ArrayLikeInt_co,
+        high: None | _ArrayLikeInt_co = ...,
+        size: None | _ShapeLike = ...,
+        dtype: dtype[int16] | type[int16] | _Int16Codes | _SupportsDType[dtype[int16]] = ...,
+        endpoint: bool = ...,
+    ) -> NDArray[int16]: ...
+    @overload
+    def integers(  # type: ignore[misc]
+        self,
+        low: _ArrayLikeInt_co,
+        high: None | _ArrayLikeInt_co = ...,
+        size: None | _ShapeLike = ...,
+        dtype: dtype[int32] | type[int32] | _Int32Codes | _SupportsDType[dtype[int32]] = ...,
+        endpoint: bool = ...,
+    ) -> NDArray[int32]: ...
+    @overload
+    def integers(  # type: ignore[misc]
+        self,
+        low: _ArrayLikeInt_co,
+        high: None | _ArrayLikeInt_co = ...,
+        size: None | _ShapeLike = ...,
+        dtype: None | dtype[int64] | type[int64] | _Int64Codes | _SupportsDType[dtype[int64]] = ...,
+        endpoint: bool = ...,
+    ) -> NDArray[int64]: ...
+    @overload
+    def integers(  # type: ignore[misc]
+        self,
+        low: _ArrayLikeInt_co,
+        high: None | _ArrayLikeInt_co = ...,
+        size: None | _ShapeLike = ...,
+        dtype: dtype[uint8] | type[uint8] | _UInt8Codes | _SupportsDType[dtype[uint8]] = ...,
+        endpoint: bool = ...,
+    ) -> NDArray[uint8]: ...
+    @overload
+    def integers(  # type: ignore[misc]
+        self,
+        low: _ArrayLikeInt_co,
+        high: None | _ArrayLikeInt_co = ...,
+        size: None | _ShapeLike = ...,
+        dtype: dtype[uint16] | type[uint16] | _UInt16Codes | _SupportsDType[dtype[uint16]] = ...,
+        endpoint: bool = ...,
+    ) -> NDArray[uint16]: ...
+    @overload
+    def integers(  # type: ignore[misc]
+        self,
+        low: _ArrayLikeInt_co,
+        high: None | _ArrayLikeInt_co = ...,
+        size: None | _ShapeLike = ...,
+        dtype: dtype[uint32] | type[uint32] | _UInt32Codes | _SupportsDType[dtype[uint32]] = ...,
+        endpoint: bool = ...,
+    ) -> NDArray[uint32]: ...
+    @overload
+    def integers(  # type: ignore[misc]
+        self,
+        low: _ArrayLikeInt_co,
+        high: None | _ArrayLikeInt_co = ...,
+        size: None | _ShapeLike = ...,
+        dtype: dtype[uint64] | type[uint64] | _UInt64Codes | _SupportsDType[dtype[uint64]] = ...,
+        endpoint: bool = ...,
+    ) -> NDArray[uint64]: ...
+    @overload
+    def integers(  # type: ignore[misc]
+        self,
+        low: _ArrayLikeInt_co,
+        high: None | _ArrayLikeInt_co = ...,
+        size: None | _ShapeLike = ...,
+        dtype: dtype[int_] | type[int] | type[int_] | _IntCodes | _SupportsDType[dtype[int_]] = ...,
+        endpoint: bool = ...,
+    ) -> NDArray[int_]: ...
+    @overload
+    def integers(  # type: ignore[misc]
+        self,
+        low: _ArrayLikeInt_co,
+        high: None | _ArrayLikeInt_co = ...,
+        size: None | _ShapeLike = ...,
+        dtype: dtype[uint] | type[uint] | _UIntCodes | _SupportsDType[dtype[uint]] = ...,
+        endpoint: bool = ...,
+    ) -> NDArray[uint]: ...
+    # TODO: Use a TypeVar _T here to get away from Any output?  Should be int->NDArray[int64], ArrayLike[_T] -> _T | NDArray[Any]
+    @overload
+    def choice(
+        self,
+        a: int,
+        size: None = ...,
+        replace: bool = ...,
+        p: None | _ArrayLikeFloat_co = ...,
+        axis: int = ...,
+        shuffle: bool = ...,
+    ) -> int: ...
+    @overload
+    def choice(
+        self,
+        a: int,
+        size: _ShapeLike = ...,
+        replace: bool = ...,
+        p: None | _ArrayLikeFloat_co = ...,
+        axis: int = ...,
+        shuffle: bool = ...,
+    ) -> NDArray[int64]: ...
+    @overload
+    def choice(
+        self,
+        a: ArrayLike,
+        size: None = ...,
+        replace: bool = ...,
+        p: None | _ArrayLikeFloat_co = ...,
+        axis: int = ...,
+        shuffle: bool = ...,
+    ) -> Any: ...
+    @overload
+    def choice(
+        self,
+        a: ArrayLike,
+        size: _ShapeLike = ...,
+        replace: bool = ...,
+        p: None | _ArrayLikeFloat_co = ...,
+        axis: int = ...,
+        shuffle: bool = ...,
+    ) -> NDArray[Any]: ...
+    @overload
+    def uniform(
+        self,
+        low: _FloatLike_co = ...,
+        high: _FloatLike_co = ...,
+        size: None = ...,
+    ) -> float: ...  # type: ignore[misc]
+    @overload
+    def uniform(
+        self,
+        low: _ArrayLikeFloat_co = ...,
+        high: _ArrayLikeFloat_co = ...,
+        size: None | _ShapeLike = ...,
+    ) -> NDArray[float64]: ...
+    @overload
+    def normal(
+        self,
+        loc: _FloatLike_co = ...,
+        scale: _FloatLike_co = ...,
+        size: None = ...,
+    ) -> float: ...  # type: ignore[misc]
+    @overload
+    def normal(
+        self,
+        loc: _ArrayLikeFloat_co = ...,
+        scale: _ArrayLikeFloat_co = ...,
+        size: None | _ShapeLike = ...,
+    ) -> NDArray[float64]: ...
+    @overload
+    def standard_gamma(  # type: ignore[misc]
+        self,
+        shape: _FloatLike_co,
+        size: None = ...,
+        dtype: _DTypeLikeFloat32 | _DTypeLikeFloat64 = ...,
+        out: None = ...,
+    ) -> float: ...
+    @overload
+    def standard_gamma(
+        self,
+        shape: _ArrayLikeFloat_co,
+        size: None | _ShapeLike = ...,
+    ) -> NDArray[float64]: ...
+    @overload
+    def standard_gamma(
+        self,
+        shape: _ArrayLikeFloat_co,
+        *,
+        out: NDArray[float64] = ...,
+    ) -> NDArray[float64]: ...
+    @overload
+    def standard_gamma(
+        self,
+        shape: _ArrayLikeFloat_co,
+        size: None | _ShapeLike = ...,
+        dtype: _DTypeLikeFloat32 = ...,
+        out: None | NDArray[float32] = ...,
+    ) -> NDArray[float32]: ...
+    @overload
+    def standard_gamma(
+        self,
+        shape: _ArrayLikeFloat_co,
+        size: None | _ShapeLike = ...,
+        dtype: _DTypeLikeFloat64 = ...,
+        out: None | NDArray[float64] = ...,
+    ) -> NDArray[float64]: ...
+    @overload
+    def gamma(self, shape: _FloatLike_co, scale: _FloatLike_co = ..., size: None = ...) -> float: ...  # type: ignore[misc]
+    @overload
+    def gamma(
+        self,
+        shape: _ArrayLikeFloat_co,
+        scale: _ArrayLikeFloat_co = ...,
+        size: None | _ShapeLike = ...,
+    ) -> NDArray[float64]: ...
+    @overload
+    def f(self, dfnum: _FloatLike_co, dfden: _FloatLike_co, size: None = ...) -> float: ...  # type: ignore[misc]
+    @overload
+    def f(
+        self, dfnum: _ArrayLikeFloat_co, dfden: _ArrayLikeFloat_co, size: None | _ShapeLike = ...
+    ) -> NDArray[float64]: ...
+    @overload
+    def noncentral_f(self, dfnum: _FloatLike_co, dfden: _FloatLike_co, nonc: _FloatLike_co, size: None = ...) -> float: ...  # type: ignore[misc]
+    @overload
+    def noncentral_f(
+        self,
+        dfnum: _ArrayLikeFloat_co,
+        dfden: _ArrayLikeFloat_co,
+        nonc: _ArrayLikeFloat_co,
+        size: None | _ShapeLike = ...,
+    ) -> NDArray[float64]: ...
+    @overload
+    def chisquare(self, df: _FloatLike_co, size: None = ...) -> float: ...  # type: ignore[misc]
+    @overload
+    def chisquare(
+        self, df: _ArrayLikeFloat_co, size: None | _ShapeLike = ...
+    ) -> NDArray[float64]: ...
+    @overload
+    def noncentral_chisquare(self, df: _FloatLike_co, nonc: _FloatLike_co, size: None = ...) -> float: ...  # type: ignore[misc]
+    @overload
+    def noncentral_chisquare(
+        self, df: _ArrayLikeFloat_co, nonc: _ArrayLikeFloat_co, size: None | _ShapeLike = ...
+    ) -> NDArray[float64]: ...
+    @overload
+    def standard_t(self, df: _FloatLike_co, size: None = ...) -> float: ...  # type: ignore[misc]
+    @overload
+    def standard_t(
+        self, df: _ArrayLikeFloat_co, size: None = ...
+    ) -> NDArray[float64]: ...
+    @overload
+    def standard_t(
+        self, df: _ArrayLikeFloat_co, size: _ShapeLike = ...
+    ) -> NDArray[float64]: ...
+    @overload
+    def vonmises(self, mu: _FloatLike_co, kappa: _FloatLike_co, size: None = ...) -> float: ...  # type: ignore[misc]
+    @overload
+    def vonmises(
+        self, mu: _ArrayLikeFloat_co, kappa: _ArrayLikeFloat_co, size: None | _ShapeLike = ...
+    ) -> NDArray[float64]: ...
+    @overload
+    def pareto(self, a: _FloatLike_co, size: None = ...) -> float: ...  # type: ignore[misc]
+    @overload
+    def pareto(
+        self, a: _ArrayLikeFloat_co, size: None | _ShapeLike = ...
+    ) -> NDArray[float64]: ...
+    @overload
+    def weibull(self, a: _FloatLike_co, size: None = ...) -> float: ...  # type: ignore[misc]
+    @overload
+    def weibull(
+        self, a: _ArrayLikeFloat_co, size: None | _ShapeLike = ...
+    ) -> NDArray[float64]: ...
+    @overload
+    def power(self, a: _FloatLike_co, size: None = ...) -> float: ...  # type: ignore[misc]
+    @overload
+    def power(
+        self, a: _ArrayLikeFloat_co, size: None | _ShapeLike = ...
+    ) -> NDArray[float64]: ...
+    @overload
+    def standard_cauchy(self, size: None = ...) -> float: ...  # type: ignore[misc]
+    @overload
+    def standard_cauchy(self, size: _ShapeLike = ...) -> NDArray[float64]: ...
+    @overload
+    def laplace(
+        self,
+        loc: _FloatLike_co = ...,
+        scale: _FloatLike_co = ...,
+        size: None = ...,
+    ) -> float: ...  # type: ignore[misc]
+    @overload
+    def laplace(
+        self,
+        loc: _ArrayLikeFloat_co = ...,
+        scale: _ArrayLikeFloat_co = ...,
+        size: None | _ShapeLike = ...,
+    ) -> NDArray[float64]: ...
+    @overload
+    def gumbel(
+        self,
+        loc: _FloatLike_co = ...,
+        scale: _FloatLike_co = ...,
+        size: None = ...,
+    ) -> float: ...  # type: ignore[misc]
+    @overload
+    def gumbel(
+        self,
+        loc: _ArrayLikeFloat_co = ...,
+        scale: _ArrayLikeFloat_co = ...,
+        size: None | _ShapeLike = ...,
+    ) -> NDArray[float64]: ...
+    @overload
+    def logistic(
+        self,
+        loc: _FloatLike_co = ...,
+        scale: _FloatLike_co = ...,
+        size: None = ...,
+    ) -> float: ...  # type: ignore[misc]
+    @overload
+    def logistic(
+        self,
+        loc: _ArrayLikeFloat_co = ...,
+        scale: _ArrayLikeFloat_co = ...,
+        size: None | _ShapeLike = ...,
+    ) -> NDArray[float64]: ...
+    @overload
+    def lognormal(
+        self,
+        mean: _FloatLike_co = ...,
+        sigma: _FloatLike_co = ...,
+        size: None = ...,
+    ) -> float: ...  # type: ignore[misc]
+    @overload
+    def lognormal(
+        self,
+        mean: _ArrayLikeFloat_co = ...,
+        sigma: _ArrayLikeFloat_co = ...,
+        size: None | _ShapeLike = ...,
+    ) -> NDArray[float64]: ...
+    @overload
+    def rayleigh(self, scale: _FloatLike_co = ..., size: None = ...) -> float: ...  # type: ignore[misc]
+    @overload
+    def rayleigh(
+        self, scale: _ArrayLikeFloat_co = ..., size: None | _ShapeLike = ...
+    ) -> NDArray[float64]: ...
+    @overload
+    def wald(self, mean: _FloatLike_co, scale: _FloatLike_co, size: None = ...) -> float: ...  # type: ignore[misc]
+    @overload
+    def wald(
+        self, mean: _ArrayLikeFloat_co, scale: _ArrayLikeFloat_co, size: None | _ShapeLike = ...
+    ) -> NDArray[float64]: ...
+    @overload
+    def triangular(
+        self,
+        left: _FloatLike_co,
+        mode: _FloatLike_co,
+        right: _FloatLike_co,
+        size: None = ...,
+    ) -> float: ...  # type: ignore[misc]
+    @overload
+    def triangular(
+        self,
+        left: _ArrayLikeFloat_co,
+        mode: _ArrayLikeFloat_co,
+        right: _ArrayLikeFloat_co,
+        size: None | _ShapeLike = ...,
+    ) -> NDArray[float64]: ...
+    @overload
+    def binomial(self, n: int, p: _FloatLike_co, size: None = ...) -> int: ...  # type: ignore[misc]
+    @overload
+    def binomial(
+        self, n: _ArrayLikeInt_co, p: _ArrayLikeFloat_co, size: None | _ShapeLike = ...
+    ) -> NDArray[int64]: ...
+    @overload
+    def negative_binomial(self, n: _FloatLike_co, p: _FloatLike_co, size: None = ...) -> int: ...  # type: ignore[misc]
+    @overload
+    def negative_binomial(
+        self, n: _ArrayLikeFloat_co, p: _ArrayLikeFloat_co, size: None | _ShapeLike = ...
+    ) -> NDArray[int64]: ...
+    @overload
+    def poisson(self, lam: _FloatLike_co = ..., size: None = ...) -> int: ...  # type: ignore[misc]
+    @overload
+    def poisson(
+        self, lam: _ArrayLikeFloat_co = ..., size: None | _ShapeLike = ...
+    ) -> NDArray[int64]: ...
+    @overload
+    def zipf(self, a: _FloatLike_co, size: None = ...) -> int: ...  # type: ignore[misc]
+    @overload
+    def zipf(
+        self, a: _ArrayLikeFloat_co, size: None | _ShapeLike = ...
+    ) -> NDArray[int64]: ...
+    @overload
+    def geometric(self, p: _FloatLike_co, size: None = ...) -> int: ...  # type: ignore[misc]
+    @overload
+    def geometric(
+        self, p: _ArrayLikeFloat_co, size: None | _ShapeLike = ...
+    ) -> NDArray[int64]: ...
+    @overload
+    def hypergeometric(self, ngood: int, nbad: int, nsample: int, size: None = ...) -> int: ...  # type: ignore[misc]
+    @overload
+    def hypergeometric(
+        self,
+        ngood: _ArrayLikeInt_co,
+        nbad: _ArrayLikeInt_co,
+        nsample: _ArrayLikeInt_co,
+        size: None | _ShapeLike = ...,
+    ) -> NDArray[int64]: ...
+    @overload
+    def logseries(self, p: _FloatLike_co, size: None = ...) -> int: ...  # type: ignore[misc]
+    @overload
+    def logseries(
+        self, p: _ArrayLikeFloat_co, size: None | _ShapeLike = ...
+    ) -> NDArray[int64]: ...
+    def multivariate_normal(
+        self,
+        mean: _ArrayLikeFloat_co,
+        cov: _ArrayLikeFloat_co,
+        size: None | _ShapeLike = ...,
+        check_valid: Literal["warn", "raise", "ignore"] = ...,
+        tol: float = ...,
+        *,
+        method: Literal["svd", "eigh", "cholesky"] = ...,
+    ) -> NDArray[float64]: ...
+    def multinomial(
+        self, n: _ArrayLikeInt_co,
+            pvals: _ArrayLikeFloat_co,
+            size: None | _ShapeLike = ...
+    ) -> NDArray[int64]: ...
+    def multivariate_hypergeometric(
+        self,
+        colors: _ArrayLikeInt_co,
+        nsample: int,
+        size: None | _ShapeLike = ...,
+        method: Literal["marginals", "count"] = ...,
+    ) -> NDArray[int64]: ...
+    def dirichlet(
+        self, alpha: _ArrayLikeFloat_co, size: None | _ShapeLike = ...
+    ) -> NDArray[float64]: ...
+    def permuted(
+        self, x: ArrayLike, *, axis: None | int = ..., out: None | NDArray[Any] = ...
+    ) -> NDArray[Any]: ...
+    def shuffle(self, x: ArrayLike, axis: int = ...) -> None: ...
+
+def default_rng(
+    seed: None | _ArrayLikeInt_co | SeedSequence | BitGenerator | Generator = ...
+) -> Generator: ...
diff --git a/venv/lib/python3.12/site-packages/numpy/random/_mt19937.cpython-312-darwin.so b/venv/lib/python3.12/site-packages/numpy/random/_mt19937.cpython-312-darwin.so
new file mode 100755
index 00000000..b1d6162f
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/random/_mt19937.cpython-312-darwin.so differ
diff --git a/venv/lib/python3.12/site-packages/numpy/random/_mt19937.pyi b/venv/lib/python3.12/site-packages/numpy/random/_mt19937.pyi
new file mode 100644
index 00000000..600411d5
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/random/_mt19937.pyi
@@ -0,0 +1,23 @@
+from typing import TypedDict
+
+from numpy import uint32
+from numpy.typing import NDArray
+from numpy.random.bit_generator import BitGenerator, SeedSequence
+from numpy._typing import _ArrayLikeInt_co
+
+class _MT19937Internal(TypedDict):
+    key: NDArray[uint32]
+    pos: int
+
+class _MT19937State(TypedDict):
+    bit_generator: str
+    state: _MT19937Internal
+
+class MT19937(BitGenerator):
+    def __init__(self, seed: None | _ArrayLikeInt_co | SeedSequence = ...) -> None: ...
+    def _legacy_seeding(self, seed: _ArrayLikeInt_co) -> None: ...
+    def jumped(self, jumps: int = ...) -> MT19937: ...
+    @property
+    def state(self) -> _MT19937State: ...
+    @state.setter
+    def state(self, value: _MT19937State) -> None: ...
diff --git a/venv/lib/python3.12/site-packages/numpy/random/_pcg64.cpython-312-darwin.so b/venv/lib/python3.12/site-packages/numpy/random/_pcg64.cpython-312-darwin.so
new file mode 100755
index 00000000..91b7f48d
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/random/_pcg64.cpython-312-darwin.so differ
diff --git a/venv/lib/python3.12/site-packages/numpy/random/_pcg64.pyi b/venv/lib/python3.12/site-packages/numpy/random/_pcg64.pyi
new file mode 100644
index 00000000..470aee86
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/random/_pcg64.pyi
@@ -0,0 +1,42 @@
+from typing import TypedDict
+
+from numpy.random.bit_generator import BitGenerator, SeedSequence
+from numpy._typing import _ArrayLikeInt_co
+
+class _PCG64Internal(TypedDict):
+    state: int
+    inc: int
+
+class _PCG64State(TypedDict):
+    bit_generator: str
+    state: _PCG64Internal
+    has_uint32: int
+    uinteger: int
+
+class PCG64(BitGenerator):
+    def __init__(self, seed: None | _ArrayLikeInt_co | SeedSequence = ...) -> None: ...
+    def jumped(self, jumps: int = ...) -> PCG64: ...
+    @property
+    def state(
+        self,
+    ) -> _PCG64State: ...
+    @state.setter
+    def state(
+        self,
+        value: _PCG64State,
+    ) -> None: ...
+    def advance(self, delta: int) -> PCG64: ...
+
+class PCG64DXSM(BitGenerator):
+    def __init__(self, seed: None | _ArrayLikeInt_co | SeedSequence = ...) -> None: ...
+    def jumped(self, jumps: int = ...) -> PCG64DXSM: ...
+    @property
+    def state(
+        self,
+    ) -> _PCG64State: ...
+    @state.setter
+    def state(
+        self,
+        value: _PCG64State,
+    ) -> None: ...
+    def advance(self, delta: int) -> PCG64DXSM: ...
diff --git a/venv/lib/python3.12/site-packages/numpy/random/_philox.cpython-312-darwin.so b/venv/lib/python3.12/site-packages/numpy/random/_philox.cpython-312-darwin.so
new file mode 100755
index 00000000..e84b7a3c
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/random/_philox.cpython-312-darwin.so differ
diff --git a/venv/lib/python3.12/site-packages/numpy/random/_philox.pyi b/venv/lib/python3.12/site-packages/numpy/random/_philox.pyi
new file mode 100644
index 00000000..485f3bc8
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/random/_philox.pyi
@@ -0,0 +1,37 @@
+from typing import TypedDict
+
+from numpy import uint64
+from numpy.typing import NDArray
+from numpy.random.bit_generator import BitGenerator, SeedSequence
+from numpy._typing import _ArrayLikeInt_co
+
+class _PhiloxInternal(TypedDict):
+    counter: NDArray[uint64]
+    key: NDArray[uint64]
+
+class _PhiloxState(TypedDict):
+    bit_generator: str
+    state: _PhiloxInternal
+    buffer: NDArray[uint64]
+    buffer_pos: int
+    has_uint32: int
+    uinteger: int
+
+class Philox(BitGenerator):
+    def __init__(
+        self,
+        seed: None | _ArrayLikeInt_co | SeedSequence = ...,
+        counter: None | _ArrayLikeInt_co = ...,
+        key: None | _ArrayLikeInt_co = ...,
+    ) -> None: ...
+    @property
+    def state(
+        self,
+    ) -> _PhiloxState: ...
+    @state.setter
+    def state(
+        self,
+        value: _PhiloxState,
+    ) -> None: ...
+    def jumped(self, jumps: int = ...) -> Philox: ...
+    def advance(self, delta: int) -> Philox: ...
diff --git a/venv/lib/python3.12/site-packages/numpy/random/_pickle.py b/venv/lib/python3.12/site-packages/numpy/random/_pickle.py
new file mode 100644
index 00000000..842bd441
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/random/_pickle.py
@@ -0,0 +1,89 @@
+from .bit_generator import BitGenerator
+from .mtrand import RandomState
+from ._philox import Philox
+from ._pcg64 import PCG64, PCG64DXSM
+from ._sfc64 import SFC64
+
+from ._generator import Generator
+from ._mt19937 import MT19937
+
+BitGenerators = {'MT19937': MT19937,
+                 'PCG64': PCG64,
+                 'PCG64DXSM': PCG64DXSM,
+                 'Philox': Philox,
+                 'SFC64': SFC64,
+                 }
+
+
+def __bit_generator_ctor(bit_generator: str | type[BitGenerator] = 'MT19937'):
+    """
+    Pickling helper function that returns a bit generator object
+
+    Parameters
+    ----------
+    bit_generator : type[BitGenerator] or str
+        BitGenerator class or string containing the name of the BitGenerator
+
+    Returns
+    -------
+    BitGenerator
+        BitGenerator instance
+    """
+    if isinstance(bit_generator, type):
+        bit_gen_class = bit_generator
+    elif bit_generator in BitGenerators:
+        bit_gen_class = BitGenerators[bit_generator]
+    else:
+        raise ValueError(
+            str(bit_generator) + ' is not a known BitGenerator module.'
+        )
+
+    return bit_gen_class()
+
+
+def __generator_ctor(bit_generator_name="MT19937",
+                     bit_generator_ctor=__bit_generator_ctor):
+    """
+    Pickling helper function that returns a Generator object
+
+    Parameters
+    ----------
+    bit_generator_name : str or BitGenerator
+        String containing the core BitGenerator's name or a
+        BitGenerator instance
+    bit_generator_ctor : callable, optional
+        Callable function that takes bit_generator_name as its only argument
+        and returns an instantized bit generator.
+
+    Returns
+    -------
+    rg : Generator
+        Generator using the named core BitGenerator
+    """
+    if isinstance(bit_generator_name, BitGenerator):
+        return Generator(bit_generator_name)
+    # Legacy path that uses a bit generator name and ctor
+    return Generator(bit_generator_ctor(bit_generator_name))
+
+
+def __randomstate_ctor(bit_generator_name="MT19937",
+                       bit_generator_ctor=__bit_generator_ctor):
+    """
+    Pickling helper function that returns a legacy RandomState-like object
+
+    Parameters
+    ----------
+    bit_generator_name : str
+        String containing the core BitGenerator's name
+    bit_generator_ctor : callable, optional
+        Callable function that takes bit_generator_name as its only argument
+        and returns an instantized bit generator.
+
+    Returns
+    -------
+    rs : RandomState
+        Legacy RandomState using the named core BitGenerator
+    """
+    if isinstance(bit_generator_name, BitGenerator):
+        return RandomState(bit_generator_name)
+    return RandomState(bit_generator_ctor(bit_generator_name))
diff --git a/venv/lib/python3.12/site-packages/numpy/random/_sfc64.cpython-312-darwin.so b/venv/lib/python3.12/site-packages/numpy/random/_sfc64.cpython-312-darwin.so
new file mode 100755
index 00000000..9446a830
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/random/_sfc64.cpython-312-darwin.so differ
diff --git a/venv/lib/python3.12/site-packages/numpy/random/_sfc64.pyi b/venv/lib/python3.12/site-packages/numpy/random/_sfc64.pyi
new file mode 100644
index 00000000..09ea4113
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/random/_sfc64.pyi
@@ -0,0 +1,26 @@
+from typing import TypedDict
+
+from numpy import uint64
+from numpy.random.bit_generator import BitGenerator, SeedSequence
+from numpy._typing import NDArray, _ArrayLikeInt_co
+
+class _SFC64Internal(TypedDict):
+    state: NDArray[uint64]
+
+class _SFC64State(TypedDict):
+    bit_generator: str
+    state: _SFC64Internal
+    has_uint32: int
+    uinteger: int
+
+class SFC64(BitGenerator):
+    def __init__(self, seed: None | _ArrayLikeInt_co | SeedSequence = ...) -> None: ...
+    @property
+    def state(
+        self,
+    ) -> _SFC64State: ...
+    @state.setter
+    def state(
+        self,
+        value: _SFC64State,
+    ) -> None: ...
diff --git a/venv/lib/python3.12/site-packages/numpy/random/bit_generator.cpython-312-darwin.so b/venv/lib/python3.12/site-packages/numpy/random/bit_generator.cpython-312-darwin.so
new file mode 100755
index 00000000..5a675d98
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/random/bit_generator.cpython-312-darwin.so differ
diff --git a/venv/lib/python3.12/site-packages/numpy/random/bit_generator.pxd b/venv/lib/python3.12/site-packages/numpy/random/bit_generator.pxd
new file mode 100644
index 00000000..dfa7d0a7
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/random/bit_generator.pxd
@@ -0,0 +1,35 @@
+cimport numpy as np
+from libc.stdint cimport uint32_t, uint64_t
+
+cdef extern from "numpy/random/bitgen.h":
+    struct bitgen:
+        void *state
+        uint64_t (*next_uint64)(void *st) nogil
+        uint32_t (*next_uint32)(void *st) nogil
+        double (*next_double)(void *st) nogil
+        uint64_t (*next_raw)(void *st) nogil
+
+    ctypedef bitgen bitgen_t
+
+cdef class BitGenerator():
+    cdef readonly object _seed_seq
+    cdef readonly object lock
+    cdef bitgen_t _bitgen
+    cdef readonly object _ctypes
+    cdef readonly object _cffi
+    cdef readonly object capsule
+
+
+cdef class SeedSequence():
+    cdef readonly object entropy
+    cdef readonly tuple spawn_key
+    cdef readonly Py_ssize_t pool_size
+    cdef readonly object pool
+    cdef readonly uint32_t n_children_spawned
+
+    cdef mix_entropy(self, np.ndarray[np.npy_uint32, ndim=1] mixer,
+                     np.ndarray[np.npy_uint32, ndim=1] entropy_array)
+    cdef get_assembled_entropy(self)
+
+cdef class SeedlessSequence():
+    pass
diff --git a/venv/lib/python3.12/site-packages/numpy/random/bit_generator.pyi b/venv/lib/python3.12/site-packages/numpy/random/bit_generator.pyi
new file mode 100644
index 00000000..d99278e8
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/random/bit_generator.pyi
@@ -0,0 +1,124 @@
+import abc
+from threading import Lock
+from collections.abc import Callable, Mapping, Sequence
+from typing import (
+    Any,
+    NamedTuple,
+    TypedDict,
+    TypeVar,
+    overload,
+    Literal,
+)
+
+from numpy import dtype, uint32, uint64
+from numpy._typing import (
+    NDArray,
+    _ArrayLikeInt_co,
+    _ShapeLike,
+    _SupportsDType,
+    _UInt32Codes,
+    _UInt64Codes,
+)
+
+_T = TypeVar("_T")
+
+_DTypeLikeUint32 = (
+    dtype[uint32]
+    | _SupportsDType[dtype[uint32]]
+    | type[uint32]
+    | _UInt32Codes
+)
+_DTypeLikeUint64 = (
+    dtype[uint64]
+    | _SupportsDType[dtype[uint64]]
+    | type[uint64]
+    | _UInt64Codes
+)
+
+class _SeedSeqState(TypedDict):
+    entropy: None | int | Sequence[int]
+    spawn_key: tuple[int, ...]
+    pool_size: int
+    n_children_spawned: int
+
+class _Interface(NamedTuple):
+    state_address: Any
+    state: Any
+    next_uint64: Any
+    next_uint32: Any
+    next_double: Any
+    bit_generator: Any
+
+class ISeedSequence(abc.ABC):
+    @abc.abstractmethod
+    def generate_state(
+        self, n_words: int, dtype: _DTypeLikeUint32 | _DTypeLikeUint64 = ...
+    ) -> NDArray[uint32 | uint64]: ...
+
+class ISpawnableSeedSequence(ISeedSequence):
+    @abc.abstractmethod
+    def spawn(self: _T, n_children: int) -> list[_T]: ...
+
+class SeedlessSeedSequence(ISpawnableSeedSequence):
+    def generate_state(
+        self, n_words: int, dtype: _DTypeLikeUint32 | _DTypeLikeUint64 = ...
+    ) -> NDArray[uint32 | uint64]: ...
+    def spawn(self: _T, n_children: int) -> list[_T]: ...
+
+class SeedSequence(ISpawnableSeedSequence):
+    entropy: None | int | Sequence[int]
+    spawn_key: tuple[int, ...]
+    pool_size: int
+    n_children_spawned: int
+    pool: NDArray[uint32]
+    def __init__(
+        self,
+        entropy: None | int | Sequence[int] | _ArrayLikeInt_co = ...,
+        *,
+        spawn_key: Sequence[int] = ...,
+        pool_size: int = ...,
+        n_children_spawned: int = ...,
+    ) -> None: ...
+    def __repr__(self) -> str: ...
+    @property
+    def state(
+        self,
+    ) -> _SeedSeqState: ...
+    def generate_state(
+        self, n_words: int, dtype: _DTypeLikeUint32 | _DTypeLikeUint64 = ...
+    ) -> NDArray[uint32 | uint64]: ...
+    def spawn(self, n_children: int) -> list[SeedSequence]: ...
+
+class BitGenerator(abc.ABC):
+    lock: Lock
+    def __init__(self, seed: None | _ArrayLikeInt_co | SeedSequence = ...) -> None: ...
+    def __getstate__(self) -> tuple[dict[str, Any], ISeedSequence]: ...
+    def __setstate__(
+            self, state_seed_seq: dict[str, Any] | tuple[dict[str, Any], ISeedSequence]
+    ) -> None: ...
+    def __reduce__(
+        self,
+    ) -> tuple[
+        Callable[[str], BitGenerator],
+        tuple[str],
+        tuple[dict[str, Any], ISeedSequence]
+    ]: ...
+    @abc.abstractmethod
+    @property
+    def state(self) -> Mapping[str, Any]: ...
+    @state.setter
+    def state(self, value: Mapping[str, Any]) -> None: ...
+    @property
+    def seed_seq(self) -> ISeedSequence: ...
+    def spawn(self, n_children: int) -> list[BitGenerator]: ...
+    @overload
+    def random_raw(self, size: None = ..., output: Literal[True] = ...) -> int: ...  # type: ignore[misc]
+    @overload
+    def random_raw(self, size: _ShapeLike = ..., output: Literal[True] = ...) -> NDArray[uint64]: ...  # type: ignore[misc]
+    @overload
+    def random_raw(self, size: None | _ShapeLike = ..., output: Literal[False] = ...) -> None: ...  # type: ignore[misc]
+    def _benchmark(self, cnt: int, method: str = ...) -> None: ...
+    @property
+    def ctypes(self) -> _Interface: ...
+    @property
+    def cffi(self) -> _Interface: ...
diff --git a/venv/lib/python3.12/site-packages/numpy/random/c_distributions.pxd b/venv/lib/python3.12/site-packages/numpy/random/c_distributions.pxd
new file mode 100644
index 00000000..b978d135
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/random/c_distributions.pxd
@@ -0,0 +1,120 @@
+#!python
+#cython: wraparound=False, nonecheck=False, boundscheck=False, cdivision=True, language_level=3
+from numpy cimport npy_intp
+
+from libc.stdint cimport (uint64_t, int32_t, int64_t)
+from numpy.random cimport bitgen_t
+
+cdef extern from "numpy/random/distributions.h":
+
+    struct s_binomial_t:
+        int has_binomial
+        double psave
+        int64_t nsave
+        double r
+        double q
+        double fm
+        int64_t m
+        double p1
+        double xm
+        double xl
+        double xr
+        double c
+        double laml
+        double lamr
+        double p2
+        double p3
+        double p4
+
+    ctypedef s_binomial_t binomial_t
+
+    float random_standard_uniform_f(bitgen_t *bitgen_state) nogil
+    double random_standard_uniform(bitgen_t *bitgen_state) nogil
+    void random_standard_uniform_fill(bitgen_t* bitgen_state, npy_intp cnt, double *out) nogil
+    void random_standard_uniform_fill_f(bitgen_t *bitgen_state, npy_intp cnt, float *out) nogil
+    
+    double random_standard_exponential(bitgen_t *bitgen_state) nogil
+    float random_standard_exponential_f(bitgen_t *bitgen_state) nogil
+    void random_standard_exponential_fill(bitgen_t *bitgen_state, npy_intp cnt, double *out) nogil
+    void random_standard_exponential_fill_f(bitgen_t *bitgen_state, npy_intp cnt, float *out) nogil
+    void random_standard_exponential_inv_fill(bitgen_t *bitgen_state, npy_intp cnt, double *out) nogil
+    void random_standard_exponential_inv_fill_f(bitgen_t *bitgen_state, npy_intp cnt, float *out) nogil
+    
+    double random_standard_normal(bitgen_t* bitgen_state) nogil
+    float random_standard_normal_f(bitgen_t *bitgen_state) nogil
+    void random_standard_normal_fill(bitgen_t *bitgen_state, npy_intp count, double *out) nogil
+    void random_standard_normal_fill_f(bitgen_t *bitgen_state, npy_intp count, float *out) nogil
+    double random_standard_gamma(bitgen_t *bitgen_state, double shape) nogil
+    float random_standard_gamma_f(bitgen_t *bitgen_state, float shape) nogil
+
+    float random_standard_uniform_f(bitgen_t *bitgen_state) nogil
+    void random_standard_uniform_fill_f(bitgen_t* bitgen_state, npy_intp cnt, float *out) nogil
+    float random_standard_normal_f(bitgen_t* bitgen_state) nogil
+    float random_standard_gamma_f(bitgen_t *bitgen_state, float shape) nogil
+
+    int64_t random_positive_int64(bitgen_t *bitgen_state) nogil
+    int32_t random_positive_int32(bitgen_t *bitgen_state) nogil
+    int64_t random_positive_int(bitgen_t *bitgen_state) nogil
+    uint64_t random_uint(bitgen_t *bitgen_state) nogil
+
+    double random_normal(bitgen_t *bitgen_state, double loc, double scale) nogil
+
+    double random_gamma(bitgen_t *bitgen_state, double shape, double scale) nogil
+    float random_gamma_f(bitgen_t *bitgen_state, float shape, float scale) nogil
+
+    double random_exponential(bitgen_t *bitgen_state, double scale) nogil
+    double random_uniform(bitgen_t *bitgen_state, double lower, double range) nogil
+    double random_beta(bitgen_t *bitgen_state, double a, double b) nogil
+    double random_chisquare(bitgen_t *bitgen_state, double df) nogil
+    double random_f(bitgen_t *bitgen_state, double dfnum, double dfden) nogil
+    double random_standard_cauchy(bitgen_t *bitgen_state) nogil
+    double random_pareto(bitgen_t *bitgen_state, double a) nogil
+    double random_weibull(bitgen_t *bitgen_state, double a) nogil
+    double random_power(bitgen_t *bitgen_state, double a) nogil
+    double random_laplace(bitgen_t *bitgen_state, double loc, double scale) nogil
+    double random_gumbel(bitgen_t *bitgen_state, double loc, double scale) nogil
+    double random_logistic(bitgen_t *bitgen_state, double loc, double scale) nogil
+    double random_lognormal(bitgen_t *bitgen_state, double mean, double sigma) nogil
+    double random_rayleigh(bitgen_t *bitgen_state, double mode) nogil
+    double random_standard_t(bitgen_t *bitgen_state, double df) nogil
+    double random_noncentral_chisquare(bitgen_t *bitgen_state, double df,
+                                       double nonc) nogil
+    double random_noncentral_f(bitgen_t *bitgen_state, double dfnum,
+                               double dfden, double nonc) nogil
+    double random_wald(bitgen_t *bitgen_state, double mean, double scale) nogil
+    double random_vonmises(bitgen_t *bitgen_state, double mu, double kappa) nogil
+    double random_triangular(bitgen_t *bitgen_state, double left, double mode,
+                             double right) nogil
+
+    int64_t random_poisson(bitgen_t *bitgen_state, double lam) nogil
+    int64_t random_negative_binomial(bitgen_t *bitgen_state, double n, double p) nogil
+    int64_t random_binomial(bitgen_t *bitgen_state, double p, int64_t n, binomial_t *binomial) nogil
+    int64_t random_logseries(bitgen_t *bitgen_state, double p) nogil
+    int64_t random_geometric_search(bitgen_t *bitgen_state, double p) nogil
+    int64_t random_geometric_inversion(bitgen_t *bitgen_state, double p) nogil
+    int64_t random_geometric(bitgen_t *bitgen_state, double p) nogil
+    int64_t random_zipf(bitgen_t *bitgen_state, double a) nogil
+    int64_t random_hypergeometric(bitgen_t *bitgen_state, int64_t good, int64_t bad,
+                                    int64_t sample) nogil
+
+    uint64_t random_interval(bitgen_t *bitgen_state, uint64_t max) nogil
+
+    # Generate random uint64 numbers in closed interval [off, off + rng].
+    uint64_t random_bounded_uint64(bitgen_t *bitgen_state,
+                                   uint64_t off, uint64_t rng,
+                                   uint64_t mask, bint use_masked) nogil
+
+    void random_multinomial(bitgen_t *bitgen_state, int64_t n, int64_t *mnix,
+                            double *pix, npy_intp d, binomial_t *binomial) nogil
+
+    int random_multivariate_hypergeometric_count(bitgen_t *bitgen_state,
+                          int64_t total,
+                          size_t num_colors, int64_t *colors,
+                          int64_t nsample,
+                          size_t num_variates, int64_t *variates) nogil
+    void random_multivariate_hypergeometric_marginals(bitgen_t *bitgen_state,
+                               int64_t total,
+                               size_t num_colors, int64_t *colors,
+                               int64_t nsample,
+                               size_t num_variates, int64_t *variates) nogil
+
diff --git a/venv/lib/python3.12/site-packages/numpy/random/lib/libnpyrandom.a b/venv/lib/python3.12/site-packages/numpy/random/lib/libnpyrandom.a
new file mode 100644
index 00000000..d393b8b3
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/random/lib/libnpyrandom.a differ
diff --git a/venv/lib/python3.12/site-packages/numpy/random/mtrand.cpython-312-darwin.so b/venv/lib/python3.12/site-packages/numpy/random/mtrand.cpython-312-darwin.so
new file mode 100755
index 00000000..80f6d88b
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/random/mtrand.cpython-312-darwin.so differ
diff --git a/venv/lib/python3.12/site-packages/numpy/random/mtrand.pyi b/venv/lib/python3.12/site-packages/numpy/random/mtrand.pyi
new file mode 100644
index 00000000..dbd3cd60
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/random/mtrand.pyi
@@ -0,0 +1,681 @@
+import builtins
+from collections.abc import Callable
+from typing import Any, overload, Literal
+
+import numpy as np
+from numpy import (
+    dtype,
+    float32,
+    float64,
+    int8,
+    int16,
+    int32,
+    int64,
+    int_,
+    long,
+    uint8,
+    uint16,
+    uint32,
+    uint64,
+    uint,
+    ulong,
+)
+from numpy.random.bit_generator import BitGenerator
+from numpy._typing import (
+    ArrayLike,
+    NDArray,
+    _ArrayLikeFloat_co,
+    _ArrayLikeInt_co,
+    _DoubleCodes,
+    _DTypeLikeBool,
+    _DTypeLikeInt,
+    _DTypeLikeUInt,
+    _Float32Codes,
+    _Float64Codes,
+    _Int8Codes,
+    _Int16Codes,
+    _Int32Codes,
+    _Int64Codes,
+    _IntCodes,
+    _LongCodes,
+    _ShapeLike,
+    _SingleCodes,
+    _SupportsDType,
+    _UInt8Codes,
+    _UInt16Codes,
+    _UInt32Codes,
+    _UInt64Codes,
+    _UIntCodes,
+    _ULongCodes,
+)
+
+_DTypeLikeFloat32 = (
+    dtype[float32]
+    | _SupportsDType[dtype[float32]]
+    | type[float32]
+    | _Float32Codes
+    | _SingleCodes
+)
+
+_DTypeLikeFloat64 = (
+    dtype[float64]
+    | _SupportsDType[dtype[float64]]
+    | type[float]
+    | type[float64]
+    | _Float64Codes
+    | _DoubleCodes
+)
+
+class RandomState:
+    _bit_generator: BitGenerator
+    def __init__(self, seed: None | _ArrayLikeInt_co | BitGenerator = ...) -> None: ...
+    def __repr__(self) -> str: ...
+    def __str__(self) -> str: ...
+    def __getstate__(self) -> dict[str, Any]: ...
+    def __setstate__(self, state: dict[str, Any]) -> None: ...
+    def __reduce__(self) -> tuple[Callable[[BitGenerator], RandomState], tuple[BitGenerator], dict[str, Any]]: ...
+    def seed(self, seed: None | _ArrayLikeFloat_co = ...) -> None: ...
+    @overload
+    def get_state(self, legacy: Literal[False] = ...) -> dict[str, Any]: ...
+    @overload
+    def get_state(
+        self, legacy: Literal[True] = ...
+    ) -> dict[str, Any] | tuple[str, NDArray[uint32], int, int, float]: ...
+    def set_state(
+        self, state: dict[str, Any] | tuple[str, NDArray[uint32], int, int, float]
+    ) -> None: ...
+    @overload
+    def random_sample(self, size: None = ...) -> float: ...  # type: ignore[misc]
+    @overload
+    def random_sample(self, size: _ShapeLike) -> NDArray[float64]: ...
+    @overload
+    def random(self, size: None = ...) -> float: ...  # type: ignore[misc]
+    @overload
+    def random(self, size: _ShapeLike) -> NDArray[float64]: ...
+    @overload
+    def beta(self, a: float, b: float, size: None = ...) -> float: ...  # type: ignore[misc]
+    @overload
+    def beta(
+        self, a: _ArrayLikeFloat_co, b: _ArrayLikeFloat_co, size: None | _ShapeLike = ...
+    ) -> NDArray[float64]: ...
+    @overload
+    def exponential(self, scale: float = ..., size: None = ...) -> float: ...  # type: ignore[misc]
+    @overload
+    def exponential(
+        self, scale: _ArrayLikeFloat_co = ..., size: None | _ShapeLike = ...
+    ) -> NDArray[float64]: ...
+    @overload
+    def standard_exponential(self, size: None = ...) -> float: ...  # type: ignore[misc]
+    @overload
+    def standard_exponential(self, size: _ShapeLike) -> NDArray[float64]: ...
+    @overload
+    def tomaxint(self, size: None = ...) -> int: ...  # type: ignore[misc]
+    @overload
+    # Generates long values, but stores it in a 64bit int:
+    def tomaxint(self, size: _ShapeLike) -> NDArray[int64]: ...
+    @overload
+    def randint(  # type: ignore[misc]
+        self,
+        low: int,
+        high: None | int = ...,
+        size: None = ...,
+    ) -> int: ...
+    @overload
+    def randint(  # type: ignore[misc]
+        self,
+        low: int,
+        high: None | int = ...,
+        size: None = ...,
+        dtype: type[bool] = ...,
+    ) -> bool: ...
+    @overload
+    def randint(  # type: ignore[misc]
+        self,
+        low: int,
+        high: None | int = ...,
+        size: None = ...,
+        dtype: type[np.bool] = ...,
+    ) -> np.bool: ...
+    @overload
+    def randint(  # type: ignore[misc]
+        self,
+        low: int,
+        high: None | int = ...,
+        size: None = ...,
+        dtype: type[int] = ...,
+    ) -> int: ...
+    @overload
+    def randint(  # type: ignore[misc]
+        self,
+        low: int,
+        high: None | int = ...,
+        size: None = ...,
+        dtype: dtype[uint8] | type[uint8] | _UInt8Codes | _SupportsDType[dtype[uint8]] = ...,
+    ) -> uint8: ...
+    @overload
+    def randint(  # type: ignore[misc]
+        self,
+        low: int,
+        high: None | int = ...,
+        size: None = ...,
+        dtype: dtype[uint16] | type[uint16] | _UInt16Codes | _SupportsDType[dtype[uint16]] = ...,
+    ) -> uint16: ...
+    @overload
+    def randint(  # type: ignore[misc]
+        self,
+        low: int,
+        high: None | int = ...,
+        size: None = ...,
+        dtype: dtype[uint32] | type[uint32] | _UInt32Codes | _SupportsDType[dtype[uint32]] = ...,
+    ) -> uint32: ...
+    @overload
+    def randint(  # type: ignore[misc]
+        self,
+        low: int,
+        high: None | int = ...,
+        size: None = ...,
+        dtype: dtype[uint] | type[uint] | _UIntCodes | _SupportsDType[dtype[uint]] = ...,
+    ) -> uint: ...
+    @overload
+    def randint(  # type: ignore[misc]
+        self,
+        low: int,
+        high: None | int = ...,
+        size: None = ...,
+        dtype: dtype[ulong] | type[ulong] | _ULongCodes | _SupportsDType[dtype[ulong]] = ...,
+    ) -> ulong: ...
+    @overload
+    def randint(  # type: ignore[misc]
+        self,
+        low: int,
+        high: None | int = ...,
+        size: None = ...,
+        dtype: dtype[uint64] | type[uint64] | _UInt64Codes | _SupportsDType[dtype[uint64]] = ...,
+    ) -> uint64: ...
+    @overload
+    def randint(  # type: ignore[misc]
+        self,
+        low: int,
+        high: None | int = ...,
+        size: None = ...,
+        dtype: dtype[int8] | type[int8] | _Int8Codes | _SupportsDType[dtype[int8]] = ...,
+    ) -> int8: ...
+    @overload
+    def randint(  # type: ignore[misc]
+        self,
+        low: int,
+        high: None | int = ...,
+        size: None = ...,
+        dtype: dtype[int16] | type[int16] | _Int16Codes | _SupportsDType[dtype[int16]] = ...,
+    ) -> int16: ...
+    @overload
+    def randint(  # type: ignore[misc]
+        self,
+        low: int,
+        high: None | int = ...,
+        size: None = ...,
+        dtype: dtype[int32] | type[int32] | _Int32Codes | _SupportsDType[dtype[int32]] = ...,
+    ) -> int32: ...
+    @overload
+    def randint(  # type: ignore[misc]
+        self,
+        low: int,
+        high: None | int = ...,
+        size: None = ...,
+        dtype: dtype[int_] | type[int_] | _IntCodes | _SupportsDType[dtype[int_]] = ...,
+    ) -> int_: ...
+    @overload
+    def randint(  # type: ignore[misc]
+        self,
+        low: int,
+        high: None | int = ...,
+        size: None = ...,
+        dtype: dtype[long] | type[long] | _LongCodes | _SupportsDType[dtype[long]] = ...,
+    ) -> long: ...
+    @overload
+    def randint(  # type: ignore[misc]
+        self,
+        low: int,
+        high: None | int = ...,
+        size: None = ...,
+        dtype: dtype[int64] | type[int64] | _Int64Codes | _SupportsDType[dtype[int64]] = ...,
+    ) -> int64: ...
+    @overload
+    def randint(  # type: ignore[misc]
+        self,
+        low: _ArrayLikeInt_co,
+        high: None | _ArrayLikeInt_co = ...,
+        size: None | _ShapeLike = ...,
+    ) -> NDArray[long]: ...
+    @overload
+    def randint(  # type: ignore[misc]
+        self,
+        low: _ArrayLikeInt_co,
+        high: None | _ArrayLikeInt_co = ...,
+        size: None | _ShapeLike = ...,
+        dtype: _DTypeLikeBool = ...,
+    ) -> NDArray[np.bool]: ...
+    @overload
+    def randint(  # type: ignore[misc]
+        self,
+        low: _ArrayLikeInt_co,
+        high: None | _ArrayLikeInt_co = ...,
+        size: None | _ShapeLike = ...,
+        dtype: dtype[int8] | type[int8] | _Int8Codes | _SupportsDType[dtype[int8]] = ...,
+    ) -> NDArray[int8]: ...
+    @overload
+    def randint(  # type: ignore[misc]
+        self,
+        low: _ArrayLikeInt_co,
+        high: None | _ArrayLikeInt_co = ...,
+        size: None | _ShapeLike = ...,
+        dtype: dtype[int16] | type[int16] | _Int16Codes | _SupportsDType[dtype[int16]] = ...,
+    ) -> NDArray[int16]: ...
+    @overload
+    def randint(  # type: ignore[misc]
+        self,
+        low: _ArrayLikeInt_co,
+        high: None | _ArrayLikeInt_co = ...,
+        size: None | _ShapeLike = ...,
+        dtype: dtype[int32] | type[int32] | _Int32Codes | _SupportsDType[dtype[int32]] = ...,
+    ) -> NDArray[int32]: ...
+    @overload
+    def randint(  # type: ignore[misc]
+        self,
+        low: _ArrayLikeInt_co,
+        high: None | _ArrayLikeInt_co = ...,
+        size: None | _ShapeLike = ...,
+        dtype: None | dtype[int64] | type[int64] | _Int64Codes | _SupportsDType[dtype[int64]] = ...,
+    ) -> NDArray[int64]: ...
+    @overload
+    def randint(  # type: ignore[misc]
+        self,
+        low: _ArrayLikeInt_co,
+        high: None | _ArrayLikeInt_co = ...,
+        size: None | _ShapeLike = ...,
+        dtype: dtype[uint8] | type[uint8] | _UInt8Codes | _SupportsDType[dtype[uint8]] = ...,
+    ) -> NDArray[uint8]: ...
+    @overload
+    def randint(  # type: ignore[misc]
+        self,
+        low: _ArrayLikeInt_co,
+        high: None | _ArrayLikeInt_co = ...,
+        size: None | _ShapeLike = ...,
+        dtype: dtype[uint16] | type[uint16] | _UInt16Codes | _SupportsDType[dtype[uint16]] = ...,
+    ) -> NDArray[uint16]: ...
+    @overload
+    def randint(  # type: ignore[misc]
+        self,
+        low: _ArrayLikeInt_co,
+        high: None | _ArrayLikeInt_co = ...,
+        size: None | _ShapeLike = ...,
+        dtype: dtype[uint32] | type[uint32] | _UInt32Codes | _SupportsDType[dtype[uint32]] = ...,
+    ) -> NDArray[uint32]: ...
+    @overload
+    def randint(  # type: ignore[misc]
+        self,
+        low: _ArrayLikeInt_co,
+        high: None | _ArrayLikeInt_co = ...,
+        size: None | _ShapeLike = ...,
+        dtype: dtype[uint64] | type[uint64] | _UInt64Codes | _SupportsDType[dtype[uint64]] = ...,
+    ) -> NDArray[uint64]: ...
+    @overload
+    def randint(  # type: ignore[misc]
+        self,
+        low: _ArrayLikeInt_co,
+        high: None | _ArrayLikeInt_co = ...,
+        size: None | _ShapeLike = ...,
+        dtype: dtype[long] | type[int] | type[long] | _LongCodes | _SupportsDType[dtype[long]] = ...,
+    ) -> NDArray[long]: ...
+    @overload
+    def randint(  # type: ignore[misc]
+        self,
+        low: _ArrayLikeInt_co,
+        high: None | _ArrayLikeInt_co = ...,
+        size: None | _ShapeLike = ...,
+        dtype: dtype[ulong] | type[ulong] | _ULongCodes | _SupportsDType[dtype[ulong]] = ...,
+    ) -> NDArray[ulong]: ...
+    def bytes(self, length: int) -> builtins.bytes: ...
+    @overload
+    def choice(
+        self,
+        a: int,
+        size: None = ...,
+        replace: bool = ...,
+        p: None | _ArrayLikeFloat_co = ...,
+    ) -> int: ...
+    @overload
+    def choice(
+        self,
+        a: int,
+        size: _ShapeLike = ...,
+        replace: bool = ...,
+        p: None | _ArrayLikeFloat_co = ...,
+    ) -> NDArray[long]: ...
+    @overload
+    def choice(
+        self,
+        a: ArrayLike,
+        size: None = ...,
+        replace: bool = ...,
+        p: None | _ArrayLikeFloat_co = ...,
+    ) -> Any: ...
+    @overload
+    def choice(
+        self,
+        a: ArrayLike,
+        size: _ShapeLike = ...,
+        replace: bool = ...,
+        p: None | _ArrayLikeFloat_co = ...,
+    ) -> NDArray[Any]: ...
+    @overload
+    def uniform(self, low: float = ..., high: float = ..., size: None = ...) -> float: ...  # type: ignore[misc]
+    @overload
+    def uniform(
+        self,
+        low: _ArrayLikeFloat_co = ...,
+        high: _ArrayLikeFloat_co = ...,
+        size: None | _ShapeLike = ...,
+    ) -> NDArray[float64]: ...
+    @overload
+    def rand(self) -> float: ...
+    @overload
+    def rand(self, *args: int) -> NDArray[float64]: ...
+    @overload
+    def randn(self) -> float: ...
+    @overload
+    def randn(self, *args: int) -> NDArray[float64]: ...
+    @overload
+    def random_integers(self, low: int, high: None | int = ..., size: None = ...) -> int: ...  # type: ignore[misc]
+    @overload
+    def random_integers(
+        self,
+        low: _ArrayLikeInt_co,
+        high: None | _ArrayLikeInt_co = ...,
+        size: None | _ShapeLike = ...,
+    ) -> NDArray[long]: ...
+    @overload
+    def standard_normal(self, size: None = ...) -> float: ...  # type: ignore[misc]
+    @overload
+    def standard_normal(  # type: ignore[misc]
+        self, size: _ShapeLike = ...
+    ) -> NDArray[float64]: ...
+    @overload
+    def normal(self, loc: float = ..., scale: float = ..., size: None = ...) -> float: ...  # type: ignore[misc]
+    @overload
+    def normal(
+        self,
+        loc: _ArrayLikeFloat_co = ...,
+        scale: _ArrayLikeFloat_co = ...,
+        size: None | _ShapeLike = ...,
+    ) -> NDArray[float64]: ...
+    @overload
+    def standard_gamma(  # type: ignore[misc]
+        self,
+        shape: float,
+        size: None = ...,
+    ) -> float: ...
+    @overload
+    def standard_gamma(
+        self,
+        shape: _ArrayLikeFloat_co,
+        size: None | _ShapeLike = ...,
+    ) -> NDArray[float64]: ...
+    @overload
+    def gamma(self, shape: float, scale: float = ..., size: None = ...) -> float: ...  # type: ignore[misc]
+    @overload
+    def gamma(
+        self,
+        shape: _ArrayLikeFloat_co,
+        scale: _ArrayLikeFloat_co = ...,
+        size: None | _ShapeLike = ...,
+    ) -> NDArray[float64]: ...
+    @overload
+    def f(self, dfnum: float, dfden: float, size: None = ...) -> float: ...  # type: ignore[misc]
+    @overload
+    def f(
+        self, dfnum: _ArrayLikeFloat_co, dfden: _ArrayLikeFloat_co, size: None | _ShapeLike = ...
+    ) -> NDArray[float64]: ...
+    @overload
+    def noncentral_f(self, dfnum: float, dfden: float, nonc: float, size: None = ...) -> float: ...  # type: ignore[misc]
+    @overload
+    def noncentral_f(
+        self,
+        dfnum: _ArrayLikeFloat_co,
+        dfden: _ArrayLikeFloat_co,
+        nonc: _ArrayLikeFloat_co,
+        size: None | _ShapeLike = ...,
+    ) -> NDArray[float64]: ...
+    @overload
+    def chisquare(self, df: float, size: None = ...) -> float: ...  # type: ignore[misc]
+    @overload
+    def chisquare(
+        self, df: _ArrayLikeFloat_co, size: None | _ShapeLike = ...
+    ) -> NDArray[float64]: ...
+    @overload
+    def noncentral_chisquare(self, df: float, nonc: float, size: None = ...) -> float: ...  # type: ignore[misc]
+    @overload
+    def noncentral_chisquare(
+        self, df: _ArrayLikeFloat_co, nonc: _ArrayLikeFloat_co, size: None | _ShapeLike = ...
+    ) -> NDArray[float64]: ...
+    @overload
+    def standard_t(self, df: float, size: None = ...) -> float: ...  # type: ignore[misc]
+    @overload
+    def standard_t(
+        self, df: _ArrayLikeFloat_co, size: None = ...
+    ) -> NDArray[float64]: ...
+    @overload
+    def standard_t(
+        self, df: _ArrayLikeFloat_co, size: _ShapeLike = ...
+    ) -> NDArray[float64]: ...
+    @overload
+    def vonmises(self, mu: float, kappa: float, size: None = ...) -> float: ...  # type: ignore[misc]
+    @overload
+    def vonmises(
+        self, mu: _ArrayLikeFloat_co, kappa: _ArrayLikeFloat_co, size: None | _ShapeLike = ...
+    ) -> NDArray[float64]: ...
+    @overload
+    def pareto(self, a: float, size: None = ...) -> float: ...  # type: ignore[misc]
+    @overload
+    def pareto(
+        self, a: _ArrayLikeFloat_co, size: None | _ShapeLike = ...
+    ) -> NDArray[float64]: ...
+    @overload
+    def weibull(self, a: float, size: None = ...) -> float: ...  # type: ignore[misc]
+    @overload
+    def weibull(
+        self, a: _ArrayLikeFloat_co, size: None | _ShapeLike = ...
+    ) -> NDArray[float64]: ...
+    @overload
+    def power(self, a: float, size: None = ...) -> float: ...  # type: ignore[misc]
+    @overload
+    def power(
+        self, a: _ArrayLikeFloat_co, size: None | _ShapeLike = ...
+    ) -> NDArray[float64]: ...
+    @overload
+    def standard_cauchy(self, size: None = ...) -> float: ...  # type: ignore[misc]
+    @overload
+    def standard_cauchy(self, size: _ShapeLike = ...) -> NDArray[float64]: ...
+    @overload
+    def laplace(self, loc: float = ..., scale: float = ..., size: None = ...) -> float: ...  # type: ignore[misc]
+    @overload
+    def laplace(
+        self,
+        loc: _ArrayLikeFloat_co = ...,
+        scale: _ArrayLikeFloat_co = ...,
+        size: None | _ShapeLike = ...,
+    ) -> NDArray[float64]: ...
+    @overload
+    def gumbel(self, loc: float = ..., scale: float = ..., size: None = ...) -> float: ...  # type: ignore[misc]
+    @overload
+    def gumbel(
+        self,
+        loc: _ArrayLikeFloat_co = ...,
+        scale: _ArrayLikeFloat_co = ...,
+        size: None | _ShapeLike = ...,
+    ) -> NDArray[float64]: ...
+    @overload
+    def logistic(self, loc: float = ..., scale: float = ..., size: None = ...) -> float: ...  # type: ignore[misc]
+    @overload
+    def logistic(
+        self,
+        loc: _ArrayLikeFloat_co = ...,
+        scale: _ArrayLikeFloat_co = ...,
+        size: None | _ShapeLike = ...,
+    ) -> NDArray[float64]: ...
+    @overload
+    def lognormal(self, mean: float = ..., sigma: float = ..., size: None = ...) -> float: ...  # type: ignore[misc]
+    @overload
+    def lognormal(
+        self,
+        mean: _ArrayLikeFloat_co = ...,
+        sigma: _ArrayLikeFloat_co = ...,
+        size: None | _ShapeLike = ...,
+    ) -> NDArray[float64]: ...
+    @overload
+    def rayleigh(self, scale: float = ..., size: None = ...) -> float: ...  # type: ignore[misc]
+    @overload
+    def rayleigh(
+        self, scale: _ArrayLikeFloat_co = ..., size: None | _ShapeLike = ...
+    ) -> NDArray[float64]: ...
+    @overload
+    def wald(self, mean: float, scale: float, size: None = ...) -> float: ...  # type: ignore[misc]
+    @overload
+    def wald(
+        self, mean: _ArrayLikeFloat_co, scale: _ArrayLikeFloat_co, size: None | _ShapeLike = ...
+    ) -> NDArray[float64]: ...
+    @overload
+    def triangular(self, left: float, mode: float, right: float, size: None = ...) -> float: ...  # type: ignore[misc]
+    @overload
+    def triangular(
+        self,
+        left: _ArrayLikeFloat_co,
+        mode: _ArrayLikeFloat_co,
+        right: _ArrayLikeFloat_co,
+        size: None | _ShapeLike = ...,
+    ) -> NDArray[float64]: ...
+    @overload
+    def binomial(self, n: int, p: float, size: None = ...) -> int: ...  # type: ignore[misc]
+    @overload
+    def binomial(
+        self, n: _ArrayLikeInt_co, p: _ArrayLikeFloat_co, size: None | _ShapeLike = ...
+    ) -> NDArray[long]: ...
+    @overload
+    def negative_binomial(self, n: float, p: float, size: None = ...) -> int: ...  # type: ignore[misc]
+    @overload
+    def negative_binomial(
+        self, n: _ArrayLikeFloat_co, p: _ArrayLikeFloat_co, size: None | _ShapeLike = ...
+    ) -> NDArray[long]: ...
+    @overload
+    def poisson(self, lam: float = ..., size: None = ...) -> int: ...  # type: ignore[misc]
+    @overload
+    def poisson(
+        self, lam: _ArrayLikeFloat_co = ..., size: None | _ShapeLike = ...
+    ) -> NDArray[long]: ...
+    @overload
+    def zipf(self, a: float, size: None = ...) -> int: ...  # type: ignore[misc]
+    @overload
+    def zipf(
+        self, a: _ArrayLikeFloat_co, size: None | _ShapeLike = ...
+    ) -> NDArray[long]: ...
+    @overload
+    def geometric(self, p: float, size: None = ...) -> int: ...  # type: ignore[misc]
+    @overload
+    def geometric(
+        self, p: _ArrayLikeFloat_co, size: None | _ShapeLike = ...
+    ) -> NDArray[long]: ...
+    @overload
+    def hypergeometric(self, ngood: int, nbad: int, nsample: int, size: None = ...) -> int: ...  # type: ignore[misc]
+    @overload
+    def hypergeometric(
+        self,
+        ngood: _ArrayLikeInt_co,
+        nbad: _ArrayLikeInt_co,
+        nsample: _ArrayLikeInt_co,
+        size: None | _ShapeLike = ...,
+    ) -> NDArray[long]: ...
+    @overload
+    def logseries(self, p: float, size: None = ...) -> int: ...  # type: ignore[misc]
+    @overload
+    def logseries(
+        self, p: _ArrayLikeFloat_co, size: None | _ShapeLike = ...
+    ) -> NDArray[long]: ...
+    def multivariate_normal(
+        self,
+        mean: _ArrayLikeFloat_co,
+        cov: _ArrayLikeFloat_co,
+        size: None | _ShapeLike = ...,
+        check_valid: Literal["warn", "raise", "ignore"] = ...,
+        tol: float = ...,
+    ) -> NDArray[float64]: ...
+    def multinomial(
+        self, n: _ArrayLikeInt_co, pvals: _ArrayLikeFloat_co, size: None | _ShapeLike = ...
+    ) -> NDArray[long]: ...
+    def dirichlet(
+        self, alpha: _ArrayLikeFloat_co, size: None | _ShapeLike = ...
+    ) -> NDArray[float64]: ...
+    def shuffle(self, x: ArrayLike) -> None: ...
+    @overload
+    def permutation(self, x: int) -> NDArray[long]: ...
+    @overload
+    def permutation(self, x: ArrayLike) -> NDArray[Any]: ...
+
+_rand: RandomState
+
+beta = _rand.beta
+binomial = _rand.binomial
+bytes = _rand.bytes
+chisquare = _rand.chisquare
+choice = _rand.choice
+dirichlet = _rand.dirichlet
+exponential = _rand.exponential
+f = _rand.f
+gamma = _rand.gamma
+get_state = _rand.get_state
+geometric = _rand.geometric
+gumbel = _rand.gumbel
+hypergeometric = _rand.hypergeometric
+laplace = _rand.laplace
+logistic = _rand.logistic
+lognormal = _rand.lognormal
+logseries = _rand.logseries
+multinomial = _rand.multinomial
+multivariate_normal = _rand.multivariate_normal
+negative_binomial = _rand.negative_binomial
+noncentral_chisquare = _rand.noncentral_chisquare
+noncentral_f = _rand.noncentral_f
+normal = _rand.normal
+pareto = _rand.pareto
+permutation = _rand.permutation
+poisson = _rand.poisson
+power = _rand.power
+rand = _rand.rand
+randint = _rand.randint
+randn = _rand.randn
+random = _rand.random
+random_integers = _rand.random_integers
+random_sample = _rand.random_sample
+rayleigh = _rand.rayleigh
+seed = _rand.seed
+set_state = _rand.set_state
+shuffle = _rand.shuffle
+standard_cauchy = _rand.standard_cauchy
+standard_exponential = _rand.standard_exponential
+standard_gamma = _rand.standard_gamma
+standard_normal = _rand.standard_normal
+standard_t = _rand.standard_t
+triangular = _rand.triangular
+uniform = _rand.uniform
+vonmises = _rand.vonmises
+wald = _rand.wald
+weibull = _rand.weibull
+zipf = _rand.zipf
+# Two legacy that are trivial wrappers around random_sample
+sample = _rand.random_sample
+ranf = _rand.random_sample
+
+def set_bit_generator(bitgen: BitGenerator) -> None:
+    ...
+
+def get_bit_generator() -> BitGenerator:
+    ...
diff --git a/venv/lib/python3.12/site-packages/numpy/random/tests/__init__.py b/venv/lib/python3.12/site-packages/numpy/random/tests/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/venv/lib/python3.12/site-packages/numpy/random/tests/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/random/tests/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 00000000..a5e33782
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/random/tests/__pycache__/__init__.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/random/tests/__pycache__/test_direct.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/random/tests/__pycache__/test_direct.cpython-312.pyc
new file mode 100644
index 00000000..25f90910
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/random/tests/__pycache__/test_direct.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/random/tests/__pycache__/test_extending.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/random/tests/__pycache__/test_extending.cpython-312.pyc
new file mode 100644
index 00000000..ef038982
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/random/tests/__pycache__/test_extending.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/random/tests/__pycache__/test_generator_mt19937.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/random/tests/__pycache__/test_generator_mt19937.cpython-312.pyc
new file mode 100644
index 00000000..0e4f23b0
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/random/tests/__pycache__/test_generator_mt19937.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/random/tests/__pycache__/test_generator_mt19937_regressions.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/random/tests/__pycache__/test_generator_mt19937_regressions.cpython-312.pyc
new file mode 100644
index 00000000..c9de7207
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/random/tests/__pycache__/test_generator_mt19937_regressions.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/random/tests/__pycache__/test_random.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/random/tests/__pycache__/test_random.cpython-312.pyc
new file mode 100644
index 00000000..bfc64536
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/random/tests/__pycache__/test_random.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/random/tests/__pycache__/test_randomstate.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/random/tests/__pycache__/test_randomstate.cpython-312.pyc
new file mode 100644
index 00000000..fa001d25
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/random/tests/__pycache__/test_randomstate.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/random/tests/__pycache__/test_randomstate_regression.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/random/tests/__pycache__/test_randomstate_regression.cpython-312.pyc
new file mode 100644
index 00000000..7eeeb4aa
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/random/tests/__pycache__/test_randomstate_regression.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/random/tests/__pycache__/test_regression.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/random/tests/__pycache__/test_regression.cpython-312.pyc
new file mode 100644
index 00000000..57406b3e
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/random/tests/__pycache__/test_regression.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/random/tests/__pycache__/test_seed_sequence.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/random/tests/__pycache__/test_seed_sequence.cpython-312.pyc
new file mode 100644
index 00000000..935cc74a
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/random/tests/__pycache__/test_seed_sequence.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/random/tests/__pycache__/test_smoke.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/random/tests/__pycache__/test_smoke.cpython-312.pyc
new file mode 100644
index 00000000..70549acf
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/random/tests/__pycache__/test_smoke.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/random/tests/data/__init__.py b/venv/lib/python3.12/site-packages/numpy/random/tests/data/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/venv/lib/python3.12/site-packages/numpy/random/tests/data/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/random/tests/data/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 00000000..64f4101e
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/random/tests/data/__pycache__/__init__.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/random/tests/data/generator_pcg64_np121.pkl.gz b/venv/lib/python3.12/site-packages/numpy/random/tests/data/generator_pcg64_np121.pkl.gz
new file mode 100644
index 00000000..b7ad03d8
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/random/tests/data/generator_pcg64_np121.pkl.gz differ
diff --git a/venv/lib/python3.12/site-packages/numpy/random/tests/data/generator_pcg64_np126.pkl.gz b/venv/lib/python3.12/site-packages/numpy/random/tests/data/generator_pcg64_np126.pkl.gz
new file mode 100644
index 00000000..6c5130b5
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/random/tests/data/generator_pcg64_np126.pkl.gz differ
diff --git a/venv/lib/python3.12/site-packages/numpy/random/tests/data/mt19937-testset-1.csv b/venv/lib/python3.12/site-packages/numpy/random/tests/data/mt19937-testset-1.csv
new file mode 100644
index 00000000..b97bfa66
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/random/tests/data/mt19937-testset-1.csv
@@ -0,0 +1,1001 @@
+seed, 0xdeadbeaf
+0, 0xc816921f
+1, 0xb3623c6d
+2, 0x5fa391bb
+3, 0x40178d9
+4, 0x7dcc9811
+5, 0x548eb8e6
+6, 0x92ba3125
+7, 0x65fde68d
+8, 0x2f81ec95
+9, 0xbd94f7a2
+10, 0xdc4d9bcc
+11, 0xa672bf13
+12, 0xb41113e
+13, 0xec7e0066
+14, 0x50239372
+15, 0xd9d66b1d
+16, 0xab72a161
+17, 0xddc2e29f
+18, 0x7ea29ab4
+19, 0x80d141ba
+20, 0xb1c7edf1
+21, 0x44d29203
+22, 0xe224d98
+23, 0x5b3e9d26
+24, 0x14fd567c
+25, 0x27d98c96
+26, 0x838779fc
+27, 0x92a138a
+28, 0x5d08965b
+29, 0x531e0ad6
+30, 0x984ee8f4
+31, 0x1ed78539
+32, 0x32bd6d8d
+33, 0xc37c8516
+34, 0x9aef5c6b
+35, 0x3aacd139
+36, 0xd96ed154
+37, 0x489cd1ed
+38, 0x2cba4b3b
+39, 0x76c6ae72
+40, 0x2dae02b9
+41, 0x52ac5fd6
+42, 0xc2b5e265
+43, 0x630e6a28
+44, 0x3f560d5d
+45, 0x9315bdf3
+46, 0xf1055aba
+47, 0x840e42c6
+48, 0xf2099c6b
+49, 0x15ff7696
+50, 0x7948d146
+51, 0x97342961
+52, 0x7a7a21c
+53, 0xc66f4fb1
+54, 0x23c4103e
+55, 0xd7321f98
+56, 0xeb7efb75
+57, 0xe02490b5
+58, 0x2aa02de
+59, 0x8bee0bf7
+60, 0xfc2da059
+61, 0xae835034
+62, 0x678f2075
+63, 0x6d03094b
+64, 0x56455e05
+65, 0x18b32373
+66, 0x8ff0356b
+67, 0x1fe442fb
+68, 0x3f1ab6c3
+69, 0xb6fd21b
+70, 0xfc310eb2
+71, 0xb19e9a4d
+72, 0x17ddee72
+73, 0xfd534251
+74, 0x9e500564
+75, 0x9013a036
+76, 0xcf08f118
+77, 0x6b6d5969
+78, 0x3ccf1977
+79, 0x7cc11497
+80, 0x651c6ac9
+81, 0x4d6b104b
+82, 0x9a28314e
+83, 0x14c237be
+84, 0x9cfc8d52
+85, 0x2947fad5
+86, 0xd71eff49
+87, 0x5188730e
+88, 0x4b894614
+89, 0xf4fa2a34
+90, 0x42f7cc69
+91, 0x4089c9e8
+92, 0xbf0bbfe4
+93, 0x3cea65c
+94, 0xc6221207
+95, 0x1bb71a8f
+96, 0x54843fe7
+97, 0xbc59de4c
+98, 0x79c6ee64
+99, 0x14e57a26
+100, 0x68d88fe
+101, 0x2b86ef64
+102, 0x8ffff3c1
+103, 0x5bdd573f
+104, 0x85671813
+105, 0xefe32ca2
+106, 0x105ded1e
+107, 0x90ca2769
+108, 0xb33963ac
+109, 0x363fbbc3
+110, 0x3b3763ae
+111, 0x1d50ab88
+112, 0xc9ec01eb
+113, 0xc8bbeada
+114, 0x5d704692
+115, 0x5fd9e40
+116, 0xe61c125
+117, 0x2fe05792
+118, 0xda8afb72
+119, 0x4cbaa653
+120, 0xdd2243df
+121, 0x896fd3f5
+122, 0x5bc23db
+123, 0xa1c4e807
+124, 0x57d1a24d
+125, 0x66503ddc
+126, 0xcf7c0838
+127, 0x19e034fc
+128, 0x66807450
+129, 0xfc219b3b
+130, 0xe8a843e7
+131, 0x9ce61f08
+132, 0x92b950d6
+133, 0xce955ec4
+134, 0xda0d1f0d
+135, 0x960c6250
+136, 0x39552432
+137, 0xde845e84
+138, 0xff3b4b11
+139, 0x5d918e6f
+140, 0xbb930df2
+141, 0x7cfb0993
+142, 0x5400e1e9
+143, 0x3bfa0954
+144, 0x7e2605fb
+145, 0x11941591
+146, 0x887e6994
+147, 0xdc8bed45
+148, 0x45b3fb50
+149, 0xfbdf8358
+150, 0x41507468
+151, 0x34c87166
+152, 0x17f64d77
+153, 0x3bbaf4f8
+154, 0x4f26f37e
+155, 0x4a56ebf2
+156, 0x81100f1
+157, 0x96d94eae
+158, 0xca88fda5
+159, 0x2eef3a60
+160, 0x952afbd3
+161, 0x2bec88c7
+162, 0x52335c4b
+163, 0x8296db8e
+164, 0x4da7d00a
+165, 0xc00ac899
+166, 0xadff8c72
+167, 0xbecf26cf
+168, 0x8835c83c
+169, 0x1d13c804
+170, 0xaa940ddc
+171, 0x68222cfe
+172, 0x4569c0e1
+173, 0x29077976
+174, 0x32d4a5af
+175, 0xd31fcdef
+176, 0xdc60682b
+177, 0x7c95c368
+178, 0x75a70213
+179, 0x43021751
+180, 0x5e52e0a6
+181, 0xf7e190b5
+182, 0xee3e4bb
+183, 0x2fe3b150
+184, 0xcf419c07
+185, 0x478a4570
+186, 0xe5c3ea50
+187, 0x417f30a8
+188, 0xf0cfdaa0
+189, 0xd1f7f738
+190, 0x2c70fc23
+191, 0x54fc89f9
+192, 0x444dcf01
+193, 0xec2a002d
+194, 0xef0c3a88
+195, 0xde21be9
+196, 0x88ab3296
+197, 0x3028897c
+198, 0x264b200b
+199, 0xd8ae0706
+200, 0x9eef901a
+201, 0xbd1b96e0
+202, 0xea71366c
+203, 0x1465b694
+204, 0x5a794650
+205, 0x83df52d4
+206, 0x8262413d
+207, 0x5bc148c0
+208, 0xe0ecd80c
+209, 0x40649571
+210, 0xb4d2ee5f
+211, 0xedfd7d09
+212, 0xa082e25f
+213, 0xc62992d1
+214, 0xbc7e65ee
+215, 0x5499cf8a
+216, 0xac28f775
+217, 0x649840fb
+218, 0xd4c54805
+219, 0x1d166ba6
+220, 0xbeb1171f
+221, 0x45b66703
+222, 0x78c03349
+223, 0x38d2a6ff
+224, 0x935cae8b
+225, 0x1d07dc3f
+226, 0x6c1ed365
+227, 0x579fc585
+228, 0x1320c0ec
+229, 0x632757eb
+230, 0xd265a397
+231, 0x70e9b6c2
+232, 0xc81e322c
+233, 0xa27153cf
+234, 0x2118ba19
+235, 0x514ec400
+236, 0x2bd0ecd6
+237, 0xc3e7dae3
+238, 0xfa39355e
+239, 0x48f23cc1
+240, 0xbcf75948
+241, 0x53ccc70c
+242, 0x75346423
+243, 0x951181e0
+244, 0x348e90df
+245, 0x14365d7f
+246, 0xfbc95d7a
+247, 0xdc98a9e6
+248, 0xed202df7
+249, 0xa59ec913
+250, 0x6b6e9ae2
+251, 0x1697f265
+252, 0x15d322d0
+253, 0xa2e7ee0a
+254, 0x88860b7e
+255, 0x455d8b9d
+256, 0x2f5c59cb
+257, 0xac49c9f1
+258, 0xa6a6a039
+259, 0xc057f56b
+260, 0xf1ff1208
+261, 0x5eb8dc9d
+262, 0xe6702509
+263, 0xe238b0ed
+264, 0x5ae32e3d
+265, 0xa88ebbdf
+266, 0xef885ae7
+267, 0xafa6d49b
+268, 0xc94499e0
+269, 0x1a196325
+270, 0x88938da3
+271, 0x14f4345
+272, 0xd8e33637
+273, 0xa3551bd5
+274, 0x73fe35c7
+275, 0x9561e94b
+276, 0xd673bf68
+277, 0x16134872
+278, 0x68c42f9f
+279, 0xdf7574c8
+280, 0x8809bab9
+281, 0x1432cf69
+282, 0xafb66bf1
+283, 0xc184aa7b
+284, 0xedbf2007
+285, 0xbd420ce1
+286, 0x761033a0
+287, 0xff7e351f
+288, 0xd6c3780e
+289, 0x5844416f
+290, 0xc6c0ee1c
+291, 0xd2e147db
+292, 0x92ac601a
+293, 0x393e846b
+294, 0x18196cca
+295, 0x54a22be
+296, 0x32bab1c4
+297, 0x60365183
+298, 0x64fa342
+299, 0xca24a493
+300, 0xd8cc8b83
+301, 0x3faf102b
+302, 0x6e09bb58
+303, 0x812f0ea
+304, 0x592c95d8
+305, 0xe45ea4c5
+306, 0x23aebf83
+307, 0xbd9691d4
+308, 0xf47b4baa
+309, 0x4ac7b487
+310, 0xcce18803
+311, 0x3377556e
+312, 0x3ff8e6b6
+313, 0x99d22063
+314, 0x23250bec
+315, 0x4e1f9861
+316, 0x8554249b
+317, 0x8635c2fc
+318, 0xe8426e8a
+319, 0x966c29d8
+320, 0x270b6082
+321, 0x3180a8a1
+322, 0xe7e1668b
+323, 0x7f868dc
+324, 0xcf4c17cf
+325, 0xe31de4d1
+326, 0xc8c8aff4
+327, 0xae8db704
+328, 0x3c928cc2
+329, 0xe12cd48
+330, 0xb33ecd04
+331, 0xb93d7cbe
+332, 0x49c69d6a
+333, 0x7d3bce64
+334, 0x86bc219
+335, 0x8408233b
+336, 0x44dc7479
+337, 0xdf80d538
+338, 0xf3db02c3
+339, 0xbbbd31d7
+340, 0x121281f
+341, 0x7521e9a3
+342, 0x8859675a
+343, 0x75aa6502
+344, 0x430ed15b
+345, 0xecf0a28d
+346, 0x659774fd
+347, 0xd58a2311
+348, 0x512389a9
+349, 0xff65e1ff
+350, 0xb6ddf222
+351, 0xe3458895
+352, 0x8b13cd6e
+353, 0xd4a22870
+354, 0xe604c50c
+355, 0x27f54f26
+356, 0x8f7f422f
+357, 0x9735b4cf
+358, 0x414072b0
+359, 0x76a1c6d5
+360, 0xa2208c06
+361, 0x83cd0f61
+362, 0x6c4f7ead
+363, 0x6553cf76
+364, 0xeffcf44
+365, 0x7f434a3f
+366, 0x9dc364bd
+367, 0x3cdf52ed
+368, 0xad597594
+369, 0x9c3e211b
+370, 0x6c04a33f
+371, 0x885dafa6
+372, 0xbbdaca71
+373, 0x7ae5dd5c
+374, 0x37675644
+375, 0x251853c6
+376, 0x130b086b
+377, 0x143fa54b
+378, 0x54cdc282
+379, 0x9faff5b3
+380, 0x502a5c8b
+381, 0xd9524550
+382, 0xae221aa6
+383, 0x55cf759b
+384, 0x24782da4
+385, 0xd715d815
+386, 0x250ea09a
+387, 0x4e0744ac
+388, 0x11e15814
+389, 0xabe5f9df
+390, 0xc8146350
+391, 0xfba67d9b
+392, 0x2b82e42f
+393, 0xd4ea96fc
+394, 0x5ffc179e
+395, 0x1598bafe
+396, 0x7fb6d662
+397, 0x1a12a0db
+398, 0x450cee4a
+399, 0x85f8e12
+400, 0xce71b594
+401, 0xd4bb1d19
+402, 0x968f379d
+403, 0x54cc1d52
+404, 0x467e6066
+405, 0x7da5f9a9
+406, 0x70977034
+407, 0x49e65c4b
+408, 0xd08570d1
+409, 0x7acdf60b
+410, 0xdffa038b
+411, 0x9ce14e4c
+412, 0x107cbbf8
+413, 0xdd746ca0
+414, 0xc6370a46
+415, 0xe7f83312
+416, 0x373fa9ce
+417, 0xd822a2c6
+418, 0x1d4efea6
+419, 0xc53dcadb
+420, 0x9b4e898f
+421, 0x71daa6bf
+422, 0x7a0bc78b
+423, 0xd7b86f50
+424, 0x1b8b3286
+425, 0xcf9425dd
+426, 0xd5263220
+427, 0x4ea0b647
+428, 0xc767fe64
+429, 0xcfc5e67
+430, 0xcc6a2942
+431, 0xa51eff00
+432, 0x76092e1b
+433, 0xf606e80f
+434, 0x824b5e20
+435, 0xebb55e14
+436, 0x783d96a6
+437, 0x10696512
+438, 0x17ee510a
+439, 0x3ab70a1f
+440, 0xcce6b210
+441, 0x8f72f0fb
+442, 0xf0610b41
+443, 0x83d01fb5
+444, 0x6b3de36
+445, 0xe4c2e84f
+446, 0x9c43bb15
+447, 0xddf2905
+448, 0x7dd63556
+449, 0x3662ca09
+450, 0xfb81f35b
+451, 0xc2c8a72a
+452, 0x8e93c37
+453, 0xa93da2d4
+454, 0xa03af8f1
+455, 0x8d75159a
+456, 0x15f010b0
+457, 0xa296ab06
+458, 0xe55962ba
+459, 0xeae700a9
+460, 0xe388964a
+461, 0x917f2bec
+462, 0x1c203fea
+463, 0x792a01ba
+464, 0xa93a80ac
+465, 0x9eb8a197
+466, 0x56c0bc73
+467, 0xb8f05799
+468, 0xf429a8c8
+469, 0xb92cee42
+470, 0xf8864ec
+471, 0x62f2518a
+472, 0x3a7bfa3e
+473, 0x12e56e6d
+474, 0xd7a18313
+475, 0x41fa3899
+476, 0xa09c4956
+477, 0xebcfd94a
+478, 0xc485f90b
+479, 0x4391ce40
+480, 0x742a3333
+481, 0xc932f9e5
+482, 0x75c6c263
+483, 0x80937f0
+484, 0xcf21833c
+485, 0x16027520
+486, 0xd42e669f
+487, 0xb0f01fb7
+488, 0xb35896f1
+489, 0x763737a9
+490, 0x1bb20209
+491, 0x3551f189
+492, 0x56bc2602
+493, 0xb6eacf4
+494, 0x42ec4d11
+495, 0x245cc68
+496, 0xc27ac43b
+497, 0x9d903466
+498, 0xce3f0c05
+499, 0xb708c31c
+500, 0xc0fd37eb
+501, 0x95938b2c
+502, 0xf20175a7
+503, 0x4a86ee9b
+504, 0xbe039a58
+505, 0xd41cabe7
+506, 0x83bc99ba
+507, 0x761d60e1
+508, 0x7737cc2e
+509, 0x2b82fc4b
+510, 0x375aa401
+511, 0xfe9597a0
+512, 0x5543806a
+513, 0x44f31238
+514, 0x7df31538
+515, 0x74cfa770
+516, 0x8755d881
+517, 0x1fde665a
+518, 0xda8bf315
+519, 0x973d8e95
+520, 0x72205228
+521, 0x8fe59717
+522, 0x7bb90b34
+523, 0xef6ed945
+524, 0x16fd4a38
+525, 0x5db44de1
+526, 0xf09f93b3
+527, 0xe84824cc
+528, 0x945bb50e
+529, 0xd0be4aa5
+530, 0x47c277c2
+531, 0xd3800c28
+532, 0xac1c33ec
+533, 0xd3dacce
+534, 0x811c8387
+535, 0x6761b36
+536, 0x70d3882f
+537, 0xd6e62e3a
+538, 0xea25daa2
+539, 0xb07f39d1
+540, 0x391d89d7
+541, 0x84b6fb5e
+542, 0x3dda3fca
+543, 0x229e80a4
+544, 0x3d94a4b7
+545, 0x5d3d576a
+546, 0xad7818a0
+547, 0xce23b03a
+548, 0x7aa2079c
+549, 0x9a6be555
+550, 0x83f3b34a
+551, 0x1848f9d9
+552, 0xd8fefc1c
+553, 0x48e6ce48
+554, 0x52e55750
+555, 0xf41a71cf
+556, 0xba08e259
+557, 0xfaf06a15
+558, 0xeaaac0fb
+559, 0x34f90098
+560, 0xb1dfffbb
+561, 0x718daec2
+562, 0xab4dda21
+563, 0xd27cc1ee
+564, 0x4aafbc4c
+565, 0x356dfb4f
+566, 0x83fcdfd6
+567, 0x8f0bcde0
+568, 0x4363f844
+569, 0xadc0f4d5
+570, 0x3bde994e
+571, 0x3884d452
+572, 0x21876b4a
+573, 0x9c985398
+574, 0xca55a226
+575, 0x3a88c583
+576, 0x916dc33c
+577, 0x8f67d1d7
+578, 0x3b26a667
+579, 0xe4ddeb4b
+580, 0x1a9d8c33
+581, 0x81c9b74f
+582, 0x9ed1e9df
+583, 0x6e61aecf
+584, 0x95e95a5d
+585, 0x68864ff5
+586, 0xb8fa5b9
+587, 0x72b1b3de
+588, 0x5e18a86b
+589, 0xd7f2337d
+590, 0xd70e0925
+591, 0xb573a4c1
+592, 0xc77b3f8a
+593, 0x389b20de
+594, 0x16cf6afb
+595, 0xa39bd275
+596, 0xf491cf01
+597, 0x6f88a802
+598, 0x8510af05
+599, 0xe7cd549a
+600, 0x8603179a
+601, 0xef43f191
+602, 0xf9b64c60
+603, 0xb00254a7
+604, 0xd7c06a2d
+605, 0x17e9380b
+606, 0x529e727b
+607, 0xaaa8fe0a
+608, 0xfb64ff4c
+609, 0xcd75af26
+610, 0xfb717c87
+611, 0xa0789899
+612, 0x10391ec9
+613, 0x7e9b40b3
+614, 0x18536554
+615, 0x728c05f7
+616, 0x787dca98
+617, 0xad948d1
+618, 0x44c18def
+619, 0x3303f2ec
+620, 0xa15acb5
+621, 0xb58d38f4
+622, 0xfe041ef8
+623, 0xd151a956
+624, 0x7b9168e8
+625, 0x5ebeca06
+626, 0x90fe95df
+627, 0xf76875aa
+628, 0xb2e0d664
+629, 0x2e3253b7
+630, 0x68e34469
+631, 0x1f0c2d89
+632, 0x13a34ac2
+633, 0x5ffeb841
+634, 0xe381e91c
+635, 0xb8549a92
+636, 0x3f35cf1
+637, 0xda0f9dcb
+638, 0xdd9828a6
+639, 0xe1428f29
+640, 0xf4db80b5
+641, 0xdac30af5
+642, 0x1af1dd17
+643, 0x9a540254
+644, 0xcab68a38
+645, 0x33560361
+646, 0x2fbf3886
+647, 0xbc785923
+648, 0xe081cd10
+649, 0x8e473356
+650, 0xd102c357
+651, 0xeea4fe48
+652, 0x248d3453
+653, 0x1da79ac
+654, 0x815a65ff
+655, 0x27693e76
+656, 0xb7d5af40
+657, 0x6d245d30
+658, 0x9e06fa8f
+659, 0xb0570dcb
+660, 0x469f0005
+661, 0x3e0ca132
+662, 0xd89bbf3
+663, 0xd61ccd47
+664, 0x6383878
+665, 0x62b5956
+666, 0x4dc83675
+667, 0x93fd8492
+668, 0x5a0091f5
+669, 0xc9f9bc3
+670, 0xa26e7778
+671, 0xeabf2d01
+672, 0xe612dc06
+673, 0x85d89ff9
+674, 0xd1763179
+675, 0xcb88947b
+676, 0x9e8757a5
+677, 0xe100e85c
+678, 0x904166eb
+679, 0x4996243d
+680, 0x4038e1cb
+681, 0x2be2c63d
+682, 0x77017e81
+683, 0x3b1f556b
+684, 0x1c785c77
+685, 0x6869b8bd
+686, 0xe1217ed4
+687, 0x4012ab2f
+688, 0xc06c0d8e
+689, 0x2122eb68
+690, 0xad1783fd
+691, 0x5f0c80e3
+692, 0x828f7efa
+693, 0x29328399
+694, 0xeadf1087
+695, 0x85dc0037
+696, 0x9691ef26
+697, 0xc0947a53
+698, 0x2a178d2a
+699, 0x2a2c7e8f
+700, 0x90378380
+701, 0xaad8d326
+702, 0x9cf1c3c8
+703, 0x84eccd44
+704, 0x79e61808
+705, 0x8b3f454e
+706, 0x209e6e1
+707, 0x51f88378
+708, 0xc210226f
+709, 0xd982adb5
+710, 0x55d44a31
+711, 0x9817d443
+712, 0xa328c626
+713, 0x13455966
+714, 0xb8f681d3
+715, 0x2a3c713b
+716, 0xc186959b
+717, 0x814a74b0
+718, 0xed7bc90
+719, 0xa88d3d6d
+720, 0x88a9f561
+721, 0x73aa1c0a
+722, 0xdfeff404
+723, 0xec037e4b
+724, 0xa5c209f0
+725, 0xb3a223b4
+726, 0x24ce3709
+727, 0x3184c790
+728, 0xa1398c62
+729, 0x2f92034e
+730, 0xbb37a79a
+731, 0x605287b4
+732, 0x8faa772c
+733, 0x6ce56c1d
+734, 0xc035fb4c
+735, 0x7cf5b316
+736, 0x6502645
+737, 0xa283d810
+738, 0x778bc2f1
+739, 0xfdf99313
+740, 0x1f513265
+741, 0xbd3837e2
+742, 0x9b84a9a
+743, 0x2139ce91
+744, 0x61a8e890
+745, 0xf9ff12db
+746, 0xb43d2ea7
+747, 0x88532e61
+748, 0x175a6655
+749, 0x7a6c4f72
+750, 0x6dafc1b7
+751, 0x449b1459
+752, 0x514f654f
+753, 0x9a6731e2
+754, 0x8632da43
+755, 0xc81b0422
+756, 0x81fe9005
+757, 0x15b79618
+758, 0xb5fa629f
+759, 0x987a474f
+760, 0x1c74f54e
+761, 0xf9743232
+762, 0xec4b55f
+763, 0x87d761e5
+764, 0xd1ad78b7
+765, 0x453d9350
+766, 0xc7a7d85
+767, 0xb2576ff5
+768, 0xcdde49b7
+769, 0x8e1f763e
+770, 0x1338583e
+771, 0xfd65b9dc
+772, 0x4f19c4f4
+773, 0x3a52d73d
+774, 0xd3509c4c
+775, 0xda24fe31
+776, 0xe2de56ba
+777, 0x2db5e540
+778, 0x23172734
+779, 0x4db572f
+780, 0xeb941718
+781, 0x84c2649a
+782, 0x3b1e5b6a
+783, 0x4c9c61b9
+784, 0x3bccd11
+785, 0xb4d7b78e
+786, 0x48580ae5
+787, 0xd273ab68
+788, 0x25c11615
+789, 0x470b53f6
+790, 0x329c2068
+791, 0x1693721b
+792, 0xf8c9aacf
+793, 0x4c3d5693
+794, 0xd778284e
+795, 0xae1cb24f
+796, 0x3c11d1b3
+797, 0xddd2b0c0
+798, 0x90269fa7
+799, 0x5666e0a2
+800, 0xf9f195a4
+801, 0x61d78eb2
+802, 0xada5a7c0
+803, 0xaa272fbe
+804, 0xba3bae2f
+805, 0xd0b70fc2
+806, 0x529f32b
+807, 0xda7a3e21
+808, 0x9a776a20
+809, 0xb21f9635
+810, 0xb3acc14e
+811, 0xac55f56
+812, 0x29dccf41
+813, 0x32dabdb3
+814, 0xaa032f58
+815, 0xfa406af4
+816, 0xce3c415d
+817, 0xb44fb4d9
+818, 0x32248d1c
+819, 0x680c6440
+820, 0xae2337b
+821, 0x294cb597
+822, 0x5bca48fe
+823, 0xaef19f40
+824, 0xad60406
+825, 0x4781f090
+826, 0xfd691ffc
+827, 0xb6568268
+828, 0xa56c72cb
+829, 0xf8a9e0fc
+830, 0x9af4fd02
+831, 0x2cd30932
+832, 0x776cefd7
+833, 0xe31f476e
+834, 0x6d94a437
+835, 0xb3cab598
+836, 0xf582d13f
+837, 0x3bf8759d
+838, 0xc3777dc
+839, 0x5e425ea8
+840, 0x1c7ff4ed
+841, 0x1c2e97d1
+842, 0xc062d2b4
+843, 0x46dc80e0
+844, 0xbcdb47e6
+845, 0x32282fe0
+846, 0xaba89063
+847, 0x5e94e9bb
+848, 0x3e667f78
+849, 0xea6eb21a
+850, 0xe56e54e8
+851, 0xa0383510
+852, 0x6768fe2b
+853, 0xb53ac3e0
+854, 0x779569a0
+855, 0xeca83c6a
+856, 0x24db4d2d
+857, 0x4585f696
+858, 0xf84748b2
+859, 0xf6a4dd5b
+860, 0x31fb524d
+861, 0x67ab39fe
+862, 0x5882a899
+863, 0x9a05fcf6
+864, 0x712b5674
+865, 0xe8c6958f
+866, 0x4b448bb3
+867, 0x530b9abf
+868, 0xb491f491
+869, 0x98352c62
+870, 0x2d0a50e3
+871, 0xeb4384da
+872, 0x36246f07
+873, 0xcbc5c1a
+874, 0xae24031d
+875, 0x44d11ed6
+876, 0xf07f1608
+877, 0xf296aadd
+878, 0x3bcfe3be
+879, 0x8fa1e7df
+880, 0xfd317a6e
+881, 0xe4975c44
+882, 0x15205892
+883, 0xa762d4df
+884, 0xf1167365
+885, 0x6811cc00
+886, 0x8315f23
+887, 0xe045b4b1
+888, 0xa8496414
+889, 0xbed313ae
+890, 0xcdae3ddb
+891, 0xa9c22c9
+892, 0x275fab1a
+893, 0xedd65fa
+894, 0x4c188229
+895, 0x63a83e58
+896, 0x18aa9207
+897, 0xa41f2e78
+898, 0xd9f63653
+899, 0xbe2be73b
+900, 0xa3364d39
+901, 0x896d5428
+902, 0xc737539e
+903, 0x745a78c6
+904, 0xf0b2b042
+905, 0x510773b4
+906, 0x92ad8e37
+907, 0x27f2f8c4
+908, 0x23704cc8
+909, 0x3d95a77f
+910, 0xf08587a4
+911, 0xbd696a25
+912, 0x948924f3
+913, 0x8cddb634
+914, 0xcd2a4910
+915, 0x8e0e300e
+916, 0x83815a9b
+917, 0x67383510
+918, 0x3c18f0d0
+919, 0xc7a7bccc
+920, 0x7cc2d3a2
+921, 0x52eb2eeb
+922, 0xe4a257e5
+923, 0xec76160e
+924, 0x63f9ad68
+925, 0x36d0bbbf
+926, 0x957bc4e4
+927, 0xc9ed90ff
+928, 0x4cb6059d
+929, 0x2f86eca1
+930, 0x3e3665a3
+931, 0x9b7eb6f4
+932, 0x492e7e18
+933, 0xa098aa51
+934, 0x7eb568b2
+935, 0x3fd639ba
+936, 0x7bebcf1
+937, 0x99c844ad
+938, 0x43cb5ec7
+939, 0x8dfbbef5
+940, 0x5be413ff
+941, 0xd93b976d
+942, 0xc1c7a86d
+943, 0x1f0e93d0
+944, 0x498204a2
+945, 0xe8fe832a
+946, 0x2236bd7
+947, 0x89953769
+948, 0x2acc3491
+949, 0x2c4f22c6
+950, 0xd7996277
+951, 0x3bcdc349
+952, 0xfc286630
+953, 0x5f8909fd
+954, 0x242677c0
+955, 0x4cb34104
+956, 0xa6ff8100
+957, 0x39ea47ec
+958, 0x9bd54140
+959, 0x7502ffe8
+960, 0x7ebef8ae
+961, 0x1ed8abe4
+962, 0xfaba8450
+963, 0xc197b65f
+964, 0x19431455
+965, 0xe229c176
+966, 0xeb2967da
+967, 0xe0c5dc05
+968, 0xa84e3227
+969, 0x10dd9e0f
+970, 0xbdb70b02
+971, 0xce24808a
+972, 0x423edab8
+973, 0x194caf71
+974, 0x144f150d
+975, 0xf811c2d2
+976, 0xc224ee85
+977, 0x2b217a5b
+978, 0xf78a5a79
+979, 0x6554a4b1
+980, 0x769582df
+981, 0xf4b2cf93
+982, 0x89648483
+983, 0xb3283a3e
+984, 0x82b895db
+985, 0x79388ef0
+986, 0x54bc42a6
+987, 0xc4dd39d9
+988, 0x45b33b7d
+989, 0x8703b2c1
+990, 0x1cc94806
+991, 0xe0f43e49
+992, 0xcaa7b6bc
+993, 0x4f88e9af
+994, 0x1477cce5
+995, 0x347dd115
+996, 0x36e335fa
+997, 0xb93c9a31
+998, 0xaac3a175
+999, 0x68a19647
diff --git a/venv/lib/python3.12/site-packages/numpy/random/tests/data/mt19937-testset-2.csv b/venv/lib/python3.12/site-packages/numpy/random/tests/data/mt19937-testset-2.csv
new file mode 100644
index 00000000..cdb8e479
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/random/tests/data/mt19937-testset-2.csv
@@ -0,0 +1,1001 @@
+seed, 0x0
+0, 0x7ab4ea94
+1, 0x9b561119
+2, 0x4957d02e
+3, 0x7dd3fdc2
+4, 0x5affe54
+5, 0x5a01741c
+6, 0x8b9e8c1f
+7, 0xda5bf11a
+8, 0x509226
+9, 0x64e2ea17
+10, 0x82c6dab5
+11, 0xe4302515
+12, 0x8198b873
+13, 0xc3ec9a82
+14, 0x829dff28
+15, 0x5278e44f
+16, 0x994a7d2c
+17, 0xf1c89398
+18, 0xaf2fddec
+19, 0x22abc6ee
+20, 0x963dbd43
+21, 0xc29edffb
+22, 0x41c1ce07
+23, 0x9c90034d
+24, 0x1f17a796
+25, 0x3833caa8
+26, 0xb8795528
+27, 0xebc595a2
+28, 0xf8f5b5dd
+29, 0xc2881f72
+30, 0x18e5d3f0
+31, 0x9b19ac7a
+32, 0xb9992436
+33, 0xc00052b3
+34, 0xb63f4475
+35, 0x962642d9
+36, 0x63506c10
+37, 0x2be6b127
+38, 0x569bdbc6
+39, 0x7f185e01
+40, 0xebb55f53
+41, 0x1c30198c
+42, 0x7c8d75c6
+43, 0xd3f2186b
+44, 0xaca5b9b1
+45, 0xbc49ff45
+46, 0xc4a802af
+47, 0x2cecd86f
+48, 0x8e0da529
+49, 0x1f22b00e
+50, 0x4559ea80
+51, 0x60f587d8
+52, 0x7c7460e9
+53, 0x67be0a4a
+54, 0x987a0183
+55, 0x7bd30f1
+56, 0xab18c4ac
+57, 0xffdbfb64
+58, 0x9ea917f9
+59, 0x1239dab7
+60, 0x38efabeb
+61, 0x5da91888
+62, 0x8f49ed62
+63, 0x83f60b1e
+64, 0x5950a3fc
+65, 0xd8911104
+66, 0x19e8859e
+67, 0x1a4d89ec
+68, 0x968ca180
+69, 0x9e1b6da3
+70, 0x3d99c2c
+71, 0x55f76289
+72, 0x8fa28b9e
+73, 0x9fe01d33
+74, 0xdade4e38
+75, 0x1ea04290
+76, 0xa7263313
+77, 0xaafc762e
+78, 0x460476d6
+79, 0x31226e12
+80, 0x451d3f05
+81, 0xd0d2764b
+82, 0xd06e1ab3
+83, 0x1394e3f4
+84, 0x2fc04ea3
+85, 0x5b8401c
+86, 0xebd6c929
+87, 0xe881687c
+88, 0x94bdd66a
+89, 0xabf85983
+90, 0x223ad12d
+91, 0x2aaeeaa3
+92, 0x1f704934
+93, 0x2db2efb6
+94, 0xf49b8dfb
+95, 0x5bdbbb9d
+96, 0xba0cd0db
+97, 0x4ec4674e
+98, 0xad0129e
+99, 0x7a66129b
+100, 0x50d12c5e
+101, 0x85b1d335
+102, 0x3efda58a
+103, 0xecd886fb
+104, 0x8ecadd3d
+105, 0x60ebac0f
+106, 0x5e10fe79
+107, 0xa84f7e5d
+108, 0x43931288
+109, 0xfacf448
+110, 0x4ee01997
+111, 0xcdc0a651
+112, 0x33c87037
+113, 0x8b50fc03
+114, 0xf52aad34
+115, 0xda6cd856
+116, 0x7585bea0
+117, 0xe947c762
+118, 0x4ddff5d8
+119, 0xe0e79b3b
+120, 0xb804cf09
+121, 0x84765c44
+122, 0x3ff666b4
+123, 0xe31621ad
+124, 0x816f2236
+125, 0x228176bc
+126, 0xfdc14904
+127, 0x635f5077
+128, 0x6981a817
+129, 0xfd9a0300
+130, 0xd3fa8a24
+131, 0xd67c1a77
+132, 0x903fe97a
+133, 0xf7c4a4d5
+134, 0x109f2058
+135, 0x48ab87fe
+136, 0xfd6f1928
+137, 0x707e9452
+138, 0xf327db9e
+139, 0x7b80d76d
+140, 0xfb6ba193
+141, 0x454a1ad0
+142, 0xe20b51e
+143, 0xb774d085
+144, 0x6b1ed574
+145, 0xb1e77de4
+146, 0xe2a83b37
+147, 0x33d3176f
+148, 0x2f0ca0fc
+149, 0x17f51e2
+150, 0x7c1fbf55
+151, 0xf09e9cd0
+152, 0xe3d9bacd
+153, 0x4244db0a
+154, 0x876c09fc
+155, 0x9db4fc2f
+156, 0xd3771d60
+157, 0x25fc6a75
+158, 0xb309915c
+159, 0xc50ee027
+160, 0xaa5b7b38
+161, 0x4c650ded
+162, 0x1acb2879
+163, 0x50db5887
+164, 0x90054847
+165, 0xfef23e5b
+166, 0x2dd7b7d5
+167, 0x990b8c2e
+168, 0x6001a601
+169, 0xb5d314c4
+170, 0xfbfb7bf9
+171, 0x1aba997d
+172, 0x814e7304
+173, 0x989d956a
+174, 0x86d5a29c
+175, 0x70a9fa08
+176, 0xc4ccba87
+177, 0x7e9cb366
+178, 0xee18eb0a
+179, 0x44f5be58
+180, 0x91d4af2d
+181, 0x5ab6e593
+182, 0x9fd6bb4d
+183, 0x85894ce
+184, 0x728a2401
+185, 0xf006f6d4
+186, 0xd782741e
+187, 0x842cd5bd
+188, 0xfb5883aa
+189, 0x7e5a471
+190, 0x83ff6965
+191, 0xc9675c6b
+192, 0xb6ced3c7
+193, 0x3de6425b
+194, 0x25e14db4
+195, 0x69ca3dec
+196, 0x81342d13
+197, 0xd7cd8417
+198, 0x88d15e69
+199, 0xefba17c9
+200, 0x43d595e6
+201, 0x89d4cf25
+202, 0x7cae9b9b
+203, 0x2242c621
+204, 0x27fc3598
+205, 0x467b1d84
+206, 0xe84d4622
+207, 0xa26bf980
+208, 0x80411010
+209, 0xe2c2bfea
+210, 0xbc6ca25a
+211, 0x3ddb592a
+212, 0xdd46eb9e
+213, 0xdfe8f657
+214, 0x2cedc974
+215, 0xf0dc546b
+216, 0xd46be68f
+217, 0x26d8a5aa
+218, 0x76e96ba3
+219, 0x7d5b5353
+220, 0xf532237c
+221, 0x6478b79
+222, 0x9b81a5e5
+223, 0x5fc68e5c
+224, 0x68436e70
+225, 0x2a0043f9
+226, 0x108d523c
+227, 0x7a4c32a3
+228, 0x9c84c742
+229, 0x6f813dae
+230, 0xfcc5bbcc
+231, 0x215b6f3a
+232, 0x84cb321d
+233, 0x7913a248
+234, 0xb1e6b585
+235, 0x49376b31
+236, 0x1dc896b0
+237, 0x347051ad
+238, 0x5524c042
+239, 0xda0eef9d
+240, 0xf2e73342
+241, 0xbeee2f9d
+242, 0x7c702874
+243, 0x9eb3bd34
+244, 0x97b09700
+245, 0xcdbab1d4
+246, 0x4a2f6ed1
+247, 0x2047bda5
+248, 0x3ecc7005
+249, 0x8d0d5e67
+250, 0x40876fb5
+251, 0xb5fd2187
+252, 0xe915d8af
+253, 0x9a2351c7
+254, 0xccc658ae
+255, 0xebb1eddc
+256, 0xc4a83671
+257, 0xffb2548f
+258, 0xe4fe387a
+259, 0x477aaab4
+260, 0x8475a4e4
+261, 0xf8823e46
+262, 0xe4130f71
+263, 0xbdb54482
+264, 0x98fe0462
+265, 0xf36b27b8
+266, 0xed7733da
+267, 0x5f428afc
+268, 0x43a3a21a
+269, 0xf8370b55
+270, 0xfade1de1
+271, 0xd9a038ea
+272, 0x3c69af23
+273, 0x24df7dd0
+274, 0xf66d9353
+275, 0x71d811be
+276, 0xcc4d024b
+277, 0xb8c30bf0
+278, 0x4198509d
+279, 0x8b37ba36
+280, 0xa41ae29a
+281, 0x8cf7799e
+282, 0x5cd0136a
+283, 0xa11324ef
+284, 0x2f8b6d4b
+285, 0x3657cf17
+286, 0x35b6873f
+287, 0xee6e5bd7
+288, 0xbeeaa98
+289, 0x9ad3c581
+290, 0xe2376c3f
+291, 0x738027cc
+292, 0x536ac839
+293, 0xf066227
+294, 0x6c9cb0f9
+295, 0x84082ae6
+296, 0xab38ae9d
+297, 0x493eade9
+298, 0xcb630b3a
+299, 0x64d44250
+300, 0xe5efb557
+301, 0xea2424d9
+302, 0x11a690ba
+303, 0x30a48ae4
+304, 0x58987e53
+305, 0x94ec6076
+306, 0x5d3308fa
+307, 0xf1635ebb
+308, 0x56a5ab90
+309, 0x2b2f2ee4
+310, 0x6f9e6483
+311, 0x8b93e327
+312, 0xa7ce140b
+313, 0x4c8aa42
+314, 0x7657bb3f
+315, 0xf250fd75
+316, 0x1edfcb0f
+317, 0xdb42ace3
+318, 0xf8147e16
+319, 0xd1992bd
+320, 0x64bb14d1
+321, 0x423e724d
+322, 0x7b172f7c
+323, 0x17171696
+324, 0x4acaf83b
+325, 0x7a83527e
+326, 0xfc980c60
+327, 0xc8b56bb
+328, 0x2453f77f
+329, 0x85ad1bf9
+330, 0x62a85dfe
+331, 0x48238c4d
+332, 0xbb3ec1eb
+333, 0x4c1c039c
+334, 0x1f37f571
+335, 0x98aecb63
+336, 0xc3b3ddd6
+337, 0xd22dad4
+338, 0xe49671a3
+339, 0xe3baf945
+340, 0xb9e21680
+341, 0xda562856
+342, 0xe8b88ce4
+343, 0x86f88de2
+344, 0x986faf76
+345, 0x6f0025c3
+346, 0x3fe21234
+347, 0xd8d3f729
+348, 0xc2d11c6f
+349, 0xd4f9e8f
+350, 0xf61a0aa
+351, 0xc48bb313
+352, 0xe944e940
+353, 0xf1801b2e
+354, 0x253590be
+355, 0x981f069d
+356, 0x891454d8
+357, 0xa4f824ad
+358, 0x6dd2cc48
+359, 0x3018827e
+360, 0x3fb329e6
+361, 0x65276517
+362, 0x8d2c0dd2
+363, 0xc965b48e
+364, 0x85d14d90
+365, 0x5a51623c
+366, 0xa9573d6a
+367, 0x82d00edf
+368, 0x5ed7ce07
+369, 0x1d946abc
+370, 0x24fa567b
+371, 0x83ef5ecc
+372, 0x9001724a
+373, 0xc4fe48f3
+374, 0x1e07c25c
+375, 0xf4d5e65e
+376, 0xb734f6e9
+377, 0x327a2df8
+378, 0x766d59b7
+379, 0x625e6b61
+380, 0xe82f32d7
+381, 0x1566c638
+382, 0x2e815871
+383, 0x606514aa
+384, 0x36b7386e
+385, 0xcaa8ce08
+386, 0xb453fe9c
+387, 0x48574e23
+388, 0x71f0da06
+389, 0xa8a79463
+390, 0x6b590210
+391, 0x86e989db
+392, 0x42899f4f
+393, 0x7a654ef9
+394, 0x4c4fe932
+395, 0x77b2fd10
+396, 0xb6b4565c
+397, 0xa2e537a3
+398, 0xef5a3dca
+399, 0x41235ea8
+400, 0x95c90541
+401, 0x50ad32c4
+402, 0xc1b8e0a4
+403, 0x498e9aab
+404, 0xffc965f1
+405, 0x72633485
+406, 0x3a731aef
+407, 0x7cfddd0b
+408, 0xb04d4129
+409, 0x184fc28e
+410, 0x424369b0
+411, 0xf9ae13a1
+412, 0xaf357c8d
+413, 0x7a19228e
+414, 0xb46de2a8
+415, 0xeff2ac76
+416, 0xa6c9357b
+417, 0x614f19c1
+418, 0x8ee1a53f
+419, 0xbe1257b1
+420, 0xf72651fe
+421, 0xd347c298
+422, 0x96dd2f23
+423, 0x5bb1d63e
+424, 0x32e10887
+425, 0x36a144da
+426, 0x9d70e791
+427, 0x5e535a25
+428, 0x214253da
+429, 0x2e43dd40
+430, 0xfc0413f4
+431, 0x1f5ea409
+432, 0x1754c126
+433, 0xcdbeebbe
+434, 0x1fb44a14
+435, 0xaec7926
+436, 0xb9d9a1e
+437, 0x9e4a6577
+438, 0x8b1f04c5
+439, 0x19854e8a
+440, 0x531080cd
+441, 0xc0cbd73
+442, 0x20399d77
+443, 0x7d8e9ed5
+444, 0x66177598
+445, 0x4d18a5c2
+446, 0xe08ebf58
+447, 0xb1f9c87b
+448, 0x66bedb10
+449, 0x26670d21
+450, 0x7a7892da
+451, 0x69b69d86
+452, 0xd04f1d1c
+453, 0xaf469625
+454, 0x7946b813
+455, 0x1ee596bd
+456, 0x7f365d85
+457, 0x795b662b
+458, 0x194ad02d
+459, 0x5a9649b5
+460, 0x6085e278
+461, 0x2cf54550
+462, 0x9c77ea0b
+463, 0x3c6ff8b
+464, 0x2141cd34
+465, 0xb90bc671
+466, 0x35037c4b
+467, 0xd04c0d76
+468, 0xc75bff8
+469, 0x8f52003b
+470, 0xfad3d031
+471, 0x667024bc
+472, 0xcb04ea36
+473, 0x3e03d587
+474, 0x2644d3a0
+475, 0xa8fe99ba
+476, 0x2b9a55fc
+477, 0x45c4d44a
+478, 0xd059881
+479, 0xe07fcd20
+480, 0x4e22046c
+481, 0x7c2cbf81
+482, 0xbf7f23de
+483, 0x69d924c3
+484, 0xe53cd01
+485, 0x3879017c
+486, 0xa590e558
+487, 0x263bc076
+488, 0x245465b1
+489, 0x449212c6
+490, 0x249dcb29
+491, 0x703d42d7
+492, 0x140eb9ec
+493, 0xc86c5741
+494, 0x7992aa5b
+495, 0xb8b76a91
+496, 0x771dac3d
+497, 0x4ecd81e3
+498, 0xe5ac30b3
+499, 0xf4d7a5a6
+500, 0xac24b97
+501, 0x63494d78
+502, 0x627ffa89
+503, 0xfa4f330
+504, 0x8098a1aa
+505, 0xcc0c61dc
+506, 0x34749fa0
+507, 0x7f217822
+508, 0x418d6f15
+509, 0xa4b6e51e
+510, 0x1036de68
+511, 0x1436986e
+512, 0x44df961d
+513, 0x368e4651
+514, 0x6a9e5d8c
+515, 0x27d1597e
+516, 0xa1926c62
+517, 0x8d1f2b55
+518, 0x5797eb42
+519, 0xa90f9e81
+520, 0x57547b10
+521, 0xdbbcca8e
+522, 0x9edd2d86
+523, 0xbb0a7527
+524, 0x7662380c
+525, 0xe7c98590
+526, 0x950fbf3f
+527, 0xdc2b76b3
+528, 0x8a945102
+529, 0x3f0a1a85
+530, 0xeb215834
+531, 0xc59f2802
+532, 0xe2a4610
+533, 0x8b5a8665
+534, 0x8b2d9933
+535, 0x40a4f0bc
+536, 0xaab5bc67
+537, 0x1442a69e
+538, 0xdf531193
+539, 0x698d3db4
+540, 0x2d40324e
+541, 0x1a25feb2
+542, 0xe8cc898f
+543, 0xf12e98f5
+544, 0xc03ad34c
+545, 0xf62fceff
+546, 0xdd827e1e
+547, 0x7d8ccb3b
+548, 0xab2d6bc1
+549, 0xc323a124
+550, 0x8184a19a
+551, 0xc3c4e934
+552, 0x5487424d
+553, 0xd6a81a44
+554, 0x90a8689d
+555, 0xe69c4c67
+556, 0xbdae02dd
+557, 0x72a18a79
+558, 0x2a88e907
+559, 0x31cf4b5d
+560, 0xb157772f
+561, 0x206ba601
+562, 0x18529232
+563, 0x7dac90d8
+564, 0x3a5f8a09
+565, 0x9f4b64a3
+566, 0xae373af9
+567, 0x1d79447c
+568, 0x2a23684b
+569, 0x41fb7ba4
+570, 0x55e4bb9e
+571, 0xd7619d3e
+572, 0xc04e4dd8
+573, 0x8418d516
+574, 0x2b2ca585
+575, 0xfa8eedf
+576, 0x5bafd977
+577, 0x31974fb0
+578, 0x9eb6697b
+579, 0xc8be22f5
+580, 0x173b126a
+581, 0x8809becf
+582, 0x3e41efe1
+583, 0x3d6cbbb8
+584, 0x278c81d8
+585, 0xa6f08434
+586, 0xa0e6601d
+587, 0x2fccd88d
+588, 0x3cbc8beb
+589, 0x5f65d864
+590, 0xa1ff8ddf
+591, 0x609dcb7c
+592, 0x4a4e1663
+593, 0xeae5531
+594, 0x962a7c85
+595, 0x1e110607
+596, 0x8c5db5d0
+597, 0xc7f2337e
+598, 0xc94fcc9c
+599, 0xe7f62629
+600, 0x6c9aa9f8
+601, 0x2e27fe0e
+602, 0x4d0dae12
+603, 0x9eecf588
+604, 0x977ba3f2
+605, 0xed0a51af
+606, 0x3f3ec633
+607, 0xc174b2ec
+608, 0x590be8a9
+609, 0x4f630d18
+610, 0xf579e989
+611, 0xe2a55584
+612, 0xee11edcd
+613, 0x150a4833
+614, 0xc0a0535c
+615, 0xb5e00993
+616, 0xb6435700
+617, 0xa98dbff
+618, 0x315716af
+619, 0x94395776
+620, 0x6cbd48d9
+621, 0xab17f8fc
+622, 0xa794ffb7
+623, 0x6b55e231
+624, 0x89ff5783
+625, 0x431dcb26
+626, 0x270f9bf8
+627, 0x2af1b8d0
+628, 0x881745ed
+629, 0x17e1be4e
+630, 0x132a0ec4
+631, 0x5712df17
+632, 0x2dfb3334
+633, 0xf5a35519
+634, 0xcafbdac6
+635, 0x73b6189d
+636, 0x10107cac
+637, 0x18c1045e
+638, 0xbc19bbad
+639, 0x8b4f05ac
+640, 0x5830d038
+641, 0x468cd98a
+642, 0x5b83a201
+643, 0xf0ccdd9c
+644, 0xcb20c4bd
+645, 0x1ff186c9
+646, 0xcdddb47f
+647, 0x5c65ce6
+648, 0xb748c580
+649, 0x23b6f262
+650, 0xe2ba8e5c
+651, 0x9a164a03
+652, 0x62d3322e
+653, 0x918d8b43
+654, 0x45c8b49d
+655, 0xce172c6e
+656, 0x23febc6
+657, 0x84fdc5b7
+658, 0xe7d1fd82
+659, 0xf0ddf3a6
+660, 0x87050436
+661, 0x13d46375
+662, 0x5b191c78
+663, 0x2cbd99c0
+664, 0x7686c7f
+665, 0xcff56c84
+666, 0x7f9b4486
+667, 0xefc997fe
+668, 0x984d4588
+669, 0xfa44f36a
+670, 0x7a5276c1
+671, 0xcfde6176
+672, 0xcacf7b1d
+673, 0xcffae9a7
+674, 0xe98848d5
+675, 0xd4346001
+676, 0xa2196cac
+677, 0x217f07dc
+678, 0x42d5bef
+679, 0x6f2e8838
+680, 0x4677a24
+681, 0x4ad9cd54
+682, 0x43df42af
+683, 0x2dde417
+684, 0xaef5acb1
+685, 0xf377f4b3
+686, 0x7d870d40
+687, 0xe53df1c2
+688, 0xaeb5be50
+689, 0x7c92eac0
+690, 0x4f00838c
+691, 0x91e05e84
+692, 0x23856c80
+693, 0xc4266fa6
+694, 0x912fddb
+695, 0x34d42d22
+696, 0x6c02ffa
+697, 0xe47d093
+698, 0x183c55b3
+699, 0xc161d142
+700, 0x3d43ff5f
+701, 0xc944a36
+702, 0x27bb9fc6
+703, 0x75c91080
+704, 0x2460d0dc
+705, 0xd2174558
+706, 0x68062dbf
+707, 0x778e5c6e
+708, 0xa4dc9a
+709, 0x7a191e69
+710, 0xc084b2ba
+711, 0xbb391d2
+712, 0x88849be
+713, 0x69c02714
+714, 0x69d4a389
+715, 0x8f51854d
+716, 0xaf10bb82
+717, 0x4d5d1c77
+718, 0x53b53109
+719, 0xa0a92aa0
+720, 0x83ecb757
+721, 0x5325752a
+722, 0x114e466e
+723, 0x4b3f2780
+724, 0xa7a6a39c
+725, 0x5e723357
+726, 0xa6b8be9b
+727, 0x157c32ff
+728, 0x8b898012
+729, 0xd7ff2b1e
+730, 0x69cd8444
+731, 0x6ad8030c
+732, 0xa08a49ec
+733, 0xfbc055d3
+734, 0xedf17e46
+735, 0xc9526200
+736, 0x3849b88a
+737, 0x2746860b
+738, 0xae13d0c1
+739, 0x4f15154f
+740, 0xd65c3975
+741, 0x6a377278
+742, 0x54d501f7
+743, 0x81a054ea
+744, 0x143592ba
+745, 0x97714ad6
+746, 0x4f9926d9
+747, 0x4f7ac56d
+748, 0xe87ca939
+749, 0x58b76f6f
+750, 0x60901ad8
+751, 0x3e401bb6
+752, 0xa058468e
+753, 0xc0bb14f6
+754, 0x2cb8f02a
+755, 0x7c2cf756
+756, 0x34c31de5
+757, 0x9b243e83
+758, 0xa5c85ab4
+759, 0x2741e3b3
+760, 0x1249000e
+761, 0x3fc4e72b
+762, 0xa3e038a2
+763, 0x952dd92c
+764, 0x2b821966
+765, 0xfa81b365
+766, 0x530919b9
+767, 0x4486d66f
+768, 0xccf4f3c1
+769, 0xa8bddd1d
+770, 0xcc295eb9
+771, 0xfccbe42f
+772, 0x38bacd8d
+773, 0x2261854f
+774, 0x56068c62
+775, 0x9bdaeb8
+776, 0x555fa5b6
+777, 0x20fe615e
+778, 0x49fb23d3
+779, 0xd093bad6
+780, 0x54919e86
+781, 0x7373eb24
+782, 0xfbaa7a98
+783, 0x5f62fb39
+784, 0xe03bc9ec
+785, 0xa5074d41
+786, 0xa1cefb1
+787, 0x13912d74
+788, 0xf6421b8
+789, 0xfcb48812
+790, 0x8f1db50b
+791, 0xc1654b87
+792, 0x948b43c2
+793, 0xf503ef77
+794, 0x117d891d
+795, 0x5493ffa
+796, 0x171313b1
+797, 0xa4b62e1e
+798, 0x77454ea6
+799, 0xbea0aff0
+800, 0x13c36389
+801, 0xe3b60bac
+802, 0xa176bed3
+803, 0x2863d428
+804, 0xe2314f46
+805, 0xa85cd3d4
+806, 0x7866e57
+807, 0x8f03f5bc
+808, 0x239ae
+809, 0x46f279fb
+810, 0xcca00559
+811, 0xaa07a104
+812, 0x89123d08
+813, 0x2e6856ba
+814, 0x43a9780d
+815, 0x676cff25
+816, 0x6744b87d
+817, 0xee260d4f
+818, 0xb98d8b77
+819, 0x9b0ca455
+820, 0x659f6fe
+821, 0x28d20d1c
+822, 0x601f2657
+823, 0xdec3073e
+824, 0x61263863
+825, 0x1a13435a
+826, 0x27497d1e
+827, 0x17a8458e
+828, 0xdddc407d
+829, 0x4bb2e8ac
+830, 0x16b2aedb
+831, 0x77ccd696
+832, 0x9d108fcd
+833, 0x25ad233e
+834, 0xaa9bc370
+835, 0xa873ab50
+836, 0xaf19c9d9
+837, 0x696e1e6b
+838, 0x1fdc4bf4
+839, 0x4c2ebc81
+840, 0xde4929ed
+841, 0xf4d0c10c
+842, 0xb6595b76
+843, 0x75cbb1b3
+844, 0xbcb6de49
+845, 0xe23157fd
+846, 0x5e596078
+847, 0xa69b0d29
+848, 0x2118a41
+849, 0x7088c16
+850, 0xc75e1e1
+851, 0x6a4af2d6
+852, 0xf19c6521
+853, 0xaff7b3b1
+854, 0x615295c7
+855, 0xbda3a8d7
+856, 0x5b5ca72e
+857, 0xdad9d80f
+858, 0xfa81c084
+859, 0xf4703fa
+860, 0x3ca54540
+861, 0xa8961d51
+862, 0x53d1ecc2
+863, 0x808d83b6
+864, 0x68e8c48e
+865, 0x89be2039
+866, 0x9088ea11
+867, 0xb8665d12
+868, 0x91272f9
+869, 0x53dddff2
+870, 0xb7a54ab
+871, 0xd2b645ca
+872, 0x99fb8590
+873, 0x5315c8e
+874, 0x2a913806
+875, 0x7f15eb2b
+876, 0xa7f1cc5d
+877, 0xbb2ee836
+878, 0xd9fafd60
+879, 0x17448d6f
+880, 0x999ec436
+881, 0x482ec606
+882, 0x9b403c0e
+883, 0x569eb51b
+884, 0xb275d1a6
+885, 0xadd29c31
+886, 0xb7ebdb15
+887, 0xdfef3662
+888, 0x51aba6db
+889, 0x6d41946d
+890, 0x77bf8896
+891, 0xcafa6fab
+892, 0x976ab40f
+893, 0x49a6d86b
+894, 0x56639e55
+895, 0x9945b996
+896, 0x81459b50
+897, 0xbce97542
+898, 0xe397c9c9
+899, 0x247a5955
+900, 0xb72b1573
+901, 0x86306f86
+902, 0x34f65dc5
+903, 0x909360c0
+904, 0xf3f696ef
+905, 0xcb9faae5
+906, 0x93daecd9
+907, 0xde1af7af
+908, 0x43a1f2d
+909, 0x6d75cde5
+910, 0x9e412b6
+911, 0x5673fed
+912, 0x16bb511a
+913, 0x35ef4cca
+914, 0x4e615aca
+915, 0x5cdaf47a
+916, 0x26676047
+917, 0x8c199325
+918, 0x2adf0cb9
+919, 0x84f2e6fd
+920, 0x5e627f64
+921, 0xb7cee354
+922, 0x542ab4a6
+923, 0xe59cd83b
+924, 0x89cc3f10
+925, 0x92b0f5f
+926, 0xc1328370
+927, 0x8208d9f7
+928, 0x68eb00cf
+929, 0xfadd4ac4
+930, 0x2517784f
+931, 0x4042b99
+932, 0x75ce0230
+933, 0x97c5a1b4
+934, 0x1a97f709
+935, 0x4c62781e
+936, 0xf530a83
+937, 0x75776413
+938, 0x321c7240
+939, 0x6afe4e36
+940, 0xad00a2b4
+941, 0xbc05477d
+942, 0xb0911e80
+943, 0x9935b87d
+944, 0xd535eec5
+945, 0x149af45e
+946, 0x786934b0
+947, 0xbc13cdac
+948, 0x208bfa2e
+949, 0xcf4b39cc
+950, 0x6ac6c172
+951, 0xbfa9a37
+952, 0x42d28db6
+953, 0x2bf1ea63
+954, 0xbed6e677
+955, 0x50325d27
+956, 0xa79d3b8b
+957, 0x52448bb1
+958, 0xefaad1bd
+959, 0x833a2e54
+960, 0xd9de549a
+961, 0x9f59672f
+962, 0x9d5f5f16
+963, 0x1c914489
+964, 0xc08fa058
+965, 0xb188698b
+966, 0xdc4672b5
+967, 0x594f720e
+968, 0x56ed428f
+969, 0x9b0898af
+970, 0x8a64d3d5
+971, 0x773308d6
+972, 0x84d62098
+973, 0x46da7cf9
+974, 0x1114eae7
+975, 0xf9f2a092
+976, 0x5363a28
+977, 0xf2db7b3a
+978, 0x102c71a9
+979, 0xe8e76aaf
+980, 0x77a97b3b
+981, 0x77b090d
+982, 0x1099620e
+983, 0xa6daaae6
+984, 0x86ff4713
+985, 0xc0ef85b8
+986, 0xf621d409
+987, 0xfd1561e2
+988, 0x4bcc687d
+989, 0x596f760
+990, 0x7c8819f9
+991, 0x8cb865b8
+992, 0xadea115a
+993, 0x56609348
+994, 0xb321ac14
+995, 0x1bac7db2
+996, 0x5fe6ee2
+997, 0xe9bfe072
+998, 0x15549e74
+999, 0xad8c191b
diff --git a/venv/lib/python3.12/site-packages/numpy/random/tests/data/pcg64-testset-1.csv b/venv/lib/python3.12/site-packages/numpy/random/tests/data/pcg64-testset-1.csv
new file mode 100644
index 00000000..0c8271fa
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/random/tests/data/pcg64-testset-1.csv
@@ -0,0 +1,1001 @@
+seed, 0xdeadbeaf
+0, 0x60d24054e17a0698
+1, 0xd5e79d89856e4f12
+2, 0xd254972fe64bd782
+3, 0xf1e3072a53c72571
+4, 0xd7c1d7393d4115c9
+5, 0x77b75928b763e1e2
+6, 0xee6dee05190f7909
+7, 0x15f7b1c51d7fa319
+8, 0x27e44105f26ac2d7
+9, 0xcc0d88b29e5b415
+10, 0xe07b1a90c685e361
+11, 0xd2e430240de95e38
+12, 0x3260bca9a24ca9da
+13, 0x9b3cf2e92385adb7
+14, 0x30b5514548271976
+15, 0xa3a1fa16c124faf9
+16, 0xf53e17e918e45bb6
+17, 0x26f19faaeb833bfc
+18, 0x95e1d605730cce1b
+19, 0xa7b520c5c093c1aa
+20, 0x4b68c010c9b106a3
+21, 0x25e19fe91df703f0
+22, 0x898364bb0bf593cb
+23, 0x5bd6ab7dbaa125db
+24, 0xd1fe47f25152045c
+25, 0x3bb11919addf2409
+26, 0x26a8cb7b3f54af8
+27, 0xe6a27ee11200aa24
+28, 0x7cb585ab01e22000
+29, 0x78e60028676d2ef3
+30, 0x5c32535e5a899528
+31, 0x83e8b6f8c4a46fb3
+32, 0xe56ef7668a161246
+33, 0x36dcbc15aeb73055
+34, 0x5ea247f0bd188acb
+35, 0x438b547b84601a80
+36, 0x8acda2a1273e9e3d
+37, 0x2b05e30a4b40c24c
+38, 0xfd87236bd13af032
+39, 0x471df211d8d985ef
+40, 0x18e8a5609a793292
+41, 0x46f0951fab6dc4e3
+42, 0x6c199c4e700f6795
+43, 0xf04aa16bfb7d22cb
+44, 0xd763d269fbaffc89
+45, 0x9991930cefbe5c2b
+46, 0xb2a11b953f824c96
+47, 0x63fd9f52172c44b0
+48, 0x183bdad907b1d848
+49, 0xe17953cddb931c52
+50, 0x515cf16726ec205a
+51, 0x88c327605150711a
+52, 0xc7090dd79cbc8dc3
+53, 0xcb487cedeb00a350
+54, 0xc8abf254d87b657
+55, 0xd43cc4cbfb493d1a
+56, 0x8705452e5d9ed1e
+57, 0xcecd11446769cf43
+58, 0xde72156c8d65bc69
+59, 0x796a8f0f47d52ee8
+60, 0xb4c0da443917d6c3
+61, 0xe07ad7568a8e3dc3
+62, 0xc24a8da39ce6dc21
+63, 0x92b21ea80a8556eb
+64, 0x572f21e531edf3af
+65, 0x9b917ed56bbed198
+66, 0xe65fd8ddc5ab3d7d
+67, 0xf55a80a8ec84fa18
+68, 0x18fc22e1a5227b61
+69, 0x72305dc7eeaa79d3
+70, 0x47ce58a36e7592cf
+71, 0x14c6374340c0f7cc
+72, 0x6f98273d4eb5a2c
+73, 0x59a8702c46fe8f8a
+74, 0xb67cbd8113cfe57f
+75, 0xaa03c5db5f5b7690
+76, 0x3fb0f77ea4568013
+77, 0x756530990398b26e
+78, 0x4c1952b2a3a6a343
+79, 0x1da15c5383074582
+80, 0xb405b21c81c274f7
+81, 0xbe664677a16788b
+82, 0x9d2e37550bcee656
+83, 0x8b4589f0d9defe02
+84, 0x2935f018ee06a59
+85, 0x3834bf88be97ed11
+86, 0xa610d049cea79b6d
+87, 0xd49ffc0d09a59ea9
+88, 0x4073365b76567adf
+89, 0x499eefb9bb7513e2
+90, 0x74a743ee6b0138a9
+91, 0x3bf0880f2d947594
+92, 0x555d1c0498600a99
+93, 0x923b32a88ef2ffa4
+94, 0x7325411065fbedea
+95, 0x9f4129ff8b79d300
+96, 0xab2b0a9b8a3785dc
+97, 0x11734bdfba3a1713
+98, 0xc8333398841ba585
+99, 0xee2409cc234e6742
+100, 0xf6638e700872ecd2
+101, 0x10875300c13cd284
+102, 0x27a9bbed7c15b2d3
+103, 0x3c87f8fef31ce9bd
+104, 0x92be263cd0914a95
+105, 0xa7b0f11bc742307e
+106, 0x4a56f788cc1c1a3c
+107, 0x4a130fa32257a48b
+108, 0x5d4d9eda16e90286
+109, 0x7cc2af564844bedc
+110, 0x2532867bfe7cda1a
+111, 0xb1c504676611fd17
+112, 0xce8e86cfb4189aee
+113, 0x99685898980d1970
+114, 0x8c3b67db23bcf1e
+115, 0x73e14c93905b135f
+116, 0xf0271b64ac2bd4d3
+117, 0xf4beba82f3ec1b2d
+118, 0x1cdbf3ee9f210af
+119, 0x2e938557c09c3ea6
+120, 0x2d314ccfa6ffd81d
+121, 0x31ad47079950ade4
+122, 0x342b27547b900872
+123, 0x171b0e20b9ef1a76
+124, 0xdf10ce6318b03654
+125, 0x1d625df4aa718897
+126, 0x8712715a9f6e02ec
+127, 0xb4a072da725bca3b
+128, 0x19d346cb7734bd42
+129, 0xfd4281d311cb2958
+130, 0x58274c9519fc8789
+131, 0x4cacf29d885fd544
+132, 0x784b14d1c2523b80
+133, 0x2d25242131bb2373
+134, 0xcd2a5e43a7d9abf9
+135, 0x15eda3806e650ecb
+136, 0xdaac5e277d764d96
+137, 0xdc5a5dd59aaa94e0
+138, 0x40d00237a46d5999
+139, 0x6205dd35a692743f
+140, 0xbbd8236740361f09
+141, 0x1625c9f4e7288bf9
+142, 0xb74f12df1479e3ce
+143, 0xb2d72a51b43d7131
+144, 0xf006a324b3707c83
+145, 0x28e8ab4abe7655b8
+146, 0xfb480093ad7ab55
+147, 0x3f8abd0d6ff8d272
+148, 0xc81a94177ac26bb7
+149, 0x3cdc178307751b14
+150, 0x9de84cc2b10ba025
+151, 0x3f8ab5aefcd046e2
+152, 0x43bdb894e1ee83b2
+153, 0xe288a40f3f06ac9d
+154, 0xdab62a7d04b4f30f
+155, 0x49f4e20295e1a805
+156, 0x3643764805e0edef
+157, 0x9449954618b6b
+158, 0x6c87e0d4508e0ce0
+159, 0x3a334be688a9dd7b
+160, 0xb35c39228776e499
+161, 0xc4118bfff938490e
+162, 0x88cbde3dcbb034b2
+163, 0xf91b287793c417c3
+164, 0x42b15f731a59f5b3
+165, 0xffa27104bbe4814d
+166, 0x1b6789d138beccde
+167, 0x542c2c1440d0ceb9
+168, 0x367294504d18fa0d
+169, 0xf918b60e804a1b58
+170, 0xd390964e33a9d0e3
+171, 0x23bb1be7c4030fe8
+172, 0x9731054d039a8afb
+173, 0x1a6205026b9d139b
+174, 0x2fa13b318254a07e
+175, 0x69571de7d8520626
+176, 0x641a13d7c03332b7
+177, 0x76a6237818f7a441
+178, 0x4e77860d0c660d81
+179, 0x4441448a1c1cbdb2
+180, 0xccd7783a042046e5
+181, 0xf620d8e0805e3200
+182, 0x7de02971367fdd0c
+183, 0x539c263c5914cab1
+184, 0x9c3b9ba1a87bbf08
+185, 0x6d95baa34cda215f
+186, 0x2db3f83ace0bac5f
+187, 0x7f5af1da2dc670a4
+188, 0xfcc098d16c891bfb
+189, 0x81a33df1d7a5ab12
+190, 0x767b0f863c8e9882
+191, 0x7a92983830de483d
+192, 0xfa7598c37a79ac25
+193, 0xb89b3ca42ce03053
+194, 0x457a542b8efed4f7
+195, 0x571b7737fd0eeda7
+196, 0xa0f59e524485c0a
+197, 0x82dca766b7901efd
+198, 0xa68243caf6a3bd5d
+199, 0x1bac981c6c740e5e
+200, 0xbcd51bedf9103e44
+201, 0x4e197efd3ae5a7bf
+202, 0x523568efd782268b
+203, 0x5ec4ef1191fef09
+204, 0xed751ed5e31c9ab
+205, 0x44eac24de03e1b29
+206, 0x9237d57c011d3fb3
+207, 0xa8c6da0f7692f235
+208, 0x9f9eb6bc15d6cac7
+209, 0x34bb8e0c93427aad
+210, 0x115febd738eaac4a
+211, 0xa439991ed139d27a
+212, 0x45c7c2633d8710a2
+213, 0x48b7475f3405a3ce
+214, 0x80158497c77bd00b
+215, 0x935c316a5b1657cb
+216, 0x59c5d54440e9695e
+217, 0x337c78c5b3d0ede2
+218, 0x8c46bb956b93790d
+219, 0xbf1dd03e471d71c5
+220, 0x2d375e90a4bef583
+221, 0xd0365428331b3790
+222, 0xfcd3969ac827ecd4
+223, 0x392fb6c580498410
+224, 0x6d6db4ceab5ea6c0
+225, 0x9bf84f1972e24786
+226, 0x798dfd820959dcc5
+227, 0x2e425095e65e8bfb
+228, 0x8c1aa11536b1c9c3
+229, 0xd28e2ef9b12f6f74
+230, 0x86583bc98c8f78d2
+231, 0x489877530e3f93e7
+232, 0xb1d9430631104a15
+233, 0x1814f6098e6263bd
+234, 0x8e2658a4e0d4cd53
+235, 0x5afe20e2531cdb2a
+236, 0x30d02f7c4755c9bf
+237, 0xe1e217cda16ed2d2
+238, 0xccb4913a42e3b791
+239, 0xfff21363ac183226
+240, 0xe788690bbda147a7
+241, 0x76905cf5917bfc6a
+242, 0x2a8fa58f7916f52c
+243, 0xf903c0cc0357815a
+244, 0x15d20f243a4998d2
+245, 0x5b7decee5a86ea44
+246, 0x114f7fc421211185
+247, 0x328eb21715764c50
+248, 0xaffaa3f45c0678fd
+249, 0x2579e6ef50378393
+250, 0x7610ab7743c19795
+251, 0xf9923d2bd101b197
+252, 0x57e42e7a62ba7e53
+253, 0x9f1dc217b4f02901
+254, 0x88a9ebd86509b234
+255, 0x867fc926aecc8591
+256, 0xaf22c1bfef04c718
+257, 0x39f701f0313f4288
+258, 0x6171ad397e6faab2
+259, 0x239bb5b9abdec4fc
+260, 0xd9a591e25dd01c6e
+261, 0x826dc4a75b628e49
+262, 0xf112b152c408f47
+263, 0x6843a06110f86c0
+264, 0x965e56a7185c1332
+265, 0x8d84492edbc71710
+266, 0xeee8ec111cfd1319
+267, 0xf2858e94ad98e458
+268, 0xbc9589fdf5f3a97e
+269, 0xaf0ceef3bc375130
+270, 0x48f4aaf13fa75c1e
+271, 0x111e9db47bee758f
+272, 0xea3171df130164ba
+273, 0x2a7bbe30bf827ab6
+274, 0xc516c3fdbf758c35
+275, 0xec55097754b04be5
+276, 0x374a997d52b6d3e6
+277, 0x487df5456085ffbc
+278, 0x528883b84df8eafe
+279, 0x805f77ab5ba26f86
+280, 0x8eb81477dc04f213
+281, 0x471ea08ec6794d72
+282, 0x69d3667ecc4d2176
+283, 0x98b7b6e295548a66
+284, 0x3877713c173f8f2
+285, 0xa00542570d0e8de3
+286, 0xf534b1bfa4033e50
+287, 0x7e1fedeac8bf6b26
+288, 0x8043f37c89628af4
+289, 0x1dd7039ec295e86d
+290, 0xce9c05b763a40cc4
+291, 0x246926481e61028f
+292, 0xb7cb0f1babf5893b
+293, 0xefe6b777f37fc63e
+294, 0xebbcabb4cb35cdcb
+295, 0x39fa63cd711eeea9
+296, 0xad5d3ba7aaf30c8d
+297, 0x8e9e78fe46021990
+298, 0xc7eaef6e7d5a3c62
+299, 0xefccdd5495d3f386
+300, 0x2179557ee8cfc76a
+301, 0x88a77f621f0885ce
+302, 0xafda62674543d90c
+303, 0xb8e6fbe2e13e56c0
+304, 0x8bfbbe26a14f9b1a
+305, 0x1404f59f5851f8c3
+306, 0x1140c53a0489566d
+307, 0x3edf2d138b5c3f1d
+308, 0x75d6bb275d817dc
+309, 0x8e660ae27107664e
+310, 0x7a8021038ee303e1
+311, 0x2042ef5eefa9079f
+312, 0xe3e7b90bbf6d457a
+313, 0xf3f819d2bb9405b
+314, 0x522e42155cae0c10
+315, 0xf5bfbb975b40e233
+316, 0x2cf82b614dd95cfa
+317, 0x183ef4a96bc40e55
+318, 0x9f6e351c5ba4e752
+319, 0x37c1110683c90846
+320, 0x1d89b7a996d8a977
+321, 0x18a444f77c7cb4d9
+322, 0xd0a8a971b78dc893
+323, 0x860232fb9e6543f1
+324, 0x60b6097f51002555
+325, 0xca1e5214123e3894
+326, 0xe03fe695c95f99bb
+327, 0x2c7c6779d5f03622
+328, 0xafeeee42f63055d1
+329, 0x670dde905515936a
+330, 0x9a922f42b59fb094
+331, 0xddb5ff49af5a651a
+332, 0xe61b04c9e58ebbf8
+333, 0x4e459dcf272e7fc4
+334, 0xd549e92c16adceeb
+335, 0x7a17dba1299d4a9c
+336, 0x825d756109f2b585
+337, 0xba142e61a9cb203e
+338, 0xc2a19f00e9c04a30
+339, 0x2d0f8140d23d0652
+340, 0x8b866d4d4d6caaf4
+341, 0x4f11d90dd91f8217
+342, 0xf6efc37373b9e0d
+343, 0x248493d6cd6a4736
+344, 0xd12b6ae74a951a3e
+345, 0x56e34722070b70a7
+346, 0x22d3f201cc9fa0eb
+347, 0xbfdcc320008291b7
+348, 0x1a7a6922e9204fbd
+349, 0x831421e0c4945ae4
+350, 0x66316feddddf0e11
+351, 0xa8c86a1517456554
+352, 0x14a9049ad989e335
+353, 0x837022259f141ecd
+354, 0xcb71793a06c261f7
+355, 0x4aeefc07ebe09a79
+356, 0x8982f15aa3b6594b
+357, 0x67bccfa7ed9b0d5b
+358, 0xb377463b523e9dec
+359, 0x53d3d594870fecb7
+360, 0xa5274b1caec5a60a
+361, 0xd6316d0cb643db39
+362, 0xabc1a9b536de88ce
+363, 0xed2fdb1383d2a077
+364, 0x12319c6feb97221b
+365, 0x7e0f6cd40ef47403
+366, 0x86135c84fe26dbf8
+367, 0xc96622d3fbbee19b
+368, 0xe3989d8d8511573f
+369, 0x42cc365554d1fdc7
+370, 0x4c1a1eb8bbce8b4f
+371, 0xfc4e30e7ef2034c1
+372, 0xc490444317a91e76
+373, 0x7ccdf469ff5dc81c
+374, 0xf5a0da4110cc09d7
+375, 0x505227baf34c0fb5
+376, 0xbe58737e8a35cc88
+377, 0xd449bee91b3e8c41
+378, 0x3e590e23299d0e6
+379, 0x291a7d9e0a64caf7
+380, 0xdc6fafbdfebd2293
+381, 0x8223f1e259fe8a65
+382, 0x6186fbc9efd9e3df
+383, 0xfda39b07e4007ffb
+384, 0xfc19aea98574dc02
+385, 0xd0e10d354fcacd8c
+386, 0xc9619916544a55a5
+387, 0xd454d50a8c8558cd
+388, 0xcd94a246712d91e
+389, 0x76a771f5d1231cce
+390, 0xdd20cb2b7b370ee5
+391, 0xa6f4f50feca57c49
+392, 0x78c8fb431f17ab9c
+393, 0x1b692b79a59b43cc
+394, 0x4c45045d287da7e6
+395, 0x522132e18bf43928
+396, 0x25c458983138b41c
+397, 0x2a1fb426ef229796
+398, 0x74dc324c74e5dd3d
+399, 0x6df75e3eb6eb5374
+400, 0xb63f2f4f9ca25b61
+401, 0xac72286112ee54d6
+402, 0x5a966f3d0a6863c4
+403, 0x8d7046bc64a46fc2
+404, 0xa7b740fd6e3087eb
+405, 0xcdbcbe0340cfcdf5
+406, 0xcb632613bf312b65
+407, 0xa91b3f2c2aac238b
+408, 0xa06deb3f5ae555a3
+409, 0x29d72e1f8db69
+410, 0x2d004bae09728ea6
+411, 0xc6eee5dce0736cc1
+412, 0xa7493145500ff60f
+413, 0xc4d68c4aa18ab93c
+414, 0x8210c29e79d48d7f
+415, 0xd0999d7889ecbef6
+416, 0x6e3bd61e66e93566
+417, 0xe6cc13d47d7d7b1f
+418, 0x3d6f181f42e03979
+419, 0xbed4e14fd867604a
+420, 0xbe511c84067bd86d
+421, 0x49a876d89e697d38
+422, 0xc04c3dde8f889c98
+423, 0xaf293eeab0f53e3f
+424, 0x9f6291dd65732cd6
+425, 0xd7811ac01de78c01
+426, 0xe385cf0261d50ec2
+427, 0x5a64134b3542bbf
+428, 0xf9d1302bc6f13a68
+429, 0x5d2aabbea37d8c31
+430, 0xd9842e99a5192970
+431, 0x713eadc4cd30e837
+432, 0xb7b002fc72abb413
+433, 0x276cfeea526af1cf
+434, 0x8519fe79b633a0ce
+435, 0x2f0e87363705a3e2
+436, 0x9adbac0be3c371e7
+437, 0xf3f44ba899a6173c
+438, 0x782d6c29618fde2b
+439, 0x7f61062acec408f
+440, 0x6e79cd836359258f
+441, 0x5c8e9b138df5785a
+442, 0xa54359c9f39a9a84
+443, 0xeec3f033135084b0
+444, 0x883ee717787a535c
+445, 0x9a2422b513a73b00
+446, 0x2dd4beddcdd64a58
+447, 0x90c8a13202239c7b
+448, 0x85b352ab759646d9
+449, 0x139f5cb2e46c53aa
+450, 0xe1d3ba6c721c66d1
+451, 0xaa66e0edc4b60a98
+452, 0x3521275c75be29b6
+453, 0x490a5190b3edfa5d
+454, 0xd2abcdd2ccb2f14e
+455, 0x9d9be8bef4a5857d
+456, 0xde19676f13ef7755
+457, 0xdac2fee2e42615f3
+458, 0xf4239801cb02f2ab
+459, 0xaa8bf923ed91875c
+460, 0x61d18a1940e4c7c0
+461, 0x1eb6aa3d5f077a6d
+462, 0xee7374c063bf29d8
+463, 0x2f0a59e34d76268d
+464, 0xc92e80e17d1eb3e9
+465, 0xafd05b3ec3d2ca72
+466, 0x28a61ad8d6c497b8
+467, 0xa7094d6834ad7d47
+468, 0x57d80ea9eccbb4f
+469, 0xb047e0fee6cdaf16
+470, 0x44f41b5eb48c00bb
+471, 0xd6dc8e1eb9c8c9ba
+472, 0x47adfd2c638c7849
+473, 0x365d63db7d526c68
+474, 0xc21cda439016135d
+475, 0x14d10c3f0f98863c
+476, 0xa93e56f74e037602
+477, 0x3b4e9c8915bdc9
+478, 0xb46f5ae155e54aa2
+479, 0x8e470d21ce1943e1
+480, 0x60b96301b5ba2e8d
+481, 0x1b473a41d381f9ff
+482, 0xabcf5a8e3269e73f
+483, 0xd410f6e94fb21fa1
+484, 0x65d1a47eebf87e5e
+485, 0x48eaa201c61cb843
+486, 0x212c1abc2499bfc5
+487, 0x4255ad8377d2d8d
+488, 0x44caeef472010612
+489, 0xffae764524f572f2
+490, 0x78d374d20c9ee550
+491, 0x6e003206c0511cee
+492, 0x7998a159145bfb82
+493, 0x921239650bda1d4d
+494, 0xae05025509bcfdc5
+495, 0xc6430c980be407b4
+496, 0x78524f1744b153f1
+497, 0x84089e6f468181fe
+498, 0x8d0d21d7dfb6c254
+499, 0x90bad90502a33603
+500, 0x3072a403cbd16315
+501, 0xdfadddf3f1c040c2
+502, 0x22f0b0639d9ff975
+503, 0xb49e48a4cad0765b
+504, 0x95a0a04f8239709d
+505, 0x56e147a24a4c481f
+506, 0xacf16ef61dea4c7e
+507, 0x424040afd2700de6
+508, 0xc67e8096a3c717a9
+509, 0x39f164181dd0a399
+510, 0x2449cedc1d62198c
+511, 0x7a53df11a1f1a61c
+512, 0x5596f1d4a3badae3
+513, 0x38ed4c822072b3d0
+514, 0xf07ef346b3fd730a
+515, 0xfd349c35c3ed51fd
+516, 0x2f15c9c7890f8f32
+517, 0x3b470df52b173c29
+518, 0xd31bfc8981281af7
+519, 0xbbcc9bdf561215bb
+520, 0x5782fffea326574f
+521, 0xb0ebdcfcc5e03290
+522, 0x7fd89d93d2b3fbef
+523, 0x280ea1865d9ba2
+524, 0xe726959845b2c100
+525, 0xd0361f032cd7dbb1
+526, 0x3c65ec2028b81a22
+527, 0x5221e9b2188920bf
+528, 0xeb5ab27c4125ec20
+529, 0x80a32dd48b54f0a4
+530, 0x369b5ced1012bebb
+531, 0x582d35d76530bc6f
+532, 0x7b50dc9b48e1e37d
+533, 0x37fdfe8bbacf8dad
+534, 0x7a0cb7e6e93840ea
+535, 0xa1132c870be0b2ce
+536, 0x9d8ac2c68267cd1a
+537, 0x470969b647fa7df4
+538, 0xabcb7d8adf7e2d24
+539, 0xacdebec9bdf9eb1c
+540, 0xe30f4cbf7eb6a59
+541, 0x746673836c4df41d
+542, 0x75120a6b647bb326
+543, 0x2f4eab556c3f6878
+544, 0xd84651ab05405b7a
+545, 0x9e695808b9622284
+546, 0xc93b71e56aa6e1a5
+547, 0x2be7f3be4a7b7050
+548, 0x6497e910b6733241
+549, 0xcf7050dfd08076fc
+550, 0x4e3cc156eca183f7
+551, 0xf801a33d9326c265
+552, 0x6aa293c8a47d40e6
+553, 0x28c429755faa6230
+554, 0x82b818651f54e7bb
+555, 0xa84d726d7acdbead
+556, 0x5cfa535d5774965d
+557, 0x4a34b7b1cb48d53
+558, 0x86a7b5bce426de84
+559, 0xfcd2307cecdb7318
+560, 0x16dbaaa71181a038
+561, 0x88e7e8cd261c2547
+562, 0x3c09ba6d1d5ea913
+563, 0x5dd3d643734ee5b6
+564, 0x326d725fe8cbb33
+565, 0x7bcca9ca2da8e784
+566, 0x482dcf6b11d7f9a4
+567, 0x1291b605b4cd3e04
+568, 0x6988181b50e2f4a8
+569, 0x649e3c37131fc292
+570, 0x4eeb67b9e21eba54
+571, 0xc051d39073dec45f
+572, 0xc99c52e110270d67
+573, 0xcb813d5d77868add
+574, 0x423a5f13573e7ac0
+575, 0x231ac4cc4fe73616
+576, 0x4c22b888a6e600ea
+577, 0x8059a6dc7c9e25c6
+578, 0x49f498a5b8ad22de
+579, 0xf1e812cc6d1826c8
+580, 0xbbaf60abe8b11e00
+581, 0x1d31d7f4d8be9a6a
+582, 0xfeadce70a9a10c14
+583, 0xb47c635bc136996a
+584, 0xd88e694c8da030cb
+585, 0xc41bbe132aff1364
+586, 0x34249ab18a4b0800
+587, 0xf14b5c825aa736cc
+588, 0x2710be6b08df78e
+589, 0x2ab56bcc9bf9e740
+590, 0x9b7f6e591b5f648
+591, 0xfb665c3772f34135
+592, 0x628a0a5d2db5d8d5
+593, 0xb3e3f251e61b5259
+594, 0x82310ae33faf1b23
+595, 0x24af8723a65cbd0b
+596, 0x671c93282fc4ad97
+597, 0x6cabeaac77270cad
+598, 0xef4643fe38b02b7f
+599, 0x7b011549d1ac6653
+600, 0xe2af87b9fccfe89
+601, 0x36b71ad67197ac8a
+602, 0xdbba55d06f2fd93b
+603, 0xf571dbd764b7f7e5
+604, 0x38ea402501cdbd45
+605, 0xb8ab5b5b1bab2913
+606, 0xfab973c4d45f32bd
+607, 0x9364f1717c2636b9
+608, 0xfad00f4d983e00fe
+609, 0xc90c532a11aef75a
+610, 0x64a6eda96e44783c
+611, 0x35891f2eb84520be
+612, 0x28d216080caed43
+613, 0x129629cc5bd206f6
+614, 0x22c3d39822cbb4b3
+615, 0xf1efbf4cce1eaa2b
+616, 0x7070cba12524ed08
+617, 0xa7ed0be9deabf20d
+618, 0x8ddb4cd6b454f76b
+619, 0xb82814b1db37b63
+620, 0x418e83b36de01876
+621, 0x9a538c7f39c6413
+622, 0xee0cd7abf8a2ecb9
+623, 0xa9222b07e95590f3
+624, 0x6296a415d68341e6
+625, 0x981e0a5a8f811929
+626, 0x4bb372d3b0de283d
+627, 0xa9805b5971866e16
+628, 0xaf3b5f5183497657
+629, 0x2152b0fd23c3d9f
+630, 0xb730c325b7173180
+631, 0x1e3439d231608c19
+632, 0x1c5ba6031379823c
+633, 0x87f5d12d6d365cbc
+634, 0xd3bc7f29614bc594
+635, 0x63102214bb391268
+636, 0x482bbd5bba648a44
+637, 0x6a23604690759dc4
+638, 0x4091d41408d3a39e
+639, 0x7cd017f922101b15
+640, 0x7ce9004ac5f9231
+641, 0x978bc3d8ec7f7fdf
+642, 0x5bd0c4d780580c11
+643, 0x4313c068bb040153
+644, 0x3ab7dab7bc38bf80
+645, 0x3aaf9c187728deea
+646, 0x6633a4ce8efb88d9
+647, 0x7263b089878f00fc
+648, 0xd0d767e96fe00eb8
+649, 0x184a7c0c01908028
+650, 0x1ebdf41e6f76e186
+651, 0xeb740ee1d0402083
+652, 0xfccf4974edb1c339
+653, 0x16e2707aa28306d
+654, 0x1684f0bdb018c3a5
+655, 0x887b6b67b88aa862
+656, 0x923d7810a2bea33a
+657, 0x56b3560babef5d6b
+658, 0xb39a14614c54b8c6
+659, 0x33e4dc545a509fc8
+660, 0x26e21f84142da9b
+661, 0xdd07598125756855
+662, 0x572d49a071d7ae0a
+663, 0xba3c7e3baea28760
+664, 0x7ecdb2d714db4b61
+665, 0x1c62b4920e1b2fe2
+666, 0x71bfafb70092834a
+667, 0xd710a4228f60d56a
+668, 0xeb16277d4ce4e95b
+669, 0x968168c90b16d3a1
+670, 0xac3439dfe8ad0062
+671, 0x5a8226f9dd5876ad
+672, 0xb843affe917291b0
+673, 0xd76d1e67051f8259
+674, 0xb73a6638cce8ccde
+675, 0xa0e6afd3c7295f9
+676, 0xff8857b4bbb5f4c6
+677, 0x99becf78938f0426
+678, 0xfcd17edc1e70f004
+679, 0x6223b8b23f2f50
+680, 0xca875f3e84587b4c
+681, 0x7d1e81e589f87fb9
+682, 0x9eb621586aa826fc
+683, 0xf46fb9ef5b9c2086
+684, 0x2882c9b7092725f3
+685, 0x5493f099bbedcd02
+686, 0x90c1ec979ffa811d
+687, 0x963f765025bcc53
+688, 0x56194e3ec3d9d4e9
+689, 0x7ec4720954cac1f0
+690, 0xfab3145171af7f90
+691, 0x52a0b4e41a13b593
+692, 0x740e2d4d5909d126
+693, 0x98f5339c09c94a28
+694, 0x1700e462fe8dec76
+695, 0x3dbffc2aa4695ac3
+696, 0x5763edacabdfe2a1
+697, 0x7b5b623ce49ef21d
+698, 0x30addc66f49860df
+699, 0xcc7511a6c31bceda
+700, 0x1b25b61ca75db43b
+701, 0x416bc4c298e59046
+702, 0x4cd11fe2d74e4649
+703, 0xb54458a9229fc978
+704, 0x8c21a27882b6ca35
+705, 0x57887c8b5e01639b
+706, 0xf4e893da996680bb
+707, 0x8d601297702c9c0d
+708, 0x2a27904a30aa53af
+709, 0x497800f6917ea8d0
+710, 0xe96db3340ada9c00
+711, 0xcc23166f14c010ee
+712, 0x782690d78fa65ec9
+713, 0xf3e00d74a0878eda
+714, 0xa7cbb683decca0a3
+715, 0xdd2e038e683a94aa
+716, 0xe2096ff8da896ca5
+717, 0xf7c83400afdabe11
+718, 0x395b8c6f6a4086a4
+719, 0x4a164ec05bee71d4
+720, 0xe87aa5d1ca0462fe
+721, 0x8dbc5aed6dff9ceb
+722, 0x12120d1e9552707b
+723, 0x877dca6889b3e6cd
+724, 0xbd65605c01e900fb
+725, 0xbd6b82c4157c3115
+726, 0x8b60282732caf78a
+727, 0x279fcf5e5de9e57f
+728, 0x34b34ebfb6a37eae
+729, 0xd258cc1a14e03b7b
+730, 0x9a528ba3db4a13fb
+731, 0xffa0aea59d057746
+732, 0x27fa7f456cd37c4e
+733, 0xe1117a57a6fdce63
+734, 0xdc8fc903970a1551
+735, 0x492dd104f30faf29
+736, 0x110def0959e5652b
+737, 0x7f8d1997636fdd15
+738, 0xfb77b05e538a9b59
+739, 0x2e41fa35b4b01fc6
+740, 0xbc35ae69a3374085
+741, 0x192c2a681c2d9b4b
+742, 0x12566b8866c189d6
+743, 0x9d88ea785c5185c8
+744, 0x30a621ad5f983c4
+745, 0x8b875efe1206f587
+746, 0x224d25c3af6e3423
+747, 0x7503e976a1ac7bcc
+748, 0x3c98aa869e823859
+749, 0x3d8835304b646892
+750, 0xf6353330ff970bc2
+751, 0x8a673f5e2edb8acb
+752, 0xf2fdcc53493838b9
+753, 0x85ddcd526236af16
+754, 0x60afb99814c676c5
+755, 0x32a1c2749e281ca8
+756, 0x2367a92ae3bee9ca
+757, 0x219fe082703743cc
+758, 0x34d8b74dc85182a9
+759, 0xdd04164c72db23f
+760, 0xe293ac28fe2671a9
+761, 0x9ca7d169cbda6f45
+762, 0x705c47972b4240ed
+763, 0xc10eda9eeb536209
+764, 0xc36ddacd0c94e85d
+765, 0x8eb592c27e8cd0d2
+766, 0x3e815991c76e7cc4
+767, 0xac9cfce31acf7580
+768, 0xbf7a4cb31c7aee94
+769, 0x663077444aceecf6
+770, 0xe7f614ff386eb568
+771, 0x79d7a229c66912c0
+772, 0x161ed4311f63e1f3
+773, 0x308a5faeb9982ede
+774, 0x7b38ddb9b7efd10
+775, 0x1e103a2589b27ecf
+776, 0x67b02baf4259f27e
+777, 0x868921c115ea2eee
+778, 0x959791912200f71e
+779, 0x4dd55f36dec10557
+780, 0xe3464d90080cb99d
+781, 0xfb2d4f6accce652f
+782, 0x109900a9257d77ba
+783, 0x3c4bda8e2c83684c
+784, 0xc9ae040fb7f868c6
+785, 0x78098ffe994f4905
+786, 0x7a94c33eca77f0b4
+787, 0xbe6a2a95e9b5c0e8
+788, 0x797d39cf963f4837
+789, 0x8d2e249e4425d06d
+790, 0x6ae2c30cd5da06f4
+791, 0x904489de762b179f
+792, 0x84713e2dfb591e3b
+793, 0x6405a40da3f6f51b
+794, 0x976b560d663a2df1
+795, 0xed1c544784ba1e22
+796, 0xca658e995ed9344c
+797, 0x2b1c6b8e4db49025
+798, 0x52b1513da528bad
+799, 0x3c63406d256d9968
+800, 0x63a31ca3d423f85e
+801, 0xb05a81f55789a720
+802, 0xd04412992c476c8e
+803, 0x828ec2f77a150a3d
+804, 0xee50926671bb60c6
+805, 0x5aa70f93e2df61b4
+806, 0x94d60fa2e8655858
+807, 0x3f5e5b770703cc7d
+808, 0xc62dfb2688ca7784
+809, 0xaaf02e1e8ba89fe4
+810, 0x4ab74e0d8c047405
+811, 0x31ee04fbac6fcead
+812, 0x1203b78b8228f5af
+813, 0x412a70836f9aa71a
+814, 0xab51cf98c03f1819
+815, 0x783a3ce9ce137f65
+816, 0x8897085b0a072cf2
+817, 0x685dd9bde8798cb
+818, 0x9a1fac7b1705e2c1
+819, 0xf3e9ff98de48e9cb
+820, 0x5c2d3eb1a1fbe917
+821, 0x3bda718b6b54d82e
+822, 0x29f2dd18f22f0821
+823, 0xb992da1572ac3597
+824, 0xacb69e7aa14b34f7
+825, 0xcd36e3ad14f088d1
+826, 0x6aaacc96a1ec55e8
+827, 0xf8ac593f154fe68f
+828, 0x18fc9cbff012339f
+829, 0x2f3368ccbbb99899
+830, 0x7cec7d17f37031f7
+831, 0x96e86bfaadcb8fc2
+832, 0x74f9e7ee3d42a752
+833, 0xbd52f6c7d9b0733
+834, 0xa48e6d96bb6ce1c9
+835, 0xaefa058254b82133
+836, 0xb7a19edfd0929107
+837, 0x6160ce9125b26e26
+838, 0x6537dbbde1d2aed
+839, 0xc567f9a6bec52dde
+840, 0xca29fd3f22443342
+841, 0x7732aa6db6a1c476
+842, 0x8f5a4d7df6b11b3
+843, 0x76649262aa7e31e1
+844, 0x60a13eb125fbc829
+845, 0xc81e4d123dd21ac1
+846, 0x643cbb09bb72f86b
+847, 0xf971a98fb25555a6
+848, 0xffa2774c66692d56
+849, 0xcb33c16c50b13ea9
+850, 0xfabf388dffda0e9b
+851, 0x55d41ec12ca24b9f
+852, 0x91cf693a3467e807
+853, 0x6be2c00b2c31d6dd
+854, 0xc5cf513b5251ae28
+855, 0xffc4384212403dec
+856, 0x45d4e1865255a69d
+857, 0xfb1dcf956972086a
+858, 0xcae946a55c4c55b8
+859, 0x7351ac7720e385c1
+860, 0x19aa8ffd86240254
+861, 0x8f515ae78f4040da
+862, 0x1e1ed2058de50fce
+863, 0x22d006dcdb374243
+864, 0x6e0f0ede7c95b441
+865, 0x70e8aa81b53b4d25
+866, 0x998f309ea41e3814
+867, 0x89ed6598fb66f390
+868, 0xb5997dc3278060df
+869, 0xb2a021eac4f7e046
+870, 0x3705b60aa2fd0768
+871, 0xfc415079ab9200e
+872, 0xf2871ac4cf45ecc9
+873, 0x24bf758d2246175f
+874, 0xac503dd6f8141b3
+875, 0x4e879d12d9f03b3
+876, 0x82034af8cf93b644
+877, 0x59899dd7e478a6c7
+878, 0xae90addb6eb11507
+879, 0x1524ddf76730cdef
+880, 0x6fd4afd5456b1c9d
+881, 0xcddb9221ea001cbc
+882, 0x64ff400bbf2e8604
+883, 0x6dda10549b06ed9b
+884, 0xed2c85104c261527
+885, 0xc7e09217d29929a8
+886, 0x56284df611a428b1
+887, 0x1a7608289c0a61
+888, 0x7cb63db15166ff66
+889, 0xc6013c76fcdcdc72
+890, 0x8e5dd566c7a5a676
+891, 0x5a8e8565f40d133b
+892, 0xe465973455848c44
+893, 0xf92eecbfe0f3c2c0
+894, 0x7d64155d4dcc5cac
+895, 0xf17595706f988dad
+896, 0xd590a001a6a19c5c
+897, 0x82a164475758db3d
+898, 0x6b144993ea1bbe32
+899, 0x22a81a7a6e453779
+900, 0x8e8c298df1a68a73
+901, 0x78056afd6d936b4c
+902, 0xaaceef0325faaf62
+903, 0xe78bb7699f82266f
+904, 0x523a2d283c5a5166
+905, 0x7076d87088f6c6db
+906, 0x6087dd54cff5aeb2
+907, 0x7ef82e62cb851680
+908, 0x4e8bcc8ed84d03d8
+909, 0xd12fa0361df3cfd3
+910, 0xefb89c79f8127297
+911, 0xa9af4e2fbce0b1f8
+912, 0x462136685b70331e
+913, 0xe9e74c93da699b77
+914, 0x9ec69215fb11d0c3
+915, 0xc10f229939e3e111
+916, 0x3f67fa79e41d2374
+917, 0xd5e7c1a9a7185162
+918, 0xa1dcce9ec91492fe
+919, 0xd4e61f0727b5d21b
+920, 0xdf6cdce46551800a
+921, 0xa3f256ce906982d3
+922, 0x209742a6b9ffc27
+923, 0x4006c96958526a57
+924, 0x9606aebc75a1967e
+925, 0x91b9f42fb64189df
+926, 0xb27119defcb938bc
+927, 0x128cc7a84ba05597
+928, 0x6c3df613c62d0d30
+929, 0x3adf69d48b629ec7
+930, 0xda42ee493837b128
+931, 0xb8e770480e760bb5
+932, 0x9feb55d57c99c626
+933, 0x29812d80afdae3ed
+934, 0xae4222a64276a8c7
+935, 0xe3897212a5b4ed53
+936, 0x98bedfd13886e669
+937, 0xca858675d7fc0d0e
+938, 0x28a359f665354234
+939, 0xfac2ccabe4128b35
+940, 0x61373cc5d11ca180
+941, 0x7007605a4512a87a
+942, 0xe71f8eade7b30b3d
+943, 0x3a9e77f9b99bd04d
+944, 0x70d3e42488098866
+945, 0xd30fc159c7cd4d99
+946, 0xe4d3f6600d2e2d6f
+947, 0x1088324dfa955c25
+948, 0x516437acd4764623
+949, 0x38a31abe50d0aa03
+950, 0x72e1054e9dc02ba
+951, 0xe6971dd664d1a2e2
+952, 0xf6698cb095d3b702
+953, 0xad995a5a8c19bd92
+954, 0x34e53c6936f656e6
+955, 0x10de240bc07c757a
+956, 0x3e3b9a6861c2bd1c
+957, 0x9c0b0b97d3712ec9
+958, 0xabf1505a75043aed
+959, 0xbdf93d3de3274179
+960, 0x28fa5904d3f62c28
+961, 0xc3b97b39ef6c5133
+962, 0xf2b2219225b8679d
+963, 0x8be4ec0f930c0aaa
+964, 0x47de5a56aa590643
+965, 0xb6f871b304129856
+966, 0x80a61c06233ab0f9
+967, 0x3ce6c3af8101b055
+968, 0x85b911708274e7d1
+969, 0x4cab65d093a488b7
+970, 0xaabc4b10661fe28e
+971, 0x35b16dea64474a68
+972, 0x1d6eb5b093361223
+973, 0xc39107b92f0fe1fb
+974, 0x1d09e048073c4841
+975, 0xc6a02f43aca8cb2f
+976, 0xaf6613dbc7da909c
+977, 0x5ac2a40c230aa756
+978, 0x33afb5e7c01c39a5
+979, 0xc7b0b20ea8b7d0ef
+980, 0xdf7306c8ccb1bbea
+981, 0x9710efc0c188b2a0
+982, 0xd6303eadb72c873e
+983, 0xa38ca609b118f35a
+984, 0x8390613065c6e535
+985, 0xdf9a0106757e431f
+986, 0x8bcf77039788e143
+987, 0x6026806a986b378e
+988, 0x482ff3b1394cb1dc
+989, 0x2a27d0ccac9ede9c
+990, 0x53c77f26e271b3ab
+991, 0x1ba004cf276cf3f
+992, 0xc135b0517dc81f7c
+993, 0x5d137838db75e442
+994, 0x3fe505f93d1dbdd7
+995, 0x351654ae7d598294
+996, 0x173f8d182af9d84d
+997, 0xf97dfcd164fe11c5
+998, 0xcda423e5ad43b290
+999, 0xa5cb380b8de10d10
diff --git a/venv/lib/python3.12/site-packages/numpy/random/tests/data/pcg64-testset-2.csv b/venv/lib/python3.12/site-packages/numpy/random/tests/data/pcg64-testset-2.csv
new file mode 100644
index 00000000..7c13e317
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/random/tests/data/pcg64-testset-2.csv
@@ -0,0 +1,1001 @@
+seed, 0x0
+0, 0xa30febcfd9c2825f
+1, 0x4510bdf882d9d721
+2, 0xa7d3da94ecde8b8
+3, 0x43b27b61342f01d
+4, 0xd0327a782cde513b
+5, 0xe9aa5979a6401c4e
+6, 0x9b4c7b7180edb27f
+7, 0xbac0495ff8829a45
+8, 0x8b2b01e7a1dc7fbf
+9, 0xef60e8078f56bfed
+10, 0xd0dbc74d4700374c
+11, 0xb37868abbe90b0
+12, 0xdb7ed8bf64e6f5f0
+13, 0x89910738de7951f
+14, 0xbacab307c3cfd379
+15, 0x2cf7c449d8b927a6
+16, 0xdcf94b3a16db7f0e
+17, 0x8a9d33d905a8792e
+18, 0x4cb9eb2014951238
+19, 0x6c353acf7b26d6f1
+20, 0x73ff53d673aa30c
+21, 0x1fd10760015eca68
+22, 0xabae0aa9021eeba8
+23, 0xa5ae363a868ee2bb
+24, 0x9d89e0f041de6631
+25, 0x6238b133c3991a65
+26, 0xff49267d75fef51a
+27, 0xfb180656ce13c53f
+28, 0xaf7fadf36128712d
+29, 0xa6847fc6f339c63e
+30, 0xb03e0b80d71ea5bc
+31, 0x63905abcb43969af
+32, 0x2295af3ee00a3bba
+33, 0xb8b375b994330415
+34, 0x867d9ef1d8716a3b
+35, 0x4f6c02f5601b4e18
+36, 0x7c5fb4c16c470d18
+37, 0xe3b57986b804b343
+38, 0xef1d79d212aca692
+39, 0x5b98774c8806209c
+40, 0x924fc76bac38a5d1
+41, 0x5266084c412ddeed
+42, 0x98240bf9b831d6a3
+43, 0x5681599e81219442
+44, 0x6441248fc2ba92bc
+45, 0xe3e9051a540349ea
+46, 0x3a2700034390baa3
+47, 0x9f893155b6d402bc
+48, 0x158207910c6d8aef
+49, 0xd5282ab7608c2cbc
+50, 0xc97f4651669dee4f
+51, 0x3d4750d95103ed60
+52, 0xe0614542caac1f04
+53, 0xefe5092144cfc6c
+54, 0x560bc486abd7e9ae
+55, 0x2678b71392daa4b8
+56, 0x734970d3dc2ba416
+57, 0xcbdbe849e51e4aaf
+58, 0x3b0b5e28b491556c
+59, 0xd51449ac45abd88
+60, 0x6790b59991f1b7ab
+61, 0x32d1c039ff2415bc
+62, 0x173b9772f24f72e0
+63, 0x9490a9ca9f883b1b
+64, 0x4c775989e6214222
+65, 0xac07db37e6ee6114
+66, 0x331371b2e3f10aee
+67, 0xf12e5326c21c28e4
+68, 0x5d77dc280c70d614
+69, 0x1b01bd17a2f281ec
+70, 0xa10d3b5882938487
+71, 0xed5a0033c394ae8f
+72, 0x70bc8ea568ea44b4
+73, 0xf4600ae77965e730
+74, 0x7ff92c0b321ce233
+75, 0x6cdbc87d0cc1d670
+76, 0x9ec64f0cf2000eb1
+77, 0xfebea50259800f68
+78, 0xf2edf9019a8fd343
+79, 0x75c584ac042e5468
+80, 0xc1fa8481d5bf9a1d
+81, 0x7f57180168514ac2
+82, 0x878100716b94f81e
+83, 0xc929406e3af17fd2
+84, 0x6a26e2c013e4bf4d
+85, 0xbc071d8848280955
+86, 0xb60d75abbfd1bdac
+87, 0xee9b76afeca9fa69
+88, 0x1d6c399d2f452810
+89, 0xbaa0bc1621e25c83
+90, 0xed6ba792f8671ba5
+91, 0xf7ca02c2ab11d8d7
+92, 0x3c3cadadf0b21e3
+93, 0xdd1784571e864e9c
+94, 0xfb2f992015157509
+95, 0xf50bb9f0d3ced743
+96, 0x261565f75c3e185f
+97, 0xf8fe33b284513e60
+98, 0xe3d2d10b5e024664
+99, 0xd28717566242cf35
+100, 0x7ae07d133ac5b789
+101, 0x3b7ccaaa53ac338e
+102, 0xcd480bace4871650
+103, 0xec6c78f923c080e9
+104, 0x44211d0ff8919d59
+105, 0x89f79af76d2a45fe
+106, 0x71583fd8a837548b
+107, 0xee57269c261511f5
+108, 0xa5ee8f3b128c5d1
+109, 0xbb64c20ed0765a17
+110, 0x9d4790ab2eeaf7e4
+111, 0x742f3db806d9e98
+112, 0xb81ec97aed6a0d1b
+113, 0x41808b34f6a8a23
+114, 0xc20913af175dfd4d
+115, 0x834427db263b22bb
+116, 0xedd9c632e611828a
+117, 0x10eac8524496f571
+118, 0xd76091b97eb00ab7
+119, 0x111298ae9fe95666
+120, 0x5824b2e2a6719c43
+121, 0x6e280ec539e934ed
+122, 0xf74fd832df90083e
+123, 0x8fee6d0f241c2e97
+124, 0x4244f331c2f19c3c
+125, 0x3dde75a845cce97f
+126, 0xe35bb8e635a9915b
+127, 0x39d2943037f7932e
+128, 0x1fe2d134201d0970
+129, 0x49d00b63c749b804
+130, 0x960c2942cd4e4e04
+131, 0x8dd8e009dbc0435f
+132, 0xcf493495c3a055cd
+133, 0x8f7b5a1c0f9fe9cd
+134, 0x49d5f90374641a25
+135, 0x69b3932073d3524c
+136, 0xd170603e7de84ee2
+137, 0xa062ba3ed3539948
+138, 0xf5861cc5b5d56c82
+139, 0x5e914998a30c7e76
+140, 0x8d77f2ad1503c0f1
+141, 0x980b6a9e3b4181fb
+142, 0xd9299cd50694c084
+143, 0x253dc0f8f1cec4c5
+144, 0x68110fb9d1b3e695
+145, 0xe8f3120d0aabc461
+146, 0xb066e7df0dfb042
+147, 0xd29ce0f797e6b60b
+148, 0x6a569bb7ca33bd42
+149, 0xd46e08b2dc2385f8
+150, 0x28c61d11d055767
+151, 0x5d73aa3d1a2bb725
+152, 0x1421191e1c14829a
+153, 0xa711bfb6423df35e
+154, 0x461af97a86308006
+155, 0xb3e1018ff3519367
+156, 0xf19cf866a268ef2b
+157, 0x207715eac9199d1d
+158, 0xdd621c410975b78c
+159, 0xf390aea68683610
+160, 0x617a2d107a0047d9
+161, 0x6e05ac416e5bebf0
+162, 0x7d253e70506c1bed
+163, 0xf9f96f4a7dd53810
+164, 0xc693b29cb1573f73
+165, 0x4f1146b0020ea544
+166, 0x45140608fbd40579
+167, 0xdcf57219828ce6be
+168, 0xe19d58cca37b5b32
+169, 0x82bda95b2a161235
+170, 0x5823c3d8a2b6c9ba
+171, 0xfeb2e74092fdf89a
+172, 0x50e1ad1abc8f869d
+173, 0x2ec63d0c105eb8da
+174, 0xe14e1c4845a3264a
+175, 0xcff53670455eb6aa
+176, 0xaafaccd24619fa3e
+177, 0xf55a988486e2422a
+178, 0xecfba16a90ff4d04
+179, 0xbf8d36c2f644757a
+180, 0xdc56ed75a0dd6249
+181, 0x3f45023eff17c3bb
+182, 0x2428bbfe90023fab
+183, 0xab892c611adcb70c
+184, 0xb6f13d8c0c2b9d74
+185, 0x2ac3fb11d224f2a8
+186, 0x65433dcfae2d9351
+187, 0xe906859ae4b45f82
+188, 0x8fb7f5f093d76a3b
+189, 0x940dd290b5e88d1a
+190, 0x31b27d21bef116e7
+191, 0x86a964e2c83b5296
+192, 0x85ffd17bc079a9e8
+193, 0x16c47c724e7ab7f1
+194, 0xfb6098a9867e7d7f
+195, 0x9246fb69092c6cb2
+196, 0x1a4033572760f32
+197, 0xc5cc568a8b273b84
+198, 0xfa6f9f2fbdd44abc
+199, 0x9701b8e087718ba3
+200, 0x51d6a7dcf73f8f3a
+201, 0x30008172cc6a972d
+202, 0xac2ab49a5ca6ac81
+203, 0x31f28ef79461e54c
+204, 0x93e35a8da8cc6132
+205, 0x9a2c58beeba3d5b9
+206, 0xf6615c1de266ac39
+207, 0x127ff9f8166b766b
+208, 0x7ffe380e80a69556
+209, 0xbe7d2c228e1542f7
+210, 0x2d5ebb4e50ba1746
+211, 0x63585761ae1bf684
+212, 0x1019eb5cee022fea
+213, 0xb9d3540ab58da30d
+214, 0x1677f4cb45620eb9
+215, 0x6524baee51783822
+216, 0xdf9f2ddcfabb0adc
+217, 0x78e8acc43b287935
+218, 0xe9a1974e999222b5
+219, 0xc41324ec2291e780
+220, 0xea52abc9ecdcbc9f
+221, 0x209d7bcd46ec6b04
+222, 0x12d504c09803db2e
+223, 0x1200e6bf21475d81
+224, 0xde6d3c2b35fd2cfc
+225, 0xa2526900ac33bd3c
+226, 0x7f1f5290fc432bc5
+227, 0x29ddfb380a3d69c8
+228, 0xac79cb6942a2909d
+229, 0x516996685b67a92a
+230, 0xb5fc39041cb828bb
+231, 0x75d9d8ca0644a276
+232, 0x81e98b76be92a3e9
+233, 0xca27888fafe12179
+234, 0x17be2ae039925765
+235, 0x9429846c0e6d0342
+236, 0x327dfd50439815e9
+237, 0xcee20cd7bc254aeb
+238, 0x7d250389f453f29e
+239, 0xfd1b232a85c95569
+240, 0x2ed55fac80f3e9e9
+241, 0xf6886c20417a1be7
+242, 0xcd08e61f0b0fdfde
+243, 0x7b33e34da5c27bff
+244, 0xd043c4b7d5603dd5
+245, 0x9a544e4c70a3b686
+246, 0xa7b60398c381f771
+247, 0xe9e7a3487c4bd4f2
+248, 0x10b58fdfe1ff112c
+249, 0xd5c1c9748c0f4ceb
+250, 0x61be9d09159d54ff
+251, 0x5356f51e8239f510
+252, 0xfe7889d9b202ecef
+253, 0xc7fc19ca5d263d5d
+254, 0x7c4c07e61dfd9f69
+255, 0x6c315fe5015f300a
+256, 0xe0a5bc00039747b4
+257, 0x16397fdcf829ee80
+258, 0xb55aee80d16a5169
+259, 0xca0609944d007eea
+260, 0xcc982249f65a02ce
+261, 0x528161feb149c148
+262, 0xcbf08ba49b41c006
+263, 0x39af1ff0b6f14138
+264, 0x5cc036be69799aec
+265, 0x6adde125b1db21c5
+266, 0x8a99d83d6b613b67
+267, 0x1cd43fca9451f74c
+268, 0x682dbb26ecc96365
+269, 0x13b4be2ceb43e3
+270, 0xbe8fbc3b6f4f581e
+271, 0xda148a2f4bda5719
+272, 0x239106ca3319f393
+273, 0xb42b4dde641f0dd5
+274, 0xd233cfdf4cb0af74
+275, 0xfb5919d905589afc
+276, 0xd802a8860c10b66a
+277, 0x6c923e1d00e7b5bc
+278, 0xfacce1134f383b89
+279, 0xf9570abda7a6d553
+280, 0x80f0f9796a208f18
+281, 0xc0e1df5280951c57
+282, 0xe9f143f08257bbe0
+283, 0x79e4c6463123d588
+284, 0xdd2118583f2b1684
+285, 0xb399ff5f2329fa18
+286, 0x4b3e9ebae96f813c
+287, 0xc484dbf247787384
+288, 0x921865eb97603f2c
+289, 0x18063c68e257d300
+290, 0x643181f345e7fc26
+291, 0x12e0b0e8eadf9fa7
+292, 0x79e613fe73dfa354
+293, 0x6db4c59203b7217a
+294, 0x6c7a0e9ba6139eaf
+295, 0x9617c7ac4e3f6d97
+296, 0x1f68a7b4fb1b4b75
+297, 0xef0b7ab24944f466
+298, 0xaf1dee1f4be1bc89
+299, 0xd2e355c959f5fd8d
+300, 0xe594c3fb95d96efc
+301, 0x9554766ca3342906
+302, 0xa4bbdc77d12842c
+303, 0xb62400211ee489a8
+304, 0x91abadaaa3bbe67c
+305, 0xd371eeb91deb42bb
+306, 0x883bab35cbd2b6e5
+307, 0xd030c3d9411a9041
+308, 0xff3c110a858ff000
+309, 0x59bdf5ca47d0bde7
+310, 0x2bc80fa3cdba1853
+311, 0x6444ccb652662cb8
+312, 0xc0c7e256b9e90339
+313, 0x70714ea9c9d72302
+314, 0x96a0142f9d897d27
+315, 0x209a9097c5a91ef7
+316, 0xb9e33afc5171e009
+317, 0x47b37af433a58d40
+318, 0x30cc4ffbfa831d26
+319, 0xdcea4a85ff815466
+320, 0x907d5bd027f2e5cc
+321, 0x7c081f6852e04a4b
+322, 0xe61950749c1d502b
+323, 0x1604e937ee69834a
+324, 0xb2372d952dd25309
+325, 0x53f6a5b834c72577
+326, 0x2ce7a74395e0b694
+327, 0xacbf9ab4fe91f225
+328, 0x5ce1e63d3a2bb90f
+329, 0x54740da3a5ed139b
+330, 0xf194ddb39f29880b
+331, 0x3305374f5d8ec08b
+332, 0x831dd0164927ff4a
+333, 0x625baa78e4458cf
+334, 0x29d27dc0a4a71152
+335, 0xe227bae9a1401034
+336, 0xca0c209831846b2b
+337, 0x8e8cc54b08b5a411
+338, 0x38f2b4acaac27db6
+339, 0x8ec88baac814e86b
+340, 0x31c08e46b007bde
+341, 0xb686c02722794c09
+342, 0xb77cf8fc682e3907
+343, 0xa56334e7f606f4b2
+344, 0x9c80b127bddd5f4f
+345, 0x12df14834cd858bf
+346, 0x3f14762a9cf5fb9f
+347, 0x930a70941ef5779e
+348, 0x64e96c849c30c080
+349, 0xfdf53bfba1300484
+350, 0xec7a9363c21bc616
+351, 0x26e9fd6a115ecb47
+352, 0x9707a84b5bc77fbb
+353, 0xb23b2737b20d5903
+354, 0x22f4825ae80f6501
+355, 0x500644b12be6a01b
+356, 0xb746645b2af082db
+357, 0xe6af051f697892f8
+358, 0x577c724248a1cfc6
+359, 0x3d2b6a434c84eed3
+360, 0xd260f5efd7328314
+361, 0x95c16cc84bb3f55c
+362, 0x7a01b2e4e0e80ca7
+363, 0x41930c3ce70a0935
+364, 0x1299bccf39d4e110
+365, 0x494883ba1a8a87f
+366, 0x9478ecfe2d918e60
+367, 0x30ec9a5670cda8af
+368, 0xf9bc877e833e2b99
+369, 0x1b83a0acfbb4a8db
+370, 0x73bc1740c0d18880
+371, 0x65086ca9773cb3e1
+372, 0x3b78c3ccd63cff2e
+373, 0xbfae748795acfb31
+374, 0xa4c9d5d56a15ba20
+375, 0xb9cb41721e52b71e
+376, 0x1532f15d4dc47748
+377, 0x5a4d647a4b9ee632
+378, 0x8513c7c5a50898d9
+379, 0x6d3d98ccd5461b2e
+380, 0xa65e99be2fe98d6
+381, 0x31abc8855334a0e5
+382, 0xf1ed22a661dca5b8
+383, 0x299e2b63229e03be
+384, 0xda201a06687bce48
+385, 0xd27794b302142c55
+386, 0x642bd3e1c7898a9d
+387, 0x777f1ff00afa1a87
+388, 0xd2f1c84fb3877baa
+389, 0xae417583289191fd
+390, 0xd641f1d88e0e2d55
+391, 0xc1f1d98fb5d18ebf
+392, 0xb0f72aecdadce97b
+393, 0xe9b8abc764f6018a
+394, 0xd2a37cff8e890594
+395, 0x2dd70d631a528771
+396, 0xbf8ba0478c18e336
+397, 0x1630bf47f372ce0a
+398, 0x6d04ea20dc3f46b8
+399, 0x6591881bf34337f2
+400, 0x33c149c7eb5b4103
+401, 0xf01a8c9857c86748
+402, 0x184348cdfc16d215
+403, 0x141168b253d2ed7
+404, 0x52aaf012ef50a6f1
+405, 0xfda1722387e16f4c
+406, 0x43c30f57d6c038fa
+407, 0xd4a8611f5f96d214
+408, 0x2c512ce17e987f2c
+409, 0x961ce450f0fa2822
+410, 0xf55a506ec6cea9cd
+411, 0xb76d694d9c7f5ef6
+412, 0xfb029216dbd8e988
+413, 0x93162501896a0081
+414, 0xfbbbd2c5ab300f5c
+415, 0xd648b6da7387d491
+416, 0xc73b4697471d9d98
+417, 0xe37412bf1c93ee76
+418, 0xa1a96d96570e6637
+419, 0x5b3ab4f82428f65c
+420, 0x873d849b188aa36f
+421, 0x39fbee0ffc9fa9ff
+422, 0xc70d21b744d677fe
+423, 0x2b8a43c23043d209
+424, 0x93c33eaa37370d16
+425, 0x8930ac1880f2b0ef
+426, 0xac01d27707036af0
+427, 0xc2af3fee504343a0
+428, 0x1c1dae2ad5535d97
+429, 0x9ffc21804b76a480
+430, 0x69f903412cc13563
+431, 0x9d3c4e2759a0c47d
+432, 0xb1a8f894be6302b9
+433, 0x95e1fd7951479506
+434, 0xbb9e6c03cd4ae8e3
+435, 0x85206010c9b737cf
+436, 0x767e813694d6238c
+437, 0x4969af329ccbb30a
+438, 0x3aa9af1075aaea5c
+439, 0xb1ff519e8118a993
+440, 0xb21a23a3c91180fe
+441, 0x320b24582ca3fd88
+442, 0xf8ca56415fb4e453
+443, 0xabd0899c07205e77
+444, 0x87fdc7a44b4ad50f
+445, 0xd75744911641a278
+446, 0x7c8c9a65df6fcb95
+447, 0x79d785e3c7a5b695
+448, 0x421e4565ba1f592f
+449, 0x27f87eb2517835cf
+450, 0xb62cc4297441c83e
+451, 0xd817a80ac815ca6d
+452, 0xad84388130df2aa8
+453, 0x5e6b1640452d6ac8
+454, 0x936285e15edce2a3
+455, 0x903bccc4969768e8
+456, 0xefc2cb7b109d3140
+457, 0x633e9dfdda2d903a
+458, 0x2a2f3225925678a1
+459, 0xe07eac91a27f8547
+460, 0xe50ced40eda78cb3
+461, 0xc5b22500e1c7441
+462, 0x32becf61bca3aa72
+463, 0xa2e37c4b30671344
+464, 0xc9f1c1910f45d544
+465, 0x9b50333b2dcdf730
+466, 0x310bfd53a1684b94
+467, 0x1e1dc21e66ac6455
+468, 0x81876c2bfb1ed5a1
+469, 0xd0c54a3e25eadc7b
+470, 0x3791b6fbbd5c7ba0
+471, 0x133be57356c599fc
+472, 0x8d1148eb8e83fdea
+473, 0x311aedba0d8b42cc
+474, 0x1142ae52745f94bb
+475, 0xc5f4ab2fbde8c4a3
+476, 0xd23be827b5b24f6d
+477, 0x65f95194cd122715
+478, 0x4b48969d73125922
+479, 0x46f165052b8ff988
+480, 0x5c689f94b9275ff4
+481, 0x93b03823ff2d536b
+482, 0x871f3775aa4e3523
+483, 0x5af829f7cc0f66a5
+484, 0xa32e05739cbeac8c
+485, 0xacff1856ddace0fe
+486, 0x8eeb5e7f991a5322
+487, 0x6325c2720e0dbdea
+488, 0x9fb817bc4fdf5200
+489, 0x9786f0d850e43d78
+490, 0x571f76dd7f9fb77a
+491, 0x4d9e94e181cbc63f
+492, 0x8bb632d3376c547a
+493, 0x9cc26d9efd1c88b9
+494, 0x9c5d49579df52b0b
+495, 0x6201abf7e1cda07b
+496, 0x90d68f0c6c884963
+497, 0xfc5b66188ef7f561
+498, 0x6d9303cf2e0e0f95
+499, 0xd7cfcff535f5ed07
+500, 0x14d1a1228daa4ac6
+501, 0xe00ef5762f66ae50
+502, 0xf113a79471582978
+503, 0x430985281785dc7a
+504, 0x31914108c206ed5
+505, 0x7ba6707b6419971c
+506, 0x2ec63b033ce112e5
+507, 0xf8bcd36ced3b41e3
+508, 0xe5cf908c8010414b
+509, 0xf5ee224b7c703e30
+510, 0x9a9733af0b12338b
+511, 0x83e18cc00ace34f8
+512, 0xd52cff39e23008b8
+513, 0xa700578136b9c0c5
+514, 0x3fa179d32ac51f99
+515, 0xef2d5eab6d4ad380
+516, 0x709024a5abd032df
+517, 0xc607c7ee349ede87
+518, 0x803d784e9731eb5f
+519, 0x2ef06f4ba769282d
+520, 0x4bc1dca1e9f07eb9
+521, 0x930c958a7a72f94d
+522, 0x249bc8db2cc7a3bf
+523, 0x3845305798f9a5d
+524, 0x6f137eca9ab6f948
+525, 0xc31f5a963d31bd67
+526, 0x9d39693d5383626f
+527, 0x52fb41c335a8b98e
+528, 0xb79d1a29a06006ec
+529, 0x7c0926a7a3eda2cc
+530, 0xffdf5214406fd53e
+531, 0xc6aa02a7e94282b9
+532, 0xd4a4431b4aa301ee
+533, 0x4271cc0f9420d3ab
+534, 0x26fccd7cc7fc2485
+535, 0x330594bb945b8d5a
+536, 0x6ea8eaad12e5cb8c
+537, 0x831c3467726bede3
+538, 0x31d1eb10017eaa61
+539, 0xc7aa75e41508f5cb
+540, 0xde51810f0cadd0b5
+541, 0x50e5b3e73692f80b
+542, 0x82107ec55636e188
+543, 0x9828ef175d843ab4
+544, 0xb8edc6a860dd421e
+545, 0x25c0c138fd537ac3
+546, 0x47e72a771e8eb563
+547, 0xbb0f8c5333f4a2cc
+548, 0x91750d2fb9b2d479
+549, 0xe662d8f6fe38df36
+550, 0x72a6d879fb5619f0
+551, 0x6817c7878dcbf077
+552, 0x4e7741cb484661e8
+553, 0x3b3b3ba0be5711bf
+554, 0xa6989f5d25868765
+555, 0x43c276398997e4e0
+556, 0xdcbe16a94da28870
+557, 0x454936980a699c99
+558, 0xac614bfa8f0266c6
+559, 0x9174841392e213d5
+560, 0xa0e2acffc5fc9d1f
+561, 0xe53a08a7a0e6521a
+562, 0x2b845cf7c24172e0
+563, 0x265a4fc5f7adec0d
+564, 0x1f34fbe5f1e49420
+565, 0x139181f6fb647f20
+566, 0x88c35d46e2fcd05e
+567, 0x2a6d5b55903c0459
+568, 0xcea28eb621ad7bf1
+569, 0x5c9cdc13e7aaa30
+570, 0x5fe63e14746e7103
+571, 0x7923e53d73835db9
+572, 0x376e661210bf1b06
+573, 0x5b1cab85450efdd5
+574, 0x3908dc096c70b452
+575, 0x4825e303cd1f396f
+576, 0xed476bfd702957c3
+577, 0x6acc013aff5db743
+578, 0x62c80b776343d488
+579, 0x9c75edcd5b012697
+580, 0xaa053362a3b9770a
+581, 0xa907e236c7c07e94
+582, 0x15b2c380451692c0
+583, 0x94f79142697bd61f
+584, 0xbc657d31ea98d44f
+585, 0xcbaa5e52517a1f5e
+586, 0x96aa2e44a7c4a03f
+587, 0x216d3c66db2b515d
+588, 0x157001807e3ca88a
+589, 0x52b3a596bdd3859a
+590, 0xed747e7fc5e3adac
+591, 0x78fd765ddb2c448d
+592, 0xe53dc7299ed8614e
+593, 0x75ad41fb1d7a790a
+594, 0xc14f6b944b0e6cb1
+595, 0x7c314b69fce3df1c
+596, 0xb56d82eb740d7abc
+597, 0x5132a93c41251fdb
+598, 0xe3ce35bd2a82f958
+599, 0x440571a981c722f2
+600, 0x194cdfd9f186bc9
+601, 0xb89e522a5db00939
+602, 0xad35f339f68df3c8
+603, 0xa82ab18420322293
+604, 0xaffa6df9b72b27c4
+605, 0x9615694d23beaa2c
+606, 0x1d82ebe563abad91
+607, 0xab50ef65fbd94385
+608, 0x1b070dbd70a9a14
+609, 0x2ececa796abbadf0
+610, 0x6bbeafe9e81ab2a2
+611, 0x60dcd0d2a9b76914
+612, 0x1e748039ef05c33f
+613, 0x6d4d17f2213ccdff
+614, 0x9fa56132957bc987
+615, 0x60a17185de2428eb
+616, 0xb56038ddf306479c
+617, 0x3b1db5df92d06d8b
+618, 0x24d1bba8bdedf580
+619, 0xbfb7e6740ebaa4d9
+620, 0xab31c4473e46f61d
+621, 0x6deb3cdd8fd5869f
+622, 0x23032e47746d72d6
+623, 0xa9e72d734e10f2e8
+624, 0xbffd199b6157bc23
+625, 0x29f8254df273fb62
+626, 0xb076142130ee55ec
+627, 0x5b0b08374126c309
+628, 0xea4536aae979521f
+629, 0xc064e7abec91a174
+630, 0x46133ef80c59d935
+631, 0xf0227e2da1b14160
+632, 0x675a76641e1af5a
+633, 0x2f50a069b33d198c
+634, 0x3ded5a65e1d657eb
+635, 0xbb6999b020694f6b
+636, 0x86b2f2b33487aed7
+637, 0x76e14e85f8bfb4cf
+638, 0x38f7f1e44bd4e0db
+639, 0xc1a7d41b7e80d4ae
+640, 0x1dfaaf80bbceb42e
+641, 0x3f51c11497720c2b
+642, 0xce6da1415ddb8b80
+643, 0x7377d8bcd359b5f3
+644, 0xe077208f3f810aca
+645, 0x9a06a8a2dacbffce
+646, 0xca1f99156b09b735
+647, 0x2ff9a93064d91451
+648, 0x50f3ea93f351a7ef
+649, 0x606fceccb07054de
+650, 0x7e83d6d2f8f6685d
+651, 0x78f3995291c5d407
+652, 0xd28d2460e22d0228
+653, 0x2c5636f68a0054dd
+654, 0xd9fafb1c56c8f6cb
+655, 0xe39889b5f9d74464
+656, 0x1355372bf5db2cc1
+657, 0x26768426b9ac323
+658, 0x4af1dbdc1111fd89
+659, 0x66973587943b927f
+660, 0xf86f5f50684dfb1d
+661, 0x1247d574ff79b534
+662, 0xc8039f3259210fe2
+663, 0x79b573235c92a9f5
+664, 0x213f642d8450e2f0
+665, 0x5db7706973376566
+666, 0x6182c12e69b373d7
+667, 0x3e5ac47300aec07f
+668, 0x4b5b6c57b1574376
+669, 0x6b7fcceefd56b17c
+670, 0xf656c3455cb9d4b8
+671, 0x7577e2e13329721f
+672, 0xf33c0c53ce956e8d
+673, 0x7d0f328ee356174
+674, 0x10ec9a168088686e
+675, 0x71ef1776d062dfa
+676, 0xaa7b590a488a6bc4
+677, 0x38612b6dd8049a1c
+678, 0x939045e36874f731
+679, 0xcb9d1d74c56d5ac9
+680, 0x54f1c1c8fef1d8ff
+681, 0x3ee4b85c8c7e939e
+682, 0xb9b4608e019f352c
+683, 0x79d4701275d12e6a
+684, 0x2632a2d9835c7f19
+685, 0x1662cd9fba293692
+686, 0xbcb70265115ee944
+687, 0xdc43fb9761468604
+688, 0xe3eec4e7d3871352
+689, 0x829531753226989d
+690, 0x2748cc67f540e074
+691, 0x39c4af25d607837d
+692, 0x741a243f4cb5df99
+693, 0xda1353287e18b49a
+694, 0xa6735689d751ea74
+695, 0x46326d587340ce0b
+696, 0xc18531df4550012b
+697, 0x6f7901e05dd4b818
+698, 0xfb966afc4c001d63
+699, 0x6dc10fca67a9cfdb
+700, 0xd6527ffadf0feaae
+701, 0x3b900172045e25d
+702, 0xb7dd594cdded6a46
+703, 0x6602aee7ec1599fc
+704, 0x7fbf12f23747546a
+705, 0x32e63f662bd2de0d
+706, 0xedf47770b67ed641
+707, 0x331bef83481c5c2a
+708, 0x8fc4256fdf05158c
+709, 0x98eba48dabccf5e0
+710, 0xdbc2f2cdb7b1c154
+711, 0x7777755616517ad3
+712, 0xd473c147d2628ac1
+713, 0x861e15d1d760b5a7
+714, 0xf4d25926405ecb07
+715, 0xb7739c69effff86e
+716, 0xe97fbafa6f96830c
+717, 0xf13e8a334e8bede1
+718, 0xcd60010cba4ee4f9
+719, 0x1f537ac2b82e6008
+720, 0x1fda8d781a89140a
+721, 0x9dc204f3f4a463f0
+722, 0x456dcd18eb56a1ab
+723, 0x629957bc87bd16a1
+724, 0x2c8000ddb8c75253
+725, 0xc31dae9ec8449284
+726, 0xdac05c8baa2b691a
+727, 0x21ff7be9ffa3e7ac
+728, 0x844f4b5ed4ee08d0
+729, 0x651f913fd636c994
+730, 0xca3e71a2110b2d49
+731, 0x7709bc42253ed09d
+732, 0xbb164d45b6569d43
+733, 0x90ec2f040c20a112
+734, 0xfa6e77e9166f5be4
+735, 0x6b6d12c1842d587d
+736, 0xfcd7ff8466e25e2a
+737, 0x6a5a2ed8bd971297
+738, 0x2ec35f6bba5adcbc
+739, 0xc83676e16651249a
+740, 0x458f6064cefe10ba
+741, 0x90d54d527e6cd028
+742, 0xa5613e88db27c388
+743, 0x331e0c7d85aa1abc
+744, 0x8cee4977e210358
+745, 0xfcae379aa6cbff8e
+746, 0xd1407afc97a57e86
+747, 0x1fab25c864f094ae
+748, 0xd914864a63004552
+749, 0x4214d226a20f1384
+750, 0x3f4e0d80c488b715
+751, 0xc5ca2f654024b7c8
+752, 0xc1e27a124e7c821c
+753, 0xd890a915ffc7918c
+754, 0x22fba040ce51a9f8
+755, 0xbf61cebd8891617a
+756, 0x7846609ee228e319
+757, 0x536d1854375509b8
+758, 0xbbfb45fc6e666f50
+759, 0xd85b4c0527f9d7d6
+760, 0x528cc9c7fa2a84c8
+761, 0x27a1baece647f2cb
+762, 0xfddf0cb92fe09dc3
+763, 0xeb5008fe965d8d96
+764, 0x4a3307937eb2e5c8
+765, 0xd07d74c240c6c363
+766, 0x16f62290179d1bbf
+767, 0xe99c9bcc9cb1ece7
+768, 0xc64f9be03c8a93be
+769, 0x32659effaf666c1f
+770, 0x4bb228cfb30b6672
+771, 0x98764870842068a5
+772, 0x5b12ef2d2cd8bdcc
+773, 0xbc79d1c1b41f28b8
+774, 0x97a517cf3279fc9a
+775, 0x34ffd46c1d4d6025
+776, 0x9c302307ee25c8f0
+777, 0x399604eed1f18a8
+778, 0x1c9b813c2043142a
+779, 0x2944ea5e55267fe9
+780, 0x5a8a9f5e728ea667
+781, 0x30c8440adb804a0
+782, 0xee0e6b627099a937
+783, 0x3d50757ada3c52da
+784, 0x4548916b32c813ab
+785, 0x602a186fe5bf109b
+786, 0xf0d440a2227ba304
+787, 0x5a10d4e0ca9ea32b
+788, 0x6e5eb90da13ba64c
+789, 0x4c6af8fd04241ab2
+790, 0xf9eb31d26e093006
+791, 0x5d674878839fe3ea
+792, 0x1562b55b2484e47c
+793, 0xa87188c099c1cb61
+794, 0xb7736b8aa02a3392
+795, 0x5f4b301125abb20f
+796, 0x361d566984637f44
+797, 0x68c4b3feac8bd0c3
+798, 0x7066c634dd2503c1
+799, 0xfecbf7c9441eb6ea
+800, 0xdbc26ae0fc81436b
+801, 0x9ef3e2b48252e7a4
+802, 0x31a49b4c339b37c7
+803, 0xb01b2a83cf346cf4
+804, 0xc24dc2347f82fbe3
+805, 0x134cad272dcd410f
+806, 0x61260742823ba59c
+807, 0x53ac4c193a97c730
+808, 0x9207c9833af34b52
+809, 0xa72e7ee77078d1f5
+810, 0x2e6f6e1b05936885
+811, 0x783b99ce5dbf9464
+812, 0xfdfeb6f0d027bb44
+813, 0x40eeb27096f92b0
+814, 0x5ef96ff5d4a4521f
+815, 0x5595806ae873718a
+816, 0x67d449eecf4ca1c3
+817, 0xde837ab611364f3f
+818, 0x7034c24d2b139be9
+819, 0xe21166603e0a9c86
+820, 0x935694435c1f0d51
+821, 0x6cb3bec90c126088
+822, 0x4096ef662b7a9f89
+823, 0xd2d85b8d238d8c15
+824, 0xa4ea533ce3ec59b2
+825, 0x3654729d80a2db29
+826, 0x214c4cc3906d29d4
+827, 0x201c447e7588e373
+828, 0xe8b8f0ae25f683eb
+829, 0x6744aaf5754e38af
+830, 0xd1ffb10d6f27a061
+831, 0xe536733a7b3a6c30
+832, 0x39f0f66e47cbf2c9
+833, 0x856a9593526fde2
+834, 0x2e2a817a0098ea4b
+835, 0xc5e1eeb551a0e3d3
+836, 0x3f21e2f5e2d50b2
+837, 0x906af56c66dd9f8c
+838, 0x30f6dbd70329fac8
+839, 0xc443dfddf3c01a60
+840, 0x7ab85d9aa9675470
+841, 0x8c9080bd39717bfc
+842, 0x4b1ccdb3c3597f6f
+843, 0x74e2542d70ab5d67
+844, 0xbb3d236aad00f74
+845, 0xcf3cadf9a2804774
+846, 0xe851d9750e42bd07
+847, 0xc0ad82029b1c371f
+848, 0x7ee119eb552d6c07
+849, 0xd8024049bd1d784a
+850, 0xfa67a899760363
+851, 0xaa7c2f438b178197
+852, 0xc473674a47ffe064
+853, 0x539fbe3fc674c270
+854, 0xdb48484748a76f3b
+855, 0xc73b2b092060d
+856, 0xa1d2a15345016f5d
+857, 0x4d0fe8599f9bba47
+858, 0xa0edc275e6f8f1d1
+859, 0x40590a8655bc8d72
+860, 0x35b4223161f05f75
+861, 0xa04c0c0f616752dc
+862, 0x7f371ed2ca45432d
+863, 0x2ff1a08f75ac6438
+864, 0xe2dc5c3682282f48
+865, 0xe1e4179fa98d9013
+866, 0x8cb083d6843a73d5
+867, 0xb4c2b5921b706854
+868, 0x738e14c0e7352445
+869, 0xcd2b646f91afd8c7
+870, 0xd5779a5b57a264fd
+871, 0xc39ff855586c7d07
+872, 0x3e3f0098c631a859
+873, 0x644e02fae032110
+874, 0xa8834613c0a45278
+875, 0x69482f2c08e10657
+876, 0xe4ee475bdb87e69a
+877, 0xdc1ef7b25c0d0019
+878, 0x88a3fa2be18d8744
+879, 0x60a02e0b21c5bec7
+880, 0xb6867b88aa19bc1a
+881, 0xb599409affcf10eb
+882, 0xaeaa1778a5e59daa
+883, 0xd7a91a52c16663e3
+884, 0x93cb269affe07b1c
+885, 0x841b6ced3a4ba815
+886, 0x84541768e1540a5c
+887, 0xe3943c84f83b3020
+888, 0x5de366fbd7b45258
+889, 0xd787cc3bde91a661
+890, 0x814071446edecb57
+891, 0x15d8c602a1141514
+892, 0x72f07bc8002d1d0d
+893, 0x4a8bd8dc9a1f0f3e
+894, 0x8723796ae0f20d35
+895, 0xda7283c2051f73b2
+896, 0x2df0cc247f90bd3b
+897, 0x79a8522b968f990a
+898, 0x951ede190c8b9d02
+899, 0xc512f1a5b14b018a
+900, 0xf0e3ddc03b9a4259
+901, 0x8cf4a35ad312e15f
+902, 0xebef28926b11094b
+903, 0x5628ba687325921c
+904, 0xc3aa75e57edc49c3
+905, 0xc38382fa98e762ba
+906, 0x8d209e896285848e
+907, 0x2c7d6adf592b4a3e
+908, 0x62de48e36f8338f3
+909, 0x4a752741e00de30e
+910, 0xf7855b70f1f6ec2b
+911, 0xa505fa4428199e43
+912, 0xe8b6b423b826bbac
+913, 0x4bd1206cf8786d05
+914, 0x6dcf040391fe3bf4
+915, 0x913f500f87e1bba3
+916, 0x5acf775aa180a5d5
+917, 0x74dd28d9432ce739
+918, 0x996c2ff2f0dc2495
+919, 0x73dbfe6c56effe4
+920, 0x56fddd25196f5e40
+921, 0xe87810158f5b7
+922, 0x7b8795e996383f1f
+923, 0x9ba5ee7c777c4c82
+924, 0x17ce3908d270fe1c
+925, 0x3df9e613c1aedfae
+926, 0xcdd26871b32fc8e1
+927, 0xd71cb13afc633979
+928, 0x63427c8ea9b1c79e
+929, 0xd070f7664d3b405d
+930, 0x46f2a9e32d9fb769
+931, 0xb4c3822a45e9fe9b
+932, 0x8ba30b97fe6f5ec7
+933, 0x70aa554ee2fc11f9
+934, 0xa80c99dbe0cfcfaf
+935, 0x36d9250cb2d68ed
+936, 0x2995e4b9e1cd1db4
+937, 0x4b3803ba57fc570f
+938, 0xae3959e7d740eaa5
+939, 0xb4cbd6662adbae08
+940, 0xae46576446e8dbc4
+941, 0xc4828e008a9a8a54
+942, 0x145d7db8e6554b2f
+943, 0x1b1b8916a730c371
+944, 0xdaf84b2bebe31963
+945, 0x5b59b80ef23a2403
+946, 0x9180c7e89cab6fd3
+947, 0x80e58f5411babf34
+948, 0xa06cf55185b9b005
+949, 0x13b2c798424173ad
+950, 0xc510f8e706311d49
+951, 0x1f974b83b6046d3a
+952, 0xae6e8e85e822d1c3
+953, 0x66f2c8dc3274a31a
+954, 0x7e04dbcbf65bd377
+955, 0xabf41ede01ec20a4
+956, 0x5efa0948f6bbb2ea
+957, 0xbc91c99d8592255
+958, 0xf6d6917911d86d75
+959, 0x85ce273d54e9097a
+960, 0xbdfd30f2420fff92
+961, 0x8802f02f610b537c
+962, 0xd1d70037ed543229
+963, 0x908aaf97f9693a46
+964, 0x1f6cfeaa0834d53a
+965, 0xa453fd1648ce04d2
+966, 0x2c38bb85ebc64af9
+967, 0xd2daff551c90c4f8
+968, 0xae5a0d949797d784
+969, 0xf0974c8552ac9593
+970, 0xa10b70499f65c693
+971, 0x39a449ebd594ddff
+972, 0x8ea090f2b17b9b49
+973, 0xc592de318090fd83
+974, 0xb63e4fbc467b6912
+975, 0x57a0c1c5ce0e4dcc
+976, 0xa7c517cf3d436b35
+977, 0xef6dcb0f3fad038b
+978, 0xaf4fb60315b91287
+979, 0x5e0776f67304f331
+980, 0xe927753b8e6f7932
+981, 0xd3df2dd92559e304
+982, 0xdaed52aa6af44413
+983, 0x1b59f4dac1e181f8
+984, 0x4a73c2293877ef39
+985, 0xca45d0d015fe44de
+986, 0x4659c8b7853735a8
+987, 0x12de6466bdf8adeb
+988, 0xaeea857a09bfec15
+989, 0xcc9cf4b3c0b88a23
+990, 0xa44ae52396a5e1bf
+991, 0x5847a724305d137f
+992, 0x8f4d4de223956182
+993, 0x58254dfada867a8
+994, 0x900a98222c2f339e
+995, 0xdb575260935d51d5
+996, 0x13fb4bfbbc0d7b53
+997, 0x62213850186bb92b
+998, 0x2a34823312c00388
+999, 0x6148329042f743b0
diff --git a/venv/lib/python3.12/site-packages/numpy/random/tests/data/pcg64dxsm-testset-1.csv b/venv/lib/python3.12/site-packages/numpy/random/tests/data/pcg64dxsm-testset-1.csv
new file mode 100644
index 00000000..39cef057
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/random/tests/data/pcg64dxsm-testset-1.csv
@@ -0,0 +1,1001 @@
+seed, 0xdeadbeaf
+0, 0xdf1ddcf1e22521fe
+1, 0xc71b2f9c706cf151
+2, 0x6922a8cc24ad96b2
+3, 0x82738c549beccc30
+4, 0x5e8415cdb1f17580
+5, 0x64c54ad0c09cb43
+6, 0x361a17a607dce278
+7, 0x4346f6afb7acad68
+8, 0x6e9f14d4f6398d6b
+9, 0xf818d4343f8ed822
+10, 0x6327647daf508ed6
+11, 0xe1d1dbe5496a262a
+12, 0xfc081e619076b2e0
+13, 0x37126563a956ab1
+14, 0x8bb46e155db16b9
+15, 0x56449f006c9f3fb4
+16, 0x34a9273550941803
+17, 0x5b4df62660f99462
+18, 0xb8665cad532e3018
+19, 0x72fc3e5f7f84216a
+20, 0x71d3c47f6fd59939
+21, 0xfd4218afa1de463b
+22, 0xc84054c78e0a9a71
+23, 0xae59034726be61a8
+24, 0xa6a5f21de983654d
+25, 0x3b633acf572009da
+26, 0x6a0884f347ab54c8
+27, 0x7a907ebe9adcab50
+28, 0xbe779be53d7b8d4a
+29, 0xf5976e8c69b9dcd1
+30, 0x1d8302f114699e11
+31, 0x7d37e43042c038a0
+32, 0x2cc1d4edc2a40f35
+33, 0x83e3347bb2d581f1
+34, 0x253f8698651a844d
+35, 0x4312dea0dd4e32f6
+36, 0x10f106439964ea3a
+37, 0x810eb374844868cc
+38, 0x366342a54b1978cc
+39, 0x9fb39b13aaddfb5e
+40, 0xdb91fd0d9482bed7
+41, 0x89f6ea4ca9c68204
+42, 0x146b31ccca461792
+43, 0x203fd9724deb2486
+44, 0x58a84f23748e25cb
+45, 0x2f20eb6aeb94e88
+46, 0x14d3581460e473c
+47, 0xad5bd0d25f37d047
+48, 0x1cf88fa16de258b2
+49, 0x3bcab6485b7a341
+50, 0xb2433b37f227d90c
+51, 0x2cffd7e0a8360cc8
+52, 0x5d2eeff7c9ebc847
+53, 0x6fd7c7ae23f9f64b
+54, 0x381650b2d00f175d
+55, 0x9d93edcedc873cae
+56, 0x56e369a033d4cb49
+57, 0x7547997116a3bac
+58, 0x11debaa897fd4665
+59, 0xdf799d2b73bd6fb8
+60, 0x3747d299c66624d
+61, 0xac9346701afd0cfa
+62, 0xac90e150fa13c7bf
+63, 0x85c56ad2248c2871
+64, 0xdea66bf35c45f195
+65, 0x59cf910ea079fb74
+66, 0x2f841bb782274586
+67, 0x9814df4384d92bd9
+68, 0x15bc70824be09925
+69, 0x16d4d0524c0503a3
+70, 0xf04ea249135c0cc7
+71, 0xa707ab509b7e3032
+72, 0x465459efa869e372
+73, 0x64cbf70a783fab67
+74, 0x36b3541a14ca8ed7
+75, 0x9a4dfae8f4c596bf
+76, 0x11d9a04224281be3
+77, 0xe09bbe6d5e98ec32
+78, 0xa6c60d908973aa0d
+79, 0x7c524c57dd5915c8
+80, 0xa810c170b27f1fdc
+81, 0xce5d409819621583
+82, 0xfe2ee3d5332a3525
+83, 0x162fb7c8b32045eb
+84, 0x4a3327156b0b2d83
+85, 0x808d0282f971064
+86, 0x2e6f04cf5ed27e60
+87, 0xaf6800699cca67a9
+88, 0xc7590aae7244c3bf
+89, 0x7824345f4713f5f9
+90, 0x8f713505f8fd059b
+91, 0x3d5b5b9bb6b1e80e
+92, 0x8674f45e5dc40d79
+93, 0xcb1e36846aa14773
+94, 0xe0ae45b2b9b778c1
+95, 0xd7254ce931eefcfb
+96, 0xef34e15e4f55ac0a
+97, 0xf17cc0ba15a99bc4
+98, 0x77bb0f7ffe7b31f1
+99, 0x6ee86438d2e71d38
+100, 0x584890f86829a455
+101, 0x7baf0d8d30ba70fe
+102, 0xb1ac8f326b8403ae
+103, 0xcc1963435c874ba7
+104, 0x9c483b953d1334ce
+105, 0xc0924bcbf3e10941
+106, 0x21bcc581558717b1
+107, 0x2c5ad1623f8d292b
+108, 0xa8ea110f6124557e
+109, 0x15f24a6c5c4c591
+110, 0x40fe0d9cd7629126
+111, 0xcfe8f2b3b081484d
+112, 0x891383f4b4cac284
+113, 0x76f2fcdef7fa845
+114, 0x4edd12133aed0584
+115, 0xd53c06d12308873d
+116, 0xf7f22882c17f86bf
+117, 0xfbaa4aad72f35e10
+118, 0x627610da2e3c0cc3
+119, 0x582b16a143634d9a
+120, 0x9b4a7f69ed38f4a0
+121, 0x2df694974d1e1cbe
+122, 0xe5be6eaafed5d4b
+123, 0xc48e2a288ad6605e
+124, 0xbcb088149ce27c2b
+125, 0x3cb6a7fb06ceecbe
+126, 0x516735fff3b9e3ac
+127, 0x5cbafc551ee5008d
+128, 0xee27d1ab855c5fd5
+129, 0xc99fb341f6baf846
+130, 0x7ad8891b92058e6d
+131, 0xf50310d03c1ac6c7
+132, 0x947e281d998cbd3e
+133, 0x1d4d94a93824fe80
+134, 0x5568b77289e7ee73
+135, 0x7d82d1b2b41e3c8b
+136, 0x1af462c7abc787b
+137, 0xcfd8dfe80bfae1ef
+138, 0xd314caeb723a63ea
+139, 0x1c63ddcfc1145429
+140, 0x3801b7cc6cbf2437
+141, 0xc327d5b9fdafddd3
+142, 0xe140278430ca3c78
+143, 0x4d0345a685cb6ef8
+144, 0x47640dc86e261ff9
+145, 0xab817f158523ebf4
+146, 0x37c51e35fbe65a6b
+147, 0xab090f475d30a178
+148, 0x4d3ec225bf599fc1
+149, 0xefd517b0041679b1
+150, 0x20ad50bca4da32c5
+151, 0x75e1f7cd07fad86d
+152, 0x348cf781ee655f4b
+153, 0x9375f0e5ffc2d2ec
+154, 0x7689082fd5f7279c
+155, 0x633e56f763561e77
+156, 0x9d1752d70861f9fd
+157, 0xa3c994b4e70b0b0f
+158, 0xabf7276a58701b88
+159, 0xbfa18d1a0540d000
+160, 0xc6a28a2475646d26
+161, 0x7cdf108583f65085
+162, 0x82dcefb9f32104be
+163, 0xc6baadd0adc6b446
+164, 0x7a63cff01075b1b4
+165, 0x67ac62e575c89919
+166, 0x96fa4320a0942035
+167, 0xc4658859385b325f
+168, 0xde22c17ff47808f6
+169, 0xbb952c4d89e2f2ec
+170, 0x638251fbc55bdc37
+171, 0x38918b307a03b3ea
+172, 0xccb60f2cedbb570b
+173, 0x3c06f4086a28f012
+174, 0x4e8d238388986e33
+175, 0x1760b7793514a143
+176, 0xa3f924efe49ee7d6
+177, 0xaf6be2dbaebc0bdf
+178, 0x6782682090dffe09
+179, 0xb63a4d90d848e8ef
+180, 0x5f649c7eaf4c54c5
+181, 0xbe57582426a085ba
+182, 0xb5dd825aa52fb76d
+183, 0x74cb4e6ca4039617
+184, 0x382e578bf0a49588
+185, 0xc043e8ea6e1dcdae
+186, 0xf902addd5c04fa7c
+187, 0xf3337994612528db
+188, 0x4e8fd48d6d15b4e6
+189, 0x7190a509927c07ab
+190, 0x864c2dee5b7108ae
+191, 0xbb9972ddc196f467
+192, 0x1ea02ab3ca10a448
+193, 0xe50a8ffde35ddef9
+194, 0x7bd2f59a67183541
+195, 0x5a940b30d8fcd27a
+196, 0x82b4cea62623d4d3
+197, 0x6fbda76d4afef445
+198, 0x8b1f6880f418328e
+199, 0x8b69a025c72c54b7
+200, 0xb71e0f3986a3835f
+201, 0xa4a7ddb8b9816825
+202, 0x945dcda28228b1d8
+203, 0xb471abf2f8044d72
+204, 0xf07d4af64742b1ba
+205, 0xfca5190bc4dd6a2a
+206, 0xd681497262e11bc5
+207, 0xbe95d5f00c577028
+208, 0x56313439fd8bde19
+209, 0x3f3d9ac9b5ee6522
+210, 0x7b8d457dd2b49bbe
+211, 0xe76b5747885d214b
+212, 0xa8a695b3deb493ea
+213, 0x5292446548c95d71
+214, 0xbf5cdf0d436412df
+215, 0x7936abaed779d28d
+216, 0x659c6e8073b3a06d
+217, 0x86c9ff28f5543b71
+218, 0x6faa748445a99146
+219, 0xdcc1e6ab57904fd7
+220, 0x770bd61233addc5f
+221, 0x16963e041e46d94f
+222, 0x158e6cb2934157ac
+223, 0xb65088a8fd246441
+224, 0x2b12ced6ce8a68c3
+225, 0x59a18d02cd6082b3
+226, 0x4ddbc318cb5488ee
+227, 0x3d4cf520b3ed20a1
+228, 0x7028b3a92e2b292d
+229, 0xf141da264a250e4d
+230, 0x9788d53e86041c37
+231, 0x1bb91238a7c97dbf
+232, 0x81953d0ddb634309
+233, 0xfa39ccfe14d2d46
+234, 0xf7c7861c9b7e8399
+235, 0x18d27ca50d9dc249
+236, 0x258dfdf38510d0d9
+237, 0x9e72d8af910ea76f
+238, 0x4f8ef24b96de50ad
+239, 0xb9d9c12297e03dc9
+240, 0x91994e41b4a1929c
+241, 0x8defa79b2ccc83b9
+242, 0x948566748706dac5
+243, 0x7b0454946e70e4cf
+244, 0x340b7cb298c70ed7
+245, 0x6602005330cebd95
+246, 0xf71cb803aa61f722
+247, 0x4683fb07fc70ae8a
+248, 0xc6db9f0c4de3ed88
+249, 0x3e8dfae2a593cef9
+250, 0x615f7c38e3862b33
+251, 0x676c7996550d857
+252, 0xc6d520d54a5c266a
+253, 0x202b1e8eef14aa2e
+254, 0xa3a84891a27a582
+255, 0x84dbee451658d47f
+256, 0x254c7cd97e777e3a
+257, 0xf50b6e977f0eba50
+258, 0x2898b1d3062a4798
+259, 0x4096f7cbbb019773
+260, 0x9fb8e75548062c50
+261, 0x4647071e5ca318ec
+262, 0x2b4750bdb3b3b01
+263, 0x88ac41cc69a39786
+264, 0x705e25476ef46fa3
+265, 0xc0c1db19884a48a6
+266, 0x1364c0afdbb465e5
+267, 0x58e98534701272a6
+268, 0x746a5ea9701517c0
+269, 0x523a70bc6b300b67
+270, 0x9b1c098eda8564ad
+271, 0xfbaeb28d3637067f
+272, 0xddd9a13551fdba65
+273, 0x56461a670559e832
+274, 0xab4fd79be85570ad
+275, 0xd4b691ecaff8ca55
+276, 0x11a4495939e7f004
+277, 0x40d069d19477eb47
+278, 0xe790783d285cd81e
+279, 0xde8218b16d935bc7
+280, 0x2635e8c65cd4182d
+281, 0xeae402623e3454
+282, 0x9f99c833184e0279
+283, 0x3d0f79a0d52d84e7
+284, 0xc1f8edb10c625b90
+285, 0x9b4546363d1f0489
+286, 0x98d86d0b1212a282
+287, 0x386b53863161200d
+288, 0xbe1165c7fe48a135
+289, 0xb9658b04dbbfdc8c
+290, 0xcea14eddfe84d71a
+291, 0x55d03298be74abe7
+292, 0x5be3b50d961ffd7e
+293, 0xc76b1045dc4b78e1
+294, 0x7830e3ff3f6c3d4c
+295, 0xb617adb36ca3729
+296, 0x4a51bdb194f14aa9
+297, 0x246024e54e6b682a
+298, 0x33d42fc9c6d33083
+299, 0xadccba149f31e1d
+300, 0x5183e66b9002f8b
+301, 0x70eb2416404d51b7
+302, 0x26c25eb225535351
+303, 0xbc2d5b0d23076561
+304, 0x5823019ddead1da
+305, 0x85cfa109fca69f62
+306, 0x26017933e7e1efd9
+307, 0x3ec7be9a32212753
+308, 0x697e8a0697cd6f60
+309, 0x44735f6cca03920f
+310, 0x8cc655eb94ee212e
+311, 0x8b8b74eba84929a0
+312, 0x7708ccedd0c98c80
+313, 0x1b6f21f19777cbe1
+314, 0x363e564bd5fadedb
+315, 0x5921543a641591fe
+316, 0xc390786d68ea8a1b
+317, 0x9b293138dc033fca
+318, 0x45447ca8dc843345
+319, 0xee6ef6755bc49c5e
+320, 0x70a3a1f5163c3be5
+321, 0xf05e25448b6343b0
+322, 0x4739f4f8717b7e69
+323, 0xb006141975bf957
+324, 0x31874a91b707f452
+325, 0x3a07f2c90bae2869
+326, 0xb73dae5499a55c5e
+327, 0x489070893bb51575
+328, 0x7129acf423940575
+329, 0x38c41f4b90130972
+330, 0xc5260ca65f5a84a1
+331, 0x6e76194f39563932
+332, 0x62ca1f9ca3de3ca6
+333, 0xb4a97874e640853f
+334, 0x38ed0f71e311cc02
+335, 0xde183b81099e8f47
+336, 0x9bb8bf8e6694346
+337, 0xd15497b6bf81e0f2
+338, 0xaaae52536c00111
+339, 0x4e4e60d1435aaafd
+340, 0x5a15512e5d6ea721
+341, 0xff0f1ffabfc6664f
+342, 0xba3ffcedc5f97fec
+343, 0xef87f391c0c6bfb6
+344, 0x4a888c5d31eb0f98
+345, 0x559a3fbfd7946e95
+346, 0xe45b44a0db5a9bad
+347, 0x9457898964190af1
+348, 0xd9357dfaab76cd9e
+349, 0xa60e907178d965a1
+350, 0x76b2dc3032dc2f4a
+351, 0x13549b9c2802120
+352, 0x8656b965a66a1800
+353, 0x16802e6e22456a23
+354, 0x23b62edc60efaa9
+355, 0x6832a366e1e4ea3b
+356, 0x46b1b41093ff2b1e
+357, 0x55c857128143f219
+358, 0x7fc35ddf5e138200
+359, 0x790abe78be67467e
+360, 0xa4446fc08babd466
+361, 0xc23d70327999b855
+362, 0x2e019d1597148196
+363, 0xfefd98e560403ab8
+364, 0xbe5f0a33da330d58
+365, 0x3078a4e9d43ca395
+366, 0x511bfedd6f12f2b3
+367, 0x8bc138e335be987c
+368, 0x24640f803465716d
+369, 0xf6530b04d0bd618f
+370, 0x9b7833e5aa782716
+371, 0x778cd35aea5841b1
+372, 0xecea3c458cefbc60
+373, 0x5107ae83fc527f46
+374, 0x278ad83d44bd2d1a
+375, 0x7014a382295aeb16
+376, 0xf326dd762048743f
+377, 0x858633d56279e553
+378, 0x76408154085f01bc
+379, 0x3e77d3364d02e746
+380, 0x2f26cea26cadd50b
+381, 0x6d6846a4ecb84273
+382, 0x4847e96f2df5f76
+383, 0x5a8610f46e13ff61
+384, 0x4e7a7cac403e10dd
+385, 0x754bdf2e20c7bc90
+386, 0x8bdd80e6c51bd0be
+387, 0x61c655fae2b4bc52
+388, 0x60873ef48e3d2f03
+389, 0x9d7d8d3698a0b4a4
+390, 0xdf48e9c355cd5d4b
+391, 0x69ecf03e20be99ac
+392, 0xc1a0c5a339bd1815
+393, 0x2e3263a6a3adccb
+394, 0x23557459719adbdc
+395, 0xd1b709a3b330e5a
+396, 0xade5ab00a5d88b9d
+397, 0x69a6bd644120cfad
+398, 0x40187ecceee92342
+399, 0x1c41964ba1ac78da
+400, 0x9ac5c51cbecabe67
+401, 0xbdc075781cf36d55
+402, 0xeaf5a32246ded56
+403, 0xcda0b67e39c0fb71
+404, 0x4839ee456ef7cc95
+405, 0xf17092fdd41d5658
+406, 0x2b5d422e60ae3253
+407, 0x3effe71102008551
+408, 0x20a47108e83934b7
+409, 0xd02da65fe768a88f
+410, 0xeb046bd56afa4026
+411, 0x70c0509c08e0fbe0
+412, 0x1d35c38d4f8bac6c
+413, 0x9aa8eb6466f392e0
+414, 0x587bd4a430740f30
+415, 0x82978fe4bad4195
+416, 0xdc4ebc4c0feb50ab
+417, 0xd3b7164d0240c06f
+418, 0x6e2ad6e5a5003a63
+419, 0xa24b430e2ee6b59c
+420, 0x2905f49fd5073094
+421, 0x5f209e4de03aa941
+422, 0x57b7da3e0bedb1dc
+423, 0x5e054018875b01f5
+424, 0xb2f2da6145658db3
+425, 0xbd9c94a69a8eb651
+426, 0x9c5f9a07cd6ac749
+427, 0x2296c4af4d529c38
+428, 0x522ed800fafdefab
+429, 0xe2a447ced0c66791
+430, 0x937f10d45e455fef
+431, 0xc882987d9e29a24
+432, 0x4610bfd6a247ee1a
+433, 0x562ba3e50870059
+434, 0x59d8d58793602189
+435, 0xfe9a606e3e34abe
+436, 0x6825f7932a5e9282
+437, 0xe77f7061bab476ad
+438, 0xbf42001da340ace3
+439, 0x9c3e9230f5e47960
+440, 0x2c0f700d96d5ad58
+441, 0x330048b7cd18f1f9
+442, 0xffc08785eca5cca9
+443, 0xb5879046915f07a5
+444, 0xef51fe26f83c988e
+445, 0xfa4c2968e7881a9a
+446, 0xc0a9744455a4aad
+447, 0xbd2ad686d6313928
+448, 0x6b9f0984c127682a
+449, 0xc9aaa00a5da59ed8
+450, 0x762a0c4b98980dbf
+451, 0x52d1a2393d3ca2d1
+452, 0x1e9308f2861db15c
+453, 0xe7b3c74fe4b4a844
+454, 0x485e15704a7fc594
+455, 0x9e7f67ea44c221f6
+456, 0xbab9ad47fde916e0
+457, 0x50e383912b7fc1f4
+458, 0xaad63db8abcef62d
+459, 0xc2f0c5699f47f013
+460, 0xee15b36ada826812
+461, 0x2a1b1cf1e1777142
+462, 0x8adb03ede79e937d
+463, 0xf14105ef65643bf3
+464, 0x752bbaefc374a3c7
+465, 0xa4980a08a5a21d23
+466, 0x418a1c05194b2db7
+467, 0xdd6ff32efe1c3cd6
+468, 0x272473ed1f0d3aa2
+469, 0x1e7fdebadabe6c06
+470, 0xd1baa90c17b3842f
+471, 0xd3d3a778e9c8404a
+472, 0x781ae7fda49fa1a0
+473, 0x61c44fdbdacc672d
+474, 0x6d447d0a1404f257
+475, 0x9303e8bdfbfb894d
+476, 0x3b3482cdec016244
+477, 0xb149bf245d062e7b
+478, 0x96f8d54b14cf992d
+479, 0x4741549a01f8c3d0
+480, 0x48270811b2992af
+481, 0x7b58f175cd25d147
+482, 0x8f19a840b56f4be9
+483, 0x84a77f43c0951a93
+484, 0x34e1a69381f0c374
+485, 0xb158383c9b4040f
+486, 0x372f1abc7cf3a9fa
+487, 0x5439819a84571763
+488, 0xabf8515e9084e2fa
+489, 0xb02312b9387ff99
+490, 0x238a85bb47a68b12
+491, 0x2068cb83857c49bb
+492, 0xc6170e743083664c
+493, 0x745cf8470bcb8467
+494, 0xe3a759a301670300
+495, 0x292c7686ad3e67da
+496, 0x359efedaff192a45
+497, 0x511f2c31a2d8c475
+498, 0x97fd041bf21c20b3
+499, 0x25ef1fe841b7b3f6
+500, 0xbb71739e656f262d
+501, 0x2729b0e989b6b7b8
+502, 0xd2142702ec7dbabf
+503, 0x7008decd2488ee3f
+504, 0x69daa95e303298d7
+505, 0xc35eca4efb8baa5a
+506, 0xf3f16d261cec3b6c
+507, 0x22371c1d75396bd3
+508, 0x7aefa08eccae857e
+509, 0x255b493c5e3c2a2f
+510, 0x779474a077d34241
+511, 0x5199c42686bea241
+512, 0x16c83931e293b8d3
+513, 0xa57fe8db8c0302c7
+514, 0xd7ace619e5312eb1
+515, 0x8740f013306d217c
+516, 0xb6a1ad5e29f4d453
+517, 0x31abf7c964688597
+518, 0xbc3d791daed71e7
+519, 0x31ee4ca67b7056ed
+520, 0x1ab5416bfe290ea3
+521, 0x93db416f6d3b843a
+522, 0xed83bbe5b1dd2fed
+523, 0xece38271470d9b6d
+524, 0x3a620f42663cd8ae
+525, 0x50c87e02acafee5d
+526, 0xcabeb8bedbc6dab5
+527, 0x2880a6d09970c729
+528, 0x4aba5dd3bfc81bc
+529, 0xaba54edf41080cec
+530, 0xb86bb916fc85a169
+531, 0x4c41de87bc79d8ca
+532, 0xcce2a202622945fe
+533, 0x513f086fad94c107
+534, 0x18b3960c11f8cc96
+535, 0x2f0d1cfd1896e236
+536, 0x1702ae3880d79b15
+537, 0x88923749029ae81
+538, 0x84810d4bdec668eb
+539, 0xf85b0a123f4fc68d
+540, 0x93efd68974b6e4d1
+541, 0x5d16d6d993a071c9
+542, 0x94436858f94ca43b
+543, 0xb3dbb9ed0cb180b6
+544, 0x6447030a010b8c99
+545, 0xd7224897c62925d8
+546, 0xb0c13c1d50605d3a
+547, 0xdff02c7cb9d45f30
+548, 0xe8103179f983570d
+549, 0xbc552037d6d0a24e
+550, 0x775e500b01486b0d
+551, 0x2050ac632c694dd6
+552, 0x218910387c4d7ae7
+553, 0xf83e8b68ff885d5d
+554, 0xe3374ec25fca51a3
+555, 0xfa750ffa3a60f3af
+556, 0x29ee40ba6df5592e
+557, 0x70e21a68f48260d2
+558, 0x3805ca72cd40886e
+559, 0x2f23e73f8eabf062
+560, 0x2296f80cdf6531ae
+561, 0x903099ed968db43a
+562, 0xf044445cf9f2929f
+563, 0xcd47fdc2de1b7a1
+564, 0xaab1cbd4f849da99
+565, 0x5fc990688da01acb
+566, 0xa9cee52ea7dab392
+567, 0xecefc3a4349283a8
+568, 0xdd6b572972e3fafc
+569, 0xc1f0b1a2ffb155da
+570, 0xc30d53fc17bd25c8
+571, 0x8afa89c77834db28
+572, 0x5569a596fb32896c
+573, 0x36f207fc8df3e3d4
+574, 0x57c2bd58517d81db
+575, 0xb524693e73d0061c
+576, 0xb69f6eb233f5c48b
+577, 0x4f0fb23cab8dc695
+578, 0x492c1ad0a48df8df
+579, 0xf6dcc348ec8dec1f
+580, 0xa4d8708d6eb2e262
+581, 0x4c2072c2c9766ff1
+582, 0xa9bf27c4304875f0
+583, 0xfc8fb8066d4f9ae2
+584, 0x188095f6235fec3c
+585, 0x1d8227a2938c2864
+586, 0x89ea50c599010378
+587, 0xcac86df0a7c6d56d
+588, 0x47a8c5df84c7d78
+589, 0xe607ae24ea228bfa
+590, 0x36624a7996efe104
+591, 0x5d72881c1227d810
+592, 0x78694a6750374c8
+593, 0x7b9a217d4ab5ff45
+594, 0xd53e5d6f7504becc
+595, 0x197a72d3f4889a0e
+596, 0xfdc70c4755a8df36
+597, 0xd0fda83748c77f74
+598, 0x7ddc919ac9d6dcc9
+599, 0x785c810a6a2dc08b
+600, 0xba4be83e7e36896c
+601, 0x379d6fe80cf2bffe
+602, 0x74cae2dabc429206
+603, 0x1efac32d5d34c917
+604, 0x3cb64e2f98d36e70
+605, 0xc0a7c3cdc3c60aa7
+606, 0x699dfadd38790ebe
+607, 0x4861e61b3ecfbeac
+608, 0x531744826c345baa
+609, 0x5ec26427ad450cba
+610, 0xf2c1741479abdcae
+611, 0xe9328a78b2595458
+612, 0x30cd1bdf087acd7f
+613, 0x7491ced4e009adbe
+614, 0xdcd942df1e2e7023
+615, 0xfe63f01689fee35
+616, 0x80282dfe5eaedc42
+617, 0x6ecdea86495f8427
+618, 0xe0adfdd5e9ed31c3
+619, 0xf32bd2a7418127e
+620, 0x8aabba078db6ee2
+621, 0xa8a8e60499145aca
+622, 0xf76b086ac4e8a0f2
+623, 0x6e55b3c452ff27f8
+624, 0xe18fa7cd025a71bf
+625, 0xeed7b685fde0fa25
+626, 0xba9b6c95867fa721
+627, 0x4c2603bc69de2df2
+628, 0xaac87eee1b58cd66
+629, 0x3c9af6656e01282c
+630, 0x2dfa05ce8ff476b6
+631, 0xeae9143fcf92f23d
+632, 0x3f0699f631be3bc8
+633, 0xa0f5f79f2492bd67
+634, 0x59c47722388131ed
+635, 0x5f6e9d2941cef1de
+636, 0xe9ad915c09788b7b
+637, 0x92c6d37e4f9482f5
+638, 0x57d301b7fdadd911
+639, 0x7e952d23d2a8443
+640, 0xbb2fa5e0704b3871
+641, 0xe5642199be36e2d5
+642, 0x5020b60d54358291
+643, 0xa0b6317ec3f60343
+644, 0xb57b08b99540bc5c
+645, 0x21f1890adc997a88
+646, 0xfcf824200dd9da2d
+647, 0x8146293d83d425d1
+648, 0xdadfbf5fbb99d420
+649, 0x1eb9bbc5e6482b7d
+650, 0xd40ff44f1bbd0f1c
+651, 0xa9f948ba2d08afa5
+652, 0x638cc07c5301e601
+653, 0x1f984baa606e14e8
+654, 0x44e153671081f398
+655, 0xb17882eeb1d77a5d
+656, 0x5fd8dbee995f14c
+657, 0xff3533e87f81b7fe
+658, 0x2f44124293c49795
+659, 0x3bf6b51e9360248
+660, 0x72d615edf1436371
+661, 0x8fc5cf4a38adab9d
+662, 0xfa517e9022078374
+663, 0xf356733f3e26f4d8
+664, 0x20ea099cdc6aad40
+665, 0xe15b977deb37637d
+666, 0xcc85601b89dae88d
+667, 0x5768c62f8dd4905c
+668, 0xa43cc632b4e56ea
+669, 0xc4240cf980e82458
+670, 0xb194e8ffb4b3eeb6
+671, 0xee753cf2219c5fa1
+672, 0xfe2500192181d44d
+673, 0x2d03d7d6493dd821
+674, 0xff0e787bb98e7f9b
+675, 0xa05cf8d3bd810ce7
+676, 0x718d5d6dcbbdcd65
+677, 0x8d0b5343a06931c
+678, 0xae3a00a932e7eaf9
+679, 0x7ed3d8f18f983e18
+680, 0x3bb778ee466dc143
+681, 0x711c685c4e9062c0
+682, 0x104c3af5d7ac9834
+683, 0x17bdbb671fb5d5cf
+684, 0xabf26caead4d2292
+685, 0xa45f02866467c005
+686, 0xf3769a32dc945d2d
+687, 0xe78d0007f6aabb66
+688, 0x34b60be4acbd8d4b
+689, 0x58c0b04b69359084
+690, 0x3a8bb354c212b1
+691, 0x6b82a8f3d70058d5
+692, 0x405bdef80a276a4a
+693, 0xe20ca40ee9195cad
+694, 0xf5dd96ba2446fefd
+695, 0xc1e180c55fe55e3c
+696, 0xa329caf6daa952b3
+697, 0xb4809dd0c84a6b0a
+698, 0xd27f82661070cee7
+699, 0xa7121f15ee2b0d8a
+700, 0x4bdaea70d6b34583
+701, 0xe821dc2f310f7a49
+702, 0x4c00a5a68e76f647
+703, 0x331065b064a2d5ea
+704, 0xac0c2ce3dc04fa37
+705, 0x56b32b37b8229008
+706, 0xe757cdb51534fcfa
+707, 0xd3ff183576b2fad7
+708, 0x179e1f4190f197a7
+709, 0xf874c626a7c9aae5
+710, 0xd58514ffc37c80e4
+711, 0xc65de31d33fa7fd3
+712, 0x6f6637052025769b
+713, 0xca1c6bdadb519cc0
+714, 0xd1f3534cde37828a
+715, 0xc858c339eee4830a
+716, 0x2371eacc215e02f4
+717, 0x84e5022db85bbbe9
+718, 0x5f71c50bba48610e
+719, 0xe420192dad9c323f
+720, 0x2889342721fca003
+721, 0x83e64f63334f501d
+722, 0xac2617172953f2c
+723, 0xfa1f78d8433938ff
+724, 0x5578382760051462
+725, 0x375d7a2e3b90af16
+726, 0xb93ff44e6c07552d
+727, 0xded1d5ad811e818c
+728, 0x7cf256b3b29e3a8c
+729, 0x78d581b8e7bf95e8
+730, 0x5b69192f2caa6ad3
+731, 0xa9e25855a52de3ce
+732, 0x69d8e8fc45cc188d
+733, 0x5dd012c139ad347d
+734, 0xfcb01c07b77db606
+735, 0x56253e36ab3d1cce
+736, 0x1181edbb3ea2192
+737, 0x325bef47ff19a08d
+738, 0xd3e231ceb27e5f7
+739, 0x8e819dd2de7956d2
+740, 0x34a9689fe6f84a51
+741, 0x3e4eeb719a9c2927
+742, 0x5c3b3440581d0aaf
+743, 0x57caf51897d7c920
+744, 0xec6a458130464b40
+745, 0xe98f044e0da40e9b
+746, 0xbe38662020eeb8e7
+747, 0x7b8c407c632724ae
+748, 0x16c7cfa97b33a544
+749, 0xd23359e2e978ae5a
+750, 0x4fdba458250933dd
+751, 0x3c9e0713cfe616ba
+752, 0x6f0df87b13163b42
+753, 0xc460902cb852cc97
+754, 0x289df8fefd6b0bce
+755, 0x4ac2a2a1c3fb8029
+756, 0x2fc3e24d8b68eef7
+757, 0x34564386a59aab9a
+758, 0x31047391ebd67ce4
+759, 0x6c23d070a0564d41
+760, 0xba6387b2b72545f7
+761, 0xcdcf1008058387af
+762, 0xc9308fa98db05192
+763, 0xdbdbb5abd01a9d84
+764, 0x937088275c7804ab
+765, 0x6f6accfefe34ee81
+766, 0x5c33c74c49cfdb2c
+767, 0x5e1a771edfb92bd3
+768, 0x6e89b009069ecae7
+769, 0x34d64e17ec0e8968
+770, 0x841203d0cde0c330
+771, 0x7642cc9d7eb9e9cb
+772, 0xca01d2e8c128b97e
+773, 0x5b8390617b3304ab
+774, 0x52ec4ed10de1eb2d
+775, 0xb90f288b9616f237
+776, 0x5bd43cd49617b2e2
+777, 0x1a53e21d25230596
+778, 0x36ccd15207a21cd6
+779, 0xc8263d780618fd3c
+780, 0x6eb520598c6ce1cb
+781, 0x493c99a3b341564f
+782, 0xab999e9c5aa8764f
+783, 0xab2fa4ceaba84b
+784, 0xbbd2f17e5cb2331b
+785, 0xc8b4d377c0cc4e81
+786, 0x31f71a6e165c4b1e
+787, 0xd1011e55fb3addaa
+788, 0x5f7ec34728dfa59
+789, 0x2aef59e60a84eb0f
+790, 0x5dde6f09aec9ad5f
+791, 0x968c6cdbc0ef0438
+792, 0x1957133afa15b13a
+793, 0xbaf28f27573a64c2
+794, 0xc6f6ddd543ebf862
+795, 0xdd7534315ec9ae1e
+796, 0xd2b80cd2758dd3b
+797, 0xa38c3da00cc81538
+798, 0x15c95b82d3f9b0f9
+799, 0x6704930287ce2571
+800, 0x9c40cc2f6f4ecb0c
+801, 0xc8de91f50b22e94e
+802, 0x39272e8fddbfdf0a
+803, 0x879e0aa810a117d
+804, 0xa312fff4e9e5f3bd
+805, 0x10dd747f2835dfec
+806, 0xeb8466db7171cdae
+807, 0xaa808d87b9ad040a
+808, 0xab4d2229a329243a
+809, 0x7c622f70d46f789c
+810, 0x5d41cef5965b2a8e
+811, 0xce97ec4702410d99
+812, 0x5beba2812c91211b
+813, 0xf134b46c93a3fec7
+814, 0x76401d5630127226
+815, 0xc55fc9d9eacd4ec1
+816, 0xaec8cefaa12f813f
+817, 0x2f845dcfd7b00722
+818, 0x3380ab4c20885921
+819, 0xdb68ad2597691b74
+820, 0x8a7e4951455f563f
+821, 0x2372d007ed761c53
+822, 0xcab691907714c4f1
+823, 0x16bc31d6f3abec1a
+824, 0x7dff639fbcf1824
+825, 0x6666985fbcff543d
+826, 0xb618948e3d8e6d0c
+827, 0x77b87837c794e068
+828, 0xcd48288d54fcb5a8
+829, 0x47a773ed6ae30dc3
+830, 0xba85ae44e203c942
+831, 0xa7a7b21791a25b2d
+832, 0x4029dd92e63f19e0
+833, 0xc2ad66ab85e7d5aa
+834, 0xa0f237c96fdab0db
+835, 0xffefb0ab1ca18ed
+836, 0x90cb4500785fd7d5
+837, 0xa7dd3120f4876435
+838, 0x53f7872624694300
+839, 0xea111326ff0040d9
+840, 0x5f83cb4cce40c83b
+841, 0x918e04936c3b504d
+842, 0x87a8db4c0e15e87c
+843, 0x7cff39da6a0dedd0
+844, 0x36f7de2037f85381
+845, 0xd1d8d94022a1e9a7
+846, 0x2c9930127dc33ec9
+847, 0x6cb4719dcd0101c6
+848, 0xc01868cde76935f7
+849, 0x6b86f2ec1ab50143
+850, 0x68af607d8d94ae61
+851, 0xe216c5b95feedf34
+852, 0x4b866bd91efe2e4b
+853, 0x4bff79df08f92c99
+854, 0x6ff664ea806acfd1
+855, 0x7fce0b3f9ece39bc
+856, 0x29bc90b59cb3db97
+857, 0x833c4b419198607d
+858, 0xf3573e36ca4d4768
+859, 0x50d71c0a3c2a3fa8
+860, 0xd754591aea2017e7
+861, 0x3f9126f1ee1ebf3
+862, 0xe775d7f4b1e43de8
+863, 0xe93d51628c263060
+864, 0x83e77f6fb32d6d82
+865, 0x43dd7eef823408e4
+866, 0x1c843c2c90180662
+867, 0xe924dafb9a16066b
+868, 0x6af3ee96e7b7fbd9
+869, 0x94d5c4f37befcd1f
+870, 0x40ffb04bedef4236
+871, 0x71c17bbc20e553e
+872, 0x101f7a0a6208729f
+873, 0x5ca34570cf923548
+874, 0x8e3139db2e96e814
+875, 0x3ab96d96263d048d
+876, 0x97f3c0bbc6755c3c
+877, 0x31fc72daedaef3dc
+878, 0x71f8d7855d10789b
+879, 0xce6dc97b4662333b
+880, 0xfddc2aabd342bc61
+881, 0xefbd4007ff8c7d2e
+882, 0xf72cd6c689ef8758
+883, 0x932c8b0c0e755137
+884, 0x94cc4dedd58ff69
+885, 0xde4dfd6890535979
+886, 0xdb00dcd2dcb4a50a
+887, 0xb0466240b4548107
+888, 0x9cb9264c7b90d1a3
+889, 0x357e378e9be5766b
+890, 0x6e0316ef03367bbf
+891, 0x201ea18839544ca
+892, 0x803ff3406be5f338
+893, 0xf9d5e82fd4144bb2
+894, 0x1b6b88ca701e9f47
+895, 0xd1fe5ab8e1f89cc0
+896, 0x14171fe176c4bece
+897, 0x887948bdef78beaa
+898, 0x80449ddc3eb9b977
+899, 0x5f4e1f900fb4bcf3
+900, 0xbe30f8701909f8e2
+901, 0xd1f2a2fb5503306d
+902, 0x6b1c77238dc23803
+903, 0x102156a6c9860f66
+904, 0x4cd446e099edf4c1
+905, 0xc79ac6cbc911f33b
+906, 0x3ee096ffe3384f1c
+907, 0xb58f83b18a306dc7
+908, 0x9f76582141de56b2
+909, 0x9ddfa85e02c13866
+910, 0x4d9a19d4ce90a543
+911, 0xbf81ab39fd17d376
+912, 0x5327e5054c6a74f1
+913, 0xd5062dd31db1a9b7
+914, 0x645853735527edc
+915, 0x485393967f91af08
+916, 0xeff9667dcf77ca68
+917, 0xd012313f5fbec464
+918, 0xbeae35bdfae55144
+919, 0x302c41ebac8444a0
+920, 0x9ccdb6c2fe58fba8
+921, 0x567753af68ed23f8
+922, 0xff90f790e43efec3
+923, 0x970cc756fb799696
+924, 0xe59239d1c44915
+925, 0x4d2d189fb3941f05
+926, 0x96f23085db165a9c
+927, 0xa1202dec7a37b1a5
+928, 0xc0c1ee74bcd7dc1a
+929, 0x9edcf2048b30333a
+930, 0xd848588ba7e865fb
+931, 0x8d9f0897317cab40
+932, 0x67b96f15e25924fb
+933, 0xefc8d8536619ee42
+934, 0xf3f621d22bdde0c2
+935, 0x68610a0de862ae32
+936, 0xa22ca5142de24cbd
+937, 0x8815452f4e6b4801
+938, 0x4e9c1b607b2750e5
+939, 0x19b3c09ba6fc9b25
+940, 0x9b2543c8836780ac
+941, 0xe702b8f950e56431
+942, 0xb357cc329cac3917
+943, 0x387bf86a17a31e08
+944, 0x9940b983d331b163
+945, 0xf5d89d7fe9095e18
+946, 0x4362682329e5c4d1
+947, 0xd2132573f6ae7b42
+948, 0xc0a5849e23a61606
+949, 0xdadbddf47265bc02
+950, 0x1b96f00339a705f7
+951, 0x94e6642329288913
+952, 0x825ab3f10e6d330b
+953, 0x1a1c31ac9d883ea0
+954, 0xb49076b7155c6f47
+955, 0x920cf3085dfe3ccb
+956, 0x9743407c9f28e825
+957, 0x6ce8a28622402719
+958, 0xce2fe67e06baf8a6
+959, 0x3a16b34784ecf5e6
+960, 0x140467cc1d162a0c
+961, 0x32d4772692ab625
+962, 0xa4f4b28562f43336
+963, 0x885b4335457bd84a
+964, 0x499d3ed26c87ad8a
+965, 0xc7328bcedb9a545e
+966, 0xc6dd76a6cbf5d2b2
+967, 0xba9c22be404ee1aa
+968, 0x70e6aee45f23521d
+969, 0x61e03a798593c177
+970, 0x171671f809c68213
+971, 0x28d54872fc1d914c
+972, 0x43c2fcd9bd098b53
+973, 0x172ad4c4a98b9d37
+974, 0x330860c9460f2516
+975, 0x49547f472df984f4
+976, 0x873b2436d3f0e114
+977, 0x6f99accf4ea050b6
+978, 0x5968ac874ed51613
+979, 0x4939d70d29a3c611
+980, 0x11f381ed28738d3d
+981, 0xa97430d36ab3a869
+982, 0xe6fa880801129e22
+983, 0xf84decbd8f48c913
+984, 0x4425c0ed1e9a82a5
+985, 0x7a1f9485e9929d5a
+986, 0xc7c51f155dfce1c6
+987, 0x9619a39501d74f2b
+988, 0x7c7035955dbf4c1b
+989, 0xc61ee569cf57c2c9
+990, 0x3eaf7c5b0df734e1
+991, 0xe71cb4064d1ede05
+992, 0x356e3cec80e418b2
+993, 0xca04306243a15be6
+994, 0x941cf3881fa18896
+995, 0x30dbb0e819d644e0
+996, 0xaae22c0bef02859a
+997, 0x7bd30917bbaa8a94
+998, 0x2672547bc8d7d329
+999, 0x4955c92aaa231578
diff --git a/venv/lib/python3.12/site-packages/numpy/random/tests/data/pcg64dxsm-testset-2.csv b/venv/lib/python3.12/site-packages/numpy/random/tests/data/pcg64dxsm-testset-2.csv
new file mode 100644
index 00000000..878c5ea7
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/random/tests/data/pcg64dxsm-testset-2.csv
@@ -0,0 +1,1001 @@
+seed, 0x0
+0, 0xd97e4a147f788a70
+1, 0x8dfa7bce56e3a253
+2, 0x13556ed9f53d3c10
+3, 0x55dbf1c241341e98
+4, 0xa2cd98f722eb0e0a
+5, 0x83dfc407203ade8
+6, 0xeaa083df518f030d
+7, 0x44968c87e432852b
+8, 0x573107b9cb8d9ecc
+9, 0x9eedd1da50b9daca
+10, 0xb33a6735ca451e3c
+11, 0x72830d2b39677262
+12, 0x9da8c512fd0207e8
+13, 0x1fc5c91954a2672b
+14, 0xd33479437116e08
+15, 0x9ccdd9390cee46f3
+16, 0x1fd39bb01acd9e76
+17, 0xedc1869a42ff7fe5
+18, 0xbd68ca0b42a6e7e9
+19, 0x620b67df09621b1f
+20, 0xfa11d51bd6950221
+21, 0xc8c45b36e7d28d08
+22, 0xe9c91272fbaad777
+23, 0x2dc87a143f220e90
+24, 0x6376a7c82361f49d
+25, 0x552c5e434232fe75
+26, 0x468f7f872ac195bc
+27, 0x32bed6858125cf89
+28, 0xe4f06111494d09d3
+29, 0xa5c166ffea248b80
+30, 0x4e26605b97064a3f
+31, 0xceafd9f6fc5569d
+32, 0xb772f2f9eed9e106
+33, 0x672c65e6a93534e2
+34, 0xcdc5e1a28d1bd6a0
+35, 0x1ed9c96daeebd3e3
+36, 0x4d189dcfc0c93c3f
+37, 0x50df5a95c62f4b43
+38, 0xcccf4949fa65bbb8
+39, 0x19b8073d53cdc984
+40, 0x6fb40bba35483703
+41, 0xb02de4aef86b515a
+42, 0x4d90c63655350310
+43, 0xea44e4089825b16c
+44, 0x8d676958b1f9da2b
+45, 0x6d313940917ae195
+46, 0x1b1d35a4c1dd19f4
+47, 0x117720f8397337ef
+48, 0xcc073cf3ac11eeaa
+49, 0x8331ec58a9ff8acb
+50, 0xf3dc2a308b6b866f
+51, 0x7eba1202663382b6
+52, 0x8269839debeb4e5a
+53, 0x87fd3dc0f9181a8e
+54, 0xabe62ddd3c925f03
+55, 0x7f56f146944fe8d4
+56, 0xc535972150852068
+57, 0x60b252d453bd3a68
+58, 0x4251f0134634490a
+59, 0x338950da210dfeb2
+60, 0xcadfe932971c9471
+61, 0xfb7049457fab470e
+62, 0x9bfb8145a4459dff
+63, 0x4a89dda3898f9d8a
+64, 0x88cc560151483929
+65, 0x277dc820f4b6796e
+66, 0x3524bd07ea0afb88
+67, 0x92eb6ffb2bf14311
+68, 0xf6559be0783f3fe9
+69, 0xf0844f9af54af00d
+70, 0xdd5e0b59adcef8a
+71, 0x4ff7e4f2ab18554c
+72, 0x3fa22c8a02634587
+73, 0x1db8e1a9442fe300
+74, 0x40cf15953ad3d3e7
+75, 0x92af15fe1a9f6f0a
+76, 0xab4a0e466fb0cfd
+77, 0x944f1555a06cca82
+78, 0x10cf48412f1f6066
+79, 0x7f51f9a455f9e8e1
+80, 0x47ee93530f024c7e
+81, 0x36cf2f0413e0f6f2
+82, 0xa315e23731969407
+83, 0xd8e2796327cf5f87
+84, 0xa86072696a555c34
+85, 0xee3f0b8804feaab7
+86, 0x41e80dc858f8360b
+87, 0x31ec2e9b78f5b29
+88, 0xd397fb9b8561344c
+89, 0x28081e724e649b74
+90, 0x5c135fc3fc672348
+91, 0x9a276ca70ce9caa0
+92, 0x9216da059229050a
+93, 0xcf7d375ed68007b0
+94, 0xa68ad1963724a770
+95, 0xd4350de8d3b6787c
+96, 0xee7d2c2cc275b6d2
+97, 0x71645ec738749735
+98, 0x45abdf8c68d33dbb
+99, 0xe71cadb692c705ea
+100, 0x60af6f061fd90622
+101, 0x1eabe2072632c99d
+102, 0x947dda995a402cb6
+103, 0xbb19f49a3454f3b
+104, 0xe6e43e907407758c
+105, 0xfe2b67016bd6873a
+106, 0x7fdb4dd8ab30a722
+107, 0x39d3265b0ff1a45b
+108, 0xed24c0e4fce8d0c2
+109, 0xf6e074f86faf669d
+110, 0x9142040df8dc2a79
+111, 0x9682ab16bc939a9c
+112, 0x6a4e80c378d971c8
+113, 0x31309c2c7fc2d3d6
+114, 0xb7237ec682993339
+115, 0x6a30c06bb83dccd9
+116, 0x21c8e9b6d8e7c382
+117, 0x258a24ae6f086a19
+118, 0xb76edb5be7df5c35
+119, 0x3c11d7d5c16e7175
+120, 0xbdfc34c31eff66e1
+121, 0x8af66e44be8bf3a2
+122, 0x3053292e193dec28
+123, 0xd0cc44545b454995
+124, 0x408ac01a9289d56
+125, 0x4e02d34318ec2e85
+126, 0x9413ff3777c6eb6b
+127, 0xa3a301f8e37eb3df
+128, 0x14e6306bd8d8f9f9
+129, 0xd3ea06ce16c4a653
+130, 0x170abe5429122982
+131, 0x7f9e6fddc6cacb85
+132, 0xa41b93e10a10a4c8
+133, 0x239216f9d5b6d0b5
+134, 0x985fcb6cb4190d98
+135, 0xb45e3e7c68f480c6
+136, 0xc1b2fc2e0446211c
+137, 0x4596adb28858c498
+138, 0x2dd706f3458ddc75
+139, 0x29c988c86f75464
+140, 0xac33a65aa679a60
+141, 0xa28fef762d39d938
+142, 0x541e6fa48647f53
+143, 0x27838d56b2649735
+144, 0x8e143d318a796212
+145, 0xaea6097745f586b8
+146, 0x636143330f8ee2e6
+147, 0xc2d05fd8b945b172
+148, 0x6e355f9eb4353055
+149, 0xeb64ca42e8bf282e
+150, 0xe8202dfd9da0fe5
+151, 0x7305689c9d790cba
+152, 0xf122f8b1bef32970
+153, 0x9562887e38c32ba5
+154, 0xf9cd9be121b738d
+155, 0x6238e0c398307913
+156, 0x5f2e79bb07c30f47
+157, 0x8ce8e45c465006e
+158, 0x39281fe1e99e2441
+159, 0xafb10c2ca2874fea
+160, 0x6e52f91633f83cf
+161, 0x8ff12c1ac73c4494
+162, 0xe48608a09365af59
+163, 0xefd9bbc7e76e6a33
+164, 0xbe16a39d5c38ec92
+165, 0x6a6ffbcaf5a2330f
+166, 0xdd5d6ac7d998d43d
+167, 0x207bf978226d4f11
+168, 0xf8eec56bd2a0f62e
+169, 0xa5bccf05dce0d975
+170, 0x93cf3ec1afe457a6
+171, 0x38651466d201f736
+172, 0x3ad21473985c9184
+173, 0xc6407a3bd38c92a6
+174, 0xb1ec42c7afa90a25
+175, 0xbdeca984df8b7dd3
+176, 0xb6926b1d00aa6c55
+177, 0x86141d0022352d49
+178, 0x169316256135ee09
+179, 0xffb1c7767af02a5c
+180, 0x502af38ad19f5c91
+181, 0xfbf6cbc080086658
+182, 0x33cf9b219edae501
+183, 0x46e69bebd77b8862
+184, 0xf11e0cc91125d041
+185, 0xb4cd1649f85e078f
+186, 0xb49be408db4e952
+187, 0xb0b8db46140cce3c
+188, 0xba647f2174012be7
+189, 0x4f0a09e406970ac9
+190, 0xf868c7aec9890a5c
+191, 0xde4c8fa7498ea090
+192, 0x872ceb197978c1d4
+193, 0x1eb5cd9c3269b258
+194, 0x3ea189f91724f014
+195, 0x41379656f7746f2c
+196, 0x7bd18493aca60e51
+197, 0x5380c23b0cbbf15e
+198, 0x920b72835f88246b
+199, 0x24d7f734a4548b8e
+200, 0x9944edb57e5aa145
+201, 0x4628e136ebb8afe1
+202, 0xb4ee6a776356e2a7
+203, 0x481cbe9744ccf7d7
+204, 0x7e8d67e8b0b995d9
+205, 0xeeacde100af7b47e
+206, 0x103da08f2487dab7
+207, 0x6b9890a91d831459
+208, 0xd0c5beae37b572c7
+209, 0xfdccc371ee73fcc
+210, 0x65438f0a367a2003
+211, 0x5d23b2c818a7e943
+212, 0x9a8ed45ac04b58b3
+213, 0xdaf3c3f1695dce10
+214, 0x5960eec706fa2bc0
+215, 0x98ca652facb80d40
+216, 0x72970ae5e2194143
+217, 0x18c6374d878c5c94
+218, 0x20fa51f997381900
+219, 0x3af253dba26d6e1d
+220, 0x1b23d65db15c7f78
+221, 0x9f53ae976259b0e3
+222, 0x9a6addb28dc92d49
+223, 0x1e085c4accd0a7d7
+224, 0xe9d3f4cc9bad6ce5
+225, 0xe018fad78b5b1059
+226, 0x5ef7682232b4b95
+227, 0xb2242aa649f5de80
+228, 0x8f3e6d8dd99b9e4e
+229, 0xb9be6cc22949d62a
+230, 0xecbdc7beaa5ff1fe
+231, 0xd388db43a855bdf0
+232, 0xd71ee3238852568d
+233, 0x85ab3056304c04b5
+234, 0x2ed7ae7ad3cfc3cb
+235, 0x781d1b03d40b6c48
+236, 0x7d3c740886657e6d
+237, 0x982cfa6828daa6b0
+238, 0x278579599c529464
+239, 0x773adecfae9f0e08
+240, 0x63a243ea4b85c5d7
+241, 0x59940074fc3709e1
+242, 0xc914a2eed58a6363
+243, 0x2602b04274dd724c
+244, 0xdf636eb7636c2c42
+245, 0x891a334d0d26c547
+246, 0xde8cd586d499e22d
+247, 0x3ea1aa4d9b7035b6
+248, 0xd085cff6f9501523
+249, 0xe82a872f374959e
+250, 0x55cb495bbd42cc53
+251, 0x5f42b3226e56ca97
+252, 0xea463f6f203493a3
+253, 0xeef3718e57731737
+254, 0x1bd4f9d62b7f9f3c
+255, 0x19284f5e74817511
+256, 0xaf6e842c7450ca87
+257, 0x1d27d2b08a6b3600
+258, 0xfb4b912b396a52e3
+259, 0x30804d4c5c710121
+260, 0x4907e82564e36338
+261, 0x6441cf3b2900ddb7
+262, 0xd76de6f51988dc66
+263, 0x4f298ef96fd5e6d2
+264, 0x65432960c009f83d
+265, 0x65ebed07e1d2e3df
+266, 0xf83ee8078febca20
+267, 0x7bb18e9d74fc5b29
+268, 0x597b5fbc2261d91
+269, 0xea4f8ed0732b15b2
+270, 0xba2267f74f458268
+271, 0x3f304acabd746bbb
+272, 0x7bd187af85659a82
+273, 0x88e20dbdb7a08ea3
+274, 0x2a2dc948c772fcb4
+275, 0x87784fec2993c867
+276, 0x89163933cd362d4e
+277, 0xfd7b24f04302f957
+278, 0x9bdd544405dfb153
+279, 0xddee0fac58ffc611
+280, 0xa8e8993417e71ec1
+281, 0x55e0ab46ff7757af
+282, 0x53e7645f08d3d7df
+283, 0xbf78e563bc656ba2
+284, 0x1d162253b45ee2de
+285, 0x15e2bfefedf29eb4
+286, 0x4e2a4584aa394702
+287, 0xa89fb12b01525897
+288, 0x825bd98f0544e4df
+289, 0xfc6c50da6750700
+290, 0xc24aaabde7d28423
+291, 0x79d6f4660fcb19e5
+292, 0xee7d4fb40c8d659f
+293, 0x70bc281b462e811d
+294, 0x23ed4dc9636519a7
+295, 0xcb7c3f5a5711b935
+296, 0xe73090e0508c5d9d
+297, 0xb25a331f375952a6
+298, 0xa64c86e0c04740f6
+299, 0xb8f3ffc8d56ac124
+300, 0x2479266fc5ee6b15
+301, 0x8d5792d27f5ffbcb
+302, 0xb064298be946cd52
+303, 0xf0934a98912ffe26
+304, 0xbe805682c6634d98
+305, 0xe0e6e2c010012b4f
+306, 0x58c47d475f75976
+307, 0x358c9a6e646b2b4a
+308, 0x7e7c4ffca5b17ba7
+309, 0x43585c8c9a24a04c
+310, 0x5154ddbcd68d5c2c
+311, 0x4a2b062d3742a5e
+312, 0xca5691191da2b946
+313, 0x696a542109457466
+314, 0x9eb5d658a5022ba5
+315, 0x8158cf6b599ab8dc
+316, 0x1b95391eaa4af4a6
+317, 0x9953e79bd0fc3107
+318, 0x8639690086748123
+319, 0x2d35781c287c6842
+320, 0x393ef0001cd7bc8f
+321, 0xe3a61be8c5f2c22a
+322, 0x5e4ff21b847cc29b
+323, 0x4c9c9389a370eb84
+324, 0xd43a25a8fc3635fa
+325, 0xf6790e4a85385508
+326, 0x37edf0c81cb95e1d
+327, 0x52db00d6e6e79af8
+328, 0x3b202bceeb7f096
+329, 0x2a164a1c776136bb
+330, 0x73e03ee3fd80fd1b
+331, 0xd2c58c0746b8d858
+332, 0x2ed2cb0038153d22
+333, 0x98996d0fc8ceeacc
+334, 0xa4ed0589936b37f
+335, 0x5f61cf41a6d2c172
+336, 0xa6d4afb538c110d7
+337, 0xe85834541baadf1a
+338, 0x4c8967107fd49212
+339, 0x49bafb762ab1a8c1
+340, 0x45d540e2a834bf17
+341, 0x1c0ec8b4ed671dac
+342, 0x3d503ce2c83fe883
+343, 0x437bfffd95f42022
+344, 0xc82d1e3d5c2bc8d2
+345, 0x7a0a9cbfcb0d3f24
+346, 0xc0a4f00251b7a3be
+347, 0xb5be24e74bb6a1c6
+348, 0xa3104b94b57545b1
+349, 0x86de7d0c4b97b361
+350, 0x879c1483f26538a6
+351, 0xd74c87557f6accfb
+352, 0x2f9be40dbf0fe8a1
+353, 0x445a93398f608d89
+354, 0x7b3cb8a7211d7fdc
+355, 0xe86cc51290d031e7
+356, 0x33ef3594052ad79f
+357, 0xc61911d241dbb590
+358, 0x37cccb0c0e3de461
+359, 0xb75259124080b48b
+360, 0xd81e8961beb4abe5
+361, 0xf4542deb84a754e
+362, 0x6ea036d00385f02e
+363, 0xa7b60b0ac3b88681
+364, 0x108a6c36ca30baf5
+365, 0x4a2adc5bbfe2bf07
+366, 0x4079501f892a5342
+367, 0x55e113963c5448f0
+368, 0x8019ff4903b37242
+369, 0x109c6dcdb7ec6618
+370, 0x1239ac50944da450
+371, 0xe1399c7f94c651c1
+372, 0x5a6bbbae388d365a
+373, 0x4d72be57b8810929
+374, 0x3f067df24384e1fb
+375, 0x4f8b9e0f7f6c7be
+376, 0x202492c342a3b08
+377, 0x250753192af93a3
+378, 0xfba1159d9de2cb8e
+379, 0xba964497ab05505c
+380, 0x1329ec5d8a709dca
+381, 0x32927cacb6cd22bb
+382, 0x6b4d7db904187d56
+383, 0xe76adccf8e841e02
+384, 0x8c4bf4b6a788202
+385, 0x3013a3b409831651
+386, 0x7427d125c475412f
+387, 0x84dcc4bb2bf43202
+388, 0x117526f1101372a5
+389, 0xfe95d64b8984bd72
+390, 0x524e129934cc55c1
+391, 0xc3db4b0418c36d30
+392, 0xe1cb2047e9c19f7a
+393, 0xea43d6c8d8982795
+394, 0xe80ac8a37df89ed
+395, 0xfecc2104329ed306
+396, 0xa5c38aac9c1d51ea
+397, 0x3abe5d1c01e4fe17
+398, 0x717a805d97fcc7ac
+399, 0x94441f8207a1fb78
+400, 0x22d7869c5f002607
+401, 0x349e899f28c3a1b9
+402, 0x5639950cdea92b75
+403, 0x7e08450497c375b
+404, 0x94bf898b475d211d
+405, 0x75c761a402375104
+406, 0x1930920ec9d2a1e7
+407, 0xb774ba1bc6f6e4e2
+408, 0xf715602412e5d900
+409, 0x87bb995f4a13f0ba
+410, 0xa3c787868dfa9c8d
+411, 0xa17fd42a5a4f0987
+412, 0x4a9f7d435242b86
+413, 0x240364aff88f8aef
+414, 0xe7cd4cf4bf39f144
+415, 0xd030f313ca4c2692
+416, 0xc46696f4e03ec1e9
+417, 0x22c60f1ec21060b3
+418, 0x16c88058fd68986f
+419, 0x69ca448e8e6bde3f
+420, 0x3466c2cdec218abd
+421, 0x837ac4d05e6b117d
+422, 0x911210e154690191
+423, 0x9ece851d6fa358b7
+424, 0x42f79cb0c45e7897
+425, 0xbf7583babd7c499b
+426, 0x2059fe8031c6e0b9
+427, 0xabbec8fc00f7e51d
+428, 0x88809d86a3a256e1
+429, 0xd36056df829fdcb5
+430, 0x515632b6cb914c64
+431, 0xba76d06c2558874
+432, 0x632c54ca4214d253
+433, 0xadec487adf2cb215
+434, 0x521e663e1940513d
+435, 0xb1b638b548806694
+436, 0xbe2d5bfbe57d2c72
+437, 0x8b89e7719db02f7
+438, 0x90ba5281c1d56e63
+439, 0x899e1b92fceea102
+440, 0xf90d918e15182fa6
+441, 0x94a489ce96c948c4
+442, 0xad34db453517fcd4
+443, 0xc5264eb2de15930f
+444, 0x101b4e6603a21cee
+445, 0xef9b6258d6e85fff
+446, 0x6075c7d6c048bd7a
+447, 0x6f03232c64e438aa
+448, 0x18c983d7105ee469
+449, 0x3ffc23f5c1375879
+450, 0xbc1b4a00afb1f9f
+451, 0x5afa6b2bb8c6b46e
+452, 0xe7fce4af2f2c152a
+453, 0x5b00ab5c4b3982c7
+454, 0x2d4b0c9c0eb4bd0c
+455, 0x61d926270642f1f2
+456, 0x7219c485c23a2377
+457, 0x7e471c752fecd895
+458, 0x23c4d30a4d17ba1f
+459, 0x65cb277fe565ca22
+460, 0xcbb56ed9c701363b
+461, 0xfd04ab3a6eba8282
+462, 0x19c9e5c8bab38500
+463, 0xea4c15227676b65b
+464, 0x20f3412606c8da6f
+465, 0xb06782d3bf61a239
+466, 0xf96e02d5276a9a31
+467, 0x835d256b42aa52a6
+468, 0x25b09151747f39c1
+469, 0x64507386e1103eda
+470, 0x51cbc05716ef88e4
+471, 0x998cd9b7989e81cc
+472, 0x9d7115416bec28d1
+473, 0xc992ca39de97906b
+474, 0xd571e6f7ca598214
+475, 0xafc7fb6ccd9abbf8
+476, 0x88ef456febff7bf4
+477, 0xdbe87ccc55b157d2
+478, 0xaab95e405f8a4f6d
+479, 0xad586a385e74af4f
+480, 0x23cd15225c8485aa
+481, 0x370940bf47900ac7
+482, 0xefd6afda1a4b0ead
+483, 0x9cb1a4c90993dd7a
+484, 0xff7893e8b2f70b11
+485, 0xb09e1807c0638e8e
+486, 0xb10915dcb4978f74
+487, 0x88212ab0051a85eb
+488, 0x7af41b76e1ec793f
+489, 0x2e5c486406d3fefd
+490, 0xebe54eff67f513cc
+491, 0xab6c90d0876a79b8
+492, 0x224df82f93fe9089
+493, 0xc51c1ce053dc9cd2
+494, 0x5ef35a4d8a633ee7
+495, 0x4aca033459c2585f
+496, 0xd066932c6eefb23d
+497, 0x5309768aab9a7591
+498, 0xa2a3e33823df37f9
+499, 0xcec77ff6a359ee9
+500, 0x784dc62d999d3483
+501, 0x84e789fb8acc985d
+502, 0xd590237e86aa60f
+503, 0x737e2ffe1c8ad600
+504, 0xc019c3a39a99eab8
+505, 0x6a39e9836964c516
+506, 0xe0fe43129535d9da
+507, 0xdfc5f603d639d4de
+508, 0x7b9a7d048a9c03b6
+509, 0xbb5aa520faa27fdd
+510, 0x2a09b4200f398fa2
+511, 0x38cc88107904064e
+512, 0xa9a90d0b2d92bb25
+513, 0x9419762f87e987e3
+514, 0x1a52c525153dedcd
+515, 0xc26d9973dd65ae99
+516, 0x8e89bd9d0dc6e6a1
+517, 0x2f30868dc01bfb53
+518, 0x20f09d99b46501c4
+519, 0x78b468a563b8f1e9
+520, 0xcccf34b0b6c380c7
+521, 0xf554e7dc815297e6
+522, 0x332a585cfb4a50ef
+523, 0xa9fb64a2b6da41d7
+524, 0xdcd2a5a337391ce0
+525, 0x8a9bd3e324c6463d
+526, 0x9f4487d725503bdd
+527, 0xf72282d82f1d0ff
+528, 0x308f4160abb72d42
+529, 0x648de1db3a601b08
+530, 0x36cab5192e7ebd39
+531, 0x7975fbe4ab6a1c66
+532, 0xd515b4d72243864e
+533, 0x43a568f8b915e895
+534, 0x15fa9f2057bdb91d
+535, 0x7a43858ef7a222dc
+536, 0x17b4a9175ac074fe
+537, 0xa932c833b8d0f8f8
+538, 0x1d2db93a9a587678
+539, 0x98abd1d146124d27
+540, 0xf0ab0431671740aa
+541, 0xa9d182467540ad33
+542, 0x41c8a6cfc331b7fc
+543, 0xa52c6bd0fcd1d228
+544, 0x2773c29a34dc6fa3
+545, 0x3098230746fc1f37
+546, 0xd63311bb4f23fabe
+547, 0x6712bf530cd2faec
+548, 0x342e8f342e42c4dd
+549, 0xfbd83331851cdcad
+550, 0xe903be1361bbc34d
+551, 0xd94372e5077e3ef9
+552, 0x95aaa234f194bd8
+553, 0x20c0c8fb11e27538
+554, 0xfaf47dc90462b30b
+555, 0x8ddc6d144147682a
+556, 0xf626833fd926af55
+557, 0x5df93c34290d1793
+558, 0xb06a903e6e9fca5e
+559, 0x10c792dc851d77ca
+560, 0xd9b1b817b18e56cb
+561, 0x3a81730c408eb408
+562, 0x65052c04a8d4b63c
+563, 0x3328546598e33742
+564, 0xeca44a13f62d156d
+565, 0x69f83d1d86b20170
+566, 0x937764200412027d
+567, 0xc57eb1b58df0f191
+568, 0xa1c7d67dce81bc41
+569, 0x8e709c59a6a579ce
+570, 0x776a2f5155d46c70
+571, 0xd92906fbbc373aa5
+572, 0xe97ad478a2a98bf6
+573, 0xc296c8819ac815f
+574, 0x613ede67ba70e93e
+575, 0xe145222498f99cde
+576, 0xafcdfa7a3c1cf9bf
+577, 0x1c89252176db670d
+578, 0xad245eda5c0865ff
+579, 0x249463d3053eb917
+580, 0xc9be16d337517c0b
+581, 0xefcc82bf67b8f731
+582, 0x1e01577d029e0d00
+583, 0xad9c24b2a4f3d418
+584, 0xed2cceb510db4d0f
+585, 0xbddadcdb92400c70
+586, 0x67d6b0476ef82186
+587, 0xbc7662ff7bf19f73
+588, 0x9d94452a729e6e92
+589, 0x6b278d8594f55428
+590, 0x6c4b31cceb1b2109
+591, 0xccc6c3a726701e9
+592, 0x6bc28ece07df8925
+593, 0xc0422b7bf150ccc4
+594, 0xab7158f044e73479
+595, 0xdf3347546d9ed83f
+596, 0x3b3235a02c70dff4
+597, 0x2551c49c14ea8d77
+598, 0xee2f7f5bb3cc228e
+599, 0x39b87bfe8c882d39
+600, 0x7dd420fad380b51c
+601, 0xffe64976af093f96
+602, 0x4a4f48dc6e7eaa5f
+603, 0x85f2514d32fdc8cc
+604, 0x1ab1215fd7f94801
+605, 0x4cd1200fc795b774
+606, 0xcf8af463a38942ee
+607, 0x319caa7ce3022721
+608, 0x8cd9798a76d1aea4
+609, 0x2bd3933ac7afd34e
+610, 0x85d4c323403cf811
+611, 0xd7b956d3064efa30
+612, 0x67a078dbf1f13068
+613, 0x665fa6c83e87c290
+614, 0x9333ac2416d2469b
+615, 0xdfb1fd21a0094977
+616, 0xa1962a6e2c25f8ff
+617, 0x1f3b10a7ed5287cf
+618, 0x70641efb3d362713
+619, 0xe527a2cf85d00918
+620, 0x9741e45d3f9890a3
+621, 0x6cb74b5d4d36db4b
+622, 0xf24734d622bd2209
+623, 0xadd6d94f78e9d378
+624, 0xc3bbdb59225cca7f
+625, 0x5ad36614275b30cd
+626, 0x495568dd74eea434
+627, 0xf35de47e0ffe1f2d
+628, 0xefa209dca719ab18
+629, 0x844ddcaeb5b99ae8
+630, 0x37449670a1dc7b19
+631, 0x5a4612c166f845c1
+632, 0xe70f7782f2087947
+633, 0x98d484deac365721
+634, 0x705302198cf52457
+635, 0x7135ae0f5b77df41
+636, 0x342ac6e44a9b6fc3
+637, 0x2713fd2a59af5826
+638, 0x6e1a3f90f84efa75
+639, 0x9fb3b4dd446ca040
+640, 0x530044ae91e6bd49
+641, 0xe984c4183974dc3e
+642, 0x40c1fa961997d066
+643, 0xb7868250d8c21559
+644, 0x8bc929fa085fd1de
+645, 0x7bdb63288dc8733e
+646, 0xac4faad24326a468
+647, 0x1c6e799833aea0b1
+648, 0xcc8a749e94f20f36
+649, 0x4e7abfd0443547c5
+650, 0xb661c73bb8caa358
+651, 0x4a800f5728ff2351
+652, 0x8c15e15189b9f7ed
+653, 0xab367846b811362c
+654, 0x4ba7508f0851ca2a
+655, 0xe9af891acbafc356
+656, 0xbdebe183989601f8
+657, 0x4c665ea496afc061
+658, 0x3ca1d14a5f2ed7c
+659, 0xfbdff10a1027dd21
+660, 0xdfd28f77c8cff968
+661, 0xc4fbaadf8a3e9c77
+662, 0xdac7e448b218c589
+663, 0xb26390b5befd19e2
+664, 0xd2ef14916c66dba9
+665, 0xfab600284b0ff86b
+666, 0xf04a1c229b58dabb
+667, 0xc21c45637e452476
+668, 0xd1435966f75e0791
+669, 0xc1f28522eda4a2d0
+670, 0x52332ae8f1222185
+671, 0x81c6c0790c0bf47e
+672, 0xfebd215e7d8ffb86
+673, 0x68c5dce55dbe962b
+674, 0x231d09cb0d2531d1
+675, 0x3218fba199dbbc6b
+676, 0x8f23c535f8ea0bf6
+677, 0x6c228963e1df8bd9
+678, 0x9843c7722ed153e3
+679, 0xd032d99e419bddec
+680, 0xe2dca88aa7814cab
+681, 0x4d53fb8c6a59cdc2
+682, 0x8fb3abc46157b68b
+683, 0xa3e733087e09b8e
+684, 0x6bdc1aee029d6b96
+685, 0x4089667a8906d65b
+686, 0x8f3026a52d39dd03
+687, 0x6d2e0ccb567bae84
+688, 0x74bad450199e464
+689, 0xf114fb68a8f300d5
+690, 0xc7a5cc7b374c7d10
+691, 0xf0e93da639b279d1
+692, 0xb9943841ad493166
+693, 0x77a69290455a3664
+694, 0x41530da2ebea054b
+695, 0xe8f9fab03ea24abf
+696, 0xaa931f0c9f55a57a
+697, 0xb4d68a75d56f97ae
+698, 0x3d58ff898b6ba297
+699, 0x49d81e08faf5a3f5
+700, 0xfc5207b9f3697f3b
+701, 0xa25911abb3cf19b7
+702, 0x6b8908eb67c3a41
+703, 0xd63ef402e2e3fa33
+704, 0x728e75d3f33b14c5
+705, 0x248cb1b8bc6f379a
+706, 0x3aa3d6d2b8c72996
+707, 0x49cc50bd2d3d2860
+708, 0xb4e1387647c72075
+709, 0x435a1630a4a81ed3
+710, 0xa5ea13005d2460cf
+711, 0xc7a613df37d159ec
+712, 0x95721ccc218b857e
+713, 0xd4b70d8c86b124d3
+714, 0x2b82bcc4b612d494
+715, 0xaf13062885276050
+716, 0xcbd8fcf571a33d9c
+717, 0x3f7f67ca1125fc15
+718, 0xddf4bb45aac81b4c
+719, 0x23606da62de9c040
+720, 0xa3a172375666b636
+721, 0x292f87387a6c6c3c
+722, 0xd1d10d00c5496fe1
+723, 0x86b0411ce8a25550
+724, 0x38e0487872e33976
+725, 0x363e49f88ddfd42c
+726, 0x45bdf1e9f6b66b0a
+727, 0x8a6fff3de394f9b5
+728, 0x8502158bb03f6209
+729, 0x22e24d16dba42907
+730, 0x3fe3ba427cc2b779
+731, 0x77144793f66b3d7e
+732, 0xcf8912ccb29b8af9
+733, 0xdc856caff2abd670
+734, 0xe6d3ae0b0d9d4c8b
+735, 0xb8f5d40e454c539f
+736, 0x79ca953114fbc6b7
+737, 0x478d6f4bbfa38837
+738, 0x9babae1a3ffdc340
+739, 0x40edd56802bae613
+740, 0x97a56c2dcccf0641
+741, 0xafc250257f027f8e
+742, 0x8da41ef1edf69125
+743, 0x6574b0280ff9d309
+744, 0x197c776151b8f820
+745, 0x6b03e077c9dac3b6
+746, 0x24a40ebbc5c341c5
+747, 0x50e585169a6a1c4b
+748, 0x37783a5a6a3e4e02
+749, 0xb3de81ee6fbad647
+750, 0xf4f292f57ca4591e
+751, 0x6214e9e7d44d30a
+752, 0x5920190c56d21c12
+753, 0x9ac163419b5e0c9b
+754, 0xfc2328761ae8ed93
+755, 0xc68f945b545508c6
+756, 0x687c49a17ce0a5e2
+757, 0x276d8f53d30d4ab4
+758, 0x8201804970343ce1
+759, 0x1b5d323cc2e7fb7e
+760, 0x6f351ef04fd904b
+761, 0x6c793a7d455d5198
+762, 0x46f5d108430ae91f
+763, 0xac16a15b2a0cf77f
+764, 0xa0d479d9e4122b9d
+765, 0x3afd94604307f19
+766, 0x2573ed6d39d38dbf
+767, 0xa58e14ba60b4294b
+768, 0xe69c1aed5840d156
+769, 0x4cf6fda7f04855c2
+770, 0x2fb65a56ef5f22da
+771, 0xf95819434d5dc220
+772, 0x29c65133623dafba
+773, 0x8e997bd018467523
+774, 0xfd08ba9d498461a7
+775, 0xdd52243bc78a5592
+776, 0x39c30108f6db88b3
+777, 0x38af8e1894f259b9
+778, 0x97eedf3b4ae5f6de
+779, 0x757825add80c5ece
+780, 0xf0fdd90ac14edb14
+781, 0xbbb19d4cc8cac6d4
+782, 0x9a82234edfae05e3
+783, 0x704401c61d1edf1c
+784, 0x8b0eb481fb3a1fb2
+785, 0xef6f36e7cc06c002
+786, 0x7a208b17e04b8cd7
+787, 0xf20e33d498838fe9
+788, 0xc2bdb22117058326
+789, 0x6ec31939eb4ca543
+790, 0x6f1654838f507a21
+791, 0xc65ab81a955d2b93
+792, 0x40b1420fdd9531b8
+793, 0xe31f221cab9f4f40
+794, 0x798cdd414c1deb7a
+795, 0x9c84e9c7d41cd983
+796, 0x63d6b1ae3b60b7fa
+797, 0xb42bfdd1a2f78ffa
+798, 0x37e431eaccaaa8e9
+799, 0x7508142a0f73eac9
+800, 0x91662a023df5893a
+801, 0x59782070e2fe3031
+802, 0xb2acd589a8ce7961
+803, 0xa224743fa877b292
+804, 0xaa5362aa27e6ed9e
+805, 0xa394a4e520c0c1c7
+806, 0xe49b16d2018ffb6f
+807, 0xb8074b9f2f1e762b
+808, 0xcf5f86143d5c23a7
+809, 0xfd838785db987087
+810, 0x31b1889df389aff8
+811, 0x30aaca876a4383b
+812, 0x1731bb71c4c38d4f
+813, 0x9a83a65395e05458
+814, 0x99cd0c8d67c8f4fc
+815, 0xfbd9fdc849b761a5
+816, 0x82c04834fc466889
+817, 0xdeef9d6e715e8c97
+818, 0x549c281c16da6078
+819, 0x2d70661254ad599d
+820, 0x57995793a72acac
+821, 0xf1727005116183ba
+822, 0xa22bb38945285de3
+823, 0x4f2d687fe45131ff
+824, 0x5666c87ddbbc981f
+825, 0xbcb4b2d4e7a517d0
+826, 0x5e794dd2e20b785d
+827, 0x449ad020149e093c
+828, 0x7704ee0412d106f5
+829, 0x83cbdf257b072ac1
+830, 0xae5c4fc9f638b0da
+831, 0x7b9e5a64e372ed47
+832, 0x7eddbbb22c2cdf57
+833, 0x3f19ebfa155b08e
+834, 0x91d991154dfd7177
+835, 0x611ae74b952d387f
+836, 0x3fdf7a335bda36ee
+837, 0xdf182433fc7a7c05
+838, 0x62c78598d1f8db0a
+839, 0xc3750c69d2c5c1f0
+840, 0xf1318024709efdee
+841, 0xaa3fd360d224dc29
+842, 0x62af53b2f307c19
+843, 0xdf527683c58120c2
+844, 0x3281deecc496f93d
+845, 0x4f704ad31527ef08
+846, 0x127a14a5e07cfdfc
+847, 0x90d0b1f549255c92
+848, 0xbc3406b212c5e1fc
+849, 0x4e89f39379dba91d
+850, 0x1290ef43c4998e6e
+851, 0xecfeb1a1cb1c6e1b
+852, 0x2067e90403003bf1
+853, 0x38ae04be30bdbeba
+854, 0x8a3537f298baedda
+855, 0xd07f3b825cdb2936
+856, 0xea020b5aebae8b45
+857, 0xfcd614ab031132b0
+858, 0x5fb682a4ff2268f5
+859, 0xd1c4662ce65596f4
+860, 0x7026b8270dd0b8dc
+861, 0x8101ec4b4beae45a
+862, 0xa0e9dc87940610a6
+863, 0x83ec33679d83165b
+864, 0x981847ca82e86d41
+865, 0xda84c188a304a0b7
+866, 0x3c37529c5a5bbbb8
+867, 0x34a8491ce3e19a5a
+868, 0xd36ad716a2fa6cb8
+869, 0xfd1d1d6a5189a15c
+870, 0x9716eb47851e8d8d
+871, 0x7dfb13ea3b15c5aa
+872, 0xbdf6e707f45113a5
+873, 0xb8118261b04bd097
+874, 0x6191f9895881bec6
+875, 0x7aac257ae11acf9b
+876, 0x35a491e1537ff120
+877, 0xe078943432efa71c
+878, 0xb3338485dd3dc2b9
+879, 0x456060975d2bb3b5
+880, 0xaddc4c451bdfc44c
+881, 0x18bfa7beacf96430
+882, 0x8802ebcaf0f67498
+883, 0xad922a5a825bd780
+884, 0x9fb4587d748f4efa
+885, 0xdb2a445136cd5e7
+886, 0xb98b3676ea8e96ac
+887, 0xb02d8d244d784878
+888, 0xa1a8442b18860abb
+889, 0x6a3029ba1361e5d1
+890, 0xf426d5fac161eb1
+891, 0xfa5ac2b87acecb23
+892, 0xaa659896e50535df
+893, 0xf40dd7a3d3c5c8ed
+894, 0x3f8367abecb705bc
+895, 0x2d60e7525873358f
+896, 0xc4a9d3948a0c3937
+897, 0x5ecc04fef6003909
+898, 0x7a865004918cba2
+899, 0x47ae110a678ec10b
+900, 0xa0f02f629d91aa67
+901, 0x4848b99e7fac9347
+902, 0xaa858346d63b80ac
+903, 0xeb5bf42ee161eeef
+904, 0x4d35d723d3c6ba37
+905, 0xdf22ca6ca93b64a7
+906, 0x9d198520f97b25b1
+907, 0x3068415350778efe
+908, 0xf3709f2e8793c2fe
+909, 0xd1517bac8dd9f16f
+910, 0xfb99bccaa15861dc
+911, 0xa9ad607d796a2521
+912, 0x55d3793d36bd22e4
+913, 0xf99270d891ff7401
+914, 0x401750a5c4aa8238
+915, 0xd84b3003e6f28309
+916, 0x8a23798b5fa7c98b
+917, 0xadd58bbc8f43e399
+918, 0xbd8c741ada62c6a8
+919, 0xbdc6937bc55b49fa
+920, 0x4aefa82201b8502
+921, 0x17adf29a717b303
+922, 0xa6ed2197be168f6c
+923, 0x1ba47543f4359a95
+924, 0xe34299949ac01ae9
+925, 0x711c76cffc9b62f3
+926, 0xbac259895508a4b7
+927, 0x3c8b3b3626b0d900
+928, 0x1a8d23fbe2ae71bf
+929, 0xca984fa3b5a5c3a1
+930, 0xb1986ab7521a9c93
+931, 0xd6b5b2c8d47a75b5
+932, 0xc7f1c4a88afb4957
+933, 0xdeb58033a3acd6cc
+934, 0xabe49ddfe1167e67
+935, 0x8d559c10205c06e3
+936, 0xea07a1a7de67a651
+937, 0xcbef60db15b6fef8
+938, 0xbfca142cff280e7
+939, 0x362693eba0732221
+940, 0x7463237e134db103
+941, 0x45574ddb5035e17a
+942, 0xfc65e0cb9b94a1aa
+943, 0x3154c55f1d86b36d
+944, 0x2d93a96dd6ab2d8b
+945, 0xbe3bc1d1f2542a25
+946, 0xdd4b541f7385bdaa
+947, 0x3b56b919d914e3f8
+948, 0x82fd51468a21895f
+949, 0x8988cf120731b916
+950, 0xa06a61db5fb93e32
+951, 0x6ed66c1b36f68623
+952, 0x875ae844d2f01c59
+953, 0x17ccd7ac912e5925
+954, 0x12fe2a66b8e40cb1
+955, 0xf843e5e3923ad791
+956, 0xa17560f2fd4ef48
+957, 0x27a2968191a8ee07
+958, 0xa9aab4d22ff44a3c
+959, 0x63cd0dcc3bb083ae
+960, 0x7a30b48c6160bf85
+961, 0x956160fb572503b3
+962, 0xc47f6b7546640257
+963, 0xaf4b625f7f49153
+964, 0x2f5c86a790e0c7e8
+965, 0xb52e0610ae07f0b8
+966, 0x38a589292c3d849e
+967, 0xc3e9ef655d30b4ef
+968, 0xb5695f765cda998a
+969, 0xde5d5e692a028e91
+970, 0x839476721555f72e
+971, 0x48b20679b17d9ebf
+972, 0xe3d4c6b2c26fb0df
+973, 0xce5a9834f0b4e71f
+974, 0x533abb253d5d420e
+975, 0x9eac5ad9aed34627
+976, 0xc0f2a01ab3c90dbb
+977, 0x6528eda93f6a066c
+978, 0xc16a1b625e467ade
+979, 0x1a4a320fb5e8b098
+980, 0x8819cccd8b4ab32f
+981, 0x42daa88531fd0bfd
+982, 0xcf732226409be17c
+983, 0xfddcdb25ccbf378c
+984, 0x9b15b603bf589fc1
+985, 0x2436066b95d366fe
+986, 0x8d42eff2e9cbda90
+987, 0x694b2fc8a4e8303c
+988, 0x8e207f98aaea3ccd
+989, 0x4730d7a620f822d9
+990, 0x468dc9ca30fe2fd4
+991, 0x74b36d8a1c0f031b
+992, 0x3c1aac1c488c1a94
+993, 0x19d0101042444585
+994, 0x8ec50c56d0c8adf4
+995, 0x721ec629e4d66394
+996, 0x3ca5ad93abeac4a4
+997, 0xaaebc76e71592623
+998, 0x969cc319e3ed6058
+999, 0xc0a277e3b2bfc3de
diff --git a/venv/lib/python3.12/site-packages/numpy/random/tests/data/philox-testset-1.csv b/venv/lib/python3.12/site-packages/numpy/random/tests/data/philox-testset-1.csv
new file mode 100644
index 00000000..e448cbf7
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/random/tests/data/philox-testset-1.csv
@@ -0,0 +1,1001 @@
+seed, 0xdeadbeaf
+0, 0xedc95200e2bd66a5
+1, 0x581d4e43b7682352
+2, 0x4be7278f5e373eab
+3, 0xee47f17991a9e7ea
+4, 0x38a7d2ae422f2e2c
+5, 0xe2a6730a3b4a8a15
+6, 0x1588b7a841486442
+7, 0x13ad777246700504
+8, 0x14d157e0f5e18204
+9, 0xd87c22a7ee8c13f1
+10, 0x30cc389ce3542ba1
+11, 0xb8a53348955bb2e9
+12, 0xc08802e3c454f74f
+13, 0xb444f627671a5780
+14, 0x4b6dd42b29cbf567
+15, 0x6109c7dc0bc5f7d5
+16, 0x85c954715d6b5b1e
+17, 0x646178d3d9a3a5d5
+18, 0xebbde42b1cd83465
+19, 0x3d015102f6bc9c1a
+20, 0x720fe2ec3798d5fd
+21, 0x93120961289ceb2e
+22, 0xc9207e960a56fae2
+23, 0xa7f042f31d991b98
+24, 0x5fac117415fae74b
+25, 0xd0a970ba8dddc287
+26, 0x84b4e7e51b43106
+27, 0x6ad02bf525ea265f
+28, 0xcdc7e5992b36ef8f
+29, 0x44d4985209261d60
+30, 0x628c02d50f4b902e
+31, 0xc7b1914922d1e76d
+32, 0xfde99ff895cba51d
+33, 0x175a0be050fa985f
+34, 0x47297d3699e03228
+35, 0xccf1e9aeaa3339cd
+36, 0x9fdd18ebeeaf15b1
+37, 0x7c94c9ab68747011
+38, 0x612d8ef22c1fa80f
+39, 0x13f52b860de89ab5
+40, 0x81f264b8c139c43b
+41, 0x8d017ba4ef1e85ba
+42, 0x6d0556f46219951e
+43, 0x8ee7b85663cf67b6
+44, 0x2432fc707645fe67
+45, 0xaf814046051e5941
+46, 0x4d432a83739ac76f
+47, 0x59e5060d0983ccdd
+48, 0xdd20e828b83d9b53
+49, 0x1b891800d7385f4c
+50, 0x10e86a026c52ff5e
+51, 0xb932f11723f7b90c
+52, 0xb2413d0a1f3582d0
+53, 0xe7cd4edda65fc6b5
+54, 0x6d3808848d56593b
+55, 0x192a727c3c7f47d9
+56, 0x9659d8aea5db8c16
+57, 0x4242c79fe2c77c16
+58, 0x605f90c913827cea
+59, 0x53e153c8bfc2138a
+60, 0xed2158fbdef5910e
+61, 0xae9e6e29d4cb5060
+62, 0x7dd51afaad3b11ce
+63, 0x2b9ba533d01a5453
+64, 0x7e0e9cf2b6c72c8
+65, 0x1cc8b3c7747ed147
+66, 0x9b102651e2e11b48
+67, 0x30b0b53cbaac33ea
+68, 0x70c28aec39b99b85
+69, 0x5f1417ff536fdb75
+70, 0x3a1d91abd53acf58
+71, 0xba116a1772168259
+72, 0xf5369bc9bd284151
+73, 0x67bf11373bf183ca
+74, 0xef0b2d44dbd33dc7
+75, 0xbfd567ee1a2953ed
+76, 0x7d373f2579b5e5c6
+77, 0x756eeae7bcdd99be
+78, 0x75f16eb9faa56f3b
+79, 0x96d55ded2b54b9a5
+80, 0x94495191db692c24
+81, 0x32358bdd56bab38c
+82, 0x3f6b64078576579
+83, 0x7177e7948bc064c9
+84, 0x2cbf23f09ba9bc91
+85, 0x9b97cc31c26645f5
+86, 0x5af2d239ff9028b1
+87, 0x316fa920e0332abe
+88, 0x46535b7d1cae10a0
+89, 0x21f0a6869298022c
+90, 0xf395c623b12deb14
+91, 0x8573995180675aa7
+92, 0xc3076509f4dc42d5
+93, 0x15e11e49760c6066
+94, 0xe8a6d311e67a021d
+95, 0x7482f389c883339b
+96, 0xda6f881573cba403
+97, 0xb110ffb847e42f07
+98, 0x2c3393140605ccf9
+99, 0xba1c8ba37d8bdc33
+100, 0x59adf43db7a86fe0
+101, 0xb4fcbf6aa585ca85
+102, 0xd794a93c18033fa6
+103, 0x6e839c01985f9d4
+104, 0x64065bf28222b2c7
+105, 0x6a6359b293fa0640
+106, 0x5ff610969e383e44
+107, 0xa8172c263f05c7f7
+108, 0x62a0172e8bd75d07
+109, 0x7be66e3c453b65ac
+110, 0x6a3b8d5a14014292
+111, 0xa2583e6087450020
+112, 0xd5d3ecc480c627d2
+113, 0xa24e83f1eec8a27c
+114, 0xa23febd2a99ee75a
+115, 0x9a5fbf91c7310366
+116, 0x5b63156932e039b
+117, 0x942af3c569908505
+118, 0x89a850f71ab6a912
+119, 0xfeadc803ac132fe9
+120, 0x67bf60e758250f3
+121, 0x533c25103466a697
+122, 0xb7deede3482f9769
+123, 0x325e043b53bba915
+124, 0x9e8d9e7fde132006
+125, 0x6bacc6860bbc436e
+126, 0xb3ea0534c42b1c53
+127, 0xb2389334db583172
+128, 0xa74b1bfbf5242ee4
+129, 0x53a487e2dc51d15c
+130, 0xe5a3b538d2c7a82e
+131, 0x7b6c70bb0c4cadaf
+132, 0xae20791b2081df1
+133, 0xc685c12e3c61d32c
+134, 0x60110e6b0286e882
+135, 0x49682119c774045c
+136, 0x53dc11a3bbd072e
+137, 0xbdc87c6e732d9c2d
+138, 0xcc4620861ebac8fd
+139, 0x7e9c3558759350cc
+140, 0x157408dee34891ba
+141, 0x9bcad1855b80651b
+142, 0xd81b29141d636908
+143, 0x1ed041a9f319c69d
+144, 0x805b2f541208b490
+145, 0x484ef3bba2eb7c66
+146, 0xb6b5e37d50a99691
+147, 0xabc26a7d9e97e85f
+148, 0xcba2a3cce0417c2f
+149, 0xa030dfffd701993c
+150, 0x2bf2dc50582ebf33
+151, 0xd9df13dd3eb9993e
+152, 0x31ca28b757232ae5
+153, 0x614562a0ccf37263
+154, 0x44d635b01725afbb
+155, 0x5ae230bc9ca9cd
+156, 0xb23a124eb98705c6
+157, 0x6395675444981b11
+158, 0xd97314c34119f9ca
+159, 0x9de61048327dd980
+160, 0x16bac6bded819707
+161, 0xcea3700e3e84b8c7
+162, 0xaa96955e2ee9c408
+163, 0x95361dcc93b5bc99
+164, 0x306921aed3713287
+165, 0x4df87f3130cd302a
+166, 0x37c451daeb6a4af5
+167, 0x8dbbe35f911d5cc1
+168, 0x518157ce61cb10f9
+169, 0x669f577aebc7b35b
+170, 0x4b0a5824a8786040
+171, 0x519bc3528de379f5
+172, 0x6128012516b54e02
+173, 0x98e4f165e5e6a6dd
+174, 0x6404d03618a9b882
+175, 0x15b6aeb3d9cd8dc5
+176, 0x87ed2c1bae83c35b
+177, 0x8377fc0252d41278
+178, 0x843f89d257a9ba02
+179, 0xcdda696ea95d0180
+180, 0xcfc4b23a50a89def
+181, 0xf37fd270d5e29902
+182, 0xafe14418f76b7efa
+183, 0xf984b81577076842
+184, 0xe8c60649ccb5458d
+185, 0x3b7be8e50f8ff27b
+186, 0xaa7506f25cef1464
+187, 0x5e513da59f106688
+188, 0x3c585e1f21a90d91
+189, 0x1df0e2075af292a
+190, 0x29fdd36d4f72795f
+191, 0xb162fe6c24cb4741
+192, 0x45073a8c02bd12c4
+193, 0xcbaaa395c2106f34
+194, 0x5db3c4c6011bc21c
+195, 0x1b02aac4f752e377
+196, 0xa2dfb583eb7bec5
+197, 0xfe1d728805d34bb1
+198, 0xf647fb78bb4601ec
+199, 0xd17be06f0d1f51ef
+200, 0x39ec97c26e3d18a0
+201, 0xb7117c6037e142c8
+202, 0xe3a6ce6e6c71a028
+203, 0xe70a265e5db90bb2
+204, 0x24da4480530def1e
+205, 0xfd82b28ce11d9a90
+206, 0x5bf61ead55074a1d
+207, 0xbe9899c61dec480d
+208, 0xae7d66d21e51ec9e
+209, 0x384ee62c26a08419
+210, 0x6648dccb7c2f4abf
+211, 0xc72aa0c2c708bdc9
+212, 0x205c5946b2b5ba71
+213, 0xd4d8d0b01890a812
+214, 0x56f185493625378d
+215, 0x92f8072c81d39bd0
+216, 0xa60b3ceecb3e4979
+217, 0xfcf41d88b63b5896
+218, 0xf5a49aa845c14003
+219, 0xffcc7e99eee1e705
+220, 0xdd98312a7a43b32d
+221, 0xa6339bd7730b004
+222, 0xdac7874ba7e30386
+223, 0xadf6f0b0d321c8
+224, 0x126a173ae4ffa39f
+225, 0x5c854b137385c1e7
+226, 0x8173d471b1e69c00
+227, 0x23fa34de43581e27
+228, 0x343b373aef4507b1
+229, 0xa482d262b4ea919c
+230, 0xf7fbef1b6f7fbba
+231, 0xd8ce559487976613
+232, 0xbf3c8dd1e6ebc654
+233, 0xda41ed375451e988
+234, 0xf54906371fd4b9b3
+235, 0x5b6bb41231a04230
+236, 0x866d816482b29c17
+237, 0x11315b96941f27dc
+238, 0xff95c79205c47d50
+239, 0x19c4fff96fbdac98
+240, 0xbfb1ae6e4131d0f4
+241, 0x9d20923f3cdb82c9
+242, 0x282175507c865dff
+243, 0xdfd5e58a40fe29be
+244, 0xedbd906ff40c8e4f
+245, 0x11b04fc82614ccb3
+246, 0xeceb8afda76ae49f
+247, 0xa4856913847c2cdf
+248, 0x6f1425f15a627f2a
+249, 0xdf144ffedf60349e
+250, 0x392d7ecfd77cc65f
+251, 0x72b8e2531049b2c6
+252, 0x5a7eb2bdb0ec9529
+253, 0xdcfd4306443e78c1
+254, 0x89ad67ed86cd7583
+255, 0x276b06c0779a6c8f
+256, 0xb2dbb723196a0ac3
+257, 0x66c86a3b65906016
+258, 0x938348768a730b47
+259, 0x5f5282de938d1a96
+260, 0xa4d4588c4b473b1f
+261, 0x8daed5962be4796f
+262, 0x9dde8d796985a56e
+263, 0x46be06dbd9ed9543
+264, 0xdf98286ceb9c5955
+265, 0xa1da1f52d7a7ca2b
+266, 0x5a7f1449f24bbd62
+267, 0x3aedc4e324e525fd
+268, 0xced62464cd0154e1
+269, 0x148fc035e7d88ce3
+270, 0x82f8878948f40d4c
+271, 0x4c04d9cdd6135c17
+272, 0xdf046948d86b3b93
+273, 0x2f0dec84f403fe40
+274, 0xa61954fb71e63c0d
+275, 0x616d8496f00382e8
+276, 0x162c622472746e27
+277, 0x43bcfe48731d2ceb
+278, 0xff22432f9ff16d85
+279, 0xc033ed32bb0ad5a4
+280, 0x5d3717cc91c0ce09
+281, 0x7a39a4852d251075
+282, 0x61cd73d71d6e6a6
+283, 0xe37e2ea4783ab1a5
+284, 0x60e1882162579ea8
+285, 0x9258ec33f1a88e00
+286, 0x24b32acf029f0407
+287, 0x1410fc9aea6d3fac
+288, 0x6054cf2a3c71d8f7
+289, 0x82f7605157a66183
+290, 0x3b34c1c0dff9eac5
+291, 0xfebe01b6d5c61819
+292, 0x7372187c68b777f2
+293, 0xc6923812cda479f0
+294, 0x386613be41b45156
+295, 0x92cfebe8cc4014b
+296, 0x8e13c4595849828b
+297, 0x90e47390d412291f
+298, 0x6b21a1d93d285138
+299, 0xbf5b1f5922f04b12
+300, 0x21e65d1643b3cb69
+301, 0xf7683b131948ac3c
+302, 0xe5d99fc926196ed2
+303, 0x7b138debbec90116
+304, 0x8a2650a75c2c2a5c
+305, 0x20689a768f9b347b
+306, 0xdfa2900cfb72dc6e
+307, 0x98959c3855611cc2
+308, 0x5fdb71b89596cc7c
+309, 0x1c14ac5c49568c7b
+310, 0x958c4293016091fe
+311, 0x7484522eb0087243
+312, 0xc4018dfb34fc190f
+313, 0xca638567e9888860
+314, 0x102cd4805f0c0e89
+315, 0xcc3bc438e04548f8
+316, 0xb808944bb56ea5be
+317, 0xffd4778dbf945c57
+318, 0xfe42617784c0233b
+319, 0x3eccbfeae9b42d3c
+320, 0xd9f1b585fd0bfa60
+321, 0x5c063d1b2705d5dd
+322, 0x8e8bec3519941b64
+323, 0x9e94c36cbec2a42
+324, 0x1cd19f5b64ffd3ad
+325, 0x9632e3aebfc68e66
+326, 0x98960c2d9da4ae45
+327, 0xb76994b1f2bbfc1f
+328, 0xca184a737d3971cc
+329, 0x964d31b07183adfb
+330, 0xe9e0ff351cd276d4
+331, 0xb5747c860b05bbe4
+332, 0x5549ddc3bd3862e2
+333, 0x495496677b27873b
+334, 0x53910baa26e3ea18
+335, 0xaa07a07ad0a688d3
+336, 0xbb43bd1f09ecdb1e
+337, 0xe2ebc105699dd84
+338, 0x6e815a2729584035
+339, 0x2caab1713b17948a
+340, 0x43d39d209fa41c90
+341, 0xfe3e71089d5d1c3a
+342, 0xa778646c32f81177
+343, 0x8d42bfb86e6e92d5
+344, 0x175571f70b4fcfbe
+345, 0x2a66a6fe10dc3b5b
+346, 0xd9545e85235ca709
+347, 0x5642781c77ced48a
+348, 0x24facc40b72ccd09
+349, 0xa800fbacce33f6f8
+350, 0x675f58a0ff19fba
+351, 0x35aedf57bb5cde1b
+352, 0xe5535a6b63f6d068
+353, 0x84dffd0102aaa85d
+354, 0x621faad65467aaa7
+355, 0x596ad85b556b112f
+356, 0x837545fff8894c7a
+357, 0x3d9a4ae1356bc6a6
+358, 0xcd8b7153205d4ad0
+359, 0x98afdd40f1ed09a6
+360, 0xa38b2dc55a5cf87f
+361, 0x484aecce2b6838bc
+362, 0x6af05c26bdab18d9
+363, 0xf418b7399dcf2e4b
+364, 0x1cfa38789b0d2445
+365, 0xfbed23c34166ee67
+366, 0x38e6820039e4912a
+367, 0x1fe94911e963591e
+368, 0x1291c79aee29ad70
+369, 0x65eccfc89506f963
+370, 0x7d14de3b2f55b1f6
+371, 0x82eb79c36cd2a739
+372, 0x41ffe3b75ea0def5
+373, 0x9eba9156470a51d9
+374, 0xd17c00b981db37d1
+375, 0xf688769a75601aa7
+376, 0xbcf738e9e03d571e
+377, 0x14712e56df8f919b
+378, 0xab14e227d156e310
+379, 0xf53d193e993e351e
+380, 0x857fae46bd312141
+381, 0xc2dd71e41b639966
+382, 0x74f8b987a3d00ad1
+383, 0x5bce8526dc527981
+384, 0x94910926c172a379
+385, 0x503c45557688a9d5
+386, 0x244d03834e05807f
+387, 0x6e014cbab9c7a31f
+388, 0xae544c638530facf
+389, 0x9b853aaaf9cbc22d
+390, 0xfb42ab7024d060ed
+391, 0x74cc3fba0dfd7ff2
+392, 0x24ec9e8f62144ad5
+393, 0x72f082954307bbe7
+394, 0x36feda21bbf67577
+395, 0x3222191611b832f1
+396, 0xd0584e81bcac8b0b
+397, 0xdce8d793ef75e771
+398, 0x978824c6c2578fc
+399, 0x6e8f77503b3c2ee4
+400, 0xc85d2d86fecf5d03
+401, 0x3d35b4a5d4d723c4
+402, 0xd3987dfd4727fff3
+403, 0xd3cde63fb6a31add
+404, 0xf6699e86165bdaeb
+405, 0x9d60ba158ec364c4
+406, 0x920c3c18b346bfc9
+407, 0x770fd1fdfbc236ca
+408, 0x45998cfc5fc12ddd
+409, 0xd74a3454e888834b
+410, 0xbf2aa68081a4a28f
+411, 0xea41b26a6f1da1b3
+412, 0x5560a2d24b9d5903
+413, 0xe3791f652a228d8b
+414, 0x365116d3b5a8520c
+415, 0xb1b2bd46528f8969
+416, 0xfcfe14943ef16ae7
+417, 0xf4d43425e8a535dc
+418, 0xe6cf10a78782a7e0
+419, 0x9c7ac0de46556e3e
+420, 0xc667ae0856eed9ef
+421, 0x47dbb532e16f9c7e
+422, 0xdf4785a5d89ee82e
+423, 0xbd014925ce79dbcf
+424, 0xea0d663fb58fa5be
+425, 0x51af07d5cc3821fb
+426, 0x27a1bdcdc4159a9d
+427, 0x520c986c59b1e140
+428, 0x50b73fd9bacd5b39
+429, 0xae5240641f51e4f3
+430, 0x71faecc164ed9681
+431, 0xda95aa35529a7ee
+432, 0xe25ba29b853c1c6d
+433, 0x9871a925cda53735
+434, 0xde481ad8540e114d
+435, 0xa2997f540e8abca0
+436, 0xc9683c5035e28185
+437, 0x1082471b57182bac
+438, 0xbd3ecf0f0b788988
+439, 0xf479760776fbb342
+440, 0x3730929200d91f44
+441, 0xc1762d79ae72809c
+442, 0xfaa0a4c7b1686cb3
+443, 0xd581e6d55afdafcd
+444, 0x6cf57bdfba2dcf6d
+445, 0xdef79d9fe6a5bcef
+446, 0x13ed376e18132bd3
+447, 0xbe67efd72defa2a
+448, 0x5acc176c468966ea
+449, 0x8b35b626af139187
+450, 0x446de3fac0d973ac
+451, 0xe1d49e06dc890317
+452, 0x817bc3fd21fc09b7
+453, 0xb71c3958a13d5579
+454, 0x8746e010f73d7148
+455, 0x1b61c06009922e83
+456, 0xba17e62e6b092316
+457, 0x1375fa23c4db8290
+458, 0x3f071230f51245a6
+459, 0x51c99a086a61cd13
+460, 0x5f0f2ae78589e1fd
+461, 0x604834e114bbbc27
+462, 0x5eb2a7a34814e9a9
+463, 0x77a6907f386bf11e
+464, 0x99525de2bd407eeb
+465, 0xb818348c57b3b98f
+466, 0x25f5f9e702fbe78d
+467, 0x8f66669e6f884473
+468, 0x1e47d46e2af4f919
+469, 0xf6a19df846476833
+470, 0xff00c67bcd06621f
+471, 0xe3dfe069795d72d8
+472, 0x8affc88b2fea4d73
+473, 0x66df747e5f827168
+474, 0xf368ec338d898a0e
+475, 0x9e1f1a739c5984a2
+476, 0x46a1c90e1ca32cbc
+477, 0xc261bc305ed8d762
+478, 0x754d7949f7da9e72
+479, 0x4c8fbbb14ef47b17
+480, 0xccbdc67a3848d80d
+481, 0x3c25e6f58bae751d
+482, 0x7078b163b936d9b6
+483, 0x440e27463c134ecf
+484, 0x6c83ee39f324db0f
+485, 0x27cf901b22aea535
+486, 0x57262dec79a3f366
+487, 0x91db09f1dbb524fb
+488, 0xd7436eefba865df2
+489, 0x16c86b0a275a3f43
+490, 0x689493e6681deaa9
+491, 0x7e1dc536c1a9ac42
+492, 0x1145beac3ac7f5cc
+493, 0x3d05e211a104b2b0
+494, 0x4f9e77ced3c52f44
+495, 0x53de1369354add72
+496, 0x1fb60f835f47cdeb
+497, 0x6ab36f089e40c106
+498, 0xaabffcb0d3d04c7
+499, 0xaa399686d921bd25
+500, 0x2bf8dd8b6d6fa7f0
+501, 0x1ddbf4e124329613
+502, 0x466a740241466a72
+503, 0x98d7381eb68a761
+504, 0x817691510bc4857a
+505, 0x8837622c0171fe33
+506, 0xcba078873179ee16
+507, 0x13adad1ab7b75af4
+508, 0x3bac3f502428840c
+509, 0xbeb3cce138de9a91
+510, 0x30ef556e40b5f0b4
+511, 0x19c22abdf3bbb108
+512, 0x977e66ea4ddc7cf
+513, 0x9f4a505f223d3bf3
+514, 0x6bc3f42ac79ec87b
+515, 0x31e77712158d6c23
+516, 0x6d8de4295a28af0d
+517, 0xee1807dbda72adb7
+518, 0xda54140179cd038f
+519, 0x715aa5cdac38e062
+520, 0x5a7e55e99a22fa16
+521, 0xf190c36aa8edbe4f
+522, 0xccadd93a82c1d044
+523, 0x7070e6d5012c3f15
+524, 0x50a83341a26c1ba5
+525, 0x11bca7cc634142e5
+526, 0x623a0d27867d8b04
+527, 0x75c18acff54fbf6e
+528, 0x455ae7d933497a6f
+529, 0xf624cf27d030c3d3
+530, 0x7a852716f8758bac
+531, 0xe7a497ac1fa2b5b4
+532, 0xf84f097498f57562
+533, 0xc4bb392f87f65943
+534, 0x618e79a5d499fbfb
+535, 0xb3c0b61d82b48b8
+536, 0x4750a10815c78ea7
+537, 0x9cf09cca3ddece69
+538, 0x2a69f1c94cc901a2
+539, 0x347a0e446e1ce86d
+540, 0xb06f3a5a5ab37bb1
+541, 0x8035bd0713d591db
+542, 0x539c9637042c3a1f
+543, 0xd7ba4dc6b273cbd7
+544, 0x12f3f99933444f85
+545, 0x4a9517b9783fb9a4
+546, 0x6422b2ea95093bc5
+547, 0x3a5ecff0f996c2a6
+548, 0x31de504efc76a723
+549, 0x7ccb7c5233c21a9f
+550, 0xc687d9e6ce4186e8
+551, 0x6e40769d6940376a
+552, 0xf51207314f1f7528
+553, 0x67ee3acb190865e3
+554, 0xe08d586270588761
+555, 0xe387fa489af1a75c
+556, 0x73414a52d29d8375
+557, 0x671a38191cf2a357
+558, 0xe00fb25b1aa54008
+559, 0x11a0610e22cf549b
+560, 0xc90cc865d57c75be
+561, 0x90d0863cc15f2b79
+562, 0x8b3e60d32ebcb856
+563, 0xb28cc55af621e04a
+564, 0xcf60bd3cb2a5ab1d
+565, 0x212cb5d421948f86
+566, 0xee297b96e0a3363f
+567, 0x4e9392ff998760d1
+568, 0x61940c8d0105ba3e
+569, 0x14ebcbae72a59a16
+570, 0xdf0f39a3d10c02af
+571, 0xfc047b2b3c1c549d
+572, 0x91718b5b98e3b286
+573, 0x9ea9539b1547d326
+574, 0x7a5a624a89a165e6
+575, 0x145b37dcaa8c4166
+576, 0x63814bbb90e5616c
+577, 0xc4bc3ca6c38bb739
+578, 0x853c3a61ddc6626c
+579, 0xa7ce8481c433829a
+580, 0x8aff426941cc07b
+581, 0x2dc3347ca68d8b95
+582, 0xce69f44f349e9917
+583, 0x2fa5cb8aca009b11
+584, 0xf26bb012115d9aca
+585, 0xafa01c2f2d27235a
+586, 0xabcba21f1b40305e
+587, 0xfec20c896c0c1128
+588, 0xc5f7a71ebacadfa0
+589, 0xc8479ad14bab4eef
+590, 0xad86ec9a3e7d3dc
+591, 0xbbecd65292b915c5
+592, 0xb1f9e28149e67446
+593, 0x708d081c03dad352
+594, 0xaa8a84dbd1de916c
+595, 0x9aa3efb29ba9480b
+596, 0xd3c63969ff11443e
+597, 0x1e9e9ac861315919
+598, 0x4fe227f91e66b41d
+599, 0xefc0212d43d253ab
+600, 0x98341437727c42d1
+601, 0x5ea85c0fe9008adc
+602, 0x7891b15faa808613
+603, 0x32db2d63989aacfd
+604, 0xc92f7f28e88fd7bc
+605, 0x3513545eb6549475
+606, 0x49abe0082906fbf8
+607, 0xcee1e1a6551e729c
+608, 0x38556672b592a28e
+609, 0xc3e61409c4ec2d45
+610, 0x96c67ce2995a0fd4
+611, 0x9b9b0cada870293
+612, 0x82d6dd5dada48037
+613, 0xeea4f415299f1706
+614, 0x371107895f152ab3
+615, 0x2f6686159f4396bb
+616, 0x61005a2ff3680089
+617, 0x9d2f2cafb595e6b6
+618, 0x4a812a920f011672
+619, 0x317554d3a77385d7
+620, 0x24c01086727eb74b
+621, 0xa15ff76d618a3a9e
+622, 0x2121bfd983859940
+623, 0x384d11577eea8114
+624, 0xab0f4299f3c44d88
+625, 0x136fd4b07cfa14d9
+626, 0x665fe45cbfaa972a
+627, 0x76c5a23398a314e9
+628, 0x5507036357ccda98
+629, 0xd9b8c5ac9dce632b
+630, 0x366bc71781da6e27
+631, 0xdd2b2ba1d6be6d15
+632, 0xf33ed0d50ea6f1a6
+633, 0xf05a9b1900174c18
+634, 0x3947e1419e2787cf
+635, 0x6c742b1e029637d0
+636, 0x32aba12196a0d2e8
+637, 0x1b94aab2e82e7df
+638, 0x68b617db19229d6
+639, 0x6c88a95ac0a33f98
+640, 0xdc9b95fd60c2d23e
+641, 0x999e6971d3afc8b3
+642, 0x7071fc6ad8b60129
+643, 0x41a8184ef62485f6
+644, 0xb68e0605c7d5e713
+645, 0x272b961a1d1bbee
+646, 0x23f04e76446187b0
+647, 0x999a7a8f6d33f260
+648, 0xdbd6318df4f168d
+649, 0x8f5e74c84c40711e
+650, 0x8ccc6b04393a19d6
+651, 0xadcd24b782dd8d3d
+652, 0x1a966b4f80ef9499
+653, 0xcb6d4f9ff5a280f0
+654, 0x8095ff2b8484018a
+655, 0xbfd3389611b8e771
+656, 0x278eb670b7d12d51
+657, 0x31df54ca8d65c20f
+658, 0x121c7fb38af6985e
+659, 0x84fb94f38fe1d0a
+660, 0x15ae8af1a6d48f02
+661, 0x8d51e4a62cba1a28
+662, 0x58e6b6b3ae0f9e42
+663, 0x9365a0a85669cc99
+664, 0xe56e92f65a2106df
+665, 0x68fa299c66b428fc
+666, 0x55e51bb0b0a832c6
+667, 0x48b565293f9bc494
+668, 0x73d8132b1cbabb57
+669, 0x9178ac3926c36cbc
+670, 0xe2f22c7b28ea5e0f
+671, 0x6af45322a99afb12
+672, 0x59072fcb486a46f4
+673, 0x166b717b08d3d8e
+674, 0xd4e627a2dfacc4ab
+675, 0x33dad6f2921dedaa
+676, 0x4b13b806834a6704
+677, 0xe5f7971b398ed54d
+678, 0x20bfae65e3e6899b
+679, 0x881dab45d2b4fc98
+680, 0x6f248126b5b885be
+681, 0x7aeb39e986f9deee
+682, 0xf819f9574b8c3a03
+683, 0xff3d93ed6bd9781a
+684, 0x3a31e2e24a2f6385
+685, 0x7888a88f8944a5e
+686, 0x4faee12f5de95537
+687, 0x7f3e4efccdb2ed67
+688, 0x91e0f2fc12593af5
+689, 0xb5be8a4b886a40d3
+690, 0x998e8288ac3a9b1b
+691, 0x85c48fc8b1349e7b
+692, 0xf03af25222d8fae5
+693, 0x45467e805b242c2e
+694, 0xa2350db793dbebdc
+695, 0xfebe5b61d2174553
+696, 0xa9a331f02c54ad0b
+697, 0xe94e49a0f905aef3
+698, 0xe54b4c812b55e3da
+699, 0xdc454114c6bc0278
+700, 0x99c7765ab476baa2
+701, 0xccd9590e47fdff7c
+702, 0xfa2bcae7afd6cb71
+703, 0x2c1bf1a433a6f0f7
+704, 0x53882c62ff0aab28
+705, 0x80ac900f844dacc
+706, 0x27ba8eb5c4a44d54
+707, 0x78f3dfb072a46004
+708, 0x34e00e6ec629edce
+709, 0x5b88d19b552d1fbd
+710, 0xe4df375dc79df432
+711, 0x37446312ff79c3b4
+712, 0xb72256900a95fa6d
+713, 0x89f3171fbdff0bfc
+714, 0xd37885b048687eba
+715, 0xbb033213b283b60e
+716, 0xcf10b523ee769030
+717, 0xbf8070b6cfd7bafb
+718, 0xb7194da81fd1763b
+719, 0xbfc303de88e68d24
+720, 0xb949c7a5aea8a072
+721, 0x844216e7bae90455
+722, 0xf1e7f20840049a33
+723, 0x96e3263ad0cae794
+724, 0x10772d51f6e9ba49
+725, 0xcea24fccae9d23b3
+726, 0xefd378add9dde040
+727, 0xba0c7c5275805976
+728, 0x2e2a04608f64fa8c
+729, 0xafb42ec43aa0fa7
+730, 0x30444b84241ac465
+731, 0x19ef384bac4493ab
+732, 0xfd1ac615d3ba5ab9
+733, 0x6cc781ba38643aff
+734, 0x30ff27ebed875cfd
+735, 0xee1a261aca97ae62
+736, 0xc5a92715202bc940
+737, 0x9e6ec76f93c657ff
+738, 0x9b9fd55f55191ca5
+739, 0x654b13af008d8f03
+740, 0x1b7f030d9bd0719f
+741, 0x6d622e277550cb7f
+742, 0x3f8ee6b8830d0538
+743, 0x475462bcd0de190f
+744, 0x21380e8a513bdbcd
+745, 0x629bf3771b1bd7a4
+746, 0x3b5fd0b62c353709
+747, 0xf95634006ec3867e
+748, 0x1be8bb584a6653c2
+749, 0x2e2d3cfa85320ce8
+750, 0x5b904b692252d11d
+751, 0x4bfd76631d527990
+752, 0xc019571ca2bec4a0
+753, 0xf2eb730cea4cd751
+754, 0xd4571d709530191a
+755, 0x3b5bd947061f5a7d
+756, 0x56e2322cd2d1d1c0
+757, 0xa8830a5f62019f83
+758, 0x901d130c1b873cf3
+759, 0xb5dd29b363c61299
+760, 0xbb710bec3a17b26d
+761, 0xc0c464daca0f2328
+762, 0x4dc8055df02650f5
+763, 0x3d3cd9bbe8b957af
+764, 0xdb79612c2635b828
+765, 0xe25b3a8ad8fa3040
+766, 0xd5875c563cbf236b
+767, 0x46861c1c3849c9bc
+768, 0xf84bf1a2814dff43
+769, 0x6d8103902e0ad5e6
+770, 0x99f51c9be8af79e5
+771, 0xb0bfa8540ff94a96
+772, 0xaf45109a4e06f7d0
+773, 0x281df3e55aea9bfc
+774, 0x6a1155ca8aa40e60
+775, 0x754d32c5de1f5da
+776, 0xce1eafb1c6ca916f
+777, 0xc4f2185fa8577bd1
+778, 0x4a188e9bdb5501d9
+779, 0xbb14107e99bd5550
+780, 0xf0381d8425ec2962
+781, 0x213dbfffc16ec4f6
+782, 0x7a999c5a28ea65bc
+783, 0x23758c2aba7709ff
+784, 0xea7e4bb205e93b44
+785, 0x9c5a31e53911c658
+786, 0x7f04d0bbdc689ddc
+787, 0xe3ed89ab8d78dcb3
+788, 0x73c38bfb43986210
+789, 0x740c7d787eb8e158
+790, 0x5284fafdfb3fb9ec
+791, 0x2e91a58ac1fb1409
+792, 0xb94a600bf0a09af3
+793, 0x533ea4dbe07d81dd
+794, 0x48c3f1a736b3c5fd
+795, 0x56ae3499fa8720ce
+796, 0x526f2def663ca818
+797, 0x2f085759c65665c4
+798, 0xf715f042c69e0db4
+799, 0x110889c399231e60
+800, 0x64584a244866f3a0
+801, 0xf02ec101a39405d3
+802, 0xe73cd5e9a7f17283
+803, 0xfea64869e7028234
+804, 0x97559974ad877891
+805, 0xc8695aba1dc9f2e5
+806, 0x7b62b76ffc2264ec
+807, 0xf5e1df172ec5ccd
+808, 0xafaeb68765e443bd
+809, 0xd3870eb2e8337623
+810, 0x4f944d684138fb39
+811, 0x6977c575038916ad
+812, 0x8ada1a225df95a56
+813, 0xe4044c6c58d15e54
+814, 0x4e5121366681cf2
+815, 0xcf8640b079357b0d
+816, 0xcd5b157d44106fa3
+817, 0x9d7a5481279e25a1
+818, 0xe10e9db41fb4b34f
+819, 0x1052607be1eadff9
+820, 0x3403d67232fe2265
+821, 0xac9358f498c34afc
+822, 0x820172da0dc39c9
+823, 0xe186e91a3b826b6a
+824, 0x1a838e2a40284445
+825, 0x1870b617ebd7bce6
+826, 0xcb7cba4424be1ed7
+827, 0x6a2e56e40fdf9041
+828, 0xace93bbe108f97ee
+829, 0xfeb9bc74ac41ca08
+830, 0x8cb2d05b0f6a1f51
+831, 0x73792309f3fac0a9
+832, 0x2507343d431308ca
+833, 0xd0ea1197be615412
+834, 0xb1870812f1d2fa94
+835, 0x6d067b6935dcd23e
+836, 0xaf161014e5492c31
+837, 0xd4be0dce97064be4
+838, 0xf8edfe3fc75c20f1
+839, 0x894751dc442d2d9c
+840, 0xb4a95f6a6663456c
+841, 0x74e93162e2d805db
+842, 0x784bc5f3a7a2f645
+843, 0xd234d7c5b0582ea9
+844, 0x491f28d0ab6cb97c
+845, 0xa79419e5cf4336c3
+846, 0x66b00141978c849
+847, 0xa7ddbd64698d563f
+848, 0xefc33a4a5d97d4b2
+849, 0x95075514a65aebdc
+850, 0x40eca5b3e28cd25e
+851, 0x90ec7d00e9c9e35d
+852, 0x63e84104d5af417a
+853, 0xdaca0ea32df5744
+854, 0x7ed54f2587795881
+855, 0x5a73931760af4ee0
+856, 0x857d1a185a3081ec
+857, 0x6eac2aabe67fb463
+858, 0xd1f86155d8bfc55f
+859, 0x6d56398f3e7877ef
+860, 0x7642f61dfc62bc17
+861, 0x1d76b12843246ffa
+862, 0xde7817809b8a31d0
+863, 0xbcca9cd091198f9d
+864, 0xf71ca566dddcdfd4
+865, 0xea4386ee8b61d082
+866, 0xe351729d6010bac4
+867, 0xfd685d8a49910dd6
+868, 0xa7a20ea6c686bd3
+869, 0x1cdaf82f4dbd5536
+870, 0xa3da1d1e77dda3e0
+871, 0x4f723b3818ff8b2a
+872, 0x1290669eca152469
+873, 0xb54158b52d30651b
+874, 0xc06b74f2c7f0fee
+875, 0x7d5840bcbf702379
+876, 0x19fa4c1254a82ed
+877, 0xcf5ce090ad0b38ea
+878, 0xd4edd6ac9437e16d
+879, 0xc6ebf25eb623b426
+880, 0xd2b6dbdf00d8fea2
+881, 0x949cf98391cc59e1
+882, 0x380a0c7d0356f7b3
+883, 0x8ffefe32465473bf
+884, 0x637b6542d27c861e
+885, 0x347d12ffc664ecd9
+886, 0xea66e3a0c75a6b37
+887, 0xc3aff6f34fb537a1
+888, 0x67bdf3579959bf49
+889, 0xa17a348e3a74b723
+890, 0x93c9ef26ddadd569
+891, 0x483909059a5ac0b2
+892, 0x26ec9074b56d5a0d
+893, 0x6216000d9a48403a
+894, 0x79b43909eab1ec05
+895, 0xe4a8e8d03649e0de
+896, 0x1435d666f3ccdc08
+897, 0xb9e22ba902650a0e
+898, 0x44dffcccc68b41f8
+899, 0x23e60dcc7a559a17
+900, 0x6fd1735eacd81266
+901, 0xf6bda0745ea20c8e
+902, 0x85efcaefe271e07c
+903, 0x9be996ee931cef42
+904, 0xe78b41c158611d64
+905, 0xd6201df605839830
+906, 0x702e8e47d2769fd3
+907, 0xb8dcf70e18cf14c
+908, 0xac2690bab1bf5c17
+909, 0x92b166b71205d696
+910, 0xb0e73c795fc6df28
+911, 0x4bf2322c8b6b6f0d
+912, 0xa842fbe67918cea0
+913, 0xb01a8675d9294e54
+914, 0xfbe3c94f03ca5af2
+915, 0x51a5c089600c441f
+916, 0x60f0fd7512d85ded
+917, 0xef3113d3bc2cadb0
+918, 0xe1ea128ade300d60
+919, 0xde413b7f8d92d746
+920, 0xfc32c6d43f47c5d8
+921, 0x69d551d8c2b54c68
+922, 0xb9bc68c175777943
+923, 0xb9c79c687f0dae90
+924, 0xd799421ef883c06e
+925, 0xbff553ca95a29a3e
+926, 0xfc9ffac46bd0aca1
+927, 0x4f6c3a30c80c3e5a
+928, 0x8b7245bc6dc4a0a
+929, 0xaf4e191a4575ff60
+930, 0x41218c4a76b90f0b
+931, 0x986052aa51b8e89b
+932, 0x284b464ed5622f9
+933, 0xba6bded912626b40
+934, 0x43cad3ed7443cb5c
+935, 0x21641fa95725f328
+936, 0x6d99d6d09d755822
+937, 0x8246dfa2d4838492
+938, 0xd2ee70b9056f4726
+939, 0x87db515a786fbb8b
+940, 0x7c63e4c1d7786e7d
+941, 0xd1a9d548f10b3e88
+942, 0xa00856475f3b74c9
+943, 0x7f1964ce67148bf4
+944, 0x446650ec71e6018c
+945, 0xb1805ca07d1b6345
+946, 0x869c0a1625b7271b
+947, 0x79d6da06ce2ecfe2
+948, 0xec7b3cafc5e3c85f
+949, 0x1745ce21e39f2c3d
+950, 0xd9a0a7af6ee97825
+951, 0x680e0e52a6e11d5c
+952, 0xd86b3f344ff7f4cd
+953, 0xab56af117c840b9c
+954, 0x5c5404c7e333a10e
+955, 0x4f1eb462f35d990d
+956, 0xf857605a5644458e
+957, 0x3bb87cdf09262f86
+958, 0xd57295baf6da64b
+959, 0xb5993f48472f2894
+960, 0x7d1a501608c060b2
+961, 0x45fabe2d0e54adf0
+962, 0xbb41c3806afb4efe
+963, 0xbfbc506049424c8
+964, 0xb7dd6b67f2203344
+965, 0x389ce52eff883b81
+966, 0xe259c55c0cf6d000
+967, 0x70fb3e3824f7d213
+968, 0x9f36d5599ed55f4b
+969, 0xd14cf6f12f83c4f7
+970, 0x570a09d56aaa0b66
+971, 0x8accafd527f4598
+972, 0xa42d64c62175adfd
+973, 0xddb9c6a87b6e1558
+974, 0xd80b6c69fa1cde2a
+975, 0x44ebaac10082207b
+976, 0xf99be8889552fa1a
+977, 0x38253cd4b38b5dc5
+978, 0x85356c8b02675791
+979, 0xbf91677b2ecdcf55
+980, 0x2316cb85e93f366e
+981, 0x9abf35954db6b053
+982, 0xf49f7425e086b45a
+983, 0x8f5b625e074afde2
+984, 0xe0d614559791b080
+985, 0xbf7b866afab2a525
+986, 0xde89d7e1641a6412
+987, 0x1d10687d8ae5b86f
+988, 0x1f034caa0e904cbd
+989, 0x2086357aec8a7a2c
+990, 0x22dc476b80c56e1e
+991, 0xbef5a73cc0e3a493
+992, 0xddfa3829b26ed797
+993, 0x8917a87ec3d4dc78
+994, 0xfeabe390628c365e
+995, 0x581b0c4f6fb2d642
+996, 0x1ef8c590adbf5b9a
+997, 0x4d8e13aac0cce879
+998, 0xfe38f71e5977fad0
+999, 0x1f83a32d4adfd2ed
diff --git a/venv/lib/python3.12/site-packages/numpy/random/tests/data/philox-testset-2.csv b/venv/lib/python3.12/site-packages/numpy/random/tests/data/philox-testset-2.csv
new file mode 100644
index 00000000..69d24c38
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/random/tests/data/philox-testset-2.csv
@@ -0,0 +1,1001 @@
+seed, 0x0
+0, 0x399e5b222b82fa9
+1, 0x41fd08c1f00f3bc5
+2, 0x78b8824162ee4d04
+3, 0x176747919e02739d
+4, 0xfaa88f002a8d3596
+5, 0x418eb6f592e6c227
+6, 0xef83020b8344dd45
+7, 0x30a74a1a6eaa064b
+8, 0x93d43bf97a490c3
+9, 0xe4ba28b442194cc
+10, 0xc829083a168a8656
+11, 0x73f45d50f8e22849
+12, 0xf912db57352824cc
+13, 0xf524216927b12ada
+14, 0x22b7697473b1dfda
+15, 0x311e2a936414b39f
+16, 0xb905abfdcc425be6
+17, 0x4b14630d031eac9c
+18, 0x1cf0c4ae01222bc8
+19, 0xa6c33efc6e82ef3
+20, 0x43b3576937ba0948
+21, 0x1e483d17cdde108a
+22, 0x6722784cac11ac88
+23, 0xee87569a48fc45d7
+24, 0xb821dcbe74d18661
+25, 0xa5d1876ef3da1a81
+26, 0xe4121c2af72a483
+27, 0x2d747e355a52cf43
+28, 0x609059957bd03725
+29, 0xc3327244b49e16c5
+30, 0xb5ae6cb000dde769
+31, 0x774315003209017
+32, 0xa2013397ba8db605
+33, 0x73b228945dbcd957
+34, 0x801af7190375d3c0
+35, 0xae6dca29f24c9c67
+36, 0xd1cc0bcb1ca26249
+37, 0x1defa62a5bd853be
+38, 0x67c2f5557fa89462
+39, 0xf1729b58122fab02
+40, 0xb67eb71949ec6c42
+41, 0x5456366ec1f8f7d7
+42, 0x44492b32eb7966f5
+43, 0xa801804159f175f1
+44, 0x5a416f23cac70d84
+45, 0x186f55293302303d
+46, 0x7339d5d7b6a43639
+47, 0xfc6df38d6a566121
+48, 0xed2fe018f150b39e
+49, 0x508e0b04a781fa1b
+50, 0x8bee9d50f32eaf50
+51, 0x9870015d37e63cc
+52, 0x93c6b12309c14f2d
+53, 0xb571cf798abe93ff
+54, 0x85c35a297a88ae6e
+55, 0x9b1b79afe497a2ae
+56, 0x1ca02e5b95d96b8d
+57, 0x5bb695a666c0a94a
+58, 0x4e3caf9bbab0b208
+59, 0x44a44be1a89f2dc1
+60, 0x4ff37c33445758d1
+61, 0xd0e02875322f35da
+62, 0xfd449a91fb92646b
+63, 0xbe0b49096b95db4d
+64, 0xffa3647cad13ef5d
+65, 0x75c127a61acd10c8
+66, 0xd65f697756f5f98e
+67, 0x3ced84be93d94434
+68, 0x4da3095c2fc46d68
+69, 0x67564e2a771ee9ac
+70, 0x36944775180644a9
+71, 0xf458db1c177cdb60
+72, 0x5b58406dcd034c8
+73, 0x793301a3fdab2a73
+74, 0x1c2a1a16d6db6128
+75, 0xc2dacd4ddddbe56c
+76, 0x2e7d15be2301a111
+77, 0xd4f4a6341b3bcd18
+78, 0x3622996bbe6a9e3b
+79, 0xaf29aa9a7d6d47da
+80, 0x6d7dbb74a4cd68ae
+81, 0xc260a17e0f39f841
+82, 0xdee0170f2af66f0d
+83, 0xf84ae780d7b5a06e
+84, 0x8326247b73f43c3a
+85, 0xd44eef44b4f98b84
+86, 0x3d10aee62ec895e3
+87, 0x4f23fef01bf703b3
+88, 0xf8e50aa57d888df6
+89, 0x7da67411e3bef261
+90, 0x1d00f2769b2f96d7
+91, 0x7ef9a15b7444b84e
+92, 0xcfa16436cc2b7e21
+93, 0x29ab8cfac00460ff
+94, 0x23613de8608b0e70
+95, 0xb1aa0980625798a8
+96, 0xb9256fd29db7df99
+97, 0xdacf311bf3e7fa18
+98, 0xa013c8f9fada20d8
+99, 0xaf5fd4fe8230fe3e
+100, 0xd3d59ca55102bc5c
+101, 0x9d08e2aa5242767f
+102, 0x40278fe131e83b53
+103, 0x56397d03c7c14c98
+104, 0xe874b77b119359b3
+105, 0x926a1ba4304ab19f
+106, 0x1e115d5aa695a91d
+107, 0xc6a459df441f2fe3
+108, 0x2ca842bc1b0b3c6a
+109, 0x24c804cf8e5eed16
+110, 0x7ca00fc4a4c3ebd3
+111, 0x546af7cecc4a4ba6
+112, 0x8faae1fa18fd6e3
+113, 0x40420b0089641a6a
+114, 0x88175a35d9abcb83
+115, 0xf7d746d1b8b1357c
+116, 0x7dae771a651be970
+117, 0x2f6485247ee4df84
+118, 0x6883702fab2d8ec5
+119, 0xeb7eea829a67f9a6
+120, 0x60d5880b485562ed
+121, 0x7d4ca3d7e41a4e7e
+122, 0xbb7fef961ab8de18
+123, 0x3b92452fb810c164
+124, 0x5f4b4755348b338
+125, 0xca45a715a7539806
+126, 0xc33efd9da5399dd
+127, 0x593d665a51d4aedd
+128, 0x75d6b8636563036b
+129, 0x7b57caa55e262082
+130, 0x4ede7427969e0dd5
+131, 0xc3f19b6f78ea00b
+132, 0xeea7bab9be2181ea
+133, 0x652c45fe9c420c04
+134, 0x14ba9e3d175670ee
+135, 0xd2ad156ba6490474
+136, 0x4d65ae41065f614
+137, 0x6ff911c8afa28eb1
+138, 0xedc2b33588f3cb68
+139, 0x437c8bc324666a2f
+140, 0x828cee25457a3f0
+141, 0x530c986091f31b9b
+142, 0x2f34671e8326ade7
+143, 0x4f686a8f4d77f6da
+144, 0xa4c1987083498895
+145, 0xbce5a88b672b0fb1
+146, 0x8476115a9e6a00cc
+147, 0x16de18a55dd2c238
+148, 0xdf38cf4c416232bc
+149, 0x2cb837924e7559f3
+150, 0xfad4727484e982ed
+151, 0x32a55d4b7801e4f
+152, 0x8b9ef96804bd10a5
+153, 0xa1fd422c9b5cf2a9
+154, 0xf46ddb122eb7e442
+155, 0x6e3842547afa3b33
+156, 0x863dee1c34afe5c4
+157, 0x6a43a1935b6db171
+158, 0x1060a5c2f8145821
+159, 0xf783ec9ed34c4607
+160, 0x1da4a86bf5f8c0b0
+161, 0x4c7714041ba12af8
+162, 0x580da7010be2f192
+163, 0xad682fe795a7ea7a
+164, 0x6687b6cb88a9ed2c
+165, 0x3c8d4b175517cd18
+166, 0xe9247c3a524a6b6b
+167, 0x337ca9cfaa02658
+168, 0xed95399481c6feec
+169, 0x58726a088e606062
+170, 0xfe7588a5b4ee342a
+171, 0xee434c7ed146fdee
+172, 0xe2ade8b60fdc4ba5
+173, 0xd57e4c155de4eaab
+174, 0xdefeae12de1137cb
+175, 0xb7a276a241316ac1
+176, 0xeb838b1b1df4ca15
+177, 0x6f78965edea32f6f
+178, 0x18bebd264d7a5d53
+179, 0x3641c691d77005ec
+180, 0xbe70ed7efea8c24c
+181, 0x33047fa8d03ca560
+182, 0x3bed0d2221ff0f87
+183, 0x23083a6ffbcf38a2
+184, 0xc23eb827073d3fa5
+185, 0xc873bb3415e9fb9b
+186, 0xa4645179e54147fe
+187, 0x2c72fb443f66e207
+188, 0x98084915dd89d8f4
+189, 0x88baa2de12c99037
+190, 0x85c74ab238cb795f
+191, 0xe122186469ea3a26
+192, 0x4c3bba99b3249292
+193, 0x85d6845d9a015234
+194, 0x147ddd69c13e6a31
+195, 0x255f4d678c9a570b
+196, 0x2d7c0c410bf962b4
+197, 0x58eb7649e0aa16ca
+198, 0x9d240bf662fe0783
+199, 0x5f74f6fa32d293cc
+200, 0x4928e52f0f79d9b9
+201, 0xe61c2b87146b706d
+202, 0xcfcd90d100cf5431
+203, 0xf15ea8138e6aa178
+204, 0x6ab8287024f9a819
+205, 0xed8942593db74e01
+206, 0xefc00e4ec2ae36dd
+207, 0xc21429fb9387f334
+208, 0xf9a3389e285a9bce
+209, 0xacdee8c43aae49b3
+210, 0xefc382f02ad55c25
+211, 0x1153b50e8d406b72
+212, 0xb00d39ebcc2f89d8
+213, 0xde62f0b9831c8850
+214, 0xc076994662eef6c7
+215, 0x66f08f4752f1e3ef
+216, 0x283b90619796249a
+217, 0x4e4869bc4227499e
+218, 0xb45ad78a49efd7ed
+219, 0xffe19aa77abf5f4b
+220, 0xfce11a0daf913aef
+221, 0x7e4e64450d5cdceb
+222, 0xe9621997cfd62762
+223, 0x4d2c9e156868081
+224, 0x4e2d96eb7cc9a08
+225, 0xda74849bba6e3bd3
+226, 0x6f4621da935e7fde
+227, 0xb94b914aa0497259
+228, 0xd50d03e8b8db1563
+229, 0x1a45c1ce5dca422e
+230, 0xc8d30d33276f843f
+231, 0xb57245774e4176b4
+232, 0x8d36342c05abbbb1
+233, 0x3591ad893ecf9e78
+234, 0x62f4717239ee0ac8
+235, 0x9b71148a1a1d4200
+236, 0x65f8e0f56dd94463
+237, 0x453b1fcfd4fac8c2
+238, 0x4c25e48e54a55865
+239, 0xa866baa05112ace2
+240, 0x7741d3c69c6e79c5
+241, 0x7deb375e8f4f7a8a
+242, 0xc242087ede42abd8
+243, 0x2fa9d1d488750c4b
+244, 0xe8940137a935d3d3
+245, 0x1dab4918ca24b2f2
+246, 0xe2368c782168fe3e
+247, 0x6e8b2d1d73695909
+248, 0x70455ebea268b33e
+249, 0x656a919202e28da1
+250, 0x5a5a8935647da999
+251, 0x428c6f77e118c13c
+252, 0xa87aee2b675bb083
+253, 0x3873a6412b239969
+254, 0x5f72c1e91cb8a2ee
+255, 0xa25af80a1beb5679
+256, 0x1af65d27c7b4abc3
+257, 0x133437060670e067
+258, 0xb1990fa39a97d32e
+259, 0x724adc89ae10ed17
+260, 0x3f682a3f2363a240
+261, 0x29198f8dbd343499
+262, 0xdfaeeaa42bc51105
+263, 0x5baff3901b9480c2
+264, 0x3f760a67043e77f5
+265, 0x610fa7aa355a43ba
+266, 0x394856ac09c4f7a7
+267, 0x1d9229d058aee82e
+268, 0x19c674804c41aeec
+269, 0x74cf12372012f4aa
+270, 0xa5d89b353fa2f6ca
+271, 0x697e4f672ac363dd
+272, 0xde6f55ba73df5af9
+273, 0x679cf537510bd68f
+274, 0x3dc916114ae9ef7e
+275, 0xd7e31a66ec2ee7ba
+276, 0xc21bebb968728495
+277, 0xc5e0781414e2adfd
+278, 0x71147b5412ddd4bd
+279, 0x3b864b410625cca9
+280, 0x433d67c0036cdc6
+281, 0x48083afa0ae20b1b
+282, 0x2d80beecd64ac4e8
+283, 0x2a753c27c3a3ee3e
+284, 0xb2c5e6afd1fe051a
+285, 0xea677930cd66c46b
+286, 0x4c3960932f92810a
+287, 0xf1b367a9e527eaba
+288, 0xb7d92a8a9a69a98e
+289, 0x9f9ad3210bd6b453
+290, 0x817f2889db2dcbd8
+291, 0x4270a665ac15813c
+292, 0x90b85353bd2be4dd
+293, 0x10c0460f7b2d68d
+294, 0x11cef32b94f947f5
+295, 0x3cf29ed8e7d477e8
+296, 0x793aaa9bd50599ef
+297, 0xbac15d1190014aad
+298, 0x987944ae80b5cb13
+299, 0x460aa51f8d57c484
+300, 0xc77df0385f97c2d3
+301, 0x92e743b7293a3822
+302, 0xbc3458bcfbcbb8c0
+303, 0xe277bcf3d04b4ed7
+304, 0xa537ae5cf1c9a31c
+305, 0x95eb00d30bd8cfb2
+306, 0x6376361c24e4f2dd
+307, 0x374477fe87b9ea8e
+308, 0x8210f1a9a039902e
+309, 0xe7628f7031321f68
+310, 0x8b8e9c0888fc1d3d
+311, 0x306be461fdc9e0ed
+312, 0x510009372f9b56f5
+313, 0xa6e6fa486b7a027a
+314, 0x9d3f002025203b5a
+315, 0x7a46e0e81ecbef86
+316, 0x41e280c611d04df0
+317, 0xedcec10418a99e8a
+318, 0x5c27b6327e0b9dbd
+319, 0xa81ed2035b509f07
+320, 0x3581e855983a4cc4
+321, 0x4744594b25e9809d
+322, 0xc737ac7c27fbd0ed
+323, 0x1b523a307045433a
+324, 0x8b4ce9171076f1d9
+325, 0x2db02d817cd5eec0
+326, 0x24a1f1229af50288
+327, 0x5550c0dcf583ff16
+328, 0x3587baaa122ec422
+329, 0xf9d3dc894229e510
+330, 0xf3100430d5cf8e87
+331, 0xc31af79862f8e2fb
+332, 0xd20582063b9f3537
+333, 0xac5e90ac95fcc7ad
+334, 0x107c4c704d5109d4
+335, 0xebc8628906dbfd70
+336, 0x215242776da8c531
+337, 0xa98002f1dcf08b51
+338, 0xbc3bdc07f3b09718
+339, 0x238677062495b512
+340, 0x53b4796f2a3c49e8
+341, 0x6424286467e22f0e
+342, 0x14d0952a11a71bac
+343, 0x2f97098149b82514
+344, 0x3777f2fdc425ad2
+345, 0xa32f2382938876d4
+346, 0xda8a39a021f20ae3
+347, 0x364361ef0a6ac32c
+348, 0x4413eede008ff05a
+349, 0x8dda8ace851aa327
+350, 0x4303cabbdcecd1ee
+351, 0x2e69f06d74aa549f
+352, 0x4797079cd4d9275c
+353, 0xc7b1890917e98307
+354, 0x34031b0e822a4b4c
+355, 0xfc79f76b566303ea
+356, 0x77014adbe255a930
+357, 0xab6c43dd162f3be5
+358, 0xa430041f3463f6b9
+359, 0x5c191a32ada3f84a
+360, 0xe8674a0781645a31
+361, 0x3a11cb667b8d0916
+362, 0xaedc73e80c39fd8a
+363, 0xfde12c1b42328765
+364, 0x97abb7dcccdc1a0b
+365, 0x52475c14d2167bc8
+366, 0x540e8811196d5aff
+367, 0xa867e4ccdb2b4b77
+368, 0x2be04af61e5bcfb9
+369, 0x81b645102bfc5dfd
+370, 0x96a52c9a66c6450f
+371, 0x632ec2d136889234
+372, 0x4ed530c0b36a6c25
+373, 0x6f4851225546b75
+374, 0x2c065d6ba46a1144
+375, 0xf8a3613ff416551d
+376, 0xb5f0fd60e9c971a9
+377, 0x339011a03bb4be65
+378, 0x9439f72b6995ded6
+379, 0xc1b03f3ef3b2292d
+380, 0xad12fd221daab3ae
+381, 0xf615b770f2cf996f
+382, 0x269d0fdcb764172
+383, 0x67837025e8039256
+384, 0x6402831fc823fafa
+385, 0x22854146a4abb964
+386, 0x7b5ad9b5a1bad7a8
+387, 0x67170e7beb6ac935
+388, 0xfc2d1e8e24adfaaa
+389, 0x7ded4395345ff40d
+390, 0x418981760a80dd07
+391, 0xc03bef38022c1d2
+392, 0x3a11850b26eade29
+393, 0xaa56d02c7175c5f4
+394, 0xd83b7917b9bfbff5
+395, 0x3c1df2f8fa6fced3
+396, 0xf3d6e2999c0bb760
+397, 0xc66d683a59a950e3
+398, 0x8e3972a9d73ffabf
+399, 0x97720a0443edffd9
+400, 0xa85f5d2fe198444a
+401, 0xfc5f0458e1b0de5e
+402, 0xe3973f03df632b87
+403, 0xe151073c84c594b3
+404, 0x68eb4e22e7ff8ecf
+405, 0x274f36eaed7cae27
+406, 0x3b87b1eb60896b13
+407, 0xbe0b2f831442d70a
+408, 0x2782ed7a48a1b328
+409, 0xb3619d890310f704
+410, 0xb03926b11b55921a
+411, 0xdb46fc44aa6a0ce4
+412, 0x4b063e2ef2e9453a
+413, 0xe1584f1aeec60fb5
+414, 0x7092bd6a879c5a49
+415, 0xb84e1e7c7d52b0e6
+416, 0x29d09ca48db64dfb
+417, 0x8f6c4a402066e905
+418, 0x77390795eabc36b
+419, 0xcc2dc2e4141cc69f
+420, 0x2727f83beb9e3c7c
+421, 0x1b29868619331de0
+422, 0xd38c571e192c246f
+423, 0x535327479fe37b6f
+424, 0xaff9ce5758617eb3
+425, 0x5658539e9288a4e4
+426, 0x8df91d87126c4c6d
+427, 0xe931cf8fdba6e255
+428, 0x815dfdf25fbee9e8
+429, 0x5c61f4c7cba91697
+430, 0xdd5f5512fe2313a1
+431, 0x499dd918a92a53cd
+432, 0xa7e969d007c97dfd
+433, 0xb8d39c6fc81ac0bb
+434, 0x1d646983def5746c
+435, 0x44d4b3b17432a60c
+436, 0x65664232a14db1e3
+437, 0xda8fae6433e7500b
+438, 0xbe51b94ff2a3fe94
+439, 0xe9b1bd9a9098ef9f
+440, 0xfe47d54176297ef5
+441, 0xb8ab99bc03bb7135
+442, 0xcfad97f608565b38
+443, 0xf05da71f6760d9c1
+444, 0xef8da40a7c70e7b
+445, 0xe0465d58dbd5d138
+446, 0xb54a2d70eb1a938
+447, 0xfdd50c905958f2d8
+448, 0x3c41933c90a57d43
+449, 0x678f6d894c6ad0bb
+450, 0x403e8f4582274e8
+451, 0x5cbbe975668df6b0
+452, 0x297e6520a7902f03
+453, 0x8f6dded33cd1efd7
+454, 0x8e903c97be8d783b
+455, 0x10bd015577e30f77
+456, 0x3fcd69d1c36eab0c
+457, 0xb45989f3ca198d3
+458, 0x507655ce02b491a9
+459, 0xa92cf99bb78602ce
+460, 0xebfb82055fbc2f0f
+461, 0x3334256279289b7a
+462, 0xc19d2a0f740ee0ac
+463, 0x8bb070dea3934905
+464, 0xa4ab57d3a8d1b3eb
+465, 0xfee1b09bcacf7ff4
+466, 0xccc7fb41ceec41fa
+467, 0xd4da49094eb5a74d
+468, 0xed5c693770af02ed
+469, 0x369dabc9bbfaa8e4
+470, 0x7eab9f360d054199
+471, 0xe36dbebf5ee94076
+472, 0xd30840e499b23d7
+473, 0x8678e6cb545015ff
+474, 0x3a47932ca0b336e
+475, 0xeb7c742b6e93d6fe
+476, 0x1404ea51fe5a62a9
+477, 0xa72cd49db978e288
+478, 0xfd7bada020173dcf
+479, 0xc9e74fc7abe50054
+480, 0x93197847bb66808d
+481, 0x25fd5f053dce5698
+482, 0xe198a9b18cc21f4
+483, 0x5cc27b1689452d5d
+484, 0x8b3657af955a98dc
+485, 0xc17f7584f54aa1c0
+486, 0xe821b088246b1427
+487, 0x32b5a9f6b45b6fa0
+488, 0x2aef7c315c2bae0c
+489, 0xe1af8129846b705a
+490, 0x4123b4c091b34614
+491, 0x6999d61ec341c073
+492, 0x14b9a8fcf86831ea
+493, 0xfd4cff6548f46c9f
+494, 0x350c3b7e6cc8d7d6
+495, 0x202a5047fecafcd5
+496, 0xa82509fe496bb57d
+497, 0x835e4b2608b575fe
+498, 0xf3abe3da919f54ec
+499, 0x8705a21e2c9b8796
+500, 0xfd02d1427005c314
+501, 0xa38458faa637f49b
+502, 0x61622f2360e7622a
+503, 0xe89335a773c2963b
+504, 0x481264b659b0e0d0
+505, 0x1e82ae94ebf62f15
+506, 0x8ea7812de49209d4
+507, 0xff963d764680584
+508, 0x418a68bef717f4af
+509, 0x581f0e7621a8ab91
+510, 0x840337e9a0ec4150
+511, 0x951ef61b344be505
+512, 0xc8b1b899feb61ec2
+513, 0x8b78ca13c56f6ed9
+514, 0x3d2fd793715a946f
+515, 0xf1c04fabcd0f4084
+516, 0x92b602614a9a9fcc
+517, 0x7991bd7a94a65be7
+518, 0x5dead10b06cad2d7
+519, 0xda7719b33f722f06
+520, 0x9d87a722b7bff71e
+521, 0xb038e479071409e9
+522, 0xf4e8bbec48054775
+523, 0x4fec2cd7a28a88ea
+524, 0x839e28526aad3e56
+525, 0xd37ec57852a98bf0
+526, 0xdef2cbbe00f3a02d
+527, 0x1aecfe01a9e4d801
+528, 0x59018d3c8beaf067
+529, 0x892753e6ac8bf3cd
+530, 0xefdd3437023d2d1c
+531, 0x447bfbd148c8cb88
+532, 0x282380221bd442b8
+533, 0xfce8658d1347384a
+534, 0x60b211a7ec6bfa8
+535, 0xd21729cfcc692974
+536, 0x162087ecd5038a47
+537, 0x2b17000c4bce39d2
+538, 0x3a1f75ff6adcdce0
+539, 0x721a411d312f1a2c
+540, 0x9c13b6133f66934d
+541, 0xaa975d14978980e5
+542, 0x9403dbd4754203fa
+543, 0x588c15762fdd643
+544, 0xdd1290f8d0ada73a
+545, 0xd9b77380936103f4
+546, 0xb2e2047a356eb829
+547, 0x7019e5e7f76f7a47
+548, 0x3c29a461f62b001d
+549, 0xa07dc6cfab59c116
+550, 0x9b97e278433f8eb
+551, 0x6affc714e7236588
+552, 0x36170aeb32911a73
+553, 0x4a665104d364a789
+554, 0x4be01464ec276c9c
+555, 0x71bb10271a8b4ecf
+556, 0xbf62e1d068bc018
+557, 0xc9ada5db2cbbb413
+558, 0x2bded75e726650e5
+559, 0x33d5a7af2f34385d
+560, 0x8179c46661d85657
+561, 0x324ebcfd29267359
+562, 0xac4c9311dc9f9110
+563, 0xc14bb6a52f9f9c0
+564, 0xc430abe15e7fb9db
+565, 0xf1cce5c14df91c38
+566, 0x651e3efa2c0750d3
+567, 0x38a33604a8be5c75
+568, 0x7aaf77fe7ff56a49
+569, 0xc0d1cc56bbf27706
+570, 0x887aa47324e156c6
+571, 0x12547c004b085e8d
+572, 0xd86a8d6fbbbfd011
+573, 0x57c860188c92d7b4
+574, 0xcd5d3843d361b8ca
+575, 0x8f586ef05a9cb3ef
+576, 0x174456e1ba6267d5
+577, 0xf5dc302c62fe583c
+578, 0xa349442fabcdb71
+579, 0xe5123c1a8b6fd08e
+580, 0x80681552aa318593
+581, 0xb295396deaef1e31
+582, 0xabb626e0b900e32b
+583, 0xf024db8d3f19c15e
+584, 0x1d04bb9548e2fb6c
+585, 0xd8ed2b2214936c2b
+586, 0x618ca1e430a52bc9
+587, 0xccbca44a6088136b
+588, 0xd0481855c8b9ccbe
+589, 0x3c92a2fade28bdf7
+590, 0x855e9fefc38c0816
+591, 0x1269bbfe55a7b27c
+592, 0x1d6c853d83726d43
+593, 0xc8655511cc7fcafc
+594, 0x301503eb125a9b0e
+595, 0xb3108e4532016b11
+596, 0xbb7ab6245da9cb3d
+597, 0x18004c49116d85eb
+598, 0x3480849c20f61129
+599, 0xe28f45157463937b
+600, 0x8e85e61060f2ce1
+601, 0x1673da4ec589ba5e
+602, 0x74b9a6bd1b194712
+603, 0xed39e147fa8b7601
+604, 0x28ce54019102ca77
+605, 0x42e0347f6d7a2f30
+606, 0xb6a908d1c4814731
+607, 0x16c3435e4e9a126d
+608, 0x8880190514c1ad54
+609, 0xfffd86229a6f773c
+610, 0x4f2420cdb0aa1a93
+611, 0xf8e1acb4120fc1fa
+612, 0x63a8c553ab36a2f2
+613, 0x86b88cf3c0a6a190
+614, 0x44d8b2801622c792
+615, 0xf6eae14e93082ff1
+616, 0xd9ed4f5d1b8fac61
+617, 0x1808ce17f4e1f70
+618, 0x446e83ea336f262f
+619, 0xc7c802b04c0917b7
+620, 0x626f45fd64968b73
+621, 0x9ffa540edc9b2c5c
+622, 0xa96a1e219e486af8
+623, 0x2bb8963884e887a1
+624, 0xba7f68a5d029e3c4
+625, 0xefc45f44392d9ca0
+626, 0x98d77762503c5eab
+627, 0xd89bcf62f2da627c
+628, 0xa3cab8347f833151
+629, 0xa095b7595907d5c7
+630, 0x3b3041274286181
+631, 0xb518db8919eb71fa
+632, 0x187036c14fdc9a36
+633, 0xd06e28301e696f5d
+634, 0xdbc71184e0c56492
+635, 0xfe51e9cae6125bfd
+636, 0x3b12d17cd014df24
+637, 0x3b95e4e2c986ac1a
+638, 0x29c1cce59fb2dea2
+639, 0x58c05793182a49d6
+640, 0xc016477e330d8c00
+641, 0x79ef335133ada5d
+642, 0x168e2cad941203f3
+643, 0xf99d0f219d702ef0
+644, 0x655628068f8f135b
+645, 0xdcdea51910ae3f92
+646, 0x8e4505039c567892
+647, 0x91a9ec7e947c89ae
+648, 0x8717172530f93949
+649, 0x1c80aba9a440171a
+650, 0x9c8f83f6ebe7441e
+651, 0x6c05e1efea4aa7f9
+652, 0x10af696b777c01b
+653, 0x5892e9d9a92fc309
+654, 0xd2ba7da71e709432
+655, 0x46378c7c3269a466
+656, 0x942c63dfe18e772c
+657, 0x6245cf02ef2476f
+658, 0x6f265b2759ea2aea
+659, 0x5aa757f17d17f4a6
+660, 0x1ad6a3c44fa09be6
+661, 0xe861af14e7015fb8
+662, 0x86be2e7db388c77
+663, 0x5c7bba32b519e9a0
+664, 0x3feb314850c4437b
+665, 0x97955add60cfb45b
+666, 0xfdb536230a540bdc
+667, 0xdac9d7bf6e58512e
+668, 0x4894c00e474e8120
+669, 0xa1918a37739da366
+670, 0xa8097f2096532807
+671, 0x592afe50e6c5e643
+672, 0xd69050ee6dcb33dc
+673, 0xa6956b262dd3c561
+674, 0x1a55c815555e63f7
+675, 0x2ec7fd37516de2bb
+676, 0x8ec251d9c70e76ba
+677, 0x9b76e4abafd2689
+678, 0x9ce3f5c751a57df1
+679, 0x915c4818bf287bc7
+680, 0x2293a0d1fe07c735
+681, 0x7627dcd5d5a66d3d
+682, 0xb5e4f92cc49c7138
+683, 0x6fc51298731d268c
+684, 0xd19800aa95441f87
+685, 0x14f70f31162fa115
+686, 0x41a3da3752936f59
+687, 0xbec0652be95652ee
+688, 0x7aa4bdb1020a290f
+689, 0x4382d0d9bee899ef
+690, 0xe6d988ae4277d6ff
+691, 0xe618088ccb2a32d1
+692, 0x411669dfaa899e90
+693, 0x234e2bf4ba76d9f
+694, 0xe109fe4cb7828687
+695, 0x1fb96b5022b0b360
+696, 0x6b24ad76c061a716
+697, 0x7e1781d4d7ecee15
+698, 0xf20c2dbe82ba38ba
+699, 0xeda8e8ae1d943655
+700, 0xa58d196e2a77eaec
+701, 0x44564765a5995a0b
+702, 0x11902fe871ecae21
+703, 0x2ea60279900e675d
+704, 0x38427227c18a9a96
+705, 0xe0af01490a1b1b48
+706, 0x826f91997e057824
+707, 0x1e57308e6e50451
+708, 0xb42d469bbbfdc350
+709, 0xb9734cff1109c49b
+710, 0x98967559bb9d364f
+711, 0xd6be360041907c12
+712, 0xa86a1279122a1e21
+713, 0x26f99a8527bfc698
+714, 0xfa8b85758f28f5d6
+715, 0xe3057429940806ae
+716, 0x4bee2d7e84f93b2b
+717, 0x948350a76ea506f4
+718, 0xa139154488045e74
+719, 0x8893579ba5e78085
+720, 0x5f21c215c6a9e397
+721, 0x456134f3a59641dc
+722, 0x92c0273f8e97a9c6
+723, 0xd2936c9c3f0c6936
+724, 0xcfa4221e752c4735
+725, 0x28cd5a7457355dca
+726, 0xecdfdde23d90999f
+727, 0x60631b2d494d032b
+728, 0xf67289df269a827f
+729, 0xcbe8011ef0f5b7ef
+730, 0x20eea973c70a84f5
+731, 0xbe1fd200398557ce
+732, 0xd2279ee030191bba
+733, 0xf2bd4291dedaf819
+734, 0xfc6d167dbe8c402
+735, 0x39ac298da5d0044b
+736, 0xceac026f5f561ce
+737, 0x10a5b0bdd8ad60e6
+738, 0xdeb3c626df6d4bcb
+739, 0x3c128962e77ff6ca
+740, 0xc786262e9c67a0e5
+741, 0x4332855b3febcdc0
+742, 0x7bda9724d1c0e020
+743, 0x6a8c93399bc4df22
+744, 0xa9b20100ac707396
+745, 0xa11a3458502c4eb5
+746, 0xb185461c60478941
+747, 0x13131d56195b7ff6
+748, 0x8d55875ddbd4aa1c
+749, 0xc09b67425f469aa5
+750, 0x39e33786cc7594c4
+751, 0x75e96db8e4b08b93
+752, 0xda01cd12a3275d1e
+753, 0x2c49e7822344fab5
+754, 0x9bd5f10612514ca7
+755, 0x1c801a5c828e7332
+756, 0x29797d3f4f6c7b4c
+757, 0xac992715e21e4e53
+758, 0xe40e89ee887ddb37
+759, 0x15189a2b265a783b
+760, 0xa854159a52af5c5
+761, 0xb9d8a5a81c12bead
+762, 0x3240cdc9d59e2a58
+763, 0x1d0b872234cf8e23
+764, 0xc01224cf6ce12cff
+765, 0x2601e9f3905c8663
+766, 0xd4ecf9890168d6b4
+767, 0xa45db796d89bfdd5
+768, 0x9f389406dad64ab4
+769, 0xa5a851adce43ffe3
+770, 0xd0962c41c26e5aa9
+771, 0x8a671679e48510a4
+772, 0xc196dc0924a6bfeb
+773, 0x3ead661043b549cb
+774, 0x51af4ca737d405ac
+775, 0xf4425b5c62275fb6
+776, 0x71e69d1f818c10f5
+777, 0xacaf4af2d3c70162
+778, 0x2e1f1d4fd7524244
+779, 0xe54fdd8f388890e8
+780, 0xfda0d33e84eb2b83
+781, 0x53965c5e392b81da
+782, 0x5c92288267263097
+783, 0xcac1b431c878c66c
+784, 0x36c0e1cf417241c6
+785, 0x5cc4d9cd1a36bf2c
+786, 0x32e4257bb5d3e470
+787, 0x4aecff904adb44fb
+788, 0x4d91a8e0d1d60cac
+789, 0xa3b478388385b038
+790, 0x48d955f24eba70be
+791, 0x310e4deb07f24f68
+792, 0x8853e73b1f30a5a
+793, 0x278aee45c2a65c5
+794, 0xf6932eedbd62fb0b
+795, 0xafb95958c82fafad
+796, 0x78e807c18616c16c
+797, 0xd7abadda7488ed9f
+798, 0x2dd72e2572aa2ae6
+799, 0x6ec3791982c2be09
+800, 0x6865bb314fac478f
+801, 0xa14dc0ce09000d1a
+802, 0xb8081ad134da10f2
+803, 0xc4ac1534aa825ef5
+804, 0xd83aeb48ae2d538f
+805, 0x38052027e3074be4
+806, 0xa9833e06ef136582
+807, 0x4f02d790ec9fd78
+808, 0xec2f60bc711c5bdc
+809, 0x9253b0d12268e561
+810, 0xa8ac607fdd62c206
+811, 0x895e28ebc920289f
+812, 0xe2fd42b154243ac7
+813, 0xc69cac2f776eee19
+814, 0xf4d4ac11db56d0dc
+815, 0xa8d37049b9f39833
+816, 0x75abbf8a196c337c
+817, 0xb115bb76750d27b8
+818, 0x39426d187839154
+819, 0xd488423e7f38bf83
+820, 0xbb92e0c76ecb6a62
+821, 0x3055a018ce39f4e3
+822, 0xc93fe0e907729bfb
+823, 0x65985d17c5863340
+824, 0x2088ae081b2028e1
+825, 0x6e628de873314057
+826, 0x864377cccf573f0e
+827, 0xae03f4c9aa63d132
+828, 0xb1db766d6404c66d
+829, 0xdce5a22414a374b
+830, 0x622155b777819997
+831, 0x69fe96e620371f3c
+832, 0xa9c67dbc326d94fc
+833, 0x932a84ae5dd43bab
+834, 0xe2301a20f6c48c3f
+835, 0x795d2e79c6477300
+836, 0xd8e3e631289521e7
+837, 0xae2684979002dfd6
+838, 0xc9c2392377550f89
+839, 0xa1b0c99d508ef7ec
+840, 0x593aef3c5a5272ec
+841, 0xe32e511a4b7162cd
+842, 0xab3b81655f5a2857
+843, 0x1b535e1a0aaf053e
+844, 0x5b33f56c1b6a07e2
+845, 0x782dc8cfcac4ef36
+846, 0xb3d4f256eecfd202
+847, 0xf73a6598f58c4f7e
+848, 0xd5722189524870ae
+849, 0x707878de6b995fc0
+850, 0xc3eb6ba73e3d7e8a
+851, 0xca75c017655b75a7
+852, 0x1b29369ea3541e5f
+853, 0x352e98858bdb58a3
+854, 0x1e4412d184b6b27d
+855, 0x2d375ba0304b2d17
+856, 0x56c30fce69a5d08e
+857, 0x6b8c2b0c06584bda
+858, 0xde4dfff228c8c91f
+859, 0xb7c9edd574e6287f
+860, 0xf6078281c9fca2b2
+861, 0xb9b9a51de02a2f1e
+862, 0xa411bef31c0103b0
+863, 0xc5facd8fc5e1d7a3
+864, 0x54e631c05ddf7359
+865, 0x815b42b3fd06c474
+866, 0xc9ac07566fda18ec
+867, 0xd84ea62957bd8e15
+868, 0x5575f74b5cfd8803
+869, 0x5779a8d460c2e304
+870, 0xfd6e87e264a85587
+871, 0xa1d674daa320b26d
+872, 0x2c3c3ec64b35afc4
+873, 0x393a274ff03e6935
+874, 0x1f40ecbac52c50ea
+875, 0xc3de64fa324ffc0c
+876, 0x56ae828b7f9deb04
+877, 0xe7c1a77b5c1f2cb3
+878, 0xa4c4aab19ea921cc
+879, 0xec164c238825822c
+880, 0xa6a3304770c03b03
+881, 0x3a63641d5b1e8123
+882, 0x42677be3a54617ef
+883, 0xa2680423e3a200c0
+884, 0x8b17cf75f3f37277
+885, 0xe7ce65a49242be3d
+886, 0x7f85934271323e4b
+887, 0xcfb0f431f79a4fab
+888, 0x392e4041a8505b65
+889, 0xd3e5daf0d8b25ea6
+890, 0x9447eff675d80f53
+891, 0xea27a9d53cfaeea8
+892, 0xe3f2335945a83ba
+893, 0x8875a43ce216413b
+894, 0xe49941f9eabce33e
+895, 0x9357c1296683a5b1
+896, 0xf0f16439e81ee701
+897, 0x3181515295ffd79a
+898, 0x9d7150fffd169ed8
+899, 0x2d6a1d281e255a72
+900, 0x81bf1286fb3a92b6
+901, 0x566d3079b499e279
+902, 0xc7939ca8f047341
+903, 0xb1f8050e7c2d59f6
+904, 0x605701045e7be192
+905, 0x51b73360e8e31a1c
+906, 0x9f4ad54483ba9fe0
+907, 0xd3085b8fcf69d1c8
+908, 0xc3e7475026dc5f0b
+909, 0x5800f8554b157354
+910, 0x37dfdf858cfcd963
+911, 0x3a1fce05ce385072
+912, 0xf495c062645c20c3
+913, 0xdcbeec2c3492c773
+914, 0xc38f427589d1d0b4
+915, 0x681ead60216a8184
+916, 0x4bd569c40cc88c41
+917, 0x49b0d442e130b7a2
+918, 0xee349156b7d1fa3f
+919, 0x2bde2d2db055135b
+920, 0xc6a460d2fbcb2378
+921, 0xd0f170494ff3dbb
+922, 0xb294422492528a23
+923, 0xfc95873c854e7b86
+924, 0x6c9c3ad1797bb19c
+925, 0xe0c06f2aab65062d
+926, 0x58e32ce0f11e3a81
+927, 0xa745fcd729ff5036
+928, 0x599b249b2fc2cdb2
+929, 0x78f23b5b0dd5b082
+930, 0x6de3e957f549ecfc
+931, 0x9d0712fa6d878756
+932, 0x9076e8554e4a413a
+933, 0xf3185818c0294de8
+934, 0x5de7cdf4b455b9b6
+935, 0xb15f6908ed703f7d
+936, 0x98c654dfedc6818
+937, 0x120502ab0e93ae42
+938, 0x67966a98a58dc120
+939, 0x1caa0fc628989482
+940, 0xd8b2c3cd480a8625
+941, 0x85c70071b3aed671
+942, 0xff385f8473714662
+943, 0xe2868e4bf3773b63
+944, 0x96cf8019b279298e
+945, 0x8511cc930bd74800
+946, 0x5312e48fdd55f5ab
+947, 0xfcdae564b52df78d
+948, 0x9eee48373e652176
+949, 0x953788f6bcbc56b0
+950, 0xd1a3855dbd2f6b37
+951, 0x3ad32acf77f4d1e9
+952, 0x917c7be81b003e30
+953, 0x9ce817da1e2e9dfb
+954, 0x2968983db162d44d
+955, 0x1e005decef5828ad
+956, 0xc38fe59d1aa4f3d5
+957, 0xf357f1710dc02f1d
+958, 0x2613912a4c83ec67
+959, 0x832a11470b9a17cb
+960, 0x5e85508a611f0dad
+961, 0x2781131677f59d56
+962, 0xa82358d7d4b0237f
+963, 0xfbf8b3cc030c3af6
+964, 0x68b2f68ac8a55adb
+965, 0x3b6fcf353add0ada
+966, 0xd1956049bcd15bd5
+967, 0x95b76f31c7f98b6d
+968, 0x814b6690df971a84
+969, 0xdcf7959cddd819e4
+970, 0xcf8c72c5d804fc88
+971, 0x56883769c8945a22
+972, 0x1f034652f658cf46
+973, 0x41df1324cda235a1
+974, 0xeccd32524504a054
+975, 0x974e0910a04ec02c
+976, 0x72104507b821f6db
+977, 0x791f8d089f273044
+978, 0xe0f79a4f567f73c3
+979, 0x52fe5bea3997f024
+980, 0x5f8b9b446494f78
+981, 0xfd9f511947059190
+982, 0x3aea9dac6063bce3
+983, 0xbfdae4dfc24aee60
+984, 0xa82cdbbf0a280318
+985, 0xf460aae18d70aa9d
+986, 0x997367cb204a57c4
+987, 0x616e21ab95ba05ef
+988, 0x9bfc93bec116769f
+989, 0x2b2ee27c37a3fa5b
+990, 0xb25c6ed54006ee38
+991, 0xab04d4a5c69e69a5
+992, 0x6d2f6b45f2d8438f
+993, 0x4ad2f32afc82f092
+994, 0x513d718908f709c0
+995, 0x5272aadc4fffca51
+996, 0xeb3f87e66156ef5d
+997, 0xf8a3d5a46a86ba85
+998, 0xdb4548a86f27abfd
+999, 0x57c05f47ff62380d
diff --git a/venv/lib/python3.12/site-packages/numpy/random/tests/data/sfc64-testset-1.csv b/venv/lib/python3.12/site-packages/numpy/random/tests/data/sfc64-testset-1.csv
new file mode 100644
index 00000000..4fffe695
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/random/tests/data/sfc64-testset-1.csv
@@ -0,0 +1,1001 @@
+seed, 0xdeadbeaf
+0, 0xa475f55fbb6bc638
+1, 0xb2d594b6c29d971c
+2, 0x275bc4ece4484fb1
+3, 0x569be72d9b3492fb
+4, 0x89a5bb9b206a670c
+5, 0xd951bfa06afdc3f9
+6, 0x7ee2e1029d52a265
+7, 0x12ef1d4de0cb4d4c
+8, 0x41658ba8f0ef0280
+9, 0x5b650c82e4fe09c5
+10, 0x638a9f3e30ec4e94
+11, 0x147487fb2ba9233e
+12, 0x89ef035603d2d1fb
+13, 0xe66ca57a190e6cbe
+14, 0x330f673740dd61fc
+15, 0xc71d3dce2f8bb34e
+16, 0x3c07c39ff150b185
+17, 0x5df952b6cae8f099
+18, 0x9f09f2b1f0ceac80
+19, 0x19598eee2d0c4c67
+20, 0x64e06483702e0ebd
+21, 0xda04d1fdb545f7fa
+22, 0xf2cf53b61a0c4f9b
+23, 0xf0bb724ce196f66e
+24, 0x71cefde55d9cf0f
+25, 0x6323f62824a20048
+26, 0x1e93604680f14b4e
+27, 0xd9d8fad1d4654025
+28, 0xf4ee25af2e76ca08
+29, 0x6af3325896befa98
+30, 0xad9e43abf5e04053
+31, 0xbf930e318ce09de3
+32, 0x61f9583b4f9ffe76
+33, 0x9b69d0b3d5ec8958
+34, 0xa608f250f9b2ca41
+35, 0x6fdba7073dc2bb5d
+36, 0xa9d57601efea6d26
+37, 0xc24a88a994954105
+38, 0xc728b1f78d88fe5b
+39, 0x88da88c2b083b3b2
+40, 0xa9e27f7303c76cfd
+41, 0xc4c24608c29176eb
+42, 0x5420b58466b972fd
+43, 0xd2018a661b6756c8
+44, 0x7caed83d9573fc7
+45, 0x562a3d81b849a06a
+46, 0x16588af120c21f2c
+47, 0x658109a7e0eb4837
+48, 0x877aabb14d3822e1
+49, 0x95704c342c3745fe
+50, 0xeeb8a0dc81603616
+51, 0x431bf94889290419
+52, 0xe4a9410ab92a5863
+53, 0xbc6be64ea60f12ba
+54, 0x328a2da920015063
+55, 0x40f6b3bf8271ae07
+56, 0x4068ff00a0e854f8
+57, 0x1b287572ca13fa78
+58, 0xa11624a600490b99
+59, 0x4a04ef29eb7150fa
+60, 0xcc9469ab5ffb739
+61, 0x99a6a9f8d95e782
+62, 0x8e90356573e7a070
+63, 0xa740b8fb415c81c4
+64, 0x47eccef67447f3da
+65, 0x2c720afe3a62a49b
+66, 0xe2a747f0a43eacf4
+67, 0xba063a87ab165576
+68, 0xbc1c78ed27feb5a3
+69, 0x285a19fa3974f9d
+70, 0x489c61e704f5f0e3
+71, 0xf5ab04f6b03f238b
+72, 0x7e25f88138a110dd
+73, 0xc3d1cef3d7c1f1d1
+74, 0xc3de6ec64d0d8e00
+75, 0x73682a15b6cc5088
+76, 0x6fecbeb319163dc5
+77, 0x7e100d5defe570a1
+78, 0xad2af9af076dce57
+79, 0x3c65100e23cd3a9a
+80, 0x4b442cc6cfe521bb
+81, 0xe89dc50f8ab1ef75
+82, 0x8b3c6fdc2496566
+83, 0xdfc50042bc2c308c
+84, 0xe39c5f158b33d2b2
+85, 0x92f6adefdfeb0ac
+86, 0xdf5808a949c85b3e
+87, 0x437384021c9dace9
+88, 0xa7b5ed0d3d67d8f
+89, 0xe1408f8b21da3c34
+90, 0xa1bba125c1e80522
+91, 0x7611dc4710385264
+92, 0xb00a46ea84082917
+93, 0x51bf8002ffa87cef
+94, 0x9bb81013e9810adc
+95, 0xd28f6600013541cd
+96, 0xc2ca3b1fa7791c1f
+97, 0x47f9ad58f099c82c
+98, 0x4d1bb9458469caf9
+99, 0xca0b165b2844257
+100, 0xc3b2e667d075dc66
+101, 0xde22f71136a3dbb1
+102, 0x23b4e3b6f219e4c3
+103, 0x327e0db4c9782f66
+104, 0x9365506a6c7a1807
+105, 0x3e868382dedd3be7
+106, 0xff04fa6534bcaa99
+107, 0x96621a8862995305
+108, 0x81bf39cb5f8e1df7
+109, 0x79b684bb8c37af7a
+110, 0xae3bc073c3cde33c
+111, 0x7805674112c899ac
+112, 0xd95a27995abb20f2
+113, 0x71a503c57b105c40
+114, 0x5ff00d6a73ec8acc
+115, 0x12f96391d91e47c2
+116, 0xd55ca097b3bd4947
+117, 0x794d79d20468b04
+118, 0x35d814efb0d7a07d
+119, 0xfa9ac9bd0aae76d3
+120, 0xa77b8a3711e175cd
+121, 0xe6694fbf421f9489
+122, 0xd8f1756525a1a0aa
+123, 0xe38dfa8426277433
+124, 0x16b640c269bbcd44
+125, 0x2a7a5a67ca24cfeb
+126, 0x669039c28d5344b4
+127, 0x2a445ee81fd596bb
+128, 0x600df94cf25607e0
+129, 0x9358561a7579abff
+130, 0xee1d52ea179fc274
+131, 0x21a8b325e89d31be
+132, 0x36fc0917486eec0a
+133, 0x3d99f40717a6be9f
+134, 0x39ac140051ca55ff
+135, 0xcef7447c26711575
+136, 0xf22666870eff441d
+137, 0x4a53c6134e1c7268
+138, 0xd26de518ad6bdb1b
+139, 0x1a736bf75b8b0e55
+140, 0xef1523f4e6bd0219
+141, 0xb287b32fd615ad92
+142, 0x2583d6af5e841dd5
+143, 0x4b9294aae7ca670c
+144, 0xf5aa4a84174f3ca9
+145, 0x886300f9e0dc6376
+146, 0x3611401e475ef130
+147, 0x69b56432b367e1ac
+148, 0x30c330e9ab36b7c4
+149, 0x1e0e73079a85b8d5
+150, 0x40fdfc7a5bfaecf
+151, 0xd7760f3e8e75a085
+152, 0x1cc1891f7f625313
+153, 0xeece1fe6165b4272
+154, 0xe61111b0c166a3c1
+155, 0x2f1201563312f185
+156, 0xfd10e8ecdd2a57cb
+157, 0x51cdc8c9dd3a89bf
+158, 0xed13cc93938b5496
+159, 0x843816129750526b
+160, 0xd09995cd6819ada
+161, 0x4601e778d40607df
+162, 0xef9df06bd66c2ea0
+163, 0xae0bdecd3db65d69
+164, 0xbb921a3c65a4ae9a
+165, 0xd66698ce8e9361be
+166, 0xacdc91647b6068f4
+167, 0xe505ef68f2a5c1c0
+168, 0xd6e62fd27c6ab137
+169, 0x6a2ba2c6a4641d86
+170, 0x9c89143715c3b81
+171, 0xe408c4e00362601a
+172, 0x986155cbf5d4bd9d
+173, 0xb9e6831728c893a7
+174, 0xb985497c3bf88d8c
+175, 0xd0d729214b727bec
+176, 0x4e557f75fece38a
+177, 0x6572067fdfd623ca
+178, 0x178d49bb4d5cd794
+179, 0xe6baf59f60445d82
+180, 0x5607d53518e3a8d2
+181, 0xba7931adb6ebbd61
+182, 0xe853576172611329
+183, 0xe945daff96000c44
+184, 0x565b9ba3d952a176
+185, 0xcdb54d4f88c584c8
+186, 0x482a7499bee9b5e5
+187, 0x76560dd0affe825b
+188, 0x2a56221faa5ca22c
+189, 0x7729be5b361f5a25
+190, 0xd6f2195795764876
+191, 0x59ef7f8f423f18c5
+192, 0x7ebefed6d02adde1
+193, 0xcfec7265329c73e5
+194, 0x4fd8606a5e59881c
+195, 0x95860982ae370b73
+196, 0xdecfa33b1f902acc
+197, 0xf9b8a57400b7c0a6
+198, 0xd20b822672ec857b
+199, 0x4eb81084096c7364
+200, 0xe535c29a44d9b6ad
+201, 0xdef8b48ebacb2e29
+202, 0x1063bc2b8ba0e915
+203, 0xe4e837fb53d76d02
+204, 0x4df935db53579fb8
+205, 0xa30a0c8053869a89
+206, 0xe891ee58a388a7b5
+207, 0x17931a0c64b8a985
+208, 0xaf2d350b494ce1b3
+209, 0x2ab9345ffbcfed82
+210, 0x7de3fe628a2592f0
+211, 0x85cf54fab8b7e79d
+212, 0x42d221520edab71b
+213, 0x17b695b3af36c233
+214, 0xa4ffe50fe53eb485
+215, 0x1102d242db800e4d
+216, 0xc8dc01f0233b3b6
+217, 0x984a030321053d36
+218, 0x27fa8dc7b7112c0e
+219, 0xba634dd8294e177f
+220, 0xe67ce34b36332eb
+221, 0x8f1351e1894fb41a
+222, 0xb522a3048761fd30
+223, 0xc350ad9bc6729edc
+224, 0xe0ed105bd3c805e1
+225, 0xa14043d2b0825aa7
+226, 0xee7779ce7fc11fdf
+227, 0xc0fa8ba23a60ab25
+228, 0xb596d1ce259afbad
+229, 0xaa9b8445537fdf62
+230, 0x770ab2c700762e13
+231, 0xe812f1183e40cc1
+232, 0x44bc898e57aefbbd
+233, 0xdd8a871df785c996
+234, 0x88836a5e371eb36b
+235, 0xb6081c9152623f27
+236, 0x895acbcd6528ca96
+237, 0xfb67e33ddfbed435
+238, 0xaf7af47d323ce26
+239, 0xe354a510c3c39b2d
+240, 0x5cacdedda0672ba3
+241, 0xa440d9a2c6c22b09
+242, 0x6395099f48d64304
+243, 0xc11cf04c75f655b5
+244, 0x1c4e054d144ddb30
+245, 0x3e0c2db89d336636
+246, 0x127ecf18a5b0b9a7
+247, 0x3b50551a88ea7a73
+248, 0xbd27003e47f1f684
+249, 0xf32d657782baac9b
+250, 0x727f5cabf020bc9
+251, 0x39c1c1c226197dc7
+252, 0x5552c87b35deeb69
+253, 0x64d54067b5ce493f
+254, 0x3494b091fe28dda0
+255, 0xdf0278bc85ee2965
+256, 0xdef16fec25efbd66
+257, 0xe2be09f578c4ce28
+258, 0xd27a9271979d3019
+259, 0x427f6fcd71845e3
+260, 0x26b52c5f81ec142b
+261, 0x98267efc3986ad46
+262, 0x7bf4165ddb7e4374
+263, 0xd05f7996d7941010
+264, 0x3b3991de97b45f14
+265, 0x9068217fb4f27a30
+266, 0xd8fe295160afc7f3
+267, 0x8a159fab4c3bc06f
+268, 0x57855506d19080b6
+269, 0x7636df6b3f2367a4
+270, 0x2844ee3abd1d5ec9
+271, 0xe5788de061f51c16
+272, 0x69e78cc9132a164
+273, 0xacd53cde6d8cd421
+274, 0xb23f3100068e91da
+275, 0x4140070a47f53891
+276, 0xe4a422225a96e53a
+277, 0xb82a8925a272a2ac
+278, 0x7c2f9573590fe3b7
+279, 0xbaf80764db170575
+280, 0x955abffa54358368
+281, 0x355ce7460614a869
+282, 0x3700ede779a4afbf
+283, 0x10a6ec01d92d68cd
+284, 0x3308f5a0a4c0afef
+285, 0x97b892d7601136c9
+286, 0x4955c3b941b8552e
+287, 0xca85aa67e941961d
+288, 0xb1859ae5db28e9d2
+289, 0x305d072ac1521fbd
+290, 0xed52a868996085bb
+291, 0x723bfa6a76358852
+292, 0x78d946ecd97c5fb3
+293, 0x39205b30a8e23e79
+294, 0xb927e3d086baadbe
+295, 0xa18d6946136e1ff5
+296, 0xdab6f0b51c1eb5ff
+297, 0xf0a640bf7a1af60c
+298, 0xf0e81db09004d0d4
+299, 0xfe76cebdbe5a4dde
+300, 0x2dafe9cc3decc376
+301, 0x4c871fdf1af34205
+302, 0xe79617d0c8fa893b
+303, 0xee658aaad3a141f7
+304, 0xfd91aa74863e19f1
+305, 0x841b8f55c103cc22
+306, 0x22766ed65444ad5d
+307, 0x56d03d1beca6c17a
+308, 0x5fd4c112c92036ae
+309, 0x75466ae58a5616dc
+310, 0xfbf98b1081e802a9
+311, 0xdc325e957bf6d8f5
+312, 0xb08da7015ebd19b7
+313, 0xf25a9c0944f0c073
+314, 0xf4625bafa0ced718
+315, 0x4349c9e093a9e692
+316, 0x75a9ccd4dd8935cb
+317, 0x7e6cf9e539361e91
+318, 0x20fdd22fb6edd475
+319, 0x5973021b57c2311f
+320, 0x75392403667edc15
+321, 0xed9b2156ea70d9f1
+322, 0xf40c114db50b64a0
+323, 0xe26bb2c9eef20c62
+324, 0x409c1e3037869f03
+325, 0xcdfd71fdda3b7f91
+326, 0xa0dfae46816777d6
+327, 0xde060a8f61a8deb8
+328, 0x890e082a8b0ca4fc
+329, 0xb9f2958eddf2d0db
+330, 0xd17c148020d20e30
+331, 0xffdc9cc176fe7201
+332, 0xffb83d925b764c1
+333, 0x817ea639e313da8d
+334, 0xa4dd335dd891ca91
+335, 0x1342d25a5e81f488
+336, 0xfa7eb9c3cf466b03
+337, 0xfe0a423d44b185d0
+338, 0x101cfd430ab96049
+339, 0x7b5d3eda9c4504b
+340, 0xe20ccc006e0193f1
+341, 0xf54ccddedebc5df0
+342, 0xc0edd142bd58f1db
+343, 0x3831f40d378d2430
+344, 0x80132353f0a88289
+345, 0x688f23c419d03ef8
+346, 0x4c6837e697884066
+347, 0x699387bb2e9a3a8f
+348, 0x8996f860342448d8
+349, 0xb0f80dff99bfa5cc
+350, 0x3e927a7f9ea12c8e
+351, 0xd7e498d1e5f9dff3
+352, 0x78ecb97bb3f864cc
+353, 0x3c4ffd069a014d38
+354, 0xf8d5073a1e09b4d4
+355, 0x8717e854f9faef23
+356, 0xfbcc5478d8d0ad7
+357, 0xd3cd8b233ca274ff
+358, 0x8bd8f11f79beb265
+359, 0xf64498a832d8fd0e
+360, 0xb01bba75112131ec
+361, 0x55572445a7869781
+362, 0x7b56622f18cb3d7a
+363, 0x7f192c9e075bdb83
+364, 0xd9a112f836b83ff3
+365, 0x68673b37269653dc
+366, 0xe46a9433fb6a0879
+367, 0x127d756ca4779001
+368, 0xc1378e8b1e8eab94
+369, 0x1006edb0f51d078c
+370, 0xc6dd53961232d926
+371, 0x9a4aeef44038256d
+372, 0xd357f4fa652d4f5f
+373, 0x59f3d2cc3378598
+374, 0xe76e6207a824a7fc
+375, 0x5fc5e33712ceffef
+376, 0x77d24aeb0ccb1adc
+377, 0x5be4b2826805659e
+378, 0x257c69d787e64634
+379, 0x58dd52ca6bc727b1
+380, 0x3ab997767235ea33
+381, 0x986a2a7a966fad14
+382, 0xc900f8b27761dcc4
+383, 0x44991bdb13795700
+384, 0xe5c145a4fe733b2
+385, 0x56f041b56bffe0d3
+386, 0x5779c4fef8067996
+387, 0xa0fe8748e829532d
+388, 0x840c1277d78d9dd4
+389, 0x37ebcb315432acbc
+390, 0xf4bc8738433ba3be
+391, 0x8b122993f2e10062
+392, 0xe1fe8481f2681ed5
+393, 0x8e23f1630d9f494a
+394, 0xda24661a01b7d0b3
+395, 0x7a02942a179cee36
+396, 0xf1e08a3c09b71ac
+397, 0x3dec2cc7ee0bd8fd
+398, 0x1f3e480113d805d4
+399, 0xc061b973ad4e3f2c
+400, 0x6bea750f17a66836
+401, 0xbc2add72eac84c25
+402, 0xcff058d3f97934ca
+403, 0x54ccc30987778ec2
+404, 0x93449ec1e1469558
+405, 0xe2ff369eb0c6836
+406, 0x41c2df2d63bf8e55
+407, 0xf9302629b6c71be2
+408, 0xdd30376b8e5ab29a
+409, 0x12db9e04f911d754
+410, 0x8d03d6cd359f1b97
+411, 0xe15956511abf1cee
+412, 0x9b68e10e2c2fd940
+413, 0x2e28de6491c1ce53
+414, 0x52b329b72d0c109d
+415, 0xc2c0b115f9da2a60
+416, 0x6ca084105271bbff
+417, 0x49b92b8676058c1e
+418, 0x767fc92a70f7e5a3
+419, 0x87ba4ed4b65a6aa0
+420, 0xf70b052e0a3975e9
+421, 0x3e925c3306db9eec
+422, 0x43253f1d96ac9513
+423, 0xe3e04f1a1ea454c4
+424, 0x763e3f4cc81ba0c8
+425, 0x2a2721ac69265705
+426, 0xdf3b0ac6416ea214
+427, 0xa6a6b57450f3e000
+428, 0xc3d3b1ac7dbfe6ac
+429, 0xb66e5e6f7d2e4ec0
+430, 0x43c65296f98f0f04
+431, 0xdb0f6e3ff974d842
+432, 0x3d6b48e02ebb203b
+433, 0xd74674ebf09d8f27
+434, 0xbe65243c58fc1200
+435, 0x55eb210a68d42625
+436, 0x87badab097dbe883
+437, 0xada3fda85a53824f
+438, 0xef2791e8f48cd37a
+439, 0x3fe7fceb927a641a
+440, 0xd3bffd3ff031ac78
+441, 0xb94efe03da4d18fb
+442, 0x162a0ad8da65ea68
+443, 0x300f234ef5b7e4a6
+444, 0xa2a8b4c77024e4fb
+445, 0x5950f095ddd7b109
+446, 0xded66dd2b1bb02ba
+447, 0x8ec24b7fa509bcb6
+448, 0x9bede53d924bdad6
+449, 0xa9c3f46423be1930
+450, 0x6dfc90597f8de8b4
+451, 0xb7419ebc65b434f0
+452, 0xa6596949238f58b9
+453, 0x966cbade640829b8
+454, 0x58c74877bdcbf65e
+455, 0xaa103b8f89b0c453
+456, 0x219f0a86e41179a4
+457, 0x90f534fc06ddc57f
+458, 0x8db7cdd644f1affa
+459, 0x38f91de0167127ac
+460, 0xdcd2a65e4df43daa
+461, 0x3e04f34a7e01f834
+462, 0x5b237eea68007768
+463, 0x7ff4d2b015921768
+464, 0xf786b286549d3d51
+465, 0xaefa053fc2c3884c
+466, 0x8e6a8ff381515d36
+467, 0x35b94f3d0a1fce3c
+468, 0x165266d19e9abb64
+469, 0x1deb5caa5f9d8076
+470, 0x13ab91290c7cfe9d
+471, 0x3651ca9856be3e05
+472, 0xe7b705f6e9cccc19
+473, 0xd6e7f79668c127ed
+474, 0xa9faf37154896f92
+475, 0x89fbf190603e0ab1
+476, 0xb34d155a86f942d0
+477, 0xb2d4400a78bfdd76
+478, 0x7c0946aca8cfb3f0
+479, 0x7492771591c9d0e8
+480, 0xd084d95c5ca2eb28
+481, 0xb18d12bd3a6023e
+482, 0xea217ed7b864d80b
+483, 0xe52f69a755dd5c6f
+484, 0x127133993d81c4aa
+485, 0xe07188fcf1670bfb
+486, 0x178fbfe668e4661d
+487, 0x1c9ee14bb0cda154
+488, 0x8d043b96b6668f98
+489, 0xbc858986ec96ca2b
+490, 0x7660f779d528b6b7
+491, 0xd448c6a1f74ae1d3
+492, 0x178e122cfc2a6862
+493, 0x236f000abaf2d23b
+494, 0x171b27f3f0921915
+495, 0x4c3ff07652f50a70
+496, 0x18663e5e7d3a66ca
+497, 0xb38c97946c750cc9
+498, 0xc5031aae6f78f909
+499, 0x4d1514e2925e95c1
+500, 0x4c2184a741dabfbb
+501, 0xfd410364edf77182
+502, 0xc228157f863ee873
+503, 0x9856fdc735cc09fc
+504, 0x660496cd1e41d60e
+505, 0x2edf1d7e01954c32
+506, 0xd32e94639bdd98cf
+507, 0x8e153f48709a77d
+508, 0x89357f332d2d6561
+509, 0x1840d512c97085e6
+510, 0x2f18d035c9e26a85
+511, 0x77b88b1448b26d5b
+512, 0xc1ca6ef4cdae0799
+513, 0xcc203f9e4508165f
+514, 0xeaf762fbc9e0cbbe
+515, 0xc070c687f3c4a290
+516, 0xd49ed321068d5c15
+517, 0x84a55eec17ee64ee
+518, 0x4d8ee685298a8871
+519, 0x9ff5f17d7e029793
+520, 0x791d7d0d62e46302
+521, 0xab218b9114e22bc6
+522, 0x4902b7ab3f7119a7
+523, 0x694930f2e29b049e
+524, 0x1a3c90650848999f
+525, 0x79f1b9d8499c932b
+526, 0xfacb6d3d55e3c92f
+527, 0x8fd8b4f25a5da9f5
+528, 0xd037dcc3a7e62ae7
+529, 0xfecf57300d8f84f4
+530, 0x32079b1e1dc12d48
+531, 0xe5f8f1e62b288f54
+532, 0x97feba3a9c108894
+533, 0xd279a51e1899a9a0
+534, 0xd68eea8e8e363fa8
+535, 0x7394cf2deeca9386
+536, 0x5f70b0c80f1dbf10
+537, 0x8d646916ed40462
+538, 0xd253bb1c8a12bbb6
+539, 0x38f399a821fbd73e
+540, 0x947523a26333ac90
+541, 0xb52e90affbc52a37
+542, 0xcf899cd964654da4
+543, 0xdf66ae9cca8d99e7
+544, 0x6051478e57c21b6a
+545, 0xffa7dc975af3c1da
+546, 0x195c7bff2d1a8f5
+547, 0x64f12b6575cf984d
+548, 0x536034cb842cf9e1
+549, 0x180f247ce5bbfad
+550, 0x8ced45081b134867
+551, 0x532bbfdf426710f3
+552, 0x4747933e74c4f54d
+553, 0x197a890dc4793401
+554, 0x76c7cc2bd42fae2
+555, 0xdabfd67f69675dd0
+556, 0x85c690a68cdb3197
+557, 0xe482cec89ce8f92
+558, 0x20bc9fb7797011b1
+559, 0x76dc85a2185782ad
+560, 0x3df37c164422117a
+561, 0x99211f5d231e0ab0
+562, 0xef7fd794a0a91f4
+563, 0x419577151915f5fe
+564, 0x3ce14a0a7135dae3
+565, 0x389b57598a075d6a
+566, 0x8cc2a9d51b5af9aa
+567, 0xe80a9beffbd13f13
+568, 0x65e96b22ea8a54d8
+569, 0x79f38c4164138ede
+570, 0xd1955846cba03d81
+571, 0x60359fe58e4f26d6
+572, 0x4ea724f585f8d13e
+573, 0x316dfdbadc801a3c
+574, 0x20aa29b7c6dd66fe
+575, 0x65eaf83a6a008caa
+576, 0x407000aff1b9e8cb
+577, 0xb4d49bfb2b268c40
+578, 0xd4e6fe8a7a0f14a9
+579, 0xe34afef924e8f58e
+580, 0xe377b0c891844824
+581, 0x29c2e20c112d30c8
+582, 0x906aad1fe0c18a95
+583, 0x308385f0efbb6474
+584, 0xf23900481bf70445
+585, 0xfdfe3ade7f937a55
+586, 0xf37aae71c33c4f97
+587, 0x1c81e3775a8bed85
+588, 0x7eb5013882ce35ea
+589, 0x37a1c1692495818d
+590, 0x3f90ae118622a0ba
+591, 0x58e4fe6fea29b037
+592, 0xd10ff1d269808825
+593, 0xbce30edb60c21bba
+594, 0x123732329afd6fee
+595, 0x429b4059f797d840
+596, 0x421166568a8c4be1
+597, 0x88f895c424c1bd7f
+598, 0x2adaf7a7b9f781cb
+599, 0xa425644b26cb698
+600, 0x8cc44d2486cc5743
+601, 0xdb9f357a33abf6ba
+602, 0x1a57c4ea77a4d70c
+603, 0x1dea29be75239e44
+604, 0x463141a137121a06
+605, 0x8fecfbbe0b8a9517
+606, 0x92c83984b3566123
+607, 0x3b1c69180ed28665
+608, 0x14a6073425ea8717
+609, 0x71f4c2b3283238d7
+610, 0xb3d491e3152f19f
+611, 0x3a0ba3a11ebac5d2
+612, 0xddb4d1dd4c0f54ac
+613, 0xdb8f36fe02414035
+614, 0x1cf5df5031b1902c
+615, 0x23a20ed12ef95870
+616, 0xf113e573b2dedcbb
+617, 0x308e2395cde0a9fa
+618, 0xd377a22581c3a7da
+619, 0xe0ced97a947a66fb
+620, 0xe44f4de9cd754b00
+621, 0x2344943337d9d1bf
+622, 0x4b5ae5e2ea6e749c
+623, 0x9b8d2e3ef41d1c01
+624, 0x59a5a53ebbd24c6b
+625, 0x4f7611bf9e8a06fb
+626, 0xea38c7b61361cd06
+627, 0xf125a2bfdd2c0c7
+628, 0x2df8dcb5926b9ebb
+629, 0x233e18720cc56988
+630, 0x974c61379b4aa95e
+631, 0xc7fe24c1c868910b
+632, 0x818fd1affc82a842
+633, 0xcee92a952a26d38e
+634, 0x8962f575ebcbf43
+635, 0x7770687e3678c460
+636, 0xdfb1db4ed1298117
+637, 0xb9db54cb03d434d3
+638, 0x34aebbf2244257ad
+639, 0xd836db0cb210c490
+640, 0x935daed7138957cd
+641, 0x3cd914b14e7948fd
+642, 0xd0472e9ed0a0f7f0
+643, 0xa9df33dca697f75e
+644, 0x15e9ea259398721a
+645, 0x23eeba0f970abd60
+646, 0x2217fdf8bbe99a12
+647, 0x5ea490a95717b198
+648, 0xf4e2bfc28280b639
+649, 0x9d19916072d6f05c
+650, 0x5e0387cab1734c6a
+651, 0x93c2c8ac26e5f01e
+652, 0xb0d934354d957eb1
+653, 0xee5099a1eef3188c
+654, 0x8be0abca8edc1115
+655, 0x989a60845dbf5aa3
+656, 0x181c7ed964eee892
+657, 0x49838ea07481288d
+658, 0x17dbc75d66116b2e
+659, 0xa4cafb7a87c0117e
+660, 0xab2d0ae44cdc2e6e
+661, 0xdf802f2457e7da6
+662, 0x4b966c4b9187e124
+663, 0x62de9db6f4811e1a
+664, 0x1e20485968bc62
+665, 0xe9ac288265caca94
+666, 0xc5c694d349aa8c1a
+667, 0x3d67f2083d9bdf10
+668, 0x9a2468e503085486
+669, 0x9d6acd3dc152d1a3
+670, 0xca951e2aeee8df77
+671, 0x2707371af9cdd7b0
+672, 0x2347ae6a4eb5ecbd
+673, 0x16abe5582cb426f
+674, 0x523af4ff980bbccb
+675, 0xb07a0f043e3694aa
+676, 0x14d7c3da81b2de7
+677, 0xf471f1b8ac22305b
+678, 0xdb087ffff9e18520
+679, 0x1a352db3574359e8
+680, 0x48d5431502cc7476
+681, 0x7c9b7e7003dfd1bf
+682, 0x4f43a48aae987169
+683, 0x9a5d3eb66dedb3e9
+684, 0xa7b331af76a9f817
+685, 0xba440154b118ab2d
+686, 0x64d22344ce24c9c6
+687, 0xa22377bd52bd043
+688, 0x9dfa1bb18ca6c5f7
+689, 0xdccf44a92f644c8b
+690, 0xf623d0a49fd18145
+691, 0x556d5c37978e28b3
+692, 0xad96e32ce9d2bb8b
+693, 0x2e479c120be52798
+694, 0x7501cf871af7b2f7
+695, 0xd02536a5d026a5b8
+696, 0x4b37ff53e76ab5a4
+697, 0xdb3a4039caaeab13
+698, 0x6cbd65e3b700c7be
+699, 0x7367abd98761a147
+700, 0xf4f9ba216a35aa77
+701, 0xf88ca25ce921eb86
+702, 0xb211de082ec2cbf2
+703, 0xdd94aa46ec57e12e
+704, 0xa967d74ad8210240
+705, 0xdaa1fada8cfa887
+706, 0x85901d081c4488ee
+707, 0xcf67f79a699ef06
+708, 0x7f2f1f0de921ee14
+709, 0x28bc61e9d3f2328b
+710, 0x3332f2963faf18e5
+711, 0x4167ac71fcf43a6
+712, 0x843c1746b0160b74
+713, 0xd9be80070c578a5e
+714, 0xbd7250c9af1473e7
+715, 0x43f78afaa3647899
+716, 0x91c6b5dd715a75a5
+717, 0x29cc66c8a07bfef3
+718, 0x3f5c667311dc22be
+719, 0x4f49cd47958260cd
+720, 0xbef8be43d920b64e
+721, 0x7a892a5f13061d8b
+722, 0x9532f40125c819b1
+723, 0x924fca3045f8a564
+724, 0x9b2c6442453b0c20
+725, 0x7e21009085b8e793
+726, 0x9b98c17e17af59d2
+727, 0xba61acb73e3ae89a
+728, 0xb9d61a710555c138
+729, 0xc2a425d80978974b
+730, 0xa275e13592da7d67
+731, 0xe962103202d9ad0f
+732, 0xbdf8367a4d6f33fd
+733, 0xe59beb2f8648bdc8
+734, 0xb4c387d8fbc4ac1c
+735, 0x5e3f276b63054b75
+736, 0xf27e616aa54d8464
+737, 0x3f271661d1cd7426
+738, 0x43a69dbee7502c78
+739, 0x8066fcea6df059a1
+740, 0x3c10f19409bdc993
+741, 0x6ba6f43fb21f23e0
+742, 0x9e182d70a5bccf09
+743, 0x1520783d2a63a199
+744, 0xba1dcc0c70b9cace
+745, 0x1009e1e9b1032d8
+746, 0xf632f6a95fb0315
+747, 0x48e711c7114cbfff
+748, 0xef281dcec67debf7
+749, 0x33789894d6abf59b
+750, 0x6c8e541fffbe7f9c
+751, 0x85417f13b08e0a88
+752, 0x9a581e36d589608f
+753, 0x461dca50b1befd35
+754, 0x5a3231680dde6462
+755, 0xcc57acf729780b97
+756, 0x50301efef62e1054
+757, 0x675d042cd4f6bbc9
+758, 0x1652fdd3794384c9
+759, 0x1c93bbeeb763cd4d
+760, 0x44b7240c4b105242
+761, 0x4c6af2a1b606ccfb
+762, 0x18fc43ece2ec1a40
+763, 0x859a5511aeae8acb
+764, 0x2f56826f1996ad2f
+765, 0xa8e95ce8bb363bdf
+766, 0xf4da396054e50e4b
+767, 0x5493865e9895883c
+768, 0x768e4c8b332ac0e3
+769, 0x32195d2aa583fca5
+770, 0xf2f353f21266bc15
+771, 0x43cddf1d021307d
+772, 0x6031e3aa30300e4a
+773, 0x4f1298469ac6088f
+774, 0x4b4d450bafac574e
+775, 0x23e1cf9c0582a22b
+776, 0x2e9036980db49cd0
+777, 0xe4e228b113c411b2
+778, 0x8bddcdb82b51706
+779, 0xd2a7ea8288593629
+780, 0x67fe90e98fdda61
+781, 0x7b63494dba95717b
+782, 0x105625904510d782
+783, 0xdf4aa2242454e50a
+784, 0x32541d6cd7d6c7e3
+785, 0x5661fb432591cf3b
+786, 0xce920a5ed047bce7
+787, 0xed4178a3c96eea8f
+788, 0xe378cd996e39863b
+789, 0x169e1fdc8e2b05e1
+790, 0xaee1812ef7149a96
+791, 0x648571c7453d12c5
+792, 0xb7b6bc9328573c43
+793, 0xe7fb969078e270d7
+794, 0xdfc2b1b8985f6e6f
+795, 0x862b6527ee39a1aa
+796, 0x1ee329aea91d7882
+797, 0x20d25324f2fe704
+798, 0xbfcc47401fc3bbfd
+799, 0x1515cdc8d48b2904
+800, 0xbd6eefe86284261c
+801, 0x9b1f28e3b35f22ee
+802, 0x842a29d35e5aecda
+803, 0xf2346109ad370765
+804, 0x24d68add5a71afd9
+805, 0x4a691421613d91e2
+806, 0x60e3058b3c244051
+807, 0x79194905cdaa5de8
+808, 0xe0e2df35c01e8987
+809, 0xe29b78beffbb5e4a
+810, 0xcdcdbc020218c19e
+811, 0x5ae0af8c16feae43
+812, 0x8109292feeaf14fa
+813, 0x34113f7508dfa521
+814, 0xc062ac163f56730a
+815, 0xf1660e66ec6d4c4c
+816, 0x5966c55f60151c80
+817, 0x3865ae8ec934b17
+818, 0x472a7314afb055ec
+819, 0x7a24277309a44a44
+820, 0x556e02dd35d38baa
+821, 0x9849611a1bc96ec1
+822, 0xd176f5d5a8eb0843
+823, 0x44db12ec60510030
+824, 0x272e3a06a0030078
+825, 0x7c4764dbefc075ea
+826, 0x910712f3735c1183
+827, 0xd49a2da74ae7aff6
+828, 0xcf9b3e6e8f776d71
+829, 0x27789fe3ec481a02
+830, 0x86659f82c6b5912b
+831, 0xe044b3dbf339158c
+832, 0x99d81f6bb62a37b0
+833, 0x5f5830c246fada9a
+834, 0xe68abab1eeb432cb
+835, 0x49c5c5ace04e104
+836, 0x1ac3871b3fc6771b
+837, 0x773b39f32d070652
+838, 0x9c4138c2ae58b1f3
+839, 0xac41c63d7452ac60
+840, 0x9248826b245359e1
+841, 0x99bba1c7a64f1670
+842, 0xe0dc99ff4ebb92f2
+843, 0x113638652740f87c
+844, 0xebf51e94da88cfc
+845, 0x5441c344b81b2585
+846, 0xe1e69e0bc2de652a
+847, 0xe9ab6d64ae42ed1e
+848, 0x879af8730e305f31
+849, 0x36b9ad912c7e00d6
+850, 0x83ef5e9fca853886
+851, 0xda54d48bb20ea974
+852, 0x32c6d93aefa92aa2
+853, 0x4e887b2c3391847d
+854, 0x50966e815f42b1b8
+855, 0x53411ac087832837
+856, 0x46f64fef79df4f29
+857, 0xb34aae3924cd272c
+858, 0xf5ad455869a0adbe
+859, 0x8351ded7144edac8
+860, 0xeb558af089677494
+861, 0x36ed71d69293a8d6
+862, 0x659f90bf5431b254
+863, 0x53349102b7519949
+864, 0x3db83e20b1713610
+865, 0x6d63f96090556254
+866, 0x4cc0467e8f45c645
+867, 0xb8840c4bd5cd4091
+868, 0xbd381463cc93d584
+869, 0x203410d878c2066d
+870, 0x2ebea06213cf71c8
+871, 0x598e8fb75e3fceb4
+872, 0xdcca41ceba0fce02
+873, 0x61bf69212b56aae5
+874, 0x97eed7f70c9114fa
+875, 0xf46f37a8b7a063f9
+876, 0x66c8f4ffe5bd6efa
+877, 0xe43fd6efda2d4e32
+878, 0x12d6c799e5ad01de
+879, 0x9ac83e7f8b709360
+880, 0xbbb7bb3c1957513d
+881, 0x7f87c08d4b3796b0
+882, 0x9a7d1d74b6aa4a5c
+883, 0xa4314530ff741b6f
+884, 0x99a80c6b6f15fca8
+885, 0xd2fec81d6d5fc3ce
+886, 0x15a98be1cc40cea
+887, 0x98693eb7719366f3
+888, 0x36ccdc2a9e9d4de8
+889, 0x3c8208f63d77df25
+890, 0xca2e376e2343df6
+891, 0xcc9b17cbb54420c6
+892, 0x8724c44a64d7dcb8
+893, 0x9d00c6949ff33869
+894, 0xf4f8e584d2699372
+895, 0x88f4748cdd5a2d53
+896, 0xe215072a1205bc6d
+897, 0x190934fe6d740442
+898, 0x7fac5c0ab2af106d
+899, 0x1b86633a0bd84fa1
+900, 0x1293e54318492dfb
+901, 0x433324fd390f34b9
+902, 0x4c5eb2c67a44643b
+903, 0x59a6e281c388b0dd
+904, 0xe78e03f9c44623b7
+905, 0x91307a93c768fc3d
+906, 0xde8867b004d8e3ff
+907, 0xdf52c3f57b7c5862
+908, 0x993f3e1d10358a92
+909, 0x9ccb10bc3e18662d
+910, 0x45093ce48a114c73
+911, 0xd59d05979d26330a
+912, 0x417c0e03300119a9
+913, 0x1c336500f90cde81
+914, 0x1c8ccd29ead9b85b
+915, 0xb76baf3e55d4d950
+916, 0x133ad6196c75fd7e
+917, 0x34200b0cde7ed560
+918, 0x9c7c3dacb213c8d9
+919, 0xd97563c4fd9bf1b6
+920, 0x5d910e871835b6cb
+921, 0x7d46c4733a16bdf9
+922, 0xe41d73194ddc87b2
+923, 0x7d3d8a0855a465a9
+924, 0x70c2a8b5d3f90c0f
+925, 0x9e7565ca5dccfe12
+926, 0x2c0acb4577aa51b1
+927, 0x3d2cd211145b79c7
+928, 0x15a7b17aa6da7732
+929, 0xab44a3730c27d780
+930, 0xf008bd6c802bde3a
+931, 0x82ed86ddf3619f77
+932, 0xaabe982ab15c49f9
+933, 0x9bcad8fa6d8e58a4
+934, 0x8f39ed8243718aa1
+935, 0xe9489340e03e3cb6
+936, 0xc722314f5eefb8d0
+937, 0x870e8869a436df59
+938, 0x4dae75b8087a8204
+939, 0xe1d790f6ec6e425b
+940, 0xafd39ea1b1d0ed09
+941, 0xdf2c99e464ddf08f
+942, 0x74936d859ab9644d
+943, 0x3871302164250e73
+944, 0x764b68921e911886
+945, 0x2a1d024b26bb9d66
+946, 0x797fba43918e75b4
+947, 0x62ec6d24ccca335b
+948, 0xf4bd8b951762b520
+949, 0x9d450dede9119397
+950, 0x5393a26d10f8c124
+951, 0x6b74769392896b57
+952, 0x7f61dbcc0e328581
+953, 0x64e1df3884d0d94
+954, 0xba77dcdf23738c37
+955, 0xf8e288bc0a177475
+956, 0x4a8abfd1702ecb7d
+957, 0x53f22886694736a7
+958, 0x8fc982597ced3e3
+959, 0x1bc46090f820fff7
+960, 0x8bd31f965d02229f
+961, 0x65cd0cb29996ee53
+962, 0x702e0f4fcf8c2e9f
+963, 0x293b77bff307a9a0
+964, 0x125a986b8b305788
+965, 0x416b0eea428ebf3c
+966, 0xeac85421ab0e8469
+967, 0x7f5496095019aa68
+968, 0x1a96d7afbc708e0
+969, 0xb91262e6766e01e1
+970, 0xd0a549cc4ccc6954
+971, 0x75a9a073f50c8a0d
+972, 0xae275d2c1c6cd23c
+973, 0xcf159b5ec5d28fd4
+974, 0x75d0838ce9b92b
+975, 0xd4eddcee6dc4677f
+976, 0x6a0a8ad5df6b75b8
+977, 0x6f3fd0ef0f13ecc4
+978, 0xb75a5826c1a8f8a8
+979, 0xd47098bbc7943766
+980, 0x3d4ddd62d5f23dd1
+981, 0x760a904e4583841c
+982, 0x2afeb5022b4cf1f
+983, 0x66d5f653729f0a13
+984, 0x9a6a5ab62980d30f
+985, 0xc332f5643bbf8d5b
+986, 0x848fb702e4056a90
+987, 0xa057beaf3f9e8c5f
+988, 0x6cc603e4560a6c6a
+989, 0xec761811a7b23211
+990, 0xb14aa4090a82aaa5
+991, 0xe29d9d028a5b2dbb
+992, 0x5564e53738d68f97
+993, 0xfabca36542eaaf3b
+994, 0xb9912fcb782020a2
+995, 0xe865e01b349284fd
+996, 0x540b5ff11c5f9274
+997, 0x3463f64e1e7451dc
+998, 0xe15d3e2f33b735f8
+999, 0xf5433336eadef6e
diff --git a/venv/lib/python3.12/site-packages/numpy/random/tests/data/sfc64-testset-2.csv b/venv/lib/python3.12/site-packages/numpy/random/tests/data/sfc64-testset-2.csv
new file mode 100644
index 00000000..70aebd5d
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/random/tests/data/sfc64-testset-2.csv
@@ -0,0 +1,1001 @@
+seed, 0x0
+0, 0x91959e5fb96a6332
+1, 0x3c1dd8a25a7e9f21
+2, 0x657bdffc99798d9e
+3, 0x1a04de320b19e022
+4, 0x65b92af0e5f3c61c
+5, 0x9c84070ce8f743c0
+6, 0xbb10e573693cdb25
+7, 0xd65ea9e76b37fb6b
+8, 0x503efd0e76c8ae66
+9, 0xd711dcd04c26d0f
+10, 0x12f53f435814ac8c
+11, 0xb392cd402cfc82bd
+12, 0x461764550e06c889
+13, 0x716a48b3514e6979
+14, 0xdd0a322213c18ad7
+15, 0x6673a8ca0a05c4d7
+16, 0x2992ef333437f844
+17, 0xc4aaf7e8240b2aad
+18, 0x6ab0a1af1f41474f
+19, 0xb0bae400c226941d
+20, 0xe5f80c2eeeab48c6
+21, 0x3832c6a93a4024bf
+22, 0x280bd824fabe8368
+23, 0x66b626228321e5ff
+24, 0xe0bdfba5325a307e
+25, 0x3a5f65c6ef254e05
+26, 0x99ea12503cb02f94
+27, 0x5d01fd2db77d420b
+28, 0x6959bf5f36b2368d
+29, 0xd856e30c62b5f5be
+30, 0xe33233e1d8140e66
+31, 0xb78be619d415fa8d
+32, 0x4f943bb2cc63d3b
+33, 0x9b1460b290952d81
+34, 0x19205d794826740e
+35, 0x64617bd9d7a6a1ff
+36, 0x30442124b55ea76a
+37, 0xebbbc3b29d0333fc
+38, 0x39235a0fe359751c
+39, 0xf9629768891121aa
+40, 0x32052f53f366e05a
+41, 0x60cc5b412c925bc8
+42, 0xf8b7ecda1c0e5a9
+43, 0x195f036e170a2568
+44, 0xfe06d0381a9ca782
+45, 0x919d89e8b88eebbf
+46, 0xa47fb30148cf0d43
+47, 0x5c983e99d5f9fd56
+48, 0xe7492cdb6a1d42cd
+49, 0xf9cfe5c865b0cfd8
+50, 0x35b653367bbc3b99
+51, 0xb1d92f6f4d4e440b
+52, 0x737e1d5bd87ed9c0
+53, 0x7a880ca1498f8e17
+54, 0x687dae8494f9a3f7
+55, 0x6bae1989f441d5d7
+56, 0x71ad3fa5a9195c2e
+57, 0x16b3969779f5d03
+58, 0xd1bce2ac973f15b3
+59, 0xa114b1ee2ce0dcdd
+60, 0x270d75c11eb1b8d5
+61, 0xc48ffa087c0a7bc
+62, 0xaaf9dc48cda9848d
+63, 0x8111cf10ef6e584d
+64, 0x6736df6af40ee6f4
+65, 0x1a1a111682fbf98d
+66, 0xeb217658e1cb3b5d
+67, 0xcaf58a8b79de9dec
+68, 0x25d0ffd63c88d7a1
+69, 0x4c498cd871b7f176
+70, 0x4069a6156eb0cf3c
+71, 0xdf012f12edcdd867
+72, 0x7734c0ac8edb1689
+73, 0xed6960ac53dbc245
+74, 0x305e20da8868c661
+75, 0x5f0c7a3719956f95
+76, 0x66842bbe3b28895
+77, 0xb608bc9a31eac410
+78, 0xfcb17d5529503abd
+79, 0x829ae5cbc29b92ee
+80, 0x17f2f0027bc24f3a
+81, 0x435926c33d8f44cc
+82, 0x3ab899327098dbec
+83, 0xaf78573b27f8ead8
+84, 0xa8b334fabcf8dc60
+85, 0xcdf3b366a6a303db
+86, 0x8da9379dd62b34c8
+87, 0xb0ba511955f264a7
+88, 0x9d72e21a644f961d
+89, 0xfac28382e2e7e710
+90, 0xd457065f048410aa
+91, 0x1cae57d952563969
+92, 0x5a160a6223253e03
+93, 0x2c45df736d73c8bd
+94, 0x7f651ebc6ad9cec5
+95, 0x77a6be96c7d2e7e7
+96, 0x1721fb1dbfd6546a
+97, 0xf73f433ecff3c997
+98, 0xed1e80f680965bfe
+99, 0x6705ad67a3003b30
+100, 0xac21134efcadb9f7
+101, 0x4d2ba0a91d456ac
+102, 0x59da7b59434eb52b
+103, 0x26c1d070fd414b5f
+104, 0xed7079ddfce83d9a
+105, 0x9277d21f88e0fb7a
+106, 0xfae16b9a8d53d282
+107, 0xb08a0e2e405fdf7d
+108, 0x2ea20df44229d6ec
+109, 0x80e4634cd3612825
+110, 0xbe62e8aeba8f8a1a
+111, 0x4981209769c190fb
+112, 0xcec96ef14c7e1f65
+113, 0x73fe4457b47e7b53
+114, 0x1d66300677315c31
+115, 0xe26821290498c4cc
+116, 0xf6110248fd8fb1c5
+117, 0x30fd7fe32dbd8be3
+118, 0x534ec9b910a2bd72
+119, 0x8f9bfe878bbf7382
+120, 0x4f4eb5295c0c2193
+121, 0xdeb22f03a913be9e
+122, 0x40f716f8e2a8886c
+123, 0xc65007d0e386cdb1
+124, 0x9bdd26d92b143a14
+125, 0xf644b0b77ea44625
+126, 0x75f5a53f6b01993a
+127, 0xfe803e347bf41010
+128, 0x594bff5fa17bc360
+129, 0x3551edfb450373c7
+130, 0x898f9dad433615db
+131, 0x923d2406daa26d49
+132, 0x99e07faccbc33426
+133, 0x7389f9ff4470f807
+134, 0xdc2a25957c6df90b
+135, 0x33c6d8965ef3053f
+136, 0x51a8f07e838f1ab
+137, 0x91c5db369380274f
+138, 0xc37de65ac56b207e
+139, 0xfcc6d2375dde7f14
+140, 0xa4e6418bff505958
+141, 0x4b8b9f78e46953c4
+142, 0x255ab2e0f93cf278
+143, 0xdf650717af3d96ef
+144, 0x2caa21cba3aae2b2
+145, 0xce7e46c6f393daa4
+146, 0x1d5b3573f9997ac7
+147, 0x5280c556e850847d
+148, 0x32edc31bef920ad7
+149, 0xefaa6b0b08cf2c6
+150, 0x5151c99d97b111c5
+151, 0x35ccf4bf53d17590
+152, 0xa210d7bd8697b385
+153, 0xa9419f95738fbe61
+154, 0xdeccf93a1a4fdc90
+155, 0xd0ea3365b18e7a05
+156, 0x84122df6dcd31b9a
+157, 0x33040a2125cea5f5
+158, 0xfe18306a862f6d86
+159, 0xdb97c8392e5c4457
+160, 0xc3e0fa735e80e422
+161, 0x7d106ff36467a0c1
+162, 0xb9825eecc720a76d
+163, 0x7fefc6f771647081
+164, 0xf5df3f5b3977bf13
+165, 0x18fb22736d36f1e0
+166, 0xadc4637b4953abfc
+167, 0x174e66d3e17974bd
+168, 0xf1614c51df4db5db
+169, 0x6664ecde5717b293
+170, 0xd5bc5b6839265c26
+171, 0xf6ca9ce1af3f1832
+172, 0xca696789a9d506ea
+173, 0x7399c246c8f9d53
+174, 0xadf49049626417e2
+175, 0xbcd84af37d09ab91
+176, 0xbb41c177f3a3fa45
+177, 0x592becc814d55302
+178, 0xa88b4e65f6cfe5f7
+179, 0xa0a55e34ff879426
+180, 0x3c2ea6aa725b42b7
+181, 0x65ac4a407b1f9521
+182, 0xde63d53f7e88b556
+183, 0x18bc76696d015f40
+184, 0xd1363f2cd4c116a8
+185, 0x2fe859be19a48e4a
+186, 0x83d6099b1415e656
+187, 0x43f2cbc1a4ee6410
+188, 0xb2eca3d3421c533d
+189, 0xc52b98ea3f031f5d
+190, 0xfe57eb01da07e9d1
+191, 0xf9377883537a6031
+192, 0x364030c05dac7add
+193, 0x6815cb06b35d4404
+194, 0xceae2d4ce31894be
+195, 0xc602bcdf6062bf6a
+196, 0xc8e4bd8dcc6062e3
+197, 0x9c29e87b92a1a791
+198, 0x41e626b871ca9651
+199, 0x325c3d1fb8efbcd8
+200, 0x7dbbacf8e3419fb3
+201, 0x3602e72516bb7319
+202, 0x537a008ebd94d24b
+203, 0xda7714fc9d4d161d
+204, 0x1c8c73700e1b621b
+205, 0x2749b80937d6c939
+206, 0x76ee6abac5b14d33
+207, 0xf18d1e92cb6a8b5c
+208, 0x6ce9579d9291c721
+209, 0x60523c745a40e58
+210, 0x637f837fcc901757
+211, 0x2ff71b19661dc5b3
+212, 0x393ab586326ad16f
+213, 0xa0970ea30fe742b7
+214, 0x570222d7f27fe5ae
+215, 0x3b5806d43fd38629
+216, 0x129a0ad7420180c5
+217, 0x1c4726355778d52c
+218, 0x7c1459cf77656499
+219, 0xfe038a0932132069
+220, 0x4c4cc317a937483a
+221, 0xa333d24067e926ba
+222, 0x401d9b6ab37f6ef2
+223, 0x87ad0e491ebe4a2a
+224, 0xfc02f312e72d121d
+225, 0xfde715b3b99767b2
+226, 0xd111c342ba521c92
+227, 0x83b221b10879c617
+228, 0x6a1bf5c01fdf4277
+229, 0x166bfc0c3f5892ee
+230, 0x4608d556d7c57856
+231, 0x8d786857c95ece49
+232, 0x2d357445a1aca4ac
+233, 0x79620dae28ecd796
+234, 0x90e715dc0f2201c4
+235, 0x173b68b4c9f4b665
+236, 0x4e14d040ebac4eef
+237, 0xbd25960b4b892e
+238, 0x911a199db6f1989d
+239, 0xfe822d7c601fd2e0
+240, 0x9b4c1d58d8223a69
+241, 0x907c1891283843b0
+242, 0xf4868bf54061c4b2
+243, 0x17f8cd1fc24efd85
+244, 0xd44253f9af14c3aa
+245, 0x16d0da0cb911d43c
+246, 0x3c6a46615828e79a
+247, 0x498591c1138e11a5
+248, 0xcc0f26336d0d6141
+249, 0x4d3ebc873212309a
+250, 0x16bad7792d5c2c6a
+251, 0x474215a80b2bbd11
+252, 0x7159848abd8492fc
+253, 0x359341c50973685f
+254, 0x27512ee7bf784a4a
+255, 0x45228ea080f70447
+256, 0x880cab616500d50e
+257, 0x12fae93f9830d56e
+258, 0x6744ee64348d9acd
+259, 0x484dada28cd2a828
+260, 0x98491d0729e41863
+261, 0x2f15aac43c2863b0
+262, 0x5727a34d77a1da0f
+263, 0xa435cebef6a62eed
+264, 0xd211697d57b053b0
+265, 0x65aa757b68bd557
+266, 0xe3a1b7a2d8a3e06a
+267, 0x2adf64e67252a7a9
+268, 0xadadcb75cadee276
+269, 0x7934bc57ac8d97bf
+270, 0xccff0d0f412e0606
+271, 0x101a82aa3e8f3db9
+272, 0xb0f2498094b4575c
+273, 0xba2561d9ef26ed8a
+274, 0xfbcd1268fc3febe1
+275, 0x9aa10bb19eb152e0
+276, 0xf496217a601a6d72
+277, 0xe4be1e4f2fa91363
+278, 0x473a602bf3dd68eb
+279, 0xfe8ed2a48c26f4b5
+280, 0x20e94b1a00159476
+281, 0x93e1cb1c6af86ec7
+282, 0x4fcba3898f7442ba
+283, 0x5150c3a3d94891df
+284, 0x91cfce6c85b033ea
+285, 0x625e8a832a806491
+286, 0x28c97ba72e3ec0b2
+287, 0x8e172de217c71ea1
+288, 0x926b80216c732639
+289, 0x28b19431a649ae3d
+290, 0x57c039a6e95a3795
+291, 0xfbc354182fe52718
+292, 0x819dfd7c7d534cef
+293, 0xabb4093a619ed44f
+294, 0xe785b7ac6f656745
+295, 0xb647b4588b2f942f
+296, 0x64cf870a14c72d27
+297, 0x6d4a4a2a0ba9b37e
+298, 0x78bfb0427d7ce6b0
+299, 0x8dcc72b8bfc79ac6
+300, 0x1c14d915d5e76c99
+301, 0xaf48ddea6f096d79
+302, 0x51b39b67aa130d8
+303, 0x1aeeb39d4def06de
+304, 0xd678092ffedfdd27
+305, 0x8f54787f325111d3
+306, 0xf2ca2e827beaa6bc
+307, 0x339d134099e98545
+308, 0x1f6a8a7b33942e43
+309, 0x952c8065dbef669a
+310, 0xe066aeb6690147f7
+311, 0xed25aa92cf58ebb6
+312, 0x7601edce215ef521
+313, 0xed1c5b396abd9434
+314, 0x4fd1e407535de9d5
+315, 0xccc8315a0d4d1441
+316, 0x85753e250bb86976
+317, 0xf232e469378761c3
+318, 0x81d691b8e9aef3c6
+319, 0x224a2f9cab0ad0e
+320, 0x978f3d3e50007f4e
+321, 0xd3713e6a6c0cbe60
+322, 0xcce8f1eadd41f80d
+323, 0x34bda028a97d469
+324, 0x90e242fdf0f59183
+325, 0x4d749754fbc5f092
+326, 0x4399f5b7851cc87b
+327, 0xcb921a5f25f6c5d7
+328, 0x120bf5d0162101
+329, 0x1304cc2aa352735a
+330, 0xf7236c5d0d5d417b
+331, 0xc31b320fc1654306
+332, 0xb468c6b23f3fb4e7
+333, 0xb5985b5bfaca4166
+334, 0x898285a1cd2f8375
+335, 0xa13493da372aa7c9
+336, 0x15c80c09c12634e7
+337, 0x9b765c5cc9d438bd
+338, 0xee7da816a9201dcb
+339, 0x92e269f73b5a248e
+340, 0xa8086c5de81400ce
+341, 0xe0053901853d42be
+342, 0x821df32c012f433e
+343, 0x17a6d69ca37387c7
+344, 0x2b10044bfba3501f
+345, 0x8dfd262afc2e8515
+346, 0xd68c2c7b60226371
+347, 0xe81ac114e4416774
+348, 0x5896d60061ebc471
+349, 0xa996e3147811dbd1
+350, 0xa819c7b80ecb3661
+351, 0x982ad71b38afbc01
+352, 0xab152b65aa17b7fe
+353, 0x4582bc282ef187ef
+354, 0xab5a17fe8d9bc669
+355, 0x83664fa9cb0284b7
+356, 0x234c4b0091968f52
+357, 0x8ab5f51805688d37
+358, 0xe9e11186e0c53eda
+359, 0x10df37ef1de2eccf
+360, 0x780f1b0d52db968f
+361, 0x50bd4ff292872cd5
+362, 0x51e681c265f5ad0
+363, 0x842c49660a527566
+364, 0x6e56ee026e9eda87
+365, 0x4cf39e40d8c80393
+366, 0x13e466df371f7e1f
+367, 0xf2ce1799f38e028e
+368, 0x833c8db7adc6ff0e
+369, 0xc6e189abc2ec98f
+370, 0xafebb3721283fec5
+371, 0xb49bc1eb5cc17bdc
+372, 0xf1d02e818f5e4488
+373, 0xe5e9d5b41a1dd815
+374, 0xce8aca6573b1bfe5
+375, 0x9b0a5d70e268b1d5
+376, 0xf3c0503a8358f4de
+377, 0x2681605dd755669d
+378, 0xea265ca7601efc70
+379, 0xa93747f0a159439f
+380, 0x62a86ede78a23e50
+381, 0xac8a18935c3d063c
+382, 0x729c0a298f5059f5
+383, 0xbbf195e5b54399f4
+384, 0x38aa9d551f968900
+385, 0x3b3e700c58778caa
+386, 0x68e6e33c4443957a
+387, 0x7c56fc13eb269815
+388, 0xaf7daca39711804a
+389, 0x50fde6d10f9544b3
+390, 0xf3d37159f6f6c03d
+391, 0x82d298f5c1a71685
+392, 0x478661ac54c5002c
+393, 0x6053768e1a324ae0
+394, 0xde8fb4a7e56707ea
+395, 0xaa2809301faa8cf4
+396, 0x690a8d49fedd0722
+397, 0xe17c481b9c217de9
+398, 0x60d1d8a2b57288e3
+399, 0x149adfaadc6b0886
+400, 0xa3c18b6eb79cd5fa
+401, 0x5774e3a091af5f58
+402, 0x2acca57ff30e5712
+403, 0x94454d67367c4b0c
+404, 0x581b2985ac2df5ca
+405, 0x71618e50744f3e70
+406, 0x270a7f3bd9a94ae6
+407, 0x3ef81af9bb36cd7b
+408, 0x8a4a2592875254aa
+409, 0x704ac6086fbb414a
+410, 0xda774d5d3f57414d
+411, 0xe20d3358b918ae9e
+412, 0x934a6b9f7b91e247
+413, 0xf91649cde87ec42c
+414, 0x248cec5f9b6ced30
+415, 0x56791809fd8d64ba
+416, 0xf502b2765c1395f
+417, 0x6b04ec973d75aa7f
+418, 0xb0339f2794bb26f
+419, 0x4c524636efbaea49
+420, 0x6bbf3876e9738748
+421, 0xf686524e754e9e24
+422, 0x8dafa05a42d19cd3
+423, 0xc5f069ab2434008e
+424, 0x4fd64cc713cba76
+425, 0xdbf93450c881ed5f
+426, 0x492e278ebabb59a2
+427, 0x993fddfde4542642
+428, 0xecde68a72c8d4e52
+429, 0xe0760b3074c311fd
+430, 0x68dc0e7e06528707
+431, 0x52b50edf49c0fdc7
+432, 0xb2bd4185c138f412
+433, 0x431496d7e1d86f3
+434, 0xa4e605b037e26c44
+435, 0x58236ae1f0aca2b5
+436, 0x26c72c420fc314d8
+437, 0x20134e982ab99a2b
+438, 0x544b59b8b211374b
+439, 0x1301c42f3a14d993
+440, 0x52a6ea740f763b0f
+441, 0xf209d70c2bebf119
+442, 0xac66a4ebc2aa1be
+443, 0x683713ed35878788
+444, 0x2b5578acec06b80c
+445, 0x86428efa11c45b36
+446, 0xb49010adb17d291e
+447, 0x73b686bd8664b6be
+448, 0x6d28ebf57b6884cc
+449, 0x9712091230ff58d9
+450, 0xc9c91f74c38b286
+451, 0x776310ac41dc008e
+452, 0x2f3739df0bf6a88e
+453, 0x5792dc62b94db675
+454, 0x5715910d024b06af
+455, 0xeb1dd745458da08
+456, 0xfce7b07ccfa851a7
+457, 0xc305f1e983ac368
+458, 0x485aa9519ac00bb0
+459, 0xa5354f6589fb0ea0
+460, 0x32fee02dfdbf4454
+461, 0x4d1ddc304bbefaaa
+462, 0x789a270a1737e57e
+463, 0x9f3072f4b1ed8156
+464, 0x4de3c00e89058120
+465, 0xb00a02529e0a86fa
+466, 0x539f6f0edd845d9a
+467, 0x85e578fe15a8c001
+468, 0xa12c8e1a72cce7d8
+469, 0xc6908abbc2b1828
+470, 0xcf70090774cbb38c
+471, 0x3b636a6977b45d4a
+472, 0xf0a731b220680b57
+473, 0x18973929f51443a8
+474, 0xe93e1fbe7eadabe
+475, 0x8233730f0a6dfa02
+476, 0x66e50b6919b0ab74
+477, 0xb1aba87c97fd08a2
+478, 0xd4dffc1fbc117ad6
+479, 0x6f7fa65724b96e6a
+480, 0x4bd5800dee92e0fa
+481, 0xe18a959db6256da
+482, 0xe53a291bc66df487
+483, 0xb7ec306a08651806
+484, 0x1847a6b80d2821e1
+485, 0xda50391283b14d39
+486, 0xacc4d3cd7cceb97a
+487, 0x57f70185165b7bc6
+488, 0x302b6d597c3aaba7
+489, 0xa47f32d037eab51e
+490, 0xe1509b4408abc559
+491, 0x4f30a1d7c2934157
+492, 0x2ad03e6c60b650b2
+493, 0x334d9c337b0a9064
+494, 0xc7f442821e7aac12
+495, 0xbcdeb09298694cdd
+496, 0xe42402389f8f0fb4
+497, 0xe5de56af539df727
+498, 0x7017f9b2101ee240
+499, 0x1ee5e68d5b10001d
+500, 0x436229051836387a
+501, 0xcd532d6d6ec38fb7
+502, 0x30a66606fdf38272
+503, 0xfdaa2ab9cf798496
+504, 0x4277b4adec70e7df
+505, 0x72cfc30256e0eaef
+506, 0x3c3359fd9bd34917
+507, 0xb7aa89598856efb0
+508, 0xf72226f8bf299ef5
+509, 0x258c499275a4356f
+510, 0x999a56bfc7f20d76
+511, 0x2b3e7432e20c18b
+512, 0x2d1251332f760cb5
+513, 0x7420e0eea62157c5
+514, 0xe85c895aa27cec3d
+515, 0x27a0545c7020d57c
+516, 0xc68638a65b4fff0d
+517, 0xfda473983a4ea747
+518, 0xd19fe65fb4c06062
+519, 0x6b1374e050ee15e4
+520, 0x80065ecd49bc4bef
+521, 0x4ee655954bc838de
+522, 0xe8fb777504a72299
+523, 0x86b652ea70f4bdde
+524, 0xcdc9e0fbde7e4f33
+525, 0x352c0a50cd3ac56
+526, 0x4b8605d368be75dc
+527, 0x1ac9ea8129efbc37
+528, 0x470325faa99f39c5
+529, 0x25dd7ef9adccf7a1
+530, 0x5ae2c7a03e965816
+531, 0xf733d2df59dacc7d
+532, 0xa05bbf0a8a1a7a70
+533, 0xe8aa3f102846ef5f
+534, 0xc9b85ec49ae71789
+535, 0xb904c14ed1cb1936
+536, 0x5ae618230b5f0444
+537, 0x97987fe47b5d7467
+538, 0xabb3aca8865ca761
+539, 0x38bfdf29d4508228
+540, 0x353654f408353330
+541, 0xeb7e92930ae4ef0d
+542, 0xec50f1a7ca526b96
+543, 0xd5e2dc08b5697544
+544, 0x24c7fd69d5ec32df
+545, 0x6f7e1095568b8620
+546, 0x6ed9c16ca13b3c8
+547, 0xe676ef460002130f
+548, 0xa3a01a3992c4b430
+549, 0xe2130406c3b1f202
+550, 0xa8f7263e2aedcd20
+551, 0xc45d71ef2e35f507
+552, 0x37155594021da7ba
+553, 0x22dc94f19de73159
+554, 0x7969fc6bffc5443f
+555, 0x97def7e44faa6bfe
+556, 0x8b940f5e8931d71f
+557, 0xd95b1dd3f1a3fdd5
+558, 0x1c83bfdca615701a
+559, 0xb7fcb56279ceca6b
+560, 0xd84f8950f20dcd0
+561, 0xb03343698de3cbe0
+562, 0xf64565d448d71f71
+563, 0xda52b4676e0ae662
+564, 0xda39c2c05b4ffb91
+565, 0xb35e2560421f6a85
+566, 0x1a7b108d48ac3646
+567, 0xc4e264dc390d79ed
+568, 0xa10727dfd9813256
+569, 0x40d23154e720e4f7
+570, 0xd9fa7cd7e313e119
+571, 0xcbf29107859e6013
+572, 0xc357338553d940b7
+573, 0x2641b7ab0bdfcbaa
+574, 0xd12f2b6060533ae7
+575, 0xd0435aa626411c56
+576, 0x44af4a488a9cec72
+577, 0xb934232ea8fa5696
+578, 0x760a8b12072b572d
+579, 0xfab18f9942cfa9b3
+580, 0x5676834c1fe84d16
+581, 0x9c54e4fddb353236
+582, 0xab49edfc9551f293
+583, 0x567f1fb45a871d
+584, 0x32a967c873998834
+585, 0x99240aad380ef8d1
+586, 0x7f66cbd432859a64
+587, 0x4cdc8a4658166822
+588, 0x984e3984a5766492
+589, 0xa3b2d0a3d64d3d94
+590, 0x177f667172f2affc
+591, 0xb1a90607a73a303f
+592, 0xe600b6c36427f878
+593, 0xf758f9834cb7f466
+594, 0x8ee9fce4a3f36449
+595, 0xcb8f11533e7da347
+596, 0xe7cf647794dabd7c
+597, 0xc9d92cfe6110806
+598, 0xea1335fa9145a1ec
+599, 0xbc6c29821d094552
+600, 0x37b9d6a858cc8bc3
+601, 0xf24e4c694929893e
+602, 0x55d025ce2d7d0004
+603, 0xccdc69acccf4267b
+604, 0xc491c04340c222eb
+605, 0xba50f75ecec9befb
+606, 0x1ec7bd85b8fe3bb9
+607, 0xe4de66498c59ae8a
+608, 0x38aa9e912712c889
+609, 0xcee0e43c5cc31566
+610, 0x72b69aa708fc7ed
+611, 0xdff70b7f6fa96679
+612, 0xd6d71d82112aadc3
+613, 0x365177892cb78531
+614, 0xa54852b39de4f72c
+615, 0x11dd5832bf16dd59
+616, 0x248a0f3369c97097
+617, 0xa14cec0260e26792
+618, 0x3517616ff142bed1
+619, 0x9b693ad39dab7636
+620, 0x739dff825e994434
+621, 0x67711e7356098c9
+622, 0xa81f8515d2fdf458
+623, 0xdac2908113fe568e
+624, 0xe99944ebc6e2806a
+625, 0x671728ca5b030975
+626, 0xfdad20edb2b4a789
+627, 0xedc6e466bd0369d2
+628, 0x88b5d469821f7e1b
+629, 0x2eabf94049a522a5
+630, 0x247794b7a2f5a8e3
+631, 0x278942bdbe02c649
+632, 0xbe5a9a9196ab99c1
+633, 0x75955060866da1b5
+634, 0xdedcfa149273c0b5
+635, 0xdbeb7a57758f3867
+636, 0x7b9053347a2c8d5a
+637, 0xa059b3f2eed338a5
+638, 0x59401a46ded3b79f
+639, 0x38044ba56a6d19fb
+640, 0x72c7221b4e77e779
+641, 0x526df3491a3a34da
+642, 0xc3b31184ba16c0c2
+643, 0xd94c7144488624af
+644, 0xcf966ee4dc373f91
+645, 0x62049e65dd416266
+646, 0x7c2adccb925bf8f
+647, 0xd5fa5c22ed4ef8e1
+648, 0xd00134ebd11f2cd1
+649, 0xfbdf81767bed3634
+650, 0x62e8cc8ff66b6e26
+651, 0x3a72d6bcd4f2dcf7
+652, 0xf1cd45b1b46a86ed
+653, 0x1271f98e0938bb9a
+654, 0x82e6927e83dc31fa
+655, 0x7b9b0e0acb67b92d
+656, 0x6df503e397b2e701
+657, 0x93888f6fb561e0c3
+658, 0x393fb6069a40291
+659, 0x967a7d894cc0754d
+660, 0x6e298996ad866333
+661, 0x5ff3cf5559d6ab46
+662, 0xd0d70508c40349f5
+663, 0xc64c66c0dd426b33
+664, 0x8fea340ee35c64dd
+665, 0xf9cd381eb3060005
+666, 0xfcc37c2799fc0b11
+667, 0x6a37c91d65b489fa
+668, 0x57231000fa0a0c9d
+669, 0x55f6e292c6703f9a
+670, 0xd0508ffbfa55a7a6
+671, 0x885db543276bdac8
+672, 0xc26dbe6a26b0e704
+673, 0x21f884874ebd709e
+674, 0x711f0b6c8f732220
+675, 0x354d0a361eaee195
+676, 0x721344d8d30b006a
+677, 0xa0e090a0d3a56f07
+678, 0x16b3d5d823a4952b
+679, 0x59d7874bc9eae7b6
+680, 0x9bbb32710076455f
+681, 0xd4fb22242ffabafd
+682, 0xe1d4ac6770be1d89
+683, 0xb259cedebc73dc8a
+684, 0x35faaa3b4246ab69
+685, 0x5d26addefdaee89
+686, 0x8e7ec350da0f3545
+687, 0xd0f316eed9f8fc79
+688, 0x98b2a52c9bf291b2
+689, 0xe4d294a8aca6a314
+690, 0x25bd554e6aa7673c
+691, 0xcfde5dcba5be2a6c
+692, 0xb5e01fb48d2d2107
+693, 0xe1caf28948028536
+694, 0xd434aa0a26f3ee9b
+695, 0xd17723381641b8f6
+696, 0xfe73bd1f3f3768a2
+697, 0x1cc6b1abd08d67e9
+698, 0x247e328371a28de0
+699, 0x502e7942e5a9104a
+700, 0x6a030fd242eb4502
+701, 0xa2ffe02744014ce8
+702, 0x59290763b18fe04e
+703, 0xcf14241564271436
+704, 0xb0fb73c3c1503aff
+705, 0x94e27c622f82137a
+706, 0x747a5b406ac3e1f0
+707, 0x9a914e96a732031d
+708, 0x59f68c6c8f078835
+709, 0x809d012c73eb4724
+710, 0x5b3c3b73e1b37d74
+711, 0xdde60ef3ba49cdf7
+712, 0x87a14e1f9c761986
+713, 0x4109b960604522af
+714, 0x122d0e1ed0eb6bb9
+715, 0xadc0d29e80bfe33
+716, 0xa25b1b44f5fc8e4e
+717, 0xbab85d8a9b793f20
+718, 0x825f4cbced0e7d1e
+719, 0x2d6ae8807acb37ea
+720, 0x8234420adce2e39
+721, 0x4a8ad4da6b804807
+722, 0x1e19f9bc215e5245
+723, 0x1d6f4848a916dd5e
+724, 0x9ac40dfcdc2d39cc
+725, 0x9f3524e3086155ec
+726, 0x861fffc43124b2ef
+727, 0xe640e3b756396372
+728, 0x41cb0f0c5e149669
+729, 0xe0bd37e1192e4205
+730, 0x62917d3858f4ce47
+731, 0xa36e7eb4d855820a
+732, 0x204b90255a3bf724
+733, 0x66ee83a0175535bc
+734, 0x2c14ce7c6b0c1423
+735, 0x85d9495fa514f70d
+736, 0x5a4fe45ead874dbc
+737, 0xe72248dcb8cfc863
+738, 0xfc21ff2932ed98cd
+739, 0xcbba1edd735b5cad
+740, 0x91ddc32809679bf5
+741, 0x192cdf2c7631ea1f
+742, 0xbbc451ddf2ea286f
+743, 0xad9e80cae2397a64
+744, 0x6918f0119b95d0e5
+745, 0xa40379017a27d70a
+746, 0x1aaeddb600e61e1
+747, 0x15afd93cbd7adda9
+748, 0x156719bc2b757ff4
+749, 0x13d9a59e2b2df49d
+750, 0x9a490986eaddf0a
+751, 0xef9a350f0b3eb6b4
+752, 0x5de7f6295ba4fa4d
+753, 0x7f37fd087c3fdb49
+754, 0xa9fe3749d6f3f209
+755, 0x50912ac036d9bfb
+756, 0x982cb4d726a441f8
+757, 0x8ca8d8af59b872d0
+758, 0x7f8adfb0ceeade8a
+759, 0xdad390ec742be44
+760, 0xa637944d0045be5b
+761, 0x3569a3b3af807061
+762, 0x9599da8eae14511d
+763, 0xc333e8d19589b01a
+764, 0xfb9b524a20b571e1
+765, 0xbd9dc8b37ce5c3e1
+766, 0x142333005fa389ac
+767, 0x1368bc37cd5bcce1
+768, 0x16094907ad6ecf73
+769, 0xb32c90dbba4c1130
+770, 0x82761d97c1747dd0
+771, 0x599f9f267ae3444d
+772, 0x79ad3382994852e1
+773, 0x2511f06d9ef06e54
+774, 0xb35e6ab7d5bbddae
+775, 0xfca9fa83a2988732
+776, 0x7d4350f0394ac3ba
+777, 0xa52a9527bb176ea3
+778, 0xb49fa0ceb2aa8353
+779, 0x1f62e504d1468cc0
+780, 0xe1a77bfccce6efc3
+781, 0x776cdff4dc0d6797
+782, 0x56612e39b652c1f2
+783, 0x5f096a29294eda04
+784, 0x7978abc3aabd8b23
+785, 0x79dd875e0485b979
+786, 0x8a98aa4d5735d778
+787, 0xcca43940f69d2388
+788, 0xb2d4b156f144f93a
+789, 0xbd528a676e9a862
+790, 0x2a394939c8e7ec5e
+791, 0xb1da900c6efe4abc
+792, 0x9869af479de4c034
+793, 0x78dbdfb88ac7c1db
+794, 0x18cb169143088041
+795, 0xe69e5461c51a3e13
+796, 0x5389fa16ea98183c
+797, 0xed7c80d1be1ea520
+798, 0x87246fc359758ced
+799, 0xab323eba95fae4ed
+800, 0xbc4c0dde7f8a1828
+801, 0xdb739f7955610b1a
+802, 0xecd8c68c3434cc
+803, 0x138c2eb88c477f44
+804, 0x28a65f96727aae41
+805, 0xdee879f2cf5629d
+806, 0x684f0c90ef20070f
+807, 0xa24a819ef5621800
+808, 0x8d0054f870e4fdcb
+809, 0x99e8c6e695b600b
+810, 0x50b705245891f7c3
+811, 0xc02eed3a6e58e51a
+812, 0x443d64e95443606c
+813, 0xca24959cfbd2d120
+814, 0xe072609ea48815bc
+815, 0xbcc715026590315b
+816, 0x3e76df24d7aa5938
+817, 0xd8ff04940d9b79ae
+818, 0x54474ce790059bcd
+819, 0x278390dd6aa70e81
+820, 0xf4df619fe35414e4
+821, 0x757d71270264e615
+822, 0x1e8a373699c11b23
+823, 0xef68c82046e67dd6
+824, 0xe280006599972620
+825, 0x234e095183b0f4d6
+826, 0xe3b7560ed9839749
+827, 0xcd5ec4086572332e
+828, 0xc41c0d4aaa279108
+829, 0x4b9cd6126bc16a6d
+830, 0x4a7252734f3e3dd0
+831, 0xb3132df156cc103a
+832, 0xf9e4abbf7b64464a
+833, 0xf936df27fb3c47b7
+834, 0x9142960873f6d71a
+835, 0x4ba6aa3235cdb10d
+836, 0x3237a2e765ba7766
+837, 0xd62f0b94c8e99e54
+838, 0x26b682f90a3ae41b
+839, 0x40ad5e82072b6f81
+840, 0xd0198101f5484000
+841, 0xe4fac60ba11c332
+842, 0x472d0b0a95ef9d38
+843, 0x8512557aec5a3d8f
+844, 0xef83169d3efd4de9
+845, 0x53fe89283e7a7676
+846, 0x2f50933053d69fc4
+847, 0x76f5e4362e2e53a2
+848, 0x8676fdccce28874a
+849, 0x2737764c1fb1f821
+850, 0x4a6f70afc066ab55
+851, 0x27f8e151e310fca4
+852, 0xd606960ccbe85161
+853, 0xcce51d7ddd270a32
+854, 0xb4235999794875c2
+855, 0x580084e358e884
+856, 0x2159d5e6dc8586d7
+857, 0x87bd54d8599b3ba4
+858, 0x3e9ade6a2181664
+859, 0x5e6e140406d97623
+860, 0x511545d5aa0080a2
+861, 0xf49d78ed219aac57
+862, 0xbece1f9c90b8ea87
+863, 0x1c741cac36a2c514
+864, 0x7453c141047db967
+865, 0xd751832a5037eba2
+866, 0x71370a3f30ada1f7
+867, 0x7c01cf2dcb408631
+868, 0x1052a4fbdccc0fa1
+869, 0x13d525c9df3fb6c
+870, 0xa3aa8dbfee760c55
+871, 0xc0288d200f5155cf
+872, 0x79f4bcd12af567c3
+873, 0x8160d163bb548755
+874, 0x5cf2995fb69fd2df
+875, 0xcc98ed01396639df
+876, 0xad95f1d9cfc8256e
+877, 0xa3df27d9fbdbfb9d
+878, 0x83e5f5dda4d52929
+879, 0x9adc05043009f55b
+880, 0xdfe8329dfde1c001
+881, 0x9980ccdd5298e6a2
+882, 0x636a7bd134f6ef56
+883, 0xef5ff780c4be6ba4
+884, 0x290d71dc77a56d16
+885, 0x6d65db9ff58de1e6
+886, 0x944b063b3805a696
+887, 0xce468ca2cce33008
+888, 0x5ba1ccb840f80f48
+889, 0x28ddce36fc9ad268
+890, 0x4f77ef254d507a21
+891, 0xce9b4057fadf3ab
+892, 0xb518bc68298730e6
+893, 0xd2eb5b8e2ec665b0
+894, 0xe1583303a4f87344
+895, 0x9d5a0df4fbe1bed5
+896, 0x2ba9bc03ec8cfd07
+897, 0x479ed880a96ca669
+898, 0xcedf96338324771a
+899, 0x312f4fc2da41ffaa
+900, 0xa0eb9cf23b5e1ed8
+901, 0xf8f88f975dc3f539
+902, 0x4a37e185d0e96e0f
+903, 0xf829654a5c0b46f9
+904, 0x3909cca7a7f8c7fb
+905, 0x4c2e1d66ceb45105
+906, 0xaffaa19e1db8af87
+907, 0x9ec498246bd18c76
+908, 0x21d51558edc089da
+909, 0xe8984112cd1b1561
+910, 0x7de1d2cf54b0c0e1
+911, 0xa06729aed50bfb9d
+912, 0xcf19f733e5db19e1
+913, 0x70edf2624ab777cd
+914, 0x46685becad10e078
+915, 0x825e0f6add46785
+916, 0x66d4af3b15f70de4
+917, 0xc676614b0666b21
+918, 0x282a916c864f5cb7
+919, 0x2707283a3f512167
+920, 0x37ff3afda7461623
+921, 0xc767eb1205e4ca86
+922, 0x46b359aecc4ea25b
+923, 0x67fbbb797a16dbb1
+924, 0x64fd4ba57122290e
+925, 0x8acc2a8ae59d8fac
+926, 0x64a49298599acc67
+927, 0xedf00de67177ce30
+928, 0x1ea9d8d7e76d2d2c
+929, 0x363fcac323f70eb2
+930, 0x19e6e3ec8a9712eb
+931, 0xca541e96b0961f09
+932, 0x4d8fd34c2822ec46
+933, 0x2fdd56a50b32f705
+934, 0xaac2fcf251e3fd3
+935, 0xb0c600299e57045c
+936, 0xd951ec589e909e38
+937, 0x4dc8414390cae508
+938, 0x537ef9d5e2321344
+939, 0xa57bc21fd31aa2dc
+940, 0xa3a60df564183750
+941, 0xbe69a5ce2e369fb6
+942, 0x7744601f4c053ec8
+943, 0x3838452af42f2612
+944, 0xd4f0dad7115a54e9
+945, 0x629cf68d8009a624
+946, 0x2211c8fa34cb98cb
+947, 0x8040b19e2213db83
+948, 0xb2a86d3ba2384fd
+949, 0x4b85cec4f93f0dab
+950, 0xc8d212d21ea6845d
+951, 0x5b271a03a4fe2be0
+952, 0xff4f671319ad8434
+953, 0x8e615a919d5afa96
+954, 0xea7f47c53161160a
+955, 0x33273930b13c6efc
+956, 0x98eedda27fb59c3c
+957, 0x188dc5e92e939677
+958, 0x9dbd0fa0911430f1
+959, 0x5b3dcf3fa75dfd2b
+960, 0x3f03846febdb275d
+961, 0x20cc24faea9e9cf6
+962, 0x854f3ac66199ff5d
+963, 0x31169ac99d341e6f
+964, 0xa85daed3c0bc1bbe
+965, 0x64633711e71ba5dd
+966, 0x530e79978dc73334
+967, 0x636f2ee6e20aef13
+968, 0xf6220f8b6d9a58fb
+969, 0x425db8fa32141a7b
+970, 0xac7c210f4b02be95
+971, 0x5fe8cfbe197a7754
+972, 0xfff7d40c79420ea
+973, 0x5f8bab9ef4697b77
+974, 0xaf6fe54e45b23fe8
+975, 0xce79456ccc70bbce
+976, 0x645ef680f48f1c00
+977, 0xa4dfac46e2028595
+978, 0x6bece4c41effc5df
+979, 0xd316df886442641f
+980, 0xa4f6ff994edd2a6
+981, 0x30281ae3cc49abe4
+982, 0x39acb7b663dea974
+983, 0x5e8829b01a7c06fb
+984, 0x87bdb08cf027f13e
+985, 0xdfa5ede784e802f6
+986, 0x46d03d55711c38cc
+987, 0xa55a961fc9788306
+988, 0xbf09ded495a2e57a
+989, 0xcd601b29a639cc16
+990, 0x2193ce026bfd1085
+991, 0x25ba27f3f225be13
+992, 0x6f685be82f64f2fe
+993, 0xec8454108229c450
+994, 0x6e79d8d205447a44
+995, 0x9ed7b6a96b9ccd68
+996, 0xae7134b3b7f8ee37
+997, 0x66963de0e5ebcc02
+998, 0x29c8dcd0d17c423f
+999, 0xfb8482c827eb90bc
diff --git a/venv/lib/python3.12/site-packages/numpy/random/tests/data/sfc64_np126.pkl.gz b/venv/lib/python3.12/site-packages/numpy/random/tests/data/sfc64_np126.pkl.gz
new file mode 100644
index 00000000..94fbceb3
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/random/tests/data/sfc64_np126.pkl.gz differ
diff --git a/venv/lib/python3.12/site-packages/numpy/random/tests/test_direct.py b/venv/lib/python3.12/site-packages/numpy/random/tests/test_direct.py
new file mode 100644
index 00000000..12c2f1d5
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/random/tests/test_direct.py
@@ -0,0 +1,561 @@
+import os
+from os.path import join
+import sys
+
+import numpy as np
+from numpy.testing import (assert_equal, assert_allclose, assert_array_equal,
+                           assert_raises)
+import pytest
+
+from numpy.random import (
+    Generator, MT19937, PCG64, PCG64DXSM, Philox, RandomState, SeedSequence,
+    SFC64, default_rng
+)
+from numpy.random._common import interface
+
+try:
+    import cffi  # noqa: F401
+
+    MISSING_CFFI = False
+except ImportError:
+    MISSING_CFFI = True
+
+try:
+    import ctypes  # noqa: F401
+
+    MISSING_CTYPES = False
+except ImportError:
+    MISSING_CTYPES = False
+
+if sys.flags.optimize > 1:
+    # no docstrings present to inspect when PYTHONOPTIMIZE/Py_OptimizeFlag > 1
+    # cffi cannot succeed
+    MISSING_CFFI = True
+
+
+pwd = os.path.dirname(os.path.abspath(__file__))
+
+
+def assert_state_equal(actual, target):
+    for key in actual:
+        if isinstance(actual[key], dict):
+            assert_state_equal(actual[key], target[key])
+        elif isinstance(actual[key], np.ndarray):
+            assert_array_equal(actual[key], target[key])
+        else:
+            assert actual[key] == target[key]
+
+
+def uint32_to_float32(u):
+    return ((u >> np.uint32(8)) * (1.0 / 2**24)).astype(np.float32)
+
+
+def uniform32_from_uint64(x):
+    x = np.uint64(x)
+    upper = np.array(x >> np.uint64(32), dtype=np.uint32)
+    lower = np.uint64(0xffffffff)
+    lower = np.array(x & lower, dtype=np.uint32)
+    joined = np.column_stack([lower, upper]).ravel()
+    return uint32_to_float32(joined)
+
+
+def uniform32_from_uint53(x):
+    x = np.uint64(x) >> np.uint64(16)
+    x = np.uint32(x & np.uint64(0xffffffff))
+    return uint32_to_float32(x)
+
+
+def uniform32_from_uint32(x):
+    return uint32_to_float32(x)
+
+
+def uniform32_from_uint(x, bits):
+    if bits == 64:
+        return uniform32_from_uint64(x)
+    elif bits == 53:
+        return uniform32_from_uint53(x)
+    elif bits == 32:
+        return uniform32_from_uint32(x)
+    else:
+        raise NotImplementedError
+
+
+def uniform_from_uint(x, bits):
+    if bits in (64, 63, 53):
+        return uniform_from_uint64(x)
+    elif bits == 32:
+        return uniform_from_uint32(x)
+
+
+def uniform_from_uint64(x):
+    return (x >> np.uint64(11)) * (1.0 / 9007199254740992.0)
+
+
+def uniform_from_uint32(x):
+    out = np.empty(len(x) // 2)
+    for i in range(0, len(x), 2):
+        a = x[i] >> 5
+        b = x[i + 1] >> 6
+        out[i // 2] = (a * 67108864.0 + b) / 9007199254740992.0
+    return out
+
+
+def uniform_from_dsfmt(x):
+    return x.view(np.double) - 1.0
+
+
+def gauss_from_uint(x, n, bits):
+    if bits in (64, 63):
+        doubles = uniform_from_uint64(x)
+    elif bits == 32:
+        doubles = uniform_from_uint32(x)
+    else:  # bits == 'dsfmt'
+        doubles = uniform_from_dsfmt(x)
+    gauss = []
+    loc = 0
+    x1 = x2 = 0.0
+    while len(gauss) < n:
+        r2 = 2
+        while r2 >= 1.0 or r2 == 0.0:
+            x1 = 2.0 * doubles[loc] - 1.0
+            x2 = 2.0 * doubles[loc + 1] - 1.0
+            r2 = x1 * x1 + x2 * x2
+            loc += 2
+
+        f = np.sqrt(-2.0 * np.log(r2) / r2)
+        gauss.append(f * x2)
+        gauss.append(f * x1)
+
+    return gauss[:n]
+
+
+def test_seedsequence():
+    from numpy.random.bit_generator import (ISeedSequence,
+                                            ISpawnableSeedSequence,
+                                            SeedlessSeedSequence)
+
+    s1 = SeedSequence(range(10), spawn_key=(1, 2), pool_size=6)
+    s1.spawn(10)
+    s2 = SeedSequence(**s1.state)
+    assert_equal(s1.state, s2.state)
+    assert_equal(s1.n_children_spawned, s2.n_children_spawned)
+
+    # The interfaces cannot be instantiated themselves.
+    assert_raises(TypeError, ISeedSequence)
+    assert_raises(TypeError, ISpawnableSeedSequence)
+    dummy = SeedlessSeedSequence()
+    assert_raises(NotImplementedError, dummy.generate_state, 10)
+    assert len(dummy.spawn(10)) == 10
+
+
+def test_generator_spawning():
+    """ Test spawning new generators and bit_generators directly.
+    """
+    rng = np.random.default_rng()
+    seq = rng.bit_generator.seed_seq
+    new_ss = seq.spawn(5)
+    expected_keys = [seq.spawn_key + (i,) for i in range(5)]
+    assert [c.spawn_key for c in new_ss] == expected_keys
+
+    new_bgs = rng.bit_generator.spawn(5)
+    expected_keys = [seq.spawn_key + (i,) for i in range(5, 10)]
+    assert [bg.seed_seq.spawn_key for bg in new_bgs] == expected_keys
+
+    new_rngs = rng.spawn(5)
+    expected_keys = [seq.spawn_key + (i,) for i in range(10, 15)]
+    found_keys = [rng.bit_generator.seed_seq.spawn_key for rng in new_rngs]
+    assert found_keys == expected_keys
+
+    # Sanity check that streams are actually different:
+    assert new_rngs[0].uniform() != new_rngs[1].uniform()
+
+
+def test_non_spawnable():
+    from numpy.random.bit_generator import ISeedSequence
+
+    class FakeSeedSequence:
+        def generate_state(self, n_words, dtype=np.uint32):
+            return np.zeros(n_words, dtype=dtype)
+
+    ISeedSequence.register(FakeSeedSequence)
+
+    rng = np.random.default_rng(FakeSeedSequence())
+
+    with pytest.raises(TypeError, match="The underlying SeedSequence"):
+        rng.spawn(5)
+
+    with pytest.raises(TypeError, match="The underlying SeedSequence"):
+        rng.bit_generator.spawn(5)
+
+
+class Base:
+    dtype = np.uint64
+    data2 = data1 = {}
+
+    @classmethod
+    def setup_class(cls):
+        cls.bit_generator = PCG64
+        cls.bits = 64
+        cls.dtype = np.uint64
+        cls.seed_error_type = TypeError
+        cls.invalid_init_types = []
+        cls.invalid_init_values = []
+
+    @classmethod
+    def _read_csv(cls, filename):
+        with open(filename) as csv:
+            seed = csv.readline()
+            seed = seed.split(',')
+            seed = [int(s.strip(), 0) for s in seed[1:]]
+            data = []
+            for line in csv:
+                data.append(int(line.split(',')[-1].strip(), 0))
+            return {'seed': seed, 'data': np.array(data, dtype=cls.dtype)}
+
+    def test_raw(self):
+        bit_generator = self.bit_generator(*self.data1['seed'])
+        uints = bit_generator.random_raw(1000)
+        assert_equal(uints, self.data1['data'])
+
+        bit_generator = self.bit_generator(*self.data1['seed'])
+        uints = bit_generator.random_raw()
+        assert_equal(uints, self.data1['data'][0])
+
+        bit_generator = self.bit_generator(*self.data2['seed'])
+        uints = bit_generator.random_raw(1000)
+        assert_equal(uints, self.data2['data'])
+
+    def test_random_raw(self):
+        bit_generator = self.bit_generator(*self.data1['seed'])
+        uints = bit_generator.random_raw(output=False)
+        assert uints is None
+        uints = bit_generator.random_raw(1000, output=False)
+        assert uints is None
+
+    def test_gauss_inv(self):
+        n = 25
+        rs = RandomState(self.bit_generator(*self.data1['seed']))
+        gauss = rs.standard_normal(n)
+        assert_allclose(gauss,
+                        gauss_from_uint(self.data1['data'], n, self.bits))
+
+        rs = RandomState(self.bit_generator(*self.data2['seed']))
+        gauss = rs.standard_normal(25)
+        assert_allclose(gauss,
+                        gauss_from_uint(self.data2['data'], n, self.bits))
+
+    def test_uniform_double(self):
+        rs = Generator(self.bit_generator(*self.data1['seed']))
+        vals = uniform_from_uint(self.data1['data'], self.bits)
+        uniforms = rs.random(len(vals))
+        assert_allclose(uniforms, vals)
+        assert_equal(uniforms.dtype, np.float64)
+
+        rs = Generator(self.bit_generator(*self.data2['seed']))
+        vals = uniform_from_uint(self.data2['data'], self.bits)
+        uniforms = rs.random(len(vals))
+        assert_allclose(uniforms, vals)
+        assert_equal(uniforms.dtype, np.float64)
+
+    def test_uniform_float(self):
+        rs = Generator(self.bit_generator(*self.data1['seed']))
+        vals = uniform32_from_uint(self.data1['data'], self.bits)
+        uniforms = rs.random(len(vals), dtype=np.float32)
+        assert_allclose(uniforms, vals)
+        assert_equal(uniforms.dtype, np.float32)
+
+        rs = Generator(self.bit_generator(*self.data2['seed']))
+        vals = uniform32_from_uint(self.data2['data'], self.bits)
+        uniforms = rs.random(len(vals), dtype=np.float32)
+        assert_allclose(uniforms, vals)
+        assert_equal(uniforms.dtype, np.float32)
+
+    def test_repr(self):
+        rs = Generator(self.bit_generator(*self.data1['seed']))
+        assert 'Generator' in repr(rs)
+        assert f'{id(rs):#x}'.upper().replace('X', 'x') in repr(rs)
+
+    def test_str(self):
+        rs = Generator(self.bit_generator(*self.data1['seed']))
+        assert 'Generator' in str(rs)
+        assert str(self.bit_generator.__name__) in str(rs)
+        assert f'{id(rs):#x}'.upper().replace('X', 'x') not in str(rs)
+
+    def test_pickle(self):
+        import pickle
+
+        bit_generator = self.bit_generator(*self.data1['seed'])
+        state = bit_generator.state
+        bitgen_pkl = pickle.dumps(bit_generator)
+        reloaded = pickle.loads(bitgen_pkl)
+        reloaded_state = reloaded.state
+        assert_array_equal(Generator(bit_generator).standard_normal(1000),
+                           Generator(reloaded).standard_normal(1000))
+        assert bit_generator is not reloaded
+        assert_state_equal(reloaded_state, state)
+
+        ss = SeedSequence(100)
+        aa = pickle.loads(pickle.dumps(ss))
+        assert_equal(ss.state, aa.state)
+
+    def test_pickle_preserves_seed_sequence(self):
+        # GH 26234
+        # Add explicit test that bit generators preserve seed sequences
+        import pickle
+
+        bit_generator = self.bit_generator(*self.data1['seed'])
+        ss = bit_generator.seed_seq
+        bg_plk = pickle.loads(pickle.dumps(bit_generator))
+        ss_plk = bg_plk.seed_seq
+        assert_equal(ss.state, ss_plk.state)
+        assert_equal(ss.pool, ss_plk.pool)
+
+        bit_generator.seed_seq.spawn(10)
+        bg_plk = pickle.loads(pickle.dumps(bit_generator))
+        ss_plk = bg_plk.seed_seq
+        assert_equal(ss.state, ss_plk.state)
+        assert_equal(ss.n_children_spawned, ss_plk.n_children_spawned)
+
+    def test_invalid_state_type(self):
+        bit_generator = self.bit_generator(*self.data1['seed'])
+        with pytest.raises(TypeError):
+            bit_generator.state = {'1'}
+
+    def test_invalid_state_value(self):
+        bit_generator = self.bit_generator(*self.data1['seed'])
+        state = bit_generator.state
+        state['bit_generator'] = 'otherBitGenerator'
+        with pytest.raises(ValueError):
+            bit_generator.state = state
+
+    def test_invalid_init_type(self):
+        bit_generator = self.bit_generator
+        for st in self.invalid_init_types:
+            with pytest.raises(TypeError):
+                bit_generator(*st)
+
+    def test_invalid_init_values(self):
+        bit_generator = self.bit_generator
+        for st in self.invalid_init_values:
+            with pytest.raises((ValueError, OverflowError)):
+                bit_generator(*st)
+
+    def test_benchmark(self):
+        bit_generator = self.bit_generator(*self.data1['seed'])
+        bit_generator._benchmark(1)
+        bit_generator._benchmark(1, 'double')
+        with pytest.raises(ValueError):
+            bit_generator._benchmark(1, 'int32')
+
+    @pytest.mark.skipif(MISSING_CFFI, reason='cffi not available')
+    def test_cffi(self):
+        bit_generator = self.bit_generator(*self.data1['seed'])
+        cffi_interface = bit_generator.cffi
+        assert isinstance(cffi_interface, interface)
+        other_cffi_interface = bit_generator.cffi
+        assert other_cffi_interface is cffi_interface
+
+    @pytest.mark.skipif(MISSING_CTYPES, reason='ctypes not available')
+    def test_ctypes(self):
+        bit_generator = self.bit_generator(*self.data1['seed'])
+        ctypes_interface = bit_generator.ctypes
+        assert isinstance(ctypes_interface, interface)
+        other_ctypes_interface = bit_generator.ctypes
+        assert other_ctypes_interface is ctypes_interface
+
+    def test_getstate(self):
+        bit_generator = self.bit_generator(*self.data1['seed'])
+        state = bit_generator.state
+        alt_state = bit_generator.__getstate__()
+        assert isinstance(alt_state, tuple)
+        assert_state_equal(state, alt_state[0])
+        assert isinstance(alt_state[1], SeedSequence)
+
+class TestPhilox(Base):
+    @classmethod
+    def setup_class(cls):
+        cls.bit_generator = Philox
+        cls.bits = 64
+        cls.dtype = np.uint64
+        cls.data1 = cls._read_csv(
+            join(pwd, './data/philox-testset-1.csv'))
+        cls.data2 = cls._read_csv(
+            join(pwd, './data/philox-testset-2.csv'))
+        cls.seed_error_type = TypeError
+        cls.invalid_init_types = []
+        cls.invalid_init_values = [(1, None, 1), (-1,), (None, None, 2 ** 257 + 1)]
+
+    def test_set_key(self):
+        bit_generator = self.bit_generator(*self.data1['seed'])
+        state = bit_generator.state
+        keyed = self.bit_generator(counter=state['state']['counter'],
+                                   key=state['state']['key'])
+        assert_state_equal(bit_generator.state, keyed.state)
+
+
+class TestPCG64(Base):
+    @classmethod
+    def setup_class(cls):
+        cls.bit_generator = PCG64
+        cls.bits = 64
+        cls.dtype = np.uint64
+        cls.data1 = cls._read_csv(join(pwd, './data/pcg64-testset-1.csv'))
+        cls.data2 = cls._read_csv(join(pwd, './data/pcg64-testset-2.csv'))
+        cls.seed_error_type = (ValueError, TypeError)
+        cls.invalid_init_types = [(3.2,), ([None],), (1, None)]
+        cls.invalid_init_values = [(-1,)]
+
+    def test_advance_symmetry(self):
+        rs = Generator(self.bit_generator(*self.data1['seed']))
+        state = rs.bit_generator.state
+        step = -0x9e3779b97f4a7c150000000000000000
+        rs.bit_generator.advance(step)
+        val_neg = rs.integers(10)
+        rs.bit_generator.state = state
+        rs.bit_generator.advance(2**128 + step)
+        val_pos = rs.integers(10)
+        rs.bit_generator.state = state
+        rs.bit_generator.advance(10 * 2**128 + step)
+        val_big = rs.integers(10)
+        assert val_neg == val_pos
+        assert val_big == val_pos
+
+    def test_advange_large(self):
+        rs = Generator(self.bit_generator(38219308213743))
+        pcg = rs.bit_generator
+        state = pcg.state["state"]
+        initial_state = 287608843259529770491897792873167516365
+        assert state["state"] == initial_state
+        pcg.advance(sum(2**i for i in (96, 64, 32, 16, 8, 4, 2, 1)))
+        state = pcg.state["state"]
+        advanced_state = 135275564607035429730177404003164635391
+        assert state["state"] == advanced_state
+
+
+
+class TestPCG64DXSM(Base):
+    @classmethod
+    def setup_class(cls):
+        cls.bit_generator = PCG64DXSM
+        cls.bits = 64
+        cls.dtype = np.uint64
+        cls.data1 = cls._read_csv(join(pwd, './data/pcg64dxsm-testset-1.csv'))
+        cls.data2 = cls._read_csv(join(pwd, './data/pcg64dxsm-testset-2.csv'))
+        cls.seed_error_type = (ValueError, TypeError)
+        cls.invalid_init_types = [(3.2,), ([None],), (1, None)]
+        cls.invalid_init_values = [(-1,)]
+
+    def test_advance_symmetry(self):
+        rs = Generator(self.bit_generator(*self.data1['seed']))
+        state = rs.bit_generator.state
+        step = -0x9e3779b97f4a7c150000000000000000
+        rs.bit_generator.advance(step)
+        val_neg = rs.integers(10)
+        rs.bit_generator.state = state
+        rs.bit_generator.advance(2**128 + step)
+        val_pos = rs.integers(10)
+        rs.bit_generator.state = state
+        rs.bit_generator.advance(10 * 2**128 + step)
+        val_big = rs.integers(10)
+        assert val_neg == val_pos
+        assert val_big == val_pos
+
+    def test_advange_large(self):
+        rs = Generator(self.bit_generator(38219308213743))
+        pcg = rs.bit_generator
+        state = pcg.state
+        initial_state = 287608843259529770491897792873167516365
+        assert state["state"]["state"] == initial_state
+        pcg.advance(sum(2**i for i in (96, 64, 32, 16, 8, 4, 2, 1)))
+        state = pcg.state["state"]
+        advanced_state = 277778083536782149546677086420637664879
+        assert state["state"] == advanced_state
+
+
+class TestMT19937(Base):
+    @classmethod
+    def setup_class(cls):
+        cls.bit_generator = MT19937
+        cls.bits = 32
+        cls.dtype = np.uint32
+        cls.data1 = cls._read_csv(join(pwd, './data/mt19937-testset-1.csv'))
+        cls.data2 = cls._read_csv(join(pwd, './data/mt19937-testset-2.csv'))
+        cls.seed_error_type = ValueError
+        cls.invalid_init_types = []
+        cls.invalid_init_values = [(-1,)]
+
+    def test_seed_float_array(self):
+        assert_raises(TypeError, self.bit_generator, np.array([np.pi]))
+        assert_raises(TypeError, self.bit_generator, np.array([-np.pi]))
+        assert_raises(TypeError, self.bit_generator, np.array([np.pi, -np.pi]))
+        assert_raises(TypeError, self.bit_generator, np.array([0, np.pi]))
+        assert_raises(TypeError, self.bit_generator, [np.pi])
+        assert_raises(TypeError, self.bit_generator, [0, np.pi])
+
+    def test_state_tuple(self):
+        rs = Generator(self.bit_generator(*self.data1['seed']))
+        bit_generator = rs.bit_generator
+        state = bit_generator.state
+        desired = rs.integers(2 ** 16)
+        tup = (state['bit_generator'], state['state']['key'],
+               state['state']['pos'])
+        bit_generator.state = tup
+        actual = rs.integers(2 ** 16)
+        assert_equal(actual, desired)
+        tup = tup + (0, 0.0)
+        bit_generator.state = tup
+        actual = rs.integers(2 ** 16)
+        assert_equal(actual, desired)
+
+
+class TestSFC64(Base):
+    @classmethod
+    def setup_class(cls):
+        cls.bit_generator = SFC64
+        cls.bits = 64
+        cls.dtype = np.uint64
+        cls.data1 = cls._read_csv(
+            join(pwd, './data/sfc64-testset-1.csv'))
+        cls.data2 = cls._read_csv(
+            join(pwd, './data/sfc64-testset-2.csv'))
+        cls.seed_error_type = (ValueError, TypeError)
+        cls.invalid_init_types = [(3.2,), ([None],), (1, None)]
+        cls.invalid_init_values = [(-1,)]
+
+    def test_legacy_pickle(self):
+        # Pickling format was changed in 2.0.x
+        import gzip
+        import pickle
+
+        expected_state = np.array(
+            [
+                9957867060933711493,
+                532597980065565856,
+                14769588338631205282,
+                13
+            ],
+            dtype=np.uint64
+        )
+
+        base_path = os.path.split(os.path.abspath(__file__))[0]
+        pkl_file = os.path.join(base_path, "data", f"sfc64_np126.pkl.gz")
+        with gzip.open(pkl_file) as gz:
+            sfc = pickle.load(gz)
+
+        assert isinstance(sfc, SFC64)
+        assert_equal(sfc.state["state"]["state"], expected_state)
+
+
+class TestDefaultRNG:
+    def test_seed(self):
+        for args in [(), (None,), (1234,), ([1234, 5678],)]:
+            rg = default_rng(*args)
+            assert isinstance(rg.bit_generator, PCG64)
+
+    def test_passthrough(self):
+        bg = Philox()
+        rg = default_rng(bg)
+        assert rg.bit_generator is bg
+        rg2 = default_rng(rg)
+        assert rg2 is rg
+        assert rg2.bit_generator is bg
diff --git a/venv/lib/python3.12/site-packages/numpy/random/tests/test_extending.py b/venv/lib/python3.12/site-packages/numpy/random/tests/test_extending.py
new file mode 100644
index 00000000..791fbaba
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/random/tests/test_extending.py
@@ -0,0 +1,119 @@
+from importlib.util import spec_from_file_location, module_from_spec
+import os
+import pathlib
+import pytest
+import shutil
+import subprocess
+import sys
+import sysconfig
+import textwrap
+import warnings
+
+import numpy as np
+from numpy.testing import IS_WASM, IS_EDITABLE
+
+
+try:
+    import cffi
+except ImportError:
+    cffi = None
+
+if sys.flags.optimize > 1:
+    # no docstrings present to inspect when PYTHONOPTIMIZE/Py_OptimizeFlag > 1
+    # cffi cannot succeed
+    cffi = None
+
+try:
+    with warnings.catch_warnings(record=True) as w:
+        # numba issue gh-4733
+        warnings.filterwarnings('always', '', DeprecationWarning)
+        import numba
+except (ImportError, SystemError):
+    # Certain numpy/numba versions trigger a SystemError due to a numba bug
+    numba = None
+
+try:
+    import cython
+    from Cython.Compiler.Version import version as cython_version
+except ImportError:
+    cython = None
+else:
+    from numpy._utils import _pep440
+    # Note: keep in sync with the one in pyproject.toml
+    required_version = '3.0.6'
+    if _pep440.parse(cython_version) < _pep440.Version(required_version):
+        # too old or wrong cython, skip the test
+        cython = None
+
+
+@pytest.mark.skipif(
+    IS_EDITABLE,
+    reason='Editable install cannot find .pxd headers'
+)
+@pytest.mark.skipif(
+        sys.platform == "win32" and sys.maxsize < 2**32,
+        reason="Failing in 32-bit Windows wheel build job, skip for now"
+)
+@pytest.mark.skipif(IS_WASM, reason="Can't start subprocess")
+@pytest.mark.skipif(cython is None, reason="requires cython")
+@pytest.mark.slow
+def test_cython(tmp_path):
+    import glob
+    # build the examples in a temporary directory
+    srcdir = os.path.join(os.path.dirname(__file__), '..')
+    shutil.copytree(srcdir, tmp_path / 'random')
+    build_dir = tmp_path / 'random' / '_examples' / 'cython'
+    target_dir = build_dir / "build"
+    os.makedirs(target_dir, exist_ok=True)
+    if sys.platform == "win32":
+        subprocess.check_call(["meson", "setup",
+                               "--buildtype=release", 
+                               "--vsenv", str(build_dir)],
+                              cwd=target_dir,
+                              )
+    else:
+        subprocess.check_call(["meson", "setup", str(build_dir)],
+                              cwd=target_dir
+                              )
+    subprocess.check_call(["meson", "compile", "-vv"], cwd=target_dir)
+
+    # gh-16162: make sure numpy's __init__.pxd was used for cython
+    # not really part of this test, but it is a convenient place to check
+
+    g = glob.glob(str(target_dir / "*" / "extending.pyx.c"))
+    with open(g[0]) as fid:
+        txt_to_find = 'NumPy API declarations from "numpy/__init__'
+        for i, line in enumerate(fid):
+            if txt_to_find in line:
+                break
+        else:
+            assert False, ("Could not find '{}' in C file, "
+                           "wrong pxd used".format(txt_to_find))
+    # import without adding the directory to sys.path
+    suffix = sysconfig.get_config_var('EXT_SUFFIX')
+
+    def load(modname):
+        so = (target_dir / modname).with_suffix(suffix)
+        spec = spec_from_file_location(modname, so)
+        mod = module_from_spec(spec)
+        spec.loader.exec_module(mod)
+        return mod
+
+    # test that the module can be imported
+    load("extending")
+    load("extending_cpp")
+    # actually test the cython c-extension
+    extending_distributions = load("extending_distributions")
+    from numpy.random import PCG64
+    values = extending_distributions.uniforms_ex(PCG64(0), 10, 'd')
+    assert values.shape == (10,)
+    assert values.dtype == np.float64
+
+@pytest.mark.skipif(numba is None or cffi is None,
+                    reason="requires numba and cffi")
+def test_numba():
+    from numpy.random._examples.numba import extending  # noqa: F401
+
+@pytest.mark.skipif(cffi is None, reason="requires cffi")
+def test_cffi():
+    from numpy.random._examples.cffi import extending  # noqa: F401
diff --git a/venv/lib/python3.12/site-packages/numpy/random/tests/test_generator_mt19937.py b/venv/lib/python3.12/site-packages/numpy/random/tests/test_generator_mt19937.py
new file mode 100644
index 00000000..514f9af2
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/random/tests/test_generator_mt19937.py
@@ -0,0 +1,2797 @@
+import os.path
+import sys
+import hashlib
+
+import pytest
+
+import numpy as np
+from numpy.exceptions import AxisError
+from numpy.linalg import LinAlgError
+from numpy.testing import (
+    assert_, assert_raises, assert_equal, assert_allclose,
+    assert_warns, assert_no_warnings, assert_array_equal,
+    assert_array_almost_equal, suppress_warnings, IS_WASM)
+
+from numpy.random import Generator, MT19937, SeedSequence, RandomState
+
+random = Generator(MT19937())
+
+JUMP_TEST_DATA = [
+    {
+        "seed": 0,
+        "steps": 10,
+        "initial": {"key_sha256": "bb1636883c2707b51c5b7fc26c6927af4430f2e0785a8c7bc886337f919f9edf", "pos": 9},
+        "jumped": {"key_sha256": "ff682ac12bb140f2d72fba8d3506cf4e46817a0db27aae1683867629031d8d55", "pos": 598},
+    },
+    {
+        "seed":384908324,
+        "steps":312,
+        "initial": {"key_sha256": "16b791a1e04886ccbbb4d448d6ff791267dc458ae599475d08d5cced29d11614", "pos": 311},
+        "jumped": {"key_sha256": "a0110a2cf23b56be0feaed8f787a7fc84bef0cb5623003d75b26bdfa1c18002c", "pos": 276},
+    },
+    {
+        "seed": [839438204, 980239840, 859048019, 821],
+        "steps": 511,
+        "initial": {"key_sha256": "d306cf01314d51bd37892d874308200951a35265ede54d200f1e065004c3e9ea", "pos": 510},
+        "jumped": {"key_sha256": "0e00ab449f01a5195a83b4aee0dfbc2ce8d46466a640b92e33977d2e42f777f8", "pos": 475},
+    },
+]
+
+
+@pytest.fixture(scope='module', params=[True, False])
+def endpoint(request):
+    return request.param
+
+
+class TestSeed:
+    def test_scalar(self):
+        s = Generator(MT19937(0))
+        assert_equal(s.integers(1000), 479)
+        s = Generator(MT19937(4294967295))
+        assert_equal(s.integers(1000), 324)
+
+    def test_array(self):
+        s = Generator(MT19937(range(10)))
+        assert_equal(s.integers(1000), 465)
+        s = Generator(MT19937(np.arange(10)))
+        assert_equal(s.integers(1000), 465)
+        s = Generator(MT19937([0]))
+        assert_equal(s.integers(1000), 479)
+        s = Generator(MT19937([4294967295]))
+        assert_equal(s.integers(1000), 324)
+
+    def test_seedsequence(self):
+        s = MT19937(SeedSequence(0))
+        assert_equal(s.random_raw(1), 2058676884)
+
+    def test_invalid_scalar(self):
+        # seed must be an unsigned 32 bit integer
+        assert_raises(TypeError, MT19937, -0.5)
+        assert_raises(ValueError, MT19937, -1)
+
+    def test_invalid_array(self):
+        # seed must be an unsigned integer
+        assert_raises(TypeError, MT19937, [-0.5])
+        assert_raises(ValueError, MT19937, [-1])
+        assert_raises(ValueError, MT19937, [1, -2, 4294967296])
+
+    def test_noninstantized_bitgen(self):
+        assert_raises(ValueError, Generator, MT19937)
+
+
+class TestBinomial:
+    def test_n_zero(self):
+        # Tests the corner case of n == 0 for the binomial distribution.
+        # binomial(0, p) should be zero for any p in [0, 1].
+        # This test addresses issue #3480.
+        zeros = np.zeros(2, dtype='int')
+        for p in [0, .5, 1]:
+            assert_(random.binomial(0, p) == 0)
+            assert_array_equal(random.binomial(zeros, p), zeros)
+
+    def test_p_is_nan(self):
+        # Issue #4571.
+        assert_raises(ValueError, random.binomial, 1, np.nan)
+
+
+class TestMultinomial:
+    def test_basic(self):
+        random.multinomial(100, [0.2, 0.8])
+
+    def test_zero_probability(self):
+        random.multinomial(100, [0.2, 0.8, 0.0, 0.0, 0.0])
+
+    def test_int_negative_interval(self):
+        assert_(-5 <= random.integers(-5, -1) < -1)
+        x = random.integers(-5, -1, 5)
+        assert_(np.all(-5 <= x))
+        assert_(np.all(x < -1))
+
+    def test_size(self):
+        # gh-3173
+        p = [0.5, 0.5]
+        assert_equal(random.multinomial(1, p, np.uint32(1)).shape, (1, 2))
+        assert_equal(random.multinomial(1, p, np.uint32(1)).shape, (1, 2))
+        assert_equal(random.multinomial(1, p, np.uint32(1)).shape, (1, 2))
+        assert_equal(random.multinomial(1, p, [2, 2]).shape, (2, 2, 2))
+        assert_equal(random.multinomial(1, p, (2, 2)).shape, (2, 2, 2))
+        assert_equal(random.multinomial(1, p, np.array((2, 2))).shape,
+                     (2, 2, 2))
+
+        assert_raises(TypeError, random.multinomial, 1, p,
+                      float(1))
+
+    def test_invalid_prob(self):
+        assert_raises(ValueError, random.multinomial, 100, [1.1, 0.2])
+        assert_raises(ValueError, random.multinomial, 100, [-.1, 0.9])
+
+    def test_invalid_n(self):
+        assert_raises(ValueError, random.multinomial, -1, [0.8, 0.2])
+        assert_raises(ValueError, random.multinomial, [-1] * 10, [0.8, 0.2])
+
+    def test_p_non_contiguous(self):
+        p = np.arange(15.)
+        p /= np.sum(p[1::3])
+        pvals = p[1::3]
+        random = Generator(MT19937(1432985819))
+        non_contig = random.multinomial(100, pvals=pvals)
+        random = Generator(MT19937(1432985819))
+        contig = random.multinomial(100, pvals=np.ascontiguousarray(pvals))
+        assert_array_equal(non_contig, contig)
+
+    def test_multinomial_pvals_float32(self):
+        x = np.array([9.9e-01, 9.9e-01, 1.0e-09, 1.0e-09, 1.0e-09, 1.0e-09,
+                      1.0e-09, 1.0e-09, 1.0e-09, 1.0e-09], dtype=np.float32)
+        pvals = x / x.sum()
+        random = Generator(MT19937(1432985819))
+        match = r"[\w\s]*pvals array is cast to 64-bit floating"
+        with pytest.raises(ValueError, match=match):
+            random.multinomial(1, pvals)
+
+
+class TestMultivariateHypergeometric:
+
+    def setup_method(self):
+        self.seed = 8675309
+
+    def test_argument_validation(self):
+        # Error cases...
+
+        # `colors` must be a 1-d sequence
+        assert_raises(ValueError, random.multivariate_hypergeometric,
+                      10, 4)
+
+        # Negative nsample
+        assert_raises(ValueError, random.multivariate_hypergeometric,
+                      [2, 3, 4], -1)
+
+        # Negative color
+        assert_raises(ValueError, random.multivariate_hypergeometric,
+                      [-1, 2, 3], 2)
+
+        # nsample exceeds sum(colors)
+        assert_raises(ValueError, random.multivariate_hypergeometric,
+                      [2, 3, 4], 10)
+
+        # nsample exceeds sum(colors) (edge case of empty colors)
+        assert_raises(ValueError, random.multivariate_hypergeometric,
+                      [], 1)
+
+        # Validation errors associated with very large values in colors.
+        assert_raises(ValueError, random.multivariate_hypergeometric,
+                      [999999999, 101], 5, 1, 'marginals')
+
+        int64_info = np.iinfo(np.int64)
+        max_int64 = int64_info.max
+        max_int64_index = max_int64 // int64_info.dtype.itemsize
+        assert_raises(ValueError, random.multivariate_hypergeometric,
+                      [max_int64_index - 100, 101], 5, 1, 'count')
+
+    @pytest.mark.parametrize('method', ['count', 'marginals'])
+    def test_edge_cases(self, method):
+        # Set the seed, but in fact, all the results in this test are
+        # deterministic, so we don't really need this.
+        random = Generator(MT19937(self.seed))
+
+        x = random.multivariate_hypergeometric([0, 0, 0], 0, method=method)
+        assert_array_equal(x, [0, 0, 0])
+
+        x = random.multivariate_hypergeometric([], 0, method=method)
+        assert_array_equal(x, [])
+
+        x = random.multivariate_hypergeometric([], 0, size=1, method=method)
+        assert_array_equal(x, np.empty((1, 0), dtype=np.int64))
+
+        x = random.multivariate_hypergeometric([1, 2, 3], 0, method=method)
+        assert_array_equal(x, [0, 0, 0])
+
+        x = random.multivariate_hypergeometric([9, 0, 0], 3, method=method)
+        assert_array_equal(x, [3, 0, 0])
+
+        colors = [1, 1, 0, 1, 1]
+        x = random.multivariate_hypergeometric(colors, sum(colors),
+                                               method=method)
+        assert_array_equal(x, colors)
+
+        x = random.multivariate_hypergeometric([3, 4, 5], 12, size=3,
+                                               method=method)
+        assert_array_equal(x, [[3, 4, 5]]*3)
+
+    # Cases for nsample:
+    #     nsample < 10
+    #     10 <= nsample < colors.sum()/2
+    #     colors.sum()/2 < nsample < colors.sum() - 10
+    #     colors.sum() - 10 < nsample < colors.sum()
+    @pytest.mark.parametrize('nsample', [8, 25, 45, 55])
+    @pytest.mark.parametrize('method', ['count', 'marginals'])
+    @pytest.mark.parametrize('size', [5, (2, 3), 150000])
+    def test_typical_cases(self, nsample, method, size):
+        random = Generator(MT19937(self.seed))
+
+        colors = np.array([10, 5, 20, 25])
+        sample = random.multivariate_hypergeometric(colors, nsample, size,
+                                                    method=method)
+        if isinstance(size, int):
+            expected_shape = (size,) + colors.shape
+        else:
+            expected_shape = size + colors.shape
+        assert_equal(sample.shape, expected_shape)
+        assert_((sample >= 0).all())
+        assert_((sample <= colors).all())
+        assert_array_equal(sample.sum(axis=-1),
+                           np.full(size, fill_value=nsample, dtype=int))
+        if isinstance(size, int) and size >= 100000:
+            # This sample is large enough to compare its mean to
+            # the expected values.
+            assert_allclose(sample.mean(axis=0),
+                            nsample * colors / colors.sum(),
+                            rtol=1e-3, atol=0.005)
+
+    def test_repeatability1(self):
+        random = Generator(MT19937(self.seed))
+        sample = random.multivariate_hypergeometric([3, 4, 5], 5, size=5,
+                                                    method='count')
+        expected = np.array([[2, 1, 2],
+                             [2, 1, 2],
+                             [1, 1, 3],
+                             [2, 0, 3],
+                             [2, 1, 2]])
+        assert_array_equal(sample, expected)
+
+    def test_repeatability2(self):
+        random = Generator(MT19937(self.seed))
+        sample = random.multivariate_hypergeometric([20, 30, 50], 50,
+                                                    size=5,
+                                                    method='marginals')
+        expected = np.array([[ 9, 17, 24],
+                             [ 7, 13, 30],
+                             [ 9, 15, 26],
+                             [ 9, 17, 24],
+                             [12, 14, 24]])
+        assert_array_equal(sample, expected)
+
+    def test_repeatability3(self):
+        random = Generator(MT19937(self.seed))
+        sample = random.multivariate_hypergeometric([20, 30, 50], 12,
+                                                    size=5,
+                                                    method='marginals')
+        expected = np.array([[2, 3, 7],
+                             [5, 3, 4],
+                             [2, 5, 5],
+                             [5, 3, 4],
+                             [1, 5, 6]])
+        assert_array_equal(sample, expected)
+
+
+class TestSetState:
+    def setup_method(self):
+        self.seed = 1234567890
+        self.rg = Generator(MT19937(self.seed))
+        self.bit_generator = self.rg.bit_generator
+        self.state = self.bit_generator.state
+        self.legacy_state = (self.state['bit_generator'],
+                             self.state['state']['key'],
+                             self.state['state']['pos'])
+
+    def test_gaussian_reset(self):
+        # Make sure the cached every-other-Gaussian is reset.
+        old = self.rg.standard_normal(size=3)
+        self.bit_generator.state = self.state
+        new = self.rg.standard_normal(size=3)
+        assert_(np.all(old == new))
+
+    def test_gaussian_reset_in_media_res(self):
+        # When the state is saved with a cached Gaussian, make sure the
+        # cached Gaussian is restored.
+
+        self.rg.standard_normal()
+        state = self.bit_generator.state
+        old = self.rg.standard_normal(size=3)
+        self.bit_generator.state = state
+        new = self.rg.standard_normal(size=3)
+        assert_(np.all(old == new))
+
+    def test_negative_binomial(self):
+        # Ensure that the negative binomial results take floating point
+        # arguments without truncation.
+        self.rg.negative_binomial(0.5, 0.5)
+
+
+class TestIntegers:
+    rfunc = random.integers
+
+    # valid integer/boolean types
+    itype = [bool, np.int8, np.uint8, np.int16, np.uint16,
+             np.int32, np.uint32, np.int64, np.uint64]
+
+    def test_unsupported_type(self, endpoint):
+        assert_raises(TypeError, self.rfunc, 1, endpoint=endpoint, dtype=float)
+
+    def test_bounds_checking(self, endpoint):
+        for dt in self.itype:
+            lbnd = 0 if dt is bool else np.iinfo(dt).min
+            ubnd = 2 if dt is bool else np.iinfo(dt).max + 1
+            ubnd = ubnd - 1 if endpoint else ubnd
+            assert_raises(ValueError, self.rfunc, lbnd - 1, ubnd,
+                          endpoint=endpoint, dtype=dt)
+            assert_raises(ValueError, self.rfunc, lbnd, ubnd + 1,
+                          endpoint=endpoint, dtype=dt)
+            assert_raises(ValueError, self.rfunc, ubnd, lbnd,
+                          endpoint=endpoint, dtype=dt)
+            assert_raises(ValueError, self.rfunc, 1, 0, endpoint=endpoint,
+                          dtype=dt)
+
+            assert_raises(ValueError, self.rfunc, [lbnd - 1], ubnd,
+                          endpoint=endpoint, dtype=dt)
+            assert_raises(ValueError, self.rfunc, [lbnd], [ubnd + 1],
+                          endpoint=endpoint, dtype=dt)
+            assert_raises(ValueError, self.rfunc, [ubnd], [lbnd],
+                          endpoint=endpoint, dtype=dt)
+            assert_raises(ValueError, self.rfunc, 1, [0],
+                          endpoint=endpoint, dtype=dt)
+            assert_raises(ValueError, self.rfunc, [ubnd+1], [ubnd],
+                          endpoint=endpoint, dtype=dt)
+
+    def test_bounds_checking_array(self, endpoint):
+        for dt in self.itype:
+            lbnd = 0 if dt is bool else np.iinfo(dt).min
+            ubnd = 2 if dt is bool else np.iinfo(dt).max + (not endpoint)
+
+            assert_raises(ValueError, self.rfunc, [lbnd - 1] * 2, [ubnd] * 2,
+                          endpoint=endpoint, dtype=dt)
+            assert_raises(ValueError, self.rfunc, [lbnd] * 2,
+                          [ubnd + 1] * 2, endpoint=endpoint, dtype=dt)
+            assert_raises(ValueError, self.rfunc, ubnd, [lbnd] * 2,
+                          endpoint=endpoint, dtype=dt)
+            assert_raises(ValueError, self.rfunc, [1] * 2, 0,
+                          endpoint=endpoint, dtype=dt)
+
+    def test_rng_zero_and_extremes(self, endpoint):
+        for dt in self.itype:
+            lbnd = 0 if dt is bool else np.iinfo(dt).min
+            ubnd = 2 if dt is bool else np.iinfo(dt).max + 1
+            ubnd = ubnd - 1 if endpoint else ubnd
+            is_open = not endpoint
+
+            tgt = ubnd - 1
+            assert_equal(self.rfunc(tgt, tgt + is_open, size=1000,
+                                    endpoint=endpoint, dtype=dt), tgt)
+            assert_equal(self.rfunc([tgt], tgt + is_open, size=1000,
+                                    endpoint=endpoint, dtype=dt), tgt)
+
+            tgt = lbnd
+            assert_equal(self.rfunc(tgt, tgt + is_open, size=1000,
+                                    endpoint=endpoint, dtype=dt), tgt)
+            assert_equal(self.rfunc(tgt, [tgt + is_open], size=1000,
+                                    endpoint=endpoint, dtype=dt), tgt)
+
+            tgt = (lbnd + ubnd) // 2
+            assert_equal(self.rfunc(tgt, tgt + is_open, size=1000,
+                                    endpoint=endpoint, dtype=dt), tgt)
+            assert_equal(self.rfunc([tgt], [tgt + is_open],
+                                    size=1000, endpoint=endpoint, dtype=dt),
+                         tgt)
+
+    def test_rng_zero_and_extremes_array(self, endpoint):
+        size = 1000
+        for dt in self.itype:
+            lbnd = 0 if dt is bool else np.iinfo(dt).min
+            ubnd = 2 if dt is bool else np.iinfo(dt).max + 1
+            ubnd = ubnd - 1 if endpoint else ubnd
+
+            tgt = ubnd - 1
+            assert_equal(self.rfunc([tgt], [tgt + 1],
+                                    size=size, dtype=dt), tgt)
+            assert_equal(self.rfunc(
+                [tgt] * size, [tgt + 1] * size, dtype=dt), tgt)
+            assert_equal(self.rfunc(
+                [tgt] * size, [tgt + 1] * size, size=size, dtype=dt), tgt)
+
+            tgt = lbnd
+            assert_equal(self.rfunc([tgt], [tgt + 1],
+                                    size=size, dtype=dt), tgt)
+            assert_equal(self.rfunc(
+                [tgt] * size, [tgt + 1] * size, dtype=dt), tgt)
+            assert_equal(self.rfunc(
+                [tgt] * size, [tgt + 1] * size, size=size, dtype=dt), tgt)
+
+            tgt = (lbnd + ubnd) // 2
+            assert_equal(self.rfunc([tgt], [tgt + 1],
+                                    size=size, dtype=dt), tgt)
+            assert_equal(self.rfunc(
+                [tgt] * size, [tgt + 1] * size, dtype=dt), tgt)
+            assert_equal(self.rfunc(
+                [tgt] * size, [tgt + 1] * size, size=size, dtype=dt), tgt)
+
+    def test_full_range(self, endpoint):
+        # Test for ticket #1690
+
+        for dt in self.itype:
+            lbnd = 0 if dt is bool else np.iinfo(dt).min
+            ubnd = 2 if dt is bool else np.iinfo(dt).max + 1
+            ubnd = ubnd - 1 if endpoint else ubnd
+
+            try:
+                self.rfunc(lbnd, ubnd, endpoint=endpoint, dtype=dt)
+            except Exception as e:
+                raise AssertionError("No error should have been raised, "
+                                     "but one was with the following "
+                                     "message:\n\n%s" % str(e))
+
+    def test_full_range_array(self, endpoint):
+        # Test for ticket #1690
+
+        for dt in self.itype:
+            lbnd = 0 if dt is bool else np.iinfo(dt).min
+            ubnd = 2 if dt is bool else np.iinfo(dt).max + 1
+            ubnd = ubnd - 1 if endpoint else ubnd
+
+            try:
+                self.rfunc([lbnd] * 2, [ubnd], endpoint=endpoint, dtype=dt)
+            except Exception as e:
+                raise AssertionError("No error should have been raised, "
+                                     "but one was with the following "
+                                     "message:\n\n%s" % str(e))
+
+    def test_in_bounds_fuzz(self, endpoint):
+        # Don't use fixed seed
+        random = Generator(MT19937())
+
+        for dt in self.itype[1:]:
+            for ubnd in [4, 8, 16]:
+                vals = self.rfunc(2, ubnd - endpoint, size=2 ** 16,
+                                  endpoint=endpoint, dtype=dt)
+                assert_(vals.max() < ubnd)
+                assert_(vals.min() >= 2)
+
+        vals = self.rfunc(0, 2 - endpoint, size=2 ** 16, endpoint=endpoint,
+                          dtype=bool)
+        assert_(vals.max() < 2)
+        assert_(vals.min() >= 0)
+
+    def test_scalar_array_equiv(self, endpoint):
+        for dt in self.itype:
+            lbnd = 0 if dt is bool else np.iinfo(dt).min
+            ubnd = 2 if dt is bool else np.iinfo(dt).max + 1
+            ubnd = ubnd - 1 if endpoint else ubnd
+
+            size = 1000
+            random = Generator(MT19937(1234))
+            scalar = random.integers(lbnd, ubnd, size=size, endpoint=endpoint,
+                                dtype=dt)
+
+            random = Generator(MT19937(1234))
+            scalar_array = random.integers([lbnd], [ubnd], size=size,
+                                      endpoint=endpoint, dtype=dt)
+
+            random = Generator(MT19937(1234))
+            array = random.integers([lbnd] * size, [ubnd] *
+                               size, size=size, endpoint=endpoint, dtype=dt)
+            assert_array_equal(scalar, scalar_array)
+            assert_array_equal(scalar, array)
+
+    def test_repeatability(self, endpoint):
+        # We use a sha256 hash of generated sequences of 1000 samples
+        # in the range [0, 6) for all but bool, where the range
+        # is [0, 2). Hashes are for little endian numbers.
+        tgt = {'bool':   '053594a9b82d656f967c54869bc6970aa0358cf94ad469c81478459c6a90eee3',
+               'int16':  '54de9072b6ee9ff7f20b58329556a46a447a8a29d67db51201bf88baa6e4e5d4',
+               'int32':  'd3a0d5efb04542b25ac712e50d21f39ac30f312a5052e9bbb1ad3baa791ac84b',
+               'int64':  '14e224389ac4580bfbdccb5697d6190b496f91227cf67df60989de3d546389b1',
+               'int8':   '0e203226ff3fbbd1580f15da4621e5f7164d0d8d6b51696dd42d004ece2cbec1',
+               'uint16': '54de9072b6ee9ff7f20b58329556a46a447a8a29d67db51201bf88baa6e4e5d4',
+               'uint32': 'd3a0d5efb04542b25ac712e50d21f39ac30f312a5052e9bbb1ad3baa791ac84b',
+               'uint64': '14e224389ac4580bfbdccb5697d6190b496f91227cf67df60989de3d546389b1',
+               'uint8':  '0e203226ff3fbbd1580f15da4621e5f7164d0d8d6b51696dd42d004ece2cbec1'}
+
+        for dt in self.itype[1:]:
+            random = Generator(MT19937(1234))
+
+            # view as little endian for hash
+            if sys.byteorder == 'little':
+                val = random.integers(0, 6 - endpoint, size=1000, endpoint=endpoint,
+                                 dtype=dt)
+            else:
+                val = random.integers(0, 6 - endpoint, size=1000, endpoint=endpoint,
+                                 dtype=dt).byteswap()
+
+            res = hashlib.sha256(val).hexdigest()
+            assert_(tgt[np.dtype(dt).name] == res)
+
+        # bools do not depend on endianness
+        random = Generator(MT19937(1234))
+        val = random.integers(0, 2 - endpoint, size=1000, endpoint=endpoint,
+                         dtype=bool).view(np.int8)
+        res = hashlib.sha256(val).hexdigest()
+        assert_(tgt[np.dtype(bool).name] == res)
+
+    def test_repeatability_broadcasting(self, endpoint):
+        for dt in self.itype:
+            lbnd = 0 if dt in (bool, np.bool) else np.iinfo(dt).min
+            ubnd = 2 if dt in (bool, np.bool) else np.iinfo(dt).max + 1
+            ubnd = ubnd - 1 if endpoint else ubnd
+
+            # view as little endian for hash
+            random = Generator(MT19937(1234))
+            val = random.integers(lbnd, ubnd, size=1000, endpoint=endpoint,
+                             dtype=dt)
+
+            random = Generator(MT19937(1234))
+            val_bc = random.integers([lbnd] * 1000, ubnd, endpoint=endpoint,
+                                dtype=dt)
+
+            assert_array_equal(val, val_bc)
+
+            random = Generator(MT19937(1234))
+            val_bc = random.integers([lbnd] * 1000, [ubnd] * 1000,
+                                endpoint=endpoint, dtype=dt)
+
+            assert_array_equal(val, val_bc)
+
+    @pytest.mark.parametrize(
+        'bound, expected',
+        [(2**32 - 1, np.array([517043486, 1364798665, 1733884389, 1353720612,
+                               3769704066, 1170797179, 4108474671])),
+         (2**32, np.array([517043487, 1364798666, 1733884390, 1353720613,
+                           3769704067, 1170797180, 4108474672])),
+         (2**32 + 1, np.array([517043487, 1733884390, 3769704068, 4108474673,
+                               1831631863, 1215661561, 3869512430]))]
+    )
+    def test_repeatability_32bit_boundary(self, bound, expected):
+        for size in [None, len(expected)]:
+            random = Generator(MT19937(1234))
+            x = random.integers(bound, size=size)
+            assert_equal(x, expected if size is not None else expected[0])
+
+    def test_repeatability_32bit_boundary_broadcasting(self):
+        desired = np.array([[[1622936284, 3620788691, 1659384060],
+                             [1417365545,  760222891, 1909653332],
+                             [3788118662,  660249498, 4092002593]],
+                            [[3625610153, 2979601262, 3844162757],
+                             [ 685800658,  120261497, 2694012896],
+                             [1207779440, 1586594375, 3854335050]],
+                            [[3004074748, 2310761796, 3012642217],
+                             [2067714190, 2786677879, 1363865881],
+                             [ 791663441, 1867303284, 2169727960]],
+                            [[1939603804, 1250951100,  298950036],
+                             [1040128489, 3791912209, 3317053765],
+                             [3155528714,   61360675, 2305155588]],
+                            [[ 817688762, 1335621943, 3288952434],
+                             [1770890872, 1102951817, 1957607470],
+                             [3099996017,  798043451,   48334215]]])
+        for size in [None, (5, 3, 3)]:
+            random = Generator(MT19937(12345))
+            x = random.integers([[-1], [0], [1]],
+                                [2**32 - 1, 2**32, 2**32 + 1],
+                                size=size)
+            assert_array_equal(x, desired if size is not None else desired[0])
+
+    def test_int64_uint64_broadcast_exceptions(self, endpoint):
+        configs = {np.uint64: ((0, 2**65), (-1, 2**62), (10, 9), (0, 0)),
+                   np.int64: ((0, 2**64), (-(2**64), 2**62), (10, 9), (0, 0),
+                              (-2**63-1, -2**63-1))}
+        for dtype in configs:
+            for config in configs[dtype]:
+                low, high = config
+                high = high - endpoint
+                low_a = np.array([[low]*10])
+                high_a = np.array([high] * 10)
+                assert_raises(ValueError, random.integers, low, high,
+                              endpoint=endpoint, dtype=dtype)
+                assert_raises(ValueError, random.integers, low_a, high,
+                              endpoint=endpoint, dtype=dtype)
+                assert_raises(ValueError, random.integers, low, high_a,
+                              endpoint=endpoint, dtype=dtype)
+                assert_raises(ValueError, random.integers, low_a, high_a,
+                              endpoint=endpoint, dtype=dtype)
+
+                low_o = np.array([[low]*10], dtype=object)
+                high_o = np.array([high] * 10, dtype=object)
+                assert_raises(ValueError, random.integers, low_o, high,
+                              endpoint=endpoint, dtype=dtype)
+                assert_raises(ValueError, random.integers, low, high_o,
+                              endpoint=endpoint, dtype=dtype)
+                assert_raises(ValueError, random.integers, low_o, high_o,
+                              endpoint=endpoint, dtype=dtype)
+
+    def test_int64_uint64_corner_case(self, endpoint):
+        # When stored in Numpy arrays, `lbnd` is casted
+        # as np.int64, and `ubnd` is casted as np.uint64.
+        # Checking whether `lbnd` >= `ubnd` used to be
+        # done solely via direct comparison, which is incorrect
+        # because when Numpy tries to compare both numbers,
+        # it casts both to np.float64 because there is
+        # no integer superset of np.int64 and np.uint64. However,
+        # `ubnd` is too large to be represented in np.float64,
+        # causing it be round down to np.iinfo(np.int64).max,
+        # leading to a ValueError because `lbnd` now equals
+        # the new `ubnd`.
+
+        dt = np.int64
+        tgt = np.iinfo(np.int64).max
+        lbnd = np.int64(np.iinfo(np.int64).max)
+        ubnd = np.uint64(np.iinfo(np.int64).max + 1 - endpoint)
+
+        # None of these function calls should
+        # generate a ValueError now.
+        actual = random.integers(lbnd, ubnd, endpoint=endpoint, dtype=dt)
+        assert_equal(actual, tgt)
+
+    def test_respect_dtype_singleton(self, endpoint):
+        # See gh-7203
+        for dt in self.itype:
+            lbnd = 0 if dt is bool else np.iinfo(dt).min
+            ubnd = 2 if dt is bool else np.iinfo(dt).max + 1
+            ubnd = ubnd - 1 if endpoint else ubnd
+            dt = np.bool if dt is bool else dt
+
+            sample = self.rfunc(lbnd, ubnd, endpoint=endpoint, dtype=dt)
+            assert_equal(sample.dtype, dt)
+
+        for dt in (bool, int):
+            lbnd = 0 if dt is bool else np.iinfo(dt).min
+            ubnd = 2 if dt is bool else np.iinfo(dt).max + 1
+            ubnd = ubnd - 1 if endpoint else ubnd
+
+            # gh-7284: Ensure that we get Python data types
+            sample = self.rfunc(lbnd, ubnd, endpoint=endpoint, dtype=dt)
+            assert not hasattr(sample, 'dtype')
+            assert_equal(type(sample), dt)
+
+    def test_respect_dtype_array(self, endpoint):
+        # See gh-7203
+        for dt in self.itype:
+            lbnd = 0 if dt is bool else np.iinfo(dt).min
+            ubnd = 2 if dt is bool else np.iinfo(dt).max + 1
+            ubnd = ubnd - 1 if endpoint else ubnd
+            dt = np.bool if dt is bool else dt
+
+            sample = self.rfunc([lbnd], [ubnd], endpoint=endpoint, dtype=dt)
+            assert_equal(sample.dtype, dt)
+            sample = self.rfunc([lbnd] * 2, [ubnd] * 2, endpoint=endpoint,
+                                dtype=dt)
+            assert_equal(sample.dtype, dt)
+
+    def test_zero_size(self, endpoint):
+        # See gh-7203
+        for dt in self.itype:
+            sample = self.rfunc(0, 0, (3, 0, 4), endpoint=endpoint, dtype=dt)
+            assert sample.shape == (3, 0, 4)
+            assert sample.dtype == dt
+            assert self.rfunc(0, -10, 0, endpoint=endpoint,
+                              dtype=dt).shape == (0,)
+            assert_equal(random.integers(0, 0, size=(3, 0, 4)).shape,
+                         (3, 0, 4))
+            assert_equal(random.integers(0, -10, size=0).shape, (0,))
+            assert_equal(random.integers(10, 10, size=0).shape, (0,))
+
+    def test_error_byteorder(self):
+        other_byteord_dt = 'i4'
+        with pytest.raises(ValueError):
+            random.integers(0, 200, size=10, dtype=other_byteord_dt)
+
+    # chi2max is the maximum acceptable chi-squared value.
+    @pytest.mark.slow
+    @pytest.mark.parametrize('sample_size,high,dtype,chi2max',
+        [(5000000, 5, np.int8, 125.0),          # p-value ~4.6e-25
+         (5000000, 7, np.uint8, 150.0),         # p-value ~7.7e-30
+         (10000000, 2500, np.int16, 3300.0),    # p-value ~3.0e-25
+         (50000000, 5000, np.uint16, 6500.0),   # p-value ~3.5e-25
+        ])
+    def test_integers_small_dtype_chisquared(self, sample_size, high,
+                                             dtype, chi2max):
+        # Regression test for gh-14774.
+        samples = random.integers(high, size=sample_size, dtype=dtype)
+
+        values, counts = np.unique(samples, return_counts=True)
+        expected = sample_size / high
+        chi2 = ((counts - expected)**2 / expected).sum()
+        assert chi2 < chi2max
+
+
+class TestRandomDist:
+    # Make sure the random distribution returns the correct value for a
+    # given seed
+
+    def setup_method(self):
+        self.seed = 1234567890
+
+    def test_integers(self):
+        random = Generator(MT19937(self.seed))
+        actual = random.integers(-99, 99, size=(3, 2))
+        desired = np.array([[-80, -56], [41, 37], [-83, -16]])
+        assert_array_equal(actual, desired)
+
+    def test_integers_masked(self):
+        # Test masked rejection sampling algorithm to generate array of
+        # uint32 in an interval.
+        random = Generator(MT19937(self.seed))
+        actual = random.integers(0, 99, size=(3, 2), dtype=np.uint32)
+        desired = np.array([[9, 21], [70, 68], [8, 41]], dtype=np.uint32)
+        assert_array_equal(actual, desired)
+
+    def test_integers_closed(self):
+        random = Generator(MT19937(self.seed))
+        actual = random.integers(-99, 99, size=(3, 2), endpoint=True)
+        desired = np.array([[-80, -56], [ 41, 38], [-83, -15]])
+        assert_array_equal(actual, desired)
+
+    def test_integers_max_int(self):
+        # Tests whether integers with closed=True can generate the
+        # maximum allowed Python int that can be converted
+        # into a C long. Previous implementations of this
+        # method have thrown an OverflowError when attempting
+        # to generate this integer.
+        actual = random.integers(np.iinfo('l').max, np.iinfo('l').max,
+                                 endpoint=True)
+
+        desired = np.iinfo('l').max
+        assert_equal(actual, desired)
+
+    def test_random(self):
+        random = Generator(MT19937(self.seed))
+        actual = random.random((3, 2))
+        desired = np.array([[0.096999199829214, 0.707517457682192],
+                            [0.084364834598269, 0.767731206553125],
+                            [0.665069021359413, 0.715487190596693]])
+        assert_array_almost_equal(actual, desired, decimal=15)
+
+        random = Generator(MT19937(self.seed))
+        actual = random.random()
+        assert_array_almost_equal(actual, desired[0, 0], decimal=15)
+
+    def test_random_float(self):
+        random = Generator(MT19937(self.seed))
+        actual = random.random((3, 2))
+        desired = np.array([[0.0969992 , 0.70751746],
+                            [0.08436483, 0.76773121],
+                            [0.66506902, 0.71548719]])
+        assert_array_almost_equal(actual, desired, decimal=7)
+
+    def test_random_float_scalar(self):
+        random = Generator(MT19937(self.seed))
+        actual = random.random(dtype=np.float32)
+        desired = 0.0969992
+        assert_array_almost_equal(actual, desired, decimal=7)
+
+    @pytest.mark.parametrize('dtype, uint_view_type',
+                             [(np.float32, np.uint32),
+                              (np.float64, np.uint64)])
+    def test_random_distribution_of_lsb(self, dtype, uint_view_type):
+        random = Generator(MT19937(self.seed))
+        sample = random.random(100000, dtype=dtype)
+        num_ones_in_lsb = np.count_nonzero(sample.view(uint_view_type) & 1)
+        # The probability of a 1 in the least significant bit is 0.25.
+        # With a sample size of 100000, the probability that num_ones_in_lsb
+        # is outside the following range is less than 5e-11.
+        assert 24100 < num_ones_in_lsb < 25900
+
+    def test_random_unsupported_type(self):
+        assert_raises(TypeError, random.random, dtype='int32')
+
+    def test_choice_uniform_replace(self):
+        random = Generator(MT19937(self.seed))
+        actual = random.choice(4, 4)
+        desired = np.array([0, 0, 2, 2], dtype=np.int64)
+        assert_array_equal(actual, desired)
+
+    def test_choice_nonuniform_replace(self):
+        random = Generator(MT19937(self.seed))
+        actual = random.choice(4, 4, p=[0.4, 0.4, 0.1, 0.1])
+        desired = np.array([0, 1, 0, 1], dtype=np.int64)
+        assert_array_equal(actual, desired)
+
+    def test_choice_uniform_noreplace(self):
+        random = Generator(MT19937(self.seed))
+        actual = random.choice(4, 3, replace=False)
+        desired = np.array([2, 0, 3], dtype=np.int64)
+        assert_array_equal(actual, desired)
+        actual = random.choice(4, 4, replace=False, shuffle=False)
+        desired = np.arange(4, dtype=np.int64)
+        assert_array_equal(actual, desired)
+
+    def test_choice_nonuniform_noreplace(self):
+        random = Generator(MT19937(self.seed))
+        actual = random.choice(4, 3, replace=False, p=[0.1, 0.3, 0.5, 0.1])
+        desired = np.array([0, 2, 3], dtype=np.int64)
+        assert_array_equal(actual, desired)
+
+    def test_choice_noninteger(self):
+        random = Generator(MT19937(self.seed))
+        actual = random.choice(['a', 'b', 'c', 'd'], 4)
+        desired = np.array(['a', 'a', 'c', 'c'])
+        assert_array_equal(actual, desired)
+
+    def test_choice_multidimensional_default_axis(self):
+        random = Generator(MT19937(self.seed))
+        actual = random.choice([[0, 1], [2, 3], [4, 5], [6, 7]], 3)
+        desired = np.array([[0, 1], [0, 1], [4, 5]])
+        assert_array_equal(actual, desired)
+
+    def test_choice_multidimensional_custom_axis(self):
+        random = Generator(MT19937(self.seed))
+        actual = random.choice([[0, 1], [2, 3], [4, 5], [6, 7]], 1, axis=1)
+        desired = np.array([[0], [2], [4], [6]])
+        assert_array_equal(actual, desired)
+
+    def test_choice_exceptions(self):
+        sample = random.choice
+        assert_raises(ValueError, sample, -1, 3)
+        assert_raises(ValueError, sample, 3., 3)
+        assert_raises(ValueError, sample, [], 3)
+        assert_raises(ValueError, sample, [1, 2, 3, 4], 3,
+                      p=[[0.25, 0.25], [0.25, 0.25]])
+        assert_raises(ValueError, sample, [1, 2], 3, p=[0.4, 0.4, 0.2])
+        assert_raises(ValueError, sample, [1, 2], 3, p=[1.1, -0.1])
+        assert_raises(ValueError, sample, [1, 2], 3, p=[0.4, 0.4])
+        assert_raises(ValueError, sample, [1, 2, 3], 4, replace=False)
+        # gh-13087
+        assert_raises(ValueError, sample, [1, 2, 3], -2, replace=False)
+        assert_raises(ValueError, sample, [1, 2, 3], (-1,), replace=False)
+        assert_raises(ValueError, sample, [1, 2, 3], (-1, 1), replace=False)
+        assert_raises(ValueError, sample, [1, 2, 3], 2,
+                      replace=False, p=[1, 0, 0])
+
+    def test_choice_return_shape(self):
+        p = [0.1, 0.9]
+        # Check scalar
+        assert_(np.isscalar(random.choice(2, replace=True)))
+        assert_(np.isscalar(random.choice(2, replace=False)))
+        assert_(np.isscalar(random.choice(2, replace=True, p=p)))
+        assert_(np.isscalar(random.choice(2, replace=False, p=p)))
+        assert_(np.isscalar(random.choice([1, 2], replace=True)))
+        assert_(random.choice([None], replace=True) is None)
+        a = np.array([1, 2])
+        arr = np.empty(1, dtype=object)
+        arr[0] = a
+        assert_(random.choice(arr, replace=True) is a)
+
+        # Check 0-d array
+        s = tuple()
+        assert_(not np.isscalar(random.choice(2, s, replace=True)))
+        assert_(not np.isscalar(random.choice(2, s, replace=False)))
+        assert_(not np.isscalar(random.choice(2, s, replace=True, p=p)))
+        assert_(not np.isscalar(random.choice(2, s, replace=False, p=p)))
+        assert_(not np.isscalar(random.choice([1, 2], s, replace=True)))
+        assert_(random.choice([None], s, replace=True).ndim == 0)
+        a = np.array([1, 2])
+        arr = np.empty(1, dtype=object)
+        arr[0] = a
+        assert_(random.choice(arr, s, replace=True).item() is a)
+
+        # Check multi dimensional array
+        s = (2, 3)
+        p = [0.1, 0.1, 0.1, 0.1, 0.4, 0.2]
+        assert_equal(random.choice(6, s, replace=True).shape, s)
+        assert_equal(random.choice(6, s, replace=False).shape, s)
+        assert_equal(random.choice(6, s, replace=True, p=p).shape, s)
+        assert_equal(random.choice(6, s, replace=False, p=p).shape, s)
+        assert_equal(random.choice(np.arange(6), s, replace=True).shape, s)
+
+        # Check zero-size
+        assert_equal(random.integers(0, 0, size=(3, 0, 4)).shape, (3, 0, 4))
+        assert_equal(random.integers(0, -10, size=0).shape, (0,))
+        assert_equal(random.integers(10, 10, size=0).shape, (0,))
+        assert_equal(random.choice(0, size=0).shape, (0,))
+        assert_equal(random.choice([], size=(0,)).shape, (0,))
+        assert_equal(random.choice(['a', 'b'], size=(3, 0, 4)).shape,
+                     (3, 0, 4))
+        assert_raises(ValueError, random.choice, [], 10)
+
+    def test_choice_nan_probabilities(self):
+        a = np.array([42, 1, 2])
+        p = [None, None, None]
+        assert_raises(ValueError, random.choice, a, p=p)
+
+    def test_choice_p_non_contiguous(self):
+        p = np.ones(10) / 5
+        p[1::2] = 3.0
+        random = Generator(MT19937(self.seed))
+        non_contig = random.choice(5, 3, p=p[::2])
+        random = Generator(MT19937(self.seed))
+        contig = random.choice(5, 3, p=np.ascontiguousarray(p[::2]))
+        assert_array_equal(non_contig, contig)
+
+    def test_choice_return_type(self):
+        # gh 9867
+        p = np.ones(4) / 4.
+        actual = random.choice(4, 2)
+        assert actual.dtype == np.int64
+        actual = random.choice(4, 2, replace=False)
+        assert actual.dtype == np.int64
+        actual = random.choice(4, 2, p=p)
+        assert actual.dtype == np.int64
+        actual = random.choice(4, 2, p=p, replace=False)
+        assert actual.dtype == np.int64
+
+    def test_choice_large_sample(self):
+        choice_hash = '4266599d12bfcfb815213303432341c06b4349f5455890446578877bb322e222'
+        random = Generator(MT19937(self.seed))
+        actual = random.choice(10000, 5000, replace=False)
+        if sys.byteorder != 'little':
+            actual = actual.byteswap()
+        res = hashlib.sha256(actual.view(np.int8)).hexdigest()
+        assert_(choice_hash == res)
+
+    def test_choice_array_size_empty_tuple(self):
+        random = Generator(MT19937(self.seed))
+        assert_array_equal(random.choice([1, 2, 3], size=()), np.array(1),
+                           strict=True)
+        assert_array_equal(random.choice([[1, 2, 3]], size=()), [1, 2, 3])
+        assert_array_equal(random.choice([[1]], size=()), [1], strict=True)
+        assert_array_equal(random.choice([[1]], size=(), axis=1), [1],
+                           strict=True)
+
+    def test_bytes(self):
+        random = Generator(MT19937(self.seed))
+        actual = random.bytes(10)
+        desired = b'\x86\xf0\xd4\x18\xe1\x81\t8%\xdd'
+        assert_equal(actual, desired)
+
+    def test_shuffle(self):
+        # Test lists, arrays (of various dtypes), and multidimensional versions
+        # of both, c-contiguous or not:
+        for conv in [lambda x: np.array([]),
+                     lambda x: x,
+                     lambda x: np.asarray(x).astype(np.int8),
+                     lambda x: np.asarray(x).astype(np.float32),
+                     lambda x: np.asarray(x).astype(np.complex64),
+                     lambda x: np.asarray(x).astype(object),
+                     lambda x: [(i, i) for i in x],
+                     lambda x: np.asarray([[i, i] for i in x]),
+                     lambda x: np.vstack([x, x]).T,
+                     # gh-11442
+                     lambda x: (np.asarray([(i, i) for i in x],
+                                           [("a", int), ("b", int)])
+                                .view(np.recarray)),
+                     # gh-4270
+                     lambda x: np.asarray([(i, i) for i in x],
+                                          [("a", object, (1,)),
+                                           ("b", np.int32, (1,))])]:
+            random = Generator(MT19937(self.seed))
+            alist = conv([1, 2, 3, 4, 5, 6, 7, 8, 9, 0])
+            random.shuffle(alist)
+            actual = alist
+            desired = conv([4, 1, 9, 8, 0, 5, 3, 6, 2, 7])
+            assert_array_equal(actual, desired)
+
+    def test_shuffle_custom_axis(self):
+        random = Generator(MT19937(self.seed))
+        actual = np.arange(16).reshape((4, 4))
+        random.shuffle(actual, axis=1)
+        desired = np.array([[ 0,  3,  1,  2],
+                            [ 4,  7,  5,  6],
+                            [ 8, 11,  9, 10],
+                            [12, 15, 13, 14]])
+        assert_array_equal(actual, desired)
+        random = Generator(MT19937(self.seed))
+        actual = np.arange(16).reshape((4, 4))
+        random.shuffle(actual, axis=-1)
+        assert_array_equal(actual, desired)
+
+    def test_shuffle_custom_axis_empty(self):
+        random = Generator(MT19937(self.seed))
+        desired = np.array([]).reshape((0, 6))
+        for axis in (0, 1):
+            actual = np.array([]).reshape((0, 6))
+            random.shuffle(actual, axis=axis)
+            assert_array_equal(actual, desired)
+
+    def test_shuffle_axis_nonsquare(self):
+        y1 = np.arange(20).reshape(2, 10)
+        y2 = y1.copy()
+        random = Generator(MT19937(self.seed))
+        random.shuffle(y1, axis=1)
+        random = Generator(MT19937(self.seed))
+        random.shuffle(y2.T)
+        assert_array_equal(y1, y2)
+
+    def test_shuffle_masked(self):
+        # gh-3263
+        a = np.ma.masked_values(np.reshape(range(20), (5, 4)) % 3 - 1, -1)
+        b = np.ma.masked_values(np.arange(20) % 3 - 1, -1)
+        a_orig = a.copy()
+        b_orig = b.copy()
+        for i in range(50):
+            random.shuffle(a)
+            assert_equal(
+                sorted(a.data[~a.mask]), sorted(a_orig.data[~a_orig.mask]))
+            random.shuffle(b)
+            assert_equal(
+                sorted(b.data[~b.mask]), sorted(b_orig.data[~b_orig.mask]))
+
+    def test_shuffle_exceptions(self):
+        random = Generator(MT19937(self.seed))
+        arr = np.arange(10)
+        assert_raises(AxisError, random.shuffle, arr, 1)
+        arr = np.arange(9).reshape((3, 3))
+        assert_raises(AxisError, random.shuffle, arr, 3)
+        assert_raises(TypeError, random.shuffle, arr, slice(1, 2, None))
+        arr = [[1, 2, 3], [4, 5, 6]]
+        assert_raises(NotImplementedError, random.shuffle, arr, 1)
+
+        arr = np.array(3)
+        assert_raises(TypeError, random.shuffle, arr)
+        arr = np.ones((3, 2))
+        assert_raises(AxisError, random.shuffle, arr, 2)
+
+    def test_shuffle_not_writeable(self):
+        random = Generator(MT19937(self.seed))
+        a = np.zeros(5)
+        a.flags.writeable = False
+        with pytest.raises(ValueError, match='read-only'):
+            random.shuffle(a)
+
+    def test_permutation(self):
+        random = Generator(MT19937(self.seed))
+        alist = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]
+        actual = random.permutation(alist)
+        desired = [4, 1, 9, 8, 0, 5, 3, 6, 2, 7]
+        assert_array_equal(actual, desired)
+
+        random = Generator(MT19937(self.seed))
+        arr_2d = np.atleast_2d([1, 2, 3, 4, 5, 6, 7, 8, 9, 0]).T
+        actual = random.permutation(arr_2d)
+        assert_array_equal(actual, np.atleast_2d(desired).T)
+
+        bad_x_str = "abcd"
+        assert_raises(AxisError, random.permutation, bad_x_str)
+
+        bad_x_float = 1.2
+        assert_raises(AxisError, random.permutation, bad_x_float)
+
+        random = Generator(MT19937(self.seed))
+        integer_val = 10
+        desired = [3, 0, 8, 7, 9, 4, 2, 5, 1, 6]
+
+        actual = random.permutation(integer_val)
+        assert_array_equal(actual, desired)
+
+    def test_permutation_custom_axis(self):
+        a = np.arange(16).reshape((4, 4))
+        desired = np.array([[ 0,  3,  1,  2],
+                            [ 4,  7,  5,  6],
+                            [ 8, 11,  9, 10],
+                            [12, 15, 13, 14]])
+        random = Generator(MT19937(self.seed))
+        actual = random.permutation(a, axis=1)
+        assert_array_equal(actual, desired)
+        random = Generator(MT19937(self.seed))
+        actual = random.permutation(a, axis=-1)
+        assert_array_equal(actual, desired)
+
+    def test_permutation_exceptions(self):
+        random = Generator(MT19937(self.seed))
+        arr = np.arange(10)
+        assert_raises(AxisError, random.permutation, arr, 1)
+        arr = np.arange(9).reshape((3, 3))
+        assert_raises(AxisError, random.permutation, arr, 3)
+        assert_raises(TypeError, random.permutation, arr, slice(1, 2, None))
+
+    @pytest.mark.parametrize("dtype", [int, object])
+    @pytest.mark.parametrize("axis, expected",
+                             [(None, np.array([[3, 7, 0, 9, 10, 11],
+                                               [8, 4, 2, 5,  1,  6]])),
+                              (0, np.array([[6, 1, 2, 9, 10, 11],
+                                            [0, 7, 8, 3,  4,  5]])),
+                              (1, np.array([[ 5, 3,  4, 0, 2, 1],
+                                            [11, 9, 10, 6, 8, 7]]))])
+    def test_permuted(self, dtype, axis, expected):
+        random = Generator(MT19937(self.seed))
+        x = np.arange(12).reshape(2, 6).astype(dtype)
+        random.permuted(x, axis=axis, out=x)
+        assert_array_equal(x, expected)
+
+        random = Generator(MT19937(self.seed))
+        x = np.arange(12).reshape(2, 6).astype(dtype)
+        y = random.permuted(x, axis=axis)
+        assert y.dtype == dtype
+        assert_array_equal(y, expected)
+
+    def test_permuted_with_strides(self):
+        random = Generator(MT19937(self.seed))
+        x0 = np.arange(22).reshape(2, 11)
+        x1 = x0.copy()
+        x = x0[:, ::3]
+        y = random.permuted(x, axis=1, out=x)
+        expected = np.array([[0, 9, 3, 6],
+                             [14, 20, 11, 17]])
+        assert_array_equal(y, expected)
+        x1[:, ::3] = expected
+        # Verify that the original x0 was modified in-place as expected.
+        assert_array_equal(x1, x0)
+
+    def test_permuted_empty(self):
+        y = random.permuted([])
+        assert_array_equal(y, [])
+
+    @pytest.mark.parametrize('outshape', [(2, 3), 5])
+    def test_permuted_out_with_wrong_shape(self, outshape):
+        a = np.array([1, 2, 3])
+        out = np.zeros(outshape, dtype=a.dtype)
+        with pytest.raises(ValueError, match='same shape'):
+            random.permuted(a, out=out)
+
+    def test_permuted_out_with_wrong_type(self):
+        out = np.zeros((3, 5), dtype=np.int32)
+        x = np.ones((3, 5))
+        with pytest.raises(TypeError, match='Cannot cast'):
+            random.permuted(x, axis=1, out=out)
+
+    def test_permuted_not_writeable(self):
+        x = np.zeros((2, 5))
+        x.flags.writeable = False
+        with pytest.raises(ValueError, match='read-only'):
+            random.permuted(x, axis=1, out=x)
+
+    def test_beta(self):
+        random = Generator(MT19937(self.seed))
+        actual = random.beta(.1, .9, size=(3, 2))
+        desired = np.array(
+            [[1.083029353267698e-10, 2.449965303168024e-11],
+             [2.397085162969853e-02, 3.590779671820755e-08],
+             [2.830254190078299e-04, 1.744709918330393e-01]])
+        assert_array_almost_equal(actual, desired, decimal=15)
+
+    def test_binomial(self):
+        random = Generator(MT19937(self.seed))
+        actual = random.binomial(100.123, .456, size=(3, 2))
+        desired = np.array([[42, 41],
+                            [42, 48],
+                            [44, 50]])
+        assert_array_equal(actual, desired)
+
+        random = Generator(MT19937(self.seed))
+        actual = random.binomial(100.123, .456)
+        desired = 42
+        assert_array_equal(actual, desired)
+
+    def test_chisquare(self):
+        random = Generator(MT19937(self.seed))
+        actual = random.chisquare(50, size=(3, 2))
+        desired = np.array([[32.9850547060149, 39.0219480493301],
+                            [56.2006134779419, 57.3474165711485],
+                            [55.4243733880198, 55.4209797925213]])
+        assert_array_almost_equal(actual, desired, decimal=13)
+
+    def test_dirichlet(self):
+        random = Generator(MT19937(self.seed))
+        alpha = np.array([51.72840233779265162, 39.74494232180943953])
+        actual = random.dirichlet(alpha, size=(3, 2))
+        desired = np.array([[[0.5439892869558927,  0.45601071304410745],
+                             [0.5588917345860708,  0.4411082654139292 ]],
+                            [[0.5632074165063435,  0.43679258349365657],
+                             [0.54862581112627,    0.45137418887373015]],
+                            [[0.49961831357047226, 0.5003816864295278 ],
+                             [0.52374806183482,    0.47625193816517997]]])
+        assert_array_almost_equal(actual, desired, decimal=15)
+        bad_alpha = np.array([5.4e-01, -1.0e-16])
+        assert_raises(ValueError, random.dirichlet, bad_alpha)
+
+        random = Generator(MT19937(self.seed))
+        alpha = np.array([51.72840233779265162, 39.74494232180943953])
+        actual = random.dirichlet(alpha)
+        assert_array_almost_equal(actual, desired[0, 0], decimal=15)
+
+    def test_dirichlet_size(self):
+        # gh-3173
+        p = np.array([51.72840233779265162, 39.74494232180943953])
+        assert_equal(random.dirichlet(p, np.uint32(1)).shape, (1, 2))
+        assert_equal(random.dirichlet(p, np.uint32(1)).shape, (1, 2))
+        assert_equal(random.dirichlet(p, np.uint32(1)).shape, (1, 2))
+        assert_equal(random.dirichlet(p, [2, 2]).shape, (2, 2, 2))
+        assert_equal(random.dirichlet(p, (2, 2)).shape, (2, 2, 2))
+        assert_equal(random.dirichlet(p, np.array((2, 2))).shape, (2, 2, 2))
+
+        assert_raises(TypeError, random.dirichlet, p, float(1))
+
+    def test_dirichlet_bad_alpha(self):
+        # gh-2089
+        alpha = np.array([5.4e-01, -1.0e-16])
+        assert_raises(ValueError, random.dirichlet, alpha)
+
+        # gh-15876
+        assert_raises(ValueError, random.dirichlet, [[5, 1]])
+        assert_raises(ValueError, random.dirichlet, [[5], [1]])
+        assert_raises(ValueError, random.dirichlet, [[[5], [1]], [[1], [5]]])
+        assert_raises(ValueError, random.dirichlet, np.array([[5, 1], [1, 5]]))
+
+    def test_dirichlet_alpha_non_contiguous(self):
+        a = np.array([51.72840233779265162, -1.0, 39.74494232180943953])
+        alpha = a[::2]
+        random = Generator(MT19937(self.seed))
+        non_contig = random.dirichlet(alpha, size=(3, 2))
+        random = Generator(MT19937(self.seed))
+        contig = random.dirichlet(np.ascontiguousarray(alpha),
+                                  size=(3, 2))
+        assert_array_almost_equal(non_contig, contig)
+
+    def test_dirichlet_small_alpha(self):
+        eps = 1.0e-9  # 1.0e-10 -> runtime x 10; 1e-11 -> runtime x 200, etc.
+        alpha = eps * np.array([1., 1.0e-3])
+        random = Generator(MT19937(self.seed))
+        actual = random.dirichlet(alpha, size=(3, 2))
+        expected = np.array([
+            [[1., 0.],
+             [1., 0.]],
+            [[1., 0.],
+             [1., 0.]],
+            [[1., 0.],
+             [1., 0.]]
+        ])
+        assert_array_almost_equal(actual, expected, decimal=15)
+
+    @pytest.mark.slow
+    def test_dirichlet_moderately_small_alpha(self):
+        # Use alpha.max() < 0.1 to trigger stick breaking code path
+        alpha = np.array([0.02, 0.04, 0.03])
+        exact_mean = alpha / alpha.sum()
+        random = Generator(MT19937(self.seed))
+        sample = random.dirichlet(alpha, size=20000000)
+        sample_mean = sample.mean(axis=0)
+        assert_allclose(sample_mean, exact_mean, rtol=1e-3)
+
+    # This set of parameters includes inputs with alpha.max() >= 0.1 and
+    # alpha.max() < 0.1 to exercise both generation methods within the
+    # dirichlet code.
+    @pytest.mark.parametrize(
+        'alpha',
+        [[5, 9, 0, 8],
+         [0.5, 0, 0, 0],
+         [1, 5, 0, 0, 1.5, 0, 0, 0],
+         [0.01, 0.03, 0, 0.005],
+         [1e-5, 0, 0, 0],
+         [0.002, 0.015, 0, 0, 0.04, 0, 0, 0],
+         [0.0],
+         [0, 0, 0]],
+    )
+    def test_dirichlet_multiple_zeros_in_alpha(self, alpha):
+        alpha = np.array(alpha)
+        y = random.dirichlet(alpha)
+        assert_equal(y[alpha == 0], 0.0)
+
+    def test_exponential(self):
+        random = Generator(MT19937(self.seed))
+        actual = random.exponential(1.1234, size=(3, 2))
+        desired = np.array([[0.098845481066258, 1.560752510746964],
+                            [0.075730916041636, 1.769098974710777],
+                            [1.488602544592235, 2.49684815275751 ]])
+        assert_array_almost_equal(actual, desired, decimal=15)
+
+    def test_exponential_0(self):
+        assert_equal(random.exponential(scale=0), 0)
+        assert_raises(ValueError, random.exponential, scale=-0.)
+
+    def test_f(self):
+        random = Generator(MT19937(self.seed))
+        actual = random.f(12, 77, size=(3, 2))
+        desired = np.array([[0.461720027077085, 1.100441958872451],
+                            [1.100337455217484, 0.91421736740018 ],
+                            [0.500811891303113, 0.826802454552058]])
+        assert_array_almost_equal(actual, desired, decimal=15)
+
+    def test_gamma(self):
+        random = Generator(MT19937(self.seed))
+        actual = random.gamma(5, 3, size=(3, 2))
+        desired = np.array([[ 5.03850858902096,  7.9228656732049 ],
+                            [18.73983605132985, 19.57961681699238],
+                            [18.17897755150825, 18.17653912505234]])
+        assert_array_almost_equal(actual, desired, decimal=14)
+
+    def test_gamma_0(self):
+        assert_equal(random.gamma(shape=0, scale=0), 0)
+        assert_raises(ValueError, random.gamma, shape=-0., scale=-0.)
+
+    def test_geometric(self):
+        random = Generator(MT19937(self.seed))
+        actual = random.geometric(.123456789, size=(3, 2))
+        desired = np.array([[1, 11],
+                            [1, 12],
+                            [11, 17]])
+        assert_array_equal(actual, desired)
+
+    def test_geometric_exceptions(self):
+        assert_raises(ValueError, random.geometric, 1.1)
+        assert_raises(ValueError, random.geometric, [1.1] * 10)
+        assert_raises(ValueError, random.geometric, -0.1)
+        assert_raises(ValueError, random.geometric, [-0.1] * 10)
+        with np.errstate(invalid='ignore'):
+            assert_raises(ValueError, random.geometric, np.nan)
+            assert_raises(ValueError, random.geometric, [np.nan] * 10)
+
+    def test_gumbel(self):
+        random = Generator(MT19937(self.seed))
+        actual = random.gumbel(loc=.123456789, scale=2.0, size=(3, 2))
+        desired = np.array([[ 4.688397515056245, -0.289514845417841],
+                            [ 4.981176042584683, -0.633224272589149],
+                            [-0.055915275687488, -0.333962478257953]])
+        assert_array_almost_equal(actual, desired, decimal=15)
+
+    def test_gumbel_0(self):
+        assert_equal(random.gumbel(scale=0), 0)
+        assert_raises(ValueError, random.gumbel, scale=-0.)
+
+    def test_hypergeometric(self):
+        random = Generator(MT19937(self.seed))
+        actual = random.hypergeometric(10.1, 5.5, 14, size=(3, 2))
+        desired = np.array([[ 9, 9],
+                            [ 9, 9],
+                            [10, 9]])
+        assert_array_equal(actual, desired)
+
+        # Test nbad = 0
+        actual = random.hypergeometric(5, 0, 3, size=4)
+        desired = np.array([3, 3, 3, 3])
+        assert_array_equal(actual, desired)
+
+        actual = random.hypergeometric(15, 0, 12, size=4)
+        desired = np.array([12, 12, 12, 12])
+        assert_array_equal(actual, desired)
+
+        # Test ngood = 0
+        actual = random.hypergeometric(0, 5, 3, size=4)
+        desired = np.array([0, 0, 0, 0])
+        assert_array_equal(actual, desired)
+
+        actual = random.hypergeometric(0, 15, 12, size=4)
+        desired = np.array([0, 0, 0, 0])
+        assert_array_equal(actual, desired)
+
+    def test_laplace(self):
+        random = Generator(MT19937(self.seed))
+        actual = random.laplace(loc=.123456789, scale=2.0, size=(3, 2))
+        desired = np.array([[-3.156353949272393,  1.195863024830054],
+                            [-3.435458081645966,  1.656882398925444],
+                            [ 0.924824032467446,  1.251116432209336]])
+        assert_array_almost_equal(actual, desired, decimal=15)
+
+    def test_laplace_0(self):
+        assert_equal(random.laplace(scale=0), 0)
+        assert_raises(ValueError, random.laplace, scale=-0.)
+
+    def test_logistic(self):
+        random = Generator(MT19937(self.seed))
+        actual = random.logistic(loc=.123456789, scale=2.0, size=(3, 2))
+        desired = np.array([[-4.338584631510999,  1.890171436749954],
+                            [-4.64547787337966 ,  2.514545562919217],
+                            [ 1.495389489198666,  1.967827627577474]])
+        assert_array_almost_equal(actual, desired, decimal=15)
+
+    def test_lognormal(self):
+        random = Generator(MT19937(self.seed))
+        actual = random.lognormal(mean=.123456789, sigma=2.0, size=(3, 2))
+        desired = np.array([[ 0.0268252166335, 13.9534486483053],
+                            [ 0.1204014788936,  2.2422077497792],
+                            [ 4.2484199496128, 12.0093343977523]])
+        assert_array_almost_equal(actual, desired, decimal=13)
+
+    def test_lognormal_0(self):
+        assert_equal(random.lognormal(sigma=0), 1)
+        assert_raises(ValueError, random.lognormal, sigma=-0.)
+
+    def test_logseries(self):
+        random = Generator(MT19937(self.seed))
+        actual = random.logseries(p=.923456789, size=(3, 2))
+        desired = np.array([[14, 17],
+                            [3, 18],
+                            [5, 1]])
+        assert_array_equal(actual, desired)
+
+    def test_logseries_zero(self):
+        random = Generator(MT19937(self.seed))
+        assert random.logseries(0) == 1
+
+    @pytest.mark.parametrize("value", [np.nextafter(0., -1), 1., np.nan, 5.])
+    def test_logseries_exceptions(self, value):
+        random = Generator(MT19937(self.seed))
+        with np.errstate(invalid="ignore"):
+            with pytest.raises(ValueError):
+                random.logseries(value)
+            with pytest.raises(ValueError):
+                # contiguous path:
+                random.logseries(np.array([value] * 10))
+            with pytest.raises(ValueError):
+                # non-contiguous path:
+                random.logseries(np.array([value] * 10)[::2])
+
+    def test_multinomial(self):
+        random = Generator(MT19937(self.seed))
+        actual = random.multinomial(20, [1 / 6.] * 6, size=(3, 2))
+        desired = np.array([[[1, 5, 1, 6, 4, 3],
+                             [4, 2, 6, 2, 4, 2]],
+                            [[5, 3, 2, 6, 3, 1],
+                             [4, 4, 0, 2, 3, 7]],
+                            [[6, 3, 1, 5, 3, 2],
+                             [5, 5, 3, 1, 2, 4]]])
+        assert_array_equal(actual, desired)
+
+    @pytest.mark.skipif(IS_WASM, reason="fp errors don't work in wasm")
+    @pytest.mark.parametrize("method", ["svd", "eigh", "cholesky"])
+    def test_multivariate_normal(self, method):
+        random = Generator(MT19937(self.seed))
+        mean = (.123456789, 10)
+        cov = [[1, 0], [0, 1]]
+        size = (3, 2)
+        actual = random.multivariate_normal(mean, cov, size, method=method)
+        desired = np.array([[[-1.747478062846581,  11.25613495182354  ],
+                             [-0.9967333370066214, 10.342002097029821 ]],
+                            [[ 0.7850019631242964, 11.181113712443013 ],
+                             [ 0.8901349653255224,  8.873825399642492 ]],
+                            [[ 0.7130260107430003,  9.551628690083056 ],
+                             [ 0.7127098726541128, 11.991709234143173 ]]])
+
+        assert_array_almost_equal(actual, desired, decimal=15)
+
+        # Check for default size, was raising deprecation warning
+        actual = random.multivariate_normal(mean, cov, method=method)
+        desired = np.array([0.233278563284287, 9.424140804347195])
+        assert_array_almost_equal(actual, desired, decimal=15)
+        # Check that non symmetric covariance input raises exception when
+        # check_valid='raises' if using default svd method.
+        mean = [0, 0]
+        cov = [[1, 2], [1, 2]]
+        assert_raises(ValueError, random.multivariate_normal, mean, cov,
+                      check_valid='raise')
+
+        # Check that non positive-semidefinite covariance warns with
+        # RuntimeWarning
+        cov = [[1, 2], [2, 1]]
+        assert_warns(RuntimeWarning, random.multivariate_normal, mean, cov)
+        assert_warns(RuntimeWarning, random.multivariate_normal, mean, cov,
+                     method='eigh')
+        assert_raises(LinAlgError, random.multivariate_normal, mean, cov,
+                      method='cholesky')
+
+        # and that it doesn't warn with RuntimeWarning check_valid='ignore'
+        assert_no_warnings(random.multivariate_normal, mean, cov,
+                           check_valid='ignore')
+
+        # and that it raises with RuntimeWarning check_valid='raises'
+        assert_raises(ValueError, random.multivariate_normal, mean, cov,
+                      check_valid='raise')
+        assert_raises(ValueError, random.multivariate_normal, mean, cov,
+                      check_valid='raise', method='eigh')
+
+        # check degenerate samples from singular covariance matrix
+        cov = [[1, 1], [1, 1]]
+        if method in ('svd', 'eigh'):
+            samples = random.multivariate_normal(mean, cov, size=(3, 2),
+                                                 method=method)
+            assert_array_almost_equal(samples[..., 0], samples[..., 1],
+                                      decimal=6)
+        else:
+            assert_raises(LinAlgError, random.multivariate_normal, mean, cov,
+                          method='cholesky')
+
+        cov = np.array([[1, 0.1], [0.1, 1]], dtype=np.float32)
+        with suppress_warnings() as sup:
+            random.multivariate_normal(mean, cov, method=method)
+            w = sup.record(RuntimeWarning)
+            assert len(w) == 0
+
+        mu = np.zeros(2)
+        cov = np.eye(2)
+        assert_raises(ValueError, random.multivariate_normal, mean, cov,
+                      check_valid='other')
+        assert_raises(ValueError, random.multivariate_normal,
+                      np.zeros((2, 1, 1)), cov)
+        assert_raises(ValueError, random.multivariate_normal,
+                      mu, np.empty((3, 2)))
+        assert_raises(ValueError, random.multivariate_normal,
+                      mu, np.eye(3))
+
+    @pytest.mark.parametrize('mean, cov', [([0], [[1+1j]]), ([0j], [[1]])])
+    def test_multivariate_normal_disallow_complex(self, mean, cov):
+        random = Generator(MT19937(self.seed))
+        with pytest.raises(TypeError, match="must not be complex"):
+            random.multivariate_normal(mean, cov)
+
+    @pytest.mark.parametrize("method", ["svd", "eigh", "cholesky"])
+    def test_multivariate_normal_basic_stats(self, method):
+        random = Generator(MT19937(self.seed))
+        n_s = 1000
+        mean = np.array([1, 2])
+        cov = np.array([[2, 1], [1, 2]])
+        s = random.multivariate_normal(mean, cov, size=(n_s,), method=method)
+        s_center = s - mean
+        cov_emp = (s_center.T @ s_center) / (n_s - 1)
+        # these are pretty loose and are only designed to detect major errors
+        assert np.all(np.abs(s_center.mean(-2)) < 0.1)
+        assert np.all(np.abs(cov_emp - cov) < 0.2)
+
+    def test_negative_binomial(self):
+        random = Generator(MT19937(self.seed))
+        actual = random.negative_binomial(n=100, p=.12345, size=(3, 2))
+        desired = np.array([[543, 727],
+                            [775, 760],
+                            [600, 674]])
+        assert_array_equal(actual, desired)
+
+    def test_negative_binomial_exceptions(self):
+        with np.errstate(invalid='ignore'):
+            assert_raises(ValueError, random.negative_binomial, 100, np.nan)
+            assert_raises(ValueError, random.negative_binomial, 100,
+                          [np.nan] * 10)
+
+    def test_negative_binomial_p0_exception(self):
+        # Verify that p=0 raises an exception.
+        with assert_raises(ValueError):
+            x = random.negative_binomial(1, 0)
+
+    def test_negative_binomial_invalid_p_n_combination(self):
+        # Verify that values of p and n that would result in an overflow
+        # or infinite loop raise an exception.
+        with np.errstate(invalid='ignore'):
+            assert_raises(ValueError, random.negative_binomial, 2**62, 0.1)
+            assert_raises(ValueError, random.negative_binomial, [2**62], [0.1])
+
+    def test_noncentral_chisquare(self):
+        random = Generator(MT19937(self.seed))
+        actual = random.noncentral_chisquare(df=5, nonc=5, size=(3, 2))
+        desired = np.array([[ 1.70561552362133, 15.97378184942111],
+                            [13.71483425173724, 20.17859633310629],
+                            [11.3615477156643 ,  3.67891108738029]])
+        assert_array_almost_equal(actual, desired, decimal=14)
+
+        actual = random.noncentral_chisquare(df=.5, nonc=.2, size=(3, 2))
+        desired = np.array([[9.41427665607629e-04, 1.70473157518850e-04],
+                            [1.14554372041263e+00, 1.38187755933435e-03],
+                            [1.90659181905387e+00, 1.21772577941822e+00]])
+        assert_array_almost_equal(actual, desired, decimal=14)
+
+        random = Generator(MT19937(self.seed))
+        actual = random.noncentral_chisquare(df=5, nonc=0, size=(3, 2))
+        desired = np.array([[0.82947954590419, 1.80139670767078],
+                            [6.58720057417794, 7.00491463609814],
+                            [6.31101879073157, 6.30982307753005]])
+        assert_array_almost_equal(actual, desired, decimal=14)
+
+    def test_noncentral_f(self):
+        random = Generator(MT19937(self.seed))
+        actual = random.noncentral_f(dfnum=5, dfden=2, nonc=1,
+                                     size=(3, 2))
+        desired = np.array([[0.060310671139  , 0.23866058175939],
+                            [0.86860246709073, 0.2668510459738 ],
+                            [0.23375780078364, 1.88922102885943]])
+        assert_array_almost_equal(actual, desired, decimal=14)
+
+    def test_noncentral_f_nan(self):
+        random = Generator(MT19937(self.seed))
+        actual = random.noncentral_f(dfnum=5, dfden=2, nonc=np.nan)
+        assert np.isnan(actual)
+
+    def test_normal(self):
+        random = Generator(MT19937(self.seed))
+        actual = random.normal(loc=.123456789, scale=2.0, size=(3, 2))
+        desired = np.array([[-3.618412914693162,  2.635726692647081],
+                            [-2.116923463013243,  0.807460983059643],
+                            [ 1.446547137248593,  2.485684213886024]])
+        assert_array_almost_equal(actual, desired, decimal=15)
+
+    def test_normal_0(self):
+        assert_equal(random.normal(scale=0), 0)
+        assert_raises(ValueError, random.normal, scale=-0.)
+
+    def test_pareto(self):
+        random = Generator(MT19937(self.seed))
+        actual = random.pareto(a=.123456789, size=(3, 2))
+        desired = np.array([[1.0394926776069018e+00, 7.7142534343505773e+04],
+                            [7.2640150889064703e-01, 3.4650454783825594e+05],
+                            [4.5852344481994740e+04, 6.5851383009539105e+07]])
+        # For some reason on 32-bit x86 Ubuntu 12.10 the [1, 0] entry in this
+        # matrix differs by 24 nulps. Discussion:
+        #   https://mail.python.org/pipermail/numpy-discussion/2012-September/063801.html
+        # Consensus is that this is probably some gcc quirk that affects
+        # rounding but not in any important way, so we just use a looser
+        # tolerance on this test:
+        np.testing.assert_array_almost_equal_nulp(actual, desired, nulp=30)
+
+    def test_poisson(self):
+        random = Generator(MT19937(self.seed))
+        actual = random.poisson(lam=.123456789, size=(3, 2))
+        desired = np.array([[0, 0],
+                            [0, 0],
+                            [0, 0]])
+        assert_array_equal(actual, desired)
+
+    def test_poisson_exceptions(self):
+        lambig = np.iinfo('int64').max
+        lamneg = -1
+        assert_raises(ValueError, random.poisson, lamneg)
+        assert_raises(ValueError, random.poisson, [lamneg] * 10)
+        assert_raises(ValueError, random.poisson, lambig)
+        assert_raises(ValueError, random.poisson, [lambig] * 10)
+        with np.errstate(invalid='ignore'):
+            assert_raises(ValueError, random.poisson, np.nan)
+            assert_raises(ValueError, random.poisson, [np.nan] * 10)
+
+    def test_power(self):
+        random = Generator(MT19937(self.seed))
+        actual = random.power(a=.123456789, size=(3, 2))
+        desired = np.array([[1.977857368842754e-09, 9.806792196620341e-02],
+                            [2.482442984543471e-10, 1.527108843266079e-01],
+                            [8.188283434244285e-02, 3.950547209346948e-01]])
+        assert_array_almost_equal(actual, desired, decimal=15)
+
+    def test_rayleigh(self):
+        random = Generator(MT19937(self.seed))
+        actual = random.rayleigh(scale=10, size=(3, 2))
+        desired = np.array([[4.19494429102666, 16.66920198906598],
+                            [3.67184544902662, 17.74695521962917],
+                            [16.27935397855501, 21.08355560691792]])
+        assert_array_almost_equal(actual, desired, decimal=14)
+
+    def test_rayleigh_0(self):
+        assert_equal(random.rayleigh(scale=0), 0)
+        assert_raises(ValueError, random.rayleigh, scale=-0.)
+
+    def test_standard_cauchy(self):
+        random = Generator(MT19937(self.seed))
+        actual = random.standard_cauchy(size=(3, 2))
+        desired = np.array([[-1.489437778266206, -3.275389641569784],
+                            [ 0.560102864910406, -0.680780916282552],
+                            [-1.314912905226277,  0.295852965660225]])
+        assert_array_almost_equal(actual, desired, decimal=15)
+
+    def test_standard_exponential(self):
+        random = Generator(MT19937(self.seed))
+        actual = random.standard_exponential(size=(3, 2), method='inv')
+        desired = np.array([[0.102031839440643, 1.229350298474972],
+                            [0.088137284693098, 1.459859985522667],
+                            [1.093830802293668, 1.256977002164613]])
+        assert_array_almost_equal(actual, desired, decimal=15)
+
+    def test_standard_expoential_type_error(self):
+        assert_raises(TypeError, random.standard_exponential, dtype=np.int32)
+
+    def test_standard_gamma(self):
+        random = Generator(MT19937(self.seed))
+        actual = random.standard_gamma(shape=3, size=(3, 2))
+        desired = np.array([[0.62970724056362, 1.22379851271008],
+                            [3.899412530884  , 4.12479964250139],
+                            [3.74994102464584, 3.74929307690815]])
+        assert_array_almost_equal(actual, desired, decimal=14)
+
+    def test_standard_gammma_scalar_float(self):
+        random = Generator(MT19937(self.seed))
+        actual = random.standard_gamma(3, dtype=np.float32)
+        desired = 2.9242148399353027
+        assert_array_almost_equal(actual, desired, decimal=6)
+
+    def test_standard_gamma_float(self):
+        random = Generator(MT19937(self.seed))
+        actual = random.standard_gamma(shape=3, size=(3, 2))
+        desired = np.array([[0.62971, 1.2238 ],
+                            [3.89941, 4.1248 ],
+                            [3.74994, 3.74929]])
+        assert_array_almost_equal(actual, desired, decimal=5)
+
+    def test_standard_gammma_float_out(self):
+        actual = np.zeros((3, 2), dtype=np.float32)
+        random = Generator(MT19937(self.seed))
+        random.standard_gamma(10.0, out=actual, dtype=np.float32)
+        desired = np.array([[10.14987,  7.87012],
+                             [ 9.46284, 12.56832],
+                             [13.82495,  7.81533]], dtype=np.float32)
+        assert_array_almost_equal(actual, desired, decimal=5)
+
+        random = Generator(MT19937(self.seed))
+        random.standard_gamma(10.0, out=actual, size=(3, 2), dtype=np.float32)
+        assert_array_almost_equal(actual, desired, decimal=5)
+
+    def test_standard_gamma_unknown_type(self):
+        assert_raises(TypeError, random.standard_gamma, 1.,
+                      dtype='int32')
+
+    def test_out_size_mismatch(self):
+        out = np.zeros(10)
+        assert_raises(ValueError, random.standard_gamma, 10.0, size=20,
+                      out=out)
+        assert_raises(ValueError, random.standard_gamma, 10.0, size=(10, 1),
+                      out=out)
+
+    def test_standard_gamma_0(self):
+        assert_equal(random.standard_gamma(shape=0), 0)
+        assert_raises(ValueError, random.standard_gamma, shape=-0.)
+
+    def test_standard_normal(self):
+        random = Generator(MT19937(self.seed))
+        actual = random.standard_normal(size=(3, 2))
+        desired = np.array([[-1.870934851846581,  1.25613495182354 ],
+                            [-1.120190126006621,  0.342002097029821],
+                            [ 0.661545174124296,  1.181113712443012]])
+        assert_array_almost_equal(actual, desired, decimal=15)
+
+    def test_standard_normal_unsupported_type(self):
+        assert_raises(TypeError, random.standard_normal, dtype=np.int32)
+
+    def test_standard_t(self):
+        random = Generator(MT19937(self.seed))
+        actual = random.standard_t(df=10, size=(3, 2))
+        desired = np.array([[-1.484666193042647,  0.30597891831161 ],
+                            [ 1.056684299648085, -0.407312602088507],
+                            [ 0.130704414281157, -2.038053410490321]])
+        assert_array_almost_equal(actual, desired, decimal=15)
+
+    def test_triangular(self):
+        random = Generator(MT19937(self.seed))
+        actual = random.triangular(left=5.12, mode=10.23, right=20.34,
+                                   size=(3, 2))
+        desired = np.array([[ 7.86664070590917, 13.6313848513185 ],
+                            [ 7.68152445215983, 14.36169131136546],
+                            [13.16105603911429, 13.72341621856971]])
+        assert_array_almost_equal(actual, desired, decimal=14)
+
+    def test_uniform(self):
+        random = Generator(MT19937(self.seed))
+        actual = random.uniform(low=1.23, high=10.54, size=(3, 2))
+        desired = np.array([[2.13306255040998 , 7.816987531021207],
+                            [2.015436610109887, 8.377577533009589],
+                            [7.421792588856135, 7.891185744455209]])
+        assert_array_almost_equal(actual, desired, decimal=15)
+
+    def test_uniform_range_bounds(self):
+        fmin = np.finfo('float').min
+        fmax = np.finfo('float').max
+
+        func = random.uniform
+        assert_raises(OverflowError, func, -np.inf, 0)
+        assert_raises(OverflowError, func, 0, np.inf)
+        assert_raises(OverflowError, func, fmin, fmax)
+        assert_raises(OverflowError, func, [-np.inf], [0])
+        assert_raises(OverflowError, func, [0], [np.inf])
+
+        # (fmax / 1e17) - fmin is within range, so this should not throw
+        # account for i386 extended precision DBL_MAX / 1e17 + DBL_MAX >
+        # DBL_MAX by increasing fmin a bit
+        random.uniform(low=np.nextafter(fmin, 1), high=fmax / 1e17)
+
+    def test_uniform_zero_range(self):
+        func = random.uniform
+        result = func(1.5, 1.5)
+        assert_allclose(result, 1.5)
+        result = func([0.0, np.pi], [0.0, np.pi])
+        assert_allclose(result, [0.0, np.pi])
+        result = func([[2145.12], [2145.12]], [2145.12, 2145.12])
+        assert_allclose(result, 2145.12 + np.zeros((2, 2)))
+
+    def test_uniform_neg_range(self):
+        func = random.uniform
+        assert_raises(ValueError, func, 2, 1)
+        assert_raises(ValueError, func,  [1, 2], [1, 1])
+        assert_raises(ValueError, func,  [[0, 1],[2, 3]], 2)
+
+    def test_scalar_exception_propagation(self):
+        # Tests that exceptions are correctly propagated in distributions
+        # when called with objects that throw exceptions when converted to
+        # scalars.
+        #
+        # Regression test for gh: 8865
+
+        class ThrowingFloat(np.ndarray):
+            def __float__(self):
+                raise TypeError
+
+        throwing_float = np.array(1.0).view(ThrowingFloat)
+        assert_raises(TypeError, random.uniform, throwing_float,
+                      throwing_float)
+
+        class ThrowingInteger(np.ndarray):
+            def __int__(self):
+                raise TypeError
+
+        throwing_int = np.array(1).view(ThrowingInteger)
+        assert_raises(TypeError, random.hypergeometric, throwing_int, 1, 1)
+
+    def test_vonmises(self):
+        random = Generator(MT19937(self.seed))
+        actual = random.vonmises(mu=1.23, kappa=1.54, size=(3, 2))
+        desired = np.array([[ 1.107972248690106,  2.841536476232361],
+                            [ 1.832602376042457,  1.945511926976032],
+                            [-0.260147475776542,  2.058047492231698]])
+        assert_array_almost_equal(actual, desired, decimal=15)
+
+    def test_vonmises_small(self):
+        # check infinite loop, gh-4720
+        random = Generator(MT19937(self.seed))
+        r = random.vonmises(mu=0., kappa=1.1e-8, size=10**6)
+        assert_(np.isfinite(r).all())
+
+    def test_vonmises_nan(self):
+        random = Generator(MT19937(self.seed))
+        r = random.vonmises(mu=0., kappa=np.nan)
+        assert_(np.isnan(r))
+
+    @pytest.mark.parametrize("kappa", [1e4, 1e15])
+    def test_vonmises_large_kappa(self, kappa):
+        random = Generator(MT19937(self.seed))
+        rs = RandomState(random.bit_generator)
+        state = random.bit_generator.state
+
+        random_state_vals = rs.vonmises(0, kappa, size=10)
+        random.bit_generator.state = state
+        gen_vals = random.vonmises(0, kappa, size=10)
+        if kappa < 1e6:
+            assert_allclose(random_state_vals, gen_vals)
+        else:
+            assert np.all(random_state_vals != gen_vals)
+
+    @pytest.mark.parametrize("mu", [-7., -np.pi, -3.1, np.pi, 3.2])
+    @pytest.mark.parametrize("kappa", [1e-9, 1e-6, 1, 1e3, 1e15])
+    def test_vonmises_large_kappa_range(self, mu, kappa):
+        random = Generator(MT19937(self.seed))
+        r = random.vonmises(mu, kappa, 50)
+        assert_(np.all(r > -np.pi) and np.all(r <= np.pi))
+
+    def test_wald(self):
+        random = Generator(MT19937(self.seed))
+        actual = random.wald(mean=1.23, scale=1.54, size=(3, 2))
+        desired = np.array([[0.26871721804551, 3.2233942732115 ],
+                            [2.20328374987066, 2.40958405189353],
+                            [2.07093587449261, 0.73073890064369]])
+        assert_array_almost_equal(actual, desired, decimal=14)
+
+    def test_weibull(self):
+        random = Generator(MT19937(self.seed))
+        actual = random.weibull(a=1.23, size=(3, 2))
+        desired = np.array([[0.138613914769468, 1.306463419753191],
+                            [0.111623365934763, 1.446570494646721],
+                            [1.257145775276011, 1.914247725027957]])
+        assert_array_almost_equal(actual, desired, decimal=15)
+
+    def test_weibull_0(self):
+        random = Generator(MT19937(self.seed))
+        assert_equal(random.weibull(a=0, size=12), np.zeros(12))
+        assert_raises(ValueError, random.weibull, a=-0.)
+
+    def test_zipf(self):
+        random = Generator(MT19937(self.seed))
+        actual = random.zipf(a=1.23, size=(3, 2))
+        desired = np.array([[  1,   1],
+                            [ 10, 867],
+                            [354,   2]])
+        assert_array_equal(actual, desired)
+
+
+class TestBroadcast:
+    # tests that functions that broadcast behave
+    # correctly when presented with non-scalar arguments
+    def setup_method(self):
+        self.seed = 123456789
+
+    def test_uniform(self):
+        random = Generator(MT19937(self.seed))
+        low = [0]
+        high = [1]
+        uniform = random.uniform
+        desired = np.array([0.16693771389729, 0.19635129550675, 0.75563050964095])
+
+        random = Generator(MT19937(self.seed))
+        actual = random.uniform(low * 3, high)
+        assert_array_almost_equal(actual, desired, decimal=14)
+
+        random = Generator(MT19937(self.seed))
+        actual = random.uniform(low, high * 3)
+        assert_array_almost_equal(actual, desired, decimal=14)
+
+    def test_normal(self):
+        loc = [0]
+        scale = [1]
+        bad_scale = [-1]
+        random = Generator(MT19937(self.seed))
+        desired = np.array([-0.38736406738527,  0.79594375042255,  0.0197076236097])
+
+        random = Generator(MT19937(self.seed))
+        actual = random.normal(loc * 3, scale)
+        assert_array_almost_equal(actual, desired, decimal=14)
+        assert_raises(ValueError, random.normal, loc * 3, bad_scale)
+
+        random = Generator(MT19937(self.seed))
+        normal = random.normal
+        actual = normal(loc, scale * 3)
+        assert_array_almost_equal(actual, desired, decimal=14)
+        assert_raises(ValueError, normal, loc, bad_scale * 3)
+
+    def test_beta(self):
+        a = [1]
+        b = [2]
+        bad_a = [-1]
+        bad_b = [-2]
+        desired = np.array([0.18719338682602, 0.73234824491364, 0.17928615186455])
+
+        random = Generator(MT19937(self.seed))
+        beta = random.beta
+        actual = beta(a * 3, b)
+        assert_array_almost_equal(actual, desired, decimal=14)
+        assert_raises(ValueError, beta, bad_a * 3, b)
+        assert_raises(ValueError, beta, a * 3, bad_b)
+
+        random = Generator(MT19937(self.seed))
+        actual = random.beta(a, b * 3)
+        assert_array_almost_equal(actual, desired, decimal=14)
+
+    def test_exponential(self):
+        scale = [1]
+        bad_scale = [-1]
+        desired = np.array([0.67245993212806, 0.21380495318094, 0.7177848928629])
+
+        random = Generator(MT19937(self.seed))
+        actual = random.exponential(scale * 3)
+        assert_array_almost_equal(actual, desired, decimal=14)
+        assert_raises(ValueError, random.exponential, bad_scale * 3)
+
+    def test_standard_gamma(self):
+        shape = [1]
+        bad_shape = [-1]
+        desired = np.array([0.67245993212806, 0.21380495318094, 0.7177848928629])
+
+        random = Generator(MT19937(self.seed))
+        std_gamma = random.standard_gamma
+        actual = std_gamma(shape * 3)
+        assert_array_almost_equal(actual, desired, decimal=14)
+        assert_raises(ValueError, std_gamma, bad_shape * 3)
+
+    def test_gamma(self):
+        shape = [1]
+        scale = [2]
+        bad_shape = [-1]
+        bad_scale = [-2]
+        desired = np.array([1.34491986425611, 0.42760990636187, 1.4355697857258])
+
+        random = Generator(MT19937(self.seed))
+        gamma = random.gamma
+        actual = gamma(shape * 3, scale)
+        assert_array_almost_equal(actual, desired, decimal=14)
+        assert_raises(ValueError, gamma, bad_shape * 3, scale)
+        assert_raises(ValueError, gamma, shape * 3, bad_scale)
+
+        random = Generator(MT19937(self.seed))
+        gamma = random.gamma
+        actual = gamma(shape, scale * 3)
+        assert_array_almost_equal(actual, desired, decimal=14)
+        assert_raises(ValueError, gamma, bad_shape, scale * 3)
+        assert_raises(ValueError, gamma, shape, bad_scale * 3)
+
+    def test_f(self):
+        dfnum = [1]
+        dfden = [2]
+        bad_dfnum = [-1]
+        bad_dfden = [-2]
+        desired = np.array([0.07765056244107, 7.72951397913186, 0.05786093891763])
+
+        random = Generator(MT19937(self.seed))
+        f = random.f
+        actual = f(dfnum * 3, dfden)
+        assert_array_almost_equal(actual, desired, decimal=14)
+        assert_raises(ValueError, f, bad_dfnum * 3, dfden)
+        assert_raises(ValueError, f, dfnum * 3, bad_dfden)
+
+        random = Generator(MT19937(self.seed))
+        f = random.f
+        actual = f(dfnum, dfden * 3)
+        assert_array_almost_equal(actual, desired, decimal=14)
+        assert_raises(ValueError, f, bad_dfnum, dfden * 3)
+        assert_raises(ValueError, f, dfnum, bad_dfden * 3)
+
+    def test_noncentral_f(self):
+        dfnum = [2]
+        dfden = [3]
+        nonc = [4]
+        bad_dfnum = [0]
+        bad_dfden = [-1]
+        bad_nonc = [-2]
+        desired = np.array([2.02434240411421, 12.91838601070124, 1.24395160354629])
+
+        random = Generator(MT19937(self.seed))
+        nonc_f = random.noncentral_f
+        actual = nonc_f(dfnum * 3, dfden, nonc)
+        assert_array_almost_equal(actual, desired, decimal=14)
+        assert np.all(np.isnan(nonc_f(dfnum, dfden, [np.nan] * 3)))
+
+        assert_raises(ValueError, nonc_f, bad_dfnum * 3, dfden, nonc)
+        assert_raises(ValueError, nonc_f, dfnum * 3, bad_dfden, nonc)
+        assert_raises(ValueError, nonc_f, dfnum * 3, dfden, bad_nonc)
+
+        random = Generator(MT19937(self.seed))
+        nonc_f = random.noncentral_f
+        actual = nonc_f(dfnum, dfden * 3, nonc)
+        assert_array_almost_equal(actual, desired, decimal=14)
+        assert_raises(ValueError, nonc_f, bad_dfnum, dfden * 3, nonc)
+        assert_raises(ValueError, nonc_f, dfnum, bad_dfden * 3, nonc)
+        assert_raises(ValueError, nonc_f, dfnum, dfden * 3, bad_nonc)
+
+        random = Generator(MT19937(self.seed))
+        nonc_f = random.noncentral_f
+        actual = nonc_f(dfnum, dfden, nonc * 3)
+        assert_array_almost_equal(actual, desired, decimal=14)
+        assert_raises(ValueError, nonc_f, bad_dfnum, dfden, nonc * 3)
+        assert_raises(ValueError, nonc_f, dfnum, bad_dfden, nonc * 3)
+        assert_raises(ValueError, nonc_f, dfnum, dfden, bad_nonc * 3)
+
+    def test_noncentral_f_small_df(self):
+        random = Generator(MT19937(self.seed))
+        desired = np.array([0.04714867120827, 0.1239390327694])
+        actual = random.noncentral_f(0.9, 0.9, 2, size=2)
+        assert_array_almost_equal(actual, desired, decimal=14)
+
+    def test_chisquare(self):
+        df = [1]
+        bad_df = [-1]
+        desired = np.array([0.05573640064251, 1.47220224353539, 2.9469379318589])
+
+        random = Generator(MT19937(self.seed))
+        actual = random.chisquare(df * 3)
+        assert_array_almost_equal(actual, desired, decimal=14)
+        assert_raises(ValueError, random.chisquare, bad_df * 3)
+
+    def test_noncentral_chisquare(self):
+        df = [1]
+        nonc = [2]
+        bad_df = [-1]
+        bad_nonc = [-2]
+        desired = np.array([0.07710766249436, 5.27829115110304, 0.630732147399])
+
+        random = Generator(MT19937(self.seed))
+        nonc_chi = random.noncentral_chisquare
+        actual = nonc_chi(df * 3, nonc)
+        assert_array_almost_equal(actual, desired, decimal=14)
+        assert_raises(ValueError, nonc_chi, bad_df * 3, nonc)
+        assert_raises(ValueError, nonc_chi, df * 3, bad_nonc)
+
+        random = Generator(MT19937(self.seed))
+        nonc_chi = random.noncentral_chisquare
+        actual = nonc_chi(df, nonc * 3)
+        assert_array_almost_equal(actual, desired, decimal=14)
+        assert_raises(ValueError, nonc_chi, bad_df, nonc * 3)
+        assert_raises(ValueError, nonc_chi, df, bad_nonc * 3)
+
+    def test_standard_t(self):
+        df = [1]
+        bad_df = [-1]
+        desired = np.array([-1.39498829447098, -1.23058658835223, 0.17207021065983])
+
+        random = Generator(MT19937(self.seed))
+        actual = random.standard_t(df * 3)
+        assert_array_almost_equal(actual, desired, decimal=14)
+        assert_raises(ValueError, random.standard_t, bad_df * 3)
+
+    def test_vonmises(self):
+        mu = [2]
+        kappa = [1]
+        bad_kappa = [-1]
+        desired = np.array([2.25935584988528, 2.23326261461399, -2.84152146503326])
+
+        random = Generator(MT19937(self.seed))
+        actual = random.vonmises(mu * 3, kappa)
+        assert_array_almost_equal(actual, desired, decimal=14)
+        assert_raises(ValueError, random.vonmises, mu * 3, bad_kappa)
+
+        random = Generator(MT19937(self.seed))
+        actual = random.vonmises(mu, kappa * 3)
+        assert_array_almost_equal(actual, desired, decimal=14)
+        assert_raises(ValueError, random.vonmises, mu, bad_kappa * 3)
+
+    def test_pareto(self):
+        a = [1]
+        bad_a = [-1]
+        desired = np.array([0.95905052946317, 0.2383810889437 , 1.04988745750013])
+
+        random = Generator(MT19937(self.seed))
+        actual = random.pareto(a * 3)
+        assert_array_almost_equal(actual, desired, decimal=14)
+        assert_raises(ValueError, random.pareto, bad_a * 3)
+
+    def test_weibull(self):
+        a = [1]
+        bad_a = [-1]
+        desired = np.array([0.67245993212806, 0.21380495318094, 0.7177848928629])
+
+        random = Generator(MT19937(self.seed))
+        actual = random.weibull(a * 3)
+        assert_array_almost_equal(actual, desired, decimal=14)
+        assert_raises(ValueError, random.weibull, bad_a * 3)
+
+    def test_power(self):
+        a = [1]
+        bad_a = [-1]
+        desired = np.array([0.48954864361052, 0.19249412888486, 0.51216834058807])
+
+        random = Generator(MT19937(self.seed))
+        actual = random.power(a * 3)
+        assert_array_almost_equal(actual, desired, decimal=14)
+        assert_raises(ValueError, random.power, bad_a * 3)
+
+    def test_laplace(self):
+        loc = [0]
+        scale = [1]
+        bad_scale = [-1]
+        desired = np.array([-1.09698732625119, -0.93470271947368, 0.71592671378202])
+
+        random = Generator(MT19937(self.seed))
+        laplace = random.laplace
+        actual = laplace(loc * 3, scale)
+        assert_array_almost_equal(actual, desired, decimal=14)
+        assert_raises(ValueError, laplace, loc * 3, bad_scale)
+
+        random = Generator(MT19937(self.seed))
+        laplace = random.laplace
+        actual = laplace(loc, scale * 3)
+        assert_array_almost_equal(actual, desired, decimal=14)
+        assert_raises(ValueError, laplace, loc, bad_scale * 3)
+
+    def test_gumbel(self):
+        loc = [0]
+        scale = [1]
+        bad_scale = [-1]
+        desired = np.array([1.70020068231762, 1.52054354273631, -0.34293267607081])
+
+        random = Generator(MT19937(self.seed))
+        gumbel = random.gumbel
+        actual = gumbel(loc * 3, scale)
+        assert_array_almost_equal(actual, desired, decimal=14)
+        assert_raises(ValueError, gumbel, loc * 3, bad_scale)
+
+        random = Generator(MT19937(self.seed))
+        gumbel = random.gumbel
+        actual = gumbel(loc, scale * 3)
+        assert_array_almost_equal(actual, desired, decimal=14)
+        assert_raises(ValueError, gumbel, loc, bad_scale * 3)
+
+    def test_logistic(self):
+        loc = [0]
+        scale = [1]
+        bad_scale = [-1]
+        desired = np.array([-1.607487640433, -1.40925686003678, 1.12887112820397])
+
+        random = Generator(MT19937(self.seed))
+        actual = random.logistic(loc * 3, scale)
+        assert_array_almost_equal(actual, desired, decimal=14)
+        assert_raises(ValueError, random.logistic, loc * 3, bad_scale)
+
+        random = Generator(MT19937(self.seed))
+        actual = random.logistic(loc, scale * 3)
+        assert_array_almost_equal(actual, desired, decimal=14)
+        assert_raises(ValueError, random.logistic, loc, bad_scale * 3)
+        assert_equal(random.logistic(1.0, 0.0), 1.0)
+
+    def test_lognormal(self):
+        mean = [0]
+        sigma = [1]
+        bad_sigma = [-1]
+        desired = np.array([0.67884390500697, 2.21653186290321, 1.01990310084276])
+
+        random = Generator(MT19937(self.seed))
+        lognormal = random.lognormal
+        actual = lognormal(mean * 3, sigma)
+        assert_array_almost_equal(actual, desired, decimal=14)
+        assert_raises(ValueError, lognormal, mean * 3, bad_sigma)
+
+        random = Generator(MT19937(self.seed))
+        actual = random.lognormal(mean, sigma * 3)
+        assert_raises(ValueError, random.lognormal, mean, bad_sigma * 3)
+
+    def test_rayleigh(self):
+        scale = [1]
+        bad_scale = [-1]
+        desired = np.array(
+            [1.1597068009872629,
+             0.6539188836253857,
+             1.1981526554349398]
+        )
+
+        random = Generator(MT19937(self.seed))
+        actual = random.rayleigh(scale * 3)
+        assert_array_almost_equal(actual, desired, decimal=14)
+        assert_raises(ValueError, random.rayleigh, bad_scale * 3)
+
+    def test_wald(self):
+        mean = [0.5]
+        scale = [1]
+        bad_mean = [0]
+        bad_scale = [-2]
+        desired = np.array([0.38052407392905, 0.50701641508592, 0.484935249864])
+
+        random = Generator(MT19937(self.seed))
+        actual = random.wald(mean * 3, scale)
+        assert_array_almost_equal(actual, desired, decimal=14)
+        assert_raises(ValueError, random.wald, bad_mean * 3, scale)
+        assert_raises(ValueError, random.wald, mean * 3, bad_scale)
+
+        random = Generator(MT19937(self.seed))
+        actual = random.wald(mean, scale * 3)
+        assert_array_almost_equal(actual, desired, decimal=14)
+        assert_raises(ValueError, random.wald, bad_mean, scale * 3)
+        assert_raises(ValueError, random.wald, mean, bad_scale * 3)
+
+    def test_triangular(self):
+        left = [1]
+        right = [3]
+        mode = [2]
+        bad_left_one = [3]
+        bad_mode_one = [4]
+        bad_left_two, bad_mode_two = right * 2
+        desired = np.array([1.57781954604754, 1.62665986867957, 2.30090130831326])
+
+        random = Generator(MT19937(self.seed))
+        triangular = random.triangular
+        actual = triangular(left * 3, mode, right)
+        assert_array_almost_equal(actual, desired, decimal=14)
+        assert_raises(ValueError, triangular, bad_left_one * 3, mode, right)
+        assert_raises(ValueError, triangular, left * 3, bad_mode_one, right)
+        assert_raises(ValueError, triangular, bad_left_two * 3, bad_mode_two,
+                      right)
+
+        random = Generator(MT19937(self.seed))
+        triangular = random.triangular
+        actual = triangular(left, mode * 3, right)
+        assert_array_almost_equal(actual, desired, decimal=14)
+        assert_raises(ValueError, triangular, bad_left_one, mode * 3, right)
+        assert_raises(ValueError, triangular, left, bad_mode_one * 3, right)
+        assert_raises(ValueError, triangular, bad_left_two, bad_mode_two * 3,
+                      right)
+
+        random = Generator(MT19937(self.seed))
+        triangular = random.triangular
+        actual = triangular(left, mode, right * 3)
+        assert_array_almost_equal(actual, desired, decimal=14)
+        assert_raises(ValueError, triangular, bad_left_one, mode, right * 3)
+        assert_raises(ValueError, triangular, left, bad_mode_one, right * 3)
+        assert_raises(ValueError, triangular, bad_left_two, bad_mode_two,
+                      right * 3)
+
+        assert_raises(ValueError, triangular, 10., 0., 20.)
+        assert_raises(ValueError, triangular, 10., 25., 20.)
+        assert_raises(ValueError, triangular, 10., 10., 10.)
+
+    def test_binomial(self):
+        n = [1]
+        p = [0.5]
+        bad_n = [-1]
+        bad_p_one = [-1]
+        bad_p_two = [1.5]
+        desired = np.array([0, 0, 1])
+
+        random = Generator(MT19937(self.seed))
+        binom = random.binomial
+        actual = binom(n * 3, p)
+        assert_array_equal(actual, desired)
+        assert_raises(ValueError, binom, bad_n * 3, p)
+        assert_raises(ValueError, binom, n * 3, bad_p_one)
+        assert_raises(ValueError, binom, n * 3, bad_p_two)
+
+        random = Generator(MT19937(self.seed))
+        actual = random.binomial(n, p * 3)
+        assert_array_equal(actual, desired)
+        assert_raises(ValueError, binom, bad_n, p * 3)
+        assert_raises(ValueError, binom, n, bad_p_one * 3)
+        assert_raises(ValueError, binom, n, bad_p_two * 3)
+
+    def test_negative_binomial(self):
+        n = [1]
+        p = [0.5]
+        bad_n = [-1]
+        bad_p_one = [-1]
+        bad_p_two = [1.5]
+        desired = np.array([0, 2, 1], dtype=np.int64)
+
+        random = Generator(MT19937(self.seed))
+        neg_binom = random.negative_binomial
+        actual = neg_binom(n * 3, p)
+        assert_array_equal(actual, desired)
+        assert_raises(ValueError, neg_binom, bad_n * 3, p)
+        assert_raises(ValueError, neg_binom, n * 3, bad_p_one)
+        assert_raises(ValueError, neg_binom, n * 3, bad_p_two)
+
+        random = Generator(MT19937(self.seed))
+        neg_binom = random.negative_binomial
+        actual = neg_binom(n, p * 3)
+        assert_array_equal(actual, desired)
+        assert_raises(ValueError, neg_binom, bad_n, p * 3)
+        assert_raises(ValueError, neg_binom, n, bad_p_one * 3)
+        assert_raises(ValueError, neg_binom, n, bad_p_two * 3)
+
+    def test_poisson(self):
+
+        lam = [1]
+        bad_lam_one = [-1]
+        desired = np.array([0, 0, 3])
+
+        random = Generator(MT19937(self.seed))
+        max_lam = random._poisson_lam_max
+        bad_lam_two = [max_lam * 2]
+        poisson = random.poisson
+        actual = poisson(lam * 3)
+        assert_array_equal(actual, desired)
+        assert_raises(ValueError, poisson, bad_lam_one * 3)
+        assert_raises(ValueError, poisson, bad_lam_two * 3)
+
+    def test_zipf(self):
+        a = [2]
+        bad_a = [0]
+        desired = np.array([1, 8, 1])
+
+        random = Generator(MT19937(self.seed))
+        zipf = random.zipf
+        actual = zipf(a * 3)
+        assert_array_equal(actual, desired)
+        assert_raises(ValueError, zipf, bad_a * 3)
+        with np.errstate(invalid='ignore'):
+            assert_raises(ValueError, zipf, np.nan)
+            assert_raises(ValueError, zipf, [0, 0, np.nan])
+
+    def test_geometric(self):
+        p = [0.5]
+        bad_p_one = [-1]
+        bad_p_two = [1.5]
+        desired = np.array([1, 1, 3])
+
+        random = Generator(MT19937(self.seed))
+        geometric = random.geometric
+        actual = geometric(p * 3)
+        assert_array_equal(actual, desired)
+        assert_raises(ValueError, geometric, bad_p_one * 3)
+        assert_raises(ValueError, geometric, bad_p_two * 3)
+
+    def test_hypergeometric(self):
+        ngood = [1]
+        nbad = [2]
+        nsample = [2]
+        bad_ngood = [-1]
+        bad_nbad = [-2]
+        bad_nsample_one = [-1]
+        bad_nsample_two = [4]
+        desired = np.array([0, 0, 1])
+
+        random = Generator(MT19937(self.seed))
+        actual = random.hypergeometric(ngood * 3, nbad, nsample)
+        assert_array_equal(actual, desired)
+        assert_raises(ValueError, random.hypergeometric, bad_ngood * 3, nbad, nsample)
+        assert_raises(ValueError, random.hypergeometric, ngood * 3, bad_nbad, nsample)
+        assert_raises(ValueError, random.hypergeometric, ngood * 3, nbad, bad_nsample_one)
+        assert_raises(ValueError, random.hypergeometric, ngood * 3, nbad, bad_nsample_two)
+
+        random = Generator(MT19937(self.seed))
+        actual = random.hypergeometric(ngood, nbad * 3, nsample)
+        assert_array_equal(actual, desired)
+        assert_raises(ValueError, random.hypergeometric, bad_ngood, nbad * 3, nsample)
+        assert_raises(ValueError, random.hypergeometric, ngood, bad_nbad * 3, nsample)
+        assert_raises(ValueError, random.hypergeometric, ngood, nbad * 3, bad_nsample_one)
+        assert_raises(ValueError, random.hypergeometric, ngood, nbad * 3, bad_nsample_two)
+
+        random = Generator(MT19937(self.seed))
+        hypergeom = random.hypergeometric
+        actual = hypergeom(ngood, nbad, nsample * 3)
+        assert_array_equal(actual, desired)
+        assert_raises(ValueError, hypergeom, bad_ngood, nbad, nsample * 3)
+        assert_raises(ValueError, hypergeom, ngood, bad_nbad, nsample * 3)
+        assert_raises(ValueError, hypergeom, ngood, nbad, bad_nsample_one * 3)
+        assert_raises(ValueError, hypergeom, ngood, nbad, bad_nsample_two * 3)
+
+        assert_raises(ValueError, hypergeom, -1, 10, 20)
+        assert_raises(ValueError, hypergeom, 10, -1, 20)
+        assert_raises(ValueError, hypergeom, 10, 10, -1)
+        assert_raises(ValueError, hypergeom, 10, 10, 25)
+
+        # ValueError for arguments that are too big.
+        assert_raises(ValueError, hypergeom, 2**30, 10, 20)
+        assert_raises(ValueError, hypergeom, 999, 2**31, 50)
+        assert_raises(ValueError, hypergeom, 999, [2**29, 2**30], 1000)
+
+    def test_logseries(self):
+        p = [0.5]
+        bad_p_one = [2]
+        bad_p_two = [-1]
+        desired = np.array([1, 1, 1])
+
+        random = Generator(MT19937(self.seed))
+        logseries = random.logseries
+        actual = logseries(p * 3)
+        assert_array_equal(actual, desired)
+        assert_raises(ValueError, logseries, bad_p_one * 3)
+        assert_raises(ValueError, logseries, bad_p_two * 3)
+
+    def test_multinomial(self):
+        random = Generator(MT19937(self.seed))
+        actual = random.multinomial([5, 20], [1 / 6.] * 6, size=(3, 2))
+        desired = np.array([[[0, 0, 2, 1, 2, 0],
+                             [2, 3, 6, 4, 2, 3]],
+                            [[1, 0, 1, 0, 2, 1],
+                             [7, 2, 2, 1, 4, 4]],
+                            [[0, 2, 0, 1, 2, 0],
+                             [3, 2, 3, 3, 4, 5]]], dtype=np.int64)
+        assert_array_equal(actual, desired)
+
+        random = Generator(MT19937(self.seed))
+        actual = random.multinomial([5, 20], [1 / 6.] * 6)
+        desired = np.array([[0, 0, 2, 1, 2, 0],
+                            [2, 3, 6, 4, 2, 3]], dtype=np.int64)
+        assert_array_equal(actual, desired)
+
+        random = Generator(MT19937(self.seed))
+        actual = random.multinomial([5, 20], [[1 / 6.] * 6] * 2)
+        desired = np.array([[0, 0, 2, 1, 2, 0],
+                            [2, 3, 6, 4, 2, 3]], dtype=np.int64)
+        assert_array_equal(actual, desired)
+
+        random = Generator(MT19937(self.seed))
+        actual = random.multinomial([[5], [20]], [[1 / 6.] * 6] * 2)
+        desired = np.array([[[0, 0, 2, 1, 2, 0],
+                             [0, 0, 2, 1, 1, 1]],
+                            [[4, 2, 3, 3, 5, 3],
+                             [7, 2, 2, 1, 4, 4]]], dtype=np.int64)
+        assert_array_equal(actual, desired)
+
+    @pytest.mark.parametrize("n", [10,
+                                   np.array([10, 10]),
+                                   np.array([[[10]], [[10]]])
+                                   ]
+                             )
+    def test_multinomial_pval_broadcast(self, n):
+        random = Generator(MT19937(self.seed))
+        pvals = np.array([1 / 4] * 4)
+        actual = random.multinomial(n, pvals)
+        n_shape = tuple() if isinstance(n, int) else n.shape
+        expected_shape = n_shape + (4,)
+        assert actual.shape == expected_shape
+        pvals = np.vstack([pvals, pvals])
+        actual = random.multinomial(n, pvals)
+        expected_shape = np.broadcast_shapes(n_shape, pvals.shape[:-1]) + (4,)
+        assert actual.shape == expected_shape
+
+        pvals = np.vstack([[pvals], [pvals]])
+        actual = random.multinomial(n, pvals)
+        expected_shape = np.broadcast_shapes(n_shape, pvals.shape[:-1])
+        assert actual.shape == expected_shape + (4,)
+        actual = random.multinomial(n, pvals, size=(3, 2) + expected_shape)
+        assert actual.shape == (3, 2) + expected_shape + (4,)
+
+        with pytest.raises(ValueError):
+            # Ensure that size is not broadcast
+            actual = random.multinomial(n, pvals, size=(1,) * 6)
+
+    def test_invalid_pvals_broadcast(self):
+        random = Generator(MT19937(self.seed))
+        pvals = [[1 / 6] * 6, [1 / 4] * 6]
+        assert_raises(ValueError, random.multinomial, 1, pvals)
+        assert_raises(ValueError, random.multinomial, 6, 0.5)
+
+    def test_empty_outputs(self):
+        random = Generator(MT19937(self.seed))
+        actual = random.multinomial(np.empty((10, 0, 6), "i8"), [1 / 6] * 6)
+        assert actual.shape == (10, 0, 6, 6)
+        actual = random.multinomial(12, np.empty((10, 0, 10)))
+        assert actual.shape == (10, 0, 10)
+        actual = random.multinomial(np.empty((3, 0, 7), "i8"),
+                                    np.empty((3, 0, 7, 4)))
+        assert actual.shape == (3, 0, 7, 4)
+
+
+@pytest.mark.skipif(IS_WASM, reason="can't start thread")
+class TestThread:
+    # make sure each state produces the same sequence even in threads
+    def setup_method(self):
+        self.seeds = range(4)
+
+    def check_function(self, function, sz):
+        from threading import Thread
+
+        out1 = np.empty((len(self.seeds),) + sz)
+        out2 = np.empty((len(self.seeds),) + sz)
+
+        # threaded generation
+        t = [Thread(target=function, args=(Generator(MT19937(s)), o))
+             for s, o in zip(self.seeds, out1)]
+        [x.start() for x in t]
+        [x.join() for x in t]
+
+        # the same serial
+        for s, o in zip(self.seeds, out2):
+            function(Generator(MT19937(s)), o)
+
+        # these platforms change x87 fpu precision mode in threads
+        if np.intp().dtype.itemsize == 4 and sys.platform == "win32":
+            assert_array_almost_equal(out1, out2)
+        else:
+            assert_array_equal(out1, out2)
+
+    def test_normal(self):
+        def gen_random(state, out):
+            out[...] = state.normal(size=10000)
+
+        self.check_function(gen_random, sz=(10000,))
+
+    def test_exp(self):
+        def gen_random(state, out):
+            out[...] = state.exponential(scale=np.ones((100, 1000)))
+
+        self.check_function(gen_random, sz=(100, 1000))
+
+    def test_multinomial(self):
+        def gen_random(state, out):
+            out[...] = state.multinomial(10, [1 / 6.] * 6, size=10000)
+
+        self.check_function(gen_random, sz=(10000, 6))
+
+
+# See Issue #4263
+class TestSingleEltArrayInput:
+    def setup_method(self):
+        self.argOne = np.array([2])
+        self.argTwo = np.array([3])
+        self.argThree = np.array([4])
+        self.tgtShape = (1,)
+
+    def test_one_arg_funcs(self):
+        funcs = (random.exponential, random.standard_gamma,
+                 random.chisquare, random.standard_t,
+                 random.pareto, random.weibull,
+                 random.power, random.rayleigh,
+                 random.poisson, random.zipf,
+                 random.geometric, random.logseries)
+
+        probfuncs = (random.geometric, random.logseries)
+
+        for func in funcs:
+            if func in probfuncs:  # p < 1.0
+                out = func(np.array([0.5]))
+
+            else:
+                out = func(self.argOne)
+
+            assert_equal(out.shape, self.tgtShape)
+
+    def test_two_arg_funcs(self):
+        funcs = (random.uniform, random.normal,
+                 random.beta, random.gamma,
+                 random.f, random.noncentral_chisquare,
+                 random.vonmises, random.laplace,
+                 random.gumbel, random.logistic,
+                 random.lognormal, random.wald,
+                 random.binomial, random.negative_binomial)
+
+        probfuncs = (random.binomial, random.negative_binomial)
+
+        for func in funcs:
+            if func in probfuncs:  # p <= 1
+                argTwo = np.array([0.5])
+
+            else:
+                argTwo = self.argTwo
+
+            out = func(self.argOne, argTwo)
+            assert_equal(out.shape, self.tgtShape)
+
+            out = func(self.argOne[0], argTwo)
+            assert_equal(out.shape, self.tgtShape)
+
+            out = func(self.argOne, argTwo[0])
+            assert_equal(out.shape, self.tgtShape)
+
+    def test_integers(self, endpoint):
+        itype = [np.bool, np.int8, np.uint8, np.int16, np.uint16,
+                 np.int32, np.uint32, np.int64, np.uint64]
+        func = random.integers
+        high = np.array([1])
+        low = np.array([0])
+
+        for dt in itype:
+            out = func(low, high, endpoint=endpoint, dtype=dt)
+            assert_equal(out.shape, self.tgtShape)
+
+            out = func(low[0], high, endpoint=endpoint, dtype=dt)
+            assert_equal(out.shape, self.tgtShape)
+
+            out = func(low, high[0], endpoint=endpoint, dtype=dt)
+            assert_equal(out.shape, self.tgtShape)
+
+    def test_three_arg_funcs(self):
+        funcs = [random.noncentral_f, random.triangular,
+                 random.hypergeometric]
+
+        for func in funcs:
+            out = func(self.argOne, self.argTwo, self.argThree)
+            assert_equal(out.shape, self.tgtShape)
+
+            out = func(self.argOne[0], self.argTwo, self.argThree)
+            assert_equal(out.shape, self.tgtShape)
+
+            out = func(self.argOne, self.argTwo[0], self.argThree)
+            assert_equal(out.shape, self.tgtShape)
+
+
+@pytest.mark.parametrize("config", JUMP_TEST_DATA)
+def test_jumped(config):
+    # Each config contains the initial seed, a number of raw steps
+    # the sha256 hashes of the initial and the final states' keys and
+    # the position of the initial and the final state.
+    # These were produced using the original C implementation.
+    seed = config["seed"]
+    steps = config["steps"]
+
+    mt19937 = MT19937(seed)
+    # Burn step
+    mt19937.random_raw(steps)
+    key = mt19937.state["state"]["key"]
+    if sys.byteorder == 'big':
+        key = key.byteswap()
+    sha256 = hashlib.sha256(key)
+    assert mt19937.state["state"]["pos"] == config["initial"]["pos"]
+    assert sha256.hexdigest() == config["initial"]["key_sha256"]
+
+    jumped = mt19937.jumped()
+    key = jumped.state["state"]["key"]
+    if sys.byteorder == 'big':
+        key = key.byteswap()
+    sha256 = hashlib.sha256(key)
+    assert jumped.state["state"]["pos"] == config["jumped"]["pos"]
+    assert sha256.hexdigest() == config["jumped"]["key_sha256"]
+
+
+def test_broadcast_size_error():
+    mu = np.ones(3)
+    sigma = np.ones((4, 3))
+    size = (10, 4, 2)
+    assert random.normal(mu, sigma, size=(5, 4, 3)).shape == (5, 4, 3)
+    with pytest.raises(ValueError):
+        random.normal(mu, sigma, size=size)
+    with pytest.raises(ValueError):
+        random.normal(mu, sigma, size=(1, 3))
+    with pytest.raises(ValueError):
+        random.normal(mu, sigma, size=(4, 1, 1))
+    # 1 arg
+    shape = np.ones((4, 3))
+    with pytest.raises(ValueError):
+        random.standard_gamma(shape, size=size)
+    with pytest.raises(ValueError):
+        random.standard_gamma(shape, size=(3,))
+    with pytest.raises(ValueError):
+        random.standard_gamma(shape, size=3)
+    # Check out
+    out = np.empty(size)
+    with pytest.raises(ValueError):
+        random.standard_gamma(shape, out=out)
+
+    # 2 arg
+    with pytest.raises(ValueError):
+        random.binomial(1, [0.3, 0.7], size=(2, 1))
+    with pytest.raises(ValueError):
+        random.binomial([1, 2], 0.3, size=(2, 1))
+    with pytest.raises(ValueError):
+        random.binomial([1, 2], [0.3, 0.7], size=(2, 1))
+    with pytest.raises(ValueError):
+        random.multinomial([2, 2], [.3, .7], size=(2, 1))
+
+    # 3 arg
+    a = random.chisquare(5, size=3)
+    b = random.chisquare(5, size=(4, 3))
+    c = random.chisquare(5, size=(5, 4, 3))
+    assert random.noncentral_f(a, b, c).shape == (5, 4, 3)
+    with pytest.raises(ValueError, match=r"Output size \(6, 5, 1, 1\) is"):
+        random.noncentral_f(a, b, c, size=(6, 5, 1, 1))
+
+
+def test_broadcast_size_scalar():
+    mu = np.ones(3)
+    sigma = np.ones(3)
+    random.normal(mu, sigma, size=3)
+    with pytest.raises(ValueError):
+        random.normal(mu, sigma, size=2)
+
+
+def test_ragged_shuffle():
+    # GH 18142
+    seq = [[], [], 1]
+    gen = Generator(MT19937(0))
+    assert_no_warnings(gen.shuffle, seq)
+    assert seq == [1, [], []]
+
+
+@pytest.mark.parametrize("high", [-2, [-2]])
+@pytest.mark.parametrize("endpoint", [True, False])
+def test_single_arg_integer_exception(high, endpoint):
+    # GH 14333
+    gen = Generator(MT19937(0))
+    msg = 'high < 0' if endpoint else 'high <= 0'
+    with pytest.raises(ValueError, match=msg):
+        gen.integers(high, endpoint=endpoint)
+    msg = 'low > high' if endpoint else 'low >= high'
+    with pytest.raises(ValueError, match=msg):
+        gen.integers(-1, high, endpoint=endpoint)
+    with pytest.raises(ValueError, match=msg):
+        gen.integers([-1], high, endpoint=endpoint)
+
+
+@pytest.mark.parametrize("dtype", ["f4", "f8"])
+def test_c_contig_req_out(dtype):
+    # GH 18704
+    out = np.empty((2, 3), order="F", dtype=dtype)
+    shape = [1, 2, 3]
+    with pytest.raises(ValueError, match="Supplied output array"):
+        random.standard_gamma(shape, out=out, dtype=dtype)
+    with pytest.raises(ValueError, match="Supplied output array"):
+        random.standard_gamma(shape, out=out, size=out.shape, dtype=dtype)
+
+
+@pytest.mark.parametrize("dtype", ["f4", "f8"])
+@pytest.mark.parametrize("order", ["F", "C"])
+@pytest.mark.parametrize("dist", [random.standard_normal, random.random])
+def test_contig_req_out(dist, order, dtype):
+    # GH 18704
+    out = np.empty((2, 3), dtype=dtype, order=order)
+    variates = dist(out=out, dtype=dtype)
+    assert variates is out
+    variates = dist(out=out, dtype=dtype, size=out.shape)
+    assert variates is out
+
+
+def test_generator_ctor_old_style_pickle():
+    rg = np.random.Generator(np.random.PCG64DXSM(0))
+    rg.standard_normal(1)
+    # Directly call reduce which is used in pickling
+    ctor, (bit_gen, ), _ = rg.__reduce__()
+    # Simulate unpickling an old pickle that only has the name
+    assert bit_gen.__class__.__name__ == "PCG64DXSM"
+    print(ctor)
+    b = ctor(*("PCG64DXSM",))
+    print(b)
+    b.bit_generator.state = bit_gen.state
+    state_b = b.bit_generator.state
+    assert bit_gen.state == state_b
+
+
+def test_pickle_preserves_seed_sequence():
+    # GH 26234
+    # Add explicit test that bit generators preserve seed sequences
+    import pickle
+
+    rg = np.random.Generator(np.random.PCG64DXSM(20240411))
+    ss = rg.bit_generator.seed_seq
+    rg_plk = pickle.loads(pickle.dumps(rg))
+    ss_plk = rg_plk.bit_generator.seed_seq
+    assert_equal(ss.state, ss_plk.state)
+    assert_equal(ss.pool, ss_plk.pool)
+
+    rg.bit_generator.seed_seq.spawn(10)
+    rg_plk = pickle.loads(pickle.dumps(rg))
+    ss_plk = rg_plk.bit_generator.seed_seq
+    assert_equal(ss.state, ss_plk.state)
+
+
+@pytest.mark.parametrize("version", [121, 126])
+def test_legacy_pickle(version):
+    # Pickling format was changes in 1.22.x and in 2.0.x
+    import pickle
+    import gzip
+
+    base_path = os.path.split(os.path.abspath(__file__))[0]
+    pkl_file = os.path.join(
+        base_path, "data", f"generator_pcg64_np{version}.pkl.gz"
+    )
+    with gzip.open(pkl_file) as gz:
+        rg = pickle.load(gz)
+    state = rg.bit_generator.state['state']
+
+    assert isinstance(rg, Generator)
+    assert isinstance(rg.bit_generator, np.random.PCG64)
+    assert state['state'] == 35399562948360463058890781895381311971
+    assert state['inc'] == 87136372517582989555478159403783844777
diff --git a/venv/lib/python3.12/site-packages/numpy/random/tests/test_generator_mt19937_regressions.py b/venv/lib/python3.12/site-packages/numpy/random/tests/test_generator_mt19937_regressions.py
new file mode 100644
index 00000000..c34e6bb3
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/random/tests/test_generator_mt19937_regressions.py
@@ -0,0 +1,206 @@
+from numpy.testing import (assert_, assert_array_equal)
+import numpy as np
+import pytest
+from numpy.random import Generator, MT19937
+
+
+class TestRegression:
+
+    def setup_method(self):
+        self.mt19937 = Generator(MT19937(121263137472525314065))
+
+    def test_vonmises_range(self):
+        # Make sure generated random variables are in [-pi, pi].
+        # Regression test for ticket #986.
+        for mu in np.linspace(-7., 7., 5):
+            r = self.mt19937.vonmises(mu, 1, 50)
+            assert_(np.all(r > -np.pi) and np.all(r <= np.pi))
+
+    def test_hypergeometric_range(self):
+        # Test for ticket #921
+        assert_(np.all(self.mt19937.hypergeometric(3, 18, 11, size=10) < 4))
+        assert_(np.all(self.mt19937.hypergeometric(18, 3, 11, size=10) > 0))
+
+        # Test for ticket #5623
+        args = (2**20 - 2, 2**20 - 2, 2**20 - 2)  # Check for 32-bit systems
+        assert_(self.mt19937.hypergeometric(*args) > 0)
+
+    def test_logseries_convergence(self):
+        # Test for ticket #923
+        N = 1000
+        rvsn = self.mt19937.logseries(0.8, size=N)
+        # these two frequency counts should be close to theoretical
+        # numbers with this large sample
+        # theoretical large N result is 0.49706795
+        freq = np.sum(rvsn == 1) / N
+        msg = f'Frequency was {freq:f}, should be > 0.45'
+        assert_(freq > 0.45, msg)
+        # theoretical large N result is 0.19882718
+        freq = np.sum(rvsn == 2) / N
+        msg = f'Frequency was {freq:f}, should be < 0.23'
+        assert_(freq < 0.23, msg)
+
+    def test_shuffle_mixed_dimension(self):
+        # Test for trac ticket #2074
+        for t in [[1, 2, 3, None],
+                  [(1, 1), (2, 2), (3, 3), None],
+                  [1, (2, 2), (3, 3), None],
+                  [(1, 1), 2, 3, None]]:
+            mt19937 = Generator(MT19937(12345))
+            shuffled = np.array(t, dtype=object)
+            mt19937.shuffle(shuffled)
+            expected = np.array([t[2], t[0], t[3], t[1]], dtype=object)
+            assert_array_equal(np.array(shuffled, dtype=object), expected)
+
+    def test_call_within_randomstate(self):
+        # Check that custom BitGenerator does not call into global state
+        res = np.array([1, 8, 0, 1, 5, 3, 3, 8, 1, 4])
+        for i in range(3):
+            mt19937 = Generator(MT19937(i))
+            m = Generator(MT19937(4321))
+            # If m.state is not honored, the result will change
+            assert_array_equal(m.choice(10, size=10, p=np.ones(10)/10.), res)
+
+    def test_multivariate_normal_size_types(self):
+        # Test for multivariate_normal issue with 'size' argument.
+        # Check that the multivariate_normal size argument can be a
+        # numpy integer.
+        self.mt19937.multivariate_normal([0], [[0]], size=1)
+        self.mt19937.multivariate_normal([0], [[0]], size=np.int_(1))
+        self.mt19937.multivariate_normal([0], [[0]], size=np.int64(1))
+
+    def test_beta_small_parameters(self):
+        # Test that beta with small a and b parameters does not produce
+        # NaNs due to roundoff errors causing 0 / 0, gh-5851
+        x = self.mt19937.beta(0.0001, 0.0001, size=100)
+        assert_(not np.any(np.isnan(x)), 'Nans in mt19937.beta')
+
+    def test_beta_very_small_parameters(self):
+        # gh-24203: beta would hang with very small parameters.
+        self.mt19937.beta(1e-49, 1e-40)
+
+    def test_beta_ridiculously_small_parameters(self):
+        # gh-24266: beta would generate nan when the parameters
+        # were subnormal or a small multiple of the smallest normal.
+        tiny = np.finfo(1.0).tiny
+        x = self.mt19937.beta(tiny/32, tiny/40, size=50)
+        assert not np.any(np.isnan(x))
+
+    def test_beta_expected_zero_frequency(self):
+        # gh-24475: For small a and b (e.g. a=0.0025, b=0.0025), beta
+        # would generate too many zeros.
+        a = 0.0025
+        b = 0.0025
+        n = 1000000
+        x = self.mt19937.beta(a, b, size=n)
+        nzeros = np.count_nonzero(x == 0)
+        # beta CDF at x = np.finfo(np.double).smallest_subnormal/2
+        # is p = 0.0776169083131899, e.g,
+        #
+        #    import numpy as np
+        #    from mpmath import mp
+        #    mp.dps = 160
+        #    x = mp.mpf(np.finfo(np.float64).smallest_subnormal)/2
+        #    # CDF of the beta distribution at x:
+        #    p = mp.betainc(a, b, x1=0, x2=x, regularized=True)
+        #    n = 1000000
+        #    exprected_freq = float(n*p)
+        #
+        expected_freq = 77616.90831318991
+        assert 0.95*expected_freq < nzeros < 1.05*expected_freq
+
+    def test_choice_sum_of_probs_tolerance(self):
+        # The sum of probs should be 1.0 with some tolerance.
+        # For low precision dtypes the tolerance was too tight.
+        # See numpy github issue 6123.
+        a = [1, 2, 3]
+        counts = [4, 4, 2]
+        for dt in np.float16, np.float32, np.float64:
+            probs = np.array(counts, dtype=dt) / sum(counts)
+            c = self.mt19937.choice(a, p=probs)
+            assert_(c in a)
+            with pytest.raises(ValueError):
+                self.mt19937.choice(a, p=probs*0.9)
+
+    def test_shuffle_of_array_of_different_length_strings(self):
+        # Test that permuting an array of different length strings
+        # will not cause a segfault on garbage collection
+        # Tests gh-7710
+
+        a = np.array(['a', 'a' * 1000])
+
+        for _ in range(100):
+            self.mt19937.shuffle(a)
+
+        # Force Garbage Collection - should not segfault.
+        import gc
+        gc.collect()
+
+    def test_shuffle_of_array_of_objects(self):
+        # Test that permuting an array of objects will not cause
+        # a segfault on garbage collection.
+        # See gh-7719
+        a = np.array([np.arange(1), np.arange(4)], dtype=object)
+
+        for _ in range(1000):
+            self.mt19937.shuffle(a)
+
+        # Force Garbage Collection - should not segfault.
+        import gc
+        gc.collect()
+
+    def test_permutation_subclass(self):
+
+        class N(np.ndarray):
+            pass
+
+        mt19937 = Generator(MT19937(1))
+        orig = np.arange(3).view(N)
+        perm = mt19937.permutation(orig)
+        assert_array_equal(perm, np.array([2, 0, 1]))
+        assert_array_equal(orig, np.arange(3).view(N))
+
+        class M:
+            a = np.arange(5)
+
+            def __array__(self, dtype=None, copy=None):
+                return self.a
+
+        mt19937 = Generator(MT19937(1))
+        m = M()
+        perm = mt19937.permutation(m)
+        assert_array_equal(perm, np.array([4, 1, 3, 0, 2]))
+        assert_array_equal(m.__array__(), np.arange(5))
+
+    def test_gamma_0(self):
+        assert self.mt19937.standard_gamma(0.0) == 0.0
+        assert_array_equal(self.mt19937.standard_gamma([0.0]), 0.0)
+
+        actual = self.mt19937.standard_gamma([0.0], dtype='float')
+        expected = np.array([0.], dtype=np.float32)
+        assert_array_equal(actual, expected)
+
+    def test_geometric_tiny_prob(self):
+        # Regression test for gh-17007.
+        # When p = 1e-30, the probability that a sample will exceed 2**63-1
+        # is 0.9999999999907766, so we expect the result to be all 2**63-1.
+        assert_array_equal(self.mt19937.geometric(p=1e-30, size=3),
+                           np.iinfo(np.int64).max)
+
+    def test_zipf_large_parameter(self):
+        # Regression test for part of gh-9829: a call such as rng.zipf(10000)
+        # would hang.
+        n = 8
+        sample = self.mt19937.zipf(10000, size=n)
+        assert_array_equal(sample, np.ones(n, dtype=np.int64))
+
+    def test_zipf_a_near_1(self):
+        # Regression test for gh-9829: a call such as rng.zipf(1.0000000000001)
+        # would hang.
+        n = 100000
+        sample = self.mt19937.zipf(1.0000000000001, size=n)
+        # Not much of a test, but let's do something more than verify that
+        # it doesn't hang.  Certainly for a monotonically decreasing
+        # discrete distribution truncated to signed 64 bit integers, more
+        # than half should be less than 2**62.
+        assert np.count_nonzero(sample < 2**62) > n/2
diff --git a/venv/lib/python3.12/site-packages/numpy/random/tests/test_random.py b/venv/lib/python3.12/site-packages/numpy/random/tests/test_random.py
new file mode 100644
index 00000000..c98584ae
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/random/tests/test_random.py
@@ -0,0 +1,1751 @@
+import warnings
+
+import pytest
+
+import numpy as np
+from numpy.testing import (
+        assert_, assert_raises, assert_equal, assert_warns,
+        assert_no_warnings, assert_array_equal, assert_array_almost_equal,
+        suppress_warnings, IS_WASM
+        )
+from numpy import random
+import sys
+
+
+class TestSeed:
+    def test_scalar(self):
+        s = np.random.RandomState(0)
+        assert_equal(s.randint(1000), 684)
+        s = np.random.RandomState(4294967295)
+        assert_equal(s.randint(1000), 419)
+
+    def test_array(self):
+        s = np.random.RandomState(range(10))
+        assert_equal(s.randint(1000), 468)
+        s = np.random.RandomState(np.arange(10))
+        assert_equal(s.randint(1000), 468)
+        s = np.random.RandomState([0])
+        assert_equal(s.randint(1000), 973)
+        s = np.random.RandomState([4294967295])
+        assert_equal(s.randint(1000), 265)
+
+    def test_invalid_scalar(self):
+        # seed must be an unsigned 32 bit integer
+        assert_raises(TypeError, np.random.RandomState, -0.5)
+        assert_raises(ValueError, np.random.RandomState, -1)
+
+    def test_invalid_array(self):
+        # seed must be an unsigned 32 bit integer
+        assert_raises(TypeError, np.random.RandomState, [-0.5])
+        assert_raises(ValueError, np.random.RandomState, [-1])
+        assert_raises(ValueError, np.random.RandomState, [4294967296])
+        assert_raises(ValueError, np.random.RandomState, [1, 2, 4294967296])
+        assert_raises(ValueError, np.random.RandomState, [1, -2, 4294967296])
+
+    def test_invalid_array_shape(self):
+        # gh-9832
+        assert_raises(ValueError, np.random.RandomState,
+                      np.array([], dtype=np.int64))
+        assert_raises(ValueError, np.random.RandomState, [[1, 2, 3]])
+        assert_raises(ValueError, np.random.RandomState, [[1, 2, 3],
+                                                          [4, 5, 6]])
+
+
+class TestBinomial:
+    def test_n_zero(self):
+        # Tests the corner case of n == 0 for the binomial distribution.
+        # binomial(0, p) should be zero for any p in [0, 1].
+        # This test addresses issue #3480.
+        zeros = np.zeros(2, dtype='int')
+        for p in [0, .5, 1]:
+            assert_(random.binomial(0, p) == 0)
+            assert_array_equal(random.binomial(zeros, p), zeros)
+
+    def test_p_is_nan(self):
+        # Issue #4571.
+        assert_raises(ValueError, random.binomial, 1, np.nan)
+
+
+class TestMultinomial:
+    def test_basic(self):
+        random.multinomial(100, [0.2, 0.8])
+
+    def test_zero_probability(self):
+        random.multinomial(100, [0.2, 0.8, 0.0, 0.0, 0.0])
+
+    def test_int_negative_interval(self):
+        assert_(-5 <= random.randint(-5, -1) < -1)
+        x = random.randint(-5, -1, 5)
+        assert_(np.all(-5 <= x))
+        assert_(np.all(x < -1))
+
+    def test_size(self):
+        # gh-3173
+        p = [0.5, 0.5]
+        assert_equal(np.random.multinomial(1, p, np.uint32(1)).shape, (1, 2))
+        assert_equal(np.random.multinomial(1, p, np.uint32(1)).shape, (1, 2))
+        assert_equal(np.random.multinomial(1, p, np.uint32(1)).shape, (1, 2))
+        assert_equal(np.random.multinomial(1, p, [2, 2]).shape, (2, 2, 2))
+        assert_equal(np.random.multinomial(1, p, (2, 2)).shape, (2, 2, 2))
+        assert_equal(np.random.multinomial(1, p, np.array((2, 2))).shape,
+                     (2, 2, 2))
+
+        assert_raises(TypeError, np.random.multinomial, 1, p,
+                      float(1))
+
+    def test_multidimensional_pvals(self):
+        assert_raises(ValueError, np.random.multinomial, 10, [[0, 1]])
+        assert_raises(ValueError, np.random.multinomial, 10, [[0], [1]])
+        assert_raises(ValueError, np.random.multinomial, 10, [[[0], [1]], [[1], [0]]])
+        assert_raises(ValueError, np.random.multinomial, 10, np.array([[0, 1], [1, 0]]))
+
+
+class TestSetState:
+    def setup_method(self):
+        self.seed = 1234567890
+        self.prng = random.RandomState(self.seed)
+        self.state = self.prng.get_state()
+
+    def test_basic(self):
+        old = self.prng.tomaxint(16)
+        self.prng.set_state(self.state)
+        new = self.prng.tomaxint(16)
+        assert_(np.all(old == new))
+
+    def test_gaussian_reset(self):
+        # Make sure the cached every-other-Gaussian is reset.
+        old = self.prng.standard_normal(size=3)
+        self.prng.set_state(self.state)
+        new = self.prng.standard_normal(size=3)
+        assert_(np.all(old == new))
+
+    def test_gaussian_reset_in_media_res(self):
+        # When the state is saved with a cached Gaussian, make sure the
+        # cached Gaussian is restored.
+
+        self.prng.standard_normal()
+        state = self.prng.get_state()
+        old = self.prng.standard_normal(size=3)
+        self.prng.set_state(state)
+        new = self.prng.standard_normal(size=3)
+        assert_(np.all(old == new))
+
+    def test_backwards_compatibility(self):
+        # Make sure we can accept old state tuples that do not have the
+        # cached Gaussian value.
+        old_state = self.state[:-2]
+        x1 = self.prng.standard_normal(size=16)
+        self.prng.set_state(old_state)
+        x2 = self.prng.standard_normal(size=16)
+        self.prng.set_state(self.state)
+        x3 = self.prng.standard_normal(size=16)
+        assert_(np.all(x1 == x2))
+        assert_(np.all(x1 == x3))
+
+    def test_negative_binomial(self):
+        # Ensure that the negative binomial results take floating point
+        # arguments without truncation.
+        self.prng.negative_binomial(0.5, 0.5)
+
+    def test_set_invalid_state(self):
+        # gh-25402
+        with pytest.raises(IndexError):
+            self.prng.set_state(())
+
+
+class TestRandint:
+
+    rfunc = np.random.randint
+
+    # valid integer/boolean types
+    itype = [np.bool, np.int8, np.uint8, np.int16, np.uint16,
+             np.int32, np.uint32, np.int64, np.uint64]
+
+    def test_unsupported_type(self):
+        assert_raises(TypeError, self.rfunc, 1, dtype=float)
+
+    def test_bounds_checking(self):
+        for dt in self.itype:
+            lbnd = 0 if dt is np.bool else np.iinfo(dt).min
+            ubnd = 2 if dt is np.bool else np.iinfo(dt).max + 1
+            assert_raises(ValueError, self.rfunc, lbnd - 1, ubnd, dtype=dt)
+            assert_raises(ValueError, self.rfunc, lbnd, ubnd + 1, dtype=dt)
+            assert_raises(ValueError, self.rfunc, ubnd, lbnd, dtype=dt)
+            assert_raises(ValueError, self.rfunc, 1, 0, dtype=dt)
+
+    def test_rng_zero_and_extremes(self):
+        for dt in self.itype:
+            lbnd = 0 if dt is np.bool else np.iinfo(dt).min
+            ubnd = 2 if dt is np.bool else np.iinfo(dt).max + 1
+
+            tgt = ubnd - 1
+            assert_equal(self.rfunc(tgt, tgt + 1, size=1000, dtype=dt), tgt)
+
+            tgt = lbnd
+            assert_equal(self.rfunc(tgt, tgt + 1, size=1000, dtype=dt), tgt)
+
+            tgt = (lbnd + ubnd)//2
+            assert_equal(self.rfunc(tgt, tgt + 1, size=1000, dtype=dt), tgt)
+
+    def test_full_range(self):
+        # Test for ticket #1690
+
+        for dt in self.itype:
+            lbnd = 0 if dt is np.bool else np.iinfo(dt).min
+            ubnd = 2 if dt is np.bool else np.iinfo(dt).max + 1
+
+            try:
+                self.rfunc(lbnd, ubnd, dtype=dt)
+            except Exception as e:
+                raise AssertionError("No error should have been raised, "
+                                     "but one was with the following "
+                                     "message:\n\n%s" % str(e))
+
+    def test_in_bounds_fuzz(self):
+        # Don't use fixed seed
+        np.random.seed()
+
+        for dt in self.itype[1:]:
+            for ubnd in [4, 8, 16]:
+                vals = self.rfunc(2, ubnd, size=2**16, dtype=dt)
+                assert_(vals.max() < ubnd)
+                assert_(vals.min() >= 2)
+
+        vals = self.rfunc(0, 2, size=2**16, dtype=np.bool)
+
+        assert_(vals.max() < 2)
+        assert_(vals.min() >= 0)
+
+    def test_repeatability(self):
+        import hashlib
+        # We use a sha256 hash of generated sequences of 1000 samples
+        # in the range [0, 6) for all but bool, where the range
+        # is [0, 2). Hashes are for little endian numbers.
+        tgt = {'bool': '509aea74d792fb931784c4b0135392c65aec64beee12b0cc167548a2c3d31e71',
+               'int16': '7b07f1a920e46f6d0fe02314155a2330bcfd7635e708da50e536c5ebb631a7d4',
+               'int32': 'e577bfed6c935de944424667e3da285012e741892dcb7051a8f1ce68ab05c92f',
+               'int64': '0fbead0b06759df2cfb55e43148822d4a1ff953c7eb19a5b08445a63bb64fa9e',
+               'int8': '001aac3a5acb935a9b186cbe14a1ca064b8bb2dd0b045d48abeacf74d0203404',
+               'uint16': '7b07f1a920e46f6d0fe02314155a2330bcfd7635e708da50e536c5ebb631a7d4',
+               'uint32': 'e577bfed6c935de944424667e3da285012e741892dcb7051a8f1ce68ab05c92f',
+               'uint64': '0fbead0b06759df2cfb55e43148822d4a1ff953c7eb19a5b08445a63bb64fa9e',
+               'uint8': '001aac3a5acb935a9b186cbe14a1ca064b8bb2dd0b045d48abeacf74d0203404'}
+
+        for dt in self.itype[1:]:
+            np.random.seed(1234)
+
+            # view as little endian for hash
+            if sys.byteorder == 'little':
+                val = self.rfunc(0, 6, size=1000, dtype=dt)
+            else:
+                val = self.rfunc(0, 6, size=1000, dtype=dt).byteswap()
+
+            res = hashlib.sha256(val.view(np.int8)).hexdigest()
+            assert_(tgt[np.dtype(dt).name] == res)
+
+        # bools do not depend on endianness
+        np.random.seed(1234)
+        val = self.rfunc(0, 2, size=1000, dtype=bool).view(np.int8)
+        res = hashlib.sha256(val).hexdigest()
+        assert_(tgt[np.dtype(bool).name] == res)
+
+    def test_int64_uint64_corner_case(self):
+        # When stored in Numpy arrays, `lbnd` is casted
+        # as np.int64, and `ubnd` is casted as np.uint64.
+        # Checking whether `lbnd` >= `ubnd` used to be
+        # done solely via direct comparison, which is incorrect
+        # because when Numpy tries to compare both numbers,
+        # it casts both to np.float64 because there is
+        # no integer superset of np.int64 and np.uint64. However,
+        # `ubnd` is too large to be represented in np.float64,
+        # causing it be round down to np.iinfo(np.int64).max,
+        # leading to a ValueError because `lbnd` now equals
+        # the new `ubnd`.
+
+        dt = np.int64
+        tgt = np.iinfo(np.int64).max
+        lbnd = np.int64(np.iinfo(np.int64).max)
+        ubnd = np.uint64(np.iinfo(np.int64).max + 1)
+
+        # None of these function calls should
+        # generate a ValueError now.
+        actual = np.random.randint(lbnd, ubnd, dtype=dt)
+        assert_equal(actual, tgt)
+
+    def test_respect_dtype_singleton(self):
+        # See gh-7203
+        for dt in self.itype:
+            lbnd = 0 if dt is np.bool else np.iinfo(dt).min
+            ubnd = 2 if dt is np.bool else np.iinfo(dt).max + 1
+
+            sample = self.rfunc(lbnd, ubnd, dtype=dt)
+            assert_equal(sample.dtype, np.dtype(dt))
+
+        for dt in (bool, int):
+            # The legacy rng uses "long" as the default integer:
+            lbnd = 0 if dt is bool else np.iinfo("long").min
+            ubnd = 2 if dt is bool else np.iinfo("long").max + 1
+
+            # gh-7284: Ensure that we get Python data types
+            sample = self.rfunc(lbnd, ubnd, dtype=dt)
+            assert_(not hasattr(sample, 'dtype'))
+            assert_equal(type(sample), dt)
+
+
+class TestRandomDist:
+    # Make sure the random distribution returns the correct value for a
+    # given seed
+
+    def setup_method(self):
+        self.seed = 1234567890
+
+    def test_rand(self):
+        np.random.seed(self.seed)
+        actual = np.random.rand(3, 2)
+        desired = np.array([[0.61879477158567997, 0.59162362775974664],
+                            [0.88868358904449662, 0.89165480011560816],
+                            [0.4575674820298663, 0.7781880808593471]])
+        assert_array_almost_equal(actual, desired, decimal=15)
+
+    def test_randn(self):
+        np.random.seed(self.seed)
+        actual = np.random.randn(3, 2)
+        desired = np.array([[1.34016345771863121, 1.73759122771936081],
+                           [1.498988344300628, -0.2286433324536169],
+                           [2.031033998682787, 2.17032494605655257]])
+        assert_array_almost_equal(actual, desired, decimal=15)
+
+    def test_randint(self):
+        np.random.seed(self.seed)
+        actual = np.random.randint(-99, 99, size=(3, 2))
+        desired = np.array([[31, 3],
+                            [-52, 41],
+                            [-48, -66]])
+        assert_array_equal(actual, desired)
+
+    def test_random_integers(self):
+        np.random.seed(self.seed)
+        with suppress_warnings() as sup:
+            w = sup.record(DeprecationWarning)
+            actual = np.random.random_integers(-99, 99, size=(3, 2))
+            assert_(len(w) == 1)
+        desired = np.array([[31, 3],
+                            [-52, 41],
+                            [-48, -66]])
+        assert_array_equal(actual, desired)
+
+    def test_random_integers_max_int(self):
+        # Tests whether random_integers can generate the
+        # maximum allowed Python int that can be converted
+        # into a C long. Previous implementations of this
+        # method have thrown an OverflowError when attempting
+        # to generate this integer.
+        with suppress_warnings() as sup:
+            w = sup.record(DeprecationWarning)
+            actual = np.random.random_integers(np.iinfo('l').max,
+                                               np.iinfo('l').max)
+            assert_(len(w) == 1)
+
+        desired = np.iinfo('l').max
+        assert_equal(actual, desired)
+
+    def test_random_integers_deprecated(self):
+        with warnings.catch_warnings():
+            warnings.simplefilter("error", DeprecationWarning)
+
+            # DeprecationWarning raised with high == None
+            assert_raises(DeprecationWarning,
+                          np.random.random_integers,
+                          np.iinfo('l').max)
+
+            # DeprecationWarning raised with high != None
+            assert_raises(DeprecationWarning,
+                          np.random.random_integers,
+                          np.iinfo('l').max, np.iinfo('l').max)
+
+    def test_random(self):
+        np.random.seed(self.seed)
+        actual = np.random.random((3, 2))
+        desired = np.array([[0.61879477158567997, 0.59162362775974664],
+                            [0.88868358904449662, 0.89165480011560816],
+                            [0.4575674820298663, 0.7781880808593471]])
+        assert_array_almost_equal(actual, desired, decimal=15)
+
+    def test_choice_uniform_replace(self):
+        np.random.seed(self.seed)
+        actual = np.random.choice(4, 4)
+        desired = np.array([2, 3, 2, 3])
+        assert_array_equal(actual, desired)
+
+    def test_choice_nonuniform_replace(self):
+        np.random.seed(self.seed)
+        actual = np.random.choice(4, 4, p=[0.4, 0.4, 0.1, 0.1])
+        desired = np.array([1, 1, 2, 2])
+        assert_array_equal(actual, desired)
+
+    def test_choice_uniform_noreplace(self):
+        np.random.seed(self.seed)
+        actual = np.random.choice(4, 3, replace=False)
+        desired = np.array([0, 1, 3])
+        assert_array_equal(actual, desired)
+
+    def test_choice_nonuniform_noreplace(self):
+        np.random.seed(self.seed)
+        actual = np.random.choice(4, 3, replace=False,
+                                  p=[0.1, 0.3, 0.5, 0.1])
+        desired = np.array([2, 3, 1])
+        assert_array_equal(actual, desired)
+
+    def test_choice_noninteger(self):
+        np.random.seed(self.seed)
+        actual = np.random.choice(['a', 'b', 'c', 'd'], 4)
+        desired = np.array(['c', 'd', 'c', 'd'])
+        assert_array_equal(actual, desired)
+
+    def test_choice_exceptions(self):
+        sample = np.random.choice
+        assert_raises(ValueError, sample, -1, 3)
+        assert_raises(ValueError, sample, 3., 3)
+        assert_raises(ValueError, sample, [[1, 2], [3, 4]], 3)
+        assert_raises(ValueError, sample, [], 3)
+        assert_raises(ValueError, sample, [1, 2, 3, 4], 3,
+                      p=[[0.25, 0.25], [0.25, 0.25]])
+        assert_raises(ValueError, sample, [1, 2], 3, p=[0.4, 0.4, 0.2])
+        assert_raises(ValueError, sample, [1, 2], 3, p=[1.1, -0.1])
+        assert_raises(ValueError, sample, [1, 2], 3, p=[0.4, 0.4])
+        assert_raises(ValueError, sample, [1, 2, 3], 4, replace=False)
+        # gh-13087
+        assert_raises(ValueError, sample, [1, 2, 3], -2, replace=False)
+        assert_raises(ValueError, sample, [1, 2, 3], (-1,), replace=False)
+        assert_raises(ValueError, sample, [1, 2, 3], (-1, 1), replace=False)
+        assert_raises(ValueError, sample, [1, 2, 3], 2,
+                      replace=False, p=[1, 0, 0])
+
+    def test_choice_return_shape(self):
+        p = [0.1, 0.9]
+        # Check scalar
+        assert_(np.isscalar(np.random.choice(2, replace=True)))
+        assert_(np.isscalar(np.random.choice(2, replace=False)))
+        assert_(np.isscalar(np.random.choice(2, replace=True, p=p)))
+        assert_(np.isscalar(np.random.choice(2, replace=False, p=p)))
+        assert_(np.isscalar(np.random.choice([1, 2], replace=True)))
+        assert_(np.random.choice([None], replace=True) is None)
+        a = np.array([1, 2])
+        arr = np.empty(1, dtype=object)
+        arr[0] = a
+        assert_(np.random.choice(arr, replace=True) is a)
+
+        # Check 0-d array
+        s = tuple()
+        assert_(not np.isscalar(np.random.choice(2, s, replace=True)))
+        assert_(not np.isscalar(np.random.choice(2, s, replace=False)))
+        assert_(not np.isscalar(np.random.choice(2, s, replace=True, p=p)))
+        assert_(not np.isscalar(np.random.choice(2, s, replace=False, p=p)))
+        assert_(not np.isscalar(np.random.choice([1, 2], s, replace=True)))
+        assert_(np.random.choice([None], s, replace=True).ndim == 0)
+        a = np.array([1, 2])
+        arr = np.empty(1, dtype=object)
+        arr[0] = a
+        assert_(np.random.choice(arr, s, replace=True).item() is a)
+
+        # Check multi dimensional array
+        s = (2, 3)
+        p = [0.1, 0.1, 0.1, 0.1, 0.4, 0.2]
+        assert_equal(np.random.choice(6, s, replace=True).shape, s)
+        assert_equal(np.random.choice(6, s, replace=False).shape, s)
+        assert_equal(np.random.choice(6, s, replace=True, p=p).shape, s)
+        assert_equal(np.random.choice(6, s, replace=False, p=p).shape, s)
+        assert_equal(np.random.choice(np.arange(6), s, replace=True).shape, s)
+
+        # Check zero-size
+        assert_equal(np.random.randint(0, 0, size=(3, 0, 4)).shape, (3, 0, 4))
+        assert_equal(np.random.randint(0, -10, size=0).shape, (0,))
+        assert_equal(np.random.randint(10, 10, size=0).shape, (0,))
+        assert_equal(np.random.choice(0, size=0).shape, (0,))
+        assert_equal(np.random.choice([], size=(0,)).shape, (0,))
+        assert_equal(np.random.choice(['a', 'b'], size=(3, 0, 4)).shape,
+                     (3, 0, 4))
+        assert_raises(ValueError, np.random.choice, [], 10)
+
+    def test_choice_nan_probabilities(self):
+        a = np.array([42, 1, 2])
+        p = [None, None, None]
+        assert_raises(ValueError, np.random.choice, a, p=p)
+
+    def test_bytes(self):
+        np.random.seed(self.seed)
+        actual = np.random.bytes(10)
+        desired = b'\x82Ui\x9e\xff\x97+Wf\xa5'
+        assert_equal(actual, desired)
+
+    def test_shuffle(self):
+        # Test lists, arrays (of various dtypes), and multidimensional versions
+        # of both, c-contiguous or not:
+        for conv in [lambda x: np.array([]),
+                     lambda x: x,
+                     lambda x: np.asarray(x).astype(np.int8),
+                     lambda x: np.asarray(x).astype(np.float32),
+                     lambda x: np.asarray(x).astype(np.complex64),
+                     lambda x: np.asarray(x).astype(object),
+                     lambda x: [(i, i) for i in x],
+                     lambda x: np.asarray([[i, i] for i in x]),
+                     lambda x: np.vstack([x, x]).T,
+                     # gh-11442
+                     lambda x: (np.asarray([(i, i) for i in x],
+                                           [("a", int), ("b", int)])
+                                .view(np.recarray)),
+                     # gh-4270
+                     lambda x: np.asarray([(i, i) for i in x],
+                                          [("a", object), ("b", np.int32)])]:
+            np.random.seed(self.seed)
+            alist = conv([1, 2, 3, 4, 5, 6, 7, 8, 9, 0])
+            np.random.shuffle(alist)
+            actual = alist
+            desired = conv([0, 1, 9, 6, 2, 4, 5, 8, 7, 3])
+            assert_array_equal(actual, desired)
+
+    def test_shuffle_masked(self):
+        # gh-3263
+        a = np.ma.masked_values(np.reshape(range(20), (5, 4)) % 3 - 1, -1)
+        b = np.ma.masked_values(np.arange(20) % 3 - 1, -1)
+        a_orig = a.copy()
+        b_orig = b.copy()
+        for i in range(50):
+            np.random.shuffle(a)
+            assert_equal(
+                sorted(a.data[~a.mask]), sorted(a_orig.data[~a_orig.mask]))
+            np.random.shuffle(b)
+            assert_equal(
+                sorted(b.data[~b.mask]), sorted(b_orig.data[~b_orig.mask]))
+
+    @pytest.mark.parametrize("random",
+            [np.random, np.random.RandomState(), np.random.default_rng()])
+    def test_shuffle_untyped_warning(self, random):
+        # Create a dict works like a sequence but isn't one
+        values = {0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6}
+        with pytest.warns(UserWarning,
+                match="you are shuffling a 'dict' object") as rec:
+            random.shuffle(values)
+        assert "test_random" in rec[0].filename
+
+    @pytest.mark.parametrize("random",
+        [np.random, np.random.RandomState(), np.random.default_rng()])
+    @pytest.mark.parametrize("use_array_like", [True, False])
+    def test_shuffle_no_object_unpacking(self, random, use_array_like):
+        class MyArr(np.ndarray):
+            pass
+
+        items = [
+            None, np.array([3]), np.float64(3), np.array(10), np.float64(7)
+        ]
+        arr = np.array(items, dtype=object)
+        item_ids = {id(i) for i in items}
+        if use_array_like:
+            arr = arr.view(MyArr)
+
+        # The array was created fine, and did not modify any objects:
+        assert all(id(i) in item_ids for i in arr)
+
+        if use_array_like and not isinstance(random, np.random.Generator):
+            # The old API gives incorrect results, but warns about it.
+            with pytest.warns(UserWarning,
+                    match="Shuffling a one dimensional array.*"):
+                random.shuffle(arr)
+        else:
+            random.shuffle(arr)
+            assert all(id(i) in item_ids for i in arr)
+
+    def test_shuffle_memoryview(self):
+        # gh-18273
+        # allow graceful handling of memoryviews
+        # (treat the same as arrays)
+        np.random.seed(self.seed)
+        a = np.arange(5).data
+        np.random.shuffle(a)
+        assert_equal(np.asarray(a), [0, 1, 4, 3, 2])
+        rng = np.random.RandomState(self.seed)
+        rng.shuffle(a)
+        assert_equal(np.asarray(a), [0, 1, 2, 3, 4])
+        rng = np.random.default_rng(self.seed)
+        rng.shuffle(a)
+        assert_equal(np.asarray(a), [4, 1, 0, 3, 2])
+
+    def test_shuffle_not_writeable(self):
+        a = np.zeros(3)
+        a.flags.writeable = False
+        with pytest.raises(ValueError, match='read-only'):
+            np.random.shuffle(a)
+
+    def test_beta(self):
+        np.random.seed(self.seed)
+        actual = np.random.beta(.1, .9, size=(3, 2))
+        desired = np.array(
+                [[1.45341850513746058e-02, 5.31297615662868145e-04],
+                 [1.85366619058432324e-06, 4.19214516800110563e-03],
+                 [1.58405155108498093e-04, 1.26252891949397652e-04]])
+        assert_array_almost_equal(actual, desired, decimal=15)
+
+    def test_binomial(self):
+        np.random.seed(self.seed)
+        actual = np.random.binomial(100, .456, size=(3, 2))
+        desired = np.array([[37, 43],
+                            [42, 48],
+                            [46, 45]])
+        assert_array_equal(actual, desired)
+
+    def test_chisquare(self):
+        np.random.seed(self.seed)
+        actual = np.random.chisquare(50, size=(3, 2))
+        desired = np.array([[63.87858175501090585, 68.68407748911370447],
+                            [65.77116116901505904, 47.09686762438974483],
+                            [72.3828403199695174, 74.18408615260374006]])
+        assert_array_almost_equal(actual, desired, decimal=13)
+
+    def test_dirichlet(self):
+        np.random.seed(self.seed)
+        alpha = np.array([51.72840233779265162, 39.74494232180943953])
+        actual = np.random.mtrand.dirichlet(alpha, size=(3, 2))
+        desired = np.array([[[0.54539444573611562, 0.45460555426388438],
+                             [0.62345816822039413, 0.37654183177960598]],
+                            [[0.55206000085785778, 0.44793999914214233],
+                             [0.58964023305154301, 0.41035976694845688]],
+                            [[0.59266909280647828, 0.40733090719352177],
+                             [0.56974431743975207, 0.43025568256024799]]])
+        assert_array_almost_equal(actual, desired, decimal=15)
+
+    def test_dirichlet_size(self):
+        # gh-3173
+        p = np.array([51.72840233779265162, 39.74494232180943953])
+        assert_equal(np.random.dirichlet(p, np.uint32(1)).shape, (1, 2))
+        assert_equal(np.random.dirichlet(p, np.uint32(1)).shape, (1, 2))
+        assert_equal(np.random.dirichlet(p, np.uint32(1)).shape, (1, 2))
+        assert_equal(np.random.dirichlet(p, [2, 2]).shape, (2, 2, 2))
+        assert_equal(np.random.dirichlet(p, (2, 2)).shape, (2, 2, 2))
+        assert_equal(np.random.dirichlet(p, np.array((2, 2))).shape, (2, 2, 2))
+
+        assert_raises(TypeError, np.random.dirichlet, p, float(1))
+
+    def test_dirichlet_bad_alpha(self):
+        # gh-2089
+        alpha = np.array([5.4e-01, -1.0e-16])
+        assert_raises(ValueError, np.random.mtrand.dirichlet, alpha)
+
+        # gh-15876
+        assert_raises(ValueError, random.dirichlet, [[5, 1]])
+        assert_raises(ValueError, random.dirichlet, [[5], [1]])
+        assert_raises(ValueError, random.dirichlet, [[[5], [1]], [[1], [5]]])
+        assert_raises(ValueError, random.dirichlet, np.array([[5, 1], [1, 5]]))
+
+    def test_exponential(self):
+        np.random.seed(self.seed)
+        actual = np.random.exponential(1.1234, size=(3, 2))
+        desired = np.array([[1.08342649775011624, 1.00607889924557314],
+                            [2.46628830085216721, 2.49668106809923884],
+                            [0.68717433461363442, 1.69175666993575979]])
+        assert_array_almost_equal(actual, desired, decimal=15)
+
+    def test_exponential_0(self):
+        assert_equal(np.random.exponential(scale=0), 0)
+        assert_raises(ValueError, np.random.exponential, scale=-0.)
+
+    def test_f(self):
+        np.random.seed(self.seed)
+        actual = np.random.f(12, 77, size=(3, 2))
+        desired = np.array([[1.21975394418575878, 1.75135759791559775],
+                            [1.44803115017146489, 1.22108959480396262],
+                            [1.02176975757740629, 1.34431827623300415]])
+        assert_array_almost_equal(actual, desired, decimal=15)
+
+    def test_gamma(self):
+        np.random.seed(self.seed)
+        actual = np.random.gamma(5, 3, size=(3, 2))
+        desired = np.array([[24.60509188649287182, 28.54993563207210627],
+                            [26.13476110204064184, 12.56988482927716078],
+                            [31.71863275789960568, 33.30143302795922011]])
+        assert_array_almost_equal(actual, desired, decimal=14)
+
+    def test_gamma_0(self):
+        assert_equal(np.random.gamma(shape=0, scale=0), 0)
+        assert_raises(ValueError, np.random.gamma, shape=-0., scale=-0.)
+
+    def test_geometric(self):
+        np.random.seed(self.seed)
+        actual = np.random.geometric(.123456789, size=(3, 2))
+        desired = np.array([[8, 7],
+                            [17, 17],
+                            [5, 12]])
+        assert_array_equal(actual, desired)
+
+    def test_gumbel(self):
+        np.random.seed(self.seed)
+        actual = np.random.gumbel(loc=.123456789, scale=2.0, size=(3, 2))
+        desired = np.array([[0.19591898743416816, 0.34405539668096674],
+                            [-1.4492522252274278, -1.47374816298446865],
+                            [1.10651090478803416, -0.69535848626236174]])
+        assert_array_almost_equal(actual, desired, decimal=15)
+
+    def test_gumbel_0(self):
+        assert_equal(np.random.gumbel(scale=0), 0)
+        assert_raises(ValueError, np.random.gumbel, scale=-0.)
+
+    def test_hypergeometric(self):
+        np.random.seed(self.seed)
+        actual = np.random.hypergeometric(10, 5, 14, size=(3, 2))
+        desired = np.array([[10, 10],
+                            [10, 10],
+                            [9, 9]])
+        assert_array_equal(actual, desired)
+
+        # Test nbad = 0
+        actual = np.random.hypergeometric(5, 0, 3, size=4)
+        desired = np.array([3, 3, 3, 3])
+        assert_array_equal(actual, desired)
+
+        actual = np.random.hypergeometric(15, 0, 12, size=4)
+        desired = np.array([12, 12, 12, 12])
+        assert_array_equal(actual, desired)
+
+        # Test ngood = 0
+        actual = np.random.hypergeometric(0, 5, 3, size=4)
+        desired = np.array([0, 0, 0, 0])
+        assert_array_equal(actual, desired)
+
+        actual = np.random.hypergeometric(0, 15, 12, size=4)
+        desired = np.array([0, 0, 0, 0])
+        assert_array_equal(actual, desired)
+
+    def test_laplace(self):
+        np.random.seed(self.seed)
+        actual = np.random.laplace(loc=.123456789, scale=2.0, size=(3, 2))
+        desired = np.array([[0.66599721112760157, 0.52829452552221945],
+                            [3.12791959514407125, 3.18202813572992005],
+                            [-0.05391065675859356, 1.74901336242837324]])
+        assert_array_almost_equal(actual, desired, decimal=15)
+
+    def test_laplace_0(self):
+        assert_equal(np.random.laplace(scale=0), 0)
+        assert_raises(ValueError, np.random.laplace, scale=-0.)
+
+    def test_logistic(self):
+        np.random.seed(self.seed)
+        actual = np.random.logistic(loc=.123456789, scale=2.0, size=(3, 2))
+        desired = np.array([[1.09232835305011444, 0.8648196662399954],
+                            [4.27818590694950185, 4.33897006346929714],
+                            [-0.21682183359214885, 2.63373365386060332]])
+        assert_array_almost_equal(actual, desired, decimal=15)
+
+    def test_lognormal(self):
+        np.random.seed(self.seed)
+        actual = np.random.lognormal(mean=.123456789, sigma=2.0, size=(3, 2))
+        desired = np.array([[16.50698631688883822, 36.54846706092654784],
+                            [22.67886599981281748, 0.71617561058995771],
+                            [65.72798501792723869, 86.84341601437161273]])
+        assert_array_almost_equal(actual, desired, decimal=13)
+
+    def test_lognormal_0(self):
+        assert_equal(np.random.lognormal(sigma=0), 1)
+        assert_raises(ValueError, np.random.lognormal, sigma=-0.)
+
+    def test_logseries(self):
+        np.random.seed(self.seed)
+        actual = np.random.logseries(p=.923456789, size=(3, 2))
+        desired = np.array([[2, 2],
+                            [6, 17],
+                            [3, 6]])
+        assert_array_equal(actual, desired)
+
+    def test_multinomial(self):
+        np.random.seed(self.seed)
+        actual = np.random.multinomial(20, [1/6.]*6, size=(3, 2))
+        desired = np.array([[[4, 3, 5, 4, 2, 2],
+                             [5, 2, 8, 2, 2, 1]],
+                            [[3, 4, 3, 6, 0, 4],
+                             [2, 1, 4, 3, 6, 4]],
+                            [[4, 4, 2, 5, 2, 3],
+                             [4, 3, 4, 2, 3, 4]]])
+        assert_array_equal(actual, desired)
+
+    def test_multivariate_normal(self):
+        np.random.seed(self.seed)
+        mean = (.123456789, 10)
+        cov = [[1, 0], [0, 1]]
+        size = (3, 2)
+        actual = np.random.multivariate_normal(mean, cov, size)
+        desired = np.array([[[1.463620246718631, 11.73759122771936],
+                             [1.622445133300628, 9.771356667546383]],
+                            [[2.154490787682787, 12.170324946056553],
+                             [1.719909438201865, 9.230548443648306]],
+                            [[0.689515026297799, 9.880729819607714],
+                             [-0.023054015651998, 9.201096623542879]]])
+
+        assert_array_almost_equal(actual, desired, decimal=15)
+
+        # Check for default size, was raising deprecation warning
+        actual = np.random.multivariate_normal(mean, cov)
+        desired = np.array([0.895289569463708, 9.17180864067987])
+        assert_array_almost_equal(actual, desired, decimal=15)
+
+        # Check that non positive-semidefinite covariance warns with
+        # RuntimeWarning
+        mean = [0, 0]
+        cov = [[1, 2], [2, 1]]
+        assert_warns(RuntimeWarning, np.random.multivariate_normal, mean, cov)
+
+        # and that it doesn't warn with RuntimeWarning check_valid='ignore'
+        assert_no_warnings(np.random.multivariate_normal, mean, cov,
+                           check_valid='ignore')
+
+        # and that it raises with RuntimeWarning check_valid='raises'
+        assert_raises(ValueError, np.random.multivariate_normal, mean, cov,
+                      check_valid='raise')
+
+        cov = np.array([[1, 0.1], [0.1, 1]], dtype=np.float32)
+        with suppress_warnings() as sup:
+            np.random.multivariate_normal(mean, cov)
+            w = sup.record(RuntimeWarning)
+            assert len(w) == 0
+
+    def test_negative_binomial(self):
+        np.random.seed(self.seed)
+        actual = np.random.negative_binomial(n=100, p=.12345, size=(3, 2))
+        desired = np.array([[848, 841],
+                            [892, 611],
+                            [779, 647]])
+        assert_array_equal(actual, desired)
+
+    def test_noncentral_chisquare(self):
+        np.random.seed(self.seed)
+        actual = np.random.noncentral_chisquare(df=5, nonc=5, size=(3, 2))
+        desired = np.array([[23.91905354498517511, 13.35324692733826346],
+                            [31.22452661329736401, 16.60047399466177254],
+                            [5.03461598262724586, 17.94973089023519464]])
+        assert_array_almost_equal(actual, desired, decimal=14)
+
+        actual = np.random.noncentral_chisquare(df=.5, nonc=.2, size=(3, 2))
+        desired = np.array([[1.47145377828516666,  0.15052899268012659],
+                            [0.00943803056963588,  1.02647251615666169],
+                            [0.332334982684171,  0.15451287602753125]])
+        assert_array_almost_equal(actual, desired, decimal=14)
+
+        np.random.seed(self.seed)
+        actual = np.random.noncentral_chisquare(df=5, nonc=0, size=(3, 2))
+        desired = np.array([[9.597154162763948, 11.725484450296079],
+                            [10.413711048138335, 3.694475922923986],
+                            [13.484222138963087, 14.377255424602957]])
+        assert_array_almost_equal(actual, desired, decimal=14)
+
+    def test_noncentral_f(self):
+        np.random.seed(self.seed)
+        actual = np.random.noncentral_f(dfnum=5, dfden=2, nonc=1,
+                                        size=(3, 2))
+        desired = np.array([[1.40598099674926669, 0.34207973179285761],
+                            [3.57715069265772545, 7.92632662577829805],
+                            [0.43741599463544162, 1.1774208752428319]])
+        assert_array_almost_equal(actual, desired, decimal=14)
+
+    def test_normal(self):
+        np.random.seed(self.seed)
+        actual = np.random.normal(loc=.123456789, scale=2.0, size=(3, 2))
+        desired = np.array([[2.80378370443726244, 3.59863924443872163],
+                            [3.121433477601256, -0.33382987590723379],
+                            [4.18552478636557357, 4.46410668111310471]])
+        assert_array_almost_equal(actual, desired, decimal=15)
+
+    def test_normal_0(self):
+        assert_equal(np.random.normal(scale=0), 0)
+        assert_raises(ValueError, np.random.normal, scale=-0.)
+
+    def test_pareto(self):
+        np.random.seed(self.seed)
+        actual = np.random.pareto(a=.123456789, size=(3, 2))
+        desired = np.array(
+                [[2.46852460439034849e+03, 1.41286880810518346e+03],
+                 [5.28287797029485181e+07, 6.57720981047328785e+07],
+                 [1.40840323350391515e+02, 1.98390255135251704e+05]])
+        # For some reason on 32-bit x86 Ubuntu 12.10 the [1, 0] entry in this
+        # matrix differs by 24 nulps. Discussion:
+        #   https://mail.python.org/pipermail/numpy-discussion/2012-September/063801.html
+        # Consensus is that this is probably some gcc quirk that affects
+        # rounding but not in any important way, so we just use a looser
+        # tolerance on this test:
+        np.testing.assert_array_almost_equal_nulp(actual, desired, nulp=30)
+
+    def test_poisson(self):
+        np.random.seed(self.seed)
+        actual = np.random.poisson(lam=.123456789, size=(3, 2))
+        desired = np.array([[0, 0],
+                            [1, 0],
+                            [0, 0]])
+        assert_array_equal(actual, desired)
+
+    def test_poisson_exceptions(self):
+        lambig = np.iinfo('l').max
+        lamneg = -1
+        assert_raises(ValueError, np.random.poisson, lamneg)
+        assert_raises(ValueError, np.random.poisson, [lamneg]*10)
+        assert_raises(ValueError, np.random.poisson, lambig)
+        assert_raises(ValueError, np.random.poisson, [lambig]*10)
+
+    def test_power(self):
+        np.random.seed(self.seed)
+        actual = np.random.power(a=.123456789, size=(3, 2))
+        desired = np.array([[0.02048932883240791, 0.01424192241128213],
+                            [0.38446073748535298, 0.39499689943484395],
+                            [0.00177699707563439, 0.13115505880863756]])
+        assert_array_almost_equal(actual, desired, decimal=15)
+
+    def test_rayleigh(self):
+        np.random.seed(self.seed)
+        actual = np.random.rayleigh(scale=10, size=(3, 2))
+        desired = np.array([[13.8882496494248393, 13.383318339044731],
+                            [20.95413364294492098, 21.08285015800712614],
+                            [11.06066537006854311, 17.35468505778271009]])
+        assert_array_almost_equal(actual, desired, decimal=14)
+
+    def test_rayleigh_0(self):
+        assert_equal(np.random.rayleigh(scale=0), 0)
+        assert_raises(ValueError, np.random.rayleigh, scale=-0.)
+
+    def test_standard_cauchy(self):
+        np.random.seed(self.seed)
+        actual = np.random.standard_cauchy(size=(3, 2))
+        desired = np.array([[0.77127660196445336, -6.55601161955910605],
+                            [0.93582023391158309, -2.07479293013759447],
+                            [-4.74601644297011926, 0.18338989290760804]])
+        assert_array_almost_equal(actual, desired, decimal=15)
+
+    def test_standard_exponential(self):
+        np.random.seed(self.seed)
+        actual = np.random.standard_exponential(size=(3, 2))
+        desired = np.array([[0.96441739162374596, 0.89556604882105506],
+                            [2.1953785836319808, 2.22243285392490542],
+                            [0.6116915921431676, 1.50592546727413201]])
+        assert_array_almost_equal(actual, desired, decimal=15)
+
+    def test_standard_gamma(self):
+        np.random.seed(self.seed)
+        actual = np.random.standard_gamma(shape=3, size=(3, 2))
+        desired = np.array([[5.50841531318455058, 6.62953470301903103],
+                            [5.93988484943779227, 2.31044849402133989],
+                            [7.54838614231317084, 8.012756093271868]])
+        assert_array_almost_equal(actual, desired, decimal=14)
+
+    def test_standard_gamma_0(self):
+        assert_equal(np.random.standard_gamma(shape=0), 0)
+        assert_raises(ValueError, np.random.standard_gamma, shape=-0.)
+
+    def test_standard_normal(self):
+        np.random.seed(self.seed)
+        actual = np.random.standard_normal(size=(3, 2))
+        desired = np.array([[1.34016345771863121, 1.73759122771936081],
+                            [1.498988344300628, -0.2286433324536169],
+                            [2.031033998682787, 2.17032494605655257]])
+        assert_array_almost_equal(actual, desired, decimal=15)
+
+    def test_standard_t(self):
+        np.random.seed(self.seed)
+        actual = np.random.standard_t(df=10, size=(3, 2))
+        desired = np.array([[0.97140611862659965, -0.08830486548450577],
+                            [1.36311143689505321, -0.55317463909867071],
+                            [-0.18473749069684214, 0.61181537341755321]])
+        assert_array_almost_equal(actual, desired, decimal=15)
+
+    def test_triangular(self):
+        np.random.seed(self.seed)
+        actual = np.random.triangular(left=5.12, mode=10.23, right=20.34,
+                                      size=(3, 2))
+        desired = np.array([[12.68117178949215784, 12.4129206149193152],
+                            [16.20131377335158263, 16.25692138747600524],
+                            [11.20400690911820263, 14.4978144835829923]])
+        assert_array_almost_equal(actual, desired, decimal=14)
+
+    def test_uniform(self):
+        np.random.seed(self.seed)
+        actual = np.random.uniform(low=1.23, high=10.54, size=(3, 2))
+        desired = np.array([[6.99097932346268003, 6.73801597444323974],
+                            [9.50364421400426274, 9.53130618907631089],
+                            [5.48995325769805476, 8.47493103280052118]])
+        assert_array_almost_equal(actual, desired, decimal=15)
+
+    def test_uniform_range_bounds(self):
+        fmin = np.finfo('float').min
+        fmax = np.finfo('float').max
+
+        func = np.random.uniform
+        assert_raises(OverflowError, func, -np.inf, 0)
+        assert_raises(OverflowError, func,  0,      np.inf)
+        assert_raises(OverflowError, func,  fmin,   fmax)
+        assert_raises(OverflowError, func, [-np.inf], [0])
+        assert_raises(OverflowError, func, [0], [np.inf])
+
+        # (fmax / 1e17) - fmin is within range, so this should not throw
+        # account for i386 extended precision DBL_MAX / 1e17 + DBL_MAX >
+        # DBL_MAX by increasing fmin a bit
+        np.random.uniform(low=np.nextafter(fmin, 1), high=fmax / 1e17)
+
+    def test_scalar_exception_propagation(self):
+        # Tests that exceptions are correctly propagated in distributions
+        # when called with objects that throw exceptions when converted to
+        # scalars.
+        #
+        # Regression test for gh: 8865
+
+        class ThrowingFloat(np.ndarray):
+            def __float__(self):
+                raise TypeError
+
+        throwing_float = np.array(1.0).view(ThrowingFloat)
+        assert_raises(TypeError, np.random.uniform, throwing_float,
+                      throwing_float)
+
+        class ThrowingInteger(np.ndarray):
+            def __int__(self):
+                raise TypeError
+
+            __index__ = __int__
+
+        throwing_int = np.array(1).view(ThrowingInteger)
+        assert_raises(TypeError, np.random.hypergeometric, throwing_int, 1, 1)
+
+    def test_vonmises(self):
+        np.random.seed(self.seed)
+        actual = np.random.vonmises(mu=1.23, kappa=1.54, size=(3, 2))
+        desired = np.array([[2.28567572673902042, 2.89163838442285037],
+                            [0.38198375564286025, 2.57638023113890746],
+                            [1.19153771588353052, 1.83509849681825354]])
+        assert_array_almost_equal(actual, desired, decimal=15)
+
+    def test_vonmises_small(self):
+        # check infinite loop, gh-4720
+        np.random.seed(self.seed)
+        r = np.random.vonmises(mu=0., kappa=1.1e-8, size=10**6)
+        np.testing.assert_(np.isfinite(r).all())
+
+    def test_wald(self):
+        np.random.seed(self.seed)
+        actual = np.random.wald(mean=1.23, scale=1.54, size=(3, 2))
+        desired = np.array([[3.82935265715889983, 5.13125249184285526],
+                            [0.35045403618358717, 1.50832396872003538],
+                            [0.24124319895843183, 0.22031101461955038]])
+        assert_array_almost_equal(actual, desired, decimal=14)
+
+    def test_weibull(self):
+        np.random.seed(self.seed)
+        actual = np.random.weibull(a=1.23, size=(3, 2))
+        desired = np.array([[0.97097342648766727, 0.91422896443565516],
+                            [1.89517770034962929, 1.91414357960479564],
+                            [0.67057783752390987, 1.39494046635066793]])
+        assert_array_almost_equal(actual, desired, decimal=15)
+
+    def test_weibull_0(self):
+        np.random.seed(self.seed)
+        assert_equal(np.random.weibull(a=0, size=12), np.zeros(12))
+        assert_raises(ValueError, np.random.weibull, a=-0.)
+
+    def test_zipf(self):
+        np.random.seed(self.seed)
+        actual = np.random.zipf(a=1.23, size=(3, 2))
+        desired = np.array([[66, 29],
+                            [1, 1],
+                            [3, 13]])
+        assert_array_equal(actual, desired)
+
+
+class TestBroadcast:
+    # tests that functions that broadcast behave
+    # correctly when presented with non-scalar arguments
+    def setup_method(self):
+        self.seed = 123456789
+
+    def setSeed(self):
+        np.random.seed(self.seed)
+
+    # TODO: Include test for randint once it can broadcast
+    # Can steal the test written in PR #6938
+
+    def test_uniform(self):
+        low = [0]
+        high = [1]
+        uniform = np.random.uniform
+        desired = np.array([0.53283302478975902,
+                            0.53413660089041659,
+                            0.50955303552646702])
+
+        self.setSeed()
+        actual = uniform(low * 3, high)
+        assert_array_almost_equal(actual, desired, decimal=14)
+
+        self.setSeed()
+        actual = uniform(low, high * 3)
+        assert_array_almost_equal(actual, desired, decimal=14)
+
+    def test_normal(self):
+        loc = [0]
+        scale = [1]
+        bad_scale = [-1]
+        normal = np.random.normal
+        desired = np.array([2.2129019979039612,
+                            2.1283977976520019,
+                            1.8417114045748335])
+
+        self.setSeed()
+        actual = normal(loc * 3, scale)
+        assert_array_almost_equal(actual, desired, decimal=14)
+        assert_raises(ValueError, normal, loc * 3, bad_scale)
+
+        self.setSeed()
+        actual = normal(loc, scale * 3)
+        assert_array_almost_equal(actual, desired, decimal=14)
+        assert_raises(ValueError, normal, loc, bad_scale * 3)
+
+    def test_beta(self):
+        a = [1]
+        b = [2]
+        bad_a = [-1]
+        bad_b = [-2]
+        beta = np.random.beta
+        desired = np.array([0.19843558305989056,
+                            0.075230336409423643,
+                            0.24976865978980844])
+
+        self.setSeed()
+        actual = beta(a * 3, b)
+        assert_array_almost_equal(actual, desired, decimal=14)
+        assert_raises(ValueError, beta, bad_a * 3, b)
+        assert_raises(ValueError, beta, a * 3, bad_b)
+
+        self.setSeed()
+        actual = beta(a, b * 3)
+        assert_array_almost_equal(actual, desired, decimal=14)
+        assert_raises(ValueError, beta, bad_a, b * 3)
+        assert_raises(ValueError, beta, a, bad_b * 3)
+
+    def test_exponential(self):
+        scale = [1]
+        bad_scale = [-1]
+        exponential = np.random.exponential
+        desired = np.array([0.76106853658845242,
+                            0.76386282278691653,
+                            0.71243813125891797])
+
+        self.setSeed()
+        actual = exponential(scale * 3)
+        assert_array_almost_equal(actual, desired, decimal=14)
+        assert_raises(ValueError, exponential, bad_scale * 3)
+
+    def test_standard_gamma(self):
+        shape = [1]
+        bad_shape = [-1]
+        std_gamma = np.random.standard_gamma
+        desired = np.array([0.76106853658845242,
+                            0.76386282278691653,
+                            0.71243813125891797])
+
+        self.setSeed()
+        actual = std_gamma(shape * 3)
+        assert_array_almost_equal(actual, desired, decimal=14)
+        assert_raises(ValueError, std_gamma, bad_shape * 3)
+
+    def test_gamma(self):
+        shape = [1]
+        scale = [2]
+        bad_shape = [-1]
+        bad_scale = [-2]
+        gamma = np.random.gamma
+        desired = np.array([1.5221370731769048,
+                            1.5277256455738331,
+                            1.4248762625178359])
+
+        self.setSeed()
+        actual = gamma(shape * 3, scale)
+        assert_array_almost_equal(actual, desired, decimal=14)
+        assert_raises(ValueError, gamma, bad_shape * 3, scale)
+        assert_raises(ValueError, gamma, shape * 3, bad_scale)
+
+        self.setSeed()
+        actual = gamma(shape, scale * 3)
+        assert_array_almost_equal(actual, desired, decimal=14)
+        assert_raises(ValueError, gamma, bad_shape, scale * 3)
+        assert_raises(ValueError, gamma, shape, bad_scale * 3)
+
+    def test_f(self):
+        dfnum = [1]
+        dfden = [2]
+        bad_dfnum = [-1]
+        bad_dfden = [-2]
+        f = np.random.f
+        desired = np.array([0.80038951638264799,
+                            0.86768719635363512,
+                            2.7251095168386801])
+
+        self.setSeed()
+        actual = f(dfnum * 3, dfden)
+        assert_array_almost_equal(actual, desired, decimal=14)
+        assert_raises(ValueError, f, bad_dfnum * 3, dfden)
+        assert_raises(ValueError, f, dfnum * 3, bad_dfden)
+
+        self.setSeed()
+        actual = f(dfnum, dfden * 3)
+        assert_array_almost_equal(actual, desired, decimal=14)
+        assert_raises(ValueError, f, bad_dfnum, dfden * 3)
+        assert_raises(ValueError, f, dfnum, bad_dfden * 3)
+
+    def test_noncentral_f(self):
+        dfnum = [2]
+        dfden = [3]
+        nonc = [4]
+        bad_dfnum = [0]
+        bad_dfden = [-1]
+        bad_nonc = [-2]
+        nonc_f = np.random.noncentral_f
+        desired = np.array([9.1393943263705211,
+                            13.025456344595602,
+                            8.8018098359100545])
+
+        self.setSeed()
+        actual = nonc_f(dfnum * 3, dfden, nonc)
+        assert_array_almost_equal(actual, desired, decimal=14)
+        assert_raises(ValueError, nonc_f, bad_dfnum * 3, dfden, nonc)
+        assert_raises(ValueError, nonc_f, dfnum * 3, bad_dfden, nonc)
+        assert_raises(ValueError, nonc_f, dfnum * 3, dfden, bad_nonc)
+
+        self.setSeed()
+        actual = nonc_f(dfnum, dfden * 3, nonc)
+        assert_array_almost_equal(actual, desired, decimal=14)
+        assert_raises(ValueError, nonc_f, bad_dfnum, dfden * 3, nonc)
+        assert_raises(ValueError, nonc_f, dfnum, bad_dfden * 3, nonc)
+        assert_raises(ValueError, nonc_f, dfnum, dfden * 3, bad_nonc)
+
+        self.setSeed()
+        actual = nonc_f(dfnum, dfden, nonc * 3)
+        assert_array_almost_equal(actual, desired, decimal=14)
+        assert_raises(ValueError, nonc_f, bad_dfnum, dfden, nonc * 3)
+        assert_raises(ValueError, nonc_f, dfnum, bad_dfden, nonc * 3)
+        assert_raises(ValueError, nonc_f, dfnum, dfden, bad_nonc * 3)
+
+    def test_noncentral_f_small_df(self):
+        self.setSeed()
+        desired = np.array([6.869638627492048, 0.785880199263955])
+        actual = np.random.noncentral_f(0.9, 0.9, 2, size=2)
+        assert_array_almost_equal(actual, desired, decimal=14)
+
+    def test_chisquare(self):
+        df = [1]
+        bad_df = [-1]
+        chisquare = np.random.chisquare
+        desired = np.array([0.57022801133088286,
+                            0.51947702108840776,
+                            0.1320969254923558])
+
+        self.setSeed()
+        actual = chisquare(df * 3)
+        assert_array_almost_equal(actual, desired, decimal=14)
+        assert_raises(ValueError, chisquare, bad_df * 3)
+
+    def test_noncentral_chisquare(self):
+        df = [1]
+        nonc = [2]
+        bad_df = [-1]
+        bad_nonc = [-2]
+        nonc_chi = np.random.noncentral_chisquare
+        desired = np.array([9.0015599467913763,
+                            4.5804135049718742,
+                            6.0872302432834564])
+
+        self.setSeed()
+        actual = nonc_chi(df * 3, nonc)
+        assert_array_almost_equal(actual, desired, decimal=14)
+        assert_raises(ValueError, nonc_chi, bad_df * 3, nonc)
+        assert_raises(ValueError, nonc_chi, df * 3, bad_nonc)
+
+        self.setSeed()
+        actual = nonc_chi(df, nonc * 3)
+        assert_array_almost_equal(actual, desired, decimal=14)
+        assert_raises(ValueError, nonc_chi, bad_df, nonc * 3)
+        assert_raises(ValueError, nonc_chi, df, bad_nonc * 3)
+
+    def test_standard_t(self):
+        df = [1]
+        bad_df = [-1]
+        t = np.random.standard_t
+        desired = np.array([3.0702872575217643,
+                            5.8560725167361607,
+                            1.0274791436474273])
+
+        self.setSeed()
+        actual = t(df * 3)
+        assert_array_almost_equal(actual, desired, decimal=14)
+        assert_raises(ValueError, t, bad_df * 3)
+
+    def test_vonmises(self):
+        mu = [2]
+        kappa = [1]
+        bad_kappa = [-1]
+        vonmises = np.random.vonmises
+        desired = np.array([2.9883443664201312,
+                            -2.7064099483995943,
+                            -1.8672476700665914])
+
+        self.setSeed()
+        actual = vonmises(mu * 3, kappa)
+        assert_array_almost_equal(actual, desired, decimal=14)
+        assert_raises(ValueError, vonmises, mu * 3, bad_kappa)
+
+        self.setSeed()
+        actual = vonmises(mu, kappa * 3)
+        assert_array_almost_equal(actual, desired, decimal=14)
+        assert_raises(ValueError, vonmises, mu, bad_kappa * 3)
+
+    def test_pareto(self):
+        a = [1]
+        bad_a = [-1]
+        pareto = np.random.pareto
+        desired = np.array([1.1405622680198362,
+                            1.1465519762044529,
+                            1.0389564467453547])
+
+        self.setSeed()
+        actual = pareto(a * 3)
+        assert_array_almost_equal(actual, desired, decimal=14)
+        assert_raises(ValueError, pareto, bad_a * 3)
+
+    def test_weibull(self):
+        a = [1]
+        bad_a = [-1]
+        weibull = np.random.weibull
+        desired = np.array([0.76106853658845242,
+                            0.76386282278691653,
+                            0.71243813125891797])
+
+        self.setSeed()
+        actual = weibull(a * 3)
+        assert_array_almost_equal(actual, desired, decimal=14)
+        assert_raises(ValueError, weibull, bad_a * 3)
+
+    def test_power(self):
+        a = [1]
+        bad_a = [-1]
+        power = np.random.power
+        desired = np.array([0.53283302478975902,
+                            0.53413660089041659,
+                            0.50955303552646702])
+
+        self.setSeed()
+        actual = power(a * 3)
+        assert_array_almost_equal(actual, desired, decimal=14)
+        assert_raises(ValueError, power, bad_a * 3)
+
+    def test_laplace(self):
+        loc = [0]
+        scale = [1]
+        bad_scale = [-1]
+        laplace = np.random.laplace
+        desired = np.array([0.067921356028507157,
+                            0.070715642226971326,
+                            0.019290950698972624])
+
+        self.setSeed()
+        actual = laplace(loc * 3, scale)
+        assert_array_almost_equal(actual, desired, decimal=14)
+        assert_raises(ValueError, laplace, loc * 3, bad_scale)
+
+        self.setSeed()
+        actual = laplace(loc, scale * 3)
+        assert_array_almost_equal(actual, desired, decimal=14)
+        assert_raises(ValueError, laplace, loc, bad_scale * 3)
+
+    def test_gumbel(self):
+        loc = [0]
+        scale = [1]
+        bad_scale = [-1]
+        gumbel = np.random.gumbel
+        desired = np.array([0.2730318639556768,
+                            0.26936705726291116,
+                            0.33906220393037939])
+
+        self.setSeed()
+        actual = gumbel(loc * 3, scale)
+        assert_array_almost_equal(actual, desired, decimal=14)
+        assert_raises(ValueError, gumbel, loc * 3, bad_scale)
+
+        self.setSeed()
+        actual = gumbel(loc, scale * 3)
+        assert_array_almost_equal(actual, desired, decimal=14)
+        assert_raises(ValueError, gumbel, loc, bad_scale * 3)
+
+    def test_logistic(self):
+        loc = [0]
+        scale = [1]
+        bad_scale = [-1]
+        logistic = np.random.logistic
+        desired = np.array([0.13152135837586171,
+                            0.13675915696285773,
+                            0.038216792802833396])
+
+        self.setSeed()
+        actual = logistic(loc * 3, scale)
+        assert_array_almost_equal(actual, desired, decimal=14)
+        assert_raises(ValueError, logistic, loc * 3, bad_scale)
+
+        self.setSeed()
+        actual = logistic(loc, scale * 3)
+        assert_array_almost_equal(actual, desired, decimal=14)
+        assert_raises(ValueError, logistic, loc, bad_scale * 3)
+
+    def test_lognormal(self):
+        mean = [0]
+        sigma = [1]
+        bad_sigma = [-1]
+        lognormal = np.random.lognormal
+        desired = np.array([9.1422086044848427,
+                            8.4013952870126261,
+                            6.3073234116578671])
+
+        self.setSeed()
+        actual = lognormal(mean * 3, sigma)
+        assert_array_almost_equal(actual, desired, decimal=14)
+        assert_raises(ValueError, lognormal, mean * 3, bad_sigma)
+
+        self.setSeed()
+        actual = lognormal(mean, sigma * 3)
+        assert_array_almost_equal(actual, desired, decimal=14)
+        assert_raises(ValueError, lognormal, mean, bad_sigma * 3)
+
+    def test_rayleigh(self):
+        scale = [1]
+        bad_scale = [-1]
+        rayleigh = np.random.rayleigh
+        desired = np.array([1.2337491937897689,
+                            1.2360119924878694,
+                            1.1936818095781789])
+
+        self.setSeed()
+        actual = rayleigh(scale * 3)
+        assert_array_almost_equal(actual, desired, decimal=14)
+        assert_raises(ValueError, rayleigh, bad_scale * 3)
+
+    def test_wald(self):
+        mean = [0.5]
+        scale = [1]
+        bad_mean = [0]
+        bad_scale = [-2]
+        wald = np.random.wald
+        desired = np.array([0.11873681120271318,
+                            0.12450084820795027,
+                            0.9096122728408238])
+
+        self.setSeed()
+        actual = wald(mean * 3, scale)
+        assert_array_almost_equal(actual, desired, decimal=14)
+        assert_raises(ValueError, wald, bad_mean * 3, scale)
+        assert_raises(ValueError, wald, mean * 3, bad_scale)
+
+        self.setSeed()
+        actual = wald(mean, scale * 3)
+        assert_array_almost_equal(actual, desired, decimal=14)
+        assert_raises(ValueError, wald, bad_mean, scale * 3)
+        assert_raises(ValueError, wald, mean, bad_scale * 3)
+        assert_raises(ValueError, wald, 0.0, 1)
+        assert_raises(ValueError, wald, 0.5, 0.0)
+
+    def test_triangular(self):
+        left = [1]
+        right = [3]
+        mode = [2]
+        bad_left_one = [3]
+        bad_mode_one = [4]
+        bad_left_two, bad_mode_two = right * 2
+        triangular = np.random.triangular
+        desired = np.array([2.03339048710429,
+                            2.0347400359389356,
+                            2.0095991069536208])
+
+        self.setSeed()
+        actual = triangular(left * 3, mode, right)
+        assert_array_almost_equal(actual, desired, decimal=14)
+        assert_raises(ValueError, triangular, bad_left_one * 3, mode, right)
+        assert_raises(ValueError, triangular, left * 3, bad_mode_one, right)
+        assert_raises(ValueError, triangular, bad_left_two * 3, bad_mode_two,
+                      right)
+
+        self.setSeed()
+        actual = triangular(left, mode * 3, right)
+        assert_array_almost_equal(actual, desired, decimal=14)
+        assert_raises(ValueError, triangular, bad_left_one, mode * 3, right)
+        assert_raises(ValueError, triangular, left, bad_mode_one * 3, right)
+        assert_raises(ValueError, triangular, bad_left_two, bad_mode_two * 3,
+                      right)
+
+        self.setSeed()
+        actual = triangular(left, mode, right * 3)
+        assert_array_almost_equal(actual, desired, decimal=14)
+        assert_raises(ValueError, triangular, bad_left_one, mode, right * 3)
+        assert_raises(ValueError, triangular, left, bad_mode_one, right * 3)
+        assert_raises(ValueError, triangular, bad_left_two, bad_mode_two,
+                      right * 3)
+
+    def test_binomial(self):
+        n = [1]
+        p = [0.5]
+        bad_n = [-1]
+        bad_p_one = [-1]
+        bad_p_two = [1.5]
+        binom = np.random.binomial
+        desired = np.array([1, 1, 1])
+
+        self.setSeed()
+        actual = binom(n * 3, p)
+        assert_array_equal(actual, desired)
+        assert_raises(ValueError, binom, bad_n * 3, p)
+        assert_raises(ValueError, binom, n * 3, bad_p_one)
+        assert_raises(ValueError, binom, n * 3, bad_p_two)
+
+        self.setSeed()
+        actual = binom(n, p * 3)
+        assert_array_equal(actual, desired)
+        assert_raises(ValueError, binom, bad_n, p * 3)
+        assert_raises(ValueError, binom, n, bad_p_one * 3)
+        assert_raises(ValueError, binom, n, bad_p_two * 3)
+
+    def test_negative_binomial(self):
+        n = [1]
+        p = [0.5]
+        bad_n = [-1]
+        bad_p_one = [-1]
+        bad_p_two = [1.5]
+        neg_binom = np.random.negative_binomial
+        desired = np.array([1, 0, 1])
+
+        self.setSeed()
+        actual = neg_binom(n * 3, p)
+        assert_array_equal(actual, desired)
+        assert_raises(ValueError, neg_binom, bad_n * 3, p)
+        assert_raises(ValueError, neg_binom, n * 3, bad_p_one)
+        assert_raises(ValueError, neg_binom, n * 3, bad_p_two)
+
+        self.setSeed()
+        actual = neg_binom(n, p * 3)
+        assert_array_equal(actual, desired)
+        assert_raises(ValueError, neg_binom, bad_n, p * 3)
+        assert_raises(ValueError, neg_binom, n, bad_p_one * 3)
+        assert_raises(ValueError, neg_binom, n, bad_p_two * 3)
+
+    def test_poisson(self):
+        max_lam = np.random.RandomState()._poisson_lam_max
+
+        lam = [1]
+        bad_lam_one = [-1]
+        bad_lam_two = [max_lam * 2]
+        poisson = np.random.poisson
+        desired = np.array([1, 1, 0])
+
+        self.setSeed()
+        actual = poisson(lam * 3)
+        assert_array_equal(actual, desired)
+        assert_raises(ValueError, poisson, bad_lam_one * 3)
+        assert_raises(ValueError, poisson, bad_lam_two * 3)
+
+    def test_zipf(self):
+        a = [2]
+        bad_a = [0]
+        zipf = np.random.zipf
+        desired = np.array([2, 2, 1])
+
+        self.setSeed()
+        actual = zipf(a * 3)
+        assert_array_equal(actual, desired)
+        assert_raises(ValueError, zipf, bad_a * 3)
+        with np.errstate(invalid='ignore'):
+            assert_raises(ValueError, zipf, np.nan)
+            assert_raises(ValueError, zipf, [0, 0, np.nan])
+
+    def test_geometric(self):
+        p = [0.5]
+        bad_p_one = [-1]
+        bad_p_two = [1.5]
+        geom = np.random.geometric
+        desired = np.array([2, 2, 2])
+
+        self.setSeed()
+        actual = geom(p * 3)
+        assert_array_equal(actual, desired)
+        assert_raises(ValueError, geom, bad_p_one * 3)
+        assert_raises(ValueError, geom, bad_p_two * 3)
+
+    def test_hypergeometric(self):
+        ngood = [1]
+        nbad = [2]
+        nsample = [2]
+        bad_ngood = [-1]
+        bad_nbad = [-2]
+        bad_nsample_one = [0]
+        bad_nsample_two = [4]
+        hypergeom = np.random.hypergeometric
+        desired = np.array([1, 1, 1])
+
+        self.setSeed()
+        actual = hypergeom(ngood * 3, nbad, nsample)
+        assert_array_equal(actual, desired)
+        assert_raises(ValueError, hypergeom, bad_ngood * 3, nbad, nsample)
+        assert_raises(ValueError, hypergeom, ngood * 3, bad_nbad, nsample)
+        assert_raises(ValueError, hypergeom, ngood * 3, nbad, bad_nsample_one)
+        assert_raises(ValueError, hypergeom, ngood * 3, nbad, bad_nsample_two)
+
+        self.setSeed()
+        actual = hypergeom(ngood, nbad * 3, nsample)
+        assert_array_equal(actual, desired)
+        assert_raises(ValueError, hypergeom, bad_ngood, nbad * 3, nsample)
+        assert_raises(ValueError, hypergeom, ngood, bad_nbad * 3, nsample)
+        assert_raises(ValueError, hypergeom, ngood, nbad * 3, bad_nsample_one)
+        assert_raises(ValueError, hypergeom, ngood, nbad * 3, bad_nsample_two)
+
+        self.setSeed()
+        actual = hypergeom(ngood, nbad, nsample * 3)
+        assert_array_equal(actual, desired)
+        assert_raises(ValueError, hypergeom, bad_ngood, nbad, nsample * 3)
+        assert_raises(ValueError, hypergeom, ngood, bad_nbad, nsample * 3)
+        assert_raises(ValueError, hypergeom, ngood, nbad, bad_nsample_one * 3)
+        assert_raises(ValueError, hypergeom, ngood, nbad, bad_nsample_two * 3)
+
+    def test_logseries(self):
+        p = [0.5]
+        bad_p_one = [2]
+        bad_p_two = [-1]
+        logseries = np.random.logseries
+        desired = np.array([1, 1, 1])
+
+        self.setSeed()
+        actual = logseries(p * 3)
+        assert_array_equal(actual, desired)
+        assert_raises(ValueError, logseries, bad_p_one * 3)
+        assert_raises(ValueError, logseries, bad_p_two * 3)
+
+
+@pytest.mark.skipif(IS_WASM, reason="can't start thread")
+class TestThread:
+    # make sure each state produces the same sequence even in threads
+    def setup_method(self):
+        self.seeds = range(4)
+
+    def check_function(self, function, sz):
+        from threading import Thread
+
+        out1 = np.empty((len(self.seeds),) + sz)
+        out2 = np.empty((len(self.seeds),) + sz)
+
+        # threaded generation
+        t = [Thread(target=function, args=(np.random.RandomState(s), o))
+             for s, o in zip(self.seeds, out1)]
+        [x.start() for x in t]
+        [x.join() for x in t]
+
+        # the same serial
+        for s, o in zip(self.seeds, out2):
+            function(np.random.RandomState(s), o)
+
+        # these platforms change x87 fpu precision mode in threads
+        if np.intp().dtype.itemsize == 4 and sys.platform == "win32":
+            assert_array_almost_equal(out1, out2)
+        else:
+            assert_array_equal(out1, out2)
+
+    def test_normal(self):
+        def gen_random(state, out):
+            out[...] = state.normal(size=10000)
+        self.check_function(gen_random, sz=(10000,))
+
+    def test_exp(self):
+        def gen_random(state, out):
+            out[...] = state.exponential(scale=np.ones((100, 1000)))
+        self.check_function(gen_random, sz=(100, 1000))
+
+    def test_multinomial(self):
+        def gen_random(state, out):
+            out[...] = state.multinomial(10, [1/6.]*6, size=10000)
+        self.check_function(gen_random, sz=(10000, 6))
+
+
+# See Issue #4263
+class TestSingleEltArrayInput:
+    def setup_method(self):
+        self.argOne = np.array([2])
+        self.argTwo = np.array([3])
+        self.argThree = np.array([4])
+        self.tgtShape = (1,)
+
+    def test_one_arg_funcs(self):
+        funcs = (np.random.exponential, np.random.standard_gamma,
+                 np.random.chisquare, np.random.standard_t,
+                 np.random.pareto, np.random.weibull,
+                 np.random.power, np.random.rayleigh,
+                 np.random.poisson, np.random.zipf,
+                 np.random.geometric, np.random.logseries)
+
+        probfuncs = (np.random.geometric, np.random.logseries)
+
+        for func in funcs:
+            if func in probfuncs:  # p < 1.0
+                out = func(np.array([0.5]))
+
+            else:
+                out = func(self.argOne)
+
+            assert_equal(out.shape, self.tgtShape)
+
+    def test_two_arg_funcs(self):
+        funcs = (np.random.uniform, np.random.normal,
+                 np.random.beta, np.random.gamma,
+                 np.random.f, np.random.noncentral_chisquare,
+                 np.random.vonmises, np.random.laplace,
+                 np.random.gumbel, np.random.logistic,
+                 np.random.lognormal, np.random.wald,
+                 np.random.binomial, np.random.negative_binomial)
+
+        probfuncs = (np.random.binomial, np.random.negative_binomial)
+
+        for func in funcs:
+            if func in probfuncs:  # p <= 1
+                argTwo = np.array([0.5])
+
+            else:
+                argTwo = self.argTwo
+
+            out = func(self.argOne, argTwo)
+            assert_equal(out.shape, self.tgtShape)
+
+            out = func(self.argOne[0], argTwo)
+            assert_equal(out.shape, self.tgtShape)
+
+            out = func(self.argOne, argTwo[0])
+            assert_equal(out.shape, self.tgtShape)
+
+    def test_randint(self):
+        itype = [bool, np.int8, np.uint8, np.int16, np.uint16,
+                 np.int32, np.uint32, np.int64, np.uint64]
+        func = np.random.randint
+        high = np.array([1])
+        low = np.array([0])
+
+        for dt in itype:
+            out = func(low, high, dtype=dt)
+            assert_equal(out.shape, self.tgtShape)
+
+            out = func(low[0], high, dtype=dt)
+            assert_equal(out.shape, self.tgtShape)
+
+            out = func(low, high[0], dtype=dt)
+            assert_equal(out.shape, self.tgtShape)
+
+    def test_three_arg_funcs(self):
+        funcs = [np.random.noncentral_f, np.random.triangular,
+                 np.random.hypergeometric]
+
+        for func in funcs:
+            out = func(self.argOne, self.argTwo, self.argThree)
+            assert_equal(out.shape, self.tgtShape)
+
+            out = func(self.argOne[0], self.argTwo, self.argThree)
+            assert_equal(out.shape, self.tgtShape)
+
+            out = func(self.argOne, self.argTwo[0], self.argThree)
+            assert_equal(out.shape, self.tgtShape)
diff --git a/venv/lib/python3.12/site-packages/numpy/random/tests/test_randomstate.py b/venv/lib/python3.12/site-packages/numpy/random/tests/test_randomstate.py
new file mode 100644
index 00000000..5121a684
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/random/tests/test_randomstate.py
@@ -0,0 +1,2124 @@
+import hashlib
+import pickle
+import sys
+import warnings
+
+import numpy as np
+import pytest
+from numpy.testing import (
+        assert_, assert_raises, assert_equal, assert_warns,
+        assert_no_warnings, assert_array_equal, assert_array_almost_equal,
+        suppress_warnings, IS_WASM
+        )
+
+from numpy.random import MT19937, PCG64
+from numpy import random
+
+INT_FUNCS = {'binomial': (100.0, 0.6),
+             'geometric': (.5,),
+             'hypergeometric': (20, 20, 10),
+             'logseries': (.5,),
+             'multinomial': (20, np.ones(6) / 6.0),
+             'negative_binomial': (100, .5),
+             'poisson': (10.0,),
+             'zipf': (2,),
+             }
+
+if np.iinfo(np.long).max < 2**32:
+    # Windows and some 32-bit platforms, e.g., ARM
+    INT_FUNC_HASHES = {'binomial': '2fbead005fc63942decb5326d36a1f32fe2c9d32c904ee61e46866b88447c263',
+                       'logseries': '23ead5dcde35d4cfd4ef2c105e4c3d43304b45dc1b1444b7823b9ee4fa144ebb',
+                       'geometric': '0d764db64f5c3bad48c8c33551c13b4d07a1e7b470f77629bef6c985cac76fcf',
+                       'hypergeometric': '7b59bf2f1691626c5815cdcd9a49e1dd68697251d4521575219e4d2a1b8b2c67',
+                       'multinomial': 'd754fa5b92943a38ec07630de92362dd2e02c43577fc147417dc5b9db94ccdd3',
+                       'negative_binomial': '8eb216f7cb2a63cf55605422845caaff002fddc64a7dc8b2d45acd477a49e824',
+                       'poisson': '70c891d76104013ebd6f6bcf30d403a9074b886ff62e4e6b8eb605bf1a4673b7',
+                       'zipf': '01f074f97517cd5d21747148ac6ca4074dde7fcb7acbaec0a936606fecacd93f',
+                       }
+else:
+    INT_FUNC_HASHES = {'binomial': '8626dd9d052cb608e93d8868de0a7b347258b199493871a1dc56e2a26cacb112',
+                       'geometric': '8edd53d272e49c4fc8fbbe6c7d08d563d62e482921f3131d0a0e068af30f0db9',
+                       'hypergeometric': '83496cc4281c77b786c9b7ad88b74d42e01603a55c60577ebab81c3ba8d45657',
+                       'logseries': '65878a38747c176bc00e930ebafebb69d4e1e16cd3a704e264ea8f5e24f548db',
+                       'multinomial': '7a984ae6dca26fd25374479e118b22f55db0aedccd5a0f2584ceada33db98605',
+                       'negative_binomial': 'd636d968e6a24ae92ab52fe11c46ac45b0897e98714426764e820a7d77602a61',
+                       'poisson': '956552176f77e7c9cb20d0118fc9cf690be488d790ed4b4c4747b965e61b0bb4',
+                       'zipf': 'f84ba7feffda41e606e20b28dfc0f1ea9964a74574513d4a4cbc98433a8bfa45',
+                       }
+
+
+@pytest.fixture(scope='module', params=INT_FUNCS)
+def int_func(request):
+    return (request.param, INT_FUNCS[request.param],
+            INT_FUNC_HASHES[request.param])
+
+
+@pytest.fixture
+def restore_singleton_bitgen():
+    """Ensures that the singleton bitgen is restored after a test"""
+    orig_bitgen = np.random.get_bit_generator()
+    yield
+    np.random.set_bit_generator(orig_bitgen)
+
+
+def assert_mt19937_state_equal(a, b):
+    assert_equal(a['bit_generator'], b['bit_generator'])
+    assert_array_equal(a['state']['key'], b['state']['key'])
+    assert_array_equal(a['state']['pos'], b['state']['pos'])
+    assert_equal(a['has_gauss'], b['has_gauss'])
+    assert_equal(a['gauss'], b['gauss'])
+
+
+class TestSeed:
+    def test_scalar(self):
+        s = random.RandomState(0)
+        assert_equal(s.randint(1000), 684)
+        s = random.RandomState(4294967295)
+        assert_equal(s.randint(1000), 419)
+
+    def test_array(self):
+        s = random.RandomState(range(10))
+        assert_equal(s.randint(1000), 468)
+        s = random.RandomState(np.arange(10))
+        assert_equal(s.randint(1000), 468)
+        s = random.RandomState([0])
+        assert_equal(s.randint(1000), 973)
+        s = random.RandomState([4294967295])
+        assert_equal(s.randint(1000), 265)
+
+    def test_invalid_scalar(self):
+        # seed must be an unsigned 32 bit integer
+        assert_raises(TypeError, random.RandomState, -0.5)
+        assert_raises(ValueError, random.RandomState, -1)
+
+    def test_invalid_array(self):
+        # seed must be an unsigned 32 bit integer
+        assert_raises(TypeError, random.RandomState, [-0.5])
+        assert_raises(ValueError, random.RandomState, [-1])
+        assert_raises(ValueError, random.RandomState, [4294967296])
+        assert_raises(ValueError, random.RandomState, [1, 2, 4294967296])
+        assert_raises(ValueError, random.RandomState, [1, -2, 4294967296])
+
+    def test_invalid_array_shape(self):
+        # gh-9832
+        assert_raises(ValueError, random.RandomState, np.array([],
+                                                               dtype=np.int64))
+        assert_raises(ValueError, random.RandomState, [[1, 2, 3]])
+        assert_raises(ValueError, random.RandomState, [[1, 2, 3],
+                                                       [4, 5, 6]])
+
+    def test_cannot_seed(self):
+        rs = random.RandomState(PCG64(0))
+        with assert_raises(TypeError):
+            rs.seed(1234)
+
+    def test_invalid_initialization(self):
+        assert_raises(ValueError, random.RandomState, MT19937)
+
+
+class TestBinomial:
+    def test_n_zero(self):
+        # Tests the corner case of n == 0 for the binomial distribution.
+        # binomial(0, p) should be zero for any p in [0, 1].
+        # This test addresses issue #3480.
+        zeros = np.zeros(2, dtype='int')
+        for p in [0, .5, 1]:
+            assert_(random.binomial(0, p) == 0)
+            assert_array_equal(random.binomial(zeros, p), zeros)
+
+    def test_p_is_nan(self):
+        # Issue #4571.
+        assert_raises(ValueError, random.binomial, 1, np.nan)
+
+
+class TestMultinomial:
+    def test_basic(self):
+        random.multinomial(100, [0.2, 0.8])
+
+    def test_zero_probability(self):
+        random.multinomial(100, [0.2, 0.8, 0.0, 0.0, 0.0])
+
+    def test_int_negative_interval(self):
+        assert_(-5 <= random.randint(-5, -1) < -1)
+        x = random.randint(-5, -1, 5)
+        assert_(np.all(-5 <= x))
+        assert_(np.all(x < -1))
+
+    def test_size(self):
+        # gh-3173
+        p = [0.5, 0.5]
+        assert_equal(random.multinomial(1, p, np.uint32(1)).shape, (1, 2))
+        assert_equal(random.multinomial(1, p, np.uint32(1)).shape, (1, 2))
+        assert_equal(random.multinomial(1, p, np.uint32(1)).shape, (1, 2))
+        assert_equal(random.multinomial(1, p, [2, 2]).shape, (2, 2, 2))
+        assert_equal(random.multinomial(1, p, (2, 2)).shape, (2, 2, 2))
+        assert_equal(random.multinomial(1, p, np.array((2, 2))).shape,
+                     (2, 2, 2))
+
+        assert_raises(TypeError, random.multinomial, 1, p,
+                      float(1))
+
+    def test_invalid_prob(self):
+        assert_raises(ValueError, random.multinomial, 100, [1.1, 0.2])
+        assert_raises(ValueError, random.multinomial, 100, [-.1, 0.9])
+
+    def test_invalid_n(self):
+        assert_raises(ValueError, random.multinomial, -1, [0.8, 0.2])
+
+    def test_p_non_contiguous(self):
+        p = np.arange(15.)
+        p /= np.sum(p[1::3])
+        pvals = p[1::3]
+        random.seed(1432985819)
+        non_contig = random.multinomial(100, pvals=pvals)
+        random.seed(1432985819)
+        contig = random.multinomial(100, pvals=np.ascontiguousarray(pvals))
+        assert_array_equal(non_contig, contig)
+
+    def test_multinomial_pvals_float32(self):
+        x = np.array([9.9e-01, 9.9e-01, 1.0e-09, 1.0e-09, 1.0e-09, 1.0e-09,
+                      1.0e-09, 1.0e-09, 1.0e-09, 1.0e-09], dtype=np.float32)
+        pvals = x / x.sum()
+        match = r"[\w\s]*pvals array is cast to 64-bit floating"
+        with pytest.raises(ValueError, match=match):
+            random.multinomial(1, pvals)
+
+    def test_multinomial_n_float(self):
+        # Non-index integer types should gracefully truncate floats
+        random.multinomial(100.5, [0.2, 0.8])
+
+class TestSetState:
+    def setup_method(self):
+        self.seed = 1234567890
+        self.random_state = random.RandomState(self.seed)
+        self.state = self.random_state.get_state()
+
+    def test_basic(self):
+        old = self.random_state.tomaxint(16)
+        self.random_state.set_state(self.state)
+        new = self.random_state.tomaxint(16)
+        assert_(np.all(old == new))
+
+    def test_gaussian_reset(self):
+        # Make sure the cached every-other-Gaussian is reset.
+        old = self.random_state.standard_normal(size=3)
+        self.random_state.set_state(self.state)
+        new = self.random_state.standard_normal(size=3)
+        assert_(np.all(old == new))
+
+    def test_gaussian_reset_in_media_res(self):
+        # When the state is saved with a cached Gaussian, make sure the
+        # cached Gaussian is restored.
+
+        self.random_state.standard_normal()
+        state = self.random_state.get_state()
+        old = self.random_state.standard_normal(size=3)
+        self.random_state.set_state(state)
+        new = self.random_state.standard_normal(size=3)
+        assert_(np.all(old == new))
+
+    def test_backwards_compatibility(self):
+        # Make sure we can accept old state tuples that do not have the
+        # cached Gaussian value.
+        old_state = self.state[:-2]
+        x1 = self.random_state.standard_normal(size=16)
+        self.random_state.set_state(old_state)
+        x2 = self.random_state.standard_normal(size=16)
+        self.random_state.set_state(self.state)
+        x3 = self.random_state.standard_normal(size=16)
+        assert_(np.all(x1 == x2))
+        assert_(np.all(x1 == x3))
+
+    def test_negative_binomial(self):
+        # Ensure that the negative binomial results take floating point
+        # arguments without truncation.
+        self.random_state.negative_binomial(0.5, 0.5)
+
+    def test_get_state_warning(self):
+        rs = random.RandomState(PCG64())
+        with suppress_warnings() as sup:
+            w = sup.record(RuntimeWarning)
+            state = rs.get_state()
+            assert_(len(w) == 1)
+            assert isinstance(state, dict)
+            assert state['bit_generator'] == 'PCG64'
+
+    def test_invalid_legacy_state_setting(self):
+        state = self.random_state.get_state()
+        new_state = ('Unknown', ) + state[1:]
+        assert_raises(ValueError, self.random_state.set_state, new_state)
+        assert_raises(TypeError, self.random_state.set_state,
+                      np.array(new_state, dtype=object))
+        state = self.random_state.get_state(legacy=False)
+        del state['bit_generator']
+        assert_raises(ValueError, self.random_state.set_state, state)
+
+    def test_pickle(self):
+        self.random_state.seed(0)
+        self.random_state.random_sample(100)
+        self.random_state.standard_normal()
+        pickled = self.random_state.get_state(legacy=False)
+        assert_equal(pickled['has_gauss'], 1)
+        rs_unpick = pickle.loads(pickle.dumps(self.random_state))
+        unpickled = rs_unpick.get_state(legacy=False)
+        assert_mt19937_state_equal(pickled, unpickled)
+
+    def test_state_setting(self):
+        attr_state = self.random_state.__getstate__()
+        self.random_state.standard_normal()
+        self.random_state.__setstate__(attr_state)
+        state = self.random_state.get_state(legacy=False)
+        assert_mt19937_state_equal(attr_state, state)
+
+    def test_repr(self):
+        assert repr(self.random_state).startswith('RandomState(MT19937)')
+
+
+class TestRandint:
+
+    rfunc = random.randint
+
+    # valid integer/boolean types
+    itype = [np.bool, np.int8, np.uint8, np.int16, np.uint16,
+             np.int32, np.uint32, np.int64, np.uint64]
+
+    def test_unsupported_type(self):
+        assert_raises(TypeError, self.rfunc, 1, dtype=float)
+
+    def test_bounds_checking(self):
+        for dt in self.itype:
+            lbnd = 0 if dt is np.bool else np.iinfo(dt).min
+            ubnd = 2 if dt is np.bool else np.iinfo(dt).max + 1
+            assert_raises(ValueError, self.rfunc, lbnd - 1, ubnd, dtype=dt)
+            assert_raises(ValueError, self.rfunc, lbnd, ubnd + 1, dtype=dt)
+            assert_raises(ValueError, self.rfunc, ubnd, lbnd, dtype=dt)
+            assert_raises(ValueError, self.rfunc, 1, 0, dtype=dt)
+
+    def test_rng_zero_and_extremes(self):
+        for dt in self.itype:
+            lbnd = 0 if dt is np.bool else np.iinfo(dt).min
+            ubnd = 2 if dt is np.bool else np.iinfo(dt).max + 1
+
+            tgt = ubnd - 1
+            assert_equal(self.rfunc(tgt, tgt + 1, size=1000, dtype=dt), tgt)
+
+            tgt = lbnd
+            assert_equal(self.rfunc(tgt, tgt + 1, size=1000, dtype=dt), tgt)
+
+            tgt = (lbnd + ubnd)//2
+            assert_equal(self.rfunc(tgt, tgt + 1, size=1000, dtype=dt), tgt)
+
+    def test_full_range(self):
+        # Test for ticket #1690
+
+        for dt in self.itype:
+            lbnd = 0 if dt is np.bool else np.iinfo(dt).min
+            ubnd = 2 if dt is np.bool else np.iinfo(dt).max + 1
+
+            try:
+                self.rfunc(lbnd, ubnd, dtype=dt)
+            except Exception as e:
+                raise AssertionError("No error should have been raised, "
+                                     "but one was with the following "
+                                     "message:\n\n%s" % str(e))
+
+    def test_in_bounds_fuzz(self):
+        # Don't use fixed seed
+        random.seed()
+
+        for dt in self.itype[1:]:
+            for ubnd in [4, 8, 16]:
+                vals = self.rfunc(2, ubnd, size=2**16, dtype=dt)
+                assert_(vals.max() < ubnd)
+                assert_(vals.min() >= 2)
+
+        vals = self.rfunc(0, 2, size=2**16, dtype=np.bool)
+
+        assert_(vals.max() < 2)
+        assert_(vals.min() >= 0)
+
+    def test_repeatability(self):
+        # We use a sha256 hash of generated sequences of 1000 samples
+        # in the range [0, 6) for all but bool, where the range
+        # is [0, 2). Hashes are for little endian numbers.
+        tgt = {'bool': '509aea74d792fb931784c4b0135392c65aec64beee12b0cc167548a2c3d31e71',
+               'int16': '7b07f1a920e46f6d0fe02314155a2330bcfd7635e708da50e536c5ebb631a7d4',
+               'int32': 'e577bfed6c935de944424667e3da285012e741892dcb7051a8f1ce68ab05c92f',
+               'int64': '0fbead0b06759df2cfb55e43148822d4a1ff953c7eb19a5b08445a63bb64fa9e',
+               'int8': '001aac3a5acb935a9b186cbe14a1ca064b8bb2dd0b045d48abeacf74d0203404',
+               'uint16': '7b07f1a920e46f6d0fe02314155a2330bcfd7635e708da50e536c5ebb631a7d4',
+               'uint32': 'e577bfed6c935de944424667e3da285012e741892dcb7051a8f1ce68ab05c92f',
+               'uint64': '0fbead0b06759df2cfb55e43148822d4a1ff953c7eb19a5b08445a63bb64fa9e',
+               'uint8': '001aac3a5acb935a9b186cbe14a1ca064b8bb2dd0b045d48abeacf74d0203404'}
+
+        for dt in self.itype[1:]:
+            random.seed(1234)
+
+            # view as little endian for hash
+            if sys.byteorder == 'little':
+                val = self.rfunc(0, 6, size=1000, dtype=dt)
+            else:
+                val = self.rfunc(0, 6, size=1000, dtype=dt).byteswap()
+
+            res = hashlib.sha256(val.view(np.int8)).hexdigest()
+            assert_(tgt[np.dtype(dt).name] == res)
+
+        # bools do not depend on endianness
+        random.seed(1234)
+        val = self.rfunc(0, 2, size=1000, dtype=bool).view(np.int8)
+        res = hashlib.sha256(val).hexdigest()
+        assert_(tgt[np.dtype(bool).name] == res)
+
+    @pytest.mark.skipif(np.iinfo('l').max < 2**32,
+                        reason='Cannot test with 32-bit C long')
+    def test_repeatability_32bit_boundary_broadcasting(self):
+        desired = np.array([[[3992670689, 2438360420, 2557845020],
+                             [4107320065, 4142558326, 3216529513],
+                             [1605979228, 2807061240,  665605495]],
+                            [[3211410639, 4128781000,  457175120],
+                             [1712592594, 1282922662, 3081439808],
+                             [3997822960, 2008322436, 1563495165]],
+                            [[1398375547, 4269260146,  115316740],
+                             [3414372578, 3437564012, 2112038651],
+                             [3572980305, 2260248732, 3908238631]],
+                            [[2561372503,  223155946, 3127879445],
+                             [ 441282060, 3514786552, 2148440361],
+                             [1629275283, 3479737011, 3003195987]],
+                            [[ 412181688,  940383289, 3047321305],
+                             [2978368172,  764731833, 2282559898],
+                             [ 105711276,  720447391, 3596512484]]])
+        for size in [None, (5, 3, 3)]:
+            random.seed(12345)
+            x = self.rfunc([[-1], [0], [1]], [2**32 - 1, 2**32, 2**32 + 1],
+                           size=size)
+            assert_array_equal(x, desired if size is not None else desired[0])
+
+    def test_int64_uint64_corner_case(self):
+        # When stored in Numpy arrays, `lbnd` is casted
+        # as np.int64, and `ubnd` is casted as np.uint64.
+        # Checking whether `lbnd` >= `ubnd` used to be
+        # done solely via direct comparison, which is incorrect
+        # because when Numpy tries to compare both numbers,
+        # it casts both to np.float64 because there is
+        # no integer superset of np.int64 and np.uint64. However,
+        # `ubnd` is too large to be represented in np.float64,
+        # causing it be round down to np.iinfo(np.int64).max,
+        # leading to a ValueError because `lbnd` now equals
+        # the new `ubnd`.
+
+        dt = np.int64
+        tgt = np.iinfo(np.int64).max
+        lbnd = np.int64(np.iinfo(np.int64).max)
+        ubnd = np.uint64(np.iinfo(np.int64).max + 1)
+
+        # None of these function calls should
+        # generate a ValueError now.
+        actual = random.randint(lbnd, ubnd, dtype=dt)
+        assert_equal(actual, tgt)
+
+    def test_respect_dtype_singleton(self):
+        # See gh-7203
+        for dt in self.itype:
+            lbnd = 0 if dt is np.bool else np.iinfo(dt).min
+            ubnd = 2 if dt is np.bool else np.iinfo(dt).max + 1
+
+            sample = self.rfunc(lbnd, ubnd, dtype=dt)
+            assert_equal(sample.dtype, np.dtype(dt))
+
+        for dt in (bool, int):
+            # The legacy random generation forces the use of "long" on this
+            # branch even when the input is `int` and the default dtype
+            # for int changed (dtype=int is also the functions default)
+            op_dtype = "long" if dt is int else "bool"
+            lbnd = 0 if dt is bool else np.iinfo(op_dtype).min
+            ubnd = 2 if dt is bool else np.iinfo(op_dtype).max + 1
+
+            sample = self.rfunc(lbnd, ubnd, dtype=dt)
+            assert_(not hasattr(sample, 'dtype'))
+            assert_equal(type(sample), dt)
+
+
+class TestRandomDist:
+    # Make sure the random distribution returns the correct value for a
+    # given seed
+
+    def setup_method(self):
+        self.seed = 1234567890
+
+    def test_rand(self):
+        random.seed(self.seed)
+        actual = random.rand(3, 2)
+        desired = np.array([[0.61879477158567997, 0.59162362775974664],
+                            [0.88868358904449662, 0.89165480011560816],
+                            [0.4575674820298663, 0.7781880808593471]])
+        assert_array_almost_equal(actual, desired, decimal=15)
+
+    def test_rand_singleton(self):
+        random.seed(self.seed)
+        actual = random.rand()
+        desired = 0.61879477158567997
+        assert_array_almost_equal(actual, desired, decimal=15)
+
+    def test_randn(self):
+        random.seed(self.seed)
+        actual = random.randn(3, 2)
+        desired = np.array([[1.34016345771863121, 1.73759122771936081],
+                           [1.498988344300628, -0.2286433324536169],
+                           [2.031033998682787, 2.17032494605655257]])
+        assert_array_almost_equal(actual, desired, decimal=15)
+
+        random.seed(self.seed)
+        actual = random.randn()
+        assert_array_almost_equal(actual, desired[0, 0], decimal=15)
+
+    def test_randint(self):
+        random.seed(self.seed)
+        actual = random.randint(-99, 99, size=(3, 2))
+        desired = np.array([[31, 3],
+                            [-52, 41],
+                            [-48, -66]])
+        assert_array_equal(actual, desired)
+
+    def test_random_integers(self):
+        random.seed(self.seed)
+        with suppress_warnings() as sup:
+            w = sup.record(DeprecationWarning)
+            actual = random.random_integers(-99, 99, size=(3, 2))
+            assert_(len(w) == 1)
+        desired = np.array([[31, 3],
+                            [-52, 41],
+                            [-48, -66]])
+        assert_array_equal(actual, desired)
+
+        random.seed(self.seed)
+        with suppress_warnings() as sup:
+            w = sup.record(DeprecationWarning)
+            actual = random.random_integers(198, size=(3, 2))
+            assert_(len(w) == 1)
+        assert_array_equal(actual, desired + 100)
+
+    def test_tomaxint(self):
+        random.seed(self.seed)
+        rs = random.RandomState(self.seed)
+        actual = rs.tomaxint(size=(3, 2))
+        if np.iinfo(np.long).max == 2147483647:
+            desired = np.array([[1328851649,  731237375],
+                                [1270502067,  320041495],
+                                [1908433478,  499156889]], dtype=np.int64)
+        else:
+            desired = np.array([[5707374374421908479, 5456764827585442327],
+                                [8196659375100692377, 8224063923314595285],
+                                [4220315081820346526, 7177518203184491332]],
+                               dtype=np.int64)
+
+        assert_equal(actual, desired)
+
+        rs.seed(self.seed)
+        actual = rs.tomaxint()
+        assert_equal(actual, desired[0, 0])
+
+    def test_random_integers_max_int(self):
+        # Tests whether random_integers can generate the
+        # maximum allowed Python int that can be converted
+        # into a C long. Previous implementations of this
+        # method have thrown an OverflowError when attempting
+        # to generate this integer.
+        with suppress_warnings() as sup:
+            w = sup.record(DeprecationWarning)
+            actual = random.random_integers(np.iinfo('l').max,
+                                            np.iinfo('l').max)
+            assert_(len(w) == 1)
+
+        desired = np.iinfo('l').max
+        assert_equal(actual, desired)
+        with suppress_warnings() as sup:
+            w = sup.record(DeprecationWarning)
+            typer = np.dtype('l').type
+            actual = random.random_integers(typer(np.iinfo('l').max),
+                                            typer(np.iinfo('l').max))
+            assert_(len(w) == 1)
+        assert_equal(actual, desired)
+
+    def test_random_integers_deprecated(self):
+        with warnings.catch_warnings():
+            warnings.simplefilter("error", DeprecationWarning)
+
+            # DeprecationWarning raised with high == None
+            assert_raises(DeprecationWarning,
+                          random.random_integers,
+                          np.iinfo('l').max)
+
+            # DeprecationWarning raised with high != None
+            assert_raises(DeprecationWarning,
+                          random.random_integers,
+                          np.iinfo('l').max, np.iinfo('l').max)
+
+    def test_random_sample(self):
+        random.seed(self.seed)
+        actual = random.random_sample((3, 2))
+        desired = np.array([[0.61879477158567997, 0.59162362775974664],
+                            [0.88868358904449662, 0.89165480011560816],
+                            [0.4575674820298663, 0.7781880808593471]])
+        assert_array_almost_equal(actual, desired, decimal=15)
+
+        random.seed(self.seed)
+        actual = random.random_sample()
+        assert_array_almost_equal(actual, desired[0, 0], decimal=15)
+
+    def test_choice_uniform_replace(self):
+        random.seed(self.seed)
+        actual = random.choice(4, 4)
+        desired = np.array([2, 3, 2, 3])
+        assert_array_equal(actual, desired)
+
+    def test_choice_nonuniform_replace(self):
+        random.seed(self.seed)
+        actual = random.choice(4, 4, p=[0.4, 0.4, 0.1, 0.1])
+        desired = np.array([1, 1, 2, 2])
+        assert_array_equal(actual, desired)
+
+    def test_choice_uniform_noreplace(self):
+        random.seed(self.seed)
+        actual = random.choice(4, 3, replace=False)
+        desired = np.array([0, 1, 3])
+        assert_array_equal(actual, desired)
+
+    def test_choice_nonuniform_noreplace(self):
+        random.seed(self.seed)
+        actual = random.choice(4, 3, replace=False, p=[0.1, 0.3, 0.5, 0.1])
+        desired = np.array([2, 3, 1])
+        assert_array_equal(actual, desired)
+
+    def test_choice_noninteger(self):
+        random.seed(self.seed)
+        actual = random.choice(['a', 'b', 'c', 'd'], 4)
+        desired = np.array(['c', 'd', 'c', 'd'])
+        assert_array_equal(actual, desired)
+
+    def test_choice_exceptions(self):
+        sample = random.choice
+        assert_raises(ValueError, sample, -1, 3)
+        assert_raises(ValueError, sample, 3., 3)
+        assert_raises(ValueError, sample, [[1, 2], [3, 4]], 3)
+        assert_raises(ValueError, sample, [], 3)
+        assert_raises(ValueError, sample, [1, 2, 3, 4], 3,
+                      p=[[0.25, 0.25], [0.25, 0.25]])
+        assert_raises(ValueError, sample, [1, 2], 3, p=[0.4, 0.4, 0.2])
+        assert_raises(ValueError, sample, [1, 2], 3, p=[1.1, -0.1])
+        assert_raises(ValueError, sample, [1, 2], 3, p=[0.4, 0.4])
+        assert_raises(ValueError, sample, [1, 2, 3], 4, replace=False)
+        # gh-13087
+        assert_raises(ValueError, sample, [1, 2, 3], -2, replace=False)
+        assert_raises(ValueError, sample, [1, 2, 3], (-1,), replace=False)
+        assert_raises(ValueError, sample, [1, 2, 3], (-1, 1), replace=False)
+        assert_raises(ValueError, sample, [1, 2, 3], 2,
+                      replace=False, p=[1, 0, 0])
+
+    def test_choice_return_shape(self):
+        p = [0.1, 0.9]
+        # Check scalar
+        assert_(np.isscalar(random.choice(2, replace=True)))
+        assert_(np.isscalar(random.choice(2, replace=False)))
+        assert_(np.isscalar(random.choice(2, replace=True, p=p)))
+        assert_(np.isscalar(random.choice(2, replace=False, p=p)))
+        assert_(np.isscalar(random.choice([1, 2], replace=True)))
+        assert_(random.choice([None], replace=True) is None)
+        a = np.array([1, 2])
+        arr = np.empty(1, dtype=object)
+        arr[0] = a
+        assert_(random.choice(arr, replace=True) is a)
+
+        # Check 0-d array
+        s = tuple()
+        assert_(not np.isscalar(random.choice(2, s, replace=True)))
+        assert_(not np.isscalar(random.choice(2, s, replace=False)))
+        assert_(not np.isscalar(random.choice(2, s, replace=True, p=p)))
+        assert_(not np.isscalar(random.choice(2, s, replace=False, p=p)))
+        assert_(not np.isscalar(random.choice([1, 2], s, replace=True)))
+        assert_(random.choice([None], s, replace=True).ndim == 0)
+        a = np.array([1, 2])
+        arr = np.empty(1, dtype=object)
+        arr[0] = a
+        assert_(random.choice(arr, s, replace=True).item() is a)
+
+        # Check multi dimensional array
+        s = (2, 3)
+        p = [0.1, 0.1, 0.1, 0.1, 0.4, 0.2]
+        assert_equal(random.choice(6, s, replace=True).shape, s)
+        assert_equal(random.choice(6, s, replace=False).shape, s)
+        assert_equal(random.choice(6, s, replace=True, p=p).shape, s)
+        assert_equal(random.choice(6, s, replace=False, p=p).shape, s)
+        assert_equal(random.choice(np.arange(6), s, replace=True).shape, s)
+
+        # Check zero-size
+        assert_equal(random.randint(0, 0, size=(3, 0, 4)).shape, (3, 0, 4))
+        assert_equal(random.randint(0, -10, size=0).shape, (0,))
+        assert_equal(random.randint(10, 10, size=0).shape, (0,))
+        assert_equal(random.choice(0, size=0).shape, (0,))
+        assert_equal(random.choice([], size=(0,)).shape, (0,))
+        assert_equal(random.choice(['a', 'b'], size=(3, 0, 4)).shape,
+                     (3, 0, 4))
+        assert_raises(ValueError, random.choice, [], 10)
+
+    def test_choice_nan_probabilities(self):
+        a = np.array([42, 1, 2])
+        p = [None, None, None]
+        assert_raises(ValueError, random.choice, a, p=p)
+
+    def test_choice_p_non_contiguous(self):
+        p = np.ones(10) / 5
+        p[1::2] = 3.0
+        random.seed(self.seed)
+        non_contig = random.choice(5, 3, p=p[::2])
+        random.seed(self.seed)
+        contig = random.choice(5, 3, p=np.ascontiguousarray(p[::2]))
+        assert_array_equal(non_contig, contig)
+
+    def test_bytes(self):
+        random.seed(self.seed)
+        actual = random.bytes(10)
+        desired = b'\x82Ui\x9e\xff\x97+Wf\xa5'
+        assert_equal(actual, desired)
+
+    def test_shuffle(self):
+        # Test lists, arrays (of various dtypes), and multidimensional versions
+        # of both, c-contiguous or not:
+        for conv in [lambda x: np.array([]),
+                     lambda x: x,
+                     lambda x: np.asarray(x).astype(np.int8),
+                     lambda x: np.asarray(x).astype(np.float32),
+                     lambda x: np.asarray(x).astype(np.complex64),
+                     lambda x: np.asarray(x).astype(object),
+                     lambda x: [(i, i) for i in x],
+                     lambda x: np.asarray([[i, i] for i in x]),
+                     lambda x: np.vstack([x, x]).T,
+                     # gh-11442
+                     lambda x: (np.asarray([(i, i) for i in x],
+                                           [("a", int), ("b", int)])
+                                .view(np.recarray)),
+                     # gh-4270
+                     lambda x: np.asarray([(i, i) for i in x],
+                                          [("a", object, (1,)),
+                                           ("b", np.int32, (1,))])]:
+            random.seed(self.seed)
+            alist = conv([1, 2, 3, 4, 5, 6, 7, 8, 9, 0])
+            random.shuffle(alist)
+            actual = alist
+            desired = conv([0, 1, 9, 6, 2, 4, 5, 8, 7, 3])
+            assert_array_equal(actual, desired)
+
+    def test_shuffle_masked(self):
+        # gh-3263
+        a = np.ma.masked_values(np.reshape(range(20), (5, 4)) % 3 - 1, -1)
+        b = np.ma.masked_values(np.arange(20) % 3 - 1, -1)
+        a_orig = a.copy()
+        b_orig = b.copy()
+        for i in range(50):
+            random.shuffle(a)
+            assert_equal(
+                sorted(a.data[~a.mask]), sorted(a_orig.data[~a_orig.mask]))
+            random.shuffle(b)
+            assert_equal(
+                sorted(b.data[~b.mask]), sorted(b_orig.data[~b_orig.mask]))
+
+        def test_shuffle_invalid_objects(self):
+            x = np.array(3)
+            assert_raises(TypeError, random.shuffle, x)
+
+    def test_permutation(self):
+        random.seed(self.seed)
+        alist = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]
+        actual = random.permutation(alist)
+        desired = [0, 1, 9, 6, 2, 4, 5, 8, 7, 3]
+        assert_array_equal(actual, desired)
+
+        random.seed(self.seed)
+        arr_2d = np.atleast_2d([1, 2, 3, 4, 5, 6, 7, 8, 9, 0]).T
+        actual = random.permutation(arr_2d)
+        assert_array_equal(actual, np.atleast_2d(desired).T)
+
+        random.seed(self.seed)
+        bad_x_str = "abcd"
+        assert_raises(IndexError, random.permutation, bad_x_str)
+
+        random.seed(self.seed)
+        bad_x_float = 1.2
+        assert_raises(IndexError, random.permutation, bad_x_float)
+
+        integer_val = 10
+        desired = [9, 0, 8, 5, 1, 3, 4, 7, 6, 2]
+
+        random.seed(self.seed)
+        actual = random.permutation(integer_val)
+        assert_array_equal(actual, desired)
+
+    def test_beta(self):
+        random.seed(self.seed)
+        actual = random.beta(.1, .9, size=(3, 2))
+        desired = np.array(
+                [[1.45341850513746058e-02, 5.31297615662868145e-04],
+                 [1.85366619058432324e-06, 4.19214516800110563e-03],
+                 [1.58405155108498093e-04, 1.26252891949397652e-04]])
+        assert_array_almost_equal(actual, desired, decimal=15)
+
+    def test_binomial(self):
+        random.seed(self.seed)
+        actual = random.binomial(100.123, .456, size=(3, 2))
+        desired = np.array([[37, 43],
+                            [42, 48],
+                            [46, 45]])
+        assert_array_equal(actual, desired)
+
+        random.seed(self.seed)
+        actual = random.binomial(100.123, .456)
+        desired = 37
+        assert_array_equal(actual, desired)
+
+    def test_chisquare(self):
+        random.seed(self.seed)
+        actual = random.chisquare(50, size=(3, 2))
+        desired = np.array([[63.87858175501090585, 68.68407748911370447],
+                            [65.77116116901505904, 47.09686762438974483],
+                            [72.3828403199695174, 74.18408615260374006]])
+        assert_array_almost_equal(actual, desired, decimal=13)
+
+    def test_dirichlet(self):
+        random.seed(self.seed)
+        alpha = np.array([51.72840233779265162, 39.74494232180943953])
+        actual = random.dirichlet(alpha, size=(3, 2))
+        desired = np.array([[[0.54539444573611562, 0.45460555426388438],
+                             [0.62345816822039413, 0.37654183177960598]],
+                            [[0.55206000085785778, 0.44793999914214233],
+                             [0.58964023305154301, 0.41035976694845688]],
+                            [[0.59266909280647828, 0.40733090719352177],
+                             [0.56974431743975207, 0.43025568256024799]]])
+        assert_array_almost_equal(actual, desired, decimal=15)
+        bad_alpha = np.array([5.4e-01, -1.0e-16])
+        assert_raises(ValueError, random.dirichlet, bad_alpha)
+
+        random.seed(self.seed)
+        alpha = np.array([51.72840233779265162, 39.74494232180943953])
+        actual = random.dirichlet(alpha)
+        assert_array_almost_equal(actual, desired[0, 0], decimal=15)
+
+    def test_dirichlet_size(self):
+        # gh-3173
+        p = np.array([51.72840233779265162, 39.74494232180943953])
+        assert_equal(random.dirichlet(p, np.uint32(1)).shape, (1, 2))
+        assert_equal(random.dirichlet(p, np.uint32(1)).shape, (1, 2))
+        assert_equal(random.dirichlet(p, np.uint32(1)).shape, (1, 2))
+        assert_equal(random.dirichlet(p, [2, 2]).shape, (2, 2, 2))
+        assert_equal(random.dirichlet(p, (2, 2)).shape, (2, 2, 2))
+        assert_equal(random.dirichlet(p, np.array((2, 2))).shape, (2, 2, 2))
+
+        assert_raises(TypeError, random.dirichlet, p, float(1))
+
+    def test_dirichlet_bad_alpha(self):
+        # gh-2089
+        alpha = np.array([5.4e-01, -1.0e-16])
+        assert_raises(ValueError, random.dirichlet, alpha)
+
+    def test_dirichlet_alpha_non_contiguous(self):
+        a = np.array([51.72840233779265162, -1.0, 39.74494232180943953])
+        alpha = a[::2]
+        random.seed(self.seed)
+        non_contig = random.dirichlet(alpha, size=(3, 2))
+        random.seed(self.seed)
+        contig = random.dirichlet(np.ascontiguousarray(alpha),
+                                  size=(3, 2))
+        assert_array_almost_equal(non_contig, contig)
+
+    def test_exponential(self):
+        random.seed(self.seed)
+        actual = random.exponential(1.1234, size=(3, 2))
+        desired = np.array([[1.08342649775011624, 1.00607889924557314],
+                            [2.46628830085216721, 2.49668106809923884],
+                            [0.68717433461363442, 1.69175666993575979]])
+        assert_array_almost_equal(actual, desired, decimal=15)
+
+    def test_exponential_0(self):
+        assert_equal(random.exponential(scale=0), 0)
+        assert_raises(ValueError, random.exponential, scale=-0.)
+
+    def test_f(self):
+        random.seed(self.seed)
+        actual = random.f(12, 77, size=(3, 2))
+        desired = np.array([[1.21975394418575878, 1.75135759791559775],
+                            [1.44803115017146489, 1.22108959480396262],
+                            [1.02176975757740629, 1.34431827623300415]])
+        assert_array_almost_equal(actual, desired, decimal=15)
+
+    def test_gamma(self):
+        random.seed(self.seed)
+        actual = random.gamma(5, 3, size=(3, 2))
+        desired = np.array([[24.60509188649287182, 28.54993563207210627],
+                            [26.13476110204064184, 12.56988482927716078],
+                            [31.71863275789960568, 33.30143302795922011]])
+        assert_array_almost_equal(actual, desired, decimal=14)
+
+    def test_gamma_0(self):
+        assert_equal(random.gamma(shape=0, scale=0), 0)
+        assert_raises(ValueError, random.gamma, shape=-0., scale=-0.)
+
+    def test_geometric(self):
+        random.seed(self.seed)
+        actual = random.geometric(.123456789, size=(3, 2))
+        desired = np.array([[8, 7],
+                            [17, 17],
+                            [5, 12]])
+        assert_array_equal(actual, desired)
+
+    def test_geometric_exceptions(self):
+        assert_raises(ValueError, random.geometric, 1.1)
+        assert_raises(ValueError, random.geometric, [1.1] * 10)
+        assert_raises(ValueError, random.geometric, -0.1)
+        assert_raises(ValueError, random.geometric, [-0.1] * 10)
+        with suppress_warnings() as sup:
+            sup.record(RuntimeWarning)
+            assert_raises(ValueError, random.geometric, np.nan)
+            assert_raises(ValueError, random.geometric, [np.nan] * 10)
+
+    def test_gumbel(self):
+        random.seed(self.seed)
+        actual = random.gumbel(loc=.123456789, scale=2.0, size=(3, 2))
+        desired = np.array([[0.19591898743416816, 0.34405539668096674],
+                            [-1.4492522252274278, -1.47374816298446865],
+                            [1.10651090478803416, -0.69535848626236174]])
+        assert_array_almost_equal(actual, desired, decimal=15)
+
+    def test_gumbel_0(self):
+        assert_equal(random.gumbel(scale=0), 0)
+        assert_raises(ValueError, random.gumbel, scale=-0.)
+
+    def test_hypergeometric(self):
+        random.seed(self.seed)
+        actual = random.hypergeometric(10.1, 5.5, 14, size=(3, 2))
+        desired = np.array([[10, 10],
+                            [10, 10],
+                            [9, 9]])
+        assert_array_equal(actual, desired)
+
+        # Test nbad = 0
+        actual = random.hypergeometric(5, 0, 3, size=4)
+        desired = np.array([3, 3, 3, 3])
+        assert_array_equal(actual, desired)
+
+        actual = random.hypergeometric(15, 0, 12, size=4)
+        desired = np.array([12, 12, 12, 12])
+        assert_array_equal(actual, desired)
+
+        # Test ngood = 0
+        actual = random.hypergeometric(0, 5, 3, size=4)
+        desired = np.array([0, 0, 0, 0])
+        assert_array_equal(actual, desired)
+
+        actual = random.hypergeometric(0, 15, 12, size=4)
+        desired = np.array([0, 0, 0, 0])
+        assert_array_equal(actual, desired)
+
+    def test_laplace(self):
+        random.seed(self.seed)
+        actual = random.laplace(loc=.123456789, scale=2.0, size=(3, 2))
+        desired = np.array([[0.66599721112760157, 0.52829452552221945],
+                            [3.12791959514407125, 3.18202813572992005],
+                            [-0.05391065675859356, 1.74901336242837324]])
+        assert_array_almost_equal(actual, desired, decimal=15)
+
+    def test_laplace_0(self):
+        assert_equal(random.laplace(scale=0), 0)
+        assert_raises(ValueError, random.laplace, scale=-0.)
+
+    def test_logistic(self):
+        random.seed(self.seed)
+        actual = random.logistic(loc=.123456789, scale=2.0, size=(3, 2))
+        desired = np.array([[1.09232835305011444, 0.8648196662399954],
+                            [4.27818590694950185, 4.33897006346929714],
+                            [-0.21682183359214885, 2.63373365386060332]])
+        assert_array_almost_equal(actual, desired, decimal=15)
+
+    def test_lognormal(self):
+        random.seed(self.seed)
+        actual = random.lognormal(mean=.123456789, sigma=2.0, size=(3, 2))
+        desired = np.array([[16.50698631688883822, 36.54846706092654784],
+                            [22.67886599981281748, 0.71617561058995771],
+                            [65.72798501792723869, 86.84341601437161273]])
+        assert_array_almost_equal(actual, desired, decimal=13)
+
+    def test_lognormal_0(self):
+        assert_equal(random.lognormal(sigma=0), 1)
+        assert_raises(ValueError, random.lognormal, sigma=-0.)
+
+    def test_logseries(self):
+        random.seed(self.seed)
+        actual = random.logseries(p=.923456789, size=(3, 2))
+        desired = np.array([[2, 2],
+                            [6, 17],
+                            [3, 6]])
+        assert_array_equal(actual, desired)
+
+    def test_logseries_zero(self):
+        assert random.logseries(0) == 1
+
+    @pytest.mark.parametrize("value", [np.nextafter(0., -1), 1., np.nan, 5.])
+    def test_logseries_exceptions(self, value):
+        with np.errstate(invalid="ignore"):
+            with pytest.raises(ValueError):
+                random.logseries(value)
+            with pytest.raises(ValueError):
+                # contiguous path:
+                random.logseries(np.array([value] * 10))
+            with pytest.raises(ValueError):
+                # non-contiguous path:
+                random.logseries(np.array([value] * 10)[::2])
+
+    def test_multinomial(self):
+        random.seed(self.seed)
+        actual = random.multinomial(20, [1 / 6.] * 6, size=(3, 2))
+        desired = np.array([[[4, 3, 5, 4, 2, 2],
+                             [5, 2, 8, 2, 2, 1]],
+                            [[3, 4, 3, 6, 0, 4],
+                             [2, 1, 4, 3, 6, 4]],
+                            [[4, 4, 2, 5, 2, 3],
+                             [4, 3, 4, 2, 3, 4]]])
+        assert_array_equal(actual, desired)
+
+    def test_multivariate_normal(self):
+        random.seed(self.seed)
+        mean = (.123456789, 10)
+        cov = [[1, 0], [0, 1]]
+        size = (3, 2)
+        actual = random.multivariate_normal(mean, cov, size)
+        desired = np.array([[[1.463620246718631, 11.73759122771936],
+                             [1.622445133300628, 9.771356667546383]],
+                            [[2.154490787682787, 12.170324946056553],
+                             [1.719909438201865, 9.230548443648306]],
+                            [[0.689515026297799, 9.880729819607714],
+                             [-0.023054015651998, 9.201096623542879]]])
+
+        assert_array_almost_equal(actual, desired, decimal=15)
+
+        # Check for default size, was raising deprecation warning
+        actual = random.multivariate_normal(mean, cov)
+        desired = np.array([0.895289569463708, 9.17180864067987])
+        assert_array_almost_equal(actual, desired, decimal=15)
+
+        # Check that non positive-semidefinite covariance warns with
+        # RuntimeWarning
+        mean = [0, 0]
+        cov = [[1, 2], [2, 1]]
+        assert_warns(RuntimeWarning, random.multivariate_normal, mean, cov)
+
+        # and that it doesn't warn with RuntimeWarning check_valid='ignore'
+        assert_no_warnings(random.multivariate_normal, mean, cov,
+                           check_valid='ignore')
+
+        # and that it raises with RuntimeWarning check_valid='raises'
+        assert_raises(ValueError, random.multivariate_normal, mean, cov,
+                      check_valid='raise')
+
+        cov = np.array([[1, 0.1], [0.1, 1]], dtype=np.float32)
+        with suppress_warnings() as sup:
+            random.multivariate_normal(mean, cov)
+            w = sup.record(RuntimeWarning)
+            assert len(w) == 0
+
+        mu = np.zeros(2)
+        cov = np.eye(2)
+        assert_raises(ValueError, random.multivariate_normal, mean, cov,
+                      check_valid='other')
+        assert_raises(ValueError, random.multivariate_normal,
+                      np.zeros((2, 1, 1)), cov)
+        assert_raises(ValueError, random.multivariate_normal,
+                      mu, np.empty((3, 2)))
+        assert_raises(ValueError, random.multivariate_normal,
+                      mu, np.eye(3))
+
+    def test_negative_binomial(self):
+        random.seed(self.seed)
+        actual = random.negative_binomial(n=100, p=.12345, size=(3, 2))
+        desired = np.array([[848, 841],
+                            [892, 611],
+                            [779, 647]])
+        assert_array_equal(actual, desired)
+
+    def test_negative_binomial_exceptions(self):
+        with suppress_warnings() as sup:
+            sup.record(RuntimeWarning)
+            assert_raises(ValueError, random.negative_binomial, 100, np.nan)
+            assert_raises(ValueError, random.negative_binomial, 100,
+                          [np.nan] * 10)
+
+    def test_noncentral_chisquare(self):
+        random.seed(self.seed)
+        actual = random.noncentral_chisquare(df=5, nonc=5, size=(3, 2))
+        desired = np.array([[23.91905354498517511, 13.35324692733826346],
+                            [31.22452661329736401, 16.60047399466177254],
+                            [5.03461598262724586, 17.94973089023519464]])
+        assert_array_almost_equal(actual, desired, decimal=14)
+
+        actual = random.noncentral_chisquare(df=.5, nonc=.2, size=(3, 2))
+        desired = np.array([[1.47145377828516666,  0.15052899268012659],
+                            [0.00943803056963588,  1.02647251615666169],
+                            [0.332334982684171,  0.15451287602753125]])
+        assert_array_almost_equal(actual, desired, decimal=14)
+
+        random.seed(self.seed)
+        actual = random.noncentral_chisquare(df=5, nonc=0, size=(3, 2))
+        desired = np.array([[9.597154162763948, 11.725484450296079],
+                            [10.413711048138335, 3.694475922923986],
+                            [13.484222138963087, 14.377255424602957]])
+        assert_array_almost_equal(actual, desired, decimal=14)
+
+    def test_noncentral_f(self):
+        random.seed(self.seed)
+        actual = random.noncentral_f(dfnum=5, dfden=2, nonc=1,
+                                     size=(3, 2))
+        desired = np.array([[1.40598099674926669, 0.34207973179285761],
+                            [3.57715069265772545, 7.92632662577829805],
+                            [0.43741599463544162, 1.1774208752428319]])
+        assert_array_almost_equal(actual, desired, decimal=14)
+
+    def test_noncentral_f_nan(self):
+        random.seed(self.seed)
+        actual = random.noncentral_f(dfnum=5, dfden=2, nonc=np.nan)
+        assert np.isnan(actual)
+
+    def test_normal(self):
+        random.seed(self.seed)
+        actual = random.normal(loc=.123456789, scale=2.0, size=(3, 2))
+        desired = np.array([[2.80378370443726244, 3.59863924443872163],
+                            [3.121433477601256, -0.33382987590723379],
+                            [4.18552478636557357, 4.46410668111310471]])
+        assert_array_almost_equal(actual, desired, decimal=15)
+
+    def test_normal_0(self):
+        assert_equal(random.normal(scale=0), 0)
+        assert_raises(ValueError, random.normal, scale=-0.)
+
+    def test_pareto(self):
+        random.seed(self.seed)
+        actual = random.pareto(a=.123456789, size=(3, 2))
+        desired = np.array(
+                [[2.46852460439034849e+03, 1.41286880810518346e+03],
+                 [5.28287797029485181e+07, 6.57720981047328785e+07],
+                 [1.40840323350391515e+02, 1.98390255135251704e+05]])
+        # For some reason on 32-bit x86 Ubuntu 12.10 the [1, 0] entry in this
+        # matrix differs by 24 nulps. Discussion:
+        #   https://mail.python.org/pipermail/numpy-discussion/2012-September/063801.html
+        # Consensus is that this is probably some gcc quirk that affects
+        # rounding but not in any important way, so we just use a looser
+        # tolerance on this test:
+        np.testing.assert_array_almost_equal_nulp(actual, desired, nulp=30)
+
+    def test_poisson(self):
+        random.seed(self.seed)
+        actual = random.poisson(lam=.123456789, size=(3, 2))
+        desired = np.array([[0, 0],
+                            [1, 0],
+                            [0, 0]])
+        assert_array_equal(actual, desired)
+
+    def test_poisson_exceptions(self):
+        lambig = np.iinfo('l').max
+        lamneg = -1
+        assert_raises(ValueError, random.poisson, lamneg)
+        assert_raises(ValueError, random.poisson, [lamneg] * 10)
+        assert_raises(ValueError, random.poisson, lambig)
+        assert_raises(ValueError, random.poisson, [lambig] * 10)
+        with suppress_warnings() as sup:
+            sup.record(RuntimeWarning)
+            assert_raises(ValueError, random.poisson, np.nan)
+            assert_raises(ValueError, random.poisson, [np.nan] * 10)
+
+    def test_power(self):
+        random.seed(self.seed)
+        actual = random.power(a=.123456789, size=(3, 2))
+        desired = np.array([[0.02048932883240791, 0.01424192241128213],
+                            [0.38446073748535298, 0.39499689943484395],
+                            [0.00177699707563439, 0.13115505880863756]])
+        assert_array_almost_equal(actual, desired, decimal=15)
+
+    def test_rayleigh(self):
+        random.seed(self.seed)
+        actual = random.rayleigh(scale=10, size=(3, 2))
+        desired = np.array([[13.8882496494248393, 13.383318339044731],
+                            [20.95413364294492098, 21.08285015800712614],
+                            [11.06066537006854311, 17.35468505778271009]])
+        assert_array_almost_equal(actual, desired, decimal=14)
+
+    def test_rayleigh_0(self):
+        assert_equal(random.rayleigh(scale=0), 0)
+        assert_raises(ValueError, random.rayleigh, scale=-0.)
+
+    def test_standard_cauchy(self):
+        random.seed(self.seed)
+        actual = random.standard_cauchy(size=(3, 2))
+        desired = np.array([[0.77127660196445336, -6.55601161955910605],
+                            [0.93582023391158309, -2.07479293013759447],
+                            [-4.74601644297011926, 0.18338989290760804]])
+        assert_array_almost_equal(actual, desired, decimal=15)
+
+    def test_standard_exponential(self):
+        random.seed(self.seed)
+        actual = random.standard_exponential(size=(3, 2))
+        desired = np.array([[0.96441739162374596, 0.89556604882105506],
+                            [2.1953785836319808, 2.22243285392490542],
+                            [0.6116915921431676, 1.50592546727413201]])
+        assert_array_almost_equal(actual, desired, decimal=15)
+
+    def test_standard_gamma(self):
+        random.seed(self.seed)
+        actual = random.standard_gamma(shape=3, size=(3, 2))
+        desired = np.array([[5.50841531318455058, 6.62953470301903103],
+                            [5.93988484943779227, 2.31044849402133989],
+                            [7.54838614231317084, 8.012756093271868]])
+        assert_array_almost_equal(actual, desired, decimal=14)
+
+    def test_standard_gamma_0(self):
+        assert_equal(random.standard_gamma(shape=0), 0)
+        assert_raises(ValueError, random.standard_gamma, shape=-0.)
+
+    def test_standard_normal(self):
+        random.seed(self.seed)
+        actual = random.standard_normal(size=(3, 2))
+        desired = np.array([[1.34016345771863121, 1.73759122771936081],
+                            [1.498988344300628, -0.2286433324536169],
+                            [2.031033998682787, 2.17032494605655257]])
+        assert_array_almost_equal(actual, desired, decimal=15)
+
+    def test_randn_singleton(self):
+        random.seed(self.seed)
+        actual = random.randn()
+        desired = np.array(1.34016345771863121)
+        assert_array_almost_equal(actual, desired, decimal=15)
+
+    def test_standard_t(self):
+        random.seed(self.seed)
+        actual = random.standard_t(df=10, size=(3, 2))
+        desired = np.array([[0.97140611862659965, -0.08830486548450577],
+                            [1.36311143689505321, -0.55317463909867071],
+                            [-0.18473749069684214, 0.61181537341755321]])
+        assert_array_almost_equal(actual, desired, decimal=15)
+
+    def test_triangular(self):
+        random.seed(self.seed)
+        actual = random.triangular(left=5.12, mode=10.23, right=20.34,
+                                   size=(3, 2))
+        desired = np.array([[12.68117178949215784, 12.4129206149193152],
+                            [16.20131377335158263, 16.25692138747600524],
+                            [11.20400690911820263, 14.4978144835829923]])
+        assert_array_almost_equal(actual, desired, decimal=14)
+
+    def test_uniform(self):
+        random.seed(self.seed)
+        actual = random.uniform(low=1.23, high=10.54, size=(3, 2))
+        desired = np.array([[6.99097932346268003, 6.73801597444323974],
+                            [9.50364421400426274, 9.53130618907631089],
+                            [5.48995325769805476, 8.47493103280052118]])
+        assert_array_almost_equal(actual, desired, decimal=15)
+
+    def test_uniform_range_bounds(self):
+        fmin = np.finfo('float').min
+        fmax = np.finfo('float').max
+
+        func = random.uniform
+        assert_raises(OverflowError, func, -np.inf, 0)
+        assert_raises(OverflowError, func, 0, np.inf)
+        assert_raises(OverflowError, func, fmin, fmax)
+        assert_raises(OverflowError, func, [-np.inf], [0])
+        assert_raises(OverflowError, func, [0], [np.inf])
+
+        # (fmax / 1e17) - fmin is within range, so this should not throw
+        # account for i386 extended precision DBL_MAX / 1e17 + DBL_MAX >
+        # DBL_MAX by increasing fmin a bit
+        random.uniform(low=np.nextafter(fmin, 1), high=fmax / 1e17)
+
+    def test_scalar_exception_propagation(self):
+        # Tests that exceptions are correctly propagated in distributions
+        # when called with objects that throw exceptions when converted to
+        # scalars.
+        #
+        # Regression test for gh: 8865
+
+        class ThrowingFloat(np.ndarray):
+            def __float__(self):
+                raise TypeError
+
+        throwing_float = np.array(1.0).view(ThrowingFloat)
+        assert_raises(TypeError, random.uniform, throwing_float,
+                      throwing_float)
+
+        class ThrowingInteger(np.ndarray):
+            def __int__(self):
+                raise TypeError
+
+        throwing_int = np.array(1).view(ThrowingInteger)
+        assert_raises(TypeError, random.hypergeometric, throwing_int, 1, 1)
+
+    def test_vonmises(self):
+        random.seed(self.seed)
+        actual = random.vonmises(mu=1.23, kappa=1.54, size=(3, 2))
+        desired = np.array([[2.28567572673902042, 2.89163838442285037],
+                            [0.38198375564286025, 2.57638023113890746],
+                            [1.19153771588353052, 1.83509849681825354]])
+        assert_array_almost_equal(actual, desired, decimal=15)
+
+    def test_vonmises_small(self):
+        # check infinite loop, gh-4720
+        random.seed(self.seed)
+        r = random.vonmises(mu=0., kappa=1.1e-8, size=10**6)
+        assert_(np.isfinite(r).all())
+
+    def test_vonmises_large(self):
+        # guard against changes in RandomState when Generator is fixed
+        random.seed(self.seed)
+        actual = random.vonmises(mu=0., kappa=1e7, size=3)
+        desired = np.array([4.634253748521111e-04,
+                            3.558873596114509e-04,
+                            -2.337119622577433e-04])
+        assert_array_almost_equal(actual, desired, decimal=8)
+
+    def test_vonmises_nan(self):
+        random.seed(self.seed)
+        r = random.vonmises(mu=0., kappa=np.nan)
+        assert_(np.isnan(r))
+
+    def test_wald(self):
+        random.seed(self.seed)
+        actual = random.wald(mean=1.23, scale=1.54, size=(3, 2))
+        desired = np.array([[3.82935265715889983, 5.13125249184285526],
+                            [0.35045403618358717, 1.50832396872003538],
+                            [0.24124319895843183, 0.22031101461955038]])
+        assert_array_almost_equal(actual, desired, decimal=14)
+
+    def test_weibull(self):
+        random.seed(self.seed)
+        actual = random.weibull(a=1.23, size=(3, 2))
+        desired = np.array([[0.97097342648766727, 0.91422896443565516],
+                            [1.89517770034962929, 1.91414357960479564],
+                            [0.67057783752390987, 1.39494046635066793]])
+        assert_array_almost_equal(actual, desired, decimal=15)
+
+    def test_weibull_0(self):
+        random.seed(self.seed)
+        assert_equal(random.weibull(a=0, size=12), np.zeros(12))
+        assert_raises(ValueError, random.weibull, a=-0.)
+
+    def test_zipf(self):
+        random.seed(self.seed)
+        actual = random.zipf(a=1.23, size=(3, 2))
+        desired = np.array([[66, 29],
+                            [1, 1],
+                            [3, 13]])
+        assert_array_equal(actual, desired)
+
+
+class TestBroadcast:
+    # tests that functions that broadcast behave
+    # correctly when presented with non-scalar arguments
+    def setup_method(self):
+        self.seed = 123456789
+
+    def set_seed(self):
+        random.seed(self.seed)
+
+    def test_uniform(self):
+        low = [0]
+        high = [1]
+        uniform = random.uniform
+        desired = np.array([0.53283302478975902,
+                            0.53413660089041659,
+                            0.50955303552646702])
+
+        self.set_seed()
+        actual = uniform(low * 3, high)
+        assert_array_almost_equal(actual, desired, decimal=14)
+
+        self.set_seed()
+        actual = uniform(low, high * 3)
+        assert_array_almost_equal(actual, desired, decimal=14)
+
+    def test_normal(self):
+        loc = [0]
+        scale = [1]
+        bad_scale = [-1]
+        normal = random.normal
+        desired = np.array([2.2129019979039612,
+                            2.1283977976520019,
+                            1.8417114045748335])
+
+        self.set_seed()
+        actual = normal(loc * 3, scale)
+        assert_array_almost_equal(actual, desired, decimal=14)
+        assert_raises(ValueError, normal, loc * 3, bad_scale)
+
+        self.set_seed()
+        actual = normal(loc, scale * 3)
+        assert_array_almost_equal(actual, desired, decimal=14)
+        assert_raises(ValueError, normal, loc, bad_scale * 3)
+
+    def test_beta(self):
+        a = [1]
+        b = [2]
+        bad_a = [-1]
+        bad_b = [-2]
+        beta = random.beta
+        desired = np.array([0.19843558305989056,
+                            0.075230336409423643,
+                            0.24976865978980844])
+
+        self.set_seed()
+        actual = beta(a * 3, b)
+        assert_array_almost_equal(actual, desired, decimal=14)
+        assert_raises(ValueError, beta, bad_a * 3, b)
+        assert_raises(ValueError, beta, a * 3, bad_b)
+
+        self.set_seed()
+        actual = beta(a, b * 3)
+        assert_array_almost_equal(actual, desired, decimal=14)
+        assert_raises(ValueError, beta, bad_a, b * 3)
+        assert_raises(ValueError, beta, a, bad_b * 3)
+
+    def test_exponential(self):
+        scale = [1]
+        bad_scale = [-1]
+        exponential = random.exponential
+        desired = np.array([0.76106853658845242,
+                            0.76386282278691653,
+                            0.71243813125891797])
+
+        self.set_seed()
+        actual = exponential(scale * 3)
+        assert_array_almost_equal(actual, desired, decimal=14)
+        assert_raises(ValueError, exponential, bad_scale * 3)
+
+    def test_standard_gamma(self):
+        shape = [1]
+        bad_shape = [-1]
+        std_gamma = random.standard_gamma
+        desired = np.array([0.76106853658845242,
+                            0.76386282278691653,
+                            0.71243813125891797])
+
+        self.set_seed()
+        actual = std_gamma(shape * 3)
+        assert_array_almost_equal(actual, desired, decimal=14)
+        assert_raises(ValueError, std_gamma, bad_shape * 3)
+
+    def test_gamma(self):
+        shape = [1]
+        scale = [2]
+        bad_shape = [-1]
+        bad_scale = [-2]
+        gamma = random.gamma
+        desired = np.array([1.5221370731769048,
+                            1.5277256455738331,
+                            1.4248762625178359])
+
+        self.set_seed()
+        actual = gamma(shape * 3, scale)
+        assert_array_almost_equal(actual, desired, decimal=14)
+        assert_raises(ValueError, gamma, bad_shape * 3, scale)
+        assert_raises(ValueError, gamma, shape * 3, bad_scale)
+
+        self.set_seed()
+        actual = gamma(shape, scale * 3)
+        assert_array_almost_equal(actual, desired, decimal=14)
+        assert_raises(ValueError, gamma, bad_shape, scale * 3)
+        assert_raises(ValueError, gamma, shape, bad_scale * 3)
+
+    def test_f(self):
+        dfnum = [1]
+        dfden = [2]
+        bad_dfnum = [-1]
+        bad_dfden = [-2]
+        f = random.f
+        desired = np.array([0.80038951638264799,
+                            0.86768719635363512,
+                            2.7251095168386801])
+
+        self.set_seed()
+        actual = f(dfnum * 3, dfden)
+        assert_array_almost_equal(actual, desired, decimal=14)
+        assert_raises(ValueError, f, bad_dfnum * 3, dfden)
+        assert_raises(ValueError, f, dfnum * 3, bad_dfden)
+
+        self.set_seed()
+        actual = f(dfnum, dfden * 3)
+        assert_array_almost_equal(actual, desired, decimal=14)
+        assert_raises(ValueError, f, bad_dfnum, dfden * 3)
+        assert_raises(ValueError, f, dfnum, bad_dfden * 3)
+
+    def test_noncentral_f(self):
+        dfnum = [2]
+        dfden = [3]
+        nonc = [4]
+        bad_dfnum = [0]
+        bad_dfden = [-1]
+        bad_nonc = [-2]
+        nonc_f = random.noncentral_f
+        desired = np.array([9.1393943263705211,
+                            13.025456344595602,
+                            8.8018098359100545])
+
+        self.set_seed()
+        actual = nonc_f(dfnum * 3, dfden, nonc)
+        assert_array_almost_equal(actual, desired, decimal=14)
+        assert np.all(np.isnan(nonc_f(dfnum, dfden, [np.nan] * 3)))
+
+        assert_raises(ValueError, nonc_f, bad_dfnum * 3, dfden, nonc)
+        assert_raises(ValueError, nonc_f, dfnum * 3, bad_dfden, nonc)
+        assert_raises(ValueError, nonc_f, dfnum * 3, dfden, bad_nonc)
+
+        self.set_seed()
+        actual = nonc_f(dfnum, dfden * 3, nonc)
+        assert_array_almost_equal(actual, desired, decimal=14)
+        assert_raises(ValueError, nonc_f, bad_dfnum, dfden * 3, nonc)
+        assert_raises(ValueError, nonc_f, dfnum, bad_dfden * 3, nonc)
+        assert_raises(ValueError, nonc_f, dfnum, dfden * 3, bad_nonc)
+
+        self.set_seed()
+        actual = nonc_f(dfnum, dfden, nonc * 3)
+        assert_array_almost_equal(actual, desired, decimal=14)
+        assert_raises(ValueError, nonc_f, bad_dfnum, dfden, nonc * 3)
+        assert_raises(ValueError, nonc_f, dfnum, bad_dfden, nonc * 3)
+        assert_raises(ValueError, nonc_f, dfnum, dfden, bad_nonc * 3)
+
+    def test_noncentral_f_small_df(self):
+        self.set_seed()
+        desired = np.array([6.869638627492048, 0.785880199263955])
+        actual = random.noncentral_f(0.9, 0.9, 2, size=2)
+        assert_array_almost_equal(actual, desired, decimal=14)
+
+    def test_chisquare(self):
+        df = [1]
+        bad_df = [-1]
+        chisquare = random.chisquare
+        desired = np.array([0.57022801133088286,
+                            0.51947702108840776,
+                            0.1320969254923558])
+
+        self.set_seed()
+        actual = chisquare(df * 3)
+        assert_array_almost_equal(actual, desired, decimal=14)
+        assert_raises(ValueError, chisquare, bad_df * 3)
+
+    def test_noncentral_chisquare(self):
+        df = [1]
+        nonc = [2]
+        bad_df = [-1]
+        bad_nonc = [-2]
+        nonc_chi = random.noncentral_chisquare
+        desired = np.array([9.0015599467913763,
+                            4.5804135049718742,
+                            6.0872302432834564])
+
+        self.set_seed()
+        actual = nonc_chi(df * 3, nonc)
+        assert_array_almost_equal(actual, desired, decimal=14)
+        assert_raises(ValueError, nonc_chi, bad_df * 3, nonc)
+        assert_raises(ValueError, nonc_chi, df * 3, bad_nonc)
+
+        self.set_seed()
+        actual = nonc_chi(df, nonc * 3)
+        assert_array_almost_equal(actual, desired, decimal=14)
+        assert_raises(ValueError, nonc_chi, bad_df, nonc * 3)
+        assert_raises(ValueError, nonc_chi, df, bad_nonc * 3)
+
+    def test_standard_t(self):
+        df = [1]
+        bad_df = [-1]
+        t = random.standard_t
+        desired = np.array([3.0702872575217643,
+                            5.8560725167361607,
+                            1.0274791436474273])
+
+        self.set_seed()
+        actual = t(df * 3)
+        assert_array_almost_equal(actual, desired, decimal=14)
+        assert_raises(ValueError, t, bad_df * 3)
+        assert_raises(ValueError, random.standard_t, bad_df * 3)
+
+    def test_vonmises(self):
+        mu = [2]
+        kappa = [1]
+        bad_kappa = [-1]
+        vonmises = random.vonmises
+        desired = np.array([2.9883443664201312,
+                            -2.7064099483995943,
+                            -1.8672476700665914])
+
+        self.set_seed()
+        actual = vonmises(mu * 3, kappa)
+        assert_array_almost_equal(actual, desired, decimal=14)
+        assert_raises(ValueError, vonmises, mu * 3, bad_kappa)
+
+        self.set_seed()
+        actual = vonmises(mu, kappa * 3)
+        assert_array_almost_equal(actual, desired, decimal=14)
+        assert_raises(ValueError, vonmises, mu, bad_kappa * 3)
+
+    def test_pareto(self):
+        a = [1]
+        bad_a = [-1]
+        pareto = random.pareto
+        desired = np.array([1.1405622680198362,
+                            1.1465519762044529,
+                            1.0389564467453547])
+
+        self.set_seed()
+        actual = pareto(a * 3)
+        assert_array_almost_equal(actual, desired, decimal=14)
+        assert_raises(ValueError, pareto, bad_a * 3)
+        assert_raises(ValueError, random.pareto, bad_a * 3)
+
+    def test_weibull(self):
+        a = [1]
+        bad_a = [-1]
+        weibull = random.weibull
+        desired = np.array([0.76106853658845242,
+                            0.76386282278691653,
+                            0.71243813125891797])
+
+        self.set_seed()
+        actual = weibull(a * 3)
+        assert_array_almost_equal(actual, desired, decimal=14)
+        assert_raises(ValueError, weibull, bad_a * 3)
+        assert_raises(ValueError, random.weibull, bad_a * 3)
+
+    def test_power(self):
+        a = [1]
+        bad_a = [-1]
+        power = random.power
+        desired = np.array([0.53283302478975902,
+                            0.53413660089041659,
+                            0.50955303552646702])
+
+        self.set_seed()
+        actual = power(a * 3)
+        assert_array_almost_equal(actual, desired, decimal=14)
+        assert_raises(ValueError, power, bad_a * 3)
+        assert_raises(ValueError, random.power, bad_a * 3)
+
+    def test_laplace(self):
+        loc = [0]
+        scale = [1]
+        bad_scale = [-1]
+        laplace = random.laplace
+        desired = np.array([0.067921356028507157,
+                            0.070715642226971326,
+                            0.019290950698972624])
+
+        self.set_seed()
+        actual = laplace(loc * 3, scale)
+        assert_array_almost_equal(actual, desired, decimal=14)
+        assert_raises(ValueError, laplace, loc * 3, bad_scale)
+
+        self.set_seed()
+        actual = laplace(loc, scale * 3)
+        assert_array_almost_equal(actual, desired, decimal=14)
+        assert_raises(ValueError, laplace, loc, bad_scale * 3)
+
+    def test_gumbel(self):
+        loc = [0]
+        scale = [1]
+        bad_scale = [-1]
+        gumbel = random.gumbel
+        desired = np.array([0.2730318639556768,
+                            0.26936705726291116,
+                            0.33906220393037939])
+
+        self.set_seed()
+        actual = gumbel(loc * 3, scale)
+        assert_array_almost_equal(actual, desired, decimal=14)
+        assert_raises(ValueError, gumbel, loc * 3, bad_scale)
+
+        self.set_seed()
+        actual = gumbel(loc, scale * 3)
+        assert_array_almost_equal(actual, desired, decimal=14)
+        assert_raises(ValueError, gumbel, loc, bad_scale * 3)
+
+    def test_logistic(self):
+        loc = [0]
+        scale = [1]
+        bad_scale = [-1]
+        logistic = random.logistic
+        desired = np.array([0.13152135837586171,
+                            0.13675915696285773,
+                            0.038216792802833396])
+
+        self.set_seed()
+        actual = logistic(loc * 3, scale)
+        assert_array_almost_equal(actual, desired, decimal=14)
+        assert_raises(ValueError, logistic, loc * 3, bad_scale)
+
+        self.set_seed()
+        actual = logistic(loc, scale * 3)
+        assert_array_almost_equal(actual, desired, decimal=14)
+        assert_raises(ValueError, logistic, loc, bad_scale * 3)
+        assert_equal(random.logistic(1.0, 0.0), 1.0)
+
+    def test_lognormal(self):
+        mean = [0]
+        sigma = [1]
+        bad_sigma = [-1]
+        lognormal = random.lognormal
+        desired = np.array([9.1422086044848427,
+                            8.4013952870126261,
+                            6.3073234116578671])
+
+        self.set_seed()
+        actual = lognormal(mean * 3, sigma)
+        assert_array_almost_equal(actual, desired, decimal=14)
+        assert_raises(ValueError, lognormal, mean * 3, bad_sigma)
+        assert_raises(ValueError, random.lognormal, mean * 3, bad_sigma)
+
+        self.set_seed()
+        actual = lognormal(mean, sigma * 3)
+        assert_array_almost_equal(actual, desired, decimal=14)
+        assert_raises(ValueError, lognormal, mean, bad_sigma * 3)
+        assert_raises(ValueError, random.lognormal, mean, bad_sigma * 3)
+
+    def test_rayleigh(self):
+        scale = [1]
+        bad_scale = [-1]
+        rayleigh = random.rayleigh
+        desired = np.array([1.2337491937897689,
+                            1.2360119924878694,
+                            1.1936818095781789])
+
+        self.set_seed()
+        actual = rayleigh(scale * 3)
+        assert_array_almost_equal(actual, desired, decimal=14)
+        assert_raises(ValueError, rayleigh, bad_scale * 3)
+
+    def test_wald(self):
+        mean = [0.5]
+        scale = [1]
+        bad_mean = [0]
+        bad_scale = [-2]
+        wald = random.wald
+        desired = np.array([0.11873681120271318,
+                            0.12450084820795027,
+                            0.9096122728408238])
+
+        self.set_seed()
+        actual = wald(mean * 3, scale)
+        assert_array_almost_equal(actual, desired, decimal=14)
+        assert_raises(ValueError, wald, bad_mean * 3, scale)
+        assert_raises(ValueError, wald, mean * 3, bad_scale)
+        assert_raises(ValueError, random.wald, bad_mean * 3, scale)
+        assert_raises(ValueError, random.wald, mean * 3, bad_scale)
+
+        self.set_seed()
+        actual = wald(mean, scale * 3)
+        assert_array_almost_equal(actual, desired, decimal=14)
+        assert_raises(ValueError, wald, bad_mean, scale * 3)
+        assert_raises(ValueError, wald, mean, bad_scale * 3)
+        assert_raises(ValueError, wald, 0.0, 1)
+        assert_raises(ValueError, wald, 0.5, 0.0)
+
+    def test_triangular(self):
+        left = [1]
+        right = [3]
+        mode = [2]
+        bad_left_one = [3]
+        bad_mode_one = [4]
+        bad_left_two, bad_mode_two = right * 2
+        triangular = random.triangular
+        desired = np.array([2.03339048710429,
+                            2.0347400359389356,
+                            2.0095991069536208])
+
+        self.set_seed()
+        actual = triangular(left * 3, mode, right)
+        assert_array_almost_equal(actual, desired, decimal=14)
+        assert_raises(ValueError, triangular, bad_left_one * 3, mode, right)
+        assert_raises(ValueError, triangular, left * 3, bad_mode_one, right)
+        assert_raises(ValueError, triangular, bad_left_two * 3, bad_mode_two,
+                      right)
+
+        self.set_seed()
+        actual = triangular(left, mode * 3, right)
+        assert_array_almost_equal(actual, desired, decimal=14)
+        assert_raises(ValueError, triangular, bad_left_one, mode * 3, right)
+        assert_raises(ValueError, triangular, left, bad_mode_one * 3, right)
+        assert_raises(ValueError, triangular, bad_left_two, bad_mode_two * 3,
+                      right)
+
+        self.set_seed()
+        actual = triangular(left, mode, right * 3)
+        assert_array_almost_equal(actual, desired, decimal=14)
+        assert_raises(ValueError, triangular, bad_left_one, mode, right * 3)
+        assert_raises(ValueError, triangular, left, bad_mode_one, right * 3)
+        assert_raises(ValueError, triangular, bad_left_two, bad_mode_two,
+                      right * 3)
+
+        assert_raises(ValueError, triangular, 10., 0., 20.)
+        assert_raises(ValueError, triangular, 10., 25., 20.)
+        assert_raises(ValueError, triangular, 10., 10., 10.)
+
+    def test_binomial(self):
+        n = [1]
+        p = [0.5]
+        bad_n = [-1]
+        bad_p_one = [-1]
+        bad_p_two = [1.5]
+        binom = random.binomial
+        desired = np.array([1, 1, 1])
+
+        self.set_seed()
+        actual = binom(n * 3, p)
+        assert_array_equal(actual, desired)
+        assert_raises(ValueError, binom, bad_n * 3, p)
+        assert_raises(ValueError, binom, n * 3, bad_p_one)
+        assert_raises(ValueError, binom, n * 3, bad_p_two)
+
+        self.set_seed()
+        actual = binom(n, p * 3)
+        assert_array_equal(actual, desired)
+        assert_raises(ValueError, binom, bad_n, p * 3)
+        assert_raises(ValueError, binom, n, bad_p_one * 3)
+        assert_raises(ValueError, binom, n, bad_p_two * 3)
+
+    def test_negative_binomial(self):
+        n = [1]
+        p = [0.5]
+        bad_n = [-1]
+        bad_p_one = [-1]
+        bad_p_two = [1.5]
+        neg_binom = random.negative_binomial
+        desired = np.array([1, 0, 1])
+
+        self.set_seed()
+        actual = neg_binom(n * 3, p)
+        assert_array_equal(actual, desired)
+        assert_raises(ValueError, neg_binom, bad_n * 3, p)
+        assert_raises(ValueError, neg_binom, n * 3, bad_p_one)
+        assert_raises(ValueError, neg_binom, n * 3, bad_p_two)
+
+        self.set_seed()
+        actual = neg_binom(n, p * 3)
+        assert_array_equal(actual, desired)
+        assert_raises(ValueError, neg_binom, bad_n, p * 3)
+        assert_raises(ValueError, neg_binom, n, bad_p_one * 3)
+        assert_raises(ValueError, neg_binom, n, bad_p_two * 3)
+
+    def test_poisson(self):
+        max_lam = random.RandomState()._poisson_lam_max
+
+        lam = [1]
+        bad_lam_one = [-1]
+        bad_lam_two = [max_lam * 2]
+        poisson = random.poisson
+        desired = np.array([1, 1, 0])
+
+        self.set_seed()
+        actual = poisson(lam * 3)
+        assert_array_equal(actual, desired)
+        assert_raises(ValueError, poisson, bad_lam_one * 3)
+        assert_raises(ValueError, poisson, bad_lam_two * 3)
+
+    def test_zipf(self):
+        a = [2]
+        bad_a = [0]
+        zipf = random.zipf
+        desired = np.array([2, 2, 1])
+
+        self.set_seed()
+        actual = zipf(a * 3)
+        assert_array_equal(actual, desired)
+        assert_raises(ValueError, zipf, bad_a * 3)
+        with np.errstate(invalid='ignore'):
+            assert_raises(ValueError, zipf, np.nan)
+            assert_raises(ValueError, zipf, [0, 0, np.nan])
+
+    def test_geometric(self):
+        p = [0.5]
+        bad_p_one = [-1]
+        bad_p_two = [1.5]
+        geom = random.geometric
+        desired = np.array([2, 2, 2])
+
+        self.set_seed()
+        actual = geom(p * 3)
+        assert_array_equal(actual, desired)
+        assert_raises(ValueError, geom, bad_p_one * 3)
+        assert_raises(ValueError, geom, bad_p_two * 3)
+
+    def test_hypergeometric(self):
+        ngood = [1]
+        nbad = [2]
+        nsample = [2]
+        bad_ngood = [-1]
+        bad_nbad = [-2]
+        bad_nsample_one = [0]
+        bad_nsample_two = [4]
+        hypergeom = random.hypergeometric
+        desired = np.array([1, 1, 1])
+
+        self.set_seed()
+        actual = hypergeom(ngood * 3, nbad, nsample)
+        assert_array_equal(actual, desired)
+        assert_raises(ValueError, hypergeom, bad_ngood * 3, nbad, nsample)
+        assert_raises(ValueError, hypergeom, ngood * 3, bad_nbad, nsample)
+        assert_raises(ValueError, hypergeom, ngood * 3, nbad, bad_nsample_one)
+        assert_raises(ValueError, hypergeom, ngood * 3, nbad, bad_nsample_two)
+
+        self.set_seed()
+        actual = hypergeom(ngood, nbad * 3, nsample)
+        assert_array_equal(actual, desired)
+        assert_raises(ValueError, hypergeom, bad_ngood, nbad * 3, nsample)
+        assert_raises(ValueError, hypergeom, ngood, bad_nbad * 3, nsample)
+        assert_raises(ValueError, hypergeom, ngood, nbad * 3, bad_nsample_one)
+        assert_raises(ValueError, hypergeom, ngood, nbad * 3, bad_nsample_two)
+
+        self.set_seed()
+        actual = hypergeom(ngood, nbad, nsample * 3)
+        assert_array_equal(actual, desired)
+        assert_raises(ValueError, hypergeom, bad_ngood, nbad, nsample * 3)
+        assert_raises(ValueError, hypergeom, ngood, bad_nbad, nsample * 3)
+        assert_raises(ValueError, hypergeom, ngood, nbad, bad_nsample_one * 3)
+        assert_raises(ValueError, hypergeom, ngood, nbad, bad_nsample_two * 3)
+
+        assert_raises(ValueError, hypergeom, -1, 10, 20)
+        assert_raises(ValueError, hypergeom, 10, -1, 20)
+        assert_raises(ValueError, hypergeom, 10, 10, 0)
+        assert_raises(ValueError, hypergeom, 10, 10, 25)
+
+    def test_logseries(self):
+        p = [0.5]
+        bad_p_one = [2]
+        bad_p_two = [-1]
+        logseries = random.logseries
+        desired = np.array([1, 1, 1])
+
+        self.set_seed()
+        actual = logseries(p * 3)
+        assert_array_equal(actual, desired)
+        assert_raises(ValueError, logseries, bad_p_one * 3)
+        assert_raises(ValueError, logseries, bad_p_two * 3)
+
+
+@pytest.mark.skipif(IS_WASM, reason="can't start thread")
+class TestThread:
+    # make sure each state produces the same sequence even in threads
+    def setup_method(self):
+        self.seeds = range(4)
+
+    def check_function(self, function, sz):
+        from threading import Thread
+
+        out1 = np.empty((len(self.seeds),) + sz)
+        out2 = np.empty((len(self.seeds),) + sz)
+
+        # threaded generation
+        t = [Thread(target=function, args=(random.RandomState(s), o))
+             for s, o in zip(self.seeds, out1)]
+        [x.start() for x in t]
+        [x.join() for x in t]
+
+        # the same serial
+        for s, o in zip(self.seeds, out2):
+            function(random.RandomState(s), o)
+
+        # these platforms change x87 fpu precision mode in threads
+        if np.intp().dtype.itemsize == 4 and sys.platform == "win32":
+            assert_array_almost_equal(out1, out2)
+        else:
+            assert_array_equal(out1, out2)
+
+    def test_normal(self):
+        def gen_random(state, out):
+            out[...] = state.normal(size=10000)
+
+        self.check_function(gen_random, sz=(10000,))
+
+    def test_exp(self):
+        def gen_random(state, out):
+            out[...] = state.exponential(scale=np.ones((100, 1000)))
+
+        self.check_function(gen_random, sz=(100, 1000))
+
+    def test_multinomial(self):
+        def gen_random(state, out):
+            out[...] = state.multinomial(10, [1 / 6.] * 6, size=10000)
+
+        self.check_function(gen_random, sz=(10000, 6))
+
+
+# See Issue #4263
+class TestSingleEltArrayInput:
+    def setup_method(self):
+        self.argOne = np.array([2])
+        self.argTwo = np.array([3])
+        self.argThree = np.array([4])
+        self.tgtShape = (1,)
+
+    def test_one_arg_funcs(self):
+        funcs = (random.exponential, random.standard_gamma,
+                 random.chisquare, random.standard_t,
+                 random.pareto, random.weibull,
+                 random.power, random.rayleigh,
+                 random.poisson, random.zipf,
+                 random.geometric, random.logseries)
+
+        probfuncs = (random.geometric, random.logseries)
+
+        for func in funcs:
+            if func in probfuncs:  # p < 1.0
+                out = func(np.array([0.5]))
+
+            else:
+                out = func(self.argOne)
+
+            assert_equal(out.shape, self.tgtShape)
+
+    def test_two_arg_funcs(self):
+        funcs = (random.uniform, random.normal,
+                 random.beta, random.gamma,
+                 random.f, random.noncentral_chisquare,
+                 random.vonmises, random.laplace,
+                 random.gumbel, random.logistic,
+                 random.lognormal, random.wald,
+                 random.binomial, random.negative_binomial)
+
+        probfuncs = (random.binomial, random.negative_binomial)
+
+        for func in funcs:
+            if func in probfuncs:  # p <= 1
+                argTwo = np.array([0.5])
+
+            else:
+                argTwo = self.argTwo
+
+            out = func(self.argOne, argTwo)
+            assert_equal(out.shape, self.tgtShape)
+
+            out = func(self.argOne[0], argTwo)
+            assert_equal(out.shape, self.tgtShape)
+
+            out = func(self.argOne, argTwo[0])
+            assert_equal(out.shape, self.tgtShape)
+
+    def test_three_arg_funcs(self):
+        funcs = [random.noncentral_f, random.triangular,
+                 random.hypergeometric]
+
+        for func in funcs:
+            out = func(self.argOne, self.argTwo, self.argThree)
+            assert_equal(out.shape, self.tgtShape)
+
+            out = func(self.argOne[0], self.argTwo, self.argThree)
+            assert_equal(out.shape, self.tgtShape)
+
+            out = func(self.argOne, self.argTwo[0], self.argThree)
+            assert_equal(out.shape, self.tgtShape)
+
+
+# Ensure returned array dtype is correct for platform
+def test_integer_dtype(int_func):
+    random.seed(123456789)
+    fname, args, sha256 = int_func
+    f = getattr(random, fname)
+    actual = f(*args, size=2)
+    assert_(actual.dtype == np.dtype('l'))
+
+
+def test_integer_repeat(int_func):
+    random.seed(123456789)
+    fname, args, sha256 = int_func
+    f = getattr(random, fname)
+    val = f(*args, size=1000000)
+    if sys.byteorder != 'little':
+        val = val.byteswap()
+    res = hashlib.sha256(val.view(np.int8)).hexdigest()
+    assert_(res == sha256)
+
+
+def test_broadcast_size_error():
+    # GH-16833
+    with pytest.raises(ValueError):
+        random.binomial(1, [0.3, 0.7], size=(2, 1))
+    with pytest.raises(ValueError):
+        random.binomial([1, 2], 0.3, size=(2, 1))
+    with pytest.raises(ValueError):
+        random.binomial([1, 2], [0.3, 0.7], size=(2, 1))
+
+
+def test_randomstate_ctor_old_style_pickle():
+    rs = np.random.RandomState(MT19937(0))
+    rs.standard_normal(1)
+    # Directly call reduce which is used in pickling
+    ctor, args, state_a = rs.__reduce__()
+    # Simulate unpickling an old pickle that only has the name
+    assert args[0].__class__.__name__ == "MT19937"
+    b = ctor(*("MT19937",))
+    b.set_state(state_a)
+    state_b = b.get_state(legacy=False)
+
+    assert_equal(state_a['bit_generator'], state_b['bit_generator'])
+    assert_array_equal(state_a['state']['key'], state_b['state']['key'])
+    assert_array_equal(state_a['state']['pos'], state_b['state']['pos'])
+    assert_equal(state_a['has_gauss'], state_b['has_gauss'])
+    assert_equal(state_a['gauss'], state_b['gauss'])
+
+
+def test_hot_swap(restore_singleton_bitgen):
+    # GH 21808
+    def_bg = np.random.default_rng(0)
+    bg = def_bg.bit_generator
+    np.random.set_bit_generator(bg)
+    assert isinstance(np.random.mtrand._rand._bit_generator, type(bg))
+
+    second_bg = np.random.get_bit_generator()
+    assert bg is second_bg
+
+
+def test_seed_alt_bit_gen(restore_singleton_bitgen):
+    # GH 21808
+    bg = PCG64(0)
+    np.random.set_bit_generator(bg)
+    state = np.random.get_state(legacy=False)
+    np.random.seed(1)
+    new_state = np.random.get_state(legacy=False)
+    print(state)
+    print(new_state)
+    assert state["bit_generator"] == "PCG64"
+    assert state["state"]["state"] != new_state["state"]["state"]
+    assert state["state"]["inc"] != new_state["state"]["inc"]
+
+
+def test_state_error_alt_bit_gen(restore_singleton_bitgen):
+    # GH 21808
+    state = np.random.get_state()
+    bg = PCG64(0)
+    np.random.set_bit_generator(bg)
+    with pytest.raises(ValueError, match="state must be for a PCG64"):
+        np.random.set_state(state)
+
+
+def test_swap_worked(restore_singleton_bitgen):
+    # GH 21808
+    np.random.seed(98765)
+    vals = np.random.randint(0, 2 ** 30, 10)
+    bg = PCG64(0)
+    state = bg.state
+    np.random.set_bit_generator(bg)
+    state_direct = np.random.get_state(legacy=False)
+    for field in state:
+        assert state[field] == state_direct[field]
+    np.random.seed(98765)
+    pcg_vals = np.random.randint(0, 2 ** 30, 10)
+    assert not np.all(vals == pcg_vals)
+    new_state = bg.state
+    assert new_state["state"]["state"] != state["state"]["state"]
+    assert new_state["state"]["inc"] == new_state["state"]["inc"]
+
+
+def test_swapped_singleton_against_direct(restore_singleton_bitgen):
+    np.random.set_bit_generator(PCG64(98765))
+    singleton_vals = np.random.randint(0, 2 ** 30, 10)
+    rg = np.random.RandomState(PCG64(98765))
+    non_singleton_vals = rg.randint(0, 2 ** 30, 10)
+    assert_equal(non_singleton_vals, singleton_vals)
diff --git a/venv/lib/python3.12/site-packages/numpy/random/tests/test_randomstate_regression.py b/venv/lib/python3.12/site-packages/numpy/random/tests/test_randomstate_regression.py
new file mode 100644
index 00000000..3fd8776c
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/random/tests/test_randomstate_regression.py
@@ -0,0 +1,216 @@
+import sys
+
+import pytest
+
+from numpy.testing import (
+    assert_, assert_array_equal, assert_raises,
+    )
+import numpy as np
+
+from numpy import random
+
+
+class TestRegression:
+
+    def test_VonMises_range(self):
+        # Make sure generated random variables are in [-pi, pi].
+        # Regression test for ticket #986.
+        for mu in np.linspace(-7., 7., 5):
+            r = random.vonmises(mu, 1, 50)
+            assert_(np.all(r > -np.pi) and np.all(r <= np.pi))
+
+    def test_hypergeometric_range(self):
+        # Test for ticket #921
+        assert_(np.all(random.hypergeometric(3, 18, 11, size=10) < 4))
+        assert_(np.all(random.hypergeometric(18, 3, 11, size=10) > 0))
+
+        # Test for ticket #5623
+        args = [
+            (2**20 - 2, 2**20 - 2, 2**20 - 2),  # Check for 32-bit systems
+        ]
+        is_64bits = sys.maxsize > 2**32
+        if is_64bits and sys.platform != 'win32':
+            # Check for 64-bit systems
+            args.append((2**40 - 2, 2**40 - 2, 2**40 - 2))
+        for arg in args:
+            assert_(random.hypergeometric(*arg) > 0)
+
+    def test_logseries_convergence(self):
+        # Test for ticket #923
+        N = 1000
+        random.seed(0)
+        rvsn = random.logseries(0.8, size=N)
+        # these two frequency counts should be close to theoretical
+        # numbers with this large sample
+        # theoretical large N result is 0.49706795
+        freq = np.sum(rvsn == 1) / N
+        msg = f'Frequency was {freq:f}, should be > 0.45'
+        assert_(freq > 0.45, msg)
+        # theoretical large N result is 0.19882718
+        freq = np.sum(rvsn == 2) / N
+        msg = f'Frequency was {freq:f}, should be < 0.23'
+        assert_(freq < 0.23, msg)
+
+    def test_shuffle_mixed_dimension(self):
+        # Test for trac ticket #2074
+        for t in [[1, 2, 3, None],
+                  [(1, 1), (2, 2), (3, 3), None],
+                  [1, (2, 2), (3, 3), None],
+                  [(1, 1), 2, 3, None]]:
+            random.seed(12345)
+            shuffled = list(t)
+            random.shuffle(shuffled)
+            expected = np.array([t[0], t[3], t[1], t[2]], dtype=object)
+            assert_array_equal(np.array(shuffled, dtype=object), expected)
+
+    def test_call_within_randomstate(self):
+        # Check that custom RandomState does not call into global state
+        m = random.RandomState()
+        res = np.array([0, 8, 7, 2, 1, 9, 4, 7, 0, 3])
+        for i in range(3):
+            random.seed(i)
+            m.seed(4321)
+            # If m.state is not honored, the result will change
+            assert_array_equal(m.choice(10, size=10, p=np.ones(10)/10.), res)
+
+    def test_multivariate_normal_size_types(self):
+        # Test for multivariate_normal issue with 'size' argument.
+        # Check that the multivariate_normal size argument can be a
+        # numpy integer.
+        random.multivariate_normal([0], [[0]], size=1)
+        random.multivariate_normal([0], [[0]], size=np.int_(1))
+        random.multivariate_normal([0], [[0]], size=np.int64(1))
+
+    def test_beta_small_parameters(self):
+        # Test that beta with small a and b parameters does not produce
+        # NaNs due to roundoff errors causing 0 / 0, gh-5851
+        random.seed(1234567890)
+        x = random.beta(0.0001, 0.0001, size=100)
+        assert_(not np.any(np.isnan(x)), 'Nans in random.beta')
+
+    def test_choice_sum_of_probs_tolerance(self):
+        # The sum of probs should be 1.0 with some tolerance.
+        # For low precision dtypes the tolerance was too tight.
+        # See numpy github issue 6123.
+        random.seed(1234)
+        a = [1, 2, 3]
+        counts = [4, 4, 2]
+        for dt in np.float16, np.float32, np.float64:
+            probs = np.array(counts, dtype=dt) / sum(counts)
+            c = random.choice(a, p=probs)
+            assert_(c in a)
+            assert_raises(ValueError, random.choice, a, p=probs*0.9)
+
+    def test_shuffle_of_array_of_different_length_strings(self):
+        # Test that permuting an array of different length strings
+        # will not cause a segfault on garbage collection
+        # Tests gh-7710
+        random.seed(1234)
+
+        a = np.array(['a', 'a' * 1000])
+
+        for _ in range(100):
+            random.shuffle(a)
+
+        # Force Garbage Collection - should not segfault.
+        import gc
+        gc.collect()
+
+    def test_shuffle_of_array_of_objects(self):
+        # Test that permuting an array of objects will not cause
+        # a segfault on garbage collection.
+        # See gh-7719
+        random.seed(1234)
+        a = np.array([np.arange(1), np.arange(4)], dtype=object)
+
+        for _ in range(1000):
+            random.shuffle(a)
+
+        # Force Garbage Collection - should not segfault.
+        import gc
+        gc.collect()
+
+    def test_permutation_subclass(self):
+        class N(np.ndarray):
+            pass
+
+        random.seed(1)
+        orig = np.arange(3).view(N)
+        perm = random.permutation(orig)
+        assert_array_equal(perm, np.array([0, 2, 1]))
+        assert_array_equal(orig, np.arange(3).view(N))
+
+        class M:
+            a = np.arange(5)
+
+            def __array__(self, dtype=None, copy=None):
+                return self.a
+
+        random.seed(1)
+        m = M()
+        perm = random.permutation(m)
+        assert_array_equal(perm, np.array([2, 1, 4, 0, 3]))
+        assert_array_equal(m.__array__(), np.arange(5))
+
+    def test_warns_byteorder(self):
+        # GH 13159
+        other_byteord_dt = 'i4'
+        with pytest.deprecated_call(match='non-native byteorder is not'):
+            random.randint(0, 200, size=10, dtype=other_byteord_dt)
+
+    def test_named_argument_initialization(self):
+        # GH 13669
+        rs1 = np.random.RandomState(123456789)
+        rs2 = np.random.RandomState(seed=123456789)
+        assert rs1.randint(0, 100) == rs2.randint(0, 100)
+
+    def test_choice_retun_dtype(self):
+        # GH 9867, now long since the NumPy default changed.
+        c = np.random.choice(10, p=[.1]*10, size=2)
+        assert c.dtype == np.dtype(np.long)
+        c = np.random.choice(10, p=[.1]*10, replace=False, size=2)
+        assert c.dtype == np.dtype(np.long)
+        c = np.random.choice(10, size=2)
+        assert c.dtype == np.dtype(np.long)
+        c = np.random.choice(10, replace=False, size=2)
+        assert c.dtype == np.dtype(np.long)
+
+    @pytest.mark.skipif(np.iinfo('l').max < 2**32,
+                        reason='Cannot test with 32-bit C long')
+    def test_randint_117(self):
+        # GH 14189
+        random.seed(0)
+        expected = np.array([2357136044, 2546248239, 3071714933, 3626093760,
+                             2588848963, 3684848379, 2340255427, 3638918503,
+                             1819583497, 2678185683], dtype='int64')
+        actual = random.randint(2**32, size=10)
+        assert_array_equal(actual, expected)
+
+    def test_p_zero_stream(self):
+        # Regression test for gh-14522.  Ensure that future versions
+        # generate the same variates as version 1.16.
+        np.random.seed(12345)
+        assert_array_equal(random.binomial(1, [0, 0.25, 0.5, 0.75, 1]),
+                           [0, 0, 0, 1, 1])
+
+    def test_n_zero_stream(self):
+        # Regression test for gh-14522.  Ensure that future versions
+        # generate the same variates as version 1.16.
+        np.random.seed(8675309)
+        expected = np.array([[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+                             [3, 4, 2, 3, 3, 1, 5, 3, 1, 3]])
+        assert_array_equal(random.binomial([[0], [10]], 0.25, size=(2, 10)),
+                           expected)
+
+
+def test_multinomial_empty():
+    # gh-20483
+    # Ensure that empty p-vals are correctly handled
+    assert random.multinomial(10, []).shape == (0,)
+    assert random.multinomial(3, [], size=(7, 5, 3)).shape == (7, 5, 3, 0)
+
+
+def test_multinomial_1d_pval():
+    # gh-20483
+    with pytest.raises(TypeError, match="pvals must be a 1-d"):
+        random.multinomial(10, 0.3)
diff --git a/venv/lib/python3.12/site-packages/numpy/random/tests/test_regression.py b/venv/lib/python3.12/site-packages/numpy/random/tests/test_regression.py
new file mode 100644
index 00000000..f7b02dc4
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/random/tests/test_regression.py
@@ -0,0 +1,149 @@
+import sys
+from numpy.testing import (
+    assert_, assert_array_equal, assert_raises,
+    )
+from numpy import random
+import numpy as np
+
+
+class TestRegression:
+
+    def test_VonMises_range(self):
+        # Make sure generated random variables are in [-pi, pi].
+        # Regression test for ticket #986.
+        for mu in np.linspace(-7., 7., 5):
+            r = random.mtrand.vonmises(mu, 1, 50)
+            assert_(np.all(r > -np.pi) and np.all(r <= np.pi))
+
+    def test_hypergeometric_range(self):
+        # Test for ticket #921
+        assert_(np.all(np.random.hypergeometric(3, 18, 11, size=10) < 4))
+        assert_(np.all(np.random.hypergeometric(18, 3, 11, size=10) > 0))
+
+        # Test for ticket #5623
+        args = [
+            (2**20 - 2, 2**20 - 2, 2**20 - 2),  # Check for 32-bit systems
+        ]
+        is_64bits = sys.maxsize > 2**32
+        if is_64bits and sys.platform != 'win32':
+            # Check for 64-bit systems
+            args.append((2**40 - 2, 2**40 - 2, 2**40 - 2))
+        for arg in args:
+            assert_(np.random.hypergeometric(*arg) > 0)
+
+    def test_logseries_convergence(self):
+        # Test for ticket #923
+        N = 1000
+        np.random.seed(0)
+        rvsn = np.random.logseries(0.8, size=N)
+        # these two frequency counts should be close to theoretical
+        # numbers with this large sample
+        # theoretical large N result is 0.49706795
+        freq = np.sum(rvsn == 1) / N
+        msg = f'Frequency was {freq:f}, should be > 0.45'
+        assert_(freq > 0.45, msg)
+        # theoretical large N result is 0.19882718
+        freq = np.sum(rvsn == 2) / N
+        msg = f'Frequency was {freq:f}, should be < 0.23'
+        assert_(freq < 0.23, msg)
+
+    def test_shuffle_mixed_dimension(self):
+        # Test for trac ticket #2074
+        for t in [[1, 2, 3, None],
+                  [(1, 1), (2, 2), (3, 3), None],
+                  [1, (2, 2), (3, 3), None],
+                  [(1, 1), 2, 3, None]]:
+            np.random.seed(12345)
+            shuffled = list(t)
+            random.shuffle(shuffled)
+            expected = np.array([t[0], t[3], t[1], t[2]], dtype=object)
+            assert_array_equal(np.array(shuffled, dtype=object), expected)
+
+    def test_call_within_randomstate(self):
+        # Check that custom RandomState does not call into global state
+        m = np.random.RandomState()
+        res = np.array([0, 8, 7, 2, 1, 9, 4, 7, 0, 3])
+        for i in range(3):
+            np.random.seed(i)
+            m.seed(4321)
+            # If m.state is not honored, the result will change
+            assert_array_equal(m.choice(10, size=10, p=np.ones(10)/10.), res)
+
+    def test_multivariate_normal_size_types(self):
+        # Test for multivariate_normal issue with 'size' argument.
+        # Check that the multivariate_normal size argument can be a
+        # numpy integer.
+        np.random.multivariate_normal([0], [[0]], size=1)
+        np.random.multivariate_normal([0], [[0]], size=np.int_(1))
+        np.random.multivariate_normal([0], [[0]], size=np.int64(1))
+
+    def test_beta_small_parameters(self):
+        # Test that beta with small a and b parameters does not produce
+        # NaNs due to roundoff errors causing 0 / 0, gh-5851
+        np.random.seed(1234567890)
+        x = np.random.beta(0.0001, 0.0001, size=100)
+        assert_(not np.any(np.isnan(x)), 'Nans in np.random.beta')
+
+    def test_choice_sum_of_probs_tolerance(self):
+        # The sum of probs should be 1.0 with some tolerance.
+        # For low precision dtypes the tolerance was too tight.
+        # See numpy github issue 6123.
+        np.random.seed(1234)
+        a = [1, 2, 3]
+        counts = [4, 4, 2]
+        for dt in np.float16, np.float32, np.float64:
+            probs = np.array(counts, dtype=dt) / sum(counts)
+            c = np.random.choice(a, p=probs)
+            assert_(c in a)
+            assert_raises(ValueError, np.random.choice, a, p=probs*0.9)
+
+    def test_shuffle_of_array_of_different_length_strings(self):
+        # Test that permuting an array of different length strings
+        # will not cause a segfault on garbage collection
+        # Tests gh-7710
+        np.random.seed(1234)
+
+        a = np.array(['a', 'a' * 1000])
+
+        for _ in range(100):
+            np.random.shuffle(a)
+
+        # Force Garbage Collection - should not segfault.
+        import gc
+        gc.collect()
+
+    def test_shuffle_of_array_of_objects(self):
+        # Test that permuting an array of objects will not cause
+        # a segfault on garbage collection.
+        # See gh-7719
+        np.random.seed(1234)
+        a = np.array([np.arange(1), np.arange(4)], dtype=object)
+
+        for _ in range(1000):
+            np.random.shuffle(a)
+
+        # Force Garbage Collection - should not segfault.
+        import gc
+        gc.collect()
+
+    def test_permutation_subclass(self):
+        class N(np.ndarray):
+            pass
+
+        np.random.seed(1)
+        orig = np.arange(3).view(N)
+        perm = np.random.permutation(orig)
+        assert_array_equal(perm, np.array([0, 2, 1]))
+        assert_array_equal(orig, np.arange(3).view(N))
+
+        class M:
+            a = np.arange(5)
+
+            def __array__(self, dtype=None, copy=None):
+                return self.a
+
+        np.random.seed(1)
+        m = M()
+        perm = np.random.permutation(m)
+        assert_array_equal(perm, np.array([2, 1, 4, 0, 3]))
+        assert_array_equal(m.__array__(), np.arange(5))
diff --git a/venv/lib/python3.12/site-packages/numpy/random/tests/test_seed_sequence.py b/venv/lib/python3.12/site-packages/numpy/random/tests/test_seed_sequence.py
new file mode 100644
index 00000000..f08cf80f
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/random/tests/test_seed_sequence.py
@@ -0,0 +1,80 @@
+import numpy as np
+from numpy.testing import assert_array_equal, assert_array_compare
+
+from numpy.random import SeedSequence
+
+
+def test_reference_data():
+    """ Check that SeedSequence generates data the same as the C++ reference.
+
+    https://gist.github.com/imneme/540829265469e673d045
+    """
+    inputs = [
+        [3735928559, 195939070, 229505742, 305419896],
+        [3668361503, 4165561550, 1661411377, 3634257570],
+        [164546577, 4166754639, 1765190214, 1303880213],
+        [446610472, 3941463886, 522937693, 1882353782],
+        [1864922766, 1719732118, 3882010307, 1776744564],
+        [4141682960, 3310988675, 553637289, 902896340],
+        [1134851934, 2352871630, 3699409824, 2648159817],
+        [1240956131, 3107113773, 1283198141, 1924506131],
+        [2669565031, 579818610, 3042504477, 2774880435],
+        [2766103236, 2883057919, 4029656435, 862374500],
+    ]
+    outputs = [
+        [3914649087, 576849849, 3593928901, 2229911004],
+        [2240804226, 3691353228, 1365957195, 2654016646],
+        [3562296087, 3191708229, 1147942216, 3726991905],
+        [1403443605, 3591372999, 1291086759, 441919183],
+        [1086200464, 2191331643, 560336446, 3658716651],
+        [3249937430, 2346751812, 847844327, 2996632307],
+        [2584285912, 4034195531, 3523502488, 169742686],
+        [959045797, 3875435559, 1886309314, 359682705],
+        [3978441347, 432478529, 3223635119, 138903045],
+        [296367413, 4262059219, 13109864, 3283683422],
+    ]
+    outputs64 = [
+        [2477551240072187391, 9577394838764454085],
+        [15854241394484835714, 11398914698975566411],
+        [13708282465491374871, 16007308345579681096],
+        [15424829579845884309, 1898028439751125927],
+        [9411697742461147792, 15714068361935982142],
+        [10079222287618677782, 12870437757549876199],
+        [17326737873898640088, 729039288628699544],
+        [16644868984619524261, 1544825456798124994],
+        [1857481142255628931, 596584038813451439],
+        [18305404959516669237, 14103312907920476776],
+    ]
+    for seed, expected, expected64 in zip(inputs, outputs, outputs64):
+        expected = np.array(expected, dtype=np.uint32)
+        ss = SeedSequence(seed)
+        state = ss.generate_state(len(expected))
+        assert_array_equal(state, expected)
+        state64 = ss.generate_state(len(expected64), dtype=np.uint64)
+        assert_array_equal(state64, expected64)
+
+
+def test_zero_padding():
+    """ Ensure that the implicit zero-padding does not cause problems.
+    """
+    # Ensure that large integers are inserted in little-endian fashion to avoid
+    # trailing 0s.
+    ss0 = SeedSequence(42)
+    ss1 = SeedSequence(42 << 32)
+    assert_array_compare(
+        np.not_equal,
+        ss0.generate_state(4),
+        ss1.generate_state(4))
+
+    # Ensure backwards compatibility with the original 0.17 release for small
+    # integers and no spawn key.
+    expected42 = np.array([3444837047, 2669555309, 2046530742, 3581440988],
+                          dtype=np.uint32)
+    assert_array_equal(SeedSequence(42).generate_state(4), expected42)
+
+    # Regression test for gh-16539 to ensure that the implicit 0s don't
+    # conflict with spawn keys.
+    assert_array_compare(
+        np.not_equal,
+        SeedSequence(42, spawn_key=(0,)).generate_state(4),
+        expected42)
diff --git a/venv/lib/python3.12/site-packages/numpy/random/tests/test_smoke.py b/venv/lib/python3.12/site-packages/numpy/random/tests/test_smoke.py
new file mode 100644
index 00000000..b402e873
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/random/tests/test_smoke.py
@@ -0,0 +1,818 @@
+import pickle
+from functools import partial
+
+import numpy as np
+import pytest
+from numpy.testing import assert_equal, assert_, assert_array_equal
+from numpy.random import (Generator, MT19937, PCG64, PCG64DXSM, Philox, SFC64)
+
+@pytest.fixture(scope='module',
+                params=(np.bool, np.int8, np.int16, np.int32, np.int64,
+                        np.uint8, np.uint16, np.uint32, np.uint64))
+def dtype(request):
+    return request.param
+
+
+def params_0(f):
+    val = f()
+    assert_(np.isscalar(val))
+    val = f(10)
+    assert_(val.shape == (10,))
+    val = f((10, 10))
+    assert_(val.shape == (10, 10))
+    val = f((10, 10, 10))
+    assert_(val.shape == (10, 10, 10))
+    val = f(size=(5, 5))
+    assert_(val.shape == (5, 5))
+
+
+def params_1(f, bounded=False):
+    a = 5.0
+    b = np.arange(2.0, 12.0)
+    c = np.arange(2.0, 102.0).reshape((10, 10))
+    d = np.arange(2.0, 1002.0).reshape((10, 10, 10))
+    e = np.array([2.0, 3.0])
+    g = np.arange(2.0, 12.0).reshape((1, 10, 1))
+    if bounded:
+        a = 0.5
+        b = b / (1.5 * b.max())
+        c = c / (1.5 * c.max())
+        d = d / (1.5 * d.max())
+        e = e / (1.5 * e.max())
+        g = g / (1.5 * g.max())
+
+    # Scalar
+    f(a)
+    # Scalar - size
+    f(a, size=(10, 10))
+    # 1d
+    f(b)
+    # 2d
+    f(c)
+    # 3d
+    f(d)
+    # 1d size
+    f(b, size=10)
+    # 2d - size - broadcast
+    f(e, size=(10, 2))
+    # 3d - size
+    f(g, size=(10, 10, 10))
+
+
+def comp_state(state1, state2):
+    identical = True
+    if isinstance(state1, dict):
+        for key in state1:
+            identical &= comp_state(state1[key], state2[key])
+    elif type(state1) != type(state2):
+        identical &= type(state1) == type(state2)
+    else:
+        if (isinstance(state1, (list, tuple, np.ndarray)) and isinstance(
+                state2, (list, tuple, np.ndarray))):
+            for s1, s2 in zip(state1, state2):
+                identical &= comp_state(s1, s2)
+        else:
+            identical &= state1 == state2
+    return identical
+
+
+def warmup(rg, n=None):
+    if n is None:
+        n = 11 + np.random.randint(0, 20)
+    rg.standard_normal(n)
+    rg.standard_normal(n)
+    rg.standard_normal(n, dtype=np.float32)
+    rg.standard_normal(n, dtype=np.float32)
+    rg.integers(0, 2 ** 24, n, dtype=np.uint64)
+    rg.integers(0, 2 ** 48, n, dtype=np.uint64)
+    rg.standard_gamma(11.0, n)
+    rg.standard_gamma(11.0, n, dtype=np.float32)
+    rg.random(n, dtype=np.float64)
+    rg.random(n, dtype=np.float32)
+
+
+class RNG:
+    @classmethod
+    def setup_class(cls):
+        # Overridden in test classes. Place holder to silence IDE noise
+        cls.bit_generator = PCG64
+        cls.advance = None
+        cls.seed = [12345]
+        cls.rg = Generator(cls.bit_generator(*cls.seed))
+        cls.initial_state = cls.rg.bit_generator.state
+        cls.seed_vector_bits = 64
+        cls._extra_setup()
+
+    @classmethod
+    def _extra_setup(cls):
+        cls.vec_1d = np.arange(2.0, 102.0)
+        cls.vec_2d = np.arange(2.0, 102.0)[None, :]
+        cls.mat = np.arange(2.0, 102.0, 0.01).reshape((100, 100))
+        cls.seed_error = TypeError
+
+    def _reset_state(self):
+        self.rg.bit_generator.state = self.initial_state
+
+    def test_init(self):
+        rg = Generator(self.bit_generator())
+        state = rg.bit_generator.state
+        rg.standard_normal(1)
+        rg.standard_normal(1)
+        rg.bit_generator.state = state
+        new_state = rg.bit_generator.state
+        assert_(comp_state(state, new_state))
+
+    def test_advance(self):
+        state = self.rg.bit_generator.state
+        if hasattr(self.rg.bit_generator, 'advance'):
+            self.rg.bit_generator.advance(self.advance)
+            assert_(not comp_state(state, self.rg.bit_generator.state))
+        else:
+            bitgen_name = self.rg.bit_generator.__class__.__name__
+            pytest.skip(f'Advance is not supported by {bitgen_name}')
+
+    def test_jump(self):
+        state = self.rg.bit_generator.state
+        if hasattr(self.rg.bit_generator, 'jumped'):
+            bit_gen2 = self.rg.bit_generator.jumped()
+            jumped_state = bit_gen2.state
+            assert_(not comp_state(state, jumped_state))
+            self.rg.random(2 * 3 * 5 * 7 * 11 * 13 * 17)
+            self.rg.bit_generator.state = state
+            bit_gen3 = self.rg.bit_generator.jumped()
+            rejumped_state = bit_gen3.state
+            assert_(comp_state(jumped_state, rejumped_state))
+        else:
+            bitgen_name = self.rg.bit_generator.__class__.__name__
+            if bitgen_name not in ('SFC64',):
+                raise AttributeError(f'no "jumped" in {bitgen_name}')
+            pytest.skip(f'Jump is not supported by {bitgen_name}')
+
+    def test_uniform(self):
+        r = self.rg.uniform(-1.0, 0.0, size=10)
+        assert_(len(r) == 10)
+        assert_((r > -1).all())
+        assert_((r <= 0).all())
+
+    def test_uniform_array(self):
+        r = self.rg.uniform(np.array([-1.0] * 10), 0.0, size=10)
+        assert_(len(r) == 10)
+        assert_((r > -1).all())
+        assert_((r <= 0).all())
+        r = self.rg.uniform(np.array([-1.0] * 10),
+                            np.array([0.0] * 10), size=10)
+        assert_(len(r) == 10)
+        assert_((r > -1).all())
+        assert_((r <= 0).all())
+        r = self.rg.uniform(-1.0, np.array([0.0] * 10), size=10)
+        assert_(len(r) == 10)
+        assert_((r > -1).all())
+        assert_((r <= 0).all())
+
+    def test_random(self):
+        assert_(len(self.rg.random(10)) == 10)
+        params_0(self.rg.random)
+
+    def test_standard_normal_zig(self):
+        assert_(len(self.rg.standard_normal(10)) == 10)
+
+    def test_standard_normal(self):
+        assert_(len(self.rg.standard_normal(10)) == 10)
+        params_0(self.rg.standard_normal)
+
+    def test_standard_gamma(self):
+        assert_(len(self.rg.standard_gamma(10, 10)) == 10)
+        assert_(len(self.rg.standard_gamma(np.array([10] * 10), 10)) == 10)
+        params_1(self.rg.standard_gamma)
+
+    def test_standard_exponential(self):
+        assert_(len(self.rg.standard_exponential(10)) == 10)
+        params_0(self.rg.standard_exponential)
+
+    def test_standard_exponential_float(self):
+        randoms = self.rg.standard_exponential(10, dtype='float32')
+        assert_(len(randoms) == 10)
+        assert randoms.dtype == np.float32
+        params_0(partial(self.rg.standard_exponential, dtype='float32'))
+
+    def test_standard_exponential_float_log(self):
+        randoms = self.rg.standard_exponential(10, dtype='float32',
+                                               method='inv')
+        assert_(len(randoms) == 10)
+        assert randoms.dtype == np.float32
+        params_0(partial(self.rg.standard_exponential, dtype='float32',
+                         method='inv'))
+
+    def test_standard_cauchy(self):
+        assert_(len(self.rg.standard_cauchy(10)) == 10)
+        params_0(self.rg.standard_cauchy)
+
+    def test_standard_t(self):
+        assert_(len(self.rg.standard_t(10, 10)) == 10)
+        params_1(self.rg.standard_t)
+
+    def test_binomial(self):
+        assert_(self.rg.binomial(10, .5) >= 0)
+        assert_(self.rg.binomial(1000, .5) >= 0)
+
+    def test_reset_state(self):
+        state = self.rg.bit_generator.state
+        int_1 = self.rg.integers(2**31)
+        self.rg.bit_generator.state = state
+        int_2 = self.rg.integers(2**31)
+        assert_(int_1 == int_2)
+
+    def test_entropy_init(self):
+        rg = Generator(self.bit_generator())
+        rg2 = Generator(self.bit_generator())
+        assert_(not comp_state(rg.bit_generator.state,
+                               rg2.bit_generator.state))
+
+    def test_seed(self):
+        rg = Generator(self.bit_generator(*self.seed))
+        rg2 = Generator(self.bit_generator(*self.seed))
+        rg.random()
+        rg2.random()
+        assert_(comp_state(rg.bit_generator.state, rg2.bit_generator.state))
+
+    def test_reset_state_gauss(self):
+        rg = Generator(self.bit_generator(*self.seed))
+        rg.standard_normal()
+        state = rg.bit_generator.state
+        n1 = rg.standard_normal(size=10)
+        rg2 = Generator(self.bit_generator())
+        rg2.bit_generator.state = state
+        n2 = rg2.standard_normal(size=10)
+        assert_array_equal(n1, n2)
+
+    def test_reset_state_uint32(self):
+        rg = Generator(self.bit_generator(*self.seed))
+        rg.integers(0, 2 ** 24, 120, dtype=np.uint32)
+        state = rg.bit_generator.state
+        n1 = rg.integers(0, 2 ** 24, 10, dtype=np.uint32)
+        rg2 = Generator(self.bit_generator())
+        rg2.bit_generator.state = state
+        n2 = rg2.integers(0, 2 ** 24, 10, dtype=np.uint32)
+        assert_array_equal(n1, n2)
+
+    def test_reset_state_float(self):
+        rg = Generator(self.bit_generator(*self.seed))
+        rg.random(dtype='float32')
+        state = rg.bit_generator.state
+        n1 = rg.random(size=10, dtype='float32')
+        rg2 = Generator(self.bit_generator())
+        rg2.bit_generator.state = state
+        n2 = rg2.random(size=10, dtype='float32')
+        assert_((n1 == n2).all())
+
+    def test_shuffle(self):
+        original = np.arange(200, 0, -1)
+        permuted = self.rg.permutation(original)
+        assert_((original != permuted).any())
+
+    def test_permutation(self):
+        original = np.arange(200, 0, -1)
+        permuted = self.rg.permutation(original)
+        assert_((original != permuted).any())
+
+    def test_beta(self):
+        vals = self.rg.beta(2.0, 2.0, 10)
+        assert_(len(vals) == 10)
+        vals = self.rg.beta(np.array([2.0] * 10), 2.0)
+        assert_(len(vals) == 10)
+        vals = self.rg.beta(2.0, np.array([2.0] * 10))
+        assert_(len(vals) == 10)
+        vals = self.rg.beta(np.array([2.0] * 10), np.array([2.0] * 10))
+        assert_(len(vals) == 10)
+        vals = self.rg.beta(np.array([2.0] * 10), np.array([[2.0]] * 10))
+        assert_(vals.shape == (10, 10))
+
+    def test_bytes(self):
+        vals = self.rg.bytes(10)
+        assert_(len(vals) == 10)
+
+    def test_chisquare(self):
+        vals = self.rg.chisquare(2.0, 10)
+        assert_(len(vals) == 10)
+        params_1(self.rg.chisquare)
+
+    def test_exponential(self):
+        vals = self.rg.exponential(2.0, 10)
+        assert_(len(vals) == 10)
+        params_1(self.rg.exponential)
+
+    def test_f(self):
+        vals = self.rg.f(3, 1000, 10)
+        assert_(len(vals) == 10)
+
+    def test_gamma(self):
+        vals = self.rg.gamma(3, 2, 10)
+        assert_(len(vals) == 10)
+
+    def test_geometric(self):
+        vals = self.rg.geometric(0.5, 10)
+        assert_(len(vals) == 10)
+        params_1(self.rg.exponential, bounded=True)
+
+    def test_gumbel(self):
+        vals = self.rg.gumbel(2.0, 2.0, 10)
+        assert_(len(vals) == 10)
+
+    def test_laplace(self):
+        vals = self.rg.laplace(2.0, 2.0, 10)
+        assert_(len(vals) == 10)
+
+    def test_logitic(self):
+        vals = self.rg.logistic(2.0, 2.0, 10)
+        assert_(len(vals) == 10)
+
+    def test_logseries(self):
+        vals = self.rg.logseries(0.5, 10)
+        assert_(len(vals) == 10)
+
+    def test_negative_binomial(self):
+        vals = self.rg.negative_binomial(10, 0.2, 10)
+        assert_(len(vals) == 10)
+
+    def test_noncentral_chisquare(self):
+        vals = self.rg.noncentral_chisquare(10, 2, 10)
+        assert_(len(vals) == 10)
+
+    def test_noncentral_f(self):
+        vals = self.rg.noncentral_f(3, 1000, 2, 10)
+        assert_(len(vals) == 10)
+        vals = self.rg.noncentral_f(np.array([3] * 10), 1000, 2)
+        assert_(len(vals) == 10)
+        vals = self.rg.noncentral_f(3, np.array([1000] * 10), 2)
+        assert_(len(vals) == 10)
+        vals = self.rg.noncentral_f(3, 1000, np.array([2] * 10))
+        assert_(len(vals) == 10)
+
+    def test_normal(self):
+        vals = self.rg.normal(10, 0.2, 10)
+        assert_(len(vals) == 10)
+
+    def test_pareto(self):
+        vals = self.rg.pareto(3.0, 10)
+        assert_(len(vals) == 10)
+
+    def test_poisson(self):
+        vals = self.rg.poisson(10, 10)
+        assert_(len(vals) == 10)
+        vals = self.rg.poisson(np.array([10] * 10))
+        assert_(len(vals) == 10)
+        params_1(self.rg.poisson)
+
+    def test_power(self):
+        vals = self.rg.power(0.2, 10)
+        assert_(len(vals) == 10)
+
+    def test_integers(self):
+        vals = self.rg.integers(10, 20, 10)
+        assert_(len(vals) == 10)
+
+    def test_rayleigh(self):
+        vals = self.rg.rayleigh(0.2, 10)
+        assert_(len(vals) == 10)
+        params_1(self.rg.rayleigh, bounded=True)
+
+    def test_vonmises(self):
+        vals = self.rg.vonmises(10, 0.2, 10)
+        assert_(len(vals) == 10)
+
+    def test_wald(self):
+        vals = self.rg.wald(1.0, 1.0, 10)
+        assert_(len(vals) == 10)
+
+    def test_weibull(self):
+        vals = self.rg.weibull(1.0, 10)
+        assert_(len(vals) == 10)
+
+    def test_zipf(self):
+        vals = self.rg.zipf(10, 10)
+        assert_(len(vals) == 10)
+        vals = self.rg.zipf(self.vec_1d)
+        assert_(len(vals) == 100)
+        vals = self.rg.zipf(self.vec_2d)
+        assert_(vals.shape == (1, 100))
+        vals = self.rg.zipf(self.mat)
+        assert_(vals.shape == (100, 100))
+
+    def test_hypergeometric(self):
+        vals = self.rg.hypergeometric(25, 25, 20)
+        assert_(np.isscalar(vals))
+        vals = self.rg.hypergeometric(np.array([25] * 10), 25, 20)
+        assert_(vals.shape == (10,))
+
+    def test_triangular(self):
+        vals = self.rg.triangular(-5, 0, 5)
+        assert_(np.isscalar(vals))
+        vals = self.rg.triangular(-5, np.array([0] * 10), 5)
+        assert_(vals.shape == (10,))
+
+    def test_multivariate_normal(self):
+        mean = [0, 0]
+        cov = [[1, 0], [0, 100]]  # diagonal covariance
+        x = self.rg.multivariate_normal(mean, cov, 5000)
+        assert_(x.shape == (5000, 2))
+        x_zig = self.rg.multivariate_normal(mean, cov, 5000)
+        assert_(x.shape == (5000, 2))
+        x_inv = self.rg.multivariate_normal(mean, cov, 5000)
+        assert_(x.shape == (5000, 2))
+        assert_((x_zig != x_inv).any())
+
+    def test_multinomial(self):
+        vals = self.rg.multinomial(100, [1.0 / 3, 2.0 / 3])
+        assert_(vals.shape == (2,))
+        vals = self.rg.multinomial(100, [1.0 / 3, 2.0 / 3], size=10)
+        assert_(vals.shape == (10, 2))
+
+    def test_dirichlet(self):
+        s = self.rg.dirichlet((10, 5, 3), 20)
+        assert_(s.shape == (20, 3))
+
+    def test_pickle(self):
+        pick = pickle.dumps(self.rg)
+        unpick = pickle.loads(pick)
+        assert_(type(self.rg) == type(unpick))
+        assert_(comp_state(self.rg.bit_generator.state,
+                           unpick.bit_generator.state))
+
+        pick = pickle.dumps(self.rg)
+        unpick = pickle.loads(pick)
+        assert_(type(self.rg) == type(unpick))
+        assert_(comp_state(self.rg.bit_generator.state,
+                           unpick.bit_generator.state))
+
+    def test_seed_array(self):
+        if self.seed_vector_bits is None:
+            bitgen_name = self.bit_generator.__name__
+            pytest.skip(f'Vector seeding is not supported by {bitgen_name}')
+
+        if self.seed_vector_bits == 32:
+            dtype = np.uint32
+        else:
+            dtype = np.uint64
+        seed = np.array([1], dtype=dtype)
+        bg = self.bit_generator(seed)
+        state1 = bg.state
+        bg = self.bit_generator(1)
+        state2 = bg.state
+        assert_(comp_state(state1, state2))
+
+        seed = np.arange(4, dtype=dtype)
+        bg = self.bit_generator(seed)
+        state1 = bg.state
+        bg = self.bit_generator(seed[0])
+        state2 = bg.state
+        assert_(not comp_state(state1, state2))
+
+        seed = np.arange(1500, dtype=dtype)
+        bg = self.bit_generator(seed)
+        state1 = bg.state
+        bg = self.bit_generator(seed[0])
+        state2 = bg.state
+        assert_(not comp_state(state1, state2))
+
+        seed = 2 ** np.mod(np.arange(1500, dtype=dtype),
+                           self.seed_vector_bits - 1) + 1
+        bg = self.bit_generator(seed)
+        state1 = bg.state
+        bg  = self.bit_generator(seed[0])
+        state2 = bg.state
+        assert_(not comp_state(state1, state2))
+
+    def test_uniform_float(self):
+        rg = Generator(self.bit_generator(12345))
+        warmup(rg)
+        state = rg.bit_generator.state
+        r1 = rg.random(11, dtype=np.float32)
+        rg2 = Generator(self.bit_generator())
+        warmup(rg2)
+        rg2.bit_generator.state = state
+        r2 = rg2.random(11, dtype=np.float32)
+        assert_array_equal(r1, r2)
+        assert_equal(r1.dtype, np.float32)
+        assert_(comp_state(rg.bit_generator.state, rg2.bit_generator.state))
+
+    def test_gamma_floats(self):
+        rg = Generator(self.bit_generator())
+        warmup(rg)
+        state = rg.bit_generator.state
+        r1 = rg.standard_gamma(4.0, 11, dtype=np.float32)
+        rg2 = Generator(self.bit_generator())
+        warmup(rg2)
+        rg2.bit_generator.state = state
+        r2 = rg2.standard_gamma(4.0, 11, dtype=np.float32)
+        assert_array_equal(r1, r2)
+        assert_equal(r1.dtype, np.float32)
+        assert_(comp_state(rg.bit_generator.state, rg2.bit_generator.state))
+
+    def test_normal_floats(self):
+        rg = Generator(self.bit_generator())
+        warmup(rg)
+        state = rg.bit_generator.state
+        r1 = rg.standard_normal(11, dtype=np.float32)
+        rg2 = Generator(self.bit_generator())
+        warmup(rg2)
+        rg2.bit_generator.state = state
+        r2 = rg2.standard_normal(11, dtype=np.float32)
+        assert_array_equal(r1, r2)
+        assert_equal(r1.dtype, np.float32)
+        assert_(comp_state(rg.bit_generator.state, rg2.bit_generator.state))
+
+    def test_normal_zig_floats(self):
+        rg = Generator(self.bit_generator())
+        warmup(rg)
+        state = rg.bit_generator.state
+        r1 = rg.standard_normal(11, dtype=np.float32)
+        rg2 = Generator(self.bit_generator())
+        warmup(rg2)
+        rg2.bit_generator.state = state
+        r2 = rg2.standard_normal(11, dtype=np.float32)
+        assert_array_equal(r1, r2)
+        assert_equal(r1.dtype, np.float32)
+        assert_(comp_state(rg.bit_generator.state, rg2.bit_generator.state))
+
+    def test_output_fill(self):
+        rg = self.rg
+        state = rg.bit_generator.state
+        size = (31, 7, 97)
+        existing = np.empty(size)
+        rg.bit_generator.state = state
+        rg.standard_normal(out=existing)
+        rg.bit_generator.state = state
+        direct = rg.standard_normal(size=size)
+        assert_equal(direct, existing)
+
+        sized = np.empty(size)
+        rg.bit_generator.state = state
+        rg.standard_normal(out=sized, size=sized.shape)
+
+        existing = np.empty(size, dtype=np.float32)
+        rg.bit_generator.state = state
+        rg.standard_normal(out=existing, dtype=np.float32)
+        rg.bit_generator.state = state
+        direct = rg.standard_normal(size=size, dtype=np.float32)
+        assert_equal(direct, existing)
+
+    def test_output_filling_uniform(self):
+        rg = self.rg
+        state = rg.bit_generator.state
+        size = (31, 7, 97)
+        existing = np.empty(size)
+        rg.bit_generator.state = state
+        rg.random(out=existing)
+        rg.bit_generator.state = state
+        direct = rg.random(size=size)
+        assert_equal(direct, existing)
+
+        existing = np.empty(size, dtype=np.float32)
+        rg.bit_generator.state = state
+        rg.random(out=existing, dtype=np.float32)
+        rg.bit_generator.state = state
+        direct = rg.random(size=size, dtype=np.float32)
+        assert_equal(direct, existing)
+
+    def test_output_filling_exponential(self):
+        rg = self.rg
+        state = rg.bit_generator.state
+        size = (31, 7, 97)
+        existing = np.empty(size)
+        rg.bit_generator.state = state
+        rg.standard_exponential(out=existing)
+        rg.bit_generator.state = state
+        direct = rg.standard_exponential(size=size)
+        assert_equal(direct, existing)
+
+        existing = np.empty(size, dtype=np.float32)
+        rg.bit_generator.state = state
+        rg.standard_exponential(out=existing, dtype=np.float32)
+        rg.bit_generator.state = state
+        direct = rg.standard_exponential(size=size, dtype=np.float32)
+        assert_equal(direct, existing)
+
+    def test_output_filling_gamma(self):
+        rg = self.rg
+        state = rg.bit_generator.state
+        size = (31, 7, 97)
+        existing = np.zeros(size)
+        rg.bit_generator.state = state
+        rg.standard_gamma(1.0, out=existing)
+        rg.bit_generator.state = state
+        direct = rg.standard_gamma(1.0, size=size)
+        assert_equal(direct, existing)
+
+        existing = np.zeros(size, dtype=np.float32)
+        rg.bit_generator.state = state
+        rg.standard_gamma(1.0, out=existing, dtype=np.float32)
+        rg.bit_generator.state = state
+        direct = rg.standard_gamma(1.0, size=size, dtype=np.float32)
+        assert_equal(direct, existing)
+
+    def test_output_filling_gamma_broadcast(self):
+        rg = self.rg
+        state = rg.bit_generator.state
+        size = (31, 7, 97)
+        mu = np.arange(97.0) + 1.0
+        existing = np.zeros(size)
+        rg.bit_generator.state = state
+        rg.standard_gamma(mu, out=existing)
+        rg.bit_generator.state = state
+        direct = rg.standard_gamma(mu, size=size)
+        assert_equal(direct, existing)
+
+        existing = np.zeros(size, dtype=np.float32)
+        rg.bit_generator.state = state
+        rg.standard_gamma(mu, out=existing, dtype=np.float32)
+        rg.bit_generator.state = state
+        direct = rg.standard_gamma(mu, size=size, dtype=np.float32)
+        assert_equal(direct, existing)
+
+    def test_output_fill_error(self):
+        rg = self.rg
+        size = (31, 7, 97)
+        existing = np.empty(size)
+        with pytest.raises(TypeError):
+            rg.standard_normal(out=existing, dtype=np.float32)
+        with pytest.raises(ValueError):
+            rg.standard_normal(out=existing[::3])
+        existing = np.empty(size, dtype=np.float32)
+        with pytest.raises(TypeError):
+            rg.standard_normal(out=existing, dtype=np.float64)
+
+        existing = np.zeros(size, dtype=np.float32)
+        with pytest.raises(TypeError):
+            rg.standard_gamma(1.0, out=existing, dtype=np.float64)
+        with pytest.raises(ValueError):
+            rg.standard_gamma(1.0, out=existing[::3], dtype=np.float32)
+        existing = np.zeros(size, dtype=np.float64)
+        with pytest.raises(TypeError):
+            rg.standard_gamma(1.0, out=existing, dtype=np.float32)
+        with pytest.raises(ValueError):
+            rg.standard_gamma(1.0, out=existing[::3])
+
+    def test_integers_broadcast(self, dtype):
+        if dtype == np.bool:
+            upper = 2
+            lower = 0
+        else:
+            info = np.iinfo(dtype)
+            upper = int(info.max) + 1
+            lower = info.min
+        self._reset_state()
+        a = self.rg.integers(lower, [upper] * 10, dtype=dtype)
+        self._reset_state()
+        b = self.rg.integers([lower] * 10, upper, dtype=dtype)
+        assert_equal(a, b)
+        self._reset_state()
+        c = self.rg.integers(lower, upper, size=10, dtype=dtype)
+        assert_equal(a, c)
+        self._reset_state()
+        d = self.rg.integers(np.array(
+            [lower] * 10), np.array([upper], dtype=object), size=10,
+            dtype=dtype)
+        assert_equal(a, d)
+        self._reset_state()
+        e = self.rg.integers(
+            np.array([lower] * 10), np.array([upper] * 10), size=10,
+            dtype=dtype)
+        assert_equal(a, e)
+
+        self._reset_state()
+        a = self.rg.integers(0, upper, size=10, dtype=dtype)
+        self._reset_state()
+        b = self.rg.integers([upper] * 10, dtype=dtype)
+        assert_equal(a, b)
+
+    def test_integers_numpy(self, dtype):
+        high = np.array([1])
+        low = np.array([0])
+
+        out = self.rg.integers(low, high, dtype=dtype)
+        assert out.shape == (1,)
+
+        out = self.rg.integers(low[0], high, dtype=dtype)
+        assert out.shape == (1,)
+
+        out = self.rg.integers(low, high[0], dtype=dtype)
+        assert out.shape == (1,)
+
+    def test_integers_broadcast_errors(self, dtype):
+        if dtype == np.bool:
+            upper = 2
+            lower = 0
+        else:
+            info = np.iinfo(dtype)
+            upper = int(info.max) + 1
+            lower = info.min
+        with pytest.raises(ValueError):
+            self.rg.integers(lower, [upper + 1] * 10, dtype=dtype)
+        with pytest.raises(ValueError):
+            self.rg.integers(lower - 1, [upper] * 10, dtype=dtype)
+        with pytest.raises(ValueError):
+            self.rg.integers([lower - 1], [upper] * 10, dtype=dtype)
+        with pytest.raises(ValueError):
+            self.rg.integers([0], [0], dtype=dtype)
+
+
+class TestMT19937(RNG):
+    @classmethod
+    def setup_class(cls):
+        cls.bit_generator = MT19937
+        cls.advance = None
+        cls.seed = [2 ** 21 + 2 ** 16 + 2 ** 5 + 1]
+        cls.rg = Generator(cls.bit_generator(*cls.seed))
+        cls.initial_state = cls.rg.bit_generator.state
+        cls.seed_vector_bits = 32
+        cls._extra_setup()
+        cls.seed_error = ValueError
+
+    def test_numpy_state(self):
+        nprg = np.random.RandomState()
+        nprg.standard_normal(99)
+        state = nprg.get_state()
+        self.rg.bit_generator.state = state
+        state2 = self.rg.bit_generator.state
+        assert_((state[1] == state2['state']['key']).all())
+        assert_(state[2] == state2['state']['pos'])
+
+
+class TestPhilox(RNG):
+    @classmethod
+    def setup_class(cls):
+        cls.bit_generator = Philox
+        cls.advance = 2**63 + 2**31 + 2**15 + 1
+        cls.seed = [12345]
+        cls.rg = Generator(cls.bit_generator(*cls.seed))
+        cls.initial_state = cls.rg.bit_generator.state
+        cls.seed_vector_bits = 64
+        cls._extra_setup()
+
+
+class TestSFC64(RNG):
+    @classmethod
+    def setup_class(cls):
+        cls.bit_generator = SFC64
+        cls.advance = None
+        cls.seed = [12345]
+        cls.rg = Generator(cls.bit_generator(*cls.seed))
+        cls.initial_state = cls.rg.bit_generator.state
+        cls.seed_vector_bits = 192
+        cls._extra_setup()
+
+
+class TestPCG64(RNG):
+    @classmethod
+    def setup_class(cls):
+        cls.bit_generator = PCG64
+        cls.advance = 2**63 + 2**31 + 2**15 + 1
+        cls.seed = [12345]
+        cls.rg = Generator(cls.bit_generator(*cls.seed))
+        cls.initial_state = cls.rg.bit_generator.state
+        cls.seed_vector_bits = 64
+        cls._extra_setup()
+
+
+class TestPCG64DXSM(RNG):
+    @classmethod
+    def setup_class(cls):
+        cls.bit_generator = PCG64DXSM
+        cls.advance = 2**63 + 2**31 + 2**15 + 1
+        cls.seed = [12345]
+        cls.rg = Generator(cls.bit_generator(*cls.seed))
+        cls.initial_state = cls.rg.bit_generator.state
+        cls.seed_vector_bits = 64
+        cls._extra_setup()
+
+
+class TestDefaultRNG(RNG):
+    @classmethod
+    def setup_class(cls):
+        # This will duplicate some tests that directly instantiate a fresh
+        # Generator(), but that's okay.
+        cls.bit_generator = PCG64
+        cls.advance = 2**63 + 2**31 + 2**15 + 1
+        cls.seed = [12345]
+        cls.rg = np.random.default_rng(*cls.seed)
+        cls.initial_state = cls.rg.bit_generator.state
+        cls.seed_vector_bits = 64
+        cls._extra_setup()
+
+    def test_default_is_pcg64(self):
+        # In order to change the default BitGenerator, we'll go through
+        # a deprecation cycle to move to a different function.
+        assert_(isinstance(self.rg.bit_generator, PCG64))
+
+    def test_seed(self):
+        np.random.default_rng()
+        np.random.default_rng(None)
+        np.random.default_rng(12345)
+        np.random.default_rng(0)
+        np.random.default_rng(43660444402423911716352051725018508569)
+        np.random.default_rng([43660444402423911716352051725018508569,
+                               279705150948142787361475340226491943209])
+        with pytest.raises(ValueError):
+            np.random.default_rng(-1)
+        with pytest.raises(ValueError):
+            np.random.default_rng([12345, -1])
diff --git a/venv/lib/python3.12/site-packages/numpy/rec/__init__.py b/venv/lib/python3.12/site-packages/numpy/rec/__init__.py
new file mode 100644
index 00000000..1a439ada
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/rec/__init__.py
@@ -0,0 +1,2 @@
+from numpy._core.records import __all__, __doc__
+from numpy._core.records import *
diff --git a/venv/lib/python3.12/site-packages/numpy/rec/__init__.pyi b/venv/lib/python3.12/site-packages/numpy/rec/__init__.pyi
new file mode 100644
index 00000000..776db577
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/rec/__init__.pyi
@@ -0,0 +1,13 @@
+from numpy._core.records import (
+    record as record,
+    recarray as recarray,
+    format_parser as format_parser,
+    fromarrays as fromarrays,
+    fromrecords as fromrecords,
+    fromstring as fromstring,
+    fromfile as fromfile,
+    array as array
+)
+
+__all__: list[str]
+__path__: list[str]
diff --git a/venv/lib/python3.12/site-packages/numpy/rec/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/rec/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 00000000..dae57abe
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/rec/__pycache__/__init__.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/strings/__init__.py b/venv/lib/python3.12/site-packages/numpy/strings/__init__.py
new file mode 100644
index 00000000..f370ba71
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/strings/__init__.py
@@ -0,0 +1,2 @@
+from numpy._core.strings import __all__, __doc__
+from numpy._core.strings import *
diff --git a/venv/lib/python3.12/site-packages/numpy/strings/__init__.pyi b/venv/lib/python3.12/site-packages/numpy/strings/__init__.pyi
new file mode 100644
index 00000000..927b0c9b
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/strings/__init__.pyi
@@ -0,0 +1,53 @@
+from numpy._core.strings import (
+    equal as equal,
+    not_equal as not_equal,
+    greater_equal as greater_equal,
+    less_equal as less_equal,
+    greater as greater,
+    less as less,
+    add as add,
+    multiply as multiply,
+    mod as mod,
+    isalpha as isalpha,
+    isalnum as isalnum,
+    isdigit as isdigit,
+    isspace as isspace,
+    isnumeric as isnumeric,
+    isdecimal as isdecimal,
+    islower as islower,
+    isupper as isupper,
+    istitle as istitle,
+    str_len as str_len,
+    find as find,
+    rfind as rfind,
+    index as index,
+    rindex as rindex,
+    count as count,
+    startswith as startswith,
+    endswith as endswith,
+    decode as decode,
+    encode as encode,
+    expandtabs as expandtabs,
+    center as center,
+    ljust as ljust,
+    rjust as rjust,
+    lstrip as lstrip,
+    rstrip as rstrip,
+    strip as strip,
+    zfill as zfill,
+    upper as upper,
+    lower as lower,
+    swapcase as swapcase,
+    capitalize as capitalize,
+    title as title,
+    replace as replace,
+    join as join,
+    split as split,
+    rsplit as rsplit,
+    splitlines as splitlines,
+    partition as partition,
+    rpartition as rpartition,
+    translate as translate,
+)
+
+__all__: list[str]
diff --git a/venv/lib/python3.12/site-packages/numpy/strings/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/strings/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 00000000..2cbddd52
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/strings/__pycache__/__init__.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/testing/__init__.py b/venv/lib/python3.12/site-packages/numpy/testing/__init__.py
new file mode 100644
index 00000000..8a34221e
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/testing/__init__.py
@@ -0,0 +1,22 @@
+"""Common test support for all numpy test scripts.
+
+This single module should provide all the common functionality for numpy tests
+in a single location, so that test scripts can just import it and work right
+away.
+
+"""
+from unittest import TestCase
+
+from . import _private
+from ._private.utils import *
+from ._private.utils import (_assert_valid_refcount, _gen_alignment_data)
+from ._private import extbuild
+from . import overrides
+
+__all__ = (
+    _private.utils.__all__ + ['TestCase', 'overrides']
+)
+
+from numpy._pytesttester import PytestTester
+test = PytestTester(__name__)
+del PytestTester
diff --git a/venv/lib/python3.12/site-packages/numpy/testing/__init__.pyi b/venv/lib/python3.12/site-packages/numpy/testing/__init__.pyi
new file mode 100644
index 00000000..2e4f7647
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/testing/__init__.pyi
@@ -0,0 +1,49 @@
+from numpy._pytesttester import PytestTester
+
+from unittest import (
+    TestCase as TestCase,
+)
+
+from numpy.testing._private.utils import (
+    assert_equal as assert_equal,
+    assert_almost_equal as assert_almost_equal,
+    assert_approx_equal as assert_approx_equal,
+    assert_array_equal as assert_array_equal,
+    assert_array_less as assert_array_less,
+    assert_string_equal as assert_string_equal,
+    assert_array_almost_equal as assert_array_almost_equal,
+    assert_raises as assert_raises,
+    build_err_msg as build_err_msg,
+    decorate_methods as decorate_methods,
+    jiffies as jiffies,
+    memusage as memusage,
+    print_assert_equal as print_assert_equal,
+    rundocs as rundocs,
+    runstring as runstring,
+    verbose as verbose,
+    measure as measure,
+    assert_ as assert_,
+    assert_array_almost_equal_nulp as assert_array_almost_equal_nulp,
+    assert_raises_regex as assert_raises_regex,
+    assert_array_max_ulp as assert_array_max_ulp,
+    assert_warns as assert_warns,
+    assert_no_warnings as assert_no_warnings,
+    assert_allclose as assert_allclose,
+    IgnoreException as IgnoreException,
+    clear_and_catch_warnings as clear_and_catch_warnings,
+    SkipTest as SkipTest,
+    KnownFailureException as KnownFailureException,
+    temppath as temppath,
+    tempdir as tempdir,
+    IS_PYPY as IS_PYPY,
+    IS_PYSTON as IS_PYSTON,
+    HAS_REFCOUNT as HAS_REFCOUNT,
+    suppress_warnings as suppress_warnings,
+    assert_array_compare as assert_array_compare,
+    assert_no_gc_cycles as assert_no_gc_cycles,
+    break_cycles as break_cycles,
+    HAS_LAPACK64 as HAS_LAPACK64,
+)
+
+__all__: list[str]
+test: PytestTester
diff --git a/venv/lib/python3.12/site-packages/numpy/testing/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/testing/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 00000000..09b5d974
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/testing/__pycache__/__init__.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/testing/__pycache__/overrides.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/testing/__pycache__/overrides.cpython-312.pyc
new file mode 100644
index 00000000..b136a8a4
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/testing/__pycache__/overrides.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/testing/__pycache__/print_coercion_tables.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/testing/__pycache__/print_coercion_tables.cpython-312.pyc
new file mode 100644
index 00000000..a15526f3
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/testing/__pycache__/print_coercion_tables.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/testing/_private/__init__.py b/venv/lib/python3.12/site-packages/numpy/testing/_private/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/venv/lib/python3.12/site-packages/numpy/testing/_private/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/testing/_private/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 00000000..a3c4bc68
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/testing/_private/__pycache__/__init__.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/testing/_private/__pycache__/extbuild.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/testing/_private/__pycache__/extbuild.cpython-312.pyc
new file mode 100644
index 00000000..fe5f3f15
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/testing/_private/__pycache__/extbuild.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/testing/_private/__pycache__/utils.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/testing/_private/__pycache__/utils.cpython-312.pyc
new file mode 100644
index 00000000..7066cc08
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/testing/_private/__pycache__/utils.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/testing/_private/extbuild.py b/venv/lib/python3.12/site-packages/numpy/testing/_private/extbuild.py
new file mode 100644
index 00000000..08cbb056
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/testing/_private/extbuild.py
@@ -0,0 +1,252 @@
+"""
+Build a c-extension module on-the-fly in tests.
+See build_and_import_extensions for usage hints
+
+"""
+
+import os
+import pathlib
+import subprocess
+import sys
+import sysconfig
+import textwrap
+
+__all__ = ['build_and_import_extension', 'compile_extension_module']
+
+
+def build_and_import_extension(
+        modname, functions, *, prologue="", build_dir=None,
+        include_dirs=[], more_init=""):
+    """
+    Build and imports a c-extension module `modname` from a list of function
+    fragments `functions`.
+
+
+    Parameters
+    ----------
+    functions : list of fragments
+        Each fragment is a sequence of func_name, calling convention, snippet.
+    prologue : string
+        Code to precede the rest, usually extra ``#include`` or ``#define``
+        macros.
+    build_dir : pathlib.Path
+        Where to build the module, usually a temporary directory
+    include_dirs : list
+        Extra directories to find include files when compiling
+    more_init : string
+        Code to appear in the module PyMODINIT_FUNC
+
+    Returns
+    -------
+    out: module
+        The module will have been loaded and is ready for use
+
+    Examples
+    --------
+    >>> functions = [("test_bytes", "METH_O", \"\"\"
+        if ( !PyBytesCheck(args)) {
+            Py_RETURN_FALSE;
+        }
+        Py_RETURN_TRUE;
+    \"\"\")]
+    >>> mod = build_and_import_extension("testme", functions)
+    >>> assert not mod.test_bytes('abc')
+    >>> assert mod.test_bytes(b'abc')
+    """
+    body = prologue + _make_methods(functions, modname)
+    init = """
+    PyObject *mod = PyModule_Create(&moduledef);
+    #ifdef Py_GIL_DISABLED
+    PyUnstable_Module_SetGIL(mod, Py_MOD_GIL_NOT_USED);
+    #endif
+           """
+    if not build_dir:
+        build_dir = pathlib.Path('.')
+    if more_init:
+        init += """#define INITERROR return NULL
+                """
+        init += more_init
+    init += "\nreturn mod;"
+    source_string = _make_source(modname, init, body)
+    try:
+        mod_so = compile_extension_module(
+            modname, build_dir, include_dirs, source_string)
+    except Exception as e:
+        # shorten the exception chain
+        raise RuntimeError(f"could not compile in {build_dir}:") from e
+    import importlib.util
+    spec = importlib.util.spec_from_file_location(modname, mod_so)
+    foo = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(foo)
+    return foo
+
+
+def compile_extension_module(
+        name, builddir, include_dirs,
+        source_string, libraries=[], library_dirs=[]):
+    """
+    Build an extension module and return the filename of the resulting
+    native code file.
+
+    Parameters
+    ----------
+    name : string
+        name of the module, possibly including dots if it is a module inside a
+        package.
+    builddir : pathlib.Path
+        Where to build the module, usually a temporary directory
+    include_dirs : list
+        Extra directories to find include files when compiling
+    libraries : list
+        Libraries to link into the extension module
+    library_dirs: list
+        Where to find the libraries, ``-L`` passed to the linker
+    """
+    modname = name.split('.')[-1]
+    dirname = builddir / name
+    dirname.mkdir(exist_ok=True)
+    cfile = _convert_str_to_file(source_string, dirname)
+    include_dirs = include_dirs + [sysconfig.get_config_var('INCLUDEPY')]
+
+    return _c_compile(
+        cfile, outputfilename=dirname / modname,
+        include_dirs=include_dirs, libraries=[], library_dirs=[],
+        )
+
+
+def _convert_str_to_file(source, dirname):
+    """Helper function to create a file ``source.c`` in `dirname` that contains
+    the string in `source`. Returns the file name
+    """
+    filename = dirname / 'source.c'
+    with filename.open('w') as f:
+        f.write(str(source))
+    return filename
+
+
+def _make_methods(functions, modname):
+    """ Turns the name, signature, code in functions into complete functions
+    and lists them in a methods_table. Then turns the methods_table into a
+    ``PyMethodDef`` structure and returns the resulting code fragment ready
+    for compilation
+    """
+    methods_table = []
+    codes = []
+    for funcname, flags, code in functions:
+        cfuncname = "%s_%s" % (modname, funcname)
+        if 'METH_KEYWORDS' in flags:
+            signature = '(PyObject *self, PyObject *args, PyObject *kwargs)'
+        else:
+            signature = '(PyObject *self, PyObject *args)'
+        methods_table.append(
+            "{\"%s\", (PyCFunction)%s, %s}," % (funcname, cfuncname, flags))
+        func_code = """
+        static PyObject* {cfuncname}{signature}
+        {{
+        {code}
+        }}
+        """.format(cfuncname=cfuncname, signature=signature, code=code)
+        codes.append(func_code)
+
+    body = "\n".join(codes) + """
+    static PyMethodDef methods[] = {
+    %(methods)s
+    { NULL }
+    };
+    static struct PyModuleDef moduledef = {
+        PyModuleDef_HEAD_INIT,
+        "%(modname)s",  /* m_name */
+        NULL,           /* m_doc */
+        -1,             /* m_size */
+        methods,        /* m_methods */
+    };
+    """ % dict(methods='\n'.join(methods_table), modname=modname)
+    return body
+
+
+def _make_source(name, init, body):
+    """ Combines the code fragments into source code ready to be compiled
+    """
+    code = """
+    #include 
+
+    %(body)s
+
+    PyMODINIT_FUNC
+    PyInit_%(name)s(void) {
+    %(init)s
+    }
+    """ % dict(
+        name=name, init=init, body=body,
+    )
+    return code
+
+
+def _c_compile(cfile, outputfilename, include_dirs=[], libraries=[],
+               library_dirs=[]):
+    if sys.platform == 'win32':
+        compile_extra = ["/we4013"]
+        link_extra = ["/LIBPATH:" + os.path.join(sys.base_prefix, 'libs')]
+    elif sys.platform.startswith('linux'):
+        compile_extra = [
+            "-O0", "-g", "-Werror=implicit-function-declaration", "-fPIC"]
+        link_extra = []
+    else:
+        compile_extra = link_extra = []
+        pass
+    if sys.platform == 'win32':
+        link_extra = link_extra + ['/DEBUG']  # generate .pdb file
+    if sys.platform == 'darwin':
+        # support Fink & Darwinports
+        for s in ('/sw/', '/opt/local/'):
+            if (s + 'include' not in include_dirs
+                    and os.path.exists(s + 'include')):
+                include_dirs.append(s + 'include')
+            if s + 'lib' not in library_dirs and os.path.exists(s + 'lib'):
+                library_dirs.append(s + 'lib')
+
+    outputfilename = outputfilename.with_suffix(get_so_suffix())
+    build(
+        cfile, outputfilename,
+        compile_extra, link_extra,
+        include_dirs, libraries, library_dirs)
+    return outputfilename
+
+
+def build(cfile, outputfilename, compile_extra, link_extra,
+          include_dirs, libraries, library_dirs):
+    "use meson to build"
+
+    build_dir = cfile.parent / "build"
+    os.makedirs(build_dir, exist_ok=True)
+    so_name = outputfilename.parts[-1]
+    with open(cfile.parent / "meson.build", "wt") as fid:
+        includes = ['-I' + d for d in include_dirs]
+        link_dirs = ['-L' + d for d in library_dirs]
+        fid.write(textwrap.dedent(f"""\
+            project('foo', 'c')
+            shared_module('{so_name}', '{cfile.parts[-1]}',
+                c_args: {includes} + {compile_extra},
+                link_args: {link_dirs} + {link_extra},
+                link_with: {libraries},
+                name_prefix: '',
+                name_suffix: 'dummy',
+            )
+        """))
+    if sys.platform == "win32":
+        subprocess.check_call(["meson", "setup",
+                               "--buildtype=release", 
+                               "--vsenv", ".."],
+                              cwd=build_dir,
+                              )
+    else:
+        subprocess.check_call(["meson", "setup", "--vsenv", ".."],
+                              cwd=build_dir
+                              )
+    subprocess.check_call(["meson", "compile"], cwd=build_dir)
+    os.rename(str(build_dir / so_name) + ".dummy", cfile.parent / so_name)
+        
+def get_so_suffix():
+    ret = sysconfig.get_config_var('EXT_SUFFIX')
+    assert ret
+    return ret
diff --git a/venv/lib/python3.12/site-packages/numpy/testing/_private/utils.py b/venv/lib/python3.12/site-packages/numpy/testing/_private/utils.py
new file mode 100644
index 00000000..5133ef7b
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/testing/_private/utils.py
@@ -0,0 +1,2714 @@
+"""
+Utility function to facilitate testing.
+
+"""
+import os
+import sys
+import platform
+import re
+import gc
+import operator
+import warnings
+from functools import partial, wraps
+import shutil
+import contextlib
+from tempfile import mkdtemp, mkstemp
+from unittest.case import SkipTest
+from warnings import WarningMessage
+import pprint
+import sysconfig
+import concurrent.futures
+
+import numpy as np
+from numpy._core import (
+     intp, float32, empty, arange, array_repr, ndarray, isnat, array)
+from numpy import isfinite, isnan, isinf
+import numpy.linalg._umath_linalg
+from numpy._utils import _rename_parameter
+
+from io import StringIO
+
+__all__ = [
+        'assert_equal', 'assert_almost_equal', 'assert_approx_equal',
+        'assert_array_equal', 'assert_array_less', 'assert_string_equal',
+        'assert_array_almost_equal', 'assert_raises', 'build_err_msg',
+        'decorate_methods', 'jiffies', 'memusage', 'print_assert_equal',
+        'rundocs', 'runstring', 'verbose', 'measure',
+        'assert_', 'assert_array_almost_equal_nulp', 'assert_raises_regex',
+        'assert_array_max_ulp', 'assert_warns', 'assert_no_warnings',
+        'assert_allclose', 'IgnoreException', 'clear_and_catch_warnings',
+        'SkipTest', 'KnownFailureException', 'temppath', 'tempdir', 'IS_PYPY',
+        'HAS_REFCOUNT', "IS_WASM", 'suppress_warnings', 'assert_array_compare',
+        'assert_no_gc_cycles', 'break_cycles', 'HAS_LAPACK64', 'IS_PYSTON',
+        '_OLD_PROMOTION', 'IS_MUSL', 'check_support_sve', 'NOGIL_BUILD',
+        'IS_EDITABLE', 'run_threaded',
+        ]
+
+
+class KnownFailureException(Exception):
+    '''Raise this exception to mark a test as a known failing test.'''
+    pass
+
+
+KnownFailureTest = KnownFailureException  # backwards compat
+verbose = 0
+
+IS_WASM = platform.machine() in ["wasm32", "wasm64"]
+IS_PYPY = sys.implementation.name == 'pypy'
+IS_PYSTON = hasattr(sys, "pyston_version_info")
+IS_EDITABLE = not bool(np.__path__) or 'editable' in np.__path__[0]
+HAS_REFCOUNT = getattr(sys, 'getrefcount', None) is not None and not IS_PYSTON
+HAS_LAPACK64 = numpy.linalg._umath_linalg._ilp64
+
+_OLD_PROMOTION = lambda: np._get_promotion_state() == 'legacy'
+
+IS_MUSL = False
+# alternate way is
+# from packaging.tags import sys_tags
+#     _tags = list(sys_tags())
+#     if 'musllinux' in _tags[0].platform:
+_v = sysconfig.get_config_var('HOST_GNU_TYPE') or ''
+if 'musl' in _v:
+    IS_MUSL = True
+
+NOGIL_BUILD = bool(sysconfig.get_config_var("Py_GIL_DISABLED"))
+
+def assert_(val, msg=''):
+    """
+    Assert that works in release mode.
+    Accepts callable msg to allow deferring evaluation until failure.
+
+    The Python built-in ``assert`` does not work when executing code in
+    optimized mode (the ``-O`` flag) - no byte-code is generated for it.
+
+    For documentation on usage, refer to the Python documentation.
+
+    """
+    __tracebackhide__ = True  # Hide traceback for py.test
+    if not val:
+        try:
+            smsg = msg()
+        except TypeError:
+            smsg = msg
+        raise AssertionError(smsg)
+
+
+if os.name == 'nt':
+    # Code "stolen" from enthought/debug/memusage.py
+    def GetPerformanceAttributes(object, counter, instance=None,
+                                 inum=-1, format=None, machine=None):
+        # NOTE: Many counters require 2 samples to give accurate results,
+        # including "% Processor Time" (as by definition, at any instant, a
+        # thread's CPU usage is either 0 or 100).  To read counters like this,
+        # you should copy this function, but keep the counter open, and call
+        # CollectQueryData() each time you need to know.
+        # See http://msdn.microsoft.com/library/en-us/dnperfmo/html/perfmonpt2.asp (dead link)
+        # My older explanation for this was that the "AddCounter" process
+        # forced the CPU to 100%, but the above makes more sense :)
+        import win32pdh
+        if format is None:
+            format = win32pdh.PDH_FMT_LONG
+        path = win32pdh.MakeCounterPath( (machine, object, instance, None,
+                                          inum, counter))
+        hq = win32pdh.OpenQuery()
+        try:
+            hc = win32pdh.AddCounter(hq, path)
+            try:
+                win32pdh.CollectQueryData(hq)
+                type, val = win32pdh.GetFormattedCounterValue(hc, format)
+                return val
+            finally:
+                win32pdh.RemoveCounter(hc)
+        finally:
+            win32pdh.CloseQuery(hq)
+
+    def memusage(processName="python", instance=0):
+        # from win32pdhutil, part of the win32all package
+        import win32pdh
+        return GetPerformanceAttributes("Process", "Virtual Bytes",
+                                        processName, instance,
+                                        win32pdh.PDH_FMT_LONG, None)
+elif sys.platform[:5] == 'linux':
+
+    def memusage(_proc_pid_stat=f'/proc/{os.getpid()}/stat'):
+        """
+        Return virtual memory size in bytes of the running python.
+
+        """
+        try:
+            with open(_proc_pid_stat) as f:
+                l = f.readline().split(' ')
+            return int(l[22])
+        except Exception:
+            return
+else:
+    def memusage():
+        """
+        Return memory usage of running python. [Not implemented]
+
+        """
+        raise NotImplementedError
+
+
+if sys.platform[:5] == 'linux':
+    def jiffies(_proc_pid_stat=f'/proc/{os.getpid()}/stat', _load_time=[]):
+        """
+        Return number of jiffies elapsed.
+
+        Return number of jiffies (1/100ths of a second) that this
+        process has been scheduled in user mode. See man 5 proc.
+
+        """
+        import time
+        if not _load_time:
+            _load_time.append(time.time())
+        try:
+            with open(_proc_pid_stat) as f:
+                l = f.readline().split(' ')
+            return int(l[13])
+        except Exception:
+            return int(100*(time.time()-_load_time[0]))
+else:
+    # os.getpid is not in all platforms available.
+    # Using time is safe but inaccurate, especially when process
+    # was suspended or sleeping.
+    def jiffies(_load_time=[]):
+        """
+        Return number of jiffies elapsed.
+
+        Return number of jiffies (1/100ths of a second) that this
+        process has been scheduled in user mode. See man 5 proc.
+
+        """
+        import time
+        if not _load_time:
+            _load_time.append(time.time())
+        return int(100*(time.time()-_load_time[0]))
+
+
+def build_err_msg(arrays, err_msg, header='Items are not equal:',
+                  verbose=True, names=('ACTUAL', 'DESIRED'), precision=8):
+    msg = ['\n' + header]
+    err_msg = str(err_msg)
+    if err_msg:
+        if err_msg.find('\n') == -1 and len(err_msg) < 79-len(header):
+            msg = [msg[0] + ' ' + err_msg]
+        else:
+            msg.append(err_msg)
+    if verbose:
+        for i, a in enumerate(arrays):
+
+            if isinstance(a, ndarray):
+                # precision argument is only needed if the objects are ndarrays
+                r_func = partial(array_repr, precision=precision)
+            else:
+                r_func = repr
+
+            try:
+                r = r_func(a)
+            except Exception as exc:
+                r = f'[repr failed for <{type(a).__name__}>: {exc}]'
+            if r.count('\n') > 3:
+                r = '\n'.join(r.splitlines()[:3])
+                r += '...'
+            msg.append(f' {names[i]}: {r}')
+    return '\n'.join(msg)
+
+
+def assert_equal(actual, desired, err_msg='', verbose=True, *, strict=False):
+    """
+    Raises an AssertionError if two objects are not equal.
+
+    Given two objects (scalars, lists, tuples, dictionaries or numpy arrays),
+    check that all elements of these objects are equal. An exception is raised
+    at the first conflicting values.
+
+    This function handles NaN comparisons as if NaN was a "normal" number.
+    That is, AssertionError is not raised if both objects have NaNs in the same
+    positions.  This is in contrast to the IEEE standard on NaNs, which says
+    that NaN compared to anything must return False.
+
+    Parameters
+    ----------
+    actual : array_like
+        The object to check.
+    desired : array_like
+        The expected object.
+    err_msg : str, optional
+        The error message to be printed in case of failure.
+    verbose : bool, optional
+        If True, the conflicting values are appended to the error message.
+    strict : bool, optional
+        If True and either of the `actual` and `desired` arguments is an array,
+        raise an ``AssertionError`` when either the shape or the data type of
+        the arguments does not match. If neither argument is an array, this
+        parameter has no effect.
+
+        .. versionadded:: 2.0.0
+
+    Raises
+    ------
+    AssertionError
+        If actual and desired are not equal.
+
+    See Also
+    --------
+    assert_allclose
+    assert_array_almost_equal_nulp,
+    assert_array_max_ulp,
+
+    Notes
+    -----
+    By default, when one of `actual` and `desired` is a scalar and the other is
+    an array, the function checks that each element of the array is equal to
+    the scalar. This behaviour can be disabled by setting ``strict==True``.
+
+    Examples
+    --------
+    >>> np.testing.assert_equal([4, 5], [4, 6])
+    Traceback (most recent call last):
+        ...
+    AssertionError:
+    Items are not equal:
+    item=1
+     ACTUAL: 5
+     DESIRED: 6
+
+    The following comparison does not raise an exception.  There are NaNs
+    in the inputs, but they are in the same positions.
+
+    >>> np.testing.assert_equal(np.array([1.0, 2.0, np.nan]), [1, 2, np.nan])
+
+    As mentioned in the Notes section, `assert_equal` has special
+    handling for scalars when one of the arguments is an array.
+    Here, the test checks that each value in `x` is 3:
+
+    >>> x = np.full((2, 5), fill_value=3)
+    >>> np.testing.assert_equal(x, 3)
+
+    Use `strict` to raise an AssertionError when comparing a scalar with an
+    array of a different shape:
+
+    >>> np.testing.assert_equal(x, 3, strict=True)
+    Traceback (most recent call last):
+        ...
+    AssertionError:
+    Arrays are not equal
+    
+    (shapes (2, 5), () mismatch)
+     ACTUAL: array([[3, 3, 3, 3, 3],
+           [3, 3, 3, 3, 3]])
+     DESIRED: array(3)
+
+    The `strict` parameter also ensures that the array data types match:
+
+    >>> x = np.array([2, 2, 2])
+    >>> y = np.array([2., 2., 2.], dtype=np.float32)
+    >>> np.testing.assert_equal(x, y, strict=True)
+    Traceback (most recent call last):
+        ...
+    AssertionError:
+    Arrays are not equal
+    
+    (dtypes int64, float32 mismatch)
+     ACTUAL: array([2, 2, 2])
+     DESIRED: array([2., 2., 2.], dtype=float32)
+    """
+    __tracebackhide__ = True  # Hide traceback for py.test
+    if isinstance(desired, dict):
+        if not isinstance(actual, dict):
+            raise AssertionError(repr(type(actual)))
+        assert_equal(len(actual), len(desired), err_msg, verbose)
+        for k, i in desired.items():
+            if k not in actual:
+                raise AssertionError(repr(k))
+            assert_equal(actual[k], desired[k], f'key={k!r}\n{err_msg}',
+                         verbose)
+        return
+    if isinstance(desired, (list, tuple)) and isinstance(actual, (list, tuple)):
+        assert_equal(len(actual), len(desired), err_msg, verbose)
+        for k in range(len(desired)):
+            assert_equal(actual[k], desired[k], f'item={k!r}\n{err_msg}',
+                         verbose)
+        return
+    from numpy._core import ndarray, isscalar, signbit
+    from numpy import iscomplexobj, real, imag
+    if isinstance(actual, ndarray) or isinstance(desired, ndarray):
+        return assert_array_equal(actual, desired, err_msg, verbose,
+                                  strict=strict)
+    msg = build_err_msg([actual, desired], err_msg, verbose=verbose)
+
+    # Handle complex numbers: separate into real/imag to handle
+    # nan/inf/negative zero correctly
+    # XXX: catch ValueError for subclasses of ndarray where iscomplex fail
+    try:
+        usecomplex = iscomplexobj(actual) or iscomplexobj(desired)
+    except (ValueError, TypeError):
+        usecomplex = False
+
+    if usecomplex:
+        if iscomplexobj(actual):
+            actualr = real(actual)
+            actuali = imag(actual)
+        else:
+            actualr = actual
+            actuali = 0
+        if iscomplexobj(desired):
+            desiredr = real(desired)
+            desiredi = imag(desired)
+        else:
+            desiredr = desired
+            desiredi = 0
+        try:
+            assert_equal(actualr, desiredr)
+            assert_equal(actuali, desiredi)
+        except AssertionError:
+            raise AssertionError(msg)
+
+    # isscalar test to check cases such as [np.nan] != np.nan
+    if isscalar(desired) != isscalar(actual):
+        raise AssertionError(msg)
+
+    try:
+        isdesnat = isnat(desired)
+        isactnat = isnat(actual)
+        dtypes_match = (np.asarray(desired).dtype.type ==
+                        np.asarray(actual).dtype.type)
+        if isdesnat and isactnat:
+            # If both are NaT (and have the same dtype -- datetime or
+            # timedelta) they are considered equal.
+            if dtypes_match:
+                return
+            else:
+                raise AssertionError(msg)
+
+    except (TypeError, ValueError, NotImplementedError):
+        pass
+
+    # Inf/nan/negative zero handling
+    try:
+        isdesnan = isnan(desired)
+        isactnan = isnan(actual)
+        if isdesnan and isactnan:
+            return  # both nan, so equal
+
+        # handle signed zero specially for floats
+        array_actual = np.asarray(actual)
+        array_desired = np.asarray(desired)
+        if (array_actual.dtype.char in 'Mm' or
+                array_desired.dtype.char in 'Mm'):
+            # version 1.18
+            # until this version, isnan failed for datetime64 and timedelta64.
+            # Now it succeeds but comparison to scalar with a different type
+            # emits a DeprecationWarning.
+            # Avoid that by skipping the next check
+            raise NotImplementedError('cannot compare to a scalar '
+                                      'with a different type')
+
+        if desired == 0 and actual == 0:
+            if not signbit(desired) == signbit(actual):
+                raise AssertionError(msg)
+
+    except (TypeError, ValueError, NotImplementedError):
+        pass
+
+    try:
+        # Explicitly use __eq__ for comparison, gh-2552
+        if not (desired == actual):
+            raise AssertionError(msg)
+
+    except (DeprecationWarning, FutureWarning) as e:
+        # this handles the case when the two types are not even comparable
+        if 'elementwise == comparison' in e.args[0]:
+            raise AssertionError(msg)
+        else:
+            raise
+
+
+def print_assert_equal(test_string, actual, desired):
+    """
+    Test if two objects are equal, and print an error message if test fails.
+
+    The test is performed with ``actual == desired``.
+
+    Parameters
+    ----------
+    test_string : str
+        The message supplied to AssertionError.
+    actual : object
+        The object to test for equality against `desired`.
+    desired : object
+        The expected result.
+
+    Examples
+    --------
+    >>> np.testing.print_assert_equal('Test XYZ of func xyz', [0, 1], [0, 1])
+    >>> np.testing.print_assert_equal('Test XYZ of func xyz', [0, 1], [0, 2])
+    Traceback (most recent call last):
+    ...
+    AssertionError: Test XYZ of func xyz failed
+    ACTUAL:
+    [0, 1]
+    DESIRED:
+    [0, 2]
+
+    """
+    __tracebackhide__ = True  # Hide traceback for py.test
+    import pprint
+
+    if not (actual == desired):
+        msg = StringIO()
+        msg.write(test_string)
+        msg.write(' failed\nACTUAL: \n')
+        pprint.pprint(actual, msg)
+        msg.write('DESIRED: \n')
+        pprint.pprint(desired, msg)
+        raise AssertionError(msg.getvalue())
+
+
+@np._no_nep50_warning()
+def assert_almost_equal(actual, desired, decimal=7, err_msg='', verbose=True):
+    """
+    Raises an AssertionError if two items are not equal up to desired
+    precision.
+
+    .. note:: It is recommended to use one of `assert_allclose`,
+              `assert_array_almost_equal_nulp` or `assert_array_max_ulp`
+              instead of this function for more consistent floating point
+              comparisons.
+
+    The test verifies that the elements of `actual` and `desired` satisfy::
+
+        abs(desired-actual) < float64(1.5 * 10**(-decimal))
+
+    That is a looser test than originally documented, but agrees with what the
+    actual implementation in `assert_array_almost_equal` did up to rounding
+    vagaries. An exception is raised at conflicting values. For ndarrays this
+    delegates to assert_array_almost_equal
+
+    Parameters
+    ----------
+    actual : array_like
+        The object to check.
+    desired : array_like
+        The expected object.
+    decimal : int, optional
+        Desired precision, default is 7.
+    err_msg : str, optional
+        The error message to be printed in case of failure.
+    verbose : bool, optional
+        If True, the conflicting values are appended to the error message.
+
+    Raises
+    ------
+    AssertionError
+      If actual and desired are not equal up to specified precision.
+
+    See Also
+    --------
+    assert_allclose: Compare two array_like objects for equality with desired
+                     relative and/or absolute precision.
+    assert_array_almost_equal_nulp, assert_array_max_ulp, assert_equal
+
+    Examples
+    --------
+    >>> from numpy.testing import assert_almost_equal
+    >>> assert_almost_equal(2.3333333333333, 2.33333334)
+    >>> assert_almost_equal(2.3333333333333, 2.33333334, decimal=10)
+    Traceback (most recent call last):
+        ...
+    AssertionError:
+    Arrays are not almost equal to 10 decimals
+     ACTUAL: 2.3333333333333
+     DESIRED: 2.33333334
+
+    >>> assert_almost_equal(np.array([1.0,2.3333333333333]),
+    ...                     np.array([1.0,2.33333334]), decimal=9)
+    Traceback (most recent call last):
+        ...
+    AssertionError:
+    Arrays are not almost equal to 9 decimals
+    
+    Mismatched elements: 1 / 2 (50%)
+    Max absolute difference among violations: 6.66669964e-09
+    Max relative difference among violations: 2.85715698e-09
+     ACTUAL: array([1.         , 2.333333333])
+     DESIRED: array([1.        , 2.33333334])
+
+    """
+    __tracebackhide__ = True  # Hide traceback for py.test
+    from numpy._core import ndarray
+    from numpy import iscomplexobj, real, imag
+
+    # Handle complex numbers: separate into real/imag to handle
+    # nan/inf/negative zero correctly
+    # XXX: catch ValueError for subclasses of ndarray where iscomplex fail
+    try:
+        usecomplex = iscomplexobj(actual) or iscomplexobj(desired)
+    except ValueError:
+        usecomplex = False
+
+    def _build_err_msg():
+        header = ('Arrays are not almost equal to %d decimals' % decimal)
+        return build_err_msg([actual, desired], err_msg, verbose=verbose,
+                             header=header)
+
+    if usecomplex:
+        if iscomplexobj(actual):
+            actualr = real(actual)
+            actuali = imag(actual)
+        else:
+            actualr = actual
+            actuali = 0
+        if iscomplexobj(desired):
+            desiredr = real(desired)
+            desiredi = imag(desired)
+        else:
+            desiredr = desired
+            desiredi = 0
+        try:
+            assert_almost_equal(actualr, desiredr, decimal=decimal)
+            assert_almost_equal(actuali, desiredi, decimal=decimal)
+        except AssertionError:
+            raise AssertionError(_build_err_msg())
+
+    if isinstance(actual, (ndarray, tuple, list)) \
+            or isinstance(desired, (ndarray, tuple, list)):
+        return assert_array_almost_equal(actual, desired, decimal, err_msg)
+    try:
+        # If one of desired/actual is not finite, handle it specially here:
+        # check that both are nan if any is a nan, and test for equality
+        # otherwise
+        if not (isfinite(desired) and isfinite(actual)):
+            if isnan(desired) or isnan(actual):
+                if not (isnan(desired) and isnan(actual)):
+                    raise AssertionError(_build_err_msg())
+            else:
+                if not desired == actual:
+                    raise AssertionError(_build_err_msg())
+            return
+    except (NotImplementedError, TypeError):
+        pass
+    if abs(desired - actual) >= np.float64(1.5 * 10.0**(-decimal)):
+        raise AssertionError(_build_err_msg())
+
+
+@np._no_nep50_warning()
+def assert_approx_equal(actual, desired, significant=7, err_msg='',
+                        verbose=True):
+    """
+    Raises an AssertionError if two items are not equal up to significant
+    digits.
+
+    .. note:: It is recommended to use one of `assert_allclose`,
+              `assert_array_almost_equal_nulp` or `assert_array_max_ulp`
+              instead of this function for more consistent floating point
+              comparisons.
+
+    Given two numbers, check that they are approximately equal.
+    Approximately equal is defined as the number of significant digits
+    that agree.
+
+    Parameters
+    ----------
+    actual : scalar
+        The object to check.
+    desired : scalar
+        The expected object.
+    significant : int, optional
+        Desired precision, default is 7.
+    err_msg : str, optional
+        The error message to be printed in case of failure.
+    verbose : bool, optional
+        If True, the conflicting values are appended to the error message.
+
+    Raises
+    ------
+    AssertionError
+      If actual and desired are not equal up to specified precision.
+
+    See Also
+    --------
+    assert_allclose: Compare two array_like objects for equality with desired
+                     relative and/or absolute precision.
+    assert_array_almost_equal_nulp, assert_array_max_ulp, assert_equal
+
+    Examples
+    --------
+    >>> np.testing.assert_approx_equal(0.12345677777777e-20, 0.1234567e-20)
+    >>> np.testing.assert_approx_equal(0.12345670e-20, 0.12345671e-20,
+    ...                                significant=8)
+    >>> np.testing.assert_approx_equal(0.12345670e-20, 0.12345672e-20,
+    ...                                significant=8)
+    Traceback (most recent call last):
+        ...
+    AssertionError:
+    Items are not equal to 8 significant digits:
+     ACTUAL: 1.234567e-21
+     DESIRED: 1.2345672e-21
+
+    the evaluated condition that raises the exception is
+
+    >>> abs(0.12345670e-20/1e-21 - 0.12345672e-20/1e-21) >= 10**-(8-1)
+    True
+
+    """
+    __tracebackhide__ = True  # Hide traceback for py.test
+    import numpy as np
+
+    (actual, desired) = map(float, (actual, desired))
+    if desired == actual:
+        return
+    # Normalized the numbers to be in range (-10.0,10.0)
+    # scale = float(pow(10,math.floor(math.log10(0.5*(abs(desired)+abs(actual))))))
+    with np.errstate(invalid='ignore'):
+        scale = 0.5*(np.abs(desired) + np.abs(actual))
+        scale = np.power(10, np.floor(np.log10(scale)))
+    try:
+        sc_desired = desired/scale
+    except ZeroDivisionError:
+        sc_desired = 0.0
+    try:
+        sc_actual = actual/scale
+    except ZeroDivisionError:
+        sc_actual = 0.0
+    msg = build_err_msg(
+        [actual, desired], err_msg,
+        header='Items are not equal to %d significant digits:' % significant,
+        verbose=verbose)
+    try:
+        # If one of desired/actual is not finite, handle it specially here:
+        # check that both are nan if any is a nan, and test for equality
+        # otherwise
+        if not (isfinite(desired) and isfinite(actual)):
+            if isnan(desired) or isnan(actual):
+                if not (isnan(desired) and isnan(actual)):
+                    raise AssertionError(msg)
+            else:
+                if not desired == actual:
+                    raise AssertionError(msg)
+            return
+    except (TypeError, NotImplementedError):
+        pass
+    if np.abs(sc_desired - sc_actual) >= np.power(10., -(significant-1)):
+        raise AssertionError(msg)
+
+
+@np._no_nep50_warning()
+def assert_array_compare(comparison, x, y, err_msg='', verbose=True, header='',
+                         precision=6, equal_nan=True, equal_inf=True,
+                         *, strict=False, names=('ACTUAL', 'DESIRED')):
+    __tracebackhide__ = True  # Hide traceback for py.test
+    from numpy._core import (array2string, isnan, inf, errstate,
+                            all, max, object_)
+
+    x = np.asanyarray(x)
+    y = np.asanyarray(y)
+
+    # original array for output formatting
+    ox, oy = x, y
+
+    def isnumber(x):
+        return x.dtype.char in '?bhilqpBHILQPefdgFDG'
+
+    def istime(x):
+        return x.dtype.char in "Mm"
+
+    def isvstring(x):
+        return x.dtype.char == "T"
+
+    def func_assert_same_pos(x, y, func=isnan, hasval='nan'):
+        """Handling nan/inf.
+
+        Combine results of running func on x and y, checking that they are True
+        at the same locations.
+
+        """
+        __tracebackhide__ = True  # Hide traceback for py.test
+
+        x_id = func(x)
+        y_id = func(y)
+        # We include work-arounds here to handle three types of slightly
+        # pathological ndarray subclasses:
+        # (1) all() on `masked` array scalars can return masked arrays, so we
+        #     use != True
+        # (2) __eq__ on some ndarray subclasses returns Python booleans
+        #     instead of element-wise comparisons, so we cast to np.bool() and
+        #     use isinstance(..., bool) checks
+        # (3) subclasses with bare-bones __array_function__ implementations may
+        #     not implement np.all(), so favor using the .all() method
+        # We are not committed to supporting such subclasses, but it's nice to
+        # support them if possible.
+        if np.bool(x_id == y_id).all() != True:
+            msg = build_err_msg(
+                [x, y],
+                err_msg + '\n%s location mismatch:'
+                % (hasval), verbose=verbose, header=header,
+                names=names,
+                precision=precision)
+            raise AssertionError(msg)
+        # If there is a scalar, then here we know the array has the same
+        # flag as it everywhere, so we should return the scalar flag.
+        if isinstance(x_id, bool) or x_id.ndim == 0:
+            return np.bool(x_id)
+        elif isinstance(y_id, bool) or y_id.ndim == 0:
+            return np.bool(y_id)
+        else:
+            return y_id
+
+    try:
+        if strict:
+            cond = x.shape == y.shape and x.dtype == y.dtype
+        else:
+            cond = (x.shape == () or y.shape == ()) or x.shape == y.shape
+        if not cond:
+            if x.shape != y.shape:
+                reason = f'\n(shapes {x.shape}, {y.shape} mismatch)'
+            else:
+                reason = f'\n(dtypes {x.dtype}, {y.dtype} mismatch)'
+            msg = build_err_msg([x, y],
+                                err_msg
+                                + reason,
+                                verbose=verbose, header=header,
+                                names=names,
+                                precision=precision)
+            raise AssertionError(msg)
+
+        flagged = np.bool(False)
+        if isnumber(x) and isnumber(y):
+            if equal_nan:
+                flagged = func_assert_same_pos(x, y, func=isnan, hasval='nan')
+
+            if equal_inf:
+                flagged |= func_assert_same_pos(x, y,
+                                                func=lambda xy: xy == +inf,
+                                                hasval='+inf')
+                flagged |= func_assert_same_pos(x, y,
+                                                func=lambda xy: xy == -inf,
+                                                hasval='-inf')
+
+        elif istime(x) and istime(y):
+            # If one is datetime64 and the other timedelta64 there is no point
+            if equal_nan and x.dtype.type == y.dtype.type:
+                flagged = func_assert_same_pos(x, y, func=isnat, hasval="NaT")
+
+        elif isvstring(x) and isvstring(y):
+            dt = x.dtype
+            if equal_nan and dt == y.dtype and hasattr(dt, 'na_object'):
+                is_nan = (isinstance(dt.na_object, float) and
+                          np.isnan(dt.na_object))
+                bool_errors = 0
+                try:
+                    bool(dt.na_object)
+                except TypeError:
+                    bool_errors = 1
+                if is_nan or bool_errors:
+                    # nan-like NA object
+                    flagged = func_assert_same_pos(
+                        x, y, func=isnan, hasval=x.dtype.na_object)
+
+        if flagged.ndim > 0:
+            x, y = x[~flagged], y[~flagged]
+            # Only do the comparison if actual values are left
+            if x.size == 0:
+                return
+        elif flagged:
+            # no sense doing comparison if everything is flagged.
+            return
+
+        val = comparison(x, y)
+        invalids = np.logical_not(val)
+
+        if isinstance(val, bool):
+            cond = val
+            reduced = array([val])
+        else:
+            reduced = val.ravel()
+            cond = reduced.all()
+
+        # The below comparison is a hack to ensure that fully masked
+        # results, for which val.ravel().all() returns np.ma.masked,
+        # do not trigger a failure (np.ma.masked != True evaluates as
+        # np.ma.masked, which is falsy).
+        if cond != True:
+            n_mismatch = reduced.size - reduced.sum(dtype=intp)
+            n_elements = flagged.size if flagged.ndim != 0 else reduced.size
+            percent_mismatch = 100 * n_mismatch / n_elements
+            remarks = [
+                'Mismatched elements: {} / {} ({:.3g}%)'.format(
+                    n_mismatch, n_elements, percent_mismatch)]
+
+            with errstate(all='ignore'):
+                # ignore errors for non-numeric types
+                with contextlib.suppress(TypeError):
+                    error = abs(x - y)
+                    if np.issubdtype(x.dtype, np.unsignedinteger):
+                        error2 = abs(y - x)
+                        np.minimum(error, error2, out=error)
+
+                    reduced_error = error[invalids]
+                    max_abs_error = max(reduced_error)
+                    if getattr(error, 'dtype', object_) == object_:
+                        remarks.append(
+                            'Max absolute difference among violations: '
+                            + str(max_abs_error))
+                    else:
+                        remarks.append(
+                            'Max absolute difference among violations: '
+                            + array2string(max_abs_error))
+                        
+                    # note: this definition of relative error matches that one
+                    # used by assert_allclose (found in np.isclose)
+                    # Filter values where the divisor would be zero
+                    nonzero = np.bool(y != 0)
+                    nonzero_and_invalid = np.logical_and(invalids, nonzero)
+                    
+                    if all(~nonzero_and_invalid):
+                        max_rel_error = array(inf)
+                    else:
+                        nonzero_invalid_error = error[nonzero_and_invalid]
+                        broadcasted_y = np.broadcast_to(y, error.shape)
+                        nonzero_invalid_y = broadcasted_y[nonzero_and_invalid]
+                        max_rel_error = max(nonzero_invalid_error 
+                                            / abs(nonzero_invalid_y))
+
+                    if getattr(error, 'dtype', object_) == object_: 
+                        remarks.append(
+                            'Max relative difference among violations: '
+                            + str(max_rel_error))
+                    else:               
+                        remarks.append(
+                            'Max relative difference among violations: '
+                            + array2string(max_rel_error))
+            err_msg = str(err_msg)
+            err_msg += '\n' + '\n'.join(remarks)
+            msg = build_err_msg([ox, oy], err_msg,
+                                verbose=verbose, header=header,
+                                names=names,
+                                precision=precision)
+            raise AssertionError(msg)
+    except ValueError:
+        import traceback
+        efmt = traceback.format_exc()
+        header = f'error during assertion:\n\n{efmt}\n\n{header}'
+
+        msg = build_err_msg([x, y], err_msg, verbose=verbose, header=header,
+                            names=names, precision=precision)
+        raise ValueError(msg)
+
+
+@_rename_parameter(['x', 'y'], ['actual', 'desired'], dep_version='2.0.0')
+def assert_array_equal(actual, desired, err_msg='', verbose=True, *,
+                       strict=False):
+    """
+    Raises an AssertionError if two array_like objects are not equal.
+
+    Given two array_like objects, check that the shape is equal and all
+    elements of these objects are equal (but see the Notes for the special
+    handling of a scalar). An exception is raised at shape mismatch or
+    conflicting values. In contrast to the standard usage in numpy, NaNs
+    are compared like numbers, no assertion is raised if both objects have
+    NaNs in the same positions.
+
+    The usual caution for verifying equality with floating point numbers is
+    advised.
+
+    .. note:: When either `actual` or `desired` is already an instance of
+        `numpy.ndarray` and `desired` is not a ``dict``, the behavior of
+        ``assert_equal(actual, desired)`` is identical to the behavior of this
+        function. Otherwise, this function performs `np.asanyarray` on the
+        inputs before comparison, whereas `assert_equal` defines special
+        comparison rules for common Python types. For example, only
+        `assert_equal` can be used to compare nested Python lists. In new code,
+        consider using only `assert_equal`, explicitly converting either
+        `actual` or `desired` to arrays if the behavior of `assert_array_equal`
+        is desired.
+
+    Parameters
+    ----------
+    actual : array_like
+        The actual object to check.
+    desired : array_like
+        The desired, expected object.
+    err_msg : str, optional
+        The error message to be printed in case of failure.
+    verbose : bool, optional
+        If True, the conflicting values are appended to the error message.
+    strict : bool, optional
+        If True, raise an AssertionError when either the shape or the data
+        type of the array_like objects does not match. The special
+        handling for scalars mentioned in the Notes section is disabled.
+
+        .. versionadded:: 1.24.0
+
+    Raises
+    ------
+    AssertionError
+        If actual and desired objects are not equal.
+
+    See Also
+    --------
+    assert_allclose: Compare two array_like objects for equality with desired
+                     relative and/or absolute precision.
+    assert_array_almost_equal_nulp, assert_array_max_ulp, assert_equal
+
+    Notes
+    -----
+    When one of `actual` and `desired` is a scalar and the other is array_like,
+    the function checks that each element of the array_like object is equal to
+    the scalar. This behaviour can be disabled with the `strict` parameter.
+
+    Examples
+    --------
+    The first assert does not raise an exception:
+
+    >>> np.testing.assert_array_equal([1.0,2.33333,np.nan],
+    ...                               [np.exp(0),2.33333, np.nan])
+
+    Assert fails with numerical imprecision with floats:
+
+    >>> np.testing.assert_array_equal([1.0,np.pi,np.nan],
+    ...                               [1, np.sqrt(np.pi)**2, np.nan])
+    Traceback (most recent call last):
+        ...
+    AssertionError:
+    Arrays are not equal
+    
+    Mismatched elements: 1 / 3 (33.3%)
+    Max absolute difference among violations: 4.4408921e-16
+    Max relative difference among violations: 1.41357986e-16
+     ACTUAL: array([1.      , 3.141593,      nan])
+     DESIRED: array([1.      , 3.141593,      nan])
+
+    Use `assert_allclose` or one of the nulp (number of floating point values)
+    functions for these cases instead:
+
+    >>> np.testing.assert_allclose([1.0,np.pi,np.nan],
+    ...                            [1, np.sqrt(np.pi)**2, np.nan],
+    ...                            rtol=1e-10, atol=0)
+
+    As mentioned in the Notes section, `assert_array_equal` has special
+    handling for scalars. Here the test checks that each value in `x` is 3:
+
+    >>> x = np.full((2, 5), fill_value=3)
+    >>> np.testing.assert_array_equal(x, 3)
+
+    Use `strict` to raise an AssertionError when comparing a scalar with an
+    array:
+
+    >>> np.testing.assert_array_equal(x, 3, strict=True)
+    Traceback (most recent call last):
+        ...
+    AssertionError:
+    Arrays are not equal
+    
+    (shapes (2, 5), () mismatch)
+     ACTUAL: array([[3, 3, 3, 3, 3],
+           [3, 3, 3, 3, 3]])
+     DESIRED: array(3)
+
+    The `strict` parameter also ensures that the array data types match:
+
+    >>> x = np.array([2, 2, 2])
+    >>> y = np.array([2., 2., 2.], dtype=np.float32)
+    >>> np.testing.assert_array_equal(x, y, strict=True)
+    Traceback (most recent call last):
+        ...
+    AssertionError:
+    Arrays are not equal
+    
+    (dtypes int64, float32 mismatch)
+     ACTUAL: array([2, 2, 2])
+     DESIRED: array([2., 2., 2.], dtype=float32)
+    """
+    __tracebackhide__ = True  # Hide traceback for py.test
+    assert_array_compare(operator.__eq__, actual, desired, err_msg=err_msg,
+                         verbose=verbose, header='Arrays are not equal',
+                         strict=strict)
+
+
+@np._no_nep50_warning()
+@_rename_parameter(['x', 'y'], ['actual', 'desired'], dep_version='2.0.0')
+def assert_array_almost_equal(actual, desired, decimal=6, err_msg='',
+                              verbose=True):
+    """
+    Raises an AssertionError if two objects are not equal up to desired
+    precision.
+
+    .. note:: It is recommended to use one of `assert_allclose`,
+              `assert_array_almost_equal_nulp` or `assert_array_max_ulp`
+              instead of this function for more consistent floating point
+              comparisons.
+
+    The test verifies identical shapes and that the elements of ``actual`` and
+    ``desired`` satisfy::
+
+        abs(desired-actual) < 1.5 * 10**(-decimal)
+
+    That is a looser test than originally documented, but agrees with what the
+    actual implementation did up to rounding vagaries. An exception is raised
+    at shape mismatch or conflicting values. In contrast to the standard usage
+    in numpy, NaNs are compared like numbers, no assertion is raised if both
+    objects have NaNs in the same positions.
+
+    Parameters
+    ----------
+    actual : array_like
+        The actual object to check.
+    desired : array_like
+        The desired, expected object.
+    decimal : int, optional
+        Desired precision, default is 6.
+    err_msg : str, optional
+      The error message to be printed in case of failure.
+    verbose : bool, optional
+        If True, the conflicting values are appended to the error message.
+
+    Raises
+    ------
+    AssertionError
+        If actual and desired are not equal up to specified precision.
+
+    See Also
+    --------
+    assert_allclose: Compare two array_like objects for equality with desired
+                     relative and/or absolute precision.
+    assert_array_almost_equal_nulp, assert_array_max_ulp, assert_equal
+
+    Examples
+    --------
+    the first assert does not raise an exception
+
+    >>> np.testing.assert_array_almost_equal([1.0,2.333,np.nan],
+    ...                                      [1.0,2.333,np.nan])
+
+    >>> np.testing.assert_array_almost_equal([1.0,2.33333,np.nan],
+    ...                                      [1.0,2.33339,np.nan], decimal=5)
+    Traceback (most recent call last):
+        ...
+    AssertionError:
+    Arrays are not almost equal to 5 decimals
+    
+    Mismatched elements: 1 / 3 (33.3%)
+    Max absolute difference among violations: 6.e-05
+    Max relative difference among violations: 2.57136612e-05
+     ACTUAL: array([1.     , 2.33333,     nan])
+     DESIRED: array([1.     , 2.33339,     nan])
+
+    >>> np.testing.assert_array_almost_equal([1.0,2.33333,np.nan],
+    ...                                      [1.0,2.33333, 5], decimal=5)
+    Traceback (most recent call last):
+        ...
+    AssertionError:
+    Arrays are not almost equal to 5 decimals
+    
+    nan location mismatch:
+     ACTUAL: array([1.     , 2.33333,     nan])
+     DESIRED: array([1.     , 2.33333, 5.     ])
+
+    """
+    __tracebackhide__ = True  # Hide traceback for py.test
+    from numpy._core import number, result_type
+    from numpy._core.numerictypes import issubdtype
+    from numpy._core.fromnumeric import any as npany
+
+    def compare(x, y):
+        try:
+            if npany(isinf(x)) or npany(isinf(y)):
+                xinfid = isinf(x)
+                yinfid = isinf(y)
+                if not (xinfid == yinfid).all():
+                    return False
+                # if one item, x and y is +- inf
+                if x.size == y.size == 1:
+                    return x == y
+                x = x[~xinfid]
+                y = y[~yinfid]
+        except (TypeError, NotImplementedError):
+            pass
+
+        # make sure y is an inexact type to avoid abs(MIN_INT); will cause
+        # casting of x later.
+        dtype = result_type(y, 1.)
+        y = np.asanyarray(y, dtype)
+        z = abs(x - y)
+
+        if not issubdtype(z.dtype, number):
+            z = z.astype(np.float64)  # handle object arrays
+
+        return z < 1.5 * 10.0**(-decimal)
+
+    assert_array_compare(compare, actual, desired, err_msg=err_msg,
+                         verbose=verbose,
+             header=('Arrays are not almost equal to %d decimals' % decimal),
+             precision=decimal)
+
+
+def assert_array_less(x, y, err_msg='', verbose=True, *, strict=False):
+    """
+    Raises an AssertionError if two array_like objects are not ordered by less
+    than.
+
+    Given two array_like objects `x` and `y`, check that the shape is equal and
+    all elements of `x` are strictly less than the corresponding elements of
+    `y` (but see the Notes for the special handling of a scalar). An exception
+    is raised at shape mismatch or values that are not correctly ordered. In
+    contrast to the  standard usage in NumPy, no assertion is raised if both
+    objects have NaNs in the same positions.
+
+    Parameters
+    ----------
+    x : array_like
+      The smaller object to check.
+    y : array_like
+      The larger object to compare.
+    err_msg : string
+      The error message to be printed in case of failure.
+    verbose : bool
+        If True, the conflicting values are appended to the error message.
+    strict : bool, optional
+        If True, raise an AssertionError when either the shape or the data
+        type of the array_like objects does not match. The special
+        handling for scalars mentioned in the Notes section is disabled.
+
+        .. versionadded:: 2.0.0
+
+    Raises
+    ------
+    AssertionError
+      If x is not strictly smaller than y, element-wise.
+
+    See Also
+    --------
+    assert_array_equal: tests objects for equality
+    assert_array_almost_equal: test objects for equality up to precision
+
+    Notes
+    -----
+    When one of `x` and `y` is a scalar and the other is array_like, the
+    function performs the comparison as though the scalar were broadcasted
+    to the shape of the array. This behaviour can be disabled with the `strict`
+    parameter.
+
+    Examples
+    --------
+    The following assertion passes because each finite element of `x` is
+    strictly less than the corresponding element of `y`, and the NaNs are in
+    corresponding locations.
+
+    >>> x = [1.0, 1.0, np.nan]
+    >>> y = [1.1, 2.0, np.nan]
+    >>> np.testing.assert_array_less(x, y)
+
+    The following assertion fails because the zeroth element of `x` is no
+    longer strictly less than the zeroth element of `y`.
+
+    >>> y[0] = 1
+    >>> np.testing.assert_array_less(x, y)
+    Traceback (most recent call last):
+        ...
+    AssertionError:
+    Arrays are not strictly ordered `x < y`
+    
+    Mismatched elements: 1 / 3 (33.3%)
+    Max absolute difference among violations: 0.
+    Max relative difference among violations: 0.
+     x: array([ 1.,  1., nan])
+     y: array([ 1.,  2., nan])
+
+    Here, `y` is a scalar, so each element of `x` is compared to `y`, and
+    the assertion passes.
+
+    >>> x = [1.0, 4.0]
+    >>> y = 5.0
+    >>> np.testing.assert_array_less(x, y)
+
+    However, with ``strict=True``, the assertion will fail because the shapes
+    do not match.
+
+    >>> np.testing.assert_array_less(x, y, strict=True)
+    Traceback (most recent call last):
+        ...
+    AssertionError:
+    Arrays are not strictly ordered `x < y`
+    
+    (shapes (2,), () mismatch)
+     x: array([1., 4.])
+     y: array(5.)
+
+    With ``strict=True``, the assertion also fails if the dtypes of the two
+    arrays do not match.
+
+    >>> y = [5, 5]
+    >>> np.testing.assert_array_less(x, y, strict=True)
+    Traceback (most recent call last):
+        ...
+    AssertionError:
+    Arrays are not strictly ordered `x < y`
+    
+    (dtypes float64, int64 mismatch)
+     x: array([1., 4.])
+     y: array([5, 5])
+    """
+    __tracebackhide__ = True  # Hide traceback for py.test
+    assert_array_compare(operator.__lt__, x, y, err_msg=err_msg,
+                         verbose=verbose,
+                         header='Arrays are not strictly ordered `x < y`',
+                         equal_inf=False,
+                         strict=strict,
+                         names=('x', 'y'))
+
+
+def runstring(astr, dict):
+    exec(astr, dict)
+
+
+def assert_string_equal(actual, desired):
+    """
+    Test if two strings are equal.
+
+    If the given strings are equal, `assert_string_equal` does nothing.
+    If they are not equal, an AssertionError is raised, and the diff
+    between the strings is shown.
+
+    Parameters
+    ----------
+    actual : str
+        The string to test for equality against the expected string.
+    desired : str
+        The expected string.
+
+    Examples
+    --------
+    >>> np.testing.assert_string_equal('abc', 'abc')
+    >>> np.testing.assert_string_equal('abc', 'abcd')
+    Traceback (most recent call last):
+      File "", line 1, in 
+    ...
+    AssertionError: Differences in strings:
+    - abc+ abcd?    +
+
+    """
+    # delay import of difflib to reduce startup time
+    __tracebackhide__ = True  # Hide traceback for py.test
+    import difflib
+
+    if not isinstance(actual, str):
+        raise AssertionError(repr(type(actual)))
+    if not isinstance(desired, str):
+        raise AssertionError(repr(type(desired)))
+    if desired == actual:
+        return
+
+    diff = list(difflib.Differ().compare(actual.splitlines(True),
+                desired.splitlines(True)))
+    diff_list = []
+    while diff:
+        d1 = diff.pop(0)
+        if d1.startswith('  '):
+            continue
+        if d1.startswith('- '):
+            l = [d1]
+            d2 = diff.pop(0)
+            if d2.startswith('? '):
+                l.append(d2)
+                d2 = diff.pop(0)
+            if not d2.startswith('+ '):
+                raise AssertionError(repr(d2))
+            l.append(d2)
+            if diff:
+                d3 = diff.pop(0)
+                if d3.startswith('? '):
+                    l.append(d3)
+                else:
+                    diff.insert(0, d3)
+            if d2[2:] == d1[2:]:
+                continue
+            diff_list.extend(l)
+            continue
+        raise AssertionError(repr(d1))
+    if not diff_list:
+        return
+    msg = f"Differences in strings:\n{''.join(diff_list).rstrip()}"
+    if actual != desired:
+        raise AssertionError(msg)
+
+
+def rundocs(filename=None, raise_on_error=True):
+    """
+    Run doctests found in the given file.
+
+    By default `rundocs` raises an AssertionError on failure.
+
+    Parameters
+    ----------
+    filename : str
+        The path to the file for which the doctests are run.
+    raise_on_error : bool
+        Whether to raise an AssertionError when a doctest fails. Default is
+        True.
+
+    Notes
+    -----
+    The doctests can be run by the user/developer by adding the ``doctests``
+    argument to the ``test()`` call. For example, to run all tests (including
+    doctests) for ``numpy.lib``:
+
+    >>> np.lib.test(doctests=True)  # doctest: +SKIP
+    """
+    from numpy.distutils.misc_util import exec_mod_from_location
+    import doctest
+    if filename is None:
+        f = sys._getframe(1)
+        filename = f.f_globals['__file__']
+    name = os.path.splitext(os.path.basename(filename))[0]
+    m = exec_mod_from_location(name, filename)
+
+    tests = doctest.DocTestFinder().find(m)
+    runner = doctest.DocTestRunner(verbose=False)
+
+    msg = []
+    if raise_on_error:
+        out = lambda s: msg.append(s)
+    else:
+        out = None
+
+    for test in tests:
+        runner.run(test, out=out)
+
+    if runner.failures > 0 and raise_on_error:
+        raise AssertionError("Some doctests failed:\n%s" % "\n".join(msg))
+
+
+def check_support_sve(__cache=[]):
+    """
+    gh-22982
+    """
+    
+    if __cache:
+        return __cache[0]
+    
+    import subprocess
+    cmd = 'lscpu'
+    try:
+        output = subprocess.run(cmd, capture_output=True, text=True)
+        result = 'sve' in output.stdout
+    except (OSError, subprocess.SubprocessError):
+        result = False
+    __cache.append(result)
+    return __cache[0]
+
+
+#
+# assert_raises and assert_raises_regex are taken from unittest.
+#
+import unittest
+
+
+class _Dummy(unittest.TestCase):
+    def nop(self):
+        pass
+
+
+_d = _Dummy('nop')
+
+
+def assert_raises(*args, **kwargs):
+    """
+    assert_raises(exception_class, callable, *args, **kwargs)
+    assert_raises(exception_class)
+
+    Fail unless an exception of class exception_class is thrown
+    by callable when invoked with arguments args and keyword
+    arguments kwargs. If a different type of exception is
+    thrown, it will not be caught, and the test case will be
+    deemed to have suffered an error, exactly as for an
+    unexpected exception.
+
+    Alternatively, `assert_raises` can be used as a context manager:
+
+    >>> from numpy.testing import assert_raises
+    >>> with assert_raises(ZeroDivisionError):
+    ...     1 / 0
+
+    is equivalent to
+
+    >>> def div(x, y):
+    ...     return x / y
+    >>> assert_raises(ZeroDivisionError, div, 1, 0)
+
+    """
+    __tracebackhide__ = True  # Hide traceback for py.test
+    return _d.assertRaises(*args, **kwargs)
+
+
+def assert_raises_regex(exception_class, expected_regexp, *args, **kwargs):
+    """
+    assert_raises_regex(exception_class, expected_regexp, callable, *args,
+                        **kwargs)
+    assert_raises_regex(exception_class, expected_regexp)
+
+    Fail unless an exception of class exception_class and with message that
+    matches expected_regexp is thrown by callable when invoked with arguments
+    args and keyword arguments kwargs.
+
+    Alternatively, can be used as a context manager like `assert_raises`.
+
+    Notes
+    -----
+    .. versionadded:: 1.9.0
+
+    """
+    __tracebackhide__ = True  # Hide traceback for py.test
+    return _d.assertRaisesRegex(exception_class, expected_regexp, *args, **kwargs)
+
+
+def decorate_methods(cls, decorator, testmatch=None):
+    """
+    Apply a decorator to all methods in a class matching a regular expression.
+
+    The given decorator is applied to all public methods of `cls` that are
+    matched by the regular expression `testmatch`
+    (``testmatch.search(methodname)``). Methods that are private, i.e. start
+    with an underscore, are ignored.
+
+    Parameters
+    ----------
+    cls : class
+        Class whose methods to decorate.
+    decorator : function
+        Decorator to apply to methods
+    testmatch : compiled regexp or str, optional
+        The regular expression. Default value is None, in which case the
+        nose default (``re.compile(r'(?:^|[\\b_\\.%s-])[Tt]est' % os.sep)``)
+        is used.
+        If `testmatch` is a string, it is compiled to a regular expression
+        first.
+
+    """
+    if testmatch is None:
+        testmatch = re.compile(r'(?:^|[\\b_\\.%s-])[Tt]est' % os.sep)
+    else:
+        testmatch = re.compile(testmatch)
+    cls_attr = cls.__dict__
+
+    # delayed import to reduce startup time
+    from inspect import isfunction
+
+    methods = [_m for _m in cls_attr.values() if isfunction(_m)]
+    for function in methods:
+        try:
+            if hasattr(function, 'compat_func_name'):
+                funcname = function.compat_func_name
+            else:
+                funcname = function.__name__
+        except AttributeError:
+            # not a function
+            continue
+        if testmatch.search(funcname) and not funcname.startswith('_'):
+            setattr(cls, funcname, decorator(function))
+    return
+
+
+def measure(code_str, times=1, label=None):
+    """
+    Return elapsed time for executing code in the namespace of the caller.
+
+    The supplied code string is compiled with the Python builtin ``compile``.
+    The precision of the timing is 10 milli-seconds. If the code will execute
+    fast on this timescale, it can be executed many times to get reasonable
+    timing accuracy.
+
+    Parameters
+    ----------
+    code_str : str
+        The code to be timed.
+    times : int, optional
+        The number of times the code is executed. Default is 1. The code is
+        only compiled once.
+    label : str, optional
+        A label to identify `code_str` with. This is passed into ``compile``
+        as the second argument (for run-time error messages).
+
+    Returns
+    -------
+    elapsed : float
+        Total elapsed time in seconds for executing `code_str` `times` times.
+
+    Examples
+    --------
+    >>> times = 10
+    >>> etime = np.testing.measure('for i in range(1000): np.sqrt(i**2)', times=times)
+    >>> print("Time for a single execution : ", etime / times, "s")  # doctest: +SKIP
+    Time for a single execution :  0.005 s
+
+    """
+    frame = sys._getframe(1)
+    locs, globs = frame.f_locals, frame.f_globals
+
+    code = compile(code_str, f'Test name: {label} ', 'exec')
+    i = 0
+    elapsed = jiffies()
+    while i < times:
+        i += 1
+        exec(code, globs, locs)
+    elapsed = jiffies() - elapsed
+    return 0.01*elapsed
+
+
+def _assert_valid_refcount(op):
+    """
+    Check that ufuncs don't mishandle refcount of object `1`.
+    Used in a few regression tests.
+    """
+    if not HAS_REFCOUNT:
+        return True
+
+    import gc
+    import numpy as np
+
+    b = np.arange(100*100).reshape(100, 100)
+    c = b
+    i = 1
+
+    gc.disable()
+    try:
+        rc = sys.getrefcount(i)
+        for j in range(15):
+            d = op(b, c)
+        assert_(sys.getrefcount(i) >= rc)
+    finally:
+        gc.enable()
+    del d  # for pyflakes
+
+
+def assert_allclose(actual, desired, rtol=1e-7, atol=0, equal_nan=True,
+                    err_msg='', verbose=True, *, strict=False):
+    """
+    Raises an AssertionError if two objects are not equal up to desired
+    tolerance.
+
+    Given two array_like objects, check that their shapes and all elements
+    are equal (but see the Notes for the special handling of a scalar). An
+    exception is raised if the shapes mismatch or any values conflict. In
+    contrast to the standard usage in numpy, NaNs are compared like numbers,
+    no assertion is raised if both objects have NaNs in the same positions.
+
+    The test is equivalent to ``allclose(actual, desired, rtol, atol)`` (note
+    that ``allclose`` has different default values). It compares the difference
+    between `actual` and `desired` to ``atol + rtol * abs(desired)``.
+
+    .. versionadded:: 1.5.0
+
+    Parameters
+    ----------
+    actual : array_like
+        Array obtained.
+    desired : array_like
+        Array desired.
+    rtol : float, optional
+        Relative tolerance.
+    atol : float, optional
+        Absolute tolerance.
+    equal_nan : bool, optional.
+        If True, NaNs will compare equal.
+    err_msg : str, optional
+        The error message to be printed in case of failure.
+    verbose : bool, optional
+        If True, the conflicting values are appended to the error message.
+    strict : bool, optional
+        If True, raise an ``AssertionError`` when either the shape or the data
+        type of the arguments does not match. The special handling of scalars
+        mentioned in the Notes section is disabled.
+
+        .. versionadded:: 2.0.0
+
+    Raises
+    ------
+    AssertionError
+        If actual and desired are not equal up to specified precision.
+
+    See Also
+    --------
+    assert_array_almost_equal_nulp, assert_array_max_ulp
+
+    Notes
+    -----
+    When one of `actual` and `desired` is a scalar and the other is
+    array_like, the function performs the comparison as if the scalar were
+    broadcasted to the shape of the array.
+    This behaviour can be disabled with the `strict` parameter.
+
+    Examples
+    --------
+    >>> x = [1e-5, 1e-3, 1e-1]
+    >>> y = np.arccos(np.cos(x))
+    >>> np.testing.assert_allclose(x, y, rtol=1e-5, atol=0)
+
+    As mentioned in the Notes section, `assert_allclose` has special
+    handling for scalars. Here, the test checks that the value of `numpy.sin`
+    is nearly zero at integer multiples of π.
+
+    >>> x = np.arange(3) * np.pi
+    >>> np.testing.assert_allclose(np.sin(x), 0, atol=1e-15)
+
+    Use `strict` to raise an ``AssertionError`` when comparing an array
+    with one or more dimensions against a scalar.
+
+    >>> np.testing.assert_allclose(np.sin(x), 0, atol=1e-15, strict=True)
+    Traceback (most recent call last):
+        ...
+    AssertionError:
+    Not equal to tolerance rtol=1e-07, atol=1e-15
+    
+    (shapes (3,), () mismatch)
+     ACTUAL: array([ 0.000000e+00,  1.224647e-16, -2.449294e-16])
+     DESIRED: array(0)
+
+    The `strict` parameter also ensures that the array data types match:
+
+    >>> y = np.zeros(3, dtype=np.float32)
+    >>> np.testing.assert_allclose(np.sin(x), y, atol=1e-15, strict=True)
+    Traceback (most recent call last):
+        ...
+    AssertionError:
+    Not equal to tolerance rtol=1e-07, atol=1e-15
+    
+    (dtypes float64, float32 mismatch)
+     ACTUAL: array([ 0.000000e+00,  1.224647e-16, -2.449294e-16])
+     DESIRED: array([0., 0., 0.], dtype=float32)
+
+    """
+    __tracebackhide__ = True  # Hide traceback for py.test
+    import numpy as np
+
+    def compare(x, y):
+        return np._core.numeric.isclose(x, y, rtol=rtol, atol=atol,
+                                       equal_nan=equal_nan)
+
+    actual, desired = np.asanyarray(actual), np.asanyarray(desired)
+    header = f'Not equal to tolerance rtol={rtol:g}, atol={atol:g}'
+    assert_array_compare(compare, actual, desired, err_msg=str(err_msg),
+                         verbose=verbose, header=header, equal_nan=equal_nan,
+                         strict=strict)
+
+
+def assert_array_almost_equal_nulp(x, y, nulp=1):
+    """
+    Compare two arrays relatively to their spacing.
+
+    This is a relatively robust method to compare two arrays whose amplitude
+    is variable.
+
+    Parameters
+    ----------
+    x, y : array_like
+        Input arrays.
+    nulp : int, optional
+        The maximum number of unit in the last place for tolerance (see Notes).
+        Default is 1.
+
+    Returns
+    -------
+    None
+
+    Raises
+    ------
+    AssertionError
+        If the spacing between `x` and `y` for one or more elements is larger
+        than `nulp`.
+
+    See Also
+    --------
+    assert_array_max_ulp : Check that all items of arrays differ in at most
+        N Units in the Last Place.
+    spacing : Return the distance between x and the nearest adjacent number.
+
+    Notes
+    -----
+    An assertion is raised if the following condition is not met::
+
+        abs(x - y) <= nulp * spacing(maximum(abs(x), abs(y)))
+
+    Examples
+    --------
+    >>> x = np.array([1., 1e-10, 1e-20])
+    >>> eps = np.finfo(x.dtype).eps
+    >>> np.testing.assert_array_almost_equal_nulp(x, x*eps/2 + x)
+
+    >>> np.testing.assert_array_almost_equal_nulp(x, x*eps + x)
+    Traceback (most recent call last):
+      ...
+    AssertionError: Arrays are not equal to 1 ULP (max is 2)
+
+    """
+    __tracebackhide__ = True  # Hide traceback for py.test
+    import numpy as np
+    ax = np.abs(x)
+    ay = np.abs(y)
+    ref = nulp * np.spacing(np.where(ax > ay, ax, ay))
+    if not np.all(np.abs(x-y) <= ref):
+        if np.iscomplexobj(x) or np.iscomplexobj(y):
+            msg = f"Arrays are not equal to {nulp} ULP"
+        else:
+            max_nulp = np.max(nulp_diff(x, y))
+            msg = f"Arrays are not equal to {nulp} ULP (max is {max_nulp:g})"
+        raise AssertionError(msg)
+
+
+def assert_array_max_ulp(a, b, maxulp=1, dtype=None):
+    """
+    Check that all items of arrays differ in at most N Units in the Last Place.
+
+    Parameters
+    ----------
+    a, b : array_like
+        Input arrays to be compared.
+    maxulp : int, optional
+        The maximum number of units in the last place that elements of `a` and
+        `b` can differ. Default is 1.
+    dtype : dtype, optional
+        Data-type to convert `a` and `b` to if given. Default is None.
+
+    Returns
+    -------
+    ret : ndarray
+        Array containing number of representable floating point numbers between
+        items in `a` and `b`.
+
+    Raises
+    ------
+    AssertionError
+        If one or more elements differ by more than `maxulp`.
+
+    Notes
+    -----
+    For computing the ULP difference, this API does not differentiate between
+    various representations of NAN (ULP difference between 0x7fc00000 and 0xffc00000
+    is zero).
+
+    See Also
+    --------
+    assert_array_almost_equal_nulp : Compare two arrays relatively to their
+        spacing.
+
+    Examples
+    --------
+    >>> a = np.linspace(0., 1., 100)
+    >>> res = np.testing.assert_array_max_ulp(a, np.arcsin(np.sin(a)))
+
+    """
+    __tracebackhide__ = True  # Hide traceback for py.test
+    import numpy as np
+    ret = nulp_diff(a, b, dtype)
+    if not np.all(ret <= maxulp):
+        raise AssertionError("Arrays are not almost equal up to %g "
+                             "ULP (max difference is %g ULP)" %
+                             (maxulp, np.max(ret)))
+    return ret
+
+
+def nulp_diff(x, y, dtype=None):
+    """For each item in x and y, return the number of representable floating
+    points between them.
+
+    Parameters
+    ----------
+    x : array_like
+        first input array
+    y : array_like
+        second input array
+    dtype : dtype, optional
+        Data-type to convert `x` and `y` to if given. Default is None.
+
+    Returns
+    -------
+    nulp : array_like
+        number of representable floating point numbers between each item in x
+        and y.
+
+    Notes
+    -----
+    For computing the ULP difference, this API does not differentiate between
+    various representations of NAN (ULP difference between 0x7fc00000 and 0xffc00000
+    is zero).
+
+    Examples
+    --------
+    # By definition, epsilon is the smallest number such as 1 + eps != 1, so
+    # there should be exactly one ULP between 1 and 1 + eps
+    >>> nulp_diff(1, 1 + np.finfo(x.dtype).eps)
+    1.0
+    """
+    import numpy as np
+    if dtype:
+        x = np.asarray(x, dtype=dtype)
+        y = np.asarray(y, dtype=dtype)
+    else:
+        x = np.asarray(x)
+        y = np.asarray(y)
+
+    t = np.common_type(x, y)
+    if np.iscomplexobj(x) or np.iscomplexobj(y):
+        raise NotImplementedError("_nulp not implemented for complex array")
+
+    x = np.array([x], dtype=t)
+    y = np.array([y], dtype=t)
+
+    x[np.isnan(x)] = np.nan
+    y[np.isnan(y)] = np.nan
+
+    if not x.shape == y.shape:
+        raise ValueError("Arrays do not have the same shape: %s - %s" %
+                         (x.shape, y.shape))
+
+    def _diff(rx, ry, vdt):
+        diff = np.asarray(rx-ry, dtype=vdt)
+        return np.abs(diff)
+
+    rx = integer_repr(x)
+    ry = integer_repr(y)
+    return _diff(rx, ry, t)
+
+
+def _integer_repr(x, vdt, comp):
+    # Reinterpret binary representation of the float as sign-magnitude:
+    # take into account two-complement representation
+    # See also
+    # https://randomascii.wordpress.com/2012/02/25/comparing-floating-point-numbers-2012-edition/
+    rx = x.view(vdt)
+    if not (rx.size == 1):
+        rx[rx < 0] = comp - rx[rx < 0]
+    else:
+        if rx < 0:
+            rx = comp - rx
+
+    return rx
+
+
+def integer_repr(x):
+    """Return the signed-magnitude interpretation of the binary representation
+    of x."""
+    import numpy as np
+    if x.dtype == np.float16:
+        return _integer_repr(x, np.int16, np.int16(-2**15))
+    elif x.dtype == np.float32:
+        return _integer_repr(x, np.int32, np.int32(-2**31))
+    elif x.dtype == np.float64:
+        return _integer_repr(x, np.int64, np.int64(-2**63))
+    else:
+        raise ValueError(f'Unsupported dtype {x.dtype}')
+
+
+@contextlib.contextmanager
+def _assert_warns_context(warning_class, name=None):
+    __tracebackhide__ = True  # Hide traceback for py.test
+    with suppress_warnings() as sup:
+        l = sup.record(warning_class)
+        yield
+        if not len(l) > 0:
+            name_str = f' when calling {name}' if name is not None else ''
+            raise AssertionError("No warning raised" + name_str)
+
+
+def assert_warns(warning_class, *args, **kwargs):
+    """
+    Fail unless the given callable throws the specified warning.
+
+    A warning of class warning_class should be thrown by the callable when
+    invoked with arguments args and keyword arguments kwargs.
+    If a different type of warning is thrown, it will not be caught.
+
+    If called with all arguments other than the warning class omitted, may be
+    used as a context manager::
+
+        with assert_warns(SomeWarning):
+            do_something()
+
+    The ability to be used as a context manager is new in NumPy v1.11.0.
+
+    .. versionadded:: 1.4.0
+
+    Parameters
+    ----------
+    warning_class : class
+        The class defining the warning that `func` is expected to throw.
+    func : callable, optional
+        Callable to test
+    *args : Arguments
+        Arguments for `func`.
+    **kwargs : Kwargs
+        Keyword arguments for `func`.
+
+    Returns
+    -------
+    The value returned by `func`.
+
+    Examples
+    --------
+    >>> import warnings
+    >>> def deprecated_func(num):
+    ...     warnings.warn("Please upgrade", DeprecationWarning)
+    ...     return num*num
+    >>> with np.testing.assert_warns(DeprecationWarning):
+    ...     assert deprecated_func(4) == 16
+    >>> # or passing a func
+    >>> ret = np.testing.assert_warns(DeprecationWarning, deprecated_func, 4)
+    >>> assert ret == 16
+    """
+    if not args and not kwargs:
+        return _assert_warns_context(warning_class)
+    elif len(args) < 1:
+        if "match" in kwargs:
+            raise RuntimeError(
+                "assert_warns does not use 'match' kwarg, "
+                "use pytest.warns instead"
+                )
+        raise RuntimeError("assert_warns(...) needs at least one arg")
+
+    func = args[0]
+    args = args[1:]
+    with _assert_warns_context(warning_class, name=func.__name__):
+        return func(*args, **kwargs)
+
+
+@contextlib.contextmanager
+def _assert_no_warnings_context(name=None):
+    __tracebackhide__ = True  # Hide traceback for py.test
+    with warnings.catch_warnings(record=True) as l:
+        warnings.simplefilter('always')
+        yield
+        if len(l) > 0:
+            name_str = f' when calling {name}' if name is not None else ''
+            raise AssertionError(f'Got warnings{name_str}: {l}')
+
+
+def assert_no_warnings(*args, **kwargs):
+    """
+    Fail if the given callable produces any warnings.
+
+    If called with all arguments omitted, may be used as a context manager::
+
+        with assert_no_warnings():
+            do_something()
+
+    The ability to be used as a context manager is new in NumPy v1.11.0.
+
+    .. versionadded:: 1.7.0
+
+    Parameters
+    ----------
+    func : callable
+        The callable to test.
+    \\*args : Arguments
+        Arguments passed to `func`.
+    \\*\\*kwargs : Kwargs
+        Keyword arguments passed to `func`.
+
+    Returns
+    -------
+    The value returned by `func`.
+
+    """
+    if not args:
+        return _assert_no_warnings_context()
+
+    func = args[0]
+    args = args[1:]
+    with _assert_no_warnings_context(name=func.__name__):
+        return func(*args, **kwargs)
+
+
+def _gen_alignment_data(dtype=float32, type='binary', max_size=24):
+    """
+    generator producing data with different alignment and offsets
+    to test simd vectorization
+
+    Parameters
+    ----------
+    dtype : dtype
+        data type to produce
+    type : string
+        'unary': create data for unary operations, creates one input
+                 and output array
+        'binary': create data for unary operations, creates two input
+                 and output array
+    max_size : integer
+        maximum size of data to produce
+
+    Returns
+    -------
+    if type is 'unary' yields one output, one input array and a message
+    containing information on the data
+    if type is 'binary' yields one output array, two input array and a message
+    containing information on the data
+
+    """
+    ufmt = 'unary offset=(%d, %d), size=%d, dtype=%r, %s'
+    bfmt = 'binary offset=(%d, %d, %d), size=%d, dtype=%r, %s'
+    for o in range(3):
+        for s in range(o + 2, max(o + 3, max_size)):
+            if type == 'unary':
+                inp = lambda: arange(s, dtype=dtype)[o:]
+                out = empty((s,), dtype=dtype)[o:]
+                yield out, inp(), ufmt % (o, o, s, dtype, 'out of place')
+                d = inp()
+                yield d, d, ufmt % (o, o, s, dtype, 'in place')
+                yield out[1:], inp()[:-1], ufmt % \
+                    (o + 1, o, s - 1, dtype, 'out of place')
+                yield out[:-1], inp()[1:], ufmt % \
+                    (o, o + 1, s - 1, dtype, 'out of place')
+                yield inp()[:-1], inp()[1:], ufmt % \
+                    (o, o + 1, s - 1, dtype, 'aliased')
+                yield inp()[1:], inp()[:-1], ufmt % \
+                    (o + 1, o, s - 1, dtype, 'aliased')
+            if type == 'binary':
+                inp1 = lambda: arange(s, dtype=dtype)[o:]
+                inp2 = lambda: arange(s, dtype=dtype)[o:]
+                out = empty((s,), dtype=dtype)[o:]
+                yield out, inp1(), inp2(),  bfmt % \
+                    (o, o, o, s, dtype, 'out of place')
+                d = inp1()
+                yield d, d, inp2(), bfmt % \
+                    (o, o, o, s, dtype, 'in place1')
+                d = inp2()
+                yield d, inp1(), d, bfmt % \
+                    (o, o, o, s, dtype, 'in place2')
+                yield out[1:], inp1()[:-1], inp2()[:-1], bfmt % \
+                    (o + 1, o, o, s - 1, dtype, 'out of place')
+                yield out[:-1], inp1()[1:], inp2()[:-1], bfmt % \
+                    (o, o + 1, o, s - 1, dtype, 'out of place')
+                yield out[:-1], inp1()[:-1], inp2()[1:], bfmt % \
+                    (o, o, o + 1, s - 1, dtype, 'out of place')
+                yield inp1()[1:], inp1()[:-1], inp2()[:-1], bfmt % \
+                    (o + 1, o, o, s - 1, dtype, 'aliased')
+                yield inp1()[:-1], inp1()[1:], inp2()[:-1], bfmt % \
+                    (o, o + 1, o, s - 1, dtype, 'aliased')
+                yield inp1()[:-1], inp1()[:-1], inp2()[1:], bfmt % \
+                    (o, o, o + 1, s - 1, dtype, 'aliased')
+
+
+class IgnoreException(Exception):
+    "Ignoring this exception due to disabled feature"
+    pass
+
+
+@contextlib.contextmanager
+def tempdir(*args, **kwargs):
+    """Context manager to provide a temporary test folder.
+
+    All arguments are passed as this to the underlying tempfile.mkdtemp
+    function.
+
+    """
+    tmpdir = mkdtemp(*args, **kwargs)
+    try:
+        yield tmpdir
+    finally:
+        shutil.rmtree(tmpdir)
+
+
+@contextlib.contextmanager
+def temppath(*args, **kwargs):
+    """Context manager for temporary files.
+
+    Context manager that returns the path to a closed temporary file. Its
+    parameters are the same as for tempfile.mkstemp and are passed directly
+    to that function. The underlying file is removed when the context is
+    exited, so it should be closed at that time.
+
+    Windows does not allow a temporary file to be opened if it is already
+    open, so the underlying file must be closed after opening before it
+    can be opened again.
+
+    """
+    fd, path = mkstemp(*args, **kwargs)
+    os.close(fd)
+    try:
+        yield path
+    finally:
+        os.remove(path)
+
+
+class clear_and_catch_warnings(warnings.catch_warnings):
+    """ Context manager that resets warning registry for catching warnings
+
+    Warnings can be slippery, because, whenever a warning is triggered, Python
+    adds a ``__warningregistry__`` member to the *calling* module.  This makes
+    it impossible to retrigger the warning in this module, whatever you put in
+    the warnings filters.  This context manager accepts a sequence of `modules`
+    as a keyword argument to its constructor and:
+
+    * stores and removes any ``__warningregistry__`` entries in given `modules`
+      on entry;
+    * resets ``__warningregistry__`` to its previous state on exit.
+
+    This makes it possible to trigger any warning afresh inside the context
+    manager without disturbing the state of warnings outside.
+
+    For compatibility with Python 3.0, please consider all arguments to be
+    keyword-only.
+
+    Parameters
+    ----------
+    record : bool, optional
+        Specifies whether warnings should be captured by a custom
+        implementation of ``warnings.showwarning()`` and be appended to a list
+        returned by the context manager. Otherwise None is returned by the
+        context manager. The objects appended to the list are arguments whose
+        attributes mirror the arguments to ``showwarning()``.
+    modules : sequence, optional
+        Sequence of modules for which to reset warnings registry on entry and
+        restore on exit. To work correctly, all 'ignore' filters should
+        filter by one of these modules.
+
+    Examples
+    --------
+    >>> import warnings
+    >>> with np.testing.clear_and_catch_warnings(
+    ...         modules=[np._core.fromnumeric]):
+    ...     warnings.simplefilter('always')
+    ...     warnings.filterwarnings('ignore', module='np._core.fromnumeric')
+    ...     # do something that raises a warning but ignore those in
+    ...     # np._core.fromnumeric
+    """
+    class_modules = ()
+
+    def __init__(self, record=False, modules=()):
+        self.modules = set(modules).union(self.class_modules)
+        self._warnreg_copies = {}
+        super().__init__(record=record)
+
+    def __enter__(self):
+        for mod in self.modules:
+            if hasattr(mod, '__warningregistry__'):
+                mod_reg = mod.__warningregistry__
+                self._warnreg_copies[mod] = mod_reg.copy()
+                mod_reg.clear()
+        return super().__enter__()
+
+    def __exit__(self, *exc_info):
+        super().__exit__(*exc_info)
+        for mod in self.modules:
+            if hasattr(mod, '__warningregistry__'):
+                mod.__warningregistry__.clear()
+            if mod in self._warnreg_copies:
+                mod.__warningregistry__.update(self._warnreg_copies[mod])
+
+
+class suppress_warnings:
+    """
+    Context manager and decorator doing much the same as
+    ``warnings.catch_warnings``.
+
+    However, it also provides a filter mechanism to work around
+    https://bugs.python.org/issue4180.
+
+    This bug causes Python before 3.4 to not reliably show warnings again
+    after they have been ignored once (even within catch_warnings). It
+    means that no "ignore" filter can be used easily, since following
+    tests might need to see the warning. Additionally it allows easier
+    specificity for testing warnings and can be nested.
+
+    Parameters
+    ----------
+    forwarding_rule : str, optional
+        One of "always", "once", "module", or "location". Analogous to
+        the usual warnings module filter mode, it is useful to reduce
+        noise mostly on the outmost level. Unsuppressed and unrecorded
+        warnings will be forwarded based on this rule. Defaults to "always".
+        "location" is equivalent to the warnings "default", match by exact
+        location the warning warning originated from.
+
+    Notes
+    -----
+    Filters added inside the context manager will be discarded again
+    when leaving it. Upon entering all filters defined outside a
+    context will be applied automatically.
+
+    When a recording filter is added, matching warnings are stored in the
+    ``log`` attribute as well as in the list returned by ``record``.
+
+    If filters are added and the ``module`` keyword is given, the
+    warning registry of this module will additionally be cleared when
+    applying it, entering the context, or exiting it. This could cause
+    warnings to appear a second time after leaving the context if they
+    were configured to be printed once (default) and were already
+    printed before the context was entered.
+
+    Nesting this context manager will work as expected when the
+    forwarding rule is "always" (default). Unfiltered and unrecorded
+    warnings will be passed out and be matched by the outer level.
+    On the outmost level they will be printed (or caught by another
+    warnings context). The forwarding rule argument can modify this
+    behaviour.
+
+    Like ``catch_warnings`` this context manager is not threadsafe.
+
+    Examples
+    --------
+
+    With a context manager::
+
+        with np.testing.suppress_warnings() as sup:
+            sup.filter(DeprecationWarning, "Some text")
+            sup.filter(module=np.ma.core)
+            log = sup.record(FutureWarning, "Does this occur?")
+            command_giving_warnings()
+            # The FutureWarning was given once, the filtered warnings were
+            # ignored. All other warnings abide outside settings (may be
+            # printed/error)
+            assert_(len(log) == 1)
+            assert_(len(sup.log) == 1)  # also stored in log attribute
+
+    Or as a decorator::
+
+        sup = np.testing.suppress_warnings()
+        sup.filter(module=np.ma.core)  # module must match exactly
+        @sup
+        def some_function():
+            # do something which causes a warning in np.ma.core
+            pass
+    """
+    def __init__(self, forwarding_rule="always"):
+        self._entered = False
+
+        # Suppressions are either instance or defined inside one with block:
+        self._suppressions = []
+
+        if forwarding_rule not in {"always", "module", "once", "location"}:
+            raise ValueError("unsupported forwarding rule.")
+        self._forwarding_rule = forwarding_rule
+
+    def _clear_registries(self):
+        if hasattr(warnings, "_filters_mutated"):
+            # clearing the registry should not be necessary on new pythons,
+            # instead the filters should be mutated.
+            warnings._filters_mutated()
+            return
+        # Simply clear the registry, this should normally be harmless,
+        # note that on new pythons it would be invalidated anyway.
+        for module in self._tmp_modules:
+            if hasattr(module, "__warningregistry__"):
+                module.__warningregistry__.clear()
+
+    def _filter(self, category=Warning, message="", module=None, record=False):
+        if record:
+            record = []  # The log where to store warnings
+        else:
+            record = None
+        if self._entered:
+            if module is None:
+                warnings.filterwarnings(
+                    "always", category=category, message=message)
+            else:
+                module_regex = module.__name__.replace('.', r'\.') + '$'
+                warnings.filterwarnings(
+                    "always", category=category, message=message,
+                    module=module_regex)
+                self._tmp_modules.add(module)
+                self._clear_registries()
+
+            self._tmp_suppressions.append(
+                (category, message, re.compile(message, re.I), module, record))
+        else:
+            self._suppressions.append(
+                (category, message, re.compile(message, re.I), module, record))
+
+        return record
+
+    def filter(self, category=Warning, message="", module=None):
+        """
+        Add a new suppressing filter or apply it if the state is entered.
+
+        Parameters
+        ----------
+        category : class, optional
+            Warning class to filter
+        message : string, optional
+            Regular expression matching the warning message.
+        module : module, optional
+            Module to filter for. Note that the module (and its file)
+            must match exactly and cannot be a submodule. This may make
+            it unreliable for external modules.
+
+        Notes
+        -----
+        When added within a context, filters are only added inside
+        the context and will be forgotten when the context is exited.
+        """
+        self._filter(category=category, message=message, module=module,
+                     record=False)
+
+    def record(self, category=Warning, message="", module=None):
+        """
+        Append a new recording filter or apply it if the state is entered.
+
+        All warnings matching will be appended to the ``log`` attribute.
+
+        Parameters
+        ----------
+        category : class, optional
+            Warning class to filter
+        message : string, optional
+            Regular expression matching the warning message.
+        module : module, optional
+            Module to filter for. Note that the module (and its file)
+            must match exactly and cannot be a submodule. This may make
+            it unreliable for external modules.
+
+        Returns
+        -------
+        log : list
+            A list which will be filled with all matched warnings.
+
+        Notes
+        -----
+        When added within a context, filters are only added inside
+        the context and will be forgotten when the context is exited.
+        """
+        return self._filter(category=category, message=message, module=module,
+                            record=True)
+
+    def __enter__(self):
+        if self._entered:
+            raise RuntimeError("cannot enter suppress_warnings twice.")
+
+        self._orig_show = warnings.showwarning
+        self._filters = warnings.filters
+        warnings.filters = self._filters[:]
+
+        self._entered = True
+        self._tmp_suppressions = []
+        self._tmp_modules = set()
+        self._forwarded = set()
+
+        self.log = []  # reset global log (no need to keep same list)
+
+        for cat, mess, _, mod, log in self._suppressions:
+            if log is not None:
+                del log[:]  # clear the log
+            if mod is None:
+                warnings.filterwarnings(
+                    "always", category=cat, message=mess)
+            else:
+                module_regex = mod.__name__.replace('.', r'\.') + '$'
+                warnings.filterwarnings(
+                    "always", category=cat, message=mess,
+                    module=module_regex)
+                self._tmp_modules.add(mod)
+        warnings.showwarning = self._showwarning
+        self._clear_registries()
+
+        return self
+
+    def __exit__(self, *exc_info):
+        warnings.showwarning = self._orig_show
+        warnings.filters = self._filters
+        self._clear_registries()
+        self._entered = False
+        del self._orig_show
+        del self._filters
+
+    def _showwarning(self, message, category, filename, lineno,
+                     *args, use_warnmsg=None, **kwargs):
+        for cat, _, pattern, mod, rec in (
+                self._suppressions + self._tmp_suppressions)[::-1]:
+            if (issubclass(category, cat) and
+                    pattern.match(message.args[0]) is not None):
+                if mod is None:
+                    # Message and category match, either recorded or ignored
+                    if rec is not None:
+                        msg = WarningMessage(message, category, filename,
+                                             lineno, **kwargs)
+                        self.log.append(msg)
+                        rec.append(msg)
+                    return
+                # Use startswith, because warnings strips the c or o from
+                # .pyc/.pyo files.
+                elif mod.__file__.startswith(filename):
+                    # The message and module (filename) match
+                    if rec is not None:
+                        msg = WarningMessage(message, category, filename,
+                                             lineno, **kwargs)
+                        self.log.append(msg)
+                        rec.append(msg)
+                    return
+
+        # There is no filter in place, so pass to the outside handler
+        # unless we should only pass it once
+        if self._forwarding_rule == "always":
+            if use_warnmsg is None:
+                self._orig_show(message, category, filename, lineno,
+                                *args, **kwargs)
+            else:
+                self._orig_showmsg(use_warnmsg)
+            return
+
+        if self._forwarding_rule == "once":
+            signature = (message.args, category)
+        elif self._forwarding_rule == "module":
+            signature = (message.args, category, filename)
+        elif self._forwarding_rule == "location":
+            signature = (message.args, category, filename, lineno)
+
+        if signature in self._forwarded:
+            return
+        self._forwarded.add(signature)
+        if use_warnmsg is None:
+            self._orig_show(message, category, filename, lineno, *args,
+                            **kwargs)
+        else:
+            self._orig_showmsg(use_warnmsg)
+
+    def __call__(self, func):
+        """
+        Function decorator to apply certain suppressions to a whole
+        function.
+        """
+        @wraps(func)
+        def new_func(*args, **kwargs):
+            with self:
+                return func(*args, **kwargs)
+
+        return new_func
+
+
+@contextlib.contextmanager
+def _assert_no_gc_cycles_context(name=None):
+    __tracebackhide__ = True  # Hide traceback for py.test
+
+    # not meaningful to test if there is no refcounting
+    if not HAS_REFCOUNT:
+        yield
+        return
+
+    assert_(gc.isenabled())
+    gc.disable()
+    gc_debug = gc.get_debug()
+    try:
+        for i in range(100):
+            if gc.collect() == 0:
+                break
+        else:
+            raise RuntimeError(
+                "Unable to fully collect garbage - perhaps a __del__ method "
+                "is creating more reference cycles?")
+
+        gc.set_debug(gc.DEBUG_SAVEALL)
+        yield
+        # gc.collect returns the number of unreachable objects in cycles that
+        # were found -- we are checking that no cycles were created in the context
+        n_objects_in_cycles = gc.collect()
+        objects_in_cycles = gc.garbage[:]
+    finally:
+        del gc.garbage[:]
+        gc.set_debug(gc_debug)
+        gc.enable()
+
+    if n_objects_in_cycles:
+        name_str = f' when calling {name}' if name is not None else ''
+        raise AssertionError(
+            "Reference cycles were found{}: {} objects were collected, "
+            "of which {} are shown below:{}"
+            .format(
+                name_str,
+                n_objects_in_cycles,
+                len(objects_in_cycles),
+                ''.join(
+                    "\n  {} object with id={}:\n    {}".format(
+                        type(o).__name__,
+                        id(o),
+                        pprint.pformat(o).replace('\n', '\n    ')
+                    ) for o in objects_in_cycles
+                )
+            )
+        )
+
+
+def assert_no_gc_cycles(*args, **kwargs):
+    """
+    Fail if the given callable produces any reference cycles.
+
+    If called with all arguments omitted, may be used as a context manager::
+
+        with assert_no_gc_cycles():
+            do_something()
+
+    .. versionadded:: 1.15.0
+
+    Parameters
+    ----------
+    func : callable
+        The callable to test.
+    \\*args : Arguments
+        Arguments passed to `func`.
+    \\*\\*kwargs : Kwargs
+        Keyword arguments passed to `func`.
+
+    Returns
+    -------
+    Nothing. The result is deliberately discarded to ensure that all cycles
+    are found.
+
+    """
+    if not args:
+        return _assert_no_gc_cycles_context()
+
+    func = args[0]
+    args = args[1:]
+    with _assert_no_gc_cycles_context(name=func.__name__):
+        func(*args, **kwargs)
+
+
+def break_cycles():
+    """
+    Break reference cycles by calling gc.collect
+    Objects can call other objects' methods (for instance, another object's
+     __del__) inside their own __del__. On PyPy, the interpreter only runs
+    between calls to gc.collect, so multiple calls are needed to completely
+    release all cycles.
+    """
+
+    gc.collect()
+    if IS_PYPY:
+        # a few more, just to make sure all the finalizers are called
+        gc.collect()
+        gc.collect()
+        gc.collect()
+        gc.collect()
+
+
+def requires_memory(free_bytes):
+    """Decorator to skip a test if not enough memory is available"""
+    import pytest
+
+    def decorator(func):
+        @wraps(func)
+        def wrapper(*a, **kw):
+            msg = check_free_memory(free_bytes)
+            if msg is not None:
+                pytest.skip(msg)
+
+            try:
+                return func(*a, **kw)
+            except MemoryError:
+                # Probably ran out of memory regardless: don't regard as failure
+                pytest.xfail("MemoryError raised")
+
+        return wrapper
+
+    return decorator
+
+
+def check_free_memory(free_bytes):
+    """
+    Check whether `free_bytes` amount of memory is currently free.
+    Returns: None if enough memory available, otherwise error message
+    """
+    env_var = 'NPY_AVAILABLE_MEM'
+    env_value = os.environ.get(env_var)
+    if env_value is not None:
+        try:
+            mem_free = _parse_size(env_value)
+        except ValueError as exc:
+            raise ValueError(f'Invalid environment variable {env_var}: {exc}')
+
+        msg = (f'{free_bytes/1e9} GB memory required, but environment variable '
+               f'NPY_AVAILABLE_MEM={env_value} set')
+    else:
+        mem_free = _get_mem_available()
+
+        if mem_free is None:
+            msg = ("Could not determine available memory; set NPY_AVAILABLE_MEM "
+                   "environment variable (e.g. NPY_AVAILABLE_MEM=16GB) to run "
+                   "the test.")
+            mem_free = -1
+        else:
+            msg = f'{free_bytes/1e9} GB memory required, but {mem_free/1e9} GB available'
+
+    return msg if mem_free < free_bytes else None
+
+
+def _parse_size(size_str):
+    """Convert memory size strings ('12 GB' etc.) to float"""
+    suffixes = {'': 1, 'b': 1,
+                'k': 1000, 'm': 1000**2, 'g': 1000**3, 't': 1000**4,
+                'kb': 1000, 'mb': 1000**2, 'gb': 1000**3, 'tb': 1000**4,
+                'kib': 1024, 'mib': 1024**2, 'gib': 1024**3, 'tib': 1024**4}
+
+    size_re = re.compile(r'^\s*(\d+|\d+\.\d+)\s*({0})\s*$'.format(
+        '|'.join(suffixes.keys())), re.I)
+
+    m = size_re.match(size_str.lower())
+    if not m or m.group(2) not in suffixes:
+        raise ValueError(f'value {size_str!r} not a valid size')
+    return int(float(m.group(1)) * suffixes[m.group(2)])
+
+
+def _get_mem_available():
+    """Return available memory in bytes, or None if unknown."""
+    try:
+        import psutil
+        return psutil.virtual_memory().available
+    except (ImportError, AttributeError):
+        pass
+
+    if sys.platform.startswith('linux'):
+        info = {}
+        with open('/proc/meminfo') as f:
+            for line in f:
+                p = line.split()
+                info[p[0].strip(':').lower()] = int(p[1]) * 1024
+
+        if 'memavailable' in info:
+            # Linux >= 3.14
+            return info['memavailable']
+        else:
+            return info['memfree'] + info['cached']
+
+    return None
+
+
+def _no_tracing(func):
+    """
+    Decorator to temporarily turn off tracing for the duration of a test.
+    Needed in tests that check refcounting, otherwise the tracing itself
+    influences the refcounts
+    """
+    if not hasattr(sys, 'gettrace'):
+        return func
+    else:
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            original_trace = sys.gettrace()
+            try:
+                sys.settrace(None)
+                return func(*args, **kwargs)
+            finally:
+                sys.settrace(original_trace)
+        return wrapper
+
+
+def _get_glibc_version():
+    try:
+        ver = os.confstr('CS_GNU_LIBC_VERSION').rsplit(' ')[1]
+    except Exception:
+        ver = '0.0'
+
+    return ver
+
+
+_glibcver = _get_glibc_version()
+_glibc_older_than = lambda x: (_glibcver != '0.0' and _glibcver < x)
+
+
+def run_threaded(func, iters, pass_count=False):
+    """Runs a function many times in parallel"""
+    with concurrent.futures.ThreadPoolExecutor(max_workers=8) as tpe:
+        if pass_count:
+            futures = [tpe.submit(func, i) for i in range(iters)]
+        else:
+            futures = [tpe.submit(func) for _ in range(iters)]
+        for f in futures:
+            f.result()
diff --git a/venv/lib/python3.12/site-packages/numpy/testing/_private/utils.pyi b/venv/lib/python3.12/site-packages/numpy/testing/_private/utils.pyi
new file mode 100644
index 00000000..113457ae
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/testing/_private/utils.pyi
@@ -0,0 +1,413 @@
+import os
+import sys
+import ast
+import types
+import warnings
+import unittest
+import contextlib
+from re import Pattern
+from collections.abc import Callable, Iterable, Sequence
+from typing import (
+    Literal as L,
+    Any,
+    AnyStr,
+    ClassVar,
+    NoReturn,
+    overload,
+    type_check_only,
+    TypeVar,
+    Final,
+    SupportsIndex,
+    ParamSpec
+)
+
+import numpy as np
+from numpy import number, object_, _FloatValue
+from numpy._typing import (
+    NDArray,
+    ArrayLike,
+    DTypeLike,
+    _ArrayLikeNumber_co,
+    _ArrayLikeObject_co,
+    _ArrayLikeTD64_co,
+    _ArrayLikeDT64_co,
+)
+
+from unittest.case import (
+    SkipTest as SkipTest,
+)
+
+_P = ParamSpec("_P")
+_T = TypeVar("_T")
+_ET = TypeVar("_ET", bound=BaseException)
+_FT = TypeVar("_FT", bound=Callable[..., Any])
+
+# Must return a bool or an ndarray/generic type
+# that is supported by `np.logical_and.reduce`
+_ComparisonFunc = Callable[
+    [NDArray[Any], NDArray[Any]],
+    (
+        bool
+        | np.bool
+        | number[Any]
+        | NDArray[np.bool | number[Any] | object_]
+    )
+]
+
+__all__: list[str]
+
+class KnownFailureException(Exception): ...
+class IgnoreException(Exception): ...
+
+class clear_and_catch_warnings(warnings.catch_warnings):
+    class_modules: ClassVar[tuple[types.ModuleType, ...]]
+    modules: set[types.ModuleType]
+    @overload
+    def __new__(
+        cls,
+        record: L[False] = ...,
+        modules: Iterable[types.ModuleType] = ...,
+    ) -> _clear_and_catch_warnings_without_records: ...
+    @overload
+    def __new__(
+        cls,
+        record: L[True],
+        modules: Iterable[types.ModuleType] = ...,
+    ) -> _clear_and_catch_warnings_with_records: ...
+    @overload
+    def __new__(
+        cls,
+        record: bool,
+        modules: Iterable[types.ModuleType] = ...,
+    ) -> clear_and_catch_warnings: ...
+    def __enter__(self) -> None | list[warnings.WarningMessage]: ...
+    def __exit__(
+        self,
+        __exc_type: None | type[BaseException] = ...,
+        __exc_val: None | BaseException = ...,
+        __exc_tb: None | types.TracebackType = ...,
+    ) -> None: ...
+
+# Type-check only `clear_and_catch_warnings` subclasses for both values of the
+# `record` parameter. Copied from the stdlib `warnings` stubs.
+
+@type_check_only
+class _clear_and_catch_warnings_with_records(clear_and_catch_warnings):
+    def __enter__(self) -> list[warnings.WarningMessage]: ...
+
+@type_check_only
+class _clear_and_catch_warnings_without_records(clear_and_catch_warnings):
+    def __enter__(self) -> None: ...
+
+class suppress_warnings:
+    log: list[warnings.WarningMessage]
+    def __init__(
+        self,
+        forwarding_rule: L["always", "module", "once", "location"] = ...,
+    ) -> None: ...
+    def filter(
+        self,
+        category: type[Warning] = ...,
+        message: str = ...,
+        module: None | types.ModuleType = ...,
+    ) -> None: ...
+    def record(
+        self,
+        category: type[Warning] = ...,
+        message: str = ...,
+        module: None | types.ModuleType = ...,
+    ) -> list[warnings.WarningMessage]: ...
+    def __enter__(self: _T) -> _T: ...
+    def __exit__(
+        self,
+        __exc_type: None | type[BaseException] = ...,
+        __exc_val: None | BaseException = ...,
+        __exc_tb: None | types.TracebackType = ...,
+    ) -> None: ...
+    def __call__(self, func: _FT) -> _FT: ...
+
+verbose: int
+IS_PYPY: Final[bool]
+IS_PYSTON: Final[bool]
+HAS_REFCOUNT: Final[bool]
+HAS_LAPACK64: Final[bool]
+
+def assert_(val: object, msg: str | Callable[[], str] = ...) -> None: ...
+
+# Contrary to runtime we can't do `os.name` checks while type checking,
+# only `sys.platform` checks
+if sys.platform == "win32" or sys.platform == "cygwin":
+    def memusage(processName: str = ..., instance: int = ...) -> int: ...
+elif sys.platform == "linux":
+    def memusage(_proc_pid_stat: str | bytes | os.PathLike[Any] = ...) -> None | int: ...
+else:
+    def memusage() -> NoReturn: ...
+
+if sys.platform == "linux":
+    def jiffies(
+        _proc_pid_stat: str | bytes | os.PathLike[Any] = ...,
+        _load_time: list[float] = ...,
+    ) -> int: ...
+else:
+    def jiffies(_load_time: list[float] = ...) -> int: ...
+
+def build_err_msg(
+    arrays: Iterable[object],
+    err_msg: str,
+    header: str = ...,
+    verbose: bool = ...,
+    names: Sequence[str] = ...,
+    precision: None | SupportsIndex = ...,
+) -> str: ...
+
+def assert_equal(
+    actual: object,
+    desired: object,
+    err_msg: object = ...,
+    verbose: bool = ...,
+    *,
+    strict: bool = ...
+) -> None: ...
+
+def print_assert_equal(
+    test_string: str,
+    actual: object,
+    desired: object,
+) -> None: ...
+
+def assert_almost_equal(
+    actual: _ArrayLikeNumber_co | _ArrayLikeObject_co,
+    desired: _ArrayLikeNumber_co | _ArrayLikeObject_co,
+    decimal: int = ...,
+    err_msg: object = ...,
+    verbose: bool = ...,
+) -> None: ...
+
+# Anything that can be coerced into `builtins.float`
+def assert_approx_equal(
+    actual: _FloatValue,
+    desired: _FloatValue,
+    significant: int = ...,
+    err_msg: object = ...,
+    verbose: bool = ...,
+) -> None: ...
+
+def assert_array_compare(
+    comparison: _ComparisonFunc,
+    x: ArrayLike,
+    y: ArrayLike,
+    err_msg: object = ...,
+    verbose: bool = ...,
+    header: str = ...,
+    precision: SupportsIndex = ...,
+    equal_nan: bool = ...,
+    equal_inf: bool = ...,
+    *,
+    strict: bool = ...
+) -> None: ...
+
+def assert_array_equal(
+    x: ArrayLike,
+    y: ArrayLike,
+    /,
+    err_msg: object = ...,
+    verbose: bool = ...,
+    *,
+    strict: bool = ...
+) -> None: ...
+
+def assert_array_almost_equal(
+    x: _ArrayLikeNumber_co | _ArrayLikeObject_co,
+    y: _ArrayLikeNumber_co | _ArrayLikeObject_co,
+    /,
+    decimal: float = ...,
+    err_msg: object = ...,
+    verbose: bool = ...,
+) -> None: ...
+
+@overload
+def assert_array_less(
+    x: _ArrayLikeNumber_co | _ArrayLikeObject_co,
+    y: _ArrayLikeNumber_co | _ArrayLikeObject_co,
+    err_msg: object = ...,
+    verbose: bool = ...,
+    *,
+    strict: bool = ...
+) -> None: ...
+@overload
+def assert_array_less(
+    x: _ArrayLikeTD64_co,
+    y: _ArrayLikeTD64_co,
+    err_msg: object = ...,
+    verbose: bool = ...,
+    *,
+    strict: bool = ...
+) -> None: ...
+@overload
+def assert_array_less(
+    x: _ArrayLikeDT64_co,
+    y: _ArrayLikeDT64_co,
+    err_msg: object = ...,
+    verbose: bool = ...,
+    *,
+    strict: bool = ...
+) -> None: ...
+
+def runstring(
+    astr: str | bytes | types.CodeType,
+    dict: None | dict[str, Any],
+) -> Any: ...
+
+def assert_string_equal(actual: str, desired: str) -> None: ...
+
+def rundocs(
+    filename: None | str | os.PathLike[str] = ...,
+    raise_on_error: bool = ...,
+) -> None: ...
+
+def raises(*args: type[BaseException]) -> Callable[[_FT], _FT]: ...
+
+@overload
+def assert_raises(  # type: ignore
+    expected_exception: type[BaseException] | tuple[type[BaseException], ...],
+    callable: Callable[_P, Any],
+    /,
+    *args: _P.args,
+    **kwargs: _P.kwargs,
+) -> None: ...
+@overload
+def assert_raises(
+    expected_exception: type[_ET] | tuple[type[_ET], ...],
+    *,
+    msg: None | str = ...,
+) -> unittest.case._AssertRaisesContext[_ET]: ...
+
+@overload
+def assert_raises_regex(
+    expected_exception: type[BaseException] | tuple[type[BaseException], ...],
+    expected_regex: str | bytes | Pattern[Any],
+    callable: Callable[_P, Any],
+    /,
+    *args: _P.args,
+    **kwargs: _P.kwargs,
+) -> None: ...
+@overload
+def assert_raises_regex(
+    expected_exception: type[_ET] | tuple[type[_ET], ...],
+    expected_regex: str | bytes | Pattern[Any],
+    *,
+    msg: None | str = ...,
+) -> unittest.case._AssertRaisesContext[_ET]: ...
+
+def decorate_methods(
+    cls: type[Any],
+    decorator: Callable[[Callable[..., Any]], Any],
+    testmatch: None | str | bytes | Pattern[Any] = ...,
+) -> None: ...
+
+def measure(
+    code_str: str | bytes | ast.mod | ast.AST,
+    times: int = ...,
+    label: None | str = ...,
+) -> float: ...
+
+@overload
+def assert_allclose(
+    actual: _ArrayLikeNumber_co | _ArrayLikeObject_co,
+    desired: _ArrayLikeNumber_co | _ArrayLikeObject_co,
+    rtol: float = ...,
+    atol: float = ...,
+    equal_nan: bool = ...,
+    err_msg: object = ...,
+    verbose: bool = ...,
+    *,
+    strict: bool = ...
+) -> None: ...
+@overload
+def assert_allclose(
+    actual: _ArrayLikeTD64_co,
+    desired: _ArrayLikeTD64_co,
+    rtol: float = ...,
+    atol: float = ...,
+    equal_nan: bool = ...,
+    err_msg: object = ...,
+    verbose: bool = ...,
+    *,
+    strict: bool = ...
+) -> None: ...
+
+def assert_array_almost_equal_nulp(
+    x: _ArrayLikeNumber_co,
+    y: _ArrayLikeNumber_co,
+    nulp: float = ...,
+) -> None: ...
+
+def assert_array_max_ulp(
+    a: _ArrayLikeNumber_co,
+    b: _ArrayLikeNumber_co,
+    maxulp: float = ...,
+    dtype: DTypeLike = ...,
+) -> NDArray[Any]: ...
+
+@overload
+def assert_warns(
+    warning_class: type[Warning],
+) -> contextlib._GeneratorContextManager[None]: ...
+@overload
+def assert_warns(
+    warning_class: type[Warning],
+    func: Callable[_P, _T],
+    /,
+    *args: _P.args,
+    **kwargs: _P.kwargs,
+) -> _T: ...
+
+@overload
+def assert_no_warnings() -> contextlib._GeneratorContextManager[None]: ...
+@overload
+def assert_no_warnings(
+    func: Callable[_P, _T],
+    /,
+    *args: _P.args,
+    **kwargs: _P.kwargs,
+) -> _T: ...
+
+@overload
+def tempdir(
+    suffix: None = ...,
+    prefix: None = ...,
+    dir: None = ...,
+) -> contextlib._GeneratorContextManager[str]: ...
+@overload
+def tempdir(
+    suffix: None | AnyStr = ...,
+    prefix: None | AnyStr = ...,
+    dir: None | AnyStr | os.PathLike[AnyStr] = ...,
+) -> contextlib._GeneratorContextManager[AnyStr]: ...
+
+@overload
+def temppath(
+    suffix: None = ...,
+    prefix: None = ...,
+    dir: None = ...,
+    text: bool = ...,
+) -> contextlib._GeneratorContextManager[str]: ...
+@overload
+def temppath(
+    suffix: None | AnyStr = ...,
+    prefix: None | AnyStr = ...,
+    dir: None | AnyStr | os.PathLike[AnyStr] = ...,
+    text: bool = ...,
+) -> contextlib._GeneratorContextManager[AnyStr]: ...
+
+@overload
+def assert_no_gc_cycles() -> contextlib._GeneratorContextManager[None]: ...
+@overload
+def assert_no_gc_cycles(
+    func: Callable[_P, Any],
+    /,
+    *args: _P.args,
+    **kwargs: _P.kwargs,
+) -> None: ...
+
+def break_cycles() -> None: ...
diff --git a/venv/lib/python3.12/site-packages/numpy/testing/overrides.py b/venv/lib/python3.12/site-packages/numpy/testing/overrides.py
new file mode 100644
index 00000000..98bed23c
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/testing/overrides.py
@@ -0,0 +1,83 @@
+"""Tools for testing implementations of __array_function__ and ufunc overrides
+
+
+"""
+
+from numpy._core.overrides import ARRAY_FUNCTIONS as _array_functions
+from numpy import ufunc as _ufunc
+import numpy._core.umath as _umath
+
+def get_overridable_numpy_ufuncs():
+    """List all numpy ufuncs overridable via `__array_ufunc__`
+
+    Parameters
+    ----------
+    None
+
+    Returns
+    -------
+    set
+        A set containing all overridable ufuncs in the public numpy API.
+    """
+    ufuncs = {obj for obj in _umath.__dict__.values()
+              if isinstance(obj, _ufunc)}
+    return ufuncs
+    
+
+def allows_array_ufunc_override(func):
+    """Determine if a function can be overridden via `__array_ufunc__`
+
+    Parameters
+    ----------
+    func : callable
+        Function that may be overridable via `__array_ufunc__`
+
+    Returns
+    -------
+    bool
+        `True` if `func` is overridable via `__array_ufunc__` and
+        `False` otherwise.
+
+    Notes
+    -----
+    This function is equivalent to ``isinstance(func, np.ufunc)`` and
+    will work correctly for ufuncs defined outside of Numpy.
+
+    """
+    return isinstance(func, np.ufunc)
+
+
+def get_overridable_numpy_array_functions():
+    """List all numpy functions overridable via `__array_function__`
+
+    Parameters
+    ----------
+    None
+
+    Returns
+    -------
+    set
+        A set containing all functions in the public numpy API that are
+        overridable via `__array_function__`.
+
+    """
+    # 'import numpy' doesn't import recfunctions, so make sure it's imported
+    # so ufuncs defined there show up in the ufunc listing
+    from numpy.lib import recfunctions
+    return _array_functions.copy()
+
+def allows_array_function_override(func):
+    """Determine if a Numpy function can be overridden via `__array_function__`
+
+    Parameters
+    ----------
+    func : callable
+        Function that may be overridable via `__array_function__`
+
+    Returns
+    -------
+    bool
+        `True` if `func` is a function in the Numpy API that is
+        overridable via `__array_function__` and `False` otherwise.
+    """
+    return func in _array_functions
diff --git a/venv/lib/python3.12/site-packages/numpy/testing/print_coercion_tables.py b/venv/lib/python3.12/site-packages/numpy/testing/print_coercion_tables.py
new file mode 100755
index 00000000..649c1cd6
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/testing/print_coercion_tables.py
@@ -0,0 +1,201 @@
+#!/usr/bin/env python3
+"""Prints type-coercion tables for the built-in NumPy types
+
+"""
+import numpy as np
+from numpy._core.numerictypes import obj2sctype
+from collections import namedtuple
+
+# Generic object that can be added, but doesn't do anything else
+class GenericObject:
+    def __init__(self, v):
+        self.v = v
+
+    def __add__(self, other):
+        return self
+
+    def __radd__(self, other):
+        return self
+
+    dtype = np.dtype('O')
+
+def print_cancast_table(ntypes):
+    print('X', end=' ')
+    for char in ntypes:
+        print(char, end=' ')
+    print()
+    for row in ntypes:
+        print(row, end=' ')
+        for col in ntypes:
+            if np.can_cast(row, col, "equiv"):
+                cast = "#"
+            elif np.can_cast(row, col, "safe"):
+                cast = "="
+            elif np.can_cast(row, col, "same_kind"):
+                cast = "~"
+            elif np.can_cast(row, col, "unsafe"):
+                cast = "."
+            else:
+                cast = " "
+            print(cast, end=' ')
+        print()
+
+def print_coercion_table(ntypes, inputfirstvalue, inputsecondvalue, firstarray, use_promote_types=False):
+    print('+', end=' ')
+    for char in ntypes:
+        print(char, end=' ')
+    print()
+    for row in ntypes:
+        if row == 'O':
+            rowtype = GenericObject
+        else:
+            rowtype = obj2sctype(row)
+
+        print(row, end=' ')
+        for col in ntypes:
+            if col == 'O':
+                coltype = GenericObject
+            else:
+                coltype = obj2sctype(col)
+            try:
+                if firstarray:
+                    rowvalue = np.array([rowtype(inputfirstvalue)], dtype=rowtype)
+                else:
+                    rowvalue = rowtype(inputfirstvalue)
+                colvalue = coltype(inputsecondvalue)
+                if use_promote_types:
+                    char = np.promote_types(rowvalue.dtype, colvalue.dtype).char
+                else:
+                    value = np.add(rowvalue, colvalue)
+                    if isinstance(value, np.ndarray):
+                        char = value.dtype.char
+                    else:
+                        char = np.dtype(type(value)).char
+            except ValueError:
+                char = '!'
+            except OverflowError:
+                char = '@'
+            except TypeError:
+                char = '#'
+            print(char, end=' ')
+        print()
+
+
+def print_new_cast_table(*, can_cast=True, legacy=False, flags=False):
+    """Prints new casts, the values given are default "can-cast" values, not
+    actual ones.
+    """
+    from numpy._core._multiarray_tests import get_all_cast_information
+
+    cast_table = {
+        -1: " ",
+        0: "#",  # No cast (classify as equivalent here)
+        1: "#",  # equivalent casting
+        2: "=",  # safe casting
+        3: "~",  # same-kind casting
+        4: ".",  # unsafe casting
+    }
+    flags_table = {
+        0 : "▗", 7: "█",
+        1: "▚", 2: "▐", 4: "▄",
+                3: "▜", 5: "▙",
+                        6: "▟",
+    }
+
+    cast_info = namedtuple("cast_info", ["can_cast", "legacy", "flags"])
+    no_cast_info = cast_info(" ", " ", " ")
+
+    casts = get_all_cast_information()
+    table = {}
+    dtypes = set()
+    for cast in casts:
+        dtypes.add(cast["from"])
+        dtypes.add(cast["to"])
+
+        if cast["from"] not in table:
+            table[cast["from"]] = {}
+        to_dict = table[cast["from"]]
+
+        can_cast = cast_table[cast["casting"]]
+        legacy = "L" if cast["legacy"] else "."
+        flags = 0
+        if cast["requires_pyapi"]:
+            flags |= 1
+        if cast["supports_unaligned"]:
+            flags |= 2
+        if cast["no_floatingpoint_errors"]:
+            flags |= 4
+
+        flags = flags_table[flags]
+        to_dict[cast["to"]] = cast_info(can_cast=can_cast, legacy=legacy, flags=flags)
+
+    # The np.dtype(x.type) is a bit strange, because dtype classes do
+    # not expose much yet.
+    types = np.typecodes["All"]
+    def sorter(x):
+        # This is a bit weird hack, to get a table as close as possible to
+        # the one printing all typecodes (but expecting user-dtypes).
+        dtype = np.dtype(x.type)
+        try:
+            indx = types.index(dtype.char)
+        except ValueError:
+            indx = np.inf
+        return (indx, dtype.char)
+
+    dtypes = sorted(dtypes, key=sorter)
+
+    def print_table(field="can_cast"):
+        print('X', end=' ')
+        for dt in dtypes:
+            print(np.dtype(dt.type).char, end=' ')
+        print()
+        for from_dt in dtypes:
+            print(np.dtype(from_dt.type).char, end=' ')
+            row = table.get(from_dt, {})
+            for to_dt in dtypes:
+                print(getattr(row.get(to_dt, no_cast_info), field), end=' ')
+            print()
+
+    if can_cast:
+        # Print the actual table:
+        print()
+        print("Casting: # is equivalent, = is safe, ~ is same-kind, and . is unsafe")
+        print()
+        print_table("can_cast")
+
+    if legacy:
+        print()
+        print("L denotes a legacy cast . a non-legacy one.")
+        print()
+        print_table("legacy")
+
+    if flags:
+        print()
+        print(f"{flags_table[0]}: no flags, {flags_table[1]}: PyAPI, "
+              f"{flags_table[2]}: supports unaligned, {flags_table[4]}: no-float-errors")
+        print()
+        print_table("flags")
+
+
+if __name__ == '__main__':
+    print("can cast")
+    print_cancast_table(np.typecodes['All'])
+    print()
+    print("In these tables, ValueError is '!', OverflowError is '@', TypeError is '#'")
+    print()
+    print("scalar + scalar")
+    print_coercion_table(np.typecodes['All'], 0, 0, False)
+    print()
+    print("scalar + neg scalar")
+    print_coercion_table(np.typecodes['All'], 0, -1, False)
+    print()
+    print("array + scalar")
+    print_coercion_table(np.typecodes['All'], 0, 0, True)
+    print()
+    print("array + neg scalar")
+    print_coercion_table(np.typecodes['All'], 0, -1, True)
+    print()
+    print("promote_types")
+    print_coercion_table(np.typecodes['All'], 0, 0, False, True)
+    print("New casting type promotion:")
+    print_new_cast_table(can_cast=True, legacy=True, flags=True)
diff --git a/venv/lib/python3.12/site-packages/numpy/testing/tests/__init__.py b/venv/lib/python3.12/site-packages/numpy/testing/tests/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/venv/lib/python3.12/site-packages/numpy/testing/tests/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/testing/tests/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 00000000..a2ac19e0
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/testing/tests/__pycache__/__init__.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/testing/tests/__pycache__/test_utils.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/testing/tests/__pycache__/test_utils.cpython-312.pyc
new file mode 100644
index 00000000..39a8e357
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/testing/tests/__pycache__/test_utils.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/testing/tests/test_utils.py b/venv/lib/python3.12/site-packages/numpy/testing/tests/test_utils.py
new file mode 100644
index 00000000..3983ec90
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/testing/tests/test_utils.py
@@ -0,0 +1,1929 @@
+import warnings
+import sys
+import os
+import itertools
+import pytest
+import weakref
+import re
+
+import numpy as np
+import numpy._core._multiarray_umath as ncu
+from numpy.testing import (
+    assert_equal, assert_array_equal, assert_almost_equal,
+    assert_array_almost_equal, assert_array_less, build_err_msg,
+    assert_raises, assert_warns, assert_no_warnings, assert_allclose,
+    assert_approx_equal, assert_array_almost_equal_nulp, assert_array_max_ulp,
+    clear_and_catch_warnings, suppress_warnings, assert_string_equal, assert_,
+    tempdir, temppath, assert_no_gc_cycles, HAS_REFCOUNT
+)
+
+
+class _GenericTest:
+
+    def _test_equal(self, a, b):
+        self._assert_func(a, b)
+
+    def _test_not_equal(self, a, b):
+        with assert_raises(AssertionError):
+            self._assert_func(a, b)
+
+    def test_array_rank1_eq(self):
+        """Test two equal array of rank 1 are found equal."""
+        a = np.array([1, 2])
+        b = np.array([1, 2])
+
+        self._test_equal(a, b)
+
+    def test_array_rank1_noteq(self):
+        """Test two different array of rank 1 are found not equal."""
+        a = np.array([1, 2])
+        b = np.array([2, 2])
+
+        self._test_not_equal(a, b)
+
+    def test_array_rank2_eq(self):
+        """Test two equal array of rank 2 are found equal."""
+        a = np.array([[1, 2], [3, 4]])
+        b = np.array([[1, 2], [3, 4]])
+
+        self._test_equal(a, b)
+
+    def test_array_diffshape(self):
+        """Test two arrays with different shapes are found not equal."""
+        a = np.array([1, 2])
+        b = np.array([[1, 2], [1, 2]])
+
+        self._test_not_equal(a, b)
+
+    def test_objarray(self):
+        """Test object arrays."""
+        a = np.array([1, 1], dtype=object)
+        self._test_equal(a, 1)
+
+    def test_array_likes(self):
+        self._test_equal([1, 2, 3], (1, 2, 3))
+
+
+class TestArrayEqual(_GenericTest):
+
+    def setup_method(self):
+        self._assert_func = assert_array_equal
+
+    def test_generic_rank1(self):
+        """Test rank 1 array for all dtypes."""
+        def foo(t):
+            a = np.empty(2, t)
+            a.fill(1)
+            b = a.copy()
+            c = a.copy()
+            c.fill(0)
+            self._test_equal(a, b)
+            self._test_not_equal(c, b)
+
+        # Test numeric types and object
+        for t in '?bhilqpBHILQPfdgFDG':
+            foo(t)
+
+        # Test strings
+        for t in ['S1', 'U1']:
+            foo(t)
+
+    def test_0_ndim_array(self):
+        x = np.array(473963742225900817127911193656584771)
+        y = np.array(18535119325151578301457182298393896)
+
+        with pytest.raises(AssertionError) as exc_info:
+            self._assert_func(x, y)
+        msg = str(exc_info.value)
+        assert_('Mismatched elements: 1 / 1 (100%)\n'
+                in msg)
+
+        y = x
+        self._assert_func(x, y)
+
+        x = np.array(4395065348745.5643764887869876)
+        y = np.array(0)
+        expected_msg = ('Mismatched elements: 1 / 1 (100%)\n'
+                        'Max absolute difference among violations: '
+                        '4.39506535e+12\n'
+                        'Max relative difference among violations: inf\n')
+        with pytest.raises(AssertionError, match=re.escape(expected_msg)):
+            self._assert_func(x, y)
+
+        x = y
+        self._assert_func(x, y)
+
+    def test_generic_rank3(self):
+        """Test rank 3 array for all dtypes."""
+        def foo(t):
+            a = np.empty((4, 2, 3), t)
+            a.fill(1)
+            b = a.copy()
+            c = a.copy()
+            c.fill(0)
+            self._test_equal(a, b)
+            self._test_not_equal(c, b)
+
+        # Test numeric types and object
+        for t in '?bhilqpBHILQPfdgFDG':
+            foo(t)
+
+        # Test strings
+        for t in ['S1', 'U1']:
+            foo(t)
+
+    def test_nan_array(self):
+        """Test arrays with nan values in them."""
+        a = np.array([1, 2, np.nan])
+        b = np.array([1, 2, np.nan])
+
+        self._test_equal(a, b)
+
+        c = np.array([1, 2, 3])
+        self._test_not_equal(c, b)
+
+    def test_string_arrays(self):
+        """Test two arrays with different shapes are found not equal."""
+        a = np.array(['floupi', 'floupa'])
+        b = np.array(['floupi', 'floupa'])
+
+        self._test_equal(a, b)
+
+        c = np.array(['floupipi', 'floupa'])
+
+        self._test_not_equal(c, b)
+
+    def test_recarrays(self):
+        """Test record arrays."""
+        a = np.empty(2, [('floupi', float), ('floupa', float)])
+        a['floupi'] = [1, 2]
+        a['floupa'] = [1, 2]
+        b = a.copy()
+
+        self._test_equal(a, b)
+
+        c = np.empty(2, [('floupipi', float),
+                         ('floupi', float), ('floupa', float)])
+        c['floupipi'] = a['floupi'].copy()
+        c['floupa'] = a['floupa'].copy()
+
+        with pytest.raises(TypeError):
+            self._test_not_equal(c, b)
+
+    def test_masked_nan_inf(self):
+        # Regression test for gh-11121
+        a = np.ma.MaskedArray([3., 4., 6.5], mask=[False, True, False])
+        b = np.array([3., np.nan, 6.5])
+        self._test_equal(a, b)
+        self._test_equal(b, a)
+        a = np.ma.MaskedArray([3., 4., 6.5], mask=[True, False, False])
+        b = np.array([np.inf, 4., 6.5])
+        self._test_equal(a, b)
+        self._test_equal(b, a)
+
+    def test_subclass_that_overrides_eq(self):
+        # While we cannot guarantee testing functions will always work for
+        # subclasses, the tests should ideally rely only on subclasses having
+        # comparison operators, not on them being able to store booleans
+        # (which, e.g., astropy Quantity cannot usefully do). See gh-8452.
+        class MyArray(np.ndarray):
+            def __eq__(self, other):
+                return bool(np.equal(self, other).all())
+
+            def __ne__(self, other):
+                return not self == other
+
+        a = np.array([1., 2.]).view(MyArray)
+        b = np.array([2., 3.]).view(MyArray)
+        assert_(type(a == a), bool)
+        assert_(a == a)
+        assert_(a != b)
+        self._test_equal(a, a)
+        self._test_not_equal(a, b)
+        self._test_not_equal(b, a)
+
+        expected_msg = ('Mismatched elements: 1 / 2 (50%)\n'
+                        'Max absolute difference among violations: 1.\n'
+                        'Max relative difference among violations: 0.5')
+        with pytest.raises(AssertionError, match=re.escape(expected_msg)):
+            self._test_equal(a, b)
+
+        c = np.array([0., 2.9]).view(MyArray)
+        expected_msg = ('Mismatched elements: 1 / 2 (50%)\n'
+                        'Max absolute difference among violations: 2.\n'
+                        'Max relative difference among violations: inf')
+        with pytest.raises(AssertionError, match=re.escape(expected_msg)):
+            self._test_equal(b, c)
+
+    def test_subclass_that_does_not_implement_npall(self):
+        class MyArray(np.ndarray):
+            def __array_function__(self, *args, **kwargs):
+                return NotImplemented
+
+        a = np.array([1., 2.]).view(MyArray)
+        b = np.array([2., 3.]).view(MyArray)
+        with assert_raises(TypeError):
+            np.all(a)
+        self._test_equal(a, a)
+        self._test_not_equal(a, b)
+        self._test_not_equal(b, a)
+
+    def test_suppress_overflow_warnings(self):
+        # Based on issue #18992
+        with pytest.raises(AssertionError):
+            with np.errstate(all="raise"):
+                np.testing.assert_array_equal(
+                    np.array([1, 2, 3], np.float32),
+                    np.array([1, 1e-40, 3], np.float32))
+
+    def test_array_vs_scalar_is_equal(self):
+        """Test comparing an array with a scalar when all values are equal."""
+        a = np.array([1., 1., 1.])
+        b = 1.
+
+        self._test_equal(a, b)
+
+    def test_array_vs_array_not_equal(self):
+        """Test comparing an array with a scalar when not all values equal."""
+        a = np.array([34986, 545676, 439655, 563766])
+        b = np.array([34986, 545676, 439655, 0])
+
+        expected_msg = ('Mismatched elements: 1 / 4 (25%)\n'
+                        'Max absolute difference among violations: 563766\n'
+                        'Max relative difference among violations: inf')
+        with pytest.raises(AssertionError, match=re.escape(expected_msg)):
+            self._assert_func(a, b)
+
+        a = np.array([34986, 545676, 439655.2, 563766])
+        expected_msg = ('Mismatched elements: 2 / 4 (50%)\n'
+                        'Max absolute difference among violations: '
+                        '563766.\n'
+                        'Max relative difference among violations: '
+                        '4.54902139e-07')
+        with pytest.raises(AssertionError, match=re.escape(expected_msg)):
+            self._assert_func(a, b)
+
+    def test_array_vs_scalar_strict(self):
+        """Test comparing an array with a scalar with strict option."""
+        a = np.array([1., 1., 1.])
+        b = 1.
+
+        with pytest.raises(AssertionError):
+            self._assert_func(a, b, strict=True)
+
+    def test_array_vs_array_strict(self):
+        """Test comparing two arrays with strict option."""
+        a = np.array([1., 1., 1.])
+        b = np.array([1., 1., 1.])
+
+        self._assert_func(a, b, strict=True)
+
+    def test_array_vs_float_array_strict(self):
+        """Test comparing two arrays with strict option."""
+        a = np.array([1, 1, 1])
+        b = np.array([1., 1., 1.])
+
+        with pytest.raises(AssertionError):
+            self._assert_func(a, b, strict=True)
+
+
+class TestBuildErrorMessage:
+
+    def test_build_err_msg_defaults(self):
+        x = np.array([1.00001, 2.00002, 3.00003])
+        y = np.array([1.00002, 2.00003, 3.00004])
+        err_msg = 'There is a mismatch'
+
+        a = build_err_msg([x, y], err_msg)
+        b = ('\nItems are not equal: There is a mismatch\n ACTUAL: array(['
+             '1.00001, 2.00002, 3.00003])\n DESIRED: array([1.00002, '
+             '2.00003, 3.00004])')
+        assert_equal(a, b)
+
+    def test_build_err_msg_no_verbose(self):
+        x = np.array([1.00001, 2.00002, 3.00003])
+        y = np.array([1.00002, 2.00003, 3.00004])
+        err_msg = 'There is a mismatch'
+
+        a = build_err_msg([x, y], err_msg, verbose=False)
+        b = '\nItems are not equal: There is a mismatch'
+        assert_equal(a, b)
+
+    def test_build_err_msg_custom_names(self):
+        x = np.array([1.00001, 2.00002, 3.00003])
+        y = np.array([1.00002, 2.00003, 3.00004])
+        err_msg = 'There is a mismatch'
+
+        a = build_err_msg([x, y], err_msg, names=('FOO', 'BAR'))
+        b = ('\nItems are not equal: There is a mismatch\n FOO: array(['
+             '1.00001, 2.00002, 3.00003])\n BAR: array([1.00002, 2.00003, '
+             '3.00004])')
+        assert_equal(a, b)
+
+    def test_build_err_msg_custom_precision(self):
+        x = np.array([1.000000001, 2.00002, 3.00003])
+        y = np.array([1.000000002, 2.00003, 3.00004])
+        err_msg = 'There is a mismatch'
+
+        a = build_err_msg([x, y], err_msg, precision=10)
+        b = ('\nItems are not equal: There is a mismatch\n ACTUAL: array(['
+             '1.000000001, 2.00002    , 3.00003    ])\n DESIRED: array(['
+             '1.000000002, 2.00003    , 3.00004    ])')
+        assert_equal(a, b)
+
+
+class TestEqual(TestArrayEqual):
+
+    def setup_method(self):
+        self._assert_func = assert_equal
+
+    def test_nan_items(self):
+        self._assert_func(np.nan, np.nan)
+        self._assert_func([np.nan], [np.nan])
+        self._test_not_equal(np.nan, [np.nan])
+        self._test_not_equal(np.nan, 1)
+
+    def test_inf_items(self):
+        self._assert_func(np.inf, np.inf)
+        self._assert_func([np.inf], [np.inf])
+        self._test_not_equal(np.inf, [np.inf])
+
+    def test_datetime(self):
+        self._test_equal(
+            np.datetime64("2017-01-01", "s"),
+            np.datetime64("2017-01-01", "s")
+        )
+        self._test_equal(
+            np.datetime64("2017-01-01", "s"),
+            np.datetime64("2017-01-01", "m")
+        )
+
+        # gh-10081
+        self._test_not_equal(
+            np.datetime64("2017-01-01", "s"),
+            np.datetime64("2017-01-02", "s")
+        )
+        self._test_not_equal(
+            np.datetime64("2017-01-01", "s"),
+            np.datetime64("2017-01-02", "m")
+        )
+
+    def test_nat_items(self):
+        # not a datetime
+        nadt_no_unit = np.datetime64("NaT")
+        nadt_s = np.datetime64("NaT", "s")
+        nadt_d = np.datetime64("NaT", "ns")
+        # not a timedelta
+        natd_no_unit = np.timedelta64("NaT")
+        natd_s = np.timedelta64("NaT", "s")
+        natd_d = np.timedelta64("NaT", "ns")
+
+        dts = [nadt_no_unit, nadt_s, nadt_d]
+        tds = [natd_no_unit, natd_s, natd_d]
+        for a, b in itertools.product(dts, dts):
+            self._assert_func(a, b)
+            self._assert_func([a], [b])
+            self._test_not_equal([a], b)
+
+        for a, b in itertools.product(tds, tds):
+            self._assert_func(a, b)
+            self._assert_func([a], [b])
+            self._test_not_equal([a], b)
+
+        for a, b in itertools.product(tds, dts):
+            self._test_not_equal(a, b)
+            self._test_not_equal(a, [b])
+            self._test_not_equal([a], [b])
+            self._test_not_equal([a], np.datetime64("2017-01-01", "s"))
+            self._test_not_equal([b], np.datetime64("2017-01-01", "s"))
+            self._test_not_equal([a], np.timedelta64(123, "s"))
+            self._test_not_equal([b], np.timedelta64(123, "s"))
+
+    def test_non_numeric(self):
+        self._assert_func('ab', 'ab')
+        self._test_not_equal('ab', 'abb')
+
+    def test_complex_item(self):
+        self._assert_func(complex(1, 2), complex(1, 2))
+        self._assert_func(complex(1, np.nan), complex(1, np.nan))
+        self._test_not_equal(complex(1, np.nan), complex(1, 2))
+        self._test_not_equal(complex(np.nan, 1), complex(1, np.nan))
+        self._test_not_equal(complex(np.nan, np.inf), complex(np.nan, 2))
+
+    def test_negative_zero(self):
+        self._test_not_equal(ncu.PZERO, ncu.NZERO)
+
+    def test_complex(self):
+        x = np.array([complex(1, 2), complex(1, np.nan)])
+        y = np.array([complex(1, 2), complex(1, 2)])
+        self._assert_func(x, x)
+        self._test_not_equal(x, y)
+
+    def test_object(self):
+        # gh-12942
+        import datetime
+        a = np.array([datetime.datetime(2000, 1, 1),
+                      datetime.datetime(2000, 1, 2)])
+        self._test_not_equal(a, a[::-1])
+
+
+class TestArrayAlmostEqual(_GenericTest):
+
+    def setup_method(self):
+        self._assert_func = assert_array_almost_equal
+
+    def test_closeness(self):
+        # Note that in the course of time we ended up with
+        #     `abs(x - y) < 1.5 * 10**(-decimal)`
+        # instead of the previously documented
+        #     `abs(x - y) < 0.5 * 10**(-decimal)`
+        # so this check serves to preserve the wrongness.
+
+        # test scalars
+        expected_msg = ('Mismatched elements: 1 / 1 (100%)\n'
+                        'Max absolute difference among violations: 1.5\n'
+                        'Max relative difference among violations: inf')
+        with pytest.raises(AssertionError, match=re.escape(expected_msg)):
+            self._assert_func(1.5, 0.0, decimal=0)
+
+        # test arrays
+        self._assert_func([1.499999], [0.0], decimal=0)
+
+        expected_msg = ('Mismatched elements: 1 / 1 (100%)\n'
+                        'Max absolute difference among violations: 1.5\n'
+                        'Max relative difference among violations: inf')
+        with pytest.raises(AssertionError, match=re.escape(expected_msg)):
+            self._assert_func([1.5], [0.0], decimal=0)
+
+        a = [1.4999999, 0.00003]
+        b = [1.49999991, 0]
+        expected_msg = ('Mismatched elements: 1 / 2 (50%)\n'
+                        'Max absolute difference among violations: 3.e-05\n'
+                        'Max relative difference among violations: inf')
+        with pytest.raises(AssertionError, match=re.escape(expected_msg)):
+            self._assert_func(a, b, decimal=7)
+
+        expected_msg = ('Mismatched elements: 1 / 2 (50%)\n'
+                        'Max absolute difference among violations: 3.e-05\n'
+                        'Max relative difference among violations: 1.')
+        with pytest.raises(AssertionError, match=re.escape(expected_msg)):
+            self._assert_func(b, a, decimal=7)
+
+    def test_simple(self):
+        x = np.array([1234.2222])
+        y = np.array([1234.2223])
+
+        self._assert_func(x, y, decimal=3)
+        self._assert_func(x, y, decimal=4)
+
+        expected_msg = ('Mismatched elements: 1 / 1 (100%)\n'
+                        'Max absolute difference among violations: '
+                        '1.e-04\n'
+                        'Max relative difference among violations: '
+                        '8.10226812e-08')
+        with pytest.raises(AssertionError, match=re.escape(expected_msg)):
+            self._assert_func(x, y, decimal=5)
+
+    def test_array_vs_scalar(self):
+        a = [5498.42354, 849.54345, 0.00]
+        b = 5498.42354
+        expected_msg = ('Mismatched elements: 2 / 3 (66.7%)\n'
+                        'Max absolute difference among violations: '
+                        '5498.42354\n'
+                        'Max relative difference among violations: 1.')
+        with pytest.raises(AssertionError, match=re.escape(expected_msg)):
+            self._assert_func(a, b, decimal=9)
+
+        expected_msg = ('Mismatched elements: 2 / 3 (66.7%)\n'
+                        'Max absolute difference among violations: '
+                        '5498.42354\n'
+                        'Max relative difference among violations: 5.4722099')
+        with pytest.raises(AssertionError, match=re.escape(expected_msg)):
+            self._assert_func(b, a, decimal=9)
+
+        a = [5498.42354, 0.00]
+        expected_msg = ('Mismatched elements: 1 / 2 (50%)\n'
+                        'Max absolute difference among violations: '
+                        '5498.42354\n'
+                        'Max relative difference among violations: inf')
+        with pytest.raises(AssertionError, match=re.escape(expected_msg)):
+            self._assert_func(b, a, decimal=7)
+
+        b = 0
+        expected_msg = ('Mismatched elements: 1 / 2 (50%)\n'
+                        'Max absolute difference among violations: '
+                        '5498.42354\n'
+                        'Max relative difference among violations: inf')
+        with pytest.raises(AssertionError, match=re.escape(expected_msg)):
+            self._assert_func(a, b, decimal=7)
+
+    def test_nan(self):
+        anan = np.array([np.nan])
+        aone = np.array([1])
+        ainf = np.array([np.inf])
+        self._assert_func(anan, anan)
+        assert_raises(AssertionError,
+                      lambda: self._assert_func(anan, aone))
+        assert_raises(AssertionError,
+                      lambda: self._assert_func(anan, ainf))
+        assert_raises(AssertionError,
+                      lambda: self._assert_func(ainf, anan))
+
+    def test_inf(self):
+        a = np.array([[1., 2.], [3., 4.]])
+        b = a.copy()
+        a[0, 0] = np.inf
+        assert_raises(AssertionError,
+                      lambda: self._assert_func(a, b))
+        b[0, 0] = -np.inf
+        assert_raises(AssertionError,
+                      lambda: self._assert_func(a, b))
+
+    def test_subclass(self):
+        a = np.array([[1., 2.], [3., 4.]])
+        b = np.ma.masked_array([[1., 2.], [0., 4.]],
+                               [[False, False], [True, False]])
+        self._assert_func(a, b)
+        self._assert_func(b, a)
+        self._assert_func(b, b)
+
+        # Test fully masked as well (see gh-11123).
+        a = np.ma.MaskedArray(3.5, mask=True)
+        b = np.array([3., 4., 6.5])
+        self._test_equal(a, b)
+        self._test_equal(b, a)
+        a = np.ma.masked
+        b = np.array([3., 4., 6.5])
+        self._test_equal(a, b)
+        self._test_equal(b, a)
+        a = np.ma.MaskedArray([3., 4., 6.5], mask=[True, True, True])
+        b = np.array([1., 2., 3.])
+        self._test_equal(a, b)
+        self._test_equal(b, a)
+        a = np.ma.MaskedArray([3., 4., 6.5], mask=[True, True, True])
+        b = np.array(1.)
+        self._test_equal(a, b)
+        self._test_equal(b, a)
+
+    def test_subclass_2(self):
+        # While we cannot guarantee testing functions will always work for
+        # subclasses, the tests should ideally rely only on subclasses having
+        # comparison operators, not on them being able to store booleans
+        # (which, e.g., astropy Quantity cannot usefully do). See gh-8452.
+        class MyArray(np.ndarray):
+            def __eq__(self, other):
+                return super().__eq__(other).view(np.ndarray)
+
+            def __lt__(self, other):
+                return super().__lt__(other).view(np.ndarray)
+
+            def all(self, *args, **kwargs):
+                return all(self)
+
+        a = np.array([1., 2.]).view(MyArray)
+        self._assert_func(a, a)
+
+        z = np.array([True, True]).view(MyArray)
+        all(z)
+        b = np.array([1., 202]).view(MyArray)
+        expected_msg = ('Mismatched elements: 1 / 2 (50%)\n'
+                        'Max absolute difference among violations: 200.\n'
+                        'Max relative difference among violations: 0.99009')
+        with pytest.raises(AssertionError, match=re.escape(expected_msg)):
+            self._assert_func(a, b)
+
+    def test_subclass_that_cannot_be_bool(self):
+        # While we cannot guarantee testing functions will always work for
+        # subclasses, the tests should ideally rely only on subclasses having
+        # comparison operators, not on them being able to store booleans
+        # (which, e.g., astropy Quantity cannot usefully do). See gh-8452.
+        class MyArray(np.ndarray):
+            def __eq__(self, other):
+                return super().__eq__(other).view(np.ndarray)
+
+            def __lt__(self, other):
+                return super().__lt__(other).view(np.ndarray)
+
+            def all(self, *args, **kwargs):
+                raise NotImplementedError
+
+        a = np.array([1., 2.]).view(MyArray)
+        self._assert_func(a, a)
+
+
+class TestAlmostEqual(_GenericTest):
+
+    def setup_method(self):
+        self._assert_func = assert_almost_equal
+
+    def test_closeness(self):
+        # Note that in the course of time we ended up with
+        #     `abs(x - y) < 1.5 * 10**(-decimal)`
+        # instead of the previously documented
+        #     `abs(x - y) < 0.5 * 10**(-decimal)`
+        # so this check serves to preserve the wrongness.
+
+        # test scalars
+        self._assert_func(1.499999, 0.0, decimal=0)
+        assert_raises(AssertionError,
+                      lambda: self._assert_func(1.5, 0.0, decimal=0))
+
+        # test arrays
+        self._assert_func([1.499999], [0.0], decimal=0)
+        assert_raises(AssertionError,
+                      lambda: self._assert_func([1.5], [0.0], decimal=0))
+
+    def test_nan_item(self):
+        self._assert_func(np.nan, np.nan)
+        assert_raises(AssertionError,
+                      lambda: self._assert_func(np.nan, 1))
+        assert_raises(AssertionError,
+                      lambda: self._assert_func(np.nan, np.inf))
+        assert_raises(AssertionError,
+                      lambda: self._assert_func(np.inf, np.nan))
+
+    def test_inf_item(self):
+        self._assert_func(np.inf, np.inf)
+        self._assert_func(-np.inf, -np.inf)
+        assert_raises(AssertionError,
+                      lambda: self._assert_func(np.inf, 1))
+        assert_raises(AssertionError,
+                      lambda: self._assert_func(-np.inf, np.inf))
+
+    def test_simple_item(self):
+        self._test_not_equal(1, 2)
+
+    def test_complex_item(self):
+        self._assert_func(complex(1, 2), complex(1, 2))
+        self._assert_func(complex(1, np.nan), complex(1, np.nan))
+        self._assert_func(complex(np.inf, np.nan), complex(np.inf, np.nan))
+        self._test_not_equal(complex(1, np.nan), complex(1, 2))
+        self._test_not_equal(complex(np.nan, 1), complex(1, np.nan))
+        self._test_not_equal(complex(np.nan, np.inf), complex(np.nan, 2))
+
+    def test_complex(self):
+        x = np.array([complex(1, 2), complex(1, np.nan)])
+        z = np.array([complex(1, 2), complex(np.nan, 1)])
+        y = np.array([complex(1, 2), complex(1, 2)])
+        self._assert_func(x, x)
+        self._test_not_equal(x, y)
+        self._test_not_equal(x, z)
+
+    def test_error_message(self):
+        """Check the message is formatted correctly for the decimal value.
+           Also check the message when input includes inf or nan (gh12200)"""
+        x = np.array([1.00000000001, 2.00000000002, 3.00003])
+        y = np.array([1.00000000002, 2.00000000003, 3.00004])
+
+        # Test with a different amount of decimal digits
+        expected_msg = ('Mismatched elements: 3 / 3 (100%)\n'
+                        'Max absolute difference among violations: 1.e-05\n'
+                        'Max relative difference among violations: '
+                        '3.33328889e-06\n'
+                        ' ACTUAL: array([1.00000000001, '
+                        '2.00000000002, '
+                        '3.00003      ])\n'
+                        ' DESIRED: array([1.00000000002, 2.00000000003, '
+                        '3.00004      ])')
+        with pytest.raises(AssertionError, match=re.escape(expected_msg)):
+            self._assert_func(x, y, decimal=12)
+
+        # With the default value of decimal digits, only the 3rd element
+        # differs. Note that we only check for the formatting of the arrays
+        # themselves.
+        expected_msg = ('Mismatched elements: 1 / 3 (33.3%)\n'
+                        'Max absolute difference among violations: 1.e-05\n'
+                        'Max relative difference among violations: '
+                        '3.33328889e-06\n'
+                        ' ACTUAL: array([1.     , 2.     , 3.00003])\n'
+                        ' DESIRED: array([1.     , 2.     , 3.00004])')
+        with pytest.raises(AssertionError, match=re.escape(expected_msg)):
+            self._assert_func(x, y)
+
+        # Check the error message when input includes inf
+        x = np.array([np.inf, 0])
+        y = np.array([np.inf, 1])
+        expected_msg = ('Mismatched elements: 1 / 2 (50%)\n'
+                        'Max absolute difference among violations: 1.\n'
+                        'Max relative difference among violations: 1.\n'
+                        ' ACTUAL: array([inf,  0.])\n'
+                        ' DESIRED: array([inf,  1.])')
+        with pytest.raises(AssertionError, match=re.escape(expected_msg)):
+            self._assert_func(x, y)
+
+        # Check the error message when dividing by zero
+        x = np.array([1, 2])
+        y = np.array([0, 0])
+        expected_msg = ('Mismatched elements: 2 / 2 (100%)\n'
+                        'Max absolute difference among violations: 2\n'
+                        'Max relative difference among violations: inf')
+        with pytest.raises(AssertionError, match=re.escape(expected_msg)):
+            self._assert_func(x, y)
+
+    def test_error_message_2(self):
+        """Check the message is formatted correctly """
+        """when either x or y is a scalar."""
+        x = 2
+        y = np.ones(20)
+        expected_msg = ('Mismatched elements: 20 / 20 (100%)\n'
+                        'Max absolute difference among violations: 1.\n'
+                        'Max relative difference among violations: 1.')
+        with pytest.raises(AssertionError, match=re.escape(expected_msg)):
+            self._assert_func(x, y)
+
+        y = 2
+        x = np.ones(20)
+        expected_msg = ('Mismatched elements: 20 / 20 (100%)\n'
+                        'Max absolute difference among violations: 1.\n'
+                        'Max relative difference among violations: 0.5')
+        with pytest.raises(AssertionError, match=re.escape(expected_msg)):
+            self._assert_func(x, y)
+
+    def test_subclass_that_cannot_be_bool(self):
+        # While we cannot guarantee testing functions will always work for
+        # subclasses, the tests should ideally rely only on subclasses having
+        # comparison operators, not on them being able to store booleans
+        # (which, e.g., astropy Quantity cannot usefully do). See gh-8452.
+        class MyArray(np.ndarray):
+            def __eq__(self, other):
+                return super().__eq__(other).view(np.ndarray)
+
+            def __lt__(self, other):
+                return super().__lt__(other).view(np.ndarray)
+
+            def all(self, *args, **kwargs):
+                raise NotImplementedError
+
+        a = np.array([1., 2.]).view(MyArray)
+        self._assert_func(a, a)
+
+
+class TestApproxEqual:
+
+    def setup_method(self):
+        self._assert_func = assert_approx_equal
+
+    def test_simple_0d_arrays(self):
+        x = np.array(1234.22)
+        y = np.array(1234.23)
+
+        self._assert_func(x, y, significant=5)
+        self._assert_func(x, y, significant=6)
+        assert_raises(AssertionError,
+                      lambda: self._assert_func(x, y, significant=7))
+
+    def test_simple_items(self):
+        x = 1234.22
+        y = 1234.23
+
+        self._assert_func(x, y, significant=4)
+        self._assert_func(x, y, significant=5)
+        self._assert_func(x, y, significant=6)
+        assert_raises(AssertionError,
+                      lambda: self._assert_func(x, y, significant=7))
+
+    def test_nan_array(self):
+        anan = np.array(np.nan)
+        aone = np.array(1)
+        ainf = np.array(np.inf)
+        self._assert_func(anan, anan)
+        assert_raises(AssertionError, lambda: self._assert_func(anan, aone))
+        assert_raises(AssertionError, lambda: self._assert_func(anan, ainf))
+        assert_raises(AssertionError, lambda: self._assert_func(ainf, anan))
+
+    def test_nan_items(self):
+        anan = np.array(np.nan)
+        aone = np.array(1)
+        ainf = np.array(np.inf)
+        self._assert_func(anan, anan)
+        assert_raises(AssertionError, lambda: self._assert_func(anan, aone))
+        assert_raises(AssertionError, lambda: self._assert_func(anan, ainf))
+        assert_raises(AssertionError, lambda: self._assert_func(ainf, anan))
+
+
+class TestArrayAssertLess:
+
+    def setup_method(self):
+        self._assert_func = assert_array_less
+
+    def test_simple_arrays(self):
+        x = np.array([1.1, 2.2])
+        y = np.array([1.2, 2.3])
+
+        self._assert_func(x, y)
+        assert_raises(AssertionError, lambda: self._assert_func(y, x))
+
+        y = np.array([1.0, 2.3])
+
+        assert_raises(AssertionError, lambda: self._assert_func(x, y))
+        assert_raises(AssertionError, lambda: self._assert_func(y, x))
+
+        a = np.array([1, 3, 6, 20])
+        b = np.array([2, 4, 6, 8])
+
+        expected_msg = ('Mismatched elements: 2 / 4 (50%)\n'
+                        'Max absolute difference among violations: 12\n'
+                        'Max relative difference among violations: 1.5')
+        with pytest.raises(AssertionError, match=re.escape(expected_msg)):
+            self._assert_func(a, b)
+
+    def test_rank2(self):
+        x = np.array([[1.1, 2.2], [3.3, 4.4]])
+        y = np.array([[1.2, 2.3], [3.4, 4.5]])
+
+        self._assert_func(x, y)
+        expected_msg = ('Mismatched elements: 4 / 4 (100%)\n'
+                        'Max absolute difference among violations: 0.1\n'
+                        'Max relative difference among violations: 0.09090909')
+        with pytest.raises(AssertionError, match=re.escape(expected_msg)):
+            self._assert_func(y, x)
+
+        y = np.array([[1.0, 2.3], [3.4, 4.5]])
+        assert_raises(AssertionError, lambda: self._assert_func(x, y))
+        assert_raises(AssertionError, lambda: self._assert_func(y, x))
+
+    def test_rank3(self):
+        x = np.ones(shape=(2, 2, 2))
+        y = np.ones(shape=(2, 2, 2))+1
+
+        self._assert_func(x, y)
+        assert_raises(AssertionError, lambda: self._assert_func(y, x))
+
+        y[0, 0, 0] = 0
+        expected_msg = ('Mismatched elements: 1 / 8 (12.5%)\n'
+                        'Max absolute difference among violations: 1.\n'
+                        'Max relative difference among violations: inf')
+        with pytest.raises(AssertionError, match=re.escape(expected_msg)):
+            self._assert_func(x, y)
+
+        assert_raises(AssertionError, lambda: self._assert_func(y, x))
+
+    def test_simple_items(self):
+        x = 1.1
+        y = 2.2
+
+        self._assert_func(x, y)
+        expected_msg = ('Mismatched elements: 1 / 1 (100%)\n'
+                        'Max absolute difference among violations: 1.1\n'
+                        'Max relative difference among violations: 1.')
+        with pytest.raises(AssertionError, match=re.escape(expected_msg)):
+            self._assert_func(y, x)
+
+        y = np.array([2.2, 3.3])
+
+        self._assert_func(x, y)
+        assert_raises(AssertionError, lambda: self._assert_func(y, x))
+
+        y = np.array([1.0, 3.3])
+
+        assert_raises(AssertionError, lambda: self._assert_func(x, y))
+
+    def test_simple_items_and_array(self):
+        x = np.array([[621.345454, 390.5436, 43.54657, 626.4535],
+                      [54.54, 627.3399, 13., 405.5435],
+                      [543.545, 8.34, 91.543, 333.3]])
+        y = 627.34
+        self._assert_func(x, y)
+
+        y = 8.339999
+        self._assert_func(y, x)
+
+        x = np.array([[3.4536, 2390.5436, 435.54657, 324525.4535],
+                      [5449.54, 999090.54, 130303.54, 405.5435],
+                      [543.545, 8.34, 91.543, 999090.53999]])
+        y = 999090.54
+
+        expected_msg = ('Mismatched elements: 1 / 12 (8.33%)\n'
+                        'Max absolute difference among violations: 0.\n'
+                        'Max relative difference among violations: 0.')
+        with pytest.raises(AssertionError, match=re.escape(expected_msg)):
+            self._assert_func(x, y)
+
+        expected_msg = ('Mismatched elements: 12 / 12 (100%)\n'
+                        'Max absolute difference among violations: '
+                        '999087.0864\n'
+                        'Max relative difference among violations: '
+                        '289288.5934676')
+        with pytest.raises(AssertionError, match=re.escape(expected_msg)):
+            self._assert_func(y, x)
+
+    def test_zeroes(self):
+        x = np.array([546456., 0, 15.455])
+        y = np.array(87654.)
+
+        expected_msg = ('Mismatched elements: 1 / 3 (33.3%)\n'
+                        'Max absolute difference among violations: 458802.\n'
+                        'Max relative difference among violations: 5.23423917')
+        with pytest.raises(AssertionError, match=re.escape(expected_msg)):
+            self._assert_func(x, y)
+
+        expected_msg = ('Mismatched elements: 2 / 3 (66.7%)\n'
+                        'Max absolute difference among violations: 87654.\n'
+                        'Max relative difference among violations: '
+                        '5670.5626011')
+        with pytest.raises(AssertionError, match=re.escape(expected_msg)):
+            self._assert_func(y, x)
+
+        y = 0
+
+        expected_msg = ('Mismatched elements: 3 / 3 (100%)\n'
+                        'Max absolute difference among violations: 546456.\n'
+                        'Max relative difference among violations: inf')
+        with pytest.raises(AssertionError, match=re.escape(expected_msg)):
+            self._assert_func(x, y)
+
+        expected_msg = ('Mismatched elements: 1 / 3 (33.3%)\n'
+                        'Max absolute difference among violations: 0.\n'
+                        'Max relative difference among violations: inf')
+        with pytest.raises(AssertionError, match=re.escape(expected_msg)):
+            self._assert_func(y, x)
+
+    def test_nan_noncompare(self):
+        anan = np.array(np.nan)
+        aone = np.array(1)
+        ainf = np.array(np.inf)
+        self._assert_func(anan, anan)
+        assert_raises(AssertionError, lambda: self._assert_func(aone, anan))
+        assert_raises(AssertionError, lambda: self._assert_func(anan, aone))
+        assert_raises(AssertionError, lambda: self._assert_func(anan, ainf))
+        assert_raises(AssertionError, lambda: self._assert_func(ainf, anan))
+
+    def test_nan_noncompare_array(self):
+        x = np.array([1.1, 2.2, 3.3])
+        anan = np.array(np.nan)
+
+        assert_raises(AssertionError, lambda: self._assert_func(x, anan))
+        assert_raises(AssertionError, lambda: self._assert_func(anan, x))
+
+        x = np.array([1.1, 2.2, np.nan])
+
+        assert_raises(AssertionError, lambda: self._assert_func(x, anan))
+        assert_raises(AssertionError, lambda: self._assert_func(anan, x))
+
+        y = np.array([1.0, 2.0, np.nan])
+
+        self._assert_func(y, x)
+        assert_raises(AssertionError, lambda: self._assert_func(x, y))
+
+    def test_inf_compare(self):
+        aone = np.array(1)
+        ainf = np.array(np.inf)
+
+        self._assert_func(aone, ainf)
+        self._assert_func(-ainf, aone)
+        self._assert_func(-ainf, ainf)
+        assert_raises(AssertionError, lambda: self._assert_func(ainf, aone))
+        assert_raises(AssertionError, lambda: self._assert_func(aone, -ainf))
+        assert_raises(AssertionError, lambda: self._assert_func(ainf, ainf))
+        assert_raises(AssertionError, lambda: self._assert_func(ainf, -ainf))
+        assert_raises(AssertionError, lambda: self._assert_func(-ainf, -ainf))
+
+    def test_inf_compare_array(self):
+        x = np.array([1.1, 2.2, np.inf])
+        ainf = np.array(np.inf)
+
+        assert_raises(AssertionError, lambda: self._assert_func(x, ainf))
+        assert_raises(AssertionError, lambda: self._assert_func(ainf, x))
+        assert_raises(AssertionError, lambda: self._assert_func(x, -ainf))
+        assert_raises(AssertionError, lambda: self._assert_func(-x, -ainf))
+        assert_raises(AssertionError, lambda: self._assert_func(-ainf, -x))
+        self._assert_func(-ainf, x)
+
+    def test_strict(self):
+        """Test the behavior of the `strict` option."""
+        x = np.zeros(3)
+        y = np.ones(())
+        self._assert_func(x, y)
+        with pytest.raises(AssertionError):
+            self._assert_func(x, y, strict=True)
+        y = np.broadcast_to(y, x.shape)
+        self._assert_func(x, y)
+        with pytest.raises(AssertionError):
+            self._assert_func(x, y.astype(np.float32), strict=True)
+
+
+class TestWarns:
+
+    def test_warn(self):
+        def f():
+            warnings.warn("yo")
+            return 3
+
+        before_filters = sys.modules['warnings'].filters[:]
+        assert_equal(assert_warns(UserWarning, f), 3)
+        after_filters = sys.modules['warnings'].filters
+
+        assert_raises(AssertionError, assert_no_warnings, f)
+        assert_equal(assert_no_warnings(lambda x: x, 1), 1)
+
+        # Check that the warnings state is unchanged
+        assert_equal(before_filters, after_filters,
+                     "assert_warns does not preserver warnings state")
+
+    def test_context_manager(self):
+
+        before_filters = sys.modules['warnings'].filters[:]
+        with assert_warns(UserWarning):
+            warnings.warn("yo")
+        after_filters = sys.modules['warnings'].filters
+
+        def no_warnings():
+            with assert_no_warnings():
+                warnings.warn("yo")
+
+        assert_raises(AssertionError, no_warnings)
+        assert_equal(before_filters, after_filters,
+                     "assert_warns does not preserver warnings state")
+
+    def test_args(self):
+        def f(a=0, b=1):
+            warnings.warn("yo")
+            return a + b
+
+        assert assert_warns(UserWarning, f, b=20) == 20
+
+        with pytest.raises(RuntimeError) as exc:
+            # assert_warns cannot do regexp matching, use pytest.warns
+            with assert_warns(UserWarning, match="A"):
+                warnings.warn("B", UserWarning)
+        assert "assert_warns" in str(exc)
+        assert "pytest.warns" in str(exc)
+
+        with pytest.raises(RuntimeError) as exc:
+            # assert_warns cannot do regexp matching, use pytest.warns
+            with assert_warns(UserWarning, wrong="A"):
+                warnings.warn("B", UserWarning)
+        assert "assert_warns" in str(exc)
+        assert "pytest.warns" not in str(exc)
+
+    def test_warn_wrong_warning(self):
+        def f():
+            warnings.warn("yo", DeprecationWarning)
+
+        failed = False
+        with warnings.catch_warnings():
+            warnings.simplefilter("error", DeprecationWarning)
+            try:
+                # Should raise a DeprecationWarning
+                assert_warns(UserWarning, f)
+                failed = True
+            except DeprecationWarning:
+                pass
+
+        if failed:
+            raise AssertionError("wrong warning caught by assert_warn")
+
+
+class TestAssertAllclose:
+
+    def test_simple(self):
+        x = 1e-3
+        y = 1e-9
+
+        assert_allclose(x, y, atol=1)
+        assert_raises(AssertionError, assert_allclose, x, y)
+
+        expected_msg = ('Mismatched elements: 1 / 1 (100%)\n'
+                        'Max absolute difference among violations: 0.001\n'
+                        'Max relative difference among violations: 999999.')
+        with pytest.raises(AssertionError, match=re.escape(expected_msg)):
+            assert_allclose(x, y)
+
+        z = 0
+        expected_msg = ('Mismatched elements: 1 / 1 (100%)\n'
+                        'Max absolute difference among violations: 1.e-09\n'
+                        'Max relative difference among violations: inf')
+        with pytest.raises(AssertionError, match=re.escape(expected_msg)):
+            assert_allclose(y, z)
+
+        expected_msg = ('Mismatched elements: 1 / 1 (100%)\n'
+                        'Max absolute difference among violations: 1.e-09\n'
+                        'Max relative difference among violations: 1.')
+        with pytest.raises(AssertionError, match=re.escape(expected_msg)):
+            assert_allclose(z, y)
+
+        a = np.array([x, y, x, y])
+        b = np.array([x, y, x, x])
+
+        assert_allclose(a, b, atol=1)
+        assert_raises(AssertionError, assert_allclose, a, b)
+
+        b[-1] = y * (1 + 1e-8)
+        assert_allclose(a, b)
+        assert_raises(AssertionError, assert_allclose, a, b, rtol=1e-9)
+
+        assert_allclose(6, 10, rtol=0.5)
+        assert_raises(AssertionError, assert_allclose, 10, 6, rtol=0.5)
+
+        b = np.array([x, y, x, x])
+        c = np.array([x, y, x, z])
+        expected_msg = ('Mismatched elements: 1 / 4 (25%)\n'
+                        'Max absolute difference among violations: 0.001\n'
+                        'Max relative difference among violations: inf')
+        with pytest.raises(AssertionError, match=re.escape(expected_msg)):
+            assert_allclose(b, c)
+
+        expected_msg = ('Mismatched elements: 1 / 4 (25%)\n'
+                        'Max absolute difference among violations: 0.001\n'
+                        'Max relative difference among violations: 1.')
+        with pytest.raises(AssertionError, match=re.escape(expected_msg)):
+            assert_allclose(c, b)
+
+    def test_min_int(self):
+        a = np.array([np.iinfo(np.int_).min], dtype=np.int_)
+        # Should not raise:
+        assert_allclose(a, a)
+
+    def test_report_fail_percentage(self):
+        a = np.array([1, 1, 1, 1])
+        b = np.array([1, 1, 1, 2])
+
+        expected_msg = ('Mismatched elements: 1 / 4 (25%)\n'
+                        'Max absolute difference among violations: 1\n'
+                        'Max relative difference among violations: 0.5')
+        with pytest.raises(AssertionError, match=re.escape(expected_msg)):
+            assert_allclose(a, b)
+
+    def test_equal_nan(self):
+        a = np.array([np.nan])
+        b = np.array([np.nan])
+        # Should not raise:
+        assert_allclose(a, b, equal_nan=True)
+
+    def test_not_equal_nan(self):
+        a = np.array([np.nan])
+        b = np.array([np.nan])
+        assert_raises(AssertionError, assert_allclose, a, b, equal_nan=False)
+
+    def test_equal_nan_default(self):
+        # Make sure equal_nan default behavior remains unchanged. (All
+        # of these functions use assert_array_compare under the hood.)
+        # None of these should raise.
+        a = np.array([np.nan])
+        b = np.array([np.nan])
+        assert_array_equal(a, b)
+        assert_array_almost_equal(a, b)
+        assert_array_less(a, b)
+        assert_allclose(a, b)
+
+    def test_report_max_relative_error(self):
+        a = np.array([0, 1])
+        b = np.array([0, 2])
+
+        expected_msg = 'Max relative difference among violations: 0.5'
+        with pytest.raises(AssertionError, match=re.escape(expected_msg)):
+            assert_allclose(a, b)
+
+    def test_timedelta(self):
+        # see gh-18286
+        a = np.array([[1, 2, 3, "NaT"]], dtype="m8[ns]")
+        assert_allclose(a, a)
+
+    def test_error_message_unsigned(self):
+        """Check the message is formatted correctly when overflow can occur
+           (gh21768)"""
+        # Ensure to test for potential overflow in the case of:
+        #        x - y
+        # and
+        #        y - x
+        x = np.asarray([0, 1, 8], dtype='uint8')
+        y = np.asarray([4, 4, 4], dtype='uint8')
+        expected_msg = 'Max absolute difference among violations: 4'
+        with pytest.raises(AssertionError, match=re.escape(expected_msg)):
+            assert_allclose(x, y, atol=3)
+
+    def test_strict(self):
+        """Test the behavior of the `strict` option."""
+        x = np.ones(3)
+        y = np.ones(())
+        assert_allclose(x, y)
+        with pytest.raises(AssertionError):
+            assert_allclose(x, y, strict=True)
+        assert_allclose(x, x)
+        with pytest.raises(AssertionError):
+            assert_allclose(x, x.astype(np.float32), strict=True)
+
+
+class TestArrayAlmostEqualNulp:
+
+    def test_float64_pass(self):
+        # The number of units of least precision
+        # In this case, use a few places above the lowest level (ie nulp=1)
+        nulp = 5
+        x = np.linspace(-20, 20, 50, dtype=np.float64)
+        x = 10**x
+        x = np.r_[-x, x]
+
+        # Addition
+        eps = np.finfo(x.dtype).eps
+        y = x + x*eps*nulp/2.
+        assert_array_almost_equal_nulp(x, y, nulp)
+
+        # Subtraction
+        epsneg = np.finfo(x.dtype).epsneg
+        y = x - x*epsneg*nulp/2.
+        assert_array_almost_equal_nulp(x, y, nulp)
+
+    def test_float64_fail(self):
+        nulp = 5
+        x = np.linspace(-20, 20, 50, dtype=np.float64)
+        x = 10**x
+        x = np.r_[-x, x]
+
+        eps = np.finfo(x.dtype).eps
+        y = x + x*eps*nulp*2.
+        assert_raises(AssertionError, assert_array_almost_equal_nulp,
+                      x, y, nulp)
+
+        epsneg = np.finfo(x.dtype).epsneg
+        y = x - x*epsneg*nulp*2.
+        assert_raises(AssertionError, assert_array_almost_equal_nulp,
+                      x, y, nulp)
+
+    def test_float64_ignore_nan(self):
+        # Ignore ULP differences between various NAN's
+        # Note that MIPS may reverse quiet and signaling nans
+        # so we use the builtin version as a base.
+        offset = np.uint64(0xffffffff)
+        nan1_i64 = np.array(np.nan, dtype=np.float64).view(np.uint64)
+        nan2_i64 = nan1_i64 ^ offset  # nan payload on MIPS is all ones.
+        nan1_f64 = nan1_i64.view(np.float64)
+        nan2_f64 = nan2_i64.view(np.float64)
+        assert_array_max_ulp(nan1_f64, nan2_f64, 0)
+
+    def test_float32_pass(self):
+        nulp = 5
+        x = np.linspace(-20, 20, 50, dtype=np.float32)
+        x = 10**x
+        x = np.r_[-x, x]
+
+        eps = np.finfo(x.dtype).eps
+        y = x + x*eps*nulp/2.
+        assert_array_almost_equal_nulp(x, y, nulp)
+
+        epsneg = np.finfo(x.dtype).epsneg
+        y = x - x*epsneg*nulp/2.
+        assert_array_almost_equal_nulp(x, y, nulp)
+
+    def test_float32_fail(self):
+        nulp = 5
+        x = np.linspace(-20, 20, 50, dtype=np.float32)
+        x = 10**x
+        x = np.r_[-x, x]
+
+        eps = np.finfo(x.dtype).eps
+        y = x + x*eps*nulp*2.
+        assert_raises(AssertionError, assert_array_almost_equal_nulp,
+                      x, y, nulp)
+
+        epsneg = np.finfo(x.dtype).epsneg
+        y = x - x*epsneg*nulp*2.
+        assert_raises(AssertionError, assert_array_almost_equal_nulp,
+                      x, y, nulp)
+
+    def test_float32_ignore_nan(self):
+        # Ignore ULP differences between various NAN's
+        # Note that MIPS may reverse quiet and signaling nans
+        # so we use the builtin version as a base.
+        offset = np.uint32(0xffff)
+        nan1_i32 = np.array(np.nan, dtype=np.float32).view(np.uint32)
+        nan2_i32 = nan1_i32 ^ offset  # nan payload on MIPS is all ones.
+        nan1_f32 = nan1_i32.view(np.float32)
+        nan2_f32 = nan2_i32.view(np.float32)
+        assert_array_max_ulp(nan1_f32, nan2_f32, 0)
+
+    def test_float16_pass(self):
+        nulp = 5
+        x = np.linspace(-4, 4, 10, dtype=np.float16)
+        x = 10**x
+        x = np.r_[-x, x]
+
+        eps = np.finfo(x.dtype).eps
+        y = x + x*eps*nulp/2.
+        assert_array_almost_equal_nulp(x, y, nulp)
+
+        epsneg = np.finfo(x.dtype).epsneg
+        y = x - x*epsneg*nulp/2.
+        assert_array_almost_equal_nulp(x, y, nulp)
+
+    def test_float16_fail(self):
+        nulp = 5
+        x = np.linspace(-4, 4, 10, dtype=np.float16)
+        x = 10**x
+        x = np.r_[-x, x]
+
+        eps = np.finfo(x.dtype).eps
+        y = x + x*eps*nulp*2.
+        assert_raises(AssertionError, assert_array_almost_equal_nulp,
+                      x, y, nulp)
+
+        epsneg = np.finfo(x.dtype).epsneg
+        y = x - x*epsneg*nulp*2.
+        assert_raises(AssertionError, assert_array_almost_equal_nulp,
+                      x, y, nulp)
+
+    def test_float16_ignore_nan(self):
+        # Ignore ULP differences between various NAN's
+        # Note that MIPS may reverse quiet and signaling nans
+        # so we use the builtin version as a base.
+        offset = np.uint16(0xff)
+        nan1_i16 = np.array(np.nan, dtype=np.float16).view(np.uint16)
+        nan2_i16 = nan1_i16 ^ offset  # nan payload on MIPS is all ones.
+        nan1_f16 = nan1_i16.view(np.float16)
+        nan2_f16 = nan2_i16.view(np.float16)
+        assert_array_max_ulp(nan1_f16, nan2_f16, 0)
+
+    def test_complex128_pass(self):
+        nulp = 5
+        x = np.linspace(-20, 20, 50, dtype=np.float64)
+        x = 10**x
+        x = np.r_[-x, x]
+        xi = x + x*1j
+
+        eps = np.finfo(x.dtype).eps
+        y = x + x*eps*nulp/2.
+        assert_array_almost_equal_nulp(xi, x + y*1j, nulp)
+        assert_array_almost_equal_nulp(xi, y + x*1j, nulp)
+        # The test condition needs to be at least a factor of sqrt(2) smaller
+        # because the real and imaginary parts both change
+        y = x + x*eps*nulp/4.
+        assert_array_almost_equal_nulp(xi, y + y*1j, nulp)
+
+        epsneg = np.finfo(x.dtype).epsneg
+        y = x - x*epsneg*nulp/2.
+        assert_array_almost_equal_nulp(xi, x + y*1j, nulp)
+        assert_array_almost_equal_nulp(xi, y + x*1j, nulp)
+        y = x - x*epsneg*nulp/4.
+        assert_array_almost_equal_nulp(xi, y + y*1j, nulp)
+
+    def test_complex128_fail(self):
+        nulp = 5
+        x = np.linspace(-20, 20, 50, dtype=np.float64)
+        x = 10**x
+        x = np.r_[-x, x]
+        xi = x + x*1j
+
+        eps = np.finfo(x.dtype).eps
+        y = x + x*eps*nulp*2.
+        assert_raises(AssertionError, assert_array_almost_equal_nulp,
+                      xi, x + y*1j, nulp)
+        assert_raises(AssertionError, assert_array_almost_equal_nulp,
+                      xi, y + x*1j, nulp)
+        # The test condition needs to be at least a factor of sqrt(2) smaller
+        # because the real and imaginary parts both change
+        y = x + x*eps*nulp
+        assert_raises(AssertionError, assert_array_almost_equal_nulp,
+                      xi, y + y*1j, nulp)
+
+        epsneg = np.finfo(x.dtype).epsneg
+        y = x - x*epsneg*nulp*2.
+        assert_raises(AssertionError, assert_array_almost_equal_nulp,
+                      xi, x + y*1j, nulp)
+        assert_raises(AssertionError, assert_array_almost_equal_nulp,
+                      xi, y + x*1j, nulp)
+        y = x - x*epsneg*nulp
+        assert_raises(AssertionError, assert_array_almost_equal_nulp,
+                      xi, y + y*1j, nulp)
+
+    def test_complex64_pass(self):
+        nulp = 5
+        x = np.linspace(-20, 20, 50, dtype=np.float32)
+        x = 10**x
+        x = np.r_[-x, x]
+        xi = x + x*1j
+
+        eps = np.finfo(x.dtype).eps
+        y = x + x*eps*nulp/2.
+        assert_array_almost_equal_nulp(xi, x + y*1j, nulp)
+        assert_array_almost_equal_nulp(xi, y + x*1j, nulp)
+        y = x + x*eps*nulp/4.
+        assert_array_almost_equal_nulp(xi, y + y*1j, nulp)
+
+        epsneg = np.finfo(x.dtype).epsneg
+        y = x - x*epsneg*nulp/2.
+        assert_array_almost_equal_nulp(xi, x + y*1j, nulp)
+        assert_array_almost_equal_nulp(xi, y + x*1j, nulp)
+        y = x - x*epsneg*nulp/4.
+        assert_array_almost_equal_nulp(xi, y + y*1j, nulp)
+
+    def test_complex64_fail(self):
+        nulp = 5
+        x = np.linspace(-20, 20, 50, dtype=np.float32)
+        x = 10**x
+        x = np.r_[-x, x]
+        xi = x + x*1j
+
+        eps = np.finfo(x.dtype).eps
+        y = x + x*eps*nulp*2.
+        assert_raises(AssertionError, assert_array_almost_equal_nulp,
+                      xi, x + y*1j, nulp)
+        assert_raises(AssertionError, assert_array_almost_equal_nulp,
+                      xi, y + x*1j, nulp)
+        y = x + x*eps*nulp
+        assert_raises(AssertionError, assert_array_almost_equal_nulp,
+                      xi, y + y*1j, nulp)
+
+        epsneg = np.finfo(x.dtype).epsneg
+        y = x - x*epsneg*nulp*2.
+        assert_raises(AssertionError, assert_array_almost_equal_nulp,
+                      xi, x + y*1j, nulp)
+        assert_raises(AssertionError, assert_array_almost_equal_nulp,
+                      xi, y + x*1j, nulp)
+        y = x - x*epsneg*nulp
+        assert_raises(AssertionError, assert_array_almost_equal_nulp,
+                      xi, y + y*1j, nulp)
+
+
+class TestULP:
+
+    def test_equal(self):
+        x = np.random.randn(10)
+        assert_array_max_ulp(x, x, maxulp=0)
+
+    def test_single(self):
+        # Generate 1 + small deviation, check that adding eps gives a few UNL
+        x = np.ones(10).astype(np.float32)
+        x += 0.01 * np.random.randn(10).astype(np.float32)
+        eps = np.finfo(np.float32).eps
+        assert_array_max_ulp(x, x+eps, maxulp=20)
+
+    def test_double(self):
+        # Generate 1 + small deviation, check that adding eps gives a few UNL
+        x = np.ones(10).astype(np.float64)
+        x += 0.01 * np.random.randn(10).astype(np.float64)
+        eps = np.finfo(np.float64).eps
+        assert_array_max_ulp(x, x+eps, maxulp=200)
+
+    def test_inf(self):
+        for dt in [np.float32, np.float64]:
+            inf = np.array([np.inf]).astype(dt)
+            big = np.array([np.finfo(dt).max])
+            assert_array_max_ulp(inf, big, maxulp=200)
+
+    def test_nan(self):
+        # Test that nan is 'far' from small, tiny, inf, max and min
+        for dt in [np.float32, np.float64]:
+            if dt == np.float32:
+                maxulp = 1e6
+            else:
+                maxulp = 1e12
+            inf = np.array([np.inf]).astype(dt)
+            nan = np.array([np.nan]).astype(dt)
+            big = np.array([np.finfo(dt).max])
+            tiny = np.array([np.finfo(dt).tiny])
+            zero = np.array([0.0]).astype(dt)
+            nzero = np.array([-0.0]).astype(dt)
+            assert_raises(AssertionError,
+                          lambda: assert_array_max_ulp(nan, inf,
+                                                       maxulp=maxulp))
+            assert_raises(AssertionError,
+                          lambda: assert_array_max_ulp(nan, big,
+                                                       maxulp=maxulp))
+            assert_raises(AssertionError,
+                          lambda: assert_array_max_ulp(nan, tiny,
+                                                       maxulp=maxulp))
+            assert_raises(AssertionError,
+                          lambda: assert_array_max_ulp(nan, zero,
+                                                       maxulp=maxulp))
+            assert_raises(AssertionError,
+                          lambda: assert_array_max_ulp(nan, nzero,
+                                                       maxulp=maxulp))
+
+
+class TestStringEqual:
+    def test_simple(self):
+        assert_string_equal("hello", "hello")
+        assert_string_equal("hello\nmultiline", "hello\nmultiline")
+
+        with pytest.raises(AssertionError) as exc_info:
+            assert_string_equal("foo\nbar", "hello\nbar")
+        msg = str(exc_info.value)
+        assert_equal(msg, "Differences in strings:\n- foo\n+ hello")
+
+        assert_raises(AssertionError,
+                      lambda: assert_string_equal("foo", "hello"))
+
+    def test_regex(self):
+        assert_string_equal("a+*b", "a+*b")
+
+        assert_raises(AssertionError,
+                      lambda: assert_string_equal("aaa", "a+b"))
+
+
+def assert_warn_len_equal(mod, n_in_context):
+    try:
+        mod_warns = mod.__warningregistry__
+    except AttributeError:
+        # the lack of a __warningregistry__
+        # attribute means that no warning has
+        # occurred; this can be triggered in
+        # a parallel test scenario, while in
+        # a serial test scenario an initial
+        # warning (and therefore the attribute)
+        # are always created first
+        mod_warns = {}
+
+    num_warns = len(mod_warns)
+
+    if 'version' in mod_warns:
+        # Python 3 adds a 'version' entry to the registry,
+        # do not count it.
+        num_warns -= 1
+
+    assert_equal(num_warns, n_in_context)
+
+
+def test_warn_len_equal_call_scenarios():
+    # assert_warn_len_equal is called under
+    # varying circumstances depending on serial
+    # vs. parallel test scenarios; this test
+    # simply aims to probe both code paths and
+    # check that no assertion is uncaught
+
+    # parallel scenario -- no warning issued yet
+    class mod:
+        pass
+
+    mod_inst = mod()
+
+    assert_warn_len_equal(mod=mod_inst,
+                          n_in_context=0)
+
+    # serial test scenario -- the __warningregistry__
+    # attribute should be present
+    class mod:
+        def __init__(self):
+            self.__warningregistry__ = {'warning1': 1,
+                                        'warning2': 2}
+
+    mod_inst = mod()
+    assert_warn_len_equal(mod=mod_inst,
+                          n_in_context=2)
+
+
+def _get_fresh_mod():
+    # Get this module, with warning registry empty
+    my_mod = sys.modules[__name__]
+    try:
+        my_mod.__warningregistry__.clear()
+    except AttributeError:
+        # will not have a __warningregistry__ unless warning has been
+        # raised in the module at some point
+        pass
+    return my_mod
+
+
+def test_clear_and_catch_warnings():
+    # Initial state of module, no warnings
+    my_mod = _get_fresh_mod()
+    assert_equal(getattr(my_mod, '__warningregistry__', {}), {})
+    with clear_and_catch_warnings(modules=[my_mod]):
+        warnings.simplefilter('ignore')
+        warnings.warn('Some warning')
+    assert_equal(my_mod.__warningregistry__, {})
+    # Without specified modules, don't clear warnings during context.
+    # catch_warnings doesn't make an entry for 'ignore'.
+    with clear_and_catch_warnings():
+        warnings.simplefilter('ignore')
+        warnings.warn('Some warning')
+    assert_warn_len_equal(my_mod, 0)
+
+    # Manually adding two warnings to the registry:
+    my_mod.__warningregistry__ = {'warning1': 1,
+                                  'warning2': 2}
+
+    # Confirm that specifying module keeps old warning, does not add new
+    with clear_and_catch_warnings(modules=[my_mod]):
+        warnings.simplefilter('ignore')
+        warnings.warn('Another warning')
+    assert_warn_len_equal(my_mod, 2)
+
+    # Another warning, no module spec it clears up registry
+    with clear_and_catch_warnings():
+        warnings.simplefilter('ignore')
+        warnings.warn('Another warning')
+    assert_warn_len_equal(my_mod, 0)
+
+
+def test_suppress_warnings_module():
+    # Initial state of module, no warnings
+    my_mod = _get_fresh_mod()
+    assert_equal(getattr(my_mod, '__warningregistry__', {}), {})
+
+    def warn_other_module():
+        # Apply along axis is implemented in python; stacklevel=2 means
+        # we end up inside its module, not ours.
+        def warn(arr):
+            warnings.warn("Some warning 2", stacklevel=2)
+            return arr
+        np.apply_along_axis(warn, 0, [0])
+
+    # Test module based warning suppression:
+    assert_warn_len_equal(my_mod, 0)
+    with suppress_warnings() as sup:
+        sup.record(UserWarning)
+        # suppress warning from other module (may have .pyc ending),
+        # if apply_along_axis is moved, had to be changed.
+        sup.filter(module=np.lib._shape_base_impl)
+        warnings.warn("Some warning")
+        warn_other_module()
+    # Check that the suppression did test the file correctly (this module
+    # got filtered)
+    assert_equal(len(sup.log), 1)
+    assert_equal(sup.log[0].message.args[0], "Some warning")
+    assert_warn_len_equal(my_mod, 0)
+    sup = suppress_warnings()
+    # Will have to be changed if apply_along_axis is moved:
+    sup.filter(module=my_mod)
+    with sup:
+        warnings.warn('Some warning')
+    assert_warn_len_equal(my_mod, 0)
+    # And test repeat works:
+    sup.filter(module=my_mod)
+    with sup:
+        warnings.warn('Some warning')
+    assert_warn_len_equal(my_mod, 0)
+
+    # Without specified modules
+    with suppress_warnings():
+        warnings.simplefilter('ignore')
+        warnings.warn('Some warning')
+    assert_warn_len_equal(my_mod, 0)
+
+
+def test_suppress_warnings_type():
+    # Initial state of module, no warnings
+    my_mod = _get_fresh_mod()
+    assert_equal(getattr(my_mod, '__warningregistry__', {}), {})
+
+    # Test module based warning suppression:
+    with suppress_warnings() as sup:
+        sup.filter(UserWarning)
+        warnings.warn('Some warning')
+    assert_warn_len_equal(my_mod, 0)
+    sup = suppress_warnings()
+    sup.filter(UserWarning)
+    with sup:
+        warnings.warn('Some warning')
+    assert_warn_len_equal(my_mod, 0)
+    # And test repeat works:
+    sup.filter(module=my_mod)
+    with sup:
+        warnings.warn('Some warning')
+    assert_warn_len_equal(my_mod, 0)
+
+    # Without specified modules
+    with suppress_warnings():
+        warnings.simplefilter('ignore')
+        warnings.warn('Some warning')
+    assert_warn_len_equal(my_mod, 0)
+
+
+def test_suppress_warnings_decorate_no_record():
+    sup = suppress_warnings()
+    sup.filter(UserWarning)
+
+    @sup
+    def warn(category):
+        warnings.warn('Some warning', category)
+
+    with warnings.catch_warnings(record=True) as w:
+        warnings.simplefilter("always")
+        warn(UserWarning)  # should be supppressed
+        warn(RuntimeWarning)
+        assert_equal(len(w), 1)
+
+
+def test_suppress_warnings_record():
+    sup = suppress_warnings()
+    log1 = sup.record()
+
+    with sup:
+        log2 = sup.record(message='Some other warning 2')
+        sup.filter(message='Some warning')
+        warnings.warn('Some warning')
+        warnings.warn('Some other warning')
+        warnings.warn('Some other warning 2')
+
+        assert_equal(len(sup.log), 2)
+        assert_equal(len(log1), 1)
+        assert_equal(len(log2), 1)
+        assert_equal(log2[0].message.args[0], 'Some other warning 2')
+
+    # Do it again, with the same context to see if some warnings survived:
+    with sup:
+        log2 = sup.record(message='Some other warning 2')
+        sup.filter(message='Some warning')
+        warnings.warn('Some warning')
+        warnings.warn('Some other warning')
+        warnings.warn('Some other warning 2')
+
+        assert_equal(len(sup.log), 2)
+        assert_equal(len(log1), 1)
+        assert_equal(len(log2), 1)
+        assert_equal(log2[0].message.args[0], 'Some other warning 2')
+
+    # Test nested:
+    with suppress_warnings() as sup:
+        sup.record()
+        with suppress_warnings() as sup2:
+            sup2.record(message='Some warning')
+            warnings.warn('Some warning')
+            warnings.warn('Some other warning')
+            assert_equal(len(sup2.log), 1)
+        assert_equal(len(sup.log), 1)
+
+
+def test_suppress_warnings_forwarding():
+    def warn_other_module():
+        # Apply along axis is implemented in python; stacklevel=2 means
+        # we end up inside its module, not ours.
+        def warn(arr):
+            warnings.warn("Some warning", stacklevel=2)
+            return arr
+        np.apply_along_axis(warn, 0, [0])
+
+    with suppress_warnings() as sup:
+        sup.record()
+        with suppress_warnings("always"):
+            for i in range(2):
+                warnings.warn("Some warning")
+
+        assert_equal(len(sup.log), 2)
+
+    with suppress_warnings() as sup:
+        sup.record()
+        with suppress_warnings("location"):
+            for i in range(2):
+                warnings.warn("Some warning")
+                warnings.warn("Some warning")
+
+        assert_equal(len(sup.log), 2)
+
+    with suppress_warnings() as sup:
+        sup.record()
+        with suppress_warnings("module"):
+            for i in range(2):
+                warnings.warn("Some warning")
+                warnings.warn("Some warning")
+                warn_other_module()
+
+        assert_equal(len(sup.log), 2)
+
+    with suppress_warnings() as sup:
+        sup.record()
+        with suppress_warnings("once"):
+            for i in range(2):
+                warnings.warn("Some warning")
+                warnings.warn("Some other warning")
+                warn_other_module()
+
+        assert_equal(len(sup.log), 2)
+
+
+def test_tempdir():
+    with tempdir() as tdir:
+        fpath = os.path.join(tdir, 'tmp')
+        with open(fpath, 'w'):
+            pass
+    assert_(not os.path.isdir(tdir))
+
+    raised = False
+    try:
+        with tempdir() as tdir:
+            raise ValueError()
+    except ValueError:
+        raised = True
+    assert_(raised)
+    assert_(not os.path.isdir(tdir))
+
+
+def test_temppath():
+    with temppath() as fpath:
+        with open(fpath, 'w'):
+            pass
+    assert_(not os.path.isfile(fpath))
+
+    raised = False
+    try:
+        with temppath() as fpath:
+            raise ValueError()
+    except ValueError:
+        raised = True
+    assert_(raised)
+    assert_(not os.path.isfile(fpath))
+
+
+class my_cacw(clear_and_catch_warnings):
+
+    class_modules = (sys.modules[__name__],)
+
+
+def test_clear_and_catch_warnings_inherit():
+    # Test can subclass and add default modules
+    my_mod = _get_fresh_mod()
+    with my_cacw():
+        warnings.simplefilter('ignore')
+        warnings.warn('Some warning')
+    assert_equal(my_mod.__warningregistry__, {})
+
+
+@pytest.mark.skipif(not HAS_REFCOUNT, reason="Python lacks refcounts")
+class TestAssertNoGcCycles:
+    """ Test assert_no_gc_cycles """
+
+    def test_passes(self):
+        def no_cycle():
+            b = []
+            b.append([])
+            return b
+
+        with assert_no_gc_cycles():
+            no_cycle()
+
+        assert_no_gc_cycles(no_cycle)
+
+    def test_asserts(self):
+        def make_cycle():
+            a = []
+            a.append(a)
+            a.append(a)
+            return a
+
+        with assert_raises(AssertionError):
+            with assert_no_gc_cycles():
+                make_cycle()
+
+        with assert_raises(AssertionError):
+            assert_no_gc_cycles(make_cycle)
+
+    @pytest.mark.slow
+    def test_fails(self):
+        """
+        Test that in cases where the garbage cannot be collected, we raise an
+        error, instead of hanging forever trying to clear it.
+        """
+
+        class ReferenceCycleInDel:
+            """
+            An object that not only contains a reference cycle, but creates new
+            cycles whenever it's garbage-collected and its __del__ runs
+            """
+            make_cycle = True
+
+            def __init__(self):
+                self.cycle = self
+
+            def __del__(self):
+                # break the current cycle so that `self` can be freed
+                self.cycle = None
+
+                if ReferenceCycleInDel.make_cycle:
+                    # but create a new one so that the garbage collector has more
+                    # work to do.
+                    ReferenceCycleInDel()
+
+        try:
+            w = weakref.ref(ReferenceCycleInDel())
+            try:
+                with assert_raises(RuntimeError):
+                    # this will be unable to get a baseline empty garbage
+                    assert_no_gc_cycles(lambda: None)
+            except AssertionError:
+                # the above test is only necessary if the GC actually tried to free
+                # our object anyway, which python 2.7 does not.
+                if w() is not None:
+                    pytest.skip("GC does not call __del__ on cyclic objects")
+                    raise
+
+        finally:
+            # make sure that we stop creating reference cycles
+            ReferenceCycleInDel.make_cycle = False
+
+
+@pytest.mark.parametrize('assert_func', [assert_array_equal,
+                                         assert_array_almost_equal])
+def test_xy_rename(assert_func):
+    # Test that keywords `x` and `y` have been renamed to `actual` and
+    # `desired`, respectively. These tests and use of `_rename_parameter`
+    # decorator can be removed before the release of NumPy 2.2.0.
+    assert_func(1, 1)
+    assert_func(actual=1, desired=1)
+
+    assert_message = "Arrays are not..."
+    with pytest.raises(AssertionError, match=assert_message):
+        assert_func(1, 2)
+    with pytest.raises(AssertionError, match=assert_message):
+        assert_func(actual=1, desired=2)
+
+    dep_message = 'Use of keyword argument...'
+    with pytest.warns(DeprecationWarning, match=dep_message):
+        assert_func(x=1, desired=1)
+    with pytest.warns(DeprecationWarning, match=dep_message):
+        assert_func(1, y=1)
+
+    type_message = '...got multiple values for argument'
+    with (pytest.warns(DeprecationWarning, match=dep_message),
+          pytest.raises(TypeError, match=type_message)):
+        assert_func(1, x=1)
+        assert_func(1, 2, y=2)
diff --git a/venv/lib/python3.12/site-packages/numpy/tests/__init__.py b/venv/lib/python3.12/site-packages/numpy/tests/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/venv/lib/python3.12/site-packages/numpy/tests/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/tests/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 00000000..2e0cb44b
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/tests/__pycache__/__init__.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/tests/__pycache__/test__all__.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/tests/__pycache__/test__all__.cpython-312.pyc
new file mode 100644
index 00000000..98b45cd4
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/tests/__pycache__/test__all__.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/tests/__pycache__/test_configtool.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/tests/__pycache__/test_configtool.cpython-312.pyc
new file mode 100644
index 00000000..20737615
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/tests/__pycache__/test_configtool.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/tests/__pycache__/test_ctypeslib.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/tests/__pycache__/test_ctypeslib.cpython-312.pyc
new file mode 100644
index 00000000..c16445dd
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/tests/__pycache__/test_ctypeslib.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/tests/__pycache__/test_lazyloading.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/tests/__pycache__/test_lazyloading.cpython-312.pyc
new file mode 100644
index 00000000..fbea2b13
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/tests/__pycache__/test_lazyloading.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/tests/__pycache__/test_matlib.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/tests/__pycache__/test_matlib.cpython-312.pyc
new file mode 100644
index 00000000..bc7168c8
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/tests/__pycache__/test_matlib.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/tests/__pycache__/test_numpy_config.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/tests/__pycache__/test_numpy_config.cpython-312.pyc
new file mode 100644
index 00000000..9f1c8387
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/tests/__pycache__/test_numpy_config.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/tests/__pycache__/test_numpy_version.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/tests/__pycache__/test_numpy_version.cpython-312.pyc
new file mode 100644
index 00000000..84c3e56c
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/tests/__pycache__/test_numpy_version.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/tests/__pycache__/test_public_api.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/tests/__pycache__/test_public_api.cpython-312.pyc
new file mode 100644
index 00000000..ce547ca2
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/tests/__pycache__/test_public_api.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/tests/__pycache__/test_reloading.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/tests/__pycache__/test_reloading.cpython-312.pyc
new file mode 100644
index 00000000..d519c56c
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/tests/__pycache__/test_reloading.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/tests/__pycache__/test_scripts.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/tests/__pycache__/test_scripts.cpython-312.pyc
new file mode 100644
index 00000000..94d7bbd1
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/tests/__pycache__/test_scripts.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/tests/__pycache__/test_warnings.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/tests/__pycache__/test_warnings.cpython-312.pyc
new file mode 100644
index 00000000..6c531bc5
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/tests/__pycache__/test_warnings.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/tests/test__all__.py b/venv/lib/python3.12/site-packages/numpy/tests/test__all__.py
new file mode 100644
index 00000000..e44bda3d
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/tests/test__all__.py
@@ -0,0 +1,9 @@
+
+import collections
+import numpy as np
+
+
+def test_no_duplicates_in_np__all__():
+    # Regression test for gh-10198.
+    dups = {k: v for k, v in collections.Counter(np.__all__).items() if v > 1}
+    assert len(dups) == 0
diff --git a/venv/lib/python3.12/site-packages/numpy/tests/test_configtool.py b/venv/lib/python3.12/site-packages/numpy/tests/test_configtool.py
new file mode 100644
index 00000000..5215057f
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/tests/test_configtool.py
@@ -0,0 +1,43 @@
+import os
+import subprocess
+import sysconfig
+
+import pytest
+import numpy as np
+
+from numpy.testing import IS_WASM
+
+
+is_editable = not bool(np.__path__)
+numpy_in_sitepackages = sysconfig.get_path('platlib') in np.__file__
+# We only expect to have a `numpy-config` available if NumPy was installed via
+# a build frontend (and not `spin` for example)
+if not (numpy_in_sitepackages or is_editable):
+    pytest.skip("`numpy-config` not expected to be installed",
+                allow_module_level=True)
+
+
+def check_numpyconfig(arg):
+    p = subprocess.run(['numpy-config', arg], capture_output=True, text=True)
+    p.check_returncode()
+    return p.stdout.strip()
+
+@pytest.mark.skipif(IS_WASM, reason="wasm interpreter cannot start subprocess")
+def test_configtool_version():
+    stdout = check_numpyconfig('--version')
+    assert stdout == np.__version__
+
+@pytest.mark.skipif(IS_WASM, reason="wasm interpreter cannot start subprocess")
+def test_configtool_cflags():
+    stdout = check_numpyconfig('--cflags')
+    assert stdout.endswith(os.path.join('numpy', '_core', 'include'))
+
+@pytest.mark.skipif(IS_WASM, reason="wasm interpreter cannot start subprocess")
+def test_configtool_pkgconfigdir():
+    stdout = check_numpyconfig('--pkgconfigdir')
+    assert stdout.endswith(os.path.join('numpy', '_core', 'lib', 'pkgconfig'))
+
+    if not is_editable:
+        # Also check that the .pc file actually exists (unless we're using an
+        # editable install, then it'll be hiding in the build dir)
+        assert os.path.exists(os.path.join(stdout, 'numpy.pc'))
diff --git a/venv/lib/python3.12/site-packages/numpy/tests/test_ctypeslib.py b/venv/lib/python3.12/site-packages/numpy/tests/test_ctypeslib.py
new file mode 100644
index 00000000..2fd0c042
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/tests/test_ctypeslib.py
@@ -0,0 +1,377 @@
+import sys
+import sysconfig
+import weakref
+from pathlib import Path
+
+import pytest
+
+import numpy as np
+from numpy.ctypeslib import ndpointer, load_library, as_array
+from numpy.testing import assert_, assert_array_equal, assert_raises, assert_equal
+
+try:
+    import ctypes
+except ImportError:
+    ctypes = None
+else:
+    cdll = None
+    test_cdll = None
+    if hasattr(sys, 'gettotalrefcount'):
+        try:
+            cdll = load_library(
+                '_multiarray_umath_d', np._core._multiarray_umath.__file__
+            )
+        except OSError:
+            pass
+        try:
+            test_cdll = load_library(
+                '_multiarray_tests', np._core._multiarray_tests.__file__
+            )
+        except OSError:
+            pass
+    if cdll is None:
+        cdll = load_library(
+            '_multiarray_umath', np._core._multiarray_umath.__file__)
+    if test_cdll is None:
+        test_cdll = load_library(
+            '_multiarray_tests', np._core._multiarray_tests.__file__
+        )
+
+    c_forward_pointer = test_cdll.forward_pointer
+
+
+@pytest.mark.skipif(ctypes is None,
+                    reason="ctypes not available in this python")
+@pytest.mark.skipif(sys.platform == 'cygwin',
+                    reason="Known to fail on cygwin")
+class TestLoadLibrary:
+    def test_basic(self):
+        loader_path = np._core._multiarray_umath.__file__
+
+        out1 = load_library('_multiarray_umath', loader_path)
+        out2 = load_library(Path('_multiarray_umath'), loader_path)
+        out3 = load_library('_multiarray_umath', Path(loader_path))
+        out4 = load_library(b'_multiarray_umath', loader_path)
+
+        assert isinstance(out1, ctypes.CDLL)
+        assert out1 is out2 is out3 is out4
+
+    def test_basic2(self):
+        # Regression for #801: load_library with a full library name
+        # (including extension) does not work.
+        try:
+            so_ext = sysconfig.get_config_var('EXT_SUFFIX')
+            load_library('_multiarray_umath%s' % so_ext,
+                         np._core._multiarray_umath.__file__)
+        except ImportError as e:
+            msg = ("ctypes is not available on this python: skipping the test"
+                   " (import error was: %s)" % str(e))
+            print(msg)
+
+
+class TestNdpointer:
+    def test_dtype(self):
+        dt = np.intc
+        p = ndpointer(dtype=dt)
+        assert_(p.from_param(np.array([1], dt)))
+        dt = 'i4')
+        p = ndpointer(dtype=dt)
+        p.from_param(np.array([1], dt))
+        assert_raises(TypeError, p.from_param,
+                          np.array([1], dt.newbyteorder('swap')))
+        dtnames = ['x', 'y']
+        dtformats = [np.intc, np.float64]
+        dtdescr = {'names': dtnames, 'formats': dtformats}
+        dt = np.dtype(dtdescr)
+        p = ndpointer(dtype=dt)
+        assert_(p.from_param(np.zeros((10,), dt)))
+        samedt = np.dtype(dtdescr)
+        p = ndpointer(dtype=samedt)
+        assert_(p.from_param(np.zeros((10,), dt)))
+        dt2 = np.dtype(dtdescr, align=True)
+        if dt.itemsize != dt2.itemsize:
+            assert_raises(TypeError, p.from_param, np.zeros((10,), dt2))
+        else:
+            assert_(p.from_param(np.zeros((10,), dt2)))
+
+    def test_ndim(self):
+        p = ndpointer(ndim=0)
+        assert_(p.from_param(np.array(1)))
+        assert_raises(TypeError, p.from_param, np.array([1]))
+        p = ndpointer(ndim=1)
+        assert_raises(TypeError, p.from_param, np.array(1))
+        assert_(p.from_param(np.array([1])))
+        p = ndpointer(ndim=2)
+        assert_(p.from_param(np.array([[1]])))
+
+    def test_shape(self):
+        p = ndpointer(shape=(1, 2))
+        assert_(p.from_param(np.array([[1, 2]])))
+        assert_raises(TypeError, p.from_param, np.array([[1], [2]]))
+        p = ndpointer(shape=())
+        assert_(p.from_param(np.array(1)))
+
+    def test_flags(self):
+        x = np.array([[1, 2], [3, 4]], order='F')
+        p = ndpointer(flags='FORTRAN')
+        assert_(p.from_param(x))
+        p = ndpointer(flags='CONTIGUOUS')
+        assert_raises(TypeError, p.from_param, x)
+        p = ndpointer(flags=x.flags.num)
+        assert_(p.from_param(x))
+        assert_raises(TypeError, p.from_param, np.array([[1, 2], [3, 4]]))
+
+    def test_cache(self):
+        assert_(ndpointer(dtype=np.float64) is ndpointer(dtype=np.float64))
+
+        # shapes are normalized
+        assert_(ndpointer(shape=2) is ndpointer(shape=(2,)))
+
+        # 1.12 <= v < 1.16 had a bug that made these fail
+        assert_(ndpointer(shape=2) is not ndpointer(ndim=2))
+        assert_(ndpointer(ndim=2) is not ndpointer(shape=2))
+
+@pytest.mark.skipif(ctypes is None,
+                    reason="ctypes not available on this python installation")
+class TestNdpointerCFunc:
+    def test_arguments(self):
+        """ Test that arguments are coerced from arrays """
+        c_forward_pointer.restype = ctypes.c_void_p
+        c_forward_pointer.argtypes = (ndpointer(ndim=2),)
+
+        c_forward_pointer(np.zeros((2, 3)))
+        # too many dimensions
+        assert_raises(
+            ctypes.ArgumentError, c_forward_pointer, np.zeros((2, 3, 4)))
+
+    @pytest.mark.parametrize(
+        'dt', [
+            float,
+            np.dtype(dict(
+                formats=['u2')
+        ct = np.ctypeslib.as_ctypes_type(dt)
+        assert_equal(ct, ctypes.c_uint16.__ctype_be__)
+
+        dt = np.dtype('u2')
+        ct = np.ctypeslib.as_ctypes_type(dt)
+        assert_equal(ct, ctypes.c_uint16)
+
+    def test_subarray(self):
+        dt = np.dtype((np.int32, (2, 3)))
+        ct = np.ctypeslib.as_ctypes_type(dt)
+        assert_equal(ct, 2 * (3 * ctypes.c_int32))
+
+    def test_structure(self):
+        dt = np.dtype([
+            ('a', np.uint16),
+            ('b', np.uint32),
+        ])
+
+        ct = np.ctypeslib.as_ctypes_type(dt)
+        assert_(issubclass(ct, ctypes.Structure))
+        assert_equal(ctypes.sizeof(ct), dt.itemsize)
+        assert_equal(ct._fields_, [
+            ('a', ctypes.c_uint16),
+            ('b', ctypes.c_uint32),
+        ])
+
+    def test_structure_aligned(self):
+        dt = np.dtype([
+            ('a', np.uint16),
+            ('b', np.uint32),
+        ], align=True)
+
+        ct = np.ctypeslib.as_ctypes_type(dt)
+        assert_(issubclass(ct, ctypes.Structure))
+        assert_equal(ctypes.sizeof(ct), dt.itemsize)
+        assert_equal(ct._fields_, [
+            ('a', ctypes.c_uint16),
+            ('', ctypes.c_char * 2),  # padding
+            ('b', ctypes.c_uint32),
+        ])
+
+    def test_union(self):
+        dt = np.dtype(dict(
+            names=['a', 'b'],
+            offsets=[0, 0],
+            formats=[np.uint16, np.uint32]
+        ))
+
+        ct = np.ctypeslib.as_ctypes_type(dt)
+        assert_(issubclass(ct, ctypes.Union))
+        assert_equal(ctypes.sizeof(ct), dt.itemsize)
+        assert_equal(ct._fields_, [
+            ('a', ctypes.c_uint16),
+            ('b', ctypes.c_uint32),
+        ])
+
+    def test_padded_union(self):
+        dt = np.dtype(dict(
+            names=['a', 'b'],
+            offsets=[0, 0],
+            formats=[np.uint16, np.uint32],
+            itemsize=5,
+        ))
+
+        ct = np.ctypeslib.as_ctypes_type(dt)
+        assert_(issubclass(ct, ctypes.Union))
+        assert_equal(ctypes.sizeof(ct), dt.itemsize)
+        assert_equal(ct._fields_, [
+            ('a', ctypes.c_uint16),
+            ('b', ctypes.c_uint32),
+            ('', ctypes.c_char * 5),  # padding
+        ])
+
+    def test_overlapping(self):
+        dt = np.dtype(dict(
+            names=['a', 'b'],
+            offsets=[0, 2],
+            formats=[np.uint32, np.uint32]
+        ))
+        assert_raises(NotImplementedError, np.ctypeslib.as_ctypes_type, dt)
diff --git a/venv/lib/python3.12/site-packages/numpy/tests/test_lazyloading.py b/venv/lib/python3.12/site-packages/numpy/tests/test_lazyloading.py
new file mode 100644
index 00000000..f31a4eab
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/tests/test_lazyloading.py
@@ -0,0 +1,38 @@
+import sys
+import importlib
+from importlib.util import LazyLoader, find_spec, module_from_spec
+import pytest
+
+
+# Warning raised by _reload_guard() in numpy/__init__.py
+@pytest.mark.filterwarnings("ignore:The NumPy module was reloaded")
+def test_lazy_load():
+    # gh-22045. lazyload doesn't import submodule names into the namespace
+    # muck with sys.modules to test the importing system
+    old_numpy = sys.modules.pop("numpy")
+
+    numpy_modules = {}
+    for mod_name, mod in list(sys.modules.items()):
+        if mod_name[:6] == "numpy.":
+            numpy_modules[mod_name] = mod
+            sys.modules.pop(mod_name)
+
+    try:
+        # create lazy load of numpy as np
+        spec = find_spec("numpy")
+        module = module_from_spec(spec)
+        sys.modules["numpy"] = module
+        loader = LazyLoader(spec.loader)
+        loader.exec_module(module)
+        np = module
+
+        # test a subpackage import
+        from numpy.lib import recfunctions
+
+        # test triggering the import of the package
+        np.ndarray
+
+    finally:
+        if old_numpy:
+            sys.modules["numpy"] = old_numpy
+            sys.modules.update(numpy_modules)
diff --git a/venv/lib/python3.12/site-packages/numpy/tests/test_matlib.py b/venv/lib/python3.12/site-packages/numpy/tests/test_matlib.py
new file mode 100644
index 00000000..0e93c484
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/tests/test_matlib.py
@@ -0,0 +1,58 @@
+import numpy as np
+import numpy.matlib
+from numpy.testing import assert_array_equal, assert_
+
+def test_empty():
+    x = numpy.matlib.empty((2,))
+    assert_(isinstance(x, np.matrix))
+    assert_(x.shape, (1, 2))
+
+def test_ones():
+    assert_array_equal(numpy.matlib.ones((2, 3)),
+                       np.matrix([[ 1.,  1.,  1.],
+                                 [ 1.,  1.,  1.]]))
+
+    assert_array_equal(numpy.matlib.ones(2), np.matrix([[ 1.,  1.]]))
+
+def test_zeros():
+    assert_array_equal(numpy.matlib.zeros((2, 3)),
+                       np.matrix([[ 0.,  0.,  0.],
+                                 [ 0.,  0.,  0.]]))
+
+    assert_array_equal(numpy.matlib.zeros(2), np.matrix([[ 0.,  0.]]))
+
+def test_identity():
+    x = numpy.matlib.identity(2, dtype=int)
+    assert_array_equal(x, np.matrix([[1, 0], [0, 1]]))
+
+def test_eye():
+    xc = numpy.matlib.eye(3, k=1, dtype=int)
+    assert_array_equal(xc, np.matrix([[ 0,  1,  0],
+                                      [ 0,  0,  1],
+                                      [ 0,  0,  0]]))
+    assert xc.flags.c_contiguous
+    assert not xc.flags.f_contiguous
+
+    xf = numpy.matlib.eye(3, 4, dtype=int, order='F')
+    assert_array_equal(xf, np.matrix([[ 1,  0,  0,  0],
+                                      [ 0,  1,  0,  0],
+                                      [ 0,  0,  1,  0]]))
+    assert not xf.flags.c_contiguous
+    assert xf.flags.f_contiguous
+
+def test_rand():
+    x = numpy.matlib.rand(3)
+    # check matrix type, array would have shape (3,)
+    assert_(x.ndim == 2)
+
+def test_randn():
+    x = np.matlib.randn(3)
+    # check matrix type, array would have shape (3,)
+    assert_(x.ndim == 2)
+
+def test_repmat():
+    a1 = np.arange(4)
+    x = numpy.matlib.repmat(a1, 2, 2)
+    y = np.array([[0, 1, 2, 3, 0, 1, 2, 3],
+                  [0, 1, 2, 3, 0, 1, 2, 3]])
+    assert_array_equal(x, y)
diff --git a/venv/lib/python3.12/site-packages/numpy/tests/test_numpy_config.py b/venv/lib/python3.12/site-packages/numpy/tests/test_numpy_config.py
new file mode 100644
index 00000000..82c1ad70
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/tests/test_numpy_config.py
@@ -0,0 +1,44 @@
+"""
+Check the numpy config is valid.
+"""
+import numpy as np
+import pytest
+from unittest.mock import Mock, patch
+
+pytestmark = pytest.mark.skipif(
+    not hasattr(np.__config__, "_built_with_meson"),
+    reason="Requires Meson builds",
+)
+
+
+class TestNumPyConfigs:
+    REQUIRED_CONFIG_KEYS = [
+        "Compilers",
+        "Machine Information",
+        "Python Information",
+    ]
+
+    @patch("numpy.__config__._check_pyyaml")
+    def test_pyyaml_not_found(self, mock_yaml_importer):
+        mock_yaml_importer.side_effect = ModuleNotFoundError()
+        with pytest.warns(UserWarning):
+            np.show_config()
+
+    def test_dict_mode(self):
+        config = np.show_config(mode="dicts")
+
+        assert isinstance(config, dict)
+        assert all([key in config for key in self.REQUIRED_CONFIG_KEYS]), (
+            "Required key missing,"
+            " see index of `False` with `REQUIRED_CONFIG_KEYS`"
+        )
+
+    def test_invalid_mode(self):
+        with pytest.raises(AttributeError):
+            np.show_config(mode="foo")
+
+    def test_warn_to_add_tests(self):
+        assert len(np.__config__.DisplayModes) == 2, (
+            "New mode detected,"
+            " please add UT if applicable and increment this count"
+        )
diff --git a/venv/lib/python3.12/site-packages/numpy/tests/test_numpy_version.py b/venv/lib/python3.12/site-packages/numpy/tests/test_numpy_version.py
new file mode 100644
index 00000000..d3abcb92
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/tests/test_numpy_version.py
@@ -0,0 +1,54 @@
+"""
+Check the numpy version is valid.
+
+Note that a development version is marked by the presence of 'dev0' or '+'
+in the version string, all else is treated as a release. The version string
+itself is set from the output of ``git describe`` which relies on tags.
+
+Examples
+--------
+
+Valid Development: 1.22.0.dev0 1.22.0.dev0+5-g7999db4df2 1.22.0+5-g7999db4df2
+Valid Release: 1.21.0.rc1, 1.21.0.b1, 1.21.0
+Invalid: 1.22.0.dev, 1.22.0.dev0-5-g7999db4dfB, 1.21.0.d1, 1.21.a
+
+Note that a release is determined by the version string, which in turn
+is controlled by the result of the ``git describe`` command.
+"""
+import re
+
+import numpy as np
+from numpy.testing import assert_
+
+
+def test_valid_numpy_version():
+    # Verify that the numpy version is a valid one (no .post suffix or other
+    # nonsense).  See gh-6431 for an issue caused by an invalid version.
+    version_pattern = r"^[0-9]+\.[0-9]+\.[0-9]+(a[0-9]|b[0-9]|rc[0-9])?"
+    dev_suffix = r"(\.dev[0-9]+(\+git[0-9]+\.[0-9a-f]+)?)?"
+    res = re.match(version_pattern + dev_suffix + '$', np.__version__)
+
+    assert_(res is not None, np.__version__)
+
+
+def test_short_version():
+    # Check numpy.short_version actually exists
+    if np.version.release:
+        assert_(np.__version__ == np.version.short_version,
+                "short_version mismatch in release version")
+    else:
+        assert_(np.__version__.split("+")[0] == np.version.short_version,
+                "short_version mismatch in development version")
+
+
+def test_version_module():
+    contents = set([s for s in dir(np.version) if not s.startswith('_')])
+    expected = set([
+        'full_version',
+        'git_revision',
+        'release',
+        'short_version',
+        'version',
+    ])
+
+    assert contents == expected
diff --git a/venv/lib/python3.12/site-packages/numpy/tests/test_public_api.py b/venv/lib/python3.12/site-packages/numpy/tests/test_public_api.py
new file mode 100644
index 00000000..eb96560b
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/tests/test_public_api.py
@@ -0,0 +1,682 @@
+import sys
+import sysconfig
+import subprocess
+import pkgutil
+import types
+import importlib
+import inspect
+import warnings
+
+import numpy as np
+import numpy
+from numpy.testing import IS_WASM
+
+import pytest
+
+try:
+    import ctypes
+except ImportError:
+    ctypes = None
+
+
+def check_dir(module, module_name=None):
+    """Returns a mapping of all objects with the wrong __module__ attribute."""
+    if module_name is None:
+        module_name = module.__name__
+    results = {}
+    for name in dir(module):
+        if name == "core":
+            continue
+        item = getattr(module, name)
+        if (hasattr(item, '__module__') and hasattr(item, '__name__')
+                and item.__module__ != module_name):
+            results[name] = item.__module__ + '.' + item.__name__
+    return results
+
+
+def test_numpy_namespace():
+    # We override dir to not show these members
+    allowlist = {
+        'recarray': 'numpy.rec.recarray',
+        'show_config': 'numpy.__config__.show',
+    }
+    bad_results = check_dir(np)
+    # pytest gives better error messages with the builtin assert than with
+    # assert_equal
+    assert bad_results == allowlist
+
+
+@pytest.mark.skipif(IS_WASM, reason="can't start subprocess")
+@pytest.mark.parametrize('name', ['testing'])
+def test_import_lazy_import(name):
+    """Make sure we can actually use the modules we lazy load.
+
+    While not exported as part of the public API, it was accessible.  With the
+    use of __getattr__ and __dir__, this isn't always true It can happen that
+    an infinite recursion may happen.
+
+    This is the only way I found that would force the failure to appear on the
+    badly implemented code.
+
+    We also test for the presence of the lazily imported modules in dir
+
+    """
+    exe = (sys.executable, '-c', "import numpy; numpy." + name)
+    result = subprocess.check_output(exe)
+    assert not result
+
+    # Make sure they are still in the __dir__
+    assert name in dir(np)
+
+
+def test_dir_testing():
+    """Assert that output of dir has only one "testing/tester"
+    attribute without duplicate"""
+    assert len(dir(np)) == len(set(dir(np)))
+
+
+def test_numpy_linalg():
+    bad_results = check_dir(np.linalg)
+    assert bad_results == {}
+
+
+def test_numpy_fft():
+    bad_results = check_dir(np.fft)
+    assert bad_results == {}
+
+
+@pytest.mark.skipif(ctypes is None,
+                    reason="ctypes not available in this python")
+def test_NPY_NO_EXPORT():
+    cdll = ctypes.CDLL(np._core._multiarray_tests.__file__)
+    # Make sure an arbitrary NPY_NO_EXPORT function is actually hidden
+    f = getattr(cdll, 'test_not_exported', None)
+    assert f is None, ("'test_not_exported' is mistakenly exported, "
+                      "NPY_NO_EXPORT does not work")
+
+
+# Historically NumPy has not used leading underscores for private submodules
+# much.  This has resulted in lots of things that look like public modules
+# (i.e. things that can be imported as `import numpy.somesubmodule.somefile`),
+# but were never intended to be public.  The PUBLIC_MODULES list contains
+# modules that are either public because they were meant to be, or because they
+# contain public functions/objects that aren't present in any other namespace
+# for whatever reason and therefore should be treated as public.
+#
+# The PRIVATE_BUT_PRESENT_MODULES list contains modules that look public (lack
+# of underscores) but should not be used.  For many of those modules the
+# current status is fine.  For others it may make sense to work on making them
+# private, to clean up our public API and avoid confusion.
+PUBLIC_MODULES = ['numpy.' + s for s in [
+    "ctypeslib",
+    "dtypes",
+    "exceptions",
+    "f2py",
+    "fft",
+    "lib",
+    "lib.array_utils",
+    "lib.format",
+    "lib.introspect",
+    "lib.mixins",
+    "lib.npyio",
+    "lib.recfunctions",  # note: still needs cleaning, was forgotten for 2.0
+    "lib.scimath",
+    "lib.stride_tricks",
+    "linalg",
+    "ma",
+    "ma.extras",
+    "ma.mrecords",
+    "polynomial",
+    "polynomial.chebyshev",
+    "polynomial.hermite",
+    "polynomial.hermite_e",
+    "polynomial.laguerre",
+    "polynomial.legendre",
+    "polynomial.polynomial",
+    "random",
+    "strings",
+    "testing",
+    "testing.overrides",
+    "typing",
+    "typing.mypy_plugin",
+    "version",
+]]
+if sys.version_info < (3, 12):
+    PUBLIC_MODULES += [
+        'numpy.' + s for s in [
+            "distutils",
+            "distutils.cpuinfo",
+            "distutils.exec_command",
+            "distutils.misc_util",
+            "distutils.log",
+            "distutils.system_info",
+        ]
+    ]
+
+
+
+PUBLIC_ALIASED_MODULES = [
+    "numpy.char",
+    "numpy.emath",
+    "numpy.rec",
+]
+
+
+PRIVATE_BUT_PRESENT_MODULES = ['numpy.' + s for s in [
+    "compat",
+    "compat.py3k",
+    "conftest",
+    "core",
+    "core.multiarray",
+    "core.numeric",
+    "core.umath",
+    "core.arrayprint",
+    "core.defchararray",
+    "core.einsumfunc",
+    "core.fromnumeric",
+    "core.function_base",
+    "core.getlimits",
+    "core.numerictypes",
+    "core.overrides",
+    "core.records",
+    "core.shape_base",
+    "f2py.auxfuncs",
+    "f2py.capi_maps",
+    "f2py.cb_rules",
+    "f2py.cfuncs",
+    "f2py.common_rules",
+    "f2py.crackfortran",
+    "f2py.diagnose",
+    "f2py.f2py2e",
+    "f2py.f90mod_rules",
+    "f2py.func2subr",
+    "f2py.rules",
+    "f2py.symbolic",
+    "f2py.use_rules",
+    "fft.helper",
+    "lib.user_array",  # note: not in np.lib, but probably should just be deleted
+    "linalg.lapack_lite",
+    "linalg.linalg",
+    "ma.core",
+    "ma.testutils",
+    "ma.timer_comparison",
+    "matlib",
+    "matrixlib",
+    "matrixlib.defmatrix",
+    "polynomial.polyutils",
+    "random.mtrand",
+    "random.bit_generator",
+    "testing.print_coercion_tables",
+]]
+if sys.version_info < (3, 12):
+    PRIVATE_BUT_PRESENT_MODULES += [
+        'numpy.' + s for s in [
+            "distutils.armccompiler",
+            "distutils.fujitsuccompiler",
+            "distutils.ccompiler",
+            'distutils.ccompiler_opt',
+            "distutils.command",
+            "distutils.command.autodist",
+            "distutils.command.bdist_rpm",
+            "distutils.command.build",
+            "distutils.command.build_clib",
+            "distutils.command.build_ext",
+            "distutils.command.build_py",
+            "distutils.command.build_scripts",
+            "distutils.command.build_src",
+            "distutils.command.config",
+            "distutils.command.config_compiler",
+            "distutils.command.develop",
+            "distutils.command.egg_info",
+            "distutils.command.install",
+            "distutils.command.install_clib",
+            "distutils.command.install_data",
+            "distutils.command.install_headers",
+            "distutils.command.sdist",
+            "distutils.conv_template",
+            "distutils.core",
+            "distutils.extension",
+            "distutils.fcompiler",
+            "distutils.fcompiler.absoft",
+            "distutils.fcompiler.arm",
+            "distutils.fcompiler.compaq",
+            "distutils.fcompiler.environment",
+            "distutils.fcompiler.g95",
+            "distutils.fcompiler.gnu",
+            "distutils.fcompiler.hpux",
+            "distutils.fcompiler.ibm",
+            "distutils.fcompiler.intel",
+            "distutils.fcompiler.lahey",
+            "distutils.fcompiler.mips",
+            "distutils.fcompiler.nag",
+            "distutils.fcompiler.none",
+            "distutils.fcompiler.pathf95",
+            "distutils.fcompiler.pg",
+            "distutils.fcompiler.nv",
+            "distutils.fcompiler.sun",
+            "distutils.fcompiler.vast",
+            "distutils.fcompiler.fujitsu",
+            "distutils.from_template",
+            "distutils.intelccompiler",
+            "distutils.lib2def",
+            "distutils.line_endings",
+            "distutils.mingw32ccompiler",
+            "distutils.msvccompiler",
+            "distutils.npy_pkg_config",
+            "distutils.numpy_distribution",
+            "distutils.pathccompiler",
+            "distutils.unixccompiler",
+        ]
+    ]
+
+
+def is_unexpected(name):
+    """Check if this needs to be considered."""
+    if '._' in name or '.tests' in name or '.setup' in name:
+        return False
+
+    if name in PUBLIC_MODULES:
+        return False
+
+    if name in PUBLIC_ALIASED_MODULES:
+        return False
+
+    if name in PRIVATE_BUT_PRESENT_MODULES:
+        return False
+
+    return True
+
+
+if sys.version_info < (3, 12):
+    SKIP_LIST = ["numpy.distutils.msvc9compiler"]
+else:
+    SKIP_LIST = []
+
+
+# suppressing warnings from deprecated modules
+@pytest.mark.filterwarnings("ignore:.*np.compat.*:DeprecationWarning")
+def test_all_modules_are_expected():
+    """
+    Test that we don't add anything that looks like a new public module by
+    accident.  Check is based on filenames.
+    """
+
+    modnames = []
+    for _, modname, ispkg in pkgutil.walk_packages(path=np.__path__,
+                                                   prefix=np.__name__ + '.',
+                                                   onerror=None):
+        if is_unexpected(modname) and modname not in SKIP_LIST:
+            # We have a name that is new.  If that's on purpose, add it to
+            # PUBLIC_MODULES.  We don't expect to have to add anything to
+            # PRIVATE_BUT_PRESENT_MODULES.  Use an underscore in the name!
+            modnames.append(modname)
+
+    if modnames:
+        raise AssertionError(f'Found unexpected modules: {modnames}')
+
+
+# Stuff that clearly shouldn't be in the API and is detected by the next test
+# below
+SKIP_LIST_2 = [
+    'numpy.lib.math',
+    'numpy.matlib.char',
+    'numpy.matlib.rec',
+    'numpy.matlib.emath',
+    'numpy.matlib.exceptions',
+    'numpy.matlib.math',
+    'numpy.matlib.linalg',
+    'numpy.matlib.fft',
+    'numpy.matlib.random',
+    'numpy.matlib.ctypeslib',
+    'numpy.matlib.ma',
+]
+if sys.version_info < (3, 12):
+    SKIP_LIST_2 += [
+        'numpy.distutils.log.sys',
+        'numpy.distutils.log.logging',
+        'numpy.distutils.log.warnings',
+    ]
+
+
+def test_all_modules_are_expected_2():
+    """
+    Method checking all objects. The pkgutil-based method in
+    `test_all_modules_are_expected` does not catch imports into a namespace,
+    only filenames.  So this test is more thorough, and checks this like:
+
+        import .lib.scimath as emath
+
+    To check if something in a module is (effectively) public, one can check if
+    there's anything in that namespace that's a public function/object but is
+    not exposed in a higher-level namespace.  For example for a `numpy.lib`
+    submodule::
+
+        mod = np.lib.mixins
+        for obj in mod.__all__:
+            if obj in np.__all__:
+                continue
+            elif obj in np.lib.__all__:
+                continue
+
+            else:
+                print(obj)
+
+    """
+
+    def find_unexpected_members(mod_name):
+        members = []
+        module = importlib.import_module(mod_name)
+        if hasattr(module, '__all__'):
+            objnames = module.__all__
+        else:
+            objnames = dir(module)
+
+        for objname in objnames:
+            if not objname.startswith('_'):
+                fullobjname = mod_name + '.' + objname
+                if isinstance(getattr(module, objname), types.ModuleType):
+                    if is_unexpected(fullobjname):
+                        if fullobjname not in SKIP_LIST_2:
+                            members.append(fullobjname)
+
+        return members
+
+    unexpected_members = find_unexpected_members("numpy")
+    for modname in PUBLIC_MODULES:
+        unexpected_members.extend(find_unexpected_members(modname))
+
+    if unexpected_members:
+        raise AssertionError("Found unexpected object(s) that look like "
+                             "modules: {}".format(unexpected_members))
+
+
+def test_api_importable():
+    """
+    Check that all submodules listed higher up in this file can be imported
+
+    Note that if a PRIVATE_BUT_PRESENT_MODULES entry goes missing, it may
+    simply need to be removed from the list (deprecation may or may not be
+    needed - apply common sense).
+    """
+    def check_importable(module_name):
+        try:
+            importlib.import_module(module_name)
+        except (ImportError, AttributeError):
+            return False
+
+        return True
+
+    module_names = []
+    for module_name in PUBLIC_MODULES:
+        if not check_importable(module_name):
+            module_names.append(module_name)
+
+    if module_names:
+        raise AssertionError("Modules in the public API that cannot be "
+                             "imported: {}".format(module_names))
+
+    for module_name in PUBLIC_ALIASED_MODULES:
+        try:
+            eval(module_name)
+        except AttributeError:
+            module_names.append(module_name)
+
+    if module_names:
+        raise AssertionError("Modules in the public API that were not "
+                             "found: {}".format(module_names))
+
+    with warnings.catch_warnings(record=True) as w:
+        warnings.filterwarnings('always', category=DeprecationWarning)
+        warnings.filterwarnings('always', category=ImportWarning)
+        for module_name in PRIVATE_BUT_PRESENT_MODULES:
+            if not check_importable(module_name):
+                module_names.append(module_name)
+
+    if module_names:
+        raise AssertionError("Modules that are not really public but looked "
+                             "public and can not be imported: "
+                             "{}".format(module_names))
+
+
+@pytest.mark.xfail(
+    sysconfig.get_config_var("Py_DEBUG") not in (None, 0, "0"),
+    reason=(
+        "NumPy possibly built with `USE_DEBUG=True ./tools/travis-test.sh`, "
+        "which does not expose the `array_api` entry point. "
+        "See https://github.com/numpy/numpy/pull/19800"
+    ),
+)
+def test_array_api_entry_point():
+    """
+    Entry point for Array API implementation can be found with importlib and
+    returns the main numpy namespace.
+    """
+    # For a development install that did not go through meson-python,
+    # the entrypoint will not have been installed. So ensure this test fails
+    # only if numpy is inside site-packages.
+    numpy_in_sitepackages = sysconfig.get_path('platlib') in np.__file__
+
+    eps = importlib.metadata.entry_points()
+    try:
+        xp_eps = eps.select(group="array_api")
+    except AttributeError:
+        # The select interface for entry_points was introduced in py3.10,
+        # deprecating its dict interface. We fallback to dict keys for finding
+        # Array API entry points so that running this test in <=3.9 will
+        # still work - see https://github.com/numpy/numpy/pull/19800.
+        xp_eps = eps.get("array_api", [])
+    if len(xp_eps) == 0:
+        if numpy_in_sitepackages:
+            msg = "No entry points for 'array_api' found"
+            raise AssertionError(msg) from None
+        return
+
+    try:
+        ep = next(ep for ep in xp_eps if ep.name == "numpy")
+    except StopIteration:
+        if numpy_in_sitepackages:
+            msg = "'numpy' not in array_api entry points"
+            raise AssertionError(msg) from None
+        return
+
+    if ep.value == 'numpy.array_api':
+        # Looks like the entrypoint for the current numpy build isn't
+        # installed, but an older numpy is also installed and hence the
+        # entrypoint is pointing to the old (no longer existing) location.
+        # This isn't a problem except for when running tests with `spin` or an
+        # in-place build.
+        return
+
+    xp = ep.load()
+    msg = (
+        f"numpy entry point value '{ep.value}' "
+        "does not point to our Array API implementation"
+    )
+    assert xp is numpy, msg
+
+
+def test_main_namespace_all_dir_coherence():
+    """
+    Checks if `dir(np)` and `np.__all__` are consistent and return
+    the same content, excluding exceptions and private members.
+    """
+    def _remove_private_members(member_set):
+        return {m for m in member_set if not m.startswith('_')}
+
+    def _remove_exceptions(member_set):
+        return member_set.difference({
+            "bool"  # included only in __dir__
+        })
+
+    all_members = _remove_private_members(np.__all__)
+    all_members = _remove_exceptions(all_members)
+
+    dir_members = _remove_private_members(np.__dir__())
+    dir_members = _remove_exceptions(dir_members)
+
+    assert all_members == dir_members, (
+        "Members that break symmetry: "
+        f"{all_members.symmetric_difference(dir_members)}"
+    )
+
+
+@pytest.mark.filterwarnings(
+    r"ignore:numpy.core(\.\w+)? is deprecated:DeprecationWarning"
+)
+def test_core_shims_coherence():
+    """
+    Check that all "semi-public" members of `numpy._core` are also accessible
+    from `numpy.core` shims.
+    """
+    import numpy.core as core
+
+    for member_name in dir(np._core):
+        # Skip private and test members. Also if a module is aliased,
+        # no need to add it to np.core
+        if (
+            member_name.startswith("_")
+            or member_name in ["tests", "strings"]
+            or f"numpy.{member_name}" in PUBLIC_ALIASED_MODULES 
+        ):
+            continue
+
+        member = getattr(np._core, member_name)
+
+        # np.core is a shim and all submodules of np.core are shims
+        # but we should be able to import everything in those shims
+        # that are available in the "real" modules in np._core
+        if inspect.ismodule(member):
+            submodule = member
+            submodule_name = member_name
+            for submodule_member_name in dir(submodule):
+                # ignore dunder names
+                if submodule_member_name.startswith("__"):
+                    continue
+                submodule_member = getattr(submodule, submodule_member_name)
+
+                core_submodule = __import__(
+                    f"numpy.core.{submodule_name}",
+                    fromlist=[submodule_member_name]
+                )
+
+                assert submodule_member is getattr(
+                    core_submodule, submodule_member_name
+                )
+
+        else:
+            assert member is getattr(core, member_name)
+
+
+def test_functions_single_location():
+    """
+    Check that each public function is available from one location only.
+
+    Test performs BFS search traversing NumPy's public API. It flags
+    any function-like object that is accessible from more that one place.
+    """
+    from typing import Any, Callable, Dict, List, Set, Tuple
+    from numpy._core._multiarray_umath import (
+        _ArrayFunctionDispatcher as dispatched_function
+    )
+
+    visited_modules: Set[types.ModuleType] = {np}
+    visited_functions: Set[Callable[..., Any]] = set()
+    # Functions often have `__name__` overridden, therefore we need
+    # to keep track of locations where functions have been found.
+    functions_original_paths: Dict[Callable[..., Any], str] = dict()
+
+    # Here we aggregate functions with more than one location.
+    # It must be empty for the test to pass.
+    duplicated_functions: List[Tuple] = []
+
+    modules_queue = [np]
+
+    while len(modules_queue) > 0:
+
+        module = modules_queue.pop()
+
+        for member_name in dir(module):
+            member = getattr(module, member_name)
+
+            # first check if we got a module
+            if (
+                inspect.ismodule(member) and  # it's a module
+                "numpy" in member.__name__ and  # inside NumPy
+                not member_name.startswith("_") and  # not private
+                "numpy._core" not in member.__name__ and  # outside _core
+                # not a legacy or testing module
+                member_name not in ["f2py", "ma", "testing", "tests"] and
+                member not in visited_modules  # not visited yet
+            ):
+                modules_queue.append(member)
+                visited_modules.add(member)
+
+            # else check if we got a function-like object
+            elif (
+                inspect.isfunction(member) or
+                isinstance(member, (dispatched_function, np.ufunc))
+            ):
+                if member in visited_functions:
+
+                    # skip main namespace functions with aliases
+                    if (
+                        member.__name__ in [
+                            "absolute",  # np.abs
+                            "arccos",  # np.acos
+                            "arccosh",  # np.acosh
+                            "arcsin",  # np.asin
+                            "arcsinh",  # np.asinh
+                            "arctan",  # np.atan
+                            "arctan2",  # np.atan2
+                            "arctanh",  # np.atanh
+                            "left_shift",  # np.bitwise_left_shift
+                            "right_shift",  # np.bitwise_right_shift
+                            "conjugate",  # np.conj
+                            "invert",  # np.bitwise_not & np.bitwise_invert
+                            "remainder",  # np.mod
+                            "divide",  # np.true_divide
+                            "concatenate",  # np.concat
+                            "power",  # np.pow
+                            "transpose",  # np.permute_dims
+                        ] and
+                        module.__name__ == "numpy"
+                    ):
+                        continue
+                    # skip trimcoef from numpy.polynomial as it is
+                    # duplicated by design.
+                    if (
+                        member.__name__ == "trimcoef" and
+                        module.__name__.startswith("numpy.polynomial")
+                    ):
+                        continue
+
+                    # skip ufuncs that are exported in np.strings as well
+                    if member.__name__ in (
+                        "add",
+                        "equal",
+                        "not_equal",
+                        "greater",
+                        "greater_equal",
+                        "less",
+                        "less_equal",
+                    ) and module.__name__ == "numpy.strings":
+                        continue
+
+                    # numpy.char reexports all numpy.strings functions for
+                    # backwards-compatibility
+                    if module.__name__ == "numpy.char":
+                        continue
+
+                    # function is present in more than one location!
+                    duplicated_functions.append(
+                        (member.__name__,
+                         module.__name__,
+                         functions_original_paths[member])
+                    )
+                else:
+                    visited_functions.add(member)
+                    functions_original_paths[member] = module.__name__
+
+    del visited_functions, visited_modules, functions_original_paths
+
+    assert len(duplicated_functions) == 0, duplicated_functions
diff --git a/venv/lib/python3.12/site-packages/numpy/tests/test_reloading.py b/venv/lib/python3.12/site-packages/numpy/tests/test_reloading.py
new file mode 100644
index 00000000..22bff721
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/tests/test_reloading.py
@@ -0,0 +1,74 @@
+import sys
+import subprocess
+import textwrap
+from importlib import reload
+import pickle
+
+import pytest
+
+import numpy.exceptions as ex
+from numpy.testing import (
+    assert_raises,
+    assert_warns,
+    assert_,
+    assert_equal,
+    IS_WASM,
+)
+
+
+def test_numpy_reloading():
+    # gh-7844. Also check that relevant globals retain their identity.
+    import numpy as np
+    import numpy._globals
+
+    _NoValue = np._NoValue
+    VisibleDeprecationWarning = ex.VisibleDeprecationWarning
+    ModuleDeprecationWarning = ex.ModuleDeprecationWarning
+
+    with assert_warns(UserWarning):
+        reload(np)
+    assert_(_NoValue is np._NoValue)
+    assert_(ModuleDeprecationWarning is ex.ModuleDeprecationWarning)
+    assert_(VisibleDeprecationWarning is ex.VisibleDeprecationWarning)
+
+    assert_raises(RuntimeError, reload, numpy._globals)
+    with assert_warns(UserWarning):
+        reload(np)
+    assert_(_NoValue is np._NoValue)
+    assert_(ModuleDeprecationWarning is ex.ModuleDeprecationWarning)
+    assert_(VisibleDeprecationWarning is ex.VisibleDeprecationWarning)
+
+def test_novalue():
+    import numpy as np
+    for proto in range(2, pickle.HIGHEST_PROTOCOL + 1):
+        assert_equal(repr(np._NoValue), '')
+        assert_(pickle.loads(pickle.dumps(np._NoValue,
+                                          protocol=proto)) is np._NoValue)
+
+
+@pytest.mark.skipif(IS_WASM, reason="can't start subprocess")
+def test_full_reimport():
+    """At the time of writing this, it is *not* truly supported, but
+    apparently enough users rely on it, for it to be an annoying change
+    when it started failing previously.
+    """
+    # Test within a new process, to ensure that we do not mess with the
+    # global state during the test run (could lead to cryptic test failures).
+    # This is generally unsafe, especially, since we also reload the C-modules.
+    code = textwrap.dedent(r"""
+        import sys
+        from pytest import warns
+        import numpy as np
+
+        for k in list(sys.modules.keys()):
+            if "numpy" in k:
+                del sys.modules[k]
+
+        with warns(UserWarning):
+            import numpy as np
+        """)
+    p = subprocess.run([sys.executable, '-c', code], capture_output=True)
+    if p.returncode:
+        raise AssertionError(
+            f"Non-zero return code: {p.returncode!r}\n\n{p.stderr.decode()}"
+        )
diff --git a/venv/lib/python3.12/site-packages/numpy/tests/test_scripts.py b/venv/lib/python3.12/site-packages/numpy/tests/test_scripts.py
new file mode 100644
index 00000000..892c04ee
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/tests/test_scripts.py
@@ -0,0 +1,47 @@
+""" Test scripts
+
+Test that we can run executable scripts that have been installed with numpy.
+"""
+import sys
+import os
+import pytest
+from os.path import join as pathjoin, isfile, dirname
+import subprocess
+
+import numpy as np
+from numpy.testing import assert_equal, IS_WASM
+
+is_inplace = isfile(pathjoin(dirname(np.__file__),  '..', 'setup.py'))
+
+
+def find_f2py_commands():
+    if sys.platform == 'win32':
+        exe_dir = dirname(sys.executable)
+        if exe_dir.endswith('Scripts'): # virtualenv
+            return [os.path.join(exe_dir, 'f2py')]
+        else:
+            return [os.path.join(exe_dir, "Scripts", 'f2py')]
+    else:
+        # Three scripts are installed in Unix-like systems:
+        # 'f2py', 'f2py{major}', and 'f2py{major.minor}'. For example,
+        # if installed with python3.9 the scripts would be named
+        # 'f2py', 'f2py3', and 'f2py3.9'.
+        version = sys.version_info
+        major = str(version.major)
+        minor = str(version.minor)
+        return ['f2py', 'f2py' + major, 'f2py' + major + '.' + minor]
+
+
+@pytest.mark.skipif(is_inplace, reason="Cannot test f2py command inplace")
+@pytest.mark.xfail(reason="Test is unreliable")
+@pytest.mark.parametrize('f2py_cmd', find_f2py_commands())
+def test_f2py(f2py_cmd):
+    # test that we can run f2py script
+    stdout = subprocess.check_output([f2py_cmd, '-v'])
+    assert_equal(stdout.strip(), np.__version__.encode('ascii'))
+
+
+@pytest.mark.skipif(IS_WASM, reason="Cannot start subprocess")
+def test_pep338():
+    stdout = subprocess.check_output([sys.executable, '-mnumpy.f2py', '-v'])
+    assert_equal(stdout.strip(), np.__version__.encode('ascii'))
diff --git a/venv/lib/python3.12/site-packages/numpy/tests/test_warnings.py b/venv/lib/python3.12/site-packages/numpy/tests/test_warnings.py
new file mode 100644
index 00000000..9304c134
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/tests/test_warnings.py
@@ -0,0 +1,76 @@
+"""
+Tests which scan for certain occurrences in the code, they may not find
+all of these occurrences but should catch almost all.
+"""
+import pytest
+
+from pathlib import Path
+import ast
+import tokenize
+import numpy
+
+class ParseCall(ast.NodeVisitor):
+    def __init__(self):
+        self.ls = []
+
+    def visit_Attribute(self, node):
+        ast.NodeVisitor.generic_visit(self, node)
+        self.ls.append(node.attr)
+
+    def visit_Name(self, node):
+        self.ls.append(node.id)
+
+
+class FindFuncs(ast.NodeVisitor):
+    def __init__(self, filename):
+        super().__init__()
+        self.__filename = filename
+
+    def visit_Call(self, node):
+        p = ParseCall()
+        p.visit(node.func)
+        ast.NodeVisitor.generic_visit(self, node)
+
+        if p.ls[-1] == 'simplefilter' or p.ls[-1] == 'filterwarnings':
+            if node.args[0].value == "ignore":
+                raise AssertionError(
+                    "warnings should have an appropriate stacklevel; found in "
+                    "{} on line {}".format(self.__filename, node.lineno))
+
+        if p.ls[-1] == 'warn' and (
+                len(p.ls) == 1 or p.ls[-2] == 'warnings'):
+
+            if "testing/tests/test_warnings.py" == self.__filename:
+                # This file
+                return
+
+            # See if stacklevel exists:
+            if len(node.args) == 3:
+                return
+            args = {kw.arg for kw in node.keywords}
+            if "stacklevel" in args:
+                return
+            raise AssertionError(
+                "warnings should have an appropriate stacklevel; found in "
+                "{} on line {}".format(self.__filename, node.lineno))
+
+
+@pytest.mark.slow
+def test_warning_calls():
+    # combined "ignore" and stacklevel error
+    base = Path(numpy.__file__).parent
+
+    for path in base.rglob("*.py"):
+        if base / "testing" in path.parents:
+            continue
+        if path == base / "__init__.py":
+            continue
+        if path == base / "random" / "__init__.py":
+            continue
+        if path == base / "conftest.py":
+            continue
+        # use tokenize to auto-detect encoding on systems where no
+        # default encoding is defined (e.g. LANG='C')
+        with tokenize.open(str(path)) as file:
+            tree = ast.parse(file.read())
+            FindFuncs(path).visit(tree)
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/__init__.py b/venv/lib/python3.12/site-packages/numpy/typing/__init__.py
new file mode 100644
index 00000000..b2479218
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/__init__.py
@@ -0,0 +1,175 @@
+"""
+============================
+Typing (:mod:`numpy.typing`)
+============================
+
+.. versionadded:: 1.20
+
+Large parts of the NumPy API have :pep:`484`-style type annotations. In
+addition a number of type aliases are available to users, most prominently
+the two below:
+
+- `ArrayLike`: objects that can be converted to arrays
+- `DTypeLike`: objects that can be converted to dtypes
+
+.. _typing-extensions: https://pypi.org/project/typing-extensions/
+
+Mypy plugin
+-----------
+
+.. versionadded:: 1.21
+
+.. automodule:: numpy.typing.mypy_plugin
+
+.. currentmodule:: numpy.typing
+
+Differences from the runtime NumPy API
+--------------------------------------
+
+NumPy is very flexible. Trying to describe the full range of
+possibilities statically would result in types that are not very
+helpful. For that reason, the typed NumPy API is often stricter than
+the runtime NumPy API. This section describes some notable
+differences.
+
+ArrayLike
+~~~~~~~~~
+
+The `ArrayLike` type tries to avoid creating object arrays. For
+example,
+
+.. code-block:: python
+
+    >>> np.array(x**2 for x in range(10))
+    array( at ...>, dtype=object)
+
+is valid NumPy code which will create a 0-dimensional object
+array. Type checkers will complain about the above example when using
+the NumPy types however. If you really intended to do the above, then
+you can either use a ``# type: ignore`` comment:
+
+.. code-block:: python
+
+    >>> np.array(x**2 for x in range(10))  # type: ignore
+
+or explicitly type the array like object as `~typing.Any`:
+
+.. code-block:: python
+
+    >>> from typing import Any
+    >>> array_like: Any = (x**2 for x in range(10))
+    >>> np.array(array_like)
+    array( at ...>, dtype=object)
+
+ndarray
+~~~~~~~
+
+It's possible to mutate the dtype of an array at runtime. For example,
+the following code is valid:
+
+.. code-block:: python
+
+    >>> x = np.array([1, 2])
+    >>> x.dtype = np.bool
+
+This sort of mutation is not allowed by the types. Users who want to
+write statically typed code should instead use the `numpy.ndarray.view`
+method to create a view of the array with a different dtype.
+
+DTypeLike
+~~~~~~~~~
+
+The `DTypeLike` type tries to avoid creation of dtype objects using
+dictionary of fields like below:
+
+.. code-block:: python
+
+    >>> x = np.dtype({"field1": (float, 1), "field2": (int, 3)})
+
+Although this is valid NumPy code, the type checker will complain about it,
+since its usage is discouraged.
+Please see : :ref:`Data type objects `
+
+Number precision
+~~~~~~~~~~~~~~~~
+
+The precision of `numpy.number` subclasses is treated as a invariant generic
+parameter (see :class:`~NBitBase`), simplifying the annotating of processes
+involving precision-based casting.
+
+.. code-block:: python
+
+    >>> from typing import TypeVar
+    >>> import numpy as np
+    >>> import numpy.typing as npt
+
+    >>> T = TypeVar("T", bound=npt.NBitBase)
+    >>> def func(a: "np.floating[T]", b: "np.floating[T]") -> "np.floating[T]":
+    ...     ...
+
+Consequently, the likes of `~numpy.float16`, `~numpy.float32` and
+`~numpy.float64` are still sub-types of `~numpy.floating`, but, contrary to
+runtime, they're not necessarily considered as sub-classes.
+
+Timedelta64
+~~~~~~~~~~~
+
+The `~numpy.timedelta64` class is not considered a subclass of
+`~numpy.signedinteger`, the former only inheriting from `~numpy.generic`
+while static type checking.
+
+0D arrays
+~~~~~~~~~
+
+During runtime numpy aggressively casts any passed 0D arrays into their
+corresponding `~numpy.generic` instance. Until the introduction of shape
+typing (see :pep:`646`) it is unfortunately not possible to make the
+necessary distinction between 0D and >0D arrays. While thus not strictly
+correct, all operations are that can potentially perform a 0D-array -> scalar
+cast are currently annotated as exclusively returning an `~numpy.ndarray`.
+
+If it is known in advance that an operation *will* perform a
+0D-array -> scalar cast, then one can consider manually remedying the
+situation with either `typing.cast` or a ``# type: ignore`` comment.
+
+Record array dtypes
+~~~~~~~~~~~~~~~~~~~
+
+The dtype of `numpy.recarray`, and the :ref:`routines.array-creation.rec`
+functions in general, can be specified in one of two ways:
+
+* Directly via the ``dtype`` argument.
+* With up to five helper arguments that operate via `numpy.rec.format_parser`:
+  ``formats``, ``names``, ``titles``, ``aligned`` and ``byteorder``.
+
+These two approaches are currently typed as being mutually exclusive,
+*i.e.* if ``dtype`` is specified than one may not specify ``formats``.
+While this mutual exclusivity is not (strictly) enforced during runtime,
+combining both dtype specifiers can lead to unexpected or even downright
+buggy behavior.
+
+API
+---
+
+"""
+# NOTE: The API section will be appended with additional entries
+# further down in this file
+
+from numpy._typing import (
+    ArrayLike,
+    DTypeLike,
+    NBitBase,
+    NDArray,
+)
+
+__all__ = ["ArrayLike", "DTypeLike", "NBitBase", "NDArray"]
+
+if __doc__ is not None:
+    from numpy._typing._add_docstring import _docstrings
+    __doc__ += _docstrings
+    __doc__ += '\n.. autoclass:: numpy.typing.NBitBase\n'
+    del _docstrings
+
+from numpy._pytesttester import PytestTester
+test = PytestTester(__name__)
+del PytestTester
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/typing/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 00000000..31cd0e17
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/typing/__pycache__/__init__.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/__pycache__/mypy_plugin.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/typing/__pycache__/mypy_plugin.cpython-312.pyc
new file mode 100644
index 00000000..9e3c227c
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/typing/__pycache__/mypy_plugin.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/mypy_plugin.py b/venv/lib/python3.12/site-packages/numpy/typing/mypy_plugin.py
new file mode 100644
index 00000000..63f063cc
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/mypy_plugin.py
@@ -0,0 +1,197 @@
+"""A mypy_ plugin for managing a number of platform-specific annotations.
+Its functionality can be split into three distinct parts:
+
+* Assigning the (platform-dependent) precisions of certain `~numpy.number`
+  subclasses, including the likes of `~numpy.int_`, `~numpy.intp` and
+  `~numpy.longlong`. See the documentation on
+  :ref:`scalar types ` for a comprehensive overview
+  of the affected classes. Without the plugin the precision of all relevant
+  classes will be inferred as `~typing.Any`.
+* Removing all extended-precision `~numpy.number` subclasses that are
+  unavailable for the platform in question. Most notably this includes the
+  likes of `~numpy.float128` and `~numpy.complex256`. Without the plugin *all*
+  extended-precision types will, as far as mypy is concerned, be available
+  to all platforms.
+* Assigning the (platform-dependent) precision of `~numpy.ctypeslib.c_intp`.
+  Without the plugin the type will default to `ctypes.c_int64`.
+
+  .. versionadded:: 1.22
+
+Examples
+--------
+To enable the plugin, one must add it to their mypy `configuration file`_:
+
+.. code-block:: ini
+
+    [mypy]
+    plugins = numpy.typing.mypy_plugin
+
+.. _mypy: https://mypy-lang.org/
+.. _configuration file: https://mypy.readthedocs.io/en/stable/config_file.html
+
+"""
+
+from __future__ import annotations
+
+from collections.abc import Iterable
+from typing import Final, TYPE_CHECKING, Callable
+
+import numpy as np
+
+try:
+    import mypy.types
+    from mypy.types import Type
+    from mypy.plugin import Plugin, AnalyzeTypeContext
+    from mypy.nodes import MypyFile, ImportFrom, Statement
+    from mypy.build import PRI_MED
+
+    _HookFunc = Callable[[AnalyzeTypeContext], Type]
+    MYPY_EX: None | ModuleNotFoundError = None
+except ModuleNotFoundError as ex:
+    MYPY_EX = ex
+
+__all__: list[str] = []
+
+
+def _get_precision_dict() -> dict[str, str]:
+    names = [
+        ("_NBitByte", np.byte),
+        ("_NBitShort", np.short),
+        ("_NBitIntC", np.intc),
+        ("_NBitIntP", np.intp),
+        ("_NBitInt", np.int_),
+        ("_NBitLong", np.long),
+        ("_NBitLongLong", np.longlong),
+
+        ("_NBitHalf", np.half),
+        ("_NBitSingle", np.single),
+        ("_NBitDouble", np.double),
+        ("_NBitLongDouble", np.longdouble),
+    ]
+    ret = {}
+    for name, typ in names:
+        n: int = 8 * typ().dtype.itemsize
+        ret[f'numpy._typing._nbit.{name}'] = f"numpy._{n}Bit"
+    return ret
+
+
+def _get_extended_precision_list() -> list[str]:
+    extended_names = [
+        "uint128",
+        "uint256",
+        "int128",
+        "int256",
+        "float80",
+        "float96",
+        "float128",
+        "float256",
+        "complex160",
+        "complex192",
+        "complex256",
+        "complex512",
+    ]
+    return [i for i in extended_names if hasattr(np, i)]
+
+
+def _get_c_intp_name() -> str:
+    # Adapted from `np.core._internal._getintp_ctype`
+    char = np.dtype('n').char
+    if char == 'i':
+        return "c_int"
+    elif char == 'l':
+        return "c_long"
+    elif char == 'q':
+        return "c_longlong"
+    else:
+        return "c_long"
+
+
+#: A dictionary mapping type-aliases in `numpy._typing._nbit` to
+#: concrete `numpy.typing.NBitBase` subclasses.
+_PRECISION_DICT: Final = _get_precision_dict()
+
+#: A list with the names of all extended precision `np.number` subclasses.
+_EXTENDED_PRECISION_LIST: Final = _get_extended_precision_list()
+
+#: The name of the ctypes quivalent of `np.intp`
+_C_INTP: Final = _get_c_intp_name()
+
+
+def _hook(ctx: AnalyzeTypeContext) -> Type:
+    """Replace a type-alias with a concrete ``NBitBase`` subclass."""
+    typ, _, api = ctx
+    name = typ.name.split(".")[-1]
+    name_new = _PRECISION_DICT[f"numpy._typing._nbit.{name}"]
+    return api.named_type(name_new)
+
+
+if TYPE_CHECKING or MYPY_EX is None:
+    def _index(iterable: Iterable[Statement], id: str) -> int:
+        """Identify the first ``ImportFrom`` instance the specified `id`."""
+        for i, value in enumerate(iterable):
+            if getattr(value, "id", None) == id:
+                return i
+        raise ValueError("Failed to identify a `ImportFrom` instance "
+                         f"with the following id: {id!r}")
+
+    def _override_imports(
+        file: MypyFile,
+        module: str,
+        imports: list[tuple[str, None | str]],
+    ) -> None:
+        """Override the first `module`-based import with new `imports`."""
+        # Construct a new `from module import y` statement
+        import_obj = ImportFrom(module, 0, names=imports)
+        import_obj.is_top_level = True
+
+        # Replace the first `module`-based import statement with `import_obj`
+        for lst in [file.defs, file.imports]:  # type: list[Statement]
+            i = _index(lst, module)
+            lst[i] = import_obj
+
+    class _NumpyPlugin(Plugin):
+        """A mypy plugin for handling versus numpy-specific typing tasks."""
+
+        def get_type_analyze_hook(self, fullname: str) -> None | _HookFunc:
+            """Set the precision of platform-specific `numpy.number`
+            subclasses.
+
+            For example: `numpy.int_`, `numpy.longlong` and `numpy.longdouble`.
+            """
+            if fullname in _PRECISION_DICT:
+                return _hook
+            return None
+
+        def get_additional_deps(
+            self, file: MypyFile
+        ) -> list[tuple[int, str, int]]:
+            """Handle all import-based overrides.
+
+            * Import platform-specific extended-precision `numpy.number`
+              subclasses (*e.g.* `numpy.float96`, `numpy.float128` and
+              `numpy.complex256`).
+            * Import the appropriate `ctypes` equivalent to `numpy.intp`.
+
+            """
+            ret = [(PRI_MED, file.fullname, -1)]
+
+            if file.fullname == "numpy":
+                _override_imports(
+                    file, "numpy._typing._extended_precision",
+                    imports=[(v, v) for v in _EXTENDED_PRECISION_LIST],
+                )
+            elif file.fullname == "numpy.ctypeslib":
+                _override_imports(
+                    file, "ctypes",
+                    imports=[(_C_INTP, "_c_intp")],
+                )
+            return ret
+
+    def plugin(version: str) -> type[_NumpyPlugin]:
+        """An entry-point for mypy."""
+        return _NumpyPlugin
+
+else:
+    def plugin(version: str) -> type[_NumpyPlugin]:
+        """An entry-point for mypy."""
+        raise MYPY_EX
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/__init__.py b/venv/lib/python3.12/site-packages/numpy/typing/tests/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/typing/tests/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 00000000..8e6ecfb4
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/typing/tests/__pycache__/__init__.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/__pycache__/test_isfile.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/typing/tests/__pycache__/test_isfile.cpython-312.pyc
new file mode 100644
index 00000000..f4fba049
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/typing/tests/__pycache__/test_isfile.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/__pycache__/test_runtime.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/typing/tests/__pycache__/test_runtime.cpython-312.pyc
new file mode 100644
index 00000000..67efeeee
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/typing/tests/__pycache__/test_runtime.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/__pycache__/test_typing.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/typing/tests/__pycache__/test_typing.cpython-312.pyc
new file mode 100644
index 00000000..79f8ad6e
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/typing/tests/__pycache__/test_typing.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/arithmetic.pyi b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/arithmetic.pyi
new file mode 100644
index 00000000..d6ff59fc
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/arithmetic.pyi
@@ -0,0 +1,123 @@
+from typing import Any
+
+import numpy as np
+import numpy.typing as npt
+
+b_ = np.bool()
+dt = np.datetime64(0, "D")
+td = np.timedelta64(0, "D")
+
+AR_b: npt.NDArray[np.bool]
+AR_u: npt.NDArray[np.uint32]
+AR_i: npt.NDArray[np.int64]
+AR_f: npt.NDArray[np.float64]
+AR_c: npt.NDArray[np.complex128]
+AR_m: npt.NDArray[np.timedelta64]
+AR_M: npt.NDArray[np.datetime64]
+
+ANY: Any
+
+AR_LIKE_b: list[bool]
+AR_LIKE_u: list[np.uint32]
+AR_LIKE_i: list[int]
+AR_LIKE_f: list[float]
+AR_LIKE_c: list[complex]
+AR_LIKE_m: list[np.timedelta64]
+AR_LIKE_M: list[np.datetime64]
+
+# Array subtraction
+
+# NOTE: mypys `NoReturn` errors are, unfortunately, not that great
+_1 = AR_b - AR_LIKE_b  # E: Need type annotation
+_2 = AR_LIKE_b - AR_b  # E: Need type annotation
+AR_i - bytes()  # E: No overload variant
+
+AR_f - AR_LIKE_m  # E: Unsupported operand types
+AR_f - AR_LIKE_M  # E: Unsupported operand types
+AR_c - AR_LIKE_m  # E: Unsupported operand types
+AR_c - AR_LIKE_M  # E: Unsupported operand types
+
+AR_m - AR_LIKE_f  # E: Unsupported operand types
+AR_M - AR_LIKE_f  # E: Unsupported operand types
+AR_m - AR_LIKE_c  # E: Unsupported operand types
+AR_M - AR_LIKE_c  # E: Unsupported operand types
+
+AR_m - AR_LIKE_M  # E: Unsupported operand types
+AR_LIKE_m - AR_M  # E: Unsupported operand types
+
+# array floor division
+
+AR_M // AR_LIKE_b  # E: Unsupported operand types
+AR_M // AR_LIKE_u  # E: Unsupported operand types
+AR_M // AR_LIKE_i  # E: Unsupported operand types
+AR_M // AR_LIKE_f  # E: Unsupported operand types
+AR_M // AR_LIKE_c  # E: Unsupported operand types
+AR_M // AR_LIKE_m  # E: Unsupported operand types
+AR_M // AR_LIKE_M  # E: Unsupported operand types
+
+AR_b // AR_LIKE_M  # E: Unsupported operand types
+AR_u // AR_LIKE_M  # E: Unsupported operand types
+AR_i // AR_LIKE_M  # E: Unsupported operand types
+AR_f // AR_LIKE_M  # E: Unsupported operand types
+AR_c // AR_LIKE_M  # E: Unsupported operand types
+AR_m // AR_LIKE_M  # E: Unsupported operand types
+AR_M // AR_LIKE_M  # E: Unsupported operand types
+
+_3 = AR_m // AR_LIKE_b  # E: Need type annotation
+AR_m // AR_LIKE_c  # E: Unsupported operand types
+
+AR_b // AR_LIKE_m  # E: Unsupported operand types
+AR_u // AR_LIKE_m  # E: Unsupported operand types
+AR_i // AR_LIKE_m  # E: Unsupported operand types
+AR_f // AR_LIKE_m  # E: Unsupported operand types
+AR_c // AR_LIKE_m  # E: Unsupported operand types
+
+# Array multiplication
+
+AR_b *= AR_LIKE_u  # E: incompatible type
+AR_b *= AR_LIKE_i  # E: incompatible type
+AR_b *= AR_LIKE_f  # E: incompatible type
+AR_b *= AR_LIKE_c  # E: incompatible type
+AR_b *= AR_LIKE_m  # E: incompatible type
+
+AR_u *= AR_LIKE_i  # E: incompatible type
+AR_u *= AR_LIKE_f  # E: incompatible type
+AR_u *= AR_LIKE_c  # E: incompatible type
+AR_u *= AR_LIKE_m  # E: incompatible type
+
+AR_i *= AR_LIKE_f  # E: incompatible type
+AR_i *= AR_LIKE_c  # E: incompatible type
+AR_i *= AR_LIKE_m  # E: incompatible type
+
+AR_f *= AR_LIKE_c  # E: incompatible type
+AR_f *= AR_LIKE_m  # E: incompatible type
+
+# Array power
+
+AR_b **= AR_LIKE_b  # E: Invalid self argument
+AR_b **= AR_LIKE_u  # E: Invalid self argument
+AR_b **= AR_LIKE_i  # E: Invalid self argument
+AR_b **= AR_LIKE_f  # E: Invalid self argument
+AR_b **= AR_LIKE_c  # E: Invalid self argument
+
+AR_u **= AR_LIKE_i  # E: incompatible type
+AR_u **= AR_LIKE_f  # E: incompatible type
+AR_u **= AR_LIKE_c  # E: incompatible type
+
+AR_i **= AR_LIKE_f  # E: incompatible type
+AR_i **= AR_LIKE_c  # E: incompatible type
+
+AR_f **= AR_LIKE_c  # E: incompatible type
+
+# Scalars
+
+b_ - b_  # E: No overload variant
+
+dt + dt  # E: Unsupported operand types
+td - dt  # E: Unsupported operand types
+td % 1  # E: Unsupported operand types
+td / dt  # E: No overload
+td % dt  # E: Unsupported operand types
+
+-b_  # E: Unsupported operand type
++b_  # E: Unsupported operand type
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/array_constructors.pyi b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/array_constructors.pyi
new file mode 100644
index 00000000..27eefe3c
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/array_constructors.pyi
@@ -0,0 +1,34 @@
+import numpy as np
+import numpy.typing as npt
+
+a: npt.NDArray[np.float64]
+generator = (i for i in range(10))
+
+np.require(a, requirements=1)  # E: No overload variant
+np.require(a, requirements="TEST")  # E: incompatible type
+
+np.zeros("test")  # E: incompatible type
+np.zeros()  # E: require at least one argument
+
+np.ones("test")  # E: incompatible type
+np.ones()  # E: require at least one argument
+
+np.array(0, float, True)  # E: No overload variant
+
+np.linspace(None, 'bob')  # E: No overload variant
+np.linspace(0, 2, num=10.0)  # E: No overload variant
+np.linspace(0, 2, endpoint='True')  # E: No overload variant
+np.linspace(0, 2, retstep=b'False')  # E: No overload variant
+np.linspace(0, 2, dtype=0)  # E: No overload variant
+np.linspace(0, 2, axis=None)  # E: No overload variant
+
+np.logspace(None, 'bob')  # E: No overload variant
+np.logspace(0, 2, base=None)  # E: No overload variant
+
+np.geomspace(None, 'bob')  # E: No overload variant
+
+np.stack(generator)  # E: No overload variant
+np.hstack({1, 2})  # E: No overload variant
+np.vstack(1)  # E: No overload variant
+
+np.array([1], like=1)  # E: No overload variant
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/array_like.pyi b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/array_like.pyi
new file mode 100644
index 00000000..133b5fd4
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/array_like.pyi
@@ -0,0 +1,16 @@
+import numpy as np
+from numpy._typing import ArrayLike
+
+
+class A:
+    pass
+
+
+x1: ArrayLike = (i for i in range(10))  # E: Incompatible types in assignment
+x2: ArrayLike = A()  # E: Incompatible types in assignment
+x3: ArrayLike = {1: "foo", 2: "bar"}  # E: Incompatible types in assignment
+
+scalar = np.int64(1)
+scalar.__array__(dtype=np.float64)  # E: No overload variant
+array = np.array([1])
+array.__array__(dtype=np.float64)  # E: No overload variant
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/array_pad.pyi b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/array_pad.pyi
new file mode 100644
index 00000000..2be51a87
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/array_pad.pyi
@@ -0,0 +1,6 @@
+import numpy as np
+import numpy.typing as npt
+
+AR_i8: npt.NDArray[np.int64]
+
+np.pad(AR_i8, 2, mode="bob")  # E: No overload variant
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/arrayprint.pyi b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/arrayprint.pyi
new file mode 100644
index 00000000..f8c8a323
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/arrayprint.pyi
@@ -0,0 +1,16 @@
+from collections.abc import Callable
+from typing import Any
+
+import numpy as np
+import numpy.typing as npt
+
+AR: npt.NDArray[np.float64]
+func1: Callable[[Any], str]
+func2: Callable[[np.integer[Any]], str]
+
+np.array2string(AR, style=None)  # E: Unexpected keyword argument
+np.array2string(AR, legacy="1.14")  # E: incompatible type
+np.array2string(AR, sign="*")  # E: incompatible type
+np.array2string(AR, floatmode="default")  # E: incompatible type
+np.array2string(AR, formatter={"A": func1})  # E: incompatible type
+np.array2string(AR, formatter={"float": func2})  # E: Incompatible types
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/arrayterator.pyi b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/arrayterator.pyi
new file mode 100644
index 00000000..00280b3a
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/arrayterator.pyi
@@ -0,0 +1,14 @@
+import numpy as np
+import numpy.typing as npt
+
+AR_i8: npt.NDArray[np.int64]
+ar_iter = np.lib.Arrayterator(AR_i8)
+
+np.lib.Arrayterator(np.int64())  # E: incompatible type
+ar_iter.shape = (10, 5)  # E: is read-only
+ar_iter[None]  # E: Invalid index type
+ar_iter[None, 1]  # E: Invalid index type
+ar_iter[np.intp()]  # E: Invalid index type
+ar_iter[np.intp(), ...]  # E: Invalid index type
+ar_iter[AR_i8]  # E: Invalid index type
+ar_iter[AR_i8, :]  # E: Invalid index type
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/bitwise_ops.pyi b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/bitwise_ops.pyi
new file mode 100644
index 00000000..13b47c48
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/bitwise_ops.pyi
@@ -0,0 +1,21 @@
+import numpy as np
+
+i8 = np.int64()
+i4 = np.int32()
+u8 = np.uint64()
+b_ = np.bool()
+i = int()
+
+f8 = np.float64()
+
+b_ >> f8  # E: No overload variant
+i8 << f8  # E: No overload variant
+i | f8  # E: Unsupported operand types
+i8 ^ f8  # E: No overload variant
+u8 & f8  # E: No overload variant
+~f8  # E: Unsupported operand type
+# TODO: Certain mixes like i4 << u8 go to float and thus should fail
+
+# mypys' error message for `NoReturn` is unfortunately pretty bad
+# TODO: Re-enable this once we add support for numerical precision for `number`s
+# a = u8 | 0  # E: Need type annotation
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/char.pyi b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/char.pyi
new file mode 100644
index 00000000..542a273b
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/char.pyi
@@ -0,0 +1,69 @@
+import numpy as np
+import numpy.typing as npt
+
+AR_U: npt.NDArray[np.str_]
+AR_S: npt.NDArray[np.bytes_]
+
+np.char.equal(AR_U, AR_S)  # E: incompatible type
+
+np.char.not_equal(AR_U, AR_S)  # E: incompatible type
+
+np.char.greater_equal(AR_U, AR_S)  # E: incompatible type
+
+np.char.less_equal(AR_U, AR_S)  # E: incompatible type
+
+np.char.greater(AR_U, AR_S)  # E: incompatible type
+
+np.char.less(AR_U, AR_S)  # E: incompatible type
+
+np.char.encode(AR_S)  # E: incompatible type
+np.char.decode(AR_U)  # E: incompatible type
+
+np.char.join(AR_U, b"_")  # E: incompatible type
+np.char.join(AR_S, "_")  # E: incompatible type
+
+np.char.ljust(AR_U, 5, fillchar=b"a")  # E: incompatible type
+np.char.ljust(AR_S, 5, fillchar="a")  # E: incompatible type
+np.char.rjust(AR_U, 5, fillchar=b"a")  # E: incompatible type
+np.char.rjust(AR_S, 5, fillchar="a")  # E: incompatible type
+
+np.char.lstrip(AR_U, chars=b"a")  # E: incompatible type
+np.char.lstrip(AR_S, chars="a")  # E: incompatible type
+np.char.strip(AR_U, chars=b"a")  # E: incompatible type
+np.char.strip(AR_S, chars="a")  # E: incompatible type
+np.char.rstrip(AR_U, chars=b"a")  # E: incompatible type
+np.char.rstrip(AR_S, chars="a")  # E: incompatible type
+
+np.char.partition(AR_U, b"a")  # E: incompatible type
+np.char.partition(AR_S, "a")  # E: incompatible type
+np.char.rpartition(AR_U, b"a")  # E: incompatible type
+np.char.rpartition(AR_S, "a")  # E: incompatible type
+
+np.char.replace(AR_U, b"_", b"-")  # E: incompatible type
+np.char.replace(AR_S, "_", "-")  # E: incompatible type
+
+np.char.split(AR_U, b"_")  # E: incompatible type
+np.char.split(AR_S, "_")  # E: incompatible type
+np.char.rsplit(AR_U, b"_")  # E: incompatible type
+np.char.rsplit(AR_S, "_")  # E: incompatible type
+
+np.char.count(AR_U, b"a", start=[1, 2, 3])  # E: incompatible type
+np.char.count(AR_S, "a", end=9)  # E: incompatible type
+
+np.char.endswith(AR_U, b"a", start=[1, 2, 3])  # E: incompatible type
+np.char.endswith(AR_S, "a", end=9)  # E: incompatible type
+np.char.startswith(AR_U, b"a", start=[1, 2, 3])  # E: incompatible type
+np.char.startswith(AR_S, "a", end=9)  # E: incompatible type
+
+np.char.find(AR_U, b"a", start=[1, 2, 3])  # E: incompatible type
+np.char.find(AR_S, "a", end=9)  # E: incompatible type
+np.char.rfind(AR_U, b"a", start=[1, 2, 3])  # E: incompatible type
+np.char.rfind(AR_S, "a", end=9)  # E: incompatible type
+
+np.char.index(AR_U, b"a", start=[1, 2, 3])  # E: incompatible type
+np.char.index(AR_S, "a", end=9)  # E: incompatible type
+np.char.rindex(AR_U, b"a", start=[1, 2, 3])  # E: incompatible type
+np.char.rindex(AR_S, "a", end=9)  # E: incompatible type
+
+np.char.isdecimal(AR_S)  # E: incompatible type
+np.char.isnumeric(AR_S)  # E: incompatible type
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/chararray.pyi b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/chararray.pyi
new file mode 100644
index 00000000..d334f689
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/chararray.pyi
@@ -0,0 +1,62 @@
+import numpy as np
+from typing import Any
+
+AR_U: np.char.chararray[Any, np.dtype[np.str_]]
+AR_S: np.char.chararray[Any, np.dtype[np.bytes_]]
+
+AR_S.encode()  # E: Invalid self argument
+AR_U.decode()  # E: Invalid self argument
+
+AR_U.join(b"_")  # E: incompatible type
+AR_S.join("_")  # E: incompatible type
+
+AR_U.ljust(5, fillchar=b"a")  # E: incompatible type
+AR_S.ljust(5, fillchar="a")  # E: incompatible type
+AR_U.rjust(5, fillchar=b"a")  # E: incompatible type
+AR_S.rjust(5, fillchar="a")  # E: incompatible type
+
+AR_U.lstrip(chars=b"a")  # E: incompatible type
+AR_S.lstrip(chars="a")  # E: incompatible type
+AR_U.strip(chars=b"a")  # E: incompatible type
+AR_S.strip(chars="a")  # E: incompatible type
+AR_U.rstrip(chars=b"a")  # E: incompatible type
+AR_S.rstrip(chars="a")  # E: incompatible type
+
+AR_U.partition(b"a")  # E: incompatible type
+AR_S.partition("a")  # E: incompatible type
+AR_U.rpartition(b"a")  # E: incompatible type
+AR_S.rpartition("a")  # E: incompatible type
+
+AR_U.replace(b"_", b"-")  # E: incompatible type
+AR_S.replace("_", "-")  # E: incompatible type
+
+AR_U.split(b"_")  # E: incompatible type
+AR_S.split("_")  # E: incompatible type
+AR_S.split(1)  # E: incompatible type
+AR_U.rsplit(b"_")  # E: incompatible type
+AR_S.rsplit("_")  # E: incompatible type
+
+AR_U.count(b"a", start=[1, 2, 3])  # E: incompatible type
+AR_S.count("a", end=9)  # E: incompatible type
+
+AR_U.endswith(b"a", start=[1, 2, 3])  # E: incompatible type
+AR_S.endswith("a", end=9)  # E: incompatible type
+AR_U.startswith(b"a", start=[1, 2, 3])  # E: incompatible type
+AR_S.startswith("a", end=9)  # E: incompatible type
+
+AR_U.find(b"a", start=[1, 2, 3])  # E: incompatible type
+AR_S.find("a", end=9)  # E: incompatible type
+AR_U.rfind(b"a", start=[1, 2, 3])  # E: incompatible type
+AR_S.rfind("a", end=9)  # E: incompatible type
+
+AR_U.index(b"a", start=[1, 2, 3])  # E: incompatible type
+AR_S.index("a", end=9)  # E: incompatible type
+AR_U.rindex(b"a", start=[1, 2, 3])  # E: incompatible type
+AR_S.rindex("a", end=9)  # E: incompatible type
+
+AR_U == AR_S  # E: Unsupported operand types
+AR_U != AR_S  # E: Unsupported operand types
+AR_U >= AR_S  # E: Unsupported operand types
+AR_U <= AR_S  # E: Unsupported operand types
+AR_U > AR_S  # E: Unsupported operand types
+AR_U < AR_S  # E: Unsupported operand types
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/comparisons.pyi b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/comparisons.pyi
new file mode 100644
index 00000000..1ae81490
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/comparisons.pyi
@@ -0,0 +1,27 @@
+import numpy as np
+import numpy.typing as npt
+
+AR_i: npt.NDArray[np.int64]
+AR_f: npt.NDArray[np.float64]
+AR_c: npt.NDArray[np.complex128]
+AR_m: npt.NDArray[np.timedelta64]
+AR_M: npt.NDArray[np.datetime64]
+
+AR_f > AR_m  # E: Unsupported operand types
+AR_c > AR_m  # E: Unsupported operand types
+
+AR_m > AR_f  # E: Unsupported operand types
+AR_m > AR_c  # E: Unsupported operand types
+
+AR_i > AR_M  # E: Unsupported operand types
+AR_f > AR_M  # E: Unsupported operand types
+AR_m > AR_M  # E: Unsupported operand types
+
+AR_M > AR_i  # E: Unsupported operand types
+AR_M > AR_f  # E: Unsupported operand types
+AR_M > AR_m  # E: Unsupported operand types
+
+AR_i > str()  # E: No overload variant
+AR_i > bytes()  # E: No overload variant
+str() > AR_M  # E: Unsupported operand types
+bytes() > AR_M  # E: Unsupported operand types
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/constants.pyi b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/constants.pyi
new file mode 100644
index 00000000..b5d6d27e
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/constants.pyi
@@ -0,0 +1,3 @@
+import numpy as np
+
+np.little_endian = np.little_endian  # E: Cannot assign to final
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/datasource.pyi b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/datasource.pyi
new file mode 100644
index 00000000..44f4fa27
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/datasource.pyi
@@ -0,0 +1,15 @@
+from pathlib import Path
+import numpy as np
+
+path: Path
+d1: np.lib.npyio.DataSource
+
+d1.abspath(path)  # E: incompatible type
+d1.abspath(b"...")  # E: incompatible type
+
+d1.exists(path)  # E: incompatible type
+d1.exists(b"...")  # E: incompatible type
+
+d1.open(path, "r")  # E: incompatible type
+d1.open(b"...", encoding="utf8")  # E: incompatible type
+d1.open(None, newline="/n")  # E: incompatible type
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/dtype.pyi b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/dtype.pyi
new file mode 100644
index 00000000..0f3810f3
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/dtype.pyi
@@ -0,0 +1,20 @@
+import numpy as np
+
+
+class Test1:
+    not_dtype = np.dtype(float)
+
+
+class Test2:
+    dtype = float
+
+
+np.dtype(Test1())  # E: No overload variant of "dtype" matches
+np.dtype(Test2())  # E: incompatible type
+
+np.dtype(  # E: No overload variant of "dtype" matches
+    {
+        "field1": (float, 1),
+        "field2": (int, 3),
+    }
+)
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/einsumfunc.pyi b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/einsumfunc.pyi
new file mode 100644
index 00000000..e51f72e4
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/einsumfunc.pyi
@@ -0,0 +1,12 @@
+import numpy as np
+import numpy.typing as npt
+
+AR_i: npt.NDArray[np.int64]
+AR_f: npt.NDArray[np.float64]
+AR_m: npt.NDArray[np.timedelta64]
+AR_U: npt.NDArray[np.str_]
+
+np.einsum("i,i->i", AR_i, AR_m)  # E: incompatible type
+np.einsum("i,i->i", AR_f, AR_f, dtype=np.int32)  # E: incompatible type
+np.einsum("i,i->i", AR_i, AR_i, out=AR_U)  # E: Value of type variable "_ArrayType" of "einsum" cannot be
+np.einsum("i,i->i", AR_i, AR_i, out=AR_U, casting="unsafe")  # E: No overload variant
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/false_positives.pyi b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/false_positives.pyi
new file mode 100644
index 00000000..7e792306
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/false_positives.pyi
@@ -0,0 +1,11 @@
+import numpy as np
+import numpy.typing as npt
+
+AR_f8: npt.NDArray[np.float64]
+
+# NOTE: Mypy bug presumably due to the special-casing of heterogeneous tuples;
+# xref numpy/numpy#20901
+#
+# The expected output should be no different than, e.g., when using a
+# list instead of a tuple
+np.concatenate(([1], AR_f8))  # E: Argument 1 to "concatenate" has incompatible type
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/flatiter.pyi b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/flatiter.pyi
new file mode 100644
index 00000000..b0c3b023
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/flatiter.pyi
@@ -0,0 +1,25 @@
+from typing import Any
+
+import numpy as np
+import numpy._typing as npt
+
+
+class Index:
+    def __index__(self) -> int:
+        ...
+
+
+a: np.flatiter[npt.NDArray[np.float64]]
+supports_array: npt._SupportsArray[np.dtype[np.float64]]
+
+a.base = Any  # E: Property "base" defined in "flatiter" is read-only
+a.coords = Any  # E: Property "coords" defined in "flatiter" is read-only
+a.index = Any  # E: Property "index" defined in "flatiter" is read-only
+a.copy(order='C')  # E: Unexpected keyword argument
+
+# NOTE: Contrary to `ndarray.__getitem__` its counterpart in `flatiter`
+# does not accept objects with the `__array__` or `__index__` protocols;
+# boolean indexing is just plain broken (gh-17175)
+a[np.bool()]  # E: No overload variant of "__getitem__"
+a[Index()]  # E: No overload variant of "__getitem__"
+a[supports_array]  # E: No overload variant of "__getitem__"
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/fromnumeric.pyi b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/fromnumeric.pyi
new file mode 100644
index 00000000..accddaf8
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/fromnumeric.pyi
@@ -0,0 +1,161 @@
+"""Tests for :mod:`numpy._core.fromnumeric`."""
+
+import numpy as np
+import numpy.typing as npt
+
+A = np.array(True, ndmin=2, dtype=bool)
+A.setflags(write=False)
+AR_U: npt.NDArray[np.str_]
+
+a = np.bool(True)
+
+np.take(a, None)  # E: No overload variant
+np.take(a, axis=1.0)  # E: No overload variant
+np.take(A, out=1)  # E: No overload variant
+np.take(A, mode="bob")  # E: No overload variant
+
+np.reshape(a, None)  # E: No overload variant
+np.reshape(A, 1, order="bob")  # E: No overload variant
+
+np.choose(a, None)  # E: No overload variant
+np.choose(a, out=1.0)  # E: No overload variant
+np.choose(A, mode="bob")  # E: No overload variant
+
+np.repeat(a, None)  # E: No overload variant
+np.repeat(A, 1, axis=1.0)  # E: No overload variant
+
+np.swapaxes(A, None, 1)  # E: No overload variant
+np.swapaxes(A, 1, [0])  # E: No overload variant
+
+np.transpose(A, axes=1.0)  # E: No overload variant
+
+np.partition(a, None)  # E: No overload variant
+np.partition(  # E: No overload variant
+    a, 0, axis="bob"
+)
+np.partition(  # E: No overload variant
+    A, 0, kind="bob"
+)
+np.partition(
+    A, 0, order=range(5)  # E: Argument "order" to "partition" has incompatible type
+)
+
+np.argpartition(
+    a, None  # E: incompatible type
+)
+np.argpartition(
+    a, 0, axis="bob"  # E: incompatible type
+)
+np.argpartition(
+    A, 0, kind="bob"  # E: incompatible type
+)
+np.argpartition(
+    A, 0, order=range(5)  # E: Argument "order" to "argpartition" has incompatible type
+)
+
+np.sort(A, axis="bob")  # E: No overload variant
+np.sort(A, kind="bob")  # E: No overload variant
+np.sort(A, order=range(5))  # E: Argument "order" to "sort" has incompatible type
+
+np.argsort(A, axis="bob")  # E: Argument "axis" to "argsort" has incompatible type
+np.argsort(A, kind="bob")  # E: Argument "kind" to "argsort" has incompatible type
+np.argsort(A, order=range(5))  # E: Argument "order" to "argsort" has incompatible type
+
+np.argmax(A, axis="bob")  # E: No overload variant of "argmax" matches argument type
+np.argmax(A, kind="bob")  # E: No overload variant of "argmax" matches argument type
+
+np.argmin(A, axis="bob")  # E: No overload variant of "argmin" matches argument type
+np.argmin(A, kind="bob")  # E: No overload variant of "argmin" matches argument type
+
+np.searchsorted(  # E: No overload variant of "searchsorted" matches argument type
+    A[0], 0, side="bob"
+)
+np.searchsorted(  # E: No overload variant of "searchsorted" matches argument type
+    A[0], 0, sorter=1.0
+)
+
+np.resize(A, 1.0)  # E: No overload variant
+
+np.squeeze(A, 1.0)  # E: No overload variant of "squeeze" matches argument type
+
+np.diagonal(A, offset=None)  # E: No overload variant
+np.diagonal(A, axis1="bob")  # E: No overload variant
+np.diagonal(A, axis2=[])  # E: No overload variant
+
+np.trace(A, offset=None)  # E: No overload variant
+np.trace(A, axis1="bob")  # E: No overload variant
+np.trace(A, axis2=[])  # E: No overload variant
+
+np.ravel(a, order="bob")  # E: No overload variant
+
+np.compress(  # E: No overload variant
+    [True], A, axis=1.0
+)
+
+np.clip(a, 1, 2, out=1)  # E: No overload variant of "clip" matches argument type
+
+np.sum(a, axis=1.0)  # E: No overload variant
+np.sum(a, keepdims=1.0)  # E: No overload variant
+np.sum(a, initial=[1])  # E: No overload variant
+
+np.all(a, axis=1.0)  # E: No overload variant
+np.all(a, keepdims=1.0)  # E: No overload variant
+np.all(a, out=1.0)  # E: No overload variant
+
+np.any(a, axis=1.0)  # E: No overload variant
+np.any(a, keepdims=1.0)  # E: No overload variant
+np.any(a, out=1.0)  # E: No overload variant
+
+np.cumsum(a, axis=1.0)  # E: No overload variant
+np.cumsum(a, dtype=1.0)  # E: No overload variant
+np.cumsum(a, out=1.0)  # E: No overload variant
+
+np.ptp(a, axis=1.0)  # E: No overload variant
+np.ptp(a, keepdims=1.0)  # E: No overload variant
+np.ptp(a, out=1.0)  # E: No overload variant
+
+np.amax(a, axis=1.0)  # E: No overload variant
+np.amax(a, keepdims=1.0)  # E: No overload variant
+np.amax(a, out=1.0)  # E: No overload variant
+np.amax(a, initial=[1.0])  # E: No overload variant
+np.amax(a, where=[1.0])  # E: incompatible type
+
+np.amin(a, axis=1.0)  # E: No overload variant
+np.amin(a, keepdims=1.0)  # E: No overload variant
+np.amin(a, out=1.0)  # E: No overload variant
+np.amin(a, initial=[1.0])  # E: No overload variant
+np.amin(a, where=[1.0])  # E: incompatible type
+
+np.prod(a, axis=1.0)  # E: No overload variant
+np.prod(a, out=False)  # E: No overload variant
+np.prod(a, keepdims=1.0)  # E: No overload variant
+np.prod(a, initial=int)  # E: No overload variant
+np.prod(a, where=1.0)  # E: No overload variant
+np.prod(AR_U)  # E: incompatible type
+
+np.cumprod(a, axis=1.0)  # E: No overload variant
+np.cumprod(a, out=False)  # E: No overload variant
+np.cumprod(AR_U)  # E: incompatible type
+
+np.size(a, axis=1.0)  # E: Argument "axis" to "size" has incompatible type
+
+np.around(a, decimals=1.0)  # E: No overload variant
+np.around(a, out=type)  # E: No overload variant
+np.around(AR_U)  # E: incompatible type
+
+np.mean(a, axis=1.0)  # E: No overload variant
+np.mean(a, out=False)  # E: No overload variant
+np.mean(a, keepdims=1.0)  # E: No overload variant
+np.mean(AR_U)  # E: incompatible type
+
+np.std(a, axis=1.0)  # E: No overload variant
+np.std(a, out=False)  # E: No overload variant
+np.std(a, ddof='test')  # E: No overload variant
+np.std(a, keepdims=1.0)  # E: No overload variant
+np.std(AR_U)  # E: incompatible type
+
+np.var(a, axis=1.0)  # E: No overload variant
+np.var(a, out=False)  # E: No overload variant
+np.var(a, ddof='test')  # E: No overload variant
+np.var(a, keepdims=1.0)  # E: No overload variant
+np.var(AR_U)  # E: incompatible type
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/histograms.pyi b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/histograms.pyi
new file mode 100644
index 00000000..22499d39
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/histograms.pyi
@@ -0,0 +1,12 @@
+import numpy as np
+import numpy.typing as npt
+
+AR_i8: npt.NDArray[np.int64]
+AR_f8: npt.NDArray[np.float64]
+
+np.histogram_bin_edges(AR_i8, range=(0, 1, 2))  # E: incompatible type
+
+np.histogram(AR_i8, range=(0, 1, 2))  # E: incompatible type
+
+np.histogramdd(AR_i8, range=(0, 1))  # E: incompatible type
+np.histogramdd(AR_i8, range=[(0, 1, 2)])  # E: incompatible type
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/index_tricks.pyi b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/index_tricks.pyi
new file mode 100644
index 00000000..22f6f4a6
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/index_tricks.pyi
@@ -0,0 +1,14 @@
+import numpy as np
+
+AR_LIKE_i: list[int]
+AR_LIKE_f: list[float]
+
+np.ndindex([1, 2, 3])  # E: No overload variant
+np.unravel_index(AR_LIKE_f, (1, 2, 3))  # E: incompatible type
+np.ravel_multi_index(AR_LIKE_i, (1, 2, 3), mode="bob")  # E: No overload variant
+np.mgrid[1]  # E: Invalid index type
+np.mgrid[...]  # E: Invalid index type
+np.ogrid[1]  # E: Invalid index type
+np.ogrid[...]  # E: Invalid index type
+np.fill_diagonal(AR_LIKE_f, 2)  # E: incompatible type
+np.diag_indices(1.0)  # E: incompatible type
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/lib_function_base.pyi b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/lib_function_base.pyi
new file mode 100644
index 00000000..dccb3dbb
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/lib_function_base.pyi
@@ -0,0 +1,51 @@
+from typing import Any
+
+import numpy as np
+import numpy.typing as npt
+
+AR_f8: npt.NDArray[np.float64]
+AR_c16: npt.NDArray[np.complex128]
+AR_m: npt.NDArray[np.timedelta64]
+AR_M: npt.NDArray[np.datetime64]
+AR_O: npt.NDArray[np.object_]
+
+def func(a: int) -> None: ...
+
+np.average(AR_m)  # E: incompatible type
+np.select(1, [AR_f8])  # E: incompatible type
+np.angle(AR_m)  # E: incompatible type
+np.unwrap(AR_m)  # E: incompatible type
+np.unwrap(AR_c16)  # E: incompatible type
+np.trim_zeros(1)  # E: incompatible type
+np.place(1, [True], 1.5)  # E: incompatible type
+np.vectorize(1)  # E: incompatible type
+np.place(AR_f8, slice(None), 5)  # E: incompatible type
+
+np.interp(AR_f8, AR_c16, AR_f8)  # E: incompatible type
+np.interp(AR_c16, AR_f8, AR_f8)  # E: incompatible type
+np.interp(AR_f8, AR_f8, AR_f8, period=AR_c16)  # E: No overload variant
+np.interp(AR_f8, AR_f8, AR_O)  # E: incompatible type
+
+np.cov(AR_m)  # E: incompatible type
+np.cov(AR_O)  # E: incompatible type
+np.corrcoef(AR_m)  # E: incompatible type
+np.corrcoef(AR_O)  # E: incompatible type
+np.corrcoef(AR_f8, bias=True)  # E: No overload variant
+np.corrcoef(AR_f8, ddof=2)  # E: No overload variant
+np.blackman(1j)  # E: incompatible type
+np.bartlett(1j)  # E: incompatible type
+np.hanning(1j)  # E: incompatible type
+np.hamming(1j)  # E: incompatible type
+np.hamming(AR_c16)  # E: incompatible type
+np.kaiser(1j, 1)  # E: incompatible type
+np.sinc(AR_O)  # E: incompatible type
+np.median(AR_M)  # E: incompatible type
+
+np.percentile(AR_f8, 50j)  # E: No overload variant
+np.percentile(AR_f8, 50, interpolation="bob")  # E: No overload variant
+np.quantile(AR_f8, 0.5j)  # E: No overload variant
+np.quantile(AR_f8, 0.5, interpolation="bob")  # E: No overload variant
+np.meshgrid(AR_f8, AR_f8, indexing="bob")  # E: incompatible type
+np.delete(AR_f8, AR_f8)  # E: incompatible type
+np.insert(AR_f8, AR_f8, 1.5)  # E: incompatible type
+np.digitize(AR_f8, 1j)  # E: No overload variant
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/lib_polynomial.pyi b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/lib_polynomial.pyi
new file mode 100644
index 00000000..e51b6b58
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/lib_polynomial.pyi
@@ -0,0 +1,29 @@
+import numpy as np
+import numpy.typing as npt
+
+AR_f8: npt.NDArray[np.float64]
+AR_c16: npt.NDArray[np.complex128]
+AR_O: npt.NDArray[np.object_]
+AR_U: npt.NDArray[np.str_]
+
+poly_obj: np.poly1d
+
+np.polymul(AR_f8, AR_U)  # E: incompatible type
+np.polydiv(AR_f8, AR_U)  # E: incompatible type
+
+5**poly_obj  # E: No overload variant
+
+np.polyint(AR_U)  # E: incompatible type
+np.polyint(AR_f8, m=1j)  # E: No overload variant
+
+np.polyder(AR_U)  # E: incompatible type
+np.polyder(AR_f8, m=1j)  # E: No overload variant
+
+np.polyfit(AR_O, AR_f8, 1)  # E: incompatible type
+np.polyfit(AR_f8, AR_f8, 1, rcond=1j)  # E: No overload variant
+np.polyfit(AR_f8, AR_f8, 1, w=AR_c16)  # E: incompatible type
+np.polyfit(AR_f8, AR_f8, 1, cov="bob")  # E: No overload variant
+
+np.polyval(AR_f8, AR_U)  # E: incompatible type
+np.polyadd(AR_f8, AR_U)  # E: incompatible type
+np.polysub(AR_f8, AR_U)  # E: incompatible type
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/lib_utils.pyi b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/lib_utils.pyi
new file mode 100644
index 00000000..8b8482ee
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/lib_utils.pyi
@@ -0,0 +1,3 @@
+import numpy.lib.array_utils as array_utils
+
+array_utils.byte_bounds(1)  # E: incompatible type
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/lib_version.pyi b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/lib_version.pyi
new file mode 100644
index 00000000..2758cfe4
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/lib_version.pyi
@@ -0,0 +1,6 @@
+from numpy.lib import NumpyVersion
+
+version: NumpyVersion
+
+NumpyVersion(b"1.8.0")  # E: incompatible type
+version >= b"1.8.0"  # E: Unsupported operand types
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/linalg.pyi b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/linalg.pyi
new file mode 100644
index 00000000..da939032
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/linalg.pyi
@@ -0,0 +1,48 @@
+import numpy as np
+import numpy.typing as npt
+
+AR_f8: npt.NDArray[np.float64]
+AR_O: npt.NDArray[np.object_]
+AR_M: npt.NDArray[np.datetime64]
+
+np.linalg.tensorsolve(AR_O, AR_O)  # E: incompatible type
+
+np.linalg.solve(AR_O, AR_O)  # E: incompatible type
+
+np.linalg.tensorinv(AR_O)  # E: incompatible type
+
+np.linalg.inv(AR_O)  # E: incompatible type
+
+np.linalg.matrix_power(AR_M, 5)  # E: incompatible type
+
+np.linalg.cholesky(AR_O)  # E: incompatible type
+
+np.linalg.qr(AR_O)  # E: incompatible type
+np.linalg.qr(AR_f8, mode="bob")  # E: No overload variant
+
+np.linalg.eigvals(AR_O)  # E: incompatible type
+
+np.linalg.eigvalsh(AR_O)  # E: incompatible type
+np.linalg.eigvalsh(AR_O, UPLO="bob")  # E: No overload variant
+
+np.linalg.eig(AR_O)  # E: incompatible type
+
+np.linalg.eigh(AR_O)  # E: incompatible type
+np.linalg.eigh(AR_O, UPLO="bob")  # E: No overload variant
+
+np.linalg.svd(AR_O)  # E: incompatible type
+
+np.linalg.cond(AR_O)  # E: incompatible type
+np.linalg.cond(AR_f8, p="bob")  # E: incompatible type
+
+np.linalg.matrix_rank(AR_O)  # E: incompatible type
+
+np.linalg.pinv(AR_O)  # E: incompatible type
+
+np.linalg.slogdet(AR_O)  # E: incompatible type
+
+np.linalg.det(AR_O)  # E: incompatible type
+
+np.linalg.norm(AR_f8, ord="bob")  # E: No overload variant
+
+np.linalg.multi_dot([AR_M])  # E: incompatible type
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/memmap.pyi b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/memmap.pyi
new file mode 100644
index 00000000..434870b6
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/memmap.pyi
@@ -0,0 +1,5 @@
+import numpy as np
+
+with open("file.txt", "r") as f:
+    np.memmap(f)  # E: No overload variant
+np.memmap("test.txt", shape=[10, 5])  # E: No overload variant
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/modules.pyi b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/modules.pyi
new file mode 100644
index 00000000..c86627e0
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/modules.pyi
@@ -0,0 +1,18 @@
+import numpy as np
+
+np.testing.bob  # E: Module has no attribute
+np.bob  # E: Module has no attribute
+
+# Stdlib modules in the namespace by accident
+np.warnings  # E: Module has no attribute
+np.sys  # E: Module has no attribute
+np.os  # E: Module "numpy" does not explicitly export
+np.math  # E: Module has no attribute
+
+# Public sub-modules that are not imported to their parent module by default;
+# e.g. one must first execute `import numpy.lib.recfunctions`
+np.lib.recfunctions  # E: Module has no attribute
+
+np.__NUMPY_SETUP__  # E: Module has no attribute
+np.__deprecated_attrs__  # E: Module has no attribute
+np.__expired_functions__  # E: Module has no attribute
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/multiarray.pyi b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/multiarray.pyi
new file mode 100644
index 00000000..0ee6c11c
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/multiarray.pyi
@@ -0,0 +1,53 @@
+import numpy as np
+import numpy.typing as npt
+
+i8: np.int64
+
+AR_b: npt.NDArray[np.bool]
+AR_u1: npt.NDArray[np.uint8]
+AR_i8: npt.NDArray[np.int64]
+AR_f8: npt.NDArray[np.float64]
+AR_M: npt.NDArray[np.datetime64]
+
+M: np.datetime64
+
+AR_LIKE_f: list[float]
+
+def func(a: int) -> None: ...
+
+np.where(AR_b, 1)  # E: No overload variant
+
+np.can_cast(AR_f8, 1)  # E: incompatible type
+
+np.vdot(AR_M, AR_M)  # E: incompatible type
+
+np.copyto(AR_LIKE_f, AR_f8)  # E: incompatible type
+
+np.putmask(AR_LIKE_f, [True, True, False], 1.5)  # E: incompatible type
+
+np.packbits(AR_f8)  # E: incompatible type
+np.packbits(AR_u1, bitorder=">")  # E: incompatible type
+
+np.unpackbits(AR_i8)  # E: incompatible type
+np.unpackbits(AR_u1, bitorder=">")  # E: incompatible type
+
+np.shares_memory(1, 1, max_work=i8)  # E: incompatible type
+np.may_share_memory(1, 1, max_work=i8)  # E: incompatible type
+
+np.arange(M)  # E: No overload variant
+np.arange(stop=10)  # E: No overload variant
+
+np.datetime_data(int)  # E: incompatible type
+
+np.busday_offset("2012", 10)  # E: No overload variant
+
+np.datetime_as_string("2012")  # E: No overload variant
+
+np.char.compare_chararrays("a", b"a", "==", False)  # E: No overload variant
+
+np.nested_iters([AR_i8, AR_i8])  # E: Missing positional argument
+np.nested_iters([AR_i8, AR_i8], 0)  # E: incompatible type
+np.nested_iters([AR_i8, AR_i8], [0])  # E: incompatible type
+np.nested_iters([AR_i8, AR_i8], [[0], [1]], flags=["test"])  # E: incompatible type
+np.nested_iters([AR_i8, AR_i8], [[0], [1]], op_flags=[["test"]])  # E: incompatible type
+np.nested_iters([AR_i8, AR_i8], [[0], [1]], buffersize=1.0)  # E: incompatible type
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/ndarray.pyi b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/ndarray.pyi
new file mode 100644
index 00000000..5ecae02e
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/ndarray.pyi
@@ -0,0 +1,11 @@
+import numpy as np
+
+# Ban setting dtype since mutating the type of the array in place
+# makes having ndarray be generic over dtype impossible. Generally
+# users should use `ndarray.view` in this situation anyway. See
+#
+# https://github.com/numpy/numpy-stubs/issues/7
+#
+# for more context.
+float_array = np.array([1.0])
+float_array.dtype = np.bool  # E: Property "dtype" defined in "ndarray" is read-only
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/ndarray_misc.pyi b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/ndarray_misc.pyi
new file mode 100644
index 00000000..674b3788
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/ndarray_misc.pyi
@@ -0,0 +1,43 @@
+"""
+Tests for miscellaneous (non-magic) ``np.ndarray``/``np.generic`` methods.
+
+More extensive tests are performed for the methods'
+function-based counterpart in `../from_numeric.py`.
+
+"""
+
+import numpy as np
+import numpy.typing as npt
+
+f8: np.float64
+AR_f8: npt.NDArray[np.float64]
+AR_M: npt.NDArray[np.datetime64]
+AR_b: npt.NDArray[np.bool]
+
+ctypes_obj = AR_f8.ctypes
+
+reveal_type(ctypes_obj.get_data())  # E: has no attribute
+reveal_type(ctypes_obj.get_shape())  # E: has no attribute
+reveal_type(ctypes_obj.get_strides())  # E: has no attribute
+reveal_type(ctypes_obj.get_as_parameter())  # E: has no attribute
+
+f8.argpartition(0)  # E: has no attribute
+f8.diagonal()  # E: has no attribute
+f8.dot(1)  # E: has no attribute
+f8.nonzero()  # E: has no attribute
+f8.partition(0)  # E: has no attribute
+f8.put(0, 2)  # E: has no attribute
+f8.setfield(2, np.float64)  # E: has no attribute
+f8.sort()  # E: has no attribute
+f8.trace()  # E: has no attribute
+
+AR_M.__int__()  # E: Invalid self argument
+AR_M.__float__()  # E: Invalid self argument
+AR_M.__complex__()  # E: Invalid self argument
+AR_b.__index__()  # E: Invalid self argument
+
+AR_f8[1.5]  # E: No overload variant
+AR_f8["field_a"]  # E: No overload variant
+AR_f8[["field_a", "field_b"]]  # E: Invalid index type
+
+AR_f8.__array_finalize__(object())  # E: incompatible type
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/nditer.pyi b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/nditer.pyi
new file mode 100644
index 00000000..1e8e37ee
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/nditer.pyi
@@ -0,0 +1,8 @@
+import numpy as np
+
+class Test(np.nditer): ...  # E: Cannot inherit from final class
+
+np.nditer([0, 1], flags=["test"])  # E: incompatible type
+np.nditer([0, 1], op_flags=[["test"]])  # E: incompatible type
+np.nditer([0, 1], itershape=(1.0,))  # E: incompatible type
+np.nditer([0, 1], buffersize=1.0)  # E: incompatible type
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/nested_sequence.pyi b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/nested_sequence.pyi
new file mode 100644
index 00000000..6301e517
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/nested_sequence.pyi
@@ -0,0 +1,17 @@
+from collections.abc import Sequence
+from numpy._typing import _NestedSequence
+
+a: Sequence[float]
+b: list[complex]
+c: tuple[str, ...]
+d: int
+e: str
+
+def func(a: _NestedSequence[int]) -> None:
+    ...
+
+reveal_type(func(a))  # E: incompatible type
+reveal_type(func(b))  # E: incompatible type
+reveal_type(func(c))  # E: incompatible type
+reveal_type(func(d))  # E: incompatible type
+reveal_type(func(e))  # E: incompatible type
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/npyio.pyi b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/npyio.pyi
new file mode 100644
index 00000000..95b6c426
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/npyio.pyi
@@ -0,0 +1,23 @@
+import pathlib
+from typing import IO
+
+import numpy.typing as npt
+import numpy as np
+
+str_path: str
+bytes_path: bytes
+pathlib_path: pathlib.Path
+str_file: IO[str]
+AR_i8: npt.NDArray[np.int64]
+
+np.load(str_file)  # E: incompatible type
+
+np.save(bytes_path, AR_i8)  # E: incompatible type
+
+np.savez(bytes_path, AR_i8)  # E: incompatible type
+
+np.savez_compressed(bytes_path, AR_i8)  # E: incompatible type
+
+np.loadtxt(bytes_path)  # E: incompatible type
+
+np.fromregex(bytes_path, ".", np.int64)  # E: No overload variant
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/numerictypes.pyi b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/numerictypes.pyi
new file mode 100644
index 00000000..29a3cf30
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/numerictypes.pyi
@@ -0,0 +1,5 @@
+import numpy as np
+
+np.isdtype(1, np.int64)  # E: incompatible type
+
+np.issubdtype(1, np.int64)  # E: incompatible type
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/random.pyi b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/random.pyi
new file mode 100644
index 00000000..aa1eae44
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/random.pyi
@@ -0,0 +1,62 @@
+import numpy as np
+import numpy.typing as npt
+
+SEED_FLOAT: float = 457.3
+SEED_ARR_FLOAT: npt.NDArray[np.float64] = np.array([1.0, 2, 3, 4])
+SEED_ARRLIKE_FLOAT: list[float] = [1.0, 2.0, 3.0, 4.0]
+SEED_SEED_SEQ: np.random.SeedSequence = np.random.SeedSequence(0)
+SEED_STR: str = "String seeding not allowed"
+
+# default rng
+np.random.default_rng(SEED_FLOAT)  # E: incompatible type
+np.random.default_rng(SEED_ARR_FLOAT)  # E: incompatible type
+np.random.default_rng(SEED_ARRLIKE_FLOAT)  # E: incompatible type
+np.random.default_rng(SEED_STR)  # E: incompatible type
+
+# Seed Sequence
+np.random.SeedSequence(SEED_FLOAT)  # E: incompatible type
+np.random.SeedSequence(SEED_ARR_FLOAT)  # E: incompatible type
+np.random.SeedSequence(SEED_ARRLIKE_FLOAT)  # E: incompatible type
+np.random.SeedSequence(SEED_SEED_SEQ)  # E: incompatible type
+np.random.SeedSequence(SEED_STR)  # E: incompatible type
+
+seed_seq: np.random.bit_generator.SeedSequence = np.random.SeedSequence()
+seed_seq.spawn(11.5)  # E: incompatible type
+seed_seq.generate_state(3.14)  # E: incompatible type
+seed_seq.generate_state(3, np.uint8)  # E: incompatible type
+seed_seq.generate_state(3, "uint8")  # E: incompatible type
+seed_seq.generate_state(3, "u1")  # E: incompatible type
+seed_seq.generate_state(3, np.uint16)  # E: incompatible type
+seed_seq.generate_state(3, "uint16")  # E: incompatible type
+seed_seq.generate_state(3, "u2")  # E: incompatible type
+seed_seq.generate_state(3, np.int32)  # E: incompatible type
+seed_seq.generate_state(3, "int32")  # E: incompatible type
+seed_seq.generate_state(3, "i4")  # E: incompatible type
+
+# Bit Generators
+np.random.MT19937(SEED_FLOAT)  # E: incompatible type
+np.random.MT19937(SEED_ARR_FLOAT)  # E: incompatible type
+np.random.MT19937(SEED_ARRLIKE_FLOAT)  # E: incompatible type
+np.random.MT19937(SEED_STR)  # E: incompatible type
+
+np.random.PCG64(SEED_FLOAT)  # E: incompatible type
+np.random.PCG64(SEED_ARR_FLOAT)  # E: incompatible type
+np.random.PCG64(SEED_ARRLIKE_FLOAT)  # E: incompatible type
+np.random.PCG64(SEED_STR)  # E: incompatible type
+
+np.random.Philox(SEED_FLOAT)  # E: incompatible type
+np.random.Philox(SEED_ARR_FLOAT)  # E: incompatible type
+np.random.Philox(SEED_ARRLIKE_FLOAT)  # E: incompatible type
+np.random.Philox(SEED_STR)  # E: incompatible type
+
+np.random.SFC64(SEED_FLOAT)  # E: incompatible type
+np.random.SFC64(SEED_ARR_FLOAT)  # E: incompatible type
+np.random.SFC64(SEED_ARRLIKE_FLOAT)  # E: incompatible type
+np.random.SFC64(SEED_STR)  # E: incompatible type
+
+# Generator
+np.random.Generator(None)  # E: incompatible type
+np.random.Generator(12333283902830213)  # E: incompatible type
+np.random.Generator("OxFEEDF00D")  # E: incompatible type
+np.random.Generator([123, 234])  # E: incompatible type
+np.random.Generator(np.array([123, 234], dtype="u4"))  # E: incompatible type
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/rec.pyi b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/rec.pyi
new file mode 100644
index 00000000..a57f1ba2
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/rec.pyi
@@ -0,0 +1,17 @@
+import numpy as np
+import numpy.typing as npt
+
+AR_i8: npt.NDArray[np.int64]
+
+np.rec.fromarrays(1)  # E: No overload variant
+np.rec.fromarrays([1, 2, 3], dtype=[("f8", "f8")], formats=["f8", "f8"])  # E: No overload variant
+
+np.rec.fromrecords(AR_i8)  # E: incompatible type
+np.rec.fromrecords([(1.5,)], dtype=[("f8", "f8")], formats=["f8", "f8"])  # E: No overload variant
+
+np.rec.fromstring("string", dtype=[("f8", "f8")])  # E: No overload variant
+np.rec.fromstring(b"bytes")  # E: No overload variant
+np.rec.fromstring(b"(1.5,)", dtype=[("f8", "f8")], formats=["f8", "f8"])  # E: No overload variant
+
+with open("test", "r") as f:
+    np.rec.fromfile(f, dtype=[("f8", "f8")])  # E: No overload variant
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/scalars.pyi b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/scalars.pyi
new file mode 100644
index 00000000..e65e111c
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/scalars.pyi
@@ -0,0 +1,92 @@
+import sys
+import numpy as np
+
+f2: np.float16
+f8: np.float64
+c8: np.complex64
+
+# Construction
+
+np.float32(3j)  # E: incompatible type
+
+# Technically the following examples are valid NumPy code. But they
+# are not considered a best practice, and people who wish to use the
+# stubs should instead do
+#
+# np.array([1.0, 0.0, 0.0], dtype=np.float32)
+# np.array([], dtype=np.complex64)
+#
+# See e.g. the discussion on the mailing list
+#
+# https://mail.python.org/pipermail/numpy-discussion/2020-April/080566.html
+#
+# and the issue
+#
+# https://github.com/numpy/numpy-stubs/issues/41
+#
+# for more context.
+np.float32([1.0, 0.0, 0.0])  # E: incompatible type
+np.complex64([])  # E: incompatible type
+
+np.complex64(1, 2)  # E: Too many arguments
+# TODO: protocols (can't check for non-existent protocols w/ __getattr__)
+
+np.datetime64(0)  # E: No overload variant
+
+class A:
+    def __float__(self):
+        return 1.0
+
+
+np.int8(A())  # E: incompatible type
+np.int16(A())  # E: incompatible type
+np.int32(A())  # E: incompatible type
+np.int64(A())  # E: incompatible type
+np.uint8(A())  # E: incompatible type
+np.uint16(A())  # E: incompatible type
+np.uint32(A())  # E: incompatible type
+np.uint64(A())  # E: incompatible type
+
+np.void("test")  # E: No overload variant
+np.void("test", dtype=None)  # E: No overload variant
+
+np.generic(1)  # E: Cannot instantiate abstract class
+np.number(1)  # E: Cannot instantiate abstract class
+np.integer(1)  # E: Cannot instantiate abstract class
+np.inexact(1)  # E: Cannot instantiate abstract class
+np.character("test")  # E: Cannot instantiate abstract class
+np.flexible(b"test")  # E: Cannot instantiate abstract class
+
+np.float64(value=0.0)  # E: Unexpected keyword argument
+np.int64(value=0)  # E: Unexpected keyword argument
+np.uint64(value=0)  # E: Unexpected keyword argument
+np.complex128(value=0.0j)  # E: Unexpected keyword argument
+np.str_(value='bob')  # E: No overload variant
+np.bytes_(value=b'test')  # E: No overload variant
+np.void(value=b'test')  # E: No overload variant
+np.bool(value=True)  # E: Unexpected keyword argument
+np.datetime64(value="2019")  # E: No overload variant
+np.timedelta64(value=0)  # E: Unexpected keyword argument
+
+np.bytes_(b"hello", encoding='utf-8')  # E: No overload variant
+np.str_("hello", encoding='utf-8')  # E: No overload variant
+
+f8.item(1)  # E: incompatible type
+f8.item((0, 1))  # E: incompatible type
+f8.squeeze(axis=1)  # E: incompatible type
+f8.squeeze(axis=(0, 1))  # E: incompatible type
+f8.transpose(1)  # E: incompatible type
+
+def func(a: np.float32) -> None: ...
+
+func(f2)  # E: incompatible type
+func(f8)  # E: incompatible type
+
+round(c8)  # E: No overload variant
+
+c8.__getnewargs__()  # E: Invalid self argument
+f2.__getnewargs__()  # E: Invalid self argument
+f2.hex()  # E: Invalid self argument
+np.float16.fromhex("0x0.0p+0")  # E: Invalid self argument
+f2.__trunc__()  # E: Invalid self argument
+f2.__getformat__("float")  # E: Invalid self argument
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/shape.pyi b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/shape.pyi
new file mode 100644
index 00000000..3dd6d14f
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/shape.pyi
@@ -0,0 +1,6 @@
+from typing import Any
+import numpy as np
+
+# test bounds of _ShapeType_co
+
+np.ndarray[tuple[str, str], Any]  # E: Value of type variable
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/shape_base.pyi b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/shape_base.pyi
new file mode 100644
index 00000000..e709741b
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/shape_base.pyi
@@ -0,0 +1,8 @@
+import numpy as np
+
+class DTypeLike:
+    dtype: np.dtype[np.int_]
+
+dtype_like: DTypeLike
+
+np.expand_dims(dtype_like, (5, 10))  # E: No overload variant
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/stride_tricks.pyi b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/stride_tricks.pyi
new file mode 100644
index 00000000..f2bfba74
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/stride_tricks.pyi
@@ -0,0 +1,9 @@
+import numpy as np
+import numpy.typing as npt
+
+AR_f8: npt.NDArray[np.float64]
+
+np.lib.stride_tricks.as_strided(AR_f8, shape=8)  # E: No overload variant
+np.lib.stride_tricks.as_strided(AR_f8, strides=8)  # E: No overload variant
+
+np.lib.stride_tricks.sliding_window_view(AR_f8, axis=(1,))  # E: No overload variant
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/strings.pyi b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/strings.pyi
new file mode 100644
index 00000000..66fcf6b2
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/strings.pyi
@@ -0,0 +1,69 @@
+import numpy as np
+import numpy.typing as npt
+
+AR_U: npt.NDArray[np.str_]
+AR_S: npt.NDArray[np.bytes_]
+
+np.strings.equal(AR_U, AR_S)  # E: incompatible type
+
+np.strings.not_equal(AR_U, AR_S)  # E: incompatible type
+
+np.strings.greater_equal(AR_U, AR_S)  # E: incompatible type
+
+np.strings.less_equal(AR_U, AR_S)  # E: incompatible type
+
+np.strings.greater(AR_U, AR_S)  # E: incompatible type
+
+np.strings.less(AR_U, AR_S)  # E: incompatible type
+
+np.strings.encode(AR_S)  # E: incompatible type
+np.strings.decode(AR_U)  # E: incompatible type
+
+np.strings.join(AR_U, b"_")  # E: incompatible type
+np.strings.join(AR_S, "_")  # E: incompatible type
+
+np.strings.ljust(AR_U, 5, fillchar=b"a")  # E: incompatible type
+np.strings.ljust(AR_S, 5, fillchar="a")  # E: incompatible type
+np.strings.rjust(AR_U, 5, fillchar=b"a")  # E: incompatible type
+np.strings.rjust(AR_S, 5, fillchar="a")  # E: incompatible type
+
+np.strings.lstrip(AR_U, b"a")  # E: incompatible type
+np.strings.lstrip(AR_S, "a")  # E: incompatible type
+np.strings.strip(AR_U, b"a")  # E: incompatible type
+np.strings.strip(AR_S, "a")  # E: incompatible type
+np.strings.rstrip(AR_U, b"a")  # E: incompatible type
+np.strings.rstrip(AR_S, "a")  # E: incompatible type
+
+np.strings.partition(AR_U, b"a")  # E: incompatible type
+np.strings.partition(AR_S, "a")  # E: incompatible type
+np.strings.rpartition(AR_U, b"a")  # E: incompatible type
+np.strings.rpartition(AR_S, "a")  # E: incompatible type
+
+np.strings.split(AR_U, b"_")  # E: incompatible type
+np.strings.split(AR_S, "_")  # E: incompatible type
+np.strings.rsplit(AR_U, b"_")  # E: incompatible type
+np.strings.rsplit(AR_S, "_")  # E: incompatible type
+
+np.strings.count(AR_U, b"a", [1, 2, 3], [1, 2, 3])  # E: incompatible type
+np.strings.count(AR_S, "a", 0, 9)  # E: incompatible type
+
+np.strings.endswith(AR_U, b"a", [1, 2, 3], [1, 2, 3])  # E: incompatible type
+np.strings.endswith(AR_S, "a", 0, 9)  # E: incompatible type
+np.strings.startswith(AR_U, b"a", [1, 2, 3], [1, 2, 3])  # E: incompatible type
+np.strings.startswith(AR_S, "a", 0, 9)  # E: incompatible type
+
+np.strings.find(AR_U, b"a", [1, 2, 3], [1, 2, 3])  # E: incompatible type
+np.strings.find(AR_S, "a", 0, 9)  # E: incompatible type
+np.strings.rfind(AR_U, b"a", [1, 2, 3], [1, 2 , 3])  # E: incompatible type
+np.strings.rfind(AR_S, "a", 0, 9)  # E: incompatible type
+
+np.strings.index(AR_U, b"a", start=[1, 2, 3])  # E: incompatible type
+np.strings.index(AR_S, "a", end=9)  # E: incompatible type
+np.strings.rindex(AR_U, b"a", start=[1, 2, 3])  # E: incompatible type
+np.strings.rindex(AR_S, "a", end=9)  # E: incompatible type
+
+np.strings.isdecimal(AR_S)  # E: incompatible type
+np.strings.isnumeric(AR_S)  # E: incompatible type
+
+np.strings.replace(AR_U, b"_", b"-", 10)  # E: incompatible type
+np.strings.replace(AR_S, "_", "-", 1)  # E: incompatible type
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/testing.pyi b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/testing.pyi
new file mode 100644
index 00000000..803870e2
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/testing.pyi
@@ -0,0 +1,28 @@
+import numpy as np
+import numpy.typing as npt
+
+AR_U: npt.NDArray[np.str_]
+
+def func() -> bool: ...
+
+np.testing.assert_(True, msg=1)  # E: incompatible type
+np.testing.build_err_msg(1, "test")  # E: incompatible type
+np.testing.assert_almost_equal(AR_U, AR_U)  # E: incompatible type
+np.testing.assert_approx_equal([1, 2, 3], [1, 2, 3])  # E: incompatible type
+np.testing.assert_array_almost_equal(AR_U, AR_U)  # E: incompatible type
+np.testing.assert_array_less(AR_U, AR_U)  # E: incompatible type
+np.testing.assert_string_equal(b"a", b"a")  # E: incompatible type
+
+np.testing.assert_raises(expected_exception=TypeError, callable=func)  # E: No overload variant
+np.testing.assert_raises_regex(expected_exception=TypeError, expected_regex="T", callable=func)  # E: No overload variant
+
+np.testing.assert_allclose(AR_U, AR_U)  # E: incompatible type
+np.testing.assert_array_almost_equal_nulp(AR_U, AR_U)  # E: incompatible type
+np.testing.assert_array_max_ulp(AR_U, AR_U)  # E: incompatible type
+
+np.testing.assert_warns(warning_class=RuntimeWarning, func=func)  # E: No overload variant
+np.testing.assert_no_warnings(func=func)  # E: No overload variant
+np.testing.assert_no_warnings(func, None)  # E: Too many arguments
+np.testing.assert_no_warnings(func, test=None)  # E: Unexpected keyword argument
+
+np.testing.assert_no_gc_cycles(func=func)  # E: No overload variant
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/twodim_base.pyi b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/twodim_base.pyi
new file mode 100644
index 00000000..76186285
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/twodim_base.pyi
@@ -0,0 +1,37 @@
+from typing import Any, TypeVar
+
+import numpy as np
+import numpy.typing as npt
+
+
+def func1(ar: npt.NDArray[Any], a: int) -> npt.NDArray[np.str_]:
+    pass
+
+
+def func2(ar: npt.NDArray[Any], a: float) -> float:
+    pass
+
+
+AR_b: npt.NDArray[np.bool]
+AR_m: npt.NDArray[np.timedelta64]
+
+AR_LIKE_b: list[bool]
+
+np.eye(10, M=20.0)  # E: No overload variant
+np.eye(10, k=2.5, dtype=int)  # E: No overload variant
+
+np.diag(AR_b, k=0.5)  # E: No overload variant
+np.diagflat(AR_b, k=0.5)  # E: No overload variant
+
+np.tri(10, M=20.0)  # E: No overload variant
+np.tri(10, k=2.5, dtype=int)  # E: No overload variant
+
+np.tril(AR_b, k=0.5)  # E: No overload variant
+np.triu(AR_b, k=0.5)  # E: No overload variant
+
+np.vander(AR_m)  # E: incompatible type
+
+np.histogram2d(AR_m)  # E: No overload variant
+
+np.mask_indices(10, func1)  # E: incompatible type
+np.mask_indices(10, func2, 10.5)  # E: incompatible type
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/type_check.pyi b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/type_check.pyi
new file mode 100644
index 00000000..95f52bfb
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/type_check.pyi
@@ -0,0 +1,13 @@
+import numpy as np
+import numpy.typing as npt
+
+DTYPE_i8: np.dtype[np.int64]
+
+np.mintypecode(DTYPE_i8)  # E: incompatible type
+np.iscomplexobj(DTYPE_i8)  # E: incompatible type
+np.isrealobj(DTYPE_i8)  # E: incompatible type
+
+np.typename(DTYPE_i8)  # E: No overload variant
+np.typename("invalid")  # E: No overload variant
+
+np.common_type(np.timedelta64())  # E: incompatible type
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/ufunc_config.pyi b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/ufunc_config.pyi
new file mode 100644
index 00000000..b080804b
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/ufunc_config.pyi
@@ -0,0 +1,21 @@
+"""Typing tests for `numpy._core._ufunc_config`."""
+
+import numpy as np
+
+def func1(a: str, b: int, c: float) -> None: ...
+def func2(a: str, *, b: int) -> None: ...
+
+class Write1:
+    def write1(self, a: str) -> None: ...
+
+class Write2:
+    def write(self, a: str, b: str) -> None: ...
+
+class Write3:
+    def write(self, *, a: str) -> None: ...
+
+np.seterrcall(func1)  # E: Argument 1 to "seterrcall" has incompatible type
+np.seterrcall(func2)  # E: Argument 1 to "seterrcall" has incompatible type
+np.seterrcall(Write1())  # E: Argument 1 to "seterrcall" has incompatible type
+np.seterrcall(Write2())  # E: Argument 1 to "seterrcall" has incompatible type
+np.seterrcall(Write3())  # E: Argument 1 to "seterrcall" has incompatible type
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/ufunclike.pyi b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/ufunclike.pyi
new file mode 100644
index 00000000..be5e6a15
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/ufunclike.pyi
@@ -0,0 +1,21 @@
+import numpy as np
+import numpy.typing as npt
+
+AR_c: npt.NDArray[np.complex128]
+AR_m: npt.NDArray[np.timedelta64]
+AR_M: npt.NDArray[np.datetime64]
+AR_O: npt.NDArray[np.object_]
+
+np.fix(AR_c)  # E: incompatible type
+np.fix(AR_m)  # E: incompatible type
+np.fix(AR_M)  # E: incompatible type
+
+np.isposinf(AR_c)  # E: incompatible type
+np.isposinf(AR_m)  # E: incompatible type
+np.isposinf(AR_M)  # E: incompatible type
+np.isposinf(AR_O)  # E: incompatible type
+
+np.isneginf(AR_c)  # E: incompatible type
+np.isneginf(AR_m)  # E: incompatible type
+np.isneginf(AR_M)  # E: incompatible type
+np.isneginf(AR_O)  # E: incompatible type
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/ufuncs.pyi b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/ufuncs.pyi
new file mode 100644
index 00000000..bbab0dfe
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/ufuncs.pyi
@@ -0,0 +1,17 @@
+import numpy as np
+import numpy.typing as npt
+
+AR_f8: npt.NDArray[np.float64]
+
+np.sin.nin + "foo"  # E: Unsupported operand types
+np.sin(1, foo="bar")  # E: No overload variant
+
+np.abs(None)  # E: No overload variant
+
+np.add(1, 1, 1)  # E: No overload variant
+np.add(1, 1, axis=0)  # E: No overload variant
+
+np.matmul(AR_f8, AR_f8, where=True)  # E: No overload variant
+
+np.frexp(AR_f8, out=None)  # E: No overload variant
+np.frexp(AR_f8, out=AR_f8)  # E: No overload variant
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/warnings_and_errors.pyi b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/warnings_and_errors.pyi
new file mode 100644
index 00000000..fae96d6b
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/fail/warnings_and_errors.pyi
@@ -0,0 +1,5 @@
+import numpy.exceptions as ex
+
+ex.AxisError(1.0)  # E: No overload variant
+ex.AxisError(1, ndim=2.0)  # E: No overload variant
+ex.AxisError(2, msg_prefix=404)  # E: No overload variant
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/misc/extended_precision.pyi b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/misc/extended_precision.pyi
new file mode 100644
index 00000000..78d8d93c
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/misc/extended_precision.pyi
@@ -0,0 +1,25 @@
+import sys
+
+import numpy as np
+from numpy._typing import _80Bit, _96Bit, _128Bit, _256Bit
+
+if sys.version_info >= (3, 11):
+    from typing import assert_type
+else:
+    from typing_extensions import assert_type
+
+assert_type(np.uint128(), np.unsignedinteger[_128Bit])
+assert_type(np.uint256(), np.unsignedinteger[_256Bit])
+
+assert_type(np.int128(), np.signedinteger[_128Bit])
+assert_type(np.int256(), np.signedinteger[_256Bit])
+
+assert_type(np.float80(), np.floating[_80Bit])
+assert_type(np.float96(), np.floating[_96Bit])
+assert_type(np.float128(), np.floating[_128Bit])
+assert_type(np.float256(), np.floating[_256Bit])
+
+assert_type(np.complex160(), np.complexfloating[_80Bit, _80Bit])
+assert_type(np.complex192(), np.complexfloating[_96Bit, _96Bit])
+assert_type(np.complex256(), np.complexfloating[_128Bit, _128Bit])
+assert_type(np.complex512(), np.complexfloating[_256Bit, _256Bit])
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/mypy.ini b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/mypy.ini
new file mode 100644
index 00000000..75530120
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/mypy.ini
@@ -0,0 +1,7 @@
+[mypy]
+plugins = numpy.typing.mypy_plugin
+show_absolute_path = True
+implicit_reexport = False
+pretty = True
+disallow_any_unimported = True
+disallow_any_generics = True
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/__pycache__/arithmetic.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/__pycache__/arithmetic.cpython-312.pyc
new file mode 100644
index 00000000..369197f2
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/__pycache__/arithmetic.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/__pycache__/array_constructors.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/__pycache__/array_constructors.cpython-312.pyc
new file mode 100644
index 00000000..62ebdc19
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/__pycache__/array_constructors.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/__pycache__/array_like.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/__pycache__/array_like.cpython-312.pyc
new file mode 100644
index 00000000..870c492e
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/__pycache__/array_like.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/__pycache__/arrayprint.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/__pycache__/arrayprint.cpython-312.pyc
new file mode 100644
index 00000000..326cffed
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/__pycache__/arrayprint.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/__pycache__/arrayterator.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/__pycache__/arrayterator.cpython-312.pyc
new file mode 100644
index 00000000..0773dc85
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/__pycache__/arrayterator.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/__pycache__/bitwise_ops.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/__pycache__/bitwise_ops.cpython-312.pyc
new file mode 100644
index 00000000..f2356ef2
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/__pycache__/bitwise_ops.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/__pycache__/comparisons.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/__pycache__/comparisons.cpython-312.pyc
new file mode 100644
index 00000000..54b31b18
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/__pycache__/comparisons.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/__pycache__/dtype.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/__pycache__/dtype.cpython-312.pyc
new file mode 100644
index 00000000..a7c75004
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/__pycache__/dtype.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/__pycache__/einsumfunc.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/__pycache__/einsumfunc.cpython-312.pyc
new file mode 100644
index 00000000..bb57b87b
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/__pycache__/einsumfunc.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/__pycache__/flatiter.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/__pycache__/flatiter.cpython-312.pyc
new file mode 100644
index 00000000..84de6df2
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/__pycache__/flatiter.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/__pycache__/fromnumeric.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/__pycache__/fromnumeric.cpython-312.pyc
new file mode 100644
index 00000000..eda48342
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/__pycache__/fromnumeric.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/__pycache__/index_tricks.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/__pycache__/index_tricks.cpython-312.pyc
new file mode 100644
index 00000000..965d71d8
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/__pycache__/index_tricks.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/__pycache__/lib_utils.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/__pycache__/lib_utils.cpython-312.pyc
new file mode 100644
index 00000000..fcb0b9d3
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/__pycache__/lib_utils.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/__pycache__/lib_version.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/__pycache__/lib_version.cpython-312.pyc
new file mode 100644
index 00000000..69b9acb6
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/__pycache__/lib_version.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/__pycache__/literal.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/__pycache__/literal.cpython-312.pyc
new file mode 100644
index 00000000..77b818c0
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/__pycache__/literal.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/__pycache__/ma.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/__pycache__/ma.cpython-312.pyc
new file mode 100644
index 00000000..694c3e20
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/__pycache__/ma.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/__pycache__/mod.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/__pycache__/mod.cpython-312.pyc
new file mode 100644
index 00000000..46f264be
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/__pycache__/mod.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/__pycache__/modules.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/__pycache__/modules.cpython-312.pyc
new file mode 100644
index 00000000..89282aea
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/__pycache__/modules.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/__pycache__/multiarray.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/__pycache__/multiarray.cpython-312.pyc
new file mode 100644
index 00000000..a3d2fd52
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/__pycache__/multiarray.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/__pycache__/ndarray_conversion.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/__pycache__/ndarray_conversion.cpython-312.pyc
new file mode 100644
index 00000000..90dd0e51
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/__pycache__/ndarray_conversion.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/__pycache__/ndarray_misc.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/__pycache__/ndarray_misc.cpython-312.pyc
new file mode 100644
index 00000000..74993fc4
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/__pycache__/ndarray_misc.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/__pycache__/ndarray_shape_manipulation.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/__pycache__/ndarray_shape_manipulation.cpython-312.pyc
new file mode 100644
index 00000000..0426b77a
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/__pycache__/ndarray_shape_manipulation.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/__pycache__/numeric.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/__pycache__/numeric.cpython-312.pyc
new file mode 100644
index 00000000..59ad717d
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/__pycache__/numeric.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/__pycache__/numerictypes.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/__pycache__/numerictypes.cpython-312.pyc
new file mode 100644
index 00000000..3d907ceb
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/__pycache__/numerictypes.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/__pycache__/random.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/__pycache__/random.cpython-312.pyc
new file mode 100644
index 00000000..87a816a7
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/__pycache__/random.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/__pycache__/scalars.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/__pycache__/scalars.cpython-312.pyc
new file mode 100644
index 00000000..8d3ff222
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/__pycache__/scalars.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/__pycache__/shape.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/__pycache__/shape.cpython-312.pyc
new file mode 100644
index 00000000..77856496
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/__pycache__/shape.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/__pycache__/simple.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/__pycache__/simple.cpython-312.pyc
new file mode 100644
index 00000000..156596fb
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/__pycache__/simple.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/__pycache__/simple_py3.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/__pycache__/simple_py3.cpython-312.pyc
new file mode 100644
index 00000000..a4699e2f
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/__pycache__/simple_py3.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/__pycache__/ufunc_config.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/__pycache__/ufunc_config.cpython-312.pyc
new file mode 100644
index 00000000..c97e6858
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/__pycache__/ufunc_config.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/__pycache__/ufunclike.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/__pycache__/ufunclike.cpython-312.pyc
new file mode 100644
index 00000000..9d8ec9f4
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/__pycache__/ufunclike.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/__pycache__/ufuncs.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/__pycache__/ufuncs.cpython-312.pyc
new file mode 100644
index 00000000..d1389992
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/__pycache__/ufuncs.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/__pycache__/warnings_and_errors.cpython-312.pyc b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/__pycache__/warnings_and_errors.cpython-312.pyc
new file mode 100644
index 00000000..ec61dbc5
Binary files /dev/null and b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/__pycache__/warnings_and_errors.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/arithmetic.py b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/arithmetic.py
new file mode 100644
index 00000000..4ac4e957
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/arithmetic.py
@@ -0,0 +1,595 @@
+from __future__ import annotations
+
+from typing import Any
+import numpy as np
+import pytest
+
+c16 = np.complex128(1)
+f8 = np.float64(1)
+i8 = np.int64(1)
+u8 = np.uint64(1)
+
+c8 = np.complex64(1)
+f4 = np.float32(1)
+i4 = np.int32(1)
+u4 = np.uint32(1)
+
+dt = np.datetime64(1, "D")
+td = np.timedelta64(1, "D")
+
+b_ = np.bool(1)
+
+b = bool(1)
+c = complex(1)
+f = float(1)
+i = int(1)
+
+
+class Object:
+    def __array__(self, dtype: np.typing.DTypeLike = None,
+                  copy: bool | None = None) -> np.ndarray[Any, np.dtype[np.object_]]:
+        ret = np.empty((), dtype=object)
+        ret[()] = self
+        return ret
+
+    def __sub__(self, value: Any) -> Object:
+        return self
+
+    def __rsub__(self, value: Any) -> Object:
+        return self
+
+    def __floordiv__(self, value: Any) -> Object:
+        return self
+
+    def __rfloordiv__(self, value: Any) -> Object:
+        return self
+
+    def __mul__(self, value: Any) -> Object:
+        return self
+
+    def __rmul__(self, value: Any) -> Object:
+        return self
+
+    def __pow__(self, value: Any) -> Object:
+        return self
+
+    def __rpow__(self, value: Any) -> Object:
+        return self
+
+
+AR_b: np.ndarray[Any, np.dtype[np.bool]] = np.array([True])
+AR_u: np.ndarray[Any, np.dtype[np.uint32]] = np.array([1], dtype=np.uint32)
+AR_i: np.ndarray[Any, np.dtype[np.int64]] = np.array([1])
+AR_f: np.ndarray[Any, np.dtype[np.float64]] = np.array([1.0])
+AR_c: np.ndarray[Any, np.dtype[np.complex128]] = np.array([1j])
+AR_m: np.ndarray[Any, np.dtype[np.timedelta64]] = np.array([np.timedelta64(1, "D")])
+AR_M: np.ndarray[Any, np.dtype[np.datetime64]] = np.array([np.datetime64(1, "D")])
+AR_O: np.ndarray[Any, np.dtype[np.object_]] = np.array([Object()])
+
+AR_LIKE_b = [True]
+AR_LIKE_u = [np.uint32(1)]
+AR_LIKE_i = [1]
+AR_LIKE_f = [1.0]
+AR_LIKE_c = [1j]
+AR_LIKE_m = [np.timedelta64(1, "D")]
+AR_LIKE_M = [np.datetime64(1, "D")]
+AR_LIKE_O = [Object()]
+
+# Array subtractions
+
+AR_b - AR_LIKE_u
+AR_b - AR_LIKE_i
+AR_b - AR_LIKE_f
+AR_b - AR_LIKE_c
+AR_b - AR_LIKE_m
+AR_b - AR_LIKE_O
+
+AR_LIKE_u - AR_b
+AR_LIKE_i - AR_b
+AR_LIKE_f - AR_b
+AR_LIKE_c - AR_b
+AR_LIKE_m - AR_b
+AR_LIKE_M - AR_b
+AR_LIKE_O - AR_b
+
+AR_u - AR_LIKE_b
+AR_u - AR_LIKE_u
+AR_u - AR_LIKE_i
+AR_u - AR_LIKE_f
+AR_u - AR_LIKE_c
+AR_u - AR_LIKE_m
+AR_u - AR_LIKE_O
+
+AR_LIKE_b - AR_u
+AR_LIKE_u - AR_u
+AR_LIKE_i - AR_u
+AR_LIKE_f - AR_u
+AR_LIKE_c - AR_u
+AR_LIKE_m - AR_u
+AR_LIKE_M - AR_u
+AR_LIKE_O - AR_u
+
+AR_i - AR_LIKE_b
+AR_i - AR_LIKE_u
+AR_i - AR_LIKE_i
+AR_i - AR_LIKE_f
+AR_i - AR_LIKE_c
+AR_i - AR_LIKE_m
+AR_i - AR_LIKE_O
+
+AR_LIKE_b - AR_i
+AR_LIKE_u - AR_i
+AR_LIKE_i - AR_i
+AR_LIKE_f - AR_i
+AR_LIKE_c - AR_i
+AR_LIKE_m - AR_i
+AR_LIKE_M - AR_i
+AR_LIKE_O - AR_i
+
+AR_f - AR_LIKE_b
+AR_f - AR_LIKE_u
+AR_f - AR_LIKE_i
+AR_f - AR_LIKE_f
+AR_f - AR_LIKE_c
+AR_f - AR_LIKE_O
+
+AR_LIKE_b - AR_f
+AR_LIKE_u - AR_f
+AR_LIKE_i - AR_f
+AR_LIKE_f - AR_f
+AR_LIKE_c - AR_f
+AR_LIKE_O - AR_f
+
+AR_c - AR_LIKE_b
+AR_c - AR_LIKE_u
+AR_c - AR_LIKE_i
+AR_c - AR_LIKE_f
+AR_c - AR_LIKE_c
+AR_c - AR_LIKE_O
+
+AR_LIKE_b - AR_c
+AR_LIKE_u - AR_c
+AR_LIKE_i - AR_c
+AR_LIKE_f - AR_c
+AR_LIKE_c - AR_c
+AR_LIKE_O - AR_c
+
+AR_m - AR_LIKE_b
+AR_m - AR_LIKE_u
+AR_m - AR_LIKE_i
+AR_m - AR_LIKE_m
+
+AR_LIKE_b - AR_m
+AR_LIKE_u - AR_m
+AR_LIKE_i - AR_m
+AR_LIKE_m - AR_m
+AR_LIKE_M - AR_m
+
+AR_M - AR_LIKE_b
+AR_M - AR_LIKE_u
+AR_M - AR_LIKE_i
+AR_M - AR_LIKE_m
+AR_M - AR_LIKE_M
+
+AR_LIKE_M - AR_M
+
+AR_O - AR_LIKE_b
+AR_O - AR_LIKE_u
+AR_O - AR_LIKE_i
+AR_O - AR_LIKE_f
+AR_O - AR_LIKE_c
+AR_O - AR_LIKE_O
+
+AR_LIKE_b - AR_O
+AR_LIKE_u - AR_O
+AR_LIKE_i - AR_O
+AR_LIKE_f - AR_O
+AR_LIKE_c - AR_O
+AR_LIKE_O - AR_O
+
+AR_u += AR_b
+AR_u += AR_u
+AR_u += 1  # Allowed during runtime as long as the object is 0D and >=0
+
+# Array floor division
+
+AR_b // AR_LIKE_b
+AR_b // AR_LIKE_u
+AR_b // AR_LIKE_i
+AR_b // AR_LIKE_f
+AR_b // AR_LIKE_O
+
+AR_LIKE_b // AR_b
+AR_LIKE_u // AR_b
+AR_LIKE_i // AR_b
+AR_LIKE_f // AR_b
+AR_LIKE_O // AR_b
+
+AR_u // AR_LIKE_b
+AR_u // AR_LIKE_u
+AR_u // AR_LIKE_i
+AR_u // AR_LIKE_f
+AR_u // AR_LIKE_O
+
+AR_LIKE_b // AR_u
+AR_LIKE_u // AR_u
+AR_LIKE_i // AR_u
+AR_LIKE_f // AR_u
+AR_LIKE_m // AR_u
+AR_LIKE_O // AR_u
+
+AR_i // AR_LIKE_b
+AR_i // AR_LIKE_u
+AR_i // AR_LIKE_i
+AR_i // AR_LIKE_f
+AR_i // AR_LIKE_O
+
+AR_LIKE_b // AR_i
+AR_LIKE_u // AR_i
+AR_LIKE_i // AR_i
+AR_LIKE_f // AR_i
+AR_LIKE_m // AR_i
+AR_LIKE_O // AR_i
+
+AR_f // AR_LIKE_b
+AR_f // AR_LIKE_u
+AR_f // AR_LIKE_i
+AR_f // AR_LIKE_f
+AR_f // AR_LIKE_O
+
+AR_LIKE_b // AR_f
+AR_LIKE_u // AR_f
+AR_LIKE_i // AR_f
+AR_LIKE_f // AR_f
+AR_LIKE_m // AR_f
+AR_LIKE_O // AR_f
+
+AR_m // AR_LIKE_u
+AR_m // AR_LIKE_i
+AR_m // AR_LIKE_f
+AR_m // AR_LIKE_m
+
+AR_LIKE_m // AR_m
+
+AR_O // AR_LIKE_b
+AR_O // AR_LIKE_u
+AR_O // AR_LIKE_i
+AR_O // AR_LIKE_f
+AR_O // AR_LIKE_O
+
+AR_LIKE_b // AR_O
+AR_LIKE_u // AR_O
+AR_LIKE_i // AR_O
+AR_LIKE_f // AR_O
+AR_LIKE_O // AR_O
+
+# Inplace multiplication
+
+AR_b *= AR_LIKE_b
+
+AR_u *= AR_LIKE_b
+AR_u *= AR_LIKE_u
+
+AR_i *= AR_LIKE_b
+AR_i *= AR_LIKE_u
+AR_i *= AR_LIKE_i
+
+AR_f *= AR_LIKE_b
+AR_f *= AR_LIKE_u
+AR_f *= AR_LIKE_i
+AR_f *= AR_LIKE_f
+
+AR_c *= AR_LIKE_b
+AR_c *= AR_LIKE_u
+AR_c *= AR_LIKE_i
+AR_c *= AR_LIKE_f
+AR_c *= AR_LIKE_c
+
+AR_m *= AR_LIKE_b
+AR_m *= AR_LIKE_u
+AR_m *= AR_LIKE_i
+AR_m *= AR_LIKE_f
+
+AR_O *= AR_LIKE_b
+AR_O *= AR_LIKE_u
+AR_O *= AR_LIKE_i
+AR_O *= AR_LIKE_f
+AR_O *= AR_LIKE_c
+AR_O *= AR_LIKE_O
+
+# Inplace power
+
+AR_u **= AR_LIKE_b
+AR_u **= AR_LIKE_u
+
+AR_i **= AR_LIKE_b
+AR_i **= AR_LIKE_u
+AR_i **= AR_LIKE_i
+
+AR_f **= AR_LIKE_b
+AR_f **= AR_LIKE_u
+AR_f **= AR_LIKE_i
+AR_f **= AR_LIKE_f
+
+AR_c **= AR_LIKE_b
+AR_c **= AR_LIKE_u
+AR_c **= AR_LIKE_i
+AR_c **= AR_LIKE_f
+AR_c **= AR_LIKE_c
+
+AR_O **= AR_LIKE_b
+AR_O **= AR_LIKE_u
+AR_O **= AR_LIKE_i
+AR_O **= AR_LIKE_f
+AR_O **= AR_LIKE_c
+AR_O **= AR_LIKE_O
+
+# unary ops
+
+-c16
+-c8
+-f8
+-f4
+-i8
+-i4
+with pytest.warns(RuntimeWarning):
+    -u8
+    -u4
+-td
+-AR_f
+
++c16
++c8
++f8
++f4
++i8
++i4
++u8
++u4
++td
++AR_f
+
+abs(c16)
+abs(c8)
+abs(f8)
+abs(f4)
+abs(i8)
+abs(i4)
+abs(u8)
+abs(u4)
+abs(td)
+abs(b_)
+abs(AR_f)
+
+# Time structures
+
+dt + td
+dt + i
+dt + i4
+dt + i8
+dt - dt
+dt - i
+dt - i4
+dt - i8
+
+td + td
+td + i
+td + i4
+td + i8
+td - td
+td - i
+td - i4
+td - i8
+td / f
+td / f4
+td / f8
+td / td
+td // td
+td % td
+
+
+# boolean
+
+b_ / b
+b_ / b_
+b_ / i
+b_ / i8
+b_ / i4
+b_ / u8
+b_ / u4
+b_ / f
+b_ / f8
+b_ / f4
+b_ / c
+b_ / c16
+b_ / c8
+
+b / b_
+b_ / b_
+i / b_
+i8 / b_
+i4 / b_
+u8 / b_
+u4 / b_
+f / b_
+f8 / b_
+f4 / b_
+c / b_
+c16 / b_
+c8 / b_
+
+# Complex
+
+c16 + c16
+c16 + f8
+c16 + i8
+c16 + c8
+c16 + f4
+c16 + i4
+c16 + b_
+c16 + b
+c16 + c
+c16 + f
+c16 + i
+c16 + AR_f
+
+c16 + c16
+f8 + c16
+i8 + c16
+c8 + c16
+f4 + c16
+i4 + c16
+b_ + c16
+b + c16
+c + c16
+f + c16
+i + c16
+AR_f + c16
+
+c8 + c16
+c8 + f8
+c8 + i8
+c8 + c8
+c8 + f4
+c8 + i4
+c8 + b_
+c8 + b
+c8 + c
+c8 + f
+c8 + i
+c8 + AR_f
+
+c16 + c8
+f8 + c8
+i8 + c8
+c8 + c8
+f4 + c8
+i4 + c8
+b_ + c8
+b + c8
+c + c8
+f + c8
+i + c8
+AR_f + c8
+
+# Float
+
+f8 + f8
+f8 + i8
+f8 + f4
+f8 + i4
+f8 + b_
+f8 + b
+f8 + c
+f8 + f
+f8 + i
+f8 + AR_f
+
+f8 + f8
+i8 + f8
+f4 + f8
+i4 + f8
+b_ + f8
+b + f8
+c + f8
+f + f8
+i + f8
+AR_f + f8
+
+f4 + f8
+f4 + i8
+f4 + f4
+f4 + i4
+f4 + b_
+f4 + b
+f4 + c
+f4 + f
+f4 + i
+f4 + AR_f
+
+f8 + f4
+i8 + f4
+f4 + f4
+i4 + f4
+b_ + f4
+b + f4
+c + f4
+f + f4
+i + f4
+AR_f + f4
+
+# Int
+
+i8 + i8
+i8 + u8
+i8 + i4
+i8 + u4
+i8 + b_
+i8 + b
+i8 + c
+i8 + f
+i8 + i
+i8 + AR_f
+
+u8 + u8
+u8 + i4
+u8 + u4
+u8 + b_
+u8 + b
+u8 + c
+u8 + f
+u8 + i
+u8 + AR_f
+
+i8 + i8
+u8 + i8
+i4 + i8
+u4 + i8
+b_ + i8
+b + i8
+c + i8
+f + i8
+i + i8
+AR_f + i8
+
+u8 + u8
+i4 + u8
+u4 + u8
+b_ + u8
+b + u8
+c + u8
+f + u8
+i + u8
+AR_f + u8
+
+i4 + i8
+i4 + i4
+i4 + i
+i4 + b_
+i4 + b
+i4 + AR_f
+
+u4 + i8
+u4 + i4
+u4 + u8
+u4 + u4
+u4 + i
+u4 + b_
+u4 + b
+u4 + AR_f
+
+i8 + i4
+i4 + i4
+i + i4
+b_ + i4
+b + i4
+AR_f + i4
+
+i8 + u4
+i4 + u4
+u8 + u4
+u4 + u4
+b_ + u4
+b + u4
+i + u4
+AR_f + u4
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/array_constructors.py b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/array_constructors.py
new file mode 100644
index 00000000..17b6fab9
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/array_constructors.py
@@ -0,0 +1,137 @@
+from typing import Any
+
+import numpy as np
+import numpy.typing as npt
+
+class Index:
+    def __index__(self) -> int:
+        return 0
+
+
+class SubClass(npt.NDArray[np.float64]):
+    pass
+
+
+def func(i: int, j: int, **kwargs: Any) -> SubClass:
+    return B
+
+
+i8 = np.int64(1)
+
+A = np.array([1])
+B = A.view(SubClass).copy()
+B_stack = np.array([[1], [1]]).view(SubClass)
+C = [1]
+
+np.ndarray(Index())
+np.ndarray([Index()])
+
+np.array(1, dtype=float)
+np.array(1, copy=None)
+np.array(1, order='F')
+np.array(1, order=None)
+np.array(1, subok=True)
+np.array(1, ndmin=3)
+np.array(1, str, copy=True, order='C', subok=False, ndmin=2)
+
+np.asarray(A)
+np.asarray(B)
+np.asarray(C)
+
+np.asanyarray(A)
+np.asanyarray(B)
+np.asanyarray(B, dtype=int)
+np.asanyarray(C)
+
+np.ascontiguousarray(A)
+np.ascontiguousarray(B)
+np.ascontiguousarray(C)
+
+np.asfortranarray(A)
+np.asfortranarray(B)
+np.asfortranarray(C)
+
+np.require(A)
+np.require(B)
+np.require(B, dtype=int)
+np.require(B, requirements=None)
+np.require(B, requirements="E")
+np.require(B, requirements=["ENSUREARRAY"])
+np.require(B, requirements={"F", "E"})
+np.require(B, requirements=["C", "OWNDATA"])
+np.require(B, requirements="W")
+np.require(B, requirements="A")
+np.require(C)
+
+np.linspace(0, 2)
+np.linspace(0.5, [0, 1, 2])
+np.linspace([0, 1, 2], 3)
+np.linspace(0j, 2)
+np.linspace(0, 2, num=10)
+np.linspace(0, 2, endpoint=True)
+np.linspace(0, 2, retstep=True)
+np.linspace(0j, 2j, retstep=True)
+np.linspace(0, 2, dtype=bool)
+np.linspace([0, 1], [2, 3], axis=Index())
+
+np.logspace(0, 2, base=2)
+np.logspace(0, 2, base=2)
+np.logspace(0, 2, base=[1j, 2j], num=2)
+
+np.geomspace(1, 2)
+
+np.zeros_like(A)
+np.zeros_like(C)
+np.zeros_like(B)
+np.zeros_like(B, dtype=np.int64)
+
+np.ones_like(A)
+np.ones_like(C)
+np.ones_like(B)
+np.ones_like(B, dtype=np.int64)
+
+np.empty_like(A)
+np.empty_like(C)
+np.empty_like(B)
+np.empty_like(B, dtype=np.int64)
+
+np.full_like(A, i8)
+np.full_like(C, i8)
+np.full_like(B, i8)
+np.full_like(B, i8, dtype=np.int64)
+
+np.ones(1)
+np.ones([1, 1, 1])
+
+np.full(1, i8)
+np.full([1, 1, 1], i8)
+
+np.indices([1, 2, 3])
+np.indices([1, 2, 3], sparse=True)
+
+np.fromfunction(func, (3, 5))
+
+np.identity(10)
+
+np.atleast_1d(C)
+np.atleast_1d(A)
+np.atleast_1d(C, C)
+np.atleast_1d(C, A)
+np.atleast_1d(A, A)
+
+np.atleast_2d(C)
+
+np.atleast_3d(C)
+
+np.vstack([C, C])
+np.vstack([C, A])
+np.vstack([A, A])
+
+np.hstack([C, C])
+
+np.stack([C, C])
+np.stack([C, C], axis=0)
+np.stack([C, C], out=B_stack)
+
+np.block([[C, C], [C, C]])
+np.block(A)
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/array_like.py b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/array_like.py
new file mode 100644
index 00000000..822e6a1d
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/array_like.py
@@ -0,0 +1,43 @@
+from __future__ import annotations
+
+from typing import Any
+
+import numpy as np
+from numpy._typing import NDArray, ArrayLike, _SupportsArray
+
+x1: ArrayLike = True
+x2: ArrayLike = 5
+x3: ArrayLike = 1.0
+x4: ArrayLike = 1 + 1j
+x5: ArrayLike = np.int8(1)
+x6: ArrayLike = np.float64(1)
+x7: ArrayLike = np.complex128(1)
+x8: ArrayLike = np.array([1, 2, 3])
+x9: ArrayLike = [1, 2, 3]
+x10: ArrayLike = (1, 2, 3)
+x11: ArrayLike = "foo"
+x12: ArrayLike = memoryview(b'foo')
+
+
+class A:
+    def __array__(
+        self, dtype: None | np.dtype[Any] = None
+    ) -> NDArray[np.float64]:
+        return np.array([1.0, 2.0, 3.0])
+
+
+x13: ArrayLike = A()
+
+scalar: _SupportsArray[np.dtype[np.int64]] = np.int64(1)
+scalar.__array__()
+array: _SupportsArray[np.dtype[np.int_]] = np.array(1)
+array.__array__()
+
+a: _SupportsArray[np.dtype[np.float64]] = A()
+a.__array__()
+a.__array__()
+
+# Escape hatch for when you mean to make something like an object
+# array.
+object_array_scalar: object = (i for i in range(10))
+np.array(object_array_scalar)
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/arrayprint.py b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/arrayprint.py
new file mode 100644
index 00000000..6c704c75
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/arrayprint.py
@@ -0,0 +1,37 @@
+import numpy as np
+
+AR = np.arange(10)
+AR.setflags(write=False)
+
+with np.printoptions():
+    np.set_printoptions(
+        precision=1,
+        threshold=2,
+        edgeitems=3,
+        linewidth=4,
+        suppress=False,
+        nanstr="Bob",
+        infstr="Bill",
+        formatter={},
+        sign="+",
+        floatmode="unique",
+    )
+    np.get_printoptions()
+    str(AR)
+
+    np.array2string(
+        AR,
+        max_line_width=5,
+        precision=2,
+        suppress_small=True,
+        separator=";",
+        prefix="test",
+        threshold=5,
+        floatmode="fixed",
+        suffix="?",
+        legacy="1.13",
+    )
+    np.format_float_scientific(1, precision=5)
+    np.format_float_positional(1, trim="k")
+    np.array_repr(AR)
+    np.array_str(AR)
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/arrayterator.py b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/arrayterator.py
new file mode 100644
index 00000000..572be5e2
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/arrayterator.py
@@ -0,0 +1,27 @@
+
+from __future__ import annotations
+
+from typing import Any
+import numpy as np
+
+AR_i8: np.ndarray[Any, np.dtype[np.int_]] = np.arange(10)
+ar_iter = np.lib.Arrayterator(AR_i8)
+
+ar_iter.var
+ar_iter.buf_size
+ar_iter.start
+ar_iter.stop
+ar_iter.step
+ar_iter.shape
+ar_iter.flat
+
+ar_iter.__array__()
+
+for i in ar_iter:
+    pass
+
+ar_iter[0]
+ar_iter[...]
+ar_iter[:]
+ar_iter[0, 0, 0]
+ar_iter[..., 0, :]
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/bitwise_ops.py b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/bitwise_ops.py
new file mode 100644
index 00000000..22a245d2
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/bitwise_ops.py
@@ -0,0 +1,131 @@
+import numpy as np
+
+i8 = np.int64(1)
+u8 = np.uint64(1)
+
+i4 = np.int32(1)
+u4 = np.uint32(1)
+
+b_ = np.bool(1)
+
+b = bool(1)
+i = int(1)
+
+AR = np.array([0, 1, 2], dtype=np.int32)
+AR.setflags(write=False)
+
+
+i8 << i8
+i8 >> i8
+i8 | i8
+i8 ^ i8
+i8 & i8
+
+i << AR
+i >> AR
+i | AR
+i ^ AR
+i & AR
+
+i8 << AR
+i8 >> AR
+i8 | AR
+i8 ^ AR
+i8 & AR
+
+i4 << i4
+i4 >> i4
+i4 | i4
+i4 ^ i4
+i4 & i4
+
+i8 << i4
+i8 >> i4
+i8 | i4
+i8 ^ i4
+i8 & i4
+
+i8 << i
+i8 >> i
+i8 | i
+i8 ^ i
+i8 & i
+
+i8 << b_
+i8 >> b_
+i8 | b_
+i8 ^ b_
+i8 & b_
+
+i8 << b
+i8 >> b
+i8 | b
+i8 ^ b
+i8 & b
+
+u8 << u8
+u8 >> u8
+u8 | u8
+u8 ^ u8
+u8 & u8
+
+u4 << u4
+u4 >> u4
+u4 | u4
+u4 ^ u4
+u4 & u4
+
+u4 << i4
+u4 >> i4
+u4 | i4
+u4 ^ i4
+u4 & i4
+
+u4 << i
+u4 >> i
+u4 | i
+u4 ^ i
+u4 & i
+
+u8 << b_
+u8 >> b_
+u8 | b_
+u8 ^ b_
+u8 & b_
+
+u8 << b
+u8 >> b
+u8 | b
+u8 ^ b
+u8 & b
+
+b_ << b_
+b_ >> b_
+b_ | b_
+b_ ^ b_
+b_ & b_
+
+b_ << AR
+b_ >> AR
+b_ | AR
+b_ ^ AR
+b_ & AR
+
+b_ << b
+b_ >> b
+b_ | b
+b_ ^ b
+b_ & b
+
+b_ << i
+b_ >> i
+b_ | i
+b_ ^ i
+b_ & i
+
+~i8
+~i4
+~u8
+~u4
+~b_
+~AR
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/comparisons.py b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/comparisons.py
new file mode 100644
index 00000000..0babc321
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/comparisons.py
@@ -0,0 +1,301 @@
+from __future__ import annotations
+
+from typing import Any
+import numpy as np
+
+c16 = np.complex128()
+f8 = np.float64()
+i8 = np.int64()
+u8 = np.uint64()
+
+c8 = np.complex64()
+f4 = np.float32()
+i4 = np.int32()
+u4 = np.uint32()
+
+dt = np.datetime64(0, "D")
+td = np.timedelta64(0, "D")
+
+b_ = np.bool()
+
+b = bool()
+c = complex()
+f = float()
+i = int()
+
+SEQ = (0, 1, 2, 3, 4)
+
+AR_b: np.ndarray[Any, np.dtype[np.bool]] = np.array([True])
+AR_u: np.ndarray[Any, np.dtype[np.uint32]] = np.array([1], dtype=np.uint32)
+AR_i: np.ndarray[Any, np.dtype[np.int_]] = np.array([1])
+AR_f: np.ndarray[Any, np.dtype[np.float64]] = np.array([1.0])
+AR_c: np.ndarray[Any, np.dtype[np.complex128]] = np.array([1.0j])
+AR_m: np.ndarray[Any, np.dtype[np.timedelta64]] = np.array([np.timedelta64("1")])
+AR_M: np.ndarray[Any, np.dtype[np.datetime64]] = np.array([np.datetime64("1")])
+AR_O: np.ndarray[Any, np.dtype[np.object_]] = np.array([1], dtype=object)
+
+# Arrays
+
+AR_b > AR_b
+AR_b > AR_u
+AR_b > AR_i
+AR_b > AR_f
+AR_b > AR_c
+
+AR_u > AR_b
+AR_u > AR_u
+AR_u > AR_i
+AR_u > AR_f
+AR_u > AR_c
+
+AR_i > AR_b
+AR_i > AR_u
+AR_i > AR_i
+AR_i > AR_f
+AR_i > AR_c
+
+AR_f > AR_b
+AR_f > AR_u
+AR_f > AR_i
+AR_f > AR_f
+AR_f > AR_c
+
+AR_c > AR_b
+AR_c > AR_u
+AR_c > AR_i
+AR_c > AR_f
+AR_c > AR_c
+
+AR_m > AR_b
+AR_m > AR_u
+AR_m > AR_i
+AR_b > AR_m
+AR_u > AR_m
+AR_i > AR_m
+
+AR_M > AR_M
+
+AR_O > AR_O
+1 > AR_O
+AR_O > 1
+
+# Time structures
+
+dt > dt
+
+td > td
+td > i
+td > i4
+td > i8
+td > AR_i
+td > SEQ
+
+# boolean
+
+b_ > b
+b_ > b_
+b_ > i
+b_ > i8
+b_ > i4
+b_ > u8
+b_ > u4
+b_ > f
+b_ > f8
+b_ > f4
+b_ > c
+b_ > c16
+b_ > c8
+b_ > AR_i
+b_ > SEQ
+
+# Complex
+
+c16 > c16
+c16 > f8
+c16 > i8
+c16 > c8
+c16 > f4
+c16 > i4
+c16 > b_
+c16 > b
+c16 > c
+c16 > f
+c16 > i
+c16 > AR_i
+c16 > SEQ
+
+c16 > c16
+f8 > c16
+i8 > c16
+c8 > c16
+f4 > c16
+i4 > c16
+b_ > c16
+b > c16
+c > c16
+f > c16
+i > c16
+AR_i > c16
+SEQ > c16
+
+c8 > c16
+c8 > f8
+c8 > i8
+c8 > c8
+c8 > f4
+c8 > i4
+c8 > b_
+c8 > b
+c8 > c
+c8 > f
+c8 > i
+c8 > AR_i
+c8 > SEQ
+
+c16 > c8
+f8 > c8
+i8 > c8
+c8 > c8
+f4 > c8
+i4 > c8
+b_ > c8
+b > c8
+c > c8
+f > c8
+i > c8
+AR_i > c8
+SEQ > c8
+
+# Float
+
+f8 > f8
+f8 > i8
+f8 > f4
+f8 > i4
+f8 > b_
+f8 > b
+f8 > c
+f8 > f
+f8 > i
+f8 > AR_i
+f8 > SEQ
+
+f8 > f8
+i8 > f8
+f4 > f8
+i4 > f8
+b_ > f8
+b > f8
+c > f8
+f > f8
+i > f8
+AR_i > f8
+SEQ > f8
+
+f4 > f8
+f4 > i8
+f4 > f4
+f4 > i4
+f4 > b_
+f4 > b
+f4 > c
+f4 > f
+f4 > i
+f4 > AR_i
+f4 > SEQ
+
+f8 > f4
+i8 > f4
+f4 > f4
+i4 > f4
+b_ > f4
+b > f4
+c > f4
+f > f4
+i > f4
+AR_i > f4
+SEQ > f4
+
+# Int
+
+i8 > i8
+i8 > u8
+i8 > i4
+i8 > u4
+i8 > b_
+i8 > b
+i8 > c
+i8 > f
+i8 > i
+i8 > AR_i
+i8 > SEQ
+
+u8 > u8
+u8 > i4
+u8 > u4
+u8 > b_
+u8 > b
+u8 > c
+u8 > f
+u8 > i
+u8 > AR_i
+u8 > SEQ
+
+i8 > i8
+u8 > i8
+i4 > i8
+u4 > i8
+b_ > i8
+b > i8
+c > i8
+f > i8
+i > i8
+AR_i > i8
+SEQ > i8
+
+u8 > u8
+i4 > u8
+u4 > u8
+b_ > u8
+b > u8
+c > u8
+f > u8
+i > u8
+AR_i > u8
+SEQ > u8
+
+i4 > i8
+i4 > i4
+i4 > i
+i4 > b_
+i4 > b
+i4 > AR_i
+i4 > SEQ
+
+u4 > i8
+u4 > i4
+u4 > u8
+u4 > u4
+u4 > i
+u4 > b_
+u4 > b
+u4 > AR_i
+u4 > SEQ
+
+i8 > i4
+i4 > i4
+i > i4
+b_ > i4
+b > i4
+AR_i > i4
+SEQ > i4
+
+i8 > u4
+i4 > u4
+u8 > u4
+u4 > u4
+b_ > u4
+b > u4
+i > u4
+AR_i > u4
+SEQ > u4
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/dtype.py b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/dtype.py
new file mode 100644
index 00000000..9f115182
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/dtype.py
@@ -0,0 +1,57 @@
+import numpy as np
+
+dtype_obj = np.dtype(np.str_)
+void_dtype_obj = np.dtype([("f0", np.float64), ("f1", np.float32)])
+
+np.dtype(dtype=np.int64)
+np.dtype(int)
+np.dtype("int")
+np.dtype(None)
+
+np.dtype((int, 2))
+np.dtype((int, (1,)))
+
+np.dtype({"names": ["a", "b"], "formats": [int, float]})
+np.dtype({"names": ["a"], "formats": [int], "titles": [object]})
+np.dtype({"names": ["a"], "formats": [int], "titles": [object()]})
+
+np.dtype([("name", np.str_, 16), ("grades", np.float64, (2,)), ("age", "int32")])
+
+np.dtype(
+    {
+        "names": ["a", "b"],
+        "formats": [int, float],
+        "itemsize": 9,
+        "aligned": False,
+        "titles": ["x", "y"],
+        "offsets": [0, 1],
+    }
+)
+
+np.dtype((np.float64, float))
+
+
+class Test:
+    dtype = np.dtype(float)
+
+
+np.dtype(Test())
+
+# Methods and attributes
+dtype_obj.base
+dtype_obj.subdtype
+dtype_obj.newbyteorder()
+dtype_obj.type
+dtype_obj.name
+dtype_obj.names
+
+dtype_obj * 0
+dtype_obj * 2
+
+0 * dtype_obj
+2 * dtype_obj
+
+void_dtype_obj["f0"]
+void_dtype_obj[0]
+void_dtype_obj[["f0", "f1"]]
+void_dtype_obj[["f0"]]
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/einsumfunc.py b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/einsumfunc.py
new file mode 100644
index 00000000..429764e6
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/einsumfunc.py
@@ -0,0 +1,36 @@
+from __future__ import annotations
+
+from typing import Any
+
+import numpy as np
+
+AR_LIKE_b = [True, True, True]
+AR_LIKE_u = [np.uint32(1), np.uint32(2), np.uint32(3)]
+AR_LIKE_i = [1, 2, 3]
+AR_LIKE_f = [1.0, 2.0, 3.0]
+AR_LIKE_c = [1j, 2j, 3j]
+AR_LIKE_U = ["1", "2", "3"]
+
+OUT_f: np.ndarray[Any, np.dtype[np.float64]] = np.empty(3, dtype=np.float64)
+OUT_c: np.ndarray[Any, np.dtype[np.complex128]] = np.empty(3, dtype=np.complex128)
+
+np.einsum("i,i->i", AR_LIKE_b, AR_LIKE_b)
+np.einsum("i,i->i", AR_LIKE_u, AR_LIKE_u)
+np.einsum("i,i->i", AR_LIKE_i, AR_LIKE_i)
+np.einsum("i,i->i", AR_LIKE_f, AR_LIKE_f)
+np.einsum("i,i->i", AR_LIKE_c, AR_LIKE_c)
+np.einsum("i,i->i", AR_LIKE_b, AR_LIKE_i)
+np.einsum("i,i,i,i->i", AR_LIKE_b, AR_LIKE_u, AR_LIKE_i, AR_LIKE_c)
+
+np.einsum("i,i->i", AR_LIKE_f, AR_LIKE_f, dtype="c16")
+np.einsum("i,i->i", AR_LIKE_U, AR_LIKE_U, dtype=bool, casting="unsafe")
+np.einsum("i,i->i", AR_LIKE_f, AR_LIKE_f, out=OUT_c)
+np.einsum("i,i->i", AR_LIKE_U, AR_LIKE_U, dtype=int, casting="unsafe", out=OUT_f)
+
+np.einsum_path("i,i->i", AR_LIKE_b, AR_LIKE_b)
+np.einsum_path("i,i->i", AR_LIKE_u, AR_LIKE_u)
+np.einsum_path("i,i->i", AR_LIKE_i, AR_LIKE_i)
+np.einsum_path("i,i->i", AR_LIKE_f, AR_LIKE_f)
+np.einsum_path("i,i->i", AR_LIKE_c, AR_LIKE_c)
+np.einsum_path("i,i->i", AR_LIKE_b, AR_LIKE_i)
+np.einsum_path("i,i,i,i->i", AR_LIKE_b, AR_LIKE_u, AR_LIKE_i, AR_LIKE_c)
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/flatiter.py b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/flatiter.py
new file mode 100644
index 00000000..63c839af
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/flatiter.py
@@ -0,0 +1,16 @@
+import numpy as np
+
+a = np.empty((2, 2)).flat
+
+a.base
+a.copy()
+a.coords
+a.index
+iter(a)
+next(a)
+a[0]
+a[[0, 1, 2]]
+a[...]
+a[:]
+a.__array__()
+a.__array__(np.dtype(np.float64))
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/fromnumeric.py b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/fromnumeric.py
new file mode 100644
index 00000000..7cc2bcfd
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/fromnumeric.py
@@ -0,0 +1,272 @@
+"""Tests for :mod:`numpy._core.fromnumeric`."""
+
+import numpy as np
+
+A = np.array(True, ndmin=2, dtype=bool)
+B = np.array(1.0, ndmin=2, dtype=np.float32)
+A.setflags(write=False)
+B.setflags(write=False)
+
+a = np.bool(True)
+b = np.float32(1.0)
+c = 1.0
+d = np.array(1.0, dtype=np.float32)  # writeable
+
+np.take(a, 0)
+np.take(b, 0)
+np.take(c, 0)
+np.take(A, 0)
+np.take(B, 0)
+np.take(A, [0])
+np.take(B, [0])
+
+np.reshape(a, 1)
+np.reshape(b, 1)
+np.reshape(c, 1)
+np.reshape(A, 1)
+np.reshape(B, 1)
+
+np.choose(a, [True, True])
+np.choose(A, [1.0, 1.0])
+
+np.repeat(a, 1)
+np.repeat(b, 1)
+np.repeat(c, 1)
+np.repeat(A, 1)
+np.repeat(B, 1)
+
+np.swapaxes(A, 0, 0)
+np.swapaxes(B, 0, 0)
+
+np.transpose(a)
+np.transpose(b)
+np.transpose(c)
+np.transpose(A)
+np.transpose(B)
+
+np.partition(a, 0, axis=None)
+np.partition(b, 0, axis=None)
+np.partition(c, 0, axis=None)
+np.partition(A, 0)
+np.partition(B, 0)
+
+np.argpartition(a, 0)
+np.argpartition(b, 0)
+np.argpartition(c, 0)
+np.argpartition(A, 0)
+np.argpartition(B, 0)
+
+np.sort(A, 0)
+np.sort(B, 0)
+
+np.argsort(A, 0)
+np.argsort(B, 0)
+
+np.argmax(A)
+np.argmax(B)
+np.argmax(A, axis=0)
+np.argmax(B, axis=0)
+
+np.argmin(A)
+np.argmin(B)
+np.argmin(A, axis=0)
+np.argmin(B, axis=0)
+
+np.searchsorted(A[0], 0)
+np.searchsorted(B[0], 0)
+np.searchsorted(A[0], [0])
+np.searchsorted(B[0], [0])
+
+np.resize(a, (5, 5))
+np.resize(b, (5, 5))
+np.resize(c, (5, 5))
+np.resize(A, (5, 5))
+np.resize(B, (5, 5))
+
+np.squeeze(a)
+np.squeeze(b)
+np.squeeze(c)
+np.squeeze(A)
+np.squeeze(B)
+
+np.diagonal(A)
+np.diagonal(B)
+
+np.trace(A)
+np.trace(B)
+
+np.ravel(a)
+np.ravel(b)
+np.ravel(c)
+np.ravel(A)
+np.ravel(B)
+
+np.nonzero(A)
+np.nonzero(B)
+
+np.shape(a)
+np.shape(b)
+np.shape(c)
+np.shape(A)
+np.shape(B)
+
+np.compress([True], a)
+np.compress([True], b)
+np.compress([True], c)
+np.compress([True], A)
+np.compress([True], B)
+
+np.clip(a, 0, 1.0)
+np.clip(b, -1, 1)
+np.clip(a, 0, None)
+np.clip(b, None, 1)
+np.clip(c, 0, 1)
+np.clip(A, 0, 1)
+np.clip(B, 0, 1)
+np.clip(B, [0, 1], [1, 2])
+
+np.sum(a)
+np.sum(b)
+np.sum(c)
+np.sum(A)
+np.sum(B)
+np.sum(A, axis=0)
+np.sum(B, axis=0)
+
+np.all(a)
+np.all(b)
+np.all(c)
+np.all(A)
+np.all(B)
+np.all(A, axis=0)
+np.all(B, axis=0)
+np.all(A, keepdims=True)
+np.all(B, keepdims=True)
+
+np.any(a)
+np.any(b)
+np.any(c)
+np.any(A)
+np.any(B)
+np.any(A, axis=0)
+np.any(B, axis=0)
+np.any(A, keepdims=True)
+np.any(B, keepdims=True)
+
+np.cumsum(a)
+np.cumsum(b)
+np.cumsum(c)
+np.cumsum(A)
+np.cumsum(B)
+
+np.cumulative_sum(a)
+np.cumulative_sum(b)
+np.cumulative_sum(c)
+np.cumulative_sum(A, axis=0)
+np.cumulative_sum(B, axis=0)
+
+np.ptp(b)
+np.ptp(c)
+np.ptp(B)
+np.ptp(B, axis=0)
+np.ptp(B, keepdims=True)
+
+np.amax(a)
+np.amax(b)
+np.amax(c)
+np.amax(A)
+np.amax(B)
+np.amax(A, axis=0)
+np.amax(B, axis=0)
+np.amax(A, keepdims=True)
+np.amax(B, keepdims=True)
+
+np.amin(a)
+np.amin(b)
+np.amin(c)
+np.amin(A)
+np.amin(B)
+np.amin(A, axis=0)
+np.amin(B, axis=0)
+np.amin(A, keepdims=True)
+np.amin(B, keepdims=True)
+
+np.prod(a)
+np.prod(b)
+np.prod(c)
+np.prod(A)
+np.prod(B)
+np.prod(a, dtype=None)
+np.prod(A, dtype=None)
+np.prod(A, axis=0)
+np.prod(B, axis=0)
+np.prod(A, keepdims=True)
+np.prod(B, keepdims=True)
+np.prod(b, out=d)
+np.prod(B, out=d)
+
+np.cumprod(a)
+np.cumprod(b)
+np.cumprod(c)
+np.cumprod(A)
+np.cumprod(B)
+
+np.cumulative_prod(a)
+np.cumulative_prod(b)
+np.cumulative_prod(c)
+np.cumulative_prod(A, axis=0)
+np.cumulative_prod(B, axis=0)
+
+np.ndim(a)
+np.ndim(b)
+np.ndim(c)
+np.ndim(A)
+np.ndim(B)
+
+np.size(a)
+np.size(b)
+np.size(c)
+np.size(A)
+np.size(B)
+
+np.around(a)
+np.around(b)
+np.around(c)
+np.around(A)
+np.around(B)
+
+np.mean(a)
+np.mean(b)
+np.mean(c)
+np.mean(A)
+np.mean(B)
+np.mean(A, axis=0)
+np.mean(B, axis=0)
+np.mean(A, keepdims=True)
+np.mean(B, keepdims=True)
+np.mean(b, out=d)
+np.mean(B, out=d)
+
+np.std(a)
+np.std(b)
+np.std(c)
+np.std(A)
+np.std(B)
+np.std(A, axis=0)
+np.std(B, axis=0)
+np.std(A, keepdims=True)
+np.std(B, keepdims=True)
+np.std(b, out=d)
+np.std(B, out=d)
+
+np.var(a)
+np.var(b)
+np.var(c)
+np.var(A)
+np.var(B)
+np.var(A, axis=0)
+np.var(B, axis=0)
+np.var(A, keepdims=True)
+np.var(B, keepdims=True)
+np.var(b, out=d)
+np.var(B, out=d)
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/index_tricks.py b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/index_tricks.py
new file mode 100644
index 00000000..4c4c1195
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/index_tricks.py
@@ -0,0 +1,64 @@
+from __future__ import annotations
+from typing import Any
+import numpy as np
+
+AR_LIKE_b = [[True, True], [True, True]]
+AR_LIKE_i = [[1, 2], [3, 4]]
+AR_LIKE_f = [[1.0, 2.0], [3.0, 4.0]]
+AR_LIKE_U = [["1", "2"], ["3", "4"]]
+
+AR_i8: np.ndarray[Any, np.dtype[np.int64]] = np.array(AR_LIKE_i, dtype=np.int64)
+
+np.ndenumerate(AR_i8)
+np.ndenumerate(AR_LIKE_f)
+np.ndenumerate(AR_LIKE_U)
+
+np.ndenumerate(AR_i8).iter
+np.ndenumerate(AR_LIKE_f).iter
+np.ndenumerate(AR_LIKE_U).iter
+
+next(np.ndenumerate(AR_i8))
+next(np.ndenumerate(AR_LIKE_f))
+next(np.ndenumerate(AR_LIKE_U))
+
+iter(np.ndenumerate(AR_i8))
+iter(np.ndenumerate(AR_LIKE_f))
+iter(np.ndenumerate(AR_LIKE_U))
+
+iter(np.ndindex(1, 2, 3))
+next(np.ndindex(1, 2, 3))
+
+np.unravel_index([22, 41, 37], (7, 6))
+np.unravel_index([31, 41, 13], (7, 6), order='F')
+np.unravel_index(1621, (6, 7, 8, 9))
+
+np.ravel_multi_index(AR_LIKE_i, (7, 6))
+np.ravel_multi_index(AR_LIKE_i, (7, 6), order='F')
+np.ravel_multi_index(AR_LIKE_i, (4, 6), mode='clip')
+np.ravel_multi_index(AR_LIKE_i, (4, 4), mode=('clip', 'wrap'))
+np.ravel_multi_index((3, 1, 4, 1), (6, 7, 8, 9))
+
+np.mgrid[1:1:2]
+np.mgrid[1:1:2, None:10]
+
+np.ogrid[1:1:2]
+np.ogrid[1:1:2, None:10]
+
+np.index_exp[0:1]
+np.index_exp[0:1, None:3]
+np.index_exp[0, 0:1, ..., [0, 1, 3]]
+
+np.s_[0:1]
+np.s_[0:1, None:3]
+np.s_[0, 0:1, ..., [0, 1, 3]]
+
+np.ix_(AR_LIKE_b[0])
+np.ix_(AR_LIKE_i[0], AR_LIKE_f[0])
+np.ix_(AR_i8[0])
+
+np.fill_diagonal(AR_i8, 5)
+
+np.diag_indices(4)
+np.diag_indices(2, 3)
+
+np.diag_indices_from(AR_i8)
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/lib_utils.py b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/lib_utils.py
new file mode 100644
index 00000000..f9b3381e
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/lib_utils.py
@@ -0,0 +1,19 @@
+from __future__ import annotations
+
+from io import StringIO
+
+import numpy as np
+import numpy.lib.array_utils as array_utils
+
+FILE = StringIO()
+AR = np.arange(10, dtype=np.float64)
+
+
+def func(a: int) -> bool:
+    return True
+
+
+array_utils.byte_bounds(AR)
+array_utils.byte_bounds(np.float64())
+
+np.info(1, output=FILE)
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/lib_version.py b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/lib_version.py
new file mode 100644
index 00000000..f3825eca
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/lib_version.py
@@ -0,0 +1,18 @@
+from numpy.lib import NumpyVersion
+
+version = NumpyVersion("1.8.0")
+
+version.vstring
+version.version
+version.major
+version.minor
+version.bugfix
+version.pre_release
+version.is_devversion
+
+version == version
+version != version
+version < "1.8.0"
+version <= version
+version > version
+version >= "1.8.0"
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/literal.py b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/literal.py
new file mode 100644
index 00000000..5ef8122d
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/literal.py
@@ -0,0 +1,48 @@
+from __future__ import annotations
+
+from typing import Any
+from functools import partial
+from collections.abc import Callable
+
+import pytest
+import numpy as np
+
+AR = np.array(0)
+AR.setflags(write=False)
+
+KACF = frozenset({None, "K", "A", "C", "F"})
+ACF = frozenset({None, "A", "C", "F"})
+CF = frozenset({None, "C", "F"})
+
+order_list: list[tuple[frozenset[str | None], Callable[..., Any]]] = [
+    (KACF, partial(np.ndarray, 1)),
+    (KACF, AR.tobytes),
+    (KACF, partial(AR.astype, int)),
+    (KACF, AR.copy),
+    (ACF, partial(AR.reshape, 1)),
+    (KACF, AR.flatten),
+    (KACF, AR.ravel),
+    (KACF, partial(np.array, 1)),
+    (CF, partial(np.zeros, 1)),
+    (CF, partial(np.ones, 1)),
+    (CF, partial(np.empty, 1)),
+    (CF, partial(np.full, 1, 1)),
+    (KACF, partial(np.zeros_like, AR)),
+    (KACF, partial(np.ones_like, AR)),
+    (KACF, partial(np.empty_like, AR)),
+    (KACF, partial(np.full_like, AR, 1)),
+    (KACF, partial(np.add, 1, 1)),  # i.e. np.ufunc.__call__
+    (ACF, partial(np.reshape, AR, 1)),
+    (KACF, partial(np.ravel, AR)),
+    (KACF, partial(np.asarray, 1)),
+    (KACF, partial(np.asanyarray, 1)),
+]
+
+for order_set, func in order_list:
+    for order in order_set:
+        func(order=order)
+
+    invalid_orders = KACF - order_set
+    for order in invalid_orders:
+        with pytest.raises(ValueError):
+            func(order=order)
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/ma.py b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/ma.py
new file mode 100644
index 00000000..6b3b1381
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/ma.py
@@ -0,0 +1,8 @@
+from typing import Any
+
+import numpy as np
+import numpy.ma
+
+
+m : np.ma.MaskedArray[Any, np.dtype[np.float64]] = np.ma.masked_array([1.5, 2, 3], mask=[True, False, True])
+
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/mod.py b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/mod.py
new file mode 100644
index 00000000..2b7e6cd8
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/mod.py
@@ -0,0 +1,149 @@
+import numpy as np
+
+f8 = np.float64(1)
+i8 = np.int64(1)
+u8 = np.uint64(1)
+
+f4 = np.float32(1)
+i4 = np.int32(1)
+u4 = np.uint32(1)
+
+td = np.timedelta64(1, "D")
+b_ = np.bool(1)
+
+b = bool(1)
+f = float(1)
+i = int(1)
+
+AR = np.array([1], dtype=np.bool)
+AR.setflags(write=False)
+
+AR2 = np.array([1], dtype=np.timedelta64)
+AR2.setflags(write=False)
+
+# Time structures
+
+td % td
+td % AR2
+AR2 % td
+
+divmod(td, td)
+divmod(td, AR2)
+divmod(AR2, td)
+
+# Bool
+
+b_ % b
+b_ % i
+b_ % f
+b_ % b_
+b_ % i8
+b_ % u8
+b_ % f8
+b_ % AR
+
+divmod(b_, b)
+divmod(b_, i)
+divmod(b_, f)
+divmod(b_, b_)
+divmod(b_, i8)
+divmod(b_, u8)
+divmod(b_, f8)
+divmod(b_, AR)
+
+b % b_
+i % b_
+f % b_
+b_ % b_
+i8 % b_
+u8 % b_
+f8 % b_
+AR % b_
+
+divmod(b, b_)
+divmod(i, b_)
+divmod(f, b_)
+divmod(b_, b_)
+divmod(i8, b_)
+divmod(u8, b_)
+divmod(f8, b_)
+divmod(AR, b_)
+
+# int
+
+i8 % b
+i8 % i
+i8 % f
+i8 % i8
+i8 % f8
+i4 % i8
+i4 % f8
+i4 % i4
+i4 % f4
+i8 % AR
+
+divmod(i8, b)
+divmod(i8, i)
+divmod(i8, f)
+divmod(i8, i8)
+divmod(i8, f8)
+divmod(i8, i4)
+divmod(i8, f4)
+divmod(i4, i4)
+divmod(i4, f4)
+divmod(i8, AR)
+
+b % i8
+i % i8
+f % i8
+i8 % i8
+f8 % i8
+i8 % i4
+f8 % i4
+i4 % i4
+f4 % i4
+AR % i8
+
+divmod(b, i8)
+divmod(i, i8)
+divmod(f, i8)
+divmod(i8, i8)
+divmod(f8, i8)
+divmod(i4, i8)
+divmod(f4, i8)
+divmod(i4, i4)
+divmod(f4, i4)
+divmod(AR, i8)
+
+# float
+
+f8 % b
+f8 % i
+f8 % f
+i8 % f4
+f4 % f4
+f8 % AR
+
+divmod(f8, b)
+divmod(f8, i)
+divmod(f8, f)
+divmod(f8, f8)
+divmod(f8, f4)
+divmod(f4, f4)
+divmod(f8, AR)
+
+b % f8
+i % f8
+f % f8
+f8 % f8
+f8 % f8
+f4 % f4
+AR % f8
+
+divmod(b, f8)
+divmod(i, f8)
+divmod(f, f8)
+divmod(f8, f8)
+divmod(f4, f8)
+divmod(f4, f4)
+divmod(AR, f8)
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/modules.py b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/modules.py
new file mode 100644
index 00000000..0c2fd4b7
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/modules.py
@@ -0,0 +1,45 @@
+import numpy as np
+from numpy import f2py
+
+np.char
+np.ctypeslib
+np.emath
+np.fft
+np.lib
+np.linalg
+np.ma
+np.matrixlib
+np.polynomial
+np.random
+np.rec
+np.strings
+np.testing
+np.version
+
+np.lib.format
+np.lib.mixins
+np.lib.scimath
+np.lib.stride_tricks
+np.lib.array_utils
+np.ma.extras
+np.polynomial.chebyshev
+np.polynomial.hermite
+np.polynomial.hermite_e
+np.polynomial.laguerre
+np.polynomial.legendre
+np.polynomial.polynomial
+
+np.__path__
+np.__version__
+
+np.__all__
+np.char.__all__
+np.ctypeslib.__all__
+np.emath.__all__
+np.lib.__all__
+np.ma.__all__
+np.random.__all__
+np.rec.__all__
+np.strings.__all__
+np.testing.__all__
+f2py.__all__
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/multiarray.py b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/multiarray.py
new file mode 100644
index 00000000..26cedfd7
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/multiarray.py
@@ -0,0 +1,76 @@
+import numpy as np
+import numpy.typing as npt
+
+AR_f8: npt.NDArray[np.float64] = np.array([1.0])
+AR_i4 = np.array([1], dtype=np.int32)
+AR_u1 = np.array([1], dtype=np.uint8)
+
+AR_LIKE_f = [1.5]
+AR_LIKE_i = [1]
+
+b_f8 = np.broadcast(AR_f8)
+b_i4_f8_f8 = np.broadcast(AR_i4, AR_f8, AR_f8)
+
+next(b_f8)
+b_f8.reset()
+b_f8.index
+b_f8.iters
+b_f8.nd
+b_f8.ndim
+b_f8.numiter
+b_f8.shape
+b_f8.size
+
+next(b_i4_f8_f8)
+b_i4_f8_f8.reset()
+b_i4_f8_f8.ndim
+b_i4_f8_f8.index
+b_i4_f8_f8.iters
+b_i4_f8_f8.nd
+b_i4_f8_f8.numiter
+b_i4_f8_f8.shape
+b_i4_f8_f8.size
+
+np.inner(AR_f8, AR_i4)
+
+np.where([True, True, False])
+np.where([True, True, False], 1, 0)
+
+np.lexsort([0, 1, 2])
+
+np.can_cast(np.dtype("i8"), int)
+np.can_cast(AR_f8, "f8")
+np.can_cast(AR_f8, np.complex128, casting="unsafe")
+
+np.min_scalar_type([1])
+np.min_scalar_type(AR_f8)
+
+np.result_type(int, AR_i4)
+np.result_type(AR_f8, AR_u1)
+np.result_type(AR_f8, np.complex128)
+
+np.dot(AR_LIKE_f, AR_i4)
+np.dot(AR_u1, 1)
+np.dot(1.5j, 1)
+np.dot(AR_u1, 1, out=AR_f8)
+
+np.vdot(AR_LIKE_f, AR_i4)
+np.vdot(AR_u1, 1)
+np.vdot(1.5j, 1)
+
+np.bincount(AR_i4)
+
+np.copyto(AR_f8, [1.6])
+
+np.putmask(AR_f8, [True], 1.5)
+
+np.packbits(AR_i4)
+np.packbits(AR_u1)
+
+np.unpackbits(AR_u1)
+
+np.shares_memory(1, 2)
+np.shares_memory(AR_f8, AR_f8, max_work=1)
+
+np.may_share_memory(1, 2)
+np.may_share_memory(AR_f8, AR_f8, max_work=1)
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/ndarray_conversion.py b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/ndarray_conversion.py
new file mode 100644
index 00000000..76da1dad
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/ndarray_conversion.py
@@ -0,0 +1,87 @@
+import os
+import tempfile
+
+import numpy as np
+
+nd = np.array([[1, 2], [3, 4]])
+scalar_array = np.array(1)
+
+# item
+scalar_array.item()
+nd.item(1)
+nd.item(0, 1)
+nd.item((0, 1))
+
+# tobytes
+nd.tobytes()
+nd.tobytes("C")
+nd.tobytes(None)
+
+# tofile
+if os.name != "nt":
+    with tempfile.NamedTemporaryFile(suffix=".txt") as tmp:
+        nd.tofile(tmp.name)
+        nd.tofile(tmp.name, "")
+        nd.tofile(tmp.name, sep="")
+
+        nd.tofile(tmp.name, "", "%s")
+        nd.tofile(tmp.name, format="%s")
+
+        nd.tofile(tmp)
+
+# dump is pretty simple
+# dumps is pretty simple
+
+# astype
+nd.astype("float")
+nd.astype(float)
+
+nd.astype(float, "K")
+nd.astype(float, order="K")
+
+nd.astype(float, "K", "unsafe")
+nd.astype(float, casting="unsafe")
+
+nd.astype(float, "K", "unsafe", True)
+nd.astype(float, subok=True)
+
+nd.astype(float, "K", "unsafe", True, True)
+nd.astype(float, copy=True)
+
+# byteswap
+nd.byteswap()
+nd.byteswap(True)
+
+# copy
+nd.copy()
+nd.copy("C")
+
+# view
+nd.view()
+nd.view(np.int64)
+nd.view(dtype=np.int64)
+nd.view(np.int64, np.matrix)
+nd.view(type=np.matrix)
+
+# getfield
+complex_array = np.array([[1 + 1j, 0], [0, 1 - 1j]], dtype=np.complex128)
+
+complex_array.getfield("float")
+complex_array.getfield(float)
+
+complex_array.getfield("float", 8)
+complex_array.getfield(float, offset=8)
+
+# setflags
+nd.setflags()
+
+nd.setflags(True)
+nd.setflags(write=True)
+
+nd.setflags(True, True)
+nd.setflags(write=True, align=True)
+
+nd.setflags(True, True, False)
+nd.setflags(write=True, align=True, uic=False)
+
+# fill is pretty simple
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/ndarray_misc.py b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/ndarray_misc.py
new file mode 100644
index 00000000..7b8ebea5
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/ndarray_misc.py
@@ -0,0 +1,176 @@
+"""
+Tests for miscellaneous (non-magic) ``np.ndarray``/``np.generic`` methods.
+
+More extensive tests are performed for the methods'
+function-based counterpart in `../from_numeric.py`.
+
+"""
+
+from __future__ import annotations
+
+import operator
+from typing import cast, Any
+
+import numpy as np
+import numpy.typing as npt
+
+class SubClass(npt.NDArray[np.float64]): ...
+
+i4 = np.int32(1)
+A: np.ndarray[Any, np.dtype[np.int32]] = np.array([[1]], dtype=np.int32)
+B0 = np.empty((), dtype=np.int32).view(SubClass)
+B1 = np.empty((1,), dtype=np.int32).view(SubClass)
+B2 = np.empty((1, 1), dtype=np.int32).view(SubClass)
+C: np.ndarray[Any, np.dtype[np.int32]] = np.array([0, 1, 2], dtype=np.int32)
+D = np.ones(3).view(SubClass)
+
+i4.all()
+A.all()
+A.all(axis=0)
+A.all(keepdims=True)
+A.all(out=B0)
+
+i4.any()
+A.any()
+A.any(axis=0)
+A.any(keepdims=True)
+A.any(out=B0)
+
+i4.argmax()
+A.argmax()
+A.argmax(axis=0)
+A.argmax(out=B0)
+
+i4.argmin()
+A.argmin()
+A.argmin(axis=0)
+A.argmin(out=B0)
+
+i4.argsort()
+A.argsort()
+
+i4.choose([()])
+_choices = np.array([[0, 1, 2], [3, 4, 5], [6, 7, 8]], dtype=np.int32)
+C.choose(_choices)
+C.choose(_choices, out=D)
+
+i4.clip(1)
+A.clip(1)
+A.clip(None, 1)
+A.clip(1, out=B2)
+A.clip(None, 1, out=B2)
+
+i4.compress([1])
+A.compress([1])
+A.compress([1], out=B1)
+
+i4.conj()
+A.conj()
+B0.conj()
+
+i4.conjugate()
+A.conjugate()
+B0.conjugate()
+
+i4.cumprod()
+A.cumprod()
+A.cumprod(out=B1)
+
+i4.cumsum()
+A.cumsum()
+A.cumsum(out=B1)
+
+i4.max()
+A.max()
+A.max(axis=0)
+A.max(keepdims=True)
+A.max(out=B0)
+
+i4.mean()
+A.mean()
+A.mean(axis=0)
+A.mean(keepdims=True)
+A.mean(out=B0)
+
+i4.min()
+A.min()
+A.min(axis=0)
+A.min(keepdims=True)
+A.min(out=B0)
+
+i4.prod()
+A.prod()
+A.prod(axis=0)
+A.prod(keepdims=True)
+A.prod(out=B0)
+
+i4.round()
+A.round()
+A.round(out=B2)
+
+i4.repeat(1)
+A.repeat(1)
+B0.repeat(1)
+
+i4.std()
+A.std()
+A.std(axis=0)
+A.std(keepdims=True)
+A.std(out=B0.astype(np.float64))
+
+i4.sum()
+A.sum()
+A.sum(axis=0)
+A.sum(keepdims=True)
+A.sum(out=B0)
+
+i4.take(0)
+A.take(0)
+A.take([0])
+A.take(0, out=B0)
+A.take([0], out=B1)
+
+i4.var()
+A.var()
+A.var(axis=0)
+A.var(keepdims=True)
+A.var(out=B0)
+
+A.argpartition([0])
+
+A.diagonal()
+
+A.dot(1)
+A.dot(1, out=B2)
+
+A.nonzero()
+
+C.searchsorted(1)
+
+A.trace()
+A.trace(out=B0)
+
+void = cast(np.void, np.array(1, dtype=[("f", np.float64)]).take(0))
+void.setfield(10, np.float64)
+
+A.item(0)
+C.item(0)
+
+A.ravel()
+C.ravel()
+
+A.flatten()
+C.flatten()
+
+A.reshape(1)
+C.reshape(3)
+
+int(np.array(1.0, dtype=np.float64))
+int(np.array("1", dtype=np.str_))
+
+float(np.array(1.0, dtype=np.float64))
+float(np.array("1", dtype=np.str_))
+
+complex(np.array(1.0, dtype=np.float64))
+
+operator.index(np.array(1, dtype=np.int64))
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/ndarray_shape_manipulation.py b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/ndarray_shape_manipulation.py
new file mode 100644
index 00000000..0ca3dff3
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/ndarray_shape_manipulation.py
@@ -0,0 +1,47 @@
+import numpy as np
+
+nd1 = np.array([[1, 2], [3, 4]])
+
+# reshape
+nd1.reshape(4)
+nd1.reshape(2, 2)
+nd1.reshape((2, 2))
+
+nd1.reshape((2, 2), order="C")
+nd1.reshape(4, order="C")
+
+# resize
+nd1.resize()
+nd1.resize(4)
+nd1.resize(2, 2)
+nd1.resize((2, 2))
+
+nd1.resize((2, 2), refcheck=True)
+nd1.resize(4, refcheck=True)
+
+nd2 = np.array([[1, 2], [3, 4]])
+
+# transpose
+nd2.transpose()
+nd2.transpose(1, 0)
+nd2.transpose((1, 0))
+
+# swapaxes
+nd2.swapaxes(0, 1)
+
+# flatten
+nd2.flatten()
+nd2.flatten("C")
+
+# ravel
+nd2.ravel()
+nd2.ravel("C")
+
+# squeeze
+nd2.squeeze()
+
+nd3 = np.array([[1, 2]])
+nd3.squeeze(0)
+
+nd4 = np.array([[[1, 2]]])
+nd4.squeeze((0, 1))
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/numeric.py b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/numeric.py
new file mode 100644
index 00000000..7f8f9297
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/numeric.py
@@ -0,0 +1,91 @@
+"""
+Tests for :mod:`numpy._core.numeric`.
+
+Does not include tests which fall under ``array_constructors``.
+
+"""
+
+from __future__ import annotations
+
+import numpy as np
+import numpy.typing as npt
+
+class SubClass(npt.NDArray[np.float64]):
+    ...
+
+i8 = np.int64(1)
+
+A = np.arange(27).reshape(3, 3, 3)
+B: list[list[list[int]]] = A.tolist()
+C = np.empty((27, 27)).view(SubClass)
+
+np.count_nonzero(i8)
+np.count_nonzero(A)
+np.count_nonzero(B)
+np.count_nonzero(A, keepdims=True)
+np.count_nonzero(A, axis=0)
+
+np.isfortran(i8)
+np.isfortran(A)
+
+np.argwhere(i8)
+np.argwhere(A)
+
+np.flatnonzero(i8)
+np.flatnonzero(A)
+
+np.correlate(B[0][0], A.ravel(), mode="valid")
+np.correlate(A.ravel(), A.ravel(), mode="same")
+
+np.convolve(B[0][0], A.ravel(), mode="valid")
+np.convolve(A.ravel(), A.ravel(), mode="same")
+
+np.outer(i8, A)
+np.outer(B, A)
+np.outer(A, A)
+np.outer(A, A, out=C)
+
+np.tensordot(B, A)
+np.tensordot(A, A)
+np.tensordot(A, A, axes=0)
+np.tensordot(A, A, axes=(0, 1))
+
+np.isscalar(i8)
+np.isscalar(A)
+np.isscalar(B)
+
+np.roll(A, 1)
+np.roll(A, (1, 2))
+np.roll(B, 1)
+
+np.rollaxis(A, 0, 1)
+
+np.moveaxis(A, 0, 1)
+np.moveaxis(A, (0, 1), (1, 2))
+
+np.cross(B, A)
+np.cross(A, A)
+
+np.indices([0, 1, 2])
+np.indices([0, 1, 2], sparse=False)
+np.indices([0, 1, 2], sparse=True)
+
+np.binary_repr(1)
+
+np.base_repr(1)
+
+np.allclose(i8, A)
+np.allclose(B, A)
+np.allclose(A, A)
+
+np.isclose(i8, A)
+np.isclose(B, A)
+np.isclose(A, A)
+
+np.array_equal(i8, A)
+np.array_equal(B, A)
+np.array_equal(A, A)
+
+np.array_equiv(i8, A)
+np.array_equiv(B, A)
+np.array_equiv(A, A)
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/numerictypes.py b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/numerictypes.py
new file mode 100644
index 00000000..24e1a998
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/numerictypes.py
@@ -0,0 +1,17 @@
+import numpy as np
+
+np.isdtype(np.float64, (np.int64, np.float64))
+np.isdtype(np.int64, "signed integer")
+
+np.issubdtype("S1", np.bytes_)
+np.issubdtype(np.float64, np.float32)
+
+np.ScalarType
+np.ScalarType[0]
+np.ScalarType[3]
+np.ScalarType[8]
+np.ScalarType[10]
+
+np.typecodes["Character"]
+np.typecodes["Complex"]
+np.typecodes["All"]
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/random.py b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/random.py
new file mode 100644
index 00000000..69afb28c
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/random.py
@@ -0,0 +1,1497 @@
+from __future__ import annotations
+
+from typing import Any
+import numpy as np
+
+SEED_NONE = None
+SEED_INT = 4579435749574957634658964293569
+SEED_ARR: np.ndarray[Any, np.dtype[np.int64]] = np.array([1, 2, 3, 4], dtype=np.int64)
+SEED_ARRLIKE: list[int] = [1, 2, 3, 4]
+SEED_SEED_SEQ: np.random.SeedSequence = np.random.SeedSequence(0)
+SEED_MT19937: np.random.MT19937 = np.random.MT19937(0)
+SEED_PCG64: np.random.PCG64 = np.random.PCG64(0)
+SEED_PHILOX: np.random.Philox = np.random.Philox(0)
+SEED_SFC64: np.random.SFC64 = np.random.SFC64(0)
+
+# default rng
+np.random.default_rng()
+np.random.default_rng(SEED_NONE)
+np.random.default_rng(SEED_INT)
+np.random.default_rng(SEED_ARR)
+np.random.default_rng(SEED_ARRLIKE)
+np.random.default_rng(SEED_SEED_SEQ)
+np.random.default_rng(SEED_MT19937)
+np.random.default_rng(SEED_PCG64)
+np.random.default_rng(SEED_PHILOX)
+np.random.default_rng(SEED_SFC64)
+
+# Seed Sequence
+np.random.SeedSequence(SEED_NONE)
+np.random.SeedSequence(SEED_INT)
+np.random.SeedSequence(SEED_ARR)
+np.random.SeedSequence(SEED_ARRLIKE)
+
+# Bit Generators
+np.random.MT19937(SEED_NONE)
+np.random.MT19937(SEED_INT)
+np.random.MT19937(SEED_ARR)
+np.random.MT19937(SEED_ARRLIKE)
+np.random.MT19937(SEED_SEED_SEQ)
+
+np.random.PCG64(SEED_NONE)
+np.random.PCG64(SEED_INT)
+np.random.PCG64(SEED_ARR)
+np.random.PCG64(SEED_ARRLIKE)
+np.random.PCG64(SEED_SEED_SEQ)
+
+np.random.Philox(SEED_NONE)
+np.random.Philox(SEED_INT)
+np.random.Philox(SEED_ARR)
+np.random.Philox(SEED_ARRLIKE)
+np.random.Philox(SEED_SEED_SEQ)
+
+np.random.SFC64(SEED_NONE)
+np.random.SFC64(SEED_INT)
+np.random.SFC64(SEED_ARR)
+np.random.SFC64(SEED_ARRLIKE)
+np.random.SFC64(SEED_SEED_SEQ)
+
+seed_seq: np.random.bit_generator.SeedSequence = np.random.SeedSequence(SEED_NONE)
+seed_seq.spawn(10)
+seed_seq.generate_state(3)
+seed_seq.generate_state(3, "u4")
+seed_seq.generate_state(3, "uint32")
+seed_seq.generate_state(3, "u8")
+seed_seq.generate_state(3, "uint64")
+seed_seq.generate_state(3, np.uint32)
+seed_seq.generate_state(3, np.uint64)
+
+
+def_gen: np.random.Generator = np.random.default_rng()
+
+D_arr_0p1: np.ndarray[Any, np.dtype[np.float64]] = np.array([0.1])
+D_arr_0p5: np.ndarray[Any, np.dtype[np.float64]] = np.array([0.5])
+D_arr_0p9: np.ndarray[Any, np.dtype[np.float64]] = np.array([0.9])
+D_arr_1p5: np.ndarray[Any, np.dtype[np.float64]] = np.array([1.5])
+I_arr_10: np.ndarray[Any, np.dtype[np.int_]] = np.array([10], dtype=np.int_)
+I_arr_20: np.ndarray[Any, np.dtype[np.int_]] = np.array([20], dtype=np.int_)
+D_arr_like_0p1: list[float] = [0.1]
+D_arr_like_0p5: list[float] = [0.5]
+D_arr_like_0p9: list[float] = [0.9]
+D_arr_like_1p5: list[float] = [1.5]
+I_arr_like_10: list[int] = [10]
+I_arr_like_20: list[int] = [20]
+D_2D_like: list[list[float]] = [[1, 2], [2, 3], [3, 4], [4, 5.1]]
+D_2D: np.ndarray[Any, np.dtype[np.float64]] = np.array(D_2D_like)
+
+S_out: np.ndarray[Any, np.dtype[np.float32]] = np.empty(1, dtype=np.float32)
+D_out: np.ndarray[Any, np.dtype[np.float64]] = np.empty(1)
+
+def_gen.standard_normal()
+def_gen.standard_normal(dtype=np.float32)
+def_gen.standard_normal(dtype="float32")
+def_gen.standard_normal(dtype="double")
+def_gen.standard_normal(dtype=np.float64)
+def_gen.standard_normal(size=None)
+def_gen.standard_normal(size=1)
+def_gen.standard_normal(size=1, dtype=np.float32)
+def_gen.standard_normal(size=1, dtype="f4")
+def_gen.standard_normal(size=1, dtype="float32", out=S_out)
+def_gen.standard_normal(dtype=np.float32, out=S_out)
+def_gen.standard_normal(size=1, dtype=np.float64)
+def_gen.standard_normal(size=1, dtype="float64")
+def_gen.standard_normal(size=1, dtype="f8")
+def_gen.standard_normal(out=D_out)
+def_gen.standard_normal(size=1, dtype="float64")
+def_gen.standard_normal(size=1, dtype="float64", out=D_out)
+
+def_gen.random()
+def_gen.random(dtype=np.float32)
+def_gen.random(dtype="float32")
+def_gen.random(dtype="double")
+def_gen.random(dtype=np.float64)
+def_gen.random(size=None)
+def_gen.random(size=1)
+def_gen.random(size=1, dtype=np.float32)
+def_gen.random(size=1, dtype="f4")
+def_gen.random(size=1, dtype="float32", out=S_out)
+def_gen.random(dtype=np.float32, out=S_out)
+def_gen.random(size=1, dtype=np.float64)
+def_gen.random(size=1, dtype="float64")
+def_gen.random(size=1, dtype="f8")
+def_gen.random(out=D_out)
+def_gen.random(size=1, dtype="float64")
+def_gen.random(size=1, dtype="float64", out=D_out)
+
+def_gen.standard_cauchy()
+def_gen.standard_cauchy(size=None)
+def_gen.standard_cauchy(size=1)
+
+def_gen.standard_exponential()
+def_gen.standard_exponential(method="inv")
+def_gen.standard_exponential(dtype=np.float32)
+def_gen.standard_exponential(dtype="float32")
+def_gen.standard_exponential(dtype="double")
+def_gen.standard_exponential(dtype=np.float64)
+def_gen.standard_exponential(size=None)
+def_gen.standard_exponential(size=None, method="inv")
+def_gen.standard_exponential(size=1, method="inv")
+def_gen.standard_exponential(size=1, dtype=np.float32)
+def_gen.standard_exponential(size=1, dtype="f4", method="inv")
+def_gen.standard_exponential(size=1, dtype="float32", out=S_out)
+def_gen.standard_exponential(dtype=np.float32, out=S_out)
+def_gen.standard_exponential(size=1, dtype=np.float64, method="inv")
+def_gen.standard_exponential(size=1, dtype="float64")
+def_gen.standard_exponential(size=1, dtype="f8")
+def_gen.standard_exponential(out=D_out)
+def_gen.standard_exponential(size=1, dtype="float64")
+def_gen.standard_exponential(size=1, dtype="float64", out=D_out)
+
+def_gen.zipf(1.5)
+def_gen.zipf(1.5, size=None)
+def_gen.zipf(1.5, size=1)
+def_gen.zipf(D_arr_1p5)
+def_gen.zipf(D_arr_1p5, size=1)
+def_gen.zipf(D_arr_like_1p5)
+def_gen.zipf(D_arr_like_1p5, size=1)
+
+def_gen.weibull(0.5)
+def_gen.weibull(0.5, size=None)
+def_gen.weibull(0.5, size=1)
+def_gen.weibull(D_arr_0p5)
+def_gen.weibull(D_arr_0p5, size=1)
+def_gen.weibull(D_arr_like_0p5)
+def_gen.weibull(D_arr_like_0p5, size=1)
+
+def_gen.standard_t(0.5)
+def_gen.standard_t(0.5, size=None)
+def_gen.standard_t(0.5, size=1)
+def_gen.standard_t(D_arr_0p5)
+def_gen.standard_t(D_arr_0p5, size=1)
+def_gen.standard_t(D_arr_like_0p5)
+def_gen.standard_t(D_arr_like_0p5, size=1)
+
+def_gen.poisson(0.5)
+def_gen.poisson(0.5, size=None)
+def_gen.poisson(0.5, size=1)
+def_gen.poisson(D_arr_0p5)
+def_gen.poisson(D_arr_0p5, size=1)
+def_gen.poisson(D_arr_like_0p5)
+def_gen.poisson(D_arr_like_0p5, size=1)
+
+def_gen.power(0.5)
+def_gen.power(0.5, size=None)
+def_gen.power(0.5, size=1)
+def_gen.power(D_arr_0p5)
+def_gen.power(D_arr_0p5, size=1)
+def_gen.power(D_arr_like_0p5)
+def_gen.power(D_arr_like_0p5, size=1)
+
+def_gen.pareto(0.5)
+def_gen.pareto(0.5, size=None)
+def_gen.pareto(0.5, size=1)
+def_gen.pareto(D_arr_0p5)
+def_gen.pareto(D_arr_0p5, size=1)
+def_gen.pareto(D_arr_like_0p5)
+def_gen.pareto(D_arr_like_0p5, size=1)
+
+def_gen.chisquare(0.5)
+def_gen.chisquare(0.5, size=None)
+def_gen.chisquare(0.5, size=1)
+def_gen.chisquare(D_arr_0p5)
+def_gen.chisquare(D_arr_0p5, size=1)
+def_gen.chisquare(D_arr_like_0p5)
+def_gen.chisquare(D_arr_like_0p5, size=1)
+
+def_gen.exponential(0.5)
+def_gen.exponential(0.5, size=None)
+def_gen.exponential(0.5, size=1)
+def_gen.exponential(D_arr_0p5)
+def_gen.exponential(D_arr_0p5, size=1)
+def_gen.exponential(D_arr_like_0p5)
+def_gen.exponential(D_arr_like_0p5, size=1)
+
+def_gen.geometric(0.5)
+def_gen.geometric(0.5, size=None)
+def_gen.geometric(0.5, size=1)
+def_gen.geometric(D_arr_0p5)
+def_gen.geometric(D_arr_0p5, size=1)
+def_gen.geometric(D_arr_like_0p5)
+def_gen.geometric(D_arr_like_0p5, size=1)
+
+def_gen.logseries(0.5)
+def_gen.logseries(0.5, size=None)
+def_gen.logseries(0.5, size=1)
+def_gen.logseries(D_arr_0p5)
+def_gen.logseries(D_arr_0p5, size=1)
+def_gen.logseries(D_arr_like_0p5)
+def_gen.logseries(D_arr_like_0p5, size=1)
+
+def_gen.rayleigh(0.5)
+def_gen.rayleigh(0.5, size=None)
+def_gen.rayleigh(0.5, size=1)
+def_gen.rayleigh(D_arr_0p5)
+def_gen.rayleigh(D_arr_0p5, size=1)
+def_gen.rayleigh(D_arr_like_0p5)
+def_gen.rayleigh(D_arr_like_0p5, size=1)
+
+def_gen.standard_gamma(0.5)
+def_gen.standard_gamma(0.5, size=None)
+def_gen.standard_gamma(0.5, dtype="float32")
+def_gen.standard_gamma(0.5, size=None, dtype="float32")
+def_gen.standard_gamma(0.5, size=1)
+def_gen.standard_gamma(D_arr_0p5)
+def_gen.standard_gamma(D_arr_0p5, dtype="f4")
+def_gen.standard_gamma(0.5, size=1, dtype="float32", out=S_out)
+def_gen.standard_gamma(D_arr_0p5, dtype=np.float32, out=S_out)
+def_gen.standard_gamma(D_arr_0p5, size=1)
+def_gen.standard_gamma(D_arr_like_0p5)
+def_gen.standard_gamma(D_arr_like_0p5, size=1)
+def_gen.standard_gamma(0.5, out=D_out)
+def_gen.standard_gamma(D_arr_like_0p5, out=D_out)
+def_gen.standard_gamma(D_arr_like_0p5, size=1)
+def_gen.standard_gamma(D_arr_like_0p5, size=1, out=D_out, dtype=np.float64)
+
+def_gen.vonmises(0.5, 0.5)
+def_gen.vonmises(0.5, 0.5, size=None)
+def_gen.vonmises(0.5, 0.5, size=1)
+def_gen.vonmises(D_arr_0p5, 0.5)
+def_gen.vonmises(0.5, D_arr_0p5)
+def_gen.vonmises(D_arr_0p5, 0.5, size=1)
+def_gen.vonmises(0.5, D_arr_0p5, size=1)
+def_gen.vonmises(D_arr_like_0p5, 0.5)
+def_gen.vonmises(0.5, D_arr_like_0p5)
+def_gen.vonmises(D_arr_0p5, D_arr_0p5)
+def_gen.vonmises(D_arr_like_0p5, D_arr_like_0p5)
+def_gen.vonmises(D_arr_0p5, D_arr_0p5, size=1)
+def_gen.vonmises(D_arr_like_0p5, D_arr_like_0p5, size=1)
+
+def_gen.wald(0.5, 0.5)
+def_gen.wald(0.5, 0.5, size=None)
+def_gen.wald(0.5, 0.5, size=1)
+def_gen.wald(D_arr_0p5, 0.5)
+def_gen.wald(0.5, D_arr_0p5)
+def_gen.wald(D_arr_0p5, 0.5, size=1)
+def_gen.wald(0.5, D_arr_0p5, size=1)
+def_gen.wald(D_arr_like_0p5, 0.5)
+def_gen.wald(0.5, D_arr_like_0p5)
+def_gen.wald(D_arr_0p5, D_arr_0p5)
+def_gen.wald(D_arr_like_0p5, D_arr_like_0p5)
+def_gen.wald(D_arr_0p5, D_arr_0p5, size=1)
+def_gen.wald(D_arr_like_0p5, D_arr_like_0p5, size=1)
+
+def_gen.uniform(0.5, 0.5)
+def_gen.uniform(0.5, 0.5, size=None)
+def_gen.uniform(0.5, 0.5, size=1)
+def_gen.uniform(D_arr_0p5, 0.5)
+def_gen.uniform(0.5, D_arr_0p5)
+def_gen.uniform(D_arr_0p5, 0.5, size=1)
+def_gen.uniform(0.5, D_arr_0p5, size=1)
+def_gen.uniform(D_arr_like_0p5, 0.5)
+def_gen.uniform(0.5, D_arr_like_0p5)
+def_gen.uniform(D_arr_0p5, D_arr_0p5)
+def_gen.uniform(D_arr_like_0p5, D_arr_like_0p5)
+def_gen.uniform(D_arr_0p5, D_arr_0p5, size=1)
+def_gen.uniform(D_arr_like_0p5, D_arr_like_0p5, size=1)
+
+def_gen.beta(0.5, 0.5)
+def_gen.beta(0.5, 0.5, size=None)
+def_gen.beta(0.5, 0.5, size=1)
+def_gen.beta(D_arr_0p5, 0.5)
+def_gen.beta(0.5, D_arr_0p5)
+def_gen.beta(D_arr_0p5, 0.5, size=1)
+def_gen.beta(0.5, D_arr_0p5, size=1)
+def_gen.beta(D_arr_like_0p5, 0.5)
+def_gen.beta(0.5, D_arr_like_0p5)
+def_gen.beta(D_arr_0p5, D_arr_0p5)
+def_gen.beta(D_arr_like_0p5, D_arr_like_0p5)
+def_gen.beta(D_arr_0p5, D_arr_0p5, size=1)
+def_gen.beta(D_arr_like_0p5, D_arr_like_0p5, size=1)
+
+def_gen.f(0.5, 0.5)
+def_gen.f(0.5, 0.5, size=None)
+def_gen.f(0.5, 0.5, size=1)
+def_gen.f(D_arr_0p5, 0.5)
+def_gen.f(0.5, D_arr_0p5)
+def_gen.f(D_arr_0p5, 0.5, size=1)
+def_gen.f(0.5, D_arr_0p5, size=1)
+def_gen.f(D_arr_like_0p5, 0.5)
+def_gen.f(0.5, D_arr_like_0p5)
+def_gen.f(D_arr_0p5, D_arr_0p5)
+def_gen.f(D_arr_like_0p5, D_arr_like_0p5)
+def_gen.f(D_arr_0p5, D_arr_0p5, size=1)
+def_gen.f(D_arr_like_0p5, D_arr_like_0p5, size=1)
+
+def_gen.gamma(0.5, 0.5)
+def_gen.gamma(0.5, 0.5, size=None)
+def_gen.gamma(0.5, 0.5, size=1)
+def_gen.gamma(D_arr_0p5, 0.5)
+def_gen.gamma(0.5, D_arr_0p5)
+def_gen.gamma(D_arr_0p5, 0.5, size=1)
+def_gen.gamma(0.5, D_arr_0p5, size=1)
+def_gen.gamma(D_arr_like_0p5, 0.5)
+def_gen.gamma(0.5, D_arr_like_0p5)
+def_gen.gamma(D_arr_0p5, D_arr_0p5)
+def_gen.gamma(D_arr_like_0p5, D_arr_like_0p5)
+def_gen.gamma(D_arr_0p5, D_arr_0p5, size=1)
+def_gen.gamma(D_arr_like_0p5, D_arr_like_0p5, size=1)
+
+def_gen.gumbel(0.5, 0.5)
+def_gen.gumbel(0.5, 0.5, size=None)
+def_gen.gumbel(0.5, 0.5, size=1)
+def_gen.gumbel(D_arr_0p5, 0.5)
+def_gen.gumbel(0.5, D_arr_0p5)
+def_gen.gumbel(D_arr_0p5, 0.5, size=1)
+def_gen.gumbel(0.5, D_arr_0p5, size=1)
+def_gen.gumbel(D_arr_like_0p5, 0.5)
+def_gen.gumbel(0.5, D_arr_like_0p5)
+def_gen.gumbel(D_arr_0p5, D_arr_0p5)
+def_gen.gumbel(D_arr_like_0p5, D_arr_like_0p5)
+def_gen.gumbel(D_arr_0p5, D_arr_0p5, size=1)
+def_gen.gumbel(D_arr_like_0p5, D_arr_like_0p5, size=1)
+
+def_gen.laplace(0.5, 0.5)
+def_gen.laplace(0.5, 0.5, size=None)
+def_gen.laplace(0.5, 0.5, size=1)
+def_gen.laplace(D_arr_0p5, 0.5)
+def_gen.laplace(0.5, D_arr_0p5)
+def_gen.laplace(D_arr_0p5, 0.5, size=1)
+def_gen.laplace(0.5, D_arr_0p5, size=1)
+def_gen.laplace(D_arr_like_0p5, 0.5)
+def_gen.laplace(0.5, D_arr_like_0p5)
+def_gen.laplace(D_arr_0p5, D_arr_0p5)
+def_gen.laplace(D_arr_like_0p5, D_arr_like_0p5)
+def_gen.laplace(D_arr_0p5, D_arr_0p5, size=1)
+def_gen.laplace(D_arr_like_0p5, D_arr_like_0p5, size=1)
+
+def_gen.logistic(0.5, 0.5)
+def_gen.logistic(0.5, 0.5, size=None)
+def_gen.logistic(0.5, 0.5, size=1)
+def_gen.logistic(D_arr_0p5, 0.5)
+def_gen.logistic(0.5, D_arr_0p5)
+def_gen.logistic(D_arr_0p5, 0.5, size=1)
+def_gen.logistic(0.5, D_arr_0p5, size=1)
+def_gen.logistic(D_arr_like_0p5, 0.5)
+def_gen.logistic(0.5, D_arr_like_0p5)
+def_gen.logistic(D_arr_0p5, D_arr_0p5)
+def_gen.logistic(D_arr_like_0p5, D_arr_like_0p5)
+def_gen.logistic(D_arr_0p5, D_arr_0p5, size=1)
+def_gen.logistic(D_arr_like_0p5, D_arr_like_0p5, size=1)
+
+def_gen.lognormal(0.5, 0.5)
+def_gen.lognormal(0.5, 0.5, size=None)
+def_gen.lognormal(0.5, 0.5, size=1)
+def_gen.lognormal(D_arr_0p5, 0.5)
+def_gen.lognormal(0.5, D_arr_0p5)
+def_gen.lognormal(D_arr_0p5, 0.5, size=1)
+def_gen.lognormal(0.5, D_arr_0p5, size=1)
+def_gen.lognormal(D_arr_like_0p5, 0.5)
+def_gen.lognormal(0.5, D_arr_like_0p5)
+def_gen.lognormal(D_arr_0p5, D_arr_0p5)
+def_gen.lognormal(D_arr_like_0p5, D_arr_like_0p5)
+def_gen.lognormal(D_arr_0p5, D_arr_0p5, size=1)
+def_gen.lognormal(D_arr_like_0p5, D_arr_like_0p5, size=1)
+
+def_gen.noncentral_chisquare(0.5, 0.5)
+def_gen.noncentral_chisquare(0.5, 0.5, size=None)
+def_gen.noncentral_chisquare(0.5, 0.5, size=1)
+def_gen.noncentral_chisquare(D_arr_0p5, 0.5)
+def_gen.noncentral_chisquare(0.5, D_arr_0p5)
+def_gen.noncentral_chisquare(D_arr_0p5, 0.5, size=1)
+def_gen.noncentral_chisquare(0.5, D_arr_0p5, size=1)
+def_gen.noncentral_chisquare(D_arr_like_0p5, 0.5)
+def_gen.noncentral_chisquare(0.5, D_arr_like_0p5)
+def_gen.noncentral_chisquare(D_arr_0p5, D_arr_0p5)
+def_gen.noncentral_chisquare(D_arr_like_0p5, D_arr_like_0p5)
+def_gen.noncentral_chisquare(D_arr_0p5, D_arr_0p5, size=1)
+def_gen.noncentral_chisquare(D_arr_like_0p5, D_arr_like_0p5, size=1)
+
+def_gen.normal(0.5, 0.5)
+def_gen.normal(0.5, 0.5, size=None)
+def_gen.normal(0.5, 0.5, size=1)
+def_gen.normal(D_arr_0p5, 0.5)
+def_gen.normal(0.5, D_arr_0p5)
+def_gen.normal(D_arr_0p5, 0.5, size=1)
+def_gen.normal(0.5, D_arr_0p5, size=1)
+def_gen.normal(D_arr_like_0p5, 0.5)
+def_gen.normal(0.5, D_arr_like_0p5)
+def_gen.normal(D_arr_0p5, D_arr_0p5)
+def_gen.normal(D_arr_like_0p5, D_arr_like_0p5)
+def_gen.normal(D_arr_0p5, D_arr_0p5, size=1)
+def_gen.normal(D_arr_like_0p5, D_arr_like_0p5, size=1)
+
+def_gen.triangular(0.1, 0.5, 0.9)
+def_gen.triangular(0.1, 0.5, 0.9, size=None)
+def_gen.triangular(0.1, 0.5, 0.9, size=1)
+def_gen.triangular(D_arr_0p1, 0.5, 0.9)
+def_gen.triangular(0.1, D_arr_0p5, 0.9)
+def_gen.triangular(D_arr_0p1, 0.5, D_arr_like_0p9, size=1)
+def_gen.triangular(0.1, D_arr_0p5, 0.9, size=1)
+def_gen.triangular(D_arr_like_0p1, 0.5, D_arr_0p9)
+def_gen.triangular(0.5, D_arr_like_0p5, 0.9)
+def_gen.triangular(D_arr_0p1, D_arr_0p5, 0.9)
+def_gen.triangular(D_arr_like_0p1, D_arr_like_0p5, 0.9)
+def_gen.triangular(D_arr_0p1, D_arr_0p5, D_arr_0p9, size=1)
+def_gen.triangular(D_arr_like_0p1, D_arr_like_0p5, D_arr_like_0p9, size=1)
+
+def_gen.noncentral_f(0.1, 0.5, 0.9)
+def_gen.noncentral_f(0.1, 0.5, 0.9, size=None)
+def_gen.noncentral_f(0.1, 0.5, 0.9, size=1)
+def_gen.noncentral_f(D_arr_0p1, 0.5, 0.9)
+def_gen.noncentral_f(0.1, D_arr_0p5, 0.9)
+def_gen.noncentral_f(D_arr_0p1, 0.5, D_arr_like_0p9, size=1)
+def_gen.noncentral_f(0.1, D_arr_0p5, 0.9, size=1)
+def_gen.noncentral_f(D_arr_like_0p1, 0.5, D_arr_0p9)
+def_gen.noncentral_f(0.5, D_arr_like_0p5, 0.9)
+def_gen.noncentral_f(D_arr_0p1, D_arr_0p5, 0.9)
+def_gen.noncentral_f(D_arr_like_0p1, D_arr_like_0p5, 0.9)
+def_gen.noncentral_f(D_arr_0p1, D_arr_0p5, D_arr_0p9, size=1)
+def_gen.noncentral_f(D_arr_like_0p1, D_arr_like_0p5, D_arr_like_0p9, size=1)
+
+def_gen.binomial(10, 0.5)
+def_gen.binomial(10, 0.5, size=None)
+def_gen.binomial(10, 0.5, size=1)
+def_gen.binomial(I_arr_10, 0.5)
+def_gen.binomial(10, D_arr_0p5)
+def_gen.binomial(I_arr_10, 0.5, size=1)
+def_gen.binomial(10, D_arr_0p5, size=1)
+def_gen.binomial(I_arr_like_10, 0.5)
+def_gen.binomial(10, D_arr_like_0p5)
+def_gen.binomial(I_arr_10, D_arr_0p5)
+def_gen.binomial(I_arr_like_10, D_arr_like_0p5)
+def_gen.binomial(I_arr_10, D_arr_0p5, size=1)
+def_gen.binomial(I_arr_like_10, D_arr_like_0p5, size=1)
+
+def_gen.negative_binomial(10, 0.5)
+def_gen.negative_binomial(10, 0.5, size=None)
+def_gen.negative_binomial(10, 0.5, size=1)
+def_gen.negative_binomial(I_arr_10, 0.5)
+def_gen.negative_binomial(10, D_arr_0p5)
+def_gen.negative_binomial(I_arr_10, 0.5, size=1)
+def_gen.negative_binomial(10, D_arr_0p5, size=1)
+def_gen.negative_binomial(I_arr_like_10, 0.5)
+def_gen.negative_binomial(10, D_arr_like_0p5)
+def_gen.negative_binomial(I_arr_10, D_arr_0p5)
+def_gen.negative_binomial(I_arr_like_10, D_arr_like_0p5)
+def_gen.negative_binomial(I_arr_10, D_arr_0p5, size=1)
+def_gen.negative_binomial(I_arr_like_10, D_arr_like_0p5, size=1)
+
+def_gen.hypergeometric(20, 20, 10)
+def_gen.hypergeometric(20, 20, 10, size=None)
+def_gen.hypergeometric(20, 20, 10, size=1)
+def_gen.hypergeometric(I_arr_20, 20, 10)
+def_gen.hypergeometric(20, I_arr_20, 10)
+def_gen.hypergeometric(I_arr_20, 20, I_arr_like_10, size=1)
+def_gen.hypergeometric(20, I_arr_20, 10, size=1)
+def_gen.hypergeometric(I_arr_like_20, 20, I_arr_10)
+def_gen.hypergeometric(20, I_arr_like_20, 10)
+def_gen.hypergeometric(I_arr_20, I_arr_20, 10)
+def_gen.hypergeometric(I_arr_like_20, I_arr_like_20, 10)
+def_gen.hypergeometric(I_arr_20, I_arr_20, I_arr_10, size=1)
+def_gen.hypergeometric(I_arr_like_20, I_arr_like_20, I_arr_like_10, size=1)
+
+I_int64_100: np.ndarray[Any, np.dtype[np.int64]] = np.array([100], dtype=np.int64)
+
+def_gen.integers(0, 100)
+def_gen.integers(100)
+def_gen.integers([100])
+def_gen.integers(0, [100])
+
+I_bool_low: np.ndarray[Any, np.dtype[np.bool]] = np.array([0], dtype=np.bool)
+I_bool_low_like: list[int] = [0]
+I_bool_high_open: np.ndarray[Any, np.dtype[np.bool]] = np.array([1], dtype=np.bool)
+I_bool_high_closed: np.ndarray[Any, np.dtype[np.bool]] = np.array([1], dtype=np.bool)
+
+def_gen.integers(2, dtype=bool)
+def_gen.integers(0, 2, dtype=bool)
+def_gen.integers(1, dtype=bool, endpoint=True)
+def_gen.integers(0, 1, dtype=bool, endpoint=True)
+def_gen.integers(I_bool_low_like, 1, dtype=bool, endpoint=True)
+def_gen.integers(I_bool_high_open, dtype=bool)
+def_gen.integers(I_bool_low, I_bool_high_open, dtype=bool)
+def_gen.integers(0, I_bool_high_open, dtype=bool)
+def_gen.integers(I_bool_high_closed, dtype=bool, endpoint=True)
+def_gen.integers(I_bool_low, I_bool_high_closed, dtype=bool, endpoint=True)
+def_gen.integers(0, I_bool_high_closed, dtype=bool, endpoint=True)
+
+def_gen.integers(2, dtype=np.bool)
+def_gen.integers(0, 2, dtype=np.bool)
+def_gen.integers(1, dtype=np.bool, endpoint=True)
+def_gen.integers(0, 1, dtype=np.bool, endpoint=True)
+def_gen.integers(I_bool_low_like, 1, dtype=np.bool, endpoint=True)
+def_gen.integers(I_bool_high_open, dtype=np.bool)
+def_gen.integers(I_bool_low, I_bool_high_open, dtype=np.bool)
+def_gen.integers(0, I_bool_high_open, dtype=np.bool)
+def_gen.integers(I_bool_high_closed, dtype=np.bool, endpoint=True)
+def_gen.integers(I_bool_low, I_bool_high_closed, dtype=np.bool, endpoint=True)
+def_gen.integers(0, I_bool_high_closed, dtype=np.bool, endpoint=True)
+
+I_u1_low: np.ndarray[Any, np.dtype[np.uint8]] = np.array([0], dtype=np.uint8)
+I_u1_low_like: list[int] = [0]
+I_u1_high_open: np.ndarray[Any, np.dtype[np.uint8]] = np.array([255], dtype=np.uint8)
+I_u1_high_closed: np.ndarray[Any, np.dtype[np.uint8]] = np.array([255], dtype=np.uint8)
+
+def_gen.integers(256, dtype="u1")
+def_gen.integers(0, 256, dtype="u1")
+def_gen.integers(255, dtype="u1", endpoint=True)
+def_gen.integers(0, 255, dtype="u1", endpoint=True)
+def_gen.integers(I_u1_low_like, 255, dtype="u1", endpoint=True)
+def_gen.integers(I_u1_high_open, dtype="u1")
+def_gen.integers(I_u1_low, I_u1_high_open, dtype="u1")
+def_gen.integers(0, I_u1_high_open, dtype="u1")
+def_gen.integers(I_u1_high_closed, dtype="u1", endpoint=True)
+def_gen.integers(I_u1_low, I_u1_high_closed, dtype="u1", endpoint=True)
+def_gen.integers(0, I_u1_high_closed, dtype="u1", endpoint=True)
+
+def_gen.integers(256, dtype="uint8")
+def_gen.integers(0, 256, dtype="uint8")
+def_gen.integers(255, dtype="uint8", endpoint=True)
+def_gen.integers(0, 255, dtype="uint8", endpoint=True)
+def_gen.integers(I_u1_low_like, 255, dtype="uint8", endpoint=True)
+def_gen.integers(I_u1_high_open, dtype="uint8")
+def_gen.integers(I_u1_low, I_u1_high_open, dtype="uint8")
+def_gen.integers(0, I_u1_high_open, dtype="uint8")
+def_gen.integers(I_u1_high_closed, dtype="uint8", endpoint=True)
+def_gen.integers(I_u1_low, I_u1_high_closed, dtype="uint8", endpoint=True)
+def_gen.integers(0, I_u1_high_closed, dtype="uint8", endpoint=True)
+
+def_gen.integers(256, dtype=np.uint8)
+def_gen.integers(0, 256, dtype=np.uint8)
+def_gen.integers(255, dtype=np.uint8, endpoint=True)
+def_gen.integers(0, 255, dtype=np.uint8, endpoint=True)
+def_gen.integers(I_u1_low_like, 255, dtype=np.uint8, endpoint=True)
+def_gen.integers(I_u1_high_open, dtype=np.uint8)
+def_gen.integers(I_u1_low, I_u1_high_open, dtype=np.uint8)
+def_gen.integers(0, I_u1_high_open, dtype=np.uint8)
+def_gen.integers(I_u1_high_closed, dtype=np.uint8, endpoint=True)
+def_gen.integers(I_u1_low, I_u1_high_closed, dtype=np.uint8, endpoint=True)
+def_gen.integers(0, I_u1_high_closed, dtype=np.uint8, endpoint=True)
+
+I_u2_low: np.ndarray[Any, np.dtype[np.uint16]] = np.array([0], dtype=np.uint16)
+I_u2_low_like: list[int] = [0]
+I_u2_high_open: np.ndarray[Any, np.dtype[np.uint16]] = np.array([65535], dtype=np.uint16)
+I_u2_high_closed: np.ndarray[Any, np.dtype[np.uint16]] = np.array([65535], dtype=np.uint16)
+
+def_gen.integers(65536, dtype="u2")
+def_gen.integers(0, 65536, dtype="u2")
+def_gen.integers(65535, dtype="u2", endpoint=True)
+def_gen.integers(0, 65535, dtype="u2", endpoint=True)
+def_gen.integers(I_u2_low_like, 65535, dtype="u2", endpoint=True)
+def_gen.integers(I_u2_high_open, dtype="u2")
+def_gen.integers(I_u2_low, I_u2_high_open, dtype="u2")
+def_gen.integers(0, I_u2_high_open, dtype="u2")
+def_gen.integers(I_u2_high_closed, dtype="u2", endpoint=True)
+def_gen.integers(I_u2_low, I_u2_high_closed, dtype="u2", endpoint=True)
+def_gen.integers(0, I_u2_high_closed, dtype="u2", endpoint=True)
+
+def_gen.integers(65536, dtype="uint16")
+def_gen.integers(0, 65536, dtype="uint16")
+def_gen.integers(65535, dtype="uint16", endpoint=True)
+def_gen.integers(0, 65535, dtype="uint16", endpoint=True)
+def_gen.integers(I_u2_low_like, 65535, dtype="uint16", endpoint=True)
+def_gen.integers(I_u2_high_open, dtype="uint16")
+def_gen.integers(I_u2_low, I_u2_high_open, dtype="uint16")
+def_gen.integers(0, I_u2_high_open, dtype="uint16")
+def_gen.integers(I_u2_high_closed, dtype="uint16", endpoint=True)
+def_gen.integers(I_u2_low, I_u2_high_closed, dtype="uint16", endpoint=True)
+def_gen.integers(0, I_u2_high_closed, dtype="uint16", endpoint=True)
+
+def_gen.integers(65536, dtype=np.uint16)
+def_gen.integers(0, 65536, dtype=np.uint16)
+def_gen.integers(65535, dtype=np.uint16, endpoint=True)
+def_gen.integers(0, 65535, dtype=np.uint16, endpoint=True)
+def_gen.integers(I_u2_low_like, 65535, dtype=np.uint16, endpoint=True)
+def_gen.integers(I_u2_high_open, dtype=np.uint16)
+def_gen.integers(I_u2_low, I_u2_high_open, dtype=np.uint16)
+def_gen.integers(0, I_u2_high_open, dtype=np.uint16)
+def_gen.integers(I_u2_high_closed, dtype=np.uint16, endpoint=True)
+def_gen.integers(I_u2_low, I_u2_high_closed, dtype=np.uint16, endpoint=True)
+def_gen.integers(0, I_u2_high_closed, dtype=np.uint16, endpoint=True)
+
+I_u4_low: np.ndarray[Any, np.dtype[np.uint32]] = np.array([0], dtype=np.uint32)
+I_u4_low_like: list[int] = [0]
+I_u4_high_open: np.ndarray[Any, np.dtype[np.uint32]] = np.array([4294967295], dtype=np.uint32)
+I_u4_high_closed: np.ndarray[Any, np.dtype[np.uint32]] = np.array([4294967295], dtype=np.uint32)
+
+def_gen.integers(4294967296, dtype="u4")
+def_gen.integers(0, 4294967296, dtype="u4")
+def_gen.integers(4294967295, dtype="u4", endpoint=True)
+def_gen.integers(0, 4294967295, dtype="u4", endpoint=True)
+def_gen.integers(I_u4_low_like, 4294967295, dtype="u4", endpoint=True)
+def_gen.integers(I_u4_high_open, dtype="u4")
+def_gen.integers(I_u4_low, I_u4_high_open, dtype="u4")
+def_gen.integers(0, I_u4_high_open, dtype="u4")
+def_gen.integers(I_u4_high_closed, dtype="u4", endpoint=True)
+def_gen.integers(I_u4_low, I_u4_high_closed, dtype="u4", endpoint=True)
+def_gen.integers(0, I_u4_high_closed, dtype="u4", endpoint=True)
+
+def_gen.integers(4294967296, dtype="uint32")
+def_gen.integers(0, 4294967296, dtype="uint32")
+def_gen.integers(4294967295, dtype="uint32", endpoint=True)
+def_gen.integers(0, 4294967295, dtype="uint32", endpoint=True)
+def_gen.integers(I_u4_low_like, 4294967295, dtype="uint32", endpoint=True)
+def_gen.integers(I_u4_high_open, dtype="uint32")
+def_gen.integers(I_u4_low, I_u4_high_open, dtype="uint32")
+def_gen.integers(0, I_u4_high_open, dtype="uint32")
+def_gen.integers(I_u4_high_closed, dtype="uint32", endpoint=True)
+def_gen.integers(I_u4_low, I_u4_high_closed, dtype="uint32", endpoint=True)
+def_gen.integers(0, I_u4_high_closed, dtype="uint32", endpoint=True)
+
+def_gen.integers(4294967296, dtype=np.uint32)
+def_gen.integers(0, 4294967296, dtype=np.uint32)
+def_gen.integers(4294967295, dtype=np.uint32, endpoint=True)
+def_gen.integers(0, 4294967295, dtype=np.uint32, endpoint=True)
+def_gen.integers(I_u4_low_like, 4294967295, dtype=np.uint32, endpoint=True)
+def_gen.integers(I_u4_high_open, dtype=np.uint32)
+def_gen.integers(I_u4_low, I_u4_high_open, dtype=np.uint32)
+def_gen.integers(0, I_u4_high_open, dtype=np.uint32)
+def_gen.integers(I_u4_high_closed, dtype=np.uint32, endpoint=True)
+def_gen.integers(I_u4_low, I_u4_high_closed, dtype=np.uint32, endpoint=True)
+def_gen.integers(0, I_u4_high_closed, dtype=np.uint32, endpoint=True)
+
+I_u8_low: np.ndarray[Any, np.dtype[np.uint64]] = np.array([0], dtype=np.uint64)
+I_u8_low_like: list[int] = [0]
+I_u8_high_open: np.ndarray[Any, np.dtype[np.uint64]] = np.array([18446744073709551615], dtype=np.uint64)
+I_u8_high_closed: np.ndarray[Any, np.dtype[np.uint64]] = np.array([18446744073709551615], dtype=np.uint64)
+
+def_gen.integers(18446744073709551616, dtype="u8")
+def_gen.integers(0, 18446744073709551616, dtype="u8")
+def_gen.integers(18446744073709551615, dtype="u8", endpoint=True)
+def_gen.integers(0, 18446744073709551615, dtype="u8", endpoint=True)
+def_gen.integers(I_u8_low_like, 18446744073709551615, dtype="u8", endpoint=True)
+def_gen.integers(I_u8_high_open, dtype="u8")
+def_gen.integers(I_u8_low, I_u8_high_open, dtype="u8")
+def_gen.integers(0, I_u8_high_open, dtype="u8")
+def_gen.integers(I_u8_high_closed, dtype="u8", endpoint=True)
+def_gen.integers(I_u8_low, I_u8_high_closed, dtype="u8", endpoint=True)
+def_gen.integers(0, I_u8_high_closed, dtype="u8", endpoint=True)
+
+def_gen.integers(18446744073709551616, dtype="uint64")
+def_gen.integers(0, 18446744073709551616, dtype="uint64")
+def_gen.integers(18446744073709551615, dtype="uint64", endpoint=True)
+def_gen.integers(0, 18446744073709551615, dtype="uint64", endpoint=True)
+def_gen.integers(I_u8_low_like, 18446744073709551615, dtype="uint64", endpoint=True)
+def_gen.integers(I_u8_high_open, dtype="uint64")
+def_gen.integers(I_u8_low, I_u8_high_open, dtype="uint64")
+def_gen.integers(0, I_u8_high_open, dtype="uint64")
+def_gen.integers(I_u8_high_closed, dtype="uint64", endpoint=True)
+def_gen.integers(I_u8_low, I_u8_high_closed, dtype="uint64", endpoint=True)
+def_gen.integers(0, I_u8_high_closed, dtype="uint64", endpoint=True)
+
+def_gen.integers(18446744073709551616, dtype=np.uint64)
+def_gen.integers(0, 18446744073709551616, dtype=np.uint64)
+def_gen.integers(18446744073709551615, dtype=np.uint64, endpoint=True)
+def_gen.integers(0, 18446744073709551615, dtype=np.uint64, endpoint=True)
+def_gen.integers(I_u8_low_like, 18446744073709551615, dtype=np.uint64, endpoint=True)
+def_gen.integers(I_u8_high_open, dtype=np.uint64)
+def_gen.integers(I_u8_low, I_u8_high_open, dtype=np.uint64)
+def_gen.integers(0, I_u8_high_open, dtype=np.uint64)
+def_gen.integers(I_u8_high_closed, dtype=np.uint64, endpoint=True)
+def_gen.integers(I_u8_low, I_u8_high_closed, dtype=np.uint64, endpoint=True)
+def_gen.integers(0, I_u8_high_closed, dtype=np.uint64, endpoint=True)
+
+I_i1_low: np.ndarray[Any, np.dtype[np.int8]] = np.array([-128], dtype=np.int8)
+I_i1_low_like: list[int] = [-128]
+I_i1_high_open: np.ndarray[Any, np.dtype[np.int8]] = np.array([127], dtype=np.int8)
+I_i1_high_closed: np.ndarray[Any, np.dtype[np.int8]] = np.array([127], dtype=np.int8)
+
+def_gen.integers(128, dtype="i1")
+def_gen.integers(-128, 128, dtype="i1")
+def_gen.integers(127, dtype="i1", endpoint=True)
+def_gen.integers(-128, 127, dtype="i1", endpoint=True)
+def_gen.integers(I_i1_low_like, 127, dtype="i1", endpoint=True)
+def_gen.integers(I_i1_high_open, dtype="i1")
+def_gen.integers(I_i1_low, I_i1_high_open, dtype="i1")
+def_gen.integers(-128, I_i1_high_open, dtype="i1")
+def_gen.integers(I_i1_high_closed, dtype="i1", endpoint=True)
+def_gen.integers(I_i1_low, I_i1_high_closed, dtype="i1", endpoint=True)
+def_gen.integers(-128, I_i1_high_closed, dtype="i1", endpoint=True)
+
+def_gen.integers(128, dtype="int8")
+def_gen.integers(-128, 128, dtype="int8")
+def_gen.integers(127, dtype="int8", endpoint=True)
+def_gen.integers(-128, 127, dtype="int8", endpoint=True)
+def_gen.integers(I_i1_low_like, 127, dtype="int8", endpoint=True)
+def_gen.integers(I_i1_high_open, dtype="int8")
+def_gen.integers(I_i1_low, I_i1_high_open, dtype="int8")
+def_gen.integers(-128, I_i1_high_open, dtype="int8")
+def_gen.integers(I_i1_high_closed, dtype="int8", endpoint=True)
+def_gen.integers(I_i1_low, I_i1_high_closed, dtype="int8", endpoint=True)
+def_gen.integers(-128, I_i1_high_closed, dtype="int8", endpoint=True)
+
+def_gen.integers(128, dtype=np.int8)
+def_gen.integers(-128, 128, dtype=np.int8)
+def_gen.integers(127, dtype=np.int8, endpoint=True)
+def_gen.integers(-128, 127, dtype=np.int8, endpoint=True)
+def_gen.integers(I_i1_low_like, 127, dtype=np.int8, endpoint=True)
+def_gen.integers(I_i1_high_open, dtype=np.int8)
+def_gen.integers(I_i1_low, I_i1_high_open, dtype=np.int8)
+def_gen.integers(-128, I_i1_high_open, dtype=np.int8)
+def_gen.integers(I_i1_high_closed, dtype=np.int8, endpoint=True)
+def_gen.integers(I_i1_low, I_i1_high_closed, dtype=np.int8, endpoint=True)
+def_gen.integers(-128, I_i1_high_closed, dtype=np.int8, endpoint=True)
+
+I_i2_low: np.ndarray[Any, np.dtype[np.int16]] = np.array([-32768], dtype=np.int16)
+I_i2_low_like: list[int] = [-32768]
+I_i2_high_open: np.ndarray[Any, np.dtype[np.int16]] = np.array([32767], dtype=np.int16)
+I_i2_high_closed: np.ndarray[Any, np.dtype[np.int16]] = np.array([32767], dtype=np.int16)
+
+def_gen.integers(32768, dtype="i2")
+def_gen.integers(-32768, 32768, dtype="i2")
+def_gen.integers(32767, dtype="i2", endpoint=True)
+def_gen.integers(-32768, 32767, dtype="i2", endpoint=True)
+def_gen.integers(I_i2_low_like, 32767, dtype="i2", endpoint=True)
+def_gen.integers(I_i2_high_open, dtype="i2")
+def_gen.integers(I_i2_low, I_i2_high_open, dtype="i2")
+def_gen.integers(-32768, I_i2_high_open, dtype="i2")
+def_gen.integers(I_i2_high_closed, dtype="i2", endpoint=True)
+def_gen.integers(I_i2_low, I_i2_high_closed, dtype="i2", endpoint=True)
+def_gen.integers(-32768, I_i2_high_closed, dtype="i2", endpoint=True)
+
+def_gen.integers(32768, dtype="int16")
+def_gen.integers(-32768, 32768, dtype="int16")
+def_gen.integers(32767, dtype="int16", endpoint=True)
+def_gen.integers(-32768, 32767, dtype="int16", endpoint=True)
+def_gen.integers(I_i2_low_like, 32767, dtype="int16", endpoint=True)
+def_gen.integers(I_i2_high_open, dtype="int16")
+def_gen.integers(I_i2_low, I_i2_high_open, dtype="int16")
+def_gen.integers(-32768, I_i2_high_open, dtype="int16")
+def_gen.integers(I_i2_high_closed, dtype="int16", endpoint=True)
+def_gen.integers(I_i2_low, I_i2_high_closed, dtype="int16", endpoint=True)
+def_gen.integers(-32768, I_i2_high_closed, dtype="int16", endpoint=True)
+
+def_gen.integers(32768, dtype=np.int16)
+def_gen.integers(-32768, 32768, dtype=np.int16)
+def_gen.integers(32767, dtype=np.int16, endpoint=True)
+def_gen.integers(-32768, 32767, dtype=np.int16, endpoint=True)
+def_gen.integers(I_i2_low_like, 32767, dtype=np.int16, endpoint=True)
+def_gen.integers(I_i2_high_open, dtype=np.int16)
+def_gen.integers(I_i2_low, I_i2_high_open, dtype=np.int16)
+def_gen.integers(-32768, I_i2_high_open, dtype=np.int16)
+def_gen.integers(I_i2_high_closed, dtype=np.int16, endpoint=True)
+def_gen.integers(I_i2_low, I_i2_high_closed, dtype=np.int16, endpoint=True)
+def_gen.integers(-32768, I_i2_high_closed, dtype=np.int16, endpoint=True)
+
+I_i4_low: np.ndarray[Any, np.dtype[np.int32]] = np.array([-2147483648], dtype=np.int32)
+I_i4_low_like: list[int] = [-2147483648]
+I_i4_high_open: np.ndarray[Any, np.dtype[np.int32]] = np.array([2147483647], dtype=np.int32)
+I_i4_high_closed: np.ndarray[Any, np.dtype[np.int32]] = np.array([2147483647], dtype=np.int32)
+
+def_gen.integers(2147483648, dtype="i4")
+def_gen.integers(-2147483648, 2147483648, dtype="i4")
+def_gen.integers(2147483647, dtype="i4", endpoint=True)
+def_gen.integers(-2147483648, 2147483647, dtype="i4", endpoint=True)
+def_gen.integers(I_i4_low_like, 2147483647, dtype="i4", endpoint=True)
+def_gen.integers(I_i4_high_open, dtype="i4")
+def_gen.integers(I_i4_low, I_i4_high_open, dtype="i4")
+def_gen.integers(-2147483648, I_i4_high_open, dtype="i4")
+def_gen.integers(I_i4_high_closed, dtype="i4", endpoint=True)
+def_gen.integers(I_i4_low, I_i4_high_closed, dtype="i4", endpoint=True)
+def_gen.integers(-2147483648, I_i4_high_closed, dtype="i4", endpoint=True)
+
+def_gen.integers(2147483648, dtype="int32")
+def_gen.integers(-2147483648, 2147483648, dtype="int32")
+def_gen.integers(2147483647, dtype="int32", endpoint=True)
+def_gen.integers(-2147483648, 2147483647, dtype="int32", endpoint=True)
+def_gen.integers(I_i4_low_like, 2147483647, dtype="int32", endpoint=True)
+def_gen.integers(I_i4_high_open, dtype="int32")
+def_gen.integers(I_i4_low, I_i4_high_open, dtype="int32")
+def_gen.integers(-2147483648, I_i4_high_open, dtype="int32")
+def_gen.integers(I_i4_high_closed, dtype="int32", endpoint=True)
+def_gen.integers(I_i4_low, I_i4_high_closed, dtype="int32", endpoint=True)
+def_gen.integers(-2147483648, I_i4_high_closed, dtype="int32", endpoint=True)
+
+def_gen.integers(2147483648, dtype=np.int32)
+def_gen.integers(-2147483648, 2147483648, dtype=np.int32)
+def_gen.integers(2147483647, dtype=np.int32, endpoint=True)
+def_gen.integers(-2147483648, 2147483647, dtype=np.int32, endpoint=True)
+def_gen.integers(I_i4_low_like, 2147483647, dtype=np.int32, endpoint=True)
+def_gen.integers(I_i4_high_open, dtype=np.int32)
+def_gen.integers(I_i4_low, I_i4_high_open, dtype=np.int32)
+def_gen.integers(-2147483648, I_i4_high_open, dtype=np.int32)
+def_gen.integers(I_i4_high_closed, dtype=np.int32, endpoint=True)
+def_gen.integers(I_i4_low, I_i4_high_closed, dtype=np.int32, endpoint=True)
+def_gen.integers(-2147483648, I_i4_high_closed, dtype=np.int32, endpoint=True)
+
+I_i8_low: np.ndarray[Any, np.dtype[np.int64]] = np.array([-9223372036854775808], dtype=np.int64)
+I_i8_low_like: list[int] = [-9223372036854775808]
+I_i8_high_open: np.ndarray[Any, np.dtype[np.int64]] = np.array([9223372036854775807], dtype=np.int64)
+I_i8_high_closed: np.ndarray[Any, np.dtype[np.int64]] = np.array([9223372036854775807], dtype=np.int64)
+
+def_gen.integers(9223372036854775808, dtype="i8")
+def_gen.integers(-9223372036854775808, 9223372036854775808, dtype="i8")
+def_gen.integers(9223372036854775807, dtype="i8", endpoint=True)
+def_gen.integers(-9223372036854775808, 9223372036854775807, dtype="i8", endpoint=True)
+def_gen.integers(I_i8_low_like, 9223372036854775807, dtype="i8", endpoint=True)
+def_gen.integers(I_i8_high_open, dtype="i8")
+def_gen.integers(I_i8_low, I_i8_high_open, dtype="i8")
+def_gen.integers(-9223372036854775808, I_i8_high_open, dtype="i8")
+def_gen.integers(I_i8_high_closed, dtype="i8", endpoint=True)
+def_gen.integers(I_i8_low, I_i8_high_closed, dtype="i8", endpoint=True)
+def_gen.integers(-9223372036854775808, I_i8_high_closed, dtype="i8", endpoint=True)
+
+def_gen.integers(9223372036854775808, dtype="int64")
+def_gen.integers(-9223372036854775808, 9223372036854775808, dtype="int64")
+def_gen.integers(9223372036854775807, dtype="int64", endpoint=True)
+def_gen.integers(-9223372036854775808, 9223372036854775807, dtype="int64", endpoint=True)
+def_gen.integers(I_i8_low_like, 9223372036854775807, dtype="int64", endpoint=True)
+def_gen.integers(I_i8_high_open, dtype="int64")
+def_gen.integers(I_i8_low, I_i8_high_open, dtype="int64")
+def_gen.integers(-9223372036854775808, I_i8_high_open, dtype="int64")
+def_gen.integers(I_i8_high_closed, dtype="int64", endpoint=True)
+def_gen.integers(I_i8_low, I_i8_high_closed, dtype="int64", endpoint=True)
+def_gen.integers(-9223372036854775808, I_i8_high_closed, dtype="int64", endpoint=True)
+
+def_gen.integers(9223372036854775808, dtype=np.int64)
+def_gen.integers(-9223372036854775808, 9223372036854775808, dtype=np.int64)
+def_gen.integers(9223372036854775807, dtype=np.int64, endpoint=True)
+def_gen.integers(-9223372036854775808, 9223372036854775807, dtype=np.int64, endpoint=True)
+def_gen.integers(I_i8_low_like, 9223372036854775807, dtype=np.int64, endpoint=True)
+def_gen.integers(I_i8_high_open, dtype=np.int64)
+def_gen.integers(I_i8_low, I_i8_high_open, dtype=np.int64)
+def_gen.integers(-9223372036854775808, I_i8_high_open, dtype=np.int64)
+def_gen.integers(I_i8_high_closed, dtype=np.int64, endpoint=True)
+def_gen.integers(I_i8_low, I_i8_high_closed, dtype=np.int64, endpoint=True)
+def_gen.integers(-9223372036854775808, I_i8_high_closed, dtype=np.int64, endpoint=True)
+
+
+def_gen.bit_generator
+
+def_gen.bytes(2)
+
+def_gen.choice(5)
+def_gen.choice(5, 3)
+def_gen.choice(5, 3, replace=True)
+def_gen.choice(5, 3, p=[1 / 5] * 5)
+def_gen.choice(5, 3, p=[1 / 5] * 5, replace=False)
+
+def_gen.choice(["pooh", "rabbit", "piglet", "Christopher"])
+def_gen.choice(["pooh", "rabbit", "piglet", "Christopher"], 3)
+def_gen.choice(["pooh", "rabbit", "piglet", "Christopher"], 3, p=[1 / 4] * 4)
+def_gen.choice(["pooh", "rabbit", "piglet", "Christopher"], 3, replace=True)
+def_gen.choice(["pooh", "rabbit", "piglet", "Christopher"], 3, replace=False, p=np.array([1 / 8, 1 / 8, 1 / 2, 1 / 4]))
+
+def_gen.dirichlet([0.5, 0.5])
+def_gen.dirichlet(np.array([0.5, 0.5]))
+def_gen.dirichlet(np.array([0.5, 0.5]), size=3)
+
+def_gen.multinomial(20, [1 / 6.0] * 6)
+def_gen.multinomial(20, np.array([0.5, 0.5]))
+def_gen.multinomial(20, [1 / 6.0] * 6, size=2)
+def_gen.multinomial([[10], [20]], [1 / 6.0] * 6, size=(2, 2))
+def_gen.multinomial(np.array([[10], [20]]), np.array([0.5, 0.5]), size=(2, 2))
+
+def_gen.multivariate_hypergeometric([3, 5, 7], 2)
+def_gen.multivariate_hypergeometric(np.array([3, 5, 7]), 2)
+def_gen.multivariate_hypergeometric(np.array([3, 5, 7]), 2, size=4)
+def_gen.multivariate_hypergeometric(np.array([3, 5, 7]), 2, size=(4, 7))
+def_gen.multivariate_hypergeometric([3, 5, 7], 2, method="count")
+def_gen.multivariate_hypergeometric(np.array([3, 5, 7]), 2, method="marginals")
+
+def_gen.multivariate_normal([0.0], [[1.0]])
+def_gen.multivariate_normal([0.0], np.array([[1.0]]))
+def_gen.multivariate_normal(np.array([0.0]), [[1.0]])
+def_gen.multivariate_normal([0.0], np.array([[1.0]]))
+
+def_gen.permutation(10)
+def_gen.permutation([1, 2, 3, 4])
+def_gen.permutation(np.array([1, 2, 3, 4]))
+def_gen.permutation(D_2D, axis=1)
+def_gen.permuted(D_2D)
+def_gen.permuted(D_2D_like)
+def_gen.permuted(D_2D, axis=1)
+def_gen.permuted(D_2D, out=D_2D)
+def_gen.permuted(D_2D_like, out=D_2D)
+def_gen.permuted(D_2D_like, out=D_2D)
+def_gen.permuted(D_2D, axis=1, out=D_2D)
+
+def_gen.shuffle(np.arange(10))
+def_gen.shuffle([1, 2, 3, 4, 5])
+def_gen.shuffle(D_2D, axis=1)
+
+def_gen.__str__()
+def_gen.__repr__()
+def_gen.__setstate__(dict(def_gen.bit_generator.state))
+
+# RandomState
+random_st: np.random.RandomState = np.random.RandomState()
+
+random_st.standard_normal()
+random_st.standard_normal(size=None)
+random_st.standard_normal(size=1)
+
+random_st.random()
+random_st.random(size=None)
+random_st.random(size=1)
+
+random_st.standard_cauchy()
+random_st.standard_cauchy(size=None)
+random_st.standard_cauchy(size=1)
+
+random_st.standard_exponential()
+random_st.standard_exponential(size=None)
+random_st.standard_exponential(size=1)
+
+random_st.zipf(1.5)
+random_st.zipf(1.5, size=None)
+random_st.zipf(1.5, size=1)
+random_st.zipf(D_arr_1p5)
+random_st.zipf(D_arr_1p5, size=1)
+random_st.zipf(D_arr_like_1p5)
+random_st.zipf(D_arr_like_1p5, size=1)
+
+random_st.weibull(0.5)
+random_st.weibull(0.5, size=None)
+random_st.weibull(0.5, size=1)
+random_st.weibull(D_arr_0p5)
+random_st.weibull(D_arr_0p5, size=1)
+random_st.weibull(D_arr_like_0p5)
+random_st.weibull(D_arr_like_0p5, size=1)
+
+random_st.standard_t(0.5)
+random_st.standard_t(0.5, size=None)
+random_st.standard_t(0.5, size=1)
+random_st.standard_t(D_arr_0p5)
+random_st.standard_t(D_arr_0p5, size=1)
+random_st.standard_t(D_arr_like_0p5)
+random_st.standard_t(D_arr_like_0p5, size=1)
+
+random_st.poisson(0.5)
+random_st.poisson(0.5, size=None)
+random_st.poisson(0.5, size=1)
+random_st.poisson(D_arr_0p5)
+random_st.poisson(D_arr_0p5, size=1)
+random_st.poisson(D_arr_like_0p5)
+random_st.poisson(D_arr_like_0p5, size=1)
+
+random_st.power(0.5)
+random_st.power(0.5, size=None)
+random_st.power(0.5, size=1)
+random_st.power(D_arr_0p5)
+random_st.power(D_arr_0p5, size=1)
+random_st.power(D_arr_like_0p5)
+random_st.power(D_arr_like_0p5, size=1)
+
+random_st.pareto(0.5)
+random_st.pareto(0.5, size=None)
+random_st.pareto(0.5, size=1)
+random_st.pareto(D_arr_0p5)
+random_st.pareto(D_arr_0p5, size=1)
+random_st.pareto(D_arr_like_0p5)
+random_st.pareto(D_arr_like_0p5, size=1)
+
+random_st.chisquare(0.5)
+random_st.chisquare(0.5, size=None)
+random_st.chisquare(0.5, size=1)
+random_st.chisquare(D_arr_0p5)
+random_st.chisquare(D_arr_0p5, size=1)
+random_st.chisquare(D_arr_like_0p5)
+random_st.chisquare(D_arr_like_0p5, size=1)
+
+random_st.exponential(0.5)
+random_st.exponential(0.5, size=None)
+random_st.exponential(0.5, size=1)
+random_st.exponential(D_arr_0p5)
+random_st.exponential(D_arr_0p5, size=1)
+random_st.exponential(D_arr_like_0p5)
+random_st.exponential(D_arr_like_0p5, size=1)
+
+random_st.geometric(0.5)
+random_st.geometric(0.5, size=None)
+random_st.geometric(0.5, size=1)
+random_st.geometric(D_arr_0p5)
+random_st.geometric(D_arr_0p5, size=1)
+random_st.geometric(D_arr_like_0p5)
+random_st.geometric(D_arr_like_0p5, size=1)
+
+random_st.logseries(0.5)
+random_st.logseries(0.5, size=None)
+random_st.logseries(0.5, size=1)
+random_st.logseries(D_arr_0p5)
+random_st.logseries(D_arr_0p5, size=1)
+random_st.logseries(D_arr_like_0p5)
+random_st.logseries(D_arr_like_0p5, size=1)
+
+random_st.rayleigh(0.5)
+random_st.rayleigh(0.5, size=None)
+random_st.rayleigh(0.5, size=1)
+random_st.rayleigh(D_arr_0p5)
+random_st.rayleigh(D_arr_0p5, size=1)
+random_st.rayleigh(D_arr_like_0p5)
+random_st.rayleigh(D_arr_like_0p5, size=1)
+
+random_st.standard_gamma(0.5)
+random_st.standard_gamma(0.5, size=None)
+random_st.standard_gamma(0.5, size=1)
+random_st.standard_gamma(D_arr_0p5)
+random_st.standard_gamma(D_arr_0p5, size=1)
+random_st.standard_gamma(D_arr_like_0p5)
+random_st.standard_gamma(D_arr_like_0p5, size=1)
+random_st.standard_gamma(D_arr_like_0p5, size=1)
+
+random_st.vonmises(0.5, 0.5)
+random_st.vonmises(0.5, 0.5, size=None)
+random_st.vonmises(0.5, 0.5, size=1)
+random_st.vonmises(D_arr_0p5, 0.5)
+random_st.vonmises(0.5, D_arr_0p5)
+random_st.vonmises(D_arr_0p5, 0.5, size=1)
+random_st.vonmises(0.5, D_arr_0p5, size=1)
+random_st.vonmises(D_arr_like_0p5, 0.5)
+random_st.vonmises(0.5, D_arr_like_0p5)
+random_st.vonmises(D_arr_0p5, D_arr_0p5)
+random_st.vonmises(D_arr_like_0p5, D_arr_like_0p5)
+random_st.vonmises(D_arr_0p5, D_arr_0p5, size=1)
+random_st.vonmises(D_arr_like_0p5, D_arr_like_0p5, size=1)
+
+random_st.wald(0.5, 0.5)
+random_st.wald(0.5, 0.5, size=None)
+random_st.wald(0.5, 0.5, size=1)
+random_st.wald(D_arr_0p5, 0.5)
+random_st.wald(0.5, D_arr_0p5)
+random_st.wald(D_arr_0p5, 0.5, size=1)
+random_st.wald(0.5, D_arr_0p5, size=1)
+random_st.wald(D_arr_like_0p5, 0.5)
+random_st.wald(0.5, D_arr_like_0p5)
+random_st.wald(D_arr_0p5, D_arr_0p5)
+random_st.wald(D_arr_like_0p5, D_arr_like_0p5)
+random_st.wald(D_arr_0p5, D_arr_0p5, size=1)
+random_st.wald(D_arr_like_0p5, D_arr_like_0p5, size=1)
+
+random_st.uniform(0.5, 0.5)
+random_st.uniform(0.5, 0.5, size=None)
+random_st.uniform(0.5, 0.5, size=1)
+random_st.uniform(D_arr_0p5, 0.5)
+random_st.uniform(0.5, D_arr_0p5)
+random_st.uniform(D_arr_0p5, 0.5, size=1)
+random_st.uniform(0.5, D_arr_0p5, size=1)
+random_st.uniform(D_arr_like_0p5, 0.5)
+random_st.uniform(0.5, D_arr_like_0p5)
+random_st.uniform(D_arr_0p5, D_arr_0p5)
+random_st.uniform(D_arr_like_0p5, D_arr_like_0p5)
+random_st.uniform(D_arr_0p5, D_arr_0p5, size=1)
+random_st.uniform(D_arr_like_0p5, D_arr_like_0p5, size=1)
+
+random_st.beta(0.5, 0.5)
+random_st.beta(0.5, 0.5, size=None)
+random_st.beta(0.5, 0.5, size=1)
+random_st.beta(D_arr_0p5, 0.5)
+random_st.beta(0.5, D_arr_0p5)
+random_st.beta(D_arr_0p5, 0.5, size=1)
+random_st.beta(0.5, D_arr_0p5, size=1)
+random_st.beta(D_arr_like_0p5, 0.5)
+random_st.beta(0.5, D_arr_like_0p5)
+random_st.beta(D_arr_0p5, D_arr_0p5)
+random_st.beta(D_arr_like_0p5, D_arr_like_0p5)
+random_st.beta(D_arr_0p5, D_arr_0p5, size=1)
+random_st.beta(D_arr_like_0p5, D_arr_like_0p5, size=1)
+
+random_st.f(0.5, 0.5)
+random_st.f(0.5, 0.5, size=None)
+random_st.f(0.5, 0.5, size=1)
+random_st.f(D_arr_0p5, 0.5)
+random_st.f(0.5, D_arr_0p5)
+random_st.f(D_arr_0p5, 0.5, size=1)
+random_st.f(0.5, D_arr_0p5, size=1)
+random_st.f(D_arr_like_0p5, 0.5)
+random_st.f(0.5, D_arr_like_0p5)
+random_st.f(D_arr_0p5, D_arr_0p5)
+random_st.f(D_arr_like_0p5, D_arr_like_0p5)
+random_st.f(D_arr_0p5, D_arr_0p5, size=1)
+random_st.f(D_arr_like_0p5, D_arr_like_0p5, size=1)
+
+random_st.gamma(0.5, 0.5)
+random_st.gamma(0.5, 0.5, size=None)
+random_st.gamma(0.5, 0.5, size=1)
+random_st.gamma(D_arr_0p5, 0.5)
+random_st.gamma(0.5, D_arr_0p5)
+random_st.gamma(D_arr_0p5, 0.5, size=1)
+random_st.gamma(0.5, D_arr_0p5, size=1)
+random_st.gamma(D_arr_like_0p5, 0.5)
+random_st.gamma(0.5, D_arr_like_0p5)
+random_st.gamma(D_arr_0p5, D_arr_0p5)
+random_st.gamma(D_arr_like_0p5, D_arr_like_0p5)
+random_st.gamma(D_arr_0p5, D_arr_0p5, size=1)
+random_st.gamma(D_arr_like_0p5, D_arr_like_0p5, size=1)
+
+random_st.gumbel(0.5, 0.5)
+random_st.gumbel(0.5, 0.5, size=None)
+random_st.gumbel(0.5, 0.5, size=1)
+random_st.gumbel(D_arr_0p5, 0.5)
+random_st.gumbel(0.5, D_arr_0p5)
+random_st.gumbel(D_arr_0p5, 0.5, size=1)
+random_st.gumbel(0.5, D_arr_0p5, size=1)
+random_st.gumbel(D_arr_like_0p5, 0.5)
+random_st.gumbel(0.5, D_arr_like_0p5)
+random_st.gumbel(D_arr_0p5, D_arr_0p5)
+random_st.gumbel(D_arr_like_0p5, D_arr_like_0p5)
+random_st.gumbel(D_arr_0p5, D_arr_0p5, size=1)
+random_st.gumbel(D_arr_like_0p5, D_arr_like_0p5, size=1)
+
+random_st.laplace(0.5, 0.5)
+random_st.laplace(0.5, 0.5, size=None)
+random_st.laplace(0.5, 0.5, size=1)
+random_st.laplace(D_arr_0p5, 0.5)
+random_st.laplace(0.5, D_arr_0p5)
+random_st.laplace(D_arr_0p5, 0.5, size=1)
+random_st.laplace(0.5, D_arr_0p5, size=1)
+random_st.laplace(D_arr_like_0p5, 0.5)
+random_st.laplace(0.5, D_arr_like_0p5)
+random_st.laplace(D_arr_0p5, D_arr_0p5)
+random_st.laplace(D_arr_like_0p5, D_arr_like_0p5)
+random_st.laplace(D_arr_0p5, D_arr_0p5, size=1)
+random_st.laplace(D_arr_like_0p5, D_arr_like_0p5, size=1)
+
+random_st.logistic(0.5, 0.5)
+random_st.logistic(0.5, 0.5, size=None)
+random_st.logistic(0.5, 0.5, size=1)
+random_st.logistic(D_arr_0p5, 0.5)
+random_st.logistic(0.5, D_arr_0p5)
+random_st.logistic(D_arr_0p5, 0.5, size=1)
+random_st.logistic(0.5, D_arr_0p5, size=1)
+random_st.logistic(D_arr_like_0p5, 0.5)
+random_st.logistic(0.5, D_arr_like_0p5)
+random_st.logistic(D_arr_0p5, D_arr_0p5)
+random_st.logistic(D_arr_like_0p5, D_arr_like_0p5)
+random_st.logistic(D_arr_0p5, D_arr_0p5, size=1)
+random_st.logistic(D_arr_like_0p5, D_arr_like_0p5, size=1)
+
+random_st.lognormal(0.5, 0.5)
+random_st.lognormal(0.5, 0.5, size=None)
+random_st.lognormal(0.5, 0.5, size=1)
+random_st.lognormal(D_arr_0p5, 0.5)
+random_st.lognormal(0.5, D_arr_0p5)
+random_st.lognormal(D_arr_0p5, 0.5, size=1)
+random_st.lognormal(0.5, D_arr_0p5, size=1)
+random_st.lognormal(D_arr_like_0p5, 0.5)
+random_st.lognormal(0.5, D_arr_like_0p5)
+random_st.lognormal(D_arr_0p5, D_arr_0p5)
+random_st.lognormal(D_arr_like_0p5, D_arr_like_0p5)
+random_st.lognormal(D_arr_0p5, D_arr_0p5, size=1)
+random_st.lognormal(D_arr_like_0p5, D_arr_like_0p5, size=1)
+
+random_st.noncentral_chisquare(0.5, 0.5)
+random_st.noncentral_chisquare(0.5, 0.5, size=None)
+random_st.noncentral_chisquare(0.5, 0.5, size=1)
+random_st.noncentral_chisquare(D_arr_0p5, 0.5)
+random_st.noncentral_chisquare(0.5, D_arr_0p5)
+random_st.noncentral_chisquare(D_arr_0p5, 0.5, size=1)
+random_st.noncentral_chisquare(0.5, D_arr_0p5, size=1)
+random_st.noncentral_chisquare(D_arr_like_0p5, 0.5)
+random_st.noncentral_chisquare(0.5, D_arr_like_0p5)
+random_st.noncentral_chisquare(D_arr_0p5, D_arr_0p5)
+random_st.noncentral_chisquare(D_arr_like_0p5, D_arr_like_0p5)
+random_st.noncentral_chisquare(D_arr_0p5, D_arr_0p5, size=1)
+random_st.noncentral_chisquare(D_arr_like_0p5, D_arr_like_0p5, size=1)
+
+random_st.normal(0.5, 0.5)
+random_st.normal(0.5, 0.5, size=None)
+random_st.normal(0.5, 0.5, size=1)
+random_st.normal(D_arr_0p5, 0.5)
+random_st.normal(0.5, D_arr_0p5)
+random_st.normal(D_arr_0p5, 0.5, size=1)
+random_st.normal(0.5, D_arr_0p5, size=1)
+random_st.normal(D_arr_like_0p5, 0.5)
+random_st.normal(0.5, D_arr_like_0p5)
+random_st.normal(D_arr_0p5, D_arr_0p5)
+random_st.normal(D_arr_like_0p5, D_arr_like_0p5)
+random_st.normal(D_arr_0p5, D_arr_0p5, size=1)
+random_st.normal(D_arr_like_0p5, D_arr_like_0p5, size=1)
+
+random_st.triangular(0.1, 0.5, 0.9)
+random_st.triangular(0.1, 0.5, 0.9, size=None)
+random_st.triangular(0.1, 0.5, 0.9, size=1)
+random_st.triangular(D_arr_0p1, 0.5, 0.9)
+random_st.triangular(0.1, D_arr_0p5, 0.9)
+random_st.triangular(D_arr_0p1, 0.5, D_arr_like_0p9, size=1)
+random_st.triangular(0.1, D_arr_0p5, 0.9, size=1)
+random_st.triangular(D_arr_like_0p1, 0.5, D_arr_0p9)
+random_st.triangular(0.5, D_arr_like_0p5, 0.9)
+random_st.triangular(D_arr_0p1, D_arr_0p5, 0.9)
+random_st.triangular(D_arr_like_0p1, D_arr_like_0p5, 0.9)
+random_st.triangular(D_arr_0p1, D_arr_0p5, D_arr_0p9, size=1)
+random_st.triangular(D_arr_like_0p1, D_arr_like_0p5, D_arr_like_0p9, size=1)
+
+random_st.noncentral_f(0.1, 0.5, 0.9)
+random_st.noncentral_f(0.1, 0.5, 0.9, size=None)
+random_st.noncentral_f(0.1, 0.5, 0.9, size=1)
+random_st.noncentral_f(D_arr_0p1, 0.5, 0.9)
+random_st.noncentral_f(0.1, D_arr_0p5, 0.9)
+random_st.noncentral_f(D_arr_0p1, 0.5, D_arr_like_0p9, size=1)
+random_st.noncentral_f(0.1, D_arr_0p5, 0.9, size=1)
+random_st.noncentral_f(D_arr_like_0p1, 0.5, D_arr_0p9)
+random_st.noncentral_f(0.5, D_arr_like_0p5, 0.9)
+random_st.noncentral_f(D_arr_0p1, D_arr_0p5, 0.9)
+random_st.noncentral_f(D_arr_like_0p1, D_arr_like_0p5, 0.9)
+random_st.noncentral_f(D_arr_0p1, D_arr_0p5, D_arr_0p9, size=1)
+random_st.noncentral_f(D_arr_like_0p1, D_arr_like_0p5, D_arr_like_0p9, size=1)
+
+random_st.binomial(10, 0.5)
+random_st.binomial(10, 0.5, size=None)
+random_st.binomial(10, 0.5, size=1)
+random_st.binomial(I_arr_10, 0.5)
+random_st.binomial(10, D_arr_0p5)
+random_st.binomial(I_arr_10, 0.5, size=1)
+random_st.binomial(10, D_arr_0p5, size=1)
+random_st.binomial(I_arr_like_10, 0.5)
+random_st.binomial(10, D_arr_like_0p5)
+random_st.binomial(I_arr_10, D_arr_0p5)
+random_st.binomial(I_arr_like_10, D_arr_like_0p5)
+random_st.binomial(I_arr_10, D_arr_0p5, size=1)
+random_st.binomial(I_arr_like_10, D_arr_like_0p5, size=1)
+
+random_st.negative_binomial(10, 0.5)
+random_st.negative_binomial(10, 0.5, size=None)
+random_st.negative_binomial(10, 0.5, size=1)
+random_st.negative_binomial(I_arr_10, 0.5)
+random_st.negative_binomial(10, D_arr_0p5)
+random_st.negative_binomial(I_arr_10, 0.5, size=1)
+random_st.negative_binomial(10, D_arr_0p5, size=1)
+random_st.negative_binomial(I_arr_like_10, 0.5)
+random_st.negative_binomial(10, D_arr_like_0p5)
+random_st.negative_binomial(I_arr_10, D_arr_0p5)
+random_st.negative_binomial(I_arr_like_10, D_arr_like_0p5)
+random_st.negative_binomial(I_arr_10, D_arr_0p5, size=1)
+random_st.negative_binomial(I_arr_like_10, D_arr_like_0p5, size=1)
+
+random_st.hypergeometric(20, 20, 10)
+random_st.hypergeometric(20, 20, 10, size=None)
+random_st.hypergeometric(20, 20, 10, size=1)
+random_st.hypergeometric(I_arr_20, 20, 10)
+random_st.hypergeometric(20, I_arr_20, 10)
+random_st.hypergeometric(I_arr_20, 20, I_arr_like_10, size=1)
+random_st.hypergeometric(20, I_arr_20, 10, size=1)
+random_st.hypergeometric(I_arr_like_20, 20, I_arr_10)
+random_st.hypergeometric(20, I_arr_like_20, 10)
+random_st.hypergeometric(I_arr_20, I_arr_20, 10)
+random_st.hypergeometric(I_arr_like_20, I_arr_like_20, 10)
+random_st.hypergeometric(I_arr_20, I_arr_20, I_arr_10, size=1)
+random_st.hypergeometric(I_arr_like_20, I_arr_like_20, I_arr_like_10, size=1)
+
+random_st.randint(0, 100)
+random_st.randint(100)
+random_st.randint([100])
+random_st.randint(0, [100])
+
+random_st.randint(2, dtype=bool)
+random_st.randint(0, 2, dtype=bool)
+random_st.randint(I_bool_high_open, dtype=bool)
+random_st.randint(I_bool_low, I_bool_high_open, dtype=bool)
+random_st.randint(0, I_bool_high_open, dtype=bool)
+
+random_st.randint(2, dtype=np.bool)
+random_st.randint(0, 2, dtype=np.bool)
+random_st.randint(I_bool_high_open, dtype=np.bool)
+random_st.randint(I_bool_low, I_bool_high_open, dtype=np.bool)
+random_st.randint(0, I_bool_high_open, dtype=np.bool)
+
+random_st.randint(256, dtype="u1")
+random_st.randint(0, 256, dtype="u1")
+random_st.randint(I_u1_high_open, dtype="u1")
+random_st.randint(I_u1_low, I_u1_high_open, dtype="u1")
+random_st.randint(0, I_u1_high_open, dtype="u1")
+
+random_st.randint(256, dtype="uint8")
+random_st.randint(0, 256, dtype="uint8")
+random_st.randint(I_u1_high_open, dtype="uint8")
+random_st.randint(I_u1_low, I_u1_high_open, dtype="uint8")
+random_st.randint(0, I_u1_high_open, dtype="uint8")
+
+random_st.randint(256, dtype=np.uint8)
+random_st.randint(0, 256, dtype=np.uint8)
+random_st.randint(I_u1_high_open, dtype=np.uint8)
+random_st.randint(I_u1_low, I_u1_high_open, dtype=np.uint8)
+random_st.randint(0, I_u1_high_open, dtype=np.uint8)
+
+random_st.randint(65536, dtype="u2")
+random_st.randint(0, 65536, dtype="u2")
+random_st.randint(I_u2_high_open, dtype="u2")
+random_st.randint(I_u2_low, I_u2_high_open, dtype="u2")
+random_st.randint(0, I_u2_high_open, dtype="u2")
+
+random_st.randint(65536, dtype="uint16")
+random_st.randint(0, 65536, dtype="uint16")
+random_st.randint(I_u2_high_open, dtype="uint16")
+random_st.randint(I_u2_low, I_u2_high_open, dtype="uint16")
+random_st.randint(0, I_u2_high_open, dtype="uint16")
+
+random_st.randint(65536, dtype=np.uint16)
+random_st.randint(0, 65536, dtype=np.uint16)
+random_st.randint(I_u2_high_open, dtype=np.uint16)
+random_st.randint(I_u2_low, I_u2_high_open, dtype=np.uint16)
+random_st.randint(0, I_u2_high_open, dtype=np.uint16)
+
+random_st.randint(4294967296, dtype="u4")
+random_st.randint(0, 4294967296, dtype="u4")
+random_st.randint(I_u4_high_open, dtype="u4")
+random_st.randint(I_u4_low, I_u4_high_open, dtype="u4")
+random_st.randint(0, I_u4_high_open, dtype="u4")
+
+random_st.randint(4294967296, dtype="uint32")
+random_st.randint(0, 4294967296, dtype="uint32")
+random_st.randint(I_u4_high_open, dtype="uint32")
+random_st.randint(I_u4_low, I_u4_high_open, dtype="uint32")
+random_st.randint(0, I_u4_high_open, dtype="uint32")
+
+random_st.randint(4294967296, dtype=np.uint32)
+random_st.randint(0, 4294967296, dtype=np.uint32)
+random_st.randint(I_u4_high_open, dtype=np.uint32)
+random_st.randint(I_u4_low, I_u4_high_open, dtype=np.uint32)
+random_st.randint(0, I_u4_high_open, dtype=np.uint32)
+
+
+random_st.randint(18446744073709551616, dtype="u8")
+random_st.randint(0, 18446744073709551616, dtype="u8")
+random_st.randint(I_u8_high_open, dtype="u8")
+random_st.randint(I_u8_low, I_u8_high_open, dtype="u8")
+random_st.randint(0, I_u8_high_open, dtype="u8")
+
+random_st.randint(18446744073709551616, dtype="uint64")
+random_st.randint(0, 18446744073709551616, dtype="uint64")
+random_st.randint(I_u8_high_open, dtype="uint64")
+random_st.randint(I_u8_low, I_u8_high_open, dtype="uint64")
+random_st.randint(0, I_u8_high_open, dtype="uint64")
+
+random_st.randint(18446744073709551616, dtype=np.uint64)
+random_st.randint(0, 18446744073709551616, dtype=np.uint64)
+random_st.randint(I_u8_high_open, dtype=np.uint64)
+random_st.randint(I_u8_low, I_u8_high_open, dtype=np.uint64)
+random_st.randint(0, I_u8_high_open, dtype=np.uint64)
+
+random_st.randint(128, dtype="i1")
+random_st.randint(-128, 128, dtype="i1")
+random_st.randint(I_i1_high_open, dtype="i1")
+random_st.randint(I_i1_low, I_i1_high_open, dtype="i1")
+random_st.randint(-128, I_i1_high_open, dtype="i1")
+
+random_st.randint(128, dtype="int8")
+random_st.randint(-128, 128, dtype="int8")
+random_st.randint(I_i1_high_open, dtype="int8")
+random_st.randint(I_i1_low, I_i1_high_open, dtype="int8")
+random_st.randint(-128, I_i1_high_open, dtype="int8")
+
+random_st.randint(128, dtype=np.int8)
+random_st.randint(-128, 128, dtype=np.int8)
+random_st.randint(I_i1_high_open, dtype=np.int8)
+random_st.randint(I_i1_low, I_i1_high_open, dtype=np.int8)
+random_st.randint(-128, I_i1_high_open, dtype=np.int8)
+
+random_st.randint(32768, dtype="i2")
+random_st.randint(-32768, 32768, dtype="i2")
+random_st.randint(I_i2_high_open, dtype="i2")
+random_st.randint(I_i2_low, I_i2_high_open, dtype="i2")
+random_st.randint(-32768, I_i2_high_open, dtype="i2")
+random_st.randint(32768, dtype="int16")
+random_st.randint(-32768, 32768, dtype="int16")
+random_st.randint(I_i2_high_open, dtype="int16")
+random_st.randint(I_i2_low, I_i2_high_open, dtype="int16")
+random_st.randint(-32768, I_i2_high_open, dtype="int16")
+random_st.randint(32768, dtype=np.int16)
+random_st.randint(-32768, 32768, dtype=np.int16)
+random_st.randint(I_i2_high_open, dtype=np.int16)
+random_st.randint(I_i2_low, I_i2_high_open, dtype=np.int16)
+random_st.randint(-32768, I_i2_high_open, dtype=np.int16)
+
+random_st.randint(2147483648, dtype="i4")
+random_st.randint(-2147483648, 2147483648, dtype="i4")
+random_st.randint(I_i4_high_open, dtype="i4")
+random_st.randint(I_i4_low, I_i4_high_open, dtype="i4")
+random_st.randint(-2147483648, I_i4_high_open, dtype="i4")
+
+random_st.randint(2147483648, dtype="int32")
+random_st.randint(-2147483648, 2147483648, dtype="int32")
+random_st.randint(I_i4_high_open, dtype="int32")
+random_st.randint(I_i4_low, I_i4_high_open, dtype="int32")
+random_st.randint(-2147483648, I_i4_high_open, dtype="int32")
+
+random_st.randint(2147483648, dtype=np.int32)
+random_st.randint(-2147483648, 2147483648, dtype=np.int32)
+random_st.randint(I_i4_high_open, dtype=np.int32)
+random_st.randint(I_i4_low, I_i4_high_open, dtype=np.int32)
+random_st.randint(-2147483648, I_i4_high_open, dtype=np.int32)
+
+random_st.randint(9223372036854775808, dtype="i8")
+random_st.randint(-9223372036854775808, 9223372036854775808, dtype="i8")
+random_st.randint(I_i8_high_open, dtype="i8")
+random_st.randint(I_i8_low, I_i8_high_open, dtype="i8")
+random_st.randint(-9223372036854775808, I_i8_high_open, dtype="i8")
+
+random_st.randint(9223372036854775808, dtype="int64")
+random_st.randint(-9223372036854775808, 9223372036854775808, dtype="int64")
+random_st.randint(I_i8_high_open, dtype="int64")
+random_st.randint(I_i8_low, I_i8_high_open, dtype="int64")
+random_st.randint(-9223372036854775808, I_i8_high_open, dtype="int64")
+
+random_st.randint(9223372036854775808, dtype=np.int64)
+random_st.randint(-9223372036854775808, 9223372036854775808, dtype=np.int64)
+random_st.randint(I_i8_high_open, dtype=np.int64)
+random_st.randint(I_i8_low, I_i8_high_open, dtype=np.int64)
+random_st.randint(-9223372036854775808, I_i8_high_open, dtype=np.int64)
+
+bg: np.random.BitGenerator = random_st._bit_generator
+
+random_st.bytes(2)
+
+random_st.choice(5)
+random_st.choice(5, 3)
+random_st.choice(5, 3, replace=True)
+random_st.choice(5, 3, p=[1 / 5] * 5)
+random_st.choice(5, 3, p=[1 / 5] * 5, replace=False)
+
+random_st.choice(["pooh", "rabbit", "piglet", "Christopher"])
+random_st.choice(["pooh", "rabbit", "piglet", "Christopher"], 3)
+random_st.choice(["pooh", "rabbit", "piglet", "Christopher"], 3, p=[1 / 4] * 4)
+random_st.choice(["pooh", "rabbit", "piglet", "Christopher"], 3, replace=True)
+random_st.choice(["pooh", "rabbit", "piglet", "Christopher"], 3, replace=False, p=np.array([1 / 8, 1 / 8, 1 / 2, 1 / 4]))
+
+random_st.dirichlet([0.5, 0.5])
+random_st.dirichlet(np.array([0.5, 0.5]))
+random_st.dirichlet(np.array([0.5, 0.5]), size=3)
+
+random_st.multinomial(20, [1 / 6.0] * 6)
+random_st.multinomial(20, np.array([0.5, 0.5]))
+random_st.multinomial(20, [1 / 6.0] * 6, size=2)
+
+random_st.multivariate_normal([0.0], [[1.0]])
+random_st.multivariate_normal([0.0], np.array([[1.0]]))
+random_st.multivariate_normal(np.array([0.0]), [[1.0]])
+random_st.multivariate_normal([0.0], np.array([[1.0]]))
+
+random_st.permutation(10)
+random_st.permutation([1, 2, 3, 4])
+random_st.permutation(np.array([1, 2, 3, 4]))
+random_st.permutation(D_2D)
+
+random_st.shuffle(np.arange(10))
+random_st.shuffle([1, 2, 3, 4, 5])
+random_st.shuffle(D_2D)
+
+np.random.RandomState(SEED_PCG64)
+np.random.RandomState(0)
+np.random.RandomState([0, 1, 2])
+random_st.__str__()
+random_st.__repr__()
+random_st_state = random_st.__getstate__()
+random_st.__setstate__(random_st_state)
+random_st.seed()
+random_st.seed(1)
+random_st.seed([0, 1])
+random_st_get_state = random_st.get_state()
+random_st_get_state_legacy = random_st.get_state(legacy=True)
+random_st.set_state(random_st_get_state)
+
+random_st.rand()
+random_st.rand(1)
+random_st.rand(1, 2)
+random_st.randn()
+random_st.randn(1)
+random_st.randn(1, 2)
+random_st.random_sample()
+random_st.random_sample(1)
+random_st.random_sample(size=(1, 2))
+
+random_st.tomaxint()
+random_st.tomaxint(1)
+random_st.tomaxint((1,))
+
+np.random.set_bit_generator(SEED_PCG64)
+np.random.get_bit_generator()
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/scalars.py b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/scalars.py
new file mode 100644
index 00000000..53caf7ff
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/scalars.py
@@ -0,0 +1,240 @@
+import sys
+import datetime as dt
+
+import pytest
+import numpy as np
+
+b =  np.bool()
+b_ = np.bool_()
+u8 = np.uint64()
+i8 = np.int64()
+f8 = np.float64()
+c16 = np.complex128()
+U = np.str_()
+S = np.bytes_()
+
+
+# Construction
+class D:
+    def __index__(self) -> int:
+        return 0
+
+
+class C:
+    def __complex__(self) -> complex:
+        return 3j
+
+
+class B:
+    def __int__(self) -> int:
+        return 4
+
+
+class A:
+    def __float__(self) -> float:
+        return 4.0
+
+
+np.complex64(3j)
+np.complex64(A())
+np.complex64(C())
+np.complex128(3j)
+np.complex128(C())
+np.complex128(None)
+np.complex64("1.2")
+np.complex128(b"2j")
+
+np.int8(4)
+np.int16(3.4)
+np.int32(4)
+np.int64(-1)
+np.uint8(B())
+np.uint32()
+np.int32("1")
+np.int64(b"2")
+
+np.float16(A())
+np.float32(16)
+np.float64(3.0)
+np.float64(None)
+np.float32("1")
+np.float16(b"2.5")
+
+np.uint64(D())
+np.float32(D())
+np.complex64(D())
+
+np.bytes_(b"hello")
+np.bytes_("hello", 'utf-8')
+np.bytes_("hello", encoding='utf-8')
+np.str_("hello")
+np.str_(b"hello", 'utf-8')
+np.str_(b"hello", encoding='utf-8')
+
+# Array-ish semantics
+np.int8().real
+np.int16().imag
+np.int32().data
+np.int64().flags
+
+np.uint8().itemsize * 2
+np.uint16().ndim + 1
+np.uint32().strides
+np.uint64().shape
+
+# Time structures
+np.datetime64()
+np.datetime64(0, "D")
+np.datetime64(0, b"D")
+np.datetime64(0, ('ms', 3))
+np.datetime64("2019")
+np.datetime64(b"2019")
+np.datetime64("2019", "D")
+np.datetime64(np.datetime64())
+np.datetime64(dt.datetime(2000, 5, 3))
+np.datetime64(dt.date(2000, 5, 3))
+np.datetime64(None)
+np.datetime64(None, "D")
+
+np.timedelta64()
+np.timedelta64(0)
+np.timedelta64(0, "D")
+np.timedelta64(0, ('ms', 3))
+np.timedelta64(0, b"D")
+np.timedelta64("3")
+np.timedelta64(b"5")
+np.timedelta64(np.timedelta64(2))
+np.timedelta64(dt.timedelta(2))
+np.timedelta64(None)
+np.timedelta64(None, "D")
+
+np.void(1)
+np.void(np.int64(1))
+np.void(True)
+np.void(np.bool(True))
+np.void(b"test")
+np.void(np.bytes_("test"))
+np.void(object(), [("a", "O"), ("b", "O")])
+np.void(object(), dtype=[("a", "O"), ("b", "O")])
+
+# Protocols
+i8 = np.int64()
+u8 = np.uint64()
+f8 = np.float64()
+c16 = np.complex128()
+b = np.bool()
+td = np.timedelta64()
+U = np.str_("1")
+S = np.bytes_("1")
+AR = np.array(1, dtype=np.float64)
+
+int(i8)
+int(u8)
+int(f8)
+int(b)
+int(td)
+int(U)
+int(S)
+int(AR)
+with pytest.warns(np.exceptions.ComplexWarning):
+    int(c16)
+
+float(i8)
+float(u8)
+float(f8)
+float(b_)
+float(td)
+float(U)
+float(S)
+float(AR)
+with pytest.warns(np.exceptions.ComplexWarning):
+    float(c16)
+
+complex(i8)
+complex(u8)
+complex(f8)
+complex(c16)
+complex(b_)
+complex(td)
+complex(U)
+complex(AR)
+
+
+# Misc
+c16.dtype
+c16.real
+c16.imag
+c16.real.real
+c16.real.imag
+c16.ndim
+c16.size
+c16.itemsize
+c16.shape
+c16.strides
+c16.squeeze()
+c16.byteswap()
+c16.transpose()
+
+# Aliases
+np.byte()
+np.short()
+np.intc()
+np.intp()
+np.int_()
+np.longlong()
+
+np.ubyte()
+np.ushort()
+np.uintc()
+np.uintp()
+np.uint()
+np.ulonglong()
+
+np.half()
+np.single()
+np.double()
+np.longdouble()
+
+np.csingle()
+np.cdouble()
+np.clongdouble()
+
+b.item()
+i8.item()
+u8.item()
+f8.item()
+c16.item()
+U.item()
+S.item()
+
+b.tolist()
+i8.tolist()
+u8.tolist()
+f8.tolist()
+c16.tolist()
+U.tolist()
+S.tolist()
+
+b.ravel()
+i8.ravel()
+u8.ravel()
+f8.ravel()
+c16.ravel()
+U.ravel()
+S.ravel()
+
+b.flatten()
+i8.flatten()
+u8.flatten()
+f8.flatten()
+c16.flatten()
+U.flatten()
+S.flatten()
+
+b.reshape(1)
+i8.reshape(1)
+u8.reshape(1)
+f8.reshape(1)
+c16.reshape(1)
+U.reshape(1)
+S.reshape(1)
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/shape.py b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/shape.py
new file mode 100644
index 00000000..8e2e2faa
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/shape.py
@@ -0,0 +1,18 @@
+from typing import Any, NamedTuple
+
+import numpy as np
+from typing_extensions import assert_type
+
+
+# Subtype of tuple[int, int]
+class XYGrid(NamedTuple):
+    x_axis: int
+    y_axis: int
+
+arr: np.ndarray[XYGrid, Any] = np.empty(XYGrid(2, 2))
+
+# Test variance of _ShapeType_co
+def accepts_2d(a: np.ndarray[tuple[int, int], Any]) -> None:
+    return None
+
+accepts_2d(arr)
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/simple.py b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/simple.py
new file mode 100644
index 00000000..1337bd52
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/simple.py
@@ -0,0 +1,164 @@
+"""Simple expression that should pass with mypy."""
+import operator
+
+import numpy as np
+import numpy.typing as npt
+from collections.abc import Iterable
+
+# Basic checks
+array = np.array([1, 2])
+
+
+def ndarray_func(x: npt.NDArray[np.float64]) -> npt.NDArray[np.float64]:
+    return x
+
+
+ndarray_func(np.array([1, 2], dtype=np.float64))
+array == 1
+array.dtype == float
+
+# Dtype construction
+np.dtype(float)
+np.dtype(np.float64)
+np.dtype(None)
+np.dtype("float64")
+np.dtype(np.dtype(float))
+np.dtype(("U", 10))
+np.dtype((np.int32, (2, 2)))
+# Define the arguments on the previous line to prevent bidirectional
+# type inference in mypy from broadening the types.
+two_tuples_dtype = [("R", "u1"), ("G", "u1"), ("B", "u1")]
+np.dtype(two_tuples_dtype)
+
+three_tuples_dtype = [("R", "u1", 2)]
+np.dtype(three_tuples_dtype)
+
+mixed_tuples_dtype = [("R", "u1"), ("G", np.str_, 1)]
+np.dtype(mixed_tuples_dtype)
+
+shape_tuple_dtype = [("R", "u1", (2, 2))]
+np.dtype(shape_tuple_dtype)
+
+shape_like_dtype = [("R", "u1", (2, 2)), ("G", np.str_, 1)]
+np.dtype(shape_like_dtype)
+
+object_dtype = [("field1", object)]
+np.dtype(object_dtype)
+
+np.dtype((np.int32, (np.int8, 4)))
+
+# Dtype comparison
+np.dtype(float) == float
+np.dtype(float) != np.float64
+np.dtype(float) < None
+np.dtype(float) <= "float64"
+np.dtype(float) > np.dtype(float)
+np.dtype(float) >= np.dtype(("U", 10))
+
+# Iteration and indexing
+def iterable_func(x: Iterable[object]) -> Iterable[object]:
+    return x
+
+
+iterable_func(array)
+[element for element in array]
+iter(array)
+zip(array, array)
+array[1]
+array[:]
+array[...]
+array[:] = 0
+
+array_2d = np.ones((3, 3))
+array_2d[:2, :2]
+array_2d[..., 0]
+array_2d[:2, :2] = 0
+
+# Other special methods
+len(array)
+str(array)
+array_scalar = np.array(1)
+int(array_scalar)
+float(array_scalar)
+# currently does not work due to https://github.com/python/typeshed/issues/1904
+# complex(array_scalar)
+bytes(array_scalar)
+operator.index(array_scalar)
+bool(array_scalar)
+
+# comparisons
+array < 1
+array <= 1
+array == 1
+array != 1
+array > 1
+array >= 1
+1 < array
+1 <= array
+1 == array
+1 != array
+1 > array
+1 >= array
+
+# binary arithmetic
+array + 1
+1 + array
+array += 1
+
+array - 1
+1 - array
+array -= 1
+
+array * 1
+1 * array
+array *= 1
+
+nonzero_array = np.array([1, 2])
+array / 1
+1 / nonzero_array
+float_array = np.array([1.0, 2.0])
+float_array /= 1
+
+array // 1
+1 // nonzero_array
+array //= 1
+
+array % 1
+1 % nonzero_array
+array %= 1
+
+divmod(array, 1)
+divmod(1, nonzero_array)
+
+array ** 1
+1 ** array
+array **= 1
+
+array << 1
+1 << array
+array <<= 1
+
+array >> 1
+1 >> array
+array >>= 1
+
+array & 1
+1 & array
+array &= 1
+
+array ^ 1
+1 ^ array
+array ^= 1
+
+array | 1
+1 | array
+array |= 1
+
+# unary arithmetic
+-array
++array
+abs(array)
+~array
+
+# Other methods
+np.array([1, 2]).transpose()
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/simple_py3.py b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/simple_py3.py
new file mode 100644
index 00000000..c05a1ce6
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/simple_py3.py
@@ -0,0 +1,6 @@
+import numpy as np
+
+array = np.array([1, 2])
+
+# The @ operator is not in python 2
+array @ array
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/ufunc_config.py b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/ufunc_config.py
new file mode 100644
index 00000000..778e1b57
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/ufunc_config.py
@@ -0,0 +1,64 @@
+"""Typing tests for `numpy._core._ufunc_config`."""
+
+import numpy as np
+
+
+def func1(a: str, b: int) -> None:
+    return None
+
+
+def func2(a: str, b: int, c: float = 1.0) -> None:
+    return None
+
+
+def func3(a: str, b: int) -> int:
+    return 0
+
+
+class Write1:
+    def write(self, a: str) -> None:
+        return None
+
+
+class Write2:
+    def write(self, a: str, b: int = 1) -> None:
+        return None
+
+
+class Write3:
+    def write(self, a: str) -> int:
+        return 0
+
+
+_err_default = np.geterr()
+_bufsize_default = np.getbufsize()
+_errcall_default = np.geterrcall()
+
+try:
+    np.seterr(all=None)
+    np.seterr(divide="ignore")
+    np.seterr(over="warn")
+    np.seterr(under="call")
+    np.seterr(invalid="raise")
+    np.geterr()
+
+    np.setbufsize(4096)
+    np.getbufsize()
+
+    np.seterrcall(func1)
+    np.seterrcall(func2)
+    np.seterrcall(func3)
+    np.seterrcall(Write1())
+    np.seterrcall(Write2())
+    np.seterrcall(Write3())
+    np.geterrcall()
+
+    with np.errstate(call=func1, all="call"):
+        pass
+    with np.errstate(call=Write1(), divide="log", over="log"):
+        pass
+
+finally:
+    np.seterr(**_err_default)
+    np.setbufsize(_bufsize_default)
+    np.seterrcall(_errcall_default)
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/ufunclike.py b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/ufunclike.py
new file mode 100644
index 00000000..f993939d
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/ufunclike.py
@@ -0,0 +1,47 @@
+from __future__ import annotations
+from typing import Any
+import numpy as np
+
+
+class Object:
+    def __ceil__(self) -> Object:
+        return self
+
+    def __floor__(self) -> Object:
+        return self
+
+    def __ge__(self, value: object) -> bool:
+        return True
+
+    def __array__(self, dtype: np.typing.DTypeLike | None = None,
+                  copy: bool | None = None) -> np.ndarray[Any, np.dtype[np.object_]]:
+        ret = np.empty((), dtype=object)
+        ret[()] = self
+        return ret
+
+
+AR_LIKE_b = [True, True, False]
+AR_LIKE_u = [np.uint32(1), np.uint32(2), np.uint32(3)]
+AR_LIKE_i = [1, 2, 3]
+AR_LIKE_f = [1.0, 2.0, 3.0]
+AR_LIKE_O = [Object(), Object(), Object()]
+AR_U: np.ndarray[Any, np.dtype[np.str_]] = np.zeros(3, dtype="U5")
+
+np.fix(AR_LIKE_b)
+np.fix(AR_LIKE_u)
+np.fix(AR_LIKE_i)
+np.fix(AR_LIKE_f)
+np.fix(AR_LIKE_O)
+np.fix(AR_LIKE_f, out=AR_U)
+
+np.isposinf(AR_LIKE_b)
+np.isposinf(AR_LIKE_u)
+np.isposinf(AR_LIKE_i)
+np.isposinf(AR_LIKE_f)
+np.isposinf(AR_LIKE_f, out=AR_U)
+
+np.isneginf(AR_LIKE_b)
+np.isneginf(AR_LIKE_u)
+np.isneginf(AR_LIKE_i)
+np.isneginf(AR_LIKE_f)
+np.isneginf(AR_LIKE_f, out=AR_U)
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/ufuncs.py b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/ufuncs.py
new file mode 100644
index 00000000..dbc61bb0
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/ufuncs.py
@@ -0,0 +1,16 @@
+import numpy as np
+
+np.sin(1)
+np.sin([1, 2, 3])
+np.sin(1, out=np.empty(1))
+np.matmul(np.ones((2, 2, 2)), np.ones((2, 2, 2)), axes=[(0, 1), (0, 1), (0, 1)])
+np.sin(1, signature="D->D")
+# NOTE: `np.generic` subclasses are not guaranteed to support addition;
+# re-enable this we can infer the exact return type of `np.sin(...)`.
+#
+# np.sin(1) + np.sin(1)
+np.sin.types[0]
+np.sin.__name__
+np.sin.__doc__
+
+np.abs(np.array([1]))
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/warnings_and_errors.py b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/warnings_and_errors.py
new file mode 100644
index 00000000..c351afb0
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/pass/warnings_and_errors.py
@@ -0,0 +1,6 @@
+import numpy.exceptions as ex
+
+ex.AxisError("test")
+ex.AxisError(1, ndim=2)
+ex.AxisError(1, ndim=2, msg_prefix="error")
+ex.AxisError(1, ndim=2, msg_prefix=None)
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/arithmetic.pyi b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/arithmetic.pyi
new file mode 100644
index 00000000..003affe0
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/arithmetic.pyi
@@ -0,0 +1,516 @@
+import sys
+from typing import Any
+
+import numpy as np
+import numpy.typing as npt
+from numpy._typing import _32Bit,_64Bit, _128Bit
+
+if sys.version_info >= (3, 11):
+    from typing import assert_type
+else:
+    from typing_extensions import assert_type
+
+# Can't directly import `np.float128` as it is not available on all platforms
+f16: np.floating[_128Bit]
+
+c16 = np.complex128()
+f8 = np.float64()
+i8 = np.int64()
+u8 = np.uint64()
+
+c8 = np.complex64()
+f4 = np.float32()
+i4 = np.int32()
+u4 = np.uint32()
+
+dt = np.datetime64(0, "D")
+td = np.timedelta64(0, "D")
+
+b_ = np.bool()
+
+b = bool()
+c = complex()
+f = float()
+i = int()
+
+AR_b: npt.NDArray[np.bool]
+AR_u: npt.NDArray[np.uint32]
+AR_i: npt.NDArray[np.int64]
+AR_f: npt.NDArray[np.float64]
+AR_c: npt.NDArray[np.complex128]
+AR_m: npt.NDArray[np.timedelta64]
+AR_M: npt.NDArray[np.datetime64]
+AR_O: npt.NDArray[np.object_]
+AR_number: npt.NDArray[np.number[Any]]
+
+AR_LIKE_b: list[bool]
+AR_LIKE_u: list[np.uint32]
+AR_LIKE_i: list[int]
+AR_LIKE_f: list[float]
+AR_LIKE_c: list[complex]
+AR_LIKE_m: list[np.timedelta64]
+AR_LIKE_M: list[np.datetime64]
+AR_LIKE_O: list[np.object_]
+
+# Array subtraction
+
+assert_type(AR_number - AR_number, npt.NDArray[np.number[Any]])
+
+assert_type(AR_b - AR_LIKE_u, npt.NDArray[np.unsignedinteger[Any]])
+assert_type(AR_b - AR_LIKE_i, npt.NDArray[np.signedinteger[Any]])
+assert_type(AR_b - AR_LIKE_f, npt.NDArray[np.floating[Any]])
+assert_type(AR_b - AR_LIKE_c, npt.NDArray[np.complexfloating[Any, Any]])
+assert_type(AR_b - AR_LIKE_m, npt.NDArray[np.timedelta64])
+assert_type(AR_b - AR_LIKE_O, Any)
+
+assert_type(AR_LIKE_u - AR_b, npt.NDArray[np.unsignedinteger[Any]])
+assert_type(AR_LIKE_i - AR_b, npt.NDArray[np.signedinteger[Any]])
+assert_type(AR_LIKE_f - AR_b, npt.NDArray[np.floating[Any]])
+assert_type(AR_LIKE_c - AR_b, npt.NDArray[np.complexfloating[Any, Any]])
+assert_type(AR_LIKE_m - AR_b, npt.NDArray[np.timedelta64])
+assert_type(AR_LIKE_M - AR_b, npt.NDArray[np.datetime64])
+assert_type(AR_LIKE_O - AR_b, Any)
+
+assert_type(AR_u - AR_LIKE_b, npt.NDArray[np.unsignedinteger[Any]])
+assert_type(AR_u - AR_LIKE_u, npt.NDArray[np.unsignedinteger[Any]])
+assert_type(AR_u - AR_LIKE_i, npt.NDArray[np.signedinteger[Any]])
+assert_type(AR_u - AR_LIKE_f, npt.NDArray[np.floating[Any]])
+assert_type(AR_u - AR_LIKE_c, npt.NDArray[np.complexfloating[Any, Any]])
+assert_type(AR_u - AR_LIKE_m, npt.NDArray[np.timedelta64])
+assert_type(AR_u - AR_LIKE_O, Any)
+
+assert_type(AR_LIKE_b - AR_u, npt.NDArray[np.unsignedinteger[Any]])
+assert_type(AR_LIKE_u - AR_u, npt.NDArray[np.unsignedinteger[Any]])
+assert_type(AR_LIKE_i - AR_u, npt.NDArray[np.signedinteger[Any]])
+assert_type(AR_LIKE_f - AR_u, npt.NDArray[np.floating[Any]])
+assert_type(AR_LIKE_c - AR_u, npt.NDArray[np.complexfloating[Any, Any]])
+assert_type(AR_LIKE_m - AR_u, npt.NDArray[np.timedelta64])
+assert_type(AR_LIKE_M - AR_u, npt.NDArray[np.datetime64])
+assert_type(AR_LIKE_O - AR_u, Any)
+
+assert_type(AR_i - AR_LIKE_b, npt.NDArray[np.signedinteger[Any]])
+assert_type(AR_i - AR_LIKE_u, npt.NDArray[np.signedinteger[Any]])
+assert_type(AR_i - AR_LIKE_i, npt.NDArray[np.signedinteger[Any]])
+assert_type(AR_i - AR_LIKE_f, npt.NDArray[np.floating[Any]])
+assert_type(AR_i - AR_LIKE_c, npt.NDArray[np.complexfloating[Any, Any]])
+assert_type(AR_i - AR_LIKE_m, npt.NDArray[np.timedelta64])
+assert_type(AR_i - AR_LIKE_O, Any)
+
+assert_type(AR_LIKE_b - AR_i, npt.NDArray[np.signedinteger[Any]])
+assert_type(AR_LIKE_u - AR_i, npt.NDArray[np.signedinteger[Any]])
+assert_type(AR_LIKE_i - AR_i, npt.NDArray[np.signedinteger[Any]])
+assert_type(AR_LIKE_f - AR_i, npt.NDArray[np.floating[Any]])
+assert_type(AR_LIKE_c - AR_i, npt.NDArray[np.complexfloating[Any, Any]])
+assert_type(AR_LIKE_m - AR_i, npt.NDArray[np.timedelta64])
+assert_type(AR_LIKE_M - AR_i, npt.NDArray[np.datetime64])
+assert_type(AR_LIKE_O - AR_i, Any)
+
+assert_type(AR_f - AR_LIKE_b, npt.NDArray[np.floating[Any]])
+assert_type(AR_f - AR_LIKE_u, npt.NDArray[np.floating[Any]])
+assert_type(AR_f - AR_LIKE_i, npt.NDArray[np.floating[Any]])
+assert_type(AR_f - AR_LIKE_f, npt.NDArray[np.floating[Any]])
+assert_type(AR_f - AR_LIKE_c, npt.NDArray[np.complexfloating[Any, Any]])
+assert_type(AR_f - AR_LIKE_O, Any)
+
+assert_type(AR_LIKE_b - AR_f, npt.NDArray[np.floating[Any]])
+assert_type(AR_LIKE_u - AR_f, npt.NDArray[np.floating[Any]])
+assert_type(AR_LIKE_i - AR_f, npt.NDArray[np.floating[Any]])
+assert_type(AR_LIKE_f - AR_f, npt.NDArray[np.floating[Any]])
+assert_type(AR_LIKE_c - AR_f, npt.NDArray[np.complexfloating[Any, Any]])
+assert_type(AR_LIKE_O - AR_f, Any)
+
+assert_type(AR_c - AR_LIKE_b, npt.NDArray[np.complexfloating[Any, Any]])
+assert_type(AR_c - AR_LIKE_u, npt.NDArray[np.complexfloating[Any, Any]])
+assert_type(AR_c - AR_LIKE_i, npt.NDArray[np.complexfloating[Any, Any]])
+assert_type(AR_c - AR_LIKE_f, npt.NDArray[np.complexfloating[Any, Any]])
+assert_type(AR_c - AR_LIKE_c, npt.NDArray[np.complexfloating[Any, Any]])
+assert_type(AR_c - AR_LIKE_O, Any)
+
+assert_type(AR_LIKE_b - AR_c, npt.NDArray[np.complexfloating[Any, Any]])
+assert_type(AR_LIKE_u - AR_c, npt.NDArray[np.complexfloating[Any, Any]])
+assert_type(AR_LIKE_i - AR_c, npt.NDArray[np.complexfloating[Any, Any]])
+assert_type(AR_LIKE_f - AR_c, npt.NDArray[np.complexfloating[Any, Any]])
+assert_type(AR_LIKE_c - AR_c, npt.NDArray[np.complexfloating[Any, Any]])
+assert_type(AR_LIKE_O - AR_c, Any)
+
+assert_type(AR_m - AR_LIKE_b, npt.NDArray[np.timedelta64])
+assert_type(AR_m - AR_LIKE_u, npt.NDArray[np.timedelta64])
+assert_type(AR_m - AR_LIKE_i, npt.NDArray[np.timedelta64])
+assert_type(AR_m - AR_LIKE_m, npt.NDArray[np.timedelta64])
+assert_type(AR_m - AR_LIKE_O, Any)
+
+assert_type(AR_LIKE_b - AR_m, npt.NDArray[np.timedelta64])
+assert_type(AR_LIKE_u - AR_m, npt.NDArray[np.timedelta64])
+assert_type(AR_LIKE_i - AR_m, npt.NDArray[np.timedelta64])
+assert_type(AR_LIKE_m - AR_m, npt.NDArray[np.timedelta64])
+assert_type(AR_LIKE_M - AR_m, npt.NDArray[np.datetime64])
+assert_type(AR_LIKE_O - AR_m, Any)
+
+assert_type(AR_M - AR_LIKE_b, npt.NDArray[np.datetime64])
+assert_type(AR_M - AR_LIKE_u, npt.NDArray[np.datetime64])
+assert_type(AR_M - AR_LIKE_i, npt.NDArray[np.datetime64])
+assert_type(AR_M - AR_LIKE_m, npt.NDArray[np.datetime64])
+assert_type(AR_M - AR_LIKE_M, npt.NDArray[np.timedelta64])
+assert_type(AR_M - AR_LIKE_O, Any)
+
+assert_type(AR_LIKE_M - AR_M, npt.NDArray[np.timedelta64])
+assert_type(AR_LIKE_O - AR_M, Any)
+
+assert_type(AR_O - AR_LIKE_b, Any)
+assert_type(AR_O - AR_LIKE_u, Any)
+assert_type(AR_O - AR_LIKE_i, Any)
+assert_type(AR_O - AR_LIKE_f, Any)
+assert_type(AR_O - AR_LIKE_c, Any)
+assert_type(AR_O - AR_LIKE_m, Any)
+assert_type(AR_O - AR_LIKE_M, Any)
+assert_type(AR_O - AR_LIKE_O, Any)
+
+assert_type(AR_LIKE_b - AR_O, Any)
+assert_type(AR_LIKE_u - AR_O, Any)
+assert_type(AR_LIKE_i - AR_O, Any)
+assert_type(AR_LIKE_f - AR_O, Any)
+assert_type(AR_LIKE_c - AR_O, Any)
+assert_type(AR_LIKE_m - AR_O, Any)
+assert_type(AR_LIKE_M - AR_O, Any)
+assert_type(AR_LIKE_O - AR_O, Any)
+
+# Array floor division
+
+assert_type(AR_b // AR_LIKE_b, npt.NDArray[np.int8])
+assert_type(AR_b // AR_LIKE_u, npt.NDArray[np.unsignedinteger[Any]])
+assert_type(AR_b // AR_LIKE_i, npt.NDArray[np.signedinteger[Any]])
+assert_type(AR_b // AR_LIKE_f, npt.NDArray[np.floating[Any]])
+assert_type(AR_b // AR_LIKE_O, Any)
+
+assert_type(AR_LIKE_b // AR_b, npt.NDArray[np.int8])
+assert_type(AR_LIKE_u // AR_b, npt.NDArray[np.unsignedinteger[Any]])
+assert_type(AR_LIKE_i // AR_b, npt.NDArray[np.signedinteger[Any]])
+assert_type(AR_LIKE_f // AR_b, npt.NDArray[np.floating[Any]])
+assert_type(AR_LIKE_O // AR_b, Any)
+
+assert_type(AR_u // AR_LIKE_b, npt.NDArray[np.unsignedinteger[Any]])
+assert_type(AR_u // AR_LIKE_u, npt.NDArray[np.unsignedinteger[Any]])
+assert_type(AR_u // AR_LIKE_i, npt.NDArray[np.signedinteger[Any]])
+assert_type(AR_u // AR_LIKE_f, npt.NDArray[np.floating[Any]])
+assert_type(AR_u // AR_LIKE_O, Any)
+
+assert_type(AR_LIKE_b // AR_u, npt.NDArray[np.unsignedinteger[Any]])
+assert_type(AR_LIKE_u // AR_u, npt.NDArray[np.unsignedinteger[Any]])
+assert_type(AR_LIKE_i // AR_u, npt.NDArray[np.signedinteger[Any]])
+assert_type(AR_LIKE_f // AR_u, npt.NDArray[np.floating[Any]])
+assert_type(AR_LIKE_m // AR_u, npt.NDArray[np.timedelta64])
+assert_type(AR_LIKE_O // AR_u, Any)
+
+assert_type(AR_i // AR_LIKE_b, npt.NDArray[np.signedinteger[Any]])
+assert_type(AR_i // AR_LIKE_u, npt.NDArray[np.signedinteger[Any]])
+assert_type(AR_i // AR_LIKE_i, npt.NDArray[np.signedinteger[Any]])
+assert_type(AR_i // AR_LIKE_f, npt.NDArray[np.floating[Any]])
+assert_type(AR_i // AR_LIKE_O, Any)
+
+assert_type(AR_LIKE_b // AR_i, npt.NDArray[np.signedinteger[Any]])
+assert_type(AR_LIKE_u // AR_i, npt.NDArray[np.signedinteger[Any]])
+assert_type(AR_LIKE_i // AR_i, npt.NDArray[np.signedinteger[Any]])
+assert_type(AR_LIKE_f // AR_i, npt.NDArray[np.floating[Any]])
+assert_type(AR_LIKE_m // AR_i, npt.NDArray[np.timedelta64])
+assert_type(AR_LIKE_O // AR_i, Any)
+
+assert_type(AR_f // AR_LIKE_b, npt.NDArray[np.floating[Any]])
+assert_type(AR_f // AR_LIKE_u, npt.NDArray[np.floating[Any]])
+assert_type(AR_f // AR_LIKE_i, npt.NDArray[np.floating[Any]])
+assert_type(AR_f // AR_LIKE_f, npt.NDArray[np.floating[Any]])
+assert_type(AR_f // AR_LIKE_O, Any)
+
+assert_type(AR_LIKE_b // AR_f, npt.NDArray[np.floating[Any]])
+assert_type(AR_LIKE_u // AR_f, npt.NDArray[np.floating[Any]])
+assert_type(AR_LIKE_i // AR_f, npt.NDArray[np.floating[Any]])
+assert_type(AR_LIKE_f // AR_f, npt.NDArray[np.floating[Any]])
+assert_type(AR_LIKE_m // AR_f, npt.NDArray[np.timedelta64])
+assert_type(AR_LIKE_O // AR_f, Any)
+
+assert_type(AR_m // AR_LIKE_u, npt.NDArray[np.timedelta64])
+assert_type(AR_m // AR_LIKE_i, npt.NDArray[np.timedelta64])
+assert_type(AR_m // AR_LIKE_f, npt.NDArray[np.timedelta64])
+assert_type(AR_m // AR_LIKE_m, npt.NDArray[np.int64])
+assert_type(AR_m // AR_LIKE_O, Any)
+
+assert_type(AR_LIKE_m // AR_m, npt.NDArray[np.int64])
+assert_type(AR_LIKE_O // AR_m, Any)
+
+assert_type(AR_O // AR_LIKE_b, Any)
+assert_type(AR_O // AR_LIKE_u, Any)
+assert_type(AR_O // AR_LIKE_i, Any)
+assert_type(AR_O // AR_LIKE_f, Any)
+assert_type(AR_O // AR_LIKE_m, Any)
+assert_type(AR_O // AR_LIKE_M, Any)
+assert_type(AR_O // AR_LIKE_O, Any)
+
+assert_type(AR_LIKE_b // AR_O, Any)
+assert_type(AR_LIKE_u // AR_O, Any)
+assert_type(AR_LIKE_i // AR_O, Any)
+assert_type(AR_LIKE_f // AR_O, Any)
+assert_type(AR_LIKE_m // AR_O, Any)
+assert_type(AR_LIKE_M // AR_O, Any)
+assert_type(AR_LIKE_O // AR_O, Any)
+
+# unary ops
+
+assert_type(-f16, np.floating[_128Bit])
+assert_type(-c16, np.complex128)
+assert_type(-c8, np.complex64)
+assert_type(-f8, np.float64)
+assert_type(-f4, np.float32)
+assert_type(-i8, np.int64)
+assert_type(-i4, np.int32)
+assert_type(-u8, np.uint64)
+assert_type(-u4, np.uint32)
+assert_type(-td, np.timedelta64)
+assert_type(-AR_f, npt.NDArray[np.float64])
+
+assert_type(+f16, np.floating[_128Bit])
+assert_type(+c16, np.complex128)
+assert_type(+c8, np.complex64)
+assert_type(+f8, np.float64)
+assert_type(+f4, np.float32)
+assert_type(+i8, np.int64)
+assert_type(+i4, np.int32)
+assert_type(+u8, np.uint64)
+assert_type(+u4, np.uint32)
+assert_type(+td, np.timedelta64)
+assert_type(+AR_f, npt.NDArray[np.float64])
+
+assert_type(abs(f16), np.floating[_128Bit])
+assert_type(abs(c16), np.float64)
+assert_type(abs(c8), np.float32)
+assert_type(abs(f8), np.float64)
+assert_type(abs(f4), np.float32)
+assert_type(abs(i8), np.int64)
+assert_type(abs(i4), np.int32)
+assert_type(abs(u8), np.uint64)
+assert_type(abs(u4), np.uint32)
+assert_type(abs(td), np.timedelta64)
+assert_type(abs(b_), np.bool)
+
+# Time structures
+
+assert_type(dt + td, np.datetime64)
+assert_type(dt + i, np.datetime64)
+assert_type(dt + i4, np.datetime64)
+assert_type(dt + i8, np.datetime64)
+assert_type(dt - dt, np.timedelta64)
+assert_type(dt - i, np.datetime64)
+assert_type(dt - i4, np.datetime64)
+assert_type(dt - i8, np.datetime64)
+
+assert_type(td + td, np.timedelta64)
+assert_type(td + i, np.timedelta64)
+assert_type(td + i4, np.timedelta64)
+assert_type(td + i8, np.timedelta64)
+assert_type(td - td, np.timedelta64)
+assert_type(td - i, np.timedelta64)
+assert_type(td - i4, np.timedelta64)
+assert_type(td - i8, np.timedelta64)
+assert_type(td / f, np.timedelta64)
+assert_type(td / f4, np.timedelta64)
+assert_type(td / f8, np.timedelta64)
+assert_type(td / td, np.float64)
+assert_type(td // td, np.int64)
+
+# boolean
+
+assert_type(b_ / b, np.float64)
+assert_type(b_ / b_, np.float64)
+assert_type(b_ / i, np.float64)
+assert_type(b_ / i8, np.float64)
+assert_type(b_ / i4, np.float64)
+assert_type(b_ / u8, np.float64)
+assert_type(b_ / u4, np.float64)
+assert_type(b_ / f, np.float64)
+assert_type(b_ / f16, np.floating[_128Bit])
+assert_type(b_ / f8, np.float64)
+assert_type(b_ / f4, np.float32)
+assert_type(b_ / c, np.complex128)
+assert_type(b_ / c16, np.complex128)
+assert_type(b_ / c8, np.complex64)
+
+assert_type(b / b_, np.float64)
+assert_type(b_ / b_, np.float64)
+assert_type(i / b_, np.float64)
+assert_type(i8 / b_, np.float64)
+assert_type(i4 / b_, np.float64)
+assert_type(u8 / b_, np.float64)
+assert_type(u4 / b_, np.float64)
+assert_type(f / b_, np.float64)
+assert_type(f16 / b_, np.floating[_128Bit])
+assert_type(f8 / b_, np.float64)
+assert_type(f4 / b_, np.float32)
+assert_type(c / b_, np.complex128)
+assert_type(c16 / b_, np.complex128)
+assert_type(c8 / b_, np.complex64)
+
+# Complex
+
+assert_type(c16 + f16, np.complexfloating[_64Bit | _128Bit, _64Bit | _128Bit])
+assert_type(c16 + c16, np.complex128)
+assert_type(c16 + f8, np.complex128)
+assert_type(c16 + i8, np.complex128)
+assert_type(c16 + c8, np.complexfloating[_32Bit | _64Bit, _32Bit | _64Bit])
+assert_type(c16 + f4, np.complexfloating[_32Bit | _64Bit, _32Bit | _64Bit])
+assert_type(c16 + i4, np.complexfloating[_32Bit | _64Bit, _32Bit | _64Bit])
+assert_type(c16 + b_, np.complex128)
+assert_type(c16 + b, np.complex128)
+assert_type(c16 + c, np.complex128)
+assert_type(c16 + f, np.complex128)
+assert_type(c16 + AR_f, npt.NDArray[np.complexfloating[Any, Any]])
+
+assert_type(f16 + c16, np.complexfloating[_64Bit | _128Bit, _64Bit | _128Bit])
+assert_type(c16 + c16, np.complex128)
+assert_type(f8 + c16, np.complex128)
+assert_type(i8 + c16, np.complex128)
+assert_type(c8 + c16, np.complexfloating[_32Bit | _64Bit, _32Bit | _64Bit])
+assert_type(f4 + c16, np.complexfloating[_32Bit | _64Bit, _32Bit | _64Bit])
+assert_type(i4 + c16, np.complexfloating[_32Bit | _64Bit, _32Bit | _64Bit])
+assert_type(b_ + c16, np.complex128)
+assert_type(b + c16, np.complex128)
+assert_type(c + c16, np.complex128)
+assert_type(f + c16, np.complex128)
+assert_type(AR_f + c16, npt.NDArray[np.complexfloating[Any, Any]])
+
+assert_type(c8 + f16, np.complexfloating[_32Bit | _128Bit, _32Bit | _128Bit])
+assert_type(c8 + c16, np.complexfloating[_32Bit | _64Bit, _32Bit | _64Bit])
+assert_type(c8 + f8, np.complexfloating[_32Bit | _64Bit, _32Bit | _64Bit])
+assert_type(c8 + i8, np.complexfloating[_32Bit | _64Bit, _32Bit | _64Bit])
+assert_type(c8 + c8, np.complex64)
+assert_type(c8 + f4, np.complex64)
+assert_type(c8 + i4, np.complex64)
+assert_type(c8 + b_, np.complex64)
+assert_type(c8 + b, np.complex64)
+assert_type(c8 + c, np.complexfloating[_32Bit | _64Bit, _32Bit | _64Bit])
+assert_type(c8 + f, np.complexfloating[_32Bit | _64Bit, _32Bit | _64Bit])
+assert_type(c8 + AR_f, npt.NDArray[np.complexfloating[Any, Any]])
+
+assert_type(f16 + c8, np.complexfloating[_32Bit | _128Bit, _32Bit | _128Bit])
+assert_type(c16 + c8, np.complexfloating[_32Bit | _64Bit, _32Bit | _64Bit])
+assert_type(f8 + c8, np.complexfloating[_32Bit | _64Bit, _32Bit | _64Bit])
+assert_type(i8 + c8, np.complexfloating[_32Bit | _64Bit, _32Bit | _64Bit])
+assert_type(c8 + c8, np.complex64)
+assert_type(f4 + c8, np.complex64)
+assert_type(i4 + c8, np.complex64)
+assert_type(b_ + c8, np.complex64)
+assert_type(b + c8, np.complex64)
+assert_type(c + c8, np.complexfloating[_32Bit | _64Bit, _32Bit | _64Bit])
+assert_type(f + c8, np.complexfloating[_32Bit | _64Bit, _32Bit | _64Bit])
+assert_type(AR_f + c8, npt.NDArray[np.complexfloating[Any, Any]])
+
+# Float
+
+assert_type(f8 + f16, np.floating[_64Bit | _128Bit])
+assert_type(f8 + f8, np.float64)
+assert_type(f8 + i8, np.float64)
+assert_type(f8 + f4, np.floating[_32Bit | _64Bit])
+assert_type(f8 + i4, np.floating[_32Bit | _64Bit])
+assert_type(f8 + b_, np.float64)
+assert_type(f8 + b, np.float64)
+assert_type(f8 + c, np.complex128)
+assert_type(f8 + f, np.float64)
+assert_type(f8 + AR_f, npt.NDArray[np.floating[Any]])
+
+assert_type(f16 + f8, np.floating[_64Bit | _128Bit])
+assert_type(f8 + f8, np.float64)
+assert_type(i8 + f8, np.float64)
+assert_type(f4 + f8, np.floating[_32Bit | _64Bit])
+assert_type(i4 + f8, np.floating[_32Bit | _64Bit])
+assert_type(b_ + f8, np.float64)
+assert_type(b + f8, np.float64)
+assert_type(c + f8, np.complex128)
+assert_type(f + f8, np.float64)
+assert_type(AR_f + f8, npt.NDArray[np.floating[Any]])
+
+assert_type(f4 + f16, np.floating[_32Bit | _128Bit])
+assert_type(f4 + f8, np.floating[_32Bit | _64Bit])
+assert_type(f4 + i8, np.floating[_32Bit | _64Bit])
+assert_type(f4 + f4, np.float32)
+assert_type(f4 + i4, np.float32)
+assert_type(f4 + b_, np.float32)
+assert_type(f4 + b, np.float32)
+assert_type(f4 + c, np.complexfloating[_32Bit | _64Bit, _32Bit | _64Bit])
+assert_type(f4 + f, np.floating[_32Bit | _64Bit])
+assert_type(f4 + AR_f, npt.NDArray[np.floating[Any]])
+
+assert_type(f16 + f4, np.floating[_32Bit | _128Bit])
+assert_type(f8 + f4, np.floating[_32Bit | _64Bit])
+assert_type(i8 + f4, np.floating[_32Bit | _64Bit])
+assert_type(f4 + f4, np.float32)
+assert_type(i4 + f4, np.float32)
+assert_type(b_ + f4, np.float32)
+assert_type(b + f4, np.float32)
+assert_type(c + f4, np.complexfloating[_32Bit | _64Bit, _32Bit | _64Bit])
+assert_type(f + f4, np.floating[_32Bit | _64Bit])
+assert_type(AR_f + f4, npt.NDArray[np.floating[Any]])
+
+# Int
+
+assert_type(i8 + i8, np.int64)
+assert_type(i8 + u8, Any)
+assert_type(i8 + i4, np.signedinteger[_32Bit | _64Bit])
+assert_type(i8 + u4, Any)
+assert_type(i8 + b_, np.int64)
+assert_type(i8 + b, np.int64)
+assert_type(i8 + c, np.complex128)
+assert_type(i8 + f, np.float64)
+assert_type(i8 + AR_f, npt.NDArray[np.floating[Any]])
+
+assert_type(u8 + u8, np.uint64)
+assert_type(u8 + i4, Any)
+assert_type(u8 + u4, np.unsignedinteger[_32Bit | _64Bit])
+assert_type(u8 + b_, np.uint64)
+assert_type(u8 + b, np.uint64)
+assert_type(u8 + c, np.complex128)
+assert_type(u8 + f, np.float64)
+assert_type(u8 + AR_f, npt.NDArray[np.floating[Any]])
+
+assert_type(i8 + i8, np.int64)
+assert_type(u8 + i8, Any)
+assert_type(i4 + i8, np.signedinteger[_32Bit | _64Bit])
+assert_type(u4 + i8, Any)
+assert_type(b_ + i8, np.int64)
+assert_type(b + i8, np.int64)
+assert_type(c + i8, np.complex128)
+assert_type(f + i8, np.float64)
+assert_type(AR_f + i8, npt.NDArray[np.floating[Any]])
+
+assert_type(u8 + u8, np.uint64)
+assert_type(i4 + u8, Any)
+assert_type(u4 + u8, np.unsignedinteger[_32Bit | _64Bit])
+assert_type(b_ + u8, np.uint64)
+assert_type(b + u8, np.uint64)
+assert_type(c + u8, np.complex128)
+assert_type(f + u8, np.float64)
+assert_type(AR_f + u8, npt.NDArray[np.floating[Any]])
+
+assert_type(i4 + i8, np.signedinteger[_32Bit | _64Bit])
+assert_type(i4 + i4, np.int32)
+assert_type(i4 + b_, np.int32)
+assert_type(i4 + b, np.int32)
+assert_type(i4 + AR_f, npt.NDArray[np.floating[Any]])
+
+assert_type(u4 + i8, Any)
+assert_type(u4 + i4, Any)
+assert_type(u4 + u8, np.unsignedinteger[_32Bit | _64Bit])
+assert_type(u4 + u4, np.uint32)
+assert_type(u4 + b_, np.uint32)
+assert_type(u4 + b, np.uint32)
+assert_type(u4 + AR_f, npt.NDArray[np.floating[Any]])
+
+assert_type(i8 + i4, np.signedinteger[_32Bit | _64Bit])
+assert_type(i4 + i4, np.int32)
+assert_type(b_ + i4, np.int32)
+assert_type(b + i4, np.int32)
+assert_type(AR_f + i4, npt.NDArray[np.floating[Any]])
+
+assert_type(i8 + u4, Any)
+assert_type(i4 + u4, Any)
+assert_type(u8 + u4, np.unsignedinteger[_32Bit | _64Bit])
+assert_type(u4 + u4, np.uint32)
+assert_type(b_ + u4, np.uint32)
+assert_type(b + u4, np.uint32)
+assert_type(AR_f + u4, npt.NDArray[np.floating[Any]])
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/array_api_info.pyi b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/array_api_info.pyi
new file mode 100644
index 00000000..b7dd2b93
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/array_api_info.pyi
@@ -0,0 +1,76 @@
+import sys
+from typing import Literal
+
+import numpy as np
+
+if sys.version_info >= (3, 11):
+    from typing import Never, assert_type
+else:
+    from typing_extensions import Never, assert_type
+
+info = np.__array_namespace_info__()
+
+assert_type(info.__module__, Literal["numpy"])
+
+assert_type(info.default_device(), Literal["cpu"])
+assert_type(info.devices()[0], Literal["cpu"])
+assert_type(info.devices()[-1], Literal["cpu"])
+
+assert_type(info.capabilities()["boolean indexing"], Literal[True])
+assert_type(info.capabilities()["data-dependent shapes"], Literal[True])
+
+assert_type(info.default_dtypes()["real floating"], np.dtype[np.float64])
+assert_type(info.default_dtypes()["complex floating"], np.dtype[np.complex128])
+assert_type(info.default_dtypes()["integral"], np.dtype[np.int_])
+assert_type(info.default_dtypes()["indexing"], np.dtype[np.intp])
+
+assert_type(info.dtypes()["bool"], np.dtype[np.bool])
+assert_type(info.dtypes()["int8"], np.dtype[np.int8])
+assert_type(info.dtypes()["uint8"], np.dtype[np.uint8])
+assert_type(info.dtypes()["float32"], np.dtype[np.float32])
+assert_type(info.dtypes()["complex64"], np.dtype[np.complex64])
+
+assert_type(info.dtypes(kind="bool")["bool"], np.dtype[np.bool])
+assert_type(info.dtypes(kind="signed integer")["int64"], np.dtype[np.int64])
+assert_type(info.dtypes(kind="unsigned integer")["uint64"], np.dtype[np.uint64])
+assert_type(info.dtypes(kind="integral")["int32"], np.dtype[np.int32])
+assert_type(info.dtypes(kind="integral")["uint32"], np.dtype[np.uint32])
+assert_type(info.dtypes(kind="real floating")["float64"], np.dtype[np.float64])
+assert_type(info.dtypes(kind="complex floating")["complex128"], np.dtype[np.complex128])
+assert_type(info.dtypes(kind="numeric")["int16"], np.dtype[np.int16])
+assert_type(info.dtypes(kind="numeric")["uint16"], np.dtype[np.uint16])
+assert_type(info.dtypes(kind="numeric")["float64"], np.dtype[np.float64])
+assert_type(info.dtypes(kind="numeric")["complex128"], np.dtype[np.complex128])
+
+assert_type(info.dtypes(kind=()), dict[Never, Never])
+
+assert_type(info.dtypes(kind=("bool",))["bool"], np.dtype[np.bool])
+assert_type(info.dtypes(kind=("signed integer",))["int64"], np.dtype[np.int64])
+assert_type(info.dtypes(kind=("integral",))["uint32"], np.dtype[np.uint32])
+assert_type(info.dtypes(kind=("complex floating",))["complex128"], np.dtype[np.complex128])
+assert_type(info.dtypes(kind=("numeric",))["float64"], np.dtype[np.float64])
+
+assert_type(
+    info.dtypes(kind=("signed integer", "unsigned integer"))["int8"],
+    np.dtype[np.int8],
+)
+assert_type(
+    info.dtypes(kind=("signed integer", "unsigned integer"))["uint8"],
+    np.dtype[np.uint8],
+)
+assert_type(
+    info.dtypes(kind=("integral", "real floating", "complex floating"))["int16"],
+    np.dtype[np.int16],
+)
+assert_type(
+    info.dtypes(kind=("integral", "real floating", "complex floating"))["uint16"],
+    np.dtype[np.uint16],
+)
+assert_type(
+    info.dtypes(kind=("integral", "real floating", "complex floating"))["float32"],
+    np.dtype[np.float32],
+)
+assert_type(
+    info.dtypes(kind=("integral", "real floating", "complex floating"))["complex64"],
+    np.dtype[np.complex64],
+)
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/array_constructors.pyi b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/array_constructors.pyi
new file mode 100644
index 00000000..2559acbd
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/array_constructors.pyi
@@ -0,0 +1,228 @@
+import sys
+from typing import Any, TypeVar
+from pathlib import Path
+from collections import deque
+
+import numpy as np
+import numpy.typing as npt
+
+if sys.version_info >= (3, 11):
+    from typing import assert_type
+else:
+    from typing_extensions import assert_type
+
+_SCT = TypeVar("_SCT", bound=np.generic, covariant=True)
+
+class SubClass(npt.NDArray[_SCT]): ...
+
+i8: np.int64
+
+A: npt.NDArray[np.float64]
+B: SubClass[np.float64]
+C: list[int]
+D: SubClass[np.float64 | np.int64]
+
+def func(i: int, j: int, **kwargs: Any) -> SubClass[np.float64]: ...
+
+assert_type(np.empty_like(A), npt.NDArray[np.float64])
+assert_type(np.empty_like(B), SubClass[np.float64])
+assert_type(np.empty_like([1, 1.0]), npt.NDArray[Any])
+assert_type(np.empty_like(A, dtype=np.int64), npt.NDArray[np.int64])
+assert_type(np.empty_like(A, dtype='c16'), npt.NDArray[Any])
+
+assert_type(np.array(A), npt.NDArray[np.float64])
+assert_type(np.array(B), npt.NDArray[np.float64])
+assert_type(np.array([1, 1.0]), npt.NDArray[Any])
+assert_type(np.array(deque([1, 2, 3])), npt.NDArray[Any])
+assert_type(np.array(A, dtype=np.int64), npt.NDArray[np.int64])
+assert_type(np.array(A, dtype='c16'), npt.NDArray[Any])
+assert_type(np.array(A, like=A), npt.NDArray[np.float64])
+assert_type(np.array(A, subok=True), npt.NDArray[np.float64])
+assert_type(np.array(B, subok=True), SubClass[np.float64])
+assert_type(np.array(B, subok=True, ndmin=0), SubClass[np.float64])
+assert_type(np.array(B, subok=True, ndmin=1), SubClass[np.float64])
+assert_type(np.array(D), npt.NDArray[np.float64 | np.int64])
+
+assert_type(np.zeros([1, 5, 6]), npt.NDArray[np.float64])
+assert_type(np.zeros([1, 5, 6], dtype=np.int64), npt.NDArray[np.int64])
+assert_type(np.zeros([1, 5, 6], dtype='c16'), npt.NDArray[Any])
+
+assert_type(np.empty([1, 5, 6]), npt.NDArray[np.float64])
+assert_type(np.empty([1, 5, 6], dtype=np.int64), npt.NDArray[np.int64])
+assert_type(np.empty([1, 5, 6], dtype='c16'), npt.NDArray[Any])
+
+assert_type(np.concatenate(A), npt.NDArray[np.float64])
+assert_type(np.concatenate([A, A]), Any)
+assert_type(np.concatenate([[1], A]), npt.NDArray[Any])
+assert_type(np.concatenate([[1], [1]]), npt.NDArray[Any])
+assert_type(np.concatenate((A, A)), npt.NDArray[np.float64])
+assert_type(np.concatenate(([1], [1])), npt.NDArray[Any])
+assert_type(np.concatenate([1, 1.0]), npt.NDArray[Any])
+assert_type(np.concatenate(A, dtype=np.int64), npt.NDArray[np.int64])
+assert_type(np.concatenate(A, dtype='c16'), npt.NDArray[Any])
+assert_type(np.concatenate([1, 1.0], out=A), npt.NDArray[np.float64])
+
+assert_type(np.asarray(A), npt.NDArray[np.float64])
+assert_type(np.asarray(B), npt.NDArray[np.float64])
+assert_type(np.asarray([1, 1.0]), npt.NDArray[Any])
+assert_type(np.asarray(A, dtype=np.int64), npt.NDArray[np.int64])
+assert_type(np.asarray(A, dtype='c16'), npt.NDArray[Any])
+
+assert_type(np.asanyarray(A), npt.NDArray[np.float64])
+assert_type(np.asanyarray(B), SubClass[np.float64])
+assert_type(np.asanyarray([1, 1.0]), npt.NDArray[Any])
+assert_type(np.asanyarray(A, dtype=np.int64), npt.NDArray[np.int64])
+assert_type(np.asanyarray(A, dtype='c16'), npt.NDArray[Any])
+
+assert_type(np.ascontiguousarray(A), npt.NDArray[np.float64])
+assert_type(np.ascontiguousarray(B), npt.NDArray[np.float64])
+assert_type(np.ascontiguousarray([1, 1.0]), npt.NDArray[Any])
+assert_type(np.ascontiguousarray(A, dtype=np.int64), npt.NDArray[np.int64])
+assert_type(np.ascontiguousarray(A, dtype='c16'), npt.NDArray[Any])
+
+assert_type(np.asfortranarray(A), npt.NDArray[np.float64])
+assert_type(np.asfortranarray(B), npt.NDArray[np.float64])
+assert_type(np.asfortranarray([1, 1.0]), npt.NDArray[Any])
+assert_type(np.asfortranarray(A, dtype=np.int64), npt.NDArray[np.int64])
+assert_type(np.asfortranarray(A, dtype='c16'), npt.NDArray[Any])
+
+assert_type(np.fromstring("1 1 1", sep=" "), npt.NDArray[np.float64])
+assert_type(np.fromstring(b"1 1 1", sep=" "), npt.NDArray[np.float64])
+assert_type(np.fromstring("1 1 1", dtype=np.int64, sep=" "), npt.NDArray[np.int64])
+assert_type(np.fromstring(b"1 1 1", dtype=np.int64, sep=" "), npt.NDArray[np.int64])
+assert_type(np.fromstring("1 1 1", dtype="c16", sep=" "), npt.NDArray[Any])
+assert_type(np.fromstring(b"1 1 1", dtype="c16", sep=" "), npt.NDArray[Any])
+
+assert_type(np.fromfile("test.txt", sep=" "), npt.NDArray[np.float64])
+assert_type(np.fromfile("test.txt", dtype=np.int64, sep=" "), npt.NDArray[np.int64])
+assert_type(np.fromfile("test.txt", dtype="c16", sep=" "), npt.NDArray[Any])
+with open("test.txt") as f:
+    assert_type(np.fromfile(f, sep=" "), npt.NDArray[np.float64])
+    assert_type(np.fromfile(b"test.txt", sep=" "), npt.NDArray[np.float64])
+    assert_type(np.fromfile(Path("test.txt"), sep=" "), npt.NDArray[np.float64])
+
+assert_type(np.fromiter("12345", np.float64), npt.NDArray[np.float64])
+assert_type(np.fromiter("12345", float), npt.NDArray[Any])
+
+assert_type(np.frombuffer(A), npt.NDArray[np.float64])
+assert_type(np.frombuffer(A, dtype=np.int64), npt.NDArray[np.int64])
+assert_type(np.frombuffer(A, dtype="c16"), npt.NDArray[Any])
+
+assert_type(np.arange(False, True), npt.NDArray[np.signedinteger[Any]])
+assert_type(np.arange(10), npt.NDArray[np.signedinteger[Any]])
+assert_type(np.arange(0, 10, step=2), npt.NDArray[np.signedinteger[Any]])
+assert_type(np.arange(10.0), npt.NDArray[np.floating[Any]])
+assert_type(np.arange(start=0, stop=10.0), npt.NDArray[np.floating[Any]])
+assert_type(np.arange(np.timedelta64(0)), npt.NDArray[np.timedelta64])
+assert_type(np.arange(0, np.timedelta64(10)), npt.NDArray[np.timedelta64])
+assert_type(np.arange(np.datetime64("0"), np.datetime64("10")), npt.NDArray[np.datetime64])
+assert_type(np.arange(10, dtype=np.float64), npt.NDArray[np.float64])
+assert_type(np.arange(0, 10, step=2, dtype=np.int16), npt.NDArray[np.int16])
+assert_type(np.arange(10, dtype=int), npt.NDArray[Any])
+assert_type(np.arange(0, 10, dtype="f8"), npt.NDArray[Any])
+
+assert_type(np.require(A), npt.NDArray[np.float64])
+assert_type(np.require(B), SubClass[np.float64])
+assert_type(np.require(B, requirements=None), SubClass[np.float64])
+assert_type(np.require(B, dtype=int), npt.NDArray[Any])
+assert_type(np.require(B, requirements="E"), npt.NDArray[Any])
+assert_type(np.require(B, requirements=["ENSUREARRAY"]), npt.NDArray[Any])
+assert_type(np.require(B, requirements={"F", "E"}), npt.NDArray[Any])
+assert_type(np.require(B, requirements=["C", "OWNDATA"]), SubClass[np.float64])
+assert_type(np.require(B, requirements="W"), SubClass[np.float64])
+assert_type(np.require(B, requirements="A"), SubClass[np.float64])
+assert_type(np.require(C), npt.NDArray[Any])
+
+assert_type(np.linspace(0, 10), npt.NDArray[np.floating[Any]])
+assert_type(np.linspace(0, 10j), npt.NDArray[np.complexfloating[Any, Any]])
+assert_type(np.linspace(0, 10, dtype=np.int64), npt.NDArray[np.int64])
+assert_type(np.linspace(0, 10, dtype=int), npt.NDArray[Any])
+assert_type(np.linspace(0, 10, retstep=True), tuple[npt.NDArray[np.floating[Any]], np.floating[Any]])
+assert_type(np.linspace(0j, 10, retstep=True), tuple[npt.NDArray[np.complexfloating[Any, Any]], np.complexfloating[Any, Any]])
+assert_type(np.linspace(0, 10, retstep=True, dtype=np.int64), tuple[npt.NDArray[np.int64], np.int64])
+assert_type(np.linspace(0j, 10, retstep=True, dtype=int), tuple[npt.NDArray[Any], Any])
+
+assert_type(np.logspace(0, 10), npt.NDArray[np.floating[Any]])
+assert_type(np.logspace(0, 10j), npt.NDArray[np.complexfloating[Any, Any]])
+assert_type(np.logspace(0, 10, dtype=np.int64), npt.NDArray[np.int64])
+assert_type(np.logspace(0, 10, dtype=int), npt.NDArray[Any])
+
+assert_type(np.geomspace(0, 10), npt.NDArray[np.floating[Any]])
+assert_type(np.geomspace(0, 10j), npt.NDArray[np.complexfloating[Any, Any]])
+assert_type(np.geomspace(0, 10, dtype=np.int64), npt.NDArray[np.int64])
+assert_type(np.geomspace(0, 10, dtype=int), npt.NDArray[Any])
+
+assert_type(np.zeros_like(A), npt.NDArray[np.float64])
+assert_type(np.zeros_like(C), npt.NDArray[Any])
+assert_type(np.zeros_like(A, dtype=float), npt.NDArray[Any])
+assert_type(np.zeros_like(B), SubClass[np.float64])
+assert_type(np.zeros_like(B, dtype=np.int64), npt.NDArray[np.int64])
+
+assert_type(np.ones_like(A), npt.NDArray[np.float64])
+assert_type(np.ones_like(C), npt.NDArray[Any])
+assert_type(np.ones_like(A, dtype=float), npt.NDArray[Any])
+assert_type(np.ones_like(B), SubClass[np.float64])
+assert_type(np.ones_like(B, dtype=np.int64), npt.NDArray[np.int64])
+
+assert_type(np.full_like(A, i8), npt.NDArray[np.float64])
+assert_type(np.full_like(C, i8), npt.NDArray[Any])
+assert_type(np.full_like(A, i8, dtype=int), npt.NDArray[Any])
+assert_type(np.full_like(B, i8), SubClass[np.float64])
+assert_type(np.full_like(B, i8, dtype=np.int64), npt.NDArray[np.int64])
+
+assert_type(np.ones(1), npt.NDArray[np.float64])
+assert_type(np.ones([1, 1, 1]), npt.NDArray[np.float64])
+assert_type(np.ones(5, dtype=np.int64), npt.NDArray[np.int64])
+assert_type(np.ones(5, dtype=int), npt.NDArray[Any])
+
+assert_type(np.full(1, i8), npt.NDArray[Any])
+assert_type(np.full([1, 1, 1], i8), npt.NDArray[Any])
+assert_type(np.full(1, i8, dtype=np.float64), npt.NDArray[np.float64])
+assert_type(np.full(1, i8, dtype=float), npt.NDArray[Any])
+
+assert_type(np.indices([1, 2, 3]), npt.NDArray[np.int_])
+assert_type(np.indices([1, 2, 3], sparse=True), tuple[npt.NDArray[np.int_], ...])
+
+assert_type(np.fromfunction(func, (3, 5)), SubClass[np.float64])
+
+assert_type(np.identity(10), npt.NDArray[np.float64])
+assert_type(np.identity(10, dtype=np.int64), npt.NDArray[np.int64])
+assert_type(np.identity(10, dtype=int), npt.NDArray[Any])
+
+assert_type(np.atleast_1d(A), npt.NDArray[np.float64])
+assert_type(np.atleast_1d(C), npt.NDArray[Any])
+assert_type(np.atleast_1d(A, A), tuple[npt.NDArray[Any], ...])
+assert_type(np.atleast_1d(A, C), tuple[npt.NDArray[Any], ...])
+assert_type(np.atleast_1d(C, C), tuple[npt.NDArray[Any], ...])
+
+assert_type(np.atleast_2d(A), npt.NDArray[np.float64])
+assert_type(np.atleast_2d(A, A), tuple[npt.NDArray[Any], ...])
+
+assert_type(np.atleast_3d(A), npt.NDArray[np.float64])
+assert_type(np.atleast_3d(A, A), tuple[npt.NDArray[Any], ...])
+
+assert_type(np.vstack([A, A]), np.ndarray[Any, Any])
+assert_type(np.vstack([A, A], dtype=np.float64), npt.NDArray[np.float64])
+assert_type(np.vstack([A, C]), npt.NDArray[Any])
+assert_type(np.vstack([C, C]), npt.NDArray[Any])
+
+assert_type(np.hstack([A, A]), np.ndarray[Any, Any])
+assert_type(np.hstack([A, A], dtype=np.float64), npt.NDArray[np.float64])
+
+assert_type(np.stack([A, A]), Any)
+assert_type(np.stack([A, A], dtype=np.float64), npt.NDArray[np.float64])
+assert_type(np.stack([A, C]), npt.NDArray[Any])
+assert_type(np.stack([C, C]), npt.NDArray[Any])
+assert_type(np.stack([A, A], axis=0), Any)
+assert_type(np.stack([A, A], out=B), SubClass[np.float64])
+
+assert_type(np.block([[A, A], [A, A]]), npt.NDArray[Any])
+assert_type(np.block(C), npt.NDArray[Any])
+
+if sys.version_info >= (3, 12):
+    from collections.abc import Buffer
+
+    def create_array(obj: npt.ArrayLike) -> npt.NDArray[Any]: ...
+
+    buffer: Buffer
+    assert_type(create_array(buffer), npt.NDArray[Any])
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/arraypad.pyi b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/arraypad.pyi
new file mode 100644
index 00000000..f53613ba
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/arraypad.pyi
@@ -0,0 +1,28 @@
+import sys
+from collections.abc import Mapping
+from typing import Any, SupportsIndex
+
+import numpy as np
+import numpy.typing as npt
+
+if sys.version_info >= (3, 11):
+    from typing import assert_type
+else:
+    from typing_extensions import assert_type
+
+def mode_func(
+    ar: npt.NDArray[np.number[Any]],
+    width: tuple[int, int],
+    iaxis: SupportsIndex,
+    kwargs: Mapping[str, Any],
+) -> None: ...
+
+AR_i8: npt.NDArray[np.int64]
+AR_f8: npt.NDArray[np.float64]
+AR_LIKE: list[int]
+
+assert_type(np.pad(AR_i8, (2, 3), "constant"), npt.NDArray[np.int64])
+assert_type(np.pad(AR_LIKE, (2, 3), "constant"), npt.NDArray[Any])
+
+assert_type(np.pad(AR_f8, (2, 3), mode_func), npt.NDArray[np.float64])
+assert_type(np.pad(AR_f8, (2, 3), mode_func, a=1, b=2), npt.NDArray[np.float64])
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/arrayprint.pyi b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/arrayprint.pyi
new file mode 100644
index 00000000..c4a16195
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/arrayprint.pyi
@@ -0,0 +1,31 @@
+import sys
+import contextlib
+from collections.abc import Callable
+from typing import Any
+
+import numpy as np
+import numpy.typing as npt
+from numpy._core.arrayprint import _FormatOptions
+
+if sys.version_info >= (3, 11):
+    from typing import assert_type
+else:
+    from typing_extensions import assert_type
+
+AR: npt.NDArray[np.int64]
+func_float: Callable[[np.floating[Any]], str]
+func_int: Callable[[np.integer[Any]], str]
+
+assert_type(np.get_printoptions(), _FormatOptions)
+assert_type(
+    np.array2string(AR, formatter={'float_kind': func_float, 'int_kind': func_int}),
+    str,
+)
+assert_type(np.format_float_scientific(1.0), str)
+assert_type(np.format_float_positional(1), str)
+assert_type(np.array_repr(AR), str)
+assert_type(np.array_str(AR), str)
+
+assert_type(np.printoptions(), contextlib._GeneratorContextManager[_FormatOptions])
+with np.printoptions() as dct:
+    assert_type(dct, _FormatOptions)
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/arraysetops.pyi b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/arraysetops.pyi
new file mode 100644
index 00000000..3b0a2448
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/arraysetops.pyi
@@ -0,0 +1,75 @@
+import sys
+from typing import Any
+
+import numpy as np
+import numpy.typing as npt
+from numpy.lib._arraysetops_impl import (
+    UniqueAllResult, UniqueCountsResult, UniqueInverseResult
+)
+
+if sys.version_info >= (3, 11):
+    from typing import assert_type
+else:
+    from typing_extensions import assert_type
+
+AR_b: npt.NDArray[np.bool]
+AR_i8: npt.NDArray[np.int64]
+AR_f8: npt.NDArray[np.float64]
+AR_M: npt.NDArray[np.datetime64]
+AR_O: npt.NDArray[np.object_]
+
+AR_LIKE_f8: list[float]
+
+assert_type(np.ediff1d(AR_b), npt.NDArray[np.int8])
+assert_type(np.ediff1d(AR_i8, to_end=[1, 2, 3]), npt.NDArray[np.int64])
+assert_type(np.ediff1d(AR_M), npt.NDArray[np.timedelta64])
+assert_type(np.ediff1d(AR_O), npt.NDArray[np.object_])
+assert_type(np.ediff1d(AR_LIKE_f8, to_begin=[1, 1.5]), npt.NDArray[Any])
+
+assert_type(np.intersect1d(AR_i8, AR_i8), npt.NDArray[np.int64])
+assert_type(np.intersect1d(AR_M, AR_M, assume_unique=True), npt.NDArray[np.datetime64])
+assert_type(np.intersect1d(AR_f8, AR_i8), npt.NDArray[Any])
+assert_type(np.intersect1d(AR_f8, AR_f8, return_indices=True), tuple[npt.NDArray[np.float64], npt.NDArray[np.intp], npt.NDArray[np.intp]])
+
+assert_type(np.setxor1d(AR_i8, AR_i8), npt.NDArray[np.int64])
+assert_type(np.setxor1d(AR_M, AR_M, assume_unique=True), npt.NDArray[np.datetime64])
+assert_type(np.setxor1d(AR_f8, AR_i8), npt.NDArray[Any])
+
+assert_type(np.isin(AR_i8, AR_i8), npt.NDArray[np.bool])
+assert_type(np.isin(AR_M, AR_M, assume_unique=True), npt.NDArray[np.bool])
+assert_type(np.isin(AR_f8, AR_i8), npt.NDArray[np.bool])
+assert_type(np.isin(AR_f8, AR_LIKE_f8, invert=True), npt.NDArray[np.bool])
+
+assert_type(np.union1d(AR_i8, AR_i8), npt.NDArray[np.int64])
+assert_type(np.union1d(AR_M, AR_M), npt.NDArray[np.datetime64])
+assert_type(np.union1d(AR_f8, AR_i8), npt.NDArray[Any])
+
+assert_type(np.setdiff1d(AR_i8, AR_i8), npt.NDArray[np.int64])
+assert_type(np.setdiff1d(AR_M, AR_M, assume_unique=True), npt.NDArray[np.datetime64])
+assert_type(np.setdiff1d(AR_f8, AR_i8), npt.NDArray[Any])
+
+assert_type(np.unique(AR_f8), npt.NDArray[np.float64])
+assert_type(np.unique(AR_LIKE_f8, axis=0), npt.NDArray[Any])
+assert_type(np.unique(AR_f8, return_index=True), tuple[npt.NDArray[np.float64], npt.NDArray[np.intp]])
+assert_type(np.unique(AR_LIKE_f8, return_index=True), tuple[npt.NDArray[Any], npt.NDArray[np.intp]])
+assert_type(np.unique(AR_f8, return_inverse=True), tuple[npt.NDArray[np.float64], npt.NDArray[np.intp]])
+assert_type(np.unique(AR_LIKE_f8, return_inverse=True), tuple[npt.NDArray[Any], npt.NDArray[np.intp]])
+assert_type(np.unique(AR_f8, return_counts=True), tuple[npt.NDArray[np.float64], npt.NDArray[np.intp]])
+assert_type(np.unique(AR_LIKE_f8, return_counts=True), tuple[npt.NDArray[Any], npt.NDArray[np.intp]])
+assert_type(np.unique(AR_f8, return_index=True, return_inverse=True), tuple[npt.NDArray[np.float64], npt.NDArray[np.intp], npt.NDArray[np.intp]])
+assert_type(np.unique(AR_LIKE_f8, return_index=True, return_inverse=True), tuple[npt.NDArray[Any], npt.NDArray[np.intp], npt.NDArray[np.intp]])
+assert_type(np.unique(AR_f8, return_index=True, return_counts=True), tuple[npt.NDArray[np.float64], npt.NDArray[np.intp], npt.NDArray[np.intp]])
+assert_type(np.unique(AR_LIKE_f8, return_index=True, return_counts=True), tuple[npt.NDArray[Any], npt.NDArray[np.intp], npt.NDArray[np.intp]])
+assert_type(np.unique(AR_f8, return_inverse=True, return_counts=True), tuple[npt.NDArray[np.float64], npt.NDArray[np.intp], npt.NDArray[np.intp]])
+assert_type(np.unique(AR_LIKE_f8, return_inverse=True, return_counts=True), tuple[npt.NDArray[Any], npt.NDArray[np.intp], npt.NDArray[np.intp]])
+assert_type(np.unique(AR_f8, return_index=True, return_inverse=True, return_counts=True), tuple[npt.NDArray[np.float64], npt.NDArray[np.intp], npt.NDArray[np.intp], npt.NDArray[np.intp]])
+assert_type(np.unique(AR_LIKE_f8, return_index=True, return_inverse=True, return_counts=True), tuple[npt.NDArray[Any], npt.NDArray[np.intp], npt.NDArray[np.intp], npt.NDArray[np.intp]])
+
+assert_type(np.unique_all(AR_f8), UniqueAllResult[np.float64])
+assert_type(np.unique_all(AR_LIKE_f8), UniqueAllResult[Any])
+assert_type(np.unique_counts(AR_f8), UniqueCountsResult[np.float64])
+assert_type(np.unique_counts(AR_LIKE_f8), UniqueCountsResult[Any])
+assert_type(np.unique_inverse(AR_f8), UniqueInverseResult[np.float64])
+assert_type(np.unique_inverse(AR_LIKE_f8), UniqueInverseResult[Any])
+assert_type(np.unique_values(AR_f8), npt.NDArray[np.float64])
+assert_type(np.unique_values(AR_LIKE_f8), npt.NDArray[Any])
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/arrayterator.pyi b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/arrayterator.pyi
new file mode 100644
index 00000000..5514bf6d
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/arrayterator.pyi
@@ -0,0 +1,33 @@
+import sys
+from typing import Any
+from collections.abc import Generator
+
+import numpy as np
+import numpy.typing as npt
+
+if sys.version_info >= (3, 11):
+    from typing import assert_type
+else:
+    from typing_extensions import assert_type
+
+AR_i8: npt.NDArray[np.int64]
+ar_iter = np.lib.Arrayterator(AR_i8)
+
+assert_type(ar_iter.var, npt.NDArray[np.int64])
+assert_type(ar_iter.buf_size, None | int)
+assert_type(ar_iter.start, list[int])
+assert_type(ar_iter.stop, list[int])
+assert_type(ar_iter.step, list[int])
+assert_type(ar_iter.shape, tuple[int, ...])
+assert_type(ar_iter.flat, Generator[np.int64, None, None])
+
+assert_type(ar_iter.__array__(), npt.NDArray[np.int64])
+
+for i in ar_iter:
+    assert_type(i, npt.NDArray[np.int64])
+
+assert_type(ar_iter[0], np.lib.Arrayterator[Any, np.dtype[np.int64]])
+assert_type(ar_iter[...], np.lib.Arrayterator[Any, np.dtype[np.int64]])
+assert_type(ar_iter[:], np.lib.Arrayterator[Any, np.dtype[np.int64]])
+assert_type(ar_iter[0, 0, 0], np.lib.Arrayterator[Any, np.dtype[np.int64]])
+assert_type(ar_iter[..., 0, :], np.lib.Arrayterator[Any, np.dtype[np.int64]])
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/bitwise_ops.pyi b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/bitwise_ops.pyi
new file mode 100644
index 00000000..1f04f4b0
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/bitwise_ops.pyi
@@ -0,0 +1,135 @@
+import sys
+from typing import Any
+
+import numpy as np
+import numpy.typing as npt
+from numpy._typing import _64Bit, _32Bit
+
+if sys.version_info >= (3, 11):
+    from typing import assert_type
+else:
+    from typing_extensions import assert_type
+
+i8 = np.int64(1)
+u8 = np.uint64(1)
+
+i4 = np.int32(1)
+u4 = np.uint32(1)
+
+b_ = np.bool(1)
+
+b = bool(1)
+i = int(1)
+
+AR = np.array([0, 1, 2], dtype=np.int32)
+AR.setflags(write=False)
+
+
+assert_type(i8 << i8, np.int64)
+assert_type(i8 >> i8, np.int64)
+assert_type(i8 | i8, np.int64)
+assert_type(i8 ^ i8, np.int64)
+assert_type(i8 & i8, np.int64)
+
+assert_type(i8 << AR, npt.NDArray[np.signedinteger[Any]])
+assert_type(i8 >> AR, npt.NDArray[np.signedinteger[Any]])
+assert_type(i8 | AR, npt.NDArray[np.signedinteger[Any]])
+assert_type(i8 ^ AR, npt.NDArray[np.signedinteger[Any]])
+assert_type(i8 & AR, npt.NDArray[np.signedinteger[Any]])
+
+assert_type(i4 << i4, np.int32)
+assert_type(i4 >> i4, np.int32)
+assert_type(i4 | i4, np.int32)
+assert_type(i4 ^ i4, np.int32)
+assert_type(i4 & i4, np.int32)
+
+assert_type(i8 << i4, np.signedinteger[_32Bit | _64Bit])
+assert_type(i8 >> i4, np.signedinteger[_32Bit | _64Bit])
+assert_type(i8 | i4, np.signedinteger[_32Bit | _64Bit])
+assert_type(i8 ^ i4, np.signedinteger[_32Bit | _64Bit])
+assert_type(i8 & i4, np.signedinteger[_32Bit | _64Bit])
+
+assert_type(i8 << b_, np.int64)
+assert_type(i8 >> b_, np.int64)
+assert_type(i8 | b_, np.int64)
+assert_type(i8 ^ b_, np.int64)
+assert_type(i8 & b_, np.int64)
+
+assert_type(i8 << b, np.int64)
+assert_type(i8 >> b, np.int64)
+assert_type(i8 | b, np.int64)
+assert_type(i8 ^ b, np.int64)
+assert_type(i8 & b, np.int64)
+
+assert_type(u8 << u8, np.uint64)
+assert_type(u8 >> u8, np.uint64)
+assert_type(u8 | u8, np.uint64)
+assert_type(u8 ^ u8, np.uint64)
+assert_type(u8 & u8, np.uint64)
+
+assert_type(u8 << AR, npt.NDArray[np.signedinteger[Any]])
+assert_type(u8 >> AR, npt.NDArray[np.signedinteger[Any]])
+assert_type(u8 | AR, npt.NDArray[np.signedinteger[Any]])
+assert_type(u8 ^ AR, npt.NDArray[np.signedinteger[Any]])
+assert_type(u8 & AR, npt.NDArray[np.signedinteger[Any]])
+
+assert_type(u4 << u4, np.uint32)
+assert_type(u4 >> u4, np.uint32)
+assert_type(u4 | u4, np.uint32)
+assert_type(u4 ^ u4, np.uint32)
+assert_type(u4 & u4, np.uint32)
+
+assert_type(u4 << i4, np.signedinteger[Any])
+assert_type(u4 >> i4, np.signedinteger[Any])
+assert_type(u4 | i4, np.signedinteger[Any])
+assert_type(u4 ^ i4, np.signedinteger[Any])
+assert_type(u4 & i4, np.signedinteger[Any])
+
+assert_type(u4 << i, np.signedinteger[Any])
+assert_type(u4 >> i, np.signedinteger[Any])
+assert_type(u4 | i, np.signedinteger[Any])
+assert_type(u4 ^ i, np.signedinteger[Any])
+assert_type(u4 & i, np.signedinteger[Any])
+
+assert_type(u8 << b_, np.uint64)
+assert_type(u8 >> b_, np.uint64)
+assert_type(u8 | b_, np.uint64)
+assert_type(u8 ^ b_, np.uint64)
+assert_type(u8 & b_, np.uint64)
+
+assert_type(u8 << b, np.uint64)
+assert_type(u8 >> b, np.uint64)
+assert_type(u8 | b, np.uint64)
+assert_type(u8 ^ b, np.uint64)
+assert_type(u8 & b, np.uint64)
+
+assert_type(b_ << b_, np.int8)
+assert_type(b_ >> b_, np.int8)
+assert_type(b_ | b_, np.bool)
+assert_type(b_ ^ b_, np.bool)
+assert_type(b_ & b_, np.bool)
+
+assert_type(b_ << AR, npt.NDArray[np.signedinteger[Any]])
+assert_type(b_ >> AR, npt.NDArray[np.signedinteger[Any]])
+assert_type(b_ | AR, npt.NDArray[np.signedinteger[Any]])
+assert_type(b_ ^ AR, npt.NDArray[np.signedinteger[Any]])
+assert_type(b_ & AR, npt.NDArray[np.signedinteger[Any]])
+
+assert_type(b_ << b, np.int8)
+assert_type(b_ >> b, np.int8)
+assert_type(b_ | b, np.bool)
+assert_type(b_ ^ b, np.bool)
+assert_type(b_ & b, np.bool)
+
+assert_type(b_ << i, np.int_)
+assert_type(b_ >> i, np.int_)
+assert_type(b_ | i, np.int_)
+assert_type(b_ ^ i, np.int_)
+assert_type(b_ & i, np.int_)
+
+assert_type(~i8, np.int64)
+assert_type(~i4, np.int32)
+assert_type(~u8, np.uint64)
+assert_type(~u4, np.uint32)
+assert_type(~b_, np.bool)
+assert_type(~AR, npt.NDArray[np.int32])
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/char.pyi b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/char.pyi
new file mode 100644
index 00000000..ab7186fa
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/char.pyi
@@ -0,0 +1,152 @@
+import sys
+from typing import Any
+
+import numpy as np
+import numpy.typing as npt
+
+if sys.version_info >= (3, 11):
+    from typing import assert_type
+else:
+    from typing_extensions import assert_type
+
+AR_U: npt.NDArray[np.str_]
+AR_S: npt.NDArray[np.bytes_]
+
+assert_type(np.char.equal(AR_U, AR_U), npt.NDArray[np.bool])
+assert_type(np.char.equal(AR_S, AR_S), npt.NDArray[np.bool])
+
+assert_type(np.char.not_equal(AR_U, AR_U), npt.NDArray[np.bool])
+assert_type(np.char.not_equal(AR_S, AR_S), npt.NDArray[np.bool])
+
+assert_type(np.char.greater_equal(AR_U, AR_U), npt.NDArray[np.bool])
+assert_type(np.char.greater_equal(AR_S, AR_S), npt.NDArray[np.bool])
+
+assert_type(np.char.less_equal(AR_U, AR_U), npt.NDArray[np.bool])
+assert_type(np.char.less_equal(AR_S, AR_S), npt.NDArray[np.bool])
+
+assert_type(np.char.greater(AR_U, AR_U), npt.NDArray[np.bool])
+assert_type(np.char.greater(AR_S, AR_S), npt.NDArray[np.bool])
+
+assert_type(np.char.less(AR_U, AR_U), npt.NDArray[np.bool])
+assert_type(np.char.less(AR_S, AR_S), npt.NDArray[np.bool])
+
+assert_type(np.char.multiply(AR_U, 5), npt.NDArray[np.str_])
+assert_type(np.char.multiply(AR_S, [5, 4, 3]), npt.NDArray[np.bytes_])
+
+assert_type(np.char.mod(AR_U, "test"), npt.NDArray[np.str_])
+assert_type(np.char.mod(AR_S, "test"), npt.NDArray[np.bytes_])
+
+assert_type(np.char.capitalize(AR_U), npt.NDArray[np.str_])
+assert_type(np.char.capitalize(AR_S), npt.NDArray[np.bytes_])
+
+assert_type(np.char.center(AR_U, 5), npt.NDArray[np.str_])
+assert_type(np.char.center(AR_S, [2, 3, 4], b"a"), npt.NDArray[np.bytes_])
+
+assert_type(np.char.encode(AR_U), npt.NDArray[np.bytes_])
+assert_type(np.char.decode(AR_S), npt.NDArray[np.str_])
+
+assert_type(np.char.expandtabs(AR_U), npt.NDArray[np.str_])
+assert_type(np.char.expandtabs(AR_S, tabsize=4), npt.NDArray[np.bytes_])
+
+assert_type(np.char.join(AR_U, "_"), npt.NDArray[np.str_])
+assert_type(np.char.join(AR_S, [b"_", b""]), npt.NDArray[np.bytes_])
+
+assert_type(np.char.ljust(AR_U, 5), npt.NDArray[np.str_])
+assert_type(np.char.ljust(AR_S, [4, 3, 1], fillchar=[b"a", b"b", b"c"]), npt.NDArray[np.bytes_])
+assert_type(np.char.rjust(AR_U, 5), npt.NDArray[np.str_])
+assert_type(np.char.rjust(AR_S, [4, 3, 1], fillchar=[b"a", b"b", b"c"]), npt.NDArray[np.bytes_])
+
+assert_type(np.char.lstrip(AR_U), npt.NDArray[np.str_])
+assert_type(np.char.lstrip(AR_S, chars=b"_"), npt.NDArray[np.bytes_])
+assert_type(np.char.rstrip(AR_U), npt.NDArray[np.str_])
+assert_type(np.char.rstrip(AR_S, chars=b"_"), npt.NDArray[np.bytes_])
+assert_type(np.char.strip(AR_U), npt.NDArray[np.str_])
+assert_type(np.char.strip(AR_S, chars=b"_"), npt.NDArray[np.bytes_])
+
+assert_type(np.char.partition(AR_U, "\n"), npt.NDArray[np.str_])
+assert_type(np.char.partition(AR_S, [b"a", b"b", b"c"]), npt.NDArray[np.bytes_])
+assert_type(np.char.rpartition(AR_U, "\n"), npt.NDArray[np.str_])
+assert_type(np.char.rpartition(AR_S, [b"a", b"b", b"c"]), npt.NDArray[np.bytes_])
+
+assert_type(np.char.replace(AR_U, "_", "-"), npt.NDArray[np.str_])
+assert_type(np.char.replace(AR_S, [b"_", b""], [b"a", b"b"]), npt.NDArray[np.bytes_])
+
+assert_type(np.char.split(AR_U, "_"), npt.NDArray[np.object_])
+assert_type(np.char.split(AR_S, maxsplit=[1, 2, 3]), npt.NDArray[np.object_])
+assert_type(np.char.rsplit(AR_U, "_"), npt.NDArray[np.object_])
+assert_type(np.char.rsplit(AR_S, maxsplit=[1, 2, 3]), npt.NDArray[np.object_])
+
+assert_type(np.char.splitlines(AR_U), npt.NDArray[np.object_])
+assert_type(np.char.splitlines(AR_S, keepends=[True, True, False]), npt.NDArray[np.object_])
+
+assert_type(np.char.swapcase(AR_U), npt.NDArray[np.str_])
+assert_type(np.char.swapcase(AR_S), npt.NDArray[np.bytes_])
+
+assert_type(np.char.title(AR_U), npt.NDArray[np.str_])
+assert_type(np.char.title(AR_S), npt.NDArray[np.bytes_])
+
+assert_type(np.char.upper(AR_U), npt.NDArray[np.str_])
+assert_type(np.char.upper(AR_S), npt.NDArray[np.bytes_])
+
+assert_type(np.char.zfill(AR_U, 5), npt.NDArray[np.str_])
+assert_type(np.char.zfill(AR_S, [2, 3, 4]), npt.NDArray[np.bytes_])
+
+assert_type(np.char.count(AR_U, "a", start=[1, 2, 3]), npt.NDArray[np.int_])
+assert_type(np.char.count(AR_S, [b"a", b"b", b"c"], end=9), npt.NDArray[np.int_])
+
+assert_type(np.char.endswith(AR_U, "a", start=[1, 2, 3]), npt.NDArray[np.bool])
+assert_type(np.char.endswith(AR_S, [b"a", b"b", b"c"], end=9), npt.NDArray[np.bool])
+assert_type(np.char.startswith(AR_U, "a", start=[1, 2, 3]), npt.NDArray[np.bool])
+assert_type(np.char.startswith(AR_S, [b"a", b"b", b"c"], end=9), npt.NDArray[np.bool])
+
+assert_type(np.char.find(AR_U, "a", start=[1, 2, 3]), npt.NDArray[np.int_])
+assert_type(np.char.find(AR_S, [b"a", b"b", b"c"], end=9), npt.NDArray[np.int_])
+assert_type(np.char.rfind(AR_U, "a", start=[1, 2, 3]), npt.NDArray[np.int_])
+assert_type(np.char.rfind(AR_S, [b"a", b"b", b"c"], end=9), npt.NDArray[np.int_])
+
+assert_type(np.char.index(AR_U, "a", start=[1, 2, 3]), npt.NDArray[np.int_])
+assert_type(np.char.index(AR_S, [b"a", b"b", b"c"], end=9), npt.NDArray[np.int_])
+assert_type(np.char.rindex(AR_U, "a", start=[1, 2, 3]), npt.NDArray[np.int_])
+assert_type(np.char.rindex(AR_S, [b"a", b"b", b"c"], end=9), npt.NDArray[np.int_])
+
+assert_type(np.char.isalpha(AR_U), npt.NDArray[np.bool])
+assert_type(np.char.isalpha(AR_S), npt.NDArray[np.bool])
+
+assert_type(np.char.isalnum(AR_U), npt.NDArray[np.bool])
+assert_type(np.char.isalnum(AR_S), npt.NDArray[np.bool])
+
+assert_type(np.char.isdecimal(AR_U), npt.NDArray[np.bool])
+
+assert_type(np.char.isdigit(AR_U), npt.NDArray[np.bool])
+assert_type(np.char.isdigit(AR_S), npt.NDArray[np.bool])
+
+assert_type(np.char.islower(AR_U), npt.NDArray[np.bool])
+assert_type(np.char.islower(AR_S), npt.NDArray[np.bool])
+
+assert_type(np.char.isnumeric(AR_U), npt.NDArray[np.bool])
+
+assert_type(np.char.isspace(AR_U), npt.NDArray[np.bool])
+assert_type(np.char.isspace(AR_S), npt.NDArray[np.bool])
+
+assert_type(np.char.istitle(AR_U), npt.NDArray[np.bool])
+assert_type(np.char.istitle(AR_S), npt.NDArray[np.bool])
+
+assert_type(np.char.isupper(AR_U), npt.NDArray[np.bool])
+assert_type(np.char.isupper(AR_S), npt.NDArray[np.bool])
+
+assert_type(np.char.str_len(AR_U), npt.NDArray[np.int_])
+assert_type(np.char.str_len(AR_S), npt.NDArray[np.int_])
+
+assert_type(np.char.array(AR_U), np.char.chararray[Any, np.dtype[np.str_]])
+assert_type(np.char.array(AR_S, order="K"), np.char.chararray[Any, np.dtype[np.bytes_]])
+assert_type(np.char.array("bob", copy=True), np.char.chararray[Any, np.dtype[np.str_]])
+assert_type(np.char.array(b"bob", itemsize=5), np.char.chararray[Any, np.dtype[np.bytes_]])
+assert_type(np.char.array(1, unicode=False), np.char.chararray[Any, np.dtype[np.bytes_]])
+assert_type(np.char.array(1, unicode=True), np.char.chararray[Any, np.dtype[np.str_]])
+
+assert_type(np.char.asarray(AR_U), np.char.chararray[Any, np.dtype[np.str_]])
+assert_type(np.char.asarray(AR_S, order="K"), np.char.chararray[Any, np.dtype[np.bytes_]])
+assert_type(np.char.asarray("bob"), np.char.chararray[Any, np.dtype[np.str_]])
+assert_type(np.char.asarray(b"bob", itemsize=5), np.char.chararray[Any, np.dtype[np.bytes_]])
+assert_type(np.char.asarray(1, unicode=False), np.char.chararray[Any, np.dtype[np.bytes_]])
+assert_type(np.char.asarray(1, unicode=True), np.char.chararray[Any, np.dtype[np.str_]])
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/chararray.pyi b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/chararray.pyi
new file mode 100644
index 00000000..0fb62152
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/chararray.pyi
@@ -0,0 +1,140 @@
+import sys
+from typing import Any
+
+import numpy as np
+import numpy.typing as npt
+
+if sys.version_info >= (3, 11):
+    from typing import assert_type
+else:
+    from typing_extensions import assert_type
+
+AR_U: np.char.chararray[Any, np.dtype[np.str_]]
+AR_S: np.char.chararray[Any, np.dtype[np.bytes_]]
+
+assert_type(AR_U == AR_U, npt.NDArray[np.bool])
+assert_type(AR_S == AR_S, npt.NDArray[np.bool])
+
+assert_type(AR_U != AR_U, npt.NDArray[np.bool])
+assert_type(AR_S != AR_S, npt.NDArray[np.bool])
+
+assert_type(AR_U >= AR_U, npt.NDArray[np.bool])
+assert_type(AR_S >= AR_S, npt.NDArray[np.bool])
+
+assert_type(AR_U <= AR_U, npt.NDArray[np.bool])
+assert_type(AR_S <= AR_S, npt.NDArray[np.bool])
+
+assert_type(AR_U > AR_U, npt.NDArray[np.bool])
+assert_type(AR_S > AR_S, npt.NDArray[np.bool])
+
+assert_type(AR_U < AR_U, npt.NDArray[np.bool])
+assert_type(AR_S < AR_S, npt.NDArray[np.bool])
+
+assert_type(AR_U * 5, np.char.chararray[Any, np.dtype[np.str_]])
+assert_type(AR_S * [5], np.char.chararray[Any, np.dtype[np.bytes_]])
+
+assert_type(AR_U % "test", np.char.chararray[Any, np.dtype[np.str_]])
+assert_type(AR_S % b"test", np.char.chararray[Any, np.dtype[np.bytes_]])
+
+assert_type(AR_U.capitalize(), np.char.chararray[Any, np.dtype[np.str_]])
+assert_type(AR_S.capitalize(), np.char.chararray[Any, np.dtype[np.bytes_]])
+
+assert_type(AR_U.center(5), np.char.chararray[Any, np.dtype[np.str_]])
+assert_type(AR_S.center([2, 3, 4], b"a"), np.char.chararray[Any, np.dtype[np.bytes_]])
+
+assert_type(AR_U.encode(), np.char.chararray[Any, np.dtype[np.bytes_]])
+assert_type(AR_S.decode(), np.char.chararray[Any, np.dtype[np.str_]])
+
+assert_type(AR_U.expandtabs(), np.char.chararray[Any, np.dtype[np.str_]])
+assert_type(AR_S.expandtabs(tabsize=4), np.char.chararray[Any, np.dtype[np.bytes_]])
+
+assert_type(AR_U.join("_"), np.char.chararray[Any, np.dtype[np.str_]])
+assert_type(AR_S.join([b"_", b""]), np.char.chararray[Any, np.dtype[np.bytes_]])
+
+assert_type(AR_U.ljust(5), np.char.chararray[Any, np.dtype[np.str_]])
+assert_type(AR_S.ljust([4, 3, 1], fillchar=[b"a", b"b", b"c"]), np.char.chararray[Any, np.dtype[np.bytes_]])
+assert_type(AR_U.rjust(5), np.char.chararray[Any, np.dtype[np.str_]])
+assert_type(AR_S.rjust([4, 3, 1], fillchar=[b"a", b"b", b"c"]), np.char.chararray[Any, np.dtype[np.bytes_]])
+
+assert_type(AR_U.lstrip(), np.char.chararray[Any, np.dtype[np.str_]])
+assert_type(AR_S.lstrip(chars=b"_"), np.char.chararray[Any, np.dtype[np.bytes_]])
+assert_type(AR_U.rstrip(), np.char.chararray[Any, np.dtype[np.str_]])
+assert_type(AR_S.rstrip(chars=b"_"), np.char.chararray[Any, np.dtype[np.bytes_]])
+assert_type(AR_U.strip(), np.char.chararray[Any, np.dtype[np.str_]])
+assert_type(AR_S.strip(chars=b"_"), np.char.chararray[Any, np.dtype[np.bytes_]])
+
+assert_type(AR_U.partition("\n"), np.char.chararray[Any, np.dtype[np.str_]])
+assert_type(AR_S.partition([b"a", b"b", b"c"]), np.char.chararray[Any, np.dtype[np.bytes_]])
+assert_type(AR_U.rpartition("\n"), np.char.chararray[Any, np.dtype[np.str_]])
+assert_type(AR_S.rpartition([b"a", b"b", b"c"]), np.char.chararray[Any, np.dtype[np.bytes_]])
+
+assert_type(AR_U.replace("_", "-"), np.char.chararray[Any, np.dtype[np.str_]])
+assert_type(AR_S.replace([b"_", b""], [b"a", b"b"]), np.char.chararray[Any, np.dtype[np.bytes_]])
+
+assert_type(AR_U.split("_"), npt.NDArray[np.object_])
+assert_type(AR_S.split(maxsplit=[1, 2, 3]), npt.NDArray[np.object_])
+assert_type(AR_U.rsplit("_"), npt.NDArray[np.object_])
+assert_type(AR_S.rsplit(maxsplit=[1, 2, 3]), npt.NDArray[np.object_])
+
+assert_type(AR_U.splitlines(), npt.NDArray[np.object_])
+assert_type(AR_S.splitlines(keepends=[True, True, False]), npt.NDArray[np.object_])
+
+assert_type(AR_U.swapcase(), np.char.chararray[Any, np.dtype[np.str_]])
+assert_type(AR_S.swapcase(), np.char.chararray[Any, np.dtype[np.bytes_]])
+
+assert_type(AR_U.title(), np.char.chararray[Any, np.dtype[np.str_]])
+assert_type(AR_S.title(), np.char.chararray[Any, np.dtype[np.bytes_]])
+
+assert_type(AR_U.upper(), np.char.chararray[Any, np.dtype[np.str_]])
+assert_type(AR_S.upper(), np.char.chararray[Any, np.dtype[np.bytes_]])
+
+assert_type(AR_U.zfill(5), np.char.chararray[Any, np.dtype[np.str_]])
+assert_type(AR_S.zfill([2, 3, 4]), np.char.chararray[Any, np.dtype[np.bytes_]])
+
+assert_type(AR_U.count("a", start=[1, 2, 3]), npt.NDArray[np.int_])
+assert_type(AR_S.count([b"a", b"b", b"c"], end=9), npt.NDArray[np.int_])
+
+assert_type(AR_U.endswith("a", start=[1, 2, 3]), npt.NDArray[np.bool])
+assert_type(AR_S.endswith([b"a", b"b", b"c"], end=9), npt.NDArray[np.bool])
+assert_type(AR_U.startswith("a", start=[1, 2, 3]), npt.NDArray[np.bool])
+assert_type(AR_S.startswith([b"a", b"b", b"c"], end=9), npt.NDArray[np.bool])
+
+assert_type(AR_U.find("a", start=[1, 2, 3]), npt.NDArray[np.int_])
+assert_type(AR_S.find([b"a", b"b", b"c"], end=9), npt.NDArray[np.int_])
+assert_type(AR_U.rfind("a", start=[1, 2, 3]), npt.NDArray[np.int_])
+assert_type(AR_S.rfind([b"a", b"b", b"c"], end=9), npt.NDArray[np.int_])
+
+assert_type(AR_U.index("a", start=[1, 2, 3]), npt.NDArray[np.int_])
+assert_type(AR_S.index([b"a", b"b", b"c"], end=9), npt.NDArray[np.int_])
+assert_type(AR_U.rindex("a", start=[1, 2, 3]), npt.NDArray[np.int_])
+assert_type(AR_S.rindex([b"a", b"b", b"c"], end=9), npt.NDArray[np.int_])
+
+assert_type(AR_U.isalpha(), npt.NDArray[np.bool])
+assert_type(AR_S.isalpha(), npt.NDArray[np.bool])
+
+assert_type(AR_U.isalnum(), npt.NDArray[np.bool])
+assert_type(AR_S.isalnum(), npt.NDArray[np.bool])
+
+assert_type(AR_U.isdecimal(), npt.NDArray[np.bool])
+assert_type(AR_S.isdecimal(), npt.NDArray[np.bool])
+
+assert_type(AR_U.isdigit(), npt.NDArray[np.bool])
+assert_type(AR_S.isdigit(), npt.NDArray[np.bool])
+
+assert_type(AR_U.islower(), npt.NDArray[np.bool])
+assert_type(AR_S.islower(), npt.NDArray[np.bool])
+
+assert_type(AR_U.isnumeric(), npt.NDArray[np.bool])
+assert_type(AR_S.isnumeric(), npt.NDArray[np.bool])
+
+assert_type(AR_U.isspace(), npt.NDArray[np.bool])
+assert_type(AR_S.isspace(), npt.NDArray[np.bool])
+
+assert_type(AR_U.istitle(), npt.NDArray[np.bool])
+assert_type(AR_S.istitle(), npt.NDArray[np.bool])
+
+assert_type(AR_U.isupper(), npt.NDArray[np.bool])
+assert_type(AR_S.isupper(), npt.NDArray[np.bool])
+
+assert_type(AR_U.__array_finalize__(object()), None)
+assert_type(AR_S.__array_finalize__(object()), None)
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/comparisons.pyi b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/comparisons.pyi
new file mode 100644
index 00000000..034efbef
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/comparisons.pyi
@@ -0,0 +1,270 @@
+import sys
+import fractions
+import decimal
+from typing import Any
+
+import numpy as np
+import numpy.typing as npt
+
+if sys.version_info >= (3, 11):
+    from typing import assert_type
+else:
+    from typing_extensions import assert_type
+
+c16 = np.complex128()
+f8 = np.float64()
+i8 = np.int64()
+u8 = np.uint64()
+
+c8 = np.complex64()
+f4 = np.float32()
+i4 = np.int32()
+u4 = np.uint32()
+
+dt = np.datetime64(0, "D")
+td = np.timedelta64(0, "D")
+
+b_ = np.bool()
+
+b = bool()
+c = complex()
+f = float()
+i = int()
+
+AR = np.array([0], dtype=np.int64)
+AR.setflags(write=False)
+
+SEQ = (0, 1, 2, 3, 4)
+
+# object-like comparisons
+
+assert_type(i8 > fractions.Fraction(1, 5), np.bool)
+assert_type(i8 > [fractions.Fraction(1, 5)], npt.NDArray[np.bool])
+assert_type(i8 > decimal.Decimal("1.5"), np.bool)
+assert_type(i8 > [decimal.Decimal("1.5")], npt.NDArray[np.bool])
+
+# Time structures
+
+assert_type(dt > dt, np.bool)
+
+assert_type(td > td, np.bool)
+assert_type(td > i, np.bool)
+assert_type(td > i4, np.bool)
+assert_type(td > i8, np.bool)
+
+assert_type(td > AR, npt.NDArray[np.bool])
+assert_type(td > SEQ, npt.NDArray[np.bool])
+assert_type(AR > SEQ, npt.NDArray[np.bool])
+assert_type(AR > td, npt.NDArray[np.bool])
+assert_type(SEQ > td, npt.NDArray[np.bool])
+assert_type(SEQ > AR, npt.NDArray[np.bool])
+
+# boolean
+
+assert_type(b_ > b, np.bool)
+assert_type(b_ > b_, np.bool)
+assert_type(b_ > i, np.bool)
+assert_type(b_ > i8, np.bool)
+assert_type(b_ > i4, np.bool)
+assert_type(b_ > u8, np.bool)
+assert_type(b_ > u4, np.bool)
+assert_type(b_ > f, np.bool)
+assert_type(b_ > f8, np.bool)
+assert_type(b_ > f4, np.bool)
+assert_type(b_ > c, np.bool)
+assert_type(b_ > c16, np.bool)
+assert_type(b_ > c8, np.bool)
+assert_type(b_ > AR, npt.NDArray[np.bool])
+assert_type(b_ > SEQ, npt.NDArray[np.bool])
+
+# Complex
+
+assert_type(c16 > c16, np.bool)
+assert_type(c16 > f8, np.bool)
+assert_type(c16 > i8, np.bool)
+assert_type(c16 > c8, np.bool)
+assert_type(c16 > f4, np.bool)
+assert_type(c16 > i4, np.bool)
+assert_type(c16 > b_, np.bool)
+assert_type(c16 > b, np.bool)
+assert_type(c16 > c, np.bool)
+assert_type(c16 > f, np.bool)
+assert_type(c16 > i, np.bool)
+assert_type(c16 > AR, npt.NDArray[np.bool])
+assert_type(c16 > SEQ, npt.NDArray[np.bool])
+
+assert_type(c16 > c16, np.bool)
+assert_type(f8 > c16, np.bool)
+assert_type(i8 > c16, np.bool)
+assert_type(c8 > c16, np.bool)
+assert_type(f4 > c16, np.bool)
+assert_type(i4 > c16, np.bool)
+assert_type(b_ > c16, np.bool)
+assert_type(b > c16, np.bool)
+assert_type(c > c16, np.bool)
+assert_type(f > c16, np.bool)
+assert_type(i > c16, np.bool)
+assert_type(AR > c16, npt.NDArray[np.bool])
+assert_type(SEQ > c16, npt.NDArray[np.bool])
+
+assert_type(c8 > c16, np.bool)
+assert_type(c8 > f8, np.bool)
+assert_type(c8 > i8, np.bool)
+assert_type(c8 > c8, np.bool)
+assert_type(c8 > f4, np.bool)
+assert_type(c8 > i4, np.bool)
+assert_type(c8 > b_, np.bool)
+assert_type(c8 > b, np.bool)
+assert_type(c8 > c, np.bool)
+assert_type(c8 > f, np.bool)
+assert_type(c8 > i, np.bool)
+assert_type(c8 > AR, npt.NDArray[np.bool])
+assert_type(c8 > SEQ, npt.NDArray[np.bool])
+
+assert_type(c16 > c8, np.bool)
+assert_type(f8 > c8, np.bool)
+assert_type(i8 > c8, np.bool)
+assert_type(c8 > c8, np.bool)
+assert_type(f4 > c8, np.bool)
+assert_type(i4 > c8, np.bool)
+assert_type(b_ > c8, np.bool)
+assert_type(b > c8, np.bool)
+assert_type(c > c8, np.bool)
+assert_type(f > c8, np.bool)
+assert_type(i > c8, np.bool)
+assert_type(AR > c8, npt.NDArray[np.bool])
+assert_type(SEQ > c8, npt.NDArray[np.bool])
+
+# Float
+
+assert_type(f8 > f8, np.bool)
+assert_type(f8 > i8, np.bool)
+assert_type(f8 > f4, np.bool)
+assert_type(f8 > i4, np.bool)
+assert_type(f8 > b_, np.bool)
+assert_type(f8 > b, np.bool)
+assert_type(f8 > c, np.bool)
+assert_type(f8 > f, np.bool)
+assert_type(f8 > i, np.bool)
+assert_type(f8 > AR, npt.NDArray[np.bool])
+assert_type(f8 > SEQ, npt.NDArray[np.bool])
+
+assert_type(f8 > f8, np.bool)
+assert_type(i8 > f8, np.bool)
+assert_type(f4 > f8, np.bool)
+assert_type(i4 > f8, np.bool)
+assert_type(b_ > f8, np.bool)
+assert_type(b > f8, np.bool)
+assert_type(c > f8, np.bool)
+assert_type(f > f8, np.bool)
+assert_type(i > f8, np.bool)
+assert_type(AR > f8, npt.NDArray[np.bool])
+assert_type(SEQ > f8, npt.NDArray[np.bool])
+
+assert_type(f4 > f8, np.bool)
+assert_type(f4 > i8, np.bool)
+assert_type(f4 > f4, np.bool)
+assert_type(f4 > i4, np.bool)
+assert_type(f4 > b_, np.bool)
+assert_type(f4 > b, np.bool)
+assert_type(f4 > c, np.bool)
+assert_type(f4 > f, np.bool)
+assert_type(f4 > i, np.bool)
+assert_type(f4 > AR, npt.NDArray[np.bool])
+assert_type(f4 > SEQ, npt.NDArray[np.bool])
+
+assert_type(f8 > f4, np.bool)
+assert_type(i8 > f4, np.bool)
+assert_type(f4 > f4, np.bool)
+assert_type(i4 > f4, np.bool)
+assert_type(b_ > f4, np.bool)
+assert_type(b > f4, np.bool)
+assert_type(c > f4, np.bool)
+assert_type(f > f4, np.bool)
+assert_type(i > f4, np.bool)
+assert_type(AR > f4, npt.NDArray[np.bool])
+assert_type(SEQ > f4, npt.NDArray[np.bool])
+
+# Int
+
+assert_type(i8 > i8, np.bool)
+assert_type(i8 > u8, np.bool)
+assert_type(i8 > i4, np.bool)
+assert_type(i8 > u4, np.bool)
+assert_type(i8 > b_, np.bool)
+assert_type(i8 > b, np.bool)
+assert_type(i8 > c, np.bool)
+assert_type(i8 > f, np.bool)
+assert_type(i8 > i, np.bool)
+assert_type(i8 > AR, npt.NDArray[np.bool])
+assert_type(i8 > SEQ, npt.NDArray[np.bool])
+
+assert_type(u8 > u8, np.bool)
+assert_type(u8 > i4, np.bool)
+assert_type(u8 > u4, np.bool)
+assert_type(u8 > b_, np.bool)
+assert_type(u8 > b, np.bool)
+assert_type(u8 > c, np.bool)
+assert_type(u8 > f, np.bool)
+assert_type(u8 > i, np.bool)
+assert_type(u8 > AR, npt.NDArray[np.bool])
+assert_type(u8 > SEQ, npt.NDArray[np.bool])
+
+assert_type(i8 > i8, np.bool)
+assert_type(u8 > i8, np.bool)
+assert_type(i4 > i8, np.bool)
+assert_type(u4 > i8, np.bool)
+assert_type(b_ > i8, np.bool)
+assert_type(b > i8, np.bool)
+assert_type(c > i8, np.bool)
+assert_type(f > i8, np.bool)
+assert_type(i > i8, np.bool)
+assert_type(AR > i8, npt.NDArray[np.bool])
+assert_type(SEQ > i8, npt.NDArray[np.bool])
+
+assert_type(u8 > u8, np.bool)
+assert_type(i4 > u8, np.bool)
+assert_type(u4 > u8, np.bool)
+assert_type(b_ > u8, np.bool)
+assert_type(b > u8, np.bool)
+assert_type(c > u8, np.bool)
+assert_type(f > u8, np.bool)
+assert_type(i > u8, np.bool)
+assert_type(AR > u8, npt.NDArray[np.bool])
+assert_type(SEQ > u8, npt.NDArray[np.bool])
+
+assert_type(i4 > i8, np.bool)
+assert_type(i4 > i4, np.bool)
+assert_type(i4 > i, np.bool)
+assert_type(i4 > b_, np.bool)
+assert_type(i4 > b, np.bool)
+assert_type(i4 > AR, npt.NDArray[np.bool])
+assert_type(i4 > SEQ, npt.NDArray[np.bool])
+
+assert_type(u4 > i8, np.bool)
+assert_type(u4 > i4, np.bool)
+assert_type(u4 > u8, np.bool)
+assert_type(u4 > u4, np.bool)
+assert_type(u4 > i, np.bool)
+assert_type(u4 > b_, np.bool)
+assert_type(u4 > b, np.bool)
+assert_type(u4 > AR, npt.NDArray[np.bool])
+assert_type(u4 > SEQ, npt.NDArray[np.bool])
+
+assert_type(i8 > i4, np.bool)
+assert_type(i4 > i4, np.bool)
+assert_type(i > i4, np.bool)
+assert_type(b_ > i4, np.bool)
+assert_type(b > i4, np.bool)
+assert_type(AR > i4, npt.NDArray[np.bool])
+assert_type(SEQ > i4, npt.NDArray[np.bool])
+
+assert_type(i8 > u4, np.bool)
+assert_type(i4 > u4, np.bool)
+assert_type(u8 > u4, np.bool)
+assert_type(u4 > u4, np.bool)
+assert_type(b_ > u4, np.bool)
+assert_type(b > u4, np.bool)
+assert_type(i > u4, np.bool)
+assert_type(AR > u4, npt.NDArray[np.bool])
+assert_type(SEQ > u4, npt.NDArray[np.bool])
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/constants.pyi b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/constants.pyi
new file mode 100644
index 00000000..5166d4f2
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/constants.pyi
@@ -0,0 +1,19 @@
+import sys
+
+import numpy as np
+
+if sys.version_info >= (3, 11):
+    from typing import assert_type
+else:
+    from typing_extensions import assert_type
+
+assert_type(np.e, float)
+assert_type(np.euler_gamma, float)
+assert_type(np.inf, float)
+assert_type(np.nan, float)
+assert_type(np.pi, float)
+
+assert_type(np.little_endian, bool)
+assert_type(np.True_, np.bool)
+assert_type(np.False_, np.bool)
+
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/ctypeslib.pyi b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/ctypeslib.pyi
new file mode 100644
index 00000000..992eb4bb
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/ctypeslib.pyi
@@ -0,0 +1,96 @@
+import sys
+import ctypes as ct
+from typing import Any
+
+import numpy as np
+import numpy.typing as npt
+from numpy import ctypeslib
+
+if sys.version_info >= (3, 11):
+    from typing import assert_type
+else:
+    from typing_extensions import assert_type
+
+AR_bool: npt.NDArray[np.bool]
+AR_ubyte: npt.NDArray[np.ubyte]
+AR_ushort: npt.NDArray[np.ushort]
+AR_uintc: npt.NDArray[np.uintc]
+AR_ulong: npt.NDArray[np.ulong]
+AR_ulonglong: npt.NDArray[np.ulonglong]
+AR_byte: npt.NDArray[np.byte]
+AR_short: npt.NDArray[np.short]
+AR_intc: npt.NDArray[np.intc]
+AR_long: npt.NDArray[np.long]
+AR_longlong: npt.NDArray[np.longlong]
+AR_single: npt.NDArray[np.single]
+AR_double: npt.NDArray[np.double]
+AR_longdouble: npt.NDArray[np.longdouble]
+AR_void: npt.NDArray[np.void]
+
+pointer: ct._Pointer[Any]
+
+assert_type(np.ctypeslib.c_intp(), ctypeslib.c_intp)
+
+assert_type(np.ctypeslib.ndpointer(), type[ctypeslib._ndptr[None]])
+assert_type(np.ctypeslib.ndpointer(dtype=np.float64), type[ctypeslib._ndptr[np.dtype[np.float64]]])
+assert_type(np.ctypeslib.ndpointer(dtype=float), type[ctypeslib._ndptr[np.dtype[Any]]])
+assert_type(np.ctypeslib.ndpointer(shape=(10, 3)), type[ctypeslib._ndptr[None]])
+assert_type(np.ctypeslib.ndpointer(np.int64, shape=(10, 3)), type[ctypeslib._concrete_ndptr[np.dtype[np.int64]]])
+assert_type(np.ctypeslib.ndpointer(int, shape=(1,)), type[np.ctypeslib._concrete_ndptr[np.dtype[Any]]])
+
+assert_type(np.ctypeslib.as_ctypes_type(np.bool), type[ct.c_bool])
+assert_type(np.ctypeslib.as_ctypes_type(np.ubyte), type[ct.c_ubyte])
+assert_type(np.ctypeslib.as_ctypes_type(np.ushort), type[ct.c_ushort])
+assert_type(np.ctypeslib.as_ctypes_type(np.uintc), type[ct.c_uint])
+assert_type(np.ctypeslib.as_ctypes_type(np.byte), type[ct.c_byte])
+assert_type(np.ctypeslib.as_ctypes_type(np.short), type[ct.c_short])
+assert_type(np.ctypeslib.as_ctypes_type(np.intc), type[ct.c_int])
+assert_type(np.ctypeslib.as_ctypes_type(np.single), type[ct.c_float])
+assert_type(np.ctypeslib.as_ctypes_type(np.double), type[ct.c_double])
+assert_type(np.ctypeslib.as_ctypes_type(ct.c_double), type[ct.c_double])
+assert_type(np.ctypeslib.as_ctypes_type("q"), type[ct.c_longlong])
+assert_type(np.ctypeslib.as_ctypes_type([("i8", np.int64), ("f8", np.float64)]), type[Any])
+assert_type(np.ctypeslib.as_ctypes_type("i8"), type[Any])
+assert_type(np.ctypeslib.as_ctypes_type("f8"), type[Any])
+
+assert_type(np.ctypeslib.as_ctypes(AR_bool.take(0)), ct.c_bool)
+assert_type(np.ctypeslib.as_ctypes(AR_ubyte.take(0)), ct.c_ubyte)
+assert_type(np.ctypeslib.as_ctypes(AR_ushort.take(0)), ct.c_ushort)
+assert_type(np.ctypeslib.as_ctypes(AR_uintc.take(0)), ct.c_uint)
+
+assert_type(np.ctypeslib.as_ctypes(AR_byte.take(0)), ct.c_byte)
+assert_type(np.ctypeslib.as_ctypes(AR_short.take(0)), ct.c_short)
+assert_type(np.ctypeslib.as_ctypes(AR_intc.take(0)), ct.c_int)
+assert_type(np.ctypeslib.as_ctypes(AR_single.take(0)), ct.c_float)
+assert_type(np.ctypeslib.as_ctypes(AR_double.take(0)), ct.c_double)
+assert_type(np.ctypeslib.as_ctypes(AR_void.take(0)), Any)
+assert_type(np.ctypeslib.as_ctypes(AR_bool), ct.Array[ct.c_bool])
+assert_type(np.ctypeslib.as_ctypes(AR_ubyte), ct.Array[ct.c_ubyte])
+assert_type(np.ctypeslib.as_ctypes(AR_ushort), ct.Array[ct.c_ushort])
+assert_type(np.ctypeslib.as_ctypes(AR_uintc), ct.Array[ct.c_uint])
+assert_type(np.ctypeslib.as_ctypes(AR_byte), ct.Array[ct.c_byte])
+assert_type(np.ctypeslib.as_ctypes(AR_short), ct.Array[ct.c_short])
+assert_type(np.ctypeslib.as_ctypes(AR_intc), ct.Array[ct.c_int])
+assert_type(np.ctypeslib.as_ctypes(AR_single), ct.Array[ct.c_float])
+assert_type(np.ctypeslib.as_ctypes(AR_double), ct.Array[ct.c_double])
+assert_type(np.ctypeslib.as_ctypes(AR_void), ct.Array[Any])
+
+assert_type(np.ctypeslib.as_array(AR_ubyte), npt.NDArray[np.ubyte])
+assert_type(np.ctypeslib.as_array(1), npt.NDArray[Any])
+assert_type(np.ctypeslib.as_array(pointer), npt.NDArray[Any])
+
+if sys.platform == "win32":
+    # Mainly on windows int is the same size as long but gets picked first:
+    assert_type(np.ctypeslib.as_ctypes_type(np.long), type[ct.c_int])
+    assert_type(np.ctypeslib.as_ctypes_type(np.ulong), type[ct.c_uint])
+    assert_type(np.ctypeslib.as_ctypes(AR_ulong), ct.Array[ct.c_uint])
+    assert_type(np.ctypeslib.as_ctypes(AR_long), ct.Array[ct.c_int])
+    assert_type(np.ctypeslib.as_ctypes(AR_long.take(0)), ct.c_int)
+    assert_type(np.ctypeslib.as_ctypes(AR_ulong.take(0)), ct.c_uint)
+else:
+    assert_type(np.ctypeslib.as_ctypes_type(np.long), type[ct.c_long])
+    assert_type(np.ctypeslib.as_ctypes_type(np.ulong), type[ct.c_ulong])
+    assert_type(np.ctypeslib.as_ctypes(AR_ulong), ct.Array[ct.c_ulong])
+    assert_type(np.ctypeslib.as_ctypes(AR_long), ct.Array[ct.c_long])
+    assert_type(np.ctypeslib.as_ctypes(AR_long.take(0)), ct.c_long)
+    assert_type(np.ctypeslib.as_ctypes(AR_ulong.take(0)), ct.c_ulong)
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/datasource.pyi b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/datasource.pyi
new file mode 100644
index 00000000..cc5a8485
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/datasource.pyi
@@ -0,0 +1,29 @@
+import sys
+from pathlib import Path
+from typing import IO, Any
+
+import numpy as np
+
+if sys.version_info >= (3, 11):
+    from typing import assert_type
+else:
+    from typing_extensions import assert_type
+
+path1: Path
+path2: str
+
+d1 = np.lib.npyio.DataSource(path1)
+d2 = np.lib.npyio.DataSource(path2)
+d3 = np.lib.npyio.DataSource(None)
+
+assert_type(d1.abspath("..."), str)
+assert_type(d2.abspath("..."), str)
+assert_type(d3.abspath("..."), str)
+
+assert_type(d1.exists("..."), bool)
+assert_type(d2.exists("..."), bool)
+assert_type(d3.exists("..."), bool)
+
+assert_type(d1.open("...", "r"), IO[Any])
+assert_type(d2.open("...", encoding="utf8"), IO[Any])
+assert_type(d3.open("...", newline="/n"), IO[Any])
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/dtype.pyi b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/dtype.pyi
new file mode 100644
index 00000000..10f6ccd0
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/dtype.pyi
@@ -0,0 +1,85 @@
+import sys
+import ctypes as ct
+from typing import Any
+
+import numpy as np
+
+if sys.version_info >= (3, 11):
+    from typing import assert_type
+else:
+    from typing_extensions import assert_type
+
+dtype_U: np.dtype[np.str_]
+dtype_V: np.dtype[np.void]
+dtype_i8: np.dtype[np.int64]
+
+assert_type(np.dtype(np.float64), np.dtype[np.float64])
+assert_type(np.dtype(np.float64, metadata={"test": "test"}), np.dtype[np.float64])
+assert_type(np.dtype(np.int64), np.dtype[np.int64])
+
+# String aliases
+assert_type(np.dtype("float64"), np.dtype[np.float64])
+assert_type(np.dtype("float32"), np.dtype[np.float32])
+assert_type(np.dtype("int64"), np.dtype[np.int64])
+assert_type(np.dtype("int32"), np.dtype[np.int32])
+assert_type(np.dtype("bool"), np.dtype[np.bool])
+assert_type(np.dtype("bytes"), np.dtype[np.bytes_])
+assert_type(np.dtype("str"), np.dtype[np.str_])
+
+# Python types
+assert_type(np.dtype(complex), np.dtype[np.cdouble])
+assert_type(np.dtype(float), np.dtype[np.double])
+assert_type(np.dtype(int), np.dtype[np.int_])
+assert_type(np.dtype(bool), np.dtype[np.bool])
+assert_type(np.dtype(str), np.dtype[np.str_])
+assert_type(np.dtype(bytes), np.dtype[np.bytes_])
+assert_type(np.dtype(object), np.dtype[np.object_])
+
+# ctypes
+assert_type(np.dtype(ct.c_double), np.dtype[np.double])
+assert_type(np.dtype(ct.c_longlong), np.dtype[np.longlong])
+assert_type(np.dtype(ct.c_uint32), np.dtype[np.uint32])
+assert_type(np.dtype(ct.c_bool), np.dtype[np.bool])
+assert_type(np.dtype(ct.c_char), np.dtype[np.bytes_])
+assert_type(np.dtype(ct.py_object), np.dtype[np.object_])
+
+# Special case for None
+assert_type(np.dtype(None), np.dtype[np.double])
+
+# Dtypes of dtypes
+assert_type(np.dtype(np.dtype(np.float64)), np.dtype[np.float64])
+
+# Parameterized dtypes
+assert_type(np.dtype("S8"), np.dtype[Any])
+
+# Void
+assert_type(np.dtype(("U", 10)), np.dtype[np.void])
+
+# Methods and attributes
+assert_type(dtype_U.base, np.dtype[Any])
+assert_type(dtype_U.subdtype, None | tuple[np.dtype[Any], tuple[int, ...]])
+assert_type(dtype_U.newbyteorder(), np.dtype[np.str_])
+assert_type(dtype_U.type, type[np.str_])
+assert_type(dtype_U.name, str)
+assert_type(dtype_U.names, None | tuple[str, ...])
+
+assert_type(dtype_U * 0, np.dtype[np.str_])
+assert_type(dtype_U * 1, np.dtype[np.str_])
+assert_type(dtype_U * 2, np.dtype[np.str_])
+
+assert_type(dtype_i8 * 0, np.dtype[np.void])
+assert_type(dtype_i8 * 1, np.dtype[np.int64])
+assert_type(dtype_i8 * 2, np.dtype[np.void])
+
+assert_type(0 * dtype_U, np.dtype[np.str_])
+assert_type(1 * dtype_U, np.dtype[np.str_])
+assert_type(2 * dtype_U, np.dtype[np.str_])
+
+assert_type(0 * dtype_i8, np.dtype[Any])
+assert_type(1 * dtype_i8, np.dtype[Any])
+assert_type(2 * dtype_i8, np.dtype[Any])
+
+assert_type(dtype_V["f0"], np.dtype[Any])
+assert_type(dtype_V[0], np.dtype[Any])
+assert_type(dtype_V[["f0", "f1"]], np.dtype[np.void])
+assert_type(dtype_V[["f0"]], np.dtype[np.void])
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/einsumfunc.pyi b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/einsumfunc.pyi
new file mode 100644
index 00000000..645aaad3
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/einsumfunc.pyi
@@ -0,0 +1,45 @@
+import sys
+from typing import Any
+
+import numpy as np
+import numpy.typing as npt
+
+if sys.version_info >= (3, 11):
+    from typing import assert_type
+else:
+    from typing_extensions import assert_type
+
+AR_LIKE_b: list[bool]
+AR_LIKE_u: list[np.uint32]
+AR_LIKE_i: list[int]
+AR_LIKE_f: list[float]
+AR_LIKE_c: list[complex]
+AR_LIKE_U: list[str]
+AR_o: npt.NDArray[np.object_]
+
+OUT_f: npt.NDArray[np.float64]
+
+assert_type(np.einsum("i,i->i", AR_LIKE_b, AR_LIKE_b), Any)
+assert_type(np.einsum("i,i->i", AR_o, AR_o), Any)
+assert_type(np.einsum("i,i->i", AR_LIKE_u, AR_LIKE_u), Any)
+assert_type(np.einsum("i,i->i", AR_LIKE_i, AR_LIKE_i), Any)
+assert_type(np.einsum("i,i->i", AR_LIKE_f, AR_LIKE_f), Any)
+assert_type(np.einsum("i,i->i", AR_LIKE_c, AR_LIKE_c), Any)
+assert_type(np.einsum("i,i->i", AR_LIKE_b, AR_LIKE_i), Any)
+assert_type(np.einsum("i,i,i,i->i", AR_LIKE_b, AR_LIKE_u, AR_LIKE_i, AR_LIKE_c), Any)
+
+assert_type(np.einsum("i,i->i", AR_LIKE_c, AR_LIKE_c, out=OUT_f), npt.NDArray[np.float64])
+assert_type(np.einsum("i,i->i", AR_LIKE_U, AR_LIKE_U, dtype=bool, casting="unsafe", out=OUT_f), npt.NDArray[np.float64])
+assert_type(np.einsum("i,i->i", AR_LIKE_f, AR_LIKE_f, dtype="c16"), Any)
+assert_type(np.einsum("i,i->i", AR_LIKE_U, AR_LIKE_U, dtype=bool, casting="unsafe"), Any)
+
+assert_type(np.einsum_path("i,i->i", AR_LIKE_b, AR_LIKE_b), tuple[list[Any], str])
+assert_type(np.einsum_path("i,i->i", AR_LIKE_u, AR_LIKE_u), tuple[list[Any], str])
+assert_type(np.einsum_path("i,i->i", AR_LIKE_i, AR_LIKE_i), tuple[list[Any], str])
+assert_type(np.einsum_path("i,i->i", AR_LIKE_f, AR_LIKE_f), tuple[list[Any], str])
+assert_type(np.einsum_path("i,i->i", AR_LIKE_c, AR_LIKE_c), tuple[list[Any], str])
+assert_type(np.einsum_path("i,i->i", AR_LIKE_b, AR_LIKE_i), tuple[list[Any], str])
+assert_type(np.einsum_path("i,i,i,i->i", AR_LIKE_b, AR_LIKE_u, AR_LIKE_i, AR_LIKE_c), tuple[list[Any], str])
+
+assert_type(np.einsum([[1, 1], [1, 1]], AR_LIKE_i, AR_LIKE_i), Any)
+assert_type(np.einsum_path([[1, 1], [1, 1]], AR_LIKE_i, AR_LIKE_i), tuple[list[Any], str])
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/emath.pyi b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/emath.pyi
new file mode 100644
index 00000000..d1027bf4
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/emath.pyi
@@ -0,0 +1,60 @@
+import sys
+from typing import Any
+
+import numpy as np
+import numpy.typing as npt
+
+if sys.version_info >= (3, 11):
+    from typing import assert_type
+else:
+    from typing_extensions import assert_type
+
+AR_f8: npt.NDArray[np.float64]
+AR_c16: npt.NDArray[np.complex128]
+f8: np.float64
+c16: np.complex128
+
+assert_type(np.emath.sqrt(f8), Any)
+assert_type(np.emath.sqrt(AR_f8), npt.NDArray[Any])
+assert_type(np.emath.sqrt(c16), np.complexfloating[Any, Any])
+assert_type(np.emath.sqrt(AR_c16), npt.NDArray[np.complexfloating[Any, Any]])
+
+assert_type(np.emath.log(f8), Any)
+assert_type(np.emath.log(AR_f8), npt.NDArray[Any])
+assert_type(np.emath.log(c16), np.complexfloating[Any, Any])
+assert_type(np.emath.log(AR_c16), npt.NDArray[np.complexfloating[Any, Any]])
+
+assert_type(np.emath.log10(f8), Any)
+assert_type(np.emath.log10(AR_f8), npt.NDArray[Any])
+assert_type(np.emath.log10(c16), np.complexfloating[Any, Any])
+assert_type(np.emath.log10(AR_c16), npt.NDArray[np.complexfloating[Any, Any]])
+
+assert_type(np.emath.log2(f8), Any)
+assert_type(np.emath.log2(AR_f8), npt.NDArray[Any])
+assert_type(np.emath.log2(c16), np.complexfloating[Any, Any])
+assert_type(np.emath.log2(AR_c16), npt.NDArray[np.complexfloating[Any, Any]])
+
+assert_type(np.emath.logn(f8, 2), Any)
+assert_type(np.emath.logn(AR_f8, 4), npt.NDArray[Any])
+assert_type(np.emath.logn(f8, 1j), np.complexfloating[Any, Any])
+assert_type(np.emath.logn(AR_c16, 1.5), npt.NDArray[np.complexfloating[Any, Any]])
+
+assert_type(np.emath.power(f8, 2), Any)
+assert_type(np.emath.power(AR_f8, 4), npt.NDArray[Any])
+assert_type(np.emath.power(f8, 2j), np.complexfloating[Any, Any])
+assert_type(np.emath.power(AR_c16, 1.5), npt.NDArray[np.complexfloating[Any, Any]])
+
+assert_type(np.emath.arccos(f8), Any)
+assert_type(np.emath.arccos(AR_f8), npt.NDArray[Any])
+assert_type(np.emath.arccos(c16), np.complexfloating[Any, Any])
+assert_type(np.emath.arccos(AR_c16), npt.NDArray[np.complexfloating[Any, Any]])
+
+assert_type(np.emath.arcsin(f8), Any)
+assert_type(np.emath.arcsin(AR_f8), npt.NDArray[Any])
+assert_type(np.emath.arcsin(c16), np.complexfloating[Any, Any])
+assert_type(np.emath.arcsin(AR_c16), npt.NDArray[np.complexfloating[Any, Any]])
+
+assert_type(np.emath.arctanh(f8), Any)
+assert_type(np.emath.arctanh(AR_f8), npt.NDArray[Any])
+assert_type(np.emath.arctanh(c16), np.complexfloating[Any, Any])
+assert_type(np.emath.arctanh(AR_c16), npt.NDArray[np.complexfloating[Any, Any]])
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/false_positives.pyi b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/false_positives.pyi
new file mode 100644
index 00000000..7a2e0162
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/false_positives.pyi
@@ -0,0 +1,18 @@
+import sys
+from typing import Any
+
+import numpy as np
+import numpy.typing as npt
+
+if sys.version_info >= (3, 11):
+    from typing import assert_type
+else:
+    from typing_extensions import assert_type
+
+AR_Any: npt.NDArray[Any]
+
+# Mypy bug where overload ambiguity is ignored for `Any`-parametrized types;
+# xref numpy/numpy#20099 and python/mypy#11347
+#
+# The expected output would be something akin to `npt.NDArray[Any]`
+assert_type(AR_Any + 2, npt.NDArray[np.signedinteger[Any]])
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/fft.pyi b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/fft.pyi
new file mode 100644
index 00000000..d6e9ba75
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/fft.pyi
@@ -0,0 +1,43 @@
+import sys
+from typing import Any
+
+import numpy as np
+import numpy.typing as npt
+
+if sys.version_info >= (3, 11):
+    from typing import assert_type
+else:
+    from typing_extensions import assert_type
+
+AR_f8: npt.NDArray[np.float64]
+AR_c16: npt.NDArray[np.complex128]
+AR_LIKE_f8: list[float]
+
+assert_type(np.fft.fftshift(AR_f8), npt.NDArray[np.float64])
+assert_type(np.fft.fftshift(AR_LIKE_f8, axes=0), npt.NDArray[Any])
+
+assert_type(np.fft.ifftshift(AR_f8), npt.NDArray[np.float64])
+assert_type(np.fft.ifftshift(AR_LIKE_f8, axes=0), npt.NDArray[Any])
+
+assert_type(np.fft.fftfreq(5, AR_f8), npt.NDArray[np.floating[Any]])
+assert_type(np.fft.fftfreq(np.int64(), AR_c16), npt.NDArray[np.complexfloating[Any, Any]])
+
+assert_type(np.fft.fftfreq(5, AR_f8), npt.NDArray[np.floating[Any]])
+assert_type(np.fft.fftfreq(np.int64(), AR_c16), npt.NDArray[np.complexfloating[Any, Any]])
+
+assert_type(np.fft.fft(AR_f8), npt.NDArray[np.complex128])
+assert_type(np.fft.ifft(AR_f8, axis=1), npt.NDArray[np.complex128])
+assert_type(np.fft.rfft(AR_f8, n=None), npt.NDArray[np.complex128])
+assert_type(np.fft.irfft(AR_f8, norm="ortho"), npt.NDArray[np.float64])
+assert_type(np.fft.hfft(AR_f8, n=2), npt.NDArray[np.float64])
+assert_type(np.fft.ihfft(AR_f8), npt.NDArray[np.complex128])
+
+assert_type(np.fft.fftn(AR_f8), npt.NDArray[np.complex128])
+assert_type(np.fft.ifftn(AR_f8), npt.NDArray[np.complex128])
+assert_type(np.fft.rfftn(AR_f8), npt.NDArray[np.complex128])
+assert_type(np.fft.irfftn(AR_f8), npt.NDArray[np.float64])
+
+assert_type(np.fft.rfft2(AR_f8), npt.NDArray[np.complex128])
+assert_type(np.fft.ifft2(AR_f8), npt.NDArray[np.complex128])
+assert_type(np.fft.fft2(AR_f8), npt.NDArray[np.complex128])
+assert_type(np.fft.irfft2(AR_f8), npt.NDArray[np.float64])
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/flatiter.pyi b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/flatiter.pyi
new file mode 100644
index 00000000..efbe75ce
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/flatiter.pyi
@@ -0,0 +1,53 @@
+import sys
+from typing import Any, Literal, TypeAlias
+
+import numpy as np
+import numpy.typing as npt
+
+if sys.version_info >= (3, 11):
+    from typing import assert_type
+else:
+    from typing_extensions import assert_type
+
+a: np.flatiter[npt.NDArray[np.str_]]
+a_1d: np.flatiter[np.ndarray[tuple[int], np.dtype[np.bytes_]]]
+
+Size: TypeAlias = Literal[42]
+a_1d_fixed: np.flatiter[np.ndarray[tuple[Size], np.dtype[np.object_]]]
+
+assert_type(a.base, npt.NDArray[np.str_])
+assert_type(a.copy(), npt.NDArray[np.str_])
+assert_type(a.coords, tuple[int, ...])
+assert_type(a.index, int)
+assert_type(iter(a), np.flatiter[npt.NDArray[np.str_]])
+assert_type(next(a), np.str_)
+assert_type(a[0], np.str_)
+assert_type(a[[0, 1, 2]], npt.NDArray[np.str_])
+assert_type(a[...], npt.NDArray[np.str_])
+assert_type(a[:], npt.NDArray[np.str_])
+assert_type(a[(...,)], npt.NDArray[np.str_])
+assert_type(a[(0,)], np.str_)
+
+assert_type(a.__array__(), npt.NDArray[np.str_])
+assert_type(a.__array__(np.dtype(np.float64)), npt.NDArray[np.float64])
+assert_type(
+    a_1d.__array__(),
+    np.ndarray[tuple[int], np.dtype[np.bytes_]],
+)
+assert_type(
+    a_1d.__array__(np.dtype(np.float64)),
+    np.ndarray[tuple[int], np.dtype[np.float64]],
+)
+assert_type(
+    a_1d_fixed.__array__(),
+    np.ndarray[tuple[Size], np.dtype[np.object_]],
+)
+assert_type(
+    a_1d_fixed.__array__(np.dtype(np.float64)),
+    np.ndarray[tuple[Size], np.dtype[np.float64]],
+)
+
+a[0] = "a"
+a[:5] = "a"
+a[...] = "a"
+a[(...,)] = "a"
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/fromnumeric.pyi b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/fromnumeric.pyi
new file mode 100644
index 00000000..94b3f5e5
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/fromnumeric.pyi
@@ -0,0 +1,325 @@
+"""Tests for :mod:`_core.fromnumeric`."""
+
+import sys
+from typing import Any
+
+import numpy as np
+import numpy.typing as npt
+
+if sys.version_info >= (3, 11):
+    from typing import assert_type
+else:
+    from typing_extensions import assert_type
+
+class NDArraySubclass(npt.NDArray[np.complex128]):
+    ...
+
+AR_b: npt.NDArray[np.bool]
+AR_f4: npt.NDArray[np.float32]
+AR_c16: npt.NDArray[np.complex128]
+AR_u8: npt.NDArray[np.uint64]
+AR_i8: npt.NDArray[np.int64]
+AR_O: npt.NDArray[np.object_]
+AR_subclass: NDArraySubclass
+
+b: np.bool
+f4: np.float32
+i8: np.int64
+f: float
+
+assert_type(np.take(b, 0), np.bool)
+assert_type(np.take(f4, 0), np.float32)
+assert_type(np.take(f, 0), Any)
+assert_type(np.take(AR_b, 0), np.bool)
+assert_type(np.take(AR_f4, 0), np.float32)
+assert_type(np.take(AR_b, [0]), npt.NDArray[np.bool])
+assert_type(np.take(AR_f4, [0]), npt.NDArray[np.float32])
+assert_type(np.take([1], [0]), npt.NDArray[Any])
+assert_type(np.take(AR_f4, [0], out=AR_subclass), NDArraySubclass)
+
+assert_type(np.reshape(b, 1), npt.NDArray[np.bool])
+assert_type(np.reshape(f4, 1), npt.NDArray[np.float32])
+assert_type(np.reshape(f, 1), npt.NDArray[Any])
+assert_type(np.reshape(AR_b, 1), npt.NDArray[np.bool])
+assert_type(np.reshape(AR_f4, 1), npt.NDArray[np.float32])
+
+assert_type(np.choose(1, [True, True]), Any)
+assert_type(np.choose([1], [True, True]), npt.NDArray[Any])
+assert_type(np.choose([1], AR_b), npt.NDArray[np.bool])
+assert_type(np.choose([1], AR_b, out=AR_f4), npt.NDArray[np.float32])
+
+assert_type(np.repeat(b, 1), npt.NDArray[np.bool])
+assert_type(np.repeat(f4, 1), npt.NDArray[np.float32])
+assert_type(np.repeat(f, 1), npt.NDArray[Any])
+assert_type(np.repeat(AR_b, 1), npt.NDArray[np.bool])
+assert_type(np.repeat(AR_f4, 1), npt.NDArray[np.float32])
+
+# TODO: array_bdd tests for np.put()
+
+assert_type(np.swapaxes([[0, 1]], 0, 0), npt.NDArray[Any])
+assert_type(np.swapaxes(AR_b, 0, 0), npt.NDArray[np.bool])
+assert_type(np.swapaxes(AR_f4, 0, 0), npt.NDArray[np.float32])
+
+assert_type(np.transpose(b), npt.NDArray[np.bool])
+assert_type(np.transpose(f4), npt.NDArray[np.float32])
+assert_type(np.transpose(f), npt.NDArray[Any])
+assert_type(np.transpose(AR_b), npt.NDArray[np.bool])
+assert_type(np.transpose(AR_f4), npt.NDArray[np.float32])
+
+assert_type(np.partition(b, 0, axis=None), npt.NDArray[np.bool])
+assert_type(np.partition(f4, 0, axis=None), npt.NDArray[np.float32])
+assert_type(np.partition(f, 0, axis=None), npt.NDArray[Any])
+assert_type(np.partition(AR_b, 0), npt.NDArray[np.bool])
+assert_type(np.partition(AR_f4, 0), npt.NDArray[np.float32])
+
+assert_type(np.argpartition(b, 0), npt.NDArray[np.intp])
+assert_type(np.argpartition(f4, 0), npt.NDArray[np.intp])
+assert_type(np.argpartition(f, 0), npt.NDArray[np.intp])
+assert_type(np.argpartition(AR_b, 0), npt.NDArray[np.intp])
+assert_type(np.argpartition(AR_f4, 0), npt.NDArray[np.intp])
+
+assert_type(np.sort([2, 1], 0), npt.NDArray[Any])
+assert_type(np.sort(AR_b, 0), npt.NDArray[np.bool])
+assert_type(np.sort(AR_f4, 0), npt.NDArray[np.float32])
+
+assert_type(np.argsort(AR_b, 0), npt.NDArray[np.intp])
+assert_type(np.argsort(AR_f4, 0), npt.NDArray[np.intp])
+
+assert_type(np.argmax(AR_b), np.intp)
+assert_type(np.argmax(AR_f4), np.intp)
+assert_type(np.argmax(AR_b, axis=0), Any)
+assert_type(np.argmax(AR_f4, axis=0), Any)
+assert_type(np.argmax(AR_f4, out=AR_subclass), NDArraySubclass)
+
+assert_type(np.argmin(AR_b), np.intp)
+assert_type(np.argmin(AR_f4), np.intp)
+assert_type(np.argmin(AR_b, axis=0), Any)
+assert_type(np.argmin(AR_f4, axis=0), Any)
+assert_type(np.argmin(AR_f4, out=AR_subclass), NDArraySubclass)
+
+assert_type(np.searchsorted(AR_b[0], 0), np.intp)
+assert_type(np.searchsorted(AR_f4[0], 0), np.intp)
+assert_type(np.searchsorted(AR_b[0], [0]), npt.NDArray[np.intp])
+assert_type(np.searchsorted(AR_f4[0], [0]), npt.NDArray[np.intp])
+
+assert_type(np.resize(b, (5, 5)), npt.NDArray[np.bool])
+assert_type(np.resize(f4, (5, 5)), npt.NDArray[np.float32])
+assert_type(np.resize(f, (5, 5)), npt.NDArray[Any])
+assert_type(np.resize(AR_b, (5, 5)), npt.NDArray[np.bool])
+assert_type(np.resize(AR_f4, (5, 5)), npt.NDArray[np.float32])
+
+assert_type(np.squeeze(b), np.bool)
+assert_type(np.squeeze(f4), np.float32)
+assert_type(np.squeeze(f), npt.NDArray[Any])
+assert_type(np.squeeze(AR_b), npt.NDArray[np.bool])
+assert_type(np.squeeze(AR_f4), npt.NDArray[np.float32])
+
+assert_type(np.diagonal(AR_b), npt.NDArray[np.bool])
+assert_type(np.diagonal(AR_f4), npt.NDArray[np.float32])
+
+assert_type(np.trace(AR_b), Any)
+assert_type(np.trace(AR_f4), Any)
+assert_type(np.trace(AR_f4, out=AR_subclass), NDArraySubclass)
+
+assert_type(np.ravel(b), npt.NDArray[np.bool])
+assert_type(np.ravel(f4), npt.NDArray[np.float32])
+assert_type(np.ravel(f), npt.NDArray[Any])
+assert_type(np.ravel(AR_b), npt.NDArray[np.bool])
+assert_type(np.ravel(AR_f4), npt.NDArray[np.float32])
+
+assert_type(np.nonzero(b), tuple[npt.NDArray[np.intp], ...])
+assert_type(np.nonzero(f4), tuple[npt.NDArray[np.intp], ...])
+assert_type(np.nonzero(f), tuple[npt.NDArray[np.intp], ...])
+assert_type(np.nonzero(AR_b), tuple[npt.NDArray[np.intp], ...])
+assert_type(np.nonzero(AR_f4), tuple[npt.NDArray[np.intp], ...])
+
+assert_type(np.shape(b), tuple[int, ...])
+assert_type(np.shape(f4), tuple[int, ...])
+assert_type(np.shape(f), tuple[int, ...])
+assert_type(np.shape(AR_b), tuple[int, ...])
+assert_type(np.shape(AR_f4), tuple[int, ...])
+
+assert_type(np.compress([True], b), npt.NDArray[np.bool])
+assert_type(np.compress([True], f4), npt.NDArray[np.float32])
+assert_type(np.compress([True], f), npt.NDArray[Any])
+assert_type(np.compress([True], AR_b), npt.NDArray[np.bool])
+assert_type(np.compress([True], AR_f4), npt.NDArray[np.float32])
+
+assert_type(np.clip(b, 0, 1.0), np.bool)
+assert_type(np.clip(f4, -1, 1), np.float32)
+assert_type(np.clip(f, 0, 1), Any)
+assert_type(np.clip(AR_b, 0, 1), npt.NDArray[np.bool])
+assert_type(np.clip(AR_f4, 0, 1), npt.NDArray[np.float32])
+assert_type(np.clip([0], 0, 1), npt.NDArray[Any])
+assert_type(np.clip(AR_b, 0, 1, out=AR_subclass), NDArraySubclass)
+
+assert_type(np.sum(b), np.bool)
+assert_type(np.sum(f4), np.float32)
+assert_type(np.sum(f), Any)
+assert_type(np.sum(AR_b), np.bool)
+assert_type(np.sum(AR_f4), np.float32)
+assert_type(np.sum(AR_b, axis=0), Any)
+assert_type(np.sum(AR_f4, axis=0), Any)
+assert_type(np.sum(AR_f4, out=AR_subclass), NDArraySubclass)
+
+assert_type(np.all(b), np.bool)
+assert_type(np.all(f4), np.bool)
+assert_type(np.all(f), np.bool)
+assert_type(np.all(AR_b), np.bool)
+assert_type(np.all(AR_f4), np.bool)
+assert_type(np.all(AR_b, axis=0), Any)
+assert_type(np.all(AR_f4, axis=0), Any)
+assert_type(np.all(AR_b, keepdims=True), Any)
+assert_type(np.all(AR_f4, keepdims=True), Any)
+assert_type(np.all(AR_f4, out=AR_subclass), NDArraySubclass)
+
+assert_type(np.any(b), np.bool)
+assert_type(np.any(f4), np.bool)
+assert_type(np.any(f), np.bool)
+assert_type(np.any(AR_b), np.bool)
+assert_type(np.any(AR_f4), np.bool)
+assert_type(np.any(AR_b, axis=0), Any)
+assert_type(np.any(AR_f4, axis=0), Any)
+assert_type(np.any(AR_b, keepdims=True), Any)
+assert_type(np.any(AR_f4, keepdims=True), Any)
+assert_type(np.any(AR_f4, out=AR_subclass), NDArraySubclass)
+
+assert_type(np.cumsum(b), npt.NDArray[np.bool])
+assert_type(np.cumsum(f4), npt.NDArray[np.float32])
+assert_type(np.cumsum(f), npt.NDArray[Any])
+assert_type(np.cumsum(AR_b), npt.NDArray[np.bool])
+assert_type(np.cumsum(AR_f4), npt.NDArray[np.float32])
+assert_type(np.cumsum(f, dtype=float), npt.NDArray[Any])
+assert_type(np.cumsum(f, dtype=np.float64), npt.NDArray[np.float64])
+assert_type(np.cumsum(AR_f4, out=AR_subclass), NDArraySubclass)
+
+assert_type(np.cumulative_sum(b), npt.NDArray[np.bool])
+assert_type(np.cumulative_sum(f4), npt.NDArray[np.float32])
+assert_type(np.cumulative_sum(f), npt.NDArray[Any])
+assert_type(np.cumulative_sum(AR_b), npt.NDArray[np.bool])
+assert_type(np.cumulative_sum(AR_f4), npt.NDArray[np.float32])
+assert_type(np.cumulative_sum(f, dtype=float), npt.NDArray[Any])
+assert_type(np.cumulative_sum(f, dtype=np.float64), npt.NDArray[np.float64])
+assert_type(np.cumulative_sum(AR_f4, out=AR_subclass), NDArraySubclass)
+
+assert_type(np.ptp(b), np.bool)
+assert_type(np.ptp(f4), np.float32)
+assert_type(np.ptp(f), Any)
+assert_type(np.ptp(AR_b), np.bool)
+assert_type(np.ptp(AR_f4), np.float32)
+assert_type(np.ptp(AR_b, axis=0), Any)
+assert_type(np.ptp(AR_f4, axis=0), Any)
+assert_type(np.ptp(AR_b, keepdims=True), Any)
+assert_type(np.ptp(AR_f4, keepdims=True), Any)
+assert_type(np.ptp(AR_f4, out=AR_subclass), NDArraySubclass)
+
+assert_type(np.amax(b), np.bool)
+assert_type(np.amax(f4), np.float32)
+assert_type(np.amax(f), Any)
+assert_type(np.amax(AR_b), np.bool)
+assert_type(np.amax(AR_f4), np.float32)
+assert_type(np.amax(AR_b, axis=0), Any)
+assert_type(np.amax(AR_f4, axis=0), Any)
+assert_type(np.amax(AR_b, keepdims=True), Any)
+assert_type(np.amax(AR_f4, keepdims=True), Any)
+assert_type(np.amax(AR_f4, out=AR_subclass), NDArraySubclass)
+
+assert_type(np.amin(b), np.bool)
+assert_type(np.amin(f4), np.float32)
+assert_type(np.amin(f), Any)
+assert_type(np.amin(AR_b), np.bool)
+assert_type(np.amin(AR_f4), np.float32)
+assert_type(np.amin(AR_b, axis=0), Any)
+assert_type(np.amin(AR_f4, axis=0), Any)
+assert_type(np.amin(AR_b, keepdims=True), Any)
+assert_type(np.amin(AR_f4, keepdims=True), Any)
+assert_type(np.amin(AR_f4, out=AR_subclass), NDArraySubclass)
+
+assert_type(np.prod(AR_b), np.int_)
+assert_type(np.prod(AR_u8), np.uint64)
+assert_type(np.prod(AR_i8), np.int64)
+assert_type(np.prod(AR_f4), np.floating[Any])
+assert_type(np.prod(AR_c16), np.complexfloating[Any, Any])
+assert_type(np.prod(AR_O), Any)
+assert_type(np.prod(AR_f4, axis=0), Any)
+assert_type(np.prod(AR_f4, keepdims=True), Any)
+assert_type(np.prod(AR_f4, dtype=np.float64), np.float64)
+assert_type(np.prod(AR_f4, dtype=float), Any)
+assert_type(np.prod(AR_f4, out=AR_subclass), NDArraySubclass)
+
+assert_type(np.cumprod(AR_b), npt.NDArray[np.int_])
+assert_type(np.cumprod(AR_u8), npt.NDArray[np.uint64])
+assert_type(np.cumprod(AR_i8), npt.NDArray[np.int64])
+assert_type(np.cumprod(AR_f4), npt.NDArray[np.floating[Any]])
+assert_type(np.cumprod(AR_c16), npt.NDArray[np.complexfloating[Any, Any]])
+assert_type(np.cumprod(AR_O), npt.NDArray[np.object_])
+assert_type(np.cumprod(AR_f4, axis=0), npt.NDArray[np.floating[Any]])
+assert_type(np.cumprod(AR_f4, dtype=np.float64), npt.NDArray[np.float64])
+assert_type(np.cumprod(AR_f4, dtype=float), npt.NDArray[Any])
+assert_type(np.cumprod(AR_f4, out=AR_subclass), NDArraySubclass)
+
+assert_type(np.cumulative_prod(AR_b), npt.NDArray[np.int_])
+assert_type(np.cumulative_prod(AR_u8), npt.NDArray[np.uint64])
+assert_type(np.cumulative_prod(AR_i8), npt.NDArray[np.int64])
+assert_type(np.cumulative_prod(AR_f4), npt.NDArray[np.floating[Any]])
+assert_type(np.cumulative_prod(AR_c16), npt.NDArray[np.complexfloating[Any, Any]])
+assert_type(np.cumulative_prod(AR_O), npt.NDArray[np.object_])
+assert_type(np.cumulative_prod(AR_f4, axis=0), npt.NDArray[np.floating[Any]])
+assert_type(np.cumulative_prod(AR_f4, dtype=np.float64), npt.NDArray[np.float64])
+assert_type(np.cumulative_prod(AR_f4, dtype=float), npt.NDArray[Any])
+assert_type(np.cumulative_prod(AR_f4, out=AR_subclass), NDArraySubclass)
+
+assert_type(np.ndim(b), int)
+assert_type(np.ndim(f4), int)
+assert_type(np.ndim(f), int)
+assert_type(np.ndim(AR_b), int)
+assert_type(np.ndim(AR_f4), int)
+
+assert_type(np.size(b), int)
+assert_type(np.size(f4), int)
+assert_type(np.size(f), int)
+assert_type(np.size(AR_b), int)
+assert_type(np.size(AR_f4), int)
+
+assert_type(np.around(b), np.float16)
+assert_type(np.around(f), Any)
+assert_type(np.around(i8), np.int64)
+assert_type(np.around(f4), np.float32)
+assert_type(np.around(AR_b), npt.NDArray[np.float16])
+assert_type(np.around(AR_i8), npt.NDArray[np.int64])
+assert_type(np.around(AR_f4), npt.NDArray[np.float32])
+assert_type(np.around([1.5]), npt.NDArray[Any])
+assert_type(np.around(AR_f4, out=AR_subclass), NDArraySubclass)
+
+assert_type(np.mean(AR_b), np.floating[Any])
+assert_type(np.mean(AR_i8), np.floating[Any])
+assert_type(np.mean(AR_f4), np.floating[Any])
+assert_type(np.mean(AR_c16), np.complexfloating[Any, Any])
+assert_type(np.mean(AR_O), Any)
+assert_type(np.mean(AR_f4, axis=0), Any)
+assert_type(np.mean(AR_f4, keepdims=True), Any)
+assert_type(np.mean(AR_f4, dtype=float), Any)
+assert_type(np.mean(AR_f4, dtype=np.float64), np.float64)
+assert_type(np.mean(AR_f4, out=AR_subclass), NDArraySubclass)
+
+assert_type(np.std(AR_b), np.floating[Any])
+assert_type(np.std(AR_i8), np.floating[Any])
+assert_type(np.std(AR_f4), np.floating[Any])
+assert_type(np.std(AR_c16), np.floating[Any])
+assert_type(np.std(AR_O), Any)
+assert_type(np.std(AR_f4, axis=0), Any)
+assert_type(np.std(AR_f4, keepdims=True), Any)
+assert_type(np.std(AR_f4, dtype=float), Any)
+assert_type(np.std(AR_f4, dtype=np.float64), np.float64)
+assert_type(np.std(AR_f4, out=AR_subclass), NDArraySubclass)
+
+assert_type(np.var(AR_b), np.floating[Any])
+assert_type(np.var(AR_i8), np.floating[Any])
+assert_type(np.var(AR_f4), np.floating[Any])
+assert_type(np.var(AR_c16), np.floating[Any])
+assert_type(np.var(AR_O), Any)
+assert_type(np.var(AR_f4, axis=0), Any)
+assert_type(np.var(AR_f4, keepdims=True), Any)
+assert_type(np.var(AR_f4, dtype=float), Any)
+assert_type(np.var(AR_f4, dtype=np.float64), np.float64)
+assert_type(np.var(AR_f4, out=AR_subclass), NDArraySubclass)
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/getlimits.pyi b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/getlimits.pyi
new file mode 100644
index 00000000..57af90cc
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/getlimits.pyi
@@ -0,0 +1,56 @@
+import sys
+from typing import Any
+
+import numpy as np
+
+if sys.version_info >= (3, 11):
+    from typing import assert_type, LiteralString
+else:
+    from typing_extensions import assert_type, LiteralString
+
+f: float
+f8: np.float64
+c8: np.complex64
+
+i: int
+i8: np.int64
+u4: np.uint32
+
+finfo_f8: np.finfo[np.float64]
+iinfo_i8: np.iinfo[np.int64]
+
+assert_type(np.finfo(f), np.finfo[np.double])
+assert_type(np.finfo(f8), np.finfo[np.float64])
+assert_type(np.finfo(c8), np.finfo[np.float32])
+assert_type(np.finfo('f2'), np.finfo[np.floating[Any]])
+
+assert_type(finfo_f8.dtype, np.dtype[np.float64])
+assert_type(finfo_f8.bits, int)
+assert_type(finfo_f8.eps, np.float64)
+assert_type(finfo_f8.epsneg, np.float64)
+assert_type(finfo_f8.iexp, int)
+assert_type(finfo_f8.machep, int)
+assert_type(finfo_f8.max, np.float64)
+assert_type(finfo_f8.maxexp, int)
+assert_type(finfo_f8.min, np.float64)
+assert_type(finfo_f8.minexp, int)
+assert_type(finfo_f8.negep, int)
+assert_type(finfo_f8.nexp, int)
+assert_type(finfo_f8.nmant, int)
+assert_type(finfo_f8.precision, int)
+assert_type(finfo_f8.resolution, np.float64)
+assert_type(finfo_f8.tiny, np.float64)
+assert_type(finfo_f8.smallest_normal, np.float64)
+assert_type(finfo_f8.smallest_subnormal, np.float64)
+
+assert_type(np.iinfo(i), np.iinfo[np.int_])
+assert_type(np.iinfo(i8), np.iinfo[np.int64])
+assert_type(np.iinfo(u4), np.iinfo[np.uint32])
+assert_type(np.iinfo('i2'), np.iinfo[Any])
+
+assert_type(iinfo_i8.dtype, np.dtype[np.int64])
+assert_type(iinfo_i8.kind, LiteralString)
+assert_type(iinfo_i8.bits, int)
+assert_type(iinfo_i8.key, LiteralString)
+assert_type(iinfo_i8.min, int)
+assert_type(iinfo_i8.max, int)
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/histograms.pyi b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/histograms.pyi
new file mode 100644
index 00000000..67067eb7
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/histograms.pyi
@@ -0,0 +1,31 @@
+import sys
+from typing import Any
+
+import numpy as np
+import numpy.typing as npt
+
+if sys.version_info >= (3, 11):
+    from typing import assert_type
+else:
+    from typing_extensions import assert_type
+
+AR_i8: npt.NDArray[np.int64]
+AR_f8: npt.NDArray[np.float64]
+
+assert_type(np.histogram_bin_edges(AR_i8, bins="auto"), npt.NDArray[Any])
+assert_type(np.histogram_bin_edges(AR_i8, bins="rice", range=(0, 3)), npt.NDArray[Any])
+assert_type(np.histogram_bin_edges(AR_i8, bins="scott", weights=AR_f8), npt.NDArray[Any])
+
+assert_type(np.histogram(AR_i8, bins="auto"), tuple[npt.NDArray[Any], npt.NDArray[Any]])
+assert_type(np.histogram(AR_i8, bins="rice", range=(0, 3)), tuple[npt.NDArray[Any], npt.NDArray[Any]])
+assert_type(np.histogram(AR_i8, bins="scott", weights=AR_f8), tuple[npt.NDArray[Any], npt.NDArray[Any]])
+assert_type(np.histogram(AR_f8, bins=1, density=True), tuple[npt.NDArray[Any], npt.NDArray[Any]])
+
+assert_type(np.histogramdd(AR_i8, bins=[1]),
+            tuple[npt.NDArray[Any], tuple[npt.NDArray[Any], ...]])
+assert_type(np.histogramdd(AR_i8, range=[(0, 3)]),
+            tuple[npt.NDArray[Any], tuple[npt.NDArray[Any], ...]])
+assert_type(np.histogramdd(AR_i8, weights=AR_f8),
+            tuple[npt.NDArray[Any], tuple[npt.NDArray[Any], ...]])
+assert_type(np.histogramdd(AR_f8, density=True),
+            tuple[npt.NDArray[Any], tuple[npt.NDArray[Any], ...]])
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/index_tricks.pyi b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/index_tricks.pyi
new file mode 100644
index 00000000..ad8be765
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/index_tricks.pyi
@@ -0,0 +1,81 @@
+import sys
+from typing import Any, Literal
+
+import numpy as np
+import numpy.typing as npt
+
+if sys.version_info >= (3, 11):
+    from typing import assert_type
+else:
+    from typing_extensions import assert_type
+
+AR_LIKE_b: list[bool]
+AR_LIKE_i: list[int]
+AR_LIKE_f: list[float]
+AR_LIKE_U: list[str]
+AR_LIKE_O: list[object]
+
+AR_i8: npt.NDArray[np.int64]
+AR_O: npt.NDArray[np.object_]
+
+assert_type(np.ndenumerate(AR_i8), np.ndenumerate[np.int64])
+assert_type(np.ndenumerate(AR_LIKE_f), np.ndenumerate[np.float64])
+assert_type(np.ndenumerate(AR_LIKE_U), np.ndenumerate[np.str_])
+assert_type(np.ndenumerate(AR_LIKE_O), np.ndenumerate[np.object_])
+
+assert_type(np.ndenumerate(AR_i8).iter, np.flatiter[npt.NDArray[np.int64]])
+assert_type(np.ndenumerate(AR_LIKE_f).iter, np.flatiter[npt.NDArray[np.float64]])
+assert_type(np.ndenumerate(AR_LIKE_U).iter, np.flatiter[npt.NDArray[np.str_]])
+assert_type(np.ndenumerate(AR_LIKE_O).iter, np.flatiter[npt.NDArray[np.object_]])
+
+assert_type(next(np.ndenumerate(AR_i8)), tuple[tuple[int, ...], np.int64])
+assert_type(next(np.ndenumerate(AR_LIKE_f)), tuple[tuple[int, ...], np.float64])
+assert_type(next(np.ndenumerate(AR_LIKE_U)), tuple[tuple[int, ...], np.str_])
+# this fails due to an unknown mypy bug
+# assert_type(next(np.ndenumerate(AR_LIKE_O)), tuple[tuple[int, ...], Any])
+
+assert_type(iter(np.ndenumerate(AR_i8)), np.ndenumerate[np.int64])
+assert_type(iter(np.ndenumerate(AR_LIKE_f)), np.ndenumerate[np.float64])
+assert_type(iter(np.ndenumerate(AR_LIKE_U)), np.ndenumerate[np.str_])
+assert_type(iter(np.ndenumerate(AR_LIKE_O)), np.ndenumerate[np.object_])
+
+assert_type(np.ndindex(1, 2, 3), np.ndindex)
+assert_type(np.ndindex((1, 2, 3)), np.ndindex)
+assert_type(iter(np.ndindex(1, 2, 3)), np.ndindex)
+assert_type(next(np.ndindex(1, 2, 3)), tuple[int, ...])
+
+assert_type(np.unravel_index([22, 41, 37], (7, 6)), tuple[npt.NDArray[np.intp], ...])
+assert_type(np.unravel_index([31, 41, 13], (7, 6), order="F"), tuple[npt.NDArray[np.intp], ...])
+assert_type(np.unravel_index(1621, (6, 7, 8, 9)), tuple[np.intp, ...])
+
+assert_type(np.ravel_multi_index([[1]], (7, 6)), npt.NDArray[np.intp])
+assert_type(np.ravel_multi_index(AR_LIKE_i, (7, 6)), np.intp)
+assert_type(np.ravel_multi_index(AR_LIKE_i, (7, 6), order="F"), np.intp)
+assert_type(np.ravel_multi_index(AR_LIKE_i, (4, 6), mode="clip"), np.intp)
+assert_type(np.ravel_multi_index(AR_LIKE_i, (4, 4), mode=("clip", "wrap")), np.intp)
+assert_type(np.ravel_multi_index((3, 1, 4, 1), (6, 7, 8, 9)), np.intp)
+
+assert_type(np.mgrid[1:1:2], npt.NDArray[Any])
+assert_type(np.mgrid[1:1:2, None:10], npt.NDArray[Any])
+
+assert_type(np.ogrid[1:1:2], tuple[npt.NDArray[Any], ...])
+assert_type(np.ogrid[1:1:2, None:10], tuple[npt.NDArray[Any], ...])
+
+assert_type(np.index_exp[0:1], tuple[slice])
+assert_type(np.index_exp[0:1, None:3], tuple[slice, slice])
+assert_type(np.index_exp[0, 0:1, ..., [0, 1, 3]], tuple[Literal[0], slice, ellipsis, list[int]])
+
+assert_type(np.s_[0:1], slice)
+assert_type(np.s_[0:1, None:3], tuple[slice, slice])
+assert_type(np.s_[0, 0:1, ..., [0, 1, 3]], tuple[Literal[0], slice, ellipsis, list[int]])
+
+assert_type(np.ix_(AR_LIKE_b), tuple[npt.NDArray[np.bool], ...])
+assert_type(np.ix_(AR_LIKE_i, AR_LIKE_f), tuple[npt.NDArray[np.float64], ...])
+assert_type(np.ix_(AR_i8), tuple[npt.NDArray[np.int64], ...])
+
+assert_type(np.fill_diagonal(AR_i8, 5), None)
+
+assert_type(np.diag_indices(4), tuple[npt.NDArray[np.int_], ...])
+assert_type(np.diag_indices(2, 3), tuple[npt.NDArray[np.int_], ...])
+
+assert_type(np.diag_indices_from(AR_i8), tuple[npt.NDArray[np.int_], ...])
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/lib_function_base.pyi b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/lib_function_base.pyi
new file mode 100644
index 00000000..b630a130
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/lib_function_base.pyi
@@ -0,0 +1,193 @@
+import sys
+from fractions import Fraction
+from typing import Any
+from collections.abc import Callable
+
+import numpy as np
+import numpy.typing as npt
+
+if sys.version_info >= (3, 11):
+    from typing import assert_type
+else:
+    from typing_extensions import assert_type
+
+vectorized_func: np.vectorize
+
+f8: np.float64
+AR_LIKE_f8: list[float]
+AR_LIKE_c16: list[complex]
+AR_LIKE_O: list[Fraction]
+
+AR_i8: npt.NDArray[np.int64]
+AR_f8: npt.NDArray[np.float64]
+AR_c16: npt.NDArray[np.complex128]
+AR_m: npt.NDArray[np.timedelta64]
+AR_M: npt.NDArray[np.datetime64]
+AR_O: npt.NDArray[np.object_]
+AR_b: npt.NDArray[np.bool]
+AR_U: npt.NDArray[np.str_]
+CHAR_AR_U: np.char.chararray[Any, np.dtype[np.str_]]
+
+def func(*args: Any, **kwargs: Any) -> Any: ...
+
+assert_type(vectorized_func.pyfunc, Callable[..., Any])
+assert_type(vectorized_func.cache, bool)
+assert_type(vectorized_func.signature, None | str)
+assert_type(vectorized_func.otypes, None | str)
+assert_type(vectorized_func.excluded, set[int | str])
+assert_type(vectorized_func.__doc__, None | str)
+assert_type(vectorized_func([1]), Any)
+assert_type(np.vectorize(int), np.vectorize)
+assert_type(
+    np.vectorize(int, otypes="i", doc="doc", excluded=(), cache=True, signature=None),
+    np.vectorize,
+)
+
+assert_type(np.rot90(AR_f8, k=2), npt.NDArray[np.float64])
+assert_type(np.rot90(AR_LIKE_f8, axes=(0, 1)), npt.NDArray[Any])
+
+assert_type(np.flip(f8), np.float64)
+assert_type(np.flip(1.0), Any)
+assert_type(np.flip(AR_f8, axis=(0, 1)), npt.NDArray[np.float64])
+assert_type(np.flip(AR_LIKE_f8, axis=0), npt.NDArray[Any])
+
+assert_type(np.iterable(1), bool)
+assert_type(np.iterable([1]), bool)
+
+assert_type(np.average(AR_f8), np.floating[Any])
+assert_type(np.average(AR_f8, weights=AR_c16), np.complexfloating[Any, Any])
+assert_type(np.average(AR_O), Any)
+assert_type(np.average(AR_f8, returned=True), tuple[np.floating[Any], np.floating[Any]])
+assert_type(np.average(AR_f8, weights=AR_c16, returned=True), tuple[np.complexfloating[Any, Any], np.complexfloating[Any, Any]])
+assert_type(np.average(AR_O, returned=True), tuple[Any, Any])
+assert_type(np.average(AR_f8, axis=0), Any)
+assert_type(np.average(AR_f8, axis=0, returned=True), tuple[Any, Any])
+
+assert_type(np.asarray_chkfinite(AR_f8), npt.NDArray[np.float64])
+assert_type(np.asarray_chkfinite(AR_LIKE_f8), npt.NDArray[Any])
+assert_type(np.asarray_chkfinite(AR_f8, dtype=np.float64), npt.NDArray[np.float64])
+assert_type(np.asarray_chkfinite(AR_f8, dtype=float), npt.NDArray[Any])
+
+assert_type(np.piecewise(AR_f8, AR_b, [func]), npt.NDArray[np.float64])
+assert_type(np.piecewise(AR_LIKE_f8, AR_b, [func]), npt.NDArray[Any])
+
+assert_type(np.select([AR_f8], [AR_f8]), npt.NDArray[Any])
+
+assert_type(np.copy(AR_LIKE_f8), npt.NDArray[Any])
+assert_type(np.copy(AR_U), npt.NDArray[np.str_])
+assert_type(np.copy(CHAR_AR_U), np.ndarray[Any, Any])
+assert_type(np.copy(CHAR_AR_U, "K", subok=True), np.char.chararray[Any, np.dtype[np.str_]])
+assert_type(np.copy(CHAR_AR_U, subok=True), np.char.chararray[Any, np.dtype[np.str_]])
+
+assert_type(np.gradient(AR_f8, axis=None), Any)
+assert_type(np.gradient(AR_LIKE_f8, edge_order=2), Any)
+
+assert_type(np.diff("bob", n=0), str)
+assert_type(np.diff(AR_f8, axis=0), npt.NDArray[Any])
+assert_type(np.diff(AR_LIKE_f8, prepend=1.5), npt.NDArray[Any])
+
+assert_type(np.angle(f8), np.floating[Any])
+assert_type(np.angle(AR_f8), npt.NDArray[np.floating[Any]])
+assert_type(np.angle(AR_c16, deg=True), npt.NDArray[np.floating[Any]])
+assert_type(np.angle(AR_O), npt.NDArray[np.object_])
+
+assert_type(np.unwrap(AR_f8), npt.NDArray[np.floating[Any]])
+assert_type(np.unwrap(AR_O), npt.NDArray[np.object_])
+
+assert_type(np.sort_complex(AR_f8), npt.NDArray[np.complexfloating[Any, Any]])
+
+assert_type(np.trim_zeros(AR_f8), npt.NDArray[np.float64])
+assert_type(np.trim_zeros(AR_LIKE_f8), list[float])
+
+assert_type(np.extract(AR_i8, AR_f8), npt.NDArray[np.float64])
+assert_type(np.extract(AR_i8, AR_LIKE_f8), npt.NDArray[Any])
+
+assert_type(np.place(AR_f8, mask=AR_i8, vals=5.0), None)
+
+assert_type(np.cov(AR_f8, bias=True), npt.NDArray[np.floating[Any]])
+assert_type(np.cov(AR_f8, AR_c16, ddof=1), npt.NDArray[np.complexfloating[Any, Any]])
+assert_type(np.cov(AR_f8, aweights=AR_f8, dtype=np.float32), npt.NDArray[np.float32])
+assert_type(np.cov(AR_f8, fweights=AR_f8, dtype=float), npt.NDArray[Any])
+
+assert_type(np.corrcoef(AR_f8, rowvar=True), npt.NDArray[np.floating[Any]])
+assert_type(np.corrcoef(AR_f8, AR_c16), npt.NDArray[np.complexfloating[Any, Any]])
+assert_type(np.corrcoef(AR_f8, dtype=np.float32), npt.NDArray[np.float32])
+assert_type(np.corrcoef(AR_f8, dtype=float), npt.NDArray[Any])
+
+assert_type(np.blackman(5), npt.NDArray[np.floating[Any]])
+assert_type(np.bartlett(6), npt.NDArray[np.floating[Any]])
+assert_type(np.hanning(4.5), npt.NDArray[np.floating[Any]])
+assert_type(np.hamming(0), npt.NDArray[np.floating[Any]])
+assert_type(np.i0(AR_i8), npt.NDArray[np.floating[Any]])
+assert_type(np.kaiser(4, 5.9), npt.NDArray[np.floating[Any]])
+
+assert_type(np.sinc(1.0), np.floating[Any])
+assert_type(np.sinc(1j), np.complexfloating[Any, Any])
+assert_type(np.sinc(AR_f8), npt.NDArray[np.floating[Any]])
+assert_type(np.sinc(AR_c16), npt.NDArray[np.complexfloating[Any, Any]])
+
+assert_type(np.median(AR_f8, keepdims=False), np.floating[Any])
+assert_type(np.median(AR_c16, overwrite_input=True), np.complexfloating[Any, Any])
+assert_type(np.median(AR_m), np.timedelta64)
+assert_type(np.median(AR_O), Any)
+assert_type(np.median(AR_f8, keepdims=True), Any)
+assert_type(np.median(AR_c16, axis=0), Any)
+assert_type(np.median(AR_LIKE_f8, out=AR_c16), npt.NDArray[np.complex128])
+
+assert_type(np.percentile(AR_f8, 50), np.floating[Any])
+assert_type(np.percentile(AR_c16, 50), np.complexfloating[Any, Any])
+assert_type(np.percentile(AR_m, 50), np.timedelta64)
+assert_type(np.percentile(AR_M, 50, overwrite_input=True), np.datetime64)
+assert_type(np.percentile(AR_O, 50), Any)
+assert_type(np.percentile(AR_f8, [50]), npt.NDArray[np.floating[Any]])
+assert_type(np.percentile(AR_c16, [50]), npt.NDArray[np.complexfloating[Any, Any]])
+assert_type(np.percentile(AR_m, [50]), npt.NDArray[np.timedelta64])
+assert_type(np.percentile(AR_M, [50], method="nearest"), npt.NDArray[np.datetime64])
+assert_type(np.percentile(AR_O, [50]), npt.NDArray[np.object_])
+assert_type(np.percentile(AR_f8, [50], keepdims=True), Any)
+assert_type(np.percentile(AR_f8, [50], axis=[1]), Any)
+assert_type(np.percentile(AR_f8, [50], out=AR_c16), npt.NDArray[np.complex128])
+
+assert_type(np.quantile(AR_f8, 0.5), np.floating[Any])
+assert_type(np.quantile(AR_c16, 0.5), np.complexfloating[Any, Any])
+assert_type(np.quantile(AR_m, 0.5), np.timedelta64)
+assert_type(np.quantile(AR_M, 0.5, overwrite_input=True), np.datetime64)
+assert_type(np.quantile(AR_O, 0.5), Any)
+assert_type(np.quantile(AR_f8, [0.5]), npt.NDArray[np.floating[Any]])
+assert_type(np.quantile(AR_c16, [0.5]), npt.NDArray[np.complexfloating[Any, Any]])
+assert_type(np.quantile(AR_m, [0.5]), npt.NDArray[np.timedelta64])
+assert_type(np.quantile(AR_M, [0.5], method="nearest"), npt.NDArray[np.datetime64])
+assert_type(np.quantile(AR_O, [0.5]), npt.NDArray[np.object_])
+assert_type(np.quantile(AR_f8, [0.5], keepdims=True), Any)
+assert_type(np.quantile(AR_f8, [0.5], axis=[1]), Any)
+assert_type(np.quantile(AR_f8, [0.5], out=AR_c16), npt.NDArray[np.complex128])
+
+assert_type(np.trapezoid(AR_LIKE_f8), np.float64)
+assert_type(np.trapezoid(AR_LIKE_f8, AR_LIKE_f8), np.float64)
+assert_type(np.trapezoid(AR_LIKE_c16), np.complex128)
+assert_type(np.trapezoid(AR_LIKE_c16, AR_LIKE_f8), np.complex128)
+assert_type(np.trapezoid(AR_LIKE_f8, AR_LIKE_c16), np.complex128)
+assert_type(np.trapezoid(AR_LIKE_O), float)
+assert_type(np.trapezoid(AR_LIKE_O, AR_LIKE_f8), float)
+assert_type(np.trapezoid(AR_f8), np.float64 | npt.NDArray[np.float64])
+assert_type(np.trapezoid(AR_f8, AR_f8), np.float64 | npt.NDArray[np.float64])
+assert_type(np.trapezoid(AR_c16), np.complex128 | npt.NDArray[np.complex128])
+assert_type(np.trapezoid(AR_c16, AR_c16), np.complex128 | npt.NDArray[np.complex128])
+assert_type(np.trapezoid(AR_m), np.timedelta64 | npt.NDArray[np.timedelta64])
+assert_type(np.trapezoid(AR_O), float | npt.NDArray[np.object_])
+assert_type(np.trapezoid(AR_O, AR_LIKE_f8), float | npt.NDArray[np.object_])
+
+assert_type(np.meshgrid(AR_f8, AR_i8, copy=False), tuple[npt.NDArray[Any], ...])
+assert_type(np.meshgrid(AR_f8, AR_i8, AR_c16, indexing="ij"), tuple[npt.NDArray[Any], ...])
+
+assert_type(np.delete(AR_f8, np.s_[:5]), npt.NDArray[np.float64])
+assert_type(np.delete(AR_LIKE_f8, [0, 4, 9], axis=0), npt.NDArray[Any])
+
+assert_type(np.insert(AR_f8, np.s_[:5], 5), npt.NDArray[np.float64])
+assert_type(np.insert(AR_LIKE_f8, [0, 4, 9], [0.5, 9.2, 7], axis=0), npt.NDArray[Any])
+
+assert_type(np.append(AR_f8, 5), npt.NDArray[Any])
+assert_type(np.append(AR_LIKE_f8, 1j, axis=0), npt.NDArray[Any])
+
+assert_type(np.digitize(4.5, [1]), np.intp)
+assert_type(np.digitize(AR_f8, [1, 2, 3]), npt.NDArray[np.intp])
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/lib_polynomial.pyi b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/lib_polynomial.pyi
new file mode 100644
index 00000000..885b40ee
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/lib_polynomial.pyi
@@ -0,0 +1,150 @@
+import sys
+from typing import Any, NoReturn
+from collections.abc import Iterator
+
+import numpy as np
+import numpy.typing as npt
+
+if sys.version_info >= (3, 11):
+    from typing import assert_type
+else:
+    from typing_extensions import assert_type
+
+AR_b: npt.NDArray[np.bool]
+AR_u4: npt.NDArray[np.uint32]
+AR_i8: npt.NDArray[np.int64]
+AR_f8: npt.NDArray[np.float64]
+AR_c16: npt.NDArray[np.complex128]
+AR_O: npt.NDArray[np.object_]
+
+poly_obj: np.poly1d
+
+assert_type(poly_obj.variable, str)
+assert_type(poly_obj.order, int)
+assert_type(poly_obj.o, int)
+assert_type(poly_obj.roots, npt.NDArray[Any])
+assert_type(poly_obj.r, npt.NDArray[Any])
+assert_type(poly_obj.coeffs, npt.NDArray[Any])
+assert_type(poly_obj.c, npt.NDArray[Any])
+assert_type(poly_obj.coef, npt.NDArray[Any])
+assert_type(poly_obj.coefficients, npt.NDArray[Any])
+assert_type(poly_obj.__hash__, None)
+
+assert_type(poly_obj(1), Any)
+assert_type(poly_obj([1]), npt.NDArray[Any])
+assert_type(poly_obj(poly_obj), np.poly1d)
+
+assert_type(len(poly_obj), int)
+assert_type(-poly_obj, np.poly1d)
+assert_type(+poly_obj, np.poly1d)
+
+assert_type(poly_obj * 5, np.poly1d)
+assert_type(5 * poly_obj, np.poly1d)
+assert_type(poly_obj + 5, np.poly1d)
+assert_type(5 + poly_obj, np.poly1d)
+assert_type(poly_obj - 5, np.poly1d)
+assert_type(5 - poly_obj, np.poly1d)
+assert_type(poly_obj**1, np.poly1d)
+assert_type(poly_obj**1.0, np.poly1d)
+assert_type(poly_obj / 5, np.poly1d)
+assert_type(5 / poly_obj, np.poly1d)
+
+assert_type(poly_obj[0], Any)
+poly_obj[0] = 5
+assert_type(iter(poly_obj), Iterator[Any])
+assert_type(poly_obj.deriv(), np.poly1d)
+assert_type(poly_obj.integ(), np.poly1d)
+
+assert_type(np.poly(poly_obj), npt.NDArray[np.floating[Any]])
+assert_type(np.poly(AR_f8), npt.NDArray[np.floating[Any]])
+assert_type(np.poly(AR_c16), npt.NDArray[np.floating[Any]])
+
+assert_type(np.polyint(poly_obj), np.poly1d)
+assert_type(np.polyint(AR_f8), npt.NDArray[np.floating[Any]])
+assert_type(np.polyint(AR_f8, k=AR_c16), npt.NDArray[np.complexfloating[Any, Any]])
+assert_type(np.polyint(AR_O, m=2), npt.NDArray[np.object_])
+
+assert_type(np.polyder(poly_obj), np.poly1d)
+assert_type(np.polyder(AR_f8), npt.NDArray[np.floating[Any]])
+assert_type(np.polyder(AR_c16), npt.NDArray[np.complexfloating[Any, Any]])
+assert_type(np.polyder(AR_O, m=2), npt.NDArray[np.object_])
+
+assert_type(np.polyfit(AR_f8, AR_f8, 2), npt.NDArray[np.float64])
+assert_type(
+    np.polyfit(AR_f8, AR_i8, 1, full=True),
+    tuple[
+        npt.NDArray[np.float64],
+        npt.NDArray[np.float64],
+        npt.NDArray[np.int32],
+        npt.NDArray[np.float64],
+        npt.NDArray[np.float64],
+    ],
+)
+assert_type(
+    np.polyfit(AR_u4, AR_f8, 1.0, cov="unscaled"),
+    tuple[
+        npt.NDArray[np.float64],
+        npt.NDArray[np.float64],
+    ],
+)
+assert_type(np.polyfit(AR_c16, AR_f8, 2), npt.NDArray[np.complex128])
+assert_type(
+    np.polyfit(AR_f8, AR_c16, 1, full=True),
+    tuple[
+        npt.NDArray[np.complex128],
+        npt.NDArray[np.float64],
+        npt.NDArray[np.int32],
+        npt.NDArray[np.float64],
+        npt.NDArray[np.float64],
+    ],
+)
+assert_type(
+    np.polyfit(AR_u4, AR_c16, 1.0, cov=True),
+    tuple[
+        npt.NDArray[np.complex128],
+        npt.NDArray[np.complex128],
+    ],
+)
+
+assert_type(np.polyval(AR_b, AR_b), npt.NDArray[np.int64])
+assert_type(np.polyval(AR_u4, AR_b), npt.NDArray[np.unsignedinteger[Any]])
+assert_type(np.polyval(AR_i8, AR_i8), npt.NDArray[np.signedinteger[Any]])
+assert_type(np.polyval(AR_f8, AR_i8), npt.NDArray[np.floating[Any]])
+assert_type(np.polyval(AR_i8, AR_c16), npt.NDArray[np.complexfloating[Any, Any]])
+assert_type(np.polyval(AR_O, AR_O), npt.NDArray[np.object_])
+
+assert_type(np.polyadd(poly_obj, AR_i8), np.poly1d)
+assert_type(np.polyadd(AR_f8, poly_obj), np.poly1d)
+assert_type(np.polyadd(AR_b, AR_b), npt.NDArray[np.bool])
+assert_type(np.polyadd(AR_u4, AR_b), npt.NDArray[np.unsignedinteger[Any]])
+assert_type(np.polyadd(AR_i8, AR_i8), npt.NDArray[np.signedinteger[Any]])
+assert_type(np.polyadd(AR_f8, AR_i8), npt.NDArray[np.floating[Any]])
+assert_type(np.polyadd(AR_i8, AR_c16), npt.NDArray[np.complexfloating[Any, Any]])
+assert_type(np.polyadd(AR_O, AR_O), npt.NDArray[np.object_])
+
+assert_type(np.polysub(poly_obj, AR_i8), np.poly1d)
+assert_type(np.polysub(AR_f8, poly_obj), np.poly1d)
+assert_type(np.polysub(AR_b, AR_b), NoReturn)
+assert_type(np.polysub(AR_u4, AR_b), npt.NDArray[np.unsignedinteger[Any]])
+assert_type(np.polysub(AR_i8, AR_i8), npt.NDArray[np.signedinteger[Any]])
+assert_type(np.polysub(AR_f8, AR_i8), npt.NDArray[np.floating[Any]])
+assert_type(np.polysub(AR_i8, AR_c16), npt.NDArray[np.complexfloating[Any, Any]])
+assert_type(np.polysub(AR_O, AR_O), npt.NDArray[np.object_])
+
+assert_type(np.polymul(poly_obj, AR_i8), np.poly1d)
+assert_type(np.polymul(AR_f8, poly_obj), np.poly1d)
+assert_type(np.polymul(AR_b, AR_b), npt.NDArray[np.bool])
+assert_type(np.polymul(AR_u4, AR_b), npt.NDArray[np.unsignedinteger[Any]])
+assert_type(np.polymul(AR_i8, AR_i8), npt.NDArray[np.signedinteger[Any]])
+assert_type(np.polymul(AR_f8, AR_i8), npt.NDArray[np.floating[Any]])
+assert_type(np.polymul(AR_i8, AR_c16), npt.NDArray[np.complexfloating[Any, Any]])
+assert_type(np.polymul(AR_O, AR_O), npt.NDArray[np.object_])
+
+assert_type(np.polydiv(poly_obj, AR_i8), tuple[np.poly1d, np.poly1d])
+assert_type(np.polydiv(AR_f8, poly_obj), tuple[np.poly1d, np.poly1d])
+assert_type(np.polydiv(AR_b, AR_b), tuple[npt.NDArray[np.floating[Any]], npt.NDArray[np.floating[Any]]])
+assert_type(np.polydiv(AR_u4, AR_b), tuple[npt.NDArray[np.floating[Any]], npt.NDArray[np.floating[Any]]])
+assert_type(np.polydiv(AR_i8, AR_i8), tuple[npt.NDArray[np.floating[Any]], npt.NDArray[np.floating[Any]]])
+assert_type(np.polydiv(AR_f8, AR_i8), tuple[npt.NDArray[np.floating[Any]], npt.NDArray[np.floating[Any]]])
+assert_type(np.polydiv(AR_i8, AR_c16), tuple[npt.NDArray[np.complexfloating[Any, Any]], npt.NDArray[np.complexfloating[Any, Any]]])
+assert_type(np.polydiv(AR_O, AR_O), tuple[npt.NDArray[Any], npt.NDArray[Any]])
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/lib_utils.pyi b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/lib_utils.pyi
new file mode 100644
index 00000000..094b6014
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/lib_utils.pyi
@@ -0,0 +1,22 @@
+import sys
+from io import StringIO
+
+import numpy as np
+import numpy.typing as npt
+import numpy.lib.array_utils as array_utils
+
+if sys.version_info >= (3, 11):
+    from typing import assert_type
+else:
+    from typing_extensions import assert_type
+
+AR: npt.NDArray[np.float64]
+AR_DICT: dict[str, npt.NDArray[np.float64]]
+FILE: StringIO
+
+def func(a: int) -> bool: ...
+
+assert_type(array_utils.byte_bounds(AR), tuple[int, int])
+assert_type(array_utils.byte_bounds(np.float64()), tuple[int, int])
+
+assert_type(np.info(1, output=FILE), None)
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/lib_version.pyi b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/lib_version.pyi
new file mode 100644
index 00000000..142d88bd
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/lib_version.pyi
@@ -0,0 +1,25 @@
+import sys
+
+from numpy.lib import NumpyVersion
+
+if sys.version_info >= (3, 11):
+    from typing import assert_type
+else:
+    from typing_extensions import assert_type
+
+version = NumpyVersion("1.8.0")
+
+assert_type(version.vstring, str)
+assert_type(version.version, str)
+assert_type(version.major, int)
+assert_type(version.minor, int)
+assert_type(version.bugfix, int)
+assert_type(version.pre_release, str)
+assert_type(version.is_devversion, bool)
+
+assert_type(version == version, bool)
+assert_type(version != version, bool)
+assert_type(version < "1.8.0", bool)
+assert_type(version <= version, bool)
+assert_type(version > version, bool)
+assert_type(version >= "1.8.0", bool)
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/linalg.pyi b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/linalg.pyi
new file mode 100644
index 00000000..8d594d42
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/linalg.pyi
@@ -0,0 +1,134 @@
+import sys
+from typing import Any
+
+import numpy as np
+import numpy.typing as npt
+from numpy.linalg._linalg import (
+    QRResult, EigResult, EighResult, SVDResult, SlogdetResult
+)
+
+if sys.version_info >= (3, 11):
+    from typing import assert_type
+else:
+    from typing_extensions import assert_type
+
+AR_i8: npt.NDArray[np.int64]
+AR_f8: npt.NDArray[np.float64]
+AR_c16: npt.NDArray[np.complex128]
+AR_O: npt.NDArray[np.object_]
+AR_m: npt.NDArray[np.timedelta64]
+AR_S: npt.NDArray[np.str_]
+AR_b: npt.NDArray[np.bool]
+
+assert_type(np.linalg.tensorsolve(AR_i8, AR_i8), npt.NDArray[np.float64])
+assert_type(np.linalg.tensorsolve(AR_i8, AR_f8), npt.NDArray[np.floating[Any]])
+assert_type(np.linalg.tensorsolve(AR_c16, AR_f8), npt.NDArray[np.complexfloating[Any, Any]])
+
+assert_type(np.linalg.solve(AR_i8, AR_i8), npt.NDArray[np.float64])
+assert_type(np.linalg.solve(AR_i8, AR_f8), npt.NDArray[np.floating[Any]])
+assert_type(np.linalg.solve(AR_c16, AR_f8), npt.NDArray[np.complexfloating[Any, Any]])
+
+assert_type(np.linalg.tensorinv(AR_i8), npt.NDArray[np.float64])
+assert_type(np.linalg.tensorinv(AR_f8), npt.NDArray[np.floating[Any]])
+assert_type(np.linalg.tensorinv(AR_c16), npt.NDArray[np.complexfloating[Any, Any]])
+
+assert_type(np.linalg.inv(AR_i8), npt.NDArray[np.float64])
+assert_type(np.linalg.inv(AR_f8), npt.NDArray[np.floating[Any]])
+assert_type(np.linalg.inv(AR_c16), npt.NDArray[np.complexfloating[Any, Any]])
+
+assert_type(np.linalg.matrix_power(AR_i8, -1), npt.NDArray[Any])
+assert_type(np.linalg.matrix_power(AR_f8, 0), npt.NDArray[Any])
+assert_type(np.linalg.matrix_power(AR_c16, 1), npt.NDArray[Any])
+assert_type(np.linalg.matrix_power(AR_O, 2), npt.NDArray[Any])
+
+assert_type(np.linalg.cholesky(AR_i8), npt.NDArray[np.float64])
+assert_type(np.linalg.cholesky(AR_f8), npt.NDArray[np.floating[Any]])
+assert_type(np.linalg.cholesky(AR_c16), npt.NDArray[np.complexfloating[Any, Any]])
+
+assert_type(np.linalg.outer(AR_i8, AR_i8), npt.NDArray[np.signedinteger[Any]])
+assert_type(np.linalg.outer(AR_f8, AR_f8), npt.NDArray[np.floating[Any]])
+assert_type(np.linalg.outer(AR_c16, AR_c16), npt.NDArray[np.complexfloating[Any, Any]])
+assert_type(np.linalg.outer(AR_b, AR_b), npt.NDArray[np.bool])
+assert_type(np.linalg.outer(AR_O, AR_O), npt.NDArray[np.object_])
+assert_type(np.linalg.outer(AR_i8, AR_m), npt.NDArray[np.timedelta64])
+
+assert_type(np.linalg.qr(AR_i8), QRResult)
+assert_type(np.linalg.qr(AR_f8), QRResult)
+assert_type(np.linalg.qr(AR_c16), QRResult)
+
+assert_type(np.linalg.eigvals(AR_i8), npt.NDArray[np.float64] | npt.NDArray[np.complex128])
+assert_type(np.linalg.eigvals(AR_f8), npt.NDArray[np.floating[Any]] | npt.NDArray[np.complexfloating[Any, Any]])
+assert_type(np.linalg.eigvals(AR_c16), npt.NDArray[np.complexfloating[Any, Any]])
+
+assert_type(np.linalg.eigvalsh(AR_i8), npt.NDArray[np.float64])
+assert_type(np.linalg.eigvalsh(AR_f8), npt.NDArray[np.floating[Any]])
+assert_type(np.linalg.eigvalsh(AR_c16), npt.NDArray[np.floating[Any]])
+
+assert_type(np.linalg.eig(AR_i8), EigResult)
+assert_type(np.linalg.eig(AR_f8), EigResult)
+assert_type(np.linalg.eig(AR_c16), EigResult)
+
+assert_type(np.linalg.eigh(AR_i8), EighResult)
+assert_type(np.linalg.eigh(AR_f8), EighResult)
+assert_type(np.linalg.eigh(AR_c16), EighResult)
+
+assert_type(np.linalg.svd(AR_i8), SVDResult)
+assert_type(np.linalg.svd(AR_f8), SVDResult)
+assert_type(np.linalg.svd(AR_c16), SVDResult)
+assert_type(np.linalg.svd(AR_i8, compute_uv=False), npt.NDArray[np.float64])
+assert_type(np.linalg.svd(AR_f8, compute_uv=False), npt.NDArray[np.floating[Any]])
+assert_type(np.linalg.svd(AR_c16, compute_uv=False), npt.NDArray[np.floating[Any]])
+
+assert_type(np.linalg.cond(AR_i8), Any)
+assert_type(np.linalg.cond(AR_f8), Any)
+assert_type(np.linalg.cond(AR_c16), Any)
+
+assert_type(np.linalg.matrix_rank(AR_i8), Any)
+assert_type(np.linalg.matrix_rank(AR_f8), Any)
+assert_type(np.linalg.matrix_rank(AR_c16), Any)
+
+assert_type(np.linalg.pinv(AR_i8), npt.NDArray[np.float64])
+assert_type(np.linalg.pinv(AR_f8), npt.NDArray[np.floating[Any]])
+assert_type(np.linalg.pinv(AR_c16), npt.NDArray[np.complexfloating[Any, Any]])
+
+assert_type(np.linalg.slogdet(AR_i8), SlogdetResult)
+assert_type(np.linalg.slogdet(AR_f8), SlogdetResult)
+assert_type(np.linalg.slogdet(AR_c16), SlogdetResult)
+
+assert_type(np.linalg.det(AR_i8), Any)
+assert_type(np.linalg.det(AR_f8), Any)
+assert_type(np.linalg.det(AR_c16), Any)
+
+assert_type(np.linalg.lstsq(AR_i8, AR_i8), tuple[npt.NDArray[np.float64], npt.NDArray[np.float64], np.int32, npt.NDArray[np.float64]])
+assert_type(np.linalg.lstsq(AR_i8, AR_f8), tuple[npt.NDArray[np.floating[Any]], npt.NDArray[np.floating[Any]], np.int32, npt.NDArray[np.floating[Any]]])
+assert_type(np.linalg.lstsq(AR_f8, AR_c16), tuple[npt.NDArray[np.complexfloating[Any, Any]], npt.NDArray[np.floating[Any]], np.int32, npt.NDArray[np.floating[Any]]])
+
+assert_type(np.linalg.norm(AR_i8), np.floating[Any])
+assert_type(np.linalg.norm(AR_f8), np.floating[Any])
+assert_type(np.linalg.norm(AR_c16), np.floating[Any])
+assert_type(np.linalg.norm(AR_S), np.floating[Any])
+assert_type(np.linalg.norm(AR_f8, axis=0), Any)
+
+assert_type(np.linalg.matrix_norm(AR_i8), np.floating[Any])
+assert_type(np.linalg.matrix_norm(AR_f8), np.floating[Any])
+assert_type(np.linalg.matrix_norm(AR_c16), np.floating[Any])
+assert_type(np.linalg.matrix_norm(AR_S), np.floating[Any])
+
+assert_type(np.linalg.vector_norm(AR_i8), np.floating[Any])
+assert_type(np.linalg.vector_norm(AR_f8), np.floating[Any])
+assert_type(np.linalg.vector_norm(AR_c16), np.floating[Any])
+assert_type(np.linalg.vector_norm(AR_S), np.floating[Any])
+
+assert_type(np.linalg.multi_dot([AR_i8, AR_i8]), Any)
+assert_type(np.linalg.multi_dot([AR_i8, AR_f8]), Any)
+assert_type(np.linalg.multi_dot([AR_f8, AR_c16]), Any)
+assert_type(np.linalg.multi_dot([AR_O, AR_O]), Any)
+assert_type(np.linalg.multi_dot([AR_m, AR_m]), Any)
+
+assert_type(np.linalg.cross(AR_i8, AR_i8), npt.NDArray[np.signedinteger[Any]])
+assert_type(np.linalg.cross(AR_f8, AR_f8), npt.NDArray[np.floating[Any]])
+assert_type(np.linalg.cross(AR_c16, AR_c16), npt.NDArray[np.complexfloating[Any, Any]])
+
+assert_type(np.linalg.matmul(AR_i8, AR_i8), npt.NDArray[np.signedinteger[Any]])
+assert_type(np.linalg.matmul(AR_f8, AR_f8), npt.NDArray[np.floating[Any]])
+assert_type(np.linalg.matmul(AR_c16, AR_c16), npt.NDArray[np.complexfloating[Any, Any]])
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/matrix.pyi b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/matrix.pyi
new file mode 100644
index 00000000..1a0aa4e3
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/matrix.pyi
@@ -0,0 +1,76 @@
+import sys
+from typing import Any
+
+import numpy as np
+import numpy.typing as npt
+
+if sys.version_info >= (3, 11):
+    from typing import assert_type
+else:
+    from typing_extensions import assert_type
+
+mat: np.matrix[Any, np.dtype[np.int64]]
+ar_f8: npt.NDArray[np.float64]
+
+assert_type(mat * 5, np.matrix[Any, Any])
+assert_type(5 * mat, np.matrix[Any, Any])
+mat *= 5
+
+assert_type(mat**5, np.matrix[Any, Any])
+mat **= 5
+
+assert_type(mat.sum(), Any)
+assert_type(mat.mean(), Any)
+assert_type(mat.std(), Any)
+assert_type(mat.var(), Any)
+assert_type(mat.prod(), Any)
+assert_type(mat.any(), np.bool)
+assert_type(mat.all(), np.bool)
+assert_type(mat.max(), np.int64)
+assert_type(mat.min(), np.int64)
+assert_type(mat.argmax(), np.intp)
+assert_type(mat.argmin(), np.intp)
+assert_type(mat.ptp(), np.int64)
+
+assert_type(mat.sum(axis=0), np.matrix[Any, Any])
+assert_type(mat.mean(axis=0), np.matrix[Any, Any])
+assert_type(mat.std(axis=0), np.matrix[Any, Any])
+assert_type(mat.var(axis=0), np.matrix[Any, Any])
+assert_type(mat.prod(axis=0), np.matrix[Any, Any])
+assert_type(mat.any(axis=0), np.matrix[Any, np.dtype[np.bool]])
+assert_type(mat.all(axis=0), np.matrix[Any, np.dtype[np.bool]])
+assert_type(mat.max(axis=0), np.matrix[Any, np.dtype[np.int64]])
+assert_type(mat.min(axis=0), np.matrix[Any, np.dtype[np.int64]])
+assert_type(mat.argmax(axis=0), np.matrix[Any, np.dtype[np.intp]])
+assert_type(mat.argmin(axis=0), np.matrix[Any, np.dtype[np.intp]])
+assert_type(mat.ptp(axis=0), np.matrix[Any, np.dtype[np.int64]])
+
+assert_type(mat.sum(out=ar_f8), npt.NDArray[np.float64])
+assert_type(mat.mean(out=ar_f8), npt.NDArray[np.float64])
+assert_type(mat.std(out=ar_f8), npt.NDArray[np.float64])
+assert_type(mat.var(out=ar_f8), npt.NDArray[np.float64])
+assert_type(mat.prod(out=ar_f8), npt.NDArray[np.float64])
+assert_type(mat.any(out=ar_f8), npt.NDArray[np.float64])
+assert_type(mat.all(out=ar_f8), npt.NDArray[np.float64])
+assert_type(mat.max(out=ar_f8), npt.NDArray[np.float64])
+assert_type(mat.min(out=ar_f8), npt.NDArray[np.float64])
+assert_type(mat.argmax(out=ar_f8), npt.NDArray[np.float64])
+assert_type(mat.argmin(out=ar_f8), npt.NDArray[np.float64])
+assert_type(mat.ptp(out=ar_f8), npt.NDArray[np.float64])
+
+assert_type(mat.T, np.matrix[Any, np.dtype[np.int64]])
+assert_type(mat.I, np.matrix[Any, Any])
+assert_type(mat.A, npt.NDArray[np.int64])
+assert_type(mat.A1, npt.NDArray[np.int64])
+assert_type(mat.H, np.matrix[Any, np.dtype[np.int64]])
+assert_type(mat.getT(), np.matrix[Any, np.dtype[np.int64]])
+assert_type(mat.getI(), np.matrix[Any, Any])
+assert_type(mat.getA(), npt.NDArray[np.int64])
+assert_type(mat.getA1(), npt.NDArray[np.int64])
+assert_type(mat.getH(), np.matrix[Any, np.dtype[np.int64]])
+
+assert_type(np.bmat(ar_f8), np.matrix[Any, Any])
+assert_type(np.bmat([[0, 1, 2]]), np.matrix[Any, Any])
+assert_type(np.bmat("mat"), np.matrix[Any, Any])
+
+assert_type(np.asmatrix(ar_f8, dtype=np.int64), np.matrix[Any, Any])
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/memmap.pyi b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/memmap.pyi
new file mode 100644
index 00000000..53278ff1
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/memmap.pyi
@@ -0,0 +1,25 @@
+import sys
+from typing import Any
+
+import numpy as np
+
+if sys.version_info >= (3, 11):
+    from typing import assert_type
+else:
+    from typing_extensions import assert_type
+
+memmap_obj: np.memmap[Any, np.dtype[np.str_]]
+
+assert_type(np.memmap.__array_priority__, float)
+assert_type(memmap_obj.__array_priority__, float)
+assert_type(memmap_obj.filename, str | None)
+assert_type(memmap_obj.offset, int)
+assert_type(memmap_obj.mode, str)
+assert_type(memmap_obj.flush(), None)
+
+assert_type(np.memmap("file.txt", offset=5), np.memmap[Any, np.dtype[np.uint8]])
+assert_type(np.memmap(b"file.txt", dtype=np.float64, shape=(10, 3)), np.memmap[Any, np.dtype[np.float64]])
+with open("file.txt", "rb") as f:
+    assert_type(np.memmap(f, dtype=float, order="K"), np.memmap[Any, np.dtype[Any]])
+
+assert_type(memmap_obj.__array_finalize__(object()), None)
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/mod.pyi b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/mod.pyi
new file mode 100644
index 00000000..11cdeb2a
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/mod.pyi
@@ -0,0 +1,148 @@
+import sys
+from typing import Any
+
+import numpy as np
+import numpy.typing as npt
+from numpy._typing import _32Bit, _64Bit
+
+if sys.version_info >= (3, 11):
+    from typing import assert_type
+else:
+    from typing_extensions import assert_type
+
+f8 = np.float64()
+i8 = np.int64()
+u8 = np.uint64()
+
+f4 = np.float32()
+i4 = np.int32()
+u4 = np.uint32()
+
+td = np.timedelta64(0, "D")
+b_ = np.bool()
+
+b = bool()
+f = float()
+i = int()
+
+AR_b: npt.NDArray[np.bool]
+AR_m: npt.NDArray[np.timedelta64]
+
+# Time structures
+
+assert_type(td % td, np.timedelta64)
+assert_type(AR_m % td, npt.NDArray[np.timedelta64])
+assert_type(td % AR_m, npt.NDArray[np.timedelta64])
+
+assert_type(divmod(td, td), tuple[np.int64, np.timedelta64])
+assert_type(divmod(AR_m, td), tuple[npt.NDArray[np.int64], npt.NDArray[np.timedelta64]])
+assert_type(divmod(td, AR_m), tuple[npt.NDArray[np.int64], npt.NDArray[np.timedelta64]])
+
+# Bool
+
+assert_type(b_ % b, np.int8)
+assert_type(b_ % i, np.int_)
+assert_type(b_ % f, np.float64)
+assert_type(b_ % b_, np.int8)
+assert_type(b_ % i8, np.int64)
+assert_type(b_ % u8, np.uint64)
+assert_type(b_ % f8, np.float64)
+assert_type(b_ % AR_b, npt.NDArray[np.int8])
+
+assert_type(divmod(b_, b), tuple[np.int8, np.int8])
+assert_type(divmod(b_, i), tuple[np.int_, np.int_])
+assert_type(divmod(b_, f), tuple[np.float64, np.float64])
+assert_type(divmod(b_, b_), tuple[np.int8, np.int8])
+assert_type(divmod(b_, i8), tuple[np.int64, np.int64])
+assert_type(divmod(b_, u8), tuple[np.uint64, np.uint64])
+assert_type(divmod(b_, f8), tuple[np.float64, np.float64])
+assert_type(divmod(b_, AR_b), tuple[npt.NDArray[np.int8], npt.NDArray[np.int8]])
+
+assert_type(b % b_, np.int8)
+assert_type(i % b_, np.int_)
+assert_type(f % b_, np.float64)
+assert_type(b_ % b_, np.int8)
+assert_type(i8 % b_, np.int64)
+assert_type(u8 % b_, np.uint64)
+assert_type(f8 % b_, np.float64)
+assert_type(AR_b % b_, npt.NDArray[np.int8])
+
+assert_type(divmod(b, b_), tuple[np.int8, np.int8])
+assert_type(divmod(i, b_), tuple[np.int_, np.int_])
+assert_type(divmod(f, b_), tuple[np.float64, np.float64])
+assert_type(divmod(b_, b_), tuple[np.int8, np.int8])
+assert_type(divmod(i8, b_), tuple[np.int64, np.int64])
+assert_type(divmod(u8, b_), tuple[np.uint64, np.uint64])
+assert_type(divmod(f8, b_), tuple[np.float64, np.float64])
+assert_type(divmod(AR_b, b_), tuple[npt.NDArray[np.int8], npt.NDArray[np.int8]])
+
+# int
+
+assert_type(i8 % b, np.int64)
+assert_type(i8 % f, np.float64)
+assert_type(i8 % i8, np.int64)
+assert_type(i8 % f8, np.float64)
+assert_type(i4 % i8, np.signedinteger[_32Bit | _64Bit])
+assert_type(i4 % f8, np.floating[_32Bit | _64Bit])
+assert_type(i4 % i4, np.int32)
+assert_type(i4 % f4, np.float32)
+assert_type(i8 % AR_b, npt.NDArray[np.signedinteger[Any]])
+
+assert_type(divmod(i8, b), tuple[np.int64, np.int64])
+assert_type(divmod(i8, f), tuple[np.float64, np.float64])
+assert_type(divmod(i8, i8), tuple[np.int64, np.int64])
+assert_type(divmod(i8, f8), tuple[np.float64, np.float64])
+assert_type(divmod(i8, i4), tuple[np.signedinteger[_32Bit | _64Bit], np.signedinteger[_32Bit | _64Bit]])
+assert_type(divmod(i8, f4), tuple[np.floating[_32Bit | _64Bit], np.floating[_32Bit | _64Bit]])
+assert_type(divmod(i4, i4), tuple[np.int32, np.int32])
+assert_type(divmod(i4, f4), tuple[np.float32, np.float32])
+assert_type(divmod(i8, AR_b), tuple[npt.NDArray[np.signedinteger[Any]], npt.NDArray[np.signedinteger[Any]]])
+
+assert_type(b % i8, np.int64)
+assert_type(f % i8, np.float64)
+assert_type(i8 % i8, np.int64)
+assert_type(f8 % i8, np.float64)
+assert_type(i8 % i4, np.signedinteger[_32Bit | _64Bit])
+assert_type(f8 % i4, np.floating[_32Bit | _64Bit])
+assert_type(i4 % i4, np.int32)
+assert_type(f4 % i4, np.float32)
+assert_type(AR_b % i8, npt.NDArray[np.signedinteger[Any]])
+
+assert_type(divmod(b, i8), tuple[np.int64, np.int64])
+assert_type(divmod(f, i8), tuple[np.float64, np.float64])
+assert_type(divmod(i8, i8), tuple[np.int64, np.int64])
+assert_type(divmod(f8, i8), tuple[np.float64, np.float64])
+assert_type(divmod(i4, i8), tuple[np.signedinteger[_32Bit | _64Bit], np.signedinteger[_32Bit | _64Bit]])
+assert_type(divmod(f4, i8), tuple[np.floating[_32Bit | _64Bit], np.floating[_32Bit | _64Bit]])
+assert_type(divmod(i4, i4), tuple[np.int32, np.int32])
+assert_type(divmod(f4, i4), tuple[np.float32, np.float32])
+assert_type(divmod(AR_b, i8), tuple[npt.NDArray[np.signedinteger[Any]], npt.NDArray[np.signedinteger[Any]]])
+
+# float
+
+assert_type(f8 % b, np.float64)
+assert_type(f8 % f, np.float64)
+assert_type(i8 % f4, np.floating[_32Bit | _64Bit])
+assert_type(f4 % f4, np.float32)
+assert_type(f8 % AR_b, npt.NDArray[np.floating[Any]])
+
+assert_type(divmod(f8, b), tuple[np.float64, np.float64])
+assert_type(divmod(f8, f), tuple[np.float64, np.float64])
+assert_type(divmod(f8, f8), tuple[np.float64, np.float64])
+assert_type(divmod(f8, f4), tuple[np.floating[_32Bit | _64Bit], np.floating[_32Bit | _64Bit]])
+assert_type(divmod(f4, f4), tuple[np.float32, np.float32])
+assert_type(divmod(f8, AR_b), tuple[npt.NDArray[np.floating[Any]], npt.NDArray[np.floating[Any]]])
+
+assert_type(b % f8, np.float64)
+assert_type(f % f8, np.float64)
+assert_type(f8 % f8, np.float64)
+assert_type(f8 % f8, np.float64)
+assert_type(f4 % f4, np.float32)
+assert_type(AR_b % f8, npt.NDArray[np.floating[Any]])
+
+assert_type(divmod(b, f8), tuple[np.float64, np.float64])
+assert_type(divmod(f, f8), tuple[np.float64, np.float64])
+assert_type(divmod(f8, f8), tuple[np.float64, np.float64])
+assert_type(divmod(f4, f8), tuple[np.floating[_32Bit | _64Bit], np.floating[_32Bit | _64Bit]])
+assert_type(divmod(f4, f4), tuple[np.float32, np.float32])
+assert_type(divmod(AR_b, f8), tuple[npt.NDArray[np.floating[Any]], npt.NDArray[np.floating[Any]]])
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/modules.pyi b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/modules.pyi
new file mode 100644
index 00000000..1ab01cd0
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/modules.pyi
@@ -0,0 +1,56 @@
+import sys
+import types
+
+import numpy as np
+from numpy import f2py
+
+if sys.version_info >= (3, 11):
+    from typing import assert_type
+else:
+    from typing_extensions import assert_type
+
+assert_type(np, types.ModuleType)
+
+assert_type(np.char, types.ModuleType)
+assert_type(np.ctypeslib, types.ModuleType)
+assert_type(np.emath, types.ModuleType)
+assert_type(np.fft, types.ModuleType)
+assert_type(np.lib, types.ModuleType)
+assert_type(np.linalg, types.ModuleType)
+assert_type(np.ma, types.ModuleType)
+assert_type(np.matrixlib, types.ModuleType)
+assert_type(np.polynomial, types.ModuleType)
+assert_type(np.random, types.ModuleType)
+assert_type(np.rec, types.ModuleType)
+assert_type(np.testing, types.ModuleType)
+assert_type(np.version, types.ModuleType)
+assert_type(np.exceptions, types.ModuleType)
+assert_type(np.dtypes, types.ModuleType)
+
+assert_type(np.lib.format, types.ModuleType)
+assert_type(np.lib.mixins, types.ModuleType)
+assert_type(np.lib.scimath, types.ModuleType)
+assert_type(np.lib.stride_tricks, types.ModuleType)
+assert_type(np.ma.extras, types.ModuleType)
+assert_type(np.polynomial.chebyshev, types.ModuleType)
+assert_type(np.polynomial.hermite, types.ModuleType)
+assert_type(np.polynomial.hermite_e, types.ModuleType)
+assert_type(np.polynomial.laguerre, types.ModuleType)
+assert_type(np.polynomial.legendre, types.ModuleType)
+assert_type(np.polynomial.polynomial, types.ModuleType)
+
+assert_type(np.__path__, list[str])
+assert_type(np.__version__, str)
+assert_type(np.test, np._pytesttester.PytestTester)
+assert_type(np.test.module_name, str)
+
+assert_type(np.__all__, list[str])
+assert_type(np.char.__all__, list[str])
+assert_type(np.ctypeslib.__all__, list[str])
+assert_type(np.emath.__all__, list[str])
+assert_type(np.lib.__all__, list[str])
+assert_type(np.ma.__all__, list[str])
+assert_type(np.random.__all__, list[str])
+assert_type(np.rec.__all__, list[str])
+assert_type(np.testing.__all__, list[str])
+assert_type(f2py.__all__, list[str])
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/multiarray.pyi b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/multiarray.pyi
new file mode 100644
index 00000000..085c5ff5
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/multiarray.pyi
@@ -0,0 +1,143 @@
+import sys
+import datetime as dt
+from typing import Any, TypeVar
+
+import numpy as np
+import numpy.typing as npt
+
+if sys.version_info >= (3, 11):
+    from typing import assert_type
+else:
+    from typing_extensions import assert_type
+
+_SCT = TypeVar("_SCT", bound=np.generic, covariant=True)
+
+class SubClass(npt.NDArray[_SCT]): ...
+
+subclass: SubClass[np.float64]
+
+AR_f8: npt.NDArray[np.float64]
+AR_i8: npt.NDArray[np.int64]
+AR_u1: npt.NDArray[np.uint8]
+AR_m: npt.NDArray[np.timedelta64]
+AR_M: npt.NDArray[np.datetime64]
+
+AR_LIKE_f: list[float]
+AR_LIKE_i: list[int]
+
+m: np.timedelta64
+M: np.datetime64
+
+b_f8 = np.broadcast(AR_f8)
+b_i8_f8_f8 = np.broadcast(AR_i8, AR_f8, AR_f8)
+
+nditer_obj: np.nditer
+
+date_scalar: dt.date
+date_seq: list[dt.date]
+timedelta_seq: list[dt.timedelta]
+
+def func(a: int) -> bool: ...
+
+assert_type(next(b_f8), tuple[Any, ...])
+assert_type(b_f8.reset(), None)
+assert_type(b_f8.index, int)
+assert_type(b_f8.iters, tuple[np.flatiter[Any], ...])
+assert_type(b_f8.nd, int)
+assert_type(b_f8.ndim, int)
+assert_type(b_f8.numiter, int)
+assert_type(b_f8.shape, tuple[int, ...])
+assert_type(b_f8.size, int)
+
+assert_type(next(b_i8_f8_f8), tuple[Any, ...])
+assert_type(b_i8_f8_f8.reset(), None)
+assert_type(b_i8_f8_f8.index, int)
+assert_type(b_i8_f8_f8.iters, tuple[np.flatiter[Any], ...])
+assert_type(b_i8_f8_f8.nd, int)
+assert_type(b_i8_f8_f8.ndim, int)
+assert_type(b_i8_f8_f8.numiter, int)
+assert_type(b_i8_f8_f8.shape, tuple[int, ...])
+assert_type(b_i8_f8_f8.size, int)
+
+assert_type(np.inner(AR_f8, AR_i8), Any)
+
+assert_type(np.where([True, True, False]), tuple[npt.NDArray[np.intp], ...])
+assert_type(np.where([True, True, False], 1, 0), npt.NDArray[Any])
+
+assert_type(np.lexsort([0, 1, 2]), Any)
+
+assert_type(np.can_cast(np.dtype("i8"), int), bool)
+assert_type(np.can_cast(AR_f8, "f8"), bool)
+assert_type(np.can_cast(AR_f8, np.complex128, casting="unsafe"), bool)
+
+assert_type(np.min_scalar_type([1]), np.dtype[Any])
+assert_type(np.min_scalar_type(AR_f8), np.dtype[Any])
+
+assert_type(np.result_type(int, [1]), np.dtype[Any])
+assert_type(np.result_type(AR_f8, AR_u1), np.dtype[Any])
+assert_type(np.result_type(AR_f8, np.complex128), np.dtype[Any])
+
+assert_type(np.dot(AR_LIKE_f, AR_i8), Any)
+assert_type(np.dot(AR_u1, 1), Any)
+assert_type(np.dot(1.5j, 1), Any)
+assert_type(np.dot(AR_u1, 1, out=AR_f8), npt.NDArray[np.float64])
+
+assert_type(np.vdot(AR_LIKE_f, AR_i8), np.floating[Any])
+assert_type(np.vdot(AR_u1, 1), np.signedinteger[Any])
+assert_type(np.vdot(1.5j, 1), np.complexfloating[Any, Any])
+
+assert_type(np.bincount(AR_i8), npt.NDArray[np.intp])
+
+assert_type(np.copyto(AR_f8, [1., 1.5, 1.6]), None)
+
+assert_type(np.putmask(AR_f8, [True, True, False], 1.5), None)
+
+assert_type(np.packbits(AR_i8), npt.NDArray[np.uint8])
+assert_type(np.packbits(AR_u1), npt.NDArray[np.uint8])
+
+assert_type(np.unpackbits(AR_u1), npt.NDArray[np.uint8])
+
+assert_type(np.shares_memory(1, 2), bool)
+assert_type(np.shares_memory(AR_f8, AR_f8, max_work=1), bool)
+
+assert_type(np.may_share_memory(1, 2), bool)
+assert_type(np.may_share_memory(AR_f8, AR_f8, max_work=1), bool)
+
+assert_type(np.promote_types(np.int32, np.int64), np.dtype[Any])
+assert_type(np.promote_types("f4", float), np.dtype[Any])
+
+assert_type(np.frompyfunc(func, 1, 1, identity=None), np.ufunc)
+
+assert_type(np.datetime_data("m8[D]"), tuple[str, int])
+assert_type(np.datetime_data(np.datetime64), tuple[str, int])
+assert_type(np.datetime_data(np.dtype(np.timedelta64)), tuple[str, int])
+
+assert_type(np.busday_count("2011-01", "2011-02"), np.int_)
+assert_type(np.busday_count(["2011-01"], "2011-02"), npt.NDArray[np.int_])
+assert_type(np.busday_count(["2011-01"], date_scalar), npt.NDArray[np.int_])
+
+assert_type(np.busday_offset(M, m), np.datetime64)
+assert_type(np.busday_offset(date_scalar, m), np.datetime64)
+assert_type(np.busday_offset(M, 5), np.datetime64)
+assert_type(np.busday_offset(AR_M, m), npt.NDArray[np.datetime64])
+assert_type(np.busday_offset(M, timedelta_seq), npt.NDArray[np.datetime64])
+assert_type(np.busday_offset("2011-01", "2011-02", roll="forward"), np.datetime64)
+assert_type(np.busday_offset(["2011-01"], "2011-02", roll="forward"), npt.NDArray[np.datetime64])
+
+assert_type(np.is_busday("2012"), np.bool)
+assert_type(np.is_busday(date_scalar), np.bool)
+assert_type(np.is_busday(["2012"]), npt.NDArray[np.bool])
+
+assert_type(np.datetime_as_string(M), np.str_)
+assert_type(np.datetime_as_string(AR_M), npt.NDArray[np.str_])
+
+assert_type(np.busdaycalendar(holidays=date_seq), np.busdaycalendar)
+assert_type(np.busdaycalendar(holidays=[M]), np.busdaycalendar)
+
+assert_type(np.char.compare_chararrays("a", "b", "!=", rstrip=False), npt.NDArray[np.bool])
+assert_type(np.char.compare_chararrays(b"a", b"a", "==", True), npt.NDArray[np.bool])
+
+assert_type(np.nested_iters([AR_i8, AR_i8], [[0], [1]], flags=["c_index"]), tuple[np.nditer, ...])
+assert_type(np.nested_iters([AR_i8, AR_i8], [[0], [1]], op_flags=[["readonly", "readonly"]]), tuple[np.nditer, ...])
+assert_type(np.nested_iters([AR_i8, AR_i8], [[0], [1]], op_dtypes=np.int_), tuple[np.nditer, ...])
+assert_type(np.nested_iters([AR_i8, AR_i8], [[0], [1]], order="C", casting="no"), tuple[np.nditer, ...])
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/nbit_base_example.pyi b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/nbit_base_example.pyi
new file mode 100644
index 00000000..ac2eb1d2
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/nbit_base_example.pyi
@@ -0,0 +1,27 @@
+import sys
+from typing import TypeVar
+
+import numpy as np
+import numpy.typing as npt
+from numpy._typing import _64Bit, _32Bit
+
+if sys.version_info >= (3, 11):
+    from typing import assert_type
+else:
+    from typing_extensions import assert_type
+
+T1 = TypeVar("T1", bound=npt.NBitBase)
+T2 = TypeVar("T2", bound=npt.NBitBase)
+
+def add(a: np.floating[T1], b: np.integer[T2]) -> np.floating[T1 | T2]:
+    return a + b
+
+i8: np.int64
+i4: np.int32
+f8: np.float64
+f4: np.float32
+
+assert_type(add(f8, i8), np.float64)
+assert_type(add(f4, i8), np.floating[_32Bit | _64Bit])
+assert_type(add(f8, i4), np.floating[_32Bit | _64Bit])
+assert_type(add(f4, i4), np.float32)
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/ndarray_conversion.pyi b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/ndarray_conversion.pyi
new file mode 100644
index 00000000..a5495b55
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/ndarray_conversion.pyi
@@ -0,0 +1,61 @@
+import sys
+from typing import Any
+
+import numpy as np
+import numpy.typing as npt
+
+if sys.version_info >= (3, 11):
+    from typing import assert_type
+else:
+    from typing_extensions import assert_type
+
+nd: npt.NDArray[np.int_]
+
+# item
+assert_type(nd.item(), int)
+assert_type(nd.item(1), int)
+assert_type(nd.item(0, 1), int)
+assert_type(nd.item((0, 1)), int)
+
+# tolist
+assert_type(nd.tolist(), Any)
+
+# itemset does not return a value
+# tostring is pretty simple
+# tobytes is pretty simple
+# tofile does not return a value
+# dump does not return a value
+# dumps is pretty simple
+
+# astype
+assert_type(nd.astype("float"), npt.NDArray[Any])
+assert_type(nd.astype(float), npt.NDArray[Any])
+assert_type(nd.astype(np.float64), npt.NDArray[np.float64])
+assert_type(nd.astype(np.float64, "K"), npt.NDArray[np.float64])
+assert_type(nd.astype(np.float64, "K", "unsafe"), npt.NDArray[np.float64])
+assert_type(nd.astype(np.float64, "K", "unsafe", True), npt.NDArray[np.float64])
+assert_type(nd.astype(np.float64, "K", "unsafe", True, True), npt.NDArray[np.float64])
+
+assert_type(np.astype(nd, np.float64), npt.NDArray[np.float64])
+
+# byteswap
+assert_type(nd.byteswap(), npt.NDArray[np.int_])
+assert_type(nd.byteswap(True), npt.NDArray[np.int_])
+
+# copy
+assert_type(nd.copy(), npt.NDArray[np.int_])
+assert_type(nd.copy("C"), npt.NDArray[np.int_])
+
+assert_type(nd.view(), npt.NDArray[np.int_])
+assert_type(nd.view(np.float64), npt.NDArray[np.float64])
+assert_type(nd.view(float), npt.NDArray[Any])
+assert_type(nd.view(np.float64, np.matrix), np.matrix[Any, Any])
+
+# getfield
+assert_type(nd.getfield("float"), npt.NDArray[Any])
+assert_type(nd.getfield(float), npt.NDArray[Any])
+assert_type(nd.getfield(np.float64), npt.NDArray[np.float64])
+assert_type(nd.getfield(np.float64, 8), npt.NDArray[np.float64])
+
+# setflags does not return a value
+# fill does not return a value
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/ndarray_misc.pyi b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/ndarray_misc.pyi
new file mode 100644
index 00000000..783e18f5
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/ndarray_misc.pyi
@@ -0,0 +1,233 @@
+"""
+Tests for miscellaneous (non-magic) ``np.ndarray``/``np.generic`` methods.
+
+More extensive tests are performed for the methods'
+function-based counterpart in `../from_numeric.py`.
+
+"""
+
+import sys
+import operator
+import ctypes as ct
+from typing import Any, Literal
+
+import numpy as np
+import numpy.typing as npt
+
+if sys.version_info >= (3, 11):
+    from typing import assert_type
+else:
+    from typing_extensions import assert_type
+
+class SubClass(npt.NDArray[np.object_]): ...
+
+f8: np.float64
+i8: np.int64
+B: SubClass
+AR_f8: npt.NDArray[np.float64]
+AR_i8: npt.NDArray[np.int64]
+AR_u1: npt.NDArray[np.uint8]
+AR_c8: npt.NDArray[np.complex64]
+AR_m: npt.NDArray[np.timedelta64]
+AR_U: npt.NDArray[np.str_]
+AR_V: npt.NDArray[np.void]
+
+ctypes_obj = AR_f8.ctypes
+
+assert_type(AR_f8.__dlpack__(), Any)
+assert_type(AR_f8.__dlpack_device__(), tuple[int, Literal[0]])
+
+assert_type(ctypes_obj.data, int)
+assert_type(ctypes_obj.shape, ct.Array[np.ctypeslib.c_intp])
+assert_type(ctypes_obj.strides, ct.Array[np.ctypeslib.c_intp])
+assert_type(ctypes_obj._as_parameter_, ct.c_void_p)
+
+assert_type(ctypes_obj.data_as(ct.c_void_p), ct.c_void_p)
+assert_type(ctypes_obj.shape_as(ct.c_longlong), ct.Array[ct.c_longlong])
+assert_type(ctypes_obj.strides_as(ct.c_ubyte), ct.Array[ct.c_ubyte])
+
+assert_type(f8.all(), np.bool)
+assert_type(AR_f8.all(), np.bool)
+assert_type(AR_f8.all(axis=0), Any)
+assert_type(AR_f8.all(keepdims=True), Any)
+assert_type(AR_f8.all(out=B), SubClass)
+
+assert_type(f8.any(), np.bool)
+assert_type(AR_f8.any(), np.bool)
+assert_type(AR_f8.any(axis=0), Any)
+assert_type(AR_f8.any(keepdims=True), Any)
+assert_type(AR_f8.any(out=B), SubClass)
+
+assert_type(f8.argmax(), np.intp)
+assert_type(AR_f8.argmax(), np.intp)
+assert_type(AR_f8.argmax(axis=0), Any)
+assert_type(AR_f8.argmax(out=B), SubClass)
+
+assert_type(f8.argmin(), np.intp)
+assert_type(AR_f8.argmin(), np.intp)
+assert_type(AR_f8.argmin(axis=0), Any)
+assert_type(AR_f8.argmin(out=B), SubClass)
+
+assert_type(f8.argsort(), npt.NDArray[Any])
+assert_type(AR_f8.argsort(), npt.NDArray[Any])
+
+assert_type(f8.astype(np.int64).choose([()]), npt.NDArray[Any])
+assert_type(AR_f8.choose([0]), npt.NDArray[Any])
+assert_type(AR_f8.choose([0], out=B), SubClass)
+
+assert_type(f8.clip(1), npt.NDArray[Any])
+assert_type(AR_f8.clip(1), npt.NDArray[Any])
+assert_type(AR_f8.clip(None, 1), npt.NDArray[Any])
+assert_type(AR_f8.clip(1, out=B), SubClass)
+assert_type(AR_f8.clip(None, 1, out=B), SubClass)
+
+assert_type(f8.compress([0]), npt.NDArray[Any])
+assert_type(AR_f8.compress([0]), npt.NDArray[Any])
+assert_type(AR_f8.compress([0], out=B), SubClass)
+
+assert_type(f8.conj(), np.float64)
+assert_type(AR_f8.conj(), npt.NDArray[np.float64])
+assert_type(B.conj(), SubClass)
+
+assert_type(f8.conjugate(), np.float64)
+assert_type(AR_f8.conjugate(), npt.NDArray[np.float64])
+assert_type(B.conjugate(), SubClass)
+
+assert_type(f8.cumprod(), npt.NDArray[Any])
+assert_type(AR_f8.cumprod(), npt.NDArray[Any])
+assert_type(AR_f8.cumprod(out=B), SubClass)
+
+assert_type(f8.cumsum(), npt.NDArray[Any])
+assert_type(AR_f8.cumsum(), npt.NDArray[Any])
+assert_type(AR_f8.cumsum(out=B), SubClass)
+
+assert_type(f8.max(), Any)
+assert_type(AR_f8.max(), Any)
+assert_type(AR_f8.max(axis=0), Any)
+assert_type(AR_f8.max(keepdims=True), Any)
+assert_type(AR_f8.max(out=B), SubClass)
+
+assert_type(f8.mean(), Any)
+assert_type(AR_f8.mean(), Any)
+assert_type(AR_f8.mean(axis=0), Any)
+assert_type(AR_f8.mean(keepdims=True), Any)
+assert_type(AR_f8.mean(out=B), SubClass)
+
+assert_type(f8.min(), Any)
+assert_type(AR_f8.min(), Any)
+assert_type(AR_f8.min(axis=0), Any)
+assert_type(AR_f8.min(keepdims=True), Any)
+assert_type(AR_f8.min(out=B), SubClass)
+
+assert_type(f8.prod(), Any)
+assert_type(AR_f8.prod(), Any)
+assert_type(AR_f8.prod(axis=0), Any)
+assert_type(AR_f8.prod(keepdims=True), Any)
+assert_type(AR_f8.prod(out=B), SubClass)
+
+assert_type(f8.round(), np.float64)
+assert_type(AR_f8.round(), npt.NDArray[np.float64])
+assert_type(AR_f8.round(out=B), SubClass)
+
+assert_type(f8.repeat(1), npt.NDArray[np.float64])
+assert_type(AR_f8.repeat(1), npt.NDArray[np.float64])
+assert_type(B.repeat(1), npt.NDArray[np.object_])
+
+assert_type(f8.std(), Any)
+assert_type(AR_f8.std(), Any)
+assert_type(AR_f8.std(axis=0), Any)
+assert_type(AR_f8.std(keepdims=True), Any)
+assert_type(AR_f8.std(out=B), SubClass)
+
+assert_type(f8.sum(), Any)
+assert_type(AR_f8.sum(), Any)
+assert_type(AR_f8.sum(axis=0), Any)
+assert_type(AR_f8.sum(keepdims=True), Any)
+assert_type(AR_f8.sum(out=B), SubClass)
+
+assert_type(f8.take(0), np.float64)
+assert_type(AR_f8.take(0), np.float64)
+assert_type(AR_f8.take([0]), npt.NDArray[np.float64])
+assert_type(AR_f8.take(0, out=B), SubClass)
+assert_type(AR_f8.take([0], out=B), SubClass)
+
+assert_type(f8.var(), Any)
+assert_type(AR_f8.var(), Any)
+assert_type(AR_f8.var(axis=0), Any)
+assert_type(AR_f8.var(keepdims=True), Any)
+assert_type(AR_f8.var(out=B), SubClass)
+
+assert_type(AR_f8.argpartition([0]), npt.NDArray[np.intp])
+
+assert_type(AR_f8.diagonal(), npt.NDArray[np.float64])
+
+assert_type(AR_f8.dot(1), npt.NDArray[Any])
+assert_type(AR_f8.dot([1]), Any)
+assert_type(AR_f8.dot(1, out=B), SubClass)
+
+assert_type(AR_f8.nonzero(), tuple[npt.NDArray[np.intp], ...])
+
+assert_type(AR_f8.searchsorted(1), np.intp)
+assert_type(AR_f8.searchsorted([1]), npt.NDArray[np.intp])
+
+assert_type(AR_f8.trace(), Any)
+assert_type(AR_f8.trace(out=B), SubClass)
+
+assert_type(AR_f8.item(), float)
+assert_type(AR_U.item(), str)
+
+assert_type(AR_f8.ravel(), npt.NDArray[np.float64])
+assert_type(AR_U.ravel(), npt.NDArray[np.str_])
+
+assert_type(AR_f8.flatten(), npt.NDArray[np.float64])
+assert_type(AR_U.flatten(), npt.NDArray[np.str_])
+
+assert_type(AR_f8.reshape(1), npt.NDArray[np.float64])
+assert_type(AR_U.reshape(1), npt.NDArray[np.str_])
+
+assert_type(int(AR_f8), int)
+assert_type(int(AR_U), int)
+
+assert_type(float(AR_f8), float)
+assert_type(float(AR_U), float)
+
+assert_type(complex(AR_f8), complex)
+
+assert_type(operator.index(AR_i8), int)
+
+assert_type(AR_f8.__array_wrap__(B), npt.NDArray[np.object_])
+
+assert_type(AR_V[0], Any)
+assert_type(AR_V[0, 0], Any)
+assert_type(AR_V[AR_i8], npt.NDArray[np.void])
+assert_type(AR_V[AR_i8, AR_i8], npt.NDArray[np.void])
+assert_type(AR_V[AR_i8, None], npt.NDArray[np.void])
+assert_type(AR_V[0, ...], npt.NDArray[np.void])
+assert_type(AR_V[[0]], npt.NDArray[np.void])
+assert_type(AR_V[[0], [0]], npt.NDArray[np.void])
+assert_type(AR_V[:], npt.NDArray[np.void])
+assert_type(AR_V["a"], npt.NDArray[Any])
+assert_type(AR_V[["a", "b"]], npt.NDArray[np.void])
+
+assert_type(AR_f8.dump("test_file"), None)
+assert_type(AR_f8.dump(b"test_file"), None)
+with open("test_file", "wb") as f:
+    assert_type(AR_f8.dump(f), None)
+
+assert_type(AR_f8.__array_finalize__(None), None)
+assert_type(AR_f8.__array_finalize__(B), None)
+assert_type(AR_f8.__array_finalize__(AR_f8), None)
+
+assert_type(f8.device, Literal["cpu"])
+assert_type(AR_f8.device, Literal["cpu"])
+
+assert_type(f8.to_device("cpu"), np.float64)
+assert_type(i8.to_device("cpu"), np.int64)
+assert_type(AR_f8.to_device("cpu"), npt.NDArray[np.float64])
+assert_type(AR_i8.to_device("cpu"), npt.NDArray[np.int64])
+assert_type(AR_u1.to_device("cpu"), npt.NDArray[np.uint8])
+assert_type(AR_c8.to_device("cpu"), npt.NDArray[np.complex64])
+assert_type(AR_m.to_device("cpu"), npt.NDArray[np.timedelta64])
+
+assert_type(f8.__array_namespace__(), Any)
+assert_type(AR_f8.__array_namespace__(), Any)
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/ndarray_shape_manipulation.pyi b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/ndarray_shape_manipulation.pyi
new file mode 100644
index 00000000..9a41a90f
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/ndarray_shape_manipulation.pyi
@@ -0,0 +1,44 @@
+import sys
+from typing import Any
+
+import numpy as np
+import numpy.typing as npt
+
+if sys.version_info >= (3, 11):
+    from typing import assert_type
+else:
+    from typing_extensions import assert_type
+
+nd: npt.NDArray[np.int64]
+
+# reshape
+assert_type(nd.reshape(), npt.NDArray[np.int64])
+assert_type(nd.reshape(4), npt.NDArray[np.int64])
+assert_type(nd.reshape(2, 2), npt.NDArray[np.int64])
+assert_type(nd.reshape((2, 2)), npt.NDArray[np.int64])
+
+assert_type(nd.reshape((2, 2), order="C"), npt.NDArray[np.int64])
+assert_type(nd.reshape(4, order="C"), npt.NDArray[np.int64])
+
+# resize does not return a value
+
+# transpose
+assert_type(nd.transpose(), npt.NDArray[np.int64])
+assert_type(nd.transpose(1, 0), npt.NDArray[np.int64])
+assert_type(nd.transpose((1, 0)), npt.NDArray[np.int64])
+
+# swapaxes
+assert_type(nd.swapaxes(0, 1), npt.NDArray[np.int64])
+
+# flatten
+assert_type(nd.flatten(), npt.NDArray[np.int64])
+assert_type(nd.flatten("C"), npt.NDArray[np.int64])
+
+# ravel
+assert_type(nd.ravel(), npt.NDArray[np.int64])
+assert_type(nd.ravel("C"), npt.NDArray[np.int64])
+
+# squeeze
+assert_type(nd.squeeze(), npt.NDArray[np.int64])
+assert_type(nd.squeeze(0), npt.NDArray[np.int64])
+assert_type(nd.squeeze((0, 2)), npt.NDArray[np.int64])
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/nditer.pyi b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/nditer.pyi
new file mode 100644
index 00000000..589453e7
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/nditer.pyi
@@ -0,0 +1,55 @@
+import sys
+from typing import Any
+
+import numpy as np
+import numpy.typing as npt
+
+if sys.version_info >= (3, 11):
+    from typing import assert_type
+else:
+    from typing_extensions import assert_type
+
+nditer_obj: np.nditer
+
+assert_type(np.nditer([0, 1], flags=["c_index"]), np.nditer)
+assert_type(np.nditer([0, 1], op_flags=[["readonly", "readonly"]]), np.nditer)
+assert_type(np.nditer([0, 1], op_dtypes=np.int_), np.nditer)
+assert_type(np.nditer([0, 1], order="C", casting="no"), np.nditer)
+
+assert_type(nditer_obj.dtypes, tuple[np.dtype[Any], ...])
+assert_type(nditer_obj.finished, bool)
+assert_type(nditer_obj.has_delayed_bufalloc, bool)
+assert_type(nditer_obj.has_index, bool)
+assert_type(nditer_obj.has_multi_index, bool)
+assert_type(nditer_obj.index, int)
+assert_type(nditer_obj.iterationneedsapi, bool)
+assert_type(nditer_obj.iterindex, int)
+assert_type(nditer_obj.iterrange, tuple[int, ...])
+assert_type(nditer_obj.itersize, int)
+assert_type(nditer_obj.itviews, tuple[npt.NDArray[Any], ...])
+assert_type(nditer_obj.multi_index, tuple[int, ...])
+assert_type(nditer_obj.ndim, int)
+assert_type(nditer_obj.nop, int)
+assert_type(nditer_obj.operands, tuple[npt.NDArray[Any], ...])
+assert_type(nditer_obj.shape, tuple[int, ...])
+assert_type(nditer_obj.value, tuple[npt.NDArray[Any], ...])
+
+assert_type(nditer_obj.close(), None)
+assert_type(nditer_obj.copy(), np.nditer)
+assert_type(nditer_obj.debug_print(), None)
+assert_type(nditer_obj.enable_external_loop(), None)
+assert_type(nditer_obj.iternext(), bool)
+assert_type(nditer_obj.remove_axis(0), None)
+assert_type(nditer_obj.remove_multi_index(), None)
+assert_type(nditer_obj.reset(), None)
+
+assert_type(len(nditer_obj), int)
+assert_type(iter(nditer_obj), np.nditer)
+assert_type(next(nditer_obj), tuple[npt.NDArray[Any], ...])
+assert_type(nditer_obj.__copy__(), np.nditer)
+with nditer_obj as f:
+    assert_type(f, np.nditer)
+assert_type(nditer_obj[0], npt.NDArray[Any])
+assert_type(nditer_obj[:], tuple[npt.NDArray[Any], ...])
+nditer_obj[0] = 0
+nditer_obj[:] = [0, 1]
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/nested_sequence.pyi b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/nested_sequence.pyi
new file mode 100644
index 00000000..3ca23d68
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/nested_sequence.pyi
@@ -0,0 +1,32 @@
+import sys
+from collections.abc import Sequence
+from typing import Any
+
+from numpy._typing import _NestedSequence
+
+if sys.version_info >= (3, 11):
+    from typing import assert_type
+else:
+    from typing_extensions import assert_type
+
+a: Sequence[int]
+b: Sequence[Sequence[int]]
+c: Sequence[Sequence[Sequence[int]]]
+d: Sequence[Sequence[Sequence[Sequence[int]]]]
+e: Sequence[bool]
+f: tuple[int, ...]
+g: list[int]
+h: Sequence[Any]
+
+def func(a: _NestedSequence[int]) -> None:
+    ...
+
+assert_type(func(a), None)
+assert_type(func(b), None)
+assert_type(func(c), None)
+assert_type(func(d), None)
+assert_type(func(e), None)
+assert_type(func(f), None)
+assert_type(func(g), None)
+assert_type(func(h), None)
+assert_type(func(range(15)), None)
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/npyio.pyi b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/npyio.pyi
new file mode 100644
index 00000000..1267b281
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/npyio.pyi
@@ -0,0 +1,89 @@
+import re
+import sys
+import zipfile
+import pathlib
+from typing import IO, Any
+from collections.abc import Mapping
+
+import numpy.typing as npt
+import numpy as np
+from numpy.lib._npyio_impl import BagObj
+
+if sys.version_info >= (3, 11):
+    from typing import assert_type
+else:
+    from typing_extensions import assert_type
+
+str_path: str
+pathlib_path: pathlib.Path
+str_file: IO[str]
+bytes_file: IO[bytes]
+
+npz_file: np.lib.npyio.NpzFile
+
+AR_i8: npt.NDArray[np.int64]
+AR_LIKE_f8: list[float]
+
+class BytesWriter:
+    def write(self, data: bytes) -> None: ...
+
+class BytesReader:
+    def read(self, n: int = ...) -> bytes: ...
+    def seek(self, offset: int, whence: int = ...) -> int: ...
+
+bytes_writer: BytesWriter
+bytes_reader: BytesReader
+
+assert_type(npz_file.zip, zipfile.ZipFile)
+assert_type(npz_file.fid, None | IO[str])
+assert_type(npz_file.files, list[str])
+assert_type(npz_file.allow_pickle, bool)
+assert_type(npz_file.pickle_kwargs, None | Mapping[str, Any])
+assert_type(npz_file.f, BagObj[np.lib.npyio.NpzFile])
+assert_type(npz_file["test"], npt.NDArray[Any])
+assert_type(len(npz_file), int)
+with npz_file as f:
+    assert_type(f, np.lib.npyio.NpzFile)
+
+assert_type(np.load(bytes_file), Any)
+assert_type(np.load(pathlib_path, allow_pickle=True), Any)
+assert_type(np.load(str_path, encoding="bytes"), Any)
+assert_type(np.load(bytes_reader), Any)
+
+assert_type(np.save(bytes_file, AR_LIKE_f8), None)
+assert_type(np.save(pathlib_path, AR_i8, allow_pickle=True), None)
+assert_type(np.save(str_path, AR_LIKE_f8), None)
+assert_type(np.save(bytes_writer, AR_LIKE_f8), None)
+
+assert_type(np.savez(bytes_file, AR_LIKE_f8), None)
+assert_type(np.savez(pathlib_path, ar1=AR_i8, ar2=AR_i8), None)
+assert_type(np.savez(str_path, AR_LIKE_f8, ar1=AR_i8), None)
+assert_type(np.savez(bytes_writer, AR_LIKE_f8, ar1=AR_i8), None)
+
+assert_type(np.savez_compressed(bytes_file, AR_LIKE_f8), None)
+assert_type(np.savez_compressed(pathlib_path, ar1=AR_i8, ar2=AR_i8), None)
+assert_type(np.savez_compressed(str_path, AR_LIKE_f8, ar1=AR_i8), None)
+assert_type(np.savez_compressed(bytes_writer, AR_LIKE_f8, ar1=AR_i8), None)
+
+assert_type(np.loadtxt(bytes_file), npt.NDArray[np.float64])
+assert_type(np.loadtxt(pathlib_path, dtype=np.str_), npt.NDArray[np.str_])
+assert_type(np.loadtxt(str_path, dtype=str, skiprows=2), npt.NDArray[Any])
+assert_type(np.loadtxt(str_file, comments="test"), npt.NDArray[np.float64])
+assert_type(np.loadtxt(str_file, comments=None), npt.NDArray[np.float64])
+assert_type(np.loadtxt(str_path, delimiter="\n"), npt.NDArray[np.float64])
+assert_type(np.loadtxt(str_path, ndmin=2), npt.NDArray[np.float64])
+assert_type(np.loadtxt(["1", "2", "3"]), npt.NDArray[np.float64])
+
+assert_type(np.fromregex(bytes_file, "test", np.float64), npt.NDArray[np.float64])
+assert_type(np.fromregex(str_file, b"test", dtype=float), npt.NDArray[Any])
+assert_type(np.fromregex(str_path, re.compile("test"), dtype=np.str_, encoding="utf8"), npt.NDArray[np.str_])
+assert_type(np.fromregex(pathlib_path, "test", np.float64), npt.NDArray[np.float64])
+assert_type(np.fromregex(bytes_reader, "test", np.float64), npt.NDArray[np.float64])
+
+assert_type(np.genfromtxt(bytes_file), npt.NDArray[Any])
+assert_type(np.genfromtxt(pathlib_path, dtype=np.str_), npt.NDArray[np.str_])
+assert_type(np.genfromtxt(str_path, dtype=str, skip_header=2), npt.NDArray[Any])
+assert_type(np.genfromtxt(str_file, comments="test"), npt.NDArray[Any])
+assert_type(np.genfromtxt(str_path, delimiter="\n"), npt.NDArray[Any])
+assert_type(np.genfromtxt(str_path, ndmin=2), npt.NDArray[Any])
+assert_type(np.genfromtxt(["1", "2", "3"], ndmin=2), npt.NDArray[Any])
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/numeric.pyi b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/numeric.pyi
new file mode 100644
index 00000000..1f0a8b36
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/numeric.pyi
@@ -0,0 +1,141 @@
+"""
+Tests for :mod:`_core.numeric`.
+
+Does not include tests which fall under ``array_constructors``.
+
+"""
+
+import sys
+from typing import Any
+
+import numpy as np
+import numpy.typing as npt
+
+if sys.version_info >= (3, 11):
+    from typing import assert_type
+else:
+    from typing_extensions import assert_type
+
+class SubClass(npt.NDArray[np.int64]):
+    ...
+
+i8: np.int64
+
+AR_b: npt.NDArray[np.bool]
+AR_u8: npt.NDArray[np.uint64]
+AR_i8: npt.NDArray[np.int64]
+AR_f8: npt.NDArray[np.float64]
+AR_c16: npt.NDArray[np.complex128]
+AR_m: npt.NDArray[np.timedelta64]
+AR_O: npt.NDArray[np.object_]
+
+B: list[int]
+C: SubClass
+
+assert_type(np.count_nonzero(i8), int)
+assert_type(np.count_nonzero(AR_i8), int)
+assert_type(np.count_nonzero(B), int)
+assert_type(np.count_nonzero(AR_i8, keepdims=True), Any)
+assert_type(np.count_nonzero(AR_i8, axis=0), Any)
+
+assert_type(np.isfortran(i8), bool)
+assert_type(np.isfortran(AR_i8), bool)
+
+assert_type(np.argwhere(i8), npt.NDArray[np.intp])
+assert_type(np.argwhere(AR_i8), npt.NDArray[np.intp])
+
+assert_type(np.flatnonzero(i8), npt.NDArray[np.intp])
+assert_type(np.flatnonzero(AR_i8), npt.NDArray[np.intp])
+
+assert_type(np.correlate(B, AR_i8, mode="valid"), npt.NDArray[np.signedinteger[Any]])
+assert_type(np.correlate(AR_i8, AR_i8, mode="same"), npt.NDArray[np.signedinteger[Any]])
+assert_type(np.correlate(AR_b, AR_b), npt.NDArray[np.bool])
+assert_type(np.correlate(AR_b, AR_u8), npt.NDArray[np.unsignedinteger[Any]])
+assert_type(np.correlate(AR_i8, AR_b), npt.NDArray[np.signedinteger[Any]])
+assert_type(np.correlate(AR_i8, AR_f8), npt.NDArray[np.floating[Any]])
+assert_type(np.correlate(AR_i8, AR_c16), npt.NDArray[np.complexfloating[Any, Any]])
+assert_type(np.correlate(AR_i8, AR_m), npt.NDArray[np.timedelta64])
+assert_type(np.correlate(AR_O, AR_O), npt.NDArray[np.object_])
+
+assert_type(np.convolve(B, AR_i8, mode="valid"), npt.NDArray[np.signedinteger[Any]])
+assert_type(np.convolve(AR_i8, AR_i8, mode="same"), npt.NDArray[np.signedinteger[Any]])
+assert_type(np.convolve(AR_b, AR_b), npt.NDArray[np.bool])
+assert_type(np.convolve(AR_b, AR_u8), npt.NDArray[np.unsignedinteger[Any]])
+assert_type(np.convolve(AR_i8, AR_b), npt.NDArray[np.signedinteger[Any]])
+assert_type(np.convolve(AR_i8, AR_f8), npt.NDArray[np.floating[Any]])
+assert_type(np.convolve(AR_i8, AR_c16), npt.NDArray[np.complexfloating[Any, Any]])
+assert_type(np.convolve(AR_i8, AR_m), npt.NDArray[np.timedelta64])
+assert_type(np.convolve(AR_O, AR_O), npt.NDArray[np.object_])
+
+assert_type(np.outer(i8, AR_i8), npt.NDArray[np.signedinteger[Any]])
+assert_type(np.outer(B, AR_i8), npt.NDArray[np.signedinteger[Any]])
+assert_type(np.outer(AR_i8, AR_i8), npt.NDArray[np.signedinteger[Any]])
+assert_type(np.outer(AR_i8, AR_i8, out=C), SubClass)
+assert_type(np.outer(AR_b, AR_b), npt.NDArray[np.bool])
+assert_type(np.outer(AR_b, AR_u8), npt.NDArray[np.unsignedinteger[Any]])
+assert_type(np.outer(AR_i8, AR_b), npt.NDArray[np.signedinteger[Any]])
+assert_type(np.convolve(AR_i8, AR_f8), npt.NDArray[np.floating[Any]])
+assert_type(np.outer(AR_i8, AR_c16), npt.NDArray[np.complexfloating[Any, Any]])
+assert_type(np.outer(AR_i8, AR_m), npt.NDArray[np.timedelta64])
+assert_type(np.outer(AR_O, AR_O), npt.NDArray[np.object_])
+
+assert_type(np.tensordot(B, AR_i8), npt.NDArray[np.signedinteger[Any]])
+assert_type(np.tensordot(AR_i8, AR_i8), npt.NDArray[np.signedinteger[Any]])
+assert_type(np.tensordot(AR_i8, AR_i8, axes=0), npt.NDArray[np.signedinteger[Any]])
+assert_type(np.tensordot(AR_i8, AR_i8, axes=(0, 1)), npt.NDArray[np.signedinteger[Any]])
+assert_type(np.tensordot(AR_b, AR_b), npt.NDArray[np.bool])
+assert_type(np.tensordot(AR_b, AR_u8), npt.NDArray[np.unsignedinteger[Any]])
+assert_type(np.tensordot(AR_i8, AR_b), npt.NDArray[np.signedinteger[Any]])
+assert_type(np.tensordot(AR_i8, AR_f8), npt.NDArray[np.floating[Any]])
+assert_type(np.tensordot(AR_i8, AR_c16), npt.NDArray[np.complexfloating[Any, Any]])
+assert_type(np.tensordot(AR_i8, AR_m), npt.NDArray[np.timedelta64])
+assert_type(np.tensordot(AR_O, AR_O), npt.NDArray[np.object_])
+
+assert_type(np.isscalar(i8), bool)
+assert_type(np.isscalar(AR_i8), bool)
+assert_type(np.isscalar(B), bool)
+
+assert_type(np.roll(AR_i8, 1), npt.NDArray[np.int64])
+assert_type(np.roll(AR_i8, (1, 2)), npt.NDArray[np.int64])
+assert_type(np.roll(B, 1), npt.NDArray[Any])
+
+assert_type(np.rollaxis(AR_i8, 0, 1), npt.NDArray[np.int64])
+
+assert_type(np.moveaxis(AR_i8, 0, 1), npt.NDArray[np.int64])
+assert_type(np.moveaxis(AR_i8, (0, 1), (1, 2)), npt.NDArray[np.int64])
+
+assert_type(np.cross(B, AR_i8), npt.NDArray[np.signedinteger[Any]])
+assert_type(np.cross(AR_i8, AR_i8), npt.NDArray[np.signedinteger[Any]])
+assert_type(np.cross(AR_b, AR_u8), npt.NDArray[np.unsignedinteger[Any]])
+assert_type(np.cross(AR_i8, AR_b), npt.NDArray[np.signedinteger[Any]])
+assert_type(np.cross(AR_i8, AR_f8), npt.NDArray[np.floating[Any]])
+assert_type(np.cross(AR_i8, AR_c16), npt.NDArray[np.complexfloating[Any, Any]])
+assert_type(np.cross(AR_O, AR_O), npt.NDArray[np.object_])
+
+assert_type(np.indices([0, 1, 2]), npt.NDArray[np.int_])
+assert_type(np.indices([0, 1, 2], sparse=True), tuple[npt.NDArray[np.int_], ...])
+assert_type(np.indices([0, 1, 2], dtype=np.float64), npt.NDArray[np.float64])
+assert_type(np.indices([0, 1, 2], sparse=True, dtype=np.float64), tuple[npt.NDArray[np.float64], ...])
+assert_type(np.indices([0, 1, 2], dtype=float), npt.NDArray[Any])
+assert_type(np.indices([0, 1, 2], sparse=True, dtype=float), tuple[npt.NDArray[Any], ...])
+
+assert_type(np.binary_repr(1), str)
+
+assert_type(np.base_repr(1), str)
+
+assert_type(np.allclose(i8, AR_i8), bool)
+assert_type(np.allclose(B, AR_i8), bool)
+assert_type(np.allclose(AR_i8, AR_i8), bool)
+
+assert_type(np.isclose(i8, i8), np.bool)
+assert_type(np.isclose(i8, AR_i8), npt.NDArray[np.bool])
+assert_type(np.isclose(B, AR_i8), npt.NDArray[np.bool])
+assert_type(np.isclose(AR_i8, AR_i8), npt.NDArray[np.bool])
+
+assert_type(np.array_equal(i8, AR_i8), bool)
+assert_type(np.array_equal(B, AR_i8), bool)
+assert_type(np.array_equal(AR_i8, AR_i8), bool)
+
+assert_type(np.array_equiv(i8, AR_i8), bool)
+assert_type(np.array_equiv(B, AR_i8), bool)
+assert_type(np.array_equiv(AR_i8, AR_i8), bool)
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/numerictypes.pyi b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/numerictypes.pyi
new file mode 100644
index 00000000..cf558ddc
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/numerictypes.pyi
@@ -0,0 +1,55 @@
+import sys
+from typing import Literal
+
+import numpy as np
+
+if sys.version_info >= (3, 11):
+    from typing import assert_type
+else:
+    from typing_extensions import assert_type
+
+assert_type(
+    np.ScalarType,
+    tuple[
+        type[int],
+        type[float],
+        type[complex],
+        type[bool],
+        type[bytes],
+        type[str],
+        type[memoryview],
+        type[np.bool],
+        type[np.csingle],
+        type[np.cdouble],
+        type[np.clongdouble],
+        type[np.half],
+        type[np.single],
+        type[np.double],
+        type[np.longdouble],
+        type[np.byte],
+        type[np.short],
+        type[np.intc],
+        type[np.long],
+        type[np.longlong],
+        type[np.timedelta64],
+        type[np.datetime64],
+        type[np.object_],
+        type[np.bytes_],
+        type[np.str_],
+        type[np.ubyte],
+        type[np.ushort],
+        type[np.uintc],
+        type[np.ulong],
+        type[np.ulonglong],
+        type[np.void],
+    ],
+)
+assert_type(np.ScalarType[0], type[int])
+assert_type(np.ScalarType[3], type[bool])
+assert_type(np.ScalarType[8], type[np.csingle])
+assert_type(np.ScalarType[10], type[np.clongdouble])
+assert_type(np.bool_, type[np.bool])
+
+assert_type(np.typecodes["Character"], Literal["c"])
+assert_type(np.typecodes["Complex"], Literal["FDG"])
+assert_type(np.typecodes["All"], Literal["?bhilqnpBHILQNPefdgFDGSUVOMm"])
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/polynomial_polybase.pyi b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/polynomial_polybase.pyi
new file mode 100644
index 00000000..60e92709
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/polynomial_polybase.pyi
@@ -0,0 +1,225 @@
+from fractions import Fraction
+import sys
+from collections.abc import Sequence
+from decimal import Decimal
+from typing import Any, Literal as L, TypeAlias, TypeVar
+
+import numpy as np
+import numpy.polynomial as npp
+import numpy.typing as npt
+
+if sys.version_info >= (3, 11):
+    from typing import LiteralString, assert_type
+else:
+    from typing_extensions import LiteralString, assert_type
+
+_Ar_x: TypeAlias = npt.NDArray[np.inexact[Any] | np.object_]
+_Ar_f: TypeAlias = npt.NDArray[np.floating[Any]]
+_Ar_c: TypeAlias = npt.NDArray[np.complexfloating[Any, Any]]
+_Ar_O: TypeAlias = npt.NDArray[np.object_]
+
+_Ar_x_n: TypeAlias = np.ndarray[tuple[int], np.dtype[np.inexact[Any] | np.object_]]
+_Ar_f_n: TypeAlias = np.ndarray[tuple[int], np.dtype[np.floating[Any]]]
+_Ar_c_n: TypeAlias = np.ndarray[tuple[int], np.dtype[np.complexfloating[Any, Any]]]
+_Ar_O_n: TypeAlias = np.ndarray[tuple[int], np.dtype[np.object_]]
+
+_Ar_x_2: TypeAlias = np.ndarray[tuple[L[2]], np.dtype[np.inexact[Any] | np.object_]]
+_Ar_f_2: TypeAlias = np.ndarray[tuple[L[2]], np.dtype[np.floating[Any]]]
+_Ar_c_2: TypeAlias = np.ndarray[tuple[L[2]], np.dtype[np.complexfloating[Any, Any]]]
+_Ar_O_2: TypeAlias = np.ndarray[tuple[L[2]], np.dtype[np.object_]]
+
+_SCT = TypeVar("_SCT", bound=np.generic)
+_Ar_1d: TypeAlias = np.ndarray[tuple[int], np.dtype[_SCT]]
+
+_BasisName: TypeAlias = L["X"]
+
+SC_i: np.int_
+SC_i_co: int | np.int_
+SC_f: np.float64
+SC_f_co: float | np.float64 | np.int_
+SC_c: np.complex128
+SC_c_co: complex | np.complex128
+SC_O: Decimal
+
+AR_i: npt.NDArray[np.int_]
+AR_f: npt.NDArray[np.float64]
+AR_f_co: npt.NDArray[np.float64] | npt.NDArray[np.int_]
+AR_c: npt.NDArray[np.complex128]
+AR_c_co: npt.NDArray[np.complex128] |npt.NDArray[np.float64] | npt.NDArray[np.int_]
+AR_O: npt.NDArray[np.object_]
+AR_O_co: npt.NDArray[np.object_ | np.number[Any]]
+
+SQ_i: Sequence[int]
+SQ_f: Sequence[float]
+SQ_c: Sequence[complex]
+SQ_O: Sequence[Decimal]
+
+PS_poly: npp.Polynomial
+PS_cheb: npp.Chebyshev
+PS_herm: npp.Hermite
+PS_herme: npp.HermiteE
+PS_lag: npp.Laguerre
+PS_leg: npp.Legendre
+PS_all: (
+    npp.Polynomial
+    | npp.Chebyshev
+    | npp.Hermite
+    | npp.HermiteE
+    | npp.Laguerre
+    | npp.Legendre
+)
+
+# static- and classmethods
+
+assert_type(type(PS_poly).basis_name, None)
+assert_type(type(PS_cheb).basis_name, L['T'])
+assert_type(type(PS_herm).basis_name, L['H'])
+assert_type(type(PS_herme).basis_name, L['He'])
+assert_type(type(PS_lag).basis_name, L['L'])
+assert_type(type(PS_leg).basis_name, L['P'])
+
+assert_type(type(PS_all).__hash__, None)
+assert_type(type(PS_all).__array_ufunc__, None)
+assert_type(type(PS_all).maxpower, L[100])
+
+assert_type(type(PS_poly).fromroots(SC_i), npp.Polynomial)
+assert_type(type(PS_poly).fromroots(SQ_i), npp.Polynomial)
+assert_type(type(PS_poly).fromroots(AR_i), npp.Polynomial)
+assert_type(type(PS_cheb).fromroots(SC_f), npp.Chebyshev)
+assert_type(type(PS_cheb).fromroots(SQ_f), npp.Chebyshev)
+assert_type(type(PS_cheb).fromroots(AR_f_co), npp.Chebyshev)
+assert_type(type(PS_herm).fromroots(SC_c), npp.Hermite)
+assert_type(type(PS_herm).fromroots(SQ_c), npp.Hermite)
+assert_type(type(PS_herm).fromroots(AR_c_co), npp.Hermite)
+assert_type(type(PS_leg).fromroots(SC_O), npp.Legendre)
+assert_type(type(PS_leg).fromroots(SQ_O), npp.Legendre)
+assert_type(type(PS_leg).fromroots(AR_O_co), npp.Legendre)
+
+assert_type(type(PS_poly).identity(), npp.Polynomial)
+assert_type(type(PS_cheb).identity(symbol='z'), npp.Chebyshev)
+
+assert_type(type(PS_lag).basis(SC_i), npp.Laguerre)
+assert_type(type(PS_leg).basis(32, symbol='u'), npp.Legendre)
+
+assert_type(type(PS_herm).cast(PS_poly), npp.Hermite)
+assert_type(type(PS_herme).cast(PS_leg), npp.HermiteE)
+
+# attributes / properties
+
+assert_type(PS_all.coef, _Ar_x_n)
+assert_type(PS_all.domain, _Ar_x_2)
+assert_type(PS_all.window, _Ar_x_2)
+assert_type(PS_all.symbol, LiteralString)
+
+# instance methods
+
+assert_type(PS_all.has_samecoef(PS_all), bool)
+assert_type(PS_all.has_samedomain(PS_all), bool)
+assert_type(PS_all.has_samewindow(PS_all), bool)
+assert_type(PS_all.has_sametype(PS_all), bool)
+assert_type(PS_poly.has_sametype(PS_poly), bool)
+assert_type(PS_poly.has_sametype(PS_leg), bool)
+assert_type(PS_poly.has_sametype(NotADirectoryError), L[False])
+
+assert_type(PS_poly.copy(), npp.Polynomial)
+assert_type(PS_cheb.copy(), npp.Chebyshev)
+assert_type(PS_herm.copy(), npp.Hermite)
+assert_type(PS_herme.copy(), npp.HermiteE)
+assert_type(PS_lag.copy(), npp.Laguerre)
+assert_type(PS_leg.copy(), npp.Legendre)
+
+assert_type(PS_leg.cutdeg(), npp.Legendre)
+assert_type(PS_leg.trim(), npp.Legendre)
+assert_type(PS_leg.trim(tol=SC_f_co), npp.Legendre)
+assert_type(PS_leg.truncate(SC_i_co), npp.Legendre)
+
+assert_type(PS_all.convert(None, npp.Chebyshev), npp.Chebyshev)
+assert_type(PS_all.convert((0, 1), npp.Laguerre), npp.Laguerre)
+assert_type(PS_all.convert([0, 1], npp.Hermite, [-1, 1]), npp.Hermite)
+
+assert_type(PS_all.degree(), int)
+assert_type(PS_all.mapparms(), tuple[Any, Any])
+
+assert_type(PS_poly.integ(), npp.Polynomial)
+assert_type(PS_herme.integ(SC_i_co), npp.HermiteE)
+assert_type(PS_lag.integ(SC_i_co, SC_f_co), npp.Laguerre)
+assert_type(PS_poly.deriv(), npp.Polynomial)
+assert_type(PS_herm.deriv(SC_i_co), npp.Hermite)
+
+assert_type(PS_poly.roots(), _Ar_x_n)
+
+assert_type(
+    PS_poly.linspace(),
+    tuple[_Ar_1d[np.float64 | np.complex128], _Ar_1d[np.float64 | np.complex128]],
+)
+
+assert_type(
+    PS_poly.linspace(9),
+    tuple[_Ar_1d[np.float64 | np.complex128], _Ar_1d[np.float64 | np.complex128]],
+)
+
+assert_type(PS_cheb.fit(AR_c_co, AR_c_co, SC_i_co), npp.Chebyshev)
+assert_type(PS_leg.fit(AR_c_co, AR_c_co, AR_i), npp.Legendre)
+assert_type(PS_herm.fit(AR_c_co, AR_c_co, SQ_i), npp.Hermite)
+assert_type(PS_poly.fit(AR_c_co, SQ_c, SQ_i), npp.Polynomial)
+assert_type(PS_lag.fit(SQ_c, SQ_c, SQ_i, full=False), npp.Laguerre)
+assert_type(
+    PS_herme.fit(SQ_c, AR_c_co, SC_i_co, full=True),
+    tuple[npp.HermiteE, Sequence[np.inexact[Any] | np.int32]],
+)
+
+# custom operations
+
+assert_type(PS_all.__hash__, None)
+assert_type(PS_all.__array_ufunc__, None)
+
+assert_type(str(PS_all), str)
+assert_type(repr(PS_all), str)
+assert_type(format(PS_all), str)
+
+assert_type(len(PS_all), int)
+assert_type(next(iter(PS_all)), np.inexact[Any] | object)
+
+assert_type(PS_all(SC_f_co), np.float64 | np.complex128)
+assert_type(PS_all(SC_c_co), np.complex128)
+assert_type(PS_all(Decimal()), np.float64 | np.complex128)
+assert_type(PS_all(Fraction()), np.float64 | np.complex128)
+assert_type(PS_poly(SQ_f), npt.NDArray[np.float64] | npt.NDArray[np.complex128] | npt.NDArray[np.object_])
+assert_type(PS_poly(SQ_c), npt.NDArray[np.complex128] | npt.NDArray[np.object_])
+assert_type(PS_poly(SQ_O), npt.NDArray[np.object_])
+assert_type(PS_poly(AR_f), npt.NDArray[np.float64] | npt.NDArray[np.complex128] | npt.NDArray[np.object_])
+assert_type(PS_poly(AR_c), npt.NDArray[np.complex128] | npt.NDArray[np.object_])
+assert_type(PS_poly(AR_O), npt.NDArray[np.object_])
+assert_type(PS_all(PS_poly), npp.Polynomial)
+
+assert_type(PS_poly == PS_poly, bool)
+assert_type(PS_poly != PS_poly, bool)
+
+assert_type(-PS_poly, npp.Polynomial)
+assert_type(+PS_poly, npp.Polynomial)
+
+assert_type(PS_poly + 5, npp.Polynomial)
+assert_type(PS_poly - 5, npp.Polynomial)
+assert_type(PS_poly * 5, npp.Polynomial)
+assert_type(PS_poly / 5, npp.Polynomial)
+assert_type(PS_poly // 5, npp.Polynomial)
+assert_type(PS_poly % 5, npp.Polynomial)
+
+assert_type(PS_poly + PS_leg, npp.Polynomial)
+assert_type(PS_poly - PS_leg, npp.Polynomial)
+assert_type(PS_poly * PS_leg, npp.Polynomial)
+assert_type(PS_poly / PS_leg, npp.Polynomial)
+assert_type(PS_poly // PS_leg, npp.Polynomial)
+assert_type(PS_poly % PS_leg, npp.Polynomial)
+
+assert_type(5 + PS_poly, npp.Polynomial)
+assert_type(5 - PS_poly, npp.Polynomial)
+assert_type(5 * PS_poly, npp.Polynomial)
+assert_type(5 / PS_poly, npp.Polynomial)
+assert_type(5 // PS_poly, npp.Polynomial)
+assert_type(5 % PS_poly, npp.Polynomial)
+assert_type(divmod(PS_poly, 5), tuple[npp.Polynomial, npp.Polynomial])
+assert_type(divmod(5, PS_poly), tuple[npp.Polynomial, npp.Polynomial])
+
+assert_type(PS_poly**1, npp.Polynomial)
+assert_type(PS_poly**1.0, npp.Polynomial)
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/polynomial_polyutils.pyi b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/polynomial_polyutils.pyi
new file mode 100644
index 00000000..eecdb14e
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/polynomial_polyutils.pyi
@@ -0,0 +1,224 @@
+import sys
+from collections.abc import Sequence
+from decimal import Decimal
+from fractions import Fraction
+from typing import Any, Literal as L, TypeAlias
+
+import numpy as np
+import numpy.typing as npt
+import numpy.polynomial.polyutils as pu
+from numpy.polynomial._polytypes import _Tuple2
+
+if sys.version_info >= (3, 11):
+    from typing import assert_type
+else:
+    from typing_extensions import assert_type
+
+_ArrFloat1D: TypeAlias = np.ndarray[tuple[int], np.dtype[np.floating[Any]]]
+_ArrComplex1D: TypeAlias = np.ndarray[tuple[int], np.dtype[np.complexfloating[Any, Any]]]
+_ArrObject1D: TypeAlias = np.ndarray[tuple[int], np.dtype[np.object_]]
+
+_ArrFloat1D_2: TypeAlias = np.ndarray[tuple[L[2]], np.dtype[np.float64]]
+_ArrComplex1D_2: TypeAlias = np.ndarray[tuple[L[2]], np.dtype[np.complex128]]
+_ArrObject1D_2: TypeAlias = np.ndarray[tuple[L[2]], np.dtype[np.object_]]
+
+num_int: int
+num_float: float
+num_complex: complex
+# will result in an `object_` dtype
+num_object: Decimal | Fraction
+
+sct_int: np.int_
+sct_float: np.float64
+sct_complex: np.complex128
+sct_object: np.object_  # doesn't exist at runtime
+
+arr_int: npt.NDArray[np.int_]
+arr_float: npt.NDArray[np.float64]
+arr_complex: npt.NDArray[np.complex128]
+arr_object: npt.NDArray[np.object_]
+
+seq_num_int: Sequence[int]
+seq_num_float: Sequence[float]
+seq_num_complex: Sequence[complex]
+seq_num_object: Sequence[Decimal | Fraction]
+
+seq_sct_int: Sequence[np.int_]
+seq_sct_float: Sequence[np.float64]
+seq_sct_complex: Sequence[np.complex128]
+seq_sct_object: Sequence[np.object_]
+
+seq_arr_int: Sequence[npt.NDArray[np.int_]]
+seq_arr_float: Sequence[npt.NDArray[np.float64]]
+seq_arr_complex: Sequence[npt.NDArray[np.complex128]]
+seq_arr_object: Sequence[npt.NDArray[np.object_]]
+
+seq_seq_num_int: Sequence[Sequence[int]]
+seq_seq_num_float: Sequence[Sequence[float]]
+seq_seq_num_complex: Sequence[Sequence[complex]]
+seq_seq_num_object: Sequence[Sequence[Decimal | Fraction]]
+
+seq_seq_sct_int: Sequence[Sequence[np.int_]]
+seq_seq_sct_float: Sequence[Sequence[np.float64]]
+seq_seq_sct_complex: Sequence[Sequence[np.complex128]]
+seq_seq_sct_object: Sequence[Sequence[np.object_]]  # doesn't exist at runtime
+
+# as_series
+
+assert_type(pu.as_series(arr_int), list[_ArrFloat1D])
+assert_type(pu.as_series(arr_float), list[_ArrFloat1D])
+assert_type(pu.as_series(arr_complex), list[_ArrComplex1D])
+assert_type(pu.as_series(arr_object), list[_ArrObject1D])
+
+assert_type(pu.as_series(seq_num_int), list[_ArrFloat1D])
+assert_type(pu.as_series(seq_num_float), list[_ArrFloat1D])
+assert_type(pu.as_series(seq_num_complex), list[_ArrComplex1D])
+assert_type(pu.as_series(seq_num_object), list[_ArrObject1D])
+
+assert_type(pu.as_series(seq_sct_int), list[_ArrFloat1D])
+assert_type(pu.as_series(seq_sct_float), list[_ArrFloat1D])
+assert_type(pu.as_series(seq_sct_complex), list[_ArrComplex1D])
+assert_type(pu.as_series(seq_sct_object), list[_ArrObject1D])
+
+assert_type(pu.as_series(seq_arr_int), list[_ArrFloat1D])
+assert_type(pu.as_series(seq_arr_float), list[_ArrFloat1D])
+assert_type(pu.as_series(seq_arr_complex), list[_ArrComplex1D])
+assert_type(pu.as_series(seq_arr_object), list[_ArrObject1D])
+
+assert_type(pu.as_series(seq_seq_num_int), list[_ArrFloat1D])
+assert_type(pu.as_series(seq_seq_num_float), list[_ArrFloat1D])
+assert_type(pu.as_series(seq_seq_num_complex), list[_ArrComplex1D])
+assert_type(pu.as_series(seq_seq_num_object), list[_ArrObject1D])
+
+assert_type(pu.as_series(seq_seq_sct_int), list[_ArrFloat1D])
+assert_type(pu.as_series(seq_seq_sct_float), list[_ArrFloat1D])
+assert_type(pu.as_series(seq_seq_sct_complex), list[_ArrComplex1D])
+assert_type(pu.as_series(seq_seq_sct_object), list[_ArrObject1D])
+
+# trimcoef
+
+assert_type(pu.trimcoef(num_int), _ArrFloat1D)
+assert_type(pu.trimcoef(num_float), _ArrFloat1D)
+assert_type(pu.trimcoef(num_complex), _ArrComplex1D)
+assert_type(pu.trimcoef(num_object), _ArrObject1D)
+assert_type(pu.trimcoef(num_object), _ArrObject1D)
+
+assert_type(pu.trimcoef(sct_int), _ArrFloat1D)
+assert_type(pu.trimcoef(sct_float), _ArrFloat1D)
+assert_type(pu.trimcoef(sct_complex), _ArrComplex1D)
+assert_type(pu.trimcoef(sct_object), _ArrObject1D)
+
+assert_type(pu.trimcoef(arr_int), _ArrFloat1D)
+assert_type(pu.trimcoef(arr_float), _ArrFloat1D)
+assert_type(pu.trimcoef(arr_complex), _ArrComplex1D)
+assert_type(pu.trimcoef(arr_object), _ArrObject1D)
+
+assert_type(pu.trimcoef(seq_num_int), _ArrFloat1D)
+assert_type(pu.trimcoef(seq_num_float), _ArrFloat1D)
+assert_type(pu.trimcoef(seq_num_complex), _ArrComplex1D)
+assert_type(pu.trimcoef(seq_num_object), _ArrObject1D)
+
+assert_type(pu.trimcoef(seq_sct_int), _ArrFloat1D)
+assert_type(pu.trimcoef(seq_sct_float), _ArrFloat1D)
+assert_type(pu.trimcoef(seq_sct_complex), _ArrComplex1D)
+assert_type(pu.trimcoef(seq_sct_object), _ArrObject1D)
+
+# getdomain
+
+assert_type(pu.getdomain(num_int), _ArrFloat1D_2)
+assert_type(pu.getdomain(num_float), _ArrFloat1D_2)
+assert_type(pu.getdomain(num_complex), _ArrComplex1D_2)
+assert_type(pu.getdomain(num_object), _ArrObject1D_2)
+assert_type(pu.getdomain(num_object), _ArrObject1D_2)
+
+assert_type(pu.getdomain(sct_int), _ArrFloat1D_2)
+assert_type(pu.getdomain(sct_float), _ArrFloat1D_2)
+assert_type(pu.getdomain(sct_complex), _ArrComplex1D_2)
+assert_type(pu.getdomain(sct_object), _ArrObject1D_2)
+
+assert_type(pu.getdomain(arr_int), _ArrFloat1D_2)
+assert_type(pu.getdomain(arr_float), _ArrFloat1D_2)
+assert_type(pu.getdomain(arr_complex), _ArrComplex1D_2)
+assert_type(pu.getdomain(arr_object), _ArrObject1D_2)
+
+assert_type(pu.getdomain(seq_num_int), _ArrFloat1D_2)
+assert_type(pu.getdomain(seq_num_float), _ArrFloat1D_2)
+assert_type(pu.getdomain(seq_num_complex), _ArrComplex1D_2)
+assert_type(pu.getdomain(seq_num_object), _ArrObject1D_2)
+
+assert_type(pu.getdomain(seq_sct_int), _ArrFloat1D_2)
+assert_type(pu.getdomain(seq_sct_float), _ArrFloat1D_2)
+assert_type(pu.getdomain(seq_sct_complex), _ArrComplex1D_2)
+assert_type(pu.getdomain(seq_sct_object), _ArrObject1D_2)
+
+# mapparms
+
+assert_type(pu.mapparms(seq_num_int, seq_num_int), _Tuple2[float])
+assert_type(pu.mapparms(seq_num_int, seq_num_float), _Tuple2[float])
+assert_type(pu.mapparms(seq_num_float, seq_num_float), _Tuple2[float])
+assert_type(pu.mapparms(seq_num_float, seq_num_complex), _Tuple2[complex])
+assert_type(pu.mapparms(seq_num_complex, seq_num_complex), _Tuple2[complex])
+assert_type(pu.mapparms(seq_num_complex, seq_num_object), _Tuple2[object])
+assert_type(pu.mapparms(seq_num_object, seq_num_object), _Tuple2[object])
+
+assert_type(pu.mapparms(seq_sct_int, seq_sct_int), _Tuple2[np.floating[Any]])
+assert_type(pu.mapparms(seq_sct_int, seq_sct_float), _Tuple2[np.floating[Any]])
+assert_type(pu.mapparms(seq_sct_float, seq_sct_float), _Tuple2[np.floating[Any]])
+assert_type(pu.mapparms(seq_sct_float, seq_sct_complex), _Tuple2[np.complexfloating[Any, Any]])
+assert_type(pu.mapparms(seq_sct_complex, seq_sct_complex), _Tuple2[np.complexfloating[Any, Any]])
+assert_type(pu.mapparms(seq_sct_complex, seq_sct_object), _Tuple2[object])
+assert_type(pu.mapparms(seq_sct_object, seq_sct_object), _Tuple2[object])
+
+assert_type(pu.mapparms(arr_int, arr_int), _Tuple2[np.floating[Any]])
+assert_type(pu.mapparms(arr_int, arr_float), _Tuple2[np.floating[Any]])
+assert_type(pu.mapparms(arr_float, arr_float), _Tuple2[np.floating[Any]])
+assert_type(pu.mapparms(arr_float, arr_complex), _Tuple2[np.complexfloating[Any, Any]])
+assert_type(pu.mapparms(arr_complex, arr_complex), _Tuple2[np.complexfloating[Any, Any]])
+assert_type(pu.mapparms(arr_complex, arr_object), _Tuple2[object])
+assert_type(pu.mapparms(arr_object, arr_object), _Tuple2[object])
+
+# mapdomain
+
+assert_type(pu.mapdomain(num_int, seq_num_int, seq_num_int), np.floating[Any])
+assert_type(pu.mapdomain(num_int, seq_num_int, seq_num_float), np.floating[Any])
+assert_type(pu.mapdomain(num_int, seq_num_float, seq_num_float), np.floating[Any])
+assert_type(pu.mapdomain(num_float, seq_num_float, seq_num_float), np.floating[Any])
+assert_type(pu.mapdomain(num_float, seq_num_float, seq_num_complex), np.complexfloating[Any, Any])
+assert_type(pu.mapdomain(num_float, seq_num_complex, seq_num_complex), np.complexfloating[Any, Any])
+assert_type(pu.mapdomain(num_complex, seq_num_complex, seq_num_complex), np.complexfloating[Any, Any])
+assert_type(pu.mapdomain(num_complex, seq_num_complex, seq_num_object), object)
+assert_type(pu.mapdomain(num_complex, seq_num_object, seq_num_object), object)
+assert_type(pu.mapdomain(num_object, seq_num_object, seq_num_object), object)
+
+assert_type(pu.mapdomain(seq_num_int, seq_num_int, seq_num_int), _ArrFloat1D)
+assert_type(pu.mapdomain(seq_num_int, seq_num_int, seq_num_float), _ArrFloat1D)
+assert_type(pu.mapdomain(seq_num_int, seq_num_float, seq_num_float), _ArrFloat1D)
+assert_type(pu.mapdomain(seq_num_float, seq_num_float, seq_num_float), _ArrFloat1D)
+assert_type(pu.mapdomain(seq_num_float, seq_num_float, seq_num_complex), _ArrComplex1D)
+assert_type(pu.mapdomain(seq_num_float, seq_num_complex, seq_num_complex), _ArrComplex1D)
+assert_type(pu.mapdomain(seq_num_complex, seq_num_complex, seq_num_complex), _ArrComplex1D)
+assert_type(pu.mapdomain(seq_num_complex, seq_num_complex, seq_num_object), _ArrObject1D)
+assert_type(pu.mapdomain(seq_num_complex, seq_num_object, seq_num_object), _ArrObject1D)
+assert_type(pu.mapdomain(seq_num_object, seq_num_object, seq_num_object), _ArrObject1D)
+
+assert_type(pu.mapdomain(seq_sct_int, seq_sct_int, seq_sct_int), _ArrFloat1D)
+assert_type(pu.mapdomain(seq_sct_int, seq_sct_int, seq_sct_float), _ArrFloat1D)
+assert_type(pu.mapdomain(seq_sct_int, seq_sct_float, seq_sct_float), _ArrFloat1D)
+assert_type(pu.mapdomain(seq_sct_float, seq_sct_float, seq_sct_float), _ArrFloat1D)
+assert_type(pu.mapdomain(seq_sct_float, seq_sct_float, seq_sct_complex), _ArrComplex1D)
+assert_type(pu.mapdomain(seq_sct_float, seq_sct_complex, seq_sct_complex), _ArrComplex1D)
+assert_type(pu.mapdomain(seq_sct_complex, seq_sct_complex, seq_sct_complex), _ArrComplex1D)
+assert_type(pu.mapdomain(seq_sct_complex, seq_sct_complex, seq_sct_object), _ArrObject1D)
+assert_type(pu.mapdomain(seq_sct_complex, seq_sct_object, seq_sct_object), _ArrObject1D)
+assert_type(pu.mapdomain(seq_sct_object, seq_sct_object, seq_sct_object), _ArrObject1D)
+
+assert_type(pu.mapdomain(arr_int, arr_int, arr_int), _ArrFloat1D)
+assert_type(pu.mapdomain(arr_int, arr_int, arr_float), _ArrFloat1D)
+assert_type(pu.mapdomain(arr_int, arr_float, arr_float), _ArrFloat1D)
+assert_type(pu.mapdomain(arr_float, arr_float, arr_float), _ArrFloat1D)
+assert_type(pu.mapdomain(arr_float, arr_float, arr_complex), _ArrComplex1D)
+assert_type(pu.mapdomain(arr_float, arr_complex, arr_complex), _ArrComplex1D)
+assert_type(pu.mapdomain(arr_complex, arr_complex, arr_complex), _ArrComplex1D)
+assert_type(pu.mapdomain(arr_complex, arr_complex, arr_object), _ArrObject1D)
+assert_type(pu.mapdomain(arr_complex, arr_object, arr_object), _ArrObject1D)
+assert_type(pu.mapdomain(arr_object, arr_object, arr_object), _ArrObject1D)
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/polynomial_series.pyi b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/polynomial_series.pyi
new file mode 100644
index 00000000..a60d05af
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/polynomial_series.pyi
@@ -0,0 +1,144 @@
+from collections.abc import Sequence
+import sys
+from typing import Any, TypeAlias
+
+import numpy as np
+import numpy.polynomial as npp
+import numpy.typing as npt
+
+if sys.version_info >= (3, 11):
+    from typing import assert_type
+else:
+    from typing_extensions import assert_type
+
+_ArrFloat1D: TypeAlias = np.ndarray[tuple[int], np.dtype[np.floating[Any]]]
+_ArrFloat1D64: TypeAlias = np.ndarray[tuple[int], np.dtype[np.float64]]
+_ArrComplex1D: TypeAlias = np.ndarray[tuple[int], np.dtype[np.complexfloating[Any, Any]]]
+_ArrComplex1D128: TypeAlias = np.ndarray[tuple[int], np.dtype[np.complex128]]
+_ArrObject1D: TypeAlias = np.ndarray[tuple[int], np.dtype[np.object_]]
+
+AR_b: npt.NDArray[np.bool]
+AR_u4: npt.NDArray[np.uint32]
+AR_i8: npt.NDArray[np.int64]
+AR_f8: npt.NDArray[np.float64]
+AR_c16: npt.NDArray[np.complex128]
+AR_O: npt.NDArray[np.object_]
+
+PS_poly: npp.Polynomial
+PS_cheb: npp.Chebyshev
+
+assert_type(npp.polynomial.polyroots(AR_f8), _ArrFloat1D64)
+assert_type(npp.polynomial.polyroots(AR_c16), _ArrComplex1D128)
+assert_type(npp.polynomial.polyroots(AR_O), _ArrObject1D)
+
+assert_type(npp.polynomial.polyfromroots(AR_f8), _ArrFloat1D)
+assert_type(npp.polynomial.polyfromroots(AR_c16), _ArrComplex1D)
+assert_type(npp.polynomial.polyfromroots(AR_O), _ArrObject1D)
+
+# assert_type(npp.polynomial.polyadd(AR_b, AR_b), NoReturn)
+assert_type(npp.polynomial.polyadd(AR_u4, AR_b), _ArrFloat1D)
+assert_type(npp.polynomial.polyadd(AR_i8, AR_i8), _ArrFloat1D)
+assert_type(npp.polynomial.polyadd(AR_f8, AR_i8), _ArrFloat1D)
+assert_type(npp.polynomial.polyadd(AR_i8, AR_c16), _ArrComplex1D)
+assert_type(npp.polynomial.polyadd(AR_O, AR_O), _ArrObject1D)
+
+assert_type(npp.polynomial.polymulx(AR_u4), _ArrFloat1D)
+assert_type(npp.polynomial.polymulx(AR_i8), _ArrFloat1D)
+assert_type(npp.polynomial.polymulx(AR_f8), _ArrFloat1D)
+assert_type(npp.polynomial.polymulx(AR_c16), _ArrComplex1D)
+assert_type(npp.polynomial.polymulx(AR_O), _ArrObject1D)
+
+assert_type(npp.polynomial.polypow(AR_u4, 2), _ArrFloat1D)
+assert_type(npp.polynomial.polypow(AR_i8, 2), _ArrFloat1D)
+assert_type(npp.polynomial.polypow(AR_f8, 2), _ArrFloat1D)
+assert_type(npp.polynomial.polypow(AR_c16, 2), _ArrComplex1D)
+assert_type(npp.polynomial.polypow(AR_O, 2), _ArrObject1D)
+
+# assert_type(npp.polynomial.polyder(PS_poly), npt.NDArray[np.object_])
+assert_type(npp.polynomial.polyder(AR_f8), npt.NDArray[np.floating[Any]])
+assert_type(npp.polynomial.polyder(AR_c16), npt.NDArray[np.complexfloating[Any, Any]])
+assert_type(npp.polynomial.polyder(AR_O, m=2), npt.NDArray[np.object_])
+
+# assert_type(npp.polynomial.polyint(PS_poly), npt.NDArray[np.object_])
+assert_type(npp.polynomial.polyint(AR_f8), npt.NDArray[np.floating[Any]])
+assert_type(npp.polynomial.polyint(AR_f8, k=AR_c16), npt.NDArray[np.complexfloating[Any, Any]])
+assert_type(npp.polynomial.polyint(AR_O, m=2), npt.NDArray[np.object_])
+
+assert_type(npp.polynomial.polyval(AR_b, AR_b), npt.NDArray[np.floating[Any]])
+assert_type(npp.polynomial.polyval(AR_u4, AR_b), npt.NDArray[np.floating[Any]])
+assert_type(npp.polynomial.polyval(AR_i8, AR_i8), npt.NDArray[np.floating[Any]])
+assert_type(npp.polynomial.polyval(AR_f8, AR_i8), npt.NDArray[np.floating[Any]])
+assert_type(npp.polynomial.polyval(AR_i8, AR_c16), npt.NDArray[np.complexfloating[Any, Any]])
+assert_type(npp.polynomial.polyval(AR_O, AR_O), npt.NDArray[np.object_])
+
+assert_type(npp.polynomial.polyval2d(AR_b, AR_b, AR_b), npt.NDArray[np.floating[Any]])
+assert_type(npp.polynomial.polyval2d(AR_u4, AR_u4, AR_b), npt.NDArray[np.floating[Any]])
+assert_type(npp.polynomial.polyval2d(AR_i8, AR_i8, AR_i8), npt.NDArray[np.floating[Any]])
+assert_type(npp.polynomial.polyval2d(AR_f8, AR_f8, AR_i8), npt.NDArray[np.floating[Any]])
+assert_type(npp.polynomial.polyval2d(AR_i8, AR_i8, AR_c16), npt.NDArray[np.complexfloating[Any, Any]])
+assert_type(npp.polynomial.polyval2d(AR_O, AR_O, AR_O), npt.NDArray[np.object_])
+
+assert_type(npp.polynomial.polyval3d(AR_b, AR_b, AR_b, AR_b), npt.NDArray[np.floating[Any]])
+assert_type(npp.polynomial.polyval3d(AR_u4, AR_u4, AR_u4, AR_b), npt.NDArray[np.floating[Any]])
+assert_type(npp.polynomial.polyval3d(AR_i8, AR_i8, AR_i8, AR_i8), npt.NDArray[np.floating[Any]])
+assert_type(npp.polynomial.polyval3d(AR_f8, AR_f8, AR_f8, AR_i8), npt.NDArray[np.floating[Any]])
+assert_type(npp.polynomial.polyval3d(AR_i8, AR_i8, AR_i8, AR_c16), npt.NDArray[np.complexfloating[Any, Any]])
+assert_type(npp.polynomial.polyval3d(AR_O, AR_O, AR_O, AR_O), npt.NDArray[np.object_])
+
+assert_type(npp.polynomial.polyvalfromroots(AR_b, AR_b), npt.NDArray[np.floating[Any]])
+assert_type(npp.polynomial.polyvalfromroots(AR_u4, AR_b), npt.NDArray[np.floating[Any]])
+assert_type(npp.polynomial.polyvalfromroots(AR_i8, AR_i8), npt.NDArray[np.floating[Any]])
+assert_type(npp.polynomial.polyvalfromroots(AR_f8, AR_i8), npt.NDArray[np.floating[Any]])
+assert_type(npp.polynomial.polyvalfromroots(AR_i8, AR_c16), npt.NDArray[np.complexfloating[Any, Any]])
+assert_type(npp.polynomial.polyvalfromroots(AR_O, AR_O), npt.NDArray[np.object_])
+
+assert_type(npp.polynomial.polyvander(AR_f8, 3), npt.NDArray[np.floating[Any]])
+assert_type(npp.polynomial.polyvander(AR_c16, 3), npt.NDArray[np.complexfloating[Any, Any]])
+assert_type(npp.polynomial.polyvander(AR_O, 3), npt.NDArray[np.object_])
+
+assert_type(npp.polynomial.polyvander2d(AR_f8, AR_f8, [4, 2]), npt.NDArray[np.floating[Any]])
+assert_type(npp.polynomial.polyvander2d(AR_c16, AR_c16, [4, 2]), npt.NDArray[np.complexfloating[Any, Any]])
+assert_type(npp.polynomial.polyvander2d(AR_O, AR_O, [4, 2]), npt.NDArray[np.object_])
+
+assert_type(npp.polynomial.polyvander3d(AR_f8, AR_f8, AR_f8, [4, 3, 2]), npt.NDArray[np.floating[Any]])
+assert_type(npp.polynomial.polyvander3d(AR_c16, AR_c16, AR_c16, [4, 3, 2]), npt.NDArray[np.complexfloating[Any, Any]])
+assert_type(npp.polynomial.polyvander3d(AR_O, AR_O, AR_O, [4, 3, 2]), npt.NDArray[np.object_])
+
+assert_type(
+    npp.polynomial.polyfit(AR_f8, AR_f8, 2),
+    npt.NDArray[np.floating[Any]],
+)
+assert_type(
+    npp.polynomial.polyfit(AR_f8, AR_i8, 1, full=True),
+    tuple[npt.NDArray[np.floating[Any]], Sequence[np.inexact[Any] | np.int32]],
+)
+assert_type(
+    npp.polynomial.polyfit(AR_c16, AR_f8, 2),
+    npt.NDArray[np.complexfloating[Any, Any]],
+)
+assert_type(
+    npp.polynomial.polyfit(AR_f8, AR_c16, 1, full=True)[0],
+    npt.NDArray[np.complexfloating[Any, Any]],
+)
+
+assert_type(npp.chebyshev.chebgauss(2), tuple[_ArrFloat1D64, _ArrFloat1D64])
+
+assert_type(npp.chebyshev.chebweight(AR_f8), npt.NDArray[np.float64])
+assert_type(npp.chebyshev.chebweight(AR_c16), npt.NDArray[np.complex128])
+assert_type(npp.chebyshev.chebweight(AR_O), npt.NDArray[np.object_])
+
+assert_type(npp.chebyshev.poly2cheb(AR_f8), _ArrFloat1D)
+assert_type(npp.chebyshev.poly2cheb(AR_c16), _ArrComplex1D)
+assert_type(npp.chebyshev.poly2cheb(AR_O), _ArrObject1D)
+
+assert_type(npp.chebyshev.cheb2poly(AR_f8), _ArrFloat1D)
+assert_type(npp.chebyshev.cheb2poly(AR_c16), _ArrComplex1D)
+assert_type(npp.chebyshev.cheb2poly(AR_O), _ArrObject1D)
+
+assert_type(npp.chebyshev.chebpts1(6), _ArrFloat1D64)
+assert_type(npp.chebyshev.chebpts2(6), _ArrFloat1D64)
+
+assert_type(
+    npp.chebyshev.chebinterpolate(np.tanh, 3),
+    npt.NDArray[np.float64 | np.complex128 | np.object_],
+)
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/random.pyi b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/random.pyi
new file mode 100644
index 00000000..b31b4b56
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/random.pyi
@@ -0,0 +1,1555 @@
+import sys
+import threading
+from typing import Any
+from collections.abc import Sequence
+
+import numpy as np
+import numpy.typing as npt
+from numpy.random._generator import Generator
+from numpy.random._mt19937 import MT19937
+from numpy.random._pcg64 import PCG64
+from numpy.random._sfc64 import SFC64
+from numpy.random._philox import Philox
+from numpy.random.bit_generator import SeedSequence, SeedlessSeedSequence
+
+if sys.version_info >= (3, 11):
+    from typing import assert_type
+else:
+    from typing_extensions import assert_type
+
+def_rng = np.random.default_rng()
+seed_seq = np.random.SeedSequence()
+mt19937 = np.random.MT19937()
+pcg64 = np.random.PCG64()
+sfc64 = np.random.SFC64()
+philox = np.random.Philox()
+seedless_seq = SeedlessSeedSequence()
+
+assert_type(def_rng, Generator)
+assert_type(mt19937, MT19937)
+assert_type(pcg64, PCG64)
+assert_type(sfc64, SFC64)
+assert_type(philox, Philox)
+assert_type(seed_seq, SeedSequence)
+assert_type(seedless_seq, SeedlessSeedSequence)
+
+mt19937_jumped = mt19937.jumped()
+mt19937_jumped3 = mt19937.jumped(3)
+mt19937_raw = mt19937.random_raw()
+mt19937_raw_arr = mt19937.random_raw(5)
+
+assert_type(mt19937_jumped, MT19937)
+assert_type(mt19937_jumped3, MT19937)
+assert_type(mt19937_raw, int)
+assert_type(mt19937_raw_arr, npt.NDArray[np.uint64])
+assert_type(mt19937.lock, threading.Lock)
+
+pcg64_jumped = pcg64.jumped()
+pcg64_jumped3 = pcg64.jumped(3)
+pcg64_adv = pcg64.advance(3)
+pcg64_raw = pcg64.random_raw()
+pcg64_raw_arr = pcg64.random_raw(5)
+
+assert_type(pcg64_jumped, PCG64)
+assert_type(pcg64_jumped3, PCG64)
+assert_type(pcg64_adv, PCG64)
+assert_type(pcg64_raw, int)
+assert_type(pcg64_raw_arr, npt.NDArray[np.uint64])
+assert_type(pcg64.lock, threading.Lock)
+
+philox_jumped = philox.jumped()
+philox_jumped3 = philox.jumped(3)
+philox_adv = philox.advance(3)
+philox_raw = philox.random_raw()
+philox_raw_arr = philox.random_raw(5)
+
+assert_type(philox_jumped, Philox)
+assert_type(philox_jumped3, Philox)
+assert_type(philox_adv, Philox)
+assert_type(philox_raw, int)
+assert_type(philox_raw_arr, npt.NDArray[np.uint64])
+assert_type(philox.lock, threading.Lock)
+
+sfc64_raw = sfc64.random_raw()
+sfc64_raw_arr = sfc64.random_raw(5)
+
+assert_type(sfc64_raw, int)
+assert_type(sfc64_raw_arr, npt.NDArray[np.uint64])
+assert_type(sfc64.lock, threading.Lock)
+
+assert_type(seed_seq.pool, npt.NDArray[np.uint32])
+assert_type(seed_seq.entropy, None | int | Sequence[int])
+assert_type(seed_seq.spawn(1), list[np.random.SeedSequence])
+assert_type(seed_seq.generate_state(8, "uint32"), npt.NDArray[np.uint32 | np.uint64])
+assert_type(seed_seq.generate_state(8, "uint64"), npt.NDArray[np.uint32 | np.uint64])
+
+
+def_gen: np.random.Generator = np.random.default_rng()
+
+D_arr_0p1: npt.NDArray[np.float64] = np.array([0.1])
+D_arr_0p5: npt.NDArray[np.float64] = np.array([0.5])
+D_arr_0p9: npt.NDArray[np.float64] = np.array([0.9])
+D_arr_1p5: npt.NDArray[np.float64] = np.array([1.5])
+I_arr_10: npt.NDArray[np.int_] = np.array([10], dtype=np.int_)
+I_arr_20: npt.NDArray[np.int_] = np.array([20], dtype=np.int_)
+D_arr_like_0p1: list[float] = [0.1]
+D_arr_like_0p5: list[float] = [0.5]
+D_arr_like_0p9: list[float] = [0.9]
+D_arr_like_1p5: list[float] = [1.5]
+I_arr_like_10: list[int] = [10]
+I_arr_like_20: list[int] = [20]
+D_2D_like: list[list[float]] = [[1, 2], [2, 3], [3, 4], [4, 5.1]]
+D_2D: npt.NDArray[np.float64] = np.array(D_2D_like)
+S_out: npt.NDArray[np.float32] = np.empty(1, dtype=np.float32)
+D_out: npt.NDArray[np.float64] = np.empty(1)
+
+assert_type(def_gen.standard_normal(), float)
+assert_type(def_gen.standard_normal(dtype=np.float32), float)
+assert_type(def_gen.standard_normal(dtype="float32"), float)
+assert_type(def_gen.standard_normal(dtype="double"), float)
+assert_type(def_gen.standard_normal(dtype=np.float64), float)
+assert_type(def_gen.standard_normal(size=None), float)
+assert_type(def_gen.standard_normal(size=1), npt.NDArray[np.float64])
+assert_type(def_gen.standard_normal(size=1, dtype=np.float32), npt.NDArray[np.float32])
+assert_type(def_gen.standard_normal(size=1, dtype="f4"), npt.NDArray[np.float32])
+assert_type(def_gen.standard_normal(size=1, dtype="float32", out=S_out), npt.NDArray[np.float32])
+assert_type(def_gen.standard_normal(dtype=np.float32, out=S_out), npt.NDArray[np.float32])
+assert_type(def_gen.standard_normal(size=1, dtype=np.float64), npt.NDArray[np.float64])
+assert_type(def_gen.standard_normal(size=1, dtype="float64"), npt.NDArray[np.float64])
+assert_type(def_gen.standard_normal(size=1, dtype="f8"), npt.NDArray[np.float64])
+assert_type(def_gen.standard_normal(out=D_out), npt.NDArray[np.float64])
+assert_type(def_gen.standard_normal(size=1, dtype="float64"), npt.NDArray[np.float64])
+assert_type(def_gen.standard_normal(size=1, dtype="float64", out=D_out), npt.NDArray[np.float64])
+
+assert_type(def_gen.random(), float)
+assert_type(def_gen.random(dtype=np.float32), float)
+assert_type(def_gen.random(dtype="float32"), float)
+assert_type(def_gen.random(dtype="double"), float)
+assert_type(def_gen.random(dtype=np.float64), float)
+assert_type(def_gen.random(size=None), float)
+assert_type(def_gen.random(size=1), npt.NDArray[np.float64])
+assert_type(def_gen.random(size=1, dtype=np.float32), npt.NDArray[np.float32])
+assert_type(def_gen.random(size=1, dtype="f4"), npt.NDArray[np.float32])
+assert_type(def_gen.random(size=1, dtype="float32", out=S_out), npt.NDArray[np.float32])
+assert_type(def_gen.random(dtype=np.float32, out=S_out), npt.NDArray[np.float32])
+assert_type(def_gen.random(size=1, dtype=np.float64), npt.NDArray[np.float64])
+assert_type(def_gen.random(size=1, dtype="float64"), npt.NDArray[np.float64])
+assert_type(def_gen.random(size=1, dtype="f8"), npt.NDArray[np.float64])
+assert_type(def_gen.random(out=D_out), npt.NDArray[np.float64])
+assert_type(def_gen.random(size=1, dtype="float64"), npt.NDArray[np.float64])
+assert_type(def_gen.random(size=1, dtype="float64", out=D_out), npt.NDArray[np.float64])
+
+assert_type(def_gen.standard_cauchy(), float)
+assert_type(def_gen.standard_cauchy(size=None), float)
+assert_type(def_gen.standard_cauchy(size=1), npt.NDArray[np.float64])
+
+assert_type(def_gen.standard_exponential(), float)
+assert_type(def_gen.standard_exponential(method="inv"), float)
+assert_type(def_gen.standard_exponential(dtype=np.float32), float)
+assert_type(def_gen.standard_exponential(dtype="float32"), float)
+assert_type(def_gen.standard_exponential(dtype="double"), float)
+assert_type(def_gen.standard_exponential(dtype=np.float64), float)
+assert_type(def_gen.standard_exponential(size=None), float)
+assert_type(def_gen.standard_exponential(size=None, method="inv"), float)
+assert_type(def_gen.standard_exponential(size=1, method="inv"), npt.NDArray[np.float64])
+assert_type(def_gen.standard_exponential(size=1, dtype=np.float32), npt.NDArray[np.float32])
+assert_type(def_gen.standard_exponential(size=1, dtype="f4", method="inv"), npt.NDArray[np.float32])
+assert_type(def_gen.standard_exponential(size=1, dtype="float32", out=S_out), npt.NDArray[np.float32])
+assert_type(def_gen.standard_exponential(dtype=np.float32, out=S_out), npt.NDArray[np.float32])
+assert_type(def_gen.standard_exponential(size=1, dtype=np.float64, method="inv"), npt.NDArray[np.float64])
+assert_type(def_gen.standard_exponential(size=1, dtype="float64"), npt.NDArray[np.float64])
+assert_type(def_gen.standard_exponential(size=1, dtype="f8"), npt.NDArray[np.float64])
+assert_type(def_gen.standard_exponential(out=D_out), npt.NDArray[np.float64])
+assert_type(def_gen.standard_exponential(size=1, dtype="float64"), npt.NDArray[np.float64])
+assert_type(def_gen.standard_exponential(size=1, dtype="float64", out=D_out), npt.NDArray[np.float64])
+
+assert_type(def_gen.zipf(1.5), int)
+assert_type(def_gen.zipf(1.5, size=None), int)
+assert_type(def_gen.zipf(1.5, size=1), npt.NDArray[np.int64])
+assert_type(def_gen.zipf(D_arr_1p5), npt.NDArray[np.int64])
+assert_type(def_gen.zipf(D_arr_1p5, size=1), npt.NDArray[np.int64])
+assert_type(def_gen.zipf(D_arr_like_1p5), npt.NDArray[np.int64])
+assert_type(def_gen.zipf(D_arr_like_1p5, size=1), npt.NDArray[np.int64])
+
+assert_type(def_gen.weibull(0.5), float)
+assert_type(def_gen.weibull(0.5, size=None), float)
+assert_type(def_gen.weibull(0.5, size=1), npt.NDArray[np.float64])
+assert_type(def_gen.weibull(D_arr_0p5), npt.NDArray[np.float64])
+assert_type(def_gen.weibull(D_arr_0p5, size=1), npt.NDArray[np.float64])
+assert_type(def_gen.weibull(D_arr_like_0p5), npt.NDArray[np.float64])
+assert_type(def_gen.weibull(D_arr_like_0p5, size=1), npt.NDArray[np.float64])
+
+assert_type(def_gen.standard_t(0.5), float)
+assert_type(def_gen.standard_t(0.5, size=None), float)
+assert_type(def_gen.standard_t(0.5, size=1), npt.NDArray[np.float64])
+assert_type(def_gen.standard_t(D_arr_0p5), npt.NDArray[np.float64])
+assert_type(def_gen.standard_t(D_arr_0p5, size=1), npt.NDArray[np.float64])
+assert_type(def_gen.standard_t(D_arr_like_0p5), npt.NDArray[np.float64])
+assert_type(def_gen.standard_t(D_arr_like_0p5, size=1), npt.NDArray[np.float64])
+
+assert_type(def_gen.poisson(0.5), int)
+assert_type(def_gen.poisson(0.5, size=None), int)
+assert_type(def_gen.poisson(0.5, size=1), npt.NDArray[np.int64])
+assert_type(def_gen.poisson(D_arr_0p5), npt.NDArray[np.int64])
+assert_type(def_gen.poisson(D_arr_0p5, size=1), npt.NDArray[np.int64])
+assert_type(def_gen.poisson(D_arr_like_0p5), npt.NDArray[np.int64])
+assert_type(def_gen.poisson(D_arr_like_0p5, size=1), npt.NDArray[np.int64])
+
+assert_type(def_gen.power(0.5), float)
+assert_type(def_gen.power(0.5, size=None), float)
+assert_type(def_gen.power(0.5, size=1), npt.NDArray[np.float64])
+assert_type(def_gen.power(D_arr_0p5), npt.NDArray[np.float64])
+assert_type(def_gen.power(D_arr_0p5, size=1), npt.NDArray[np.float64])
+assert_type(def_gen.power(D_arr_like_0p5), npt.NDArray[np.float64])
+assert_type(def_gen.power(D_arr_like_0p5, size=1), npt.NDArray[np.float64])
+
+assert_type(def_gen.pareto(0.5), float)
+assert_type(def_gen.pareto(0.5, size=None), float)
+assert_type(def_gen.pareto(0.5, size=1), npt.NDArray[np.float64])
+assert_type(def_gen.pareto(D_arr_0p5), npt.NDArray[np.float64])
+assert_type(def_gen.pareto(D_arr_0p5, size=1), npt.NDArray[np.float64])
+assert_type(def_gen.pareto(D_arr_like_0p5), npt.NDArray[np.float64])
+assert_type(def_gen.pareto(D_arr_like_0p5, size=1), npt.NDArray[np.float64])
+
+assert_type(def_gen.chisquare(0.5), float)
+assert_type(def_gen.chisquare(0.5, size=None), float)
+assert_type(def_gen.chisquare(0.5, size=1), npt.NDArray[np.float64])
+assert_type(def_gen.chisquare(D_arr_0p5), npt.NDArray[np.float64])
+assert_type(def_gen.chisquare(D_arr_0p5, size=1), npt.NDArray[np.float64])
+assert_type(def_gen.chisquare(D_arr_like_0p5), npt.NDArray[np.float64])
+assert_type(def_gen.chisquare(D_arr_like_0p5, size=1), npt.NDArray[np.float64])
+
+assert_type(def_gen.exponential(0.5), float)
+assert_type(def_gen.exponential(0.5, size=None), float)
+assert_type(def_gen.exponential(0.5, size=1), npt.NDArray[np.float64])
+assert_type(def_gen.exponential(D_arr_0p5), npt.NDArray[np.float64])
+assert_type(def_gen.exponential(D_arr_0p5, size=1), npt.NDArray[np.float64])
+assert_type(def_gen.exponential(D_arr_like_0p5), npt.NDArray[np.float64])
+assert_type(def_gen.exponential(D_arr_like_0p5, size=1), npt.NDArray[np.float64])
+
+assert_type(def_gen.geometric(0.5), int)
+assert_type(def_gen.geometric(0.5, size=None), int)
+assert_type(def_gen.geometric(0.5, size=1), npt.NDArray[np.int64])
+assert_type(def_gen.geometric(D_arr_0p5), npt.NDArray[np.int64])
+assert_type(def_gen.geometric(D_arr_0p5, size=1), npt.NDArray[np.int64])
+assert_type(def_gen.geometric(D_arr_like_0p5), npt.NDArray[np.int64])
+assert_type(def_gen.geometric(D_arr_like_0p5, size=1), npt.NDArray[np.int64])
+
+assert_type(def_gen.logseries(0.5), int)
+assert_type(def_gen.logseries(0.5, size=None), int)
+assert_type(def_gen.logseries(0.5, size=1), npt.NDArray[np.int64])
+assert_type(def_gen.logseries(D_arr_0p5), npt.NDArray[np.int64])
+assert_type(def_gen.logseries(D_arr_0p5, size=1), npt.NDArray[np.int64])
+assert_type(def_gen.logseries(D_arr_like_0p5), npt.NDArray[np.int64])
+assert_type(def_gen.logseries(D_arr_like_0p5, size=1), npt.NDArray[np.int64])
+
+assert_type(def_gen.rayleigh(0.5), float)
+assert_type(def_gen.rayleigh(0.5, size=None), float)
+assert_type(def_gen.rayleigh(0.5, size=1), npt.NDArray[np.float64])
+assert_type(def_gen.rayleigh(D_arr_0p5), npt.NDArray[np.float64])
+assert_type(def_gen.rayleigh(D_arr_0p5, size=1), npt.NDArray[np.float64])
+assert_type(def_gen.rayleigh(D_arr_like_0p5), npt.NDArray[np.float64])
+assert_type(def_gen.rayleigh(D_arr_like_0p5, size=1), npt.NDArray[np.float64])
+
+assert_type(def_gen.standard_gamma(0.5), float)
+assert_type(def_gen.standard_gamma(0.5, size=None), float)
+assert_type(def_gen.standard_gamma(0.5, dtype="float32"), float)
+assert_type(def_gen.standard_gamma(0.5, size=None, dtype="float32"), float)
+assert_type(def_gen.standard_gamma(0.5, size=1), npt.NDArray[np.float64])
+assert_type(def_gen.standard_gamma(D_arr_0p5), npt.NDArray[np.float64])
+assert_type(def_gen.standard_gamma(D_arr_0p5, dtype="f4"), npt.NDArray[np.float32])
+assert_type(def_gen.standard_gamma(0.5, size=1, dtype="float32", out=S_out), npt.NDArray[np.float32])
+assert_type(def_gen.standard_gamma(D_arr_0p5, dtype=np.float32, out=S_out), npt.NDArray[np.float32])
+assert_type(def_gen.standard_gamma(D_arr_0p5, size=1), npt.NDArray[np.float64])
+assert_type(def_gen.standard_gamma(D_arr_like_0p5), npt.NDArray[np.float64])
+assert_type(def_gen.standard_gamma(D_arr_like_0p5, size=1), npt.NDArray[np.float64])
+assert_type(def_gen.standard_gamma(0.5, out=D_out), npt.NDArray[np.float64])
+assert_type(def_gen.standard_gamma(D_arr_like_0p5, out=D_out), npt.NDArray[np.float64])
+assert_type(def_gen.standard_gamma(D_arr_like_0p5, size=1), npt.NDArray[np.float64])
+assert_type(def_gen.standard_gamma(D_arr_like_0p5, size=1, out=D_out, dtype=np.float64), npt.NDArray[np.float64])
+
+assert_type(def_gen.vonmises(0.5, 0.5), float)
+assert_type(def_gen.vonmises(0.5, 0.5, size=None), float)
+assert_type(def_gen.vonmises(0.5, 0.5, size=1), npt.NDArray[np.float64])
+assert_type(def_gen.vonmises(D_arr_0p5, 0.5), npt.NDArray[np.float64])
+assert_type(def_gen.vonmises(0.5, D_arr_0p5), npt.NDArray[np.float64])
+assert_type(def_gen.vonmises(D_arr_0p5, 0.5, size=1), npt.NDArray[np.float64])
+assert_type(def_gen.vonmises(0.5, D_arr_0p5, size=1), npt.NDArray[np.float64])
+assert_type(def_gen.vonmises(D_arr_like_0p5, 0.5), npt.NDArray[np.float64])
+assert_type(def_gen.vonmises(0.5, D_arr_like_0p5), npt.NDArray[np.float64])
+assert_type(def_gen.vonmises(D_arr_0p5, D_arr_0p5), npt.NDArray[np.float64])
+assert_type(def_gen.vonmises(D_arr_like_0p5, D_arr_like_0p5), npt.NDArray[np.float64])
+assert_type(def_gen.vonmises(D_arr_0p5, D_arr_0p5, size=1), npt.NDArray[np.float64])
+assert_type(def_gen.vonmises(D_arr_like_0p5, D_arr_like_0p5, size=1), npt.NDArray[np.float64])
+
+assert_type(def_gen.wald(0.5, 0.5), float)
+assert_type(def_gen.wald(0.5, 0.5, size=None), float)
+assert_type(def_gen.wald(0.5, 0.5, size=1), npt.NDArray[np.float64])
+assert_type(def_gen.wald(D_arr_0p5, 0.5), npt.NDArray[np.float64])
+assert_type(def_gen.wald(0.5, D_arr_0p5), npt.NDArray[np.float64])
+assert_type(def_gen.wald(D_arr_0p5, 0.5, size=1), npt.NDArray[np.float64])
+assert_type(def_gen.wald(0.5, D_arr_0p5, size=1), npt.NDArray[np.float64])
+assert_type(def_gen.wald(D_arr_like_0p5, 0.5), npt.NDArray[np.float64])
+assert_type(def_gen.wald(0.5, D_arr_like_0p5), npt.NDArray[np.float64])
+assert_type(def_gen.wald(D_arr_0p5, D_arr_0p5), npt.NDArray[np.float64])
+assert_type(def_gen.wald(D_arr_like_0p5, D_arr_like_0p5), npt.NDArray[np.float64])
+assert_type(def_gen.wald(D_arr_0p5, D_arr_0p5, size=1), npt.NDArray[np.float64])
+assert_type(def_gen.wald(D_arr_like_0p5, D_arr_like_0p5, size=1), npt.NDArray[np.float64])
+
+assert_type(def_gen.uniform(0.5, 0.5), float)
+assert_type(def_gen.uniform(0.5, 0.5, size=None), float)
+assert_type(def_gen.uniform(0.5, 0.5, size=1), npt.NDArray[np.float64])
+assert_type(def_gen.uniform(D_arr_0p5, 0.5), npt.NDArray[np.float64])
+assert_type(def_gen.uniform(0.5, D_arr_0p5), npt.NDArray[np.float64])
+assert_type(def_gen.uniform(D_arr_0p5, 0.5, size=1), npt.NDArray[np.float64])
+assert_type(def_gen.uniform(0.5, D_arr_0p5, size=1), npt.NDArray[np.float64])
+assert_type(def_gen.uniform(D_arr_like_0p5, 0.5), npt.NDArray[np.float64])
+assert_type(def_gen.uniform(0.5, D_arr_like_0p5), npt.NDArray[np.float64])
+assert_type(def_gen.uniform(D_arr_0p5, D_arr_0p5), npt.NDArray[np.float64])
+assert_type(def_gen.uniform(D_arr_like_0p5, D_arr_like_0p5), npt.NDArray[np.float64])
+assert_type(def_gen.uniform(D_arr_0p5, D_arr_0p5, size=1), npt.NDArray[np.float64])
+assert_type(def_gen.uniform(D_arr_like_0p5, D_arr_like_0p5, size=1), npt.NDArray[np.float64])
+
+assert_type(def_gen.beta(0.5, 0.5), float)
+assert_type(def_gen.beta(0.5, 0.5, size=None), float)
+assert_type(def_gen.beta(0.5, 0.5, size=1), npt.NDArray[np.float64])
+assert_type(def_gen.beta(D_arr_0p5, 0.5), npt.NDArray[np.float64])
+assert_type(def_gen.beta(0.5, D_arr_0p5), npt.NDArray[np.float64])
+assert_type(def_gen.beta(D_arr_0p5, 0.5, size=1), npt.NDArray[np.float64])
+assert_type(def_gen.beta(0.5, D_arr_0p5, size=1), npt.NDArray[np.float64])
+assert_type(def_gen.beta(D_arr_like_0p5, 0.5), npt.NDArray[np.float64])
+assert_type(def_gen.beta(0.5, D_arr_like_0p5), npt.NDArray[np.float64])
+assert_type(def_gen.beta(D_arr_0p5, D_arr_0p5), npt.NDArray[np.float64])
+assert_type(def_gen.beta(D_arr_like_0p5, D_arr_like_0p5), npt.NDArray[np.float64])
+assert_type(def_gen.beta(D_arr_0p5, D_arr_0p5, size=1), npt.NDArray[np.float64])
+assert_type(def_gen.beta(D_arr_like_0p5, D_arr_like_0p5, size=1), npt.NDArray[np.float64])
+
+assert_type(def_gen.f(0.5, 0.5), float)
+assert_type(def_gen.f(0.5, 0.5, size=None), float)
+assert_type(def_gen.f(0.5, 0.5, size=1), npt.NDArray[np.float64])
+assert_type(def_gen.f(D_arr_0p5, 0.5), npt.NDArray[np.float64])
+assert_type(def_gen.f(0.5, D_arr_0p5), npt.NDArray[np.float64])
+assert_type(def_gen.f(D_arr_0p5, 0.5, size=1), npt.NDArray[np.float64])
+assert_type(def_gen.f(0.5, D_arr_0p5, size=1), npt.NDArray[np.float64])
+assert_type(def_gen.f(D_arr_like_0p5, 0.5), npt.NDArray[np.float64])
+assert_type(def_gen.f(0.5, D_arr_like_0p5), npt.NDArray[np.float64])
+assert_type(def_gen.f(D_arr_0p5, D_arr_0p5), npt.NDArray[np.float64])
+assert_type(def_gen.f(D_arr_like_0p5, D_arr_like_0p5), npt.NDArray[np.float64])
+assert_type(def_gen.f(D_arr_0p5, D_arr_0p5, size=1), npt.NDArray[np.float64])
+assert_type(def_gen.f(D_arr_like_0p5, D_arr_like_0p5, size=1), npt.NDArray[np.float64])
+
+assert_type(def_gen.gamma(0.5, 0.5), float)
+assert_type(def_gen.gamma(0.5, 0.5, size=None), float)
+assert_type(def_gen.gamma(0.5, 0.5, size=1), npt.NDArray[np.float64])
+assert_type(def_gen.gamma(D_arr_0p5, 0.5), npt.NDArray[np.float64])
+assert_type(def_gen.gamma(0.5, D_arr_0p5), npt.NDArray[np.float64])
+assert_type(def_gen.gamma(D_arr_0p5, 0.5, size=1), npt.NDArray[np.float64])
+assert_type(def_gen.gamma(0.5, D_arr_0p5, size=1), npt.NDArray[np.float64])
+assert_type(def_gen.gamma(D_arr_like_0p5, 0.5), npt.NDArray[np.float64])
+assert_type(def_gen.gamma(0.5, D_arr_like_0p5), npt.NDArray[np.float64])
+assert_type(def_gen.gamma(D_arr_0p5, D_arr_0p5), npt.NDArray[np.float64])
+assert_type(def_gen.gamma(D_arr_like_0p5, D_arr_like_0p5), npt.NDArray[np.float64])
+assert_type(def_gen.gamma(D_arr_0p5, D_arr_0p5, size=1), npt.NDArray[np.float64])
+assert_type(def_gen.gamma(D_arr_like_0p5, D_arr_like_0p5, size=1), npt.NDArray[np.float64])
+
+assert_type(def_gen.gumbel(0.5, 0.5), float)
+assert_type(def_gen.gumbel(0.5, 0.5, size=None), float)
+assert_type(def_gen.gumbel(0.5, 0.5, size=1), npt.NDArray[np.float64])
+assert_type(def_gen.gumbel(D_arr_0p5, 0.5), npt.NDArray[np.float64])
+assert_type(def_gen.gumbel(0.5, D_arr_0p5), npt.NDArray[np.float64])
+assert_type(def_gen.gumbel(D_arr_0p5, 0.5, size=1), npt.NDArray[np.float64])
+assert_type(def_gen.gumbel(0.5, D_arr_0p5, size=1), npt.NDArray[np.float64])
+assert_type(def_gen.gumbel(D_arr_like_0p5, 0.5), npt.NDArray[np.float64])
+assert_type(def_gen.gumbel(0.5, D_arr_like_0p5), npt.NDArray[np.float64])
+assert_type(def_gen.gumbel(D_arr_0p5, D_arr_0p5), npt.NDArray[np.float64])
+assert_type(def_gen.gumbel(D_arr_like_0p5, D_arr_like_0p5), npt.NDArray[np.float64])
+assert_type(def_gen.gumbel(D_arr_0p5, D_arr_0p5, size=1), npt.NDArray[np.float64])
+assert_type(def_gen.gumbel(D_arr_like_0p5, D_arr_like_0p5, size=1), npt.NDArray[np.float64])
+
+assert_type(def_gen.laplace(0.5, 0.5), float)
+assert_type(def_gen.laplace(0.5, 0.5, size=None), float)
+assert_type(def_gen.laplace(0.5, 0.5, size=1), npt.NDArray[np.float64])
+assert_type(def_gen.laplace(D_arr_0p5, 0.5), npt.NDArray[np.float64])
+assert_type(def_gen.laplace(0.5, D_arr_0p5), npt.NDArray[np.float64])
+assert_type(def_gen.laplace(D_arr_0p5, 0.5, size=1), npt.NDArray[np.float64])
+assert_type(def_gen.laplace(0.5, D_arr_0p5, size=1), npt.NDArray[np.float64])
+assert_type(def_gen.laplace(D_arr_like_0p5, 0.5), npt.NDArray[np.float64])
+assert_type(def_gen.laplace(0.5, D_arr_like_0p5), npt.NDArray[np.float64])
+assert_type(def_gen.laplace(D_arr_0p5, D_arr_0p5), npt.NDArray[np.float64])
+assert_type(def_gen.laplace(D_arr_like_0p5, D_arr_like_0p5), npt.NDArray[np.float64])
+assert_type(def_gen.laplace(D_arr_0p5, D_arr_0p5, size=1), npt.NDArray[np.float64])
+assert_type(def_gen.laplace(D_arr_like_0p5, D_arr_like_0p5, size=1), npt.NDArray[np.float64])
+
+assert_type(def_gen.logistic(0.5, 0.5), float)
+assert_type(def_gen.logistic(0.5, 0.5, size=None), float)
+assert_type(def_gen.logistic(0.5, 0.5, size=1), npt.NDArray[np.float64])
+assert_type(def_gen.logistic(D_arr_0p5, 0.5), npt.NDArray[np.float64])
+assert_type(def_gen.logistic(0.5, D_arr_0p5), npt.NDArray[np.float64])
+assert_type(def_gen.logistic(D_arr_0p5, 0.5, size=1), npt.NDArray[np.float64])
+assert_type(def_gen.logistic(0.5, D_arr_0p5, size=1), npt.NDArray[np.float64])
+assert_type(def_gen.logistic(D_arr_like_0p5, 0.5), npt.NDArray[np.float64])
+assert_type(def_gen.logistic(0.5, D_arr_like_0p5), npt.NDArray[np.float64])
+assert_type(def_gen.logistic(D_arr_0p5, D_arr_0p5), npt.NDArray[np.float64])
+assert_type(def_gen.logistic(D_arr_like_0p5, D_arr_like_0p5), npt.NDArray[np.float64])
+assert_type(def_gen.logistic(D_arr_0p5, D_arr_0p5, size=1), npt.NDArray[np.float64])
+assert_type(def_gen.logistic(D_arr_like_0p5, D_arr_like_0p5, size=1), npt.NDArray[np.float64])
+
+assert_type(def_gen.lognormal(0.5, 0.5), float)
+assert_type(def_gen.lognormal(0.5, 0.5, size=None), float)
+assert_type(def_gen.lognormal(0.5, 0.5, size=1), npt.NDArray[np.float64])
+assert_type(def_gen.lognormal(D_arr_0p5, 0.5), npt.NDArray[np.float64])
+assert_type(def_gen.lognormal(0.5, D_arr_0p5), npt.NDArray[np.float64])
+assert_type(def_gen.lognormal(D_arr_0p5, 0.5, size=1), npt.NDArray[np.float64])
+assert_type(def_gen.lognormal(0.5, D_arr_0p5, size=1), npt.NDArray[np.float64])
+assert_type(def_gen.lognormal(D_arr_like_0p5, 0.5), npt.NDArray[np.float64])
+assert_type(def_gen.lognormal(0.5, D_arr_like_0p5), npt.NDArray[np.float64])
+assert_type(def_gen.lognormal(D_arr_0p5, D_arr_0p5), npt.NDArray[np.float64])
+assert_type(def_gen.lognormal(D_arr_like_0p5, D_arr_like_0p5), npt.NDArray[np.float64])
+assert_type(def_gen.lognormal(D_arr_0p5, D_arr_0p5, size=1), npt.NDArray[np.float64])
+assert_type(def_gen.lognormal(D_arr_like_0p5, D_arr_like_0p5, size=1), npt.NDArray[np.float64])
+
+assert_type(def_gen.noncentral_chisquare(0.5, 0.5), float)
+assert_type(def_gen.noncentral_chisquare(0.5, 0.5, size=None), float)
+assert_type(def_gen.noncentral_chisquare(0.5, 0.5, size=1), npt.NDArray[np.float64])
+assert_type(def_gen.noncentral_chisquare(D_arr_0p5, 0.5), npt.NDArray[np.float64])
+assert_type(def_gen.noncentral_chisquare(0.5, D_arr_0p5), npt.NDArray[np.float64])
+assert_type(def_gen.noncentral_chisquare(D_arr_0p5, 0.5, size=1), npt.NDArray[np.float64])
+assert_type(def_gen.noncentral_chisquare(0.5, D_arr_0p5, size=1), npt.NDArray[np.float64])
+assert_type(def_gen.noncentral_chisquare(D_arr_like_0p5, 0.5), npt.NDArray[np.float64])
+assert_type(def_gen.noncentral_chisquare(0.5, D_arr_like_0p5), npt.NDArray[np.float64])
+assert_type(def_gen.noncentral_chisquare(D_arr_0p5, D_arr_0p5), npt.NDArray[np.float64])
+assert_type(def_gen.noncentral_chisquare(D_arr_like_0p5, D_arr_like_0p5), npt.NDArray[np.float64])
+assert_type(def_gen.noncentral_chisquare(D_arr_0p5, D_arr_0p5, size=1), npt.NDArray[np.float64])
+assert_type(def_gen.noncentral_chisquare(D_arr_like_0p5, D_arr_like_0p5, size=1), npt.NDArray[np.float64])
+
+assert_type(def_gen.normal(0.5, 0.5), float)
+assert_type(def_gen.normal(0.5, 0.5, size=None), float)
+assert_type(def_gen.normal(0.5, 0.5, size=1), npt.NDArray[np.float64])
+assert_type(def_gen.normal(D_arr_0p5, 0.5), npt.NDArray[np.float64])
+assert_type(def_gen.normal(0.5, D_arr_0p5), npt.NDArray[np.float64])
+assert_type(def_gen.normal(D_arr_0p5, 0.5, size=1), npt.NDArray[np.float64])
+assert_type(def_gen.normal(0.5, D_arr_0p5, size=1), npt.NDArray[np.float64])
+assert_type(def_gen.normal(D_arr_like_0p5, 0.5), npt.NDArray[np.float64])
+assert_type(def_gen.normal(0.5, D_arr_like_0p5), npt.NDArray[np.float64])
+assert_type(def_gen.normal(D_arr_0p5, D_arr_0p5), npt.NDArray[np.float64])
+assert_type(def_gen.normal(D_arr_like_0p5, D_arr_like_0p5), npt.NDArray[np.float64])
+assert_type(def_gen.normal(D_arr_0p5, D_arr_0p5, size=1), npt.NDArray[np.float64])
+assert_type(def_gen.normal(D_arr_like_0p5, D_arr_like_0p5, size=1), npt.NDArray[np.float64])
+
+assert_type(def_gen.triangular(0.1, 0.5, 0.9), float)
+assert_type(def_gen.triangular(0.1, 0.5, 0.9, size=None), float)
+assert_type(def_gen.triangular(0.1, 0.5, 0.9, size=1), npt.NDArray[np.float64])
+assert_type(def_gen.triangular(D_arr_0p1, 0.5, 0.9), npt.NDArray[np.float64])
+assert_type(def_gen.triangular(0.1, D_arr_0p5, 0.9), npt.NDArray[np.float64])
+assert_type(def_gen.triangular(D_arr_0p1, 0.5, D_arr_like_0p9, size=1), npt.NDArray[np.float64])
+assert_type(def_gen.triangular(0.1, D_arr_0p5, 0.9, size=1), npt.NDArray[np.float64])
+assert_type(def_gen.triangular(D_arr_like_0p1, 0.5, D_arr_0p9), npt.NDArray[np.float64])
+assert_type(def_gen.triangular(0.5, D_arr_like_0p5, 0.9), npt.NDArray[np.float64])
+assert_type(def_gen.triangular(D_arr_0p1, D_arr_0p5, 0.9), npt.NDArray[np.float64])
+assert_type(def_gen.triangular(D_arr_like_0p1, D_arr_like_0p5, 0.9), npt.NDArray[np.float64])
+assert_type(def_gen.triangular(D_arr_0p1, D_arr_0p5, D_arr_0p9, size=1), npt.NDArray[np.float64])
+assert_type(def_gen.triangular(D_arr_like_0p1, D_arr_like_0p5, D_arr_like_0p9, size=1), npt.NDArray[np.float64])
+
+assert_type(def_gen.noncentral_f(0.1, 0.5, 0.9), float)
+assert_type(def_gen.noncentral_f(0.1, 0.5, 0.9, size=None), float)
+assert_type(def_gen.noncentral_f(0.1, 0.5, 0.9, size=1), npt.NDArray[np.float64])
+assert_type(def_gen.noncentral_f(D_arr_0p1, 0.5, 0.9), npt.NDArray[np.float64])
+assert_type(def_gen.noncentral_f(0.1, D_arr_0p5, 0.9), npt.NDArray[np.float64])
+assert_type(def_gen.noncentral_f(D_arr_0p1, 0.5, D_arr_like_0p9, size=1), npt.NDArray[np.float64])
+assert_type(def_gen.noncentral_f(0.1, D_arr_0p5, 0.9, size=1), npt.NDArray[np.float64])
+assert_type(def_gen.noncentral_f(D_arr_like_0p1, 0.5, D_arr_0p9), npt.NDArray[np.float64])
+assert_type(def_gen.noncentral_f(0.5, D_arr_like_0p5, 0.9), npt.NDArray[np.float64])
+assert_type(def_gen.noncentral_f(D_arr_0p1, D_arr_0p5, 0.9), npt.NDArray[np.float64])
+assert_type(def_gen.noncentral_f(D_arr_like_0p1, D_arr_like_0p5, 0.9), npt.NDArray[np.float64])
+assert_type(def_gen.noncentral_f(D_arr_0p1, D_arr_0p5, D_arr_0p9, size=1), npt.NDArray[np.float64])
+assert_type(def_gen.noncentral_f(D_arr_like_0p1, D_arr_like_0p5, D_arr_like_0p9, size=1), npt.NDArray[np.float64])
+
+assert_type(def_gen.binomial(10, 0.5), int)
+assert_type(def_gen.binomial(10, 0.5, size=None), int)
+assert_type(def_gen.binomial(10, 0.5, size=1), npt.NDArray[np.int64])
+assert_type(def_gen.binomial(I_arr_10, 0.5), npt.NDArray[np.int64])
+assert_type(def_gen.binomial(10, D_arr_0p5), npt.NDArray[np.int64])
+assert_type(def_gen.binomial(I_arr_10, 0.5, size=1), npt.NDArray[np.int64])
+assert_type(def_gen.binomial(10, D_arr_0p5, size=1), npt.NDArray[np.int64])
+assert_type(def_gen.binomial(I_arr_like_10, 0.5), npt.NDArray[np.int64])
+assert_type(def_gen.binomial(10, D_arr_like_0p5), npt.NDArray[np.int64])
+assert_type(def_gen.binomial(I_arr_10, D_arr_0p5), npt.NDArray[np.int64])
+assert_type(def_gen.binomial(I_arr_like_10, D_arr_like_0p5), npt.NDArray[np.int64])
+assert_type(def_gen.binomial(I_arr_10, D_arr_0p5, size=1), npt.NDArray[np.int64])
+assert_type(def_gen.binomial(I_arr_like_10, D_arr_like_0p5, size=1), npt.NDArray[np.int64])
+
+assert_type(def_gen.negative_binomial(10, 0.5), int)
+assert_type(def_gen.negative_binomial(10, 0.5, size=None), int)
+assert_type(def_gen.negative_binomial(10, 0.5, size=1), npt.NDArray[np.int64])
+assert_type(def_gen.negative_binomial(I_arr_10, 0.5), npt.NDArray[np.int64])
+assert_type(def_gen.negative_binomial(10, D_arr_0p5), npt.NDArray[np.int64])
+assert_type(def_gen.negative_binomial(I_arr_10, 0.5, size=1), npt.NDArray[np.int64])
+assert_type(def_gen.negative_binomial(10, D_arr_0p5, size=1), npt.NDArray[np.int64])
+assert_type(def_gen.negative_binomial(I_arr_like_10, 0.5), npt.NDArray[np.int64])
+assert_type(def_gen.negative_binomial(10, D_arr_like_0p5), npt.NDArray[np.int64])
+assert_type(def_gen.negative_binomial(I_arr_10, D_arr_0p5), npt.NDArray[np.int64])
+assert_type(def_gen.negative_binomial(I_arr_like_10, D_arr_like_0p5), npt.NDArray[np.int64])
+assert_type(def_gen.negative_binomial(I_arr_10, D_arr_0p5, size=1), npt.NDArray[np.int64])
+assert_type(def_gen.negative_binomial(I_arr_like_10, D_arr_like_0p5, size=1), npt.NDArray[np.int64])
+
+assert_type(def_gen.hypergeometric(20, 20, 10), int)
+assert_type(def_gen.hypergeometric(20, 20, 10, size=None), int)
+assert_type(def_gen.hypergeometric(20, 20, 10, size=1), npt.NDArray[np.int64])
+assert_type(def_gen.hypergeometric(I_arr_20, 20, 10), npt.NDArray[np.int64])
+assert_type(def_gen.hypergeometric(20, I_arr_20, 10), npt.NDArray[np.int64])
+assert_type(def_gen.hypergeometric(I_arr_20, 20, I_arr_like_10, size=1), npt.NDArray[np.int64])
+assert_type(def_gen.hypergeometric(20, I_arr_20, 10, size=1), npt.NDArray[np.int64])
+assert_type(def_gen.hypergeometric(I_arr_like_20, 20, I_arr_10), npt.NDArray[np.int64])
+assert_type(def_gen.hypergeometric(20, I_arr_like_20, 10), npt.NDArray[np.int64])
+assert_type(def_gen.hypergeometric(I_arr_20, I_arr_20, 10), npt.NDArray[np.int64])
+assert_type(def_gen.hypergeometric(I_arr_like_20, I_arr_like_20, 10), npt.NDArray[np.int64])
+assert_type(def_gen.hypergeometric(I_arr_20, I_arr_20, I_arr_10, size=1), npt.NDArray[np.int64])
+assert_type(def_gen.hypergeometric(I_arr_like_20, I_arr_like_20, I_arr_like_10, size=1), npt.NDArray[np.int64])
+
+I_int64_100: npt.NDArray[np.int64] = np.array([100], dtype=np.int64)
+
+assert_type(def_gen.integers(0, 100), int)
+assert_type(def_gen.integers(100), int)
+assert_type(def_gen.integers([100]), npt.NDArray[np.int64])
+assert_type(def_gen.integers(0, [100]), npt.NDArray[np.int64])
+
+I_bool_low: npt.NDArray[np.bool] = np.array([0], dtype=np.bool)
+I_bool_low_like: list[int] = [0]
+I_bool_high_open: npt.NDArray[np.bool] = np.array([1], dtype=np.bool)
+I_bool_high_closed: npt.NDArray[np.bool] = np.array([1], dtype=np.bool)
+
+assert_type(def_gen.integers(2, dtype=bool), bool)
+assert_type(def_gen.integers(0, 2, dtype=bool), bool)
+assert_type(def_gen.integers(1, dtype=bool, endpoint=True), bool)
+assert_type(def_gen.integers(0, 1, dtype=bool, endpoint=True), bool)
+assert_type(def_gen.integers(I_bool_low_like, 1, dtype=bool, endpoint=True), npt.NDArray[np.bool])
+assert_type(def_gen.integers(I_bool_high_open, dtype=bool), npt.NDArray[np.bool])
+assert_type(def_gen.integers(I_bool_low, I_bool_high_open, dtype=bool), npt.NDArray[np.bool])
+assert_type(def_gen.integers(0, I_bool_high_open, dtype=bool), npt.NDArray[np.bool])
+assert_type(def_gen.integers(I_bool_high_closed, dtype=bool, endpoint=True), npt.NDArray[np.bool])
+assert_type(def_gen.integers(I_bool_low, I_bool_high_closed, dtype=bool, endpoint=True), npt.NDArray[np.bool])
+assert_type(def_gen.integers(0, I_bool_high_closed, dtype=bool, endpoint=True), npt.NDArray[np.bool])
+
+assert_type(def_gen.integers(2, dtype=np.bool), np.bool)
+assert_type(def_gen.integers(0, 2, dtype=np.bool), np.bool)
+assert_type(def_gen.integers(1, dtype=np.bool, endpoint=True), np.bool)
+assert_type(def_gen.integers(0, 1, dtype=np.bool, endpoint=True), np.bool)
+assert_type(def_gen.integers(I_bool_low_like, 1, dtype=np.bool, endpoint=True), npt.NDArray[np.bool])
+assert_type(def_gen.integers(I_bool_high_open, dtype=np.bool), npt.NDArray[np.bool])
+assert_type(def_gen.integers(I_bool_low, I_bool_high_open, dtype=np.bool), npt.NDArray[np.bool])
+assert_type(def_gen.integers(0, I_bool_high_open, dtype=np.bool), npt.NDArray[np.bool])
+assert_type(def_gen.integers(I_bool_high_closed, dtype=np.bool, endpoint=True), npt.NDArray[np.bool])
+assert_type(def_gen.integers(I_bool_low, I_bool_high_closed, dtype=np.bool, endpoint=True), npt.NDArray[np.bool])
+assert_type(def_gen.integers(0, I_bool_high_closed, dtype=np.bool, endpoint=True), npt.NDArray[np.bool])
+
+I_u1_low: npt.NDArray[np.uint8] = np.array([0], dtype=np.uint8)
+I_u1_low_like: list[int] = [0]
+I_u1_high_open: npt.NDArray[np.uint8] = np.array([255], dtype=np.uint8)
+I_u1_high_closed: npt.NDArray[np.uint8] = np.array([255], dtype=np.uint8)
+
+assert_type(def_gen.integers(256, dtype="u1"), np.uint8)
+assert_type(def_gen.integers(0, 256, dtype="u1"), np.uint8)
+assert_type(def_gen.integers(255, dtype="u1", endpoint=True), np.uint8)
+assert_type(def_gen.integers(0, 255, dtype="u1", endpoint=True), np.uint8)
+assert_type(def_gen.integers(I_u1_low_like, 255, dtype="u1", endpoint=True), npt.NDArray[np.uint8])
+assert_type(def_gen.integers(I_u1_high_open, dtype="u1"), npt.NDArray[np.uint8])
+assert_type(def_gen.integers(I_u1_low, I_u1_high_open, dtype="u1"), npt.NDArray[np.uint8])
+assert_type(def_gen.integers(0, I_u1_high_open, dtype="u1"), npt.NDArray[np.uint8])
+assert_type(def_gen.integers(I_u1_high_closed, dtype="u1", endpoint=True), npt.NDArray[np.uint8])
+assert_type(def_gen.integers(I_u1_low, I_u1_high_closed, dtype="u1", endpoint=True), npt.NDArray[np.uint8])
+assert_type(def_gen.integers(0, I_u1_high_closed, dtype="u1", endpoint=True), npt.NDArray[np.uint8])
+
+assert_type(def_gen.integers(256, dtype="uint8"), np.uint8)
+assert_type(def_gen.integers(0, 256, dtype="uint8"), np.uint8)
+assert_type(def_gen.integers(255, dtype="uint8", endpoint=True), np.uint8)
+assert_type(def_gen.integers(0, 255, dtype="uint8", endpoint=True), np.uint8)
+assert_type(def_gen.integers(I_u1_low_like, 255, dtype="uint8", endpoint=True), npt.NDArray[np.uint8])
+assert_type(def_gen.integers(I_u1_high_open, dtype="uint8"), npt.NDArray[np.uint8])
+assert_type(def_gen.integers(I_u1_low, I_u1_high_open, dtype="uint8"), npt.NDArray[np.uint8])
+assert_type(def_gen.integers(0, I_u1_high_open, dtype="uint8"), npt.NDArray[np.uint8])
+assert_type(def_gen.integers(I_u1_high_closed, dtype="uint8", endpoint=True), npt.NDArray[np.uint8])
+assert_type(def_gen.integers(I_u1_low, I_u1_high_closed, dtype="uint8", endpoint=True), npt.NDArray[np.uint8])
+assert_type(def_gen.integers(0, I_u1_high_closed, dtype="uint8", endpoint=True), npt.NDArray[np.uint8])
+
+assert_type(def_gen.integers(256, dtype=np.uint8), np.uint8)
+assert_type(def_gen.integers(0, 256, dtype=np.uint8), np.uint8)
+assert_type(def_gen.integers(255, dtype=np.uint8, endpoint=True), np.uint8)
+assert_type(def_gen.integers(0, 255, dtype=np.uint8, endpoint=True), np.uint8)
+assert_type(def_gen.integers(I_u1_low_like, 255, dtype=np.uint8, endpoint=True), npt.NDArray[np.uint8])
+assert_type(def_gen.integers(I_u1_high_open, dtype=np.uint8), npt.NDArray[np.uint8])
+assert_type(def_gen.integers(I_u1_low, I_u1_high_open, dtype=np.uint8), npt.NDArray[np.uint8])
+assert_type(def_gen.integers(0, I_u1_high_open, dtype=np.uint8), npt.NDArray[np.uint8])
+assert_type(def_gen.integers(I_u1_high_closed, dtype=np.uint8, endpoint=True), npt.NDArray[np.uint8])
+assert_type(def_gen.integers(I_u1_low, I_u1_high_closed, dtype=np.uint8, endpoint=True), npt.NDArray[np.uint8])
+assert_type(def_gen.integers(0, I_u1_high_closed, dtype=np.uint8, endpoint=True), npt.NDArray[np.uint8])
+
+I_u2_low: npt.NDArray[np.uint16] = np.array([0], dtype=np.uint16)
+I_u2_low_like: list[int] = [0]
+I_u2_high_open: npt.NDArray[np.uint16] = np.array([65535], dtype=np.uint16)
+I_u2_high_closed: npt.NDArray[np.uint16] = np.array([65535], dtype=np.uint16)
+
+assert_type(def_gen.integers(65536, dtype="u2"), np.uint16)
+assert_type(def_gen.integers(0, 65536, dtype="u2"), np.uint16)
+assert_type(def_gen.integers(65535, dtype="u2", endpoint=True), np.uint16)
+assert_type(def_gen.integers(0, 65535, dtype="u2", endpoint=True), np.uint16)
+assert_type(def_gen.integers(I_u2_low_like, 65535, dtype="u2", endpoint=True), npt.NDArray[np.uint16])
+assert_type(def_gen.integers(I_u2_high_open, dtype="u2"), npt.NDArray[np.uint16])
+assert_type(def_gen.integers(I_u2_low, I_u2_high_open, dtype="u2"), npt.NDArray[np.uint16])
+assert_type(def_gen.integers(0, I_u2_high_open, dtype="u2"), npt.NDArray[np.uint16])
+assert_type(def_gen.integers(I_u2_high_closed, dtype="u2", endpoint=True), npt.NDArray[np.uint16])
+assert_type(def_gen.integers(I_u2_low, I_u2_high_closed, dtype="u2", endpoint=True), npt.NDArray[np.uint16])
+assert_type(def_gen.integers(0, I_u2_high_closed, dtype="u2", endpoint=True), npt.NDArray[np.uint16])
+
+assert_type(def_gen.integers(65536, dtype="uint16"), np.uint16)
+assert_type(def_gen.integers(0, 65536, dtype="uint16"), np.uint16)
+assert_type(def_gen.integers(65535, dtype="uint16", endpoint=True), np.uint16)
+assert_type(def_gen.integers(0, 65535, dtype="uint16", endpoint=True), np.uint16)
+assert_type(def_gen.integers(I_u2_low_like, 65535, dtype="uint16", endpoint=True), npt.NDArray[np.uint16])
+assert_type(def_gen.integers(I_u2_high_open, dtype="uint16"), npt.NDArray[np.uint16])
+assert_type(def_gen.integers(I_u2_low, I_u2_high_open, dtype="uint16"), npt.NDArray[np.uint16])
+assert_type(def_gen.integers(0, I_u2_high_open, dtype="uint16"), npt.NDArray[np.uint16])
+assert_type(def_gen.integers(I_u2_high_closed, dtype="uint16", endpoint=True), npt.NDArray[np.uint16])
+assert_type(def_gen.integers(I_u2_low, I_u2_high_closed, dtype="uint16", endpoint=True), npt.NDArray[np.uint16])
+assert_type(def_gen.integers(0, I_u2_high_closed, dtype="uint16", endpoint=True), npt.NDArray[np.uint16])
+
+assert_type(def_gen.integers(65536, dtype=np.uint16), np.uint16)
+assert_type(def_gen.integers(0, 65536, dtype=np.uint16), np.uint16)
+assert_type(def_gen.integers(65535, dtype=np.uint16, endpoint=True), np.uint16)
+assert_type(def_gen.integers(0, 65535, dtype=np.uint16, endpoint=True), np.uint16)
+assert_type(def_gen.integers(I_u2_low_like, 65535, dtype=np.uint16, endpoint=True), npt.NDArray[np.uint16])
+assert_type(def_gen.integers(I_u2_high_open, dtype=np.uint16), npt.NDArray[np.uint16])
+assert_type(def_gen.integers(I_u2_low, I_u2_high_open, dtype=np.uint16), npt.NDArray[np.uint16])
+assert_type(def_gen.integers(0, I_u2_high_open, dtype=np.uint16), npt.NDArray[np.uint16])
+assert_type(def_gen.integers(I_u2_high_closed, dtype=np.uint16, endpoint=True), npt.NDArray[np.uint16])
+assert_type(def_gen.integers(I_u2_low, I_u2_high_closed, dtype=np.uint16, endpoint=True), npt.NDArray[np.uint16])
+assert_type(def_gen.integers(0, I_u2_high_closed, dtype=np.uint16, endpoint=True), npt.NDArray[np.uint16])
+
+I_u4_low: npt.NDArray[np.uint32] = np.array([0], dtype=np.uint32)
+I_u4_low_like: list[int] = [0]
+I_u4_high_open: npt.NDArray[np.uint32] = np.array([4294967295], dtype=np.uint32)
+I_u4_high_closed: npt.NDArray[np.uint32] = np.array([4294967295], dtype=np.uint32)
+
+assert_type(def_gen.integers(4294967296, dtype=np.int_), np.int_)
+assert_type(def_gen.integers(0, 4294967296, dtype=np.int_), np.int_)
+assert_type(def_gen.integers(4294967295, dtype=np.int_, endpoint=True), np.int_)
+assert_type(def_gen.integers(0, 4294967295, dtype=np.int_, endpoint=True), np.int_)
+assert_type(def_gen.integers(I_u4_low_like, 4294967295, dtype=np.int_, endpoint=True), npt.NDArray[np.int_])
+assert_type(def_gen.integers(I_u4_high_open, dtype=np.int_), npt.NDArray[np.int_])
+assert_type(def_gen.integers(I_u4_low, I_u4_high_open, dtype=np.int_), npt.NDArray[np.int_])
+assert_type(def_gen.integers(0, I_u4_high_open, dtype=np.int_), npt.NDArray[np.int_])
+assert_type(def_gen.integers(I_u4_high_closed, dtype=np.int_, endpoint=True), npt.NDArray[np.int_])
+assert_type(def_gen.integers(I_u4_low, I_u4_high_closed, dtype=np.int_, endpoint=True), npt.NDArray[np.int_])
+assert_type(def_gen.integers(0, I_u4_high_closed, dtype=np.int_, endpoint=True), npt.NDArray[np.int_])
+
+
+assert_type(def_gen.integers(4294967296, dtype="u4"), np.uint32)
+assert_type(def_gen.integers(0, 4294967296, dtype="u4"), np.uint32)
+assert_type(def_gen.integers(4294967295, dtype="u4", endpoint=True), np.uint32)
+assert_type(def_gen.integers(0, 4294967295, dtype="u4", endpoint=True), np.uint32)
+assert_type(def_gen.integers(I_u4_low_like, 4294967295, dtype="u4", endpoint=True), npt.NDArray[np.uint32])
+assert_type(def_gen.integers(I_u4_high_open, dtype="u4"), npt.NDArray[np.uint32])
+assert_type(def_gen.integers(I_u4_low, I_u4_high_open, dtype="u4"), npt.NDArray[np.uint32])
+assert_type(def_gen.integers(0, I_u4_high_open, dtype="u4"), npt.NDArray[np.uint32])
+assert_type(def_gen.integers(I_u4_high_closed, dtype="u4", endpoint=True), npt.NDArray[np.uint32])
+assert_type(def_gen.integers(I_u4_low, I_u4_high_closed, dtype="u4", endpoint=True), npt.NDArray[np.uint32])
+assert_type(def_gen.integers(0, I_u4_high_closed, dtype="u4", endpoint=True), npt.NDArray[np.uint32])
+
+assert_type(def_gen.integers(4294967296, dtype="uint32"), np.uint32)
+assert_type(def_gen.integers(0, 4294967296, dtype="uint32"), np.uint32)
+assert_type(def_gen.integers(4294967295, dtype="uint32", endpoint=True), np.uint32)
+assert_type(def_gen.integers(0, 4294967295, dtype="uint32", endpoint=True), np.uint32)
+assert_type(def_gen.integers(I_u4_low_like, 4294967295, dtype="uint32", endpoint=True), npt.NDArray[np.uint32])
+assert_type(def_gen.integers(I_u4_high_open, dtype="uint32"), npt.NDArray[np.uint32])
+assert_type(def_gen.integers(I_u4_low, I_u4_high_open, dtype="uint32"), npt.NDArray[np.uint32])
+assert_type(def_gen.integers(0, I_u4_high_open, dtype="uint32"), npt.NDArray[np.uint32])
+assert_type(def_gen.integers(I_u4_high_closed, dtype="uint32", endpoint=True), npt.NDArray[np.uint32])
+assert_type(def_gen.integers(I_u4_low, I_u4_high_closed, dtype="uint32", endpoint=True), npt.NDArray[np.uint32])
+assert_type(def_gen.integers(0, I_u4_high_closed, dtype="uint32", endpoint=True), npt.NDArray[np.uint32])
+
+assert_type(def_gen.integers(4294967296, dtype=np.uint32), np.uint32)
+assert_type(def_gen.integers(0, 4294967296, dtype=np.uint32), np.uint32)
+assert_type(def_gen.integers(4294967295, dtype=np.uint32, endpoint=True), np.uint32)
+assert_type(def_gen.integers(0, 4294967295, dtype=np.uint32, endpoint=True), np.uint32)
+assert_type(def_gen.integers(I_u4_low_like, 4294967295, dtype=np.uint32, endpoint=True), npt.NDArray[np.uint32])
+assert_type(def_gen.integers(I_u4_high_open, dtype=np.uint32), npt.NDArray[np.uint32])
+assert_type(def_gen.integers(I_u4_low, I_u4_high_open, dtype=np.uint32), npt.NDArray[np.uint32])
+assert_type(def_gen.integers(0, I_u4_high_open, dtype=np.uint32), npt.NDArray[np.uint32])
+assert_type(def_gen.integers(I_u4_high_closed, dtype=np.uint32, endpoint=True), npt.NDArray[np.uint32])
+assert_type(def_gen.integers(I_u4_low, I_u4_high_closed, dtype=np.uint32, endpoint=True), npt.NDArray[np.uint32])
+assert_type(def_gen.integers(0, I_u4_high_closed, dtype=np.uint32, endpoint=True), npt.NDArray[np.uint32])
+
+assert_type(def_gen.integers(4294967296, dtype=np.uint), np.uint)
+assert_type(def_gen.integers(0, 4294967296, dtype=np.uint), np.uint)
+assert_type(def_gen.integers(4294967295, dtype=np.uint, endpoint=True), np.uint)
+assert_type(def_gen.integers(0, 4294967295, dtype=np.uint, endpoint=True), np.uint)
+assert_type(def_gen.integers(I_u4_low_like, 4294967295, dtype=np.uint, endpoint=True), npt.NDArray[np.uint])
+assert_type(def_gen.integers(I_u4_high_open, dtype=np.uint), npt.NDArray[np.uint])
+assert_type(def_gen.integers(I_u4_low, I_u4_high_open, dtype=np.uint), npt.NDArray[np.uint])
+assert_type(def_gen.integers(0, I_u4_high_open, dtype=np.uint), npt.NDArray[np.uint])
+assert_type(def_gen.integers(I_u4_high_closed, dtype=np.uint, endpoint=True), npt.NDArray[np.uint])
+assert_type(def_gen.integers(I_u4_low, I_u4_high_closed, dtype=np.uint, endpoint=True), npt.NDArray[np.uint])
+assert_type(def_gen.integers(0, I_u4_high_closed, dtype=np.uint, endpoint=True), npt.NDArray[np.uint])
+
+I_u8_low: npt.NDArray[np.uint64] = np.array([0], dtype=np.uint64)
+I_u8_low_like: list[int] = [0]
+I_u8_high_open: npt.NDArray[np.uint64] = np.array([18446744073709551615], dtype=np.uint64)
+I_u8_high_closed: npt.NDArray[np.uint64] = np.array([18446744073709551615], dtype=np.uint64)
+
+assert_type(def_gen.integers(18446744073709551616, dtype="u8"), np.uint64)
+assert_type(def_gen.integers(0, 18446744073709551616, dtype="u8"), np.uint64)
+assert_type(def_gen.integers(18446744073709551615, dtype="u8", endpoint=True), np.uint64)
+assert_type(def_gen.integers(0, 18446744073709551615, dtype="u8", endpoint=True), np.uint64)
+assert_type(def_gen.integers(I_u8_low_like, 18446744073709551615, dtype="u8", endpoint=True), npt.NDArray[np.uint64])
+assert_type(def_gen.integers(I_u8_high_open, dtype="u8"), npt.NDArray[np.uint64])
+assert_type(def_gen.integers(I_u8_low, I_u8_high_open, dtype="u8"), npt.NDArray[np.uint64])
+assert_type(def_gen.integers(0, I_u8_high_open, dtype="u8"), npt.NDArray[np.uint64])
+assert_type(def_gen.integers(I_u8_high_closed, dtype="u8", endpoint=True), npt.NDArray[np.uint64])
+assert_type(def_gen.integers(I_u8_low, I_u8_high_closed, dtype="u8", endpoint=True), npt.NDArray[np.uint64])
+assert_type(def_gen.integers(0, I_u8_high_closed, dtype="u8", endpoint=True), npt.NDArray[np.uint64])
+
+assert_type(def_gen.integers(18446744073709551616, dtype="uint64"), np.uint64)
+assert_type(def_gen.integers(0, 18446744073709551616, dtype="uint64"), np.uint64)
+assert_type(def_gen.integers(18446744073709551615, dtype="uint64", endpoint=True), np.uint64)
+assert_type(def_gen.integers(0, 18446744073709551615, dtype="uint64", endpoint=True), np.uint64)
+assert_type(def_gen.integers(I_u8_low_like, 18446744073709551615, dtype="uint64", endpoint=True), npt.NDArray[np.uint64])
+assert_type(def_gen.integers(I_u8_high_open, dtype="uint64"), npt.NDArray[np.uint64])
+assert_type(def_gen.integers(I_u8_low, I_u8_high_open, dtype="uint64"), npt.NDArray[np.uint64])
+assert_type(def_gen.integers(0, I_u8_high_open, dtype="uint64"), npt.NDArray[np.uint64])
+assert_type(def_gen.integers(I_u8_high_closed, dtype="uint64", endpoint=True), npt.NDArray[np.uint64])
+assert_type(def_gen.integers(I_u8_low, I_u8_high_closed, dtype="uint64", endpoint=True), npt.NDArray[np.uint64])
+assert_type(def_gen.integers(0, I_u8_high_closed, dtype="uint64", endpoint=True), npt.NDArray[np.uint64])
+
+assert_type(def_gen.integers(18446744073709551616, dtype=np.uint64), np.uint64)
+assert_type(def_gen.integers(0, 18446744073709551616, dtype=np.uint64), np.uint64)
+assert_type(def_gen.integers(18446744073709551615, dtype=np.uint64, endpoint=True), np.uint64)
+assert_type(def_gen.integers(0, 18446744073709551615, dtype=np.uint64, endpoint=True), np.uint64)
+assert_type(def_gen.integers(I_u8_low_like, 18446744073709551615, dtype=np.uint64, endpoint=True), npt.NDArray[np.uint64])
+assert_type(def_gen.integers(I_u8_high_open, dtype=np.uint64), npt.NDArray[np.uint64])
+assert_type(def_gen.integers(I_u8_low, I_u8_high_open, dtype=np.uint64), npt.NDArray[np.uint64])
+assert_type(def_gen.integers(0, I_u8_high_open, dtype=np.uint64), npt.NDArray[np.uint64])
+assert_type(def_gen.integers(I_u8_high_closed, dtype=np.uint64, endpoint=True), npt.NDArray[np.uint64])
+assert_type(def_gen.integers(I_u8_low, I_u8_high_closed, dtype=np.uint64, endpoint=True), npt.NDArray[np.uint64])
+assert_type(def_gen.integers(0, I_u8_high_closed, dtype=np.uint64, endpoint=True), npt.NDArray[np.uint64])
+
+I_i1_low: npt.NDArray[np.int8] = np.array([-128], dtype=np.int8)
+I_i1_low_like: list[int] = [-128]
+I_i1_high_open: npt.NDArray[np.int8] = np.array([127], dtype=np.int8)
+I_i1_high_closed: npt.NDArray[np.int8] = np.array([127], dtype=np.int8)
+
+assert_type(def_gen.integers(128, dtype="i1"), np.int8)
+assert_type(def_gen.integers(-128, 128, dtype="i1"), np.int8)
+assert_type(def_gen.integers(127, dtype="i1", endpoint=True), np.int8)
+assert_type(def_gen.integers(-128, 127, dtype="i1", endpoint=True), np.int8)
+assert_type(def_gen.integers(I_i1_low_like, 127, dtype="i1", endpoint=True), npt.NDArray[np.int8])
+assert_type(def_gen.integers(I_i1_high_open, dtype="i1"), npt.NDArray[np.int8])
+assert_type(def_gen.integers(I_i1_low, I_i1_high_open, dtype="i1"), npt.NDArray[np.int8])
+assert_type(def_gen.integers(-128, I_i1_high_open, dtype="i1"), npt.NDArray[np.int8])
+assert_type(def_gen.integers(I_i1_high_closed, dtype="i1", endpoint=True), npt.NDArray[np.int8])
+assert_type(def_gen.integers(I_i1_low, I_i1_high_closed, dtype="i1", endpoint=True), npt.NDArray[np.int8])
+assert_type(def_gen.integers(-128, I_i1_high_closed, dtype="i1", endpoint=True), npt.NDArray[np.int8])
+
+assert_type(def_gen.integers(128, dtype="int8"), np.int8)
+assert_type(def_gen.integers(-128, 128, dtype="int8"), np.int8)
+assert_type(def_gen.integers(127, dtype="int8", endpoint=True), np.int8)
+assert_type(def_gen.integers(-128, 127, dtype="int8", endpoint=True), np.int8)
+assert_type(def_gen.integers(I_i1_low_like, 127, dtype="int8", endpoint=True), npt.NDArray[np.int8])
+assert_type(def_gen.integers(I_i1_high_open, dtype="int8"), npt.NDArray[np.int8])
+assert_type(def_gen.integers(I_i1_low, I_i1_high_open, dtype="int8"), npt.NDArray[np.int8])
+assert_type(def_gen.integers(-128, I_i1_high_open, dtype="int8"), npt.NDArray[np.int8])
+assert_type(def_gen.integers(I_i1_high_closed, dtype="int8", endpoint=True), npt.NDArray[np.int8])
+assert_type(def_gen.integers(I_i1_low, I_i1_high_closed, dtype="int8", endpoint=True), npt.NDArray[np.int8])
+assert_type(def_gen.integers(-128, I_i1_high_closed, dtype="int8", endpoint=True), npt.NDArray[np.int8])
+
+assert_type(def_gen.integers(128, dtype=np.int8), np.int8)
+assert_type(def_gen.integers(-128, 128, dtype=np.int8), np.int8)
+assert_type(def_gen.integers(127, dtype=np.int8, endpoint=True), np.int8)
+assert_type(def_gen.integers(-128, 127, dtype=np.int8, endpoint=True), np.int8)
+assert_type(def_gen.integers(I_i1_low_like, 127, dtype=np.int8, endpoint=True), npt.NDArray[np.int8])
+assert_type(def_gen.integers(I_i1_high_open, dtype=np.int8), npt.NDArray[np.int8])
+assert_type(def_gen.integers(I_i1_low, I_i1_high_open, dtype=np.int8), npt.NDArray[np.int8])
+assert_type(def_gen.integers(-128, I_i1_high_open, dtype=np.int8), npt.NDArray[np.int8])
+assert_type(def_gen.integers(I_i1_high_closed, dtype=np.int8, endpoint=True), npt.NDArray[np.int8])
+assert_type(def_gen.integers(I_i1_low, I_i1_high_closed, dtype=np.int8, endpoint=True), npt.NDArray[np.int8])
+assert_type(def_gen.integers(-128, I_i1_high_closed, dtype=np.int8, endpoint=True), npt.NDArray[np.int8])
+
+I_i2_low: npt.NDArray[np.int16] = np.array([-32768], dtype=np.int16)
+I_i2_low_like: list[int] = [-32768]
+I_i2_high_open: npt.NDArray[np.int16] = np.array([32767], dtype=np.int16)
+I_i2_high_closed: npt.NDArray[np.int16] = np.array([32767], dtype=np.int16)
+
+assert_type(def_gen.integers(32768, dtype="i2"), np.int16)
+assert_type(def_gen.integers(-32768, 32768, dtype="i2"), np.int16)
+assert_type(def_gen.integers(32767, dtype="i2", endpoint=True), np.int16)
+assert_type(def_gen.integers(-32768, 32767, dtype="i2", endpoint=True), np.int16)
+assert_type(def_gen.integers(I_i2_low_like, 32767, dtype="i2", endpoint=True), npt.NDArray[np.int16])
+assert_type(def_gen.integers(I_i2_high_open, dtype="i2"), npt.NDArray[np.int16])
+assert_type(def_gen.integers(I_i2_low, I_i2_high_open, dtype="i2"), npt.NDArray[np.int16])
+assert_type(def_gen.integers(-32768, I_i2_high_open, dtype="i2"), npt.NDArray[np.int16])
+assert_type(def_gen.integers(I_i2_high_closed, dtype="i2", endpoint=True), npt.NDArray[np.int16])
+assert_type(def_gen.integers(I_i2_low, I_i2_high_closed, dtype="i2", endpoint=True), npt.NDArray[np.int16])
+assert_type(def_gen.integers(-32768, I_i2_high_closed, dtype="i2", endpoint=True), npt.NDArray[np.int16])
+
+assert_type(def_gen.integers(32768, dtype="int16"), np.int16)
+assert_type(def_gen.integers(-32768, 32768, dtype="int16"), np.int16)
+assert_type(def_gen.integers(32767, dtype="int16", endpoint=True), np.int16)
+assert_type(def_gen.integers(-32768, 32767, dtype="int16", endpoint=True), np.int16)
+assert_type(def_gen.integers(I_i2_low_like, 32767, dtype="int16", endpoint=True), npt.NDArray[np.int16])
+assert_type(def_gen.integers(I_i2_high_open, dtype="int16"), npt.NDArray[np.int16])
+assert_type(def_gen.integers(I_i2_low, I_i2_high_open, dtype="int16"), npt.NDArray[np.int16])
+assert_type(def_gen.integers(-32768, I_i2_high_open, dtype="int16"), npt.NDArray[np.int16])
+assert_type(def_gen.integers(I_i2_high_closed, dtype="int16", endpoint=True), npt.NDArray[np.int16])
+assert_type(def_gen.integers(I_i2_low, I_i2_high_closed, dtype="int16", endpoint=True), npt.NDArray[np.int16])
+assert_type(def_gen.integers(-32768, I_i2_high_closed, dtype="int16", endpoint=True), npt.NDArray[np.int16])
+
+assert_type(def_gen.integers(32768, dtype=np.int16), np.int16)
+assert_type(def_gen.integers(-32768, 32768, dtype=np.int16), np.int16)
+assert_type(def_gen.integers(32767, dtype=np.int16, endpoint=True), np.int16)
+assert_type(def_gen.integers(-32768, 32767, dtype=np.int16, endpoint=True), np.int16)
+assert_type(def_gen.integers(I_i2_low_like, 32767, dtype=np.int16, endpoint=True), npt.NDArray[np.int16])
+assert_type(def_gen.integers(I_i2_high_open, dtype=np.int16), npt.NDArray[np.int16])
+assert_type(def_gen.integers(I_i2_low, I_i2_high_open, dtype=np.int16), npt.NDArray[np.int16])
+assert_type(def_gen.integers(-32768, I_i2_high_open, dtype=np.int16), npt.NDArray[np.int16])
+assert_type(def_gen.integers(I_i2_high_closed, dtype=np.int16, endpoint=True), npt.NDArray[np.int16])
+assert_type(def_gen.integers(I_i2_low, I_i2_high_closed, dtype=np.int16, endpoint=True), npt.NDArray[np.int16])
+assert_type(def_gen.integers(-32768, I_i2_high_closed, dtype=np.int16, endpoint=True), npt.NDArray[np.int16])
+
+I_i4_low: npt.NDArray[np.int32] = np.array([-2147483648], dtype=np.int32)
+I_i4_low_like: list[int] = [-2147483648]
+I_i4_high_open: npt.NDArray[np.int32] = np.array([2147483647], dtype=np.int32)
+I_i4_high_closed: npt.NDArray[np.int32] = np.array([2147483647], dtype=np.int32)
+
+assert_type(def_gen.integers(2147483648, dtype="i4"), np.int32)
+assert_type(def_gen.integers(-2147483648, 2147483648, dtype="i4"), np.int32)
+assert_type(def_gen.integers(2147483647, dtype="i4", endpoint=True), np.int32)
+assert_type(def_gen.integers(-2147483648, 2147483647, dtype="i4", endpoint=True), np.int32)
+assert_type(def_gen.integers(I_i4_low_like, 2147483647, dtype="i4", endpoint=True), npt.NDArray[np.int32])
+assert_type(def_gen.integers(I_i4_high_open, dtype="i4"), npt.NDArray[np.int32])
+assert_type(def_gen.integers(I_i4_low, I_i4_high_open, dtype="i4"), npt.NDArray[np.int32])
+assert_type(def_gen.integers(-2147483648, I_i4_high_open, dtype="i4"), npt.NDArray[np.int32])
+assert_type(def_gen.integers(I_i4_high_closed, dtype="i4", endpoint=True), npt.NDArray[np.int32])
+assert_type(def_gen.integers(I_i4_low, I_i4_high_closed, dtype="i4", endpoint=True), npt.NDArray[np.int32])
+assert_type(def_gen.integers(-2147483648, I_i4_high_closed, dtype="i4", endpoint=True), npt.NDArray[np.int32])
+
+assert_type(def_gen.integers(2147483648, dtype="int32"), np.int32)
+assert_type(def_gen.integers(-2147483648, 2147483648, dtype="int32"), np.int32)
+assert_type(def_gen.integers(2147483647, dtype="int32", endpoint=True), np.int32)
+assert_type(def_gen.integers(-2147483648, 2147483647, dtype="int32", endpoint=True), np.int32)
+assert_type(def_gen.integers(I_i4_low_like, 2147483647, dtype="int32", endpoint=True), npt.NDArray[np.int32])
+assert_type(def_gen.integers(I_i4_high_open, dtype="int32"), npt.NDArray[np.int32])
+assert_type(def_gen.integers(I_i4_low, I_i4_high_open, dtype="int32"), npt.NDArray[np.int32])
+assert_type(def_gen.integers(-2147483648, I_i4_high_open, dtype="int32"), npt.NDArray[np.int32])
+assert_type(def_gen.integers(I_i4_high_closed, dtype="int32", endpoint=True), npt.NDArray[np.int32])
+assert_type(def_gen.integers(I_i4_low, I_i4_high_closed, dtype="int32", endpoint=True), npt.NDArray[np.int32])
+assert_type(def_gen.integers(-2147483648, I_i4_high_closed, dtype="int32", endpoint=True), npt.NDArray[np.int32])
+
+assert_type(def_gen.integers(2147483648, dtype=np.int32), np.int32)
+assert_type(def_gen.integers(-2147483648, 2147483648, dtype=np.int32), np.int32)
+assert_type(def_gen.integers(2147483647, dtype=np.int32, endpoint=True), np.int32)
+assert_type(def_gen.integers(-2147483648, 2147483647, dtype=np.int32, endpoint=True), np.int32)
+assert_type(def_gen.integers(I_i4_low_like, 2147483647, dtype=np.int32, endpoint=True), npt.NDArray[np.int32])
+assert_type(def_gen.integers(I_i4_high_open, dtype=np.int32), npt.NDArray[np.int32])
+assert_type(def_gen.integers(I_i4_low, I_i4_high_open, dtype=np.int32), npt.NDArray[np.int32])
+assert_type(def_gen.integers(-2147483648, I_i4_high_open, dtype=np.int32), npt.NDArray[np.int32])
+assert_type(def_gen.integers(I_i4_high_closed, dtype=np.int32, endpoint=True), npt.NDArray[np.int32])
+assert_type(def_gen.integers(I_i4_low, I_i4_high_closed, dtype=np.int32, endpoint=True), npt.NDArray[np.int32])
+assert_type(def_gen.integers(-2147483648, I_i4_high_closed, dtype=np.int32, endpoint=True), npt.NDArray[np.int32])
+
+I_i8_low: npt.NDArray[np.int64] = np.array([-9223372036854775808], dtype=np.int64)
+I_i8_low_like: list[int] = [-9223372036854775808]
+I_i8_high_open: npt.NDArray[np.int64] = np.array([9223372036854775807], dtype=np.int64)
+I_i8_high_closed: npt.NDArray[np.int64] = np.array([9223372036854775807], dtype=np.int64)
+
+assert_type(def_gen.integers(9223372036854775808, dtype="i8"), np.int64)
+assert_type(def_gen.integers(-9223372036854775808, 9223372036854775808, dtype="i8"), np.int64)
+assert_type(def_gen.integers(9223372036854775807, dtype="i8", endpoint=True), np.int64)
+assert_type(def_gen.integers(-9223372036854775808, 9223372036854775807, dtype="i8", endpoint=True), np.int64)
+assert_type(def_gen.integers(I_i8_low_like, 9223372036854775807, dtype="i8", endpoint=True), npt.NDArray[np.int64])
+assert_type(def_gen.integers(I_i8_high_open, dtype="i8"), npt.NDArray[np.int64])
+assert_type(def_gen.integers(I_i8_low, I_i8_high_open, dtype="i8"), npt.NDArray[np.int64])
+assert_type(def_gen.integers(-9223372036854775808, I_i8_high_open, dtype="i8"), npt.NDArray[np.int64])
+assert_type(def_gen.integers(I_i8_high_closed, dtype="i8", endpoint=True), npt.NDArray[np.int64])
+assert_type(def_gen.integers(I_i8_low, I_i8_high_closed, dtype="i8", endpoint=True), npt.NDArray[np.int64])
+assert_type(def_gen.integers(-9223372036854775808, I_i8_high_closed, dtype="i8", endpoint=True), npt.NDArray[np.int64])
+
+assert_type(def_gen.integers(9223372036854775808, dtype="int64"), np.int64)
+assert_type(def_gen.integers(-9223372036854775808, 9223372036854775808, dtype="int64"), np.int64)
+assert_type(def_gen.integers(9223372036854775807, dtype="int64", endpoint=True), np.int64)
+assert_type(def_gen.integers(-9223372036854775808, 9223372036854775807, dtype="int64", endpoint=True), np.int64)
+assert_type(def_gen.integers(I_i8_low_like, 9223372036854775807, dtype="int64", endpoint=True), npt.NDArray[np.int64])
+assert_type(def_gen.integers(I_i8_high_open, dtype="int64"), npt.NDArray[np.int64])
+assert_type(def_gen.integers(I_i8_low, I_i8_high_open, dtype="int64"), npt.NDArray[np.int64])
+assert_type(def_gen.integers(-9223372036854775808, I_i8_high_open, dtype="int64"), npt.NDArray[np.int64])
+assert_type(def_gen.integers(I_i8_high_closed, dtype="int64", endpoint=True), npt.NDArray[np.int64])
+assert_type(def_gen.integers(I_i8_low, I_i8_high_closed, dtype="int64", endpoint=True), npt.NDArray[np.int64])
+assert_type(def_gen.integers(-9223372036854775808, I_i8_high_closed, dtype="int64", endpoint=True), npt.NDArray[np.int64])
+
+assert_type(def_gen.integers(9223372036854775808, dtype=np.int64), np.int64)
+assert_type(def_gen.integers(-9223372036854775808, 9223372036854775808, dtype=np.int64), np.int64)
+assert_type(def_gen.integers(9223372036854775807, dtype=np.int64, endpoint=True), np.int64)
+assert_type(def_gen.integers(-9223372036854775808, 9223372036854775807, dtype=np.int64, endpoint=True), np.int64)
+assert_type(def_gen.integers(I_i8_low_like, 9223372036854775807, dtype=np.int64, endpoint=True), npt.NDArray[np.int64])
+assert_type(def_gen.integers(I_i8_high_open, dtype=np.int64), npt.NDArray[np.int64])
+assert_type(def_gen.integers(I_i8_low, I_i8_high_open, dtype=np.int64), npt.NDArray[np.int64])
+assert_type(def_gen.integers(-9223372036854775808, I_i8_high_open, dtype=np.int64), npt.NDArray[np.int64])
+assert_type(def_gen.integers(I_i8_high_closed, dtype=np.int64, endpoint=True), npt.NDArray[np.int64])
+assert_type(def_gen.integers(I_i8_low, I_i8_high_closed, dtype=np.int64, endpoint=True), npt.NDArray[np.int64])
+assert_type(def_gen.integers(-9223372036854775808, I_i8_high_closed, dtype=np.int64, endpoint=True), npt.NDArray[np.int64])
+
+
+assert_type(def_gen.bit_generator, np.random.BitGenerator)
+
+assert_type(def_gen.bytes(2), bytes)
+
+assert_type(def_gen.choice(5), int)
+assert_type(def_gen.choice(5, 3), npt.NDArray[np.int64])
+assert_type(def_gen.choice(5, 3, replace=True), npt.NDArray[np.int64])
+assert_type(def_gen.choice(5, 3, p=[1 / 5] * 5), npt.NDArray[np.int64])
+assert_type(def_gen.choice(5, 3, p=[1 / 5] * 5, replace=False), npt.NDArray[np.int64])
+
+assert_type(def_gen.choice(["pooh", "rabbit", "piglet", "Christopher"]), Any)
+assert_type(def_gen.choice(["pooh", "rabbit", "piglet", "Christopher"], 3), npt.NDArray[Any])
+assert_type(def_gen.choice(["pooh", "rabbit", "piglet", "Christopher"], 3, p=[1 / 4] * 4), npt.NDArray[Any])
+assert_type(def_gen.choice(["pooh", "rabbit", "piglet", "Christopher"], 3, replace=True), npt.NDArray[Any])
+assert_type(def_gen.choice(["pooh", "rabbit", "piglet", "Christopher"], 3, replace=False, p=np.array([1 / 8, 1 / 8, 1 / 2, 1 / 4])), npt.NDArray[Any])
+
+assert_type(def_gen.dirichlet([0.5, 0.5]), npt.NDArray[np.float64])
+assert_type(def_gen.dirichlet(np.array([0.5, 0.5])), npt.NDArray[np.float64])
+assert_type(def_gen.dirichlet(np.array([0.5, 0.5]), size=3), npt.NDArray[np.float64])
+
+assert_type(def_gen.multinomial(20, [1 / 6.0] * 6), npt.NDArray[np.int64])
+assert_type(def_gen.multinomial(20, np.array([0.5, 0.5])), npt.NDArray[np.int64])
+assert_type(def_gen.multinomial(20, [1 / 6.0] * 6, size=2), npt.NDArray[np.int64])
+assert_type(def_gen.multinomial([[10], [20]], [1 / 6.0] * 6, size=(2, 2)), npt.NDArray[np.int64])
+assert_type(def_gen.multinomial(np.array([[10], [20]]), np.array([0.5, 0.5]), size=(2, 2)), npt.NDArray[np.int64])
+
+assert_type(def_gen.multivariate_hypergeometric([3, 5, 7], 2), npt.NDArray[np.int64])
+assert_type(def_gen.multivariate_hypergeometric(np.array([3, 5, 7]), 2), npt.NDArray[np.int64])
+assert_type(def_gen.multivariate_hypergeometric(np.array([3, 5, 7]), 2, size=4), npt.NDArray[np.int64])
+assert_type(def_gen.multivariate_hypergeometric(np.array([3, 5, 7]), 2, size=(4, 7)), npt.NDArray[np.int64])
+assert_type(def_gen.multivariate_hypergeometric([3, 5, 7], 2, method="count"), npt.NDArray[np.int64])
+assert_type(def_gen.multivariate_hypergeometric(np.array([3, 5, 7]), 2, method="marginals"), npt.NDArray[np.int64])
+
+assert_type(def_gen.multivariate_normal([0.0], [[1.0]]), npt.NDArray[np.float64])
+assert_type(def_gen.multivariate_normal([0.0], np.array([[1.0]])), npt.NDArray[np.float64])
+assert_type(def_gen.multivariate_normal(np.array([0.0]), [[1.0]]), npt.NDArray[np.float64])
+assert_type(def_gen.multivariate_normal([0.0], np.array([[1.0]])), npt.NDArray[np.float64])
+
+assert_type(def_gen.permutation(10), npt.NDArray[np.int64])
+assert_type(def_gen.permutation([1, 2, 3, 4]), npt.NDArray[Any])
+assert_type(def_gen.permutation(np.array([1, 2, 3, 4])), npt.NDArray[Any])
+assert_type(def_gen.permutation(D_2D, axis=1), npt.NDArray[Any])
+assert_type(def_gen.permuted(D_2D), npt.NDArray[Any])
+assert_type(def_gen.permuted(D_2D_like), npt.NDArray[Any])
+assert_type(def_gen.permuted(D_2D, axis=1), npt.NDArray[Any])
+assert_type(def_gen.permuted(D_2D, out=D_2D), npt.NDArray[Any])
+assert_type(def_gen.permuted(D_2D_like, out=D_2D), npt.NDArray[Any])
+assert_type(def_gen.permuted(D_2D_like, out=D_2D), npt.NDArray[Any])
+assert_type(def_gen.permuted(D_2D, axis=1, out=D_2D), npt.NDArray[Any])
+
+assert_type(def_gen.shuffle(np.arange(10)), None)
+assert_type(def_gen.shuffle([1, 2, 3, 4, 5]), None)
+assert_type(def_gen.shuffle(D_2D, axis=1), None)
+
+assert_type(np.random.Generator(pcg64), np.random.Generator)
+assert_type(def_gen.__str__(), str)
+assert_type(def_gen.__repr__(), str)
+assert_type(def_gen.__setstate__(dict(def_gen.bit_generator.state)), None)
+
+# RandomState
+random_st: np.random.RandomState = np.random.RandomState()
+
+assert_type(random_st.standard_normal(), float)
+assert_type(random_st.standard_normal(size=None), float)
+assert_type(random_st.standard_normal(size=1), npt.NDArray[np.float64])
+
+assert_type(random_st.random(), float)
+assert_type(random_st.random(size=None), float)
+assert_type(random_st.random(size=1), npt.NDArray[np.float64])
+
+assert_type(random_st.standard_cauchy(), float)
+assert_type(random_st.standard_cauchy(size=None), float)
+assert_type(random_st.standard_cauchy(size=1), npt.NDArray[np.float64])
+
+assert_type(random_st.standard_exponential(), float)
+assert_type(random_st.standard_exponential(size=None), float)
+assert_type(random_st.standard_exponential(size=1), npt.NDArray[np.float64])
+
+assert_type(random_st.zipf(1.5), int)
+assert_type(random_st.zipf(1.5, size=None), int)
+assert_type(random_st.zipf(1.5, size=1), npt.NDArray[np.long])
+assert_type(random_st.zipf(D_arr_1p5), npt.NDArray[np.long])
+assert_type(random_st.zipf(D_arr_1p5, size=1), npt.NDArray[np.long])
+assert_type(random_st.zipf(D_arr_like_1p5), npt.NDArray[np.long])
+assert_type(random_st.zipf(D_arr_like_1p5, size=1), npt.NDArray[np.long])
+
+assert_type(random_st.weibull(0.5), float)
+assert_type(random_st.weibull(0.5, size=None), float)
+assert_type(random_st.weibull(0.5, size=1), npt.NDArray[np.float64])
+assert_type(random_st.weibull(D_arr_0p5), npt.NDArray[np.float64])
+assert_type(random_st.weibull(D_arr_0p5, size=1), npt.NDArray[np.float64])
+assert_type(random_st.weibull(D_arr_like_0p5), npt.NDArray[np.float64])
+assert_type(random_st.weibull(D_arr_like_0p5, size=1), npt.NDArray[np.float64])
+
+assert_type(random_st.standard_t(0.5), float)
+assert_type(random_st.standard_t(0.5, size=None), float)
+assert_type(random_st.standard_t(0.5, size=1), npt.NDArray[np.float64])
+assert_type(random_st.standard_t(D_arr_0p5), npt.NDArray[np.float64])
+assert_type(random_st.standard_t(D_arr_0p5, size=1), npt.NDArray[np.float64])
+assert_type(random_st.standard_t(D_arr_like_0p5), npt.NDArray[np.float64])
+assert_type(random_st.standard_t(D_arr_like_0p5, size=1), npt.NDArray[np.float64])
+
+assert_type(random_st.poisson(0.5), int)
+assert_type(random_st.poisson(0.5, size=None), int)
+assert_type(random_st.poisson(0.5, size=1), npt.NDArray[np.long])
+assert_type(random_st.poisson(D_arr_0p5), npt.NDArray[np.long])
+assert_type(random_st.poisson(D_arr_0p5, size=1), npt.NDArray[np.long])
+assert_type(random_st.poisson(D_arr_like_0p5), npt.NDArray[np.long])
+assert_type(random_st.poisson(D_arr_like_0p5, size=1), npt.NDArray[np.long])
+
+assert_type(random_st.power(0.5), float)
+assert_type(random_st.power(0.5, size=None), float)
+assert_type(random_st.power(0.5, size=1), npt.NDArray[np.float64])
+assert_type(random_st.power(D_arr_0p5), npt.NDArray[np.float64])
+assert_type(random_st.power(D_arr_0p5, size=1), npt.NDArray[np.float64])
+assert_type(random_st.power(D_arr_like_0p5), npt.NDArray[np.float64])
+assert_type(random_st.power(D_arr_like_0p5, size=1), npt.NDArray[np.float64])
+
+assert_type(random_st.pareto(0.5), float)
+assert_type(random_st.pareto(0.5, size=None), float)
+assert_type(random_st.pareto(0.5, size=1), npt.NDArray[np.float64])
+assert_type(random_st.pareto(D_arr_0p5), npt.NDArray[np.float64])
+assert_type(random_st.pareto(D_arr_0p5, size=1), npt.NDArray[np.float64])
+assert_type(random_st.pareto(D_arr_like_0p5), npt.NDArray[np.float64])
+assert_type(random_st.pareto(D_arr_like_0p5, size=1), npt.NDArray[np.float64])
+
+assert_type(random_st.chisquare(0.5), float)
+assert_type(random_st.chisquare(0.5, size=None), float)
+assert_type(random_st.chisquare(0.5, size=1), npt.NDArray[np.float64])
+assert_type(random_st.chisquare(D_arr_0p5), npt.NDArray[np.float64])
+assert_type(random_st.chisquare(D_arr_0p5, size=1), npt.NDArray[np.float64])
+assert_type(random_st.chisquare(D_arr_like_0p5), npt.NDArray[np.float64])
+assert_type(random_st.chisquare(D_arr_like_0p5, size=1), npt.NDArray[np.float64])
+
+assert_type(random_st.exponential(0.5), float)
+assert_type(random_st.exponential(0.5, size=None), float)
+assert_type(random_st.exponential(0.5, size=1), npt.NDArray[np.float64])
+assert_type(random_st.exponential(D_arr_0p5), npt.NDArray[np.float64])
+assert_type(random_st.exponential(D_arr_0p5, size=1), npt.NDArray[np.float64])
+assert_type(random_st.exponential(D_arr_like_0p5), npt.NDArray[np.float64])
+assert_type(random_st.exponential(D_arr_like_0p5, size=1), npt.NDArray[np.float64])
+
+assert_type(random_st.geometric(0.5), int)
+assert_type(random_st.geometric(0.5, size=None), int)
+assert_type(random_st.geometric(0.5, size=1), npt.NDArray[np.long])
+assert_type(random_st.geometric(D_arr_0p5), npt.NDArray[np.long])
+assert_type(random_st.geometric(D_arr_0p5, size=1), npt.NDArray[np.long])
+assert_type(random_st.geometric(D_arr_like_0p5), npt.NDArray[np.long])
+assert_type(random_st.geometric(D_arr_like_0p5, size=1), npt.NDArray[np.long])
+
+assert_type(random_st.logseries(0.5), int)
+assert_type(random_st.logseries(0.5, size=None), int)
+assert_type(random_st.logseries(0.5, size=1), npt.NDArray[np.long])
+assert_type(random_st.logseries(D_arr_0p5), npt.NDArray[np.long])
+assert_type(random_st.logseries(D_arr_0p5, size=1), npt.NDArray[np.long])
+assert_type(random_st.logseries(D_arr_like_0p5), npt.NDArray[np.long])
+assert_type(random_st.logseries(D_arr_like_0p5, size=1), npt.NDArray[np.long])
+
+assert_type(random_st.rayleigh(0.5), float)
+assert_type(random_st.rayleigh(0.5, size=None), float)
+assert_type(random_st.rayleigh(0.5, size=1), npt.NDArray[np.float64])
+assert_type(random_st.rayleigh(D_arr_0p5), npt.NDArray[np.float64])
+assert_type(random_st.rayleigh(D_arr_0p5, size=1), npt.NDArray[np.float64])
+assert_type(random_st.rayleigh(D_arr_like_0p5), npt.NDArray[np.float64])
+assert_type(random_st.rayleigh(D_arr_like_0p5, size=1), npt.NDArray[np.float64])
+
+assert_type(random_st.standard_gamma(0.5), float)
+assert_type(random_st.standard_gamma(0.5, size=None), float)
+assert_type(random_st.standard_gamma(0.5, size=1), npt.NDArray[np.float64])
+assert_type(random_st.standard_gamma(D_arr_0p5), npt.NDArray[np.float64])
+assert_type(random_st.standard_gamma(D_arr_0p5, size=1), npt.NDArray[np.float64])
+assert_type(random_st.standard_gamma(D_arr_like_0p5), npt.NDArray[np.float64])
+assert_type(random_st.standard_gamma(D_arr_like_0p5, size=1), npt.NDArray[np.float64])
+assert_type(random_st.standard_gamma(D_arr_like_0p5, size=1), npt.NDArray[np.float64])
+
+assert_type(random_st.vonmises(0.5, 0.5), float)
+assert_type(random_st.vonmises(0.5, 0.5, size=None), float)
+assert_type(random_st.vonmises(0.5, 0.5, size=1), npt.NDArray[np.float64])
+assert_type(random_st.vonmises(D_arr_0p5, 0.5), npt.NDArray[np.float64])
+assert_type(random_st.vonmises(0.5, D_arr_0p5), npt.NDArray[np.float64])
+assert_type(random_st.vonmises(D_arr_0p5, 0.5, size=1), npt.NDArray[np.float64])
+assert_type(random_st.vonmises(0.5, D_arr_0p5, size=1), npt.NDArray[np.float64])
+assert_type(random_st.vonmises(D_arr_like_0p5, 0.5), npt.NDArray[np.float64])
+assert_type(random_st.vonmises(0.5, D_arr_like_0p5), npt.NDArray[np.float64])
+assert_type(random_st.vonmises(D_arr_0p5, D_arr_0p5), npt.NDArray[np.float64])
+assert_type(random_st.vonmises(D_arr_like_0p5, D_arr_like_0p5), npt.NDArray[np.float64])
+assert_type(random_st.vonmises(D_arr_0p5, D_arr_0p5, size=1), npt.NDArray[np.float64])
+assert_type(random_st.vonmises(D_arr_like_0p5, D_arr_like_0p5, size=1), npt.NDArray[np.float64])
+
+assert_type(random_st.wald(0.5, 0.5), float)
+assert_type(random_st.wald(0.5, 0.5, size=None), float)
+assert_type(random_st.wald(0.5, 0.5, size=1), npt.NDArray[np.float64])
+assert_type(random_st.wald(D_arr_0p5, 0.5), npt.NDArray[np.float64])
+assert_type(random_st.wald(0.5, D_arr_0p5), npt.NDArray[np.float64])
+assert_type(random_st.wald(D_arr_0p5, 0.5, size=1), npt.NDArray[np.float64])
+assert_type(random_st.wald(0.5, D_arr_0p5, size=1), npt.NDArray[np.float64])
+assert_type(random_st.wald(D_arr_like_0p5, 0.5), npt.NDArray[np.float64])
+assert_type(random_st.wald(0.5, D_arr_like_0p5), npt.NDArray[np.float64])
+assert_type(random_st.wald(D_arr_0p5, D_arr_0p5), npt.NDArray[np.float64])
+assert_type(random_st.wald(D_arr_like_0p5, D_arr_like_0p5), npt.NDArray[np.float64])
+assert_type(random_st.wald(D_arr_0p5, D_arr_0p5, size=1), npt.NDArray[np.float64])
+assert_type(random_st.wald(D_arr_like_0p5, D_arr_like_0p5, size=1), npt.NDArray[np.float64])
+
+assert_type(random_st.uniform(0.5, 0.5), float)
+assert_type(random_st.uniform(0.5, 0.5, size=None), float)
+assert_type(random_st.uniform(0.5, 0.5, size=1), npt.NDArray[np.float64])
+assert_type(random_st.uniform(D_arr_0p5, 0.5), npt.NDArray[np.float64])
+assert_type(random_st.uniform(0.5, D_arr_0p5), npt.NDArray[np.float64])
+assert_type(random_st.uniform(D_arr_0p5, 0.5, size=1), npt.NDArray[np.float64])
+assert_type(random_st.uniform(0.5, D_arr_0p5, size=1), npt.NDArray[np.float64])
+assert_type(random_st.uniform(D_arr_like_0p5, 0.5), npt.NDArray[np.float64])
+assert_type(random_st.uniform(0.5, D_arr_like_0p5), npt.NDArray[np.float64])
+assert_type(random_st.uniform(D_arr_0p5, D_arr_0p5), npt.NDArray[np.float64])
+assert_type(random_st.uniform(D_arr_like_0p5, D_arr_like_0p5), npt.NDArray[np.float64])
+assert_type(random_st.uniform(D_arr_0p5, D_arr_0p5, size=1), npt.NDArray[np.float64])
+assert_type(random_st.uniform(D_arr_like_0p5, D_arr_like_0p5, size=1), npt.NDArray[np.float64])
+
+assert_type(random_st.beta(0.5, 0.5), float)
+assert_type(random_st.beta(0.5, 0.5, size=None), float)
+assert_type(random_st.beta(0.5, 0.5, size=1), npt.NDArray[np.float64])
+assert_type(random_st.beta(D_arr_0p5, 0.5), npt.NDArray[np.float64])
+assert_type(random_st.beta(0.5, D_arr_0p5), npt.NDArray[np.float64])
+assert_type(random_st.beta(D_arr_0p5, 0.5, size=1), npt.NDArray[np.float64])
+assert_type(random_st.beta(0.5, D_arr_0p5, size=1), npt.NDArray[np.float64])
+assert_type(random_st.beta(D_arr_like_0p5, 0.5), npt.NDArray[np.float64])
+assert_type(random_st.beta(0.5, D_arr_like_0p5), npt.NDArray[np.float64])
+assert_type(random_st.beta(D_arr_0p5, D_arr_0p5), npt.NDArray[np.float64])
+assert_type(random_st.beta(D_arr_like_0p5, D_arr_like_0p5), npt.NDArray[np.float64])
+assert_type(random_st.beta(D_arr_0p5, D_arr_0p5, size=1), npt.NDArray[np.float64])
+assert_type(random_st.beta(D_arr_like_0p5, D_arr_like_0p5, size=1), npt.NDArray[np.float64])
+
+assert_type(random_st.f(0.5, 0.5), float)
+assert_type(random_st.f(0.5, 0.5, size=None), float)
+assert_type(random_st.f(0.5, 0.5, size=1), npt.NDArray[np.float64])
+assert_type(random_st.f(D_arr_0p5, 0.5), npt.NDArray[np.float64])
+assert_type(random_st.f(0.5, D_arr_0p5), npt.NDArray[np.float64])
+assert_type(random_st.f(D_arr_0p5, 0.5, size=1), npt.NDArray[np.float64])
+assert_type(random_st.f(0.5, D_arr_0p5, size=1), npt.NDArray[np.float64])
+assert_type(random_st.f(D_arr_like_0p5, 0.5), npt.NDArray[np.float64])
+assert_type(random_st.f(0.5, D_arr_like_0p5), npt.NDArray[np.float64])
+assert_type(random_st.f(D_arr_0p5, D_arr_0p5), npt.NDArray[np.float64])
+assert_type(random_st.f(D_arr_like_0p5, D_arr_like_0p5), npt.NDArray[np.float64])
+assert_type(random_st.f(D_arr_0p5, D_arr_0p5, size=1), npt.NDArray[np.float64])
+assert_type(random_st.f(D_arr_like_0p5, D_arr_like_0p5, size=1), npt.NDArray[np.float64])
+
+assert_type(random_st.gamma(0.5, 0.5), float)
+assert_type(random_st.gamma(0.5, 0.5, size=None), float)
+assert_type(random_st.gamma(0.5, 0.5, size=1), npt.NDArray[np.float64])
+assert_type(random_st.gamma(D_arr_0p5, 0.5), npt.NDArray[np.float64])
+assert_type(random_st.gamma(0.5, D_arr_0p5), npt.NDArray[np.float64])
+assert_type(random_st.gamma(D_arr_0p5, 0.5, size=1), npt.NDArray[np.float64])
+assert_type(random_st.gamma(0.5, D_arr_0p5, size=1), npt.NDArray[np.float64])
+assert_type(random_st.gamma(D_arr_like_0p5, 0.5), npt.NDArray[np.float64])
+assert_type(random_st.gamma(0.5, D_arr_like_0p5), npt.NDArray[np.float64])
+assert_type(random_st.gamma(D_arr_0p5, D_arr_0p5), npt.NDArray[np.float64])
+assert_type(random_st.gamma(D_arr_like_0p5, D_arr_like_0p5), npt.NDArray[np.float64])
+assert_type(random_st.gamma(D_arr_0p5, D_arr_0p5, size=1), npt.NDArray[np.float64])
+assert_type(random_st.gamma(D_arr_like_0p5, D_arr_like_0p5, size=1), npt.NDArray[np.float64])
+
+assert_type(random_st.gumbel(0.5, 0.5), float)
+assert_type(random_st.gumbel(0.5, 0.5, size=None), float)
+assert_type(random_st.gumbel(0.5, 0.5, size=1), npt.NDArray[np.float64])
+assert_type(random_st.gumbel(D_arr_0p5, 0.5), npt.NDArray[np.float64])
+assert_type(random_st.gumbel(0.5, D_arr_0p5), npt.NDArray[np.float64])
+assert_type(random_st.gumbel(D_arr_0p5, 0.5, size=1), npt.NDArray[np.float64])
+assert_type(random_st.gumbel(0.5, D_arr_0p5, size=1), npt.NDArray[np.float64])
+assert_type(random_st.gumbel(D_arr_like_0p5, 0.5), npt.NDArray[np.float64])
+assert_type(random_st.gumbel(0.5, D_arr_like_0p5), npt.NDArray[np.float64])
+assert_type(random_st.gumbel(D_arr_0p5, D_arr_0p5), npt.NDArray[np.float64])
+assert_type(random_st.gumbel(D_arr_like_0p5, D_arr_like_0p5), npt.NDArray[np.float64])
+assert_type(random_st.gumbel(D_arr_0p5, D_arr_0p5, size=1), npt.NDArray[np.float64])
+assert_type(random_st.gumbel(D_arr_like_0p5, D_arr_like_0p5, size=1), npt.NDArray[np.float64])
+
+assert_type(random_st.laplace(0.5, 0.5), float)
+assert_type(random_st.laplace(0.5, 0.5, size=None), float)
+assert_type(random_st.laplace(0.5, 0.5, size=1), npt.NDArray[np.float64])
+assert_type(random_st.laplace(D_arr_0p5, 0.5), npt.NDArray[np.float64])
+assert_type(random_st.laplace(0.5, D_arr_0p5), npt.NDArray[np.float64])
+assert_type(random_st.laplace(D_arr_0p5, 0.5, size=1), npt.NDArray[np.float64])
+assert_type(random_st.laplace(0.5, D_arr_0p5, size=1), npt.NDArray[np.float64])
+assert_type(random_st.laplace(D_arr_like_0p5, 0.5), npt.NDArray[np.float64])
+assert_type(random_st.laplace(0.5, D_arr_like_0p5), npt.NDArray[np.float64])
+assert_type(random_st.laplace(D_arr_0p5, D_arr_0p5), npt.NDArray[np.float64])
+assert_type(random_st.laplace(D_arr_like_0p5, D_arr_like_0p5), npt.NDArray[np.float64])
+assert_type(random_st.laplace(D_arr_0p5, D_arr_0p5, size=1), npt.NDArray[np.float64])
+assert_type(random_st.laplace(D_arr_like_0p5, D_arr_like_0p5, size=1), npt.NDArray[np.float64])
+
+assert_type(random_st.logistic(0.5, 0.5), float)
+assert_type(random_st.logistic(0.5, 0.5, size=None), float)
+assert_type(random_st.logistic(0.5, 0.5, size=1), npt.NDArray[np.float64])
+assert_type(random_st.logistic(D_arr_0p5, 0.5), npt.NDArray[np.float64])
+assert_type(random_st.logistic(0.5, D_arr_0p5), npt.NDArray[np.float64])
+assert_type(random_st.logistic(D_arr_0p5, 0.5, size=1), npt.NDArray[np.float64])
+assert_type(random_st.logistic(0.5, D_arr_0p5, size=1), npt.NDArray[np.float64])
+assert_type(random_st.logistic(D_arr_like_0p5, 0.5), npt.NDArray[np.float64])
+assert_type(random_st.logistic(0.5, D_arr_like_0p5), npt.NDArray[np.float64])
+assert_type(random_st.logistic(D_arr_0p5, D_arr_0p5), npt.NDArray[np.float64])
+assert_type(random_st.logistic(D_arr_like_0p5, D_arr_like_0p5), npt.NDArray[np.float64])
+assert_type(random_st.logistic(D_arr_0p5, D_arr_0p5, size=1), npt.NDArray[np.float64])
+assert_type(random_st.logistic(D_arr_like_0p5, D_arr_like_0p5, size=1), npt.NDArray[np.float64])
+
+assert_type(random_st.lognormal(0.5, 0.5), float)
+assert_type(random_st.lognormal(0.5, 0.5, size=None), float)
+assert_type(random_st.lognormal(0.5, 0.5, size=1), npt.NDArray[np.float64])
+assert_type(random_st.lognormal(D_arr_0p5, 0.5), npt.NDArray[np.float64])
+assert_type(random_st.lognormal(0.5, D_arr_0p5), npt.NDArray[np.float64])
+assert_type(random_st.lognormal(D_arr_0p5, 0.5, size=1), npt.NDArray[np.float64])
+assert_type(random_st.lognormal(0.5, D_arr_0p5, size=1), npt.NDArray[np.float64])
+assert_type(random_st.lognormal(D_arr_like_0p5, 0.5), npt.NDArray[np.float64])
+assert_type(random_st.lognormal(0.5, D_arr_like_0p5), npt.NDArray[np.float64])
+assert_type(random_st.lognormal(D_arr_0p5, D_arr_0p5), npt.NDArray[np.float64])
+assert_type(random_st.lognormal(D_arr_like_0p5, D_arr_like_0p5), npt.NDArray[np.float64])
+assert_type(random_st.lognormal(D_arr_0p5, D_arr_0p5, size=1), npt.NDArray[np.float64])
+assert_type(random_st.lognormal(D_arr_like_0p5, D_arr_like_0p5, size=1), npt.NDArray[np.float64])
+
+assert_type(random_st.noncentral_chisquare(0.5, 0.5), float)
+assert_type(random_st.noncentral_chisquare(0.5, 0.5, size=None), float)
+assert_type(random_st.noncentral_chisquare(0.5, 0.5, size=1), npt.NDArray[np.float64])
+assert_type(random_st.noncentral_chisquare(D_arr_0p5, 0.5), npt.NDArray[np.float64])
+assert_type(random_st.noncentral_chisquare(0.5, D_arr_0p5), npt.NDArray[np.float64])
+assert_type(random_st.noncentral_chisquare(D_arr_0p5, 0.5, size=1), npt.NDArray[np.float64])
+assert_type(random_st.noncentral_chisquare(0.5, D_arr_0p5, size=1), npt.NDArray[np.float64])
+assert_type(random_st.noncentral_chisquare(D_arr_like_0p5, 0.5), npt.NDArray[np.float64])
+assert_type(random_st.noncentral_chisquare(0.5, D_arr_like_0p5), npt.NDArray[np.float64])
+assert_type(random_st.noncentral_chisquare(D_arr_0p5, D_arr_0p5), npt.NDArray[np.float64])
+assert_type(random_st.noncentral_chisquare(D_arr_like_0p5, D_arr_like_0p5), npt.NDArray[np.float64])
+assert_type(random_st.noncentral_chisquare(D_arr_0p5, D_arr_0p5, size=1), npt.NDArray[np.float64])
+assert_type(random_st.noncentral_chisquare(D_arr_like_0p5, D_arr_like_0p5, size=1), npt.NDArray[np.float64])
+
+assert_type(random_st.normal(0.5, 0.5), float)
+assert_type(random_st.normal(0.5, 0.5, size=None), float)
+assert_type(random_st.normal(0.5, 0.5, size=1), npt.NDArray[np.float64])
+assert_type(random_st.normal(D_arr_0p5, 0.5), npt.NDArray[np.float64])
+assert_type(random_st.normal(0.5, D_arr_0p5), npt.NDArray[np.float64])
+assert_type(random_st.normal(D_arr_0p5, 0.5, size=1), npt.NDArray[np.float64])
+assert_type(random_st.normal(0.5, D_arr_0p5, size=1), npt.NDArray[np.float64])
+assert_type(random_st.normal(D_arr_like_0p5, 0.5), npt.NDArray[np.float64])
+assert_type(random_st.normal(0.5, D_arr_like_0p5), npt.NDArray[np.float64])
+assert_type(random_st.normal(D_arr_0p5, D_arr_0p5), npt.NDArray[np.float64])
+assert_type(random_st.normal(D_arr_like_0p5, D_arr_like_0p5), npt.NDArray[np.float64])
+assert_type(random_st.normal(D_arr_0p5, D_arr_0p5, size=1), npt.NDArray[np.float64])
+assert_type(random_st.normal(D_arr_like_0p5, D_arr_like_0p5, size=1), npt.NDArray[np.float64])
+
+assert_type(random_st.triangular(0.1, 0.5, 0.9), float)
+assert_type(random_st.triangular(0.1, 0.5, 0.9, size=None), float)
+assert_type(random_st.triangular(0.1, 0.5, 0.9, size=1), npt.NDArray[np.float64])
+assert_type(random_st.triangular(D_arr_0p1, 0.5, 0.9), npt.NDArray[np.float64])
+assert_type(random_st.triangular(0.1, D_arr_0p5, 0.9), npt.NDArray[np.float64])
+assert_type(random_st.triangular(D_arr_0p1, 0.5, D_arr_like_0p9, size=1), npt.NDArray[np.float64])
+assert_type(random_st.triangular(0.1, D_arr_0p5, 0.9, size=1), npt.NDArray[np.float64])
+assert_type(random_st.triangular(D_arr_like_0p1, 0.5, D_arr_0p9), npt.NDArray[np.float64])
+assert_type(random_st.triangular(0.5, D_arr_like_0p5, 0.9), npt.NDArray[np.float64])
+assert_type(random_st.triangular(D_arr_0p1, D_arr_0p5, 0.9), npt.NDArray[np.float64])
+assert_type(random_st.triangular(D_arr_like_0p1, D_arr_like_0p5, 0.9), npt.NDArray[np.float64])
+assert_type(random_st.triangular(D_arr_0p1, D_arr_0p5, D_arr_0p9, size=1), npt.NDArray[np.float64])
+assert_type(random_st.triangular(D_arr_like_0p1, D_arr_like_0p5, D_arr_like_0p9, size=1), npt.NDArray[np.float64])
+
+assert_type(random_st.noncentral_f(0.1, 0.5, 0.9), float)
+assert_type(random_st.noncentral_f(0.1, 0.5, 0.9, size=None), float)
+assert_type(random_st.noncentral_f(0.1, 0.5, 0.9, size=1), npt.NDArray[np.float64])
+assert_type(random_st.noncentral_f(D_arr_0p1, 0.5, 0.9), npt.NDArray[np.float64])
+assert_type(random_st.noncentral_f(0.1, D_arr_0p5, 0.9), npt.NDArray[np.float64])
+assert_type(random_st.noncentral_f(D_arr_0p1, 0.5, D_arr_like_0p9, size=1), npt.NDArray[np.float64])
+assert_type(random_st.noncentral_f(0.1, D_arr_0p5, 0.9, size=1), npt.NDArray[np.float64])
+assert_type(random_st.noncentral_f(D_arr_like_0p1, 0.5, D_arr_0p9), npt.NDArray[np.float64])
+assert_type(random_st.noncentral_f(0.5, D_arr_like_0p5, 0.9), npt.NDArray[np.float64])
+assert_type(random_st.noncentral_f(D_arr_0p1, D_arr_0p5, 0.9), npt.NDArray[np.float64])
+assert_type(random_st.noncentral_f(D_arr_like_0p1, D_arr_like_0p5, 0.9), npt.NDArray[np.float64])
+assert_type(random_st.noncentral_f(D_arr_0p1, D_arr_0p5, D_arr_0p9, size=1), npt.NDArray[np.float64])
+assert_type(random_st.noncentral_f(D_arr_like_0p1, D_arr_like_0p5, D_arr_like_0p9, size=1), npt.NDArray[np.float64])
+
+assert_type(random_st.binomial(10, 0.5), int)
+assert_type(random_st.binomial(10, 0.5, size=None), int)
+assert_type(random_st.binomial(10, 0.5, size=1), npt.NDArray[np.long])
+assert_type(random_st.binomial(I_arr_10, 0.5), npt.NDArray[np.long])
+assert_type(random_st.binomial(10, D_arr_0p5), npt.NDArray[np.long])
+assert_type(random_st.binomial(I_arr_10, 0.5, size=1), npt.NDArray[np.long])
+assert_type(random_st.binomial(10, D_arr_0p5, size=1), npt.NDArray[np.long])
+assert_type(random_st.binomial(I_arr_like_10, 0.5), npt.NDArray[np.long])
+assert_type(random_st.binomial(10, D_arr_like_0p5), npt.NDArray[np.long])
+assert_type(random_st.binomial(I_arr_10, D_arr_0p5), npt.NDArray[np.long])
+assert_type(random_st.binomial(I_arr_like_10, D_arr_like_0p5), npt.NDArray[np.long])
+assert_type(random_st.binomial(I_arr_10, D_arr_0p5, size=1), npt.NDArray[np.long])
+assert_type(random_st.binomial(I_arr_like_10, D_arr_like_0p5, size=1), npt.NDArray[np.long])
+
+assert_type(random_st.negative_binomial(10, 0.5), int)
+assert_type(random_st.negative_binomial(10, 0.5, size=None), int)
+assert_type(random_st.negative_binomial(10, 0.5, size=1), npt.NDArray[np.long])
+assert_type(random_st.negative_binomial(I_arr_10, 0.5), npt.NDArray[np.long])
+assert_type(random_st.negative_binomial(10, D_arr_0p5), npt.NDArray[np.long])
+assert_type(random_st.negative_binomial(I_arr_10, 0.5, size=1), npt.NDArray[np.long])
+assert_type(random_st.negative_binomial(10, D_arr_0p5, size=1), npt.NDArray[np.long])
+assert_type(random_st.negative_binomial(I_arr_like_10, 0.5), npt.NDArray[np.long])
+assert_type(random_st.negative_binomial(10, D_arr_like_0p5), npt.NDArray[np.long])
+assert_type(random_st.negative_binomial(I_arr_10, D_arr_0p5), npt.NDArray[np.long])
+assert_type(random_st.negative_binomial(I_arr_like_10, D_arr_like_0p5), npt.NDArray[np.long])
+assert_type(random_st.negative_binomial(I_arr_10, D_arr_0p5, size=1), npt.NDArray[np.long])
+assert_type(random_st.negative_binomial(I_arr_like_10, D_arr_like_0p5, size=1), npt.NDArray[np.long])
+
+assert_type(random_st.hypergeometric(20, 20, 10), int)
+assert_type(random_st.hypergeometric(20, 20, 10, size=None), int)
+assert_type(random_st.hypergeometric(20, 20, 10, size=1), npt.NDArray[np.long])
+assert_type(random_st.hypergeometric(I_arr_20, 20, 10), npt.NDArray[np.long])
+assert_type(random_st.hypergeometric(20, I_arr_20, 10), npt.NDArray[np.long])
+assert_type(random_st.hypergeometric(I_arr_20, 20, I_arr_like_10, size=1), npt.NDArray[np.long])
+assert_type(random_st.hypergeometric(20, I_arr_20, 10, size=1), npt.NDArray[np.long])
+assert_type(random_st.hypergeometric(I_arr_like_20, 20, I_arr_10), npt.NDArray[np.long])
+assert_type(random_st.hypergeometric(20, I_arr_like_20, 10), npt.NDArray[np.long])
+assert_type(random_st.hypergeometric(I_arr_20, I_arr_20, 10), npt.NDArray[np.long])
+assert_type(random_st.hypergeometric(I_arr_like_20, I_arr_like_20, 10), npt.NDArray[np.long])
+assert_type(random_st.hypergeometric(I_arr_20, I_arr_20, I_arr_10, size=1), npt.NDArray[np.long])
+assert_type(random_st.hypergeometric(I_arr_like_20, I_arr_like_20, I_arr_like_10, size=1), npt.NDArray[np.long])
+
+assert_type(random_st.randint(0, 100), int)
+assert_type(random_st.randint(100), int)
+assert_type(random_st.randint([100]), npt.NDArray[np.long])
+assert_type(random_st.randint(0, [100]), npt.NDArray[np.long])
+
+assert_type(random_st.randint(2, dtype=bool), bool)
+assert_type(random_st.randint(0, 2, dtype=bool), bool)
+assert_type(random_st.randint(I_bool_high_open, dtype=bool), npt.NDArray[np.bool])
+assert_type(random_st.randint(I_bool_low, I_bool_high_open, dtype=bool), npt.NDArray[np.bool])
+assert_type(random_st.randint(0, I_bool_high_open, dtype=bool), npt.NDArray[np.bool])
+
+assert_type(random_st.randint(2, dtype=np.bool), np.bool)
+assert_type(random_st.randint(0, 2, dtype=np.bool), np.bool)
+assert_type(random_st.randint(I_bool_high_open, dtype=np.bool), npt.NDArray[np.bool])
+assert_type(random_st.randint(I_bool_low, I_bool_high_open, dtype=np.bool), npt.NDArray[np.bool])
+assert_type(random_st.randint(0, I_bool_high_open, dtype=np.bool), npt.NDArray[np.bool])
+
+assert_type(random_st.randint(256, dtype="u1"), np.uint8)
+assert_type(random_st.randint(0, 256, dtype="u1"), np.uint8)
+assert_type(random_st.randint(I_u1_high_open, dtype="u1"), npt.NDArray[np.uint8])
+assert_type(random_st.randint(I_u1_low, I_u1_high_open, dtype="u1"), npt.NDArray[np.uint8])
+assert_type(random_st.randint(0, I_u1_high_open, dtype="u1"), npt.NDArray[np.uint8])
+
+assert_type(random_st.randint(256, dtype="uint8"), np.uint8)
+assert_type(random_st.randint(0, 256, dtype="uint8"), np.uint8)
+assert_type(random_st.randint(I_u1_high_open, dtype="uint8"), npt.NDArray[np.uint8])
+assert_type(random_st.randint(I_u1_low, I_u1_high_open, dtype="uint8"), npt.NDArray[np.uint8])
+assert_type(random_st.randint(0, I_u1_high_open, dtype="uint8"), npt.NDArray[np.uint8])
+
+assert_type(random_st.randint(256, dtype=np.uint8), np.uint8)
+assert_type(random_st.randint(0, 256, dtype=np.uint8), np.uint8)
+assert_type(random_st.randint(I_u1_high_open, dtype=np.uint8), npt.NDArray[np.uint8])
+assert_type(random_st.randint(I_u1_low, I_u1_high_open, dtype=np.uint8), npt.NDArray[np.uint8])
+assert_type(random_st.randint(0, I_u1_high_open, dtype=np.uint8), npt.NDArray[np.uint8])
+
+assert_type(random_st.randint(65536, dtype="u2"), np.uint16)
+assert_type(random_st.randint(0, 65536, dtype="u2"), np.uint16)
+assert_type(random_st.randint(I_u2_high_open, dtype="u2"), npt.NDArray[np.uint16])
+assert_type(random_st.randint(I_u2_low, I_u2_high_open, dtype="u2"), npt.NDArray[np.uint16])
+assert_type(random_st.randint(0, I_u2_high_open, dtype="u2"), npt.NDArray[np.uint16])
+
+assert_type(random_st.randint(65536, dtype="uint16"), np.uint16)
+assert_type(random_st.randint(0, 65536, dtype="uint16"), np.uint16)
+assert_type(random_st.randint(I_u2_high_open, dtype="uint16"), npt.NDArray[np.uint16])
+assert_type(random_st.randint(I_u2_low, I_u2_high_open, dtype="uint16"), npt.NDArray[np.uint16])
+assert_type(random_st.randint(0, I_u2_high_open, dtype="uint16"), npt.NDArray[np.uint16])
+
+assert_type(random_st.randint(65536, dtype=np.uint16), np.uint16)
+assert_type(random_st.randint(0, 65536, dtype=np.uint16), np.uint16)
+assert_type(random_st.randint(I_u2_high_open, dtype=np.uint16), npt.NDArray[np.uint16])
+assert_type(random_st.randint(I_u2_low, I_u2_high_open, dtype=np.uint16), npt.NDArray[np.uint16])
+assert_type(random_st.randint(0, I_u2_high_open, dtype=np.uint16), npt.NDArray[np.uint16])
+
+assert_type(random_st.randint(4294967296, dtype="u4"), np.uint32)
+assert_type(random_st.randint(0, 4294967296, dtype="u4"), np.uint32)
+assert_type(random_st.randint(I_u4_high_open, dtype="u4"), npt.NDArray[np.uint32])
+assert_type(random_st.randint(I_u4_low, I_u4_high_open, dtype="u4"), npt.NDArray[np.uint32])
+assert_type(random_st.randint(0, I_u4_high_open, dtype="u4"), npt.NDArray[np.uint32])
+
+assert_type(random_st.randint(4294967296, dtype="uint32"), np.uint32)
+assert_type(random_st.randint(0, 4294967296, dtype="uint32"), np.uint32)
+assert_type(random_st.randint(I_u4_high_open, dtype="uint32"), npt.NDArray[np.uint32])
+assert_type(random_st.randint(I_u4_low, I_u4_high_open, dtype="uint32"), npt.NDArray[np.uint32])
+assert_type(random_st.randint(0, I_u4_high_open, dtype="uint32"), npt.NDArray[np.uint32])
+
+assert_type(random_st.randint(4294967296, dtype=np.uint32), np.uint32)
+assert_type(random_st.randint(0, 4294967296, dtype=np.uint32), np.uint32)
+assert_type(random_st.randint(I_u4_high_open, dtype=np.uint32), npt.NDArray[np.uint32])
+assert_type(random_st.randint(I_u4_low, I_u4_high_open, dtype=np.uint32), npt.NDArray[np.uint32])
+assert_type(random_st.randint(0, I_u4_high_open, dtype=np.uint32), npt.NDArray[np.uint32])
+
+assert_type(random_st.randint(4294967296, dtype=np.uint), np.uint)
+assert_type(random_st.randint(0, 4294967296, dtype=np.uint), np.uint)
+assert_type(random_st.randint(I_u4_high_open, dtype=np.uint), npt.NDArray[np.uint])
+assert_type(random_st.randint(I_u4_low, I_u4_high_open, dtype=np.uint), npt.NDArray[np.uint])
+assert_type(random_st.randint(0, I_u4_high_open, dtype=np.uint), npt.NDArray[np.uint])
+
+assert_type(random_st.randint(18446744073709551616, dtype="u8"), np.uint64)
+assert_type(random_st.randint(0, 18446744073709551616, dtype="u8"), np.uint64)
+assert_type(random_st.randint(I_u8_high_open, dtype="u8"), npt.NDArray[np.uint64])
+assert_type(random_st.randint(I_u8_low, I_u8_high_open, dtype="u8"), npt.NDArray[np.uint64])
+assert_type(random_st.randint(0, I_u8_high_open, dtype="u8"), npt.NDArray[np.uint64])
+
+assert_type(random_st.randint(18446744073709551616, dtype="uint64"), np.uint64)
+assert_type(random_st.randint(0, 18446744073709551616, dtype="uint64"), np.uint64)
+assert_type(random_st.randint(I_u8_high_open, dtype="uint64"), npt.NDArray[np.uint64])
+assert_type(random_st.randint(I_u8_low, I_u8_high_open, dtype="uint64"), npt.NDArray[np.uint64])
+assert_type(random_st.randint(0, I_u8_high_open, dtype="uint64"), npt.NDArray[np.uint64])
+
+assert_type(random_st.randint(18446744073709551616, dtype=np.uint64), np.uint64)
+assert_type(random_st.randint(0, 18446744073709551616, dtype=np.uint64), np.uint64)
+assert_type(random_st.randint(I_u8_high_open, dtype=np.uint64), npt.NDArray[np.uint64])
+assert_type(random_st.randint(I_u8_low, I_u8_high_open, dtype=np.uint64), npt.NDArray[np.uint64])
+assert_type(random_st.randint(0, I_u8_high_open, dtype=np.uint64), npt.NDArray[np.uint64])
+
+assert_type(random_st.randint(128, dtype="i1"), np.int8)
+assert_type(random_st.randint(-128, 128, dtype="i1"), np.int8)
+assert_type(random_st.randint(I_i1_high_open, dtype="i1"), npt.NDArray[np.int8])
+assert_type(random_st.randint(I_i1_low, I_i1_high_open, dtype="i1"), npt.NDArray[np.int8])
+assert_type(random_st.randint(-128, I_i1_high_open, dtype="i1"), npt.NDArray[np.int8])
+
+assert_type(random_st.randint(128, dtype="int8"), np.int8)
+assert_type(random_st.randint(-128, 128, dtype="int8"), np.int8)
+assert_type(random_st.randint(I_i1_high_open, dtype="int8"), npt.NDArray[np.int8])
+assert_type(random_st.randint(I_i1_low, I_i1_high_open, dtype="int8"), npt.NDArray[np.int8])
+assert_type(random_st.randint(-128, I_i1_high_open, dtype="int8"), npt.NDArray[np.int8])
+
+assert_type(random_st.randint(128, dtype=np.int8), np.int8)
+assert_type(random_st.randint(-128, 128, dtype=np.int8), np.int8)
+assert_type(random_st.randint(I_i1_high_open, dtype=np.int8), npt.NDArray[np.int8])
+assert_type(random_st.randint(I_i1_low, I_i1_high_open, dtype=np.int8), npt.NDArray[np.int8])
+assert_type(random_st.randint(-128, I_i1_high_open, dtype=np.int8), npt.NDArray[np.int8])
+
+assert_type(random_st.randint(32768, dtype="i2"), np.int16)
+assert_type(random_st.randint(-32768, 32768, dtype="i2"), np.int16)
+assert_type(random_st.randint(I_i2_high_open, dtype="i2"), npt.NDArray[np.int16])
+assert_type(random_st.randint(I_i2_low, I_i2_high_open, dtype="i2"), npt.NDArray[np.int16])
+assert_type(random_st.randint(-32768, I_i2_high_open, dtype="i2"), npt.NDArray[np.int16])
+
+assert_type(random_st.randint(32768, dtype="int16"), np.int16)
+assert_type(random_st.randint(-32768, 32768, dtype="int16"), np.int16)
+assert_type(random_st.randint(I_i2_high_open, dtype="int16"), npt.NDArray[np.int16])
+assert_type(random_st.randint(I_i2_low, I_i2_high_open, dtype="int16"), npt.NDArray[np.int16])
+assert_type(random_st.randint(-32768, I_i2_high_open, dtype="int16"), npt.NDArray[np.int16])
+
+assert_type(random_st.randint(32768, dtype=np.int16), np.int16)
+assert_type(random_st.randint(-32768, 32768, dtype=np.int16), np.int16)
+assert_type(random_st.randint(I_i2_high_open, dtype=np.int16), npt.NDArray[np.int16])
+assert_type(random_st.randint(I_i2_low, I_i2_high_open, dtype=np.int16), npt.NDArray[np.int16])
+assert_type(random_st.randint(-32768, I_i2_high_open, dtype=np.int16), npt.NDArray[np.int16])
+
+assert_type(random_st.randint(2147483648, dtype="i4"), np.int32)
+assert_type(random_st.randint(-2147483648, 2147483648, dtype="i4"), np.int32)
+assert_type(random_st.randint(I_i4_high_open, dtype="i4"), npt.NDArray[np.int32])
+assert_type(random_st.randint(I_i4_low, I_i4_high_open, dtype="i4"), npt.NDArray[np.int32])
+assert_type(random_st.randint(-2147483648, I_i4_high_open, dtype="i4"), npt.NDArray[np.int32])
+
+assert_type(random_st.randint(2147483648, dtype="int32"), np.int32)
+assert_type(random_st.randint(-2147483648, 2147483648, dtype="int32"), np.int32)
+assert_type(random_st.randint(I_i4_high_open, dtype="int32"), npt.NDArray[np.int32])
+assert_type(random_st.randint(I_i4_low, I_i4_high_open, dtype="int32"), npt.NDArray[np.int32])
+assert_type(random_st.randint(-2147483648, I_i4_high_open, dtype="int32"), npt.NDArray[np.int32])
+
+assert_type(random_st.randint(2147483648, dtype=np.int32), np.int32)
+assert_type(random_st.randint(-2147483648, 2147483648, dtype=np.int32), np.int32)
+assert_type(random_st.randint(I_i4_high_open, dtype=np.int32), npt.NDArray[np.int32])
+assert_type(random_st.randint(I_i4_low, I_i4_high_open, dtype=np.int32), npt.NDArray[np.int32])
+assert_type(random_st.randint(-2147483648, I_i4_high_open, dtype=np.int32), npt.NDArray[np.int32])
+
+assert_type(random_st.randint(2147483648, dtype=np.int_), np.int_)
+assert_type(random_st.randint(-2147483648, 2147483648, dtype=np.int_), np.int_)
+assert_type(random_st.randint(I_i4_high_open, dtype=np.int_), npt.NDArray[np.int_])
+assert_type(random_st.randint(I_i4_low, I_i4_high_open, dtype=np.int_), npt.NDArray[np.int_])
+assert_type(random_st.randint(-2147483648, I_i4_high_open, dtype=np.int_), npt.NDArray[np.int_])
+
+assert_type(random_st.randint(9223372036854775808, dtype="i8"), np.int64)
+assert_type(random_st.randint(-9223372036854775808, 9223372036854775808, dtype="i8"), np.int64)
+assert_type(random_st.randint(I_i8_high_open, dtype="i8"), npt.NDArray[np.int64])
+assert_type(random_st.randint(I_i8_low, I_i8_high_open, dtype="i8"), npt.NDArray[np.int64])
+assert_type(random_st.randint(-9223372036854775808, I_i8_high_open, dtype="i8"), npt.NDArray[np.int64])
+
+assert_type(random_st.randint(9223372036854775808, dtype="int64"), np.int64)
+assert_type(random_st.randint(-9223372036854775808, 9223372036854775808, dtype="int64"), np.int64)
+assert_type(random_st.randint(I_i8_high_open, dtype="int64"), npt.NDArray[np.int64])
+assert_type(random_st.randint(I_i8_low, I_i8_high_open, dtype="int64"), npt.NDArray[np.int64])
+assert_type(random_st.randint(-9223372036854775808, I_i8_high_open, dtype="int64"), npt.NDArray[np.int64])
+
+assert_type(random_st.randint(9223372036854775808, dtype=np.int64), np.int64)
+assert_type(random_st.randint(-9223372036854775808, 9223372036854775808, dtype=np.int64), np.int64)
+assert_type(random_st.randint(I_i8_high_open, dtype=np.int64), npt.NDArray[np.int64])
+assert_type(random_st.randint(I_i8_low, I_i8_high_open, dtype=np.int64), npt.NDArray[np.int64])
+assert_type(random_st.randint(-9223372036854775808, I_i8_high_open, dtype=np.int64), npt.NDArray[np.int64])
+
+assert_type(random_st._bit_generator, np.random.BitGenerator)
+
+assert_type(random_st.bytes(2), bytes)
+
+assert_type(random_st.choice(5), int)
+assert_type(random_st.choice(5, 3), npt.NDArray[np.long])
+assert_type(random_st.choice(5, 3, replace=True), npt.NDArray[np.long])
+assert_type(random_st.choice(5, 3, p=[1 / 5] * 5), npt.NDArray[np.long])
+assert_type(random_st.choice(5, 3, p=[1 / 5] * 5, replace=False), npt.NDArray[np.long])
+
+assert_type(random_st.choice(["pooh", "rabbit", "piglet", "Christopher"]), Any)
+assert_type(random_st.choice(["pooh", "rabbit", "piglet", "Christopher"], 3), npt.NDArray[Any])
+assert_type(random_st.choice(["pooh", "rabbit", "piglet", "Christopher"], 3, p=[1 / 4] * 4), npt.NDArray[Any])
+assert_type(random_st.choice(["pooh", "rabbit", "piglet", "Christopher"], 3, replace=True), npt.NDArray[Any])
+assert_type(random_st.choice(["pooh", "rabbit", "piglet", "Christopher"], 3, replace=False, p=np.array([1 / 8, 1 / 8, 1 / 2, 1 / 4])), npt.NDArray[Any])
+
+assert_type(random_st.dirichlet([0.5, 0.5]), npt.NDArray[np.float64])
+assert_type(random_st.dirichlet(np.array([0.5, 0.5])), npt.NDArray[np.float64])
+assert_type(random_st.dirichlet(np.array([0.5, 0.5]), size=3), npt.NDArray[np.float64])
+
+assert_type(random_st.multinomial(20, [1 / 6.0] * 6), npt.NDArray[np.long])
+assert_type(random_st.multinomial(20, np.array([0.5, 0.5])), npt.NDArray[np.long])
+assert_type(random_st.multinomial(20, [1 / 6.0] * 6, size=2), npt.NDArray[np.long])
+
+assert_type(random_st.multivariate_normal([0.0], [[1.0]]), npt.NDArray[np.float64])
+assert_type(random_st.multivariate_normal([0.0], np.array([[1.0]])), npt.NDArray[np.float64])
+assert_type(random_st.multivariate_normal(np.array([0.0]), [[1.0]]), npt.NDArray[np.float64])
+assert_type(random_st.multivariate_normal([0.0], np.array([[1.0]])), npt.NDArray[np.float64])
+
+assert_type(random_st.permutation(10), npt.NDArray[np.long])
+assert_type(random_st.permutation([1, 2, 3, 4]), npt.NDArray[Any])
+assert_type(random_st.permutation(np.array([1, 2, 3, 4])), npt.NDArray[Any])
+assert_type(random_st.permutation(D_2D), npt.NDArray[Any])
+
+assert_type(random_st.shuffle(np.arange(10)), None)
+assert_type(random_st.shuffle([1, 2, 3, 4, 5]), None)
+assert_type(random_st.shuffle(D_2D), None)
+
+assert_type(np.random.RandomState(pcg64), np.random.RandomState)
+assert_type(np.random.RandomState(0), np.random.RandomState)
+assert_type(np.random.RandomState([0, 1, 2]), np.random.RandomState)
+assert_type(random_st.__str__(), str)
+assert_type(random_st.__repr__(), str)
+random_st_state = random_st.__getstate__()
+assert_type(random_st_state, dict[str, Any])
+assert_type(random_st.__setstate__(random_st_state), None)
+assert_type(random_st.seed(), None)
+assert_type(random_st.seed(1), None)
+assert_type(random_st.seed([0, 1]), None)
+random_st_get_state = random_st.get_state()
+assert_type(random_st_state, dict[str, Any])
+random_st_get_state_legacy = random_st.get_state(legacy=True)
+assert_type(random_st_get_state_legacy, dict[str, Any] | tuple[str, npt.NDArray[np.uint32], int, int, float])
+assert_type(random_st.set_state(random_st_get_state), None)
+
+assert_type(random_st.rand(), float)
+assert_type(random_st.rand(1), npt.NDArray[np.float64])
+assert_type(random_st.rand(1, 2), npt.NDArray[np.float64])
+assert_type(random_st.randn(), float)
+assert_type(random_st.randn(1), npt.NDArray[np.float64])
+assert_type(random_st.randn(1, 2), npt.NDArray[np.float64])
+assert_type(random_st.random_sample(), float)
+assert_type(random_st.random_sample(1), npt.NDArray[np.float64])
+assert_type(random_st.random_sample(size=(1, 2)), npt.NDArray[np.float64])
+
+assert_type(random_st.tomaxint(), int)
+assert_type(random_st.tomaxint(1), npt.NDArray[np.int64])
+assert_type(random_st.tomaxint((1,)), npt.NDArray[np.int64])
+
+assert_type(np.random.set_bit_generator(pcg64), None)
+assert_type(np.random.get_bit_generator(), np.random.BitGenerator)
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/rec.pyi b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/rec.pyi
new file mode 100644
index 00000000..f2ae0891
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/rec.pyi
@@ -0,0 +1,172 @@
+import io
+import sys
+from typing import Any
+
+import numpy as np
+import numpy.typing as npt
+
+if sys.version_info >= (3, 11):
+    from typing import assert_type
+else:
+    from typing_extensions import assert_type
+
+AR_i8: npt.NDArray[np.int64]
+REC_AR_V: np.recarray[Any, np.dtype[np.record]]
+AR_LIST: list[npt.NDArray[np.int64]]
+
+record: np.record
+file_obj: io.BufferedIOBase
+
+assert_type(np.rec.format_parser(
+    formats=[np.float64, np.int64, np.bool],
+    names=["f8", "i8", "?"],
+    titles=None,
+    aligned=True,
+), np.rec.format_parser)
+assert_type(np.rec.format_parser.dtype, np.dtype[np.void])
+
+assert_type(record.field_a, Any)
+assert_type(record.field_b, Any)
+assert_type(record["field_a"], Any)
+assert_type(record["field_b"], Any)
+assert_type(record.pprint(), str)
+record.field_c = 5
+
+assert_type(REC_AR_V.field(0), Any)
+assert_type(REC_AR_V.field("field_a"), Any)
+assert_type(REC_AR_V.field(0, AR_i8), None)
+assert_type(REC_AR_V.field("field_a", AR_i8), None)
+assert_type(REC_AR_V["field_a"], npt.NDArray[Any])
+assert_type(REC_AR_V.field_a, Any)
+assert_type(REC_AR_V.__array_finalize__(object()), None)
+
+assert_type(
+    np.recarray(
+        shape=(10, 5),
+        formats=[np.float64, np.int64, np.bool],
+        order="K",
+        byteorder="|",
+    ),
+    np.recarray[Any, np.dtype[np.record]],
+)
+
+assert_type(
+    np.recarray(
+        shape=(10, 5),
+        dtype=[("f8", np.float64), ("i8", np.int64)],
+        strides=(5, 5),
+    ),
+    np.recarray[Any, np.dtype[Any]],
+)
+
+assert_type(np.rec.fromarrays(AR_LIST), np.recarray[Any, np.dtype[Any]])
+assert_type(
+    np.rec.fromarrays(AR_LIST, dtype=np.int64),
+    np.recarray[Any, np.dtype[Any]],
+)
+assert_type(
+    np.rec.fromarrays(
+        AR_LIST,
+        formats=[np.int64, np.float64],
+        names=["i8", "f8"]
+    ),
+    np.recarray[Any, np.dtype[np.record]],
+)
+
+assert_type(
+    np.rec.fromrecords((1, 1.5)), 
+    np.recarray[Any, np.dtype[np.record]]
+)
+
+assert_type(
+    np.rec.fromrecords(
+        [(1, 1.5)],
+        dtype=[("i8", np.int64), ("f8", np.float64)],
+    ),
+    np.recarray[Any, np.dtype[np.record]],
+)
+
+assert_type(
+    np.rec.fromrecords(
+        REC_AR_V,
+        formats=[np.int64, np.float64],
+        names=["i8", "f8"]
+    ),
+    np.recarray[Any, np.dtype[np.record]],
+)
+
+assert_type(
+    np.rec.fromstring(
+        b"(1, 1.5)",
+        dtype=[("i8", np.int64), ("f8", np.float64)],
+    ),
+    np.recarray[Any, np.dtype[np.record]],
+)
+
+assert_type(
+    np.rec.fromstring(
+        REC_AR_V,
+        formats=[np.int64, np.float64],
+        names=["i8", "f8"]
+    ),
+    np.recarray[Any, np.dtype[np.record]],
+)
+
+assert_type(np.rec.fromfile(
+    "test_file.txt",
+    dtype=[("i8", np.int64), ("f8", np.float64)],
+), np.recarray[Any, np.dtype[Any]])
+
+assert_type(
+    np.rec.fromfile(
+        file_obj,
+        formats=[np.int64, np.float64],
+        names=["i8", "f8"]
+    ),
+    np.recarray[Any, np.dtype[np.record]],
+)
+
+assert_type(np.rec.array(AR_i8), np.recarray[Any, np.dtype[np.int64]])
+
+assert_type(
+    np.rec.array([(1, 1.5)], dtype=[("i8", np.int64), ("f8", np.float64)]),
+    np.recarray[Any, np.dtype[Any]],
+)
+
+assert_type(
+    np.rec.array(
+        [(1, 1.5)],
+        formats=[np.int64, np.float64],
+        names=["i8", "f8"]
+    ),
+    np.recarray[Any, np.dtype[np.record]],
+)
+
+assert_type(
+    np.rec.array(
+        None,
+        dtype=np.float64,
+        shape=(10, 3),
+    ),
+    np.recarray[Any, np.dtype[Any]],
+)
+
+assert_type(
+    np.rec.array(
+        None,
+        formats=[np.int64, np.float64],
+        names=["i8", "f8"],
+        shape=(10, 3),
+    ),
+    np.recarray[Any, np.dtype[np.record]],
+)
+
+assert_type(
+    np.rec.array(file_obj, dtype=np.float64),
+    np.recarray[Any, np.dtype[Any]],
+)
+
+assert_type(
+    np.rec.array(file_obj, formats=[np.int64, np.float64], names=["i8", "f8"]),
+    np.recarray[Any, np.dtype[np.record]],
+)
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/scalars.pyi b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/scalars.pyi
new file mode 100644
index 00000000..95775e9a
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/scalars.pyi
@@ -0,0 +1,158 @@
+import sys
+from typing import Any, Literal
+
+import numpy as np
+import numpy.typing as npt
+
+if sys.version_info >= (3, 11):
+    from typing import assert_type
+else:
+    from typing_extensions import assert_type
+
+b: np.bool
+u8: np.uint64
+i8: np.int64
+f8: np.float64
+c8: np.complex64
+c16: np.complex128
+m: np.timedelta64
+U: np.str_
+S: np.bytes_
+V: np.void
+
+assert_type(c8.real, np.float32)
+assert_type(c8.imag, np.float32)
+
+assert_type(c8.real.real, np.float32)
+assert_type(c8.real.imag, np.float32)
+
+assert_type(c8.itemsize, int)
+assert_type(c8.shape, tuple[()])
+assert_type(c8.strides, tuple[()])
+
+assert_type(c8.ndim, Literal[0])
+assert_type(c8.size, Literal[1])
+
+assert_type(c8.squeeze(), np.complex64)
+assert_type(c8.byteswap(), np.complex64)
+assert_type(c8.transpose(), np.complex64)
+
+assert_type(c8.dtype, np.dtype[np.complex64])
+
+assert_type(c8.real, np.float32)
+assert_type(c16.imag, np.float64)
+
+assert_type(np.str_('foo'), np.str_)
+
+assert_type(V[0], Any)
+assert_type(V["field1"], Any)
+assert_type(V[["field1", "field2"]], np.void)
+V[0] = 5
+
+# Aliases
+assert_type(np.bool_(), np.bool)
+assert_type(np.byte(), np.byte)
+assert_type(np.short(), np.short)
+assert_type(np.intc(), np.intc)
+assert_type(np.intp(), np.intp)
+assert_type(np.int_(), np.int_)
+assert_type(np.long(), np.long)
+assert_type(np.longlong(), np.longlong)
+
+assert_type(np.ubyte(), np.ubyte)
+assert_type(np.ushort(), np.ushort)
+assert_type(np.uintc(), np.uintc)
+assert_type(np.uintp(), np.uintp)
+assert_type(np.uint(), np.uint)
+assert_type(np.ulong(), np.ulong)
+assert_type(np.ulonglong(), np.ulonglong)
+
+assert_type(np.half(), np.half)
+assert_type(np.single(), np.single)
+assert_type(np.double(), np.double)
+assert_type(np.longdouble(), np.longdouble)
+
+assert_type(np.csingle(), np.csingle)
+assert_type(np.cdouble(), np.cdouble)
+assert_type(np.clongdouble(), np.clongdouble)
+
+assert_type(b.item(), bool)
+assert_type(i8.item(), int)
+assert_type(u8.item(), int)
+assert_type(f8.item(), float)
+assert_type(c16.item(), complex)
+assert_type(U.item(), str)
+assert_type(S.item(), bytes)
+
+assert_type(b.tolist(), bool)
+assert_type(i8.tolist(), int)
+assert_type(u8.tolist(), int)
+assert_type(f8.tolist(), float)
+assert_type(c16.tolist(), complex)
+assert_type(U.tolist(), str)
+assert_type(S.tolist(), bytes)
+
+assert_type(b.ravel(), npt.NDArray[np.bool])
+assert_type(i8.ravel(), npt.NDArray[np.int64])
+assert_type(u8.ravel(), npt.NDArray[np.uint64])
+assert_type(f8.ravel(), npt.NDArray[np.float64])
+assert_type(c16.ravel(), npt.NDArray[np.complex128])
+assert_type(U.ravel(), npt.NDArray[np.str_])
+assert_type(S.ravel(), npt.NDArray[np.bytes_])
+
+assert_type(b.flatten(), npt.NDArray[np.bool])
+assert_type(i8.flatten(), npt.NDArray[np.int64])
+assert_type(u8.flatten(), npt.NDArray[np.uint64])
+assert_type(f8.flatten(), npt.NDArray[np.float64])
+assert_type(c16.flatten(), npt.NDArray[np.complex128])
+assert_type(U.flatten(), npt.NDArray[np.str_])
+assert_type(S.flatten(), npt.NDArray[np.bytes_])
+
+assert_type(b.reshape(1), npt.NDArray[np.bool])
+assert_type(i8.reshape(1), npt.NDArray[np.int64])
+assert_type(u8.reshape(1), npt.NDArray[np.uint64])
+assert_type(f8.reshape(1), npt.NDArray[np.float64])
+assert_type(c16.reshape(1), npt.NDArray[np.complex128])
+assert_type(U.reshape(1), npt.NDArray[np.str_])
+assert_type(S.reshape(1), npt.NDArray[np.bytes_])
+
+assert_type(i8.astype(float), Any)
+assert_type(i8.astype(np.float64), np.float64)
+
+assert_type(i8.view(), np.int64)
+assert_type(i8.view(np.float64), np.float64)
+assert_type(i8.view(float), Any)
+assert_type(i8.view(np.float64, np.ndarray), np.float64)
+
+assert_type(i8.getfield(float), Any)
+assert_type(i8.getfield(np.float64), np.float64)
+assert_type(i8.getfield(np.float64, 8), np.float64)
+
+assert_type(f8.as_integer_ratio(), tuple[int, int])
+assert_type(f8.is_integer(), bool)
+assert_type(f8.__trunc__(), int)
+assert_type(f8.__getformat__("float"), str)
+assert_type(f8.hex(), str)
+assert_type(np.float64.fromhex("0x0.0p+0"), np.float64)
+
+assert_type(f8.__getnewargs__(), tuple[float])
+assert_type(c16.__getnewargs__(), tuple[float, float])
+
+assert_type(i8.numerator, np.int64)
+assert_type(i8.denominator, Literal[1])
+assert_type(u8.numerator, np.uint64)
+assert_type(u8.denominator, Literal[1])
+assert_type(m.numerator, np.timedelta64)
+assert_type(m.denominator, Literal[1])
+
+assert_type(round(i8), int)
+assert_type(round(i8, 3), np.int64)
+assert_type(round(u8), int)
+assert_type(round(u8, 3), np.uint64)
+assert_type(round(f8), int)
+assert_type(round(f8, 3), np.float64)
+
+assert_type(f8.__ceil__(), int)
+assert_type(f8.__floor__(), int)
+
+assert_type(i8.is_integer(), Literal[True])
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/shape.pyi b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/shape.pyi
new file mode 100644
index 00000000..8f8d819c
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/shape.pyi
@@ -0,0 +1,15 @@
+from typing import Any, NamedTuple
+
+import numpy as np
+from typing_extensions import assert_type
+
+
+# Subtype of tuple[int, int]
+class XYGrid(NamedTuple):
+    x_axis: int
+    y_axis: int
+
+arr: np.ndarray[XYGrid, Any]
+
+# Test shape property matches shape typevar
+assert_type(arr.shape, XYGrid)
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/shape_base.pyi b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/shape_base.pyi
new file mode 100644
index 00000000..526f3abf
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/shape_base.pyi
@@ -0,0 +1,58 @@
+import sys
+from typing import Any
+
+import numpy as np
+import numpy.typing as npt
+
+if sys.version_info >= (3, 11):
+    from typing import assert_type
+else:
+    from typing_extensions import assert_type
+
+i8: np.int64
+f8: np.float64
+
+AR_b: npt.NDArray[np.bool]
+AR_i8: npt.NDArray[np.int64]
+AR_f8: npt.NDArray[np.float64]
+
+AR_LIKE_f8: list[float]
+
+assert_type(np.take_along_axis(AR_f8, AR_i8, axis=1), npt.NDArray[np.float64])
+assert_type(np.take_along_axis(f8, AR_i8, axis=None), npt.NDArray[np.float64])
+
+assert_type(np.put_along_axis(AR_f8, AR_i8, "1.0", axis=1), None)
+
+assert_type(np.expand_dims(AR_i8, 2), npt.NDArray[np.int64])
+assert_type(np.expand_dims(AR_LIKE_f8, 2), npt.NDArray[Any])
+
+assert_type(np.column_stack([AR_i8]), npt.NDArray[np.int64])
+assert_type(np.column_stack([AR_LIKE_f8]), npt.NDArray[Any])
+
+assert_type(np.dstack([AR_i8]), npt.NDArray[np.int64])
+assert_type(np.dstack([AR_LIKE_f8]), npt.NDArray[Any])
+
+assert_type(np.array_split(AR_i8, [3, 5, 6, 10]), list[npt.NDArray[np.int64]])
+assert_type(np.array_split(AR_LIKE_f8, [3, 5, 6, 10]), list[npt.NDArray[Any]])
+
+assert_type(np.split(AR_i8, [3, 5, 6, 10]), list[npt.NDArray[np.int64]])
+assert_type(np.split(AR_LIKE_f8, [3, 5, 6, 10]), list[npt.NDArray[Any]])
+
+assert_type(np.hsplit(AR_i8, [3, 5, 6, 10]), list[npt.NDArray[np.int64]])
+assert_type(np.hsplit(AR_LIKE_f8, [3, 5, 6, 10]), list[npt.NDArray[Any]])
+
+assert_type(np.vsplit(AR_i8, [3, 5, 6, 10]), list[npt.NDArray[np.int64]])
+assert_type(np.vsplit(AR_LIKE_f8, [3, 5, 6, 10]), list[npt.NDArray[Any]])
+
+assert_type(np.dsplit(AR_i8, [3, 5, 6, 10]), list[npt.NDArray[np.int64]])
+assert_type(np.dsplit(AR_LIKE_f8, [3, 5, 6, 10]), list[npt.NDArray[Any]])
+
+assert_type(np.kron(AR_b, AR_b), npt.NDArray[np.bool])
+assert_type(np.kron(AR_b, AR_i8), npt.NDArray[np.signedinteger[Any]])
+assert_type(np.kron(AR_f8, AR_f8), npt.NDArray[np.floating[Any]])
+
+assert_type(np.tile(AR_i8, 5), npt.NDArray[np.int64])
+assert_type(np.tile(AR_LIKE_f8, [2, 2]), npt.NDArray[Any])
+
+assert_type(np.unstack(AR_i8, axis=0), tuple[npt.NDArray[np.int64], ...])
+assert_type(np.unstack(AR_LIKE_f8, axis=0), tuple[npt.NDArray[Any], ...])
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/stride_tricks.pyi b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/stride_tricks.pyi
new file mode 100644
index 00000000..893e1bc3
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/stride_tricks.pyi
@@ -0,0 +1,33 @@
+import sys
+from typing import Any
+
+import numpy as np
+import numpy.typing as npt
+
+if sys.version_info >= (3, 11):
+    from typing import assert_type
+else:
+    from typing_extensions import assert_type
+
+AR_f8: npt.NDArray[np.float64]
+AR_LIKE_f: list[float]
+interface_dict: dict[str, Any]
+
+assert_type(np.lib.stride_tricks.as_strided(AR_f8), npt.NDArray[np.float64])
+assert_type(np.lib.stride_tricks.as_strided(AR_LIKE_f), npt.NDArray[Any])
+assert_type(np.lib.stride_tricks.as_strided(AR_f8, strides=(1, 5)), npt.NDArray[np.float64])
+assert_type(np.lib.stride_tricks.as_strided(AR_f8, shape=[9, 20]), npt.NDArray[np.float64])
+
+assert_type(np.lib.stride_tricks.sliding_window_view(AR_f8, 5), npt.NDArray[np.float64])
+assert_type(np.lib.stride_tricks.sliding_window_view(AR_LIKE_f, (1, 5)), npt.NDArray[Any])
+assert_type(np.lib.stride_tricks.sliding_window_view(AR_f8, [9], axis=1), npt.NDArray[np.float64])
+
+assert_type(np.broadcast_to(AR_f8, 5), npt.NDArray[np.float64])
+assert_type(np.broadcast_to(AR_LIKE_f, (1, 5)), npt.NDArray[Any])
+assert_type(np.broadcast_to(AR_f8, [4, 6], subok=True), npt.NDArray[np.float64])
+
+assert_type(np.broadcast_shapes((1, 2), [3, 1], (3, 2)), tuple[int, ...])
+assert_type(np.broadcast_shapes((6, 7), (5, 6, 1), 7, (5, 1, 7)), tuple[int, ...])
+
+assert_type(np.broadcast_arrays(AR_f8, AR_f8), tuple[npt.NDArray[Any], ...])
+assert_type(np.broadcast_arrays(AR_f8, AR_LIKE_f), tuple[npt.NDArray[Any], ...])
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/strings.pyi b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/strings.pyi
new file mode 100644
index 00000000..500a250b
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/strings.pyi
@@ -0,0 +1,137 @@
+import sys
+
+import numpy as np
+import numpy.typing as npt
+
+if sys.version_info >= (3, 11):
+    from typing import assert_type
+else:
+    from typing_extensions import assert_type
+
+AR_U: npt.NDArray[np.str_]
+AR_S: npt.NDArray[np.bytes_]
+
+assert_type(np.strings.equal(AR_U, AR_U), npt.NDArray[np.bool])
+assert_type(np.strings.equal(AR_S, AR_S), npt.NDArray[np.bool])
+
+assert_type(np.strings.not_equal(AR_U, AR_U), npt.NDArray[np.bool])
+assert_type(np.strings.not_equal(AR_S, AR_S), npt.NDArray[np.bool])
+
+assert_type(np.strings.greater_equal(AR_U, AR_U), npt.NDArray[np.bool])
+assert_type(np.strings.greater_equal(AR_S, AR_S), npt.NDArray[np.bool])
+
+assert_type(np.strings.less_equal(AR_U, AR_U), npt.NDArray[np.bool])
+assert_type(np.strings.less_equal(AR_S, AR_S), npt.NDArray[np.bool])
+
+assert_type(np.strings.greater(AR_U, AR_U), npt.NDArray[np.bool])
+assert_type(np.strings.greater(AR_S, AR_S), npt.NDArray[np.bool])
+
+assert_type(np.strings.less(AR_U, AR_U), npt.NDArray[np.bool])
+assert_type(np.strings.less(AR_S, AR_S), npt.NDArray[np.bool])
+
+assert_type(np.strings.multiply(AR_U, 5), npt.NDArray[np.str_])
+assert_type(np.strings.multiply(AR_S, [5, 4, 3]), npt.NDArray[np.bytes_])
+
+assert_type(np.strings.mod(AR_U, "test"), npt.NDArray[np.str_])
+assert_type(np.strings.mod(AR_S, "test"), npt.NDArray[np.bytes_])
+
+assert_type(np.strings.capitalize(AR_U), npt.NDArray[np.str_])
+assert_type(np.strings.capitalize(AR_S), npt.NDArray[np.bytes_])
+
+assert_type(np.strings.center(AR_U, 5), npt.NDArray[np.str_])
+assert_type(np.strings.center(AR_S, [2, 3, 4], b"a"), npt.NDArray[np.bytes_])
+
+assert_type(np.strings.encode(AR_U), npt.NDArray[np.bytes_])
+assert_type(np.strings.decode(AR_S), npt.NDArray[np.str_])
+
+assert_type(np.strings.expandtabs(AR_U), npt.NDArray[np.str_])
+assert_type(np.strings.expandtabs(AR_S, tabsize=4), npt.NDArray[np.bytes_])
+
+assert_type(np.strings.join(AR_U, "_"), npt.NDArray[np.str_])
+assert_type(np.strings.join(AR_S, [b"_", b""]), npt.NDArray[np.bytes_])
+
+assert_type(np.strings.ljust(AR_U, 5), npt.NDArray[np.str_])
+assert_type(np.strings.ljust(AR_S, [4, 3, 1], fillchar=[b"a", b"b", b"c"]), npt.NDArray[np.bytes_])
+assert_type(np.strings.rjust(AR_U, 5), npt.NDArray[np.str_])
+assert_type(np.strings.rjust(AR_S, [4, 3, 1], fillchar=[b"a", b"b", b"c"]), npt.NDArray[np.bytes_])
+
+assert_type(np.strings.lstrip(AR_U), npt.NDArray[np.str_])
+assert_type(np.strings.lstrip(AR_S, b"_"), npt.NDArray[np.bytes_])
+assert_type(np.strings.rstrip(AR_U), npt.NDArray[np.str_])
+assert_type(np.strings.rstrip(AR_S, b"_"), npt.NDArray[np.bytes_])
+assert_type(np.strings.strip(AR_U), npt.NDArray[np.str_])
+assert_type(np.strings.strip(AR_S, b"_"), npt.NDArray[np.bytes_])
+
+assert_type(np.strings.count(AR_U, "a", start=[1, 2, 3]), npt.NDArray[np.int_])
+assert_type(np.strings.count(AR_S, [b"a", b"b", b"c"], end=9), npt.NDArray[np.int_])
+
+assert_type(np.strings.partition(AR_U, "\n"), npt.NDArray[np.str_])
+assert_type(np.strings.partition(AR_S, [b"a", b"b", b"c"]), npt.NDArray[np.bytes_])
+assert_type(np.strings.rpartition(AR_U, "\n"), npt.NDArray[np.str_])
+assert_type(np.strings.rpartition(AR_S, [b"a", b"b", b"c"]), npt.NDArray[np.bytes_])
+
+assert_type(np.strings.replace(AR_U, "_", "-"), npt.NDArray[np.str_])
+assert_type(np.strings.replace(AR_S, [b"_", b""], [b"a", b"b"]), npt.NDArray[np.bytes_])
+
+assert_type(np.strings.split(AR_U, "_"), npt.NDArray[np.object_])
+assert_type(np.strings.split(AR_S, maxsplit=[1, 2, 3]), npt.NDArray[np.object_])
+assert_type(np.strings.rsplit(AR_U, "_"), npt.NDArray[np.object_])
+assert_type(np.strings.rsplit(AR_S, maxsplit=[1, 2, 3]), npt.NDArray[np.object_])
+
+assert_type(np.strings.splitlines(AR_U), npt.NDArray[np.object_])
+assert_type(np.strings.splitlines(AR_S, keepends=[True, True, False]), npt.NDArray[np.object_])
+
+assert_type(np.strings.swapcase(AR_U), npt.NDArray[np.str_])
+assert_type(np.strings.swapcase(AR_S), npt.NDArray[np.bytes_])
+
+assert_type(np.strings.title(AR_U), npt.NDArray[np.str_])
+assert_type(np.strings.title(AR_S), npt.NDArray[np.bytes_])
+
+assert_type(np.strings.upper(AR_U), npt.NDArray[np.str_])
+assert_type(np.strings.upper(AR_S), npt.NDArray[np.bytes_])
+
+assert_type(np.strings.zfill(AR_U, 5), npt.NDArray[np.str_])
+assert_type(np.strings.zfill(AR_S, [2, 3, 4]), npt.NDArray[np.bytes_])
+
+assert_type(np.strings.endswith(AR_U, "a", start=[1, 2, 3]), npt.NDArray[np.bool])
+assert_type(np.strings.endswith(AR_S, [b"a", b"b", b"c"], end=9), npt.NDArray[np.bool])
+assert_type(np.strings.startswith(AR_U, "a", start=[1, 2, 3]), npt.NDArray[np.bool])
+assert_type(np.strings.startswith(AR_S, [b"a", b"b", b"c"], end=9), npt.NDArray[np.bool])
+
+assert_type(np.strings.find(AR_U, "a", start=[1, 2, 3]), npt.NDArray[np.int_])
+assert_type(np.strings.find(AR_S, [b"a", b"b", b"c"], end=9), npt.NDArray[np.int_])
+assert_type(np.strings.rfind(AR_U, "a", start=[1, 2, 3]), npt.NDArray[np.int_])
+assert_type(np.strings.rfind(AR_S, [b"a", b"b", b"c"], end=9), npt.NDArray[np.int_])
+
+assert_type(np.strings.index(AR_U, "a", start=[1, 2, 3]), npt.NDArray[np.int_])
+assert_type(np.strings.index(AR_S, [b"a", b"b", b"c"], end=9), npt.NDArray[np.int_])
+assert_type(np.strings.rindex(AR_U, "a", start=[1, 2, 3]), npt.NDArray[np.int_])
+assert_type(np.strings.rindex(AR_S, [b"a", b"b", b"c"], end=9), npt.NDArray[np.int_])
+
+assert_type(np.strings.isalpha(AR_U), npt.NDArray[np.bool])
+assert_type(np.strings.isalpha(AR_S), npt.NDArray[np.bool])
+
+assert_type(np.strings.isalnum(AR_U), npt.NDArray[np.bool])
+assert_type(np.strings.isalnum(AR_S), npt.NDArray[np.bool])
+
+assert_type(np.strings.isdecimal(AR_U), npt.NDArray[np.bool])
+
+assert_type(np.strings.isdigit(AR_U), npt.NDArray[np.bool])
+assert_type(np.strings.isdigit(AR_S), npt.NDArray[np.bool])
+
+assert_type(np.strings.islower(AR_U), npt.NDArray[np.bool])
+assert_type(np.strings.islower(AR_S), npt.NDArray[np.bool])
+
+assert_type(np.strings.isnumeric(AR_U), npt.NDArray[np.bool])
+
+assert_type(np.strings.isspace(AR_U), npt.NDArray[np.bool])
+assert_type(np.strings.isspace(AR_S), npt.NDArray[np.bool])
+
+assert_type(np.strings.istitle(AR_U), npt.NDArray[np.bool])
+assert_type(np.strings.istitle(AR_S), npt.NDArray[np.bool])
+
+assert_type(np.strings.isupper(AR_U), npt.NDArray[np.bool])
+assert_type(np.strings.isupper(AR_S), npt.NDArray[np.bool])
+
+assert_type(np.strings.str_len(AR_U), npt.NDArray[np.int_])
+assert_type(np.strings.str_len(AR_S), npt.NDArray[np.int_])
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/testing.pyi b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/testing.pyi
new file mode 100644
index 00000000..2a0d8349
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/testing.pyi
@@ -0,0 +1,203 @@
+import re
+import sys
+import warnings
+import types
+import unittest
+import contextlib
+from collections.abc import Callable
+from typing import Any, TypeVar
+from pathlib import Path
+
+import numpy as np
+import numpy.typing as npt
+
+if sys.version_info >= (3, 11):
+    from typing import assert_type
+else:
+    from typing_extensions import assert_type
+
+AR_f8: npt.NDArray[np.float64]
+AR_i8: npt.NDArray[np.int64]
+
+bool_obj: bool
+suppress_obj: np.testing.suppress_warnings
+FT = TypeVar("FT", bound=Callable[..., Any])
+
+def func() -> int: ...
+
+def func2(
+    x: npt.NDArray[np.number[Any]],
+    y: npt.NDArray[np.number[Any]],
+) -> npt.NDArray[np.bool]: ...
+
+assert_type(np.testing.KnownFailureException(), np.testing.KnownFailureException)
+assert_type(np.testing.IgnoreException(), np.testing.IgnoreException)
+
+assert_type(
+    np.testing.clear_and_catch_warnings(modules=[np.testing]),
+    np.testing._private.utils._clear_and_catch_warnings_without_records,
+)
+assert_type(
+    np.testing.clear_and_catch_warnings(True),
+    np.testing._private.utils._clear_and_catch_warnings_with_records,
+)
+assert_type(
+    np.testing.clear_and_catch_warnings(False),
+    np.testing._private.utils._clear_and_catch_warnings_without_records,
+)
+assert_type(
+    np.testing.clear_and_catch_warnings(bool_obj),
+    np.testing.clear_and_catch_warnings,
+)
+assert_type(
+    np.testing.clear_and_catch_warnings.class_modules,
+    tuple[types.ModuleType, ...],
+)
+assert_type(
+    np.testing.clear_and_catch_warnings.modules,
+    set[types.ModuleType],
+)
+
+with np.testing.clear_and_catch_warnings(True) as c1:
+    assert_type(c1, list[warnings.WarningMessage])
+with np.testing.clear_and_catch_warnings() as c2:
+    assert_type(c2, None)
+
+assert_type(np.testing.suppress_warnings("once"), np.testing.suppress_warnings)
+assert_type(np.testing.suppress_warnings()(func), Callable[[], int])
+assert_type(suppress_obj.filter(RuntimeWarning), None)
+assert_type(suppress_obj.record(RuntimeWarning), list[warnings.WarningMessage])
+with suppress_obj as c3:
+    assert_type(c3, np.testing.suppress_warnings)
+
+assert_type(np.testing.verbose, int)
+assert_type(np.testing.IS_PYPY, bool)
+assert_type(np.testing.HAS_REFCOUNT, bool)
+assert_type(np.testing.HAS_LAPACK64, bool)
+
+assert_type(np.testing.assert_(1, msg="test"), None)
+assert_type(np.testing.assert_(2, msg=lambda: "test"), None)
+
+if sys.platform == "win32" or sys.platform == "cygwin":
+    assert_type(np.testing.memusage(), int)
+elif sys.platform == "linux":
+    assert_type(np.testing.memusage(), None | int)
+
+assert_type(np.testing.jiffies(), int)
+
+assert_type(np.testing.build_err_msg([0, 1, 2], "test"), str)
+assert_type(np.testing.build_err_msg(range(2), "test", header="header"), str)
+assert_type(np.testing.build_err_msg(np.arange(9).reshape(3, 3), "test", verbose=False), str)
+assert_type(np.testing.build_err_msg("abc", "test", names=["x", "y"]), str)
+assert_type(np.testing.build_err_msg([1.0, 2.0], "test", precision=5), str)
+
+assert_type(np.testing.assert_equal({1}, {1}), None)
+assert_type(np.testing.assert_equal([1, 2, 3], [1, 2, 3], err_msg="fail"), None)
+assert_type(np.testing.assert_equal(1, 1.0, verbose=True), None)
+
+assert_type(np.testing.print_assert_equal('Test XYZ of func xyz', [0, 1], [0, 1]), None)
+
+assert_type(np.testing.assert_almost_equal(1.0, 1.1), None)
+assert_type(np.testing.assert_almost_equal([1, 2, 3], [1, 2, 3], err_msg="fail"), None)
+assert_type(np.testing.assert_almost_equal(1, 1.0, verbose=True), None)
+assert_type(np.testing.assert_almost_equal(1, 1.0001, decimal=2), None)
+
+assert_type(np.testing.assert_approx_equal(1.0, 1.1), None)
+assert_type(np.testing.assert_approx_equal("1", "2", err_msg="fail"), None)
+assert_type(np.testing.assert_approx_equal(1, 1.0, verbose=True), None)
+assert_type(np.testing.assert_approx_equal(1, 1.0001, significant=2), None)
+
+assert_type(np.testing.assert_array_compare(func2, AR_i8, AR_f8, err_msg="test"), None)
+assert_type(np.testing.assert_array_compare(func2, AR_i8, AR_f8, verbose=True), None)
+assert_type(np.testing.assert_array_compare(func2, AR_i8, AR_f8, header="header"), None)
+assert_type(np.testing.assert_array_compare(func2, AR_i8, AR_f8, precision=np.int64()), None)
+assert_type(np.testing.assert_array_compare(func2, AR_i8, AR_f8, equal_nan=False), None)
+assert_type(np.testing.assert_array_compare(func2, AR_i8, AR_f8, equal_inf=True), None)
+
+assert_type(np.testing.assert_array_equal(AR_i8, AR_f8), None)
+assert_type(np.testing.assert_array_equal(AR_i8, AR_f8, err_msg="test"), None)
+assert_type(np.testing.assert_array_equal(AR_i8, AR_f8, verbose=True), None)
+
+assert_type(np.testing.assert_array_almost_equal(AR_i8, AR_f8), None)
+assert_type(np.testing.assert_array_almost_equal(AR_i8, AR_f8, err_msg="test"), None)
+assert_type(np.testing.assert_array_almost_equal(AR_i8, AR_f8, verbose=True), None)
+assert_type(np.testing.assert_array_almost_equal(AR_i8, AR_f8, decimal=1), None)
+
+assert_type(np.testing.assert_array_less(AR_i8, AR_f8), None)
+assert_type(np.testing.assert_array_less(AR_i8, AR_f8, err_msg="test"), None)
+assert_type(np.testing.assert_array_less(AR_i8, AR_f8, verbose=True), None)
+
+assert_type(np.testing.runstring("1 + 1", {}), Any)
+assert_type(np.testing.runstring("int64() + 1", {"int64": np.int64}), Any)
+
+assert_type(np.testing.assert_string_equal("1", "1"), None)
+
+assert_type(np.testing.rundocs(), None)
+assert_type(np.testing.rundocs("test.py"), None)
+assert_type(np.testing.rundocs(Path("test.py"), raise_on_error=True), None)
+
+def func3(a: int) -> bool: ...
+
+assert_type(
+    np.testing.assert_raises(RuntimeWarning),
+    unittest.case._AssertRaisesContext[RuntimeWarning],
+)
+assert_type(np.testing.assert_raises(RuntimeWarning, func3, 5), None)
+
+assert_type(
+    np.testing.assert_raises_regex(RuntimeWarning, r"test"),
+    unittest.case._AssertRaisesContext[RuntimeWarning],
+)
+assert_type(np.testing.assert_raises_regex(RuntimeWarning, b"test", func3, 5), None)
+assert_type(np.testing.assert_raises_regex(RuntimeWarning, re.compile(b"test"), func3, 5), None)
+
+class Test: ...
+
+def decorate(a: FT) -> FT:
+    return a
+
+assert_type(np.testing.decorate_methods(Test, decorate), None)
+assert_type(np.testing.decorate_methods(Test, decorate, None), None)
+assert_type(np.testing.decorate_methods(Test, decorate, "test"), None)
+assert_type(np.testing.decorate_methods(Test, decorate, b"test"), None)
+assert_type(np.testing.decorate_methods(Test, decorate, re.compile("test")), None)
+
+assert_type(np.testing.measure("for i in range(1000): np.sqrt(i**2)"), float)
+assert_type(np.testing.measure(b"for i in range(1000): np.sqrt(i**2)", times=5), float)
+
+assert_type(np.testing.assert_allclose(AR_i8, AR_f8), None)
+assert_type(np.testing.assert_allclose(AR_i8, AR_f8, rtol=0.005), None)
+assert_type(np.testing.assert_allclose(AR_i8, AR_f8, atol=1), None)
+assert_type(np.testing.assert_allclose(AR_i8, AR_f8, equal_nan=True), None)
+assert_type(np.testing.assert_allclose(AR_i8, AR_f8, err_msg="err"), None)
+assert_type(np.testing.assert_allclose(AR_i8, AR_f8, verbose=False), None)
+
+assert_type(np.testing.assert_array_almost_equal_nulp(AR_i8, AR_f8, nulp=2), None)
+
+assert_type(np.testing.assert_array_max_ulp(AR_i8, AR_f8, maxulp=2), npt.NDArray[Any])
+assert_type(np.testing.assert_array_max_ulp(AR_i8, AR_f8, dtype=np.float32), npt.NDArray[Any])
+
+assert_type(np.testing.assert_warns(RuntimeWarning), contextlib._GeneratorContextManager[None])
+assert_type(np.testing.assert_warns(RuntimeWarning, func3, 5), bool)
+
+def func4(a: int, b: str) -> bool: ...
+
+assert_type(np.testing.assert_no_warnings(), contextlib._GeneratorContextManager[None])
+assert_type(np.testing.assert_no_warnings(func3, 5), bool)
+assert_type(np.testing.assert_no_warnings(func4, a=1, b="test"), bool)
+assert_type(np.testing.assert_no_warnings(func4, 1, "test"), bool)
+
+assert_type(np.testing.tempdir("test_dir"), contextlib._GeneratorContextManager[str])
+assert_type(np.testing.tempdir(prefix=b"test"), contextlib._GeneratorContextManager[bytes])
+assert_type(np.testing.tempdir("test_dir", dir=Path("here")), contextlib._GeneratorContextManager[str])
+
+assert_type(np.testing.temppath("test_dir", text=True), contextlib._GeneratorContextManager[str])
+assert_type(np.testing.temppath(prefix=b"test"), contextlib._GeneratorContextManager[bytes])
+assert_type(np.testing.temppath("test_dir", dir=Path("here")), contextlib._GeneratorContextManager[str])
+
+assert_type(np.testing.assert_no_gc_cycles(), contextlib._GeneratorContextManager[None])
+assert_type(np.testing.assert_no_gc_cycles(func3, 5), None)
+
+assert_type(np.testing.break_cycles(), None)
+
+assert_type(np.testing.TestCase(), unittest.case.TestCase)
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/twodim_base.pyi b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/twodim_base.pyi
new file mode 100644
index 00000000..f52ad3a4
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/twodim_base.pyi
@@ -0,0 +1,156 @@
+import sys
+from typing import Any, TypeVar
+
+import numpy as np
+import numpy.typing as npt
+
+if sys.version_info >= (3, 11):
+    from typing import assert_type
+else:
+    from typing_extensions import assert_type
+
+_SCT = TypeVar("_SCT", bound=np.generic)
+
+
+def func1(ar: npt.NDArray[_SCT], a: int) -> npt.NDArray[_SCT]:
+    pass
+
+
+def func2(ar: npt.NDArray[np.number[Any]], a: str) -> npt.NDArray[np.float64]:
+    pass
+
+
+AR_b: npt.NDArray[np.bool]
+AR_u: npt.NDArray[np.uint64]
+AR_i: npt.NDArray[np.int64]
+AR_f: npt.NDArray[np.float64]
+AR_c: npt.NDArray[np.complex128]
+AR_O: npt.NDArray[np.object_]
+
+AR_LIKE_b: list[bool]
+AR_LIKE_c: list[complex]
+
+assert_type(np.fliplr(AR_b), npt.NDArray[np.bool])
+assert_type(np.fliplr(AR_LIKE_b), npt.NDArray[Any])
+
+assert_type(np.flipud(AR_b), npt.NDArray[np.bool])
+assert_type(np.flipud(AR_LIKE_b), npt.NDArray[Any])
+
+assert_type(np.eye(10), npt.NDArray[np.float64])
+assert_type(np.eye(10, M=20, dtype=np.int64), npt.NDArray[np.int64])
+assert_type(np.eye(10, k=2, dtype=int), npt.NDArray[Any])
+
+assert_type(np.diag(AR_b), npt.NDArray[np.bool])
+assert_type(np.diag(AR_LIKE_b, k=0), npt.NDArray[Any])
+
+assert_type(np.diagflat(AR_b), npt.NDArray[np.bool])
+assert_type(np.diagflat(AR_LIKE_b, k=0), npt.NDArray[Any])
+
+assert_type(np.tri(10), npt.NDArray[np.float64])
+assert_type(np.tri(10, M=20, dtype=np.int64), npt.NDArray[np.int64])
+assert_type(np.tri(10, k=2, dtype=int), npt.NDArray[Any])
+
+assert_type(np.tril(AR_b), npt.NDArray[np.bool])
+assert_type(np.tril(AR_LIKE_b, k=0), npt.NDArray[Any])
+
+assert_type(np.triu(AR_b), npt.NDArray[np.bool])
+assert_type(np.triu(AR_LIKE_b, k=0), npt.NDArray[Any])
+
+assert_type(np.vander(AR_b), npt.NDArray[np.signedinteger[Any]])
+assert_type(np.vander(AR_u), npt.NDArray[np.signedinteger[Any]])
+assert_type(np.vander(AR_i, N=2), npt.NDArray[np.signedinteger[Any]])
+assert_type(np.vander(AR_f, increasing=True), npt.NDArray[np.floating[Any]])
+assert_type(np.vander(AR_c), npt.NDArray[np.complexfloating[Any, Any]])
+assert_type(np.vander(AR_O), npt.NDArray[np.object_])
+
+assert_type(
+    np.histogram2d(AR_LIKE_c, AR_LIKE_c),
+    tuple[
+        npt.NDArray[np.float64],
+        npt.NDArray[np.complex128 | np.float64],
+        npt.NDArray[np.complex128 | np.float64],
+    ],
+)
+assert_type(
+    np.histogram2d(AR_i, AR_b),
+    tuple[
+        npt.NDArray[np.float64],
+        npt.NDArray[np.float64],
+        npt.NDArray[np.float64],
+    ],
+)
+assert_type(
+    np.histogram2d(AR_f, AR_i),
+    tuple[
+        npt.NDArray[np.float64],
+        npt.NDArray[np.float64],
+        npt.NDArray[np.float64],
+    ],
+)
+assert_type(
+    np.histogram2d(AR_i, AR_f),
+    tuple[
+        npt.NDArray[np.float64],
+        npt.NDArray[np.float64],
+        npt.NDArray[np.float64],
+    ],
+)
+assert_type(
+    np.histogram2d(AR_f, AR_c, weights=AR_LIKE_b),
+    tuple[
+        npt.NDArray[np.float64],
+        npt.NDArray[np.complex128],
+        npt.NDArray[np.complex128],
+    ],
+)
+assert_type(
+    np.histogram2d(AR_f, AR_c, bins=8),
+    tuple[
+        npt.NDArray[np.float64],
+        npt.NDArray[np.complex128],
+        npt.NDArray[np.complex128],
+    ],
+)
+assert_type(
+    np.histogram2d(AR_c, AR_f, bins=(8, 5)),
+    tuple[
+        npt.NDArray[np.float64],
+        npt.NDArray[np.complex128],
+        npt.NDArray[np.complex128],
+    ],
+)
+assert_type(
+    np.histogram2d(AR_c, AR_i, bins=AR_u),
+    tuple[
+        npt.NDArray[np.float64],
+        npt.NDArray[np.uint64],
+        npt.NDArray[np.uint64],
+    ],
+)
+assert_type(
+    np.histogram2d(AR_c, AR_c, bins=(AR_u, AR_u)),
+    tuple[
+        npt.NDArray[np.float64],
+        npt.NDArray[np.uint64],
+        npt.NDArray[np.uint64],
+    ],
+)
+assert_type(
+    np.histogram2d(AR_c, AR_c, bins=(AR_b, 8)),
+    tuple[
+        npt.NDArray[np.float64],
+        npt.NDArray[np.bool | np.complex128],
+        npt.NDArray[np.bool | np.complex128],
+    ],
+)
+
+assert_type(np.mask_indices(10, func1), tuple[npt.NDArray[np.intp], npt.NDArray[np.intp]])
+assert_type(np.mask_indices(8, func2, "0"), tuple[npt.NDArray[np.intp], npt.NDArray[np.intp]])
+
+assert_type(np.tril_indices(10), tuple[npt.NDArray[np.int_], npt.NDArray[np.int_]])
+
+assert_type(np.tril_indices_from(AR_b), tuple[npt.NDArray[np.int_], npt.NDArray[np.int_]])
+
+assert_type(np.triu_indices(10), tuple[npt.NDArray[np.int_], npt.NDArray[np.int_]])
+
+assert_type(np.triu_indices_from(AR_b), tuple[npt.NDArray[np.int_], npt.NDArray[np.int_]])
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/type_check.pyi b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/type_check.pyi
new file mode 100644
index 00000000..6d357278
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/type_check.pyi
@@ -0,0 +1,82 @@
+import sys
+from typing import Any, Literal
+
+import numpy as np
+import numpy.typing as npt
+from numpy._typing import _16Bit, _32Bit, _64Bit, _128Bit
+
+if sys.version_info >= (3, 11):
+    from typing import assert_type
+else:
+    from typing_extensions import assert_type
+
+f8: np.float64
+f: float
+
+# NOTE: Avoid importing the platform specific `np.float128` type
+AR_i8: npt.NDArray[np.int64]
+AR_i4: npt.NDArray[np.int32]
+AR_f2: npt.NDArray[np.float16]
+AR_f8: npt.NDArray[np.float64]
+AR_f16: npt.NDArray[np.floating[_128Bit]]
+AR_c8: npt.NDArray[np.complex64]
+AR_c16: npt.NDArray[np.complex128]
+
+AR_LIKE_f: list[float]
+
+class RealObj:
+    real: slice
+
+class ImagObj:
+    imag: slice
+
+assert_type(np.mintypecode(["f8"], typeset="qfQF"), str)
+
+assert_type(np.real(RealObj()), slice)
+assert_type(np.real(AR_f8), npt.NDArray[np.float64])
+assert_type(np.real(AR_c16), npt.NDArray[np.float64])
+assert_type(np.real(AR_LIKE_f), npt.NDArray[Any])
+
+assert_type(np.imag(ImagObj()), slice)
+assert_type(np.imag(AR_f8), npt.NDArray[np.float64])
+assert_type(np.imag(AR_c16), npt.NDArray[np.float64])
+assert_type(np.imag(AR_LIKE_f), npt.NDArray[Any])
+
+assert_type(np.iscomplex(f8), np.bool)
+assert_type(np.iscomplex(AR_f8), npt.NDArray[np.bool])
+assert_type(np.iscomplex(AR_LIKE_f), npt.NDArray[np.bool])
+
+assert_type(np.isreal(f8), np.bool)
+assert_type(np.isreal(AR_f8), npt.NDArray[np.bool])
+assert_type(np.isreal(AR_LIKE_f), npt.NDArray[np.bool])
+
+assert_type(np.iscomplexobj(f8), bool)
+assert_type(np.isrealobj(f8), bool)
+
+assert_type(np.nan_to_num(f8), np.float64)
+assert_type(np.nan_to_num(f, copy=True), Any)
+assert_type(np.nan_to_num(AR_f8, nan=1.5), npt.NDArray[np.float64])
+assert_type(np.nan_to_num(AR_LIKE_f, posinf=9999), npt.NDArray[Any])
+
+assert_type(np.real_if_close(AR_f8), npt.NDArray[np.float64])
+assert_type(np.real_if_close(AR_c16), npt.NDArray[np.float64] | npt.NDArray[np.complex128])
+assert_type(np.real_if_close(AR_c8), npt.NDArray[np.float32] | npt.NDArray[np.complex64])
+assert_type(np.real_if_close(AR_LIKE_f), npt.NDArray[Any])
+
+assert_type(np.typename("h"), Literal["short"])
+assert_type(np.typename("B"), Literal["unsigned char"])
+assert_type(np.typename("V"), Literal["void"])
+assert_type(np.typename("S1"), Literal["character"])
+
+assert_type(np.common_type(AR_i4), type[np.float64])
+assert_type(np.common_type(AR_f2), type[np.float16])
+assert_type(np.common_type(AR_f2, AR_i4), type[np.floating[_16Bit | _64Bit]])
+assert_type(np.common_type(AR_f16, AR_i4), type[np.floating[_64Bit | _128Bit]])
+assert_type(
+    np.common_type(AR_c8, AR_f2),
+    type[np.complexfloating[_16Bit | _32Bit, _16Bit | _32Bit]],
+)
+assert_type(
+    np.common_type(AR_f2, AR_c8, AR_i4),
+    type[np.complexfloating[_16Bit | _32Bit | _64Bit, _16Bit | _32Bit | _64Bit]],
+)
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/ufunc_config.pyi b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/ufunc_config.pyi
new file mode 100644
index 00000000..9d74abf4
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/ufunc_config.pyi
@@ -0,0 +1,37 @@
+"""Typing tests for `_core._ufunc_config`."""
+
+import sys
+from typing import Any, Protocol
+from collections.abc import Callable
+
+import numpy as np
+
+if sys.version_info >= (3, 11):
+    from typing import assert_type
+else:
+    from typing_extensions import assert_type
+
+def func(a: str, b: int) -> None: ...
+
+class Write:
+    def write(self, value: str) -> None: ...
+
+class SupportsWrite(Protocol):
+    def write(self, s: str, /) -> object: ...
+
+assert_type(np.seterr(all=None), np._core._ufunc_config._ErrDict)
+assert_type(np.seterr(divide="ignore"), np._core._ufunc_config._ErrDict)
+assert_type(np.seterr(over="warn"), np._core._ufunc_config._ErrDict)
+assert_type(np.seterr(under="call"), np._core._ufunc_config._ErrDict)
+assert_type(np.seterr(invalid="raise"), np._core._ufunc_config._ErrDict)
+assert_type(np.geterr(), np._core._ufunc_config._ErrDict)
+
+assert_type(np.setbufsize(4096), int)
+assert_type(np.getbufsize(), int)
+
+assert_type(np.seterrcall(func), Callable[[str, int], Any] | None | SupportsWrite)
+assert_type(np.seterrcall(Write()), Callable[[str, int], Any] | None | SupportsWrite)
+assert_type(np.geterrcall(), Callable[[str, int], Any] | None | SupportsWrite)
+
+assert_type(np.errstate(call=func, all="call"), np.errstate)
+assert_type(np.errstate(call=Write(), divide="log", over="log"), np.errstate)
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/ufunclike.pyi b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/ufunclike.pyi
new file mode 100644
index 00000000..e29e76ed
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/ufunclike.pyi
@@ -0,0 +1,37 @@
+import sys
+from typing import Any
+
+import numpy as np
+import numpy.typing as npt
+
+if sys.version_info >= (3, 11):
+    from typing import assert_type
+else:
+    from typing_extensions import assert_type
+
+AR_LIKE_b: list[bool]
+AR_LIKE_u: list[np.uint32]
+AR_LIKE_i: list[int]
+AR_LIKE_f: list[float]
+AR_LIKE_O: list[np.object_]
+
+AR_U: npt.NDArray[np.str_]
+
+assert_type(np.fix(AR_LIKE_b), npt.NDArray[np.floating[Any]])
+assert_type(np.fix(AR_LIKE_u), npt.NDArray[np.floating[Any]])
+assert_type(np.fix(AR_LIKE_i), npt.NDArray[np.floating[Any]])
+assert_type(np.fix(AR_LIKE_f), npt.NDArray[np.floating[Any]])
+assert_type(np.fix(AR_LIKE_O), npt.NDArray[np.object_])
+assert_type(np.fix(AR_LIKE_f, out=AR_U), npt.NDArray[np.str_])
+
+assert_type(np.isposinf(AR_LIKE_b), npt.NDArray[np.bool])
+assert_type(np.isposinf(AR_LIKE_u), npt.NDArray[np.bool])
+assert_type(np.isposinf(AR_LIKE_i), npt.NDArray[np.bool])
+assert_type(np.isposinf(AR_LIKE_f), npt.NDArray[np.bool])
+assert_type(np.isposinf(AR_LIKE_f, out=AR_U), npt.NDArray[np.str_])
+
+assert_type(np.isneginf(AR_LIKE_b), npt.NDArray[np.bool])
+assert_type(np.isneginf(AR_LIKE_u), npt.NDArray[np.bool])
+assert_type(np.isneginf(AR_LIKE_i), npt.NDArray[np.bool])
+assert_type(np.isneginf(AR_LIKE_f), npt.NDArray[np.bool])
+assert_type(np.isneginf(AR_LIKE_f, out=AR_U), npt.NDArray[np.str_])
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/ufuncs.pyi b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/ufuncs.pyi
new file mode 100644
index 00000000..39a796bf
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/ufuncs.pyi
@@ -0,0 +1,122 @@
+import sys
+from typing import Literal, Any, NoReturn
+
+import numpy as np
+import numpy.typing as npt
+
+if sys.version_info >= (3, 11):
+    from typing import assert_type
+else:
+    from typing_extensions import assert_type
+
+i8: np.int64
+f8: np.float64
+AR_f8: npt.NDArray[np.float64]
+AR_i8: npt.NDArray[np.int64]
+
+assert_type(np.absolute.__doc__, str)
+assert_type(np.absolute.types, list[str])
+
+assert_type(np.absolute.__name__, Literal["absolute"])
+assert_type(np.absolute.ntypes, Literal[20])
+assert_type(np.absolute.identity, None)
+assert_type(np.absolute.nin, Literal[1])
+assert_type(np.absolute.nin, Literal[1])
+assert_type(np.absolute.nout, Literal[1])
+assert_type(np.absolute.nargs, Literal[2])
+assert_type(np.absolute.signature, None)
+assert_type(np.absolute(f8), Any)
+assert_type(np.absolute(AR_f8), npt.NDArray[Any])
+assert_type(np.absolute.at(AR_f8, AR_i8), None)
+
+assert_type(np.add.__name__, Literal["add"])
+assert_type(np.add.ntypes, Literal[22])
+assert_type(np.add.identity, Literal[0])
+assert_type(np.add.nin, Literal[2])
+assert_type(np.add.nout, Literal[1])
+assert_type(np.add.nargs, Literal[3])
+assert_type(np.add.signature, None)
+assert_type(np.add(f8, f8), Any)
+assert_type(np.add(AR_f8, f8), npt.NDArray[Any])
+assert_type(np.add.at(AR_f8, AR_i8, f8), None)
+assert_type(np.add.reduce(AR_f8, axis=0), Any)
+assert_type(np.add.accumulate(AR_f8), npt.NDArray[Any])
+assert_type(np.add.reduceat(AR_f8, AR_i8), npt.NDArray[Any])
+assert_type(np.add.outer(f8, f8), Any)
+assert_type(np.add.outer(AR_f8, f8), npt.NDArray[Any])
+
+assert_type(np.frexp.__name__, Literal["frexp"])
+assert_type(np.frexp.ntypes, Literal[4])
+assert_type(np.frexp.identity, None)
+assert_type(np.frexp.nin, Literal[1])
+assert_type(np.frexp.nout, Literal[2])
+assert_type(np.frexp.nargs, Literal[3])
+assert_type(np.frexp.signature, None)
+assert_type(np.frexp(f8), tuple[Any, Any])
+assert_type(np.frexp(AR_f8), tuple[npt.NDArray[Any], npt.NDArray[Any]])
+
+assert_type(np.divmod.__name__, Literal["divmod"])
+assert_type(np.divmod.ntypes, Literal[15])
+assert_type(np.divmod.identity, None)
+assert_type(np.divmod.nin, Literal[2])
+assert_type(np.divmod.nout, Literal[2])
+assert_type(np.divmod.nargs, Literal[4])
+assert_type(np.divmod.signature, None)
+assert_type(np.divmod(f8, f8), tuple[Any, Any])
+assert_type(np.divmod(AR_f8, f8), tuple[npt.NDArray[Any], npt.NDArray[Any]])
+
+assert_type(np.matmul.__name__, Literal["matmul"])
+assert_type(np.matmul.ntypes, Literal[19])
+assert_type(np.matmul.identity, None)
+assert_type(np.matmul.nin, Literal[2])
+assert_type(np.matmul.nout, Literal[1])
+assert_type(np.matmul.nargs, Literal[3])
+assert_type(np.matmul.signature, Literal["(n?,k),(k,m?)->(n?,m?)"])
+assert_type(np.matmul.identity, None)
+assert_type(np.matmul(AR_f8, AR_f8), Any)
+assert_type(np.matmul(AR_f8, AR_f8, axes=[(0, 1), (0, 1), (0, 1)]), Any)
+
+assert_type(np.vecdot.__name__, Literal["vecdot"])
+assert_type(np.vecdot.ntypes, Literal[19])
+assert_type(np.vecdot.identity, None)
+assert_type(np.vecdot.nin, Literal[2])
+assert_type(np.vecdot.nout, Literal[1])
+assert_type(np.vecdot.nargs, Literal[3])
+assert_type(np.vecdot.signature, Literal["(n),(n)->()"])
+assert_type(np.vecdot.identity, None)
+assert_type(np.vecdot(AR_f8, AR_f8), Any)
+
+assert_type(np.bitwise_count.__name__, Literal['bitwise_count'])
+assert_type(np.bitwise_count.ntypes, Literal[11])
+assert_type(np.bitwise_count.identity, None)
+assert_type(np.bitwise_count.nin, Literal[1])
+assert_type(np.bitwise_count.nout, Literal[1])
+assert_type(np.bitwise_count.nargs, Literal[2])
+assert_type(np.bitwise_count.signature, None)
+assert_type(np.bitwise_count.identity, None)
+assert_type(np.bitwise_count(i8), Any)
+assert_type(np.bitwise_count(AR_i8), npt.NDArray[Any])
+
+assert_type(np.absolute.outer(), NoReturn)
+assert_type(np.frexp.outer(), NoReturn)
+assert_type(np.divmod.outer(), NoReturn)
+assert_type(np.matmul.outer(), NoReturn)
+
+assert_type(np.absolute.reduceat(), NoReturn)
+assert_type(np.frexp.reduceat(), NoReturn)
+assert_type(np.divmod.reduceat(), NoReturn)
+assert_type(np.matmul.reduceat(), NoReturn)
+
+assert_type(np.absolute.reduce(), NoReturn)
+assert_type(np.frexp.reduce(), NoReturn)
+assert_type(np.divmod.reduce(), NoReturn)
+assert_type(np.matmul.reduce(), NoReturn)
+
+assert_type(np.absolute.accumulate(), NoReturn)
+assert_type(np.frexp.accumulate(), NoReturn)
+assert_type(np.divmod.accumulate(), NoReturn)
+assert_type(np.matmul.accumulate(), NoReturn)
+
+assert_type(np.frexp.at(), NoReturn)
+assert_type(np.divmod.at(), NoReturn)
+assert_type(np.matmul.at(), NoReturn)
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/warnings_and_errors.pyi b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/warnings_and_errors.pyi
new file mode 100644
index 00000000..e498fee0
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/data/reveal/warnings_and_errors.pyi
@@ -0,0 +1,16 @@
+import sys
+
+import numpy.exceptions as ex
+
+if sys.version_info >= (3, 11):
+    from typing import assert_type
+else:
+    from typing_extensions import assert_type
+
+assert_type(ex.ModuleDeprecationWarning(), ex.ModuleDeprecationWarning)
+assert_type(ex.VisibleDeprecationWarning(), ex.VisibleDeprecationWarning)
+assert_type(ex.ComplexWarning(), ex.ComplexWarning)
+assert_type(ex.RankWarning(), ex.RankWarning)
+assert_type(ex.TooHardError(), ex.TooHardError)
+assert_type(ex.AxisError("test"), ex.AxisError)
+assert_type(ex.AxisError(5, 1), ex.AxisError)
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/test_isfile.py b/venv/lib/python3.12/site-packages/numpy/typing/tests/test_isfile.py
new file mode 100644
index 00000000..e77b560f
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/test_isfile.py
@@ -0,0 +1,32 @@
+import os
+import sys
+from pathlib import Path
+
+import numpy as np
+from numpy.testing import assert_
+
+ROOT = Path(np.__file__).parents[0]
+FILES = [
+    ROOT / "py.typed",
+    ROOT / "__init__.pyi",
+    ROOT / "ctypeslib.pyi",
+    ROOT / "_core" / "__init__.pyi",
+    ROOT / "f2py" / "__init__.pyi",
+    ROOT / "fft" / "__init__.pyi",
+    ROOT / "lib" / "__init__.pyi",
+    ROOT / "linalg" / "__init__.pyi",
+    ROOT / "ma" / "__init__.pyi",
+    ROOT / "matrixlib" / "__init__.pyi",
+    ROOT / "polynomial" / "__init__.pyi",
+    ROOT / "random" / "__init__.pyi",
+    ROOT / "testing" / "__init__.pyi",
+]
+if sys.version_info < (3, 12):
+    FILES += [ROOT / "distutils" / "__init__.pyi"]
+
+
+class TestIsFile:
+    def test_isfile(self):
+        """Test if all ``.pyi`` files are properly installed."""
+        for file in FILES:
+            assert_(os.path.isfile(file))
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/test_runtime.py b/venv/lib/python3.12/site-packages/numpy/typing/tests/test_runtime.py
new file mode 100644
index 00000000..c32c5db3
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/test_runtime.py
@@ -0,0 +1,109 @@
+"""Test the runtime usage of `numpy.typing`."""
+
+from __future__ import annotations
+
+from typing import (
+    get_type_hints,
+    Union,
+    NamedTuple,
+    get_args,
+    get_origin,
+    Any,
+)
+
+import pytest
+import numpy as np
+import numpy.typing as npt
+import numpy._typing as _npt
+
+
+class TypeTup(NamedTuple):
+    typ: type
+    args: tuple[type, ...]
+    origin: None | type
+
+
+NDArrayTup = TypeTup(npt.NDArray, npt.NDArray.__args__, np.ndarray)
+
+TYPES = {
+    "ArrayLike": TypeTup(npt.ArrayLike, npt.ArrayLike.__args__, Union),
+    "DTypeLike": TypeTup(npt.DTypeLike, npt.DTypeLike.__args__, Union),
+    "NBitBase": TypeTup(npt.NBitBase, (), None),
+    "NDArray": NDArrayTup,
+}
+
+
+@pytest.mark.parametrize("name,tup", TYPES.items(), ids=TYPES.keys())
+def test_get_args(name: type, tup: TypeTup) -> None:
+    """Test `typing.get_args`."""
+    typ, ref = tup.typ, tup.args
+    out = get_args(typ)
+    assert out == ref
+
+
+@pytest.mark.parametrize("name,tup", TYPES.items(), ids=TYPES.keys())
+def test_get_origin(name: type, tup: TypeTup) -> None:
+    """Test `typing.get_origin`."""
+    typ, ref = tup.typ, tup.origin
+    out = get_origin(typ)
+    assert out == ref
+
+
+@pytest.mark.parametrize("name,tup", TYPES.items(), ids=TYPES.keys())
+def test_get_type_hints(name: type, tup: TypeTup) -> None:
+    """Test `typing.get_type_hints`."""
+    typ = tup.typ
+
+    # Explicitly set `__annotations__` in order to circumvent the
+    # stringification performed by `from __future__ import annotations`
+    def func(a): pass
+    func.__annotations__ = {"a": typ, "return": None}
+
+    out = get_type_hints(func)
+    ref = {"a": typ, "return": type(None)}
+    assert out == ref
+
+
+@pytest.mark.parametrize("name,tup", TYPES.items(), ids=TYPES.keys())
+def test_get_type_hints_str(name: type, tup: TypeTup) -> None:
+    """Test `typing.get_type_hints` with string-representation of types."""
+    typ_str, typ = f"npt.{name}", tup.typ
+
+    # Explicitly set `__annotations__` in order to circumvent the
+    # stringification performed by `from __future__ import annotations`
+    def func(a): pass
+    func.__annotations__ = {"a": typ_str, "return": None}
+
+    out = get_type_hints(func)
+    ref = {"a": typ, "return": type(None)}
+    assert out == ref
+
+
+def test_keys() -> None:
+    """Test that ``TYPES.keys()`` and ``numpy.typing.__all__`` are synced."""
+    keys = TYPES.keys()
+    ref = set(npt.__all__)
+    assert keys == ref
+
+
+PROTOCOLS: dict[str, tuple[type[Any], object]] = {
+    "_SupportsDType": (_npt._SupportsDType, np.int64(1)),
+    "_SupportsArray": (_npt._SupportsArray, np.arange(10)),
+    "_SupportsArrayFunc": (_npt._SupportsArrayFunc, np.arange(10)),
+    "_NestedSequence": (_npt._NestedSequence, [1]),
+}
+
+
+@pytest.mark.parametrize("cls,obj", PROTOCOLS.values(), ids=PROTOCOLS.keys())
+class TestRuntimeProtocol:
+    def test_isinstance(self, cls: type[Any], obj: object) -> None:
+        assert isinstance(obj, cls)
+        assert not isinstance(None, cls)
+
+    def test_issubclass(self, cls: type[Any], obj: object) -> None:
+        if cls is _npt._SupportsDType:
+            pytest.xfail(
+                "Protocols with non-method members don't support issubclass()"
+            )
+        assert issubclass(type(obj), cls)
+        assert not issubclass(type(None), cls)
diff --git a/venv/lib/python3.12/site-packages/numpy/typing/tests/test_typing.py b/venv/lib/python3.12/site-packages/numpy/typing/tests/test_typing.py
new file mode 100644
index 00000000..dc65a51a
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/typing/tests/test_typing.py
@@ -0,0 +1,286 @@
+from __future__ import annotations
+
+import importlib.util
+import os
+import re
+import shutil
+from collections import defaultdict
+from collections.abc import Iterator
+from typing import TYPE_CHECKING
+
+import pytest
+from numpy.typing.mypy_plugin import _EXTENDED_PRECISION_LIST
+
+
+# Only trigger a full `mypy` run if this environment variable is set
+# Note that these tests tend to take over a minute even on a macOS M1 CPU,
+# and more than that in CI.
+RUN_MYPY = "NPY_RUN_MYPY_IN_TESTSUITE" in os.environ
+if RUN_MYPY and RUN_MYPY not in ('0', '', 'false'):
+    RUN_MYPY = True
+
+# Skips all functions in this file
+pytestmark = pytest.mark.skipif(
+    not RUN_MYPY,
+    reason="`NPY_RUN_MYPY_IN_TESTSUITE` not set"
+)
+
+
+try:
+    from mypy import api
+except ImportError:
+    NO_MYPY = True
+else:
+    NO_MYPY = False
+
+if TYPE_CHECKING:
+    # We need this as annotation, but it's located in a private namespace.
+    # As a compromise, do *not* import it during runtime
+    from _pytest.mark.structures import ParameterSet
+
+DATA_DIR = os.path.join(os.path.dirname(__file__), "data")
+PASS_DIR = os.path.join(DATA_DIR, "pass")
+FAIL_DIR = os.path.join(DATA_DIR, "fail")
+REVEAL_DIR = os.path.join(DATA_DIR, "reveal")
+MISC_DIR = os.path.join(DATA_DIR, "misc")
+MYPY_INI = os.path.join(DATA_DIR, "mypy.ini")
+CACHE_DIR = os.path.join(DATA_DIR, ".mypy_cache")
+
+#: A dictionary with file names as keys and lists of the mypy stdout as values.
+#: To-be populated by `run_mypy`.
+OUTPUT_MYPY: defaultdict[str, list[str]] = defaultdict(list)
+
+
+def _key_func(key: str) -> str:
+    """Split at the first occurrence of the ``:`` character.
+
+    Windows drive-letters (*e.g.* ``C:``) are ignored herein.
+    """
+    drive, tail = os.path.splitdrive(key)
+    return os.path.join(drive, tail.split(":", 1)[0])
+
+
+def _strip_filename(msg: str) -> tuple[int, str]:
+    """Strip the filename and line number from a mypy message."""
+    _, tail = os.path.splitdrive(msg)
+    _, lineno, msg = tail.split(":", 2)
+    return int(lineno), msg.strip()
+
+
+def strip_func(match: re.Match[str]) -> str:
+    """`re.sub` helper function for stripping module names."""
+    return match.groups()[1]
+
+
+@pytest.fixture(scope="module", autouse=True)
+def run_mypy() -> None:
+    """Clears the cache and run mypy before running any of the typing tests.
+
+    The mypy results are cached in `OUTPUT_MYPY` for further use.
+
+    The cache refresh can be skipped using
+
+    NUMPY_TYPING_TEST_CLEAR_CACHE=0 pytest numpy/typing/tests
+    """
+    if (
+        os.path.isdir(CACHE_DIR)
+        and bool(os.environ.get("NUMPY_TYPING_TEST_CLEAR_CACHE", True))
+    ):
+        shutil.rmtree(CACHE_DIR)
+
+    split_pattern = re.compile(r"(\s+)?\^(\~+)?")
+    for directory in (PASS_DIR, REVEAL_DIR, FAIL_DIR, MISC_DIR):
+        # Run mypy
+        stdout, stderr, exit_code = api.run([
+            "--config-file",
+            MYPY_INI,
+            "--cache-dir",
+            CACHE_DIR,
+            directory,
+        ])
+        if stderr:
+            pytest.fail(f"Unexpected mypy standard error\n\n{stderr}")
+        elif exit_code not in {0, 1}:
+            pytest.fail(f"Unexpected mypy exit code: {exit_code}\n\n{stdout}")
+
+        str_concat = ""
+        filename: str | None = None
+        for i in stdout.split("\n"):
+            if "note:" in i:
+                continue
+            if filename is None:
+                filename = _key_func(i)
+
+            str_concat += f"{i}\n"
+            if split_pattern.match(i) is not None:
+                OUTPUT_MYPY[filename].append(str_concat)
+                str_concat = ""
+                filename = None
+
+
+def get_test_cases(directory: str) -> Iterator[ParameterSet]:
+    for root, _, files in os.walk(directory):
+        for fname in files:
+            short_fname, ext = os.path.splitext(fname)
+            if ext in (".pyi", ".py"):
+                fullpath = os.path.join(root, fname)
+                yield pytest.param(fullpath, id=short_fname)
+
+
+@pytest.mark.slow
+@pytest.mark.skipif(NO_MYPY, reason="Mypy is not installed")
+@pytest.mark.parametrize("path", get_test_cases(PASS_DIR))
+def test_success(path) -> None:
+    # Alias `OUTPUT_MYPY` so that it appears in the local namespace
+    output_mypy = OUTPUT_MYPY
+    if path in output_mypy:
+        msg = "Unexpected mypy output\n\n"
+        msg += "\n".join(_strip_filename(v)[1] for v in output_mypy[path])
+        raise AssertionError(msg)
+
+
+@pytest.mark.slow
+@pytest.mark.skipif(NO_MYPY, reason="Mypy is not installed")
+@pytest.mark.parametrize("path", get_test_cases(FAIL_DIR))
+def test_fail(path: str) -> None:
+    __tracebackhide__ = True
+
+    with open(path) as fin:
+        lines = fin.readlines()
+
+    errors = defaultdict(lambda: "")
+
+    output_mypy = OUTPUT_MYPY
+    assert path in output_mypy
+
+    for error_line in output_mypy[path]:
+        lineno, error_line = _strip_filename(error_line)
+        errors[lineno] += f'{error_line}\n'
+
+    for i, line in enumerate(lines):
+        lineno = i + 1
+        if (
+            line.startswith('#')
+            or (" E:" not in line and lineno not in errors)
+        ):
+            continue
+
+        target_line = lines[lineno - 1]
+        if "# E:" in target_line:
+            expression, _, marker = target_line.partition("  # E: ")
+            expected_error = errors[lineno].strip()
+            marker = marker.strip()
+            _test_fail(path, expression, marker, expected_error, lineno)
+        else:
+            pytest.fail(
+                f"Unexpected mypy output at line {lineno}\n\n{errors[lineno]}"
+            )
+
+
+_FAIL_MSG1 = """Extra error at line {}
+
+Expression: {}
+Extra error: {!r}
+"""
+
+_FAIL_MSG2 = """Error mismatch at line {}
+
+Expression: {}
+Expected error: {}
+Observed error: {!r}
+"""
+
+
+def _test_fail(
+    path: str,
+    expression: str,
+    error: str,
+    expected_error: None | str,
+    lineno: int,
+) -> None:
+    if expected_error is None:
+        raise AssertionError(_FAIL_MSG1.format(lineno, expression, error))
+    elif error not in expected_error:
+        raise AssertionError(_FAIL_MSG2.format(
+            lineno, expression, expected_error, error
+        ))
+
+
+_REVEAL_MSG = """Reveal mismatch at line {}
+
+{}
+"""
+
+
+@pytest.mark.slow
+@pytest.mark.skipif(NO_MYPY, reason="Mypy is not installed")
+@pytest.mark.parametrize("path", get_test_cases(REVEAL_DIR))
+def test_reveal(path: str) -> None:
+    """Validate that mypy correctly infers the return-types of
+    the expressions in `path`.
+    """
+    __tracebackhide__ = True
+
+    output_mypy = OUTPUT_MYPY
+    if path not in output_mypy:
+        return
+
+    for error_line in output_mypy[path]:
+        lineno, error_line = _strip_filename(error_line)
+        raise AssertionError(_REVEAL_MSG.format(lineno, error_line))
+
+
+@pytest.mark.slow
+@pytest.mark.skipif(NO_MYPY, reason="Mypy is not installed")
+@pytest.mark.parametrize("path", get_test_cases(PASS_DIR))
+def test_code_runs(path: str) -> None:
+    """Validate that the code in `path` properly during runtime."""
+    path_without_extension, _ = os.path.splitext(path)
+    dirname, filename = path.split(os.sep)[-2:]
+
+    spec = importlib.util.spec_from_file_location(
+        f"{dirname}.{filename}", path
+    )
+    assert spec is not None
+    assert spec.loader is not None
+
+    test_module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(test_module)
+
+
+LINENO_MAPPING = {
+    11: "uint128",
+    12: "uint256",
+    14: "int128",
+    15: "int256",
+    17: "float80",
+    18: "float96",
+    19: "float128",
+    20: "float256",
+    22: "complex160",
+    23: "complex192",
+    24: "complex256",
+    25: "complex512",
+}
+
+
+@pytest.mark.slow
+@pytest.mark.skipif(NO_MYPY, reason="Mypy is not installed")
+def test_extended_precision() -> None:
+    path = os.path.join(MISC_DIR, "extended_precision.pyi")
+    output_mypy = OUTPUT_MYPY
+    assert path in output_mypy
+
+    with open(path) as f:
+        expression_list = f.readlines()
+
+    for _msg in output_mypy[path]:
+        lineno, msg = _strip_filename(_msg)
+        expression = expression_list[lineno - 1].rstrip("\n")
+
+        if LINENO_MAPPING[lineno] in _EXTENDED_PRECISION_LIST:
+            raise AssertionError(_REVEAL_MSG.format(lineno, msg))
+        elif "error" not in msg:
+            _test_fail(
+                path, expression, msg, 'Expression is of type "Any"', lineno
+            )
diff --git a/venv/lib/python3.12/site-packages/numpy/version.py b/venv/lib/python3.12/site-packages/numpy/version.py
new file mode 100644
index 00000000..27cf4620
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/version.py
@@ -0,0 +1,11 @@
+
+"""
+Module to expose more detailed version info for the installed `numpy`
+"""
+version = "2.1.3"
+__version__ = version
+full_version = version
+
+git_revision = "98464cc0cbc1f211482a0756ded305bed1599f18"
+release = 'dev' not in version and '+' not in version
+short_version = version.split("+")[0]
diff --git a/venv/lib/python3.12/site-packages/numpy/version.pyi b/venv/lib/python3.12/site-packages/numpy/version.pyi
new file mode 100644
index 00000000..1262189f
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/numpy/version.pyi
@@ -0,0 +1,24 @@
+import sys
+from typing import Final, TypeAlias
+
+if sys.version_info >= (3, 11):
+    from typing import LiteralString
+else:
+    LiteralString: TypeAlias = str
+
+__all__ = (
+    '__version__',
+    'full_version',
+    'git_revision',
+    'release',
+    'short_version',
+    'version',
+)
+
+version: Final[LiteralString]
+__version__: Final[LiteralString]
+full_version: Final[LiteralString]
+
+git_revision: Final[LiteralString]
+release: Final[bool]
+short_version: Final[LiteralString]
diff --git a/venv/lib/python3.12/site-packages/pip-24.2.dist-info/AUTHORS.txt b/venv/lib/python3.12/site-packages/pip-24.2.dist-info/AUTHORS.txt
new file mode 100644
index 00000000..dda2ac30
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip-24.2.dist-info/AUTHORS.txt
@@ -0,0 +1,796 @@
+@Switch01
+A_Rog
+Aakanksha Agrawal
+Abhinav Sagar
+ABHYUDAY PRATAP SINGH
+abs51295
+AceGentile
+Adam Chainz
+Adam Tse
+Adam Wentz
+admin
+Adolfo Ochagavía
+Adrien Morison
+Agus
+ahayrapetyan
+Ahilya
+AinsworthK
+Akash Srivastava
+Alan Yee
+Albert Tugushev
+Albert-Guan
+albertg
+Alberto Sottile
+Aleks Bunin
+Ales Erjavec
+Alethea Flowers
+Alex Gaynor
+Alex Grönholm
+Alex Hedges
+Alex Loosley
+Alex Morega
+Alex Stachowiak
+Alexander Shtyrov
+Alexandre Conrad
+Alexey Popravka
+Aleš Erjavec
+Alli
+Ami Fischman
+Ananya Maiti
+Anatoly Techtonik
+Anders Kaseorg
+Andre Aguiar
+Andreas Lutro
+Andrei Geacar
+Andrew Gaul
+Andrew Shymanel
+Andrey Bienkowski
+Andrey Bulgakov
+Andrés Delfino
+Andy Freeland
+Andy Kluger
+Ani Hayrapetyan
+Aniruddha Basak
+Anish Tambe
+Anrs Hu
+Anthony Sottile
+Antoine Musso
+Anton Ovchinnikov
+Anton Patrushev
+Antonio Alvarado Hernandez
+Antony Lee
+Antti Kaihola
+Anubhav Patel
+Anudit Nagar
+Anuj Godase
+AQNOUCH Mohammed
+AraHaan
+arena
+arenasys
+Arindam Choudhury
+Armin Ronacher
+Arnon Yaari
+Artem
+Arun Babu Neelicattu
+Ashley Manton
+Ashwin Ramaswami
+atse
+Atsushi Odagiri
+Avinash Karhana
+Avner Cohen
+Awit (Ah-Wit) Ghirmai
+Baptiste Mispelon
+Barney Gale
+barneygale
+Bartek Ogryczak
+Bastian Venthur
+Ben Bodenmiller
+Ben Darnell
+Ben Hoyt
+Ben Mares
+Ben Rosser
+Bence Nagy
+Benjamin Peterson
+Benjamin VanEvery
+Benoit Pierre
+Berker Peksag
+Bernard
+Bernard Tyers
+Bernardo B. Marques
+Bernhard M. Wiedemann
+Bertil Hatt
+Bhavam Vidyarthi
+Blazej Michalik
+Bogdan Opanchuk
+BorisZZZ
+Brad Erickson
+Bradley Ayers
+Branch Vincent
+Brandon L. Reiss
+Brandt Bucher
+Brannon Dorsey
+Brett Randall
+Brett Rosen
+Brian Cristante
+Brian Rosner
+briantracy
+BrownTruck
+Bruno Oliveira
+Bruno Renié
+Bruno S
+Bstrdsmkr
+Buck Golemon
+burrows
+Bussonnier Matthias
+bwoodsend
+c22
+Caleb Martinez
+Calvin Smith
+Carl Meyer
+Carlos Liam
+Carol Willing
+Carter Thayer
+Cass
+Chandrasekhar Atina
+Charlie Marsh
+Chih-Hsuan Yen
+Chris Brinker
+Chris Hunt
+Chris Jerdonek
+Chris Kuehl
+Chris Markiewicz
+Chris McDonough
+Chris Pawley
+Chris Pryer
+Chris Wolfe
+Christian Clauss
+Christian Heimes
+Christian Oudard
+Christoph Reiter
+Christopher Hunt
+Christopher Snyder
+chrysle
+cjc7373
+Clark Boylan
+Claudio Jolowicz
+Clay McClure
+Cody
+Cody Soyland
+Colin Watson
+Collin Anderson
+Connor Osborn
+Cooper Lees
+Cooper Ry Lees
+Cory Benfield
+Cory Wright
+Craig Kerstiens
+Cristian Sorinel
+Cristina
+Cristina Muñoz
+ctg123
+Curtis Doty
+cytolentino
+Daan De Meyer
+Dale
+Damian
+Damian Quiroga
+Damian Shaw
+Dan Black
+Dan Savilonis
+Dan Sully
+Dane Hillard
+daniel
+Daniel Collins
+Daniel Hahler
+Daniel Holth
+Daniel Jost
+Daniel Katz
+Daniel Shaulov
+Daniele Esposti
+Daniele Nicolodi
+Daniele Procida
+Daniil Konovalenko
+Danny Hermes
+Danny McClanahan
+Darren Kavanagh
+Dav Clark
+Dave Abrahams
+Dave Jones
+David Aguilar
+David Black
+David Bordeynik
+David Caro
+David D Lowe
+David Evans
+David Hewitt
+David Linke
+David Poggi
+David Poznik
+David Pursehouse
+David Runge
+David Tucker
+David Wales
+Davidovich
+ddelange
+Deepak Sharma
+Deepyaman Datta
+Denise Yu
+dependabot[bot]
+derwolfe
+Desetude
+Devesh Kumar Singh
+devsagul
+Diego Caraballo
+Diego Ramirez
+DiegoCaraballo
+Dimitri Merejkowsky
+Dimitri Papadopoulos
+Dirk Stolle
+Dmitry Gladkov
+Dmitry Volodin
+Domen Kožar
+Dominic Davis-Foster
+Donald Stufft
+Dongweiming
+doron zarhi
+Dos Moonen
+Douglas Thor
+DrFeathers
+Dustin Ingram
+Dustin Rodrigues
+Dwayne Bailey
+Ed Morley
+Edgar Ramírez
+Edgar Ramírez Mondragón
+Ee Durbin
+Efflam Lemaillet
+efflamlemaillet
+Eitan Adler
+ekristina
+elainechan
+Eli Schwartz
+Elisha Hollander
+Ellen Marie Dash
+Emil Burzo
+Emil Styrke
+Emmanuel Arias
+Endoh Takanao
+enoch
+Erdinc Mutlu
+Eric Cousineau
+Eric Gillingham
+Eric Hanchrow
+Eric Hopper
+Erik M. Bray
+Erik Rose
+Erwin Janssen
+Eugene Vereshchagin
+everdimension
+Federico
+Felipe Peter
+Felix Yan
+fiber-space
+Filip Kokosiński
+Filipe Laíns
+Finn Womack
+finnagin
+Flavio Amurrio
+Florian Briand
+Florian Rathgeber
+Francesco
+Francesco Montesano
+Fredrik Orderud
+Frost Ming
+Gabriel Curio
+Gabriel de Perthuis
+Garry Polley
+gavin
+gdanielson
+Geoffrey Sneddon
+George Song
+Georgi Valkov
+Georgy Pchelkin
+ghost
+Giftlin Rajaiah
+gizmoguy1
+gkdoc
+Godefroid Chapelle
+Gopinath M
+GOTO Hayato
+gousaiyang
+gpiks
+Greg Roodt
+Greg Ward
+Guilherme Espada
+Guillaume Seguin
+gutsytechster
+Guy Rozendorn
+Guy Tuval
+gzpan123
+Hanjun Kim
+Hari Charan
+Harsh Vardhan
+harupy
+Harutaka Kawamura
+hauntsaninja
+Henrich Hartzer
+Henry Schreiner
+Herbert Pfennig
+Holly Stotelmyer
+Honnix
+Hsiaoming Yang
+Hugo Lopes Tavares
+Hugo van Kemenade
+Hugues Bruant
+Hynek Schlawack
+Ian Bicking
+Ian Cordasco
+Ian Lee
+Ian Stapleton Cordasco
+Ian Wienand
+Igor Kuzmitshov
+Igor Sobreira
+Ikko Ashimine
+Ilan Schnell
+Illia Volochii
+Ilya Baryshev
+Inada Naoki
+Ionel Cristian Mărieș
+Ionel Maries Cristian
+Itamar Turner-Trauring
+Ivan Pozdeev
+J. Nick Koston
+Jacob Kim
+Jacob Walls
+Jaime Sanz
+jakirkham
+Jakub Kuczys
+Jakub Stasiak
+Jakub Vysoky
+Jakub Wilk
+James Cleveland
+James Curtin
+James Firth
+James Gerity
+James Polley
+Jan Pokorný
+Jannis Leidel
+Jarek Potiuk
+jarondl
+Jason Curtis
+Jason R. Coombs
+JasonMo
+JasonMo1
+Jay Graves
+Jean Abou Samra
+Jean-Christophe Fillion-Robin
+Jeff Barber
+Jeff Dairiki
+Jeff Widman
+Jelmer Vernooij
+jenix21
+Jeremy Fleischman
+Jeremy Stanley
+Jeremy Zafran
+Jesse Rittner
+Jiashuo Li
+Jim Fisher
+Jim Garrison
+Jinzhe Zeng
+Jiun Bae
+Jivan Amara
+Joe Bylund
+Joe Michelini
+John Paton
+John Sirois
+John T. Wodder II
+John-Scott Atlakson
+johnthagen
+Jon Banafato
+Jon Dufresne
+Jon Parise
+Jonas Nockert
+Jonathan Herbert
+Joonatan Partanen
+Joost Molenaar
+Jorge Niedbalski
+Joseph Bylund
+Joseph Long
+Josh Bronson
+Josh Cannon
+Josh Hansen
+Josh Schneier
+Joshua
+Juan Luis Cano Rodríguez
+Juanjo Bazán
+Judah Rand
+Julian Berman
+Julian Gethmann
+Julien Demoor
+Jussi Kukkonen
+jwg4
+Jyrki Pulliainen
+Kai Chen
+Kai Mueller
+Kamal Bin Mustafa
+kasium
+kaustav haldar
+keanemind
+Keith Maxwell
+Kelsey Hightower
+Kenneth Belitzky
+Kenneth Reitz
+Kevin Burke
+Kevin Carter
+Kevin Frommelt
+Kevin R Patterson
+Kexuan Sun
+Kit Randel
+Klaas van Schelven
+KOLANICH
+konstin
+kpinc
+Krishna Oza
+Kumar McMillan
+Kuntal Majumder
+Kurt McKee
+Kyle Persohn
+lakshmanaram
+Laszlo Kiss-Kollar
+Laurent Bristiel
+Laurent LAPORTE
+Laurie O
+Laurie Opperman
+layday
+Leon Sasson
+Lev Givon
+Lincoln de Sousa
+Lipis
+lorddavidiii
+Loren Carvalho
+Lucas Cimon
+Ludovic Gasc
+Luis Medel
+Lukas Geiger
+Lukas Juhrich
+Luke Macken
+Luo Jiebin
+luojiebin
+luz.paz
+László Kiss Kollár
+M00nL1ght
+Marc Abramowitz
+Marc Tamlyn
+Marcus Smith
+Mariatta
+Mark Kohler
+Mark McLoughlin
+Mark Williams
+Markus Hametner
+Martey Dodoo
+Martin Fischer
+Martin Häcker
+Martin Pavlasek
+Masaki
+Masklinn
+Matej Stuchlik
+Mathew Jennings
+Mathieu Bridon
+Mathieu Kniewallner
+Matt Bacchi
+Matt Good
+Matt Maker
+Matt Robenolt
+Matt Wozniski
+matthew
+Matthew Einhorn
+Matthew Feickert
+Matthew Gilliard
+Matthew Hughes
+Matthew Iversen
+Matthew Treinish
+Matthew Trumbell
+Matthew Willson
+Matthias Bussonnier
+mattip
+Maurits van Rees
+Max W Chase
+Maxim Kurnikov
+Maxime Rouyrre
+mayeut
+mbaluna
+mdebi
+memoselyk
+meowmeowcat
+Michael
+Michael Aquilina
+Michael E. Karpeles
+Michael Klich
+Michael Mintz
+Michael Williamson
+michaelpacer
+Michał Górny
+Mickaël Schoentgen
+Miguel Araujo Perez
+Mihir Singh
+Mike
+Mike Hendricks
+Min RK
+MinRK
+Miro Hrončok
+Monica Baluna
+montefra
+Monty Taylor
+morotti
+mrKazzila
+Muha Ajjan
+Nadav Wexler
+Nahuel Ambrosini
+Nate Coraor
+Nate Prewitt
+Nathan Houghton
+Nathaniel J. Smith
+Nehal J Wani
+Neil Botelho
+Nguyễn Gia Phong
+Nicholas Serra
+Nick Coghlan
+Nick Stenning
+Nick Timkovich
+Nicolas Bock
+Nicole Harris
+Nikhil Benesch
+Nikhil Ladha
+Nikita Chepanov
+Nikolay Korolev
+Nipunn Koorapati
+Nitesh Sharma
+Niyas Sait
+Noah
+Noah Gorny
+Nowell Strite
+NtaleGrey
+nvdv
+OBITORASU
+Ofek Lev
+ofrinevo
+Oliver Freund
+Oliver Jeeves
+Oliver Mannion
+Oliver Tonnhofer
+Olivier Girardot
+Olivier Grisel
+Ollie Rutherfurd
+OMOTO Kenji
+Omry Yadan
+onlinejudge95
+Oren Held
+Oscar Benjamin
+Oz N Tiram
+Pachwenko
+Patrick Dubroy
+Patrick Jenkins
+Patrick Lawson
+patricktokeeffe
+Patrik Kopkan
+Paul Ganssle
+Paul Kehrer
+Paul Moore
+Paul Nasrat
+Paul Oswald
+Paul van der Linden
+Paulus Schoutsen
+Pavel Safronov
+Pavithra Eswaramoorthy
+Pawel Jasinski
+Paweł Szramowski
+Pekka Klärck
+Peter Gessler
+Peter Lisák
+Peter Shen
+Peter Waller
+Petr Viktorin
+petr-tik
+Phaneendra Chiruvella
+Phil Elson
+Phil Freo
+Phil Pennock
+Phil Whelan
+Philip Jägenstedt
+Philip Molloy
+Philippe Ombredanne
+Pi Delport
+Pierre-Yves Rofes
+Pieter Degroote
+pip
+Prabakaran Kumaresshan
+Prabhjyotsing Surjit Singh Sodhi
+Prabhu Marappan
+Pradyun Gedam
+Prashant Sharma
+Pratik Mallya
+pre-commit-ci[bot]
+Preet Thakkar
+Preston Holmes
+Przemek Wrzos
+Pulkit Goyal
+q0w
+Qiangning Hong
+Qiming Xu
+Quentin Lee
+Quentin Pradet
+R. David Murray
+Rafael Caricio
+Ralf Schmitt
+Ran Benita
+Razzi Abuissa
+rdb
+Reece Dunham
+Remi Rampin
+Rene Dudfield
+Riccardo Magliocchetti
+Riccardo Schirone
+Richard Jones
+Richard Si
+Ricky Ng-Adam
+Rishi
+rmorotti
+RobberPhex
+Robert Collins
+Robert McGibbon
+Robert Pollak
+Robert T. McGibbon
+robin elisha robinson
+Roey Berman
+Rohan Jain
+Roman Bogorodskiy
+Roman Donchenko
+Romuald Brunet
+ronaudinho
+Ronny Pfannschmidt
+Rory McCann
+Ross Brattain
+Roy Wellington Ⅳ
+Ruairidh MacLeod
+Russell Keith-Magee
+Ryan Shepherd
+Ryan Wooden
+ryneeverett
+S. Guliaev
+Sachi King
+Salvatore Rinchiera
+sandeepkiran-js
+Sander Van Balen
+Savio Jomton
+schlamar
+Scott Kitterman
+Sean
+seanj
+Sebastian Jordan
+Sebastian Schaetz
+Segev Finer
+SeongSoo Cho
+Sergey Vasilyev
+Seth Michael Larson
+Seth Woodworth
+Shahar Epstein
+Shantanu
+shenxianpeng
+shireenrao
+Shivansh-007
+Shixian Sheng
+Shlomi Fish
+Shovan Maity
+Simeon Visser
+Simon Cross
+Simon Pichugin
+sinoroc
+sinscary
+snook92
+socketubs
+Sorin Sbarnea
+Srinivas Nyayapati
+Stavros Korokithakis
+Stefan Scherfke
+Stefano Rivera
+Stephan Erb
+Stephen Rosen
+stepshal
+Steve (Gadget) Barnes
+Steve Barnes
+Steve Dower
+Steve Kowalik
+Steven Myint
+Steven Silvester
+stonebig
+studioj
+Stéphane Bidoul
+Stéphane Bidoul (ACSONE)
+Stéphane Klein
+Sumana Harihareswara
+Surbhi Sharma
+Sviatoslav Sydorenko
+Sviatoslav Sydorenko (Святослав Сидоренко)
+Swat009
+Sylvain
+Takayuki SHIMIZUKAWA
+Taneli Hukkinen
+tbeswick
+Thiago
+Thijs Triemstra
+Thomas Fenzl
+Thomas Grainger
+Thomas Guettler
+Thomas Johansson
+Thomas Kluyver
+Thomas Smith
+Thomas VINCENT
+Tim D. Smith
+Tim Gates
+Tim Harder
+Tim Heap
+tim smith
+tinruufu
+Tobias Hermann
+Tom Forbes
+Tom Freudenheim
+Tom V
+Tomas Hrnciar
+Tomas Orsava
+Tomer Chachamu
+Tommi Enenkel | AnB
+Tomáš Hrnčiar
+Tony Beswick
+Tony Narlock
+Tony Zhaocheng Tan
+TonyBeswick
+toonarmycaptain
+Toshio Kuratomi
+toxinu
+Travis Swicegood
+Tushar Sadhwani
+Tzu-ping Chung
+Valentin Haenel
+Victor Stinner
+victorvpaulo
+Vikram - Google
+Viktor Szépe
+Ville Skyttä
+Vinay Sajip
+Vincent Philippon
+Vinicyus Macedo
+Vipul Kumar
+Vitaly Babiy
+Vladimir Fokow
+Vladimir Rutsky
+W. Trevor King
+Wil Tan
+Wilfred Hughes
+William Edwards
+William ML Leslie
+William T Olson
+William Woodruff
+Wilson Mo
+wim glenn
+Winson Luk
+Wolfgang Maier
+Wu Zhenyu
+XAMES3
+Xavier Fernandez
+Xianpeng Shen
+xoviat
+xtreak
+YAMAMOTO Takashi
+Yen Chi Hsuan
+Yeray Diaz Diaz
+Yoval P
+Yu Jian
+Yuan Jing Vincent Yan
+Yusuke Hayashi
+Zearin
+Zhiping Deng
+ziebam
+Zvezdan Petkovic
+Łukasz Langa
+Роман Донченко
+Семён Марьясин
diff --git a/venv/lib/python3.12/site-packages/pip-24.2.dist-info/INSTALLER b/venv/lib/python3.12/site-packages/pip-24.2.dist-info/INSTALLER
new file mode 100644
index 00000000..a1b589e3
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip-24.2.dist-info/INSTALLER
@@ -0,0 +1 @@
+pip
diff --git a/venv/lib/python3.12/site-packages/pip-24.2.dist-info/LICENSE.txt b/venv/lib/python3.12/site-packages/pip-24.2.dist-info/LICENSE.txt
new file mode 100644
index 00000000..8e7b65ea
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip-24.2.dist-info/LICENSE.txt
@@ -0,0 +1,20 @@
+Copyright (c) 2008-present The pip developers (see AUTHORS.txt file)
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/venv/lib/python3.12/site-packages/pip-24.2.dist-info/METADATA b/venv/lib/python3.12/site-packages/pip-24.2.dist-info/METADATA
new file mode 100644
index 00000000..6141107f
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip-24.2.dist-info/METADATA
@@ -0,0 +1,89 @@
+Metadata-Version: 2.1
+Name: pip
+Version: 24.2
+Summary: The PyPA recommended tool for installing Python packages.
+Author-email: The pip developers 
+License: MIT
+Project-URL: Homepage, https://pip.pypa.io/
+Project-URL: Documentation, https://pip.pypa.io
+Project-URL: Source, https://github.com/pypa/pip
+Project-URL: Changelog, https://pip.pypa.io/en/stable/news/
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Topic :: Software Development :: Build Tools
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Requires-Python: >=3.8
+Description-Content-Type: text/x-rst
+License-File: LICENSE.txt
+License-File: AUTHORS.txt
+
+pip - The Python Package Installer
+==================================
+
+.. |pypi-version| image:: https://img.shields.io/pypi/v/pip.svg
+   :target: https://pypi.org/project/pip/
+   :alt: PyPI
+
+.. |python-versions| image:: https://img.shields.io/pypi/pyversions/pip
+   :target: https://pypi.org/project/pip
+   :alt: PyPI - Python Version
+
+.. |docs-badge| image:: https://readthedocs.org/projects/pip/badge/?version=latest
+   :target: https://pip.pypa.io/en/latest
+   :alt: Documentation
+
+|pypi-version| |python-versions| |docs-badge|
+
+pip is the `package installer`_ for Python. You can use pip to install packages from the `Python Package Index`_ and other indexes.
+
+Please take a look at our documentation for how to install and use pip:
+
+* `Installation`_
+* `Usage`_
+
+We release updates regularly, with a new version every 3 months. Find more details in our documentation:
+
+* `Release notes`_
+* `Release process`_
+
+If you find bugs, need help, or want to talk to the developers, please use our mailing lists or chat rooms:
+
+* `Issue tracking`_
+* `Discourse channel`_
+* `User IRC`_
+
+If you want to get involved head over to GitHub to get the source code, look at our development documentation and feel free to jump on the developer mailing lists and chat rooms:
+
+* `GitHub page`_
+* `Development documentation`_
+* `Development IRC`_
+
+Code of Conduct
+---------------
+
+Everyone interacting in the pip project's codebases, issue trackers, chat
+rooms, and mailing lists is expected to follow the `PSF Code of Conduct`_.
+
+.. _package installer: https://packaging.python.org/guides/tool-recommendations/
+.. _Python Package Index: https://pypi.org
+.. _Installation: https://pip.pypa.io/en/stable/installation/
+.. _Usage: https://pip.pypa.io/en/stable/
+.. _Release notes: https://pip.pypa.io/en/stable/news.html
+.. _Release process: https://pip.pypa.io/en/latest/development/release-process/
+.. _GitHub page: https://github.com/pypa/pip
+.. _Development documentation: https://pip.pypa.io/en/latest/development
+.. _Issue tracking: https://github.com/pypa/pip/issues
+.. _Discourse channel: https://discuss.python.org/c/packaging
+.. _User IRC: https://kiwiirc.com/nextclient/#ircs://irc.libera.chat:+6697/pypa
+.. _Development IRC: https://kiwiirc.com/nextclient/#ircs://irc.libera.chat:+6697/pypa-dev
+.. _PSF Code of Conduct: https://github.com/pypa/.github/blob/main/CODE_OF_CONDUCT.md
diff --git a/venv/lib/python3.12/site-packages/pip-24.2.dist-info/RECORD b/venv/lib/python3.12/site-packages/pip-24.2.dist-info/RECORD
new file mode 100644
index 00000000..104634ae
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip-24.2.dist-info/RECORD
@@ -0,0 +1,853 @@
+../../../bin/pip,sha256=JVHHkdkka3or7-Z-f44wEm_OaoiDH-hfieQD3MVI1is,270
+../../../bin/pip3,sha256=JVHHkdkka3or7-Z-f44wEm_OaoiDH-hfieQD3MVI1is,270
+../../../bin/pip3.12,sha256=JVHHkdkka3or7-Z-f44wEm_OaoiDH-hfieQD3MVI1is,270
+pip-24.2.dist-info/AUTHORS.txt,sha256=KDa8Pd3GDeKSogF6yFW0l9A9eMneLDOFrcIDqkL8G8s,10868
+pip-24.2.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+pip-24.2.dist-info/LICENSE.txt,sha256=Y0MApmnUmurmWxLGxIySTFGkzfPR_whtw0VtyLyqIQQ,1093
+pip-24.2.dist-info/METADATA,sha256=PhzCxQxIhsnZ871cPUe3Hew9PhhpgflLbfqU3WizZqM,3624
+pip-24.2.dist-info/RECORD,,
+pip-24.2.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pip-24.2.dist-info/WHEEL,sha256=R0nc6qTxuoLk7ShA2_Y-UWkN8ZdfDBG2B6Eqpz2WXbs,91
+pip-24.2.dist-info/entry_points.txt,sha256=eeIjuzfnfR2PrhbjnbzFU6MnSS70kZLxwaHHq6M-bD0,87
+pip-24.2.dist-info/top_level.txt,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+pip/__init__.py,sha256=EQxEGXUQIu-9fNJxVEK74ufx_fTk_HpYV9lAbw-WWbs,355
+pip/__main__.py,sha256=WzbhHXTbSE6gBY19mNN9m4s5o_365LOvTYSgqgbdBhE,854
+pip/__pip-runner__.py,sha256=cPPWuJ6NK_k-GzfvlejLFgwzmYUROmpAR6QC3Q-vkXQ,1450
+pip/__pycache__/__init__.cpython-312.pyc,,
+pip/__pycache__/__main__.cpython-312.pyc,,
+pip/__pycache__/__pip-runner__.cpython-312.pyc,,
+pip/_internal/__init__.py,sha256=MfcoOluDZ8QMCFYal04IqOJ9q6m2V7a0aOsnI-WOxUo,513
+pip/_internal/__pycache__/__init__.cpython-312.pyc,,
+pip/_internal/__pycache__/build_env.cpython-312.pyc,,
+pip/_internal/__pycache__/cache.cpython-312.pyc,,
+pip/_internal/__pycache__/configuration.cpython-312.pyc,,
+pip/_internal/__pycache__/exceptions.cpython-312.pyc,,
+pip/_internal/__pycache__/main.cpython-312.pyc,,
+pip/_internal/__pycache__/pyproject.cpython-312.pyc,,
+pip/_internal/__pycache__/self_outdated_check.cpython-312.pyc,,
+pip/_internal/__pycache__/wheel_builder.cpython-312.pyc,,
+pip/_internal/build_env.py,sha256=QiusW8QEaj387y0hdRqVbuelHSHGYcT7WzVckbmMhR0,10420
+pip/_internal/cache.py,sha256=Jb698p5PNigRtpW5o26wQNkkUv4MnQ94mc471wL63A0,10369
+pip/_internal/cli/__init__.py,sha256=FkHBgpxxb-_gd6r1FjnNhfMOzAUYyXoXKJ6abijfcFU,132
+pip/_internal/cli/__pycache__/__init__.cpython-312.pyc,,
+pip/_internal/cli/__pycache__/autocompletion.cpython-312.pyc,,
+pip/_internal/cli/__pycache__/base_command.cpython-312.pyc,,
+pip/_internal/cli/__pycache__/cmdoptions.cpython-312.pyc,,
+pip/_internal/cli/__pycache__/command_context.cpython-312.pyc,,
+pip/_internal/cli/__pycache__/index_command.cpython-312.pyc,,
+pip/_internal/cli/__pycache__/main.cpython-312.pyc,,
+pip/_internal/cli/__pycache__/main_parser.cpython-312.pyc,,
+pip/_internal/cli/__pycache__/parser.cpython-312.pyc,,
+pip/_internal/cli/__pycache__/progress_bars.cpython-312.pyc,,
+pip/_internal/cli/__pycache__/req_command.cpython-312.pyc,,
+pip/_internal/cli/__pycache__/spinners.cpython-312.pyc,,
+pip/_internal/cli/__pycache__/status_codes.cpython-312.pyc,,
+pip/_internal/cli/autocompletion.py,sha256=Lli3Mr6aDNu7ZkJJFFvwD2-hFxNI6Avz8OwMyS5TVrs,6865
+pip/_internal/cli/base_command.py,sha256=F8nUcSM-Y-MQljJUe724-yxmc5viFXHyM_zH70NmIh4,8289
+pip/_internal/cli/cmdoptions.py,sha256=mDqBr0d0hoztbRJs-PWtcKpqNAc7khU6ZpoesZKocT8,30110
+pip/_internal/cli/command_context.py,sha256=RHgIPwtObh5KhMrd3YZTkl8zbVG-6Okml7YbFX4Ehg0,774
+pip/_internal/cli/index_command.py,sha256=YIJ84cfYcbDBACnB8eoDgqjYJU6GpiWP2Rh7Ij-Xyak,5633
+pip/_internal/cli/main.py,sha256=BDZef-bWe9g9Jpr4OVs4dDf-845HJsKw835T7AqEnAc,2817
+pip/_internal/cli/main_parser.py,sha256=laDpsuBDl6kyfywp9eMMA9s84jfH2TJJn-vmL0GG90w,4338
+pip/_internal/cli/parser.py,sha256=QAkY6s8N-AD7w5D2PQm2Y8C2MIJSv7iuAeNjOMvDBUA,10811
+pip/_internal/cli/progress_bars.py,sha256=0FAf7eN67KnIv_gZQhTWSnKXXUzQko1ftGXEoLe5Yec,2713
+pip/_internal/cli/req_command.py,sha256=DqeFhmUMs6o6Ev8qawAcOoYNdAZsfyKS0MZI5jsJYwQ,12250
+pip/_internal/cli/spinners.py,sha256=hIJ83GerdFgFCdobIA23Jggetegl_uC4Sp586nzFbPE,5118
+pip/_internal/cli/status_codes.py,sha256=sEFHUaUJbqv8iArL3HAtcztWZmGOFX01hTesSytDEh0,116
+pip/_internal/commands/__init__.py,sha256=5oRO9O3dM2vGuh0bFw4HOVletryrz5HHMmmPWwJrH9U,3882
+pip/_internal/commands/__pycache__/__init__.cpython-312.pyc,,
+pip/_internal/commands/__pycache__/cache.cpython-312.pyc,,
+pip/_internal/commands/__pycache__/check.cpython-312.pyc,,
+pip/_internal/commands/__pycache__/completion.cpython-312.pyc,,
+pip/_internal/commands/__pycache__/configuration.cpython-312.pyc,,
+pip/_internal/commands/__pycache__/debug.cpython-312.pyc,,
+pip/_internal/commands/__pycache__/download.cpython-312.pyc,,
+pip/_internal/commands/__pycache__/freeze.cpython-312.pyc,,
+pip/_internal/commands/__pycache__/hash.cpython-312.pyc,,
+pip/_internal/commands/__pycache__/help.cpython-312.pyc,,
+pip/_internal/commands/__pycache__/index.cpython-312.pyc,,
+pip/_internal/commands/__pycache__/inspect.cpython-312.pyc,,
+pip/_internal/commands/__pycache__/install.cpython-312.pyc,,
+pip/_internal/commands/__pycache__/list.cpython-312.pyc,,
+pip/_internal/commands/__pycache__/search.cpython-312.pyc,,
+pip/_internal/commands/__pycache__/show.cpython-312.pyc,,
+pip/_internal/commands/__pycache__/uninstall.cpython-312.pyc,,
+pip/_internal/commands/__pycache__/wheel.cpython-312.pyc,,
+pip/_internal/commands/cache.py,sha256=xg76_ZFEBC6zoQ3gXLRfMZJft4z2a0RwH4GEFZC6nnU,7944
+pip/_internal/commands/check.py,sha256=Hr_4eiMd9cgVDgEvjtIdw915NmL7ROIWW8enkr8slPQ,2268
+pip/_internal/commands/completion.py,sha256=HT4lD0bgsflHq2IDgYfiEdp7IGGtE7s6MgI3xn0VQEw,4287
+pip/_internal/commands/configuration.py,sha256=n98enwp6y0b5G6fiRQjaZo43FlJKYve_daMhN-4BRNc,9766
+pip/_internal/commands/debug.py,sha256=DNDRgE9YsKrbYzU0s3VKi8rHtKF4X13CJ_br_8PUXO0,6797
+pip/_internal/commands/download.py,sha256=0qB0nys6ZEPsog451lDsjL5Bx7Z97t-B80oFZKhpzKM,5273
+pip/_internal/commands/freeze.py,sha256=2Vt72BYTSm9rzue6d8dNzt8idxWK4Db6Hd-anq7GQ80,3203
+pip/_internal/commands/hash.py,sha256=EVVOuvGtoPEdFi8SNnmdqlCQrhCxV-kJsdwtdcCnXGQ,1703
+pip/_internal/commands/help.py,sha256=gcc6QDkcgHMOuAn5UxaZwAStsRBrnGSn_yxjS57JIoM,1132
+pip/_internal/commands/index.py,sha256=RAXxmJwFhVb5S1BYzb5ifX3sn9Na8v2CCVYwSMP8pao,4731
+pip/_internal/commands/inspect.py,sha256=PGrY9TRTRCM3y5Ml8Bdk8DEOXquWRfscr4DRo1LOTPc,3189
+pip/_internal/commands/install.py,sha256=iqesiLIZc6Op9uihMQFYRhAA2DQRZUxbM4z1BwXoFls,29428
+pip/_internal/commands/list.py,sha256=RgaIV4kN-eMSpgUAXc-6bjnURzl0v3cRE11xr54O9Cg,12771
+pip/_internal/commands/search.py,sha256=hSGtIHg26LRe468Ly7oZ6gfd9KbTxBRZAAtJc9Um6S4,5628
+pip/_internal/commands/show.py,sha256=IG9L5uo8w6UA4tI_IlmaxLCoNKPa5JNJCljj3NWs0OE,7507
+pip/_internal/commands/uninstall.py,sha256=7pOR7enK76gimyxQbzxcG1OsyLXL3DvX939xmM8Fvtg,3892
+pip/_internal/commands/wheel.py,sha256=eJRhr_qoNNxWAkkdJCNiQM7CXd4E1_YyQhsqJnBPGGg,6414
+pip/_internal/configuration.py,sha256=XkAiBS0hpzsM-LF0Qu5hvPWO_Bs67-oQKRYFBuMbESs,14006
+pip/_internal/distributions/__init__.py,sha256=Hq6kt6gXBgjNit5hTTWLAzeCNOKoB-N0pGYSqehrli8,858
+pip/_internal/distributions/__pycache__/__init__.cpython-312.pyc,,
+pip/_internal/distributions/__pycache__/base.cpython-312.pyc,,
+pip/_internal/distributions/__pycache__/installed.cpython-312.pyc,,
+pip/_internal/distributions/__pycache__/sdist.cpython-312.pyc,,
+pip/_internal/distributions/__pycache__/wheel.cpython-312.pyc,,
+pip/_internal/distributions/base.py,sha256=QeB9qvKXDIjLdPBDE5fMgpfGqMMCr-govnuoQnGuiF8,1783
+pip/_internal/distributions/installed.py,sha256=QinHFbWAQ8oE0pbD8MFZWkwlnfU1QYTccA1vnhrlYOU,842
+pip/_internal/distributions/sdist.py,sha256=PlcP4a6-R6c98XnOM-b6Lkb3rsvh9iG4ok8shaanrzs,6751
+pip/_internal/distributions/wheel.py,sha256=THBYfnv7VVt8mYhMYUtH13S1E7FDwtDyDfmUcl8ai0E,1317
+pip/_internal/exceptions.py,sha256=6qcW3QgmFVlRxlZvDSLUhSzKJ7_Tedo-lyqWA6NfdAU,25371
+pip/_internal/index/__init__.py,sha256=vpt-JeTZefh8a-FC22ZeBSXFVbuBcXSGiILhQZJaNpQ,30
+pip/_internal/index/__pycache__/__init__.cpython-312.pyc,,
+pip/_internal/index/__pycache__/collector.cpython-312.pyc,,
+pip/_internal/index/__pycache__/package_finder.cpython-312.pyc,,
+pip/_internal/index/__pycache__/sources.cpython-312.pyc,,
+pip/_internal/index/collector.py,sha256=RdPO0JLAlmyBWPAWYHPyRoGjz3GNAeTngCNkbGey_mE,16265
+pip/_internal/index/package_finder.py,sha256=yRC4xsyudwKnNoU6IXvNoyqYo5ScT7lB6Wa-z2eh7cs,37666
+pip/_internal/index/sources.py,sha256=dJegiR9f86kslaAHcv9-R5L_XBf5Rzm_FkyPteDuPxI,8688
+pip/_internal/locations/__init__.py,sha256=UaAxeZ_f93FyouuFf4p7SXYF-4WstXuEvd3LbmPCAno,14925
+pip/_internal/locations/__pycache__/__init__.cpython-312.pyc,,
+pip/_internal/locations/__pycache__/_distutils.cpython-312.pyc,,
+pip/_internal/locations/__pycache__/_sysconfig.cpython-312.pyc,,
+pip/_internal/locations/__pycache__/base.cpython-312.pyc,,
+pip/_internal/locations/_distutils.py,sha256=H9ZHK_35rdDV1Qsmi4QeaBULjFT4Mbu6QuoVGkJ6QHI,6009
+pip/_internal/locations/_sysconfig.py,sha256=IGzds60qsFneRogC-oeBaY7bEh3lPt_v47kMJChQXsU,7724
+pip/_internal/locations/base.py,sha256=RQiPi1d4FVM2Bxk04dQhXZ2PqkeljEL2fZZ9SYqIQ78,2556
+pip/_internal/main.py,sha256=r-UnUe8HLo5XFJz8inTcOOTiu_sxNhgHb6VwlGUllOI,340
+pip/_internal/metadata/__init__.py,sha256=9pU3W3s-6HtjFuYhWcLTYVmSaziklPv7k2x8p7X1GmA,4339
+pip/_internal/metadata/__pycache__/__init__.cpython-312.pyc,,
+pip/_internal/metadata/__pycache__/_json.cpython-312.pyc,,
+pip/_internal/metadata/__pycache__/base.cpython-312.pyc,,
+pip/_internal/metadata/__pycache__/pkg_resources.cpython-312.pyc,,
+pip/_internal/metadata/_json.py,sha256=P0cAJrH_mtmMZvlZ16ZXm_-izA4lpr5wy08laICuiaA,2644
+pip/_internal/metadata/base.py,sha256=ft0K5XNgI4ETqZnRv2-CtvgYiMOMAeGMAzxT-f6VLJA,25298
+pip/_internal/metadata/importlib/__init__.py,sha256=jUUidoxnHcfITHHaAWG1G2i5fdBYklv_uJcjo2x7VYE,135
+pip/_internal/metadata/importlib/__pycache__/__init__.cpython-312.pyc,,
+pip/_internal/metadata/importlib/__pycache__/_compat.cpython-312.pyc,,
+pip/_internal/metadata/importlib/__pycache__/_dists.cpython-312.pyc,,
+pip/_internal/metadata/importlib/__pycache__/_envs.cpython-312.pyc,,
+pip/_internal/metadata/importlib/_compat.py,sha256=c6av8sP8BBjAZuFSJow1iWfygUXNM3xRTCn5nqw6B9M,2796
+pip/_internal/metadata/importlib/_dists.py,sha256=anh0mLI-FYRPUhAdipd0Va3YJJc6HelCKQ0bFhY10a0,8017
+pip/_internal/metadata/importlib/_envs.py,sha256=JHjNfnk9RsjrcQw8dLBqdfBglOKSepEe9aq03B4nRpU,7431
+pip/_internal/metadata/pkg_resources.py,sha256=U07ETAINSGeSRBfWUG93E4tZZbaW_f7PGzEqZN0hulc,10542
+pip/_internal/models/__init__.py,sha256=3DHUd_qxpPozfzouoqa9g9ts1Czr5qaHfFxbnxriepM,63
+pip/_internal/models/__pycache__/__init__.cpython-312.pyc,,
+pip/_internal/models/__pycache__/candidate.cpython-312.pyc,,
+pip/_internal/models/__pycache__/direct_url.cpython-312.pyc,,
+pip/_internal/models/__pycache__/format_control.cpython-312.pyc,,
+pip/_internal/models/__pycache__/index.cpython-312.pyc,,
+pip/_internal/models/__pycache__/installation_report.cpython-312.pyc,,
+pip/_internal/models/__pycache__/link.cpython-312.pyc,,
+pip/_internal/models/__pycache__/scheme.cpython-312.pyc,,
+pip/_internal/models/__pycache__/search_scope.cpython-312.pyc,,
+pip/_internal/models/__pycache__/selection_prefs.cpython-312.pyc,,
+pip/_internal/models/__pycache__/target_python.cpython-312.pyc,,
+pip/_internal/models/__pycache__/wheel.cpython-312.pyc,,
+pip/_internal/models/candidate.py,sha256=zzgFRuw_kWPjKpGw7LC0ZUMD2CQ2EberUIYs8izjdCA,753
+pip/_internal/models/direct_url.py,sha256=uBtY2HHd3TO9cKQJWh0ThvE5FRr-MWRYChRU4IG9HZE,6578
+pip/_internal/models/format_control.py,sha256=wtsQqSK9HaUiNxQEuB-C62eVimw6G4_VQFxV9-_KDBE,2486
+pip/_internal/models/index.py,sha256=tYnL8oxGi4aSNWur0mG8DAP7rC6yuha_MwJO8xw0crI,1030
+pip/_internal/models/installation_report.py,sha256=zRVZoaz-2vsrezj_H3hLOhMZCK9c7TbzWgC-jOalD00,2818
+pip/_internal/models/link.py,sha256=jHax9O-9zlSzEwjBCDkx0OXjKXwBDwOuPwn-PsR8dCs,21034
+pip/_internal/models/scheme.py,sha256=PakmHJM3e8OOWSZFtfz1Az7f1meONJnkGuQxFlt3wBE,575
+pip/_internal/models/search_scope.py,sha256=67NEnsYY84784S-MM7ekQuo9KXLH-7MzFntXjapvAo0,4531
+pip/_internal/models/selection_prefs.py,sha256=qaFfDs3ciqoXPg6xx45N1jPLqccLJw4N0s4P0PyHTQ8,2015
+pip/_internal/models/target_python.py,sha256=2XaH2rZ5ZF-K5wcJbEMGEl7SqrTToDDNkrtQ2v_v_-Q,4271
+pip/_internal/models/wheel.py,sha256=Odc1NVWL5N-i6A3vFa50BfNvCRlGvGa4som60FQM198,3601
+pip/_internal/network/__init__.py,sha256=jf6Tt5nV_7zkARBrKojIXItgejvoegVJVKUbhAa5Ioc,50
+pip/_internal/network/__pycache__/__init__.cpython-312.pyc,,
+pip/_internal/network/__pycache__/auth.cpython-312.pyc,,
+pip/_internal/network/__pycache__/cache.cpython-312.pyc,,
+pip/_internal/network/__pycache__/download.cpython-312.pyc,,
+pip/_internal/network/__pycache__/lazy_wheel.cpython-312.pyc,,
+pip/_internal/network/__pycache__/session.cpython-312.pyc,,
+pip/_internal/network/__pycache__/utils.cpython-312.pyc,,
+pip/_internal/network/__pycache__/xmlrpc.cpython-312.pyc,,
+pip/_internal/network/auth.py,sha256=D4gASjUrqoDFlSt6gQ767KAAjv6PUyJU0puDlhXNVRE,20809
+pip/_internal/network/cache.py,sha256=48A971qCzKNFvkb57uGEk7-0xaqPS0HWj2711QNTxkU,3935
+pip/_internal/network/download.py,sha256=FLOP29dPYECBiAi7eEjvAbNkyzaKNqbyjOT2m8HPW8U,6048
+pip/_internal/network/lazy_wheel.py,sha256=2PXVduYZPCPZkkQFe1J1GbfHJWeCU--FXonGyIfw9eU,7638
+pip/_internal/network/session.py,sha256=XmanBKjVwPFmh1iJ58q6TDh9xabH37gREuQJ_feuZGA,18741
+pip/_internal/network/utils.py,sha256=Inaxel-NxBu4PQWkjyErdnfewsFCcgHph7dzR1-FboY,4088
+pip/_internal/network/xmlrpc.py,sha256=sAxzOacJ-N1NXGPvap9jC3zuYWSnnv3GXtgR2-E2APA,1838
+pip/_internal/operations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pip/_internal/operations/__pycache__/__init__.cpython-312.pyc,,
+pip/_internal/operations/__pycache__/check.cpython-312.pyc,,
+pip/_internal/operations/__pycache__/freeze.cpython-312.pyc,,
+pip/_internal/operations/__pycache__/prepare.cpython-312.pyc,,
+pip/_internal/operations/build/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pip/_internal/operations/build/__pycache__/__init__.cpython-312.pyc,,
+pip/_internal/operations/build/__pycache__/build_tracker.cpython-312.pyc,,
+pip/_internal/operations/build/__pycache__/metadata.cpython-312.pyc,,
+pip/_internal/operations/build/__pycache__/metadata_editable.cpython-312.pyc,,
+pip/_internal/operations/build/__pycache__/metadata_legacy.cpython-312.pyc,,
+pip/_internal/operations/build/__pycache__/wheel.cpython-312.pyc,,
+pip/_internal/operations/build/__pycache__/wheel_editable.cpython-312.pyc,,
+pip/_internal/operations/build/__pycache__/wheel_legacy.cpython-312.pyc,,
+pip/_internal/operations/build/build_tracker.py,sha256=-ARW_TcjHCOX7D2NUOGntB4Fgc6b4aolsXkAK6BWL7w,4774
+pip/_internal/operations/build/metadata.py,sha256=9S0CUD8U3QqZeXp-Zyt8HxwU90lE4QrnYDgrqZDzBnc,1422
+pip/_internal/operations/build/metadata_editable.py,sha256=VLL7LvntKE8qxdhUdEJhcotFzUsOSI8NNS043xULKew,1474
+pip/_internal/operations/build/metadata_legacy.py,sha256=8i6i1QZX9m_lKPStEFsHKM0MT4a-CD408JOw99daLmo,2190
+pip/_internal/operations/build/wheel.py,sha256=sT12FBLAxDC6wyrDorh8kvcZ1jG5qInCRWzzP-UkJiQ,1075
+pip/_internal/operations/build/wheel_editable.py,sha256=yOtoH6zpAkoKYEUtr8FhzrYnkNHQaQBjWQ2HYae1MQg,1417
+pip/_internal/operations/build/wheel_legacy.py,sha256=K-6kNhmj-1xDF45ny1yheMerF0ui4EoQCLzEoHh6-tc,3045
+pip/_internal/operations/check.py,sha256=L24vRL8VWbyywdoeAhM89WCd8zLTnjIbULlKelUgIec,5912
+pip/_internal/operations/freeze.py,sha256=V59yEyCSz_YhZuhH09-6aV_zvYBMrS_IxFFNqn2QzlA,9864
+pip/_internal/operations/install/__init__.py,sha256=mX7hyD2GNBO2mFGokDQ30r_GXv7Y_PLdtxcUv144e-s,51
+pip/_internal/operations/install/__pycache__/__init__.cpython-312.pyc,,
+pip/_internal/operations/install/__pycache__/editable_legacy.cpython-312.pyc,,
+pip/_internal/operations/install/__pycache__/wheel.cpython-312.pyc,,
+pip/_internal/operations/install/editable_legacy.py,sha256=PoEsNEPGbIZ2yQphPsmYTKLOCMs4gv5OcCdzW124NcA,1283
+pip/_internal/operations/install/wheel.py,sha256=X5Iz9yUg5LlK5VNQ9g2ikc6dcRu8EPi_SUi5iuEDRgo,27615
+pip/_internal/operations/prepare.py,sha256=joWJwPkuqGscQgVNImLK71e9hRapwKvRCM8HclysmvU,28118
+pip/_internal/pyproject.py,sha256=rw4fwlptDp1hZgYoplwbAGwWA32sWQkp7ysf8Ju6iXc,7287
+pip/_internal/req/__init__.py,sha256=HxBFtZy_BbCclLgr26waMtpzYdO5T3vxePvpGAXSt5s,2653
+pip/_internal/req/__pycache__/__init__.cpython-312.pyc,,
+pip/_internal/req/__pycache__/constructors.cpython-312.pyc,,
+pip/_internal/req/__pycache__/req_file.cpython-312.pyc,,
+pip/_internal/req/__pycache__/req_install.cpython-312.pyc,,
+pip/_internal/req/__pycache__/req_set.cpython-312.pyc,,
+pip/_internal/req/__pycache__/req_uninstall.cpython-312.pyc,,
+pip/_internal/req/constructors.py,sha256=qXNZtUqhsXpHxkRaIQhp20_Kz6I88MDKM8SQR9fckIc,18424
+pip/_internal/req/req_file.py,sha256=hnC9Oz-trqGQpuDnCVWqwpJkAvtbCsk7-5k0EWVQhlQ,17687
+pip/_internal/req/req_install.py,sha256=yhT98NGDoAEk03jznTJnYCznzhiMEEA2ocgsUG_dcNU,35788
+pip/_internal/req/req_set.py,sha256=j3esG0s6SzoVReX9rWn4rpYNtyET_fwxbwJPRimvRxo,2858
+pip/_internal/req/req_uninstall.py,sha256=qzDIxJo-OETWqGais7tSMCDcWbATYABT-Tid3ityF0s,23853
+pip/_internal/resolution/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pip/_internal/resolution/__pycache__/__init__.cpython-312.pyc,,
+pip/_internal/resolution/__pycache__/base.cpython-312.pyc,,
+pip/_internal/resolution/base.py,sha256=qlmh325SBVfvG6Me9gc5Nsh5sdwHBwzHBq6aEXtKsLA,583
+pip/_internal/resolution/legacy/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pip/_internal/resolution/legacy/__pycache__/__init__.cpython-312.pyc,,
+pip/_internal/resolution/legacy/__pycache__/resolver.cpython-312.pyc,,
+pip/_internal/resolution/legacy/resolver.py,sha256=3HZiJBRd1FTN6jQpI4qRO8-TbLYeIbUTS6PFvXnXs2w,24068
+pip/_internal/resolution/resolvelib/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pip/_internal/resolution/resolvelib/__pycache__/__init__.cpython-312.pyc,,
+pip/_internal/resolution/resolvelib/__pycache__/base.cpython-312.pyc,,
+pip/_internal/resolution/resolvelib/__pycache__/candidates.cpython-312.pyc,,
+pip/_internal/resolution/resolvelib/__pycache__/factory.cpython-312.pyc,,
+pip/_internal/resolution/resolvelib/__pycache__/found_candidates.cpython-312.pyc,,
+pip/_internal/resolution/resolvelib/__pycache__/provider.cpython-312.pyc,,
+pip/_internal/resolution/resolvelib/__pycache__/reporter.cpython-312.pyc,,
+pip/_internal/resolution/resolvelib/__pycache__/requirements.cpython-312.pyc,,
+pip/_internal/resolution/resolvelib/__pycache__/resolver.cpython-312.pyc,,
+pip/_internal/resolution/resolvelib/base.py,sha256=DCf669FsqyQY5uqXeePDHQY1e4QO-pBzWH8O0s9-K94,5023
+pip/_internal/resolution/resolvelib/candidates.py,sha256=07CBc85ya3J19XqdvUsLQwtVIxiTYq9km9hbTRh0jb0,19823
+pip/_internal/resolution/resolvelib/factory.py,sha256=mTTq_nG1F9Eq3VnlYPH6Ap-mydcS-mxC5y5L-CLLp80,32459
+pip/_internal/resolution/resolvelib/found_candidates.py,sha256=9hrTyQqFvl9I7Tji79F1AxHv39Qh1rkJ_7deSHSMfQc,6383
+pip/_internal/resolution/resolvelib/provider.py,sha256=bcsFnYvlmtB80cwVdW1fIwgol8ZNr1f1VHyRTkz47SM,9935
+pip/_internal/resolution/resolvelib/reporter.py,sha256=00JtoXEkTlw0-rl_sl54d71avwOsJHt9GGHcrj5Sza0,3168
+pip/_internal/resolution/resolvelib/requirements.py,sha256=7JG4Z72e5Yk4vU0S5ulGvbqTy4FMQGYhY5zQhX9zTtY,8065
+pip/_internal/resolution/resolvelib/resolver.py,sha256=nLJOsVMEVi2gQUVJoUFKMZAeu2f7GRMjGMvNSWyz0Bc,12592
+pip/_internal/self_outdated_check.py,sha256=pkjQixuWyQ1vrVxZAaYD6SSHgXuFUnHZybXEWTkh0S0,8145
+pip/_internal/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pip/_internal/utils/__pycache__/__init__.cpython-312.pyc,,
+pip/_internal/utils/__pycache__/_jaraco_text.cpython-312.pyc,,
+pip/_internal/utils/__pycache__/_log.cpython-312.pyc,,
+pip/_internal/utils/__pycache__/appdirs.cpython-312.pyc,,
+pip/_internal/utils/__pycache__/compat.cpython-312.pyc,,
+pip/_internal/utils/__pycache__/compatibility_tags.cpython-312.pyc,,
+pip/_internal/utils/__pycache__/datetime.cpython-312.pyc,,
+pip/_internal/utils/__pycache__/deprecation.cpython-312.pyc,,
+pip/_internal/utils/__pycache__/direct_url_helpers.cpython-312.pyc,,
+pip/_internal/utils/__pycache__/egg_link.cpython-312.pyc,,
+pip/_internal/utils/__pycache__/encoding.cpython-312.pyc,,
+pip/_internal/utils/__pycache__/entrypoints.cpython-312.pyc,,
+pip/_internal/utils/__pycache__/filesystem.cpython-312.pyc,,
+pip/_internal/utils/__pycache__/filetypes.cpython-312.pyc,,
+pip/_internal/utils/__pycache__/glibc.cpython-312.pyc,,
+pip/_internal/utils/__pycache__/hashes.cpython-312.pyc,,
+pip/_internal/utils/__pycache__/logging.cpython-312.pyc,,
+pip/_internal/utils/__pycache__/misc.cpython-312.pyc,,
+pip/_internal/utils/__pycache__/packaging.cpython-312.pyc,,
+pip/_internal/utils/__pycache__/retry.cpython-312.pyc,,
+pip/_internal/utils/__pycache__/setuptools_build.cpython-312.pyc,,
+pip/_internal/utils/__pycache__/subprocess.cpython-312.pyc,,
+pip/_internal/utils/__pycache__/temp_dir.cpython-312.pyc,,
+pip/_internal/utils/__pycache__/unpacking.cpython-312.pyc,,
+pip/_internal/utils/__pycache__/urls.cpython-312.pyc,,
+pip/_internal/utils/__pycache__/virtualenv.cpython-312.pyc,,
+pip/_internal/utils/__pycache__/wheel.cpython-312.pyc,,
+pip/_internal/utils/_jaraco_text.py,sha256=M15uUPIh5NpP1tdUGBxRau6q1ZAEtI8-XyLEETscFfE,3350
+pip/_internal/utils/_log.py,sha256=-jHLOE_THaZz5BFcCnoSL9EYAtJ0nXem49s9of4jvKw,1015
+pip/_internal/utils/appdirs.py,sha256=swgcTKOm3daLeXTW6v5BUS2Ti2RvEnGRQYH_yDXklAo,1665
+pip/_internal/utils/compat.py,sha256=ckkFveBiYQjRWjkNsajt_oWPS57tJvE8XxoC4OIYgCY,2399
+pip/_internal/utils/compatibility_tags.py,sha256=ydin8QG8BHqYRsPY4OL6cmb44CbqXl1T0xxS97VhHkk,5377
+pip/_internal/utils/datetime.py,sha256=m21Y3wAtQc-ji6Veb6k_M5g6A0ZyFI4egchTdnwh-pQ,242
+pip/_internal/utils/deprecation.py,sha256=k7Qg_UBAaaTdyq82YVARA6D7RmcGTXGv7fnfcgigj4Q,3707
+pip/_internal/utils/direct_url_helpers.py,sha256=r2MRtkVDACv9AGqYODBUC9CjwgtsUU1s68hmgfCJMtA,3196
+pip/_internal/utils/egg_link.py,sha256=0FePZoUYKv4RGQ2t6x7w5Z427wbA_Uo3WZnAkrgsuqo,2463
+pip/_internal/utils/encoding.py,sha256=qqsXDtiwMIjXMEiIVSaOjwH5YmirCaK-dIzb6-XJsL0,1169
+pip/_internal/utils/entrypoints.py,sha256=YlhLTRl2oHBAuqhc-zmL7USS67TPWVHImjeAQHreZTQ,3064
+pip/_internal/utils/filesystem.py,sha256=ajvA-q4ocliW9kPp8Yquh-4vssXbu-UKbo5FV9V4X64,4950
+pip/_internal/utils/filetypes.py,sha256=i8XAQ0eFCog26Fw9yV0Yb1ygAqKYB1w9Cz9n0fj8gZU,716
+pip/_internal/utils/glibc.py,sha256=vUkWq_1pJuzcYNcGKLlQmABoUiisK8noYY1yc8Wq4w4,3734
+pip/_internal/utils/hashes.py,sha256=XGGLL0AG8-RhWnyz87xF6MFZ--BKadHU35D47eApCKI,4972
+pip/_internal/utils/logging.py,sha256=7BFKB1uFjdxD5crM-GtwA5T2qjbQ2LPD-gJDuJeDNTg,11606
+pip/_internal/utils/misc.py,sha256=HR_V97vNTHNzwq01JrnTZtsLLkWAOJ9_EeYfHJZSgDY,23745
+pip/_internal/utils/packaging.py,sha256=iI3LH43lVNR4hWBOqF6lFsZq4aycb2j0UcHlmDmcqUg,2109
+pip/_internal/utils/retry.py,sha256=mhFbykXjhTnZfgzeuy-vl9c8nECnYn_CMtwNJX2tYzQ,1392
+pip/_internal/utils/setuptools_build.py,sha256=ouXpud-jeS8xPyTPsXJ-m34NPvK5os45otAzdSV_IJE,4435
+pip/_internal/utils/subprocess.py,sha256=EsvqSRiSMHF98T8Txmu6NLU3U--MpTTQjtNgKP0P--M,8988
+pip/_internal/utils/temp_dir.py,sha256=5qOXe8M4JeY6vaFQM867d5zkp1bSwMZ-KT5jymmP0Zg,9310
+pip/_internal/utils/unpacking.py,sha256=eyDkSsk4nW8ZfiSjNzJduCznpHyaGHVv3ak_LMGsiEM,11951
+pip/_internal/utils/urls.py,sha256=qceSOZb5lbNDrHNsv7_S4L4Ytszja5NwPKUMnZHbYnM,1599
+pip/_internal/utils/virtualenv.py,sha256=S6f7csYorRpiD6cvn3jISZYc3I8PJC43H5iMFpRAEDU,3456
+pip/_internal/utils/wheel.py,sha256=b442jkydFHjXzDy6cMR7MpzWBJ1Q82hR5F33cmcHV3g,4494
+pip/_internal/vcs/__init__.py,sha256=UAqvzpbi0VbZo3Ub6skEeZAw-ooIZR-zX_WpCbxyCoU,596
+pip/_internal/vcs/__pycache__/__init__.cpython-312.pyc,,
+pip/_internal/vcs/__pycache__/bazaar.cpython-312.pyc,,
+pip/_internal/vcs/__pycache__/git.cpython-312.pyc,,
+pip/_internal/vcs/__pycache__/mercurial.cpython-312.pyc,,
+pip/_internal/vcs/__pycache__/subversion.cpython-312.pyc,,
+pip/_internal/vcs/__pycache__/versioncontrol.cpython-312.pyc,,
+pip/_internal/vcs/bazaar.py,sha256=EKStcQaKpNu0NK4p5Q10Oc4xb3DUxFw024XrJy40bFQ,3528
+pip/_internal/vcs/git.py,sha256=3tpc9LQA_J4IVW5r5NvWaaSeDzcmJOrSFZN0J8vIKfU,18177
+pip/_internal/vcs/mercurial.py,sha256=oULOhzJ2Uie-06d1omkL-_Gc6meGaUkyogvqG9ZCyPs,5249
+pip/_internal/vcs/subversion.py,sha256=ddTugHBqHzV3ebKlU5QXHPN4gUqlyXbOx8q8NgXKvs8,11735
+pip/_internal/vcs/versioncontrol.py,sha256=cvf_-hnTAjQLXJ3d17FMNhQfcO1AcKWUF10tfrYyP-c,22440
+pip/_internal/wheel_builder.py,sha256=DL3A8LKeRj_ACp11WS5wSgASgPFqeyAeXJKdXfmaWXU,11799
+pip/_vendor/__init__.py,sha256=JYuAXvClhInxIrA2FTp5p-uuWVL7WV6-vEpTs46-Qh4,4873
+pip/_vendor/__pycache__/__init__.cpython-312.pyc,,
+pip/_vendor/__pycache__/typing_extensions.cpython-312.pyc,,
+pip/_vendor/cachecontrol/__init__.py,sha256=GiYoagwPEiJ_xR_lbwWGaoCiPtF_rz4isjfjdDAgHU4,676
+pip/_vendor/cachecontrol/__pycache__/__init__.cpython-312.pyc,,
+pip/_vendor/cachecontrol/__pycache__/_cmd.cpython-312.pyc,,
+pip/_vendor/cachecontrol/__pycache__/adapter.cpython-312.pyc,,
+pip/_vendor/cachecontrol/__pycache__/cache.cpython-312.pyc,,
+pip/_vendor/cachecontrol/__pycache__/controller.cpython-312.pyc,,
+pip/_vendor/cachecontrol/__pycache__/filewrapper.cpython-312.pyc,,
+pip/_vendor/cachecontrol/__pycache__/heuristics.cpython-312.pyc,,
+pip/_vendor/cachecontrol/__pycache__/serialize.cpython-312.pyc,,
+pip/_vendor/cachecontrol/__pycache__/wrapper.cpython-312.pyc,,
+pip/_vendor/cachecontrol/_cmd.py,sha256=iist2EpzJvDVIhMAxXq8iFnTBsiZAd6iplxfmNboNyk,1737
+pip/_vendor/cachecontrol/adapter.py,sha256=fByO_Pd_EOemjWbuocvBWdN85xT0q_TBm2lxS6vD4fk,6355
+pip/_vendor/cachecontrol/cache.py,sha256=OTQj72tUf8C1uEgczdl3Gc8vkldSzsTITKtDGKMx4z8,1952
+pip/_vendor/cachecontrol/caches/__init__.py,sha256=dtrrroK5BnADR1GWjCZ19aZ0tFsMfvFBtLQQU1sp_ag,303
+pip/_vendor/cachecontrol/caches/__pycache__/__init__.cpython-312.pyc,,
+pip/_vendor/cachecontrol/caches/__pycache__/file_cache.cpython-312.pyc,,
+pip/_vendor/cachecontrol/caches/__pycache__/redis_cache.cpython-312.pyc,,
+pip/_vendor/cachecontrol/caches/file_cache.py,sha256=9AlmmTJc6cslb6k5z_6q0sGPHVrMj8zv-uWy-simmfE,5406
+pip/_vendor/cachecontrol/caches/redis_cache.py,sha256=9rmqwtYu_ljVkW6_oLqbC7EaX_a8YT_yLuna-eS0dgo,1386
+pip/_vendor/cachecontrol/controller.py,sha256=o-ejGJlBmpKK8QQLyTPJj0t7siU8XVHXuV8MCybCxQ8,18575
+pip/_vendor/cachecontrol/filewrapper.py,sha256=STttGmIPBvZzt2b51dUOwoWX5crcMCpKZOisM3f5BNc,4292
+pip/_vendor/cachecontrol/heuristics.py,sha256=IYe4QmHERWsMvtxNrp920WeaIsaTTyqLB14DSheSbtY,4834
+pip/_vendor/cachecontrol/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pip/_vendor/cachecontrol/serialize.py,sha256=HQd2IllQ05HzPkVLMXTF2uX5mjEQjDBkxCqUJUODpZk,5163
+pip/_vendor/cachecontrol/wrapper.py,sha256=hsGc7g8QGQTT-4f8tgz3AM5qwScg6FO0BSdLSRdEvpU,1417
+pip/_vendor/certifi/__init__.py,sha256=LHXz7E80YJYBzCBv6ZyidQ5-ciYSkSebpY2E5OM0l7o,94
+pip/_vendor/certifi/__main__.py,sha256=1k3Cr95vCxxGRGDljrW3wMdpZdL3Nhf0u1n-k2qdsCY,255
+pip/_vendor/certifi/__pycache__/__init__.cpython-312.pyc,,
+pip/_vendor/certifi/__pycache__/__main__.cpython-312.pyc,,
+pip/_vendor/certifi/__pycache__/core.cpython-312.pyc,,
+pip/_vendor/certifi/cacert.pem,sha256=SIupYGAr8HzGP073rsEIaS_sQYIPwzKKjj894DgUmu4,291528
+pip/_vendor/certifi/core.py,sha256=2SRT5rIcQChFDbe37BQa-kULxAgJ8qN6l1jfqTp4HIs,4486
+pip/_vendor/certifi/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pip/_vendor/distlib/__init__.py,sha256=hJKF7FHoqbmGckncDuEINWo_OYkDNiHODtYXSMcvjcc,625
+pip/_vendor/distlib/__pycache__/__init__.cpython-312.pyc,,
+pip/_vendor/distlib/__pycache__/compat.cpython-312.pyc,,
+pip/_vendor/distlib/__pycache__/database.cpython-312.pyc,,
+pip/_vendor/distlib/__pycache__/index.cpython-312.pyc,,
+pip/_vendor/distlib/__pycache__/locators.cpython-312.pyc,,
+pip/_vendor/distlib/__pycache__/manifest.cpython-312.pyc,,
+pip/_vendor/distlib/__pycache__/markers.cpython-312.pyc,,
+pip/_vendor/distlib/__pycache__/metadata.cpython-312.pyc,,
+pip/_vendor/distlib/__pycache__/resources.cpython-312.pyc,,
+pip/_vendor/distlib/__pycache__/scripts.cpython-312.pyc,,
+pip/_vendor/distlib/__pycache__/util.cpython-312.pyc,,
+pip/_vendor/distlib/__pycache__/version.cpython-312.pyc,,
+pip/_vendor/distlib/__pycache__/wheel.cpython-312.pyc,,
+pip/_vendor/distlib/compat.py,sha256=Un-uIBvy02w-D267OG4VEhuddqWgKj9nNkxVltAb75w,41487
+pip/_vendor/distlib/database.py,sha256=0V9Qvs0Vrxa2F_-hLWitIyVyRifJ0pCxyOI-kEOBwsA,51965
+pip/_vendor/distlib/index.py,sha256=lTbw268rRhj8dw1sib3VZ_0EhSGgoJO3FKJzSFMOaeA,20797
+pip/_vendor/distlib/locators.py,sha256=o1r_M86_bRLafSpetmyfX8KRtFu-_Q58abvQrnOSnbA,51767
+pip/_vendor/distlib/manifest.py,sha256=3qfmAmVwxRqU1o23AlfXrQGZzh6g_GGzTAP_Hb9C5zQ,14168
+pip/_vendor/distlib/markers.py,sha256=n3DfOh1yvZ_8EW7atMyoYeZFXjYla0Nz0itQlojCd0A,5268
+pip/_vendor/distlib/metadata.py,sha256=pB9WZ9mBfmQxc9OVIldLS5CjOoQRvKAvUwwQyKwKQtQ,39693
+pip/_vendor/distlib/resources.py,sha256=LwbPksc0A1JMbi6XnuPdMBUn83X7BPuFNWqPGEKI698,10820
+pip/_vendor/distlib/scripts.py,sha256=8_gP9J7_tlNRicnWmPX4ZiDlP5wTwJKDeeg-8_qXUZU,18780
+pip/_vendor/distlib/t32.exe,sha256=a0GV5kCoWsMutvliiCKmIgV98eRZ33wXoS-XrqvJQVs,97792
+pip/_vendor/distlib/t64-arm.exe,sha256=68TAa32V504xVBnufojh0PcenpR3U4wAqTqf-MZqbPw,182784
+pip/_vendor/distlib/t64.exe,sha256=gaYY8hy4fbkHYTTnA4i26ct8IQZzkBG2pRdy0iyuBrc,108032
+pip/_vendor/distlib/util.py,sha256=XSznxEi_i3T20UJuaVc0qXHz5ksGUCW1khYlBprN_QE,67530
+pip/_vendor/distlib/version.py,sha256=9pXkduchve_aN7JG6iL9VTYV_kqNSGoc2Dwl8JuySnQ,23747
+pip/_vendor/distlib/w32.exe,sha256=R4csx3-OGM9kL4aPIzQKRo5TfmRSHZo6QWyLhDhNBks,91648
+pip/_vendor/distlib/w64-arm.exe,sha256=xdyYhKj0WDcVUOCb05blQYvzdYIKMbmJn2SZvzkcey4,168448
+pip/_vendor/distlib/w64.exe,sha256=ejGf-rojoBfXseGLpya6bFTFPWRG21X5KvU8J5iU-K0,101888
+pip/_vendor/distlib/wheel.py,sha256=FVQCve8u-L0QYk5-YTZc7s4WmNQdvjRWTK08KXzZVX4,43958
+pip/_vendor/distro/__init__.py,sha256=2fHjF-SfgPvjyNZ1iHh_wjqWdR_Yo5ODHwZC0jLBPhc,981
+pip/_vendor/distro/__main__.py,sha256=bu9d3TifoKciZFcqRBuygV3GSuThnVD_m2IK4cz96Vs,64
+pip/_vendor/distro/__pycache__/__init__.cpython-312.pyc,,
+pip/_vendor/distro/__pycache__/__main__.cpython-312.pyc,,
+pip/_vendor/distro/__pycache__/distro.cpython-312.pyc,,
+pip/_vendor/distro/distro.py,sha256=XqbefacAhDT4zr_trnbA15eY8vdK4GTghgmvUGrEM_4,49430
+pip/_vendor/distro/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pip/_vendor/idna/__init__.py,sha256=KJQN1eQBr8iIK5SKrJ47lXvxG0BJ7Lm38W4zT0v_8lk,849
+pip/_vendor/idna/__pycache__/__init__.cpython-312.pyc,,
+pip/_vendor/idna/__pycache__/codec.cpython-312.pyc,,
+pip/_vendor/idna/__pycache__/compat.cpython-312.pyc,,
+pip/_vendor/idna/__pycache__/core.cpython-312.pyc,,
+pip/_vendor/idna/__pycache__/idnadata.cpython-312.pyc,,
+pip/_vendor/idna/__pycache__/intranges.cpython-312.pyc,,
+pip/_vendor/idna/__pycache__/package_data.cpython-312.pyc,,
+pip/_vendor/idna/__pycache__/uts46data.cpython-312.pyc,,
+pip/_vendor/idna/codec.py,sha256=PS6m-XmdST7Wj7J7ulRMakPDt5EBJyYrT3CPtjh-7t4,3426
+pip/_vendor/idna/compat.py,sha256=0_sOEUMT4CVw9doD3vyRhX80X19PwqFoUBs7gWsFME4,321
+pip/_vendor/idna/core.py,sha256=lyhpoe2vulEaB_65xhXmoKgO-xUqFDvcwxu5hpNNO4E,12663
+pip/_vendor/idna/idnadata.py,sha256=dqRwytzkjIHMBa2R1lYvHDwACenZPt8eGVu1Y8UBE-E,78320
+pip/_vendor/idna/intranges.py,sha256=YBr4fRYuWH7kTKS2tXlFjM24ZF1Pdvcir-aywniInqg,1881
+pip/_vendor/idna/package_data.py,sha256=Tkt0KnIeyIlnHddOaz9WSkkislNgokJAuE-p5GorMqo,21
+pip/_vendor/idna/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pip/_vendor/idna/uts46data.py,sha256=1KuksWqLuccPXm2uyRVkhfiFLNIhM_H2m4azCcnOqEU,206503
+pip/_vendor/msgpack/__init__.py,sha256=gsMP7JTECZNUSjvOyIbdhNOkpB9Z8BcGwabVGY2UcdQ,1077
+pip/_vendor/msgpack/__pycache__/__init__.cpython-312.pyc,,
+pip/_vendor/msgpack/__pycache__/exceptions.cpython-312.pyc,,
+pip/_vendor/msgpack/__pycache__/ext.cpython-312.pyc,,
+pip/_vendor/msgpack/__pycache__/fallback.cpython-312.pyc,,
+pip/_vendor/msgpack/exceptions.py,sha256=dCTWei8dpkrMsQDcjQk74ATl9HsIBH0ybt8zOPNqMYc,1081
+pip/_vendor/msgpack/ext.py,sha256=fKp00BqDLjUtZnPd70Llr138zk8JsCuSpJkkZ5S4dt8,5629
+pip/_vendor/msgpack/fallback.py,sha256=wdUWJkWX2gzfRW9BBCTOuIE1Wvrf5PtBtR8ZtY7G_EE,33175
+pip/_vendor/packaging/__init__.py,sha256=dtw2bNmWCQ9WnMoK3bk_elL1svSlikXtLpZhCFIB9SE,496
+pip/_vendor/packaging/__pycache__/__init__.cpython-312.pyc,,
+pip/_vendor/packaging/__pycache__/_elffile.cpython-312.pyc,,
+pip/_vendor/packaging/__pycache__/_manylinux.cpython-312.pyc,,
+pip/_vendor/packaging/__pycache__/_musllinux.cpython-312.pyc,,
+pip/_vendor/packaging/__pycache__/_parser.cpython-312.pyc,,
+pip/_vendor/packaging/__pycache__/_structures.cpython-312.pyc,,
+pip/_vendor/packaging/__pycache__/_tokenizer.cpython-312.pyc,,
+pip/_vendor/packaging/__pycache__/markers.cpython-312.pyc,,
+pip/_vendor/packaging/__pycache__/metadata.cpython-312.pyc,,
+pip/_vendor/packaging/__pycache__/requirements.cpython-312.pyc,,
+pip/_vendor/packaging/__pycache__/specifiers.cpython-312.pyc,,
+pip/_vendor/packaging/__pycache__/tags.cpython-312.pyc,,
+pip/_vendor/packaging/__pycache__/utils.cpython-312.pyc,,
+pip/_vendor/packaging/__pycache__/version.cpython-312.pyc,,
+pip/_vendor/packaging/_elffile.py,sha256=_LcJW4YNKywYsl4169B2ukKRqwxjxst_8H0FRVQKlz8,3282
+pip/_vendor/packaging/_manylinux.py,sha256=Xo4V0PZz8sbuVCbTni0t1CR0AHeir_7ib4lTmV8scD4,9586
+pip/_vendor/packaging/_musllinux.py,sha256=p9ZqNYiOItGee8KcZFeHF_YcdhVwGHdK6r-8lgixvGQ,2694
+pip/_vendor/packaging/_parser.py,sha256=s_TvTvDNK0NrM2QB3VKThdWFM4Nc0P6JnkObkl3MjpM,10236
+pip/_vendor/packaging/_structures.py,sha256=q3eVNmbWJGG_S0Dit_S3Ao8qQqz_5PYTXFAKBZe5yr4,1431
+pip/_vendor/packaging/_tokenizer.py,sha256=J6v5H7Jzvb-g81xp_2QACKwO7LxHQA6ikryMU7zXwN8,5273
+pip/_vendor/packaging/markers.py,sha256=dWKSqn5Sp-jDmOG-W3GfLHKjwhf1IsznbT71VlBoB5M,10671
+pip/_vendor/packaging/metadata.py,sha256=KINuSkJ12u-SyoKNTy_pHNGAfMUtxNvZ53qA1zAKcKI,32349
+pip/_vendor/packaging/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pip/_vendor/packaging/requirements.py,sha256=gYyRSAdbrIyKDY66ugIDUQjRMvxkH2ALioTmX3tnL6o,2947
+pip/_vendor/packaging/specifiers.py,sha256=HfGgfNJRvrzC759gnnoojHyiWs_DYmcw5PEh5jHH-YE,39738
+pip/_vendor/packaging/tags.py,sha256=y8EbheOu9WS7s-MebaXMcHMF-jzsA_C1Lz5XRTiSy4w,18883
+pip/_vendor/packaging/utils.py,sha256=NAdYUwnlAOpkat_RthavX8a07YuVxgGL_vwrx73GSDM,5287
+pip/_vendor/packaging/version.py,sha256=wE4sSVlF-d1H6HFC1vszEe35CwTig_fh4HHIFg95hFE,16210
+pip/_vendor/pkg_resources/__init__.py,sha256=jrhDRbOubP74QuPXxd7U7Po42PH2l-LZ2XfcO7llpZ4,124463
+pip/_vendor/pkg_resources/__pycache__/__init__.cpython-312.pyc,,
+pip/_vendor/platformdirs/__init__.py,sha256=FTA6LGNm40GwNZt3gG3uLAacWvf2E_2HTmH0rAALGR8,22285
+pip/_vendor/platformdirs/__main__.py,sha256=jBJ8zb7Mpx5ebcqF83xrpO94MaeCpNGHVf9cvDN2JLg,1505
+pip/_vendor/platformdirs/__pycache__/__init__.cpython-312.pyc,,
+pip/_vendor/platformdirs/__pycache__/__main__.cpython-312.pyc,,
+pip/_vendor/platformdirs/__pycache__/android.cpython-312.pyc,,
+pip/_vendor/platformdirs/__pycache__/api.cpython-312.pyc,,
+pip/_vendor/platformdirs/__pycache__/macos.cpython-312.pyc,,
+pip/_vendor/platformdirs/__pycache__/unix.cpython-312.pyc,,
+pip/_vendor/platformdirs/__pycache__/version.cpython-312.pyc,,
+pip/_vendor/platformdirs/__pycache__/windows.cpython-312.pyc,,
+pip/_vendor/platformdirs/android.py,sha256=xZXY9Jd46WOsxT2U6-5HsNtDZ-IQqxcEUrBLl3hYk4o,9016
+pip/_vendor/platformdirs/api.py,sha256=QBYdUac2eC521ek_y53uD1Dcq-lJX8IgSRVd4InC6uc,8996
+pip/_vendor/platformdirs/macos.py,sha256=wftsbsvq6nZ0WORXSiCrZNkRHz_WKuktl0a6mC7MFkI,5580
+pip/_vendor/platformdirs/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pip/_vendor/platformdirs/unix.py,sha256=Cci9Wqt35dAMsg6HT9nRGHSBW5obb0pR3AE1JJnsCXg,10643
+pip/_vendor/platformdirs/version.py,sha256=r7F76tZRjgQKzrpx_I0_ZMQOMU-PS7eGnHD7zEK3KB0,411
+pip/_vendor/platformdirs/windows.py,sha256=IFpiohUBwxPtCzlyKwNtxyW4Jk8haa6W8o59mfrDXVo,10125
+pip/_vendor/pygments/__init__.py,sha256=7N1oiaWulw_nCsTY4EEixYLz15pWY5u4uPAFFi-ielU,2983
+pip/_vendor/pygments/__main__.py,sha256=isIhBxLg65nLlXukG4VkMuPfNdd7gFzTZ_R_z3Q8diY,353
+pip/_vendor/pygments/__pycache__/__init__.cpython-312.pyc,,
+pip/_vendor/pygments/__pycache__/__main__.cpython-312.pyc,,
+pip/_vendor/pygments/__pycache__/cmdline.cpython-312.pyc,,
+pip/_vendor/pygments/__pycache__/console.cpython-312.pyc,,
+pip/_vendor/pygments/__pycache__/filter.cpython-312.pyc,,
+pip/_vendor/pygments/__pycache__/formatter.cpython-312.pyc,,
+pip/_vendor/pygments/__pycache__/lexer.cpython-312.pyc,,
+pip/_vendor/pygments/__pycache__/modeline.cpython-312.pyc,,
+pip/_vendor/pygments/__pycache__/plugin.cpython-312.pyc,,
+pip/_vendor/pygments/__pycache__/regexopt.cpython-312.pyc,,
+pip/_vendor/pygments/__pycache__/scanner.cpython-312.pyc,,
+pip/_vendor/pygments/__pycache__/sphinxext.cpython-312.pyc,,
+pip/_vendor/pygments/__pycache__/style.cpython-312.pyc,,
+pip/_vendor/pygments/__pycache__/token.cpython-312.pyc,,
+pip/_vendor/pygments/__pycache__/unistring.cpython-312.pyc,,
+pip/_vendor/pygments/__pycache__/util.cpython-312.pyc,,
+pip/_vendor/pygments/cmdline.py,sha256=LIVzmAunlk9sRJJp54O4KRy9GDIN4Wu13v9p9QzfGPM,23656
+pip/_vendor/pygments/console.py,sha256=yhP9UsLAVmWKVQf2446JJewkA7AiXeeTf4Ieg3Oi2fU,1718
+pip/_vendor/pygments/filter.py,sha256=_ADNPCskD8_GmodHi6_LoVgPU3Zh336aBCT5cOeTMs0,1910
+pip/_vendor/pygments/filters/__init__.py,sha256=RdedK2KWKXlKwR7cvkfr3NUj9YiZQgMgilRMFUg2jPA,40392
+pip/_vendor/pygments/filters/__pycache__/__init__.cpython-312.pyc,,
+pip/_vendor/pygments/formatter.py,sha256=jDWBTndlBH2Z5IYZFVDnP0qn1CaTQjTWt7iAGtCnJEg,4390
+pip/_vendor/pygments/formatters/__init__.py,sha256=8No-NUs8rBTSSBJIv4hSEQt2M0cFB4hwAT0snVc2QGE,5385
+pip/_vendor/pygments/formatters/__pycache__/__init__.cpython-312.pyc,,
+pip/_vendor/pygments/formatters/__pycache__/_mapping.cpython-312.pyc,,
+pip/_vendor/pygments/formatters/__pycache__/bbcode.cpython-312.pyc,,
+pip/_vendor/pygments/formatters/__pycache__/groff.cpython-312.pyc,,
+pip/_vendor/pygments/formatters/__pycache__/html.cpython-312.pyc,,
+pip/_vendor/pygments/formatters/__pycache__/img.cpython-312.pyc,,
+pip/_vendor/pygments/formatters/__pycache__/irc.cpython-312.pyc,,
+pip/_vendor/pygments/formatters/__pycache__/latex.cpython-312.pyc,,
+pip/_vendor/pygments/formatters/__pycache__/other.cpython-312.pyc,,
+pip/_vendor/pygments/formatters/__pycache__/pangomarkup.cpython-312.pyc,,
+pip/_vendor/pygments/formatters/__pycache__/rtf.cpython-312.pyc,,
+pip/_vendor/pygments/formatters/__pycache__/svg.cpython-312.pyc,,
+pip/_vendor/pygments/formatters/__pycache__/terminal.cpython-312.pyc,,
+pip/_vendor/pygments/formatters/__pycache__/terminal256.cpython-312.pyc,,
+pip/_vendor/pygments/formatters/_mapping.py,sha256=1Cw37FuQlNacnxRKmtlPX4nyLoX9_ttko5ZwscNUZZ4,4176
+pip/_vendor/pygments/formatters/bbcode.py,sha256=3JQLI45tcrQ_kRUMjuab6C7Hb0XUsbVWqqbSn9cMjkI,3320
+pip/_vendor/pygments/formatters/groff.py,sha256=M39k0PaSSZRnxWjqBSVPkF0mu1-Vr7bm6RsFvs-CNN4,5106
+pip/_vendor/pygments/formatters/html.py,sha256=SE2jc3YCqbMS3rZW9EAmDlAUhdVxJ52gA4dileEvCGU,35669
+pip/_vendor/pygments/formatters/img.py,sha256=MwA4xWPLOwh6j7Yc6oHzjuqSPt0M1fh5r-5BTIIUfsU,23287
+pip/_vendor/pygments/formatters/irc.py,sha256=dp1Z0l_ObJ5NFh9MhqLGg5ptG5hgJqedT2Vkutt9v0M,4981
+pip/_vendor/pygments/formatters/latex.py,sha256=XMmhOCqUKDBQtG5mGJNAFYxApqaC5puo5cMmPfK3944,19306
+pip/_vendor/pygments/formatters/other.py,sha256=56PMJOliin-rAUdnRM0i1wsV1GdUPd_dvQq0_UPfF9c,5034
+pip/_vendor/pygments/formatters/pangomarkup.py,sha256=y16U00aVYYEFpeCfGXlYBSMacG425CbfoG8oKbKegIg,2218
+pip/_vendor/pygments/formatters/rtf.py,sha256=ZT90dmcKyJboIB0mArhL7IhE467GXRN0G7QAUgG03To,11957
+pip/_vendor/pygments/formatters/svg.py,sha256=KKsiophPupHuxm0So-MsbQEWOT54IAiSF7hZPmxtKXE,7174
+pip/_vendor/pygments/formatters/terminal.py,sha256=AojNG4MlKq2L6IsC_VnXHu4AbHCBn9Otog6u45XvxeI,4674
+pip/_vendor/pygments/formatters/terminal256.py,sha256=kGkNUVo3FpwjytIDS0if79EuUoroAprcWt3igrcIqT0,11753
+pip/_vendor/pygments/lexer.py,sha256=TYHDt___gNW4axTl2zvPZff-VQi8fPaIh5OKRcVSjUM,35349
+pip/_vendor/pygments/lexers/__init__.py,sha256=pIlxyQJuu_syh9lE080cq8ceVbEVcKp0osAFU5fawJU,12115
+pip/_vendor/pygments/lexers/__pycache__/__init__.cpython-312.pyc,,
+pip/_vendor/pygments/lexers/__pycache__/_mapping.cpython-312.pyc,,
+pip/_vendor/pygments/lexers/__pycache__/python.cpython-312.pyc,,
+pip/_vendor/pygments/lexers/_mapping.py,sha256=61-h3zr103m01OS5BUq_AfUiL9YI06Ves9ipQ7k4vr4,76097
+pip/_vendor/pygments/lexers/python.py,sha256=2J_YJrPTr_A6fJY_qKiKv0GpgPwHMrlMSeo59qN3fe4,53687
+pip/_vendor/pygments/modeline.py,sha256=gtRYZBS-CKOCDXHhGZqApboHBaZwGH8gznN3O6nuxj4,1005
+pip/_vendor/pygments/plugin.py,sha256=ioeJ3QeoJ-UQhZpY9JL7vbxsTVuwwM7BCu-Jb8nN0AU,1891
+pip/_vendor/pygments/regexopt.py,sha256=Hky4EB13rIXEHQUNkwmCrYqtIlnXDehNR3MztafZ43w,3072
+pip/_vendor/pygments/scanner.py,sha256=NDy3ofK_fHRFK4hIDvxpamG871aewqcsIb6sgTi7Fhk,3092
+pip/_vendor/pygments/sphinxext.py,sha256=iOptJBcqOGPwMEJ2p70PvwpZPIGdvdZ8dxvq6kzxDgA,7981
+pip/_vendor/pygments/style.py,sha256=rSCZWFpg1_DwFMXDU0nEVmAcBHpuQGf9RxvOPPQvKLQ,6420
+pip/_vendor/pygments/styles/__init__.py,sha256=qUk6_1z5KmT8EdJFZYgESmG6P_HJF_2vVrDD7HSCGYY,2042
+pip/_vendor/pygments/styles/__pycache__/__init__.cpython-312.pyc,,
+pip/_vendor/pygments/styles/__pycache__/_mapping.cpython-312.pyc,,
+pip/_vendor/pygments/styles/_mapping.py,sha256=6lovFUE29tz6EsV3XYY4hgozJ7q1JL7cfO3UOlgnS8w,3312
+pip/_vendor/pygments/token.py,sha256=qZwT7LSPy5YBY3JgDjut642CCy7JdQzAfmqD9NmT5j0,6226
+pip/_vendor/pygments/unistring.py,sha256=p5c1i-HhoIhWemy9CUsaN9o39oomYHNxXll0Xfw6tEA,63208
+pip/_vendor/pygments/util.py,sha256=2tj2nS1X9_OpcuSjf8dOET2bDVZhs8cEKd_uT6-Fgg8,10031
+pip/_vendor/pyproject_hooks/__init__.py,sha256=kCehmy0UaBa9oVMD7ZIZrnswfnP3LXZ5lvnNJAL5JBM,491
+pip/_vendor/pyproject_hooks/__pycache__/__init__.cpython-312.pyc,,
+pip/_vendor/pyproject_hooks/__pycache__/_compat.cpython-312.pyc,,
+pip/_vendor/pyproject_hooks/__pycache__/_impl.cpython-312.pyc,,
+pip/_vendor/pyproject_hooks/_compat.py,sha256=by6evrYnqkisiM-MQcvOKs5bgDMzlOSgZqRHNqf04zE,138
+pip/_vendor/pyproject_hooks/_impl.py,sha256=61GJxzQip0IInhuO69ZI5GbNQ82XEDUB_1Gg5_KtUoc,11920
+pip/_vendor/pyproject_hooks/_in_process/__init__.py,sha256=9gQATptbFkelkIy0OfWFEACzqxXJMQDWCH9rBOAZVwQ,546
+pip/_vendor/pyproject_hooks/_in_process/__pycache__/__init__.cpython-312.pyc,,
+pip/_vendor/pyproject_hooks/_in_process/__pycache__/_in_process.cpython-312.pyc,,
+pip/_vendor/pyproject_hooks/_in_process/_in_process.py,sha256=m2b34c917IW5o-Q_6TYIHlsK9lSUlNiyrITTUH_zwew,10927
+pip/_vendor/requests/__init__.py,sha256=HlB_HzhrzGtfD_aaYUwUh1zWXLZ75_YCLyit75d0Vz8,5057
+pip/_vendor/requests/__pycache__/__init__.cpython-312.pyc,,
+pip/_vendor/requests/__pycache__/__version__.cpython-312.pyc,,
+pip/_vendor/requests/__pycache__/_internal_utils.cpython-312.pyc,,
+pip/_vendor/requests/__pycache__/adapters.cpython-312.pyc,,
+pip/_vendor/requests/__pycache__/api.cpython-312.pyc,,
+pip/_vendor/requests/__pycache__/auth.cpython-312.pyc,,
+pip/_vendor/requests/__pycache__/certs.cpython-312.pyc,,
+pip/_vendor/requests/__pycache__/compat.cpython-312.pyc,,
+pip/_vendor/requests/__pycache__/cookies.cpython-312.pyc,,
+pip/_vendor/requests/__pycache__/exceptions.cpython-312.pyc,,
+pip/_vendor/requests/__pycache__/help.cpython-312.pyc,,
+pip/_vendor/requests/__pycache__/hooks.cpython-312.pyc,,
+pip/_vendor/requests/__pycache__/models.cpython-312.pyc,,
+pip/_vendor/requests/__pycache__/packages.cpython-312.pyc,,
+pip/_vendor/requests/__pycache__/sessions.cpython-312.pyc,,
+pip/_vendor/requests/__pycache__/status_codes.cpython-312.pyc,,
+pip/_vendor/requests/__pycache__/structures.cpython-312.pyc,,
+pip/_vendor/requests/__pycache__/utils.cpython-312.pyc,,
+pip/_vendor/requests/__version__.py,sha256=FVfglgZmNQnmYPXpOohDU58F5EUb_-VnSTaAesS187g,435
+pip/_vendor/requests/_internal_utils.py,sha256=nMQymr4hs32TqVo5AbCrmcJEhvPUh7xXlluyqwslLiQ,1495
+pip/_vendor/requests/adapters.py,sha256=J7VeVxKBvawbtlX2DERVo05J9BXTcWYLMHNd1Baa-bk,27607
+pip/_vendor/requests/api.py,sha256=_Zb9Oa7tzVIizTKwFrPjDEY9ejtm_OnSRERnADxGsQs,6449
+pip/_vendor/requests/auth.py,sha256=kF75tqnLctZ9Mf_hm9TZIj4cQWnN5uxRz8oWsx5wmR0,10186
+pip/_vendor/requests/certs.py,sha256=PVPooB0jP5hkZEULSCwC074532UFbR2Ptgu0I5zwmCs,575
+pip/_vendor/requests/compat.py,sha256=Mo9f9xZpefod8Zm-n9_StJcVTmwSukXR2p3IQyyVXvU,1485
+pip/_vendor/requests/cookies.py,sha256=bNi-iqEj4NPZ00-ob-rHvzkvObzN3lEpgw3g6paS3Xw,18590
+pip/_vendor/requests/exceptions.py,sha256=D1wqzYWne1mS2rU43tP9CeN1G7QAy7eqL9o1god6Ejw,4272
+pip/_vendor/requests/help.py,sha256=hRKaf9u0G7fdwrqMHtF3oG16RKktRf6KiwtSq2Fo1_0,3813
+pip/_vendor/requests/hooks.py,sha256=CiuysiHA39V5UfcCBXFIx83IrDpuwfN9RcTUgv28ftQ,733
+pip/_vendor/requests/models.py,sha256=x4K4CmH-lC0l2Kb-iPfMN4dRXxHEcbOaEWBL_i09AwI,35483
+pip/_vendor/requests/packages.py,sha256=_ZQDCJTJ8SP3kVWunSqBsRZNPzj2c1WFVqbdr08pz3U,1057
+pip/_vendor/requests/sessions.py,sha256=ykTI8UWGSltOfH07HKollH7kTBGw4WhiBVaQGmckTw4,30495
+pip/_vendor/requests/status_codes.py,sha256=iJUAeA25baTdw-6PfD0eF4qhpINDJRJI-yaMqxs4LEI,4322
+pip/_vendor/requests/structures.py,sha256=-IbmhVz06S-5aPSZuUthZ6-6D9XOjRuTXHOabY041XM,2912
+pip/_vendor/requests/utils.py,sha256=L79vnFbzJ3SFLKtJwpoWe41Tozi3RlZv94pY1TFIyow,33631
+pip/_vendor/resolvelib/__init__.py,sha256=h509TdEcpb5-44JonaU3ex2TM15GVBLjM9CNCPwnTTs,537
+pip/_vendor/resolvelib/__pycache__/__init__.cpython-312.pyc,,
+pip/_vendor/resolvelib/__pycache__/providers.cpython-312.pyc,,
+pip/_vendor/resolvelib/__pycache__/reporters.cpython-312.pyc,,
+pip/_vendor/resolvelib/__pycache__/resolvers.cpython-312.pyc,,
+pip/_vendor/resolvelib/__pycache__/structs.cpython-312.pyc,,
+pip/_vendor/resolvelib/compat/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pip/_vendor/resolvelib/compat/__pycache__/__init__.cpython-312.pyc,,
+pip/_vendor/resolvelib/compat/__pycache__/collections_abc.cpython-312.pyc,,
+pip/_vendor/resolvelib/compat/collections_abc.py,sha256=uy8xUZ-NDEw916tugUXm8HgwCGiMO0f-RcdnpkfXfOs,156
+pip/_vendor/resolvelib/providers.py,sha256=fuuvVrCetu5gsxPB43ERyjfO8aReS3rFQHpDgiItbs4,5871
+pip/_vendor/resolvelib/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pip/_vendor/resolvelib/reporters.py,sha256=TSbRmWzTc26w0ggsV1bxVpeWDB8QNIre6twYl7GIZBE,1601
+pip/_vendor/resolvelib/resolvers.py,sha256=G8rsLZSq64g5VmIq-lB7UcIJ1gjAxIQJmTF4REZleQ0,20511
+pip/_vendor/resolvelib/structs.py,sha256=0_1_XO8z_CLhegP3Vpf9VJ3zJcfLm0NOHRM-i0Ykz3o,4963
+pip/_vendor/rich/__init__.py,sha256=dRxjIL-SbFVY0q3IjSMrfgBTHrm1LZDgLOygVBwiYZc,6090
+pip/_vendor/rich/__main__.py,sha256=eO7Cq8JnrgG8zVoeImiAs92q3hXNMIfp0w5lMsO7Q2Y,8477
+pip/_vendor/rich/__pycache__/__init__.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/__main__.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/_cell_widths.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/_emoji_codes.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/_emoji_replace.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/_export_format.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/_extension.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/_fileno.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/_inspect.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/_log_render.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/_loop.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/_null_file.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/_palettes.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/_pick.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/_ratio.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/_spinners.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/_stack.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/_timer.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/_win32_console.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/_windows.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/_windows_renderer.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/_wrap.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/abc.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/align.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/ansi.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/bar.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/box.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/cells.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/color.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/color_triplet.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/columns.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/console.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/constrain.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/containers.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/control.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/default_styles.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/diagnose.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/emoji.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/errors.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/file_proxy.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/filesize.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/highlighter.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/json.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/jupyter.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/layout.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/live.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/live_render.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/logging.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/markup.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/measure.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/padding.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/pager.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/palette.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/panel.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/pretty.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/progress.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/progress_bar.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/prompt.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/protocol.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/region.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/repr.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/rule.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/scope.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/screen.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/segment.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/spinner.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/status.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/style.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/styled.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/syntax.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/table.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/terminal_theme.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/text.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/theme.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/themes.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/traceback.cpython-312.pyc,,
+pip/_vendor/rich/__pycache__/tree.cpython-312.pyc,,
+pip/_vendor/rich/_cell_widths.py,sha256=fbmeyetEdHjzE_Vx2l1uK7tnPOhMs2X1lJfO3vsKDpA,10209
+pip/_vendor/rich/_emoji_codes.py,sha256=hu1VL9nbVdppJrVoijVshRlcRRe_v3dju3Mmd2sKZdY,140235
+pip/_vendor/rich/_emoji_replace.py,sha256=n-kcetsEUx2ZUmhQrfeMNc-teeGhpuSQ5F8VPBsyvDo,1064
+pip/_vendor/rich/_export_format.py,sha256=RI08pSrm5tBSzPMvnbTqbD9WIalaOoN5d4M1RTmLq1Y,2128
+pip/_vendor/rich/_extension.py,sha256=Xt47QacCKwYruzjDi-gOBq724JReDj9Cm9xUi5fr-34,265
+pip/_vendor/rich/_fileno.py,sha256=HWZxP5C2ajMbHryvAQZseflVfQoGzsKOHzKGsLD8ynQ,799
+pip/_vendor/rich/_inspect.py,sha256=oZJGw31e64dwXSCmrDnvZbwVb1ZKhWfU8wI3VWohjJk,9695
+pip/_vendor/rich/_log_render.py,sha256=1ByI0PA1ZpxZY3CGJOK54hjlq4X-Bz_boIjIqCd8Kns,3225
+pip/_vendor/rich/_loop.py,sha256=hV_6CLdoPm0va22Wpw4zKqM0RYsz3TZxXj0PoS-9eDQ,1236
+pip/_vendor/rich/_null_file.py,sha256=tGSXk_v-IZmbj1GAzHit8A3kYIQMiCpVsCFfsC-_KJ4,1387
+pip/_vendor/rich/_palettes.py,sha256=cdev1JQKZ0JvlguV9ipHgznTdnvlIzUFDBb0It2PzjI,7063
+pip/_vendor/rich/_pick.py,sha256=evDt8QN4lF5CiwrUIXlOJCntitBCOsI3ZLPEIAVRLJU,423
+pip/_vendor/rich/_ratio.py,sha256=Zt58apszI6hAAcXPpgdWKpu3c31UBWebOeR4mbyptvU,5471
+pip/_vendor/rich/_spinners.py,sha256=U2r1_g_1zSjsjiUdAESc2iAMc3i4ri_S8PYP6kQ5z1I,19919
+pip/_vendor/rich/_stack.py,sha256=-C8OK7rxn3sIUdVwxZBBpeHhIzX0eI-VM3MemYfaXm0,351
+pip/_vendor/rich/_timer.py,sha256=zelxbT6oPFZnNrwWPpc1ktUeAT-Vc4fuFcRZLQGLtMI,417
+pip/_vendor/rich/_win32_console.py,sha256=P0vxI2fcndym1UU1S37XAzQzQnkyY7YqAKmxm24_gug,22820
+pip/_vendor/rich/_windows.py,sha256=aBwaD_S56SbgopIvayVmpk0Y28uwY2C5Bab1wl3Bp-I,1925
+pip/_vendor/rich/_windows_renderer.py,sha256=t74ZL3xuDCP3nmTp9pH1L5LiI2cakJuQRQleHCJerlk,2783
+pip/_vendor/rich/_wrap.py,sha256=FlSsom5EX0LVkA3KWy34yHnCfLtqX-ZIepXKh-70rpc,3404
+pip/_vendor/rich/abc.py,sha256=ON-E-ZqSSheZ88VrKX2M3PXpFbGEUUZPMa_Af0l-4f0,890
+pip/_vendor/rich/align.py,sha256=sCUkisXkQfoq-IQPyBELfJ8l7LihZJX3HbH8K7Cie-M,10368
+pip/_vendor/rich/ansi.py,sha256=iD6532QYqnBm6hADulKjrV8l8kFJ-9fEVooHJHH3hMg,6906
+pip/_vendor/rich/bar.py,sha256=ldbVHOzKJOnflVNuv1xS7g6dLX2E3wMnXkdPbpzJTcs,3263
+pip/_vendor/rich/box.py,sha256=nr5fYIUghB_iUCEq6y0Z3LlCT8gFPDrzN9u2kn7tJl4,10831
+pip/_vendor/rich/cells.py,sha256=aMmGK4BjXhgE6_JF1ZEGmW3O7mKkE8g84vUnj4Et4To,4780
+pip/_vendor/rich/color.py,sha256=bCRATVdRe5IClJ6Hl62de2PKQ_U4i2MZ4ugjUEg7Tao,18223
+pip/_vendor/rich/color_triplet.py,sha256=3lhQkdJbvWPoLDO-AnYImAWmJvV5dlgYNCVZ97ORaN4,1054
+pip/_vendor/rich/columns.py,sha256=HUX0KcMm9dsKNi11fTbiM_h2iDtl8ySCaVcxlalEzq8,7131
+pip/_vendor/rich/console.py,sha256=deFZIubq2M9A2MCsKFAsFQlWDvcOMsGuUA07QkOaHIw,99173
+pip/_vendor/rich/constrain.py,sha256=1VIPuC8AgtKWrcncQrjBdYqA3JVWysu6jZo1rrh7c7Q,1288
+pip/_vendor/rich/containers.py,sha256=c_56TxcedGYqDepHBMTuZdUIijitAQgnox-Qde0Z1qo,5502
+pip/_vendor/rich/control.py,sha256=DSkHTUQLorfSERAKE_oTAEUFefZnZp4bQb4q8rHbKws,6630
+pip/_vendor/rich/default_styles.py,sha256=-Fe318kMVI_IwciK5POpThcO0-9DYJ67TZAN6DlmlmM,8082
+pip/_vendor/rich/diagnose.py,sha256=an6uouwhKPAlvQhYpNNpGq9EJysfMIOvvCbO3oSoR24,972
+pip/_vendor/rich/emoji.py,sha256=omTF9asaAnsM4yLY94eR_9dgRRSm1lHUszX20D1yYCQ,2501
+pip/_vendor/rich/errors.py,sha256=5pP3Kc5d4QJ_c0KFsxrfyhjiPVe7J1zOqSFbFAzcV-Y,642
+pip/_vendor/rich/file_proxy.py,sha256=Tl9THMDZ-Pk5Wm8sI1gGg_U5DhusmxD-FZ0fUbcU0W0,1683
+pip/_vendor/rich/filesize.py,sha256=9fTLAPCAwHmBXdRv7KZU194jSgNrRb6Wx7RIoBgqeKY,2508
+pip/_vendor/rich/highlighter.py,sha256=6ZAjUcNhBRajBCo9umFUclyi2xL0-55JL7S0vYGUJu4,9585
+pip/_vendor/rich/json.py,sha256=vVEoKdawoJRjAFayPwXkMBPLy7RSTs-f44wSQDR2nJ0,5031
+pip/_vendor/rich/jupyter.py,sha256=QyoKoE_8IdCbrtiSHp9TsTSNyTHY0FO5whE7jOTd9UE,3252
+pip/_vendor/rich/layout.py,sha256=ajkSFAtEVv9EFTcFs-w4uZfft7nEXhNzL7ZVdgrT5rI,14004
+pip/_vendor/rich/live.py,sha256=vUcnJV2LMSK3sQNaILbm0-_B8BpAeiHfcQMAMLfpRe0,14271
+pip/_vendor/rich/live_render.py,sha256=zJtB471jGziBtEwxc54x12wEQtH4BuQr1SA8v9kU82w,3666
+pip/_vendor/rich/logging.py,sha256=uB-cB-3Q4bmXDLLpbOWkmFviw-Fde39zyMV6tKJ2WHQ,11903
+pip/_vendor/rich/markup.py,sha256=3euGKP5s41NCQwaSjTnJxus5iZMHjxpIM0W6fCxra38,8451
+pip/_vendor/rich/measure.py,sha256=HmrIJX8sWRTHbgh8MxEay_83VkqNW_70s8aKP5ZcYI8,5305
+pip/_vendor/rich/padding.py,sha256=kTFGsdGe0os7tXLnHKpwTI90CXEvrceeZGCshmJy5zw,4970
+pip/_vendor/rich/pager.py,sha256=SO_ETBFKbg3n_AgOzXm41Sv36YxXAyI3_R-KOY2_uSc,828
+pip/_vendor/rich/palette.py,sha256=lInvR1ODDT2f3UZMfL1grq7dY_pDdKHw4bdUgOGaM4Y,3396
+pip/_vendor/rich/panel.py,sha256=2Fd1V7e1kHxlPFIusoHY5T7-Cs0RpkrihgVG9ZVqJ4g,10705
+pip/_vendor/rich/pretty.py,sha256=5oIHP_CGWnHEnD0zMdW5qfGC5kHqIKn7zH_eC4crULE,35848
+pip/_vendor/rich/progress.py,sha256=P02xi7T2Ua3qq17o83bkshe4c0v_45cg8VyTj6US6Vg,59715
+pip/_vendor/rich/progress_bar.py,sha256=L4jw8E6Qb_x-jhOrLVhkuMaPmiAhFIl8jHQbWFrKuR8,8164
+pip/_vendor/rich/prompt.py,sha256=wdOn2X8XTJKnLnlw6PoMY7xG4iUPp3ezt4O5gqvpV-E,11304
+pip/_vendor/rich/protocol.py,sha256=5hHHDDNHckdk8iWH5zEbi-zuIVSF5hbU2jIo47R7lTE,1391
+pip/_vendor/rich/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pip/_vendor/rich/region.py,sha256=rNT9xZrVZTYIXZC0NYn41CJQwYNbR-KecPOxTgQvB8Y,166
+pip/_vendor/rich/repr.py,sha256=5MZJZmONgC6kud-QW-_m1okXwL2aR6u6y-pUcUCJz28,4431
+pip/_vendor/rich/rule.py,sha256=0fNaS_aERa3UMRc3T5WMpN_sumtDxfaor2y3of1ftBk,4602
+pip/_vendor/rich/scope.py,sha256=TMUU8qo17thyqQCPqjDLYpg_UU1k5qVd-WwiJvnJVas,2843
+pip/_vendor/rich/screen.py,sha256=YoeReESUhx74grqb0mSSb9lghhysWmFHYhsbMVQjXO8,1591
+pip/_vendor/rich/segment.py,sha256=hU1ueeXqI6YeFa08K9DAjlF2QLxcJY9pwZx7RsXavlk,24246
+pip/_vendor/rich/spinner.py,sha256=15koCmF0DQeD8-k28Lpt6X_zJQUlzEhgo_6A6uy47lc,4339
+pip/_vendor/rich/status.py,sha256=kkPph3YeAZBo-X-4wPp8gTqZyU466NLwZBA4PZTTewo,4424
+pip/_vendor/rich/style.py,sha256=3hiocH_4N8vwRm3-8yFWzM7tSwjjEven69XqWasSQwM,27073
+pip/_vendor/rich/styled.py,sha256=eZNnzGrI4ki_54pgY3Oj0T-x3lxdXTYh4_ryDB24wBU,1258
+pip/_vendor/rich/syntax.py,sha256=TnZDuOD4DeHFbkaVEAji1gf8qgAlMU9Boe_GksMGCkk,35475
+pip/_vendor/rich/table.py,sha256=nGEvAZHF4dy1vT9h9Gj9O5qhSQO3ODAxJv0RY1vnIB8,39680
+pip/_vendor/rich/terminal_theme.py,sha256=1j5-ufJfnvlAo5Qsi_ACZiXDmwMXzqgmFByObT9-yJY,3370
+pip/_vendor/rich/text.py,sha256=5rQ3zvNrg5UZKNLecbh7fiw9v3HeFulNVtRY_CBDjjE,47312
+pip/_vendor/rich/theme.py,sha256=belFJogzA0W0HysQabKaHOc3RWH2ko3fQAJhoN-AFdo,3777
+pip/_vendor/rich/themes.py,sha256=0xgTLozfabebYtcJtDdC5QkX5IVUEaviqDUJJh4YVFk,102
+pip/_vendor/rich/traceback.py,sha256=CUpxYLjQWIb6vQQ6O72X0hvDV6caryGqU6UweHgOyCY,29601
+pip/_vendor/rich/tree.py,sha256=meAOUU6sYnoBEOX2ILrPLY9k5bWrWNQKkaiEFvHinXM,9167
+pip/_vendor/tomli/__init__.py,sha256=JhUwV66DB1g4Hvt1UQCVMdfCu-IgAV8FXmvDU9onxd4,396
+pip/_vendor/tomli/__pycache__/__init__.cpython-312.pyc,,
+pip/_vendor/tomli/__pycache__/_parser.cpython-312.pyc,,
+pip/_vendor/tomli/__pycache__/_re.cpython-312.pyc,,
+pip/_vendor/tomli/__pycache__/_types.cpython-312.pyc,,
+pip/_vendor/tomli/_parser.py,sha256=g9-ENaALS-B8dokYpCuzUFalWlog7T-SIYMjLZSWrtM,22633
+pip/_vendor/tomli/_re.py,sha256=dbjg5ChZT23Ka9z9DHOXfdtSpPwUfdgMXnj8NOoly-w,2943
+pip/_vendor/tomli/_types.py,sha256=-GTG2VUqkpxwMqzmVO4F7ybKddIbAnuAHXfmWQcTi3Q,254
+pip/_vendor/tomli/py.typed,sha256=8PjyZ1aVoQpRVvt71muvuq5qE-jTFZkK-GLHkhdebmc,26
+pip/_vendor/truststore/__init__.py,sha256=M-PhuLMIF7gxKXk7tpo2MD7dk6nqG1ae8GXWdNXbMdQ,403
+pip/_vendor/truststore/__pycache__/__init__.cpython-312.pyc,,
+pip/_vendor/truststore/__pycache__/_api.cpython-312.pyc,,
+pip/_vendor/truststore/__pycache__/_macos.cpython-312.pyc,,
+pip/_vendor/truststore/__pycache__/_openssl.cpython-312.pyc,,
+pip/_vendor/truststore/__pycache__/_ssl_constants.cpython-312.pyc,,
+pip/_vendor/truststore/__pycache__/_windows.cpython-312.pyc,,
+pip/_vendor/truststore/_api.py,sha256=B9JIHipzBIS8pMP_J50-o1DHVZsvKZQUXTB0HQQ_UPg,10461
+pip/_vendor/truststore/_macos.py,sha256=VJ24avz5aEGYAs_kWvnGjMJtuIP4xJcYa459UQOQC3M,17608
+pip/_vendor/truststore/_openssl.py,sha256=LLUZ7ZGaio-i5dpKKjKCSeSufmn6T8pi9lDcFnvSyq0,2324
+pip/_vendor/truststore/_ssl_constants.py,sha256=NUD4fVKdSD02ri7-db0tnO0VqLP9aHuzmStcW7tAl08,1130
+pip/_vendor/truststore/_windows.py,sha256=eldNViHNHeY5r3fiBoz_JFGD37atXB9S5yaRoPKEGAA,17891
+pip/_vendor/truststore/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pip/_vendor/typing_extensions.py,sha256=78hFl0HpDY-ylHUVCnWdU5nTHxUP2-S-3wEZk6CQmLk,134499
+pip/_vendor/urllib3/__init__.py,sha256=iXLcYiJySn0GNbWOOZDDApgBL1JgP44EZ8i1760S8Mc,3333
+pip/_vendor/urllib3/__pycache__/__init__.cpython-312.pyc,,
+pip/_vendor/urllib3/__pycache__/_collections.cpython-312.pyc,,
+pip/_vendor/urllib3/__pycache__/_version.cpython-312.pyc,,
+pip/_vendor/urllib3/__pycache__/connection.cpython-312.pyc,,
+pip/_vendor/urllib3/__pycache__/connectionpool.cpython-312.pyc,,
+pip/_vendor/urllib3/__pycache__/exceptions.cpython-312.pyc,,
+pip/_vendor/urllib3/__pycache__/fields.cpython-312.pyc,,
+pip/_vendor/urllib3/__pycache__/filepost.cpython-312.pyc,,
+pip/_vendor/urllib3/__pycache__/poolmanager.cpython-312.pyc,,
+pip/_vendor/urllib3/__pycache__/request.cpython-312.pyc,,
+pip/_vendor/urllib3/__pycache__/response.cpython-312.pyc,,
+pip/_vendor/urllib3/_collections.py,sha256=pyASJJhW7wdOpqJj9QJA8FyGRfr8E8uUUhqUvhF0728,11372
+pip/_vendor/urllib3/_version.py,sha256=cuJvnSrWxXGYgQ3-ZRoPMw8-qaN5tpw71jnH1t16dLA,64
+pip/_vendor/urllib3/connection.py,sha256=92k9td_y4PEiTIjNufCUa1NzMB3J3w0LEdyokYgXnW8,20300
+pip/_vendor/urllib3/connectionpool.py,sha256=Be6q65SR9laoikg-h_jmc_p8OWtEmwgq_Om_Xtig-2M,40285
+pip/_vendor/urllib3/contrib/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pip/_vendor/urllib3/contrib/__pycache__/__init__.cpython-312.pyc,,
+pip/_vendor/urllib3/contrib/__pycache__/_appengine_environ.cpython-312.pyc,,
+pip/_vendor/urllib3/contrib/__pycache__/appengine.cpython-312.pyc,,
+pip/_vendor/urllib3/contrib/__pycache__/ntlmpool.cpython-312.pyc,,
+pip/_vendor/urllib3/contrib/__pycache__/pyopenssl.cpython-312.pyc,,
+pip/_vendor/urllib3/contrib/__pycache__/securetransport.cpython-312.pyc,,
+pip/_vendor/urllib3/contrib/__pycache__/socks.cpython-312.pyc,,
+pip/_vendor/urllib3/contrib/_appengine_environ.py,sha256=bDbyOEhW2CKLJcQqAKAyrEHN-aklsyHFKq6vF8ZFsmk,957
+pip/_vendor/urllib3/contrib/_securetransport/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pip/_vendor/urllib3/contrib/_securetransport/__pycache__/__init__.cpython-312.pyc,,
+pip/_vendor/urllib3/contrib/_securetransport/__pycache__/bindings.cpython-312.pyc,,
+pip/_vendor/urllib3/contrib/_securetransport/__pycache__/low_level.cpython-312.pyc,,
+pip/_vendor/urllib3/contrib/_securetransport/bindings.py,sha256=4Xk64qIkPBt09A5q-RIFUuDhNc9mXilVapm7WnYnzRw,17632
+pip/_vendor/urllib3/contrib/_securetransport/low_level.py,sha256=B2JBB2_NRP02xK6DCa1Pa9IuxrPwxzDzZbixQkb7U9M,13922
+pip/_vendor/urllib3/contrib/appengine.py,sha256=VR68eAVE137lxTgjBDwCna5UiBZTOKa01Aj_-5BaCz4,11036
+pip/_vendor/urllib3/contrib/ntlmpool.py,sha256=NlfkW7WMdW8ziqudopjHoW299og1BTWi0IeIibquFwk,4528
+pip/_vendor/urllib3/contrib/pyopenssl.py,sha256=hDJh4MhyY_p-oKlFcYcQaVQRDv6GMmBGuW9yjxyeejM,17081
+pip/_vendor/urllib3/contrib/securetransport.py,sha256=Fef1IIUUFHqpevzXiDPbIGkDKchY2FVKeVeLGR1Qq3g,34446
+pip/_vendor/urllib3/contrib/socks.py,sha256=aRi9eWXo9ZEb95XUxef4Z21CFlnnjbEiAo9HOseoMt4,7097
+pip/_vendor/urllib3/exceptions.py,sha256=0Mnno3KHTNfXRfY7638NufOPkUb6mXOm-Lqj-4x2w8A,8217
+pip/_vendor/urllib3/fields.py,sha256=kvLDCg_JmH1lLjUUEY_FLS8UhY7hBvDPuVETbY8mdrM,8579
+pip/_vendor/urllib3/filepost.py,sha256=5b_qqgRHVlL7uLtdAYBzBh-GHmU5AfJVt_2N0XS3PeY,2440
+pip/_vendor/urllib3/packages/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pip/_vendor/urllib3/packages/__pycache__/__init__.cpython-312.pyc,,
+pip/_vendor/urllib3/packages/__pycache__/six.cpython-312.pyc,,
+pip/_vendor/urllib3/packages/backports/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pip/_vendor/urllib3/packages/backports/__pycache__/__init__.cpython-312.pyc,,
+pip/_vendor/urllib3/packages/backports/__pycache__/makefile.cpython-312.pyc,,
+pip/_vendor/urllib3/packages/backports/__pycache__/weakref_finalize.cpython-312.pyc,,
+pip/_vendor/urllib3/packages/backports/makefile.py,sha256=nbzt3i0agPVP07jqqgjhaYjMmuAi_W5E0EywZivVO8E,1417
+pip/_vendor/urllib3/packages/backports/weakref_finalize.py,sha256=tRCal5OAhNSRyb0DhHp-38AtIlCsRP8BxF3NX-6rqIA,5343
+pip/_vendor/urllib3/packages/six.py,sha256=b9LM0wBXv7E7SrbCjAm4wwN-hrH-iNxv18LgWNMMKPo,34665
+pip/_vendor/urllib3/poolmanager.py,sha256=aWyhXRtNO4JUnCSVVqKTKQd8EXTvUm1VN9pgs2bcONo,19990
+pip/_vendor/urllib3/request.py,sha256=YTWFNr7QIwh7E1W9dde9LM77v2VWTJ5V78XuTTw7D1A,6691
+pip/_vendor/urllib3/response.py,sha256=fmDJAFkG71uFTn-sVSTh2Iw0WmcXQYqkbRjihvwBjU8,30641
+pip/_vendor/urllib3/util/__init__.py,sha256=JEmSmmqqLyaw8P51gUImZh8Gwg9i1zSe-DoqAitn2nc,1155
+pip/_vendor/urllib3/util/__pycache__/__init__.cpython-312.pyc,,
+pip/_vendor/urllib3/util/__pycache__/connection.cpython-312.pyc,,
+pip/_vendor/urllib3/util/__pycache__/proxy.cpython-312.pyc,,
+pip/_vendor/urllib3/util/__pycache__/queue.cpython-312.pyc,,
+pip/_vendor/urllib3/util/__pycache__/request.cpython-312.pyc,,
+pip/_vendor/urllib3/util/__pycache__/response.cpython-312.pyc,,
+pip/_vendor/urllib3/util/__pycache__/retry.cpython-312.pyc,,
+pip/_vendor/urllib3/util/__pycache__/ssl_.cpython-312.pyc,,
+pip/_vendor/urllib3/util/__pycache__/ssl_match_hostname.cpython-312.pyc,,
+pip/_vendor/urllib3/util/__pycache__/ssltransport.cpython-312.pyc,,
+pip/_vendor/urllib3/util/__pycache__/timeout.cpython-312.pyc,,
+pip/_vendor/urllib3/util/__pycache__/url.cpython-312.pyc,,
+pip/_vendor/urllib3/util/__pycache__/wait.cpython-312.pyc,,
+pip/_vendor/urllib3/util/connection.py,sha256=5Lx2B1PW29KxBn2T0xkN1CBgRBa3gGVJBKoQoRogEVk,4901
+pip/_vendor/urllib3/util/proxy.py,sha256=zUvPPCJrp6dOF0N4GAVbOcl6o-4uXKSrGiTkkr5vUS4,1605
+pip/_vendor/urllib3/util/queue.py,sha256=nRgX8_eX-_VkvxoX096QWoz8Ps0QHUAExILCY_7PncM,498
+pip/_vendor/urllib3/util/request.py,sha256=C0OUt2tcU6LRiQJ7YYNP9GvPrSvl7ziIBekQ-5nlBZk,3997
+pip/_vendor/urllib3/util/response.py,sha256=GJpg3Egi9qaJXRwBh5wv-MNuRWan5BIu40oReoxWP28,3510
+pip/_vendor/urllib3/util/retry.py,sha256=Z6WEf518eTOXP5jr5QSQ9gqJI0DVYt3Xs3EKnYaTmus,22013
+pip/_vendor/urllib3/util/ssl_.py,sha256=X4-AqW91aYPhPx6-xbf66yHFQKbqqfC_5Zt4WkLX1Hc,17177
+pip/_vendor/urllib3/util/ssl_match_hostname.py,sha256=Ir4cZVEjmAk8gUAIHWSi7wtOO83UCYABY2xFD1Ql_WA,5758
+pip/_vendor/urllib3/util/ssltransport.py,sha256=NA-u5rMTrDFDFC8QzRKUEKMG0561hOD4qBTr3Z4pv6E,6895
+pip/_vendor/urllib3/util/timeout.py,sha256=cwq4dMk87mJHSBktK1miYJ-85G-3T3RmT20v7SFCpno,10168
+pip/_vendor/urllib3/util/url.py,sha256=lCAE7M5myA8EDdW0sJuyyZhVB9K_j38ljWhHAnFaWoE,14296
+pip/_vendor/urllib3/util/wait.py,sha256=fOX0_faozG2P7iVojQoE1mbydweNyTcm-hXEfFrTtLI,5403
+pip/_vendor/vendor.txt,sha256=PxNaxxkkpBaw5zOTsDpHEY-zEaHjgkDgyrSxOuxg8nw,330
+pip/py.typed,sha256=EBVvvPRTn_eIpz5e5QztSCdrMX7Qwd7VP93RSoIlZ2I,286
diff --git a/venv/lib/python3.12/site-packages/pip-24.2.dist-info/REQUESTED b/venv/lib/python3.12/site-packages/pip-24.2.dist-info/REQUESTED
new file mode 100644
index 00000000..e69de29b
diff --git a/venv/lib/python3.12/site-packages/pip-24.2.dist-info/WHEEL b/venv/lib/python3.12/site-packages/pip-24.2.dist-info/WHEEL
new file mode 100644
index 00000000..1a9c5358
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip-24.2.dist-info/WHEEL
@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (72.1.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+
diff --git a/venv/lib/python3.12/site-packages/pip-24.2.dist-info/entry_points.txt b/venv/lib/python3.12/site-packages/pip-24.2.dist-info/entry_points.txt
new file mode 100644
index 00000000..25fcf7e2
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip-24.2.dist-info/entry_points.txt
@@ -0,0 +1,3 @@
+[console_scripts]
+pip = pip._internal.cli.main:main
+pip3 = pip._internal.cli.main:main
diff --git a/venv/lib/python3.12/site-packages/pip-24.2.dist-info/top_level.txt b/venv/lib/python3.12/site-packages/pip-24.2.dist-info/top_level.txt
new file mode 100644
index 00000000..a1b589e3
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip-24.2.dist-info/top_level.txt
@@ -0,0 +1 @@
+pip
diff --git a/venv/lib/python3.12/site-packages/pip/__init__.py b/venv/lib/python3.12/site-packages/pip/__init__.py
new file mode 100644
index 00000000..640e922f
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/__init__.py
@@ -0,0 +1,13 @@
+from typing import List, Optional
+
+__version__ = "24.2"
+
+
+def main(args: Optional[List[str]] = None) -> int:
+    """This is an internal API only meant for use by pip's own console scripts.
+
+    For additional details, see https://github.com/pypa/pip/issues/7498.
+    """
+    from pip._internal.utils.entrypoints import _wrapper
+
+    return _wrapper(args)
diff --git a/venv/lib/python3.12/site-packages/pip/__main__.py b/venv/lib/python3.12/site-packages/pip/__main__.py
new file mode 100644
index 00000000..59913261
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/__main__.py
@@ -0,0 +1,24 @@
+import os
+import sys
+
+# Remove '' and current working directory from the first entry
+# of sys.path, if present to avoid using current directory
+# in pip commands check, freeze, install, list and show,
+# when invoked as python -m pip 
+if sys.path[0] in ("", os.getcwd()):
+    sys.path.pop(0)
+
+# If we are running from a wheel, add the wheel to sys.path
+# This allows the usage python pip-*.whl/pip install pip-*.whl
+if __package__ == "":
+    # __file__ is pip-*.whl/pip/__main__.py
+    # first dirname call strips of '/__main__.py', second strips off '/pip'
+    # Resulting path is the name of the wheel itself
+    # Add that to sys.path so we can import pip
+    path = os.path.dirname(os.path.dirname(__file__))
+    sys.path.insert(0, path)
+
+if __name__ == "__main__":
+    from pip._internal.cli.main import main as _main
+
+    sys.exit(_main())
diff --git a/venv/lib/python3.12/site-packages/pip/__pip-runner__.py b/venv/lib/python3.12/site-packages/pip/__pip-runner__.py
new file mode 100644
index 00000000..c633787f
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/__pip-runner__.py
@@ -0,0 +1,50 @@
+"""Execute exactly this copy of pip, within a different environment.
+
+This file is named as it is, to ensure that this module can't be imported via
+an import statement.
+"""
+
+# /!\ This version compatibility check section must be Python 2 compatible. /!\
+
+import sys
+
+# Copied from pyproject.toml
+PYTHON_REQUIRES = (3, 8)
+
+
+def version_str(version):  # type: ignore
+    return ".".join(str(v) for v in version)
+
+
+if sys.version_info[:2] < PYTHON_REQUIRES:
+    raise SystemExit(
+        "This version of pip does not support python {} (requires >={}).".format(
+            version_str(sys.version_info[:2]), version_str(PYTHON_REQUIRES)
+        )
+    )
+
+# From here on, we can use Python 3 features, but the syntax must remain
+# Python 2 compatible.
+
+import runpy  # noqa: E402
+from importlib.machinery import PathFinder  # noqa: E402
+from os.path import dirname  # noqa: E402
+
+PIP_SOURCES_ROOT = dirname(dirname(__file__))
+
+
+class PipImportRedirectingFinder:
+    @classmethod
+    def find_spec(self, fullname, path=None, target=None):  # type: ignore
+        if fullname != "pip":
+            return None
+
+        spec = PathFinder.find_spec(fullname, [PIP_SOURCES_ROOT], target)
+        assert spec, (PIP_SOURCES_ROOT, fullname)
+        return spec
+
+
+sys.meta_path.insert(0, PipImportRedirectingFinder())
+
+assert __name__ == "__main__", "Cannot run __pip-runner__.py as a non-main module"
+runpy.run_module("pip", run_name="__main__", alter_sys=True)
diff --git a/venv/lib/python3.12/site-packages/pip/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 00000000..ce88c712
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/__pycache__/__init__.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/__pycache__/__main__.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/__pycache__/__main__.cpython-312.pyc
new file mode 100644
index 00000000..74c701a3
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/__pycache__/__main__.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/__pycache__/__pip-runner__.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/__pycache__/__pip-runner__.cpython-312.pyc
new file mode 100644
index 00000000..f522a326
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/__pycache__/__pip-runner__.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/__init__.py b/venv/lib/python3.12/site-packages/pip/_internal/__init__.py
new file mode 100644
index 00000000..1a5b7f87
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/__init__.py
@@ -0,0 +1,18 @@
+from typing import List, Optional
+
+from pip._internal.utils import _log
+
+# init_logging() must be called before any call to logging.getLogger()
+# which happens at import of most modules.
+_log.init_logging()
+
+
+def main(args: Optional[List[str]] = None) -> int:
+    """This is preserved for old console scripts that may still be referencing
+    it.
+
+    For additional details, see https://github.com/pypa/pip/issues/7498.
+    """
+    from pip._internal.utils.entrypoints import _wrapper
+
+    return _wrapper(args)
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 00000000..b4792de6
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/__pycache__/__init__.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/__pycache__/build_env.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/__pycache__/build_env.cpython-312.pyc
new file mode 100644
index 00000000..8a05e272
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/__pycache__/build_env.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/__pycache__/cache.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/__pycache__/cache.cpython-312.pyc
new file mode 100644
index 00000000..2016b12d
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/__pycache__/cache.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/__pycache__/configuration.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/__pycache__/configuration.cpython-312.pyc
new file mode 100644
index 00000000..31dbe90f
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/__pycache__/configuration.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/__pycache__/exceptions.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/__pycache__/exceptions.cpython-312.pyc
new file mode 100644
index 00000000..f350edc2
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/__pycache__/exceptions.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/__pycache__/main.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/__pycache__/main.cpython-312.pyc
new file mode 100644
index 00000000..16ca8feb
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/__pycache__/main.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/__pycache__/pyproject.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/__pycache__/pyproject.cpython-312.pyc
new file mode 100644
index 00000000..a55e2d2a
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/__pycache__/pyproject.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/__pycache__/self_outdated_check.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/__pycache__/self_outdated_check.cpython-312.pyc
new file mode 100644
index 00000000..2df53ca2
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/__pycache__/self_outdated_check.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/__pycache__/wheel_builder.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/__pycache__/wheel_builder.cpython-312.pyc
new file mode 100644
index 00000000..367878be
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/__pycache__/wheel_builder.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/build_env.py b/venv/lib/python3.12/site-packages/pip/_internal/build_env.py
new file mode 100644
index 00000000..be1e0ca8
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/build_env.py
@@ -0,0 +1,315 @@
+"""Build Environment used for isolation during sdist building
+"""
+
+import logging
+import os
+import pathlib
+import site
+import sys
+import textwrap
+from collections import OrderedDict
+from types import TracebackType
+from typing import TYPE_CHECKING, Iterable, List, Optional, Set, Tuple, Type, Union
+
+from pip._vendor.certifi import where
+from pip._vendor.packaging.version import Version
+
+from pip import __file__ as pip_location
+from pip._internal.cli.spinners import open_spinner
+from pip._internal.locations import get_platlib, get_purelib, get_scheme
+from pip._internal.metadata import get_default_environment, get_environment
+from pip._internal.utils.logging import VERBOSE
+from pip._internal.utils.packaging import get_requirement
+from pip._internal.utils.subprocess import call_subprocess
+from pip._internal.utils.temp_dir import TempDirectory, tempdir_kinds
+
+if TYPE_CHECKING:
+    from pip._internal.index.package_finder import PackageFinder
+
+logger = logging.getLogger(__name__)
+
+
+def _dedup(a: str, b: str) -> Union[Tuple[str], Tuple[str, str]]:
+    return (a, b) if a != b else (a,)
+
+
+class _Prefix:
+    def __init__(self, path: str) -> None:
+        self.path = path
+        self.setup = False
+        scheme = get_scheme("", prefix=path)
+        self.bin_dir = scheme.scripts
+        self.lib_dirs = _dedup(scheme.purelib, scheme.platlib)
+
+
+def get_runnable_pip() -> str:
+    """Get a file to pass to a Python executable, to run the currently-running pip.
+
+    This is used to run a pip subprocess, for installing requirements into the build
+    environment.
+    """
+    source = pathlib.Path(pip_location).resolve().parent
+
+    if not source.is_dir():
+        # This would happen if someone is using pip from inside a zip file. In that
+        # case, we can use that directly.
+        return str(source)
+
+    return os.fsdecode(source / "__pip-runner__.py")
+
+
+def _get_system_sitepackages() -> Set[str]:
+    """Get system site packages
+
+    Usually from site.getsitepackages,
+    but fallback on `get_purelib()/get_platlib()` if unavailable
+    (e.g. in a virtualenv created by virtualenv<20)
+
+    Returns normalized set of strings.
+    """
+    if hasattr(site, "getsitepackages"):
+        system_sites = site.getsitepackages()
+    else:
+        # virtualenv < 20 overwrites site.py without getsitepackages
+        # fallback on get_purelib/get_platlib.
+        # this is known to miss things, but shouldn't in the cases
+        # where getsitepackages() has been removed (inside a virtualenv)
+        system_sites = [get_purelib(), get_platlib()]
+    return {os.path.normcase(path) for path in system_sites}
+
+
+class BuildEnvironment:
+    """Creates and manages an isolated environment to install build deps"""
+
+    def __init__(self) -> None:
+        temp_dir = TempDirectory(kind=tempdir_kinds.BUILD_ENV, globally_managed=True)
+
+        self._prefixes = OrderedDict(
+            (name, _Prefix(os.path.join(temp_dir.path, name)))
+            for name in ("normal", "overlay")
+        )
+
+        self._bin_dirs: List[str] = []
+        self._lib_dirs: List[str] = []
+        for prefix in reversed(list(self._prefixes.values())):
+            self._bin_dirs.append(prefix.bin_dir)
+            self._lib_dirs.extend(prefix.lib_dirs)
+
+        # Customize site to:
+        # - ensure .pth files are honored
+        # - prevent access to system site packages
+        system_sites = _get_system_sitepackages()
+
+        self._site_dir = os.path.join(temp_dir.path, "site")
+        if not os.path.exists(self._site_dir):
+            os.mkdir(self._site_dir)
+        with open(
+            os.path.join(self._site_dir, "sitecustomize.py"), "w", encoding="utf-8"
+        ) as fp:
+            fp.write(
+                textwrap.dedent(
+                    """
+                import os, site, sys
+
+                # First, drop system-sites related paths.
+                original_sys_path = sys.path[:]
+                known_paths = set()
+                for path in {system_sites!r}:
+                    site.addsitedir(path, known_paths=known_paths)
+                system_paths = set(
+                    os.path.normcase(path)
+                    for path in sys.path[len(original_sys_path):]
+                )
+                original_sys_path = [
+                    path for path in original_sys_path
+                    if os.path.normcase(path) not in system_paths
+                ]
+                sys.path = original_sys_path
+
+                # Second, add lib directories.
+                # ensuring .pth file are processed.
+                for path in {lib_dirs!r}:
+                    assert not path in sys.path
+                    site.addsitedir(path)
+                """
+                ).format(system_sites=system_sites, lib_dirs=self._lib_dirs)
+            )
+
+    def __enter__(self) -> None:
+        self._save_env = {
+            name: os.environ.get(name, None)
+            for name in ("PATH", "PYTHONNOUSERSITE", "PYTHONPATH")
+        }
+
+        path = self._bin_dirs[:]
+        old_path = self._save_env["PATH"]
+        if old_path:
+            path.extend(old_path.split(os.pathsep))
+
+        pythonpath = [self._site_dir]
+
+        os.environ.update(
+            {
+                "PATH": os.pathsep.join(path),
+                "PYTHONNOUSERSITE": "1",
+                "PYTHONPATH": os.pathsep.join(pythonpath),
+            }
+        )
+
+    def __exit__(
+        self,
+        exc_type: Optional[Type[BaseException]],
+        exc_val: Optional[BaseException],
+        exc_tb: Optional[TracebackType],
+    ) -> None:
+        for varname, old_value in self._save_env.items():
+            if old_value is None:
+                os.environ.pop(varname, None)
+            else:
+                os.environ[varname] = old_value
+
+    def check_requirements(
+        self, reqs: Iterable[str]
+    ) -> Tuple[Set[Tuple[str, str]], Set[str]]:
+        """Return 2 sets:
+        - conflicting requirements: set of (installed, wanted) reqs tuples
+        - missing requirements: set of reqs
+        """
+        missing = set()
+        conflicting = set()
+        if reqs:
+            env = (
+                get_environment(self._lib_dirs)
+                if hasattr(self, "_lib_dirs")
+                else get_default_environment()
+            )
+            for req_str in reqs:
+                req = get_requirement(req_str)
+                # We're explicitly evaluating with an empty extra value, since build
+                # environments are not provided any mechanism to select specific extras.
+                if req.marker is not None and not req.marker.evaluate({"extra": ""}):
+                    continue
+                dist = env.get_distribution(req.name)
+                if not dist:
+                    missing.add(req_str)
+                    continue
+                if isinstance(dist.version, Version):
+                    installed_req_str = f"{req.name}=={dist.version}"
+                else:
+                    installed_req_str = f"{req.name}==={dist.version}"
+                if not req.specifier.contains(dist.version, prereleases=True):
+                    conflicting.add((installed_req_str, req_str))
+                # FIXME: Consider direct URL?
+        return conflicting, missing
+
+    def install_requirements(
+        self,
+        finder: "PackageFinder",
+        requirements: Iterable[str],
+        prefix_as_string: str,
+        *,
+        kind: str,
+    ) -> None:
+        prefix = self._prefixes[prefix_as_string]
+        assert not prefix.setup
+        prefix.setup = True
+        if not requirements:
+            return
+        self._install_requirements(
+            get_runnable_pip(),
+            finder,
+            requirements,
+            prefix,
+            kind=kind,
+        )
+
+    @staticmethod
+    def _install_requirements(
+        pip_runnable: str,
+        finder: "PackageFinder",
+        requirements: Iterable[str],
+        prefix: _Prefix,
+        *,
+        kind: str,
+    ) -> None:
+        args: List[str] = [
+            sys.executable,
+            pip_runnable,
+            "install",
+            "--ignore-installed",
+            "--no-user",
+            "--prefix",
+            prefix.path,
+            "--no-warn-script-location",
+            "--disable-pip-version-check",
+        ]
+        if logger.getEffectiveLevel() <= logging.DEBUG:
+            args.append("-vv")
+        elif logger.getEffectiveLevel() <= VERBOSE:
+            args.append("-v")
+        for format_control in ("no_binary", "only_binary"):
+            formats = getattr(finder.format_control, format_control)
+            args.extend(
+                (
+                    "--" + format_control.replace("_", "-"),
+                    ",".join(sorted(formats or {":none:"})),
+                )
+            )
+
+        index_urls = finder.index_urls
+        if index_urls:
+            args.extend(["-i", index_urls[0]])
+            for extra_index in index_urls[1:]:
+                args.extend(["--extra-index-url", extra_index])
+        else:
+            args.append("--no-index")
+        for link in finder.find_links:
+            args.extend(["--find-links", link])
+
+        for host in finder.trusted_hosts:
+            args.extend(["--trusted-host", host])
+        if finder.allow_all_prereleases:
+            args.append("--pre")
+        if finder.prefer_binary:
+            args.append("--prefer-binary")
+        args.append("--")
+        args.extend(requirements)
+        extra_environ = {"_PIP_STANDALONE_CERT": where()}
+        with open_spinner(f"Installing {kind}") as spinner:
+            call_subprocess(
+                args,
+                command_desc=f"pip subprocess to install {kind}",
+                spinner=spinner,
+                extra_environ=extra_environ,
+            )
+
+
+class NoOpBuildEnvironment(BuildEnvironment):
+    """A no-op drop-in replacement for BuildEnvironment"""
+
+    def __init__(self) -> None:
+        pass
+
+    def __enter__(self) -> None:
+        pass
+
+    def __exit__(
+        self,
+        exc_type: Optional[Type[BaseException]],
+        exc_val: Optional[BaseException],
+        exc_tb: Optional[TracebackType],
+    ) -> None:
+        pass
+
+    def cleanup(self) -> None:
+        pass
+
+    def install_requirements(
+        self,
+        finder: "PackageFinder",
+        requirements: Iterable[str],
+        prefix_as_string: str,
+        *,
+        kind: str,
+    ) -> None:
+        raise NotImplementedError()
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/cache.py b/venv/lib/python3.12/site-packages/pip/_internal/cache.py
new file mode 100644
index 00000000..6b451267
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/cache.py
@@ -0,0 +1,290 @@
+"""Cache Management
+"""
+
+import hashlib
+import json
+import logging
+import os
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+from pip._vendor.packaging.tags import Tag, interpreter_name, interpreter_version
+from pip._vendor.packaging.utils import canonicalize_name
+
+from pip._internal.exceptions import InvalidWheelFilename
+from pip._internal.models.direct_url import DirectUrl
+from pip._internal.models.link import Link
+from pip._internal.models.wheel import Wheel
+from pip._internal.utils.temp_dir import TempDirectory, tempdir_kinds
+from pip._internal.utils.urls import path_to_url
+
+logger = logging.getLogger(__name__)
+
+ORIGIN_JSON_NAME = "origin.json"
+
+
+def _hash_dict(d: Dict[str, str]) -> str:
+    """Return a stable sha224 of a dictionary."""
+    s = json.dumps(d, sort_keys=True, separators=(",", ":"), ensure_ascii=True)
+    return hashlib.sha224(s.encode("ascii")).hexdigest()
+
+
+class Cache:
+    """An abstract class - provides cache directories for data from links
+
+    :param cache_dir: The root of the cache.
+    """
+
+    def __init__(self, cache_dir: str) -> None:
+        super().__init__()
+        assert not cache_dir or os.path.isabs(cache_dir)
+        self.cache_dir = cache_dir or None
+
+    def _get_cache_path_parts(self, link: Link) -> List[str]:
+        """Get parts of part that must be os.path.joined with cache_dir"""
+
+        # We want to generate an url to use as our cache key, we don't want to
+        # just reuse the URL because it might have other items in the fragment
+        # and we don't care about those.
+        key_parts = {"url": link.url_without_fragment}
+        if link.hash_name is not None and link.hash is not None:
+            key_parts[link.hash_name] = link.hash
+        if link.subdirectory_fragment:
+            key_parts["subdirectory"] = link.subdirectory_fragment
+
+        # Include interpreter name, major and minor version in cache key
+        # to cope with ill-behaved sdists that build a different wheel
+        # depending on the python version their setup.py is being run on,
+        # and don't encode the difference in compatibility tags.
+        # https://github.com/pypa/pip/issues/7296
+        key_parts["interpreter_name"] = interpreter_name()
+        key_parts["interpreter_version"] = interpreter_version()
+
+        # Encode our key url with sha224, we'll use this because it has similar
+        # security properties to sha256, but with a shorter total output (and
+        # thus less secure). However the differences don't make a lot of
+        # difference for our use case here.
+        hashed = _hash_dict(key_parts)
+
+        # We want to nest the directories some to prevent having a ton of top
+        # level directories where we might run out of sub directories on some
+        # FS.
+        parts = [hashed[:2], hashed[2:4], hashed[4:6], hashed[6:]]
+
+        return parts
+
+    def _get_candidates(self, link: Link, canonical_package_name: str) -> List[Any]:
+        can_not_cache = not self.cache_dir or not canonical_package_name or not link
+        if can_not_cache:
+            return []
+
+        path = self.get_path_for_link(link)
+        if os.path.isdir(path):
+            return [(candidate, path) for candidate in os.listdir(path)]
+        return []
+
+    def get_path_for_link(self, link: Link) -> str:
+        """Return a directory to store cached items in for link."""
+        raise NotImplementedError()
+
+    def get(
+        self,
+        link: Link,
+        package_name: Optional[str],
+        supported_tags: List[Tag],
+    ) -> Link:
+        """Returns a link to a cached item if it exists, otherwise returns the
+        passed link.
+        """
+        raise NotImplementedError()
+
+
+class SimpleWheelCache(Cache):
+    """A cache of wheels for future installs."""
+
+    def __init__(self, cache_dir: str) -> None:
+        super().__init__(cache_dir)
+
+    def get_path_for_link(self, link: Link) -> str:
+        """Return a directory to store cached wheels for link
+
+        Because there are M wheels for any one sdist, we provide a directory
+        to cache them in, and then consult that directory when looking up
+        cache hits.
+
+        We only insert things into the cache if they have plausible version
+        numbers, so that we don't contaminate the cache with things that were
+        not unique. E.g. ./package might have dozens of installs done for it
+        and build a version of 0.0...and if we built and cached a wheel, we'd
+        end up using the same wheel even if the source has been edited.
+
+        :param link: The link of the sdist for which this will cache wheels.
+        """
+        parts = self._get_cache_path_parts(link)
+        assert self.cache_dir
+        # Store wheels within the root cache_dir
+        return os.path.join(self.cache_dir, "wheels", *parts)
+
+    def get(
+        self,
+        link: Link,
+        package_name: Optional[str],
+        supported_tags: List[Tag],
+    ) -> Link:
+        candidates = []
+
+        if not package_name:
+            return link
+
+        canonical_package_name = canonicalize_name(package_name)
+        for wheel_name, wheel_dir in self._get_candidates(link, canonical_package_name):
+            try:
+                wheel = Wheel(wheel_name)
+            except InvalidWheelFilename:
+                continue
+            if canonicalize_name(wheel.name) != canonical_package_name:
+                logger.debug(
+                    "Ignoring cached wheel %s for %s as it "
+                    "does not match the expected distribution name %s.",
+                    wheel_name,
+                    link,
+                    package_name,
+                )
+                continue
+            if not wheel.supported(supported_tags):
+                # Built for a different python/arch/etc
+                continue
+            candidates.append(
+                (
+                    wheel.support_index_min(supported_tags),
+                    wheel_name,
+                    wheel_dir,
+                )
+            )
+
+        if not candidates:
+            return link
+
+        _, wheel_name, wheel_dir = min(candidates)
+        return Link(path_to_url(os.path.join(wheel_dir, wheel_name)))
+
+
+class EphemWheelCache(SimpleWheelCache):
+    """A SimpleWheelCache that creates it's own temporary cache directory"""
+
+    def __init__(self) -> None:
+        self._temp_dir = TempDirectory(
+            kind=tempdir_kinds.EPHEM_WHEEL_CACHE,
+            globally_managed=True,
+        )
+
+        super().__init__(self._temp_dir.path)
+
+
+class CacheEntry:
+    def __init__(
+        self,
+        link: Link,
+        persistent: bool,
+    ):
+        self.link = link
+        self.persistent = persistent
+        self.origin: Optional[DirectUrl] = None
+        origin_direct_url_path = Path(self.link.file_path).parent / ORIGIN_JSON_NAME
+        if origin_direct_url_path.exists():
+            try:
+                self.origin = DirectUrl.from_json(
+                    origin_direct_url_path.read_text(encoding="utf-8")
+                )
+            except Exception as e:
+                logger.warning(
+                    "Ignoring invalid cache entry origin file %s for %s (%s)",
+                    origin_direct_url_path,
+                    link.filename,
+                    e,
+                )
+
+
+class WheelCache(Cache):
+    """Wraps EphemWheelCache and SimpleWheelCache into a single Cache
+
+    This Cache allows for gracefully degradation, using the ephem wheel cache
+    when a certain link is not found in the simple wheel cache first.
+    """
+
+    def __init__(self, cache_dir: str) -> None:
+        super().__init__(cache_dir)
+        self._wheel_cache = SimpleWheelCache(cache_dir)
+        self._ephem_cache = EphemWheelCache()
+
+    def get_path_for_link(self, link: Link) -> str:
+        return self._wheel_cache.get_path_for_link(link)
+
+    def get_ephem_path_for_link(self, link: Link) -> str:
+        return self._ephem_cache.get_path_for_link(link)
+
+    def get(
+        self,
+        link: Link,
+        package_name: Optional[str],
+        supported_tags: List[Tag],
+    ) -> Link:
+        cache_entry = self.get_cache_entry(link, package_name, supported_tags)
+        if cache_entry is None:
+            return link
+        return cache_entry.link
+
+    def get_cache_entry(
+        self,
+        link: Link,
+        package_name: Optional[str],
+        supported_tags: List[Tag],
+    ) -> Optional[CacheEntry]:
+        """Returns a CacheEntry with a link to a cached item if it exists or
+        None. The cache entry indicates if the item was found in the persistent
+        or ephemeral cache.
+        """
+        retval = self._wheel_cache.get(
+            link=link,
+            package_name=package_name,
+            supported_tags=supported_tags,
+        )
+        if retval is not link:
+            return CacheEntry(retval, persistent=True)
+
+        retval = self._ephem_cache.get(
+            link=link,
+            package_name=package_name,
+            supported_tags=supported_tags,
+        )
+        if retval is not link:
+            return CacheEntry(retval, persistent=False)
+
+        return None
+
+    @staticmethod
+    def record_download_origin(cache_dir: str, download_info: DirectUrl) -> None:
+        origin_path = Path(cache_dir) / ORIGIN_JSON_NAME
+        if origin_path.exists():
+            try:
+                origin = DirectUrl.from_json(origin_path.read_text(encoding="utf-8"))
+            except Exception as e:
+                logger.warning(
+                    "Could not read origin file %s in cache entry (%s). "
+                    "Will attempt to overwrite it.",
+                    origin_path,
+                    e,
+                )
+            else:
+                # TODO: use DirectUrl.equivalent when
+                # https://github.com/pypa/pip/pull/10564 is merged.
+                if origin.url != download_info.url:
+                    logger.warning(
+                        "Origin URL %s in cache entry %s does not match download URL "
+                        "%s. This is likely a pip bug or a cache corruption issue. "
+                        "Will overwrite it with the new value.",
+                        origin.url,
+                        cache_dir,
+                        download_info.url,
+                    )
+        origin_path.write_text(download_info.to_json(), encoding="utf-8")
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/cli/__init__.py b/venv/lib/python3.12/site-packages/pip/_internal/cli/__init__.py
new file mode 100644
index 00000000..e589bb91
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/cli/__init__.py
@@ -0,0 +1,4 @@
+"""Subpackage containing all of pip's command line interface related code
+"""
+
+# This file intentionally does not import submodules
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/cli/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/cli/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 00000000..e0a89b16
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/cli/__pycache__/__init__.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/cli/__pycache__/autocompletion.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/cli/__pycache__/autocompletion.cpython-312.pyc
new file mode 100644
index 00000000..9edc22c5
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/cli/__pycache__/autocompletion.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/cli/__pycache__/base_command.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/cli/__pycache__/base_command.cpython-312.pyc
new file mode 100644
index 00000000..de43aefe
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/cli/__pycache__/base_command.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/cli/__pycache__/cmdoptions.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/cli/__pycache__/cmdoptions.cpython-312.pyc
new file mode 100644
index 00000000..b6e30728
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/cli/__pycache__/cmdoptions.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/cli/__pycache__/command_context.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/cli/__pycache__/command_context.cpython-312.pyc
new file mode 100644
index 00000000..96a2664a
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/cli/__pycache__/command_context.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/cli/__pycache__/index_command.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/cli/__pycache__/index_command.cpython-312.pyc
new file mode 100644
index 00000000..b8805fb4
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/cli/__pycache__/index_command.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/cli/__pycache__/main.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/cli/__pycache__/main.cpython-312.pyc
new file mode 100644
index 00000000..ec9e012b
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/cli/__pycache__/main.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/cli/__pycache__/main_parser.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/cli/__pycache__/main_parser.cpython-312.pyc
new file mode 100644
index 00000000..e0c036ee
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/cli/__pycache__/main_parser.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/cli/__pycache__/parser.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/cli/__pycache__/parser.cpython-312.pyc
new file mode 100644
index 00000000..28022f97
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/cli/__pycache__/parser.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/cli/__pycache__/progress_bars.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/cli/__pycache__/progress_bars.cpython-312.pyc
new file mode 100644
index 00000000..7b5186fa
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/cli/__pycache__/progress_bars.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/cli/__pycache__/req_command.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/cli/__pycache__/req_command.cpython-312.pyc
new file mode 100644
index 00000000..2915258e
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/cli/__pycache__/req_command.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/cli/__pycache__/spinners.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/cli/__pycache__/spinners.cpython-312.pyc
new file mode 100644
index 00000000..62c854ee
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/cli/__pycache__/spinners.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/cli/__pycache__/status_codes.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/cli/__pycache__/status_codes.cpython-312.pyc
new file mode 100644
index 00000000..4a7a55c5
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/cli/__pycache__/status_codes.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/cli/autocompletion.py b/venv/lib/python3.12/site-packages/pip/_internal/cli/autocompletion.py
new file mode 100644
index 00000000..f3f70ac8
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/cli/autocompletion.py
@@ -0,0 +1,176 @@
+"""Logic that powers autocompletion installed by ``pip completion``.
+"""
+
+import optparse
+import os
+import sys
+from itertools import chain
+from typing import Any, Iterable, List, Optional
+
+from pip._internal.cli.main_parser import create_main_parser
+from pip._internal.commands import commands_dict, create_command
+from pip._internal.metadata import get_default_environment
+
+
+def autocomplete() -> None:
+    """Entry Point for completion of main and subcommand options."""
+    # Don't complete if user hasn't sourced bash_completion file.
+    if "PIP_AUTO_COMPLETE" not in os.environ:
+        return
+    # Don't complete if autocompletion environment variables
+    # are not present
+    if not os.environ.get("COMP_WORDS") or not os.environ.get("COMP_CWORD"):
+        return
+    cwords = os.environ["COMP_WORDS"].split()[1:]
+    cword = int(os.environ["COMP_CWORD"])
+    try:
+        current = cwords[cword - 1]
+    except IndexError:
+        current = ""
+
+    parser = create_main_parser()
+    subcommands = list(commands_dict)
+    options = []
+
+    # subcommand
+    subcommand_name: Optional[str] = None
+    for word in cwords:
+        if word in subcommands:
+            subcommand_name = word
+            break
+    # subcommand options
+    if subcommand_name is not None:
+        # special case: 'help' subcommand has no options
+        if subcommand_name == "help":
+            sys.exit(1)
+        # special case: list locally installed dists for show and uninstall
+        should_list_installed = not current.startswith("-") and subcommand_name in [
+            "show",
+            "uninstall",
+        ]
+        if should_list_installed:
+            env = get_default_environment()
+            lc = current.lower()
+            installed = [
+                dist.canonical_name
+                for dist in env.iter_installed_distributions(local_only=True)
+                if dist.canonical_name.startswith(lc)
+                and dist.canonical_name not in cwords[1:]
+            ]
+            # if there are no dists installed, fall back to option completion
+            if installed:
+                for dist in installed:
+                    print(dist)
+                sys.exit(1)
+
+        should_list_installables = (
+            not current.startswith("-") and subcommand_name == "install"
+        )
+        if should_list_installables:
+            for path in auto_complete_paths(current, "path"):
+                print(path)
+            sys.exit(1)
+
+        subcommand = create_command(subcommand_name)
+
+        for opt in subcommand.parser.option_list_all:
+            if opt.help != optparse.SUPPRESS_HELP:
+                options += [
+                    (opt_str, opt.nargs) for opt_str in opt._long_opts + opt._short_opts
+                ]
+
+        # filter out previously specified options from available options
+        prev_opts = [x.split("=")[0] for x in cwords[1 : cword - 1]]
+        options = [(x, v) for (x, v) in options if x not in prev_opts]
+        # filter options by current input
+        options = [(k, v) for k, v in options if k.startswith(current)]
+        # get completion type given cwords and available subcommand options
+        completion_type = get_path_completion_type(
+            cwords,
+            cword,
+            subcommand.parser.option_list_all,
+        )
+        # get completion files and directories if ``completion_type`` is
+        # ````, ```` or ````
+        if completion_type:
+            paths = auto_complete_paths(current, completion_type)
+            options = [(path, 0) for path in paths]
+        for option in options:
+            opt_label = option[0]
+            # append '=' to options which require args
+            if option[1] and option[0][:2] == "--":
+                opt_label += "="
+            print(opt_label)
+    else:
+        # show main parser options only when necessary
+
+        opts = [i.option_list for i in parser.option_groups]
+        opts.append(parser.option_list)
+        flattened_opts = chain.from_iterable(opts)
+        if current.startswith("-"):
+            for opt in flattened_opts:
+                if opt.help != optparse.SUPPRESS_HELP:
+                    subcommands += opt._long_opts + opt._short_opts
+        else:
+            # get completion type given cwords and all available options
+            completion_type = get_path_completion_type(cwords, cword, flattened_opts)
+            if completion_type:
+                subcommands = list(auto_complete_paths(current, completion_type))
+
+        print(" ".join([x for x in subcommands if x.startswith(current)]))
+    sys.exit(1)
+
+
+def get_path_completion_type(
+    cwords: List[str], cword: int, opts: Iterable[Any]
+) -> Optional[str]:
+    """Get the type of path completion (``file``, ``dir``, ``path`` or None)
+
+    :param cwords: same as the environmental variable ``COMP_WORDS``
+    :param cword: same as the environmental variable ``COMP_CWORD``
+    :param opts: The available options to check
+    :return: path completion type (``file``, ``dir``, ``path`` or None)
+    """
+    if cword < 2 or not cwords[cword - 2].startswith("-"):
+        return None
+    for opt in opts:
+        if opt.help == optparse.SUPPRESS_HELP:
+            continue
+        for o in str(opt).split("/"):
+            if cwords[cword - 2].split("=")[0] == o:
+                if not opt.metavar or any(
+                    x in ("path", "file", "dir") for x in opt.metavar.split("/")
+                ):
+                    return opt.metavar
+    return None
+
+
+def auto_complete_paths(current: str, completion_type: str) -> Iterable[str]:
+    """If ``completion_type`` is ``file`` or ``path``, list all regular files
+    and directories starting with ``current``; otherwise only list directories
+    starting with ``current``.
+
+    :param current: The word to be completed
+    :param completion_type: path completion type(``file``, ``path`` or ``dir``)
+    :return: A generator of regular files and/or directories
+    """
+    directory, filename = os.path.split(current)
+    current_path = os.path.abspath(directory)
+    # Don't complete paths if they can't be accessed
+    if not os.access(current_path, os.R_OK):
+        return
+    filename = os.path.normcase(filename)
+    # list all files that start with ``filename``
+    file_list = (
+        x for x in os.listdir(current_path) if os.path.normcase(x).startswith(filename)
+    )
+    for f in file_list:
+        opt = os.path.join(current_path, f)
+        comp_file = os.path.normcase(os.path.join(directory, f))
+        # complete regular files when there is not ```` after option
+        # complete directories when there is ````, ```` or
+        # ````after option
+        if completion_type != "dir" and os.path.isfile(opt):
+            yield comp_file
+        elif os.path.isdir(opt):
+            yield os.path.join(comp_file, "")
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/cli/base_command.py b/venv/lib/python3.12/site-packages/pip/_internal/cli/base_command.py
new file mode 100644
index 00000000..bc1ab659
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/cli/base_command.py
@@ -0,0 +1,231 @@
+"""Base Command class, and related routines"""
+
+import logging
+import logging.config
+import optparse
+import os
+import sys
+import traceback
+from optparse import Values
+from typing import List, Optional, Tuple
+
+from pip._vendor.rich import reconfigure
+from pip._vendor.rich import traceback as rich_traceback
+
+from pip._internal.cli import cmdoptions
+from pip._internal.cli.command_context import CommandContextMixIn
+from pip._internal.cli.parser import ConfigOptionParser, UpdatingDefaultsHelpFormatter
+from pip._internal.cli.status_codes import (
+    ERROR,
+    PREVIOUS_BUILD_DIR_ERROR,
+    UNKNOWN_ERROR,
+    VIRTUALENV_NOT_FOUND,
+)
+from pip._internal.exceptions import (
+    BadCommand,
+    CommandError,
+    DiagnosticPipError,
+    InstallationError,
+    NetworkConnectionError,
+    PreviousBuildDirError,
+)
+from pip._internal.utils.filesystem import check_path_owner
+from pip._internal.utils.logging import BrokenStdoutLoggingError, setup_logging
+from pip._internal.utils.misc import get_prog, normalize_path
+from pip._internal.utils.temp_dir import TempDirectoryTypeRegistry as TempDirRegistry
+from pip._internal.utils.temp_dir import global_tempdir_manager, tempdir_registry
+from pip._internal.utils.virtualenv import running_under_virtualenv
+
+__all__ = ["Command"]
+
+logger = logging.getLogger(__name__)
+
+
+class Command(CommandContextMixIn):
+    usage: str = ""
+    ignore_require_venv: bool = False
+
+    def __init__(self, name: str, summary: str, isolated: bool = False) -> None:
+        super().__init__()
+
+        self.name = name
+        self.summary = summary
+        self.parser = ConfigOptionParser(
+            usage=self.usage,
+            prog=f"{get_prog()} {name}",
+            formatter=UpdatingDefaultsHelpFormatter(),
+            add_help_option=False,
+            name=name,
+            description=self.__doc__,
+            isolated=isolated,
+        )
+
+        self.tempdir_registry: Optional[TempDirRegistry] = None
+
+        # Commands should add options to this option group
+        optgroup_name = f"{self.name.capitalize()} Options"
+        self.cmd_opts = optparse.OptionGroup(self.parser, optgroup_name)
+
+        # Add the general options
+        gen_opts = cmdoptions.make_option_group(
+            cmdoptions.general_group,
+            self.parser,
+        )
+        self.parser.add_option_group(gen_opts)
+
+        self.add_options()
+
+    def add_options(self) -> None:
+        pass
+
+    def handle_pip_version_check(self, options: Values) -> None:
+        """
+        This is a no-op so that commands by default do not do the pip version
+        check.
+        """
+        # Make sure we do the pip version check if the index_group options
+        # are present.
+        assert not hasattr(options, "no_index")
+
+    def run(self, options: Values, args: List[str]) -> int:
+        raise NotImplementedError
+
+    def _run_wrapper(self, level_number: int, options: Values, args: List[str]) -> int:
+        def _inner_run() -> int:
+            try:
+                return self.run(options, args)
+            finally:
+                self.handle_pip_version_check(options)
+
+        if options.debug_mode:
+            rich_traceback.install(show_locals=True)
+            return _inner_run()
+
+        try:
+            status = _inner_run()
+            assert isinstance(status, int)
+            return status
+        except DiagnosticPipError as exc:
+            logger.error("%s", exc, extra={"rich": True})
+            logger.debug("Exception information:", exc_info=True)
+
+            return ERROR
+        except PreviousBuildDirError as exc:
+            logger.critical(str(exc))
+            logger.debug("Exception information:", exc_info=True)
+
+            return PREVIOUS_BUILD_DIR_ERROR
+        except (
+            InstallationError,
+            BadCommand,
+            NetworkConnectionError,
+        ) as exc:
+            logger.critical(str(exc))
+            logger.debug("Exception information:", exc_info=True)
+
+            return ERROR
+        except CommandError as exc:
+            logger.critical("%s", exc)
+            logger.debug("Exception information:", exc_info=True)
+
+            return ERROR
+        except BrokenStdoutLoggingError:
+            # Bypass our logger and write any remaining messages to
+            # stderr because stdout no longer works.
+            print("ERROR: Pipe to stdout was broken", file=sys.stderr)
+            if level_number <= logging.DEBUG:
+                traceback.print_exc(file=sys.stderr)
+
+            return ERROR
+        except KeyboardInterrupt:
+            logger.critical("Operation cancelled by user")
+            logger.debug("Exception information:", exc_info=True)
+
+            return ERROR
+        except BaseException:
+            logger.critical("Exception:", exc_info=True)
+
+            return UNKNOWN_ERROR
+
+    def parse_args(self, args: List[str]) -> Tuple[Values, List[str]]:
+        # factored out for testability
+        return self.parser.parse_args(args)
+
+    def main(self, args: List[str]) -> int:
+        try:
+            with self.main_context():
+                return self._main(args)
+        finally:
+            logging.shutdown()
+
+    def _main(self, args: List[str]) -> int:
+        # We must initialize this before the tempdir manager, otherwise the
+        # configuration would not be accessible by the time we clean up the
+        # tempdir manager.
+        self.tempdir_registry = self.enter_context(tempdir_registry())
+        # Intentionally set as early as possible so globally-managed temporary
+        # directories are available to the rest of the code.
+        self.enter_context(global_tempdir_manager())
+
+        options, args = self.parse_args(args)
+
+        # Set verbosity so that it can be used elsewhere.
+        self.verbosity = options.verbose - options.quiet
+
+        reconfigure(no_color=options.no_color)
+        level_number = setup_logging(
+            verbosity=self.verbosity,
+            no_color=options.no_color,
+            user_log_file=options.log,
+        )
+
+        always_enabled_features = set(options.features_enabled) & set(
+            cmdoptions.ALWAYS_ENABLED_FEATURES
+        )
+        if always_enabled_features:
+            logger.warning(
+                "The following features are always enabled: %s. ",
+                ", ".join(sorted(always_enabled_features)),
+            )
+
+        # Make sure that the --python argument isn't specified after the
+        # subcommand. We can tell, because if --python was specified,
+        # we should only reach this point if we're running in the created
+        # subprocess, which has the _PIP_RUNNING_IN_SUBPROCESS environment
+        # variable set.
+        if options.python and "_PIP_RUNNING_IN_SUBPROCESS" not in os.environ:
+            logger.critical(
+                "The --python option must be placed before the pip subcommand name"
+            )
+            sys.exit(ERROR)
+
+        # TODO: Try to get these passing down from the command?
+        #       without resorting to os.environ to hold these.
+        #       This also affects isolated builds and it should.
+
+        if options.no_input:
+            os.environ["PIP_NO_INPUT"] = "1"
+
+        if options.exists_action:
+            os.environ["PIP_EXISTS_ACTION"] = " ".join(options.exists_action)
+
+        if options.require_venv and not self.ignore_require_venv:
+            # If a venv is required check if it can really be found
+            if not running_under_virtualenv():
+                logger.critical("Could not find an activated virtualenv (required).")
+                sys.exit(VIRTUALENV_NOT_FOUND)
+
+        if options.cache_dir:
+            options.cache_dir = normalize_path(options.cache_dir)
+            if not check_path_owner(options.cache_dir):
+                logger.warning(
+                    "The directory '%s' or its parent directory is not owned "
+                    "or is not writable by the current user. The cache "
+                    "has been disabled. Check the permissions and owner of "
+                    "that directory. If executing pip with sudo, you should "
+                    "use sudo's -H flag.",
+                    options.cache_dir,
+                )
+                options.cache_dir = None
+
+        return self._run_wrapper(level_number, options, args)
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/cli/cmdoptions.py b/venv/lib/python3.12/site-packages/pip/_internal/cli/cmdoptions.py
new file mode 100644
index 00000000..0b7cff77
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/cli/cmdoptions.py
@@ -0,0 +1,1075 @@
+"""
+shared options and groups
+
+The principle here is to define options once, but *not* instantiate them
+globally. One reason being that options with action='append' can carry state
+between parses. pip parses general options twice internally, and shouldn't
+pass on state. To be consistent, all options will follow this design.
+"""
+
+# The following comment should be removed at some point in the future.
+# mypy: strict-optional=False
+
+import importlib.util
+import logging
+import os
+import textwrap
+from functools import partial
+from optparse import SUPPRESS_HELP, Option, OptionGroup, OptionParser, Values
+from textwrap import dedent
+from typing import Any, Callable, Dict, Optional, Tuple
+
+from pip._vendor.packaging.utils import canonicalize_name
+
+from pip._internal.cli.parser import ConfigOptionParser
+from pip._internal.exceptions import CommandError
+from pip._internal.locations import USER_CACHE_DIR, get_src_prefix
+from pip._internal.models.format_control import FormatControl
+from pip._internal.models.index import PyPI
+from pip._internal.models.target_python import TargetPython
+from pip._internal.utils.hashes import STRONG_HASHES
+from pip._internal.utils.misc import strtobool
+
+logger = logging.getLogger(__name__)
+
+
+def raise_option_error(parser: OptionParser, option: Option, msg: str) -> None:
+    """
+    Raise an option parsing error using parser.error().
+
+    Args:
+      parser: an OptionParser instance.
+      option: an Option instance.
+      msg: the error text.
+    """
+    msg = f"{option} error: {msg}"
+    msg = textwrap.fill(" ".join(msg.split()))
+    parser.error(msg)
+
+
+def make_option_group(group: Dict[str, Any], parser: ConfigOptionParser) -> OptionGroup:
+    """
+    Return an OptionGroup object
+    group  -- assumed to be dict with 'name' and 'options' keys
+    parser -- an optparse Parser
+    """
+    option_group = OptionGroup(parser, group["name"])
+    for option in group["options"]:
+        option_group.add_option(option())
+    return option_group
+
+
+def check_dist_restriction(options: Values, check_target: bool = False) -> None:
+    """Function for determining if custom platform options are allowed.
+
+    :param options: The OptionParser options.
+    :param check_target: Whether or not to check if --target is being used.
+    """
+    dist_restriction_set = any(
+        [
+            options.python_version,
+            options.platforms,
+            options.abis,
+            options.implementation,
+        ]
+    )
+
+    binary_only = FormatControl(set(), {":all:"})
+    sdist_dependencies_allowed = (
+        options.format_control != binary_only and not options.ignore_dependencies
+    )
+
+    # Installations or downloads using dist restrictions must not combine
+    # source distributions and dist-specific wheels, as they are not
+    # guaranteed to be locally compatible.
+    if dist_restriction_set and sdist_dependencies_allowed:
+        raise CommandError(
+            "When restricting platform and interpreter constraints using "
+            "--python-version, --platform, --abi, or --implementation, "
+            "either --no-deps must be set, or --only-binary=:all: must be "
+            "set and --no-binary must not be set (or must be set to "
+            ":none:)."
+        )
+
+    if check_target:
+        if not options.dry_run and dist_restriction_set and not options.target_dir:
+            raise CommandError(
+                "Can not use any platform or abi specific options unless "
+                "installing via '--target' or using '--dry-run'"
+            )
+
+
+def _path_option_check(option: Option, opt: str, value: str) -> str:
+    return os.path.expanduser(value)
+
+
+def _package_name_option_check(option: Option, opt: str, value: str) -> str:
+    return canonicalize_name(value)
+
+
+class PipOption(Option):
+    TYPES = Option.TYPES + ("path", "package_name")
+    TYPE_CHECKER = Option.TYPE_CHECKER.copy()
+    TYPE_CHECKER["package_name"] = _package_name_option_check
+    TYPE_CHECKER["path"] = _path_option_check
+
+
+###########
+# options #
+###########
+
+help_: Callable[..., Option] = partial(
+    Option,
+    "-h",
+    "--help",
+    dest="help",
+    action="help",
+    help="Show help.",
+)
+
+debug_mode: Callable[..., Option] = partial(
+    Option,
+    "--debug",
+    dest="debug_mode",
+    action="store_true",
+    default=False,
+    help=(
+        "Let unhandled exceptions propagate outside the main subroutine, "
+        "instead of logging them to stderr."
+    ),
+)
+
+isolated_mode: Callable[..., Option] = partial(
+    Option,
+    "--isolated",
+    dest="isolated_mode",
+    action="store_true",
+    default=False,
+    help=(
+        "Run pip in an isolated mode, ignoring environment variables and user "
+        "configuration."
+    ),
+)
+
+require_virtualenv: Callable[..., Option] = partial(
+    Option,
+    "--require-virtualenv",
+    "--require-venv",
+    dest="require_venv",
+    action="store_true",
+    default=False,
+    help=(
+        "Allow pip to only run in a virtual environment; "
+        "exit with an error otherwise."
+    ),
+)
+
+override_externally_managed: Callable[..., Option] = partial(
+    Option,
+    "--break-system-packages",
+    dest="override_externally_managed",
+    action="store_true",
+    help="Allow pip to modify an EXTERNALLY-MANAGED Python installation",
+)
+
+python: Callable[..., Option] = partial(
+    Option,
+    "--python",
+    dest="python",
+    help="Run pip with the specified Python interpreter.",
+)
+
+verbose: Callable[..., Option] = partial(
+    Option,
+    "-v",
+    "--verbose",
+    dest="verbose",
+    action="count",
+    default=0,
+    help="Give more output. Option is additive, and can be used up to 3 times.",
+)
+
+no_color: Callable[..., Option] = partial(
+    Option,
+    "--no-color",
+    dest="no_color",
+    action="store_true",
+    default=False,
+    help="Suppress colored output.",
+)
+
+version: Callable[..., Option] = partial(
+    Option,
+    "-V",
+    "--version",
+    dest="version",
+    action="store_true",
+    help="Show version and exit.",
+)
+
+quiet: Callable[..., Option] = partial(
+    Option,
+    "-q",
+    "--quiet",
+    dest="quiet",
+    action="count",
+    default=0,
+    help=(
+        "Give less output. Option is additive, and can be used up to 3"
+        " times (corresponding to WARNING, ERROR, and CRITICAL logging"
+        " levels)."
+    ),
+)
+
+progress_bar: Callable[..., Option] = partial(
+    Option,
+    "--progress-bar",
+    dest="progress_bar",
+    type="choice",
+    choices=["on", "off", "raw"],
+    default="on",
+    help="Specify whether the progress bar should be used [on, off, raw] (default: on)",
+)
+
+log: Callable[..., Option] = partial(
+    PipOption,
+    "--log",
+    "--log-file",
+    "--local-log",
+    dest="log",
+    metavar="path",
+    type="path",
+    help="Path to a verbose appending log.",
+)
+
+no_input: Callable[..., Option] = partial(
+    Option,
+    # Don't ask for input
+    "--no-input",
+    dest="no_input",
+    action="store_true",
+    default=False,
+    help="Disable prompting for input.",
+)
+
+keyring_provider: Callable[..., Option] = partial(
+    Option,
+    "--keyring-provider",
+    dest="keyring_provider",
+    choices=["auto", "disabled", "import", "subprocess"],
+    default="auto",
+    help=(
+        "Enable the credential lookup via the keyring library if user input is allowed."
+        " Specify which mechanism to use [disabled, import, subprocess]."
+        " (default: disabled)"
+    ),
+)
+
+proxy: Callable[..., Option] = partial(
+    Option,
+    "--proxy",
+    dest="proxy",
+    type="str",
+    default="",
+    help="Specify a proxy in the form scheme://[user:passwd@]proxy.server:port.",
+)
+
+retries: Callable[..., Option] = partial(
+    Option,
+    "--retries",
+    dest="retries",
+    type="int",
+    default=5,
+    help="Maximum number of retries each connection should attempt "
+    "(default %default times).",
+)
+
+timeout: Callable[..., Option] = partial(
+    Option,
+    "--timeout",
+    "--default-timeout",
+    metavar="sec",
+    dest="timeout",
+    type="float",
+    default=15,
+    help="Set the socket timeout (default %default seconds).",
+)
+
+
+def exists_action() -> Option:
+    return Option(
+        # Option when path already exist
+        "--exists-action",
+        dest="exists_action",
+        type="choice",
+        choices=["s", "i", "w", "b", "a"],
+        default=[],
+        action="append",
+        metavar="action",
+        help="Default action when a path already exists: "
+        "(s)witch, (i)gnore, (w)ipe, (b)ackup, (a)bort.",
+    )
+
+
+cert: Callable[..., Option] = partial(
+    PipOption,
+    "--cert",
+    dest="cert",
+    type="path",
+    metavar="path",
+    help=(
+        "Path to PEM-encoded CA certificate bundle. "
+        "If provided, overrides the default. "
+        "See 'SSL Certificate Verification' in pip documentation "
+        "for more information."
+    ),
+)
+
+client_cert: Callable[..., Option] = partial(
+    PipOption,
+    "--client-cert",
+    dest="client_cert",
+    type="path",
+    default=None,
+    metavar="path",
+    help="Path to SSL client certificate, a single file containing the "
+    "private key and the certificate in PEM format.",
+)
+
+index_url: Callable[..., Option] = partial(
+    Option,
+    "-i",
+    "--index-url",
+    "--pypi-url",
+    dest="index_url",
+    metavar="URL",
+    default=PyPI.simple_url,
+    help="Base URL of the Python Package Index (default %default). "
+    "This should point to a repository compliant with PEP 503 "
+    "(the simple repository API) or a local directory laid out "
+    "in the same format.",
+)
+
+
+def extra_index_url() -> Option:
+    return Option(
+        "--extra-index-url",
+        dest="extra_index_urls",
+        metavar="URL",
+        action="append",
+        default=[],
+        help="Extra URLs of package indexes to use in addition to "
+        "--index-url. Should follow the same rules as "
+        "--index-url.",
+    )
+
+
+no_index: Callable[..., Option] = partial(
+    Option,
+    "--no-index",
+    dest="no_index",
+    action="store_true",
+    default=False,
+    help="Ignore package index (only looking at --find-links URLs instead).",
+)
+
+
+def find_links() -> Option:
+    return Option(
+        "-f",
+        "--find-links",
+        dest="find_links",
+        action="append",
+        default=[],
+        metavar="url",
+        help="If a URL or path to an html file, then parse for links to "
+        "archives such as sdist (.tar.gz) or wheel (.whl) files. "
+        "If a local path or file:// URL that's a directory, "
+        "then look for archives in the directory listing. "
+        "Links to VCS project URLs are not supported.",
+    )
+
+
+def trusted_host() -> Option:
+    return Option(
+        "--trusted-host",
+        dest="trusted_hosts",
+        action="append",
+        metavar="HOSTNAME",
+        default=[],
+        help="Mark this host or host:port pair as trusted, even though it "
+        "does not have valid or any HTTPS.",
+    )
+
+
+def constraints() -> Option:
+    return Option(
+        "-c",
+        "--constraint",
+        dest="constraints",
+        action="append",
+        default=[],
+        metavar="file",
+        help="Constrain versions using the given constraints file. "
+        "This option can be used multiple times.",
+    )
+
+
+def requirements() -> Option:
+    return Option(
+        "-r",
+        "--requirement",
+        dest="requirements",
+        action="append",
+        default=[],
+        metavar="file",
+        help="Install from the given requirements file. "
+        "This option can be used multiple times.",
+    )
+
+
+def editable() -> Option:
+    return Option(
+        "-e",
+        "--editable",
+        dest="editables",
+        action="append",
+        default=[],
+        metavar="path/url",
+        help=(
+            "Install a project in editable mode (i.e. setuptools "
+            '"develop mode") from a local project path or a VCS url.'
+        ),
+    )
+
+
+def _handle_src(option: Option, opt_str: str, value: str, parser: OptionParser) -> None:
+    value = os.path.abspath(value)
+    setattr(parser.values, option.dest, value)
+
+
+src: Callable[..., Option] = partial(
+    PipOption,
+    "--src",
+    "--source",
+    "--source-dir",
+    "--source-directory",
+    dest="src_dir",
+    type="path",
+    metavar="dir",
+    default=get_src_prefix(),
+    action="callback",
+    callback=_handle_src,
+    help="Directory to check out editable projects into. "
+    'The default in a virtualenv is "/src". '
+    'The default for global installs is "/src".',
+)
+
+
+def _get_format_control(values: Values, option: Option) -> Any:
+    """Get a format_control object."""
+    return getattr(values, option.dest)
+
+
+def _handle_no_binary(
+    option: Option, opt_str: str, value: str, parser: OptionParser
+) -> None:
+    existing = _get_format_control(parser.values, option)
+    FormatControl.handle_mutual_excludes(
+        value,
+        existing.no_binary,
+        existing.only_binary,
+    )
+
+
+def _handle_only_binary(
+    option: Option, opt_str: str, value: str, parser: OptionParser
+) -> None:
+    existing = _get_format_control(parser.values, option)
+    FormatControl.handle_mutual_excludes(
+        value,
+        existing.only_binary,
+        existing.no_binary,
+    )
+
+
+def no_binary() -> Option:
+    format_control = FormatControl(set(), set())
+    return Option(
+        "--no-binary",
+        dest="format_control",
+        action="callback",
+        callback=_handle_no_binary,
+        type="str",
+        default=format_control,
+        help="Do not use binary packages. Can be supplied multiple times, and "
+        'each time adds to the existing value. Accepts either ":all:" to '
+        'disable all binary packages, ":none:" to empty the set (notice '
+        "the colons), or one or more package names with commas between "
+        "them (no colons). Note that some packages are tricky to compile "
+        "and may fail to install when this option is used on them.",
+    )
+
+
+def only_binary() -> Option:
+    format_control = FormatControl(set(), set())
+    return Option(
+        "--only-binary",
+        dest="format_control",
+        action="callback",
+        callback=_handle_only_binary,
+        type="str",
+        default=format_control,
+        help="Do not use source packages. Can be supplied multiple times, and "
+        'each time adds to the existing value. Accepts either ":all:" to '
+        'disable all source packages, ":none:" to empty the set, or one '
+        "or more package names with commas between them. Packages "
+        "without binary distributions will fail to install when this "
+        "option is used on them.",
+    )
+
+
+platforms: Callable[..., Option] = partial(
+    Option,
+    "--platform",
+    dest="platforms",
+    metavar="platform",
+    action="append",
+    default=None,
+    help=(
+        "Only use wheels compatible with . Defaults to the "
+        "platform of the running system. Use this option multiple times to "
+        "specify multiple platforms supported by the target interpreter."
+    ),
+)
+
+
+# This was made a separate function for unit-testing purposes.
+def _convert_python_version(value: str) -> Tuple[Tuple[int, ...], Optional[str]]:
+    """
+    Convert a version string like "3", "37", or "3.7.3" into a tuple of ints.
+
+    :return: A 2-tuple (version_info, error_msg), where `error_msg` is
+        non-None if and only if there was a parsing error.
+    """
+    if not value:
+        # The empty string is the same as not providing a value.
+        return (None, None)
+
+    parts = value.split(".")
+    if len(parts) > 3:
+        return ((), "at most three version parts are allowed")
+
+    if len(parts) == 1:
+        # Then we are in the case of "3" or "37".
+        value = parts[0]
+        if len(value) > 1:
+            parts = [value[0], value[1:]]
+
+    try:
+        version_info = tuple(int(part) for part in parts)
+    except ValueError:
+        return ((), "each version part must be an integer")
+
+    return (version_info, None)
+
+
+def _handle_python_version(
+    option: Option, opt_str: str, value: str, parser: OptionParser
+) -> None:
+    """
+    Handle a provided --python-version value.
+    """
+    version_info, error_msg = _convert_python_version(value)
+    if error_msg is not None:
+        msg = f"invalid --python-version value: {value!r}: {error_msg}"
+        raise_option_error(parser, option=option, msg=msg)
+
+    parser.values.python_version = version_info
+
+
+python_version: Callable[..., Option] = partial(
+    Option,
+    "--python-version",
+    dest="python_version",
+    metavar="python_version",
+    action="callback",
+    callback=_handle_python_version,
+    type="str",
+    default=None,
+    help=dedent(
+        """\
+    The Python interpreter version to use for wheel and "Requires-Python"
+    compatibility checks. Defaults to a version derived from the running
+    interpreter. The version can be specified using up to three dot-separated
+    integers (e.g. "3" for 3.0.0, "3.7" for 3.7.0, or "3.7.3"). A major-minor
+    version can also be given as a string without dots (e.g. "37" for 3.7.0).
+    """
+    ),
+)
+
+
+implementation: Callable[..., Option] = partial(
+    Option,
+    "--implementation",
+    dest="implementation",
+    metavar="implementation",
+    default=None,
+    help=(
+        "Only use wheels compatible with Python "
+        "implementation , e.g. 'pp', 'jy', 'cp', "
+        " or 'ip'. If not specified, then the current "
+        "interpreter implementation is used.  Use 'py' to force "
+        "implementation-agnostic wheels."
+    ),
+)
+
+
+abis: Callable[..., Option] = partial(
+    Option,
+    "--abi",
+    dest="abis",
+    metavar="abi",
+    action="append",
+    default=None,
+    help=(
+        "Only use wheels compatible with Python abi , e.g. 'pypy_41'. "
+        "If not specified, then the current interpreter abi tag is used. "
+        "Use this option multiple times to specify multiple abis supported "
+        "by the target interpreter. Generally you will need to specify "
+        "--implementation, --platform, and --python-version when using this "
+        "option."
+    ),
+)
+
+
+def add_target_python_options(cmd_opts: OptionGroup) -> None:
+    cmd_opts.add_option(platforms())
+    cmd_opts.add_option(python_version())
+    cmd_opts.add_option(implementation())
+    cmd_opts.add_option(abis())
+
+
+def make_target_python(options: Values) -> TargetPython:
+    target_python = TargetPython(
+        platforms=options.platforms,
+        py_version_info=options.python_version,
+        abis=options.abis,
+        implementation=options.implementation,
+    )
+
+    return target_python
+
+
+def prefer_binary() -> Option:
+    return Option(
+        "--prefer-binary",
+        dest="prefer_binary",
+        action="store_true",
+        default=False,
+        help=(
+            "Prefer binary packages over source packages, even if the "
+            "source packages are newer."
+        ),
+    )
+
+
+cache_dir: Callable[..., Option] = partial(
+    PipOption,
+    "--cache-dir",
+    dest="cache_dir",
+    default=USER_CACHE_DIR,
+    metavar="dir",
+    type="path",
+    help="Store the cache data in .",
+)
+
+
+def _handle_no_cache_dir(
+    option: Option, opt: str, value: str, parser: OptionParser
+) -> None:
+    """
+    Process a value provided for the --no-cache-dir option.
+
+    This is an optparse.Option callback for the --no-cache-dir option.
+    """
+    # The value argument will be None if --no-cache-dir is passed via the
+    # command-line, since the option doesn't accept arguments.  However,
+    # the value can be non-None if the option is triggered e.g. by an
+    # environment variable, like PIP_NO_CACHE_DIR=true.
+    if value is not None:
+        # Then parse the string value to get argument error-checking.
+        try:
+            strtobool(value)
+        except ValueError as exc:
+            raise_option_error(parser, option=option, msg=str(exc))
+
+    # Originally, setting PIP_NO_CACHE_DIR to a value that strtobool()
+    # converted to 0 (like "false" or "no") caused cache_dir to be disabled
+    # rather than enabled (logic would say the latter).  Thus, we disable
+    # the cache directory not just on values that parse to True, but (for
+    # backwards compatibility reasons) also on values that parse to False.
+    # In other words, always set it to False if the option is provided in
+    # some (valid) form.
+    parser.values.cache_dir = False
+
+
+no_cache: Callable[..., Option] = partial(
+    Option,
+    "--no-cache-dir",
+    dest="cache_dir",
+    action="callback",
+    callback=_handle_no_cache_dir,
+    help="Disable the cache.",
+)
+
+no_deps: Callable[..., Option] = partial(
+    Option,
+    "--no-deps",
+    "--no-dependencies",
+    dest="ignore_dependencies",
+    action="store_true",
+    default=False,
+    help="Don't install package dependencies.",
+)
+
+ignore_requires_python: Callable[..., Option] = partial(
+    Option,
+    "--ignore-requires-python",
+    dest="ignore_requires_python",
+    action="store_true",
+    help="Ignore the Requires-Python information.",
+)
+
+no_build_isolation: Callable[..., Option] = partial(
+    Option,
+    "--no-build-isolation",
+    dest="build_isolation",
+    action="store_false",
+    default=True,
+    help="Disable isolation when building a modern source distribution. "
+    "Build dependencies specified by PEP 518 must be already installed "
+    "if this option is used.",
+)
+
+check_build_deps: Callable[..., Option] = partial(
+    Option,
+    "--check-build-dependencies",
+    dest="check_build_deps",
+    action="store_true",
+    default=False,
+    help="Check the build dependencies when PEP517 is used.",
+)
+
+
+def _handle_no_use_pep517(
+    option: Option, opt: str, value: str, parser: OptionParser
+) -> None:
+    """
+    Process a value provided for the --no-use-pep517 option.
+
+    This is an optparse.Option callback for the no_use_pep517 option.
+    """
+    # Since --no-use-pep517 doesn't accept arguments, the value argument
+    # will be None if --no-use-pep517 is passed via the command-line.
+    # However, the value can be non-None if the option is triggered e.g.
+    # by an environment variable, for example "PIP_NO_USE_PEP517=true".
+    if value is not None:
+        msg = """A value was passed for --no-use-pep517,
+        probably using either the PIP_NO_USE_PEP517 environment variable
+        or the "no-use-pep517" config file option. Use an appropriate value
+        of the PIP_USE_PEP517 environment variable or the "use-pep517"
+        config file option instead.
+        """
+        raise_option_error(parser, option=option, msg=msg)
+
+    # If user doesn't wish to use pep517, we check if setuptools and wheel are installed
+    # and raise error if it is not.
+    packages = ("setuptools", "wheel")
+    if not all(importlib.util.find_spec(package) for package in packages):
+        msg = (
+            f"It is not possible to use --no-use-pep517 "
+            f"without {' and '.join(packages)} installed."
+        )
+        raise_option_error(parser, option=option, msg=msg)
+
+    # Otherwise, --no-use-pep517 was passed via the command-line.
+    parser.values.use_pep517 = False
+
+
+use_pep517: Any = partial(
+    Option,
+    "--use-pep517",
+    dest="use_pep517",
+    action="store_true",
+    default=None,
+    help="Use PEP 517 for building source distributions "
+    "(use --no-use-pep517 to force legacy behaviour).",
+)
+
+no_use_pep517: Any = partial(
+    Option,
+    "--no-use-pep517",
+    dest="use_pep517",
+    action="callback",
+    callback=_handle_no_use_pep517,
+    default=None,
+    help=SUPPRESS_HELP,
+)
+
+
+def _handle_config_settings(
+    option: Option, opt_str: str, value: str, parser: OptionParser
+) -> None:
+    key, sep, val = value.partition("=")
+    if sep != "=":
+        parser.error(f"Arguments to {opt_str} must be of the form KEY=VAL")
+    dest = getattr(parser.values, option.dest)
+    if dest is None:
+        dest = {}
+        setattr(parser.values, option.dest, dest)
+    if key in dest:
+        if isinstance(dest[key], list):
+            dest[key].append(val)
+        else:
+            dest[key] = [dest[key], val]
+    else:
+        dest[key] = val
+
+
+config_settings: Callable[..., Option] = partial(
+    Option,
+    "-C",
+    "--config-settings",
+    dest="config_settings",
+    type=str,
+    action="callback",
+    callback=_handle_config_settings,
+    metavar="settings",
+    help="Configuration settings to be passed to the PEP 517 build backend. "
+    "Settings take the form KEY=VALUE. Use multiple --config-settings options "
+    "to pass multiple keys to the backend.",
+)
+
+build_options: Callable[..., Option] = partial(
+    Option,
+    "--build-option",
+    dest="build_options",
+    metavar="options",
+    action="append",
+    help="Extra arguments to be supplied to 'setup.py bdist_wheel'.",
+)
+
+global_options: Callable[..., Option] = partial(
+    Option,
+    "--global-option",
+    dest="global_options",
+    action="append",
+    metavar="options",
+    help="Extra global options to be supplied to the setup.py "
+    "call before the install or bdist_wheel command.",
+)
+
+no_clean: Callable[..., Option] = partial(
+    Option,
+    "--no-clean",
+    action="store_true",
+    default=False,
+    help="Don't clean up build directories.",
+)
+
+pre: Callable[..., Option] = partial(
+    Option,
+    "--pre",
+    action="store_true",
+    default=False,
+    help="Include pre-release and development versions. By default, "
+    "pip only finds stable versions.",
+)
+
+disable_pip_version_check: Callable[..., Option] = partial(
+    Option,
+    "--disable-pip-version-check",
+    dest="disable_pip_version_check",
+    action="store_true",
+    default=False,
+    help="Don't periodically check PyPI to determine whether a new version "
+    "of pip is available for download. Implied with --no-index.",
+)
+
+root_user_action: Callable[..., Option] = partial(
+    Option,
+    "--root-user-action",
+    dest="root_user_action",
+    default="warn",
+    choices=["warn", "ignore"],
+    help="Action if pip is run as a root user [warn, ignore] (default: warn)",
+)
+
+
+def _handle_merge_hash(
+    option: Option, opt_str: str, value: str, parser: OptionParser
+) -> None:
+    """Given a value spelled "algo:digest", append the digest to a list
+    pointed to in a dict by the algo name."""
+    if not parser.values.hashes:
+        parser.values.hashes = {}
+    try:
+        algo, digest = value.split(":", 1)
+    except ValueError:
+        parser.error(
+            f"Arguments to {opt_str} must be a hash name "
+            "followed by a value, like --hash=sha256:"
+            "abcde..."
+        )
+    if algo not in STRONG_HASHES:
+        parser.error(
+            "Allowed hash algorithms for {} are {}.".format(
+                opt_str, ", ".join(STRONG_HASHES)
+            )
+        )
+    parser.values.hashes.setdefault(algo, []).append(digest)
+
+
+hash: Callable[..., Option] = partial(
+    Option,
+    "--hash",
+    # Hash values eventually end up in InstallRequirement.hashes due to
+    # __dict__ copying in process_line().
+    dest="hashes",
+    action="callback",
+    callback=_handle_merge_hash,
+    type="string",
+    help="Verify that the package's archive matches this "
+    "hash before installing. Example: --hash=sha256:abcdef...",
+)
+
+
+require_hashes: Callable[..., Option] = partial(
+    Option,
+    "--require-hashes",
+    dest="require_hashes",
+    action="store_true",
+    default=False,
+    help="Require a hash to check each requirement against, for "
+    "repeatable installs. This option is implied when any package in a "
+    "requirements file has a --hash option.",
+)
+
+
+list_path: Callable[..., Option] = partial(
+    PipOption,
+    "--path",
+    dest="path",
+    type="path",
+    action="append",
+    help="Restrict to the specified installation path for listing "
+    "packages (can be used multiple times).",
+)
+
+
+def check_list_path_option(options: Values) -> None:
+    if options.path and (options.user or options.local):
+        raise CommandError("Cannot combine '--path' with '--user' or '--local'")
+
+
+list_exclude: Callable[..., Option] = partial(
+    PipOption,
+    "--exclude",
+    dest="excludes",
+    action="append",
+    metavar="package",
+    type="package_name",
+    help="Exclude specified package from the output",
+)
+
+
+no_python_version_warning: Callable[..., Option] = partial(
+    Option,
+    "--no-python-version-warning",
+    dest="no_python_version_warning",
+    action="store_true",
+    default=False,
+    help="Silence deprecation warnings for upcoming unsupported Pythons.",
+)
+
+
+# Features that are now always on. A warning is printed if they are used.
+ALWAYS_ENABLED_FEATURES = [
+    "truststore",  # always on since 24.2
+    "no-binary-enable-wheel-cache",  # always on since 23.1
+]
+
+use_new_feature: Callable[..., Option] = partial(
+    Option,
+    "--use-feature",
+    dest="features_enabled",
+    metavar="feature",
+    action="append",
+    default=[],
+    choices=[
+        "fast-deps",
+    ]
+    + ALWAYS_ENABLED_FEATURES,
+    help="Enable new functionality, that may be backward incompatible.",
+)
+
+use_deprecated_feature: Callable[..., Option] = partial(
+    Option,
+    "--use-deprecated",
+    dest="deprecated_features_enabled",
+    metavar="feature",
+    action="append",
+    default=[],
+    choices=[
+        "legacy-resolver",
+        "legacy-certs",
+    ],
+    help=("Enable deprecated functionality, that will be removed in the future."),
+)
+
+
+##########
+# groups #
+##########
+
+general_group: Dict[str, Any] = {
+    "name": "General Options",
+    "options": [
+        help_,
+        debug_mode,
+        isolated_mode,
+        require_virtualenv,
+        python,
+        verbose,
+        version,
+        quiet,
+        log,
+        no_input,
+        keyring_provider,
+        proxy,
+        retries,
+        timeout,
+        exists_action,
+        trusted_host,
+        cert,
+        client_cert,
+        cache_dir,
+        no_cache,
+        disable_pip_version_check,
+        no_color,
+        no_python_version_warning,
+        use_new_feature,
+        use_deprecated_feature,
+    ],
+}
+
+index_group: Dict[str, Any] = {
+    "name": "Package Index Options",
+    "options": [
+        index_url,
+        extra_index_url,
+        no_index,
+        find_links,
+    ],
+}
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/cli/command_context.py b/venv/lib/python3.12/site-packages/pip/_internal/cli/command_context.py
new file mode 100644
index 00000000..139995ac
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/cli/command_context.py
@@ -0,0 +1,27 @@
+from contextlib import ExitStack, contextmanager
+from typing import ContextManager, Generator, TypeVar
+
+_T = TypeVar("_T", covariant=True)
+
+
+class CommandContextMixIn:
+    def __init__(self) -> None:
+        super().__init__()
+        self._in_main_context = False
+        self._main_context = ExitStack()
+
+    @contextmanager
+    def main_context(self) -> Generator[None, None, None]:
+        assert not self._in_main_context
+
+        self._in_main_context = True
+        try:
+            with self._main_context:
+                yield
+        finally:
+            self._in_main_context = False
+
+    def enter_context(self, context_provider: ContextManager[_T]) -> _T:
+        assert self._in_main_context
+
+        return self._main_context.enter_context(context_provider)
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/cli/index_command.py b/venv/lib/python3.12/site-packages/pip/_internal/cli/index_command.py
new file mode 100644
index 00000000..226f8da1
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/cli/index_command.py
@@ -0,0 +1,170 @@
+"""
+Contains command classes which may interact with an index / the network.
+
+Unlike its sister module, req_command, this module still uses lazy imports
+so commands which don't always hit the network (e.g. list w/o --outdated or
+--uptodate) don't need waste time importing PipSession and friends.
+"""
+
+import logging
+import os
+import sys
+from optparse import Values
+from typing import TYPE_CHECKING, List, Optional
+
+from pip._vendor import certifi
+
+from pip._internal.cli.base_command import Command
+from pip._internal.cli.command_context import CommandContextMixIn
+
+if TYPE_CHECKING:
+    from ssl import SSLContext
+
+    from pip._internal.network.session import PipSession
+
+logger = logging.getLogger(__name__)
+
+
+def _create_truststore_ssl_context() -> Optional["SSLContext"]:
+    if sys.version_info < (3, 10):
+        logger.debug("Disabling truststore because Python version isn't 3.10+")
+        return None
+
+    try:
+        import ssl
+    except ImportError:
+        logger.warning("Disabling truststore since ssl support is missing")
+        return None
+
+    try:
+        from pip._vendor import truststore
+    except ImportError:
+        logger.warning("Disabling truststore because platform isn't supported")
+        return None
+
+    ctx = truststore.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
+    ctx.load_verify_locations(certifi.where())
+    return ctx
+
+
+class SessionCommandMixin(CommandContextMixIn):
+    """
+    A class mixin for command classes needing _build_session().
+    """
+
+    def __init__(self) -> None:
+        super().__init__()
+        self._session: Optional["PipSession"] = None
+
+    @classmethod
+    def _get_index_urls(cls, options: Values) -> Optional[List[str]]:
+        """Return a list of index urls from user-provided options."""
+        index_urls = []
+        if not getattr(options, "no_index", False):
+            url = getattr(options, "index_url", None)
+            if url:
+                index_urls.append(url)
+        urls = getattr(options, "extra_index_urls", None)
+        if urls:
+            index_urls.extend(urls)
+        # Return None rather than an empty list
+        return index_urls or None
+
+    def get_default_session(self, options: Values) -> "PipSession":
+        """Get a default-managed session."""
+        if self._session is None:
+            self._session = self.enter_context(self._build_session(options))
+            # there's no type annotation on requests.Session, so it's
+            # automatically ContextManager[Any] and self._session becomes Any,
+            # then https://github.com/python/mypy/issues/7696 kicks in
+            assert self._session is not None
+        return self._session
+
+    def _build_session(
+        self,
+        options: Values,
+        retries: Optional[int] = None,
+        timeout: Optional[int] = None,
+    ) -> "PipSession":
+        from pip._internal.network.session import PipSession
+
+        cache_dir = options.cache_dir
+        assert not cache_dir or os.path.isabs(cache_dir)
+
+        if "legacy-certs" not in options.deprecated_features_enabled:
+            ssl_context = _create_truststore_ssl_context()
+        else:
+            ssl_context = None
+
+        session = PipSession(
+            cache=os.path.join(cache_dir, "http-v2") if cache_dir else None,
+            retries=retries if retries is not None else options.retries,
+            trusted_hosts=options.trusted_hosts,
+            index_urls=self._get_index_urls(options),
+            ssl_context=ssl_context,
+        )
+
+        # Handle custom ca-bundles from the user
+        if options.cert:
+            session.verify = options.cert
+
+        # Handle SSL client certificate
+        if options.client_cert:
+            session.cert = options.client_cert
+
+        # Handle timeouts
+        if options.timeout or timeout:
+            session.timeout = timeout if timeout is not None else options.timeout
+
+        # Handle configured proxies
+        if options.proxy:
+            session.proxies = {
+                "http": options.proxy,
+                "https": options.proxy,
+            }
+            session.trust_env = False
+
+        # Determine if we can prompt the user for authentication or not
+        session.auth.prompting = not options.no_input
+        session.auth.keyring_provider = options.keyring_provider
+
+        return session
+
+
+def _pip_self_version_check(session: "PipSession", options: Values) -> None:
+    from pip._internal.self_outdated_check import pip_self_version_check as check
+
+    check(session, options)
+
+
+class IndexGroupCommand(Command, SessionCommandMixin):
+    """
+    Abstract base class for commands with the index_group options.
+
+    This also corresponds to the commands that permit the pip version check.
+    """
+
+    def handle_pip_version_check(self, options: Values) -> None:
+        """
+        Do the pip version check if not disabled.
+
+        This overrides the default behavior of not doing the check.
+        """
+        # Make sure the index_group options are present.
+        assert hasattr(options, "no_index")
+
+        if options.disable_pip_version_check or options.no_index:
+            return
+
+        try:
+            # Otherwise, check if we're using the latest version of pip available.
+            session = self._build_session(
+                options,
+                retries=0,
+                timeout=min(5, options.timeout),
+            )
+            with session:
+                _pip_self_version_check(session, options)
+        except Exception:
+            logger.warning("There was an error checking the latest version of pip.")
+            logger.debug("See below for error", exc_info=True)
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/cli/main.py b/venv/lib/python3.12/site-packages/pip/_internal/cli/main.py
new file mode 100644
index 00000000..563ac79c
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/cli/main.py
@@ -0,0 +1,80 @@
+"""Primary application entrypoint.
+"""
+
+import locale
+import logging
+import os
+import sys
+import warnings
+from typing import List, Optional
+
+from pip._internal.cli.autocompletion import autocomplete
+from pip._internal.cli.main_parser import parse_command
+from pip._internal.commands import create_command
+from pip._internal.exceptions import PipError
+from pip._internal.utils import deprecation
+
+logger = logging.getLogger(__name__)
+
+
+# Do not import and use main() directly! Using it directly is actively
+# discouraged by pip's maintainers. The name, location and behavior of
+# this function is subject to change, so calling it directly is not
+# portable across different pip versions.
+
+# In addition, running pip in-process is unsupported and unsafe. This is
+# elaborated in detail at
+# https://pip.pypa.io/en/stable/user_guide/#using-pip-from-your-program.
+# That document also provides suggestions that should work for nearly
+# all users that are considering importing and using main() directly.
+
+# However, we know that certain users will still want to invoke pip
+# in-process. If you understand and accept the implications of using pip
+# in an unsupported manner, the best approach is to use runpy to avoid
+# depending on the exact location of this entry point.
+
+# The following example shows how to use runpy to invoke pip in that
+# case:
+#
+#     sys.argv = ["pip", your, args, here]
+#     runpy.run_module("pip", run_name="__main__")
+#
+# Note that this will exit the process after running, unlike a direct
+# call to main. As it is not safe to do any processing after calling
+# main, this should not be an issue in practice.
+
+
+def main(args: Optional[List[str]] = None) -> int:
+    if args is None:
+        args = sys.argv[1:]
+
+    # Suppress the pkg_resources deprecation warning
+    # Note - we use a module of .*pkg_resources to cover
+    # the normal case (pip._vendor.pkg_resources) and the
+    # devendored case (a bare pkg_resources)
+    warnings.filterwarnings(
+        action="ignore", category=DeprecationWarning, module=".*pkg_resources"
+    )
+
+    # Configure our deprecation warnings to be sent through loggers
+    deprecation.install_warning_logger()
+
+    autocomplete()
+
+    try:
+        cmd_name, cmd_args = parse_command(args)
+    except PipError as exc:
+        sys.stderr.write(f"ERROR: {exc}")
+        sys.stderr.write(os.linesep)
+        sys.exit(1)
+
+    # Needed for locale.getpreferredencoding(False) to work
+    # in pip._internal.utils.encoding.auto_decode
+    try:
+        locale.setlocale(locale.LC_ALL, "")
+    except locale.Error as e:
+        # setlocale can apparently crash if locale are uninitialized
+        logger.debug("Ignoring error %s when setting locale", e)
+    command = create_command(cmd_name, isolated=("--isolated" in cmd_args))
+
+    return command.main(cmd_args)
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/cli/main_parser.py b/venv/lib/python3.12/site-packages/pip/_internal/cli/main_parser.py
new file mode 100644
index 00000000..5ade356b
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/cli/main_parser.py
@@ -0,0 +1,134 @@
+"""A single place for constructing and exposing the main parser
+"""
+
+import os
+import subprocess
+import sys
+from typing import List, Optional, Tuple
+
+from pip._internal.build_env import get_runnable_pip
+from pip._internal.cli import cmdoptions
+from pip._internal.cli.parser import ConfigOptionParser, UpdatingDefaultsHelpFormatter
+from pip._internal.commands import commands_dict, get_similar_commands
+from pip._internal.exceptions import CommandError
+from pip._internal.utils.misc import get_pip_version, get_prog
+
+__all__ = ["create_main_parser", "parse_command"]
+
+
+def create_main_parser() -> ConfigOptionParser:
+    """Creates and returns the main parser for pip's CLI"""
+
+    parser = ConfigOptionParser(
+        usage="\n%prog  [options]",
+        add_help_option=False,
+        formatter=UpdatingDefaultsHelpFormatter(),
+        name="global",
+        prog=get_prog(),
+    )
+    parser.disable_interspersed_args()
+
+    parser.version = get_pip_version()
+
+    # add the general options
+    gen_opts = cmdoptions.make_option_group(cmdoptions.general_group, parser)
+    parser.add_option_group(gen_opts)
+
+    # so the help formatter knows
+    parser.main = True  # type: ignore
+
+    # create command listing for description
+    description = [""] + [
+        f"{name:27} {command_info.summary}"
+        for name, command_info in commands_dict.items()
+    ]
+    parser.description = "\n".join(description)
+
+    return parser
+
+
+def identify_python_interpreter(python: str) -> Optional[str]:
+    # If the named file exists, use it.
+    # If it's a directory, assume it's a virtual environment and
+    # look for the environment's Python executable.
+    if os.path.exists(python):
+        if os.path.isdir(python):
+            # bin/python for Unix, Scripts/python.exe for Windows
+            # Try both in case of odd cases like cygwin.
+            for exe in ("bin/python", "Scripts/python.exe"):
+                py = os.path.join(python, exe)
+                if os.path.exists(py):
+                    return py
+        else:
+            return python
+
+    # Could not find the interpreter specified
+    return None
+
+
+def parse_command(args: List[str]) -> Tuple[str, List[str]]:
+    parser = create_main_parser()
+
+    # Note: parser calls disable_interspersed_args(), so the result of this
+    # call is to split the initial args into the general options before the
+    # subcommand and everything else.
+    # For example:
+    #  args: ['--timeout=5', 'install', '--user', 'INITools']
+    #  general_options: ['--timeout==5']
+    #  args_else: ['install', '--user', 'INITools']
+    general_options, args_else = parser.parse_args(args)
+
+    # --python
+    if general_options.python and "_PIP_RUNNING_IN_SUBPROCESS" not in os.environ:
+        # Re-invoke pip using the specified Python interpreter
+        interpreter = identify_python_interpreter(general_options.python)
+        if interpreter is None:
+            raise CommandError(
+                f"Could not locate Python interpreter {general_options.python}"
+            )
+
+        pip_cmd = [
+            interpreter,
+            get_runnable_pip(),
+        ]
+        pip_cmd.extend(args)
+
+        # Set a flag so the child doesn't re-invoke itself, causing
+        # an infinite loop.
+        os.environ["_PIP_RUNNING_IN_SUBPROCESS"] = "1"
+        returncode = 0
+        try:
+            proc = subprocess.run(pip_cmd)
+            returncode = proc.returncode
+        except (subprocess.SubprocessError, OSError) as exc:
+            raise CommandError(f"Failed to run pip under {interpreter}: {exc}")
+        sys.exit(returncode)
+
+    # --version
+    if general_options.version:
+        sys.stdout.write(parser.version)
+        sys.stdout.write(os.linesep)
+        sys.exit()
+
+    # pip || pip help -> print_help()
+    if not args_else or (args_else[0] == "help" and len(args_else) == 1):
+        parser.print_help()
+        sys.exit()
+
+    # the subcommand name
+    cmd_name = args_else[0]
+
+    if cmd_name not in commands_dict:
+        guess = get_similar_commands(cmd_name)
+
+        msg = [f'unknown command "{cmd_name}"']
+        if guess:
+            msg.append(f'maybe you meant "{guess}"')
+
+        raise CommandError(" - ".join(msg))
+
+    # all the args without the subcommand
+    cmd_args = args[:]
+    cmd_args.remove(cmd_name)
+
+    return cmd_name, cmd_args
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/cli/parser.py b/venv/lib/python3.12/site-packages/pip/_internal/cli/parser.py
new file mode 100644
index 00000000..b7d7c1f6
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/cli/parser.py
@@ -0,0 +1,294 @@
+"""Base option parser setup"""
+
+import logging
+import optparse
+import shutil
+import sys
+import textwrap
+from contextlib import suppress
+from typing import Any, Dict, Generator, List, Optional, Tuple
+
+from pip._internal.cli.status_codes import UNKNOWN_ERROR
+from pip._internal.configuration import Configuration, ConfigurationError
+from pip._internal.utils.misc import redact_auth_from_url, strtobool
+
+logger = logging.getLogger(__name__)
+
+
+class PrettyHelpFormatter(optparse.IndentedHelpFormatter):
+    """A prettier/less verbose help formatter for optparse."""
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        # help position must be aligned with __init__.parseopts.description
+        kwargs["max_help_position"] = 30
+        kwargs["indent_increment"] = 1
+        kwargs["width"] = shutil.get_terminal_size()[0] - 2
+        super().__init__(*args, **kwargs)
+
+    def format_option_strings(self, option: optparse.Option) -> str:
+        return self._format_option_strings(option)
+
+    def _format_option_strings(
+        self, option: optparse.Option, mvarfmt: str = " <{}>", optsep: str = ", "
+    ) -> str:
+        """
+        Return a comma-separated list of option strings and metavars.
+
+        :param option:  tuple of (short opt, long opt), e.g: ('-f', '--format')
+        :param mvarfmt: metavar format string
+        :param optsep:  separator
+        """
+        opts = []
+
+        if option._short_opts:
+            opts.append(option._short_opts[0])
+        if option._long_opts:
+            opts.append(option._long_opts[0])
+        if len(opts) > 1:
+            opts.insert(1, optsep)
+
+        if option.takes_value():
+            assert option.dest is not None
+            metavar = option.metavar or option.dest.lower()
+            opts.append(mvarfmt.format(metavar.lower()))
+
+        return "".join(opts)
+
+    def format_heading(self, heading: str) -> str:
+        if heading == "Options":
+            return ""
+        return heading + ":\n"
+
+    def format_usage(self, usage: str) -> str:
+        """
+        Ensure there is only one newline between usage and the first heading
+        if there is no description.
+        """
+        msg = "\nUsage: {}\n".format(self.indent_lines(textwrap.dedent(usage), "  "))
+        return msg
+
+    def format_description(self, description: Optional[str]) -> str:
+        # leave full control over description to us
+        if description:
+            if hasattr(self.parser, "main"):
+                label = "Commands"
+            else:
+                label = "Description"
+            # some doc strings have initial newlines, some don't
+            description = description.lstrip("\n")
+            # some doc strings have final newlines and spaces, some don't
+            description = description.rstrip()
+            # dedent, then reindent
+            description = self.indent_lines(textwrap.dedent(description), "  ")
+            description = f"{label}:\n{description}\n"
+            return description
+        else:
+            return ""
+
+    def format_epilog(self, epilog: Optional[str]) -> str:
+        # leave full control over epilog to us
+        if epilog:
+            return epilog
+        else:
+            return ""
+
+    def indent_lines(self, text: str, indent: str) -> str:
+        new_lines = [indent + line for line in text.split("\n")]
+        return "\n".join(new_lines)
+
+
+class UpdatingDefaultsHelpFormatter(PrettyHelpFormatter):
+    """Custom help formatter for use in ConfigOptionParser.
+
+    This is updates the defaults before expanding them, allowing
+    them to show up correctly in the help listing.
+
+    Also redact auth from url type options
+    """
+
+    def expand_default(self, option: optparse.Option) -> str:
+        default_values = None
+        if self.parser is not None:
+            assert isinstance(self.parser, ConfigOptionParser)
+            self.parser._update_defaults(self.parser.defaults)
+            assert option.dest is not None
+            default_values = self.parser.defaults.get(option.dest)
+        help_text = super().expand_default(option)
+
+        if default_values and option.metavar == "URL":
+            if isinstance(default_values, str):
+                default_values = [default_values]
+
+            # If its not a list, we should abort and just return the help text
+            if not isinstance(default_values, list):
+                default_values = []
+
+            for val in default_values:
+                help_text = help_text.replace(val, redact_auth_from_url(val))
+
+        return help_text
+
+
+class CustomOptionParser(optparse.OptionParser):
+    def insert_option_group(
+        self, idx: int, *args: Any, **kwargs: Any
+    ) -> optparse.OptionGroup:
+        """Insert an OptionGroup at a given position."""
+        group = self.add_option_group(*args, **kwargs)
+
+        self.option_groups.pop()
+        self.option_groups.insert(idx, group)
+
+        return group
+
+    @property
+    def option_list_all(self) -> List[optparse.Option]:
+        """Get a list of all options, including those in option groups."""
+        res = self.option_list[:]
+        for i in self.option_groups:
+            res.extend(i.option_list)
+
+        return res
+
+
+class ConfigOptionParser(CustomOptionParser):
+    """Custom option parser which updates its defaults by checking the
+    configuration files and environmental variables"""
+
+    def __init__(
+        self,
+        *args: Any,
+        name: str,
+        isolated: bool = False,
+        **kwargs: Any,
+    ) -> None:
+        self.name = name
+        self.config = Configuration(isolated)
+
+        assert self.name
+        super().__init__(*args, **kwargs)
+
+    def check_default(self, option: optparse.Option, key: str, val: Any) -> Any:
+        try:
+            return option.check_value(key, val)
+        except optparse.OptionValueError as exc:
+            print(f"An error occurred during configuration: {exc}")
+            sys.exit(3)
+
+    def _get_ordered_configuration_items(
+        self,
+    ) -> Generator[Tuple[str, Any], None, None]:
+        # Configuration gives keys in an unordered manner. Order them.
+        override_order = ["global", self.name, ":env:"]
+
+        # Pool the options into different groups
+        section_items: Dict[str, List[Tuple[str, Any]]] = {
+            name: [] for name in override_order
+        }
+        for section_key, val in self.config.items():
+            # ignore empty values
+            if not val:
+                logger.debug(
+                    "Ignoring configuration key '%s' as it's value is empty.",
+                    section_key,
+                )
+                continue
+
+            section, key = section_key.split(".", 1)
+            if section in override_order:
+                section_items[section].append((key, val))
+
+        # Yield each group in their override order
+        for section in override_order:
+            for key, val in section_items[section]:
+                yield key, val
+
+    def _update_defaults(self, defaults: Dict[str, Any]) -> Dict[str, Any]:
+        """Updates the given defaults with values from the config files and
+        the environ. Does a little special handling for certain types of
+        options (lists)."""
+
+        # Accumulate complex default state.
+        self.values = optparse.Values(self.defaults)
+        late_eval = set()
+        # Then set the options with those values
+        for key, val in self._get_ordered_configuration_items():
+            # '--' because configuration supports only long names
+            option = self.get_option("--" + key)
+
+            # Ignore options not present in this parser. E.g. non-globals put
+            # in [global] by users that want them to apply to all applicable
+            # commands.
+            if option is None:
+                continue
+
+            assert option.dest is not None
+
+            if option.action in ("store_true", "store_false"):
+                try:
+                    val = strtobool(val)
+                except ValueError:
+                    self.error(
+                        f"{val} is not a valid value for {key} option, "
+                        "please specify a boolean value like yes/no, "
+                        "true/false or 1/0 instead."
+                    )
+            elif option.action == "count":
+                with suppress(ValueError):
+                    val = strtobool(val)
+                with suppress(ValueError):
+                    val = int(val)
+                if not isinstance(val, int) or val < 0:
+                    self.error(
+                        f"{val} is not a valid value for {key} option, "
+                        "please instead specify either a non-negative integer "
+                        "or a boolean value like yes/no or false/true "
+                        "which is equivalent to 1/0."
+                    )
+            elif option.action == "append":
+                val = val.split()
+                val = [self.check_default(option, key, v) for v in val]
+            elif option.action == "callback":
+                assert option.callback is not None
+                late_eval.add(option.dest)
+                opt_str = option.get_opt_string()
+                val = option.convert_value(opt_str, val)
+                # From take_action
+                args = option.callback_args or ()
+                kwargs = option.callback_kwargs or {}
+                option.callback(option, opt_str, val, self, *args, **kwargs)
+            else:
+                val = self.check_default(option, key, val)
+
+            defaults[option.dest] = val
+
+        for key in late_eval:
+            defaults[key] = getattr(self.values, key)
+        self.values = None
+        return defaults
+
+    def get_default_values(self) -> optparse.Values:
+        """Overriding to make updating the defaults after instantiation of
+        the option parser possible, _update_defaults() does the dirty work."""
+        if not self.process_default_values:
+            # Old, pre-Optik 1.5 behaviour.
+            return optparse.Values(self.defaults)
+
+        # Load the configuration, or error out in case of an error
+        try:
+            self.config.load()
+        except ConfigurationError as err:
+            self.exit(UNKNOWN_ERROR, str(err))
+
+        defaults = self._update_defaults(self.defaults.copy())  # ours
+        for option in self._get_all_options():
+            assert option.dest is not None
+            default = defaults.get(option.dest)
+            if isinstance(default, str):
+                opt_str = option.get_opt_string()
+                defaults[option.dest] = option.check_value(opt_str, default)
+        return optparse.Values(defaults)
+
+    def error(self, msg: str) -> None:
+        self.print_usage(sys.stderr)
+        self.exit(UNKNOWN_ERROR, f"{msg}\n")
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/cli/progress_bars.py b/venv/lib/python3.12/site-packages/pip/_internal/cli/progress_bars.py
new file mode 100644
index 00000000..883359c9
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/cli/progress_bars.py
@@ -0,0 +1,94 @@
+import functools
+import sys
+from typing import Callable, Generator, Iterable, Iterator, Optional, Tuple
+
+from pip._vendor.rich.progress import (
+    BarColumn,
+    DownloadColumn,
+    FileSizeColumn,
+    Progress,
+    ProgressColumn,
+    SpinnerColumn,
+    TextColumn,
+    TimeElapsedColumn,
+    TimeRemainingColumn,
+    TransferSpeedColumn,
+)
+
+from pip._internal.cli.spinners import RateLimiter
+from pip._internal.utils.logging import get_indentation
+
+DownloadProgressRenderer = Callable[[Iterable[bytes]], Iterator[bytes]]
+
+
+def _rich_progress_bar(
+    iterable: Iterable[bytes],
+    *,
+    bar_type: str,
+    size: int,
+) -> Generator[bytes, None, None]:
+    assert bar_type == "on", "This should only be used in the default mode."
+
+    if not size:
+        total = float("inf")
+        columns: Tuple[ProgressColumn, ...] = (
+            TextColumn("[progress.description]{task.description}"),
+            SpinnerColumn("line", speed=1.5),
+            FileSizeColumn(),
+            TransferSpeedColumn(),
+            TimeElapsedColumn(),
+        )
+    else:
+        total = size
+        columns = (
+            TextColumn("[progress.description]{task.description}"),
+            BarColumn(),
+            DownloadColumn(),
+            TransferSpeedColumn(),
+            TextColumn("eta"),
+            TimeRemainingColumn(),
+        )
+
+    progress = Progress(*columns, refresh_per_second=5)
+    task_id = progress.add_task(" " * (get_indentation() + 2), total=total)
+    with progress:
+        for chunk in iterable:
+            yield chunk
+            progress.update(task_id, advance=len(chunk))
+
+
+def _raw_progress_bar(
+    iterable: Iterable[bytes],
+    *,
+    size: Optional[int],
+) -> Generator[bytes, None, None]:
+    def write_progress(current: int, total: int) -> None:
+        sys.stdout.write("Progress %d of %d\n" % (current, total))
+        sys.stdout.flush()
+
+    current = 0
+    total = size or 0
+    rate_limiter = RateLimiter(0.25)
+
+    write_progress(current, total)
+    for chunk in iterable:
+        current += len(chunk)
+        if rate_limiter.ready() or current == total:
+            write_progress(current, total)
+            rate_limiter.reset()
+        yield chunk
+
+
+def get_download_progress_renderer(
+    *, bar_type: str, size: Optional[int] = None
+) -> DownloadProgressRenderer:
+    """Get an object that can be used to render the download progress.
+
+    Returns a callable, that takes an iterable to "wrap".
+    """
+    if bar_type == "on":
+        return functools.partial(_rich_progress_bar, bar_type=bar_type, size=size)
+    elif bar_type == "raw":
+        return functools.partial(_raw_progress_bar, size=size)
+    else:
+        return iter  # no-op, when passed an iterator
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/cli/req_command.py b/venv/lib/python3.12/site-packages/pip/_internal/cli/req_command.py
new file mode 100644
index 00000000..92900f94
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/cli/req_command.py
@@ -0,0 +1,329 @@
+"""Contains the RequirementCommand base class.
+
+This class is in a separate module so the commands that do not always
+need PackageFinder capability don't unnecessarily import the
+PackageFinder machinery and all its vendored dependencies, etc.
+"""
+
+import logging
+from functools import partial
+from optparse import Values
+from typing import Any, List, Optional, Tuple
+
+from pip._internal.cache import WheelCache
+from pip._internal.cli import cmdoptions
+from pip._internal.cli.index_command import IndexGroupCommand
+from pip._internal.cli.index_command import SessionCommandMixin as SessionCommandMixin
+from pip._internal.exceptions import CommandError, PreviousBuildDirError
+from pip._internal.index.collector import LinkCollector
+from pip._internal.index.package_finder import PackageFinder
+from pip._internal.models.selection_prefs import SelectionPreferences
+from pip._internal.models.target_python import TargetPython
+from pip._internal.network.session import PipSession
+from pip._internal.operations.build.build_tracker import BuildTracker
+from pip._internal.operations.prepare import RequirementPreparer
+from pip._internal.req.constructors import (
+    install_req_from_editable,
+    install_req_from_line,
+    install_req_from_parsed_requirement,
+    install_req_from_req_string,
+)
+from pip._internal.req.req_file import parse_requirements
+from pip._internal.req.req_install import InstallRequirement
+from pip._internal.resolution.base import BaseResolver
+from pip._internal.utils.temp_dir import (
+    TempDirectory,
+    TempDirectoryTypeRegistry,
+    tempdir_kinds,
+)
+
+logger = logging.getLogger(__name__)
+
+
+KEEPABLE_TEMPDIR_TYPES = [
+    tempdir_kinds.BUILD_ENV,
+    tempdir_kinds.EPHEM_WHEEL_CACHE,
+    tempdir_kinds.REQ_BUILD,
+]
+
+
+def with_cleanup(func: Any) -> Any:
+    """Decorator for common logic related to managing temporary
+    directories.
+    """
+
+    def configure_tempdir_registry(registry: TempDirectoryTypeRegistry) -> None:
+        for t in KEEPABLE_TEMPDIR_TYPES:
+            registry.set_delete(t, False)
+
+    def wrapper(
+        self: RequirementCommand, options: Values, args: List[Any]
+    ) -> Optional[int]:
+        assert self.tempdir_registry is not None
+        if options.no_clean:
+            configure_tempdir_registry(self.tempdir_registry)
+
+        try:
+            return func(self, options, args)
+        except PreviousBuildDirError:
+            # This kind of conflict can occur when the user passes an explicit
+            # build directory with a pre-existing folder. In that case we do
+            # not want to accidentally remove it.
+            configure_tempdir_registry(self.tempdir_registry)
+            raise
+
+    return wrapper
+
+
+class RequirementCommand(IndexGroupCommand):
+    def __init__(self, *args: Any, **kw: Any) -> None:
+        super().__init__(*args, **kw)
+
+        self.cmd_opts.add_option(cmdoptions.no_clean())
+
+    @staticmethod
+    def determine_resolver_variant(options: Values) -> str:
+        """Determines which resolver should be used, based on the given options."""
+        if "legacy-resolver" in options.deprecated_features_enabled:
+            return "legacy"
+
+        return "resolvelib"
+
+    @classmethod
+    def make_requirement_preparer(
+        cls,
+        temp_build_dir: TempDirectory,
+        options: Values,
+        build_tracker: BuildTracker,
+        session: PipSession,
+        finder: PackageFinder,
+        use_user_site: bool,
+        download_dir: Optional[str] = None,
+        verbosity: int = 0,
+    ) -> RequirementPreparer:
+        """
+        Create a RequirementPreparer instance for the given parameters.
+        """
+        temp_build_dir_path = temp_build_dir.path
+        assert temp_build_dir_path is not None
+        legacy_resolver = False
+
+        resolver_variant = cls.determine_resolver_variant(options)
+        if resolver_variant == "resolvelib":
+            lazy_wheel = "fast-deps" in options.features_enabled
+            if lazy_wheel:
+                logger.warning(
+                    "pip is using lazily downloaded wheels using HTTP "
+                    "range requests to obtain dependency information. "
+                    "This experimental feature is enabled through "
+                    "--use-feature=fast-deps and it is not ready for "
+                    "production."
+                )
+        else:
+            legacy_resolver = True
+            lazy_wheel = False
+            if "fast-deps" in options.features_enabled:
+                logger.warning(
+                    "fast-deps has no effect when used with the legacy resolver."
+                )
+
+        return RequirementPreparer(
+            build_dir=temp_build_dir_path,
+            src_dir=options.src_dir,
+            download_dir=download_dir,
+            build_isolation=options.build_isolation,
+            check_build_deps=options.check_build_deps,
+            build_tracker=build_tracker,
+            session=session,
+            progress_bar=options.progress_bar,
+            finder=finder,
+            require_hashes=options.require_hashes,
+            use_user_site=use_user_site,
+            lazy_wheel=lazy_wheel,
+            verbosity=verbosity,
+            legacy_resolver=legacy_resolver,
+        )
+
+    @classmethod
+    def make_resolver(
+        cls,
+        preparer: RequirementPreparer,
+        finder: PackageFinder,
+        options: Values,
+        wheel_cache: Optional[WheelCache] = None,
+        use_user_site: bool = False,
+        ignore_installed: bool = True,
+        ignore_requires_python: bool = False,
+        force_reinstall: bool = False,
+        upgrade_strategy: str = "to-satisfy-only",
+        use_pep517: Optional[bool] = None,
+        py_version_info: Optional[Tuple[int, ...]] = None,
+    ) -> BaseResolver:
+        """
+        Create a Resolver instance for the given parameters.
+        """
+        make_install_req = partial(
+            install_req_from_req_string,
+            isolated=options.isolated_mode,
+            use_pep517=use_pep517,
+        )
+        resolver_variant = cls.determine_resolver_variant(options)
+        # The long import name and duplicated invocation is needed to convince
+        # Mypy into correctly typechecking. Otherwise it would complain the
+        # "Resolver" class being redefined.
+        if resolver_variant == "resolvelib":
+            import pip._internal.resolution.resolvelib.resolver
+
+            return pip._internal.resolution.resolvelib.resolver.Resolver(
+                preparer=preparer,
+                finder=finder,
+                wheel_cache=wheel_cache,
+                make_install_req=make_install_req,
+                use_user_site=use_user_site,
+                ignore_dependencies=options.ignore_dependencies,
+                ignore_installed=ignore_installed,
+                ignore_requires_python=ignore_requires_python,
+                force_reinstall=force_reinstall,
+                upgrade_strategy=upgrade_strategy,
+                py_version_info=py_version_info,
+            )
+        import pip._internal.resolution.legacy.resolver
+
+        return pip._internal.resolution.legacy.resolver.Resolver(
+            preparer=preparer,
+            finder=finder,
+            wheel_cache=wheel_cache,
+            make_install_req=make_install_req,
+            use_user_site=use_user_site,
+            ignore_dependencies=options.ignore_dependencies,
+            ignore_installed=ignore_installed,
+            ignore_requires_python=ignore_requires_python,
+            force_reinstall=force_reinstall,
+            upgrade_strategy=upgrade_strategy,
+            py_version_info=py_version_info,
+        )
+
+    def get_requirements(
+        self,
+        args: List[str],
+        options: Values,
+        finder: PackageFinder,
+        session: PipSession,
+    ) -> List[InstallRequirement]:
+        """
+        Parse command-line arguments into the corresponding requirements.
+        """
+        requirements: List[InstallRequirement] = []
+        for filename in options.constraints:
+            for parsed_req in parse_requirements(
+                filename,
+                constraint=True,
+                finder=finder,
+                options=options,
+                session=session,
+            ):
+                req_to_add = install_req_from_parsed_requirement(
+                    parsed_req,
+                    isolated=options.isolated_mode,
+                    user_supplied=False,
+                )
+                requirements.append(req_to_add)
+
+        for req in args:
+            req_to_add = install_req_from_line(
+                req,
+                comes_from=None,
+                isolated=options.isolated_mode,
+                use_pep517=options.use_pep517,
+                user_supplied=True,
+                config_settings=getattr(options, "config_settings", None),
+            )
+            requirements.append(req_to_add)
+
+        for req in options.editables:
+            req_to_add = install_req_from_editable(
+                req,
+                user_supplied=True,
+                isolated=options.isolated_mode,
+                use_pep517=options.use_pep517,
+                config_settings=getattr(options, "config_settings", None),
+            )
+            requirements.append(req_to_add)
+
+        # NOTE: options.require_hashes may be set if --require-hashes is True
+        for filename in options.requirements:
+            for parsed_req in parse_requirements(
+                filename, finder=finder, options=options, session=session
+            ):
+                req_to_add = install_req_from_parsed_requirement(
+                    parsed_req,
+                    isolated=options.isolated_mode,
+                    use_pep517=options.use_pep517,
+                    user_supplied=True,
+                    config_settings=(
+                        parsed_req.options.get("config_settings")
+                        if parsed_req.options
+                        else None
+                    ),
+                )
+                requirements.append(req_to_add)
+
+        # If any requirement has hash options, enable hash checking.
+        if any(req.has_hash_options for req in requirements):
+            options.require_hashes = True
+
+        if not (args or options.editables or options.requirements):
+            opts = {"name": self.name}
+            if options.find_links:
+                raise CommandError(
+                    "You must give at least one requirement to {name} "
+                    '(maybe you meant "pip {name} {links}"?)'.format(
+                        **dict(opts, links=" ".join(options.find_links))
+                    )
+                )
+            else:
+                raise CommandError(
+                    "You must give at least one requirement to {name} "
+                    '(see "pip help {name}")'.format(**opts)
+                )
+
+        return requirements
+
+    @staticmethod
+    def trace_basic_info(finder: PackageFinder) -> None:
+        """
+        Trace basic information about the provided objects.
+        """
+        # Display where finder is looking for packages
+        search_scope = finder.search_scope
+        locations = search_scope.get_formatted_locations()
+        if locations:
+            logger.info(locations)
+
+    def _build_package_finder(
+        self,
+        options: Values,
+        session: PipSession,
+        target_python: Optional[TargetPython] = None,
+        ignore_requires_python: Optional[bool] = None,
+    ) -> PackageFinder:
+        """
+        Create a package finder appropriate to this requirement command.
+
+        :param ignore_requires_python: Whether to ignore incompatible
+            "Requires-Python" values in links. Defaults to False.
+        """
+        link_collector = LinkCollector.create(session, options=options)
+        selection_prefs = SelectionPreferences(
+            allow_yanked=True,
+            format_control=options.format_control,
+            allow_all_prereleases=options.pre,
+            prefer_binary=options.prefer_binary,
+            ignore_requires_python=ignore_requires_python,
+        )
+
+        return PackageFinder.create(
+            link_collector=link_collector,
+            selection_prefs=selection_prefs,
+            target_python=target_python,
+        )
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/cli/spinners.py b/venv/lib/python3.12/site-packages/pip/_internal/cli/spinners.py
new file mode 100644
index 00000000..cf2b976f
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/cli/spinners.py
@@ -0,0 +1,159 @@
+import contextlib
+import itertools
+import logging
+import sys
+import time
+from typing import IO, Generator, Optional
+
+from pip._internal.utils.compat import WINDOWS
+from pip._internal.utils.logging import get_indentation
+
+logger = logging.getLogger(__name__)
+
+
+class SpinnerInterface:
+    def spin(self) -> None:
+        raise NotImplementedError()
+
+    def finish(self, final_status: str) -> None:
+        raise NotImplementedError()
+
+
+class InteractiveSpinner(SpinnerInterface):
+    def __init__(
+        self,
+        message: str,
+        file: Optional[IO[str]] = None,
+        spin_chars: str = "-\\|/",
+        # Empirically, 8 updates/second looks nice
+        min_update_interval_seconds: float = 0.125,
+    ):
+        self._message = message
+        if file is None:
+            file = sys.stdout
+        self._file = file
+        self._rate_limiter = RateLimiter(min_update_interval_seconds)
+        self._finished = False
+
+        self._spin_cycle = itertools.cycle(spin_chars)
+
+        self._file.write(" " * get_indentation() + self._message + " ... ")
+        self._width = 0
+
+    def _write(self, status: str) -> None:
+        assert not self._finished
+        # Erase what we wrote before by backspacing to the beginning, writing
+        # spaces to overwrite the old text, and then backspacing again
+        backup = "\b" * self._width
+        self._file.write(backup + " " * self._width + backup)
+        # Now we have a blank slate to add our status
+        self._file.write(status)
+        self._width = len(status)
+        self._file.flush()
+        self._rate_limiter.reset()
+
+    def spin(self) -> None:
+        if self._finished:
+            return
+        if not self._rate_limiter.ready():
+            return
+        self._write(next(self._spin_cycle))
+
+    def finish(self, final_status: str) -> None:
+        if self._finished:
+            return
+        self._write(final_status)
+        self._file.write("\n")
+        self._file.flush()
+        self._finished = True
+
+
+# Used for dumb terminals, non-interactive installs (no tty), etc.
+# We still print updates occasionally (once every 60 seconds by default) to
+# act as a keep-alive for systems like Travis-CI that take lack-of-output as
+# an indication that a task has frozen.
+class NonInteractiveSpinner(SpinnerInterface):
+    def __init__(self, message: str, min_update_interval_seconds: float = 60.0) -> None:
+        self._message = message
+        self._finished = False
+        self._rate_limiter = RateLimiter(min_update_interval_seconds)
+        self._update("started")
+
+    def _update(self, status: str) -> None:
+        assert not self._finished
+        self._rate_limiter.reset()
+        logger.info("%s: %s", self._message, status)
+
+    def spin(self) -> None:
+        if self._finished:
+            return
+        if not self._rate_limiter.ready():
+            return
+        self._update("still running...")
+
+    def finish(self, final_status: str) -> None:
+        if self._finished:
+            return
+        self._update(f"finished with status '{final_status}'")
+        self._finished = True
+
+
+class RateLimiter:
+    def __init__(self, min_update_interval_seconds: float) -> None:
+        self._min_update_interval_seconds = min_update_interval_seconds
+        self._last_update: float = 0
+
+    def ready(self) -> bool:
+        now = time.time()
+        delta = now - self._last_update
+        return delta >= self._min_update_interval_seconds
+
+    def reset(self) -> None:
+        self._last_update = time.time()
+
+
+@contextlib.contextmanager
+def open_spinner(message: str) -> Generator[SpinnerInterface, None, None]:
+    # Interactive spinner goes directly to sys.stdout rather than being routed
+    # through the logging system, but it acts like it has level INFO,
+    # i.e. it's only displayed if we're at level INFO or better.
+    # Non-interactive spinner goes through the logging system, so it is always
+    # in sync with logging configuration.
+    if sys.stdout.isatty() and logger.getEffectiveLevel() <= logging.INFO:
+        spinner: SpinnerInterface = InteractiveSpinner(message)
+    else:
+        spinner = NonInteractiveSpinner(message)
+    try:
+        with hidden_cursor(sys.stdout):
+            yield spinner
+    except KeyboardInterrupt:
+        spinner.finish("canceled")
+        raise
+    except Exception:
+        spinner.finish("error")
+        raise
+    else:
+        spinner.finish("done")
+
+
+HIDE_CURSOR = "\x1b[?25l"
+SHOW_CURSOR = "\x1b[?25h"
+
+
+@contextlib.contextmanager
+def hidden_cursor(file: IO[str]) -> Generator[None, None, None]:
+    # The Windows terminal does not support the hide/show cursor ANSI codes,
+    # even via colorama. So don't even try.
+    if WINDOWS:
+        yield
+    # We don't want to clutter the output with control characters if we're
+    # writing to a file, or if the user is running with --quiet.
+    # See https://github.com/pypa/pip/issues/3418
+    elif not file.isatty() or logger.getEffectiveLevel() > logging.INFO:
+        yield
+    else:
+        file.write(HIDE_CURSOR)
+        try:
+            yield
+        finally:
+            file.write(SHOW_CURSOR)
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/cli/status_codes.py b/venv/lib/python3.12/site-packages/pip/_internal/cli/status_codes.py
new file mode 100644
index 00000000..5e29502c
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/cli/status_codes.py
@@ -0,0 +1,6 @@
+SUCCESS = 0
+ERROR = 1
+UNKNOWN_ERROR = 2
+VIRTUALENV_NOT_FOUND = 3
+PREVIOUS_BUILD_DIR_ERROR = 4
+NO_MATCHES_FOUND = 23
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/commands/__init__.py b/venv/lib/python3.12/site-packages/pip/_internal/commands/__init__.py
new file mode 100644
index 00000000..858a4101
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/commands/__init__.py
@@ -0,0 +1,132 @@
+"""
+Package containing all pip commands
+"""
+
+import importlib
+from collections import namedtuple
+from typing import Any, Dict, Optional
+
+from pip._internal.cli.base_command import Command
+
+CommandInfo = namedtuple("CommandInfo", "module_path, class_name, summary")
+
+# This dictionary does a bunch of heavy lifting for help output:
+# - Enables avoiding additional (costly) imports for presenting `--help`.
+# - The ordering matters for help display.
+#
+# Even though the module path starts with the same "pip._internal.commands"
+# prefix, the full path makes testing easier (specifically when modifying
+# `commands_dict` in test setup / teardown).
+commands_dict: Dict[str, CommandInfo] = {
+    "install": CommandInfo(
+        "pip._internal.commands.install",
+        "InstallCommand",
+        "Install packages.",
+    ),
+    "download": CommandInfo(
+        "pip._internal.commands.download",
+        "DownloadCommand",
+        "Download packages.",
+    ),
+    "uninstall": CommandInfo(
+        "pip._internal.commands.uninstall",
+        "UninstallCommand",
+        "Uninstall packages.",
+    ),
+    "freeze": CommandInfo(
+        "pip._internal.commands.freeze",
+        "FreezeCommand",
+        "Output installed packages in requirements format.",
+    ),
+    "inspect": CommandInfo(
+        "pip._internal.commands.inspect",
+        "InspectCommand",
+        "Inspect the python environment.",
+    ),
+    "list": CommandInfo(
+        "pip._internal.commands.list",
+        "ListCommand",
+        "List installed packages.",
+    ),
+    "show": CommandInfo(
+        "pip._internal.commands.show",
+        "ShowCommand",
+        "Show information about installed packages.",
+    ),
+    "check": CommandInfo(
+        "pip._internal.commands.check",
+        "CheckCommand",
+        "Verify installed packages have compatible dependencies.",
+    ),
+    "config": CommandInfo(
+        "pip._internal.commands.configuration",
+        "ConfigurationCommand",
+        "Manage local and global configuration.",
+    ),
+    "search": CommandInfo(
+        "pip._internal.commands.search",
+        "SearchCommand",
+        "Search PyPI for packages.",
+    ),
+    "cache": CommandInfo(
+        "pip._internal.commands.cache",
+        "CacheCommand",
+        "Inspect and manage pip's wheel cache.",
+    ),
+    "index": CommandInfo(
+        "pip._internal.commands.index",
+        "IndexCommand",
+        "Inspect information available from package indexes.",
+    ),
+    "wheel": CommandInfo(
+        "pip._internal.commands.wheel",
+        "WheelCommand",
+        "Build wheels from your requirements.",
+    ),
+    "hash": CommandInfo(
+        "pip._internal.commands.hash",
+        "HashCommand",
+        "Compute hashes of package archives.",
+    ),
+    "completion": CommandInfo(
+        "pip._internal.commands.completion",
+        "CompletionCommand",
+        "A helper command used for command completion.",
+    ),
+    "debug": CommandInfo(
+        "pip._internal.commands.debug",
+        "DebugCommand",
+        "Show information useful for debugging.",
+    ),
+    "help": CommandInfo(
+        "pip._internal.commands.help",
+        "HelpCommand",
+        "Show help for commands.",
+    ),
+}
+
+
+def create_command(name: str, **kwargs: Any) -> Command:
+    """
+    Create an instance of the Command class with the given name.
+    """
+    module_path, class_name, summary = commands_dict[name]
+    module = importlib.import_module(module_path)
+    command_class = getattr(module, class_name)
+    command = command_class(name=name, summary=summary, **kwargs)
+
+    return command
+
+
+def get_similar_commands(name: str) -> Optional[str]:
+    """Command name auto-correct."""
+    from difflib import get_close_matches
+
+    name = name.lower()
+
+    close_commands = get_close_matches(name, commands_dict.keys())
+
+    if close_commands:
+        return close_commands[0]
+    else:
+        return None
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/commands/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/commands/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 00000000..707d13dd
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/commands/__pycache__/__init__.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/commands/__pycache__/cache.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/commands/__pycache__/cache.cpython-312.pyc
new file mode 100644
index 00000000..89028520
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/commands/__pycache__/cache.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/commands/__pycache__/check.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/commands/__pycache__/check.cpython-312.pyc
new file mode 100644
index 00000000..a6dd06cd
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/commands/__pycache__/check.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/commands/__pycache__/completion.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/commands/__pycache__/completion.cpython-312.pyc
new file mode 100644
index 00000000..220ed9b0
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/commands/__pycache__/completion.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/commands/__pycache__/configuration.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/commands/__pycache__/configuration.cpython-312.pyc
new file mode 100644
index 00000000..1a6d83e3
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/commands/__pycache__/configuration.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/commands/__pycache__/debug.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/commands/__pycache__/debug.cpython-312.pyc
new file mode 100644
index 00000000..77f432f0
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/commands/__pycache__/debug.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/commands/__pycache__/download.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/commands/__pycache__/download.cpython-312.pyc
new file mode 100644
index 00000000..d69bdf34
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/commands/__pycache__/download.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/commands/__pycache__/freeze.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/commands/__pycache__/freeze.cpython-312.pyc
new file mode 100644
index 00000000..31904a9d
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/commands/__pycache__/freeze.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/commands/__pycache__/hash.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/commands/__pycache__/hash.cpython-312.pyc
new file mode 100644
index 00000000..05262b25
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/commands/__pycache__/hash.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/commands/__pycache__/help.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/commands/__pycache__/help.cpython-312.pyc
new file mode 100644
index 00000000..af739cdf
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/commands/__pycache__/help.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/commands/__pycache__/index.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/commands/__pycache__/index.cpython-312.pyc
new file mode 100644
index 00000000..5654be85
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/commands/__pycache__/index.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/commands/__pycache__/inspect.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/commands/__pycache__/inspect.cpython-312.pyc
new file mode 100644
index 00000000..c966d7ab
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/commands/__pycache__/inspect.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/commands/__pycache__/install.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/commands/__pycache__/install.cpython-312.pyc
new file mode 100644
index 00000000..4ad7c973
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/commands/__pycache__/install.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/commands/__pycache__/list.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/commands/__pycache__/list.cpython-312.pyc
new file mode 100644
index 00000000..4a21ccd0
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/commands/__pycache__/list.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/commands/__pycache__/search.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/commands/__pycache__/search.cpython-312.pyc
new file mode 100644
index 00000000..6fdd44bb
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/commands/__pycache__/search.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/commands/__pycache__/show.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/commands/__pycache__/show.cpython-312.pyc
new file mode 100644
index 00000000..dc6f1b8c
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/commands/__pycache__/show.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/commands/__pycache__/uninstall.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/commands/__pycache__/uninstall.cpython-312.pyc
new file mode 100644
index 00000000..caaf4189
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/commands/__pycache__/uninstall.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/commands/__pycache__/wheel.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/commands/__pycache__/wheel.cpython-312.pyc
new file mode 100644
index 00000000..6688de21
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/commands/__pycache__/wheel.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/commands/cache.py b/venv/lib/python3.12/site-packages/pip/_internal/commands/cache.py
new file mode 100644
index 00000000..32833615
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/commands/cache.py
@@ -0,0 +1,225 @@
+import os
+import textwrap
+from optparse import Values
+from typing import Any, List
+
+from pip._internal.cli.base_command import Command
+from pip._internal.cli.status_codes import ERROR, SUCCESS
+from pip._internal.exceptions import CommandError, PipError
+from pip._internal.utils import filesystem
+from pip._internal.utils.logging import getLogger
+
+logger = getLogger(__name__)
+
+
+class CacheCommand(Command):
+    """
+    Inspect and manage pip's wheel cache.
+
+    Subcommands:
+
+    - dir: Show the cache directory.
+    - info: Show information about the cache.
+    - list: List filenames of packages stored in the cache.
+    - remove: Remove one or more package from the cache.
+    - purge: Remove all items from the cache.
+
+    ```` can be a glob expression or a package name.
+    """
+
+    ignore_require_venv = True
+    usage = """
+        %prog dir
+        %prog info
+        %prog list [] [--format=[human, abspath]]
+        %prog remove 
+        %prog purge
+    """
+
+    def add_options(self) -> None:
+        self.cmd_opts.add_option(
+            "--format",
+            action="store",
+            dest="list_format",
+            default="human",
+            choices=("human", "abspath"),
+            help="Select the output format among: human (default) or abspath",
+        )
+
+        self.parser.insert_option_group(0, self.cmd_opts)
+
+    def run(self, options: Values, args: List[str]) -> int:
+        handlers = {
+            "dir": self.get_cache_dir,
+            "info": self.get_cache_info,
+            "list": self.list_cache_items,
+            "remove": self.remove_cache_items,
+            "purge": self.purge_cache,
+        }
+
+        if not options.cache_dir:
+            logger.error("pip cache commands can not function since cache is disabled.")
+            return ERROR
+
+        # Determine action
+        if not args or args[0] not in handlers:
+            logger.error(
+                "Need an action (%s) to perform.",
+                ", ".join(sorted(handlers)),
+            )
+            return ERROR
+
+        action = args[0]
+
+        # Error handling happens here, not in the action-handlers.
+        try:
+            handlers[action](options, args[1:])
+        except PipError as e:
+            logger.error(e.args[0])
+            return ERROR
+
+        return SUCCESS
+
+    def get_cache_dir(self, options: Values, args: List[Any]) -> None:
+        if args:
+            raise CommandError("Too many arguments")
+
+        logger.info(options.cache_dir)
+
+    def get_cache_info(self, options: Values, args: List[Any]) -> None:
+        if args:
+            raise CommandError("Too many arguments")
+
+        num_http_files = len(self._find_http_files(options))
+        num_packages = len(self._find_wheels(options, "*"))
+
+        http_cache_location = self._cache_dir(options, "http-v2")
+        old_http_cache_location = self._cache_dir(options, "http")
+        wheels_cache_location = self._cache_dir(options, "wheels")
+        http_cache_size = filesystem.format_size(
+            filesystem.directory_size(http_cache_location)
+            + filesystem.directory_size(old_http_cache_location)
+        )
+        wheels_cache_size = filesystem.format_directory_size(wheels_cache_location)
+
+        message = (
+            textwrap.dedent(
+                """
+                    Package index page cache location (pip v23.3+): {http_cache_location}
+                    Package index page cache location (older pips): {old_http_cache_location}
+                    Package index page cache size: {http_cache_size}
+                    Number of HTTP files: {num_http_files}
+                    Locally built wheels location: {wheels_cache_location}
+                    Locally built wheels size: {wheels_cache_size}
+                    Number of locally built wheels: {package_count}
+                """  # noqa: E501
+            )
+            .format(
+                http_cache_location=http_cache_location,
+                old_http_cache_location=old_http_cache_location,
+                http_cache_size=http_cache_size,
+                num_http_files=num_http_files,
+                wheels_cache_location=wheels_cache_location,
+                package_count=num_packages,
+                wheels_cache_size=wheels_cache_size,
+            )
+            .strip()
+        )
+
+        logger.info(message)
+
+    def list_cache_items(self, options: Values, args: List[Any]) -> None:
+        if len(args) > 1:
+            raise CommandError("Too many arguments")
+
+        if args:
+            pattern = args[0]
+        else:
+            pattern = "*"
+
+        files = self._find_wheels(options, pattern)
+        if options.list_format == "human":
+            self.format_for_human(files)
+        else:
+            self.format_for_abspath(files)
+
+    def format_for_human(self, files: List[str]) -> None:
+        if not files:
+            logger.info("No locally built wheels cached.")
+            return
+
+        results = []
+        for filename in files:
+            wheel = os.path.basename(filename)
+            size = filesystem.format_file_size(filename)
+            results.append(f" - {wheel} ({size})")
+        logger.info("Cache contents:\n")
+        logger.info("\n".join(sorted(results)))
+
+    def format_for_abspath(self, files: List[str]) -> None:
+        if files:
+            logger.info("\n".join(sorted(files)))
+
+    def remove_cache_items(self, options: Values, args: List[Any]) -> None:
+        if len(args) > 1:
+            raise CommandError("Too many arguments")
+
+        if not args:
+            raise CommandError("Please provide a pattern")
+
+        files = self._find_wheels(options, args[0])
+
+        no_matching_msg = "No matching packages"
+        if args[0] == "*":
+            # Only fetch http files if no specific pattern given
+            files += self._find_http_files(options)
+        else:
+            # Add the pattern to the log message
+            no_matching_msg += f' for pattern "{args[0]}"'
+
+        if not files:
+            logger.warning(no_matching_msg)
+
+        for filename in files:
+            os.unlink(filename)
+            logger.verbose("Removed %s", filename)
+        logger.info("Files removed: %s", len(files))
+
+    def purge_cache(self, options: Values, args: List[Any]) -> None:
+        if args:
+            raise CommandError("Too many arguments")
+
+        return self.remove_cache_items(options, ["*"])
+
+    def _cache_dir(self, options: Values, subdir: str) -> str:
+        return os.path.join(options.cache_dir, subdir)
+
+    def _find_http_files(self, options: Values) -> List[str]:
+        old_http_dir = self._cache_dir(options, "http")
+        new_http_dir = self._cache_dir(options, "http-v2")
+        return filesystem.find_files(old_http_dir, "*") + filesystem.find_files(
+            new_http_dir, "*"
+        )
+
+    def _find_wheels(self, options: Values, pattern: str) -> List[str]:
+        wheel_dir = self._cache_dir(options, "wheels")
+
+        # The wheel filename format, as specified in PEP 427, is:
+        #     {distribution}-{version}(-{build})?-{python}-{abi}-{platform}.whl
+        #
+        # Additionally, non-alphanumeric values in the distribution are
+        # normalized to underscores (_), meaning hyphens can never occur
+        # before `-{version}`.
+        #
+        # Given that information:
+        # - If the pattern we're given contains a hyphen (-), the user is
+        #   providing at least the version. Thus, we can just append `*.whl`
+        #   to match the rest of it.
+        # - If the pattern we're given doesn't contain a hyphen (-), the
+        #   user is only providing the name. Thus, we append `-*.whl` to
+        #   match the hyphen before the version, followed by anything else.
+        #
+        # PEP 427: https://www.python.org/dev/peps/pep-0427/
+        pattern = pattern + ("*.whl" if "-" in pattern else "-*.whl")
+
+        return filesystem.find_files(wheel_dir, pattern)
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/commands/check.py b/venv/lib/python3.12/site-packages/pip/_internal/commands/check.py
new file mode 100644
index 00000000..f54a16dc
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/commands/check.py
@@ -0,0 +1,67 @@
+import logging
+from optparse import Values
+from typing import List
+
+from pip._internal.cli.base_command import Command
+from pip._internal.cli.status_codes import ERROR, SUCCESS
+from pip._internal.metadata import get_default_environment
+from pip._internal.operations.check import (
+    check_package_set,
+    check_unsupported,
+    create_package_set_from_installed,
+)
+from pip._internal.utils.compatibility_tags import get_supported
+from pip._internal.utils.misc import write_output
+
+logger = logging.getLogger(__name__)
+
+
+class CheckCommand(Command):
+    """Verify installed packages have compatible dependencies."""
+
+    ignore_require_venv = True
+    usage = """
+      %prog [options]"""
+
+    def run(self, options: Values, args: List[str]) -> int:
+        package_set, parsing_probs = create_package_set_from_installed()
+        missing, conflicting = check_package_set(package_set)
+        unsupported = list(
+            check_unsupported(
+                get_default_environment().iter_installed_distributions(),
+                get_supported(),
+            )
+        )
+
+        for project_name in missing:
+            version = package_set[project_name].version
+            for dependency in missing[project_name]:
+                write_output(
+                    "%s %s requires %s, which is not installed.",
+                    project_name,
+                    version,
+                    dependency[0],
+                )
+
+        for project_name in conflicting:
+            version = package_set[project_name].version
+            for dep_name, dep_version, req in conflicting[project_name]:
+                write_output(
+                    "%s %s has requirement %s, but you have %s %s.",
+                    project_name,
+                    version,
+                    req,
+                    dep_name,
+                    dep_version,
+                )
+        for package in unsupported:
+            write_output(
+                "%s %s is not supported on this platform",
+                package.raw_name,
+                package.version,
+            )
+        if missing or conflicting or parsing_probs or unsupported:
+            return ERROR
+        else:
+            write_output("No broken requirements found.")
+            return SUCCESS
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/commands/completion.py b/venv/lib/python3.12/site-packages/pip/_internal/commands/completion.py
new file mode 100644
index 00000000..9e89e279
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/commands/completion.py
@@ -0,0 +1,130 @@
+import sys
+import textwrap
+from optparse import Values
+from typing import List
+
+from pip._internal.cli.base_command import Command
+from pip._internal.cli.status_codes import SUCCESS
+from pip._internal.utils.misc import get_prog
+
+BASE_COMPLETION = """
+# pip {shell} completion start{script}# pip {shell} completion end
+"""
+
+COMPLETION_SCRIPTS = {
+    "bash": """
+        _pip_completion()
+        {{
+            COMPREPLY=( $( COMP_WORDS="${{COMP_WORDS[*]}}" \\
+                           COMP_CWORD=$COMP_CWORD \\
+                           PIP_AUTO_COMPLETE=1 $1 2>/dev/null ) )
+        }}
+        complete -o default -F _pip_completion {prog}
+    """,
+    "zsh": """
+        #compdef -P pip[0-9.]#
+        __pip() {{
+          compadd $( COMP_WORDS="$words[*]" \\
+                     COMP_CWORD=$((CURRENT-1)) \\
+                     PIP_AUTO_COMPLETE=1 $words[1] 2>/dev/null )
+        }}
+        if [[ $zsh_eval_context[-1] == loadautofunc ]]; then
+          # autoload from fpath, call function directly
+          __pip "$@"
+        else
+          # eval/source/. command, register function for later
+          compdef __pip -P 'pip[0-9.]#'
+        fi
+    """,
+    "fish": """
+        function __fish_complete_pip
+            set -lx COMP_WORDS (commandline -o) ""
+            set -lx COMP_CWORD ( \\
+                math (contains -i -- (commandline -t) $COMP_WORDS)-1 \\
+            )
+            set -lx PIP_AUTO_COMPLETE 1
+            string split \\  -- (eval $COMP_WORDS[1])
+        end
+        complete -fa "(__fish_complete_pip)" -c {prog}
+    """,
+    "powershell": """
+        if ((Test-Path Function:\\TabExpansion) -and -not `
+            (Test-Path Function:\\_pip_completeBackup)) {{
+            Rename-Item Function:\\TabExpansion _pip_completeBackup
+        }}
+        function TabExpansion($line, $lastWord) {{
+            $lastBlock = [regex]::Split($line, '[|;]')[-1].TrimStart()
+            if ($lastBlock.StartsWith("{prog} ")) {{
+                $Env:COMP_WORDS=$lastBlock
+                $Env:COMP_CWORD=$lastBlock.Split().Length - 1
+                $Env:PIP_AUTO_COMPLETE=1
+                (& {prog}).Split()
+                Remove-Item Env:COMP_WORDS
+                Remove-Item Env:COMP_CWORD
+                Remove-Item Env:PIP_AUTO_COMPLETE
+            }}
+            elseif (Test-Path Function:\\_pip_completeBackup) {{
+                # Fall back on existing tab expansion
+                _pip_completeBackup $line $lastWord
+            }}
+        }}
+    """,
+}
+
+
+class CompletionCommand(Command):
+    """A helper command to be used for command completion."""
+
+    ignore_require_venv = True
+
+    def add_options(self) -> None:
+        self.cmd_opts.add_option(
+            "--bash",
+            "-b",
+            action="store_const",
+            const="bash",
+            dest="shell",
+            help="Emit completion code for bash",
+        )
+        self.cmd_opts.add_option(
+            "--zsh",
+            "-z",
+            action="store_const",
+            const="zsh",
+            dest="shell",
+            help="Emit completion code for zsh",
+        )
+        self.cmd_opts.add_option(
+            "--fish",
+            "-f",
+            action="store_const",
+            const="fish",
+            dest="shell",
+            help="Emit completion code for fish",
+        )
+        self.cmd_opts.add_option(
+            "--powershell",
+            "-p",
+            action="store_const",
+            const="powershell",
+            dest="shell",
+            help="Emit completion code for powershell",
+        )
+
+        self.parser.insert_option_group(0, self.cmd_opts)
+
+    def run(self, options: Values, args: List[str]) -> int:
+        """Prints the completion code of the given shell"""
+        shells = COMPLETION_SCRIPTS.keys()
+        shell_options = ["--" + shell for shell in sorted(shells)]
+        if options.shell in shells:
+            script = textwrap.dedent(
+                COMPLETION_SCRIPTS.get(options.shell, "").format(prog=get_prog())
+            )
+            print(BASE_COMPLETION.format(script=script, shell=options.shell))
+            return SUCCESS
+        else:
+            sys.stderr.write(
+                "ERROR: You must pass {}\n".format(" or ".join(shell_options))
+            )
+            return SUCCESS
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/commands/configuration.py b/venv/lib/python3.12/site-packages/pip/_internal/commands/configuration.py
new file mode 100644
index 00000000..1a1dc6b6
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/commands/configuration.py
@@ -0,0 +1,280 @@
+import logging
+import os
+import subprocess
+from optparse import Values
+from typing import Any, List, Optional
+
+from pip._internal.cli.base_command import Command
+from pip._internal.cli.status_codes import ERROR, SUCCESS
+from pip._internal.configuration import (
+    Configuration,
+    Kind,
+    get_configuration_files,
+    kinds,
+)
+from pip._internal.exceptions import PipError
+from pip._internal.utils.logging import indent_log
+from pip._internal.utils.misc import get_prog, write_output
+
+logger = logging.getLogger(__name__)
+
+
+class ConfigurationCommand(Command):
+    """
+    Manage local and global configuration.
+
+    Subcommands:
+
+    - list: List the active configuration (or from the file specified)
+    - edit: Edit the configuration file in an editor
+    - get: Get the value associated with command.option
+    - set: Set the command.option=value
+    - unset: Unset the value associated with command.option
+    - debug: List the configuration files and values defined under them
+
+    Configuration keys should be dot separated command and option name,
+    with the special prefix "global" affecting any command. For example,
+    "pip config set global.index-url https://example.org/" would configure
+    the index url for all commands, but "pip config set download.timeout 10"
+    would configure a 10 second timeout only for "pip download" commands.
+
+    If none of --user, --global and --site are passed, a virtual
+    environment configuration file is used if one is active and the file
+    exists. Otherwise, all modifications happen to the user file by
+    default.
+    """
+
+    ignore_require_venv = True
+    usage = """
+        %prog [] list
+        %prog [] [--editor ] edit
+
+        %prog [] get command.option
+        %prog [] set command.option value
+        %prog [] unset command.option
+        %prog [] debug
+    """
+
+    def add_options(self) -> None:
+        self.cmd_opts.add_option(
+            "--editor",
+            dest="editor",
+            action="store",
+            default=None,
+            help=(
+                "Editor to use to edit the file. Uses VISUAL or EDITOR "
+                "environment variables if not provided."
+            ),
+        )
+
+        self.cmd_opts.add_option(
+            "--global",
+            dest="global_file",
+            action="store_true",
+            default=False,
+            help="Use the system-wide configuration file only",
+        )
+
+        self.cmd_opts.add_option(
+            "--user",
+            dest="user_file",
+            action="store_true",
+            default=False,
+            help="Use the user configuration file only",
+        )
+
+        self.cmd_opts.add_option(
+            "--site",
+            dest="site_file",
+            action="store_true",
+            default=False,
+            help="Use the current environment configuration file only",
+        )
+
+        self.parser.insert_option_group(0, self.cmd_opts)
+
+    def run(self, options: Values, args: List[str]) -> int:
+        handlers = {
+            "list": self.list_values,
+            "edit": self.open_in_editor,
+            "get": self.get_name,
+            "set": self.set_name_value,
+            "unset": self.unset_name,
+            "debug": self.list_config_values,
+        }
+
+        # Determine action
+        if not args or args[0] not in handlers:
+            logger.error(
+                "Need an action (%s) to perform.",
+                ", ".join(sorted(handlers)),
+            )
+            return ERROR
+
+        action = args[0]
+
+        # Determine which configuration files are to be loaded
+        #    Depends on whether the command is modifying.
+        try:
+            load_only = self._determine_file(
+                options, need_value=(action in ["get", "set", "unset", "edit"])
+            )
+        except PipError as e:
+            logger.error(e.args[0])
+            return ERROR
+
+        # Load a new configuration
+        self.configuration = Configuration(
+            isolated=options.isolated_mode, load_only=load_only
+        )
+        self.configuration.load()
+
+        # Error handling happens here, not in the action-handlers.
+        try:
+            handlers[action](options, args[1:])
+        except PipError as e:
+            logger.error(e.args[0])
+            return ERROR
+
+        return SUCCESS
+
+    def _determine_file(self, options: Values, need_value: bool) -> Optional[Kind]:
+        file_options = [
+            key
+            for key, value in (
+                (kinds.USER, options.user_file),
+                (kinds.GLOBAL, options.global_file),
+                (kinds.SITE, options.site_file),
+            )
+            if value
+        ]
+
+        if not file_options:
+            if not need_value:
+                return None
+            # Default to user, unless there's a site file.
+            elif any(
+                os.path.exists(site_config_file)
+                for site_config_file in get_configuration_files()[kinds.SITE]
+            ):
+                return kinds.SITE
+            else:
+                return kinds.USER
+        elif len(file_options) == 1:
+            return file_options[0]
+
+        raise PipError(
+            "Need exactly one file to operate upon "
+            "(--user, --site, --global) to perform."
+        )
+
+    def list_values(self, options: Values, args: List[str]) -> None:
+        self._get_n_args(args, "list", n=0)
+
+        for key, value in sorted(self.configuration.items()):
+            write_output("%s=%r", key, value)
+
+    def get_name(self, options: Values, args: List[str]) -> None:
+        key = self._get_n_args(args, "get [name]", n=1)
+        value = self.configuration.get_value(key)
+
+        write_output("%s", value)
+
+    def set_name_value(self, options: Values, args: List[str]) -> None:
+        key, value = self._get_n_args(args, "set [name] [value]", n=2)
+        self.configuration.set_value(key, value)
+
+        self._save_configuration()
+
+    def unset_name(self, options: Values, args: List[str]) -> None:
+        key = self._get_n_args(args, "unset [name]", n=1)
+        self.configuration.unset_value(key)
+
+        self._save_configuration()
+
+    def list_config_values(self, options: Values, args: List[str]) -> None:
+        """List config key-value pairs across different config files"""
+        self._get_n_args(args, "debug", n=0)
+
+        self.print_env_var_values()
+        # Iterate over config files and print if they exist, and the
+        # key-value pairs present in them if they do
+        for variant, files in sorted(self.configuration.iter_config_files()):
+            write_output("%s:", variant)
+            for fname in files:
+                with indent_log():
+                    file_exists = os.path.exists(fname)
+                    write_output("%s, exists: %r", fname, file_exists)
+                    if file_exists:
+                        self.print_config_file_values(variant)
+
+    def print_config_file_values(self, variant: Kind) -> None:
+        """Get key-value pairs from the file of a variant"""
+        for name, value in self.configuration.get_values_in_config(variant).items():
+            with indent_log():
+                write_output("%s: %s", name, value)
+
+    def print_env_var_values(self) -> None:
+        """Get key-values pairs present as environment variables"""
+        write_output("%s:", "env_var")
+        with indent_log():
+            for key, value in sorted(self.configuration.get_environ_vars()):
+                env_var = f"PIP_{key.upper()}"
+                write_output("%s=%r", env_var, value)
+
+    def open_in_editor(self, options: Values, args: List[str]) -> None:
+        editor = self._determine_editor(options)
+
+        fname = self.configuration.get_file_to_edit()
+        if fname is None:
+            raise PipError("Could not determine appropriate file.")
+        elif '"' in fname:
+            # This shouldn't happen, unless we see a username like that.
+            # If that happens, we'd appreciate a pull request fixing this.
+            raise PipError(
+                f'Can not open an editor for a file name containing "\n{fname}'
+            )
+
+        try:
+            subprocess.check_call(f'{editor} "{fname}"', shell=True)
+        except FileNotFoundError as e:
+            if not e.filename:
+                e.filename = editor
+            raise
+        except subprocess.CalledProcessError as e:
+            raise PipError(f"Editor Subprocess exited with exit code {e.returncode}")
+
+    def _get_n_args(self, args: List[str], example: str, n: int) -> Any:
+        """Helper to make sure the command got the right number of arguments"""
+        if len(args) != n:
+            msg = (
+                f"Got unexpected number of arguments, expected {n}. "
+                f'(example: "{get_prog()} config {example}")'
+            )
+            raise PipError(msg)
+
+        if n == 1:
+            return args[0]
+        else:
+            return args
+
+    def _save_configuration(self) -> None:
+        # We successfully ran a modifying command. Need to save the
+        # configuration.
+        try:
+            self.configuration.save()
+        except Exception:
+            logger.exception(
+                "Unable to save configuration. Please report this as a bug."
+            )
+            raise PipError("Internal Error.")
+
+    def _determine_editor(self, options: Values) -> str:
+        if options.editor is not None:
+            return options.editor
+        elif "VISUAL" in os.environ:
+            return os.environ["VISUAL"]
+        elif "EDITOR" in os.environ:
+            return os.environ["EDITOR"]
+        else:
+            raise PipError("Could not determine editor to use.")
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/commands/debug.py b/venv/lib/python3.12/site-packages/pip/_internal/commands/debug.py
new file mode 100644
index 00000000..567ca967
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/commands/debug.py
@@ -0,0 +1,201 @@
+import locale
+import logging
+import os
+import sys
+from optparse import Values
+from types import ModuleType
+from typing import Any, Dict, List, Optional
+
+import pip._vendor
+from pip._vendor.certifi import where
+from pip._vendor.packaging.version import parse as parse_version
+
+from pip._internal.cli import cmdoptions
+from pip._internal.cli.base_command import Command
+from pip._internal.cli.cmdoptions import make_target_python
+from pip._internal.cli.status_codes import SUCCESS
+from pip._internal.configuration import Configuration
+from pip._internal.metadata import get_environment
+from pip._internal.utils.compat import open_text_resource
+from pip._internal.utils.logging import indent_log
+from pip._internal.utils.misc import get_pip_version
+
+logger = logging.getLogger(__name__)
+
+
+def show_value(name: str, value: Any) -> None:
+    logger.info("%s: %s", name, value)
+
+
+def show_sys_implementation() -> None:
+    logger.info("sys.implementation:")
+    implementation_name = sys.implementation.name
+    with indent_log():
+        show_value("name", implementation_name)
+
+
+def create_vendor_txt_map() -> Dict[str, str]:
+    with open_text_resource("pip._vendor", "vendor.txt") as f:
+        # Purge non version specifying lines.
+        # Also, remove any space prefix or suffixes (including comments).
+        lines = [
+            line.strip().split(" ", 1)[0] for line in f.readlines() if "==" in line
+        ]
+
+    # Transform into "module" -> version dict.
+    return dict(line.split("==", 1) for line in lines)
+
+
+def get_module_from_module_name(module_name: str) -> Optional[ModuleType]:
+    # Module name can be uppercase in vendor.txt for some reason...
+    module_name = module_name.lower().replace("-", "_")
+    # PATCH: setuptools is actually only pkg_resources.
+    if module_name == "setuptools":
+        module_name = "pkg_resources"
+
+    try:
+        __import__(f"pip._vendor.{module_name}", globals(), locals(), level=0)
+        return getattr(pip._vendor, module_name)
+    except ImportError:
+        # We allow 'truststore' to fail to import due
+        # to being unavailable on Python 3.9 and earlier.
+        if module_name == "truststore" and sys.version_info < (3, 10):
+            return None
+        raise
+
+
+def get_vendor_version_from_module(module_name: str) -> Optional[str]:
+    module = get_module_from_module_name(module_name)
+    version = getattr(module, "__version__", None)
+
+    if module and not version:
+        # Try to find version in debundled module info.
+        assert module.__file__ is not None
+        env = get_environment([os.path.dirname(module.__file__)])
+        dist = env.get_distribution(module_name)
+        if dist:
+            version = str(dist.version)
+
+    return version
+
+
+def show_actual_vendor_versions(vendor_txt_versions: Dict[str, str]) -> None:
+    """Log the actual version and print extra info if there is
+    a conflict or if the actual version could not be imported.
+    """
+    for module_name, expected_version in vendor_txt_versions.items():
+        extra_message = ""
+        actual_version = get_vendor_version_from_module(module_name)
+        if not actual_version:
+            extra_message = (
+                " (Unable to locate actual module version, using"
+                " vendor.txt specified version)"
+            )
+            actual_version = expected_version
+        elif parse_version(actual_version) != parse_version(expected_version):
+            extra_message = (
+                " (CONFLICT: vendor.txt suggests version should"
+                f" be {expected_version})"
+            )
+        logger.info("%s==%s%s", module_name, actual_version, extra_message)
+
+
+def show_vendor_versions() -> None:
+    logger.info("vendored library versions:")
+
+    vendor_txt_versions = create_vendor_txt_map()
+    with indent_log():
+        show_actual_vendor_versions(vendor_txt_versions)
+
+
+def show_tags(options: Values) -> None:
+    tag_limit = 10
+
+    target_python = make_target_python(options)
+    tags = target_python.get_sorted_tags()
+
+    # Display the target options that were explicitly provided.
+    formatted_target = target_python.format_given()
+    suffix = ""
+    if formatted_target:
+        suffix = f" (target: {formatted_target})"
+
+    msg = f"Compatible tags: {len(tags)}{suffix}"
+    logger.info(msg)
+
+    if options.verbose < 1 and len(tags) > tag_limit:
+        tags_limited = True
+        tags = tags[:tag_limit]
+    else:
+        tags_limited = False
+
+    with indent_log():
+        for tag in tags:
+            logger.info(str(tag))
+
+        if tags_limited:
+            msg = f"...\n[First {tag_limit} tags shown. Pass --verbose to show all.]"
+            logger.info(msg)
+
+
+def ca_bundle_info(config: Configuration) -> str:
+    levels = {key.split(".", 1)[0] for key, _ in config.items()}
+    if not levels:
+        return "Not specified"
+
+    levels_that_override_global = ["install", "wheel", "download"]
+    global_overriding_level = [
+        level for level in levels if level in levels_that_override_global
+    ]
+    if not global_overriding_level:
+        return "global"
+
+    if "global" in levels:
+        levels.remove("global")
+    return ", ".join(levels)
+
+
+class DebugCommand(Command):
+    """
+    Display debug information.
+    """
+
+    usage = """
+      %prog """
+    ignore_require_venv = True
+
+    def add_options(self) -> None:
+        cmdoptions.add_target_python_options(self.cmd_opts)
+        self.parser.insert_option_group(0, self.cmd_opts)
+        self.parser.config.load()
+
+    def run(self, options: Values, args: List[str]) -> int:
+        logger.warning(
+            "This command is only meant for debugging. "
+            "Do not use this with automation for parsing and getting these "
+            "details, since the output and options of this command may "
+            "change without notice."
+        )
+        show_value("pip version", get_pip_version())
+        show_value("sys.version", sys.version)
+        show_value("sys.executable", sys.executable)
+        show_value("sys.getdefaultencoding", sys.getdefaultencoding())
+        show_value("sys.getfilesystemencoding", sys.getfilesystemencoding())
+        show_value(
+            "locale.getpreferredencoding",
+            locale.getpreferredencoding(),
+        )
+        show_value("sys.platform", sys.platform)
+        show_sys_implementation()
+
+        show_value("'cert' config value", ca_bundle_info(self.parser.config))
+        show_value("REQUESTS_CA_BUNDLE", os.environ.get("REQUESTS_CA_BUNDLE"))
+        show_value("CURL_CA_BUNDLE", os.environ.get("CURL_CA_BUNDLE"))
+        show_value("pip._vendor.certifi.where()", where())
+        show_value("pip._vendor.DEBUNDLED", pip._vendor.DEBUNDLED)
+
+        show_vendor_versions()
+
+        show_tags(options)
+
+        return SUCCESS
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/commands/download.py b/venv/lib/python3.12/site-packages/pip/_internal/commands/download.py
new file mode 100644
index 00000000..917bbb91
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/commands/download.py
@@ -0,0 +1,146 @@
+import logging
+import os
+from optparse import Values
+from typing import List
+
+from pip._internal.cli import cmdoptions
+from pip._internal.cli.cmdoptions import make_target_python
+from pip._internal.cli.req_command import RequirementCommand, with_cleanup
+from pip._internal.cli.status_codes import SUCCESS
+from pip._internal.operations.build.build_tracker import get_build_tracker
+from pip._internal.req.req_install import check_legacy_setup_py_options
+from pip._internal.utils.misc import ensure_dir, normalize_path, write_output
+from pip._internal.utils.temp_dir import TempDirectory
+
+logger = logging.getLogger(__name__)
+
+
+class DownloadCommand(RequirementCommand):
+    """
+    Download packages from:
+
+    - PyPI (and other indexes) using requirement specifiers.
+    - VCS project urls.
+    - Local project directories.
+    - Local or remote source archives.
+
+    pip also supports downloading from "requirements files", which provide
+    an easy way to specify a whole environment to be downloaded.
+    """
+
+    usage = """
+      %prog [options]  [package-index-options] ...
+      %prog [options] -r  [package-index-options] ...
+      %prog [options]  ...
+      %prog [options]  ...
+      %prog [options]  ..."""
+
+    def add_options(self) -> None:
+        self.cmd_opts.add_option(cmdoptions.constraints())
+        self.cmd_opts.add_option(cmdoptions.requirements())
+        self.cmd_opts.add_option(cmdoptions.no_deps())
+        self.cmd_opts.add_option(cmdoptions.global_options())
+        self.cmd_opts.add_option(cmdoptions.no_binary())
+        self.cmd_opts.add_option(cmdoptions.only_binary())
+        self.cmd_opts.add_option(cmdoptions.prefer_binary())
+        self.cmd_opts.add_option(cmdoptions.src())
+        self.cmd_opts.add_option(cmdoptions.pre())
+        self.cmd_opts.add_option(cmdoptions.require_hashes())
+        self.cmd_opts.add_option(cmdoptions.progress_bar())
+        self.cmd_opts.add_option(cmdoptions.no_build_isolation())
+        self.cmd_opts.add_option(cmdoptions.use_pep517())
+        self.cmd_opts.add_option(cmdoptions.no_use_pep517())
+        self.cmd_opts.add_option(cmdoptions.check_build_deps())
+        self.cmd_opts.add_option(cmdoptions.ignore_requires_python())
+
+        self.cmd_opts.add_option(
+            "-d",
+            "--dest",
+            "--destination-dir",
+            "--destination-directory",
+            dest="download_dir",
+            metavar="dir",
+            default=os.curdir,
+            help="Download packages into .",
+        )
+
+        cmdoptions.add_target_python_options(self.cmd_opts)
+
+        index_opts = cmdoptions.make_option_group(
+            cmdoptions.index_group,
+            self.parser,
+        )
+
+        self.parser.insert_option_group(0, index_opts)
+        self.parser.insert_option_group(0, self.cmd_opts)
+
+    @with_cleanup
+    def run(self, options: Values, args: List[str]) -> int:
+        options.ignore_installed = True
+        # editable doesn't really make sense for `pip download`, but the bowels
+        # of the RequirementSet code require that property.
+        options.editables = []
+
+        cmdoptions.check_dist_restriction(options)
+
+        options.download_dir = normalize_path(options.download_dir)
+        ensure_dir(options.download_dir)
+
+        session = self.get_default_session(options)
+
+        target_python = make_target_python(options)
+        finder = self._build_package_finder(
+            options=options,
+            session=session,
+            target_python=target_python,
+            ignore_requires_python=options.ignore_requires_python,
+        )
+
+        build_tracker = self.enter_context(get_build_tracker())
+
+        directory = TempDirectory(
+            delete=not options.no_clean,
+            kind="download",
+            globally_managed=True,
+        )
+
+        reqs = self.get_requirements(args, options, finder, session)
+        check_legacy_setup_py_options(options, reqs)
+
+        preparer = self.make_requirement_preparer(
+            temp_build_dir=directory,
+            options=options,
+            build_tracker=build_tracker,
+            session=session,
+            finder=finder,
+            download_dir=options.download_dir,
+            use_user_site=False,
+            verbosity=self.verbosity,
+        )
+
+        resolver = self.make_resolver(
+            preparer=preparer,
+            finder=finder,
+            options=options,
+            ignore_requires_python=options.ignore_requires_python,
+            use_pep517=options.use_pep517,
+            py_version_info=options.python_version,
+        )
+
+        self.trace_basic_info(finder)
+
+        requirement_set = resolver.resolve(reqs, check_supported_wheels=True)
+
+        downloaded: List[str] = []
+        for req in requirement_set.requirements.values():
+            if req.satisfied_by is None:
+                assert req.name is not None
+                preparer.save_linked_requirement(req)
+                downloaded.append(req.name)
+
+        preparer.prepare_linked_requirements_more(requirement_set.requirements.values())
+
+        if downloaded:
+            write_output("Successfully downloaded %s", " ".join(downloaded))
+
+        return SUCCESS
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/commands/freeze.py b/venv/lib/python3.12/site-packages/pip/_internal/commands/freeze.py
new file mode 100644
index 00000000..885fdfeb
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/commands/freeze.py
@@ -0,0 +1,109 @@
+import sys
+from optparse import Values
+from typing import AbstractSet, List
+
+from pip._internal.cli import cmdoptions
+from pip._internal.cli.base_command import Command
+from pip._internal.cli.status_codes import SUCCESS
+from pip._internal.operations.freeze import freeze
+from pip._internal.utils.compat import stdlib_pkgs
+
+
+def _should_suppress_build_backends() -> bool:
+    return sys.version_info < (3, 12)
+
+
+def _dev_pkgs() -> AbstractSet[str]:
+    pkgs = {"pip"}
+
+    if _should_suppress_build_backends():
+        pkgs |= {"setuptools", "distribute", "wheel"}
+
+    return pkgs
+
+
+class FreezeCommand(Command):
+    """
+    Output installed packages in requirements format.
+
+    packages are listed in a case-insensitive sorted order.
+    """
+
+    ignore_require_venv = True
+    usage = """
+      %prog [options]"""
+    log_streams = ("ext://sys.stderr", "ext://sys.stderr")
+
+    def add_options(self) -> None:
+        self.cmd_opts.add_option(
+            "-r",
+            "--requirement",
+            dest="requirements",
+            action="append",
+            default=[],
+            metavar="file",
+            help=(
+                "Use the order in the given requirements file and its "
+                "comments when generating output. This option can be "
+                "used multiple times."
+            ),
+        )
+        self.cmd_opts.add_option(
+            "-l",
+            "--local",
+            dest="local",
+            action="store_true",
+            default=False,
+            help=(
+                "If in a virtualenv that has global access, do not output "
+                "globally-installed packages."
+            ),
+        )
+        self.cmd_opts.add_option(
+            "--user",
+            dest="user",
+            action="store_true",
+            default=False,
+            help="Only output packages installed in user-site.",
+        )
+        self.cmd_opts.add_option(cmdoptions.list_path())
+        self.cmd_opts.add_option(
+            "--all",
+            dest="freeze_all",
+            action="store_true",
+            help=(
+                "Do not skip these packages in the output:"
+                " {}".format(", ".join(_dev_pkgs()))
+            ),
+        )
+        self.cmd_opts.add_option(
+            "--exclude-editable",
+            dest="exclude_editable",
+            action="store_true",
+            help="Exclude editable package from output.",
+        )
+        self.cmd_opts.add_option(cmdoptions.list_exclude())
+
+        self.parser.insert_option_group(0, self.cmd_opts)
+
+    def run(self, options: Values, args: List[str]) -> int:
+        skip = set(stdlib_pkgs)
+        if not options.freeze_all:
+            skip.update(_dev_pkgs())
+
+        if options.excludes:
+            skip.update(options.excludes)
+
+        cmdoptions.check_list_path_option(options)
+
+        for line in freeze(
+            requirement=options.requirements,
+            local_only=options.local,
+            user_only=options.user,
+            paths=options.path,
+            isolated=options.isolated_mode,
+            skip=skip,
+            exclude_editable=options.exclude_editable,
+        ):
+            sys.stdout.write(line + "\n")
+        return SUCCESS
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/commands/hash.py b/venv/lib/python3.12/site-packages/pip/_internal/commands/hash.py
new file mode 100644
index 00000000..042dac81
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/commands/hash.py
@@ -0,0 +1,59 @@
+import hashlib
+import logging
+import sys
+from optparse import Values
+from typing import List
+
+from pip._internal.cli.base_command import Command
+from pip._internal.cli.status_codes import ERROR, SUCCESS
+from pip._internal.utils.hashes import FAVORITE_HASH, STRONG_HASHES
+from pip._internal.utils.misc import read_chunks, write_output
+
+logger = logging.getLogger(__name__)
+
+
+class HashCommand(Command):
+    """
+    Compute a hash of a local package archive.
+
+    These can be used with --hash in a requirements file to do repeatable
+    installs.
+    """
+
+    usage = "%prog [options]  ..."
+    ignore_require_venv = True
+
+    def add_options(self) -> None:
+        self.cmd_opts.add_option(
+            "-a",
+            "--algorithm",
+            dest="algorithm",
+            choices=STRONG_HASHES,
+            action="store",
+            default=FAVORITE_HASH,
+            help="The hash algorithm to use: one of {}".format(
+                ", ".join(STRONG_HASHES)
+            ),
+        )
+        self.parser.insert_option_group(0, self.cmd_opts)
+
+    def run(self, options: Values, args: List[str]) -> int:
+        if not args:
+            self.parser.print_usage(sys.stderr)
+            return ERROR
+
+        algorithm = options.algorithm
+        for path in args:
+            write_output(
+                "%s:\n--hash=%s:%s", path, algorithm, _hash_of_file(path, algorithm)
+            )
+        return SUCCESS
+
+
+def _hash_of_file(path: str, algorithm: str) -> str:
+    """Return the hash digest of a file."""
+    with open(path, "rb") as archive:
+        hash = hashlib.new(algorithm)
+        for chunk in read_chunks(archive):
+            hash.update(chunk)
+    return hash.hexdigest()
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/commands/help.py b/venv/lib/python3.12/site-packages/pip/_internal/commands/help.py
new file mode 100644
index 00000000..62066318
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/commands/help.py
@@ -0,0 +1,41 @@
+from optparse import Values
+from typing import List
+
+from pip._internal.cli.base_command import Command
+from pip._internal.cli.status_codes import SUCCESS
+from pip._internal.exceptions import CommandError
+
+
+class HelpCommand(Command):
+    """Show help for commands"""
+
+    usage = """
+      %prog """
+    ignore_require_venv = True
+
+    def run(self, options: Values, args: List[str]) -> int:
+        from pip._internal.commands import (
+            commands_dict,
+            create_command,
+            get_similar_commands,
+        )
+
+        try:
+            # 'pip help' with no args is handled by pip.__init__.parseopt()
+            cmd_name = args[0]  # the command we need help for
+        except IndexError:
+            return SUCCESS
+
+        if cmd_name not in commands_dict:
+            guess = get_similar_commands(cmd_name)
+
+            msg = [f'unknown command "{cmd_name}"']
+            if guess:
+                msg.append(f'maybe you meant "{guess}"')
+
+            raise CommandError(" - ".join(msg))
+
+        command = create_command(cmd_name)
+        command.parser.print_help()
+
+        return SUCCESS
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/commands/index.py b/venv/lib/python3.12/site-packages/pip/_internal/commands/index.py
new file mode 100644
index 00000000..2e2661bb
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/commands/index.py
@@ -0,0 +1,139 @@
+import logging
+from optparse import Values
+from typing import Any, Iterable, List, Optional
+
+from pip._vendor.packaging.version import Version
+
+from pip._internal.cli import cmdoptions
+from pip._internal.cli.req_command import IndexGroupCommand
+from pip._internal.cli.status_codes import ERROR, SUCCESS
+from pip._internal.commands.search import print_dist_installation_info
+from pip._internal.exceptions import CommandError, DistributionNotFound, PipError
+from pip._internal.index.collector import LinkCollector
+from pip._internal.index.package_finder import PackageFinder
+from pip._internal.models.selection_prefs import SelectionPreferences
+from pip._internal.models.target_python import TargetPython
+from pip._internal.network.session import PipSession
+from pip._internal.utils.misc import write_output
+
+logger = logging.getLogger(__name__)
+
+
+class IndexCommand(IndexGroupCommand):
+    """
+    Inspect information available from package indexes.
+    """
+
+    ignore_require_venv = True
+    usage = """
+        %prog versions 
+    """
+
+    def add_options(self) -> None:
+        cmdoptions.add_target_python_options(self.cmd_opts)
+
+        self.cmd_opts.add_option(cmdoptions.ignore_requires_python())
+        self.cmd_opts.add_option(cmdoptions.pre())
+        self.cmd_opts.add_option(cmdoptions.no_binary())
+        self.cmd_opts.add_option(cmdoptions.only_binary())
+
+        index_opts = cmdoptions.make_option_group(
+            cmdoptions.index_group,
+            self.parser,
+        )
+
+        self.parser.insert_option_group(0, index_opts)
+        self.parser.insert_option_group(0, self.cmd_opts)
+
+    def run(self, options: Values, args: List[str]) -> int:
+        handlers = {
+            "versions": self.get_available_package_versions,
+        }
+
+        logger.warning(
+            "pip index is currently an experimental command. "
+            "It may be removed/changed in a future release "
+            "without prior warning."
+        )
+
+        # Determine action
+        if not args or args[0] not in handlers:
+            logger.error(
+                "Need an action (%s) to perform.",
+                ", ".join(sorted(handlers)),
+            )
+            return ERROR
+
+        action = args[0]
+
+        # Error handling happens here, not in the action-handlers.
+        try:
+            handlers[action](options, args[1:])
+        except PipError as e:
+            logger.error(e.args[0])
+            return ERROR
+
+        return SUCCESS
+
+    def _build_package_finder(
+        self,
+        options: Values,
+        session: PipSession,
+        target_python: Optional[TargetPython] = None,
+        ignore_requires_python: Optional[bool] = None,
+    ) -> PackageFinder:
+        """
+        Create a package finder appropriate to the index command.
+        """
+        link_collector = LinkCollector.create(session, options=options)
+
+        # Pass allow_yanked=False to ignore yanked versions.
+        selection_prefs = SelectionPreferences(
+            allow_yanked=False,
+            allow_all_prereleases=options.pre,
+            ignore_requires_python=ignore_requires_python,
+        )
+
+        return PackageFinder.create(
+            link_collector=link_collector,
+            selection_prefs=selection_prefs,
+            target_python=target_python,
+        )
+
+    def get_available_package_versions(self, options: Values, args: List[Any]) -> None:
+        if len(args) != 1:
+            raise CommandError("You need to specify exactly one argument")
+
+        target_python = cmdoptions.make_target_python(options)
+        query = args[0]
+
+        with self._build_session(options) as session:
+            finder = self._build_package_finder(
+                options=options,
+                session=session,
+                target_python=target_python,
+                ignore_requires_python=options.ignore_requires_python,
+            )
+
+            versions: Iterable[Version] = (
+                candidate.version for candidate in finder.find_all_candidates(query)
+            )
+
+            if not options.pre:
+                # Remove prereleases
+                versions = (
+                    version for version in versions if not version.is_prerelease
+                )
+            versions = set(versions)
+
+            if not versions:
+                raise DistributionNotFound(
+                    f"No matching distribution found for {query}"
+                )
+
+            formatted_versions = [str(ver) for ver in sorted(versions, reverse=True)]
+            latest = formatted_versions[0]
+
+        write_output(f"{query} ({latest})")
+        write_output("Available versions: {}".format(", ".join(formatted_versions)))
+        print_dist_installation_info(query, latest)
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/commands/inspect.py b/venv/lib/python3.12/site-packages/pip/_internal/commands/inspect.py
new file mode 100644
index 00000000..e810c131
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/commands/inspect.py
@@ -0,0 +1,92 @@
+import logging
+from optparse import Values
+from typing import Any, Dict, List
+
+from pip._vendor.packaging.markers import default_environment
+from pip._vendor.rich import print_json
+
+from pip import __version__
+from pip._internal.cli import cmdoptions
+from pip._internal.cli.base_command import Command
+from pip._internal.cli.status_codes import SUCCESS
+from pip._internal.metadata import BaseDistribution, get_environment
+from pip._internal.utils.compat import stdlib_pkgs
+from pip._internal.utils.urls import path_to_url
+
+logger = logging.getLogger(__name__)
+
+
+class InspectCommand(Command):
+    """
+    Inspect the content of a Python environment and produce a report in JSON format.
+    """
+
+    ignore_require_venv = True
+    usage = """
+      %prog [options]"""
+
+    def add_options(self) -> None:
+        self.cmd_opts.add_option(
+            "--local",
+            action="store_true",
+            default=False,
+            help=(
+                "If in a virtualenv that has global access, do not list "
+                "globally-installed packages."
+            ),
+        )
+        self.cmd_opts.add_option(
+            "--user",
+            dest="user",
+            action="store_true",
+            default=False,
+            help="Only output packages installed in user-site.",
+        )
+        self.cmd_opts.add_option(cmdoptions.list_path())
+        self.parser.insert_option_group(0, self.cmd_opts)
+
+    def run(self, options: Values, args: List[str]) -> int:
+        cmdoptions.check_list_path_option(options)
+        dists = get_environment(options.path).iter_installed_distributions(
+            local_only=options.local,
+            user_only=options.user,
+            skip=set(stdlib_pkgs),
+        )
+        output = {
+            "version": "1",
+            "pip_version": __version__,
+            "installed": [self._dist_to_dict(dist) for dist in dists],
+            "environment": default_environment(),
+            # TODO tags? scheme?
+        }
+        print_json(data=output)
+        return SUCCESS
+
+    def _dist_to_dict(self, dist: BaseDistribution) -> Dict[str, Any]:
+        res: Dict[str, Any] = {
+            "metadata": dist.metadata_dict,
+            "metadata_location": dist.info_location,
+        }
+        # direct_url. Note that we don't have download_info (as in the installation
+        # report) since it is not recorded in installed metadata.
+        direct_url = dist.direct_url
+        if direct_url is not None:
+            res["direct_url"] = direct_url.to_dict()
+        else:
+            # Emulate direct_url for legacy editable installs.
+            editable_project_location = dist.editable_project_location
+            if editable_project_location is not None:
+                res["direct_url"] = {
+                    "url": path_to_url(editable_project_location),
+                    "dir_info": {
+                        "editable": True,
+                    },
+                }
+        # installer
+        installer = dist.installer
+        if dist.installer:
+            res["installer"] = installer
+        # requested
+        if dist.installed_with_dist_info:
+            res["requested"] = dist.requested
+        return res
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/commands/install.py b/venv/lib/python3.12/site-packages/pip/_internal/commands/install.py
new file mode 100644
index 00000000..ad45a2f2
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/commands/install.py
@@ -0,0 +1,783 @@
+import errno
+import json
+import operator
+import os
+import shutil
+import site
+from optparse import SUPPRESS_HELP, Values
+from typing import List, Optional
+
+from pip._vendor.packaging.utils import canonicalize_name
+from pip._vendor.rich import print_json
+
+from pip._internal.cache import WheelCache
+from pip._internal.cli import cmdoptions
+from pip._internal.cli.cmdoptions import make_target_python
+from pip._internal.cli.req_command import (
+    RequirementCommand,
+    with_cleanup,
+)
+from pip._internal.cli.status_codes import ERROR, SUCCESS
+from pip._internal.exceptions import CommandError, InstallationError
+from pip._internal.locations import get_scheme
+from pip._internal.metadata import get_environment
+from pip._internal.models.installation_report import InstallationReport
+from pip._internal.operations.build.build_tracker import get_build_tracker
+from pip._internal.operations.check import ConflictDetails, check_install_conflicts
+from pip._internal.req import install_given_reqs
+from pip._internal.req.req_install import (
+    InstallRequirement,
+    check_legacy_setup_py_options,
+)
+from pip._internal.utils.compat import WINDOWS
+from pip._internal.utils.filesystem import test_writable_dir
+from pip._internal.utils.logging import getLogger
+from pip._internal.utils.misc import (
+    check_externally_managed,
+    ensure_dir,
+    get_pip_version,
+    protect_pip_from_modification_on_windows,
+    warn_if_run_as_root,
+    write_output,
+)
+from pip._internal.utils.temp_dir import TempDirectory
+from pip._internal.utils.virtualenv import (
+    running_under_virtualenv,
+    virtualenv_no_global,
+)
+from pip._internal.wheel_builder import build, should_build_for_install_command
+
+logger = getLogger(__name__)
+
+
+class InstallCommand(RequirementCommand):
+    """
+    Install packages from:
+
+    - PyPI (and other indexes) using requirement specifiers.
+    - VCS project urls.
+    - Local project directories.
+    - Local or remote source archives.
+
+    pip also supports installing from "requirements files", which provide
+    an easy way to specify a whole environment to be installed.
+    """
+
+    usage = """
+      %prog [options]  [package-index-options] ...
+      %prog [options] -r  [package-index-options] ...
+      %prog [options] [-e]  ...
+      %prog [options] [-e]  ...
+      %prog [options]  ..."""
+
+    def add_options(self) -> None:
+        self.cmd_opts.add_option(cmdoptions.requirements())
+        self.cmd_opts.add_option(cmdoptions.constraints())
+        self.cmd_opts.add_option(cmdoptions.no_deps())
+        self.cmd_opts.add_option(cmdoptions.pre())
+
+        self.cmd_opts.add_option(cmdoptions.editable())
+        self.cmd_opts.add_option(
+            "--dry-run",
+            action="store_true",
+            dest="dry_run",
+            default=False,
+            help=(
+                "Don't actually install anything, just print what would be. "
+                "Can be used in combination with --ignore-installed "
+                "to 'resolve' the requirements."
+            ),
+        )
+        self.cmd_opts.add_option(
+            "-t",
+            "--target",
+            dest="target_dir",
+            metavar="dir",
+            default=None,
+            help=(
+                "Install packages into . "
+                "By default this will not replace existing files/folders in "
+                ". Use --upgrade to replace existing packages in  "
+                "with new versions."
+            ),
+        )
+        cmdoptions.add_target_python_options(self.cmd_opts)
+
+        self.cmd_opts.add_option(
+            "--user",
+            dest="use_user_site",
+            action="store_true",
+            help=(
+                "Install to the Python user install directory for your "
+                "platform. Typically ~/.local/, or %APPDATA%\\Python on "
+                "Windows. (See the Python documentation for site.USER_BASE "
+                "for full details.)"
+            ),
+        )
+        self.cmd_opts.add_option(
+            "--no-user",
+            dest="use_user_site",
+            action="store_false",
+            help=SUPPRESS_HELP,
+        )
+        self.cmd_opts.add_option(
+            "--root",
+            dest="root_path",
+            metavar="dir",
+            default=None,
+            help="Install everything relative to this alternate root directory.",
+        )
+        self.cmd_opts.add_option(
+            "--prefix",
+            dest="prefix_path",
+            metavar="dir",
+            default=None,
+            help=(
+                "Installation prefix where lib, bin and other top-level "
+                "folders are placed. Note that the resulting installation may "
+                "contain scripts and other resources which reference the "
+                "Python interpreter of pip, and not that of ``--prefix``. "
+                "See also the ``--python`` option if the intention is to "
+                "install packages into another (possibly pip-free) "
+                "environment."
+            ),
+        )
+
+        self.cmd_opts.add_option(cmdoptions.src())
+
+        self.cmd_opts.add_option(
+            "-U",
+            "--upgrade",
+            dest="upgrade",
+            action="store_true",
+            help=(
+                "Upgrade all specified packages to the newest available "
+                "version. The handling of dependencies depends on the "
+                "upgrade-strategy used."
+            ),
+        )
+
+        self.cmd_opts.add_option(
+            "--upgrade-strategy",
+            dest="upgrade_strategy",
+            default="only-if-needed",
+            choices=["only-if-needed", "eager"],
+            help=(
+                "Determines how dependency upgrading should be handled "
+                "[default: %default]. "
+                '"eager" - dependencies are upgraded regardless of '
+                "whether the currently installed version satisfies the "
+                "requirements of the upgraded package(s). "
+                '"only-if-needed" -  are upgraded only when they do not '
+                "satisfy the requirements of the upgraded package(s)."
+            ),
+        )
+
+        self.cmd_opts.add_option(
+            "--force-reinstall",
+            dest="force_reinstall",
+            action="store_true",
+            help="Reinstall all packages even if they are already up-to-date.",
+        )
+
+        self.cmd_opts.add_option(
+            "-I",
+            "--ignore-installed",
+            dest="ignore_installed",
+            action="store_true",
+            help=(
+                "Ignore the installed packages, overwriting them. "
+                "This can break your system if the existing package "
+                "is of a different version or was installed "
+                "with a different package manager!"
+            ),
+        )
+
+        self.cmd_opts.add_option(cmdoptions.ignore_requires_python())
+        self.cmd_opts.add_option(cmdoptions.no_build_isolation())
+        self.cmd_opts.add_option(cmdoptions.use_pep517())
+        self.cmd_opts.add_option(cmdoptions.no_use_pep517())
+        self.cmd_opts.add_option(cmdoptions.check_build_deps())
+        self.cmd_opts.add_option(cmdoptions.override_externally_managed())
+
+        self.cmd_opts.add_option(cmdoptions.config_settings())
+        self.cmd_opts.add_option(cmdoptions.global_options())
+
+        self.cmd_opts.add_option(
+            "--compile",
+            action="store_true",
+            dest="compile",
+            default=True,
+            help="Compile Python source files to bytecode",
+        )
+
+        self.cmd_opts.add_option(
+            "--no-compile",
+            action="store_false",
+            dest="compile",
+            help="Do not compile Python source files to bytecode",
+        )
+
+        self.cmd_opts.add_option(
+            "--no-warn-script-location",
+            action="store_false",
+            dest="warn_script_location",
+            default=True,
+            help="Do not warn when installing scripts outside PATH",
+        )
+        self.cmd_opts.add_option(
+            "--no-warn-conflicts",
+            action="store_false",
+            dest="warn_about_conflicts",
+            default=True,
+            help="Do not warn about broken dependencies",
+        )
+        self.cmd_opts.add_option(cmdoptions.no_binary())
+        self.cmd_opts.add_option(cmdoptions.only_binary())
+        self.cmd_opts.add_option(cmdoptions.prefer_binary())
+        self.cmd_opts.add_option(cmdoptions.require_hashes())
+        self.cmd_opts.add_option(cmdoptions.progress_bar())
+        self.cmd_opts.add_option(cmdoptions.root_user_action())
+
+        index_opts = cmdoptions.make_option_group(
+            cmdoptions.index_group,
+            self.parser,
+        )
+
+        self.parser.insert_option_group(0, index_opts)
+        self.parser.insert_option_group(0, self.cmd_opts)
+
+        self.cmd_opts.add_option(
+            "--report",
+            dest="json_report_file",
+            metavar="file",
+            default=None,
+            help=(
+                "Generate a JSON file describing what pip did to install "
+                "the provided requirements. "
+                "Can be used in combination with --dry-run and --ignore-installed "
+                "to 'resolve' the requirements. "
+                "When - is used as file name it writes to stdout. "
+                "When writing to stdout, please combine with the --quiet option "
+                "to avoid mixing pip logging output with JSON output."
+            ),
+        )
+
+    @with_cleanup
+    def run(self, options: Values, args: List[str]) -> int:
+        if options.use_user_site and options.target_dir is not None:
+            raise CommandError("Can not combine '--user' and '--target'")
+
+        # Check whether the environment we're installing into is externally
+        # managed, as specified in PEP 668. Specifying --root, --target, or
+        # --prefix disables the check, since there's no reliable way to locate
+        # the EXTERNALLY-MANAGED file for those cases. An exception is also
+        # made specifically for "--dry-run --report" for convenience.
+        installing_into_current_environment = (
+            not (options.dry_run and options.json_report_file)
+            and options.root_path is None
+            and options.target_dir is None
+            and options.prefix_path is None
+        )
+        if (
+            installing_into_current_environment
+            and not options.override_externally_managed
+        ):
+            check_externally_managed()
+
+        upgrade_strategy = "to-satisfy-only"
+        if options.upgrade:
+            upgrade_strategy = options.upgrade_strategy
+
+        cmdoptions.check_dist_restriction(options, check_target=True)
+
+        logger.verbose("Using %s", get_pip_version())
+        options.use_user_site = decide_user_install(
+            options.use_user_site,
+            prefix_path=options.prefix_path,
+            target_dir=options.target_dir,
+            root_path=options.root_path,
+            isolated_mode=options.isolated_mode,
+        )
+
+        target_temp_dir: Optional[TempDirectory] = None
+        target_temp_dir_path: Optional[str] = None
+        if options.target_dir:
+            options.ignore_installed = True
+            options.target_dir = os.path.abspath(options.target_dir)
+            if (
+                # fmt: off
+                os.path.exists(options.target_dir) and
+                not os.path.isdir(options.target_dir)
+                # fmt: on
+            ):
+                raise CommandError(
+                    "Target path exists but is not a directory, will not continue."
+                )
+
+            # Create a target directory for using with the target option
+            target_temp_dir = TempDirectory(kind="target")
+            target_temp_dir_path = target_temp_dir.path
+            self.enter_context(target_temp_dir)
+
+        global_options = options.global_options or []
+
+        session = self.get_default_session(options)
+
+        target_python = make_target_python(options)
+        finder = self._build_package_finder(
+            options=options,
+            session=session,
+            target_python=target_python,
+            ignore_requires_python=options.ignore_requires_python,
+        )
+        build_tracker = self.enter_context(get_build_tracker())
+
+        directory = TempDirectory(
+            delete=not options.no_clean,
+            kind="install",
+            globally_managed=True,
+        )
+
+        try:
+            reqs = self.get_requirements(args, options, finder, session)
+            check_legacy_setup_py_options(options, reqs)
+
+            wheel_cache = WheelCache(options.cache_dir)
+
+            # Only when installing is it permitted to use PEP 660.
+            # In other circumstances (pip wheel, pip download) we generate
+            # regular (i.e. non editable) metadata and wheels.
+            for req in reqs:
+                req.permit_editable_wheels = True
+
+            preparer = self.make_requirement_preparer(
+                temp_build_dir=directory,
+                options=options,
+                build_tracker=build_tracker,
+                session=session,
+                finder=finder,
+                use_user_site=options.use_user_site,
+                verbosity=self.verbosity,
+            )
+            resolver = self.make_resolver(
+                preparer=preparer,
+                finder=finder,
+                options=options,
+                wheel_cache=wheel_cache,
+                use_user_site=options.use_user_site,
+                ignore_installed=options.ignore_installed,
+                ignore_requires_python=options.ignore_requires_python,
+                force_reinstall=options.force_reinstall,
+                upgrade_strategy=upgrade_strategy,
+                use_pep517=options.use_pep517,
+                py_version_info=options.python_version,
+            )
+
+            self.trace_basic_info(finder)
+
+            requirement_set = resolver.resolve(
+                reqs, check_supported_wheels=not options.target_dir
+            )
+
+            if options.json_report_file:
+                report = InstallationReport(requirement_set.requirements_to_install)
+                if options.json_report_file == "-":
+                    print_json(data=report.to_dict())
+                else:
+                    with open(options.json_report_file, "w", encoding="utf-8") as f:
+                        json.dump(report.to_dict(), f, indent=2, ensure_ascii=False)
+
+            if options.dry_run:
+                would_install_items = sorted(
+                    (r.metadata["name"], r.metadata["version"])
+                    for r in requirement_set.requirements_to_install
+                )
+                if would_install_items:
+                    write_output(
+                        "Would install %s",
+                        " ".join("-".join(item) for item in would_install_items),
+                    )
+                return SUCCESS
+
+            try:
+                pip_req = requirement_set.get_requirement("pip")
+            except KeyError:
+                modifying_pip = False
+            else:
+                # If we're not replacing an already installed pip,
+                # we're not modifying it.
+                modifying_pip = pip_req.satisfied_by is None
+                if modifying_pip:
+                    # Eagerly import this module to avoid crashes. Otherwise, this
+                    # module would be imported *after* pip was replaced, resulting in
+                    # crashes if the new self_outdated_check module was incompatible
+                    # with the rest of pip that's already imported.
+                    import pip._internal.self_outdated_check  # noqa: F401
+            protect_pip_from_modification_on_windows(modifying_pip=modifying_pip)
+
+            reqs_to_build = [
+                r
+                for r in requirement_set.requirements.values()
+                if should_build_for_install_command(r)
+            ]
+
+            _, build_failures = build(
+                reqs_to_build,
+                wheel_cache=wheel_cache,
+                verify=True,
+                build_options=[],
+                global_options=global_options,
+            )
+
+            if build_failures:
+                raise InstallationError(
+                    "ERROR: Failed to build installable wheels for some "
+                    "pyproject.toml based projects ({})".format(
+                        ", ".join(r.name for r in build_failures)  # type: ignore
+                    )
+                )
+
+            to_install = resolver.get_installation_order(requirement_set)
+
+            # Check for conflicts in the package set we're installing.
+            conflicts: Optional[ConflictDetails] = None
+            should_warn_about_conflicts = (
+                not options.ignore_dependencies and options.warn_about_conflicts
+            )
+            if should_warn_about_conflicts:
+                conflicts = self._determine_conflicts(to_install)
+
+            # Don't warn about script install locations if
+            # --target or --prefix has been specified
+            warn_script_location = options.warn_script_location
+            if options.target_dir or options.prefix_path:
+                warn_script_location = False
+
+            installed = install_given_reqs(
+                to_install,
+                global_options,
+                root=options.root_path,
+                home=target_temp_dir_path,
+                prefix=options.prefix_path,
+                warn_script_location=warn_script_location,
+                use_user_site=options.use_user_site,
+                pycompile=options.compile,
+            )
+
+            lib_locations = get_lib_location_guesses(
+                user=options.use_user_site,
+                home=target_temp_dir_path,
+                root=options.root_path,
+                prefix=options.prefix_path,
+                isolated=options.isolated_mode,
+            )
+            env = get_environment(lib_locations)
+
+            # Display a summary of installed packages, with extra care to
+            # display a package name as it was requested by the user.
+            installed.sort(key=operator.attrgetter("name"))
+            summary = []
+            installed_versions = {}
+            for distribution in env.iter_all_distributions():
+                installed_versions[distribution.canonical_name] = distribution.version
+            for package in installed:
+                display_name = package.name
+                version = installed_versions.get(canonicalize_name(display_name), None)
+                if version:
+                    text = f"{display_name}-{version}"
+                else:
+                    text = display_name
+                summary.append(text)
+
+            if conflicts is not None:
+                self._warn_about_conflicts(
+                    conflicts,
+                    resolver_variant=self.determine_resolver_variant(options),
+                )
+
+            installed_desc = " ".join(summary)
+            if installed_desc:
+                write_output(
+                    "Successfully installed %s",
+                    installed_desc,
+                )
+        except OSError as error:
+            show_traceback = self.verbosity >= 1
+
+            message = create_os_error_message(
+                error,
+                show_traceback,
+                options.use_user_site,
+            )
+            logger.error(message, exc_info=show_traceback)
+
+            return ERROR
+
+        if options.target_dir:
+            assert target_temp_dir
+            self._handle_target_dir(
+                options.target_dir, target_temp_dir, options.upgrade
+            )
+        if options.root_user_action == "warn":
+            warn_if_run_as_root()
+        return SUCCESS
+
+    def _handle_target_dir(
+        self, target_dir: str, target_temp_dir: TempDirectory, upgrade: bool
+    ) -> None:
+        ensure_dir(target_dir)
+
+        # Checking both purelib and platlib directories for installed
+        # packages to be moved to target directory
+        lib_dir_list = []
+
+        # Checking both purelib and platlib directories for installed
+        # packages to be moved to target directory
+        scheme = get_scheme("", home=target_temp_dir.path)
+        purelib_dir = scheme.purelib
+        platlib_dir = scheme.platlib
+        data_dir = scheme.data
+
+        if os.path.exists(purelib_dir):
+            lib_dir_list.append(purelib_dir)
+        if os.path.exists(platlib_dir) and platlib_dir != purelib_dir:
+            lib_dir_list.append(platlib_dir)
+        if os.path.exists(data_dir):
+            lib_dir_list.append(data_dir)
+
+        for lib_dir in lib_dir_list:
+            for item in os.listdir(lib_dir):
+                if lib_dir == data_dir:
+                    ddir = os.path.join(data_dir, item)
+                    if any(s.startswith(ddir) for s in lib_dir_list[:-1]):
+                        continue
+                target_item_dir = os.path.join(target_dir, item)
+                if os.path.exists(target_item_dir):
+                    if not upgrade:
+                        logger.warning(
+                            "Target directory %s already exists. Specify "
+                            "--upgrade to force replacement.",
+                            target_item_dir,
+                        )
+                        continue
+                    if os.path.islink(target_item_dir):
+                        logger.warning(
+                            "Target directory %s already exists and is "
+                            "a link. pip will not automatically replace "
+                            "links, please remove if replacement is "
+                            "desired.",
+                            target_item_dir,
+                        )
+                        continue
+                    if os.path.isdir(target_item_dir):
+                        shutil.rmtree(target_item_dir)
+                    else:
+                        os.remove(target_item_dir)
+
+                shutil.move(os.path.join(lib_dir, item), target_item_dir)
+
+    def _determine_conflicts(
+        self, to_install: List[InstallRequirement]
+    ) -> Optional[ConflictDetails]:
+        try:
+            return check_install_conflicts(to_install)
+        except Exception:
+            logger.exception(
+                "Error while checking for conflicts. Please file an issue on "
+                "pip's issue tracker: https://github.com/pypa/pip/issues/new"
+            )
+            return None
+
+    def _warn_about_conflicts(
+        self, conflict_details: ConflictDetails, resolver_variant: str
+    ) -> None:
+        package_set, (missing, conflicting) = conflict_details
+        if not missing and not conflicting:
+            return
+
+        parts: List[str] = []
+        if resolver_variant == "legacy":
+            parts.append(
+                "pip's legacy dependency resolver does not consider dependency "
+                "conflicts when selecting packages. This behaviour is the "
+                "source of the following dependency conflicts."
+            )
+        else:
+            assert resolver_variant == "resolvelib"
+            parts.append(
+                "pip's dependency resolver does not currently take into account "
+                "all the packages that are installed. This behaviour is the "
+                "source of the following dependency conflicts."
+            )
+
+        # NOTE: There is some duplication here, with commands/check.py
+        for project_name in missing:
+            version = package_set[project_name][0]
+            for dependency in missing[project_name]:
+                message = (
+                    f"{project_name} {version} requires {dependency[1]}, "
+                    "which is not installed."
+                )
+                parts.append(message)
+
+        for project_name in conflicting:
+            version = package_set[project_name][0]
+            for dep_name, dep_version, req in conflicting[project_name]:
+                message = (
+                    "{name} {version} requires {requirement}, but {you} have "
+                    "{dep_name} {dep_version} which is incompatible."
+                ).format(
+                    name=project_name,
+                    version=version,
+                    requirement=req,
+                    dep_name=dep_name,
+                    dep_version=dep_version,
+                    you=("you" if resolver_variant == "resolvelib" else "you'll"),
+                )
+                parts.append(message)
+
+        logger.critical("\n".join(parts))
+
+
+def get_lib_location_guesses(
+    user: bool = False,
+    home: Optional[str] = None,
+    root: Optional[str] = None,
+    isolated: bool = False,
+    prefix: Optional[str] = None,
+) -> List[str]:
+    scheme = get_scheme(
+        "",
+        user=user,
+        home=home,
+        root=root,
+        isolated=isolated,
+        prefix=prefix,
+    )
+    return [scheme.purelib, scheme.platlib]
+
+
+def site_packages_writable(root: Optional[str], isolated: bool) -> bool:
+    return all(
+        test_writable_dir(d)
+        for d in set(get_lib_location_guesses(root=root, isolated=isolated))
+    )
+
+
+def decide_user_install(
+    use_user_site: Optional[bool],
+    prefix_path: Optional[str] = None,
+    target_dir: Optional[str] = None,
+    root_path: Optional[str] = None,
+    isolated_mode: bool = False,
+) -> bool:
+    """Determine whether to do a user install based on the input options.
+
+    If use_user_site is False, no additional checks are done.
+    If use_user_site is True, it is checked for compatibility with other
+    options.
+    If use_user_site is None, the default behaviour depends on the environment,
+    which is provided by the other arguments.
+    """
+    # In some cases (config from tox), use_user_site can be set to an integer
+    # rather than a bool, which 'use_user_site is False' wouldn't catch.
+    if (use_user_site is not None) and (not use_user_site):
+        logger.debug("Non-user install by explicit request")
+        return False
+
+    if use_user_site:
+        if prefix_path:
+            raise CommandError(
+                "Can not combine '--user' and '--prefix' as they imply "
+                "different installation locations"
+            )
+        if virtualenv_no_global():
+            raise InstallationError(
+                "Can not perform a '--user' install. User site-packages "
+                "are not visible in this virtualenv."
+            )
+        logger.debug("User install by explicit request")
+        return True
+
+    # If we are here, user installs have not been explicitly requested/avoided
+    assert use_user_site is None
+
+    # user install incompatible with --prefix/--target
+    if prefix_path or target_dir:
+        logger.debug("Non-user install due to --prefix or --target option")
+        return False
+
+    # If user installs are not enabled, choose a non-user install
+    if not site.ENABLE_USER_SITE:
+        logger.debug("Non-user install because user site-packages disabled")
+        return False
+
+    # If we have permission for a non-user install, do that,
+    # otherwise do a user install.
+    if site_packages_writable(root=root_path, isolated=isolated_mode):
+        logger.debug("Non-user install because site-packages writeable")
+        return False
+
+    logger.info(
+        "Defaulting to user installation because normal site-packages "
+        "is not writeable"
+    )
+    return True
+
+
+def create_os_error_message(
+    error: OSError, show_traceback: bool, using_user_site: bool
+) -> str:
+    """Format an error message for an OSError
+
+    It may occur anytime during the execution of the install command.
+    """
+    parts = []
+
+    # Mention the error if we are not going to show a traceback
+    parts.append("Could not install packages due to an OSError")
+    if not show_traceback:
+        parts.append(": ")
+        parts.append(str(error))
+    else:
+        parts.append(".")
+
+    # Spilt the error indication from a helper message (if any)
+    parts[-1] += "\n"
+
+    # Suggest useful actions to the user:
+    #  (1) using user site-packages or (2) verifying the permissions
+    if error.errno == errno.EACCES:
+        user_option_part = "Consider using the `--user` option"
+        permissions_part = "Check the permissions"
+
+        if not running_under_virtualenv() and not using_user_site:
+            parts.extend(
+                [
+                    user_option_part,
+                    " or ",
+                    permissions_part.lower(),
+                ]
+            )
+        else:
+            parts.append(permissions_part)
+        parts.append(".\n")
+
+    # Suggest the user to enable Long Paths if path length is
+    # more than 260
+    if (
+        WINDOWS
+        and error.errno == errno.ENOENT
+        and error.filename
+        and len(error.filename) > 260
+    ):
+        parts.append(
+            "HINT: This error might have occurred since "
+            "this system does not have Windows Long Path "
+            "support enabled. You can find information on "
+            "how to enable this at "
+            "https://pip.pypa.io/warnings/enable-long-paths\n"
+        )
+
+    return "".join(parts).strip() + "\n"
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/commands/list.py b/venv/lib/python3.12/site-packages/pip/_internal/commands/list.py
new file mode 100644
index 00000000..82fc46a1
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/commands/list.py
@@ -0,0 +1,375 @@
+import json
+import logging
+from optparse import Values
+from typing import TYPE_CHECKING, Generator, List, Optional, Sequence, Tuple, cast
+
+from pip._vendor.packaging.utils import canonicalize_name
+from pip._vendor.packaging.version import Version
+
+from pip._internal.cli import cmdoptions
+from pip._internal.cli.index_command import IndexGroupCommand
+from pip._internal.cli.status_codes import SUCCESS
+from pip._internal.exceptions import CommandError
+from pip._internal.metadata import BaseDistribution, get_environment
+from pip._internal.models.selection_prefs import SelectionPreferences
+from pip._internal.utils.compat import stdlib_pkgs
+from pip._internal.utils.misc import tabulate, write_output
+
+if TYPE_CHECKING:
+    from pip._internal.index.package_finder import PackageFinder
+    from pip._internal.network.session import PipSession
+
+    class _DistWithLatestInfo(BaseDistribution):
+        """Give the distribution object a couple of extra fields.
+
+        These will be populated during ``get_outdated()``. This is dirty but
+        makes the rest of the code much cleaner.
+        """
+
+        latest_version: Version
+        latest_filetype: str
+
+    _ProcessedDists = Sequence[_DistWithLatestInfo]
+
+
+logger = logging.getLogger(__name__)
+
+
+class ListCommand(IndexGroupCommand):
+    """
+    List installed packages, including editables.
+
+    Packages are listed in a case-insensitive sorted order.
+    """
+
+    ignore_require_venv = True
+    usage = """
+      %prog [options]"""
+
+    def add_options(self) -> None:
+        self.cmd_opts.add_option(
+            "-o",
+            "--outdated",
+            action="store_true",
+            default=False,
+            help="List outdated packages",
+        )
+        self.cmd_opts.add_option(
+            "-u",
+            "--uptodate",
+            action="store_true",
+            default=False,
+            help="List uptodate packages",
+        )
+        self.cmd_opts.add_option(
+            "-e",
+            "--editable",
+            action="store_true",
+            default=False,
+            help="List editable projects.",
+        )
+        self.cmd_opts.add_option(
+            "-l",
+            "--local",
+            action="store_true",
+            default=False,
+            help=(
+                "If in a virtualenv that has global access, do not list "
+                "globally-installed packages."
+            ),
+        )
+        self.cmd_opts.add_option(
+            "--user",
+            dest="user",
+            action="store_true",
+            default=False,
+            help="Only output packages installed in user-site.",
+        )
+        self.cmd_opts.add_option(cmdoptions.list_path())
+        self.cmd_opts.add_option(
+            "--pre",
+            action="store_true",
+            default=False,
+            help=(
+                "Include pre-release and development versions. By default, "
+                "pip only finds stable versions."
+            ),
+        )
+
+        self.cmd_opts.add_option(
+            "--format",
+            action="store",
+            dest="list_format",
+            default="columns",
+            choices=("columns", "freeze", "json"),
+            help=(
+                "Select the output format among: columns (default), freeze, or json. "
+                "The 'freeze' format cannot be used with the --outdated option."
+            ),
+        )
+
+        self.cmd_opts.add_option(
+            "--not-required",
+            action="store_true",
+            dest="not_required",
+            help="List packages that are not dependencies of installed packages.",
+        )
+
+        self.cmd_opts.add_option(
+            "--exclude-editable",
+            action="store_false",
+            dest="include_editable",
+            help="Exclude editable package from output.",
+        )
+        self.cmd_opts.add_option(
+            "--include-editable",
+            action="store_true",
+            dest="include_editable",
+            help="Include editable package from output.",
+            default=True,
+        )
+        self.cmd_opts.add_option(cmdoptions.list_exclude())
+        index_opts = cmdoptions.make_option_group(cmdoptions.index_group, self.parser)
+
+        self.parser.insert_option_group(0, index_opts)
+        self.parser.insert_option_group(0, self.cmd_opts)
+
+    def handle_pip_version_check(self, options: Values) -> None:
+        if options.outdated or options.uptodate:
+            super().handle_pip_version_check(options)
+
+    def _build_package_finder(
+        self, options: Values, session: "PipSession"
+    ) -> "PackageFinder":
+        """
+        Create a package finder appropriate to this list command.
+        """
+        # Lazy import the heavy index modules as most list invocations won't need 'em.
+        from pip._internal.index.collector import LinkCollector
+        from pip._internal.index.package_finder import PackageFinder
+
+        link_collector = LinkCollector.create(session, options=options)
+
+        # Pass allow_yanked=False to ignore yanked versions.
+        selection_prefs = SelectionPreferences(
+            allow_yanked=False,
+            allow_all_prereleases=options.pre,
+        )
+
+        return PackageFinder.create(
+            link_collector=link_collector,
+            selection_prefs=selection_prefs,
+        )
+
+    def run(self, options: Values, args: List[str]) -> int:
+        if options.outdated and options.uptodate:
+            raise CommandError("Options --outdated and --uptodate cannot be combined.")
+
+        if options.outdated and options.list_format == "freeze":
+            raise CommandError(
+                "List format 'freeze' cannot be used with the --outdated option."
+            )
+
+        cmdoptions.check_list_path_option(options)
+
+        skip = set(stdlib_pkgs)
+        if options.excludes:
+            skip.update(canonicalize_name(n) for n in options.excludes)
+
+        packages: "_ProcessedDists" = [
+            cast("_DistWithLatestInfo", d)
+            for d in get_environment(options.path).iter_installed_distributions(
+                local_only=options.local,
+                user_only=options.user,
+                editables_only=options.editable,
+                include_editables=options.include_editable,
+                skip=skip,
+            )
+        ]
+
+        # get_not_required must be called firstly in order to find and
+        # filter out all dependencies correctly. Otherwise a package
+        # can't be identified as requirement because some parent packages
+        # could be filtered out before.
+        if options.not_required:
+            packages = self.get_not_required(packages, options)
+
+        if options.outdated:
+            packages = self.get_outdated(packages, options)
+        elif options.uptodate:
+            packages = self.get_uptodate(packages, options)
+
+        self.output_package_listing(packages, options)
+        return SUCCESS
+
+    def get_outdated(
+        self, packages: "_ProcessedDists", options: Values
+    ) -> "_ProcessedDists":
+        return [
+            dist
+            for dist in self.iter_packages_latest_infos(packages, options)
+            if dist.latest_version > dist.version
+        ]
+
+    def get_uptodate(
+        self, packages: "_ProcessedDists", options: Values
+    ) -> "_ProcessedDists":
+        return [
+            dist
+            for dist in self.iter_packages_latest_infos(packages, options)
+            if dist.latest_version == dist.version
+        ]
+
+    def get_not_required(
+        self, packages: "_ProcessedDists", options: Values
+    ) -> "_ProcessedDists":
+        dep_keys = {
+            canonicalize_name(dep.name)
+            for dist in packages
+            for dep in (dist.iter_dependencies() or ())
+        }
+
+        # Create a set to remove duplicate packages, and cast it to a list
+        # to keep the return type consistent with get_outdated and
+        # get_uptodate
+        return list({pkg for pkg in packages if pkg.canonical_name not in dep_keys})
+
+    def iter_packages_latest_infos(
+        self, packages: "_ProcessedDists", options: Values
+    ) -> Generator["_DistWithLatestInfo", None, None]:
+        with self._build_session(options) as session:
+            finder = self._build_package_finder(options, session)
+
+            def latest_info(
+                dist: "_DistWithLatestInfo",
+            ) -> Optional["_DistWithLatestInfo"]:
+                all_candidates = finder.find_all_candidates(dist.canonical_name)
+                if not options.pre:
+                    # Remove prereleases
+                    all_candidates = [
+                        candidate
+                        for candidate in all_candidates
+                        if not candidate.version.is_prerelease
+                    ]
+
+                evaluator = finder.make_candidate_evaluator(
+                    project_name=dist.canonical_name,
+                )
+                best_candidate = evaluator.sort_best_candidate(all_candidates)
+                if best_candidate is None:
+                    return None
+
+                remote_version = best_candidate.version
+                if best_candidate.link.is_wheel:
+                    typ = "wheel"
+                else:
+                    typ = "sdist"
+                dist.latest_version = remote_version
+                dist.latest_filetype = typ
+                return dist
+
+            for dist in map(latest_info, packages):
+                if dist is not None:
+                    yield dist
+
+    def output_package_listing(
+        self, packages: "_ProcessedDists", options: Values
+    ) -> None:
+        packages = sorted(
+            packages,
+            key=lambda dist: dist.canonical_name,
+        )
+        if options.list_format == "columns" and packages:
+            data, header = format_for_columns(packages, options)
+            self.output_package_listing_columns(data, header)
+        elif options.list_format == "freeze":
+            for dist in packages:
+                if options.verbose >= 1:
+                    write_output(
+                        "%s==%s (%s)", dist.raw_name, dist.version, dist.location
+                    )
+                else:
+                    write_output("%s==%s", dist.raw_name, dist.version)
+        elif options.list_format == "json":
+            write_output(format_for_json(packages, options))
+
+    def output_package_listing_columns(
+        self, data: List[List[str]], header: List[str]
+    ) -> None:
+        # insert the header first: we need to know the size of column names
+        if len(data) > 0:
+            data.insert(0, header)
+
+        pkg_strings, sizes = tabulate(data)
+
+        # Create and add a separator.
+        if len(data) > 0:
+            pkg_strings.insert(1, " ".join("-" * x for x in sizes))
+
+        for val in pkg_strings:
+            write_output(val)
+
+
+def format_for_columns(
+    pkgs: "_ProcessedDists", options: Values
+) -> Tuple[List[List[str]], List[str]]:
+    """
+    Convert the package data into something usable
+    by output_package_listing_columns.
+    """
+    header = ["Package", "Version"]
+
+    running_outdated = options.outdated
+    if running_outdated:
+        header.extend(["Latest", "Type"])
+
+    has_editables = any(x.editable for x in pkgs)
+    if has_editables:
+        header.append("Editable project location")
+
+    if options.verbose >= 1:
+        header.append("Location")
+    if options.verbose >= 1:
+        header.append("Installer")
+
+    data = []
+    for proj in pkgs:
+        # if we're working on the 'outdated' list, separate out the
+        # latest_version and type
+        row = [proj.raw_name, proj.raw_version]
+
+        if running_outdated:
+            row.append(str(proj.latest_version))
+            row.append(proj.latest_filetype)
+
+        if has_editables:
+            row.append(proj.editable_project_location or "")
+
+        if options.verbose >= 1:
+            row.append(proj.location or "")
+        if options.verbose >= 1:
+            row.append(proj.installer)
+
+        data.append(row)
+
+    return data, header
+
+
+def format_for_json(packages: "_ProcessedDists", options: Values) -> str:
+    data = []
+    for dist in packages:
+        info = {
+            "name": dist.raw_name,
+            "version": str(dist.version),
+        }
+        if options.verbose >= 1:
+            info["location"] = dist.location or ""
+            info["installer"] = dist.installer
+        if options.outdated:
+            info["latest_version"] = str(dist.latest_version)
+            info["latest_filetype"] = dist.latest_filetype
+        editable_project_location = dist.editable_project_location
+        if editable_project_location:
+            info["editable_project_location"] = editable_project_location
+        data.append(info)
+    return json.dumps(data)
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/commands/search.py b/venv/lib/python3.12/site-packages/pip/_internal/commands/search.py
new file mode 100644
index 00000000..e0d329d5
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/commands/search.py
@@ -0,0 +1,172 @@
+import logging
+import shutil
+import sys
+import textwrap
+import xmlrpc.client
+from collections import OrderedDict
+from optparse import Values
+from typing import TYPE_CHECKING, Dict, List, Optional, TypedDict
+
+from pip._vendor.packaging.version import parse as parse_version
+
+from pip._internal.cli.base_command import Command
+from pip._internal.cli.req_command import SessionCommandMixin
+from pip._internal.cli.status_codes import NO_MATCHES_FOUND, SUCCESS
+from pip._internal.exceptions import CommandError
+from pip._internal.metadata import get_default_environment
+from pip._internal.models.index import PyPI
+from pip._internal.network.xmlrpc import PipXmlrpcTransport
+from pip._internal.utils.logging import indent_log
+from pip._internal.utils.misc import write_output
+
+if TYPE_CHECKING:
+
+    class TransformedHit(TypedDict):
+        name: str
+        summary: str
+        versions: List[str]
+
+
+logger = logging.getLogger(__name__)
+
+
+class SearchCommand(Command, SessionCommandMixin):
+    """Search for PyPI packages whose name or summary contains ."""
+
+    usage = """
+      %prog [options] """
+    ignore_require_venv = True
+
+    def add_options(self) -> None:
+        self.cmd_opts.add_option(
+            "-i",
+            "--index",
+            dest="index",
+            metavar="URL",
+            default=PyPI.pypi_url,
+            help="Base URL of Python Package Index (default %default)",
+        )
+
+        self.parser.insert_option_group(0, self.cmd_opts)
+
+    def run(self, options: Values, args: List[str]) -> int:
+        if not args:
+            raise CommandError("Missing required argument (search query).")
+        query = args
+        pypi_hits = self.search(query, options)
+        hits = transform_hits(pypi_hits)
+
+        terminal_width = None
+        if sys.stdout.isatty():
+            terminal_width = shutil.get_terminal_size()[0]
+
+        print_results(hits, terminal_width=terminal_width)
+        if pypi_hits:
+            return SUCCESS
+        return NO_MATCHES_FOUND
+
+    def search(self, query: List[str], options: Values) -> List[Dict[str, str]]:
+        index_url = options.index
+
+        session = self.get_default_session(options)
+
+        transport = PipXmlrpcTransport(index_url, session)
+        pypi = xmlrpc.client.ServerProxy(index_url, transport)
+        try:
+            hits = pypi.search({"name": query, "summary": query}, "or")
+        except xmlrpc.client.Fault as fault:
+            message = (
+                f"XMLRPC request failed [code: {fault.faultCode}]\n{fault.faultString}"
+            )
+            raise CommandError(message)
+        assert isinstance(hits, list)
+        return hits
+
+
+def transform_hits(hits: List[Dict[str, str]]) -> List["TransformedHit"]:
+    """
+    The list from pypi is really a list of versions. We want a list of
+    packages with the list of versions stored inline. This converts the
+    list from pypi into one we can use.
+    """
+    packages: Dict[str, "TransformedHit"] = OrderedDict()
+    for hit in hits:
+        name = hit["name"]
+        summary = hit["summary"]
+        version = hit["version"]
+
+        if name not in packages.keys():
+            packages[name] = {
+                "name": name,
+                "summary": summary,
+                "versions": [version],
+            }
+        else:
+            packages[name]["versions"].append(version)
+
+            # if this is the highest version, replace summary and score
+            if version == highest_version(packages[name]["versions"]):
+                packages[name]["summary"] = summary
+
+    return list(packages.values())
+
+
+def print_dist_installation_info(name: str, latest: str) -> None:
+    env = get_default_environment()
+    dist = env.get_distribution(name)
+    if dist is not None:
+        with indent_log():
+            if dist.version == latest:
+                write_output("INSTALLED: %s (latest)", dist.version)
+            else:
+                write_output("INSTALLED: %s", dist.version)
+                if parse_version(latest).pre:
+                    write_output(
+                        "LATEST:    %s (pre-release; install"
+                        " with `pip install --pre`)",
+                        latest,
+                    )
+                else:
+                    write_output("LATEST:    %s", latest)
+
+
+def print_results(
+    hits: List["TransformedHit"],
+    name_column_width: Optional[int] = None,
+    terminal_width: Optional[int] = None,
+) -> None:
+    if not hits:
+        return
+    if name_column_width is None:
+        name_column_width = (
+            max(
+                [
+                    len(hit["name"]) + len(highest_version(hit.get("versions", ["-"])))
+                    for hit in hits
+                ]
+            )
+            + 4
+        )
+
+    for hit in hits:
+        name = hit["name"]
+        summary = hit["summary"] or ""
+        latest = highest_version(hit.get("versions", ["-"]))
+        if terminal_width is not None:
+            target_width = terminal_width - name_column_width - 5
+            if target_width > 10:
+                # wrap and indent summary to fit terminal
+                summary_lines = textwrap.wrap(summary, target_width)
+                summary = ("\n" + " " * (name_column_width + 3)).join(summary_lines)
+
+        name_latest = f"{name} ({latest})"
+        line = f"{name_latest:{name_column_width}} - {summary}"
+        try:
+            write_output(line)
+            print_dist_installation_info(name, latest)
+        except UnicodeEncodeError:
+            pass
+
+
+def highest_version(versions: List[str]) -> str:
+    return max(versions, key=parse_version)
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/commands/show.py b/venv/lib/python3.12/site-packages/pip/_internal/commands/show.py
new file mode 100644
index 00000000..c54d548f
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/commands/show.py
@@ -0,0 +1,217 @@
+import logging
+from optparse import Values
+from typing import Generator, Iterable, Iterator, List, NamedTuple, Optional
+
+from pip._vendor.packaging.requirements import InvalidRequirement
+from pip._vendor.packaging.utils import canonicalize_name
+
+from pip._internal.cli.base_command import Command
+from pip._internal.cli.status_codes import ERROR, SUCCESS
+from pip._internal.metadata import BaseDistribution, get_default_environment
+from pip._internal.utils.misc import write_output
+
+logger = logging.getLogger(__name__)
+
+
+class ShowCommand(Command):
+    """
+    Show information about one or more installed packages.
+
+    The output is in RFC-compliant mail header format.
+    """
+
+    usage = """
+      %prog [options]  ..."""
+    ignore_require_venv = True
+
+    def add_options(self) -> None:
+        self.cmd_opts.add_option(
+            "-f",
+            "--files",
+            dest="files",
+            action="store_true",
+            default=False,
+            help="Show the full list of installed files for each package.",
+        )
+
+        self.parser.insert_option_group(0, self.cmd_opts)
+
+    def run(self, options: Values, args: List[str]) -> int:
+        if not args:
+            logger.warning("ERROR: Please provide a package name or names.")
+            return ERROR
+        query = args
+
+        results = search_packages_info(query)
+        if not print_results(
+            results, list_files=options.files, verbose=options.verbose
+        ):
+            return ERROR
+        return SUCCESS
+
+
+class _PackageInfo(NamedTuple):
+    name: str
+    version: str
+    location: str
+    editable_project_location: Optional[str]
+    requires: List[str]
+    required_by: List[str]
+    installer: str
+    metadata_version: str
+    classifiers: List[str]
+    summary: str
+    homepage: str
+    project_urls: List[str]
+    author: str
+    author_email: str
+    license: str
+    entry_points: List[str]
+    files: Optional[List[str]]
+
+
+def search_packages_info(query: List[str]) -> Generator[_PackageInfo, None, None]:
+    """
+    Gather details from installed distributions. Print distribution name,
+    version, location, and installed files. Installed files requires a
+    pip generated 'installed-files.txt' in the distributions '.egg-info'
+    directory.
+    """
+    env = get_default_environment()
+
+    installed = {dist.canonical_name: dist for dist in env.iter_all_distributions()}
+    query_names = [canonicalize_name(name) for name in query]
+    missing = sorted(
+        [name for name, pkg in zip(query, query_names) if pkg not in installed]
+    )
+    if missing:
+        logger.warning("Package(s) not found: %s", ", ".join(missing))
+
+    def _get_requiring_packages(current_dist: BaseDistribution) -> Iterator[str]:
+        return (
+            dist.metadata["Name"] or "UNKNOWN"
+            for dist in installed.values()
+            if current_dist.canonical_name
+            in {canonicalize_name(d.name) for d in dist.iter_dependencies()}
+        )
+
+    for query_name in query_names:
+        try:
+            dist = installed[query_name]
+        except KeyError:
+            continue
+
+        try:
+            requires = sorted(
+                # Avoid duplicates in requirements (e.g. due to environment markers).
+                {req.name for req in dist.iter_dependencies()},
+                key=str.lower,
+            )
+        except InvalidRequirement:
+            requires = sorted(dist.iter_raw_dependencies(), key=str.lower)
+
+        try:
+            required_by = sorted(_get_requiring_packages(dist), key=str.lower)
+        except InvalidRequirement:
+            required_by = ["#N/A"]
+
+        try:
+            entry_points_text = dist.read_text("entry_points.txt")
+            entry_points = entry_points_text.splitlines(keepends=False)
+        except FileNotFoundError:
+            entry_points = []
+
+        files_iter = dist.iter_declared_entries()
+        if files_iter is None:
+            files: Optional[List[str]] = None
+        else:
+            files = sorted(files_iter)
+
+        metadata = dist.metadata
+
+        project_urls = metadata.get_all("Project-URL", [])
+        homepage = metadata.get("Home-page", "")
+        if not homepage:
+            # It's common that there is a "homepage" Project-URL, but Home-page
+            # remains unset (especially as PEP 621 doesn't surface the field).
+            #
+            # This logic was taken from PyPI's codebase.
+            for url in project_urls:
+                url_label, url = url.split(",", maxsplit=1)
+                normalized_label = (
+                    url_label.casefold().replace("-", "").replace("_", "").strip()
+                )
+                if normalized_label == "homepage":
+                    homepage = url.strip()
+                    break
+
+        yield _PackageInfo(
+            name=dist.raw_name,
+            version=dist.raw_version,
+            location=dist.location or "",
+            editable_project_location=dist.editable_project_location,
+            requires=requires,
+            required_by=required_by,
+            installer=dist.installer,
+            metadata_version=dist.metadata_version or "",
+            classifiers=metadata.get_all("Classifier", []),
+            summary=metadata.get("Summary", ""),
+            homepage=homepage,
+            project_urls=project_urls,
+            author=metadata.get("Author", ""),
+            author_email=metadata.get("Author-email", ""),
+            license=metadata.get("License", ""),
+            entry_points=entry_points,
+            files=files,
+        )
+
+
+def print_results(
+    distributions: Iterable[_PackageInfo],
+    list_files: bool,
+    verbose: bool,
+) -> bool:
+    """
+    Print the information from installed distributions found.
+    """
+    results_printed = False
+    for i, dist in enumerate(distributions):
+        results_printed = True
+        if i > 0:
+            write_output("---")
+
+        write_output("Name: %s", dist.name)
+        write_output("Version: %s", dist.version)
+        write_output("Summary: %s", dist.summary)
+        write_output("Home-page: %s", dist.homepage)
+        write_output("Author: %s", dist.author)
+        write_output("Author-email: %s", dist.author_email)
+        write_output("License: %s", dist.license)
+        write_output("Location: %s", dist.location)
+        if dist.editable_project_location is not None:
+            write_output(
+                "Editable project location: %s", dist.editable_project_location
+            )
+        write_output("Requires: %s", ", ".join(dist.requires))
+        write_output("Required-by: %s", ", ".join(dist.required_by))
+
+        if verbose:
+            write_output("Metadata-Version: %s", dist.metadata_version)
+            write_output("Installer: %s", dist.installer)
+            write_output("Classifiers:")
+            for classifier in dist.classifiers:
+                write_output("  %s", classifier)
+            write_output("Entry-points:")
+            for entry in dist.entry_points:
+                write_output("  %s", entry.strip())
+            write_output("Project-URLs:")
+            for project_url in dist.project_urls:
+                write_output("  %s", project_url)
+        if list_files:
+            write_output("Files:")
+            if dist.files is None:
+                write_output("Cannot locate RECORD or installed-files.txt")
+            else:
+                for line in dist.files:
+                    write_output("  %s", line.strip())
+    return results_printed
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/commands/uninstall.py b/venv/lib/python3.12/site-packages/pip/_internal/commands/uninstall.py
new file mode 100644
index 00000000..bc0edeac
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/commands/uninstall.py
@@ -0,0 +1,114 @@
+import logging
+from optparse import Values
+from typing import List
+
+from pip._vendor.packaging.utils import canonicalize_name
+
+from pip._internal.cli import cmdoptions
+from pip._internal.cli.base_command import Command
+from pip._internal.cli.index_command import SessionCommandMixin
+from pip._internal.cli.status_codes import SUCCESS
+from pip._internal.exceptions import InstallationError
+from pip._internal.req import parse_requirements
+from pip._internal.req.constructors import (
+    install_req_from_line,
+    install_req_from_parsed_requirement,
+)
+from pip._internal.utils.misc import (
+    check_externally_managed,
+    protect_pip_from_modification_on_windows,
+    warn_if_run_as_root,
+)
+
+logger = logging.getLogger(__name__)
+
+
+class UninstallCommand(Command, SessionCommandMixin):
+    """
+    Uninstall packages.
+
+    pip is able to uninstall most installed packages. Known exceptions are:
+
+    - Pure distutils packages installed with ``python setup.py install``, which
+      leave behind no metadata to determine what files were installed.
+    - Script wrappers installed by ``python setup.py develop``.
+    """
+
+    usage = """
+      %prog [options]  ...
+      %prog [options] -r  ..."""
+
+    def add_options(self) -> None:
+        self.cmd_opts.add_option(
+            "-r",
+            "--requirement",
+            dest="requirements",
+            action="append",
+            default=[],
+            metavar="file",
+            help=(
+                "Uninstall all the packages listed in the given requirements "
+                "file.  This option can be used multiple times."
+            ),
+        )
+        self.cmd_opts.add_option(
+            "-y",
+            "--yes",
+            dest="yes",
+            action="store_true",
+            help="Don't ask for confirmation of uninstall deletions.",
+        )
+        self.cmd_opts.add_option(cmdoptions.root_user_action())
+        self.cmd_opts.add_option(cmdoptions.override_externally_managed())
+        self.parser.insert_option_group(0, self.cmd_opts)
+
+    def run(self, options: Values, args: List[str]) -> int:
+        session = self.get_default_session(options)
+
+        reqs_to_uninstall = {}
+        for name in args:
+            req = install_req_from_line(
+                name,
+                isolated=options.isolated_mode,
+            )
+            if req.name:
+                reqs_to_uninstall[canonicalize_name(req.name)] = req
+            else:
+                logger.warning(
+                    "Invalid requirement: %r ignored -"
+                    " the uninstall command expects named"
+                    " requirements.",
+                    name,
+                )
+        for filename in options.requirements:
+            for parsed_req in parse_requirements(
+                filename, options=options, session=session
+            ):
+                req = install_req_from_parsed_requirement(
+                    parsed_req, isolated=options.isolated_mode
+                )
+                if req.name:
+                    reqs_to_uninstall[canonicalize_name(req.name)] = req
+        if not reqs_to_uninstall:
+            raise InstallationError(
+                f"You must give at least one requirement to {self.name} (see "
+                f'"pip help {self.name}")'
+            )
+
+        if not options.override_externally_managed:
+            check_externally_managed()
+
+        protect_pip_from_modification_on_windows(
+            modifying_pip="pip" in reqs_to_uninstall
+        )
+
+        for req in reqs_to_uninstall.values():
+            uninstall_pathset = req.uninstall(
+                auto_confirm=options.yes,
+                verbose=self.verbosity > 0,
+            )
+            if uninstall_pathset:
+                uninstall_pathset.commit()
+        if options.root_user_action == "warn":
+            warn_if_run_as_root()
+        return SUCCESS
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/commands/wheel.py b/venv/lib/python3.12/site-packages/pip/_internal/commands/wheel.py
new file mode 100644
index 00000000..278719f4
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/commands/wheel.py
@@ -0,0 +1,182 @@
+import logging
+import os
+import shutil
+from optparse import Values
+from typing import List
+
+from pip._internal.cache import WheelCache
+from pip._internal.cli import cmdoptions
+from pip._internal.cli.req_command import RequirementCommand, with_cleanup
+from pip._internal.cli.status_codes import SUCCESS
+from pip._internal.exceptions import CommandError
+from pip._internal.operations.build.build_tracker import get_build_tracker
+from pip._internal.req.req_install import (
+    InstallRequirement,
+    check_legacy_setup_py_options,
+)
+from pip._internal.utils.misc import ensure_dir, normalize_path
+from pip._internal.utils.temp_dir import TempDirectory
+from pip._internal.wheel_builder import build, should_build_for_wheel_command
+
+logger = logging.getLogger(__name__)
+
+
+class WheelCommand(RequirementCommand):
+    """
+    Build Wheel archives for your requirements and dependencies.
+
+    Wheel is a built-package format, and offers the advantage of not
+    recompiling your software during every install. For more details, see the
+    wheel docs: https://wheel.readthedocs.io/en/latest/
+
+    'pip wheel' uses the build system interface as described here:
+    https://pip.pypa.io/en/stable/reference/build-system/
+
+    """
+
+    usage = """
+      %prog [options]  ...
+      %prog [options] -r  ...
+      %prog [options] [-e]  ...
+      %prog [options] [-e]  ...
+      %prog [options]  ..."""
+
+    def add_options(self) -> None:
+        self.cmd_opts.add_option(
+            "-w",
+            "--wheel-dir",
+            dest="wheel_dir",
+            metavar="dir",
+            default=os.curdir,
+            help=(
+                "Build wheels into , where the default is the "
+                "current working directory."
+            ),
+        )
+        self.cmd_opts.add_option(cmdoptions.no_binary())
+        self.cmd_opts.add_option(cmdoptions.only_binary())
+        self.cmd_opts.add_option(cmdoptions.prefer_binary())
+        self.cmd_opts.add_option(cmdoptions.no_build_isolation())
+        self.cmd_opts.add_option(cmdoptions.use_pep517())
+        self.cmd_opts.add_option(cmdoptions.no_use_pep517())
+        self.cmd_opts.add_option(cmdoptions.check_build_deps())
+        self.cmd_opts.add_option(cmdoptions.constraints())
+        self.cmd_opts.add_option(cmdoptions.editable())
+        self.cmd_opts.add_option(cmdoptions.requirements())
+        self.cmd_opts.add_option(cmdoptions.src())
+        self.cmd_opts.add_option(cmdoptions.ignore_requires_python())
+        self.cmd_opts.add_option(cmdoptions.no_deps())
+        self.cmd_opts.add_option(cmdoptions.progress_bar())
+
+        self.cmd_opts.add_option(
+            "--no-verify",
+            dest="no_verify",
+            action="store_true",
+            default=False,
+            help="Don't verify if built wheel is valid.",
+        )
+
+        self.cmd_opts.add_option(cmdoptions.config_settings())
+        self.cmd_opts.add_option(cmdoptions.build_options())
+        self.cmd_opts.add_option(cmdoptions.global_options())
+
+        self.cmd_opts.add_option(
+            "--pre",
+            action="store_true",
+            default=False,
+            help=(
+                "Include pre-release and development versions. By default, "
+                "pip only finds stable versions."
+            ),
+        )
+
+        self.cmd_opts.add_option(cmdoptions.require_hashes())
+
+        index_opts = cmdoptions.make_option_group(
+            cmdoptions.index_group,
+            self.parser,
+        )
+
+        self.parser.insert_option_group(0, index_opts)
+        self.parser.insert_option_group(0, self.cmd_opts)
+
+    @with_cleanup
+    def run(self, options: Values, args: List[str]) -> int:
+        session = self.get_default_session(options)
+
+        finder = self._build_package_finder(options, session)
+
+        options.wheel_dir = normalize_path(options.wheel_dir)
+        ensure_dir(options.wheel_dir)
+
+        build_tracker = self.enter_context(get_build_tracker())
+
+        directory = TempDirectory(
+            delete=not options.no_clean,
+            kind="wheel",
+            globally_managed=True,
+        )
+
+        reqs = self.get_requirements(args, options, finder, session)
+        check_legacy_setup_py_options(options, reqs)
+
+        wheel_cache = WheelCache(options.cache_dir)
+
+        preparer = self.make_requirement_preparer(
+            temp_build_dir=directory,
+            options=options,
+            build_tracker=build_tracker,
+            session=session,
+            finder=finder,
+            download_dir=options.wheel_dir,
+            use_user_site=False,
+            verbosity=self.verbosity,
+        )
+
+        resolver = self.make_resolver(
+            preparer=preparer,
+            finder=finder,
+            options=options,
+            wheel_cache=wheel_cache,
+            ignore_requires_python=options.ignore_requires_python,
+            use_pep517=options.use_pep517,
+        )
+
+        self.trace_basic_info(finder)
+
+        requirement_set = resolver.resolve(reqs, check_supported_wheels=True)
+
+        reqs_to_build: List[InstallRequirement] = []
+        for req in requirement_set.requirements.values():
+            if req.is_wheel:
+                preparer.save_linked_requirement(req)
+            elif should_build_for_wheel_command(req):
+                reqs_to_build.append(req)
+
+        preparer.prepare_linked_requirements_more(requirement_set.requirements.values())
+
+        # build wheels
+        build_successes, build_failures = build(
+            reqs_to_build,
+            wheel_cache=wheel_cache,
+            verify=(not options.no_verify),
+            build_options=options.build_options or [],
+            global_options=options.global_options or [],
+        )
+        for req in build_successes:
+            assert req.link and req.link.is_wheel
+            assert req.local_file_path
+            # copy from cache to target directory
+            try:
+                shutil.copy(req.local_file_path, options.wheel_dir)
+            except OSError as e:
+                logger.warning(
+                    "Building wheel for %s failed: %s",
+                    req.name,
+                    e,
+                )
+                build_failures.append(req)
+        if len(build_failures) != 0:
+            raise CommandError("Failed to build one or more wheels")
+
+        return SUCCESS
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/configuration.py b/venv/lib/python3.12/site-packages/pip/_internal/configuration.py
new file mode 100644
index 00000000..c25273d5
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/configuration.py
@@ -0,0 +1,383 @@
+"""Configuration management setup
+
+Some terminology:
+- name
+  As written in config files.
+- value
+  Value associated with a name
+- key
+  Name combined with it's section (section.name)
+- variant
+  A single word describing where the configuration key-value pair came from
+"""
+
+import configparser
+import locale
+import os
+import sys
+from typing import Any, Dict, Iterable, List, NewType, Optional, Tuple
+
+from pip._internal.exceptions import (
+    ConfigurationError,
+    ConfigurationFileCouldNotBeLoaded,
+)
+from pip._internal.utils import appdirs
+from pip._internal.utils.compat import WINDOWS
+from pip._internal.utils.logging import getLogger
+from pip._internal.utils.misc import ensure_dir, enum
+
+RawConfigParser = configparser.RawConfigParser  # Shorthand
+Kind = NewType("Kind", str)
+
+CONFIG_BASENAME = "pip.ini" if WINDOWS else "pip.conf"
+ENV_NAMES_IGNORED = "version", "help"
+
+# The kinds of configurations there are.
+kinds = enum(
+    USER="user",  # User Specific
+    GLOBAL="global",  # System Wide
+    SITE="site",  # [Virtual] Environment Specific
+    ENV="env",  # from PIP_CONFIG_FILE
+    ENV_VAR="env-var",  # from Environment Variables
+)
+OVERRIDE_ORDER = kinds.GLOBAL, kinds.USER, kinds.SITE, kinds.ENV, kinds.ENV_VAR
+VALID_LOAD_ONLY = kinds.USER, kinds.GLOBAL, kinds.SITE
+
+logger = getLogger(__name__)
+
+
+# NOTE: Maybe use the optionx attribute to normalize keynames.
+def _normalize_name(name: str) -> str:
+    """Make a name consistent regardless of source (environment or file)"""
+    name = name.lower().replace("_", "-")
+    if name.startswith("--"):
+        name = name[2:]  # only prefer long opts
+    return name
+
+
+def _disassemble_key(name: str) -> List[str]:
+    if "." not in name:
+        error_message = (
+            "Key does not contain dot separated section and key. "
+            f"Perhaps you wanted to use 'global.{name}' instead?"
+        )
+        raise ConfigurationError(error_message)
+    return name.split(".", 1)
+
+
+def get_configuration_files() -> Dict[Kind, List[str]]:
+    global_config_files = [
+        os.path.join(path, CONFIG_BASENAME) for path in appdirs.site_config_dirs("pip")
+    ]
+
+    site_config_file = os.path.join(sys.prefix, CONFIG_BASENAME)
+    legacy_config_file = os.path.join(
+        os.path.expanduser("~"),
+        "pip" if WINDOWS else ".pip",
+        CONFIG_BASENAME,
+    )
+    new_config_file = os.path.join(appdirs.user_config_dir("pip"), CONFIG_BASENAME)
+    return {
+        kinds.GLOBAL: global_config_files,
+        kinds.SITE: [site_config_file],
+        kinds.USER: [legacy_config_file, new_config_file],
+    }
+
+
+class Configuration:
+    """Handles management of configuration.
+
+    Provides an interface to accessing and managing configuration files.
+
+    This class converts provides an API that takes "section.key-name" style
+    keys and stores the value associated with it as "key-name" under the
+    section "section".
+
+    This allows for a clean interface wherein the both the section and the
+    key-name are preserved in an easy to manage form in the configuration files
+    and the data stored is also nice.
+    """
+
+    def __init__(self, isolated: bool, load_only: Optional[Kind] = None) -> None:
+        super().__init__()
+
+        if load_only is not None and load_only not in VALID_LOAD_ONLY:
+            raise ConfigurationError(
+                "Got invalid value for load_only - should be one of {}".format(
+                    ", ".join(map(repr, VALID_LOAD_ONLY))
+                )
+            )
+        self.isolated = isolated
+        self.load_only = load_only
+
+        # Because we keep track of where we got the data from
+        self._parsers: Dict[Kind, List[Tuple[str, RawConfigParser]]] = {
+            variant: [] for variant in OVERRIDE_ORDER
+        }
+        self._config: Dict[Kind, Dict[str, Any]] = {
+            variant: {} for variant in OVERRIDE_ORDER
+        }
+        self._modified_parsers: List[Tuple[str, RawConfigParser]] = []
+
+    def load(self) -> None:
+        """Loads configuration from configuration files and environment"""
+        self._load_config_files()
+        if not self.isolated:
+            self._load_environment_vars()
+
+    def get_file_to_edit(self) -> Optional[str]:
+        """Returns the file with highest priority in configuration"""
+        assert self.load_only is not None, "Need to be specified a file to be editing"
+
+        try:
+            return self._get_parser_to_modify()[0]
+        except IndexError:
+            return None
+
+    def items(self) -> Iterable[Tuple[str, Any]]:
+        """Returns key-value pairs like dict.items() representing the loaded
+        configuration
+        """
+        return self._dictionary.items()
+
+    def get_value(self, key: str) -> Any:
+        """Get a value from the configuration."""
+        orig_key = key
+        key = _normalize_name(key)
+        try:
+            return self._dictionary[key]
+        except KeyError:
+            # disassembling triggers a more useful error message than simply
+            # "No such key" in the case that the key isn't in the form command.option
+            _disassemble_key(key)
+            raise ConfigurationError(f"No such key - {orig_key}")
+
+    def set_value(self, key: str, value: Any) -> None:
+        """Modify a value in the configuration."""
+        key = _normalize_name(key)
+        self._ensure_have_load_only()
+
+        assert self.load_only
+        fname, parser = self._get_parser_to_modify()
+
+        if parser is not None:
+            section, name = _disassemble_key(key)
+
+            # Modify the parser and the configuration
+            if not parser.has_section(section):
+                parser.add_section(section)
+            parser.set(section, name, value)
+
+        self._config[self.load_only][key] = value
+        self._mark_as_modified(fname, parser)
+
+    def unset_value(self, key: str) -> None:
+        """Unset a value in the configuration."""
+        orig_key = key
+        key = _normalize_name(key)
+        self._ensure_have_load_only()
+
+        assert self.load_only
+        if key not in self._config[self.load_only]:
+            raise ConfigurationError(f"No such key - {orig_key}")
+
+        fname, parser = self._get_parser_to_modify()
+
+        if parser is not None:
+            section, name = _disassemble_key(key)
+            if not (
+                parser.has_section(section) and parser.remove_option(section, name)
+            ):
+                # The option was not removed.
+                raise ConfigurationError(
+                    "Fatal Internal error [id=1]. Please report as a bug."
+                )
+
+            # The section may be empty after the option was removed.
+            if not parser.items(section):
+                parser.remove_section(section)
+            self._mark_as_modified(fname, parser)
+
+        del self._config[self.load_only][key]
+
+    def save(self) -> None:
+        """Save the current in-memory state."""
+        self._ensure_have_load_only()
+
+        for fname, parser in self._modified_parsers:
+            logger.info("Writing to %s", fname)
+
+            # Ensure directory exists.
+            ensure_dir(os.path.dirname(fname))
+
+            # Ensure directory's permission(need to be writeable)
+            try:
+                with open(fname, "w") as f:
+                    parser.write(f)
+            except OSError as error:
+                raise ConfigurationError(
+                    f"An error occurred while writing to the configuration file "
+                    f"{fname}: {error}"
+                )
+
+    #
+    # Private routines
+    #
+
+    def _ensure_have_load_only(self) -> None:
+        if self.load_only is None:
+            raise ConfigurationError("Needed a specific file to be modifying.")
+        logger.debug("Will be working with %s variant only", self.load_only)
+
+    @property
+    def _dictionary(self) -> Dict[str, Any]:
+        """A dictionary representing the loaded configuration."""
+        # NOTE: Dictionaries are not populated if not loaded. So, conditionals
+        #       are not needed here.
+        retval = {}
+
+        for variant in OVERRIDE_ORDER:
+            retval.update(self._config[variant])
+
+        return retval
+
+    def _load_config_files(self) -> None:
+        """Loads configuration from configuration files"""
+        config_files = dict(self.iter_config_files())
+        if config_files[kinds.ENV][0:1] == [os.devnull]:
+            logger.debug(
+                "Skipping loading configuration files due to "
+                "environment's PIP_CONFIG_FILE being os.devnull"
+            )
+            return
+
+        for variant, files in config_files.items():
+            for fname in files:
+                # If there's specific variant set in `load_only`, load only
+                # that variant, not the others.
+                if self.load_only is not None and variant != self.load_only:
+                    logger.debug("Skipping file '%s' (variant: %s)", fname, variant)
+                    continue
+
+                parser = self._load_file(variant, fname)
+
+                # Keeping track of the parsers used
+                self._parsers[variant].append((fname, parser))
+
+    def _load_file(self, variant: Kind, fname: str) -> RawConfigParser:
+        logger.verbose("For variant '%s', will try loading '%s'", variant, fname)
+        parser = self._construct_parser(fname)
+
+        for section in parser.sections():
+            items = parser.items(section)
+            self._config[variant].update(self._normalized_keys(section, items))
+
+        return parser
+
+    def _construct_parser(self, fname: str) -> RawConfigParser:
+        parser = configparser.RawConfigParser()
+        # If there is no such file, don't bother reading it but create the
+        # parser anyway, to hold the data.
+        # Doing this is useful when modifying and saving files, where we don't
+        # need to construct a parser.
+        if os.path.exists(fname):
+            locale_encoding = locale.getpreferredencoding(False)
+            try:
+                parser.read(fname, encoding=locale_encoding)
+            except UnicodeDecodeError:
+                # See https://github.com/pypa/pip/issues/4963
+                raise ConfigurationFileCouldNotBeLoaded(
+                    reason=f"contains invalid {locale_encoding} characters",
+                    fname=fname,
+                )
+            except configparser.Error as error:
+                # See https://github.com/pypa/pip/issues/4893
+                raise ConfigurationFileCouldNotBeLoaded(error=error)
+        return parser
+
+    def _load_environment_vars(self) -> None:
+        """Loads configuration from environment variables"""
+        self._config[kinds.ENV_VAR].update(
+            self._normalized_keys(":env:", self.get_environ_vars())
+        )
+
+    def _normalized_keys(
+        self, section: str, items: Iterable[Tuple[str, Any]]
+    ) -> Dict[str, Any]:
+        """Normalizes items to construct a dictionary with normalized keys.
+
+        This routine is where the names become keys and are made the same
+        regardless of source - configuration files or environment.
+        """
+        normalized = {}
+        for name, val in items:
+            key = section + "." + _normalize_name(name)
+            normalized[key] = val
+        return normalized
+
+    def get_environ_vars(self) -> Iterable[Tuple[str, str]]:
+        """Returns a generator with all environmental vars with prefix PIP_"""
+        for key, val in os.environ.items():
+            if key.startswith("PIP_"):
+                name = key[4:].lower()
+                if name not in ENV_NAMES_IGNORED:
+                    yield name, val
+
+    # XXX: This is patched in the tests.
+    def iter_config_files(self) -> Iterable[Tuple[Kind, List[str]]]:
+        """Yields variant and configuration files associated with it.
+
+        This should be treated like items of a dictionary. The order
+        here doesn't affect what gets overridden. That is controlled
+        by OVERRIDE_ORDER. However this does control the order they are
+        displayed to the user. It's probably most ergononmic to display
+        things in the same order as OVERRIDE_ORDER
+        """
+        # SMELL: Move the conditions out of this function
+
+        env_config_file = os.environ.get("PIP_CONFIG_FILE", None)
+        config_files = get_configuration_files()
+
+        yield kinds.GLOBAL, config_files[kinds.GLOBAL]
+
+        # per-user config is not loaded when env_config_file exists
+        should_load_user_config = not self.isolated and not (
+            env_config_file and os.path.exists(env_config_file)
+        )
+        if should_load_user_config:
+            # The legacy config file is overridden by the new config file
+            yield kinds.USER, config_files[kinds.USER]
+
+        # virtualenv config
+        yield kinds.SITE, config_files[kinds.SITE]
+
+        if env_config_file is not None:
+            yield kinds.ENV, [env_config_file]
+        else:
+            yield kinds.ENV, []
+
+    def get_values_in_config(self, variant: Kind) -> Dict[str, Any]:
+        """Get values present in a config file"""
+        return self._config[variant]
+
+    def _get_parser_to_modify(self) -> Tuple[str, RawConfigParser]:
+        # Determine which parser to modify
+        assert self.load_only
+        parsers = self._parsers[self.load_only]
+        if not parsers:
+            # This should not happen if everything works correctly.
+            raise ConfigurationError(
+                "Fatal Internal error [id=2]. Please report as a bug."
+            )
+
+        # Use the highest priority parser.
+        return parsers[-1]
+
+    # XXX: This is patched in the tests.
+    def _mark_as_modified(self, fname: str, parser: RawConfigParser) -> None:
+        file_parser_tuple = (fname, parser)
+        if file_parser_tuple not in self._modified_parsers:
+            self._modified_parsers.append(file_parser_tuple)
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}({self._dictionary!r})"
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/distributions/__init__.py b/venv/lib/python3.12/site-packages/pip/_internal/distributions/__init__.py
new file mode 100644
index 00000000..9a89a838
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/distributions/__init__.py
@@ -0,0 +1,21 @@
+from pip._internal.distributions.base import AbstractDistribution
+from pip._internal.distributions.sdist import SourceDistribution
+from pip._internal.distributions.wheel import WheelDistribution
+from pip._internal.req.req_install import InstallRequirement
+
+
+def make_distribution_for_install_requirement(
+    install_req: InstallRequirement,
+) -> AbstractDistribution:
+    """Returns a Distribution for the given InstallRequirement"""
+    # Editable requirements will always be source distributions. They use the
+    # legacy logic until we create a modern standard for them.
+    if install_req.editable:
+        return SourceDistribution(install_req)
+
+    # If it's a wheel, it's a WheelDistribution
+    if install_req.is_wheel:
+        return WheelDistribution(install_req)
+
+    # Otherwise, a SourceDistribution
+    return SourceDistribution(install_req)
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/distributions/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/distributions/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 00000000..99c73b1b
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/distributions/__pycache__/__init__.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/distributions/__pycache__/base.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/distributions/__pycache__/base.cpython-312.pyc
new file mode 100644
index 00000000..6d085edb
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/distributions/__pycache__/base.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/distributions/__pycache__/installed.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/distributions/__pycache__/installed.cpython-312.pyc
new file mode 100644
index 00000000..da2e8e5d
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/distributions/__pycache__/installed.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/distributions/__pycache__/sdist.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/distributions/__pycache__/sdist.cpython-312.pyc
new file mode 100644
index 00000000..661705c3
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/distributions/__pycache__/sdist.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/distributions/__pycache__/wheel.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/distributions/__pycache__/wheel.cpython-312.pyc
new file mode 100644
index 00000000..a241d652
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/distributions/__pycache__/wheel.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/distributions/base.py b/venv/lib/python3.12/site-packages/pip/_internal/distributions/base.py
new file mode 100644
index 00000000..6e4d0c91
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/distributions/base.py
@@ -0,0 +1,53 @@
+import abc
+from typing import TYPE_CHECKING, Optional
+
+from pip._internal.metadata.base import BaseDistribution
+from pip._internal.req import InstallRequirement
+
+if TYPE_CHECKING:
+    from pip._internal.index.package_finder import PackageFinder
+
+
+class AbstractDistribution(metaclass=abc.ABCMeta):
+    """A base class for handling installable artifacts.
+
+    The requirements for anything installable are as follows:
+
+     - we must be able to determine the requirement name
+       (or we can't correctly handle the non-upgrade case).
+
+     - for packages with setup requirements, we must also be able
+       to determine their requirements without installing additional
+       packages (for the same reason as run-time dependencies)
+
+     - we must be able to create a Distribution object exposing the
+       above metadata.
+
+     - if we need to do work in the build tracker, we must be able to generate a unique
+       string to identify the requirement in the build tracker.
+    """
+
+    def __init__(self, req: InstallRequirement) -> None:
+        super().__init__()
+        self.req = req
+
+    @abc.abstractproperty
+    def build_tracker_id(self) -> Optional[str]:
+        """A string that uniquely identifies this requirement to the build tracker.
+
+        If None, then this dist has no work to do in the build tracker, and
+        ``.prepare_distribution_metadata()`` will not be called."""
+        raise NotImplementedError()
+
+    @abc.abstractmethod
+    def get_metadata_distribution(self) -> BaseDistribution:
+        raise NotImplementedError()
+
+    @abc.abstractmethod
+    def prepare_distribution_metadata(
+        self,
+        finder: "PackageFinder",
+        build_isolation: bool,
+        check_build_deps: bool,
+    ) -> None:
+        raise NotImplementedError()
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/distributions/installed.py b/venv/lib/python3.12/site-packages/pip/_internal/distributions/installed.py
new file mode 100644
index 00000000..ab8d53be
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/distributions/installed.py
@@ -0,0 +1,29 @@
+from typing import Optional
+
+from pip._internal.distributions.base import AbstractDistribution
+from pip._internal.index.package_finder import PackageFinder
+from pip._internal.metadata import BaseDistribution
+
+
+class InstalledDistribution(AbstractDistribution):
+    """Represents an installed package.
+
+    This does not need any preparation as the required information has already
+    been computed.
+    """
+
+    @property
+    def build_tracker_id(self) -> Optional[str]:
+        return None
+
+    def get_metadata_distribution(self) -> BaseDistribution:
+        assert self.req.satisfied_by is not None, "not actually installed"
+        return self.req.satisfied_by
+
+    def prepare_distribution_metadata(
+        self,
+        finder: PackageFinder,
+        build_isolation: bool,
+        check_build_deps: bool,
+    ) -> None:
+        pass
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/distributions/sdist.py b/venv/lib/python3.12/site-packages/pip/_internal/distributions/sdist.py
new file mode 100644
index 00000000..28ea5cea
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/distributions/sdist.py
@@ -0,0 +1,158 @@
+import logging
+from typing import TYPE_CHECKING, Iterable, Optional, Set, Tuple
+
+from pip._internal.build_env import BuildEnvironment
+from pip._internal.distributions.base import AbstractDistribution
+from pip._internal.exceptions import InstallationError
+from pip._internal.metadata import BaseDistribution
+from pip._internal.utils.subprocess import runner_with_spinner_message
+
+if TYPE_CHECKING:
+    from pip._internal.index.package_finder import PackageFinder
+
+logger = logging.getLogger(__name__)
+
+
+class SourceDistribution(AbstractDistribution):
+    """Represents a source distribution.
+
+    The preparation step for these needs metadata for the packages to be
+    generated, either using PEP 517 or using the legacy `setup.py egg_info`.
+    """
+
+    @property
+    def build_tracker_id(self) -> Optional[str]:
+        """Identify this requirement uniquely by its link."""
+        assert self.req.link
+        return self.req.link.url_without_fragment
+
+    def get_metadata_distribution(self) -> BaseDistribution:
+        return self.req.get_dist()
+
+    def prepare_distribution_metadata(
+        self,
+        finder: "PackageFinder",
+        build_isolation: bool,
+        check_build_deps: bool,
+    ) -> None:
+        # Load pyproject.toml, to determine whether PEP 517 is to be used
+        self.req.load_pyproject_toml()
+
+        # Set up the build isolation, if this requirement should be isolated
+        should_isolate = self.req.use_pep517 and build_isolation
+        if should_isolate:
+            # Setup an isolated environment and install the build backend static
+            # requirements in it.
+            self._prepare_build_backend(finder)
+            # Check that if the requirement is editable, it either supports PEP 660 or
+            # has a setup.py or a setup.cfg. This cannot be done earlier because we need
+            # to setup the build backend to verify it supports build_editable, nor can
+            # it be done later, because we want to avoid installing build requirements
+            # needlessly. Doing it here also works around setuptools generating
+            # UNKNOWN.egg-info when running get_requires_for_build_wheel on a directory
+            # without setup.py nor setup.cfg.
+            self.req.isolated_editable_sanity_check()
+            # Install the dynamic build requirements.
+            self._install_build_reqs(finder)
+        # Check if the current environment provides build dependencies
+        should_check_deps = self.req.use_pep517 and check_build_deps
+        if should_check_deps:
+            pyproject_requires = self.req.pyproject_requires
+            assert pyproject_requires is not None
+            conflicting, missing = self.req.build_env.check_requirements(
+                pyproject_requires
+            )
+            if conflicting:
+                self._raise_conflicts("the backend dependencies", conflicting)
+            if missing:
+                self._raise_missing_reqs(missing)
+        self.req.prepare_metadata()
+
+    def _prepare_build_backend(self, finder: "PackageFinder") -> None:
+        # Isolate in a BuildEnvironment and install the build-time
+        # requirements.
+        pyproject_requires = self.req.pyproject_requires
+        assert pyproject_requires is not None
+
+        self.req.build_env = BuildEnvironment()
+        self.req.build_env.install_requirements(
+            finder, pyproject_requires, "overlay", kind="build dependencies"
+        )
+        conflicting, missing = self.req.build_env.check_requirements(
+            self.req.requirements_to_check
+        )
+        if conflicting:
+            self._raise_conflicts("PEP 517/518 supported requirements", conflicting)
+        if missing:
+            logger.warning(
+                "Missing build requirements in pyproject.toml for %s.",
+                self.req,
+            )
+            logger.warning(
+                "The project does not specify a build backend, and "
+                "pip cannot fall back to setuptools without %s.",
+                " and ".join(map(repr, sorted(missing))),
+            )
+
+    def _get_build_requires_wheel(self) -> Iterable[str]:
+        with self.req.build_env:
+            runner = runner_with_spinner_message("Getting requirements to build wheel")
+            backend = self.req.pep517_backend
+            assert backend is not None
+            with backend.subprocess_runner(runner):
+                return backend.get_requires_for_build_wheel()
+
+    def _get_build_requires_editable(self) -> Iterable[str]:
+        with self.req.build_env:
+            runner = runner_with_spinner_message(
+                "Getting requirements to build editable"
+            )
+            backend = self.req.pep517_backend
+            assert backend is not None
+            with backend.subprocess_runner(runner):
+                return backend.get_requires_for_build_editable()
+
+    def _install_build_reqs(self, finder: "PackageFinder") -> None:
+        # Install any extra build dependencies that the backend requests.
+        # This must be done in a second pass, as the pyproject.toml
+        # dependencies must be installed before we can call the backend.
+        if (
+            self.req.editable
+            and self.req.permit_editable_wheels
+            and self.req.supports_pyproject_editable
+        ):
+            build_reqs = self._get_build_requires_editable()
+        else:
+            build_reqs = self._get_build_requires_wheel()
+        conflicting, missing = self.req.build_env.check_requirements(build_reqs)
+        if conflicting:
+            self._raise_conflicts("the backend dependencies", conflicting)
+        self.req.build_env.install_requirements(
+            finder, missing, "normal", kind="backend dependencies"
+        )
+
+    def _raise_conflicts(
+        self, conflicting_with: str, conflicting_reqs: Set[Tuple[str, str]]
+    ) -> None:
+        format_string = (
+            "Some build dependencies for {requirement} "
+            "conflict with {conflicting_with}: {description}."
+        )
+        error_message = format_string.format(
+            requirement=self.req,
+            conflicting_with=conflicting_with,
+            description=", ".join(
+                f"{installed} is incompatible with {wanted}"
+                for installed, wanted in sorted(conflicting_reqs)
+            ),
+        )
+        raise InstallationError(error_message)
+
+    def _raise_missing_reqs(self, missing: Set[str]) -> None:
+        format_string = (
+            "Some build dependencies for {requirement} are missing: {missing}."
+        )
+        error_message = format_string.format(
+            requirement=self.req, missing=", ".join(map(repr, sorted(missing)))
+        )
+        raise InstallationError(error_message)
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/distributions/wheel.py b/venv/lib/python3.12/site-packages/pip/_internal/distributions/wheel.py
new file mode 100644
index 00000000..bfadd39d
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/distributions/wheel.py
@@ -0,0 +1,42 @@
+from typing import TYPE_CHECKING, Optional
+
+from pip._vendor.packaging.utils import canonicalize_name
+
+from pip._internal.distributions.base import AbstractDistribution
+from pip._internal.metadata import (
+    BaseDistribution,
+    FilesystemWheel,
+    get_wheel_distribution,
+)
+
+if TYPE_CHECKING:
+    from pip._internal.index.package_finder import PackageFinder
+
+
+class WheelDistribution(AbstractDistribution):
+    """Represents a wheel distribution.
+
+    This does not need any preparation as wheels can be directly unpacked.
+    """
+
+    @property
+    def build_tracker_id(self) -> Optional[str]:
+        return None
+
+    def get_metadata_distribution(self) -> BaseDistribution:
+        """Loads the metadata from the wheel file into memory and returns a
+        Distribution that uses it, not relying on the wheel file or
+        requirement.
+        """
+        assert self.req.local_file_path, "Set as part of preparation during download"
+        assert self.req.name, "Wheels are never unnamed"
+        wheel = FilesystemWheel(self.req.local_file_path)
+        return get_wheel_distribution(wheel, canonicalize_name(self.req.name))
+
+    def prepare_distribution_metadata(
+        self,
+        finder: "PackageFinder",
+        build_isolation: bool,
+        check_build_deps: bool,
+    ) -> None:
+        pass
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/exceptions.py b/venv/lib/python3.12/site-packages/pip/_internal/exceptions.py
new file mode 100644
index 00000000..2587740f
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/exceptions.py
@@ -0,0 +1,777 @@
+"""Exceptions used throughout package.
+
+This module MUST NOT try to import from anything within `pip._internal` to
+operate. This is expected to be importable from any/all files within the
+subpackage and, thus, should not depend on them.
+"""
+
+import configparser
+import contextlib
+import locale
+import logging
+import pathlib
+import re
+import sys
+from itertools import chain, groupby, repeat
+from typing import TYPE_CHECKING, Dict, Iterator, List, Literal, Optional, Union
+
+from pip._vendor.rich.console import Console, ConsoleOptions, RenderResult
+from pip._vendor.rich.markup import escape
+from pip._vendor.rich.text import Text
+
+if TYPE_CHECKING:
+    from hashlib import _Hash
+
+    from pip._vendor.requests.models import Request, Response
+
+    from pip._internal.metadata import BaseDistribution
+    from pip._internal.req.req_install import InstallRequirement
+
+logger = logging.getLogger(__name__)
+
+
+#
+# Scaffolding
+#
+def _is_kebab_case(s: str) -> bool:
+    return re.match(r"^[a-z]+(-[a-z]+)*$", s) is not None
+
+
+def _prefix_with_indent(
+    s: Union[Text, str],
+    console: Console,
+    *,
+    prefix: str,
+    indent: str,
+) -> Text:
+    if isinstance(s, Text):
+        text = s
+    else:
+        text = console.render_str(s)
+
+    return console.render_str(prefix, overflow="ignore") + console.render_str(
+        f"\n{indent}", overflow="ignore"
+    ).join(text.split(allow_blank=True))
+
+
+class PipError(Exception):
+    """The base pip error."""
+
+
+class DiagnosticPipError(PipError):
+    """An error, that presents diagnostic information to the user.
+
+    This contains a bunch of logic, to enable pretty presentation of our error
+    messages. Each error gets a unique reference. Each error can also include
+    additional context, a hint and/or a note -- which are presented with the
+    main error message in a consistent style.
+
+    This is adapted from the error output styling in `sphinx-theme-builder`.
+    """
+
+    reference: str
+
+    def __init__(
+        self,
+        *,
+        kind: 'Literal["error", "warning"]' = "error",
+        reference: Optional[str] = None,
+        message: Union[str, Text],
+        context: Optional[Union[str, Text]],
+        hint_stmt: Optional[Union[str, Text]],
+        note_stmt: Optional[Union[str, Text]] = None,
+        link: Optional[str] = None,
+    ) -> None:
+        # Ensure a proper reference is provided.
+        if reference is None:
+            assert hasattr(self, "reference"), "error reference not provided!"
+            reference = self.reference
+        assert _is_kebab_case(reference), "error reference must be kebab-case!"
+
+        self.kind = kind
+        self.reference = reference
+
+        self.message = message
+        self.context = context
+
+        self.note_stmt = note_stmt
+        self.hint_stmt = hint_stmt
+
+        self.link = link
+
+        super().__init__(f"<{self.__class__.__name__}: {self.reference}>")
+
+    def __repr__(self) -> str:
+        return (
+            f"<{self.__class__.__name__}("
+            f"reference={self.reference!r}, "
+            f"message={self.message!r}, "
+            f"context={self.context!r}, "
+            f"note_stmt={self.note_stmt!r}, "
+            f"hint_stmt={self.hint_stmt!r}"
+            ")>"
+        )
+
+    def __rich_console__(
+        self,
+        console: Console,
+        options: ConsoleOptions,
+    ) -> RenderResult:
+        colour = "red" if self.kind == "error" else "yellow"
+
+        yield f"[{colour} bold]{self.kind}[/]: [bold]{self.reference}[/]"
+        yield ""
+
+        if not options.ascii_only:
+            # Present the main message, with relevant context indented.
+            if self.context is not None:
+                yield _prefix_with_indent(
+                    self.message,
+                    console,
+                    prefix=f"[{colour}]×[/] ",
+                    indent=f"[{colour}]│[/] ",
+                )
+                yield _prefix_with_indent(
+                    self.context,
+                    console,
+                    prefix=f"[{colour}]╰─>[/] ",
+                    indent=f"[{colour}]   [/] ",
+                )
+            else:
+                yield _prefix_with_indent(
+                    self.message,
+                    console,
+                    prefix="[red]×[/] ",
+                    indent="  ",
+                )
+        else:
+            yield self.message
+            if self.context is not None:
+                yield ""
+                yield self.context
+
+        if self.note_stmt is not None or self.hint_stmt is not None:
+            yield ""
+
+        if self.note_stmt is not None:
+            yield _prefix_with_indent(
+                self.note_stmt,
+                console,
+                prefix="[magenta bold]note[/]: ",
+                indent="      ",
+            )
+        if self.hint_stmt is not None:
+            yield _prefix_with_indent(
+                self.hint_stmt,
+                console,
+                prefix="[cyan bold]hint[/]: ",
+                indent="      ",
+            )
+
+        if self.link is not None:
+            yield ""
+            yield f"Link: {self.link}"
+
+
+#
+# Actual Errors
+#
+class ConfigurationError(PipError):
+    """General exception in configuration"""
+
+
+class InstallationError(PipError):
+    """General exception during installation"""
+
+
+class MissingPyProjectBuildRequires(DiagnosticPipError):
+    """Raised when pyproject.toml has `build-system`, but no `build-system.requires`."""
+
+    reference = "missing-pyproject-build-system-requires"
+
+    def __init__(self, *, package: str) -> None:
+        super().__init__(
+            message=f"Can not process {escape(package)}",
+            context=Text(
+                "This package has an invalid pyproject.toml file.\n"
+                "The [build-system] table is missing the mandatory `requires` key."
+            ),
+            note_stmt="This is an issue with the package mentioned above, not pip.",
+            hint_stmt=Text("See PEP 518 for the detailed specification."),
+        )
+
+
+class InvalidPyProjectBuildRequires(DiagnosticPipError):
+    """Raised when pyproject.toml an invalid `build-system.requires`."""
+
+    reference = "invalid-pyproject-build-system-requires"
+
+    def __init__(self, *, package: str, reason: str) -> None:
+        super().__init__(
+            message=f"Can not process {escape(package)}",
+            context=Text(
+                "This package has an invalid `build-system.requires` key in "
+                f"pyproject.toml.\n{reason}"
+            ),
+            note_stmt="This is an issue with the package mentioned above, not pip.",
+            hint_stmt=Text("See PEP 518 for the detailed specification."),
+        )
+
+
+class NoneMetadataError(PipError):
+    """Raised when accessing a Distribution's "METADATA" or "PKG-INFO".
+
+    This signifies an inconsistency, when the Distribution claims to have
+    the metadata file (if not, raise ``FileNotFoundError`` instead), but is
+    not actually able to produce its content. This may be due to permission
+    errors.
+    """
+
+    def __init__(
+        self,
+        dist: "BaseDistribution",
+        metadata_name: str,
+    ) -> None:
+        """
+        :param dist: A Distribution object.
+        :param metadata_name: The name of the metadata being accessed
+            (can be "METADATA" or "PKG-INFO").
+        """
+        self.dist = dist
+        self.metadata_name = metadata_name
+
+    def __str__(self) -> str:
+        # Use `dist` in the error message because its stringification
+        # includes more information, like the version and location.
+        return f"None {self.metadata_name} metadata found for distribution: {self.dist}"
+
+
+class UserInstallationInvalid(InstallationError):
+    """A --user install is requested on an environment without user site."""
+
+    def __str__(self) -> str:
+        return "User base directory is not specified"
+
+
+class InvalidSchemeCombination(InstallationError):
+    def __str__(self) -> str:
+        before = ", ".join(str(a) for a in self.args[:-1])
+        return f"Cannot set {before} and {self.args[-1]} together"
+
+
+class DistributionNotFound(InstallationError):
+    """Raised when a distribution cannot be found to satisfy a requirement"""
+
+
+class RequirementsFileParseError(InstallationError):
+    """Raised when a general error occurs parsing a requirements file line."""
+
+
+class BestVersionAlreadyInstalled(PipError):
+    """Raised when the most up-to-date version of a package is already
+    installed."""
+
+
+class BadCommand(PipError):
+    """Raised when virtualenv or a command is not found"""
+
+
+class CommandError(PipError):
+    """Raised when there is an error in command-line arguments"""
+
+
+class PreviousBuildDirError(PipError):
+    """Raised when there's a previous conflicting build directory"""
+
+
+class NetworkConnectionError(PipError):
+    """HTTP connection error"""
+
+    def __init__(
+        self,
+        error_msg: str,
+        response: Optional["Response"] = None,
+        request: Optional["Request"] = None,
+    ) -> None:
+        """
+        Initialize NetworkConnectionError with  `request` and `response`
+        objects.
+        """
+        self.response = response
+        self.request = request
+        self.error_msg = error_msg
+        if (
+            self.response is not None
+            and not self.request
+            and hasattr(response, "request")
+        ):
+            self.request = self.response.request
+        super().__init__(error_msg, response, request)
+
+    def __str__(self) -> str:
+        return str(self.error_msg)
+
+
+class InvalidWheelFilename(InstallationError):
+    """Invalid wheel filename."""
+
+
+class UnsupportedWheel(InstallationError):
+    """Unsupported wheel."""
+
+
+class InvalidWheel(InstallationError):
+    """Invalid (e.g. corrupt) wheel."""
+
+    def __init__(self, location: str, name: str):
+        self.location = location
+        self.name = name
+
+    def __str__(self) -> str:
+        return f"Wheel '{self.name}' located at {self.location} is invalid."
+
+
+class MetadataInconsistent(InstallationError):
+    """Built metadata contains inconsistent information.
+
+    This is raised when the metadata contains values (e.g. name and version)
+    that do not match the information previously obtained from sdist filename,
+    user-supplied ``#egg=`` value, or an install requirement name.
+    """
+
+    def __init__(
+        self, ireq: "InstallRequirement", field: str, f_val: str, m_val: str
+    ) -> None:
+        self.ireq = ireq
+        self.field = field
+        self.f_val = f_val
+        self.m_val = m_val
+
+    def __str__(self) -> str:
+        return (
+            f"Requested {self.ireq} has inconsistent {self.field}: "
+            f"expected {self.f_val!r}, but metadata has {self.m_val!r}"
+        )
+
+
+class MetadataInvalid(InstallationError):
+    """Metadata is invalid."""
+
+    def __init__(self, ireq: "InstallRequirement", error: str) -> None:
+        self.ireq = ireq
+        self.error = error
+
+    def __str__(self) -> str:
+        return f"Requested {self.ireq} has invalid metadata: {self.error}"
+
+
+class InstallationSubprocessError(DiagnosticPipError, InstallationError):
+    """A subprocess call failed."""
+
+    reference = "subprocess-exited-with-error"
+
+    def __init__(
+        self,
+        *,
+        command_description: str,
+        exit_code: int,
+        output_lines: Optional[List[str]],
+    ) -> None:
+        if output_lines is None:
+            output_prompt = Text("See above for output.")
+        else:
+            output_prompt = (
+                Text.from_markup(f"[red][{len(output_lines)} lines of output][/]\n")
+                + Text("".join(output_lines))
+                + Text.from_markup(R"[red]\[end of output][/]")
+            )
+
+        super().__init__(
+            message=(
+                f"[green]{escape(command_description)}[/] did not run successfully.\n"
+                f"exit code: {exit_code}"
+            ),
+            context=output_prompt,
+            hint_stmt=None,
+            note_stmt=(
+                "This error originates from a subprocess, and is likely not a "
+                "problem with pip."
+            ),
+        )
+
+        self.command_description = command_description
+        self.exit_code = exit_code
+
+    def __str__(self) -> str:
+        return f"{self.command_description} exited with {self.exit_code}"
+
+
+class MetadataGenerationFailed(InstallationSubprocessError, InstallationError):
+    reference = "metadata-generation-failed"
+
+    def __init__(
+        self,
+        *,
+        package_details: str,
+    ) -> None:
+        super(InstallationSubprocessError, self).__init__(
+            message="Encountered error while generating package metadata.",
+            context=escape(package_details),
+            hint_stmt="See above for details.",
+            note_stmt="This is an issue with the package mentioned above, not pip.",
+        )
+
+    def __str__(self) -> str:
+        return "metadata generation failed"
+
+
+class HashErrors(InstallationError):
+    """Multiple HashError instances rolled into one for reporting"""
+
+    def __init__(self) -> None:
+        self.errors: List["HashError"] = []
+
+    def append(self, error: "HashError") -> None:
+        self.errors.append(error)
+
+    def __str__(self) -> str:
+        lines = []
+        self.errors.sort(key=lambda e: e.order)
+        for cls, errors_of_cls in groupby(self.errors, lambda e: e.__class__):
+            lines.append(cls.head)
+            lines.extend(e.body() for e in errors_of_cls)
+        if lines:
+            return "\n".join(lines)
+        return ""
+
+    def __bool__(self) -> bool:
+        return bool(self.errors)
+
+
+class HashError(InstallationError):
+    """
+    A failure to verify a package against known-good hashes
+
+    :cvar order: An int sorting hash exception classes by difficulty of
+        recovery (lower being harder), so the user doesn't bother fretting
+        about unpinned packages when he has deeper issues, like VCS
+        dependencies, to deal with. Also keeps error reports in a
+        deterministic order.
+    :cvar head: A section heading for display above potentially many
+        exceptions of this kind
+    :ivar req: The InstallRequirement that triggered this error. This is
+        pasted on after the exception is instantiated, because it's not
+        typically available earlier.
+
+    """
+
+    req: Optional["InstallRequirement"] = None
+    head = ""
+    order: int = -1
+
+    def body(self) -> str:
+        """Return a summary of me for display under the heading.
+
+        This default implementation simply prints a description of the
+        triggering requirement.
+
+        :param req: The InstallRequirement that provoked this error, with
+            its link already populated by the resolver's _populate_link().
+
+        """
+        return f"    {self._requirement_name()}"
+
+    def __str__(self) -> str:
+        return f"{self.head}\n{self.body()}"
+
+    def _requirement_name(self) -> str:
+        """Return a description of the requirement that triggered me.
+
+        This default implementation returns long description of the req, with
+        line numbers
+
+        """
+        return str(self.req) if self.req else "unknown package"
+
+
+class VcsHashUnsupported(HashError):
+    """A hash was provided for a version-control-system-based requirement, but
+    we don't have a method for hashing those."""
+
+    order = 0
+    head = (
+        "Can't verify hashes for these requirements because we don't "
+        "have a way to hash version control repositories:"
+    )
+
+
+class DirectoryUrlHashUnsupported(HashError):
+    """A hash was provided for a version-control-system-based requirement, but
+    we don't have a method for hashing those."""
+
+    order = 1
+    head = (
+        "Can't verify hashes for these file:// requirements because they "
+        "point to directories:"
+    )
+
+
+class HashMissing(HashError):
+    """A hash was needed for a requirement but is absent."""
+
+    order = 2
+    head = (
+        "Hashes are required in --require-hashes mode, but they are "
+        "missing from some requirements. Here is a list of those "
+        "requirements along with the hashes their downloaded archives "
+        "actually had. Add lines like these to your requirements files to "
+        "prevent tampering. (If you did not enable --require-hashes "
+        "manually, note that it turns on automatically when any package "
+        "has a hash.)"
+    )
+
+    def __init__(self, gotten_hash: str) -> None:
+        """
+        :param gotten_hash: The hash of the (possibly malicious) archive we
+            just downloaded
+        """
+        self.gotten_hash = gotten_hash
+
+    def body(self) -> str:
+        # Dodge circular import.
+        from pip._internal.utils.hashes import FAVORITE_HASH
+
+        package = None
+        if self.req:
+            # In the case of URL-based requirements, display the original URL
+            # seen in the requirements file rather than the package name,
+            # so the output can be directly copied into the requirements file.
+            package = (
+                self.req.original_link
+                if self.req.is_direct
+                # In case someone feeds something downright stupid
+                # to InstallRequirement's constructor.
+                else getattr(self.req, "req", None)
+            )
+        return "    {} --hash={}:{}".format(
+            package or "unknown package", FAVORITE_HASH, self.gotten_hash
+        )
+
+
+class HashUnpinned(HashError):
+    """A requirement had a hash specified but was not pinned to a specific
+    version."""
+
+    order = 3
+    head = (
+        "In --require-hashes mode, all requirements must have their "
+        "versions pinned with ==. These do not:"
+    )
+
+
+class HashMismatch(HashError):
+    """
+    Distribution file hash values don't match.
+
+    :ivar package_name: The name of the package that triggered the hash
+        mismatch. Feel free to write to this after the exception is raise to
+        improve its error message.
+
+    """
+
+    order = 4
+    head = (
+        "THESE PACKAGES DO NOT MATCH THE HASHES FROM THE REQUIREMENTS "
+        "FILE. If you have updated the package versions, please update "
+        "the hashes. Otherwise, examine the package contents carefully; "
+        "someone may have tampered with them."
+    )
+
+    def __init__(self, allowed: Dict[str, List[str]], gots: Dict[str, "_Hash"]) -> None:
+        """
+        :param allowed: A dict of algorithm names pointing to lists of allowed
+            hex digests
+        :param gots: A dict of algorithm names pointing to hashes we
+            actually got from the files under suspicion
+        """
+        self.allowed = allowed
+        self.gots = gots
+
+    def body(self) -> str:
+        return f"    {self._requirement_name()}:\n{self._hash_comparison()}"
+
+    def _hash_comparison(self) -> str:
+        """
+        Return a comparison of actual and expected hash values.
+
+        Example::
+
+               Expected sha256 abcdeabcdeabcdeabcdeabcdeabcdeabcdeabcdeabcde
+                            or 123451234512345123451234512345123451234512345
+                    Got        bcdefbcdefbcdefbcdefbcdefbcdefbcdefbcdefbcdef
+
+        """
+
+        def hash_then_or(hash_name: str) -> "chain[str]":
+            # For now, all the decent hashes have 6-char names, so we can get
+            # away with hard-coding space literals.
+            return chain([hash_name], repeat("    or"))
+
+        lines: List[str] = []
+        for hash_name, expecteds in self.allowed.items():
+            prefix = hash_then_or(hash_name)
+            lines.extend((f"        Expected {next(prefix)} {e}") for e in expecteds)
+            lines.append(
+                f"             Got        {self.gots[hash_name].hexdigest()}\n"
+            )
+        return "\n".join(lines)
+
+
+class UnsupportedPythonVersion(InstallationError):
+    """Unsupported python version according to Requires-Python package
+    metadata."""
+
+
+class ConfigurationFileCouldNotBeLoaded(ConfigurationError):
+    """When there are errors while loading a configuration file"""
+
+    def __init__(
+        self,
+        reason: str = "could not be loaded",
+        fname: Optional[str] = None,
+        error: Optional[configparser.Error] = None,
+    ) -> None:
+        super().__init__(error)
+        self.reason = reason
+        self.fname = fname
+        self.error = error
+
+    def __str__(self) -> str:
+        if self.fname is not None:
+            message_part = f" in {self.fname}."
+        else:
+            assert self.error is not None
+            message_part = f".\n{self.error}\n"
+        return f"Configuration file {self.reason}{message_part}"
+
+
+_DEFAULT_EXTERNALLY_MANAGED_ERROR = f"""\
+The Python environment under {sys.prefix} is managed externally, and may not be
+manipulated by the user. Please use specific tooling from the distributor of
+the Python installation to interact with this environment instead.
+"""
+
+
+class ExternallyManagedEnvironment(DiagnosticPipError):
+    """The current environment is externally managed.
+
+    This is raised when the current environment is externally managed, as
+    defined by `PEP 668`_. The ``EXTERNALLY-MANAGED`` configuration is checked
+    and displayed when the error is bubbled up to the user.
+
+    :param error: The error message read from ``EXTERNALLY-MANAGED``.
+    """
+
+    reference = "externally-managed-environment"
+
+    def __init__(self, error: Optional[str]) -> None:
+        if error is None:
+            context = Text(_DEFAULT_EXTERNALLY_MANAGED_ERROR)
+        else:
+            context = Text(error)
+        super().__init__(
+            message="This environment is externally managed",
+            context=context,
+            note_stmt=(
+                "If you believe this is a mistake, please contact your "
+                "Python installation or OS distribution provider. "
+                "You can override this, at the risk of breaking your Python "
+                "installation or OS, by passing --break-system-packages."
+            ),
+            hint_stmt=Text("See PEP 668 for the detailed specification."),
+        )
+
+    @staticmethod
+    def _iter_externally_managed_error_keys() -> Iterator[str]:
+        # LC_MESSAGES is in POSIX, but not the C standard. The most common
+        # platform that does not implement this category is Windows, where
+        # using other categories for console message localization is equally
+        # unreliable, so we fall back to the locale-less vendor message. This
+        # can always be re-evaluated when a vendor proposes a new alternative.
+        try:
+            category = locale.LC_MESSAGES
+        except AttributeError:
+            lang: Optional[str] = None
+        else:
+            lang, _ = locale.getlocale(category)
+        if lang is not None:
+            yield f"Error-{lang}"
+            for sep in ("-", "_"):
+                before, found, _ = lang.partition(sep)
+                if not found:
+                    continue
+                yield f"Error-{before}"
+        yield "Error"
+
+    @classmethod
+    def from_config(
+        cls,
+        config: Union[pathlib.Path, str],
+    ) -> "ExternallyManagedEnvironment":
+        parser = configparser.ConfigParser(interpolation=None)
+        try:
+            parser.read(config, encoding="utf-8")
+            section = parser["externally-managed"]
+            for key in cls._iter_externally_managed_error_keys():
+                with contextlib.suppress(KeyError):
+                    return cls(section[key])
+        except KeyError:
+            pass
+        except (OSError, UnicodeDecodeError, configparser.ParsingError):
+            from pip._internal.utils._log import VERBOSE
+
+            exc_info = logger.isEnabledFor(VERBOSE)
+            logger.warning("Failed to read %s", config, exc_info=exc_info)
+        return cls(None)
+
+
+class UninstallMissingRecord(DiagnosticPipError):
+    reference = "uninstall-no-record-file"
+
+    def __init__(self, *, distribution: "BaseDistribution") -> None:
+        installer = distribution.installer
+        if not installer or installer == "pip":
+            dep = f"{distribution.raw_name}=={distribution.version}"
+            hint = Text.assemble(
+                "You might be able to recover from this via: ",
+                (f"pip install --force-reinstall --no-deps {dep}", "green"),
+            )
+        else:
+            hint = Text(
+                f"The package was installed by {installer}. "
+                "You should check if it can uninstall the package."
+            )
+
+        super().__init__(
+            message=Text(f"Cannot uninstall {distribution}"),
+            context=(
+                "The package's contents are unknown: "
+                f"no RECORD file was found for {distribution.raw_name}."
+            ),
+            hint_stmt=hint,
+        )
+
+
+class LegacyDistutilsInstall(DiagnosticPipError):
+    reference = "uninstall-distutils-installed-package"
+
+    def __init__(self, *, distribution: "BaseDistribution") -> None:
+        super().__init__(
+            message=Text(f"Cannot uninstall {distribution}"),
+            context=(
+                "It is a distutils installed project and thus we cannot accurately "
+                "determine which files belong to it which would lead to only a partial "
+                "uninstall."
+            ),
+            hint_stmt=None,
+        )
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/index/__init__.py b/venv/lib/python3.12/site-packages/pip/_internal/index/__init__.py
new file mode 100644
index 00000000..7a17b7b3
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/index/__init__.py
@@ -0,0 +1,2 @@
+"""Index interaction code
+"""
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/index/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/index/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 00000000..63701fda
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/index/__pycache__/__init__.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/index/__pycache__/collector.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/index/__pycache__/collector.cpython-312.pyc
new file mode 100644
index 00000000..b35f5569
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/index/__pycache__/collector.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/index/__pycache__/package_finder.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/index/__pycache__/package_finder.cpython-312.pyc
new file mode 100644
index 00000000..9e058b18
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/index/__pycache__/package_finder.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/index/__pycache__/sources.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/index/__pycache__/sources.cpython-312.pyc
new file mode 100644
index 00000000..1f8665bd
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/index/__pycache__/sources.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/index/collector.py b/venv/lib/python3.12/site-packages/pip/_internal/index/collector.py
new file mode 100644
index 00000000..5f8fdee3
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/index/collector.py
@@ -0,0 +1,494 @@
+"""
+The main purpose of this module is to expose LinkCollector.collect_sources().
+"""
+
+import collections
+import email.message
+import functools
+import itertools
+import json
+import logging
+import os
+import urllib.parse
+import urllib.request
+from dataclasses import dataclass
+from html.parser import HTMLParser
+from optparse import Values
+from typing import (
+    Callable,
+    Dict,
+    Iterable,
+    List,
+    MutableMapping,
+    NamedTuple,
+    Optional,
+    Protocol,
+    Sequence,
+    Tuple,
+    Union,
+)
+
+from pip._vendor import requests
+from pip._vendor.requests import Response
+from pip._vendor.requests.exceptions import RetryError, SSLError
+
+from pip._internal.exceptions import NetworkConnectionError
+from pip._internal.models.link import Link
+from pip._internal.models.search_scope import SearchScope
+from pip._internal.network.session import PipSession
+from pip._internal.network.utils import raise_for_status
+from pip._internal.utils.filetypes import is_archive_file
+from pip._internal.utils.misc import redact_auth_from_url
+from pip._internal.vcs import vcs
+
+from .sources import CandidatesFromPage, LinkSource, build_source
+
+logger = logging.getLogger(__name__)
+
+ResponseHeaders = MutableMapping[str, str]
+
+
+def _match_vcs_scheme(url: str) -> Optional[str]:
+    """Look for VCS schemes in the URL.
+
+    Returns the matched VCS scheme, or None if there's no match.
+    """
+    for scheme in vcs.schemes:
+        if url.lower().startswith(scheme) and url[len(scheme)] in "+:":
+            return scheme
+    return None
+
+
+class _NotAPIContent(Exception):
+    def __init__(self, content_type: str, request_desc: str) -> None:
+        super().__init__(content_type, request_desc)
+        self.content_type = content_type
+        self.request_desc = request_desc
+
+
+def _ensure_api_header(response: Response) -> None:
+    """
+    Check the Content-Type header to ensure the response contains a Simple
+    API Response.
+
+    Raises `_NotAPIContent` if the content type is not a valid content-type.
+    """
+    content_type = response.headers.get("Content-Type", "Unknown")
+
+    content_type_l = content_type.lower()
+    if content_type_l.startswith(
+        (
+            "text/html",
+            "application/vnd.pypi.simple.v1+html",
+            "application/vnd.pypi.simple.v1+json",
+        )
+    ):
+        return
+
+    raise _NotAPIContent(content_type, response.request.method)
+
+
+class _NotHTTP(Exception):
+    pass
+
+
+def _ensure_api_response(url: str, session: PipSession) -> None:
+    """
+    Send a HEAD request to the URL, and ensure the response contains a simple
+    API Response.
+
+    Raises `_NotHTTP` if the URL is not available for a HEAD request, or
+    `_NotAPIContent` if the content type is not a valid content type.
+    """
+    scheme, netloc, path, query, fragment = urllib.parse.urlsplit(url)
+    if scheme not in {"http", "https"}:
+        raise _NotHTTP()
+
+    resp = session.head(url, allow_redirects=True)
+    raise_for_status(resp)
+
+    _ensure_api_header(resp)
+
+
+def _get_simple_response(url: str, session: PipSession) -> Response:
+    """Access an Simple API response with GET, and return the response.
+
+    This consists of three parts:
+
+    1. If the URL looks suspiciously like an archive, send a HEAD first to
+       check the Content-Type is HTML or Simple API, to avoid downloading a
+       large file. Raise `_NotHTTP` if the content type cannot be determined, or
+       `_NotAPIContent` if it is not HTML or a Simple API.
+    2. Actually perform the request. Raise HTTP exceptions on network failures.
+    3. Check the Content-Type header to make sure we got a Simple API response,
+       and raise `_NotAPIContent` otherwise.
+    """
+    if is_archive_file(Link(url).filename):
+        _ensure_api_response(url, session=session)
+
+    logger.debug("Getting page %s", redact_auth_from_url(url))
+
+    resp = session.get(
+        url,
+        headers={
+            "Accept": ", ".join(
+                [
+                    "application/vnd.pypi.simple.v1+json",
+                    "application/vnd.pypi.simple.v1+html; q=0.1",
+                    "text/html; q=0.01",
+                ]
+            ),
+            # We don't want to blindly returned cached data for
+            # /simple/, because authors generally expecting that
+            # twine upload && pip install will function, but if
+            # they've done a pip install in the last ~10 minutes
+            # it won't. Thus by setting this to zero we will not
+            # blindly use any cached data, however the benefit of
+            # using max-age=0 instead of no-cache, is that we will
+            # still support conditional requests, so we will still
+            # minimize traffic sent in cases where the page hasn't
+            # changed at all, we will just always incur the round
+            # trip for the conditional GET now instead of only
+            # once per 10 minutes.
+            # For more information, please see pypa/pip#5670.
+            "Cache-Control": "max-age=0",
+        },
+    )
+    raise_for_status(resp)
+
+    # The check for archives above only works if the url ends with
+    # something that looks like an archive. However that is not a
+    # requirement of an url. Unless we issue a HEAD request on every
+    # url we cannot know ahead of time for sure if something is a
+    # Simple API response or not. However we can check after we've
+    # downloaded it.
+    _ensure_api_header(resp)
+
+    logger.debug(
+        "Fetched page %s as %s",
+        redact_auth_from_url(url),
+        resp.headers.get("Content-Type", "Unknown"),
+    )
+
+    return resp
+
+
+def _get_encoding_from_headers(headers: ResponseHeaders) -> Optional[str]:
+    """Determine if we have any encoding information in our headers."""
+    if headers and "Content-Type" in headers:
+        m = email.message.Message()
+        m["content-type"] = headers["Content-Type"]
+        charset = m.get_param("charset")
+        if charset:
+            return str(charset)
+    return None
+
+
+class CacheablePageContent:
+    def __init__(self, page: "IndexContent") -> None:
+        assert page.cache_link_parsing
+        self.page = page
+
+    def __eq__(self, other: object) -> bool:
+        return isinstance(other, type(self)) and self.page.url == other.page.url
+
+    def __hash__(self) -> int:
+        return hash(self.page.url)
+
+
+class ParseLinks(Protocol):
+    def __call__(self, page: "IndexContent") -> Iterable[Link]: ...
+
+
+def with_cached_index_content(fn: ParseLinks) -> ParseLinks:
+    """
+    Given a function that parses an Iterable[Link] from an IndexContent, cache the
+    function's result (keyed by CacheablePageContent), unless the IndexContent
+    `page` has `page.cache_link_parsing == False`.
+    """
+
+    @functools.lru_cache(maxsize=None)
+    def wrapper(cacheable_page: CacheablePageContent) -> List[Link]:
+        return list(fn(cacheable_page.page))
+
+    @functools.wraps(fn)
+    def wrapper_wrapper(page: "IndexContent") -> List[Link]:
+        if page.cache_link_parsing:
+            return wrapper(CacheablePageContent(page))
+        return list(fn(page))
+
+    return wrapper_wrapper
+
+
+@with_cached_index_content
+def parse_links(page: "IndexContent") -> Iterable[Link]:
+    """
+    Parse a Simple API's Index Content, and yield its anchor elements as Link objects.
+    """
+
+    content_type_l = page.content_type.lower()
+    if content_type_l.startswith("application/vnd.pypi.simple.v1+json"):
+        data = json.loads(page.content)
+        for file in data.get("files", []):
+            link = Link.from_json(file, page.url)
+            if link is None:
+                continue
+            yield link
+        return
+
+    parser = HTMLLinkParser(page.url)
+    encoding = page.encoding or "utf-8"
+    parser.feed(page.content.decode(encoding))
+
+    url = page.url
+    base_url = parser.base_url or url
+    for anchor in parser.anchors:
+        link = Link.from_element(anchor, page_url=url, base_url=base_url)
+        if link is None:
+            continue
+        yield link
+
+
+@dataclass(frozen=True)
+class IndexContent:
+    """Represents one response (or page), along with its URL.
+
+    :param encoding: the encoding to decode the given content.
+    :param url: the URL from which the HTML was downloaded.
+    :param cache_link_parsing: whether links parsed from this page's url
+                               should be cached. PyPI index urls should
+                               have this set to False, for example.
+    """
+
+    content: bytes
+    content_type: str
+    encoding: Optional[str]
+    url: str
+    cache_link_parsing: bool = True
+
+    def __str__(self) -> str:
+        return redact_auth_from_url(self.url)
+
+
+class HTMLLinkParser(HTMLParser):
+    """
+    HTMLParser that keeps the first base HREF and a list of all anchor
+    elements' attributes.
+    """
+
+    def __init__(self, url: str) -> None:
+        super().__init__(convert_charrefs=True)
+
+        self.url: str = url
+        self.base_url: Optional[str] = None
+        self.anchors: List[Dict[str, Optional[str]]] = []
+
+    def handle_starttag(self, tag: str, attrs: List[Tuple[str, Optional[str]]]) -> None:
+        if tag == "base" and self.base_url is None:
+            href = self.get_href(attrs)
+            if href is not None:
+                self.base_url = href
+        elif tag == "a":
+            self.anchors.append(dict(attrs))
+
+    def get_href(self, attrs: List[Tuple[str, Optional[str]]]) -> Optional[str]:
+        for name, value in attrs:
+            if name == "href":
+                return value
+        return None
+
+
+def _handle_get_simple_fail(
+    link: Link,
+    reason: Union[str, Exception],
+    meth: Optional[Callable[..., None]] = None,
+) -> None:
+    if meth is None:
+        meth = logger.debug
+    meth("Could not fetch URL %s: %s - skipping", link, reason)
+
+
+def _make_index_content(
+    response: Response, cache_link_parsing: bool = True
+) -> IndexContent:
+    encoding = _get_encoding_from_headers(response.headers)
+    return IndexContent(
+        response.content,
+        response.headers["Content-Type"],
+        encoding=encoding,
+        url=response.url,
+        cache_link_parsing=cache_link_parsing,
+    )
+
+
+def _get_index_content(link: Link, *, session: PipSession) -> Optional["IndexContent"]:
+    url = link.url.split("#", 1)[0]
+
+    # Check for VCS schemes that do not support lookup as web pages.
+    vcs_scheme = _match_vcs_scheme(url)
+    if vcs_scheme:
+        logger.warning(
+            "Cannot look at %s URL %s because it does not support lookup as web pages.",
+            vcs_scheme,
+            link,
+        )
+        return None
+
+    # Tack index.html onto file:// URLs that point to directories
+    scheme, _, path, _, _, _ = urllib.parse.urlparse(url)
+    if scheme == "file" and os.path.isdir(urllib.request.url2pathname(path)):
+        # add trailing slash if not present so urljoin doesn't trim
+        # final segment
+        if not url.endswith("/"):
+            url += "/"
+        # TODO: In the future, it would be nice if pip supported PEP 691
+        #       style responses in the file:// URLs, however there's no
+        #       standard file extension for application/vnd.pypi.simple.v1+json
+        #       so we'll need to come up with something on our own.
+        url = urllib.parse.urljoin(url, "index.html")
+        logger.debug(" file: URL is directory, getting %s", url)
+
+    try:
+        resp = _get_simple_response(url, session=session)
+    except _NotHTTP:
+        logger.warning(
+            "Skipping page %s because it looks like an archive, and cannot "
+            "be checked by a HTTP HEAD request.",
+            link,
+        )
+    except _NotAPIContent as exc:
+        logger.warning(
+            "Skipping page %s because the %s request got Content-Type: %s. "
+            "The only supported Content-Types are application/vnd.pypi.simple.v1+json, "
+            "application/vnd.pypi.simple.v1+html, and text/html",
+            link,
+            exc.request_desc,
+            exc.content_type,
+        )
+    except NetworkConnectionError as exc:
+        _handle_get_simple_fail(link, exc)
+    except RetryError as exc:
+        _handle_get_simple_fail(link, exc)
+    except SSLError as exc:
+        reason = "There was a problem confirming the ssl certificate: "
+        reason += str(exc)
+        _handle_get_simple_fail(link, reason, meth=logger.info)
+    except requests.ConnectionError as exc:
+        _handle_get_simple_fail(link, f"connection error: {exc}")
+    except requests.Timeout:
+        _handle_get_simple_fail(link, "timed out")
+    else:
+        return _make_index_content(resp, cache_link_parsing=link.cache_link_parsing)
+    return None
+
+
+class CollectedSources(NamedTuple):
+    find_links: Sequence[Optional[LinkSource]]
+    index_urls: Sequence[Optional[LinkSource]]
+
+
+class LinkCollector:
+    """
+    Responsible for collecting Link objects from all configured locations,
+    making network requests as needed.
+
+    The class's main method is its collect_sources() method.
+    """
+
+    def __init__(
+        self,
+        session: PipSession,
+        search_scope: SearchScope,
+    ) -> None:
+        self.search_scope = search_scope
+        self.session = session
+
+    @classmethod
+    def create(
+        cls,
+        session: PipSession,
+        options: Values,
+        suppress_no_index: bool = False,
+    ) -> "LinkCollector":
+        """
+        :param session: The Session to use to make requests.
+        :param suppress_no_index: Whether to ignore the --no-index option
+            when constructing the SearchScope object.
+        """
+        index_urls = [options.index_url] + options.extra_index_urls
+        if options.no_index and not suppress_no_index:
+            logger.debug(
+                "Ignoring indexes: %s",
+                ",".join(redact_auth_from_url(url) for url in index_urls),
+            )
+            index_urls = []
+
+        # Make sure find_links is a list before passing to create().
+        find_links = options.find_links or []
+
+        search_scope = SearchScope.create(
+            find_links=find_links,
+            index_urls=index_urls,
+            no_index=options.no_index,
+        )
+        link_collector = LinkCollector(
+            session=session,
+            search_scope=search_scope,
+        )
+        return link_collector
+
+    @property
+    def find_links(self) -> List[str]:
+        return self.search_scope.find_links
+
+    def fetch_response(self, location: Link) -> Optional[IndexContent]:
+        """
+        Fetch an HTML page containing package links.
+        """
+        return _get_index_content(location, session=self.session)
+
+    def collect_sources(
+        self,
+        project_name: str,
+        candidates_from_page: CandidatesFromPage,
+    ) -> CollectedSources:
+        # The OrderedDict calls deduplicate sources by URL.
+        index_url_sources = collections.OrderedDict(
+            build_source(
+                loc,
+                candidates_from_page=candidates_from_page,
+                page_validator=self.session.is_secure_origin,
+                expand_dir=False,
+                cache_link_parsing=False,
+                project_name=project_name,
+            )
+            for loc in self.search_scope.get_index_urls_locations(project_name)
+        ).values()
+        find_links_sources = collections.OrderedDict(
+            build_source(
+                loc,
+                candidates_from_page=candidates_from_page,
+                page_validator=self.session.is_secure_origin,
+                expand_dir=True,
+                cache_link_parsing=True,
+                project_name=project_name,
+            )
+            for loc in self.find_links
+        ).values()
+
+        if logger.isEnabledFor(logging.DEBUG):
+            lines = [
+                f"* {s.link}"
+                for s in itertools.chain(find_links_sources, index_url_sources)
+                if s is not None and s.link is not None
+            ]
+            lines = [
+                f"{len(lines)} location(s) to search "
+                f"for versions of {project_name}:"
+            ] + lines
+            logger.debug("\n".join(lines))
+
+        return CollectedSources(
+            find_links=list(find_links_sources),
+            index_urls=list(index_url_sources),
+        )
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/index/package_finder.py b/venv/lib/python3.12/site-packages/pip/_internal/index/package_finder.py
new file mode 100644
index 00000000..0d65ce35
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/index/package_finder.py
@@ -0,0 +1,1020 @@
+"""Routines related to PyPI, indexes"""
+
+import enum
+import functools
+import itertools
+import logging
+import re
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, FrozenSet, Iterable, List, Optional, Set, Tuple, Union
+
+from pip._vendor.packaging import specifiers
+from pip._vendor.packaging.tags import Tag
+from pip._vendor.packaging.utils import canonicalize_name
+from pip._vendor.packaging.version import InvalidVersion, _BaseVersion
+from pip._vendor.packaging.version import parse as parse_version
+
+from pip._internal.exceptions import (
+    BestVersionAlreadyInstalled,
+    DistributionNotFound,
+    InvalidWheelFilename,
+    UnsupportedWheel,
+)
+from pip._internal.index.collector import LinkCollector, parse_links
+from pip._internal.models.candidate import InstallationCandidate
+from pip._internal.models.format_control import FormatControl
+from pip._internal.models.link import Link
+from pip._internal.models.search_scope import SearchScope
+from pip._internal.models.selection_prefs import SelectionPreferences
+from pip._internal.models.target_python import TargetPython
+from pip._internal.models.wheel import Wheel
+from pip._internal.req import InstallRequirement
+from pip._internal.utils._log import getLogger
+from pip._internal.utils.filetypes import WHEEL_EXTENSION
+from pip._internal.utils.hashes import Hashes
+from pip._internal.utils.logging import indent_log
+from pip._internal.utils.misc import build_netloc
+from pip._internal.utils.packaging import check_requires_python
+from pip._internal.utils.unpacking import SUPPORTED_EXTENSIONS
+
+if TYPE_CHECKING:
+    from pip._vendor.typing_extensions import TypeGuard
+
+__all__ = ["FormatControl", "BestCandidateResult", "PackageFinder"]
+
+
+logger = getLogger(__name__)
+
+BuildTag = Union[Tuple[()], Tuple[int, str]]
+CandidateSortingKey = Tuple[int, int, int, _BaseVersion, Optional[int], BuildTag]
+
+
+def _check_link_requires_python(
+    link: Link,
+    version_info: Tuple[int, int, int],
+    ignore_requires_python: bool = False,
+) -> bool:
+    """
+    Return whether the given Python version is compatible with a link's
+    "Requires-Python" value.
+
+    :param version_info: A 3-tuple of ints representing the Python
+        major-minor-micro version to check.
+    :param ignore_requires_python: Whether to ignore the "Requires-Python"
+        value if the given Python version isn't compatible.
+    """
+    try:
+        is_compatible = check_requires_python(
+            link.requires_python,
+            version_info=version_info,
+        )
+    except specifiers.InvalidSpecifier:
+        logger.debug(
+            "Ignoring invalid Requires-Python (%r) for link: %s",
+            link.requires_python,
+            link,
+        )
+    else:
+        if not is_compatible:
+            version = ".".join(map(str, version_info))
+            if not ignore_requires_python:
+                logger.verbose(
+                    "Link requires a different Python (%s not in: %r): %s",
+                    version,
+                    link.requires_python,
+                    link,
+                )
+                return False
+
+            logger.debug(
+                "Ignoring failed Requires-Python check (%s not in: %r) for link: %s",
+                version,
+                link.requires_python,
+                link,
+            )
+
+    return True
+
+
+class LinkType(enum.Enum):
+    candidate = enum.auto()
+    different_project = enum.auto()
+    yanked = enum.auto()
+    format_unsupported = enum.auto()
+    format_invalid = enum.auto()
+    platform_mismatch = enum.auto()
+    requires_python_mismatch = enum.auto()
+
+
+class LinkEvaluator:
+    """
+    Responsible for evaluating links for a particular project.
+    """
+
+    _py_version_re = re.compile(r"-py([123]\.?[0-9]?)$")
+
+    # Don't include an allow_yanked default value to make sure each call
+    # site considers whether yanked releases are allowed. This also causes
+    # that decision to be made explicit in the calling code, which helps
+    # people when reading the code.
+    def __init__(
+        self,
+        project_name: str,
+        canonical_name: str,
+        formats: FrozenSet[str],
+        target_python: TargetPython,
+        allow_yanked: bool,
+        ignore_requires_python: Optional[bool] = None,
+    ) -> None:
+        """
+        :param project_name: The user supplied package name.
+        :param canonical_name: The canonical package name.
+        :param formats: The formats allowed for this package. Should be a set
+            with 'binary' or 'source' or both in it.
+        :param target_python: The target Python interpreter to use when
+            evaluating link compatibility. This is used, for example, to
+            check wheel compatibility, as well as when checking the Python
+            version, e.g. the Python version embedded in a link filename
+            (or egg fragment) and against an HTML link's optional PEP 503
+            "data-requires-python" attribute.
+        :param allow_yanked: Whether files marked as yanked (in the sense
+            of PEP 592) are permitted to be candidates for install.
+        :param ignore_requires_python: Whether to ignore incompatible
+            PEP 503 "data-requires-python" values in HTML links. Defaults
+            to False.
+        """
+        if ignore_requires_python is None:
+            ignore_requires_python = False
+
+        self._allow_yanked = allow_yanked
+        self._canonical_name = canonical_name
+        self._ignore_requires_python = ignore_requires_python
+        self._formats = formats
+        self._target_python = target_python
+
+        self.project_name = project_name
+
+    def evaluate_link(self, link: Link) -> Tuple[LinkType, str]:
+        """
+        Determine whether a link is a candidate for installation.
+
+        :return: A tuple (result, detail), where *result* is an enum
+            representing whether the evaluation found a candidate, or the reason
+            why one is not found. If a candidate is found, *detail* will be the
+            candidate's version string; if one is not found, it contains the
+            reason the link fails to qualify.
+        """
+        version = None
+        if link.is_yanked and not self._allow_yanked:
+            reason = link.yanked_reason or ""
+            return (LinkType.yanked, f"yanked for reason: {reason}")
+
+        if link.egg_fragment:
+            egg_info = link.egg_fragment
+            ext = link.ext
+        else:
+            egg_info, ext = link.splitext()
+            if not ext:
+                return (LinkType.format_unsupported, "not a file")
+            if ext not in SUPPORTED_EXTENSIONS:
+                return (
+                    LinkType.format_unsupported,
+                    f"unsupported archive format: {ext}",
+                )
+            if "binary" not in self._formats and ext == WHEEL_EXTENSION:
+                reason = f"No binaries permitted for {self.project_name}"
+                return (LinkType.format_unsupported, reason)
+            if "macosx10" in link.path and ext == ".zip":
+                return (LinkType.format_unsupported, "macosx10 one")
+            if ext == WHEEL_EXTENSION:
+                try:
+                    wheel = Wheel(link.filename)
+                except InvalidWheelFilename:
+                    return (
+                        LinkType.format_invalid,
+                        "invalid wheel filename",
+                    )
+                if canonicalize_name(wheel.name) != self._canonical_name:
+                    reason = f"wrong project name (not {self.project_name})"
+                    return (LinkType.different_project, reason)
+
+                supported_tags = self._target_python.get_unsorted_tags()
+                if not wheel.supported(supported_tags):
+                    # Include the wheel's tags in the reason string to
+                    # simplify troubleshooting compatibility issues.
+                    file_tags = ", ".join(wheel.get_formatted_file_tags())
+                    reason = (
+                        f"none of the wheel's tags ({file_tags}) are compatible "
+                        f"(run pip debug --verbose to show compatible tags)"
+                    )
+                    return (LinkType.platform_mismatch, reason)
+
+                version = wheel.version
+
+        # This should be up by the self.ok_binary check, but see issue 2700.
+        if "source" not in self._formats and ext != WHEEL_EXTENSION:
+            reason = f"No sources permitted for {self.project_name}"
+            return (LinkType.format_unsupported, reason)
+
+        if not version:
+            version = _extract_version_from_fragment(
+                egg_info,
+                self._canonical_name,
+            )
+        if not version:
+            reason = f"Missing project version for {self.project_name}"
+            return (LinkType.format_invalid, reason)
+
+        match = self._py_version_re.search(version)
+        if match:
+            version = version[: match.start()]
+            py_version = match.group(1)
+            if py_version != self._target_python.py_version:
+                return (
+                    LinkType.platform_mismatch,
+                    "Python version is incorrect",
+                )
+
+        supports_python = _check_link_requires_python(
+            link,
+            version_info=self._target_python.py_version_info,
+            ignore_requires_python=self._ignore_requires_python,
+        )
+        if not supports_python:
+            reason = f"{version} Requires-Python {link.requires_python}"
+            return (LinkType.requires_python_mismatch, reason)
+
+        logger.debug("Found link %s, version: %s", link, version)
+
+        return (LinkType.candidate, version)
+
+
+def filter_unallowed_hashes(
+    candidates: List[InstallationCandidate],
+    hashes: Optional[Hashes],
+    project_name: str,
+) -> List[InstallationCandidate]:
+    """
+    Filter out candidates whose hashes aren't allowed, and return a new
+    list of candidates.
+
+    If at least one candidate has an allowed hash, then all candidates with
+    either an allowed hash or no hash specified are returned.  Otherwise,
+    the given candidates are returned.
+
+    Including the candidates with no hash specified when there is a match
+    allows a warning to be logged if there is a more preferred candidate
+    with no hash specified.  Returning all candidates in the case of no
+    matches lets pip report the hash of the candidate that would otherwise
+    have been installed (e.g. permitting the user to more easily update
+    their requirements file with the desired hash).
+    """
+    if not hashes:
+        logger.debug(
+            "Given no hashes to check %s links for project %r: "
+            "discarding no candidates",
+            len(candidates),
+            project_name,
+        )
+        # Make sure we're not returning back the given value.
+        return list(candidates)
+
+    matches_or_no_digest = []
+    # Collect the non-matches for logging purposes.
+    non_matches = []
+    match_count = 0
+    for candidate in candidates:
+        link = candidate.link
+        if not link.has_hash:
+            pass
+        elif link.is_hash_allowed(hashes=hashes):
+            match_count += 1
+        else:
+            non_matches.append(candidate)
+            continue
+
+        matches_or_no_digest.append(candidate)
+
+    if match_count:
+        filtered = matches_or_no_digest
+    else:
+        # Make sure we're not returning back the given value.
+        filtered = list(candidates)
+
+    if len(filtered) == len(candidates):
+        discard_message = "discarding no candidates"
+    else:
+        discard_message = "discarding {} non-matches:\n  {}".format(
+            len(non_matches),
+            "\n  ".join(str(candidate.link) for candidate in non_matches),
+        )
+
+    logger.debug(
+        "Checked %s links for project %r against %s hashes "
+        "(%s matches, %s no digest): %s",
+        len(candidates),
+        project_name,
+        hashes.digest_count,
+        match_count,
+        len(matches_or_no_digest) - match_count,
+        discard_message,
+    )
+
+    return filtered
+
+
+@dataclass
+class CandidatePreferences:
+    """
+    Encapsulates some of the preferences for filtering and sorting
+    InstallationCandidate objects.
+    """
+
+    prefer_binary: bool = False
+    allow_all_prereleases: bool = False
+
+
+class BestCandidateResult:
+    """A collection of candidates, returned by `PackageFinder.find_best_candidate`.
+
+    This class is only intended to be instantiated by CandidateEvaluator's
+    `compute_best_candidate()` method.
+    """
+
+    def __init__(
+        self,
+        candidates: List[InstallationCandidate],
+        applicable_candidates: List[InstallationCandidate],
+        best_candidate: Optional[InstallationCandidate],
+    ) -> None:
+        """
+        :param candidates: A sequence of all available candidates found.
+        :param applicable_candidates: The applicable candidates.
+        :param best_candidate: The most preferred candidate found, or None
+            if no applicable candidates were found.
+        """
+        assert set(applicable_candidates) <= set(candidates)
+
+        if best_candidate is None:
+            assert not applicable_candidates
+        else:
+            assert best_candidate in applicable_candidates
+
+        self._applicable_candidates = applicable_candidates
+        self._candidates = candidates
+
+        self.best_candidate = best_candidate
+
+    def iter_all(self) -> Iterable[InstallationCandidate]:
+        """Iterate through all candidates."""
+        return iter(self._candidates)
+
+    def iter_applicable(self) -> Iterable[InstallationCandidate]:
+        """Iterate through the applicable candidates."""
+        return iter(self._applicable_candidates)
+
+
+class CandidateEvaluator:
+    """
+    Responsible for filtering and sorting candidates for installation based
+    on what tags are valid.
+    """
+
+    @classmethod
+    def create(
+        cls,
+        project_name: str,
+        target_python: Optional[TargetPython] = None,
+        prefer_binary: bool = False,
+        allow_all_prereleases: bool = False,
+        specifier: Optional[specifiers.BaseSpecifier] = None,
+        hashes: Optional[Hashes] = None,
+    ) -> "CandidateEvaluator":
+        """Create a CandidateEvaluator object.
+
+        :param target_python: The target Python interpreter to use when
+            checking compatibility. If None (the default), a TargetPython
+            object will be constructed from the running Python.
+        :param specifier: An optional object implementing `filter`
+            (e.g. `packaging.specifiers.SpecifierSet`) to filter applicable
+            versions.
+        :param hashes: An optional collection of allowed hashes.
+        """
+        if target_python is None:
+            target_python = TargetPython()
+        if specifier is None:
+            specifier = specifiers.SpecifierSet()
+
+        supported_tags = target_python.get_sorted_tags()
+
+        return cls(
+            project_name=project_name,
+            supported_tags=supported_tags,
+            specifier=specifier,
+            prefer_binary=prefer_binary,
+            allow_all_prereleases=allow_all_prereleases,
+            hashes=hashes,
+        )
+
+    def __init__(
+        self,
+        project_name: str,
+        supported_tags: List[Tag],
+        specifier: specifiers.BaseSpecifier,
+        prefer_binary: bool = False,
+        allow_all_prereleases: bool = False,
+        hashes: Optional[Hashes] = None,
+    ) -> None:
+        """
+        :param supported_tags: The PEP 425 tags supported by the target
+            Python in order of preference (most preferred first).
+        """
+        self._allow_all_prereleases = allow_all_prereleases
+        self._hashes = hashes
+        self._prefer_binary = prefer_binary
+        self._project_name = project_name
+        self._specifier = specifier
+        self._supported_tags = supported_tags
+        # Since the index of the tag in the _supported_tags list is used
+        # as a priority, precompute a map from tag to index/priority to be
+        # used in wheel.find_most_preferred_tag.
+        self._wheel_tag_preferences = {
+            tag: idx for idx, tag in enumerate(supported_tags)
+        }
+
+    def get_applicable_candidates(
+        self,
+        candidates: List[InstallationCandidate],
+    ) -> List[InstallationCandidate]:
+        """
+        Return the applicable candidates from a list of candidates.
+        """
+        # Using None infers from the specifier instead.
+        allow_prereleases = self._allow_all_prereleases or None
+        specifier = self._specifier
+
+        # We turn the version object into a str here because otherwise
+        # when we're debundled but setuptools isn't, Python will see
+        # packaging.version.Version and
+        # pkg_resources._vendor.packaging.version.Version as different
+        # types. This way we'll use a str as a common data interchange
+        # format. If we stop using the pkg_resources provided specifier
+        # and start using our own, we can drop the cast to str().
+        candidates_and_versions = [(c, str(c.version)) for c in candidates]
+        versions = set(
+            specifier.filter(
+                (v for _, v in candidates_and_versions),
+                prereleases=allow_prereleases,
+            )
+        )
+
+        applicable_candidates = [c for c, v in candidates_and_versions if v in versions]
+        filtered_applicable_candidates = filter_unallowed_hashes(
+            candidates=applicable_candidates,
+            hashes=self._hashes,
+            project_name=self._project_name,
+        )
+
+        return sorted(filtered_applicable_candidates, key=self._sort_key)
+
+    def _sort_key(self, candidate: InstallationCandidate) -> CandidateSortingKey:
+        """
+        Function to pass as the `key` argument to a call to sorted() to sort
+        InstallationCandidates by preference.
+
+        Returns a tuple such that tuples sorting as greater using Python's
+        default comparison operator are more preferred.
+
+        The preference is as follows:
+
+        First and foremost, candidates with allowed (matching) hashes are
+        always preferred over candidates without matching hashes. This is
+        because e.g. if the only candidate with an allowed hash is yanked,
+        we still want to use that candidate.
+
+        Second, excepting hash considerations, candidates that have been
+        yanked (in the sense of PEP 592) are always less preferred than
+        candidates that haven't been yanked. Then:
+
+        If not finding wheels, they are sorted by version only.
+        If finding wheels, then the sort order is by version, then:
+          1. existing installs
+          2. wheels ordered via Wheel.support_index_min(self._supported_tags)
+          3. source archives
+        If prefer_binary was set, then all wheels are sorted above sources.
+
+        Note: it was considered to embed this logic into the Link
+              comparison operators, but then different sdist links
+              with the same version, would have to be considered equal
+        """
+        valid_tags = self._supported_tags
+        support_num = len(valid_tags)
+        build_tag: BuildTag = ()
+        binary_preference = 0
+        link = candidate.link
+        if link.is_wheel:
+            # can raise InvalidWheelFilename
+            wheel = Wheel(link.filename)
+            try:
+                pri = -(
+                    wheel.find_most_preferred_tag(
+                        valid_tags, self._wheel_tag_preferences
+                    )
+                )
+            except ValueError:
+                raise UnsupportedWheel(
+                    f"{wheel.filename} is not a supported wheel for this platform. It "
+                    "can't be sorted."
+                )
+            if self._prefer_binary:
+                binary_preference = 1
+            if wheel.build_tag is not None:
+                match = re.match(r"^(\d+)(.*)$", wheel.build_tag)
+                assert match is not None, "guaranteed by filename validation"
+                build_tag_groups = match.groups()
+                build_tag = (int(build_tag_groups[0]), build_tag_groups[1])
+        else:  # sdist
+            pri = -(support_num)
+        has_allowed_hash = int(link.is_hash_allowed(self._hashes))
+        yank_value = -1 * int(link.is_yanked)  # -1 for yanked.
+        return (
+            has_allowed_hash,
+            yank_value,
+            binary_preference,
+            candidate.version,
+            pri,
+            build_tag,
+        )
+
+    def sort_best_candidate(
+        self,
+        candidates: List[InstallationCandidate],
+    ) -> Optional[InstallationCandidate]:
+        """
+        Return the best candidate per the instance's sort order, or None if
+        no candidate is acceptable.
+        """
+        if not candidates:
+            return None
+        best_candidate = max(candidates, key=self._sort_key)
+        return best_candidate
+
+    def compute_best_candidate(
+        self,
+        candidates: List[InstallationCandidate],
+    ) -> BestCandidateResult:
+        """
+        Compute and return a `BestCandidateResult` instance.
+        """
+        applicable_candidates = self.get_applicable_candidates(candidates)
+
+        best_candidate = self.sort_best_candidate(applicable_candidates)
+
+        return BestCandidateResult(
+            candidates,
+            applicable_candidates=applicable_candidates,
+            best_candidate=best_candidate,
+        )
+
+
+class PackageFinder:
+    """This finds packages.
+
+    This is meant to match easy_install's technique for looking for
+    packages, by reading pages and looking for appropriate links.
+    """
+
+    def __init__(
+        self,
+        link_collector: LinkCollector,
+        target_python: TargetPython,
+        allow_yanked: bool,
+        format_control: Optional[FormatControl] = None,
+        candidate_prefs: Optional[CandidatePreferences] = None,
+        ignore_requires_python: Optional[bool] = None,
+    ) -> None:
+        """
+        This constructor is primarily meant to be used by the create() class
+        method and from tests.
+
+        :param format_control: A FormatControl object, used to control
+            the selection of source packages / binary packages when consulting
+            the index and links.
+        :param candidate_prefs: Options to use when creating a
+            CandidateEvaluator object.
+        """
+        if candidate_prefs is None:
+            candidate_prefs = CandidatePreferences()
+
+        format_control = format_control or FormatControl(set(), set())
+
+        self._allow_yanked = allow_yanked
+        self._candidate_prefs = candidate_prefs
+        self._ignore_requires_python = ignore_requires_python
+        self._link_collector = link_collector
+        self._target_python = target_python
+
+        self.format_control = format_control
+
+        # These are boring links that have already been logged somehow.
+        self._logged_links: Set[Tuple[Link, LinkType, str]] = set()
+
+    # Don't include an allow_yanked default value to make sure each call
+    # site considers whether yanked releases are allowed. This also causes
+    # that decision to be made explicit in the calling code, which helps
+    # people when reading the code.
+    @classmethod
+    def create(
+        cls,
+        link_collector: LinkCollector,
+        selection_prefs: SelectionPreferences,
+        target_python: Optional[TargetPython] = None,
+    ) -> "PackageFinder":
+        """Create a PackageFinder.
+
+        :param selection_prefs: The candidate selection preferences, as a
+            SelectionPreferences object.
+        :param target_python: The target Python interpreter to use when
+            checking compatibility. If None (the default), a TargetPython
+            object will be constructed from the running Python.
+        """
+        if target_python is None:
+            target_python = TargetPython()
+
+        candidate_prefs = CandidatePreferences(
+            prefer_binary=selection_prefs.prefer_binary,
+            allow_all_prereleases=selection_prefs.allow_all_prereleases,
+        )
+
+        return cls(
+            candidate_prefs=candidate_prefs,
+            link_collector=link_collector,
+            target_python=target_python,
+            allow_yanked=selection_prefs.allow_yanked,
+            format_control=selection_prefs.format_control,
+            ignore_requires_python=selection_prefs.ignore_requires_python,
+        )
+
+    @property
+    def target_python(self) -> TargetPython:
+        return self._target_python
+
+    @property
+    def search_scope(self) -> SearchScope:
+        return self._link_collector.search_scope
+
+    @search_scope.setter
+    def search_scope(self, search_scope: SearchScope) -> None:
+        self._link_collector.search_scope = search_scope
+
+    @property
+    def find_links(self) -> List[str]:
+        return self._link_collector.find_links
+
+    @property
+    def index_urls(self) -> List[str]:
+        return self.search_scope.index_urls
+
+    @property
+    def trusted_hosts(self) -> Iterable[str]:
+        for host_port in self._link_collector.session.pip_trusted_origins:
+            yield build_netloc(*host_port)
+
+    @property
+    def allow_all_prereleases(self) -> bool:
+        return self._candidate_prefs.allow_all_prereleases
+
+    def set_allow_all_prereleases(self) -> None:
+        self._candidate_prefs.allow_all_prereleases = True
+
+    @property
+    def prefer_binary(self) -> bool:
+        return self._candidate_prefs.prefer_binary
+
+    def set_prefer_binary(self) -> None:
+        self._candidate_prefs.prefer_binary = True
+
+    def requires_python_skipped_reasons(self) -> List[str]:
+        reasons = {
+            detail
+            for _, result, detail in self._logged_links
+            if result == LinkType.requires_python_mismatch
+        }
+        return sorted(reasons)
+
+    def make_link_evaluator(self, project_name: str) -> LinkEvaluator:
+        canonical_name = canonicalize_name(project_name)
+        formats = self.format_control.get_allowed_formats(canonical_name)
+
+        return LinkEvaluator(
+            project_name=project_name,
+            canonical_name=canonical_name,
+            formats=formats,
+            target_python=self._target_python,
+            allow_yanked=self._allow_yanked,
+            ignore_requires_python=self._ignore_requires_python,
+        )
+
+    def _sort_links(self, links: Iterable[Link]) -> List[Link]:
+        """
+        Returns elements of links in order, non-egg links first, egg links
+        second, while eliminating duplicates
+        """
+        eggs, no_eggs = [], []
+        seen: Set[Link] = set()
+        for link in links:
+            if link not in seen:
+                seen.add(link)
+                if link.egg_fragment:
+                    eggs.append(link)
+                else:
+                    no_eggs.append(link)
+        return no_eggs + eggs
+
+    def _log_skipped_link(self, link: Link, result: LinkType, detail: str) -> None:
+        entry = (link, result, detail)
+        if entry not in self._logged_links:
+            # Put the link at the end so the reason is more visible and because
+            # the link string is usually very long.
+            logger.debug("Skipping link: %s: %s", detail, link)
+            self._logged_links.add(entry)
+
+    def get_install_candidate(
+        self, link_evaluator: LinkEvaluator, link: Link
+    ) -> Optional[InstallationCandidate]:
+        """
+        If the link is a candidate for install, convert it to an
+        InstallationCandidate and return it. Otherwise, return None.
+        """
+        result, detail = link_evaluator.evaluate_link(link)
+        if result != LinkType.candidate:
+            self._log_skipped_link(link, result, detail)
+            return None
+
+        try:
+            return InstallationCandidate(
+                name=link_evaluator.project_name,
+                link=link,
+                version=detail,
+            )
+        except InvalidVersion:
+            return None
+
+    def evaluate_links(
+        self, link_evaluator: LinkEvaluator, links: Iterable[Link]
+    ) -> List[InstallationCandidate]:
+        """
+        Convert links that are candidates to InstallationCandidate objects.
+        """
+        candidates = []
+        for link in self._sort_links(links):
+            candidate = self.get_install_candidate(link_evaluator, link)
+            if candidate is not None:
+                candidates.append(candidate)
+
+        return candidates
+
+    def process_project_url(
+        self, project_url: Link, link_evaluator: LinkEvaluator
+    ) -> List[InstallationCandidate]:
+        logger.debug(
+            "Fetching project page and analyzing links: %s",
+            project_url,
+        )
+        index_response = self._link_collector.fetch_response(project_url)
+        if index_response is None:
+            return []
+
+        page_links = list(parse_links(index_response))
+
+        with indent_log():
+            package_links = self.evaluate_links(
+                link_evaluator,
+                links=page_links,
+            )
+
+        return package_links
+
+    @functools.lru_cache(maxsize=None)
+    def find_all_candidates(self, project_name: str) -> List[InstallationCandidate]:
+        """Find all available InstallationCandidate for project_name
+
+        This checks index_urls and find_links.
+        All versions found are returned as an InstallationCandidate list.
+
+        See LinkEvaluator.evaluate_link() for details on which files
+        are accepted.
+        """
+        link_evaluator = self.make_link_evaluator(project_name)
+
+        collected_sources = self._link_collector.collect_sources(
+            project_name=project_name,
+            candidates_from_page=functools.partial(
+                self.process_project_url,
+                link_evaluator=link_evaluator,
+            ),
+        )
+
+        page_candidates_it = itertools.chain.from_iterable(
+            source.page_candidates()
+            for sources in collected_sources
+            for source in sources
+            if source is not None
+        )
+        page_candidates = list(page_candidates_it)
+
+        file_links_it = itertools.chain.from_iterable(
+            source.file_links()
+            for sources in collected_sources
+            for source in sources
+            if source is not None
+        )
+        file_candidates = self.evaluate_links(
+            link_evaluator,
+            sorted(file_links_it, reverse=True),
+        )
+
+        if logger.isEnabledFor(logging.DEBUG) and file_candidates:
+            paths = []
+            for candidate in file_candidates:
+                assert candidate.link.url  # we need to have a URL
+                try:
+                    paths.append(candidate.link.file_path)
+                except Exception:
+                    paths.append(candidate.link.url)  # it's not a local file
+
+            logger.debug("Local files found: %s", ", ".join(paths))
+
+        # This is an intentional priority ordering
+        return file_candidates + page_candidates
+
+    def make_candidate_evaluator(
+        self,
+        project_name: str,
+        specifier: Optional[specifiers.BaseSpecifier] = None,
+        hashes: Optional[Hashes] = None,
+    ) -> CandidateEvaluator:
+        """Create a CandidateEvaluator object to use."""
+        candidate_prefs = self._candidate_prefs
+        return CandidateEvaluator.create(
+            project_name=project_name,
+            target_python=self._target_python,
+            prefer_binary=candidate_prefs.prefer_binary,
+            allow_all_prereleases=candidate_prefs.allow_all_prereleases,
+            specifier=specifier,
+            hashes=hashes,
+        )
+
+    @functools.lru_cache(maxsize=None)
+    def find_best_candidate(
+        self,
+        project_name: str,
+        specifier: Optional[specifiers.BaseSpecifier] = None,
+        hashes: Optional[Hashes] = None,
+    ) -> BestCandidateResult:
+        """Find matches for the given project and specifier.
+
+        :param specifier: An optional object implementing `filter`
+            (e.g. `packaging.specifiers.SpecifierSet`) to filter applicable
+            versions.
+
+        :return: A `BestCandidateResult` instance.
+        """
+        candidates = self.find_all_candidates(project_name)
+        candidate_evaluator = self.make_candidate_evaluator(
+            project_name=project_name,
+            specifier=specifier,
+            hashes=hashes,
+        )
+        return candidate_evaluator.compute_best_candidate(candidates)
+
+    def find_requirement(
+        self, req: InstallRequirement, upgrade: bool
+    ) -> Optional[InstallationCandidate]:
+        """Try to find a Link matching req
+
+        Expects req, an InstallRequirement and upgrade, a boolean
+        Returns a InstallationCandidate if found,
+        Raises DistributionNotFound or BestVersionAlreadyInstalled otherwise
+        """
+        hashes = req.hashes(trust_internet=False)
+        best_candidate_result = self.find_best_candidate(
+            req.name,
+            specifier=req.specifier,
+            hashes=hashes,
+        )
+        best_candidate = best_candidate_result.best_candidate
+
+        installed_version: Optional[_BaseVersion] = None
+        if req.satisfied_by is not None:
+            installed_version = req.satisfied_by.version
+
+        def _format_versions(cand_iter: Iterable[InstallationCandidate]) -> str:
+            # This repeated parse_version and str() conversion is needed to
+            # handle different vendoring sources from pip and pkg_resources.
+            # If we stop using the pkg_resources provided specifier and start
+            # using our own, we can drop the cast to str().
+            return (
+                ", ".join(
+                    sorted(
+                        {str(c.version) for c in cand_iter},
+                        key=parse_version,
+                    )
+                )
+                or "none"
+            )
+
+        if installed_version is None and best_candidate is None:
+            logger.critical(
+                "Could not find a version that satisfies the requirement %s "
+                "(from versions: %s)",
+                req,
+                _format_versions(best_candidate_result.iter_all()),
+            )
+
+            raise DistributionNotFound(f"No matching distribution found for {req}")
+
+        def _should_install_candidate(
+            candidate: Optional[InstallationCandidate],
+        ) -> "TypeGuard[InstallationCandidate]":
+            if installed_version is None:
+                return True
+            if best_candidate is None:
+                return False
+            return best_candidate.version > installed_version
+
+        if not upgrade and installed_version is not None:
+            if _should_install_candidate(best_candidate):
+                logger.debug(
+                    "Existing installed version (%s) satisfies requirement "
+                    "(most up-to-date version is %s)",
+                    installed_version,
+                    best_candidate.version,
+                )
+            else:
+                logger.debug(
+                    "Existing installed version (%s) is most up-to-date and "
+                    "satisfies requirement",
+                    installed_version,
+                )
+            return None
+
+        if _should_install_candidate(best_candidate):
+            logger.debug(
+                "Using version %s (newest of versions: %s)",
+                best_candidate.version,
+                _format_versions(best_candidate_result.iter_applicable()),
+            )
+            return best_candidate
+
+        # We have an existing version, and its the best version
+        logger.debug(
+            "Installed version (%s) is most up-to-date (past versions: %s)",
+            installed_version,
+            _format_versions(best_candidate_result.iter_applicable()),
+        )
+        raise BestVersionAlreadyInstalled
+
+
+def _find_name_version_sep(fragment: str, canonical_name: str) -> int:
+    """Find the separator's index based on the package's canonical name.
+
+    :param fragment: A + filename "fragment" (stem) or
+        egg fragment.
+    :param canonical_name: The package's canonical name.
+
+    This function is needed since the canonicalized name does not necessarily
+    have the same length as the egg info's name part. An example::
+
+    >>> fragment = 'foo__bar-1.0'
+    >>> canonical_name = 'foo-bar'
+    >>> _find_name_version_sep(fragment, canonical_name)
+    8
+    """
+    # Project name and version must be separated by one single dash. Find all
+    # occurrences of dashes; if the string in front of it matches the canonical
+    # name, this is the one separating the name and version parts.
+    for i, c in enumerate(fragment):
+        if c != "-":
+            continue
+        if canonicalize_name(fragment[:i]) == canonical_name:
+            return i
+    raise ValueError(f"{fragment} does not match {canonical_name}")
+
+
+def _extract_version_from_fragment(fragment: str, canonical_name: str) -> Optional[str]:
+    """Parse the version string from a + filename
+    "fragment" (stem) or egg fragment.
+
+    :param fragment: The string to parse. E.g. foo-2.1
+    :param canonical_name: The canonicalized name of the package this
+        belongs to.
+    """
+    try:
+        version_start = _find_name_version_sep(fragment, canonical_name) + 1
+    except ValueError:
+        return None
+    version = fragment[version_start:]
+    if not version:
+        return None
+    return version
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/index/sources.py b/venv/lib/python3.12/site-packages/pip/_internal/index/sources.py
new file mode 100644
index 00000000..f4626d71
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/index/sources.py
@@ -0,0 +1,285 @@
+import logging
+import mimetypes
+import os
+from collections import defaultdict
+from typing import Callable, Dict, Iterable, List, Optional, Tuple
+
+from pip._vendor.packaging.utils import (
+    InvalidSdistFilename,
+    InvalidVersion,
+    InvalidWheelFilename,
+    canonicalize_name,
+    parse_sdist_filename,
+    parse_wheel_filename,
+)
+
+from pip._internal.models.candidate import InstallationCandidate
+from pip._internal.models.link import Link
+from pip._internal.utils.urls import path_to_url, url_to_path
+from pip._internal.vcs import is_url
+
+logger = logging.getLogger(__name__)
+
+FoundCandidates = Iterable[InstallationCandidate]
+FoundLinks = Iterable[Link]
+CandidatesFromPage = Callable[[Link], Iterable[InstallationCandidate]]
+PageValidator = Callable[[Link], bool]
+
+
+class LinkSource:
+    @property
+    def link(self) -> Optional[Link]:
+        """Returns the underlying link, if there's one."""
+        raise NotImplementedError()
+
+    def page_candidates(self) -> FoundCandidates:
+        """Candidates found by parsing an archive listing HTML file."""
+        raise NotImplementedError()
+
+    def file_links(self) -> FoundLinks:
+        """Links found by specifying archives directly."""
+        raise NotImplementedError()
+
+
+def _is_html_file(file_url: str) -> bool:
+    return mimetypes.guess_type(file_url, strict=False)[0] == "text/html"
+
+
+class _FlatDirectoryToUrls:
+    """Scans directory and caches results"""
+
+    def __init__(self, path: str) -> None:
+        self._path = path
+        self._page_candidates: List[str] = []
+        self._project_name_to_urls: Dict[str, List[str]] = defaultdict(list)
+        self._scanned_directory = False
+
+    def _scan_directory(self) -> None:
+        """Scans directory once and populates both page_candidates
+        and project_name_to_urls at the same time
+        """
+        for entry in os.scandir(self._path):
+            url = path_to_url(entry.path)
+            if _is_html_file(url):
+                self._page_candidates.append(url)
+                continue
+
+            # File must have a valid wheel or sdist name,
+            # otherwise not worth considering as a package
+            try:
+                project_filename = parse_wheel_filename(entry.name)[0]
+            except (InvalidWheelFilename, InvalidVersion):
+                try:
+                    project_filename = parse_sdist_filename(entry.name)[0]
+                except (InvalidSdistFilename, InvalidVersion):
+                    continue
+
+            self._project_name_to_urls[project_filename].append(url)
+        self._scanned_directory = True
+
+    @property
+    def page_candidates(self) -> List[str]:
+        if not self._scanned_directory:
+            self._scan_directory()
+
+        return self._page_candidates
+
+    @property
+    def project_name_to_urls(self) -> Dict[str, List[str]]:
+        if not self._scanned_directory:
+            self._scan_directory()
+
+        return self._project_name_to_urls
+
+
+class _FlatDirectorySource(LinkSource):
+    """Link source specified by ``--find-links=``.
+
+    This looks the content of the directory, and returns:
+
+    * ``page_candidates``: Links listed on each HTML file in the directory.
+    * ``file_candidates``: Archives in the directory.
+    """
+
+    _paths_to_urls: Dict[str, _FlatDirectoryToUrls] = {}
+
+    def __init__(
+        self,
+        candidates_from_page: CandidatesFromPage,
+        path: str,
+        project_name: str,
+    ) -> None:
+        self._candidates_from_page = candidates_from_page
+        self._project_name = canonicalize_name(project_name)
+
+        # Get existing instance of _FlatDirectoryToUrls if it exists
+        if path in self._paths_to_urls:
+            self._path_to_urls = self._paths_to_urls[path]
+        else:
+            self._path_to_urls = _FlatDirectoryToUrls(path=path)
+            self._paths_to_urls[path] = self._path_to_urls
+
+    @property
+    def link(self) -> Optional[Link]:
+        return None
+
+    def page_candidates(self) -> FoundCandidates:
+        for url in self._path_to_urls.page_candidates:
+            yield from self._candidates_from_page(Link(url))
+
+    def file_links(self) -> FoundLinks:
+        for url in self._path_to_urls.project_name_to_urls[self._project_name]:
+            yield Link(url)
+
+
+class _LocalFileSource(LinkSource):
+    """``--find-links=`` or ``--[extra-]index-url=``.
+
+    If a URL is supplied, it must be a ``file:`` URL. If a path is supplied to
+    the option, it is converted to a URL first. This returns:
+
+    * ``page_candidates``: Links listed on an HTML file.
+    * ``file_candidates``: The non-HTML file.
+    """
+
+    def __init__(
+        self,
+        candidates_from_page: CandidatesFromPage,
+        link: Link,
+    ) -> None:
+        self._candidates_from_page = candidates_from_page
+        self._link = link
+
+    @property
+    def link(self) -> Optional[Link]:
+        return self._link
+
+    def page_candidates(self) -> FoundCandidates:
+        if not _is_html_file(self._link.url):
+            return
+        yield from self._candidates_from_page(self._link)
+
+    def file_links(self) -> FoundLinks:
+        if _is_html_file(self._link.url):
+            return
+        yield self._link
+
+
+class _RemoteFileSource(LinkSource):
+    """``--find-links=`` or ``--[extra-]index-url=``.
+
+    This returns:
+
+    * ``page_candidates``: Links listed on an HTML file.
+    * ``file_candidates``: The non-HTML file.
+    """
+
+    def __init__(
+        self,
+        candidates_from_page: CandidatesFromPage,
+        page_validator: PageValidator,
+        link: Link,
+    ) -> None:
+        self._candidates_from_page = candidates_from_page
+        self._page_validator = page_validator
+        self._link = link
+
+    @property
+    def link(self) -> Optional[Link]:
+        return self._link
+
+    def page_candidates(self) -> FoundCandidates:
+        if not self._page_validator(self._link):
+            return
+        yield from self._candidates_from_page(self._link)
+
+    def file_links(self) -> FoundLinks:
+        yield self._link
+
+
+class _IndexDirectorySource(LinkSource):
+    """``--[extra-]index-url=``.
+
+    This is treated like a remote URL; ``candidates_from_page`` contains logic
+    for this by appending ``index.html`` to the link.
+    """
+
+    def __init__(
+        self,
+        candidates_from_page: CandidatesFromPage,
+        link: Link,
+    ) -> None:
+        self._candidates_from_page = candidates_from_page
+        self._link = link
+
+    @property
+    def link(self) -> Optional[Link]:
+        return self._link
+
+    def page_candidates(self) -> FoundCandidates:
+        yield from self._candidates_from_page(self._link)
+
+    def file_links(self) -> FoundLinks:
+        return ()
+
+
+def build_source(
+    location: str,
+    *,
+    candidates_from_page: CandidatesFromPage,
+    page_validator: PageValidator,
+    expand_dir: bool,
+    cache_link_parsing: bool,
+    project_name: str,
+) -> Tuple[Optional[str], Optional[LinkSource]]:
+    path: Optional[str] = None
+    url: Optional[str] = None
+    if os.path.exists(location):  # Is a local path.
+        url = path_to_url(location)
+        path = location
+    elif location.startswith("file:"):  # A file: URL.
+        url = location
+        path = url_to_path(location)
+    elif is_url(location):
+        url = location
+
+    if url is None:
+        msg = (
+            "Location '%s' is ignored: "
+            "it is either a non-existing path or lacks a specific scheme."
+        )
+        logger.warning(msg, location)
+        return (None, None)
+
+    if path is None:
+        source: LinkSource = _RemoteFileSource(
+            candidates_from_page=candidates_from_page,
+            page_validator=page_validator,
+            link=Link(url, cache_link_parsing=cache_link_parsing),
+        )
+        return (url, source)
+
+    if os.path.isdir(path):
+        if expand_dir:
+            source = _FlatDirectorySource(
+                candidates_from_page=candidates_from_page,
+                path=path,
+                project_name=project_name,
+            )
+        else:
+            source = _IndexDirectorySource(
+                candidates_from_page=candidates_from_page,
+                link=Link(url, cache_link_parsing=cache_link_parsing),
+            )
+        return (url, source)
+    elif os.path.isfile(path):
+        source = _LocalFileSource(
+            candidates_from_page=candidates_from_page,
+            link=Link(url, cache_link_parsing=cache_link_parsing),
+        )
+        return (url, source)
+    logger.warning(
+        "Location '%s' is ignored: it is neither a file nor a directory.",
+        location,
+    )
+    return (url, None)
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/locations/__init__.py b/venv/lib/python3.12/site-packages/pip/_internal/locations/__init__.py
new file mode 100644
index 00000000..32382be7
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/locations/__init__.py
@@ -0,0 +1,456 @@
+import functools
+import logging
+import os
+import pathlib
+import sys
+import sysconfig
+from typing import Any, Dict, Generator, Optional, Tuple
+
+from pip._internal.models.scheme import SCHEME_KEYS, Scheme
+from pip._internal.utils.compat import WINDOWS
+from pip._internal.utils.deprecation import deprecated
+from pip._internal.utils.virtualenv import running_under_virtualenv
+
+from . import _sysconfig
+from .base import (
+    USER_CACHE_DIR,
+    get_major_minor_version,
+    get_src_prefix,
+    is_osx_framework,
+    site_packages,
+    user_site,
+)
+
+__all__ = [
+    "USER_CACHE_DIR",
+    "get_bin_prefix",
+    "get_bin_user",
+    "get_major_minor_version",
+    "get_platlib",
+    "get_purelib",
+    "get_scheme",
+    "get_src_prefix",
+    "site_packages",
+    "user_site",
+]
+
+
+logger = logging.getLogger(__name__)
+
+
+_PLATLIBDIR: str = getattr(sys, "platlibdir", "lib")
+
+_USE_SYSCONFIG_DEFAULT = sys.version_info >= (3, 10)
+
+
+def _should_use_sysconfig() -> bool:
+    """This function determines the value of _USE_SYSCONFIG.
+
+    By default, pip uses sysconfig on Python 3.10+.
+    But Python distributors can override this decision by setting:
+        sysconfig._PIP_USE_SYSCONFIG = True / False
+    Rationale in https://github.com/pypa/pip/issues/10647
+
+    This is a function for testability, but should be constant during any one
+    run.
+    """
+    return bool(getattr(sysconfig, "_PIP_USE_SYSCONFIG", _USE_SYSCONFIG_DEFAULT))
+
+
+_USE_SYSCONFIG = _should_use_sysconfig()
+
+if not _USE_SYSCONFIG:
+    # Import distutils lazily to avoid deprecation warnings,
+    # but import it soon enough that it is in memory and available during
+    # a pip reinstall.
+    from . import _distutils
+
+# Be noisy about incompatibilities if this platforms "should" be using
+# sysconfig, but is explicitly opting out and using distutils instead.
+if _USE_SYSCONFIG_DEFAULT and not _USE_SYSCONFIG:
+    _MISMATCH_LEVEL = logging.WARNING
+else:
+    _MISMATCH_LEVEL = logging.DEBUG
+
+
+def _looks_like_bpo_44860() -> bool:
+    """The resolution to bpo-44860 will change this incorrect platlib.
+
+    See .
+    """
+    from distutils.command.install import INSTALL_SCHEMES
+
+    try:
+        unix_user_platlib = INSTALL_SCHEMES["unix_user"]["platlib"]
+    except KeyError:
+        return False
+    return unix_user_platlib == "$usersite"
+
+
+def _looks_like_red_hat_patched_platlib_purelib(scheme: Dict[str, str]) -> bool:
+    platlib = scheme["platlib"]
+    if "/$platlibdir/" in platlib:
+        platlib = platlib.replace("/$platlibdir/", f"/{_PLATLIBDIR}/")
+    if "/lib64/" not in platlib:
+        return False
+    unpatched = platlib.replace("/lib64/", "/lib/")
+    return unpatched.replace("$platbase/", "$base/") == scheme["purelib"]
+
+
+@functools.lru_cache(maxsize=None)
+def _looks_like_red_hat_lib() -> bool:
+    """Red Hat patches platlib in unix_prefix and unix_home, but not purelib.
+
+    This is the only way I can see to tell a Red Hat-patched Python.
+    """
+    from distutils.command.install import INSTALL_SCHEMES
+
+    return all(
+        k in INSTALL_SCHEMES
+        and _looks_like_red_hat_patched_platlib_purelib(INSTALL_SCHEMES[k])
+        for k in ("unix_prefix", "unix_home")
+    )
+
+
+@functools.lru_cache(maxsize=None)
+def _looks_like_debian_scheme() -> bool:
+    """Debian adds two additional schemes."""
+    from distutils.command.install import INSTALL_SCHEMES
+
+    return "deb_system" in INSTALL_SCHEMES and "unix_local" in INSTALL_SCHEMES
+
+
+@functools.lru_cache(maxsize=None)
+def _looks_like_red_hat_scheme() -> bool:
+    """Red Hat patches ``sys.prefix`` and ``sys.exec_prefix``.
+
+    Red Hat's ``00251-change-user-install-location.patch`` changes the install
+    command's ``prefix`` and ``exec_prefix`` to append ``"/local"``. This is
+    (fortunately?) done quite unconditionally, so we create a default command
+    object without any configuration to detect this.
+    """
+    from distutils.command.install import install
+    from distutils.dist import Distribution
+
+    cmd: Any = install(Distribution())
+    cmd.finalize_options()
+    return (
+        cmd.exec_prefix == f"{os.path.normpath(sys.exec_prefix)}/local"
+        and cmd.prefix == f"{os.path.normpath(sys.prefix)}/local"
+    )
+
+
+@functools.lru_cache(maxsize=None)
+def _looks_like_slackware_scheme() -> bool:
+    """Slackware patches sysconfig but fails to patch distutils and site.
+
+    Slackware changes sysconfig's user scheme to use ``"lib64"`` for the lib
+    path, but does not do the same to the site module.
+    """
+    if user_site is None:  # User-site not available.
+        return False
+    try:
+        paths = sysconfig.get_paths(scheme="posix_user", expand=False)
+    except KeyError:  # User-site not available.
+        return False
+    return "/lib64/" in paths["purelib"] and "/lib64/" not in user_site
+
+
+@functools.lru_cache(maxsize=None)
+def _looks_like_msys2_mingw_scheme() -> bool:
+    """MSYS2 patches distutils and sysconfig to use a UNIX-like scheme.
+
+    However, MSYS2 incorrectly patches sysconfig ``nt`` scheme. The fix is
+    likely going to be included in their 3.10 release, so we ignore the warning.
+    See msys2/MINGW-packages#9319.
+
+    MSYS2 MINGW's patch uses lowercase ``"lib"`` instead of the usual uppercase,
+    and is missing the final ``"site-packages"``.
+    """
+    paths = sysconfig.get_paths("nt", expand=False)
+    return all(
+        "Lib" not in p and "lib" in p and not p.endswith("site-packages")
+        for p in (paths[key] for key in ("platlib", "purelib"))
+    )
+
+
+def _fix_abiflags(parts: Tuple[str]) -> Generator[str, None, None]:
+    ldversion = sysconfig.get_config_var("LDVERSION")
+    abiflags = getattr(sys, "abiflags", None)
+
+    # LDVERSION does not end with sys.abiflags. Just return the path unchanged.
+    if not ldversion or not abiflags or not ldversion.endswith(abiflags):
+        yield from parts
+        return
+
+    # Strip sys.abiflags from LDVERSION-based path components.
+    for part in parts:
+        if part.endswith(ldversion):
+            part = part[: (0 - len(abiflags))]
+        yield part
+
+
+@functools.lru_cache(maxsize=None)
+def _warn_mismatched(old: pathlib.Path, new: pathlib.Path, *, key: str) -> None:
+    issue_url = "https://github.com/pypa/pip/issues/10151"
+    message = (
+        "Value for %s does not match. Please report this to <%s>"
+        "\ndistutils: %s"
+        "\nsysconfig: %s"
+    )
+    logger.log(_MISMATCH_LEVEL, message, key, issue_url, old, new)
+
+
+def _warn_if_mismatch(old: pathlib.Path, new: pathlib.Path, *, key: str) -> bool:
+    if old == new:
+        return False
+    _warn_mismatched(old, new, key=key)
+    return True
+
+
+@functools.lru_cache(maxsize=None)
+def _log_context(
+    *,
+    user: bool = False,
+    home: Optional[str] = None,
+    root: Optional[str] = None,
+    prefix: Optional[str] = None,
+) -> None:
+    parts = [
+        "Additional context:",
+        "user = %r",
+        "home = %r",
+        "root = %r",
+        "prefix = %r",
+    ]
+
+    logger.log(_MISMATCH_LEVEL, "\n".join(parts), user, home, root, prefix)
+
+
+def get_scheme(
+    dist_name: str,
+    user: bool = False,
+    home: Optional[str] = None,
+    root: Optional[str] = None,
+    isolated: bool = False,
+    prefix: Optional[str] = None,
+) -> Scheme:
+    new = _sysconfig.get_scheme(
+        dist_name,
+        user=user,
+        home=home,
+        root=root,
+        isolated=isolated,
+        prefix=prefix,
+    )
+    if _USE_SYSCONFIG:
+        return new
+
+    old = _distutils.get_scheme(
+        dist_name,
+        user=user,
+        home=home,
+        root=root,
+        isolated=isolated,
+        prefix=prefix,
+    )
+
+    warning_contexts = []
+    for k in SCHEME_KEYS:
+        old_v = pathlib.Path(getattr(old, k))
+        new_v = pathlib.Path(getattr(new, k))
+
+        if old_v == new_v:
+            continue
+
+        # distutils incorrectly put PyPy packages under ``site-packages/python``
+        # in the ``posix_home`` scheme, but PyPy devs said they expect the
+        # directory name to be ``pypy`` instead. So we treat this as a bug fix
+        # and not warn about it. See bpo-43307 and python/cpython#24628.
+        skip_pypy_special_case = (
+            sys.implementation.name == "pypy"
+            and home is not None
+            and k in ("platlib", "purelib")
+            and old_v.parent == new_v.parent
+            and old_v.name.startswith("python")
+            and new_v.name.startswith("pypy")
+        )
+        if skip_pypy_special_case:
+            continue
+
+        # sysconfig's ``osx_framework_user`` does not include ``pythonX.Y`` in
+        # the ``include`` value, but distutils's ``headers`` does. We'll let
+        # CPython decide whether this is a bug or feature. See bpo-43948.
+        skip_osx_framework_user_special_case = (
+            user
+            and is_osx_framework()
+            and k == "headers"
+            and old_v.parent.parent == new_v.parent
+            and old_v.parent.name.startswith("python")
+        )
+        if skip_osx_framework_user_special_case:
+            continue
+
+        # On Red Hat and derived Linux distributions, distutils is patched to
+        # use "lib64" instead of "lib" for platlib.
+        if k == "platlib" and _looks_like_red_hat_lib():
+            continue
+
+        # On Python 3.9+, sysconfig's posix_user scheme sets platlib against
+        # sys.platlibdir, but distutils's unix_user incorrectly coninutes
+        # using the same $usersite for both platlib and purelib. This creates a
+        # mismatch when sys.platlibdir is not "lib".
+        skip_bpo_44860 = (
+            user
+            and k == "platlib"
+            and not WINDOWS
+            and sys.version_info >= (3, 9)
+            and _PLATLIBDIR != "lib"
+            and _looks_like_bpo_44860()
+        )
+        if skip_bpo_44860:
+            continue
+
+        # Slackware incorrectly patches posix_user to use lib64 instead of lib,
+        # but not usersite to match the location.
+        skip_slackware_user_scheme = (
+            user
+            and k in ("platlib", "purelib")
+            and not WINDOWS
+            and _looks_like_slackware_scheme()
+        )
+        if skip_slackware_user_scheme:
+            continue
+
+        # Both Debian and Red Hat patch Python to place the system site under
+        # /usr/local instead of /usr. Debian also places lib in dist-packages
+        # instead of site-packages, but the /usr/local check should cover it.
+        skip_linux_system_special_case = (
+            not (user or home or prefix or running_under_virtualenv())
+            and old_v.parts[1:3] == ("usr", "local")
+            and len(new_v.parts) > 1
+            and new_v.parts[1] == "usr"
+            and (len(new_v.parts) < 3 or new_v.parts[2] != "local")
+            and (_looks_like_red_hat_scheme() or _looks_like_debian_scheme())
+        )
+        if skip_linux_system_special_case:
+            continue
+
+        # MSYS2 MINGW's sysconfig patch does not include the "site-packages"
+        # part of the path. This is incorrect and will be fixed in MSYS.
+        skip_msys2_mingw_bug = (
+            WINDOWS and k in ("platlib", "purelib") and _looks_like_msys2_mingw_scheme()
+        )
+        if skip_msys2_mingw_bug:
+            continue
+
+        # CPython's POSIX install script invokes pip (via ensurepip) against the
+        # interpreter located in the source tree, not the install site. This
+        # triggers special logic in sysconfig that's not present in distutils.
+        # https://github.com/python/cpython/blob/8c21941ddaf/Lib/sysconfig.py#L178-L194
+        skip_cpython_build = (
+            sysconfig.is_python_build(check_home=True)
+            and not WINDOWS
+            and k in ("headers", "include", "platinclude")
+        )
+        if skip_cpython_build:
+            continue
+
+        warning_contexts.append((old_v, new_v, f"scheme.{k}"))
+
+    if not warning_contexts:
+        return old
+
+    # Check if this path mismatch is caused by distutils config files. Those
+    # files will no longer work once we switch to sysconfig, so this raises a
+    # deprecation message for them.
+    default_old = _distutils.distutils_scheme(
+        dist_name,
+        user,
+        home,
+        root,
+        isolated,
+        prefix,
+        ignore_config_files=True,
+    )
+    if any(default_old[k] != getattr(old, k) for k in SCHEME_KEYS):
+        deprecated(
+            reason=(
+                "Configuring installation scheme with distutils config files "
+                "is deprecated and will no longer work in the near future. If you "
+                "are using a Homebrew or Linuxbrew Python, please see discussion "
+                "at https://github.com/Homebrew/homebrew-core/issues/76621"
+            ),
+            replacement=None,
+            gone_in=None,
+        )
+        return old
+
+    # Post warnings about this mismatch so user can report them back.
+    for old_v, new_v, key in warning_contexts:
+        _warn_mismatched(old_v, new_v, key=key)
+    _log_context(user=user, home=home, root=root, prefix=prefix)
+
+    return old
+
+
+def get_bin_prefix() -> str:
+    new = _sysconfig.get_bin_prefix()
+    if _USE_SYSCONFIG:
+        return new
+
+    old = _distutils.get_bin_prefix()
+    if _warn_if_mismatch(pathlib.Path(old), pathlib.Path(new), key="bin_prefix"):
+        _log_context()
+    return old
+
+
+def get_bin_user() -> str:
+    return _sysconfig.get_scheme("", user=True).scripts
+
+
+def _looks_like_deb_system_dist_packages(value: str) -> bool:
+    """Check if the value is Debian's APT-controlled dist-packages.
+
+    Debian's ``distutils.sysconfig.get_python_lib()`` implementation returns the
+    default package path controlled by APT, but does not patch ``sysconfig`` to
+    do the same. This is similar to the bug worked around in ``get_scheme()``,
+    but here the default is ``deb_system`` instead of ``unix_local``. Ultimately
+    we can't do anything about this Debian bug, and this detection allows us to
+    skip the warning when needed.
+    """
+    if not _looks_like_debian_scheme():
+        return False
+    if value == "/usr/lib/python3/dist-packages":
+        return True
+    return False
+
+
+def get_purelib() -> str:
+    """Return the default pure-Python lib location."""
+    new = _sysconfig.get_purelib()
+    if _USE_SYSCONFIG:
+        return new
+
+    old = _distutils.get_purelib()
+    if _looks_like_deb_system_dist_packages(old):
+        return old
+    if _warn_if_mismatch(pathlib.Path(old), pathlib.Path(new), key="purelib"):
+        _log_context()
+    return old
+
+
+def get_platlib() -> str:
+    """Return the default platform-shared lib location."""
+    new = _sysconfig.get_platlib()
+    if _USE_SYSCONFIG:
+        return new
+
+    from . import _distutils
+
+    old = _distutils.get_platlib()
+    if _looks_like_deb_system_dist_packages(old):
+        return old
+    if _warn_if_mismatch(pathlib.Path(old), pathlib.Path(new), key="platlib"):
+        _log_context()
+    return old
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/locations/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/locations/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 00000000..426628c0
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/locations/__pycache__/__init__.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/locations/__pycache__/_distutils.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/locations/__pycache__/_distutils.cpython-312.pyc
new file mode 100644
index 00000000..0d54da95
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/locations/__pycache__/_distutils.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/locations/__pycache__/_sysconfig.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/locations/__pycache__/_sysconfig.cpython-312.pyc
new file mode 100644
index 00000000..71910a18
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/locations/__pycache__/_sysconfig.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/locations/__pycache__/base.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/locations/__pycache__/base.cpython-312.pyc
new file mode 100644
index 00000000..6f88f5a8
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/locations/__pycache__/base.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/locations/_distutils.py b/venv/lib/python3.12/site-packages/pip/_internal/locations/_distutils.py
new file mode 100644
index 00000000..0e18c6e1
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/locations/_distutils.py
@@ -0,0 +1,172 @@
+"""Locations where we look for configs, install stuff, etc"""
+
+# The following comment should be removed at some point in the future.
+# mypy: strict-optional=False
+
+# If pip's going to use distutils, it should not be using the copy that setuptools
+# might have injected into the environment. This is done by removing the injected
+# shim, if it's injected.
+#
+# See https://github.com/pypa/pip/issues/8761 for the original discussion and
+# rationale for why this is done within pip.
+try:
+    __import__("_distutils_hack").remove_shim()
+except (ImportError, AttributeError):
+    pass
+
+import logging
+import os
+import sys
+from distutils.cmd import Command as DistutilsCommand
+from distutils.command.install import SCHEME_KEYS
+from distutils.command.install import install as distutils_install_command
+from distutils.sysconfig import get_python_lib
+from typing import Dict, List, Optional, Union, cast
+
+from pip._internal.models.scheme import Scheme
+from pip._internal.utils.compat import WINDOWS
+from pip._internal.utils.virtualenv import running_under_virtualenv
+
+from .base import get_major_minor_version
+
+logger = logging.getLogger(__name__)
+
+
+def distutils_scheme(
+    dist_name: str,
+    user: bool = False,
+    home: Optional[str] = None,
+    root: Optional[str] = None,
+    isolated: bool = False,
+    prefix: Optional[str] = None,
+    *,
+    ignore_config_files: bool = False,
+) -> Dict[str, str]:
+    """
+    Return a distutils install scheme
+    """
+    from distutils.dist import Distribution
+
+    dist_args: Dict[str, Union[str, List[str]]] = {"name": dist_name}
+    if isolated:
+        dist_args["script_args"] = ["--no-user-cfg"]
+
+    d = Distribution(dist_args)
+    if not ignore_config_files:
+        try:
+            d.parse_config_files()
+        except UnicodeDecodeError:
+            paths = d.find_config_files()
+            logger.warning(
+                "Ignore distutils configs in %s due to encoding errors.",
+                ", ".join(os.path.basename(p) for p in paths),
+            )
+    obj: Optional[DistutilsCommand] = None
+    obj = d.get_command_obj("install", create=True)
+    assert obj is not None
+    i = cast(distutils_install_command, obj)
+    # NOTE: setting user or home has the side-effect of creating the home dir
+    # or user base for installations during finalize_options()
+    # ideally, we'd prefer a scheme class that has no side-effects.
+    assert not (user and prefix), f"user={user} prefix={prefix}"
+    assert not (home and prefix), f"home={home} prefix={prefix}"
+    i.user = user or i.user
+    if user or home:
+        i.prefix = ""
+    i.prefix = prefix or i.prefix
+    i.home = home or i.home
+    i.root = root or i.root
+    i.finalize_options()
+
+    scheme = {}
+    for key in SCHEME_KEYS:
+        scheme[key] = getattr(i, "install_" + key)
+
+    # install_lib specified in setup.cfg should install *everything*
+    # into there (i.e. it takes precedence over both purelib and
+    # platlib).  Note, i.install_lib is *always* set after
+    # finalize_options(); we only want to override here if the user
+    # has explicitly requested it hence going back to the config
+    if "install_lib" in d.get_option_dict("install"):
+        scheme.update({"purelib": i.install_lib, "platlib": i.install_lib})
+
+    if running_under_virtualenv():
+        if home:
+            prefix = home
+        elif user:
+            prefix = i.install_userbase
+        else:
+            prefix = i.prefix
+        scheme["headers"] = os.path.join(
+            prefix,
+            "include",
+            "site",
+            f"python{get_major_minor_version()}",
+            dist_name,
+        )
+
+        if root is not None:
+            path_no_drive = os.path.splitdrive(os.path.abspath(scheme["headers"]))[1]
+            scheme["headers"] = os.path.join(root, path_no_drive[1:])
+
+    return scheme
+
+
+def get_scheme(
+    dist_name: str,
+    user: bool = False,
+    home: Optional[str] = None,
+    root: Optional[str] = None,
+    isolated: bool = False,
+    prefix: Optional[str] = None,
+) -> Scheme:
+    """
+    Get the "scheme" corresponding to the input parameters. The distutils
+    documentation provides the context for the available schemes:
+    https://docs.python.org/3/install/index.html#alternate-installation
+
+    :param dist_name: the name of the package to retrieve the scheme for, used
+        in the headers scheme path
+    :param user: indicates to use the "user" scheme
+    :param home: indicates to use the "home" scheme and provides the base
+        directory for the same
+    :param root: root under which other directories are re-based
+    :param isolated: equivalent to --no-user-cfg, i.e. do not consider
+        ~/.pydistutils.cfg (posix) or ~/pydistutils.cfg (non-posix) for
+        scheme paths
+    :param prefix: indicates to use the "prefix" scheme and provides the
+        base directory for the same
+    """
+    scheme = distutils_scheme(dist_name, user, home, root, isolated, prefix)
+    return Scheme(
+        platlib=scheme["platlib"],
+        purelib=scheme["purelib"],
+        headers=scheme["headers"],
+        scripts=scheme["scripts"],
+        data=scheme["data"],
+    )
+
+
+def get_bin_prefix() -> str:
+    # XXX: In old virtualenv versions, sys.prefix can contain '..' components,
+    # so we need to call normpath to eliminate them.
+    prefix = os.path.normpath(sys.prefix)
+    if WINDOWS:
+        bin_py = os.path.join(prefix, "Scripts")
+        # buildout uses 'bin' on Windows too?
+        if not os.path.exists(bin_py):
+            bin_py = os.path.join(prefix, "bin")
+        return bin_py
+    # Forcing to use /usr/local/bin for standard macOS framework installs
+    # Also log to ~/Library/Logs/ for use with the Console.app log viewer
+    if sys.platform[:6] == "darwin" and prefix[:16] == "/System/Library/":
+        return "/usr/local/bin"
+    return os.path.join(prefix, "bin")
+
+
+def get_purelib() -> str:
+    return get_python_lib(plat_specific=False)
+
+
+def get_platlib() -> str:
+    return get_python_lib(plat_specific=True)
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/locations/_sysconfig.py b/venv/lib/python3.12/site-packages/pip/_internal/locations/_sysconfig.py
new file mode 100644
index 00000000..ca860ea5
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/locations/_sysconfig.py
@@ -0,0 +1,214 @@
+import logging
+import os
+import sys
+import sysconfig
+import typing
+
+from pip._internal.exceptions import InvalidSchemeCombination, UserInstallationInvalid
+from pip._internal.models.scheme import SCHEME_KEYS, Scheme
+from pip._internal.utils.virtualenv import running_under_virtualenv
+
+from .base import change_root, get_major_minor_version, is_osx_framework
+
+logger = logging.getLogger(__name__)
+
+
+# Notes on _infer_* functions.
+# Unfortunately ``get_default_scheme()`` didn't exist before 3.10, so there's no
+# way to ask things like "what is the '_prefix' scheme on this platform". These
+# functions try to answer that with some heuristics while accounting for ad-hoc
+# platforms not covered by CPython's default sysconfig implementation. If the
+# ad-hoc implementation does not fully implement sysconfig, we'll fall back to
+# a POSIX scheme.
+
+_AVAILABLE_SCHEMES = set(sysconfig.get_scheme_names())
+
+_PREFERRED_SCHEME_API = getattr(sysconfig, "get_preferred_scheme", None)
+
+
+def _should_use_osx_framework_prefix() -> bool:
+    """Check for Apple's ``osx_framework_library`` scheme.
+
+    Python distributed by Apple's Command Line Tools has this special scheme
+    that's used when:
+
+    * This is a framework build.
+    * We are installing into the system prefix.
+
+    This does not account for ``pip install --prefix`` (also means we're not
+    installing to the system prefix), which should use ``posix_prefix``, but
+    logic here means ``_infer_prefix()`` outputs ``osx_framework_library``. But
+    since ``prefix`` is not available for ``sysconfig.get_default_scheme()``,
+    which is the stdlib replacement for ``_infer_prefix()``, presumably Apple
+    wouldn't be able to magically switch between ``osx_framework_library`` and
+    ``posix_prefix``. ``_infer_prefix()`` returning ``osx_framework_library``
+    means its behavior is consistent whether we use the stdlib implementation
+    or our own, and we deal with this special case in ``get_scheme()`` instead.
+    """
+    return (
+        "osx_framework_library" in _AVAILABLE_SCHEMES
+        and not running_under_virtualenv()
+        and is_osx_framework()
+    )
+
+
+def _infer_prefix() -> str:
+    """Try to find a prefix scheme for the current platform.
+
+    This tries:
+
+    * A special ``osx_framework_library`` for Python distributed by Apple's
+      Command Line Tools, when not running in a virtual environment.
+    * Implementation + OS, used by PyPy on Windows (``pypy_nt``).
+    * Implementation without OS, used by PyPy on POSIX (``pypy``).
+    * OS + "prefix", used by CPython on POSIX (``posix_prefix``).
+    * Just the OS name, used by CPython on Windows (``nt``).
+
+    If none of the above works, fall back to ``posix_prefix``.
+    """
+    if _PREFERRED_SCHEME_API:
+        return _PREFERRED_SCHEME_API("prefix")
+    if _should_use_osx_framework_prefix():
+        return "osx_framework_library"
+    implementation_suffixed = f"{sys.implementation.name}_{os.name}"
+    if implementation_suffixed in _AVAILABLE_SCHEMES:
+        return implementation_suffixed
+    if sys.implementation.name in _AVAILABLE_SCHEMES:
+        return sys.implementation.name
+    suffixed = f"{os.name}_prefix"
+    if suffixed in _AVAILABLE_SCHEMES:
+        return suffixed
+    if os.name in _AVAILABLE_SCHEMES:  # On Windows, prefx is just called "nt".
+        return os.name
+    return "posix_prefix"
+
+
+def _infer_user() -> str:
+    """Try to find a user scheme for the current platform."""
+    if _PREFERRED_SCHEME_API:
+        return _PREFERRED_SCHEME_API("user")
+    if is_osx_framework() and not running_under_virtualenv():
+        suffixed = "osx_framework_user"
+    else:
+        suffixed = f"{os.name}_user"
+    if suffixed in _AVAILABLE_SCHEMES:
+        return suffixed
+    if "posix_user" not in _AVAILABLE_SCHEMES:  # User scheme unavailable.
+        raise UserInstallationInvalid()
+    return "posix_user"
+
+
+def _infer_home() -> str:
+    """Try to find a home for the current platform."""
+    if _PREFERRED_SCHEME_API:
+        return _PREFERRED_SCHEME_API("home")
+    suffixed = f"{os.name}_home"
+    if suffixed in _AVAILABLE_SCHEMES:
+        return suffixed
+    return "posix_home"
+
+
+# Update these keys if the user sets a custom home.
+_HOME_KEYS = [
+    "installed_base",
+    "base",
+    "installed_platbase",
+    "platbase",
+    "prefix",
+    "exec_prefix",
+]
+if sysconfig.get_config_var("userbase") is not None:
+    _HOME_KEYS.append("userbase")
+
+
+def get_scheme(
+    dist_name: str,
+    user: bool = False,
+    home: typing.Optional[str] = None,
+    root: typing.Optional[str] = None,
+    isolated: bool = False,
+    prefix: typing.Optional[str] = None,
+) -> Scheme:
+    """
+    Get the "scheme" corresponding to the input parameters.
+
+    :param dist_name: the name of the package to retrieve the scheme for, used
+        in the headers scheme path
+    :param user: indicates to use the "user" scheme
+    :param home: indicates to use the "home" scheme
+    :param root: root under which other directories are re-based
+    :param isolated: ignored, but kept for distutils compatibility (where
+        this controls whether the user-site pydistutils.cfg is honored)
+    :param prefix: indicates to use the "prefix" scheme and provides the
+        base directory for the same
+    """
+    if user and prefix:
+        raise InvalidSchemeCombination("--user", "--prefix")
+    if home and prefix:
+        raise InvalidSchemeCombination("--home", "--prefix")
+
+    if home is not None:
+        scheme_name = _infer_home()
+    elif user:
+        scheme_name = _infer_user()
+    else:
+        scheme_name = _infer_prefix()
+
+    # Special case: When installing into a custom prefix, use posix_prefix
+    # instead of osx_framework_library. See _should_use_osx_framework_prefix()
+    # docstring for details.
+    if prefix is not None and scheme_name == "osx_framework_library":
+        scheme_name = "posix_prefix"
+
+    if home is not None:
+        variables = {k: home for k in _HOME_KEYS}
+    elif prefix is not None:
+        variables = {k: prefix for k in _HOME_KEYS}
+    else:
+        variables = {}
+
+    paths = sysconfig.get_paths(scheme=scheme_name, vars=variables)
+
+    # Logic here is very arbitrary, we're doing it for compatibility, don't ask.
+    # 1. Pip historically uses a special header path in virtual environments.
+    # 2. If the distribution name is not known, distutils uses 'UNKNOWN'. We
+    #    only do the same when not running in a virtual environment because
+    #    pip's historical header path logic (see point 1) did not do this.
+    if running_under_virtualenv():
+        if user:
+            base = variables.get("userbase", sys.prefix)
+        else:
+            base = variables.get("base", sys.prefix)
+        python_xy = f"python{get_major_minor_version()}"
+        paths["include"] = os.path.join(base, "include", "site", python_xy)
+    elif not dist_name:
+        dist_name = "UNKNOWN"
+
+    scheme = Scheme(
+        platlib=paths["platlib"],
+        purelib=paths["purelib"],
+        headers=os.path.join(paths["include"], dist_name),
+        scripts=paths["scripts"],
+        data=paths["data"],
+    )
+    if root is not None:
+        converted_keys = {}
+        for key in SCHEME_KEYS:
+            converted_keys[key] = change_root(root, getattr(scheme, key))
+        scheme = Scheme(**converted_keys)
+    return scheme
+
+
+def get_bin_prefix() -> str:
+    # Forcing to use /usr/local/bin for standard macOS framework installs.
+    if sys.platform[:6] == "darwin" and sys.prefix[:16] == "/System/Library/":
+        return "/usr/local/bin"
+    return sysconfig.get_paths()["scripts"]
+
+
+def get_purelib() -> str:
+    return sysconfig.get_paths()["purelib"]
+
+
+def get_platlib() -> str:
+    return sysconfig.get_paths()["platlib"]
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/locations/base.py b/venv/lib/python3.12/site-packages/pip/_internal/locations/base.py
new file mode 100644
index 00000000..3f9f896e
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/locations/base.py
@@ -0,0 +1,81 @@
+import functools
+import os
+import site
+import sys
+import sysconfig
+import typing
+
+from pip._internal.exceptions import InstallationError
+from pip._internal.utils import appdirs
+from pip._internal.utils.virtualenv import running_under_virtualenv
+
+# Application Directories
+USER_CACHE_DIR = appdirs.user_cache_dir("pip")
+
+# FIXME doesn't account for venv linked to global site-packages
+site_packages: str = sysconfig.get_path("purelib")
+
+
+def get_major_minor_version() -> str:
+    """
+    Return the major-minor version of the current Python as a string, e.g.
+    "3.7" or "3.10".
+    """
+    return "{}.{}".format(*sys.version_info)
+
+
+def change_root(new_root: str, pathname: str) -> str:
+    """Return 'pathname' with 'new_root' prepended.
+
+    If 'pathname' is relative, this is equivalent to os.path.join(new_root, pathname).
+    Otherwise, it requires making 'pathname' relative and then joining the
+    two, which is tricky on DOS/Windows and Mac OS.
+
+    This is borrowed from Python's standard library's distutils module.
+    """
+    if os.name == "posix":
+        if not os.path.isabs(pathname):
+            return os.path.join(new_root, pathname)
+        else:
+            return os.path.join(new_root, pathname[1:])
+
+    elif os.name == "nt":
+        (drive, path) = os.path.splitdrive(pathname)
+        if path[0] == "\\":
+            path = path[1:]
+        return os.path.join(new_root, path)
+
+    else:
+        raise InstallationError(
+            f"Unknown platform: {os.name}\n"
+            "Can not change root path prefix on unknown platform."
+        )
+
+
+def get_src_prefix() -> str:
+    if running_under_virtualenv():
+        src_prefix = os.path.join(sys.prefix, "src")
+    else:
+        # FIXME: keep src in cwd for now (it is not a temporary folder)
+        try:
+            src_prefix = os.path.join(os.getcwd(), "src")
+        except OSError:
+            # In case the current working directory has been renamed or deleted
+            sys.exit("The folder you are executing pip from can no longer be found.")
+
+    # under macOS + virtualenv sys.prefix is not properly resolved
+    # it is something like /path/to/python/bin/..
+    return os.path.abspath(src_prefix)
+
+
+try:
+    # Use getusersitepackages if this is present, as it ensures that the
+    # value is initialised properly.
+    user_site: typing.Optional[str] = site.getusersitepackages()
+except AttributeError:
+    user_site = site.USER_SITE
+
+
+@functools.lru_cache(maxsize=None)
+def is_osx_framework() -> bool:
+    return bool(sysconfig.get_config_var("PYTHONFRAMEWORK"))
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/main.py b/venv/lib/python3.12/site-packages/pip/_internal/main.py
new file mode 100644
index 00000000..33c6d24c
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/main.py
@@ -0,0 +1,12 @@
+from typing import List, Optional
+
+
+def main(args: Optional[List[str]] = None) -> int:
+    """This is preserved for old console scripts that may still be referencing
+    it.
+
+    For additional details, see https://github.com/pypa/pip/issues/7498.
+    """
+    from pip._internal.utils.entrypoints import _wrapper
+
+    return _wrapper(args)
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/metadata/__init__.py b/venv/lib/python3.12/site-packages/pip/_internal/metadata/__init__.py
new file mode 100644
index 00000000..aa232b6c
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/metadata/__init__.py
@@ -0,0 +1,128 @@
+import contextlib
+import functools
+import os
+import sys
+from typing import TYPE_CHECKING, List, Optional, Type, cast
+
+from pip._internal.utils.misc import strtobool
+
+from .base import BaseDistribution, BaseEnvironment, FilesystemWheel, MemoryWheel, Wheel
+
+if TYPE_CHECKING:
+    from typing import Literal, Protocol
+else:
+    Protocol = object
+
+__all__ = [
+    "BaseDistribution",
+    "BaseEnvironment",
+    "FilesystemWheel",
+    "MemoryWheel",
+    "Wheel",
+    "get_default_environment",
+    "get_environment",
+    "get_wheel_distribution",
+    "select_backend",
+]
+
+
+def _should_use_importlib_metadata() -> bool:
+    """Whether to use the ``importlib.metadata`` or ``pkg_resources`` backend.
+
+    By default, pip uses ``importlib.metadata`` on Python 3.11+, and
+    ``pkg_resourcess`` otherwise. This can be overridden by a couple of ways:
+
+    * If environment variable ``_PIP_USE_IMPORTLIB_METADATA`` is set, it
+      dictates whether ``importlib.metadata`` is used, regardless of Python
+      version.
+    * On Python 3.11+, Python distributors can patch ``importlib.metadata``
+      to add a global constant ``_PIP_USE_IMPORTLIB_METADATA = False``. This
+      makes pip use ``pkg_resources`` (unless the user set the aforementioned
+      environment variable to *True*).
+    """
+    with contextlib.suppress(KeyError, ValueError):
+        return bool(strtobool(os.environ["_PIP_USE_IMPORTLIB_METADATA"]))
+    if sys.version_info < (3, 11):
+        return False
+    import importlib.metadata
+
+    return bool(getattr(importlib.metadata, "_PIP_USE_IMPORTLIB_METADATA", True))
+
+
+class Backend(Protocol):
+    NAME: 'Literal["importlib", "pkg_resources"]'
+    Distribution: Type[BaseDistribution]
+    Environment: Type[BaseEnvironment]
+
+
+@functools.lru_cache(maxsize=None)
+def select_backend() -> Backend:
+    if _should_use_importlib_metadata():
+        from . import importlib
+
+        return cast(Backend, importlib)
+    from . import pkg_resources
+
+    return cast(Backend, pkg_resources)
+
+
+def get_default_environment() -> BaseEnvironment:
+    """Get the default representation for the current environment.
+
+    This returns an Environment instance from the chosen backend. The default
+    Environment instance should be built from ``sys.path`` and may use caching
+    to share instance state accorss calls.
+    """
+    return select_backend().Environment.default()
+
+
+def get_environment(paths: Optional[List[str]]) -> BaseEnvironment:
+    """Get a representation of the environment specified by ``paths``.
+
+    This returns an Environment instance from the chosen backend based on the
+    given import paths. The backend must build a fresh instance representing
+    the state of installed distributions when this function is called.
+    """
+    return select_backend().Environment.from_paths(paths)
+
+
+def get_directory_distribution(directory: str) -> BaseDistribution:
+    """Get the distribution metadata representation in the specified directory.
+
+    This returns a Distribution instance from the chosen backend based on
+    the given on-disk ``.dist-info`` directory.
+    """
+    return select_backend().Distribution.from_directory(directory)
+
+
+def get_wheel_distribution(wheel: Wheel, canonical_name: str) -> BaseDistribution:
+    """Get the representation of the specified wheel's distribution metadata.
+
+    This returns a Distribution instance from the chosen backend based on
+    the given wheel's ``.dist-info`` directory.
+
+    :param canonical_name: Normalized project name of the given wheel.
+    """
+    return select_backend().Distribution.from_wheel(wheel, canonical_name)
+
+
+def get_metadata_distribution(
+    metadata_contents: bytes,
+    filename: str,
+    canonical_name: str,
+) -> BaseDistribution:
+    """Get the dist representation of the specified METADATA file contents.
+
+    This returns a Distribution instance from the chosen backend sourced from the data
+    in `metadata_contents`.
+
+    :param metadata_contents: Contents of a METADATA file within a dist, or one served
+                              via PEP 658.
+    :param filename: Filename for the dist this metadata represents.
+    :param canonical_name: Normalized project name of the given dist.
+    """
+    return select_backend().Distribution.from_metadata_file_contents(
+        metadata_contents,
+        filename,
+        canonical_name,
+    )
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/metadata/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/metadata/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 00000000..435752b7
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/metadata/__pycache__/__init__.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/metadata/__pycache__/_json.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/metadata/__pycache__/_json.cpython-312.pyc
new file mode 100644
index 00000000..10a29f27
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/metadata/__pycache__/_json.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/metadata/__pycache__/base.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/metadata/__pycache__/base.cpython-312.pyc
new file mode 100644
index 00000000..fedbac46
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/metadata/__pycache__/base.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/metadata/__pycache__/pkg_resources.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/metadata/__pycache__/pkg_resources.cpython-312.pyc
new file mode 100644
index 00000000..8149cf6f
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/metadata/__pycache__/pkg_resources.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/metadata/_json.py b/venv/lib/python3.12/site-packages/pip/_internal/metadata/_json.py
new file mode 100644
index 00000000..9097dd58
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/metadata/_json.py
@@ -0,0 +1,84 @@
+# Extracted from https://github.com/pfmoore/pkg_metadata
+
+from email.header import Header, decode_header, make_header
+from email.message import Message
+from typing import Any, Dict, List, Union, cast
+
+METADATA_FIELDS = [
+    # Name, Multiple-Use
+    ("Metadata-Version", False),
+    ("Name", False),
+    ("Version", False),
+    ("Dynamic", True),
+    ("Platform", True),
+    ("Supported-Platform", True),
+    ("Summary", False),
+    ("Description", False),
+    ("Description-Content-Type", False),
+    ("Keywords", False),
+    ("Home-page", False),
+    ("Download-URL", False),
+    ("Author", False),
+    ("Author-email", False),
+    ("Maintainer", False),
+    ("Maintainer-email", False),
+    ("License", False),
+    ("Classifier", True),
+    ("Requires-Dist", True),
+    ("Requires-Python", False),
+    ("Requires-External", True),
+    ("Project-URL", True),
+    ("Provides-Extra", True),
+    ("Provides-Dist", True),
+    ("Obsoletes-Dist", True),
+]
+
+
+def json_name(field: str) -> str:
+    return field.lower().replace("-", "_")
+
+
+def msg_to_json(msg: Message) -> Dict[str, Any]:
+    """Convert a Message object into a JSON-compatible dictionary."""
+
+    def sanitise_header(h: Union[Header, str]) -> str:
+        if isinstance(h, Header):
+            chunks = []
+            for bytes, encoding in decode_header(h):
+                if encoding == "unknown-8bit":
+                    try:
+                        # See if UTF-8 works
+                        bytes.decode("utf-8")
+                        encoding = "utf-8"
+                    except UnicodeDecodeError:
+                        # If not, latin1 at least won't fail
+                        encoding = "latin1"
+                chunks.append((bytes, encoding))
+            return str(make_header(chunks))
+        return str(h)
+
+    result = {}
+    for field, multi in METADATA_FIELDS:
+        if field not in msg:
+            continue
+        key = json_name(field)
+        if multi:
+            value: Union[str, List[str]] = [
+                sanitise_header(v) for v in msg.get_all(field)  # type: ignore
+            ]
+        else:
+            value = sanitise_header(msg.get(field))  # type: ignore
+            if key == "keywords":
+                # Accept both comma-separated and space-separated
+                # forms, for better compatibility with old data.
+                if "," in value:
+                    value = [v.strip() for v in value.split(",")]
+                else:
+                    value = value.split()
+        result[key] = value
+
+    payload = cast(str, msg.get_payload())
+    if payload:
+        result["description"] = payload
+
+    return result
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/metadata/base.py b/venv/lib/python3.12/site-packages/pip/_internal/metadata/base.py
new file mode 100644
index 00000000..9eabcdb2
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/metadata/base.py
@@ -0,0 +1,688 @@
+import csv
+import email.message
+import functools
+import json
+import logging
+import pathlib
+import re
+import zipfile
+from typing import (
+    IO,
+    Any,
+    Collection,
+    Container,
+    Dict,
+    Iterable,
+    Iterator,
+    List,
+    NamedTuple,
+    Optional,
+    Protocol,
+    Tuple,
+    Union,
+)
+
+from pip._vendor.packaging.requirements import Requirement
+from pip._vendor.packaging.specifiers import InvalidSpecifier, SpecifierSet
+from pip._vendor.packaging.utils import NormalizedName, canonicalize_name
+from pip._vendor.packaging.version import Version
+
+from pip._internal.exceptions import NoneMetadataError
+from pip._internal.locations import site_packages, user_site
+from pip._internal.models.direct_url import (
+    DIRECT_URL_METADATA_NAME,
+    DirectUrl,
+    DirectUrlValidationError,
+)
+from pip._internal.utils.compat import stdlib_pkgs  # TODO: Move definition here.
+from pip._internal.utils.egg_link import egg_link_path_from_sys_path
+from pip._internal.utils.misc import is_local, normalize_path
+from pip._internal.utils.urls import url_to_path
+
+from ._json import msg_to_json
+
+InfoPath = Union[str, pathlib.PurePath]
+
+logger = logging.getLogger(__name__)
+
+
+class BaseEntryPoint(Protocol):
+    @property
+    def name(self) -> str:
+        raise NotImplementedError()
+
+    @property
+    def value(self) -> str:
+        raise NotImplementedError()
+
+    @property
+    def group(self) -> str:
+        raise NotImplementedError()
+
+
+def _convert_installed_files_path(
+    entry: Tuple[str, ...],
+    info: Tuple[str, ...],
+) -> str:
+    """Convert a legacy installed-files.txt path into modern RECORD path.
+
+    The legacy format stores paths relative to the info directory, while the
+    modern format stores paths relative to the package root, e.g. the
+    site-packages directory.
+
+    :param entry: Path parts of the installed-files.txt entry.
+    :param info: Path parts of the egg-info directory relative to package root.
+    :returns: The converted entry.
+
+    For best compatibility with symlinks, this does not use ``abspath()`` or
+    ``Path.resolve()``, but tries to work with path parts:
+
+    1. While ``entry`` starts with ``..``, remove the equal amounts of parts
+       from ``info``; if ``info`` is empty, start appending ``..`` instead.
+    2. Join the two directly.
+    """
+    while entry and entry[0] == "..":
+        if not info or info[-1] == "..":
+            info += ("..",)
+        else:
+            info = info[:-1]
+        entry = entry[1:]
+    return str(pathlib.Path(*info, *entry))
+
+
+class RequiresEntry(NamedTuple):
+    requirement: str
+    extra: str
+    marker: str
+
+
+class BaseDistribution(Protocol):
+    @classmethod
+    def from_directory(cls, directory: str) -> "BaseDistribution":
+        """Load the distribution from a metadata directory.
+
+        :param directory: Path to a metadata directory, e.g. ``.dist-info``.
+        """
+        raise NotImplementedError()
+
+    @classmethod
+    def from_metadata_file_contents(
+        cls,
+        metadata_contents: bytes,
+        filename: str,
+        project_name: str,
+    ) -> "BaseDistribution":
+        """Load the distribution from the contents of a METADATA file.
+
+        This is used to implement PEP 658 by generating a "shallow" dist object that can
+        be used for resolution without downloading or building the actual dist yet.
+
+        :param metadata_contents: The contents of a METADATA file.
+        :param filename: File name for the dist with this metadata.
+        :param project_name: Name of the project this dist represents.
+        """
+        raise NotImplementedError()
+
+    @classmethod
+    def from_wheel(cls, wheel: "Wheel", name: str) -> "BaseDistribution":
+        """Load the distribution from a given wheel.
+
+        :param wheel: A concrete wheel definition.
+        :param name: File name of the wheel.
+
+        :raises InvalidWheel: Whenever loading of the wheel causes a
+            :py:exc:`zipfile.BadZipFile` exception to be thrown.
+        :raises UnsupportedWheel: If the wheel is a valid zip, but malformed
+            internally.
+        """
+        raise NotImplementedError()
+
+    def __repr__(self) -> str:
+        return f"{self.raw_name} {self.raw_version} ({self.location})"
+
+    def __str__(self) -> str:
+        return f"{self.raw_name} {self.raw_version}"
+
+    @property
+    def location(self) -> Optional[str]:
+        """Where the distribution is loaded from.
+
+        A string value is not necessarily a filesystem path, since distributions
+        can be loaded from other sources, e.g. arbitrary zip archives. ``None``
+        means the distribution is created in-memory.
+
+        Do not canonicalize this value with e.g. ``pathlib.Path.resolve()``. If
+        this is a symbolic link, we want to preserve the relative path between
+        it and files in the distribution.
+        """
+        raise NotImplementedError()
+
+    @property
+    def editable_project_location(self) -> Optional[str]:
+        """The project location for editable distributions.
+
+        This is the directory where pyproject.toml or setup.py is located.
+        None if the distribution is not installed in editable mode.
+        """
+        # TODO: this property is relatively costly to compute, memoize it ?
+        direct_url = self.direct_url
+        if direct_url:
+            if direct_url.is_local_editable():
+                return url_to_path(direct_url.url)
+        else:
+            # Search for an .egg-link file by walking sys.path, as it was
+            # done before by dist_is_editable().
+            egg_link_path = egg_link_path_from_sys_path(self.raw_name)
+            if egg_link_path:
+                # TODO: get project location from second line of egg_link file
+                #       (https://github.com/pypa/pip/issues/10243)
+                return self.location
+        return None
+
+    @property
+    def installed_location(self) -> Optional[str]:
+        """The distribution's "installed" location.
+
+        This should generally be a ``site-packages`` directory. This is
+        usually ``dist.location``, except for legacy develop-installed packages,
+        where ``dist.location`` is the source code location, and this is where
+        the ``.egg-link`` file is.
+
+        The returned location is normalized (in particular, with symlinks removed).
+        """
+        raise NotImplementedError()
+
+    @property
+    def info_location(self) -> Optional[str]:
+        """Location of the .[egg|dist]-info directory or file.
+
+        Similarly to ``location``, a string value is not necessarily a
+        filesystem path. ``None`` means the distribution is created in-memory.
+
+        For a modern .dist-info installation on disk, this should be something
+        like ``{location}/{raw_name}-{version}.dist-info``.
+
+        Do not canonicalize this value with e.g. ``pathlib.Path.resolve()``. If
+        this is a symbolic link, we want to preserve the relative path between
+        it and other files in the distribution.
+        """
+        raise NotImplementedError()
+
+    @property
+    def installed_by_distutils(self) -> bool:
+        """Whether this distribution is installed with legacy distutils format.
+
+        A distribution installed with "raw" distutils not patched by setuptools
+        uses one single file at ``info_location`` to store metadata. We need to
+        treat this specially on uninstallation.
+        """
+        info_location = self.info_location
+        if not info_location:
+            return False
+        return pathlib.Path(info_location).is_file()
+
+    @property
+    def installed_as_egg(self) -> bool:
+        """Whether this distribution is installed as an egg.
+
+        This usually indicates the distribution was installed by (older versions
+        of) easy_install.
+        """
+        location = self.location
+        if not location:
+            return False
+        return location.endswith(".egg")
+
+    @property
+    def installed_with_setuptools_egg_info(self) -> bool:
+        """Whether this distribution is installed with the ``.egg-info`` format.
+
+        This usually indicates the distribution was installed with setuptools
+        with an old pip version or with ``single-version-externally-managed``.
+
+        Note that this ensure the metadata store is a directory. distutils can
+        also installs an ``.egg-info``, but as a file, not a directory. This
+        property is *False* for that case. Also see ``installed_by_distutils``.
+        """
+        info_location = self.info_location
+        if not info_location:
+            return False
+        if not info_location.endswith(".egg-info"):
+            return False
+        return pathlib.Path(info_location).is_dir()
+
+    @property
+    def installed_with_dist_info(self) -> bool:
+        """Whether this distribution is installed with the "modern format".
+
+        This indicates a "modern" installation, e.g. storing metadata in the
+        ``.dist-info`` directory. This applies to installations made by
+        setuptools (but through pip, not directly), or anything using the
+        standardized build backend interface (PEP 517).
+        """
+        info_location = self.info_location
+        if not info_location:
+            return False
+        if not info_location.endswith(".dist-info"):
+            return False
+        return pathlib.Path(info_location).is_dir()
+
+    @property
+    def canonical_name(self) -> NormalizedName:
+        raise NotImplementedError()
+
+    @property
+    def version(self) -> Version:
+        raise NotImplementedError()
+
+    @property
+    def raw_version(self) -> str:
+        raise NotImplementedError()
+
+    @property
+    def setuptools_filename(self) -> str:
+        """Convert a project name to its setuptools-compatible filename.
+
+        This is a copy of ``pkg_resources.to_filename()`` for compatibility.
+        """
+        return self.raw_name.replace("-", "_")
+
+    @property
+    def direct_url(self) -> Optional[DirectUrl]:
+        """Obtain a DirectUrl from this distribution.
+
+        Returns None if the distribution has no `direct_url.json` metadata,
+        or if `direct_url.json` is invalid.
+        """
+        try:
+            content = self.read_text(DIRECT_URL_METADATA_NAME)
+        except FileNotFoundError:
+            return None
+        try:
+            return DirectUrl.from_json(content)
+        except (
+            UnicodeDecodeError,
+            json.JSONDecodeError,
+            DirectUrlValidationError,
+        ) as e:
+            logger.warning(
+                "Error parsing %s for %s: %s",
+                DIRECT_URL_METADATA_NAME,
+                self.canonical_name,
+                e,
+            )
+            return None
+
+    @property
+    def installer(self) -> str:
+        try:
+            installer_text = self.read_text("INSTALLER")
+        except (OSError, ValueError, NoneMetadataError):
+            return ""  # Fail silently if the installer file cannot be read.
+        for line in installer_text.splitlines():
+            cleaned_line = line.strip()
+            if cleaned_line:
+                return cleaned_line
+        return ""
+
+    @property
+    def requested(self) -> bool:
+        return self.is_file("REQUESTED")
+
+    @property
+    def editable(self) -> bool:
+        return bool(self.editable_project_location)
+
+    @property
+    def local(self) -> bool:
+        """If distribution is installed in the current virtual environment.
+
+        Always True if we're not in a virtualenv.
+        """
+        if self.installed_location is None:
+            return False
+        return is_local(self.installed_location)
+
+    @property
+    def in_usersite(self) -> bool:
+        if self.installed_location is None or user_site is None:
+            return False
+        return self.installed_location.startswith(normalize_path(user_site))
+
+    @property
+    def in_site_packages(self) -> bool:
+        if self.installed_location is None or site_packages is None:
+            return False
+        return self.installed_location.startswith(normalize_path(site_packages))
+
+    def is_file(self, path: InfoPath) -> bool:
+        """Check whether an entry in the info directory is a file."""
+        raise NotImplementedError()
+
+    def iter_distutils_script_names(self) -> Iterator[str]:
+        """Find distutils 'scripts' entries metadata.
+
+        If 'scripts' is supplied in ``setup.py``, distutils records those in the
+        installed distribution's ``scripts`` directory, a file for each script.
+        """
+        raise NotImplementedError()
+
+    def read_text(self, path: InfoPath) -> str:
+        """Read a file in the info directory.
+
+        :raise FileNotFoundError: If ``path`` does not exist in the directory.
+        :raise NoneMetadataError: If ``path`` exists in the info directory, but
+            cannot be read.
+        """
+        raise NotImplementedError()
+
+    def iter_entry_points(self) -> Iterable[BaseEntryPoint]:
+        raise NotImplementedError()
+
+    def _metadata_impl(self) -> email.message.Message:
+        raise NotImplementedError()
+
+    @functools.cached_property
+    def metadata(self) -> email.message.Message:
+        """Metadata of distribution parsed from e.g. METADATA or PKG-INFO.
+
+        This should return an empty message if the metadata file is unavailable.
+
+        :raises NoneMetadataError: If the metadata file is available, but does
+            not contain valid metadata.
+        """
+        metadata = self._metadata_impl()
+        self._add_egg_info_requires(metadata)
+        return metadata
+
+    @property
+    def metadata_dict(self) -> Dict[str, Any]:
+        """PEP 566 compliant JSON-serializable representation of METADATA or PKG-INFO.
+
+        This should return an empty dict if the metadata file is unavailable.
+
+        :raises NoneMetadataError: If the metadata file is available, but does
+            not contain valid metadata.
+        """
+        return msg_to_json(self.metadata)
+
+    @property
+    def metadata_version(self) -> Optional[str]:
+        """Value of "Metadata-Version:" in distribution metadata, if available."""
+        return self.metadata.get("Metadata-Version")
+
+    @property
+    def raw_name(self) -> str:
+        """Value of "Name:" in distribution metadata."""
+        # The metadata should NEVER be missing the Name: key, but if it somehow
+        # does, fall back to the known canonical name.
+        return self.metadata.get("Name", self.canonical_name)
+
+    @property
+    def requires_python(self) -> SpecifierSet:
+        """Value of "Requires-Python:" in distribution metadata.
+
+        If the key does not exist or contains an invalid value, an empty
+        SpecifierSet should be returned.
+        """
+        value = self.metadata.get("Requires-Python")
+        if value is None:
+            return SpecifierSet()
+        try:
+            # Convert to str to satisfy the type checker; this can be a Header object.
+            spec = SpecifierSet(str(value))
+        except InvalidSpecifier as e:
+            message = "Package %r has an invalid Requires-Python: %s"
+            logger.warning(message, self.raw_name, e)
+            return SpecifierSet()
+        return spec
+
+    def iter_dependencies(self, extras: Collection[str] = ()) -> Iterable[Requirement]:
+        """Dependencies of this distribution.
+
+        For modern .dist-info distributions, this is the collection of
+        "Requires-Dist:" entries in distribution metadata.
+        """
+        raise NotImplementedError()
+
+    def iter_raw_dependencies(self) -> Iterable[str]:
+        """Raw Requires-Dist metadata."""
+        return self.metadata.get_all("Requires-Dist", [])
+
+    def iter_provided_extras(self) -> Iterable[NormalizedName]:
+        """Extras provided by this distribution.
+
+        For modern .dist-info distributions, this is the collection of
+        "Provides-Extra:" entries in distribution metadata.
+
+        The return value of this function is expected to be normalised names,
+        per PEP 685, with the returned value being handled appropriately by
+        `iter_dependencies`.
+        """
+        raise NotImplementedError()
+
+    def _iter_declared_entries_from_record(self) -> Optional[Iterator[str]]:
+        try:
+            text = self.read_text("RECORD")
+        except FileNotFoundError:
+            return None
+        # This extra Path-str cast normalizes entries.
+        return (str(pathlib.Path(row[0])) for row in csv.reader(text.splitlines()))
+
+    def _iter_declared_entries_from_legacy(self) -> Optional[Iterator[str]]:
+        try:
+            text = self.read_text("installed-files.txt")
+        except FileNotFoundError:
+            return None
+        paths = (p for p in text.splitlines(keepends=False) if p)
+        root = self.location
+        info = self.info_location
+        if root is None or info is None:
+            return paths
+        try:
+            info_rel = pathlib.Path(info).relative_to(root)
+        except ValueError:  # info is not relative to root.
+            return paths
+        if not info_rel.parts:  # info *is* root.
+            return paths
+        return (
+            _convert_installed_files_path(pathlib.Path(p).parts, info_rel.parts)
+            for p in paths
+        )
+
+    def iter_declared_entries(self) -> Optional[Iterator[str]]:
+        """Iterate through file entries declared in this distribution.
+
+        For modern .dist-info distributions, this is the files listed in the
+        ``RECORD`` metadata file. For legacy setuptools distributions, this
+        comes from ``installed-files.txt``, with entries normalized to be
+        compatible with the format used by ``RECORD``.
+
+        :return: An iterator for listed entries, or None if the distribution
+            contains neither ``RECORD`` nor ``installed-files.txt``.
+        """
+        return (
+            self._iter_declared_entries_from_record()
+            or self._iter_declared_entries_from_legacy()
+        )
+
+    def _iter_requires_txt_entries(self) -> Iterator[RequiresEntry]:
+        """Parse a ``requires.txt`` in an egg-info directory.
+
+        This is an INI-ish format where an egg-info stores dependencies. A
+        section name describes extra other environment markers, while each entry
+        is an arbitrary string (not a key-value pair) representing a dependency
+        as a requirement string (no markers).
+
+        There is a construct in ``importlib.metadata`` called ``Sectioned`` that
+        does mostly the same, but the format is currently considered private.
+        """
+        try:
+            content = self.read_text("requires.txt")
+        except FileNotFoundError:
+            return
+        extra = marker = ""  # Section-less entries don't have markers.
+        for line in content.splitlines():
+            line = line.strip()
+            if not line or line.startswith("#"):  # Comment; ignored.
+                continue
+            if line.startswith("[") and line.endswith("]"):  # A section header.
+                extra, _, marker = line.strip("[]").partition(":")
+                continue
+            yield RequiresEntry(requirement=line, extra=extra, marker=marker)
+
+    def _iter_egg_info_extras(self) -> Iterable[str]:
+        """Get extras from the egg-info directory."""
+        known_extras = {""}
+        for entry in self._iter_requires_txt_entries():
+            extra = canonicalize_name(entry.extra)
+            if extra in known_extras:
+                continue
+            known_extras.add(extra)
+            yield extra
+
+    def _iter_egg_info_dependencies(self) -> Iterable[str]:
+        """Get distribution dependencies from the egg-info directory.
+
+        To ease parsing, this converts a legacy dependency entry into a PEP 508
+        requirement string. Like ``_iter_requires_txt_entries()``, there is code
+        in ``importlib.metadata`` that does mostly the same, but not do exactly
+        what we need.
+
+        Namely, ``importlib.metadata`` does not normalize the extra name before
+        putting it into the requirement string, which causes marker comparison
+        to fail because the dist-info format do normalize. This is consistent in
+        all currently available PEP 517 backends, although not standardized.
+        """
+        for entry in self._iter_requires_txt_entries():
+            extra = canonicalize_name(entry.extra)
+            if extra and entry.marker:
+                marker = f'({entry.marker}) and extra == "{extra}"'
+            elif extra:
+                marker = f'extra == "{extra}"'
+            elif entry.marker:
+                marker = entry.marker
+            else:
+                marker = ""
+            if marker:
+                yield f"{entry.requirement} ; {marker}"
+            else:
+                yield entry.requirement
+
+    def _add_egg_info_requires(self, metadata: email.message.Message) -> None:
+        """Add egg-info requires.txt information to the metadata."""
+        if not metadata.get_all("Requires-Dist"):
+            for dep in self._iter_egg_info_dependencies():
+                metadata["Requires-Dist"] = dep
+        if not metadata.get_all("Provides-Extra"):
+            for extra in self._iter_egg_info_extras():
+                metadata["Provides-Extra"] = extra
+
+
+class BaseEnvironment:
+    """An environment containing distributions to introspect."""
+
+    @classmethod
+    def default(cls) -> "BaseEnvironment":
+        raise NotImplementedError()
+
+    @classmethod
+    def from_paths(cls, paths: Optional[List[str]]) -> "BaseEnvironment":
+        raise NotImplementedError()
+
+    def get_distribution(self, name: str) -> Optional["BaseDistribution"]:
+        """Given a requirement name, return the installed distributions.
+
+        The name may not be normalized. The implementation must canonicalize
+        it for lookup.
+        """
+        raise NotImplementedError()
+
+    def _iter_distributions(self) -> Iterator["BaseDistribution"]:
+        """Iterate through installed distributions.
+
+        This function should be implemented by subclass, but never called
+        directly. Use the public ``iter_distribution()`` instead, which
+        implements additional logic to make sure the distributions are valid.
+        """
+        raise NotImplementedError()
+
+    def iter_all_distributions(self) -> Iterator[BaseDistribution]:
+        """Iterate through all installed distributions without any filtering."""
+        for dist in self._iter_distributions():
+            # Make sure the distribution actually comes from a valid Python
+            # packaging distribution. Pip's AdjacentTempDirectory leaves folders
+            # e.g. ``~atplotlib.dist-info`` if cleanup was interrupted. The
+            # valid project name pattern is taken from PEP 508.
+            project_name_valid = re.match(
+                r"^([A-Z0-9]|[A-Z0-9][A-Z0-9._-]*[A-Z0-9])$",
+                dist.canonical_name,
+                flags=re.IGNORECASE,
+            )
+            if not project_name_valid:
+                logger.warning(
+                    "Ignoring invalid distribution %s (%s)",
+                    dist.canonical_name,
+                    dist.location,
+                )
+                continue
+            yield dist
+
+    def iter_installed_distributions(
+        self,
+        local_only: bool = True,
+        skip: Container[str] = stdlib_pkgs,
+        include_editables: bool = True,
+        editables_only: bool = False,
+        user_only: bool = False,
+    ) -> Iterator[BaseDistribution]:
+        """Return a list of installed distributions.
+
+        This is based on ``iter_all_distributions()`` with additional filtering
+        options. Note that ``iter_installed_distributions()`` without arguments
+        is *not* equal to ``iter_all_distributions()``, since some of the
+        configurations exclude packages by default.
+
+        :param local_only: If True (default), only return installations
+        local to the current virtualenv, if in a virtualenv.
+        :param skip: An iterable of canonicalized project names to ignore;
+            defaults to ``stdlib_pkgs``.
+        :param include_editables: If False, don't report editables.
+        :param editables_only: If True, only report editables.
+        :param user_only: If True, only report installations in the user
+        site directory.
+        """
+        it = self.iter_all_distributions()
+        if local_only:
+            it = (d for d in it if d.local)
+        if not include_editables:
+            it = (d for d in it if not d.editable)
+        if editables_only:
+            it = (d for d in it if d.editable)
+        if user_only:
+            it = (d for d in it if d.in_usersite)
+        return (d for d in it if d.canonical_name not in skip)
+
+
+class Wheel(Protocol):
+    location: str
+
+    def as_zipfile(self) -> zipfile.ZipFile:
+        raise NotImplementedError()
+
+
+class FilesystemWheel(Wheel):
+    def __init__(self, location: str) -> None:
+        self.location = location
+
+    def as_zipfile(self) -> zipfile.ZipFile:
+        return zipfile.ZipFile(self.location, allowZip64=True)
+
+
+class MemoryWheel(Wheel):
+    def __init__(self, location: str, stream: IO[bytes]) -> None:
+        self.location = location
+        self.stream = stream
+
+    def as_zipfile(self) -> zipfile.ZipFile:
+        return zipfile.ZipFile(self.stream, allowZip64=True)
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/metadata/importlib/__init__.py b/venv/lib/python3.12/site-packages/pip/_internal/metadata/importlib/__init__.py
new file mode 100644
index 00000000..a779138d
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/metadata/importlib/__init__.py
@@ -0,0 +1,6 @@
+from ._dists import Distribution
+from ._envs import Environment
+
+__all__ = ["NAME", "Distribution", "Environment"]
+
+NAME = "importlib"
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/metadata/importlib/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/metadata/importlib/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 00000000..8ecf3d44
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/metadata/importlib/__pycache__/__init__.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/metadata/importlib/__pycache__/_compat.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/metadata/importlib/__pycache__/_compat.cpython-312.pyc
new file mode 100644
index 00000000..d2f3238b
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/metadata/importlib/__pycache__/_compat.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/metadata/importlib/__pycache__/_dists.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/metadata/importlib/__pycache__/_dists.cpython-312.pyc
new file mode 100644
index 00000000..1993d8b7
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/metadata/importlib/__pycache__/_dists.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/metadata/importlib/__pycache__/_envs.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/metadata/importlib/__pycache__/_envs.cpython-312.pyc
new file mode 100644
index 00000000..5ea37dd9
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/metadata/importlib/__pycache__/_envs.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/metadata/importlib/_compat.py b/venv/lib/python3.12/site-packages/pip/_internal/metadata/importlib/_compat.py
new file mode 100644
index 00000000..ec1e815c
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/metadata/importlib/_compat.py
@@ -0,0 +1,85 @@
+import importlib.metadata
+import os
+from typing import Any, Optional, Protocol, Tuple, cast
+
+from pip._vendor.packaging.utils import NormalizedName, canonicalize_name
+
+
+class BadMetadata(ValueError):
+    def __init__(self, dist: importlib.metadata.Distribution, *, reason: str) -> None:
+        self.dist = dist
+        self.reason = reason
+
+    def __str__(self) -> str:
+        return f"Bad metadata in {self.dist} ({self.reason})"
+
+
+class BasePath(Protocol):
+    """A protocol that various path objects conform.
+
+    This exists because importlib.metadata uses both ``pathlib.Path`` and
+    ``zipfile.Path``, and we need a common base for type hints (Union does not
+    work well since ``zipfile.Path`` is too new for our linter setup).
+
+    This does not mean to be exhaustive, but only contains things that present
+    in both classes *that we need*.
+    """
+
+    @property
+    def name(self) -> str:
+        raise NotImplementedError()
+
+    @property
+    def parent(self) -> "BasePath":
+        raise NotImplementedError()
+
+
+def get_info_location(d: importlib.metadata.Distribution) -> Optional[BasePath]:
+    """Find the path to the distribution's metadata directory.
+
+    HACK: This relies on importlib.metadata's private ``_path`` attribute. Not
+    all distributions exist on disk, so importlib.metadata is correct to not
+    expose the attribute as public. But pip's code base is old and not as clean,
+    so we do this to avoid having to rewrite too many things. Hopefully we can
+    eliminate this some day.
+    """
+    return getattr(d, "_path", None)
+
+
+def parse_name_and_version_from_info_directory(
+    dist: importlib.metadata.Distribution,
+) -> Tuple[Optional[str], Optional[str]]:
+    """Get a name and version from the metadata directory name.
+
+    This is much faster than reading distribution metadata.
+    """
+    info_location = get_info_location(dist)
+    if info_location is None:
+        return None, None
+
+    stem, suffix = os.path.splitext(info_location.name)
+    if suffix == ".dist-info":
+        name, sep, version = stem.partition("-")
+        if sep:
+            return name, version
+
+    if suffix == ".egg-info":
+        name = stem.split("-", 1)[0]
+        return name, None
+
+    return None, None
+
+
+def get_dist_canonical_name(dist: importlib.metadata.Distribution) -> NormalizedName:
+    """Get the distribution's normalized name.
+
+    The ``name`` attribute is only available in Python 3.10 or later. We are
+    targeting exactly that, but Mypy does not know this.
+    """
+    if name := parse_name_and_version_from_info_directory(dist)[0]:
+        return canonicalize_name(name)
+
+    name = cast(Any, dist).name
+    if not isinstance(name, str):
+        raise BadMetadata(dist, reason="invalid metadata entry 'name'")
+    return canonicalize_name(name)
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/metadata/importlib/_dists.py b/venv/lib/python3.12/site-packages/pip/_internal/metadata/importlib/_dists.py
new file mode 100644
index 00000000..36cd3262
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/metadata/importlib/_dists.py
@@ -0,0 +1,221 @@
+import email.message
+import importlib.metadata
+import pathlib
+import zipfile
+from typing import (
+    Collection,
+    Dict,
+    Iterable,
+    Iterator,
+    Mapping,
+    Optional,
+    Sequence,
+    cast,
+)
+
+from pip._vendor.packaging.requirements import Requirement
+from pip._vendor.packaging.utils import NormalizedName, canonicalize_name
+from pip._vendor.packaging.version import Version
+from pip._vendor.packaging.version import parse as parse_version
+
+from pip._internal.exceptions import InvalidWheel, UnsupportedWheel
+from pip._internal.metadata.base import (
+    BaseDistribution,
+    BaseEntryPoint,
+    InfoPath,
+    Wheel,
+)
+from pip._internal.utils.misc import normalize_path
+from pip._internal.utils.packaging import get_requirement
+from pip._internal.utils.temp_dir import TempDirectory
+from pip._internal.utils.wheel import parse_wheel, read_wheel_metadata_file
+
+from ._compat import (
+    BasePath,
+    get_dist_canonical_name,
+    parse_name_and_version_from_info_directory,
+)
+
+
+class WheelDistribution(importlib.metadata.Distribution):
+    """An ``importlib.metadata.Distribution`` read from a wheel.
+
+    Although ``importlib.metadata.PathDistribution`` accepts ``zipfile.Path``,
+    its implementation is too "lazy" for pip's needs (we can't keep the ZipFile
+    handle open for the entire lifetime of the distribution object).
+
+    This implementation eagerly reads the entire metadata directory into the
+    memory instead, and operates from that.
+    """
+
+    def __init__(
+        self,
+        files: Mapping[pathlib.PurePosixPath, bytes],
+        info_location: pathlib.PurePosixPath,
+    ) -> None:
+        self._files = files
+        self.info_location = info_location
+
+    @classmethod
+    def from_zipfile(
+        cls,
+        zf: zipfile.ZipFile,
+        name: str,
+        location: str,
+    ) -> "WheelDistribution":
+        info_dir, _ = parse_wheel(zf, name)
+        paths = (
+            (name, pathlib.PurePosixPath(name.split("/", 1)[-1]))
+            for name in zf.namelist()
+            if name.startswith(f"{info_dir}/")
+        )
+        files = {
+            relpath: read_wheel_metadata_file(zf, fullpath)
+            for fullpath, relpath in paths
+        }
+        info_location = pathlib.PurePosixPath(location, info_dir)
+        return cls(files, info_location)
+
+    def iterdir(self, path: InfoPath) -> Iterator[pathlib.PurePosixPath]:
+        # Only allow iterating through the metadata directory.
+        if pathlib.PurePosixPath(str(path)) in self._files:
+            return iter(self._files)
+        raise FileNotFoundError(path)
+
+    def read_text(self, filename: str) -> Optional[str]:
+        try:
+            data = self._files[pathlib.PurePosixPath(filename)]
+        except KeyError:
+            return None
+        try:
+            text = data.decode("utf-8")
+        except UnicodeDecodeError as e:
+            wheel = self.info_location.parent
+            error = f"Error decoding metadata for {wheel}: {e} in {filename} file"
+            raise UnsupportedWheel(error)
+        return text
+
+
+class Distribution(BaseDistribution):
+    def __init__(
+        self,
+        dist: importlib.metadata.Distribution,
+        info_location: Optional[BasePath],
+        installed_location: Optional[BasePath],
+    ) -> None:
+        self._dist = dist
+        self._info_location = info_location
+        self._installed_location = installed_location
+
+    @classmethod
+    def from_directory(cls, directory: str) -> BaseDistribution:
+        info_location = pathlib.Path(directory)
+        dist = importlib.metadata.Distribution.at(info_location)
+        return cls(dist, info_location, info_location.parent)
+
+    @classmethod
+    def from_metadata_file_contents(
+        cls,
+        metadata_contents: bytes,
+        filename: str,
+        project_name: str,
+    ) -> BaseDistribution:
+        # Generate temp dir to contain the metadata file, and write the file contents.
+        temp_dir = pathlib.Path(
+            TempDirectory(kind="metadata", globally_managed=True).path
+        )
+        metadata_path = temp_dir / "METADATA"
+        metadata_path.write_bytes(metadata_contents)
+        # Construct dist pointing to the newly created directory.
+        dist = importlib.metadata.Distribution.at(metadata_path.parent)
+        return cls(dist, metadata_path.parent, None)
+
+    @classmethod
+    def from_wheel(cls, wheel: Wheel, name: str) -> BaseDistribution:
+        try:
+            with wheel.as_zipfile() as zf:
+                dist = WheelDistribution.from_zipfile(zf, name, wheel.location)
+        except zipfile.BadZipFile as e:
+            raise InvalidWheel(wheel.location, name) from e
+        return cls(dist, dist.info_location, pathlib.PurePosixPath(wheel.location))
+
+    @property
+    def location(self) -> Optional[str]:
+        if self._info_location is None:
+            return None
+        return str(self._info_location.parent)
+
+    @property
+    def info_location(self) -> Optional[str]:
+        if self._info_location is None:
+            return None
+        return str(self._info_location)
+
+    @property
+    def installed_location(self) -> Optional[str]:
+        if self._installed_location is None:
+            return None
+        return normalize_path(str(self._installed_location))
+
+    @property
+    def canonical_name(self) -> NormalizedName:
+        return get_dist_canonical_name(self._dist)
+
+    @property
+    def version(self) -> Version:
+        if version := parse_name_and_version_from_info_directory(self._dist)[1]:
+            return parse_version(version)
+        return parse_version(self._dist.version)
+
+    @property
+    def raw_version(self) -> str:
+        return self._dist.version
+
+    def is_file(self, path: InfoPath) -> bool:
+        return self._dist.read_text(str(path)) is not None
+
+    def iter_distutils_script_names(self) -> Iterator[str]:
+        # A distutils installation is always "flat" (not in e.g. egg form), so
+        # if this distribution's info location is NOT a pathlib.Path (but e.g.
+        # zipfile.Path), it can never contain any distutils scripts.
+        if not isinstance(self._info_location, pathlib.Path):
+            return
+        for child in self._info_location.joinpath("scripts").iterdir():
+            yield child.name
+
+    def read_text(self, path: InfoPath) -> str:
+        content = self._dist.read_text(str(path))
+        if content is None:
+            raise FileNotFoundError(path)
+        return content
+
+    def iter_entry_points(self) -> Iterable[BaseEntryPoint]:
+        # importlib.metadata's EntryPoint structure sasitfies BaseEntryPoint.
+        return self._dist.entry_points
+
+    def _metadata_impl(self) -> email.message.Message:
+        # From Python 3.10+, importlib.metadata declares PackageMetadata as the
+        # return type. This protocol is unfortunately a disaster now and misses
+        # a ton of fields that we need, including get() and get_payload(). We
+        # rely on the implementation that the object is actually a Message now,
+        # until upstream can improve the protocol. (python/cpython#94952)
+        return cast(email.message.Message, self._dist.metadata)
+
+    def iter_provided_extras(self) -> Iterable[NormalizedName]:
+        return [
+            canonicalize_name(extra)
+            for extra in self.metadata.get_all("Provides-Extra", [])
+        ]
+
+    def iter_dependencies(self, extras: Collection[str] = ()) -> Iterable[Requirement]:
+        contexts: Sequence[Dict[str, str]] = [{"extra": e} for e in extras]
+        for req_string in self.metadata.get_all("Requires-Dist", []):
+            # strip() because email.message.Message.get_all() may return a leading \n
+            # in case a long header was wrapped.
+            req = get_requirement(req_string.strip())
+            if not req.marker:
+                yield req
+            elif not extras and req.marker.evaluate({"extra": ""}):
+                yield req
+            elif any(req.marker.evaluate(context) for context in contexts):
+                yield req
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/metadata/importlib/_envs.py b/venv/lib/python3.12/site-packages/pip/_internal/metadata/importlib/_envs.py
new file mode 100644
index 00000000..70cb7a60
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/metadata/importlib/_envs.py
@@ -0,0 +1,189 @@
+import functools
+import importlib.metadata
+import logging
+import os
+import pathlib
+import sys
+import zipfile
+import zipimport
+from typing import Iterator, List, Optional, Sequence, Set, Tuple
+
+from pip._vendor.packaging.utils import NormalizedName, canonicalize_name
+
+from pip._internal.metadata.base import BaseDistribution, BaseEnvironment
+from pip._internal.models.wheel import Wheel
+from pip._internal.utils.deprecation import deprecated
+from pip._internal.utils.filetypes import WHEEL_EXTENSION
+
+from ._compat import BadMetadata, BasePath, get_dist_canonical_name, get_info_location
+from ._dists import Distribution
+
+logger = logging.getLogger(__name__)
+
+
+def _looks_like_wheel(location: str) -> bool:
+    if not location.endswith(WHEEL_EXTENSION):
+        return False
+    if not os.path.isfile(location):
+        return False
+    if not Wheel.wheel_file_re.match(os.path.basename(location)):
+        return False
+    return zipfile.is_zipfile(location)
+
+
+class _DistributionFinder:
+    """Finder to locate distributions.
+
+    The main purpose of this class is to memoize found distributions' names, so
+    only one distribution is returned for each package name. At lot of pip code
+    assumes this (because it is setuptools's behavior), and not doing the same
+    can potentially cause a distribution in lower precedence path to override a
+    higher precedence one if the caller is not careful.
+
+    Eventually we probably want to make it possible to see lower precedence
+    installations as well. It's useful feature, after all.
+    """
+
+    FoundResult = Tuple[importlib.metadata.Distribution, Optional[BasePath]]
+
+    def __init__(self) -> None:
+        self._found_names: Set[NormalizedName] = set()
+
+    def _find_impl(self, location: str) -> Iterator[FoundResult]:
+        """Find distributions in a location."""
+        # Skip looking inside a wheel. Since a package inside a wheel is not
+        # always valid (due to .data directories etc.), its .dist-info entry
+        # should not be considered an installed distribution.
+        if _looks_like_wheel(location):
+            return
+        # To know exactly where we find a distribution, we have to feed in the
+        # paths one by one, instead of dumping the list to importlib.metadata.
+        for dist in importlib.metadata.distributions(path=[location]):
+            info_location = get_info_location(dist)
+            try:
+                name = get_dist_canonical_name(dist)
+            except BadMetadata as e:
+                logger.warning("Skipping %s due to %s", info_location, e.reason)
+                continue
+            if name in self._found_names:
+                continue
+            self._found_names.add(name)
+            yield dist, info_location
+
+    def find(self, location: str) -> Iterator[BaseDistribution]:
+        """Find distributions in a location.
+
+        The path can be either a directory, or a ZIP archive.
+        """
+        for dist, info_location in self._find_impl(location):
+            if info_location is None:
+                installed_location: Optional[BasePath] = None
+            else:
+                installed_location = info_location.parent
+            yield Distribution(dist, info_location, installed_location)
+
+    def find_linked(self, location: str) -> Iterator[BaseDistribution]:
+        """Read location in egg-link files and return distributions in there.
+
+        The path should be a directory; otherwise this returns nothing. This
+        follows how setuptools does this for compatibility. The first non-empty
+        line in the egg-link is read as a path (resolved against the egg-link's
+        containing directory if relative). Distributions found at that linked
+        location are returned.
+        """
+        path = pathlib.Path(location)
+        if not path.is_dir():
+            return
+        for child in path.iterdir():
+            if child.suffix != ".egg-link":
+                continue
+            with child.open() as f:
+                lines = (line.strip() for line in f)
+                target_rel = next((line for line in lines if line), "")
+            if not target_rel:
+                continue
+            target_location = str(path.joinpath(target_rel))
+            for dist, info_location in self._find_impl(target_location):
+                yield Distribution(dist, info_location, path)
+
+    def _find_eggs_in_dir(self, location: str) -> Iterator[BaseDistribution]:
+        from pip._vendor.pkg_resources import find_distributions
+
+        from pip._internal.metadata import pkg_resources as legacy
+
+        with os.scandir(location) as it:
+            for entry in it:
+                if not entry.name.endswith(".egg"):
+                    continue
+                for dist in find_distributions(entry.path):
+                    yield legacy.Distribution(dist)
+
+    def _find_eggs_in_zip(self, location: str) -> Iterator[BaseDistribution]:
+        from pip._vendor.pkg_resources import find_eggs_in_zip
+
+        from pip._internal.metadata import pkg_resources as legacy
+
+        try:
+            importer = zipimport.zipimporter(location)
+        except zipimport.ZipImportError:
+            return
+        for dist in find_eggs_in_zip(importer, location):
+            yield legacy.Distribution(dist)
+
+    def find_eggs(self, location: str) -> Iterator[BaseDistribution]:
+        """Find eggs in a location.
+
+        This actually uses the old *pkg_resources* backend. We likely want to
+        deprecate this so we can eventually remove the *pkg_resources*
+        dependency entirely. Before that, this should first emit a deprecation
+        warning for some versions when using the fallback since importing
+        *pkg_resources* is slow for those who don't need it.
+        """
+        if os.path.isdir(location):
+            yield from self._find_eggs_in_dir(location)
+        if zipfile.is_zipfile(location):
+            yield from self._find_eggs_in_zip(location)
+
+
+@functools.lru_cache(maxsize=None)  # Warn a distribution exactly once.
+def _emit_egg_deprecation(location: Optional[str]) -> None:
+    deprecated(
+        reason=f"Loading egg at {location} is deprecated.",
+        replacement="to use pip for package installation",
+        gone_in="24.3",
+        issue=12330,
+    )
+
+
+class Environment(BaseEnvironment):
+    def __init__(self, paths: Sequence[str]) -> None:
+        self._paths = paths
+
+    @classmethod
+    def default(cls) -> BaseEnvironment:
+        return cls(sys.path)
+
+    @classmethod
+    def from_paths(cls, paths: Optional[List[str]]) -> BaseEnvironment:
+        if paths is None:
+            return cls(sys.path)
+        return cls(paths)
+
+    def _iter_distributions(self) -> Iterator[BaseDistribution]:
+        finder = _DistributionFinder()
+        for location in self._paths:
+            yield from finder.find(location)
+            for dist in finder.find_eggs(location):
+                _emit_egg_deprecation(dist.location)
+                yield dist
+            # This must go last because that's how pkg_resources tie-breaks.
+            yield from finder.find_linked(location)
+
+    def get_distribution(self, name: str) -> Optional[BaseDistribution]:
+        canonical_name = canonicalize_name(name)
+        matches = (
+            distribution
+            for distribution in self.iter_all_distributions()
+            if distribution.canonical_name == canonical_name
+        )
+        return next(matches, None)
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/metadata/pkg_resources.py b/venv/lib/python3.12/site-packages/pip/_internal/metadata/pkg_resources.py
new file mode 100644
index 00000000..4ea84f93
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/metadata/pkg_resources.py
@@ -0,0 +1,301 @@
+import email.message
+import email.parser
+import logging
+import os
+import zipfile
+from typing import (
+    Collection,
+    Iterable,
+    Iterator,
+    List,
+    Mapping,
+    NamedTuple,
+    Optional,
+)
+
+from pip._vendor import pkg_resources
+from pip._vendor.packaging.requirements import Requirement
+from pip._vendor.packaging.utils import NormalizedName, canonicalize_name
+from pip._vendor.packaging.version import Version
+from pip._vendor.packaging.version import parse as parse_version
+
+from pip._internal.exceptions import InvalidWheel, NoneMetadataError, UnsupportedWheel
+from pip._internal.utils.egg_link import egg_link_path_from_location
+from pip._internal.utils.misc import display_path, normalize_path
+from pip._internal.utils.wheel import parse_wheel, read_wheel_metadata_file
+
+from .base import (
+    BaseDistribution,
+    BaseEntryPoint,
+    BaseEnvironment,
+    InfoPath,
+    Wheel,
+)
+
+__all__ = ["NAME", "Distribution", "Environment"]
+
+logger = logging.getLogger(__name__)
+
+NAME = "pkg_resources"
+
+
+class EntryPoint(NamedTuple):
+    name: str
+    value: str
+    group: str
+
+
+class InMemoryMetadata:
+    """IMetadataProvider that reads metadata files from a dictionary.
+
+    This also maps metadata decoding exceptions to our internal exception type.
+    """
+
+    def __init__(self, metadata: Mapping[str, bytes], wheel_name: str) -> None:
+        self._metadata = metadata
+        self._wheel_name = wheel_name
+
+    def has_metadata(self, name: str) -> bool:
+        return name in self._metadata
+
+    def get_metadata(self, name: str) -> str:
+        try:
+            return self._metadata[name].decode()
+        except UnicodeDecodeError as e:
+            # Augment the default error with the origin of the file.
+            raise UnsupportedWheel(
+                f"Error decoding metadata for {self._wheel_name}: {e} in {name} file"
+            )
+
+    def get_metadata_lines(self, name: str) -> Iterable[str]:
+        return pkg_resources.yield_lines(self.get_metadata(name))
+
+    def metadata_isdir(self, name: str) -> bool:
+        return False
+
+    def metadata_listdir(self, name: str) -> List[str]:
+        return []
+
+    def run_script(self, script_name: str, namespace: str) -> None:
+        pass
+
+
+class Distribution(BaseDistribution):
+    def __init__(self, dist: pkg_resources.Distribution) -> None:
+        self._dist = dist
+        # This is populated lazily, to avoid loading metadata for all possible
+        # distributions eagerly.
+        self.__extra_mapping: Optional[Mapping[NormalizedName, str]] = None
+
+    @property
+    def _extra_mapping(self) -> Mapping[NormalizedName, str]:
+        if self.__extra_mapping is None:
+            self.__extra_mapping = {
+                canonicalize_name(extra): extra for extra in self._dist.extras
+            }
+
+        return self.__extra_mapping
+
+    @classmethod
+    def from_directory(cls, directory: str) -> BaseDistribution:
+        dist_dir = directory.rstrip(os.sep)
+
+        # Build a PathMetadata object, from path to metadata. :wink:
+        base_dir, dist_dir_name = os.path.split(dist_dir)
+        metadata = pkg_resources.PathMetadata(base_dir, dist_dir)
+
+        # Determine the correct Distribution object type.
+        if dist_dir.endswith(".egg-info"):
+            dist_cls = pkg_resources.Distribution
+            dist_name = os.path.splitext(dist_dir_name)[0]
+        else:
+            assert dist_dir.endswith(".dist-info")
+            dist_cls = pkg_resources.DistInfoDistribution
+            dist_name = os.path.splitext(dist_dir_name)[0].split("-")[0]
+
+        dist = dist_cls(base_dir, project_name=dist_name, metadata=metadata)
+        return cls(dist)
+
+    @classmethod
+    def from_metadata_file_contents(
+        cls,
+        metadata_contents: bytes,
+        filename: str,
+        project_name: str,
+    ) -> BaseDistribution:
+        metadata_dict = {
+            "METADATA": metadata_contents,
+        }
+        dist = pkg_resources.DistInfoDistribution(
+            location=filename,
+            metadata=InMemoryMetadata(metadata_dict, filename),
+            project_name=project_name,
+        )
+        return cls(dist)
+
+    @classmethod
+    def from_wheel(cls, wheel: Wheel, name: str) -> BaseDistribution:
+        try:
+            with wheel.as_zipfile() as zf:
+                info_dir, _ = parse_wheel(zf, name)
+                metadata_dict = {
+                    path.split("/", 1)[-1]: read_wheel_metadata_file(zf, path)
+                    for path in zf.namelist()
+                    if path.startswith(f"{info_dir}/")
+                }
+        except zipfile.BadZipFile as e:
+            raise InvalidWheel(wheel.location, name) from e
+        except UnsupportedWheel as e:
+            raise UnsupportedWheel(f"{name} has an invalid wheel, {e}")
+        dist = pkg_resources.DistInfoDistribution(
+            location=wheel.location,
+            metadata=InMemoryMetadata(metadata_dict, wheel.location),
+            project_name=name,
+        )
+        return cls(dist)
+
+    @property
+    def location(self) -> Optional[str]:
+        return self._dist.location
+
+    @property
+    def installed_location(self) -> Optional[str]:
+        egg_link = egg_link_path_from_location(self.raw_name)
+        if egg_link:
+            location = egg_link
+        elif self.location:
+            location = self.location
+        else:
+            return None
+        return normalize_path(location)
+
+    @property
+    def info_location(self) -> Optional[str]:
+        return self._dist.egg_info
+
+    @property
+    def installed_by_distutils(self) -> bool:
+        # A distutils-installed distribution is provided by FileMetadata. This
+        # provider has a "path" attribute not present anywhere else. Not the
+        # best introspection logic, but pip has been doing this for a long time.
+        try:
+            return bool(self._dist._provider.path)
+        except AttributeError:
+            return False
+
+    @property
+    def canonical_name(self) -> NormalizedName:
+        return canonicalize_name(self._dist.project_name)
+
+    @property
+    def version(self) -> Version:
+        return parse_version(self._dist.version)
+
+    @property
+    def raw_version(self) -> str:
+        return self._dist.version
+
+    def is_file(self, path: InfoPath) -> bool:
+        return self._dist.has_metadata(str(path))
+
+    def iter_distutils_script_names(self) -> Iterator[str]:
+        yield from self._dist.metadata_listdir("scripts")
+
+    def read_text(self, path: InfoPath) -> str:
+        name = str(path)
+        if not self._dist.has_metadata(name):
+            raise FileNotFoundError(name)
+        content = self._dist.get_metadata(name)
+        if content is None:
+            raise NoneMetadataError(self, name)
+        return content
+
+    def iter_entry_points(self) -> Iterable[BaseEntryPoint]:
+        for group, entries in self._dist.get_entry_map().items():
+            for name, entry_point in entries.items():
+                name, _, value = str(entry_point).partition("=")
+                yield EntryPoint(name=name.strip(), value=value.strip(), group=group)
+
+    def _metadata_impl(self) -> email.message.Message:
+        """
+        :raises NoneMetadataError: if the distribution reports `has_metadata()`
+            True but `get_metadata()` returns None.
+        """
+        if isinstance(self._dist, pkg_resources.DistInfoDistribution):
+            metadata_name = "METADATA"
+        else:
+            metadata_name = "PKG-INFO"
+        try:
+            metadata = self.read_text(metadata_name)
+        except FileNotFoundError:
+            if self.location:
+                displaying_path = display_path(self.location)
+            else:
+                displaying_path = repr(self.location)
+            logger.warning("No metadata found in %s", displaying_path)
+            metadata = ""
+        feed_parser = email.parser.FeedParser()
+        feed_parser.feed(metadata)
+        return feed_parser.close()
+
+    def iter_dependencies(self, extras: Collection[str] = ()) -> Iterable[Requirement]:
+        if extras:
+            relevant_extras = set(self._extra_mapping) & set(
+                map(canonicalize_name, extras)
+            )
+            extras = [self._extra_mapping[extra] for extra in relevant_extras]
+        return self._dist.requires(extras)
+
+    def iter_provided_extras(self) -> Iterable[NormalizedName]:
+        return self._extra_mapping.keys()
+
+
+class Environment(BaseEnvironment):
+    def __init__(self, ws: pkg_resources.WorkingSet) -> None:
+        self._ws = ws
+
+    @classmethod
+    def default(cls) -> BaseEnvironment:
+        return cls(pkg_resources.working_set)
+
+    @classmethod
+    def from_paths(cls, paths: Optional[List[str]]) -> BaseEnvironment:
+        return cls(pkg_resources.WorkingSet(paths))
+
+    def _iter_distributions(self) -> Iterator[BaseDistribution]:
+        for dist in self._ws:
+            yield Distribution(dist)
+
+    def _search_distribution(self, name: str) -> Optional[BaseDistribution]:
+        """Find a distribution matching the ``name`` in the environment.
+
+        This searches from *all* distributions available in the environment, to
+        match the behavior of ``pkg_resources.get_distribution()``.
+        """
+        canonical_name = canonicalize_name(name)
+        for dist in self.iter_all_distributions():
+            if dist.canonical_name == canonical_name:
+                return dist
+        return None
+
+    def get_distribution(self, name: str) -> Optional[BaseDistribution]:
+        # Search the distribution by looking through the working set.
+        dist = self._search_distribution(name)
+        if dist:
+            return dist
+
+        # If distribution could not be found, call working_set.require to
+        # update the working set, and try to find the distribution again.
+        # This might happen for e.g. when you install a package twice, once
+        # using setup.py develop and again using setup.py install. Now when
+        # running pip uninstall twice, the package gets removed from the
+        # working set in the first uninstall, so we have to populate the
+        # working set again so that pip knows about it and the packages gets
+        # picked up and is successfully uninstalled the second time too.
+        try:
+            # We didn't pass in any version specifiers, so this can never
+            # raise pkg_resources.VersionConflict.
+            self._ws.require(name)
+        except pkg_resources.DistributionNotFound:
+            return None
+        return self._search_distribution(name)
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/models/__init__.py b/venv/lib/python3.12/site-packages/pip/_internal/models/__init__.py
new file mode 100644
index 00000000..7855226e
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/models/__init__.py
@@ -0,0 +1,2 @@
+"""A package that contains models that represent entities.
+"""
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/models/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/models/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 00000000..f752f2f1
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/models/__pycache__/__init__.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/models/__pycache__/candidate.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/models/__pycache__/candidate.cpython-312.pyc
new file mode 100644
index 00000000..ee5dd3c6
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/models/__pycache__/candidate.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/models/__pycache__/direct_url.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/models/__pycache__/direct_url.cpython-312.pyc
new file mode 100644
index 00000000..0c4bb410
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/models/__pycache__/direct_url.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/models/__pycache__/format_control.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/models/__pycache__/format_control.cpython-312.pyc
new file mode 100644
index 00000000..dce9c001
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/models/__pycache__/format_control.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/models/__pycache__/index.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/models/__pycache__/index.cpython-312.pyc
new file mode 100644
index 00000000..c5debe01
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/models/__pycache__/index.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/models/__pycache__/installation_report.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/models/__pycache__/installation_report.cpython-312.pyc
new file mode 100644
index 00000000..45f08cf5
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/models/__pycache__/installation_report.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/models/__pycache__/link.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/models/__pycache__/link.cpython-312.pyc
new file mode 100644
index 00000000..74c8b0e3
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/models/__pycache__/link.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/models/__pycache__/scheme.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/models/__pycache__/scheme.cpython-312.pyc
new file mode 100644
index 00000000..257f5ec2
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/models/__pycache__/scheme.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/models/__pycache__/search_scope.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/models/__pycache__/search_scope.cpython-312.pyc
new file mode 100644
index 00000000..7673cdfc
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/models/__pycache__/search_scope.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/models/__pycache__/selection_prefs.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/models/__pycache__/selection_prefs.cpython-312.pyc
new file mode 100644
index 00000000..23c076a6
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/models/__pycache__/selection_prefs.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/models/__pycache__/target_python.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/models/__pycache__/target_python.cpython-312.pyc
new file mode 100644
index 00000000..913c2907
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/models/__pycache__/target_python.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/models/__pycache__/wheel.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/models/__pycache__/wheel.cpython-312.pyc
new file mode 100644
index 00000000..fdb318d6
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/models/__pycache__/wheel.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/models/candidate.py b/venv/lib/python3.12/site-packages/pip/_internal/models/candidate.py
new file mode 100644
index 00000000..f27f2831
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/models/candidate.py
@@ -0,0 +1,25 @@
+from dataclasses import dataclass
+
+from pip._vendor.packaging.version import Version
+from pip._vendor.packaging.version import parse as parse_version
+
+from pip._internal.models.link import Link
+
+
+@dataclass(frozen=True)
+class InstallationCandidate:
+    """Represents a potential "candidate" for installation."""
+
+    __slots__ = ["name", "version", "link"]
+
+    name: str
+    version: Version
+    link: Link
+
+    def __init__(self, name: str, version: str, link: Link) -> None:
+        object.__setattr__(self, "name", name)
+        object.__setattr__(self, "version", parse_version(version))
+        object.__setattr__(self, "link", link)
+
+    def __str__(self) -> str:
+        return f"{self.name!r} candidate (version {self.version} at {self.link})"
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/models/direct_url.py b/venv/lib/python3.12/site-packages/pip/_internal/models/direct_url.py
new file mode 100644
index 00000000..fc5ec8d4
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/models/direct_url.py
@@ -0,0 +1,224 @@
+""" PEP 610 """
+
+import json
+import re
+import urllib.parse
+from dataclasses import dataclass
+from typing import Any, ClassVar, Dict, Iterable, Optional, Type, TypeVar, Union
+
+__all__ = [
+    "DirectUrl",
+    "DirectUrlValidationError",
+    "DirInfo",
+    "ArchiveInfo",
+    "VcsInfo",
+]
+
+T = TypeVar("T")
+
+DIRECT_URL_METADATA_NAME = "direct_url.json"
+ENV_VAR_RE = re.compile(r"^\$\{[A-Za-z0-9-_]+\}(:\$\{[A-Za-z0-9-_]+\})?$")
+
+
+class DirectUrlValidationError(Exception):
+    pass
+
+
+def _get(
+    d: Dict[str, Any], expected_type: Type[T], key: str, default: Optional[T] = None
+) -> Optional[T]:
+    """Get value from dictionary and verify expected type."""
+    if key not in d:
+        return default
+    value = d[key]
+    if not isinstance(value, expected_type):
+        raise DirectUrlValidationError(
+            f"{value!r} has unexpected type for {key} (expected {expected_type})"
+        )
+    return value
+
+
+def _get_required(
+    d: Dict[str, Any], expected_type: Type[T], key: str, default: Optional[T] = None
+) -> T:
+    value = _get(d, expected_type, key, default)
+    if value is None:
+        raise DirectUrlValidationError(f"{key} must have a value")
+    return value
+
+
+def _exactly_one_of(infos: Iterable[Optional["InfoType"]]) -> "InfoType":
+    infos = [info for info in infos if info is not None]
+    if not infos:
+        raise DirectUrlValidationError(
+            "missing one of archive_info, dir_info, vcs_info"
+        )
+    if len(infos) > 1:
+        raise DirectUrlValidationError(
+            "more than one of archive_info, dir_info, vcs_info"
+        )
+    assert infos[0] is not None
+    return infos[0]
+
+
+def _filter_none(**kwargs: Any) -> Dict[str, Any]:
+    """Make dict excluding None values."""
+    return {k: v for k, v in kwargs.items() if v is not None}
+
+
+@dataclass
+class VcsInfo:
+    name: ClassVar = "vcs_info"
+
+    vcs: str
+    commit_id: str
+    requested_revision: Optional[str] = None
+
+    @classmethod
+    def _from_dict(cls, d: Optional[Dict[str, Any]]) -> Optional["VcsInfo"]:
+        if d is None:
+            return None
+        return cls(
+            vcs=_get_required(d, str, "vcs"),
+            commit_id=_get_required(d, str, "commit_id"),
+            requested_revision=_get(d, str, "requested_revision"),
+        )
+
+    def _to_dict(self) -> Dict[str, Any]:
+        return _filter_none(
+            vcs=self.vcs,
+            requested_revision=self.requested_revision,
+            commit_id=self.commit_id,
+        )
+
+
+class ArchiveInfo:
+    name = "archive_info"
+
+    def __init__(
+        self,
+        hash: Optional[str] = None,
+        hashes: Optional[Dict[str, str]] = None,
+    ) -> None:
+        # set hashes before hash, since the hash setter will further populate hashes
+        self.hashes = hashes
+        self.hash = hash
+
+    @property
+    def hash(self) -> Optional[str]:
+        return self._hash
+
+    @hash.setter
+    def hash(self, value: Optional[str]) -> None:
+        if value is not None:
+            # Auto-populate the hashes key to upgrade to the new format automatically.
+            # We don't back-populate the legacy hash key from hashes.
+            try:
+                hash_name, hash_value = value.split("=", 1)
+            except ValueError:
+                raise DirectUrlValidationError(
+                    f"invalid archive_info.hash format: {value!r}"
+                )
+            if self.hashes is None:
+                self.hashes = {hash_name: hash_value}
+            elif hash_name not in self.hashes:
+                self.hashes = self.hashes.copy()
+                self.hashes[hash_name] = hash_value
+        self._hash = value
+
+    @classmethod
+    def _from_dict(cls, d: Optional[Dict[str, Any]]) -> Optional["ArchiveInfo"]:
+        if d is None:
+            return None
+        return cls(hash=_get(d, str, "hash"), hashes=_get(d, dict, "hashes"))
+
+    def _to_dict(self) -> Dict[str, Any]:
+        return _filter_none(hash=self.hash, hashes=self.hashes)
+
+
+@dataclass
+class DirInfo:
+    name: ClassVar = "dir_info"
+
+    editable: bool = False
+
+    @classmethod
+    def _from_dict(cls, d: Optional[Dict[str, Any]]) -> Optional["DirInfo"]:
+        if d is None:
+            return None
+        return cls(editable=_get_required(d, bool, "editable", default=False))
+
+    def _to_dict(self) -> Dict[str, Any]:
+        return _filter_none(editable=self.editable or None)
+
+
+InfoType = Union[ArchiveInfo, DirInfo, VcsInfo]
+
+
+@dataclass
+class DirectUrl:
+    url: str
+    info: InfoType
+    subdirectory: Optional[str] = None
+
+    def _remove_auth_from_netloc(self, netloc: str) -> str:
+        if "@" not in netloc:
+            return netloc
+        user_pass, netloc_no_user_pass = netloc.split("@", 1)
+        if (
+            isinstance(self.info, VcsInfo)
+            and self.info.vcs == "git"
+            and user_pass == "git"
+        ):
+            return netloc
+        if ENV_VAR_RE.match(user_pass):
+            return netloc
+        return netloc_no_user_pass
+
+    @property
+    def redacted_url(self) -> str:
+        """url with user:password part removed unless it is formed with
+        environment variables as specified in PEP 610, or it is ``git``
+        in the case of a git URL.
+        """
+        purl = urllib.parse.urlsplit(self.url)
+        netloc = self._remove_auth_from_netloc(purl.netloc)
+        surl = urllib.parse.urlunsplit(
+            (purl.scheme, netloc, purl.path, purl.query, purl.fragment)
+        )
+        return surl
+
+    def validate(self) -> None:
+        self.from_dict(self.to_dict())
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> "DirectUrl":
+        return DirectUrl(
+            url=_get_required(d, str, "url"),
+            subdirectory=_get(d, str, "subdirectory"),
+            info=_exactly_one_of(
+                [
+                    ArchiveInfo._from_dict(_get(d, dict, "archive_info")),
+                    DirInfo._from_dict(_get(d, dict, "dir_info")),
+                    VcsInfo._from_dict(_get(d, dict, "vcs_info")),
+                ]
+            ),
+        )
+
+    def to_dict(self) -> Dict[str, Any]:
+        res = _filter_none(
+            url=self.redacted_url,
+            subdirectory=self.subdirectory,
+        )
+        res[self.info.name] = self.info._to_dict()
+        return res
+
+    @classmethod
+    def from_json(cls, s: str) -> "DirectUrl":
+        return cls.from_dict(json.loads(s))
+
+    def to_json(self) -> str:
+        return json.dumps(self.to_dict(), sort_keys=True)
+
+    def is_local_editable(self) -> bool:
+        return isinstance(self.info, DirInfo) and self.info.editable
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/models/format_control.py b/venv/lib/python3.12/site-packages/pip/_internal/models/format_control.py
new file mode 100644
index 00000000..ccd11272
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/models/format_control.py
@@ -0,0 +1,78 @@
+from typing import FrozenSet, Optional, Set
+
+from pip._vendor.packaging.utils import canonicalize_name
+
+from pip._internal.exceptions import CommandError
+
+
+class FormatControl:
+    """Helper for managing formats from which a package can be installed."""
+
+    __slots__ = ["no_binary", "only_binary"]
+
+    def __init__(
+        self,
+        no_binary: Optional[Set[str]] = None,
+        only_binary: Optional[Set[str]] = None,
+    ) -> None:
+        if no_binary is None:
+            no_binary = set()
+        if only_binary is None:
+            only_binary = set()
+
+        self.no_binary = no_binary
+        self.only_binary = only_binary
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, self.__class__):
+            return NotImplemented
+
+        if self.__slots__ != other.__slots__:
+            return False
+
+        return all(getattr(self, k) == getattr(other, k) for k in self.__slots__)
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}({self.no_binary}, {self.only_binary})"
+
+    @staticmethod
+    def handle_mutual_excludes(value: str, target: Set[str], other: Set[str]) -> None:
+        if value.startswith("-"):
+            raise CommandError(
+                "--no-binary / --only-binary option requires 1 argument."
+            )
+        new = value.split(",")
+        while ":all:" in new:
+            other.clear()
+            target.clear()
+            target.add(":all:")
+            del new[: new.index(":all:") + 1]
+            # Without a none, we want to discard everything as :all: covers it
+            if ":none:" not in new:
+                return
+        for name in new:
+            if name == ":none:":
+                target.clear()
+                continue
+            name = canonicalize_name(name)
+            other.discard(name)
+            target.add(name)
+
+    def get_allowed_formats(self, canonical_name: str) -> FrozenSet[str]:
+        result = {"binary", "source"}
+        if canonical_name in self.only_binary:
+            result.discard("source")
+        elif canonical_name in self.no_binary:
+            result.discard("binary")
+        elif ":all:" in self.only_binary:
+            result.discard("source")
+        elif ":all:" in self.no_binary:
+            result.discard("binary")
+        return frozenset(result)
+
+    def disallow_binaries(self) -> None:
+        self.handle_mutual_excludes(
+            ":all:",
+            self.no_binary,
+            self.only_binary,
+        )
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/models/index.py b/venv/lib/python3.12/site-packages/pip/_internal/models/index.py
new file mode 100644
index 00000000..b94c3251
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/models/index.py
@@ -0,0 +1,28 @@
+import urllib.parse
+
+
+class PackageIndex:
+    """Represents a Package Index and provides easier access to endpoints"""
+
+    __slots__ = ["url", "netloc", "simple_url", "pypi_url", "file_storage_domain"]
+
+    def __init__(self, url: str, file_storage_domain: str) -> None:
+        super().__init__()
+        self.url = url
+        self.netloc = urllib.parse.urlsplit(url).netloc
+        self.simple_url = self._url_for_path("simple")
+        self.pypi_url = self._url_for_path("pypi")
+
+        # This is part of a temporary hack used to block installs of PyPI
+        # packages which depend on external urls only necessary until PyPI can
+        # block such packages themselves
+        self.file_storage_domain = file_storage_domain
+
+    def _url_for_path(self, path: str) -> str:
+        return urllib.parse.urljoin(self.url, path)
+
+
+PyPI = PackageIndex("https://pypi.org/", file_storage_domain="files.pythonhosted.org")
+TestPyPI = PackageIndex(
+    "https://test.pypi.org/", file_storage_domain="test-files.pythonhosted.org"
+)
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/models/installation_report.py b/venv/lib/python3.12/site-packages/pip/_internal/models/installation_report.py
new file mode 100644
index 00000000..b9c6330d
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/models/installation_report.py
@@ -0,0 +1,56 @@
+from typing import Any, Dict, Sequence
+
+from pip._vendor.packaging.markers import default_environment
+
+from pip import __version__
+from pip._internal.req.req_install import InstallRequirement
+
+
+class InstallationReport:
+    def __init__(self, install_requirements: Sequence[InstallRequirement]):
+        self._install_requirements = install_requirements
+
+    @classmethod
+    def _install_req_to_dict(cls, ireq: InstallRequirement) -> Dict[str, Any]:
+        assert ireq.download_info, f"No download_info for {ireq}"
+        res = {
+            # PEP 610 json for the download URL. download_info.archive_info.hashes may
+            # be absent when the requirement was installed from the wheel cache
+            # and the cache entry was populated by an older pip version that did not
+            # record origin.json.
+            "download_info": ireq.download_info.to_dict(),
+            # is_direct is true if the requirement was a direct URL reference (which
+            # includes editable requirements), and false if the requirement was
+            # downloaded from a PEP 503 index or --find-links.
+            "is_direct": ireq.is_direct,
+            # is_yanked is true if the requirement was yanked from the index, but
+            # was still selected by pip to conform to PEP 592.
+            "is_yanked": ireq.link.is_yanked if ireq.link else False,
+            # requested is true if the requirement was specified by the user (aka
+            # top level requirement), and false if it was installed as a dependency of a
+            # requirement. https://peps.python.org/pep-0376/#requested
+            "requested": ireq.user_supplied,
+            # PEP 566 json encoding for metadata
+            # https://www.python.org/dev/peps/pep-0566/#json-compatible-metadata
+            "metadata": ireq.get_dist().metadata_dict,
+        }
+        if ireq.user_supplied and ireq.extras:
+            # For top level requirements, the list of requested extras, if any.
+            res["requested_extras"] = sorted(ireq.extras)
+        return res
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "version": "1",
+            "pip_version": __version__,
+            "install": [
+                self._install_req_to_dict(ireq) for ireq in self._install_requirements
+            ],
+            # https://peps.python.org/pep-0508/#environment-markers
+            # TODO: currently, the resolver uses the default environment to evaluate
+            # environment markers, so that is what we report here. In the future, it
+            # should also take into account options such as --python-version or
+            # --platform, perhaps under the form of an environment_override field?
+            # https://github.com/pypa/pip/issues/11198
+            "environment": default_environment(),
+        }
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/models/link.py b/venv/lib/python3.12/site-packages/pip/_internal/models/link.py
new file mode 100644
index 00000000..2f41f2f6
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/models/link.py
@@ -0,0 +1,590 @@
+import functools
+import itertools
+import logging
+import os
+import posixpath
+import re
+import urllib.parse
+from dataclasses import dataclass
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Dict,
+    List,
+    Mapping,
+    NamedTuple,
+    Optional,
+    Tuple,
+    Union,
+)
+
+from pip._internal.utils.deprecation import deprecated
+from pip._internal.utils.filetypes import WHEEL_EXTENSION
+from pip._internal.utils.hashes import Hashes
+from pip._internal.utils.misc import (
+    pairwise,
+    redact_auth_from_url,
+    split_auth_from_netloc,
+    splitext,
+)
+from pip._internal.utils.urls import path_to_url, url_to_path
+
+if TYPE_CHECKING:
+    from pip._internal.index.collector import IndexContent
+
+logger = logging.getLogger(__name__)
+
+
+# Order matters, earlier hashes have a precedence over later hashes for what
+# we will pick to use.
+_SUPPORTED_HASHES = ("sha512", "sha384", "sha256", "sha224", "sha1", "md5")
+
+
+@dataclass(frozen=True)
+class LinkHash:
+    """Links to content may have embedded hash values. This class parses those.
+
+    `name` must be any member of `_SUPPORTED_HASHES`.
+
+    This class can be converted to and from `ArchiveInfo`. While ArchiveInfo intends to
+    be JSON-serializable to conform to PEP 610, this class contains the logic for
+    parsing a hash name and value for correctness, and then checking whether that hash
+    conforms to a schema with `.is_hash_allowed()`."""
+
+    name: str
+    value: str
+
+    _hash_url_fragment_re = re.compile(
+        # NB: we do not validate that the second group (.*) is a valid hex
+        # digest. Instead, we simply keep that string in this class, and then check it
+        # against Hashes when hash-checking is needed. This is easier to debug than
+        # proactively discarding an invalid hex digest, as we handle incorrect hashes
+        # and malformed hashes in the same place.
+        r"[#&]({choices})=([^&]*)".format(
+            choices="|".join(re.escape(hash_name) for hash_name in _SUPPORTED_HASHES)
+        ),
+    )
+
+    def __post_init__(self) -> None:
+        assert self.name in _SUPPORTED_HASHES
+
+    @classmethod
+    @functools.lru_cache(maxsize=None)
+    def find_hash_url_fragment(cls, url: str) -> Optional["LinkHash"]:
+        """Search a string for a checksum algorithm name and encoded output value."""
+        match = cls._hash_url_fragment_re.search(url)
+        if match is None:
+            return None
+        name, value = match.groups()
+        return cls(name=name, value=value)
+
+    def as_dict(self) -> Dict[str, str]:
+        return {self.name: self.value}
+
+    def as_hashes(self) -> Hashes:
+        """Return a Hashes instance which checks only for the current hash."""
+        return Hashes({self.name: [self.value]})
+
+    def is_hash_allowed(self, hashes: Optional[Hashes]) -> bool:
+        """
+        Return True if the current hash is allowed by `hashes`.
+        """
+        if hashes is None:
+            return False
+        return hashes.is_hash_allowed(self.name, hex_digest=self.value)
+
+
+@dataclass(frozen=True)
+class MetadataFile:
+    """Information about a core metadata file associated with a distribution."""
+
+    hashes: Optional[Dict[str, str]]
+
+    def __post_init__(self) -> None:
+        if self.hashes is not None:
+            assert all(name in _SUPPORTED_HASHES for name in self.hashes)
+
+
+def supported_hashes(hashes: Optional[Dict[str, str]]) -> Optional[Dict[str, str]]:
+    # Remove any unsupported hash types from the mapping. If this leaves no
+    # supported hashes, return None
+    if hashes is None:
+        return None
+    hashes = {n: v for n, v in hashes.items() if n in _SUPPORTED_HASHES}
+    if not hashes:
+        return None
+    return hashes
+
+
+def _clean_url_path_part(part: str) -> str:
+    """
+    Clean a "part" of a URL path (i.e. after splitting on "@" characters).
+    """
+    # We unquote prior to quoting to make sure nothing is double quoted.
+    return urllib.parse.quote(urllib.parse.unquote(part))
+
+
+def _clean_file_url_path(part: str) -> str:
+    """
+    Clean the first part of a URL path that corresponds to a local
+    filesystem path (i.e. the first part after splitting on "@" characters).
+    """
+    # We unquote prior to quoting to make sure nothing is double quoted.
+    # Also, on Windows the path part might contain a drive letter which
+    # should not be quoted. On Linux where drive letters do not
+    # exist, the colon should be quoted. We rely on urllib.request
+    # to do the right thing here.
+    return urllib.request.pathname2url(urllib.request.url2pathname(part))
+
+
+# percent-encoded:                   /
+_reserved_chars_re = re.compile("(@|%2F)", re.IGNORECASE)
+
+
+def _clean_url_path(path: str, is_local_path: bool) -> str:
+    """
+    Clean the path portion of a URL.
+    """
+    if is_local_path:
+        clean_func = _clean_file_url_path
+    else:
+        clean_func = _clean_url_path_part
+
+    # Split on the reserved characters prior to cleaning so that
+    # revision strings in VCS URLs are properly preserved.
+    parts = _reserved_chars_re.split(path)
+
+    cleaned_parts = []
+    for to_clean, reserved in pairwise(itertools.chain(parts, [""])):
+        cleaned_parts.append(clean_func(to_clean))
+        # Normalize %xx escapes (e.g. %2f -> %2F)
+        cleaned_parts.append(reserved.upper())
+
+    return "".join(cleaned_parts)
+
+
+def _ensure_quoted_url(url: str) -> str:
+    """
+    Make sure a link is fully quoted.
+    For example, if ' ' occurs in the URL, it will be replaced with "%20",
+    and without double-quoting other characters.
+    """
+    # Split the URL into parts according to the general structure
+    # `scheme://netloc/path;parameters?query#fragment`.
+    result = urllib.parse.urlparse(url)
+    # If the netloc is empty, then the URL refers to a local filesystem path.
+    is_local_path = not result.netloc
+    path = _clean_url_path(result.path, is_local_path=is_local_path)
+    return urllib.parse.urlunparse(result._replace(path=path))
+
+
+@functools.total_ordering
+class Link:
+    """Represents a parsed link from a Package Index's simple URL"""
+
+    __slots__ = [
+        "_parsed_url",
+        "_url",
+        "_hashes",
+        "comes_from",
+        "requires_python",
+        "yanked_reason",
+        "metadata_file_data",
+        "cache_link_parsing",
+        "egg_fragment",
+    ]
+
+    def __init__(
+        self,
+        url: str,
+        comes_from: Optional[Union[str, "IndexContent"]] = None,
+        requires_python: Optional[str] = None,
+        yanked_reason: Optional[str] = None,
+        metadata_file_data: Optional[MetadataFile] = None,
+        cache_link_parsing: bool = True,
+        hashes: Optional[Mapping[str, str]] = None,
+    ) -> None:
+        """
+        :param url: url of the resource pointed to (href of the link)
+        :param comes_from: instance of IndexContent where the link was found,
+            or string.
+        :param requires_python: String containing the `Requires-Python`
+            metadata field, specified in PEP 345. This may be specified by
+            a data-requires-python attribute in the HTML link tag, as
+            described in PEP 503.
+        :param yanked_reason: the reason the file has been yanked, if the
+            file has been yanked, or None if the file hasn't been yanked.
+            This is the value of the "data-yanked" attribute, if present, in
+            a simple repository HTML link. If the file has been yanked but
+            no reason was provided, this should be the empty string. See
+            PEP 592 for more information and the specification.
+        :param metadata_file_data: the metadata attached to the file, or None if
+            no such metadata is provided. This argument, if not None, indicates
+            that a separate metadata file exists, and also optionally supplies
+            hashes for that file.
+        :param cache_link_parsing: A flag that is used elsewhere to determine
+            whether resources retrieved from this link should be cached. PyPI
+            URLs should generally have this set to False, for example.
+        :param hashes: A mapping of hash names to digests to allow us to
+            determine the validity of a download.
+        """
+
+        # The comes_from, requires_python, and metadata_file_data arguments are
+        # only used by classmethods of this class, and are not used in client
+        # code directly.
+
+        # url can be a UNC windows share
+        if url.startswith("\\\\"):
+            url = path_to_url(url)
+
+        self._parsed_url = urllib.parse.urlsplit(url)
+        # Store the url as a private attribute to prevent accidentally
+        # trying to set a new value.
+        self._url = url
+
+        link_hash = LinkHash.find_hash_url_fragment(url)
+        hashes_from_link = {} if link_hash is None else link_hash.as_dict()
+        if hashes is None:
+            self._hashes = hashes_from_link
+        else:
+            self._hashes = {**hashes, **hashes_from_link}
+
+        self.comes_from = comes_from
+        self.requires_python = requires_python if requires_python else None
+        self.yanked_reason = yanked_reason
+        self.metadata_file_data = metadata_file_data
+
+        self.cache_link_parsing = cache_link_parsing
+        self.egg_fragment = self._egg_fragment()
+
+    @classmethod
+    def from_json(
+        cls,
+        file_data: Dict[str, Any],
+        page_url: str,
+    ) -> Optional["Link"]:
+        """
+        Convert an pypi json document from a simple repository page into a Link.
+        """
+        file_url = file_data.get("url")
+        if file_url is None:
+            return None
+
+        url = _ensure_quoted_url(urllib.parse.urljoin(page_url, file_url))
+        pyrequire = file_data.get("requires-python")
+        yanked_reason = file_data.get("yanked")
+        hashes = file_data.get("hashes", {})
+
+        # PEP 714: Indexes must use the name core-metadata, but
+        # clients should support the old name as a fallback for compatibility.
+        metadata_info = file_data.get("core-metadata")
+        if metadata_info is None:
+            metadata_info = file_data.get("dist-info-metadata")
+
+        # The metadata info value may be a boolean, or a dict of hashes.
+        if isinstance(metadata_info, dict):
+            # The file exists, and hashes have been supplied
+            metadata_file_data = MetadataFile(supported_hashes(metadata_info))
+        elif metadata_info:
+            # The file exists, but there are no hashes
+            metadata_file_data = MetadataFile(None)
+        else:
+            # False or not present: the file does not exist
+            metadata_file_data = None
+
+        # The Link.yanked_reason expects an empty string instead of a boolean.
+        if yanked_reason and not isinstance(yanked_reason, str):
+            yanked_reason = ""
+        # The Link.yanked_reason expects None instead of False.
+        elif not yanked_reason:
+            yanked_reason = None
+
+        return cls(
+            url,
+            comes_from=page_url,
+            requires_python=pyrequire,
+            yanked_reason=yanked_reason,
+            hashes=hashes,
+            metadata_file_data=metadata_file_data,
+        )
+
+    @classmethod
+    def from_element(
+        cls,
+        anchor_attribs: Dict[str, Optional[str]],
+        page_url: str,
+        base_url: str,
+    ) -> Optional["Link"]:
+        """
+        Convert an anchor element's attributes in a simple repository page to a Link.
+        """
+        href = anchor_attribs.get("href")
+        if not href:
+            return None
+
+        url = _ensure_quoted_url(urllib.parse.urljoin(base_url, href))
+        pyrequire = anchor_attribs.get("data-requires-python")
+        yanked_reason = anchor_attribs.get("data-yanked")
+
+        # PEP 714: Indexes must use the name data-core-metadata, but
+        # clients should support the old name as a fallback for compatibility.
+        metadata_info = anchor_attribs.get("data-core-metadata")
+        if metadata_info is None:
+            metadata_info = anchor_attribs.get("data-dist-info-metadata")
+        # The metadata info value may be the string "true", or a string of
+        # the form "hashname=hashval"
+        if metadata_info == "true":
+            # The file exists, but there are no hashes
+            metadata_file_data = MetadataFile(None)
+        elif metadata_info is None:
+            # The file does not exist
+            metadata_file_data = None
+        else:
+            # The file exists, and hashes have been supplied
+            hashname, sep, hashval = metadata_info.partition("=")
+            if sep == "=":
+                metadata_file_data = MetadataFile(supported_hashes({hashname: hashval}))
+            else:
+                # Error - data is wrong. Treat as no hashes supplied.
+                logger.debug(
+                    "Index returned invalid data-dist-info-metadata value: %s",
+                    metadata_info,
+                )
+                metadata_file_data = MetadataFile(None)
+
+        return cls(
+            url,
+            comes_from=page_url,
+            requires_python=pyrequire,
+            yanked_reason=yanked_reason,
+            metadata_file_data=metadata_file_data,
+        )
+
+    def __str__(self) -> str:
+        if self.requires_python:
+            rp = f" (requires-python:{self.requires_python})"
+        else:
+            rp = ""
+        if self.comes_from:
+            return f"{redact_auth_from_url(self._url)} (from {self.comes_from}){rp}"
+        else:
+            return redact_auth_from_url(str(self._url))
+
+    def __repr__(self) -> str:
+        return f""
+
+    def __hash__(self) -> int:
+        return hash(self.url)
+
+    def __eq__(self, other: Any) -> bool:
+        if not isinstance(other, Link):
+            return NotImplemented
+        return self.url == other.url
+
+    def __lt__(self, other: Any) -> bool:
+        if not isinstance(other, Link):
+            return NotImplemented
+        return self.url < other.url
+
+    @property
+    def url(self) -> str:
+        return self._url
+
+    @property
+    def filename(self) -> str:
+        path = self.path.rstrip("/")
+        name = posixpath.basename(path)
+        if not name:
+            # Make sure we don't leak auth information if the netloc
+            # includes a username and password.
+            netloc, user_pass = split_auth_from_netloc(self.netloc)
+            return netloc
+
+        name = urllib.parse.unquote(name)
+        assert name, f"URL {self._url!r} produced no filename"
+        return name
+
+    @property
+    def file_path(self) -> str:
+        return url_to_path(self.url)
+
+    @property
+    def scheme(self) -> str:
+        return self._parsed_url.scheme
+
+    @property
+    def netloc(self) -> str:
+        """
+        This can contain auth information.
+        """
+        return self._parsed_url.netloc
+
+    @property
+    def path(self) -> str:
+        return urllib.parse.unquote(self._parsed_url.path)
+
+    def splitext(self) -> Tuple[str, str]:
+        return splitext(posixpath.basename(self.path.rstrip("/")))
+
+    @property
+    def ext(self) -> str:
+        return self.splitext()[1]
+
+    @property
+    def url_without_fragment(self) -> str:
+        scheme, netloc, path, query, fragment = self._parsed_url
+        return urllib.parse.urlunsplit((scheme, netloc, path, query, ""))
+
+    _egg_fragment_re = re.compile(r"[#&]egg=([^&]*)")
+
+    # Per PEP 508.
+    _project_name_re = re.compile(
+        r"^([A-Z0-9]|[A-Z0-9][A-Z0-9._-]*[A-Z0-9])$", re.IGNORECASE
+    )
+
+    def _egg_fragment(self) -> Optional[str]:
+        match = self._egg_fragment_re.search(self._url)
+        if not match:
+            return None
+
+        # An egg fragment looks like a PEP 508 project name, along with
+        # an optional extras specifier. Anything else is invalid.
+        project_name = match.group(1)
+        if not self._project_name_re.match(project_name):
+            deprecated(
+                reason=f"{self} contains an egg fragment with a non-PEP 508 name",
+                replacement="to use the req @ url syntax, and remove the egg fragment",
+                gone_in="25.0",
+                issue=11617,
+            )
+
+        return project_name
+
+    _subdirectory_fragment_re = re.compile(r"[#&]subdirectory=([^&]*)")
+
+    @property
+    def subdirectory_fragment(self) -> Optional[str]:
+        match = self._subdirectory_fragment_re.search(self._url)
+        if not match:
+            return None
+        return match.group(1)
+
+    def metadata_link(self) -> Optional["Link"]:
+        """Return a link to the associated core metadata file (if any)."""
+        if self.metadata_file_data is None:
+            return None
+        metadata_url = f"{self.url_without_fragment}.metadata"
+        if self.metadata_file_data.hashes is None:
+            return Link(metadata_url)
+        return Link(metadata_url, hashes=self.metadata_file_data.hashes)
+
+    def as_hashes(self) -> Hashes:
+        return Hashes({k: [v] for k, v in self._hashes.items()})
+
+    @property
+    def hash(self) -> Optional[str]:
+        return next(iter(self._hashes.values()), None)
+
+    @property
+    def hash_name(self) -> Optional[str]:
+        return next(iter(self._hashes), None)
+
+    @property
+    def show_url(self) -> str:
+        return posixpath.basename(self._url.split("#", 1)[0].split("?", 1)[0])
+
+    @property
+    def is_file(self) -> bool:
+        return self.scheme == "file"
+
+    def is_existing_dir(self) -> bool:
+        return self.is_file and os.path.isdir(self.file_path)
+
+    @property
+    def is_wheel(self) -> bool:
+        return self.ext == WHEEL_EXTENSION
+
+    @property
+    def is_vcs(self) -> bool:
+        from pip._internal.vcs import vcs
+
+        return self.scheme in vcs.all_schemes
+
+    @property
+    def is_yanked(self) -> bool:
+        return self.yanked_reason is not None
+
+    @property
+    def has_hash(self) -> bool:
+        return bool(self._hashes)
+
+    def is_hash_allowed(self, hashes: Optional[Hashes]) -> bool:
+        """
+        Return True if the link has a hash and it is allowed by `hashes`.
+        """
+        if hashes is None:
+            return False
+        return any(hashes.is_hash_allowed(k, v) for k, v in self._hashes.items())
+
+
+class _CleanResult(NamedTuple):
+    """Convert link for equivalency check.
+
+    This is used in the resolver to check whether two URL-specified requirements
+    likely point to the same distribution and can be considered equivalent. This
+    equivalency logic avoids comparing URLs literally, which can be too strict
+    (e.g. "a=1&b=2" vs "b=2&a=1") and produce conflicts unexpecting to users.
+
+    Currently this does three things:
+
+    1. Drop the basic auth part. This is technically wrong since a server can
+       serve different content based on auth, but if it does that, it is even
+       impossible to guarantee two URLs without auth are equivalent, since
+       the user can input different auth information when prompted. So the
+       practical solution is to assume the auth doesn't affect the response.
+    2. Parse the query to avoid the ordering issue. Note that ordering under the
+       same key in the query are NOT cleaned; i.e. "a=1&a=2" and "a=2&a=1" are
+       still considered different.
+    3. Explicitly drop most of the fragment part, except ``subdirectory=`` and
+       hash values, since it should have no impact the downloaded content. Note
+       that this drops the "egg=" part historically used to denote the requested
+       project (and extras), which is wrong in the strictest sense, but too many
+       people are supplying it inconsistently to cause superfluous resolution
+       conflicts, so we choose to also ignore them.
+    """
+
+    parsed: urllib.parse.SplitResult
+    query: Dict[str, List[str]]
+    subdirectory: str
+    hashes: Dict[str, str]
+
+
+def _clean_link(link: Link) -> _CleanResult:
+    parsed = link._parsed_url
+    netloc = parsed.netloc.rsplit("@", 1)[-1]
+    # According to RFC 8089, an empty host in file: means localhost.
+    if parsed.scheme == "file" and not netloc:
+        netloc = "localhost"
+    fragment = urllib.parse.parse_qs(parsed.fragment)
+    if "egg" in fragment:
+        logger.debug("Ignoring egg= fragment in %s", link)
+    try:
+        # If there are multiple subdirectory values, use the first one.
+        # This matches the behavior of Link.subdirectory_fragment.
+        subdirectory = fragment["subdirectory"][0]
+    except (IndexError, KeyError):
+        subdirectory = ""
+    # If there are multiple hash values under the same algorithm, use the
+    # first one. This matches the behavior of Link.hash_value.
+    hashes = {k: fragment[k][0] for k in _SUPPORTED_HASHES if k in fragment}
+    return _CleanResult(
+        parsed=parsed._replace(netloc=netloc, query="", fragment=""),
+        query=urllib.parse.parse_qs(parsed.query),
+        subdirectory=subdirectory,
+        hashes=hashes,
+    )
+
+
+@functools.lru_cache(maxsize=None)
+def links_equivalent(link1: Link, link2: Link) -> bool:
+    return _clean_link(link1) == _clean_link(link2)
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/models/scheme.py b/venv/lib/python3.12/site-packages/pip/_internal/models/scheme.py
new file mode 100644
index 00000000..06a9a550
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/models/scheme.py
@@ -0,0 +1,25 @@
+"""
+For types associated with installation schemes.
+
+For a general overview of available schemes and their context, see
+https://docs.python.org/3/install/index.html#alternate-installation.
+"""
+
+from dataclasses import dataclass
+
+SCHEME_KEYS = ["platlib", "purelib", "headers", "scripts", "data"]
+
+
+@dataclass(frozen=True)
+class Scheme:
+    """A Scheme holds paths which are used as the base directories for
+    artifacts associated with a Python package.
+    """
+
+    __slots__ = SCHEME_KEYS
+
+    platlib: str
+    purelib: str
+    headers: str
+    scripts: str
+    data: str
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/models/search_scope.py b/venv/lib/python3.12/site-packages/pip/_internal/models/search_scope.py
new file mode 100644
index 00000000..ee7bc862
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/models/search_scope.py
@@ -0,0 +1,127 @@
+import itertools
+import logging
+import os
+import posixpath
+import urllib.parse
+from dataclasses import dataclass
+from typing import List
+
+from pip._vendor.packaging.utils import canonicalize_name
+
+from pip._internal.models.index import PyPI
+from pip._internal.utils.compat import has_tls
+from pip._internal.utils.misc import normalize_path, redact_auth_from_url
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass(frozen=True)
+class SearchScope:
+    """
+    Encapsulates the locations that pip is configured to search.
+    """
+
+    __slots__ = ["find_links", "index_urls", "no_index"]
+
+    find_links: List[str]
+    index_urls: List[str]
+    no_index: bool
+
+    @classmethod
+    def create(
+        cls,
+        find_links: List[str],
+        index_urls: List[str],
+        no_index: bool,
+    ) -> "SearchScope":
+        """
+        Create a SearchScope object after normalizing the `find_links`.
+        """
+        # Build find_links. If an argument starts with ~, it may be
+        # a local file relative to a home directory. So try normalizing
+        # it and if it exists, use the normalized version.
+        # This is deliberately conservative - it might be fine just to
+        # blindly normalize anything starting with a ~...
+        built_find_links: List[str] = []
+        for link in find_links:
+            if link.startswith("~"):
+                new_link = normalize_path(link)
+                if os.path.exists(new_link):
+                    link = new_link
+            built_find_links.append(link)
+
+        # If we don't have TLS enabled, then WARN if anyplace we're looking
+        # relies on TLS.
+        if not has_tls():
+            for link in itertools.chain(index_urls, built_find_links):
+                parsed = urllib.parse.urlparse(link)
+                if parsed.scheme == "https":
+                    logger.warning(
+                        "pip is configured with locations that require "
+                        "TLS/SSL, however the ssl module in Python is not "
+                        "available."
+                    )
+                    break
+
+        return cls(
+            find_links=built_find_links,
+            index_urls=index_urls,
+            no_index=no_index,
+        )
+
+    def get_formatted_locations(self) -> str:
+        lines = []
+        redacted_index_urls = []
+        if self.index_urls and self.index_urls != [PyPI.simple_url]:
+            for url in self.index_urls:
+                redacted_index_url = redact_auth_from_url(url)
+
+                # Parse the URL
+                purl = urllib.parse.urlsplit(redacted_index_url)
+
+                # URL is generally invalid if scheme and netloc is missing
+                # there are issues with Python and URL parsing, so this test
+                # is a bit crude. See bpo-20271, bpo-23505. Python doesn't
+                # always parse invalid URLs correctly - it should raise
+                # exceptions for malformed URLs
+                if not purl.scheme and not purl.netloc:
+                    logger.warning(
+                        'The index url "%s" seems invalid, please provide a scheme.',
+                        redacted_index_url,
+                    )
+
+                redacted_index_urls.append(redacted_index_url)
+
+            lines.append(
+                "Looking in indexes: {}".format(", ".join(redacted_index_urls))
+            )
+
+        if self.find_links:
+            lines.append(
+                "Looking in links: {}".format(
+                    ", ".join(redact_auth_from_url(url) for url in self.find_links)
+                )
+            )
+        return "\n".join(lines)
+
+    def get_index_urls_locations(self, project_name: str) -> List[str]:
+        """Returns the locations found via self.index_urls
+
+        Checks the url_name on the main (first in the list) index and
+        use this url_name to produce all locations
+        """
+
+        def mkurl_pypi_url(url: str) -> str:
+            loc = posixpath.join(
+                url, urllib.parse.quote(canonicalize_name(project_name))
+            )
+            # For maximum compatibility with easy_install, ensure the path
+            # ends in a trailing slash.  Although this isn't in the spec
+            # (and PyPI can handle it without the slash) some other index
+            # implementations might break if they relied on easy_install's
+            # behavior.
+            if not loc.endswith("/"):
+                loc = loc + "/"
+            return loc
+
+        return [mkurl_pypi_url(url) for url in self.index_urls]
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/models/selection_prefs.py b/venv/lib/python3.12/site-packages/pip/_internal/models/selection_prefs.py
new file mode 100644
index 00000000..e9b50aa5
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/models/selection_prefs.py
@@ -0,0 +1,53 @@
+from typing import Optional
+
+from pip._internal.models.format_control import FormatControl
+
+
+# TODO: This needs Python 3.10's improved slots support for dataclasses
+# to be converted into a dataclass.
+class SelectionPreferences:
+    """
+    Encapsulates the candidate selection preferences for downloading
+    and installing files.
+    """
+
+    __slots__ = [
+        "allow_yanked",
+        "allow_all_prereleases",
+        "format_control",
+        "prefer_binary",
+        "ignore_requires_python",
+    ]
+
+    # Don't include an allow_yanked default value to make sure each call
+    # site considers whether yanked releases are allowed. This also causes
+    # that decision to be made explicit in the calling code, which helps
+    # people when reading the code.
+    def __init__(
+        self,
+        allow_yanked: bool,
+        allow_all_prereleases: bool = False,
+        format_control: Optional[FormatControl] = None,
+        prefer_binary: bool = False,
+        ignore_requires_python: Optional[bool] = None,
+    ) -> None:
+        """Create a SelectionPreferences object.
+
+        :param allow_yanked: Whether files marked as yanked (in the sense
+            of PEP 592) are permitted to be candidates for install.
+        :param format_control: A FormatControl object or None. Used to control
+            the selection of source packages / binary packages when consulting
+            the index and links.
+        :param prefer_binary: Whether to prefer an old, but valid, binary
+            dist over a new source dist.
+        :param ignore_requires_python: Whether to ignore incompatible
+            "Requires-Python" values in links. Defaults to False.
+        """
+        if ignore_requires_python is None:
+            ignore_requires_python = False
+
+        self.allow_yanked = allow_yanked
+        self.allow_all_prereleases = allow_all_prereleases
+        self.format_control = format_control
+        self.prefer_binary = prefer_binary
+        self.ignore_requires_python = ignore_requires_python
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/models/target_python.py b/venv/lib/python3.12/site-packages/pip/_internal/models/target_python.py
new file mode 100644
index 00000000..88925a9f
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/models/target_python.py
@@ -0,0 +1,121 @@
+import sys
+from typing import List, Optional, Set, Tuple
+
+from pip._vendor.packaging.tags import Tag
+
+from pip._internal.utils.compatibility_tags import get_supported, version_info_to_nodot
+from pip._internal.utils.misc import normalize_version_info
+
+
+class TargetPython:
+    """
+    Encapsulates the properties of a Python interpreter one is targeting
+    for a package install, download, etc.
+    """
+
+    __slots__ = [
+        "_given_py_version_info",
+        "abis",
+        "implementation",
+        "platforms",
+        "py_version",
+        "py_version_info",
+        "_valid_tags",
+        "_valid_tags_set",
+    ]
+
+    def __init__(
+        self,
+        platforms: Optional[List[str]] = None,
+        py_version_info: Optional[Tuple[int, ...]] = None,
+        abis: Optional[List[str]] = None,
+        implementation: Optional[str] = None,
+    ) -> None:
+        """
+        :param platforms: A list of strings or None. If None, searches for
+            packages that are supported by the current system. Otherwise, will
+            find packages that can be built on the platforms passed in. These
+            packages will only be downloaded for distribution: they will
+            not be built locally.
+        :param py_version_info: An optional tuple of ints representing the
+            Python version information to use (e.g. `sys.version_info[:3]`).
+            This can have length 1, 2, or 3 when provided.
+        :param abis: A list of strings or None. This is passed to
+            compatibility_tags.py's get_supported() function as is.
+        :param implementation: A string or None. This is passed to
+            compatibility_tags.py's get_supported() function as is.
+        """
+        # Store the given py_version_info for when we call get_supported().
+        self._given_py_version_info = py_version_info
+
+        if py_version_info is None:
+            py_version_info = sys.version_info[:3]
+        else:
+            py_version_info = normalize_version_info(py_version_info)
+
+        py_version = ".".join(map(str, py_version_info[:2]))
+
+        self.abis = abis
+        self.implementation = implementation
+        self.platforms = platforms
+        self.py_version = py_version
+        self.py_version_info = py_version_info
+
+        # This is used to cache the return value of get_(un)sorted_tags.
+        self._valid_tags: Optional[List[Tag]] = None
+        self._valid_tags_set: Optional[Set[Tag]] = None
+
+    def format_given(self) -> str:
+        """
+        Format the given, non-None attributes for display.
+        """
+        display_version = None
+        if self._given_py_version_info is not None:
+            display_version = ".".join(
+                str(part) for part in self._given_py_version_info
+            )
+
+        key_values = [
+            ("platforms", self.platforms),
+            ("version_info", display_version),
+            ("abis", self.abis),
+            ("implementation", self.implementation),
+        ]
+        return " ".join(
+            f"{key}={value!r}" for key, value in key_values if value is not None
+        )
+
+    def get_sorted_tags(self) -> List[Tag]:
+        """
+        Return the supported PEP 425 tags to check wheel candidates against.
+
+        The tags are returned in order of preference (most preferred first).
+        """
+        if self._valid_tags is None:
+            # Pass versions=None if no py_version_info was given since
+            # versions=None uses special default logic.
+            py_version_info = self._given_py_version_info
+            if py_version_info is None:
+                version = None
+            else:
+                version = version_info_to_nodot(py_version_info)
+
+            tags = get_supported(
+                version=version,
+                platforms=self.platforms,
+                abis=self.abis,
+                impl=self.implementation,
+            )
+            self._valid_tags = tags
+
+        return self._valid_tags
+
+    def get_unsorted_tags(self) -> Set[Tag]:
+        """Exactly the same as get_sorted_tags, but returns a set.
+
+        This is important for performance.
+        """
+        if self._valid_tags_set is None:
+            self._valid_tags_set = set(self.get_sorted_tags())
+
+        return self._valid_tags_set
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/models/wheel.py b/venv/lib/python3.12/site-packages/pip/_internal/models/wheel.py
new file mode 100644
index 00000000..36d4d2e7
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/models/wheel.py
@@ -0,0 +1,93 @@
+"""Represents a wheel file and provides access to the various parts of the
+name that have meaning.
+"""
+
+import re
+from typing import Dict, Iterable, List
+
+from pip._vendor.packaging.tags import Tag
+
+from pip._internal.exceptions import InvalidWheelFilename
+
+
+class Wheel:
+    """A wheel file"""
+
+    wheel_file_re = re.compile(
+        r"""^(?P(?P[^\s-]+?)-(?P[^\s-]*?))
+        ((-(?P\d[^-]*?))?-(?P[^\s-]+?)-(?P[^\s-]+?)-(?P[^\s-]+?)
+        \.whl|\.dist-info)$""",
+        re.VERBOSE,
+    )
+
+    def __init__(self, filename: str) -> None:
+        """
+        :raises InvalidWheelFilename: when the filename is invalid for a wheel
+        """
+        wheel_info = self.wheel_file_re.match(filename)
+        if not wheel_info:
+            raise InvalidWheelFilename(f"{filename} is not a valid wheel filename.")
+        self.filename = filename
+        self.name = wheel_info.group("name").replace("_", "-")
+        # we'll assume "_" means "-" due to wheel naming scheme
+        # (https://github.com/pypa/pip/issues/1150)
+        self.version = wheel_info.group("ver").replace("_", "-")
+        self.build_tag = wheel_info.group("build")
+        self.pyversions = wheel_info.group("pyver").split(".")
+        self.abis = wheel_info.group("abi").split(".")
+        self.plats = wheel_info.group("plat").split(".")
+
+        # All the tag combinations from this file
+        self.file_tags = {
+            Tag(x, y, z) for x in self.pyversions for y in self.abis for z in self.plats
+        }
+
+    def get_formatted_file_tags(self) -> List[str]:
+        """Return the wheel's tags as a sorted list of strings."""
+        return sorted(str(tag) for tag in self.file_tags)
+
+    def support_index_min(self, tags: List[Tag]) -> int:
+        """Return the lowest index that one of the wheel's file_tag combinations
+        achieves in the given list of supported tags.
+
+        For example, if there are 8 supported tags and one of the file tags
+        is first in the list, then return 0.
+
+        :param tags: the PEP 425 tags to check the wheel against, in order
+            with most preferred first.
+
+        :raises ValueError: If none of the wheel's file tags match one of
+            the supported tags.
+        """
+        try:
+            return next(i for i, t in enumerate(tags) if t in self.file_tags)
+        except StopIteration:
+            raise ValueError()
+
+    def find_most_preferred_tag(
+        self, tags: List[Tag], tag_to_priority: Dict[Tag, int]
+    ) -> int:
+        """Return the priority of the most preferred tag that one of the wheel's file
+        tag combinations achieves in the given list of supported tags using the given
+        tag_to_priority mapping, where lower priorities are more-preferred.
+
+        This is used in place of support_index_min in some cases in order to avoid
+        an expensive linear scan of a large list of tags.
+
+        :param tags: the PEP 425 tags to check the wheel against.
+        :param tag_to_priority: a mapping from tag to priority of that tag, where
+            lower is more preferred.
+
+        :raises ValueError: If none of the wheel's file tags match one of
+            the supported tags.
+        """
+        return min(
+            tag_to_priority[tag] for tag in self.file_tags if tag in tag_to_priority
+        )
+
+    def supported(self, tags: Iterable[Tag]) -> bool:
+        """Return whether the wheel is compatible with one of the given tags.
+
+        :param tags: the PEP 425 tags to check the wheel against.
+        """
+        return not self.file_tags.isdisjoint(tags)
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/network/__init__.py b/venv/lib/python3.12/site-packages/pip/_internal/network/__init__.py
new file mode 100644
index 00000000..b51bde91
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/network/__init__.py
@@ -0,0 +1,2 @@
+"""Contains purely network-related utilities.
+"""
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/network/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/network/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 00000000..02af8420
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/network/__pycache__/__init__.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/network/__pycache__/auth.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/network/__pycache__/auth.cpython-312.pyc
new file mode 100644
index 00000000..f5837f63
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/network/__pycache__/auth.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/network/__pycache__/cache.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/network/__pycache__/cache.cpython-312.pyc
new file mode 100644
index 00000000..09b36cdd
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/network/__pycache__/cache.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/network/__pycache__/download.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/network/__pycache__/download.cpython-312.pyc
new file mode 100644
index 00000000..f733e730
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/network/__pycache__/download.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/network/__pycache__/lazy_wheel.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/network/__pycache__/lazy_wheel.cpython-312.pyc
new file mode 100644
index 00000000..0161d549
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/network/__pycache__/lazy_wheel.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/network/__pycache__/session.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/network/__pycache__/session.cpython-312.pyc
new file mode 100644
index 00000000..c0eff2f5
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/network/__pycache__/session.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/network/__pycache__/utils.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/network/__pycache__/utils.cpython-312.pyc
new file mode 100644
index 00000000..8c3ed2e2
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/network/__pycache__/utils.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/network/__pycache__/xmlrpc.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/network/__pycache__/xmlrpc.cpython-312.pyc
new file mode 100644
index 00000000..3e20b68e
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/network/__pycache__/xmlrpc.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/network/auth.py b/venv/lib/python3.12/site-packages/pip/_internal/network/auth.py
new file mode 100644
index 00000000..1a2606ed
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/network/auth.py
@@ -0,0 +1,566 @@
+"""Network Authentication Helpers
+
+Contains interface (MultiDomainBasicAuth) and associated glue code for
+providing credentials in the context of network requests.
+"""
+
+import logging
+import os
+import shutil
+import subprocess
+import sysconfig
+import typing
+import urllib.parse
+from abc import ABC, abstractmethod
+from functools import lru_cache
+from os.path import commonprefix
+from pathlib import Path
+from typing import Any, Dict, List, NamedTuple, Optional, Tuple
+
+from pip._vendor.requests.auth import AuthBase, HTTPBasicAuth
+from pip._vendor.requests.models import Request, Response
+from pip._vendor.requests.utils import get_netrc_auth
+
+from pip._internal.utils.logging import getLogger
+from pip._internal.utils.misc import (
+    ask,
+    ask_input,
+    ask_password,
+    remove_auth_from_url,
+    split_auth_netloc_from_url,
+)
+from pip._internal.vcs.versioncontrol import AuthInfo
+
+logger = getLogger(__name__)
+
+KEYRING_DISABLED = False
+
+
+class Credentials(NamedTuple):
+    url: str
+    username: str
+    password: str
+
+
+class KeyRingBaseProvider(ABC):
+    """Keyring base provider interface"""
+
+    has_keyring: bool
+
+    @abstractmethod
+    def get_auth_info(
+        self, url: str, username: Optional[str]
+    ) -> Optional[AuthInfo]: ...
+
+    @abstractmethod
+    def save_auth_info(self, url: str, username: str, password: str) -> None: ...
+
+
+class KeyRingNullProvider(KeyRingBaseProvider):
+    """Keyring null provider"""
+
+    has_keyring = False
+
+    def get_auth_info(self, url: str, username: Optional[str]) -> Optional[AuthInfo]:
+        return None
+
+    def save_auth_info(self, url: str, username: str, password: str) -> None:
+        return None
+
+
+class KeyRingPythonProvider(KeyRingBaseProvider):
+    """Keyring interface which uses locally imported `keyring`"""
+
+    has_keyring = True
+
+    def __init__(self) -> None:
+        import keyring
+
+        self.keyring = keyring
+
+    def get_auth_info(self, url: str, username: Optional[str]) -> Optional[AuthInfo]:
+        # Support keyring's get_credential interface which supports getting
+        # credentials without a username. This is only available for
+        # keyring>=15.2.0.
+        if hasattr(self.keyring, "get_credential"):
+            logger.debug("Getting credentials from keyring for %s", url)
+            cred = self.keyring.get_credential(url, username)
+            if cred is not None:
+                return cred.username, cred.password
+            return None
+
+        if username is not None:
+            logger.debug("Getting password from keyring for %s", url)
+            password = self.keyring.get_password(url, username)
+            if password:
+                return username, password
+        return None
+
+    def save_auth_info(self, url: str, username: str, password: str) -> None:
+        self.keyring.set_password(url, username, password)
+
+
+class KeyRingCliProvider(KeyRingBaseProvider):
+    """Provider which uses `keyring` cli
+
+    Instead of calling the keyring package installed alongside pip
+    we call keyring on the command line which will enable pip to
+    use which ever installation of keyring is available first in
+    PATH.
+    """
+
+    has_keyring = True
+
+    def __init__(self, cmd: str) -> None:
+        self.keyring = cmd
+
+    def get_auth_info(self, url: str, username: Optional[str]) -> Optional[AuthInfo]:
+        # This is the default implementation of keyring.get_credential
+        # https://github.com/jaraco/keyring/blob/97689324abcf01bd1793d49063e7ca01e03d7d07/keyring/backend.py#L134-L139
+        if username is not None:
+            password = self._get_password(url, username)
+            if password is not None:
+                return username, password
+        return None
+
+    def save_auth_info(self, url: str, username: str, password: str) -> None:
+        return self._set_password(url, username, password)
+
+    def _get_password(self, service_name: str, username: str) -> Optional[str]:
+        """Mirror the implementation of keyring.get_password using cli"""
+        if self.keyring is None:
+            return None
+
+        cmd = [self.keyring, "get", service_name, username]
+        env = os.environ.copy()
+        env["PYTHONIOENCODING"] = "utf-8"
+        res = subprocess.run(
+            cmd,
+            stdin=subprocess.DEVNULL,
+            stdout=subprocess.PIPE,
+            env=env,
+        )
+        if res.returncode:
+            return None
+        return res.stdout.decode("utf-8").strip(os.linesep)
+
+    def _set_password(self, service_name: str, username: str, password: str) -> None:
+        """Mirror the implementation of keyring.set_password using cli"""
+        if self.keyring is None:
+            return None
+        env = os.environ.copy()
+        env["PYTHONIOENCODING"] = "utf-8"
+        subprocess.run(
+            [self.keyring, "set", service_name, username],
+            input=f"{password}{os.linesep}".encode(),
+            env=env,
+            check=True,
+        )
+        return None
+
+
+@lru_cache(maxsize=None)
+def get_keyring_provider(provider: str) -> KeyRingBaseProvider:
+    logger.verbose("Keyring provider requested: %s", provider)
+
+    # keyring has previously failed and been disabled
+    if KEYRING_DISABLED:
+        provider = "disabled"
+    if provider in ["import", "auto"]:
+        try:
+            impl = KeyRingPythonProvider()
+            logger.verbose("Keyring provider set: import")
+            return impl
+        except ImportError:
+            pass
+        except Exception as exc:
+            # In the event of an unexpected exception
+            # we should warn the user
+            msg = "Installed copy of keyring fails with exception %s"
+            if provider == "auto":
+                msg = msg + ", trying to find a keyring executable as a fallback"
+            logger.warning(msg, exc, exc_info=logger.isEnabledFor(logging.DEBUG))
+    if provider in ["subprocess", "auto"]:
+        cli = shutil.which("keyring")
+        if cli and cli.startswith(sysconfig.get_path("scripts")):
+            # all code within this function is stolen from shutil.which implementation
+            @typing.no_type_check
+            def PATH_as_shutil_which_determines_it() -> str:
+                path = os.environ.get("PATH", None)
+                if path is None:
+                    try:
+                        path = os.confstr("CS_PATH")
+                    except (AttributeError, ValueError):
+                        # os.confstr() or CS_PATH is not available
+                        path = os.defpath
+                # bpo-35755: Don't use os.defpath if the PATH environment variable is
+                # set to an empty string
+
+                return path
+
+            scripts = Path(sysconfig.get_path("scripts"))
+
+            paths = []
+            for path in PATH_as_shutil_which_determines_it().split(os.pathsep):
+                p = Path(path)
+                try:
+                    if not p.samefile(scripts):
+                        paths.append(path)
+                except FileNotFoundError:
+                    pass
+
+            path = os.pathsep.join(paths)
+
+            cli = shutil.which("keyring", path=path)
+
+        if cli:
+            logger.verbose("Keyring provider set: subprocess with executable %s", cli)
+            return KeyRingCliProvider(cli)
+
+    logger.verbose("Keyring provider set: disabled")
+    return KeyRingNullProvider()
+
+
+class MultiDomainBasicAuth(AuthBase):
+    def __init__(
+        self,
+        prompting: bool = True,
+        index_urls: Optional[List[str]] = None,
+        keyring_provider: str = "auto",
+    ) -> None:
+        self.prompting = prompting
+        self.index_urls = index_urls
+        self.keyring_provider = keyring_provider  # type: ignore[assignment]
+        self.passwords: Dict[str, AuthInfo] = {}
+        # When the user is prompted to enter credentials and keyring is
+        # available, we will offer to save them. If the user accepts,
+        # this value is set to the credentials they entered. After the
+        # request authenticates, the caller should call
+        # ``save_credentials`` to save these.
+        self._credentials_to_save: Optional[Credentials] = None
+
+    @property
+    def keyring_provider(self) -> KeyRingBaseProvider:
+        return get_keyring_provider(self._keyring_provider)
+
+    @keyring_provider.setter
+    def keyring_provider(self, provider: str) -> None:
+        # The free function get_keyring_provider has been decorated with
+        # functools.cache. If an exception occurs in get_keyring_auth that
+        # cache will be cleared and keyring disabled, take that into account
+        # if you want to remove this indirection.
+        self._keyring_provider = provider
+
+    @property
+    def use_keyring(self) -> bool:
+        # We won't use keyring when --no-input is passed unless
+        # a specific provider is requested because it might require
+        # user interaction
+        return self.prompting or self._keyring_provider not in ["auto", "disabled"]
+
+    def _get_keyring_auth(
+        self,
+        url: Optional[str],
+        username: Optional[str],
+    ) -> Optional[AuthInfo]:
+        """Return the tuple auth for a given url from keyring."""
+        # Do nothing if no url was provided
+        if not url:
+            return None
+
+        try:
+            return self.keyring_provider.get_auth_info(url, username)
+        except Exception as exc:
+            # Log the full exception (with stacktrace) at debug, so it'll only
+            # show up when running in verbose mode.
+            logger.debug("Keyring is skipped due to an exception", exc_info=True)
+            # Always log a shortened version of the exception.
+            logger.warning(
+                "Keyring is skipped due to an exception: %s",
+                str(exc),
+            )
+            global KEYRING_DISABLED
+            KEYRING_DISABLED = True
+            get_keyring_provider.cache_clear()
+            return None
+
+    def _get_index_url(self, url: str) -> Optional[str]:
+        """Return the original index URL matching the requested URL.
+
+        Cached or dynamically generated credentials may work against
+        the original index URL rather than just the netloc.
+
+        The provided url should have had its username and password
+        removed already. If the original index url had credentials then
+        they will be included in the return value.
+
+        Returns None if no matching index was found, or if --no-index
+        was specified by the user.
+        """
+        if not url or not self.index_urls:
+            return None
+
+        url = remove_auth_from_url(url).rstrip("/") + "/"
+        parsed_url = urllib.parse.urlsplit(url)
+
+        candidates = []
+
+        for index in self.index_urls:
+            index = index.rstrip("/") + "/"
+            parsed_index = urllib.parse.urlsplit(remove_auth_from_url(index))
+            if parsed_url == parsed_index:
+                return index
+
+            if parsed_url.netloc != parsed_index.netloc:
+                continue
+
+            candidate = urllib.parse.urlsplit(index)
+            candidates.append(candidate)
+
+        if not candidates:
+            return None
+
+        candidates.sort(
+            reverse=True,
+            key=lambda candidate: commonprefix(
+                [
+                    parsed_url.path,
+                    candidate.path,
+                ]
+            ).rfind("/"),
+        )
+
+        return urllib.parse.urlunsplit(candidates[0])
+
+    def _get_new_credentials(
+        self,
+        original_url: str,
+        *,
+        allow_netrc: bool = True,
+        allow_keyring: bool = False,
+    ) -> AuthInfo:
+        """Find and return credentials for the specified URL."""
+        # Split the credentials and netloc from the url.
+        url, netloc, url_user_password = split_auth_netloc_from_url(
+            original_url,
+        )
+
+        # Start with the credentials embedded in the url
+        username, password = url_user_password
+        if username is not None and password is not None:
+            logger.debug("Found credentials in url for %s", netloc)
+            return url_user_password
+
+        # Find a matching index url for this request
+        index_url = self._get_index_url(url)
+        if index_url:
+            # Split the credentials from the url.
+            index_info = split_auth_netloc_from_url(index_url)
+            if index_info:
+                index_url, _, index_url_user_password = index_info
+                logger.debug("Found index url %s", index_url)
+
+        # If an index URL was found, try its embedded credentials
+        if index_url and index_url_user_password[0] is not None:
+            username, password = index_url_user_password
+            if username is not None and password is not None:
+                logger.debug("Found credentials in index url for %s", netloc)
+                return index_url_user_password
+
+        # Get creds from netrc if we still don't have them
+        if allow_netrc:
+            netrc_auth = get_netrc_auth(original_url)
+            if netrc_auth:
+                logger.debug("Found credentials in netrc for %s", netloc)
+                return netrc_auth
+
+        # If we don't have a password and keyring is available, use it.
+        if allow_keyring:
+            # The index url is more specific than the netloc, so try it first
+            # fmt: off
+            kr_auth = (
+                self._get_keyring_auth(index_url, username) or
+                self._get_keyring_auth(netloc, username)
+            )
+            # fmt: on
+            if kr_auth:
+                logger.debug("Found credentials in keyring for %s", netloc)
+                return kr_auth
+
+        return username, password
+
+    def _get_url_and_credentials(
+        self, original_url: str
+    ) -> Tuple[str, Optional[str], Optional[str]]:
+        """Return the credentials to use for the provided URL.
+
+        If allowed, netrc and keyring may be used to obtain the
+        correct credentials.
+
+        Returns (url_without_credentials, username, password). Note
+        that even if the original URL contains credentials, this
+        function may return a different username and password.
+        """
+        url, netloc, _ = split_auth_netloc_from_url(original_url)
+
+        # Try to get credentials from original url
+        username, password = self._get_new_credentials(original_url)
+
+        # If credentials not found, use any stored credentials for this netloc.
+        # Do this if either the username or the password is missing.
+        # This accounts for the situation in which the user has specified
+        # the username in the index url, but the password comes from keyring.
+        if (username is None or password is None) and netloc in self.passwords:
+            un, pw = self.passwords[netloc]
+            # It is possible that the cached credentials are for a different username,
+            # in which case the cache should be ignored.
+            if username is None or username == un:
+                username, password = un, pw
+
+        if username is not None or password is not None:
+            # Convert the username and password if they're None, so that
+            # this netloc will show up as "cached" in the conditional above.
+            # Further, HTTPBasicAuth doesn't accept None, so it makes sense to
+            # cache the value that is going to be used.
+            username = username or ""
+            password = password or ""
+
+            # Store any acquired credentials.
+            self.passwords[netloc] = (username, password)
+
+        assert (
+            # Credentials were found
+            (username is not None and password is not None)
+            # Credentials were not found
+            or (username is None and password is None)
+        ), f"Could not load credentials from url: {original_url}"
+
+        return url, username, password
+
+    def __call__(self, req: Request) -> Request:
+        # Get credentials for this request
+        url, username, password = self._get_url_and_credentials(req.url)
+
+        # Set the url of the request to the url without any credentials
+        req.url = url
+
+        if username is not None and password is not None:
+            # Send the basic auth with this request
+            req = HTTPBasicAuth(username, password)(req)
+
+        # Attach a hook to handle 401 responses
+        req.register_hook("response", self.handle_401)
+
+        return req
+
+    # Factored out to allow for easy patching in tests
+    def _prompt_for_password(
+        self, netloc: str
+    ) -> Tuple[Optional[str], Optional[str], bool]:
+        username = ask_input(f"User for {netloc}: ") if self.prompting else None
+        if not username:
+            return None, None, False
+        if self.use_keyring:
+            auth = self._get_keyring_auth(netloc, username)
+            if auth and auth[0] is not None and auth[1] is not None:
+                return auth[0], auth[1], False
+        password = ask_password("Password: ")
+        return username, password, True
+
+    # Factored out to allow for easy patching in tests
+    def _should_save_password_to_keyring(self) -> bool:
+        if (
+            not self.prompting
+            or not self.use_keyring
+            or not self.keyring_provider.has_keyring
+        ):
+            return False
+        return ask("Save credentials to keyring [y/N]: ", ["y", "n"]) == "y"
+
+    def handle_401(self, resp: Response, **kwargs: Any) -> Response:
+        # We only care about 401 responses, anything else we want to just
+        #   pass through the actual response
+        if resp.status_code != 401:
+            return resp
+
+        username, password = None, None
+
+        # Query the keyring for credentials:
+        if self.use_keyring:
+            username, password = self._get_new_credentials(
+                resp.url,
+                allow_netrc=False,
+                allow_keyring=True,
+            )
+
+        # We are not able to prompt the user so simply return the response
+        if not self.prompting and not username and not password:
+            return resp
+
+        parsed = urllib.parse.urlparse(resp.url)
+
+        # Prompt the user for a new username and password
+        save = False
+        if not username and not password:
+            username, password, save = self._prompt_for_password(parsed.netloc)
+
+        # Store the new username and password to use for future requests
+        self._credentials_to_save = None
+        if username is not None and password is not None:
+            self.passwords[parsed.netloc] = (username, password)
+
+            # Prompt to save the password to keyring
+            if save and self._should_save_password_to_keyring():
+                self._credentials_to_save = Credentials(
+                    url=parsed.netloc,
+                    username=username,
+                    password=password,
+                )
+
+        # Consume content and release the original connection to allow our new
+        #   request to reuse the same one.
+        # The result of the assignment isn't used, it's just needed to consume
+        # the content.
+        _ = resp.content
+        resp.raw.release_conn()
+
+        # Add our new username and password to the request
+        req = HTTPBasicAuth(username or "", password or "")(resp.request)
+        req.register_hook("response", self.warn_on_401)
+
+        # On successful request, save the credentials that were used to
+        # keyring. (Note that if the user responded "no" above, this member
+        # is not set and nothing will be saved.)
+        if self._credentials_to_save:
+            req.register_hook("response", self.save_credentials)
+
+        # Send our new request
+        new_resp = resp.connection.send(req, **kwargs)
+        new_resp.history.append(resp)
+
+        return new_resp
+
+    def warn_on_401(self, resp: Response, **kwargs: Any) -> None:
+        """Response callback to warn about incorrect credentials."""
+        if resp.status_code == 401:
+            logger.warning(
+                "401 Error, Credentials not correct for %s",
+                resp.request.url,
+            )
+
+    def save_credentials(self, resp: Response, **kwargs: Any) -> None:
+        """Response callback to save credentials on success."""
+        assert (
+            self.keyring_provider.has_keyring
+        ), "should never reach here without keyring"
+
+        creds = self._credentials_to_save
+        self._credentials_to_save = None
+        if creds and resp.status_code < 400:
+            try:
+                logger.info("Saving credentials to keyring")
+                self.keyring_provider.save_auth_info(
+                    creds.url, creds.username, creds.password
+                )
+            except Exception:
+                logger.exception("Failed to save credentials")
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/network/cache.py b/venv/lib/python3.12/site-packages/pip/_internal/network/cache.py
new file mode 100644
index 00000000..4d0fb545
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/network/cache.py
@@ -0,0 +1,106 @@
+"""HTTP cache implementation.
+"""
+
+import os
+from contextlib import contextmanager
+from datetime import datetime
+from typing import BinaryIO, Generator, Optional, Union
+
+from pip._vendor.cachecontrol.cache import SeparateBodyBaseCache
+from pip._vendor.cachecontrol.caches import SeparateBodyFileCache
+from pip._vendor.requests.models import Response
+
+from pip._internal.utils.filesystem import adjacent_tmp_file, replace
+from pip._internal.utils.misc import ensure_dir
+
+
+def is_from_cache(response: Response) -> bool:
+    return getattr(response, "from_cache", False)
+
+
+@contextmanager
+def suppressed_cache_errors() -> Generator[None, None, None]:
+    """If we can't access the cache then we can just skip caching and process
+    requests as if caching wasn't enabled.
+    """
+    try:
+        yield
+    except OSError:
+        pass
+
+
+class SafeFileCache(SeparateBodyBaseCache):
+    """
+    A file based cache which is safe to use even when the target directory may
+    not be accessible or writable.
+
+    There is a race condition when two processes try to write and/or read the
+    same entry at the same time, since each entry consists of two separate
+    files (https://github.com/psf/cachecontrol/issues/324).  We therefore have
+    additional logic that makes sure that both files to be present before
+    returning an entry; this fixes the read side of the race condition.
+
+    For the write side, we assume that the server will only ever return the
+    same data for the same URL, which ought to be the case for files pip is
+    downloading.  PyPI does not have a mechanism to swap out a wheel for
+    another wheel, for example.  If this assumption is not true, the
+    CacheControl issue will need to be fixed.
+    """
+
+    def __init__(self, directory: str) -> None:
+        assert directory is not None, "Cache directory must not be None."
+        super().__init__()
+        self.directory = directory
+
+    def _get_cache_path(self, name: str) -> str:
+        # From cachecontrol.caches.file_cache.FileCache._fn, brought into our
+        # class for backwards-compatibility and to avoid using a non-public
+        # method.
+        hashed = SeparateBodyFileCache.encode(name)
+        parts = list(hashed[:5]) + [hashed]
+        return os.path.join(self.directory, *parts)
+
+    def get(self, key: str) -> Optional[bytes]:
+        # The cache entry is only valid if both metadata and body exist.
+        metadata_path = self._get_cache_path(key)
+        body_path = metadata_path + ".body"
+        if not (os.path.exists(metadata_path) and os.path.exists(body_path)):
+            return None
+        with suppressed_cache_errors():
+            with open(metadata_path, "rb") as f:
+                return f.read()
+
+    def _write(self, path: str, data: bytes) -> None:
+        with suppressed_cache_errors():
+            ensure_dir(os.path.dirname(path))
+
+            with adjacent_tmp_file(path) as f:
+                f.write(data)
+
+            replace(f.name, path)
+
+    def set(
+        self, key: str, value: bytes, expires: Union[int, datetime, None] = None
+    ) -> None:
+        path = self._get_cache_path(key)
+        self._write(path, value)
+
+    def delete(self, key: str) -> None:
+        path = self._get_cache_path(key)
+        with suppressed_cache_errors():
+            os.remove(path)
+        with suppressed_cache_errors():
+            os.remove(path + ".body")
+
+    def get_body(self, key: str) -> Optional[BinaryIO]:
+        # The cache entry is only valid if both metadata and body exist.
+        metadata_path = self._get_cache_path(key)
+        body_path = metadata_path + ".body"
+        if not (os.path.exists(metadata_path) and os.path.exists(body_path)):
+            return None
+        with suppressed_cache_errors():
+            return open(body_path, "rb")
+
+    def set_body(self, key: str, body: bytes) -> None:
+        path = self._get_cache_path(key) + ".body"
+        self._write(path, body)
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/network/download.py b/venv/lib/python3.12/site-packages/pip/_internal/network/download.py
new file mode 100644
index 00000000..5c3bce3d
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/network/download.py
@@ -0,0 +1,187 @@
+"""Download files with progress indicators.
+"""
+
+import email.message
+import logging
+import mimetypes
+import os
+from typing import Iterable, Optional, Tuple
+
+from pip._vendor.requests.models import Response
+
+from pip._internal.cli.progress_bars import get_download_progress_renderer
+from pip._internal.exceptions import NetworkConnectionError
+from pip._internal.models.index import PyPI
+from pip._internal.models.link import Link
+from pip._internal.network.cache import is_from_cache
+from pip._internal.network.session import PipSession
+from pip._internal.network.utils import HEADERS, raise_for_status, response_chunks
+from pip._internal.utils.misc import format_size, redact_auth_from_url, splitext
+
+logger = logging.getLogger(__name__)
+
+
+def _get_http_response_size(resp: Response) -> Optional[int]:
+    try:
+        return int(resp.headers["content-length"])
+    except (ValueError, KeyError, TypeError):
+        return None
+
+
+def _prepare_download(
+    resp: Response,
+    link: Link,
+    progress_bar: str,
+) -> Iterable[bytes]:
+    total_length = _get_http_response_size(resp)
+
+    if link.netloc == PyPI.file_storage_domain:
+        url = link.show_url
+    else:
+        url = link.url_without_fragment
+
+    logged_url = redact_auth_from_url(url)
+
+    if total_length:
+        logged_url = f"{logged_url} ({format_size(total_length)})"
+
+    if is_from_cache(resp):
+        logger.info("Using cached %s", logged_url)
+    else:
+        logger.info("Downloading %s", logged_url)
+
+    if logger.getEffectiveLevel() > logging.INFO:
+        show_progress = False
+    elif is_from_cache(resp):
+        show_progress = False
+    elif not total_length:
+        show_progress = True
+    elif total_length > (512 * 1024):
+        show_progress = True
+    else:
+        show_progress = False
+
+    chunks = response_chunks(resp)
+
+    if not show_progress:
+        return chunks
+
+    renderer = get_download_progress_renderer(bar_type=progress_bar, size=total_length)
+    return renderer(chunks)
+
+
+def sanitize_content_filename(filename: str) -> str:
+    """
+    Sanitize the "filename" value from a Content-Disposition header.
+    """
+    return os.path.basename(filename)
+
+
+def parse_content_disposition(content_disposition: str, default_filename: str) -> str:
+    """
+    Parse the "filename" value from a Content-Disposition header, and
+    return the default filename if the result is empty.
+    """
+    m = email.message.Message()
+    m["content-type"] = content_disposition
+    filename = m.get_param("filename")
+    if filename:
+        # We need to sanitize the filename to prevent directory traversal
+        # in case the filename contains ".." path parts.
+        filename = sanitize_content_filename(str(filename))
+    return filename or default_filename
+
+
+def _get_http_response_filename(resp: Response, link: Link) -> str:
+    """Get an ideal filename from the given HTTP response, falling back to
+    the link filename if not provided.
+    """
+    filename = link.filename  # fallback
+    # Have a look at the Content-Disposition header for a better guess
+    content_disposition = resp.headers.get("content-disposition")
+    if content_disposition:
+        filename = parse_content_disposition(content_disposition, filename)
+    ext: Optional[str] = splitext(filename)[1]
+    if not ext:
+        ext = mimetypes.guess_extension(resp.headers.get("content-type", ""))
+        if ext:
+            filename += ext
+    if not ext and link.url != resp.url:
+        ext = os.path.splitext(resp.url)[1]
+        if ext:
+            filename += ext
+    return filename
+
+
+def _http_get_download(session: PipSession, link: Link) -> Response:
+    target_url = link.url.split("#", 1)[0]
+    resp = session.get(target_url, headers=HEADERS, stream=True)
+    raise_for_status(resp)
+    return resp
+
+
+class Downloader:
+    def __init__(
+        self,
+        session: PipSession,
+        progress_bar: str,
+    ) -> None:
+        self._session = session
+        self._progress_bar = progress_bar
+
+    def __call__(self, link: Link, location: str) -> Tuple[str, str]:
+        """Download the file given by link into location."""
+        try:
+            resp = _http_get_download(self._session, link)
+        except NetworkConnectionError as e:
+            assert e.response is not None
+            logger.critical(
+                "HTTP error %s while getting %s", e.response.status_code, link
+            )
+            raise
+
+        filename = _get_http_response_filename(resp, link)
+        filepath = os.path.join(location, filename)
+
+        chunks = _prepare_download(resp, link, self._progress_bar)
+        with open(filepath, "wb") as content_file:
+            for chunk in chunks:
+                content_file.write(chunk)
+        content_type = resp.headers.get("Content-Type", "")
+        return filepath, content_type
+
+
+class BatchDownloader:
+    def __init__(
+        self,
+        session: PipSession,
+        progress_bar: str,
+    ) -> None:
+        self._session = session
+        self._progress_bar = progress_bar
+
+    def __call__(
+        self, links: Iterable[Link], location: str
+    ) -> Iterable[Tuple[Link, Tuple[str, str]]]:
+        """Download the files given by links into location."""
+        for link in links:
+            try:
+                resp = _http_get_download(self._session, link)
+            except NetworkConnectionError as e:
+                assert e.response is not None
+                logger.critical(
+                    "HTTP error %s while getting %s",
+                    e.response.status_code,
+                    link,
+                )
+                raise
+
+            filename = _get_http_response_filename(resp, link)
+            filepath = os.path.join(location, filename)
+
+            chunks = _prepare_download(resp, link, self._progress_bar)
+            with open(filepath, "wb") as content_file:
+                for chunk in chunks:
+                    content_file.write(chunk)
+            content_type = resp.headers.get("Content-Type", "")
+            yield link, (filepath, content_type)
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/network/lazy_wheel.py b/venv/lib/python3.12/site-packages/pip/_internal/network/lazy_wheel.py
new file mode 100644
index 00000000..82ec50d5
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/network/lazy_wheel.py
@@ -0,0 +1,210 @@
+"""Lazy ZIP over HTTP"""
+
+__all__ = ["HTTPRangeRequestUnsupported", "dist_from_wheel_url"]
+
+from bisect import bisect_left, bisect_right
+from contextlib import contextmanager
+from tempfile import NamedTemporaryFile
+from typing import Any, Dict, Generator, List, Optional, Tuple
+from zipfile import BadZipFile, ZipFile
+
+from pip._vendor.packaging.utils import canonicalize_name
+from pip._vendor.requests.models import CONTENT_CHUNK_SIZE, Response
+
+from pip._internal.metadata import BaseDistribution, MemoryWheel, get_wheel_distribution
+from pip._internal.network.session import PipSession
+from pip._internal.network.utils import HEADERS, raise_for_status, response_chunks
+
+
+class HTTPRangeRequestUnsupported(Exception):
+    pass
+
+
+def dist_from_wheel_url(name: str, url: str, session: PipSession) -> BaseDistribution:
+    """Return a distribution object from the given wheel URL.
+
+    This uses HTTP range requests to only fetch the portion of the wheel
+    containing metadata, just enough for the object to be constructed.
+    If such requests are not supported, HTTPRangeRequestUnsupported
+    is raised.
+    """
+    with LazyZipOverHTTP(url, session) as zf:
+        # For read-only ZIP files, ZipFile only needs methods read,
+        # seek, seekable and tell, not the whole IO protocol.
+        wheel = MemoryWheel(zf.name, zf)  # type: ignore
+        # After context manager exit, wheel.name
+        # is an invalid file by intention.
+        return get_wheel_distribution(wheel, canonicalize_name(name))
+
+
+class LazyZipOverHTTP:
+    """File-like object mapped to a ZIP file over HTTP.
+
+    This uses HTTP range requests to lazily fetch the file's content,
+    which is supposed to be fed to ZipFile.  If such requests are not
+    supported by the server, raise HTTPRangeRequestUnsupported
+    during initialization.
+    """
+
+    def __init__(
+        self, url: str, session: PipSession, chunk_size: int = CONTENT_CHUNK_SIZE
+    ) -> None:
+        head = session.head(url, headers=HEADERS)
+        raise_for_status(head)
+        assert head.status_code == 200
+        self._session, self._url, self._chunk_size = session, url, chunk_size
+        self._length = int(head.headers["Content-Length"])
+        self._file = NamedTemporaryFile()
+        self.truncate(self._length)
+        self._left: List[int] = []
+        self._right: List[int] = []
+        if "bytes" not in head.headers.get("Accept-Ranges", "none"):
+            raise HTTPRangeRequestUnsupported("range request is not supported")
+        self._check_zip()
+
+    @property
+    def mode(self) -> str:
+        """Opening mode, which is always rb."""
+        return "rb"
+
+    @property
+    def name(self) -> str:
+        """Path to the underlying file."""
+        return self._file.name
+
+    def seekable(self) -> bool:
+        """Return whether random access is supported, which is True."""
+        return True
+
+    def close(self) -> None:
+        """Close the file."""
+        self._file.close()
+
+    @property
+    def closed(self) -> bool:
+        """Whether the file is closed."""
+        return self._file.closed
+
+    def read(self, size: int = -1) -> bytes:
+        """Read up to size bytes from the object and return them.
+
+        As a convenience, if size is unspecified or -1,
+        all bytes until EOF are returned.  Fewer than
+        size bytes may be returned if EOF is reached.
+        """
+        download_size = max(size, self._chunk_size)
+        start, length = self.tell(), self._length
+        stop = length if size < 0 else min(start + download_size, length)
+        start = max(0, stop - download_size)
+        self._download(start, stop - 1)
+        return self._file.read(size)
+
+    def readable(self) -> bool:
+        """Return whether the file is readable, which is True."""
+        return True
+
+    def seek(self, offset: int, whence: int = 0) -> int:
+        """Change stream position and return the new absolute position.
+
+        Seek to offset relative position indicated by whence:
+        * 0: Start of stream (the default).  pos should be >= 0;
+        * 1: Current position - pos may be negative;
+        * 2: End of stream - pos usually negative.
+        """
+        return self._file.seek(offset, whence)
+
+    def tell(self) -> int:
+        """Return the current position."""
+        return self._file.tell()
+
+    def truncate(self, size: Optional[int] = None) -> int:
+        """Resize the stream to the given size in bytes.
+
+        If size is unspecified resize to the current position.
+        The current stream position isn't changed.
+
+        Return the new file size.
+        """
+        return self._file.truncate(size)
+
+    def writable(self) -> bool:
+        """Return False."""
+        return False
+
+    def __enter__(self) -> "LazyZipOverHTTP":
+        self._file.__enter__()
+        return self
+
+    def __exit__(self, *exc: Any) -> None:
+        self._file.__exit__(*exc)
+
+    @contextmanager
+    def _stay(self) -> Generator[None, None, None]:
+        """Return a context manager keeping the position.
+
+        At the end of the block, seek back to original position.
+        """
+        pos = self.tell()
+        try:
+            yield
+        finally:
+            self.seek(pos)
+
+    def _check_zip(self) -> None:
+        """Check and download until the file is a valid ZIP."""
+        end = self._length - 1
+        for start in reversed(range(0, end, self._chunk_size)):
+            self._download(start, end)
+            with self._stay():
+                try:
+                    # For read-only ZIP files, ZipFile only needs
+                    # methods read, seek, seekable and tell.
+                    ZipFile(self)  # type: ignore
+                except BadZipFile:
+                    pass
+                else:
+                    break
+
+    def _stream_response(
+        self, start: int, end: int, base_headers: Dict[str, str] = HEADERS
+    ) -> Response:
+        """Return HTTP response to a range request from start to end."""
+        headers = base_headers.copy()
+        headers["Range"] = f"bytes={start}-{end}"
+        # TODO: Get range requests to be correctly cached
+        headers["Cache-Control"] = "no-cache"
+        return self._session.get(self._url, headers=headers, stream=True)
+
+    def _merge(
+        self, start: int, end: int, left: int, right: int
+    ) -> Generator[Tuple[int, int], None, None]:
+        """Return a generator of intervals to be fetched.
+
+        Args:
+            start (int): Start of needed interval
+            end (int): End of needed interval
+            left (int): Index of first overlapping downloaded data
+            right (int): Index after last overlapping downloaded data
+        """
+        lslice, rslice = self._left[left:right], self._right[left:right]
+        i = start = min([start] + lslice[:1])
+        end = max([end] + rslice[-1:])
+        for j, k in zip(lslice, rslice):
+            if j > i:
+                yield i, j - 1
+            i = k + 1
+        if i <= end:
+            yield i, end
+        self._left[left:right], self._right[left:right] = [start], [end]
+
+    def _download(self, start: int, end: int) -> None:
+        """Download bytes from start to end inclusively."""
+        with self._stay():
+            left = bisect_left(self._right, start)
+            right = bisect_right(self._left, end)
+            for start, end in self._merge(start, end, left, right):
+                response = self._stream_response(start, end)
+                response.raise_for_status()
+                self.seek(start)
+                for chunk in response_chunks(response, self._chunk_size):
+                    self._file.write(chunk)
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/network/session.py b/venv/lib/python3.12/site-packages/pip/_internal/network/session.py
new file mode 100644
index 00000000..1765b4f6
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/network/session.py
@@ -0,0 +1,522 @@
+"""PipSession and supporting code, containing all pip-specific
+network request configuration and behavior.
+"""
+
+import email.utils
+import functools
+import io
+import ipaddress
+import json
+import logging
+import mimetypes
+import os
+import platform
+import shutil
+import subprocess
+import sys
+import urllib.parse
+import warnings
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Dict,
+    Generator,
+    List,
+    Mapping,
+    Optional,
+    Sequence,
+    Tuple,
+    Union,
+)
+
+from pip._vendor import requests, urllib3
+from pip._vendor.cachecontrol import CacheControlAdapter as _BaseCacheControlAdapter
+from pip._vendor.requests.adapters import DEFAULT_POOLBLOCK, BaseAdapter
+from pip._vendor.requests.adapters import HTTPAdapter as _BaseHTTPAdapter
+from pip._vendor.requests.models import PreparedRequest, Response
+from pip._vendor.requests.structures import CaseInsensitiveDict
+from pip._vendor.urllib3.connectionpool import ConnectionPool
+from pip._vendor.urllib3.exceptions import InsecureRequestWarning
+
+from pip import __version__
+from pip._internal.metadata import get_default_environment
+from pip._internal.models.link import Link
+from pip._internal.network.auth import MultiDomainBasicAuth
+from pip._internal.network.cache import SafeFileCache
+
+# Import ssl from compat so the initial import occurs in only one place.
+from pip._internal.utils.compat import has_tls
+from pip._internal.utils.glibc import libc_ver
+from pip._internal.utils.misc import build_url_from_netloc, parse_netloc
+from pip._internal.utils.urls import url_to_path
+
+if TYPE_CHECKING:
+    from ssl import SSLContext
+
+    from pip._vendor.urllib3.poolmanager import PoolManager
+
+
+logger = logging.getLogger(__name__)
+
+SecureOrigin = Tuple[str, str, Optional[Union[int, str]]]
+
+
+# Ignore warning raised when using --trusted-host.
+warnings.filterwarnings("ignore", category=InsecureRequestWarning)
+
+
+SECURE_ORIGINS: List[SecureOrigin] = [
+    # protocol, hostname, port
+    # Taken from Chrome's list of secure origins (See: http://bit.ly/1qrySKC)
+    ("https", "*", "*"),
+    ("*", "localhost", "*"),
+    ("*", "127.0.0.0/8", "*"),
+    ("*", "::1/128", "*"),
+    ("file", "*", None),
+    # ssh is always secure.
+    ("ssh", "*", "*"),
+]
+
+
+# These are environment variables present when running under various
+# CI systems.  For each variable, some CI systems that use the variable
+# are indicated.  The collection was chosen so that for each of a number
+# of popular systems, at least one of the environment variables is used.
+# This list is used to provide some indication of and lower bound for
+# CI traffic to PyPI.  Thus, it is okay if the list is not comprehensive.
+# For more background, see: https://github.com/pypa/pip/issues/5499
+CI_ENVIRONMENT_VARIABLES = (
+    # Azure Pipelines
+    "BUILD_BUILDID",
+    # Jenkins
+    "BUILD_ID",
+    # AppVeyor, CircleCI, Codeship, Gitlab CI, Shippable, Travis CI
+    "CI",
+    # Explicit environment variable.
+    "PIP_IS_CI",
+)
+
+
+def looks_like_ci() -> bool:
+    """
+    Return whether it looks like pip is running under CI.
+    """
+    # We don't use the method of checking for a tty (e.g. using isatty())
+    # because some CI systems mimic a tty (e.g. Travis CI).  Thus that
+    # method doesn't provide definitive information in either direction.
+    return any(name in os.environ for name in CI_ENVIRONMENT_VARIABLES)
+
+
+@functools.lru_cache(maxsize=1)
+def user_agent() -> str:
+    """
+    Return a string representing the user agent.
+    """
+    data: Dict[str, Any] = {
+        "installer": {"name": "pip", "version": __version__},
+        "python": platform.python_version(),
+        "implementation": {
+            "name": platform.python_implementation(),
+        },
+    }
+
+    if data["implementation"]["name"] == "CPython":
+        data["implementation"]["version"] = platform.python_version()
+    elif data["implementation"]["name"] == "PyPy":
+        pypy_version_info = sys.pypy_version_info  # type: ignore
+        if pypy_version_info.releaselevel == "final":
+            pypy_version_info = pypy_version_info[:3]
+        data["implementation"]["version"] = ".".join(
+            [str(x) for x in pypy_version_info]
+        )
+    elif data["implementation"]["name"] == "Jython":
+        # Complete Guess
+        data["implementation"]["version"] = platform.python_version()
+    elif data["implementation"]["name"] == "IronPython":
+        # Complete Guess
+        data["implementation"]["version"] = platform.python_version()
+
+    if sys.platform.startswith("linux"):
+        from pip._vendor import distro
+
+        linux_distribution = distro.name(), distro.version(), distro.codename()
+        distro_infos: Dict[str, Any] = dict(
+            filter(
+                lambda x: x[1],
+                zip(["name", "version", "id"], linux_distribution),
+            )
+        )
+        libc = dict(
+            filter(
+                lambda x: x[1],
+                zip(["lib", "version"], libc_ver()),
+            )
+        )
+        if libc:
+            distro_infos["libc"] = libc
+        if distro_infos:
+            data["distro"] = distro_infos
+
+    if sys.platform.startswith("darwin") and platform.mac_ver()[0]:
+        data["distro"] = {"name": "macOS", "version": platform.mac_ver()[0]}
+
+    if platform.system():
+        data.setdefault("system", {})["name"] = platform.system()
+
+    if platform.release():
+        data.setdefault("system", {})["release"] = platform.release()
+
+    if platform.machine():
+        data["cpu"] = platform.machine()
+
+    if has_tls():
+        import _ssl as ssl
+
+        data["openssl_version"] = ssl.OPENSSL_VERSION
+
+    setuptools_dist = get_default_environment().get_distribution("setuptools")
+    if setuptools_dist is not None:
+        data["setuptools_version"] = str(setuptools_dist.version)
+
+    if shutil.which("rustc") is not None:
+        # If for any reason `rustc --version` fails, silently ignore it
+        try:
+            rustc_output = subprocess.check_output(
+                ["rustc", "--version"], stderr=subprocess.STDOUT, timeout=0.5
+            )
+        except Exception:
+            pass
+        else:
+            if rustc_output.startswith(b"rustc "):
+                # The format of `rustc --version` is:
+                # `b'rustc 1.52.1 (9bc8c42bb 2021-05-09)\n'`
+                # We extract just the middle (1.52.1) part
+                data["rustc_version"] = rustc_output.split(b" ")[1].decode()
+
+    # Use None rather than False so as not to give the impression that
+    # pip knows it is not being run under CI.  Rather, it is a null or
+    # inconclusive result.  Also, we include some value rather than no
+    # value to make it easier to know that the check has been run.
+    data["ci"] = True if looks_like_ci() else None
+
+    user_data = os.environ.get("PIP_USER_AGENT_USER_DATA")
+    if user_data is not None:
+        data["user_data"] = user_data
+
+    return "{data[installer][name]}/{data[installer][version]} {json}".format(
+        data=data,
+        json=json.dumps(data, separators=(",", ":"), sort_keys=True),
+    )
+
+
+class LocalFSAdapter(BaseAdapter):
+    def send(
+        self,
+        request: PreparedRequest,
+        stream: bool = False,
+        timeout: Optional[Union[float, Tuple[float, float]]] = None,
+        verify: Union[bool, str] = True,
+        cert: Optional[Union[str, Tuple[str, str]]] = None,
+        proxies: Optional[Mapping[str, str]] = None,
+    ) -> Response:
+        pathname = url_to_path(request.url)
+
+        resp = Response()
+        resp.status_code = 200
+        resp.url = request.url
+
+        try:
+            stats = os.stat(pathname)
+        except OSError as exc:
+            # format the exception raised as a io.BytesIO object,
+            # to return a better error message:
+            resp.status_code = 404
+            resp.reason = type(exc).__name__
+            resp.raw = io.BytesIO(f"{resp.reason}: {exc}".encode())
+        else:
+            modified = email.utils.formatdate(stats.st_mtime, usegmt=True)
+            content_type = mimetypes.guess_type(pathname)[0] or "text/plain"
+            resp.headers = CaseInsensitiveDict(
+                {
+                    "Content-Type": content_type,
+                    "Content-Length": stats.st_size,
+                    "Last-Modified": modified,
+                }
+            )
+
+            resp.raw = open(pathname, "rb")
+            resp.close = resp.raw.close
+
+        return resp
+
+    def close(self) -> None:
+        pass
+
+
+class _SSLContextAdapterMixin:
+    """Mixin to add the ``ssl_context`` constructor argument to HTTP adapters.
+
+    The additional argument is forwarded directly to the pool manager. This allows us
+    to dynamically decide what SSL store to use at runtime, which is used to implement
+    the optional ``truststore`` backend.
+    """
+
+    def __init__(
+        self,
+        *,
+        ssl_context: Optional["SSLContext"] = None,
+        **kwargs: Any,
+    ) -> None:
+        self._ssl_context = ssl_context
+        super().__init__(**kwargs)
+
+    def init_poolmanager(
+        self,
+        connections: int,
+        maxsize: int,
+        block: bool = DEFAULT_POOLBLOCK,
+        **pool_kwargs: Any,
+    ) -> "PoolManager":
+        if self._ssl_context is not None:
+            pool_kwargs.setdefault("ssl_context", self._ssl_context)
+        return super().init_poolmanager(  # type: ignore[misc]
+            connections=connections,
+            maxsize=maxsize,
+            block=block,
+            **pool_kwargs,
+        )
+
+
+class HTTPAdapter(_SSLContextAdapterMixin, _BaseHTTPAdapter):
+    pass
+
+
+class CacheControlAdapter(_SSLContextAdapterMixin, _BaseCacheControlAdapter):
+    pass
+
+
+class InsecureHTTPAdapter(HTTPAdapter):
+    def cert_verify(
+        self,
+        conn: ConnectionPool,
+        url: str,
+        verify: Union[bool, str],
+        cert: Optional[Union[str, Tuple[str, str]]],
+    ) -> None:
+        super().cert_verify(conn=conn, url=url, verify=False, cert=cert)
+
+
+class InsecureCacheControlAdapter(CacheControlAdapter):
+    def cert_verify(
+        self,
+        conn: ConnectionPool,
+        url: str,
+        verify: Union[bool, str],
+        cert: Optional[Union[str, Tuple[str, str]]],
+    ) -> None:
+        super().cert_verify(conn=conn, url=url, verify=False, cert=cert)
+
+
+class PipSession(requests.Session):
+    timeout: Optional[int] = None
+
+    def __init__(
+        self,
+        *args: Any,
+        retries: int = 0,
+        cache: Optional[str] = None,
+        trusted_hosts: Sequence[str] = (),
+        index_urls: Optional[List[str]] = None,
+        ssl_context: Optional["SSLContext"] = None,
+        **kwargs: Any,
+    ) -> None:
+        """
+        :param trusted_hosts: Domains not to emit warnings for when not using
+            HTTPS.
+        """
+        super().__init__(*args, **kwargs)
+
+        # Namespace the attribute with "pip_" just in case to prevent
+        # possible conflicts with the base class.
+        self.pip_trusted_origins: List[Tuple[str, Optional[int]]] = []
+
+        # Attach our User Agent to the request
+        self.headers["User-Agent"] = user_agent()
+
+        # Attach our Authentication handler to the session
+        self.auth = MultiDomainBasicAuth(index_urls=index_urls)
+
+        # Create our urllib3.Retry instance which will allow us to customize
+        # how we handle retries.
+        retries = urllib3.Retry(
+            # Set the total number of retries that a particular request can
+            # have.
+            total=retries,
+            # A 503 error from PyPI typically means that the Fastly -> Origin
+            # connection got interrupted in some way. A 503 error in general
+            # is typically considered a transient error so we'll go ahead and
+            # retry it.
+            # A 500 may indicate transient error in Amazon S3
+            # A 502 may be a transient error from a CDN like CloudFlare or CloudFront
+            # A 520 or 527 - may indicate transient error in CloudFlare
+            status_forcelist=[500, 502, 503, 520, 527],
+            # Add a small amount of back off between failed requests in
+            # order to prevent hammering the service.
+            backoff_factor=0.25,
+        )  # type: ignore
+
+        # Our Insecure HTTPAdapter disables HTTPS validation. It does not
+        # support caching so we'll use it for all http:// URLs.
+        # If caching is disabled, we will also use it for
+        # https:// hosts that we've marked as ignoring
+        # TLS errors for (trusted-hosts).
+        insecure_adapter = InsecureHTTPAdapter(max_retries=retries)
+
+        # We want to _only_ cache responses on securely fetched origins or when
+        # the host is specified as trusted. We do this because
+        # we can't validate the response of an insecurely/untrusted fetched
+        # origin, and we don't want someone to be able to poison the cache and
+        # require manual eviction from the cache to fix it.
+        if cache:
+            secure_adapter = CacheControlAdapter(
+                cache=SafeFileCache(cache),
+                max_retries=retries,
+                ssl_context=ssl_context,
+            )
+            self._trusted_host_adapter = InsecureCacheControlAdapter(
+                cache=SafeFileCache(cache),
+                max_retries=retries,
+            )
+        else:
+            secure_adapter = HTTPAdapter(max_retries=retries, ssl_context=ssl_context)
+            self._trusted_host_adapter = insecure_adapter
+
+        self.mount("https://", secure_adapter)
+        self.mount("http://", insecure_adapter)
+
+        # Enable file:// urls
+        self.mount("file://", LocalFSAdapter())
+
+        for host in trusted_hosts:
+            self.add_trusted_host(host, suppress_logging=True)
+
+    def update_index_urls(self, new_index_urls: List[str]) -> None:
+        """
+        :param new_index_urls: New index urls to update the authentication
+            handler with.
+        """
+        self.auth.index_urls = new_index_urls
+
+    def add_trusted_host(
+        self, host: str, source: Optional[str] = None, suppress_logging: bool = False
+    ) -> None:
+        """
+        :param host: It is okay to provide a host that has previously been
+            added.
+        :param source: An optional source string, for logging where the host
+            string came from.
+        """
+        if not suppress_logging:
+            msg = f"adding trusted host: {host!r}"
+            if source is not None:
+                msg += f" (from {source})"
+            logger.info(msg)
+
+        parsed_host, parsed_port = parse_netloc(host)
+        if parsed_host is None:
+            raise ValueError(f"Trusted host URL must include a host part: {host!r}")
+        if (parsed_host, parsed_port) not in self.pip_trusted_origins:
+            self.pip_trusted_origins.append((parsed_host, parsed_port))
+
+        self.mount(
+            build_url_from_netloc(host, scheme="http") + "/", self._trusted_host_adapter
+        )
+        self.mount(build_url_from_netloc(host) + "/", self._trusted_host_adapter)
+        if not parsed_port:
+            self.mount(
+                build_url_from_netloc(host, scheme="http") + ":",
+                self._trusted_host_adapter,
+            )
+            # Mount wildcard ports for the same host.
+            self.mount(build_url_from_netloc(host) + ":", self._trusted_host_adapter)
+
+    def iter_secure_origins(self) -> Generator[SecureOrigin, None, None]:
+        yield from SECURE_ORIGINS
+        for host, port in self.pip_trusted_origins:
+            yield ("*", host, "*" if port is None else port)
+
+    def is_secure_origin(self, location: Link) -> bool:
+        # Determine if this url used a secure transport mechanism
+        parsed = urllib.parse.urlparse(str(location))
+        origin_protocol, origin_host, origin_port = (
+            parsed.scheme,
+            parsed.hostname,
+            parsed.port,
+        )
+
+        # The protocol to use to see if the protocol matches.
+        # Don't count the repository type as part of the protocol: in
+        # cases such as "git+ssh", only use "ssh". (I.e., Only verify against
+        # the last scheme.)
+        origin_protocol = origin_protocol.rsplit("+", 1)[-1]
+
+        # Determine if our origin is a secure origin by looking through our
+        # hardcoded list of secure origins, as well as any additional ones
+        # configured on this PackageFinder instance.
+        for secure_origin in self.iter_secure_origins():
+            secure_protocol, secure_host, secure_port = secure_origin
+            if origin_protocol != secure_protocol and secure_protocol != "*":
+                continue
+
+            try:
+                addr = ipaddress.ip_address(origin_host or "")
+                network = ipaddress.ip_network(secure_host)
+            except ValueError:
+                # We don't have both a valid address or a valid network, so
+                # we'll check this origin against hostnames.
+                if (
+                    origin_host
+                    and origin_host.lower() != secure_host.lower()
+                    and secure_host != "*"
+                ):
+                    continue
+            else:
+                # We have a valid address and network, so see if the address
+                # is contained within the network.
+                if addr not in network:
+                    continue
+
+            # Check to see if the port matches.
+            if (
+                origin_port != secure_port
+                and secure_port != "*"
+                and secure_port is not None
+            ):
+                continue
+
+            # If we've gotten here, then this origin matches the current
+            # secure origin and we should return True
+            return True
+
+        # If we've gotten to this point, then the origin isn't secure and we
+        # will not accept it as a valid location to search. We will however
+        # log a warning that we are ignoring it.
+        logger.warning(
+            "The repository located at %s is not a trusted or secure host and "
+            "is being ignored. If this repository is available via HTTPS we "
+            "recommend you use HTTPS instead, otherwise you may silence "
+            "this warning and allow it anyway with '--trusted-host %s'.",
+            origin_host,
+            origin_host,
+        )
+
+        return False
+
+    def request(self, method: str, url: str, *args: Any, **kwargs: Any) -> Response:
+        # Allow setting a default timeout on a session
+        kwargs.setdefault("timeout", self.timeout)
+        # Allow setting a default proxies on a session
+        kwargs.setdefault("proxies", self.proxies)
+
+        # Dispatch the actual request
+        return super().request(method, url, *args, **kwargs)
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/network/utils.py b/venv/lib/python3.12/site-packages/pip/_internal/network/utils.py
new file mode 100644
index 00000000..bba4c265
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/network/utils.py
@@ -0,0 +1,98 @@
+from typing import Dict, Generator
+
+from pip._vendor.requests.models import Response
+
+from pip._internal.exceptions import NetworkConnectionError
+
+# The following comments and HTTP headers were originally added by
+# Donald Stufft in git commit 22c562429a61bb77172039e480873fb239dd8c03.
+#
+# We use Accept-Encoding: identity here because requests defaults to
+# accepting compressed responses. This breaks in a variety of ways
+# depending on how the server is configured.
+# - Some servers will notice that the file isn't a compressible file
+#   and will leave the file alone and with an empty Content-Encoding
+# - Some servers will notice that the file is already compressed and
+#   will leave the file alone, adding a Content-Encoding: gzip header
+# - Some servers won't notice anything at all and will take a file
+#   that's already been compressed and compress it again, and set
+#   the Content-Encoding: gzip header
+# By setting this to request only the identity encoding we're hoping
+# to eliminate the third case.  Hopefully there does not exist a server
+# which when given a file will notice it is already compressed and that
+# you're not asking for a compressed file and will then decompress it
+# before sending because if that's the case I don't think it'll ever be
+# possible to make this work.
+HEADERS: Dict[str, str] = {"Accept-Encoding": "identity"}
+
+DOWNLOAD_CHUNK_SIZE = 256 * 1024
+
+
+def raise_for_status(resp: Response) -> None:
+    http_error_msg = ""
+    if isinstance(resp.reason, bytes):
+        # We attempt to decode utf-8 first because some servers
+        # choose to localize their reason strings. If the string
+        # isn't utf-8, we fall back to iso-8859-1 for all other
+        # encodings.
+        try:
+            reason = resp.reason.decode("utf-8")
+        except UnicodeDecodeError:
+            reason = resp.reason.decode("iso-8859-1")
+    else:
+        reason = resp.reason
+
+    if 400 <= resp.status_code < 500:
+        http_error_msg = (
+            f"{resp.status_code} Client Error: {reason} for url: {resp.url}"
+        )
+
+    elif 500 <= resp.status_code < 600:
+        http_error_msg = (
+            f"{resp.status_code} Server Error: {reason} for url: {resp.url}"
+        )
+
+    if http_error_msg:
+        raise NetworkConnectionError(http_error_msg, response=resp)
+
+
+def response_chunks(
+    response: Response, chunk_size: int = DOWNLOAD_CHUNK_SIZE
+) -> Generator[bytes, None, None]:
+    """Given a requests Response, provide the data chunks."""
+    try:
+        # Special case for urllib3.
+        for chunk in response.raw.stream(
+            chunk_size,
+            # We use decode_content=False here because we don't
+            # want urllib3 to mess with the raw bytes we get
+            # from the server. If we decompress inside of
+            # urllib3 then we cannot verify the checksum
+            # because the checksum will be of the compressed
+            # file. This breakage will only occur if the
+            # server adds a Content-Encoding header, which
+            # depends on how the server was configured:
+            # - Some servers will notice that the file isn't a
+            #   compressible file and will leave the file alone
+            #   and with an empty Content-Encoding
+            # - Some servers will notice that the file is
+            #   already compressed and will leave the file
+            #   alone and will add a Content-Encoding: gzip
+            #   header
+            # - Some servers won't notice anything at all and
+            #   will take a file that's already been compressed
+            #   and compress it again and set the
+            #   Content-Encoding: gzip header
+            #
+            # By setting this not to decode automatically we
+            # hope to eliminate problems with the second case.
+            decode_content=False,
+        ):
+            yield chunk
+    except AttributeError:
+        # Standard file-like object.
+        while True:
+            chunk = response.raw.read(chunk_size)
+            if not chunk:
+                break
+            yield chunk
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/network/xmlrpc.py b/venv/lib/python3.12/site-packages/pip/_internal/network/xmlrpc.py
new file mode 100644
index 00000000..22ec8d2f
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/network/xmlrpc.py
@@ -0,0 +1,62 @@
+"""xmlrpclib.Transport implementation
+"""
+
+import logging
+import urllib.parse
+import xmlrpc.client
+from typing import TYPE_CHECKING, Tuple
+
+from pip._internal.exceptions import NetworkConnectionError
+from pip._internal.network.session import PipSession
+from pip._internal.network.utils import raise_for_status
+
+if TYPE_CHECKING:
+    from xmlrpc.client import _HostType, _Marshallable
+
+    from _typeshed import SizedBuffer
+
+logger = logging.getLogger(__name__)
+
+
+class PipXmlrpcTransport(xmlrpc.client.Transport):
+    """Provide a `xmlrpclib.Transport` implementation via a `PipSession`
+    object.
+    """
+
+    def __init__(
+        self, index_url: str, session: PipSession, use_datetime: bool = False
+    ) -> None:
+        super().__init__(use_datetime)
+        index_parts = urllib.parse.urlparse(index_url)
+        self._scheme = index_parts.scheme
+        self._session = session
+
+    def request(
+        self,
+        host: "_HostType",
+        handler: str,
+        request_body: "SizedBuffer",
+        verbose: bool = False,
+    ) -> Tuple["_Marshallable", ...]:
+        assert isinstance(host, str)
+        parts = (self._scheme, host, handler, None, None, None)
+        url = urllib.parse.urlunparse(parts)
+        try:
+            headers = {"Content-Type": "text/xml"}
+            response = self._session.post(
+                url,
+                data=request_body,
+                headers=headers,
+                stream=True,
+            )
+            raise_for_status(response)
+            self.verbose = verbose
+            return self.parse_response(response.raw)
+        except NetworkConnectionError as exc:
+            assert exc.response
+            logger.critical(
+                "HTTP error %s while getting %s",
+                exc.response.status_code,
+                url,
+            )
+            raise
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/operations/__init__.py b/venv/lib/python3.12/site-packages/pip/_internal/operations/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/operations/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/operations/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 00000000..18db14eb
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/operations/__pycache__/__init__.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/operations/__pycache__/check.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/operations/__pycache__/check.cpython-312.pyc
new file mode 100644
index 00000000..e5e72d00
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/operations/__pycache__/check.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/operations/__pycache__/freeze.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/operations/__pycache__/freeze.cpython-312.pyc
new file mode 100644
index 00000000..4d7da9a3
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/operations/__pycache__/freeze.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/operations/__pycache__/prepare.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/operations/__pycache__/prepare.cpython-312.pyc
new file mode 100644
index 00000000..a772dcf9
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/operations/__pycache__/prepare.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/operations/build/__init__.py b/venv/lib/python3.12/site-packages/pip/_internal/operations/build/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/operations/build/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/operations/build/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 00000000..7c30e7df
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/operations/build/__pycache__/__init__.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/operations/build/__pycache__/build_tracker.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/operations/build/__pycache__/build_tracker.cpython-312.pyc
new file mode 100644
index 00000000..0db99367
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/operations/build/__pycache__/build_tracker.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/operations/build/__pycache__/metadata.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/operations/build/__pycache__/metadata.cpython-312.pyc
new file mode 100644
index 00000000..f67ff637
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/operations/build/__pycache__/metadata.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/operations/build/__pycache__/metadata_editable.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/operations/build/__pycache__/metadata_editable.cpython-312.pyc
new file mode 100644
index 00000000..c485975f
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/operations/build/__pycache__/metadata_editable.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/operations/build/__pycache__/metadata_legacy.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/operations/build/__pycache__/metadata_legacy.cpython-312.pyc
new file mode 100644
index 00000000..456ceeba
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/operations/build/__pycache__/metadata_legacy.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/operations/build/__pycache__/wheel.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/operations/build/__pycache__/wheel.cpython-312.pyc
new file mode 100644
index 00000000..0d63a96a
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/operations/build/__pycache__/wheel.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/operations/build/__pycache__/wheel_editable.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/operations/build/__pycache__/wheel_editable.cpython-312.pyc
new file mode 100644
index 00000000..10d57528
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/operations/build/__pycache__/wheel_editable.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/operations/build/__pycache__/wheel_legacy.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/operations/build/__pycache__/wheel_legacy.cpython-312.pyc
new file mode 100644
index 00000000..67751c85
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/operations/build/__pycache__/wheel_legacy.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/operations/build/build_tracker.py b/venv/lib/python3.12/site-packages/pip/_internal/operations/build/build_tracker.py
new file mode 100644
index 00000000..0ed8dd23
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/operations/build/build_tracker.py
@@ -0,0 +1,138 @@
+import contextlib
+import hashlib
+import logging
+import os
+from types import TracebackType
+from typing import Dict, Generator, Optional, Type, Union
+
+from pip._internal.req.req_install import InstallRequirement
+from pip._internal.utils.temp_dir import TempDirectory
+
+logger = logging.getLogger(__name__)
+
+
+@contextlib.contextmanager
+def update_env_context_manager(**changes: str) -> Generator[None, None, None]:
+    target = os.environ
+
+    # Save values from the target and change them.
+    non_existent_marker = object()
+    saved_values: Dict[str, Union[object, str]] = {}
+    for name, new_value in changes.items():
+        try:
+            saved_values[name] = target[name]
+        except KeyError:
+            saved_values[name] = non_existent_marker
+        target[name] = new_value
+
+    try:
+        yield
+    finally:
+        # Restore original values in the target.
+        for name, original_value in saved_values.items():
+            if original_value is non_existent_marker:
+                del target[name]
+            else:
+                assert isinstance(original_value, str)  # for mypy
+                target[name] = original_value
+
+
+@contextlib.contextmanager
+def get_build_tracker() -> Generator["BuildTracker", None, None]:
+    root = os.environ.get("PIP_BUILD_TRACKER")
+    with contextlib.ExitStack() as ctx:
+        if root is None:
+            root = ctx.enter_context(TempDirectory(kind="build-tracker")).path
+            ctx.enter_context(update_env_context_manager(PIP_BUILD_TRACKER=root))
+            logger.debug("Initialized build tracking at %s", root)
+
+        with BuildTracker(root) as tracker:
+            yield tracker
+
+
+class TrackerId(str):
+    """Uniquely identifying string provided to the build tracker."""
+
+
+class BuildTracker:
+    """Ensure that an sdist cannot request itself as a setup requirement.
+
+    When an sdist is prepared, it identifies its setup requirements in the
+    context of ``BuildTracker.track()``. If a requirement shows up recursively, this
+    raises an exception.
+
+    This stops fork bombs embedded in malicious packages."""
+
+    def __init__(self, root: str) -> None:
+        self._root = root
+        self._entries: Dict[TrackerId, InstallRequirement] = {}
+        logger.debug("Created build tracker: %s", self._root)
+
+    def __enter__(self) -> "BuildTracker":
+        logger.debug("Entered build tracker: %s", self._root)
+        return self
+
+    def __exit__(
+        self,
+        exc_type: Optional[Type[BaseException]],
+        exc_val: Optional[BaseException],
+        exc_tb: Optional[TracebackType],
+    ) -> None:
+        self.cleanup()
+
+    def _entry_path(self, key: TrackerId) -> str:
+        hashed = hashlib.sha224(key.encode()).hexdigest()
+        return os.path.join(self._root, hashed)
+
+    def add(self, req: InstallRequirement, key: TrackerId) -> None:
+        """Add an InstallRequirement to build tracking."""
+
+        # Get the file to write information about this requirement.
+        entry_path = self._entry_path(key)
+
+        # Try reading from the file. If it exists and can be read from, a build
+        # is already in progress, so a LookupError is raised.
+        try:
+            with open(entry_path) as fp:
+                contents = fp.read()
+        except FileNotFoundError:
+            pass
+        else:
+            message = f"{req.link} is already being built: {contents}"
+            raise LookupError(message)
+
+        # If we're here, req should really not be building already.
+        assert key not in self._entries
+
+        # Start tracking this requirement.
+        with open(entry_path, "w", encoding="utf-8") as fp:
+            fp.write(str(req))
+        self._entries[key] = req
+
+        logger.debug("Added %s to build tracker %r", req, self._root)
+
+    def remove(self, req: InstallRequirement, key: TrackerId) -> None:
+        """Remove an InstallRequirement from build tracking."""
+
+        # Delete the created file and the corresponding entry.
+        os.unlink(self._entry_path(key))
+        del self._entries[key]
+
+        logger.debug("Removed %s from build tracker %r", req, self._root)
+
+    def cleanup(self) -> None:
+        for key, req in list(self._entries.items()):
+            self.remove(req, key)
+
+        logger.debug("Removed build tracker: %r", self._root)
+
+    @contextlib.contextmanager
+    def track(self, req: InstallRequirement, key: str) -> Generator[None, None, None]:
+        """Ensure that `key` cannot install itself as a setup requirement.
+
+        :raises LookupError: If `key` was already provided in a parent invocation of
+                             the context introduced by this method."""
+        tracker_id = TrackerId(key)
+        self.add(req, tracker_id)
+        yield
+        self.remove(req, tracker_id)
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/operations/build/metadata.py b/venv/lib/python3.12/site-packages/pip/_internal/operations/build/metadata.py
new file mode 100644
index 00000000..c66ac354
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/operations/build/metadata.py
@@ -0,0 +1,39 @@
+"""Metadata generation logic for source distributions.
+"""
+
+import os
+
+from pip._vendor.pyproject_hooks import BuildBackendHookCaller
+
+from pip._internal.build_env import BuildEnvironment
+from pip._internal.exceptions import (
+    InstallationSubprocessError,
+    MetadataGenerationFailed,
+)
+from pip._internal.utils.subprocess import runner_with_spinner_message
+from pip._internal.utils.temp_dir import TempDirectory
+
+
+def generate_metadata(
+    build_env: BuildEnvironment, backend: BuildBackendHookCaller, details: str
+) -> str:
+    """Generate metadata using mechanisms described in PEP 517.
+
+    Returns the generated metadata directory.
+    """
+    metadata_tmpdir = TempDirectory(kind="modern-metadata", globally_managed=True)
+
+    metadata_dir = metadata_tmpdir.path
+
+    with build_env:
+        # Note that BuildBackendHookCaller implements a fallback for
+        # prepare_metadata_for_build_wheel, so we don't have to
+        # consider the possibility that this hook doesn't exist.
+        runner = runner_with_spinner_message("Preparing metadata (pyproject.toml)")
+        with backend.subprocess_runner(runner):
+            try:
+                distinfo_dir = backend.prepare_metadata_for_build_wheel(metadata_dir)
+            except InstallationSubprocessError as error:
+                raise MetadataGenerationFailed(package_details=details) from error
+
+    return os.path.join(metadata_dir, distinfo_dir)
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/operations/build/metadata_editable.py b/venv/lib/python3.12/site-packages/pip/_internal/operations/build/metadata_editable.py
new file mode 100644
index 00000000..27c69f0d
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/operations/build/metadata_editable.py
@@ -0,0 +1,41 @@
+"""Metadata generation logic for source distributions.
+"""
+
+import os
+
+from pip._vendor.pyproject_hooks import BuildBackendHookCaller
+
+from pip._internal.build_env import BuildEnvironment
+from pip._internal.exceptions import (
+    InstallationSubprocessError,
+    MetadataGenerationFailed,
+)
+from pip._internal.utils.subprocess import runner_with_spinner_message
+from pip._internal.utils.temp_dir import TempDirectory
+
+
+def generate_editable_metadata(
+    build_env: BuildEnvironment, backend: BuildBackendHookCaller, details: str
+) -> str:
+    """Generate metadata using mechanisms described in PEP 660.
+
+    Returns the generated metadata directory.
+    """
+    metadata_tmpdir = TempDirectory(kind="modern-metadata", globally_managed=True)
+
+    metadata_dir = metadata_tmpdir.path
+
+    with build_env:
+        # Note that BuildBackendHookCaller implements a fallback for
+        # prepare_metadata_for_build_wheel/editable, so we don't have to
+        # consider the possibility that this hook doesn't exist.
+        runner = runner_with_spinner_message(
+            "Preparing editable metadata (pyproject.toml)"
+        )
+        with backend.subprocess_runner(runner):
+            try:
+                distinfo_dir = backend.prepare_metadata_for_build_editable(metadata_dir)
+            except InstallationSubprocessError as error:
+                raise MetadataGenerationFailed(package_details=details) from error
+
+    return os.path.join(metadata_dir, distinfo_dir)
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/operations/build/metadata_legacy.py b/venv/lib/python3.12/site-packages/pip/_internal/operations/build/metadata_legacy.py
new file mode 100644
index 00000000..c01dd1c6
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/operations/build/metadata_legacy.py
@@ -0,0 +1,74 @@
+"""Metadata generation logic for legacy source distributions.
+"""
+
+import logging
+import os
+
+from pip._internal.build_env import BuildEnvironment
+from pip._internal.cli.spinners import open_spinner
+from pip._internal.exceptions import (
+    InstallationError,
+    InstallationSubprocessError,
+    MetadataGenerationFailed,
+)
+from pip._internal.utils.setuptools_build import make_setuptools_egg_info_args
+from pip._internal.utils.subprocess import call_subprocess
+from pip._internal.utils.temp_dir import TempDirectory
+
+logger = logging.getLogger(__name__)
+
+
+def _find_egg_info(directory: str) -> str:
+    """Find an .egg-info subdirectory in `directory`."""
+    filenames = [f for f in os.listdir(directory) if f.endswith(".egg-info")]
+
+    if not filenames:
+        raise InstallationError(f"No .egg-info directory found in {directory}")
+
+    if len(filenames) > 1:
+        raise InstallationError(
+            f"More than one .egg-info directory found in {directory}"
+        )
+
+    return os.path.join(directory, filenames[0])
+
+
+def generate_metadata(
+    build_env: BuildEnvironment,
+    setup_py_path: str,
+    source_dir: str,
+    isolated: bool,
+    details: str,
+) -> str:
+    """Generate metadata using setup.py-based defacto mechanisms.
+
+    Returns the generated metadata directory.
+    """
+    logger.debug(
+        "Running setup.py (path:%s) egg_info for package %s",
+        setup_py_path,
+        details,
+    )
+
+    egg_info_dir = TempDirectory(kind="pip-egg-info", globally_managed=True).path
+
+    args = make_setuptools_egg_info_args(
+        setup_py_path,
+        egg_info_dir=egg_info_dir,
+        no_user_config=isolated,
+    )
+
+    with build_env:
+        with open_spinner("Preparing metadata (setup.py)") as spinner:
+            try:
+                call_subprocess(
+                    args,
+                    cwd=source_dir,
+                    command_desc="python setup.py egg_info",
+                    spinner=spinner,
+                )
+            except InstallationSubprocessError as error:
+                raise MetadataGenerationFailed(package_details=details) from error
+
+    # Return the .egg-info directory.
+    return _find_egg_info(egg_info_dir)
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/operations/build/wheel.py b/venv/lib/python3.12/site-packages/pip/_internal/operations/build/wheel.py
new file mode 100644
index 00000000..064811ad
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/operations/build/wheel.py
@@ -0,0 +1,37 @@
+import logging
+import os
+from typing import Optional
+
+from pip._vendor.pyproject_hooks import BuildBackendHookCaller
+
+from pip._internal.utils.subprocess import runner_with_spinner_message
+
+logger = logging.getLogger(__name__)
+
+
+def build_wheel_pep517(
+    name: str,
+    backend: BuildBackendHookCaller,
+    metadata_directory: str,
+    tempd: str,
+) -> Optional[str]:
+    """Build one InstallRequirement using the PEP 517 build process.
+
+    Returns path to wheel if successfully built. Otherwise, returns None.
+    """
+    assert metadata_directory is not None
+    try:
+        logger.debug("Destination directory: %s", tempd)
+
+        runner = runner_with_spinner_message(
+            f"Building wheel for {name} (pyproject.toml)"
+        )
+        with backend.subprocess_runner(runner):
+            wheel_name = backend.build_wheel(
+                tempd,
+                metadata_directory=metadata_directory,
+            )
+    except Exception:
+        logger.error("Failed building wheel for %s", name)
+        return None
+    return os.path.join(tempd, wheel_name)
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/operations/build/wheel_editable.py b/venv/lib/python3.12/site-packages/pip/_internal/operations/build/wheel_editable.py
new file mode 100644
index 00000000..719d69dd
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/operations/build/wheel_editable.py
@@ -0,0 +1,46 @@
+import logging
+import os
+from typing import Optional
+
+from pip._vendor.pyproject_hooks import BuildBackendHookCaller, HookMissing
+
+from pip._internal.utils.subprocess import runner_with_spinner_message
+
+logger = logging.getLogger(__name__)
+
+
+def build_wheel_editable(
+    name: str,
+    backend: BuildBackendHookCaller,
+    metadata_directory: str,
+    tempd: str,
+) -> Optional[str]:
+    """Build one InstallRequirement using the PEP 660 build process.
+
+    Returns path to wheel if successfully built. Otherwise, returns None.
+    """
+    assert metadata_directory is not None
+    try:
+        logger.debug("Destination directory: %s", tempd)
+
+        runner = runner_with_spinner_message(
+            f"Building editable for {name} (pyproject.toml)"
+        )
+        with backend.subprocess_runner(runner):
+            try:
+                wheel_name = backend.build_editable(
+                    tempd,
+                    metadata_directory=metadata_directory,
+                )
+            except HookMissing as e:
+                logger.error(
+                    "Cannot build editable %s because the build "
+                    "backend does not have the %s hook",
+                    name,
+                    e,
+                )
+                return None
+    except Exception:
+        logger.error("Failed building editable for %s", name)
+        return None
+    return os.path.join(tempd, wheel_name)
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/operations/build/wheel_legacy.py b/venv/lib/python3.12/site-packages/pip/_internal/operations/build/wheel_legacy.py
new file mode 100644
index 00000000..3ee2a705
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/operations/build/wheel_legacy.py
@@ -0,0 +1,102 @@
+import logging
+import os.path
+from typing import List, Optional
+
+from pip._internal.cli.spinners import open_spinner
+from pip._internal.utils.setuptools_build import make_setuptools_bdist_wheel_args
+from pip._internal.utils.subprocess import call_subprocess, format_command_args
+
+logger = logging.getLogger(__name__)
+
+
+def format_command_result(
+    command_args: List[str],
+    command_output: str,
+) -> str:
+    """Format command information for logging."""
+    command_desc = format_command_args(command_args)
+    text = f"Command arguments: {command_desc}\n"
+
+    if not command_output:
+        text += "Command output: None"
+    elif logger.getEffectiveLevel() > logging.DEBUG:
+        text += "Command output: [use --verbose to show]"
+    else:
+        if not command_output.endswith("\n"):
+            command_output += "\n"
+        text += f"Command output:\n{command_output}"
+
+    return text
+
+
+def get_legacy_build_wheel_path(
+    names: List[str],
+    temp_dir: str,
+    name: str,
+    command_args: List[str],
+    command_output: str,
+) -> Optional[str]:
+    """Return the path to the wheel in the temporary build directory."""
+    # Sort for determinism.
+    names = sorted(names)
+    if not names:
+        msg = f"Legacy build of wheel for {name!r} created no files.\n"
+        msg += format_command_result(command_args, command_output)
+        logger.warning(msg)
+        return None
+
+    if len(names) > 1:
+        msg = (
+            f"Legacy build of wheel for {name!r} created more than one file.\n"
+            f"Filenames (choosing first): {names}\n"
+        )
+        msg += format_command_result(command_args, command_output)
+        logger.warning(msg)
+
+    return os.path.join(temp_dir, names[0])
+
+
+def build_wheel_legacy(
+    name: str,
+    setup_py_path: str,
+    source_dir: str,
+    global_options: List[str],
+    build_options: List[str],
+    tempd: str,
+) -> Optional[str]:
+    """Build one unpacked package using the "legacy" build process.
+
+    Returns path to wheel if successfully built. Otherwise, returns None.
+    """
+    wheel_args = make_setuptools_bdist_wheel_args(
+        setup_py_path,
+        global_options=global_options,
+        build_options=build_options,
+        destination_dir=tempd,
+    )
+
+    spin_message = f"Building wheel for {name} (setup.py)"
+    with open_spinner(spin_message) as spinner:
+        logger.debug("Destination directory: %s", tempd)
+
+        try:
+            output = call_subprocess(
+                wheel_args,
+                command_desc="python setup.py bdist_wheel",
+                cwd=source_dir,
+                spinner=spinner,
+            )
+        except Exception:
+            spinner.finish("error")
+            logger.error("Failed building wheel for %s", name)
+            return None
+
+        names = os.listdir(tempd)
+        wheel_path = get_legacy_build_wheel_path(
+            names=names,
+            temp_dir=tempd,
+            name=name,
+            command_args=wheel_args,
+            command_output=output,
+        )
+        return wheel_path
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/operations/check.py b/venv/lib/python3.12/site-packages/pip/_internal/operations/check.py
new file mode 100644
index 00000000..4b6fbc4c
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/operations/check.py
@@ -0,0 +1,181 @@
+"""Validation of dependencies of packages
+"""
+
+import logging
+from contextlib import suppress
+from email.parser import Parser
+from functools import reduce
+from typing import (
+    Callable,
+    Dict,
+    FrozenSet,
+    Generator,
+    Iterable,
+    List,
+    NamedTuple,
+    Optional,
+    Set,
+    Tuple,
+)
+
+from pip._vendor.packaging.requirements import Requirement
+from pip._vendor.packaging.tags import Tag, parse_tag
+from pip._vendor.packaging.utils import NormalizedName, canonicalize_name
+from pip._vendor.packaging.version import Version
+
+from pip._internal.distributions import make_distribution_for_install_requirement
+from pip._internal.metadata import get_default_environment
+from pip._internal.metadata.base import BaseDistribution
+from pip._internal.req.req_install import InstallRequirement
+
+logger = logging.getLogger(__name__)
+
+
+class PackageDetails(NamedTuple):
+    version: Version
+    dependencies: List[Requirement]
+
+
+# Shorthands
+PackageSet = Dict[NormalizedName, PackageDetails]
+Missing = Tuple[NormalizedName, Requirement]
+Conflicting = Tuple[NormalizedName, Version, Requirement]
+
+MissingDict = Dict[NormalizedName, List[Missing]]
+ConflictingDict = Dict[NormalizedName, List[Conflicting]]
+CheckResult = Tuple[MissingDict, ConflictingDict]
+ConflictDetails = Tuple[PackageSet, CheckResult]
+
+
+def create_package_set_from_installed() -> Tuple[PackageSet, bool]:
+    """Converts a list of distributions into a PackageSet."""
+    package_set = {}
+    problems = False
+    env = get_default_environment()
+    for dist in env.iter_installed_distributions(local_only=False, skip=()):
+        name = dist.canonical_name
+        try:
+            dependencies = list(dist.iter_dependencies())
+            package_set[name] = PackageDetails(dist.version, dependencies)
+        except (OSError, ValueError) as e:
+            # Don't crash on unreadable or broken metadata.
+            logger.warning("Error parsing dependencies of %s: %s", name, e)
+            problems = True
+    return package_set, problems
+
+
+def check_package_set(
+    package_set: PackageSet, should_ignore: Optional[Callable[[str], bool]] = None
+) -> CheckResult:
+    """Check if a package set is consistent
+
+    If should_ignore is passed, it should be a callable that takes a
+    package name and returns a boolean.
+    """
+
+    missing = {}
+    conflicting = {}
+
+    for package_name, package_detail in package_set.items():
+        # Info about dependencies of package_name
+        missing_deps: Set[Missing] = set()
+        conflicting_deps: Set[Conflicting] = set()
+
+        if should_ignore and should_ignore(package_name):
+            continue
+
+        for req in package_detail.dependencies:
+            name = canonicalize_name(req.name)
+
+            # Check if it's missing
+            if name not in package_set:
+                missed = True
+                if req.marker is not None:
+                    missed = req.marker.evaluate({"extra": ""})
+                if missed:
+                    missing_deps.add((name, req))
+                continue
+
+            # Check if there's a conflict
+            version = package_set[name].version
+            if not req.specifier.contains(version, prereleases=True):
+                conflicting_deps.add((name, version, req))
+
+        if missing_deps:
+            missing[package_name] = sorted(missing_deps, key=str)
+        if conflicting_deps:
+            conflicting[package_name] = sorted(conflicting_deps, key=str)
+
+    return missing, conflicting
+
+
+def check_install_conflicts(to_install: List[InstallRequirement]) -> ConflictDetails:
+    """For checking if the dependency graph would be consistent after \
+    installing given requirements
+    """
+    # Start from the current state
+    package_set, _ = create_package_set_from_installed()
+    # Install packages
+    would_be_installed = _simulate_installation_of(to_install, package_set)
+
+    # Only warn about directly-dependent packages; create a whitelist of them
+    whitelist = _create_whitelist(would_be_installed, package_set)
+
+    return (
+        package_set,
+        check_package_set(
+            package_set, should_ignore=lambda name: name not in whitelist
+        ),
+    )
+
+
+def check_unsupported(
+    packages: Iterable[BaseDistribution],
+    supported_tags: Iterable[Tag],
+) -> Generator[BaseDistribution, None, None]:
+    for p in packages:
+        with suppress(FileNotFoundError):
+            wheel_file = p.read_text("WHEEL")
+            wheel_tags: FrozenSet[Tag] = reduce(
+                frozenset.union,
+                map(parse_tag, Parser().parsestr(wheel_file).get_all("Tag", [])),
+                frozenset(),
+            )
+            if wheel_tags.isdisjoint(supported_tags):
+                yield p
+
+
+def _simulate_installation_of(
+    to_install: List[InstallRequirement], package_set: PackageSet
+) -> Set[NormalizedName]:
+    """Computes the version of packages after installing to_install."""
+    # Keep track of packages that were installed
+    installed = set()
+
+    # Modify it as installing requirement_set would (assuming no errors)
+    for inst_req in to_install:
+        abstract_dist = make_distribution_for_install_requirement(inst_req)
+        dist = abstract_dist.get_metadata_distribution()
+        name = dist.canonical_name
+        package_set[name] = PackageDetails(dist.version, list(dist.iter_dependencies()))
+
+        installed.add(name)
+
+    return installed
+
+
+def _create_whitelist(
+    would_be_installed: Set[NormalizedName], package_set: PackageSet
+) -> Set[NormalizedName]:
+    packages_affected = set(would_be_installed)
+
+    for package_name in package_set:
+        if package_name in packages_affected:
+            continue
+
+        for req in package_set[package_name].dependencies:
+            if canonicalize_name(req.name) in packages_affected:
+                packages_affected.add(package_name)
+                break
+
+    return packages_affected
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/operations/freeze.py b/venv/lib/python3.12/site-packages/pip/_internal/operations/freeze.py
new file mode 100644
index 00000000..bb1039fb
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/operations/freeze.py
@@ -0,0 +1,258 @@
+import collections
+import logging
+import os
+from typing import Container, Dict, Generator, Iterable, List, NamedTuple, Optional, Set
+
+from pip._vendor.packaging.utils import canonicalize_name
+from pip._vendor.packaging.version import InvalidVersion
+
+from pip._internal.exceptions import BadCommand, InstallationError
+from pip._internal.metadata import BaseDistribution, get_environment
+from pip._internal.req.constructors import (
+    install_req_from_editable,
+    install_req_from_line,
+)
+from pip._internal.req.req_file import COMMENT_RE
+from pip._internal.utils.direct_url_helpers import direct_url_as_pep440_direct_reference
+
+logger = logging.getLogger(__name__)
+
+
+class _EditableInfo(NamedTuple):
+    requirement: str
+    comments: List[str]
+
+
+def freeze(
+    requirement: Optional[List[str]] = None,
+    local_only: bool = False,
+    user_only: bool = False,
+    paths: Optional[List[str]] = None,
+    isolated: bool = False,
+    exclude_editable: bool = False,
+    skip: Container[str] = (),
+) -> Generator[str, None, None]:
+    installations: Dict[str, FrozenRequirement] = {}
+
+    dists = get_environment(paths).iter_installed_distributions(
+        local_only=local_only,
+        skip=(),
+        user_only=user_only,
+    )
+    for dist in dists:
+        req = FrozenRequirement.from_dist(dist)
+        if exclude_editable and req.editable:
+            continue
+        installations[req.canonical_name] = req
+
+    if requirement:
+        # the options that don't get turned into an InstallRequirement
+        # should only be emitted once, even if the same option is in multiple
+        # requirements files, so we need to keep track of what has been emitted
+        # so that we don't emit it again if it's seen again
+        emitted_options: Set[str] = set()
+        # keep track of which files a requirement is in so that we can
+        # give an accurate warning if a requirement appears multiple times.
+        req_files: Dict[str, List[str]] = collections.defaultdict(list)
+        for req_file_path in requirement:
+            with open(req_file_path) as req_file:
+                for line in req_file:
+                    if (
+                        not line.strip()
+                        or line.strip().startswith("#")
+                        or line.startswith(
+                            (
+                                "-r",
+                                "--requirement",
+                                "-f",
+                                "--find-links",
+                                "-i",
+                                "--index-url",
+                                "--pre",
+                                "--trusted-host",
+                                "--process-dependency-links",
+                                "--extra-index-url",
+                                "--use-feature",
+                            )
+                        )
+                    ):
+                        line = line.rstrip()
+                        if line not in emitted_options:
+                            emitted_options.add(line)
+                            yield line
+                        continue
+
+                    if line.startswith("-e") or line.startswith("--editable"):
+                        if line.startswith("-e"):
+                            line = line[2:].strip()
+                        else:
+                            line = line[len("--editable") :].strip().lstrip("=")
+                        line_req = install_req_from_editable(
+                            line,
+                            isolated=isolated,
+                        )
+                    else:
+                        line_req = install_req_from_line(
+                            COMMENT_RE.sub("", line).strip(),
+                            isolated=isolated,
+                        )
+
+                    if not line_req.name:
+                        logger.info(
+                            "Skipping line in requirement file [%s] because "
+                            "it's not clear what it would install: %s",
+                            req_file_path,
+                            line.strip(),
+                        )
+                        logger.info(
+                            "  (add #egg=PackageName to the URL to avoid"
+                            " this warning)"
+                        )
+                    else:
+                        line_req_canonical_name = canonicalize_name(line_req.name)
+                        if line_req_canonical_name not in installations:
+                            # either it's not installed, or it is installed
+                            # but has been processed already
+                            if not req_files[line_req.name]:
+                                logger.warning(
+                                    "Requirement file [%s] contains %s, but "
+                                    "package %r is not installed",
+                                    req_file_path,
+                                    COMMENT_RE.sub("", line).strip(),
+                                    line_req.name,
+                                )
+                            else:
+                                req_files[line_req.name].append(req_file_path)
+                        else:
+                            yield str(installations[line_req_canonical_name]).rstrip()
+                            del installations[line_req_canonical_name]
+                            req_files[line_req.name].append(req_file_path)
+
+        # Warn about requirements that were included multiple times (in a
+        # single requirements file or in different requirements files).
+        for name, files in req_files.items():
+            if len(files) > 1:
+                logger.warning(
+                    "Requirement %s included multiple times [%s]",
+                    name,
+                    ", ".join(sorted(set(files))),
+                )
+
+        yield ("## The following requirements were added by pip freeze:")
+    for installation in sorted(installations.values(), key=lambda x: x.name.lower()):
+        if installation.canonical_name not in skip:
+            yield str(installation).rstrip()
+
+
+def _format_as_name_version(dist: BaseDistribution) -> str:
+    try:
+        dist_version = dist.version
+    except InvalidVersion:
+        # legacy version
+        return f"{dist.raw_name}==={dist.raw_version}"
+    else:
+        return f"{dist.raw_name}=={dist_version}"
+
+
+def _get_editable_info(dist: BaseDistribution) -> _EditableInfo:
+    """
+    Compute and return values (req, comments) for use in
+    FrozenRequirement.from_dist().
+    """
+    editable_project_location = dist.editable_project_location
+    assert editable_project_location
+    location = os.path.normcase(os.path.abspath(editable_project_location))
+
+    from pip._internal.vcs import RemoteNotFoundError, RemoteNotValidError, vcs
+
+    vcs_backend = vcs.get_backend_for_dir(location)
+
+    if vcs_backend is None:
+        display = _format_as_name_version(dist)
+        logger.debug(
+            'No VCS found for editable requirement "%s" in: %r',
+            display,
+            location,
+        )
+        return _EditableInfo(
+            requirement=location,
+            comments=[f"# Editable install with no version control ({display})"],
+        )
+
+    vcs_name = type(vcs_backend).__name__
+
+    try:
+        req = vcs_backend.get_src_requirement(location, dist.raw_name)
+    except RemoteNotFoundError:
+        display = _format_as_name_version(dist)
+        return _EditableInfo(
+            requirement=location,
+            comments=[f"# Editable {vcs_name} install with no remote ({display})"],
+        )
+    except RemoteNotValidError as ex:
+        display = _format_as_name_version(dist)
+        return _EditableInfo(
+            requirement=location,
+            comments=[
+                f"# Editable {vcs_name} install ({display}) with either a deleted "
+                f"local remote or invalid URI:",
+                f"# '{ex.url}'",
+            ],
+        )
+    except BadCommand:
+        logger.warning(
+            "cannot determine version of editable source in %s "
+            "(%s command not found in path)",
+            location,
+            vcs_backend.name,
+        )
+        return _EditableInfo(requirement=location, comments=[])
+    except InstallationError as exc:
+        logger.warning("Error when trying to get requirement for VCS system %s", exc)
+    else:
+        return _EditableInfo(requirement=req, comments=[])
+
+    logger.warning("Could not determine repository location of %s", location)
+
+    return _EditableInfo(
+        requirement=location,
+        comments=["## !! Could not determine repository location"],
+    )
+
+
+class FrozenRequirement:
+    def __init__(
+        self,
+        name: str,
+        req: str,
+        editable: bool,
+        comments: Iterable[str] = (),
+    ) -> None:
+        self.name = name
+        self.canonical_name = canonicalize_name(name)
+        self.req = req
+        self.editable = editable
+        self.comments = comments
+
+    @classmethod
+    def from_dist(cls, dist: BaseDistribution) -> "FrozenRequirement":
+        editable = dist.editable
+        if editable:
+            req, comments = _get_editable_info(dist)
+        else:
+            comments = []
+            direct_url = dist.direct_url
+            if direct_url:
+                # if PEP 610 metadata is present, use it
+                req = direct_url_as_pep440_direct_reference(direct_url, dist.raw_name)
+            else:
+                # name==version requirement
+                req = _format_as_name_version(dist)
+
+        return cls(dist.raw_name, req, editable, comments=comments)
+
+    def __str__(self) -> str:
+        req = self.req
+        if self.editable:
+            req = f"-e {req}"
+        return "\n".join(list(self.comments) + [str(req)]) + "\n"
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/operations/install/__init__.py b/venv/lib/python3.12/site-packages/pip/_internal/operations/install/__init__.py
new file mode 100644
index 00000000..24d6a5dd
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/operations/install/__init__.py
@@ -0,0 +1,2 @@
+"""For modules related to installing packages.
+"""
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/operations/install/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/operations/install/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 00000000..19a17ec5
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/operations/install/__pycache__/__init__.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/operations/install/__pycache__/editable_legacy.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/operations/install/__pycache__/editable_legacy.cpython-312.pyc
new file mode 100644
index 00000000..9827a8d1
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/operations/install/__pycache__/editable_legacy.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/operations/install/__pycache__/wheel.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/operations/install/__pycache__/wheel.cpython-312.pyc
new file mode 100644
index 00000000..47254800
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/operations/install/__pycache__/wheel.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/operations/install/editable_legacy.py b/venv/lib/python3.12/site-packages/pip/_internal/operations/install/editable_legacy.py
new file mode 100644
index 00000000..9aaa699a
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/operations/install/editable_legacy.py
@@ -0,0 +1,47 @@
+"""Legacy editable installation process, i.e. `setup.py develop`.
+"""
+
+import logging
+from typing import Optional, Sequence
+
+from pip._internal.build_env import BuildEnvironment
+from pip._internal.utils.logging import indent_log
+from pip._internal.utils.setuptools_build import make_setuptools_develop_args
+from pip._internal.utils.subprocess import call_subprocess
+
+logger = logging.getLogger(__name__)
+
+
+def install_editable(
+    *,
+    global_options: Sequence[str],
+    prefix: Optional[str],
+    home: Optional[str],
+    use_user_site: bool,
+    name: str,
+    setup_py_path: str,
+    isolated: bool,
+    build_env: BuildEnvironment,
+    unpacked_source_directory: str,
+) -> None:
+    """Install a package in editable mode. Most arguments are pass-through
+    to setuptools.
+    """
+    logger.info("Running setup.py develop for %s", name)
+
+    args = make_setuptools_develop_args(
+        setup_py_path,
+        global_options=global_options,
+        no_user_config=isolated,
+        prefix=prefix,
+        home=home,
+        use_user_site=use_user_site,
+    )
+
+    with indent_log():
+        with build_env:
+            call_subprocess(
+                args,
+                command_desc="python setup.py develop",
+                cwd=unpacked_source_directory,
+            )
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/operations/install/wheel.py b/venv/lib/python3.12/site-packages/pip/_internal/operations/install/wheel.py
new file mode 100644
index 00000000..aef42aa9
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/operations/install/wheel.py
@@ -0,0 +1,741 @@
+"""Support for installing and building the "wheel" binary package format.
+"""
+
+import collections
+import compileall
+import contextlib
+import csv
+import importlib
+import logging
+import os.path
+import re
+import shutil
+import sys
+import warnings
+from base64 import urlsafe_b64encode
+from email.message import Message
+from itertools import chain, filterfalse, starmap
+from typing import (
+    IO,
+    TYPE_CHECKING,
+    Any,
+    BinaryIO,
+    Callable,
+    Dict,
+    Generator,
+    Iterable,
+    Iterator,
+    List,
+    NewType,
+    Optional,
+    Protocol,
+    Sequence,
+    Set,
+    Tuple,
+    Union,
+    cast,
+)
+from zipfile import ZipFile, ZipInfo
+
+from pip._vendor.distlib.scripts import ScriptMaker
+from pip._vendor.distlib.util import get_export_entry
+from pip._vendor.packaging.utils import canonicalize_name
+
+from pip._internal.exceptions import InstallationError
+from pip._internal.locations import get_major_minor_version
+from pip._internal.metadata import (
+    BaseDistribution,
+    FilesystemWheel,
+    get_wheel_distribution,
+)
+from pip._internal.models.direct_url import DIRECT_URL_METADATA_NAME, DirectUrl
+from pip._internal.models.scheme import SCHEME_KEYS, Scheme
+from pip._internal.utils.filesystem import adjacent_tmp_file, replace
+from pip._internal.utils.misc import StreamWrapper, ensure_dir, hash_file, partition
+from pip._internal.utils.unpacking import (
+    current_umask,
+    is_within_directory,
+    set_extracted_file_to_default_mode_plus_executable,
+    zip_item_is_executable,
+)
+from pip._internal.utils.wheel import parse_wheel
+
+if TYPE_CHECKING:
+
+    class File(Protocol):
+        src_record_path: "RecordPath"
+        dest_path: str
+        changed: bool
+
+        def save(self) -> None:
+            pass
+
+
+logger = logging.getLogger(__name__)
+
+RecordPath = NewType("RecordPath", str)
+InstalledCSVRow = Tuple[RecordPath, str, Union[int, str]]
+
+
+def rehash(path: str, blocksize: int = 1 << 20) -> Tuple[str, str]:
+    """Return (encoded_digest, length) for path using hashlib.sha256()"""
+    h, length = hash_file(path, blocksize)
+    digest = "sha256=" + urlsafe_b64encode(h.digest()).decode("latin1").rstrip("=")
+    return (digest, str(length))
+
+
+def csv_io_kwargs(mode: str) -> Dict[str, Any]:
+    """Return keyword arguments to properly open a CSV file
+    in the given mode.
+    """
+    return {"mode": mode, "newline": "", "encoding": "utf-8"}
+
+
+def fix_script(path: str) -> bool:
+    """Replace #!python with #!/path/to/python
+    Return True if file was changed.
+    """
+    # XXX RECORD hashes will need to be updated
+    assert os.path.isfile(path)
+
+    with open(path, "rb") as script:
+        firstline = script.readline()
+        if not firstline.startswith(b"#!python"):
+            return False
+        exename = sys.executable.encode(sys.getfilesystemencoding())
+        firstline = b"#!" + exename + os.linesep.encode("ascii")
+        rest = script.read()
+    with open(path, "wb") as script:
+        script.write(firstline)
+        script.write(rest)
+    return True
+
+
+def wheel_root_is_purelib(metadata: Message) -> bool:
+    return metadata.get("Root-Is-Purelib", "").lower() == "true"
+
+
+def get_entrypoints(dist: BaseDistribution) -> Tuple[Dict[str, str], Dict[str, str]]:
+    console_scripts = {}
+    gui_scripts = {}
+    for entry_point in dist.iter_entry_points():
+        if entry_point.group == "console_scripts":
+            console_scripts[entry_point.name] = entry_point.value
+        elif entry_point.group == "gui_scripts":
+            gui_scripts[entry_point.name] = entry_point.value
+    return console_scripts, gui_scripts
+
+
+def message_about_scripts_not_on_PATH(scripts: Sequence[str]) -> Optional[str]:
+    """Determine if any scripts are not on PATH and format a warning.
+    Returns a warning message if one or more scripts are not on PATH,
+    otherwise None.
+    """
+    if not scripts:
+        return None
+
+    # Group scripts by the path they were installed in
+    grouped_by_dir: Dict[str, Set[str]] = collections.defaultdict(set)
+    for destfile in scripts:
+        parent_dir = os.path.dirname(destfile)
+        script_name = os.path.basename(destfile)
+        grouped_by_dir[parent_dir].add(script_name)
+
+    # We don't want to warn for directories that are on PATH.
+    not_warn_dirs = [
+        os.path.normcase(os.path.normpath(i)).rstrip(os.sep)
+        for i in os.environ.get("PATH", "").split(os.pathsep)
+    ]
+    # If an executable sits with sys.executable, we don't warn for it.
+    #     This covers the case of venv invocations without activating the venv.
+    not_warn_dirs.append(
+        os.path.normcase(os.path.normpath(os.path.dirname(sys.executable)))
+    )
+    warn_for: Dict[str, Set[str]] = {
+        parent_dir: scripts
+        for parent_dir, scripts in grouped_by_dir.items()
+        if os.path.normcase(os.path.normpath(parent_dir)) not in not_warn_dirs
+    }
+    if not warn_for:
+        return None
+
+    # Format a message
+    msg_lines = []
+    for parent_dir, dir_scripts in warn_for.items():
+        sorted_scripts: List[str] = sorted(dir_scripts)
+        if len(sorted_scripts) == 1:
+            start_text = f"script {sorted_scripts[0]} is"
+        else:
+            start_text = "scripts {} are".format(
+                ", ".join(sorted_scripts[:-1]) + " and " + sorted_scripts[-1]
+            )
+
+        msg_lines.append(
+            f"The {start_text} installed in '{parent_dir}' which is not on PATH."
+        )
+
+    last_line_fmt = (
+        "Consider adding {} to PATH or, if you prefer "
+        "to suppress this warning, use --no-warn-script-location."
+    )
+    if len(msg_lines) == 1:
+        msg_lines.append(last_line_fmt.format("this directory"))
+    else:
+        msg_lines.append(last_line_fmt.format("these directories"))
+
+    # Add a note if any directory starts with ~
+    warn_for_tilde = any(
+        i[0] == "~" for i in os.environ.get("PATH", "").split(os.pathsep) if i
+    )
+    if warn_for_tilde:
+        tilde_warning_msg = (
+            "NOTE: The current PATH contains path(s) starting with `~`, "
+            "which may not be expanded by all applications."
+        )
+        msg_lines.append(tilde_warning_msg)
+
+    # Returns the formatted multiline message
+    return "\n".join(msg_lines)
+
+
+def _normalized_outrows(
+    outrows: Iterable[InstalledCSVRow],
+) -> List[Tuple[str, str, str]]:
+    """Normalize the given rows of a RECORD file.
+
+    Items in each row are converted into str. Rows are then sorted to make
+    the value more predictable for tests.
+
+    Each row is a 3-tuple (path, hash, size) and corresponds to a record of
+    a RECORD file (see PEP 376 and PEP 427 for details).  For the rows
+    passed to this function, the size can be an integer as an int or string,
+    or the empty string.
+    """
+    # Normally, there should only be one row per path, in which case the
+    # second and third elements don't come into play when sorting.
+    # However, in cases in the wild where a path might happen to occur twice,
+    # we don't want the sort operation to trigger an error (but still want
+    # determinism).  Since the third element can be an int or string, we
+    # coerce each element to a string to avoid a TypeError in this case.
+    # For additional background, see--
+    # https://github.com/pypa/pip/issues/5868
+    return sorted(
+        (record_path, hash_, str(size)) for record_path, hash_, size in outrows
+    )
+
+
+def _record_to_fs_path(record_path: RecordPath, lib_dir: str) -> str:
+    return os.path.join(lib_dir, record_path)
+
+
+def _fs_to_record_path(path: str, lib_dir: str) -> RecordPath:
+    # On Windows, do not handle relative paths if they belong to different
+    # logical disks
+    if os.path.splitdrive(path)[0].lower() == os.path.splitdrive(lib_dir)[0].lower():
+        path = os.path.relpath(path, lib_dir)
+
+    path = path.replace(os.path.sep, "/")
+    return cast("RecordPath", path)
+
+
+def get_csv_rows_for_installed(
+    old_csv_rows: List[List[str]],
+    installed: Dict[RecordPath, RecordPath],
+    changed: Set[RecordPath],
+    generated: List[str],
+    lib_dir: str,
+) -> List[InstalledCSVRow]:
+    """
+    :param installed: A map from archive RECORD path to installation RECORD
+        path.
+    """
+    installed_rows: List[InstalledCSVRow] = []
+    for row in old_csv_rows:
+        if len(row) > 3:
+            logger.warning("RECORD line has more than three elements: %s", row)
+        old_record_path = cast("RecordPath", row[0])
+        new_record_path = installed.pop(old_record_path, old_record_path)
+        if new_record_path in changed:
+            digest, length = rehash(_record_to_fs_path(new_record_path, lib_dir))
+        else:
+            digest = row[1] if len(row) > 1 else ""
+            length = row[2] if len(row) > 2 else ""
+        installed_rows.append((new_record_path, digest, length))
+    for f in generated:
+        path = _fs_to_record_path(f, lib_dir)
+        digest, length = rehash(f)
+        installed_rows.append((path, digest, length))
+    return installed_rows + [
+        (installed_record_path, "", "") for installed_record_path in installed.values()
+    ]
+
+
+def get_console_script_specs(console: Dict[str, str]) -> List[str]:
+    """
+    Given the mapping from entrypoint name to callable, return the relevant
+    console script specs.
+    """
+    # Don't mutate caller's version
+    console = console.copy()
+
+    scripts_to_generate = []
+
+    # Special case pip and setuptools to generate versioned wrappers
+    #
+    # The issue is that some projects (specifically, pip and setuptools) use
+    # code in setup.py to create "versioned" entry points - pip2.7 on Python
+    # 2.7, pip3.3 on Python 3.3, etc. But these entry points are baked into
+    # the wheel metadata at build time, and so if the wheel is installed with
+    # a *different* version of Python the entry points will be wrong. The
+    # correct fix for this is to enhance the metadata to be able to describe
+    # such versioned entry points.
+    # Currently, projects using versioned entry points will either have
+    # incorrect versioned entry points, or they will not be able to distribute
+    # "universal" wheels (i.e., they will need a wheel per Python version).
+    #
+    # Because setuptools and pip are bundled with _ensurepip and virtualenv,
+    # we need to use universal wheels. As a workaround, we
+    # override the versioned entry points in the wheel and generate the
+    # correct ones.
+    #
+    # To add the level of hack in this section of code, in order to support
+    # ensurepip this code will look for an ``ENSUREPIP_OPTIONS`` environment
+    # variable which will control which version scripts get installed.
+    #
+    # ENSUREPIP_OPTIONS=altinstall
+    #   - Only pipX.Y and easy_install-X.Y will be generated and installed
+    # ENSUREPIP_OPTIONS=install
+    #   - pipX.Y, pipX, easy_install-X.Y will be generated and installed. Note
+    #     that this option is technically if ENSUREPIP_OPTIONS is set and is
+    #     not altinstall
+    # DEFAULT
+    #   - The default behavior is to install pip, pipX, pipX.Y, easy_install
+    #     and easy_install-X.Y.
+    pip_script = console.pop("pip", None)
+    if pip_script:
+        if "ENSUREPIP_OPTIONS" not in os.environ:
+            scripts_to_generate.append("pip = " + pip_script)
+
+        if os.environ.get("ENSUREPIP_OPTIONS", "") != "altinstall":
+            scripts_to_generate.append(f"pip{sys.version_info[0]} = {pip_script}")
+
+        scripts_to_generate.append(f"pip{get_major_minor_version()} = {pip_script}")
+        # Delete any other versioned pip entry points
+        pip_ep = [k for k in console if re.match(r"pip(\d+(\.\d+)?)?$", k)]
+        for k in pip_ep:
+            del console[k]
+    easy_install_script = console.pop("easy_install", None)
+    if easy_install_script:
+        if "ENSUREPIP_OPTIONS" not in os.environ:
+            scripts_to_generate.append("easy_install = " + easy_install_script)
+
+        scripts_to_generate.append(
+            f"easy_install-{get_major_minor_version()} = {easy_install_script}"
+        )
+        # Delete any other versioned easy_install entry points
+        easy_install_ep = [
+            k for k in console if re.match(r"easy_install(-\d+\.\d+)?$", k)
+        ]
+        for k in easy_install_ep:
+            del console[k]
+
+    # Generate the console entry points specified in the wheel
+    scripts_to_generate.extend(starmap("{} = {}".format, console.items()))
+
+    return scripts_to_generate
+
+
+class ZipBackedFile:
+    def __init__(
+        self, src_record_path: RecordPath, dest_path: str, zip_file: ZipFile
+    ) -> None:
+        self.src_record_path = src_record_path
+        self.dest_path = dest_path
+        self._zip_file = zip_file
+        self.changed = False
+
+    def _getinfo(self) -> ZipInfo:
+        return self._zip_file.getinfo(self.src_record_path)
+
+    def save(self) -> None:
+        # When we open the output file below, any existing file is truncated
+        # before we start writing the new contents. This is fine in most
+        # cases, but can cause a segfault if pip has loaded a shared
+        # object (e.g. from pyopenssl through its vendored urllib3)
+        # Since the shared object is mmap'd an attempt to call a
+        # symbol in it will then cause a segfault. Unlinking the file
+        # allows writing of new contents while allowing the process to
+        # continue to use the old copy.
+        if os.path.exists(self.dest_path):
+            os.unlink(self.dest_path)
+
+        zipinfo = self._getinfo()
+
+        # optimization: the file is created by open(),
+        # skip the decompression when there is 0 bytes to decompress.
+        with open(self.dest_path, "wb") as dest:
+            if zipinfo.file_size > 0:
+                with self._zip_file.open(zipinfo) as f:
+                    blocksize = min(zipinfo.file_size, 1024 * 1024)
+                    shutil.copyfileobj(f, dest, blocksize)
+
+        if zip_item_is_executable(zipinfo):
+            set_extracted_file_to_default_mode_plus_executable(self.dest_path)
+
+
+class ScriptFile:
+    def __init__(self, file: "File") -> None:
+        self._file = file
+        self.src_record_path = self._file.src_record_path
+        self.dest_path = self._file.dest_path
+        self.changed = False
+
+    def save(self) -> None:
+        self._file.save()
+        self.changed = fix_script(self.dest_path)
+
+
+class MissingCallableSuffix(InstallationError):
+    def __init__(self, entry_point: str) -> None:
+        super().__init__(
+            f"Invalid script entry point: {entry_point} - A callable "
+            "suffix is required. Cf https://packaging.python.org/"
+            "specifications/entry-points/#use-for-scripts for more "
+            "information."
+        )
+
+
+def _raise_for_invalid_entrypoint(specification: str) -> None:
+    entry = get_export_entry(specification)
+    if entry is not None and entry.suffix is None:
+        raise MissingCallableSuffix(str(entry))
+
+
+class PipScriptMaker(ScriptMaker):
+    def make(
+        self, specification: str, options: Optional[Dict[str, Any]] = None
+    ) -> List[str]:
+        _raise_for_invalid_entrypoint(specification)
+        return super().make(specification, options)
+
+
+def _install_wheel(  # noqa: C901, PLR0915 function is too long
+    name: str,
+    wheel_zip: ZipFile,
+    wheel_path: str,
+    scheme: Scheme,
+    pycompile: bool = True,
+    warn_script_location: bool = True,
+    direct_url: Optional[DirectUrl] = None,
+    requested: bool = False,
+) -> None:
+    """Install a wheel.
+
+    :param name: Name of the project to install
+    :param wheel_zip: open ZipFile for wheel being installed
+    :param scheme: Distutils scheme dictating the install directories
+    :param req_description: String used in place of the requirement, for
+        logging
+    :param pycompile: Whether to byte-compile installed Python files
+    :param warn_script_location: Whether to check that scripts are installed
+        into a directory on PATH
+    :raises UnsupportedWheel:
+        * when the directory holds an unpacked wheel with incompatible
+          Wheel-Version
+        * when the .dist-info dir does not match the wheel
+    """
+    info_dir, metadata = parse_wheel(wheel_zip, name)
+
+    if wheel_root_is_purelib(metadata):
+        lib_dir = scheme.purelib
+    else:
+        lib_dir = scheme.platlib
+
+    # Record details of the files moved
+    #   installed = files copied from the wheel to the destination
+    #   changed = files changed while installing (scripts #! line typically)
+    #   generated = files newly generated during the install (script wrappers)
+    installed: Dict[RecordPath, RecordPath] = {}
+    changed: Set[RecordPath] = set()
+    generated: List[str] = []
+
+    def record_installed(
+        srcfile: RecordPath, destfile: str, modified: bool = False
+    ) -> None:
+        """Map archive RECORD paths to installation RECORD paths."""
+        newpath = _fs_to_record_path(destfile, lib_dir)
+        installed[srcfile] = newpath
+        if modified:
+            changed.add(newpath)
+
+    def is_dir_path(path: RecordPath) -> bool:
+        return path.endswith("/")
+
+    def assert_no_path_traversal(dest_dir_path: str, target_path: str) -> None:
+        if not is_within_directory(dest_dir_path, target_path):
+            message = (
+                "The wheel {!r} has a file {!r} trying to install"
+                " outside the target directory {!r}"
+            )
+            raise InstallationError(
+                message.format(wheel_path, target_path, dest_dir_path)
+            )
+
+    def root_scheme_file_maker(
+        zip_file: ZipFile, dest: str
+    ) -> Callable[[RecordPath], "File"]:
+        def make_root_scheme_file(record_path: RecordPath) -> "File":
+            normed_path = os.path.normpath(record_path)
+            dest_path = os.path.join(dest, normed_path)
+            assert_no_path_traversal(dest, dest_path)
+            return ZipBackedFile(record_path, dest_path, zip_file)
+
+        return make_root_scheme_file
+
+    def data_scheme_file_maker(
+        zip_file: ZipFile, scheme: Scheme
+    ) -> Callable[[RecordPath], "File"]:
+        scheme_paths = {key: getattr(scheme, key) for key in SCHEME_KEYS}
+
+        def make_data_scheme_file(record_path: RecordPath) -> "File":
+            normed_path = os.path.normpath(record_path)
+            try:
+                _, scheme_key, dest_subpath = normed_path.split(os.path.sep, 2)
+            except ValueError:
+                message = (
+                    f"Unexpected file in {wheel_path}: {record_path!r}. .data directory"
+                    " contents should be named like: '/'."
+                )
+                raise InstallationError(message)
+
+            try:
+                scheme_path = scheme_paths[scheme_key]
+            except KeyError:
+                valid_scheme_keys = ", ".join(sorted(scheme_paths))
+                message = (
+                    f"Unknown scheme key used in {wheel_path}: {scheme_key} "
+                    f"(for file {record_path!r}). .data directory contents "
+                    f"should be in subdirectories named with a valid scheme "
+                    f"key ({valid_scheme_keys})"
+                )
+                raise InstallationError(message)
+
+            dest_path = os.path.join(scheme_path, dest_subpath)
+            assert_no_path_traversal(scheme_path, dest_path)
+            return ZipBackedFile(record_path, dest_path, zip_file)
+
+        return make_data_scheme_file
+
+    def is_data_scheme_path(path: RecordPath) -> bool:
+        return path.split("/", 1)[0].endswith(".data")
+
+    paths = cast(List[RecordPath], wheel_zip.namelist())
+    file_paths = filterfalse(is_dir_path, paths)
+    root_scheme_paths, data_scheme_paths = partition(is_data_scheme_path, file_paths)
+
+    make_root_scheme_file = root_scheme_file_maker(wheel_zip, lib_dir)
+    files: Iterator[File] = map(make_root_scheme_file, root_scheme_paths)
+
+    def is_script_scheme_path(path: RecordPath) -> bool:
+        parts = path.split("/", 2)
+        return len(parts) > 2 and parts[0].endswith(".data") and parts[1] == "scripts"
+
+    other_scheme_paths, script_scheme_paths = partition(
+        is_script_scheme_path, data_scheme_paths
+    )
+
+    make_data_scheme_file = data_scheme_file_maker(wheel_zip, scheme)
+    other_scheme_files = map(make_data_scheme_file, other_scheme_paths)
+    files = chain(files, other_scheme_files)
+
+    # Get the defined entry points
+    distribution = get_wheel_distribution(
+        FilesystemWheel(wheel_path),
+        canonicalize_name(name),
+    )
+    console, gui = get_entrypoints(distribution)
+
+    def is_entrypoint_wrapper(file: "File") -> bool:
+        # EP, EP.exe and EP-script.py are scripts generated for
+        # entry point EP by setuptools
+        path = file.dest_path
+        name = os.path.basename(path)
+        if name.lower().endswith(".exe"):
+            matchname = name[:-4]
+        elif name.lower().endswith("-script.py"):
+            matchname = name[:-10]
+        elif name.lower().endswith(".pya"):
+            matchname = name[:-4]
+        else:
+            matchname = name
+        # Ignore setuptools-generated scripts
+        return matchname in console or matchname in gui
+
+    script_scheme_files: Iterator[File] = map(
+        make_data_scheme_file, script_scheme_paths
+    )
+    script_scheme_files = filterfalse(is_entrypoint_wrapper, script_scheme_files)
+    script_scheme_files = map(ScriptFile, script_scheme_files)
+    files = chain(files, script_scheme_files)
+
+    existing_parents = set()
+    for file in files:
+        # directory creation is lazy and after file filtering
+        # to ensure we don't install empty dirs; empty dirs can't be
+        # uninstalled.
+        parent_dir = os.path.dirname(file.dest_path)
+        if parent_dir not in existing_parents:
+            ensure_dir(parent_dir)
+            existing_parents.add(parent_dir)
+        file.save()
+        record_installed(file.src_record_path, file.dest_path, file.changed)
+
+    def pyc_source_file_paths() -> Generator[str, None, None]:
+        # We de-duplicate installation paths, since there can be overlap (e.g.
+        # file in .data maps to same location as file in wheel root).
+        # Sorting installation paths makes it easier to reproduce and debug
+        # issues related to permissions on existing files.
+        for installed_path in sorted(set(installed.values())):
+            full_installed_path = os.path.join(lib_dir, installed_path)
+            if not os.path.isfile(full_installed_path):
+                continue
+            if not full_installed_path.endswith(".py"):
+                continue
+            yield full_installed_path
+
+    def pyc_output_path(path: str) -> str:
+        """Return the path the pyc file would have been written to."""
+        return importlib.util.cache_from_source(path)
+
+    # Compile all of the pyc files for the installed files
+    if pycompile:
+        with contextlib.redirect_stdout(
+            StreamWrapper.from_stream(sys.stdout)
+        ) as stdout:
+            with warnings.catch_warnings():
+                warnings.filterwarnings("ignore")
+                for path in pyc_source_file_paths():
+                    success = compileall.compile_file(path, force=True, quiet=True)
+                    if success:
+                        pyc_path = pyc_output_path(path)
+                        assert os.path.exists(pyc_path)
+                        pyc_record_path = cast(
+                            "RecordPath", pyc_path.replace(os.path.sep, "/")
+                        )
+                        record_installed(pyc_record_path, pyc_path)
+        logger.debug(stdout.getvalue())
+
+    maker = PipScriptMaker(None, scheme.scripts)
+
+    # Ensure old scripts are overwritten.
+    # See https://github.com/pypa/pip/issues/1800
+    maker.clobber = True
+
+    # Ensure we don't generate any variants for scripts because this is almost
+    # never what somebody wants.
+    # See https://bitbucket.org/pypa/distlib/issue/35/
+    maker.variants = {""}
+
+    # This is required because otherwise distlib creates scripts that are not
+    # executable.
+    # See https://bitbucket.org/pypa/distlib/issue/32/
+    maker.set_mode = True
+
+    # Generate the console and GUI entry points specified in the wheel
+    scripts_to_generate = get_console_script_specs(console)
+
+    gui_scripts_to_generate = list(starmap("{} = {}".format, gui.items()))
+
+    generated_console_scripts = maker.make_multiple(scripts_to_generate)
+    generated.extend(generated_console_scripts)
+
+    generated.extend(maker.make_multiple(gui_scripts_to_generate, {"gui": True}))
+
+    if warn_script_location:
+        msg = message_about_scripts_not_on_PATH(generated_console_scripts)
+        if msg is not None:
+            logger.warning(msg)
+
+    generated_file_mode = 0o666 & ~current_umask()
+
+    @contextlib.contextmanager
+    def _generate_file(path: str, **kwargs: Any) -> Generator[BinaryIO, None, None]:
+        with adjacent_tmp_file(path, **kwargs) as f:
+            yield f
+        os.chmod(f.name, generated_file_mode)
+        replace(f.name, path)
+
+    dest_info_dir = os.path.join(lib_dir, info_dir)
+
+    # Record pip as the installer
+    installer_path = os.path.join(dest_info_dir, "INSTALLER")
+    with _generate_file(installer_path) as installer_file:
+        installer_file.write(b"pip\n")
+    generated.append(installer_path)
+
+    # Record the PEP 610 direct URL reference
+    if direct_url is not None:
+        direct_url_path = os.path.join(dest_info_dir, DIRECT_URL_METADATA_NAME)
+        with _generate_file(direct_url_path) as direct_url_file:
+            direct_url_file.write(direct_url.to_json().encode("utf-8"))
+        generated.append(direct_url_path)
+
+    # Record the REQUESTED file
+    if requested:
+        requested_path = os.path.join(dest_info_dir, "REQUESTED")
+        with open(requested_path, "wb"):
+            pass
+        generated.append(requested_path)
+
+    record_text = distribution.read_text("RECORD")
+    record_rows = list(csv.reader(record_text.splitlines()))
+
+    rows = get_csv_rows_for_installed(
+        record_rows,
+        installed=installed,
+        changed=changed,
+        generated=generated,
+        lib_dir=lib_dir,
+    )
+
+    # Record details of all files installed
+    record_path = os.path.join(dest_info_dir, "RECORD")
+
+    with _generate_file(record_path, **csv_io_kwargs("w")) as record_file:
+        # Explicitly cast to typing.IO[str] as a workaround for the mypy error:
+        # "writer" has incompatible type "BinaryIO"; expected "_Writer"
+        writer = csv.writer(cast("IO[str]", record_file))
+        writer.writerows(_normalized_outrows(rows))
+
+
+@contextlib.contextmanager
+def req_error_context(req_description: str) -> Generator[None, None, None]:
+    try:
+        yield
+    except InstallationError as e:
+        message = f"For req: {req_description}. {e.args[0]}"
+        raise InstallationError(message) from e
+
+
+def install_wheel(
+    name: str,
+    wheel_path: str,
+    scheme: Scheme,
+    req_description: str,
+    pycompile: bool = True,
+    warn_script_location: bool = True,
+    direct_url: Optional[DirectUrl] = None,
+    requested: bool = False,
+) -> None:
+    with ZipFile(wheel_path, allowZip64=True) as z:
+        with req_error_context(req_description):
+            _install_wheel(
+                name=name,
+                wheel_zip=z,
+                wheel_path=wheel_path,
+                scheme=scheme,
+                pycompile=pycompile,
+                warn_script_location=warn_script_location,
+                direct_url=direct_url,
+                requested=requested,
+            )
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/operations/prepare.py b/venv/lib/python3.12/site-packages/pip/_internal/operations/prepare.py
new file mode 100644
index 00000000..e6aa3447
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/operations/prepare.py
@@ -0,0 +1,732 @@
+"""Prepares a distribution for installation
+"""
+
+# The following comment should be removed at some point in the future.
+# mypy: strict-optional=False
+
+import mimetypes
+import os
+import shutil
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Dict, Iterable, List, Optional
+
+from pip._vendor.packaging.utils import canonicalize_name
+
+from pip._internal.distributions import make_distribution_for_install_requirement
+from pip._internal.distributions.installed import InstalledDistribution
+from pip._internal.exceptions import (
+    DirectoryUrlHashUnsupported,
+    HashMismatch,
+    HashUnpinned,
+    InstallationError,
+    MetadataInconsistent,
+    NetworkConnectionError,
+    VcsHashUnsupported,
+)
+from pip._internal.index.package_finder import PackageFinder
+from pip._internal.metadata import BaseDistribution, get_metadata_distribution
+from pip._internal.models.direct_url import ArchiveInfo
+from pip._internal.models.link import Link
+from pip._internal.models.wheel import Wheel
+from pip._internal.network.download import BatchDownloader, Downloader
+from pip._internal.network.lazy_wheel import (
+    HTTPRangeRequestUnsupported,
+    dist_from_wheel_url,
+)
+from pip._internal.network.session import PipSession
+from pip._internal.operations.build.build_tracker import BuildTracker
+from pip._internal.req.req_install import InstallRequirement
+from pip._internal.utils._log import getLogger
+from pip._internal.utils.direct_url_helpers import (
+    direct_url_for_editable,
+    direct_url_from_link,
+)
+from pip._internal.utils.hashes import Hashes, MissingHashes
+from pip._internal.utils.logging import indent_log
+from pip._internal.utils.misc import (
+    display_path,
+    hash_file,
+    hide_url,
+    redact_auth_from_requirement,
+)
+from pip._internal.utils.temp_dir import TempDirectory
+from pip._internal.utils.unpacking import unpack_file
+from pip._internal.vcs import vcs
+
+logger = getLogger(__name__)
+
+
+def _get_prepared_distribution(
+    req: InstallRequirement,
+    build_tracker: BuildTracker,
+    finder: PackageFinder,
+    build_isolation: bool,
+    check_build_deps: bool,
+) -> BaseDistribution:
+    """Prepare a distribution for installation."""
+    abstract_dist = make_distribution_for_install_requirement(req)
+    tracker_id = abstract_dist.build_tracker_id
+    if tracker_id is not None:
+        with build_tracker.track(req, tracker_id):
+            abstract_dist.prepare_distribution_metadata(
+                finder, build_isolation, check_build_deps
+            )
+    return abstract_dist.get_metadata_distribution()
+
+
+def unpack_vcs_link(link: Link, location: str, verbosity: int) -> None:
+    vcs_backend = vcs.get_backend_for_scheme(link.scheme)
+    assert vcs_backend is not None
+    vcs_backend.unpack(location, url=hide_url(link.url), verbosity=verbosity)
+
+
+@dataclass
+class File:
+    path: str
+    content_type: Optional[str] = None
+
+    def __post_init__(self) -> None:
+        if self.content_type is None:
+            self.content_type = mimetypes.guess_type(self.path)[0]
+
+
+def get_http_url(
+    link: Link,
+    download: Downloader,
+    download_dir: Optional[str] = None,
+    hashes: Optional[Hashes] = None,
+) -> File:
+    temp_dir = TempDirectory(kind="unpack", globally_managed=True)
+    # If a download dir is specified, is the file already downloaded there?
+    already_downloaded_path = None
+    if download_dir:
+        already_downloaded_path = _check_download_dir(link, download_dir, hashes)
+
+    if already_downloaded_path:
+        from_path = already_downloaded_path
+        content_type = None
+    else:
+        # let's download to a tmp dir
+        from_path, content_type = download(link, temp_dir.path)
+        if hashes:
+            hashes.check_against_path(from_path)
+
+    return File(from_path, content_type)
+
+
+def get_file_url(
+    link: Link, download_dir: Optional[str] = None, hashes: Optional[Hashes] = None
+) -> File:
+    """Get file and optionally check its hash."""
+    # If a download dir is specified, is the file already there and valid?
+    already_downloaded_path = None
+    if download_dir:
+        already_downloaded_path = _check_download_dir(link, download_dir, hashes)
+
+    if already_downloaded_path:
+        from_path = already_downloaded_path
+    else:
+        from_path = link.file_path
+
+    # If --require-hashes is off, `hashes` is either empty, the
+    # link's embedded hash, or MissingHashes; it is required to
+    # match. If --require-hashes is on, we are satisfied by any
+    # hash in `hashes` matching: a URL-based or an option-based
+    # one; no internet-sourced hash will be in `hashes`.
+    if hashes:
+        hashes.check_against_path(from_path)
+    return File(from_path, None)
+
+
+def unpack_url(
+    link: Link,
+    location: str,
+    download: Downloader,
+    verbosity: int,
+    download_dir: Optional[str] = None,
+    hashes: Optional[Hashes] = None,
+) -> Optional[File]:
+    """Unpack link into location, downloading if required.
+
+    :param hashes: A Hashes object, one of whose embedded hashes must match,
+        or HashMismatch will be raised. If the Hashes is empty, no matches are
+        required, and unhashable types of requirements (like VCS ones, which
+        would ordinarily raise HashUnsupported) are allowed.
+    """
+    # non-editable vcs urls
+    if link.is_vcs:
+        unpack_vcs_link(link, location, verbosity=verbosity)
+        return None
+
+    assert not link.is_existing_dir()
+
+    # file urls
+    if link.is_file:
+        file = get_file_url(link, download_dir, hashes=hashes)
+
+    # http urls
+    else:
+        file = get_http_url(
+            link,
+            download,
+            download_dir,
+            hashes=hashes,
+        )
+
+    # unpack the archive to the build dir location. even when only downloading
+    # archives, they have to be unpacked to parse dependencies, except wheels
+    if not link.is_wheel:
+        unpack_file(file.path, location, file.content_type)
+
+    return file
+
+
+def _check_download_dir(
+    link: Link,
+    download_dir: str,
+    hashes: Optional[Hashes],
+    warn_on_hash_mismatch: bool = True,
+) -> Optional[str]:
+    """Check download_dir for previously downloaded file with correct hash
+    If a correct file is found return its path else None
+    """
+    download_path = os.path.join(download_dir, link.filename)
+
+    if not os.path.exists(download_path):
+        return None
+
+    # If already downloaded, does its hash match?
+    logger.info("File was already downloaded %s", download_path)
+    if hashes:
+        try:
+            hashes.check_against_path(download_path)
+        except HashMismatch:
+            if warn_on_hash_mismatch:
+                logger.warning(
+                    "Previously-downloaded file %s has bad hash. Re-downloading.",
+                    download_path,
+                )
+            os.unlink(download_path)
+            return None
+    return download_path
+
+
+class RequirementPreparer:
+    """Prepares a Requirement"""
+
+    def __init__(
+        self,
+        build_dir: str,
+        download_dir: Optional[str],
+        src_dir: str,
+        build_isolation: bool,
+        check_build_deps: bool,
+        build_tracker: BuildTracker,
+        session: PipSession,
+        progress_bar: str,
+        finder: PackageFinder,
+        require_hashes: bool,
+        use_user_site: bool,
+        lazy_wheel: bool,
+        verbosity: int,
+        legacy_resolver: bool,
+    ) -> None:
+        super().__init__()
+
+        self.src_dir = src_dir
+        self.build_dir = build_dir
+        self.build_tracker = build_tracker
+        self._session = session
+        self._download = Downloader(session, progress_bar)
+        self._batch_download = BatchDownloader(session, progress_bar)
+        self.finder = finder
+
+        # Where still-packed archives should be written to. If None, they are
+        # not saved, and are deleted immediately after unpacking.
+        self.download_dir = download_dir
+
+        # Is build isolation allowed?
+        self.build_isolation = build_isolation
+
+        # Should check build dependencies?
+        self.check_build_deps = check_build_deps
+
+        # Should hash-checking be required?
+        self.require_hashes = require_hashes
+
+        # Should install in user site-packages?
+        self.use_user_site = use_user_site
+
+        # Should wheels be downloaded lazily?
+        self.use_lazy_wheel = lazy_wheel
+
+        # How verbose should underlying tooling be?
+        self.verbosity = verbosity
+
+        # Are we using the legacy resolver?
+        self.legacy_resolver = legacy_resolver
+
+        # Memoized downloaded files, as mapping of url: path.
+        self._downloaded: Dict[str, str] = {}
+
+        # Previous "header" printed for a link-based InstallRequirement
+        self._previous_requirement_header = ("", "")
+
+    def _log_preparing_link(self, req: InstallRequirement) -> None:
+        """Provide context for the requirement being prepared."""
+        if req.link.is_file and not req.is_wheel_from_cache:
+            message = "Processing %s"
+            information = str(display_path(req.link.file_path))
+        else:
+            message = "Collecting %s"
+            information = redact_auth_from_requirement(req.req) if req.req else str(req)
+
+        # If we used req.req, inject requirement source if available (this
+        # would already be included if we used req directly)
+        if req.req and req.comes_from:
+            if isinstance(req.comes_from, str):
+                comes_from: Optional[str] = req.comes_from
+            else:
+                comes_from = req.comes_from.from_path()
+            if comes_from:
+                information += f" (from {comes_from})"
+
+        if (message, information) != self._previous_requirement_header:
+            self._previous_requirement_header = (message, information)
+            logger.info(message, information)
+
+        if req.is_wheel_from_cache:
+            with indent_log():
+                logger.info("Using cached %s", req.link.filename)
+
+    def _ensure_link_req_src_dir(
+        self, req: InstallRequirement, parallel_builds: bool
+    ) -> None:
+        """Ensure source_dir of a linked InstallRequirement."""
+        # Since source_dir is only set for editable requirements.
+        if req.link.is_wheel:
+            # We don't need to unpack wheels, so no need for a source
+            # directory.
+            return
+        assert req.source_dir is None
+        if req.link.is_existing_dir():
+            # build local directories in-tree
+            req.source_dir = req.link.file_path
+            return
+
+        # We always delete unpacked sdists after pip runs.
+        req.ensure_has_source_dir(
+            self.build_dir,
+            autodelete=True,
+            parallel_builds=parallel_builds,
+        )
+        req.ensure_pristine_source_checkout()
+
+    def _get_linked_req_hashes(self, req: InstallRequirement) -> Hashes:
+        # By the time this is called, the requirement's link should have
+        # been checked so we can tell what kind of requirements req is
+        # and raise some more informative errors than otherwise.
+        # (For example, we can raise VcsHashUnsupported for a VCS URL
+        # rather than HashMissing.)
+        if not self.require_hashes:
+            return req.hashes(trust_internet=True)
+
+        # We could check these first 2 conditions inside unpack_url
+        # and save repetition of conditions, but then we would
+        # report less-useful error messages for unhashable
+        # requirements, complaining that there's no hash provided.
+        if req.link.is_vcs:
+            raise VcsHashUnsupported()
+        if req.link.is_existing_dir():
+            raise DirectoryUrlHashUnsupported()
+
+        # Unpinned packages are asking for trouble when a new version
+        # is uploaded.  This isn't a security check, but it saves users
+        # a surprising hash mismatch in the future.
+        # file:/// URLs aren't pinnable, so don't complain about them
+        # not being pinned.
+        if not req.is_direct and not req.is_pinned:
+            raise HashUnpinned()
+
+        # If known-good hashes are missing for this requirement,
+        # shim it with a facade object that will provoke hash
+        # computation and then raise a HashMissing exception
+        # showing the user what the hash should be.
+        return req.hashes(trust_internet=False) or MissingHashes()
+
+    def _fetch_metadata_only(
+        self,
+        req: InstallRequirement,
+    ) -> Optional[BaseDistribution]:
+        if self.legacy_resolver:
+            logger.debug(
+                "Metadata-only fetching is not used in the legacy resolver",
+            )
+            return None
+        if self.require_hashes:
+            logger.debug(
+                "Metadata-only fetching is not used as hash checking is required",
+            )
+            return None
+        # Try PEP 658 metadata first, then fall back to lazy wheel if unavailable.
+        return self._fetch_metadata_using_link_data_attr(
+            req
+        ) or self._fetch_metadata_using_lazy_wheel(req.link)
+
+    def _fetch_metadata_using_link_data_attr(
+        self,
+        req: InstallRequirement,
+    ) -> Optional[BaseDistribution]:
+        """Fetch metadata from the data-dist-info-metadata attribute, if possible."""
+        # (1) Get the link to the metadata file, if provided by the backend.
+        metadata_link = req.link.metadata_link()
+        if metadata_link is None:
+            return None
+        assert req.req is not None
+        logger.verbose(
+            "Obtaining dependency information for %s from %s",
+            req.req,
+            metadata_link,
+        )
+        # (2) Download the contents of the METADATA file, separate from the dist itself.
+        metadata_file = get_http_url(
+            metadata_link,
+            self._download,
+            hashes=metadata_link.as_hashes(),
+        )
+        with open(metadata_file.path, "rb") as f:
+            metadata_contents = f.read()
+        # (3) Generate a dist just from those file contents.
+        metadata_dist = get_metadata_distribution(
+            metadata_contents,
+            req.link.filename,
+            req.req.name,
+        )
+        # (4) Ensure the Name: field from the METADATA file matches the name from the
+        #     install requirement.
+        #
+        #     NB: raw_name will fall back to the name from the install requirement if
+        #     the Name: field is not present, but it's noted in the raw_name docstring
+        #     that that should NEVER happen anyway.
+        if canonicalize_name(metadata_dist.raw_name) != canonicalize_name(req.req.name):
+            raise MetadataInconsistent(
+                req, "Name", req.req.name, metadata_dist.raw_name
+            )
+        return metadata_dist
+
+    def _fetch_metadata_using_lazy_wheel(
+        self,
+        link: Link,
+    ) -> Optional[BaseDistribution]:
+        """Fetch metadata using lazy wheel, if possible."""
+        # --use-feature=fast-deps must be provided.
+        if not self.use_lazy_wheel:
+            return None
+        if link.is_file or not link.is_wheel:
+            logger.debug(
+                "Lazy wheel is not used as %r does not point to a remote wheel",
+                link,
+            )
+            return None
+
+        wheel = Wheel(link.filename)
+        name = canonicalize_name(wheel.name)
+        logger.info(
+            "Obtaining dependency information from %s %s",
+            name,
+            wheel.version,
+        )
+        url = link.url.split("#", 1)[0]
+        try:
+            return dist_from_wheel_url(name, url, self._session)
+        except HTTPRangeRequestUnsupported:
+            logger.debug("%s does not support range requests", url)
+            return None
+
+    def _complete_partial_requirements(
+        self,
+        partially_downloaded_reqs: Iterable[InstallRequirement],
+        parallel_builds: bool = False,
+    ) -> None:
+        """Download any requirements which were only fetched by metadata."""
+        # Download to a temporary directory. These will be copied over as
+        # needed for downstream 'download', 'wheel', and 'install' commands.
+        temp_dir = TempDirectory(kind="unpack", globally_managed=True).path
+
+        # Map each link to the requirement that owns it. This allows us to set
+        # `req.local_file_path` on the appropriate requirement after passing
+        # all the links at once into BatchDownloader.
+        links_to_fully_download: Dict[Link, InstallRequirement] = {}
+        for req in partially_downloaded_reqs:
+            assert req.link
+            links_to_fully_download[req.link] = req
+
+        batch_download = self._batch_download(
+            links_to_fully_download.keys(),
+            temp_dir,
+        )
+        for link, (filepath, _) in batch_download:
+            logger.debug("Downloading link %s to %s", link, filepath)
+            req = links_to_fully_download[link]
+            # Record the downloaded file path so wheel reqs can extract a Distribution
+            # in .get_dist().
+            req.local_file_path = filepath
+            # Record that the file is downloaded so we don't do it again in
+            # _prepare_linked_requirement().
+            self._downloaded[req.link.url] = filepath
+
+            # If this is an sdist, we need to unpack it after downloading, but the
+            # .source_dir won't be set up until we are in _prepare_linked_requirement().
+            # Add the downloaded archive to the install requirement to unpack after
+            # preparing the source dir.
+            if not req.is_wheel:
+                req.needs_unpacked_archive(Path(filepath))
+
+        # This step is necessary to ensure all lazy wheels are processed
+        # successfully by the 'download', 'wheel', and 'install' commands.
+        for req in partially_downloaded_reqs:
+            self._prepare_linked_requirement(req, parallel_builds)
+
+    def prepare_linked_requirement(
+        self, req: InstallRequirement, parallel_builds: bool = False
+    ) -> BaseDistribution:
+        """Prepare a requirement to be obtained from req.link."""
+        assert req.link
+        self._log_preparing_link(req)
+        with indent_log():
+            # Check if the relevant file is already available
+            # in the download directory
+            file_path = None
+            if self.download_dir is not None and req.link.is_wheel:
+                hashes = self._get_linked_req_hashes(req)
+                file_path = _check_download_dir(
+                    req.link,
+                    self.download_dir,
+                    hashes,
+                    # When a locally built wheel has been found in cache, we don't warn
+                    # about re-downloading when the already downloaded wheel hash does
+                    # not match. This is because the hash must be checked against the
+                    # original link, not the cached link. It that case the already
+                    # downloaded file will be removed and re-fetched from cache (which
+                    # implies a hash check against the cache entry's origin.json).
+                    warn_on_hash_mismatch=not req.is_wheel_from_cache,
+                )
+
+            if file_path is not None:
+                # The file is already available, so mark it as downloaded
+                self._downloaded[req.link.url] = file_path
+            else:
+                # The file is not available, attempt to fetch only metadata
+                metadata_dist = self._fetch_metadata_only(req)
+                if metadata_dist is not None:
+                    req.needs_more_preparation = True
+                    return metadata_dist
+
+            # None of the optimizations worked, fully prepare the requirement
+            return self._prepare_linked_requirement(req, parallel_builds)
+
+    def prepare_linked_requirements_more(
+        self, reqs: Iterable[InstallRequirement], parallel_builds: bool = False
+    ) -> None:
+        """Prepare linked requirements more, if needed."""
+        reqs = [req for req in reqs if req.needs_more_preparation]
+        for req in reqs:
+            # Determine if any of these requirements were already downloaded.
+            if self.download_dir is not None and req.link.is_wheel:
+                hashes = self._get_linked_req_hashes(req)
+                file_path = _check_download_dir(req.link, self.download_dir, hashes)
+                if file_path is not None:
+                    self._downloaded[req.link.url] = file_path
+                    req.needs_more_preparation = False
+
+        # Prepare requirements we found were already downloaded for some
+        # reason. The other downloads will be completed separately.
+        partially_downloaded_reqs: List[InstallRequirement] = []
+        for req in reqs:
+            if req.needs_more_preparation:
+                partially_downloaded_reqs.append(req)
+            else:
+                self._prepare_linked_requirement(req, parallel_builds)
+
+        # TODO: separate this part out from RequirementPreparer when the v1
+        # resolver can be removed!
+        self._complete_partial_requirements(
+            partially_downloaded_reqs,
+            parallel_builds=parallel_builds,
+        )
+
+    def _prepare_linked_requirement(
+        self, req: InstallRequirement, parallel_builds: bool
+    ) -> BaseDistribution:
+        assert req.link
+        link = req.link
+
+        hashes = self._get_linked_req_hashes(req)
+
+        if hashes and req.is_wheel_from_cache:
+            assert req.download_info is not None
+            assert link.is_wheel
+            assert link.is_file
+            # We need to verify hashes, and we have found the requirement in the cache
+            # of locally built wheels.
+            if (
+                isinstance(req.download_info.info, ArchiveInfo)
+                and req.download_info.info.hashes
+                and hashes.has_one_of(req.download_info.info.hashes)
+            ):
+                # At this point we know the requirement was built from a hashable source
+                # artifact, and we verified that the cache entry's hash of the original
+                # artifact matches one of the hashes we expect. We don't verify hashes
+                # against the cached wheel, because the wheel is not the original.
+                hashes = None
+            else:
+                logger.warning(
+                    "The hashes of the source archive found in cache entry "
+                    "don't match, ignoring cached built wheel "
+                    "and re-downloading source."
+                )
+                req.link = req.cached_wheel_source_link
+                link = req.link
+
+        self._ensure_link_req_src_dir(req, parallel_builds)
+
+        if link.is_existing_dir():
+            local_file = None
+        elif link.url not in self._downloaded:
+            try:
+                local_file = unpack_url(
+                    link,
+                    req.source_dir,
+                    self._download,
+                    self.verbosity,
+                    self.download_dir,
+                    hashes,
+                )
+            except NetworkConnectionError as exc:
+                raise InstallationError(
+                    f"Could not install requirement {req} because of HTTP "
+                    f"error {exc} for URL {link}"
+                )
+        else:
+            file_path = self._downloaded[link.url]
+            if hashes:
+                hashes.check_against_path(file_path)
+            local_file = File(file_path, content_type=None)
+
+        # If download_info is set, we got it from the wheel cache.
+        if req.download_info is None:
+            # Editables don't go through this function (see
+            # prepare_editable_requirement).
+            assert not req.editable
+            req.download_info = direct_url_from_link(link, req.source_dir)
+            # Make sure we have a hash in download_info. If we got it as part of the
+            # URL, it will have been verified and we can rely on it. Otherwise we
+            # compute it from the downloaded file.
+            # FIXME: https://github.com/pypa/pip/issues/11943
+            if (
+                isinstance(req.download_info.info, ArchiveInfo)
+                and not req.download_info.info.hashes
+                and local_file
+            ):
+                hash = hash_file(local_file.path)[0].hexdigest()
+                # We populate info.hash for backward compatibility.
+                # This will automatically populate info.hashes.
+                req.download_info.info.hash = f"sha256={hash}"
+
+        # For use in later processing,
+        # preserve the file path on the requirement.
+        if local_file:
+            req.local_file_path = local_file.path
+
+        dist = _get_prepared_distribution(
+            req,
+            self.build_tracker,
+            self.finder,
+            self.build_isolation,
+            self.check_build_deps,
+        )
+        return dist
+
+    def save_linked_requirement(self, req: InstallRequirement) -> None:
+        assert self.download_dir is not None
+        assert req.link is not None
+        link = req.link
+        if link.is_vcs or (link.is_existing_dir() and req.editable):
+            # Make a .zip of the source_dir we already created.
+            req.archive(self.download_dir)
+            return
+
+        if link.is_existing_dir():
+            logger.debug(
+                "Not copying link to destination directory "
+                "since it is a directory: %s",
+                link,
+            )
+            return
+        if req.local_file_path is None:
+            # No distribution was downloaded for this requirement.
+            return
+
+        download_location = os.path.join(self.download_dir, link.filename)
+        if not os.path.exists(download_location):
+            shutil.copy(req.local_file_path, download_location)
+            download_path = display_path(download_location)
+            logger.info("Saved %s", download_path)
+
+    def prepare_editable_requirement(
+        self,
+        req: InstallRequirement,
+    ) -> BaseDistribution:
+        """Prepare an editable requirement."""
+        assert req.editable, "cannot prepare a non-editable req as editable"
+
+        logger.info("Obtaining %s", req)
+
+        with indent_log():
+            if self.require_hashes:
+                raise InstallationError(
+                    f"The editable requirement {req} cannot be installed when "
+                    "requiring hashes, because there is no single file to "
+                    "hash."
+                )
+            req.ensure_has_source_dir(self.src_dir)
+            req.update_editable()
+            assert req.source_dir
+            req.download_info = direct_url_for_editable(req.unpacked_source_directory)
+
+            dist = _get_prepared_distribution(
+                req,
+                self.build_tracker,
+                self.finder,
+                self.build_isolation,
+                self.check_build_deps,
+            )
+
+            req.check_if_exists(self.use_user_site)
+
+        return dist
+
+    def prepare_installed_requirement(
+        self,
+        req: InstallRequirement,
+        skip_reason: str,
+    ) -> BaseDistribution:
+        """Prepare an already-installed requirement."""
+        assert req.satisfied_by, "req should have been satisfied but isn't"
+        assert skip_reason is not None, (
+            "did not get skip reason skipped but req.satisfied_by "
+            f"is set to {req.satisfied_by}"
+        )
+        logger.info(
+            "Requirement %s: %s (%s)", skip_reason, req, req.satisfied_by.version
+        )
+        with indent_log():
+            if self.require_hashes:
+                logger.debug(
+                    "Since it is already installed, we are trusting this "
+                    "package without checking its hash. To ensure a "
+                    "completely repeatable environment, install into an "
+                    "empty virtualenv."
+                )
+            return InstalledDistribution(req).get_metadata_distribution()
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/pyproject.py b/venv/lib/python3.12/site-packages/pip/_internal/pyproject.py
new file mode 100644
index 00000000..2a9cad48
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/pyproject.py
@@ -0,0 +1,185 @@
+import importlib.util
+import os
+import sys
+from collections import namedtuple
+from typing import Any, List, Optional
+
+if sys.version_info >= (3, 11):
+    import tomllib
+else:
+    from pip._vendor import tomli as tomllib
+
+from pip._vendor.packaging.requirements import InvalidRequirement
+
+from pip._internal.exceptions import (
+    InstallationError,
+    InvalidPyProjectBuildRequires,
+    MissingPyProjectBuildRequires,
+)
+from pip._internal.utils.packaging import get_requirement
+
+
+def _is_list_of_str(obj: Any) -> bool:
+    return isinstance(obj, list) and all(isinstance(item, str) for item in obj)
+
+
+def make_pyproject_path(unpacked_source_directory: str) -> str:
+    return os.path.join(unpacked_source_directory, "pyproject.toml")
+
+
+BuildSystemDetails = namedtuple(
+    "BuildSystemDetails", ["requires", "backend", "check", "backend_path"]
+)
+
+
+def load_pyproject_toml(
+    use_pep517: Optional[bool], pyproject_toml: str, setup_py: str, req_name: str
+) -> Optional[BuildSystemDetails]:
+    """Load the pyproject.toml file.
+
+    Parameters:
+        use_pep517 - Has the user requested PEP 517 processing? None
+                     means the user hasn't explicitly specified.
+        pyproject_toml - Location of the project's pyproject.toml file
+        setup_py - Location of the project's setup.py file
+        req_name - The name of the requirement we're processing (for
+                   error reporting)
+
+    Returns:
+        None if we should use the legacy code path, otherwise a tuple
+        (
+            requirements from pyproject.toml,
+            name of PEP 517 backend,
+            requirements we should check are installed after setting
+                up the build environment
+            directory paths to import the backend from (backend-path),
+                relative to the project root.
+        )
+    """
+    has_pyproject = os.path.isfile(pyproject_toml)
+    has_setup = os.path.isfile(setup_py)
+
+    if not has_pyproject and not has_setup:
+        raise InstallationError(
+            f"{req_name} does not appear to be a Python project: "
+            f"neither 'setup.py' nor 'pyproject.toml' found."
+        )
+
+    if has_pyproject:
+        with open(pyproject_toml, encoding="utf-8") as f:
+            pp_toml = tomllib.loads(f.read())
+        build_system = pp_toml.get("build-system")
+    else:
+        build_system = None
+
+    # The following cases must use PEP 517
+    # We check for use_pep517 being non-None and falsey because that means
+    # the user explicitly requested --no-use-pep517.  The value 0 as
+    # opposed to False can occur when the value is provided via an
+    # environment variable or config file option (due to the quirk of
+    # strtobool() returning an integer in pip's configuration code).
+    if has_pyproject and not has_setup:
+        if use_pep517 is not None and not use_pep517:
+            raise InstallationError(
+                "Disabling PEP 517 processing is invalid: "
+                "project does not have a setup.py"
+            )
+        use_pep517 = True
+    elif build_system and "build-backend" in build_system:
+        if use_pep517 is not None and not use_pep517:
+            raise InstallationError(
+                "Disabling PEP 517 processing is invalid: "
+                "project specifies a build backend of {} "
+                "in pyproject.toml".format(build_system["build-backend"])
+            )
+        use_pep517 = True
+
+    # If we haven't worked out whether to use PEP 517 yet,
+    # and the user hasn't explicitly stated a preference,
+    # we do so if the project has a pyproject.toml file
+    # or if we cannot import setuptools or wheels.
+
+    # We fallback to PEP 517 when without setuptools or without the wheel package,
+    # so setuptools can be installed as a default build backend.
+    # For more info see:
+    # https://discuss.python.org/t/pip-without-setuptools-could-the-experience-be-improved/11810/9
+    # https://github.com/pypa/pip/issues/8559
+    elif use_pep517 is None:
+        use_pep517 = (
+            has_pyproject
+            or not importlib.util.find_spec("setuptools")
+            or not importlib.util.find_spec("wheel")
+        )
+
+    # At this point, we know whether we're going to use PEP 517.
+    assert use_pep517 is not None
+
+    # If we're using the legacy code path, there is nothing further
+    # for us to do here.
+    if not use_pep517:
+        return None
+
+    if build_system is None:
+        # Either the user has a pyproject.toml with no build-system
+        # section, or the user has no pyproject.toml, but has opted in
+        # explicitly via --use-pep517.
+        # In the absence of any explicit backend specification, we
+        # assume the setuptools backend that most closely emulates the
+        # traditional direct setup.py execution, and require wheel and
+        # a version of setuptools that supports that backend.
+
+        build_system = {
+            "requires": ["setuptools>=40.8.0"],
+            "build-backend": "setuptools.build_meta:__legacy__",
+        }
+
+    # If we're using PEP 517, we have build system information (either
+    # from pyproject.toml, or defaulted by the code above).
+    # Note that at this point, we do not know if the user has actually
+    # specified a backend, though.
+    assert build_system is not None
+
+    # Ensure that the build-system section in pyproject.toml conforms
+    # to PEP 518.
+
+    # Specifying the build-system table but not the requires key is invalid
+    if "requires" not in build_system:
+        raise MissingPyProjectBuildRequires(package=req_name)
+
+    # Error out if requires is not a list of strings
+    requires = build_system["requires"]
+    if not _is_list_of_str(requires):
+        raise InvalidPyProjectBuildRequires(
+            package=req_name,
+            reason="It is not a list of strings.",
+        )
+
+    # Each requirement must be valid as per PEP 508
+    for requirement in requires:
+        try:
+            get_requirement(requirement)
+        except InvalidRequirement as error:
+            raise InvalidPyProjectBuildRequires(
+                package=req_name,
+                reason=f"It contains an invalid requirement: {requirement!r}",
+            ) from error
+
+    backend = build_system.get("build-backend")
+    backend_path = build_system.get("backend-path", [])
+    check: List[str] = []
+    if backend is None:
+        # If the user didn't specify a backend, we assume they want to use
+        # the setuptools backend. But we can't be sure they have included
+        # a version of setuptools which supplies the backend. So we
+        # make a note to check that this requirement is present once
+        # we have set up the environment.
+        # This is quite a lot of work to check for a very specific case. But
+        # the problem is, that case is potentially quite common - projects that
+        # adopted PEP 518 early for the ability to specify requirements to
+        # execute setup.py, but never considered needing to mention the build
+        # tools themselves. The original PEP 518 code had a similar check (but
+        # implemented in a different way).
+        backend = "setuptools.build_meta:__legacy__"
+        check = ["setuptools>=40.8.0"]
+
+    return BuildSystemDetails(requires, backend, check, backend_path)
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/req/__init__.py b/venv/lib/python3.12/site-packages/pip/_internal/req/__init__.py
new file mode 100644
index 00000000..422d851d
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/req/__init__.py
@@ -0,0 +1,90 @@
+import collections
+import logging
+from dataclasses import dataclass
+from typing import Generator, List, Optional, Sequence, Tuple
+
+from pip._internal.utils.logging import indent_log
+
+from .req_file import parse_requirements
+from .req_install import InstallRequirement
+from .req_set import RequirementSet
+
+__all__ = [
+    "RequirementSet",
+    "InstallRequirement",
+    "parse_requirements",
+    "install_given_reqs",
+]
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass(frozen=True)
+class InstallationResult:
+    name: str
+
+
+def _validate_requirements(
+    requirements: List[InstallRequirement],
+) -> Generator[Tuple[str, InstallRequirement], None, None]:
+    for req in requirements:
+        assert req.name, f"invalid to-be-installed requirement: {req}"
+        yield req.name, req
+
+
+def install_given_reqs(
+    requirements: List[InstallRequirement],
+    global_options: Sequence[str],
+    root: Optional[str],
+    home: Optional[str],
+    prefix: Optional[str],
+    warn_script_location: bool,
+    use_user_site: bool,
+    pycompile: bool,
+) -> List[InstallationResult]:
+    """
+    Install everything in the given list.
+
+    (to be called after having downloaded and unpacked the packages)
+    """
+    to_install = collections.OrderedDict(_validate_requirements(requirements))
+
+    if to_install:
+        logger.info(
+            "Installing collected packages: %s",
+            ", ".join(to_install.keys()),
+        )
+
+    installed = []
+
+    with indent_log():
+        for req_name, requirement in to_install.items():
+            if requirement.should_reinstall:
+                logger.info("Attempting uninstall: %s", req_name)
+                with indent_log():
+                    uninstalled_pathset = requirement.uninstall(auto_confirm=True)
+            else:
+                uninstalled_pathset = None
+
+            try:
+                requirement.install(
+                    global_options,
+                    root=root,
+                    home=home,
+                    prefix=prefix,
+                    warn_script_location=warn_script_location,
+                    use_user_site=use_user_site,
+                    pycompile=pycompile,
+                )
+            except Exception:
+                # if install did not succeed, rollback previous uninstall
+                if uninstalled_pathset and not requirement.install_succeeded:
+                    uninstalled_pathset.rollback()
+                raise
+            else:
+                if uninstalled_pathset and requirement.install_succeeded:
+                    uninstalled_pathset.commit()
+
+            installed.append(InstallationResult(req_name))
+
+    return installed
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/req/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/req/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 00000000..9b239373
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/req/__pycache__/__init__.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/req/__pycache__/constructors.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/req/__pycache__/constructors.cpython-312.pyc
new file mode 100644
index 00000000..c539ed97
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/req/__pycache__/constructors.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/req/__pycache__/req_file.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/req/__pycache__/req_file.cpython-312.pyc
new file mode 100644
index 00000000..20417b45
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/req/__pycache__/req_file.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/req/__pycache__/req_install.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/req/__pycache__/req_install.cpython-312.pyc
new file mode 100644
index 00000000..7a82056e
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/req/__pycache__/req_install.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/req/__pycache__/req_set.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/req/__pycache__/req_set.cpython-312.pyc
new file mode 100644
index 00000000..b9781af8
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/req/__pycache__/req_set.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/req/__pycache__/req_uninstall.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/req/__pycache__/req_uninstall.cpython-312.pyc
new file mode 100644
index 00000000..97a34d44
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/req/__pycache__/req_uninstall.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/req/constructors.py b/venv/lib/python3.12/site-packages/pip/_internal/req/constructors.py
new file mode 100644
index 00000000..d73236e0
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/req/constructors.py
@@ -0,0 +1,560 @@
+"""Backing implementation for InstallRequirement's various constructors
+
+The idea here is that these formed a major chunk of InstallRequirement's size
+so, moving them and support code dedicated to them outside of that class
+helps creates for better understandability for the rest of the code.
+
+These are meant to be used elsewhere within pip to create instances of
+InstallRequirement.
+"""
+
+import copy
+import logging
+import os
+import re
+from dataclasses import dataclass
+from typing import Collection, Dict, List, Optional, Set, Tuple, Union
+
+from pip._vendor.packaging.markers import Marker
+from pip._vendor.packaging.requirements import InvalidRequirement, Requirement
+from pip._vendor.packaging.specifiers import Specifier
+
+from pip._internal.exceptions import InstallationError
+from pip._internal.models.index import PyPI, TestPyPI
+from pip._internal.models.link import Link
+from pip._internal.models.wheel import Wheel
+from pip._internal.req.req_file import ParsedRequirement
+from pip._internal.req.req_install import InstallRequirement
+from pip._internal.utils.filetypes import is_archive_file
+from pip._internal.utils.misc import is_installable_dir
+from pip._internal.utils.packaging import get_requirement
+from pip._internal.utils.urls import path_to_url
+from pip._internal.vcs import is_url, vcs
+
+__all__ = [
+    "install_req_from_editable",
+    "install_req_from_line",
+    "parse_editable",
+]
+
+logger = logging.getLogger(__name__)
+operators = Specifier._operators.keys()
+
+
+def _strip_extras(path: str) -> Tuple[str, Optional[str]]:
+    m = re.match(r"^(.+)(\[[^\]]+\])$", path)
+    extras = None
+    if m:
+        path_no_extras = m.group(1)
+        extras = m.group(2)
+    else:
+        path_no_extras = path
+
+    return path_no_extras, extras
+
+
+def convert_extras(extras: Optional[str]) -> Set[str]:
+    if not extras:
+        return set()
+    return get_requirement("placeholder" + extras.lower()).extras
+
+
+def _set_requirement_extras(req: Requirement, new_extras: Set[str]) -> Requirement:
+    """
+    Returns a new requirement based on the given one, with the supplied extras. If the
+    given requirement already has extras those are replaced (or dropped if no new extras
+    are given).
+    """
+    match: Optional[re.Match[str]] = re.fullmatch(
+        # see https://peps.python.org/pep-0508/#complete-grammar
+        r"([\w\t .-]+)(\[[^\]]*\])?(.*)",
+        str(req),
+        flags=re.ASCII,
+    )
+    # ireq.req is a valid requirement so the regex should always match
+    assert (
+        match is not None
+    ), f"regex match on requirement {req} failed, this should never happen"
+    pre: Optional[str] = match.group(1)
+    post: Optional[str] = match.group(3)
+    assert (
+        pre is not None and post is not None
+    ), f"regex group selection for requirement {req} failed, this should never happen"
+    extras: str = "[%s]" % ",".join(sorted(new_extras)) if new_extras else ""
+    return get_requirement(f"{pre}{extras}{post}")
+
+
+def parse_editable(editable_req: str) -> Tuple[Optional[str], str, Set[str]]:
+    """Parses an editable requirement into:
+        - a requirement name
+        - an URL
+        - extras
+        - editable options
+    Accepted requirements:
+        svn+http://blahblah@rev#egg=Foobar[baz]&subdirectory=version_subdir
+        .[some_extra]
+    """
+
+    url = editable_req
+
+    # If a file path is specified with extras, strip off the extras.
+    url_no_extras, extras = _strip_extras(url)
+
+    if os.path.isdir(url_no_extras):
+        # Treating it as code that has already been checked out
+        url_no_extras = path_to_url(url_no_extras)
+
+    if url_no_extras.lower().startswith("file:"):
+        package_name = Link(url_no_extras).egg_fragment
+        if extras:
+            return (
+                package_name,
+                url_no_extras,
+                get_requirement("placeholder" + extras.lower()).extras,
+            )
+        else:
+            return package_name, url_no_extras, set()
+
+    for version_control in vcs:
+        if url.lower().startswith(f"{version_control}:"):
+            url = f"{version_control}+{url}"
+            break
+
+    link = Link(url)
+
+    if not link.is_vcs:
+        backends = ", ".join(vcs.all_schemes)
+        raise InstallationError(
+            f"{editable_req} is not a valid editable requirement. "
+            f"It should either be a path to a local project or a VCS URL "
+            f"(beginning with {backends})."
+        )
+
+    package_name = link.egg_fragment
+    if not package_name:
+        raise InstallationError(
+            f"Could not detect requirement name for '{editable_req}', "
+            "please specify one with #egg=your_package_name"
+        )
+    return package_name, url, set()
+
+
+def check_first_requirement_in_file(filename: str) -> None:
+    """Check if file is parsable as a requirements file.
+
+    This is heavily based on ``pkg_resources.parse_requirements``, but
+    simplified to just check the first meaningful line.
+
+    :raises InvalidRequirement: If the first meaningful line cannot be parsed
+        as an requirement.
+    """
+    with open(filename, encoding="utf-8", errors="ignore") as f:
+        # Create a steppable iterator, so we can handle \-continuations.
+        lines = (
+            line
+            for line in (line.strip() for line in f)
+            if line and not line.startswith("#")  # Skip blank lines/comments.
+        )
+
+        for line in lines:
+            # Drop comments -- a hash without a space may be in a URL.
+            if " #" in line:
+                line = line[: line.find(" #")]
+            # If there is a line continuation, drop it, and append the next line.
+            if line.endswith("\\"):
+                line = line[:-2].strip() + next(lines, "")
+            get_requirement(line)
+            return
+
+
+def deduce_helpful_msg(req: str) -> str:
+    """Returns helpful msg in case requirements file does not exist,
+    or cannot be parsed.
+
+    :params req: Requirements file path
+    """
+    if not os.path.exists(req):
+        return f" File '{req}' does not exist."
+    msg = " The path does exist. "
+    # Try to parse and check if it is a requirements file.
+    try:
+        check_first_requirement_in_file(req)
+    except InvalidRequirement:
+        logger.debug("Cannot parse '%s' as requirements file", req)
+    else:
+        msg += (
+            f"The argument you provided "
+            f"({req}) appears to be a"
+            f" requirements file. If that is the"
+            f" case, use the '-r' flag to install"
+            f" the packages specified within it."
+        )
+    return msg
+
+
+@dataclass(frozen=True)
+class RequirementParts:
+    requirement: Optional[Requirement]
+    link: Optional[Link]
+    markers: Optional[Marker]
+    extras: Set[str]
+
+
+def parse_req_from_editable(editable_req: str) -> RequirementParts:
+    name, url, extras_override = parse_editable(editable_req)
+
+    if name is not None:
+        try:
+            req: Optional[Requirement] = get_requirement(name)
+        except InvalidRequirement as exc:
+            raise InstallationError(f"Invalid requirement: {name!r}: {exc}")
+    else:
+        req = None
+
+    link = Link(url)
+
+    return RequirementParts(req, link, None, extras_override)
+
+
+# ---- The actual constructors follow ----
+
+
+def install_req_from_editable(
+    editable_req: str,
+    comes_from: Optional[Union[InstallRequirement, str]] = None,
+    *,
+    use_pep517: Optional[bool] = None,
+    isolated: bool = False,
+    global_options: Optional[List[str]] = None,
+    hash_options: Optional[Dict[str, List[str]]] = None,
+    constraint: bool = False,
+    user_supplied: bool = False,
+    permit_editable_wheels: bool = False,
+    config_settings: Optional[Dict[str, Union[str, List[str]]]] = None,
+) -> InstallRequirement:
+    parts = parse_req_from_editable(editable_req)
+
+    return InstallRequirement(
+        parts.requirement,
+        comes_from=comes_from,
+        user_supplied=user_supplied,
+        editable=True,
+        permit_editable_wheels=permit_editable_wheels,
+        link=parts.link,
+        constraint=constraint,
+        use_pep517=use_pep517,
+        isolated=isolated,
+        global_options=global_options,
+        hash_options=hash_options,
+        config_settings=config_settings,
+        extras=parts.extras,
+    )
+
+
+def _looks_like_path(name: str) -> bool:
+    """Checks whether the string "looks like" a path on the filesystem.
+
+    This does not check whether the target actually exists, only judge from the
+    appearance.
+
+    Returns true if any of the following conditions is true:
+    * a path separator is found (either os.path.sep or os.path.altsep);
+    * a dot is found (which represents the current directory).
+    """
+    if os.path.sep in name:
+        return True
+    if os.path.altsep is not None and os.path.altsep in name:
+        return True
+    if name.startswith("."):
+        return True
+    return False
+
+
+def _get_url_from_path(path: str, name: str) -> Optional[str]:
+    """
+    First, it checks whether a provided path is an installable directory. If it
+    is, returns the path.
+
+    If false, check if the path is an archive file (such as a .whl).
+    The function checks if the path is a file. If false, if the path has
+    an @, it will treat it as a PEP 440 URL requirement and return the path.
+    """
+    if _looks_like_path(name) and os.path.isdir(path):
+        if is_installable_dir(path):
+            return path_to_url(path)
+        # TODO: The is_installable_dir test here might not be necessary
+        #       now that it is done in load_pyproject_toml too.
+        raise InstallationError(
+            f"Directory {name!r} is not installable. Neither 'setup.py' "
+            "nor 'pyproject.toml' found."
+        )
+    if not is_archive_file(path):
+        return None
+    if os.path.isfile(path):
+        return path_to_url(path)
+    urlreq_parts = name.split("@", 1)
+    if len(urlreq_parts) >= 2 and not _looks_like_path(urlreq_parts[0]):
+        # If the path contains '@' and the part before it does not look
+        # like a path, try to treat it as a PEP 440 URL req instead.
+        return None
+    logger.warning(
+        "Requirement %r looks like a filename, but the file does not exist",
+        name,
+    )
+    return path_to_url(path)
+
+
+def parse_req_from_line(name: str, line_source: Optional[str]) -> RequirementParts:
+    if is_url(name):
+        marker_sep = "; "
+    else:
+        marker_sep = ";"
+    if marker_sep in name:
+        name, markers_as_string = name.split(marker_sep, 1)
+        markers_as_string = markers_as_string.strip()
+        if not markers_as_string:
+            markers = None
+        else:
+            markers = Marker(markers_as_string)
+    else:
+        markers = None
+    name = name.strip()
+    req_as_string = None
+    path = os.path.normpath(os.path.abspath(name))
+    link = None
+    extras_as_string = None
+
+    if is_url(name):
+        link = Link(name)
+    else:
+        p, extras_as_string = _strip_extras(path)
+        url = _get_url_from_path(p, name)
+        if url is not None:
+            link = Link(url)
+
+    # it's a local file, dir, or url
+    if link:
+        # Handle relative file URLs
+        if link.scheme == "file" and re.search(r"\.\./", link.url):
+            link = Link(path_to_url(os.path.normpath(os.path.abspath(link.path))))
+        # wheel file
+        if link.is_wheel:
+            wheel = Wheel(link.filename)  # can raise InvalidWheelFilename
+            req_as_string = f"{wheel.name}=={wheel.version}"
+        else:
+            # set the req to the egg fragment.  when it's not there, this
+            # will become an 'unnamed' requirement
+            req_as_string = link.egg_fragment
+
+    # a requirement specifier
+    else:
+        req_as_string = name
+
+    extras = convert_extras(extras_as_string)
+
+    def with_source(text: str) -> str:
+        if not line_source:
+            return text
+        return f"{text} (from {line_source})"
+
+    def _parse_req_string(req_as_string: str) -> Requirement:
+        try:
+            return get_requirement(req_as_string)
+        except InvalidRequirement as exc:
+            if os.path.sep in req_as_string:
+                add_msg = "It looks like a path."
+                add_msg += deduce_helpful_msg(req_as_string)
+            elif "=" in req_as_string and not any(
+                op in req_as_string for op in operators
+            ):
+                add_msg = "= is not a valid operator. Did you mean == ?"
+            else:
+                add_msg = ""
+            msg = with_source(f"Invalid requirement: {req_as_string!r}: {exc}")
+            if add_msg:
+                msg += f"\nHint: {add_msg}"
+            raise InstallationError(msg)
+
+    if req_as_string is not None:
+        req: Optional[Requirement] = _parse_req_string(req_as_string)
+    else:
+        req = None
+
+    return RequirementParts(req, link, markers, extras)
+
+
+def install_req_from_line(
+    name: str,
+    comes_from: Optional[Union[str, InstallRequirement]] = None,
+    *,
+    use_pep517: Optional[bool] = None,
+    isolated: bool = False,
+    global_options: Optional[List[str]] = None,
+    hash_options: Optional[Dict[str, List[str]]] = None,
+    constraint: bool = False,
+    line_source: Optional[str] = None,
+    user_supplied: bool = False,
+    config_settings: Optional[Dict[str, Union[str, List[str]]]] = None,
+) -> InstallRequirement:
+    """Creates an InstallRequirement from a name, which might be a
+    requirement, directory containing 'setup.py', filename, or URL.
+
+    :param line_source: An optional string describing where the line is from,
+        for logging purposes in case of an error.
+    """
+    parts = parse_req_from_line(name, line_source)
+
+    return InstallRequirement(
+        parts.requirement,
+        comes_from,
+        link=parts.link,
+        markers=parts.markers,
+        use_pep517=use_pep517,
+        isolated=isolated,
+        global_options=global_options,
+        hash_options=hash_options,
+        config_settings=config_settings,
+        constraint=constraint,
+        extras=parts.extras,
+        user_supplied=user_supplied,
+    )
+
+
+def install_req_from_req_string(
+    req_string: str,
+    comes_from: Optional[InstallRequirement] = None,
+    isolated: bool = False,
+    use_pep517: Optional[bool] = None,
+    user_supplied: bool = False,
+) -> InstallRequirement:
+    try:
+        req = get_requirement(req_string)
+    except InvalidRequirement as exc:
+        raise InstallationError(f"Invalid requirement: {req_string!r}: {exc}")
+
+    domains_not_allowed = [
+        PyPI.file_storage_domain,
+        TestPyPI.file_storage_domain,
+    ]
+    if (
+        req.url
+        and comes_from
+        and comes_from.link
+        and comes_from.link.netloc in domains_not_allowed
+    ):
+        # Explicitly disallow pypi packages that depend on external urls
+        raise InstallationError(
+            "Packages installed from PyPI cannot depend on packages "
+            "which are not also hosted on PyPI.\n"
+            f"{comes_from.name} depends on {req} "
+        )
+
+    return InstallRequirement(
+        req,
+        comes_from,
+        isolated=isolated,
+        use_pep517=use_pep517,
+        user_supplied=user_supplied,
+    )
+
+
+def install_req_from_parsed_requirement(
+    parsed_req: ParsedRequirement,
+    isolated: bool = False,
+    use_pep517: Optional[bool] = None,
+    user_supplied: bool = False,
+    config_settings: Optional[Dict[str, Union[str, List[str]]]] = None,
+) -> InstallRequirement:
+    if parsed_req.is_editable:
+        req = install_req_from_editable(
+            parsed_req.requirement,
+            comes_from=parsed_req.comes_from,
+            use_pep517=use_pep517,
+            constraint=parsed_req.constraint,
+            isolated=isolated,
+            user_supplied=user_supplied,
+            config_settings=config_settings,
+        )
+
+    else:
+        req = install_req_from_line(
+            parsed_req.requirement,
+            comes_from=parsed_req.comes_from,
+            use_pep517=use_pep517,
+            isolated=isolated,
+            global_options=(
+                parsed_req.options.get("global_options", [])
+                if parsed_req.options
+                else []
+            ),
+            hash_options=(
+                parsed_req.options.get("hashes", {}) if parsed_req.options else {}
+            ),
+            constraint=parsed_req.constraint,
+            line_source=parsed_req.line_source,
+            user_supplied=user_supplied,
+            config_settings=config_settings,
+        )
+    return req
+
+
+def install_req_from_link_and_ireq(
+    link: Link, ireq: InstallRequirement
+) -> InstallRequirement:
+    return InstallRequirement(
+        req=ireq.req,
+        comes_from=ireq.comes_from,
+        editable=ireq.editable,
+        link=link,
+        markers=ireq.markers,
+        use_pep517=ireq.use_pep517,
+        isolated=ireq.isolated,
+        global_options=ireq.global_options,
+        hash_options=ireq.hash_options,
+        config_settings=ireq.config_settings,
+        user_supplied=ireq.user_supplied,
+    )
+
+
+def install_req_drop_extras(ireq: InstallRequirement) -> InstallRequirement:
+    """
+    Creates a new InstallationRequirement using the given template but without
+    any extras. Sets the original requirement as the new one's parent
+    (comes_from).
+    """
+    return InstallRequirement(
+        req=(
+            _set_requirement_extras(ireq.req, set()) if ireq.req is not None else None
+        ),
+        comes_from=ireq,
+        editable=ireq.editable,
+        link=ireq.link,
+        markers=ireq.markers,
+        use_pep517=ireq.use_pep517,
+        isolated=ireq.isolated,
+        global_options=ireq.global_options,
+        hash_options=ireq.hash_options,
+        constraint=ireq.constraint,
+        extras=[],
+        config_settings=ireq.config_settings,
+        user_supplied=ireq.user_supplied,
+        permit_editable_wheels=ireq.permit_editable_wheels,
+    )
+
+
+def install_req_extend_extras(
+    ireq: InstallRequirement,
+    extras: Collection[str],
+) -> InstallRequirement:
+    """
+    Returns a copy of an installation requirement with some additional extras.
+    Makes a shallow copy of the ireq object.
+    """
+    result = copy.copy(ireq)
+    result.extras = {*ireq.extras, *extras}
+    result.req = (
+        _set_requirement_extras(ireq.req, result.extras)
+        if ireq.req is not None
+        else None
+    )
+    return result
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/req/req_file.py b/venv/lib/python3.12/site-packages/pip/_internal/req/req_file.py
new file mode 100644
index 00000000..53ad8674
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/req/req_file.py
@@ -0,0 +1,551 @@
+"""
+Requirements file parsing
+"""
+
+import logging
+import optparse
+import os
+import re
+import shlex
+import urllib.parse
+from optparse import Values
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Callable,
+    Dict,
+    Generator,
+    Iterable,
+    List,
+    NoReturn,
+    Optional,
+    Tuple,
+)
+
+from pip._internal.cli import cmdoptions
+from pip._internal.exceptions import InstallationError, RequirementsFileParseError
+from pip._internal.models.search_scope import SearchScope
+from pip._internal.utils.encoding import auto_decode
+
+if TYPE_CHECKING:
+    from pip._internal.index.package_finder import PackageFinder
+    from pip._internal.network.session import PipSession
+
+__all__ = ["parse_requirements"]
+
+ReqFileLines = Iterable[Tuple[int, str]]
+
+LineParser = Callable[[str], Tuple[str, Values]]
+
+SCHEME_RE = re.compile(r"^(http|https|file):", re.I)
+COMMENT_RE = re.compile(r"(^|\s+)#.*$")
+
+# Matches environment variable-style values in '${MY_VARIABLE_1}' with the
+# variable name consisting of only uppercase letters, digits or the '_'
+# (underscore). This follows the POSIX standard defined in IEEE Std 1003.1,
+# 2013 Edition.
+ENV_VAR_RE = re.compile(r"(?P\$\{(?P[A-Z0-9_]+)\})")
+
+SUPPORTED_OPTIONS: List[Callable[..., optparse.Option]] = [
+    cmdoptions.index_url,
+    cmdoptions.extra_index_url,
+    cmdoptions.no_index,
+    cmdoptions.constraints,
+    cmdoptions.requirements,
+    cmdoptions.editable,
+    cmdoptions.find_links,
+    cmdoptions.no_binary,
+    cmdoptions.only_binary,
+    cmdoptions.prefer_binary,
+    cmdoptions.require_hashes,
+    cmdoptions.pre,
+    cmdoptions.trusted_host,
+    cmdoptions.use_new_feature,
+]
+
+# options to be passed to requirements
+SUPPORTED_OPTIONS_REQ: List[Callable[..., optparse.Option]] = [
+    cmdoptions.global_options,
+    cmdoptions.hash,
+    cmdoptions.config_settings,
+]
+
+SUPPORTED_OPTIONS_EDITABLE_REQ: List[Callable[..., optparse.Option]] = [
+    cmdoptions.config_settings,
+]
+
+
+# the 'dest' string values
+SUPPORTED_OPTIONS_REQ_DEST = [str(o().dest) for o in SUPPORTED_OPTIONS_REQ]
+SUPPORTED_OPTIONS_EDITABLE_REQ_DEST = [
+    str(o().dest) for o in SUPPORTED_OPTIONS_EDITABLE_REQ
+]
+
+logger = logging.getLogger(__name__)
+
+
+class ParsedRequirement:
+    def __init__(
+        self,
+        requirement: str,
+        is_editable: bool,
+        comes_from: str,
+        constraint: bool,
+        options: Optional[Dict[str, Any]] = None,
+        line_source: Optional[str] = None,
+    ) -> None:
+        self.requirement = requirement
+        self.is_editable = is_editable
+        self.comes_from = comes_from
+        self.options = options
+        self.constraint = constraint
+        self.line_source = line_source
+
+
+class ParsedLine:
+    def __init__(
+        self,
+        filename: str,
+        lineno: int,
+        args: str,
+        opts: Values,
+        constraint: bool,
+    ) -> None:
+        self.filename = filename
+        self.lineno = lineno
+        self.opts = opts
+        self.constraint = constraint
+
+        if args:
+            self.is_requirement = True
+            self.is_editable = False
+            self.requirement = args
+        elif opts.editables:
+            self.is_requirement = True
+            self.is_editable = True
+            # We don't support multiple -e on one line
+            self.requirement = opts.editables[0]
+        else:
+            self.is_requirement = False
+
+
+def parse_requirements(
+    filename: str,
+    session: "PipSession",
+    finder: Optional["PackageFinder"] = None,
+    options: Optional[optparse.Values] = None,
+    constraint: bool = False,
+) -> Generator[ParsedRequirement, None, None]:
+    """Parse a requirements file and yield ParsedRequirement instances.
+
+    :param filename:    Path or url of requirements file.
+    :param session:     PipSession instance.
+    :param finder:      Instance of pip.index.PackageFinder.
+    :param options:     cli options.
+    :param constraint:  If true, parsing a constraint file rather than
+        requirements file.
+    """
+    line_parser = get_line_parser(finder)
+    parser = RequirementsFileParser(session, line_parser)
+
+    for parsed_line in parser.parse(filename, constraint):
+        parsed_req = handle_line(
+            parsed_line, options=options, finder=finder, session=session
+        )
+        if parsed_req is not None:
+            yield parsed_req
+
+
+def preprocess(content: str) -> ReqFileLines:
+    """Split, filter, and join lines, and return a line iterator
+
+    :param content: the content of the requirements file
+    """
+    lines_enum: ReqFileLines = enumerate(content.splitlines(), start=1)
+    lines_enum = join_lines(lines_enum)
+    lines_enum = ignore_comments(lines_enum)
+    lines_enum = expand_env_variables(lines_enum)
+    return lines_enum
+
+
+def handle_requirement_line(
+    line: ParsedLine,
+    options: Optional[optparse.Values] = None,
+) -> ParsedRequirement:
+    # preserve for the nested code path
+    line_comes_from = "{} {} (line {})".format(
+        "-c" if line.constraint else "-r",
+        line.filename,
+        line.lineno,
+    )
+
+    assert line.is_requirement
+
+    # get the options that apply to requirements
+    if line.is_editable:
+        supported_dest = SUPPORTED_OPTIONS_EDITABLE_REQ_DEST
+    else:
+        supported_dest = SUPPORTED_OPTIONS_REQ_DEST
+    req_options = {}
+    for dest in supported_dest:
+        if dest in line.opts.__dict__ and line.opts.__dict__[dest]:
+            req_options[dest] = line.opts.__dict__[dest]
+
+    line_source = f"line {line.lineno} of {line.filename}"
+    return ParsedRequirement(
+        requirement=line.requirement,
+        is_editable=line.is_editable,
+        comes_from=line_comes_from,
+        constraint=line.constraint,
+        options=req_options,
+        line_source=line_source,
+    )
+
+
+def handle_option_line(
+    opts: Values,
+    filename: str,
+    lineno: int,
+    finder: Optional["PackageFinder"] = None,
+    options: Optional[optparse.Values] = None,
+    session: Optional["PipSession"] = None,
+) -> None:
+    if opts.hashes:
+        logger.warning(
+            "%s line %s has --hash but no requirement, and will be ignored.",
+            filename,
+            lineno,
+        )
+
+    if options:
+        # percolate options upward
+        if opts.require_hashes:
+            options.require_hashes = opts.require_hashes
+        if opts.features_enabled:
+            options.features_enabled.extend(
+                f for f in opts.features_enabled if f not in options.features_enabled
+            )
+
+    # set finder options
+    if finder:
+        find_links = finder.find_links
+        index_urls = finder.index_urls
+        no_index = finder.search_scope.no_index
+        if opts.no_index is True:
+            no_index = True
+            index_urls = []
+        if opts.index_url and not no_index:
+            index_urls = [opts.index_url]
+        if opts.extra_index_urls and not no_index:
+            index_urls.extend(opts.extra_index_urls)
+        if opts.find_links:
+            # FIXME: it would be nice to keep track of the source
+            # of the find_links: support a find-links local path
+            # relative to a requirements file.
+            value = opts.find_links[0]
+            req_dir = os.path.dirname(os.path.abspath(filename))
+            relative_to_reqs_file = os.path.join(req_dir, value)
+            if os.path.exists(relative_to_reqs_file):
+                value = relative_to_reqs_file
+            find_links.append(value)
+
+        if session:
+            # We need to update the auth urls in session
+            session.update_index_urls(index_urls)
+
+        search_scope = SearchScope(
+            find_links=find_links,
+            index_urls=index_urls,
+            no_index=no_index,
+        )
+        finder.search_scope = search_scope
+
+        if opts.pre:
+            finder.set_allow_all_prereleases()
+
+        if opts.prefer_binary:
+            finder.set_prefer_binary()
+
+        if session:
+            for host in opts.trusted_hosts or []:
+                source = f"line {lineno} of {filename}"
+                session.add_trusted_host(host, source=source)
+
+
+def handle_line(
+    line: ParsedLine,
+    options: Optional[optparse.Values] = None,
+    finder: Optional["PackageFinder"] = None,
+    session: Optional["PipSession"] = None,
+) -> Optional[ParsedRequirement]:
+    """Handle a single parsed requirements line; This can result in
+    creating/yielding requirements, or updating the finder.
+
+    :param line:        The parsed line to be processed.
+    :param options:     CLI options.
+    :param finder:      The finder - updated by non-requirement lines.
+    :param session:     The session - updated by non-requirement lines.
+
+    Returns a ParsedRequirement object if the line is a requirement line,
+    otherwise returns None.
+
+    For lines that contain requirements, the only options that have an effect
+    are from SUPPORTED_OPTIONS_REQ, and they are scoped to the
+    requirement. Other options from SUPPORTED_OPTIONS may be present, but are
+    ignored.
+
+    For lines that do not contain requirements, the only options that have an
+    effect are from SUPPORTED_OPTIONS. Options from SUPPORTED_OPTIONS_REQ may
+    be present, but are ignored. These lines may contain multiple options
+    (although our docs imply only one is supported), and all our parsed and
+    affect the finder.
+    """
+
+    if line.is_requirement:
+        parsed_req = handle_requirement_line(line, options)
+        return parsed_req
+    else:
+        handle_option_line(
+            line.opts,
+            line.filename,
+            line.lineno,
+            finder,
+            options,
+            session,
+        )
+        return None
+
+
+class RequirementsFileParser:
+    def __init__(
+        self,
+        session: "PipSession",
+        line_parser: LineParser,
+    ) -> None:
+        self._session = session
+        self._line_parser = line_parser
+
+    def parse(
+        self, filename: str, constraint: bool
+    ) -> Generator[ParsedLine, None, None]:
+        """Parse a given file, yielding parsed lines."""
+        yield from self._parse_and_recurse(filename, constraint)
+
+    def _parse_and_recurse(
+        self, filename: str, constraint: bool
+    ) -> Generator[ParsedLine, None, None]:
+        for line in self._parse_file(filename, constraint):
+            if not line.is_requirement and (
+                line.opts.requirements or line.opts.constraints
+            ):
+                # parse a nested requirements file
+                if line.opts.requirements:
+                    req_path = line.opts.requirements[0]
+                    nested_constraint = False
+                else:
+                    req_path = line.opts.constraints[0]
+                    nested_constraint = True
+
+                # original file is over http
+                if SCHEME_RE.search(filename):
+                    # do a url join so relative paths work
+                    req_path = urllib.parse.urljoin(filename, req_path)
+                # original file and nested file are paths
+                elif not SCHEME_RE.search(req_path):
+                    # do a join so relative paths work
+                    req_path = os.path.join(
+                        os.path.dirname(filename),
+                        req_path,
+                    )
+
+                yield from self._parse_and_recurse(req_path, nested_constraint)
+            else:
+                yield line
+
+    def _parse_file(
+        self, filename: str, constraint: bool
+    ) -> Generator[ParsedLine, None, None]:
+        _, content = get_file_content(filename, self._session)
+
+        lines_enum = preprocess(content)
+
+        for line_number, line in lines_enum:
+            try:
+                args_str, opts = self._line_parser(line)
+            except OptionParsingError as e:
+                # add offending line
+                msg = f"Invalid requirement: {line}\n{e.msg}"
+                raise RequirementsFileParseError(msg)
+
+            yield ParsedLine(
+                filename,
+                line_number,
+                args_str,
+                opts,
+                constraint,
+            )
+
+
+def get_line_parser(finder: Optional["PackageFinder"]) -> LineParser:
+    def parse_line(line: str) -> Tuple[str, Values]:
+        # Build new parser for each line since it accumulates appendable
+        # options.
+        parser = build_parser()
+        defaults = parser.get_default_values()
+        defaults.index_url = None
+        if finder:
+            defaults.format_control = finder.format_control
+
+        args_str, options_str = break_args_options(line)
+
+        try:
+            options = shlex.split(options_str)
+        except ValueError as e:
+            raise OptionParsingError(f"Could not split options: {options_str}") from e
+
+        opts, _ = parser.parse_args(options, defaults)
+
+        return args_str, opts
+
+    return parse_line
+
+
+def break_args_options(line: str) -> Tuple[str, str]:
+    """Break up the line into an args and options string.  We only want to shlex
+    (and then optparse) the options, not the args.  args can contain markers
+    which are corrupted by shlex.
+    """
+    tokens = line.split(" ")
+    args = []
+    options = tokens[:]
+    for token in tokens:
+        if token.startswith("-") or token.startswith("--"):
+            break
+        else:
+            args.append(token)
+            options.pop(0)
+    return " ".join(args), " ".join(options)
+
+
+class OptionParsingError(Exception):
+    def __init__(self, msg: str) -> None:
+        self.msg = msg
+
+
+def build_parser() -> optparse.OptionParser:
+    """
+    Return a parser for parsing requirement lines
+    """
+    parser = optparse.OptionParser(add_help_option=False)
+
+    option_factories = SUPPORTED_OPTIONS + SUPPORTED_OPTIONS_REQ
+    for option_factory in option_factories:
+        option = option_factory()
+        parser.add_option(option)
+
+    # By default optparse sys.exits on parsing errors. We want to wrap
+    # that in our own exception.
+    def parser_exit(self: Any, msg: str) -> "NoReturn":
+        raise OptionParsingError(msg)
+
+    # NOTE: mypy disallows assigning to a method
+    #       https://github.com/python/mypy/issues/2427
+    parser.exit = parser_exit  # type: ignore
+
+    return parser
+
+
+def join_lines(lines_enum: ReqFileLines) -> ReqFileLines:
+    """Joins a line ending in '\' with the previous line (except when following
+    comments).  The joined line takes on the index of the first line.
+    """
+    primary_line_number = None
+    new_line: List[str] = []
+    for line_number, line in lines_enum:
+        if not line.endswith("\\") or COMMENT_RE.match(line):
+            if COMMENT_RE.match(line):
+                # this ensures comments are always matched later
+                line = " " + line
+            if new_line:
+                new_line.append(line)
+                assert primary_line_number is not None
+                yield primary_line_number, "".join(new_line)
+                new_line = []
+            else:
+                yield line_number, line
+        else:
+            if not new_line:
+                primary_line_number = line_number
+            new_line.append(line.strip("\\"))
+
+    # last line contains \
+    if new_line:
+        assert primary_line_number is not None
+        yield primary_line_number, "".join(new_line)
+
+    # TODO: handle space after '\'.
+
+
+def ignore_comments(lines_enum: ReqFileLines) -> ReqFileLines:
+    """
+    Strips comments and filter empty lines.
+    """
+    for line_number, line in lines_enum:
+        line = COMMENT_RE.sub("", line)
+        line = line.strip()
+        if line:
+            yield line_number, line
+
+
+def expand_env_variables(lines_enum: ReqFileLines) -> ReqFileLines:
+    """Replace all environment variables that can be retrieved via `os.getenv`.
+
+    The only allowed format for environment variables defined in the
+    requirement file is `${MY_VARIABLE_1}` to ensure two things:
+
+    1. Strings that contain a `$` aren't accidentally (partially) expanded.
+    2. Ensure consistency across platforms for requirement files.
+
+    These points are the result of a discussion on the `github pull
+    request #3514 `_.
+
+    Valid characters in variable names follow the `POSIX standard
+    `_ and are limited
+    to uppercase letter, digits and the `_` (underscore).
+    """
+    for line_number, line in lines_enum:
+        for env_var, var_name in ENV_VAR_RE.findall(line):
+            value = os.getenv(var_name)
+            if not value:
+                continue
+
+            line = line.replace(env_var, value)
+
+        yield line_number, line
+
+
+def get_file_content(url: str, session: "PipSession") -> Tuple[str, str]:
+    """Gets the content of a file; it may be a filename, file: URL, or
+    http: URL.  Returns (location, content).  Content is unicode.
+    Respects # -*- coding: declarations on the retrieved files.
+
+    :param url:         File path or url.
+    :param session:     PipSession instance.
+    """
+    scheme = urllib.parse.urlsplit(url).scheme
+    # Pip has special support for file:// URLs (LocalFSAdapter).
+    if scheme in ["http", "https", "file"]:
+        # Delay importing heavy network modules until absolutely necessary.
+        from pip._internal.network.utils import raise_for_status
+
+        resp = session.get(url)
+        raise_for_status(resp)
+        return resp.url, resp.text
+
+    # Assume this is a bare path.
+    try:
+        with open(url, "rb") as f:
+            content = auto_decode(f.read())
+    except OSError as exc:
+        raise InstallationError(f"Could not open requirements file: {exc}")
+    return url, content
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/req/req_install.py b/venv/lib/python3.12/site-packages/pip/_internal/req/req_install.py
new file mode 100644
index 00000000..834bc513
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/req/req_install.py
@@ -0,0 +1,934 @@
+import functools
+import logging
+import os
+import shutil
+import sys
+import uuid
+import zipfile
+from optparse import Values
+from pathlib import Path
+from typing import Any, Collection, Dict, Iterable, List, Optional, Sequence, Union
+
+from pip._vendor.packaging.markers import Marker
+from pip._vendor.packaging.requirements import Requirement
+from pip._vendor.packaging.specifiers import SpecifierSet
+from pip._vendor.packaging.utils import canonicalize_name
+from pip._vendor.packaging.version import Version
+from pip._vendor.packaging.version import parse as parse_version
+from pip._vendor.pyproject_hooks import BuildBackendHookCaller
+
+from pip._internal.build_env import BuildEnvironment, NoOpBuildEnvironment
+from pip._internal.exceptions import InstallationError, PreviousBuildDirError
+from pip._internal.locations import get_scheme
+from pip._internal.metadata import (
+    BaseDistribution,
+    get_default_environment,
+    get_directory_distribution,
+    get_wheel_distribution,
+)
+from pip._internal.metadata.base import FilesystemWheel
+from pip._internal.models.direct_url import DirectUrl
+from pip._internal.models.link import Link
+from pip._internal.operations.build.metadata import generate_metadata
+from pip._internal.operations.build.metadata_editable import generate_editable_metadata
+from pip._internal.operations.build.metadata_legacy import (
+    generate_metadata as generate_metadata_legacy,
+)
+from pip._internal.operations.install.editable_legacy import (
+    install_editable as install_editable_legacy,
+)
+from pip._internal.operations.install.wheel import install_wheel
+from pip._internal.pyproject import load_pyproject_toml, make_pyproject_path
+from pip._internal.req.req_uninstall import UninstallPathSet
+from pip._internal.utils.deprecation import deprecated
+from pip._internal.utils.hashes import Hashes
+from pip._internal.utils.misc import (
+    ConfiguredBuildBackendHookCaller,
+    ask_path_exists,
+    backup_dir,
+    display_path,
+    hide_url,
+    is_installable_dir,
+    redact_auth_from_requirement,
+    redact_auth_from_url,
+)
+from pip._internal.utils.packaging import get_requirement
+from pip._internal.utils.subprocess import runner_with_spinner_message
+from pip._internal.utils.temp_dir import TempDirectory, tempdir_kinds
+from pip._internal.utils.unpacking import unpack_file
+from pip._internal.utils.virtualenv import running_under_virtualenv
+from pip._internal.vcs import vcs
+
+logger = logging.getLogger(__name__)
+
+
+class InstallRequirement:
+    """
+    Represents something that may be installed later on, may have information
+    about where to fetch the relevant requirement and also contains logic for
+    installing the said requirement.
+    """
+
+    def __init__(
+        self,
+        req: Optional[Requirement],
+        comes_from: Optional[Union[str, "InstallRequirement"]],
+        editable: bool = False,
+        link: Optional[Link] = None,
+        markers: Optional[Marker] = None,
+        use_pep517: Optional[bool] = None,
+        isolated: bool = False,
+        *,
+        global_options: Optional[List[str]] = None,
+        hash_options: Optional[Dict[str, List[str]]] = None,
+        config_settings: Optional[Dict[str, Union[str, List[str]]]] = None,
+        constraint: bool = False,
+        extras: Collection[str] = (),
+        user_supplied: bool = False,
+        permit_editable_wheels: bool = False,
+    ) -> None:
+        assert req is None or isinstance(req, Requirement), req
+        self.req = req
+        self.comes_from = comes_from
+        self.constraint = constraint
+        self.editable = editable
+        self.permit_editable_wheels = permit_editable_wheels
+
+        # source_dir is the local directory where the linked requirement is
+        # located, or unpacked. In case unpacking is needed, creating and
+        # populating source_dir is done by the RequirementPreparer. Note this
+        # is not necessarily the directory where pyproject.toml or setup.py is
+        # located - that one is obtained via unpacked_source_directory.
+        self.source_dir: Optional[str] = None
+        if self.editable:
+            assert link
+            if link.is_file:
+                self.source_dir = os.path.normpath(os.path.abspath(link.file_path))
+
+        # original_link is the direct URL that was provided by the user for the
+        # requirement, either directly or via a constraints file.
+        if link is None and req and req.url:
+            # PEP 508 URL requirement
+            link = Link(req.url)
+        self.link = self.original_link = link
+
+        # When this InstallRequirement is a wheel obtained from the cache of locally
+        # built wheels, this is the source link corresponding to the cache entry, which
+        # was used to download and build the cached wheel.
+        self.cached_wheel_source_link: Optional[Link] = None
+
+        # Information about the location of the artifact that was downloaded . This
+        # property is guaranteed to be set in resolver results.
+        self.download_info: Optional[DirectUrl] = None
+
+        # Path to any downloaded or already-existing package.
+        self.local_file_path: Optional[str] = None
+        if self.link and self.link.is_file:
+            self.local_file_path = self.link.file_path
+
+        if extras:
+            self.extras = extras
+        elif req:
+            self.extras = req.extras
+        else:
+            self.extras = set()
+        if markers is None and req:
+            markers = req.marker
+        self.markers = markers
+
+        # This holds the Distribution object if this requirement is already installed.
+        self.satisfied_by: Optional[BaseDistribution] = None
+        # Whether the installation process should try to uninstall an existing
+        # distribution before installing this requirement.
+        self.should_reinstall = False
+        # Temporary build location
+        self._temp_build_dir: Optional[TempDirectory] = None
+        # Set to True after successful installation
+        self.install_succeeded: Optional[bool] = None
+        # Supplied options
+        self.global_options = global_options if global_options else []
+        self.hash_options = hash_options if hash_options else {}
+        self.config_settings = config_settings
+        # Set to True after successful preparation of this requirement
+        self.prepared = False
+        # User supplied requirement are explicitly requested for installation
+        # by the user via CLI arguments or requirements files, as opposed to,
+        # e.g. dependencies, extras or constraints.
+        self.user_supplied = user_supplied
+
+        self.isolated = isolated
+        self.build_env: BuildEnvironment = NoOpBuildEnvironment()
+
+        # For PEP 517, the directory where we request the project metadata
+        # gets stored. We need this to pass to build_wheel, so the backend
+        # can ensure that the wheel matches the metadata (see the PEP for
+        # details).
+        self.metadata_directory: Optional[str] = None
+
+        # The static build requirements (from pyproject.toml)
+        self.pyproject_requires: Optional[List[str]] = None
+
+        # Build requirements that we will check are available
+        self.requirements_to_check: List[str] = []
+
+        # The PEP 517 backend we should use to build the project
+        self.pep517_backend: Optional[BuildBackendHookCaller] = None
+
+        # Are we using PEP 517 for this requirement?
+        # After pyproject.toml has been loaded, the only valid values are True
+        # and False. Before loading, None is valid (meaning "use the default").
+        # Setting an explicit value before loading pyproject.toml is supported,
+        # but after loading this flag should be treated as read only.
+        self.use_pep517 = use_pep517
+
+        # If config settings are provided, enforce PEP 517.
+        if self.config_settings:
+            if self.use_pep517 is False:
+                logger.warning(
+                    "--no-use-pep517 ignored for %s "
+                    "because --config-settings are specified.",
+                    self,
+                )
+            self.use_pep517 = True
+
+        # This requirement needs more preparation before it can be built
+        self.needs_more_preparation = False
+
+        # This requirement needs to be unpacked before it can be installed.
+        self._archive_source: Optional[Path] = None
+
+    def __str__(self) -> str:
+        if self.req:
+            s = redact_auth_from_requirement(self.req)
+            if self.link:
+                s += f" from {redact_auth_from_url(self.link.url)}"
+        elif self.link:
+            s = redact_auth_from_url(self.link.url)
+        else:
+            s = ""
+        if self.satisfied_by is not None:
+            if self.satisfied_by.location is not None:
+                location = display_path(self.satisfied_by.location)
+            else:
+                location = ""
+            s += f" in {location}"
+        if self.comes_from:
+            if isinstance(self.comes_from, str):
+                comes_from: Optional[str] = self.comes_from
+            else:
+                comes_from = self.comes_from.from_path()
+            if comes_from:
+                s += f" (from {comes_from})"
+        return s
+
+    def __repr__(self) -> str:
+        return (
+            f"<{self.__class__.__name__} object: "
+            f"{str(self)} editable={self.editable!r}>"
+        )
+
+    def format_debug(self) -> str:
+        """An un-tested helper for getting state, for debugging."""
+        attributes = vars(self)
+        names = sorted(attributes)
+
+        state = (f"{attr}={attributes[attr]!r}" for attr in sorted(names))
+        return "<{name} object: {{{state}}}>".format(
+            name=self.__class__.__name__,
+            state=", ".join(state),
+        )
+
+    # Things that are valid for all kinds of requirements?
+    @property
+    def name(self) -> Optional[str]:
+        if self.req is None:
+            return None
+        return self.req.name
+
+    @functools.cached_property
+    def supports_pyproject_editable(self) -> bool:
+        if not self.use_pep517:
+            return False
+        assert self.pep517_backend
+        with self.build_env:
+            runner = runner_with_spinner_message(
+                "Checking if build backend supports build_editable"
+            )
+            with self.pep517_backend.subprocess_runner(runner):
+                return "build_editable" in self.pep517_backend._supported_features()
+
+    @property
+    def specifier(self) -> SpecifierSet:
+        assert self.req is not None
+        return self.req.specifier
+
+    @property
+    def is_direct(self) -> bool:
+        """Whether this requirement was specified as a direct URL."""
+        return self.original_link is not None
+
+    @property
+    def is_pinned(self) -> bool:
+        """Return whether I am pinned to an exact version.
+
+        For example, some-package==1.2 is pinned; some-package>1.2 is not.
+        """
+        assert self.req is not None
+        specifiers = self.req.specifier
+        return len(specifiers) == 1 and next(iter(specifiers)).operator in {"==", "==="}
+
+    def match_markers(self, extras_requested: Optional[Iterable[str]] = None) -> bool:
+        if not extras_requested:
+            # Provide an extra to safely evaluate the markers
+            # without matching any extra
+            extras_requested = ("",)
+        if self.markers is not None:
+            return any(
+                self.markers.evaluate({"extra": extra}) for extra in extras_requested
+            )
+        else:
+            return True
+
+    @property
+    def has_hash_options(self) -> bool:
+        """Return whether any known-good hashes are specified as options.
+
+        These activate --require-hashes mode; hashes specified as part of a
+        URL do not.
+
+        """
+        return bool(self.hash_options)
+
+    def hashes(self, trust_internet: bool = True) -> Hashes:
+        """Return a hash-comparer that considers my option- and URL-based
+        hashes to be known-good.
+
+        Hashes in URLs--ones embedded in the requirements file, not ones
+        downloaded from an index server--are almost peers with ones from
+        flags. They satisfy --require-hashes (whether it was implicitly or
+        explicitly activated) but do not activate it. md5 and sha224 are not
+        allowed in flags, which should nudge people toward good algos. We
+        always OR all hashes together, even ones from URLs.
+
+        :param trust_internet: Whether to trust URL-based (#md5=...) hashes
+            downloaded from the internet, as by populate_link()
+
+        """
+        good_hashes = self.hash_options.copy()
+        if trust_internet:
+            link = self.link
+        elif self.is_direct and self.user_supplied:
+            link = self.original_link
+        else:
+            link = None
+        if link and link.hash:
+            assert link.hash_name is not None
+            good_hashes.setdefault(link.hash_name, []).append(link.hash)
+        return Hashes(good_hashes)
+
+    def from_path(self) -> Optional[str]:
+        """Format a nice indicator to show where this "comes from" """
+        if self.req is None:
+            return None
+        s = str(self.req)
+        if self.comes_from:
+            comes_from: Optional[str]
+            if isinstance(self.comes_from, str):
+                comes_from = self.comes_from
+            else:
+                comes_from = self.comes_from.from_path()
+            if comes_from:
+                s += "->" + comes_from
+        return s
+
+    def ensure_build_location(
+        self, build_dir: str, autodelete: bool, parallel_builds: bool
+    ) -> str:
+        assert build_dir is not None
+        if self._temp_build_dir is not None:
+            assert self._temp_build_dir.path
+            return self._temp_build_dir.path
+        if self.req is None:
+            # Some systems have /tmp as a symlink which confuses custom
+            # builds (such as numpy). Thus, we ensure that the real path
+            # is returned.
+            self._temp_build_dir = TempDirectory(
+                kind=tempdir_kinds.REQ_BUILD, globally_managed=True
+            )
+
+            return self._temp_build_dir.path
+
+        # This is the only remaining place where we manually determine the path
+        # for the temporary directory. It is only needed for editables where
+        # it is the value of the --src option.
+
+        # When parallel builds are enabled, add a UUID to the build directory
+        # name so multiple builds do not interfere with each other.
+        dir_name: str = canonicalize_name(self.req.name)
+        if parallel_builds:
+            dir_name = f"{dir_name}_{uuid.uuid4().hex}"
+
+        # FIXME: Is there a better place to create the build_dir? (hg and bzr
+        # need this)
+        if not os.path.exists(build_dir):
+            logger.debug("Creating directory %s", build_dir)
+            os.makedirs(build_dir)
+        actual_build_dir = os.path.join(build_dir, dir_name)
+        # `None` indicates that we respect the globally-configured deletion
+        # settings, which is what we actually want when auto-deleting.
+        delete_arg = None if autodelete else False
+        return TempDirectory(
+            path=actual_build_dir,
+            delete=delete_arg,
+            kind=tempdir_kinds.REQ_BUILD,
+            globally_managed=True,
+        ).path
+
+    def _set_requirement(self) -> None:
+        """Set requirement after generating metadata."""
+        assert self.req is None
+        assert self.metadata is not None
+        assert self.source_dir is not None
+
+        # Construct a Requirement object from the generated metadata
+        if isinstance(parse_version(self.metadata["Version"]), Version):
+            op = "=="
+        else:
+            op = "==="
+
+        self.req = get_requirement(
+            "".join(
+                [
+                    self.metadata["Name"],
+                    op,
+                    self.metadata["Version"],
+                ]
+            )
+        )
+
+    def warn_on_mismatching_name(self) -> None:
+        assert self.req is not None
+        metadata_name = canonicalize_name(self.metadata["Name"])
+        if canonicalize_name(self.req.name) == metadata_name:
+            # Everything is fine.
+            return
+
+        # If we're here, there's a mismatch. Log a warning about it.
+        logger.warning(
+            "Generating metadata for package %s "
+            "produced metadata for project name %s. Fix your "
+            "#egg=%s fragments.",
+            self.name,
+            metadata_name,
+            self.name,
+        )
+        self.req = get_requirement(metadata_name)
+
+    def check_if_exists(self, use_user_site: bool) -> None:
+        """Find an installed distribution that satisfies or conflicts
+        with this requirement, and set self.satisfied_by or
+        self.should_reinstall appropriately.
+        """
+        if self.req is None:
+            return
+        existing_dist = get_default_environment().get_distribution(self.req.name)
+        if not existing_dist:
+            return
+
+        version_compatible = self.req.specifier.contains(
+            existing_dist.version,
+            prereleases=True,
+        )
+        if not version_compatible:
+            self.satisfied_by = None
+            if use_user_site:
+                if existing_dist.in_usersite:
+                    self.should_reinstall = True
+                elif running_under_virtualenv() and existing_dist.in_site_packages:
+                    raise InstallationError(
+                        f"Will not install to the user site because it will "
+                        f"lack sys.path precedence to {existing_dist.raw_name} "
+                        f"in {existing_dist.location}"
+                    )
+            else:
+                self.should_reinstall = True
+        else:
+            if self.editable:
+                self.should_reinstall = True
+                # when installing editables, nothing pre-existing should ever
+                # satisfy
+                self.satisfied_by = None
+            else:
+                self.satisfied_by = existing_dist
+
+    # Things valid for wheels
+    @property
+    def is_wheel(self) -> bool:
+        if not self.link:
+            return False
+        return self.link.is_wheel
+
+    @property
+    def is_wheel_from_cache(self) -> bool:
+        # When True, it means that this InstallRequirement is a local wheel file in the
+        # cache of locally built wheels.
+        return self.cached_wheel_source_link is not None
+
+    # Things valid for sdists
+    @property
+    def unpacked_source_directory(self) -> str:
+        assert self.source_dir, f"No source dir for {self}"
+        return os.path.join(
+            self.source_dir, self.link and self.link.subdirectory_fragment or ""
+        )
+
+    @property
+    def setup_py_path(self) -> str:
+        assert self.source_dir, f"No source dir for {self}"
+        setup_py = os.path.join(self.unpacked_source_directory, "setup.py")
+
+        return setup_py
+
+    @property
+    def setup_cfg_path(self) -> str:
+        assert self.source_dir, f"No source dir for {self}"
+        setup_cfg = os.path.join(self.unpacked_source_directory, "setup.cfg")
+
+        return setup_cfg
+
+    @property
+    def pyproject_toml_path(self) -> str:
+        assert self.source_dir, f"No source dir for {self}"
+        return make_pyproject_path(self.unpacked_source_directory)
+
+    def load_pyproject_toml(self) -> None:
+        """Load the pyproject.toml file.
+
+        After calling this routine, all of the attributes related to PEP 517
+        processing for this requirement have been set. In particular, the
+        use_pep517 attribute can be used to determine whether we should
+        follow the PEP 517 or legacy (setup.py) code path.
+        """
+        pyproject_toml_data = load_pyproject_toml(
+            self.use_pep517, self.pyproject_toml_path, self.setup_py_path, str(self)
+        )
+
+        if pyproject_toml_data is None:
+            assert not self.config_settings
+            self.use_pep517 = False
+            return
+
+        self.use_pep517 = True
+        requires, backend, check, backend_path = pyproject_toml_data
+        self.requirements_to_check = check
+        self.pyproject_requires = requires
+        self.pep517_backend = ConfiguredBuildBackendHookCaller(
+            self,
+            self.unpacked_source_directory,
+            backend,
+            backend_path=backend_path,
+        )
+
+    def isolated_editable_sanity_check(self) -> None:
+        """Check that an editable requirement if valid for use with PEP 517/518.
+
+        This verifies that an editable that has a pyproject.toml either supports PEP 660
+        or as a setup.py or a setup.cfg
+        """
+        if (
+            self.editable
+            and self.use_pep517
+            and not self.supports_pyproject_editable
+            and not os.path.isfile(self.setup_py_path)
+            and not os.path.isfile(self.setup_cfg_path)
+        ):
+            raise InstallationError(
+                f"Project {self} has a 'pyproject.toml' and its build "
+                f"backend is missing the 'build_editable' hook. Since it does not "
+                f"have a 'setup.py' nor a 'setup.cfg', "
+                f"it cannot be installed in editable mode. "
+                f"Consider using a build backend that supports PEP 660."
+            )
+
+    def prepare_metadata(self) -> None:
+        """Ensure that project metadata is available.
+
+        Under PEP 517 and PEP 660, call the backend hook to prepare the metadata.
+        Under legacy processing, call setup.py egg-info.
+        """
+        assert self.source_dir, f"No source dir for {self}"
+        details = self.name or f"from {self.link}"
+
+        if self.use_pep517:
+            assert self.pep517_backend is not None
+            if (
+                self.editable
+                and self.permit_editable_wheels
+                and self.supports_pyproject_editable
+            ):
+                self.metadata_directory = generate_editable_metadata(
+                    build_env=self.build_env,
+                    backend=self.pep517_backend,
+                    details=details,
+                )
+            else:
+                self.metadata_directory = generate_metadata(
+                    build_env=self.build_env,
+                    backend=self.pep517_backend,
+                    details=details,
+                )
+        else:
+            self.metadata_directory = generate_metadata_legacy(
+                build_env=self.build_env,
+                setup_py_path=self.setup_py_path,
+                source_dir=self.unpacked_source_directory,
+                isolated=self.isolated,
+                details=details,
+            )
+
+        # Act on the newly generated metadata, based on the name and version.
+        if not self.name:
+            self._set_requirement()
+        else:
+            self.warn_on_mismatching_name()
+
+        self.assert_source_matches_version()
+
+    @property
+    def metadata(self) -> Any:
+        if not hasattr(self, "_metadata"):
+            self._metadata = self.get_dist().metadata
+
+        return self._metadata
+
+    def get_dist(self) -> BaseDistribution:
+        if self.metadata_directory:
+            return get_directory_distribution(self.metadata_directory)
+        elif self.local_file_path and self.is_wheel:
+            assert self.req is not None
+            return get_wheel_distribution(
+                FilesystemWheel(self.local_file_path),
+                canonicalize_name(self.req.name),
+            )
+        raise AssertionError(
+            f"InstallRequirement {self} has no metadata directory and no wheel: "
+            f"can't make a distribution."
+        )
+
+    def assert_source_matches_version(self) -> None:
+        assert self.source_dir, f"No source dir for {self}"
+        version = self.metadata["version"]
+        if self.req and self.req.specifier and version not in self.req.specifier:
+            logger.warning(
+                "Requested %s, but installing version %s",
+                self,
+                version,
+            )
+        else:
+            logger.debug(
+                "Source in %s has version %s, which satisfies requirement %s",
+                display_path(self.source_dir),
+                version,
+                self,
+            )
+
+    # For both source distributions and editables
+    def ensure_has_source_dir(
+        self,
+        parent_dir: str,
+        autodelete: bool = False,
+        parallel_builds: bool = False,
+    ) -> None:
+        """Ensure that a source_dir is set.
+
+        This will create a temporary build dir if the name of the requirement
+        isn't known yet.
+
+        :param parent_dir: The ideal pip parent_dir for the source_dir.
+            Generally src_dir for editables and build_dir for sdists.
+        :return: self.source_dir
+        """
+        if self.source_dir is None:
+            self.source_dir = self.ensure_build_location(
+                parent_dir,
+                autodelete=autodelete,
+                parallel_builds=parallel_builds,
+            )
+
+    def needs_unpacked_archive(self, archive_source: Path) -> None:
+        assert self._archive_source is None
+        self._archive_source = archive_source
+
+    def ensure_pristine_source_checkout(self) -> None:
+        """Ensure the source directory has not yet been built in."""
+        assert self.source_dir is not None
+        if self._archive_source is not None:
+            unpack_file(str(self._archive_source), self.source_dir)
+        elif is_installable_dir(self.source_dir):
+            # If a checkout exists, it's unwise to keep going.
+            # version inconsistencies are logged later, but do not fail
+            # the installation.
+            raise PreviousBuildDirError(
+                f"pip can't proceed with requirements '{self}' due to a "
+                f"pre-existing build directory ({self.source_dir}). This is likely "
+                "due to a previous installation that failed . pip is "
+                "being responsible and not assuming it can delete this. "
+                "Please delete it and try again."
+            )
+
+    # For editable installations
+    def update_editable(self) -> None:
+        if not self.link:
+            logger.debug(
+                "Cannot update repository at %s; repository location is unknown",
+                self.source_dir,
+            )
+            return
+        assert self.editable
+        assert self.source_dir
+        if self.link.scheme == "file":
+            # Static paths don't get updated
+            return
+        vcs_backend = vcs.get_backend_for_scheme(self.link.scheme)
+        # Editable requirements are validated in Requirement constructors.
+        # So here, if it's neither a path nor a valid VCS URL, it's a bug.
+        assert vcs_backend, f"Unsupported VCS URL {self.link.url}"
+        hidden_url = hide_url(self.link.url)
+        vcs_backend.obtain(self.source_dir, url=hidden_url, verbosity=0)
+
+    # Top-level Actions
+    def uninstall(
+        self, auto_confirm: bool = False, verbose: bool = False
+    ) -> Optional[UninstallPathSet]:
+        """
+        Uninstall the distribution currently satisfying this requirement.
+
+        Prompts before removing or modifying files unless
+        ``auto_confirm`` is True.
+
+        Refuses to delete or modify files outside of ``sys.prefix`` -
+        thus uninstallation within a virtual environment can only
+        modify that virtual environment, even if the virtualenv is
+        linked to global site-packages.
+
+        """
+        assert self.req
+        dist = get_default_environment().get_distribution(self.req.name)
+        if not dist:
+            logger.warning("Skipping %s as it is not installed.", self.name)
+            return None
+        logger.info("Found existing installation: %s", dist)
+
+        uninstalled_pathset = UninstallPathSet.from_dist(dist)
+        uninstalled_pathset.remove(auto_confirm, verbose)
+        return uninstalled_pathset
+
+    def _get_archive_name(self, path: str, parentdir: str, rootdir: str) -> str:
+        def _clean_zip_name(name: str, prefix: str) -> str:
+            assert name.startswith(
+                prefix + os.path.sep
+            ), f"name {name!r} doesn't start with prefix {prefix!r}"
+            name = name[len(prefix) + 1 :]
+            name = name.replace(os.path.sep, "/")
+            return name
+
+        assert self.req is not None
+        path = os.path.join(parentdir, path)
+        name = _clean_zip_name(path, rootdir)
+        return self.req.name + "/" + name
+
+    def archive(self, build_dir: Optional[str]) -> None:
+        """Saves archive to provided build_dir.
+
+        Used for saving downloaded VCS requirements as part of `pip download`.
+        """
+        assert self.source_dir
+        if build_dir is None:
+            return
+
+        create_archive = True
+        archive_name = "{}-{}.zip".format(self.name, self.metadata["version"])
+        archive_path = os.path.join(build_dir, archive_name)
+
+        if os.path.exists(archive_path):
+            response = ask_path_exists(
+                f"The file {display_path(archive_path)} exists. (i)gnore, (w)ipe, "
+                "(b)ackup, (a)bort ",
+                ("i", "w", "b", "a"),
+            )
+            if response == "i":
+                create_archive = False
+            elif response == "w":
+                logger.warning("Deleting %s", display_path(archive_path))
+                os.remove(archive_path)
+            elif response == "b":
+                dest_file = backup_dir(archive_path)
+                logger.warning(
+                    "Backing up %s to %s",
+                    display_path(archive_path),
+                    display_path(dest_file),
+                )
+                shutil.move(archive_path, dest_file)
+            elif response == "a":
+                sys.exit(-1)
+
+        if not create_archive:
+            return
+
+        zip_output = zipfile.ZipFile(
+            archive_path,
+            "w",
+            zipfile.ZIP_DEFLATED,
+            allowZip64=True,
+        )
+        with zip_output:
+            dir = os.path.normcase(os.path.abspath(self.unpacked_source_directory))
+            for dirpath, dirnames, filenames in os.walk(dir):
+                for dirname in dirnames:
+                    dir_arcname = self._get_archive_name(
+                        dirname,
+                        parentdir=dirpath,
+                        rootdir=dir,
+                    )
+                    zipdir = zipfile.ZipInfo(dir_arcname + "/")
+                    zipdir.external_attr = 0x1ED << 16  # 0o755
+                    zip_output.writestr(zipdir, "")
+                for filename in filenames:
+                    file_arcname = self._get_archive_name(
+                        filename,
+                        parentdir=dirpath,
+                        rootdir=dir,
+                    )
+                    filename = os.path.join(dirpath, filename)
+                    zip_output.write(filename, file_arcname)
+
+        logger.info("Saved %s", display_path(archive_path))
+
+    def install(
+        self,
+        global_options: Optional[Sequence[str]] = None,
+        root: Optional[str] = None,
+        home: Optional[str] = None,
+        prefix: Optional[str] = None,
+        warn_script_location: bool = True,
+        use_user_site: bool = False,
+        pycompile: bool = True,
+    ) -> None:
+        assert self.req is not None
+        scheme = get_scheme(
+            self.req.name,
+            user=use_user_site,
+            home=home,
+            root=root,
+            isolated=self.isolated,
+            prefix=prefix,
+        )
+
+        if self.editable and not self.is_wheel:
+            deprecated(
+                reason=(
+                    f"Legacy editable install of {self} (setup.py develop) "
+                    "is deprecated."
+                ),
+                replacement=(
+                    "to add a pyproject.toml or enable --use-pep517, "
+                    "and use setuptools >= 64. "
+                    "If the resulting installation is not behaving as expected, "
+                    "try using --config-settings editable_mode=compat. "
+                    "Please consult the setuptools documentation for more information"
+                ),
+                gone_in="25.0",
+                issue=11457,
+            )
+            if self.config_settings:
+                logger.warning(
+                    "--config-settings ignored for legacy editable install of %s. "
+                    "Consider upgrading to a version of setuptools "
+                    "that supports PEP 660 (>= 64).",
+                    self,
+                )
+            install_editable_legacy(
+                global_options=global_options if global_options is not None else [],
+                prefix=prefix,
+                home=home,
+                use_user_site=use_user_site,
+                name=self.req.name,
+                setup_py_path=self.setup_py_path,
+                isolated=self.isolated,
+                build_env=self.build_env,
+                unpacked_source_directory=self.unpacked_source_directory,
+            )
+            self.install_succeeded = True
+            return
+
+        assert self.is_wheel
+        assert self.local_file_path
+
+        install_wheel(
+            self.req.name,
+            self.local_file_path,
+            scheme=scheme,
+            req_description=str(self.req),
+            pycompile=pycompile,
+            warn_script_location=warn_script_location,
+            direct_url=self.download_info if self.is_direct else None,
+            requested=self.user_supplied,
+        )
+        self.install_succeeded = True
+
+
+def check_invalid_constraint_type(req: InstallRequirement) -> str:
+    # Check for unsupported forms
+    problem = ""
+    if not req.name:
+        problem = "Unnamed requirements are not allowed as constraints"
+    elif req.editable:
+        problem = "Editable requirements are not allowed as constraints"
+    elif req.extras:
+        problem = "Constraints cannot have extras"
+
+    if problem:
+        deprecated(
+            reason=(
+                "Constraints are only allowed to take the form of a package "
+                "name and a version specifier. Other forms were originally "
+                "permitted as an accident of the implementation, but were "
+                "undocumented. The new implementation of the resolver no "
+                "longer supports these forms."
+            ),
+            replacement="replacing the constraint with a requirement",
+            # No plan yet for when the new resolver becomes default
+            gone_in=None,
+            issue=8210,
+        )
+
+    return problem
+
+
+def _has_option(options: Values, reqs: List[InstallRequirement], option: str) -> bool:
+    if getattr(options, option, None):
+        return True
+    for req in reqs:
+        if getattr(req, option, None):
+            return True
+    return False
+
+
+def check_legacy_setup_py_options(
+    options: Values,
+    reqs: List[InstallRequirement],
+) -> None:
+    has_build_options = _has_option(options, reqs, "build_options")
+    has_global_options = _has_option(options, reqs, "global_options")
+    if has_build_options or has_global_options:
+        deprecated(
+            reason="--build-option and --global-option are deprecated.",
+            issue=11859,
+            replacement="to use --config-settings",
+            gone_in="25.0",
+        )
+        logger.warning(
+            "Implying --no-binary=:all: due to the presence of "
+            "--build-option / --global-option. "
+        )
+        options.format_control.disallow_binaries()
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/req/req_set.py b/venv/lib/python3.12/site-packages/pip/_internal/req/req_set.py
new file mode 100644
index 00000000..ec7a6e07
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/req/req_set.py
@@ -0,0 +1,82 @@
+import logging
+from collections import OrderedDict
+from typing import Dict, List
+
+from pip._vendor.packaging.utils import canonicalize_name
+
+from pip._internal.req.req_install import InstallRequirement
+
+logger = logging.getLogger(__name__)
+
+
+class RequirementSet:
+    def __init__(self, check_supported_wheels: bool = True) -> None:
+        """Create a RequirementSet."""
+
+        self.requirements: Dict[str, InstallRequirement] = OrderedDict()
+        self.check_supported_wheels = check_supported_wheels
+
+        self.unnamed_requirements: List[InstallRequirement] = []
+
+    def __str__(self) -> str:
+        requirements = sorted(
+            (req for req in self.requirements.values() if not req.comes_from),
+            key=lambda req: canonicalize_name(req.name or ""),
+        )
+        return " ".join(str(req.req) for req in requirements)
+
+    def __repr__(self) -> str:
+        requirements = sorted(
+            self.requirements.values(),
+            key=lambda req: canonicalize_name(req.name or ""),
+        )
+
+        format_string = "<{classname} object; {count} requirement(s): {reqs}>"
+        return format_string.format(
+            classname=self.__class__.__name__,
+            count=len(requirements),
+            reqs=", ".join(str(req.req) for req in requirements),
+        )
+
+    def add_unnamed_requirement(self, install_req: InstallRequirement) -> None:
+        assert not install_req.name
+        self.unnamed_requirements.append(install_req)
+
+    def add_named_requirement(self, install_req: InstallRequirement) -> None:
+        assert install_req.name
+
+        project_name = canonicalize_name(install_req.name)
+        self.requirements[project_name] = install_req
+
+    def has_requirement(self, name: str) -> bool:
+        project_name = canonicalize_name(name)
+
+        return (
+            project_name in self.requirements
+            and not self.requirements[project_name].constraint
+        )
+
+    def get_requirement(self, name: str) -> InstallRequirement:
+        project_name = canonicalize_name(name)
+
+        if project_name in self.requirements:
+            return self.requirements[project_name]
+
+        raise KeyError(f"No project with the name {name!r}")
+
+    @property
+    def all_requirements(self) -> List[InstallRequirement]:
+        return self.unnamed_requirements + list(self.requirements.values())
+
+    @property
+    def requirements_to_install(self) -> List[InstallRequirement]:
+        """Return the list of requirements that need to be installed.
+
+        TODO remove this property together with the legacy resolver, since the new
+             resolver only returns requirements that need to be installed.
+        """
+        return [
+            install_req
+            for install_req in self.all_requirements
+            if not install_req.constraint and not install_req.satisfied_by
+        ]
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/req/req_uninstall.py b/venv/lib/python3.12/site-packages/pip/_internal/req/req_uninstall.py
new file mode 100644
index 00000000..26df2084
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/req/req_uninstall.py
@@ -0,0 +1,633 @@
+import functools
+import os
+import sys
+import sysconfig
+from importlib.util import cache_from_source
+from typing import Any, Callable, Dict, Generator, Iterable, List, Optional, Set, Tuple
+
+from pip._internal.exceptions import LegacyDistutilsInstall, UninstallMissingRecord
+from pip._internal.locations import get_bin_prefix, get_bin_user
+from pip._internal.metadata import BaseDistribution
+from pip._internal.utils.compat import WINDOWS
+from pip._internal.utils.egg_link import egg_link_path_from_location
+from pip._internal.utils.logging import getLogger, indent_log
+from pip._internal.utils.misc import ask, normalize_path, renames, rmtree
+from pip._internal.utils.temp_dir import AdjacentTempDirectory, TempDirectory
+from pip._internal.utils.virtualenv import running_under_virtualenv
+
+logger = getLogger(__name__)
+
+
+def _script_names(
+    bin_dir: str, script_name: str, is_gui: bool
+) -> Generator[str, None, None]:
+    """Create the fully qualified name of the files created by
+    {console,gui}_scripts for the given ``dist``.
+    Returns the list of file names
+    """
+    exe_name = os.path.join(bin_dir, script_name)
+    yield exe_name
+    if not WINDOWS:
+        return
+    yield f"{exe_name}.exe"
+    yield f"{exe_name}.exe.manifest"
+    if is_gui:
+        yield f"{exe_name}-script.pyw"
+    else:
+        yield f"{exe_name}-script.py"
+
+
+def _unique(
+    fn: Callable[..., Generator[Any, None, None]]
+) -> Callable[..., Generator[Any, None, None]]:
+    @functools.wraps(fn)
+    def unique(*args: Any, **kw: Any) -> Generator[Any, None, None]:
+        seen: Set[Any] = set()
+        for item in fn(*args, **kw):
+            if item not in seen:
+                seen.add(item)
+                yield item
+
+    return unique
+
+
+@_unique
+def uninstallation_paths(dist: BaseDistribution) -> Generator[str, None, None]:
+    """
+    Yield all the uninstallation paths for dist based on RECORD-without-.py[co]
+
+    Yield paths to all the files in RECORD. For each .py file in RECORD, add
+    the .pyc and .pyo in the same directory.
+
+    UninstallPathSet.add() takes care of the __pycache__ .py[co].
+
+    If RECORD is not found, raises an error,
+    with possible information from the INSTALLER file.
+
+    https://packaging.python.org/specifications/recording-installed-packages/
+    """
+    location = dist.location
+    assert location is not None, "not installed"
+
+    entries = dist.iter_declared_entries()
+    if entries is None:
+        raise UninstallMissingRecord(distribution=dist)
+
+    for entry in entries:
+        path = os.path.join(location, entry)
+        yield path
+        if path.endswith(".py"):
+            dn, fn = os.path.split(path)
+            base = fn[:-3]
+            path = os.path.join(dn, base + ".pyc")
+            yield path
+            path = os.path.join(dn, base + ".pyo")
+            yield path
+
+
+def compact(paths: Iterable[str]) -> Set[str]:
+    """Compact a path set to contain the minimal number of paths
+    necessary to contain all paths in the set. If /a/path/ and
+    /a/path/to/a/file.txt are both in the set, leave only the
+    shorter path."""
+
+    sep = os.path.sep
+    short_paths: Set[str] = set()
+    for path in sorted(paths, key=len):
+        should_skip = any(
+            path.startswith(shortpath.rstrip("*"))
+            and path[len(shortpath.rstrip("*").rstrip(sep))] == sep
+            for shortpath in short_paths
+        )
+        if not should_skip:
+            short_paths.add(path)
+    return short_paths
+
+
+def compress_for_rename(paths: Iterable[str]) -> Set[str]:
+    """Returns a set containing the paths that need to be renamed.
+
+    This set may include directories when the original sequence of paths
+    included every file on disk.
+    """
+    case_map = {os.path.normcase(p): p for p in paths}
+    remaining = set(case_map)
+    unchecked = sorted({os.path.split(p)[0] for p in case_map.values()}, key=len)
+    wildcards: Set[str] = set()
+
+    def norm_join(*a: str) -> str:
+        return os.path.normcase(os.path.join(*a))
+
+    for root in unchecked:
+        if any(os.path.normcase(root).startswith(w) for w in wildcards):
+            # This directory has already been handled.
+            continue
+
+        all_files: Set[str] = set()
+        all_subdirs: Set[str] = set()
+        for dirname, subdirs, files in os.walk(root):
+            all_subdirs.update(norm_join(root, dirname, d) for d in subdirs)
+            all_files.update(norm_join(root, dirname, f) for f in files)
+        # If all the files we found are in our remaining set of files to
+        # remove, then remove them from the latter set and add a wildcard
+        # for the directory.
+        if not (all_files - remaining):
+            remaining.difference_update(all_files)
+            wildcards.add(root + os.sep)
+
+    return set(map(case_map.__getitem__, remaining)) | wildcards
+
+
+def compress_for_output_listing(paths: Iterable[str]) -> Tuple[Set[str], Set[str]]:
+    """Returns a tuple of 2 sets of which paths to display to user
+
+    The first set contains paths that would be deleted. Files of a package
+    are not added and the top-level directory of the package has a '*' added
+    at the end - to signify that all it's contents are removed.
+
+    The second set contains files that would have been skipped in the above
+    folders.
+    """
+
+    will_remove = set(paths)
+    will_skip = set()
+
+    # Determine folders and files
+    folders = set()
+    files = set()
+    for path in will_remove:
+        if path.endswith(".pyc"):
+            continue
+        if path.endswith("__init__.py") or ".dist-info" in path:
+            folders.add(os.path.dirname(path))
+        files.add(path)
+
+    _normcased_files = set(map(os.path.normcase, files))
+
+    folders = compact(folders)
+
+    # This walks the tree using os.walk to not miss extra folders
+    # that might get added.
+    for folder in folders:
+        for dirpath, _, dirfiles in os.walk(folder):
+            for fname in dirfiles:
+                if fname.endswith(".pyc"):
+                    continue
+
+                file_ = os.path.join(dirpath, fname)
+                if (
+                    os.path.isfile(file_)
+                    and os.path.normcase(file_) not in _normcased_files
+                ):
+                    # We are skipping this file. Add it to the set.
+                    will_skip.add(file_)
+
+    will_remove = files | {os.path.join(folder, "*") for folder in folders}
+
+    return will_remove, will_skip
+
+
+class StashedUninstallPathSet:
+    """A set of file rename operations to stash files while
+    tentatively uninstalling them."""
+
+    def __init__(self) -> None:
+        # Mapping from source file root to [Adjacent]TempDirectory
+        # for files under that directory.
+        self._save_dirs: Dict[str, TempDirectory] = {}
+        # (old path, new path) tuples for each move that may need
+        # to be undone.
+        self._moves: List[Tuple[str, str]] = []
+
+    def _get_directory_stash(self, path: str) -> str:
+        """Stashes a directory.
+
+        Directories are stashed adjacent to their original location if
+        possible, or else moved/copied into the user's temp dir."""
+
+        try:
+            save_dir: TempDirectory = AdjacentTempDirectory(path)
+        except OSError:
+            save_dir = TempDirectory(kind="uninstall")
+        self._save_dirs[os.path.normcase(path)] = save_dir
+
+        return save_dir.path
+
+    def _get_file_stash(self, path: str) -> str:
+        """Stashes a file.
+
+        If no root has been provided, one will be created for the directory
+        in the user's temp directory."""
+        path = os.path.normcase(path)
+        head, old_head = os.path.dirname(path), None
+        save_dir = None
+
+        while head != old_head:
+            try:
+                save_dir = self._save_dirs[head]
+                break
+            except KeyError:
+                pass
+            head, old_head = os.path.dirname(head), head
+        else:
+            # Did not find any suitable root
+            head = os.path.dirname(path)
+            save_dir = TempDirectory(kind="uninstall")
+            self._save_dirs[head] = save_dir
+
+        relpath = os.path.relpath(path, head)
+        if relpath and relpath != os.path.curdir:
+            return os.path.join(save_dir.path, relpath)
+        return save_dir.path
+
+    def stash(self, path: str) -> str:
+        """Stashes the directory or file and returns its new location.
+        Handle symlinks as files to avoid modifying the symlink targets.
+        """
+        path_is_dir = os.path.isdir(path) and not os.path.islink(path)
+        if path_is_dir:
+            new_path = self._get_directory_stash(path)
+        else:
+            new_path = self._get_file_stash(path)
+
+        self._moves.append((path, new_path))
+        if path_is_dir and os.path.isdir(new_path):
+            # If we're moving a directory, we need to
+            # remove the destination first or else it will be
+            # moved to inside the existing directory.
+            # We just created new_path ourselves, so it will
+            # be removable.
+            os.rmdir(new_path)
+        renames(path, new_path)
+        return new_path
+
+    def commit(self) -> None:
+        """Commits the uninstall by removing stashed files."""
+        for save_dir in self._save_dirs.values():
+            save_dir.cleanup()
+        self._moves = []
+        self._save_dirs = {}
+
+    def rollback(self) -> None:
+        """Undoes the uninstall by moving stashed files back."""
+        for p in self._moves:
+            logger.info("Moving to %s\n from %s", *p)
+
+        for new_path, path in self._moves:
+            try:
+                logger.debug("Replacing %s from %s", new_path, path)
+                if os.path.isfile(new_path) or os.path.islink(new_path):
+                    os.unlink(new_path)
+                elif os.path.isdir(new_path):
+                    rmtree(new_path)
+                renames(path, new_path)
+            except OSError as ex:
+                logger.error("Failed to restore %s", new_path)
+                logger.debug("Exception: %s", ex)
+
+        self.commit()
+
+    @property
+    def can_rollback(self) -> bool:
+        return bool(self._moves)
+
+
+class UninstallPathSet:
+    """A set of file paths to be removed in the uninstallation of a
+    requirement."""
+
+    def __init__(self, dist: BaseDistribution) -> None:
+        self._paths: Set[str] = set()
+        self._refuse: Set[str] = set()
+        self._pth: Dict[str, UninstallPthEntries] = {}
+        self._dist = dist
+        self._moved_paths = StashedUninstallPathSet()
+        # Create local cache of normalize_path results. Creating an UninstallPathSet
+        # can result in hundreds/thousands of redundant calls to normalize_path with
+        # the same args, which hurts performance.
+        self._normalize_path_cached = functools.lru_cache(normalize_path)
+
+    def _permitted(self, path: str) -> bool:
+        """
+        Return True if the given path is one we are permitted to
+        remove/modify, False otherwise.
+
+        """
+        # aka is_local, but caching normalized sys.prefix
+        if not running_under_virtualenv():
+            return True
+        return path.startswith(self._normalize_path_cached(sys.prefix))
+
+    def add(self, path: str) -> None:
+        head, tail = os.path.split(path)
+
+        # we normalize the head to resolve parent directory symlinks, but not
+        # the tail, since we only want to uninstall symlinks, not their targets
+        path = os.path.join(self._normalize_path_cached(head), os.path.normcase(tail))
+
+        if not os.path.exists(path):
+            return
+        if self._permitted(path):
+            self._paths.add(path)
+        else:
+            self._refuse.add(path)
+
+        # __pycache__ files can show up after 'installed-files.txt' is created,
+        # due to imports
+        if os.path.splitext(path)[1] == ".py":
+            self.add(cache_from_source(path))
+
+    def add_pth(self, pth_file: str, entry: str) -> None:
+        pth_file = self._normalize_path_cached(pth_file)
+        if self._permitted(pth_file):
+            if pth_file not in self._pth:
+                self._pth[pth_file] = UninstallPthEntries(pth_file)
+            self._pth[pth_file].add(entry)
+        else:
+            self._refuse.add(pth_file)
+
+    def remove(self, auto_confirm: bool = False, verbose: bool = False) -> None:
+        """Remove paths in ``self._paths`` with confirmation (unless
+        ``auto_confirm`` is True)."""
+
+        if not self._paths:
+            logger.info(
+                "Can't uninstall '%s'. No files were found to uninstall.",
+                self._dist.raw_name,
+            )
+            return
+
+        dist_name_version = f"{self._dist.raw_name}-{self._dist.raw_version}"
+        logger.info("Uninstalling %s:", dist_name_version)
+
+        with indent_log():
+            if auto_confirm or self._allowed_to_proceed(verbose):
+                moved = self._moved_paths
+
+                for_rename = compress_for_rename(self._paths)
+
+                for path in sorted(compact(for_rename)):
+                    moved.stash(path)
+                    logger.verbose("Removing file or directory %s", path)
+
+                for pth in self._pth.values():
+                    pth.remove()
+
+                logger.info("Successfully uninstalled %s", dist_name_version)
+
+    def _allowed_to_proceed(self, verbose: bool) -> bool:
+        """Display which files would be deleted and prompt for confirmation"""
+
+        def _display(msg: str, paths: Iterable[str]) -> None:
+            if not paths:
+                return
+
+            logger.info(msg)
+            with indent_log():
+                for path in sorted(compact(paths)):
+                    logger.info(path)
+
+        if not verbose:
+            will_remove, will_skip = compress_for_output_listing(self._paths)
+        else:
+            # In verbose mode, display all the files that are going to be
+            # deleted.
+            will_remove = set(self._paths)
+            will_skip = set()
+
+        _display("Would remove:", will_remove)
+        _display("Would not remove (might be manually added):", will_skip)
+        _display("Would not remove (outside of prefix):", self._refuse)
+        if verbose:
+            _display("Will actually move:", compress_for_rename(self._paths))
+
+        return ask("Proceed (Y/n)? ", ("y", "n", "")) != "n"
+
+    def rollback(self) -> None:
+        """Rollback the changes previously made by remove()."""
+        if not self._moved_paths.can_rollback:
+            logger.error(
+                "Can't roll back %s; was not uninstalled",
+                self._dist.raw_name,
+            )
+            return
+        logger.info("Rolling back uninstall of %s", self._dist.raw_name)
+        self._moved_paths.rollback()
+        for pth in self._pth.values():
+            pth.rollback()
+
+    def commit(self) -> None:
+        """Remove temporary save dir: rollback will no longer be possible."""
+        self._moved_paths.commit()
+
+    @classmethod
+    def from_dist(cls, dist: BaseDistribution) -> "UninstallPathSet":
+        dist_location = dist.location
+        info_location = dist.info_location
+        if dist_location is None:
+            logger.info(
+                "Not uninstalling %s since it is not installed",
+                dist.canonical_name,
+            )
+            return cls(dist)
+
+        normalized_dist_location = normalize_path(dist_location)
+        if not dist.local:
+            logger.info(
+                "Not uninstalling %s at %s, outside environment %s",
+                dist.canonical_name,
+                normalized_dist_location,
+                sys.prefix,
+            )
+            return cls(dist)
+
+        if normalized_dist_location in {
+            p
+            for p in {sysconfig.get_path("stdlib"), sysconfig.get_path("platstdlib")}
+            if p
+        }:
+            logger.info(
+                "Not uninstalling %s at %s, as it is in the standard library.",
+                dist.canonical_name,
+                normalized_dist_location,
+            )
+            return cls(dist)
+
+        paths_to_remove = cls(dist)
+        develop_egg_link = egg_link_path_from_location(dist.raw_name)
+
+        # Distribution is installed with metadata in a "flat" .egg-info
+        # directory. This means it is not a modern .dist-info installation, an
+        # egg, or legacy editable.
+        setuptools_flat_installation = (
+            dist.installed_with_setuptools_egg_info
+            and info_location is not None
+            and os.path.exists(info_location)
+            # If dist is editable and the location points to a ``.egg-info``,
+            # we are in fact in the legacy editable case.
+            and not info_location.endswith(f"{dist.setuptools_filename}.egg-info")
+        )
+
+        # Uninstall cases order do matter as in the case of 2 installs of the
+        # same package, pip needs to uninstall the currently detected version
+        if setuptools_flat_installation:
+            if info_location is not None:
+                paths_to_remove.add(info_location)
+            installed_files = dist.iter_declared_entries()
+            if installed_files is not None:
+                for installed_file in installed_files:
+                    paths_to_remove.add(os.path.join(dist_location, installed_file))
+            # FIXME: need a test for this elif block
+            # occurs with --single-version-externally-managed/--record outside
+            # of pip
+            elif dist.is_file("top_level.txt"):
+                try:
+                    namespace_packages = dist.read_text("namespace_packages.txt")
+                except FileNotFoundError:
+                    namespaces = []
+                else:
+                    namespaces = namespace_packages.splitlines(keepends=False)
+                for top_level_pkg in [
+                    p
+                    for p in dist.read_text("top_level.txt").splitlines()
+                    if p and p not in namespaces
+                ]:
+                    path = os.path.join(dist_location, top_level_pkg)
+                    paths_to_remove.add(path)
+                    paths_to_remove.add(f"{path}.py")
+                    paths_to_remove.add(f"{path}.pyc")
+                    paths_to_remove.add(f"{path}.pyo")
+
+        elif dist.installed_by_distutils:
+            raise LegacyDistutilsInstall(distribution=dist)
+
+        elif dist.installed_as_egg:
+            # package installed by easy_install
+            # We cannot match on dist.egg_name because it can slightly vary
+            # i.e. setuptools-0.6c11-py2.6.egg vs setuptools-0.6rc11-py2.6.egg
+            paths_to_remove.add(dist_location)
+            easy_install_egg = os.path.split(dist_location)[1]
+            easy_install_pth = os.path.join(
+                os.path.dirname(dist_location),
+                "easy-install.pth",
+            )
+            paths_to_remove.add_pth(easy_install_pth, "./" + easy_install_egg)
+
+        elif dist.installed_with_dist_info:
+            for path in uninstallation_paths(dist):
+                paths_to_remove.add(path)
+
+        elif develop_egg_link:
+            # PEP 660 modern editable is handled in the ``.dist-info`` case
+            # above, so this only covers the setuptools-style editable.
+            with open(develop_egg_link) as fh:
+                link_pointer = os.path.normcase(fh.readline().strip())
+                normalized_link_pointer = paths_to_remove._normalize_path_cached(
+                    link_pointer
+                )
+            assert os.path.samefile(
+                normalized_link_pointer, normalized_dist_location
+            ), (
+                f"Egg-link {develop_egg_link} (to {link_pointer}) does not match "
+                f"installed location of {dist.raw_name} (at {dist_location})"
+            )
+            paths_to_remove.add(develop_egg_link)
+            easy_install_pth = os.path.join(
+                os.path.dirname(develop_egg_link), "easy-install.pth"
+            )
+            paths_to_remove.add_pth(easy_install_pth, dist_location)
+
+        else:
+            logger.debug(
+                "Not sure how to uninstall: %s - Check: %s",
+                dist,
+                dist_location,
+            )
+
+        if dist.in_usersite:
+            bin_dir = get_bin_user()
+        else:
+            bin_dir = get_bin_prefix()
+
+        # find distutils scripts= scripts
+        try:
+            for script in dist.iter_distutils_script_names():
+                paths_to_remove.add(os.path.join(bin_dir, script))
+                if WINDOWS:
+                    paths_to_remove.add(os.path.join(bin_dir, f"{script}.bat"))
+        except (FileNotFoundError, NotADirectoryError):
+            pass
+
+        # find console_scripts and gui_scripts
+        def iter_scripts_to_remove(
+            dist: BaseDistribution,
+            bin_dir: str,
+        ) -> Generator[str, None, None]:
+            for entry_point in dist.iter_entry_points():
+                if entry_point.group == "console_scripts":
+                    yield from _script_names(bin_dir, entry_point.name, False)
+                elif entry_point.group == "gui_scripts":
+                    yield from _script_names(bin_dir, entry_point.name, True)
+
+        for s in iter_scripts_to_remove(dist, bin_dir):
+            paths_to_remove.add(s)
+
+        return paths_to_remove
+
+
+class UninstallPthEntries:
+    def __init__(self, pth_file: str) -> None:
+        self.file = pth_file
+        self.entries: Set[str] = set()
+        self._saved_lines: Optional[List[bytes]] = None
+
+    def add(self, entry: str) -> None:
+        entry = os.path.normcase(entry)
+        # On Windows, os.path.normcase converts the entry to use
+        # backslashes.  This is correct for entries that describe absolute
+        # paths outside of site-packages, but all the others use forward
+        # slashes.
+        # os.path.splitdrive is used instead of os.path.isabs because isabs
+        # treats non-absolute paths with drive letter markings like c:foo\bar
+        # as absolute paths. It also does not recognize UNC paths if they don't
+        # have more than "\\sever\share". Valid examples: "\\server\share\" or
+        # "\\server\share\folder".
+        if WINDOWS and not os.path.splitdrive(entry)[0]:
+            entry = entry.replace("\\", "/")
+        self.entries.add(entry)
+
+    def remove(self) -> None:
+        logger.verbose("Removing pth entries from %s:", self.file)
+
+        # If the file doesn't exist, log a warning and return
+        if not os.path.isfile(self.file):
+            logger.warning("Cannot remove entries from nonexistent file %s", self.file)
+            return
+        with open(self.file, "rb") as fh:
+            # windows uses '\r\n' with py3k, but uses '\n' with py2.x
+            lines = fh.readlines()
+            self._saved_lines = lines
+        if any(b"\r\n" in line for line in lines):
+            endline = "\r\n"
+        else:
+            endline = "\n"
+        # handle missing trailing newline
+        if lines and not lines[-1].endswith(endline.encode("utf-8")):
+            lines[-1] = lines[-1] + endline.encode("utf-8")
+        for entry in self.entries:
+            try:
+                logger.verbose("Removing entry: %s", entry)
+                lines.remove((entry + endline).encode("utf-8"))
+            except ValueError:
+                pass
+        with open(self.file, "wb") as fh:
+            fh.writelines(lines)
+
+    def rollback(self) -> bool:
+        if self._saved_lines is None:
+            logger.error("Cannot roll back changes to %s, none were made", self.file)
+            return False
+        logger.debug("Rolling %s back to previous state", self.file)
+        with open(self.file, "wb") as fh:
+            fh.writelines(self._saved_lines)
+        return True
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/resolution/__init__.py b/venv/lib/python3.12/site-packages/pip/_internal/resolution/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/resolution/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/resolution/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 00000000..8b4ce2bd
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/resolution/__pycache__/__init__.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/resolution/__pycache__/base.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/resolution/__pycache__/base.cpython-312.pyc
new file mode 100644
index 00000000..335bdd28
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/resolution/__pycache__/base.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/resolution/base.py b/venv/lib/python3.12/site-packages/pip/_internal/resolution/base.py
new file mode 100644
index 00000000..42dade18
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/resolution/base.py
@@ -0,0 +1,20 @@
+from typing import Callable, List, Optional
+
+from pip._internal.req.req_install import InstallRequirement
+from pip._internal.req.req_set import RequirementSet
+
+InstallRequirementProvider = Callable[
+    [str, Optional[InstallRequirement]], InstallRequirement
+]
+
+
+class BaseResolver:
+    def resolve(
+        self, root_reqs: List[InstallRequirement], check_supported_wheels: bool
+    ) -> RequirementSet:
+        raise NotImplementedError()
+
+    def get_installation_order(
+        self, req_set: RequirementSet
+    ) -> List[InstallRequirement]:
+        raise NotImplementedError()
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/resolution/legacy/__init__.py b/venv/lib/python3.12/site-packages/pip/_internal/resolution/legacy/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/resolution/legacy/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/resolution/legacy/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 00000000..66f76b8d
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/resolution/legacy/__pycache__/__init__.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/resolution/legacy/__pycache__/resolver.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/resolution/legacy/__pycache__/resolver.cpython-312.pyc
new file mode 100644
index 00000000..9f0c70c0
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/resolution/legacy/__pycache__/resolver.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/resolution/legacy/resolver.py b/venv/lib/python3.12/site-packages/pip/_internal/resolution/legacy/resolver.py
new file mode 100644
index 00000000..1dd0d704
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/resolution/legacy/resolver.py
@@ -0,0 +1,597 @@
+"""Dependency Resolution
+
+The dependency resolution in pip is performed as follows:
+
+for top-level requirements:
+    a. only one spec allowed per project, regardless of conflicts or not.
+       otherwise a "double requirement" exception is raised
+    b. they override sub-dependency requirements.
+for sub-dependencies
+    a. "first found, wins" (where the order is breadth first)
+"""
+
+import logging
+import sys
+from collections import defaultdict
+from itertools import chain
+from typing import DefaultDict, Iterable, List, Optional, Set, Tuple
+
+from pip._vendor.packaging import specifiers
+from pip._vendor.packaging.requirements import Requirement
+
+from pip._internal.cache import WheelCache
+from pip._internal.exceptions import (
+    BestVersionAlreadyInstalled,
+    DistributionNotFound,
+    HashError,
+    HashErrors,
+    InstallationError,
+    NoneMetadataError,
+    UnsupportedPythonVersion,
+)
+from pip._internal.index.package_finder import PackageFinder
+from pip._internal.metadata import BaseDistribution
+from pip._internal.models.link import Link
+from pip._internal.models.wheel import Wheel
+from pip._internal.operations.prepare import RequirementPreparer
+from pip._internal.req.req_install import (
+    InstallRequirement,
+    check_invalid_constraint_type,
+)
+from pip._internal.req.req_set import RequirementSet
+from pip._internal.resolution.base import BaseResolver, InstallRequirementProvider
+from pip._internal.utils import compatibility_tags
+from pip._internal.utils.compatibility_tags import get_supported
+from pip._internal.utils.direct_url_helpers import direct_url_from_link
+from pip._internal.utils.logging import indent_log
+from pip._internal.utils.misc import normalize_version_info
+from pip._internal.utils.packaging import check_requires_python
+
+logger = logging.getLogger(__name__)
+
+DiscoveredDependencies = DefaultDict[Optional[str], List[InstallRequirement]]
+
+
+def _check_dist_requires_python(
+    dist: BaseDistribution,
+    version_info: Tuple[int, int, int],
+    ignore_requires_python: bool = False,
+) -> None:
+    """
+    Check whether the given Python version is compatible with a distribution's
+    "Requires-Python" value.
+
+    :param version_info: A 3-tuple of ints representing the Python
+        major-minor-micro version to check.
+    :param ignore_requires_python: Whether to ignore the "Requires-Python"
+        value if the given Python version isn't compatible.
+
+    :raises UnsupportedPythonVersion: When the given Python version isn't
+        compatible.
+    """
+    # This idiosyncratically converts the SpecifierSet to str and let
+    # check_requires_python then parse it again into SpecifierSet. But this
+    # is the legacy resolver so I'm just not going to bother refactoring.
+    try:
+        requires_python = str(dist.requires_python)
+    except FileNotFoundError as e:
+        raise NoneMetadataError(dist, str(e))
+    try:
+        is_compatible = check_requires_python(
+            requires_python,
+            version_info=version_info,
+        )
+    except specifiers.InvalidSpecifier as exc:
+        logger.warning(
+            "Package %r has an invalid Requires-Python: %s", dist.raw_name, exc
+        )
+        return
+
+    if is_compatible:
+        return
+
+    version = ".".join(map(str, version_info))
+    if ignore_requires_python:
+        logger.debug(
+            "Ignoring failed Requires-Python check for package %r: %s not in %r",
+            dist.raw_name,
+            version,
+            requires_python,
+        )
+        return
+
+    raise UnsupportedPythonVersion(
+        f"Package {dist.raw_name!r} requires a different Python: "
+        f"{version} not in {requires_python!r}"
+    )
+
+
+class Resolver(BaseResolver):
+    """Resolves which packages need to be installed/uninstalled to perform \
+    the requested operation without breaking the requirements of any package.
+    """
+
+    _allowed_strategies = {"eager", "only-if-needed", "to-satisfy-only"}
+
+    def __init__(
+        self,
+        preparer: RequirementPreparer,
+        finder: PackageFinder,
+        wheel_cache: Optional[WheelCache],
+        make_install_req: InstallRequirementProvider,
+        use_user_site: bool,
+        ignore_dependencies: bool,
+        ignore_installed: bool,
+        ignore_requires_python: bool,
+        force_reinstall: bool,
+        upgrade_strategy: str,
+        py_version_info: Optional[Tuple[int, ...]] = None,
+    ) -> None:
+        super().__init__()
+        assert upgrade_strategy in self._allowed_strategies
+
+        if py_version_info is None:
+            py_version_info = sys.version_info[:3]
+        else:
+            py_version_info = normalize_version_info(py_version_info)
+
+        self._py_version_info = py_version_info
+
+        self.preparer = preparer
+        self.finder = finder
+        self.wheel_cache = wheel_cache
+
+        self.upgrade_strategy = upgrade_strategy
+        self.force_reinstall = force_reinstall
+        self.ignore_dependencies = ignore_dependencies
+        self.ignore_installed = ignore_installed
+        self.ignore_requires_python = ignore_requires_python
+        self.use_user_site = use_user_site
+        self._make_install_req = make_install_req
+
+        self._discovered_dependencies: DiscoveredDependencies = defaultdict(list)
+
+    def resolve(
+        self, root_reqs: List[InstallRequirement], check_supported_wheels: bool
+    ) -> RequirementSet:
+        """Resolve what operations need to be done
+
+        As a side-effect of this method, the packages (and their dependencies)
+        are downloaded, unpacked and prepared for installation. This
+        preparation is done by ``pip.operations.prepare``.
+
+        Once PyPI has static dependency metadata available, it would be
+        possible to move the preparation to become a step separated from
+        dependency resolution.
+        """
+        requirement_set = RequirementSet(check_supported_wheels=check_supported_wheels)
+        for req in root_reqs:
+            if req.constraint:
+                check_invalid_constraint_type(req)
+            self._add_requirement_to_set(requirement_set, req)
+
+        # Actually prepare the files, and collect any exceptions. Most hash
+        # exceptions cannot be checked ahead of time, because
+        # _populate_link() needs to be called before we can make decisions
+        # based on link type.
+        discovered_reqs: List[InstallRequirement] = []
+        hash_errors = HashErrors()
+        for req in chain(requirement_set.all_requirements, discovered_reqs):
+            try:
+                discovered_reqs.extend(self._resolve_one(requirement_set, req))
+            except HashError as exc:
+                exc.req = req
+                hash_errors.append(exc)
+
+        if hash_errors:
+            raise hash_errors
+
+        return requirement_set
+
+    def _add_requirement_to_set(
+        self,
+        requirement_set: RequirementSet,
+        install_req: InstallRequirement,
+        parent_req_name: Optional[str] = None,
+        extras_requested: Optional[Iterable[str]] = None,
+    ) -> Tuple[List[InstallRequirement], Optional[InstallRequirement]]:
+        """Add install_req as a requirement to install.
+
+        :param parent_req_name: The name of the requirement that needed this
+            added. The name is used because when multiple unnamed requirements
+            resolve to the same name, we could otherwise end up with dependency
+            links that point outside the Requirements set. parent_req must
+            already be added. Note that None implies that this is a user
+            supplied requirement, vs an inferred one.
+        :param extras_requested: an iterable of extras used to evaluate the
+            environment markers.
+        :return: Additional requirements to scan. That is either [] if
+            the requirement is not applicable, or [install_req] if the
+            requirement is applicable and has just been added.
+        """
+        # If the markers do not match, ignore this requirement.
+        if not install_req.match_markers(extras_requested):
+            logger.info(
+                "Ignoring %s: markers '%s' don't match your environment",
+                install_req.name,
+                install_req.markers,
+            )
+            return [], None
+
+        # If the wheel is not supported, raise an error.
+        # Should check this after filtering out based on environment markers to
+        # allow specifying different wheels based on the environment/OS, in a
+        # single requirements file.
+        if install_req.link and install_req.link.is_wheel:
+            wheel = Wheel(install_req.link.filename)
+            tags = compatibility_tags.get_supported()
+            if requirement_set.check_supported_wheels and not wheel.supported(tags):
+                raise InstallationError(
+                    f"{wheel.filename} is not a supported wheel on this platform."
+                )
+
+        # This next bit is really a sanity check.
+        assert (
+            not install_req.user_supplied or parent_req_name is None
+        ), "a user supplied req shouldn't have a parent"
+
+        # Unnamed requirements are scanned again and the requirement won't be
+        # added as a dependency until after scanning.
+        if not install_req.name:
+            requirement_set.add_unnamed_requirement(install_req)
+            return [install_req], None
+
+        try:
+            existing_req: Optional[InstallRequirement] = (
+                requirement_set.get_requirement(install_req.name)
+            )
+        except KeyError:
+            existing_req = None
+
+        has_conflicting_requirement = (
+            parent_req_name is None
+            and existing_req
+            and not existing_req.constraint
+            and existing_req.extras == install_req.extras
+            and existing_req.req
+            and install_req.req
+            and existing_req.req.specifier != install_req.req.specifier
+        )
+        if has_conflicting_requirement:
+            raise InstallationError(
+                f"Double requirement given: {install_req} "
+                f"(already in {existing_req}, name={install_req.name!r})"
+            )
+
+        # When no existing requirement exists, add the requirement as a
+        # dependency and it will be scanned again after.
+        if not existing_req:
+            requirement_set.add_named_requirement(install_req)
+            # We'd want to rescan this requirement later
+            return [install_req], install_req
+
+        # Assume there's no need to scan, and that we've already
+        # encountered this for scanning.
+        if install_req.constraint or not existing_req.constraint:
+            return [], existing_req
+
+        does_not_satisfy_constraint = install_req.link and not (
+            existing_req.link and install_req.link.path == existing_req.link.path
+        )
+        if does_not_satisfy_constraint:
+            raise InstallationError(
+                f"Could not satisfy constraints for '{install_req.name}': "
+                "installation from path or url cannot be "
+                "constrained to a version"
+            )
+        # If we're now installing a constraint, mark the existing
+        # object for real installation.
+        existing_req.constraint = False
+        # If we're now installing a user supplied requirement,
+        # mark the existing object as such.
+        if install_req.user_supplied:
+            existing_req.user_supplied = True
+        existing_req.extras = tuple(
+            sorted(set(existing_req.extras) | set(install_req.extras))
+        )
+        logger.debug(
+            "Setting %s extras to: %s",
+            existing_req,
+            existing_req.extras,
+        )
+        # Return the existing requirement for addition to the parent and
+        # scanning again.
+        return [existing_req], existing_req
+
+    def _is_upgrade_allowed(self, req: InstallRequirement) -> bool:
+        if self.upgrade_strategy == "to-satisfy-only":
+            return False
+        elif self.upgrade_strategy == "eager":
+            return True
+        else:
+            assert self.upgrade_strategy == "only-if-needed"
+            return req.user_supplied or req.constraint
+
+    def _set_req_to_reinstall(self, req: InstallRequirement) -> None:
+        """
+        Set a requirement to be installed.
+        """
+        # Don't uninstall the conflict if doing a user install and the
+        # conflict is not a user install.
+        assert req.satisfied_by is not None
+        if not self.use_user_site or req.satisfied_by.in_usersite:
+            req.should_reinstall = True
+        req.satisfied_by = None
+
+    def _check_skip_installed(
+        self, req_to_install: InstallRequirement
+    ) -> Optional[str]:
+        """Check if req_to_install should be skipped.
+
+        This will check if the req is installed, and whether we should upgrade
+        or reinstall it, taking into account all the relevant user options.
+
+        After calling this req_to_install will only have satisfied_by set to
+        None if the req_to_install is to be upgraded/reinstalled etc. Any
+        other value will be a dist recording the current thing installed that
+        satisfies the requirement.
+
+        Note that for vcs urls and the like we can't assess skipping in this
+        routine - we simply identify that we need to pull the thing down,
+        then later on it is pulled down and introspected to assess upgrade/
+        reinstalls etc.
+
+        :return: A text reason for why it was skipped, or None.
+        """
+        if self.ignore_installed:
+            return None
+
+        req_to_install.check_if_exists(self.use_user_site)
+        if not req_to_install.satisfied_by:
+            return None
+
+        if self.force_reinstall:
+            self._set_req_to_reinstall(req_to_install)
+            return None
+
+        if not self._is_upgrade_allowed(req_to_install):
+            if self.upgrade_strategy == "only-if-needed":
+                return "already satisfied, skipping upgrade"
+            return "already satisfied"
+
+        # Check for the possibility of an upgrade.  For link-based
+        # requirements we have to pull the tree down and inspect to assess
+        # the version #, so it's handled way down.
+        if not req_to_install.link:
+            try:
+                self.finder.find_requirement(req_to_install, upgrade=True)
+            except BestVersionAlreadyInstalled:
+                # Then the best version is installed.
+                return "already up-to-date"
+            except DistributionNotFound:
+                # No distribution found, so we squash the error.  It will
+                # be raised later when we re-try later to do the install.
+                # Why don't we just raise here?
+                pass
+
+        self._set_req_to_reinstall(req_to_install)
+        return None
+
+    def _find_requirement_link(self, req: InstallRequirement) -> Optional[Link]:
+        upgrade = self._is_upgrade_allowed(req)
+        best_candidate = self.finder.find_requirement(req, upgrade)
+        if not best_candidate:
+            return None
+
+        # Log a warning per PEP 592 if necessary before returning.
+        link = best_candidate.link
+        if link.is_yanked:
+            reason = link.yanked_reason or ""
+            msg = (
+                # Mark this as a unicode string to prevent
+                # "UnicodeEncodeError: 'ascii' codec can't encode character"
+                # in Python 2 when the reason contains non-ascii characters.
+                "The candidate selected for download or install is a "
+                f"yanked version: {best_candidate}\n"
+                f"Reason for being yanked: {reason}"
+            )
+            logger.warning(msg)
+
+        return link
+
+    def _populate_link(self, req: InstallRequirement) -> None:
+        """Ensure that if a link can be found for this, that it is found.
+
+        Note that req.link may still be None - if the requirement is already
+        installed and not needed to be upgraded based on the return value of
+        _is_upgrade_allowed().
+
+        If preparer.require_hashes is True, don't use the wheel cache, because
+        cached wheels, always built locally, have different hashes than the
+        files downloaded from the index server and thus throw false hash
+        mismatches. Furthermore, cached wheels at present have undeterministic
+        contents due to file modification times.
+        """
+        if req.link is None:
+            req.link = self._find_requirement_link(req)
+
+        if self.wheel_cache is None or self.preparer.require_hashes:
+            return
+
+        assert req.link is not None, "_find_requirement_link unexpectedly returned None"
+        cache_entry = self.wheel_cache.get_cache_entry(
+            link=req.link,
+            package_name=req.name,
+            supported_tags=get_supported(),
+        )
+        if cache_entry is not None:
+            logger.debug("Using cached wheel link: %s", cache_entry.link)
+            if req.link is req.original_link and cache_entry.persistent:
+                req.cached_wheel_source_link = req.link
+            if cache_entry.origin is not None:
+                req.download_info = cache_entry.origin
+            else:
+                # Legacy cache entry that does not have origin.json.
+                # download_info may miss the archive_info.hashes field.
+                req.download_info = direct_url_from_link(
+                    req.link, link_is_in_wheel_cache=cache_entry.persistent
+                )
+            req.link = cache_entry.link
+
+    def _get_dist_for(self, req: InstallRequirement) -> BaseDistribution:
+        """Takes a InstallRequirement and returns a single AbstractDist \
+        representing a prepared variant of the same.
+        """
+        if req.editable:
+            return self.preparer.prepare_editable_requirement(req)
+
+        # satisfied_by is only evaluated by calling _check_skip_installed,
+        # so it must be None here.
+        assert req.satisfied_by is None
+        skip_reason = self._check_skip_installed(req)
+
+        if req.satisfied_by:
+            return self.preparer.prepare_installed_requirement(req, skip_reason)
+
+        # We eagerly populate the link, since that's our "legacy" behavior.
+        self._populate_link(req)
+        dist = self.preparer.prepare_linked_requirement(req)
+
+        # NOTE
+        # The following portion is for determining if a certain package is
+        # going to be re-installed/upgraded or not and reporting to the user.
+        # This should probably get cleaned up in a future refactor.
+
+        # req.req is only avail after unpack for URL
+        # pkgs repeat check_if_exists to uninstall-on-upgrade
+        # (#14)
+        if not self.ignore_installed:
+            req.check_if_exists(self.use_user_site)
+
+        if req.satisfied_by:
+            should_modify = (
+                self.upgrade_strategy != "to-satisfy-only"
+                or self.force_reinstall
+                or self.ignore_installed
+                or req.link.scheme == "file"
+            )
+            if should_modify:
+                self._set_req_to_reinstall(req)
+            else:
+                logger.info(
+                    "Requirement already satisfied (use --upgrade to upgrade): %s",
+                    req,
+                )
+        return dist
+
+    def _resolve_one(
+        self,
+        requirement_set: RequirementSet,
+        req_to_install: InstallRequirement,
+    ) -> List[InstallRequirement]:
+        """Prepare a single requirements file.
+
+        :return: A list of additional InstallRequirements to also install.
+        """
+        # Tell user what we are doing for this requirement:
+        # obtain (editable), skipping, processing (local url), collecting
+        # (remote url or package name)
+        if req_to_install.constraint or req_to_install.prepared:
+            return []
+
+        req_to_install.prepared = True
+
+        # Parse and return dependencies
+        dist = self._get_dist_for(req_to_install)
+        # This will raise UnsupportedPythonVersion if the given Python
+        # version isn't compatible with the distribution's Requires-Python.
+        _check_dist_requires_python(
+            dist,
+            version_info=self._py_version_info,
+            ignore_requires_python=self.ignore_requires_python,
+        )
+
+        more_reqs: List[InstallRequirement] = []
+
+        def add_req(subreq: Requirement, extras_requested: Iterable[str]) -> None:
+            # This idiosyncratically converts the Requirement to str and let
+            # make_install_req then parse it again into Requirement. But this is
+            # the legacy resolver so I'm just not going to bother refactoring.
+            sub_install_req = self._make_install_req(str(subreq), req_to_install)
+            parent_req_name = req_to_install.name
+            to_scan_again, add_to_parent = self._add_requirement_to_set(
+                requirement_set,
+                sub_install_req,
+                parent_req_name=parent_req_name,
+                extras_requested=extras_requested,
+            )
+            if parent_req_name and add_to_parent:
+                self._discovered_dependencies[parent_req_name].append(add_to_parent)
+            more_reqs.extend(to_scan_again)
+
+        with indent_log():
+            # We add req_to_install before its dependencies, so that we
+            # can refer to it when adding dependencies.
+            assert req_to_install.name is not None
+            if not requirement_set.has_requirement(req_to_install.name):
+                # 'unnamed' requirements will get added here
+                # 'unnamed' requirements can only come from being directly
+                # provided by the user.
+                assert req_to_install.user_supplied
+                self._add_requirement_to_set(
+                    requirement_set, req_to_install, parent_req_name=None
+                )
+
+            if not self.ignore_dependencies:
+                if req_to_install.extras:
+                    logger.debug(
+                        "Installing extra requirements: %r",
+                        ",".join(req_to_install.extras),
+                    )
+                missing_requested = sorted(
+                    set(req_to_install.extras) - set(dist.iter_provided_extras())
+                )
+                for missing in missing_requested:
+                    logger.warning(
+                        "%s %s does not provide the extra '%s'",
+                        dist.raw_name,
+                        dist.version,
+                        missing,
+                    )
+
+                available_requested = sorted(
+                    set(dist.iter_provided_extras()) & set(req_to_install.extras)
+                )
+                for subreq in dist.iter_dependencies(available_requested):
+                    add_req(subreq, extras_requested=available_requested)
+
+        return more_reqs
+
+    def get_installation_order(
+        self, req_set: RequirementSet
+    ) -> List[InstallRequirement]:
+        """Create the installation order.
+
+        The installation order is topological - requirements are installed
+        before the requiring thing. We break cycles at an arbitrary point,
+        and make no other guarantees.
+        """
+        # The current implementation, which we may change at any point
+        # installs the user specified things in the order given, except when
+        # dependencies must come earlier to achieve topological order.
+        order = []
+        ordered_reqs: Set[InstallRequirement] = set()
+
+        def schedule(req: InstallRequirement) -> None:
+            if req.satisfied_by or req in ordered_reqs:
+                return
+            if req.constraint:
+                return
+            ordered_reqs.add(req)
+            for dep in self._discovered_dependencies[req.name]:
+                schedule(dep)
+            order.append(req)
+
+        for install_req in req_set.requirements.values():
+            schedule(install_req)
+        return order
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/resolution/resolvelib/__init__.py b/venv/lib/python3.12/site-packages/pip/_internal/resolution/resolvelib/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/resolution/resolvelib/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/resolution/resolvelib/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 00000000..575c8f7f
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/resolution/resolvelib/__pycache__/__init__.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/resolution/resolvelib/__pycache__/base.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/resolution/resolvelib/__pycache__/base.cpython-312.pyc
new file mode 100644
index 00000000..a6042118
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/resolution/resolvelib/__pycache__/base.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/resolution/resolvelib/__pycache__/candidates.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/resolution/resolvelib/__pycache__/candidates.cpython-312.pyc
new file mode 100644
index 00000000..a2ab8e70
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/resolution/resolvelib/__pycache__/candidates.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/resolution/resolvelib/__pycache__/factory.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/resolution/resolvelib/__pycache__/factory.cpython-312.pyc
new file mode 100644
index 00000000..560e4124
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/resolution/resolvelib/__pycache__/factory.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/resolution/resolvelib/__pycache__/found_candidates.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/resolution/resolvelib/__pycache__/found_candidates.cpython-312.pyc
new file mode 100644
index 00000000..e111bcdb
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/resolution/resolvelib/__pycache__/found_candidates.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/resolution/resolvelib/__pycache__/provider.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/resolution/resolvelib/__pycache__/provider.cpython-312.pyc
new file mode 100644
index 00000000..08f312f2
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/resolution/resolvelib/__pycache__/provider.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/resolution/resolvelib/__pycache__/reporter.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/resolution/resolvelib/__pycache__/reporter.cpython-312.pyc
new file mode 100644
index 00000000..6e5bbad7
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/resolution/resolvelib/__pycache__/reporter.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/resolution/resolvelib/__pycache__/requirements.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/resolution/resolvelib/__pycache__/requirements.cpython-312.pyc
new file mode 100644
index 00000000..5b925500
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/resolution/resolvelib/__pycache__/requirements.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/resolution/resolvelib/__pycache__/resolver.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/resolution/resolvelib/__pycache__/resolver.cpython-312.pyc
new file mode 100644
index 00000000..5b8d033f
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/resolution/resolvelib/__pycache__/resolver.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/resolution/resolvelib/base.py b/venv/lib/python3.12/site-packages/pip/_internal/resolution/resolvelib/base.py
new file mode 100644
index 00000000..0f31dc9b
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/resolution/resolvelib/base.py
@@ -0,0 +1,139 @@
+from dataclasses import dataclass
+from typing import FrozenSet, Iterable, Optional, Tuple
+
+from pip._vendor.packaging.specifiers import SpecifierSet
+from pip._vendor.packaging.utils import NormalizedName
+from pip._vendor.packaging.version import Version
+
+from pip._internal.models.link import Link, links_equivalent
+from pip._internal.req.req_install import InstallRequirement
+from pip._internal.utils.hashes import Hashes
+
+CandidateLookup = Tuple[Optional["Candidate"], Optional[InstallRequirement]]
+
+
+def format_name(project: NormalizedName, extras: FrozenSet[NormalizedName]) -> str:
+    if not extras:
+        return project
+    extras_expr = ",".join(sorted(extras))
+    return f"{project}[{extras_expr}]"
+
+
+@dataclass(frozen=True)
+class Constraint:
+    specifier: SpecifierSet
+    hashes: Hashes
+    links: FrozenSet[Link]
+
+    @classmethod
+    def empty(cls) -> "Constraint":
+        return Constraint(SpecifierSet(), Hashes(), frozenset())
+
+    @classmethod
+    def from_ireq(cls, ireq: InstallRequirement) -> "Constraint":
+        links = frozenset([ireq.link]) if ireq.link else frozenset()
+        return Constraint(ireq.specifier, ireq.hashes(trust_internet=False), links)
+
+    def __bool__(self) -> bool:
+        return bool(self.specifier) or bool(self.hashes) or bool(self.links)
+
+    def __and__(self, other: InstallRequirement) -> "Constraint":
+        if not isinstance(other, InstallRequirement):
+            return NotImplemented
+        specifier = self.specifier & other.specifier
+        hashes = self.hashes & other.hashes(trust_internet=False)
+        links = self.links
+        if other.link:
+            links = links.union([other.link])
+        return Constraint(specifier, hashes, links)
+
+    def is_satisfied_by(self, candidate: "Candidate") -> bool:
+        # Reject if there are any mismatched URL constraints on this package.
+        if self.links and not all(_match_link(link, candidate) for link in self.links):
+            return False
+        # We can safely always allow prereleases here since PackageFinder
+        # already implements the prerelease logic, and would have filtered out
+        # prerelease candidates if the user does not expect them.
+        return self.specifier.contains(candidate.version, prereleases=True)
+
+
+class Requirement:
+    @property
+    def project_name(self) -> NormalizedName:
+        """The "project name" of a requirement.
+
+        This is different from ``name`` if this requirement contains extras,
+        in which case ``name`` would contain the ``[...]`` part, while this
+        refers to the name of the project.
+        """
+        raise NotImplementedError("Subclass should override")
+
+    @property
+    def name(self) -> str:
+        """The name identifying this requirement in the resolver.
+
+        This is different from ``project_name`` if this requirement contains
+        extras, where ``project_name`` would not contain the ``[...]`` part.
+        """
+        raise NotImplementedError("Subclass should override")
+
+    def is_satisfied_by(self, candidate: "Candidate") -> bool:
+        return False
+
+    def get_candidate_lookup(self) -> CandidateLookup:
+        raise NotImplementedError("Subclass should override")
+
+    def format_for_error(self) -> str:
+        raise NotImplementedError("Subclass should override")
+
+
+def _match_link(link: Link, candidate: "Candidate") -> bool:
+    if candidate.source_link:
+        return links_equivalent(link, candidate.source_link)
+    return False
+
+
+class Candidate:
+    @property
+    def project_name(self) -> NormalizedName:
+        """The "project name" of the candidate.
+
+        This is different from ``name`` if this candidate contains extras,
+        in which case ``name`` would contain the ``[...]`` part, while this
+        refers to the name of the project.
+        """
+        raise NotImplementedError("Override in subclass")
+
+    @property
+    def name(self) -> str:
+        """The name identifying this candidate in the resolver.
+
+        This is different from ``project_name`` if this candidate contains
+        extras, where ``project_name`` would not contain the ``[...]`` part.
+        """
+        raise NotImplementedError("Override in subclass")
+
+    @property
+    def version(self) -> Version:
+        raise NotImplementedError("Override in subclass")
+
+    @property
+    def is_installed(self) -> bool:
+        raise NotImplementedError("Override in subclass")
+
+    @property
+    def is_editable(self) -> bool:
+        raise NotImplementedError("Override in subclass")
+
+    @property
+    def source_link(self) -> Optional[Link]:
+        raise NotImplementedError("Override in subclass")
+
+    def iter_dependencies(self, with_requires: bool) -> Iterable[Optional[Requirement]]:
+        raise NotImplementedError("Override in subclass")
+
+    def get_install_requirement(self) -> Optional[InstallRequirement]:
+        raise NotImplementedError("Override in subclass")
+
+    def format_for_error(self) -> str:
+        raise NotImplementedError("Subclass should override")
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/resolution/resolvelib/candidates.py b/venv/lib/python3.12/site-packages/pip/_internal/resolution/resolvelib/candidates.py
new file mode 100644
index 00000000..d30d477b
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/resolution/resolvelib/candidates.py
@@ -0,0 +1,569 @@
+import logging
+import sys
+from typing import TYPE_CHECKING, Any, FrozenSet, Iterable, Optional, Tuple, Union, cast
+
+from pip._vendor.packaging.requirements import InvalidRequirement
+from pip._vendor.packaging.utils import NormalizedName, canonicalize_name
+from pip._vendor.packaging.version import Version
+
+from pip._internal.exceptions import (
+    HashError,
+    InstallationSubprocessError,
+    MetadataInconsistent,
+    MetadataInvalid,
+)
+from pip._internal.metadata import BaseDistribution
+from pip._internal.models.link import Link, links_equivalent
+from pip._internal.models.wheel import Wheel
+from pip._internal.req.constructors import (
+    install_req_from_editable,
+    install_req_from_line,
+)
+from pip._internal.req.req_install import InstallRequirement
+from pip._internal.utils.direct_url_helpers import direct_url_from_link
+from pip._internal.utils.misc import normalize_version_info
+
+from .base import Candidate, Requirement, format_name
+
+if TYPE_CHECKING:
+    from .factory import Factory
+
+logger = logging.getLogger(__name__)
+
+BaseCandidate = Union[
+    "AlreadyInstalledCandidate",
+    "EditableCandidate",
+    "LinkCandidate",
+]
+
+# Avoid conflicting with the PyPI package "Python".
+REQUIRES_PYTHON_IDENTIFIER = cast(NormalizedName, "")
+
+
+def as_base_candidate(candidate: Candidate) -> Optional[BaseCandidate]:
+    """The runtime version of BaseCandidate."""
+    base_candidate_classes = (
+        AlreadyInstalledCandidate,
+        EditableCandidate,
+        LinkCandidate,
+    )
+    if isinstance(candidate, base_candidate_classes):
+        return candidate
+    return None
+
+
+def make_install_req_from_link(
+    link: Link, template: InstallRequirement
+) -> InstallRequirement:
+    assert not template.editable, "template is editable"
+    if template.req:
+        line = str(template.req)
+    else:
+        line = link.url
+    ireq = install_req_from_line(
+        line,
+        user_supplied=template.user_supplied,
+        comes_from=template.comes_from,
+        use_pep517=template.use_pep517,
+        isolated=template.isolated,
+        constraint=template.constraint,
+        global_options=template.global_options,
+        hash_options=template.hash_options,
+        config_settings=template.config_settings,
+    )
+    ireq.original_link = template.original_link
+    ireq.link = link
+    ireq.extras = template.extras
+    return ireq
+
+
+def make_install_req_from_editable(
+    link: Link, template: InstallRequirement
+) -> InstallRequirement:
+    assert template.editable, "template not editable"
+    ireq = install_req_from_editable(
+        link.url,
+        user_supplied=template.user_supplied,
+        comes_from=template.comes_from,
+        use_pep517=template.use_pep517,
+        isolated=template.isolated,
+        constraint=template.constraint,
+        permit_editable_wheels=template.permit_editable_wheels,
+        global_options=template.global_options,
+        hash_options=template.hash_options,
+        config_settings=template.config_settings,
+    )
+    ireq.extras = template.extras
+    return ireq
+
+
+def _make_install_req_from_dist(
+    dist: BaseDistribution, template: InstallRequirement
+) -> InstallRequirement:
+    if template.req:
+        line = str(template.req)
+    elif template.link:
+        line = f"{dist.canonical_name} @ {template.link.url}"
+    else:
+        line = f"{dist.canonical_name}=={dist.version}"
+    ireq = install_req_from_line(
+        line,
+        user_supplied=template.user_supplied,
+        comes_from=template.comes_from,
+        use_pep517=template.use_pep517,
+        isolated=template.isolated,
+        constraint=template.constraint,
+        global_options=template.global_options,
+        hash_options=template.hash_options,
+        config_settings=template.config_settings,
+    )
+    ireq.satisfied_by = dist
+    return ireq
+
+
+class _InstallRequirementBackedCandidate(Candidate):
+    """A candidate backed by an ``InstallRequirement``.
+
+    This represents a package request with the target not being already
+    in the environment, and needs to be fetched and installed. The backing
+    ``InstallRequirement`` is responsible for most of the leg work; this
+    class exposes appropriate information to the resolver.
+
+    :param link: The link passed to the ``InstallRequirement``. The backing
+        ``InstallRequirement`` will use this link to fetch the distribution.
+    :param source_link: The link this candidate "originates" from. This is
+        different from ``link`` when the link is found in the wheel cache.
+        ``link`` would point to the wheel cache, while this points to the
+        found remote link (e.g. from pypi.org).
+    """
+
+    dist: BaseDistribution
+    is_installed = False
+
+    def __init__(
+        self,
+        link: Link,
+        source_link: Link,
+        ireq: InstallRequirement,
+        factory: "Factory",
+        name: Optional[NormalizedName] = None,
+        version: Optional[Version] = None,
+    ) -> None:
+        self._link = link
+        self._source_link = source_link
+        self._factory = factory
+        self._ireq = ireq
+        self._name = name
+        self._version = version
+        self.dist = self._prepare()
+        self._hash: Optional[int] = None
+
+    def __str__(self) -> str:
+        return f"{self.name} {self.version}"
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}({str(self._link)!r})"
+
+    def __hash__(self) -> int:
+        if self._hash is not None:
+            return self._hash
+
+        self._hash = hash((self.__class__, self._link))
+        return self._hash
+
+    def __eq__(self, other: Any) -> bool:
+        if isinstance(other, self.__class__):
+            return links_equivalent(self._link, other._link)
+        return False
+
+    @property
+    def source_link(self) -> Optional[Link]:
+        return self._source_link
+
+    @property
+    def project_name(self) -> NormalizedName:
+        """The normalised name of the project the candidate refers to"""
+        if self._name is None:
+            self._name = self.dist.canonical_name
+        return self._name
+
+    @property
+    def name(self) -> str:
+        return self.project_name
+
+    @property
+    def version(self) -> Version:
+        if self._version is None:
+            self._version = self.dist.version
+        return self._version
+
+    def format_for_error(self) -> str:
+        return (
+            f"{self.name} {self.version} "
+            f"(from {self._link.file_path if self._link.is_file else self._link})"
+        )
+
+    def _prepare_distribution(self) -> BaseDistribution:
+        raise NotImplementedError("Override in subclass")
+
+    def _check_metadata_consistency(self, dist: BaseDistribution) -> None:
+        """Check for consistency of project name and version of dist."""
+        if self._name is not None and self._name != dist.canonical_name:
+            raise MetadataInconsistent(
+                self._ireq,
+                "name",
+                self._name,
+                dist.canonical_name,
+            )
+        if self._version is not None and self._version != dist.version:
+            raise MetadataInconsistent(
+                self._ireq,
+                "version",
+                str(self._version),
+                str(dist.version),
+            )
+        # check dependencies are valid
+        # TODO performance: this means we iterate the dependencies at least twice,
+        # we may want to cache parsed Requires-Dist
+        try:
+            list(dist.iter_dependencies(list(dist.iter_provided_extras())))
+        except InvalidRequirement as e:
+            raise MetadataInvalid(self._ireq, str(e))
+
+    def _prepare(self) -> BaseDistribution:
+        try:
+            dist = self._prepare_distribution()
+        except HashError as e:
+            # Provide HashError the underlying ireq that caused it. This
+            # provides context for the resulting error message to show the
+            # offending line to the user.
+            e.req = self._ireq
+            raise
+        except InstallationSubprocessError as exc:
+            # The output has been presented already, so don't duplicate it.
+            exc.context = "See above for output."
+            raise
+
+        self._check_metadata_consistency(dist)
+        return dist
+
+    def iter_dependencies(self, with_requires: bool) -> Iterable[Optional[Requirement]]:
+        requires = self.dist.iter_dependencies() if with_requires else ()
+        for r in requires:
+            yield from self._factory.make_requirements_from_spec(str(r), self._ireq)
+        yield self._factory.make_requires_python_requirement(self.dist.requires_python)
+
+    def get_install_requirement(self) -> Optional[InstallRequirement]:
+        return self._ireq
+
+
+class LinkCandidate(_InstallRequirementBackedCandidate):
+    is_editable = False
+
+    def __init__(
+        self,
+        link: Link,
+        template: InstallRequirement,
+        factory: "Factory",
+        name: Optional[NormalizedName] = None,
+        version: Optional[Version] = None,
+    ) -> None:
+        source_link = link
+        cache_entry = factory.get_wheel_cache_entry(source_link, name)
+        if cache_entry is not None:
+            logger.debug("Using cached wheel link: %s", cache_entry.link)
+            link = cache_entry.link
+        ireq = make_install_req_from_link(link, template)
+        assert ireq.link == link
+        if ireq.link.is_wheel and not ireq.link.is_file:
+            wheel = Wheel(ireq.link.filename)
+            wheel_name = canonicalize_name(wheel.name)
+            assert name == wheel_name, f"{name!r} != {wheel_name!r} for wheel"
+            # Version may not be present for PEP 508 direct URLs
+            if version is not None:
+                wheel_version = Version(wheel.version)
+                assert (
+                    version == wheel_version
+                ), f"{version!r} != {wheel_version!r} for wheel {name}"
+
+        if cache_entry is not None:
+            assert ireq.link.is_wheel
+            assert ireq.link.is_file
+            if cache_entry.persistent and template.link is template.original_link:
+                ireq.cached_wheel_source_link = source_link
+            if cache_entry.origin is not None:
+                ireq.download_info = cache_entry.origin
+            else:
+                # Legacy cache entry that does not have origin.json.
+                # download_info may miss the archive_info.hashes field.
+                ireq.download_info = direct_url_from_link(
+                    source_link, link_is_in_wheel_cache=cache_entry.persistent
+                )
+
+        super().__init__(
+            link=link,
+            source_link=source_link,
+            ireq=ireq,
+            factory=factory,
+            name=name,
+            version=version,
+        )
+
+    def _prepare_distribution(self) -> BaseDistribution:
+        preparer = self._factory.preparer
+        return preparer.prepare_linked_requirement(self._ireq, parallel_builds=True)
+
+
+class EditableCandidate(_InstallRequirementBackedCandidate):
+    is_editable = True
+
+    def __init__(
+        self,
+        link: Link,
+        template: InstallRequirement,
+        factory: "Factory",
+        name: Optional[NormalizedName] = None,
+        version: Optional[Version] = None,
+    ) -> None:
+        super().__init__(
+            link=link,
+            source_link=link,
+            ireq=make_install_req_from_editable(link, template),
+            factory=factory,
+            name=name,
+            version=version,
+        )
+
+    def _prepare_distribution(self) -> BaseDistribution:
+        return self._factory.preparer.prepare_editable_requirement(self._ireq)
+
+
+class AlreadyInstalledCandidate(Candidate):
+    is_installed = True
+    source_link = None
+
+    def __init__(
+        self,
+        dist: BaseDistribution,
+        template: InstallRequirement,
+        factory: "Factory",
+    ) -> None:
+        self.dist = dist
+        self._ireq = _make_install_req_from_dist(dist, template)
+        self._factory = factory
+        self._version = None
+
+        # This is just logging some messages, so we can do it eagerly.
+        # The returned dist would be exactly the same as self.dist because we
+        # set satisfied_by in _make_install_req_from_dist.
+        # TODO: Supply reason based on force_reinstall and upgrade_strategy.
+        skip_reason = "already satisfied"
+        factory.preparer.prepare_installed_requirement(self._ireq, skip_reason)
+
+    def __str__(self) -> str:
+        return str(self.dist)
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}({self.dist!r})"
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, AlreadyInstalledCandidate):
+            return NotImplemented
+        return self.name == other.name and self.version == other.version
+
+    def __hash__(self) -> int:
+        return hash((self.name, self.version))
+
+    @property
+    def project_name(self) -> NormalizedName:
+        return self.dist.canonical_name
+
+    @property
+    def name(self) -> str:
+        return self.project_name
+
+    @property
+    def version(self) -> Version:
+        if self._version is None:
+            self._version = self.dist.version
+        return self._version
+
+    @property
+    def is_editable(self) -> bool:
+        return self.dist.editable
+
+    def format_for_error(self) -> str:
+        return f"{self.name} {self.version} (Installed)"
+
+    def iter_dependencies(self, with_requires: bool) -> Iterable[Optional[Requirement]]:
+        if not with_requires:
+            return
+        for r in self.dist.iter_dependencies():
+            yield from self._factory.make_requirements_from_spec(str(r), self._ireq)
+
+    def get_install_requirement(self) -> Optional[InstallRequirement]:
+        return None
+
+
+class ExtrasCandidate(Candidate):
+    """A candidate that has 'extras', indicating additional dependencies.
+
+    Requirements can be for a project with dependencies, something like
+    foo[extra].  The extras don't affect the project/version being installed
+    directly, but indicate that we need additional dependencies. We model that
+    by having an artificial ExtrasCandidate that wraps the "base" candidate.
+
+    The ExtrasCandidate differs from the base in the following ways:
+
+    1. It has a unique name, of the form foo[extra]. This causes the resolver
+       to treat it as a separate node in the dependency graph.
+    2. When we're getting the candidate's dependencies,
+       a) We specify that we want the extra dependencies as well.
+       b) We add a dependency on the base candidate.
+          See below for why this is needed.
+    3. We return None for the underlying InstallRequirement, as the base
+       candidate will provide it, and we don't want to end up with duplicates.
+
+    The dependency on the base candidate is needed so that the resolver can't
+    decide that it should recommend foo[extra1] version 1.0 and foo[extra2]
+    version 2.0. Having those candidates depend on foo=1.0 and foo=2.0
+    respectively forces the resolver to recognise that this is a conflict.
+    """
+
+    def __init__(
+        self,
+        base: BaseCandidate,
+        extras: FrozenSet[str],
+        *,
+        comes_from: Optional[InstallRequirement] = None,
+    ) -> None:
+        """
+        :param comes_from: the InstallRequirement that led to this candidate if it
+            differs from the base's InstallRequirement. This will often be the
+            case in the sense that this candidate's requirement has the extras
+            while the base's does not. Unlike the InstallRequirement backed
+            candidates, this requirement is used solely for reporting purposes,
+            it does not do any leg work.
+        """
+        self.base = base
+        self.extras = frozenset(canonicalize_name(e) for e in extras)
+        self._comes_from = comes_from if comes_from is not None else self.base._ireq
+
+    def __str__(self) -> str:
+        name, rest = str(self.base).split(" ", 1)
+        return "{}[{}] {}".format(name, ",".join(self.extras), rest)
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}(base={self.base!r}, extras={self.extras!r})"
+
+    def __hash__(self) -> int:
+        return hash((self.base, self.extras))
+
+    def __eq__(self, other: Any) -> bool:
+        if isinstance(other, self.__class__):
+            return self.base == other.base and self.extras == other.extras
+        return False
+
+    @property
+    def project_name(self) -> NormalizedName:
+        return self.base.project_name
+
+    @property
+    def name(self) -> str:
+        """The normalised name of the project the candidate refers to"""
+        return format_name(self.base.project_name, self.extras)
+
+    @property
+    def version(self) -> Version:
+        return self.base.version
+
+    def format_for_error(self) -> str:
+        return "{} [{}]".format(
+            self.base.format_for_error(), ", ".join(sorted(self.extras))
+        )
+
+    @property
+    def is_installed(self) -> bool:
+        return self.base.is_installed
+
+    @property
+    def is_editable(self) -> bool:
+        return self.base.is_editable
+
+    @property
+    def source_link(self) -> Optional[Link]:
+        return self.base.source_link
+
+    def iter_dependencies(self, with_requires: bool) -> Iterable[Optional[Requirement]]:
+        factory = self.base._factory
+
+        # Add a dependency on the exact base
+        # (See note 2b in the class docstring)
+        yield factory.make_requirement_from_candidate(self.base)
+        if not with_requires:
+            return
+
+        # The user may have specified extras that the candidate doesn't
+        # support. We ignore any unsupported extras here.
+        valid_extras = self.extras.intersection(self.base.dist.iter_provided_extras())
+        invalid_extras = self.extras.difference(self.base.dist.iter_provided_extras())
+        for extra in sorted(invalid_extras):
+            logger.warning(
+                "%s %s does not provide the extra '%s'",
+                self.base.name,
+                self.version,
+                extra,
+            )
+
+        for r in self.base.dist.iter_dependencies(valid_extras):
+            yield from factory.make_requirements_from_spec(
+                str(r),
+                self._comes_from,
+                valid_extras,
+            )
+
+    def get_install_requirement(self) -> Optional[InstallRequirement]:
+        # We don't return anything here, because we always
+        # depend on the base candidate, and we'll get the
+        # install requirement from that.
+        return None
+
+
+class RequiresPythonCandidate(Candidate):
+    is_installed = False
+    source_link = None
+
+    def __init__(self, py_version_info: Optional[Tuple[int, ...]]) -> None:
+        if py_version_info is not None:
+            version_info = normalize_version_info(py_version_info)
+        else:
+            version_info = sys.version_info[:3]
+        self._version = Version(".".join(str(c) for c in version_info))
+
+    # We don't need to implement __eq__() and __ne__() since there is always
+    # only one RequiresPythonCandidate in a resolution, i.e. the host Python.
+    # The built-in object.__eq__() and object.__ne__() do exactly what we want.
+
+    def __str__(self) -> str:
+        return f"Python {self._version}"
+
+    @property
+    def project_name(self) -> NormalizedName:
+        return REQUIRES_PYTHON_IDENTIFIER
+
+    @property
+    def name(self) -> str:
+        return REQUIRES_PYTHON_IDENTIFIER
+
+    @property
+    def version(self) -> Version:
+        return self._version
+
+    def format_for_error(self) -> str:
+        return f"Python {self.version}"
+
+    def iter_dependencies(self, with_requires: bool) -> Iterable[Optional[Requirement]]:
+        return ()
+
+    def get_install_requirement(self) -> Optional[InstallRequirement]:
+        return None
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/resolution/resolvelib/factory.py b/venv/lib/python3.12/site-packages/pip/_internal/resolution/resolvelib/factory.py
new file mode 100644
index 00000000..145bdbf7
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/resolution/resolvelib/factory.py
@@ -0,0 +1,817 @@
+import contextlib
+import functools
+import logging
+from typing import (
+    TYPE_CHECKING,
+    Callable,
+    Dict,
+    FrozenSet,
+    Iterable,
+    Iterator,
+    List,
+    Mapping,
+    NamedTuple,
+    Optional,
+    Protocol,
+    Sequence,
+    Set,
+    Tuple,
+    TypeVar,
+    cast,
+)
+
+from pip._vendor.packaging.requirements import InvalidRequirement
+from pip._vendor.packaging.specifiers import SpecifierSet
+from pip._vendor.packaging.utils import NormalizedName, canonicalize_name
+from pip._vendor.packaging.version import Version
+from pip._vendor.resolvelib import ResolutionImpossible
+
+from pip._internal.cache import CacheEntry, WheelCache
+from pip._internal.exceptions import (
+    DistributionNotFound,
+    InstallationError,
+    MetadataInconsistent,
+    MetadataInvalid,
+    UnsupportedPythonVersion,
+    UnsupportedWheel,
+)
+from pip._internal.index.package_finder import PackageFinder
+from pip._internal.metadata import BaseDistribution, get_default_environment
+from pip._internal.models.link import Link
+from pip._internal.models.wheel import Wheel
+from pip._internal.operations.prepare import RequirementPreparer
+from pip._internal.req.constructors import (
+    install_req_drop_extras,
+    install_req_from_link_and_ireq,
+)
+from pip._internal.req.req_install import (
+    InstallRequirement,
+    check_invalid_constraint_type,
+)
+from pip._internal.resolution.base import InstallRequirementProvider
+from pip._internal.utils.compatibility_tags import get_supported
+from pip._internal.utils.hashes import Hashes
+from pip._internal.utils.packaging import get_requirement
+from pip._internal.utils.virtualenv import running_under_virtualenv
+
+from .base import Candidate, Constraint, Requirement
+from .candidates import (
+    AlreadyInstalledCandidate,
+    BaseCandidate,
+    EditableCandidate,
+    ExtrasCandidate,
+    LinkCandidate,
+    RequiresPythonCandidate,
+    as_base_candidate,
+)
+from .found_candidates import FoundCandidates, IndexCandidateInfo
+from .requirements import (
+    ExplicitRequirement,
+    RequiresPythonRequirement,
+    SpecifierRequirement,
+    SpecifierWithoutExtrasRequirement,
+    UnsatisfiableRequirement,
+)
+
+if TYPE_CHECKING:
+
+    class ConflictCause(Protocol):
+        requirement: RequiresPythonRequirement
+        parent: Candidate
+
+
+logger = logging.getLogger(__name__)
+
+C = TypeVar("C")
+Cache = Dict[Link, C]
+
+
+class CollectedRootRequirements(NamedTuple):
+    requirements: List[Requirement]
+    constraints: Dict[str, Constraint]
+    user_requested: Dict[str, int]
+
+
+class Factory:
+    def __init__(
+        self,
+        finder: PackageFinder,
+        preparer: RequirementPreparer,
+        make_install_req: InstallRequirementProvider,
+        wheel_cache: Optional[WheelCache],
+        use_user_site: bool,
+        force_reinstall: bool,
+        ignore_installed: bool,
+        ignore_requires_python: bool,
+        py_version_info: Optional[Tuple[int, ...]] = None,
+    ) -> None:
+        self._finder = finder
+        self.preparer = preparer
+        self._wheel_cache = wheel_cache
+        self._python_candidate = RequiresPythonCandidate(py_version_info)
+        self._make_install_req_from_spec = make_install_req
+        self._use_user_site = use_user_site
+        self._force_reinstall = force_reinstall
+        self._ignore_requires_python = ignore_requires_python
+
+        self._build_failures: Cache[InstallationError] = {}
+        self._link_candidate_cache: Cache[LinkCandidate] = {}
+        self._editable_candidate_cache: Cache[EditableCandidate] = {}
+        self._installed_candidate_cache: Dict[str, AlreadyInstalledCandidate] = {}
+        self._extras_candidate_cache: Dict[
+            Tuple[int, FrozenSet[NormalizedName]], ExtrasCandidate
+        ] = {}
+        self._supported_tags_cache = get_supported()
+
+        if not ignore_installed:
+            env = get_default_environment()
+            self._installed_dists = {
+                dist.canonical_name: dist
+                for dist in env.iter_installed_distributions(local_only=False)
+            }
+        else:
+            self._installed_dists = {}
+
+    @property
+    def force_reinstall(self) -> bool:
+        return self._force_reinstall
+
+    def _fail_if_link_is_unsupported_wheel(self, link: Link) -> None:
+        if not link.is_wheel:
+            return
+        wheel = Wheel(link.filename)
+        if wheel.supported(self._finder.target_python.get_unsorted_tags()):
+            return
+        msg = f"{link.filename} is not a supported wheel on this platform."
+        raise UnsupportedWheel(msg)
+
+    def _make_extras_candidate(
+        self,
+        base: BaseCandidate,
+        extras: FrozenSet[str],
+        *,
+        comes_from: Optional[InstallRequirement] = None,
+    ) -> ExtrasCandidate:
+        cache_key = (id(base), frozenset(canonicalize_name(e) for e in extras))
+        try:
+            candidate = self._extras_candidate_cache[cache_key]
+        except KeyError:
+            candidate = ExtrasCandidate(base, extras, comes_from=comes_from)
+            self._extras_candidate_cache[cache_key] = candidate
+        return candidate
+
+    def _make_candidate_from_dist(
+        self,
+        dist: BaseDistribution,
+        extras: FrozenSet[str],
+        template: InstallRequirement,
+    ) -> Candidate:
+        try:
+            base = self._installed_candidate_cache[dist.canonical_name]
+        except KeyError:
+            base = AlreadyInstalledCandidate(dist, template, factory=self)
+            self._installed_candidate_cache[dist.canonical_name] = base
+        if not extras:
+            return base
+        return self._make_extras_candidate(base, extras, comes_from=template)
+
+    def _make_candidate_from_link(
+        self,
+        link: Link,
+        extras: FrozenSet[str],
+        template: InstallRequirement,
+        name: Optional[NormalizedName],
+        version: Optional[Version],
+    ) -> Optional[Candidate]:
+        base: Optional[BaseCandidate] = self._make_base_candidate_from_link(
+            link, template, name, version
+        )
+        if not extras or base is None:
+            return base
+        return self._make_extras_candidate(base, extras, comes_from=template)
+
+    def _make_base_candidate_from_link(
+        self,
+        link: Link,
+        template: InstallRequirement,
+        name: Optional[NormalizedName],
+        version: Optional[Version],
+    ) -> Optional[BaseCandidate]:
+        # TODO: Check already installed candidate, and use it if the link and
+        # editable flag match.
+
+        if link in self._build_failures:
+            # We already tried this candidate before, and it does not build.
+            # Don't bother trying again.
+            return None
+
+        if template.editable:
+            if link not in self._editable_candidate_cache:
+                try:
+                    self._editable_candidate_cache[link] = EditableCandidate(
+                        link,
+                        template,
+                        factory=self,
+                        name=name,
+                        version=version,
+                    )
+                except (MetadataInconsistent, MetadataInvalid) as e:
+                    logger.info(
+                        "Discarding [blue underline]%s[/]: [yellow]%s[reset]",
+                        link,
+                        e,
+                        extra={"markup": True},
+                    )
+                    self._build_failures[link] = e
+                    return None
+
+            return self._editable_candidate_cache[link]
+        else:
+            if link not in self._link_candidate_cache:
+                try:
+                    self._link_candidate_cache[link] = LinkCandidate(
+                        link,
+                        template,
+                        factory=self,
+                        name=name,
+                        version=version,
+                    )
+                except MetadataInconsistent as e:
+                    logger.info(
+                        "Discarding [blue underline]%s[/]: [yellow]%s[reset]",
+                        link,
+                        e,
+                        extra={"markup": True},
+                    )
+                    self._build_failures[link] = e
+                    return None
+            return self._link_candidate_cache[link]
+
+    def _iter_found_candidates(
+        self,
+        ireqs: Sequence[InstallRequirement],
+        specifier: SpecifierSet,
+        hashes: Hashes,
+        prefers_installed: bool,
+        incompatible_ids: Set[int],
+    ) -> Iterable[Candidate]:
+        if not ireqs:
+            return ()
+
+        # The InstallRequirement implementation requires us to give it a
+        # "template". Here we just choose the first requirement to represent
+        # all of them.
+        # Hopefully the Project model can correct this mismatch in the future.
+        template = ireqs[0]
+        assert template.req, "Candidates found on index must be PEP 508"
+        name = canonicalize_name(template.req.name)
+
+        extras: FrozenSet[str] = frozenset()
+        for ireq in ireqs:
+            assert ireq.req, "Candidates found on index must be PEP 508"
+            specifier &= ireq.req.specifier
+            hashes &= ireq.hashes(trust_internet=False)
+            extras |= frozenset(ireq.extras)
+
+        def _get_installed_candidate() -> Optional[Candidate]:
+            """Get the candidate for the currently-installed version."""
+            # If --force-reinstall is set, we want the version from the index
+            # instead, so we "pretend" there is nothing installed.
+            if self._force_reinstall:
+                return None
+            try:
+                installed_dist = self._installed_dists[name]
+            except KeyError:
+                return None
+            # Don't use the installed distribution if its version does not fit
+            # the current dependency graph.
+            if not specifier.contains(installed_dist.version, prereleases=True):
+                return None
+            candidate = self._make_candidate_from_dist(
+                dist=installed_dist,
+                extras=extras,
+                template=template,
+            )
+            # The candidate is a known incompatibility. Don't use it.
+            if id(candidate) in incompatible_ids:
+                return None
+            return candidate
+
+        def iter_index_candidate_infos() -> Iterator[IndexCandidateInfo]:
+            result = self._finder.find_best_candidate(
+                project_name=name,
+                specifier=specifier,
+                hashes=hashes,
+            )
+            icans = list(result.iter_applicable())
+
+            # PEP 592: Yanked releases are ignored unless the specifier
+            # explicitly pins a version (via '==' or '===') that can be
+            # solely satisfied by a yanked release.
+            all_yanked = all(ican.link.is_yanked for ican in icans)
+
+            def is_pinned(specifier: SpecifierSet) -> bool:
+                for sp in specifier:
+                    if sp.operator == "===":
+                        return True
+                    if sp.operator != "==":
+                        continue
+                    if sp.version.endswith(".*"):
+                        continue
+                    return True
+                return False
+
+            pinned = is_pinned(specifier)
+
+            # PackageFinder returns earlier versions first, so we reverse.
+            for ican in reversed(icans):
+                if not (all_yanked and pinned) and ican.link.is_yanked:
+                    continue
+                func = functools.partial(
+                    self._make_candidate_from_link,
+                    link=ican.link,
+                    extras=extras,
+                    template=template,
+                    name=name,
+                    version=ican.version,
+                )
+                yield ican.version, func
+
+        return FoundCandidates(
+            iter_index_candidate_infos,
+            _get_installed_candidate(),
+            prefers_installed,
+            incompatible_ids,
+        )
+
+    def _iter_explicit_candidates_from_base(
+        self,
+        base_requirements: Iterable[Requirement],
+        extras: FrozenSet[str],
+    ) -> Iterator[Candidate]:
+        """Produce explicit candidates from the base given an extra-ed package.
+
+        :param base_requirements: Requirements known to the resolver. The
+            requirements are guaranteed to not have extras.
+        :param extras: The extras to inject into the explicit requirements'
+            candidates.
+        """
+        for req in base_requirements:
+            lookup_cand, _ = req.get_candidate_lookup()
+            if lookup_cand is None:  # Not explicit.
+                continue
+            # We've stripped extras from the identifier, and should always
+            # get a BaseCandidate here, unless there's a bug elsewhere.
+            base_cand = as_base_candidate(lookup_cand)
+            assert base_cand is not None, "no extras here"
+            yield self._make_extras_candidate(base_cand, extras)
+
+    def _iter_candidates_from_constraints(
+        self,
+        identifier: str,
+        constraint: Constraint,
+        template: InstallRequirement,
+    ) -> Iterator[Candidate]:
+        """Produce explicit candidates from constraints.
+
+        This creates "fake" InstallRequirement objects that are basically clones
+        of what "should" be the template, but with original_link set to link.
+        """
+        for link in constraint.links:
+            self._fail_if_link_is_unsupported_wheel(link)
+            candidate = self._make_base_candidate_from_link(
+                link,
+                template=install_req_from_link_and_ireq(link, template),
+                name=canonicalize_name(identifier),
+                version=None,
+            )
+            if candidate:
+                yield candidate
+
+    def find_candidates(
+        self,
+        identifier: str,
+        requirements: Mapping[str, Iterable[Requirement]],
+        incompatibilities: Mapping[str, Iterator[Candidate]],
+        constraint: Constraint,
+        prefers_installed: bool,
+        is_satisfied_by: Callable[[Requirement, Candidate], bool],
+    ) -> Iterable[Candidate]:
+        # Collect basic lookup information from the requirements.
+        explicit_candidates: Set[Candidate] = set()
+        ireqs: List[InstallRequirement] = []
+        for req in requirements[identifier]:
+            cand, ireq = req.get_candidate_lookup()
+            if cand is not None:
+                explicit_candidates.add(cand)
+            if ireq is not None:
+                ireqs.append(ireq)
+
+        # If the current identifier contains extras, add requires and explicit
+        # candidates from entries from extra-less identifier.
+        with contextlib.suppress(InvalidRequirement):
+            parsed_requirement = get_requirement(identifier)
+            if parsed_requirement.name != identifier:
+                explicit_candidates.update(
+                    self._iter_explicit_candidates_from_base(
+                        requirements.get(parsed_requirement.name, ()),
+                        frozenset(parsed_requirement.extras),
+                    ),
+                )
+                for req in requirements.get(parsed_requirement.name, []):
+                    _, ireq = req.get_candidate_lookup()
+                    if ireq is not None:
+                        ireqs.append(ireq)
+
+        # Add explicit candidates from constraints. We only do this if there are
+        # known ireqs, which represent requirements not already explicit. If
+        # there are no ireqs, we're constraining already-explicit requirements,
+        # which is handled later when we return the explicit candidates.
+        if ireqs:
+            try:
+                explicit_candidates.update(
+                    self._iter_candidates_from_constraints(
+                        identifier,
+                        constraint,
+                        template=ireqs[0],
+                    ),
+                )
+            except UnsupportedWheel:
+                # If we're constrained to install a wheel incompatible with the
+                # target architecture, no candidates will ever be valid.
+                return ()
+
+        # Since we cache all the candidates, incompatibility identification
+        # can be made quicker by comparing only the id() values.
+        incompat_ids = {id(c) for c in incompatibilities.get(identifier, ())}
+
+        # If none of the requirements want an explicit candidate, we can ask
+        # the finder for candidates.
+        if not explicit_candidates:
+            return self._iter_found_candidates(
+                ireqs,
+                constraint.specifier,
+                constraint.hashes,
+                prefers_installed,
+                incompat_ids,
+            )
+
+        return (
+            c
+            for c in explicit_candidates
+            if id(c) not in incompat_ids
+            and constraint.is_satisfied_by(c)
+            and all(is_satisfied_by(req, c) for req in requirements[identifier])
+        )
+
+    def _make_requirements_from_install_req(
+        self, ireq: InstallRequirement, requested_extras: Iterable[str]
+    ) -> Iterator[Requirement]:
+        """
+        Returns requirement objects associated with the given InstallRequirement. In
+        most cases this will be a single object but the following special cases exist:
+            - the InstallRequirement has markers that do not apply -> result is empty
+            - the InstallRequirement has both a constraint (or link) and extras
+                -> result is split in two requirement objects: one with the constraint
+                (or link) and one with the extra. This allows centralized constraint
+                handling for the base, resulting in fewer candidate rejections.
+        """
+        if not ireq.match_markers(requested_extras):
+            logger.info(
+                "Ignoring %s: markers '%s' don't match your environment",
+                ireq.name,
+                ireq.markers,
+            )
+        elif not ireq.link:
+            if ireq.extras and ireq.req is not None and ireq.req.specifier:
+                yield SpecifierWithoutExtrasRequirement(ireq)
+            yield SpecifierRequirement(ireq)
+        else:
+            self._fail_if_link_is_unsupported_wheel(ireq.link)
+            # Always make the link candidate for the base requirement to make it
+            # available to `find_candidates` for explicit candidate lookup for any
+            # set of extras.
+            # The extras are required separately via a second requirement.
+            cand = self._make_base_candidate_from_link(
+                ireq.link,
+                template=install_req_drop_extras(ireq) if ireq.extras else ireq,
+                name=canonicalize_name(ireq.name) if ireq.name else None,
+                version=None,
+            )
+            if cand is None:
+                # There's no way we can satisfy a URL requirement if the underlying
+                # candidate fails to build. An unnamed URL must be user-supplied, so
+                # we fail eagerly. If the URL is named, an unsatisfiable requirement
+                # can make the resolver do the right thing, either backtrack (and
+                # maybe find some other requirement that's buildable) or raise a
+                # ResolutionImpossible eventually.
+                if not ireq.name:
+                    raise self._build_failures[ireq.link]
+                yield UnsatisfiableRequirement(canonicalize_name(ireq.name))
+            else:
+                # require the base from the link
+                yield self.make_requirement_from_candidate(cand)
+                if ireq.extras:
+                    # require the extras on top of the base candidate
+                    yield self.make_requirement_from_candidate(
+                        self._make_extras_candidate(cand, frozenset(ireq.extras))
+                    )
+
+    def collect_root_requirements(
+        self, root_ireqs: List[InstallRequirement]
+    ) -> CollectedRootRequirements:
+        collected = CollectedRootRequirements([], {}, {})
+        for i, ireq in enumerate(root_ireqs):
+            if ireq.constraint:
+                # Ensure we only accept valid constraints
+                problem = check_invalid_constraint_type(ireq)
+                if problem:
+                    raise InstallationError(problem)
+                if not ireq.match_markers():
+                    continue
+                assert ireq.name, "Constraint must be named"
+                name = canonicalize_name(ireq.name)
+                if name in collected.constraints:
+                    collected.constraints[name] &= ireq
+                else:
+                    collected.constraints[name] = Constraint.from_ireq(ireq)
+            else:
+                reqs = list(
+                    self._make_requirements_from_install_req(
+                        ireq,
+                        requested_extras=(),
+                    )
+                )
+                if not reqs:
+                    continue
+                template = reqs[0]
+                if ireq.user_supplied and template.name not in collected.user_requested:
+                    collected.user_requested[template.name] = i
+                collected.requirements.extend(reqs)
+        # Put requirements with extras at the end of the root requires. This does not
+        # affect resolvelib's picking preference but it does affect its initial criteria
+        # population: by putting extras at the end we enable the candidate finder to
+        # present resolvelib with a smaller set of candidates to resolvelib, already
+        # taking into account any non-transient constraints on the associated base. This
+        # means resolvelib will have fewer candidates to visit and reject.
+        # Python's list sort is stable, meaning relative order is kept for objects with
+        # the same key.
+        collected.requirements.sort(key=lambda r: r.name != r.project_name)
+        return collected
+
+    def make_requirement_from_candidate(
+        self, candidate: Candidate
+    ) -> ExplicitRequirement:
+        return ExplicitRequirement(candidate)
+
+    def make_requirements_from_spec(
+        self,
+        specifier: str,
+        comes_from: Optional[InstallRequirement],
+        requested_extras: Iterable[str] = (),
+    ) -> Iterator[Requirement]:
+        """
+        Returns requirement objects associated with the given specifier. In most cases
+        this will be a single object but the following special cases exist:
+            - the specifier has markers that do not apply -> result is empty
+            - the specifier has both a constraint and extras -> result is split
+                in two requirement objects: one with the constraint and one with the
+                extra. This allows centralized constraint handling for the base,
+                resulting in fewer candidate rejections.
+        """
+        ireq = self._make_install_req_from_spec(specifier, comes_from)
+        return self._make_requirements_from_install_req(ireq, requested_extras)
+
+    def make_requires_python_requirement(
+        self,
+        specifier: SpecifierSet,
+    ) -> Optional[Requirement]:
+        if self._ignore_requires_python:
+            return None
+        # Don't bother creating a dependency for an empty Requires-Python.
+        if not str(specifier):
+            return None
+        return RequiresPythonRequirement(specifier, self._python_candidate)
+
+    def get_wheel_cache_entry(
+        self, link: Link, name: Optional[str]
+    ) -> Optional[CacheEntry]:
+        """Look up the link in the wheel cache.
+
+        If ``preparer.require_hashes`` is True, don't use the wheel cache,
+        because cached wheels, always built locally, have different hashes
+        than the files downloaded from the index server and thus throw false
+        hash mismatches. Furthermore, cached wheels at present have
+        nondeterministic contents due to file modification times.
+        """
+        if self._wheel_cache is None:
+            return None
+        return self._wheel_cache.get_cache_entry(
+            link=link,
+            package_name=name,
+            supported_tags=self._supported_tags_cache,
+        )
+
+    def get_dist_to_uninstall(self, candidate: Candidate) -> Optional[BaseDistribution]:
+        # TODO: Are there more cases this needs to return True? Editable?
+        dist = self._installed_dists.get(candidate.project_name)
+        if dist is None:  # Not installed, no uninstallation required.
+            return None
+
+        # We're installing into global site. The current installation must
+        # be uninstalled, no matter it's in global or user site, because the
+        # user site installation has precedence over global.
+        if not self._use_user_site:
+            return dist
+
+        # We're installing into user site. Remove the user site installation.
+        if dist.in_usersite:
+            return dist
+
+        # We're installing into user site, but the installed incompatible
+        # package is in global site. We can't uninstall that, and would let
+        # the new user installation to "shadow" it. But shadowing won't work
+        # in virtual environments, so we error out.
+        if running_under_virtualenv() and dist.in_site_packages:
+            message = (
+                f"Will not install to the user site because it will lack "
+                f"sys.path precedence to {dist.raw_name} in {dist.location}"
+            )
+            raise InstallationError(message)
+        return None
+
+    def _report_requires_python_error(
+        self, causes: Sequence["ConflictCause"]
+    ) -> UnsupportedPythonVersion:
+        assert causes, "Requires-Python error reported with no cause"
+
+        version = self._python_candidate.version
+
+        if len(causes) == 1:
+            specifier = str(causes[0].requirement.specifier)
+            message = (
+                f"Package {causes[0].parent.name!r} requires a different "
+                f"Python: {version} not in {specifier!r}"
+            )
+            return UnsupportedPythonVersion(message)
+
+        message = f"Packages require a different Python. {version} not in:"
+        for cause in causes:
+            package = cause.parent.format_for_error()
+            specifier = str(cause.requirement.specifier)
+            message += f"\n{specifier!r} (required by {package})"
+        return UnsupportedPythonVersion(message)
+
+    def _report_single_requirement_conflict(
+        self, req: Requirement, parent: Optional[Candidate]
+    ) -> DistributionNotFound:
+        if parent is None:
+            req_disp = str(req)
+        else:
+            req_disp = f"{req} (from {parent.name})"
+
+        cands = self._finder.find_all_candidates(req.project_name)
+        skipped_by_requires_python = self._finder.requires_python_skipped_reasons()
+
+        versions_set: Set[Version] = set()
+        yanked_versions_set: Set[Version] = set()
+        for c in cands:
+            is_yanked = c.link.is_yanked if c.link else False
+            if is_yanked:
+                yanked_versions_set.add(c.version)
+            else:
+                versions_set.add(c.version)
+
+        versions = [str(v) for v in sorted(versions_set)]
+        yanked_versions = [str(v) for v in sorted(yanked_versions_set)]
+
+        if yanked_versions:
+            # Saying "version X is yanked" isn't entirely accurate.
+            # https://github.com/pypa/pip/issues/11745#issuecomment-1402805842
+            logger.critical(
+                "Ignored the following yanked versions: %s",
+                ", ".join(yanked_versions) or "none",
+            )
+        if skipped_by_requires_python:
+            logger.critical(
+                "Ignored the following versions that require a different python "
+                "version: %s",
+                "; ".join(skipped_by_requires_python) or "none",
+            )
+        logger.critical(
+            "Could not find a version that satisfies the requirement %s "
+            "(from versions: %s)",
+            req_disp,
+            ", ".join(versions) or "none",
+        )
+        if str(req) == "requirements.txt":
+            logger.info(
+                "HINT: You are attempting to install a package literally "
+                'named "requirements.txt" (which cannot exist). Consider '
+                "using the '-r' flag to install the packages listed in "
+                "requirements.txt"
+            )
+
+        return DistributionNotFound(f"No matching distribution found for {req}")
+
+    def get_installation_error(
+        self,
+        e: "ResolutionImpossible[Requirement, Candidate]",
+        constraints: Dict[str, Constraint],
+    ) -> InstallationError:
+        assert e.causes, "Installation error reported with no cause"
+
+        # If one of the things we can't solve is "we need Python X.Y",
+        # that is what we report.
+        requires_python_causes = [
+            cause
+            for cause in e.causes
+            if isinstance(cause.requirement, RequiresPythonRequirement)
+            and not cause.requirement.is_satisfied_by(self._python_candidate)
+        ]
+        if requires_python_causes:
+            # The comprehension above makes sure all Requirement instances are
+            # RequiresPythonRequirement, so let's cast for convenience.
+            return self._report_requires_python_error(
+                cast("Sequence[ConflictCause]", requires_python_causes),
+            )
+
+        # Otherwise, we have a set of causes which can't all be satisfied
+        # at once.
+
+        # The simplest case is when we have *one* cause that can't be
+        # satisfied. We just report that case.
+        if len(e.causes) == 1:
+            req, parent = e.causes[0]
+            if req.name not in constraints:
+                return self._report_single_requirement_conflict(req, parent)
+
+        # OK, we now have a list of requirements that can't all be
+        # satisfied at once.
+
+        # A couple of formatting helpers
+        def text_join(parts: List[str]) -> str:
+            if len(parts) == 1:
+                return parts[0]
+
+            return ", ".join(parts[:-1]) + " and " + parts[-1]
+
+        def describe_trigger(parent: Candidate) -> str:
+            ireq = parent.get_install_requirement()
+            if not ireq or not ireq.comes_from:
+                return f"{parent.name}=={parent.version}"
+            if isinstance(ireq.comes_from, InstallRequirement):
+                return str(ireq.comes_from.name)
+            return str(ireq.comes_from)
+
+        triggers = set()
+        for req, parent in e.causes:
+            if parent is None:
+                # This is a root requirement, so we can report it directly
+                trigger = req.format_for_error()
+            else:
+                trigger = describe_trigger(parent)
+            triggers.add(trigger)
+
+        if triggers:
+            info = text_join(sorted(triggers))
+        else:
+            info = "the requested packages"
+
+        msg = (
+            f"Cannot install {info} because these package versions "
+            "have conflicting dependencies."
+        )
+        logger.critical(msg)
+        msg = "\nThe conflict is caused by:"
+
+        relevant_constraints = set()
+        for req, parent in e.causes:
+            if req.name in constraints:
+                relevant_constraints.add(req.name)
+            msg = msg + "\n    "
+            if parent:
+                msg = msg + f"{parent.name} {parent.version} depends on "
+            else:
+                msg = msg + "The user requested "
+            msg = msg + req.format_for_error()
+        for key in relevant_constraints:
+            spec = constraints[key].specifier
+            msg += f"\n    The user requested (constraint) {key}{spec}"
+
+        msg = (
+            msg
+            + "\n\n"
+            + "To fix this you could try to:\n"
+            + "1. loosen the range of package versions you've specified\n"
+            + "2. remove package versions to allow pip to attempt to solve "
+            + "the dependency conflict\n"
+        )
+
+        logger.info(msg)
+
+        return DistributionNotFound(
+            "ResolutionImpossible: for help visit "
+            "https://pip.pypa.io/en/latest/topics/dependency-resolution/"
+            "#dealing-with-dependency-conflicts"
+        )
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/resolution/resolvelib/found_candidates.py b/venv/lib/python3.12/site-packages/pip/_internal/resolution/resolvelib/found_candidates.py
new file mode 100644
index 00000000..a1d57e0f
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/resolution/resolvelib/found_candidates.py
@@ -0,0 +1,174 @@
+"""Utilities to lazily create and visit candidates found.
+
+Creating and visiting a candidate is a *very* costly operation. It involves
+fetching, extracting, potentially building modules from source, and verifying
+distribution metadata. It is therefore crucial for performance to keep
+everything here lazy all the way down, so we only touch candidates that we
+absolutely need, and not "download the world" when we only need one version of
+something.
+"""
+
+import functools
+import logging
+from collections.abc import Sequence
+from typing import TYPE_CHECKING, Any, Callable, Iterator, Optional, Set, Tuple
+
+from pip._vendor.packaging.version import _BaseVersion
+
+from pip._internal.exceptions import MetadataInvalid
+
+from .base import Candidate
+
+logger = logging.getLogger(__name__)
+
+IndexCandidateInfo = Tuple[_BaseVersion, Callable[[], Optional[Candidate]]]
+
+if TYPE_CHECKING:
+    SequenceCandidate = Sequence[Candidate]
+else:
+    # For compatibility: Python before 3.9 does not support using [] on the
+    # Sequence class.
+    #
+    # >>> from collections.abc import Sequence
+    # >>> Sequence[str]
+    # Traceback (most recent call last):
+    #   File "", line 1, in 
+    # TypeError: 'ABCMeta' object is not subscriptable
+    #
+    # TODO: Remove this block after dropping Python 3.8 support.
+    SequenceCandidate = Sequence
+
+
+def _iter_built(infos: Iterator[IndexCandidateInfo]) -> Iterator[Candidate]:
+    """Iterator for ``FoundCandidates``.
+
+    This iterator is used when the package is not already installed. Candidates
+    from index come later in their normal ordering.
+    """
+    versions_found: Set[_BaseVersion] = set()
+    for version, func in infos:
+        if version in versions_found:
+            continue
+        try:
+            candidate = func()
+        except MetadataInvalid as e:
+            logger.warning(
+                "Ignoring version %s of %s since it has invalid metadata:\n"
+                "%s\n"
+                "Please use pip<24.1 if you need to use this version.",
+                version,
+                e.ireq.name,
+                e,
+            )
+            # Mark version as found to avoid trying other candidates with the same
+            # version, since they most likely have invalid metadata as well.
+            versions_found.add(version)
+        else:
+            if candidate is None:
+                continue
+            yield candidate
+            versions_found.add(version)
+
+
+def _iter_built_with_prepended(
+    installed: Candidate, infos: Iterator[IndexCandidateInfo]
+) -> Iterator[Candidate]:
+    """Iterator for ``FoundCandidates``.
+
+    This iterator is used when the resolver prefers the already-installed
+    candidate and NOT to upgrade. The installed candidate is therefore
+    always yielded first, and candidates from index come later in their
+    normal ordering, except skipped when the version is already installed.
+    """
+    yield installed
+    versions_found: Set[_BaseVersion] = {installed.version}
+    for version, func in infos:
+        if version in versions_found:
+            continue
+        candidate = func()
+        if candidate is None:
+            continue
+        yield candidate
+        versions_found.add(version)
+
+
+def _iter_built_with_inserted(
+    installed: Candidate, infos: Iterator[IndexCandidateInfo]
+) -> Iterator[Candidate]:
+    """Iterator for ``FoundCandidates``.
+
+    This iterator is used when the resolver prefers to upgrade an
+    already-installed package. Candidates from index are returned in their
+    normal ordering, except replaced when the version is already installed.
+
+    The implementation iterates through and yields other candidates, inserting
+    the installed candidate exactly once before we start yielding older or
+    equivalent candidates, or after all other candidates if they are all newer.
+    """
+    versions_found: Set[_BaseVersion] = set()
+    for version, func in infos:
+        if version in versions_found:
+            continue
+        # If the installed candidate is better, yield it first.
+        if installed.version >= version:
+            yield installed
+            versions_found.add(installed.version)
+        candidate = func()
+        if candidate is None:
+            continue
+        yield candidate
+        versions_found.add(version)
+
+    # If the installed candidate is older than all other candidates.
+    if installed.version not in versions_found:
+        yield installed
+
+
+class FoundCandidates(SequenceCandidate):
+    """A lazy sequence to provide candidates to the resolver.
+
+    The intended usage is to return this from `find_matches()` so the resolver
+    can iterate through the sequence multiple times, but only access the index
+    page when remote packages are actually needed. This improve performances
+    when suitable candidates are already installed on disk.
+    """
+
+    def __init__(
+        self,
+        get_infos: Callable[[], Iterator[IndexCandidateInfo]],
+        installed: Optional[Candidate],
+        prefers_installed: bool,
+        incompatible_ids: Set[int],
+    ):
+        self._get_infos = get_infos
+        self._installed = installed
+        self._prefers_installed = prefers_installed
+        self._incompatible_ids = incompatible_ids
+
+    def __getitem__(self, index: Any) -> Any:
+        # Implemented to satisfy the ABC check. This is not needed by the
+        # resolver, and should not be used by the provider either (for
+        # performance reasons).
+        raise NotImplementedError("don't do this")
+
+    def __iter__(self) -> Iterator[Candidate]:
+        infos = self._get_infos()
+        if not self._installed:
+            iterator = _iter_built(infos)
+        elif self._prefers_installed:
+            iterator = _iter_built_with_prepended(self._installed, infos)
+        else:
+            iterator = _iter_built_with_inserted(self._installed, infos)
+        return (c for c in iterator if id(c) not in self._incompatible_ids)
+
+    def __len__(self) -> int:
+        # Implemented to satisfy the ABC check. This is not needed by the
+        # resolver, and should not be used by the provider either (for
+        # performance reasons).
+        raise NotImplementedError("don't do this")
+
+    @functools.lru_cache(maxsize=1)
+    def __bool__(self) -> bool:
+        if self._prefers_installed and self._installed:
+            return True
+        return any(self)
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/resolution/resolvelib/provider.py b/venv/lib/python3.12/site-packages/pip/_internal/resolution/resolvelib/provider.py
new file mode 100644
index 00000000..fb0dd85f
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/resolution/resolvelib/provider.py
@@ -0,0 +1,258 @@
+import collections
+import math
+from functools import lru_cache
+from typing import (
+    TYPE_CHECKING,
+    Dict,
+    Iterable,
+    Iterator,
+    Mapping,
+    Sequence,
+    TypeVar,
+    Union,
+)
+
+from pip._vendor.resolvelib.providers import AbstractProvider
+
+from .base import Candidate, Constraint, Requirement
+from .candidates import REQUIRES_PYTHON_IDENTIFIER
+from .factory import Factory
+
+if TYPE_CHECKING:
+    from pip._vendor.resolvelib.providers import Preference
+    from pip._vendor.resolvelib.resolvers import RequirementInformation
+
+    PreferenceInformation = RequirementInformation[Requirement, Candidate]
+
+    _ProviderBase = AbstractProvider[Requirement, Candidate, str]
+else:
+    _ProviderBase = AbstractProvider
+
+# Notes on the relationship between the provider, the factory, and the
+# candidate and requirement classes.
+#
+# The provider is a direct implementation of the resolvelib class. Its role
+# is to deliver the API that resolvelib expects.
+#
+# Rather than work with completely abstract "requirement" and "candidate"
+# concepts as resolvelib does, pip has concrete classes implementing these two
+# ideas. The API of Requirement and Candidate objects are defined in the base
+# classes, but essentially map fairly directly to the equivalent provider
+# methods. In particular, `find_matches` and `is_satisfied_by` are
+# requirement methods, and `get_dependencies` is a candidate method.
+#
+# The factory is the interface to pip's internal mechanisms. It is stateless,
+# and is created by the resolver and held as a property of the provider. It is
+# responsible for creating Requirement and Candidate objects, and provides
+# services to those objects (access to pip's finder and preparer).
+
+
+D = TypeVar("D")
+V = TypeVar("V")
+
+
+def _get_with_identifier(
+    mapping: Mapping[str, V],
+    identifier: str,
+    default: D,
+) -> Union[D, V]:
+    """Get item from a package name lookup mapping with a resolver identifier.
+
+    This extra logic is needed when the target mapping is keyed by package
+    name, which cannot be directly looked up with an identifier (which may
+    contain requested extras). Additional logic is added to also look up a value
+    by "cleaning up" the extras from the identifier.
+    """
+    if identifier in mapping:
+        return mapping[identifier]
+    # HACK: Theoretically we should check whether this identifier is a valid
+    # "NAME[EXTRAS]" format, and parse out the name part with packaging or
+    # some regular expression. But since pip's resolver only spits out three
+    # kinds of identifiers: normalized PEP 503 names, normalized names plus
+    # extras, and Requires-Python, we can cheat a bit here.
+    name, open_bracket, _ = identifier.partition("[")
+    if open_bracket and name in mapping:
+        return mapping[name]
+    return default
+
+
+class PipProvider(_ProviderBase):
+    """Pip's provider implementation for resolvelib.
+
+    :params constraints: A mapping of constraints specified by the user. Keys
+        are canonicalized project names.
+    :params ignore_dependencies: Whether the user specified ``--no-deps``.
+    :params upgrade_strategy: The user-specified upgrade strategy.
+    :params user_requested: A set of canonicalized package names that the user
+        supplied for pip to install/upgrade.
+    """
+
+    def __init__(
+        self,
+        factory: Factory,
+        constraints: Dict[str, Constraint],
+        ignore_dependencies: bool,
+        upgrade_strategy: str,
+        user_requested: Dict[str, int],
+    ) -> None:
+        self._factory = factory
+        self._constraints = constraints
+        self._ignore_dependencies = ignore_dependencies
+        self._upgrade_strategy = upgrade_strategy
+        self._user_requested = user_requested
+        self._known_depths: Dict[str, float] = collections.defaultdict(lambda: math.inf)
+
+    def identify(self, requirement_or_candidate: Union[Requirement, Candidate]) -> str:
+        return requirement_or_candidate.name
+
+    def get_preference(
+        self,
+        identifier: str,
+        resolutions: Mapping[str, Candidate],
+        candidates: Mapping[str, Iterator[Candidate]],
+        information: Mapping[str, Iterable["PreferenceInformation"]],
+        backtrack_causes: Sequence["PreferenceInformation"],
+    ) -> "Preference":
+        """Produce a sort key for given requirement based on preference.
+
+        The lower the return value is, the more preferred this group of
+        arguments is.
+
+        Currently pip considers the following in order:
+
+        * Prefer if any of the known requirements is "direct", e.g. points to an
+          explicit URL.
+        * If equal, prefer if any requirement is "pinned", i.e. contains
+          operator ``===`` or ``==``.
+        * If equal, calculate an approximate "depth" and resolve requirements
+          closer to the user-specified requirements first. If the depth cannot
+          by determined (eg: due to no matching parents), it is considered
+          infinite.
+        * Order user-specified requirements by the order they are specified.
+        * If equal, prefers "non-free" requirements, i.e. contains at least one
+          operator, such as ``>=`` or ``<``.
+        * If equal, order alphabetically for consistency (helps debuggability).
+        """
+        try:
+            next(iter(information[identifier]))
+        except StopIteration:
+            # There is no information for this identifier, so there's no known
+            # candidates.
+            has_information = False
+        else:
+            has_information = True
+
+        if has_information:
+            lookups = (r.get_candidate_lookup() for r, _ in information[identifier])
+            candidate, ireqs = zip(*lookups)
+        else:
+            candidate, ireqs = None, ()
+
+        operators = [
+            specifier.operator
+            for specifier_set in (ireq.specifier for ireq in ireqs if ireq)
+            for specifier in specifier_set
+        ]
+
+        direct = candidate is not None
+        pinned = any(op[:2] == "==" for op in operators)
+        unfree = bool(operators)
+
+        try:
+            requested_order: Union[int, float] = self._user_requested[identifier]
+        except KeyError:
+            requested_order = math.inf
+            if has_information:
+                parent_depths = (
+                    self._known_depths[parent.name] if parent is not None else 0.0
+                    for _, parent in information[identifier]
+                )
+                inferred_depth = min(d for d in parent_depths) + 1.0
+            else:
+                inferred_depth = math.inf
+        else:
+            inferred_depth = 1.0
+        self._known_depths[identifier] = inferred_depth
+
+        requested_order = self._user_requested.get(identifier, math.inf)
+
+        # Requires-Python has only one candidate and the check is basically
+        # free, so we always do it first to avoid needless work if it fails.
+        requires_python = identifier == REQUIRES_PYTHON_IDENTIFIER
+
+        # Prefer the causes of backtracking on the assumption that the problem
+        # resolving the dependency tree is related to the failures that caused
+        # the backtracking
+        backtrack_cause = self.is_backtrack_cause(identifier, backtrack_causes)
+
+        return (
+            not requires_python,
+            not direct,
+            not pinned,
+            not backtrack_cause,
+            inferred_depth,
+            requested_order,
+            not unfree,
+            identifier,
+        )
+
+    def find_matches(
+        self,
+        identifier: str,
+        requirements: Mapping[str, Iterator[Requirement]],
+        incompatibilities: Mapping[str, Iterator[Candidate]],
+    ) -> Iterable[Candidate]:
+        def _eligible_for_upgrade(identifier: str) -> bool:
+            """Are upgrades allowed for this project?
+
+            This checks the upgrade strategy, and whether the project was one
+            that the user specified in the command line, in order to decide
+            whether we should upgrade if there's a newer version available.
+
+            (Note that we don't need access to the `--upgrade` flag, because
+            an upgrade strategy of "to-satisfy-only" means that `--upgrade`
+            was not specified).
+            """
+            if self._upgrade_strategy == "eager":
+                return True
+            elif self._upgrade_strategy == "only-if-needed":
+                user_order = _get_with_identifier(
+                    self._user_requested,
+                    identifier,
+                    default=None,
+                )
+                return user_order is not None
+            return False
+
+        constraint = _get_with_identifier(
+            self._constraints,
+            identifier,
+            default=Constraint.empty(),
+        )
+        return self._factory.find_candidates(
+            identifier=identifier,
+            requirements=requirements,
+            constraint=constraint,
+            prefers_installed=(not _eligible_for_upgrade(identifier)),
+            incompatibilities=incompatibilities,
+            is_satisfied_by=self.is_satisfied_by,
+        )
+
+    @lru_cache(maxsize=None)
+    def is_satisfied_by(self, requirement: Requirement, candidate: Candidate) -> bool:
+        return requirement.is_satisfied_by(candidate)
+
+    def get_dependencies(self, candidate: Candidate) -> Sequence[Requirement]:
+        with_requires = not self._ignore_dependencies
+        return [r for r in candidate.iter_dependencies(with_requires) if r is not None]
+
+    @staticmethod
+    def is_backtrack_cause(
+        identifier: str, backtrack_causes: Sequence["PreferenceInformation"]
+    ) -> bool:
+        for backtrack_cause in backtrack_causes:
+            if identifier == backtrack_cause.requirement.name:
+                return True
+            if backtrack_cause.parent and identifier == backtrack_cause.parent.name:
+                return True
+        return False
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/resolution/resolvelib/reporter.py b/venv/lib/python3.12/site-packages/pip/_internal/resolution/resolvelib/reporter.py
new file mode 100644
index 00000000..0594569d
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/resolution/resolvelib/reporter.py
@@ -0,0 +1,81 @@
+from collections import defaultdict
+from logging import getLogger
+from typing import Any, DefaultDict
+
+from pip._vendor.resolvelib.reporters import BaseReporter
+
+from .base import Candidate, Requirement
+
+logger = getLogger(__name__)
+
+
+class PipReporter(BaseReporter):
+    def __init__(self) -> None:
+        self.reject_count_by_package: DefaultDict[str, int] = defaultdict(int)
+
+        self._messages_at_reject_count = {
+            1: (
+                "pip is looking at multiple versions of {package_name} to "
+                "determine which version is compatible with other "
+                "requirements. This could take a while."
+            ),
+            8: (
+                "pip is still looking at multiple versions of {package_name} to "
+                "determine which version is compatible with other "
+                "requirements. This could take a while."
+            ),
+            13: (
+                "This is taking longer than usual. You might need to provide "
+                "the dependency resolver with stricter constraints to reduce "
+                "runtime. See https://pip.pypa.io/warnings/backtracking for "
+                "guidance. If you want to abort this run, press Ctrl + C."
+            ),
+        }
+
+    def rejecting_candidate(self, criterion: Any, candidate: Candidate) -> None:
+        self.reject_count_by_package[candidate.name] += 1
+
+        count = self.reject_count_by_package[candidate.name]
+        if count not in self._messages_at_reject_count:
+            return
+
+        message = self._messages_at_reject_count[count]
+        logger.info("INFO: %s", message.format(package_name=candidate.name))
+
+        msg = "Will try a different candidate, due to conflict:"
+        for req_info in criterion.information:
+            req, parent = req_info.requirement, req_info.parent
+            # Inspired by Factory.get_installation_error
+            msg += "\n    "
+            if parent:
+                msg += f"{parent.name} {parent.version} depends on "
+            else:
+                msg += "The user requested "
+            msg += req.format_for_error()
+        logger.debug(msg)
+
+
+class PipDebuggingReporter(BaseReporter):
+    """A reporter that does an info log for every event it sees."""
+
+    def starting(self) -> None:
+        logger.info("Reporter.starting()")
+
+    def starting_round(self, index: int) -> None:
+        logger.info("Reporter.starting_round(%r)", index)
+
+    def ending_round(self, index: int, state: Any) -> None:
+        logger.info("Reporter.ending_round(%r, state)", index)
+        logger.debug("Reporter.ending_round(%r, %r)", index, state)
+
+    def ending(self, state: Any) -> None:
+        logger.info("Reporter.ending(%r)", state)
+
+    def adding_requirement(self, requirement: Requirement, parent: Candidate) -> None:
+        logger.info("Reporter.adding_requirement(%r, %r)", requirement, parent)
+
+    def rejecting_candidate(self, criterion: Any, candidate: Candidate) -> None:
+        logger.info("Reporter.rejecting_candidate(%r, %r)", criterion, candidate)
+
+    def pinning(self, candidate: Candidate) -> None:
+        logger.info("Reporter.pinning(%r)", candidate)
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/resolution/resolvelib/requirements.py b/venv/lib/python3.12/site-packages/pip/_internal/resolution/resolvelib/requirements.py
new file mode 100644
index 00000000..b04f41b2
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/resolution/resolvelib/requirements.py
@@ -0,0 +1,245 @@
+from typing import Any, Optional
+
+from pip._vendor.packaging.specifiers import SpecifierSet
+from pip._vendor.packaging.utils import NormalizedName, canonicalize_name
+
+from pip._internal.req.constructors import install_req_drop_extras
+from pip._internal.req.req_install import InstallRequirement
+
+from .base import Candidate, CandidateLookup, Requirement, format_name
+
+
+class ExplicitRequirement(Requirement):
+    def __init__(self, candidate: Candidate) -> None:
+        self.candidate = candidate
+
+    def __str__(self) -> str:
+        return str(self.candidate)
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}({self.candidate!r})"
+
+    def __hash__(self) -> int:
+        return hash(self.candidate)
+
+    def __eq__(self, other: Any) -> bool:
+        if not isinstance(other, ExplicitRequirement):
+            return False
+        return self.candidate == other.candidate
+
+    @property
+    def project_name(self) -> NormalizedName:
+        # No need to canonicalize - the candidate did this
+        return self.candidate.project_name
+
+    @property
+    def name(self) -> str:
+        # No need to canonicalize - the candidate did this
+        return self.candidate.name
+
+    def format_for_error(self) -> str:
+        return self.candidate.format_for_error()
+
+    def get_candidate_lookup(self) -> CandidateLookup:
+        return self.candidate, None
+
+    def is_satisfied_by(self, candidate: Candidate) -> bool:
+        return candidate == self.candidate
+
+
+class SpecifierRequirement(Requirement):
+    def __init__(self, ireq: InstallRequirement) -> None:
+        assert ireq.link is None, "This is a link, not a specifier"
+        self._ireq = ireq
+        self._equal_cache: Optional[str] = None
+        self._hash: Optional[int] = None
+        self._extras = frozenset(canonicalize_name(e) for e in self._ireq.extras)
+
+    @property
+    def _equal(self) -> str:
+        if self._equal_cache is not None:
+            return self._equal_cache
+
+        self._equal_cache = str(self._ireq)
+        return self._equal_cache
+
+    def __str__(self) -> str:
+        return str(self._ireq.req)
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}({str(self._ireq.req)!r})"
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, SpecifierRequirement):
+            return NotImplemented
+        return self._equal == other._equal
+
+    def __hash__(self) -> int:
+        if self._hash is not None:
+            return self._hash
+
+        self._hash = hash(self._equal)
+        return self._hash
+
+    @property
+    def project_name(self) -> NormalizedName:
+        assert self._ireq.req, "Specifier-backed ireq is always PEP 508"
+        return canonicalize_name(self._ireq.req.name)
+
+    @property
+    def name(self) -> str:
+        return format_name(self.project_name, self._extras)
+
+    def format_for_error(self) -> str:
+        # Convert comma-separated specifiers into "A, B, ..., F and G"
+        # This makes the specifier a bit more "human readable", without
+        # risking a change in meaning. (Hopefully! Not all edge cases have
+        # been checked)
+        parts = [s.strip() for s in str(self).split(",")]
+        if len(parts) == 0:
+            return ""
+        elif len(parts) == 1:
+            return parts[0]
+
+        return ", ".join(parts[:-1]) + " and " + parts[-1]
+
+    def get_candidate_lookup(self) -> CandidateLookup:
+        return None, self._ireq
+
+    def is_satisfied_by(self, candidate: Candidate) -> bool:
+        assert candidate.name == self.name, (
+            f"Internal issue: Candidate is not for this requirement "
+            f"{candidate.name} vs {self.name}"
+        )
+        # We can safely always allow prereleases here since PackageFinder
+        # already implements the prerelease logic, and would have filtered out
+        # prerelease candidates if the user does not expect them.
+        assert self._ireq.req, "Specifier-backed ireq is always PEP 508"
+        spec = self._ireq.req.specifier
+        return spec.contains(candidate.version, prereleases=True)
+
+
+class SpecifierWithoutExtrasRequirement(SpecifierRequirement):
+    """
+    Requirement backed by an install requirement on a base package.
+    Trims extras from its install requirement if there are any.
+    """
+
+    def __init__(self, ireq: InstallRequirement) -> None:
+        assert ireq.link is None, "This is a link, not a specifier"
+        self._ireq = install_req_drop_extras(ireq)
+        self._equal_cache: Optional[str] = None
+        self._hash: Optional[int] = None
+        self._extras = frozenset(canonicalize_name(e) for e in self._ireq.extras)
+
+    @property
+    def _equal(self) -> str:
+        if self._equal_cache is not None:
+            return self._equal_cache
+
+        self._equal_cache = str(self._ireq)
+        return self._equal_cache
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, SpecifierWithoutExtrasRequirement):
+            return NotImplemented
+        return self._equal == other._equal
+
+    def __hash__(self) -> int:
+        if self._hash is not None:
+            return self._hash
+
+        self._hash = hash(self._equal)
+        return self._hash
+
+
+class RequiresPythonRequirement(Requirement):
+    """A requirement representing Requires-Python metadata."""
+
+    def __init__(self, specifier: SpecifierSet, match: Candidate) -> None:
+        self.specifier = specifier
+        self._specifier_string = str(specifier)  # for faster __eq__
+        self._hash: Optional[int] = None
+        self._candidate = match
+
+    def __str__(self) -> str:
+        return f"Python {self.specifier}"
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}({str(self.specifier)!r})"
+
+    def __hash__(self) -> int:
+        if self._hash is not None:
+            return self._hash
+
+        self._hash = hash((self._specifier_string, self._candidate))
+        return self._hash
+
+    def __eq__(self, other: Any) -> bool:
+        if not isinstance(other, RequiresPythonRequirement):
+            return False
+        return (
+            self._specifier_string == other._specifier_string
+            and self._candidate == other._candidate
+        )
+
+    @property
+    def project_name(self) -> NormalizedName:
+        return self._candidate.project_name
+
+    @property
+    def name(self) -> str:
+        return self._candidate.name
+
+    def format_for_error(self) -> str:
+        return str(self)
+
+    def get_candidate_lookup(self) -> CandidateLookup:
+        if self.specifier.contains(self._candidate.version, prereleases=True):
+            return self._candidate, None
+        return None, None
+
+    def is_satisfied_by(self, candidate: Candidate) -> bool:
+        assert candidate.name == self._candidate.name, "Not Python candidate"
+        # We can safely always allow prereleases here since PackageFinder
+        # already implements the prerelease logic, and would have filtered out
+        # prerelease candidates if the user does not expect them.
+        return self.specifier.contains(candidate.version, prereleases=True)
+
+
+class UnsatisfiableRequirement(Requirement):
+    """A requirement that cannot be satisfied."""
+
+    def __init__(self, name: NormalizedName) -> None:
+        self._name = name
+
+    def __str__(self) -> str:
+        return f"{self._name} (unavailable)"
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}({str(self._name)!r})"
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, UnsatisfiableRequirement):
+            return NotImplemented
+        return self._name == other._name
+
+    def __hash__(self) -> int:
+        return hash(self._name)
+
+    @property
+    def project_name(self) -> NormalizedName:
+        return self._name
+
+    @property
+    def name(self) -> str:
+        return self._name
+
+    def format_for_error(self) -> str:
+        return str(self)
+
+    def get_candidate_lookup(self) -> CandidateLookup:
+        return None, None
+
+    def is_satisfied_by(self, candidate: Candidate) -> bool:
+        return False
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/resolution/resolvelib/resolver.py b/venv/lib/python3.12/site-packages/pip/_internal/resolution/resolvelib/resolver.py
new file mode 100644
index 00000000..c12beef0
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/resolution/resolvelib/resolver.py
@@ -0,0 +1,317 @@
+import contextlib
+import functools
+import logging
+import os
+from typing import TYPE_CHECKING, Dict, List, Optional, Set, Tuple, cast
+
+from pip._vendor.packaging.utils import canonicalize_name
+from pip._vendor.resolvelib import BaseReporter, ResolutionImpossible
+from pip._vendor.resolvelib import Resolver as RLResolver
+from pip._vendor.resolvelib.structs import DirectedGraph
+
+from pip._internal.cache import WheelCache
+from pip._internal.index.package_finder import PackageFinder
+from pip._internal.operations.prepare import RequirementPreparer
+from pip._internal.req.constructors import install_req_extend_extras
+from pip._internal.req.req_install import InstallRequirement
+from pip._internal.req.req_set import RequirementSet
+from pip._internal.resolution.base import BaseResolver, InstallRequirementProvider
+from pip._internal.resolution.resolvelib.provider import PipProvider
+from pip._internal.resolution.resolvelib.reporter import (
+    PipDebuggingReporter,
+    PipReporter,
+)
+from pip._internal.utils.packaging import get_requirement
+
+from .base import Candidate, Requirement
+from .factory import Factory
+
+if TYPE_CHECKING:
+    from pip._vendor.resolvelib.resolvers import Result as RLResult
+
+    Result = RLResult[Requirement, Candidate, str]
+
+
+logger = logging.getLogger(__name__)
+
+
+class Resolver(BaseResolver):
+    _allowed_strategies = {"eager", "only-if-needed", "to-satisfy-only"}
+
+    def __init__(
+        self,
+        preparer: RequirementPreparer,
+        finder: PackageFinder,
+        wheel_cache: Optional[WheelCache],
+        make_install_req: InstallRequirementProvider,
+        use_user_site: bool,
+        ignore_dependencies: bool,
+        ignore_installed: bool,
+        ignore_requires_python: bool,
+        force_reinstall: bool,
+        upgrade_strategy: str,
+        py_version_info: Optional[Tuple[int, ...]] = None,
+    ):
+        super().__init__()
+        assert upgrade_strategy in self._allowed_strategies
+
+        self.factory = Factory(
+            finder=finder,
+            preparer=preparer,
+            make_install_req=make_install_req,
+            wheel_cache=wheel_cache,
+            use_user_site=use_user_site,
+            force_reinstall=force_reinstall,
+            ignore_installed=ignore_installed,
+            ignore_requires_python=ignore_requires_python,
+            py_version_info=py_version_info,
+        )
+        self.ignore_dependencies = ignore_dependencies
+        self.upgrade_strategy = upgrade_strategy
+        self._result: Optional[Result] = None
+
+    def resolve(
+        self, root_reqs: List[InstallRequirement], check_supported_wheels: bool
+    ) -> RequirementSet:
+        collected = self.factory.collect_root_requirements(root_reqs)
+        provider = PipProvider(
+            factory=self.factory,
+            constraints=collected.constraints,
+            ignore_dependencies=self.ignore_dependencies,
+            upgrade_strategy=self.upgrade_strategy,
+            user_requested=collected.user_requested,
+        )
+        if "PIP_RESOLVER_DEBUG" in os.environ:
+            reporter: BaseReporter = PipDebuggingReporter()
+        else:
+            reporter = PipReporter()
+        resolver: RLResolver[Requirement, Candidate, str] = RLResolver(
+            provider,
+            reporter,
+        )
+
+        try:
+            limit_how_complex_resolution_can_be = 200000
+            result = self._result = resolver.resolve(
+                collected.requirements, max_rounds=limit_how_complex_resolution_can_be
+            )
+
+        except ResolutionImpossible as e:
+            error = self.factory.get_installation_error(
+                cast("ResolutionImpossible[Requirement, Candidate]", e),
+                collected.constraints,
+            )
+            raise error from e
+
+        req_set = RequirementSet(check_supported_wheels=check_supported_wheels)
+        # process candidates with extras last to ensure their base equivalent is
+        # already in the req_set if appropriate.
+        # Python's sort is stable so using a binary key function keeps relative order
+        # within both subsets.
+        for candidate in sorted(
+            result.mapping.values(), key=lambda c: c.name != c.project_name
+        ):
+            ireq = candidate.get_install_requirement()
+            if ireq is None:
+                if candidate.name != candidate.project_name:
+                    # extend existing req's extras
+                    with contextlib.suppress(KeyError):
+                        req = req_set.get_requirement(candidate.project_name)
+                        req_set.add_named_requirement(
+                            install_req_extend_extras(
+                                req, get_requirement(candidate.name).extras
+                            )
+                        )
+                continue
+
+            # Check if there is already an installation under the same name,
+            # and set a flag for later stages to uninstall it, if needed.
+            installed_dist = self.factory.get_dist_to_uninstall(candidate)
+            if installed_dist is None:
+                # There is no existing installation -- nothing to uninstall.
+                ireq.should_reinstall = False
+            elif self.factory.force_reinstall:
+                # The --force-reinstall flag is set -- reinstall.
+                ireq.should_reinstall = True
+            elif installed_dist.version != candidate.version:
+                # The installation is different in version -- reinstall.
+                ireq.should_reinstall = True
+            elif candidate.is_editable or installed_dist.editable:
+                # The incoming distribution is editable, or different in
+                # editable-ness to installation -- reinstall.
+                ireq.should_reinstall = True
+            elif candidate.source_link and candidate.source_link.is_file:
+                # The incoming distribution is under file://
+                if candidate.source_link.is_wheel:
+                    # is a local wheel -- do nothing.
+                    logger.info(
+                        "%s is already installed with the same version as the "
+                        "provided wheel. Use --force-reinstall to force an "
+                        "installation of the wheel.",
+                        ireq.name,
+                    )
+                    continue
+
+                # is a local sdist or path -- reinstall
+                ireq.should_reinstall = True
+            else:
+                continue
+
+            link = candidate.source_link
+            if link and link.is_yanked:
+                # The reason can contain non-ASCII characters, Unicode
+                # is required for Python 2.
+                msg = (
+                    "The candidate selected for download or install is a "
+                    "yanked version: {name!r} candidate (version {version} "
+                    "at {link})\nReason for being yanked: {reason}"
+                ).format(
+                    name=candidate.name,
+                    version=candidate.version,
+                    link=link,
+                    reason=link.yanked_reason or "",
+                )
+                logger.warning(msg)
+
+            req_set.add_named_requirement(ireq)
+
+        reqs = req_set.all_requirements
+        self.factory.preparer.prepare_linked_requirements_more(reqs)
+        for req in reqs:
+            req.prepared = True
+            req.needs_more_preparation = False
+        return req_set
+
+    def get_installation_order(
+        self, req_set: RequirementSet
+    ) -> List[InstallRequirement]:
+        """Get order for installation of requirements in RequirementSet.
+
+        The returned list contains a requirement before another that depends on
+        it. This helps ensure that the environment is kept consistent as they
+        get installed one-by-one.
+
+        The current implementation creates a topological ordering of the
+        dependency graph, giving more weight to packages with less
+        or no dependencies, while breaking any cycles in the graph at
+        arbitrary points. We make no guarantees about where the cycle
+        would be broken, other than it *would* be broken.
+        """
+        assert self._result is not None, "must call resolve() first"
+
+        if not req_set.requirements:
+            # Nothing is left to install, so we do not need an order.
+            return []
+
+        graph = self._result.graph
+        weights = get_topological_weights(graph, set(req_set.requirements.keys()))
+
+        sorted_items = sorted(
+            req_set.requirements.items(),
+            key=functools.partial(_req_set_item_sorter, weights=weights),
+            reverse=True,
+        )
+        return [ireq for _, ireq in sorted_items]
+
+
+def get_topological_weights(
+    graph: "DirectedGraph[Optional[str]]", requirement_keys: Set[str]
+) -> Dict[Optional[str], int]:
+    """Assign weights to each node based on how "deep" they are.
+
+    This implementation may change at any point in the future without prior
+    notice.
+
+    We first simplify the dependency graph by pruning any leaves and giving them
+    the highest weight: a package without any dependencies should be installed
+    first. This is done again and again in the same way, giving ever less weight
+    to the newly found leaves. The loop stops when no leaves are left: all
+    remaining packages have at least one dependency left in the graph.
+
+    Then we continue with the remaining graph, by taking the length for the
+    longest path to any node from root, ignoring any paths that contain a single
+    node twice (i.e. cycles). This is done through a depth-first search through
+    the graph, while keeping track of the path to the node.
+
+    Cycles in the graph result would result in node being revisited while also
+    being on its own path. In this case, take no action. This helps ensure we
+    don't get stuck in a cycle.
+
+    When assigning weight, the longer path (i.e. larger length) is preferred.
+
+    We are only interested in the weights of packages that are in the
+    requirement_keys.
+    """
+    path: Set[Optional[str]] = set()
+    weights: Dict[Optional[str], int] = {}
+
+    def visit(node: Optional[str]) -> None:
+        if node in path:
+            # We hit a cycle, so we'll break it here.
+            return
+
+        # Time to visit the children!
+        path.add(node)
+        for child in graph.iter_children(node):
+            visit(child)
+        path.remove(node)
+
+        if node not in requirement_keys:
+            return
+
+        last_known_parent_count = weights.get(node, 0)
+        weights[node] = max(last_known_parent_count, len(path))
+
+    # Simplify the graph, pruning leaves that have no dependencies.
+    # This is needed for large graphs (say over 200 packages) because the
+    # `visit` function is exponentially slower then, taking minutes.
+    # See https://github.com/pypa/pip/issues/10557
+    # We will loop until we explicitly break the loop.
+    while True:
+        leaves = set()
+        for key in graph:
+            if key is None:
+                continue
+            for _child in graph.iter_children(key):
+                # This means we have at least one child
+                break
+            else:
+                # No child.
+                leaves.add(key)
+        if not leaves:
+            # We are done simplifying.
+            break
+        # Calculate the weight for the leaves.
+        weight = len(graph) - 1
+        for leaf in leaves:
+            if leaf not in requirement_keys:
+                continue
+            weights[leaf] = weight
+        # Remove the leaves from the graph, making it simpler.
+        for leaf in leaves:
+            graph.remove(leaf)
+
+    # Visit the remaining graph.
+    # `None` is guaranteed to be the root node by resolvelib.
+    visit(None)
+
+    # Sanity check: all requirement keys should be in the weights,
+    # and no other keys should be in the weights.
+    difference = set(weights.keys()).difference(requirement_keys)
+    assert not difference, difference
+
+    return weights
+
+
+def _req_set_item_sorter(
+    item: Tuple[str, InstallRequirement],
+    weights: Dict[Optional[str], int],
+) -> Tuple[int, str]:
+    """Key function used to sort install requirements for installation.
+
+    Based on the "weight" mapping calculated in ``get_installation_order()``.
+    The canonical package name is returned as the second member as a tie-
+    breaker to ensure the result is predictable, which is useful in tests.
+    """
+    name = canonicalize_name(item[0])
+    return weights[name], name
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/self_outdated_check.py b/venv/lib/python3.12/site-packages/pip/_internal/self_outdated_check.py
new file mode 100644
index 00000000..f9a91af9
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/self_outdated_check.py
@@ -0,0 +1,244 @@
+import datetime
+import functools
+import hashlib
+import json
+import logging
+import optparse
+import os.path
+import sys
+from dataclasses import dataclass
+from typing import Any, Callable, Dict, Optional
+
+from pip._vendor.packaging.version import Version
+from pip._vendor.packaging.version import parse as parse_version
+from pip._vendor.rich.console import Group
+from pip._vendor.rich.markup import escape
+from pip._vendor.rich.text import Text
+
+from pip._internal.index.collector import LinkCollector
+from pip._internal.index.package_finder import PackageFinder
+from pip._internal.metadata import get_default_environment
+from pip._internal.models.selection_prefs import SelectionPreferences
+from pip._internal.network.session import PipSession
+from pip._internal.utils.compat import WINDOWS
+from pip._internal.utils.entrypoints import (
+    get_best_invocation_for_this_pip,
+    get_best_invocation_for_this_python,
+)
+from pip._internal.utils.filesystem import adjacent_tmp_file, check_path_owner, replace
+from pip._internal.utils.misc import ensure_dir
+
+_WEEK = datetime.timedelta(days=7)
+
+logger = logging.getLogger(__name__)
+
+
+def _get_statefile_name(key: str) -> str:
+    key_bytes = key.encode()
+    name = hashlib.sha224(key_bytes).hexdigest()
+    return name
+
+
+def _convert_date(isodate: str) -> datetime.datetime:
+    """Convert an ISO format string to a date.
+
+    Handles the format 2020-01-22T14:24:01Z (trailing Z)
+    which is not supported by older versions of fromisoformat.
+    """
+    return datetime.datetime.fromisoformat(isodate.replace("Z", "+00:00"))
+
+
+class SelfCheckState:
+    def __init__(self, cache_dir: str) -> None:
+        self._state: Dict[str, Any] = {}
+        self._statefile_path = None
+
+        # Try to load the existing state
+        if cache_dir:
+            self._statefile_path = os.path.join(
+                cache_dir, "selfcheck", _get_statefile_name(self.key)
+            )
+            try:
+                with open(self._statefile_path, encoding="utf-8") as statefile:
+                    self._state = json.load(statefile)
+            except (OSError, ValueError, KeyError):
+                # Explicitly suppressing exceptions, since we don't want to
+                # error out if the cache file is invalid.
+                pass
+
+    @property
+    def key(self) -> str:
+        return sys.prefix
+
+    def get(self, current_time: datetime.datetime) -> Optional[str]:
+        """Check if we have a not-outdated version loaded already."""
+        if not self._state:
+            return None
+
+        if "last_check" not in self._state:
+            return None
+
+        if "pypi_version" not in self._state:
+            return None
+
+        # Determine if we need to refresh the state
+        last_check = _convert_date(self._state["last_check"])
+        time_since_last_check = current_time - last_check
+        if time_since_last_check > _WEEK:
+            return None
+
+        return self._state["pypi_version"]
+
+    def set(self, pypi_version: str, current_time: datetime.datetime) -> None:
+        # If we do not have a path to cache in, don't bother saving.
+        if not self._statefile_path:
+            return
+
+        # Check to make sure that we own the directory
+        if not check_path_owner(os.path.dirname(self._statefile_path)):
+            return
+
+        # Now that we've ensured the directory is owned by this user, we'll go
+        # ahead and make sure that all our directories are created.
+        ensure_dir(os.path.dirname(self._statefile_path))
+
+        state = {
+            # Include the key so it's easy to tell which pip wrote the
+            # file.
+            "key": self.key,
+            "last_check": current_time.isoformat(),
+            "pypi_version": pypi_version,
+        }
+
+        text = json.dumps(state, sort_keys=True, separators=(",", ":"))
+
+        with adjacent_tmp_file(self._statefile_path) as f:
+            f.write(text.encode())
+
+        try:
+            # Since we have a prefix-specific state file, we can just
+            # overwrite whatever is there, no need to check.
+            replace(f.name, self._statefile_path)
+        except OSError:
+            # Best effort.
+            pass
+
+
+@dataclass
+class UpgradePrompt:
+    old: str
+    new: str
+
+    def __rich__(self) -> Group:
+        if WINDOWS:
+            pip_cmd = f"{get_best_invocation_for_this_python()} -m pip"
+        else:
+            pip_cmd = get_best_invocation_for_this_pip()
+
+        notice = "[bold][[reset][blue]notice[reset][bold]][reset]"
+        return Group(
+            Text(),
+            Text.from_markup(
+                f"{notice} A new release of pip is available: "
+                f"[red]{self.old}[reset] -> [green]{self.new}[reset]"
+            ),
+            Text.from_markup(
+                f"{notice} To update, run: "
+                f"[green]{escape(pip_cmd)} install --upgrade pip"
+            ),
+        )
+
+
+def was_installed_by_pip(pkg: str) -> bool:
+    """Checks whether pkg was installed by pip
+
+    This is used not to display the upgrade message when pip is in fact
+    installed by system package manager, such as dnf on Fedora.
+    """
+    dist = get_default_environment().get_distribution(pkg)
+    return dist is not None and "pip" == dist.installer
+
+
+def _get_current_remote_pip_version(
+    session: PipSession, options: optparse.Values
+) -> Optional[str]:
+    # Lets use PackageFinder to see what the latest pip version is
+    link_collector = LinkCollector.create(
+        session,
+        options=options,
+        suppress_no_index=True,
+    )
+
+    # Pass allow_yanked=False so we don't suggest upgrading to a
+    # yanked version.
+    selection_prefs = SelectionPreferences(
+        allow_yanked=False,
+        allow_all_prereleases=False,  # Explicitly set to False
+    )
+
+    finder = PackageFinder.create(
+        link_collector=link_collector,
+        selection_prefs=selection_prefs,
+    )
+    best_candidate = finder.find_best_candidate("pip").best_candidate
+    if best_candidate is None:
+        return None
+
+    return str(best_candidate.version)
+
+
+def _self_version_check_logic(
+    *,
+    state: SelfCheckState,
+    current_time: datetime.datetime,
+    local_version: Version,
+    get_remote_version: Callable[[], Optional[str]],
+) -> Optional[UpgradePrompt]:
+    remote_version_str = state.get(current_time)
+    if remote_version_str is None:
+        remote_version_str = get_remote_version()
+        if remote_version_str is None:
+            logger.debug("No remote pip version found")
+            return None
+        state.set(remote_version_str, current_time)
+
+    remote_version = parse_version(remote_version_str)
+    logger.debug("Remote version of pip: %s", remote_version)
+    logger.debug("Local version of pip:  %s", local_version)
+
+    pip_installed_by_pip = was_installed_by_pip("pip")
+    logger.debug("Was pip installed by pip? %s", pip_installed_by_pip)
+    if not pip_installed_by_pip:
+        return None  # Only suggest upgrade if pip is installed by pip.
+
+    local_version_is_older = (
+        local_version < remote_version
+        and local_version.base_version != remote_version.base_version
+    )
+    if local_version_is_older:
+        return UpgradePrompt(old=str(local_version), new=remote_version_str)
+
+    return None
+
+
+def pip_self_version_check(session: PipSession, options: optparse.Values) -> None:
+    """Check for an update for pip.
+
+    Limit the frequency of checks to once per week. State is stored either in
+    the active virtualenv or in the user's USER_CACHE_DIR keyed off the prefix
+    of the pip script path.
+    """
+    installed_dist = get_default_environment().get_distribution("pip")
+    if not installed_dist:
+        return
+
+    upgrade_prompt = _self_version_check_logic(
+        state=SelfCheckState(cache_dir=options.cache_dir),
+        current_time=datetime.datetime.now(datetime.timezone.utc),
+        local_version=installed_dist.version,
+        get_remote_version=functools.partial(
+            _get_current_remote_pip_version, session, options
+        ),
+    )
+    if upgrade_prompt is not None:
+        logger.warning("%s", upgrade_prompt, extra={"rich": True})
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/utils/__init__.py b/venv/lib/python3.12/site-packages/pip/_internal/utils/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/utils/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/utils/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 00000000..da8ae2e2
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/utils/__pycache__/__init__.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/utils/__pycache__/_jaraco_text.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/utils/__pycache__/_jaraco_text.cpython-312.pyc
new file mode 100644
index 00000000..75eaeb22
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/utils/__pycache__/_jaraco_text.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/utils/__pycache__/_log.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/utils/__pycache__/_log.cpython-312.pyc
new file mode 100644
index 00000000..aa6ea9f5
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/utils/__pycache__/_log.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/utils/__pycache__/appdirs.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/utils/__pycache__/appdirs.cpython-312.pyc
new file mode 100644
index 00000000..6d4e6eb2
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/utils/__pycache__/appdirs.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/utils/__pycache__/compat.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/utils/__pycache__/compat.cpython-312.pyc
new file mode 100644
index 00000000..02ac55e5
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/utils/__pycache__/compat.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/utils/__pycache__/compatibility_tags.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/utils/__pycache__/compatibility_tags.cpython-312.pyc
new file mode 100644
index 00000000..b27c5bb5
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/utils/__pycache__/compatibility_tags.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/utils/__pycache__/datetime.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/utils/__pycache__/datetime.cpython-312.pyc
new file mode 100644
index 00000000..c8a9ce6e
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/utils/__pycache__/datetime.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/utils/__pycache__/deprecation.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/utils/__pycache__/deprecation.cpython-312.pyc
new file mode 100644
index 00000000..20fae331
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/utils/__pycache__/deprecation.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/utils/__pycache__/direct_url_helpers.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/utils/__pycache__/direct_url_helpers.cpython-312.pyc
new file mode 100644
index 00000000..7b25d881
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/utils/__pycache__/direct_url_helpers.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/utils/__pycache__/egg_link.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/utils/__pycache__/egg_link.cpython-312.pyc
new file mode 100644
index 00000000..cb911236
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/utils/__pycache__/egg_link.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/utils/__pycache__/encoding.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/utils/__pycache__/encoding.cpython-312.pyc
new file mode 100644
index 00000000..e7faf407
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/utils/__pycache__/encoding.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/utils/__pycache__/entrypoints.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/utils/__pycache__/entrypoints.cpython-312.pyc
new file mode 100644
index 00000000..e70ec394
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/utils/__pycache__/entrypoints.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/utils/__pycache__/filesystem.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/utils/__pycache__/filesystem.cpython-312.pyc
new file mode 100644
index 00000000..7b945eff
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/utils/__pycache__/filesystem.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/utils/__pycache__/filetypes.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/utils/__pycache__/filetypes.cpython-312.pyc
new file mode 100644
index 00000000..27a12ea0
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/utils/__pycache__/filetypes.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/utils/__pycache__/glibc.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/utils/__pycache__/glibc.cpython-312.pyc
new file mode 100644
index 00000000..c2b8a3d0
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/utils/__pycache__/glibc.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/utils/__pycache__/hashes.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/utils/__pycache__/hashes.cpython-312.pyc
new file mode 100644
index 00000000..4365c1b0
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/utils/__pycache__/hashes.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/utils/__pycache__/logging.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/utils/__pycache__/logging.cpython-312.pyc
new file mode 100644
index 00000000..8d33e322
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/utils/__pycache__/logging.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/utils/__pycache__/misc.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/utils/__pycache__/misc.cpython-312.pyc
new file mode 100644
index 00000000..47e1162c
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/utils/__pycache__/misc.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/utils/__pycache__/packaging.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/utils/__pycache__/packaging.cpython-312.pyc
new file mode 100644
index 00000000..455a49e3
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/utils/__pycache__/packaging.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/utils/__pycache__/retry.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/utils/__pycache__/retry.cpython-312.pyc
new file mode 100644
index 00000000..44085da2
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/utils/__pycache__/retry.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/utils/__pycache__/setuptools_build.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/utils/__pycache__/setuptools_build.cpython-312.pyc
new file mode 100644
index 00000000..5846299c
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/utils/__pycache__/setuptools_build.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/utils/__pycache__/subprocess.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/utils/__pycache__/subprocess.cpython-312.pyc
new file mode 100644
index 00000000..dcfb6b9c
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/utils/__pycache__/subprocess.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/utils/__pycache__/temp_dir.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/utils/__pycache__/temp_dir.cpython-312.pyc
new file mode 100644
index 00000000..88e9a004
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/utils/__pycache__/temp_dir.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/utils/__pycache__/unpacking.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/utils/__pycache__/unpacking.cpython-312.pyc
new file mode 100644
index 00000000..396abd6a
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/utils/__pycache__/unpacking.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/utils/__pycache__/urls.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/utils/__pycache__/urls.cpython-312.pyc
new file mode 100644
index 00000000..27c15267
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/utils/__pycache__/urls.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/utils/__pycache__/virtualenv.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/utils/__pycache__/virtualenv.cpython-312.pyc
new file mode 100644
index 00000000..9fdfdd76
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/utils/__pycache__/virtualenv.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/utils/__pycache__/wheel.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/utils/__pycache__/wheel.cpython-312.pyc
new file mode 100644
index 00000000..30a80865
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/utils/__pycache__/wheel.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/utils/_jaraco_text.py b/venv/lib/python3.12/site-packages/pip/_internal/utils/_jaraco_text.py
new file mode 100644
index 00000000..6ccf53b7
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/utils/_jaraco_text.py
@@ -0,0 +1,109 @@
+"""Functions brought over from jaraco.text.
+
+These functions are not supposed to be used within `pip._internal`. These are
+helper functions brought over from `jaraco.text` to enable vendoring newer
+copies of `pkg_resources` without having to vendor `jaraco.text` and its entire
+dependency cone; something that our vendoring setup is not currently capable of
+handling.
+
+License reproduced from original source below:
+
+Copyright Jason R. Coombs
+
+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.
+"""
+
+import functools
+import itertools
+
+
+def _nonblank(str):
+    return str and not str.startswith("#")
+
+
+@functools.singledispatch
+def yield_lines(iterable):
+    r"""
+    Yield valid lines of a string or iterable.
+
+    >>> list(yield_lines(''))
+    []
+    >>> list(yield_lines(['foo', 'bar']))
+    ['foo', 'bar']
+    >>> list(yield_lines('foo\nbar'))
+    ['foo', 'bar']
+    >>> list(yield_lines('\nfoo\n#bar\nbaz #comment'))
+    ['foo', 'baz #comment']
+    >>> list(yield_lines(['foo\nbar', 'baz', 'bing\n\n\n']))
+    ['foo', 'bar', 'baz', 'bing']
+    """
+    return itertools.chain.from_iterable(map(yield_lines, iterable))
+
+
+@yield_lines.register(str)
+def _(text):
+    return filter(_nonblank, map(str.strip, text.splitlines()))
+
+
+def drop_comment(line):
+    """
+    Drop comments.
+
+    >>> drop_comment('foo # bar')
+    'foo'
+
+    A hash without a space may be in a URL.
+
+    >>> drop_comment('http://example.com/foo#bar')
+    'http://example.com/foo#bar'
+    """
+    return line.partition(" #")[0]
+
+
+def join_continuation(lines):
+    r"""
+    Join lines continued by a trailing backslash.
+
+    >>> list(join_continuation(['foo \\', 'bar', 'baz']))
+    ['foobar', 'baz']
+    >>> list(join_continuation(['foo \\', 'bar', 'baz']))
+    ['foobar', 'baz']
+    >>> list(join_continuation(['foo \\', 'bar \\', 'baz']))
+    ['foobarbaz']
+
+    Not sure why, but...
+    The character preceding the backslash is also elided.
+
+    >>> list(join_continuation(['goo\\', 'dly']))
+    ['godly']
+
+    A terrible idea, but...
+    If no line is available to continue, suppress the lines.
+
+    >>> list(join_continuation(['foo', 'bar\\', 'baz\\']))
+    ['foo']
+    """
+    lines = iter(lines)
+    for item in lines:
+        while item.endswith("\\"):
+            try:
+                item = item[:-2].strip() + next(lines)
+            except StopIteration:
+                return
+        yield item
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/utils/_log.py b/venv/lib/python3.12/site-packages/pip/_internal/utils/_log.py
new file mode 100644
index 00000000..92c4c6a1
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/utils/_log.py
@@ -0,0 +1,38 @@
+"""Customize logging
+
+Defines custom logger class for the `logger.verbose(...)` method.
+
+init_logging() must be called before any other modules that call logging.getLogger.
+"""
+
+import logging
+from typing import Any, cast
+
+# custom log level for `--verbose` output
+# between DEBUG and INFO
+VERBOSE = 15
+
+
+class VerboseLogger(logging.Logger):
+    """Custom Logger, defining a verbose log-level
+
+    VERBOSE is between INFO and DEBUG.
+    """
+
+    def verbose(self, msg: str, *args: Any, **kwargs: Any) -> None:
+        return self.log(VERBOSE, msg, *args, **kwargs)
+
+
+def getLogger(name: str) -> VerboseLogger:
+    """logging.getLogger, but ensures our VerboseLogger class is returned"""
+    return cast(VerboseLogger, logging.getLogger(name))
+
+
+def init_logging() -> None:
+    """Register our VerboseLogger and VERBOSE log level.
+
+    Should be called before any calls to getLogger(),
+    i.e. in pip._internal.__init__
+    """
+    logging.setLoggerClass(VerboseLogger)
+    logging.addLevelName(VERBOSE, "VERBOSE")
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/utils/appdirs.py b/venv/lib/python3.12/site-packages/pip/_internal/utils/appdirs.py
new file mode 100644
index 00000000..16933bf8
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/utils/appdirs.py
@@ -0,0 +1,52 @@
+"""
+This code wraps the vendored appdirs module to so the return values are
+compatible for the current pip code base.
+
+The intention is to rewrite current usages gradually, keeping the tests pass,
+and eventually drop this after all usages are changed.
+"""
+
+import os
+import sys
+from typing import List
+
+from pip._vendor import platformdirs as _appdirs
+
+
+def user_cache_dir(appname: str) -> str:
+    return _appdirs.user_cache_dir(appname, appauthor=False)
+
+
+def _macos_user_config_dir(appname: str, roaming: bool = True) -> str:
+    # Use ~/Application Support/pip, if the directory exists.
+    path = _appdirs.user_data_dir(appname, appauthor=False, roaming=roaming)
+    if os.path.isdir(path):
+        return path
+
+    # Use a Linux-like ~/.config/pip, by default.
+    linux_like_path = "~/.config/"
+    if appname:
+        linux_like_path = os.path.join(linux_like_path, appname)
+
+    return os.path.expanduser(linux_like_path)
+
+
+def user_config_dir(appname: str, roaming: bool = True) -> str:
+    if sys.platform == "darwin":
+        return _macos_user_config_dir(appname, roaming)
+
+    return _appdirs.user_config_dir(appname, appauthor=False, roaming=roaming)
+
+
+# for the discussion regarding site_config_dir locations
+# see 
+def site_config_dirs(appname: str) -> List[str]:
+    if sys.platform == "darwin":
+        return [_appdirs.site_data_dir(appname, appauthor=False, multipath=True)]
+
+    dirval = _appdirs.site_config_dir(appname, appauthor=False, multipath=True)
+    if sys.platform == "win32":
+        return [dirval]
+
+    # Unix-y system. Look in /etc as well.
+    return dirval.split(os.pathsep) + ["/etc"]
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/utils/compat.py b/venv/lib/python3.12/site-packages/pip/_internal/utils/compat.py
new file mode 100644
index 00000000..d8b54e4e
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/utils/compat.py
@@ -0,0 +1,79 @@
+"""Stuff that differs in different Python versions and platform
+distributions."""
+
+import importlib.resources
+import logging
+import os
+import sys
+from typing import IO
+
+__all__ = ["get_path_uid", "stdlib_pkgs", "WINDOWS"]
+
+
+logger = logging.getLogger(__name__)
+
+
+def has_tls() -> bool:
+    try:
+        import _ssl  # noqa: F401  # ignore unused
+
+        return True
+    except ImportError:
+        pass
+
+    from pip._vendor.urllib3.util import IS_PYOPENSSL
+
+    return IS_PYOPENSSL
+
+
+def get_path_uid(path: str) -> int:
+    """
+    Return path's uid.
+
+    Does not follow symlinks:
+        https://github.com/pypa/pip/pull/935#discussion_r5307003
+
+    Placed this function in compat due to differences on AIX and
+    Jython, that should eventually go away.
+
+    :raises OSError: When path is a symlink or can't be read.
+    """
+    if hasattr(os, "O_NOFOLLOW"):
+        fd = os.open(path, os.O_RDONLY | os.O_NOFOLLOW)
+        file_uid = os.fstat(fd).st_uid
+        os.close(fd)
+    else:  # AIX and Jython
+        # WARNING: time of check vulnerability, but best we can do w/o NOFOLLOW
+        if not os.path.islink(path):
+            # older versions of Jython don't have `os.fstat`
+            file_uid = os.stat(path).st_uid
+        else:
+            # raise OSError for parity with os.O_NOFOLLOW above
+            raise OSError(f"{path} is a symlink; Will not return uid for symlinks")
+    return file_uid
+
+
+# The importlib.resources.open_text function was deprecated in 3.11 with suggested
+# replacement we use below.
+if sys.version_info < (3, 11):
+    open_text_resource = importlib.resources.open_text
+else:
+
+    def open_text_resource(
+        package: str, resource: str, encoding: str = "utf-8", errors: str = "strict"
+    ) -> IO[str]:
+        return (importlib.resources.files(package) / resource).open(
+            "r", encoding=encoding, errors=errors
+        )
+
+
+# packages in the stdlib that may have installation metadata, but should not be
+# considered 'installed'.  this theoretically could be determined based on
+# dist.location (py27:`sysconfig.get_paths()['stdlib']`,
+# py26:sysconfig.get_config_vars('LIBDEST')), but fear platform variation may
+# make this ineffective, so hard-coding
+stdlib_pkgs = {"python", "wsgiref", "argparse"}
+
+
+# windows detection, covers cpython and ironpython
+WINDOWS = sys.platform.startswith("win") or (sys.platform == "cli" and os.name == "nt")
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/utils/compatibility_tags.py b/venv/lib/python3.12/site-packages/pip/_internal/utils/compatibility_tags.py
new file mode 100644
index 00000000..b6ed9a78
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/utils/compatibility_tags.py
@@ -0,0 +1,165 @@
+"""Generate and work with PEP 425 Compatibility Tags.
+"""
+
+import re
+from typing import List, Optional, Tuple
+
+from pip._vendor.packaging.tags import (
+    PythonVersion,
+    Tag,
+    compatible_tags,
+    cpython_tags,
+    generic_tags,
+    interpreter_name,
+    interpreter_version,
+    mac_platforms,
+)
+
+_osx_arch_pat = re.compile(r"(.+)_(\d+)_(\d+)_(.+)")
+
+
+def version_info_to_nodot(version_info: Tuple[int, ...]) -> str:
+    # Only use up to the first two numbers.
+    return "".join(map(str, version_info[:2]))
+
+
+def _mac_platforms(arch: str) -> List[str]:
+    match = _osx_arch_pat.match(arch)
+    if match:
+        name, major, minor, actual_arch = match.groups()
+        mac_version = (int(major), int(minor))
+        arches = [
+            # Since we have always only checked that the platform starts
+            # with "macosx", for backwards-compatibility we extract the
+            # actual prefix provided by the user in case they provided
+            # something like "macosxcustom_". It may be good to remove
+            # this as undocumented or deprecate it in the future.
+            "{}_{}".format(name, arch[len("macosx_") :])
+            for arch in mac_platforms(mac_version, actual_arch)
+        ]
+    else:
+        # arch pattern didn't match (?!)
+        arches = [arch]
+    return arches
+
+
+def _custom_manylinux_platforms(arch: str) -> List[str]:
+    arches = [arch]
+    arch_prefix, arch_sep, arch_suffix = arch.partition("_")
+    if arch_prefix == "manylinux2014":
+        # manylinux1/manylinux2010 wheels run on most manylinux2014 systems
+        # with the exception of wheels depending on ncurses. PEP 599 states
+        # manylinux1/manylinux2010 wheels should be considered
+        # manylinux2014 wheels:
+        # https://www.python.org/dev/peps/pep-0599/#backwards-compatibility-with-manylinux2010-wheels
+        if arch_suffix in {"i686", "x86_64"}:
+            arches.append("manylinux2010" + arch_sep + arch_suffix)
+            arches.append("manylinux1" + arch_sep + arch_suffix)
+    elif arch_prefix == "manylinux2010":
+        # manylinux1 wheels run on most manylinux2010 systems with the
+        # exception of wheels depending on ncurses. PEP 571 states
+        # manylinux1 wheels should be considered manylinux2010 wheels:
+        # https://www.python.org/dev/peps/pep-0571/#backwards-compatibility-with-manylinux1-wheels
+        arches.append("manylinux1" + arch_sep + arch_suffix)
+    return arches
+
+
+def _get_custom_platforms(arch: str) -> List[str]:
+    arch_prefix, arch_sep, arch_suffix = arch.partition("_")
+    if arch.startswith("macosx"):
+        arches = _mac_platforms(arch)
+    elif arch_prefix in ["manylinux2014", "manylinux2010"]:
+        arches = _custom_manylinux_platforms(arch)
+    else:
+        arches = [arch]
+    return arches
+
+
+def _expand_allowed_platforms(platforms: Optional[List[str]]) -> Optional[List[str]]:
+    if not platforms:
+        return None
+
+    seen = set()
+    result = []
+
+    for p in platforms:
+        if p in seen:
+            continue
+        additions = [c for c in _get_custom_platforms(p) if c not in seen]
+        seen.update(additions)
+        result.extend(additions)
+
+    return result
+
+
+def _get_python_version(version: str) -> PythonVersion:
+    if len(version) > 1:
+        return int(version[0]), int(version[1:])
+    else:
+        return (int(version[0]),)
+
+
+def _get_custom_interpreter(
+    implementation: Optional[str] = None, version: Optional[str] = None
+) -> str:
+    if implementation is None:
+        implementation = interpreter_name()
+    if version is None:
+        version = interpreter_version()
+    return f"{implementation}{version}"
+
+
+def get_supported(
+    version: Optional[str] = None,
+    platforms: Optional[List[str]] = None,
+    impl: Optional[str] = None,
+    abis: Optional[List[str]] = None,
+) -> List[Tag]:
+    """Return a list of supported tags for each version specified in
+    `versions`.
+
+    :param version: a string version, of the form "33" or "32",
+        or None. The version will be assumed to support our ABI.
+    :param platform: specify a list of platforms you want valid
+        tags for, or None. If None, use the local system platform.
+    :param impl: specify the exact implementation you want valid
+        tags for, or None. If None, use the local interpreter impl.
+    :param abis: specify a list of abis you want valid
+        tags for, or None. If None, use the local interpreter abi.
+    """
+    supported: List[Tag] = []
+
+    python_version: Optional[PythonVersion] = None
+    if version is not None:
+        python_version = _get_python_version(version)
+
+    interpreter = _get_custom_interpreter(impl, version)
+
+    platforms = _expand_allowed_platforms(platforms)
+
+    is_cpython = (impl or interpreter_name()) == "cp"
+    if is_cpython:
+        supported.extend(
+            cpython_tags(
+                python_version=python_version,
+                abis=abis,
+                platforms=platforms,
+            )
+        )
+    else:
+        supported.extend(
+            generic_tags(
+                interpreter=interpreter,
+                abis=abis,
+                platforms=platforms,
+            )
+        )
+    supported.extend(
+        compatible_tags(
+            python_version=python_version,
+            interpreter=interpreter,
+            platforms=platforms,
+        )
+    )
+
+    return supported
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/utils/datetime.py b/venv/lib/python3.12/site-packages/pip/_internal/utils/datetime.py
new file mode 100644
index 00000000..8668b3b0
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/utils/datetime.py
@@ -0,0 +1,11 @@
+"""For when pip wants to check the date or time.
+"""
+
+import datetime
+
+
+def today_is_later_than(year: int, month: int, day: int) -> bool:
+    today = datetime.date.today()
+    given = datetime.date(year, month, day)
+
+    return today > given
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/utils/deprecation.py b/venv/lib/python3.12/site-packages/pip/_internal/utils/deprecation.py
new file mode 100644
index 00000000..0911147e
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/utils/deprecation.py
@@ -0,0 +1,124 @@
+"""
+A module that implements tooling to enable easy warnings about deprecations.
+"""
+
+import logging
+import warnings
+from typing import Any, Optional, TextIO, Type, Union
+
+from pip._vendor.packaging.version import parse
+
+from pip import __version__ as current_version  # NOTE: tests patch this name.
+
+DEPRECATION_MSG_PREFIX = "DEPRECATION: "
+
+
+class PipDeprecationWarning(Warning):
+    pass
+
+
+_original_showwarning: Any = None
+
+
+# Warnings <-> Logging Integration
+def _showwarning(
+    message: Union[Warning, str],
+    category: Type[Warning],
+    filename: str,
+    lineno: int,
+    file: Optional[TextIO] = None,
+    line: Optional[str] = None,
+) -> None:
+    if file is not None:
+        if _original_showwarning is not None:
+            _original_showwarning(message, category, filename, lineno, file, line)
+    elif issubclass(category, PipDeprecationWarning):
+        # We use a specially named logger which will handle all of the
+        # deprecation messages for pip.
+        logger = logging.getLogger("pip._internal.deprecations")
+        logger.warning(message)
+    else:
+        _original_showwarning(message, category, filename, lineno, file, line)
+
+
+def install_warning_logger() -> None:
+    # Enable our Deprecation Warnings
+    warnings.simplefilter("default", PipDeprecationWarning, append=True)
+
+    global _original_showwarning
+
+    if _original_showwarning is None:
+        _original_showwarning = warnings.showwarning
+        warnings.showwarning = _showwarning
+
+
+def deprecated(
+    *,
+    reason: str,
+    replacement: Optional[str],
+    gone_in: Optional[str],
+    feature_flag: Optional[str] = None,
+    issue: Optional[int] = None,
+) -> None:
+    """Helper to deprecate existing functionality.
+
+    reason:
+        Textual reason shown to the user about why this functionality has
+        been deprecated. Should be a complete sentence.
+    replacement:
+        Textual suggestion shown to the user about what alternative
+        functionality they can use.
+    gone_in:
+        The version of pip does this functionality should get removed in.
+        Raises an error if pip's current version is greater than or equal to
+        this.
+    feature_flag:
+        Command-line flag of the form --use-feature={feature_flag} for testing
+        upcoming functionality.
+    issue:
+        Issue number on the tracker that would serve as a useful place for
+        users to find related discussion and provide feedback.
+    """
+
+    # Determine whether or not the feature is already gone in this version.
+    is_gone = gone_in is not None and parse(current_version) >= parse(gone_in)
+
+    message_parts = [
+        (reason, f"{DEPRECATION_MSG_PREFIX}{{}}"),
+        (
+            gone_in,
+            (
+                "pip {} will enforce this behaviour change."
+                if not is_gone
+                else "Since pip {}, this is no longer supported."
+            ),
+        ),
+        (
+            replacement,
+            "A possible replacement is {}.",
+        ),
+        (
+            feature_flag,
+            (
+                "You can use the flag --use-feature={} to test the upcoming behaviour."
+                if not is_gone
+                else None
+            ),
+        ),
+        (
+            issue,
+            "Discussion can be found at https://github.com/pypa/pip/issues/{}",
+        ),
+    ]
+
+    message = " ".join(
+        format_str.format(value)
+        for value, format_str in message_parts
+        if format_str is not None and value is not None
+    )
+
+    # Raise as an error if this behaviour is deprecated.
+    if is_gone:
+        raise PipDeprecationWarning(message)
+
+    warnings.warn(message, category=PipDeprecationWarning, stacklevel=2)
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/utils/direct_url_helpers.py b/venv/lib/python3.12/site-packages/pip/_internal/utils/direct_url_helpers.py
new file mode 100644
index 00000000..66020d39
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/utils/direct_url_helpers.py
@@ -0,0 +1,87 @@
+from typing import Optional
+
+from pip._internal.models.direct_url import ArchiveInfo, DirectUrl, DirInfo, VcsInfo
+from pip._internal.models.link import Link
+from pip._internal.utils.urls import path_to_url
+from pip._internal.vcs import vcs
+
+
+def direct_url_as_pep440_direct_reference(direct_url: DirectUrl, name: str) -> str:
+    """Convert a DirectUrl to a pip requirement string."""
+    direct_url.validate()  # if invalid, this is a pip bug
+    requirement = name + " @ "
+    fragments = []
+    if isinstance(direct_url.info, VcsInfo):
+        requirement += (
+            f"{direct_url.info.vcs}+{direct_url.url}@{direct_url.info.commit_id}"
+        )
+    elif isinstance(direct_url.info, ArchiveInfo):
+        requirement += direct_url.url
+        if direct_url.info.hash:
+            fragments.append(direct_url.info.hash)
+    else:
+        assert isinstance(direct_url.info, DirInfo)
+        requirement += direct_url.url
+    if direct_url.subdirectory:
+        fragments.append("subdirectory=" + direct_url.subdirectory)
+    if fragments:
+        requirement += "#" + "&".join(fragments)
+    return requirement
+
+
+def direct_url_for_editable(source_dir: str) -> DirectUrl:
+    return DirectUrl(
+        url=path_to_url(source_dir),
+        info=DirInfo(editable=True),
+    )
+
+
+def direct_url_from_link(
+    link: Link, source_dir: Optional[str] = None, link_is_in_wheel_cache: bool = False
+) -> DirectUrl:
+    if link.is_vcs:
+        vcs_backend = vcs.get_backend_for_scheme(link.scheme)
+        assert vcs_backend
+        url, requested_revision, _ = vcs_backend.get_url_rev_and_auth(
+            link.url_without_fragment
+        )
+        # For VCS links, we need to find out and add commit_id.
+        if link_is_in_wheel_cache:
+            # If the requested VCS link corresponds to a cached
+            # wheel, it means the requested revision was an
+            # immutable commit hash, otherwise it would not have
+            # been cached. In that case we don't have a source_dir
+            # with the VCS checkout.
+            assert requested_revision
+            commit_id = requested_revision
+        else:
+            # If the wheel was not in cache, it means we have
+            # had to checkout from VCS to build and we have a source_dir
+            # which we can inspect to find out the commit id.
+            assert source_dir
+            commit_id = vcs_backend.get_revision(source_dir)
+        return DirectUrl(
+            url=url,
+            info=VcsInfo(
+                vcs=vcs_backend.name,
+                commit_id=commit_id,
+                requested_revision=requested_revision,
+            ),
+            subdirectory=link.subdirectory_fragment,
+        )
+    elif link.is_existing_dir():
+        return DirectUrl(
+            url=link.url_without_fragment,
+            info=DirInfo(),
+            subdirectory=link.subdirectory_fragment,
+        )
+    else:
+        hash = None
+        hash_name = link.hash_name
+        if hash_name:
+            hash = f"{hash_name}={link.hash}"
+        return DirectUrl(
+            url=link.url_without_fragment,
+            info=ArchiveInfo(hash=hash),
+            subdirectory=link.subdirectory_fragment,
+        )
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/utils/egg_link.py b/venv/lib/python3.12/site-packages/pip/_internal/utils/egg_link.py
new file mode 100644
index 00000000..4a384a63
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/utils/egg_link.py
@@ -0,0 +1,80 @@
+import os
+import re
+import sys
+from typing import List, Optional
+
+from pip._internal.locations import site_packages, user_site
+from pip._internal.utils.virtualenv import (
+    running_under_virtualenv,
+    virtualenv_no_global,
+)
+
+__all__ = [
+    "egg_link_path_from_sys_path",
+    "egg_link_path_from_location",
+]
+
+
+def _egg_link_names(raw_name: str) -> List[str]:
+    """
+    Convert a Name metadata value to a .egg-link name, by applying
+    the same substitution as pkg_resources's safe_name function.
+    Note: we cannot use canonicalize_name because it has a different logic.
+
+    We also look for the raw name (without normalization) as setuptools 69 changed
+    the way it names .egg-link files (https://github.com/pypa/setuptools/issues/4167).
+    """
+    return [
+        re.sub("[^A-Za-z0-9.]+", "-", raw_name) + ".egg-link",
+        f"{raw_name}.egg-link",
+    ]
+
+
+def egg_link_path_from_sys_path(raw_name: str) -> Optional[str]:
+    """
+    Look for a .egg-link file for project name, by walking sys.path.
+    """
+    egg_link_names = _egg_link_names(raw_name)
+    for path_item in sys.path:
+        for egg_link_name in egg_link_names:
+            egg_link = os.path.join(path_item, egg_link_name)
+            if os.path.isfile(egg_link):
+                return egg_link
+    return None
+
+
+def egg_link_path_from_location(raw_name: str) -> Optional[str]:
+    """
+    Return the path for the .egg-link file if it exists, otherwise, None.
+
+    There's 3 scenarios:
+    1) not in a virtualenv
+       try to find in site.USER_SITE, then site_packages
+    2) in a no-global virtualenv
+       try to find in site_packages
+    3) in a yes-global virtualenv
+       try to find in site_packages, then site.USER_SITE
+       (don't look in global location)
+
+    For #1 and #3, there could be odd cases, where there's an egg-link in 2
+    locations.
+
+    This method will just return the first one found.
+    """
+    sites: List[str] = []
+    if running_under_virtualenv():
+        sites.append(site_packages)
+        if not virtualenv_no_global() and user_site:
+            sites.append(user_site)
+    else:
+        if user_site:
+            sites.append(user_site)
+        sites.append(site_packages)
+
+    egg_link_names = _egg_link_names(raw_name)
+    for site in sites:
+        for egg_link_name in egg_link_names:
+            egglink = os.path.join(site, egg_link_name)
+            if os.path.isfile(egglink):
+                return egglink
+    return None
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/utils/encoding.py b/venv/lib/python3.12/site-packages/pip/_internal/utils/encoding.py
new file mode 100644
index 00000000..008f06a7
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/utils/encoding.py
@@ -0,0 +1,36 @@
+import codecs
+import locale
+import re
+import sys
+from typing import List, Tuple
+
+BOMS: List[Tuple[bytes, str]] = [
+    (codecs.BOM_UTF8, "utf-8"),
+    (codecs.BOM_UTF16, "utf-16"),
+    (codecs.BOM_UTF16_BE, "utf-16-be"),
+    (codecs.BOM_UTF16_LE, "utf-16-le"),
+    (codecs.BOM_UTF32, "utf-32"),
+    (codecs.BOM_UTF32_BE, "utf-32-be"),
+    (codecs.BOM_UTF32_LE, "utf-32-le"),
+]
+
+ENCODING_RE = re.compile(rb"coding[:=]\s*([-\w.]+)")
+
+
+def auto_decode(data: bytes) -> str:
+    """Check a bytes string for a BOM to correctly detect the encoding
+
+    Fallback to locale.getpreferredencoding(False) like open() on Python3"""
+    for bom, encoding in BOMS:
+        if data.startswith(bom):
+            return data[len(bom) :].decode(encoding)
+    # Lets check the first two lines as in PEP263
+    for line in data.split(b"\n")[:2]:
+        if line[0:1] == b"#" and ENCODING_RE.search(line):
+            result = ENCODING_RE.search(line)
+            assert result is not None
+            encoding = result.groups()[0].decode("ascii")
+            return data.decode(encoding)
+    return data.decode(
+        locale.getpreferredencoding(False) or sys.getdefaultencoding(),
+    )
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/utils/entrypoints.py b/venv/lib/python3.12/site-packages/pip/_internal/utils/entrypoints.py
new file mode 100644
index 00000000..15013693
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/utils/entrypoints.py
@@ -0,0 +1,84 @@
+import itertools
+import os
+import shutil
+import sys
+from typing import List, Optional
+
+from pip._internal.cli.main import main
+from pip._internal.utils.compat import WINDOWS
+
+_EXECUTABLE_NAMES = [
+    "pip",
+    f"pip{sys.version_info.major}",
+    f"pip{sys.version_info.major}.{sys.version_info.minor}",
+]
+if WINDOWS:
+    _allowed_extensions = {"", ".exe"}
+    _EXECUTABLE_NAMES = [
+        "".join(parts)
+        for parts in itertools.product(_EXECUTABLE_NAMES, _allowed_extensions)
+    ]
+
+
+def _wrapper(args: Optional[List[str]] = None) -> int:
+    """Central wrapper for all old entrypoints.
+
+    Historically pip has had several entrypoints defined. Because of issues
+    arising from PATH, sys.path, multiple Pythons, their interactions, and most
+    of them having a pip installed, users suffer every time an entrypoint gets
+    moved.
+
+    To alleviate this pain, and provide a mechanism for warning users and
+    directing them to an appropriate place for help, we now define all of
+    our old entrypoints as wrappers for the current one.
+    """
+    sys.stderr.write(
+        "WARNING: pip is being invoked by an old script wrapper. This will "
+        "fail in a future version of pip.\n"
+        "Please see https://github.com/pypa/pip/issues/5599 for advice on "
+        "fixing the underlying issue.\n"
+        "To avoid this problem you can invoke Python with '-m pip' instead of "
+        "running pip directly.\n"
+    )
+    return main(args)
+
+
+def get_best_invocation_for_this_pip() -> str:
+    """Try to figure out the best way to invoke pip in the current environment."""
+    binary_directory = "Scripts" if WINDOWS else "bin"
+    binary_prefix = os.path.join(sys.prefix, binary_directory)
+
+    # Try to use pip[X[.Y]] names, if those executables for this environment are
+    # the first on PATH with that name.
+    path_parts = os.path.normcase(os.environ.get("PATH", "")).split(os.pathsep)
+    exe_are_in_PATH = os.path.normcase(binary_prefix) in path_parts
+    if exe_are_in_PATH:
+        for exe_name in _EXECUTABLE_NAMES:
+            found_executable = shutil.which(exe_name)
+            binary_executable = os.path.join(binary_prefix, exe_name)
+            if (
+                found_executable
+                and os.path.exists(binary_executable)
+                and os.path.samefile(
+                    found_executable,
+                    binary_executable,
+                )
+            ):
+                return exe_name
+
+    # Use the `-m` invocation, if there's no "nice" invocation.
+    return f"{get_best_invocation_for_this_python()} -m pip"
+
+
+def get_best_invocation_for_this_python() -> str:
+    """Try to figure out the best way to invoke the current Python."""
+    exe = sys.executable
+    exe_name = os.path.basename(exe)
+
+    # Try to use the basename, if it's the first executable.
+    found_executable = shutil.which(exe_name)
+    if found_executable and os.path.samefile(found_executable, exe):
+        return exe_name
+
+    # Use the full executable name, because we couldn't find something simpler.
+    return exe
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/utils/filesystem.py b/venv/lib/python3.12/site-packages/pip/_internal/utils/filesystem.py
new file mode 100644
index 00000000..22e356cd
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/utils/filesystem.py
@@ -0,0 +1,149 @@
+import fnmatch
+import os
+import os.path
+import random
+import sys
+from contextlib import contextmanager
+from tempfile import NamedTemporaryFile
+from typing import Any, BinaryIO, Generator, List, Union, cast
+
+from pip._internal.utils.compat import get_path_uid
+from pip._internal.utils.misc import format_size
+from pip._internal.utils.retry import retry
+
+
+def check_path_owner(path: str) -> bool:
+    # If we don't have a way to check the effective uid of this process, then
+    # we'll just assume that we own the directory.
+    if sys.platform == "win32" or not hasattr(os, "geteuid"):
+        return True
+
+    assert os.path.isabs(path)
+
+    previous = None
+    while path != previous:
+        if os.path.lexists(path):
+            # Check if path is writable by current user.
+            if os.geteuid() == 0:
+                # Special handling for root user in order to handle properly
+                # cases where users use sudo without -H flag.
+                try:
+                    path_uid = get_path_uid(path)
+                except OSError:
+                    return False
+                return path_uid == 0
+            else:
+                return os.access(path, os.W_OK)
+        else:
+            previous, path = path, os.path.dirname(path)
+    return False  # assume we don't own the path
+
+
+@contextmanager
+def adjacent_tmp_file(path: str, **kwargs: Any) -> Generator[BinaryIO, None, None]:
+    """Return a file-like object pointing to a tmp file next to path.
+
+    The file is created securely and is ensured to be written to disk
+    after the context reaches its end.
+
+    kwargs will be passed to tempfile.NamedTemporaryFile to control
+    the way the temporary file will be opened.
+    """
+    with NamedTemporaryFile(
+        delete=False,
+        dir=os.path.dirname(path),
+        prefix=os.path.basename(path),
+        suffix=".tmp",
+        **kwargs,
+    ) as f:
+        result = cast(BinaryIO, f)
+        try:
+            yield result
+        finally:
+            result.flush()
+            os.fsync(result.fileno())
+
+
+replace = retry(stop_after_delay=1, wait=0.25)(os.replace)
+
+
+# test_writable_dir and _test_writable_dir_win are copied from Flit,
+# with the author's agreement to also place them under pip's license.
+def test_writable_dir(path: str) -> bool:
+    """Check if a directory is writable.
+
+    Uses os.access() on POSIX, tries creating files on Windows.
+    """
+    # If the directory doesn't exist, find the closest parent that does.
+    while not os.path.isdir(path):
+        parent = os.path.dirname(path)
+        if parent == path:
+            break  # Should never get here, but infinite loops are bad
+        path = parent
+
+    if os.name == "posix":
+        return os.access(path, os.W_OK)
+
+    return _test_writable_dir_win(path)
+
+
+def _test_writable_dir_win(path: str) -> bool:
+    # os.access doesn't work on Windows: http://bugs.python.org/issue2528
+    # and we can't use tempfile: http://bugs.python.org/issue22107
+    basename = "accesstest_deleteme_fishfingers_custard_"
+    alphabet = "abcdefghijklmnopqrstuvwxyz0123456789"
+    for _ in range(10):
+        name = basename + "".join(random.choice(alphabet) for _ in range(6))
+        file = os.path.join(path, name)
+        try:
+            fd = os.open(file, os.O_RDWR | os.O_CREAT | os.O_EXCL)
+        except FileExistsError:
+            pass
+        except PermissionError:
+            # This could be because there's a directory with the same name.
+            # But it's highly unlikely there's a directory called that,
+            # so we'll assume it's because the parent dir is not writable.
+            # This could as well be because the parent dir is not readable,
+            # due to non-privileged user access.
+            return False
+        else:
+            os.close(fd)
+            os.unlink(file)
+            return True
+
+    # This should never be reached
+    raise OSError("Unexpected condition testing for writable directory")
+
+
+def find_files(path: str, pattern: str) -> List[str]:
+    """Returns a list of absolute paths of files beneath path, recursively,
+    with filenames which match the UNIX-style shell glob pattern."""
+    result: List[str] = []
+    for root, _, files in os.walk(path):
+        matches = fnmatch.filter(files, pattern)
+        result.extend(os.path.join(root, f) for f in matches)
+    return result
+
+
+def file_size(path: str) -> Union[int, float]:
+    # If it's a symlink, return 0.
+    if os.path.islink(path):
+        return 0
+    return os.path.getsize(path)
+
+
+def format_file_size(path: str) -> str:
+    return format_size(file_size(path))
+
+
+def directory_size(path: str) -> Union[int, float]:
+    size = 0.0
+    for root, _dirs, files in os.walk(path):
+        for filename in files:
+            file_path = os.path.join(root, filename)
+            size += file_size(file_path)
+    return size
+
+
+def format_directory_size(path: str) -> str:
+    return format_size(directory_size(path))
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/utils/filetypes.py b/venv/lib/python3.12/site-packages/pip/_internal/utils/filetypes.py
new file mode 100644
index 00000000..59485701
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/utils/filetypes.py
@@ -0,0 +1,27 @@
+"""Filetype information.
+"""
+
+from typing import Tuple
+
+from pip._internal.utils.misc import splitext
+
+WHEEL_EXTENSION = ".whl"
+BZ2_EXTENSIONS: Tuple[str, ...] = (".tar.bz2", ".tbz")
+XZ_EXTENSIONS: Tuple[str, ...] = (
+    ".tar.xz",
+    ".txz",
+    ".tlz",
+    ".tar.lz",
+    ".tar.lzma",
+)
+ZIP_EXTENSIONS: Tuple[str, ...] = (".zip", WHEEL_EXTENSION)
+TAR_EXTENSIONS: Tuple[str, ...] = (".tar.gz", ".tgz", ".tar")
+ARCHIVE_EXTENSIONS = ZIP_EXTENSIONS + BZ2_EXTENSIONS + TAR_EXTENSIONS + XZ_EXTENSIONS
+
+
+def is_archive_file(name: str) -> bool:
+    """Return True if `name` is a considered as an archive file."""
+    ext = splitext(name)[1].lower()
+    if ext in ARCHIVE_EXTENSIONS:
+        return True
+    return False
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/utils/glibc.py b/venv/lib/python3.12/site-packages/pip/_internal/utils/glibc.py
new file mode 100644
index 00000000..998868ff
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/utils/glibc.py
@@ -0,0 +1,101 @@
+import os
+import sys
+from typing import Optional, Tuple
+
+
+def glibc_version_string() -> Optional[str]:
+    "Returns glibc version string, or None if not using glibc."
+    return glibc_version_string_confstr() or glibc_version_string_ctypes()
+
+
+def glibc_version_string_confstr() -> Optional[str]:
+    "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/fcf1d003bf4f0100c9d0921ff3d70e1127ca1b71/Lib/platform.py#L175-L183
+    if sys.platform == "win32":
+        return None
+    try:
+        gnu_libc_version = os.confstr("CS_GNU_LIBC_VERSION")
+        if gnu_libc_version is None:
+            return None
+        # os.confstr("CS_GNU_LIBC_VERSION") returns a string like "glibc 2.17":
+        _, version = gnu_libc_version.split()
+    except (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() -> Optional[str]:
+    "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't 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
+
+
+# platform.libc_ver regularly returns completely nonsensical glibc
+# versions. E.g. on my computer, platform says:
+#
+#   ~$ python2.7 -c 'import platform; print(platform.libc_ver())'
+#   ('glibc', '2.7')
+#   ~$ python3.5 -c 'import platform; print(platform.libc_ver())'
+#   ('glibc', '2.9')
+#
+# But the truth is:
+#
+#   ~$ ldd --version
+#   ldd (Debian GLIBC 2.22-11) 2.22
+#
+# This is unfortunate, because it means that the linehaul data on libc
+# versions that was generated by pip 8.1.2 and earlier is useless and
+# misleading. Solution: instead of using platform, use our code that actually
+# works.
+def libc_ver() -> Tuple[str, str]:
+    """Try to determine the glibc version
+
+    Returns a tuple of strings (lib, version) which default to empty strings
+    in case the lookup fails.
+    """
+    glibc_version = glibc_version_string()
+    if glibc_version is None:
+        return ("", "")
+    else:
+        return ("glibc", glibc_version)
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/utils/hashes.py b/venv/lib/python3.12/site-packages/pip/_internal/utils/hashes.py
new file mode 100644
index 00000000..535e94fc
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/utils/hashes.py
@@ -0,0 +1,147 @@
+import hashlib
+from typing import TYPE_CHECKING, BinaryIO, Dict, Iterable, List, NoReturn, Optional
+
+from pip._internal.exceptions import HashMismatch, HashMissing, InstallationError
+from pip._internal.utils.misc import read_chunks
+
+if TYPE_CHECKING:
+    from hashlib import _Hash
+
+
+# The recommended hash algo of the moment. Change this whenever the state of
+# the art changes; it won't hurt backward compatibility.
+FAVORITE_HASH = "sha256"
+
+
+# Names of hashlib algorithms allowed by the --hash option and ``pip hash``
+# Currently, those are the ones at least as collision-resistant as sha256.
+STRONG_HASHES = ["sha256", "sha384", "sha512"]
+
+
+class Hashes:
+    """A wrapper that builds multiple hashes at once and checks them against
+    known-good values
+
+    """
+
+    def __init__(self, hashes: Optional[Dict[str, List[str]]] = None) -> None:
+        """
+        :param hashes: A dict of algorithm names pointing to lists of allowed
+            hex digests
+        """
+        allowed = {}
+        if hashes is not None:
+            for alg, keys in hashes.items():
+                # Make sure values are always sorted (to ease equality checks)
+                allowed[alg] = [k.lower() for k in sorted(keys)]
+        self._allowed = allowed
+
+    def __and__(self, other: "Hashes") -> "Hashes":
+        if not isinstance(other, Hashes):
+            return NotImplemented
+
+        # If either of the Hashes object is entirely empty (i.e. no hash
+        # specified at all), all hashes from the other object are allowed.
+        if not other:
+            return self
+        if not self:
+            return other
+
+        # Otherwise only hashes that present in both objects are allowed.
+        new = {}
+        for alg, values in other._allowed.items():
+            if alg not in self._allowed:
+                continue
+            new[alg] = [v for v in values if v in self._allowed[alg]]
+        return Hashes(new)
+
+    @property
+    def digest_count(self) -> int:
+        return sum(len(digests) for digests in self._allowed.values())
+
+    def is_hash_allowed(self, hash_name: str, hex_digest: str) -> bool:
+        """Return whether the given hex digest is allowed."""
+        return hex_digest in self._allowed.get(hash_name, [])
+
+    def check_against_chunks(self, chunks: Iterable[bytes]) -> None:
+        """Check good hashes against ones built from iterable of chunks of
+        data.
+
+        Raise HashMismatch if none match.
+
+        """
+        gots = {}
+        for hash_name in self._allowed.keys():
+            try:
+                gots[hash_name] = hashlib.new(hash_name)
+            except (ValueError, TypeError):
+                raise InstallationError(f"Unknown hash name: {hash_name}")
+
+        for chunk in chunks:
+            for hash in gots.values():
+                hash.update(chunk)
+
+        for hash_name, got in gots.items():
+            if got.hexdigest() in self._allowed[hash_name]:
+                return
+        self._raise(gots)
+
+    def _raise(self, gots: Dict[str, "_Hash"]) -> "NoReturn":
+        raise HashMismatch(self._allowed, gots)
+
+    def check_against_file(self, file: BinaryIO) -> None:
+        """Check good hashes against a file-like object
+
+        Raise HashMismatch if none match.
+
+        """
+        return self.check_against_chunks(read_chunks(file))
+
+    def check_against_path(self, path: str) -> None:
+        with open(path, "rb") as file:
+            return self.check_against_file(file)
+
+    def has_one_of(self, hashes: Dict[str, str]) -> bool:
+        """Return whether any of the given hashes are allowed."""
+        for hash_name, hex_digest in hashes.items():
+            if self.is_hash_allowed(hash_name, hex_digest):
+                return True
+        return False
+
+    def __bool__(self) -> bool:
+        """Return whether I know any known-good hashes."""
+        return bool(self._allowed)
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, Hashes):
+            return NotImplemented
+        return self._allowed == other._allowed
+
+    def __hash__(self) -> int:
+        return hash(
+            ",".join(
+                sorted(
+                    ":".join((alg, digest))
+                    for alg, digest_list in self._allowed.items()
+                    for digest in digest_list
+                )
+            )
+        )
+
+
+class MissingHashes(Hashes):
+    """A workalike for Hashes used when we're missing a hash for a requirement
+
+    It computes the actual hash of the requirement and raises a HashMissing
+    exception showing it to the user.
+
+    """
+
+    def __init__(self) -> None:
+        """Don't offer the ``hashes`` kwarg."""
+        # Pass our favorite hash in to generate a "gotten hash". With the
+        # empty list, it will never match, so an error will always raise.
+        super().__init__(hashes={FAVORITE_HASH: []})
+
+    def _raise(self, gots: Dict[str, "_Hash"]) -> "NoReturn":
+        raise HashMissing(gots[FAVORITE_HASH].hexdigest())
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/utils/logging.py b/venv/lib/python3.12/site-packages/pip/_internal/utils/logging.py
new file mode 100644
index 00000000..41f6eb51
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/utils/logging.py
@@ -0,0 +1,347 @@
+import contextlib
+import errno
+import logging
+import logging.handlers
+import os
+import sys
+import threading
+from dataclasses import dataclass
+from io import TextIOWrapper
+from logging import Filter
+from typing import Any, ClassVar, Generator, List, Optional, TextIO, Type
+
+from pip._vendor.rich.console import (
+    Console,
+    ConsoleOptions,
+    ConsoleRenderable,
+    RenderableType,
+    RenderResult,
+    RichCast,
+)
+from pip._vendor.rich.highlighter import NullHighlighter
+from pip._vendor.rich.logging import RichHandler
+from pip._vendor.rich.segment import Segment
+from pip._vendor.rich.style import Style
+
+from pip._internal.utils._log import VERBOSE, getLogger
+from pip._internal.utils.compat import WINDOWS
+from pip._internal.utils.deprecation import DEPRECATION_MSG_PREFIX
+from pip._internal.utils.misc import ensure_dir
+
+_log_state = threading.local()
+subprocess_logger = getLogger("pip.subprocessor")
+
+
+class BrokenStdoutLoggingError(Exception):
+    """
+    Raised if BrokenPipeError occurs for the stdout stream while logging.
+    """
+
+
+def _is_broken_pipe_error(exc_class: Type[BaseException], exc: BaseException) -> bool:
+    if exc_class is BrokenPipeError:
+        return True
+
+    # On Windows, a broken pipe can show up as EINVAL rather than EPIPE:
+    # https://bugs.python.org/issue19612
+    # https://bugs.python.org/issue30418
+    if not WINDOWS:
+        return False
+
+    return isinstance(exc, OSError) and exc.errno in (errno.EINVAL, errno.EPIPE)
+
+
+@contextlib.contextmanager
+def indent_log(num: int = 2) -> Generator[None, None, None]:
+    """
+    A context manager which will cause the log output to be indented for any
+    log messages emitted inside it.
+    """
+    # For thread-safety
+    _log_state.indentation = get_indentation()
+    _log_state.indentation += num
+    try:
+        yield
+    finally:
+        _log_state.indentation -= num
+
+
+def get_indentation() -> int:
+    return getattr(_log_state, "indentation", 0)
+
+
+class IndentingFormatter(logging.Formatter):
+    default_time_format = "%Y-%m-%dT%H:%M:%S"
+
+    def __init__(
+        self,
+        *args: Any,
+        add_timestamp: bool = False,
+        **kwargs: Any,
+    ) -> None:
+        """
+        A logging.Formatter that obeys the indent_log() context manager.
+
+        :param add_timestamp: A bool indicating output lines should be prefixed
+            with their record's timestamp.
+        """
+        self.add_timestamp = add_timestamp
+        super().__init__(*args, **kwargs)
+
+    def get_message_start(self, formatted: str, levelno: int) -> str:
+        """
+        Return the start of the formatted log message (not counting the
+        prefix to add to each line).
+        """
+        if levelno < logging.WARNING:
+            return ""
+        if formatted.startswith(DEPRECATION_MSG_PREFIX):
+            # Then the message already has a prefix.  We don't want it to
+            # look like "WARNING: DEPRECATION: ...."
+            return ""
+        if levelno < logging.ERROR:
+            return "WARNING: "
+
+        return "ERROR: "
+
+    def format(self, record: logging.LogRecord) -> str:
+        """
+        Calls the standard formatter, but will indent all of the log message
+        lines by our current indentation level.
+        """
+        formatted = super().format(record)
+        message_start = self.get_message_start(formatted, record.levelno)
+        formatted = message_start + formatted
+
+        prefix = ""
+        if self.add_timestamp:
+            prefix = f"{self.formatTime(record)} "
+        prefix += " " * get_indentation()
+        formatted = "".join([prefix + line for line in formatted.splitlines(True)])
+        return formatted
+
+
+@dataclass
+class IndentedRenderable:
+    renderable: RenderableType
+    indent: int
+
+    def __rich_console__(
+        self, console: Console, options: ConsoleOptions
+    ) -> RenderResult:
+        segments = console.render(self.renderable, options)
+        lines = Segment.split_lines(segments)
+        for line in lines:
+            yield Segment(" " * self.indent)
+            yield from line
+            yield Segment("\n")
+
+
+class RichPipStreamHandler(RichHandler):
+    KEYWORDS: ClassVar[Optional[List[str]]] = []
+
+    def __init__(self, stream: Optional[TextIO], no_color: bool) -> None:
+        super().__init__(
+            console=Console(file=stream, no_color=no_color, soft_wrap=True),
+            show_time=False,
+            show_level=False,
+            show_path=False,
+            highlighter=NullHighlighter(),
+        )
+
+    # Our custom override on Rich's logger, to make things work as we need them to.
+    def emit(self, record: logging.LogRecord) -> None:
+        style: Optional[Style] = None
+
+        # If we are given a diagnostic error to present, present it with indentation.
+        if getattr(record, "rich", False):
+            assert isinstance(record.args, tuple)
+            (rich_renderable,) = record.args
+            assert isinstance(
+                rich_renderable, (ConsoleRenderable, RichCast, str)
+            ), f"{rich_renderable} is not rich-console-renderable"
+
+            renderable: RenderableType = IndentedRenderable(
+                rich_renderable, indent=get_indentation()
+            )
+        else:
+            message = self.format(record)
+            renderable = self.render_message(record, message)
+            if record.levelno is not None:
+                if record.levelno >= logging.ERROR:
+                    style = Style(color="red")
+                elif record.levelno >= logging.WARNING:
+                    style = Style(color="yellow")
+
+        try:
+            self.console.print(renderable, overflow="ignore", crop=False, style=style)
+        except Exception:
+            self.handleError(record)
+
+    def handleError(self, record: logging.LogRecord) -> None:
+        """Called when logging is unable to log some output."""
+
+        exc_class, exc = sys.exc_info()[:2]
+        # If a broken pipe occurred while calling write() or flush() on the
+        # stdout stream in logging's Handler.emit(), then raise our special
+        # exception so we can handle it in main() instead of logging the
+        # broken pipe error and continuing.
+        if (
+            exc_class
+            and exc
+            and self.console.file is sys.stdout
+            and _is_broken_pipe_error(exc_class, exc)
+        ):
+            raise BrokenStdoutLoggingError()
+
+        return super().handleError(record)
+
+
+class BetterRotatingFileHandler(logging.handlers.RotatingFileHandler):
+    def _open(self) -> TextIOWrapper:
+        ensure_dir(os.path.dirname(self.baseFilename))
+        return super()._open()
+
+
+class MaxLevelFilter(Filter):
+    def __init__(self, level: int) -> None:
+        self.level = level
+
+    def filter(self, record: logging.LogRecord) -> bool:
+        return record.levelno < self.level
+
+
+class ExcludeLoggerFilter(Filter):
+    """
+    A logging Filter that excludes records from a logger (or its children).
+    """
+
+    def filter(self, record: logging.LogRecord) -> bool:
+        # The base Filter class allows only records from a logger (or its
+        # children).
+        return not super().filter(record)
+
+
+def setup_logging(verbosity: int, no_color: bool, user_log_file: Optional[str]) -> int:
+    """Configures and sets up all of the logging
+
+    Returns the requested logging level, as its integer value.
+    """
+
+    # Determine the level to be logging at.
+    if verbosity >= 2:
+        level_number = logging.DEBUG
+    elif verbosity == 1:
+        level_number = VERBOSE
+    elif verbosity == -1:
+        level_number = logging.WARNING
+    elif verbosity == -2:
+        level_number = logging.ERROR
+    elif verbosity <= -3:
+        level_number = logging.CRITICAL
+    else:
+        level_number = logging.INFO
+
+    level = logging.getLevelName(level_number)
+
+    # The "root" logger should match the "console" level *unless* we also need
+    # to log to a user log file.
+    include_user_log = user_log_file is not None
+    if include_user_log:
+        additional_log_file = user_log_file
+        root_level = "DEBUG"
+    else:
+        additional_log_file = "/dev/null"
+        root_level = level
+
+    # Disable any logging besides WARNING unless we have DEBUG level logging
+    # enabled for vendored libraries.
+    vendored_log_level = "WARNING" if level in ["INFO", "ERROR"] else "DEBUG"
+
+    # Shorthands for clarity
+    log_streams = {
+        "stdout": "ext://sys.stdout",
+        "stderr": "ext://sys.stderr",
+    }
+    handler_classes = {
+        "stream": "pip._internal.utils.logging.RichPipStreamHandler",
+        "file": "pip._internal.utils.logging.BetterRotatingFileHandler",
+    }
+    handlers = ["console", "console_errors", "console_subprocess"] + (
+        ["user_log"] if include_user_log else []
+    )
+
+    logging.config.dictConfig(
+        {
+            "version": 1,
+            "disable_existing_loggers": False,
+            "filters": {
+                "exclude_warnings": {
+                    "()": "pip._internal.utils.logging.MaxLevelFilter",
+                    "level": logging.WARNING,
+                },
+                "restrict_to_subprocess": {
+                    "()": "logging.Filter",
+                    "name": subprocess_logger.name,
+                },
+                "exclude_subprocess": {
+                    "()": "pip._internal.utils.logging.ExcludeLoggerFilter",
+                    "name": subprocess_logger.name,
+                },
+            },
+            "formatters": {
+                "indent": {
+                    "()": IndentingFormatter,
+                    "format": "%(message)s",
+                },
+                "indent_with_timestamp": {
+                    "()": IndentingFormatter,
+                    "format": "%(message)s",
+                    "add_timestamp": True,
+                },
+            },
+            "handlers": {
+                "console": {
+                    "level": level,
+                    "class": handler_classes["stream"],
+                    "no_color": no_color,
+                    "stream": log_streams["stdout"],
+                    "filters": ["exclude_subprocess", "exclude_warnings"],
+                    "formatter": "indent",
+                },
+                "console_errors": {
+                    "level": "WARNING",
+                    "class": handler_classes["stream"],
+                    "no_color": no_color,
+                    "stream": log_streams["stderr"],
+                    "filters": ["exclude_subprocess"],
+                    "formatter": "indent",
+                },
+                # A handler responsible for logging to the console messages
+                # from the "subprocessor" logger.
+                "console_subprocess": {
+                    "level": level,
+                    "class": handler_classes["stream"],
+                    "stream": log_streams["stderr"],
+                    "no_color": no_color,
+                    "filters": ["restrict_to_subprocess"],
+                    "formatter": "indent",
+                },
+                "user_log": {
+                    "level": "DEBUG",
+                    "class": handler_classes["file"],
+                    "filename": additional_log_file,
+                    "encoding": "utf-8",
+                    "delay": True,
+                    "formatter": "indent_with_timestamp",
+                },
+            },
+            "root": {
+                "level": root_level,
+                "handlers": handlers,
+            },
+            "loggers": {"pip._vendor": {"level": vendored_log_level}},
+        }
+    )
+
+    return level_number
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/utils/misc.py b/venv/lib/python3.12/site-packages/pip/_internal/utils/misc.py
new file mode 100644
index 00000000..3707e872
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/utils/misc.py
@@ -0,0 +1,777 @@
+import errno
+import getpass
+import hashlib
+import logging
+import os
+import posixpath
+import shutil
+import stat
+import sys
+import sysconfig
+import urllib.parse
+from dataclasses import dataclass
+from functools import partial
+from io import StringIO
+from itertools import filterfalse, tee, zip_longest
+from pathlib import Path
+from types import FunctionType, TracebackType
+from typing import (
+    Any,
+    BinaryIO,
+    Callable,
+    Dict,
+    Generator,
+    Iterable,
+    Iterator,
+    List,
+    Optional,
+    TextIO,
+    Tuple,
+    Type,
+    TypeVar,
+    Union,
+    cast,
+)
+
+from pip._vendor.packaging.requirements import Requirement
+from pip._vendor.pyproject_hooks import BuildBackendHookCaller
+
+from pip import __version__
+from pip._internal.exceptions import CommandError, ExternallyManagedEnvironment
+from pip._internal.locations import get_major_minor_version
+from pip._internal.utils.compat import WINDOWS
+from pip._internal.utils.retry import retry
+from pip._internal.utils.virtualenv import running_under_virtualenv
+
+__all__ = [
+    "rmtree",
+    "display_path",
+    "backup_dir",
+    "ask",
+    "splitext",
+    "format_size",
+    "is_installable_dir",
+    "normalize_path",
+    "renames",
+    "get_prog",
+    "ensure_dir",
+    "remove_auth_from_url",
+    "check_externally_managed",
+    "ConfiguredBuildBackendHookCaller",
+]
+
+logger = logging.getLogger(__name__)
+
+T = TypeVar("T")
+ExcInfo = Tuple[Type[BaseException], BaseException, TracebackType]
+VersionInfo = Tuple[int, int, int]
+NetlocTuple = Tuple[str, Tuple[Optional[str], Optional[str]]]
+OnExc = Callable[[FunctionType, Path, BaseException], Any]
+OnErr = Callable[[FunctionType, Path, ExcInfo], Any]
+
+FILE_CHUNK_SIZE = 1024 * 1024
+
+
+def get_pip_version() -> str:
+    pip_pkg_dir = os.path.join(os.path.dirname(__file__), "..", "..")
+    pip_pkg_dir = os.path.abspath(pip_pkg_dir)
+
+    return f"pip {__version__} from {pip_pkg_dir} (python {get_major_minor_version()})"
+
+
+def normalize_version_info(py_version_info: Tuple[int, ...]) -> Tuple[int, int, int]:
+    """
+    Convert a tuple of ints representing a Python version to one of length
+    three.
+
+    :param py_version_info: a tuple of ints representing a Python version,
+        or None to specify no version. The tuple can have any length.
+
+    :return: a tuple of length three if `py_version_info` is non-None.
+        Otherwise, return `py_version_info` unchanged (i.e. None).
+    """
+    if len(py_version_info) < 3:
+        py_version_info += (3 - len(py_version_info)) * (0,)
+    elif len(py_version_info) > 3:
+        py_version_info = py_version_info[:3]
+
+    return cast("VersionInfo", py_version_info)
+
+
+def ensure_dir(path: str) -> None:
+    """os.path.makedirs without EEXIST."""
+    try:
+        os.makedirs(path)
+    except OSError as e:
+        # Windows can raise spurious ENOTEMPTY errors. See #6426.
+        if e.errno != errno.EEXIST and e.errno != errno.ENOTEMPTY:
+            raise
+
+
+def get_prog() -> str:
+    try:
+        prog = os.path.basename(sys.argv[0])
+        if prog in ("__main__.py", "-c"):
+            return f"{sys.executable} -m pip"
+        else:
+            return prog
+    except (AttributeError, TypeError, IndexError):
+        pass
+    return "pip"
+
+
+# Retry every half second for up to 3 seconds
+@retry(stop_after_delay=3, wait=0.5)
+def rmtree(
+    dir: str, ignore_errors: bool = False, onexc: Optional[OnExc] = None
+) -> None:
+    if ignore_errors:
+        onexc = _onerror_ignore
+    if onexc is None:
+        onexc = _onerror_reraise
+    handler: OnErr = partial(
+        # `[func, path, Union[ExcInfo, BaseException]] -> Any` is equivalent to
+        # `Union[([func, path, ExcInfo] -> Any), ([func, path, BaseException] -> Any)]`.
+        cast(Union[OnExc, OnErr], rmtree_errorhandler),
+        onexc=onexc,
+    )
+    if sys.version_info >= (3, 12):
+        # See https://docs.python.org/3.12/whatsnew/3.12.html#shutil.
+        shutil.rmtree(dir, onexc=handler)  # type: ignore
+    else:
+        shutil.rmtree(dir, onerror=handler)  # type: ignore
+
+
+def _onerror_ignore(*_args: Any) -> None:
+    pass
+
+
+def _onerror_reraise(*_args: Any) -> None:
+    raise  # noqa: PLE0704 - Bare exception used to reraise existing exception
+
+
+def rmtree_errorhandler(
+    func: FunctionType,
+    path: Path,
+    exc_info: Union[ExcInfo, BaseException],
+    *,
+    onexc: OnExc = _onerror_reraise,
+) -> None:
+    """
+    `rmtree` error handler to 'force' a file remove (i.e. like `rm -f`).
+
+    * If a file is readonly then it's write flag is set and operation is
+      retried.
+
+    * `onerror` is the original callback from `rmtree(... onerror=onerror)`
+      that is chained at the end if the "rm -f" still fails.
+    """
+    try:
+        st_mode = os.stat(path).st_mode
+    except OSError:
+        # it's equivalent to os.path.exists
+        return
+
+    if not st_mode & stat.S_IWRITE:
+        # convert to read/write
+        try:
+            os.chmod(path, st_mode | stat.S_IWRITE)
+        except OSError:
+            pass
+        else:
+            # use the original function to repeat the operation
+            try:
+                func(path)
+                return
+            except OSError:
+                pass
+
+    if not isinstance(exc_info, BaseException):
+        _, exc_info, _ = exc_info
+    onexc(func, path, exc_info)
+
+
+def display_path(path: str) -> str:
+    """Gives the display value for a given path, making it relative to cwd
+    if possible."""
+    path = os.path.normcase(os.path.abspath(path))
+    if path.startswith(os.getcwd() + os.path.sep):
+        path = "." + path[len(os.getcwd()) :]
+    return path
+
+
+def backup_dir(dir: str, ext: str = ".bak") -> str:
+    """Figure out the name of a directory to back up the given dir to
+    (adding .bak, .bak2, etc)"""
+    n = 1
+    extension = ext
+    while os.path.exists(dir + extension):
+        n += 1
+        extension = ext + str(n)
+    return dir + extension
+
+
+def ask_path_exists(message: str, options: Iterable[str]) -> str:
+    for action in os.environ.get("PIP_EXISTS_ACTION", "").split():
+        if action in options:
+            return action
+    return ask(message, options)
+
+
+def _check_no_input(message: str) -> None:
+    """Raise an error if no input is allowed."""
+    if os.environ.get("PIP_NO_INPUT"):
+        raise Exception(
+            f"No input was expected ($PIP_NO_INPUT set); question: {message}"
+        )
+
+
+def ask(message: str, options: Iterable[str]) -> str:
+    """Ask the message interactively, with the given possible responses"""
+    while 1:
+        _check_no_input(message)
+        response = input(message)
+        response = response.strip().lower()
+        if response not in options:
+            print(
+                "Your response ({!r}) was not one of the expected responses: "
+                "{}".format(response, ", ".join(options))
+            )
+        else:
+            return response
+
+
+def ask_input(message: str) -> str:
+    """Ask for input interactively."""
+    _check_no_input(message)
+    return input(message)
+
+
+def ask_password(message: str) -> str:
+    """Ask for a password interactively."""
+    _check_no_input(message)
+    return getpass.getpass(message)
+
+
+def strtobool(val: str) -> int:
+    """Convert a string representation of truth to true (1) or false (0).
+
+    True values are 'y', 'yes', 't', 'true', 'on', and '1'; false values
+    are 'n', 'no', 'f', 'false', 'off', and '0'.  Raises ValueError if
+    'val' is anything else.
+    """
+    val = val.lower()
+    if val in ("y", "yes", "t", "true", "on", "1"):
+        return 1
+    elif val in ("n", "no", "f", "false", "off", "0"):
+        return 0
+    else:
+        raise ValueError(f"invalid truth value {val!r}")
+
+
+def format_size(bytes: float) -> str:
+    if bytes > 1000 * 1000:
+        return f"{bytes / 1000.0 / 1000:.1f} MB"
+    elif bytes > 10 * 1000:
+        return f"{int(bytes / 1000)} kB"
+    elif bytes > 1000:
+        return f"{bytes / 1000.0:.1f} kB"
+    else:
+        return f"{int(bytes)} bytes"
+
+
+def tabulate(rows: Iterable[Iterable[Any]]) -> Tuple[List[str], List[int]]:
+    """Return a list of formatted rows and a list of column sizes.
+
+    For example::
+
+    >>> tabulate([['foobar', 2000], [0xdeadbeef]])
+    (['foobar     2000', '3735928559'], [10, 4])
+    """
+    rows = [tuple(map(str, row)) for row in rows]
+    sizes = [max(map(len, col)) for col in zip_longest(*rows, fillvalue="")]
+    table = [" ".join(map(str.ljust, row, sizes)).rstrip() for row in rows]
+    return table, sizes
+
+
+def is_installable_dir(path: str) -> bool:
+    """Is path is a directory containing pyproject.toml or setup.py?
+
+    If pyproject.toml exists, this is a PEP 517 project. Otherwise we look for
+    a legacy setuptools layout by identifying setup.py. We don't check for the
+    setup.cfg because using it without setup.py is only available for PEP 517
+    projects, which are already covered by the pyproject.toml check.
+    """
+    if not os.path.isdir(path):
+        return False
+    if os.path.isfile(os.path.join(path, "pyproject.toml")):
+        return True
+    if os.path.isfile(os.path.join(path, "setup.py")):
+        return True
+    return False
+
+
+def read_chunks(
+    file: BinaryIO, size: int = FILE_CHUNK_SIZE
+) -> Generator[bytes, None, None]:
+    """Yield pieces of data from a file-like object until EOF."""
+    while True:
+        chunk = file.read(size)
+        if not chunk:
+            break
+        yield chunk
+
+
+def normalize_path(path: str, resolve_symlinks: bool = True) -> str:
+    """
+    Convert a path to its canonical, case-normalized, absolute version.
+
+    """
+    path = os.path.expanduser(path)
+    if resolve_symlinks:
+        path = os.path.realpath(path)
+    else:
+        path = os.path.abspath(path)
+    return os.path.normcase(path)
+
+
+def splitext(path: str) -> Tuple[str, str]:
+    """Like os.path.splitext, but take off .tar too"""
+    base, ext = posixpath.splitext(path)
+    if base.lower().endswith(".tar"):
+        ext = base[-4:] + ext
+        base = base[:-4]
+    return base, ext
+
+
+def renames(old: str, new: str) -> None:
+    """Like os.renames(), but handles renaming across devices."""
+    # Implementation borrowed from os.renames().
+    head, tail = os.path.split(new)
+    if head and tail and not os.path.exists(head):
+        os.makedirs(head)
+
+    shutil.move(old, new)
+
+    head, tail = os.path.split(old)
+    if head and tail:
+        try:
+            os.removedirs(head)
+        except OSError:
+            pass
+
+
+def is_local(path: str) -> bool:
+    """
+    Return True if path is within sys.prefix, if we're running in a virtualenv.
+
+    If we're not in a virtualenv, all paths are considered "local."
+
+    Caution: this function assumes the head of path has been normalized
+    with normalize_path.
+    """
+    if not running_under_virtualenv():
+        return True
+    return path.startswith(normalize_path(sys.prefix))
+
+
+def write_output(msg: Any, *args: Any) -> None:
+    logger.info(msg, *args)
+
+
+class StreamWrapper(StringIO):
+    orig_stream: TextIO
+
+    @classmethod
+    def from_stream(cls, orig_stream: TextIO) -> "StreamWrapper":
+        ret = cls()
+        ret.orig_stream = orig_stream
+        return ret
+
+    # compileall.compile_dir() needs stdout.encoding to print to stdout
+    # type ignore is because TextIOBase.encoding is writeable
+    @property
+    def encoding(self) -> str:  # type: ignore
+        return self.orig_stream.encoding
+
+
+# Simulates an enum
+def enum(*sequential: Any, **named: Any) -> Type[Any]:
+    enums = dict(zip(sequential, range(len(sequential))), **named)
+    reverse = {value: key for key, value in enums.items()}
+    enums["reverse_mapping"] = reverse
+    return type("Enum", (), enums)
+
+
+def build_netloc(host: str, port: Optional[int]) -> str:
+    """
+    Build a netloc from a host-port pair
+    """
+    if port is None:
+        return host
+    if ":" in host:
+        # Only wrap host with square brackets when it is IPv6
+        host = f"[{host}]"
+    return f"{host}:{port}"
+
+
+def build_url_from_netloc(netloc: str, scheme: str = "https") -> str:
+    """
+    Build a full URL from a netloc.
+    """
+    if netloc.count(":") >= 2 and "@" not in netloc and "[" not in netloc:
+        # It must be a bare IPv6 address, so wrap it with brackets.
+        netloc = f"[{netloc}]"
+    return f"{scheme}://{netloc}"
+
+
+def parse_netloc(netloc: str) -> Tuple[Optional[str], Optional[int]]:
+    """
+    Return the host-port pair from a netloc.
+    """
+    url = build_url_from_netloc(netloc)
+    parsed = urllib.parse.urlparse(url)
+    return parsed.hostname, parsed.port
+
+
+def split_auth_from_netloc(netloc: str) -> NetlocTuple:
+    """
+    Parse out and remove the auth information from a netloc.
+
+    Returns: (netloc, (username, password)).
+    """
+    if "@" not in netloc:
+        return netloc, (None, None)
+
+    # Split from the right because that's how urllib.parse.urlsplit()
+    # behaves if more than one @ is present (which can be checked using
+    # the password attribute of urlsplit()'s return value).
+    auth, netloc = netloc.rsplit("@", 1)
+    pw: Optional[str] = None
+    if ":" in auth:
+        # Split from the left because that's how urllib.parse.urlsplit()
+        # behaves if more than one : is present (which again can be checked
+        # using the password attribute of the return value)
+        user, pw = auth.split(":", 1)
+    else:
+        user, pw = auth, None
+
+    user = urllib.parse.unquote(user)
+    if pw is not None:
+        pw = urllib.parse.unquote(pw)
+
+    return netloc, (user, pw)
+
+
+def redact_netloc(netloc: str) -> str:
+    """
+    Replace the sensitive data in a netloc with "****", if it exists.
+
+    For example:
+        - "user:pass@example.com" returns "user:****@example.com"
+        - "accesstoken@example.com" returns "****@example.com"
+    """
+    netloc, (user, password) = split_auth_from_netloc(netloc)
+    if user is None:
+        return netloc
+    if password is None:
+        user = "****"
+        password = ""
+    else:
+        user = urllib.parse.quote(user)
+        password = ":****"
+    return f"{user}{password}@{netloc}"
+
+
+def _transform_url(
+    url: str, transform_netloc: Callable[[str], Tuple[Any, ...]]
+) -> Tuple[str, NetlocTuple]:
+    """Transform and replace netloc in a url.
+
+    transform_netloc is a function taking the netloc and returning a
+    tuple. The first element of this tuple is the new netloc. The
+    entire tuple is returned.
+
+    Returns a tuple containing the transformed url as item 0 and the
+    original tuple returned by transform_netloc as item 1.
+    """
+    purl = urllib.parse.urlsplit(url)
+    netloc_tuple = transform_netloc(purl.netloc)
+    # stripped url
+    url_pieces = (purl.scheme, netloc_tuple[0], purl.path, purl.query, purl.fragment)
+    surl = urllib.parse.urlunsplit(url_pieces)
+    return surl, cast("NetlocTuple", netloc_tuple)
+
+
+def _get_netloc(netloc: str) -> NetlocTuple:
+    return split_auth_from_netloc(netloc)
+
+
+def _redact_netloc(netloc: str) -> Tuple[str]:
+    return (redact_netloc(netloc),)
+
+
+def split_auth_netloc_from_url(
+    url: str,
+) -> Tuple[str, str, Tuple[Optional[str], Optional[str]]]:
+    """
+    Parse a url into separate netloc, auth, and url with no auth.
+
+    Returns: (url_without_auth, netloc, (username, password))
+    """
+    url_without_auth, (netloc, auth) = _transform_url(url, _get_netloc)
+    return url_without_auth, netloc, auth
+
+
+def remove_auth_from_url(url: str) -> str:
+    """Return a copy of url with 'username:password@' removed."""
+    # username/pass params are passed to subversion through flags
+    # and are not recognized in the url.
+    return _transform_url(url, _get_netloc)[0]
+
+
+def redact_auth_from_url(url: str) -> str:
+    """Replace the password in a given url with ****."""
+    return _transform_url(url, _redact_netloc)[0]
+
+
+def redact_auth_from_requirement(req: Requirement) -> str:
+    """Replace the password in a given requirement url with ****."""
+    if not req.url:
+        return str(req)
+    return str(req).replace(req.url, redact_auth_from_url(req.url))
+
+
+@dataclass(frozen=True)
+class HiddenText:
+    secret: str
+    redacted: str
+
+    def __repr__(self) -> str:
+        return f""
+
+    def __str__(self) -> str:
+        return self.redacted
+
+    # This is useful for testing.
+    def __eq__(self, other: Any) -> bool:
+        if type(self) != type(other):
+            return False
+
+        # The string being used for redaction doesn't also have to match,
+        # just the raw, original string.
+        return self.secret == other.secret
+
+
+def hide_value(value: str) -> HiddenText:
+    return HiddenText(value, redacted="****")
+
+
+def hide_url(url: str) -> HiddenText:
+    redacted = redact_auth_from_url(url)
+    return HiddenText(url, redacted=redacted)
+
+
+def protect_pip_from_modification_on_windows(modifying_pip: bool) -> None:
+    """Protection of pip.exe from modification on Windows
+
+    On Windows, any operation modifying pip should be run as:
+        python -m pip ...
+    """
+    pip_names = [
+        "pip",
+        f"pip{sys.version_info.major}",
+        f"pip{sys.version_info.major}.{sys.version_info.minor}",
+    ]
+
+    # See https://github.com/pypa/pip/issues/1299 for more discussion
+    should_show_use_python_msg = (
+        modifying_pip and WINDOWS and os.path.basename(sys.argv[0]) in pip_names
+    )
+
+    if should_show_use_python_msg:
+        new_command = [sys.executable, "-m", "pip"] + sys.argv[1:]
+        raise CommandError(
+            "To modify pip, please run the following command:\n{}".format(
+                " ".join(new_command)
+            )
+        )
+
+
+def check_externally_managed() -> None:
+    """Check whether the current environment is externally managed.
+
+    If the ``EXTERNALLY-MANAGED`` config file is found, the current environment
+    is considered externally managed, and an ExternallyManagedEnvironment is
+    raised.
+    """
+    if running_under_virtualenv():
+        return
+    marker = os.path.join(sysconfig.get_path("stdlib"), "EXTERNALLY-MANAGED")
+    if not os.path.isfile(marker):
+        return
+    raise ExternallyManagedEnvironment.from_config(marker)
+
+
+def is_console_interactive() -> bool:
+    """Is this console interactive?"""
+    return sys.stdin is not None and sys.stdin.isatty()
+
+
+def hash_file(path: str, blocksize: int = 1 << 20) -> Tuple[Any, int]:
+    """Return (hash, length) for path using hashlib.sha256()"""
+
+    h = hashlib.sha256()
+    length = 0
+    with open(path, "rb") as f:
+        for block in read_chunks(f, size=blocksize):
+            length += len(block)
+            h.update(block)
+    return h, length
+
+
+def pairwise(iterable: Iterable[Any]) -> Iterator[Tuple[Any, Any]]:
+    """
+    Return paired elements.
+
+    For example:
+        s -> (s0, s1), (s2, s3), (s4, s5), ...
+    """
+    iterable = iter(iterable)
+    return zip_longest(iterable, iterable)
+
+
+def partition(
+    pred: Callable[[T], bool], iterable: Iterable[T]
+) -> Tuple[Iterable[T], Iterable[T]]:
+    """
+    Use a predicate to partition entries into false entries and true entries,
+    like
+
+        partition(is_odd, range(10)) --> 0 2 4 6 8   and  1 3 5 7 9
+    """
+    t1, t2 = tee(iterable)
+    return filterfalse(pred, t1), filter(pred, t2)
+
+
+class ConfiguredBuildBackendHookCaller(BuildBackendHookCaller):
+    def __init__(
+        self,
+        config_holder: Any,
+        source_dir: str,
+        build_backend: str,
+        backend_path: Optional[str] = None,
+        runner: Optional[Callable[..., None]] = None,
+        python_executable: Optional[str] = None,
+    ):
+        super().__init__(
+            source_dir, build_backend, backend_path, runner, python_executable
+        )
+        self.config_holder = config_holder
+
+    def build_wheel(
+        self,
+        wheel_directory: str,
+        config_settings: Optional[Dict[str, Union[str, List[str]]]] = None,
+        metadata_directory: Optional[str] = None,
+    ) -> str:
+        cs = self.config_holder.config_settings
+        return super().build_wheel(
+            wheel_directory, config_settings=cs, metadata_directory=metadata_directory
+        )
+
+    def build_sdist(
+        self,
+        sdist_directory: str,
+        config_settings: Optional[Dict[str, Union[str, List[str]]]] = None,
+    ) -> str:
+        cs = self.config_holder.config_settings
+        return super().build_sdist(sdist_directory, config_settings=cs)
+
+    def build_editable(
+        self,
+        wheel_directory: str,
+        config_settings: Optional[Dict[str, Union[str, List[str]]]] = None,
+        metadata_directory: Optional[str] = None,
+    ) -> str:
+        cs = self.config_holder.config_settings
+        return super().build_editable(
+            wheel_directory, config_settings=cs, metadata_directory=metadata_directory
+        )
+
+    def get_requires_for_build_wheel(
+        self, config_settings: Optional[Dict[str, Union[str, List[str]]]] = None
+    ) -> List[str]:
+        cs = self.config_holder.config_settings
+        return super().get_requires_for_build_wheel(config_settings=cs)
+
+    def get_requires_for_build_sdist(
+        self, config_settings: Optional[Dict[str, Union[str, List[str]]]] = None
+    ) -> List[str]:
+        cs = self.config_holder.config_settings
+        return super().get_requires_for_build_sdist(config_settings=cs)
+
+    def get_requires_for_build_editable(
+        self, config_settings: Optional[Dict[str, Union[str, List[str]]]] = None
+    ) -> List[str]:
+        cs = self.config_holder.config_settings
+        return super().get_requires_for_build_editable(config_settings=cs)
+
+    def prepare_metadata_for_build_wheel(
+        self,
+        metadata_directory: str,
+        config_settings: Optional[Dict[str, Union[str, List[str]]]] = None,
+        _allow_fallback: bool = True,
+    ) -> str:
+        cs = self.config_holder.config_settings
+        return super().prepare_metadata_for_build_wheel(
+            metadata_directory=metadata_directory,
+            config_settings=cs,
+            _allow_fallback=_allow_fallback,
+        )
+
+    def prepare_metadata_for_build_editable(
+        self,
+        metadata_directory: str,
+        config_settings: Optional[Dict[str, Union[str, List[str]]]] = None,
+        _allow_fallback: bool = True,
+    ) -> str:
+        cs = self.config_holder.config_settings
+        return super().prepare_metadata_for_build_editable(
+            metadata_directory=metadata_directory,
+            config_settings=cs,
+            _allow_fallback=_allow_fallback,
+        )
+
+
+def warn_if_run_as_root() -> None:
+    """Output a warning for sudo users on Unix.
+
+    In a virtual environment, sudo pip still writes to virtualenv.
+    On Windows, users may run pip as Administrator without issues.
+    This warning only applies to Unix root users outside of virtualenv.
+    """
+    if running_under_virtualenv():
+        return
+    if not hasattr(os, "getuid"):
+        return
+    # On Windows, there are no "system managed" Python packages. Installing as
+    # Administrator via pip is the correct way of updating system environments.
+    #
+    # We choose sys.platform over utils.compat.WINDOWS here to enable Mypy platform
+    # checks: https://mypy.readthedocs.io/en/stable/common_issues.html
+    if sys.platform == "win32" or sys.platform == "cygwin":
+        return
+
+    if os.getuid() != 0:
+        return
+
+    logger.warning(
+        "Running pip as the 'root' user can result in broken permissions and "
+        "conflicting behaviour with the system package manager, possibly "
+        "rendering your system unusable."
+        "It is recommended to use a virtual environment instead: "
+        "https://pip.pypa.io/warnings/venv. "
+        "Use the --root-user-action option if you know what you are doing and "
+        "want to suppress this warning."
+    )
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/utils/packaging.py b/venv/lib/python3.12/site-packages/pip/_internal/utils/packaging.py
new file mode 100644
index 00000000..4b8fa0fe
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/utils/packaging.py
@@ -0,0 +1,57 @@
+import functools
+import logging
+import re
+from typing import NewType, Optional, Tuple, cast
+
+from pip._vendor.packaging import specifiers, version
+from pip._vendor.packaging.requirements import Requirement
+
+NormalizedExtra = NewType("NormalizedExtra", str)
+
+logger = logging.getLogger(__name__)
+
+
+def check_requires_python(
+    requires_python: Optional[str], version_info: Tuple[int, ...]
+) -> bool:
+    """
+    Check if the given Python version matches a "Requires-Python" specifier.
+
+    :param version_info: A 3-tuple of ints representing a Python
+        major-minor-micro version to check (e.g. `sys.version_info[:3]`).
+
+    :return: `True` if the given Python version satisfies the requirement.
+        Otherwise, return `False`.
+
+    :raises InvalidSpecifier: If `requires_python` has an invalid format.
+    """
+    if requires_python is None:
+        # The package provides no information
+        return True
+    requires_python_specifier = specifiers.SpecifierSet(requires_python)
+
+    python_version = version.parse(".".join(map(str, version_info)))
+    return python_version in requires_python_specifier
+
+
+@functools.lru_cache(maxsize=2048)
+def get_requirement(req_string: str) -> Requirement:
+    """Construct a packaging.Requirement object with caching"""
+    # Parsing requirement strings is expensive, and is also expected to happen
+    # with a low diversity of different arguments (at least relative the number
+    # constructed). This method adds a cache to requirement object creation to
+    # minimize repeated parsing of the same string to construct equivalent
+    # Requirement objects.
+    return Requirement(req_string)
+
+
+def safe_extra(extra: str) -> NormalizedExtra:
+    """Convert an arbitrary string to a standard 'extra' name
+
+    Any runs of non-alphanumeric characters are replaced with a single '_',
+    and the result is always lowercased.
+
+    This function is duplicated from ``pkg_resources``. Note that this is not
+    the same to either ``canonicalize_name`` or ``_egg_link_name``.
+    """
+    return cast(NormalizedExtra, re.sub("[^A-Za-z0-9.-]+", "_", extra).lower())
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/utils/retry.py b/venv/lib/python3.12/site-packages/pip/_internal/utils/retry.py
new file mode 100644
index 00000000..abfe0728
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/utils/retry.py
@@ -0,0 +1,42 @@
+import functools
+from time import perf_counter, sleep
+from typing import Callable, TypeVar
+
+from pip._vendor.typing_extensions import ParamSpec
+
+T = TypeVar("T")
+P = ParamSpec("P")
+
+
+def retry(
+    wait: float, stop_after_delay: float
+) -> Callable[[Callable[P, T]], Callable[P, T]]:
+    """Decorator to automatically retry a function on error.
+
+    If the function raises, the function is recalled with the same arguments
+    until it returns or the time limit is reached. When the time limit is
+    surpassed, the last exception raised is reraised.
+
+    :param wait: The time to wait after an error before retrying, in seconds.
+    :param stop_after_delay: The time limit after which retries will cease,
+        in seconds.
+    """
+
+    def wrapper(func: Callable[P, T]) -> Callable[P, T]:
+
+        @functools.wraps(func)
+        def retry_wrapped(*args: P.args, **kwargs: P.kwargs) -> T:
+            # The performance counter is monotonic on all platforms we care
+            # about and has much better resolution than time.monotonic().
+            start_time = perf_counter()
+            while True:
+                try:
+                    return func(*args, **kwargs)
+                except Exception:
+                    if perf_counter() - start_time > stop_after_delay:
+                        raise
+                    sleep(wait)
+
+        return retry_wrapped
+
+    return wrapper
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/utils/setuptools_build.py b/venv/lib/python3.12/site-packages/pip/_internal/utils/setuptools_build.py
new file mode 100644
index 00000000..96d1b246
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/utils/setuptools_build.py
@@ -0,0 +1,146 @@
+import sys
+import textwrap
+from typing import List, Optional, Sequence
+
+# Shim to wrap setup.py invocation with setuptools
+# Note that __file__ is handled via two {!r} *and* %r, to ensure that paths on
+# Windows are correctly handled (it should be "C:\\Users" not "C:\Users").
+_SETUPTOOLS_SHIM = textwrap.dedent(
+    """
+    exec(compile('''
+    # This is  -- a caller that pip uses to run setup.py
+    #
+    # - It imports setuptools before invoking setup.py, to enable projects that directly
+    #   import from `distutils.core` to work with newer packaging standards.
+    # - It provides a clear error message when setuptools is not installed.
+    # - It sets `sys.argv[0]` to the underlying `setup.py`, when invoking `setup.py` so
+    #   setuptools doesn't think the script is `-c`. This avoids the following warning:
+    #     manifest_maker: standard file '-c' not found".
+    # - It generates a shim setup.py, for handling setup.cfg-only projects.
+    import os, sys, tokenize
+
+    try:
+        import setuptools
+    except ImportError as error:
+        print(
+            "ERROR: Can not execute `setup.py` since setuptools is not available in "
+            "the build environment.",
+            file=sys.stderr,
+        )
+        sys.exit(1)
+
+    __file__ = %r
+    sys.argv[0] = __file__
+
+    if os.path.exists(__file__):
+        filename = __file__
+        with tokenize.open(__file__) as f:
+            setup_py_code = f.read()
+    else:
+        filename = ""
+        setup_py_code = "from setuptools import setup; setup()"
+
+    exec(compile(setup_py_code, filename, "exec"))
+    ''' % ({!r},), "", "exec"))
+    """
+).rstrip()
+
+
+def make_setuptools_shim_args(
+    setup_py_path: str,
+    global_options: Optional[Sequence[str]] = None,
+    no_user_config: bool = False,
+    unbuffered_output: bool = False,
+) -> List[str]:
+    """
+    Get setuptools command arguments with shim wrapped setup file invocation.
+
+    :param setup_py_path: The path to setup.py to be wrapped.
+    :param global_options: Additional global options.
+    :param no_user_config: If True, disables personal user configuration.
+    :param unbuffered_output: If True, adds the unbuffered switch to the
+     argument list.
+    """
+    args = [sys.executable]
+    if unbuffered_output:
+        args += ["-u"]
+    args += ["-c", _SETUPTOOLS_SHIM.format(setup_py_path)]
+    if global_options:
+        args += global_options
+    if no_user_config:
+        args += ["--no-user-cfg"]
+    return args
+
+
+def make_setuptools_bdist_wheel_args(
+    setup_py_path: str,
+    global_options: Sequence[str],
+    build_options: Sequence[str],
+    destination_dir: str,
+) -> List[str]:
+    # NOTE: Eventually, we'd want to also -S to the flags here, when we're
+    # isolating. Currently, it breaks Python in virtualenvs, because it
+    # relies on site.py to find parts of the standard library outside the
+    # virtualenv.
+    args = make_setuptools_shim_args(
+        setup_py_path, global_options=global_options, unbuffered_output=True
+    )
+    args += ["bdist_wheel", "-d", destination_dir]
+    args += build_options
+    return args
+
+
+def make_setuptools_clean_args(
+    setup_py_path: str,
+    global_options: Sequence[str],
+) -> List[str]:
+    args = make_setuptools_shim_args(
+        setup_py_path, global_options=global_options, unbuffered_output=True
+    )
+    args += ["clean", "--all"]
+    return args
+
+
+def make_setuptools_develop_args(
+    setup_py_path: str,
+    *,
+    global_options: Sequence[str],
+    no_user_config: bool,
+    prefix: Optional[str],
+    home: Optional[str],
+    use_user_site: bool,
+) -> List[str]:
+    assert not (use_user_site and prefix)
+
+    args = make_setuptools_shim_args(
+        setup_py_path,
+        global_options=global_options,
+        no_user_config=no_user_config,
+    )
+
+    args += ["develop", "--no-deps"]
+
+    if prefix:
+        args += ["--prefix", prefix]
+    if home is not None:
+        args += ["--install-dir", home]
+
+    if use_user_site:
+        args += ["--user", "--prefix="]
+
+    return args
+
+
+def make_setuptools_egg_info_args(
+    setup_py_path: str,
+    egg_info_dir: Optional[str],
+    no_user_config: bool,
+) -> List[str]:
+    args = make_setuptools_shim_args(setup_py_path, no_user_config=no_user_config)
+
+    args += ["egg_info"]
+
+    if egg_info_dir:
+        args += ["--egg-base", egg_info_dir]
+
+    return args
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/utils/subprocess.py b/venv/lib/python3.12/site-packages/pip/_internal/utils/subprocess.py
new file mode 100644
index 00000000..cb2e23f0
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/utils/subprocess.py
@@ -0,0 +1,245 @@
+import logging
+import os
+import shlex
+import subprocess
+from typing import Any, Callable, Iterable, List, Literal, Mapping, Optional, Union
+
+from pip._vendor.rich.markup import escape
+
+from pip._internal.cli.spinners import SpinnerInterface, open_spinner
+from pip._internal.exceptions import InstallationSubprocessError
+from pip._internal.utils.logging import VERBOSE, subprocess_logger
+from pip._internal.utils.misc import HiddenText
+
+CommandArgs = List[Union[str, HiddenText]]
+
+
+def make_command(*args: Union[str, HiddenText, CommandArgs]) -> CommandArgs:
+    """
+    Create a CommandArgs object.
+    """
+    command_args: CommandArgs = []
+    for arg in args:
+        # Check for list instead of CommandArgs since CommandArgs is
+        # only known during type-checking.
+        if isinstance(arg, list):
+            command_args.extend(arg)
+        else:
+            # Otherwise, arg is str or HiddenText.
+            command_args.append(arg)
+
+    return command_args
+
+
+def format_command_args(args: Union[List[str], CommandArgs]) -> str:
+    """
+    Format command arguments for display.
+    """
+    # For HiddenText arguments, display the redacted form by calling str().
+    # Also, we don't apply str() to arguments that aren't HiddenText since
+    # this can trigger a UnicodeDecodeError in Python 2 if the argument
+    # has type unicode and includes a non-ascii character.  (The type
+    # checker doesn't ensure the annotations are correct in all cases.)
+    return " ".join(
+        shlex.quote(str(arg)) if isinstance(arg, HiddenText) else shlex.quote(arg)
+        for arg in args
+    )
+
+
+def reveal_command_args(args: Union[List[str], CommandArgs]) -> List[str]:
+    """
+    Return the arguments in their raw, unredacted form.
+    """
+    return [arg.secret if isinstance(arg, HiddenText) else arg for arg in args]
+
+
+def call_subprocess(
+    cmd: Union[List[str], CommandArgs],
+    show_stdout: bool = False,
+    cwd: Optional[str] = None,
+    on_returncode: 'Literal["raise", "warn", "ignore"]' = "raise",
+    extra_ok_returncodes: Optional[Iterable[int]] = None,
+    extra_environ: Optional[Mapping[str, Any]] = None,
+    unset_environ: Optional[Iterable[str]] = None,
+    spinner: Optional[SpinnerInterface] = None,
+    log_failed_cmd: Optional[bool] = True,
+    stdout_only: Optional[bool] = False,
+    *,
+    command_desc: str,
+) -> str:
+    """
+    Args:
+      show_stdout: if true, use INFO to log the subprocess's stderr and
+        stdout streams.  Otherwise, use DEBUG.  Defaults to False.
+      extra_ok_returncodes: an iterable of integer return codes that are
+        acceptable, in addition to 0. Defaults to None, which means [].
+      unset_environ: an iterable of environment variable names to unset
+        prior to calling subprocess.Popen().
+      log_failed_cmd: if false, failed commands are not logged, only raised.
+      stdout_only: if true, return only stdout, else return both. When true,
+        logging of both stdout and stderr occurs when the subprocess has
+        terminated, else logging occurs as subprocess output is produced.
+    """
+    if extra_ok_returncodes is None:
+        extra_ok_returncodes = []
+    if unset_environ is None:
+        unset_environ = []
+    # Most places in pip use show_stdout=False. What this means is--
+    #
+    # - We connect the child's output (combined stderr and stdout) to a
+    #   single pipe, which we read.
+    # - We log this output to stderr at DEBUG level as it is received.
+    # - If DEBUG logging isn't enabled (e.g. if --verbose logging wasn't
+    #   requested), then we show a spinner so the user can still see the
+    #   subprocess is in progress.
+    # - If the subprocess exits with an error, we log the output to stderr
+    #   at ERROR level if it hasn't already been displayed to the console
+    #   (e.g. if --verbose logging wasn't enabled).  This way we don't log
+    #   the output to the console twice.
+    #
+    # If show_stdout=True, then the above is still done, but with DEBUG
+    # replaced by INFO.
+    if show_stdout:
+        # Then log the subprocess output at INFO level.
+        log_subprocess: Callable[..., None] = subprocess_logger.info
+        used_level = logging.INFO
+    else:
+        # Then log the subprocess output using VERBOSE.  This also ensures
+        # it will be logged to the log file (aka user_log), if enabled.
+        log_subprocess = subprocess_logger.verbose
+        used_level = VERBOSE
+
+    # Whether the subprocess will be visible in the console.
+    showing_subprocess = subprocess_logger.getEffectiveLevel() <= used_level
+
+    # Only use the spinner if we're not showing the subprocess output
+    # and we have a spinner.
+    use_spinner = not showing_subprocess and spinner is not None
+
+    log_subprocess("Running command %s", command_desc)
+    env = os.environ.copy()
+    if extra_environ:
+        env.update(extra_environ)
+    for name in unset_environ:
+        env.pop(name, None)
+    try:
+        proc = subprocess.Popen(
+            # Convert HiddenText objects to the underlying str.
+            reveal_command_args(cmd),
+            stdin=subprocess.PIPE,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT if not stdout_only else subprocess.PIPE,
+            cwd=cwd,
+            env=env,
+            errors="backslashreplace",
+        )
+    except Exception as exc:
+        if log_failed_cmd:
+            subprocess_logger.critical(
+                "Error %s while executing command %s",
+                exc,
+                command_desc,
+            )
+        raise
+    all_output = []
+    if not stdout_only:
+        assert proc.stdout
+        assert proc.stdin
+        proc.stdin.close()
+        # In this mode, stdout and stderr are in the same pipe.
+        while True:
+            line: str = proc.stdout.readline()
+            if not line:
+                break
+            line = line.rstrip()
+            all_output.append(line + "\n")
+
+            # Show the line immediately.
+            log_subprocess(line)
+            # Update the spinner.
+            if use_spinner:
+                assert spinner
+                spinner.spin()
+        try:
+            proc.wait()
+        finally:
+            if proc.stdout:
+                proc.stdout.close()
+        output = "".join(all_output)
+    else:
+        # In this mode, stdout and stderr are in different pipes.
+        # We must use communicate() which is the only safe way to read both.
+        out, err = proc.communicate()
+        # log line by line to preserve pip log indenting
+        for out_line in out.splitlines():
+            log_subprocess(out_line)
+        all_output.append(out)
+        for err_line in err.splitlines():
+            log_subprocess(err_line)
+        all_output.append(err)
+        output = out
+
+    proc_had_error = proc.returncode and proc.returncode not in extra_ok_returncodes
+    if use_spinner:
+        assert spinner
+        if proc_had_error:
+            spinner.finish("error")
+        else:
+            spinner.finish("done")
+    if proc_had_error:
+        if on_returncode == "raise":
+            error = InstallationSubprocessError(
+                command_description=command_desc,
+                exit_code=proc.returncode,
+                output_lines=all_output if not showing_subprocess else None,
+            )
+            if log_failed_cmd:
+                subprocess_logger.error("%s", error, extra={"rich": True})
+                subprocess_logger.verbose(
+                    "[bold magenta]full command[/]: [blue]%s[/]",
+                    escape(format_command_args(cmd)),
+                    extra={"markup": True},
+                )
+                subprocess_logger.verbose(
+                    "[bold magenta]cwd[/]: %s",
+                    escape(cwd or "[inherit]"),
+                    extra={"markup": True},
+                )
+
+            raise error
+        elif on_returncode == "warn":
+            subprocess_logger.warning(
+                'Command "%s" had error code %s in %s',
+                command_desc,
+                proc.returncode,
+                cwd,
+            )
+        elif on_returncode == "ignore":
+            pass
+        else:
+            raise ValueError(f"Invalid value: on_returncode={on_returncode!r}")
+    return output
+
+
+def runner_with_spinner_message(message: str) -> Callable[..., None]:
+    """Provide a subprocess_runner that shows a spinner message.
+
+    Intended for use with for BuildBackendHookCaller. Thus, the runner has
+    an API that matches what's expected by BuildBackendHookCaller.subprocess_runner.
+    """
+
+    def runner(
+        cmd: List[str],
+        cwd: Optional[str] = None,
+        extra_environ: Optional[Mapping[str, Any]] = None,
+    ) -> None:
+        with open_spinner(message) as spinner:
+            call_subprocess(
+                cmd,
+                command_desc=message,
+                cwd=cwd,
+                extra_environ=extra_environ,
+                spinner=spinner,
+            )
+
+    return runner
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/utils/temp_dir.py b/venv/lib/python3.12/site-packages/pip/_internal/utils/temp_dir.py
new file mode 100644
index 00000000..06668e8a
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/utils/temp_dir.py
@@ -0,0 +1,296 @@
+import errno
+import itertools
+import logging
+import os.path
+import tempfile
+import traceback
+from contextlib import ExitStack, contextmanager
+from pathlib import Path
+from typing import (
+    Any,
+    Callable,
+    Dict,
+    Generator,
+    List,
+    Optional,
+    TypeVar,
+    Union,
+)
+
+from pip._internal.utils.misc import enum, rmtree
+
+logger = logging.getLogger(__name__)
+
+_T = TypeVar("_T", bound="TempDirectory")
+
+
+# Kinds of temporary directories. Only needed for ones that are
+# globally-managed.
+tempdir_kinds = enum(
+    BUILD_ENV="build-env",
+    EPHEM_WHEEL_CACHE="ephem-wheel-cache",
+    REQ_BUILD="req-build",
+)
+
+
+_tempdir_manager: Optional[ExitStack] = None
+
+
+@contextmanager
+def global_tempdir_manager() -> Generator[None, None, None]:
+    global _tempdir_manager
+    with ExitStack() as stack:
+        old_tempdir_manager, _tempdir_manager = _tempdir_manager, stack
+        try:
+            yield
+        finally:
+            _tempdir_manager = old_tempdir_manager
+
+
+class TempDirectoryTypeRegistry:
+    """Manages temp directory behavior"""
+
+    def __init__(self) -> None:
+        self._should_delete: Dict[str, bool] = {}
+
+    def set_delete(self, kind: str, value: bool) -> None:
+        """Indicate whether a TempDirectory of the given kind should be
+        auto-deleted.
+        """
+        self._should_delete[kind] = value
+
+    def get_delete(self, kind: str) -> bool:
+        """Get configured auto-delete flag for a given TempDirectory type,
+        default True.
+        """
+        return self._should_delete.get(kind, True)
+
+
+_tempdir_registry: Optional[TempDirectoryTypeRegistry] = None
+
+
+@contextmanager
+def tempdir_registry() -> Generator[TempDirectoryTypeRegistry, None, None]:
+    """Provides a scoped global tempdir registry that can be used to dictate
+    whether directories should be deleted.
+    """
+    global _tempdir_registry
+    old_tempdir_registry = _tempdir_registry
+    _tempdir_registry = TempDirectoryTypeRegistry()
+    try:
+        yield _tempdir_registry
+    finally:
+        _tempdir_registry = old_tempdir_registry
+
+
+class _Default:
+    pass
+
+
+_default = _Default()
+
+
+class TempDirectory:
+    """Helper class that owns and cleans up a temporary directory.
+
+    This class can be used as a context manager or as an OO representation of a
+    temporary directory.
+
+    Attributes:
+        path
+            Location to the created temporary directory
+        delete
+            Whether the directory should be deleted when exiting
+            (when used as a contextmanager)
+
+    Methods:
+        cleanup()
+            Deletes the temporary directory
+
+    When used as a context manager, if the delete attribute is True, on
+    exiting the context the temporary directory is deleted.
+    """
+
+    def __init__(
+        self,
+        path: Optional[str] = None,
+        delete: Union[bool, None, _Default] = _default,
+        kind: str = "temp",
+        globally_managed: bool = False,
+        ignore_cleanup_errors: bool = True,
+    ):
+        super().__init__()
+
+        if delete is _default:
+            if path is not None:
+                # If we were given an explicit directory, resolve delete option
+                # now.
+                delete = False
+            else:
+                # Otherwise, we wait until cleanup and see what
+                # tempdir_registry says.
+                delete = None
+
+        # The only time we specify path is in for editables where it
+        # is the value of the --src option.
+        if path is None:
+            path = self._create(kind)
+
+        self._path = path
+        self._deleted = False
+        self.delete = delete
+        self.kind = kind
+        self.ignore_cleanup_errors = ignore_cleanup_errors
+
+        if globally_managed:
+            assert _tempdir_manager is not None
+            _tempdir_manager.enter_context(self)
+
+    @property
+    def path(self) -> str:
+        assert not self._deleted, f"Attempted to access deleted path: {self._path}"
+        return self._path
+
+    def __repr__(self) -> str:
+        return f"<{self.__class__.__name__} {self.path!r}>"
+
+    def __enter__(self: _T) -> _T:
+        return self
+
+    def __exit__(self, exc: Any, value: Any, tb: Any) -> None:
+        if self.delete is not None:
+            delete = self.delete
+        elif _tempdir_registry:
+            delete = _tempdir_registry.get_delete(self.kind)
+        else:
+            delete = True
+
+        if delete:
+            self.cleanup()
+
+    def _create(self, kind: str) -> str:
+        """Create a temporary directory and store its path in self.path"""
+        # We realpath here because some systems have their default tmpdir
+        # symlinked to another directory.  This tends to confuse build
+        # scripts, so we canonicalize the path by traversing potential
+        # symlinks here.
+        path = os.path.realpath(tempfile.mkdtemp(prefix=f"pip-{kind}-"))
+        logger.debug("Created temporary directory: %s", path)
+        return path
+
+    def cleanup(self) -> None:
+        """Remove the temporary directory created and reset state"""
+        self._deleted = True
+        if not os.path.exists(self._path):
+            return
+
+        errors: List[BaseException] = []
+
+        def onerror(
+            func: Callable[..., Any],
+            path: Path,
+            exc_val: BaseException,
+        ) -> None:
+            """Log a warning for a `rmtree` error and continue"""
+            formatted_exc = "\n".join(
+                traceback.format_exception_only(type(exc_val), exc_val)
+            )
+            formatted_exc = formatted_exc.rstrip()  # remove trailing new line
+            if func in (os.unlink, os.remove, os.rmdir):
+                logger.debug(
+                    "Failed to remove a temporary file '%s' due to %s.\n",
+                    path,
+                    formatted_exc,
+                )
+            else:
+                logger.debug("%s failed with %s.", func.__qualname__, formatted_exc)
+            errors.append(exc_val)
+
+        if self.ignore_cleanup_errors:
+            try:
+                # first try with @retry; retrying to handle ephemeral errors
+                rmtree(self._path, ignore_errors=False)
+            except OSError:
+                # last pass ignore/log all errors
+                rmtree(self._path, onexc=onerror)
+            if errors:
+                logger.warning(
+                    "Failed to remove contents in a temporary directory '%s'.\n"
+                    "You can safely remove it manually.",
+                    self._path,
+                )
+        else:
+            rmtree(self._path)
+
+
+class AdjacentTempDirectory(TempDirectory):
+    """Helper class that creates a temporary directory adjacent to a real one.
+
+    Attributes:
+        original
+            The original directory to create a temp directory for.
+        path
+            After calling create() or entering, contains the full
+            path to the temporary directory.
+        delete
+            Whether the directory should be deleted when exiting
+            (when used as a contextmanager)
+
+    """
+
+    # The characters that may be used to name the temp directory
+    # We always prepend a ~ and then rotate through these until
+    # a usable name is found.
+    # pkg_resources raises a different error for .dist-info folder
+    # with leading '-' and invalid metadata
+    LEADING_CHARS = "-~.=%0123456789"
+
+    def __init__(self, original: str, delete: Optional[bool] = None) -> None:
+        self.original = original.rstrip("/\\")
+        super().__init__(delete=delete)
+
+    @classmethod
+    def _generate_names(cls, name: str) -> Generator[str, None, None]:
+        """Generates a series of temporary names.
+
+        The algorithm replaces the leading characters in the name
+        with ones that are valid filesystem characters, but are not
+        valid package names (for both Python and pip definitions of
+        package).
+        """
+        for i in range(1, len(name)):
+            for candidate in itertools.combinations_with_replacement(
+                cls.LEADING_CHARS, i - 1
+            ):
+                new_name = "~" + "".join(candidate) + name[i:]
+                if new_name != name:
+                    yield new_name
+
+        # If we make it this far, we will have to make a longer name
+        for i in range(len(cls.LEADING_CHARS)):
+            for candidate in itertools.combinations_with_replacement(
+                cls.LEADING_CHARS, i
+            ):
+                new_name = "~" + "".join(candidate) + name
+                if new_name != name:
+                    yield new_name
+
+    def _create(self, kind: str) -> str:
+        root, name = os.path.split(self.original)
+        for candidate in self._generate_names(name):
+            path = os.path.join(root, candidate)
+            try:
+                os.mkdir(path)
+            except OSError as ex:
+                # Continue if the name exists already
+                if ex.errno != errno.EEXIST:
+                    raise
+            else:
+                path = os.path.realpath(path)
+                break
+        else:
+            # Final fallback on the default behavior.
+            path = os.path.realpath(tempfile.mkdtemp(prefix=f"pip-{kind}-"))
+
+        logger.debug("Created temporary directory: %s", path)
+        return path
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/utils/unpacking.py b/venv/lib/python3.12/site-packages/pip/_internal/utils/unpacking.py
new file mode 100644
index 00000000..875e30e1
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/utils/unpacking.py
@@ -0,0 +1,337 @@
+"""Utilities related archives.
+"""
+
+import logging
+import os
+import shutil
+import stat
+import sys
+import tarfile
+import zipfile
+from typing import Iterable, List, Optional
+from zipfile import ZipInfo
+
+from pip._internal.exceptions import InstallationError
+from pip._internal.utils.filetypes import (
+    BZ2_EXTENSIONS,
+    TAR_EXTENSIONS,
+    XZ_EXTENSIONS,
+    ZIP_EXTENSIONS,
+)
+from pip._internal.utils.misc import ensure_dir
+
+logger = logging.getLogger(__name__)
+
+
+SUPPORTED_EXTENSIONS = ZIP_EXTENSIONS + TAR_EXTENSIONS
+
+try:
+    import bz2  # noqa
+
+    SUPPORTED_EXTENSIONS += BZ2_EXTENSIONS
+except ImportError:
+    logger.debug("bz2 module is not available")
+
+try:
+    # Only for Python 3.3+
+    import lzma  # noqa
+
+    SUPPORTED_EXTENSIONS += XZ_EXTENSIONS
+except ImportError:
+    logger.debug("lzma module is not available")
+
+
+def current_umask() -> int:
+    """Get the current umask which involves having to set it temporarily."""
+    mask = os.umask(0)
+    os.umask(mask)
+    return mask
+
+
+def split_leading_dir(path: str) -> List[str]:
+    path = path.lstrip("/").lstrip("\\")
+    if "/" in path and (
+        ("\\" in path and path.find("/") < path.find("\\")) or "\\" not in path
+    ):
+        return path.split("/", 1)
+    elif "\\" in path:
+        return path.split("\\", 1)
+    else:
+        return [path, ""]
+
+
+def has_leading_dir(paths: Iterable[str]) -> bool:
+    """Returns true if all the paths have the same leading path name
+    (i.e., everything is in one subdirectory in an archive)"""
+    common_prefix = None
+    for path in paths:
+        prefix, rest = split_leading_dir(path)
+        if not prefix:
+            return False
+        elif common_prefix is None:
+            common_prefix = prefix
+        elif prefix != common_prefix:
+            return False
+    return True
+
+
+def is_within_directory(directory: str, target: str) -> bool:
+    """
+    Return true if the absolute path of target is within the directory
+    """
+    abs_directory = os.path.abspath(directory)
+    abs_target = os.path.abspath(target)
+
+    prefix = os.path.commonprefix([abs_directory, abs_target])
+    return prefix == abs_directory
+
+
+def _get_default_mode_plus_executable() -> int:
+    return 0o777 & ~current_umask() | 0o111
+
+
+def set_extracted_file_to_default_mode_plus_executable(path: str) -> None:
+    """
+    Make file present at path have execute for user/group/world
+    (chmod +x) is no-op on windows per python docs
+    """
+    os.chmod(path, _get_default_mode_plus_executable())
+
+
+def zip_item_is_executable(info: ZipInfo) -> bool:
+    mode = info.external_attr >> 16
+    # if mode and regular file and any execute permissions for
+    # user/group/world?
+    return bool(mode and stat.S_ISREG(mode) and mode & 0o111)
+
+
+def unzip_file(filename: str, location: str, flatten: bool = True) -> None:
+    """
+    Unzip the file (with path `filename`) to the destination `location`.  All
+    files are written based on system defaults and umask (i.e. permissions are
+    not preserved), except that regular file members with any execute
+    permissions (user, group, or world) have "chmod +x" applied after being
+    written. Note that for windows, any execute changes using os.chmod are
+    no-ops per the python docs.
+    """
+    ensure_dir(location)
+    zipfp = open(filename, "rb")
+    try:
+        zip = zipfile.ZipFile(zipfp, allowZip64=True)
+        leading = has_leading_dir(zip.namelist()) and flatten
+        for info in zip.infolist():
+            name = info.filename
+            fn = name
+            if leading:
+                fn = split_leading_dir(name)[1]
+            fn = os.path.join(location, fn)
+            dir = os.path.dirname(fn)
+            if not is_within_directory(location, fn):
+                message = (
+                    "The zip file ({}) has a file ({}) trying to install "
+                    "outside target directory ({})"
+                )
+                raise InstallationError(message.format(filename, fn, location))
+            if fn.endswith("/") or fn.endswith("\\"):
+                # A directory
+                ensure_dir(fn)
+            else:
+                ensure_dir(dir)
+                # Don't use read() to avoid allocating an arbitrarily large
+                # chunk of memory for the file's content
+                fp = zip.open(name)
+                try:
+                    with open(fn, "wb") as destfp:
+                        shutil.copyfileobj(fp, destfp)
+                finally:
+                    fp.close()
+                    if zip_item_is_executable(info):
+                        set_extracted_file_to_default_mode_plus_executable(fn)
+    finally:
+        zipfp.close()
+
+
+def untar_file(filename: str, location: str) -> None:
+    """
+    Untar the file (with path `filename`) to the destination `location`.
+    All files are written based on system defaults and umask (i.e. permissions
+    are not preserved), except that regular file members with any execute
+    permissions (user, group, or world) have "chmod +x" applied on top of the
+    default.  Note that for windows, any execute changes using os.chmod are
+    no-ops per the python docs.
+    """
+    ensure_dir(location)
+    if filename.lower().endswith(".gz") or filename.lower().endswith(".tgz"):
+        mode = "r:gz"
+    elif filename.lower().endswith(BZ2_EXTENSIONS):
+        mode = "r:bz2"
+    elif filename.lower().endswith(XZ_EXTENSIONS):
+        mode = "r:xz"
+    elif filename.lower().endswith(".tar"):
+        mode = "r"
+    else:
+        logger.warning(
+            "Cannot determine compression type for file %s",
+            filename,
+        )
+        mode = "r:*"
+
+    tar = tarfile.open(filename, mode, encoding="utf-8")
+    try:
+        leading = has_leading_dir([member.name for member in tar.getmembers()])
+
+        # PEP 706 added `tarfile.data_filter`, and made some other changes to
+        # Python's tarfile module (see below). The features were backported to
+        # security releases.
+        try:
+            data_filter = tarfile.data_filter
+        except AttributeError:
+            _untar_without_filter(filename, location, tar, leading)
+        else:
+            default_mode_plus_executable = _get_default_mode_plus_executable()
+
+            if leading:
+                # Strip the leading directory from all files in the archive,
+                # including hardlink targets (which are relative to the
+                # unpack location).
+                for member in tar.getmembers():
+                    name_lead, name_rest = split_leading_dir(member.name)
+                    member.name = name_rest
+                    if member.islnk():
+                        lnk_lead, lnk_rest = split_leading_dir(member.linkname)
+                        if lnk_lead == name_lead:
+                            member.linkname = lnk_rest
+
+            def pip_filter(member: tarfile.TarInfo, path: str) -> tarfile.TarInfo:
+                orig_mode = member.mode
+                try:
+                    try:
+                        member = data_filter(member, location)
+                    except tarfile.LinkOutsideDestinationError:
+                        if sys.version_info[:3] in {
+                            (3, 8, 17),
+                            (3, 9, 17),
+                            (3, 10, 12),
+                            (3, 11, 4),
+                        }:
+                            # The tarfile filter in specific Python versions
+                            # raises LinkOutsideDestinationError on valid input
+                            # (https://github.com/python/cpython/issues/107845)
+                            # Ignore the error there, but do use the
+                            # more lax `tar_filter`
+                            member = tarfile.tar_filter(member, location)
+                        else:
+                            raise
+                except tarfile.TarError as exc:
+                    message = "Invalid member in the tar file {}: {}"
+                    # Filter error messages mention the member name.
+                    # No need to add it here.
+                    raise InstallationError(
+                        message.format(
+                            filename,
+                            exc,
+                        )
+                    )
+                if member.isfile() and orig_mode & 0o111:
+                    member.mode = default_mode_plus_executable
+                else:
+                    # See PEP 706 note above.
+                    # The PEP changed this from `int` to `Optional[int]`,
+                    # where None means "use the default". Mypy doesn't
+                    # know this yet.
+                    member.mode = None  # type: ignore [assignment]
+                return member
+
+            tar.extractall(location, filter=pip_filter)
+
+    finally:
+        tar.close()
+
+
+def _untar_without_filter(
+    filename: str,
+    location: str,
+    tar: tarfile.TarFile,
+    leading: bool,
+) -> None:
+    """Fallback for Python without tarfile.data_filter"""
+    for member in tar.getmembers():
+        fn = member.name
+        if leading:
+            fn = split_leading_dir(fn)[1]
+        path = os.path.join(location, fn)
+        if not is_within_directory(location, path):
+            message = (
+                "The tar file ({}) has a file ({}) trying to install "
+                "outside target directory ({})"
+            )
+            raise InstallationError(message.format(filename, path, location))
+        if member.isdir():
+            ensure_dir(path)
+        elif member.issym():
+            try:
+                tar._extract_member(member, path)
+            except Exception as exc:
+                # Some corrupt tar files seem to produce this
+                # (specifically bad symlinks)
+                logger.warning(
+                    "In the tar file %s the member %s is invalid: %s",
+                    filename,
+                    member.name,
+                    exc,
+                )
+                continue
+        else:
+            try:
+                fp = tar.extractfile(member)
+            except (KeyError, AttributeError) as exc:
+                # Some corrupt tar files seem to produce this
+                # (specifically bad symlinks)
+                logger.warning(
+                    "In the tar file %s the member %s is invalid: %s",
+                    filename,
+                    member.name,
+                    exc,
+                )
+                continue
+            ensure_dir(os.path.dirname(path))
+            assert fp is not None
+            with open(path, "wb") as destfp:
+                shutil.copyfileobj(fp, destfp)
+            fp.close()
+            # Update the timestamp (useful for cython compiled files)
+            tar.utime(member, path)
+            # member have any execute permissions for user/group/world?
+            if member.mode & 0o111:
+                set_extracted_file_to_default_mode_plus_executable(path)
+
+
+def unpack_file(
+    filename: str,
+    location: str,
+    content_type: Optional[str] = None,
+) -> None:
+    filename = os.path.realpath(filename)
+    if (
+        content_type == "application/zip"
+        or filename.lower().endswith(ZIP_EXTENSIONS)
+        or zipfile.is_zipfile(filename)
+    ):
+        unzip_file(filename, location, flatten=not filename.endswith(".whl"))
+    elif (
+        content_type == "application/x-gzip"
+        or tarfile.is_tarfile(filename)
+        or filename.lower().endswith(TAR_EXTENSIONS + BZ2_EXTENSIONS + XZ_EXTENSIONS)
+    ):
+        untar_file(filename, location)
+    else:
+        # FIXME: handle?
+        # FIXME: magic signatures?
+        logger.critical(
+            "Cannot unpack file %s (downloaded from %s, content-type: %s); "
+            "cannot detect archive format",
+            filename,
+            location,
+            content_type,
+        )
+        raise InstallationError(f"Cannot determine archive format of {location}")
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/utils/urls.py b/venv/lib/python3.12/site-packages/pip/_internal/utils/urls.py
new file mode 100644
index 00000000..9f34f882
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/utils/urls.py
@@ -0,0 +1,55 @@
+import os
+import string
+import urllib.parse
+import urllib.request
+
+from .compat import WINDOWS
+
+
+def path_to_url(path: str) -> str:
+    """
+    Convert a path to a file: URL.  The path will be made absolute and have
+    quoted path parts.
+    """
+    path = os.path.normpath(os.path.abspath(path))
+    url = urllib.parse.urljoin("file:", urllib.request.pathname2url(path))
+    return url
+
+
+def url_to_path(url: str) -> str:
+    """
+    Convert a file: URL to a path.
+    """
+    assert url.startswith(
+        "file:"
+    ), f"You can only turn file: urls into filenames (not {url!r})"
+
+    _, netloc, path, _, _ = urllib.parse.urlsplit(url)
+
+    if not netloc or netloc == "localhost":
+        # According to RFC 8089, same as empty authority.
+        netloc = ""
+    elif WINDOWS:
+        # If we have a UNC path, prepend UNC share notation.
+        netloc = "\\\\" + netloc
+    else:
+        raise ValueError(
+            f"non-local file URIs are not supported on this platform: {url!r}"
+        )
+
+    path = urllib.request.url2pathname(netloc + path)
+
+    # On Windows, urlsplit parses the path as something like "/C:/Users/foo".
+    # This creates issues for path-related functions like io.open(), so we try
+    # to detect and strip the leading slash.
+    if (
+        WINDOWS
+        and not netloc  # Not UNC.
+        and len(path) >= 3
+        and path[0] == "/"  # Leading slash to strip.
+        and path[1] in string.ascii_letters  # Drive letter.
+        and path[2:4] in (":", ":/")  # Colon + end of string, or colon + absolute path.
+    ):
+        path = path[1:]
+
+    return path
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/utils/virtualenv.py b/venv/lib/python3.12/site-packages/pip/_internal/utils/virtualenv.py
new file mode 100644
index 00000000..882e36f5
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/utils/virtualenv.py
@@ -0,0 +1,104 @@
+import logging
+import os
+import re
+import site
+import sys
+from typing import List, Optional
+
+logger = logging.getLogger(__name__)
+_INCLUDE_SYSTEM_SITE_PACKAGES_REGEX = re.compile(
+    r"include-system-site-packages\s*=\s*(?Ptrue|false)"
+)
+
+
+def _running_under_venv() -> bool:
+    """Checks if sys.base_prefix and sys.prefix match.
+
+    This handles PEP 405 compliant virtual environments.
+    """
+    return sys.prefix != getattr(sys, "base_prefix", sys.prefix)
+
+
+def _running_under_legacy_virtualenv() -> bool:
+    """Checks if sys.real_prefix is set.
+
+    This handles virtual environments created with pypa's virtualenv.
+    """
+    # pypa/virtualenv case
+    return hasattr(sys, "real_prefix")
+
+
+def running_under_virtualenv() -> bool:
+    """True if we're running inside a virtual environment, False otherwise."""
+    return _running_under_venv() or _running_under_legacy_virtualenv()
+
+
+def _get_pyvenv_cfg_lines() -> Optional[List[str]]:
+    """Reads {sys.prefix}/pyvenv.cfg and returns its contents as list of lines
+
+    Returns None, if it could not read/access the file.
+    """
+    pyvenv_cfg_file = os.path.join(sys.prefix, "pyvenv.cfg")
+    try:
+        # Although PEP 405 does not specify, the built-in venv module always
+        # writes with UTF-8. (pypa/pip#8717)
+        with open(pyvenv_cfg_file, encoding="utf-8") as f:
+            return f.read().splitlines()  # avoids trailing newlines
+    except OSError:
+        return None
+
+
+def _no_global_under_venv() -> bool:
+    """Check `{sys.prefix}/pyvenv.cfg` for system site-packages inclusion
+
+    PEP 405 specifies that when system site-packages are not supposed to be
+    visible from a virtual environment, `pyvenv.cfg` must contain the following
+    line:
+
+        include-system-site-packages = false
+
+    Additionally, log a warning if accessing the file fails.
+    """
+    cfg_lines = _get_pyvenv_cfg_lines()
+    if cfg_lines is None:
+        # We're not in a "sane" venv, so assume there is no system
+        # site-packages access (since that's PEP 405's default state).
+        logger.warning(
+            "Could not access 'pyvenv.cfg' despite a virtual environment "
+            "being active. Assuming global site-packages is not accessible "
+            "in this environment."
+        )
+        return True
+
+    for line in cfg_lines:
+        match = _INCLUDE_SYSTEM_SITE_PACKAGES_REGEX.match(line)
+        if match is not None and match.group("value") == "false":
+            return True
+    return False
+
+
+def _no_global_under_legacy_virtualenv() -> bool:
+    """Check if "no-global-site-packages.txt" exists beside site.py
+
+    This mirrors logic in pypa/virtualenv for determining whether system
+    site-packages are visible in the virtual environment.
+    """
+    site_mod_dir = os.path.dirname(os.path.abspath(site.__file__))
+    no_global_site_packages_file = os.path.join(
+        site_mod_dir,
+        "no-global-site-packages.txt",
+    )
+    return os.path.exists(no_global_site_packages_file)
+
+
+def virtualenv_no_global() -> bool:
+    """Returns a boolean, whether running in venv with no system site-packages."""
+    # PEP 405 compliance needs to be checked first since virtualenv >=20 would
+    # return True for both checks, but is only able to use the PEP 405 config.
+    if _running_under_venv():
+        return _no_global_under_venv()
+
+    if _running_under_legacy_virtualenv():
+        return _no_global_under_legacy_virtualenv()
+
+    return False
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/utils/wheel.py b/venv/lib/python3.12/site-packages/pip/_internal/utils/wheel.py
new file mode 100644
index 00000000..f85aee8a
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/utils/wheel.py
@@ -0,0 +1,134 @@
+"""Support functions for working with wheel files.
+"""
+
+import logging
+from email.message import Message
+from email.parser import Parser
+from typing import Tuple
+from zipfile import BadZipFile, ZipFile
+
+from pip._vendor.packaging.utils import canonicalize_name
+
+from pip._internal.exceptions import UnsupportedWheel
+
+VERSION_COMPATIBLE = (1, 0)
+
+
+logger = logging.getLogger(__name__)
+
+
+def parse_wheel(wheel_zip: ZipFile, name: str) -> Tuple[str, Message]:
+    """Extract information from the provided wheel, ensuring it meets basic
+    standards.
+
+    Returns the name of the .dist-info directory and the parsed WHEEL metadata.
+    """
+    try:
+        info_dir = wheel_dist_info_dir(wheel_zip, name)
+        metadata = wheel_metadata(wheel_zip, info_dir)
+        version = wheel_version(metadata)
+    except UnsupportedWheel as e:
+        raise UnsupportedWheel(f"{name} has an invalid wheel, {e}")
+
+    check_compatibility(version, name)
+
+    return info_dir, metadata
+
+
+def wheel_dist_info_dir(source: ZipFile, name: str) -> str:
+    """Returns the name of the contained .dist-info directory.
+
+    Raises AssertionError or UnsupportedWheel if not found, >1 found, or
+    it doesn't match the provided name.
+    """
+    # Zip file path separators must be /
+    subdirs = {p.split("/", 1)[0] for p in source.namelist()}
+
+    info_dirs = [s for s in subdirs if s.endswith(".dist-info")]
+
+    if not info_dirs:
+        raise UnsupportedWheel(".dist-info directory not found")
+
+    if len(info_dirs) > 1:
+        raise UnsupportedWheel(
+            "multiple .dist-info directories found: {}".format(", ".join(info_dirs))
+        )
+
+    info_dir = info_dirs[0]
+
+    info_dir_name = canonicalize_name(info_dir)
+    canonical_name = canonicalize_name(name)
+    if not info_dir_name.startswith(canonical_name):
+        raise UnsupportedWheel(
+            f".dist-info directory {info_dir!r} does not start with {canonical_name!r}"
+        )
+
+    return info_dir
+
+
+def read_wheel_metadata_file(source: ZipFile, path: str) -> bytes:
+    try:
+        return source.read(path)
+        # BadZipFile for general corruption, KeyError for missing entry,
+        # and RuntimeError for password-protected files
+    except (BadZipFile, KeyError, RuntimeError) as e:
+        raise UnsupportedWheel(f"could not read {path!r} file: {e!r}")
+
+
+def wheel_metadata(source: ZipFile, dist_info_dir: str) -> Message:
+    """Return the WHEEL metadata of an extracted wheel, if possible.
+    Otherwise, raise UnsupportedWheel.
+    """
+    path = f"{dist_info_dir}/WHEEL"
+    # Zip file path separators must be /
+    wheel_contents = read_wheel_metadata_file(source, path)
+
+    try:
+        wheel_text = wheel_contents.decode()
+    except UnicodeDecodeError as e:
+        raise UnsupportedWheel(f"error decoding {path!r}: {e!r}")
+
+    # FeedParser (used by Parser) does not raise any exceptions. The returned
+    # message may have .defects populated, but for backwards-compatibility we
+    # currently ignore them.
+    return Parser().parsestr(wheel_text)
+
+
+def wheel_version(wheel_data: Message) -> Tuple[int, ...]:
+    """Given WHEEL metadata, return the parsed Wheel-Version.
+    Otherwise, raise UnsupportedWheel.
+    """
+    version_text = wheel_data["Wheel-Version"]
+    if version_text is None:
+        raise UnsupportedWheel("WHEEL is missing Wheel-Version")
+
+    version = version_text.strip()
+
+    try:
+        return tuple(map(int, version.split(".")))
+    except ValueError:
+        raise UnsupportedWheel(f"invalid Wheel-Version: {version!r}")
+
+
+def check_compatibility(version: Tuple[int, ...], name: str) -> None:
+    """Raises errors or warns if called with an incompatible Wheel-Version.
+
+    pip should refuse to install a Wheel-Version that's a major series
+    ahead of what it's compatible with (e.g 2.0 > 1.1); and warn when
+    installing a version only minor version ahead (e.g 1.2 > 1.1).
+
+    version: a 2-tuple representing a Wheel-Version (Major, Minor)
+    name: name of wheel or package to raise exception about
+
+    :raises UnsupportedWheel: when an incompatible Wheel-Version is given
+    """
+    if version[0] > VERSION_COMPATIBLE[0]:
+        raise UnsupportedWheel(
+            "{}'s Wheel-Version ({}) is not compatible with this version "
+            "of pip".format(name, ".".join(map(str, version)))
+        )
+    elif version > VERSION_COMPATIBLE:
+        logger.warning(
+            "Installing from a newer Wheel-Version (%s)",
+            ".".join(map(str, version)),
+        )
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/vcs/__init__.py b/venv/lib/python3.12/site-packages/pip/_internal/vcs/__init__.py
new file mode 100644
index 00000000..b6beddbe
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/vcs/__init__.py
@@ -0,0 +1,15 @@
+# Expose a limited set of classes and functions so callers outside of
+# the vcs package don't need to import deeper than `pip._internal.vcs`.
+# (The test directory may still need to import from a vcs sub-package.)
+# Import all vcs modules to register each VCS in the VcsSupport object.
+import pip._internal.vcs.bazaar
+import pip._internal.vcs.git
+import pip._internal.vcs.mercurial
+import pip._internal.vcs.subversion  # noqa: F401
+from pip._internal.vcs.versioncontrol import (  # noqa: F401
+    RemoteNotFoundError,
+    RemoteNotValidError,
+    is_url,
+    make_vcs_requirement_url,
+    vcs,
+)
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/vcs/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/vcs/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 00000000..7206c2db
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/vcs/__pycache__/__init__.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/vcs/__pycache__/bazaar.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/vcs/__pycache__/bazaar.cpython-312.pyc
new file mode 100644
index 00000000..90ef549a
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/vcs/__pycache__/bazaar.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/vcs/__pycache__/git.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/vcs/__pycache__/git.cpython-312.pyc
new file mode 100644
index 00000000..4dc626f9
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/vcs/__pycache__/git.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/vcs/__pycache__/mercurial.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/vcs/__pycache__/mercurial.cpython-312.pyc
new file mode 100644
index 00000000..24d45e69
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/vcs/__pycache__/mercurial.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/vcs/__pycache__/subversion.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/vcs/__pycache__/subversion.cpython-312.pyc
new file mode 100644
index 00000000..bc1e5072
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/vcs/__pycache__/subversion.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/vcs/__pycache__/versioncontrol.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_internal/vcs/__pycache__/versioncontrol.cpython-312.pyc
new file mode 100644
index 00000000..302a7b88
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_internal/vcs/__pycache__/versioncontrol.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/vcs/bazaar.py b/venv/lib/python3.12/site-packages/pip/_internal/vcs/bazaar.py
new file mode 100644
index 00000000..c754b7cc
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/vcs/bazaar.py
@@ -0,0 +1,112 @@
+import logging
+from typing import List, Optional, Tuple
+
+from pip._internal.utils.misc import HiddenText, display_path
+from pip._internal.utils.subprocess import make_command
+from pip._internal.utils.urls import path_to_url
+from pip._internal.vcs.versioncontrol import (
+    AuthInfo,
+    RemoteNotFoundError,
+    RevOptions,
+    VersionControl,
+    vcs,
+)
+
+logger = logging.getLogger(__name__)
+
+
+class Bazaar(VersionControl):
+    name = "bzr"
+    dirname = ".bzr"
+    repo_name = "branch"
+    schemes = (
+        "bzr+http",
+        "bzr+https",
+        "bzr+ssh",
+        "bzr+sftp",
+        "bzr+ftp",
+        "bzr+lp",
+        "bzr+file",
+    )
+
+    @staticmethod
+    def get_base_rev_args(rev: str) -> List[str]:
+        return ["-r", rev]
+
+    def fetch_new(
+        self, dest: str, url: HiddenText, rev_options: RevOptions, verbosity: int
+    ) -> None:
+        rev_display = rev_options.to_display()
+        logger.info(
+            "Checking out %s%s to %s",
+            url,
+            rev_display,
+            display_path(dest),
+        )
+        if verbosity <= 0:
+            flags = ["--quiet"]
+        elif verbosity == 1:
+            flags = []
+        else:
+            flags = [f"-{'v'*verbosity}"]
+        cmd_args = make_command(
+            "checkout", "--lightweight", *flags, rev_options.to_args(), url, dest
+        )
+        self.run_command(cmd_args)
+
+    def switch(self, dest: str, url: HiddenText, rev_options: RevOptions) -> None:
+        self.run_command(make_command("switch", url), cwd=dest)
+
+    def update(self, dest: str, url: HiddenText, rev_options: RevOptions) -> None:
+        output = self.run_command(
+            make_command("info"), show_stdout=False, stdout_only=True, cwd=dest
+        )
+        if output.startswith("Standalone "):
+            # Older versions of pip used to create standalone branches.
+            # Convert the standalone branch to a checkout by calling "bzr bind".
+            cmd_args = make_command("bind", "-q", url)
+            self.run_command(cmd_args, cwd=dest)
+
+        cmd_args = make_command("update", "-q", rev_options.to_args())
+        self.run_command(cmd_args, cwd=dest)
+
+    @classmethod
+    def get_url_rev_and_auth(cls, url: str) -> Tuple[str, Optional[str], AuthInfo]:
+        # hotfix the URL scheme after removing bzr+ from bzr+ssh:// re-add it
+        url, rev, user_pass = super().get_url_rev_and_auth(url)
+        if url.startswith("ssh://"):
+            url = "bzr+" + url
+        return url, rev, user_pass
+
+    @classmethod
+    def get_remote_url(cls, location: str) -> str:
+        urls = cls.run_command(
+            ["info"], show_stdout=False, stdout_only=True, cwd=location
+        )
+        for line in urls.splitlines():
+            line = line.strip()
+            for x in ("checkout of branch: ", "parent branch: "):
+                if line.startswith(x):
+                    repo = line.split(x)[1]
+                    if cls._is_local_repository(repo):
+                        return path_to_url(repo)
+                    return repo
+        raise RemoteNotFoundError
+
+    @classmethod
+    def get_revision(cls, location: str) -> str:
+        revision = cls.run_command(
+            ["revno"],
+            show_stdout=False,
+            stdout_only=True,
+            cwd=location,
+        )
+        return revision.splitlines()[-1]
+
+    @classmethod
+    def is_commit_id_equal(cls, dest: str, name: Optional[str]) -> bool:
+        """Always assume the versions don't match"""
+        return False
+
+
+vcs.register(Bazaar)
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/vcs/git.py b/venv/lib/python3.12/site-packages/pip/_internal/vcs/git.py
new file mode 100644
index 00000000..0425debb
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/vcs/git.py
@@ -0,0 +1,527 @@
+import logging
+import os.path
+import pathlib
+import re
+import urllib.parse
+import urllib.request
+from dataclasses import replace
+from typing import List, Optional, Tuple
+
+from pip._internal.exceptions import BadCommand, InstallationError
+from pip._internal.utils.misc import HiddenText, display_path, hide_url
+from pip._internal.utils.subprocess import make_command
+from pip._internal.vcs.versioncontrol import (
+    AuthInfo,
+    RemoteNotFoundError,
+    RemoteNotValidError,
+    RevOptions,
+    VersionControl,
+    find_path_to_project_root_from_repo_root,
+    vcs,
+)
+
+urlsplit = urllib.parse.urlsplit
+urlunsplit = urllib.parse.urlunsplit
+
+
+logger = logging.getLogger(__name__)
+
+
+GIT_VERSION_REGEX = re.compile(
+    r"^git version "  # Prefix.
+    r"(\d+)"  # Major.
+    r"\.(\d+)"  # Dot, minor.
+    r"(?:\.(\d+))?"  # Optional dot, patch.
+    r".*$"  # Suffix, including any pre- and post-release segments we don't care about.
+)
+
+HASH_REGEX = re.compile("^[a-fA-F0-9]{40}$")
+
+# SCP (Secure copy protocol) shorthand. e.g. 'git@example.com:foo/bar.git'
+SCP_REGEX = re.compile(
+    r"""^
+    # Optional user, e.g. 'git@'
+    (\w+@)?
+    # Server, e.g. 'github.com'.
+    ([^/:]+):
+    # The server-side path. e.g. 'user/project.git'. Must start with an
+    # alphanumeric character so as not to be confusable with a Windows paths
+    # like 'C:/foo/bar' or 'C:\foo\bar'.
+    (\w[^:]*)
+    $""",
+    re.VERBOSE,
+)
+
+
+def looks_like_hash(sha: str) -> bool:
+    return bool(HASH_REGEX.match(sha))
+
+
+class Git(VersionControl):
+    name = "git"
+    dirname = ".git"
+    repo_name = "clone"
+    schemes = (
+        "git+http",
+        "git+https",
+        "git+ssh",
+        "git+git",
+        "git+file",
+    )
+    # Prevent the user's environment variables from interfering with pip:
+    # https://github.com/pypa/pip/issues/1130
+    unset_environ = ("GIT_DIR", "GIT_WORK_TREE")
+    default_arg_rev = "HEAD"
+
+    @staticmethod
+    def get_base_rev_args(rev: str) -> List[str]:
+        return [rev]
+
+    def is_immutable_rev_checkout(self, url: str, dest: str) -> bool:
+        _, rev_options = self.get_url_rev_options(hide_url(url))
+        if not rev_options.rev:
+            return False
+        if not self.is_commit_id_equal(dest, rev_options.rev):
+            # the current commit is different from rev,
+            # which means rev was something else than a commit hash
+            return False
+        # return False in the rare case rev is both a commit hash
+        # and a tag or a branch; we don't want to cache in that case
+        # because that branch/tag could point to something else in the future
+        is_tag_or_branch = bool(self.get_revision_sha(dest, rev_options.rev)[0])
+        return not is_tag_or_branch
+
+    def get_git_version(self) -> Tuple[int, ...]:
+        version = self.run_command(
+            ["version"],
+            command_desc="git version",
+            show_stdout=False,
+            stdout_only=True,
+        )
+        match = GIT_VERSION_REGEX.match(version)
+        if not match:
+            logger.warning("Can't parse git version: %s", version)
+            return ()
+        return (int(match.group(1)), int(match.group(2)))
+
+    @classmethod
+    def get_current_branch(cls, location: str) -> Optional[str]:
+        """
+        Return the current branch, or None if HEAD isn't at a branch
+        (e.g. detached HEAD).
+        """
+        # git-symbolic-ref exits with empty stdout if "HEAD" is a detached
+        # HEAD rather than a symbolic ref.  In addition, the -q causes the
+        # command to exit with status code 1 instead of 128 in this case
+        # and to suppress the message to stderr.
+        args = ["symbolic-ref", "-q", "HEAD"]
+        output = cls.run_command(
+            args,
+            extra_ok_returncodes=(1,),
+            show_stdout=False,
+            stdout_only=True,
+            cwd=location,
+        )
+        ref = output.strip()
+
+        if ref.startswith("refs/heads/"):
+            return ref[len("refs/heads/") :]
+
+        return None
+
+    @classmethod
+    def get_revision_sha(cls, dest: str, rev: str) -> Tuple[Optional[str], bool]:
+        """
+        Return (sha_or_none, is_branch), where sha_or_none is a commit hash
+        if the revision names a remote branch or tag, otherwise None.
+
+        Args:
+          dest: the repository directory.
+          rev: the revision name.
+        """
+        # Pass rev to pre-filter the list.
+        output = cls.run_command(
+            ["show-ref", rev],
+            cwd=dest,
+            show_stdout=False,
+            stdout_only=True,
+            on_returncode="ignore",
+        )
+        refs = {}
+        # NOTE: We do not use splitlines here since that would split on other
+        #       unicode separators, which can be maliciously used to install a
+        #       different revision.
+        for line in output.strip().split("\n"):
+            line = line.rstrip("\r")
+            if not line:
+                continue
+            try:
+                ref_sha, ref_name = line.split(" ", maxsplit=2)
+            except ValueError:
+                # Include the offending line to simplify troubleshooting if
+                # this error ever occurs.
+                raise ValueError(f"unexpected show-ref line: {line!r}")
+
+            refs[ref_name] = ref_sha
+
+        branch_ref = f"refs/remotes/origin/{rev}"
+        tag_ref = f"refs/tags/{rev}"
+
+        sha = refs.get(branch_ref)
+        if sha is not None:
+            return (sha, True)
+
+        sha = refs.get(tag_ref)
+
+        return (sha, False)
+
+    @classmethod
+    def _should_fetch(cls, dest: str, rev: str) -> bool:
+        """
+        Return true if rev is a ref or is a commit that we don't have locally.
+
+        Branches and tags are not considered in this method because they are
+        assumed to be always available locally (which is a normal outcome of
+        ``git clone`` and ``git fetch --tags``).
+        """
+        if rev.startswith("refs/"):
+            # Always fetch remote refs.
+            return True
+
+        if not looks_like_hash(rev):
+            # Git fetch would fail with abbreviated commits.
+            return False
+
+        if cls.has_commit(dest, rev):
+            # Don't fetch if we have the commit locally.
+            return False
+
+        return True
+
+    @classmethod
+    def resolve_revision(
+        cls, dest: str, url: HiddenText, rev_options: RevOptions
+    ) -> RevOptions:
+        """
+        Resolve a revision to a new RevOptions object with the SHA1 of the
+        branch, tag, or ref if found.
+
+        Args:
+          rev_options: a RevOptions object.
+        """
+        rev = rev_options.arg_rev
+        # The arg_rev property's implementation for Git ensures that the
+        # rev return value is always non-None.
+        assert rev is not None
+
+        sha, is_branch = cls.get_revision_sha(dest, rev)
+
+        if sha is not None:
+            rev_options = rev_options.make_new(sha)
+            rev_options = replace(rev_options, branch_name=(rev if is_branch else None))
+
+            return rev_options
+
+        # Do not show a warning for the common case of something that has
+        # the form of a Git commit hash.
+        if not looks_like_hash(rev):
+            logger.warning(
+                "Did not find branch or tag '%s', assuming revision or ref.",
+                rev,
+            )
+
+        if not cls._should_fetch(dest, rev):
+            return rev_options
+
+        # fetch the requested revision
+        cls.run_command(
+            make_command("fetch", "-q", url, rev_options.to_args()),
+            cwd=dest,
+        )
+        # Change the revision to the SHA of the ref we fetched
+        sha = cls.get_revision(dest, rev="FETCH_HEAD")
+        rev_options = rev_options.make_new(sha)
+
+        return rev_options
+
+    @classmethod
+    def is_commit_id_equal(cls, dest: str, name: Optional[str]) -> bool:
+        """
+        Return whether the current commit hash equals the given name.
+
+        Args:
+          dest: the repository directory.
+          name: a string name.
+        """
+        if not name:
+            # Then avoid an unnecessary subprocess call.
+            return False
+
+        return cls.get_revision(dest) == name
+
+    def fetch_new(
+        self, dest: str, url: HiddenText, rev_options: RevOptions, verbosity: int
+    ) -> None:
+        rev_display = rev_options.to_display()
+        logger.info("Cloning %s%s to %s", url, rev_display, display_path(dest))
+        if verbosity <= 0:
+            flags: Tuple[str, ...] = ("--quiet",)
+        elif verbosity == 1:
+            flags = ()
+        else:
+            flags = ("--verbose", "--progress")
+        if self.get_git_version() >= (2, 17):
+            # Git added support for partial clone in 2.17
+            # https://git-scm.com/docs/partial-clone
+            # Speeds up cloning by functioning without a complete copy of repository
+            self.run_command(
+                make_command(
+                    "clone",
+                    "--filter=blob:none",
+                    *flags,
+                    url,
+                    dest,
+                )
+            )
+        else:
+            self.run_command(make_command("clone", *flags, url, dest))
+
+        if rev_options.rev:
+            # Then a specific revision was requested.
+            rev_options = self.resolve_revision(dest, url, rev_options)
+            branch_name = getattr(rev_options, "branch_name", None)
+            logger.debug("Rev options %s, branch_name %s", rev_options, branch_name)
+            if branch_name is None:
+                # Only do a checkout if the current commit id doesn't match
+                # the requested revision.
+                if not self.is_commit_id_equal(dest, rev_options.rev):
+                    cmd_args = make_command(
+                        "checkout",
+                        "-q",
+                        rev_options.to_args(),
+                    )
+                    self.run_command(cmd_args, cwd=dest)
+            elif self.get_current_branch(dest) != branch_name:
+                # Then a specific branch was requested, and that branch
+                # is not yet checked out.
+                track_branch = f"origin/{branch_name}"
+                cmd_args = [
+                    "checkout",
+                    "-b",
+                    branch_name,
+                    "--track",
+                    track_branch,
+                ]
+                self.run_command(cmd_args, cwd=dest)
+        else:
+            sha = self.get_revision(dest)
+            rev_options = rev_options.make_new(sha)
+
+        logger.info("Resolved %s to commit %s", url, rev_options.rev)
+
+        #: repo may contain submodules
+        self.update_submodules(dest)
+
+    def switch(self, dest: str, url: HiddenText, rev_options: RevOptions) -> None:
+        self.run_command(
+            make_command("config", "remote.origin.url", url),
+            cwd=dest,
+        )
+        cmd_args = make_command("checkout", "-q", rev_options.to_args())
+        self.run_command(cmd_args, cwd=dest)
+
+        self.update_submodules(dest)
+
+    def update(self, dest: str, url: HiddenText, rev_options: RevOptions) -> None:
+        # First fetch changes from the default remote
+        if self.get_git_version() >= (1, 9):
+            # fetch tags in addition to everything else
+            self.run_command(["fetch", "-q", "--tags"], cwd=dest)
+        else:
+            self.run_command(["fetch", "-q"], cwd=dest)
+        # Then reset to wanted revision (maybe even origin/master)
+        rev_options = self.resolve_revision(dest, url, rev_options)
+        cmd_args = make_command("reset", "--hard", "-q", rev_options.to_args())
+        self.run_command(cmd_args, cwd=dest)
+        #: update submodules
+        self.update_submodules(dest)
+
+    @classmethod
+    def get_remote_url(cls, location: str) -> str:
+        """
+        Return URL of the first remote encountered.
+
+        Raises RemoteNotFoundError if the repository does not have a remote
+        url configured.
+        """
+        # We need to pass 1 for extra_ok_returncodes since the command
+        # exits with return code 1 if there are no matching lines.
+        stdout = cls.run_command(
+            ["config", "--get-regexp", r"remote\..*\.url"],
+            extra_ok_returncodes=(1,),
+            show_stdout=False,
+            stdout_only=True,
+            cwd=location,
+        )
+        remotes = stdout.splitlines()
+        try:
+            found_remote = remotes[0]
+        except IndexError:
+            raise RemoteNotFoundError
+
+        for remote in remotes:
+            if remote.startswith("remote.origin.url "):
+                found_remote = remote
+                break
+        url = found_remote.split(" ")[1]
+        return cls._git_remote_to_pip_url(url.strip())
+
+    @staticmethod
+    def _git_remote_to_pip_url(url: str) -> str:
+        """
+        Convert a remote url from what git uses to what pip accepts.
+
+        There are 3 legal forms **url** may take:
+
+            1. A fully qualified url: ssh://git@example.com/foo/bar.git
+            2. A local project.git folder: /path/to/bare/repository.git
+            3. SCP shorthand for form 1: git@example.com:foo/bar.git
+
+        Form 1 is output as-is. Form 2 must be converted to URI and form 3 must
+        be converted to form 1.
+
+        See the corresponding test test_git_remote_url_to_pip() for examples of
+        sample inputs/outputs.
+        """
+        if re.match(r"\w+://", url):
+            # This is already valid. Pass it though as-is.
+            return url
+        if os.path.exists(url):
+            # A local bare remote (git clone --mirror).
+            # Needs a file:// prefix.
+            return pathlib.PurePath(url).as_uri()
+        scp_match = SCP_REGEX.match(url)
+        if scp_match:
+            # Add an ssh:// prefix and replace the ':' with a '/'.
+            return scp_match.expand(r"ssh://\1\2/\3")
+        # Otherwise, bail out.
+        raise RemoteNotValidError(url)
+
+    @classmethod
+    def has_commit(cls, location: str, rev: str) -> bool:
+        """
+        Check if rev is a commit that is available in the local repository.
+        """
+        try:
+            cls.run_command(
+                ["rev-parse", "-q", "--verify", "sha^" + rev],
+                cwd=location,
+                log_failed_cmd=False,
+            )
+        except InstallationError:
+            return False
+        else:
+            return True
+
+    @classmethod
+    def get_revision(cls, location: str, rev: Optional[str] = None) -> str:
+        if rev is None:
+            rev = "HEAD"
+        current_rev = cls.run_command(
+            ["rev-parse", rev],
+            show_stdout=False,
+            stdout_only=True,
+            cwd=location,
+        )
+        return current_rev.strip()
+
+    @classmethod
+    def get_subdirectory(cls, location: str) -> Optional[str]:
+        """
+        Return the path to Python project root, relative to the repo root.
+        Return None if the project root is in the repo root.
+        """
+        # find the repo root
+        git_dir = cls.run_command(
+            ["rev-parse", "--git-dir"],
+            show_stdout=False,
+            stdout_only=True,
+            cwd=location,
+        ).strip()
+        if not os.path.isabs(git_dir):
+            git_dir = os.path.join(location, git_dir)
+        repo_root = os.path.abspath(os.path.join(git_dir, ".."))
+        return find_path_to_project_root_from_repo_root(location, repo_root)
+
+    @classmethod
+    def get_url_rev_and_auth(cls, url: str) -> Tuple[str, Optional[str], AuthInfo]:
+        """
+        Prefixes stub URLs like 'user@hostname:user/repo.git' with 'ssh://'.
+        That's required because although they use SSH they sometimes don't
+        work with a ssh:// scheme (e.g. GitHub). But we need a scheme for
+        parsing. Hence we remove it again afterwards and return it as a stub.
+        """
+        # Works around an apparent Git bug
+        # (see https://article.gmane.org/gmane.comp.version-control.git/146500)
+        scheme, netloc, path, query, fragment = urlsplit(url)
+        if scheme.endswith("file"):
+            initial_slashes = path[: -len(path.lstrip("/"))]
+            newpath = initial_slashes + urllib.request.url2pathname(path).replace(
+                "\\", "/"
+            ).lstrip("/")
+            after_plus = scheme.find("+") + 1
+            url = scheme[:after_plus] + urlunsplit(
+                (scheme[after_plus:], netloc, newpath, query, fragment),
+            )
+
+        if "://" not in url:
+            assert "file:" not in url
+            url = url.replace("git+", "git+ssh://")
+            url, rev, user_pass = super().get_url_rev_and_auth(url)
+            url = url.replace("ssh://", "")
+        else:
+            url, rev, user_pass = super().get_url_rev_and_auth(url)
+
+        return url, rev, user_pass
+
+    @classmethod
+    def update_submodules(cls, location: str) -> None:
+        if not os.path.exists(os.path.join(location, ".gitmodules")):
+            return
+        cls.run_command(
+            ["submodule", "update", "--init", "--recursive", "-q"],
+            cwd=location,
+        )
+
+    @classmethod
+    def get_repository_root(cls, location: str) -> Optional[str]:
+        loc = super().get_repository_root(location)
+        if loc:
+            return loc
+        try:
+            r = cls.run_command(
+                ["rev-parse", "--show-toplevel"],
+                cwd=location,
+                show_stdout=False,
+                stdout_only=True,
+                on_returncode="raise",
+                log_failed_cmd=False,
+            )
+        except BadCommand:
+            logger.debug(
+                "could not determine if %s is under git control "
+                "because git is not available",
+                location,
+            )
+            return None
+        except InstallationError:
+            return None
+        return os.path.normpath(r.rstrip("\r\n"))
+
+    @staticmethod
+    def should_add_vcs_url_prefix(repo_url: str) -> bool:
+        """In either https or ssh form, requirements must be prefixed with git+."""
+        return True
+
+
+vcs.register(Git)
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/vcs/mercurial.py b/venv/lib/python3.12/site-packages/pip/_internal/vcs/mercurial.py
new file mode 100644
index 00000000..c183d41d
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/vcs/mercurial.py
@@ -0,0 +1,163 @@
+import configparser
+import logging
+import os
+from typing import List, Optional, Tuple
+
+from pip._internal.exceptions import BadCommand, InstallationError
+from pip._internal.utils.misc import HiddenText, display_path
+from pip._internal.utils.subprocess import make_command
+from pip._internal.utils.urls import path_to_url
+from pip._internal.vcs.versioncontrol import (
+    RevOptions,
+    VersionControl,
+    find_path_to_project_root_from_repo_root,
+    vcs,
+)
+
+logger = logging.getLogger(__name__)
+
+
+class Mercurial(VersionControl):
+    name = "hg"
+    dirname = ".hg"
+    repo_name = "clone"
+    schemes = (
+        "hg+file",
+        "hg+http",
+        "hg+https",
+        "hg+ssh",
+        "hg+static-http",
+    )
+
+    @staticmethod
+    def get_base_rev_args(rev: str) -> List[str]:
+        return [f"--rev={rev}"]
+
+    def fetch_new(
+        self, dest: str, url: HiddenText, rev_options: RevOptions, verbosity: int
+    ) -> None:
+        rev_display = rev_options.to_display()
+        logger.info(
+            "Cloning hg %s%s to %s",
+            url,
+            rev_display,
+            display_path(dest),
+        )
+        if verbosity <= 0:
+            flags: Tuple[str, ...] = ("--quiet",)
+        elif verbosity == 1:
+            flags = ()
+        elif verbosity == 2:
+            flags = ("--verbose",)
+        else:
+            flags = ("--verbose", "--debug")
+        self.run_command(make_command("clone", "--noupdate", *flags, url, dest))
+        self.run_command(
+            make_command("update", *flags, rev_options.to_args()),
+            cwd=dest,
+        )
+
+    def switch(self, dest: str, url: HiddenText, rev_options: RevOptions) -> None:
+        repo_config = os.path.join(dest, self.dirname, "hgrc")
+        config = configparser.RawConfigParser()
+        try:
+            config.read(repo_config)
+            config.set("paths", "default", url.secret)
+            with open(repo_config, "w") as config_file:
+                config.write(config_file)
+        except (OSError, configparser.NoSectionError) as exc:
+            logger.warning("Could not switch Mercurial repository to %s: %s", url, exc)
+        else:
+            cmd_args = make_command("update", "-q", rev_options.to_args())
+            self.run_command(cmd_args, cwd=dest)
+
+    def update(self, dest: str, url: HiddenText, rev_options: RevOptions) -> None:
+        self.run_command(["pull", "-q"], cwd=dest)
+        cmd_args = make_command("update", "-q", rev_options.to_args())
+        self.run_command(cmd_args, cwd=dest)
+
+    @classmethod
+    def get_remote_url(cls, location: str) -> str:
+        url = cls.run_command(
+            ["showconfig", "paths.default"],
+            show_stdout=False,
+            stdout_only=True,
+            cwd=location,
+        ).strip()
+        if cls._is_local_repository(url):
+            url = path_to_url(url)
+        return url.strip()
+
+    @classmethod
+    def get_revision(cls, location: str) -> str:
+        """
+        Return the repository-local changeset revision number, as an integer.
+        """
+        current_revision = cls.run_command(
+            ["parents", "--template={rev}"],
+            show_stdout=False,
+            stdout_only=True,
+            cwd=location,
+        ).strip()
+        return current_revision
+
+    @classmethod
+    def get_requirement_revision(cls, location: str) -> str:
+        """
+        Return the changeset identification hash, as a 40-character
+        hexadecimal string
+        """
+        current_rev_hash = cls.run_command(
+            ["parents", "--template={node}"],
+            show_stdout=False,
+            stdout_only=True,
+            cwd=location,
+        ).strip()
+        return current_rev_hash
+
+    @classmethod
+    def is_commit_id_equal(cls, dest: str, name: Optional[str]) -> bool:
+        """Always assume the versions don't match"""
+        return False
+
+    @classmethod
+    def get_subdirectory(cls, location: str) -> Optional[str]:
+        """
+        Return the path to Python project root, relative to the repo root.
+        Return None if the project root is in the repo root.
+        """
+        # find the repo root
+        repo_root = cls.run_command(
+            ["root"], show_stdout=False, stdout_only=True, cwd=location
+        ).strip()
+        if not os.path.isabs(repo_root):
+            repo_root = os.path.abspath(os.path.join(location, repo_root))
+        return find_path_to_project_root_from_repo_root(location, repo_root)
+
+    @classmethod
+    def get_repository_root(cls, location: str) -> Optional[str]:
+        loc = super().get_repository_root(location)
+        if loc:
+            return loc
+        try:
+            r = cls.run_command(
+                ["root"],
+                cwd=location,
+                show_stdout=False,
+                stdout_only=True,
+                on_returncode="raise",
+                log_failed_cmd=False,
+            )
+        except BadCommand:
+            logger.debug(
+                "could not determine if %s is under hg control "
+                "because hg is not available",
+                location,
+            )
+            return None
+        except InstallationError:
+            return None
+        return os.path.normpath(r.rstrip("\r\n"))
+
+
+vcs.register(Mercurial)
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/vcs/subversion.py b/venv/lib/python3.12/site-packages/pip/_internal/vcs/subversion.py
new file mode 100644
index 00000000..f359266d
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/vcs/subversion.py
@@ -0,0 +1,324 @@
+import logging
+import os
+import re
+from typing import List, Optional, Tuple
+
+from pip._internal.utils.misc import (
+    HiddenText,
+    display_path,
+    is_console_interactive,
+    is_installable_dir,
+    split_auth_from_netloc,
+)
+from pip._internal.utils.subprocess import CommandArgs, make_command
+from pip._internal.vcs.versioncontrol import (
+    AuthInfo,
+    RemoteNotFoundError,
+    RevOptions,
+    VersionControl,
+    vcs,
+)
+
+logger = logging.getLogger(__name__)
+
+_svn_xml_url_re = re.compile('url="([^"]+)"')
+_svn_rev_re = re.compile(r'committed-rev="(\d+)"')
+_svn_info_xml_rev_re = re.compile(r'\s*revision="(\d+)"')
+_svn_info_xml_url_re = re.compile(r"(.*)")
+
+
+class Subversion(VersionControl):
+    name = "svn"
+    dirname = ".svn"
+    repo_name = "checkout"
+    schemes = ("svn+ssh", "svn+http", "svn+https", "svn+svn", "svn+file")
+
+    @classmethod
+    def should_add_vcs_url_prefix(cls, remote_url: str) -> bool:
+        return True
+
+    @staticmethod
+    def get_base_rev_args(rev: str) -> List[str]:
+        return ["-r", rev]
+
+    @classmethod
+    def get_revision(cls, location: str) -> str:
+        """
+        Return the maximum revision for all files under a given location
+        """
+        # Note: taken from setuptools.command.egg_info
+        revision = 0
+
+        for base, dirs, _ in os.walk(location):
+            if cls.dirname not in dirs:
+                dirs[:] = []
+                continue  # no sense walking uncontrolled subdirs
+            dirs.remove(cls.dirname)
+            entries_fn = os.path.join(base, cls.dirname, "entries")
+            if not os.path.exists(entries_fn):
+                # FIXME: should we warn?
+                continue
+
+            dirurl, localrev = cls._get_svn_url_rev(base)
+
+            if base == location:
+                assert dirurl is not None
+                base = dirurl + "/"  # save the root url
+            elif not dirurl or not dirurl.startswith(base):
+                dirs[:] = []
+                continue  # not part of the same svn tree, skip it
+            revision = max(revision, localrev)
+        return str(revision)
+
+    @classmethod
+    def get_netloc_and_auth(
+        cls, netloc: str, scheme: str
+    ) -> Tuple[str, Tuple[Optional[str], Optional[str]]]:
+        """
+        This override allows the auth information to be passed to svn via the
+        --username and --password options instead of via the URL.
+        """
+        if scheme == "ssh":
+            # The --username and --password options can't be used for
+            # svn+ssh URLs, so keep the auth information in the URL.
+            return super().get_netloc_and_auth(netloc, scheme)
+
+        return split_auth_from_netloc(netloc)
+
+    @classmethod
+    def get_url_rev_and_auth(cls, url: str) -> Tuple[str, Optional[str], AuthInfo]:
+        # hotfix the URL scheme after removing svn+ from svn+ssh:// re-add it
+        url, rev, user_pass = super().get_url_rev_and_auth(url)
+        if url.startswith("ssh://"):
+            url = "svn+" + url
+        return url, rev, user_pass
+
+    @staticmethod
+    def make_rev_args(
+        username: Optional[str], password: Optional[HiddenText]
+    ) -> CommandArgs:
+        extra_args: CommandArgs = []
+        if username:
+            extra_args += ["--username", username]
+        if password:
+            extra_args += ["--password", password]
+
+        return extra_args
+
+    @classmethod
+    def get_remote_url(cls, location: str) -> str:
+        # In cases where the source is in a subdirectory, we have to look up in
+        # the location until we find a valid project root.
+        orig_location = location
+        while not is_installable_dir(location):
+            last_location = location
+            location = os.path.dirname(location)
+            if location == last_location:
+                # We've traversed up to the root of the filesystem without
+                # finding a Python project.
+                logger.warning(
+                    "Could not find Python project for directory %s (tried all "
+                    "parent directories)",
+                    orig_location,
+                )
+                raise RemoteNotFoundError
+
+        url, _rev = cls._get_svn_url_rev(location)
+        if url is None:
+            raise RemoteNotFoundError
+
+        return url
+
+    @classmethod
+    def _get_svn_url_rev(cls, location: str) -> Tuple[Optional[str], int]:
+        from pip._internal.exceptions import InstallationError
+
+        entries_path = os.path.join(location, cls.dirname, "entries")
+        if os.path.exists(entries_path):
+            with open(entries_path) as f:
+                data = f.read()
+        else:  # subversion >= 1.7 does not have the 'entries' file
+            data = ""
+
+        url = None
+        if data.startswith("8") or data.startswith("9") or data.startswith("10"):
+            entries = list(map(str.splitlines, data.split("\n\x0c\n")))
+            del entries[0][0]  # get rid of the '8'
+            url = entries[0][3]
+            revs = [int(d[9]) for d in entries if len(d) > 9 and d[9]] + [0]
+        elif data.startswith("= 1.7
+                # Note that using get_remote_call_options is not necessary here
+                # because `svn info` is being run against a local directory.
+                # We don't need to worry about making sure interactive mode
+                # is being used to prompt for passwords, because passwords
+                # are only potentially needed for remote server requests.
+                xml = cls.run_command(
+                    ["info", "--xml", location],
+                    show_stdout=False,
+                    stdout_only=True,
+                )
+                match = _svn_info_xml_url_re.search(xml)
+                assert match is not None
+                url = match.group(1)
+                revs = [int(m.group(1)) for m in _svn_info_xml_rev_re.finditer(xml)]
+            except InstallationError:
+                url, revs = None, []
+
+        if revs:
+            rev = max(revs)
+        else:
+            rev = 0
+
+        return url, rev
+
+    @classmethod
+    def is_commit_id_equal(cls, dest: str, name: Optional[str]) -> bool:
+        """Always assume the versions don't match"""
+        return False
+
+    def __init__(self, use_interactive: Optional[bool] = None) -> None:
+        if use_interactive is None:
+            use_interactive = is_console_interactive()
+        self.use_interactive = use_interactive
+
+        # This member is used to cache the fetched version of the current
+        # ``svn`` client.
+        # Special value definitions:
+        #   None: Not evaluated yet.
+        #   Empty tuple: Could not parse version.
+        self._vcs_version: Optional[Tuple[int, ...]] = None
+
+        super().__init__()
+
+    def call_vcs_version(self) -> Tuple[int, ...]:
+        """Query the version of the currently installed Subversion client.
+
+        :return: A tuple containing the parts of the version information or
+            ``()`` if the version returned from ``svn`` could not be parsed.
+        :raises: BadCommand: If ``svn`` is not installed.
+        """
+        # Example versions:
+        #   svn, version 1.10.3 (r1842928)
+        #      compiled Feb 25 2019, 14:20:39 on x86_64-apple-darwin17.0.0
+        #   svn, version 1.7.14 (r1542130)
+        #      compiled Mar 28 2018, 08:49:13 on x86_64-pc-linux-gnu
+        #   svn, version 1.12.0-SlikSvn (SlikSvn/1.12.0)
+        #      compiled May 28 2019, 13:44:56 on x86_64-microsoft-windows6.2
+        version_prefix = "svn, version "
+        version = self.run_command(["--version"], show_stdout=False, stdout_only=True)
+        if not version.startswith(version_prefix):
+            return ()
+
+        version = version[len(version_prefix) :].split()[0]
+        version_list = version.partition("-")[0].split(".")
+        try:
+            parsed_version = tuple(map(int, version_list))
+        except ValueError:
+            return ()
+
+        return parsed_version
+
+    def get_vcs_version(self) -> Tuple[int, ...]:
+        """Return the version of the currently installed Subversion client.
+
+        If the version of the Subversion client has already been queried,
+        a cached value will be used.
+
+        :return: A tuple containing the parts of the version information or
+            ``()`` if the version returned from ``svn`` could not be parsed.
+        :raises: BadCommand: If ``svn`` is not installed.
+        """
+        if self._vcs_version is not None:
+            # Use cached version, if available.
+            # If parsing the version failed previously (empty tuple),
+            # do not attempt to parse it again.
+            return self._vcs_version
+
+        vcs_version = self.call_vcs_version()
+        self._vcs_version = vcs_version
+        return vcs_version
+
+    def get_remote_call_options(self) -> CommandArgs:
+        """Return options to be used on calls to Subversion that contact the server.
+
+        These options are applicable for the following ``svn`` subcommands used
+        in this class.
+
+            - checkout
+            - switch
+            - update
+
+        :return: A list of command line arguments to pass to ``svn``.
+        """
+        if not self.use_interactive:
+            # --non-interactive switch is available since Subversion 0.14.4.
+            # Subversion < 1.8 runs in interactive mode by default.
+            return ["--non-interactive"]
+
+        svn_version = self.get_vcs_version()
+        # By default, Subversion >= 1.8 runs in non-interactive mode if
+        # stdin is not a TTY. Since that is how pip invokes SVN, in
+        # call_subprocess(), pip must pass --force-interactive to ensure
+        # the user can be prompted for a password, if required.
+        #   SVN added the --force-interactive option in SVN 1.8. Since
+        # e.g. RHEL/CentOS 7, which is supported until 2024, ships with
+        # SVN 1.7, pip should continue to support SVN 1.7. Therefore, pip
+        # can't safely add the option if the SVN version is < 1.8 (or unknown).
+        if svn_version >= (1, 8):
+            return ["--force-interactive"]
+
+        return []
+
+    def fetch_new(
+        self, dest: str, url: HiddenText, rev_options: RevOptions, verbosity: int
+    ) -> None:
+        rev_display = rev_options.to_display()
+        logger.info(
+            "Checking out %s%s to %s",
+            url,
+            rev_display,
+            display_path(dest),
+        )
+        if verbosity <= 0:
+            flags = ["--quiet"]
+        else:
+            flags = []
+        cmd_args = make_command(
+            "checkout",
+            *flags,
+            self.get_remote_call_options(),
+            rev_options.to_args(),
+            url,
+            dest,
+        )
+        self.run_command(cmd_args)
+
+    def switch(self, dest: str, url: HiddenText, rev_options: RevOptions) -> None:
+        cmd_args = make_command(
+            "switch",
+            self.get_remote_call_options(),
+            rev_options.to_args(),
+            url,
+            dest,
+        )
+        self.run_command(cmd_args)
+
+    def update(self, dest: str, url: HiddenText, rev_options: RevOptions) -> None:
+        cmd_args = make_command(
+            "update",
+            self.get_remote_call_options(),
+            rev_options.to_args(),
+            dest,
+        )
+        self.run_command(cmd_args)
+
+
+vcs.register(Subversion)
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/vcs/versioncontrol.py b/venv/lib/python3.12/site-packages/pip/_internal/vcs/versioncontrol.py
new file mode 100644
index 00000000..a4133165
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/vcs/versioncontrol.py
@@ -0,0 +1,688 @@
+"""Handles all VCS (version control) support"""
+
+import logging
+import os
+import shutil
+import sys
+import urllib.parse
+from dataclasses import dataclass, field
+from typing import (
+    Any,
+    Dict,
+    Iterable,
+    Iterator,
+    List,
+    Literal,
+    Mapping,
+    Optional,
+    Tuple,
+    Type,
+    Union,
+)
+
+from pip._internal.cli.spinners import SpinnerInterface
+from pip._internal.exceptions import BadCommand, InstallationError
+from pip._internal.utils.misc import (
+    HiddenText,
+    ask_path_exists,
+    backup_dir,
+    display_path,
+    hide_url,
+    hide_value,
+    is_installable_dir,
+    rmtree,
+)
+from pip._internal.utils.subprocess import (
+    CommandArgs,
+    call_subprocess,
+    format_command_args,
+    make_command,
+)
+
+__all__ = ["vcs"]
+
+
+logger = logging.getLogger(__name__)
+
+AuthInfo = Tuple[Optional[str], Optional[str]]
+
+
+def is_url(name: str) -> bool:
+    """
+    Return true if the name looks like a URL.
+    """
+    scheme = urllib.parse.urlsplit(name).scheme
+    if not scheme:
+        return False
+    return scheme in ["http", "https", "file", "ftp"] + vcs.all_schemes
+
+
+def make_vcs_requirement_url(
+    repo_url: str, rev: str, project_name: str, subdir: Optional[str] = None
+) -> str:
+    """
+    Return the URL for a VCS requirement.
+
+    Args:
+      repo_url: the remote VCS url, with any needed VCS prefix (e.g. "git+").
+      project_name: the (unescaped) project name.
+    """
+    egg_project_name = project_name.replace("-", "_")
+    req = f"{repo_url}@{rev}#egg={egg_project_name}"
+    if subdir:
+        req += f"&subdirectory={subdir}"
+
+    return req
+
+
+def find_path_to_project_root_from_repo_root(
+    location: str, repo_root: str
+) -> Optional[str]:
+    """
+    Find the the Python project's root by searching up the filesystem from
+    `location`. Return the path to project root relative to `repo_root`.
+    Return None if the project root is `repo_root`, or cannot be found.
+    """
+    # find project root.
+    orig_location = location
+    while not is_installable_dir(location):
+        last_location = location
+        location = os.path.dirname(location)
+        if location == last_location:
+            # We've traversed up to the root of the filesystem without
+            # finding a Python project.
+            logger.warning(
+                "Could not find a Python project for directory %s (tried all "
+                "parent directories)",
+                orig_location,
+            )
+            return None
+
+    if os.path.samefile(repo_root, location):
+        return None
+
+    return os.path.relpath(location, repo_root)
+
+
+class RemoteNotFoundError(Exception):
+    pass
+
+
+class RemoteNotValidError(Exception):
+    def __init__(self, url: str):
+        super().__init__(url)
+        self.url = url
+
+
+@dataclass(frozen=True)
+class RevOptions:
+    """
+    Encapsulates a VCS-specific revision to install, along with any VCS
+    install options.
+
+    Args:
+        vc_class: a VersionControl subclass.
+        rev: the name of the revision to install.
+        extra_args: a list of extra options.
+    """
+
+    vc_class: Type["VersionControl"]
+    rev: Optional[str] = None
+    extra_args: CommandArgs = field(default_factory=list)
+    branch_name: Optional[str] = None
+
+    def __repr__(self) -> str:
+        return f""
+
+    @property
+    def arg_rev(self) -> Optional[str]:
+        if self.rev is None:
+            return self.vc_class.default_arg_rev
+
+        return self.rev
+
+    def to_args(self) -> CommandArgs:
+        """
+        Return the VCS-specific command arguments.
+        """
+        args: CommandArgs = []
+        rev = self.arg_rev
+        if rev is not None:
+            args += self.vc_class.get_base_rev_args(rev)
+        args += self.extra_args
+
+        return args
+
+    def to_display(self) -> str:
+        if not self.rev:
+            return ""
+
+        return f" (to revision {self.rev})"
+
+    def make_new(self, rev: str) -> "RevOptions":
+        """
+        Make a copy of the current instance, but with a new rev.
+
+        Args:
+          rev: the name of the revision for the new object.
+        """
+        return self.vc_class.make_rev_options(rev, extra_args=self.extra_args)
+
+
+class VcsSupport:
+    _registry: Dict[str, "VersionControl"] = {}
+    schemes = ["ssh", "git", "hg", "bzr", "sftp", "svn"]
+
+    def __init__(self) -> None:
+        # Register more schemes with urlparse for various version control
+        # systems
+        urllib.parse.uses_netloc.extend(self.schemes)
+        super().__init__()
+
+    def __iter__(self) -> Iterator[str]:
+        return self._registry.__iter__()
+
+    @property
+    def backends(self) -> List["VersionControl"]:
+        return list(self._registry.values())
+
+    @property
+    def dirnames(self) -> List[str]:
+        return [backend.dirname for backend in self.backends]
+
+    @property
+    def all_schemes(self) -> List[str]:
+        schemes: List[str] = []
+        for backend in self.backends:
+            schemes.extend(backend.schemes)
+        return schemes
+
+    def register(self, cls: Type["VersionControl"]) -> None:
+        if not hasattr(cls, "name"):
+            logger.warning("Cannot register VCS %s", cls.__name__)
+            return
+        if cls.name not in self._registry:
+            self._registry[cls.name] = cls()
+            logger.debug("Registered VCS backend: %s", cls.name)
+
+    def unregister(self, name: str) -> None:
+        if name in self._registry:
+            del self._registry[name]
+
+    def get_backend_for_dir(self, location: str) -> Optional["VersionControl"]:
+        """
+        Return a VersionControl object if a repository of that type is found
+        at the given directory.
+        """
+        vcs_backends = {}
+        for vcs_backend in self._registry.values():
+            repo_path = vcs_backend.get_repository_root(location)
+            if not repo_path:
+                continue
+            logger.debug("Determine that %s uses VCS: %s", location, vcs_backend.name)
+            vcs_backends[repo_path] = vcs_backend
+
+        if not vcs_backends:
+            return None
+
+        # Choose the VCS in the inner-most directory. Since all repository
+        # roots found here would be either `location` or one of its
+        # parents, the longest path should have the most path components,
+        # i.e. the backend representing the inner-most repository.
+        inner_most_repo_path = max(vcs_backends, key=len)
+        return vcs_backends[inner_most_repo_path]
+
+    def get_backend_for_scheme(self, scheme: str) -> Optional["VersionControl"]:
+        """
+        Return a VersionControl object or None.
+        """
+        for vcs_backend in self._registry.values():
+            if scheme in vcs_backend.schemes:
+                return vcs_backend
+        return None
+
+    def get_backend(self, name: str) -> Optional["VersionControl"]:
+        """
+        Return a VersionControl object or None.
+        """
+        name = name.lower()
+        return self._registry.get(name)
+
+
+vcs = VcsSupport()
+
+
+class VersionControl:
+    name = ""
+    dirname = ""
+    repo_name = ""
+    # List of supported schemes for this Version Control
+    schemes: Tuple[str, ...] = ()
+    # Iterable of environment variable names to pass to call_subprocess().
+    unset_environ: Tuple[str, ...] = ()
+    default_arg_rev: Optional[str] = None
+
+    @classmethod
+    def should_add_vcs_url_prefix(cls, remote_url: str) -> bool:
+        """
+        Return whether the vcs prefix (e.g. "git+") should be added to a
+        repository's remote url when used in a requirement.
+        """
+        return not remote_url.lower().startswith(f"{cls.name}:")
+
+    @classmethod
+    def get_subdirectory(cls, location: str) -> Optional[str]:
+        """
+        Return the path to Python project root, relative to the repo root.
+        Return None if the project root is in the repo root.
+        """
+        return None
+
+    @classmethod
+    def get_requirement_revision(cls, repo_dir: str) -> str:
+        """
+        Return the revision string that should be used in a requirement.
+        """
+        return cls.get_revision(repo_dir)
+
+    @classmethod
+    def get_src_requirement(cls, repo_dir: str, project_name: str) -> str:
+        """
+        Return the requirement string to use to redownload the files
+        currently at the given repository directory.
+
+        Args:
+          project_name: the (unescaped) project name.
+
+        The return value has a form similar to the following:
+
+            {repository_url}@{revision}#egg={project_name}
+        """
+        repo_url = cls.get_remote_url(repo_dir)
+
+        if cls.should_add_vcs_url_prefix(repo_url):
+            repo_url = f"{cls.name}+{repo_url}"
+
+        revision = cls.get_requirement_revision(repo_dir)
+        subdir = cls.get_subdirectory(repo_dir)
+        req = make_vcs_requirement_url(repo_url, revision, project_name, subdir=subdir)
+
+        return req
+
+    @staticmethod
+    def get_base_rev_args(rev: str) -> List[str]:
+        """
+        Return the base revision arguments for a vcs command.
+
+        Args:
+          rev: the name of a revision to install.  Cannot be None.
+        """
+        raise NotImplementedError
+
+    def is_immutable_rev_checkout(self, url: str, dest: str) -> bool:
+        """
+        Return true if the commit hash checked out at dest matches
+        the revision in url.
+
+        Always return False, if the VCS does not support immutable commit
+        hashes.
+
+        This method does not check if there are local uncommitted changes
+        in dest after checkout, as pip currently has no use case for that.
+        """
+        return False
+
+    @classmethod
+    def make_rev_options(
+        cls, rev: Optional[str] = None, extra_args: Optional[CommandArgs] = None
+    ) -> RevOptions:
+        """
+        Return a RevOptions object.
+
+        Args:
+          rev: the name of a revision to install.
+          extra_args: a list of extra options.
+        """
+        return RevOptions(cls, rev, extra_args=extra_args or [])
+
+    @classmethod
+    def _is_local_repository(cls, repo: str) -> bool:
+        """
+        posix absolute paths start with os.path.sep,
+        win32 ones start with drive (like c:\\folder)
+        """
+        drive, tail = os.path.splitdrive(repo)
+        return repo.startswith(os.path.sep) or bool(drive)
+
+    @classmethod
+    def get_netloc_and_auth(
+        cls, netloc: str, scheme: str
+    ) -> Tuple[str, Tuple[Optional[str], Optional[str]]]:
+        """
+        Parse the repository URL's netloc, and return the new netloc to use
+        along with auth information.
+
+        Args:
+          netloc: the original repository URL netloc.
+          scheme: the repository URL's scheme without the vcs prefix.
+
+        This is mainly for the Subversion class to override, so that auth
+        information can be provided via the --username and --password options
+        instead of through the URL.  For other subclasses like Git without
+        such an option, auth information must stay in the URL.
+
+        Returns: (netloc, (username, password)).
+        """
+        return netloc, (None, None)
+
+    @classmethod
+    def get_url_rev_and_auth(cls, url: str) -> Tuple[str, Optional[str], AuthInfo]:
+        """
+        Parse the repository URL to use, and return the URL, revision,
+        and auth info to use.
+
+        Returns: (url, rev, (username, password)).
+        """
+        scheme, netloc, path, query, frag = urllib.parse.urlsplit(url)
+        if "+" not in scheme:
+            raise ValueError(
+                f"Sorry, {url!r} is a malformed VCS url. "
+                "The format is +://, "
+                "e.g. svn+http://myrepo/svn/MyApp#egg=MyApp"
+            )
+        # Remove the vcs prefix.
+        scheme = scheme.split("+", 1)[1]
+        netloc, user_pass = cls.get_netloc_and_auth(netloc, scheme)
+        rev = None
+        if "@" in path:
+            path, rev = path.rsplit("@", 1)
+            if not rev:
+                raise InstallationError(
+                    f"The URL {url!r} has an empty revision (after @) "
+                    "which is not supported. Include a revision after @ "
+                    "or remove @ from the URL."
+                )
+        url = urllib.parse.urlunsplit((scheme, netloc, path, query, ""))
+        return url, rev, user_pass
+
+    @staticmethod
+    def make_rev_args(
+        username: Optional[str], password: Optional[HiddenText]
+    ) -> CommandArgs:
+        """
+        Return the RevOptions "extra arguments" to use in obtain().
+        """
+        return []
+
+    def get_url_rev_options(self, url: HiddenText) -> Tuple[HiddenText, RevOptions]:
+        """
+        Return the URL and RevOptions object to use in obtain(),
+        as a tuple (url, rev_options).
+        """
+        secret_url, rev, user_pass = self.get_url_rev_and_auth(url.secret)
+        username, secret_password = user_pass
+        password: Optional[HiddenText] = None
+        if secret_password is not None:
+            password = hide_value(secret_password)
+        extra_args = self.make_rev_args(username, password)
+        rev_options = self.make_rev_options(rev, extra_args=extra_args)
+
+        return hide_url(secret_url), rev_options
+
+    @staticmethod
+    def normalize_url(url: str) -> str:
+        """
+        Normalize a URL for comparison by unquoting it and removing any
+        trailing slash.
+        """
+        return urllib.parse.unquote(url).rstrip("/")
+
+    @classmethod
+    def compare_urls(cls, url1: str, url2: str) -> bool:
+        """
+        Compare two repo URLs for identity, ignoring incidental differences.
+        """
+        return cls.normalize_url(url1) == cls.normalize_url(url2)
+
+    def fetch_new(
+        self, dest: str, url: HiddenText, rev_options: RevOptions, verbosity: int
+    ) -> None:
+        """
+        Fetch a revision from a repository, in the case that this is the
+        first fetch from the repository.
+
+        Args:
+          dest: the directory to fetch the repository to.
+          rev_options: a RevOptions object.
+          verbosity: verbosity level.
+        """
+        raise NotImplementedError
+
+    def switch(self, dest: str, url: HiddenText, rev_options: RevOptions) -> None:
+        """
+        Switch the repo at ``dest`` to point to ``URL``.
+
+        Args:
+          rev_options: a RevOptions object.
+        """
+        raise NotImplementedError
+
+    def update(self, dest: str, url: HiddenText, rev_options: RevOptions) -> None:
+        """
+        Update an already-existing repo to the given ``rev_options``.
+
+        Args:
+          rev_options: a RevOptions object.
+        """
+        raise NotImplementedError
+
+    @classmethod
+    def is_commit_id_equal(cls, dest: str, name: Optional[str]) -> bool:
+        """
+        Return whether the id of the current commit equals the given name.
+
+        Args:
+          dest: the repository directory.
+          name: a string name.
+        """
+        raise NotImplementedError
+
+    def obtain(self, dest: str, url: HiddenText, verbosity: int) -> None:
+        """
+        Install or update in editable mode the package represented by this
+        VersionControl object.
+
+        :param dest: the repository directory in which to install or update.
+        :param url: the repository URL starting with a vcs prefix.
+        :param verbosity: verbosity level.
+        """
+        url, rev_options = self.get_url_rev_options(url)
+
+        if not os.path.exists(dest):
+            self.fetch_new(dest, url, rev_options, verbosity=verbosity)
+            return
+
+        rev_display = rev_options.to_display()
+        if self.is_repository_directory(dest):
+            existing_url = self.get_remote_url(dest)
+            if self.compare_urls(existing_url, url.secret):
+                logger.debug(
+                    "%s in %s exists, and has correct URL (%s)",
+                    self.repo_name.title(),
+                    display_path(dest),
+                    url,
+                )
+                if not self.is_commit_id_equal(dest, rev_options.rev):
+                    logger.info(
+                        "Updating %s %s%s",
+                        display_path(dest),
+                        self.repo_name,
+                        rev_display,
+                    )
+                    self.update(dest, url, rev_options)
+                else:
+                    logger.info("Skipping because already up-to-date.")
+                return
+
+            logger.warning(
+                "%s %s in %s exists with URL %s",
+                self.name,
+                self.repo_name,
+                display_path(dest),
+                existing_url,
+            )
+            prompt = ("(s)witch, (i)gnore, (w)ipe, (b)ackup ", ("s", "i", "w", "b"))
+        else:
+            logger.warning(
+                "Directory %s already exists, and is not a %s %s.",
+                dest,
+                self.name,
+                self.repo_name,
+            )
+            # https://github.com/python/mypy/issues/1174
+            prompt = ("(i)gnore, (w)ipe, (b)ackup ", ("i", "w", "b"))  # type: ignore
+
+        logger.warning(
+            "The plan is to install the %s repository %s",
+            self.name,
+            url,
+        )
+        response = ask_path_exists(f"What to do?  {prompt[0]}", prompt[1])
+
+        if response == "a":
+            sys.exit(-1)
+
+        if response == "w":
+            logger.warning("Deleting %s", display_path(dest))
+            rmtree(dest)
+            self.fetch_new(dest, url, rev_options, verbosity=verbosity)
+            return
+
+        if response == "b":
+            dest_dir = backup_dir(dest)
+            logger.warning("Backing up %s to %s", display_path(dest), dest_dir)
+            shutil.move(dest, dest_dir)
+            self.fetch_new(dest, url, rev_options, verbosity=verbosity)
+            return
+
+        # Do nothing if the response is "i".
+        if response == "s":
+            logger.info(
+                "Switching %s %s to %s%s",
+                self.repo_name,
+                display_path(dest),
+                url,
+                rev_display,
+            )
+            self.switch(dest, url, rev_options)
+
+    def unpack(self, location: str, url: HiddenText, verbosity: int) -> None:
+        """
+        Clean up current location and download the url repository
+        (and vcs infos) into location
+
+        :param url: the repository URL starting with a vcs prefix.
+        :param verbosity: verbosity level.
+        """
+        if os.path.exists(location):
+            rmtree(location)
+        self.obtain(location, url=url, verbosity=verbosity)
+
+    @classmethod
+    def get_remote_url(cls, location: str) -> str:
+        """
+        Return the url used at location
+
+        Raises RemoteNotFoundError if the repository does not have a remote
+        url configured.
+        """
+        raise NotImplementedError
+
+    @classmethod
+    def get_revision(cls, location: str) -> str:
+        """
+        Return the current commit id of the files at the given location.
+        """
+        raise NotImplementedError
+
+    @classmethod
+    def run_command(
+        cls,
+        cmd: Union[List[str], CommandArgs],
+        show_stdout: bool = True,
+        cwd: Optional[str] = None,
+        on_returncode: 'Literal["raise", "warn", "ignore"]' = "raise",
+        extra_ok_returncodes: Optional[Iterable[int]] = None,
+        command_desc: Optional[str] = None,
+        extra_environ: Optional[Mapping[str, Any]] = None,
+        spinner: Optional[SpinnerInterface] = None,
+        log_failed_cmd: bool = True,
+        stdout_only: bool = False,
+    ) -> str:
+        """
+        Run a VCS subcommand
+        This is simply a wrapper around call_subprocess that adds the VCS
+        command name, and checks that the VCS is available
+        """
+        cmd = make_command(cls.name, *cmd)
+        if command_desc is None:
+            command_desc = format_command_args(cmd)
+        try:
+            return call_subprocess(
+                cmd,
+                show_stdout,
+                cwd,
+                on_returncode=on_returncode,
+                extra_ok_returncodes=extra_ok_returncodes,
+                command_desc=command_desc,
+                extra_environ=extra_environ,
+                unset_environ=cls.unset_environ,
+                spinner=spinner,
+                log_failed_cmd=log_failed_cmd,
+                stdout_only=stdout_only,
+            )
+        except NotADirectoryError:
+            raise BadCommand(f"Cannot find command {cls.name!r} - invalid PATH")
+        except FileNotFoundError:
+            # errno.ENOENT = no such file or directory
+            # In other words, the VCS executable isn't available
+            raise BadCommand(
+                f"Cannot find command {cls.name!r} - do you have "
+                f"{cls.name!r} installed and in your PATH?"
+            )
+        except PermissionError:
+            # errno.EACCES = Permission denied
+            # This error occurs, for instance, when the command is installed
+            # only for another user. So, the current user don't have
+            # permission to call the other user command.
+            raise BadCommand(
+                f"No permission to execute {cls.name!r} - install it "
+                f"locally, globally (ask admin), or check your PATH. "
+                f"See possible solutions at "
+                f"https://pip.pypa.io/en/latest/reference/pip_freeze/"
+                f"#fixing-permission-denied."
+            )
+
+    @classmethod
+    def is_repository_directory(cls, path: str) -> bool:
+        """
+        Return whether a directory path is a repository directory.
+        """
+        logger.debug("Checking in %s for %s (%s)...", path, cls.dirname, cls.name)
+        return os.path.exists(os.path.join(path, cls.dirname))
+
+    @classmethod
+    def get_repository_root(cls, location: str) -> Optional[str]:
+        """
+        Return the "root" (top-level) directory controlled by the vcs,
+        or `None` if the directory is not in any.
+
+        It is meant to be overridden to implement smarter detection
+        mechanisms for specific vcs.
+
+        This can do more than is_repository_directory() alone. For
+        example, the Git override checks that Git is actually available.
+        """
+        if cls.is_repository_directory(location):
+            return location
+        return None
diff --git a/venv/lib/python3.12/site-packages/pip/_internal/wheel_builder.py b/venv/lib/python3.12/site-packages/pip/_internal/wheel_builder.py
new file mode 100644
index 00000000..93f8e1f5
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_internal/wheel_builder.py
@@ -0,0 +1,354 @@
+"""Orchestrator for building wheels from InstallRequirements.
+"""
+
+import logging
+import os.path
+import re
+import shutil
+from typing import Iterable, List, Optional, Tuple
+
+from pip._vendor.packaging.utils import canonicalize_name, canonicalize_version
+from pip._vendor.packaging.version import InvalidVersion, Version
+
+from pip._internal.cache import WheelCache
+from pip._internal.exceptions import InvalidWheelFilename, UnsupportedWheel
+from pip._internal.metadata import FilesystemWheel, get_wheel_distribution
+from pip._internal.models.link import Link
+from pip._internal.models.wheel import Wheel
+from pip._internal.operations.build.wheel import build_wheel_pep517
+from pip._internal.operations.build.wheel_editable import build_wheel_editable
+from pip._internal.operations.build.wheel_legacy import build_wheel_legacy
+from pip._internal.req.req_install import InstallRequirement
+from pip._internal.utils.logging import indent_log
+from pip._internal.utils.misc import ensure_dir, hash_file
+from pip._internal.utils.setuptools_build import make_setuptools_clean_args
+from pip._internal.utils.subprocess import call_subprocess
+from pip._internal.utils.temp_dir import TempDirectory
+from pip._internal.utils.urls import path_to_url
+from pip._internal.vcs import vcs
+
+logger = logging.getLogger(__name__)
+
+_egg_info_re = re.compile(r"([a-z0-9_.]+)-([a-z0-9_.!+-]+)", re.IGNORECASE)
+
+BuildResult = Tuple[List[InstallRequirement], List[InstallRequirement]]
+
+
+def _contains_egg_info(s: str) -> bool:
+    """Determine whether the string looks like an egg_info.
+
+    :param s: The string to parse. E.g. foo-2.1
+    """
+    return bool(_egg_info_re.search(s))
+
+
+def _should_build(
+    req: InstallRequirement,
+    need_wheel: bool,
+) -> bool:
+    """Return whether an InstallRequirement should be built into a wheel."""
+    if req.constraint:
+        # never build requirements that are merely constraints
+        return False
+    if req.is_wheel:
+        if need_wheel:
+            logger.info(
+                "Skipping %s, due to already being wheel.",
+                req.name,
+            )
+        return False
+
+    if need_wheel:
+        # i.e. pip wheel, not pip install
+        return True
+
+    # From this point, this concerns the pip install command only
+    # (need_wheel=False).
+
+    if not req.source_dir:
+        return False
+
+    if req.editable:
+        # we only build PEP 660 editable requirements
+        return req.supports_pyproject_editable
+
+    return True
+
+
+def should_build_for_wheel_command(
+    req: InstallRequirement,
+) -> bool:
+    return _should_build(req, need_wheel=True)
+
+
+def should_build_for_install_command(
+    req: InstallRequirement,
+) -> bool:
+    return _should_build(req, need_wheel=False)
+
+
+def _should_cache(
+    req: InstallRequirement,
+) -> Optional[bool]:
+    """
+    Return whether a built InstallRequirement can be stored in the persistent
+    wheel cache, assuming the wheel cache is available, and _should_build()
+    has determined a wheel needs to be built.
+    """
+    if req.editable or not req.source_dir:
+        # never cache editable requirements
+        return False
+
+    if req.link and req.link.is_vcs:
+        # VCS checkout. Do not cache
+        # unless it points to an immutable commit hash.
+        assert not req.editable
+        assert req.source_dir
+        vcs_backend = vcs.get_backend_for_scheme(req.link.scheme)
+        assert vcs_backend
+        if vcs_backend.is_immutable_rev_checkout(req.link.url, req.source_dir):
+            return True
+        return False
+
+    assert req.link
+    base, ext = req.link.splitext()
+    if _contains_egg_info(base):
+        return True
+
+    # Otherwise, do not cache.
+    return False
+
+
+def _get_cache_dir(
+    req: InstallRequirement,
+    wheel_cache: WheelCache,
+) -> str:
+    """Return the persistent or temporary cache directory where the built
+    wheel need to be stored.
+    """
+    cache_available = bool(wheel_cache.cache_dir)
+    assert req.link
+    if cache_available and _should_cache(req):
+        cache_dir = wheel_cache.get_path_for_link(req.link)
+    else:
+        cache_dir = wheel_cache.get_ephem_path_for_link(req.link)
+    return cache_dir
+
+
+def _verify_one(req: InstallRequirement, wheel_path: str) -> None:
+    canonical_name = canonicalize_name(req.name or "")
+    w = Wheel(os.path.basename(wheel_path))
+    if canonicalize_name(w.name) != canonical_name:
+        raise InvalidWheelFilename(
+            f"Wheel has unexpected file name: expected {canonical_name!r}, "
+            f"got {w.name!r}",
+        )
+    dist = get_wheel_distribution(FilesystemWheel(wheel_path), canonical_name)
+    dist_verstr = str(dist.version)
+    if canonicalize_version(dist_verstr) != canonicalize_version(w.version):
+        raise InvalidWheelFilename(
+            f"Wheel has unexpected file name: expected {dist_verstr!r}, "
+            f"got {w.version!r}",
+        )
+    metadata_version_value = dist.metadata_version
+    if metadata_version_value is None:
+        raise UnsupportedWheel("Missing Metadata-Version")
+    try:
+        metadata_version = Version(metadata_version_value)
+    except InvalidVersion:
+        msg = f"Invalid Metadata-Version: {metadata_version_value}"
+        raise UnsupportedWheel(msg)
+    if metadata_version >= Version("1.2") and not isinstance(dist.version, Version):
+        raise UnsupportedWheel(
+            f"Metadata 1.2 mandates PEP 440 version, but {dist_verstr!r} is not"
+        )
+
+
+def _build_one(
+    req: InstallRequirement,
+    output_dir: str,
+    verify: bool,
+    build_options: List[str],
+    global_options: List[str],
+    editable: bool,
+) -> Optional[str]:
+    """Build one wheel.
+
+    :return: The filename of the built wheel, or None if the build failed.
+    """
+    artifact = "editable" if editable else "wheel"
+    try:
+        ensure_dir(output_dir)
+    except OSError as e:
+        logger.warning(
+            "Building %s for %s failed: %s",
+            artifact,
+            req.name,
+            e,
+        )
+        return None
+
+    # Install build deps into temporary directory (PEP 518)
+    with req.build_env:
+        wheel_path = _build_one_inside_env(
+            req, output_dir, build_options, global_options, editable
+        )
+    if wheel_path and verify:
+        try:
+            _verify_one(req, wheel_path)
+        except (InvalidWheelFilename, UnsupportedWheel) as e:
+            logger.warning("Built %s for %s is invalid: %s", artifact, req.name, e)
+            return None
+    return wheel_path
+
+
+def _build_one_inside_env(
+    req: InstallRequirement,
+    output_dir: str,
+    build_options: List[str],
+    global_options: List[str],
+    editable: bool,
+) -> Optional[str]:
+    with TempDirectory(kind="wheel") as temp_dir:
+        assert req.name
+        if req.use_pep517:
+            assert req.metadata_directory
+            assert req.pep517_backend
+            if global_options:
+                logger.warning(
+                    "Ignoring --global-option when building %s using PEP 517", req.name
+                )
+            if build_options:
+                logger.warning(
+                    "Ignoring --build-option when building %s using PEP 517", req.name
+                )
+            if editable:
+                wheel_path = build_wheel_editable(
+                    name=req.name,
+                    backend=req.pep517_backend,
+                    metadata_directory=req.metadata_directory,
+                    tempd=temp_dir.path,
+                )
+            else:
+                wheel_path = build_wheel_pep517(
+                    name=req.name,
+                    backend=req.pep517_backend,
+                    metadata_directory=req.metadata_directory,
+                    tempd=temp_dir.path,
+                )
+        else:
+            wheel_path = build_wheel_legacy(
+                name=req.name,
+                setup_py_path=req.setup_py_path,
+                source_dir=req.unpacked_source_directory,
+                global_options=global_options,
+                build_options=build_options,
+                tempd=temp_dir.path,
+            )
+
+        if wheel_path is not None:
+            wheel_name = os.path.basename(wheel_path)
+            dest_path = os.path.join(output_dir, wheel_name)
+            try:
+                wheel_hash, length = hash_file(wheel_path)
+                shutil.move(wheel_path, dest_path)
+                logger.info(
+                    "Created wheel for %s: filename=%s size=%d sha256=%s",
+                    req.name,
+                    wheel_name,
+                    length,
+                    wheel_hash.hexdigest(),
+                )
+                logger.info("Stored in directory: %s", output_dir)
+                return dest_path
+            except Exception as e:
+                logger.warning(
+                    "Building wheel for %s failed: %s",
+                    req.name,
+                    e,
+                )
+        # Ignore return, we can't do anything else useful.
+        if not req.use_pep517:
+            _clean_one_legacy(req, global_options)
+        return None
+
+
+def _clean_one_legacy(req: InstallRequirement, global_options: List[str]) -> bool:
+    clean_args = make_setuptools_clean_args(
+        req.setup_py_path,
+        global_options=global_options,
+    )
+
+    logger.info("Running setup.py clean for %s", req.name)
+    try:
+        call_subprocess(
+            clean_args, command_desc="python setup.py clean", cwd=req.source_dir
+        )
+        return True
+    except Exception:
+        logger.error("Failed cleaning build dir for %s", req.name)
+        return False
+
+
+def build(
+    requirements: Iterable[InstallRequirement],
+    wheel_cache: WheelCache,
+    verify: bool,
+    build_options: List[str],
+    global_options: List[str],
+) -> BuildResult:
+    """Build wheels.
+
+    :return: The list of InstallRequirement that succeeded to build and
+        the list of InstallRequirement that failed to build.
+    """
+    if not requirements:
+        return [], []
+
+    # Build the wheels.
+    logger.info(
+        "Building wheels for collected packages: %s",
+        ", ".join(req.name for req in requirements),  # type: ignore
+    )
+
+    with indent_log():
+        build_successes, build_failures = [], []
+        for req in requirements:
+            assert req.name
+            cache_dir = _get_cache_dir(req, wheel_cache)
+            wheel_file = _build_one(
+                req,
+                cache_dir,
+                verify,
+                build_options,
+                global_options,
+                req.editable and req.permit_editable_wheels,
+            )
+            if wheel_file:
+                # Record the download origin in the cache
+                if req.download_info is not None:
+                    # download_info is guaranteed to be set because when we build an
+                    # InstallRequirement it has been through the preparer before, but
+                    # let's be cautious.
+                    wheel_cache.record_download_origin(cache_dir, req.download_info)
+                # Update the link for this.
+                req.link = Link(path_to_url(wheel_file))
+                req.local_file_path = req.link.file_path
+                assert req.link.is_wheel
+                build_successes.append(req)
+            else:
+                build_failures.append(req)
+
+    # notify success/failure
+    if build_successes:
+        logger.info(
+            "Successfully built %s",
+            " ".join([req.name for req in build_successes]),  # type: ignore
+        )
+    if build_failures:
+        logger.info(
+            "Failed to build %s",
+            " ".join([req.name for req in build_failures]),  # type: ignore
+        )
+    # Return a list of requirements that failed to build
+    return build_successes, build_failures
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/__init__.py b/venv/lib/python3.12/site-packages/pip/_vendor/__init__.py
new file mode 100644
index 00000000..561089cc
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_vendor/__init__.py
@@ -0,0 +1,116 @@
+"""
+pip._vendor is for vendoring dependencies of pip to prevent needing pip to
+depend on something external.
+
+Files inside of pip._vendor should be considered immutable and should only be
+updated to versions from upstream.
+"""
+from __future__ import absolute_import
+
+import glob
+import os.path
+import sys
+
+# Downstream redistributors which have debundled our dependencies should also
+# patch this value to be true. This will trigger the additional patching
+# to cause things like "six" to be available as pip.
+DEBUNDLED = False
+
+# By default, look in this directory for a bunch of .whl files which we will
+# add to the beginning of sys.path before attempting to import anything. This
+# is done to support downstream re-distributors like Debian and Fedora who
+# wish to create their own Wheels for our dependencies to aid in debundling.
+WHEEL_DIR = os.path.abspath(os.path.dirname(__file__))
+
+
+# Define a small helper function to alias our vendored modules to the real ones
+# if the vendored ones do not exist. This idea of this was taken from
+# https://github.com/kennethreitz/requests/pull/2567.
+def vendored(modulename):
+    vendored_name = "{0}.{1}".format(__name__, modulename)
+
+    try:
+        __import__(modulename, globals(), locals(), level=0)
+    except ImportError:
+        # We can just silently allow import failures to pass here. If we
+        # got to this point it means that ``import pip._vendor.whatever``
+        # failed and so did ``import whatever``. Since we're importing this
+        # upfront in an attempt to alias imports, not erroring here will
+        # just mean we get a regular import error whenever pip *actually*
+        # tries to import one of these modules to use it, which actually
+        # gives us a better error message than we would have otherwise
+        # gotten.
+        pass
+    else:
+        sys.modules[vendored_name] = sys.modules[modulename]
+        base, head = vendored_name.rsplit(".", 1)
+        setattr(sys.modules[base], head, sys.modules[modulename])
+
+
+# If we're operating in a debundled setup, then we want to go ahead and trigger
+# the aliasing of our vendored libraries as well as looking for wheels to add
+# to our sys.path. This will cause all of this code to be a no-op typically
+# however downstream redistributors can enable it in a consistent way across
+# all platforms.
+if DEBUNDLED:
+    # Actually look inside of WHEEL_DIR to find .whl files and add them to the
+    # front of our sys.path.
+    sys.path[:] = glob.glob(os.path.join(WHEEL_DIR, "*.whl")) + sys.path
+
+    # Actually alias all of our vendored dependencies.
+    vendored("cachecontrol")
+    vendored("certifi")
+    vendored("distlib")
+    vendored("distro")
+    vendored("packaging")
+    vendored("packaging.version")
+    vendored("packaging.specifiers")
+    vendored("pkg_resources")
+    vendored("platformdirs")
+    vendored("progress")
+    vendored("pyproject_hooks")
+    vendored("requests")
+    vendored("requests.exceptions")
+    vendored("requests.packages")
+    vendored("requests.packages.urllib3")
+    vendored("requests.packages.urllib3._collections")
+    vendored("requests.packages.urllib3.connection")
+    vendored("requests.packages.urllib3.connectionpool")
+    vendored("requests.packages.urllib3.contrib")
+    vendored("requests.packages.urllib3.contrib.ntlmpool")
+    vendored("requests.packages.urllib3.contrib.pyopenssl")
+    vendored("requests.packages.urllib3.exceptions")
+    vendored("requests.packages.urllib3.fields")
+    vendored("requests.packages.urllib3.filepost")
+    vendored("requests.packages.urllib3.packages")
+    vendored("requests.packages.urllib3.packages.ordered_dict")
+    vendored("requests.packages.urllib3.packages.six")
+    vendored("requests.packages.urllib3.packages.ssl_match_hostname")
+    vendored("requests.packages.urllib3.packages.ssl_match_hostname."
+             "_implementation")
+    vendored("requests.packages.urllib3.poolmanager")
+    vendored("requests.packages.urllib3.request")
+    vendored("requests.packages.urllib3.response")
+    vendored("requests.packages.urllib3.util")
+    vendored("requests.packages.urllib3.util.connection")
+    vendored("requests.packages.urllib3.util.request")
+    vendored("requests.packages.urllib3.util.response")
+    vendored("requests.packages.urllib3.util.retry")
+    vendored("requests.packages.urllib3.util.ssl_")
+    vendored("requests.packages.urllib3.util.timeout")
+    vendored("requests.packages.urllib3.util.url")
+    vendored("resolvelib")
+    vendored("rich")
+    vendored("rich.console")
+    vendored("rich.highlighter")
+    vendored("rich.logging")
+    vendored("rich.markup")
+    vendored("rich.progress")
+    vendored("rich.segment")
+    vendored("rich.style")
+    vendored("rich.text")
+    vendored("rich.traceback")
+    if sys.version_info < (3, 11):
+        vendored("tomli")
+    vendored("truststore")
+    vendored("urllib3")
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_vendor/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 00000000..087d6c9b
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_vendor/__pycache__/__init__.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/__pycache__/typing_extensions.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_vendor/__pycache__/typing_extensions.cpython-312.pyc
new file mode 100644
index 00000000..a06f6906
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_vendor/__pycache__/typing_extensions.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/cachecontrol/__init__.py b/venv/lib/python3.12/site-packages/pip/_vendor/cachecontrol/__init__.py
new file mode 100644
index 00000000..b34b0fcb
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_vendor/cachecontrol/__init__.py
@@ -0,0 +1,28 @@
+# SPDX-FileCopyrightText: 2015 Eric Larson
+#
+# SPDX-License-Identifier: Apache-2.0
+
+"""CacheControl import Interface.
+
+Make it easy to import from cachecontrol without long namespaces.
+"""
+__author__ = "Eric Larson"
+__email__ = "eric@ionrock.org"
+__version__ = "0.14.0"
+
+from pip._vendor.cachecontrol.adapter import CacheControlAdapter
+from pip._vendor.cachecontrol.controller import CacheController
+from pip._vendor.cachecontrol.wrapper import CacheControl
+
+__all__ = [
+    "__author__",
+    "__email__",
+    "__version__",
+    "CacheControlAdapter",
+    "CacheController",
+    "CacheControl",
+]
+
+import logging
+
+logging.getLogger(__name__).addHandler(logging.NullHandler())
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/cachecontrol/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_vendor/cachecontrol/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 00000000..37f6b958
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_vendor/cachecontrol/__pycache__/__init__.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/cachecontrol/__pycache__/_cmd.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_vendor/cachecontrol/__pycache__/_cmd.cpython-312.pyc
new file mode 100644
index 00000000..39752b62
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_vendor/cachecontrol/__pycache__/_cmd.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/cachecontrol/__pycache__/adapter.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_vendor/cachecontrol/__pycache__/adapter.cpython-312.pyc
new file mode 100644
index 00000000..f869e978
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_vendor/cachecontrol/__pycache__/adapter.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/cachecontrol/__pycache__/cache.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_vendor/cachecontrol/__pycache__/cache.cpython-312.pyc
new file mode 100644
index 00000000..13d3fc63
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_vendor/cachecontrol/__pycache__/cache.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/cachecontrol/__pycache__/controller.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_vendor/cachecontrol/__pycache__/controller.cpython-312.pyc
new file mode 100644
index 00000000..c5f27830
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_vendor/cachecontrol/__pycache__/controller.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/cachecontrol/__pycache__/filewrapper.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_vendor/cachecontrol/__pycache__/filewrapper.cpython-312.pyc
new file mode 100644
index 00000000..0b345d39
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_vendor/cachecontrol/__pycache__/filewrapper.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/cachecontrol/__pycache__/heuristics.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_vendor/cachecontrol/__pycache__/heuristics.cpython-312.pyc
new file mode 100644
index 00000000..b0d91a72
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_vendor/cachecontrol/__pycache__/heuristics.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/cachecontrol/__pycache__/serialize.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_vendor/cachecontrol/__pycache__/serialize.cpython-312.pyc
new file mode 100644
index 00000000..eccaed3e
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_vendor/cachecontrol/__pycache__/serialize.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/cachecontrol/__pycache__/wrapper.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_vendor/cachecontrol/__pycache__/wrapper.cpython-312.pyc
new file mode 100644
index 00000000..6fbd0526
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_vendor/cachecontrol/__pycache__/wrapper.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/cachecontrol/_cmd.py b/venv/lib/python3.12/site-packages/pip/_vendor/cachecontrol/_cmd.py
new file mode 100644
index 00000000..2c84208a
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_vendor/cachecontrol/_cmd.py
@@ -0,0 +1,70 @@
+# SPDX-FileCopyrightText: 2015 Eric Larson
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import logging
+from argparse import ArgumentParser
+from typing import TYPE_CHECKING
+
+from pip._vendor import requests
+
+from pip._vendor.cachecontrol.adapter import CacheControlAdapter
+from pip._vendor.cachecontrol.cache import DictCache
+from pip._vendor.cachecontrol.controller import logger
+
+if TYPE_CHECKING:
+    from argparse import Namespace
+
+    from pip._vendor.cachecontrol.controller import CacheController
+
+
+def setup_logging() -> None:
+    logger.setLevel(logging.DEBUG)
+    handler = logging.StreamHandler()
+    logger.addHandler(handler)
+
+
+def get_session() -> requests.Session:
+    adapter = CacheControlAdapter(
+        DictCache(), cache_etags=True, serializer=None, heuristic=None
+    )
+    sess = requests.Session()
+    sess.mount("http://", adapter)
+    sess.mount("https://", adapter)
+
+    sess.cache_controller = adapter.controller  # type: ignore[attr-defined]
+    return sess
+
+
+def get_args() -> Namespace:
+    parser = ArgumentParser()
+    parser.add_argument("url", help="The URL to try and cache")
+    return parser.parse_args()
+
+
+def main() -> None:
+    args = get_args()
+    sess = get_session()
+
+    # Make a request to get a response
+    resp = sess.get(args.url)
+
+    # Turn on logging
+    setup_logging()
+
+    # try setting the cache
+    cache_controller: CacheController = (
+        sess.cache_controller  # type: ignore[attr-defined]
+    )
+    cache_controller.cache_response(resp.request, resp.raw)
+
+    # Now try to get it
+    if cache_controller.cached_request(resp.request):
+        print("Cached!")
+    else:
+        print("Not cached :(")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/cachecontrol/adapter.py b/venv/lib/python3.12/site-packages/pip/_vendor/cachecontrol/adapter.py
new file mode 100644
index 00000000..fbb4ecc8
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_vendor/cachecontrol/adapter.py
@@ -0,0 +1,161 @@
+# SPDX-FileCopyrightText: 2015 Eric Larson
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import functools
+import types
+import zlib
+from typing import TYPE_CHECKING, Any, Collection, Mapping
+
+from pip._vendor.requests.adapters import HTTPAdapter
+
+from pip._vendor.cachecontrol.cache import DictCache
+from pip._vendor.cachecontrol.controller import PERMANENT_REDIRECT_STATUSES, CacheController
+from pip._vendor.cachecontrol.filewrapper import CallbackFileWrapper
+
+if TYPE_CHECKING:
+    from pip._vendor.requests import PreparedRequest, Response
+    from pip._vendor.urllib3 import HTTPResponse
+
+    from pip._vendor.cachecontrol.cache import BaseCache
+    from pip._vendor.cachecontrol.heuristics import BaseHeuristic
+    from pip._vendor.cachecontrol.serialize import Serializer
+
+
+class CacheControlAdapter(HTTPAdapter):
+    invalidating_methods = {"PUT", "PATCH", "DELETE"}
+
+    def __init__(
+        self,
+        cache: BaseCache | None = None,
+        cache_etags: bool = True,
+        controller_class: type[CacheController] | None = None,
+        serializer: Serializer | None = None,
+        heuristic: BaseHeuristic | None = None,
+        cacheable_methods: Collection[str] | None = None,
+        *args: Any,
+        **kw: Any,
+    ) -> None:
+        super().__init__(*args, **kw)
+        self.cache = DictCache() if cache is None else cache
+        self.heuristic = heuristic
+        self.cacheable_methods = cacheable_methods or ("GET",)
+
+        controller_factory = controller_class or CacheController
+        self.controller = controller_factory(
+            self.cache, cache_etags=cache_etags, serializer=serializer
+        )
+
+    def send(
+        self,
+        request: PreparedRequest,
+        stream: bool = False,
+        timeout: None | float | tuple[float, float] | tuple[float, None] = None,
+        verify: bool | str = True,
+        cert: (None | bytes | str | tuple[bytes | str, bytes | str]) = None,
+        proxies: Mapping[str, str] | None = None,
+        cacheable_methods: Collection[str] | None = None,
+    ) -> Response:
+        """
+        Send a request. Use the request information to see if it
+        exists in the cache and cache the response if we need to and can.
+        """
+        cacheable = cacheable_methods or self.cacheable_methods
+        if request.method in cacheable:
+            try:
+                cached_response = self.controller.cached_request(request)
+            except zlib.error:
+                cached_response = None
+            if cached_response:
+                return self.build_response(request, cached_response, from_cache=True)
+
+            # check for etags and add headers if appropriate
+            request.headers.update(self.controller.conditional_headers(request))
+
+        resp = super().send(request, stream, timeout, verify, cert, proxies)
+
+        return resp
+
+    def build_response(
+        self,
+        request: PreparedRequest,
+        response: HTTPResponse,
+        from_cache: bool = False,
+        cacheable_methods: Collection[str] | None = None,
+    ) -> Response:
+        """
+        Build a response by making a request or using the cache.
+
+        This will end up calling send and returning a potentially
+        cached response
+        """
+        cacheable = cacheable_methods or self.cacheable_methods
+        if not from_cache and request.method in cacheable:
+            # Check for any heuristics that might update headers
+            # before trying to cache.
+            if self.heuristic:
+                response = self.heuristic.apply(response)
+
+            # apply any expiration heuristics
+            if response.status == 304:
+                # We must have sent an ETag request. This could mean
+                # that we've been expired already or that we simply
+                # have an etag. In either case, we want to try and
+                # update the cache if that is the case.
+                cached_response = self.controller.update_cached_response(
+                    request, response
+                )
+
+                if cached_response is not response:
+                    from_cache = True
+
+                # We are done with the server response, read a
+                # possible response body (compliant servers will
+                # not return one, but we cannot be 100% sure) and
+                # release the connection back to the pool.
+                response.read(decode_content=False)
+                response.release_conn()
+
+                response = cached_response
+
+            # We always cache the 301 responses
+            elif int(response.status) in PERMANENT_REDIRECT_STATUSES:
+                self.controller.cache_response(request, response)
+            else:
+                # Wrap the response file with a wrapper that will cache the
+                #   response when the stream has been consumed.
+                response._fp = CallbackFileWrapper(  # type: ignore[assignment]
+                    response._fp,  # type: ignore[arg-type]
+                    functools.partial(
+                        self.controller.cache_response, request, response
+                    ),
+                )
+                if response.chunked:
+                    super_update_chunk_length = response._update_chunk_length
+
+                    def _update_chunk_length(self: HTTPResponse) -> None:
+                        super_update_chunk_length()
+                        if self.chunk_left == 0:
+                            self._fp._close()  # type: ignore[union-attr]
+
+                    response._update_chunk_length = types.MethodType(  # type: ignore[method-assign]
+                        _update_chunk_length, response
+                    )
+
+        resp: Response = super().build_response(request, response)  # type: ignore[no-untyped-call]
+
+        # See if we should invalidate the cache.
+        if request.method in self.invalidating_methods and resp.ok:
+            assert request.url is not None
+            cache_url = self.controller.cache_url(request.url)
+            self.cache.delete(cache_url)
+
+        # Give the request a from_cache attr to let people use it
+        resp.from_cache = from_cache  # type: ignore[attr-defined]
+
+        return resp
+
+    def close(self) -> None:
+        self.cache.close()
+        super().close()  # type: ignore[no-untyped-call]
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/cachecontrol/cache.py b/venv/lib/python3.12/site-packages/pip/_vendor/cachecontrol/cache.py
new file mode 100644
index 00000000..3293b005
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_vendor/cachecontrol/cache.py
@@ -0,0 +1,74 @@
+# SPDX-FileCopyrightText: 2015 Eric Larson
+#
+# SPDX-License-Identifier: Apache-2.0
+
+"""
+The cache object API for implementing caches. The default is a thread
+safe in-memory dictionary.
+"""
+from __future__ import annotations
+
+from threading import Lock
+from typing import IO, TYPE_CHECKING, MutableMapping
+
+if TYPE_CHECKING:
+    from datetime import datetime
+
+
+class BaseCache:
+    def get(self, key: str) -> bytes | None:
+        raise NotImplementedError()
+
+    def set(
+        self, key: str, value: bytes, expires: int | datetime | None = None
+    ) -> None:
+        raise NotImplementedError()
+
+    def delete(self, key: str) -> None:
+        raise NotImplementedError()
+
+    def close(self) -> None:
+        pass
+
+
+class DictCache(BaseCache):
+    def __init__(self, init_dict: MutableMapping[str, bytes] | None = None) -> None:
+        self.lock = Lock()
+        self.data = init_dict or {}
+
+    def get(self, key: str) -> bytes | None:
+        return self.data.get(key, None)
+
+    def set(
+        self, key: str, value: bytes, expires: int | datetime | None = None
+    ) -> None:
+        with self.lock:
+            self.data.update({key: value})
+
+    def delete(self, key: str) -> None:
+        with self.lock:
+            if key in self.data:
+                self.data.pop(key)
+
+
+class SeparateBodyBaseCache(BaseCache):
+    """
+    In this variant, the body is not stored mixed in with the metadata, but is
+    passed in (as a bytes-like object) in a separate call to ``set_body()``.
+
+    That is, the expected interaction pattern is::
+
+        cache.set(key, serialized_metadata)
+        cache.set_body(key)
+
+    Similarly, the body should be loaded separately via ``get_body()``.
+    """
+
+    def set_body(self, key: str, body: bytes) -> None:
+        raise NotImplementedError()
+
+    def get_body(self, key: str) -> IO[bytes] | None:
+        """
+        Return the body as file-like object.
+        """
+        raise NotImplementedError()
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/cachecontrol/caches/__init__.py b/venv/lib/python3.12/site-packages/pip/_vendor/cachecontrol/caches/__init__.py
new file mode 100644
index 00000000..24ff469f
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_vendor/cachecontrol/caches/__init__.py
@@ -0,0 +1,8 @@
+# SPDX-FileCopyrightText: 2015 Eric Larson
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from pip._vendor.cachecontrol.caches.file_cache import FileCache, SeparateBodyFileCache
+from pip._vendor.cachecontrol.caches.redis_cache import RedisCache
+
+__all__ = ["FileCache", "SeparateBodyFileCache", "RedisCache"]
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/cachecontrol/caches/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_vendor/cachecontrol/caches/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 00000000..02ee5928
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_vendor/cachecontrol/caches/__pycache__/__init__.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/cachecontrol/caches/__pycache__/file_cache.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_vendor/cachecontrol/caches/__pycache__/file_cache.cpython-312.pyc
new file mode 100644
index 00000000..02afb7cc
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_vendor/cachecontrol/caches/__pycache__/file_cache.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/cachecontrol/caches/__pycache__/redis_cache.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_vendor/cachecontrol/caches/__pycache__/redis_cache.cpython-312.pyc
new file mode 100644
index 00000000..f478d8b2
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_vendor/cachecontrol/caches/__pycache__/redis_cache.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/cachecontrol/caches/file_cache.py b/venv/lib/python3.12/site-packages/pip/_vendor/cachecontrol/caches/file_cache.py
new file mode 100644
index 00000000..e6e3a579
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_vendor/cachecontrol/caches/file_cache.py
@@ -0,0 +1,182 @@
+# SPDX-FileCopyrightText: 2015 Eric Larson
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import hashlib
+import os
+from textwrap import dedent
+from typing import IO, TYPE_CHECKING, Union
+from pathlib import Path
+
+from pip._vendor.cachecontrol.cache import BaseCache, SeparateBodyBaseCache
+from pip._vendor.cachecontrol.controller import CacheController
+
+if TYPE_CHECKING:
+    from datetime import datetime
+
+    from filelock import BaseFileLock
+
+
+def _secure_open_write(filename: str, fmode: int) -> IO[bytes]:
+    # We only want to write to this file, so open it in write only mode
+    flags = os.O_WRONLY
+
+    # os.O_CREAT | os.O_EXCL will fail if the file already exists, so we only
+    #  will open *new* files.
+    # We specify this because we want to ensure that the mode we pass is the
+    # mode of the file.
+    flags |= os.O_CREAT | os.O_EXCL
+
+    # Do not follow symlinks to prevent someone from making a symlink that
+    # we follow and insecurely open a cache file.
+    if hasattr(os, "O_NOFOLLOW"):
+        flags |= os.O_NOFOLLOW
+
+    # On Windows we'll mark this file as binary
+    if hasattr(os, "O_BINARY"):
+        flags |= os.O_BINARY
+
+    # Before we open our file, we want to delete any existing file that is
+    # there
+    try:
+        os.remove(filename)
+    except OSError:
+        # The file must not exist already, so we can just skip ahead to opening
+        pass
+
+    # Open our file, the use of os.O_CREAT | os.O_EXCL will ensure that if a
+    # race condition happens between the os.remove and this line, that an
+    # error will be raised. Because we utilize a lockfile this should only
+    # happen if someone is attempting to attack us.
+    fd = os.open(filename, flags, fmode)
+    try:
+        return os.fdopen(fd, "wb")
+
+    except:
+        # An error occurred wrapping our FD in a file object
+        os.close(fd)
+        raise
+
+
+class _FileCacheMixin:
+    """Shared implementation for both FileCache variants."""
+
+    def __init__(
+        self,
+        directory: str | Path,
+        forever: bool = False,
+        filemode: int = 0o0600,
+        dirmode: int = 0o0700,
+        lock_class: type[BaseFileLock] | None = None,
+    ) -> None:
+        try:
+            if lock_class is None:
+                from filelock import FileLock
+
+                lock_class = FileLock
+        except ImportError:
+            notice = dedent(
+                """
+            NOTE: In order to use the FileCache you must have
+            filelock installed. You can install it via pip:
+              pip install cachecontrol[filecache]
+            """
+            )
+            raise ImportError(notice)
+
+        self.directory = directory
+        self.forever = forever
+        self.filemode = filemode
+        self.dirmode = dirmode
+        self.lock_class = lock_class
+
+    @staticmethod
+    def encode(x: str) -> str:
+        return hashlib.sha224(x.encode()).hexdigest()
+
+    def _fn(self, name: str) -> str:
+        # NOTE: This method should not change as some may depend on it.
+        #       See: https://github.com/ionrock/cachecontrol/issues/63
+        hashed = self.encode(name)
+        parts = list(hashed[:5]) + [hashed]
+        return os.path.join(self.directory, *parts)
+
+    def get(self, key: str) -> bytes | None:
+        name = self._fn(key)
+        try:
+            with open(name, "rb") as fh:
+                return fh.read()
+
+        except FileNotFoundError:
+            return None
+
+    def set(
+        self, key: str, value: bytes, expires: int | datetime | None = None
+    ) -> None:
+        name = self._fn(key)
+        self._write(name, value)
+
+    def _write(self, path: str, data: bytes) -> None:
+        """
+        Safely write the data to the given path.
+        """
+        # Make sure the directory exists
+        try:
+            os.makedirs(os.path.dirname(path), self.dirmode)
+        except OSError:
+            pass
+
+        with self.lock_class(path + ".lock"):
+            # Write our actual file
+            with _secure_open_write(path, self.filemode) as fh:
+                fh.write(data)
+
+    def _delete(self, key: str, suffix: str) -> None:
+        name = self._fn(key) + suffix
+        if not self.forever:
+            try:
+                os.remove(name)
+            except FileNotFoundError:
+                pass
+
+
+class FileCache(_FileCacheMixin, BaseCache):
+    """
+    Traditional FileCache: body is stored in memory, so not suitable for large
+    downloads.
+    """
+
+    def delete(self, key: str) -> None:
+        self._delete(key, "")
+
+
+class SeparateBodyFileCache(_FileCacheMixin, SeparateBodyBaseCache):
+    """
+    Memory-efficient FileCache: body is stored in a separate file, reducing
+    peak memory usage.
+    """
+
+    def get_body(self, key: str) -> IO[bytes] | None:
+        name = self._fn(key) + ".body"
+        try:
+            return open(name, "rb")
+        except FileNotFoundError:
+            return None
+
+    def set_body(self, key: str, body: bytes) -> None:
+        name = self._fn(key) + ".body"
+        self._write(name, body)
+
+    def delete(self, key: str) -> None:
+        self._delete(key, "")
+        self._delete(key, ".body")
+
+
+def url_to_file_path(url: str, filecache: FileCache) -> str:
+    """Return the file cache path based on the URL.
+
+    This does not ensure the file exists!
+    """
+    key = CacheController.cache_url(url)
+    return filecache._fn(key)
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/cachecontrol/caches/redis_cache.py b/venv/lib/python3.12/site-packages/pip/_vendor/cachecontrol/caches/redis_cache.py
new file mode 100644
index 00000000..f4f68c47
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_vendor/cachecontrol/caches/redis_cache.py
@@ -0,0 +1,48 @@
+# SPDX-FileCopyrightText: 2015 Eric Larson
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+
+from datetime import datetime, timezone
+from typing import TYPE_CHECKING
+
+from pip._vendor.cachecontrol.cache import BaseCache
+
+if TYPE_CHECKING:
+    from redis import Redis
+
+
+class RedisCache(BaseCache):
+    def __init__(self, conn: Redis[bytes]) -> None:
+        self.conn = conn
+
+    def get(self, key: str) -> bytes | None:
+        return self.conn.get(key)
+
+    def set(
+        self, key: str, value: bytes, expires: int | datetime | None = None
+    ) -> None:
+        if not expires:
+            self.conn.set(key, value)
+        elif isinstance(expires, datetime):
+            now_utc = datetime.now(timezone.utc)
+            if expires.tzinfo is None:
+                now_utc = now_utc.replace(tzinfo=None)
+            delta = expires - now_utc
+            self.conn.setex(key, int(delta.total_seconds()), value)
+        else:
+            self.conn.setex(key, expires, value)
+
+    def delete(self, key: str) -> None:
+        self.conn.delete(key)
+
+    def clear(self) -> None:
+        """Helper for clearing all the keys in a database. Use with
+        caution!"""
+        for key in self.conn.keys():
+            self.conn.delete(key)
+
+    def close(self) -> None:
+        """Redis uses connection pooling, no need to close the connection."""
+        pass
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/cachecontrol/controller.py b/venv/lib/python3.12/site-packages/pip/_vendor/cachecontrol/controller.py
new file mode 100644
index 00000000..d7dd86e5
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_vendor/cachecontrol/controller.py
@@ -0,0 +1,499 @@
+# SPDX-FileCopyrightText: 2015 Eric Larson
+#
+# SPDX-License-Identifier: Apache-2.0
+
+"""
+The httplib2 algorithms ported for use with requests.
+"""
+from __future__ import annotations
+
+import calendar
+import logging
+import re
+import time
+from email.utils import parsedate_tz
+from typing import TYPE_CHECKING, Collection, Mapping
+
+from pip._vendor.requests.structures import CaseInsensitiveDict
+
+from pip._vendor.cachecontrol.cache import DictCache, SeparateBodyBaseCache
+from pip._vendor.cachecontrol.serialize import Serializer
+
+if TYPE_CHECKING:
+    from typing import Literal
+
+    from pip._vendor.requests import PreparedRequest
+    from pip._vendor.urllib3 import HTTPResponse
+
+    from pip._vendor.cachecontrol.cache import BaseCache
+
+logger = logging.getLogger(__name__)
+
+URI = re.compile(r"^(([^:/?#]+):)?(//([^/?#]*))?([^?#]*)(\?([^#]*))?(#(.*))?")
+
+PERMANENT_REDIRECT_STATUSES = (301, 308)
+
+
+def parse_uri(uri: str) -> tuple[str, str, str, str, str]:
+    """Parses a URI using the regex given in Appendix B of RFC 3986.
+
+    (scheme, authority, path, query, fragment) = parse_uri(uri)
+    """
+    match = URI.match(uri)
+    assert match is not None
+    groups = match.groups()
+    return (groups[1], groups[3], groups[4], groups[6], groups[8])
+
+
+class CacheController:
+    """An interface to see if request should cached or not."""
+
+    def __init__(
+        self,
+        cache: BaseCache | None = None,
+        cache_etags: bool = True,
+        serializer: Serializer | None = None,
+        status_codes: Collection[int] | None = None,
+    ):
+        self.cache = DictCache() if cache is None else cache
+        self.cache_etags = cache_etags
+        self.serializer = serializer or Serializer()
+        self.cacheable_status_codes = status_codes or (200, 203, 300, 301, 308)
+
+    @classmethod
+    def _urlnorm(cls, uri: str) -> str:
+        """Normalize the URL to create a safe key for the cache"""
+        (scheme, authority, path, query, fragment) = parse_uri(uri)
+        if not scheme or not authority:
+            raise Exception("Only absolute URIs are allowed. uri = %s" % uri)
+
+        scheme = scheme.lower()
+        authority = authority.lower()
+
+        if not path:
+            path = "/"
+
+        # Could do syntax based normalization of the URI before
+        # computing the digest. See Section 6.2.2 of Std 66.
+        request_uri = query and "?".join([path, query]) or path
+        defrag_uri = scheme + "://" + authority + request_uri
+
+        return defrag_uri
+
+    @classmethod
+    def cache_url(cls, uri: str) -> str:
+        return cls._urlnorm(uri)
+
+    def parse_cache_control(self, headers: Mapping[str, str]) -> dict[str, int | None]:
+        known_directives = {
+            # https://tools.ietf.org/html/rfc7234#section-5.2
+            "max-age": (int, True),
+            "max-stale": (int, False),
+            "min-fresh": (int, True),
+            "no-cache": (None, False),
+            "no-store": (None, False),
+            "no-transform": (None, False),
+            "only-if-cached": (None, False),
+            "must-revalidate": (None, False),
+            "public": (None, False),
+            "private": (None, False),
+            "proxy-revalidate": (None, False),
+            "s-maxage": (int, True),
+        }
+
+        cc_headers = headers.get("cache-control", headers.get("Cache-Control", ""))
+
+        retval: dict[str, int | None] = {}
+
+        for cc_directive in cc_headers.split(","):
+            if not cc_directive.strip():
+                continue
+
+            parts = cc_directive.split("=", 1)
+            directive = parts[0].strip()
+
+            try:
+                typ, required = known_directives[directive]
+            except KeyError:
+                logger.debug("Ignoring unknown cache-control directive: %s", directive)
+                continue
+
+            if not typ or not required:
+                retval[directive] = None
+            if typ:
+                try:
+                    retval[directive] = typ(parts[1].strip())
+                except IndexError:
+                    if required:
+                        logger.debug(
+                            "Missing value for cache-control " "directive: %s",
+                            directive,
+                        )
+                except ValueError:
+                    logger.debug(
+                        "Invalid value for cache-control directive " "%s, must be %s",
+                        directive,
+                        typ.__name__,
+                    )
+
+        return retval
+
+    def _load_from_cache(self, request: PreparedRequest) -> HTTPResponse | None:
+        """
+        Load a cached response, or return None if it's not available.
+        """
+        # We do not support caching of partial content: so if the request contains a
+        # Range header then we don't want to load anything from the cache.
+        if "Range" in request.headers:
+            return None
+
+        cache_url = request.url
+        assert cache_url is not None
+        cache_data = self.cache.get(cache_url)
+        if cache_data is None:
+            logger.debug("No cache entry available")
+            return None
+
+        if isinstance(self.cache, SeparateBodyBaseCache):
+            body_file = self.cache.get_body(cache_url)
+        else:
+            body_file = None
+
+        result = self.serializer.loads(request, cache_data, body_file)
+        if result is None:
+            logger.warning("Cache entry deserialization failed, entry ignored")
+        return result
+
+    def cached_request(self, request: PreparedRequest) -> HTTPResponse | Literal[False]:
+        """
+        Return a cached response if it exists in the cache, otherwise
+        return False.
+        """
+        assert request.url is not None
+        cache_url = self.cache_url(request.url)
+        logger.debug('Looking up "%s" in the cache', cache_url)
+        cc = self.parse_cache_control(request.headers)
+
+        # Bail out if the request insists on fresh data
+        if "no-cache" in cc:
+            logger.debug('Request header has "no-cache", cache bypassed')
+            return False
+
+        if "max-age" in cc and cc["max-age"] == 0:
+            logger.debug('Request header has "max_age" as 0, cache bypassed')
+            return False
+
+        # Check whether we can load the response from the cache:
+        resp = self._load_from_cache(request)
+        if not resp:
+            return False
+
+        # If we have a cached permanent redirect, return it immediately. We
+        # don't need to test our response for other headers b/c it is
+        # intrinsically "cacheable" as it is Permanent.
+        #
+        # See:
+        #   https://tools.ietf.org/html/rfc7231#section-6.4.2
+        #
+        # Client can try to refresh the value by repeating the request
+        # with cache busting headers as usual (ie no-cache).
+        if int(resp.status) in PERMANENT_REDIRECT_STATUSES:
+            msg = (
+                "Returning cached permanent redirect response "
+                "(ignoring date and etag information)"
+            )
+            logger.debug(msg)
+            return resp
+
+        headers: CaseInsensitiveDict[str] = CaseInsensitiveDict(resp.headers)
+        if not headers or "date" not in headers:
+            if "etag" not in headers:
+                # Without date or etag, the cached response can never be used
+                # and should be deleted.
+                logger.debug("Purging cached response: no date or etag")
+                self.cache.delete(cache_url)
+            logger.debug("Ignoring cached response: no date")
+            return False
+
+        now = time.time()
+        time_tuple = parsedate_tz(headers["date"])
+        assert time_tuple is not None
+        date = calendar.timegm(time_tuple[:6])
+        current_age = max(0, now - date)
+        logger.debug("Current age based on date: %i", current_age)
+
+        # TODO: There is an assumption that the result will be a
+        #       urllib3 response object. This may not be best since we
+        #       could probably avoid instantiating or constructing the
+        #       response until we know we need it.
+        resp_cc = self.parse_cache_control(headers)
+
+        # determine freshness
+        freshness_lifetime = 0
+
+        # Check the max-age pragma in the cache control header
+        max_age = resp_cc.get("max-age")
+        if max_age is not None:
+            freshness_lifetime = max_age
+            logger.debug("Freshness lifetime from max-age: %i", freshness_lifetime)
+
+        # If there isn't a max-age, check for an expires header
+        elif "expires" in headers:
+            expires = parsedate_tz(headers["expires"])
+            if expires is not None:
+                expire_time = calendar.timegm(expires[:6]) - date
+                freshness_lifetime = max(0, expire_time)
+                logger.debug("Freshness lifetime from expires: %i", freshness_lifetime)
+
+        # Determine if we are setting freshness limit in the
+        # request. Note, this overrides what was in the response.
+        max_age = cc.get("max-age")
+        if max_age is not None:
+            freshness_lifetime = max_age
+            logger.debug(
+                "Freshness lifetime from request max-age: %i", freshness_lifetime
+            )
+
+        min_fresh = cc.get("min-fresh")
+        if min_fresh is not None:
+            # adjust our current age by our min fresh
+            current_age += min_fresh
+            logger.debug("Adjusted current age from min-fresh: %i", current_age)
+
+        # Return entry if it is fresh enough
+        if freshness_lifetime > current_age:
+            logger.debug('The response is "fresh", returning cached response')
+            logger.debug("%i > %i", freshness_lifetime, current_age)
+            return resp
+
+        # we're not fresh. If we don't have an Etag, clear it out
+        if "etag" not in headers:
+            logger.debug('The cached response is "stale" with no etag, purging')
+            self.cache.delete(cache_url)
+
+        # return the original handler
+        return False
+
+    def conditional_headers(self, request: PreparedRequest) -> dict[str, str]:
+        resp = self._load_from_cache(request)
+        new_headers = {}
+
+        if resp:
+            headers: CaseInsensitiveDict[str] = CaseInsensitiveDict(resp.headers)
+
+            if "etag" in headers:
+                new_headers["If-None-Match"] = headers["ETag"]
+
+            if "last-modified" in headers:
+                new_headers["If-Modified-Since"] = headers["Last-Modified"]
+
+        return new_headers
+
+    def _cache_set(
+        self,
+        cache_url: str,
+        request: PreparedRequest,
+        response: HTTPResponse,
+        body: bytes | None = None,
+        expires_time: int | None = None,
+    ) -> None:
+        """
+        Store the data in the cache.
+        """
+        if isinstance(self.cache, SeparateBodyBaseCache):
+            # We pass in the body separately; just put a placeholder empty
+            # string in the metadata.
+            self.cache.set(
+                cache_url,
+                self.serializer.dumps(request, response, b""),
+                expires=expires_time,
+            )
+            # body is None can happen when, for example, we're only updating
+            # headers, as is the case in update_cached_response().
+            if body is not None:
+                self.cache.set_body(cache_url, body)
+        else:
+            self.cache.set(
+                cache_url,
+                self.serializer.dumps(request, response, body),
+                expires=expires_time,
+            )
+
+    def cache_response(
+        self,
+        request: PreparedRequest,
+        response: HTTPResponse,
+        body: bytes | None = None,
+        status_codes: Collection[int] | None = None,
+    ) -> None:
+        """
+        Algorithm for caching requests.
+
+        This assumes a requests Response object.
+        """
+        # From httplib2: Don't cache 206's since we aren't going to
+        #                handle byte range requests
+        cacheable_status_codes = status_codes or self.cacheable_status_codes
+        if response.status not in cacheable_status_codes:
+            logger.debug(
+                "Status code %s not in %s", response.status, cacheable_status_codes
+            )
+            return
+
+        response_headers: CaseInsensitiveDict[str] = CaseInsensitiveDict(
+            response.headers
+        )
+
+        if "date" in response_headers:
+            time_tuple = parsedate_tz(response_headers["date"])
+            assert time_tuple is not None
+            date = calendar.timegm(time_tuple[:6])
+        else:
+            date = 0
+
+        # If we've been given a body, our response has a Content-Length, that
+        # Content-Length is valid then we can check to see if the body we've
+        # been given matches the expected size, and if it doesn't we'll just
+        # skip trying to cache it.
+        if (
+            body is not None
+            and "content-length" in response_headers
+            and response_headers["content-length"].isdigit()
+            and int(response_headers["content-length"]) != len(body)
+        ):
+            return
+
+        cc_req = self.parse_cache_control(request.headers)
+        cc = self.parse_cache_control(response_headers)
+
+        assert request.url is not None
+        cache_url = self.cache_url(request.url)
+        logger.debug('Updating cache with response from "%s"', cache_url)
+
+        # Delete it from the cache if we happen to have it stored there
+        no_store = False
+        if "no-store" in cc:
+            no_store = True
+            logger.debug('Response header has "no-store"')
+        if "no-store" in cc_req:
+            no_store = True
+            logger.debug('Request header has "no-store"')
+        if no_store and self.cache.get(cache_url):
+            logger.debug('Purging existing cache entry to honor "no-store"')
+            self.cache.delete(cache_url)
+        if no_store:
+            return
+
+        # https://tools.ietf.org/html/rfc7234#section-4.1:
+        # A Vary header field-value of "*" always fails to match.
+        # Storing such a response leads to a deserialization warning
+        # during cache lookup and is not allowed to ever be served,
+        # so storing it can be avoided.
+        if "*" in response_headers.get("vary", ""):
+            logger.debug('Response header has "Vary: *"')
+            return
+
+        # If we've been given an etag, then keep the response
+        if self.cache_etags and "etag" in response_headers:
+            expires_time = 0
+            if response_headers.get("expires"):
+                expires = parsedate_tz(response_headers["expires"])
+                if expires is not None:
+                    expires_time = calendar.timegm(expires[:6]) - date
+
+            expires_time = max(expires_time, 14 * 86400)
+
+            logger.debug(f"etag object cached for {expires_time} seconds")
+            logger.debug("Caching due to etag")
+            self._cache_set(cache_url, request, response, body, expires_time)
+
+        # Add to the cache any permanent redirects. We do this before looking
+        # that the Date headers.
+        elif int(response.status) in PERMANENT_REDIRECT_STATUSES:
+            logger.debug("Caching permanent redirect")
+            self._cache_set(cache_url, request, response, b"")
+
+        # Add to the cache if the response headers demand it. If there
+        # is no date header then we can't do anything about expiring
+        # the cache.
+        elif "date" in response_headers:
+            time_tuple = parsedate_tz(response_headers["date"])
+            assert time_tuple is not None
+            date = calendar.timegm(time_tuple[:6])
+            # cache when there is a max-age > 0
+            max_age = cc.get("max-age")
+            if max_age is not None and max_age > 0:
+                logger.debug("Caching b/c date exists and max-age > 0")
+                expires_time = max_age
+                self._cache_set(
+                    cache_url,
+                    request,
+                    response,
+                    body,
+                    expires_time,
+                )
+
+            # If the request can expire, it means we should cache it
+            # in the meantime.
+            elif "expires" in response_headers:
+                if response_headers["expires"]:
+                    expires = parsedate_tz(response_headers["expires"])
+                    if expires is not None:
+                        expires_time = calendar.timegm(expires[:6]) - date
+                    else:
+                        expires_time = None
+
+                    logger.debug(
+                        "Caching b/c of expires header. expires in {} seconds".format(
+                            expires_time
+                        )
+                    )
+                    self._cache_set(
+                        cache_url,
+                        request,
+                        response,
+                        body,
+                        expires_time,
+                    )
+
+    def update_cached_response(
+        self, request: PreparedRequest, response: HTTPResponse
+    ) -> HTTPResponse:
+        """On a 304 we will get a new set of headers that we want to
+        update our cached value with, assuming we have one.
+
+        This should only ever be called when we've sent an ETag and
+        gotten a 304 as the response.
+        """
+        assert request.url is not None
+        cache_url = self.cache_url(request.url)
+        cached_response = self._load_from_cache(request)
+
+        if not cached_response:
+            # we didn't have a cached response
+            return response
+
+        # Lets update our headers with the headers from the new request:
+        # http://tools.ietf.org/html/draft-ietf-httpbis-p4-conditional-26#section-4.1
+        #
+        # The server isn't supposed to send headers that would make
+        # the cached body invalid. But... just in case, we'll be sure
+        # to strip out ones we know that might be problmatic due to
+        # typical assumptions.
+        excluded_headers = ["content-length"]
+
+        cached_response.headers.update(
+            {
+                k: v
+                for k, v in response.headers.items()
+                if k.lower() not in excluded_headers
+            }
+        )
+
+        # we want a 200 b/c we have content via the cache
+        cached_response.status = 200
+
+        # update our cache
+        self._cache_set(cache_url, request, cached_response)
+
+        return cached_response
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/cachecontrol/filewrapper.py b/venv/lib/python3.12/site-packages/pip/_vendor/cachecontrol/filewrapper.py
new file mode 100644
index 00000000..25143902
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_vendor/cachecontrol/filewrapper.py
@@ -0,0 +1,119 @@
+# SPDX-FileCopyrightText: 2015 Eric Larson
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import mmap
+from tempfile import NamedTemporaryFile
+from typing import TYPE_CHECKING, Any, Callable
+
+if TYPE_CHECKING:
+    from http.client import HTTPResponse
+
+
+class CallbackFileWrapper:
+    """
+    Small wrapper around a fp object which will tee everything read into a
+    buffer, and when that file is closed it will execute a callback with the
+    contents of that buffer.
+
+    All attributes are proxied to the underlying file object.
+
+    This class uses members with a double underscore (__) leading prefix so as
+    not to accidentally shadow an attribute.
+
+    The data is stored in a temporary file until it is all available.  As long
+    as the temporary files directory is disk-based (sometimes it's a
+    memory-backed-``tmpfs`` on Linux), data will be unloaded to disk if memory
+    pressure is high.  For small files the disk usually won't be used at all,
+    it'll all be in the filesystem memory cache, so there should be no
+    performance impact.
+    """
+
+    def __init__(
+        self, fp: HTTPResponse, callback: Callable[[bytes], None] | None
+    ) -> None:
+        self.__buf = NamedTemporaryFile("rb+", delete=True)
+        self.__fp = fp
+        self.__callback = callback
+
+    def __getattr__(self, name: str) -> Any:
+        # The vaguaries of garbage collection means that self.__fp is
+        # not always set.  By using __getattribute__ and the private
+        # name[0] allows looking up the attribute value and raising an
+        # AttributeError when it doesn't exist. This stop thigns from
+        # infinitely recursing calls to getattr in the case where
+        # self.__fp hasn't been set.
+        #
+        # [0] https://docs.python.org/2/reference/expressions.html#atom-identifiers
+        fp = self.__getattribute__("_CallbackFileWrapper__fp")
+        return getattr(fp, name)
+
+    def __is_fp_closed(self) -> bool:
+        try:
+            return self.__fp.fp is None
+
+        except AttributeError:
+            pass
+
+        try:
+            closed: bool = self.__fp.closed
+            return closed
+
+        except AttributeError:
+            pass
+
+        # We just don't cache it then.
+        # TODO: Add some logging here...
+        return False
+
+    def _close(self) -> None:
+        if self.__callback:
+            if self.__buf.tell() == 0:
+                # Empty file:
+                result = b""
+            else:
+                # Return the data without actually loading it into memory,
+                # relying on Python's buffer API and mmap(). mmap() just gives
+                # a view directly into the filesystem's memory cache, so it
+                # doesn't result in duplicate memory use.
+                self.__buf.seek(0, 0)
+                result = memoryview(
+                    mmap.mmap(self.__buf.fileno(), 0, access=mmap.ACCESS_READ)
+                )
+            self.__callback(result)
+
+        # We assign this to None here, because otherwise we can get into
+        # really tricky problems where the CPython interpreter dead locks
+        # because the callback is holding a reference to something which
+        # has a __del__ method. Setting this to None breaks the cycle
+        # and allows the garbage collector to do it's thing normally.
+        self.__callback = None
+
+        # Closing the temporary file releases memory and frees disk space.
+        # Important when caching big files.
+        self.__buf.close()
+
+    def read(self, amt: int | None = None) -> bytes:
+        data: bytes = self.__fp.read(amt)
+        if data:
+            # We may be dealing with b'', a sign that things are over:
+            # it's passed e.g. after we've already closed self.__buf.
+            self.__buf.write(data)
+        if self.__is_fp_closed():
+            self._close()
+
+        return data
+
+    def _safe_read(self, amt: int) -> bytes:
+        data: bytes = self.__fp._safe_read(amt)  # type: ignore[attr-defined]
+        if amt == 2 and data == b"\r\n":
+            # urllib executes this read to toss the CRLF at the end
+            # of the chunk.
+            return data
+
+        self.__buf.write(data)
+        if self.__is_fp_closed():
+            self._close()
+
+        return data
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/cachecontrol/heuristics.py b/venv/lib/python3.12/site-packages/pip/_vendor/cachecontrol/heuristics.py
new file mode 100644
index 00000000..f6e5634e
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_vendor/cachecontrol/heuristics.py
@@ -0,0 +1,154 @@
+# SPDX-FileCopyrightText: 2015 Eric Larson
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import calendar
+import time
+from datetime import datetime, timedelta, timezone
+from email.utils import formatdate, parsedate, parsedate_tz
+from typing import TYPE_CHECKING, Any, Mapping
+
+if TYPE_CHECKING:
+    from pip._vendor.urllib3 import HTTPResponse
+
+TIME_FMT = "%a, %d %b %Y %H:%M:%S GMT"
+
+
+def expire_after(delta: timedelta, date: datetime | None = None) -> datetime:
+    date = date or datetime.now(timezone.utc)
+    return date + delta
+
+
+def datetime_to_header(dt: datetime) -> str:
+    return formatdate(calendar.timegm(dt.timetuple()))
+
+
+class BaseHeuristic:
+    def warning(self, response: HTTPResponse) -> str | None:
+        """
+        Return a valid 1xx warning header value describing the cache
+        adjustments.
+
+        The response is provided too allow warnings like 113
+        http://tools.ietf.org/html/rfc7234#section-5.5.4 where we need
+        to explicitly say response is over 24 hours old.
+        """
+        return '110 - "Response is Stale"'
+
+    def update_headers(self, response: HTTPResponse) -> dict[str, str]:
+        """Update the response headers with any new headers.
+
+        NOTE: This SHOULD always include some Warning header to
+              signify that the response was cached by the client, not
+              by way of the provided headers.
+        """
+        return {}
+
+    def apply(self, response: HTTPResponse) -> HTTPResponse:
+        updated_headers = self.update_headers(response)
+
+        if updated_headers:
+            response.headers.update(updated_headers)
+            warning_header_value = self.warning(response)
+            if warning_header_value is not None:
+                response.headers.update({"Warning": warning_header_value})
+
+        return response
+
+
+class OneDayCache(BaseHeuristic):
+    """
+    Cache the response by providing an expires 1 day in the
+    future.
+    """
+
+    def update_headers(self, response: HTTPResponse) -> dict[str, str]:
+        headers = {}
+
+        if "expires" not in response.headers:
+            date = parsedate(response.headers["date"])
+            expires = expire_after(timedelta(days=1), date=datetime(*date[:6], tzinfo=timezone.utc))  # type: ignore[index,misc]
+            headers["expires"] = datetime_to_header(expires)
+            headers["cache-control"] = "public"
+        return headers
+
+
+class ExpiresAfter(BaseHeuristic):
+    """
+    Cache **all** requests for a defined time period.
+    """
+
+    def __init__(self, **kw: Any) -> None:
+        self.delta = timedelta(**kw)
+
+    def update_headers(self, response: HTTPResponse) -> dict[str, str]:
+        expires = expire_after(self.delta)
+        return {"expires": datetime_to_header(expires), "cache-control": "public"}
+
+    def warning(self, response: HTTPResponse) -> str | None:
+        tmpl = "110 - Automatically cached for %s. Response might be stale"
+        return tmpl % self.delta
+
+
+class LastModified(BaseHeuristic):
+    """
+    If there is no Expires header already, fall back on Last-Modified
+    using the heuristic from
+    http://tools.ietf.org/html/rfc7234#section-4.2.2
+    to calculate a reasonable value.
+
+    Firefox also does something like this per
+    https://developer.mozilla.org/en-US/docs/Web/HTTP/Caching_FAQ
+    http://lxr.mozilla.org/mozilla-release/source/netwerk/protocol/http/nsHttpResponseHead.cpp#397
+    Unlike mozilla we limit this to 24-hr.
+    """
+
+    cacheable_by_default_statuses = {
+        200,
+        203,
+        204,
+        206,
+        300,
+        301,
+        404,
+        405,
+        410,
+        414,
+        501,
+    }
+
+    def update_headers(self, resp: HTTPResponse) -> dict[str, str]:
+        headers: Mapping[str, str] = resp.headers
+
+        if "expires" in headers:
+            return {}
+
+        if "cache-control" in headers and headers["cache-control"] != "public":
+            return {}
+
+        if resp.status not in self.cacheable_by_default_statuses:
+            return {}
+
+        if "date" not in headers or "last-modified" not in headers:
+            return {}
+
+        time_tuple = parsedate_tz(headers["date"])
+        assert time_tuple is not None
+        date = calendar.timegm(time_tuple[:6])
+        last_modified = parsedate(headers["last-modified"])
+        if last_modified is None:
+            return {}
+
+        now = time.time()
+        current_age = max(0, now - date)
+        delta = date - calendar.timegm(last_modified)
+        freshness_lifetime = max(0, min(delta / 10, 24 * 3600))
+        if freshness_lifetime <= current_age:
+            return {}
+
+        expires = date + freshness_lifetime
+        return {"expires": time.strftime(TIME_FMT, time.gmtime(expires))}
+
+    def warning(self, resp: HTTPResponse) -> str | None:
+        return None
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/cachecontrol/py.typed b/venv/lib/python3.12/site-packages/pip/_vendor/cachecontrol/py.typed
new file mode 100644
index 00000000..e69de29b
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/cachecontrol/serialize.py b/venv/lib/python3.12/site-packages/pip/_vendor/cachecontrol/serialize.py
new file mode 100644
index 00000000..a49487a1
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_vendor/cachecontrol/serialize.py
@@ -0,0 +1,146 @@
+# SPDX-FileCopyrightText: 2015 Eric Larson
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import io
+from typing import IO, TYPE_CHECKING, Any, Mapping, cast
+
+from pip._vendor import msgpack
+from pip._vendor.requests.structures import CaseInsensitiveDict
+from pip._vendor.urllib3 import HTTPResponse
+
+if TYPE_CHECKING:
+    from pip._vendor.requests import PreparedRequest
+
+
+class Serializer:
+    serde_version = "4"
+
+    def dumps(
+        self,
+        request: PreparedRequest,
+        response: HTTPResponse,
+        body: bytes | None = None,
+    ) -> bytes:
+        response_headers: CaseInsensitiveDict[str] = CaseInsensitiveDict(
+            response.headers
+        )
+
+        if body is None:
+            # When a body isn't passed in, we'll read the response. We
+            # also update the response with a new file handler to be
+            # sure it acts as though it was never read.
+            body = response.read(decode_content=False)
+            response._fp = io.BytesIO(body)  # type: ignore[assignment]
+            response.length_remaining = len(body)
+
+        data = {
+            "response": {
+                "body": body,  # Empty bytestring if body is stored separately
+                "headers": {str(k): str(v) for k, v in response.headers.items()},
+                "status": response.status,
+                "version": response.version,
+                "reason": str(response.reason),
+                "decode_content": response.decode_content,
+            }
+        }
+
+        # Construct our vary headers
+        data["vary"] = {}
+        if "vary" in response_headers:
+            varied_headers = response_headers["vary"].split(",")
+            for header in varied_headers:
+                header = str(header).strip()
+                header_value = request.headers.get(header, None)
+                if header_value is not None:
+                    header_value = str(header_value)
+                data["vary"][header] = header_value
+
+        return b",".join([f"cc={self.serde_version}".encode(), self.serialize(data)])
+
+    def serialize(self, data: dict[str, Any]) -> bytes:
+        return cast(bytes, msgpack.dumps(data, use_bin_type=True))
+
+    def loads(
+        self,
+        request: PreparedRequest,
+        data: bytes,
+        body_file: IO[bytes] | None = None,
+    ) -> HTTPResponse | None:
+        # Short circuit if we've been given an empty set of data
+        if not data:
+            return None
+
+        # Previous versions of this library supported other serialization
+        # formats, but these have all been removed.
+        if not data.startswith(f"cc={self.serde_version},".encode()):
+            return None
+
+        data = data[5:]
+        return self._loads_v4(request, data, body_file)
+
+    def prepare_response(
+        self,
+        request: PreparedRequest,
+        cached: Mapping[str, Any],
+        body_file: IO[bytes] | None = None,
+    ) -> HTTPResponse | None:
+        """Verify our vary headers match and construct a real urllib3
+        HTTPResponse object.
+        """
+        # Special case the '*' Vary value as it means we cannot actually
+        # determine if the cached response is suitable for this request.
+        # This case is also handled in the controller code when creating
+        # a cache entry, but is left here for backwards compatibility.
+        if "*" in cached.get("vary", {}):
+            return None
+
+        # Ensure that the Vary headers for the cached response match our
+        # request
+        for header, value in cached.get("vary", {}).items():
+            if request.headers.get(header, None) != value:
+                return None
+
+        body_raw = cached["response"].pop("body")
+
+        headers: CaseInsensitiveDict[str] = CaseInsensitiveDict(
+            data=cached["response"]["headers"]
+        )
+        if headers.get("transfer-encoding", "") == "chunked":
+            headers.pop("transfer-encoding")
+
+        cached["response"]["headers"] = headers
+
+        try:
+            body: IO[bytes]
+            if body_file is None:
+                body = io.BytesIO(body_raw)
+            else:
+                body = body_file
+        except TypeError:
+            # This can happen if cachecontrol serialized to v1 format (pickle)
+            # using Python 2. A Python 2 str(byte string) will be unpickled as
+            # a Python 3 str (unicode string), which will cause the above to
+            # fail with:
+            #
+            #     TypeError: 'str' does not support the buffer interface
+            body = io.BytesIO(body_raw.encode("utf8"))
+
+        # Discard any `strict` parameter serialized by older version of cachecontrol.
+        cached["response"].pop("strict", None)
+
+        return HTTPResponse(body=body, preload_content=False, **cached["response"])
+
+    def _loads_v4(
+        self,
+        request: PreparedRequest,
+        data: bytes,
+        body_file: IO[bytes] | None = None,
+    ) -> HTTPResponse | None:
+        try:
+            cached = msgpack.loads(data, raw=False)
+        except ValueError:
+            return None
+
+        return self.prepare_response(request, cached, body_file)
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/cachecontrol/wrapper.py b/venv/lib/python3.12/site-packages/pip/_vendor/cachecontrol/wrapper.py
new file mode 100644
index 00000000..f618bc36
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_vendor/cachecontrol/wrapper.py
@@ -0,0 +1,43 @@
+# SPDX-FileCopyrightText: 2015 Eric Larson
+#
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Collection
+
+from pip._vendor.cachecontrol.adapter import CacheControlAdapter
+from pip._vendor.cachecontrol.cache import DictCache
+
+if TYPE_CHECKING:
+    from pip._vendor import requests
+
+    from pip._vendor.cachecontrol.cache import BaseCache
+    from pip._vendor.cachecontrol.controller import CacheController
+    from pip._vendor.cachecontrol.heuristics import BaseHeuristic
+    from pip._vendor.cachecontrol.serialize import Serializer
+
+
+def CacheControl(
+    sess: requests.Session,
+    cache: BaseCache | None = None,
+    cache_etags: bool = True,
+    serializer: Serializer | None = None,
+    heuristic: BaseHeuristic | None = None,
+    controller_class: type[CacheController] | None = None,
+    adapter_class: type[CacheControlAdapter] | None = None,
+    cacheable_methods: Collection[str] | None = None,
+) -> requests.Session:
+    cache = DictCache() if cache is None else cache
+    adapter_class = adapter_class or CacheControlAdapter
+    adapter = adapter_class(
+        cache,
+        cache_etags=cache_etags,
+        serializer=serializer,
+        heuristic=heuristic,
+        controller_class=controller_class,
+        cacheable_methods=cacheable_methods,
+    )
+    sess.mount("http://", adapter)
+    sess.mount("https://", adapter)
+
+    return sess
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/certifi/__init__.py b/venv/lib/python3.12/site-packages/pip/_vendor/certifi/__init__.py
new file mode 100644
index 00000000..d321f1bc
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_vendor/certifi/__init__.py
@@ -0,0 +1,4 @@
+from .core import contents, where
+
+__all__ = ["contents", "where"]
+__version__ = "2024.07.04"
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/certifi/__main__.py b/venv/lib/python3.12/site-packages/pip/_vendor/certifi/__main__.py
new file mode 100644
index 00000000..00376349
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_vendor/certifi/__main__.py
@@ -0,0 +1,12 @@
+import argparse
+
+from pip._vendor.certifi import contents, where
+
+parser = argparse.ArgumentParser()
+parser.add_argument("-c", "--contents", action="store_true")
+args = parser.parse_args()
+
+if args.contents:
+    print(contents())
+else:
+    print(where())
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/certifi/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_vendor/certifi/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 00000000..fef438fb
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_vendor/certifi/__pycache__/__init__.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/certifi/__pycache__/__main__.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_vendor/certifi/__pycache__/__main__.cpython-312.pyc
new file mode 100644
index 00000000..8ae6c635
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_vendor/certifi/__pycache__/__main__.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/certifi/__pycache__/core.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_vendor/certifi/__pycache__/core.cpython-312.pyc
new file mode 100644
index 00000000..5f44fa8b
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_vendor/certifi/__pycache__/core.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/certifi/cacert.pem b/venv/lib/python3.12/site-packages/pip/_vendor/certifi/cacert.pem
new file mode 100644
index 00000000..a6581589
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_vendor/certifi/cacert.pem
@@ -0,0 +1,4798 @@
+
+# Issuer: CN=GlobalSign Root CA O=GlobalSign nv-sa OU=Root CA
+# Subject: CN=GlobalSign Root CA O=GlobalSign nv-sa OU=Root CA
+# Label: "GlobalSign Root CA"
+# Serial: 4835703278459707669005204
+# MD5 Fingerprint: 3e:45:52:15:09:51:92:e1:b7:5d:37:9f:b1:87:29:8a
+# SHA1 Fingerprint: b1:bc:96:8b:d4:f4:9d:62:2a:a8:9a:81:f2:15:01:52:a4:1d:82:9c
+# SHA256 Fingerprint: eb:d4:10:40:e4:bb:3e:c7:42:c9:e3:81:d3:1e:f2:a4:1a:48:b6:68:5c:96:e7:ce:f3:c1:df:6c:d4:33:1c:99
+-----BEGIN CERTIFICATE-----
+MIIDdTCCAl2gAwIBAgILBAAAAAABFUtaw5QwDQYJKoZIhvcNAQEFBQAwVzELMAkG
+A1UEBhMCQkUxGTAXBgNVBAoTEEdsb2JhbFNpZ24gbnYtc2ExEDAOBgNVBAsTB1Jv
+b3QgQ0ExGzAZBgNVBAMTEkdsb2JhbFNpZ24gUm9vdCBDQTAeFw05ODA5MDExMjAw
+MDBaFw0yODAxMjgxMjAwMDBaMFcxCzAJBgNVBAYTAkJFMRkwFwYDVQQKExBHbG9i
+YWxTaWduIG52LXNhMRAwDgYDVQQLEwdSb290IENBMRswGQYDVQQDExJHbG9iYWxT
+aWduIFJvb3QgQ0EwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDaDuaZ
+jc6j40+Kfvvxi4Mla+pIH/EqsLmVEQS98GPR4mdmzxzdzxtIK+6NiY6arymAZavp
+xy0Sy6scTHAHoT0KMM0VjU/43dSMUBUc71DuxC73/OlS8pF94G3VNTCOXkNz8kHp
+1Wrjsok6Vjk4bwY8iGlbKk3Fp1S4bInMm/k8yuX9ifUSPJJ4ltbcdG6TRGHRjcdG
+snUOhugZitVtbNV4FpWi6cgKOOvyJBNPc1STE4U6G7weNLWLBYy5d4ux2x8gkasJ
+U26Qzns3dLlwR5EiUWMWea6xrkEmCMgZK9FGqkjWZCrXgzT/LCrBbBlDSgeF59N8
+9iFo7+ryUp9/k5DPAgMBAAGjQjBAMA4GA1UdDwEB/wQEAwIBBjAPBgNVHRMBAf8E
+BTADAQH/MB0GA1UdDgQWBBRge2YaRQ2XyolQL30EzTSo//z9SzANBgkqhkiG9w0B
+AQUFAAOCAQEA1nPnfE920I2/7LqivjTFKDK1fPxsnCwrvQmeU79rXqoRSLblCKOz
+yj1hTdNGCbM+w6DjY1Ub8rrvrTnhQ7k4o+YviiY776BQVvnGCv04zcQLcFGUl5gE
+38NflNUVyRRBnMRddWQVDf9VMOyGj/8N7yy5Y0b2qvzfvGn9LhJIZJrglfCm7ymP
+AbEVtQwdpf5pLGkkeB6zpxxxYu7KyJesF12KwvhHhm4qxFYxldBniYUr+WymXUad
+DKqC5JlR3XC321Y9YeRq4VzW9v493kHMB65jUr9TU/Qr6cf9tveCX4XSQRjbgbME
+HMUfpIBvFSDJ3gyICh3WZlXi/EjJKSZp4A==
+-----END CERTIFICATE-----
+
+# Issuer: CN=Entrust.net Certification Authority (2048) O=Entrust.net OU=www.entrust.net/CPS_2048 incorp. by ref. (limits liab.)/(c) 1999 Entrust.net Limited
+# Subject: CN=Entrust.net Certification Authority (2048) O=Entrust.net OU=www.entrust.net/CPS_2048 incorp. by ref. (limits liab.)/(c) 1999 Entrust.net Limited
+# Label: "Entrust.net Premium 2048 Secure Server CA"
+# Serial: 946069240
+# MD5 Fingerprint: ee:29:31:bc:32:7e:9a:e6:e8:b5:f7:51:b4:34:71:90
+# SHA1 Fingerprint: 50:30:06:09:1d:97:d4:f5:ae:39:f7:cb:e7:92:7d:7d:65:2d:34:31
+# SHA256 Fingerprint: 6d:c4:71:72:e0:1c:bc:b0:bf:62:58:0d:89:5f:e2:b8:ac:9a:d4:f8:73:80:1e:0c:10:b9:c8:37:d2:1e:b1:77
+-----BEGIN CERTIFICATE-----
+MIIEKjCCAxKgAwIBAgIEOGPe+DANBgkqhkiG9w0BAQUFADCBtDEUMBIGA1UEChML
+RW50cnVzdC5uZXQxQDA+BgNVBAsUN3d3dy5lbnRydXN0Lm5ldC9DUFNfMjA0OCBp
+bmNvcnAuIGJ5IHJlZi4gKGxpbWl0cyBsaWFiLikxJTAjBgNVBAsTHChjKSAxOTk5
+IEVudHJ1c3QubmV0IExpbWl0ZWQxMzAxBgNVBAMTKkVudHJ1c3QubmV0IENlcnRp
+ZmljYXRpb24gQXV0aG9yaXR5ICgyMDQ4KTAeFw05OTEyMjQxNzUwNTFaFw0yOTA3
+MjQxNDE1MTJaMIG0MRQwEgYDVQQKEwtFbnRydXN0Lm5ldDFAMD4GA1UECxQ3d3d3
+LmVudHJ1c3QubmV0L0NQU18yMDQ4IGluY29ycC4gYnkgcmVmLiAobGltaXRzIGxp
+YWIuKTElMCMGA1UECxMcKGMpIDE5OTkgRW50cnVzdC5uZXQgTGltaXRlZDEzMDEG
+A1UEAxMqRW50cnVzdC5uZXQgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkgKDIwNDgp
+MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEArU1LqRKGsuqjIAcVFmQq
+K0vRvwtKTY7tgHalZ7d4QMBzQshowNtTK91euHaYNZOLGp18EzoOH1u3Hs/lJBQe
+sYGpjX24zGtLA/ECDNyrpUAkAH90lKGdCCmziAv1h3edVc3kw37XamSrhRSGlVuX
+MlBvPci6Zgzj/L24ScF2iUkZ/cCovYmjZy/Gn7xxGWC4LeksyZB2ZnuU4q941mVT
+XTzWnLLPKQP5L6RQstRIzgUyVYr9smRMDuSYB3Xbf9+5CFVghTAp+XtIpGmG4zU/
+HoZdenoVve8AjhUiVBcAkCaTvA5JaJG/+EfTnZVCwQ5N328mz8MYIWJmQ3DW1cAH
+4QIDAQABo0IwQDAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/BAUwAwEB/zAdBgNV
+HQ4EFgQUVeSB0RGAvtiJuQijMfmhJAkWuXAwDQYJKoZIhvcNAQEFBQADggEBADub
+j1abMOdTmXx6eadNl9cZlZD7Bh/KM3xGY4+WZiT6QBshJ8rmcnPyT/4xmf3IDExo
+U8aAghOY+rat2l098c5u9hURlIIM7j+VrxGrD9cv3h8Dj1csHsm7mhpElesYT6Yf
+zX1XEC+bBAlahLVu2B064dae0Wx5XnkcFMXj0EyTO2U87d89vqbllRrDtRnDvV5b
+u/8j72gZyxKTJ1wDLW8w0B62GqzeWvfRqqgnpv55gcR5mTNXuhKwqeBCbJPKVt7+
+bYQLCIt+jerXmCHG8+c8eS9enNFMFY3h7CI3zJpDC5fcgJCNs2ebb0gIFVbPv/Er
+fF6adulZkMV8gzURZVE=
+-----END CERTIFICATE-----
+
+# Issuer: CN=Baltimore CyberTrust Root O=Baltimore OU=CyberTrust
+# Subject: CN=Baltimore CyberTrust Root O=Baltimore OU=CyberTrust
+# Label: "Baltimore CyberTrust Root"
+# Serial: 33554617
+# MD5 Fingerprint: ac:b6:94:a5:9c:17:e0:d7:91:52:9b:b1:97:06:a6:e4
+# SHA1 Fingerprint: d4:de:20:d0:5e:66:fc:53:fe:1a:50:88:2c:78:db:28:52:ca:e4:74
+# SHA256 Fingerprint: 16:af:57:a9:f6:76:b0:ab:12:60:95:aa:5e:ba:de:f2:2a:b3:11:19:d6:44:ac:95:cd:4b:93:db:f3:f2:6a:eb
+-----BEGIN CERTIFICATE-----
+MIIDdzCCAl+gAwIBAgIEAgAAuTANBgkqhkiG9w0BAQUFADBaMQswCQYDVQQGEwJJ
+RTESMBAGA1UEChMJQmFsdGltb3JlMRMwEQYDVQQLEwpDeWJlclRydXN0MSIwIAYD
+VQQDExlCYWx0aW1vcmUgQ3liZXJUcnVzdCBSb290MB4XDTAwMDUxMjE4NDYwMFoX
+DTI1MDUxMjIzNTkwMFowWjELMAkGA1UEBhMCSUUxEjAQBgNVBAoTCUJhbHRpbW9y
+ZTETMBEGA1UECxMKQ3liZXJUcnVzdDEiMCAGA1UEAxMZQmFsdGltb3JlIEN5YmVy
+VHJ1c3QgUm9vdDCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAKMEuyKr
+mD1X6CZymrV51Cni4eiVgLGw41uOKymaZN+hXe2wCQVt2yguzmKiYv60iNoS6zjr
+IZ3AQSsBUnuId9Mcj8e6uYi1agnnc+gRQKfRzMpijS3ljwumUNKoUMMo6vWrJYeK
+mpYcqWe4PwzV9/lSEy/CG9VwcPCPwBLKBsua4dnKM3p31vjsufFoREJIE9LAwqSu
+XmD+tqYF/LTdB1kC1FkYmGP1pWPgkAx9XbIGevOF6uvUA65ehD5f/xXtabz5OTZy
+dc93Uk3zyZAsuT3lySNTPx8kmCFcB5kpvcY67Oduhjprl3RjM71oGDHweI12v/ye
+jl0qhqdNkNwnGjkCAwEAAaNFMEMwHQYDVR0OBBYEFOWdWTCCR1jMrPoIVDaGezq1
+BE3wMBIGA1UdEwEB/wQIMAYBAf8CAQMwDgYDVR0PAQH/BAQDAgEGMA0GCSqGSIb3
+DQEBBQUAA4IBAQCFDF2O5G9RaEIFoN27TyclhAO992T9Ldcw46QQF+vaKSm2eT92
+9hkTI7gQCvlYpNRhcL0EYWoSihfVCr3FvDB81ukMJY2GQE/szKN+OMY3EU/t3Wgx
+jkzSswF07r51XgdIGn9w/xZchMB5hbgF/X++ZRGjD8ACtPhSNzkE1akxehi/oCr0
+Epn3o0WC4zxe9Z2etciefC7IpJ5OCBRLbf1wbWsaY71k5h+3zvDyny67G7fyUIhz
+ksLi4xaNmjICq44Y3ekQEe5+NauQrz4wlHrQMz2nZQ/1/I6eYs9HRCwBXbsdtTLS
+R9I4LtD+gdwyah617jzV/OeBHRnDJELqYzmp
+-----END CERTIFICATE-----
+
+# Issuer: CN=Entrust Root Certification Authority O=Entrust, Inc. OU=www.entrust.net/CPS is incorporated by reference/(c) 2006 Entrust, Inc.
+# Subject: CN=Entrust Root Certification Authority O=Entrust, Inc. OU=www.entrust.net/CPS is incorporated by reference/(c) 2006 Entrust, Inc.
+# Label: "Entrust Root Certification Authority"
+# Serial: 1164660820
+# MD5 Fingerprint: d6:a5:c3:ed:5d:dd:3e:00:c1:3d:87:92:1f:1d:3f:e4
+# SHA1 Fingerprint: b3:1e:b1:b7:40:e3:6c:84:02:da:dc:37:d4:4d:f5:d4:67:49:52:f9
+# SHA256 Fingerprint: 73:c1:76:43:4f:1b:c6:d5:ad:f4:5b:0e:76:e7:27:28:7c:8d:e5:76:16:c1:e6:e6:14:1a:2b:2c:bc:7d:8e:4c
+-----BEGIN CERTIFICATE-----
+MIIEkTCCA3mgAwIBAgIERWtQVDANBgkqhkiG9w0BAQUFADCBsDELMAkGA1UEBhMC
+VVMxFjAUBgNVBAoTDUVudHJ1c3QsIEluYy4xOTA3BgNVBAsTMHd3dy5lbnRydXN0
+Lm5ldC9DUFMgaXMgaW5jb3Jwb3JhdGVkIGJ5IHJlZmVyZW5jZTEfMB0GA1UECxMW
+KGMpIDIwMDYgRW50cnVzdCwgSW5jLjEtMCsGA1UEAxMkRW50cnVzdCBSb290IENl
+cnRpZmljYXRpb24gQXV0aG9yaXR5MB4XDTA2MTEyNzIwMjM0MloXDTI2MTEyNzIw
+NTM0MlowgbAxCzAJBgNVBAYTAlVTMRYwFAYDVQQKEw1FbnRydXN0LCBJbmMuMTkw
+NwYDVQQLEzB3d3cuZW50cnVzdC5uZXQvQ1BTIGlzIGluY29ycG9yYXRlZCBieSBy
+ZWZlcmVuY2UxHzAdBgNVBAsTFihjKSAyMDA2IEVudHJ1c3QsIEluYy4xLTArBgNV
+BAMTJEVudHJ1c3QgUm9vdCBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eTCCASIwDQYJ
+KoZIhvcNAQEBBQADggEPADCCAQoCggEBALaVtkNC+sZtKm9I35RMOVcF7sN5EUFo
+Nu3s/poBj6E4KPz3EEZmLk0eGrEaTsbRwJWIsMn/MYszA9u3g3s+IIRe7bJWKKf4
+4LlAcTfFy0cOlypowCKVYhXbR9n10Cv/gkvJrT7eTNuQgFA/CYqEAOwwCj0Yzfv9
+KlmaI5UXLEWeH25DeW0MXJj+SKfFI0dcXv1u5x609mhF0YaDW6KKjbHjKYD+JXGI
+rb68j6xSlkuqUY3kEzEZ6E5Nn9uss2rVvDlUccp6en+Q3X0dgNmBu1kmwhH+5pPi
+94DkZfs0Nw4pgHBNrziGLp5/V6+eF67rHMsoIV+2HNjnogQi+dPa2MsCAwEAAaOB
+sDCBrTAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/BAUwAwEB/zArBgNVHRAEJDAi
+gA8yMDA2MTEyNzIwMjM0MlqBDzIwMjYxMTI3MjA1MzQyWjAfBgNVHSMEGDAWgBRo
+kORnpKZTgMeGZqTx90tD+4S9bTAdBgNVHQ4EFgQUaJDkZ6SmU4DHhmak8fdLQ/uE
+vW0wHQYJKoZIhvZ9B0EABBAwDhsIVjcuMTo0LjADAgSQMA0GCSqGSIb3DQEBBQUA
+A4IBAQCT1DCw1wMgKtD5Y+iRDAUgqV8ZyntyTtSx29CW+1RaGSwMCPeyvIWonX9t
+O1KzKtvn1ISMY/YPyyYBkVBs9F8U4pN0wBOeMDpQ47RgxRzwIkSNcUesyBrJ6Zua
+AGAT/3B+XxFNSRuzFVJ7yVTav52Vr2ua2J7p8eRDjeIRRDq/r72DQnNSi6q7pynP
+9WQcCk3RvKqsnyrQ/39/2n3qse0wJcGE2jTSW3iDVuycNsMm4hH2Z0kdkquM++v/
+eu6FSqdQgPCnXEqULl8FmTxSQeDNtGPPAUO6nIPcj2A781q0tHuu2guQOHXvgR1m
+0vdXcDazv/wor3ElhVsT/h5/WrQ8
+-----END CERTIFICATE-----
+
+# Issuer: CN=AAA Certificate Services O=Comodo CA Limited
+# Subject: CN=AAA Certificate Services O=Comodo CA Limited
+# Label: "Comodo AAA Services root"
+# Serial: 1
+# MD5 Fingerprint: 49:79:04:b0:eb:87:19:ac:47:b0:bc:11:51:9b:74:d0
+# SHA1 Fingerprint: d1:eb:23:a4:6d:17:d6:8f:d9:25:64:c2:f1:f1:60:17:64:d8:e3:49
+# SHA256 Fingerprint: d7:a7:a0:fb:5d:7e:27:31:d7:71:e9:48:4e:bc:de:f7:1d:5f:0c:3e:0a:29:48:78:2b:c8:3e:e0:ea:69:9e:f4
+-----BEGIN CERTIFICATE-----
+MIIEMjCCAxqgAwIBAgIBATANBgkqhkiG9w0BAQUFADB7MQswCQYDVQQGEwJHQjEb
+MBkGA1UECAwSR3JlYXRlciBNYW5jaGVzdGVyMRAwDgYDVQQHDAdTYWxmb3JkMRow
+GAYDVQQKDBFDb21vZG8gQ0EgTGltaXRlZDEhMB8GA1UEAwwYQUFBIENlcnRpZmlj
+YXRlIFNlcnZpY2VzMB4XDTA0MDEwMTAwMDAwMFoXDTI4MTIzMTIzNTk1OVowezEL
+MAkGA1UEBhMCR0IxGzAZBgNVBAgMEkdyZWF0ZXIgTWFuY2hlc3RlcjEQMA4GA1UE
+BwwHU2FsZm9yZDEaMBgGA1UECgwRQ29tb2RvIENBIExpbWl0ZWQxITAfBgNVBAMM
+GEFBQSBDZXJ0aWZpY2F0ZSBTZXJ2aWNlczCCASIwDQYJKoZIhvcNAQEBBQADggEP
+ADCCAQoCggEBAL5AnfRu4ep2hxxNRUSOvkbIgwadwSr+GB+O5AL686tdUIoWMQua
+BtDFcCLNSS1UY8y2bmhGC1Pqy0wkwLxyTurxFa70VJoSCsN6sjNg4tqJVfMiWPPe
+3M/vg4aijJRPn2jymJBGhCfHdr/jzDUsi14HZGWCwEiwqJH5YZ92IFCokcdmtet4
+YgNW8IoaE+oxox6gmf049vYnMlhvB/VruPsUK6+3qszWY19zjNoFmag4qMsXeDZR
+rOme9Hg6jc8P2ULimAyrL58OAd7vn5lJ8S3frHRNG5i1R8XlKdH5kBjHYpy+g8cm
+ez6KJcfA3Z3mNWgQIJ2P2N7Sw4ScDV7oL8kCAwEAAaOBwDCBvTAdBgNVHQ4EFgQU
+oBEKIz6W8Qfs4q8p74Klf9AwpLQwDgYDVR0PAQH/BAQDAgEGMA8GA1UdEwEB/wQF
+MAMBAf8wewYDVR0fBHQwcjA4oDagNIYyaHR0cDovL2NybC5jb21vZG9jYS5jb20v
+QUFBQ2VydGlmaWNhdGVTZXJ2aWNlcy5jcmwwNqA0oDKGMGh0dHA6Ly9jcmwuY29t
+b2RvLm5ldC9BQUFDZXJ0aWZpY2F0ZVNlcnZpY2VzLmNybDANBgkqhkiG9w0BAQUF
+AAOCAQEACFb8AvCb6P+k+tZ7xkSAzk/ExfYAWMymtrwUSWgEdujm7l3sAg9g1o1Q
+GE8mTgHj5rCl7r+8dFRBv/38ErjHT1r0iWAFf2C3BUrz9vHCv8S5dIa2LX1rzNLz
+Rt0vxuBqw8M0Ayx9lt1awg6nCpnBBYurDC/zXDrPbDdVCYfeU0BsWO/8tqtlbgT2
+G9w84FoVxp7Z8VlIMCFlA2zs6SFz7JsDoeA3raAVGI/6ugLOpyypEBMs1OUIJqsi
+l2D4kF501KKaU73yqWjgom7C12yxow+ev+to51byrvLjKzg6CYG1a4XXvi3tPxq3
+smPi9WIsgtRqAEFQ8TmDn5XpNpaYbg==
+-----END CERTIFICATE-----
+
+# Issuer: CN=QuoVadis Root CA 2 O=QuoVadis Limited
+# Subject: CN=QuoVadis Root CA 2 O=QuoVadis Limited
+# Label: "QuoVadis Root CA 2"
+# Serial: 1289
+# MD5 Fingerprint: 5e:39:7b:dd:f8:ba:ec:82:e9:ac:62:ba:0c:54:00:2b
+# SHA1 Fingerprint: ca:3a:fb:cf:12:40:36:4b:44:b2:16:20:88:80:48:39:19:93:7c:f7
+# SHA256 Fingerprint: 85:a0:dd:7d:d7:20:ad:b7:ff:05:f8:3d:54:2b:20:9d:c7:ff:45:28:f7:d6:77:b1:83:89:fe:a5:e5:c4:9e:86
+-----BEGIN CERTIFICATE-----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+-----END CERTIFICATE-----
+
+# Issuer: CN=QuoVadis Root CA 3 O=QuoVadis Limited
+# Subject: CN=QuoVadis Root CA 3 O=QuoVadis Limited
+# Label: "QuoVadis Root CA 3"
+# Serial: 1478
+# MD5 Fingerprint: 31:85:3c:62:94:97:63:b9:aa:fd:89:4e:af:6f:e0:cf
+# SHA1 Fingerprint: 1f:49:14:f7:d8:74:95:1d:dd:ae:02:c0:be:fd:3a:2d:82:75:51:85
+# SHA256 Fingerprint: 18:f1:fc:7f:20:5d:f8:ad:dd:eb:7f:e0:07:dd:57:e3:af:37:5a:9c:4d:8d:73:54:6b:f4:f1:fe:d1:e1:8d:35
+-----BEGIN CERTIFICATE-----
+MIIGnTCCBIWgAwIBAgICBcYwDQYJKoZIhvcNAQEFBQAwRTELMAkGA1UEBhMCQk0x
+GTAXBgNVBAoTEFF1b1ZhZGlzIExpbWl0ZWQxGzAZBgNVBAMTElF1b1ZhZGlzIFJv
+b3QgQ0EgMzAeFw0wNjExMjQxOTExMjNaFw0zMTExMjQxOTA2NDRaMEUxCzAJBgNV
+BAYTAkJNMRkwFwYDVQQKExBRdW9WYWRpcyBMaW1pdGVkMRswGQYDVQQDExJRdW9W
+YWRpcyBSb290IENBIDMwggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQDM
+V0IWVJzmmNPTTe7+7cefQzlKZbPoFog02w1ZkXTPkrgEQK0CSzGrvI2RaNggDhoB
+4hp7Thdd4oq3P5kazethq8Jlph+3t723j/z9cI8LoGe+AaJZz3HmDyl2/7FWeUUr
+H556VOijKTVopAFPD6QuN+8bv+OPEKhyq1hX51SGyMnzW9os2l2ObjyjPtr7guXd
+8lyyBTNvijbO0BNO/79KDDRMpsMhvVAEVeuxu537RR5kFd5VAYwCdrXLoT9Cabwv
+vWhDFlaJKjdhkf2mrk7AyxRllDdLkgbvBNDInIjbC3uBr7E9KsRlOni27tyAsdLT
+mZw67mtaa7ONt9XOnMK+pUsvFrGeaDsGb659n/je7Mwpp5ijJUMv7/FfJuGITfhe
+btfZFG4ZM2mnO4SJk8RTVROhUXhA+LjJou57ulJCg54U7QVSWllWp5f8nT8KKdjc
+T5EOE7zelaTfi5m+rJsziO+1ga8bxiJTyPbH7pcUsMV8eFLI8M5ud2CEpukqdiDt
+WAEXMJPpGovgc2PZapKUSU60rUqFxKMiMPwJ7Wgic6aIDFUhWMXhOp8q3crhkODZ
+c6tsgLjoC2SToJyMGf+z0gzskSaHirOi4XCPLArlzW1oUevaPwV/izLmE1xr/l9A
+4iLItLRkT9a6fUg+qGkM17uGcclzuD87nSVL2v9A6wIDAQABo4IBlTCCAZEwDwYD
+VR0TAQH/BAUwAwEB/zCB4QYDVR0gBIHZMIHWMIHTBgkrBgEEAb5YAAMwgcUwgZMG
+CCsGAQUFBwICMIGGGoGDQW55IHVzZSBvZiB0aGlzIENlcnRpZmljYXRlIGNvbnN0
+aXR1dGVzIGFjY2VwdGFuY2Ugb2YgdGhlIFF1b1ZhZGlzIFJvb3QgQ0EgMyBDZXJ0
+aWZpY2F0ZSBQb2xpY3kgLyBDZXJ0aWZpY2F0aW9uIFByYWN0aWNlIFN0YXRlbWVu
+dC4wLQYIKwYBBQUHAgEWIWh0dHA6Ly93d3cucXVvdmFkaXNnbG9iYWwuY29tL2Nw
+czALBgNVHQ8EBAMCAQYwHQYDVR0OBBYEFPLAE+CCQz777i9nMpY1XNu4ywLQMG4G
+A1UdIwRnMGWAFPLAE+CCQz777i9nMpY1XNu4ywLQoUmkRzBFMQswCQYDVQQGEwJC
+TTEZMBcGA1UEChMQUXVvVmFkaXMgTGltaXRlZDEbMBkGA1UEAxMSUXVvVmFkaXMg
+Um9vdCBDQSAzggIFxjANBgkqhkiG9w0BAQUFAAOCAgEAT62gLEz6wPJv92ZVqyM0
+7ucp2sNbtrCD2dDQ4iH782CnO11gUyeim/YIIirnv6By5ZwkajGxkHon24QRiSem
+d1o417+shvzuXYO8BsbRd2sPbSQvS3pspweWyuOEn62Iix2rFo1bZhfZFvSLgNLd
++LJ2w/w4E6oM3kJpK27zPOuAJ9v1pkQNn1pVWQvVDVJIxa6f8i+AxeoyUDUSly7B
+4f/xI4hROJ/yZlZ25w9Rl6VSDE1JUZU2Pb+iSwwQHYaZTKrzchGT5Or2m9qoXadN
+t54CrnMAyNojA+j56hl0YgCUyyIgvpSnWbWCar6ZeXqp8kokUvd0/bpO5qgdAm6x
+DYBEwa7TIzdfu4V8K5Iu6H6li92Z4b8nby1dqnuH/grdS/yO9SbkbnBCbjPsMZ57
+k8HkyWkaPcBrTiJt7qtYTcbQQcEr6k8Sh17rRdhs9ZgC06DYVYoGmRmioHfRMJ6s
+zHXug/WwYjnPbFfiTNKRCw51KBuav/0aQ/HKd/s7j2G4aSgWQgRecCocIdiP4b0j
+Wy10QJLZYxkNc91pvGJHvOB0K7Lrfb5BG7XARsWhIstfTsEokt4YutUqKLsRixeT
+mJlglFwjz1onl14LBQaTNx47aTbrqZ5hHY8y2o4M1nQ+ewkk2gF3R8Q7zTSMmfXK
+4SVhM7JZG+Ju1zdXtg2pEto=
+-----END CERTIFICATE-----
+
+# Issuer: CN=XRamp Global Certification Authority O=XRamp Security Services Inc OU=www.xrampsecurity.com
+# Subject: CN=XRamp Global Certification Authority O=XRamp Security Services Inc OU=www.xrampsecurity.com
+# Label: "XRamp Global CA Root"
+# Serial: 107108908803651509692980124233745014957
+# MD5 Fingerprint: a1:0b:44:b3:ca:10:d8:00:6e:9d:0f:d8:0f:92:0a:d1
+# SHA1 Fingerprint: b8:01:86:d1:eb:9c:86:a5:41:04:cf:30:54:f3:4c:52:b7:e5:58:c6
+# SHA256 Fingerprint: ce:cd:dc:90:50:99:d8:da:df:c5:b1:d2:09:b7:37:cb:e2:c1:8c:fb:2c:10:c0:ff:0b:cf:0d:32:86:fc:1a:a2
+-----BEGIN CERTIFICATE-----
+MIIEMDCCAxigAwIBAgIQUJRs7Bjq1ZxN1ZfvdY+grTANBgkqhkiG9w0BAQUFADCB
+gjELMAkGA1UEBhMCVVMxHjAcBgNVBAsTFXd3dy54cmFtcHNlY3VyaXR5LmNvbTEk
+MCIGA1UEChMbWFJhbXAgU2VjdXJpdHkgU2VydmljZXMgSW5jMS0wKwYDVQQDEyRY
+UmFtcCBHbG9iYWwgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkwHhcNMDQxMTAxMTcx
+NDA0WhcNMzUwMTAxMDUzNzE5WjCBgjELMAkGA1UEBhMCVVMxHjAcBgNVBAsTFXd3
+dy54cmFtcHNlY3VyaXR5LmNvbTEkMCIGA1UEChMbWFJhbXAgU2VjdXJpdHkgU2Vy
+dmljZXMgSW5jMS0wKwYDVQQDEyRYUmFtcCBHbG9iYWwgQ2VydGlmaWNhdGlvbiBB
+dXRob3JpdHkwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCYJB69FbS6
+38eMpSe2OAtp87ZOqCwuIR1cRN8hXX4jdP5efrRKt6atH67gBhbim1vZZ3RrXYCP
+KZ2GG9mcDZhtdhAoWORlsH9KmHmf4MMxfoArtYzAQDsRhtDLooY2YKTVMIJt2W7Q
+DxIEM5dfT2Fa8OT5kavnHTu86M/0ay00fOJIYRyO82FEzG+gSqmUsE3a56k0enI4
+qEHMPJQRfevIpoy3hsvKMzvZPTeL+3o+hiznc9cKV6xkmxnr9A8ECIqsAxcZZPRa
+JSKNNCyy9mgdEm3Tih4U2sSPpuIjhdV6Db1q4Ons7Be7QhtnqiXtRYMh/MHJfNVi
+PvryxS3T/dRlAgMBAAGjgZ8wgZwwEwYJKwYBBAGCNxQCBAYeBABDAEEwCwYDVR0P
+BAQDAgGGMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFMZPoj0GY4QJnM5i5ASs
+jVy16bYbMDYGA1UdHwQvMC0wK6ApoCeGJWh0dHA6Ly9jcmwueHJhbXBzZWN1cml0
+eS5jb20vWEdDQS5jcmwwEAYJKwYBBAGCNxUBBAMCAQEwDQYJKoZIhvcNAQEFBQAD
+ggEBAJEVOQMBG2f7Shz5CmBbodpNl2L5JFMn14JkTpAuw0kbK5rc/Kh4ZzXxHfAR
+vbdI4xD2Dd8/0sm2qlWkSLoC295ZLhVbO50WfUfXN+pfTXYSNrsf16GBBEYgoyxt
+qZ4Bfj8pzgCT3/3JknOJiWSe5yvkHJEs0rnOfc5vMZnT5r7SHpDwCRR5XCOrTdLa
+IR9NmXmd4c8nnxCbHIgNsIpkQTG4DmyQJKSbXHGPurt+HBvbaoAPIbzp26a3QPSy
+i6mx5O+aGtA9aZnuqCij4Tyz8LIRnM98QObd50N9otg6tamN8jSZxNQQ4Qb9CYQQ
+O+7ETPTsJ3xCwnR8gooJybQDJbw=
+-----END CERTIFICATE-----
+
+# Issuer: O=The Go Daddy Group, Inc. OU=Go Daddy Class 2 Certification Authority
+# Subject: O=The Go Daddy Group, Inc. OU=Go Daddy Class 2 Certification Authority
+# Label: "Go Daddy Class 2 CA"
+# Serial: 0
+# MD5 Fingerprint: 91:de:06:25:ab:da:fd:32:17:0c:bb:25:17:2a:84:67
+# SHA1 Fingerprint: 27:96:ba:e6:3f:18:01:e2:77:26:1b:a0:d7:77:70:02:8f:20:ee:e4
+# SHA256 Fingerprint: c3:84:6b:f2:4b:9e:93:ca:64:27:4c:0e:c6:7c:1e:cc:5e:02:4f:fc:ac:d2:d7:40:19:35:0e:81:fe:54:6a:e4
+-----BEGIN CERTIFICATE-----
+MIIEADCCAuigAwIBAgIBADANBgkqhkiG9w0BAQUFADBjMQswCQYDVQQGEwJVUzEh
+MB8GA1UEChMYVGhlIEdvIERhZGR5IEdyb3VwLCBJbmMuMTEwLwYDVQQLEyhHbyBE
+YWRkeSBDbGFzcyAyIENlcnRpZmljYXRpb24gQXV0aG9yaXR5MB4XDTA0MDYyOTE3
+MDYyMFoXDTM0MDYyOTE3MDYyMFowYzELMAkGA1UEBhMCVVMxITAfBgNVBAoTGFRo
+ZSBHbyBEYWRkeSBHcm91cCwgSW5jLjExMC8GA1UECxMoR28gRGFkZHkgQ2xhc3Mg
+MiBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eTCCASAwDQYJKoZIhvcNAQEBBQADggEN
+ADCCAQgCggEBAN6d1+pXGEmhW+vXX0iG6r7d/+TvZxz0ZWizV3GgXne77ZtJ6XCA
+PVYYYwhv2vLM0D9/AlQiVBDYsoHUwHU9S3/Hd8M+eKsaA7Ugay9qK7HFiH7Eux6w
+wdhFJ2+qN1j3hybX2C32qRe3H3I2TqYXP2WYktsqbl2i/ojgC95/5Y0V4evLOtXi
+EqITLdiOr18SPaAIBQi2XKVlOARFmR6jYGB0xUGlcmIbYsUfb18aQr4CUWWoriMY
+avx4A6lNf4DD+qta/KFApMoZFv6yyO9ecw3ud72a9nmYvLEHZ6IVDd2gWMZEewo+
+YihfukEHU1jPEX44dMX4/7VpkI+EdOqXG68CAQOjgcAwgb0wHQYDVR0OBBYEFNLE
+sNKR1EwRcbNhyz2h/t2oatTjMIGNBgNVHSMEgYUwgYKAFNLEsNKR1EwRcbNhyz2h
+/t2oatTjoWekZTBjMQswCQYDVQQGEwJVUzEhMB8GA1UEChMYVGhlIEdvIERhZGR5
+IEdyb3VwLCBJbmMuMTEwLwYDVQQLEyhHbyBEYWRkeSBDbGFzcyAyIENlcnRpZmlj
+YXRpb24gQXV0aG9yaXR5ggEAMAwGA1UdEwQFMAMBAf8wDQYJKoZIhvcNAQEFBQAD
+ggEBADJL87LKPpH8EsahB4yOd6AzBhRckB4Y9wimPQoZ+YeAEW5p5JYXMP80kWNy
+OO7MHAGjHZQopDH2esRU1/blMVgDoszOYtuURXO1v0XJJLXVggKtI3lpjbi2Tc7P
+TMozI+gciKqdi0FuFskg5YmezTvacPd+mSYgFFQlq25zheabIZ0KbIIOqPjCDPoQ
+HmyW74cNxA9hi63ugyuV+I6ShHI56yDqg+2DzZduCLzrTia2cyvk0/ZM/iZx4mER
+dEr/VxqHD3VILs9RaRegAhJhldXRQLIQTO7ErBBDpqWeCtWVYpoNz4iCxTIM5Cuf
+ReYNnyicsbkqWletNw+vHX/bvZ8=
+-----END CERTIFICATE-----
+
+# Issuer: O=Starfield Technologies, Inc. OU=Starfield Class 2 Certification Authority
+# Subject: O=Starfield Technologies, Inc. OU=Starfield Class 2 Certification Authority
+# Label: "Starfield Class 2 CA"
+# Serial: 0
+# MD5 Fingerprint: 32:4a:4b:bb:c8:63:69:9b:be:74:9a:c6:dd:1d:46:24
+# SHA1 Fingerprint: ad:7e:1c:28:b0:64:ef:8f:60:03:40:20:14:c3:d0:e3:37:0e:b5:8a
+# SHA256 Fingerprint: 14:65:fa:20:53:97:b8:76:fa:a6:f0:a9:95:8e:55:90:e4:0f:cc:7f:aa:4f:b7:c2:c8:67:75:21:fb:5f:b6:58
+-----BEGIN CERTIFICATE-----
+MIIEDzCCAvegAwIBAgIBADANBgkqhkiG9w0BAQUFADBoMQswCQYDVQQGEwJVUzEl
+MCMGA1UEChMcU3RhcmZpZWxkIFRlY2hub2xvZ2llcywgSW5jLjEyMDAGA1UECxMp
+U3RhcmZpZWxkIENsYXNzIDIgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkwHhcNMDQw
+NjI5MTczOTE2WhcNMzQwNjI5MTczOTE2WjBoMQswCQYDVQQGEwJVUzElMCMGA1UE
+ChMcU3RhcmZpZWxkIFRlY2hub2xvZ2llcywgSW5jLjEyMDAGA1UECxMpU3RhcmZp
+ZWxkIENsYXNzIDIgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkwggEgMA0GCSqGSIb3
+DQEBAQUAA4IBDQAwggEIAoIBAQC3Msj+6XGmBIWtDBFk385N78gDGIc/oav7PKaf
+8MOh2tTYbitTkPskpD6E8J7oX+zlJ0T1KKY/e97gKvDIr1MvnsoFAZMej2YcOadN
++lq2cwQlZut3f+dZxkqZJRRU6ybH838Z1TBwj6+wRir/resp7defqgSHo9T5iaU0
+X9tDkYI22WY8sbi5gv2cOj4QyDvvBmVmepsZGD3/cVE8MC5fvj13c7JdBmzDI1aa
+K4UmkhynArPkPw2vCHmCuDY96pzTNbO8acr1zJ3o/WSNF4Azbl5KXZnJHoe0nRrA
+1W4TNSNe35tfPe/W93bC6j67eA0cQmdrBNj41tpvi/JEoAGrAgEDo4HFMIHCMB0G
+A1UdDgQWBBS/X7fRzt0fhvRbVazc1xDCDqmI5zCBkgYDVR0jBIGKMIGHgBS/X7fR
+zt0fhvRbVazc1xDCDqmI56FspGowaDELMAkGA1UEBhMCVVMxJTAjBgNVBAoTHFN0
+YXJmaWVsZCBUZWNobm9sb2dpZXMsIEluYy4xMjAwBgNVBAsTKVN0YXJmaWVsZCBD
+bGFzcyAyIENlcnRpZmljYXRpb24gQXV0aG9yaXR5ggEAMAwGA1UdEwQFMAMBAf8w
+DQYJKoZIhvcNAQEFBQADggEBAAWdP4id0ckaVaGsafPzWdqbAYcaT1epoXkJKtv3
+L7IezMdeatiDh6GX70k1PncGQVhiv45YuApnP+yz3SFmH8lU+nLMPUxA2IGvd56D
+eruix/U0F47ZEUD0/CwqTRV/p2JdLiXTAAsgGh1o+Re49L2L7ShZ3U0WixeDyLJl
+xy16paq8U4Zt3VekyvggQQto8PT7dL5WXXp59fkdheMtlb71cZBDzI0fmgAKhynp
+VSJYACPq4xJDKVtHCN2MQWplBqjlIapBtJUhlbl90TSrE9atvNziPTnNvT51cKEY
+WQPJIrSPnNVeKtelttQKbfi3QBFGmh95DmK/D5fs4C8fF5Q=
+-----END CERTIFICATE-----
+
+# Issuer: CN=DigiCert Assured ID Root CA O=DigiCert Inc OU=www.digicert.com
+# Subject: CN=DigiCert Assured ID Root CA O=DigiCert Inc OU=www.digicert.com
+# Label: "DigiCert Assured ID Root CA"
+# Serial: 17154717934120587862167794914071425081
+# MD5 Fingerprint: 87:ce:0b:7b:2a:0e:49:00:e1:58:71:9b:37:a8:93:72
+# SHA1 Fingerprint: 05:63:b8:63:0d:62:d7:5a:bb:c8:ab:1e:4b:df:b5:a8:99:b2:4d:43
+# SHA256 Fingerprint: 3e:90:99:b5:01:5e:8f:48:6c:00:bc:ea:9d:11:1e:e7:21:fa:ba:35:5a:89:bc:f1:df:69:56:1e:3d:c6:32:5c
+-----BEGIN CERTIFICATE-----
+MIIDtzCCAp+gAwIBAgIQDOfg5RfYRv6P5WD8G/AwOTANBgkqhkiG9w0BAQUFADBl
+MQswCQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3
+d3cuZGlnaWNlcnQuY29tMSQwIgYDVQQDExtEaWdpQ2VydCBBc3N1cmVkIElEIFJv
+b3QgQ0EwHhcNMDYxMTEwMDAwMDAwWhcNMzExMTEwMDAwMDAwWjBlMQswCQYDVQQG
+EwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3d3cuZGlnaWNl
+cnQuY29tMSQwIgYDVQQDExtEaWdpQ2VydCBBc3N1cmVkIElEIFJvb3QgQ0EwggEi
+MA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCtDhXO5EOAXLGH87dg+XESpa7c
+JpSIqvTO9SA5KFhgDPiA2qkVlTJhPLWxKISKityfCgyDF3qPkKyK53lTXDGEKvYP
+mDI2dsze3Tyoou9q+yHyUmHfnyDXH+Kx2f4YZNISW1/5WBg1vEfNoTb5a3/UsDg+
+wRvDjDPZ2C8Y/igPs6eD1sNuRMBhNZYW/lmci3Zt1/GiSw0r/wty2p5g0I6QNcZ4
+VYcgoc/lbQrISXwxmDNsIumH0DJaoroTghHtORedmTpyoeb6pNnVFzF1roV9Iq4/
+AUaG9ih5yLHa5FcXxH4cDrC0kqZWs72yl+2qp/C3xag/lRbQ/6GW6whfGHdPAgMB
+AAGjYzBhMA4GA1UdDwEB/wQEAwIBhjAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW
+BBRF66Kv9JLLgjEtUYunpyGd823IDzAfBgNVHSMEGDAWgBRF66Kv9JLLgjEtUYun
+pyGd823IDzANBgkqhkiG9w0BAQUFAAOCAQEAog683+Lt8ONyc3pklL/3cmbYMuRC
+dWKuh+vy1dneVrOfzM4UKLkNl2BcEkxY5NM9g0lFWJc1aRqoR+pWxnmrEthngYTf
+fwk8lOa4JiwgvT2zKIn3X/8i4peEH+ll74fg38FnSbNd67IJKusm7Xi+fT8r87cm
+NW1fiQG2SVufAQWbqz0lwcy2f8Lxb4bG+mRo64EtlOtCt/qMHt1i8b5QZ7dsvfPx
+H2sMNgcWfzd8qVttevESRmCD1ycEvkvOl77DZypoEd+A5wwzZr8TDRRu838fYxAe
++o0bJW1sj6W3YQGx0qMmoRBxna3iw/nDmVG3KwcIzi7mULKn+gpFL6Lw8g==
+-----END CERTIFICATE-----
+
+# Issuer: CN=DigiCert Global Root CA O=DigiCert Inc OU=www.digicert.com
+# Subject: CN=DigiCert Global Root CA O=DigiCert Inc OU=www.digicert.com
+# Label: "DigiCert Global Root CA"
+# Serial: 10944719598952040374951832963794454346
+# MD5 Fingerprint: 79:e4:a9:84:0d:7d:3a:96:d7:c0:4f:e2:43:4c:89:2e
+# SHA1 Fingerprint: a8:98:5d:3a:65:e5:e5:c4:b2:d7:d6:6d:40:c6:dd:2f:b1:9c:54:36
+# SHA256 Fingerprint: 43:48:a0:e9:44:4c:78:cb:26:5e:05:8d:5e:89:44:b4:d8:4f:96:62:bd:26:db:25:7f:89:34:a4:43:c7:01:61
+-----BEGIN CERTIFICATE-----
+MIIDrzCCApegAwIBAgIQCDvgVpBCRrGhdWrJWZHHSjANBgkqhkiG9w0BAQUFADBh
+MQswCQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3
+d3cuZGlnaWNlcnQuY29tMSAwHgYDVQQDExdEaWdpQ2VydCBHbG9iYWwgUm9vdCBD
+QTAeFw0wNjExMTAwMDAwMDBaFw0zMTExMTAwMDAwMDBaMGExCzAJBgNVBAYTAlVT
+MRUwEwYDVQQKEwxEaWdpQ2VydCBJbmMxGTAXBgNVBAsTEHd3dy5kaWdpY2VydC5j
+b20xIDAeBgNVBAMTF0RpZ2lDZXJ0IEdsb2JhbCBSb290IENBMIIBIjANBgkqhkiG
+9w0BAQEFAAOCAQ8AMIIBCgKCAQEA4jvhEXLeqKTTo1eqUKKPC3eQyaKl7hLOllsB
+CSDMAZOnTjC3U/dDxGkAV53ijSLdhwZAAIEJzs4bg7/fzTtxRuLWZscFs3YnFo97
+nh6Vfe63SKMI2tavegw5BmV/Sl0fvBf4q77uKNd0f3p4mVmFaG5cIzJLv07A6Fpt
+43C/dxC//AH2hdmoRBBYMql1GNXRor5H4idq9Joz+EkIYIvUX7Q6hL+hqkpMfT7P
+T19sdl6gSzeRntwi5m3OFBqOasv+zbMUZBfHWymeMr/y7vrTC0LUq7dBMtoM1O/4
+gdW7jVg/tRvoSSiicNoxBN33shbyTApOB6jtSj1etX+jkMOvJwIDAQABo2MwYTAO
+BgNVHQ8BAf8EBAMCAYYwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUA95QNVbR
+TLtm8KPiGxvDl7I90VUwHwYDVR0jBBgwFoAUA95QNVbRTLtm8KPiGxvDl7I90VUw
+DQYJKoZIhvcNAQEFBQADggEBAMucN6pIExIK+t1EnE9SsPTfrgT1eXkIoyQY/Esr
+hMAtudXH/vTBH1jLuG2cenTnmCmrEbXjcKChzUyImZOMkXDiqw8cvpOp/2PV5Adg
+06O/nVsJ8dWO41P0jmP6P6fbtGbfYmbW0W5BjfIttep3Sp+dWOIrWcBAI+0tKIJF
+PnlUkiaY4IBIqDfv8NZ5YBberOgOzW6sRBc4L0na4UU+Krk2U886UAb3LujEV0ls
+YSEY1QSteDwsOoBrp+uvFRTp2InBuThs4pFsiv9kuXclVzDAGySj4dzp30d8tbQk
+CAUw7C29C79Fv1C5qfPrmAESrciIxpg0X40KPMbp1ZWVbd4=
+-----END CERTIFICATE-----
+
+# Issuer: CN=DigiCert High Assurance EV Root CA O=DigiCert Inc OU=www.digicert.com
+# Subject: CN=DigiCert High Assurance EV Root CA O=DigiCert Inc OU=www.digicert.com
+# Label: "DigiCert High Assurance EV Root CA"
+# Serial: 3553400076410547919724730734378100087
+# MD5 Fingerprint: d4:74:de:57:5c:39:b2:d3:9c:85:83:c5:c0:65:49:8a
+# SHA1 Fingerprint: 5f:b7:ee:06:33:e2:59:db:ad:0c:4c:9a:e6:d3:8f:1a:61:c7:dc:25
+# SHA256 Fingerprint: 74:31:e5:f4:c3:c1:ce:46:90:77:4f:0b:61:e0:54:40:88:3b:a9:a0:1e:d0:0b:a6:ab:d7:80:6e:d3:b1:18:cf
+-----BEGIN CERTIFICATE-----
+MIIDxTCCAq2gAwIBAgIQAqxcJmoLQJuPC3nyrkYldzANBgkqhkiG9w0BAQUFADBs
+MQswCQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3
+d3cuZGlnaWNlcnQuY29tMSswKQYDVQQDEyJEaWdpQ2VydCBIaWdoIEFzc3VyYW5j
+ZSBFViBSb290IENBMB4XDTA2MTExMDAwMDAwMFoXDTMxMTExMDAwMDAwMFowbDEL
+MAkGA1UEBhMCVVMxFTATBgNVBAoTDERpZ2lDZXJ0IEluYzEZMBcGA1UECxMQd3d3
+LmRpZ2ljZXJ0LmNvbTErMCkGA1UEAxMiRGlnaUNlcnQgSGlnaCBBc3N1cmFuY2Ug
+RVYgUm9vdCBDQTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAMbM5XPm
++9S75S0tMqbf5YE/yc0lSbZxKsPVlDRnogocsF9ppkCxxLeyj9CYpKlBWTrT3JTW
+PNt0OKRKzE0lgvdKpVMSOO7zSW1xkX5jtqumX8OkhPhPYlG++MXs2ziS4wblCJEM
+xChBVfvLWokVfnHoNb9Ncgk9vjo4UFt3MRuNs8ckRZqnrG0AFFoEt7oT61EKmEFB
+Ik5lYYeBQVCmeVyJ3hlKV9Uu5l0cUyx+mM0aBhakaHPQNAQTXKFx01p8VdteZOE3
+hzBWBOURtCmAEvF5OYiiAhF8J2a3iLd48soKqDirCmTCv2ZdlYTBoSUeh10aUAsg
+EsxBu24LUTi4S8sCAwEAAaNjMGEwDgYDVR0PAQH/BAQDAgGGMA8GA1UdEwEB/wQF
+MAMBAf8wHQYDVR0OBBYEFLE+w2kD+L9HAdSYJhoIAu9jZCvDMB8GA1UdIwQYMBaA
+FLE+w2kD+L9HAdSYJhoIAu9jZCvDMA0GCSqGSIb3DQEBBQUAA4IBAQAcGgaX3Nec
+nzyIZgYIVyHbIUf4KmeqvxgydkAQV8GK83rZEWWONfqe/EW1ntlMMUu4kehDLI6z
+eM7b41N5cdblIZQB2lWHmiRk9opmzN6cN82oNLFpmyPInngiK3BD41VHMWEZ71jF
+hS9OMPagMRYjyOfiZRYzy78aG6A9+MpeizGLYAiJLQwGXFK3xPkKmNEVX58Svnw2
+Yzi9RKR/5CYrCsSXaQ3pjOLAEFe4yHYSkVXySGnYvCoCWw9E1CAx2/S6cCZdkGCe
+vEsXCS+0yx5DaMkHJ8HSXPfqIbloEpw8nL+e/IBcm2PN7EeqJSdnoDfzAIJ9VNep
++OkuE6N36B9K
+-----END CERTIFICATE-----
+
+# Issuer: CN=SwissSign Gold CA - G2 O=SwissSign AG
+# Subject: CN=SwissSign Gold CA - G2 O=SwissSign AG
+# Label: "SwissSign Gold CA - G2"
+# Serial: 13492815561806991280
+# MD5 Fingerprint: 24:77:d9:a8:91:d1:3b:fa:88:2d:c2:ff:f8:cd:33:93
+# SHA1 Fingerprint: d8:c5:38:8a:b7:30:1b:1b:6e:d4:7a:e6:45:25:3a:6f:9f:1a:27:61
+# SHA256 Fingerprint: 62:dd:0b:e9:b9:f5:0a:16:3e:a0:f8:e7:5c:05:3b:1e:ca:57:ea:55:c8:68:8f:64:7c:68:81:f2:c8:35:7b:95
+-----BEGIN CERTIFICATE-----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+-----END CERTIFICATE-----
+
+# Issuer: CN=SwissSign Silver CA - G2 O=SwissSign AG
+# Subject: CN=SwissSign Silver CA - G2 O=SwissSign AG
+# Label: "SwissSign Silver CA - G2"
+# Serial: 5700383053117599563
+# MD5 Fingerprint: e0:06:a1:c9:7d:cf:c9:fc:0d:c0:56:75:96:d8:62:13
+# SHA1 Fingerprint: 9b:aa:e5:9f:56:ee:21:cb:43:5a:be:25:93:df:a7:f0:40:d1:1d:cb
+# SHA256 Fingerprint: be:6c:4d:a2:bb:b9:ba:59:b6:f3:93:97:68:37:42:46:c3:c0:05:99:3f:a9:8f:02:0d:1d:ed:be:d4:8a:81:d5
+-----BEGIN CERTIFICATE-----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+-----END CERTIFICATE-----
+
+# Issuer: CN=SecureTrust CA O=SecureTrust Corporation
+# Subject: CN=SecureTrust CA O=SecureTrust Corporation
+# Label: "SecureTrust CA"
+# Serial: 17199774589125277788362757014266862032
+# MD5 Fingerprint: dc:32:c3:a7:6d:25:57:c7:68:09:9d:ea:2d:a9:a2:d1
+# SHA1 Fingerprint: 87:82:c6:c3:04:35:3b:cf:d2:96:92:d2:59:3e:7d:44:d9:34:ff:11
+# SHA256 Fingerprint: f1:c1:b5:0a:e5:a2:0d:d8:03:0e:c9:f6:bc:24:82:3d:d3:67:b5:25:57:59:b4:e7:1b:61:fc:e9:f7:37:5d:73
+-----BEGIN CERTIFICATE-----
+MIIDuDCCAqCgAwIBAgIQDPCOXAgWpa1Cf/DrJxhZ0DANBgkqhkiG9w0BAQUFADBI
+MQswCQYDVQQGEwJVUzEgMB4GA1UEChMXU2VjdXJlVHJ1c3QgQ29ycG9yYXRpb24x
+FzAVBgNVBAMTDlNlY3VyZVRydXN0IENBMB4XDTA2MTEwNzE5MzExOFoXDTI5MTIz
+MTE5NDA1NVowSDELMAkGA1UEBhMCVVMxIDAeBgNVBAoTF1NlY3VyZVRydXN0IENv
+cnBvcmF0aW9uMRcwFQYDVQQDEw5TZWN1cmVUcnVzdCBDQTCCASIwDQYJKoZIhvcN
+AQEBBQADggEPADCCAQoCggEBAKukgeWVzfX2FI7CT8rU4niVWJxB4Q2ZQCQXOZEz
+Zum+4YOvYlyJ0fwkW2Gz4BERQRwdbvC4u/jep4G6pkjGnx29vo6pQT64lO0pGtSO
+0gMdA+9tDWccV9cGrcrI9f4Or2YlSASWC12juhbDCE/RRvgUXPLIXgGZbf2IzIao
+wW8xQmxSPmjL8xk037uHGFaAJsTQ3MBv396gwpEWoGQRS0S8Hvbn+mPeZqx2pHGj
+7DaUaHp3pLHnDi+BeuK1cobvomuL8A/b01k/unK8RCSc43Oz969XL0Imnal0ugBS
+8kvNU3xHCzaFDmapCJcWNFfBZveA4+1wVMeT4C4oFVmHursCAwEAAaOBnTCBmjAT
+BgkrBgEEAYI3FAIEBh4EAEMAQTALBgNVHQ8EBAMCAYYwDwYDVR0TAQH/BAUwAwEB
+/zAdBgNVHQ4EFgQUQjK2FvoE/f5dS3rD/fdMQB1aQ68wNAYDVR0fBC0wKzApoCeg
+JYYjaHR0cDovL2NybC5zZWN1cmV0cnVzdC5jb20vU1RDQS5jcmwwEAYJKwYBBAGC
+NxUBBAMCAQAwDQYJKoZIhvcNAQEFBQADggEBADDtT0rhWDpSclu1pqNlGKa7UTt3
+6Z3q059c4EVlew3KW+JwULKUBRSuSceNQQcSc5R+DCMh/bwQf2AQWnL1mA6s7Ll/
+3XpvXdMc9P+IBWlCqQVxyLesJugutIxq/3HcuLHfmbx8IVQr5Fiiu1cprp6poxkm
+D5kuCLDv/WnPmRoJjeOnnyvJNjR7JLN4TJUXpAYmHrZkUjZfYGfZnMUFdAvnZyPS
+CPyI6a6Lf+Ew9Dd+/cYy2i2eRDAwbO4H3tI0/NL/QPZL9GZGBlSm8jIKYyYwa5vR
+3ItHuuG51WLQoqD0ZwV4KWMabwTW+MZMo5qxN7SN5ShLHZ4swrhovO0C7jE=
+-----END CERTIFICATE-----
+
+# Issuer: CN=Secure Global CA O=SecureTrust Corporation
+# Subject: CN=Secure Global CA O=SecureTrust Corporation
+# Label: "Secure Global CA"
+# Serial: 9751836167731051554232119481456978597
+# MD5 Fingerprint: cf:f4:27:0d:d4:ed:dc:65:16:49:6d:3d:da:bf:6e:de
+# SHA1 Fingerprint: 3a:44:73:5a:e5:81:90:1f:24:86:61:46:1e:3b:9c:c4:5f:f5:3a:1b
+# SHA256 Fingerprint: 42:00:f5:04:3a:c8:59:0e:bb:52:7d:20:9e:d1:50:30:29:fb:cb:d4:1c:a1:b5:06:ec:27:f1:5a:de:7d:ac:69
+-----BEGIN CERTIFICATE-----
+MIIDvDCCAqSgAwIBAgIQB1YipOjUiolN9BPI8PjqpTANBgkqhkiG9w0BAQUFADBK
+MQswCQYDVQQGEwJVUzEgMB4GA1UEChMXU2VjdXJlVHJ1c3QgQ29ycG9yYXRpb24x
+GTAXBgNVBAMTEFNlY3VyZSBHbG9iYWwgQ0EwHhcNMDYxMTA3MTk0MjI4WhcNMjkx
+MjMxMTk1MjA2WjBKMQswCQYDVQQGEwJVUzEgMB4GA1UEChMXU2VjdXJlVHJ1c3Qg
+Q29ycG9yYXRpb24xGTAXBgNVBAMTEFNlY3VyZSBHbG9iYWwgQ0EwggEiMA0GCSqG
+SIb3DQEBAQUAA4IBDwAwggEKAoIBAQCvNS7YrGxVaQZx5RNoJLNP2MwhR/jxYDiJ
+iQPpvepeRlMJ3Fz1Wuj3RSoC6zFh1ykzTM7HfAo3fg+6MpjhHZevj8fcyTiW89sa
+/FHtaMbQbqR8JNGuQsiWUGMu4P51/pinX0kuleM5M2SOHqRfkNJnPLLZ/kG5VacJ
+jnIFHovdRIWCQtBJwB1g8NEXLJXr9qXBkqPFwqcIYA1gBBCWeZ4WNOaptvolRTnI
+HmX5k/Wq8VLcmZg9pYYaDDUz+kulBAYVHDGA76oYa8J719rO+TMg1fW9ajMtgQT7
+sFzUnKPiXB3jqUJ1XnvUd+85VLrJChgbEplJL4hL/VBi0XPnj3pDAgMBAAGjgZ0w
+gZowEwYJKwYBBAGCNxQCBAYeBABDAEEwCwYDVR0PBAQDAgGGMA8GA1UdEwEB/wQF
+MAMBAf8wHQYDVR0OBBYEFK9EBMJBfkiD2045AuzshHrmzsmkMDQGA1UdHwQtMCsw
+KaAnoCWGI2h0dHA6Ly9jcmwuc2VjdXJldHJ1c3QuY29tL1NHQ0EuY3JsMBAGCSsG
+AQQBgjcVAQQDAgEAMA0GCSqGSIb3DQEBBQUAA4IBAQBjGghAfaReUw132HquHw0L
+URYD7xh8yOOvaliTFGCRsoTciE6+OYo68+aCiV0BN7OrJKQVDpI1WkpEXk5X+nXO
+H0jOZvQ8QCaSmGwb7iRGDBezUqXbpZGRzzfTb+cnCDpOGR86p1hcF895P4vkp9Mm
+I50mD1hp/Ed+stCNi5O/KU9DaXR2Z0vPB4zmAve14bRDtUstFJ/53CYNv6ZHdAbY
+iNE6KTCEztI5gGIbqMdXSbxqVVFnFUq+NQfk1XWYN3kwFNspnWzFacxHVaIw98xc
+f8LDmBxrThaA63p4ZUWiABqvDA1VZDRIuJK58bRQKfJPIx/abKwfROHdI3hRW8cW
+-----END CERTIFICATE-----
+
+# Issuer: CN=COMODO Certification Authority O=COMODO CA Limited
+# Subject: CN=COMODO Certification Authority O=COMODO CA Limited
+# Label: "COMODO Certification Authority"
+# Serial: 104350513648249232941998508985834464573
+# MD5 Fingerprint: 5c:48:dc:f7:42:72:ec:56:94:6d:1c:cc:71:35:80:75
+# SHA1 Fingerprint: 66:31:bf:9e:f7:4f:9e:b6:c9:d5:a6:0c:ba:6a:be:d1:f7:bd:ef:7b
+# SHA256 Fingerprint: 0c:2c:d6:3d:f7:80:6f:a3:99:ed:e8:09:11:6b:57:5b:f8:79:89:f0:65:18:f9:80:8c:86:05:03:17:8b:af:66
+-----BEGIN CERTIFICATE-----
+MIIEHTCCAwWgAwIBAgIQToEtioJl4AsC7j41AkblPTANBgkqhkiG9w0BAQUFADCB
+gTELMAkGA1UEBhMCR0IxGzAZBgNVBAgTEkdyZWF0ZXIgTWFuY2hlc3RlcjEQMA4G
+A1UEBxMHU2FsZm9yZDEaMBgGA1UEChMRQ09NT0RPIENBIExpbWl0ZWQxJzAlBgNV
+BAMTHkNPTU9ETyBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eTAeFw0wNjEyMDEwMDAw
+MDBaFw0yOTEyMzEyMzU5NTlaMIGBMQswCQYDVQQGEwJHQjEbMBkGA1UECBMSR3Jl
+YXRlciBNYW5jaGVzdGVyMRAwDgYDVQQHEwdTYWxmb3JkMRowGAYDVQQKExFDT01P
+RE8gQ0EgTGltaXRlZDEnMCUGA1UEAxMeQ09NT0RPIENlcnRpZmljYXRpb24gQXV0
+aG9yaXR5MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA0ECLi3LjkRv3
+UcEbVASY06m/weaKXTuH+7uIzg3jLz8GlvCiKVCZrts7oVewdFFxze1CkU1B/qnI
+2GqGd0S7WWaXUF601CxwRM/aN5VCaTwwxHGzUvAhTaHYujl8HJ6jJJ3ygxaYqhZ8
+Q5sVW7euNJH+1GImGEaaP+vB+fGQV+useg2L23IwambV4EajcNxo2f8ESIl33rXp
++2dtQem8Ob0y2WIC8bGoPW43nOIv4tOiJovGuFVDiOEjPqXSJDlqR6sA1KGzqSX+
+DT+nHbrTUcELpNqsOO9VUCQFZUaTNE8tja3G1CEZ0o7KBWFxB3NH5YoZEr0ETc5O
+nKVIrLsm9wIDAQABo4GOMIGLMB0GA1UdDgQWBBQLWOWLxkwVN6RAqTCpIb5HNlpW
+/zAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/BAUwAwEB/zBJBgNVHR8EQjBAMD6g
+PKA6hjhodHRwOi8vY3JsLmNvbW9kb2NhLmNvbS9DT01PRE9DZXJ0aWZpY2F0aW9u
+QXV0aG9yaXR5LmNybDANBgkqhkiG9w0BAQUFAAOCAQEAPpiem/Yb6dc5t3iuHXIY
+SdOH5EOC6z/JqvWote9VfCFSZfnVDeFs9D6Mk3ORLgLETgdxb8CPOGEIqB6BCsAv
+IC9Bi5HcSEW88cbeunZrM8gALTFGTO3nnc+IlP8zwFboJIYmuNg4ON8qa90SzMc/
+RxdMosIGlgnW2/4/PEZB31jiVg88O8EckzXZOFKs7sjsLjBOlDW0JB9LeGna8gI4
+zJVSk/BwJVmcIGfE7vmLV2H0knZ9P4SNVbfo5azV8fUZVqZa+5Acr5Pr5RzUZ5dd
+BA6+C4OmF4O5MBKgxTMVBbkN+8cFduPYSo38NBejxiEovjBFMR7HeL5YYTisO+IB
+ZQ==
+-----END CERTIFICATE-----
+
+# Issuer: CN=COMODO ECC Certification Authority O=COMODO CA Limited
+# Subject: CN=COMODO ECC Certification Authority O=COMODO CA Limited
+# Label: "COMODO ECC Certification Authority"
+# Serial: 41578283867086692638256921589707938090
+# MD5 Fingerprint: 7c:62:ff:74:9d:31:53:5e:68:4a:d5:78:aa:1e:bf:23
+# SHA1 Fingerprint: 9f:74:4e:9f:2b:4d:ba:ec:0f:31:2c:50:b6:56:3b:8e:2d:93:c3:11
+# SHA256 Fingerprint: 17:93:92:7a:06:14:54:97:89:ad:ce:2f:8f:34:f7:f0:b6:6d:0f:3a:e3:a3:b8:4d:21:ec:15:db:ba:4f:ad:c7
+-----BEGIN CERTIFICATE-----
+MIICiTCCAg+gAwIBAgIQH0evqmIAcFBUTAGem2OZKjAKBggqhkjOPQQDAzCBhTEL
+MAkGA1UEBhMCR0IxGzAZBgNVBAgTEkdyZWF0ZXIgTWFuY2hlc3RlcjEQMA4GA1UE
+BxMHU2FsZm9yZDEaMBgGA1UEChMRQ09NT0RPIENBIExpbWl0ZWQxKzApBgNVBAMT
+IkNPTU9ETyBFQ0MgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkwHhcNMDgwMzA2MDAw
+MDAwWhcNMzgwMTE4MjM1OTU5WjCBhTELMAkGA1UEBhMCR0IxGzAZBgNVBAgTEkdy
+ZWF0ZXIgTWFuY2hlc3RlcjEQMA4GA1UEBxMHU2FsZm9yZDEaMBgGA1UEChMRQ09N
+T0RPIENBIExpbWl0ZWQxKzApBgNVBAMTIkNPTU9ETyBFQ0MgQ2VydGlmaWNhdGlv
+biBBdXRob3JpdHkwdjAQBgcqhkjOPQIBBgUrgQQAIgNiAAQDR3svdcmCFYX7deSR
+FtSrYpn1PlILBs5BAH+X4QokPB0BBO490o0JlwzgdeT6+3eKKvUDYEs2ixYjFq0J
+cfRK9ChQtP6IHG4/bC8vCVlbpVsLM5niwz2J+Wos77LTBumjQjBAMB0GA1UdDgQW
+BBR1cacZSBm8nZ3qQUfflMRId5nTeTAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/
+BAUwAwEB/zAKBggqhkjOPQQDAwNoADBlAjEA7wNbeqy3eApyt4jf/7VGFAkK+qDm
+fQjGGoe9GKhzvSbKYAydzpmfz1wPMOG+FDHqAjAU9JM8SaczepBGR7NjfRObTrdv
+GDeAU/7dIOA1mjbRxwG55tzd8/8dLDoWV9mSOdY=
+-----END CERTIFICATE-----
+
+# Issuer: CN=Certigna O=Dhimyotis
+# Subject: CN=Certigna O=Dhimyotis
+# Label: "Certigna"
+# Serial: 18364802974209362175
+# MD5 Fingerprint: ab:57:a6:5b:7d:42:82:19:b5:d8:58:26:28:5e:fd:ff
+# SHA1 Fingerprint: b1:2e:13:63:45:86:a4:6f:1a:b2:60:68:37:58:2d:c4:ac:fd:94:97
+# SHA256 Fingerprint: e3:b6:a2:db:2e:d7:ce:48:84:2f:7a:c5:32:41:c7:b7:1d:54:14:4b:fb:40:c1:1f:3f:1d:0b:42:f5:ee:a1:2d
+-----BEGIN CERTIFICATE-----
+MIIDqDCCApCgAwIBAgIJAP7c4wEPyUj/MA0GCSqGSIb3DQEBBQUAMDQxCzAJBgNV
+BAYTAkZSMRIwEAYDVQQKDAlEaGlteW90aXMxETAPBgNVBAMMCENlcnRpZ25hMB4X
+DTA3MDYyOTE1MTMwNVoXDTI3MDYyOTE1MTMwNVowNDELMAkGA1UEBhMCRlIxEjAQ
+BgNVBAoMCURoaW15b3RpczERMA8GA1UEAwwIQ2VydGlnbmEwggEiMA0GCSqGSIb3
+DQEBAQUAA4IBDwAwggEKAoIBAQDIaPHJ1tazNHUmgh7stL7qXOEm7RFHYeGifBZ4
+QCHkYJ5ayGPhxLGWkv8YbWkj4Sti993iNi+RB7lIzw7sebYs5zRLcAglozyHGxny
+gQcPOJAZ0xH+hrTy0V4eHpbNgGzOOzGTtvKg0KmVEn2lmsxryIRWijOp5yIVUxbw
+zBfsV1/pogqYCd7jX5xv3EjjhQsVWqa6n6xI4wmy9/Qy3l40vhx4XUJbzg4ij02Q
+130yGLMLLGq/jj8UEYkgDncUtT2UCIf3JR7VsmAA7G8qKCVuKj4YYxclPz5EIBb2
+JsglrgVKtOdjLPOMFlN+XPsRGgjBRmKfIrjxwo1p3Po6WAbfAgMBAAGjgbwwgbkw
+DwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGu3+QTmQtCRZvgHyUtVF9lo53BEw
+ZAYDVR0jBF0wW4AUGu3+QTmQtCRZvgHyUtVF9lo53BGhOKQ2MDQxCzAJBgNVBAYT
+AkZSMRIwEAYDVQQKDAlEaGlteW90aXMxETAPBgNVBAMMCENlcnRpZ25hggkA/tzj
+AQ/JSP8wDgYDVR0PAQH/BAQDAgEGMBEGCWCGSAGG+EIBAQQEAwIABzANBgkqhkiG
+9w0BAQUFAAOCAQEAhQMeknH2Qq/ho2Ge6/PAD/Kl1NqV5ta+aDY9fm4fTIrv0Q8h
+bV6lUmPOEvjvKtpv6zf+EwLHyzs+ImvaYS5/1HI93TDhHkxAGYwP15zRgzB7mFnc
+fca5DClMoTOi62c6ZYTTluLtdkVwj7Ur3vkj1kluPBS1xp81HlDQwY9qcEQCYsuu
+HWhBp6pX6FOqB9IG9tUUBguRA3UsbHK1YZWaDYu5Def131TN3ubY1gkIl2PlwS6w
+t0QmwCbAr1UwnjvVNioZBPRcHv/PLLf/0P2HQBHVESO7SMAhqaQoLf0V+LBOK/Qw
+WyH8EZE0vkHve52Xdf+XlcCWWC/qu0bXu+TZLg==
+-----END CERTIFICATE-----
+
+# Issuer: O=Chunghwa Telecom Co., Ltd. OU=ePKI Root Certification Authority
+# Subject: O=Chunghwa Telecom Co., Ltd. OU=ePKI Root Certification Authority
+# Label: "ePKI Root Certification Authority"
+# Serial: 28956088682735189655030529057352760477
+# MD5 Fingerprint: 1b:2e:00:ca:26:06:90:3d:ad:fe:6f:15:68:d3:6b:b3
+# SHA1 Fingerprint: 67:65:0d:f1:7e:8e:7e:5b:82:40:a4:f4:56:4b:cf:e2:3d:69:c6:f0
+# SHA256 Fingerprint: c0:a6:f4:dc:63:a2:4b:fd:cf:54:ef:2a:6a:08:2a:0a:72:de:35:80:3e:2f:f5:ff:52:7a:e5:d8:72:06:df:d5
+-----BEGIN CERTIFICATE-----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+-----END CERTIFICATE-----
+
+# Issuer: O=certSIGN OU=certSIGN ROOT CA
+# Subject: O=certSIGN OU=certSIGN ROOT CA
+# Label: "certSIGN ROOT CA"
+# Serial: 35210227249154
+# MD5 Fingerprint: 18:98:c0:d6:e9:3a:fc:f9:b0:f5:0c:f7:4b:01:44:17
+# SHA1 Fingerprint: fa:b7:ee:36:97:26:62:fb:2d:b0:2a:f6:bf:03:fd:e8:7c:4b:2f:9b
+# SHA256 Fingerprint: ea:a9:62:c4:fa:4a:6b:af:eb:e4:15:19:6d:35:1c:cd:88:8d:4f:53:f3:fa:8a:e6:d7:c4:66:a9:4e:60:42:bb
+-----BEGIN CERTIFICATE-----
+MIIDODCCAiCgAwIBAgIGIAYFFnACMA0GCSqGSIb3DQEBBQUAMDsxCzAJBgNVBAYT
+AlJPMREwDwYDVQQKEwhjZXJ0U0lHTjEZMBcGA1UECxMQY2VydFNJR04gUk9PVCBD
+QTAeFw0wNjA3MDQxNzIwMDRaFw0zMTA3MDQxNzIwMDRaMDsxCzAJBgNVBAYTAlJP
+MREwDwYDVQQKEwhjZXJ0U0lHTjEZMBcGA1UECxMQY2VydFNJR04gUk9PVCBDQTCC
+ASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBALczuX7IJUqOtdu0KBuqV5Do
+0SLTZLrTk+jUrIZhQGpgV2hUhE28alQCBf/fm5oqrl0Hj0rDKH/v+yv6efHHrfAQ
+UySQi2bJqIirr1qjAOm+ukbuW3N7LBeCgV5iLKECZbO9xSsAfsT8AzNXDe3i+s5d
+RdY4zTW2ssHQnIFKquSyAVwdj1+ZxLGt24gh65AIgoDzMKND5pCCrlUoSe1b16kQ
+OA7+j0xbm0bqQfWwCHTD0IgztnzXdN/chNFDDnU5oSVAKOp4yw4sLjmdjItuFhwv
+JoIQ4uNllAoEwF73XVv4EOLQunpL+943AAAaWyjj0pxzPjKHmKHJUS/X3qwzs08C
+AwEAAaNCMEAwDwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMCAcYwHQYDVR0O
+BBYEFOCMm9slSbPxfIbWskKHC9BroNnkMA0GCSqGSIb3DQEBBQUAA4IBAQA+0hyJ
+LjX8+HXd5n9liPRyTMks1zJO890ZeUe9jjtbkw9QSSQTaxQGcu8J06Gh40CEyecY
+MnQ8SG4Pn0vU9x7Tk4ZkVJdjclDVVc/6IJMCopvDI5NOFlV2oHB5bc0hH88vLbwZ
+44gx+FkagQnIl6Z0x2DEW8xXjrJ1/RsCCdtZb3KTafcxQdaIOL+Hsr0Wefmq5L6I
+Jd1hJyMctTEHBDa0GpC9oHRxUIltvBTjD4au8as+x6AJzKNI0eDbZOeStc+vckNw
+i/nDhDwTqn6Sm1dTk/pwwpEOMfmbZ13pljheX7NzTogVZ96edhBiIL5VaZVDADlN
+9u6wWk5JRFRYX0KD
+-----END CERTIFICATE-----
+
+# Issuer: CN=NetLock Arany (Class Gold) F\u0151tan\xfas\xedtv\xe1ny O=NetLock Kft. OU=Tan\xfas\xedtv\xe1nykiad\xf3k (Certification Services)
+# Subject: CN=NetLock Arany (Class Gold) F\u0151tan\xfas\xedtv\xe1ny O=NetLock Kft. OU=Tan\xfas\xedtv\xe1nykiad\xf3k (Certification Services)
+# Label: "NetLock Arany (Class Gold) F\u0151tan\xfas\xedtv\xe1ny"
+# Serial: 80544274841616
+# MD5 Fingerprint: c5:a1:b7:ff:73:dd:d6:d7:34:32:18:df:fc:3c:ad:88
+# SHA1 Fingerprint: 06:08:3f:59:3f:15:a1:04:a0:69:a4:6b:a9:03:d0:06:b7:97:09:91
+# SHA256 Fingerprint: 6c:61:da:c3:a2:de:f0:31:50:6b:e0:36:d2:a6:fe:40:19:94:fb:d1:3d:f9:c8:d4:66:59:92:74:c4:46:ec:98
+-----BEGIN CERTIFICATE-----
+MIIEFTCCAv2gAwIBAgIGSUEs5AAQMA0GCSqGSIb3DQEBCwUAMIGnMQswCQYDVQQG
+EwJIVTERMA8GA1UEBwwIQnVkYXBlc3QxFTATBgNVBAoMDE5ldExvY2sgS2Z0LjE3
+MDUGA1UECwwuVGFuw7pzw610dsOhbnlraWFkw7NrIChDZXJ0aWZpY2F0aW9uIFNl
+cnZpY2VzKTE1MDMGA1UEAwwsTmV0TG9jayBBcmFueSAoQ2xhc3MgR29sZCkgRsWR
+dGFuw7pzw610dsOhbnkwHhcNMDgxMjExMTUwODIxWhcNMjgxMjA2MTUwODIxWjCB
+pzELMAkGA1UEBhMCSFUxETAPBgNVBAcMCEJ1ZGFwZXN0MRUwEwYDVQQKDAxOZXRM
+b2NrIEtmdC4xNzA1BgNVBAsMLlRhbsO6c8OtdHbDoW55a2lhZMOzayAoQ2VydGlm
+aWNhdGlvbiBTZXJ2aWNlcykxNTAzBgNVBAMMLE5ldExvY2sgQXJhbnkgKENsYXNz
+IEdvbGQpIEbFkXRhbsO6c8OtdHbDoW55MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8A
+MIIBCgKCAQEAxCRec75LbRTDofTjl5Bu0jBFHjzuZ9lk4BqKf8owyoPjIMHj9DrT
+lF8afFttvzBPhCf2nx9JvMaZCpDyD/V/Q4Q3Y1GLeqVw/HpYzY6b7cNGbIRwXdrz
+AZAj/E4wqX7hJ2Pn7WQ8oLjJM2P+FpD/sLj916jAwJRDC7bVWaaeVtAkH3B5r9s5
+VA1lddkVQZQBr17s9o3x/61k/iCa11zr/qYfCGSji3ZVrR47KGAuhyXoqq8fxmRG
+ILdwfzzeSNuWU7c5d+Qa4scWhHaXWy+7GRWF+GmF9ZmnqfI0p6m2pgP8b4Y9VHx2
+BJtr+UBdADTHLpl1neWIA6pN+APSQnbAGwIDAKiLo0UwQzASBgNVHRMBAf8ECDAG
+AQH/AgEEMA4GA1UdDwEB/wQEAwIBBjAdBgNVHQ4EFgQUzPpnk/C2uNClwB7zU/2M
+U9+D15YwDQYJKoZIhvcNAQELBQADggEBAKt/7hwWqZw8UQCgwBEIBaeZ5m8BiFRh
+bvG5GK1Krf6BQCOUL/t1fC8oS2IkgYIL9WHxHG64YTjrgfpioTtaYtOUZcTh5m2C
++C8lcLIhJsFyUR+MLMOEkMNaj7rP9KdlpeuY0fsFskZ1FSNqb4VjMIDw1Z4fKRzC
+bLBQWV2QWzuoDTDPv31/zvGdg73JRm4gpvlhUbohL3u+pRVjodSVh/GeufOJ8z2F
+uLjbvrW5KfnaNwUASZQDhETnv0Mxz3WLJdH0pmT1kvarBes96aULNmLazAZfNou2
+XjG4Kvte9nHfRCaexOYNkbQudZWAUWpLMKawYqGT8ZvYzsRjdT9ZR7E=
+-----END CERTIFICATE-----
+
+# Issuer: CN=SecureSign RootCA11 O=Japan Certification Services, Inc.
+# Subject: CN=SecureSign RootCA11 O=Japan Certification Services, Inc.
+# Label: "SecureSign RootCA11"
+# Serial: 1
+# MD5 Fingerprint: b7:52:74:e2:92:b4:80:93:f2:75:e4:cc:d7:f2:ea:26
+# SHA1 Fingerprint: 3b:c4:9f:48:f8:f3:73:a0:9c:1e:bd:f8:5b:b1:c3:65:c7:d8:11:b3
+# SHA256 Fingerprint: bf:0f:ee:fb:9e:3a:58:1a:d5:f9:e9:db:75:89:98:57:43:d2:61:08:5c:4d:31:4f:6f:5d:72:59:aa:42:16:12
+-----BEGIN CERTIFICATE-----
+MIIDbTCCAlWgAwIBAgIBATANBgkqhkiG9w0BAQUFADBYMQswCQYDVQQGEwJKUDEr
+MCkGA1UEChMiSmFwYW4gQ2VydGlmaWNhdGlvbiBTZXJ2aWNlcywgSW5jLjEcMBoG
+A1UEAxMTU2VjdXJlU2lnbiBSb290Q0ExMTAeFw0wOTA0MDgwNDU2NDdaFw0yOTA0
+MDgwNDU2NDdaMFgxCzAJBgNVBAYTAkpQMSswKQYDVQQKEyJKYXBhbiBDZXJ0aWZp
+Y2F0aW9uIFNlcnZpY2VzLCBJbmMuMRwwGgYDVQQDExNTZWN1cmVTaWduIFJvb3RD
+QTExMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA/XeqpRyQBTvLTJsz
+i1oURaTnkBbR31fSIRCkF/3frNYfp+TbfPfs37gD2pRY/V1yfIw/XwFndBWW4wI8
+h9uuywGOwvNmxoVF9ALGOrVisq/6nL+k5tSAMJjzDbaTj6nU2DbysPyKyiyhFTOV
+MdrAG/LuYpmGYz+/3ZMqg6h2uRMft85OQoWPIucuGvKVCbIFtUROd6EgvanyTgp9
+UK31BQ1FT0Zx/Sg+U/sE2C3XZR1KG/rPO7AxmjVuyIsG0wCR8pQIZUyxNAYAeoni
+8McDWc/V1uinMrPmmECGxc0nEovMe863ETxiYAcjPitAbpSACW22s293bzUIUPsC
+h8U+iQIDAQABo0IwQDAdBgNVHQ4EFgQUW/hNT7KlhtQ60vFjmqC+CfZXt94wDgYD
+VR0PAQH/BAQDAgEGMA8GA1UdEwEB/wQFMAMBAf8wDQYJKoZIhvcNAQEFBQADggEB
+AKChOBZmLqdWHyGcBvod7bkixTgm2E5P7KN/ed5GIaGHd48HCJqypMWvDzKYC3xm
+KbabfSVSSUOrTC4rbnpwrxYO4wJs+0LmGJ1F2FXI6Dvd5+H0LgscNFxsWEr7jIhQ
+X5Ucv+2rIrVls4W6ng+4reV6G4pQOh29Dbx7VFALuUKvVaAYga1lme++5Jy/xIWr
+QbJUb9wlze144o4MjQlJ3WN7WmmWAiGovVJZ6X01y8hSyn+B/tlr0/cR7SXf+Of5
+pPpyl4RTDaXQMhhRdlkUbA/r7F+AjHVDg8OFmP9Mni0N5HeDk061lgeLKBObjBmN
+QSdJQO7e5iNEOdyhIta6A/I=
+-----END CERTIFICATE-----
+
+# Issuer: CN=Microsec e-Szigno Root CA 2009 O=Microsec Ltd.
+# Subject: CN=Microsec e-Szigno Root CA 2009 O=Microsec Ltd.
+# Label: "Microsec e-Szigno Root CA 2009"
+# Serial: 14014712776195784473
+# MD5 Fingerprint: f8:49:f4:03:bc:44:2d:83:be:48:69:7d:29:64:fc:b1
+# SHA1 Fingerprint: 89:df:74:fe:5c:f4:0f:4a:80:f9:e3:37:7d:54:da:91:e1:01:31:8e
+# SHA256 Fingerprint: 3c:5f:81:fe:a5:fa:b8:2c:64:bf:a2:ea:ec:af:cd:e8:e0:77:fc:86:20:a7:ca:e5:37:16:3d:f3:6e:db:f3:78
+-----BEGIN CERTIFICATE-----
+MIIECjCCAvKgAwIBAgIJAMJ+QwRORz8ZMA0GCSqGSIb3DQEBCwUAMIGCMQswCQYD
+VQQGEwJIVTERMA8GA1UEBwwIQnVkYXBlc3QxFjAUBgNVBAoMDU1pY3Jvc2VjIEx0
+ZC4xJzAlBgNVBAMMHk1pY3Jvc2VjIGUtU3ppZ25vIFJvb3QgQ0EgMjAwOTEfMB0G
+CSqGSIb3DQEJARYQaW5mb0BlLXN6aWduby5odTAeFw0wOTA2MTYxMTMwMThaFw0y
+OTEyMzAxMTMwMThaMIGCMQswCQYDVQQGEwJIVTERMA8GA1UEBwwIQnVkYXBlc3Qx
+FjAUBgNVBAoMDU1pY3Jvc2VjIEx0ZC4xJzAlBgNVBAMMHk1pY3Jvc2VjIGUtU3pp
+Z25vIFJvb3QgQ0EgMjAwOTEfMB0GCSqGSIb3DQEJARYQaW5mb0BlLXN6aWduby5o
+dTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAOn4j/NjrdqG2KfgQvvP
+kd6mJviZpWNwrZuuyjNAfW2WbqEORO7hE52UQlKavXWFdCyoDh2Tthi3jCyoz/tc
+cbna7P7ofo/kLx2yqHWH2Leh5TvPmUpG0IMZfcChEhyVbUr02MelTTMuhTlAdX4U
+fIASmFDHQWe4oIBhVKZsTh/gnQ4H6cm6M+f+wFUoLAKApxn1ntxVUwOXewdI/5n7
+N4okxFnMUBBjjqqpGrCEGob5X7uxUG6k0QrM1XF+H6cbfPVTbiJfyyvm1HxdrtbC
+xkzlBQHZ7Vf8wSN5/PrIJIOV87VqUQHQd9bpEqH5GoP7ghu5sJf0dgYzQ0mg/wu1
++rUCAwEAAaOBgDB+MA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgEGMB0G
+A1UdDgQWBBTLD8bfQkPMPcu1SCOhGnqmKrs0aDAfBgNVHSMEGDAWgBTLD8bfQkPM
+Pcu1SCOhGnqmKrs0aDAbBgNVHREEFDASgRBpbmZvQGUtc3ppZ25vLmh1MA0GCSqG
+SIb3DQEBCwUAA4IBAQDJ0Q5eLtXMs3w+y/w9/w0olZMEyL/azXm4Q5DwpL7v8u8h
+mLzU1F0G9u5C7DBsoKqpyvGvivo/C3NqPuouQH4frlRheesuCDfXI/OMn74dseGk
+ddug4lQUsbocKaQY9hK6ohQU4zE1yED/t+AFdlfBHFny+L/k7SViXITwfn4fs775
+tyERzAMBVnCnEJIeGzSBHq2cGsMEPO0CYdYeBvNfOofyK/FFh+U9rNHHV4S9a67c
+2Pm2G2JwCz02yULyMtd6YebS2z3PyKnJm9zbWETXbzivf3jTo60adbocwTZ8jx5t
+HMN1Rq41Bab2XD0h7lbwyYIiLXpUq3DDfSJlgnCW
+-----END CERTIFICATE-----
+
+# Issuer: CN=GlobalSign O=GlobalSign OU=GlobalSign Root CA - R3
+# Subject: CN=GlobalSign O=GlobalSign OU=GlobalSign Root CA - R3
+# Label: "GlobalSign Root CA - R3"
+# Serial: 4835703278459759426209954
+# MD5 Fingerprint: c5:df:b8:49:ca:05:13:55:ee:2d:ba:1a:c3:3e:b0:28
+# SHA1 Fingerprint: d6:9b:56:11:48:f0:1c:77:c5:45:78:c1:09:26:df:5b:85:69:76:ad
+# SHA256 Fingerprint: cb:b5:22:d7:b7:f1:27:ad:6a:01:13:86:5b:df:1c:d4:10:2e:7d:07:59:af:63:5a:7c:f4:72:0d:c9:63:c5:3b
+-----BEGIN CERTIFICATE-----
+MIIDXzCCAkegAwIBAgILBAAAAAABIVhTCKIwDQYJKoZIhvcNAQELBQAwTDEgMB4G
+A1UECxMXR2xvYmFsU2lnbiBSb290IENBIC0gUjMxEzARBgNVBAoTCkdsb2JhbFNp
+Z24xEzARBgNVBAMTCkdsb2JhbFNpZ24wHhcNMDkwMzE4MTAwMDAwWhcNMjkwMzE4
+MTAwMDAwWjBMMSAwHgYDVQQLExdHbG9iYWxTaWduIFJvb3QgQ0EgLSBSMzETMBEG
+A1UEChMKR2xvYmFsU2lnbjETMBEGA1UEAxMKR2xvYmFsU2lnbjCCASIwDQYJKoZI
+hvcNAQEBBQADggEPADCCAQoCggEBAMwldpB5BngiFvXAg7aEyiie/QV2EcWtiHL8
+RgJDx7KKnQRfJMsuS+FggkbhUqsMgUdwbN1k0ev1LKMPgj0MK66X17YUhhB5uzsT
+gHeMCOFJ0mpiLx9e+pZo34knlTifBtc+ycsmWQ1z3rDI6SYOgxXG71uL0gRgykmm
+KPZpO/bLyCiR5Z2KYVc3rHQU3HTgOu5yLy6c+9C7v/U9AOEGM+iCK65TpjoWc4zd
+QQ4gOsC0p6Hpsk+QLjJg6VfLuQSSaGjlOCZgdbKfd/+RFO+uIEn8rUAVSNECMWEZ
+XriX7613t2Saer9fwRPvm2L7DWzgVGkWqQPabumDk3F2xmmFghcCAwEAAaNCMEAw
+DgYDVR0PAQH/BAQDAgEGMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFI/wS3+o
+LkUkrk1Q+mOai97i3Ru8MA0GCSqGSIb3DQEBCwUAA4IBAQBLQNvAUKr+yAzv95ZU
+RUm7lgAJQayzE4aGKAczymvmdLm6AC2upArT9fHxD4q/c2dKg8dEe3jgr25sbwMp
+jjM5RcOO5LlXbKr8EpbsU8Yt5CRsuZRj+9xTaGdWPoO4zzUhw8lo/s7awlOqzJCK
+6fBdRoyV3XpYKBovHd7NADdBj+1EbddTKJd+82cEHhXXipa0095MJ6RMG3NzdvQX
+mcIfeg7jLQitChws/zyrVQ4PkX4268NXSb7hLi18YIvDQVETI53O9zJrlAGomecs
+Mx86OyXShkDOOyyGeMlhLxS67ttVb9+E7gUJTb0o2HLO02JQZR7rkpeDMdmztcpH
+WD9f
+-----END CERTIFICATE-----
+
+# Issuer: CN=Izenpe.com O=IZENPE S.A.
+# Subject: CN=Izenpe.com O=IZENPE S.A.
+# Label: "Izenpe.com"
+# Serial: 917563065490389241595536686991402621
+# MD5 Fingerprint: a6:b0:cd:85:80:da:5c:50:34:a3:39:90:2f:55:67:73
+# SHA1 Fingerprint: 2f:78:3d:25:52:18:a7:4a:65:39:71:b5:2c:a2:9c:45:15:6f:e9:19
+# SHA256 Fingerprint: 25:30:cc:8e:98:32:15:02:ba:d9:6f:9b:1f:ba:1b:09:9e:2d:29:9e:0f:45:48:bb:91:4f:36:3b:c0:d4:53:1f
+-----BEGIN CERTIFICATE-----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+-----END CERTIFICATE-----
+
+# Issuer: CN=Go Daddy Root Certificate Authority - G2 O=GoDaddy.com, Inc.
+# Subject: CN=Go Daddy Root Certificate Authority - G2 O=GoDaddy.com, Inc.
+# Label: "Go Daddy Root Certificate Authority - G2"
+# Serial: 0
+# MD5 Fingerprint: 80:3a:bc:22:c1:e6:fb:8d:9b:3b:27:4a:32:1b:9a:01
+# SHA1 Fingerprint: 47:be:ab:c9:22:ea:e8:0e:78:78:34:62:a7:9f:45:c2:54:fd:e6:8b
+# SHA256 Fingerprint: 45:14:0b:32:47:eb:9c:c8:c5:b4:f0:d7:b5:30:91:f7:32:92:08:9e:6e:5a:63:e2:74:9d:d3:ac:a9:19:8e:da
+-----BEGIN CERTIFICATE-----
+MIIDxTCCAq2gAwIBAgIBADANBgkqhkiG9w0BAQsFADCBgzELMAkGA1UEBhMCVVMx
+EDAOBgNVBAgTB0FyaXpvbmExEzARBgNVBAcTClNjb3R0c2RhbGUxGjAYBgNVBAoT
+EUdvRGFkZHkuY29tLCBJbmMuMTEwLwYDVQQDEyhHbyBEYWRkeSBSb290IENlcnRp
+ZmljYXRlIEF1dGhvcml0eSAtIEcyMB4XDTA5MDkwMTAwMDAwMFoXDTM3MTIzMTIz
+NTk1OVowgYMxCzAJBgNVBAYTAlVTMRAwDgYDVQQIEwdBcml6b25hMRMwEQYDVQQH
+EwpTY290dHNkYWxlMRowGAYDVQQKExFHb0RhZGR5LmNvbSwgSW5jLjExMC8GA1UE
+AxMoR28gRGFkZHkgUm9vdCBDZXJ0aWZpY2F0ZSBBdXRob3JpdHkgLSBHMjCCASIw
+DQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAL9xYgjx+lk09xvJGKP3gElY6SKD
+E6bFIEMBO4Tx5oVJnyfq9oQbTqC023CYxzIBsQU+B07u9PpPL1kwIuerGVZr4oAH
+/PMWdYA5UXvl+TW2dE6pjYIT5LY/qQOD+qK+ihVqf94Lw7YZFAXK6sOoBJQ7Rnwy
+DfMAZiLIjWltNowRGLfTshxgtDj6AozO091GB94KPutdfMh8+7ArU6SSYmlRJQVh
+GkSBjCypQ5Yj36w6gZoOKcUcqeldHraenjAKOc7xiID7S13MMuyFYkMlNAJWJwGR
+tDtwKj9useiciAF9n9T521NtYJ2/LOdYq7hfRvzOxBsDPAnrSTFcaUaz4EcCAwEA
+AaNCMEAwDwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYE
+FDqahQcQZyi27/a9BUFuIMGU2g/eMA0GCSqGSIb3DQEBCwUAA4IBAQCZ21151fmX
+WWcDYfF+OwYxdS2hII5PZYe096acvNjpL9DbWu7PdIxztDhC2gV7+AJ1uP2lsdeu
+9tfeE8tTEH6KRtGX+rcuKxGrkLAngPnon1rpN5+r5N9ss4UXnT3ZJE95kTXWXwTr
+gIOrmgIttRD02JDHBHNA7XIloKmf7J6raBKZV8aPEjoJpL1E/QYVN8Gb5DKj7Tjo
+2GTzLH4U/ALqn83/B2gX2yKQOC16jdFU8WnjXzPKej17CuPKf1855eJ1usV2GDPO
+LPAvTK33sefOT6jEm0pUBsV/fdUID+Ic/n4XuKxe9tQWskMJDE32p2u0mYRlynqI
+4uJEvlz36hz1
+-----END CERTIFICATE-----
+
+# Issuer: CN=Starfield Root Certificate Authority - G2 O=Starfield Technologies, Inc.
+# Subject: CN=Starfield Root Certificate Authority - G2 O=Starfield Technologies, Inc.
+# Label: "Starfield Root Certificate Authority - G2"
+# Serial: 0
+# MD5 Fingerprint: d6:39:81:c6:52:7e:96:69:fc:fc:ca:66:ed:05:f2:96
+# SHA1 Fingerprint: b5:1c:06:7c:ee:2b:0c:3d:f8:55:ab:2d:92:f4:fe:39:d4:e7:0f:0e
+# SHA256 Fingerprint: 2c:e1:cb:0b:f9:d2:f9:e1:02:99:3f:be:21:51:52:c3:b2:dd:0c:ab:de:1c:68:e5:31:9b:83:91:54:db:b7:f5
+-----BEGIN CERTIFICATE-----
+MIID3TCCAsWgAwIBAgIBADANBgkqhkiG9w0BAQsFADCBjzELMAkGA1UEBhMCVVMx
+EDAOBgNVBAgTB0FyaXpvbmExEzARBgNVBAcTClNjb3R0c2RhbGUxJTAjBgNVBAoT
+HFN0YXJmaWVsZCBUZWNobm9sb2dpZXMsIEluYy4xMjAwBgNVBAMTKVN0YXJmaWVs
+ZCBSb290IENlcnRpZmljYXRlIEF1dGhvcml0eSAtIEcyMB4XDTA5MDkwMTAwMDAw
+MFoXDTM3MTIzMTIzNTk1OVowgY8xCzAJBgNVBAYTAlVTMRAwDgYDVQQIEwdBcml6
+b25hMRMwEQYDVQQHEwpTY290dHNkYWxlMSUwIwYDVQQKExxTdGFyZmllbGQgVGVj
+aG5vbG9naWVzLCBJbmMuMTIwMAYDVQQDEylTdGFyZmllbGQgUm9vdCBDZXJ0aWZp
+Y2F0ZSBBdXRob3JpdHkgLSBHMjCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoC
+ggEBAL3twQP89o/8ArFvW59I2Z154qK3A2FWGMNHttfKPTUuiUP3oWmb3ooa/RMg
+nLRJdzIpVv257IzdIvpy3Cdhl+72WoTsbhm5iSzchFvVdPtrX8WJpRBSiUZV9Lh1
+HOZ/5FSuS/hVclcCGfgXcVnrHigHdMWdSL5stPSksPNkN3mSwOxGXn/hbVNMYq/N
+Hwtjuzqd+/x5AJhhdM8mgkBj87JyahkNmcrUDnXMN/uLicFZ8WJ/X7NfZTD4p7dN
+dloedl40wOiWVpmKs/B/pM293DIxfJHP4F8R+GuqSVzRmZTRouNjWwl2tVZi4Ut0
+HZbUJtQIBFnQmA4O5t78w+wfkPECAwEAAaNCMEAwDwYDVR0TAQH/BAUwAwEB/zAO
+BgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFHwMMh+n2TB/xH1oo2Kooc6rB1snMA0G
+CSqGSIb3DQEBCwUAA4IBAQARWfolTwNvlJk7mh+ChTnUdgWUXuEok21iXQnCoKjU
+sHU48TRqneSfioYmUeYs0cYtbpUgSpIB7LiKZ3sx4mcujJUDJi5DnUox9g61DLu3
+4jd/IroAow57UvtruzvE03lRTs2Q9GcHGcg8RnoNAX3FWOdt5oUwF5okxBDgBPfg
+8n/Uqgr/Qh037ZTlZFkSIHc40zI+OIF1lnP6aI+xy84fxez6nH7PfrHxBy22/L/K
+pL/QlwVKvOoYKAKQvVR4CSFx09F9HdkWsKlhPdAKACL8x3vLCWRFCztAgfd9fDL1
+mMpYjn0q7pBZc2T5NnReJaH1ZgUufzkVqSr7UIuOhWn0
+-----END CERTIFICATE-----
+
+# Issuer: CN=Starfield Services Root Certificate Authority - G2 O=Starfield Technologies, Inc.
+# Subject: CN=Starfield Services Root Certificate Authority - G2 O=Starfield Technologies, Inc.
+# Label: "Starfield Services Root Certificate Authority - G2"
+# Serial: 0
+# MD5 Fingerprint: 17:35:74:af:7b:61:1c:eb:f4:f9:3c:e2:ee:40:f9:a2
+# SHA1 Fingerprint: 92:5a:8f:8d:2c:6d:04:e0:66:5f:59:6a:ff:22:d8:63:e8:25:6f:3f
+# SHA256 Fingerprint: 56:8d:69:05:a2:c8:87:08:a4:b3:02:51:90:ed:cf:ed:b1:97:4a:60:6a:13:c6:e5:29:0f:cb:2a:e6:3e:da:b5
+-----BEGIN CERTIFICATE-----
+MIID7zCCAtegAwIBAgIBADANBgkqhkiG9w0BAQsFADCBmDELMAkGA1UEBhMCVVMx
+EDAOBgNVBAgTB0FyaXpvbmExEzARBgNVBAcTClNjb3R0c2RhbGUxJTAjBgNVBAoT
+HFN0YXJmaWVsZCBUZWNobm9sb2dpZXMsIEluYy4xOzA5BgNVBAMTMlN0YXJmaWVs
+ZCBTZXJ2aWNlcyBSb290IENlcnRpZmljYXRlIEF1dGhvcml0eSAtIEcyMB4XDTA5
+MDkwMTAwMDAwMFoXDTM3MTIzMTIzNTk1OVowgZgxCzAJBgNVBAYTAlVTMRAwDgYD
+VQQIEwdBcml6b25hMRMwEQYDVQQHEwpTY290dHNkYWxlMSUwIwYDVQQKExxTdGFy
+ZmllbGQgVGVjaG5vbG9naWVzLCBJbmMuMTswOQYDVQQDEzJTdGFyZmllbGQgU2Vy
+dmljZXMgUm9vdCBDZXJ0aWZpY2F0ZSBBdXRob3JpdHkgLSBHMjCCASIwDQYJKoZI
+hvcNAQEBBQADggEPADCCAQoCggEBANUMOsQq+U7i9b4Zl1+OiFOxHz/Lz58gE20p
+OsgPfTz3a3Y4Y9k2YKibXlwAgLIvWX/2h/klQ4bnaRtSmpDhcePYLQ1Ob/bISdm2
+8xpWriu2dBTrz/sm4xq6HZYuajtYlIlHVv8loJNwU4PahHQUw2eeBGg6345AWh1K
+Ts9DkTvnVtYAcMtS7nt9rjrnvDH5RfbCYM8TWQIrgMw0R9+53pBlbQLPLJGmpufe
+hRhJfGZOozptqbXuNC66DQO4M99H67FrjSXZm86B0UVGMpZwh94CDklDhbZsc7tk
+6mFBrMnUVN+HL8cisibMn1lUaJ/8viovxFUcdUBgF4UCVTmLfwUCAwEAAaNCMEAw
+DwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFJxfAN+q
+AdcwKziIorhtSpzyEZGDMA0GCSqGSIb3DQEBCwUAA4IBAQBLNqaEd2ndOxmfZyMI
+bw5hyf2E3F/YNoHN2BtBLZ9g3ccaaNnRbobhiCPPE95Dz+I0swSdHynVv/heyNXB
+ve6SbzJ08pGCL72CQnqtKrcgfU28elUSwhXqvfdqlS5sdJ/PHLTyxQGjhdByPq1z
+qwubdQxtRbeOlKyWN7Wg0I8VRw7j6IPdj/3vQQF3zCepYoUz8jcI73HPdwbeyBkd
+iEDPfUYd/x7H4c7/I9vG+o1VTqkC50cRRj70/b17KSa7qWFiNyi2LSr2EIZkyXCn
+0q23KXB56jzaYyWf/Wi3MOxw+3WKt21gZ7IeyLnp2KhvAotnDU0mV3HaIPzBSlCN
+sSi6
+-----END CERTIFICATE-----
+
+# Issuer: CN=AffirmTrust Commercial O=AffirmTrust
+# Subject: CN=AffirmTrust Commercial O=AffirmTrust
+# Label: "AffirmTrust Commercial"
+# Serial: 8608355977964138876
+# MD5 Fingerprint: 82:92:ba:5b:ef:cd:8a:6f:a6:3d:55:f9:84:f6:d6:b7
+# SHA1 Fingerprint: f9:b5:b6:32:45:5f:9c:be:ec:57:5f:80:dc:e9:6e:2c:c7:b2:78:b7
+# SHA256 Fingerprint: 03:76:ab:1d:54:c5:f9:80:3c:e4:b2:e2:01:a0:ee:7e:ef:7b:57:b6:36:e8:a9:3c:9b:8d:48:60:c9:6f:5f:a7
+-----BEGIN CERTIFICATE-----
+MIIDTDCCAjSgAwIBAgIId3cGJyapsXwwDQYJKoZIhvcNAQELBQAwRDELMAkGA1UE
+BhMCVVMxFDASBgNVBAoMC0FmZmlybVRydXN0MR8wHQYDVQQDDBZBZmZpcm1UcnVz
+dCBDb21tZXJjaWFsMB4XDTEwMDEyOTE0MDYwNloXDTMwMTIzMTE0MDYwNlowRDEL
+MAkGA1UEBhMCVVMxFDASBgNVBAoMC0FmZmlybVRydXN0MR8wHQYDVQQDDBZBZmZp
+cm1UcnVzdCBDb21tZXJjaWFsMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKC
+AQEA9htPZwcroRX1BiLLHwGy43NFBkRJLLtJJRTWzsO3qyxPxkEylFf6EqdbDuKP
+Hx6GGaeqtS25Xw2Kwq+FNXkyLbscYjfysVtKPcrNcV/pQr6U6Mje+SJIZMblq8Yr
+ba0F8PrVC8+a5fBQpIs7R6UjW3p6+DM/uO+Zl+MgwdYoic+U+7lF7eNAFxHUdPAL
+MeIrJmqbTFeurCA+ukV6BfO9m2kVrn1OIGPENXY6BwLJN/3HR+7o8XYdcxXyl6S1
+yHp52UKqK39c/s4mT6NmgTWvRLpUHhwwMmWd5jyTXlBOeuM61G7MGvv50jeuJCqr
+VwMiKA1JdX+3KNp1v47j3A55MQIDAQABo0IwQDAdBgNVHQ4EFgQUnZPGU4teyq8/
+nx4P5ZmVvCT2lI8wDwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMCAQYwDQYJ
+KoZIhvcNAQELBQADggEBAFis9AQOzcAN/wr91LoWXym9e2iZWEnStB03TX8nfUYG
+XUPGhi4+c7ImfU+TqbbEKpqrIZcUsd6M06uJFdhrJNTxFq7YpFzUf1GO7RgBsZNj
+vbz4YYCanrHOQnDiqX0GJX0nof5v7LMeJNrjS1UaADs1tDvZ110w/YETifLCBivt
+Z8SOyUOyXGsViQK8YvxO8rUzqrJv0wqiUOP2O+guRMLbZjipM1ZI8W0bM40NjD9g
+N53Tym1+NH4Nn3J2ixufcv1SNUFFApYvHLKac0khsUlHRUe072o0EclNmsxZt9YC
+nlpOZbWUrhvfKbAW8b8Angc6F2S1BLUjIZkKlTuXfO8=
+-----END CERTIFICATE-----
+
+# Issuer: CN=AffirmTrust Networking O=AffirmTrust
+# Subject: CN=AffirmTrust Networking O=AffirmTrust
+# Label: "AffirmTrust Networking"
+# Serial: 8957382827206547757
+# MD5 Fingerprint: 42:65:ca:be:01:9a:9a:4c:a9:8c:41:49:cd:c0:d5:7f
+# SHA1 Fingerprint: 29:36:21:02:8b:20:ed:02:f5:66:c5:32:d1:d6:ed:90:9f:45:00:2f
+# SHA256 Fingerprint: 0a:81:ec:5a:92:97:77:f1:45:90:4a:f3:8d:5d:50:9f:66:b5:e2:c5:8f:cd:b5:31:05:8b:0e:17:f3:f0:b4:1b
+-----BEGIN CERTIFICATE-----
+MIIDTDCCAjSgAwIBAgIIfE8EORzUmS0wDQYJKoZIhvcNAQEFBQAwRDELMAkGA1UE
+BhMCVVMxFDASBgNVBAoMC0FmZmlybVRydXN0MR8wHQYDVQQDDBZBZmZpcm1UcnVz
+dCBOZXR3b3JraW5nMB4XDTEwMDEyOTE0MDgyNFoXDTMwMTIzMTE0MDgyNFowRDEL
+MAkGA1UEBhMCVVMxFDASBgNVBAoMC0FmZmlybVRydXN0MR8wHQYDVQQDDBZBZmZp
+cm1UcnVzdCBOZXR3b3JraW5nMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKC
+AQEAtITMMxcua5Rsa2FSoOujz3mUTOWUgJnLVWREZY9nZOIG41w3SfYvm4SEHi3y
+YJ0wTsyEheIszx6e/jarM3c1RNg1lho9Nuh6DtjVR6FqaYvZ/Ls6rnla1fTWcbua
+kCNrmreIdIcMHl+5ni36q1Mr3Lt2PpNMCAiMHqIjHNRqrSK6mQEubWXLviRmVSRL
+QESxG9fhwoXA3hA/Pe24/PHxI1Pcv2WXb9n5QHGNfb2V1M6+oF4nI979ptAmDgAp
+6zxG8D1gvz9Q0twmQVGeFDdCBKNwV6gbh+0t+nvujArjqWaJGctB+d1ENmHP4ndG
+yH329JKBNv3bNPFyfvMMFr20FQIDAQABo0IwQDAdBgNVHQ4EFgQUBx/S55zawm6i
+QLSwelAQUHTEyL0wDwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMCAQYwDQYJ
+KoZIhvcNAQEFBQADggEBAIlXshZ6qML91tmbmzTCnLQyFE2npN/svqe++EPbkTfO
+tDIuUFUaNU52Q3Eg75N3ThVwLofDwR1t3Mu1J9QsVtFSUzpE0nPIxBsFZVpikpzu
+QY0x2+c06lkh1QF612S4ZDnNye2v7UsDSKegmQGA3GWjNq5lWUhPgkvIZfFXHeVZ
+Lgo/bNjR9eUJtGxUAArgFU2HdW23WJZa3W3SAKD0m0i+wzekujbgfIeFlxoVot4u
+olu9rxj5kFDNcFn4J2dHy8egBzp90SxdbBk6ZrV9/ZFvgrG+CJPbFEfxojfHRZ48
+x3evZKiT3/Zpg4Jg8klCNO1aAFSFHBY2kgxc+qatv9s=
+-----END CERTIFICATE-----
+
+# Issuer: CN=AffirmTrust Premium O=AffirmTrust
+# Subject: CN=AffirmTrust Premium O=AffirmTrust
+# Label: "AffirmTrust Premium"
+# Serial: 7893706540734352110
+# MD5 Fingerprint: c4:5d:0e:48:b6:ac:28:30:4e:0a:bc:f9:38:16:87:57
+# SHA1 Fingerprint: d8:a6:33:2c:e0:03:6f:b1:85:f6:63:4f:7d:6a:06:65:26:32:28:27
+# SHA256 Fingerprint: 70:a7:3f:7f:37:6b:60:07:42:48:90:45:34:b1:14:82:d5:bf:0e:69:8e:cc:49:8d:f5:25:77:eb:f2:e9:3b:9a
+-----BEGIN CERTIFICATE-----
+MIIFRjCCAy6gAwIBAgIIbYwURrGmCu4wDQYJKoZIhvcNAQEMBQAwQTELMAkGA1UE
+BhMCVVMxFDASBgNVBAoMC0FmZmlybVRydXN0MRwwGgYDVQQDDBNBZmZpcm1UcnVz
+dCBQcmVtaXVtMB4XDTEwMDEyOTE0MTAzNloXDTQwMTIzMTE0MTAzNlowQTELMAkG
+A1UEBhMCVVMxFDASBgNVBAoMC0FmZmlybVRydXN0MRwwGgYDVQQDDBNBZmZpcm1U
+cnVzdCBQcmVtaXVtMIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEAxBLf
+qV/+Qd3d9Z+K4/as4Tx4mrzY8H96oDMq3I0gW64tb+eT2TZwamjPjlGjhVtnBKAQ
+JG9dKILBl1fYSCkTtuG+kU3fhQxTGJoeJKJPj/CihQvL9Cl/0qRY7iZNyaqoe5rZ
++jjeRFcV5fiMyNlI4g0WJx0eyIOFJbe6qlVBzAMiSy2RjYvmia9mx+n/K+k8rNrS
+s8PhaJyJ+HoAVt70VZVs+7pk3WKL3wt3MutizCaam7uqYoNMtAZ6MMgpv+0GTZe5
+HMQxK9VfvFMSF5yZVylmd2EhMQcuJUmdGPLu8ytxjLW6OQdJd/zvLpKQBY0tL3d7
+70O/Nbua2Plzpyzy0FfuKE4mX4+QaAkvuPjcBukumj5Rp9EixAqnOEhss/n/fauG
+V+O61oV4d7pD6kh/9ti+I20ev9E2bFhc8e6kGVQa9QPSdubhjL08s9NIS+LI+H+S
+qHZGnEJlPqQewQcDWkYtuJfzt9WyVSHvutxMAJf7FJUnM7/oQ0dG0giZFmA7mn7S
+5u046uwBHjxIVkkJx0w3AJ6IDsBz4W9m6XJHMD4Q5QsDyZpCAGzFlH5hxIrff4Ia
+C1nEWTJ3s7xgaVY5/bQGeyzWZDbZvUjthB9+pSKPKrhC9IK31FOQeE4tGv2Bb0TX
+OwF0lkLgAOIua+rF7nKsu7/+6qqo+Nz2snmKtmcCAwEAAaNCMEAwHQYDVR0OBBYE
+FJ3AZ6YMItkm9UWrpmVSESfYRaxjMA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/
+BAQDAgEGMA0GCSqGSIb3DQEBDAUAA4ICAQCzV00QYk465KzquByvMiPIs0laUZx2
+KI15qldGF9X1Uva3ROgIRL8YhNILgM3FEv0AVQVhh0HctSSePMTYyPtwni94loMg
+Nt58D2kTiKV1NpgIpsbfrM7jWNa3Pt668+s0QNiigfV4Py/VpfzZotReBA4Xrf5B
+8OWycvpEgjNC6C1Y91aMYj+6QrCcDFx+LmUmXFNPALJ4fqENmS2NuB2OosSw/WDQ
+MKSOyARiqcTtNd56l+0OOF6SL5Nwpamcb6d9Ex1+xghIsV5n61EIJenmJWtSKZGc
+0jlzCFfemQa0W50QBuHCAKi4HEoCChTQwUHK+4w1IX2COPKpVJEZNZOUbWo6xbLQ
+u4mGk+ibyQ86p3q4ofB4Rvr8Ny/lioTz3/4E2aFooC8k4gmVBtWVyuEklut89pMF
+u+1z6S3RdTnX5yTb2E5fQ4+e0BQ5v1VwSJlXMbSc7kqYA5YwH2AG7hsj/oFgIxpH
+YoWlzBk0gG+zrBrjn/B7SK3VAdlntqlyk+otZrWyuOQ9PLLvTIzq6we/qzWaVYa8
+GKa1qF60g2xraUDTn9zxw2lrueFtCfTxqlB2Cnp9ehehVZZCmTEJ3WARjQUwfuaO
+RtGdFNrHF+QFlozEJLUbzxQHskD4o55BhrwE0GuWyCqANP2/7waj3VjFhT0+j/6e
+KeC2uAloGRwYQw==
+-----END CERTIFICATE-----
+
+# Issuer: CN=AffirmTrust Premium ECC O=AffirmTrust
+# Subject: CN=AffirmTrust Premium ECC O=AffirmTrust
+# Label: "AffirmTrust Premium ECC"
+# Serial: 8401224907861490260
+# MD5 Fingerprint: 64:b0:09:55:cf:b1:d5:99:e2:be:13:ab:a6:5d:ea:4d
+# SHA1 Fingerprint: b8:23:6b:00:2f:1d:16:86:53:01:55:6c:11:a4:37:ca:eb:ff:c3:bb
+# SHA256 Fingerprint: bd:71:fd:f6:da:97:e4:cf:62:d1:64:7a:dd:25:81:b0:7d:79:ad:f8:39:7e:b4:ec:ba:9c:5e:84:88:82:14:23
+-----BEGIN CERTIFICATE-----
+MIIB/jCCAYWgAwIBAgIIdJclisc/elQwCgYIKoZIzj0EAwMwRTELMAkGA1UEBhMC
+VVMxFDASBgNVBAoMC0FmZmlybVRydXN0MSAwHgYDVQQDDBdBZmZpcm1UcnVzdCBQ
+cmVtaXVtIEVDQzAeFw0xMDAxMjkxNDIwMjRaFw00MDEyMzExNDIwMjRaMEUxCzAJ
+BgNVBAYTAlVTMRQwEgYDVQQKDAtBZmZpcm1UcnVzdDEgMB4GA1UEAwwXQWZmaXJt
+VHJ1c3QgUHJlbWl1bSBFQ0MwdjAQBgcqhkjOPQIBBgUrgQQAIgNiAAQNMF4bFZ0D
+0KF5Nbc6PJJ6yhUczWLznCZcBz3lVPqj1swS6vQUX+iOGasvLkjmrBhDeKzQN8O9
+ss0s5kfiGuZjuD0uL3jET9v0D6RoTFVya5UdThhClXjMNzyR4ptlKymjQjBAMB0G
+A1UdDgQWBBSaryl6wBE1NSZRMADDav5A1a7WPDAPBgNVHRMBAf8EBTADAQH/MA4G
+A1UdDwEB/wQEAwIBBjAKBggqhkjOPQQDAwNnADBkAjAXCfOHiFBar8jAQr9HX/Vs
+aobgxCd05DhT1wV/GzTjxi+zygk8N53X57hG8f2h4nECMEJZh0PUUd+60wkyWs6I
+flc9nF9Ca/UHLbXwgpP5WW+uZPpY5Yse42O+tYHNbwKMeQ==
+-----END CERTIFICATE-----
+
+# Issuer: CN=Certum Trusted Network CA O=Unizeto Technologies S.A. OU=Certum Certification Authority
+# Subject: CN=Certum Trusted Network CA O=Unizeto Technologies S.A. OU=Certum Certification Authority
+# Label: "Certum Trusted Network CA"
+# Serial: 279744
+# MD5 Fingerprint: d5:e9:81:40:c5:18:69:fc:46:2c:89:75:62:0f:aa:78
+# SHA1 Fingerprint: 07:e0:32:e0:20:b7:2c:3f:19:2f:06:28:a2:59:3a:19:a7:0f:06:9e
+# SHA256 Fingerprint: 5c:58:46:8d:55:f5:8e:49:7e:74:39:82:d2:b5:00:10:b6:d1:65:37:4a:cf:83:a7:d4:a3:2d:b7:68:c4:40:8e
+-----BEGIN CERTIFICATE-----
+MIIDuzCCAqOgAwIBAgIDBETAMA0GCSqGSIb3DQEBBQUAMH4xCzAJBgNVBAYTAlBM
+MSIwIAYDVQQKExlVbml6ZXRvIFRlY2hub2xvZ2llcyBTLkEuMScwJQYDVQQLEx5D
+ZXJ0dW0gQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkxIjAgBgNVBAMTGUNlcnR1bSBU
+cnVzdGVkIE5ldHdvcmsgQ0EwHhcNMDgxMDIyMTIwNzM3WhcNMjkxMjMxMTIwNzM3
+WjB+MQswCQYDVQQGEwJQTDEiMCAGA1UEChMZVW5pemV0byBUZWNobm9sb2dpZXMg
+Uy5BLjEnMCUGA1UECxMeQ2VydHVtIENlcnRpZmljYXRpb24gQXV0aG9yaXR5MSIw
+IAYDVQQDExlDZXJ0dW0gVHJ1c3RlZCBOZXR3b3JrIENBMIIBIjANBgkqhkiG9w0B
+AQEFAAOCAQ8AMIIBCgKCAQEA4/t9o3K6wvDJFIf1awFO4W5AB7ptJ11/91sts1rH
+UV+rpDKmYYe2bg+G0jACl/jXaVehGDldamR5xgFZrDwxSjh80gTSSyjoIF87B6LM
+TXPb865Px1bVWqeWifrzq2jUI4ZZJ88JJ7ysbnKDHDBy3+Ci6dLhdHUZvSqeexVU
+BBvXQzmtVSjF4hq79MDkrjhJM8x2hZ85RdKknvISjFH4fOQtf/WsX+sWn7Et0brM
+kUJ3TCXJkDhv2/DM+44el1k+1WBO5gUo7Ul5E0u6SNsv+XLTOcr+H9g0cvW0QM8x
+AcPs3hEtF10fuFDRXhmnad4HMyjKUJX5p1TLVIZQRan5SQIDAQABo0IwQDAPBgNV
+HRMBAf8EBTADAQH/MB0GA1UdDgQWBBQIds3LB/8k9sXN7buQvOKEN0Z19zAOBgNV
+HQ8BAf8EBAMCAQYwDQYJKoZIhvcNAQEFBQADggEBAKaorSLOAT2mo/9i0Eidi15y
+sHhE49wcrwn9I0j6vSrEuVUEtRCjjSfeC4Jj0O7eDDd5QVsisrCaQVymcODU0HfL
+I9MA4GxWL+FpDQ3Zqr8hgVDZBqWo/5U30Kr+4rP1mS1FhIrlQgnXdAIv94nYmem8
+J9RHjboNRhx3zxSkHLmkMcScKHQDNP8zGSal6Q10tz6XxnboJ5ajZt3hrvJBW8qY
+VoNzcOSGGtIxQbovvi0TWnZvTuhOgQ4/WwMioBK+ZlgRSssDxLQqKi2WF+A5VLxI
+03YnnZotBqbJ7DnSq9ufmgsnAjUpsUCV5/nonFWIGUbWtzT1fs45mtk48VH3Tyw=
+-----END CERTIFICATE-----
+
+# Issuer: CN=TWCA Root Certification Authority O=TAIWAN-CA OU=Root CA
+# Subject: CN=TWCA Root Certification Authority O=TAIWAN-CA OU=Root CA
+# Label: "TWCA Root Certification Authority"
+# Serial: 1
+# MD5 Fingerprint: aa:08:8f:f6:f9:7b:b7:f2:b1:a7:1e:9b:ea:ea:bd:79
+# SHA1 Fingerprint: cf:9e:87:6d:d3:eb:fc:42:26:97:a3:b5:a3:7a:a0:76:a9:06:23:48
+# SHA256 Fingerprint: bf:d8:8f:e1:10:1c:41:ae:3e:80:1b:f8:be:56:35:0e:e9:ba:d1:a6:b9:bd:51:5e:dc:5c:6d:5b:87:11:ac:44
+-----BEGIN CERTIFICATE-----
+MIIDezCCAmOgAwIBAgIBATANBgkqhkiG9w0BAQUFADBfMQswCQYDVQQGEwJUVzES
+MBAGA1UECgwJVEFJV0FOLUNBMRAwDgYDVQQLDAdSb290IENBMSowKAYDVQQDDCFU
+V0NBIFJvb3QgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkwHhcNMDgwODI4MDcyNDMz
+WhcNMzAxMjMxMTU1OTU5WjBfMQswCQYDVQQGEwJUVzESMBAGA1UECgwJVEFJV0FO
+LUNBMRAwDgYDVQQLDAdSb290IENBMSowKAYDVQQDDCFUV0NBIFJvb3QgQ2VydGlm
+aWNhdGlvbiBBdXRob3JpdHkwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIB
+AQCwfnK4pAOU5qfeCTiRShFAh6d8WWQUe7UREN3+v9XAu1bihSX0NXIP+FPQQeFE
+AcK0HMMxQhZHhTMidrIKbw/lJVBPhYa+v5guEGcevhEFhgWQxFnQfHgQsIBct+HH
+K3XLfJ+utdGdIzdjp9xCoi2SBBtQwXu4PhvJVgSLL1KbralW6cH/ralYhzC2gfeX
+RfwZVzsrb+RH9JlF/h3x+JejiB03HFyP4HYlmlD4oFT/RJB2I9IyxsOrBr/8+7/z
+rX2SYgJbKdM1o5OaQ2RgXbL6Mv87BK9NQGr5x+PvI/1ry+UPizgN7gr8/g+YnzAx
+3WxSZfmLgb4i4RxYA7qRG4kHAgMBAAGjQjBAMA4GA1UdDwEB/wQEAwIBBjAPBgNV
+HRMBAf8EBTADAQH/MB0GA1UdDgQWBBRqOFsmjd6LWvJPelSDGRjjCDWmujANBgkq
+hkiG9w0BAQUFAAOCAQEAPNV3PdrfibqHDAhUaiBQkr6wQT25JmSDCi/oQMCXKCeC
+MErJk/9q56YAf4lCmtYR5VPOL8zy2gXE/uJQxDqGfczafhAJO5I1KlOy/usrBdls
+XebQ79NqZp4VKIV66IIArB6nCWlWQtNoURi+VJq/REG6Sb4gumlc7rh3zc5sH62D
+lhh9DrUUOYTxKOkto557HnpyWoOzeW/vtPzQCqVYT0bf+215WfKEIlKuD8z7fDvn
+aspHYcN6+NOSBB+4IIThNlQWx0DeO4pz3N/GCUzf7Nr/1FNCocnyYh0igzyXxfkZ
+YiesZSLX0zzG5Y6yU8xJzrww/nsOM5D77dIUkR8Hrw==
+-----END CERTIFICATE-----
+
+# Issuer: O=SECOM Trust Systems CO.,LTD. OU=Security Communication RootCA2
+# Subject: O=SECOM Trust Systems CO.,LTD. OU=Security Communication RootCA2
+# Label: "Security Communication RootCA2"
+# Serial: 0
+# MD5 Fingerprint: 6c:39:7d:a4:0e:55:59:b2:3f:d6:41:b1:12:50:de:43
+# SHA1 Fingerprint: 5f:3b:8c:f2:f8:10:b3:7d:78:b4:ce:ec:19:19:c3:73:34:b9:c7:74
+# SHA256 Fingerprint: 51:3b:2c:ec:b8:10:d4:cd:e5:dd:85:39:1a:df:c6:c2:dd:60:d8:7b:b7:36:d2:b5:21:48:4a:a4:7a:0e:be:f6
+-----BEGIN CERTIFICATE-----
+MIIDdzCCAl+gAwIBAgIBADANBgkqhkiG9w0BAQsFADBdMQswCQYDVQQGEwJKUDEl
+MCMGA1UEChMcU0VDT00gVHJ1c3QgU3lzdGVtcyBDTy4sTFRELjEnMCUGA1UECxMe
+U2VjdXJpdHkgQ29tbXVuaWNhdGlvbiBSb290Q0EyMB4XDTA5MDUyOTA1MDAzOVoX
+DTI5MDUyOTA1MDAzOVowXTELMAkGA1UEBhMCSlAxJTAjBgNVBAoTHFNFQ09NIFRy
+dXN0IFN5c3RlbXMgQ08uLExURC4xJzAlBgNVBAsTHlNlY3VyaXR5IENvbW11bmlj
+YXRpb24gUm9vdENBMjCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBANAV
+OVKxUrO6xVmCxF1SrjpDZYBLx/KWvNs2l9amZIyoXvDjChz335c9S672XewhtUGr
+zbl+dp+++T42NKA7wfYxEUV0kz1XgMX5iZnK5atq1LXaQZAQwdbWQonCv/Q4EpVM
+VAX3NuRFg3sUZdbcDE3R3n4MqzvEFb46VqZab3ZpUql6ucjrappdUtAtCms1FgkQ
+hNBqyjoGADdH5H5XTz+L62e4iKrFvlNVspHEfbmwhRkGeC7bYRr6hfVKkaHnFtWO
+ojnflLhwHyg/i/xAXmODPIMqGplrz95Zajv8bxbXH/1KEOtOghY6rCcMU/Gt1SSw
+awNQwS08Ft1ENCcadfsCAwEAAaNCMEAwHQYDVR0OBBYEFAqFqXdlBZh8QIH4D5cs
+OPEK7DzPMA4GA1UdDwEB/wQEAwIBBjAPBgNVHRMBAf8EBTADAQH/MA0GCSqGSIb3
+DQEBCwUAA4IBAQBMOqNErLlFsceTfsgLCkLfZOoc7llsCLqJX2rKSpWeeo8HxdpF
+coJxDjrSzG+ntKEju/Ykn8sX/oymzsLS28yN/HH8AynBbF0zX2S2ZTuJbxh2ePXc
+okgfGT+Ok+vx+hfuzU7jBBJV1uXk3fs+BXziHV7Gp7yXT2g69ekuCkO2r1dcYmh8
+t/2jioSgrGK+KwmHNPBqAbubKVY8/gA3zyNs8U6qtnRGEmyR7jTV7JqR50S+kDFy
+1UkC9gLl9B/rfNmWVan/7Ir5mUf/NVoCqgTLiluHcSmRvaS0eg29mvVXIwAHIRc/
+SjnRBUkLp7Y3gaVdjKozXoEofKd9J+sAro03
+-----END CERTIFICATE-----
+
+# Issuer: CN=Actalis Authentication Root CA O=Actalis S.p.A./03358520967
+# Subject: CN=Actalis Authentication Root CA O=Actalis S.p.A./03358520967
+# Label: "Actalis Authentication Root CA"
+# Serial: 6271844772424770508
+# MD5 Fingerprint: 69:c1:0d:4f:07:a3:1b:c3:fe:56:3d:04:bc:11:f6:a6
+# SHA1 Fingerprint: f3:73:b3:87:06:5a:28:84:8a:f2:f3:4a:ce:19:2b:dd:c7:8e:9c:ac
+# SHA256 Fingerprint: 55:92:60:84:ec:96:3a:64:b9:6e:2a:be:01:ce:0b:a8:6a:64:fb:fe:bc:c7:aa:b5:af:c1:55:b3:7f:d7:60:66
+-----BEGIN CERTIFICATE-----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+-----END CERTIFICATE-----
+
+# Issuer: CN=Buypass Class 2 Root CA O=Buypass AS-983163327
+# Subject: CN=Buypass Class 2 Root CA O=Buypass AS-983163327
+# Label: "Buypass Class 2 Root CA"
+# Serial: 2
+# MD5 Fingerprint: 46:a7:d2:fe:45:fb:64:5a:a8:59:90:9b:78:44:9b:29
+# SHA1 Fingerprint: 49:0a:75:74:de:87:0a:47:fe:58:ee:f6:c7:6b:eb:c6:0b:12:40:99
+# SHA256 Fingerprint: 9a:11:40:25:19:7c:5b:b9:5d:94:e6:3d:55:cd:43:79:08:47:b6:46:b2:3c:df:11:ad:a4:a0:0e:ff:15:fb:48
+-----BEGIN CERTIFICATE-----
+MIIFWTCCA0GgAwIBAgIBAjANBgkqhkiG9w0BAQsFADBOMQswCQYDVQQGEwJOTzEd
+MBsGA1UECgwUQnV5cGFzcyBBUy05ODMxNjMzMjcxIDAeBgNVBAMMF0J1eXBhc3Mg
+Q2xhc3MgMiBSb290IENBMB4XDTEwMTAyNjA4MzgwM1oXDTQwMTAyNjA4MzgwM1ow
+TjELMAkGA1UEBhMCTk8xHTAbBgNVBAoMFEJ1eXBhc3MgQVMtOTgzMTYzMzI3MSAw
+HgYDVQQDDBdCdXlwYXNzIENsYXNzIDIgUm9vdCBDQTCCAiIwDQYJKoZIhvcNAQEB
+BQADggIPADCCAgoCggIBANfHXvfBB9R3+0Mh9PT1aeTuMgHbo4Yf5FkNuud1g1Lr
+6hxhFUi7HQfKjK6w3Jad6sNgkoaCKHOcVgb/S2TwDCo3SbXlzwx87vFKu3MwZfPV
+L4O2fuPn9Z6rYPnT8Z2SdIrkHJasW4DptfQxh6NR/Md+oW+OU3fUl8FVM5I+GC91
+1K2GScuVr1QGbNgGE41b/+EmGVnAJLqBcXmQRFBoJJRfuLMR8SlBYaNByyM21cHx
+MlAQTn/0hpPshNOOvEu/XAFOBz3cFIqUCqTqc/sLUegTBxj6DvEr0VQVfTzh97QZ
+QmdiXnfgolXsttlpF9U6r0TtSsWe5HonfOV116rLJeffawrbD02TTqigzXsu8lkB
+arcNuAeBfos4GzjmCleZPe4h6KP1DBbdi+w0jpwqHAAVF41og9JwnxgIzRFo1clr
+Us3ERo/ctfPYV3Me6ZQ5BL/T3jjetFPsaRyifsSP5BtwrfKi+fv3FmRmaZ9JUaLi
+FRhnBkp/1Wy1TbMz4GHrXb7pmA8y1x1LPC5aAVKRCfLf6o3YBkBjqhHk/sM3nhRS
+P/TizPJhk9H9Z2vXUq6/aKtAQ6BXNVN48FP4YUIHZMbXb5tMOA1jrGKvNouicwoN
+9SG9dKpN6nIDSdvHXx1iY8f93ZHsM+71bbRuMGjeyNYmsHVee7QHIJihdjK4TWxP
+AgMBAAGjQjBAMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFMmAd+BikoL1Rpzz
+uvdMw964o605MA4GA1UdDwEB/wQEAwIBBjANBgkqhkiG9w0BAQsFAAOCAgEAU18h
+9bqwOlI5LJKwbADJ784g7wbylp7ppHR/ehb8t/W2+xUbP6umwHJdELFx7rxP462s
+A20ucS6vxOOto70MEae0/0qyexAQH6dXQbLArvQsWdZHEIjzIVEpMMpghq9Gqx3t
+OluwlN5E40EIosHsHdb9T7bWR9AUC8rmyrV7d35BH16Dx7aMOZawP5aBQW9gkOLo
++fsicdl9sz1Gv7SEr5AcD48Saq/v7h56rgJKihcrdv6sVIkkLE8/trKnToyokZf7
+KcZ7XC25y2a2t6hbElGFtQl+Ynhw/qlqYLYdDnkM/crqJIByw5c/8nerQyIKx+u2
+DISCLIBrQYoIwOula9+ZEsuK1V6ADJHgJgg2SMX6OBE1/yWDLfJ6v9r9jv6ly0Us
+H8SIU653DtmadsWOLB2jutXsMq7Aqqz30XpN69QH4kj3Io6wpJ9qzo6ysmD0oyLQ
+I+uUWnpp3Q+/QFesa1lQ2aOZ4W7+jQF5JyMV3pKdewlNWudLSDBaGOYKbeaP4NK7
+5t98biGCwWg5TbSYWGZizEqQXsP6JwSxeRV0mcy+rSDeJmAc61ZRpqPq5KM/p/9h
+3PFaTWwyI0PurKju7koSCTxdccK+efrCh2gdC/1cacwG0Jp9VJkqyTkaGa9LKkPz
+Y11aWOIv4x3kqdbQCtCev9eBCfHJxyYNrJgWVqA=
+-----END CERTIFICATE-----
+
+# Issuer: CN=Buypass Class 3 Root CA O=Buypass AS-983163327
+# Subject: CN=Buypass Class 3 Root CA O=Buypass AS-983163327
+# Label: "Buypass Class 3 Root CA"
+# Serial: 2
+# MD5 Fingerprint: 3d:3b:18:9e:2c:64:5a:e8:d5:88:ce:0e:f9:37:c2:ec
+# SHA1 Fingerprint: da:fa:f7:fa:66:84:ec:06:8f:14:50:bd:c7:c2:81:a5:bc:a9:64:57
+# SHA256 Fingerprint: ed:f7:eb:bc:a2:7a:2a:38:4d:38:7b:7d:40:10:c6:66:e2:ed:b4:84:3e:4c:29:b4:ae:1d:5b:93:32:e6:b2:4d
+-----BEGIN CERTIFICATE-----
+MIIFWTCCA0GgAwIBAgIBAjANBgkqhkiG9w0BAQsFADBOMQswCQYDVQQGEwJOTzEd
+MBsGA1UECgwUQnV5cGFzcyBBUy05ODMxNjMzMjcxIDAeBgNVBAMMF0J1eXBhc3Mg
+Q2xhc3MgMyBSb290IENBMB4XDTEwMTAyNjA4Mjg1OFoXDTQwMTAyNjA4Mjg1OFow
+TjELMAkGA1UEBhMCTk8xHTAbBgNVBAoMFEJ1eXBhc3MgQVMtOTgzMTYzMzI3MSAw
+HgYDVQQDDBdCdXlwYXNzIENsYXNzIDMgUm9vdCBDQTCCAiIwDQYJKoZIhvcNAQEB
+BQADggIPADCCAgoCggIBAKXaCpUWUOOV8l6ddjEGMnqb8RB2uACatVI2zSRHsJ8Y
+ZLya9vrVediQYkwiL944PdbgqOkcLNt4EemOaFEVcsfzM4fkoF0LXOBXByow9c3E
+N3coTRiR5r/VUv1xLXA+58bEiuPwKAv0dpihi4dVsjoT/Lc+JzeOIuOoTyrvYLs9
+tznDDgFHmV0ST9tD+leh7fmdvhFHJlsTmKtdFoqwNxxXnUX/iJY2v7vKB3tvh2PX
+0DJq1l1sDPGzbjniazEuOQAnFN44wOwZZoYS6J1yFhNkUsepNxz9gjDthBgd9K5c
+/3ATAOux9TN6S9ZV+AWNS2mw9bMoNlwUxFFzTWsL8TQH2xc519woe2v1n/MuwU8X
+KhDzzMro6/1rqy6any2CbgTUUgGTLT2G/H783+9CHaZr77kgxve9oKeV/afmiSTY
+zIw0bOIjL9kSGiG5VZFvC5F5GQytQIgLcOJ60g7YaEi7ghM5EFjp2CoHxhLbWNvS
+O1UQRwUVZ2J+GGOmRj8JDlQyXr8NYnon74Do29lLBlo3WiXQCBJ31G8JUJc9yB3D
+34xFMFbG02SrZvPAXpacw8Tvw3xrizp5f7NJzz3iiZ+gMEuFuZyUJHmPfWupRWgP
+K9Dx2hzLabjKSWJtyNBjYt1gD1iqj6G8BaVmos8bdrKEZLFMOVLAMLrwjEsCsLa3
+AgMBAAGjQjBAMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEe4zf/lb+74suwv
+Tg75JbCOPGvDMA4GA1UdDwEB/wQEAwIBBjANBgkqhkiG9w0BAQsFAAOCAgEAACAj
+QTUEkMJAYmDv4jVM1z+s4jSQuKFvdvoWFqRINyzpkMLyPPgKn9iB5btb2iUspKdV
+cSQy9sgL8rxq+JOssgfCX5/bzMiKqr5qb+FJEMwx14C7u8jYog5kV+qi9cKpMRXS
+IGrs/CIBKM+GuIAeqcwRpTzyFrNHnfzSgCHEy9BHcEGhyoMZCCxt8l13nIoUE9Q2
+HJLw5QY33KbmkJs4j1xrG0aGQ0JfPgEHU1RdZX33inOhmlRaHylDFCfChQ+1iHsa
+O5S3HWCntZznKWlXWpuTekMwGwPXYshApqr8ZORK15FTAaggiG6cX0S5y2CBNOxv
+033aSF/rtJC8LakcC6wc1aJoIIAE1vyxjy+7SjENSoYc6+I2KSb12tjE8nVhz36u
+dmNKekBlk4f4HoCMhuWG1o8O/FMsYOgWYRqiPkN7zTlgVGr18okmAWiDSKIz6MkE
+kbIRNBE+6tBDGR8Dk5AM/1E9V/RBbuHLoL7ryWPNbczk+DaqaJ3tvV2XcEQNtg41
+3OEMXbugUZTLfhbrES+jkkXITHHZvMmZUldGL1DPvTVp9D0VzgalLA8+9oG6lLvD
+u79leNKGef9JOxqDDPDeeOzI8k1MGt6CKfjBWtrt7uYnXuhF0J0cUahoq0Tj0Itq
+4/g7u9xN12TyUb7mqqta6THuBrxzvxNiCp/HuZc=
+-----END CERTIFICATE-----
+
+# Issuer: CN=T-TeleSec GlobalRoot Class 3 O=T-Systems Enterprise Services GmbH OU=T-Systems Trust Center
+# Subject: CN=T-TeleSec GlobalRoot Class 3 O=T-Systems Enterprise Services GmbH OU=T-Systems Trust Center
+# Label: "T-TeleSec GlobalRoot Class 3"
+# Serial: 1
+# MD5 Fingerprint: ca:fb:40:a8:4e:39:92:8a:1d:fe:8e:2f:c4:27:ea:ef
+# SHA1 Fingerprint: 55:a6:72:3e:cb:f2:ec:cd:c3:23:74:70:19:9d:2a:be:11:e3:81:d1
+# SHA256 Fingerprint: fd:73:da:d3:1c:64:4f:f1:b4:3b:ef:0c:cd:da:96:71:0b:9c:d9:87:5e:ca:7e:31:70:7a:f3:e9:6d:52:2b:bd
+-----BEGIN CERTIFICATE-----
+MIIDwzCCAqugAwIBAgIBATANBgkqhkiG9w0BAQsFADCBgjELMAkGA1UEBhMCREUx
+KzApBgNVBAoMIlQtU3lzdGVtcyBFbnRlcnByaXNlIFNlcnZpY2VzIEdtYkgxHzAd
+BgNVBAsMFlQtU3lzdGVtcyBUcnVzdCBDZW50ZXIxJTAjBgNVBAMMHFQtVGVsZVNl
+YyBHbG9iYWxSb290IENsYXNzIDMwHhcNMDgxMDAxMTAyOTU2WhcNMzMxMDAxMjM1
+OTU5WjCBgjELMAkGA1UEBhMCREUxKzApBgNVBAoMIlQtU3lzdGVtcyBFbnRlcnBy
+aXNlIFNlcnZpY2VzIEdtYkgxHzAdBgNVBAsMFlQtU3lzdGVtcyBUcnVzdCBDZW50
+ZXIxJTAjBgNVBAMMHFQtVGVsZVNlYyBHbG9iYWxSb290IENsYXNzIDMwggEiMA0G
+CSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQC9dZPwYiJvJK7genasfb3ZJNW4t/zN
+8ELg63iIVl6bmlQdTQyK9tPPcPRStdiTBONGhnFBSivwKixVA9ZIw+A5OO3yXDw/
+RLyTPWGrTs0NvvAgJ1gORH8EGoel15YUNpDQSXuhdfsaa3Ox+M6pCSzyU9XDFES4
+hqX2iys52qMzVNn6chr3IhUciJFrf2blw2qAsCTz34ZFiP0Zf3WHHx+xGwpzJFu5
+ZeAsVMhg02YXP+HMVDNzkQI6pn97djmiH5a2OK61yJN0HZ65tOVgnS9W0eDrXltM
+EnAMbEQgqxHY9Bn20pxSN+f6tsIxO0rUFJmtxxr1XV/6B7h8DR/Wgx6zAgMBAAGj
+QjBAMA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgEGMB0GA1UdDgQWBBS1
+A/d2O2GCahKqGFPrAyGUv/7OyjANBgkqhkiG9w0BAQsFAAOCAQEAVj3vlNW92nOy
+WL6ukK2YJ5f+AbGwUgC4TeQbIXQbfsDuXmkqJa9c1h3a0nnJ85cp4IaH3gRZD/FZ
+1GSFS5mvJQQeyUapl96Cshtwn5z2r3Ex3XsFpSzTucpH9sry9uetuUg/vBa3wW30
+6gmv7PO15wWeph6KU1HWk4HMdJP2udqmJQV0eVp+QD6CSyYRMG7hP0HHRwA11fXT
+91Q+gT3aSWqas+8QPebrb9HIIkfLzM8BMZLZGOMivgkeGj5asuRrDFR6fUNOuIml
+e9eiPZaGzPImNC1qkp2aGtAw4l1OBLBfiyB+d8E9lYLRRpo7PHi4b6HQDWSieB4p
+TpPDpFQUWw==
+-----END CERTIFICATE-----
+
+# Issuer: CN=D-TRUST Root Class 3 CA 2 2009 O=D-Trust GmbH
+# Subject: CN=D-TRUST Root Class 3 CA 2 2009 O=D-Trust GmbH
+# Label: "D-TRUST Root Class 3 CA 2 2009"
+# Serial: 623603
+# MD5 Fingerprint: cd:e0:25:69:8d:47:ac:9c:89:35:90:f7:fd:51:3d:2f
+# SHA1 Fingerprint: 58:e8:ab:b0:36:15:33:fb:80:f7:9b:1b:6d:29:d3:ff:8d:5f:00:f0
+# SHA256 Fingerprint: 49:e7:a4:42:ac:f0:ea:62:87:05:00:54:b5:25:64:b6:50:e4:f4:9e:42:e3:48:d6:aa:38:e0:39:e9:57:b1:c1
+-----BEGIN CERTIFICATE-----
+MIIEMzCCAxugAwIBAgIDCYPzMA0GCSqGSIb3DQEBCwUAME0xCzAJBgNVBAYTAkRF
+MRUwEwYDVQQKDAxELVRydXN0IEdtYkgxJzAlBgNVBAMMHkQtVFJVU1QgUm9vdCBD
+bGFzcyAzIENBIDIgMjAwOTAeFw0wOTExMDUwODM1NThaFw0yOTExMDUwODM1NTha
+ME0xCzAJBgNVBAYTAkRFMRUwEwYDVQQKDAxELVRydXN0IEdtYkgxJzAlBgNVBAMM
+HkQtVFJVU1QgUm9vdCBDbGFzcyAzIENBIDIgMjAwOTCCASIwDQYJKoZIhvcNAQEB
+BQADggEPADCCAQoCggEBANOySs96R+91myP6Oi/WUEWJNTrGa9v+2wBoqOADER03
+UAifTUpolDWzU9GUY6cgVq/eUXjsKj3zSEhQPgrfRlWLJ23DEE0NkVJD2IfgXU42
+tSHKXzlABF9bfsyjxiupQB7ZNoTWSPOSHjRGICTBpFGOShrvUD9pXRl/RcPHAY9R
+ySPocq60vFYJfxLLHLGvKZAKyVXMD9O0Gu1HNVpK7ZxzBCHQqr0ME7UAyiZsxGsM
+lFqVlNpQmvH/pStmMaTJOKDfHR+4CS7zp+hnUquVH+BGPtikw8paxTGA6Eian5Rp
+/hnd2HN8gcqW3o7tszIFZYQ05ub9VxC1X3a/L7AQDcUCAwEAAaOCARowggEWMA8G
+A1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFP3aFMSfMN4hvR5COfyrYyNJ4PGEMA4G
+A1UdDwEB/wQEAwIBBjCB0wYDVR0fBIHLMIHIMIGAoH6gfIZ6bGRhcDovL2RpcmVj
+dG9yeS5kLXRydXN0Lm5ldC9DTj1ELVRSVVNUJTIwUm9vdCUyMENsYXNzJTIwMyUy
+MENBJTIwMiUyMDIwMDksTz1ELVRydXN0JTIwR21iSCxDPURFP2NlcnRpZmljYXRl
+cmV2b2NhdGlvbmxpc3QwQ6BBoD+GPWh0dHA6Ly93d3cuZC10cnVzdC5uZXQvY3Js
+L2QtdHJ1c3Rfcm9vdF9jbGFzc18zX2NhXzJfMjAwOS5jcmwwDQYJKoZIhvcNAQEL
+BQADggEBAH+X2zDI36ScfSF6gHDOFBJpiBSVYEQBrLLpME+bUMJm2H6NMLVwMeni
+acfzcNsgFYbQDfC+rAF1hM5+n02/t2A7nPPKHeJeaNijnZflQGDSNiH+0LS4F9p0
+o3/U37CYAqxva2ssJSRyoWXuJVrl5jLn8t+rSfrzkGkj2wTZ51xY/GXUl77M/C4K
+zCUqNQT4YJEVdT1B/yMfGchs64JTBKbkTCJNjYy6zltz7GRUUG3RnFX7acM2w4y8
+PIWmawomDeCTmGCufsYkl4phX5GOZpIJhzbNi5stPvZR1FDUWSi9g/LMKHtThm3Y
+Johw1+qRzT65ysCQblrGXnRl11z+o+I=
+-----END CERTIFICATE-----
+
+# Issuer: CN=D-TRUST Root Class 3 CA 2 EV 2009 O=D-Trust GmbH
+# Subject: CN=D-TRUST Root Class 3 CA 2 EV 2009 O=D-Trust GmbH
+# Label: "D-TRUST Root Class 3 CA 2 EV 2009"
+# Serial: 623604
+# MD5 Fingerprint: aa:c6:43:2c:5e:2d:cd:c4:34:c0:50:4f:11:02:4f:b6
+# SHA1 Fingerprint: 96:c9:1b:0b:95:b4:10:98:42:fa:d0:d8:22:79:fe:60:fa:b9:16:83
+# SHA256 Fingerprint: ee:c5:49:6b:98:8c:e9:86:25:b9:34:09:2e:ec:29:08:be:d0:b0:f3:16:c2:d4:73:0c:84:ea:f1:f3:d3:48:81
+-----BEGIN CERTIFICATE-----
+MIIEQzCCAyugAwIBAgIDCYP0MA0GCSqGSIb3DQEBCwUAMFAxCzAJBgNVBAYTAkRF
+MRUwEwYDVQQKDAxELVRydXN0IEdtYkgxKjAoBgNVBAMMIUQtVFJVU1QgUm9vdCBD
+bGFzcyAzIENBIDIgRVYgMjAwOTAeFw0wOTExMDUwODUwNDZaFw0yOTExMDUwODUw
+NDZaMFAxCzAJBgNVBAYTAkRFMRUwEwYDVQQKDAxELVRydXN0IEdtYkgxKjAoBgNV
+BAMMIUQtVFJVU1QgUm9vdCBDbGFzcyAzIENBIDIgRVYgMjAwOTCCASIwDQYJKoZI
+hvcNAQEBBQADggEPADCCAQoCggEBAJnxhDRwui+3MKCOvXwEz75ivJn9gpfSegpn
+ljgJ9hBOlSJzmY3aFS3nBfwZcyK3jpgAvDw9rKFs+9Z5JUut8Mxk2og+KbgPCdM0
+3TP1YtHhzRnp7hhPTFiu4h7WDFsVWtg6uMQYZB7jM7K1iXdODL/ZlGsTl28So/6Z
+qQTMFexgaDbtCHu39b+T7WYxg4zGcTSHThfqr4uRjRxWQa4iN1438h3Z0S0NL2lR
+p75mpoo6Kr3HGrHhFPC+Oh25z1uxav60sUYgovseO3Dvk5h9jHOW8sXvhXCtKSb8
+HgQ+HKDYD8tSg2J87otTlZCpV6LqYQXY+U3EJ/pure3511H3a6UCAwEAAaOCASQw
+ggEgMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFNOUikxiEyoZLsyvcop9Ntea
+HNxnMA4GA1UdDwEB/wQEAwIBBjCB3QYDVR0fBIHVMIHSMIGHoIGEoIGBhn9sZGFw
+Oi8vZGlyZWN0b3J5LmQtdHJ1c3QubmV0L0NOPUQtVFJVU1QlMjBSb290JTIwQ2xh
+c3MlMjAzJTIwQ0ElMjAyJTIwRVYlMjAyMDA5LE89RC1UcnVzdCUyMEdtYkgsQz1E
+RT9jZXJ0aWZpY2F0ZXJldm9jYXRpb25saXN0MEagRKBChkBodHRwOi8vd3d3LmQt
+dHJ1c3QubmV0L2NybC9kLXRydXN0X3Jvb3RfY2xhc3NfM19jYV8yX2V2XzIwMDku
+Y3JsMA0GCSqGSIb3DQEBCwUAA4IBAQA07XtaPKSUiO8aEXUHL7P+PPoeUSbrh/Yp
+3uDx1MYkCenBz1UbtDDZzhr+BlGmFaQt77JLvyAoJUnRpjZ3NOhk31KxEcdzes05
+nsKtjHEh8lprr988TlWvsoRlFIm5d8sqMb7Po23Pb0iUMkZv53GMoKaEGTcH8gNF
+CSuGdXzfX2lXANtu2KZyIktQ1HWYVt+3GP9DQ1CuekR78HlR10M9p9OB0/DJT7na
+xpeG0ILD5EJt/rDiZE4OJudANCa1CInXCGNjOCd1HjPqbqjdn5lPdE2BiYBL3ZqX
+KVwvvoFBuYz/6n1gBp7N1z3TLqMVvKjmJuVvw9y4AyHqnxbxLFS1
+-----END CERTIFICATE-----
+
+# Issuer: CN=CA Disig Root R2 O=Disig a.s.
+# Subject: CN=CA Disig Root R2 O=Disig a.s.
+# Label: "CA Disig Root R2"
+# Serial: 10572350602393338211
+# MD5 Fingerprint: 26:01:fb:d8:27:a7:17:9a:45:54:38:1a:43:01:3b:03
+# SHA1 Fingerprint: b5:61:eb:ea:a4:de:e4:25:4b:69:1a:98:a5:57:47:c2:34:c7:d9:71
+# SHA256 Fingerprint: e2:3d:4a:03:6d:7b:70:e9:f5:95:b1:42:20:79:d2:b9:1e:df:bb:1f:b6:51:a0:63:3e:aa:8a:9d:c5:f8:07:03
+-----BEGIN CERTIFICATE-----
+MIIFaTCCA1GgAwIBAgIJAJK4iNuwisFjMA0GCSqGSIb3DQEBCwUAMFIxCzAJBgNV
+BAYTAlNLMRMwEQYDVQQHEwpCcmF0aXNsYXZhMRMwEQYDVQQKEwpEaXNpZyBhLnMu
+MRkwFwYDVQQDExBDQSBEaXNpZyBSb290IFIyMB4XDTEyMDcxOTA5MTUzMFoXDTQy
+MDcxOTA5MTUzMFowUjELMAkGA1UEBhMCU0sxEzARBgNVBAcTCkJyYXRpc2xhdmEx
+EzARBgNVBAoTCkRpc2lnIGEucy4xGTAXBgNVBAMTEENBIERpc2lnIFJvb3QgUjIw
+ggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQCio8QACdaFXS1tFPbCw3Oe
+NcJxVX6B+6tGUODBfEl45qt5WDza/3wcn9iXAng+a0EE6UG9vgMsRfYvZNSrXaNH
+PWSb6WiaxswbP7q+sos0Ai6YVRn8jG+qX9pMzk0DIaPY0jSTVpbLTAwAFjxfGs3I
+x2ymrdMxp7zo5eFm1tL7A7RBZckQrg4FY8aAamkw/dLukO8NJ9+flXP04SXabBbe
+QTg06ov80egEFGEtQX6sx3dOy1FU+16SGBsEWmjGycT6txOgmLcRK7fWV8x8nhfR
+yyX+hk4kLlYMeE2eARKmK6cBZW58Yh2EhN/qwGu1pSqVg8NTEQxzHQuyRpDRQjrO
+QG6Vrf/GlK1ul4SOfW+eioANSW1z4nuSHsPzwfPrLgVv2RvPN3YEyLRa5Beny912
+H9AZdugsBbPWnDTYltxhh5EF5EQIM8HauQhl1K6yNg3ruji6DOWbnuuNZt2Zz9aJ
+QfYEkoopKW1rOhzndX0CcQ7zwOe9yxndnWCywmZgtrEE7snmhrmaZkCo5xHtgUUD
+i/ZnWejBBhG93c+AAk9lQHhcR1DIm+YfgXvkRKhbhZri3lrVx/k6RGZL5DJUfORs
+nLMOPReisjQS1n6yqEm70XooQL6iFh/f5DcfEXP7kAplQ6INfPgGAVUzfbANuPT1
+rqVCV3w2EYx7XsQDnYx5nQIDAQABo0IwQDAPBgNVHRMBAf8EBTADAQH/MA4GA1Ud
+DwEB/wQEAwIBBjAdBgNVHQ4EFgQUtZn4r7CU9eMg1gqtzk5WpC5uQu0wDQYJKoZI
+hvcNAQELBQADggIBACYGXnDnZTPIgm7ZnBc6G3pmsgH2eDtpXi/q/075KMOYKmFM
+tCQSin1tERT3nLXK5ryeJ45MGcipvXrA1zYObYVybqjGom32+nNjf7xueQgcnYqf
+GopTpti72TVVsRHFqQOzVju5hJMiXn7B9hJSi+osZ7z+Nkz1uM/Rs0mSO9MpDpkb
+lvdhuDvEK7Z4bLQjb/D907JedR+Zlais9trhxTF7+9FGs9K8Z7RiVLoJ92Owk6Ka
++elSLotgEqv89WBW7xBci8QaQtyDW2QOy7W81k/BfDxujRNt+3vrMNDcTa/F1bal
+TFtxyegxvug4BkihGuLq0t4SOVga/4AOgnXmt8kHbA7v/zjxmHHEt38OFdAlab0i
+nSvtBfZGR6ztwPDUO+Ls7pZbkBNOHlY667DvlruWIxG68kOGdGSVyCh13x01utI3
+gzhTODY7z2zp+WsO0PsE6E9312UBeIYMej4hYvF/Y3EMyZ9E26gnonW+boE+18Dr
+G5gPcFw0sorMwIUY6256s/daoQe/qUKS82Ail+QUoQebTnbAjn39pCXHR+3/H3Os
+zMOl6W8KjptlwlCFtaOgUxLMVYdh84GuEEZhvUQhuMI9dM9+JDX6HAcOmz0iyu8x
+L4ysEr3vQCj8KWefshNPZiTEUxnpHikV7+ZtsH8tZ/3zbBt1RqPlShfppNcL
+-----END CERTIFICATE-----
+
+# Issuer: CN=ACCVRAIZ1 O=ACCV OU=PKIACCV
+# Subject: CN=ACCVRAIZ1 O=ACCV OU=PKIACCV
+# Label: "ACCVRAIZ1"
+# Serial: 6828503384748696800
+# MD5 Fingerprint: d0:a0:5a:ee:05:b6:09:94:21:a1:7d:f1:b2:29:82:02
+# SHA1 Fingerprint: 93:05:7a:88:15:c6:4f:ce:88:2f:fa:91:16:52:28:78:bc:53:64:17
+# SHA256 Fingerprint: 9a:6e:c0:12:e1:a7:da:9d:be:34:19:4d:47:8a:d7:c0:db:18:22:fb:07:1d:f1:29:81:49:6e:d1:04:38:41:13
+-----BEGIN CERTIFICATE-----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+-----END CERTIFICATE-----
+
+# Issuer: CN=TWCA Global Root CA O=TAIWAN-CA OU=Root CA
+# Subject: CN=TWCA Global Root CA O=TAIWAN-CA OU=Root CA
+# Label: "TWCA Global Root CA"
+# Serial: 3262
+# MD5 Fingerprint: f9:03:7e:cf:e6:9e:3c:73:7a:2a:90:07:69:ff:2b:96
+# SHA1 Fingerprint: 9c:bb:48:53:f6:a4:f6:d3:52:a4:e8:32:52:55:60:13:f5:ad:af:65
+# SHA256 Fingerprint: 59:76:90:07:f7:68:5d:0f:cd:50:87:2f:9f:95:d5:75:5a:5b:2b:45:7d:81:f3:69:2b:61:0a:98:67:2f:0e:1b
+-----BEGIN CERTIFICATE-----
+MIIFQTCCAymgAwIBAgICDL4wDQYJKoZIhvcNAQELBQAwUTELMAkGA1UEBhMCVFcx
+EjAQBgNVBAoTCVRBSVdBTi1DQTEQMA4GA1UECxMHUm9vdCBDQTEcMBoGA1UEAxMT
+VFdDQSBHbG9iYWwgUm9vdCBDQTAeFw0xMjA2MjcwNjI4MzNaFw0zMDEyMzExNTU5
+NTlaMFExCzAJBgNVBAYTAlRXMRIwEAYDVQQKEwlUQUlXQU4tQ0ExEDAOBgNVBAsT
+B1Jvb3QgQ0ExHDAaBgNVBAMTE1RXQ0EgR2xvYmFsIFJvb3QgQ0EwggIiMA0GCSqG
+SIb3DQEBAQUAA4ICDwAwggIKAoICAQCwBdvI64zEbooh745NnHEKH1Jw7W2CnJfF
+10xORUnLQEK1EjRsGcJ0pDFfhQKX7EMzClPSnIyOt7h52yvVavKOZsTuKwEHktSz
+0ALfUPZVr2YOy+BHYC8rMjk1Ujoog/h7FsYYuGLWRyWRzvAZEk2tY/XTP3VfKfCh
+MBwqoJimFb3u/Rk28OKRQ4/6ytYQJ0lM793B8YVwm8rqqFpD/G2Gb3PpN0Wp8DbH
+zIh1HrtsBv+baz4X7GGqcXzGHaL3SekVtTzWoWH1EfcFbx39Eb7QMAfCKbAJTibc
+46KokWofwpFFiFzlmLhxpRUZyXx1EcxwdE8tmx2RRP1WKKD+u4ZqyPpcC1jcxkt2
+yKsi2XMPpfRaAok/T54igu6idFMqPVMnaR1sjjIsZAAmY2E2TqNGtz99sy2sbZCi
+laLOz9qC5wc0GZbpuCGqKX6mOL6OKUohZnkfs8O1CWfe1tQHRvMq2uYiN2DLgbYP
+oA/pyJV/v1WRBXrPPRXAb94JlAGD1zQbzECl8LibZ9WYkTunhHiVJqRaCPgrdLQA
+BDzfuBSO6N+pjWxnkjMdwLfS7JLIvgm/LCkFbwJrnu+8vyq8W8BQj0FwcYeyTbcE
+qYSjMq+u7msXi7Kx/mzhkIyIqJdIzshNy/MGz19qCkKxHh53L46g5pIOBvwFItIm
+4TFRfTLcDwIDAQABoyMwITAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/BAUwAwEB
+/zANBgkqhkiG9w0BAQsFAAOCAgEAXzSBdu+WHdXltdkCY4QWwa6gcFGn90xHNcgL
+1yg9iXHZqjNB6hQbbCEAwGxCGX6faVsgQt+i0trEfJdLjbDorMjupWkEmQqSpqsn
+LhpNgb+E1HAerUf+/UqdM+DyucRFCCEK2mlpc3INvjT+lIutwx4116KD7+U4x6WF
+H6vPNOw/KP4M8VeGTslV9xzU2KV9Bnpv1d8Q34FOIWWxtuEXeZVFBs5fzNxGiWNo
+RI2T9GRwoD2dKAXDOXC4Ynsg/eTb6QihuJ49CcdP+yz4k3ZB3lLg4VfSnQO8d57+
+nile98FRYB/e2guyLXW3Q0iT5/Z5xoRdgFlglPx4mI88k1HtQJAH32RjJMtOcQWh
+15QaiDLxInQirqWm2BJpTGCjAu4r7NRjkgtevi92a6O2JryPA9gK8kxkRr05YuWW
+6zRjESjMlfGt7+/cgFhI6Uu46mWs6fyAtbXIRfmswZ/ZuepiiI7E8UuDEq3mi4TW
+nsLrgxifarsbJGAzcMzs9zLzXNl5fe+epP7JI8Mk7hWSsT2RTyaGvWZzJBPqpK5j
+wa19hAM8EHiGG3njxPPyBJUgriOCxLM6AGK/5jYk4Ve6xx6QddVfP5VhK8E7zeWz
+aGHQRiapIVJpLesux+t3zqY6tQMzT3bR51xUAV3LePTJDL/PEo4XLSNolOer/qmy
+KwbQBM0=
+-----END CERTIFICATE-----
+
+# Issuer: CN=TeliaSonera Root CA v1 O=TeliaSonera
+# Subject: CN=TeliaSonera Root CA v1 O=TeliaSonera
+# Label: "TeliaSonera Root CA v1"
+# Serial: 199041966741090107964904287217786801558
+# MD5 Fingerprint: 37:41:49:1b:18:56:9a:26:f5:ad:c2:66:fb:40:a5:4c
+# SHA1 Fingerprint: 43:13:bb:96:f1:d5:86:9b:c1:4e:6a:92:f6:cf:f6:34:69:87:82:37
+# SHA256 Fingerprint: dd:69:36:fe:21:f8:f0:77:c1:23:a1:a5:21:c1:22:24:f7:22:55:b7:3e:03:a7:26:06:93:e8:a2:4b:0f:a3:89
+-----BEGIN CERTIFICATE-----
+MIIFODCCAyCgAwIBAgIRAJW+FqD3LkbxezmCcvqLzZYwDQYJKoZIhvcNAQEFBQAw
+NzEUMBIGA1UECgwLVGVsaWFTb25lcmExHzAdBgNVBAMMFlRlbGlhU29uZXJhIFJv
+b3QgQ0EgdjEwHhcNMDcxMDE4MTIwMDUwWhcNMzIxMDE4MTIwMDUwWjA3MRQwEgYD
+VQQKDAtUZWxpYVNvbmVyYTEfMB0GA1UEAwwWVGVsaWFTb25lcmEgUm9vdCBDQSB2
+MTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAMK+6yfwIaPzaSZVfp3F
+VRaRXP3vIb9TgHot0pGMYzHw7CTww6XScnwQbfQ3t+XmfHnqjLWCi65ItqwA3GV1
+7CpNX8GH9SBlK4GoRz6JI5UwFpB/6FcHSOcZrr9FZ7E3GwYq/t75rH2D+1665I+X
+Z75Ljo1kB1c4VWk0Nj0TSO9P4tNmHqTPGrdeNjPUtAa9GAH9d4RQAEX1jF3oI7x+
+/jXh7VB7qTCNGdMJjmhnXb88lxhTuylixcpecsHHltTbLaC0H2kD7OriUPEMPPCs
+81Mt8Bz17Ww5OXOAFshSsCPN4D7c3TxHoLs1iuKYaIu+5b9y7tL6pe0S7fyYGKkm
+dtwoSxAgHNN/Fnct7W+A90m7UwW7XWjH1Mh1Fj+JWov3F0fUTPHSiXk+TT2YqGHe
+Oh7S+F4D4MHJHIzTjU3TlTazN19jY5szFPAtJmtTfImMMsJu7D0hADnJoWjiUIMu
+sDor8zagrC/kb2HCUQk5PotTubtn2txTuXZZNp1D5SDgPTJghSJRt8czu90VL6R4
+pgd7gUY2BIbdeTXHlSw7sKMXNeVzH7RcWe/a6hBle3rQf5+ztCo3O3CLm1u5K7fs
+slESl1MpWtTwEhDcTwK7EpIvYtQ/aUN8Ddb8WHUBiJ1YFkveupD/RwGJBmr2X7KQ
+arMCpgKIv7NHfirZ1fpoeDVNAgMBAAGjPzA9MA8GA1UdEwEB/wQFMAMBAf8wCwYD
+VR0PBAQDAgEGMB0GA1UdDgQWBBTwj1k4ALP1j5qWDNXr+nuqF+gTEjANBgkqhkiG
+9w0BAQUFAAOCAgEAvuRcYk4k9AwI//DTDGjkk0kiP0Qnb7tt3oNmzqjMDfz1mgbl
+dxSR651Be5kqhOX//CHBXfDkH1e3damhXwIm/9fH907eT/j3HEbAek9ALCI18Bmx
+0GtnLLCo4MBANzX2hFxc469CeP6nyQ1Q6g2EdvZR74NTxnr/DlZJLo961gzmJ1Tj
+TQpgcmLNkQfWpb/ImWvtxBnmq0wROMVvMeJuScg/doAmAyYp4Db29iBT4xdwNBed
+Y2gea+zDTYa4EzAvXUYNR0PVG6pZDrlcjQZIrXSHX8f8MVRBE+LHIQ6e4B4N4cB7
+Q4WQxYpYxmUKeFfyxiMPAdkgS94P+5KFdSpcc41teyWRyu5FrgZLAMzTsVlQ2jqI
+OylDRl6XK1TOU2+NSueW+r9xDkKLfP0ooNBIytrEgUy7onOTJsjrDNYmiLbAJM+7
+vVvrdX3pCI6GMyx5dwlppYn8s3CQh3aP0yK7Qs69cwsgJirQmz1wHiRszYd2qReW
+t88NkvuOGKmYSdGe/mBEciG5Ge3C9THxOUiIkCR1VBatzvT4aRRkOfujuLpwQMcn
+HL/EVlP6Y2XQ8xwOFvVrhlhNGNTkDY6lnVuR3HYkUD/GKvvZt5y11ubQ2egZixVx
+SK236thZiNSQvxaz2emsWWFUyBy6ysHK4bkgTI86k4mloMy/0/Z1pHWWbVY=
+-----END CERTIFICATE-----
+
+# Issuer: CN=T-TeleSec GlobalRoot Class 2 O=T-Systems Enterprise Services GmbH OU=T-Systems Trust Center
+# Subject: CN=T-TeleSec GlobalRoot Class 2 O=T-Systems Enterprise Services GmbH OU=T-Systems Trust Center
+# Label: "T-TeleSec GlobalRoot Class 2"
+# Serial: 1
+# MD5 Fingerprint: 2b:9b:9e:e4:7b:6c:1f:00:72:1a:cc:c1:77:79:df:6a
+# SHA1 Fingerprint: 59:0d:2d:7d:88:4f:40:2e:61:7e:a5:62:32:17:65:cf:17:d8:94:e9
+# SHA256 Fingerprint: 91:e2:f5:78:8d:58:10:eb:a7:ba:58:73:7d:e1:54:8a:8e:ca:cd:01:45:98:bc:0b:14:3e:04:1b:17:05:25:52
+-----BEGIN CERTIFICATE-----
+MIIDwzCCAqugAwIBAgIBATANBgkqhkiG9w0BAQsFADCBgjELMAkGA1UEBhMCREUx
+KzApBgNVBAoMIlQtU3lzdGVtcyBFbnRlcnByaXNlIFNlcnZpY2VzIEdtYkgxHzAd
+BgNVBAsMFlQtU3lzdGVtcyBUcnVzdCBDZW50ZXIxJTAjBgNVBAMMHFQtVGVsZVNl
+YyBHbG9iYWxSb290IENsYXNzIDIwHhcNMDgxMDAxMTA0MDE0WhcNMzMxMDAxMjM1
+OTU5WjCBgjELMAkGA1UEBhMCREUxKzApBgNVBAoMIlQtU3lzdGVtcyBFbnRlcnBy
+aXNlIFNlcnZpY2VzIEdtYkgxHzAdBgNVBAsMFlQtU3lzdGVtcyBUcnVzdCBDZW50
+ZXIxJTAjBgNVBAMMHFQtVGVsZVNlYyBHbG9iYWxSb290IENsYXNzIDIwggEiMA0G
+CSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCqX9obX+hzkeXaXPSi5kfl82hVYAUd
+AqSzm1nzHoqvNK38DcLZSBnuaY/JIPwhqgcZ7bBcrGXHX+0CfHt8LRvWurmAwhiC
+FoT6ZrAIxlQjgeTNuUk/9k9uN0goOA/FvudocP05l03Sx5iRUKrERLMjfTlH6VJi
+1hKTXrcxlkIF+3anHqP1wvzpesVsqXFP6st4vGCvx9702cu+fjOlbpSD8DT6Iavq
+jnKgP6TeMFvvhk1qlVtDRKgQFRzlAVfFmPHmBiiRqiDFt1MmUUOyCxGVWOHAD3bZ
+wI18gfNycJ5v/hqO2V81xrJvNHy+SE/iWjnX2J14np+GPgNeGYtEotXHAgMBAAGj
+QjBAMA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgEGMB0GA1UdDgQWBBS/
+WSA2AHmgoCJrjNXyYdK4LMuCSjANBgkqhkiG9w0BAQsFAAOCAQEAMQOiYQsfdOhy
+NsZt+U2e+iKo4YFWz827n+qrkRk4r6p8FU3ztqONpfSO9kSpp+ghla0+AGIWiPAC
+uvxhI+YzmzB6azZie60EI4RYZeLbK4rnJVM3YlNfvNoBYimipidx5joifsFvHZVw
+IEoHNN/q/xWA5brXethbdXwFeilHfkCoMRN3zUA7tFFHei4R40cR3p1m0IvVVGb6
+g1XqfMIpiRvpb7PO4gWEyS8+eIVibslfwXhjdFjASBgMmTnrpMwatXlajRWc2BQN
+9noHV8cigwUtPJslJj0Ys6lDfMjIq2SPDqO/nBudMNva0Bkuqjzx+zOAduTNrRlP
+BSeOE6Fuwg==
+-----END CERTIFICATE-----
+
+# Issuer: CN=Atos TrustedRoot 2011 O=Atos
+# Subject: CN=Atos TrustedRoot 2011 O=Atos
+# Label: "Atos TrustedRoot 2011"
+# Serial: 6643877497813316402
+# MD5 Fingerprint: ae:b9:c4:32:4b:ac:7f:5d:66:cc:77:94:bb:2a:77:56
+# SHA1 Fingerprint: 2b:b1:f5:3e:55:0c:1d:c5:f1:d4:e6:b7:6a:46:4b:55:06:02:ac:21
+# SHA256 Fingerprint: f3:56:be:a2:44:b7:a9:1e:b3:5d:53:ca:9a:d7:86:4a:ce:01:8e:2d:35:d5:f8:f9:6d:df:68:a6:f4:1a:a4:74
+-----BEGIN CERTIFICATE-----
+MIIDdzCCAl+gAwIBAgIIXDPLYixfszIwDQYJKoZIhvcNAQELBQAwPDEeMBwGA1UE
+AwwVQXRvcyBUcnVzdGVkUm9vdCAyMDExMQ0wCwYDVQQKDARBdG9zMQswCQYDVQQG
+EwJERTAeFw0xMTA3MDcxNDU4MzBaFw0zMDEyMzEyMzU5NTlaMDwxHjAcBgNVBAMM
+FUF0b3MgVHJ1c3RlZFJvb3QgMjAxMTENMAsGA1UECgwEQXRvczELMAkGA1UEBhMC
+REUwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCVhTuXbyo7LjvPpvMp
+Nb7PGKw+qtn4TaA+Gke5vJrf8v7MPkfoepbCJI419KkM/IL9bcFyYie96mvr54rM
+VD6QUM+A1JX76LWC1BTFtqlVJVfbsVD2sGBkWXppzwO3bw2+yj5vdHLqqjAqc2K+
+SZFhyBH+DgMq92og3AIVDV4VavzjgsG1xZ1kCWyjWZgHJ8cblithdHFsQ/H3NYkQ
+4J7sVaE3IqKHBAUsR320HLliKWYoyrfhk/WklAOZuXCFteZI6o1Q/NnezG8HDt0L
+cp2AMBYHlT8oDv3FdU9T1nSatCQujgKRz3bFmx5VdJx4IbHwLfELn8LVlhgf8FQi
+eowHAgMBAAGjfTB7MB0GA1UdDgQWBBSnpQaxLKYJYO7Rl+lwrrw7GWzbITAPBgNV
+HRMBAf8EBTADAQH/MB8GA1UdIwQYMBaAFKelBrEspglg7tGX6XCuvDsZbNshMBgG
+A1UdIAQRMA8wDQYLKwYBBAGwLQMEAQEwDgYDVR0PAQH/BAQDAgGGMA0GCSqGSIb3
+DQEBCwUAA4IBAQAmdzTblEiGKkGdLD4GkGDEjKwLVLgfuXvTBznk+j57sj1O7Z8j
+vZfza1zv7v1Apt+hk6EKhqzvINB5Ab149xnYJDE0BAGmuhWawyfc2E8PzBhj/5kP
+DpFrdRbhIfzYJsdHt6bPWHJxfrrhTZVHO8mvbaG0weyJ9rQPOLXiZNwlz6bb65pc
+maHFCN795trV1lpFDMS3wrUU77QR/w4VtfX128a961qn8FYiqTxlVMYVqL2Gns2D
+lmh6cYGJ4Qvh6hEbaAjMaZ7snkGeRDImeuKHCnE96+RapNLbxc3G3mB/ufNPRJLv
+KrcYPqcZ2Qt9sTdBQrC6YB3y/gkRsPCHe6ed
+-----END CERTIFICATE-----
+
+# Issuer: CN=QuoVadis Root CA 1 G3 O=QuoVadis Limited
+# Subject: CN=QuoVadis Root CA 1 G3 O=QuoVadis Limited
+# Label: "QuoVadis Root CA 1 G3"
+# Serial: 687049649626669250736271037606554624078720034195
+# MD5 Fingerprint: a4:bc:5b:3f:fe:37:9a:fa:64:f0:e2:fa:05:3d:0b:ab
+# SHA1 Fingerprint: 1b:8e:ea:57:96:29:1a:c9:39:ea:b8:0a:81:1a:73:73:c0:93:79:67
+# SHA256 Fingerprint: 8a:86:6f:d1:b2:76:b5:7e:57:8e:92:1c:65:82:8a:2b:ed:58:e9:f2:f2:88:05:41:34:b7:f1:f4:bf:c9:cc:74
+-----BEGIN CERTIFICATE-----
+MIIFYDCCA0igAwIBAgIUeFhfLq0sGUvjNwc1NBMotZbUZZMwDQYJKoZIhvcNAQEL
+BQAwSDELMAkGA1UEBhMCQk0xGTAXBgNVBAoTEFF1b1ZhZGlzIExpbWl0ZWQxHjAc
+BgNVBAMTFVF1b1ZhZGlzIFJvb3QgQ0EgMSBHMzAeFw0xMjAxMTIxNzI3NDRaFw00
+MjAxMTIxNzI3NDRaMEgxCzAJBgNVBAYTAkJNMRkwFwYDVQQKExBRdW9WYWRpcyBM
+aW1pdGVkMR4wHAYDVQQDExVRdW9WYWRpcyBSb290IENBIDEgRzMwggIiMA0GCSqG
+SIb3DQEBAQUAA4ICDwAwggIKAoICAQCgvlAQjunybEC0BJyFuTHK3C3kEakEPBtV
+wedYMB0ktMPvhd6MLOHBPd+C5k+tR4ds7FtJwUrVu4/sh6x/gpqG7D0DmVIB0jWe
+rNrwU8lmPNSsAgHaJNM7qAJGr6Qc4/hzWHa39g6QDbXwz8z6+cZM5cOGMAqNF341
+68Xfuw6cwI2H44g4hWf6Pser4BOcBRiYz5P1sZK0/CPTz9XEJ0ngnjybCKOLXSoh
+4Pw5qlPafX7PGglTvF0FBM+hSo+LdoINofjSxxR3W5A2B4GbPgb6Ul5jxaYA/qXp
+UhtStZI5cgMJYr2wYBZupt0lwgNm3fME0UDiTouG9G/lg6AnhF4EwfWQvTA9xO+o
+abw4m6SkltFi2mnAAZauy8RRNOoMqv8hjlmPSlzkYZqn0ukqeI1RPToV7qJZjqlc
+3sX5kCLliEVx3ZGZbHqfPT2YfF72vhZooF6uCyP8Wg+qInYtyaEQHeTTRCOQiJ/G
+KubX9ZqzWB4vMIkIG1SitZgj7Ah3HJVdYdHLiZxfokqRmu8hqkkWCKi9YSgxyXSt
+hfbZxbGL0eUQMk1fiyA6PEkfM4VZDdvLCXVDaXP7a3F98N/ETH3Goy7IlXnLc6KO
+Tk0k+17kBL5yG6YnLUlamXrXXAkgt3+UuU/xDRxeiEIbEbfnkduebPRq34wGmAOt
+zCjvpUfzUwIDAQABo0IwQDAPBgNVHRMBAf8EBTADAQH/MA4GA1UdDwEB/wQEAwIB
+BjAdBgNVHQ4EFgQUo5fW816iEOGrRZ88F2Q87gFwnMwwDQYJKoZIhvcNAQELBQAD
+ggIBABj6W3X8PnrHX3fHyt/PX8MSxEBd1DKquGrX1RUVRpgjpeaQWxiZTOOtQqOC
+MTaIzen7xASWSIsBx40Bz1szBpZGZnQdT+3Btrm0DWHMY37XLneMlhwqI2hrhVd2
+cDMT/uFPpiN3GPoajOi9ZcnPP/TJF9zrx7zABC4tRi9pZsMbj/7sPtPKlL92CiUN
+qXsCHKnQO18LwIE6PWThv6ctTr1NxNgpxiIY0MWscgKCP6o6ojoilzHdCGPDdRS5
+YCgtW2jgFqlmgiNR9etT2DGbe+m3nUvriBbP+V04ikkwj+3x6xn0dxoxGE1nVGwv
+b2X52z3sIexe9PSLymBlVNFxZPT5pqOBMzYzcfCkeF9OrYMh3jRJjehZrJ3ydlo2
+8hP0r+AJx2EqbPfgna67hkooby7utHnNkDPDs3b69fBsnQGQ+p6Q9pxyz0fawx/k
+NSBT8lTR32GDpgLiJTjehTItXnOQUl1CxM49S+H5GYQd1aJQzEH7QRTDvdbJWqNj
+ZgKAvQU6O0ec7AAmTPWIUb+oI38YB7AL7YsmoWTTYUrrXJ/es69nA7Mf3W1daWhp
+q1467HxpvMc7hU6eFbm0FU/DlXpY18ls6Wy58yljXrQs8C097Vpl4KlbQMJImYFt
+nh8GKjwStIsPm6Ik8KaN1nrgS7ZklmOVhMJKzRwuJIczYOXD
+-----END CERTIFICATE-----
+
+# Issuer: CN=QuoVadis Root CA 2 G3 O=QuoVadis Limited
+# Subject: CN=QuoVadis Root CA 2 G3 O=QuoVadis Limited
+# Label: "QuoVadis Root CA 2 G3"
+# Serial: 390156079458959257446133169266079962026824725800
+# MD5 Fingerprint: af:0c:86:6e:bf:40:2d:7f:0b:3e:12:50:ba:12:3d:06
+# SHA1 Fingerprint: 09:3c:61:f3:8b:8b:dc:7d:55:df:75:38:02:05:00:e1:25:f5:c8:36
+# SHA256 Fingerprint: 8f:e4:fb:0a:f9:3a:4d:0d:67:db:0b:eb:b2:3e:37:c7:1b:f3:25:dc:bc:dd:24:0e:a0:4d:af:58:b4:7e:18:40
+-----BEGIN CERTIFICATE-----
+MIIFYDCCA0igAwIBAgIURFc0JFuBiZs18s64KztbpybwdSgwDQYJKoZIhvcNAQEL
+BQAwSDELMAkGA1UEBhMCQk0xGTAXBgNVBAoTEFF1b1ZhZGlzIExpbWl0ZWQxHjAc
+BgNVBAMTFVF1b1ZhZGlzIFJvb3QgQ0EgMiBHMzAeFw0xMjAxMTIxODU5MzJaFw00
+MjAxMTIxODU5MzJaMEgxCzAJBgNVBAYTAkJNMRkwFwYDVQQKExBRdW9WYWRpcyBM
+aW1pdGVkMR4wHAYDVQQDExVRdW9WYWRpcyBSb290IENBIDIgRzMwggIiMA0GCSqG
+SIb3DQEBAQUAA4ICDwAwggIKAoICAQChriWyARjcV4g/Ruv5r+LrI3HimtFhZiFf
+qq8nUeVuGxbULX1QsFN3vXg6YOJkApt8hpvWGo6t/x8Vf9WVHhLL5hSEBMHfNrMW
+n4rjyduYNM7YMxcoRvynyfDStNVNCXJJ+fKH46nafaF9a7I6JaltUkSs+L5u+9ym
+c5GQYaYDFCDy54ejiK2toIz/pgslUiXnFgHVy7g1gQyjO/Dh4fxaXc6AcW34Sas+
+O7q414AB+6XrW7PFXmAqMaCvN+ggOp+oMiwMzAkd056OXbxMmO7FGmh77FOm6RQ1
+o9/NgJ8MSPsc9PG/Srj61YxxSscfrf5BmrODXfKEVu+lV0POKa2Mq1W/xPtbAd0j
+IaFYAI7D0GoT7RPjEiuA3GfmlbLNHiJuKvhB1PLKFAeNilUSxmn1uIZoL1NesNKq
+IcGY5jDjZ1XHm26sGahVpkUG0CM62+tlXSoREfA7T8pt9DTEceT/AFr2XK4jYIVz
+8eQQsSWu1ZK7E8EM4DnatDlXtas1qnIhO4M15zHfeiFuuDIIfR0ykRVKYnLP43eh
+vNURG3YBZwjgQQvD6xVu+KQZ2aKrr+InUlYrAoosFCT5v0ICvybIxo/gbjh9Uy3l
+7ZizlWNof/k19N+IxWA1ksB8aRxhlRbQ694Lrz4EEEVlWFA4r0jyWbYW8jwNkALG
+cC4BrTwV1wIDAQABo0IwQDAPBgNVHRMBAf8EBTADAQH/MA4GA1UdDwEB/wQEAwIB
+BjAdBgNVHQ4EFgQU7edvdlq/YOxJW8ald7tyFnGbxD0wDQYJKoZIhvcNAQELBQAD
+ggIBAJHfgD9DCX5xwvfrs4iP4VGyvD11+ShdyLyZm3tdquXK4Qr36LLTn91nMX66
+AarHakE7kNQIXLJgapDwyM4DYvmL7ftuKtwGTTwpD4kWilhMSA/ohGHqPHKmd+RC
+roijQ1h5fq7KpVMNqT1wvSAZYaRsOPxDMuHBR//47PERIjKWnML2W2mWeyAMQ0Ga
+W/ZZGYjeVYg3UQt4XAoeo0L9x52ID8DyeAIkVJOviYeIyUqAHerQbj5hLja7NQ4n
+lv1mNDthcnPxFlxHBlRJAHpYErAK74X9sbgzdWqTHBLmYF5vHX/JHyPLhGGfHoJE
++V+tYlUkmlKY7VHnoX6XOuYvHxHaU4AshZ6rNRDbIl9qxV6XU/IyAgkwo1jwDQHV
+csaxfGl7w/U2Rcxhbl5MlMVerugOXou/983g7aEOGzPuVBj+D77vfoRrQ+NwmNtd
+dbINWQeFFSM51vHfqSYP1kjHs6Yi9TM3WpVHn3u6GBVv/9YUZINJ0gpnIdsPNWNg
+KCLjsZWDzYWm3S8P52dSbrsvhXz1SnPnxT7AvSESBT/8twNJAlvIJebiVDj1eYeM
+HVOyToV7BjjHLPj4sHKNJeV3UvQDHEimUF+IIDBu8oJDqz2XhOdT+yHBTw8imoa4
+WSr2Rz0ZiC3oheGe7IUIarFsNMkd7EgrO3jtZsSOeWmD3n+M
+-----END CERTIFICATE-----
+
+# Issuer: CN=QuoVadis Root CA 3 G3 O=QuoVadis Limited
+# Subject: CN=QuoVadis Root CA 3 G3 O=QuoVadis Limited
+# Label: "QuoVadis Root CA 3 G3"
+# Serial: 268090761170461462463995952157327242137089239581
+# MD5 Fingerprint: df:7d:b9:ad:54:6f:68:a1:df:89:57:03:97:43:b0:d7
+# SHA1 Fingerprint: 48:12:bd:92:3c:a8:c4:39:06:e7:30:6d:27:96:e6:a4:cf:22:2e:7d
+# SHA256 Fingerprint: 88:ef:81:de:20:2e:b0:18:45:2e:43:f8:64:72:5c:ea:5f:bd:1f:c2:d9:d2:05:73:07:09:c5:d8:b8:69:0f:46
+-----BEGIN CERTIFICATE-----
+MIIFYDCCA0igAwIBAgIULvWbAiin23r/1aOp7r0DoM8Sah0wDQYJKoZIhvcNAQEL
+BQAwSDELMAkGA1UEBhMCQk0xGTAXBgNVBAoTEFF1b1ZhZGlzIExpbWl0ZWQxHjAc
+BgNVBAMTFVF1b1ZhZGlzIFJvb3QgQ0EgMyBHMzAeFw0xMjAxMTIyMDI2MzJaFw00
+MjAxMTIyMDI2MzJaMEgxCzAJBgNVBAYTAkJNMRkwFwYDVQQKExBRdW9WYWRpcyBM
+aW1pdGVkMR4wHAYDVQQDExVRdW9WYWRpcyBSb290IENBIDMgRzMwggIiMA0GCSqG
+SIb3DQEBAQUAA4ICDwAwggIKAoICAQCzyw4QZ47qFJenMioKVjZ/aEzHs286IxSR
+/xl/pcqs7rN2nXrpixurazHb+gtTTK/FpRp5PIpM/6zfJd5O2YIyC0TeytuMrKNu
+FoM7pmRLMon7FhY4futD4tN0SsJiCnMK3UmzV9KwCoWdcTzeo8vAMvMBOSBDGzXR
+U7Ox7sWTaYI+FrUoRqHe6okJ7UO4BUaKhvVZR74bbwEhELn9qdIoyhA5CcoTNs+c
+ra1AdHkrAj80//ogaX3T7mH1urPnMNA3I4ZyYUUpSFlob3emLoG+B01vr87ERROR
+FHAGjx+f+IdpsQ7vw4kZ6+ocYfx6bIrc1gMLnia6Et3UVDmrJqMz6nWB2i3ND0/k
+A9HvFZcba5DFApCTZgIhsUfei5pKgLlVj7WiL8DWM2fafsSntARE60f75li59wzw
+eyuxwHApw0BiLTtIadwjPEjrewl5qW3aqDCYz4ByA4imW0aucnl8CAMhZa634Ryl
+sSqiMd5mBPfAdOhx3v89WcyWJhKLhZVXGqtrdQtEPREoPHtht+KPZ0/l7DxMYIBp
+VzgeAVuNVejH38DMdyM0SXV89pgR6y3e7UEuFAUCf+D+IOs15xGsIs5XPd7JMG0Q
+A4XN8f+MFrXBsj6IbGB/kE+V9/YtrQE5BwT6dYB9v0lQ7e/JxHwc64B+27bQ3RP+
+ydOc17KXqQIDAQABo0IwQDAPBgNVHRMBAf8EBTADAQH/MA4GA1UdDwEB/wQEAwIB
+BjAdBgNVHQ4EFgQUxhfQvKjqAkPyGwaZXSuQILnXnOQwDQYJKoZIhvcNAQELBQAD
+ggIBADRh2Va1EodVTd2jNTFGu6QHcrxfYWLopfsLN7E8trP6KZ1/AvWkyaiTt3px
+KGmPc+FSkNrVvjrlt3ZqVoAh313m6Tqe5T72omnHKgqwGEfcIHB9UqM+WXzBusnI
+FUBhynLWcKzSt/Ac5IYp8M7vaGPQtSCKFWGafoaYtMnCdvvMujAWzKNhxnQT5Wvv
+oxXqA/4Ti2Tk08HS6IT7SdEQTXlm66r99I0xHnAUrdzeZxNMgRVhvLfZkXdxGYFg
+u/BYpbWcC/ePIlUnwEsBbTuZDdQdm2NnL9DuDcpmvJRPpq3t/O5jrFc/ZSXPsoaP
+0Aj/uHYUbt7lJ+yreLVTubY/6CD50qi+YUbKh4yE8/nxoGibIh6BJpsQBJFxwAYf
+3KDTuVan45gtf4Od34wrnDKOMpTwATwiKp9Dwi7DmDkHOHv8XgBCH/MyJnmDhPbl
+8MFREsALHgQjDFSlTC9JxUrRtm5gDWv8a4uFJGS3iQ6rJUdbPM9+Sb3H6QrG2vd+
+DhcI00iX0HGS8A85PjRqHH3Y8iKuu2n0M7SmSFXRDw4m6Oy2Cy2nhTXN/VnIn9HN
+PlopNLk9hM6xZdRZkZFWdSHBd575euFgndOtBBj0fOtek49TSiIp+EgrPk2GrFt/
+ywaZWWDYWGWVjUTR939+J399roD1B0y2PpxxVJkES/1Y+Zj0
+-----END CERTIFICATE-----
+
+# Issuer: CN=DigiCert Assured ID Root G2 O=DigiCert Inc OU=www.digicert.com
+# Subject: CN=DigiCert Assured ID Root G2 O=DigiCert Inc OU=www.digicert.com
+# Label: "DigiCert Assured ID Root G2"
+# Serial: 15385348160840213938643033620894905419
+# MD5 Fingerprint: 92:38:b9:f8:63:24:82:65:2c:57:33:e6:fe:81:8f:9d
+# SHA1 Fingerprint: a1:4b:48:d9:43:ee:0a:0e:40:90:4f:3c:e0:a4:c0:91:93:51:5d:3f
+# SHA256 Fingerprint: 7d:05:eb:b6:82:33:9f:8c:94:51:ee:09:4e:eb:fe:fa:79:53:a1:14:ed:b2:f4:49:49:45:2f:ab:7d:2f:c1:85
+-----BEGIN CERTIFICATE-----
+MIIDljCCAn6gAwIBAgIQC5McOtY5Z+pnI7/Dr5r0SzANBgkqhkiG9w0BAQsFADBl
+MQswCQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3
+d3cuZGlnaWNlcnQuY29tMSQwIgYDVQQDExtEaWdpQ2VydCBBc3N1cmVkIElEIFJv
+b3QgRzIwHhcNMTMwODAxMTIwMDAwWhcNMzgwMTE1MTIwMDAwWjBlMQswCQYDVQQG
+EwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3d3cuZGlnaWNl
+cnQuY29tMSQwIgYDVQQDExtEaWdpQ2VydCBBc3N1cmVkIElEIFJvb3QgRzIwggEi
+MA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDZ5ygvUj82ckmIkzTz+GoeMVSA
+n61UQbVH35ao1K+ALbkKz3X9iaV9JPrjIgwrvJUXCzO/GU1BBpAAvQxNEP4Htecc
+biJVMWWXvdMX0h5i89vqbFCMP4QMls+3ywPgym2hFEwbid3tALBSfK+RbLE4E9Hp
+EgjAALAcKxHad3A2m67OeYfcgnDmCXRwVWmvo2ifv922ebPynXApVfSr/5Vh88lA
+bx3RvpO704gqu52/clpWcTs/1PPRCv4o76Pu2ZmvA9OPYLfykqGxvYmJHzDNw6Yu
+YjOuFgJ3RFrngQo8p0Quebg/BLxcoIfhG69Rjs3sLPr4/m3wOnyqi+RnlTGNAgMB
+AAGjQjBAMA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgGGMB0GA1UdDgQW
+BBTOw0q5mVXyuNtgv6l+vVa1lzan1jANBgkqhkiG9w0BAQsFAAOCAQEAyqVVjOPI
+QW5pJ6d1Ee88hjZv0p3GeDgdaZaikmkuOGybfQTUiaWxMTeKySHMq2zNixya1r9I
+0jJmwYrA8y8678Dj1JGG0VDjA9tzd29KOVPt3ibHtX2vK0LRdWLjSisCx1BL4Gni
+lmwORGYQRI+tBev4eaymG+g3NJ1TyWGqolKvSnAWhsI6yLETcDbYz+70CjTVW0z9
+B5yiutkBclzzTcHdDrEcDcRjvq30FPuJ7KJBDkzMyFdA0G4Dqs0MjomZmWzwPDCv
+ON9vvKO+KSAnq3T/EyJ43pdSVR6DtVQgA+6uwE9W3jfMw3+qBCe703e4YtsXfJwo
+IhNzbM8m9Yop5w==
+-----END CERTIFICATE-----
+
+# Issuer: CN=DigiCert Assured ID Root G3 O=DigiCert Inc OU=www.digicert.com
+# Subject: CN=DigiCert Assured ID Root G3 O=DigiCert Inc OU=www.digicert.com
+# Label: "DigiCert Assured ID Root G3"
+# Serial: 15459312981008553731928384953135426796
+# MD5 Fingerprint: 7c:7f:65:31:0c:81:df:8d:ba:3e:99:e2:5c:ad:6e:fb
+# SHA1 Fingerprint: f5:17:a2:4f:9a:48:c6:c9:f8:a2:00:26:9f:dc:0f:48:2c:ab:30:89
+# SHA256 Fingerprint: 7e:37:cb:8b:4c:47:09:0c:ab:36:55:1b:a6:f4:5d:b8:40:68:0f:ba:16:6a:95:2d:b1:00:71:7f:43:05:3f:c2
+-----BEGIN CERTIFICATE-----
+MIICRjCCAc2gAwIBAgIQC6Fa+h3foLVJRK/NJKBs7DAKBggqhkjOPQQDAzBlMQsw
+CQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3d3cu
+ZGlnaWNlcnQuY29tMSQwIgYDVQQDExtEaWdpQ2VydCBBc3N1cmVkIElEIFJvb3Qg
+RzMwHhcNMTMwODAxMTIwMDAwWhcNMzgwMTE1MTIwMDAwWjBlMQswCQYDVQQGEwJV
+UzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3d3cuZGlnaWNlcnQu
+Y29tMSQwIgYDVQQDExtEaWdpQ2VydCBBc3N1cmVkIElEIFJvb3QgRzMwdjAQBgcq
+hkjOPQIBBgUrgQQAIgNiAAQZ57ysRGXtzbg/WPuNsVepRC0FFfLvC/8QdJ+1YlJf
+Zn4f5dwbRXkLzMZTCp2NXQLZqVneAlr2lSoOjThKiknGvMYDOAdfVdp+CW7if17Q
+RSAPWXYQ1qAk8C3eNvJsKTmjQjBAMA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/
+BAQDAgGGMB0GA1UdDgQWBBTL0L2p4ZgFUaFNN6KDec6NHSrkhDAKBggqhkjOPQQD
+AwNnADBkAjAlpIFFAmsSS3V0T8gj43DydXLefInwz5FyYZ5eEJJZVrmDxxDnOOlY
+JjZ91eQ0hjkCMHw2U/Aw5WJjOpnitqM7mzT6HtoQknFekROn3aRukswy1vUhZscv
+6pZjamVFkpUBtA==
+-----END CERTIFICATE-----
+
+# Issuer: CN=DigiCert Global Root G2 O=DigiCert Inc OU=www.digicert.com
+# Subject: CN=DigiCert Global Root G2 O=DigiCert Inc OU=www.digicert.com
+# Label: "DigiCert Global Root G2"
+# Serial: 4293743540046975378534879503202253541
+# MD5 Fingerprint: e4:a6:8a:c8:54:ac:52:42:46:0a:fd:72:48:1b:2a:44
+# SHA1 Fingerprint: df:3c:24:f9:bf:d6:66:76:1b:26:80:73:fe:06:d1:cc:8d:4f:82:a4
+# SHA256 Fingerprint: cb:3c:cb:b7:60:31:e5:e0:13:8f:8d:d3:9a:23:f9:de:47:ff:c3:5e:43:c1:14:4c:ea:27:d4:6a:5a:b1:cb:5f
+-----BEGIN CERTIFICATE-----
+MIIDjjCCAnagAwIBAgIQAzrx5qcRqaC7KGSxHQn65TANBgkqhkiG9w0BAQsFADBh
+MQswCQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3
+d3cuZGlnaWNlcnQuY29tMSAwHgYDVQQDExdEaWdpQ2VydCBHbG9iYWwgUm9vdCBH
+MjAeFw0xMzA4MDExMjAwMDBaFw0zODAxMTUxMjAwMDBaMGExCzAJBgNVBAYTAlVT
+MRUwEwYDVQQKEwxEaWdpQ2VydCBJbmMxGTAXBgNVBAsTEHd3dy5kaWdpY2VydC5j
+b20xIDAeBgNVBAMTF0RpZ2lDZXJ0IEdsb2JhbCBSb290IEcyMIIBIjANBgkqhkiG
+9w0BAQEFAAOCAQ8AMIIBCgKCAQEAuzfNNNx7a8myaJCtSnX/RrohCgiN9RlUyfuI
+2/Ou8jqJkTx65qsGGmvPrC3oXgkkRLpimn7Wo6h+4FR1IAWsULecYxpsMNzaHxmx
+1x7e/dfgy5SDN67sH0NO3Xss0r0upS/kqbitOtSZpLYl6ZtrAGCSYP9PIUkY92eQ
+q2EGnI/yuum06ZIya7XzV+hdG82MHauVBJVJ8zUtluNJbd134/tJS7SsVQepj5Wz
+tCO7TG1F8PapspUwtP1MVYwnSlcUfIKdzXOS0xZKBgyMUNGPHgm+F6HmIcr9g+UQ
+vIOlCsRnKPZzFBQ9RnbDhxSJITRNrw9FDKZJobq7nMWxM4MphQIDAQABo0IwQDAP
+BgNVHRMBAf8EBTADAQH/MA4GA1UdDwEB/wQEAwIBhjAdBgNVHQ4EFgQUTiJUIBiV
+5uNu5g/6+rkS7QYXjzkwDQYJKoZIhvcNAQELBQADggEBAGBnKJRvDkhj6zHd6mcY
+1Yl9PMWLSn/pvtsrF9+wX3N3KjITOYFnQoQj8kVnNeyIv/iPsGEMNKSuIEyExtv4
+NeF22d+mQrvHRAiGfzZ0JFrabA0UWTW98kndth/Jsw1HKj2ZL7tcu7XUIOGZX1NG
+Fdtom/DzMNU+MeKNhJ7jitralj41E6Vf8PlwUHBHQRFXGU7Aj64GxJUTFy8bJZ91
+8rGOmaFvE7FBcf6IKshPECBV1/MUReXgRPTqh5Uykw7+U0b6LJ3/iyK5S9kJRaTe
+pLiaWN0bfVKfjllDiIGknibVb63dDcY3fe0Dkhvld1927jyNxF1WW6LZZm6zNTfl
+MrY=
+-----END CERTIFICATE-----
+
+# Issuer: CN=DigiCert Global Root G3 O=DigiCert Inc OU=www.digicert.com
+# Subject: CN=DigiCert Global Root G3 O=DigiCert Inc OU=www.digicert.com
+# Label: "DigiCert Global Root G3"
+# Serial: 7089244469030293291760083333884364146
+# MD5 Fingerprint: f5:5d:a4:50:a5:fb:28:7e:1e:0f:0d:cc:96:57:56:ca
+# SHA1 Fingerprint: 7e:04:de:89:6a:3e:66:6d:00:e6:87:d3:3f:fa:d9:3b:e8:3d:34:9e
+# SHA256 Fingerprint: 31:ad:66:48:f8:10:41:38:c7:38:f3:9e:a4:32:01:33:39:3e:3a:18:cc:02:29:6e:f9:7c:2a:c9:ef:67:31:d0
+-----BEGIN CERTIFICATE-----
+MIICPzCCAcWgAwIBAgIQBVVWvPJepDU1w6QP1atFcjAKBggqhkjOPQQDAzBhMQsw
+CQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3d3cu
+ZGlnaWNlcnQuY29tMSAwHgYDVQQDExdEaWdpQ2VydCBHbG9iYWwgUm9vdCBHMzAe
+Fw0xMzA4MDExMjAwMDBaFw0zODAxMTUxMjAwMDBaMGExCzAJBgNVBAYTAlVTMRUw
+EwYDVQQKEwxEaWdpQ2VydCBJbmMxGTAXBgNVBAsTEHd3dy5kaWdpY2VydC5jb20x
+IDAeBgNVBAMTF0RpZ2lDZXJ0IEdsb2JhbCBSb290IEczMHYwEAYHKoZIzj0CAQYF
+K4EEACIDYgAE3afZu4q4C/sLfyHS8L6+c/MzXRq8NOrexpu80JX28MzQC7phW1FG
+fp4tn+6OYwwX7Adw9c+ELkCDnOg/QW07rdOkFFk2eJ0DQ+4QE2xy3q6Ip6FrtUPO
+Z9wj/wMco+I+o0IwQDAPBgNVHRMBAf8EBTADAQH/MA4GA1UdDwEB/wQEAwIBhjAd
+BgNVHQ4EFgQUs9tIpPmhxdiuNkHMEWNpYim8S8YwCgYIKoZIzj0EAwMDaAAwZQIx
+AK288mw/EkrRLTnDCgmXc/SINoyIJ7vmiI1Qhadj+Z4y3maTD/HMsQmP3Wyr+mt/
+oAIwOWZbwmSNuJ5Q3KjVSaLtx9zRSX8XAbjIho9OjIgrqJqpisXRAL34VOKa5Vt8
+sycX
+-----END CERTIFICATE-----
+
+# Issuer: CN=DigiCert Trusted Root G4 O=DigiCert Inc OU=www.digicert.com
+# Subject: CN=DigiCert Trusted Root G4 O=DigiCert Inc OU=www.digicert.com
+# Label: "DigiCert Trusted Root G4"
+# Serial: 7451500558977370777930084869016614236
+# MD5 Fingerprint: 78:f2:fc:aa:60:1f:2f:b4:eb:c9:37:ba:53:2e:75:49
+# SHA1 Fingerprint: dd:fb:16:cd:49:31:c9:73:a2:03:7d:3f:c8:3a:4d:7d:77:5d:05:e4
+# SHA256 Fingerprint: 55:2f:7b:dc:f1:a7:af:9e:6c:e6:72:01:7f:4f:12:ab:f7:72:40:c7:8e:76:1a:c2:03:d1:d9:d2:0a:c8:99:88
+-----BEGIN CERTIFICATE-----
+MIIFkDCCA3igAwIBAgIQBZsbV56OITLiOQe9p3d1XDANBgkqhkiG9w0BAQwFADBi
+MQswCQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3
+d3cuZGlnaWNlcnQuY29tMSEwHwYDVQQDExhEaWdpQ2VydCBUcnVzdGVkIFJvb3Qg
+RzQwHhcNMTMwODAxMTIwMDAwWhcNMzgwMTE1MTIwMDAwWjBiMQswCQYDVQQGEwJV
+UzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3d3cuZGlnaWNlcnQu
+Y29tMSEwHwYDVQQDExhEaWdpQ2VydCBUcnVzdGVkIFJvb3QgRzQwggIiMA0GCSqG
+SIb3DQEBAQUAA4ICDwAwggIKAoICAQC/5pBzaN675F1KPDAiMGkz7MKnJS7JIT3y
+ithZwuEppz1Yq3aaza57G4QNxDAf8xukOBbrVsaXbR2rsnnyyhHS5F/WBTxSD1If
+xp4VpX6+n6lXFllVcq9ok3DCsrp1mWpzMpTREEQQLt+C8weE5nQ7bXHiLQwb7iDV
+ySAdYyktzuxeTsiT+CFhmzTrBcZe7FsavOvJz82sNEBfsXpm7nfISKhmV1efVFiO
+DCu3T6cw2Vbuyntd463JT17lNecxy9qTXtyOj4DatpGYQJB5w3jHtrHEtWoYOAMQ
+jdjUN6QuBX2I9YI+EJFwq1WCQTLX2wRzKm6RAXwhTNS8rhsDdV14Ztk6MUSaM0C/
+CNdaSaTC5qmgZ92kJ7yhTzm1EVgX9yRcRo9k98FpiHaYdj1ZXUJ2h4mXaXpI8OCi
+EhtmmnTK3kse5w5jrubU75KSOp493ADkRSWJtppEGSt+wJS00mFt6zPZxd9LBADM
+fRyVw4/3IbKyEbe7f/LVjHAsQWCqsWMYRJUadmJ+9oCw++hkpjPRiQfhvbfmQ6QY
+uKZ3AeEPlAwhHbJUKSWJbOUOUlFHdL4mrLZBdd56rF+NP8m800ERElvlEFDrMcXK
+chYiCd98THU/Y+whX8QgUWtvsauGi0/C1kVfnSD8oR7FwI+isX4KJpn15GkvmB0t
+9dmpsh3lGwIDAQABo0IwQDAPBgNVHRMBAf8EBTADAQH/MA4GA1UdDwEB/wQEAwIB
+hjAdBgNVHQ4EFgQU7NfjgtJxXWRM3y5nP+e6mK4cD08wDQYJKoZIhvcNAQEMBQAD
+ggIBALth2X2pbL4XxJEbw6GiAI3jZGgPVs93rnD5/ZpKmbnJeFwMDF/k5hQpVgs2
+SV1EY+CtnJYYZhsjDT156W1r1lT40jzBQ0CuHVD1UvyQO7uYmWlrx8GnqGikJ9yd
++SeuMIW59mdNOj6PWTkiU0TryF0Dyu1Qen1iIQqAyHNm0aAFYF/opbSnr6j3bTWc
+fFqK1qI4mfN4i/RN0iAL3gTujJtHgXINwBQy7zBZLq7gcfJW5GqXb5JQbZaNaHqa
+sjYUegbyJLkJEVDXCLG4iXqEI2FCKeWjzaIgQdfRnGTZ6iahixTXTBmyUEFxPT9N
+cCOGDErcgdLMMpSEDQgJlxxPwO5rIHQw0uA5NBCFIRUBCOhVMt5xSdkoF1BN5r5N
+0XWs0Mr7QbhDparTwwVETyw2m+L64kW4I1NsBm9nVX9GtUw/bihaeSbSpKhil9Ie
+4u1Ki7wb/UdKDd9nZn6yW0HQO+T0O/QEY+nvwlQAUaCKKsnOeMzV6ocEGLPOr0mI
+r/OSmbaz5mEP0oUA51Aa5BuVnRmhuZyxm7EAHu/QD09CbMkKvO5D+jpxpchNJqU1
+/YldvIViHTLSoCtU7ZpXwdv6EM8Zt4tKG48BtieVU+i2iW1bvGjUI+iLUaJW+fCm
+gKDWHrO8Dw9TdSmq6hN35N6MgSGtBxBHEa2HPQfRdbzP82Z+
+-----END CERTIFICATE-----
+
+# Issuer: CN=COMODO RSA Certification Authority O=COMODO CA Limited
+# Subject: CN=COMODO RSA Certification Authority O=COMODO CA Limited
+# Label: "COMODO RSA Certification Authority"
+# Serial: 101909084537582093308941363524873193117
+# MD5 Fingerprint: 1b:31:b0:71:40:36:cc:14:36:91:ad:c4:3e:fd:ec:18
+# SHA1 Fingerprint: af:e5:d2:44:a8:d1:19:42:30:ff:47:9f:e2:f8:97:bb:cd:7a:8c:b4
+# SHA256 Fingerprint: 52:f0:e1:c4:e5:8e:c6:29:29:1b:60:31:7f:07:46:71:b8:5d:7e:a8:0d:5b:07:27:34:63:53:4b:32:b4:02:34
+-----BEGIN CERTIFICATE-----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+-----END CERTIFICATE-----
+
+# Issuer: CN=USERTrust RSA Certification Authority O=The USERTRUST Network
+# Subject: CN=USERTrust RSA Certification Authority O=The USERTRUST Network
+# Label: "USERTrust RSA Certification Authority"
+# Serial: 2645093764781058787591871645665788717
+# MD5 Fingerprint: 1b:fe:69:d1:91:b7:19:33:a3:72:a8:0f:e1:55:e5:b5
+# SHA1 Fingerprint: 2b:8f:1b:57:33:0d:bb:a2:d0:7a:6c:51:f7:0e:e9:0d:da:b9:ad:8e
+# SHA256 Fingerprint: e7:93:c9:b0:2f:d8:aa:13:e2:1c:31:22:8a:cc:b0:81:19:64:3b:74:9c:89:89:64:b1:74:6d:46:c3:d4:cb:d2
+-----BEGIN CERTIFICATE-----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+-----END CERTIFICATE-----
+
+# Issuer: CN=USERTrust ECC Certification Authority O=The USERTRUST Network
+# Subject: CN=USERTrust ECC Certification Authority O=The USERTRUST Network
+# Label: "USERTrust ECC Certification Authority"
+# Serial: 123013823720199481456569720443997572134
+# MD5 Fingerprint: fa:68:bc:d9:b5:7f:ad:fd:c9:1d:06:83:28:cc:24:c1
+# SHA1 Fingerprint: d1:cb:ca:5d:b2:d5:2a:7f:69:3b:67:4d:e5:f0:5a:1d:0c:95:7d:f0
+# SHA256 Fingerprint: 4f:f4:60:d5:4b:9c:86:da:bf:bc:fc:57:12:e0:40:0d:2b:ed:3f:bc:4d:4f:bd:aa:86:e0:6a:dc:d2:a9:ad:7a
+-----BEGIN CERTIFICATE-----
+MIICjzCCAhWgAwIBAgIQXIuZxVqUxdJxVt7NiYDMJjAKBggqhkjOPQQDAzCBiDEL
+MAkGA1UEBhMCVVMxEzARBgNVBAgTCk5ldyBKZXJzZXkxFDASBgNVBAcTC0plcnNl
+eSBDaXR5MR4wHAYDVQQKExVUaGUgVVNFUlRSVVNUIE5ldHdvcmsxLjAsBgNVBAMT
+JVVTRVJUcnVzdCBFQ0MgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkwHhcNMTAwMjAx
+MDAwMDAwWhcNMzgwMTE4MjM1OTU5WjCBiDELMAkGA1UEBhMCVVMxEzARBgNVBAgT
+Ck5ldyBKZXJzZXkxFDASBgNVBAcTC0plcnNleSBDaXR5MR4wHAYDVQQKExVUaGUg
+VVNFUlRSVVNUIE5ldHdvcmsxLjAsBgNVBAMTJVVTRVJUcnVzdCBFQ0MgQ2VydGlm
+aWNhdGlvbiBBdXRob3JpdHkwdjAQBgcqhkjOPQIBBgUrgQQAIgNiAAQarFRaqflo
+I+d61SRvU8Za2EurxtW20eZzca7dnNYMYf3boIkDuAUU7FfO7l0/4iGzzvfUinng
+o4N+LZfQYcTxmdwlkWOrfzCjtHDix6EznPO/LlxTsV+zfTJ/ijTjeXmjQjBAMB0G
+A1UdDgQWBBQ64QmG1M8ZwpZ2dEl23OA1xmNjmjAOBgNVHQ8BAf8EBAMCAQYwDwYD
+VR0TAQH/BAUwAwEB/zAKBggqhkjOPQQDAwNoADBlAjA2Z6EWCNzklwBBHU6+4WMB
+zzuqQhFkoJ2UOQIReVx7Hfpkue4WQrO/isIJxOzksU0CMQDpKmFHjFJKS04YcPbW
+RNZu9YO6bVi9JNlWSOrvxKJGgYhqOkbRqZtNyWHa0V1Xahg=
+-----END CERTIFICATE-----
+
+# Issuer: CN=GlobalSign O=GlobalSign OU=GlobalSign ECC Root CA - R5
+# Subject: CN=GlobalSign O=GlobalSign OU=GlobalSign ECC Root CA - R5
+# Label: "GlobalSign ECC Root CA - R5"
+# Serial: 32785792099990507226680698011560947931244
+# MD5 Fingerprint: 9f:ad:3b:1c:02:1e:8a:ba:17:74:38:81:0c:a2:bc:08
+# SHA1 Fingerprint: 1f:24:c6:30:cd:a4:18:ef:20:69:ff:ad:4f:dd:5f:46:3a:1b:69:aa
+# SHA256 Fingerprint: 17:9f:bc:14:8a:3d:d0:0f:d2:4e:a1:34:58:cc:43:bf:a7:f5:9c:81:82:d7:83:a5:13:f6:eb:ec:10:0c:89:24
+-----BEGIN CERTIFICATE-----
+MIICHjCCAaSgAwIBAgIRYFlJ4CYuu1X5CneKcflK2GwwCgYIKoZIzj0EAwMwUDEk
+MCIGA1UECxMbR2xvYmFsU2lnbiBFQ0MgUm9vdCBDQSAtIFI1MRMwEQYDVQQKEwpH
+bG9iYWxTaWduMRMwEQYDVQQDEwpHbG9iYWxTaWduMB4XDTEyMTExMzAwMDAwMFoX
+DTM4MDExOTAzMTQwN1owUDEkMCIGA1UECxMbR2xvYmFsU2lnbiBFQ0MgUm9vdCBD
+QSAtIFI1MRMwEQYDVQQKEwpHbG9iYWxTaWduMRMwEQYDVQQDEwpHbG9iYWxTaWdu
+MHYwEAYHKoZIzj0CAQYFK4EEACIDYgAER0UOlvt9Xb/pOdEh+J8LttV7HpI6SFkc
+8GIxLcB6KP4ap1yztsyX50XUWPrRd21DosCHZTQKH3rd6zwzocWdTaRvQZU4f8ke
+hOvRnkmSh5SHDDqFSmafnVmTTZdhBoZKo0IwQDAOBgNVHQ8BAf8EBAMCAQYwDwYD
+VR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPeYpSJvqB8ohREom3m7e0oPQn1kwCgYI
+KoZIzj0EAwMDaAAwZQIxAOVpEslu28YxuglB4Zf4+/2a4n0Sye18ZNPLBSWLVtmg
+515dTguDnFt2KaAJJiFqYgIwcdK1j1zqO+F4CYWodZI7yFz9SO8NdCKoCOJuxUnO
+xwy8p2Fp8fc74SrL+SvzZpA3
+-----END CERTIFICATE-----
+
+# Issuer: CN=IdenTrust Commercial Root CA 1 O=IdenTrust
+# Subject: CN=IdenTrust Commercial Root CA 1 O=IdenTrust
+# Label: "IdenTrust Commercial Root CA 1"
+# Serial: 13298821034946342390520003877796839426
+# MD5 Fingerprint: b3:3e:77:73:75:ee:a0:d3:e3:7e:49:63:49:59:bb:c7
+# SHA1 Fingerprint: df:71:7e:aa:4a:d9:4e:c9:55:84:99:60:2d:48:de:5f:bc:f0:3a:25
+# SHA256 Fingerprint: 5d:56:49:9b:e4:d2:e0:8b:cf:ca:d0:8a:3e:38:72:3d:50:50:3b:de:70:69:48:e4:2f:55:60:30:19:e5:28:ae
+-----BEGIN CERTIFICATE-----
+MIIFYDCCA0igAwIBAgIQCgFCgAAAAUUjyES1AAAAAjANBgkqhkiG9w0BAQsFADBK
+MQswCQYDVQQGEwJVUzESMBAGA1UEChMJSWRlblRydXN0MScwJQYDVQQDEx5JZGVu
+VHJ1c3QgQ29tbWVyY2lhbCBSb290IENBIDEwHhcNMTQwMTE2MTgxMjIzWhcNMzQw
+MTE2MTgxMjIzWjBKMQswCQYDVQQGEwJVUzESMBAGA1UEChMJSWRlblRydXN0MScw
+JQYDVQQDEx5JZGVuVHJ1c3QgQ29tbWVyY2lhbCBSb290IENBIDEwggIiMA0GCSqG
+SIb3DQEBAQUAA4ICDwAwggIKAoICAQCnUBneP5k91DNG8W9RYYKyqU+PZ4ldhNlT
+3Qwo2dfw/66VQ3KZ+bVdfIrBQuExUHTRgQ18zZshq0PirK1ehm7zCYofWjK9ouuU
++ehcCuz/mNKvcbO0U59Oh++SvL3sTzIwiEsXXlfEU8L2ApeN2WIrvyQfYo3fw7gp
+S0l4PJNgiCL8mdo2yMKi1CxUAGc1bnO/AljwpN3lsKImesrgNqUZFvX9t++uP0D1
+bVoE/c40yiTcdCMbXTMTEl3EASX2MN0CXZ/g1Ue9tOsbobtJSdifWwLziuQkkORi
+T0/Br4sOdBeo0XKIanoBScy0RnnGF7HamB4HWfp1IYVl3ZBWzvurpWCdxJ35UrCL
+vYf5jysjCiN2O/cz4ckA82n5S6LgTrx+kzmEB/dEcH7+B1rlsazRGMzyNeVJSQjK
+Vsk9+w8YfYs7wRPCTY/JTw436R+hDmrfYi7LNQZReSzIJTj0+kuniVyc0uMNOYZK
+dHzVWYfCP04MXFL0PfdSgvHqo6z9STQaKPNBiDoT7uje/5kdX7rL6B7yuVBgwDHT
+c+XvvqDtMwt0viAgxGds8AgDelWAf0ZOlqf0Hj7h9tgJ4TNkK2PXMl6f+cB7D3hv
+l7yTmvmcEpB4eoCHFddydJxVdHixuuFucAS6T6C6aMN7/zHwcz09lCqxC0EOoP5N
+iGVreTO01wIDAQABo0IwQDAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/BAUwAwEB
+/zAdBgNVHQ4EFgQU7UQZwNPwBovupHu+QucmVMiONnYwDQYJKoZIhvcNAQELBQAD
+ggIBAA2ukDL2pkt8RHYZYR4nKM1eVO8lvOMIkPkp165oCOGUAFjvLi5+U1KMtlwH
+6oi6mYtQlNeCgN9hCQCTrQ0U5s7B8jeUeLBfnLOic7iPBZM4zY0+sLj7wM+x8uwt
+LRvM7Kqas6pgghstO8OEPVeKlh6cdbjTMM1gCIOQ045U8U1mwF10A0Cj7oV+wh93
+nAbowacYXVKV7cndJZ5t+qntozo00Fl72u1Q8zW/7esUTTHHYPTa8Yec4kjixsU3
++wYQ+nVZZjFHKdp2mhzpgq7vmrlR94gjmmmVYjzlVYA211QC//G5Xc7UI2/YRYRK
+W2XviQzdFKcgyxilJbQN+QHwotL0AMh0jqEqSI5l2xPE4iUXfeu+h1sXIFRRk0pT
+AwvsXcoz7WL9RccvW9xYoIA55vrX/hMUpu09lEpCdNTDd1lzzY9GvlU47/rokTLq
+l1gEIt44w8y8bckzOmoKaT+gyOpyj4xjhiO9bTyWnpXgSUyqorkqG5w2gXjtw+hG
+4iZZRHUe2XWJUc0QhJ1hYMtd+ZciTY6Y5uN/9lu7rs3KSoFrXgvzUeF0K+l+J6fZ
+mUlO+KWA2yUPHGNiiskzZ2s8EIPGrd6ozRaOjfAHN3Gf8qv8QfXBi+wAN10J5U6A
+7/qxXDgGpRtK4dw4LTzcqx+QGtVKnO7RcGzM7vRX+Bi6hG6H
+-----END CERTIFICATE-----
+
+# Issuer: CN=IdenTrust Public Sector Root CA 1 O=IdenTrust
+# Subject: CN=IdenTrust Public Sector Root CA 1 O=IdenTrust
+# Label: "IdenTrust Public Sector Root CA 1"
+# Serial: 13298821034946342390521976156843933698
+# MD5 Fingerprint: 37:06:a5:b0:fc:89:9d:ba:f4:6b:8c:1a:64:cd:d5:ba
+# SHA1 Fingerprint: ba:29:41:60:77:98:3f:f4:f3:ef:f2:31:05:3b:2e:ea:6d:4d:45:fd
+# SHA256 Fingerprint: 30:d0:89:5a:9a:44:8a:26:20:91:63:55:22:d1:f5:20:10:b5:86:7a:ca:e1:2c:78:ef:95:8f:d4:f4:38:9f:2f
+-----BEGIN CERTIFICATE-----
+MIIFZjCCA06gAwIBAgIQCgFCgAAAAUUjz0Z8AAAAAjANBgkqhkiG9w0BAQsFADBN
+MQswCQYDVQQGEwJVUzESMBAGA1UEChMJSWRlblRydXN0MSowKAYDVQQDEyFJZGVu
+VHJ1c3QgUHVibGljIFNlY3RvciBSb290IENBIDEwHhcNMTQwMTE2MTc1MzMyWhcN
+MzQwMTE2MTc1MzMyWjBNMQswCQYDVQQGEwJVUzESMBAGA1UEChMJSWRlblRydXN0
+MSowKAYDVQQDEyFJZGVuVHJ1c3QgUHVibGljIFNlY3RvciBSb290IENBIDEwggIi
+MA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQC2IpT8pEiv6EdrCvsnduTyP4o7
+ekosMSqMjbCpwzFrqHd2hCa2rIFCDQjrVVi7evi8ZX3yoG2LqEfpYnYeEe4IFNGy
+RBb06tD6Hi9e28tzQa68ALBKK0CyrOE7S8ItneShm+waOh7wCLPQ5CQ1B5+ctMlS
+bdsHyo+1W/CD80/HLaXIrcuVIKQxKFdYWuSNG5qrng0M8gozOSI5Cpcu81N3uURF
+/YTLNiCBWS2ab21ISGHKTN9T0a9SvESfqy9rg3LvdYDaBjMbXcjaY8ZNzaxmMc3R
+3j6HEDbhuaR672BQssvKplbgN6+rNBM5Jeg5ZuSYeqoSmJxZZoY+rfGwyj4GD3vw
+EUs3oERte8uojHH01bWRNszwFcYr3lEXsZdMUD2xlVl8BX0tIdUAvwFnol57plzy
+9yLxkA2T26pEUWbMfXYD62qoKjgZl3YNa4ph+bz27nb9cCvdKTz4Ch5bQhyLVi9V
+GxyhLrXHFub4qjySjmm2AcG1hp2JDws4lFTo6tyePSW8Uybt1as5qsVATFSrsrTZ
+2fjXctscvG29ZV/viDUqZi/u9rNl8DONfJhBaUYPQxxp+pu10GFqzcpL2UyQRqsV
+WaFHVCkugyhfHMKiq3IXAAaOReyL4jM9f9oZRORicsPfIsbyVtTdX5Vy7W1f90gD
+W/3FKqD2cyOEEBsB5wIDAQABo0IwQDAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/
+BAUwAwEB/zAdBgNVHQ4EFgQU43HgntinQtnbcZFrlJPrw6PRFKMwDQYJKoZIhvcN
+AQELBQADggIBAEf63QqwEZE4rU1d9+UOl1QZgkiHVIyqZJnYWv6IAcVYpZmxI1Qj
+t2odIFflAWJBF9MJ23XLblSQdf4an4EKwt3X9wnQW3IV5B4Jaj0z8yGa5hV+rVHV
+DRDtfULAj+7AmgjVQdZcDiFpboBhDhXAuM/FSRJSzL46zNQuOAXeNf0fb7iAaJg9
+TaDKQGXSc3z1i9kKlT/YPyNtGtEqJBnZhbMX73huqVjRI9PHE+1yJX9dsXNw0H8G
+lwmEKYBhHfpe/3OsoOOJuBxxFcbeMX8S3OFtm6/n6J91eEyrRjuazr8FGF1NFTwW
+mhlQBJqymm9li1JfPFgEKCXAZmExfrngdbkaqIHWchezxQMxNRF4eKLg6TCMf4Df
+WN88uieW4oA0beOY02QnrEh+KHdcxiVhJfiFDGX6xDIvpZgF5PgLZxYWxoK4Mhn5
++bl53B/N66+rDt0b20XkeucC4pVd/GnwU2lhlXV5C15V5jgclKlZM57IcXR5f1GJ
+tshquDDIajjDbp7hNxbqBWJMWxJH7ae0s1hWx0nzfxJoCTFx8G34Tkf71oXuxVhA
+GaQdp/lLQzfcaFpPz+vCZHTetBXZ9FRUGi8c15dxVJCO2SCdUyt/q4/i6jC8UDfv
+8Ue1fXwsBOxonbRJRBD0ckscZOf85muQ3Wl9af0AVqW3rLatt8o+Ae+c
+-----END CERTIFICATE-----
+
+# Issuer: CN=Entrust Root Certification Authority - G2 O=Entrust, Inc. OU=See www.entrust.net/legal-terms/(c) 2009 Entrust, Inc. - for authorized use only
+# Subject: CN=Entrust Root Certification Authority - G2 O=Entrust, Inc. OU=See www.entrust.net/legal-terms/(c) 2009 Entrust, Inc. - for authorized use only
+# Label: "Entrust Root Certification Authority - G2"
+# Serial: 1246989352
+# MD5 Fingerprint: 4b:e2:c9:91:96:65:0c:f4:0e:5a:93:92:a0:0a:fe:b2
+# SHA1 Fingerprint: 8c:f4:27:fd:79:0c:3a:d1:66:06:8d:e8:1e:57:ef:bb:93:22:72:d4
+# SHA256 Fingerprint: 43:df:57:74:b0:3e:7f:ef:5f:e4:0d:93:1a:7b:ed:f1:bb:2e:6b:42:73:8c:4e:6d:38:41:10:3d:3a:a7:f3:39
+-----BEGIN CERTIFICATE-----
+MIIEPjCCAyagAwIBAgIESlOMKDANBgkqhkiG9w0BAQsFADCBvjELMAkGA1UEBhMC
+VVMxFjAUBgNVBAoTDUVudHJ1c3QsIEluYy4xKDAmBgNVBAsTH1NlZSB3d3cuZW50
+cnVzdC5uZXQvbGVnYWwtdGVybXMxOTA3BgNVBAsTMChjKSAyMDA5IEVudHJ1c3Qs
+IEluYy4gLSBmb3IgYXV0aG9yaXplZCB1c2Ugb25seTEyMDAGA1UEAxMpRW50cnVz
+dCBSb290IENlcnRpZmljYXRpb24gQXV0aG9yaXR5IC0gRzIwHhcNMDkwNzA3MTcy
+NTU0WhcNMzAxMjA3MTc1NTU0WjCBvjELMAkGA1UEBhMCVVMxFjAUBgNVBAoTDUVu
+dHJ1c3QsIEluYy4xKDAmBgNVBAsTH1NlZSB3d3cuZW50cnVzdC5uZXQvbGVnYWwt
+dGVybXMxOTA3BgNVBAsTMChjKSAyMDA5IEVudHJ1c3QsIEluYy4gLSBmb3IgYXV0
+aG9yaXplZCB1c2Ugb25seTEyMDAGA1UEAxMpRW50cnVzdCBSb290IENlcnRpZmlj
+YXRpb24gQXV0aG9yaXR5IC0gRzIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEK
+AoIBAQC6hLZy254Ma+KZ6TABp3bqMriVQRrJ2mFOWHLP/vaCeb9zYQYKpSfYs1/T
+RU4cctZOMvJyig/3gxnQaoCAAEUesMfnmr8SVycco2gvCoe9amsOXmXzHHfV1IWN
+cCG0szLni6LVhjkCsbjSR87kyUnEO6fe+1R9V77w6G7CebI6C1XiUJgWMhNcL3hW
+wcKUs/Ja5CeanyTXxuzQmyWC48zCxEXFjJd6BmsqEZ+pCm5IO2/b1BEZQvePB7/1
+U1+cPvQXLOZprE4yTGJ36rfo5bs0vBmLrpxR57d+tVOxMyLlbc9wPBr64ptntoP0
+jaWvYkxN4FisZDQSA/i2jZRjJKRxAgMBAAGjQjBAMA4GA1UdDwEB/wQEAwIBBjAP
+BgNVHRMBAf8EBTADAQH/MB0GA1UdDgQWBBRqciZ60B7vfec7aVHUbI2fkBJmqzAN
+BgkqhkiG9w0BAQsFAAOCAQEAeZ8dlsa2eT8ijYfThwMEYGprmi5ZiXMRrEPR9RP/
+jTkrwPK9T3CMqS/qF8QLVJ7UG5aYMzyorWKiAHarWWluBh1+xLlEjZivEtRh2woZ
+Rkfz6/djwUAFQKXSt/S1mja/qYh2iARVBCuch38aNzx+LaUa2NSJXsq9rD1s2G2v
+1fN2D807iDginWyTmsQ9v4IbZT+mD12q/OWyFcq1rca8PdCE6OoGcrBNOTJ4vz4R
+nAuknZoh8/CbCzB428Hch0P+vGOaysXCHMnHjf87ElgI5rY97HosTvuDls4MPGmH
+VHOkc8KT/1EQrBVUAdj8BbGJoX90g5pJ19xOe4pIb4tF9g==
+-----END CERTIFICATE-----
+
+# Issuer: CN=Entrust Root Certification Authority - EC1 O=Entrust, Inc. OU=See www.entrust.net/legal-terms/(c) 2012 Entrust, Inc. - for authorized use only
+# Subject: CN=Entrust Root Certification Authority - EC1 O=Entrust, Inc. OU=See www.entrust.net/legal-terms/(c) 2012 Entrust, Inc. - for authorized use only
+# Label: "Entrust Root Certification Authority - EC1"
+# Serial: 51543124481930649114116133369
+# MD5 Fingerprint: b6:7e:1d:f0:58:c5:49:6c:24:3b:3d:ed:98:18:ed:bc
+# SHA1 Fingerprint: 20:d8:06:40:df:9b:25:f5:12:25:3a:11:ea:f7:59:8a:eb:14:b5:47
+# SHA256 Fingerprint: 02:ed:0e:b2:8c:14:da:45:16:5c:56:67:91:70:0d:64:51:d7:fb:56:f0:b2:ab:1d:3b:8e:b0:70:e5:6e:df:f5
+-----BEGIN CERTIFICATE-----
+MIIC+TCCAoCgAwIBAgINAKaLeSkAAAAAUNCR+TAKBggqhkjOPQQDAzCBvzELMAkG
+A1UEBhMCVVMxFjAUBgNVBAoTDUVudHJ1c3QsIEluYy4xKDAmBgNVBAsTH1NlZSB3
+d3cuZW50cnVzdC5uZXQvbGVnYWwtdGVybXMxOTA3BgNVBAsTMChjKSAyMDEyIEVu
+dHJ1c3QsIEluYy4gLSBmb3IgYXV0aG9yaXplZCB1c2Ugb25seTEzMDEGA1UEAxMq
+RW50cnVzdCBSb290IENlcnRpZmljYXRpb24gQXV0aG9yaXR5IC0gRUMxMB4XDTEy
+MTIxODE1MjUzNloXDTM3MTIxODE1NTUzNlowgb8xCzAJBgNVBAYTAlVTMRYwFAYD
+VQQKEw1FbnRydXN0LCBJbmMuMSgwJgYDVQQLEx9TZWUgd3d3LmVudHJ1c3QubmV0
+L2xlZ2FsLXRlcm1zMTkwNwYDVQQLEzAoYykgMjAxMiBFbnRydXN0LCBJbmMuIC0g
+Zm9yIGF1dGhvcml6ZWQgdXNlIG9ubHkxMzAxBgNVBAMTKkVudHJ1c3QgUm9vdCBD
+ZXJ0aWZpY2F0aW9uIEF1dGhvcml0eSAtIEVDMTB2MBAGByqGSM49AgEGBSuBBAAi
+A2IABIQTydC6bUF74mzQ61VfZgIaJPRbiWlH47jCffHyAsWfoPZb1YsGGYZPUxBt
+ByQnoaD41UcZYUx9ypMn6nQM72+WCf5j7HBdNq1nd67JnXxVRDqiY1Ef9eNi1KlH
+Bz7MIKNCMEAwDgYDVR0PAQH/BAQDAgEGMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0O
+BBYEFLdj5xrdjekIplWDpOBqUEFlEUJJMAoGCCqGSM49BAMDA2cAMGQCMGF52OVC
+R98crlOZF7ZvHH3hvxGU0QOIdeSNiaSKd0bebWHvAvX7td/M/k7//qnmpwIwW5nX
+hTcGtXsI/esni0qU+eH6p44mCOh8kmhtc9hvJqwhAriZtyZBWyVgrtBIGu4G
+-----END CERTIFICATE-----
+
+# Issuer: CN=CFCA EV ROOT O=China Financial Certification Authority
+# Subject: CN=CFCA EV ROOT O=China Financial Certification Authority
+# Label: "CFCA EV ROOT"
+# Serial: 407555286
+# MD5 Fingerprint: 74:e1:b6:ed:26:7a:7a:44:30:33:94:ab:7b:27:81:30
+# SHA1 Fingerprint: e2:b8:29:4b:55:84:ab:6b:58:c2:90:46:6c:ac:3f:b8:39:8f:84:83
+# SHA256 Fingerprint: 5c:c3:d7:8e:4e:1d:5e:45:54:7a:04:e6:87:3e:64:f9:0c:f9:53:6d:1c:cc:2e:f8:00:f3:55:c4:c5:fd:70:fd
+-----BEGIN CERTIFICATE-----
+MIIFjTCCA3WgAwIBAgIEGErM1jANBgkqhkiG9w0BAQsFADBWMQswCQYDVQQGEwJD
+TjEwMC4GA1UECgwnQ2hpbmEgRmluYW5jaWFsIENlcnRpZmljYXRpb24gQXV0aG9y
+aXR5MRUwEwYDVQQDDAxDRkNBIEVWIFJPT1QwHhcNMTIwODA4MDMwNzAxWhcNMjkx
+MjMxMDMwNzAxWjBWMQswCQYDVQQGEwJDTjEwMC4GA1UECgwnQ2hpbmEgRmluYW5j
+aWFsIENlcnRpZmljYXRpb24gQXV0aG9yaXR5MRUwEwYDVQQDDAxDRkNBIEVWIFJP
+T1QwggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQDXXWvNED8fBVnVBU03
+sQ7smCuOFR36k0sXgiFxEFLXUWRwFsJVaU2OFW2fvwwbwuCjZ9YMrM8irq93VCpL
+TIpTUnrD7i7es3ElweldPe6hL6P3KjzJIx1qqx2hp/Hz7KDVRM8Vz3IvHWOX6Jn5
+/ZOkVIBMUtRSqy5J35DNuF++P96hyk0g1CXohClTt7GIH//62pCfCqktQT+x8Rgp
+7hZZLDRJGqgG16iI0gNyejLi6mhNbiyWZXvKWfry4t3uMCz7zEasxGPrb382KzRz
+EpR/38wmnvFyXVBlWY9ps4deMm/DGIq1lY+wejfeWkU7xzbh72fROdOXW3NiGUgt
+hxwG+3SYIElz8AXSG7Ggo7cbcNOIabla1jj0Ytwli3i/+Oh+uFzJlU9fpy25IGvP
+a931DfSCt/SyZi4QKPaXWnuWFo8BGS1sbn85WAZkgwGDg8NNkt0yxoekN+kWzqot
+aK8KgWU6cMGbrU1tVMoqLUuFG7OA5nBFDWteNfB/O7ic5ARwiRIlk9oKmSJgamNg
+TnYGmE69g60dWIolhdLHZR4tjsbftsbhf4oEIRUpdPA+nJCdDC7xij5aqgwJHsfV
+PKPtl8MeNPo4+QgO48BdK4PRVmrJtqhUUy54Mmc9gn900PvhtgVguXDbjgv5E1hv
+cWAQUhC5wUEJ73IfZzF4/5YFjQIDAQABo2MwYTAfBgNVHSMEGDAWgBTj/i39KNAL
+tbq2osS/BqoFjJP7LzAPBgNVHRMBAf8EBTADAQH/MA4GA1UdDwEB/wQEAwIBBjAd
+BgNVHQ4EFgQU4/4t/SjQC7W6tqLEvwaqBYyT+y8wDQYJKoZIhvcNAQELBQADggIB
+ACXGumvrh8vegjmWPfBEp2uEcwPenStPuiB/vHiyz5ewG5zz13ku9Ui20vsXiObT
+ej/tUxPQ4i9qecsAIyjmHjdXNYmEwnZPNDatZ8POQQaIxffu2Bq41gt/UP+TqhdL
+jOztUmCypAbqTuv0axn96/Ua4CUqmtzHQTb3yHQFhDmVOdYLO6Qn+gjYXB74BGBS
+ESgoA//vU2YApUo0FmZ8/Qmkrp5nGm9BC2sGE5uPhnEFtC+NiWYzKXZUmhH4J/qy
+P5Hgzg0b8zAarb8iXRvTvyUFTeGSGn+ZnzxEk8rUQElsgIfXBDrDMlI1Dlb4pd19
+xIsNER9Tyx6yF7Zod1rg1MvIB671Oi6ON7fQAUtDKXeMOZePglr4UeWJoBjnaH9d
+Ci77o0cOPaYjesYBx4/IXr9tgFa+iiS6M+qf4TIRnvHST4D2G0CvOJ4RUHlzEhLN
+5mydLIhyPDCBBpEi6lmt2hkuIsKNuYyH4Ga8cyNfIWRjgEj1oDwYPZTISEEdQLpe
+/v5WOaHIz16eGWRGENoXkbcFgKyLmZJ956LYBws2J+dIeWCKw9cTXPhyQN9Ky8+Z
+AAoACxGV2lZFA4gKn2fQ1XmxqI1AbQ3CekD6819kR5LLU7m7Wc5P/dAVUwHY3+vZ
+5nbv0CO7O6l5s9UCKc2Jo5YPSjXnTkLAdc0Hz+Ys63su
+-----END CERTIFICATE-----
+
+# Issuer: CN=OISTE WISeKey Global Root GB CA O=WISeKey OU=OISTE Foundation Endorsed
+# Subject: CN=OISTE WISeKey Global Root GB CA O=WISeKey OU=OISTE Foundation Endorsed
+# Label: "OISTE WISeKey Global Root GB CA"
+# Serial: 157768595616588414422159278966750757568
+# MD5 Fingerprint: a4:eb:b9:61:28:2e:b7:2f:98:b0:35:26:90:99:51:1d
+# SHA1 Fingerprint: 0f:f9:40:76:18:d3:d7:6a:4b:98:f0:a8:35:9e:0c:fd:27:ac:cc:ed
+# SHA256 Fingerprint: 6b:9c:08:e8:6e:b0:f7:67:cf:ad:65:cd:98:b6:21:49:e5:49:4a:67:f5:84:5e:7b:d1:ed:01:9f:27:b8:6b:d6
+-----BEGIN CERTIFICATE-----
+MIIDtTCCAp2gAwIBAgIQdrEgUnTwhYdGs/gjGvbCwDANBgkqhkiG9w0BAQsFADBt
+MQswCQYDVQQGEwJDSDEQMA4GA1UEChMHV0lTZUtleTEiMCAGA1UECxMZT0lTVEUg
+Rm91bmRhdGlvbiBFbmRvcnNlZDEoMCYGA1UEAxMfT0lTVEUgV0lTZUtleSBHbG9i
+YWwgUm9vdCBHQiBDQTAeFw0xNDEyMDExNTAwMzJaFw0zOTEyMDExNTEwMzFaMG0x
+CzAJBgNVBAYTAkNIMRAwDgYDVQQKEwdXSVNlS2V5MSIwIAYDVQQLExlPSVNURSBG
+b3VuZGF0aW9uIEVuZG9yc2VkMSgwJgYDVQQDEx9PSVNURSBXSVNlS2V5IEdsb2Jh
+bCBSb290IEdCIENBMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA2Be3
+HEokKtaXscriHvt9OO+Y9bI5mE4nuBFde9IllIiCFSZqGzG7qFshISvYD06fWvGx
+WuR51jIjK+FTzJlFXHtPrby/h0oLS5daqPZI7H17Dc0hBt+eFf1Biki3IPShehtX
+1F1Q/7pn2COZH8g/497/b1t3sWtuuMlk9+HKQUYOKXHQuSP8yYFfTvdv37+ErXNk
+u7dCjmn21HYdfp2nuFeKUWdy19SouJVUQHMD9ur06/4oQnc/nSMbsrY9gBQHTC5P
+99UKFg29ZkM3fiNDecNAhvVMKdqOmq0NpQSHiB6F4+lT1ZvIiwNjeOvgGUpuuy9r
+M2RYk61pv48b74JIxwIDAQABo1EwTzALBgNVHQ8EBAMCAYYwDwYDVR0TAQH/BAUw
+AwEB/zAdBgNVHQ4EFgQUNQ/INmNe4qPs+TtmFc5RUuORmj0wEAYJKwYBBAGCNxUB
+BAMCAQAwDQYJKoZIhvcNAQELBQADggEBAEBM+4eymYGQfp3FsLAmzYh7KzKNbrgh
+cViXfa43FK8+5/ea4n32cZiZBKpDdHij40lhPnOMTZTg+XHEthYOU3gf1qKHLwI5
+gSk8rxWYITD+KJAAjNHhy/peyP34EEY7onhCkRd0VQreUGdNZtGn//3ZwLWoo4rO
+ZvUPQ82nK1d7Y0Zqqi5S2PTt4W2tKZB4SLrhI6qjiey1q5bAtEuiHZeeevJuQHHf
+aPFlTc58Bd9TZaml8LGXBHAVRgOY1NK/VLSgWH1Sb9pWJmLU2NuJMW8c8CLC02Ic
+Nc1MaRVUGpCY3useX8p3x8uOPUNpnJpY0CQ73xtAln41rYHHTnG6iBM=
+-----END CERTIFICATE-----
+
+# Issuer: CN=SZAFIR ROOT CA2 O=Krajowa Izba Rozliczeniowa S.A.
+# Subject: CN=SZAFIR ROOT CA2 O=Krajowa Izba Rozliczeniowa S.A.
+# Label: "SZAFIR ROOT CA2"
+# Serial: 357043034767186914217277344587386743377558296292
+# MD5 Fingerprint: 11:64:c1:89:b0:24:b1:8c:b1:07:7e:89:9e:51:9e:99
+# SHA1 Fingerprint: e2:52:fa:95:3f:ed:db:24:60:bd:6e:28:f3:9c:cc:cf:5e:b3:3f:de
+# SHA256 Fingerprint: a1:33:9d:33:28:1a:0b:56:e5:57:d3:d3:2b:1c:e7:f9:36:7e:b0:94:bd:5f:a7:2a:7e:50:04:c8:de:d7:ca:fe
+-----BEGIN CERTIFICATE-----
+MIIDcjCCAlqgAwIBAgIUPopdB+xV0jLVt+O2XwHrLdzk1uQwDQYJKoZIhvcNAQEL
+BQAwUTELMAkGA1UEBhMCUEwxKDAmBgNVBAoMH0tyYWpvd2EgSXpiYSBSb3psaWN6
+ZW5pb3dhIFMuQS4xGDAWBgNVBAMMD1NaQUZJUiBST09UIENBMjAeFw0xNTEwMTkw
+NzQzMzBaFw0zNTEwMTkwNzQzMzBaMFExCzAJBgNVBAYTAlBMMSgwJgYDVQQKDB9L
+cmFqb3dhIEl6YmEgUm96bGljemVuaW93YSBTLkEuMRgwFgYDVQQDDA9TWkFGSVIg
+Uk9PVCBDQTIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQC3vD5QqEvN
+QLXOYeeWyrSh2gwisPq1e3YAd4wLz32ohswmUeQgPYUM1ljj5/QqGJ3a0a4m7utT
+3PSQ1hNKDJA8w/Ta0o4NkjrcsbH/ON7Dui1fgLkCvUqdGw+0w8LBZwPd3BucPbOw
+3gAeqDRHu5rr/gsUvTaE2g0gv/pby6kWIK05YO4vdbbnl5z5Pv1+TW9NL++IDWr6
+3fE9biCloBK0TXC5ztdyO4mTp4CEHCdJckm1/zuVnsHMyAHs6A6KCpbns6aH5db5
+BSsNl0BwPLqsdVqc1U2dAgrSS5tmS0YHF2Wtn2yIANwiieDhZNRnvDF5YTy7ykHN
+XGoAyDw4jlivAgMBAAGjQjBAMA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQD
+AgEGMB0GA1UdDgQWBBQuFqlKGLXLzPVvUPMjX/hd56zwyDANBgkqhkiG9w0BAQsF
+AAOCAQEAtXP4A9xZWx126aMqe5Aosk3AM0+qmrHUuOQn/6mWmc5G4G18TKI4pAZw
+8PRBEew/R40/cof5O/2kbytTAOD/OblqBw7rHRz2onKQy4I9EYKL0rufKq8h5mOG
+nXkZ7/e7DDWQw4rtTw/1zBLZpD67oPwglV9PJi8RI4NOdQcPv5vRtB3pEAT+ymCP
+oky4rc/hkA/NrgrHXXu3UNLUYfrVFdvXn4dRVOul4+vJhaAlIDf7js4MNIThPIGy
+d05DpYhfhmehPea0XGG2Ptv+tyjFogeutcrKjSoS75ftwjCkySp6+/NNIxuZMzSg
+LvWpCz/UXeHPhJ/iGcJfitYgHuNztw==
+-----END CERTIFICATE-----
+
+# Issuer: CN=Certum Trusted Network CA 2 O=Unizeto Technologies S.A. OU=Certum Certification Authority
+# Subject: CN=Certum Trusted Network CA 2 O=Unizeto Technologies S.A. OU=Certum Certification Authority
+# Label: "Certum Trusted Network CA 2"
+# Serial: 44979900017204383099463764357512596969
+# MD5 Fingerprint: 6d:46:9e:d9:25:6d:08:23:5b:5e:74:7d:1e:27:db:f2
+# SHA1 Fingerprint: d3:dd:48:3e:2b:bf:4c:05:e8:af:10:f5:fa:76:26:cf:d3:dc:30:92
+# SHA256 Fingerprint: b6:76:f2:ed:da:e8:77:5c:d3:6c:b0:f6:3c:d1:d4:60:39:61:f4:9e:62:65:ba:01:3a:2f:03:07:b6:d0:b8:04
+-----BEGIN CERTIFICATE-----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+-----END CERTIFICATE-----
+
+# Issuer: CN=Hellenic Academic and Research Institutions RootCA 2015 O=Hellenic Academic and Research Institutions Cert. Authority
+# Subject: CN=Hellenic Academic and Research Institutions RootCA 2015 O=Hellenic Academic and Research Institutions Cert. Authority
+# Label: "Hellenic Academic and Research Institutions RootCA 2015"
+# Serial: 0
+# MD5 Fingerprint: ca:ff:e2:db:03:d9:cb:4b:e9:0f:ad:84:fd:7b:18:ce
+# SHA1 Fingerprint: 01:0c:06:95:a6:98:19:14:ff:bf:5f:c6:b0:b6:95:ea:29:e9:12:a6
+# SHA256 Fingerprint: a0:40:92:9a:02:ce:53:b4:ac:f4:f2:ff:c6:98:1c:e4:49:6f:75:5e:6d:45:fe:0b:2a:69:2b:cd:52:52:3f:36
+-----BEGIN CERTIFICATE-----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+-----END CERTIFICATE-----
+
+# Issuer: CN=Hellenic Academic and Research Institutions ECC RootCA 2015 O=Hellenic Academic and Research Institutions Cert. Authority
+# Subject: CN=Hellenic Academic and Research Institutions ECC RootCA 2015 O=Hellenic Academic and Research Institutions Cert. Authority
+# Label: "Hellenic Academic and Research Institutions ECC RootCA 2015"
+# Serial: 0
+# MD5 Fingerprint: 81:e5:b4:17:eb:c2:f5:e1:4b:0d:41:7b:49:92:fe:ef
+# SHA1 Fingerprint: 9f:f1:71:8d:92:d5:9a:f3:7d:74:97:b4:bc:6f:84:68:0b:ba:b6:66
+# SHA256 Fingerprint: 44:b5:45:aa:8a:25:e6:5a:73:ca:15:dc:27:fc:36:d2:4c:1c:b9:95:3a:06:65:39:b1:15:82:dc:48:7b:48:33
+-----BEGIN CERTIFICATE-----
+MIICwzCCAkqgAwIBAgIBADAKBggqhkjOPQQDAjCBqjELMAkGA1UEBhMCR1IxDzAN
+BgNVBAcTBkF0aGVuczFEMEIGA1UEChM7SGVsbGVuaWMgQWNhZGVtaWMgYW5kIFJl
+c2VhcmNoIEluc3RpdHV0aW9ucyBDZXJ0LiBBdXRob3JpdHkxRDBCBgNVBAMTO0hl
+bGxlbmljIEFjYWRlbWljIGFuZCBSZXNlYXJjaCBJbnN0aXR1dGlvbnMgRUNDIFJv
+b3RDQSAyMDE1MB4XDTE1MDcwNzEwMzcxMloXDTQwMDYzMDEwMzcxMlowgaoxCzAJ
+BgNVBAYTAkdSMQ8wDQYDVQQHEwZBdGhlbnMxRDBCBgNVBAoTO0hlbGxlbmljIEFj
+YWRlbWljIGFuZCBSZXNlYXJjaCBJbnN0aXR1dGlvbnMgQ2VydC4gQXV0aG9yaXR5
+MUQwQgYDVQQDEztIZWxsZW5pYyBBY2FkZW1pYyBhbmQgUmVzZWFyY2ggSW5zdGl0
+dXRpb25zIEVDQyBSb290Q0EgMjAxNTB2MBAGByqGSM49AgEGBSuBBAAiA2IABJKg
+QehLgoRc4vgxEZmGZE4JJS+dQS8KrjVPdJWyUWRrjWvmP3CV8AVER6ZyOFB2lQJa
+jq4onvktTpnvLEhvTCUp6NFxW98dwXU3tNf6e3pCnGoKVlp8aQuqgAkkbH7BRqNC
+MEAwDwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFLQi
+C4KZJAEOnLvkDv2/+5cgk5kqMAoGCCqGSM49BAMCA2cAMGQCMGfOFmI4oqxiRaep
+lSTAGiecMjvAwNW6qef4BENThe5SId6d9SWDPp5YSy/XZxMOIQIwBeF1Ad5o7Sof
+TUwJCA3sS61kFyjndc5FZXIhF8siQQ6ME5g4mlRtm8rifOoCWCKR
+-----END CERTIFICATE-----
+
+# Issuer: CN=ISRG Root X1 O=Internet Security Research Group
+# Subject: CN=ISRG Root X1 O=Internet Security Research Group
+# Label: "ISRG Root X1"
+# Serial: 172886928669790476064670243504169061120
+# MD5 Fingerprint: 0c:d2:f9:e0:da:17:73:e9:ed:86:4d:a5:e3:70:e7:4e
+# SHA1 Fingerprint: ca:bd:2a:79:a1:07:6a:31:f2:1d:25:36:35:cb:03:9d:43:29:a5:e8
+# SHA256 Fingerprint: 96:bc:ec:06:26:49:76:f3:74:60:77:9a:cf:28:c5:a7:cf:e8:a3:c0:aa:e1:1a:8f:fc:ee:05:c0:bd:df:08:c6
+-----BEGIN CERTIFICATE-----
+MIIFazCCA1OgAwIBAgIRAIIQz7DSQONZRGPgu2OCiwAwDQYJKoZIhvcNAQELBQAw
+TzELMAkGA1UEBhMCVVMxKTAnBgNVBAoTIEludGVybmV0IFNlY3VyaXR5IFJlc2Vh
+cmNoIEdyb3VwMRUwEwYDVQQDEwxJU1JHIFJvb3QgWDEwHhcNMTUwNjA0MTEwNDM4
+WhcNMzUwNjA0MTEwNDM4WjBPMQswCQYDVQQGEwJVUzEpMCcGA1UEChMgSW50ZXJu
+ZXQgU2VjdXJpdHkgUmVzZWFyY2ggR3JvdXAxFTATBgNVBAMTDElTUkcgUm9vdCBY
+MTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAK3oJHP0FDfzm54rVygc
+h77ct984kIxuPOZXoHj3dcKi/vVqbvYATyjb3miGbESTtrFj/RQSa78f0uoxmyF+
+0TM8ukj13Xnfs7j/EvEhmkvBioZxaUpmZmyPfjxwv60pIgbz5MDmgK7iS4+3mX6U
+A5/TR5d8mUgjU+g4rk8Kb4Mu0UlXjIB0ttov0DiNewNwIRt18jA8+o+u3dpjq+sW
+T8KOEUt+zwvo/7V3LvSye0rgTBIlDHCNAymg4VMk7BPZ7hm/ELNKjD+Jo2FR3qyH
+B5T0Y3HsLuJvW5iB4YlcNHlsdu87kGJ55tukmi8mxdAQ4Q7e2RCOFvu396j3x+UC
+B5iPNgiV5+I3lg02dZ77DnKxHZu8A/lJBdiB3QW0KtZB6awBdpUKD9jf1b0SHzUv
+KBds0pjBqAlkd25HN7rOrFleaJ1/ctaJxQZBKT5ZPt0m9STJEadao0xAH0ahmbWn
+OlFuhjuefXKnEgV4We0+UXgVCwOPjdAvBbI+e0ocS3MFEvzG6uBQE3xDk3SzynTn
+jh8BCNAw1FtxNrQHusEwMFxIt4I7mKZ9YIqioymCzLq9gwQbooMDQaHWBfEbwrbw
+qHyGO0aoSCqI3Haadr8faqU9GY/rOPNk3sgrDQoo//fb4hVC1CLQJ13hef4Y53CI
+rU7m2Ys6xt0nUW7/vGT1M0NPAgMBAAGjQjBAMA4GA1UdDwEB/wQEAwIBBjAPBgNV
+HRMBAf8EBTADAQH/MB0GA1UdDgQWBBR5tFnme7bl5AFzgAiIyBpY9umbbjANBgkq
+hkiG9w0BAQsFAAOCAgEAVR9YqbyyqFDQDLHYGmkgJykIrGF1XIpu+ILlaS/V9lZL
+ubhzEFnTIZd+50xx+7LSYK05qAvqFyFWhfFQDlnrzuBZ6brJFe+GnY+EgPbk6ZGQ
+3BebYhtF8GaV0nxvwuo77x/Py9auJ/GpsMiu/X1+mvoiBOv/2X/qkSsisRcOj/KK
+NFtY2PwByVS5uCbMiogziUwthDyC3+6WVwW6LLv3xLfHTjuCvjHIInNzktHCgKQ5
+ORAzI4JMPJ+GslWYHb4phowim57iaztXOoJwTdwJx4nLCgdNbOhdjsnvzqvHu7Ur
+TkXWStAmzOVyyghqpZXjFaH3pO3JLF+l+/+sKAIuvtd7u+Nxe5AW0wdeRlN8NwdC
+jNPElpzVmbUq4JUagEiuTDkHzsxHpFKVK7q4+63SM1N95R1NbdWhscdCb+ZAJzVc
+oyi3B43njTOQ5yOf+1CceWxG1bQVs5ZufpsMljq4Ui0/1lvh+wjChP4kqKOJ2qxq
+4RgqsahDYVvTH9w7jXbyLeiNdd8XM2w9U/t7y0Ff/9yi0GE44Za4rF2LN9d11TPA
+mRGunUHBcnWEvgJBQl9nJEiU0Zsnvgc/ubhPgXRR4Xq37Z0j4r7g1SgEEzwxA57d
+emyPxgcYxn/eR44/KJ4EBs+lVDR3veyJm+kXQ99b21/+jh5Xos1AnX5iItreGCc=
+-----END CERTIFICATE-----
+
+# Issuer: O=FNMT-RCM OU=AC RAIZ FNMT-RCM
+# Subject: O=FNMT-RCM OU=AC RAIZ FNMT-RCM
+# Label: "AC RAIZ FNMT-RCM"
+# Serial: 485876308206448804701554682760554759
+# MD5 Fingerprint: e2:09:04:b4:d3:bd:d1:a0:14:fd:1a:d2:47:c4:57:1d
+# SHA1 Fingerprint: ec:50:35:07:b2:15:c4:95:62:19:e2:a8:9a:5b:42:99:2c:4c:2c:20
+# SHA256 Fingerprint: eb:c5:57:0c:29:01:8c:4d:67:b1:aa:12:7b:af:12:f7:03:b4:61:1e:bc:17:b7:da:b5:57:38:94:17:9b:93:fa
+-----BEGIN CERTIFICATE-----
+MIIFgzCCA2ugAwIBAgIPXZONMGc2yAYdGsdUhGkHMA0GCSqGSIb3DQEBCwUAMDsx
+CzAJBgNVBAYTAkVTMREwDwYDVQQKDAhGTk1ULVJDTTEZMBcGA1UECwwQQUMgUkFJ
+WiBGTk1ULVJDTTAeFw0wODEwMjkxNTU5NTZaFw0zMDAxMDEwMDAwMDBaMDsxCzAJ
+BgNVBAYTAkVTMREwDwYDVQQKDAhGTk1ULVJDTTEZMBcGA1UECwwQQUMgUkFJWiBG
+Tk1ULVJDTTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBALpxgHpMhm5/
+yBNtwMZ9HACXjywMI7sQmkCpGreHiPibVmr75nuOi5KOpyVdWRHbNi63URcfqQgf
+BBckWKo3Shjf5TnUV/3XwSyRAZHiItQDwFj8d0fsjz50Q7qsNI1NOHZnjrDIbzAz
+WHFctPVrbtQBULgTfmxKo0nRIBnuvMApGGWn3v7v3QqQIecaZ5JCEJhfTzC8PhxF
+tBDXaEAUwED653cXeuYLj2VbPNmaUtu1vZ5Gzz3rkQUCwJaydkxNEJY7kvqcfw+Z
+374jNUUeAlz+taibmSXaXvMiwzn15Cou08YfxGyqxRxqAQVKL9LFwag0Jl1mpdIC
+IfkYtwb1TplvqKtMUejPUBjFd8g5CSxJkjKZqLsXF3mwWsXmo8RZZUc1g16p6DUL
+mbvkzSDGm0oGObVo/CK67lWMK07q87Hj/LaZmtVC+nFNCM+HHmpxffnTtOmlcYF7
+wk5HlqX2doWjKI/pgG6BU6VtX7hI+cL5NqYuSf+4lsKMB7ObiFj86xsc3i1w4peS
+MKGJ47xVqCfWS+2QrYv6YyVZLag13cqXM7zlzced0ezvXg5KkAYmY6252TUtB7p2
+ZSysV4999AeU14ECll2jB0nVetBX+RvnU0Z1qrB5QstocQjpYL05ac70r8NWQMet
+UqIJ5G+GR4of6ygnXYMgrwTJbFaai0b1AgMBAAGjgYMwgYAwDwYDVR0TAQH/BAUw
+AwEB/zAOBgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFPd9xf3E6Jobd2Sn9R2gzL+H
+YJptMD4GA1UdIAQ3MDUwMwYEVR0gADArMCkGCCsGAQUFBwIBFh1odHRwOi8vd3d3
+LmNlcnQuZm5tdC5lcy9kcGNzLzANBgkqhkiG9w0BAQsFAAOCAgEAB5BK3/MjTvDD
+nFFlm5wioooMhfNzKWtN/gHiqQxjAb8EZ6WdmF/9ARP67Jpi6Yb+tmLSbkyU+8B1
+RXxlDPiyN8+sD8+Nb/kZ94/sHvJwnvDKuO+3/3Y3dlv2bojzr2IyIpMNOmqOFGYM
+LVN0V2Ue1bLdI4E7pWYjJ2cJj+F3qkPNZVEI7VFY/uY5+ctHhKQV8Xa7pO6kO8Rf
+77IzlhEYt8llvhjho6Tc+hj507wTmzl6NLrTQfv6MooqtyuGC2mDOL7Nii4LcK2N
+JpLuHvUBKwrZ1pebbuCoGRw6IYsMHkCtA+fdZn71uSANA+iW+YJF1DngoABd15jm
+fZ5nc8OaKveri6E6FO80vFIOiZiaBECEHX5FaZNXzuvO+FB8TxxuBEOb+dY7Ixjp
+6o7RTUaN8Tvkasq6+yO3m/qZASlaWFot4/nUbQ4mrcFuNLwy+AwF+mWj2zs3gyLp
+1txyM/1d8iC9djwj2ij3+RvrWWTV3F9yfiD8zYm1kGdNYno/Tq0dwzn+evQoFt9B
+9kiABdcPUXmsEKvU7ANm5mqwujGSQkBqvjrTcuFqN1W8rB2Vt2lh8kORdOag0wok
+RqEIr9baRRmW1FMdW4R58MD3R++Lj8UGrp1MYp3/RgT408m2ECVAdf4WqslKYIYv
+uu8wd+RU4riEmViAqhOLUTpPSPaLtrM=
+-----END CERTIFICATE-----
+
+# Issuer: CN=Amazon Root CA 1 O=Amazon
+# Subject: CN=Amazon Root CA 1 O=Amazon
+# Label: "Amazon Root CA 1"
+# Serial: 143266978916655856878034712317230054538369994
+# MD5 Fingerprint: 43:c6:bf:ae:ec:fe:ad:2f:18:c6:88:68:30:fc:c8:e6
+# SHA1 Fingerprint: 8d:a7:f9:65:ec:5e:fc:37:91:0f:1c:6e:59:fd:c1:cc:6a:6e:de:16
+# SHA256 Fingerprint: 8e:cd:e6:88:4f:3d:87:b1:12:5b:a3:1a:c3:fc:b1:3d:70:16:de:7f:57:cc:90:4f:e1:cb:97:c6:ae:98:19:6e
+-----BEGIN CERTIFICATE-----
+MIIDQTCCAimgAwIBAgITBmyfz5m/jAo54vB4ikPmljZbyjANBgkqhkiG9w0BAQsF
+ADA5MQswCQYDVQQGEwJVUzEPMA0GA1UEChMGQW1hem9uMRkwFwYDVQQDExBBbWF6
+b24gUm9vdCBDQSAxMB4XDTE1MDUyNjAwMDAwMFoXDTM4MDExNzAwMDAwMFowOTEL
+MAkGA1UEBhMCVVMxDzANBgNVBAoTBkFtYXpvbjEZMBcGA1UEAxMQQW1hem9uIFJv
+b3QgQ0EgMTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBALJ4gHHKeNXj
+ca9HgFB0fW7Y14h29Jlo91ghYPl0hAEvrAIthtOgQ3pOsqTQNroBvo3bSMgHFzZM
+9O6II8c+6zf1tRn4SWiw3te5djgdYZ6k/oI2peVKVuRF4fn9tBb6dNqcmzU5L/qw
+IFAGbHrQgLKm+a/sRxmPUDgH3KKHOVj4utWp+UhnMJbulHheb4mjUcAwhmahRWa6
+VOujw5H5SNz/0egwLX0tdHA114gk957EWW67c4cX8jJGKLhD+rcdqsq08p8kDi1L
+93FcXmn/6pUCyziKrlA4b9v7LWIbxcceVOF34GfID5yHI9Y/QCB/IIDEgEw+OyQm
+jgSubJrIqg0CAwEAAaNCMEAwDwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMC
+AYYwHQYDVR0OBBYEFIQYzIU07LwMlJQuCFmcx7IQTgoIMA0GCSqGSIb3DQEBCwUA
+A4IBAQCY8jdaQZChGsV2USggNiMOruYou6r4lK5IpDB/G/wkjUu0yKGX9rbxenDI
+U5PMCCjjmCXPI6T53iHTfIUJrU6adTrCC2qJeHZERxhlbI1Bjjt/msv0tadQ1wUs
+N+gDS63pYaACbvXy8MWy7Vu33PqUXHeeE6V/Uq2V8viTO96LXFvKWlJbYK8U90vv
+o/ufQJVtMVT8QtPHRh8jrdkPSHCa2XV4cdFyQzR1bldZwgJcJmApzyMZFo6IQ6XU
+5MsI+yMRQ+hDKXJioaldXgjUkK642M4UwtBV8ob2xJNDd2ZhwLnoQdeXeGADbkpy
+rqXRfboQnoZsG4q5WTP468SQvvG5
+-----END CERTIFICATE-----
+
+# Issuer: CN=Amazon Root CA 2 O=Amazon
+# Subject: CN=Amazon Root CA 2 O=Amazon
+# Label: "Amazon Root CA 2"
+# Serial: 143266982885963551818349160658925006970653239
+# MD5 Fingerprint: c8:e5:8d:ce:a8:42:e2:7a:c0:2a:5c:7c:9e:26:bf:66
+# SHA1 Fingerprint: 5a:8c:ef:45:d7:a6:98:59:76:7a:8c:8b:44:96:b5:78:cf:47:4b:1a
+# SHA256 Fingerprint: 1b:a5:b2:aa:8c:65:40:1a:82:96:01:18:f8:0b:ec:4f:62:30:4d:83:ce:c4:71:3a:19:c3:9c:01:1e:a4:6d:b4
+-----BEGIN CERTIFICATE-----
+MIIFQTCCAymgAwIBAgITBmyf0pY1hp8KD+WGePhbJruKNzANBgkqhkiG9w0BAQwF
+ADA5MQswCQYDVQQGEwJVUzEPMA0GA1UEChMGQW1hem9uMRkwFwYDVQQDExBBbWF6
+b24gUm9vdCBDQSAyMB4XDTE1MDUyNjAwMDAwMFoXDTQwMDUyNjAwMDAwMFowOTEL
+MAkGA1UEBhMCVVMxDzANBgNVBAoTBkFtYXpvbjEZMBcGA1UEAxMQQW1hem9uIFJv
+b3QgQ0EgMjCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAK2Wny2cSkxK
+gXlRmeyKy2tgURO8TW0G/LAIjd0ZEGrHJgw12MBvIITplLGbhQPDW9tK6Mj4kHbZ
+W0/jTOgGNk3Mmqw9DJArktQGGWCsN0R5hYGCrVo34A3MnaZMUnbqQ523BNFQ9lXg
+1dKmSYXpN+nKfq5clU1Imj+uIFptiJXZNLhSGkOQsL9sBbm2eLfq0OQ6PBJTYv9K
+8nu+NQWpEjTj82R0Yiw9AElaKP4yRLuH3WUnAnE72kr3H9rN9yFVkE8P7K6C4Z9r
+2UXTu/Bfh+08LDmG2j/e7HJV63mjrdvdfLC6HM783k81ds8P+HgfajZRRidhW+me
+z/CiVX18JYpvL7TFz4QuK/0NURBs+18bvBt+xa47mAExkv8LV/SasrlX6avvDXbR
+8O70zoan4G7ptGmh32n2M8ZpLpcTnqWHsFcQgTfJU7O7f/aS0ZzQGPSSbtqDT6Zj
+mUyl+17vIWR6IF9sZIUVyzfpYgwLKhbcAS4y2j5L9Z469hdAlO+ekQiG+r5jqFoz
+7Mt0Q5X5bGlSNscpb/xVA1wf+5+9R+vnSUeVC06JIglJ4PVhHvG/LopyboBZ/1c6
++XUyo05f7O0oYtlNc/LMgRdg7c3r3NunysV+Ar3yVAhU/bQtCSwXVEqY0VThUWcI
+0u1ufm8/0i2BWSlmy5A5lREedCf+3euvAgMBAAGjQjBAMA8GA1UdEwEB/wQFMAMB
+Af8wDgYDVR0PAQH/BAQDAgGGMB0GA1UdDgQWBBSwDPBMMPQFWAJI/TPlUq9LhONm
+UjANBgkqhkiG9w0BAQwFAAOCAgEAqqiAjw54o+Ci1M3m9Zh6O+oAA7CXDpO8Wqj2
+LIxyh6mx/H9z/WNxeKWHWc8w4Q0QshNabYL1auaAn6AFC2jkR2vHat+2/XcycuUY
++gn0oJMsXdKMdYV2ZZAMA3m3MSNjrXiDCYZohMr/+c8mmpJ5581LxedhpxfL86kS
+k5Nrp+gvU5LEYFiwzAJRGFuFjWJZY7attN6a+yb3ACfAXVU3dJnJUH/jWS5E4ywl
+7uxMMne0nxrpS10gxdr9HIcWxkPo1LsmmkVwXqkLN1PiRnsn/eBG8om3zEK2yygm
+btmlyTrIQRNg91CMFa6ybRoVGld45pIq2WWQgj9sAq+uEjonljYE1x2igGOpm/Hl
+urR8FLBOybEfdF849lHqm/osohHUqS0nGkWxr7JOcQ3AWEbWaQbLU8uz/mtBzUF+
+fUwPfHJ5elnNXkoOrJupmHN5fLT0zLm4BwyydFy4x2+IoZCn9Kr5v2c69BoVYh63
+n749sSmvZ6ES8lgQGVMDMBu4Gon2nL2XA46jCfMdiyHxtN/kHNGfZQIG6lzWE7OE
+76KlXIx3KadowGuuQNKotOrN8I1LOJwZmhsoVLiJkO/KdYE+HvJkJMcYr07/R54H
+9jVlpNMKVv/1F2Rs76giJUmTtt8AF9pYfl3uxRuw0dFfIRDH+fO6AgonB8Xx1sfT
+4PsJYGw=
+-----END CERTIFICATE-----
+
+# Issuer: CN=Amazon Root CA 3 O=Amazon
+# Subject: CN=Amazon Root CA 3 O=Amazon
+# Label: "Amazon Root CA 3"
+# Serial: 143266986699090766294700635381230934788665930
+# MD5 Fingerprint: a0:d4:ef:0b:f7:b5:d8:49:95:2a:ec:f5:c4:fc:81:87
+# SHA1 Fingerprint: 0d:44:dd:8c:3c:8c:1a:1a:58:75:64:81:e9:0f:2e:2a:ff:b3:d2:6e
+# SHA256 Fingerprint: 18:ce:6c:fe:7b:f1:4e:60:b2:e3:47:b8:df:e8:68:cb:31:d0:2e:bb:3a:da:27:15:69:f5:03:43:b4:6d:b3:a4
+-----BEGIN CERTIFICATE-----
+MIIBtjCCAVugAwIBAgITBmyf1XSXNmY/Owua2eiedgPySjAKBggqhkjOPQQDAjA5
+MQswCQYDVQQGEwJVUzEPMA0GA1UEChMGQW1hem9uMRkwFwYDVQQDExBBbWF6b24g
+Um9vdCBDQSAzMB4XDTE1MDUyNjAwMDAwMFoXDTQwMDUyNjAwMDAwMFowOTELMAkG
+A1UEBhMCVVMxDzANBgNVBAoTBkFtYXpvbjEZMBcGA1UEAxMQQW1hem9uIFJvb3Qg
+Q0EgMzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABCmXp8ZBf8ANm+gBG1bG8lKl
+ui2yEujSLtf6ycXYqm0fc4E7O5hrOXwzpcVOho6AF2hiRVd9RFgdszflZwjrZt6j
+QjBAMA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgGGMB0GA1UdDgQWBBSr
+ttvXBp43rDCGB5Fwx5zEGbF4wDAKBggqhkjOPQQDAgNJADBGAiEA4IWSoxe3jfkr
+BqWTrBqYaGFy+uGh0PsceGCmQ5nFuMQCIQCcAu/xlJyzlvnrxir4tiz+OpAUFteM
+YyRIHN8wfdVoOw==
+-----END CERTIFICATE-----
+
+# Issuer: CN=Amazon Root CA 4 O=Amazon
+# Subject: CN=Amazon Root CA 4 O=Amazon
+# Label: "Amazon Root CA 4"
+# Serial: 143266989758080763974105200630763877849284878
+# MD5 Fingerprint: 89:bc:27:d5:eb:17:8d:06:6a:69:d5:fd:89:47:b4:cd
+# SHA1 Fingerprint: f6:10:84:07:d6:f8:bb:67:98:0c:c2:e2:44:c2:eb:ae:1c:ef:63:be
+# SHA256 Fingerprint: e3:5d:28:41:9e:d0:20:25:cf:a6:90:38:cd:62:39:62:45:8d:a5:c6:95:fb:de:a3:c2:2b:0b:fb:25:89:70:92
+-----BEGIN CERTIFICATE-----
+MIIB8jCCAXigAwIBAgITBmyf18G7EEwpQ+Vxe3ssyBrBDjAKBggqhkjOPQQDAzA5
+MQswCQYDVQQGEwJVUzEPMA0GA1UEChMGQW1hem9uMRkwFwYDVQQDExBBbWF6b24g
+Um9vdCBDQSA0MB4XDTE1MDUyNjAwMDAwMFoXDTQwMDUyNjAwMDAwMFowOTELMAkG
+A1UEBhMCVVMxDzANBgNVBAoTBkFtYXpvbjEZMBcGA1UEAxMQQW1hem9uIFJvb3Qg
+Q0EgNDB2MBAGByqGSM49AgEGBSuBBAAiA2IABNKrijdPo1MN/sGKe0uoe0ZLY7Bi
+9i0b2whxIdIA6GO9mif78DluXeo9pcmBqqNbIJhFXRbb/egQbeOc4OO9X4Ri83Bk
+M6DLJC9wuoihKqB1+IGuYgbEgds5bimwHvouXKNCMEAwDwYDVR0TAQH/BAUwAwEB
+/zAOBgNVHQ8BAf8EBAMCAYYwHQYDVR0OBBYEFNPsxzplbszh2naaVvuc84ZtV+WB
+MAoGCCqGSM49BAMDA2gAMGUCMDqLIfG9fhGt0O9Yli/W651+kI0rz2ZVwyzjKKlw
+CkcO8DdZEv8tmZQoTipPNU0zWgIxAOp1AE47xDqUEpHJWEadIRNyp4iciuRMStuW
+1KyLa2tJElMzrdfkviT8tQp21KW8EA==
+-----END CERTIFICATE-----
+
+# Issuer: CN=TUBITAK Kamu SM SSL Kok Sertifikasi - Surum 1 O=Turkiye Bilimsel ve Teknolojik Arastirma Kurumu - TUBITAK OU=Kamu Sertifikasyon Merkezi - Kamu SM
+# Subject: CN=TUBITAK Kamu SM SSL Kok Sertifikasi - Surum 1 O=Turkiye Bilimsel ve Teknolojik Arastirma Kurumu - TUBITAK OU=Kamu Sertifikasyon Merkezi - Kamu SM
+# Label: "TUBITAK Kamu SM SSL Kok Sertifikasi - Surum 1"
+# Serial: 1
+# MD5 Fingerprint: dc:00:81:dc:69:2f:3e:2f:b0:3b:f6:3d:5a:91:8e:49
+# SHA1 Fingerprint: 31:43:64:9b:ec:ce:27:ec:ed:3a:3f:0b:8f:0d:e4:e8:91:dd:ee:ca
+# SHA256 Fingerprint: 46:ed:c3:68:90:46:d5:3a:45:3f:b3:10:4a:b8:0d:ca:ec:65:8b:26:60:ea:16:29:dd:7e:86:79:90:64:87:16
+-----BEGIN CERTIFICATE-----
+MIIEYzCCA0ugAwIBAgIBATANBgkqhkiG9w0BAQsFADCB0jELMAkGA1UEBhMCVFIx
+GDAWBgNVBAcTD0dlYnplIC0gS29jYWVsaTFCMEAGA1UEChM5VHVya2l5ZSBCaWxp
+bXNlbCB2ZSBUZWtub2xvamlrIEFyYXN0aXJtYSBLdXJ1bXUgLSBUVUJJVEFLMS0w
+KwYDVQQLEyRLYW11IFNlcnRpZmlrYXN5b24gTWVya2V6aSAtIEthbXUgU00xNjA0
+BgNVBAMTLVRVQklUQUsgS2FtdSBTTSBTU0wgS29rIFNlcnRpZmlrYXNpIC0gU3Vy
+dW0gMTAeFw0xMzExMjUwODI1NTVaFw00MzEwMjUwODI1NTVaMIHSMQswCQYDVQQG
+EwJUUjEYMBYGA1UEBxMPR2ViemUgLSBLb2NhZWxpMUIwQAYDVQQKEzlUdXJraXll
+IEJpbGltc2VsIHZlIFRla25vbG9qaWsgQXJhc3Rpcm1hIEt1cnVtdSAtIFRVQklU
+QUsxLTArBgNVBAsTJEthbXUgU2VydGlmaWthc3lvbiBNZXJrZXppIC0gS2FtdSBT
+TTE2MDQGA1UEAxMtVFVCSVRBSyBLYW11IFNNIFNTTCBLb2sgU2VydGlmaWthc2kg
+LSBTdXJ1bSAxMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAr3UwM6q7
+a9OZLBI3hNmNe5eA027n/5tQlT6QlVZC1xl8JoSNkvoBHToP4mQ4t4y86Ij5iySr
+LqP1N+RAjhgleYN1Hzv/bKjFxlb4tO2KRKOrbEz8HdDc72i9z+SqzvBV96I01INr
+N3wcwv61A+xXzry0tcXtAA9TNypN9E8Mg/uGz8v+jE69h/mniyFXnHrfA2eJLJ2X
+YacQuFWQfw4tJzh03+f92k4S400VIgLI4OD8D62K18lUUMw7D8oWgITQUVbDjlZ/
+iSIzL+aFCr2lqBs23tPcLG07xxO9WSMs5uWk99gL7eqQQESolbuT1dCANLZGeA4f
+AJNG4e7p+exPFwIDAQABo0IwQDAdBgNVHQ4EFgQUZT/HiobGPN08VFw1+DrtUgxH
+V8gwDgYDVR0PAQH/BAQDAgEGMA8GA1UdEwEB/wQFMAMBAf8wDQYJKoZIhvcNAQEL
+BQADggEBACo/4fEyjq7hmFxLXs9rHmoJ0iKpEsdeV31zVmSAhHqT5Am5EM2fKifh
+AHe+SMg1qIGf5LgsyX8OsNJLN13qudULXjS99HMpw+0mFZx+CFOKWI3QSyjfwbPf
+IPP54+M638yclNhOT8NrF7f3cuitZjO1JVOr4PhMqZ398g26rrnZqsZr+ZO7rqu4
+lzwDGrpDxpa5RXI4s6ehlj2Re37AIVNMh+3yC1SVUZPVIqUNivGTDj5UDrDYyU7c
+8jEyVupk+eq1nRZmQnLzf9OxMUP8pI4X8W0jq5Rm+K37DwhuJi1/FwcJsoz7UMCf
+lo3Ptv0AnVoUmr8CRPXBwp8iXqIPoeM=
+-----END CERTIFICATE-----
+
+# Issuer: CN=GDCA TrustAUTH R5 ROOT O=GUANG DONG CERTIFICATE AUTHORITY CO.,LTD.
+# Subject: CN=GDCA TrustAUTH R5 ROOT O=GUANG DONG CERTIFICATE AUTHORITY CO.,LTD.
+# Label: "GDCA TrustAUTH R5 ROOT"
+# Serial: 9009899650740120186
+# MD5 Fingerprint: 63:cc:d9:3d:34:35:5c:6f:53:a3:e2:08:70:48:1f:b4
+# SHA1 Fingerprint: 0f:36:38:5b:81:1a:25:c3:9b:31:4e:83:ca:e9:34:66:70:cc:74:b4
+# SHA256 Fingerprint: bf:ff:8f:d0:44:33:48:7d:6a:8a:a6:0c:1a:29:76:7a:9f:c2:bb:b0:5e:42:0f:71:3a:13:b9:92:89:1d:38:93
+-----BEGIN CERTIFICATE-----
+MIIFiDCCA3CgAwIBAgIIfQmX/vBH6nowDQYJKoZIhvcNAQELBQAwYjELMAkGA1UE
+BhMCQ04xMjAwBgNVBAoMKUdVQU5HIERPTkcgQ0VSVElGSUNBVEUgQVVUSE9SSVRZ
+IENPLixMVEQuMR8wHQYDVQQDDBZHRENBIFRydXN0QVVUSCBSNSBST09UMB4XDTE0
+MTEyNjA1MTMxNVoXDTQwMTIzMTE1NTk1OVowYjELMAkGA1UEBhMCQ04xMjAwBgNV
+BAoMKUdVQU5HIERPTkcgQ0VSVElGSUNBVEUgQVVUSE9SSVRZIENPLixMVEQuMR8w
+HQYDVQQDDBZHRENBIFRydXN0QVVUSCBSNSBST09UMIICIjANBgkqhkiG9w0BAQEF
+AAOCAg8AMIICCgKCAgEA2aMW8Mh0dHeb7zMNOwZ+Vfy1YI92hhJCfVZmPoiC7XJj
+Dp6L3TQsAlFRwxn9WVSEyfFrs0yw6ehGXTjGoqcuEVe6ghWinI9tsJlKCvLriXBj
+TnnEt1u9ol2x8kECK62pOqPseQrsXzrj/e+APK00mxqriCZ7VqKChh/rNYmDf1+u
+KU49tm7srsHwJ5uu4/Ts765/94Y9cnrrpftZTqfrlYwiOXnhLQiPzLyRuEH3FMEj
+qcOtmkVEs7LXLM3GKeJQEK5cy4KOFxg2fZfmiJqwTTQJ9Cy5WmYqsBebnh52nUpm
+MUHfP/vFBu8btn4aRjb3ZGM74zkYI+dndRTVdVeSN72+ahsmUPI2JgaQxXABZG12
+ZuGR224HwGGALrIuL4xwp9E7PLOR5G62xDtw8mySlwnNR30YwPO7ng/Wi64HtloP
+zgsMR6flPri9fcebNaBhlzpBdRfMK5Z3KpIhHtmVdiBnaM8Nvd/WHwlqmuLMc3Gk
+L30SgLdTMEZeS1SZD2fJpcjyIMGC7J0R38IC+xo70e0gmu9lZJIQDSri3nDxGGeC
+jGHeuLzRL5z7D9Ar7Rt2ueQ5Vfj4oR24qoAATILnsn8JuLwwoC8N9VKejveSswoA
+HQBUlwbgsQfZxw9cZX08bVlX5O2ljelAU58VS6Bx9hoh49pwBiFYFIeFd3mqgnkC
+AwEAAaNCMEAwHQYDVR0OBBYEFOLJQJ9NzuiaoXzPDj9lxSmIahlRMA8GA1UdEwEB
+/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgGGMA0GCSqGSIb3DQEBCwUAA4ICAQDRSVfg
+p8xoWLoBDysZzY2wYUWsEe1jUGn4H3++Fo/9nesLqjJHdtJnJO29fDMylyrHBYZm
+DRd9FBUb1Ov9H5r2XpdptxolpAqzkT9fNqyL7FeoPueBihhXOYV0GkLH6VsTX4/5
+COmSdI31R9KrO9b7eGZONn356ZLpBN79SWP8bfsUcZNnL0dKt7n/HipzcEYwv1ry
+L3ml4Y0M2fmyYzeMN2WFcGpcWwlyua1jPLHd+PwyvzeG5LuOmCd+uh8W4XAR8gPf
+JWIyJyYYMoSf/wA6E7qaTfRPuBRwIrHKK5DOKcFw9C+df/KQHtZa37dG/OaG+svg
+IHZ6uqbL9XzeYqWxi+7egmaKTjowHz+Ay60nugxe19CxVsp3cbK1daFQqUBDF8Io
+2c9Si1vIY9RCPqAzekYu9wogRlR+ak8x8YF+QnQ4ZXMn7sZ8uI7XpTrXmKGcjBBV
+09tL7ECQ8s1uV9JiDnxXk7Gnbc2dg7sq5+W2O3FYrf3RRbxake5TFW/TRQl1brqQ
+XR4EzzffHqhmsYzmIGrv/EhOdJhCrylvLmrH+33RZjEizIYAfmaDDEL0vTSSwxrq
+T8p+ck0LcIymSLumoRT2+1hEmRSuqguTaaApJUqlyyvdimYHFngVV3Eb7PVHhPOe
+MTd61X8kreS8/f3MboPoDKi3QWwH3b08hpcv0g==
+-----END CERTIFICATE-----
+
+# Issuer: CN=SSL.com Root Certification Authority RSA O=SSL Corporation
+# Subject: CN=SSL.com Root Certification Authority RSA O=SSL Corporation
+# Label: "SSL.com Root Certification Authority RSA"
+# Serial: 8875640296558310041
+# MD5 Fingerprint: 86:69:12:c0:70:f1:ec:ac:ac:c2:d5:bc:a5:5b:a1:29
+# SHA1 Fingerprint: b7:ab:33:08:d1:ea:44:77:ba:14:80:12:5a:6f:bd:a9:36:49:0c:bb
+# SHA256 Fingerprint: 85:66:6a:56:2e:e0:be:5c:e9:25:c1:d8:89:0a:6f:76:a8:7e:c1:6d:4d:7d:5f:29:ea:74:19:cf:20:12:3b:69
+-----BEGIN CERTIFICATE-----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+-----END CERTIFICATE-----
+
+# Issuer: CN=SSL.com Root Certification Authority ECC O=SSL Corporation
+# Subject: CN=SSL.com Root Certification Authority ECC O=SSL Corporation
+# Label: "SSL.com Root Certification Authority ECC"
+# Serial: 8495723813297216424
+# MD5 Fingerprint: 2e:da:e4:39:7f:9c:8f:37:d1:70:9f:26:17:51:3a:8e
+# SHA1 Fingerprint: c3:19:7c:39:24:e6:54:af:1b:c4:ab:20:95:7a:e2:c3:0e:13:02:6a
+# SHA256 Fingerprint: 34:17:bb:06:cc:60:07:da:1b:96:1c:92:0b:8a:b4:ce:3f:ad:82:0e:4a:a3:0b:9a:cb:c4:a7:4e:bd:ce:bc:65
+-----BEGIN CERTIFICATE-----
+MIICjTCCAhSgAwIBAgIIdebfy8FoW6gwCgYIKoZIzj0EAwIwfDELMAkGA1UEBhMC
+VVMxDjAMBgNVBAgMBVRleGFzMRAwDgYDVQQHDAdIb3VzdG9uMRgwFgYDVQQKDA9T
+U0wgQ29ycG9yYXRpb24xMTAvBgNVBAMMKFNTTC5jb20gUm9vdCBDZXJ0aWZpY2F0
+aW9uIEF1dGhvcml0eSBFQ0MwHhcNMTYwMjEyMTgxNDAzWhcNNDEwMjEyMTgxNDAz
+WjB8MQswCQYDVQQGEwJVUzEOMAwGA1UECAwFVGV4YXMxEDAOBgNVBAcMB0hvdXN0
+b24xGDAWBgNVBAoMD1NTTCBDb3Jwb3JhdGlvbjExMC8GA1UEAwwoU1NMLmNvbSBS
+b290IENlcnRpZmljYXRpb24gQXV0aG9yaXR5IEVDQzB2MBAGByqGSM49AgEGBSuB
+BAAiA2IABEVuqVDEpiM2nl8ojRfLliJkP9x6jh3MCLOicSS6jkm5BBtHllirLZXI
+7Z4INcgn64mMU1jrYor+8FsPazFSY0E7ic3s7LaNGdM0B9y7xgZ/wkWV7Mt/qCPg
+CemB+vNH06NjMGEwHQYDVR0OBBYEFILRhXMw5zUE044CkvvlpNHEIejNMA8GA1Ud
+EwEB/wQFMAMBAf8wHwYDVR0jBBgwFoAUgtGFczDnNQTTjgKS++Wk0cQh6M0wDgYD
+VR0PAQH/BAQDAgGGMAoGCCqGSM49BAMCA2cAMGQCMG/n61kRpGDPYbCWe+0F+S8T
+kdzt5fxQaxFGRrMcIQBiu77D5+jNB5n5DQtdcj7EqgIwH7y6C+IwJPt8bYBVCpk+
+gA0z5Wajs6O7pdWLjwkspl1+4vAHCGht0nxpbl/f5Wpl
+-----END CERTIFICATE-----
+
+# Issuer: CN=SSL.com EV Root Certification Authority RSA R2 O=SSL Corporation
+# Subject: CN=SSL.com EV Root Certification Authority RSA R2 O=SSL Corporation
+# Label: "SSL.com EV Root Certification Authority RSA R2"
+# Serial: 6248227494352943350
+# MD5 Fingerprint: e1:1e:31:58:1a:ae:54:53:02:f6:17:6a:11:7b:4d:95
+# SHA1 Fingerprint: 74:3a:f0:52:9b:d0:32:a0:f4:4a:83:cd:d4:ba:a9:7b:7c:2e:c4:9a
+# SHA256 Fingerprint: 2e:7b:f1:6c:c2:24:85:a7:bb:e2:aa:86:96:75:07:61:b0:ae:39:be:3b:2f:e9:d0:cc:6d:4e:f7:34:91:42:5c
+-----BEGIN CERTIFICATE-----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+-----END CERTIFICATE-----
+
+# Issuer: CN=SSL.com EV Root Certification Authority ECC O=SSL Corporation
+# Subject: CN=SSL.com EV Root Certification Authority ECC O=SSL Corporation
+# Label: "SSL.com EV Root Certification Authority ECC"
+# Serial: 3182246526754555285
+# MD5 Fingerprint: 59:53:22:65:83:42:01:54:c0:ce:42:b9:5a:7c:f2:90
+# SHA1 Fingerprint: 4c:dd:51:a3:d1:f5:20:32:14:b0:c6:c5:32:23:03:91:c7:46:42:6d
+# SHA256 Fingerprint: 22:a2:c1:f7:bd:ed:70:4c:c1:e7:01:b5:f4:08:c3:10:88:0f:e9:56:b5:de:2a:4a:44:f9:9c:87:3a:25:a7:c8
+-----BEGIN CERTIFICATE-----
+MIIClDCCAhqgAwIBAgIILCmcWxbtBZUwCgYIKoZIzj0EAwIwfzELMAkGA1UEBhMC
+VVMxDjAMBgNVBAgMBVRleGFzMRAwDgYDVQQHDAdIb3VzdG9uMRgwFgYDVQQKDA9T
+U0wgQ29ycG9yYXRpb24xNDAyBgNVBAMMK1NTTC5jb20gRVYgUm9vdCBDZXJ0aWZp
+Y2F0aW9uIEF1dGhvcml0eSBFQ0MwHhcNMTYwMjEyMTgxNTIzWhcNNDEwMjEyMTgx
+NTIzWjB/MQswCQYDVQQGEwJVUzEOMAwGA1UECAwFVGV4YXMxEDAOBgNVBAcMB0hv
+dXN0b24xGDAWBgNVBAoMD1NTTCBDb3Jwb3JhdGlvbjE0MDIGA1UEAwwrU1NMLmNv
+bSBFViBSb290IENlcnRpZmljYXRpb24gQXV0aG9yaXR5IEVDQzB2MBAGByqGSM49
+AgEGBSuBBAAiA2IABKoSR5CYG/vvw0AHgyBO8TCCogbR8pKGYfL2IWjKAMTH6kMA
+VIbc/R/fALhBYlzccBYy3h+Z1MzFB8gIH2EWB1E9fVwHU+M1OIzfzZ/ZLg1Kthku
+WnBaBu2+8KGwytAJKaNjMGEwHQYDVR0OBBYEFFvKXuXe0oGqzagtZFG22XKbl+ZP
+MA8GA1UdEwEB/wQFMAMBAf8wHwYDVR0jBBgwFoAUW8pe5d7SgarNqC1kUbbZcpuX
+5k8wDgYDVR0PAQH/BAQDAgGGMAoGCCqGSM49BAMCA2gAMGUCMQCK5kCJN+vp1RPZ
+ytRrJPOwPYdGWBrssd9v+1a6cGvHOMzosYxPD/fxZ3YOg9AeUY8CMD32IygmTMZg
+h5Mmm7I1HrrW9zzRHM76JTymGoEVW/MSD2zuZYrJh6j5B+BimoxcSg==
+-----END CERTIFICATE-----
+
+# Issuer: CN=GlobalSign O=GlobalSign OU=GlobalSign Root CA - R6
+# Subject: CN=GlobalSign O=GlobalSign OU=GlobalSign Root CA - R6
+# Label: "GlobalSign Root CA - R6"
+# Serial: 1417766617973444989252670301619537
+# MD5 Fingerprint: 4f:dd:07:e4:d4:22:64:39:1e:0c:37:42:ea:d1:c6:ae
+# SHA1 Fingerprint: 80:94:64:0e:b5:a7:a1:ca:11:9c:1f:dd:d5:9f:81:02:63:a7:fb:d1
+# SHA256 Fingerprint: 2c:ab:ea:fe:37:d0:6c:a2:2a:ba:73:91:c0:03:3d:25:98:29:52:c4:53:64:73:49:76:3a:3a:b5:ad:6c:cf:69
+-----BEGIN CERTIFICATE-----
+MIIFgzCCA2ugAwIBAgIORea7A4Mzw4VlSOb/RVEwDQYJKoZIhvcNAQEMBQAwTDEg
+MB4GA1UECxMXR2xvYmFsU2lnbiBSb290IENBIC0gUjYxEzARBgNVBAoTCkdsb2Jh
+bFNpZ24xEzARBgNVBAMTCkdsb2JhbFNpZ24wHhcNMTQxMjEwMDAwMDAwWhcNMzQx
+MjEwMDAwMDAwWjBMMSAwHgYDVQQLExdHbG9iYWxTaWduIFJvb3QgQ0EgLSBSNjET
+MBEGA1UEChMKR2xvYmFsU2lnbjETMBEGA1UEAxMKR2xvYmFsU2lnbjCCAiIwDQYJ
+KoZIhvcNAQEBBQADggIPADCCAgoCggIBAJUH6HPKZvnsFMp7PPcNCPG0RQssgrRI
+xutbPK6DuEGSMxSkb3/pKszGsIhrxbaJ0cay/xTOURQh7ErdG1rG1ofuTToVBu1k
+ZguSgMpE3nOUTvOniX9PeGMIyBJQbUJmL025eShNUhqKGoC3GYEOfsSKvGRMIRxD
+aNc9PIrFsmbVkJq3MQbFvuJtMgamHvm566qjuL++gmNQ0PAYid/kD3n16qIfKtJw
+LnvnvJO7bVPiSHyMEAc4/2ayd2F+4OqMPKq0pPbzlUoSB239jLKJz9CgYXfIWHSw
+1CM69106yqLbnQneXUQtkPGBzVeS+n68UARjNN9rkxi+azayOeSsJDa38O+2HBNX
+k7besvjihbdzorg1qkXy4J02oW9UivFyVm4uiMVRQkQVlO6jxTiWm05OWgtH8wY2
+SXcwvHE35absIQh1/OZhFj931dmRl4QKbNQCTXTAFO39OfuD8l4UoQSwC+n+7o/h
+bguyCLNhZglqsQY6ZZZZwPA1/cnaKI0aEYdwgQqomnUdnjqGBQCe24DWJfncBZ4n
+WUx2OVvq+aWh2IMP0f/fMBH5hc8zSPXKbWQULHpYT9NLCEnFlWQaYw55PfWzjMpY
+rZxCRXluDocZXFSxZba/jJvcE+kNb7gu3GduyYsRtYQUigAZcIN5kZeR1Bonvzce
+MgfYFGM8KEyvAgMBAAGjYzBhMA4GA1UdDwEB/wQEAwIBBjAPBgNVHRMBAf8EBTAD
+AQH/MB0GA1UdDgQWBBSubAWjkxPioufi1xzWx/B/yGdToDAfBgNVHSMEGDAWgBSu
+bAWjkxPioufi1xzWx/B/yGdToDANBgkqhkiG9w0BAQwFAAOCAgEAgyXt6NH9lVLN
+nsAEoJFp5lzQhN7craJP6Ed41mWYqVuoPId8AorRbrcWc+ZfwFSY1XS+wc3iEZGt
+Ixg93eFyRJa0lV7Ae46ZeBZDE1ZXs6KzO7V33EByrKPrmzU+sQghoefEQzd5Mr61
+55wsTLxDKZmOMNOsIeDjHfrYBzN2VAAiKrlNIC5waNrlU/yDXNOd8v9EDERm8tLj
+vUYAGm0CuiVdjaExUd1URhxN25mW7xocBFymFe944Hn+Xds+qkxV/ZoVqW/hpvvf
+cDDpw+5CRu3CkwWJ+n1jez/QcYF8AOiYrg54NMMl+68KnyBr3TsTjxKM4kEaSHpz
+oHdpx7Zcf4LIHv5YGygrqGytXm3ABdJ7t+uA/iU3/gKbaKxCXcPu9czc8FB10jZp
+nOZ7BN9uBmm23goJSFmH63sUYHpkqmlD75HHTOwY3WzvUy2MmeFe8nI+z1TIvWfs
+pA9MRf/TuTAjB0yPEL+GltmZWrSZVxykzLsViVO6LAUP5MSeGbEYNNVMnbrt9x+v
+JJUEeKgDu+6B5dpffItKoZB0JaezPkvILFa9x8jvOOJckvB595yEunQtYQEgfn7R
+8k8HWV+LLUNS60YMlOH1Zkd5d9VUWx+tJDfLRVpOoERIyNiwmcUVhAn21klJwGW4
+5hpxbqCo8YLoRT5s1gLXCmeDBVrJpBA=
+-----END CERTIFICATE-----
+
+# Issuer: CN=OISTE WISeKey Global Root GC CA O=WISeKey OU=OISTE Foundation Endorsed
+# Subject: CN=OISTE WISeKey Global Root GC CA O=WISeKey OU=OISTE Foundation Endorsed
+# Label: "OISTE WISeKey Global Root GC CA"
+# Serial: 44084345621038548146064804565436152554
+# MD5 Fingerprint: a9:d6:b9:2d:2f:93:64:f8:a5:69:ca:91:e9:68:07:23
+# SHA1 Fingerprint: e0:11:84:5e:34:de:be:88:81:b9:9c:f6:16:26:d1:96:1f:c3:b9:31
+# SHA256 Fingerprint: 85:60:f9:1c:36:24:da:ba:95:70:b5:fe:a0:db:e3:6f:f1:1a:83:23:be:94:86:85:4f:b3:f3:4a:55:71:19:8d
+-----BEGIN CERTIFICATE-----
+MIICaTCCAe+gAwIBAgIQISpWDK7aDKtARb8roi066jAKBggqhkjOPQQDAzBtMQsw
+CQYDVQQGEwJDSDEQMA4GA1UEChMHV0lTZUtleTEiMCAGA1UECxMZT0lTVEUgRm91
+bmRhdGlvbiBFbmRvcnNlZDEoMCYGA1UEAxMfT0lTVEUgV0lTZUtleSBHbG9iYWwg
+Um9vdCBHQyBDQTAeFw0xNzA1MDkwOTQ4MzRaFw00MjA1MDkwOTU4MzNaMG0xCzAJ
+BgNVBAYTAkNIMRAwDgYDVQQKEwdXSVNlS2V5MSIwIAYDVQQLExlPSVNURSBGb3Vu
+ZGF0aW9uIEVuZG9yc2VkMSgwJgYDVQQDEx9PSVNURSBXSVNlS2V5IEdsb2JhbCBS
+b290IEdDIENBMHYwEAYHKoZIzj0CAQYFK4EEACIDYgAETOlQwMYPchi82PG6s4ni
+eUqjFqdrVCTbUf/q9Akkwwsin8tqJ4KBDdLArzHkdIJuyiXZjHWd8dvQmqJLIX4W
+p2OQ0jnUsYd4XxiWD1AbNTcPasbc2RNNpI6QN+a9WzGRo1QwUjAOBgNVHQ8BAf8E
+BAMCAQYwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSIcUrOPDnpBgOtfKie7T
+rYy0UGYwEAYJKwYBBAGCNxUBBAMCAQAwCgYIKoZIzj0EAwMDaAAwZQIwJsdpW9zV
+57LnyAyMjMPdeYwbY9XJUpROTYJKcx6ygISpJcBMWm1JKWB4E+J+SOtkAjEA2zQg
+Mgj/mkkCtojeFK9dbJlxjRo/i9fgojaGHAeCOnZT/cKi7e97sIBPWA9LUzm9
+-----END CERTIFICATE-----
+
+# Issuer: CN=UCA Global G2 Root O=UniTrust
+# Subject: CN=UCA Global G2 Root O=UniTrust
+# Label: "UCA Global G2 Root"
+# Serial: 124779693093741543919145257850076631279
+# MD5 Fingerprint: 80:fe:f0:c4:4a:f0:5c:62:32:9f:1c:ba:78:a9:50:f8
+# SHA1 Fingerprint: 28:f9:78:16:19:7a:ff:18:25:18:aa:44:fe:c1:a0:ce:5c:b6:4c:8a
+# SHA256 Fingerprint: 9b:ea:11:c9:76:fe:01:47:64:c1:be:56:a6:f9:14:b5:a5:60:31:7a:bd:99:88:39:33:82:e5:16:1a:a0:49:3c
+-----BEGIN CERTIFICATE-----
+MIIFRjCCAy6gAwIBAgIQXd+x2lqj7V2+WmUgZQOQ7zANBgkqhkiG9w0BAQsFADA9
+MQswCQYDVQQGEwJDTjERMA8GA1UECgwIVW5pVHJ1c3QxGzAZBgNVBAMMElVDQSBH
+bG9iYWwgRzIgUm9vdDAeFw0xNjAzMTEwMDAwMDBaFw00MDEyMzEwMDAwMDBaMD0x
+CzAJBgNVBAYTAkNOMREwDwYDVQQKDAhVbmlUcnVzdDEbMBkGA1UEAwwSVUNBIEds
+b2JhbCBHMiBSb290MIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEAxeYr
+b3zvJgUno4Ek2m/LAfmZmqkywiKHYUGRO8vDaBsGxUypK8FnFyIdK+35KYmToni9
+kmugow2ifsqTs6bRjDXVdfkX9s9FxeV67HeToI8jrg4aA3++1NDtLnurRiNb/yzm
+VHqUwCoV8MmNsHo7JOHXaOIxPAYzRrZUEaalLyJUKlgNAQLx+hVRZ2zA+te2G3/R
+VogvGjqNO7uCEeBHANBSh6v7hn4PJGtAnTRnvI3HLYZveT6OqTwXS3+wmeOwcWDc
+C/Vkw85DvG1xudLeJ1uK6NjGruFZfc8oLTW4lVYa8bJYS7cSN8h8s+1LgOGN+jIj
+tm+3SJUIsUROhYw6AlQgL9+/V087OpAh18EmNVQg7Mc/R+zvWr9LesGtOxdQXGLY
+D0tK3Cv6brxzks3sx1DoQZbXqX5t2Okdj4q1uViSukqSKwxW/YDrCPBeKW4bHAyv
+j5OJrdu9o54hyokZ7N+1wxrrFv54NkzWbtA+FxyQF2smuvt6L78RHBgOLXMDj6Dl
+NaBa4kx1HXHhOThTeEDMg5PXCp6dW4+K5OXgSORIskfNTip1KnvyIvbJvgmRlld6
+iIis7nCs+dwp4wwcOxJORNanTrAmyPPZGpeRaOrvjUYG0lZFWJo8DA+DuAUlwznP
+O6Q0ibd5Ei9Hxeepl2n8pndntd978XplFeRhVmUCAwEAAaNCMEAwDgYDVR0PAQH/
+BAQDAgEGMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFIHEjMz15DD/pQwIX4wV
+ZyF0Ad/fMA0GCSqGSIb3DQEBCwUAA4ICAQATZSL1jiutROTL/7lo5sOASD0Ee/oj
+L3rtNtqyzm325p7lX1iPyzcyochltq44PTUbPrw7tgTQvPlJ9Zv3hcU2tsu8+Mg5
+1eRfB70VVJd0ysrtT7q6ZHafgbiERUlMjW+i67HM0cOU2kTC5uLqGOiiHycFutfl
+1qnN3e92mI0ADs0b+gO3joBYDic/UvuUospeZcnWhNq5NXHzJsBPd+aBJ9J3O5oU
+b3n09tDh05S60FdRvScFDcH9yBIw7m+NESsIndTUv4BFFJqIRNow6rSn4+7vW4LV
+PtateJLbXDzz2K36uGt/xDYotgIVilQsnLAXc47QN6MUPJiVAAwpBVueSUmxX8fj
+y88nZY41F7dXyDDZQVu5FLbowg+UMaeUmMxq67XhJ/UQqAHojhJi6IjMtX9Gl8Cb
+EGY4GjZGXyJoPd/JxhMnq1MGrKI8hgZlb7F+sSlEmqO6SWkoaY/X5V+tBIZkbxqg
+DMUIYs6Ao9Dz7GjevjPHF1t/gMRMTLGmhIrDO7gJzRSBuhjjVFc2/tsvfEehOjPI
++Vg7RE+xygKJBJYoaMVLuCaJu9YzL1DV/pqJuhgyklTGW+Cd+V7lDSKb9triyCGy
+YiGqhkCyLmTTX8jjfhFnRR8F/uOi77Oos/N9j/gMHyIfLXC0uAE0djAA5SN4p1bX
+UB+K+wb1whnw0A==
+-----END CERTIFICATE-----
+
+# Issuer: CN=UCA Extended Validation Root O=UniTrust
+# Subject: CN=UCA Extended Validation Root O=UniTrust
+# Label: "UCA Extended Validation Root"
+# Serial: 106100277556486529736699587978573607008
+# MD5 Fingerprint: a1:f3:5f:43:c6:34:9b:da:bf:8c:7e:05:53:ad:96:e2
+# SHA1 Fingerprint: a3:a1:b0:6f:24:61:23:4a:e3:36:a5:c2:37:fc:a6:ff:dd:f0:d7:3a
+# SHA256 Fingerprint: d4:3a:f9:b3:54:73:75:5c:96:84:fc:06:d7:d8:cb:70:ee:5c:28:e7:73:fb:29:4e:b4:1e:e7:17:22:92:4d:24
+-----BEGIN CERTIFICATE-----
+MIIFWjCCA0KgAwIBAgIQT9Irj/VkyDOeTzRYZiNwYDANBgkqhkiG9w0BAQsFADBH
+MQswCQYDVQQGEwJDTjERMA8GA1UECgwIVW5pVHJ1c3QxJTAjBgNVBAMMHFVDQSBF
+eHRlbmRlZCBWYWxpZGF0aW9uIFJvb3QwHhcNMTUwMzEzMDAwMDAwWhcNMzgxMjMx
+MDAwMDAwWjBHMQswCQYDVQQGEwJDTjERMA8GA1UECgwIVW5pVHJ1c3QxJTAjBgNV
+BAMMHFVDQSBFeHRlbmRlZCBWYWxpZGF0aW9uIFJvb3QwggIiMA0GCSqGSIb3DQEB
+AQUAA4ICDwAwggIKAoICAQCpCQcoEwKwmeBkqh5DFnpzsZGgdT6o+uM4AHrsiWog
+D4vFsJszA1qGxliG1cGFu0/GnEBNyr7uaZa4rYEwmnySBesFK5pI0Lh2PpbIILvS
+sPGP2KxFRv+qZ2C0d35qHzwaUnoEPQc8hQ2E0B92CvdqFN9y4zR8V05WAT558aop
+O2z6+I9tTcg1367r3CTueUWnhbYFiN6IXSV8l2RnCdm/WhUFhvMJHuxYMjMR83dk
+sHYf5BA1FxvyDrFspCqjc/wJHx4yGVMR59mzLC52LqGj3n5qiAno8geK+LLNEOfi
+c0CTuwjRP+H8C5SzJe98ptfRr5//lpr1kXuYC3fUfugH0mK1lTnj8/FtDw5lhIpj
+VMWAtuCeS31HJqcBCF3RiJ7XwzJE+oJKCmhUfzhTA8ykADNkUVkLo4KRel7sFsLz
+KuZi2irbWWIQJUoqgQtHB0MGcIfS+pMRKXpITeuUx3BNr2fVUbGAIAEBtHoIppB/
+TuDvB0GHr2qlXov7z1CymlSvw4m6WC31MJixNnI5fkkE/SmnTHnkBVfblLkWU41G
+sx2VYVdWf6/wFlthWG82UBEL2KwrlRYaDh8IzTY0ZRBiZtWAXxQgXy0MoHgKaNYs
+1+lvK9JKBZP8nm9rZ/+I8U6laUpSNwXqxhaN0sSZ0YIrO7o1dfdRUVjzyAfd5LQD
+fwIDAQABo0IwQDAdBgNVHQ4EFgQU2XQ65DA9DfcS3H5aBZ8eNJr34RQwDwYDVR0T
+AQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMCAYYwDQYJKoZIhvcNAQELBQADggIBADaN
+l8xCFWQpN5smLNb7rhVpLGsaGvdftvkHTFnq88nIua7Mui563MD1sC3AO6+fcAUR
+ap8lTwEpcOPlDOHqWnzcSbvBHiqB9RZLcpHIojG5qtr8nR/zXUACE/xOHAbKsxSQ
+VBcZEhrxH9cMaVr2cXj0lH2RC47skFSOvG+hTKv8dGT9cZr4QQehzZHkPJrgmzI5
+c6sq1WnIeJEmMX3ixzDx/BR4dxIOE/TdFpS/S2d7cFOFyrC78zhNLJA5wA3CXWvp
+4uXViI3WLL+rG761KIcSF3Ru/H38j9CHJrAb+7lsq+KePRXBOy5nAliRn+/4Qh8s
+t2j1da3Ptfb/EX3C8CSlrdP6oDyp+l3cpaDvRKS+1ujl5BOWF3sGPjLtx7dCvHaj
+2GU4Kzg1USEODm8uNBNA4StnDG1KQTAYI1oyVZnJF+A83vbsea0rWBmirSwiGpWO
+vpaQXUJXxPkUAzUrHC1RVwinOt4/5Mi0A3PCwSaAuwtCH60NryZy2sy+s6ODWA2C
+xR9GUeOcGMyNm43sSet1UNWMKFnKdDTajAshqx7qG+XH/RU+wBeq+yNuJkbL+vmx
+cmtpzyKEC2IPrNkZAJSidjzULZrtBJ4tBmIQN1IchXIbJ+XMxjHsN+xjWZsLHXbM
+fjKaiJUINlK73nZfdklJrX+9ZSCyycErdhh2n1ax
+-----END CERTIFICATE-----
+
+# Issuer: CN=Certigna Root CA O=Dhimyotis OU=0002 48146308100036
+# Subject: CN=Certigna Root CA O=Dhimyotis OU=0002 48146308100036
+# Label: "Certigna Root CA"
+# Serial: 269714418870597844693661054334862075617
+# MD5 Fingerprint: 0e:5c:30:62:27:eb:5b:bc:d7:ae:62:ba:e9:d5:df:77
+# SHA1 Fingerprint: 2d:0d:52:14:ff:9e:ad:99:24:01:74:20:47:6e:6c:85:27:27:f5:43
+# SHA256 Fingerprint: d4:8d:3d:23:ee:db:50:a4:59:e5:51:97:60:1c:27:77:4b:9d:7b:18:c9:4d:5a:05:95:11:a1:02:50:b9:31:68
+-----BEGIN CERTIFICATE-----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=
+-----END CERTIFICATE-----
+
+# Issuer: CN=emSign Root CA - G1 O=eMudhra Technologies Limited OU=emSign PKI
+# Subject: CN=emSign Root CA - G1 O=eMudhra Technologies Limited OU=emSign PKI
+# Label: "emSign Root CA - G1"
+# Serial: 235931866688319308814040
+# MD5 Fingerprint: 9c:42:84:57:dd:cb:0b:a7:2e:95:ad:b6:f3:da:bc:ac
+# SHA1 Fingerprint: 8a:c7:ad:8f:73:ac:4e:c1:b5:75:4d:a5:40:f4:fc:cf:7c:b5:8e:8c
+# SHA256 Fingerprint: 40:f6:af:03:46:a9:9a:a1:cd:1d:55:5a:4e:9c:ce:62:c7:f9:63:46:03:ee:40:66:15:83:3d:c8:c8:d0:03:67
+-----BEGIN CERTIFICATE-----
+MIIDlDCCAnygAwIBAgIKMfXkYgxsWO3W2DANBgkqhkiG9w0BAQsFADBnMQswCQYD
+VQQGEwJJTjETMBEGA1UECxMKZW1TaWduIFBLSTElMCMGA1UEChMcZU11ZGhyYSBU
+ZWNobm9sb2dpZXMgTGltaXRlZDEcMBoGA1UEAxMTZW1TaWduIFJvb3QgQ0EgLSBH
+MTAeFw0xODAyMTgxODMwMDBaFw00MzAyMTgxODMwMDBaMGcxCzAJBgNVBAYTAklO
+MRMwEQYDVQQLEwplbVNpZ24gUEtJMSUwIwYDVQQKExxlTXVkaHJhIFRlY2hub2xv
+Z2llcyBMaW1pdGVkMRwwGgYDVQQDExNlbVNpZ24gUm9vdCBDQSAtIEcxMIIBIjAN
+BgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAk0u76WaK7p1b1TST0Bsew+eeuGQz
+f2N4aLTNLnF115sgxk0pvLZoYIr3IZpWNVrzdr3YzZr/k1ZLpVkGoZM0Kd0WNHVO
+8oG0x5ZOrRkVUkr+PHB1cM2vK6sVmjM8qrOLqs1D/fXqcP/tzxE7lM5OMhbTI0Aq
+d7OvPAEsbO2ZLIvZTmmYsvePQbAyeGHWDV/D+qJAkh1cF+ZwPjXnorfCYuKrpDhM
+tTk1b+oDafo6VGiFbdbyL0NVHpENDtjVaqSW0RM8LHhQ6DqS0hdW5TUaQBw+jSzt
+Od9C4INBdN+jzcKGYEho42kLVACL5HZpIQ15TjQIXhTCzLG3rdd8cIrHhQIDAQAB
+o0IwQDAdBgNVHQ4EFgQU++8Nhp6w492pufEhF38+/PB3KxowDgYDVR0PAQH/BAQD
+AgEGMA8GA1UdEwEB/wQFMAMBAf8wDQYJKoZIhvcNAQELBQADggEBAFn/8oz1h31x
+PaOfG1vR2vjTnGs2vZupYeveFix0PZ7mddrXuqe8QhfnPZHr5X3dPpzxz5KsbEjM
+wiI/aTvFthUvozXGaCocV685743QNcMYDHsAVhzNixl03r4PEuDQqqE/AjSxcM6d
+GNYIAwlG7mDgfrbESQRRfXBgvKqy/3lyeqYdPV8q+Mri/Tm3R7nrft8EI6/6nAYH
+6ftjk4BAtcZsCjEozgyfz7MjNYBBjWzEN3uBL4ChQEKF6dk4jeihU80Bv2noWgby
+RQuQ+q7hv53yrlc8pa6yVvSLZUDp/TGBLPQ5Cdjua6e0ph0VpZj3AYHYhX3zUVxx
+iN66zB+Afko=
+-----END CERTIFICATE-----
+
+# Issuer: CN=emSign ECC Root CA - G3 O=eMudhra Technologies Limited OU=emSign PKI
+# Subject: CN=emSign ECC Root CA - G3 O=eMudhra Technologies Limited OU=emSign PKI
+# Label: "emSign ECC Root CA - G3"
+# Serial: 287880440101571086945156
+# MD5 Fingerprint: ce:0b:72:d1:9f:88:8e:d0:50:03:e8:e3:b8:8b:67:40
+# SHA1 Fingerprint: 30:43:fa:4f:f2:57:dc:a0:c3:80:ee:2e:58:ea:78:b2:3f:e6:bb:c1
+# SHA256 Fingerprint: 86:a1:ec:ba:08:9c:4a:8d:3b:be:27:34:c6:12:ba:34:1d:81:3e:04:3c:f9:e8:a8:62:cd:5c:57:a3:6b:be:6b
+-----BEGIN CERTIFICATE-----
+MIICTjCCAdOgAwIBAgIKPPYHqWhwDtqLhDAKBggqhkjOPQQDAzBrMQswCQYDVQQG
+EwJJTjETMBEGA1UECxMKZW1TaWduIFBLSTElMCMGA1UEChMcZU11ZGhyYSBUZWNo
+bm9sb2dpZXMgTGltaXRlZDEgMB4GA1UEAxMXZW1TaWduIEVDQyBSb290IENBIC0g
+RzMwHhcNMTgwMjE4MTgzMDAwWhcNNDMwMjE4MTgzMDAwWjBrMQswCQYDVQQGEwJJ
+TjETMBEGA1UECxMKZW1TaWduIFBLSTElMCMGA1UEChMcZU11ZGhyYSBUZWNobm9s
+b2dpZXMgTGltaXRlZDEgMB4GA1UEAxMXZW1TaWduIEVDQyBSb290IENBIC0gRzMw
+djAQBgcqhkjOPQIBBgUrgQQAIgNiAAQjpQy4LRL1KPOxst3iAhKAnjlfSU2fySU0
+WXTsuwYc58Byr+iuL+FBVIcUqEqy6HyC5ltqtdyzdc6LBtCGI79G1Y4PPwT01xyS
+fvalY8L1X44uT6EYGQIrMgqCZH0Wk9GjQjBAMB0GA1UdDgQWBBR8XQKEE9TMipuB
+zhccLikenEhjQjAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/BAUwAwEB/zAKBggq
+hkjOPQQDAwNpADBmAjEAvvNhzwIQHWSVB7gYboiFBS+DCBeQyh+KTOgNG3qxrdWB
+CUfvO6wIBHxcmbHtRwfSAjEAnbpV/KlK6O3t5nYBQnvI+GDZjVGLVTv7jHvrZQnD
++JbNR6iC8hZVdyR+EhCVBCyj
+-----END CERTIFICATE-----
+
+# Issuer: CN=emSign Root CA - C1 O=eMudhra Inc OU=emSign PKI
+# Subject: CN=emSign Root CA - C1 O=eMudhra Inc OU=emSign PKI
+# Label: "emSign Root CA - C1"
+# Serial: 825510296613316004955058
+# MD5 Fingerprint: d8:e3:5d:01:21:fa:78:5a:b0:df:ba:d2:ee:2a:5f:68
+# SHA1 Fingerprint: e7:2e:f1:df:fc:b2:09:28:cf:5d:d4:d5:67:37:b1:51:cb:86:4f:01
+# SHA256 Fingerprint: 12:56:09:aa:30:1d:a0:a2:49:b9:7a:82:39:cb:6a:34:21:6f:44:dc:ac:9f:39:54:b1:42:92:f2:e8:c8:60:8f
+-----BEGIN CERTIFICATE-----
+MIIDczCCAlugAwIBAgILAK7PALrEzzL4Q7IwDQYJKoZIhvcNAQELBQAwVjELMAkG
+A1UEBhMCVVMxEzARBgNVBAsTCmVtU2lnbiBQS0kxFDASBgNVBAoTC2VNdWRocmEg
+SW5jMRwwGgYDVQQDExNlbVNpZ24gUm9vdCBDQSAtIEMxMB4XDTE4MDIxODE4MzAw
+MFoXDTQzMDIxODE4MzAwMFowVjELMAkGA1UEBhMCVVMxEzARBgNVBAsTCmVtU2ln
+biBQS0kxFDASBgNVBAoTC2VNdWRocmEgSW5jMRwwGgYDVQQDExNlbVNpZ24gUm9v
+dCBDQSAtIEMxMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAz+upufGZ
+BczYKCFK83M0UYRWEPWgTywS4/oTmifQz/l5GnRfHXk5/Fv4cI7gklL35CX5VIPZ
+HdPIWoU/Xse2B+4+wM6ar6xWQio5JXDWv7V7Nq2s9nPczdcdioOl+yuQFTdrHCZH
+3DspVpNqs8FqOp099cGXOFgFixwR4+S0uF2FHYP+eF8LRWgYSKVGczQ7/g/IdrvH
+GPMF0Ybzhe3nudkyrVWIzqa2kbBPrH4VI5b2P/AgNBbeCsbEBEV5f6f9vtKppa+c
+xSMq9zwhbL2vj07FOrLzNBL834AaSaTUqZX3noleoomslMuoaJuvimUnzYnu3Yy1
+aylwQ6BpC+S5DwIDAQABo0IwQDAdBgNVHQ4EFgQU/qHgcB4qAzlSWkK+XJGFehiq
+TbUwDgYDVR0PAQH/BAQDAgEGMA8GA1UdEwEB/wQFMAMBAf8wDQYJKoZIhvcNAQEL
+BQADggEBAMJKVvoVIXsoounlHfv4LcQ5lkFMOycsxGwYFYDGrK9HWS8mC+M2sO87
+/kOXSTKZEhVb3xEp/6tT+LvBeA+snFOvV71ojD1pM/CjoCNjO2RnIkSt1XHLVip4
+kqNPEjE2NuLe/gDEo2APJ62gsIq1NnpSob0n9CAnYuhNlCQT5AoE6TyrLshDCUrG
+YQTlSTR+08TI9Q/Aqum6VF7zYytPT1DU/rl7mYw9wC68AivTxEDkigcxHpvOJpkT
++xHqmiIMERnHXhuBUDDIlhJu58tBf5E7oke3VIAb3ADMmpDqw8NQBmIMMMAVSKeo
+WXzhriKi4gp6D/piq1JM4fHfyr6DDUI=
+-----END CERTIFICATE-----
+
+# Issuer: CN=emSign ECC Root CA - C3 O=eMudhra Inc OU=emSign PKI
+# Subject: CN=emSign ECC Root CA - C3 O=eMudhra Inc OU=emSign PKI
+# Label: "emSign ECC Root CA - C3"
+# Serial: 582948710642506000014504
+# MD5 Fingerprint: 3e:53:b3:a3:81:ee:d7:10:f8:d3:b0:1d:17:92:f5:d5
+# SHA1 Fingerprint: b6:af:43:c2:9b:81:53:7d:f6:ef:6b:c3:1f:1f:60:15:0c:ee:48:66
+# SHA256 Fingerprint: bc:4d:80:9b:15:18:9d:78:db:3e:1d:8c:f4:f9:72:6a:79:5d:a1:64:3c:a5:f1:35:8e:1d:db:0e:dc:0d:7e:b3
+-----BEGIN CERTIFICATE-----
+MIICKzCCAbGgAwIBAgIKe3G2gla4EnycqDAKBggqhkjOPQQDAzBaMQswCQYDVQQG
+EwJVUzETMBEGA1UECxMKZW1TaWduIFBLSTEUMBIGA1UEChMLZU11ZGhyYSBJbmMx
+IDAeBgNVBAMTF2VtU2lnbiBFQ0MgUm9vdCBDQSAtIEMzMB4XDTE4MDIxODE4MzAw
+MFoXDTQzMDIxODE4MzAwMFowWjELMAkGA1UEBhMCVVMxEzARBgNVBAsTCmVtU2ln
+biBQS0kxFDASBgNVBAoTC2VNdWRocmEgSW5jMSAwHgYDVQQDExdlbVNpZ24gRUND
+IFJvb3QgQ0EgLSBDMzB2MBAGByqGSM49AgEGBSuBBAAiA2IABP2lYa57JhAd6bci
+MK4G9IGzsUJxlTm801Ljr6/58pc1kjZGDoeVjbk5Wum739D+yAdBPLtVb4Ojavti
+sIGJAnB9SMVK4+kiVCJNk7tCDK93nCOmfddhEc5lx/h//vXyqaNCMEAwHQYDVR0O
+BBYEFPtaSNCAIEDyqOkAB2kZd6fmw/TPMA4GA1UdDwEB/wQEAwIBBjAPBgNVHRMB
+Af8EBTADAQH/MAoGCCqGSM49BAMDA2gAMGUCMQC02C8Cif22TGK6Q04ThHK1rt0c
+3ta13FaPWEBaLd4gTCKDypOofu4SQMfWh0/434UCMBwUZOR8loMRnLDRWmFLpg9J
+0wD8ofzkpf9/rdcw0Md3f76BB1UwUCAU9Vc4CqgxUQ==
+-----END CERTIFICATE-----
+
+# Issuer: CN=Hongkong Post Root CA 3 O=Hongkong Post
+# Subject: CN=Hongkong Post Root CA 3 O=Hongkong Post
+# Label: "Hongkong Post Root CA 3"
+# Serial: 46170865288971385588281144162979347873371282084
+# MD5 Fingerprint: 11:fc:9f:bd:73:30:02:8a:fd:3f:f3:58:b9:cb:20:f0
+# SHA1 Fingerprint: 58:a2:d0:ec:20:52:81:5b:c1:f3:f8:64:02:24:4e:c2:8e:02:4b:02
+# SHA256 Fingerprint: 5a:2f:c0:3f:0c:83:b0:90:bb:fa:40:60:4b:09:88:44:6c:76:36:18:3d:f9:84:6e:17:10:1a:44:7f:b8:ef:d6
+-----BEGIN CERTIFICATE-----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+-----END CERTIFICATE-----
+
+# Issuer: CN=Entrust Root Certification Authority - G4 O=Entrust, Inc. OU=See www.entrust.net/legal-terms/(c) 2015 Entrust, Inc. - for authorized use only
+# Subject: CN=Entrust Root Certification Authority - G4 O=Entrust, Inc. OU=See www.entrust.net/legal-terms/(c) 2015 Entrust, Inc. - for authorized use only
+# Label: "Entrust Root Certification Authority - G4"
+# Serial: 289383649854506086828220374796556676440
+# MD5 Fingerprint: 89:53:f1:83:23:b7:7c:8e:05:f1:8c:71:38:4e:1f:88
+# SHA1 Fingerprint: 14:88:4e:86:26:37:b0:26:af:59:62:5c:40:77:ec:35:29:ba:96:01
+# SHA256 Fingerprint: db:35:17:d1:f6:73:2a:2d:5a:b9:7c:53:3e:c7:07:79:ee:32:70:a6:2f:b4:ac:42:38:37:24:60:e6:f0:1e:88
+-----BEGIN CERTIFICATE-----
+MIIGSzCCBDOgAwIBAgIRANm1Q3+vqTkPAAAAAFVlrVgwDQYJKoZIhvcNAQELBQAw
+gb4xCzAJBgNVBAYTAlVTMRYwFAYDVQQKEw1FbnRydXN0LCBJbmMuMSgwJgYDVQQL
+Ex9TZWUgd3d3LmVudHJ1c3QubmV0L2xlZ2FsLXRlcm1zMTkwNwYDVQQLEzAoYykg
+MjAxNSBFbnRydXN0LCBJbmMuIC0gZm9yIGF1dGhvcml6ZWQgdXNlIG9ubHkxMjAw
+BgNVBAMTKUVudHJ1c3QgUm9vdCBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eSAtIEc0
+MB4XDTE1MDUyNzExMTExNloXDTM3MTIyNzExNDExNlowgb4xCzAJBgNVBAYTAlVT
+MRYwFAYDVQQKEw1FbnRydXN0LCBJbmMuMSgwJgYDVQQLEx9TZWUgd3d3LmVudHJ1
+c3QubmV0L2xlZ2FsLXRlcm1zMTkwNwYDVQQLEzAoYykgMjAxNSBFbnRydXN0LCBJ
+bmMuIC0gZm9yIGF1dGhvcml6ZWQgdXNlIG9ubHkxMjAwBgNVBAMTKUVudHJ1c3Qg
+Um9vdCBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eSAtIEc0MIICIjANBgkqhkiG9w0B
+AQEFAAOCAg8AMIICCgKCAgEAsewsQu7i0TD/pZJH4i3DumSXbcr3DbVZwbPLqGgZ
+2K+EbTBwXX7zLtJTmeH+H17ZSK9dE43b/2MzTdMAArzE+NEGCJR5WIoV3imz/f3E
+T+iq4qA7ec2/a0My3dl0ELn39GjUu9CH1apLiipvKgS1sqbHoHrmSKvS0VnM1n4j
+5pds8ELl3FFLFUHtSUrJ3hCX1nbB76W1NhSXNdh4IjVS70O92yfbYVaCNNzLiGAM
+C1rlLAHGVK/XqsEQe9IFWrhAnoanw5CGAlZSCXqc0ieCU0plUmr1POeo8pyvi73T
+DtTUXm6Hnmo9RR3RXRv06QqsYJn7ibT/mCzPfB3pAqoEmh643IhuJbNsZvc8kPNX
+wbMv9W3y+8qh+CmdRouzavbmZwe+LGcKKh9asj5XxNMhIWNlUpEbsZmOeX7m640A
+2Vqq6nPopIICR5b+W45UYaPrL0swsIsjdXJ8ITzI9vF01Bx7owVV7rtNOzK+mndm
+nqxpkCIHH2E6lr7lmk/MBTwoWdPBDFSoWWG9yHJM6Nyfh3+9nEg2XpWjDrk4JFX8
+dWbrAuMINClKxuMrLzOg2qOGpRKX/YAr2hRC45K9PvJdXmd0LhyIRyk0X+IyqJwl
+N4y6mACXi0mWHv0liqzc2thddG5msP9E36EYxr5ILzeUePiVSj9/E15dWf10hkNj
+c0kCAwEAAaNCMEAwDwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMCAQYwHQYD
+VR0OBBYEFJ84xFYjwznooHFs6FRM5Og6sb9nMA0GCSqGSIb3DQEBCwUAA4ICAQAS
+5UKme4sPDORGpbZgQIeMJX6tuGguW8ZAdjwD+MlZ9POrYs4QjbRaZIxowLByQzTS
+Gwv2LFPSypBLhmb8qoMi9IsabyZIrHZ3CL/FmFz0Jomee8O5ZDIBf9PD3Vht7LGr
+hFV0d4QEJ1JrhkzO3bll/9bGXp+aEJlLdWr+aumXIOTkdnrG0CSqkM0gkLpHZPt/
+B7NTeLUKYvJzQ85BK4FqLoUWlFPUa19yIqtRLULVAJyZv967lDtX/Zr1hstWO1uI
+AeV8KEsD+UmDfLJ/fOPtjqF/YFOOVZ1QNBIPt5d7bIdKROf1beyAN/BYGW5KaHbw
+H5Lk6rWS02FREAutp9lfx1/cH6NcjKF+m7ee01ZvZl4HliDtC3T7Zk6LERXpgUl+
+b7DUUH8i119lAg2m9IUe2K4GS0qn0jFmwvjO5QimpAKWRGhXxNUzzxkvFMSUHHuk
+2fCfDrGA4tGeEWSpiBE6doLlYsKA2KSD7ZPvfC+QsDJMlhVoSFLUmQjAJOgc47Ol
+IQ6SwJAfzyBfyjs4x7dtOvPmRLgOMWuIjnDrnBdSqEGULoe256YSxXXfW8AKbnuk
+5F6G+TaU33fD6Q3AOfF5u0aOq0NZJ7cguyPpVkAh7DE9ZapD8j3fcEThuk0mEDuY
+n/PIjhs4ViFqUZPTkcpG2om3PVODLAgfi49T3f+sHw==
+-----END CERTIFICATE-----
+
+# Issuer: CN=Microsoft ECC Root Certificate Authority 2017 O=Microsoft Corporation
+# Subject: CN=Microsoft ECC Root Certificate Authority 2017 O=Microsoft Corporation
+# Label: "Microsoft ECC Root Certificate Authority 2017"
+# Serial: 136839042543790627607696632466672567020
+# MD5 Fingerprint: dd:a1:03:e6:4a:93:10:d1:bf:f0:19:42:cb:fe:ed:67
+# SHA1 Fingerprint: 99:9a:64:c3:7f:f4:7d:9f:ab:95:f1:47:69:89:14:60:ee:c4:c3:c5
+# SHA256 Fingerprint: 35:8d:f3:9d:76:4a:f9:e1:b7:66:e9:c9:72:df:35:2e:e1:5c:fa:c2:27:af:6a:d1:d7:0e:8e:4a:6e:dc:ba:02
+-----BEGIN CERTIFICATE-----
+MIICWTCCAd+gAwIBAgIQZvI9r4fei7FK6gxXMQHC7DAKBggqhkjOPQQDAzBlMQsw
+CQYDVQQGEwJVUzEeMBwGA1UEChMVTWljcm9zb2Z0IENvcnBvcmF0aW9uMTYwNAYD
+VQQDEy1NaWNyb3NvZnQgRUNDIFJvb3QgQ2VydGlmaWNhdGUgQXV0aG9yaXR5IDIw
+MTcwHhcNMTkxMjE4MjMwNjQ1WhcNNDIwNzE4MjMxNjA0WjBlMQswCQYDVQQGEwJV
+UzEeMBwGA1UEChMVTWljcm9zb2Z0IENvcnBvcmF0aW9uMTYwNAYDVQQDEy1NaWNy
+b3NvZnQgRUNDIFJvb3QgQ2VydGlmaWNhdGUgQXV0aG9yaXR5IDIwMTcwdjAQBgcq
+hkjOPQIBBgUrgQQAIgNiAATUvD0CQnVBEyPNgASGAlEvaqiBYgtlzPbKnR5vSmZR
+ogPZnZH6thaxjG7efM3beaYvzrvOcS/lpaso7GMEZpn4+vKTEAXhgShC48Zo9OYb
+hGBKia/teQ87zvH2RPUBeMCjVDBSMA4GA1UdDwEB/wQEAwIBhjAPBgNVHRMBAf8E
+BTADAQH/MB0GA1UdDgQWBBTIy5lycFIM+Oa+sgRXKSrPQhDtNTAQBgkrBgEEAYI3
+FQEEAwIBADAKBggqhkjOPQQDAwNoADBlAjBY8k3qDPlfXu5gKcs68tvWMoQZP3zV
+L8KxzJOuULsJMsbG7X7JNpQS5GiFBqIb0C8CMQCZ6Ra0DvpWSNSkMBaReNtUjGUB
+iudQZsIxtzm6uBoiB078a1QWIP8rtedMDE2mT3M=
+-----END CERTIFICATE-----
+
+# Issuer: CN=Microsoft RSA Root Certificate Authority 2017 O=Microsoft Corporation
+# Subject: CN=Microsoft RSA Root Certificate Authority 2017 O=Microsoft Corporation
+# Label: "Microsoft RSA Root Certificate Authority 2017"
+# Serial: 40975477897264996090493496164228220339
+# MD5 Fingerprint: 10:ff:00:ff:cf:c9:f8:c7:7a:c0:ee:35:8e:c9:0f:47
+# SHA1 Fingerprint: 73:a5:e6:4a:3b:ff:83:16:ff:0e:dc:cc:61:8a:90:6e:4e:ae:4d:74
+# SHA256 Fingerprint: c7:41:f7:0f:4b:2a:8d:88:bf:2e:71:c1:41:22:ef:53:ef:10:eb:a0:cf:a5:e6:4c:fa:20:f4:18:85:30:73:e0
+-----BEGIN CERTIFICATE-----
+MIIFqDCCA5CgAwIBAgIQHtOXCV/YtLNHcB6qvn9FszANBgkqhkiG9w0BAQwFADBl
+MQswCQYDVQQGEwJVUzEeMBwGA1UEChMVTWljcm9zb2Z0IENvcnBvcmF0aW9uMTYw
+NAYDVQQDEy1NaWNyb3NvZnQgUlNBIFJvb3QgQ2VydGlmaWNhdGUgQXV0aG9yaXR5
+IDIwMTcwHhcNMTkxMjE4MjI1MTIyWhcNNDIwNzE4MjMwMDIzWjBlMQswCQYDVQQG
+EwJVUzEeMBwGA1UEChMVTWljcm9zb2Z0IENvcnBvcmF0aW9uMTYwNAYDVQQDEy1N
+aWNyb3NvZnQgUlNBIFJvb3QgQ2VydGlmaWNhdGUgQXV0aG9yaXR5IDIwMTcwggIi
+MA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQDKW76UM4wplZEWCpW9R2LBifOZ
+Nt9GkMml7Xhqb0eRaPgnZ1AzHaGm++DlQ6OEAlcBXZxIQIJTELy/xztokLaCLeX0
+ZdDMbRnMlfl7rEqUrQ7eS0MdhweSE5CAg2Q1OQT85elss7YfUJQ4ZVBcF0a5toW1
+HLUX6NZFndiyJrDKxHBKrmCk3bPZ7Pw71VdyvD/IybLeS2v4I2wDwAW9lcfNcztm
+gGTjGqwu+UcF8ga2m3P1eDNbx6H7JyqhtJqRjJHTOoI+dkC0zVJhUXAoP8XFWvLJ
+jEm7FFtNyP9nTUwSlq31/niol4fX/V4ggNyhSyL71Imtus5Hl0dVe49FyGcohJUc
+aDDv70ngNXtk55iwlNpNhTs+VcQor1fznhPbRiefHqJeRIOkpcrVE7NLP8TjwuaG
+YaRSMLl6IE9vDzhTyzMMEyuP1pq9KsgtsRx9S1HKR9FIJ3Jdh+vVReZIZZ2vUpC6
+W6IYZVcSn2i51BVrlMRpIpj0M+Dt+VGOQVDJNE92kKz8OMHY4Xu54+OU4UZpyw4K
+UGsTuqwPN1q3ErWQgR5WrlcihtnJ0tHXUeOrO8ZV/R4O03QK0dqq6mm4lyiPSMQH
++FJDOvTKVTUssKZqwJz58oHhEmrARdlns87/I6KJClTUFLkqqNfs+avNJVgyeY+Q
+W5g5xAgGwax/Dj0ApQIDAQABo1QwUjAOBgNVHQ8BAf8EBAMCAYYwDwYDVR0TAQH/
+BAUwAwEB/zAdBgNVHQ4EFgQUCctZf4aycI8awznjwNnpv7tNsiMwEAYJKwYBBAGC
+NxUBBAMCAQAwDQYJKoZIhvcNAQEMBQADggIBAKyvPl3CEZaJjqPnktaXFbgToqZC
+LgLNFgVZJ8og6Lq46BrsTaiXVq5lQ7GPAJtSzVXNUzltYkyLDVt8LkS/gxCP81OC
+gMNPOsduET/m4xaRhPtthH80dK2Jp86519efhGSSvpWhrQlTM93uCupKUY5vVau6
+tZRGrox/2KJQJWVggEbbMwSubLWYdFQl3JPk+ONVFT24bcMKpBLBaYVu32TxU5nh
+SnUgnZUP5NbcA/FZGOhHibJXWpS2qdgXKxdJ5XbLwVaZOjex/2kskZGT4d9Mozd2
+TaGf+G0eHdP67Pv0RR0Tbc/3WeUiJ3IrhvNXuzDtJE3cfVa7o7P4NHmJweDyAmH3
+pvwPuxwXC65B2Xy9J6P9LjrRk5Sxcx0ki69bIImtt2dmefU6xqaWM/5TkshGsRGR
+xpl/j8nWZjEgQRCHLQzWwa80mMpkg/sTV9HB8Dx6jKXB/ZUhoHHBk2dxEuqPiApp
+GWSZI1b7rCoucL5mxAyE7+WL85MB+GqQk2dLsmijtWKP6T+MejteD+eMuMZ87zf9
+dOLITzNy4ZQ5bb0Sr74MTnB8G2+NszKTc0QWbej09+CVgI+WXTik9KveCjCHk9hN
+AHFiRSdLOkKEW39lt2c0Ui2cFmuqqNh7o0JMcccMyj6D5KbvtwEwXlGjefVwaaZB
+RA+GsCyRxj3qrg+E
+-----END CERTIFICATE-----
+
+# Issuer: CN=e-Szigno Root CA 2017 O=Microsec Ltd.
+# Subject: CN=e-Szigno Root CA 2017 O=Microsec Ltd.
+# Label: "e-Szigno Root CA 2017"
+# Serial: 411379200276854331539784714
+# MD5 Fingerprint: de:1f:f6:9e:84:ae:a7:b4:21:ce:1e:58:7d:d1:84:98
+# SHA1 Fingerprint: 89:d4:83:03:4f:9e:9a:48:80:5f:72:37:d4:a9:a6:ef:cb:7c:1f:d1
+# SHA256 Fingerprint: be:b0:0b:30:83:9b:9b:c3:2c:32:e4:44:79:05:95:06:41:f2:64:21:b1:5e:d0:89:19:8b:51:8a:e2:ea:1b:99
+-----BEGIN CERTIFICATE-----
+MIICQDCCAeWgAwIBAgIMAVRI7yH9l1kN9QQKMAoGCCqGSM49BAMCMHExCzAJBgNV
+BAYTAkhVMREwDwYDVQQHDAhCdWRhcGVzdDEWMBQGA1UECgwNTWljcm9zZWMgTHRk
+LjEXMBUGA1UEYQwOVkFUSFUtMjM1ODQ0OTcxHjAcBgNVBAMMFWUtU3ppZ25vIFJv
+b3QgQ0EgMjAxNzAeFw0xNzA4MjIxMjA3MDZaFw00MjA4MjIxMjA3MDZaMHExCzAJ
+BgNVBAYTAkhVMREwDwYDVQQHDAhCdWRhcGVzdDEWMBQGA1UECgwNTWljcm9zZWMg
+THRkLjEXMBUGA1UEYQwOVkFUSFUtMjM1ODQ0OTcxHjAcBgNVBAMMFWUtU3ppZ25v
+IFJvb3QgQ0EgMjAxNzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABJbcPYrYsHtv
+xie+RJCxs1YVe45DJH0ahFnuY2iyxl6H0BVIHqiQrb1TotreOpCmYF9oMrWGQd+H
+Wyx7xf58etqjYzBhMA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgEGMB0G
+A1UdDgQWBBSHERUI0arBeAyxr87GyZDvvzAEwDAfBgNVHSMEGDAWgBSHERUI0arB
+eAyxr87GyZDvvzAEwDAKBggqhkjOPQQDAgNJADBGAiEAtVfd14pVCzbhhkT61Nlo
+jbjcI4qKDdQvfepz7L9NbKgCIQDLpbQS+ue16M9+k/zzNY9vTlp8tLxOsvxyqltZ
++efcMQ==
+-----END CERTIFICATE-----
+
+# Issuer: O=CERTSIGN SA OU=certSIGN ROOT CA G2
+# Subject: O=CERTSIGN SA OU=certSIGN ROOT CA G2
+# Label: "certSIGN Root CA G2"
+# Serial: 313609486401300475190
+# MD5 Fingerprint: 8c:f1:75:8a:c6:19:cf:94:b7:f7:65:20:87:c3:97:c7
+# SHA1 Fingerprint: 26:f9:93:b4:ed:3d:28:27:b0:b9:4b:a7:e9:15:1d:a3:8d:92:e5:32
+# SHA256 Fingerprint: 65:7c:fe:2f:a7:3f:aa:38:46:25:71:f3:32:a2:36:3a:46:fc:e7:02:09:51:71:07:02:cd:fb:b6:ee:da:33:05
+-----BEGIN CERTIFICATE-----
+MIIFRzCCAy+gAwIBAgIJEQA0tk7GNi02MA0GCSqGSIb3DQEBCwUAMEExCzAJBgNV
+BAYTAlJPMRQwEgYDVQQKEwtDRVJUU0lHTiBTQTEcMBoGA1UECxMTY2VydFNJR04g
+Uk9PVCBDQSBHMjAeFw0xNzAyMDYwOTI3MzVaFw00MjAyMDYwOTI3MzVaMEExCzAJ
+BgNVBAYTAlJPMRQwEgYDVQQKEwtDRVJUU0lHTiBTQTEcMBoGA1UECxMTY2VydFNJ
+R04gUk9PVCBDQSBHMjCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAMDF
+dRmRfUR0dIf+DjuW3NgBFszuY5HnC2/OOwppGnzC46+CjobXXo9X69MhWf05N0Iw
+vlDqtg+piNguLWkh59E3GE59kdUWX2tbAMI5Qw02hVK5U2UPHULlj88F0+7cDBrZ
+uIt4ImfkabBoxTzkbFpG583H+u/E7Eu9aqSs/cwoUe+StCmrqzWaTOTECMYmzPhp
+n+Sc8CnTXPnGFiWeI8MgwT0PPzhAsP6CRDiqWhqKa2NYOLQV07YRaXseVO6MGiKs
+cpc/I1mbySKEwQdPzH/iV8oScLumZfNpdWO9lfsbl83kqK/20U6o2YpxJM02PbyW
+xPFsqa7lzw1uKA2wDrXKUXt4FMMgL3/7FFXhEZn91QqhngLjYl/rNUssuHLoPj1P
+rCy7Lobio3aP5ZMqz6WryFyNSwb/EkaseMsUBzXgqd+L6a8VTxaJW732jcZZroiF
+DsGJ6x9nxUWO/203Nit4ZoORUSs9/1F3dmKh7Gc+PoGD4FapUB8fepmrY7+EF3fx
+DTvf95xhszWYijqy7DwaNz9+j5LP2RIUZNoQAhVB/0/E6xyjyfqZ90bp4RjZsbgy
+LcsUDFDYg2WD7rlcz8sFWkz6GZdr1l0T08JcVLwyc6B49fFtHsufpaafItzRUZ6C
+eWRgKRM+o/1Pcmqr4tTluCRVLERLiohEnMqE0yo7AgMBAAGjQjBAMA8GA1UdEwEB
+/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgEGMB0GA1UdDgQWBBSCIS1mxteg4BXrzkwJ
+d8RgnlRuAzANBgkqhkiG9w0BAQsFAAOCAgEAYN4auOfyYILVAzOBywaK8SJJ6ejq
+kX/GM15oGQOGO0MBzwdw5AgeZYWR5hEit/UCI46uuR59H35s5r0l1ZUa8gWmr4UC
+b6741jH/JclKyMeKqdmfS0mbEVeZkkMR3rYzpMzXjWR91M08KCy0mpbqTfXERMQl
+qiCA2ClV9+BB/AYm/7k29UMUA2Z44RGx2iBfRgB4ACGlHgAoYXhvqAEBj500mv/0
+OJD7uNGzcgbJceaBxXntC6Z58hMLnPddDnskk7RI24Zf3lCGeOdA5jGokHZwYa+c
+NywRtYK3qq4kNFtyDGkNzVmf9nGvnAvRCjj5BiKDUyUM/FHE5r7iOZULJK2v0ZXk
+ltd0ZGtxTgI8qoXzIKNDOXZbbFD+mpwUHmUUihW9o4JFWklWatKcsWMy5WHgUyIO
+pwpJ6st+H6jiYoD2EEVSmAYY3qXNL3+q1Ok+CHLsIwMCPKaq2LxndD0UF/tUSxfj
+03k9bWtJySgOLnRQvwzZRjoQhsmnP+mg7H/rpXdYaXHmgwo38oZJar55CJD2AhZk
+PuXaTH4MNMn5X7azKFGnpyuqSfqNZSlO42sTp5SjLVFteAxEy9/eCG/Oo2Sr05WE
+1LlSVHJ7liXMvGnjSG4N0MedJ5qq+BOS3R7fY581qRY27Iy4g/Q9iY/NtBde17MX
+QRBdJ3NghVdJIgc=
+-----END CERTIFICATE-----
+
+# Issuer: CN=Trustwave Global Certification Authority O=Trustwave Holdings, Inc.
+# Subject: CN=Trustwave Global Certification Authority O=Trustwave Holdings, Inc.
+# Label: "Trustwave Global Certification Authority"
+# Serial: 1846098327275375458322922162
+# MD5 Fingerprint: f8:1c:18:2d:2f:ba:5f:6d:a1:6c:bc:c7:ab:91:c7:0e
+# SHA1 Fingerprint: 2f:8f:36:4f:e1:58:97:44:21:59:87:a5:2a:9a:d0:69:95:26:7f:b5
+# SHA256 Fingerprint: 97:55:20:15:f5:dd:fc:3c:87:88:c0:06:94:45:55:40:88:94:45:00:84:f1:00:86:70:86:bc:1a:2b:b5:8d:c8
+-----BEGIN CERTIFICATE-----
+MIIF2jCCA8KgAwIBAgIMBfcOhtpJ80Y1LrqyMA0GCSqGSIb3DQEBCwUAMIGIMQsw
+CQYDVQQGEwJVUzERMA8GA1UECAwISWxsaW5vaXMxEDAOBgNVBAcMB0NoaWNhZ28x
+ITAfBgNVBAoMGFRydXN0d2F2ZSBIb2xkaW5ncywgSW5jLjExMC8GA1UEAwwoVHJ1
+c3R3YXZlIEdsb2JhbCBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eTAeFw0xNzA4MjMx
+OTM0MTJaFw00MjA4MjMxOTM0MTJaMIGIMQswCQYDVQQGEwJVUzERMA8GA1UECAwI
+SWxsaW5vaXMxEDAOBgNVBAcMB0NoaWNhZ28xITAfBgNVBAoMGFRydXN0d2F2ZSBI
+b2xkaW5ncywgSW5jLjExMC8GA1UEAwwoVHJ1c3R3YXZlIEdsb2JhbCBDZXJ0aWZp
+Y2F0aW9uIEF1dGhvcml0eTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIB
+ALldUShLPDeS0YLOvR29zd24q88KPuFd5dyqCblXAj7mY2Hf8g+CY66j96xz0Xzn
+swuvCAAJWX/NKSqIk4cXGIDtiLK0thAfLdZfVaITXdHG6wZWiYj+rDKd/VzDBcdu
+7oaJuogDnXIhhpCujwOl3J+IKMujkkkP7NAP4m1ET4BqstTnoApTAbqOl5F2brz8
+1Ws25kCI1nsvXwXoLG0R8+eyvpJETNKXpP7ScoFDB5zpET71ixpZfR9oWN0EACyW
+80OzfpgZdNmcc9kYvkHHNHnZ9GLCQ7mzJ7Aiy/k9UscwR7PJPrhq4ufogXBeQotP
+JqX+OsIgbrv4Fo7NDKm0G2x2EOFYeUY+VM6AqFcJNykbmROPDMjWLBz7BegIlT1l
+RtzuzWniTY+HKE40Cz7PFNm73bZQmq131BnW2hqIyE4bJ3XYsgjxroMwuREOzYfw
+hI0Vcnyh78zyiGG69Gm7DIwLdVcEuE4qFC49DxweMqZiNu5m4iK4BUBjECLzMx10
+coos9TkpoNPnG4CELcU9402x/RpvumUHO1jsQkUm+9jaJXLE9gCxInm943xZYkqc
+BW89zubWR2OZxiRvchLIrH+QtAuRcOi35hYQcRfO3gZPSEF9NUqjifLJS3tBEW1n
+twiYTOURGa5CgNz7kAXU+FDKvuStx8KU1xad5hePrzb7AgMBAAGjQjBAMA8GA1Ud
+EwEB/wQFMAMBAf8wHQYDVR0OBBYEFJngGWcNYtt2s9o9uFvo/ULSMQ6HMA4GA1Ud
+DwEB/wQEAwIBBjANBgkqhkiG9w0BAQsFAAOCAgEAmHNw4rDT7TnsTGDZqRKGFx6W
+0OhUKDtkLSGm+J1WE2pIPU/HPinbbViDVD2HfSMF1OQc3Og4ZYbFdada2zUFvXfe
+uyk3QAUHw5RSn8pk3fEbK9xGChACMf1KaA0HZJDmHvUqoai7PF35owgLEQzxPy0Q
+lG/+4jSHg9bP5Rs1bdID4bANqKCqRieCNqcVtgimQlRXtpla4gt5kNdXElE1GYhB
+aCXUNxeEFfsBctyV3lImIJgm4nb1J2/6ADtKYdkNy1GTKv0WBpanI5ojSP5RvbbE
+sLFUzt5sQa0WZ37b/TjNuThOssFgy50X31ieemKyJo90lZvkWx3SD92YHJtZuSPT
+MaCm/zjdzyBP6VhWOmfD0faZmZ26NraAL4hHT4a/RDqA5Dccprrql5gR0IRiR2Qe
+qu5AvzSxnI9O4fKSTx+O856X3vOmeWqJcU9LJxdI/uz0UA9PSX3MReO9ekDFQdxh
+VicGaeVyQYHTtgGJoC86cnn+OjC/QezHYj6RS8fZMXZC+fc8Y+wmjHMMfRod6qh8
+h6jCJ3zhM0EPz8/8AKAigJ5Kp28AsEFFtyLKaEjFQqKu3R3y4G5OBVixwJAWKqQ9
+EEC+j2Jjg6mcgn0tAumDMHzLJ8n9HmYAsC7TIS+OMxZsmO0QqAfWzJPP29FpHOTK
+yeC2nOnOcXHebD8WpHk=
+-----END CERTIFICATE-----
+
+# Issuer: CN=Trustwave Global ECC P256 Certification Authority O=Trustwave Holdings, Inc.
+# Subject: CN=Trustwave Global ECC P256 Certification Authority O=Trustwave Holdings, Inc.
+# Label: "Trustwave Global ECC P256 Certification Authority"
+# Serial: 4151900041497450638097112925
+# MD5 Fingerprint: 5b:44:e3:8d:5d:36:86:26:e8:0d:05:d2:59:a7:83:54
+# SHA1 Fingerprint: b4:90:82:dd:45:0c:be:8b:5b:b1:66:d3:e2:a4:08:26:cd:ed:42:cf
+# SHA256 Fingerprint: 94:5b:bc:82:5e:a5:54:f4:89:d1:fd:51:a7:3d:df:2e:a6:24:ac:70:19:a0:52:05:22:5c:22:a7:8c:cf:a8:b4
+-----BEGIN CERTIFICATE-----
+MIICYDCCAgegAwIBAgIMDWpfCD8oXD5Rld9dMAoGCCqGSM49BAMCMIGRMQswCQYD
+VQQGEwJVUzERMA8GA1UECBMISWxsaW5vaXMxEDAOBgNVBAcTB0NoaWNhZ28xITAf
+BgNVBAoTGFRydXN0d2F2ZSBIb2xkaW5ncywgSW5jLjE6MDgGA1UEAxMxVHJ1c3R3
+YXZlIEdsb2JhbCBFQ0MgUDI1NiBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eTAeFw0x
+NzA4MjMxOTM1MTBaFw00MjA4MjMxOTM1MTBaMIGRMQswCQYDVQQGEwJVUzERMA8G
+A1UECBMISWxsaW5vaXMxEDAOBgNVBAcTB0NoaWNhZ28xITAfBgNVBAoTGFRydXN0
+d2F2ZSBIb2xkaW5ncywgSW5jLjE6MDgGA1UEAxMxVHJ1c3R3YXZlIEdsb2JhbCBF
+Q0MgUDI1NiBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eTBZMBMGByqGSM49AgEGCCqG
+SM49AwEHA0IABH77bOYj43MyCMpg5lOcunSNGLB4kFKA3TjASh3RqMyTpJcGOMoN
+FWLGjgEqZZ2q3zSRLoHB5DOSMcT9CTqmP62jQzBBMA8GA1UdEwEB/wQFMAMBAf8w
+DwYDVR0PAQH/BAUDAwcGADAdBgNVHQ4EFgQUo0EGrJBt0UrrdaVKEJmzsaGLSvcw
+CgYIKoZIzj0EAwIDRwAwRAIgB+ZU2g6gWrKuEZ+Hxbb/ad4lvvigtwjzRM4q3wgh
+DDcCIC0mA6AFvWvR9lz4ZcyGbbOcNEhjhAnFjXca4syc4XR7
+-----END CERTIFICATE-----
+
+# Issuer: CN=Trustwave Global ECC P384 Certification Authority O=Trustwave Holdings, Inc.
+# Subject: CN=Trustwave Global ECC P384 Certification Authority O=Trustwave Holdings, Inc.
+# Label: "Trustwave Global ECC P384 Certification Authority"
+# Serial: 2704997926503831671788816187
+# MD5 Fingerprint: ea:cf:60:c4:3b:b9:15:29:40:a1:97:ed:78:27:93:d6
+# SHA1 Fingerprint: e7:f3:a3:c8:cf:6f:c3:04:2e:6d:0e:67:32:c5:9e:68:95:0d:5e:d2
+# SHA256 Fingerprint: 55:90:38:59:c8:c0:c3:eb:b8:75:9e:ce:4e:25:57:22:5f:f5:75:8b:bd:38:eb:d4:82:76:60:1e:1b:d5:80:97
+-----BEGIN CERTIFICATE-----
+MIICnTCCAiSgAwIBAgIMCL2Fl2yZJ6SAaEc7MAoGCCqGSM49BAMDMIGRMQswCQYD
+VQQGEwJVUzERMA8GA1UECBMISWxsaW5vaXMxEDAOBgNVBAcTB0NoaWNhZ28xITAf
+BgNVBAoTGFRydXN0d2F2ZSBIb2xkaW5ncywgSW5jLjE6MDgGA1UEAxMxVHJ1c3R3
+YXZlIEdsb2JhbCBFQ0MgUDM4NCBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eTAeFw0x
+NzA4MjMxOTM2NDNaFw00MjA4MjMxOTM2NDNaMIGRMQswCQYDVQQGEwJVUzERMA8G
+A1UECBMISWxsaW5vaXMxEDAOBgNVBAcTB0NoaWNhZ28xITAfBgNVBAoTGFRydXN0
+d2F2ZSBIb2xkaW5ncywgSW5jLjE6MDgGA1UEAxMxVHJ1c3R3YXZlIEdsb2JhbCBF
+Q0MgUDM4NCBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eTB2MBAGByqGSM49AgEGBSuB
+BAAiA2IABGvaDXU1CDFHBa5FmVXxERMuSvgQMSOjfoPTfygIOiYaOs+Xgh+AtycJ
+j9GOMMQKmw6sWASr9zZ9lCOkmwqKi6vr/TklZvFe/oyujUF5nQlgziip04pt89ZF
+1PKYhDhloKNDMEEwDwYDVR0TAQH/BAUwAwEB/zAPBgNVHQ8BAf8EBQMDBwYAMB0G
+A1UdDgQWBBRVqYSJ0sEyvRjLbKYHTsjnnb6CkDAKBggqhkjOPQQDAwNnADBkAjA3
+AZKXRRJ+oPM+rRk6ct30UJMDEr5E0k9BpIycnR+j9sKS50gU/k6bpZFXrsY3crsC
+MGclCrEMXu6pY5Jv5ZAL/mYiykf9ijH3g/56vxC+GCsej/YpHpRZ744hN8tRmKVu
+Sw==
+-----END CERTIFICATE-----
+
+# Issuer: CN=NAVER Global Root Certification Authority O=NAVER BUSINESS PLATFORM Corp.
+# Subject: CN=NAVER Global Root Certification Authority O=NAVER BUSINESS PLATFORM Corp.
+# Label: "NAVER Global Root Certification Authority"
+# Serial: 9013692873798656336226253319739695165984492813
+# MD5 Fingerprint: c8:7e:41:f6:25:3b:f5:09:b3:17:e8:46:3d:bf:d0:9b
+# SHA1 Fingerprint: 8f:6b:f2:a9:27:4a:da:14:a0:c4:f4:8e:61:27:f9:c0:1e:78:5d:d1
+# SHA256 Fingerprint: 88:f4:38:dc:f8:ff:d1:fa:8f:42:91:15:ff:e5:f8:2a:e1:e0:6e:0c:70:c3:75:fa:ad:71:7b:34:a4:9e:72:65
+-----BEGIN CERTIFICATE-----
+MIIFojCCA4qgAwIBAgIUAZQwHqIL3fXFMyqxQ0Rx+NZQTQ0wDQYJKoZIhvcNAQEM
+BQAwaTELMAkGA1UEBhMCS1IxJjAkBgNVBAoMHU5BVkVSIEJVU0lORVNTIFBMQVRG
+T1JNIENvcnAuMTIwMAYDVQQDDClOQVZFUiBHbG9iYWwgUm9vdCBDZXJ0aWZpY2F0
+aW9uIEF1dGhvcml0eTAeFw0xNzA4MTgwODU4NDJaFw0zNzA4MTgyMzU5NTlaMGkx
+CzAJBgNVBAYTAktSMSYwJAYDVQQKDB1OQVZFUiBCVVNJTkVTUyBQTEFURk9STSBD
+b3JwLjEyMDAGA1UEAwwpTkFWRVIgR2xvYmFsIFJvb3QgQ2VydGlmaWNhdGlvbiBB
+dXRob3JpdHkwggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQC21PGTXLVA
+iQqrDZBbUGOukJR0F0Vy1ntlWilLp1agS7gvQnXp2XskWjFlqxcX0TM62RHcQDaH
+38dq6SZeWYp34+hInDEW+j6RscrJo+KfziFTowI2MMtSAuXaMl3Dxeb57hHHi8lE
+HoSTGEq0n+USZGnQJoViAbbJAh2+g1G7XNr4rRVqmfeSVPc0W+m/6imBEtRTkZaz
+kVrd/pBzKPswRrXKCAfHcXLJZtM0l/aM9BhK4dA9WkW2aacp+yPOiNgSnABIqKYP
+szuSjXEOdMWLyEz59JuOuDxp7W87UC9Y7cSw0BwbagzivESq2M0UXZR4Yb8Obtoq
+vC8MC3GmsxY/nOb5zJ9TNeIDoKAYv7vxvvTWjIcNQvcGufFt7QSUqP620wbGQGHf
+nZ3zVHbOUzoBppJB7ASjjw2i1QnK1sua8e9DXcCrpUHPXFNwcMmIpi3Ua2FzUCaG
+YQ5fG8Ir4ozVu53BA0K6lNpfqbDKzE0K70dpAy8i+/Eozr9dUGWokG2zdLAIx6yo
+0es+nPxdGoMuK8u180SdOqcXYZaicdNwlhVNt0xz7hlcxVs+Qf6sdWA7G2POAN3a
+CJBitOUt7kinaxeZVL6HSuOpXgRM6xBtVNbv8ejyYhbLgGvtPe31HzClrkvJE+2K
+AQHJuFFYwGY6sWZLxNUxAmLpdIQM201GLQIDAQABo0IwQDAdBgNVHQ4EFgQU0p+I
+36HNLL3s9TsBAZMzJ7LrYEswDgYDVR0PAQH/BAQDAgEGMA8GA1UdEwEB/wQFMAMB
+Af8wDQYJKoZIhvcNAQEMBQADggIBADLKgLOdPVQG3dLSLvCkASELZ0jKbY7gyKoN
+qo0hV4/GPnrK21HUUrPUloSlWGB/5QuOH/XcChWB5Tu2tyIvCZwTFrFsDDUIbatj
+cu3cvuzHV+YwIHHW1xDBE1UBjCpD5EHxzzp6U5LOogMFDTjfArsQLtk70pt6wKGm
++LUx5vR1yblTmXVHIloUFcd4G7ad6Qz4G3bxhYTeodoS76TiEJd6eN4MUZeoIUCL
+hr0N8F5OSza7OyAfikJW4Qsav3vQIkMsRIz75Sq0bBwcupTgE34h5prCy8VCZLQe
+lHsIJchxzIdFV4XTnyliIoNRlwAYl3dqmJLJfGBs32x9SuRwTMKeuB330DTHD8z7
+p/8Dvq1wkNoL3chtl1+afwkyQf3NosxabUzyqkn+Zvjp2DXrDige7kgvOtB5CTh8
+piKCk5XQA76+AqAF3SAi428diDRgxuYKuQl1C/AH6GmWNcf7I4GOODm4RStDeKLR
+LBT/DShycpWbXgnbiUSYqqFJu3FS8r/2/yehNq+4tneI3TqkbZs0kNwUXTC/t+sX
+5Ie3cdCh13cV1ELX8vMxmV2b3RZtP+oGI/hGoiLtk/bdmuYqh7GYVPEi92tF4+KO
+dh2ajcQGjTa3FPOdVGm3jjzVpG2Tgbet9r1ke8LJaDmgkpzNNIaRkPpkUZ3+/uul
+9XXeifdy
+-----END CERTIFICATE-----
+
+# Issuer: CN=AC RAIZ FNMT-RCM SERVIDORES SEGUROS O=FNMT-RCM OU=Ceres
+# Subject: CN=AC RAIZ FNMT-RCM SERVIDORES SEGUROS O=FNMT-RCM OU=Ceres
+# Label: "AC RAIZ FNMT-RCM SERVIDORES SEGUROS"
+# Serial: 131542671362353147877283741781055151509
+# MD5 Fingerprint: 19:36:9c:52:03:2f:d2:d1:bb:23:cc:dd:1e:12:55:bb
+# SHA1 Fingerprint: 62:ff:d9:9e:c0:65:0d:03:ce:75:93:d2:ed:3f:2d:32:c9:e3:e5:4a
+# SHA256 Fingerprint: 55:41:53:b1:3d:2c:f9:dd:b7:53:bf:be:1a:4e:0a:e0:8d:0a:a4:18:70:58:fe:60:a2:b8:62:b2:e4:b8:7b:cb
+-----BEGIN CERTIFICATE-----
+MIICbjCCAfOgAwIBAgIQYvYybOXE42hcG2LdnC6dlTAKBggqhkjOPQQDAzB4MQsw
+CQYDVQQGEwJFUzERMA8GA1UECgwIRk5NVC1SQ00xDjAMBgNVBAsMBUNlcmVzMRgw
+FgYDVQRhDA9WQVRFUy1RMjgyNjAwNEoxLDAqBgNVBAMMI0FDIFJBSVogRk5NVC1S
+Q00gU0VSVklET1JFUyBTRUdVUk9TMB4XDTE4MTIyMDA5MzczM1oXDTQzMTIyMDA5
+MzczM1oweDELMAkGA1UEBhMCRVMxETAPBgNVBAoMCEZOTVQtUkNNMQ4wDAYDVQQL
+DAVDZXJlczEYMBYGA1UEYQwPVkFURVMtUTI4MjYwMDRKMSwwKgYDVQQDDCNBQyBS
+QUlaIEZOTVQtUkNNIFNFUlZJRE9SRVMgU0VHVVJPUzB2MBAGByqGSM49AgEGBSuB
+BAAiA2IABPa6V1PIyqvfNkpSIeSX0oNnnvBlUdBeh8dHsVnyV0ebAAKTRBdp20LH
+sbI6GA60XYyzZl2hNPk2LEnb80b8s0RpRBNm/dfF/a82Tc4DTQdxz69qBdKiQ1oK
+Um8BA06Oi6NCMEAwDwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMCAQYwHQYD
+VR0OBBYEFAG5L++/EYZg8k/QQW6rcx/n0m5JMAoGCCqGSM49BAMDA2kAMGYCMQCu
+SuMrQMN0EfKVrRYj3k4MGuZdpSRea0R7/DjiT8ucRRcRTBQnJlU5dUoDzBOQn5IC
+MQD6SmxgiHPz7riYYqnOK8LZiqZwMR2vsJRM60/G49HzYqc8/5MuB1xJAWdpEgJy
+v+c=
+-----END CERTIFICATE-----
+
+# Issuer: CN=GlobalSign Root R46 O=GlobalSign nv-sa
+# Subject: CN=GlobalSign Root R46 O=GlobalSign nv-sa
+# Label: "GlobalSign Root R46"
+# Serial: 1552617688466950547958867513931858518042577
+# MD5 Fingerprint: c4:14:30:e4:fa:66:43:94:2a:6a:1b:24:5f:19:d0:ef
+# SHA1 Fingerprint: 53:a2:b0:4b:ca:6b:d6:45:e6:39:8a:8e:c4:0d:d2:bf:77:c3:a2:90
+# SHA256 Fingerprint: 4f:a3:12:6d:8d:3a:11:d1:c4:85:5a:4f:80:7c:ba:d6:cf:91:9d:3a:5a:88:b0:3b:ea:2c:63:72:d9:3c:40:c9
+-----BEGIN CERTIFICATE-----
+MIIFWjCCA0KgAwIBAgISEdK7udcjGJ5AXwqdLdDfJWfRMA0GCSqGSIb3DQEBDAUA
+MEYxCzAJBgNVBAYTAkJFMRkwFwYDVQQKExBHbG9iYWxTaWduIG52LXNhMRwwGgYD
+VQQDExNHbG9iYWxTaWduIFJvb3QgUjQ2MB4XDTE5MDMyMDAwMDAwMFoXDTQ2MDMy
+MDAwMDAwMFowRjELMAkGA1UEBhMCQkUxGTAXBgNVBAoTEEdsb2JhbFNpZ24gbnYt
+c2ExHDAaBgNVBAMTE0dsb2JhbFNpZ24gUm9vdCBSNDYwggIiMA0GCSqGSIb3DQEB
+AQUAA4ICDwAwggIKAoICAQCsrHQy6LNl5brtQyYdpokNRbopiLKkHWPd08EsCVeJ
+OaFV6Wc0dwxu5FUdUiXSE2te4R2pt32JMl8Nnp8semNgQB+msLZ4j5lUlghYruQG
+vGIFAha/r6gjA7aUD7xubMLL1aa7DOn2wQL7Id5m3RerdELv8HQvJfTqa1VbkNud
+316HCkD7rRlr+/fKYIje2sGP1q7Vf9Q8g+7XFkyDRTNrJ9CG0Bwta/OrffGFqfUo
+0q3v84RLHIf8E6M6cqJaESvWJ3En7YEtbWaBkoe0G1h6zD8K+kZPTXhc+CtI4wSE
+y132tGqzZfxCnlEmIyDLPRT5ge1lFgBPGmSXZgjPjHvjK8Cd+RTyG/FWaha/LIWF
+zXg4mutCagI0GIMXTpRW+LaCtfOW3T3zvn8gdz57GSNrLNRyc0NXfeD412lPFzYE
++cCQYDdF3uYM2HSNrpyibXRdQr4G9dlkbgIQrImwTDsHTUB+JMWKmIJ5jqSngiCN
+I/onccnfxkF0oE32kRbcRoxfKWMxWXEM2G/CtjJ9++ZdU6Z+Ffy7dXxd7Pj2Fxzs
+x2sZy/N78CsHpdlseVR2bJ0cpm4O6XkMqCNqo98bMDGfsVR7/mrLZqrcZdCinkqa
+ByFrgY/bxFn63iLABJzjqls2k+g9vXqhnQt2sQvHnf3PmKgGwvgqo6GDoLclcqUC
+4wIDAQABo0IwQDAOBgNVHQ8BAf8EBAMCAYYwDwYDVR0TAQH/BAUwAwEB/zAdBgNV
+HQ4EFgQUA1yrc4GHqMywptWU4jaWSf8FmSwwDQYJKoZIhvcNAQEMBQADggIBAHx4
+7PYCLLtbfpIrXTncvtgdokIzTfnvpCo7RGkerNlFo048p9gkUbJUHJNOxO97k4Vg
+JuoJSOD1u8fpaNK7ajFxzHmuEajwmf3lH7wvqMxX63bEIaZHU1VNaL8FpO7XJqti
+2kM3S+LGteWygxk6x9PbTZ4IevPuzz5i+6zoYMzRx6Fcg0XERczzF2sUyQQCPtIk
+pnnpHs6i58FZFZ8d4kuaPp92CC1r2LpXFNqD6v6MVenQTqnMdzGxRBF6XLE+0xRF
+FRhiJBPSy03OXIPBNvIQtQ6IbbjhVp+J3pZmOUdkLG5NrmJ7v2B0GbhWrJKsFjLt
+rWhV/pi60zTe9Mlhww6G9kuEYO4Ne7UyWHmRVSyBQ7N0H3qqJZ4d16GLuc1CLgSk
+ZoNNiTW2bKg2SnkheCLQQrzRQDGQob4Ez8pn7fXwgNNgyYMqIgXQBztSvwyeqiv5
+u+YfjyW6hY0XHgL+XVAEV8/+LbzvXMAaq7afJMbfc2hIkCwU9D9SGuTSyxTDYWnP
+4vkYxboznxSjBF25cfe1lNj2M8FawTSLfJvdkzrnE6JwYZ+vj+vYxXX4M2bUdGc6
+N3ec592kD3ZDZopD8p/7DEJ4Y9HiD2971KE9dJeFt0g5QdYg/NA6s/rob8SKunE3
+vouXsXgxT7PntgMTzlSdriVZzH81Xwj3QEUxeCp6
+-----END CERTIFICATE-----
+
+# Issuer: CN=GlobalSign Root E46 O=GlobalSign nv-sa
+# Subject: CN=GlobalSign Root E46 O=GlobalSign nv-sa
+# Label: "GlobalSign Root E46"
+# Serial: 1552617690338932563915843282459653771421763
+# MD5 Fingerprint: b5:b8:66:ed:de:08:83:e3:c9:e2:01:34:06:ac:51:6f
+# SHA1 Fingerprint: 39:b4:6c:d5:fe:80:06:eb:e2:2f:4a:bb:08:33:a0:af:db:b9:dd:84
+# SHA256 Fingerprint: cb:b9:c4:4d:84:b8:04:3e:10:50:ea:31:a6:9f:51:49:55:d7:bf:d2:e2:c6:b4:93:01:01:9a:d6:1d:9f:50:58
+-----BEGIN CERTIFICATE-----
+MIICCzCCAZGgAwIBAgISEdK7ujNu1LzmJGjFDYQdmOhDMAoGCCqGSM49BAMDMEYx
+CzAJBgNVBAYTAkJFMRkwFwYDVQQKExBHbG9iYWxTaWduIG52LXNhMRwwGgYDVQQD
+ExNHbG9iYWxTaWduIFJvb3QgRTQ2MB4XDTE5MDMyMDAwMDAwMFoXDTQ2MDMyMDAw
+MDAwMFowRjELMAkGA1UEBhMCQkUxGTAXBgNVBAoTEEdsb2JhbFNpZ24gbnYtc2Ex
+HDAaBgNVBAMTE0dsb2JhbFNpZ24gUm9vdCBFNDYwdjAQBgcqhkjOPQIBBgUrgQQA
+IgNiAAScDrHPt+ieUnd1NPqlRqetMhkytAepJ8qUuwzSChDH2omwlwxwEwkBjtjq
+R+q+soArzfwoDdusvKSGN+1wCAB16pMLey5SnCNoIwZD7JIvU4Tb+0cUB+hflGdd
+yXqBPCCjQjBAMA4GA1UdDwEB/wQEAwIBhjAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud
+DgQWBBQxCpCPtsad0kRLgLWi5h+xEk8blTAKBggqhkjOPQQDAwNoADBlAjEA31SQ
+7Zvvi5QCkxeCmb6zniz2C5GMn0oUsfZkvLtoURMMA/cVi4RguYv/Uo7njLwcAjA8
++RHUjE7AwWHCFUyqqx0LMV87HOIAl0Qx5v5zli/altP+CAezNIm8BZ/3Hobui3A=
+-----END CERTIFICATE-----
+
+# Issuer: CN=ANF Secure Server Root CA O=ANF Autoridad de Certificacion OU=ANF CA Raiz
+# Subject: CN=ANF Secure Server Root CA O=ANF Autoridad de Certificacion OU=ANF CA Raiz
+# Label: "ANF Secure Server Root CA"
+# Serial: 996390341000653745
+# MD5 Fingerprint: 26:a6:44:5a:d9:af:4e:2f:b2:1d:b6:65:b0:4e:e8:96
+# SHA1 Fingerprint: 5b:6e:68:d0:cc:15:b6:a0:5f:1e:c1:5f:ae:02:fc:6b:2f:5d:6f:74
+# SHA256 Fingerprint: fb:8f:ec:75:91:69:b9:10:6b:1e:51:16:44:c6:18:c5:13:04:37:3f:6c:06:43:08:8d:8b:ef:fd:1b:99:75:99
+-----BEGIN CERTIFICATE-----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+-----END CERTIFICATE-----
+
+# Issuer: CN=Certum EC-384 CA O=Asseco Data Systems S.A. OU=Certum Certification Authority
+# Subject: CN=Certum EC-384 CA O=Asseco Data Systems S.A. OU=Certum Certification Authority
+# Label: "Certum EC-384 CA"
+# Serial: 160250656287871593594747141429395092468
+# MD5 Fingerprint: b6:65:b3:96:60:97:12:a1:ec:4e:e1:3d:a3:c6:c9:f1
+# SHA1 Fingerprint: f3:3e:78:3c:ac:df:f4:a2:cc:ac:67:55:69:56:d7:e5:16:3c:e1:ed
+# SHA256 Fingerprint: 6b:32:80:85:62:53:18:aa:50:d1:73:c9:8d:8b:da:09:d5:7e:27:41:3d:11:4c:f7:87:a0:f5:d0:6c:03:0c:f6
+-----BEGIN CERTIFICATE-----
+MIICZTCCAeugAwIBAgIQeI8nXIESUiClBNAt3bpz9DAKBggqhkjOPQQDAzB0MQsw
+CQYDVQQGEwJQTDEhMB8GA1UEChMYQXNzZWNvIERhdGEgU3lzdGVtcyBTLkEuMScw
+JQYDVQQLEx5DZXJ0dW0gQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkxGTAXBgNVBAMT
+EENlcnR1bSBFQy0zODQgQ0EwHhcNMTgwMzI2MDcyNDU0WhcNNDMwMzI2MDcyNDU0
+WjB0MQswCQYDVQQGEwJQTDEhMB8GA1UEChMYQXNzZWNvIERhdGEgU3lzdGVtcyBT
+LkEuMScwJQYDVQQLEx5DZXJ0dW0gQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkxGTAX
+BgNVBAMTEENlcnR1bSBFQy0zODQgQ0EwdjAQBgcqhkjOPQIBBgUrgQQAIgNiAATE
+KI6rGFtqvm5kN2PkzeyrOvfMobgOgknXhimfoZTy42B4mIF4Bk3y7JoOV2CDn7Tm
+Fy8as10CW4kjPMIRBSqniBMY81CE1700LCeJVf/OTOffph8oxPBUw7l8t1Ot68Kj
+QjBAMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFI0GZnQkdjrzife81r1HfS+8
+EF9LMA4GA1UdDwEB/wQEAwIBBjAKBggqhkjOPQQDAwNoADBlAjADVS2m5hjEfO/J
+UG7BJw+ch69u1RsIGL2SKcHvlJF40jocVYli5RsJHrpka/F2tNQCMQC0QoSZ/6vn
+nvuRlydd3LBbMHHOXjgaatkl5+r3YZJW+OraNsKHZZYuciUvf9/DE8k=
+-----END CERTIFICATE-----
+
+# Issuer: CN=Certum Trusted Root CA O=Asseco Data Systems S.A. OU=Certum Certification Authority
+# Subject: CN=Certum Trusted Root CA O=Asseco Data Systems S.A. OU=Certum Certification Authority
+# Label: "Certum Trusted Root CA"
+# Serial: 40870380103424195783807378461123655149
+# MD5 Fingerprint: 51:e1:c2:e7:fe:4c:84:af:59:0e:2f:f4:54:6f:ea:29
+# SHA1 Fingerprint: c8:83:44:c0:18:ae:9f:cc:f1:87:b7:8f:22:d1:c5:d7:45:84:ba:e5
+# SHA256 Fingerprint: fe:76:96:57:38:55:77:3e:37:a9:5e:7a:d4:d9:cc:96:c3:01:57:c1:5d:31:76:5b:a9:b1:57:04:e1:ae:78:fd
+-----BEGIN CERTIFICATE-----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+-----END CERTIFICATE-----
+
+# Issuer: CN=TunTrust Root CA O=Agence Nationale de Certification Electronique
+# Subject: CN=TunTrust Root CA O=Agence Nationale de Certification Electronique
+# Label: "TunTrust Root CA"
+# Serial: 108534058042236574382096126452369648152337120275
+# MD5 Fingerprint: 85:13:b9:90:5b:36:5c:b6:5e:b8:5a:f8:e0:31:57:b4
+# SHA1 Fingerprint: cf:e9:70:84:0f:e0:73:0f:9d:f6:0c:7f:2c:4b:ee:20:46:34:9c:bb
+# SHA256 Fingerprint: 2e:44:10:2a:b5:8c:b8:54:19:45:1c:8e:19:d9:ac:f3:66:2c:af:bc:61:4b:6a:53:96:0a:30:f7:d0:e2:eb:41
+-----BEGIN CERTIFICATE-----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+-----END CERTIFICATE-----
+
+# Issuer: CN=HARICA TLS RSA Root CA 2021 O=Hellenic Academic and Research Institutions CA
+# Subject: CN=HARICA TLS RSA Root CA 2021 O=Hellenic Academic and Research Institutions CA
+# Label: "HARICA TLS RSA Root CA 2021"
+# Serial: 76817823531813593706434026085292783742
+# MD5 Fingerprint: 65:47:9b:58:86:dd:2c:f0:fc:a2:84:1f:1e:96:c4:91
+# SHA1 Fingerprint: 02:2d:05:82:fa:88:ce:14:0c:06:79:de:7f:14:10:e9:45:d7:a5:6d
+# SHA256 Fingerprint: d9:5d:0e:8e:da:79:52:5b:f9:be:b1:1b:14:d2:10:0d:32:94:98:5f:0c:62:d9:fa:bd:9c:d9:99:ec:cb:7b:1d
+-----BEGIN CERTIFICATE-----
+MIIFpDCCA4ygAwIBAgIQOcqTHO9D88aOk8f0ZIk4fjANBgkqhkiG9w0BAQsFADBs
+MQswCQYDVQQGEwJHUjE3MDUGA1UECgwuSGVsbGVuaWMgQWNhZGVtaWMgYW5kIFJl
+c2VhcmNoIEluc3RpdHV0aW9ucyBDQTEkMCIGA1UEAwwbSEFSSUNBIFRMUyBSU0Eg
+Um9vdCBDQSAyMDIxMB4XDTIxMDIxOTEwNTUzOFoXDTQ1MDIxMzEwNTUzN1owbDEL
+MAkGA1UEBhMCR1IxNzA1BgNVBAoMLkhlbGxlbmljIEFjYWRlbWljIGFuZCBSZXNl
+YXJjaCBJbnN0aXR1dGlvbnMgQ0ExJDAiBgNVBAMMG0hBUklDQSBUTFMgUlNBIFJv
+b3QgQ0EgMjAyMTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAIvC569l
+mwVnlskNJLnQDmT8zuIkGCyEf3dRywQRNrhe7Wlxp57kJQmXZ8FHws+RFjZiPTgE
+4VGC/6zStGndLuwRo0Xua2s7TL+MjaQenRG56Tj5eg4MmOIjHdFOY9TnuEFE+2uv
+a9of08WRiFukiZLRgeaMOVig1mlDqa2YUlhu2wr7a89o+uOkXjpFc5gH6l8Cct4M
+pbOfrqkdtx2z/IpZ525yZa31MJQjB/OCFks1mJxTuy/K5FrZx40d/JiZ+yykgmvw
+Kh+OC19xXFyuQnspiYHLA6OZyoieC0AJQTPb5lh6/a6ZcMBaD9YThnEvdmn8kN3b
+LW7R8pv1GmuebxWMevBLKKAiOIAkbDakO/IwkfN4E8/BPzWr8R0RI7VDIp4BkrcY
+AuUR0YLbFQDMYTfBKnya4dC6s1BG7oKsnTH4+yPiAwBIcKMJJnkVU2DzOFytOOqB
+AGMUuTNe3QvboEUHGjMJ+E20pwKmafTCWQWIZYVWrkvL4N48fS0ayOn7H6NhStYq
+E613TBoYm5EPWNgGVMWX+Ko/IIqmhaZ39qb8HOLubpQzKoNQhArlT4b4UEV4AIHr
+W2jjJo3Me1xR9BQsQL4aYB16cmEdH2MtiKrOokWQCPxrvrNQKlr9qEgYRtaQQJKQ
+CoReaDH46+0N0x3GfZkYVVYnZS6NRcUk7M7jAgMBAAGjQjBAMA8GA1UdEwEB/wQF
+MAMBAf8wHQYDVR0OBBYEFApII6ZgpJIKM+qTW8VX6iVNvRLuMA4GA1UdDwEB/wQE
+AwIBhjANBgkqhkiG9w0BAQsFAAOCAgEAPpBIqm5iFSVmewzVjIuJndftTgfvnNAU
+X15QvWiWkKQUEapobQk1OUAJ2vQJLDSle1mESSmXdMgHHkdt8s4cUCbjnj1AUz/3
+f5Z2EMVGpdAgS1D0NTsY9FVqQRtHBmg8uwkIYtlfVUKqrFOFrJVWNlar5AWMxaja
+H6NpvVMPxP/cyuN+8kyIhkdGGvMA9YCRotxDQpSbIPDRzbLrLFPCU3hKTwSUQZqP
+JzLB5UkZv/HywouoCjkxKLR9YjYsTewfM7Z+d21+UPCfDtcRj88YxeMn/ibvBZ3P
+zzfF0HvaO7AWhAw6k9a+F9sPPg4ZeAnHqQJyIkv3N3a6dcSFA1pj1bF1BcK5vZSt
+jBWZp5N99sXzqnTPBIWUmAD04vnKJGW/4GKvyMX6ssmeVkjaef2WdhW+o45WxLM0
+/L5H9MG0qPzVMIho7suuyWPEdr6sOBjhXlzPrjoiUevRi7PzKzMHVIf6tLITe7pT
+BGIBnfHAT+7hOtSLIBD6Alfm78ELt5BGnBkpjNxvoEppaZS3JGWg/6w/zgH7IS79
+aPib8qXPMThcFarmlwDB31qlpzmq6YR/PFGoOtmUW4y/Twhx5duoXNTSpv4Ao8YW
+xw/ogM4cKGR0GQjTQuPOAF1/sdwTsOEFy9EgqoZ0njnnkf3/W9b3raYvAwtt41dU
+63ZTGI0RmLo=
+-----END CERTIFICATE-----
+
+# Issuer: CN=HARICA TLS ECC Root CA 2021 O=Hellenic Academic and Research Institutions CA
+# Subject: CN=HARICA TLS ECC Root CA 2021 O=Hellenic Academic and Research Institutions CA
+# Label: "HARICA TLS ECC Root CA 2021"
+# Serial: 137515985548005187474074462014555733966
+# MD5 Fingerprint: ae:f7:4c:e5:66:35:d1:b7:9b:8c:22:93:74:d3:4b:b0
+# SHA1 Fingerprint: bc:b0:c1:9d:e9:98:92:70:19:38:57:e9:8d:a7:b4:5d:6e:ee:01:48
+# SHA256 Fingerprint: 3f:99:cc:47:4a:cf:ce:4d:fe:d5:87:94:66:5e:47:8d:15:47:73:9f:2e:78:0f:1b:b4:ca:9b:13:30:97:d4:01
+-----BEGIN CERTIFICATE-----
+MIICVDCCAdugAwIBAgIQZ3SdjXfYO2rbIvT/WeK/zjAKBggqhkjOPQQDAzBsMQsw
+CQYDVQQGEwJHUjE3MDUGA1UECgwuSGVsbGVuaWMgQWNhZGVtaWMgYW5kIFJlc2Vh
+cmNoIEluc3RpdHV0aW9ucyBDQTEkMCIGA1UEAwwbSEFSSUNBIFRMUyBFQ0MgUm9v
+dCBDQSAyMDIxMB4XDTIxMDIxOTExMDExMFoXDTQ1MDIxMzExMDEwOVowbDELMAkG
+A1UEBhMCR1IxNzA1BgNVBAoMLkhlbGxlbmljIEFjYWRlbWljIGFuZCBSZXNlYXJj
+aCBJbnN0aXR1dGlvbnMgQ0ExJDAiBgNVBAMMG0hBUklDQSBUTFMgRUNDIFJvb3Qg
+Q0EgMjAyMTB2MBAGByqGSM49AgEGBSuBBAAiA2IABDgI/rGgltJ6rK9JOtDA4MM7
+KKrxcm1lAEeIhPyaJmuqS7psBAqIXhfyVYf8MLA04jRYVxqEU+kw2anylnTDUR9Y
+STHMmE5gEYd103KUkE+bECUqqHgtvpBBWJAVcqeht6NCMEAwDwYDVR0TAQH/BAUw
+AwEB/zAdBgNVHQ4EFgQUyRtTgRL+BNUW0aq8mm+3oJUZbsowDgYDVR0PAQH/BAQD
+AgGGMAoGCCqGSM49BAMDA2cAMGQCMBHervjcToiwqfAircJRQO9gcS3ujwLEXQNw
+SaSS6sUUiHCm0w2wqsosQJz76YJumgIwK0eaB8bRwoF8yguWGEEbo/QwCZ61IygN
+nxS2PFOiTAZpffpskcYqSUXm7LcT4Tps
+-----END CERTIFICATE-----
+
+# Issuer: CN=Autoridad de Certificacion Firmaprofesional CIF A62634068
+# Subject: CN=Autoridad de Certificacion Firmaprofesional CIF A62634068
+# Label: "Autoridad de Certificacion Firmaprofesional CIF A62634068"
+# Serial: 1977337328857672817
+# MD5 Fingerprint: 4e:6e:9b:54:4c:ca:b7:fa:48:e4:90:b1:15:4b:1c:a3
+# SHA1 Fingerprint: 0b:be:c2:27:22:49:cb:39:aa:db:35:5c:53:e3:8c:ae:78:ff:b6:fe
+# SHA256 Fingerprint: 57:de:05:83:ef:d2:b2:6e:03:61:da:99:da:9d:f4:64:8d:ef:7e:e8:44:1c:3b:72:8a:fa:9b:cd:e0:f9:b2:6a
+-----BEGIN CERTIFICATE-----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+-----END CERTIFICATE-----
+
+# Issuer: CN=vTrus ECC Root CA O=iTrusChina Co.,Ltd.
+# Subject: CN=vTrus ECC Root CA O=iTrusChina Co.,Ltd.
+# Label: "vTrus ECC Root CA"
+# Serial: 630369271402956006249506845124680065938238527194
+# MD5 Fingerprint: de:4b:c1:f5:52:8c:9b:43:e1:3e:8f:55:54:17:8d:85
+# SHA1 Fingerprint: f6:9c:db:b0:fc:f6:02:13:b6:52:32:a6:a3:91:3f:16:70:da:c3:e1
+# SHA256 Fingerprint: 30:fb:ba:2c:32:23:8e:2a:98:54:7a:f9:79:31:e5:50:42:8b:9b:3f:1c:8e:eb:66:33:dc:fa:86:c5:b2:7d:d3
+-----BEGIN CERTIFICATE-----
+MIICDzCCAZWgAwIBAgIUbmq8WapTvpg5Z6LSa6Q75m0c1towCgYIKoZIzj0EAwMw
+RzELMAkGA1UEBhMCQ04xHDAaBgNVBAoTE2lUcnVzQ2hpbmEgQ28uLEx0ZC4xGjAY
+BgNVBAMTEXZUcnVzIEVDQyBSb290IENBMB4XDTE4MDczMTA3MjY0NFoXDTQzMDcz
+MTA3MjY0NFowRzELMAkGA1UEBhMCQ04xHDAaBgNVBAoTE2lUcnVzQ2hpbmEgQ28u
+LEx0ZC4xGjAYBgNVBAMTEXZUcnVzIEVDQyBSb290IENBMHYwEAYHKoZIzj0CAQYF
+K4EEACIDYgAEZVBKrox5lkqqHAjDo6LN/llWQXf9JpRCux3NCNtzslt188+cToL0
+v/hhJoVs1oVbcnDS/dtitN9Ti72xRFhiQgnH+n9bEOf+QP3A2MMrMudwpremIFUd
+e4BdS49nTPEQo0IwQDAdBgNVHQ4EFgQUmDnNvtiyjPeyq+GtJK97fKHbH88wDwYD
+VR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMCAQYwCgYIKoZIzj0EAwMDaAAwZQIw
+V53dVvHH4+m4SVBrm2nDb+zDfSXkV5UTQJtS0zvzQBm8JsctBp61ezaf9SXUY2sA
+AjEA6dPGnlaaKsyh2j/IZivTWJwghfqrkYpwcBE4YGQLYgmRWAD5Tfs0aNoJrSEG
+GJTO
+-----END CERTIFICATE-----
+
+# Issuer: CN=vTrus Root CA O=iTrusChina Co.,Ltd.
+# Subject: CN=vTrus Root CA O=iTrusChina Co.,Ltd.
+# Label: "vTrus Root CA"
+# Serial: 387574501246983434957692974888460947164905180485
+# MD5 Fingerprint: b8:c9:37:df:fa:6b:31:84:64:c5:ea:11:6a:1b:75:fc
+# SHA1 Fingerprint: 84:1a:69:fb:f5:cd:1a:25:34:13:3d:e3:f8:fc:b8:99:d0:c9:14:b7
+# SHA256 Fingerprint: 8a:71:de:65:59:33:6f:42:6c:26:e5:38:80:d0:0d:88:a1:8d:a4:c6:a9:1f:0d:cb:61:94:e2:06:c5:c9:63:87
+-----BEGIN CERTIFICATE-----
+MIIFVjCCAz6gAwIBAgIUQ+NxE9izWRRdt86M/TX9b7wFjUUwDQYJKoZIhvcNAQEL
+BQAwQzELMAkGA1UEBhMCQ04xHDAaBgNVBAoTE2lUcnVzQ2hpbmEgQ28uLEx0ZC4x
+FjAUBgNVBAMTDXZUcnVzIFJvb3QgQ0EwHhcNMTgwNzMxMDcyNDA1WhcNNDMwNzMx
+MDcyNDA1WjBDMQswCQYDVQQGEwJDTjEcMBoGA1UEChMTaVRydXNDaGluYSBDby4s
+THRkLjEWMBQGA1UEAxMNdlRydXMgUm9vdCBDQTCCAiIwDQYJKoZIhvcNAQEBBQAD
+ggIPADCCAgoCggIBAL1VfGHTuB0EYgWgrmy3cLRB6ksDXhA/kFocizuwZotsSKYc
+IrrVQJLuM7IjWcmOvFjai57QGfIvWcaMY1q6n6MLsLOaXLoRuBLpDLvPbmyAhykU
+AyyNJJrIZIO1aqwTLDPxn9wsYTwaP3BVm60AUn/PBLn+NvqcwBauYv6WTEN+VRS+
+GrPSbcKvdmaVayqwlHeFXgQPYh1jdfdr58tbmnDsPmcF8P4HCIDPKNsFxhQnL4Z9
+8Cfe/+Z+M0jnCx5Y0ScrUw5XSmXX+6KAYPxMvDVTAWqXcoKv8R1w6Jz1717CbMdH
+flqUhSZNO7rrTOiwCcJlwp2dCZtOtZcFrPUGoPc2BX70kLJrxLT5ZOrpGgrIDajt
+J8nU57O5q4IikCc9Kuh8kO+8T/3iCiSn3mUkpF3qwHYw03dQ+A0Em5Q2AXPKBlim
+0zvc+gRGE1WKyURHuFE5Gi7oNOJ5y1lKCn+8pu8fA2dqWSslYpPZUxlmPCdiKYZN
+pGvu/9ROutW04o5IWgAZCfEF2c6Rsffr6TlP9m8EQ5pV9T4FFL2/s1m02I4zhKOQ
+UqqzApVg+QxMaPnu1RcN+HFXtSXkKe5lXa/R7jwXC1pDxaWG6iSe4gUH3DRCEpHW
+OXSuTEGC2/KmSNGzm/MzqvOmwMVO9fSddmPmAsYiS8GVP1BkLFTltvA8Kc9XAgMB
+AAGjQjBAMB0GA1UdDgQWBBRUYnBj8XWEQ1iO0RYgscasGrz2iTAPBgNVHRMBAf8E
+BTADAQH/MA4GA1UdDwEB/wQEAwIBBjANBgkqhkiG9w0BAQsFAAOCAgEAKbqSSaet
+8PFww+SX8J+pJdVrnjT+5hpk9jprUrIQeBqfTNqK2uwcN1LgQkv7bHbKJAs5EhWd
+nxEt/Hlk3ODg9d3gV8mlsnZwUKT+twpw1aA08XXXTUm6EdGz2OyC/+sOxL9kLX1j
+bhd47F18iMjrjld22VkE+rxSH0Ws8HqA7Oxvdq6R2xCOBNyS36D25q5J08FsEhvM
+Kar5CKXiNxTKsbhm7xqC5PD48acWabfbqWE8n/Uxy+QARsIvdLGx14HuqCaVvIiv
+TDUHKgLKeBRtRytAVunLKmChZwOgzoy8sHJnxDHO2zTlJQNgJXtxmOTAGytfdELS
+S8VZCAeHvsXDf+eW2eHcKJfWjwXj9ZtOyh1QRwVTsMo554WgicEFOwE30z9J4nfr
+I8iIZjs9OXYhRvHsXyO466JmdXTBQPfYaJqT4i2pLr0cox7IdMakLXogqzu4sEb9
+b91fUlV1YvCXoHzXOP0l382gmxDPi7g4Xl7FtKYCNqEeXxzP4padKar9mK5S4fNB
+UvupLnKWnyfjqnN9+BojZns7q2WwMgFLFT49ok8MKzWixtlnEjUwzXYuFrOZnk1P
+Ti07NEPhmg4NpGaXutIcSkwsKouLgU9xGqndXHt7CMUADTdA43x7VF8vhV929ven
+sBxXVsFy6K2ir40zSbofitzmdHxghm+Hl3s=
+-----END CERTIFICATE-----
+
+# Issuer: CN=ISRG Root X2 O=Internet Security Research Group
+# Subject: CN=ISRG Root X2 O=Internet Security Research Group
+# Label: "ISRG Root X2"
+# Serial: 87493402998870891108772069816698636114
+# MD5 Fingerprint: d3:9e:c4:1e:23:3c:a6:df:cf:a3:7e:6d:e0:14:e6:e5
+# SHA1 Fingerprint: bd:b1:b9:3c:d5:97:8d:45:c6:26:14:55:f8:db:95:c7:5a:d1:53:af
+# SHA256 Fingerprint: 69:72:9b:8e:15:a8:6e:fc:17:7a:57:af:b7:17:1d:fc:64:ad:d2:8c:2f:ca:8c:f1:50:7e:34:45:3c:cb:14:70
+-----BEGIN CERTIFICATE-----
+MIICGzCCAaGgAwIBAgIQQdKd0XLq7qeAwSxs6S+HUjAKBggqhkjOPQQDAzBPMQsw
+CQYDVQQGEwJVUzEpMCcGA1UEChMgSW50ZXJuZXQgU2VjdXJpdHkgUmVzZWFyY2gg
+R3JvdXAxFTATBgNVBAMTDElTUkcgUm9vdCBYMjAeFw0yMDA5MDQwMDAwMDBaFw00
+MDA5MTcxNjAwMDBaME8xCzAJBgNVBAYTAlVTMSkwJwYDVQQKEyBJbnRlcm5ldCBT
+ZWN1cml0eSBSZXNlYXJjaCBHcm91cDEVMBMGA1UEAxMMSVNSRyBSb290IFgyMHYw
+EAYHKoZIzj0CAQYFK4EEACIDYgAEzZvVn4CDCuwJSvMWSj5cz3es3mcFDR0HttwW
++1qLFNvicWDEukWVEYmO6gbf9yoWHKS5xcUy4APgHoIYOIvXRdgKam7mAHf7AlF9
+ItgKbppbd9/w+kHsOdx1ymgHDB/qo0IwQDAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0T
+AQH/BAUwAwEB/zAdBgNVHQ4EFgQUfEKWrt5LSDv6kviejM9ti6lyN5UwCgYIKoZI
+zj0EAwMDaAAwZQIwe3lORlCEwkSHRhtFcP9Ymd70/aTSVaYgLXTWNLxBo1BfASdW
+tL4ndQavEi51mI38AjEAi/V3bNTIZargCyzuFJ0nN6T5U6VR5CmD1/iQMVtCnwr1
+/q4AaOeMSQ+2b1tbFfLn
+-----END CERTIFICATE-----
+
+# Issuer: CN=HiPKI Root CA - G1 O=Chunghwa Telecom Co., Ltd.
+# Subject: CN=HiPKI Root CA - G1 O=Chunghwa Telecom Co., Ltd.
+# Label: "HiPKI Root CA - G1"
+# Serial: 60966262342023497858655262305426234976
+# MD5 Fingerprint: 69:45:df:16:65:4b:e8:68:9a:8f:76:5f:ff:80:9e:d3
+# SHA1 Fingerprint: 6a:92:e4:a8:ee:1b:ec:96:45:37:e3:29:57:49:cd:96:e3:e5:d2:60
+# SHA256 Fingerprint: f0:15:ce:3c:c2:39:bf:ef:06:4b:e9:f1:d2:c4:17:e1:a0:26:4a:0a:94:be:1f:0c:8d:12:18:64:eb:69:49:cc
+-----BEGIN CERTIFICATE-----
+MIIFajCCA1KgAwIBAgIQLd2szmKXlKFD6LDNdmpeYDANBgkqhkiG9w0BAQsFADBP
+MQswCQYDVQQGEwJUVzEjMCEGA1UECgwaQ2h1bmdod2EgVGVsZWNvbSBDby4sIEx0
+ZC4xGzAZBgNVBAMMEkhpUEtJIFJvb3QgQ0EgLSBHMTAeFw0xOTAyMjIwOTQ2MDRa
+Fw0zNzEyMzExNTU5NTlaME8xCzAJBgNVBAYTAlRXMSMwIQYDVQQKDBpDaHVuZ2h3
+YSBUZWxlY29tIENvLiwgTHRkLjEbMBkGA1UEAwwSSGlQS0kgUm9vdCBDQSAtIEcx
+MIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEA9B5/UnMyDHPkvRN0o9Qw
+qNCuS9i233VHZvR85zkEHmpwINJaR3JnVfSl6J3VHiGh8Ge6zCFovkRTv4354twv
+Vcg3Px+kwJyz5HdcoEb+d/oaoDjq7Zpy3iu9lFc6uux55199QmQ5eiY29yTw1S+6
+lZgRZq2XNdZ1AYDgr/SEYYwNHl98h5ZeQa/rh+r4XfEuiAU+TCK72h8q3VJGZDnz
+Qs7ZngyzsHeXZJzA9KMuH5UHsBffMNsAGJZMoYFL3QRtU6M9/Aes1MU3guvklQgZ
+KILSQjqj2FPseYlgSGDIcpJQ3AOPgz+yQlda22rpEZfdhSi8MEyr48KxRURHH+CK
+FgeW0iEPU8DtqX7UTuybCeyvQqww1r/REEXgphaypcXTT3OUM3ECoWqj1jOXTyFj
+HluP2cFeRXF3D4FdXyGarYPM+l7WjSNfGz1BryB1ZlpK9p/7qxj3ccC2HTHsOyDr
+y+K49a6SsvfhhEvyovKTmiKe0xRvNlS9H15ZFblzqMF8b3ti6RZsR1pl8w4Rm0bZ
+/W3c1pzAtH2lsN0/Vm+h+fbkEkj9Bn8SV7apI09bA8PgcSojt/ewsTu8mL3WmKgM
+a/aOEmem8rJY5AIJEzypuxC00jBF8ez3ABHfZfjcK0NVvxaXxA/VLGGEqnKG/uY6
+fsI/fe78LxQ+5oXdUG+3Se0CAwEAAaNCMEAwDwYDVR0TAQH/BAUwAwEB/zAdBgNV
+HQ4EFgQU8ncX+l6o/vY9cdVouslGDDjYr7AwDgYDVR0PAQH/BAQDAgGGMA0GCSqG
+SIb3DQEBCwUAA4ICAQBQUfB13HAE4/+qddRxosuej6ip0691x1TPOhwEmSKsxBHi
+7zNKpiMdDg1H2DfHb680f0+BazVP6XKlMeJ45/dOlBhbQH3PayFUhuaVevvGyuqc
+SE5XCV0vrPSltJczWNWseanMX/mF+lLFjfiRFOs6DRfQUsJ748JzjkZ4Bjgs6Fza
+ZsT0pPBWGTMpWmWSBUdGSquEwx4noR8RkpkndZMPvDY7l1ePJlsMu5wP1G4wB9Tc
+XzZoZjmDlicmisjEOf6aIW/Vcobpf2Lll07QJNBAsNB1CI69aO4I1258EHBGG3zg
+iLKecoaZAeO/n0kZtCW+VmWuF2PlHt/o/0elv+EmBYTksMCv5wiZqAxeJoBF1Pho
+L5aPruJKHJwWDBNvOIf2u8g0X5IDUXlwpt/L9ZlNec1OvFefQ05rLisY+GpzjLrF
+Ne85akEez3GoorKGB1s6yeHvP2UEgEcyRHCVTjFnanRbEEV16rCf0OY1/k6fi8wr
+kkVbbiVghUbN0aqwdmaTd5a+g744tiROJgvM7XpWGuDpWsZkrUx6AEhEL7lAuxM+
+vhV4nYWBSipX3tUZQ9rbyltHhoMLP7YNdnhzeSJesYAfz77RP1YQmCuVh6EfnWQU
+YDksswBVLuT1sw5XxJFBAJw/6KXf6vb/yPCtbVKoF6ubYfwSUTXkJf2vqmqGOQ==
+-----END CERTIFICATE-----
+
+# Issuer: CN=GlobalSign O=GlobalSign OU=GlobalSign ECC Root CA - R4
+# Subject: CN=GlobalSign O=GlobalSign OU=GlobalSign ECC Root CA - R4
+# Label: "GlobalSign ECC Root CA - R4"
+# Serial: 159662223612894884239637590694
+# MD5 Fingerprint: 26:29:f8:6d:e1:88:bf:a2:65:7f:aa:c4:cd:0f:7f:fc
+# SHA1 Fingerprint: 6b:a0:b0:98:e1:71:ef:5a:ad:fe:48:15:80:77:10:f4:bd:6f:0b:28
+# SHA256 Fingerprint: b0:85:d7:0b:96:4f:19:1a:73:e4:af:0d:54:ae:7a:0e:07:aa:fd:af:9b:71:dd:08:62:13:8a:b7:32:5a:24:a2
+-----BEGIN CERTIFICATE-----
+MIIB3DCCAYOgAwIBAgINAgPlfvU/k/2lCSGypjAKBggqhkjOPQQDAjBQMSQwIgYD
+VQQLExtHbG9iYWxTaWduIEVDQyBSb290IENBIC0gUjQxEzARBgNVBAoTCkdsb2Jh
+bFNpZ24xEzARBgNVBAMTCkdsb2JhbFNpZ24wHhcNMTIxMTEzMDAwMDAwWhcNMzgw
+MTE5MDMxNDA3WjBQMSQwIgYDVQQLExtHbG9iYWxTaWduIEVDQyBSb290IENBIC0g
+UjQxEzARBgNVBAoTCkdsb2JhbFNpZ24xEzARBgNVBAMTCkdsb2JhbFNpZ24wWTAT
+BgcqhkjOPQIBBggqhkjOPQMBBwNCAAS4xnnTj2wlDp8uORkcA6SumuU5BwkWymOx
+uYb4ilfBV85C+nOh92VC/x7BALJucw7/xyHlGKSq2XE/qNS5zowdo0IwQDAOBgNV
+HQ8BAf8EBAMCAYYwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUVLB7rUW44kB/
++wpu+74zyTyjhNUwCgYIKoZIzj0EAwIDRwAwRAIgIk90crlgr/HmnKAWBVBfw147
+bmF0774BxL4YSFlhgjICICadVGNA3jdgUM/I2O2dgq43mLyjj0xMqTQrbO/7lZsm
+-----END CERTIFICATE-----
+
+# Issuer: CN=GTS Root R1 O=Google Trust Services LLC
+# Subject: CN=GTS Root R1 O=Google Trust Services LLC
+# Label: "GTS Root R1"
+# Serial: 159662320309726417404178440727
+# MD5 Fingerprint: 05:fe:d0:bf:71:a8:a3:76:63:da:01:e0:d8:52:dc:40
+# SHA1 Fingerprint: e5:8c:1c:c4:91:3b:38:63:4b:e9:10:6e:e3:ad:8e:6b:9d:d9:81:4a
+# SHA256 Fingerprint: d9:47:43:2a:bd:e7:b7:fa:90:fc:2e:6b:59:10:1b:12:80:e0:e1:c7:e4:e4:0f:a3:c6:88:7f:ff:57:a7:f4:cf
+-----BEGIN CERTIFICATE-----
+MIIFVzCCAz+gAwIBAgINAgPlk28xsBNJiGuiFzANBgkqhkiG9w0BAQwFADBHMQsw
+CQYDVQQGEwJVUzEiMCAGA1UEChMZR29vZ2xlIFRydXN0IFNlcnZpY2VzIExMQzEU
+MBIGA1UEAxMLR1RTIFJvb3QgUjEwHhcNMTYwNjIyMDAwMDAwWhcNMzYwNjIyMDAw
+MDAwWjBHMQswCQYDVQQGEwJVUzEiMCAGA1UEChMZR29vZ2xlIFRydXN0IFNlcnZp
+Y2VzIExMQzEUMBIGA1UEAxMLR1RTIFJvb3QgUjEwggIiMA0GCSqGSIb3DQEBAQUA
+A4ICDwAwggIKAoICAQC2EQKLHuOhd5s73L+UPreVp0A8of2C+X0yBoJx9vaMf/vo
+27xqLpeXo4xL+Sv2sfnOhB2x+cWX3u+58qPpvBKJXqeqUqv4IyfLpLGcY9vXmX7w
+Cl7raKb0xlpHDU0QM+NOsROjyBhsS+z8CZDfnWQpJSMHobTSPS5g4M/SCYe7zUjw
+TcLCeoiKu7rPWRnWr4+wB7CeMfGCwcDfLqZtbBkOtdh+JhpFAz2weaSUKK0Pfybl
+qAj+lug8aJRT7oM6iCsVlgmy4HqMLnXWnOunVmSPlk9orj2XwoSPwLxAwAtcvfaH
+szVsrBhQf4TgTM2S0yDpM7xSma8ytSmzJSq0SPly4cpk9+aCEI3oncKKiPo4Zor8
+Y/kB+Xj9e1x3+naH+uzfsQ55lVe0vSbv1gHR6xYKu44LtcXFilWr06zqkUspzBmk
+MiVOKvFlRNACzqrOSbTqn3yDsEB750Orp2yjj32JgfpMpf/VjsPOS+C12LOORc92
+wO1AK/1TD7Cn1TsNsYqiA94xrcx36m97PtbfkSIS5r762DL8EGMUUXLeXdYWk70p
+aDPvOmbsB4om3xPXV2V4J95eSRQAogB/mqghtqmxlbCluQ0WEdrHbEg8QOB+DVrN
+VjzRlwW5y0vtOUucxD/SVRNuJLDWcfr0wbrM7Rv1/oFB2ACYPTrIrnqYNxgFlQID
+AQABo0IwQDAOBgNVHQ8BAf8EBAMCAYYwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4E
+FgQU5K8rJnEaK0gnhS9SZizv8IkTcT4wDQYJKoZIhvcNAQEMBQADggIBAJ+qQibb
+C5u+/x6Wki4+omVKapi6Ist9wTrYggoGxval3sBOh2Z5ofmmWJyq+bXmYOfg6LEe
+QkEzCzc9zolwFcq1JKjPa7XSQCGYzyI0zzvFIoTgxQ6KfF2I5DUkzps+GlQebtuy
+h6f88/qBVRRiClmpIgUxPoLW7ttXNLwzldMXG+gnoot7TiYaelpkttGsN/H9oPM4
+7HLwEXWdyzRSjeZ2axfG34arJ45JK3VmgRAhpuo+9K4l/3wV3s6MJT/KYnAK9y8J
+ZgfIPxz88NtFMN9iiMG1D53Dn0reWVlHxYciNuaCp+0KueIHoI17eko8cdLiA6Ef
+MgfdG+RCzgwARWGAtQsgWSl4vflVy2PFPEz0tv/bal8xa5meLMFrUKTX5hgUvYU/
+Z6tGn6D/Qqc6f1zLXbBwHSs09dR2CQzreExZBfMzQsNhFRAbd03OIozUhfJFfbdT
+6u9AWpQKXCBfTkBdYiJ23//OYb2MI3jSNwLgjt7RETeJ9r/tSQdirpLsQBqvFAnZ
+0E6yove+7u7Y/9waLd64NnHi/Hm3lCXRSHNboTXns5lndcEZOitHTtNCjv0xyBZm
+2tIMPNuzjsmhDYAPexZ3FL//2wmUspO8IFgV6dtxQ/PeEMMA3KgqlbbC1j+Qa3bb
+bP6MvPJwNQzcmRk13NfIRmPVNnGuV/u3gm3c
+-----END CERTIFICATE-----
+
+# Issuer: CN=GTS Root R2 O=Google Trust Services LLC
+# Subject: CN=GTS Root R2 O=Google Trust Services LLC
+# Label: "GTS Root R2"
+# Serial: 159662449406622349769042896298
+# MD5 Fingerprint: 1e:39:c0:53:e6:1e:29:82:0b:ca:52:55:36:5d:57:dc
+# SHA1 Fingerprint: 9a:44:49:76:32:db:de:fa:d0:bc:fb:5a:7b:17:bd:9e:56:09:24:94
+# SHA256 Fingerprint: 8d:25:cd:97:22:9d:bf:70:35:6b:da:4e:b3:cc:73:40:31:e2:4c:f0:0f:af:cf:d3:2d:c7:6e:b5:84:1c:7e:a8
+-----BEGIN CERTIFICATE-----
+MIIFVzCCAz+gAwIBAgINAgPlrsWNBCUaqxElqjANBgkqhkiG9w0BAQwFADBHMQsw
+CQYDVQQGEwJVUzEiMCAGA1UEChMZR29vZ2xlIFRydXN0IFNlcnZpY2VzIExMQzEU
+MBIGA1UEAxMLR1RTIFJvb3QgUjIwHhcNMTYwNjIyMDAwMDAwWhcNMzYwNjIyMDAw
+MDAwWjBHMQswCQYDVQQGEwJVUzEiMCAGA1UEChMZR29vZ2xlIFRydXN0IFNlcnZp
+Y2VzIExMQzEUMBIGA1UEAxMLR1RTIFJvb3QgUjIwggIiMA0GCSqGSIb3DQEBAQUA
+A4ICDwAwggIKAoICAQDO3v2m++zsFDQ8BwZabFn3GTXd98GdVarTzTukk3LvCvpt
+nfbwhYBboUhSnznFt+4orO/LdmgUud+tAWyZH8QiHZ/+cnfgLFuv5AS/T3KgGjSY
+6Dlo7JUle3ah5mm5hRm9iYz+re026nO8/4Piy33B0s5Ks40FnotJk9/BW9BuXvAu
+MC6C/Pq8tBcKSOWIm8Wba96wyrQD8Nr0kLhlZPdcTK3ofmZemde4wj7I0BOdre7k
+RXuJVfeKH2JShBKzwkCX44ofR5GmdFrS+LFjKBC4swm4VndAoiaYecb+3yXuPuWg
+f9RhD1FLPD+M2uFwdNjCaKH5wQzpoeJ/u1U8dgbuak7MkogwTZq9TwtImoS1mKPV
++3PBV2HdKFZ1E66HjucMUQkQdYhMvI35ezzUIkgfKtzra7tEscszcTJGr61K8Yzo
+dDqs5xoic4DSMPclQsciOzsSrZYuxsN2B6ogtzVJV+mSSeh2FnIxZyuWfoqjx5RW
+Ir9qS34BIbIjMt/kmkRtWVtd9QCgHJvGeJeNkP+byKq0rxFROV7Z+2et1VsRnTKa
+G73VululycslaVNVJ1zgyjbLiGH7HrfQy+4W+9OmTN6SpdTi3/UGVN4unUu0kzCq
+gc7dGtxRcw1PcOnlthYhGXmy5okLdWTK1au8CcEYof/UVKGFPP0UJAOyh9OktwID
+AQABo0IwQDAOBgNVHQ8BAf8EBAMCAYYwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4E
+FgQUu//KjiOfT5nK2+JopqUVJxce2Q4wDQYJKoZIhvcNAQEMBQADggIBAB/Kzt3H
+vqGf2SdMC9wXmBFqiN495nFWcrKeGk6c1SuYJF2ba3uwM4IJvd8lRuqYnrYb/oM8
+0mJhwQTtzuDFycgTE1XnqGOtjHsB/ncw4c5omwX4Eu55MaBBRTUoCnGkJE+M3DyC
+B19m3H0Q/gxhswWV7uGugQ+o+MePTagjAiZrHYNSVc61LwDKgEDg4XSsYPWHgJ2u
+NmSRXbBoGOqKYcl3qJfEycel/FVL8/B/uWU9J2jQzGv6U53hkRrJXRqWbTKH7QMg
+yALOWr7Z6v2yTcQvG99fevX4i8buMTolUVVnjWQye+mew4K6Ki3pHrTgSAai/Gev
+HyICc/sgCq+dVEuhzf9gR7A/Xe8bVr2XIZYtCtFenTgCR2y59PYjJbigapordwj6
+xLEokCZYCDzifqrXPW+6MYgKBesntaFJ7qBFVHvmJ2WZICGoo7z7GJa7Um8M7YNR
+TOlZ4iBgxcJlkoKM8xAfDoqXvneCbT+PHV28SSe9zE8P4c52hgQjxcCMElv924Sg
+JPFI/2R80L5cFtHvma3AH/vLrrw4IgYmZNralw4/KBVEqE8AyvCazM90arQ+POuV
+7LXTWtiBmelDGDfrs7vRWGJB82bSj6p4lVQgw1oudCvV0b4YacCs1aTPObpRhANl
+6WLAYv7YTVWW4tAR+kg0Eeye7QUd5MjWHYbL
+-----END CERTIFICATE-----
+
+# Issuer: CN=GTS Root R3 O=Google Trust Services LLC
+# Subject: CN=GTS Root R3 O=Google Trust Services LLC
+# Label: "GTS Root R3"
+# Serial: 159662495401136852707857743206
+# MD5 Fingerprint: 3e:e7:9d:58:02:94:46:51:94:e5:e0:22:4a:8b:e7:73
+# SHA1 Fingerprint: ed:e5:71:80:2b:c8:92:b9:5b:83:3c:d2:32:68:3f:09:cd:a0:1e:46
+# SHA256 Fingerprint: 34:d8:a7:3e:e2:08:d9:bc:db:0d:95:65:20:93:4b:4e:40:e6:94:82:59:6e:8b:6f:73:c8:42:6b:01:0a:6f:48
+-----BEGIN CERTIFICATE-----
+MIICCTCCAY6gAwIBAgINAgPluILrIPglJ209ZjAKBggqhkjOPQQDAzBHMQswCQYD
+VQQGEwJVUzEiMCAGA1UEChMZR29vZ2xlIFRydXN0IFNlcnZpY2VzIExMQzEUMBIG
+A1UEAxMLR1RTIFJvb3QgUjMwHhcNMTYwNjIyMDAwMDAwWhcNMzYwNjIyMDAwMDAw
+WjBHMQswCQYDVQQGEwJVUzEiMCAGA1UEChMZR29vZ2xlIFRydXN0IFNlcnZpY2Vz
+IExMQzEUMBIGA1UEAxMLR1RTIFJvb3QgUjMwdjAQBgcqhkjOPQIBBgUrgQQAIgNi
+AAQfTzOHMymKoYTey8chWEGJ6ladK0uFxh1MJ7x/JlFyb+Kf1qPKzEUURout736G
+jOyxfi//qXGdGIRFBEFVbivqJn+7kAHjSxm65FSWRQmx1WyRRK2EE46ajA2ADDL2
+4CejQjBAMA4GA1UdDwEB/wQEAwIBhjAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW
+BBTB8Sa6oC2uhYHP0/EqEr24Cmf9vDAKBggqhkjOPQQDAwNpADBmAjEA9uEglRR7
+VKOQFhG/hMjqb2sXnh5GmCCbn9MN2azTL818+FsuVbu/3ZL3pAzcMeGiAjEA/Jdm
+ZuVDFhOD3cffL74UOO0BzrEXGhF16b0DjyZ+hOXJYKaV11RZt+cRLInUue4X
+-----END CERTIFICATE-----
+
+# Issuer: CN=GTS Root R4 O=Google Trust Services LLC
+# Subject: CN=GTS Root R4 O=Google Trust Services LLC
+# Label: "GTS Root R4"
+# Serial: 159662532700760215368942768210
+# MD5 Fingerprint: 43:96:83:77:19:4d:76:b3:9d:65:52:e4:1d:22:a5:e8
+# SHA1 Fingerprint: 77:d3:03:67:b5:e0:0c:15:f6:0c:38:61:df:7c:e1:3b:92:46:4d:47
+# SHA256 Fingerprint: 34:9d:fa:40:58:c5:e2:63:12:3b:39:8a:e7:95:57:3c:4e:13:13:c8:3f:e6:8f:93:55:6c:d5:e8:03:1b:3c:7d
+-----BEGIN CERTIFICATE-----
+MIICCTCCAY6gAwIBAgINAgPlwGjvYxqccpBQUjAKBggqhkjOPQQDAzBHMQswCQYD
+VQQGEwJVUzEiMCAGA1UEChMZR29vZ2xlIFRydXN0IFNlcnZpY2VzIExMQzEUMBIG
+A1UEAxMLR1RTIFJvb3QgUjQwHhcNMTYwNjIyMDAwMDAwWhcNMzYwNjIyMDAwMDAw
+WjBHMQswCQYDVQQGEwJVUzEiMCAGA1UEChMZR29vZ2xlIFRydXN0IFNlcnZpY2Vz
+IExMQzEUMBIGA1UEAxMLR1RTIFJvb3QgUjQwdjAQBgcqhkjOPQIBBgUrgQQAIgNi
+AATzdHOnaItgrkO4NcWBMHtLSZ37wWHO5t5GvWvVYRg1rkDdc/eJkTBa6zzuhXyi
+QHY7qca4R9gq55KRanPpsXI5nymfopjTX15YhmUPoYRlBtHci8nHc8iMai/lxKvR
+HYqjQjBAMA4GA1UdDwEB/wQEAwIBhjAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW
+BBSATNbrdP9JNqPV2Py1PsVq8JQdjDAKBggqhkjOPQQDAwNpADBmAjEA6ED/g94D
+9J+uHXqnLrmvT/aDHQ4thQEd0dlq7A/Cr8deVl5c1RxYIigL9zC2L7F8AjEA8GE8
+p/SgguMh1YQdc4acLa/KNJvxn7kjNuK8YAOdgLOaVsjh4rsUecrNIdSUtUlD
+-----END CERTIFICATE-----
+
+# Issuer: CN=Telia Root CA v2 O=Telia Finland Oyj
+# Subject: CN=Telia Root CA v2 O=Telia Finland Oyj
+# Label: "Telia Root CA v2"
+# Serial: 7288924052977061235122729490515358
+# MD5 Fingerprint: 0e:8f:ac:aa:82:df:85:b1:f4:dc:10:1c:fc:99:d9:48
+# SHA1 Fingerprint: b9:99:cd:d1:73:50:8a:c4:47:05:08:9c:8c:88:fb:be:a0:2b:40:cd
+# SHA256 Fingerprint: 24:2b:69:74:2f:cb:1e:5b:2a:bf:98:89:8b:94:57:21:87:54:4e:5b:4d:99:11:78:65:73:62:1f:6a:74:b8:2c
+-----BEGIN CERTIFICATE-----
+MIIFdDCCA1ygAwIBAgIPAWdfJ9b+euPkrL4JWwWeMA0GCSqGSIb3DQEBCwUAMEQx
+CzAJBgNVBAYTAkZJMRowGAYDVQQKDBFUZWxpYSBGaW5sYW5kIE95ajEZMBcGA1UE
+AwwQVGVsaWEgUm9vdCBDQSB2MjAeFw0xODExMjkxMTU1NTRaFw00MzExMjkxMTU1
+NTRaMEQxCzAJBgNVBAYTAkZJMRowGAYDVQQKDBFUZWxpYSBGaW5sYW5kIE95ajEZ
+MBcGA1UEAwwQVGVsaWEgUm9vdCBDQSB2MjCCAiIwDQYJKoZIhvcNAQEBBQADggIP
+ADCCAgoCggIBALLQPwe84nvQa5n44ndp586dpAO8gm2h/oFlH0wnrI4AuhZ76zBq
+AMCzdGh+sq/H1WKzej9Qyow2RCRj0jbpDIX2Q3bVTKFgcmfiKDOlyzG4OiIjNLh9
+vVYiQJ3q9HsDrWj8soFPmNB06o3lfc1jw6P23pLCWBnglrvFxKk9pXSW/q/5iaq9
+lRdU2HhE8Qx3FZLgmEKnpNaqIJLNwaCzlrI6hEKNfdWV5Nbb6WLEWLN5xYzTNTOD
+n3WhUidhOPFZPY5Q4L15POdslv5e2QJltI5c0BE0312/UqeBAMN/mUWZFdUXyApT
+7GPzmX3MaRKGwhfwAZ6/hLzRUssbkmbOpFPlob/E2wnW5olWK8jjfN7j/4nlNW4o
+6GwLI1GpJQXrSPjdscr6bAhR77cYbETKJuFzxokGgeWKrLDiKca5JLNrRBH0pUPC
+TEPlcDaMtjNXepUugqD0XBCzYYP2AgWGLnwtbNwDRm41k9V6lS/eINhbfpSQBGq6
+WT0EBXWdN6IOLj3rwaRSg/7Qa9RmjtzG6RJOHSpXqhC8fF6CfaamyfItufUXJ63R
+DolUK5X6wK0dmBR4M0KGCqlztft0DbcbMBnEWg4cJ7faGND/isgFuvGqHKI3t+ZI
+pEYslOqodmJHixBTB0hXbOKSTbauBcvcwUpej6w9GU7C7WB1K9vBykLVAgMBAAGj
+YzBhMB8GA1UdIwQYMBaAFHKs5DN5qkWH9v2sHZ7Wxy+G2CQ5MB0GA1UdDgQWBBRy
+rOQzeapFh/b9rB2e1scvhtgkOTAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/BAUw
+AwEB/zANBgkqhkiG9w0BAQsFAAOCAgEAoDtZpwmUPjaE0n4vOaWWl/oRrfxn83EJ
+8rKJhGdEr7nv7ZbsnGTbMjBvZ5qsfl+yqwE2foH65IRe0qw24GtixX1LDoJt0nZi
+0f6X+J8wfBj5tFJ3gh1229MdqfDBmgC9bXXYfef6xzijnHDoRnkDry5023X4blMM
+A8iZGok1GTzTyVR8qPAs5m4HeW9q4ebqkYJpCh3DflminmtGFZhb069GHWLIzoBS
+SRE/yQQSwxN8PzuKlts8oB4KtItUsiRnDe+Cy748fdHif64W1lZYudogsYMVoe+K
+TTJvQS8TUoKU1xrBeKJR3Stwbbca+few4GeXVtt8YVMJAygCQMez2P2ccGrGKMOF
+6eLtGpOg3kuYooQ+BXcBlj37tCAPnHICehIv1aO6UXivKitEZU61/Qrowc15h2Er
+3oBXRb9n8ZuRXqWk7FlIEA04x7D6w0RtBPV4UBySllva9bguulvP5fBqnUsvWHMt
+Ty3EHD70sz+rFQ47GUGKpMFXEmZxTPpT41frYpUJnlTd0cI8Vzy9OK2YZLe4A5pT
+VmBds9hCG1xLEooc6+t9xnppxyd/pPiL8uSUZodL6ZQHCRJ5irLrdATczvREWeAW
+ysUsWNc8e89ihmpQfTU2Zqf7N+cox9jQraVplI/owd8k+BsHMYeB2F326CjYSlKA
+rBPuUBQemMc=
+-----END CERTIFICATE-----
+
+# Issuer: CN=D-TRUST BR Root CA 1 2020 O=D-Trust GmbH
+# Subject: CN=D-TRUST BR Root CA 1 2020 O=D-Trust GmbH
+# Label: "D-TRUST BR Root CA 1 2020"
+# Serial: 165870826978392376648679885835942448534
+# MD5 Fingerprint: b5:aa:4b:d5:ed:f7:e3:55:2e:8f:72:0a:f3:75:b8:ed
+# SHA1 Fingerprint: 1f:5b:98:f0:e3:b5:f7:74:3c:ed:e6:b0:36:7d:32:cd:f4:09:41:67
+# SHA256 Fingerprint: e5:9a:aa:81:60:09:c2:2b:ff:5b:25:ba:d3:7d:f3:06:f0:49:79:7c:1f:81:d8:5a:b0:89:e6:57:bd:8f:00:44
+-----BEGIN CERTIFICATE-----
+MIIC2zCCAmCgAwIBAgIQfMmPK4TX3+oPyWWa00tNljAKBggqhkjOPQQDAzBIMQsw
+CQYDVQQGEwJERTEVMBMGA1UEChMMRC1UcnVzdCBHbWJIMSIwIAYDVQQDExlELVRS
+VVNUIEJSIFJvb3QgQ0EgMSAyMDIwMB4XDTIwMDIxMTA5NDUwMFoXDTM1MDIxMTA5
+NDQ1OVowSDELMAkGA1UEBhMCREUxFTATBgNVBAoTDEQtVHJ1c3QgR21iSDEiMCAG
+A1UEAxMZRC1UUlVTVCBCUiBSb290IENBIDEgMjAyMDB2MBAGByqGSM49AgEGBSuB
+BAAiA2IABMbLxyjR+4T1mu9CFCDhQ2tuda38KwOE1HaTJddZO0Flax7mNCq7dPYS
+zuht56vkPE4/RAiLzRZxy7+SmfSk1zxQVFKQhYN4lGdnoxwJGT11NIXe7WB9xwy0
+QVK5buXuQqOCAQ0wggEJMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFHOREKv/
+VbNafAkl1bK6CKBrqx9tMA4GA1UdDwEB/wQEAwIBBjCBxgYDVR0fBIG+MIG7MD6g
+PKA6hjhodHRwOi8vY3JsLmQtdHJ1c3QubmV0L2NybC9kLXRydXN0X2JyX3Jvb3Rf
+Y2FfMV8yMDIwLmNybDB5oHegdYZzbGRhcDovL2RpcmVjdG9yeS5kLXRydXN0Lm5l
+dC9DTj1ELVRSVVNUJTIwQlIlMjBSb290JTIwQ0ElMjAxJTIwMjAyMCxPPUQtVHJ1
+c3QlMjBHbWJILEM9REU/Y2VydGlmaWNhdGVyZXZvY2F0aW9ubGlzdDAKBggqhkjO
+PQQDAwNpADBmAjEAlJAtE/rhY/hhY+ithXhUkZy4kzg+GkHaQBZTQgjKL47xPoFW
+wKrY7RjEsK70PvomAjEA8yjixtsrmfu3Ubgko6SUeho/5jbiA1czijDLgsfWFBHV
+dWNbFJWcHwHP2NVypw87
+-----END CERTIFICATE-----
+
+# Issuer: CN=D-TRUST EV Root CA 1 2020 O=D-Trust GmbH
+# Subject: CN=D-TRUST EV Root CA 1 2020 O=D-Trust GmbH
+# Label: "D-TRUST EV Root CA 1 2020"
+# Serial: 126288379621884218666039612629459926992
+# MD5 Fingerprint: 8c:2d:9d:70:9f:48:99:11:06:11:fb:e9:cb:30:c0:6e
+# SHA1 Fingerprint: 61:db:8c:21:59:69:03:90:d8:7c:9c:12:86:54:cf:9d:3d:f4:dd:07
+# SHA256 Fingerprint: 08:17:0d:1a:a3:64:53:90:1a:2f:95:92:45:e3:47:db:0c:8d:37:ab:aa:bc:56:b8:1a:a1:00:dc:95:89:70:db
+-----BEGIN CERTIFICATE-----
+MIIC2zCCAmCgAwIBAgIQXwJB13qHfEwDo6yWjfv/0DAKBggqhkjOPQQDAzBIMQsw
+CQYDVQQGEwJERTEVMBMGA1UEChMMRC1UcnVzdCBHbWJIMSIwIAYDVQQDExlELVRS
+VVNUIEVWIFJvb3QgQ0EgMSAyMDIwMB4XDTIwMDIxMTEwMDAwMFoXDTM1MDIxMTA5
+NTk1OVowSDELMAkGA1UEBhMCREUxFTATBgNVBAoTDEQtVHJ1c3QgR21iSDEiMCAG
+A1UEAxMZRC1UUlVTVCBFViBSb290IENBIDEgMjAyMDB2MBAGByqGSM49AgEGBSuB
+BAAiA2IABPEL3YZDIBnfl4XoIkqbz52Yv7QFJsnL46bSj8WeeHsxiamJrSc8ZRCC
+/N/DnU7wMyPE0jL1HLDfMxddxfCxivnvubcUyilKwg+pf3VlSSowZ/Rk99Yad9rD
+wpdhQntJraOCAQ0wggEJMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFH8QARY3
+OqQo5FD4pPfsazK2/umLMA4GA1UdDwEB/wQEAwIBBjCBxgYDVR0fBIG+MIG7MD6g
+PKA6hjhodHRwOi8vY3JsLmQtdHJ1c3QubmV0L2NybC9kLXRydXN0X2V2X3Jvb3Rf
+Y2FfMV8yMDIwLmNybDB5oHegdYZzbGRhcDovL2RpcmVjdG9yeS5kLXRydXN0Lm5l
+dC9DTj1ELVRSVVNUJTIwRVYlMjBSb290JTIwQ0ElMjAxJTIwMjAyMCxPPUQtVHJ1
+c3QlMjBHbWJILEM9REU/Y2VydGlmaWNhdGVyZXZvY2F0aW9ubGlzdDAKBggqhkjO
+PQQDAwNpADBmAjEAyjzGKnXCXnViOTYAYFqLwZOZzNnbQTs7h5kXO9XMT8oi96CA
+y/m0sRtW9XLS/BnRAjEAkfcwkz8QRitxpNA7RJvAKQIFskF3UfN5Wp6OFKBOQtJb
+gfM0agPnIjhQW+0ZT0MW
+-----END CERTIFICATE-----
+
+# Issuer: CN=DigiCert TLS ECC P384 Root G5 O=DigiCert, Inc.
+# Subject: CN=DigiCert TLS ECC P384 Root G5 O=DigiCert, Inc.
+# Label: "DigiCert TLS ECC P384 Root G5"
+# Serial: 13129116028163249804115411775095713523
+# MD5 Fingerprint: d3:71:04:6a:43:1c:db:a6:59:e1:a8:a3:aa:c5:71:ed
+# SHA1 Fingerprint: 17:f3:de:5e:9f:0f:19:e9:8e:f6:1f:32:26:6e:20:c4:07:ae:30:ee
+# SHA256 Fingerprint: 01:8e:13:f0:77:25:32:cf:80:9b:d1:b1:72:81:86:72:83:fc:48:c6:e1:3b:e9:c6:98:12:85:4a:49:0c:1b:05
+-----BEGIN CERTIFICATE-----
+MIICGTCCAZ+gAwIBAgIQCeCTZaz32ci5PhwLBCou8zAKBggqhkjOPQQDAzBOMQsw
+CQYDVQQGEwJVUzEXMBUGA1UEChMORGlnaUNlcnQsIEluYy4xJjAkBgNVBAMTHURp
+Z2lDZXJ0IFRMUyBFQ0MgUDM4NCBSb290IEc1MB4XDTIxMDExNTAwMDAwMFoXDTQ2
+MDExNDIzNTk1OVowTjELMAkGA1UEBhMCVVMxFzAVBgNVBAoTDkRpZ2lDZXJ0LCBJ
+bmMuMSYwJAYDVQQDEx1EaWdpQ2VydCBUTFMgRUNDIFAzODQgUm9vdCBHNTB2MBAG
+ByqGSM49AgEGBSuBBAAiA2IABMFEoc8Rl1Ca3iOCNQfN0MsYndLxf3c1TzvdlHJS
+7cI7+Oz6e2tYIOyZrsn8aLN1udsJ7MgT9U7GCh1mMEy7H0cKPGEQQil8pQgO4CLp
+0zVozptjn4S1mU1YoI71VOeVyaNCMEAwHQYDVR0OBBYEFMFRRVBZqz7nLFr6ICIS
+B4CIfBFqMA4GA1UdDwEB/wQEAwIBhjAPBgNVHRMBAf8EBTADAQH/MAoGCCqGSM49
+BAMDA2gAMGUCMQCJao1H5+z8blUD2WdsJk6Dxv3J+ysTvLd6jLRl0mlpYxNjOyZQ
+LgGheQaRnUi/wr4CMEfDFXuxoJGZSZOoPHzoRgaLLPIxAJSdYsiJvRmEFOml+wG4
+DXZDjC5Ty3zfDBeWUA==
+-----END CERTIFICATE-----
+
+# Issuer: CN=DigiCert TLS RSA4096 Root G5 O=DigiCert, Inc.
+# Subject: CN=DigiCert TLS RSA4096 Root G5 O=DigiCert, Inc.
+# Label: "DigiCert TLS RSA4096 Root G5"
+# Serial: 11930366277458970227240571539258396554
+# MD5 Fingerprint: ac:fe:f7:34:96:a9:f2:b3:b4:12:4b:e4:27:41:6f:e1
+# SHA1 Fingerprint: a7:88:49:dc:5d:7c:75:8c:8c:de:39:98:56:b3:aa:d0:b2:a5:71:35
+# SHA256 Fingerprint: 37:1a:00:dc:05:33:b3:72:1a:7e:eb:40:e8:41:9e:70:79:9d:2b:0a:0f:2c:1d:80:69:31:65:f7:ce:c4:ad:75
+-----BEGIN CERTIFICATE-----
+MIIFZjCCA06gAwIBAgIQCPm0eKj6ftpqMzeJ3nzPijANBgkqhkiG9w0BAQwFADBN
+MQswCQYDVQQGEwJVUzEXMBUGA1UEChMORGlnaUNlcnQsIEluYy4xJTAjBgNVBAMT
+HERpZ2lDZXJ0IFRMUyBSU0E0MDk2IFJvb3QgRzUwHhcNMjEwMTE1MDAwMDAwWhcN
+NDYwMTE0MjM1OTU5WjBNMQswCQYDVQQGEwJVUzEXMBUGA1UEChMORGlnaUNlcnQs
+IEluYy4xJTAjBgNVBAMTHERpZ2lDZXJ0IFRMUyBSU0E0MDk2IFJvb3QgRzUwggIi
+MA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQCz0PTJeRGd/fxmgefM1eS87IE+
+ajWOLrfn3q/5B03PMJ3qCQuZvWxX2hhKuHisOjmopkisLnLlvevxGs3npAOpPxG0
+2C+JFvuUAT27L/gTBaF4HI4o4EXgg/RZG5Wzrn4DReW+wkL+7vI8toUTmDKdFqgp
+wgscONyfMXdcvyej/Cestyu9dJsXLfKB2l2w4SMXPohKEiPQ6s+d3gMXsUJKoBZM
+pG2T6T867jp8nVid9E6P/DsjyG244gXazOvswzH016cpVIDPRFtMbzCe88zdH5RD
+nU1/cHAN1DrRN/BsnZvAFJNY781BOHW8EwOVfH/jXOnVDdXifBBiqmvwPXbzP6Po
+sMH976pXTayGpxi0KcEsDr9kvimM2AItzVwv8n/vFfQMFawKsPHTDU9qTXeXAaDx
+Zre3zu/O7Oyldcqs4+Fj97ihBMi8ez9dLRYiVu1ISf6nL3kwJZu6ay0/nTvEF+cd
+Lvvyz6b84xQslpghjLSR6Rlgg/IwKwZzUNWYOwbpx4oMYIwo+FKbbuH2TbsGJJvX
+KyY//SovcfXWJL5/MZ4PbeiPT02jP/816t9JXkGPhvnxd3lLG7SjXi/7RgLQZhNe
+XoVPzthwiHvOAbWWl9fNff2C+MIkwcoBOU+NosEUQB+cZtUMCUbW8tDRSHZWOkPL
+tgoRObqME2wGtZ7P6wIDAQABo0IwQDAdBgNVHQ4EFgQUUTMc7TZArxfTJc1paPKv
+TiM+s0EwDgYDVR0PAQH/BAQDAgGGMA8GA1UdEwEB/wQFMAMBAf8wDQYJKoZIhvcN
+AQEMBQADggIBAGCmr1tfV9qJ20tQqcQjNSH/0GEwhJG3PxDPJY7Jv0Y02cEhJhxw
+GXIeo8mH/qlDZJY6yFMECrZBu8RHANmfGBg7sg7zNOok992vIGCukihfNudd5N7H
+PNtQOa27PShNlnx2xlv0wdsUpasZYgcYQF+Xkdycx6u1UQ3maVNVzDl92sURVXLF
+O4uJ+DQtpBflF+aZfTCIITfNMBc9uPK8qHWgQ9w+iUuQrm0D4ByjoJYJu32jtyoQ
+REtGBzRj7TG5BO6jm5qu5jF49OokYTurWGT/u4cnYiWB39yhL/btp/96j1EuMPik
+AdKFOV8BmZZvWltwGUb+hmA+rYAQCd05JS9Yf7vSdPD3Rh9GOUrYU9DzLjtxpdRv
+/PNn5AeP3SYZ4Y1b+qOTEZvpyDrDVWiakuFSdjjo4bq9+0/V77PnSIMx8IIh47a+
+p6tv75/fTM8BuGJqIz3nCU2AG3swpMPdB380vqQmsvZB6Akd4yCYqjdP//fx4ilw
+MUc/dNAUFvohigLVigmUdy7yWSiLfFCSCmZ4OIN1xLVaqBHG5cGdZlXPU8Sv13WF
+qUITVuwhd4GTWgzqltlJyqEI8pc7bZsEGCREjnwB8twl2F6GmrE52/WRMmrRpnCK
+ovfepEWFJqgejF0pW8hL2JpqA15w8oVPbEtoL8pU9ozaMv7Da4M/OMZ+
+-----END CERTIFICATE-----
+
+# Issuer: CN=Certainly Root R1 O=Certainly
+# Subject: CN=Certainly Root R1 O=Certainly
+# Label: "Certainly Root R1"
+# Serial: 188833316161142517227353805653483829216
+# MD5 Fingerprint: 07:70:d4:3e:82:87:a0:fa:33:36:13:f4:fa:33:e7:12
+# SHA1 Fingerprint: a0:50:ee:0f:28:71:f4:27:b2:12:6d:6f:50:96:25:ba:cc:86:42:af
+# SHA256 Fingerprint: 77:b8:2c:d8:64:4c:43:05:f7:ac:c5:cb:15:6b:45:67:50:04:03:3d:51:c6:0c:62:02:a8:e0:c3:34:67:d3:a0
+-----BEGIN CERTIFICATE-----
+MIIFRzCCAy+gAwIBAgIRAI4P+UuQcWhlM1T01EQ5t+AwDQYJKoZIhvcNAQELBQAw
+PTELMAkGA1UEBhMCVVMxEjAQBgNVBAoTCUNlcnRhaW5seTEaMBgGA1UEAxMRQ2Vy
+dGFpbmx5IFJvb3QgUjEwHhcNMjEwNDAxMDAwMDAwWhcNNDYwNDAxMDAwMDAwWjA9
+MQswCQYDVQQGEwJVUzESMBAGA1UEChMJQ2VydGFpbmx5MRowGAYDVQQDExFDZXJ0
+YWlubHkgUm9vdCBSMTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBANA2
+1B/q3avk0bbm+yLA3RMNansiExyXPGhjZjKcA7WNpIGD2ngwEc/csiu+kr+O5MQT
+vqRoTNoCaBZ0vrLdBORrKt03H2As2/X3oXyVtwxwhi7xOu9S98zTm/mLvg7fMbed
+aFySpvXl8wo0tf97ouSHocavFwDvA5HtqRxOcT3Si2yJ9HiG5mpJoM610rCrm/b0
+1C7jcvk2xusVtyWMOvwlDbMicyF0yEqWYZL1LwsYpfSt4u5BvQF5+paMjRcCMLT5
+r3gajLQ2EBAHBXDQ9DGQilHFhiZ5shGIXsXwClTNSaa/ApzSRKft43jvRl5tcdF5
+cBxGX1HpyTfcX35pe0HfNEXgO4T0oYoKNp43zGJS4YkNKPl6I7ENPT2a/Z2B7yyQ
+wHtETrtJ4A5KVpK8y7XdeReJkd5hiXSSqOMyhb5OhaRLWcsrxXiOcVTQAjeZjOVJ
+6uBUcqQRBi8LjMFbvrWhsFNunLhgkR9Za/kt9JQKl7XsxXYDVBtlUrpMklZRNaBA
+2CnbrlJ2Oy0wQJuK0EJWtLeIAaSHO1OWzaMWj/Nmqhexx2DgwUMFDO6bW2BvBlyH
+Wyf5QBGenDPBt+U1VwV/J84XIIwc/PH72jEpSe31C4SnT8H2TsIonPru4K8H+zMR
+eiFPCyEQtkA6qyI6BJyLm4SGcprSp6XEtHWRqSsjAgMBAAGjQjBAMA4GA1UdDwEB
+/wQEAwIBBjAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQWBBTgqj8ljZ9EXME66C6u
+d0yEPmcM9DANBgkqhkiG9w0BAQsFAAOCAgEAuVevuBLaV4OPaAszHQNTVfSVcOQr
+PbA56/qJYv331hgELyE03fFo8NWWWt7CgKPBjcZq91l3rhVkz1t5BXdm6ozTaw3d
+8VkswTOlMIAVRQdFGjEitpIAq5lNOo93r6kiyi9jyhXWx8bwPWz8HA2YEGGeEaIi
+1wrykXprOQ4vMMM2SZ/g6Q8CRFA3lFV96p/2O7qUpUzpvD5RtOjKkjZUbVwlKNrd
+rRT90+7iIgXr0PK3aBLXWopBGsaSpVo7Y0VPv+E6dyIvXL9G+VoDhRNCX8reU9di
+taY1BMJH/5n9hN9czulegChB8n3nHpDYT3Y+gjwN/KUD+nsa2UUeYNrEjvn8K8l7
+lcUq/6qJ34IxD3L/DCfXCh5WAFAeDJDBlrXYFIW7pw0WwfgHJBu6haEaBQmAupVj
+yTrsJZ9/nbqkRxWbRHDxakvWOF5D8xh+UG7pWijmZeZ3Gzr9Hb4DJqPb1OG7fpYn
+Kx3upPvaJVQTA945xsMfTZDsjxtK0hzthZU4UHlG1sGQUDGpXJpuHfUzVounmdLy
+yCwzk5Iwx06MZTMQZBf9JBeW0Y3COmor6xOLRPIh80oat3df1+2IpHLlOR+Vnb5n
+wXARPbv0+Em34yaXOp/SX3z7wJl8OSngex2/DaeP0ik0biQVy96QXr8axGbqwua6
+OV+KmalBWQewLK8=
+-----END CERTIFICATE-----
+
+# Issuer: CN=Certainly Root E1 O=Certainly
+# Subject: CN=Certainly Root E1 O=Certainly
+# Label: "Certainly Root E1"
+# Serial: 8168531406727139161245376702891150584
+# MD5 Fingerprint: 0a:9e:ca:cd:3e:52:50:c6:36:f3:4b:a3:ed:a7:53:e9
+# SHA1 Fingerprint: f9:e1:6d:dc:01:89:cf:d5:82:45:63:3e:c5:37:7d:c2:eb:93:6f:2b
+# SHA256 Fingerprint: b4:58:5f:22:e4:ac:75:6a:4e:86:12:a1:36:1c:5d:9d:03:1a:93:fd:84:fe:bb:77:8f:a3:06:8b:0f:c4:2d:c2
+-----BEGIN CERTIFICATE-----
+MIIB9zCCAX2gAwIBAgIQBiUzsUcDMydc+Y2aub/M+DAKBggqhkjOPQQDAzA9MQsw
+CQYDVQQGEwJVUzESMBAGA1UEChMJQ2VydGFpbmx5MRowGAYDVQQDExFDZXJ0YWlu
+bHkgUm9vdCBFMTAeFw0yMTA0MDEwMDAwMDBaFw00NjA0MDEwMDAwMDBaMD0xCzAJ
+BgNVBAYTAlVTMRIwEAYDVQQKEwlDZXJ0YWlubHkxGjAYBgNVBAMTEUNlcnRhaW5s
+eSBSb290IEUxMHYwEAYHKoZIzj0CAQYFK4EEACIDYgAE3m/4fxzf7flHh4axpMCK
++IKXgOqPyEpeKn2IaKcBYhSRJHpcnqMXfYqGITQYUBsQ3tA3SybHGWCA6TS9YBk2
+QNYphwk8kXr2vBMj3VlOBF7PyAIcGFPBMdjaIOlEjeR2o0IwQDAOBgNVHQ8BAf8E
+BAMCAQYwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU8ygYy2R17ikq6+2uI1g4
+hevIIgcwCgYIKoZIzj0EAwMDaAAwZQIxALGOWiDDshliTd6wT99u0nCK8Z9+aozm
+ut6Dacpps6kFtZaSF4fC0urQe87YQVt8rgIwRt7qy12a7DLCZRawTDBcMPPaTnOG
+BtjOiQRINzf43TNRnXCve1XYAS59BWQOhriR
+-----END CERTIFICATE-----
+
+# Issuer: CN=Security Communication RootCA3 O=SECOM Trust Systems CO.,LTD.
+# Subject: CN=Security Communication RootCA3 O=SECOM Trust Systems CO.,LTD.
+# Label: "Security Communication RootCA3"
+# Serial: 16247922307909811815
+# MD5 Fingerprint: 1c:9a:16:ff:9e:5c:e0:4d:8a:14:01:f4:35:5d:29:26
+# SHA1 Fingerprint: c3:03:c8:22:74:92:e5:61:a2:9c:5f:79:91:2b:1e:44:13:91:30:3a
+# SHA256 Fingerprint: 24:a5:5c:2a:b0:51:44:2d:06:17:76:65:41:23:9a:4a:d0:32:d7:c5:51:75:aa:34:ff:de:2f:bc:4f:5c:52:94
+-----BEGIN CERTIFICATE-----
+MIIFfzCCA2egAwIBAgIJAOF8N0D9G/5nMA0GCSqGSIb3DQEBDAUAMF0xCzAJBgNV
+BAYTAkpQMSUwIwYDVQQKExxTRUNPTSBUcnVzdCBTeXN0ZW1zIENPLixMVEQuMScw
+JQYDVQQDEx5TZWN1cml0eSBDb21tdW5pY2F0aW9uIFJvb3RDQTMwHhcNMTYwNjE2
+MDYxNzE2WhcNMzgwMTE4MDYxNzE2WjBdMQswCQYDVQQGEwJKUDElMCMGA1UEChMc
+U0VDT00gVHJ1c3QgU3lzdGVtcyBDTy4sTFRELjEnMCUGA1UEAxMeU2VjdXJpdHkg
+Q29tbXVuaWNhdGlvbiBSb290Q0EzMIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIIC
+CgKCAgEA48lySfcw3gl8qUCBWNO0Ot26YQ+TUG5pPDXC7ltzkBtnTCHsXzW7OT4r
+CmDvu20rhvtxosis5FaU+cmvsXLUIKx00rgVrVH+hXShuRD+BYD5UpOzQD11EKzA
+lrenfna84xtSGc4RHwsENPXY9Wk8d/Nk9A2qhd7gCVAEF5aEt8iKvE1y/By7z/MG
+TfmfZPd+pmaGNXHIEYBMwXFAWB6+oHP2/D5Q4eAvJj1+XCO1eXDe+uDRpdYMQXF7
+9+qMHIjH7Iv10S9VlkZ8WjtYO/u62C21Jdp6Ts9EriGmnpjKIG58u4iFW/vAEGK7
+8vknR+/RiTlDxN/e4UG/VHMgly1s2vPUB6PmudhvrvyMGS7TZ2crldtYXLVqAvO4
+g160a75BflcJdURQVc1aEWEhCmHCqYj9E7wtiS/NYeCVvsq1e+F7NGcLH7YMx3we
+GVPKp7FKFSBWFHA9K4IsD50VHUeAR/94mQ4xr28+j+2GaR57GIgUssL8gjMunEst
++3A7caoreyYn8xrC3PsXuKHqy6C0rtOUfnrQq8PsOC0RLoi/1D+tEjtCrI8Cbn3M
+0V9hvqG8OmpI6iZVIhZdXw3/JzOfGAN0iltSIEdrRU0id4xVJ/CvHozJgyJUt5rQ
+T9nO/NkuHJYosQLTA70lUhw0Zk8jq/R3gpYd0VcwCBEF/VfR2ccCAwEAAaNCMEAw
+HQYDVR0OBBYEFGQUfPxYchamCik0FW8qy7z8r6irMA4GA1UdDwEB/wQEAwIBBjAP
+BgNVHRMBAf8EBTADAQH/MA0GCSqGSIb3DQEBDAUAA4ICAQDcAiMI4u8hOscNtybS
+YpOnpSNyByCCYN8Y11StaSWSntkUz5m5UoHPrmyKO1o5yGwBQ8IibQLwYs1OY0PA
+FNr0Y/Dq9HHuTofjcan0yVflLl8cebsjqodEV+m9NU1Bu0soo5iyG9kLFwfl9+qd
+9XbXv8S2gVj/yP9kaWJ5rW4OH3/uHWnlt3Jxs/6lATWUVCvAUm2PVcTJ0rjLyjQI
+UYWg9by0F1jqClx6vWPGOi//lkkZhOpn2ASxYfQAW0q3nHE3GYV5v4GwxxMOdnE+
+OoAGrgYWp421wsTL/0ClXI2lyTrtcoHKXJg80jQDdwj98ClZXSEIx2C/pHF7uNke
+gr4Jr2VvKKu/S7XuPghHJ6APbw+LP6yVGPO5DtxnVW5inkYO0QR4ynKudtml+LLf
+iAlhi+8kTtFZP1rUPcmTPCtk9YENFpb3ksP+MW/oKjJ0DvRMmEoYDjBU1cXrvMUV
+nuiZIesnKwkK2/HmcBhWuwzkvvnoEKQTkrgc4NtnHVMDpCKn3F2SEDzq//wbEBrD
+2NCcnWXL0CsnMQMeNuE9dnUM/0Umud1RvCPHX9jYhxBAEg09ODfnRDwYwFMJZI//
+1ZqmfHAuc1Uh6N//g7kdPjIe1qZ9LPFm6Vwdp6POXiUyK+OVrCoHzrQoeIY8Laad
+TdJ0MN1kURXbg4NR16/9M51NZg==
+-----END CERTIFICATE-----
+
+# Issuer: CN=Security Communication ECC RootCA1 O=SECOM Trust Systems CO.,LTD.
+# Subject: CN=Security Communication ECC RootCA1 O=SECOM Trust Systems CO.,LTD.
+# Label: "Security Communication ECC RootCA1"
+# Serial: 15446673492073852651
+# MD5 Fingerprint: 7e:43:b0:92:68:ec:05:43:4c:98:ab:5d:35:2e:7e:86
+# SHA1 Fingerprint: b8:0e:26:a9:bf:d2:b2:3b:c0:ef:46:c9:ba:c7:bb:f6:1d:0d:41:41
+# SHA256 Fingerprint: e7:4f:bd:a5:5b:d5:64:c4:73:a3:6b:44:1a:a7:99:c8:a6:8e:07:74:40:e8:28:8b:9f:a1:e5:0e:4b:ba:ca:11
+-----BEGIN CERTIFICATE-----
+MIICODCCAb6gAwIBAgIJANZdm7N4gS7rMAoGCCqGSM49BAMDMGExCzAJBgNVBAYT
+AkpQMSUwIwYDVQQKExxTRUNPTSBUcnVzdCBTeXN0ZW1zIENPLixMVEQuMSswKQYD
+VQQDEyJTZWN1cml0eSBDb21tdW5pY2F0aW9uIEVDQyBSb290Q0ExMB4XDTE2MDYx
+NjA1MTUyOFoXDTM4MDExODA1MTUyOFowYTELMAkGA1UEBhMCSlAxJTAjBgNVBAoT
+HFNFQ09NIFRydXN0IFN5c3RlbXMgQ08uLExURC4xKzApBgNVBAMTIlNlY3VyaXR5
+IENvbW11bmljYXRpb24gRUNDIFJvb3RDQTEwdjAQBgcqhkjOPQIBBgUrgQQAIgNi
+AASkpW9gAwPDvTH00xecK4R1rOX9PVdu12O/5gSJko6BnOPpR27KkBLIE+Cnnfdl
+dB9sELLo5OnvbYUymUSxXv3MdhDYW72ixvnWQuRXdtyQwjWpS4g8EkdtXP9JTxpK
+ULGjQjBAMB0GA1UdDgQWBBSGHOf+LaVKiwj+KBH6vqNm+GBZLzAOBgNVHQ8BAf8E
+BAMCAQYwDwYDVR0TAQH/BAUwAwEB/zAKBggqhkjOPQQDAwNoADBlAjAVXUI9/Lbu
+9zuxNuie9sRGKEkz0FhDKmMpzE2xtHqiuQ04pV1IKv3LsnNdo4gIxwwCMQDAqy0O
+be0YottT6SXbVQjgUMzfRGEWgqtJsLKB7HOHeLRMsmIbEvoWTSVLY70eN9k=
+-----END CERTIFICATE-----
+
+# Issuer: CN=BJCA Global Root CA1 O=BEIJING CERTIFICATE AUTHORITY
+# Subject: CN=BJCA Global Root CA1 O=BEIJING CERTIFICATE AUTHORITY
+# Label: "BJCA Global Root CA1"
+# Serial: 113562791157148395269083148143378328608
+# MD5 Fingerprint: 42:32:99:76:43:33:36:24:35:07:82:9b:28:f9:d0:90
+# SHA1 Fingerprint: d5:ec:8d:7b:4c:ba:79:f4:e7:e8:cb:9d:6b:ae:77:83:10:03:21:6a
+# SHA256 Fingerprint: f3:89:6f:88:fe:7c:0a:88:27:66:a7:fa:6a:d2:74:9f:b5:7a:7f:3e:98:fb:76:9c:1f:a7:b0:9c:2c:44:d5:ae
+-----BEGIN CERTIFICATE-----
+MIIFdDCCA1ygAwIBAgIQVW9l47TZkGobCdFsPsBsIDANBgkqhkiG9w0BAQsFADBU
+MQswCQYDVQQGEwJDTjEmMCQGA1UECgwdQkVJSklORyBDRVJUSUZJQ0FURSBBVVRI
+T1JJVFkxHTAbBgNVBAMMFEJKQ0EgR2xvYmFsIFJvb3QgQ0ExMB4XDTE5MTIxOTAz
+MTYxN1oXDTQ0MTIxMjAzMTYxN1owVDELMAkGA1UEBhMCQ04xJjAkBgNVBAoMHUJF
+SUpJTkcgQ0VSVElGSUNBVEUgQVVUSE9SSVRZMR0wGwYDVQQDDBRCSkNBIEdsb2Jh
+bCBSb290IENBMTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAPFmCL3Z
+xRVhy4QEQaVpN3cdwbB7+sN3SJATcmTRuHyQNZ0YeYjjlwE8R4HyDqKYDZ4/N+AZ
+spDyRhySsTphzvq3Rp4Dhtczbu33RYx2N95ulpH3134rhxfVizXuhJFyV9xgw8O5
+58dnJCNPYwpj9mZ9S1WnP3hkSWkSl+BMDdMJoDIwOvqfwPKcxRIqLhy1BDPapDgR
+at7GGPZHOiJBhyL8xIkoVNiMpTAK+BcWyqw3/XmnkRd4OJmtWO2y3syJfQOcs4ll
+5+M7sSKGjwZteAf9kRJ/sGsciQ35uMt0WwfCyPQ10WRjeulumijWML3mG90Vr4Tq
+nMfK9Q7q8l0ph49pczm+LiRvRSGsxdRpJQaDrXpIhRMsDQa4bHlW/KNnMoH1V6XK
+V0Jp6VwkYe/iMBhORJhVb3rCk9gZtt58R4oRTklH2yiUAguUSiz5EtBP6DF+bHq/
+pj+bOT0CFqMYs2esWz8sgytnOYFcuX6U1WTdno9uruh8W7TXakdI136z1C2OVnZO
+z2nxbkRs1CTqjSShGL+9V/6pmTW12xB3uD1IutbB5/EjPtffhZ0nPNRAvQoMvfXn
+jSXWgXSHRtQpdaJCbPdzied9v3pKH9MiyRVVz99vfFXQpIsHETdfg6YmV6YBW37+
+WGgHqel62bno/1Afq8K0wM7o6v0PvY1NuLxxAgMBAAGjQjBAMB0GA1UdDgQWBBTF
+7+3M2I0hxkjk49cULqcWk+WYATAPBgNVHRMBAf8EBTADAQH/MA4GA1UdDwEB/wQE
+AwIBBjANBgkqhkiG9w0BAQsFAAOCAgEAUoKsITQfI/Ki2Pm4rzc2IInRNwPWaZ+4
+YRC6ojGYWUfo0Q0lHhVBDOAqVdVXUsv45Mdpox1NcQJeXyFFYEhcCY5JEMEE3Kli
+awLwQ8hOnThJdMkycFRtwUf8jrQ2ntScvd0g1lPJGKm1Vrl2i5VnZu69mP6u775u
++2D2/VnGKhs/I0qUJDAnyIm860Qkmss9vk/Ves6OF8tiwdneHg56/0OGNFK8YT88
+X7vZdrRTvJez/opMEi4r89fO4aL/3Xtw+zuhTaRjAv04l5U/BXCga99igUOLtFkN
+SoxUnMW7gZ/NfaXvCyUeOiDbHPwfmGcCCtRzRBPbUYQaVQNW4AB+dAb/OMRyHdOo
+P2gxXdMJxy6MW2Pg6Nwe0uxhHvLe5e/2mXZgLR6UcnHGCyoyx5JO1UbXHfmpGQrI
++pXObSOYqgs4rZpWDW+N8TEAiMEXnM0ZNjX+VVOg4DwzX5Ze4jLp3zO7Bkqp2IRz
+znfSxqxx4VyjHQy7Ct9f4qNx2No3WqB4K/TUfet27fJhcKVlmtOJNBir+3I+17Q9
+eVzYH6Eze9mCUAyTF6ps3MKCuwJXNq+YJyo5UOGwifUll35HaBC07HPKs5fRJNz2
+YqAo07WjuGS3iGJCz51TzZm+ZGiPTx4SSPfSKcOYKMryMguTjClPPGAyzQWWYezy
+r/6zcCwupvI=
+-----END CERTIFICATE-----
+
+# Issuer: CN=BJCA Global Root CA2 O=BEIJING CERTIFICATE AUTHORITY
+# Subject: CN=BJCA Global Root CA2 O=BEIJING CERTIFICATE AUTHORITY
+# Label: "BJCA Global Root CA2"
+# Serial: 58605626836079930195615843123109055211
+# MD5 Fingerprint: 5e:0a:f6:47:5f:a6:14:e8:11:01:95:3f:4d:01:eb:3c
+# SHA1 Fingerprint: f4:27:86:eb:6e:b8:6d:88:31:67:02:fb:ba:66:a4:53:00:aa:7a:a6
+# SHA256 Fingerprint: 57:4d:f6:93:1e:27:80:39:66:7b:72:0a:fd:c1:60:0f:c2:7e:b6:6d:d3:09:29:79:fb:73:85:64:87:21:28:82
+-----BEGIN CERTIFICATE-----
+MIICJTCCAaugAwIBAgIQLBcIfWQqwP6FGFkGz7RK6zAKBggqhkjOPQQDAzBUMQsw
+CQYDVQQGEwJDTjEmMCQGA1UECgwdQkVJSklORyBDRVJUSUZJQ0FURSBBVVRIT1JJ
+VFkxHTAbBgNVBAMMFEJKQ0EgR2xvYmFsIFJvb3QgQ0EyMB4XDTE5MTIxOTAzMTgy
+MVoXDTQ0MTIxMjAzMTgyMVowVDELMAkGA1UEBhMCQ04xJjAkBgNVBAoMHUJFSUpJ
+TkcgQ0VSVElGSUNBVEUgQVVUSE9SSVRZMR0wGwYDVQQDDBRCSkNBIEdsb2JhbCBS
+b290IENBMjB2MBAGByqGSM49AgEGBSuBBAAiA2IABJ3LgJGNU2e1uVCxA/jlSR9B
+IgmwUVJY1is0j8USRhTFiy8shP8sbqjV8QnjAyEUxEM9fMEsxEtqSs3ph+B99iK+
++kpRuDCK/eHeGBIK9ke35xe/J4rUQUyWPGCWwf0VHKNCMEAwHQYDVR0OBBYEFNJK
+sVF/BvDRgh9Obl+rg/xI1LCRMA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQD
+AgEGMAoGCCqGSM49BAMDA2gAMGUCMBq8W9f+qdJUDkpd0m2xQNz0Q9XSSpkZElaA
+94M04TVOSG0ED1cxMDAtsaqdAzjbBgIxAMvMh1PLet8gUXOQwKhbYdDFUDn9hf7B
+43j4ptZLvZuHjw/l1lOWqzzIQNph91Oj9w==
+-----END CERTIFICATE-----
+
+# Issuer: CN=Sectigo Public Server Authentication Root E46 O=Sectigo Limited
+# Subject: CN=Sectigo Public Server Authentication Root E46 O=Sectigo Limited
+# Label: "Sectigo Public Server Authentication Root E46"
+# Serial: 88989738453351742415770396670917916916
+# MD5 Fingerprint: 28:23:f8:b2:98:5c:37:16:3b:3e:46:13:4e:b0:b3:01
+# SHA1 Fingerprint: ec:8a:39:6c:40:f0:2e:bc:42:75:d4:9f:ab:1c:1a:5b:67:be:d2:9a
+# SHA256 Fingerprint: c9:0f:26:f0:fb:1b:40:18:b2:22:27:51:9b:5c:a2:b5:3e:2c:a5:b3:be:5c:f1:8e:fe:1b:ef:47:38:0c:53:83
+-----BEGIN CERTIFICATE-----
+MIICOjCCAcGgAwIBAgIQQvLM2htpN0RfFf51KBC49DAKBggqhkjOPQQDAzBfMQsw
+CQYDVQQGEwJHQjEYMBYGA1UEChMPU2VjdGlnbyBMaW1pdGVkMTYwNAYDVQQDEy1T
+ZWN0aWdvIFB1YmxpYyBTZXJ2ZXIgQXV0aGVudGljYXRpb24gUm9vdCBFNDYwHhcN
+MjEwMzIyMDAwMDAwWhcNNDYwMzIxMjM1OTU5WjBfMQswCQYDVQQGEwJHQjEYMBYG
+A1UEChMPU2VjdGlnbyBMaW1pdGVkMTYwNAYDVQQDEy1TZWN0aWdvIFB1YmxpYyBT
+ZXJ2ZXIgQXV0aGVudGljYXRpb24gUm9vdCBFNDYwdjAQBgcqhkjOPQIBBgUrgQQA
+IgNiAAR2+pmpbiDt+dd34wc7qNs9Xzjoq1WmVk/WSOrsfy2qw7LFeeyZYX8QeccC
+WvkEN/U0NSt3zn8gj1KjAIns1aeibVvjS5KToID1AZTc8GgHHs3u/iVStSBDHBv+
+6xnOQ6OjQjBAMB0GA1UdDgQWBBTRItpMWfFLXyY4qp3W7usNw/upYTAOBgNVHQ8B
+Af8EBAMCAYYwDwYDVR0TAQH/BAUwAwEB/zAKBggqhkjOPQQDAwNnADBkAjAn7qRa
+qCG76UeXlImldCBteU/IvZNeWBj7LRoAasm4PdCkT0RHlAFWovgzJQxC36oCMB3q
+4S6ILuH5px0CMk7yn2xVdOOurvulGu7t0vzCAxHrRVxgED1cf5kDW21USAGKcw==
+-----END CERTIFICATE-----
+
+# Issuer: CN=Sectigo Public Server Authentication Root R46 O=Sectigo Limited
+# Subject: CN=Sectigo Public Server Authentication Root R46 O=Sectigo Limited
+# Label: "Sectigo Public Server Authentication Root R46"
+# Serial: 156256931880233212765902055439220583700
+# MD5 Fingerprint: 32:10:09:52:00:d5:7e:6c:43:df:15:c0:b1:16:93:e5
+# SHA1 Fingerprint: ad:98:f9:f3:e4:7d:75:3b:65:d4:82:b3:a4:52:17:bb:6e:f5:e4:38
+# SHA256 Fingerprint: 7b:b6:47:a6:2a:ee:ac:88:bf:25:7a:a5:22:d0:1f:fe:a3:95:e0:ab:45:c7:3f:93:f6:56:54:ec:38:f2:5a:06
+-----BEGIN CERTIFICATE-----
+MIIFijCCA3KgAwIBAgIQdY39i658BwD6qSWn4cetFDANBgkqhkiG9w0BAQwFADBf
+MQswCQYDVQQGEwJHQjEYMBYGA1UEChMPU2VjdGlnbyBMaW1pdGVkMTYwNAYDVQQD
+Ey1TZWN0aWdvIFB1YmxpYyBTZXJ2ZXIgQXV0aGVudGljYXRpb24gUm9vdCBSNDYw
+HhcNMjEwMzIyMDAwMDAwWhcNNDYwMzIxMjM1OTU5WjBfMQswCQYDVQQGEwJHQjEY
+MBYGA1UEChMPU2VjdGlnbyBMaW1pdGVkMTYwNAYDVQQDEy1TZWN0aWdvIFB1Ymxp
+YyBTZXJ2ZXIgQXV0aGVudGljYXRpb24gUm9vdCBSNDYwggIiMA0GCSqGSIb3DQEB
+AQUAA4ICDwAwggIKAoICAQCTvtU2UnXYASOgHEdCSe5jtrch/cSV1UgrJnwUUxDa
+ef0rty2k1Cz66jLdScK5vQ9IPXtamFSvnl0xdE8H/FAh3aTPaE8bEmNtJZlMKpnz
+SDBh+oF8HqcIStw+KxwfGExxqjWMrfhu6DtK2eWUAtaJhBOqbchPM8xQljeSM9xf
+iOefVNlI8JhD1mb9nxc4Q8UBUQvX4yMPFF1bFOdLvt30yNoDN9HWOaEhUTCDsG3X
+ME6WW5HwcCSrv0WBZEMNvSE6Lzzpng3LILVCJ8zab5vuZDCQOc2TZYEhMbUjUDM3
+IuM47fgxMMxF/mL50V0yeUKH32rMVhlATc6qu/m1dkmU8Sf4kaWD5QazYw6A3OAS
+VYCmO2a0OYctyPDQ0RTp5A1NDvZdV3LFOxxHVp3i1fuBYYzMTYCQNFu31xR13NgE
+SJ/AwSiItOkcyqex8Va3e0lMWeUgFaiEAin6OJRpmkkGj80feRQXEgyDet4fsZfu
++Zd4KKTIRJLpfSYFplhym3kT2BFfrsU4YjRosoYwjviQYZ4ybPUHNs2iTG7sijbt
+8uaZFURww3y8nDnAtOFr94MlI1fZEoDlSfB1D++N6xybVCi0ITz8fAr/73trdf+L
+HaAZBav6+CuBQug4urv7qv094PPK306Xlynt8xhW6aWWrL3DkJiy4Pmi1KZHQ3xt
+zwIDAQABo0IwQDAdBgNVHQ4EFgQUVnNYZJX5khqwEioEYnmhQBWIIUkwDgYDVR0P
+AQH/BAQDAgGGMA8GA1UdEwEB/wQFMAMBAf8wDQYJKoZIhvcNAQEMBQADggIBAC9c
+mTz8Bl6MlC5w6tIyMY208FHVvArzZJ8HXtXBc2hkeqK5Duj5XYUtqDdFqij0lgVQ
+YKlJfp/imTYpE0RHap1VIDzYm/EDMrraQKFz6oOht0SmDpkBm+S8f74TlH7Kph52
+gDY9hAaLMyZlbcp+nv4fjFg4exqDsQ+8FxG75gbMY/qB8oFM2gsQa6H61SilzwZA
+Fv97fRheORKkU55+MkIQpiGRqRxOF3yEvJ+M0ejf5lG5Nkc/kLnHvALcWxxPDkjB
+JYOcCj+esQMzEhonrPcibCTRAUH4WAP+JWgiH5paPHxsnnVI84HxZmduTILA7rpX
+DhjvLpr3Etiga+kFpaHpaPi8TD8SHkXoUsCjvxInebnMMTzD9joiFgOgyY9mpFui
+TdaBJQbpdqQACj7LzTWb4OE4y2BThihCQRxEV+ioratF4yUQvNs+ZUH7G6aXD+u5
+dHn5HrwdVw1Hr8Mvn4dGp+smWg9WY7ViYG4A++MnESLn/pmPNPW56MORcr3Ywx65
+LvKRRFHQV80MNNVIIb/bE/FmJUNS0nAiNs2fxBx1IK1jcmMGDw4nztJqDby1ORrp
+0XZ60Vzk50lJLVU3aPAaOpg+VBeHVOmmJ1CJeyAvP/+/oYtKR5j/K3tJPsMpRmAY
+QqszKbrAKbkTidOIijlBO8n9pu0f9GBj39ItVQGL
+-----END CERTIFICATE-----
+
+# Issuer: CN=SSL.com TLS RSA Root CA 2022 O=SSL Corporation
+# Subject: CN=SSL.com TLS RSA Root CA 2022 O=SSL Corporation
+# Label: "SSL.com TLS RSA Root CA 2022"
+# Serial: 148535279242832292258835760425842727825
+# MD5 Fingerprint: d8:4e:c6:59:30:d8:fe:a0:d6:7a:5a:2c:2c:69:78:da
+# SHA1 Fingerprint: ec:2c:83:40:72:af:26:95:10:ff:0e:f2:03:ee:31:70:f6:78:9d:ca
+# SHA256 Fingerprint: 8f:af:7d:2e:2c:b4:70:9b:b8:e0:b3:36:66:bf:75:a5:dd:45:b5:de:48:0f:8e:a8:d4:bf:e6:be:bc:17:f2:ed
+-----BEGIN CERTIFICATE-----
+MIIFiTCCA3GgAwIBAgIQb77arXO9CEDii02+1PdbkTANBgkqhkiG9w0BAQsFADBO
+MQswCQYDVQQGEwJVUzEYMBYGA1UECgwPU1NMIENvcnBvcmF0aW9uMSUwIwYDVQQD
+DBxTU0wuY29tIFRMUyBSU0EgUm9vdCBDQSAyMDIyMB4XDTIyMDgyNTE2MzQyMloX
+DTQ2MDgxOTE2MzQyMVowTjELMAkGA1UEBhMCVVMxGDAWBgNVBAoMD1NTTCBDb3Jw
+b3JhdGlvbjElMCMGA1UEAwwcU1NMLmNvbSBUTFMgUlNBIFJvb3QgQ0EgMjAyMjCC
+AiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBANCkCXJPQIgSYT41I57u9nTP
+L3tYPc48DRAokC+X94xI2KDYJbFMsBFMF3NQ0CJKY7uB0ylu1bUJPiYYf7ISf5OY
+t6/wNr/y7hienDtSxUcZXXTzZGbVXcdotL8bHAajvI9AI7YexoS9UcQbOcGV0ins
+S657Lb85/bRi3pZ7QcacoOAGcvvwB5cJOYF0r/c0WRFXCsJbwST0MXMwgsadugL3
+PnxEX4MN8/HdIGkWCVDi1FW24IBydm5MR7d1VVm0U3TZlMZBrViKMWYPHqIbKUBO
+L9975hYsLfy/7PO0+r4Y9ptJ1O4Fbtk085zx7AGL0SDGD6C1vBdOSHtRwvzpXGk3
+R2azaPgVKPC506QVzFpPulJwoxJF3ca6TvvC0PeoUidtbnm1jPx7jMEWTO6Af77w
+dr5BUxIzrlo4QqvXDz5BjXYHMtWrifZOZ9mxQnUjbvPNQrL8VfVThxc7wDNY8VLS
++YCk8OjwO4s4zKTGkH8PnP2L0aPP2oOnaclQNtVcBdIKQXTbYxE3waWglksejBYS
+d66UNHsef8JmAOSqg+qKkK3ONkRN0VHpvB/zagX9wHQfJRlAUW7qglFA35u5CCoG
+AtUjHBPW6dvbxrB6y3snm/vg1UYk7RBLY0ulBY+6uB0rpvqR4pJSvezrZ5dtmi2f
+gTIFZzL7SAg/2SW4BCUvAgMBAAGjYzBhMA8GA1UdEwEB/wQFMAMBAf8wHwYDVR0j
+BBgwFoAU+y437uOEeicuzRk1sTN8/9REQrkwHQYDVR0OBBYEFPsuN+7jhHonLs0Z
+NbEzfP/UREK5MA4GA1UdDwEB/wQEAwIBhjANBgkqhkiG9w0BAQsFAAOCAgEAjYlt
+hEUY8U+zoO9opMAdrDC8Z2awms22qyIZZtM7QbUQnRC6cm4pJCAcAZli05bg4vsM
+QtfhWsSWTVTNj8pDU/0quOr4ZcoBwq1gaAafORpR2eCNJvkLTqVTJXojpBzOCBvf
+R4iyrT7gJ4eLSYwfqUdYe5byiB0YrrPRpgqU+tvT5TgKa3kSM/tKWTcWQA673vWJ
+DPFs0/dRa1419dvAJuoSc06pkZCmF8NsLzjUo3KUQyxi4U5cMj29TH0ZR6LDSeeW
+P4+a0zvkEdiLA9z2tmBVGKaBUfPhqBVq6+AL8BQx1rmMRTqoENjwuSfr98t67wVy
+lrXEj5ZzxOhWc5y8aVFjvO9nHEMaX3cZHxj4HCUp+UmZKbaSPaKDN7EgkaibMOlq
+bLQjk2UEqxHzDh1TJElTHaE/nUiSEeJ9DU/1172iWD54nR4fK/4huxoTtrEoZP2w
+AgDHbICivRZQIA9ygV/MlP+7mea6kMvq+cYMwq7FGc4zoWtcu358NFcXrfA/rs3q
+r5nsLFR+jM4uElZI7xc7P0peYNLcdDa8pUNjyw9bowJWCZ4kLOGGgYz+qxcs+sji
+Mho6/4UIyYOf8kpIEFR3N+2ivEC+5BB09+Rbu7nzifmPQdjH5FCQNYA+HLhNkNPU
+98OwoX6EyneSMSy4kLGCenROmxMmtNVQZlR4rmA=
+-----END CERTIFICATE-----
+
+# Issuer: CN=SSL.com TLS ECC Root CA 2022 O=SSL Corporation
+# Subject: CN=SSL.com TLS ECC Root CA 2022 O=SSL Corporation
+# Label: "SSL.com TLS ECC Root CA 2022"
+# Serial: 26605119622390491762507526719404364228
+# MD5 Fingerprint: 99:d7:5c:f1:51:36:cc:e9:ce:d9:19:2e:77:71:56:c5
+# SHA1 Fingerprint: 9f:5f:d9:1a:54:6d:f5:0c:71:f0:ee:7a:bd:17:49:98:84:73:e2:39
+# SHA256 Fingerprint: c3:2f:fd:9f:46:f9:36:d1:6c:36:73:99:09:59:43:4b:9a:d6:0a:af:bb:9e:7c:f3:36:54:f1:44:cc:1b:a1:43
+-----BEGIN CERTIFICATE-----
+MIICOjCCAcCgAwIBAgIQFAP1q/s3ixdAW+JDsqXRxDAKBggqhkjOPQQDAzBOMQsw
+CQYDVQQGEwJVUzEYMBYGA1UECgwPU1NMIENvcnBvcmF0aW9uMSUwIwYDVQQDDBxT
+U0wuY29tIFRMUyBFQ0MgUm9vdCBDQSAyMDIyMB4XDTIyMDgyNTE2MzM0OFoXDTQ2
+MDgxOTE2MzM0N1owTjELMAkGA1UEBhMCVVMxGDAWBgNVBAoMD1NTTCBDb3Jwb3Jh
+dGlvbjElMCMGA1UEAwwcU1NMLmNvbSBUTFMgRUNDIFJvb3QgQ0EgMjAyMjB2MBAG
+ByqGSM49AgEGBSuBBAAiA2IABEUpNXP6wrgjzhR9qLFNoFs27iosU8NgCTWyJGYm
+acCzldZdkkAZDsalE3D07xJRKF3nzL35PIXBz5SQySvOkkJYWWf9lCcQZIxPBLFN
+SeR7T5v15wj4A4j3p8OSSxlUgaNjMGEwDwYDVR0TAQH/BAUwAwEB/zAfBgNVHSME
+GDAWgBSJjy+j6CugFFR781a4Jl9nOAuc0DAdBgNVHQ4EFgQUiY8vo+groBRUe/NW
+uCZfZzgLnNAwDgYDVR0PAQH/BAQDAgGGMAoGCCqGSM49BAMDA2gAMGUCMFXjIlbp
+15IkWE8elDIPDAI2wv2sdDJO4fscgIijzPvX6yv/N33w7deedWo1dlJF4AIxAMeN
+b0Igj762TVntd00pxCAgRWSGOlDGxK0tk/UYfXLtqc/ErFc2KAhl3zx5Zn6g6g==
+-----END CERTIFICATE-----
+
+# Issuer: CN=Atos TrustedRoot Root CA ECC TLS 2021 O=Atos
+# Subject: CN=Atos TrustedRoot Root CA ECC TLS 2021 O=Atos
+# Label: "Atos TrustedRoot Root CA ECC TLS 2021"
+# Serial: 81873346711060652204712539181482831616
+# MD5 Fingerprint: 16:9f:ad:f1:70:ad:79:d6:ed:29:b4:d1:c5:79:70:a8
+# SHA1 Fingerprint: 9e:bc:75:10:42:b3:02:f3:81:f4:f7:30:62:d4:8f:c3:a7:51:b2:dd
+# SHA256 Fingerprint: b2:fa:e5:3e:14:cc:d7:ab:92:12:06:47:01:ae:27:9c:1d:89:88:fa:cb:77:5f:a8:a0:08:91:4e:66:39:88:a8
+-----BEGIN CERTIFICATE-----
+MIICFTCCAZugAwIBAgIQPZg7pmY9kGP3fiZXOATvADAKBggqhkjOPQQDAzBMMS4w
+LAYDVQQDDCVBdG9zIFRydXN0ZWRSb290IFJvb3QgQ0EgRUNDIFRMUyAyMDIxMQ0w
+CwYDVQQKDARBdG9zMQswCQYDVQQGEwJERTAeFw0yMTA0MjIwOTI2MjNaFw00MTA0
+MTcwOTI2MjJaMEwxLjAsBgNVBAMMJUF0b3MgVHJ1c3RlZFJvb3QgUm9vdCBDQSBF
+Q0MgVExTIDIwMjExDTALBgNVBAoMBEF0b3MxCzAJBgNVBAYTAkRFMHYwEAYHKoZI
+zj0CAQYFK4EEACIDYgAEloZYKDcKZ9Cg3iQZGeHkBQcfl+3oZIK59sRxUM6KDP/X
+tXa7oWyTbIOiaG6l2b4siJVBzV3dscqDY4PMwL502eCdpO5KTlbgmClBk1IQ1SQ4
+AjJn8ZQSb+/Xxd4u/RmAo0IwQDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQWBBR2
+KCXWfeBmmnoJsmo7jjPXNtNPojAOBgNVHQ8BAf8EBAMCAYYwCgYIKoZIzj0EAwMD
+aAAwZQIwW5kp85wxtolrbNa9d+F851F+uDrNozZffPc8dz7kUK2o59JZDCaOMDtu
+CCrCp1rIAjEAmeMM56PDr9NJLkaCI2ZdyQAUEv049OGYa3cpetskz2VAv9LcjBHo
+9H1/IISpQuQo
+-----END CERTIFICATE-----
+
+# Issuer: CN=Atos TrustedRoot Root CA RSA TLS 2021 O=Atos
+# Subject: CN=Atos TrustedRoot Root CA RSA TLS 2021 O=Atos
+# Label: "Atos TrustedRoot Root CA RSA TLS 2021"
+# Serial: 111436099570196163832749341232207667876
+# MD5 Fingerprint: d4:d3:46:b8:9a:c0:9c:76:5d:9e:3a:c3:b9:99:31:d2
+# SHA1 Fingerprint: 18:52:3b:0d:06:37:e4:d6:3a:df:23:e4:98:fb:5b:16:fb:86:74:48
+# SHA256 Fingerprint: 81:a9:08:8e:a5:9f:b3:64:c5:48:a6:f8:55:59:09:9b:6f:04:05:ef:bf:18:e5:32:4e:c9:f4:57:ba:00:11:2f
+-----BEGIN CERTIFICATE-----
+MIIFZDCCA0ygAwIBAgIQU9XP5hmTC/srBRLYwiqipDANBgkqhkiG9w0BAQwFADBM
+MS4wLAYDVQQDDCVBdG9zIFRydXN0ZWRSb290IFJvb3QgQ0EgUlNBIFRMUyAyMDIx
+MQ0wCwYDVQQKDARBdG9zMQswCQYDVQQGEwJERTAeFw0yMTA0MjIwOTIxMTBaFw00
+MTA0MTcwOTIxMDlaMEwxLjAsBgNVBAMMJUF0b3MgVHJ1c3RlZFJvb3QgUm9vdCBD
+QSBSU0EgVExTIDIwMjExDTALBgNVBAoMBEF0b3MxCzAJBgNVBAYTAkRFMIICIjAN
+BgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEAtoAOxHm9BYx9sKOdTSJNy/BBl01Z
+4NH+VoyX8te9j2y3I49f1cTYQcvyAh5x5en2XssIKl4w8i1mx4QbZFc4nXUtVsYv
+Ye+W/CBGvevUez8/fEc4BKkbqlLfEzfTFRVOvV98r61jx3ncCHvVoOX3W3WsgFWZ
+kmGbzSoXfduP9LVq6hdKZChmFSlsAvFr1bqjM9xaZ6cF4r9lthawEO3NUDPJcFDs
+GY6wx/J0W2tExn2WuZgIWWbeKQGb9Cpt0xU6kGpn8bRrZtkh68rZYnxGEFzedUln
+nkL5/nWpo63/dgpnQOPF943HhZpZnmKaau1Fh5hnstVKPNe0OwANwI8f4UDErmwh
+3El+fsqyjW22v5MvoVw+j8rtgI5Y4dtXz4U2OLJxpAmMkokIiEjxQGMYsluMWuPD
+0xeqqxmjLBvk1cbiZnrXghmmOxYsL3GHX0WelXOTwkKBIROW1527k2gV+p2kHYzy
+geBYBr3JtuP2iV2J+axEoctr+hbxx1A9JNr3w+SH1VbxT5Aw+kUJWdo0zuATHAR8
+ANSbhqRAvNncTFd+rrcztl524WWLZt+NyteYr842mIycg5kDcPOvdO3GDjbnvezB
+c6eUWsuSZIKmAMFwoW4sKeFYV+xafJlrJaSQOoD0IJ2azsct+bJLKZWD6TWNp0lI
+pw9MGZHQ9b8Q4HECAwEAAaNCMEAwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU
+dEmZ0f+0emhFdcN+tNzMzjkz2ggwDgYDVR0PAQH/BAQDAgGGMA0GCSqGSIb3DQEB
+DAUAA4ICAQAjQ1MkYlxt/T7Cz1UAbMVWiLkO3TriJQ2VSpfKgInuKs1l+NsW4AmS
+4BjHeJi78+xCUvuppILXTdiK/ORO/auQxDh1MoSf/7OwKwIzNsAQkG8dnK/haZPs
+o0UvFJ/1TCplQ3IM98P4lYsU84UgYt1UU90s3BiVaU+DR3BAM1h3Egyi61IxHkzJ
+qM7F78PRreBrAwA0JrRUITWXAdxfG/F851X6LWh3e9NpzNMOa7pNdkTWwhWaJuyw
+xfW70Xp0wmzNxbVe9kzmWy2B27O3Opee7c9GslA9hGCZcbUztVdF5kJHdWoOsAgM
+rr3e97sPWD2PAzHoPYJQyi9eDF20l74gNAf0xBLh7tew2VktafcxBPTy+av5EzH4
+AXcOPUIjJsyacmdRIXrMPIWo6iFqO9taPKU0nprALN+AnCng33eU0aKAQv9qTFsR
+0PXNor6uzFFcw9VUewyu1rkGd4Di7wcaaMxZUa1+XGdrudviB0JbuAEFWDlN5LuY
+o7Ey7Nmj1m+UI/87tyll5gfp77YZ6ufCOB0yiJA8EytuzO+rdwY0d4RPcuSBhPm5
+dDTedk+SKlOxJTnbPP/lPqYO5Wue/9vsL3SD3460s6neFE3/MaNFcyT6lSnMEpcE
+oji2jbDwN/zIIX8/syQbPYtuzE2wFg2WHYMfRsCbvUOZ58SWLs5fyQ==
+-----END CERTIFICATE-----
+
+# Issuer: CN=TrustAsia Global Root CA G3 O=TrustAsia Technologies, Inc.
+# Subject: CN=TrustAsia Global Root CA G3 O=TrustAsia Technologies, Inc.
+# Label: "TrustAsia Global Root CA G3"
+# Serial: 576386314500428537169965010905813481816650257167
+# MD5 Fingerprint: 30:42:1b:b7:bb:81:75:35:e4:16:4f:53:d2:94:de:04
+# SHA1 Fingerprint: 63:cf:b6:c1:27:2b:56:e4:88:8e:1c:23:9a:b6:2e:81:47:24:c3:c7
+# SHA256 Fingerprint: e0:d3:22:6a:eb:11:63:c2:e4:8f:f9:be:3b:50:b4:c6:43:1b:e7:bb:1e:ac:c5:c3:6b:5d:5e:c5:09:03:9a:08
+-----BEGIN CERTIFICATE-----
+MIIFpTCCA42gAwIBAgIUZPYOZXdhaqs7tOqFhLuxibhxkw8wDQYJKoZIhvcNAQEM
+BQAwWjELMAkGA1UEBhMCQ04xJTAjBgNVBAoMHFRydXN0QXNpYSBUZWNobm9sb2dp
+ZXMsIEluYy4xJDAiBgNVBAMMG1RydXN0QXNpYSBHbG9iYWwgUm9vdCBDQSBHMzAe
+Fw0yMTA1MjAwMjEwMTlaFw00NjA1MTkwMjEwMTlaMFoxCzAJBgNVBAYTAkNOMSUw
+IwYDVQQKDBxUcnVzdEFzaWEgVGVjaG5vbG9naWVzLCBJbmMuMSQwIgYDVQQDDBtU
+cnVzdEFzaWEgR2xvYmFsIFJvb3QgQ0EgRzMwggIiMA0GCSqGSIb3DQEBAQUAA4IC
+DwAwggIKAoICAQDAMYJhkuSUGwoqZdC+BqmHO1ES6nBBruL7dOoKjbmzTNyPtxNS
+T1QY4SxzlZHFZjtqz6xjbYdT8PfxObegQ2OwxANdV6nnRM7EoYNl9lA+sX4WuDqK
+AtCWHwDNBSHvBm3dIZwZQ0WhxeiAysKtQGIXBsaqvPPW5vxQfmZCHzyLpnl5hkA1
+nyDvP+uLRx+PjsXUjrYsyUQE49RDdT/VP68czH5GX6zfZBCK70bwkPAPLfSIC7Ep
+qq+FqklYqL9joDiR5rPmd2jE+SoZhLsO4fWvieylL1AgdB4SQXMeJNnKziyhWTXA
+yB1GJ2Faj/lN03J5Zh6fFZAhLf3ti1ZwA0pJPn9pMRJpxx5cynoTi+jm9WAPzJMs
+hH/x/Gr8m0ed262IPfN2dTPXS6TIi/n1Q1hPy8gDVI+lhXgEGvNz8teHHUGf59gX
+zhqcD0r83ERoVGjiQTz+LISGNzzNPy+i2+f3VANfWdP3kXjHi3dqFuVJhZBFcnAv
+kV34PmVACxmZySYgWmjBNb9Pp1Hx2BErW+Canig7CjoKH8GB5S7wprlppYiU5msT
+f9FkPz2ccEblooV7WIQn3MSAPmeamseaMQ4w7OYXQJXZRe0Blqq/DPNL0WP3E1jA
+uPP6Z92bfW1K/zJMtSU7/xxnD4UiWQWRkUF3gdCFTIcQcf+eQxuulXUtgQIDAQAB
+o2MwYTAPBgNVHRMBAf8EBTADAQH/MB8GA1UdIwQYMBaAFEDk5PIj7zjKsK5Xf/Ih
+MBY027ySMB0GA1UdDgQWBBRA5OTyI+84yrCuV3/yITAWNNu8kjAOBgNVHQ8BAf8E
+BAMCAQYwDQYJKoZIhvcNAQEMBQADggIBACY7UeFNOPMyGLS0XuFlXsSUT9SnYaP4
+wM8zAQLpw6o1D/GUE3d3NZ4tVlFEbuHGLige/9rsR82XRBf34EzC4Xx8MnpmyFq2
+XFNFV1pF1AWZLy4jVe5jaN/TG3inEpQGAHUNcoTpLrxaatXeL1nHo+zSh2bbt1S1
+JKv0Q3jbSwTEb93mPmY+KfJLaHEih6D4sTNjduMNhXJEIlU/HHzp/LgV6FL6qj6j
+ITk1dImmasI5+njPtqzn59ZW/yOSLlALqbUHM/Q4X6RJpstlcHboCoWASzY9M/eV
+VHUl2qzEc4Jl6VL1XP04lQJqaTDFHApXB64ipCz5xUG3uOyfT0gA+QEEVcys+TIx
+xHWVBqB/0Y0n3bOppHKH/lmLmnp0Ft0WpWIp6zqW3IunaFnT63eROfjXy9mPX1on
+AX1daBli2MjN9LdyR75bl87yraKZk62Uy5P2EgmVtqvXO9A/EcswFi55gORngS1d
+7XB4tmBZrOFdRWOPyN9yaFvqHbgB8X7754qz41SgOAngPN5C8sLtLpvzHzW2Ntjj
+gKGLzZlkD8Kqq7HK9W+eQ42EVJmzbsASZthwEPEGNTNDqJwuuhQxzhB/HIbjj9LV
++Hfsm6vxL2PZQl/gZ4FkkfGXL/xuJvYz+NO1+MRiqzFRJQJ6+N1rZdVtTTDIZbpo
+FGWsJwt0ivKH
+-----END CERTIFICATE-----
+
+# Issuer: CN=TrustAsia Global Root CA G4 O=TrustAsia Technologies, Inc.
+# Subject: CN=TrustAsia Global Root CA G4 O=TrustAsia Technologies, Inc.
+# Label: "TrustAsia Global Root CA G4"
+# Serial: 451799571007117016466790293371524403291602933463
+# MD5 Fingerprint: 54:dd:b2:d7:5f:d8:3e:ed:7c:e0:0b:2e:cc:ed:eb:eb
+# SHA1 Fingerprint: 57:73:a5:61:5d:80:b2:e6:ac:38:82:fc:68:07:31:ac:9f:b5:92:5a
+# SHA256 Fingerprint: be:4b:56:cb:50:56:c0:13:6a:52:6d:f4:44:50:8d:aa:36:a0:b5:4f:42:e4:ac:38:f7:2a:f4:70:e4:79:65:4c
+-----BEGIN CERTIFICATE-----
+MIICVTCCAdygAwIBAgIUTyNkuI6XY57GU4HBdk7LKnQV1tcwCgYIKoZIzj0EAwMw
+WjELMAkGA1UEBhMCQ04xJTAjBgNVBAoMHFRydXN0QXNpYSBUZWNobm9sb2dpZXMs
+IEluYy4xJDAiBgNVBAMMG1RydXN0QXNpYSBHbG9iYWwgUm9vdCBDQSBHNDAeFw0y
+MTA1MjAwMjEwMjJaFw00NjA1MTkwMjEwMjJaMFoxCzAJBgNVBAYTAkNOMSUwIwYD
+VQQKDBxUcnVzdEFzaWEgVGVjaG5vbG9naWVzLCBJbmMuMSQwIgYDVQQDDBtUcnVz
+dEFzaWEgR2xvYmFsIFJvb3QgQ0EgRzQwdjAQBgcqhkjOPQIBBgUrgQQAIgNiAATx
+s8045CVD5d4ZCbuBeaIVXxVjAd7Cq92zphtnS4CDr5nLrBfbK5bKfFJV4hrhPVbw
+LxYI+hW8m7tH5j/uqOFMjPXTNvk4XatwmkcN4oFBButJ+bAp3TPsUKV/eSm4IJij
+YzBhMA8GA1UdEwEB/wQFMAMBAf8wHwYDVR0jBBgwFoAUpbtKl86zK3+kMd6Xg1mD
+pm9xy94wHQYDVR0OBBYEFKW7SpfOsyt/pDHel4NZg6ZvccveMA4GA1UdDwEB/wQE
+AwIBBjAKBggqhkjOPQQDAwNnADBkAjBe8usGzEkxn0AAbbd+NvBNEU/zy4k6LHiR
+UKNbwMp1JvK/kF0LgoxgKJ/GcJpo5PECMFxYDlZ2z1jD1xCMuo6u47xkdUfFVZDj
+/bpV6wfEU6s3qe4hsiFbYI89MvHVI5TWWA==
+-----END CERTIFICATE-----
+
+# Issuer: CN=CommScope Public Trust ECC Root-01 O=CommScope
+# Subject: CN=CommScope Public Trust ECC Root-01 O=CommScope
+# Label: "CommScope Public Trust ECC Root-01"
+# Serial: 385011430473757362783587124273108818652468453534
+# MD5 Fingerprint: 3a:40:a7:fc:03:8c:9c:38:79:2f:3a:a2:6c:b6:0a:16
+# SHA1 Fingerprint: 07:86:c0:d8:dd:8e:c0:80:98:06:98:d0:58:7a:ef:de:a6:cc:a2:5d
+# SHA256 Fingerprint: 11:43:7c:da:7b:b4:5e:41:36:5f:45:b3:9a:38:98:6b:0d:e0:0d:ef:34:8e:0c:7b:b0:87:36:33:80:0b:c3:8b
+-----BEGIN CERTIFICATE-----
+MIICHTCCAaOgAwIBAgIUQ3CCd89NXTTxyq4yLzf39H91oJ4wCgYIKoZIzj0EAwMw
+TjELMAkGA1UEBhMCVVMxEjAQBgNVBAoMCUNvbW1TY29wZTErMCkGA1UEAwwiQ29t
+bVNjb3BlIFB1YmxpYyBUcnVzdCBFQ0MgUm9vdC0wMTAeFw0yMTA0MjgxNzM1NDNa
+Fw00NjA0MjgxNzM1NDJaME4xCzAJBgNVBAYTAlVTMRIwEAYDVQQKDAlDb21tU2Nv
+cGUxKzApBgNVBAMMIkNvbW1TY29wZSBQdWJsaWMgVHJ1c3QgRUNDIFJvb3QtMDEw
+djAQBgcqhkjOPQIBBgUrgQQAIgNiAARLNumuV16ocNfQj3Rid8NeeqrltqLxeP0C
+flfdkXmcbLlSiFS8LwS+uM32ENEp7LXQoMPwiXAZu1FlxUOcw5tjnSCDPgYLpkJE
+hRGnSjot6dZoL0hOUysHP029uax3OVejQjBAMA8GA1UdEwEB/wQFMAMBAf8wDgYD
+VR0PAQH/BAQDAgEGMB0GA1UdDgQWBBSOB2LAUN3GGQYARnQE9/OufXVNMDAKBggq
+hkjOPQQDAwNoADBlAjEAnDPfQeMjqEI2Jpc1XHvr20v4qotzVRVcrHgpD7oh2MSg
+2NED3W3ROT3Ek2DS43KyAjB8xX6I01D1HiXo+k515liWpDVfG2XqYZpwI7UNo5uS
+Um9poIyNStDuiw7LR47QjRE=
+-----END CERTIFICATE-----
+
+# Issuer: CN=CommScope Public Trust ECC Root-02 O=CommScope
+# Subject: CN=CommScope Public Trust ECC Root-02 O=CommScope
+# Label: "CommScope Public Trust ECC Root-02"
+# Serial: 234015080301808452132356021271193974922492992893
+# MD5 Fingerprint: 59:b0:44:d5:65:4d:b8:5c:55:19:92:02:b6:d1:94:b2
+# SHA1 Fingerprint: 3c:3f:ef:57:0f:fe:65:93:86:9e:a0:fe:b0:f6:ed:8e:d1:13:c7:e5
+# SHA256 Fingerprint: 2f:fb:7f:81:3b:bb:b3:c8:9a:b4:e8:16:2d:0f:16:d7:15:09:a8:30:cc:9d:73:c2:62:e5:14:08:75:d1:ad:4a
+-----BEGIN CERTIFICATE-----
+MIICHDCCAaOgAwIBAgIUKP2ZYEFHpgE6yhR7H+/5aAiDXX0wCgYIKoZIzj0EAwMw
+TjELMAkGA1UEBhMCVVMxEjAQBgNVBAoMCUNvbW1TY29wZTErMCkGA1UEAwwiQ29t
+bVNjb3BlIFB1YmxpYyBUcnVzdCBFQ0MgUm9vdC0wMjAeFw0yMTA0MjgxNzQ0NTRa
+Fw00NjA0MjgxNzQ0NTNaME4xCzAJBgNVBAYTAlVTMRIwEAYDVQQKDAlDb21tU2Nv
+cGUxKzApBgNVBAMMIkNvbW1TY29wZSBQdWJsaWMgVHJ1c3QgRUNDIFJvb3QtMDIw
+djAQBgcqhkjOPQIBBgUrgQQAIgNiAAR4MIHoYx7l63FRD/cHB8o5mXxO1Q/MMDAL
+j2aTPs+9xYa9+bG3tD60B8jzljHz7aRP+KNOjSkVWLjVb3/ubCK1sK9IRQq9qEmU
+v4RDsNuESgMjGWdqb8FuvAY5N9GIIvejQjBAMA8GA1UdEwEB/wQFMAMBAf8wDgYD
+VR0PAQH/BAQDAgEGMB0GA1UdDgQWBBTmGHX/72DehKT1RsfeSlXjMjZ59TAKBggq
+hkjOPQQDAwNnADBkAjAmc0l6tqvmSfR9Uj/UQQSugEODZXW5hYA4O9Zv5JOGq4/n
+ich/m35rChJVYaoR4HkCMHfoMXGsPHED1oQmHhS48zs73u1Z/GtMMH9ZzkXpc2AV
+mkzw5l4lIhVtwodZ0LKOag==
+-----END CERTIFICATE-----
+
+# Issuer: CN=CommScope Public Trust RSA Root-01 O=CommScope
+# Subject: CN=CommScope Public Trust RSA Root-01 O=CommScope
+# Label: "CommScope Public Trust RSA Root-01"
+# Serial: 354030733275608256394402989253558293562031411421
+# MD5 Fingerprint: 0e:b4:15:bc:87:63:5d:5d:02:73:d4:26:38:68:73:d8
+# SHA1 Fingerprint: 6d:0a:5f:f7:b4:23:06:b4:85:b3:b7:97:64:fc:ac:75:f5:33:f2:93
+# SHA256 Fingerprint: 02:bd:f9:6e:2a:45:dd:9b:f1:8f:c7:e1:db:df:21:a0:37:9b:a3:c9:c2:61:03:44:cf:d8:d6:06:fe:c1:ed:81
+-----BEGIN CERTIFICATE-----
+MIIFbDCCA1SgAwIBAgIUPgNJgXUWdDGOTKvVxZAplsU5EN0wDQYJKoZIhvcNAQEL
+BQAwTjELMAkGA1UEBhMCVVMxEjAQBgNVBAoMCUNvbW1TY29wZTErMCkGA1UEAwwi
+Q29tbVNjb3BlIFB1YmxpYyBUcnVzdCBSU0EgUm9vdC0wMTAeFw0yMTA0MjgxNjQ1
+NTRaFw00NjA0MjgxNjQ1NTNaME4xCzAJBgNVBAYTAlVTMRIwEAYDVQQKDAlDb21t
+U2NvcGUxKzApBgNVBAMMIkNvbW1TY29wZSBQdWJsaWMgVHJ1c3QgUlNBIFJvb3Qt
+MDEwggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQCwSGWjDR1C45FtnYSk
+YZYSwu3D2iM0GXb26v1VWvZVAVMP8syMl0+5UMuzAURWlv2bKOx7dAvnQmtVzslh
+suitQDy6uUEKBU8bJoWPQ7VAtYXR1HHcg0Hz9kXHgKKEUJdGzqAMxGBWBB0HW0al
+DrJLpA6lfO741GIDuZNqihS4cPgugkY4Iw50x2tBt9Apo52AsH53k2NC+zSDO3Oj
+WiE260f6GBfZumbCk6SP/F2krfxQapWsvCQz0b2If4b19bJzKo98rwjyGpg/qYFl
+P8GMicWWMJoKz/TUyDTtnS+8jTiGU+6Xn6myY5QXjQ/cZip8UlF1y5mO6D1cv547
+KI2DAg+pn3LiLCuz3GaXAEDQpFSOm117RTYm1nJD68/A6g3czhLmfTifBSeolz7p
+UcZsBSjBAg/pGG3svZwG1KdJ9FQFa2ww8esD1eo9anbCyxooSU1/ZOD6K9pzg4H/
+kQO9lLvkuI6cMmPNn7togbGEW682v3fuHX/3SZtS7NJ3Wn2RnU3COS3kuoL4b/JO
+Hg9O5j9ZpSPcPYeoKFgo0fEbNttPxP/hjFtyjMcmAyejOQoBqsCyMWCDIqFPEgkB
+Ea801M/XrmLTBQe0MXXgDW1XT2mH+VepuhX2yFJtocucH+X8eKg1mp9BFM6ltM6U
+CBwJrVbl2rZJmkrqYxhTnCwuwwIDAQABo0IwQDAPBgNVHRMBAf8EBTADAQH/MA4G
+A1UdDwEB/wQEAwIBBjAdBgNVHQ4EFgQUN12mmnQywsL5x6YVEFm45P3luG0wDQYJ
+KoZIhvcNAQELBQADggIBAK+nz97/4L1CjU3lIpbfaOp9TSp90K09FlxD533Ahuh6
+NWPxzIHIxgvoLlI1pKZJkGNRrDSsBTtXAOnTYtPZKdVUvhwQkZyybf5Z/Xn36lbQ
+nmhUQo8mUuJM3y+Xpi/SB5io82BdS5pYV4jvguX6r2yBS5KPQJqTRlnLX3gWsWc+
+QgvfKNmwrZggvkN80V4aCRckjXtdlemrwWCrWxhkgPut4AZ9HcpZuPN4KWfGVh2v
+trV0KnahP/t1MJ+UXjulYPPLXAziDslg+MkfFoom3ecnf+slpoq9uC02EJqxWE2a
+aE9gVOX2RhOOiKy8IUISrcZKiX2bwdgt6ZYD9KJ0DLwAHb/WNyVntHKLr4W96ioD
+j8z7PEQkguIBpQtZtjSNMgsSDesnwv1B10A8ckYpwIzqug/xBpMu95yo9GA+o/E4
+Xo4TwbM6l4c/ksp4qRyv0LAbJh6+cOx69TOY6lz/KwsETkPdY34Op054A5U+1C0w
+lREQKC6/oAI+/15Z0wUOlV9TRe9rh9VIzRamloPh37MG88EU26fsHItdkJANclHn
+YfkUyq+Dj7+vsQpZXdxc1+SWrVtgHdqul7I52Qb1dgAT+GhMIbA1xNxVssnBQVoc
+icCMb3SgazNNtQEo/a2tiRc7ppqEvOuM6sRxJKi6KfkIsidWNTJf6jn7MZrVGczw
+-----END CERTIFICATE-----
+
+# Issuer: CN=CommScope Public Trust RSA Root-02 O=CommScope
+# Subject: CN=CommScope Public Trust RSA Root-02 O=CommScope
+# Label: "CommScope Public Trust RSA Root-02"
+# Serial: 480062499834624527752716769107743131258796508494
+# MD5 Fingerprint: e1:29:f9:62:7b:76:e2:96:6d:f3:d4:d7:0f:ae:1f:aa
+# SHA1 Fingerprint: ea:b0:e2:52:1b:89:93:4c:11:68:f2:d8:9a:ac:22:4c:a3:8a:57:ae
+# SHA256 Fingerprint: ff:e9:43:d7:93:42:4b:4f:7c:44:0c:1c:3d:64:8d:53:63:f3:4b:82:dc:87:aa:7a:9f:11:8f:c5:de:e1:01:f1
+-----BEGIN CERTIFICATE-----
+MIIFbDCCA1SgAwIBAgIUVBa/O345lXGN0aoApYYNK496BU4wDQYJKoZIhvcNAQEL
+BQAwTjELMAkGA1UEBhMCVVMxEjAQBgNVBAoMCUNvbW1TY29wZTErMCkGA1UEAwwi
+Q29tbVNjb3BlIFB1YmxpYyBUcnVzdCBSU0EgUm9vdC0wMjAeFw0yMTA0MjgxNzE2
+NDNaFw00NjA0MjgxNzE2NDJaME4xCzAJBgNVBAYTAlVTMRIwEAYDVQQKDAlDb21t
+U2NvcGUxKzApBgNVBAMMIkNvbW1TY29wZSBQdWJsaWMgVHJ1c3QgUlNBIFJvb3Qt
+MDIwggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQDh+g77aAASyE3VrCLE
+NQE7xVTlWXZjpX/rwcRqmL0yjReA61260WI9JSMZNRTpf4mnG2I81lDnNJUDMrG0
+kyI9p+Kx7eZ7Ti6Hmw0zdQreqjXnfuU2mKKuJZ6VszKWpCtYHu8//mI0SFHRtI1C
+rWDaSWqVcN3SAOLMV2MCe5bdSZdbkk6V0/nLKR8YSvgBKtJjCW4k6YnS5cciTNxz
+hkcAqg2Ijq6FfUrpuzNPDlJwnZXjfG2WWy09X6GDRl224yW4fKcZgBzqZUPckXk2
+LHR88mcGyYnJ27/aaL8j7dxrrSiDeS/sOKUNNwFnJ5rpM9kzXzehxfCrPfp4sOcs
+n/Y+n2Dg70jpkEUeBVF4GiwSLFworA2iI540jwXmojPOEXcT1A6kHkIfhs1w/tku
+FT0du7jyU1fbzMZ0KZwYszZ1OC4PVKH4kh+Jlk+71O6d6Ts2QrUKOyrUZHk2EOH5
+kQMreyBUzQ0ZGshBMjTRsJnhkB4BQDa1t/qp5Xd1pCKBXbCL5CcSD1SIxtuFdOa3
+wNemKfrb3vOTlycEVS8KbzfFPROvCgCpLIscgSjX74Yxqa7ybrjKaixUR9gqiC6v
+wQcQeKwRoi9C8DfF8rhW3Q5iLc4tVn5V8qdE9isy9COoR+jUKgF4z2rDN6ieZdIs
+5fq6M8EGRPbmz6UNp2YINIos8wIDAQABo0IwQDAPBgNVHRMBAf8EBTADAQH/MA4G
+A1UdDwEB/wQEAwIBBjAdBgNVHQ4EFgQUR9DnsSL/nSz12Vdgs7GxcJXvYXowDQYJ
+KoZIhvcNAQELBQADggIBAIZpsU0v6Z9PIpNojuQhmaPORVMbc0RTAIFhzTHjCLqB
+KCh6krm2qMhDnscTJk3C2OVVnJJdUNjCK9v+5qiXz1I6JMNlZFxHMaNlNRPDk7n3
++VGXu6TwYofF1gbTl4MgqX67tiHCpQ2EAOHyJxCDut0DgdXdaMNmEMjRdrSzbyme
+APnCKfWxkxlSaRosTKCL4BWaMS/TiJVZbuXEs1DIFAhKm4sTg7GkcrI7djNB3Nyq
+pgdvHSQSn8h2vS/ZjvQs7rfSOBAkNlEv41xdgSGn2rtO/+YHqP65DSdsu3BaVXoT
+6fEqSWnHX4dXTEN5bTpl6TBcQe7rd6VzEojov32u5cSoHw2OHG1QAk8mGEPej1WF
+sQs3BWDJVTkSBKEqz3EWnzZRSb9wO55nnPt7eck5HHisd5FUmrh1CoFSl+NmYWvt
+PjgelmFV4ZFUjO2MJB+ByRCac5krFk5yAD9UG/iNuovnFNa2RU9g7Jauwy8CTl2d
+lklyALKrdVwPaFsdZcJfMw8eD/A7hvWwTruc9+olBdytoptLFwG+Qt81IR2tq670
+v64fG9PiO/yzcnMcmyiQiRM9HcEARwmWmjgb3bHPDcK0RPOWlc4yOo80nOAXx17O
+rg3bhzjlP1v9mxnhMUF6cKojawHhRUzNlM47ni3niAIi9G7oyOzWPPO5std3eqx7
+-----END CERTIFICATE-----
+
+# Issuer: CN=Telekom Security TLS ECC Root 2020 O=Deutsche Telekom Security GmbH
+# Subject: CN=Telekom Security TLS ECC Root 2020 O=Deutsche Telekom Security GmbH
+# Label: "Telekom Security TLS ECC Root 2020"
+# Serial: 72082518505882327255703894282316633856
+# MD5 Fingerprint: c1:ab:fe:6a:10:2c:03:8d:bc:1c:22:32:c0:85:a7:fd
+# SHA1 Fingerprint: c0:f8:96:c5:a9:3b:01:06:21:07:da:18:42:48:bc:e9:9d:88:d5:ec
+# SHA256 Fingerprint: 57:8a:f4:de:d0:85:3f:4e:59:98:db:4a:ea:f9:cb:ea:8d:94:5f:60:b6:20:a3:8d:1a:3c:13:b2:bc:7b:a8:e1
+-----BEGIN CERTIFICATE-----
+MIICQjCCAcmgAwIBAgIQNjqWjMlcsljN0AFdxeVXADAKBggqhkjOPQQDAzBjMQsw
+CQYDVQQGEwJERTEnMCUGA1UECgweRGV1dHNjaGUgVGVsZWtvbSBTZWN1cml0eSBH
+bWJIMSswKQYDVQQDDCJUZWxla29tIFNlY3VyaXR5IFRMUyBFQ0MgUm9vdCAyMDIw
+MB4XDTIwMDgyNTA3NDgyMFoXDTQ1MDgyNTIzNTk1OVowYzELMAkGA1UEBhMCREUx
+JzAlBgNVBAoMHkRldXRzY2hlIFRlbGVrb20gU2VjdXJpdHkgR21iSDErMCkGA1UE
+AwwiVGVsZWtvbSBTZWN1cml0eSBUTFMgRUNDIFJvb3QgMjAyMDB2MBAGByqGSM49
+AgEGBSuBBAAiA2IABM6//leov9Wq9xCazbzREaK9Z0LMkOsVGJDZos0MKiXrPk/O
+tdKPD/M12kOLAoC+b1EkHQ9rK8qfwm9QMuU3ILYg/4gND21Ju9sGpIeQkpT0CdDP
+f8iAC8GXs7s1J8nCG6NCMEAwHQYDVR0OBBYEFONyzG6VmUex5rNhTNHLq+O6zd6f
+MA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgEGMAoGCCqGSM49BAMDA2cA
+MGQCMHVSi7ekEE+uShCLsoRbQuHmKjYC2qBuGT8lv9pZMo7k+5Dck2TOrbRBR2Di
+z6fLHgIwN0GMZt9Ba9aDAEH9L1r3ULRn0SyocddDypwnJJGDSA3PzfdUga/sf+Rn
+27iQ7t0l
+-----END CERTIFICATE-----
+
+# Issuer: CN=Telekom Security TLS RSA Root 2023 O=Deutsche Telekom Security GmbH
+# Subject: CN=Telekom Security TLS RSA Root 2023 O=Deutsche Telekom Security GmbH
+# Label: "Telekom Security TLS RSA Root 2023"
+# Serial: 44676229530606711399881795178081572759
+# MD5 Fingerprint: bf:5b:eb:54:40:cd:48:71:c4:20:8d:7d:de:0a:42:f2
+# SHA1 Fingerprint: 54:d3:ac:b3:bd:57:56:f6:85:9d:ce:e5:c3:21:e2:d4:ad:83:d0:93
+# SHA256 Fingerprint: ef:c6:5c:ad:bb:59:ad:b6:ef:e8:4d:a2:23:11:b3:56:24:b7:1b:3b:1e:a0:da:8b:66:55:17:4e:c8:97:86:46
+-----BEGIN CERTIFICATE-----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+-----END CERTIFICATE-----
+
+# Issuer: CN=FIRMAPROFESIONAL CA ROOT-A WEB O=Firmaprofesional SA
+# Subject: CN=FIRMAPROFESIONAL CA ROOT-A WEB O=Firmaprofesional SA
+# Label: "FIRMAPROFESIONAL CA ROOT-A WEB"
+# Serial: 65916896770016886708751106294915943533
+# MD5 Fingerprint: 82:b2:ad:45:00:82:b0:66:63:f8:5f:c3:67:4e:ce:a3
+# SHA1 Fingerprint: a8:31:11:74:a6:14:15:0d:ca:77:dd:0e:e4:0c:5d:58:fc:a0:72:a5
+# SHA256 Fingerprint: be:f2:56:da:f2:6e:9c:69:bd:ec:16:02:35:97:98:f3:ca:f7:18:21:a0:3e:01:82:57:c5:3c:65:61:7f:3d:4a
+-----BEGIN CERTIFICATE-----
+MIICejCCAgCgAwIBAgIQMZch7a+JQn81QYehZ1ZMbTAKBggqhkjOPQQDAzBuMQsw
+CQYDVQQGEwJFUzEcMBoGA1UECgwTRmlybWFwcm9mZXNpb25hbCBTQTEYMBYGA1UE
+YQwPVkFURVMtQTYyNjM0MDY4MScwJQYDVQQDDB5GSVJNQVBST0ZFU0lPTkFMIENB
+IFJPT1QtQSBXRUIwHhcNMjIwNDA2MDkwMTM2WhcNNDcwMzMxMDkwMTM2WjBuMQsw
+CQYDVQQGEwJFUzEcMBoGA1UECgwTRmlybWFwcm9mZXNpb25hbCBTQTEYMBYGA1UE
+YQwPVkFURVMtQTYyNjM0MDY4MScwJQYDVQQDDB5GSVJNQVBST0ZFU0lPTkFMIENB
+IFJPT1QtQSBXRUIwdjAQBgcqhkjOPQIBBgUrgQQAIgNiAARHU+osEaR3xyrq89Zf
+e9MEkVz6iMYiuYMQYneEMy3pA4jU4DP37XcsSmDq5G+tbbT4TIqk5B/K6k84Si6C
+cyvHZpsKjECcfIr28jlgst7L7Ljkb+qbXbdTkBgyVcUgt5SjYzBhMA8GA1UdEwEB
+/wQFMAMBAf8wHwYDVR0jBBgwFoAUk+FDY1w8ndYn81LsF7Kpryz3dvgwHQYDVR0O
+BBYEFJPhQ2NcPJ3WJ/NS7Beyqa8s93b4MA4GA1UdDwEB/wQEAwIBBjAKBggqhkjO
+PQQDAwNoADBlAjAdfKR7w4l1M+E7qUW/Runpod3JIha3RxEL2Jq68cgLcFBTApFw
+hVmpHqTm6iMxoAACMQD94vizrxa5HnPEluPBMBnYfubDl94cT7iJLzPrSA8Z94dG
+XSaQpYXFuXqUPoeovQA=
+-----END CERTIFICATE-----
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/certifi/core.py b/venv/lib/python3.12/site-packages/pip/_vendor/certifi/core.py
new file mode 100644
index 00000000..70e0c3bd
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_vendor/certifi/core.py
@@ -0,0 +1,114 @@
+"""
+certifi.py
+~~~~~~~~~~
+
+This module returns the installation location of cacert.pem or its contents.
+"""
+import sys
+import atexit
+
+def exit_cacert_ctx() -> None:
+    _CACERT_CTX.__exit__(None, None, None)  # type: ignore[union-attr]
+
+
+if sys.version_info >= (3, 11):
+
+    from importlib.resources import as_file, files
+
+    _CACERT_CTX = None
+    _CACERT_PATH = None
+
+    def where() -> str:
+        # This is slightly terrible, but we want to delay extracting the file
+        # in cases where we're inside of a zipimport situation until someone
+        # actually calls where(), but we don't want to re-extract the file
+        # on every call of where(), so we'll do it once then store it in a
+        # global variable.
+        global _CACERT_CTX
+        global _CACERT_PATH
+        if _CACERT_PATH is None:
+            # This is slightly janky, the importlib.resources API wants you to
+            # manage the cleanup of this file, so it doesn't actually return a
+            # path, it returns a context manager that will give you the path
+            # when you enter it and will do any cleanup when you leave it. In
+            # the common case of not needing a temporary file, it will just
+            # return the file system location and the __exit__() is a no-op.
+            #
+            # We also have to hold onto the actual context manager, because
+            # it will do the cleanup whenever it gets garbage collected, so
+            # we will also store that at the global level as well.
+            _CACERT_CTX = as_file(files("pip._vendor.certifi").joinpath("cacert.pem"))
+            _CACERT_PATH = str(_CACERT_CTX.__enter__())
+            atexit.register(exit_cacert_ctx)
+
+        return _CACERT_PATH
+
+    def contents() -> str:
+        return files("pip._vendor.certifi").joinpath("cacert.pem").read_text(encoding="ascii")
+
+elif sys.version_info >= (3, 7):
+
+    from importlib.resources import path as get_path, read_text
+
+    _CACERT_CTX = None
+    _CACERT_PATH = None
+
+    def where() -> str:
+        # This is slightly terrible, but we want to delay extracting the
+        # file in cases where we're inside of a zipimport situation until
+        # someone actually calls where(), but we don't want to re-extract
+        # the file on every call of where(), so we'll do it once then store
+        # it in a global variable.
+        global _CACERT_CTX
+        global _CACERT_PATH
+        if _CACERT_PATH is None:
+            # This is slightly janky, the importlib.resources API wants you
+            # to manage the cleanup of this file, so it doesn't actually
+            # return a path, it returns a context manager that will give
+            # you the path when you enter it and will do any cleanup when
+            # you leave it. In the common case of not needing a temporary
+            # file, it will just return the file system location and the
+            # __exit__() is a no-op.
+            #
+            # We also have to hold onto the actual context manager, because
+            # it will do the cleanup whenever it gets garbage collected, so
+            # we will also store that at the global level as well.
+            _CACERT_CTX = get_path("pip._vendor.certifi", "cacert.pem")
+            _CACERT_PATH = str(_CACERT_CTX.__enter__())
+            atexit.register(exit_cacert_ctx)
+
+        return _CACERT_PATH
+
+    def contents() -> str:
+        return read_text("pip._vendor.certifi", "cacert.pem", encoding="ascii")
+
+else:
+    import os
+    import types
+    from typing import Union
+
+    Package = Union[types.ModuleType, str]
+    Resource = Union[str, "os.PathLike"]
+
+    # This fallback will work for Python versions prior to 3.7 that lack the
+    # importlib.resources module but relies on the existing `where` function
+    # so won't address issues with environments like PyOxidizer that don't set
+    # __file__ on modules.
+    def read_text(
+        package: Package,
+        resource: Resource,
+        encoding: str = 'utf-8',
+        errors: str = 'strict'
+    ) -> str:
+        with open(where(), encoding=encoding) as data:
+            return data.read()
+
+    # If we don't have importlib.resources, then we will just do the old logic
+    # of assuming we're on the filesystem and munge the path directly.
+    def where() -> str:
+        f = os.path.dirname(__file__)
+
+        return os.path.join(f, "cacert.pem")
+
+    def contents() -> str:
+        return read_text("pip._vendor.certifi", "cacert.pem", encoding="ascii")
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/certifi/py.typed b/venv/lib/python3.12/site-packages/pip/_vendor/certifi/py.typed
new file mode 100644
index 00000000..e69de29b
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/distlib/__init__.py b/venv/lib/python3.12/site-packages/pip/_vendor/distlib/__init__.py
new file mode 100644
index 00000000..e999438f
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_vendor/distlib/__init__.py
@@ -0,0 +1,33 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2012-2023 Vinay Sajip.
+# Licensed to the Python Software Foundation under a contributor agreement.
+# See LICENSE.txt and CONTRIBUTORS.txt.
+#
+import logging
+
+__version__ = '0.3.8'
+
+
+class DistlibException(Exception):
+    pass
+
+
+try:
+    from logging import NullHandler
+except ImportError:  # pragma: no cover
+
+    class NullHandler(logging.Handler):
+
+        def handle(self, record):
+            pass
+
+        def emit(self, record):
+            pass
+
+        def createLock(self):
+            self.lock = None
+
+
+logger = logging.getLogger(__name__)
+logger.addHandler(NullHandler())
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/distlib/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_vendor/distlib/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 00000000..d7aa9aef
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_vendor/distlib/__pycache__/__init__.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/distlib/__pycache__/compat.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_vendor/distlib/__pycache__/compat.cpython-312.pyc
new file mode 100644
index 00000000..4bef5c1a
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_vendor/distlib/__pycache__/compat.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/distlib/__pycache__/database.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_vendor/distlib/__pycache__/database.cpython-312.pyc
new file mode 100644
index 00000000..7fd33f71
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_vendor/distlib/__pycache__/database.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/distlib/__pycache__/index.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_vendor/distlib/__pycache__/index.cpython-312.pyc
new file mode 100644
index 00000000..194ccb84
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_vendor/distlib/__pycache__/index.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/distlib/__pycache__/locators.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_vendor/distlib/__pycache__/locators.cpython-312.pyc
new file mode 100644
index 00000000..b4b4fc81
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_vendor/distlib/__pycache__/locators.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/distlib/__pycache__/manifest.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_vendor/distlib/__pycache__/manifest.cpython-312.pyc
new file mode 100644
index 00000000..dd2488ca
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_vendor/distlib/__pycache__/manifest.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/distlib/__pycache__/markers.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_vendor/distlib/__pycache__/markers.cpython-312.pyc
new file mode 100644
index 00000000..2b5628e7
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_vendor/distlib/__pycache__/markers.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/distlib/__pycache__/metadata.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_vendor/distlib/__pycache__/metadata.cpython-312.pyc
new file mode 100644
index 00000000..bf36797e
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_vendor/distlib/__pycache__/metadata.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/distlib/__pycache__/resources.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_vendor/distlib/__pycache__/resources.cpython-312.pyc
new file mode 100644
index 00000000..f9f30bb8
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_vendor/distlib/__pycache__/resources.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/distlib/__pycache__/scripts.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_vendor/distlib/__pycache__/scripts.cpython-312.pyc
new file mode 100644
index 00000000..10c61206
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_vendor/distlib/__pycache__/scripts.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/distlib/__pycache__/util.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_vendor/distlib/__pycache__/util.cpython-312.pyc
new file mode 100644
index 00000000..efb5d261
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_vendor/distlib/__pycache__/util.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/distlib/__pycache__/version.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_vendor/distlib/__pycache__/version.cpython-312.pyc
new file mode 100644
index 00000000..314309e5
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_vendor/distlib/__pycache__/version.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/distlib/__pycache__/wheel.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_vendor/distlib/__pycache__/wheel.cpython-312.pyc
new file mode 100644
index 00000000..1f52c3e4
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_vendor/distlib/__pycache__/wheel.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/distlib/compat.py b/venv/lib/python3.12/site-packages/pip/_vendor/distlib/compat.py
new file mode 100644
index 00000000..e93dc27a
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_vendor/distlib/compat.py
@@ -0,0 +1,1138 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2013-2017 Vinay Sajip.
+# Licensed to the Python Software Foundation under a contributor agreement.
+# See LICENSE.txt and CONTRIBUTORS.txt.
+#
+from __future__ import absolute_import
+
+import os
+import re
+import shutil
+import sys
+
+try:
+    import ssl
+except ImportError:  # pragma: no cover
+    ssl = None
+
+if sys.version_info[0] < 3:  # pragma: no cover
+    from StringIO import StringIO
+    string_types = basestring,
+    text_type = unicode
+    from types import FileType as file_type
+    import __builtin__ as builtins
+    import ConfigParser as configparser
+    from urlparse import urlparse, urlunparse, urljoin, urlsplit, urlunsplit
+    from urllib import (urlretrieve, quote as _quote, unquote, url2pathname,
+                        pathname2url, ContentTooShortError, splittype)
+
+    def quote(s):
+        if isinstance(s, unicode):
+            s = s.encode('utf-8')
+        return _quote(s)
+
+    import urllib2
+    from urllib2 import (Request, urlopen, URLError, HTTPError,
+                         HTTPBasicAuthHandler, HTTPPasswordMgr, HTTPHandler,
+                         HTTPRedirectHandler, build_opener)
+    if ssl:
+        from urllib2 import HTTPSHandler
+    import httplib
+    import xmlrpclib
+    import Queue as queue
+    from HTMLParser import HTMLParser
+    import htmlentitydefs
+    raw_input = raw_input
+    from itertools import ifilter as filter
+    from itertools import ifilterfalse as filterfalse
+
+    # Leaving this around for now, in case it needs resurrecting in some way
+    # _userprog = None
+    # def splituser(host):
+    # """splituser('user[:passwd]@host[:port]') --> 'user[:passwd]', 'host[:port]'."""
+    # global _userprog
+    # if _userprog is None:
+    # import re
+    # _userprog = re.compile('^(.*)@(.*)$')
+
+    # match = _userprog.match(host)
+    # if match: return match.group(1, 2)
+    # return None, host
+
+else:  # pragma: no cover
+    from io import StringIO
+    string_types = str,
+    text_type = str
+    from io import TextIOWrapper as file_type
+    import builtins
+    import configparser
+    from urllib.parse import (urlparse, urlunparse, urljoin, quote, unquote,
+                              urlsplit, urlunsplit, splittype)
+    from urllib.request import (urlopen, urlretrieve, Request, url2pathname,
+                                pathname2url, HTTPBasicAuthHandler,
+                                HTTPPasswordMgr, HTTPHandler,
+                                HTTPRedirectHandler, build_opener)
+    if ssl:
+        from urllib.request import HTTPSHandler
+    from urllib.error import HTTPError, URLError, ContentTooShortError
+    import http.client as httplib
+    import urllib.request as urllib2
+    import xmlrpc.client as xmlrpclib
+    import queue
+    from html.parser import HTMLParser
+    import html.entities as htmlentitydefs
+    raw_input = input
+    from itertools import filterfalse
+    filter = filter
+
+try:
+    from ssl import match_hostname, CertificateError
+except ImportError:  # pragma: no cover
+
+    class CertificateError(ValueError):
+        pass
+
+    def _dnsname_match(dn, hostname, max_wildcards=1):
+        """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
+
+        parts = dn.split('.')
+        leftmost, remainder = parts[0], 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 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 match_hostname(cert, hostname):
+        """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")
+        dnsnames = []
+        san = cert.get('subjectAltName', ())
+        for key, value in san:
+            if key == 'DNS':
+                if _dnsname_match(value, hostname):
+                    return
+                dnsnames.append(value)
+        if not dnsnames:
+            # The subject is only checked when there is no dNSName entry
+            # in subjectAltName
+            for sub in cert.get('subject', ()):
+                for key, value in sub:
+                    # XXX according to RFC 2818, the most specific Common Name
+                    # must be used.
+                    if key == 'commonName':
+                        if _dnsname_match(value, hostname):
+                            return
+                        dnsnames.append(value)
+        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("hostname %r "
+                                   "doesn't match %r" %
+                                   (hostname, dnsnames[0]))
+        else:
+            raise CertificateError("no appropriate commonName or "
+                                   "subjectAltName fields were found")
+
+
+try:
+    from types import SimpleNamespace as Container
+except ImportError:  # pragma: no cover
+
+    class Container(object):
+        """
+        A generic container for when multiple values need to be returned
+        """
+
+        def __init__(self, **kwargs):
+            self.__dict__.update(kwargs)
+
+
+try:
+    from shutil import which
+except ImportError:  # pragma: no cover
+    # Implementation from Python 3.3
+    def which(cmd, mode=os.F_OK | os.X_OK, path=None):
+        """Given a command, mode, and a PATH string, return the path which
+        conforms to the given mode on the PATH, or None if there is no such
+        file.
+
+        `mode` defaults to os.F_OK | os.X_OK. `path` defaults to the result
+        of os.environ.get("PATH"), or can be overridden with a custom search
+        path.
+
+        """
+
+        # Check that a given file can be accessed with the correct mode.
+        # Additionally check that `file` is not a directory, as on Windows
+        # directories pass the os.access check.
+        def _access_check(fn, mode):
+            return (os.path.exists(fn) and os.access(fn, mode)
+                    and not os.path.isdir(fn))
+
+        # If we're given a path with a directory part, look it up directly rather
+        # than referring to PATH directories. This includes checking relative to the
+        # current directory, e.g. ./script
+        if os.path.dirname(cmd):
+            if _access_check(cmd, mode):
+                return cmd
+            return None
+
+        if path is None:
+            path = os.environ.get("PATH", os.defpath)
+        if not path:
+            return None
+        path = path.split(os.pathsep)
+
+        if sys.platform == "win32":
+            # The current directory takes precedence on Windows.
+            if os.curdir not in path:
+                path.insert(0, os.curdir)
+
+            # PATHEXT is necessary to check on Windows.
+            pathext = os.environ.get("PATHEXT", "").split(os.pathsep)
+            # See if the given file matches any of the expected path extensions.
+            # This will allow us to short circuit when given "python.exe".
+            # If it does match, only test that one, otherwise we have to try
+            # others.
+            if any(cmd.lower().endswith(ext.lower()) for ext in pathext):
+                files = [cmd]
+            else:
+                files = [cmd + ext for ext in pathext]
+        else:
+            # On other platforms you don't have things like PATHEXT to tell you
+            # what file suffixes are executable, so just pass on cmd as-is.
+            files = [cmd]
+
+        seen = set()
+        for dir in path:
+            normdir = os.path.normcase(dir)
+            if normdir not in seen:
+                seen.add(normdir)
+                for thefile in files:
+                    name = os.path.join(dir, thefile)
+                    if _access_check(name, mode):
+                        return name
+        return None
+
+
+# ZipFile is a context manager in 2.7, but not in 2.6
+
+from zipfile import ZipFile as BaseZipFile
+
+if hasattr(BaseZipFile, '__enter__'):  # pragma: no cover
+    ZipFile = BaseZipFile
+else:  # pragma: no cover
+    from zipfile import ZipExtFile as BaseZipExtFile
+
+    class ZipExtFile(BaseZipExtFile):
+
+        def __init__(self, base):
+            self.__dict__.update(base.__dict__)
+
+        def __enter__(self):
+            return self
+
+        def __exit__(self, *exc_info):
+            self.close()
+            # return None, so if an exception occurred, it will propagate
+
+    class ZipFile(BaseZipFile):
+
+        def __enter__(self):
+            return self
+
+        def __exit__(self, *exc_info):
+            self.close()
+            # return None, so if an exception occurred, it will propagate
+
+        def open(self, *args, **kwargs):
+            base = BaseZipFile.open(self, *args, **kwargs)
+            return ZipExtFile(base)
+
+
+try:
+    from platform import python_implementation
+except ImportError:  # pragma: no cover
+
+    def python_implementation():
+        """Return a string identifying the Python implementation."""
+        if 'PyPy' in sys.version:
+            return 'PyPy'
+        if os.name == 'java':
+            return 'Jython'
+        if sys.version.startswith('IronPython'):
+            return 'IronPython'
+        return 'CPython'
+
+
+import sysconfig
+
+try:
+    callable = callable
+except NameError:  # pragma: no cover
+    from collections.abc import Callable
+
+    def callable(obj):
+        return isinstance(obj, Callable)
+
+
+try:
+    fsencode = os.fsencode
+    fsdecode = os.fsdecode
+except AttributeError:  # pragma: no cover
+    # Issue #99: on some systems (e.g. containerised),
+    # sys.getfilesystemencoding() returns None, and we need a real value,
+    # so fall back to utf-8. From the CPython 2.7 docs relating to Unix and
+    # sys.getfilesystemencoding(): the return value is "the user’s preference
+    # according to the result of nl_langinfo(CODESET), or None if the
+    # nl_langinfo(CODESET) failed."
+    _fsencoding = sys.getfilesystemencoding() or 'utf-8'
+    if _fsencoding == 'mbcs':
+        _fserrors = 'strict'
+    else:
+        _fserrors = 'surrogateescape'
+
+    def fsencode(filename):
+        if isinstance(filename, bytes):
+            return filename
+        elif isinstance(filename, text_type):
+            return filename.encode(_fsencoding, _fserrors)
+        else:
+            raise TypeError("expect bytes or str, not %s" %
+                            type(filename).__name__)
+
+    def fsdecode(filename):
+        if isinstance(filename, text_type):
+            return filename
+        elif isinstance(filename, bytes):
+            return filename.decode(_fsencoding, _fserrors)
+        else:
+            raise TypeError("expect bytes or str, not %s" %
+                            type(filename).__name__)
+
+
+try:
+    from tokenize import detect_encoding
+except ImportError:  # pragma: no cover
+    from codecs import BOM_UTF8, lookup
+
+    cookie_re = re.compile(r"coding[:=]\s*([-\w.]+)")
+
+    def _get_normal_name(orig_enc):
+        """Imitates get_normal_name in tokenizer.c."""
+        # Only care about the first 12 characters.
+        enc = orig_enc[:12].lower().replace("_", "-")
+        if enc == "utf-8" or enc.startswith("utf-8-"):
+            return "utf-8"
+        if enc in ("latin-1", "iso-8859-1", "iso-latin-1") or \
+           enc.startswith(("latin-1-", "iso-8859-1-", "iso-latin-1-")):
+            return "iso-8859-1"
+        return orig_enc
+
+    def detect_encoding(readline):
+        """
+        The detect_encoding() function is used to detect the encoding that should
+        be used to decode a Python source file.  It requires one argument, readline,
+        in the same way as the tokenize() generator.
+
+        It will call readline a maximum of twice, and return the encoding used
+        (as a string) and a list of any lines (left as bytes) it has read in.
+
+        It detects the encoding from the presence of a utf-8 bom or an encoding
+        cookie as specified in pep-0263.  If both a bom and a cookie are present,
+        but disagree, a SyntaxError will be raised.  If the encoding cookie is an
+        invalid charset, raise a SyntaxError.  Note that if a utf-8 bom is found,
+        'utf-8-sig' is returned.
+
+        If no encoding is specified, then the default of 'utf-8' will be returned.
+        """
+        try:
+            filename = readline.__self__.name
+        except AttributeError:
+            filename = None
+        bom_found = False
+        encoding = None
+        default = 'utf-8'
+
+        def read_or_stop():
+            try:
+                return readline()
+            except StopIteration:
+                return b''
+
+        def find_cookie(line):
+            try:
+                # Decode as UTF-8. Either the line is an encoding declaration,
+                # in which case it should be pure ASCII, or it must be UTF-8
+                # per default encoding.
+                line_string = line.decode('utf-8')
+            except UnicodeDecodeError:
+                msg = "invalid or missing encoding declaration"
+                if filename is not None:
+                    msg = '{} for {!r}'.format(msg, filename)
+                raise SyntaxError(msg)
+
+            matches = cookie_re.findall(line_string)
+            if not matches:
+                return None
+            encoding = _get_normal_name(matches[0])
+            try:
+                codec = lookup(encoding)
+            except LookupError:
+                # This behaviour mimics the Python interpreter
+                if filename is None:
+                    msg = "unknown encoding: " + encoding
+                else:
+                    msg = "unknown encoding for {!r}: {}".format(
+                        filename, encoding)
+                raise SyntaxError(msg)
+
+            if bom_found:
+                if codec.name != 'utf-8':
+                    # This behaviour mimics the Python interpreter
+                    if filename is None:
+                        msg = 'encoding problem: utf-8'
+                    else:
+                        msg = 'encoding problem for {!r}: utf-8'.format(
+                            filename)
+                    raise SyntaxError(msg)
+                encoding += '-sig'
+            return encoding
+
+        first = read_or_stop()
+        if first.startswith(BOM_UTF8):
+            bom_found = True
+            first = first[3:]
+            default = 'utf-8-sig'
+        if not first:
+            return default, []
+
+        encoding = find_cookie(first)
+        if encoding:
+            return encoding, [first]
+
+        second = read_or_stop()
+        if not second:
+            return default, [first]
+
+        encoding = find_cookie(second)
+        if encoding:
+            return encoding, [first, second]
+
+        return default, [first, second]
+
+
+# For converting & <-> & etc.
+try:
+    from html import escape
+except ImportError:
+    from cgi import escape
+if sys.version_info[:2] < (3, 4):
+    unescape = HTMLParser().unescape
+else:
+    from html import unescape
+
+try:
+    from collections import ChainMap
+except ImportError:  # pragma: no cover
+    from collections import MutableMapping
+
+    try:
+        from reprlib import recursive_repr as _recursive_repr
+    except ImportError:
+
+        def _recursive_repr(fillvalue='...'):
+            '''
+            Decorator to make a repr function return fillvalue for a recursive
+            call
+            '''
+
+            def decorating_function(user_function):
+                repr_running = set()
+
+                def wrapper(self):
+                    key = id(self), get_ident()
+                    if key in repr_running:
+                        return fillvalue
+                    repr_running.add(key)
+                    try:
+                        result = user_function(self)
+                    finally:
+                        repr_running.discard(key)
+                    return result
+
+                # Can't use functools.wraps() here because of bootstrap issues
+                wrapper.__module__ = getattr(user_function, '__module__')
+                wrapper.__doc__ = getattr(user_function, '__doc__')
+                wrapper.__name__ = getattr(user_function, '__name__')
+                wrapper.__annotations__ = getattr(user_function,
+                                                  '__annotations__', {})
+                return wrapper
+
+            return decorating_function
+
+    class ChainMap(MutableMapping):
+        '''
+        A ChainMap groups multiple dicts (or other mappings) together
+        to create a single, updateable view.
+
+        The underlying mappings are stored in a list.  That list is public and can
+        accessed or updated using the *maps* attribute.  There is no other state.
+
+        Lookups search the underlying mappings successively until a key is found.
+        In contrast, writes, updates, and deletions only operate on the first
+        mapping.
+        '''
+
+        def __init__(self, *maps):
+            '''Initialize a ChainMap by setting *maps* to the given mappings.
+            If no mappings are provided, a single empty dictionary is used.
+
+            '''
+            self.maps = list(maps) or [{}]  # always at least one map
+
+        def __missing__(self, key):
+            raise KeyError(key)
+
+        def __getitem__(self, key):
+            for mapping in self.maps:
+                try:
+                    return mapping[
+                        key]  # can't use 'key in mapping' with defaultdict
+                except KeyError:
+                    pass
+            return self.__missing__(
+                key)  # support subclasses that define __missing__
+
+        def get(self, key, default=None):
+            return self[key] if key in self else default
+
+        def __len__(self):
+            return len(set().union(
+                *self.maps))  # reuses stored hash values if possible
+
+        def __iter__(self):
+            return iter(set().union(*self.maps))
+
+        def __contains__(self, key):
+            return any(key in m for m in self.maps)
+
+        def __bool__(self):
+            return any(self.maps)
+
+        @_recursive_repr()
+        def __repr__(self):
+            return '{0.__class__.__name__}({1})'.format(
+                self, ', '.join(map(repr, self.maps)))
+
+        @classmethod
+        def fromkeys(cls, iterable, *args):
+            'Create a ChainMap with a single dict created from the iterable.'
+            return cls(dict.fromkeys(iterable, *args))
+
+        def copy(self):
+            'New ChainMap or subclass with a new copy of maps[0] and refs to maps[1:]'
+            return self.__class__(self.maps[0].copy(), *self.maps[1:])
+
+        __copy__ = copy
+
+        def new_child(self):  # like Django's Context.push()
+            'New ChainMap with a new dict followed by all previous maps.'
+            return self.__class__({}, *self.maps)
+
+        @property
+        def parents(self):  # like Django's Context.pop()
+            'New ChainMap from maps[1:].'
+            return self.__class__(*self.maps[1:])
+
+        def __setitem__(self, key, value):
+            self.maps[0][key] = value
+
+        def __delitem__(self, key):
+            try:
+                del self.maps[0][key]
+            except KeyError:
+                raise KeyError(
+                    'Key not found in the first mapping: {!r}'.format(key))
+
+        def popitem(self):
+            'Remove and return an item pair from maps[0]. Raise KeyError is maps[0] is empty.'
+            try:
+                return self.maps[0].popitem()
+            except KeyError:
+                raise KeyError('No keys found in the first mapping.')
+
+        def pop(self, key, *args):
+            'Remove *key* from maps[0] and return its value. Raise KeyError if *key* not in maps[0].'
+            try:
+                return self.maps[0].pop(key, *args)
+            except KeyError:
+                raise KeyError(
+                    'Key not found in the first mapping: {!r}'.format(key))
+
+        def clear(self):
+            'Clear maps[0], leaving maps[1:] intact.'
+            self.maps[0].clear()
+
+
+try:
+    from importlib.util import cache_from_source  # Python >= 3.4
+except ImportError:  # pragma: no cover
+
+    def cache_from_source(path, debug_override=None):
+        assert path.endswith('.py')
+        if debug_override is None:
+            debug_override = __debug__
+        if debug_override:
+            suffix = 'c'
+        else:
+            suffix = 'o'
+        return path + suffix
+
+
+try:
+    from collections import OrderedDict
+except ImportError:  # pragma: no cover
+    # {{{ http://code.activestate.com/recipes/576693/ (r9)
+    # Backport of OrderedDict() class that runs on Python 2.4, 2.5, 2.6, 2.7 and pypy.
+    # Passes Python2.7's test suite and incorporates all the latest updates.
+    try:
+        from thread import get_ident as _get_ident
+    except ImportError:
+        from dummy_thread import get_ident as _get_ident
+
+    try:
+        from _abcoll import KeysView, ValuesView, ItemsView
+    except ImportError:
+        pass
+
+    class OrderedDict(dict):
+        'Dictionary that remembers insertion order'
+
+        # An inherited dict maps keys to values.
+        # The inherited dict provides __getitem__, __len__, __contains__, and get.
+        # The remaining methods are order-aware.
+        # Big-O running times for all methods are the same as for regular dictionaries.
+
+        # The internal self.__map dictionary maps keys to links in a doubly linked list.
+        # The circular doubly linked list starts and ends with a sentinel element.
+        # The sentinel element never gets deleted (this simplifies the algorithm).
+        # Each link is stored as a list of length three:  [PREV, NEXT, KEY].
+
+        def __init__(self, *args, **kwds):
+            '''Initialize an ordered dictionary.  Signature is the same as for
+            regular dictionaries, but keyword arguments are not recommended
+            because their insertion order is arbitrary.
+
+            '''
+            if len(args) > 1:
+                raise TypeError('expected at most 1 arguments, got %d' %
+                                len(args))
+            try:
+                self.__root
+            except AttributeError:
+                self.__root = root = []  # sentinel node
+                root[:] = [root, root, None]
+                self.__map = {}
+            self.__update(*args, **kwds)
+
+        def __setitem__(self, key, value, dict_setitem=dict.__setitem__):
+            'od.__setitem__(i, y) <==> od[i]=y'
+            # Setting a new item creates a new link which goes at the end of the linked
+            # list, and the inherited dictionary is updated with the new key/value pair.
+            if key not in self:
+                root = self.__root
+                last = root[0]
+                last[1] = root[0] = self.__map[key] = [last, root, key]
+            dict_setitem(self, key, value)
+
+        def __delitem__(self, key, dict_delitem=dict.__delitem__):
+            'od.__delitem__(y) <==> del od[y]'
+            # Deleting an existing item uses self.__map to find the link which is
+            # then removed by updating the links in the predecessor and successor nodes.
+            dict_delitem(self, key)
+            link_prev, link_next, key = self.__map.pop(key)
+            link_prev[1] = link_next
+            link_next[0] = link_prev
+
+        def __iter__(self):
+            'od.__iter__() <==> iter(od)'
+            root = self.__root
+            curr = root[1]
+            while curr is not root:
+                yield curr[2]
+                curr = curr[1]
+
+        def __reversed__(self):
+            'od.__reversed__() <==> reversed(od)'
+            root = self.__root
+            curr = root[0]
+            while curr is not root:
+                yield curr[2]
+                curr = curr[0]
+
+        def clear(self):
+            'od.clear() -> None.  Remove all items from od.'
+            try:
+                for node in self.__map.itervalues():
+                    del node[:]
+                root = self.__root
+                root[:] = [root, root, None]
+                self.__map.clear()
+            except AttributeError:
+                pass
+            dict.clear(self)
+
+        def popitem(self, last=True):
+            '''od.popitem() -> (k, v), return and remove a (key, value) pair.
+            Pairs are returned in LIFO order if last is true or FIFO order if false.
+
+            '''
+            if not self:
+                raise KeyError('dictionary is empty')
+            root = self.__root
+            if last:
+                link = root[0]
+                link_prev = link[0]
+                link_prev[1] = root
+                root[0] = link_prev
+            else:
+                link = root[1]
+                link_next = link[1]
+                root[1] = link_next
+                link_next[0] = root
+            key = link[2]
+            del self.__map[key]
+            value = dict.pop(self, key)
+            return key, value
+
+        # -- the following methods do not depend on the internal structure --
+
+        def keys(self):
+            'od.keys() -> list of keys in od'
+            return list(self)
+
+        def values(self):
+            'od.values() -> list of values in od'
+            return [self[key] for key in self]
+
+        def items(self):
+            'od.items() -> list of (key, value) pairs in od'
+            return [(key, self[key]) for key in self]
+
+        def iterkeys(self):
+            'od.iterkeys() -> an iterator over the keys in od'
+            return iter(self)
+
+        def itervalues(self):
+            'od.itervalues -> an iterator over the values in od'
+            for k in self:
+                yield self[k]
+
+        def iteritems(self):
+            'od.iteritems -> an iterator over the (key, value) items in od'
+            for k in self:
+                yield (k, self[k])
+
+        def update(*args, **kwds):
+            '''od.update(E, **F) -> None.  Update od from dict/iterable E and F.
+
+            If E is a dict instance, does:           for k in E: od[k] = E[k]
+            If E has a .keys() method, does:         for k in E.keys(): od[k] = E[k]
+            Or if E is an iterable of items, does:   for k, v in E: od[k] = v
+            In either case, this is followed by:     for k, v in F.items(): od[k] = v
+
+            '''
+            if len(args) > 2:
+                raise TypeError('update() takes at most 2 positional '
+                                'arguments (%d given)' % (len(args), ))
+            elif not args:
+                raise TypeError('update() takes at least 1 argument (0 given)')
+            self = args[0]
+            # Make progressively weaker assumptions about "other"
+            other = ()
+            if len(args) == 2:
+                other = args[1]
+            if isinstance(other, dict):
+                for key in other:
+                    self[key] = other[key]
+            elif hasattr(other, 'keys'):
+                for key in other.keys():
+                    self[key] = other[key]
+            else:
+                for key, value in other:
+                    self[key] = value
+            for key, value in kwds.items():
+                self[key] = value
+
+        __update = update  # let subclasses override update without breaking __init__
+
+        __marker = object()
+
+        def pop(self, key, default=__marker):
+            '''od.pop(k[,d]) -> v, remove specified key and return the corresponding value.
+            If key is not found, d is returned if given, otherwise KeyError is raised.
+
+            '''
+            if key in self:
+                result = self[key]
+                del self[key]
+                return result
+            if default is self.__marker:
+                raise KeyError(key)
+            return default
+
+        def setdefault(self, key, default=None):
+            'od.setdefault(k[,d]) -> od.get(k,d), also set od[k]=d if k not in od'
+            if key in self:
+                return self[key]
+            self[key] = default
+            return default
+
+        def __repr__(self, _repr_running=None):
+            'od.__repr__() <==> repr(od)'
+            if not _repr_running:
+                _repr_running = {}
+            call_key = id(self), _get_ident()
+            if call_key in _repr_running:
+                return '...'
+            _repr_running[call_key] = 1
+            try:
+                if not self:
+                    return '%s()' % (self.__class__.__name__, )
+                return '%s(%r)' % (self.__class__.__name__, self.items())
+            finally:
+                del _repr_running[call_key]
+
+        def __reduce__(self):
+            'Return state information for pickling'
+            items = [[k, self[k]] for k in self]
+            inst_dict = vars(self).copy()
+            for k in vars(OrderedDict()):
+                inst_dict.pop(k, None)
+            if inst_dict:
+                return (self.__class__, (items, ), inst_dict)
+            return self.__class__, (items, )
+
+        def copy(self):
+            'od.copy() -> a shallow copy of od'
+            return self.__class__(self)
+
+        @classmethod
+        def fromkeys(cls, iterable, value=None):
+            '''OD.fromkeys(S[, v]) -> New ordered dictionary with keys from S
+            and values equal to v (which defaults to None).
+
+            '''
+            d = cls()
+            for key in iterable:
+                d[key] = value
+            return d
+
+        def __eq__(self, other):
+            '''od.__eq__(y) <==> od==y.  Comparison to another OD is order-sensitive
+            while comparison to a regular mapping is order-insensitive.
+
+            '''
+            if isinstance(other, OrderedDict):
+                return len(self) == len(
+                    other) and self.items() == other.items()
+            return dict.__eq__(self, other)
+
+        def __ne__(self, other):
+            return not self == other
+
+        # -- the following methods are only used in Python 2.7 --
+
+        def viewkeys(self):
+            "od.viewkeys() -> a set-like object providing a view on od's keys"
+            return KeysView(self)
+
+        def viewvalues(self):
+            "od.viewvalues() -> an object providing a view on od's values"
+            return ValuesView(self)
+
+        def viewitems(self):
+            "od.viewitems() -> a set-like object providing a view on od's items"
+            return ItemsView(self)
+
+
+try:
+    from logging.config import BaseConfigurator, valid_ident
+except ImportError:  # pragma: no cover
+    IDENTIFIER = re.compile('^[a-z_][a-z0-9_]*$', re.I)
+
+    def valid_ident(s):
+        m = IDENTIFIER.match(s)
+        if not m:
+            raise ValueError('Not a valid Python identifier: %r' % s)
+        return True
+
+    # The ConvertingXXX classes are wrappers around standard Python containers,
+    # and they serve to convert any suitable values in the container. The
+    # conversion converts base dicts, lists and tuples to their wrapped
+    # equivalents, whereas strings which match a conversion format are converted
+    # appropriately.
+    #
+    # Each wrapper should have a configurator attribute holding the actual
+    # configurator to use for conversion.
+
+    class ConvertingDict(dict):
+        """A converting dictionary wrapper."""
+
+        def __getitem__(self, key):
+            value = dict.__getitem__(self, key)
+            result = self.configurator.convert(value)
+            # If the converted value is different, save for next time
+            if value is not result:
+                self[key] = result
+                if type(result) in (ConvertingDict, ConvertingList,
+                                    ConvertingTuple):
+                    result.parent = self
+                    result.key = key
+            return result
+
+        def get(self, key, default=None):
+            value = dict.get(self, key, default)
+            result = self.configurator.convert(value)
+            # If the converted value is different, save for next time
+            if value is not result:
+                self[key] = result
+                if type(result) in (ConvertingDict, ConvertingList,
+                                    ConvertingTuple):
+                    result.parent = self
+                    result.key = key
+            return result
+
+    def pop(self, key, default=None):
+        value = dict.pop(self, key, default)
+        result = self.configurator.convert(value)
+        if value is not result:
+            if type(result) in (ConvertingDict, ConvertingList,
+                                ConvertingTuple):
+                result.parent = self
+                result.key = key
+        return result
+
+    class ConvertingList(list):
+        """A converting list wrapper."""
+
+        def __getitem__(self, key):
+            value = list.__getitem__(self, key)
+            result = self.configurator.convert(value)
+            # If the converted value is different, save for next time
+            if value is not result:
+                self[key] = result
+                if type(result) in (ConvertingDict, ConvertingList,
+                                    ConvertingTuple):
+                    result.parent = self
+                    result.key = key
+            return result
+
+        def pop(self, idx=-1):
+            value = list.pop(self, idx)
+            result = self.configurator.convert(value)
+            if value is not result:
+                if type(result) in (ConvertingDict, ConvertingList,
+                                    ConvertingTuple):
+                    result.parent = self
+            return result
+
+    class ConvertingTuple(tuple):
+        """A converting tuple wrapper."""
+
+        def __getitem__(self, key):
+            value = tuple.__getitem__(self, key)
+            result = self.configurator.convert(value)
+            if value is not result:
+                if type(result) in (ConvertingDict, ConvertingList,
+                                    ConvertingTuple):
+                    result.parent = self
+                    result.key = key
+            return result
+
+    class BaseConfigurator(object):
+        """
+        The configurator base class which defines some useful defaults.
+        """
+
+        CONVERT_PATTERN = re.compile(r'^(?P[a-z]+)://(?P.*)$')
+
+        WORD_PATTERN = re.compile(r'^\s*(\w+)\s*')
+        DOT_PATTERN = re.compile(r'^\.\s*(\w+)\s*')
+        INDEX_PATTERN = re.compile(r'^\[\s*(\w+)\s*\]\s*')
+        DIGIT_PATTERN = re.compile(r'^\d+$')
+
+        value_converters = {
+            'ext': 'ext_convert',
+            'cfg': 'cfg_convert',
+        }
+
+        # We might want to use a different one, e.g. importlib
+        importer = staticmethod(__import__)
+
+        def __init__(self, config):
+            self.config = ConvertingDict(config)
+            self.config.configurator = self
+
+        def resolve(self, s):
+            """
+            Resolve strings to objects using standard import and attribute
+            syntax.
+            """
+            name = s.split('.')
+            used = name.pop(0)
+            try:
+                found = self.importer(used)
+                for frag in name:
+                    used += '.' + frag
+                    try:
+                        found = getattr(found, frag)
+                    except AttributeError:
+                        self.importer(used)
+                        found = getattr(found, frag)
+                return found
+            except ImportError:
+                e, tb = sys.exc_info()[1:]
+                v = ValueError('Cannot resolve %r: %s' % (s, e))
+                v.__cause__, v.__traceback__ = e, tb
+                raise v
+
+        def ext_convert(self, value):
+            """Default converter for the ext:// protocol."""
+            return self.resolve(value)
+
+        def cfg_convert(self, value):
+            """Default converter for the cfg:// protocol."""
+            rest = value
+            m = self.WORD_PATTERN.match(rest)
+            if m is None:
+                raise ValueError("Unable to convert %r" % value)
+            else:
+                rest = rest[m.end():]
+                d = self.config[m.groups()[0]]
+                while rest:
+                    m = self.DOT_PATTERN.match(rest)
+                    if m:
+                        d = d[m.groups()[0]]
+                    else:
+                        m = self.INDEX_PATTERN.match(rest)
+                        if m:
+                            idx = m.groups()[0]
+                            if not self.DIGIT_PATTERN.match(idx):
+                                d = d[idx]
+                            else:
+                                try:
+                                    n = int(
+                                        idx
+                                    )  # try as number first (most likely)
+                                    d = d[n]
+                                except TypeError:
+                                    d = d[idx]
+                    if m:
+                        rest = rest[m.end():]
+                    else:
+                        raise ValueError('Unable to convert '
+                                         '%r at %r' % (value, rest))
+            # rest should be empty
+            return d
+
+        def convert(self, value):
+            """
+            Convert values to an appropriate type. dicts, lists and tuples are
+            replaced by their converting alternatives. Strings are checked to
+            see if they have a conversion format and are converted if they do.
+            """
+            if not isinstance(value, ConvertingDict) and isinstance(
+                    value, dict):
+                value = ConvertingDict(value)
+                value.configurator = self
+            elif not isinstance(value, ConvertingList) and isinstance(
+                    value, list):
+                value = ConvertingList(value)
+                value.configurator = self
+            elif not isinstance(value, ConvertingTuple) and isinstance(value, tuple):
+                value = ConvertingTuple(value)
+                value.configurator = self
+            elif isinstance(value, string_types):
+                m = self.CONVERT_PATTERN.match(value)
+                if m:
+                    d = m.groupdict()
+                    prefix = d['prefix']
+                    converter = self.value_converters.get(prefix, None)
+                    if converter:
+                        suffix = d['suffix']
+                        converter = getattr(self, converter)
+                        value = converter(suffix)
+            return value
+
+        def configure_custom(self, config):
+            """Configure an object with a user-supplied factory."""
+            c = config.pop('()')
+            if not callable(c):
+                c = self.resolve(c)
+            props = config.pop('.', None)
+            # Check for valid identifiers
+            kwargs = dict([(k, config[k]) for k in config if valid_ident(k)])
+            result = c(**kwargs)
+            if props:
+                for name, value in props.items():
+                    setattr(result, name, value)
+            return result
+
+        def as_tuple(self, value):
+            """Utility function which converts lists to tuples."""
+            if isinstance(value, list):
+                value = tuple(value)
+            return value
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/distlib/database.py b/venv/lib/python3.12/site-packages/pip/_vendor/distlib/database.py
new file mode 100644
index 00000000..eb3765f1
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_vendor/distlib/database.py
@@ -0,0 +1,1359 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2012-2023 The Python Software Foundation.
+# See LICENSE.txt and CONTRIBUTORS.txt.
+#
+"""PEP 376 implementation."""
+
+from __future__ import unicode_literals
+
+import base64
+import codecs
+import contextlib
+import hashlib
+import logging
+import os
+import posixpath
+import sys
+import zipimport
+
+from . import DistlibException, resources
+from .compat import StringIO
+from .version import get_scheme, UnsupportedVersionError
+from .metadata import (Metadata, METADATA_FILENAME, WHEEL_METADATA_FILENAME,
+                       LEGACY_METADATA_FILENAME)
+from .util import (parse_requirement, cached_property, parse_name_and_version,
+                   read_exports, write_exports, CSVReader, CSVWriter)
+
+__all__ = [
+    'Distribution', 'BaseInstalledDistribution', 'InstalledDistribution',
+    'EggInfoDistribution', 'DistributionPath'
+]
+
+logger = logging.getLogger(__name__)
+
+EXPORTS_FILENAME = 'pydist-exports.json'
+COMMANDS_FILENAME = 'pydist-commands.json'
+
+DIST_FILES = ('INSTALLER', METADATA_FILENAME, 'RECORD', 'REQUESTED',
+              'RESOURCES', EXPORTS_FILENAME, 'SHARED')
+
+DISTINFO_EXT = '.dist-info'
+
+
+class _Cache(object):
+    """
+    A simple cache mapping names and .dist-info paths to distributions
+    """
+
+    def __init__(self):
+        """
+        Initialise an instance. There is normally one for each DistributionPath.
+        """
+        self.name = {}
+        self.path = {}
+        self.generated = False
+
+    def clear(self):
+        """
+        Clear the cache, setting it to its initial state.
+        """
+        self.name.clear()
+        self.path.clear()
+        self.generated = False
+
+    def add(self, dist):
+        """
+        Add a distribution to the cache.
+        :param dist: The distribution to add.
+        """
+        if dist.path not in self.path:
+            self.path[dist.path] = dist
+            self.name.setdefault(dist.key, []).append(dist)
+
+
+class DistributionPath(object):
+    """
+    Represents a set of distributions installed on a path (typically sys.path).
+    """
+
+    def __init__(self, path=None, include_egg=False):
+        """
+        Create an instance from a path, optionally including legacy (distutils/
+        setuptools/distribute) distributions.
+        :param path: The path to use, as a list of directories. If not specified,
+                     sys.path is used.
+        :param include_egg: If True, this instance will look for and return legacy
+                            distributions as well as those based on PEP 376.
+        """
+        if path is None:
+            path = sys.path
+        self.path = path
+        self._include_dist = True
+        self._include_egg = include_egg
+
+        self._cache = _Cache()
+        self._cache_egg = _Cache()
+        self._cache_enabled = True
+        self._scheme = get_scheme('default')
+
+    def _get_cache_enabled(self):
+        return self._cache_enabled
+
+    def _set_cache_enabled(self, value):
+        self._cache_enabled = value
+
+    cache_enabled = property(_get_cache_enabled, _set_cache_enabled)
+
+    def clear_cache(self):
+        """
+        Clears the internal cache.
+        """
+        self._cache.clear()
+        self._cache_egg.clear()
+
+    def _yield_distributions(self):
+        """
+        Yield .dist-info and/or .egg(-info) distributions.
+        """
+        # We need to check if we've seen some resources already, because on
+        # some Linux systems (e.g. some Debian/Ubuntu variants) there are
+        # symlinks which alias other files in the environment.
+        seen = set()
+        for path in self.path:
+            finder = resources.finder_for_path(path)
+            if finder is None:
+                continue
+            r = finder.find('')
+            if not r or not r.is_container:
+                continue
+            rset = sorted(r.resources)
+            for entry in rset:
+                r = finder.find(entry)
+                if not r or r.path in seen:
+                    continue
+                try:
+                    if self._include_dist and entry.endswith(DISTINFO_EXT):
+                        possible_filenames = [
+                            METADATA_FILENAME, WHEEL_METADATA_FILENAME,
+                            LEGACY_METADATA_FILENAME
+                        ]
+                        for metadata_filename in possible_filenames:
+                            metadata_path = posixpath.join(
+                                entry, metadata_filename)
+                            pydist = finder.find(metadata_path)
+                            if pydist:
+                                break
+                        else:
+                            continue
+
+                        with contextlib.closing(pydist.as_stream()) as stream:
+                            metadata = Metadata(fileobj=stream,
+                                                scheme='legacy')
+                        logger.debug('Found %s', r.path)
+                        seen.add(r.path)
+                        yield new_dist_class(r.path,
+                                             metadata=metadata,
+                                             env=self)
+                    elif self._include_egg and entry.endswith(
+                            ('.egg-info', '.egg')):
+                        logger.debug('Found %s', r.path)
+                        seen.add(r.path)
+                        yield old_dist_class(r.path, self)
+                except Exception as e:
+                    msg = 'Unable to read distribution at %s, perhaps due to bad metadata: %s'
+                    logger.warning(msg, r.path, e)
+                    import warnings
+                    warnings.warn(msg % (r.path, e), stacklevel=2)
+
+    def _generate_cache(self):
+        """
+        Scan the path for distributions and populate the cache with
+        those that are found.
+        """
+        gen_dist = not self._cache.generated
+        gen_egg = self._include_egg and not self._cache_egg.generated
+        if gen_dist or gen_egg:
+            for dist in self._yield_distributions():
+                if isinstance(dist, InstalledDistribution):
+                    self._cache.add(dist)
+                else:
+                    self._cache_egg.add(dist)
+
+            if gen_dist:
+                self._cache.generated = True
+            if gen_egg:
+                self._cache_egg.generated = True
+
+    @classmethod
+    def distinfo_dirname(cls, name, version):
+        """
+        The *name* and *version* parameters are converted into their
+        filename-escaped form, i.e. any ``'-'`` characters are replaced
+        with ``'_'`` other than the one in ``'dist-info'`` and the one
+        separating the name from the version number.
+
+        :parameter name: is converted to a standard distribution name by replacing
+                         any runs of non- alphanumeric characters with a single
+                         ``'-'``.
+        :type name: string
+        :parameter version: is converted to a standard version string. Spaces
+                            become dots, and all other non-alphanumeric characters
+                            (except dots) become dashes, with runs of multiple
+                            dashes condensed to a single dash.
+        :type version: string
+        :returns: directory name
+        :rtype: string"""
+        name = name.replace('-', '_')
+        return '-'.join([name, version]) + DISTINFO_EXT
+
+    def get_distributions(self):
+        """
+        Provides an iterator that looks for distributions and returns
+        :class:`InstalledDistribution` or
+        :class:`EggInfoDistribution` instances for each one of them.
+
+        :rtype: iterator of :class:`InstalledDistribution` and
+                :class:`EggInfoDistribution` instances
+        """
+        if not self._cache_enabled:
+            for dist in self._yield_distributions():
+                yield dist
+        else:
+            self._generate_cache()
+
+            for dist in self._cache.path.values():
+                yield dist
+
+            if self._include_egg:
+                for dist in self._cache_egg.path.values():
+                    yield dist
+
+    def get_distribution(self, name):
+        """
+        Looks for a named distribution on the path.
+
+        This function only returns the first result found, as no more than one
+        value is expected. If nothing is found, ``None`` is returned.
+
+        :rtype: :class:`InstalledDistribution`, :class:`EggInfoDistribution`
+                or ``None``
+        """
+        result = None
+        name = name.lower()
+        if not self._cache_enabled:
+            for dist in self._yield_distributions():
+                if dist.key == name:
+                    result = dist
+                    break
+        else:
+            self._generate_cache()
+
+            if name in self._cache.name:
+                result = self._cache.name[name][0]
+            elif self._include_egg and name in self._cache_egg.name:
+                result = self._cache_egg.name[name][0]
+        return result
+
+    def provides_distribution(self, name, version=None):
+        """
+        Iterates over all distributions to find which distributions provide *name*.
+        If a *version* is provided, it will be used to filter the results.
+
+        This function only returns the first result found, since no more than
+        one values are expected. If the directory is not found, returns ``None``.
+
+        :parameter version: a version specifier that indicates the version
+                            required, conforming to the format in ``PEP-345``
+
+        :type name: string
+        :type version: string
+        """
+        matcher = None
+        if version is not None:
+            try:
+                matcher = self._scheme.matcher('%s (%s)' % (name, version))
+            except ValueError:
+                raise DistlibException('invalid name or version: %r, %r' %
+                                       (name, version))
+
+        for dist in self.get_distributions():
+            # We hit a problem on Travis where enum34 was installed and doesn't
+            # have a provides attribute ...
+            if not hasattr(dist, 'provides'):
+                logger.debug('No "provides": %s', dist)
+            else:
+                provided = dist.provides
+
+                for p in provided:
+                    p_name, p_ver = parse_name_and_version(p)
+                    if matcher is None:
+                        if p_name == name:
+                            yield dist
+                            break
+                    else:
+                        if p_name == name and matcher.match(p_ver):
+                            yield dist
+                            break
+
+    def get_file_path(self, name, relative_path):
+        """
+        Return the path to a resource file.
+        """
+        dist = self.get_distribution(name)
+        if dist is None:
+            raise LookupError('no distribution named %r found' % name)
+        return dist.get_resource_path(relative_path)
+
+    def get_exported_entries(self, category, name=None):
+        """
+        Return all of the exported entries in a particular category.
+
+        :param category: The category to search for entries.
+        :param name: If specified, only entries with that name are returned.
+        """
+        for dist in self.get_distributions():
+            r = dist.exports
+            if category in r:
+                d = r[category]
+                if name is not None:
+                    if name in d:
+                        yield d[name]
+                else:
+                    for v in d.values():
+                        yield v
+
+
+class Distribution(object):
+    """
+    A base class for distributions, whether installed or from indexes.
+    Either way, it must have some metadata, so that's all that's needed
+    for construction.
+    """
+
+    build_time_dependency = False
+    """
+    Set to True if it's known to be only a build-time dependency (i.e.
+    not needed after installation).
+    """
+
+    requested = False
+    """A boolean that indicates whether the ``REQUESTED`` metadata file is
+    present (in other words, whether the package was installed by user
+    request or it was installed as a dependency)."""
+
+    def __init__(self, metadata):
+        """
+        Initialise an instance.
+        :param metadata: The instance of :class:`Metadata` describing this
+        distribution.
+        """
+        self.metadata = metadata
+        self.name = metadata.name
+        self.key = self.name.lower()  # for case-insensitive comparisons
+        self.version = metadata.version
+        self.locator = None
+        self.digest = None
+        self.extras = None  # additional features requested
+        self.context = None  # environment marker overrides
+        self.download_urls = set()
+        self.digests = {}
+
+    @property
+    def source_url(self):
+        """
+        The source archive download URL for this distribution.
+        """
+        return self.metadata.source_url
+
+    download_url = source_url  # Backward compatibility
+
+    @property
+    def name_and_version(self):
+        """
+        A utility property which displays the name and version in parentheses.
+        """
+        return '%s (%s)' % (self.name, self.version)
+
+    @property
+    def provides(self):
+        """
+        A set of distribution names and versions provided by this distribution.
+        :return: A set of "name (version)" strings.
+        """
+        plist = self.metadata.provides
+        s = '%s (%s)' % (self.name, self.version)
+        if s not in plist:
+            plist.append(s)
+        return plist
+
+    def _get_requirements(self, req_attr):
+        md = self.metadata
+        reqts = getattr(md, req_attr)
+        logger.debug('%s: got requirements %r from metadata: %r', self.name,
+                     req_attr, reqts)
+        return set(
+            md.get_requirements(reqts, extras=self.extras, env=self.context))
+
+    @property
+    def run_requires(self):
+        return self._get_requirements('run_requires')
+
+    @property
+    def meta_requires(self):
+        return self._get_requirements('meta_requires')
+
+    @property
+    def build_requires(self):
+        return self._get_requirements('build_requires')
+
+    @property
+    def test_requires(self):
+        return self._get_requirements('test_requires')
+
+    @property
+    def dev_requires(self):
+        return self._get_requirements('dev_requires')
+
+    def matches_requirement(self, req):
+        """
+        Say if this instance matches (fulfills) a requirement.
+        :param req: The requirement to match.
+        :rtype req: str
+        :return: True if it matches, else False.
+        """
+        # Requirement may contain extras - parse to lose those
+        # from what's passed to the matcher
+        r = parse_requirement(req)
+        scheme = get_scheme(self.metadata.scheme)
+        try:
+            matcher = scheme.matcher(r.requirement)
+        except UnsupportedVersionError:
+            # XXX compat-mode if cannot read the version
+            logger.warning('could not read version %r - using name only', req)
+            name = req.split()[0]
+            matcher = scheme.matcher(name)
+
+        name = matcher.key  # case-insensitive
+
+        result = False
+        for p in self.provides:
+            p_name, p_ver = parse_name_and_version(p)
+            if p_name != name:
+                continue
+            try:
+                result = matcher.match(p_ver)
+                break
+            except UnsupportedVersionError:
+                pass
+        return result
+
+    def __repr__(self):
+        """
+        Return a textual representation of this instance,
+        """
+        if self.source_url:
+            suffix = ' [%s]' % self.source_url
+        else:
+            suffix = ''
+        return '' % (self.name, self.version, suffix)
+
+    def __eq__(self, other):
+        """
+        See if this distribution is the same as another.
+        :param other: The distribution to compare with. To be equal to one
+                      another. distributions must have the same type, name,
+                      version and source_url.
+        :return: True if it is the same, else False.
+        """
+        if type(other) is not type(self):
+            result = False
+        else:
+            result = (self.name == other.name and self.version == other.version
+                      and self.source_url == other.source_url)
+        return result
+
+    def __hash__(self):
+        """
+        Compute hash in a way which matches the equality test.
+        """
+        return hash(self.name) + hash(self.version) + hash(self.source_url)
+
+
+class BaseInstalledDistribution(Distribution):
+    """
+    This is the base class for installed distributions (whether PEP 376 or
+    legacy).
+    """
+
+    hasher = None
+
+    def __init__(self, metadata, path, env=None):
+        """
+        Initialise an instance.
+        :param metadata: An instance of :class:`Metadata` which describes the
+                         distribution. This will normally have been initialised
+                         from a metadata file in the ``path``.
+        :param path:     The path of the ``.dist-info`` or ``.egg-info``
+                         directory for the distribution.
+        :param env:      This is normally the :class:`DistributionPath`
+                         instance where this distribution was found.
+        """
+        super(BaseInstalledDistribution, self).__init__(metadata)
+        self.path = path
+        self.dist_path = env
+
+    def get_hash(self, data, hasher=None):
+        """
+        Get the hash of some data, using a particular hash algorithm, if
+        specified.
+
+        :param data: The data to be hashed.
+        :type data: bytes
+        :param hasher: The name of a hash implementation, supported by hashlib,
+                       or ``None``. Examples of valid values are ``'sha1'``,
+                       ``'sha224'``, ``'sha384'``, '``sha256'``, ``'md5'`` and
+                       ``'sha512'``. If no hasher is specified, the ``hasher``
+                       attribute of the :class:`InstalledDistribution` instance
+                       is used. If the hasher is determined to be ``None``, MD5
+                       is used as the hashing algorithm.
+        :returns: The hash of the data. If a hasher was explicitly specified,
+                  the returned hash will be prefixed with the specified hasher
+                  followed by '='.
+        :rtype: str
+        """
+        if hasher is None:
+            hasher = self.hasher
+        if hasher is None:
+            hasher = hashlib.md5
+            prefix = ''
+        else:
+            hasher = getattr(hashlib, hasher)
+            prefix = '%s=' % self.hasher
+        digest = hasher(data).digest()
+        digest = base64.urlsafe_b64encode(digest).rstrip(b'=').decode('ascii')
+        return '%s%s' % (prefix, digest)
+
+
+class InstalledDistribution(BaseInstalledDistribution):
+    """
+    Created with the *path* of the ``.dist-info`` directory provided to the
+    constructor. It reads the metadata contained in ``pydist.json`` when it is
+    instantiated., or uses a passed in Metadata instance (useful for when
+    dry-run mode is being used).
+    """
+
+    hasher = 'sha256'
+
+    def __init__(self, path, metadata=None, env=None):
+        self.modules = []
+        self.finder = finder = resources.finder_for_path(path)
+        if finder is None:
+            raise ValueError('finder unavailable for %s' % path)
+        if env and env._cache_enabled and path in env._cache.path:
+            metadata = env._cache.path[path].metadata
+        elif metadata is None:
+            r = finder.find(METADATA_FILENAME)
+            # Temporary - for Wheel 0.23 support
+            if r is None:
+                r = finder.find(WHEEL_METADATA_FILENAME)
+            # Temporary - for legacy support
+            if r is None:
+                r = finder.find(LEGACY_METADATA_FILENAME)
+            if r is None:
+                raise ValueError('no %s found in %s' %
+                                 (METADATA_FILENAME, path))
+            with contextlib.closing(r.as_stream()) as stream:
+                metadata = Metadata(fileobj=stream, scheme='legacy')
+
+        super(InstalledDistribution, self).__init__(metadata, path, env)
+
+        if env and env._cache_enabled:
+            env._cache.add(self)
+
+        r = finder.find('REQUESTED')
+        self.requested = r is not None
+        p = os.path.join(path, 'top_level.txt')
+        if os.path.exists(p):
+            with open(p, 'rb') as f:
+                data = f.read().decode('utf-8')
+            self.modules = data.splitlines()
+
+    def __repr__(self):
+        return '' % (
+            self.name, self.version, self.path)
+
+    def __str__(self):
+        return "%s %s" % (self.name, self.version)
+
+    def _get_records(self):
+        """
+        Get the list of installed files for the distribution
+        :return: A list of tuples of path, hash and size. Note that hash and
+                 size might be ``None`` for some entries. The path is exactly
+                 as stored in the file (which is as in PEP 376).
+        """
+        results = []
+        r = self.get_distinfo_resource('RECORD')
+        with contextlib.closing(r.as_stream()) as stream:
+            with CSVReader(stream=stream) as record_reader:
+                # Base location is parent dir of .dist-info dir
+                # base_location = os.path.dirname(self.path)
+                # base_location = os.path.abspath(base_location)
+                for row in record_reader:
+                    missing = [None for i in range(len(row), 3)]
+                    path, checksum, size = row + missing
+                    # if not os.path.isabs(path):
+                    #     path = path.replace('/', os.sep)
+                    #     path = os.path.join(base_location, path)
+                    results.append((path, checksum, size))
+        return results
+
+    @cached_property
+    def exports(self):
+        """
+        Return the information exported by this distribution.
+        :return: A dictionary of exports, mapping an export category to a dict
+                 of :class:`ExportEntry` instances describing the individual
+                 export entries, and keyed by name.
+        """
+        result = {}
+        r = self.get_distinfo_resource(EXPORTS_FILENAME)
+        if r:
+            result = self.read_exports()
+        return result
+
+    def read_exports(self):
+        """
+        Read exports data from a file in .ini format.
+
+        :return: A dictionary of exports, mapping an export category to a list
+                 of :class:`ExportEntry` instances describing the individual
+                 export entries.
+        """
+        result = {}
+        r = self.get_distinfo_resource(EXPORTS_FILENAME)
+        if r:
+            with contextlib.closing(r.as_stream()) as stream:
+                result = read_exports(stream)
+        return result
+
+    def write_exports(self, exports):
+        """
+        Write a dictionary of exports to a file in .ini format.
+        :param exports: A dictionary of exports, mapping an export category to
+                        a list of :class:`ExportEntry` instances describing the
+                        individual export entries.
+        """
+        rf = self.get_distinfo_file(EXPORTS_FILENAME)
+        with open(rf, 'w') as f:
+            write_exports(exports, f)
+
+    def get_resource_path(self, relative_path):
+        """
+        NOTE: This API may change in the future.
+
+        Return the absolute path to a resource file with the given relative
+        path.
+
+        :param relative_path: The path, relative to .dist-info, of the resource
+                              of interest.
+        :return: The absolute path where the resource is to be found.
+        """
+        r = self.get_distinfo_resource('RESOURCES')
+        with contextlib.closing(r.as_stream()) as stream:
+            with CSVReader(stream=stream) as resources_reader:
+                for relative, destination in resources_reader:
+                    if relative == relative_path:
+                        return destination
+        raise KeyError('no resource file with relative path %r '
+                       'is installed' % relative_path)
+
+    def list_installed_files(self):
+        """
+        Iterates over the ``RECORD`` entries and returns a tuple
+        ``(path, hash, size)`` for each line.
+
+        :returns: iterator of (path, hash, size)
+        """
+        for result in self._get_records():
+            yield result
+
+    def write_installed_files(self, paths, prefix, dry_run=False):
+        """
+        Writes the ``RECORD`` file, using the ``paths`` iterable passed in. Any
+        existing ``RECORD`` file is silently overwritten.
+
+        prefix is used to determine when to write absolute paths.
+        """
+        prefix = os.path.join(prefix, '')
+        base = os.path.dirname(self.path)
+        base_under_prefix = base.startswith(prefix)
+        base = os.path.join(base, '')
+        record_path = self.get_distinfo_file('RECORD')
+        logger.info('creating %s', record_path)
+        if dry_run:
+            return None
+        with CSVWriter(record_path) as writer:
+            for path in paths:
+                if os.path.isdir(path) or path.endswith(('.pyc', '.pyo')):
+                    # do not put size and hash, as in PEP-376
+                    hash_value = size = ''
+                else:
+                    size = '%d' % os.path.getsize(path)
+                    with open(path, 'rb') as fp:
+                        hash_value = self.get_hash(fp.read())
+                if path.startswith(base) or (base_under_prefix
+                                             and path.startswith(prefix)):
+                    path = os.path.relpath(path, base)
+                writer.writerow((path, hash_value, size))
+
+            # add the RECORD file itself
+            if record_path.startswith(base):
+                record_path = os.path.relpath(record_path, base)
+            writer.writerow((record_path, '', ''))
+        return record_path
+
+    def check_installed_files(self):
+        """
+        Checks that the hashes and sizes of the files in ``RECORD`` are
+        matched by the files themselves. Returns a (possibly empty) list of
+        mismatches. Each entry in the mismatch list will be a tuple consisting
+        of the path, 'exists', 'size' or 'hash' according to what didn't match
+        (existence is checked first, then size, then hash), the expected
+        value and the actual value.
+        """
+        mismatches = []
+        base = os.path.dirname(self.path)
+        record_path = self.get_distinfo_file('RECORD')
+        for path, hash_value, size in self.list_installed_files():
+            if not os.path.isabs(path):
+                path = os.path.join(base, path)
+            if path == record_path:
+                continue
+            if not os.path.exists(path):
+                mismatches.append((path, 'exists', True, False))
+            elif os.path.isfile(path):
+                actual_size = str(os.path.getsize(path))
+                if size and actual_size != size:
+                    mismatches.append((path, 'size', size, actual_size))
+                elif hash_value:
+                    if '=' in hash_value:
+                        hasher = hash_value.split('=', 1)[0]
+                    else:
+                        hasher = None
+
+                    with open(path, 'rb') as f:
+                        actual_hash = self.get_hash(f.read(), hasher)
+                        if actual_hash != hash_value:
+                            mismatches.append(
+                                (path, 'hash', hash_value, actual_hash))
+        return mismatches
+
+    @cached_property
+    def shared_locations(self):
+        """
+        A dictionary of shared locations whose keys are in the set 'prefix',
+        'purelib', 'platlib', 'scripts', 'headers', 'data' and 'namespace'.
+        The corresponding value is the absolute path of that category for
+        this distribution, and takes into account any paths selected by the
+        user at installation time (e.g. via command-line arguments). In the
+        case of the 'namespace' key, this would be a list of absolute paths
+        for the roots of namespace packages in this distribution.
+
+        The first time this property is accessed, the relevant information is
+        read from the SHARED file in the .dist-info directory.
+        """
+        result = {}
+        shared_path = os.path.join(self.path, 'SHARED')
+        if os.path.isfile(shared_path):
+            with codecs.open(shared_path, 'r', encoding='utf-8') as f:
+                lines = f.read().splitlines()
+            for line in lines:
+                key, value = line.split('=', 1)
+                if key == 'namespace':
+                    result.setdefault(key, []).append(value)
+                else:
+                    result[key] = value
+        return result
+
+    def write_shared_locations(self, paths, dry_run=False):
+        """
+        Write shared location information to the SHARED file in .dist-info.
+        :param paths: A dictionary as described in the documentation for
+        :meth:`shared_locations`.
+        :param dry_run: If True, the action is logged but no file is actually
+                        written.
+        :return: The path of the file written to.
+        """
+        shared_path = os.path.join(self.path, 'SHARED')
+        logger.info('creating %s', shared_path)
+        if dry_run:
+            return None
+        lines = []
+        for key in ('prefix', 'lib', 'headers', 'scripts', 'data'):
+            path = paths[key]
+            if os.path.isdir(paths[key]):
+                lines.append('%s=%s' % (key, path))
+        for ns in paths.get('namespace', ()):
+            lines.append('namespace=%s' % ns)
+
+        with codecs.open(shared_path, 'w', encoding='utf-8') as f:
+            f.write('\n'.join(lines))
+        return shared_path
+
+    def get_distinfo_resource(self, path):
+        if path not in DIST_FILES:
+            raise DistlibException('invalid path for a dist-info file: '
+                                   '%r at %r' % (path, self.path))
+        finder = resources.finder_for_path(self.path)
+        if finder is None:
+            raise DistlibException('Unable to get a finder for %s' % self.path)
+        return finder.find(path)
+
+    def get_distinfo_file(self, path):
+        """
+        Returns a path located under the ``.dist-info`` directory. Returns a
+        string representing the path.
+
+        :parameter path: a ``'/'``-separated path relative to the
+                         ``.dist-info`` directory or an absolute path;
+                         If *path* is an absolute path and doesn't start
+                         with the ``.dist-info`` directory path,
+                         a :class:`DistlibException` is raised
+        :type path: str
+        :rtype: str
+        """
+        # Check if it is an absolute path  # XXX use relpath, add tests
+        if path.find(os.sep) >= 0:
+            # it's an absolute path?
+            distinfo_dirname, path = path.split(os.sep)[-2:]
+            if distinfo_dirname != self.path.split(os.sep)[-1]:
+                raise DistlibException(
+                    'dist-info file %r does not belong to the %r %s '
+                    'distribution' % (path, self.name, self.version))
+
+        # The file must be relative
+        if path not in DIST_FILES:
+            raise DistlibException('invalid path for a dist-info file: '
+                                   '%r at %r' % (path, self.path))
+
+        return os.path.join(self.path, path)
+
+    def list_distinfo_files(self):
+        """
+        Iterates over the ``RECORD`` entries and returns paths for each line if
+        the path is pointing to a file located in the ``.dist-info`` directory
+        or one of its subdirectories.
+
+        :returns: iterator of paths
+        """
+        base = os.path.dirname(self.path)
+        for path, checksum, size in self._get_records():
+            # XXX add separator or use real relpath algo
+            if not os.path.isabs(path):
+                path = os.path.join(base, path)
+            if path.startswith(self.path):
+                yield path
+
+    def __eq__(self, other):
+        return (isinstance(other, InstalledDistribution)
+                and self.path == other.path)
+
+    # See http://docs.python.org/reference/datamodel#object.__hash__
+    __hash__ = object.__hash__
+
+
+class EggInfoDistribution(BaseInstalledDistribution):
+    """Created with the *path* of the ``.egg-info`` directory or file provided
+    to the constructor. It reads the metadata contained in the file itself, or
+    if the given path happens to be a directory, the metadata is read from the
+    file ``PKG-INFO`` under that directory."""
+
+    requested = True  # as we have no way of knowing, assume it was
+    shared_locations = {}
+
+    def __init__(self, path, env=None):
+
+        def set_name_and_version(s, n, v):
+            s.name = n
+            s.key = n.lower()  # for case-insensitive comparisons
+            s.version = v
+
+        self.path = path
+        self.dist_path = env
+        if env and env._cache_enabled and path in env._cache_egg.path:
+            metadata = env._cache_egg.path[path].metadata
+            set_name_and_version(self, metadata.name, metadata.version)
+        else:
+            metadata = self._get_metadata(path)
+
+            # Need to be set before caching
+            set_name_and_version(self, metadata.name, metadata.version)
+
+            if env and env._cache_enabled:
+                env._cache_egg.add(self)
+        super(EggInfoDistribution, self).__init__(metadata, path, env)
+
+    def _get_metadata(self, path):
+        requires = None
+
+        def parse_requires_data(data):
+            """Create a list of dependencies from a requires.txt file.
+
+            *data*: the contents of a setuptools-produced requires.txt file.
+            """
+            reqs = []
+            lines = data.splitlines()
+            for line in lines:
+                line = line.strip()
+                # sectioned files have bare newlines (separating sections)
+                if not line:  # pragma: no cover
+                    continue
+                if line.startswith('['):  # pragma: no cover
+                    logger.warning(
+                        'Unexpected line: quitting requirement scan: %r', line)
+                    break
+                r = parse_requirement(line)
+                if not r:  # pragma: no cover
+                    logger.warning('Not recognised as a requirement: %r', line)
+                    continue
+                if r.extras:  # pragma: no cover
+                    logger.warning('extra requirements in requires.txt are '
+                                   'not supported')
+                if not r.constraints:
+                    reqs.append(r.name)
+                else:
+                    cons = ', '.join('%s%s' % c for c in r.constraints)
+                    reqs.append('%s (%s)' % (r.name, cons))
+            return reqs
+
+        def parse_requires_path(req_path):
+            """Create a list of dependencies from a requires.txt file.
+
+            *req_path*: the path to a setuptools-produced requires.txt file.
+            """
+
+            reqs = []
+            try:
+                with codecs.open(req_path, 'r', 'utf-8') as fp:
+                    reqs = parse_requires_data(fp.read())
+            except IOError:
+                pass
+            return reqs
+
+        tl_path = tl_data = None
+        if path.endswith('.egg'):
+            if os.path.isdir(path):
+                p = os.path.join(path, 'EGG-INFO')
+                meta_path = os.path.join(p, 'PKG-INFO')
+                metadata = Metadata(path=meta_path, scheme='legacy')
+                req_path = os.path.join(p, 'requires.txt')
+                tl_path = os.path.join(p, 'top_level.txt')
+                requires = parse_requires_path(req_path)
+            else:
+                # FIXME handle the case where zipfile is not available
+                zipf = zipimport.zipimporter(path)
+                fileobj = StringIO(
+                    zipf.get_data('EGG-INFO/PKG-INFO').decode('utf8'))
+                metadata = Metadata(fileobj=fileobj, scheme='legacy')
+                try:
+                    data = zipf.get_data('EGG-INFO/requires.txt')
+                    tl_data = zipf.get_data('EGG-INFO/top_level.txt').decode(
+                        'utf-8')
+                    requires = parse_requires_data(data.decode('utf-8'))
+                except IOError:
+                    requires = None
+        elif path.endswith('.egg-info'):
+            if os.path.isdir(path):
+                req_path = os.path.join(path, 'requires.txt')
+                requires = parse_requires_path(req_path)
+                path = os.path.join(path, 'PKG-INFO')
+                tl_path = os.path.join(path, 'top_level.txt')
+            metadata = Metadata(path=path, scheme='legacy')
+        else:
+            raise DistlibException('path must end with .egg-info or .egg, '
+                                   'got %r' % path)
+
+        if requires:
+            metadata.add_requirements(requires)
+        # look for top-level modules in top_level.txt, if present
+        if tl_data is None:
+            if tl_path is not None and os.path.exists(tl_path):
+                with open(tl_path, 'rb') as f:
+                    tl_data = f.read().decode('utf-8')
+        if not tl_data:
+            tl_data = []
+        else:
+            tl_data = tl_data.splitlines()
+        self.modules = tl_data
+        return metadata
+
+    def __repr__(self):
+        return '' % (self.name, self.version,
+                                                      self.path)
+
+    def __str__(self):
+        return "%s %s" % (self.name, self.version)
+
+    def check_installed_files(self):
+        """
+        Checks that the hashes and sizes of the files in ``RECORD`` are
+        matched by the files themselves. Returns a (possibly empty) list of
+        mismatches. Each entry in the mismatch list will be a tuple consisting
+        of the path, 'exists', 'size' or 'hash' according to what didn't match
+        (existence is checked first, then size, then hash), the expected
+        value and the actual value.
+        """
+        mismatches = []
+        record_path = os.path.join(self.path, 'installed-files.txt')
+        if os.path.exists(record_path):
+            for path, _, _ in self.list_installed_files():
+                if path == record_path:
+                    continue
+                if not os.path.exists(path):
+                    mismatches.append((path, 'exists', True, False))
+        return mismatches
+
+    def list_installed_files(self):
+        """
+        Iterates over the ``installed-files.txt`` entries and returns a tuple
+        ``(path, hash, size)`` for each line.
+
+        :returns: a list of (path, hash, size)
+        """
+
+        def _md5(path):
+            f = open(path, 'rb')
+            try:
+                content = f.read()
+            finally:
+                f.close()
+            return hashlib.md5(content).hexdigest()
+
+        def _size(path):
+            return os.stat(path).st_size
+
+        record_path = os.path.join(self.path, 'installed-files.txt')
+        result = []
+        if os.path.exists(record_path):
+            with codecs.open(record_path, 'r', encoding='utf-8') as f:
+                for line in f:
+                    line = line.strip()
+                    p = os.path.normpath(os.path.join(self.path, line))
+                    # "./" is present as a marker between installed files
+                    # and installation metadata files
+                    if not os.path.exists(p):
+                        logger.warning('Non-existent file: %s', p)
+                        if p.endswith(('.pyc', '.pyo')):
+                            continue
+                        # otherwise fall through and fail
+                    if not os.path.isdir(p):
+                        result.append((p, _md5(p), _size(p)))
+            result.append((record_path, None, None))
+        return result
+
+    def list_distinfo_files(self, absolute=False):
+        """
+        Iterates over the ``installed-files.txt`` entries and returns paths for
+        each line if the path is pointing to a file located in the
+        ``.egg-info`` directory or one of its subdirectories.
+
+        :parameter absolute: If *absolute* is ``True``, each returned path is
+                          transformed into a local absolute path. Otherwise the
+                          raw value from ``installed-files.txt`` is returned.
+        :type absolute: boolean
+        :returns: iterator of paths
+        """
+        record_path = os.path.join(self.path, 'installed-files.txt')
+        if os.path.exists(record_path):
+            skip = True
+            with codecs.open(record_path, 'r', encoding='utf-8') as f:
+                for line in f:
+                    line = line.strip()
+                    if line == './':
+                        skip = False
+                        continue
+                    if not skip:
+                        p = os.path.normpath(os.path.join(self.path, line))
+                        if p.startswith(self.path):
+                            if absolute:
+                                yield p
+                            else:
+                                yield line
+
+    def __eq__(self, other):
+        return (isinstance(other, EggInfoDistribution)
+                and self.path == other.path)
+
+    # See http://docs.python.org/reference/datamodel#object.__hash__
+    __hash__ = object.__hash__
+
+
+new_dist_class = InstalledDistribution
+old_dist_class = EggInfoDistribution
+
+
+class DependencyGraph(object):
+    """
+    Represents a dependency graph between distributions.
+
+    The dependency relationships are stored in an ``adjacency_list`` that maps
+    distributions to a list of ``(other, label)`` tuples where  ``other``
+    is a distribution and the edge is labeled with ``label`` (i.e. the version
+    specifier, if such was provided). Also, for more efficient traversal, for
+    every distribution ``x``, a list of predecessors is kept in
+    ``reverse_list[x]``. An edge from distribution ``a`` to
+    distribution ``b`` means that ``a`` depends on ``b``. If any missing
+    dependencies are found, they are stored in ``missing``, which is a
+    dictionary that maps distributions to a list of requirements that were not
+    provided by any other distributions.
+    """
+
+    def __init__(self):
+        self.adjacency_list = {}
+        self.reverse_list = {}
+        self.missing = {}
+
+    def add_distribution(self, distribution):
+        """Add the *distribution* to the graph.
+
+        :type distribution: :class:`distutils2.database.InstalledDistribution`
+                            or :class:`distutils2.database.EggInfoDistribution`
+        """
+        self.adjacency_list[distribution] = []
+        self.reverse_list[distribution] = []
+        # self.missing[distribution] = []
+
+    def add_edge(self, x, y, label=None):
+        """Add an edge from distribution *x* to distribution *y* with the given
+        *label*.
+
+        :type x: :class:`distutils2.database.InstalledDistribution` or
+                 :class:`distutils2.database.EggInfoDistribution`
+        :type y: :class:`distutils2.database.InstalledDistribution` or
+                 :class:`distutils2.database.EggInfoDistribution`
+        :type label: ``str`` or ``None``
+        """
+        self.adjacency_list[x].append((y, label))
+        # multiple edges are allowed, so be careful
+        if x not in self.reverse_list[y]:
+            self.reverse_list[y].append(x)
+
+    def add_missing(self, distribution, requirement):
+        """
+        Add a missing *requirement* for the given *distribution*.
+
+        :type distribution: :class:`distutils2.database.InstalledDistribution`
+                            or :class:`distutils2.database.EggInfoDistribution`
+        :type requirement: ``str``
+        """
+        logger.debug('%s missing %r', distribution, requirement)
+        self.missing.setdefault(distribution, []).append(requirement)
+
+    def _repr_dist(self, dist):
+        return '%s %s' % (dist.name, dist.version)
+
+    def repr_node(self, dist, level=1):
+        """Prints only a subgraph"""
+        output = [self._repr_dist(dist)]
+        for other, label in self.adjacency_list[dist]:
+            dist = self._repr_dist(other)
+            if label is not None:
+                dist = '%s [%s]' % (dist, label)
+            output.append('    ' * level + str(dist))
+            suboutput = self.repr_node(other, level + 1)
+            subs = suboutput.split('\n')
+            output.extend(subs[1:])
+        return '\n'.join(output)
+
+    def to_dot(self, f, skip_disconnected=True):
+        """Writes a DOT output for the graph to the provided file *f*.
+
+        If *skip_disconnected* is set to ``True``, then all distributions
+        that are not dependent on any other distribution are skipped.
+
+        :type f: has to support ``file``-like operations
+        :type skip_disconnected: ``bool``
+        """
+        disconnected = []
+
+        f.write("digraph dependencies {\n")
+        for dist, adjs in self.adjacency_list.items():
+            if len(adjs) == 0 and not skip_disconnected:
+                disconnected.append(dist)
+            for other, label in adjs:
+                if label is not None:
+                    f.write('"%s" -> "%s" [label="%s"]\n' %
+                            (dist.name, other.name, label))
+                else:
+                    f.write('"%s" -> "%s"\n' % (dist.name, other.name))
+        if not skip_disconnected and len(disconnected) > 0:
+            f.write('subgraph disconnected {\n')
+            f.write('label = "Disconnected"\n')
+            f.write('bgcolor = red\n')
+
+            for dist in disconnected:
+                f.write('"%s"' % dist.name)
+                f.write('\n')
+            f.write('}\n')
+        f.write('}\n')
+
+    def topological_sort(self):
+        """
+        Perform a topological sort of the graph.
+        :return: A tuple, the first element of which is a topologically sorted
+                 list of distributions, and the second element of which is a
+                 list of distributions that cannot be sorted because they have
+                 circular dependencies and so form a cycle.
+        """
+        result = []
+        # Make a shallow copy of the adjacency list
+        alist = {}
+        for k, v in self.adjacency_list.items():
+            alist[k] = v[:]
+        while True:
+            # See what we can remove in this run
+            to_remove = []
+            for k, v in list(alist.items())[:]:
+                if not v:
+                    to_remove.append(k)
+                    del alist[k]
+            if not to_remove:
+                # What's left in alist (if anything) is a cycle.
+                break
+            # Remove from the adjacency list of others
+            for k, v in alist.items():
+                alist[k] = [(d, r) for d, r in v if d not in to_remove]
+            logger.debug('Moving to result: %s',
+                         ['%s (%s)' % (d.name, d.version) for d in to_remove])
+            result.extend(to_remove)
+        return result, list(alist.keys())
+
+    def __repr__(self):
+        """Representation of the graph"""
+        output = []
+        for dist, adjs in self.adjacency_list.items():
+            output.append(self.repr_node(dist))
+        return '\n'.join(output)
+
+
+def make_graph(dists, scheme='default'):
+    """Makes a dependency graph from the given distributions.
+
+    :parameter dists: a list of distributions
+    :type dists: list of :class:`distutils2.database.InstalledDistribution` and
+                 :class:`distutils2.database.EggInfoDistribution` instances
+    :rtype: a :class:`DependencyGraph` instance
+    """
+    scheme = get_scheme(scheme)
+    graph = DependencyGraph()
+    provided = {}  # maps names to lists of (version, dist) tuples
+
+    # first, build the graph and find out what's provided
+    for dist in dists:
+        graph.add_distribution(dist)
+
+        for p in dist.provides:
+            name, version = parse_name_and_version(p)
+            logger.debug('Add to provided: %s, %s, %s', name, version, dist)
+            provided.setdefault(name, []).append((version, dist))
+
+    # now make the edges
+    for dist in dists:
+        requires = (dist.run_requires | dist.meta_requires
+                    | dist.build_requires | dist.dev_requires)
+        for req in requires:
+            try:
+                matcher = scheme.matcher(req)
+            except UnsupportedVersionError:
+                # XXX compat-mode if cannot read the version
+                logger.warning('could not read version %r - using name only',
+                               req)
+                name = req.split()[0]
+                matcher = scheme.matcher(name)
+
+            name = matcher.key  # case-insensitive
+
+            matched = False
+            if name in provided:
+                for version, provider in provided[name]:
+                    try:
+                        match = matcher.match(version)
+                    except UnsupportedVersionError:
+                        match = False
+
+                    if match:
+                        graph.add_edge(dist, provider, req)
+                        matched = True
+                        break
+            if not matched:
+                graph.add_missing(dist, req)
+    return graph
+
+
+def get_dependent_dists(dists, dist):
+    """Recursively generate a list of distributions from *dists* that are
+    dependent on *dist*.
+
+    :param dists: a list of distributions
+    :param dist: a distribution, member of *dists* for which we are interested
+    """
+    if dist not in dists:
+        raise DistlibException('given distribution %r is not a member '
+                               'of the list' % dist.name)
+    graph = make_graph(dists)
+
+    dep = [dist]  # dependent distributions
+    todo = graph.reverse_list[dist]  # list of nodes we should inspect
+
+    while todo:
+        d = todo.pop()
+        dep.append(d)
+        for succ in graph.reverse_list[d]:
+            if succ not in dep:
+                todo.append(succ)
+
+    dep.pop(0)  # remove dist from dep, was there to prevent infinite loops
+    return dep
+
+
+def get_required_dists(dists, dist):
+    """Recursively generate a list of distributions from *dists* that are
+    required by *dist*.
+
+    :param dists: a list of distributions
+    :param dist: a distribution, member of *dists* for which we are interested
+                 in finding the dependencies.
+    """
+    if dist not in dists:
+        raise DistlibException('given distribution %r is not a member '
+                               'of the list' % dist.name)
+    graph = make_graph(dists)
+
+    req = set()  # required distributions
+    todo = graph.adjacency_list[dist]  # list of nodes we should inspect
+    seen = set(t[0] for t in todo)  # already added to todo
+
+    while todo:
+        d = todo.pop()[0]
+        req.add(d)
+        pred_list = graph.adjacency_list[d]
+        for pred in pred_list:
+            d = pred[0]
+            if d not in req and d not in seen:
+                seen.add(d)
+                todo.append(pred)
+    return req
+
+
+def make_dist(name, version, **kwargs):
+    """
+    A convenience method for making a dist given just a name and version.
+    """
+    summary = kwargs.pop('summary', 'Placeholder for summary')
+    md = Metadata(**kwargs)
+    md.name = name
+    md.version = version
+    md.summary = summary or 'Placeholder for summary'
+    return Distribution(md)
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/distlib/index.py b/venv/lib/python3.12/site-packages/pip/_vendor/distlib/index.py
new file mode 100644
index 00000000..56cd2867
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_vendor/distlib/index.py
@@ -0,0 +1,508 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2013-2023 Vinay Sajip.
+# Licensed to the Python Software Foundation under a contributor agreement.
+# See LICENSE.txt and CONTRIBUTORS.txt.
+#
+import hashlib
+import logging
+import os
+import shutil
+import subprocess
+import tempfile
+try:
+    from threading import Thread
+except ImportError:  # pragma: no cover
+    from dummy_threading import Thread
+
+from . import DistlibException
+from .compat import (HTTPBasicAuthHandler, Request, HTTPPasswordMgr,
+                     urlparse, build_opener, string_types)
+from .util import zip_dir, ServerProxy
+
+logger = logging.getLogger(__name__)
+
+DEFAULT_INDEX = 'https://pypi.org/pypi'
+DEFAULT_REALM = 'pypi'
+
+
+class PackageIndex(object):
+    """
+    This class represents a package index compatible with PyPI, the Python
+    Package Index.
+    """
+
+    boundary = b'----------ThIs_Is_tHe_distlib_index_bouNdaRY_$'
+
+    def __init__(self, url=None):
+        """
+        Initialise an instance.
+
+        :param url: The URL of the index. If not specified, the URL for PyPI is
+                    used.
+        """
+        self.url = url or DEFAULT_INDEX
+        self.read_configuration()
+        scheme, netloc, path, params, query, frag = urlparse(self.url)
+        if params or query or frag or scheme not in ('http', 'https'):
+            raise DistlibException('invalid repository: %s' % self.url)
+        self.password_handler = None
+        self.ssl_verifier = None
+        self.gpg = None
+        self.gpg_home = None
+        with open(os.devnull, 'w') as sink:
+            # Use gpg by default rather than gpg2, as gpg2 insists on
+            # prompting for passwords
+            for s in ('gpg', 'gpg2'):
+                try:
+                    rc = subprocess.check_call([s, '--version'], stdout=sink,
+                                               stderr=sink)
+                    if rc == 0:
+                        self.gpg = s
+                        break
+                except OSError:
+                    pass
+
+    def _get_pypirc_command(self):
+        """
+        Get the distutils command for interacting with PyPI configurations.
+        :return: the command.
+        """
+        from .util import _get_pypirc_command as cmd
+        return cmd()
+
+    def read_configuration(self):
+        """
+        Read the PyPI access configuration as supported by distutils. This populates
+        ``username``, ``password``, ``realm`` and ``url`` attributes from the
+        configuration.
+        """
+        from .util import _load_pypirc
+        cfg = _load_pypirc(self)
+        self.username = cfg.get('username')
+        self.password = cfg.get('password')
+        self.realm = cfg.get('realm', 'pypi')
+        self.url = cfg.get('repository', self.url)
+
+    def save_configuration(self):
+        """
+        Save the PyPI access configuration. You must have set ``username`` and
+        ``password`` attributes before calling this method.
+        """
+        self.check_credentials()
+        from .util import _store_pypirc
+        _store_pypirc(self)
+
+    def check_credentials(self):
+        """
+        Check that ``username`` and ``password`` have been set, and raise an
+        exception if not.
+        """
+        if self.username is None or self.password is None:
+            raise DistlibException('username and password must be set')
+        pm = HTTPPasswordMgr()
+        _, netloc, _, _, _, _ = urlparse(self.url)
+        pm.add_password(self.realm, netloc, self.username, self.password)
+        self.password_handler = HTTPBasicAuthHandler(pm)
+
+    def register(self, metadata):  # pragma: no cover
+        """
+        Register a distribution on PyPI, using the provided metadata.
+
+        :param metadata: A :class:`Metadata` instance defining at least a name
+                         and version number for the distribution to be
+                         registered.
+        :return: The HTTP response received from PyPI upon submission of the
+                request.
+        """
+        self.check_credentials()
+        metadata.validate()
+        d = metadata.todict()
+        d[':action'] = 'verify'
+        request = self.encode_request(d.items(), [])
+        self.send_request(request)
+        d[':action'] = 'submit'
+        request = self.encode_request(d.items(), [])
+        return self.send_request(request)
+
+    def _reader(self, name, stream, outbuf):
+        """
+        Thread runner for reading lines of from a subprocess into a buffer.
+
+        :param name: The logical name of the stream (used for logging only).
+        :param stream: The stream to read from. This will typically a pipe
+                       connected to the output stream of a subprocess.
+        :param outbuf: The list to append the read lines to.
+        """
+        while True:
+            s = stream.readline()
+            if not s:
+                break
+            s = s.decode('utf-8').rstrip()
+            outbuf.append(s)
+            logger.debug('%s: %s' % (name, s))
+        stream.close()
+
+    def get_sign_command(self, filename, signer, sign_password, keystore=None):  # pragma: no cover
+        """
+        Return a suitable command for signing a file.
+
+        :param filename: The pathname to the file to be signed.
+        :param signer: The identifier of the signer of the file.
+        :param sign_password: The passphrase for the signer's
+                              private key used for signing.
+        :param keystore: The path to a directory which contains the keys
+                         used in verification. If not specified, the
+                         instance's ``gpg_home`` attribute is used instead.
+        :return: The signing command as a list suitable to be
+                 passed to :class:`subprocess.Popen`.
+        """
+        cmd = [self.gpg, '--status-fd', '2', '--no-tty']
+        if keystore is None:
+            keystore = self.gpg_home
+        if keystore:
+            cmd.extend(['--homedir', keystore])
+        if sign_password is not None:
+            cmd.extend(['--batch', '--passphrase-fd', '0'])
+        td = tempfile.mkdtemp()
+        sf = os.path.join(td, os.path.basename(filename) + '.asc')
+        cmd.extend(['--detach-sign', '--armor', '--local-user',
+                    signer, '--output', sf, filename])
+        logger.debug('invoking: %s', ' '.join(cmd))
+        return cmd, sf
+
+    def run_command(self, cmd, input_data=None):
+        """
+        Run a command in a child process , passing it any input data specified.
+
+        :param cmd: The command to run.
+        :param input_data: If specified, this must be a byte string containing
+                           data to be sent to the child process.
+        :return: A tuple consisting of the subprocess' exit code, a list of
+                 lines read from the subprocess' ``stdout``, and a list of
+                 lines read from the subprocess' ``stderr``.
+        """
+        kwargs = {
+            'stdout': subprocess.PIPE,
+            'stderr': subprocess.PIPE,
+        }
+        if input_data is not None:
+            kwargs['stdin'] = subprocess.PIPE
+        stdout = []
+        stderr = []
+        p = subprocess.Popen(cmd, **kwargs)
+        # We don't use communicate() here because we may need to
+        # get clever with interacting with the command
+        t1 = Thread(target=self._reader, args=('stdout', p.stdout, stdout))
+        t1.start()
+        t2 = Thread(target=self._reader, args=('stderr', p.stderr, stderr))
+        t2.start()
+        if input_data is not None:
+            p.stdin.write(input_data)
+            p.stdin.close()
+
+        p.wait()
+        t1.join()
+        t2.join()
+        return p.returncode, stdout, stderr
+
+    def sign_file(self, filename, signer, sign_password, keystore=None):  # pragma: no cover
+        """
+        Sign a file.
+
+        :param filename: The pathname to the file to be signed.
+        :param signer: The identifier of the signer of the file.
+        :param sign_password: The passphrase for the signer's
+                              private key used for signing.
+        :param keystore: The path to a directory which contains the keys
+                         used in signing. If not specified, the instance's
+                         ``gpg_home`` attribute is used instead.
+        :return: The absolute pathname of the file where the signature is
+                 stored.
+        """
+        cmd, sig_file = self.get_sign_command(filename, signer, sign_password,
+                                              keystore)
+        rc, stdout, stderr = self.run_command(cmd,
+                                              sign_password.encode('utf-8'))
+        if rc != 0:
+            raise DistlibException('sign command failed with error '
+                                   'code %s' % rc)
+        return sig_file
+
+    def upload_file(self, metadata, filename, signer=None, sign_password=None,
+                    filetype='sdist', pyversion='source', keystore=None):
+        """
+        Upload a release file to the index.
+
+        :param metadata: A :class:`Metadata` instance defining at least a name
+                         and version number for the file to be uploaded.
+        :param filename: The pathname of the file to be uploaded.
+        :param signer: The identifier of the signer of the file.
+        :param sign_password: The passphrase for the signer's
+                              private key used for signing.
+        :param filetype: The type of the file being uploaded. This is the
+                        distutils command which produced that file, e.g.
+                        ``sdist`` or ``bdist_wheel``.
+        :param pyversion: The version of Python which the release relates
+                          to. For code compatible with any Python, this would
+                          be ``source``, otherwise it would be e.g. ``3.2``.
+        :param keystore: The path to a directory which contains the keys
+                         used in signing. If not specified, the instance's
+                         ``gpg_home`` attribute is used instead.
+        :return: The HTTP response received from PyPI upon submission of the
+                request.
+        """
+        self.check_credentials()
+        if not os.path.exists(filename):
+            raise DistlibException('not found: %s' % filename)
+        metadata.validate()
+        d = metadata.todict()
+        sig_file = None
+        if signer:
+            if not self.gpg:
+                logger.warning('no signing program available - not signed')
+            else:
+                sig_file = self.sign_file(filename, signer, sign_password,
+                                          keystore)
+        with open(filename, 'rb') as f:
+            file_data = f.read()
+        md5_digest = hashlib.md5(file_data).hexdigest()
+        sha256_digest = hashlib.sha256(file_data).hexdigest()
+        d.update({
+            ':action': 'file_upload',
+            'protocol_version': '1',
+            'filetype': filetype,
+            'pyversion': pyversion,
+            'md5_digest': md5_digest,
+            'sha256_digest': sha256_digest,
+        })
+        files = [('content', os.path.basename(filename), file_data)]
+        if sig_file:
+            with open(sig_file, 'rb') as f:
+                sig_data = f.read()
+            files.append(('gpg_signature', os.path.basename(sig_file),
+                         sig_data))
+            shutil.rmtree(os.path.dirname(sig_file))
+        request = self.encode_request(d.items(), files)
+        return self.send_request(request)
+
+    def upload_documentation(self, metadata, doc_dir):  # pragma: no cover
+        """
+        Upload documentation to the index.
+
+        :param metadata: A :class:`Metadata` instance defining at least a name
+                         and version number for the documentation to be
+                         uploaded.
+        :param doc_dir: The pathname of the directory which contains the
+                        documentation. This should be the directory that
+                        contains the ``index.html`` for the documentation.
+        :return: The HTTP response received from PyPI upon submission of the
+                request.
+        """
+        self.check_credentials()
+        if not os.path.isdir(doc_dir):
+            raise DistlibException('not a directory: %r' % doc_dir)
+        fn = os.path.join(doc_dir, 'index.html')
+        if not os.path.exists(fn):
+            raise DistlibException('not found: %r' % fn)
+        metadata.validate()
+        name, version = metadata.name, metadata.version
+        zip_data = zip_dir(doc_dir).getvalue()
+        fields = [(':action', 'doc_upload'),
+                  ('name', name), ('version', version)]
+        files = [('content', name, zip_data)]
+        request = self.encode_request(fields, files)
+        return self.send_request(request)
+
+    def get_verify_command(self, signature_filename, data_filename,
+                           keystore=None):
+        """
+        Return a suitable command for verifying a file.
+
+        :param signature_filename: The pathname to the file containing the
+                                   signature.
+        :param data_filename: The pathname to the file containing the
+                              signed data.
+        :param keystore: The path to a directory which contains the keys
+                         used in verification. If not specified, the
+                         instance's ``gpg_home`` attribute is used instead.
+        :return: The verifying command as a list suitable to be
+                 passed to :class:`subprocess.Popen`.
+        """
+        cmd = [self.gpg, '--status-fd', '2', '--no-tty']
+        if keystore is None:
+            keystore = self.gpg_home
+        if keystore:
+            cmd.extend(['--homedir', keystore])
+        cmd.extend(['--verify', signature_filename, data_filename])
+        logger.debug('invoking: %s', ' '.join(cmd))
+        return cmd
+
+    def verify_signature(self, signature_filename, data_filename,
+                         keystore=None):
+        """
+        Verify a signature for a file.
+
+        :param signature_filename: The pathname to the file containing the
+                                   signature.
+        :param data_filename: The pathname to the file containing the
+                              signed data.
+        :param keystore: The path to a directory which contains the keys
+                         used in verification. If not specified, the
+                         instance's ``gpg_home`` attribute is used instead.
+        :return: True if the signature was verified, else False.
+        """
+        if not self.gpg:
+            raise DistlibException('verification unavailable because gpg '
+                                   'unavailable')
+        cmd = self.get_verify_command(signature_filename, data_filename,
+                                      keystore)
+        rc, stdout, stderr = self.run_command(cmd)
+        if rc not in (0, 1):
+            raise DistlibException('verify command failed with error code %s' % rc)
+        return rc == 0
+
+    def download_file(self, url, destfile, digest=None, reporthook=None):
+        """
+        This is a convenience method for downloading a file from an URL.
+        Normally, this will be a file from the index, though currently
+        no check is made for this (i.e. a file can be downloaded from
+        anywhere).
+
+        The method is just like the :func:`urlretrieve` function in the
+        standard library, except that it allows digest computation to be
+        done during download and checking that the downloaded data
+        matched any expected value.
+
+        :param url: The URL of the file to be downloaded (assumed to be
+                    available via an HTTP GET request).
+        :param destfile: The pathname where the downloaded file is to be
+                         saved.
+        :param digest: If specified, this must be a (hasher, value)
+                       tuple, where hasher is the algorithm used (e.g.
+                       ``'md5'``) and ``value`` is the expected value.
+        :param reporthook: The same as for :func:`urlretrieve` in the
+                           standard library.
+        """
+        if digest is None:
+            digester = None
+            logger.debug('No digest specified')
+        else:
+            if isinstance(digest, (list, tuple)):
+                hasher, digest = digest
+            else:
+                hasher = 'md5'
+            digester = getattr(hashlib, hasher)()
+            logger.debug('Digest specified: %s' % digest)
+        # The following code is equivalent to urlretrieve.
+        # We need to do it this way so that we can compute the
+        # digest of the file as we go.
+        with open(destfile, 'wb') as dfp:
+            # addinfourl is not a context manager on 2.x
+            # so we have to use try/finally
+            sfp = self.send_request(Request(url))
+            try:
+                headers = sfp.info()
+                blocksize = 8192
+                size = -1
+                read = 0
+                blocknum = 0
+                if "content-length" in headers:
+                    size = int(headers["Content-Length"])
+                if reporthook:
+                    reporthook(blocknum, blocksize, size)
+                while True:
+                    block = sfp.read(blocksize)
+                    if not block:
+                        break
+                    read += len(block)
+                    dfp.write(block)
+                    if digester:
+                        digester.update(block)
+                    blocknum += 1
+                    if reporthook:
+                        reporthook(blocknum, blocksize, size)
+            finally:
+                sfp.close()
+
+        # check that we got the whole file, if we can
+        if size >= 0 and read < size:
+            raise DistlibException(
+                'retrieval incomplete: got only %d out of %d bytes'
+                % (read, size))
+        # if we have a digest, it must match.
+        if digester:
+            actual = digester.hexdigest()
+            if digest != actual:
+                raise DistlibException('%s digest mismatch for %s: expected '
+                                       '%s, got %s' % (hasher, destfile,
+                                                       digest, actual))
+            logger.debug('Digest verified: %s', digest)
+
+    def send_request(self, req):
+        """
+        Send a standard library :class:`Request` to PyPI and return its
+        response.
+
+        :param req: The request to send.
+        :return: The HTTP response from PyPI (a standard library HTTPResponse).
+        """
+        handlers = []
+        if self.password_handler:
+            handlers.append(self.password_handler)
+        if self.ssl_verifier:
+            handlers.append(self.ssl_verifier)
+        opener = build_opener(*handlers)
+        return opener.open(req)
+
+    def encode_request(self, fields, files):
+        """
+        Encode fields and files for posting to an HTTP server.
+
+        :param fields: The fields to send as a list of (fieldname, value)
+                       tuples.
+        :param files: The files to send as a list of (fieldname, filename,
+                      file_bytes) tuple.
+        """
+        # Adapted from packaging, which in turn was adapted from
+        # http://code.activestate.com/recipes/146306
+
+        parts = []
+        boundary = self.boundary
+        for k, values in fields:
+            if not isinstance(values, (list, tuple)):
+                values = [values]
+
+            for v in values:
+                parts.extend((
+                    b'--' + boundary,
+                    ('Content-Disposition: form-data; name="%s"' %
+                     k).encode('utf-8'),
+                    b'',
+                    v.encode('utf-8')))
+        for key, filename, value in files:
+            parts.extend((
+                b'--' + boundary,
+                ('Content-Disposition: form-data; name="%s"; filename="%s"' %
+                 (key, filename)).encode('utf-8'),
+                b'',
+                value))
+
+        parts.extend((b'--' + boundary + b'--', b''))
+
+        body = b'\r\n'.join(parts)
+        ct = b'multipart/form-data; boundary=' + boundary
+        headers = {
+            'Content-type': ct,
+            'Content-length': str(len(body))
+        }
+        return Request(self.url, body, headers)
+
+    def search(self, terms, operator=None):  # pragma: no cover
+        if isinstance(terms, string_types):
+            terms = {'name': terms}
+        rpc_proxy = ServerProxy(self.url, timeout=3.0)
+        try:
+            return rpc_proxy.search(terms, operator or 'and')
+        finally:
+            rpc_proxy('close')()
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/distlib/locators.py b/venv/lib/python3.12/site-packages/pip/_vendor/distlib/locators.py
new file mode 100644
index 00000000..f9f0788f
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_vendor/distlib/locators.py
@@ -0,0 +1,1303 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2012-2023 Vinay Sajip.
+# Licensed to the Python Software Foundation under a contributor agreement.
+# See LICENSE.txt and CONTRIBUTORS.txt.
+#
+
+import gzip
+from io import BytesIO
+import json
+import logging
+import os
+import posixpath
+import re
+try:
+    import threading
+except ImportError:  # pragma: no cover
+    import dummy_threading as threading
+import zlib
+
+from . import DistlibException
+from .compat import (urljoin, urlparse, urlunparse, url2pathname, pathname2url,
+                     queue, quote, unescape, build_opener,
+                     HTTPRedirectHandler as BaseRedirectHandler, text_type,
+                     Request, HTTPError, URLError)
+from .database import Distribution, DistributionPath, make_dist
+from .metadata import Metadata, MetadataInvalidError
+from .util import (cached_property, ensure_slash, split_filename, get_project_data,
+                   parse_requirement, parse_name_and_version, ServerProxy,
+                   normalize_name)
+from .version import get_scheme, UnsupportedVersionError
+from .wheel import Wheel, is_compatible
+
+logger = logging.getLogger(__name__)
+
+HASHER_HASH = re.compile(r'^(\w+)=([a-f0-9]+)')
+CHARSET = re.compile(r';\s*charset\s*=\s*(.*)\s*$', re.I)
+HTML_CONTENT_TYPE = re.compile('text/html|application/x(ht)?ml')
+DEFAULT_INDEX = 'https://pypi.org/pypi'
+
+
+def get_all_distribution_names(url=None):
+    """
+    Return all distribution names known by an index.
+    :param url: The URL of the index.
+    :return: A list of all known distribution names.
+    """
+    if url is None:
+        url = DEFAULT_INDEX
+    client = ServerProxy(url, timeout=3.0)
+    try:
+        return client.list_packages()
+    finally:
+        client('close')()
+
+
+class RedirectHandler(BaseRedirectHandler):
+    """
+    A class to work around a bug in some Python 3.2.x releases.
+    """
+    # There's a bug in the base version for some 3.2.x
+    # (e.g. 3.2.2 on Ubuntu Oneiric). If a Location header
+    # returns e.g. /abc, it bails because it says the scheme ''
+    # is bogus, when actually it should use the request's
+    # URL for the scheme. See Python issue #13696.
+    def http_error_302(self, req, fp, code, msg, headers):
+        # Some servers (incorrectly) return multiple Location headers
+        # (so probably same goes for URI).  Use first header.
+        newurl = None
+        for key in ('location', 'uri'):
+            if key in headers:
+                newurl = headers[key]
+                break
+        if newurl is None:  # pragma: no cover
+            return
+        urlparts = urlparse(newurl)
+        if urlparts.scheme == '':
+            newurl = urljoin(req.get_full_url(), newurl)
+            if hasattr(headers, 'replace_header'):
+                headers.replace_header(key, newurl)
+            else:
+                headers[key] = newurl
+        return BaseRedirectHandler.http_error_302(self, req, fp, code, msg,
+                                                  headers)
+
+    http_error_301 = http_error_303 = http_error_307 = http_error_302
+
+
+class Locator(object):
+    """
+    A base class for locators - things that locate distributions.
+    """
+    source_extensions = ('.tar.gz', '.tar.bz2', '.tar', '.zip', '.tgz', '.tbz')
+    binary_extensions = ('.egg', '.exe', '.whl')
+    excluded_extensions = ('.pdf',)
+
+    # A list of tags indicating which wheels you want to match. The default
+    # value of None matches against the tags compatible with the running
+    # Python. If you want to match other values, set wheel_tags on a locator
+    # instance to a list of tuples (pyver, abi, arch) which you want to match.
+    wheel_tags = None
+
+    downloadable_extensions = source_extensions + ('.whl',)
+
+    def __init__(self, scheme='default'):
+        """
+        Initialise an instance.
+        :param scheme: Because locators look for most recent versions, they
+                       need to know the version scheme to use. This specifies
+                       the current PEP-recommended scheme - use ``'legacy'``
+                       if you need to support existing distributions on PyPI.
+        """
+        self._cache = {}
+        self.scheme = scheme
+        # Because of bugs in some of the handlers on some of the platforms,
+        # we use our own opener rather than just using urlopen.
+        self.opener = build_opener(RedirectHandler())
+        # If get_project() is called from locate(), the matcher instance
+        # is set from the requirement passed to locate(). See issue #18 for
+        # why this can be useful to know.
+        self.matcher = None
+        self.errors = queue.Queue()
+
+    def get_errors(self):
+        """
+        Return any errors which have occurred.
+        """
+        result = []
+        while not self.errors.empty():  # pragma: no cover
+            try:
+                e = self.errors.get(False)
+                result.append(e)
+            except self.errors.Empty:
+                continue
+            self.errors.task_done()
+        return result
+
+    def clear_errors(self):
+        """
+        Clear any errors which may have been logged.
+        """
+        # Just get the errors and throw them away
+        self.get_errors()
+
+    def clear_cache(self):
+        self._cache.clear()
+
+    def _get_scheme(self):
+        return self._scheme
+
+    def _set_scheme(self, value):
+        self._scheme = value
+
+    scheme = property(_get_scheme, _set_scheme)
+
+    def _get_project(self, name):
+        """
+        For a given project, get a dictionary mapping available versions to Distribution
+        instances.
+
+        This should be implemented in subclasses.
+
+        If called from a locate() request, self.matcher will be set to a
+        matcher for the requirement to satisfy, otherwise it will be None.
+        """
+        raise NotImplementedError('Please implement in the subclass')
+
+    def get_distribution_names(self):
+        """
+        Return all the distribution names known to this locator.
+        """
+        raise NotImplementedError('Please implement in the subclass')
+
+    def get_project(self, name):
+        """
+        For a given project, get a dictionary mapping available versions to Distribution
+        instances.
+
+        This calls _get_project to do all the work, and just implements a caching layer on top.
+        """
+        if self._cache is None:  # pragma: no cover
+            result = self._get_project(name)
+        elif name in self._cache:
+            result = self._cache[name]
+        else:
+            self.clear_errors()
+            result = self._get_project(name)
+            self._cache[name] = result
+        return result
+
+    def score_url(self, url):
+        """
+        Give an url a score which can be used to choose preferred URLs
+        for a given project release.
+        """
+        t = urlparse(url)
+        basename = posixpath.basename(t.path)
+        compatible = True
+        is_wheel = basename.endswith('.whl')
+        is_downloadable = basename.endswith(self.downloadable_extensions)
+        if is_wheel:
+            compatible = is_compatible(Wheel(basename), self.wheel_tags)
+        return (t.scheme == 'https', 'pypi.org' in t.netloc,
+                is_downloadable, is_wheel, compatible, basename)
+
+    def prefer_url(self, url1, url2):
+        """
+        Choose one of two URLs where both are candidates for distribution
+        archives for the same version of a distribution (for example,
+        .tar.gz vs. zip).
+
+        The current implementation favours https:// URLs over http://, archives
+        from PyPI over those from other locations, wheel compatibility (if a
+        wheel) and then the archive name.
+        """
+        result = url2
+        if url1:
+            s1 = self.score_url(url1)
+            s2 = self.score_url(url2)
+            if s1 > s2:
+                result = url1
+            if result != url2:
+                logger.debug('Not replacing %r with %r', url1, url2)
+            else:
+                logger.debug('Replacing %r with %r', url1, url2)
+        return result
+
+    def split_filename(self, filename, project_name):
+        """
+        Attempt to split a filename in project name, version and Python version.
+        """
+        return split_filename(filename, project_name)
+
+    def convert_url_to_download_info(self, url, project_name):
+        """
+        See if a URL is a candidate for a download URL for a project (the URL
+        has typically been scraped from an HTML page).
+
+        If it is, a dictionary is returned with keys "name", "version",
+        "filename" and "url"; otherwise, None is returned.
+        """
+        def same_project(name1, name2):
+            return normalize_name(name1) == normalize_name(name2)
+
+        result = None
+        scheme, netloc, path, params, query, frag = urlparse(url)
+        if frag.lower().startswith('egg='):  # pragma: no cover
+            logger.debug('%s: version hint in fragment: %r',
+                         project_name, frag)
+        m = HASHER_HASH.match(frag)
+        if m:
+            algo, digest = m.groups()
+        else:
+            algo, digest = None, None
+        origpath = path
+        if path and path[-1] == '/':  # pragma: no cover
+            path = path[:-1]
+        if path.endswith('.whl'):
+            try:
+                wheel = Wheel(path)
+                if not is_compatible(wheel, self.wheel_tags):
+                    logger.debug('Wheel not compatible: %s', path)
+                else:
+                    if project_name is None:
+                        include = True
+                    else:
+                        include = same_project(wheel.name, project_name)
+                    if include:
+                        result = {
+                            'name': wheel.name,
+                            'version': wheel.version,
+                            'filename': wheel.filename,
+                            'url': urlunparse((scheme, netloc, origpath,
+                                               params, query, '')),
+                            'python-version': ', '.join(
+                                ['.'.join(list(v[2:])) for v in wheel.pyver]),
+                        }
+            except Exception:  # pragma: no cover
+                logger.warning('invalid path for wheel: %s', path)
+        elif not path.endswith(self.downloadable_extensions):  # pragma: no cover
+            logger.debug('Not downloadable: %s', path)
+        else:  # downloadable extension
+            path = filename = posixpath.basename(path)
+            for ext in self.downloadable_extensions:
+                if path.endswith(ext):
+                    path = path[:-len(ext)]
+                    t = self.split_filename(path, project_name)
+                    if not t:  # pragma: no cover
+                        logger.debug('No match for project/version: %s', path)
+                    else:
+                        name, version, pyver = t
+                        if not project_name or same_project(project_name, name):
+                            result = {
+                                'name': name,
+                                'version': version,
+                                'filename': filename,
+                                'url': urlunparse((scheme, netloc, origpath,
+                                                   params, query, '')),
+                            }
+                            if pyver:  # pragma: no cover
+                                result['python-version'] = pyver
+                    break
+        if result and algo:
+            result['%s_digest' % algo] = digest
+        return result
+
+    def _get_digest(self, info):
+        """
+        Get a digest from a dictionary by looking at a "digests" dictionary
+        or keys of the form 'algo_digest'.
+
+        Returns a 2-tuple (algo, digest) if found, else None. Currently
+        looks only for SHA256, then MD5.
+        """
+        result = None
+        if 'digests' in info:
+            digests = info['digests']
+            for algo in ('sha256', 'md5'):
+                if algo in digests:
+                    result = (algo, digests[algo])
+                    break
+        if not result:
+            for algo in ('sha256', 'md5'):
+                key = '%s_digest' % algo
+                if key in info:
+                    result = (algo, info[key])
+                    break
+        return result
+
+    def _update_version_data(self, result, info):
+        """
+        Update a result dictionary (the final result from _get_project) with a
+        dictionary for a specific version, which typically holds information
+        gleaned from a filename or URL for an archive for the distribution.
+        """
+        name = info.pop('name')
+        version = info.pop('version')
+        if version in result:
+            dist = result[version]
+            md = dist.metadata
+        else:
+            dist = make_dist(name, version, scheme=self.scheme)
+            md = dist.metadata
+        dist.digest = digest = self._get_digest(info)
+        url = info['url']
+        result['digests'][url] = digest
+        if md.source_url != info['url']:
+            md.source_url = self.prefer_url(md.source_url, url)
+            result['urls'].setdefault(version, set()).add(url)
+        dist.locator = self
+        result[version] = dist
+
+    def locate(self, requirement, prereleases=False):
+        """
+        Find the most recent distribution which matches the given
+        requirement.
+
+        :param requirement: A requirement of the form 'foo (1.0)' or perhaps
+                            'foo (>= 1.0, < 2.0, != 1.3)'
+        :param prereleases: If ``True``, allow pre-release versions
+                            to be located. Otherwise, pre-release versions
+                            are not returned.
+        :return: A :class:`Distribution` instance, or ``None`` if no such
+                 distribution could be located.
+        """
+        result = None
+        r = parse_requirement(requirement)
+        if r is None:  # pragma: no cover
+            raise DistlibException('Not a valid requirement: %r' % requirement)
+        scheme = get_scheme(self.scheme)
+        self.matcher = matcher = scheme.matcher(r.requirement)
+        logger.debug('matcher: %s (%s)', matcher, type(matcher).__name__)
+        versions = self.get_project(r.name)
+        if len(versions) > 2:   # urls and digests keys are present
+            # sometimes, versions are invalid
+            slist = []
+            vcls = matcher.version_class
+            for k in versions:
+                if k in ('urls', 'digests'):
+                    continue
+                try:
+                    if not matcher.match(k):
+                        pass  # logger.debug('%s did not match %r', matcher, k)
+                    else:
+                        if prereleases or not vcls(k).is_prerelease:
+                            slist.append(k)
+                except Exception:  # pragma: no cover
+                    logger.warning('error matching %s with %r', matcher, k)
+                    pass  # slist.append(k)
+            if len(slist) > 1:
+                slist = sorted(slist, key=scheme.key)
+            if slist:
+                logger.debug('sorted list: %s', slist)
+                version = slist[-1]
+                result = versions[version]
+        if result:
+            if r.extras:
+                result.extras = r.extras
+            result.download_urls = versions.get('urls', {}).get(version, set())
+            d = {}
+            sd = versions.get('digests', {})
+            for url in result.download_urls:
+                if url in sd:  # pragma: no cover
+                    d[url] = sd[url]
+            result.digests = d
+        self.matcher = None
+        return result
+
+
+class PyPIRPCLocator(Locator):
+    """
+    This locator uses XML-RPC to locate distributions. It therefore
+    cannot be used with simple mirrors (that only mirror file content).
+    """
+    def __init__(self, url, **kwargs):
+        """
+        Initialise an instance.
+
+        :param url: The URL to use for XML-RPC.
+        :param kwargs: Passed to the superclass constructor.
+        """
+        super(PyPIRPCLocator, self).__init__(**kwargs)
+        self.base_url = url
+        self.client = ServerProxy(url, timeout=3.0)
+
+    def get_distribution_names(self):
+        """
+        Return all the distribution names known to this locator.
+        """
+        return set(self.client.list_packages())
+
+    def _get_project(self, name):
+        result = {'urls': {}, 'digests': {}}
+        versions = self.client.package_releases(name, True)
+        for v in versions:
+            urls = self.client.release_urls(name, v)
+            data = self.client.release_data(name, v)
+            metadata = Metadata(scheme=self.scheme)
+            metadata.name = data['name']
+            metadata.version = data['version']
+            metadata.license = data.get('license')
+            metadata.keywords = data.get('keywords', [])
+            metadata.summary = data.get('summary')
+            dist = Distribution(metadata)
+            if urls:
+                info = urls[0]
+                metadata.source_url = info['url']
+                dist.digest = self._get_digest(info)
+                dist.locator = self
+                result[v] = dist
+                for info in urls:
+                    url = info['url']
+                    digest = self._get_digest(info)
+                    result['urls'].setdefault(v, set()).add(url)
+                    result['digests'][url] = digest
+        return result
+
+
+class PyPIJSONLocator(Locator):
+    """
+    This locator uses PyPI's JSON interface. It's very limited in functionality
+    and probably not worth using.
+    """
+    def __init__(self, url, **kwargs):
+        super(PyPIJSONLocator, self).__init__(**kwargs)
+        self.base_url = ensure_slash(url)
+
+    def get_distribution_names(self):
+        """
+        Return all the distribution names known to this locator.
+        """
+        raise NotImplementedError('Not available from this locator')
+
+    def _get_project(self, name):
+        result = {'urls': {}, 'digests': {}}
+        url = urljoin(self.base_url, '%s/json' % quote(name))
+        try:
+            resp = self.opener.open(url)
+            data = resp.read().decode()  # for now
+            d = json.loads(data)
+            md = Metadata(scheme=self.scheme)
+            data = d['info']
+            md.name = data['name']
+            md.version = data['version']
+            md.license = data.get('license')
+            md.keywords = data.get('keywords', [])
+            md.summary = data.get('summary')
+            dist = Distribution(md)
+            dist.locator = self
+            # urls = d['urls']
+            result[md.version] = dist
+            for info in d['urls']:
+                url = info['url']
+                dist.download_urls.add(url)
+                dist.digests[url] = self._get_digest(info)
+                result['urls'].setdefault(md.version, set()).add(url)
+                result['digests'][url] = self._get_digest(info)
+            # Now get other releases
+            for version, infos in d['releases'].items():
+                if version == md.version:
+                    continue    # already done
+                omd = Metadata(scheme=self.scheme)
+                omd.name = md.name
+                omd.version = version
+                odist = Distribution(omd)
+                odist.locator = self
+                result[version] = odist
+                for info in infos:
+                    url = info['url']
+                    odist.download_urls.add(url)
+                    odist.digests[url] = self._get_digest(info)
+                    result['urls'].setdefault(version, set()).add(url)
+                    result['digests'][url] = self._get_digest(info)
+#            for info in urls:
+#                md.source_url = info['url']
+#                dist.digest = self._get_digest(info)
+#                dist.locator = self
+#                for info in urls:
+#                    url = info['url']
+#                    result['urls'].setdefault(md.version, set()).add(url)
+#                    result['digests'][url] = self._get_digest(info)
+        except Exception as e:
+            self.errors.put(text_type(e))
+            logger.exception('JSON fetch failed: %s', e)
+        return result
+
+
+class Page(object):
+    """
+    This class represents a scraped HTML page.
+    """
+    # The following slightly hairy-looking regex just looks for the contents of
+    # an anchor link, which has an attribute "href" either immediately preceded
+    # or immediately followed by a "rel" attribute. The attribute values can be
+    # declared with double quotes, single quotes or no quotes - which leads to
+    # the length of the expression.
+    _href = re.compile("""
+(rel\\s*=\\s*(?:"(?P[^"]*)"|'(?P[^']*)'|(?P[^>\\s\n]*))\\s+)?
+href\\s*=\\s*(?:"(?P[^"]*)"|'(?P[^']*)'|(?P[^>\\s\n]*))
+(\\s+rel\\s*=\\s*(?:"(?P[^"]*)"|'(?P[^']*)'|(?P[^>\\s\n]*)))?
+""", re.I | re.S | re.X)
+    _base = re.compile(r"""]+)""", re.I | re.S)
+
+    def __init__(self, data, url):
+        """
+        Initialise an instance with the Unicode page contents and the URL they
+        came from.
+        """
+        self.data = data
+        self.base_url = self.url = url
+        m = self._base.search(self.data)
+        if m:
+            self.base_url = m.group(1)
+
+    _clean_re = re.compile(r'[^a-z0-9$&+,/:;=?@.#%_\\|-]', re.I)
+
+    @cached_property
+    def links(self):
+        """
+        Return the URLs of all the links on a page together with information
+        about their "rel" attribute, for determining which ones to treat as
+        downloads and which ones to queue for further scraping.
+        """
+        def clean(url):
+            "Tidy up an URL."
+            scheme, netloc, path, params, query, frag = urlparse(url)
+            return urlunparse((scheme, netloc, quote(path),
+                               params, query, frag))
+
+        result = set()
+        for match in self._href.finditer(self.data):
+            d = match.groupdict('')
+            rel = (d['rel1'] or d['rel2'] or d['rel3'] or
+                   d['rel4'] or d['rel5'] or d['rel6'])
+            url = d['url1'] or d['url2'] or d['url3']
+            url = urljoin(self.base_url, url)
+            url = unescape(url)
+            url = self._clean_re.sub(lambda m: '%%%2x' % ord(m.group(0)), url)
+            result.add((url, rel))
+        # We sort the result, hoping to bring the most recent versions
+        # to the front
+        result = sorted(result, key=lambda t: t[0], reverse=True)
+        return result
+
+
+class SimpleScrapingLocator(Locator):
+    """
+    A locator which scrapes HTML pages to locate downloads for a distribution.
+    This runs multiple threads to do the I/O; performance is at least as good
+    as pip's PackageFinder, which works in an analogous fashion.
+    """
+
+    # These are used to deal with various Content-Encoding schemes.
+    decoders = {
+        'deflate': zlib.decompress,
+        'gzip': lambda b: gzip.GzipFile(fileobj=BytesIO(b)).read(),
+        'none': lambda b: b,
+    }
+
+    def __init__(self, url, timeout=None, num_workers=10, **kwargs):
+        """
+        Initialise an instance.
+        :param url: The root URL to use for scraping.
+        :param timeout: The timeout, in seconds, to be applied to requests.
+                        This defaults to ``None`` (no timeout specified).
+        :param num_workers: The number of worker threads you want to do I/O,
+                            This defaults to 10.
+        :param kwargs: Passed to the superclass.
+        """
+        super(SimpleScrapingLocator, self).__init__(**kwargs)
+        self.base_url = ensure_slash(url)
+        self.timeout = timeout
+        self._page_cache = {}
+        self._seen = set()
+        self._to_fetch = queue.Queue()
+        self._bad_hosts = set()
+        self.skip_externals = False
+        self.num_workers = num_workers
+        self._lock = threading.RLock()
+        # See issue #45: we need to be resilient when the locator is used
+        # in a thread, e.g. with concurrent.futures. We can't use self._lock
+        # as it is for coordinating our internal threads - the ones created
+        # in _prepare_threads.
+        self._gplock = threading.RLock()
+        self.platform_check = False  # See issue #112
+
+    def _prepare_threads(self):
+        """
+        Threads are created only when get_project is called, and terminate
+        before it returns. They are there primarily to parallelise I/O (i.e.
+        fetching web pages).
+        """
+        self._threads = []
+        for i in range(self.num_workers):
+            t = threading.Thread(target=self._fetch)
+            t.daemon = True
+            t.start()
+            self._threads.append(t)
+
+    def _wait_threads(self):
+        """
+        Tell all the threads to terminate (by sending a sentinel value) and
+        wait for them to do so.
+        """
+        # Note that you need two loops, since you can't say which
+        # thread will get each sentinel
+        for t in self._threads:
+            self._to_fetch.put(None)    # sentinel
+        for t in self._threads:
+            t.join()
+        self._threads = []
+
+    def _get_project(self, name):
+        result = {'urls': {}, 'digests': {}}
+        with self._gplock:
+            self.result = result
+            self.project_name = name
+            url = urljoin(self.base_url, '%s/' % quote(name))
+            self._seen.clear()
+            self._page_cache.clear()
+            self._prepare_threads()
+            try:
+                logger.debug('Queueing %s', url)
+                self._to_fetch.put(url)
+                self._to_fetch.join()
+            finally:
+                self._wait_threads()
+            del self.result
+        return result
+
+    platform_dependent = re.compile(r'\b(linux_(i\d86|x86_64|arm\w+)|'
+                                    r'win(32|_amd64)|macosx_?\d+)\b', re.I)
+
+    def _is_platform_dependent(self, url):
+        """
+        Does an URL refer to a platform-specific download?
+        """
+        return self.platform_dependent.search(url)
+
+    def _process_download(self, url):
+        """
+        See if an URL is a suitable download for a project.
+
+        If it is, register information in the result dictionary (for
+        _get_project) about the specific version it's for.
+
+        Note that the return value isn't actually used other than as a boolean
+        value.
+        """
+        if self.platform_check and self._is_platform_dependent(url):
+            info = None
+        else:
+            info = self.convert_url_to_download_info(url, self.project_name)
+        logger.debug('process_download: %s -> %s', url, info)
+        if info:
+            with self._lock:    # needed because self.result is shared
+                self._update_version_data(self.result, info)
+        return info
+
+    def _should_queue(self, link, referrer, rel):
+        """
+        Determine whether a link URL from a referring page and with a
+        particular "rel" attribute should be queued for scraping.
+        """
+        scheme, netloc, path, _, _, _ = urlparse(link)
+        if path.endswith(self.source_extensions + self.binary_extensions +
+                         self.excluded_extensions):
+            result = False
+        elif self.skip_externals and not link.startswith(self.base_url):
+            result = False
+        elif not referrer.startswith(self.base_url):
+            result = False
+        elif rel not in ('homepage', 'download'):
+            result = False
+        elif scheme not in ('http', 'https', 'ftp'):
+            result = False
+        elif self._is_platform_dependent(link):
+            result = False
+        else:
+            host = netloc.split(':', 1)[0]
+            if host.lower() == 'localhost':
+                result = False
+            else:
+                result = True
+        logger.debug('should_queue: %s (%s) from %s -> %s', link, rel,
+                     referrer, result)
+        return result
+
+    def _fetch(self):
+        """
+        Get a URL to fetch from the work queue, get the HTML page, examine its
+        links for download candidates and candidates for further scraping.
+
+        This is a handy method to run in a thread.
+        """
+        while True:
+            url = self._to_fetch.get()
+            try:
+                if url:
+                    page = self.get_page(url)
+                    if page is None:    # e.g. after an error
+                        continue
+                    for link, rel in page.links:
+                        if link not in self._seen:
+                            try:
+                                self._seen.add(link)
+                                if (not self._process_download(link) and
+                                        self._should_queue(link, url, rel)):
+                                    logger.debug('Queueing %s from %s', link, url)
+                                    self._to_fetch.put(link)
+                            except MetadataInvalidError:  # e.g. invalid versions
+                                pass
+            except Exception as e:  # pragma: no cover
+                self.errors.put(text_type(e))
+            finally:
+                # always do this, to avoid hangs :-)
+                self._to_fetch.task_done()
+            if not url:
+                # logger.debug('Sentinel seen, quitting.')
+                break
+
+    def get_page(self, url):
+        """
+        Get the HTML for an URL, possibly from an in-memory cache.
+
+        XXX TODO Note: this cache is never actually cleared. It's assumed that
+        the data won't get stale over the lifetime of a locator instance (not
+        necessarily true for the default_locator).
+        """
+        # http://peak.telecommunity.com/DevCenter/EasyInstall#package-index-api
+        scheme, netloc, path, _, _, _ = urlparse(url)
+        if scheme == 'file' and os.path.isdir(url2pathname(path)):
+            url = urljoin(ensure_slash(url), 'index.html')
+
+        if url in self._page_cache:
+            result = self._page_cache[url]
+            logger.debug('Returning %s from cache: %s', url, result)
+        else:
+            host = netloc.split(':', 1)[0]
+            result = None
+            if host in self._bad_hosts:
+                logger.debug('Skipping %s due to bad host %s', url, host)
+            else:
+                req = Request(url, headers={'Accept-encoding': 'identity'})
+                try:
+                    logger.debug('Fetching %s', url)
+                    resp = self.opener.open(req, timeout=self.timeout)
+                    logger.debug('Fetched %s', url)
+                    headers = resp.info()
+                    content_type = headers.get('Content-Type', '')
+                    if HTML_CONTENT_TYPE.match(content_type):
+                        final_url = resp.geturl()
+                        data = resp.read()
+                        encoding = headers.get('Content-Encoding')
+                        if encoding:
+                            decoder = self.decoders[encoding]   # fail if not found
+                            data = decoder(data)
+                        encoding = 'utf-8'
+                        m = CHARSET.search(content_type)
+                        if m:
+                            encoding = m.group(1)
+                        try:
+                            data = data.decode(encoding)
+                        except UnicodeError:  # pragma: no cover
+                            data = data.decode('latin-1')    # fallback
+                        result = Page(data, final_url)
+                        self._page_cache[final_url] = result
+                except HTTPError as e:
+                    if e.code != 404:
+                        logger.exception('Fetch failed: %s: %s', url, e)
+                except URLError as e:  # pragma: no cover
+                    logger.exception('Fetch failed: %s: %s', url, e)
+                    with self._lock:
+                        self._bad_hosts.add(host)
+                except Exception as e:  # pragma: no cover
+                    logger.exception('Fetch failed: %s: %s', url, e)
+                finally:
+                    self._page_cache[url] = result   # even if None (failure)
+        return result
+
+    _distname_re = re.compile(']*>([^<]+)<')
+
+    def get_distribution_names(self):
+        """
+        Return all the distribution names known to this locator.
+        """
+        result = set()
+        page = self.get_page(self.base_url)
+        if not page:
+            raise DistlibException('Unable to get %s' % self.base_url)
+        for match in self._distname_re.finditer(page.data):
+            result.add(match.group(1))
+        return result
+
+
+class DirectoryLocator(Locator):
+    """
+    This class locates distributions in a directory tree.
+    """
+
+    def __init__(self, path, **kwargs):
+        """
+        Initialise an instance.
+        :param path: The root of the directory tree to search.
+        :param kwargs: Passed to the superclass constructor,
+                       except for:
+                       * recursive - if True (the default), subdirectories are
+                         recursed into. If False, only the top-level directory
+                         is searched,
+        """
+        self.recursive = kwargs.pop('recursive', True)
+        super(DirectoryLocator, self).__init__(**kwargs)
+        path = os.path.abspath(path)
+        if not os.path.isdir(path):  # pragma: no cover
+            raise DistlibException('Not a directory: %r' % path)
+        self.base_dir = path
+
+    def should_include(self, filename, parent):
+        """
+        Should a filename be considered as a candidate for a distribution
+        archive? As well as the filename, the directory which contains it
+        is provided, though not used by the current implementation.
+        """
+        return filename.endswith(self.downloadable_extensions)
+
+    def _get_project(self, name):
+        result = {'urls': {}, 'digests': {}}
+        for root, dirs, files in os.walk(self.base_dir):
+            for fn in files:
+                if self.should_include(fn, root):
+                    fn = os.path.join(root, fn)
+                    url = urlunparse(('file', '',
+                                      pathname2url(os.path.abspath(fn)),
+                                      '', '', ''))
+                    info = self.convert_url_to_download_info(url, name)
+                    if info:
+                        self._update_version_data(result, info)
+            if not self.recursive:
+                break
+        return result
+
+    def get_distribution_names(self):
+        """
+        Return all the distribution names known to this locator.
+        """
+        result = set()
+        for root, dirs, files in os.walk(self.base_dir):
+            for fn in files:
+                if self.should_include(fn, root):
+                    fn = os.path.join(root, fn)
+                    url = urlunparse(('file', '',
+                                      pathname2url(os.path.abspath(fn)),
+                                      '', '', ''))
+                    info = self.convert_url_to_download_info(url, None)
+                    if info:
+                        result.add(info['name'])
+            if not self.recursive:
+                break
+        return result
+
+
+class JSONLocator(Locator):
+    """
+    This locator uses special extended metadata (not available on PyPI) and is
+    the basis of performant dependency resolution in distlib. Other locators
+    require archive downloads before dependencies can be determined! As you
+    might imagine, that can be slow.
+    """
+    def get_distribution_names(self):
+        """
+        Return all the distribution names known to this locator.
+        """
+        raise NotImplementedError('Not available from this locator')
+
+    def _get_project(self, name):
+        result = {'urls': {}, 'digests': {}}
+        data = get_project_data(name)
+        if data:
+            for info in data.get('files', []):
+                if info['ptype'] != 'sdist' or info['pyversion'] != 'source':
+                    continue
+                # We don't store summary in project metadata as it makes
+                # the data bigger for no benefit during dependency
+                # resolution
+                dist = make_dist(data['name'], info['version'],
+                                 summary=data.get('summary',
+                                                  'Placeholder for summary'),
+                                 scheme=self.scheme)
+                md = dist.metadata
+                md.source_url = info['url']
+                # TODO SHA256 digest
+                if 'digest' in info and info['digest']:
+                    dist.digest = ('md5', info['digest'])
+                md.dependencies = info.get('requirements', {})
+                dist.exports = info.get('exports', {})
+                result[dist.version] = dist
+                result['urls'].setdefault(dist.version, set()).add(info['url'])
+        return result
+
+
+class DistPathLocator(Locator):
+    """
+    This locator finds installed distributions in a path. It can be useful for
+    adding to an :class:`AggregatingLocator`.
+    """
+    def __init__(self, distpath, **kwargs):
+        """
+        Initialise an instance.
+
+        :param distpath: A :class:`DistributionPath` instance to search.
+        """
+        super(DistPathLocator, self).__init__(**kwargs)
+        assert isinstance(distpath, DistributionPath)
+        self.distpath = distpath
+
+    def _get_project(self, name):
+        dist = self.distpath.get_distribution(name)
+        if dist is None:
+            result = {'urls': {}, 'digests': {}}
+        else:
+            result = {
+                dist.version: dist,
+                'urls': {dist.version: set([dist.source_url])},
+                'digests': {dist.version: set([None])}
+            }
+        return result
+
+
+class AggregatingLocator(Locator):
+    """
+    This class allows you to chain and/or merge a list of locators.
+    """
+    def __init__(self, *locators, **kwargs):
+        """
+        Initialise an instance.
+
+        :param locators: The list of locators to search.
+        :param kwargs: Passed to the superclass constructor,
+                       except for:
+                       * merge - if False (the default), the first successful
+                         search from any of the locators is returned. If True,
+                         the results from all locators are merged (this can be
+                         slow).
+        """
+        self.merge = kwargs.pop('merge', False)
+        self.locators = locators
+        super(AggregatingLocator, self).__init__(**kwargs)
+
+    def clear_cache(self):
+        super(AggregatingLocator, self).clear_cache()
+        for locator in self.locators:
+            locator.clear_cache()
+
+    def _set_scheme(self, value):
+        self._scheme = value
+        for locator in self.locators:
+            locator.scheme = value
+
+    scheme = property(Locator.scheme.fget, _set_scheme)
+
+    def _get_project(self, name):
+        result = {}
+        for locator in self.locators:
+            d = locator.get_project(name)
+            if d:
+                if self.merge:
+                    files = result.get('urls', {})
+                    digests = result.get('digests', {})
+                    # next line could overwrite result['urls'], result['digests']
+                    result.update(d)
+                    df = result.get('urls')
+                    if files and df:
+                        for k, v in files.items():
+                            if k in df:
+                                df[k] |= v
+                            else:
+                                df[k] = v
+                    dd = result.get('digests')
+                    if digests and dd:
+                        dd.update(digests)
+                else:
+                    # See issue #18. If any dists are found and we're looking
+                    # for specific constraints, we only return something if
+                    # a match is found. For example, if a DirectoryLocator
+                    # returns just foo (1.0) while we're looking for
+                    # foo (>= 2.0), we'll pretend there was nothing there so
+                    # that subsequent locators can be queried. Otherwise we
+                    # would just return foo (1.0) which would then lead to a
+                    # failure to find foo (>= 2.0), because other locators
+                    # weren't searched. Note that this only matters when
+                    # merge=False.
+                    if self.matcher is None:
+                        found = True
+                    else:
+                        found = False
+                        for k in d:
+                            if self.matcher.match(k):
+                                found = True
+                                break
+                    if found:
+                        result = d
+                        break
+        return result
+
+    def get_distribution_names(self):
+        """
+        Return all the distribution names known to this locator.
+        """
+        result = set()
+        for locator in self.locators:
+            try:
+                result |= locator.get_distribution_names()
+            except NotImplementedError:
+                pass
+        return result
+
+
+# We use a legacy scheme simply because most of the dists on PyPI use legacy
+# versions which don't conform to PEP 440.
+default_locator = AggregatingLocator(
+                    # JSONLocator(), # don't use as PEP 426 is withdrawn
+                    SimpleScrapingLocator('https://pypi.org/simple/',
+                                          timeout=3.0),
+                    scheme='legacy')
+
+locate = default_locator.locate
+
+
+class DependencyFinder(object):
+    """
+    Locate dependencies for distributions.
+    """
+
+    def __init__(self, locator=None):
+        """
+        Initialise an instance, using the specified locator
+        to locate distributions.
+        """
+        self.locator = locator or default_locator
+        self.scheme = get_scheme(self.locator.scheme)
+
+    def add_distribution(self, dist):
+        """
+        Add a distribution to the finder. This will update internal information
+        about who provides what.
+        :param dist: The distribution to add.
+        """
+        logger.debug('adding distribution %s', dist)
+        name = dist.key
+        self.dists_by_name[name] = dist
+        self.dists[(name, dist.version)] = dist
+        for p in dist.provides:
+            name, version = parse_name_and_version(p)
+            logger.debug('Add to provided: %s, %s, %s', name, version, dist)
+            self.provided.setdefault(name, set()).add((version, dist))
+
+    def remove_distribution(self, dist):
+        """
+        Remove a distribution from the finder. This will update internal
+        information about who provides what.
+        :param dist: The distribution to remove.
+        """
+        logger.debug('removing distribution %s', dist)
+        name = dist.key
+        del self.dists_by_name[name]
+        del self.dists[(name, dist.version)]
+        for p in dist.provides:
+            name, version = parse_name_and_version(p)
+            logger.debug('Remove from provided: %s, %s, %s', name, version, dist)
+            s = self.provided[name]
+            s.remove((version, dist))
+            if not s:
+                del self.provided[name]
+
+    def get_matcher(self, reqt):
+        """
+        Get a version matcher for a requirement.
+        :param reqt: The requirement
+        :type reqt: str
+        :return: A version matcher (an instance of
+                 :class:`distlib.version.Matcher`).
+        """
+        try:
+            matcher = self.scheme.matcher(reqt)
+        except UnsupportedVersionError:  # pragma: no cover
+            # XXX compat-mode if cannot read the version
+            name = reqt.split()[0]
+            matcher = self.scheme.matcher(name)
+        return matcher
+
+    def find_providers(self, reqt):
+        """
+        Find the distributions which can fulfill a requirement.
+
+        :param reqt: The requirement.
+         :type reqt: str
+        :return: A set of distribution which can fulfill the requirement.
+        """
+        matcher = self.get_matcher(reqt)
+        name = matcher.key   # case-insensitive
+        result = set()
+        provided = self.provided
+        if name in provided:
+            for version, provider in provided[name]:
+                try:
+                    match = matcher.match(version)
+                except UnsupportedVersionError:
+                    match = False
+
+                if match:
+                    result.add(provider)
+                    break
+        return result
+
+    def try_to_replace(self, provider, other, problems):
+        """
+        Attempt to replace one provider with another. This is typically used
+        when resolving dependencies from multiple sources, e.g. A requires
+        (B >= 1.0) while C requires (B >= 1.1).
+
+        For successful replacement, ``provider`` must meet all the requirements
+        which ``other`` fulfills.
+
+        :param provider: The provider we are trying to replace with.
+        :param other: The provider we're trying to replace.
+        :param problems: If False is returned, this will contain what
+                         problems prevented replacement. This is currently
+                         a tuple of the literal string 'cantreplace',
+                         ``provider``, ``other``  and the set of requirements
+                         that ``provider`` couldn't fulfill.
+        :return: True if we can replace ``other`` with ``provider``, else
+                 False.
+        """
+        rlist = self.reqts[other]
+        unmatched = set()
+        for s in rlist:
+            matcher = self.get_matcher(s)
+            if not matcher.match(provider.version):
+                unmatched.add(s)
+        if unmatched:
+            # can't replace other with provider
+            problems.add(('cantreplace', provider, other,
+                          frozenset(unmatched)))
+            result = False
+        else:
+            # can replace other with provider
+            self.remove_distribution(other)
+            del self.reqts[other]
+            for s in rlist:
+                self.reqts.setdefault(provider, set()).add(s)
+            self.add_distribution(provider)
+            result = True
+        return result
+
+    def find(self, requirement, meta_extras=None, prereleases=False):
+        """
+        Find a distribution and all distributions it depends on.
+
+        :param requirement: The requirement specifying the distribution to
+                            find, or a Distribution instance.
+        :param meta_extras: A list of meta extras such as :test:, :build: and
+                            so on.
+        :param prereleases: If ``True``, allow pre-release versions to be
+                            returned - otherwise, don't return prereleases
+                            unless they're all that's available.
+
+        Return a set of :class:`Distribution` instances and a set of
+        problems.
+
+        The distributions returned should be such that they have the
+        :attr:`required` attribute set to ``True`` if they were
+        from the ``requirement`` passed to ``find()``, and they have the
+        :attr:`build_time_dependency` attribute set to ``True`` unless they
+        are post-installation dependencies of the ``requirement``.
+
+        The problems should be a tuple consisting of the string
+        ``'unsatisfied'`` and the requirement which couldn't be satisfied
+        by any distribution known to the locator.
+        """
+
+        self.provided = {}
+        self.dists = {}
+        self.dists_by_name = {}
+        self.reqts = {}
+
+        meta_extras = set(meta_extras or [])
+        if ':*:' in meta_extras:
+            meta_extras.remove(':*:')
+            # :meta: and :run: are implicitly included
+            meta_extras |= set([':test:', ':build:', ':dev:'])
+
+        if isinstance(requirement, Distribution):
+            dist = odist = requirement
+            logger.debug('passed %s as requirement', odist)
+        else:
+            dist = odist = self.locator.locate(requirement,
+                                               prereleases=prereleases)
+            if dist is None:
+                raise DistlibException('Unable to locate %r' % requirement)
+            logger.debug('located %s', odist)
+        dist.requested = True
+        problems = set()
+        todo = set([dist])
+        install_dists = set([odist])
+        while todo:
+            dist = todo.pop()
+            name = dist.key     # case-insensitive
+            if name not in self.dists_by_name:
+                self.add_distribution(dist)
+            else:
+                # import pdb; pdb.set_trace()
+                other = self.dists_by_name[name]
+                if other != dist:
+                    self.try_to_replace(dist, other, problems)
+
+            ireqts = dist.run_requires | dist.meta_requires
+            sreqts = dist.build_requires
+            ereqts = set()
+            if meta_extras and dist in install_dists:
+                for key in ('test', 'build', 'dev'):
+                    e = ':%s:' % key
+                    if e in meta_extras:
+                        ereqts |= getattr(dist, '%s_requires' % key)
+            all_reqts = ireqts | sreqts | ereqts
+            for r in all_reqts:
+                providers = self.find_providers(r)
+                if not providers:
+                    logger.debug('No providers found for %r', r)
+                    provider = self.locator.locate(r, prereleases=prereleases)
+                    # If no provider is found and we didn't consider
+                    # prereleases, consider them now.
+                    if provider is None and not prereleases:
+                        provider = self.locator.locate(r, prereleases=True)
+                    if provider is None:
+                        logger.debug('Cannot satisfy %r', r)
+                        problems.add(('unsatisfied', r))
+                    else:
+                        n, v = provider.key, provider.version
+                        if (n, v) not in self.dists:
+                            todo.add(provider)
+                        providers.add(provider)
+                        if r in ireqts and dist in install_dists:
+                            install_dists.add(provider)
+                            logger.debug('Adding %s to install_dists',
+                                         provider.name_and_version)
+                for p in providers:
+                    name = p.key
+                    if name not in self.dists_by_name:
+                        self.reqts.setdefault(p, set()).add(r)
+                    else:
+                        other = self.dists_by_name[name]
+                        if other != p:
+                            # see if other can be replaced by p
+                            self.try_to_replace(p, other, problems)
+
+        dists = set(self.dists.values())
+        for dist in dists:
+            dist.build_time_dependency = dist not in install_dists
+            if dist.build_time_dependency:
+                logger.debug('%s is a build-time dependency only.',
+                             dist.name_and_version)
+        logger.debug('find done for %s', odist)
+        return dists, problems
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/distlib/manifest.py b/venv/lib/python3.12/site-packages/pip/_vendor/distlib/manifest.py
new file mode 100644
index 00000000..420dcf12
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_vendor/distlib/manifest.py
@@ -0,0 +1,384 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2012-2023 Python Software Foundation.
+# See LICENSE.txt and CONTRIBUTORS.txt.
+#
+"""
+Class representing the list of files in a distribution.
+
+Equivalent to distutils.filelist, but fixes some problems.
+"""
+import fnmatch
+import logging
+import os
+import re
+import sys
+
+from . import DistlibException
+from .compat import fsdecode
+from .util import convert_path
+
+
+__all__ = ['Manifest']
+
+logger = logging.getLogger(__name__)
+
+# a \ followed by some spaces + EOL
+_COLLAPSE_PATTERN = re.compile('\\\\w*\n', re.M)
+_COMMENTED_LINE = re.compile('#.*?(?=\n)|\n(?=$)', re.M | re.S)
+
+#
+# Due to the different results returned by fnmatch.translate, we need
+# to do slightly different processing for Python 2.7 and 3.2 ... this needed
+# to be brought in for Python 3.6 onwards.
+#
+_PYTHON_VERSION = sys.version_info[:2]
+
+
+class Manifest(object):
+    """
+    A list of files built by exploring the filesystem and filtered by applying various
+    patterns to what we find there.
+    """
+
+    def __init__(self, base=None):
+        """
+        Initialise an instance.
+
+        :param base: The base directory to explore under.
+        """
+        self.base = os.path.abspath(os.path.normpath(base or os.getcwd()))
+        self.prefix = self.base + os.sep
+        self.allfiles = None
+        self.files = set()
+
+    #
+    # Public API
+    #
+
+    def findall(self):
+        """Find all files under the base and set ``allfiles`` to the absolute
+        pathnames of files found.
+        """
+        from stat import S_ISREG, S_ISDIR, S_ISLNK
+
+        self.allfiles = allfiles = []
+        root = self.base
+        stack = [root]
+        pop = stack.pop
+        push = stack.append
+
+        while stack:
+            root = pop()
+            names = os.listdir(root)
+
+            for name in names:
+                fullname = os.path.join(root, name)
+
+                # Avoid excess stat calls -- just one will do, thank you!
+                stat = os.stat(fullname)
+                mode = stat.st_mode
+                if S_ISREG(mode):
+                    allfiles.append(fsdecode(fullname))
+                elif S_ISDIR(mode) and not S_ISLNK(mode):
+                    push(fullname)
+
+    def add(self, item):
+        """
+        Add a file to the manifest.
+
+        :param item: The pathname to add. This can be relative to the base.
+        """
+        if not item.startswith(self.prefix):
+            item = os.path.join(self.base, item)
+        self.files.add(os.path.normpath(item))
+
+    def add_many(self, items):
+        """
+        Add a list of files to the manifest.
+
+        :param items: The pathnames to add. These can be relative to the base.
+        """
+        for item in items:
+            self.add(item)
+
+    def sorted(self, wantdirs=False):
+        """
+        Return sorted files in directory order
+        """
+
+        def add_dir(dirs, d):
+            dirs.add(d)
+            logger.debug('add_dir added %s', d)
+            if d != self.base:
+                parent, _ = os.path.split(d)
+                assert parent not in ('', '/')
+                add_dir(dirs, parent)
+
+        result = set(self.files)    # make a copy!
+        if wantdirs:
+            dirs = set()
+            for f in result:
+                add_dir(dirs, os.path.dirname(f))
+            result |= dirs
+        return [os.path.join(*path_tuple) for path_tuple in
+                sorted(os.path.split(path) for path in result)]
+
+    def clear(self):
+        """Clear all collected files."""
+        self.files = set()
+        self.allfiles = []
+
+    def process_directive(self, directive):
+        """
+        Process a directive which either adds some files from ``allfiles`` to
+        ``files``, or removes some files from ``files``.
+
+        :param directive: The directive to process. This should be in a format
+                     compatible with distutils ``MANIFEST.in`` files:
+
+                     http://docs.python.org/distutils/sourcedist.html#commands
+        """
+        # Parse the line: split it up, make sure the right number of words
+        # is there, and return the relevant words.  'action' is always
+        # defined: it's the first word of the line.  Which of the other
+        # three are defined depends on the action; it'll be either
+        # patterns, (dir and patterns), or (dirpattern).
+        action, patterns, thedir, dirpattern = self._parse_directive(directive)
+
+        # OK, now we know that the action is valid and we have the
+        # right number of words on the line for that action -- so we
+        # can proceed with minimal error-checking.
+        if action == 'include':
+            for pattern in patterns:
+                if not self._include_pattern(pattern, anchor=True):
+                    logger.warning('no files found matching %r', pattern)
+
+        elif action == 'exclude':
+            for pattern in patterns:
+                self._exclude_pattern(pattern, anchor=True)
+
+        elif action == 'global-include':
+            for pattern in patterns:
+                if not self._include_pattern(pattern, anchor=False):
+                    logger.warning('no files found matching %r '
+                                   'anywhere in distribution', pattern)
+
+        elif action == 'global-exclude':
+            for pattern in patterns:
+                self._exclude_pattern(pattern, anchor=False)
+
+        elif action == 'recursive-include':
+            for pattern in patterns:
+                if not self._include_pattern(pattern, prefix=thedir):
+                    logger.warning('no files found matching %r '
+                                   'under directory %r', pattern, thedir)
+
+        elif action == 'recursive-exclude':
+            for pattern in patterns:
+                self._exclude_pattern(pattern, prefix=thedir)
+
+        elif action == 'graft':
+            if not self._include_pattern(None, prefix=dirpattern):
+                logger.warning('no directories found matching %r',
+                               dirpattern)
+
+        elif action == 'prune':
+            if not self._exclude_pattern(None, prefix=dirpattern):
+                logger.warning('no previously-included directories found '
+                               'matching %r', dirpattern)
+        else:   # pragma: no cover
+            # This should never happen, as it should be caught in
+            # _parse_template_line
+            raise DistlibException(
+                'invalid action %r' % action)
+
+    #
+    # Private API
+    #
+
+    def _parse_directive(self, directive):
+        """
+        Validate a directive.
+        :param directive: The directive to validate.
+        :return: A tuple of action, patterns, thedir, dir_patterns
+        """
+        words = directive.split()
+        if len(words) == 1 and words[0] not in ('include', 'exclude',
+                                                'global-include',
+                                                'global-exclude',
+                                                'recursive-include',
+                                                'recursive-exclude',
+                                                'graft', 'prune'):
+            # no action given, let's use the default 'include'
+            words.insert(0, 'include')
+
+        action = words[0]
+        patterns = thedir = dir_pattern = None
+
+        if action in ('include', 'exclude',
+                      'global-include', 'global-exclude'):
+            if len(words) < 2:
+                raise DistlibException(
+                    '%r expects   ...' % action)
+
+            patterns = [convert_path(word) for word in words[1:]]
+
+        elif action in ('recursive-include', 'recursive-exclude'):
+            if len(words) < 3:
+                raise DistlibException(
+                    '%r expects    ...' % action)
+
+            thedir = convert_path(words[1])
+            patterns = [convert_path(word) for word in words[2:]]
+
+        elif action in ('graft', 'prune'):
+            if len(words) != 2:
+                raise DistlibException(
+                    '%r expects a single ' % action)
+
+            dir_pattern = convert_path(words[1])
+
+        else:
+            raise DistlibException('unknown action %r' % action)
+
+        return action, patterns, thedir, dir_pattern
+
+    def _include_pattern(self, pattern, anchor=True, prefix=None,
+                         is_regex=False):
+        """Select strings (presumably filenames) from 'self.files' that
+        match 'pattern', a Unix-style wildcard (glob) pattern.
+
+        Patterns are not quite the same as implemented by the 'fnmatch'
+        module: '*' and '?'  match non-special characters, where "special"
+        is platform-dependent: slash on Unix; colon, slash, and backslash on
+        DOS/Windows; and colon on Mac OS.
+
+        If 'anchor' is true (the default), then the pattern match is more
+        stringent: "*.py" will match "foo.py" but not "foo/bar.py".  If
+        'anchor' is false, both of these will match.
+
+        If 'prefix' is supplied, then only filenames starting with 'prefix'
+        (itself a pattern) and ending with 'pattern', with anything in between
+        them, will match.  'anchor' is ignored in this case.
+
+        If 'is_regex' is true, 'anchor' and 'prefix' are ignored, and
+        'pattern' is assumed to be either a string containing a regex or a
+        regex object -- no translation is done, the regex is just compiled
+        and used as-is.
+
+        Selected strings will be added to self.files.
+
+        Return True if files are found.
+        """
+        # XXX docstring lying about what the special chars are?
+        found = False
+        pattern_re = self._translate_pattern(pattern, anchor, prefix, is_regex)
+
+        # delayed loading of allfiles list
+        if self.allfiles is None:
+            self.findall()
+
+        for name in self.allfiles:
+            if pattern_re.search(name):
+                self.files.add(name)
+                found = True
+        return found
+
+    def _exclude_pattern(self, pattern, anchor=True, prefix=None,
+                         is_regex=False):
+        """Remove strings (presumably filenames) from 'files' that match
+        'pattern'.
+
+        Other parameters are the same as for 'include_pattern()', above.
+        The list 'self.files' is modified in place. Return True if files are
+        found.
+
+        This API is public to allow e.g. exclusion of SCM subdirs, e.g. when
+        packaging source distributions
+        """
+        found = False
+        pattern_re = self._translate_pattern(pattern, anchor, prefix, is_regex)
+        for f in list(self.files):
+            if pattern_re.search(f):
+                self.files.remove(f)
+                found = True
+        return found
+
+    def _translate_pattern(self, pattern, anchor=True, prefix=None,
+                           is_regex=False):
+        """Translate a shell-like wildcard pattern to a compiled regular
+        expression.
+
+        Return the compiled regex.  If 'is_regex' true,
+        then 'pattern' is directly compiled to a regex (if it's a string)
+        or just returned as-is (assumes it's a regex object).
+        """
+        if is_regex:
+            if isinstance(pattern, str):
+                return re.compile(pattern)
+            else:
+                return pattern
+
+        if _PYTHON_VERSION > (3, 2):
+            # ditch start and end characters
+            start, _, end = self._glob_to_re('_').partition('_')
+
+        if pattern:
+            pattern_re = self._glob_to_re(pattern)
+            if _PYTHON_VERSION > (3, 2):
+                assert pattern_re.startswith(start) and pattern_re.endswith(end)
+        else:
+            pattern_re = ''
+
+        base = re.escape(os.path.join(self.base, ''))
+        if prefix is not None:
+            # ditch end of pattern character
+            if _PYTHON_VERSION <= (3, 2):
+                empty_pattern = self._glob_to_re('')
+                prefix_re = self._glob_to_re(prefix)[:-len(empty_pattern)]
+            else:
+                prefix_re = self._glob_to_re(prefix)
+                assert prefix_re.startswith(start) and prefix_re.endswith(end)
+                prefix_re = prefix_re[len(start): len(prefix_re) - len(end)]
+            sep = os.sep
+            if os.sep == '\\':
+                sep = r'\\'
+            if _PYTHON_VERSION <= (3, 2):
+                pattern_re = '^' + base + sep.join((prefix_re,
+                                                    '.*' + pattern_re))
+            else:
+                pattern_re = pattern_re[len(start): len(pattern_re) - len(end)]
+                pattern_re = r'%s%s%s%s.*%s%s' % (start, base, prefix_re, sep,
+                                                  pattern_re, end)
+        else:  # no prefix -- respect anchor flag
+            if anchor:
+                if _PYTHON_VERSION <= (3, 2):
+                    pattern_re = '^' + base + pattern_re
+                else:
+                    pattern_re = r'%s%s%s' % (start, base, pattern_re[len(start):])
+
+        return re.compile(pattern_re)
+
+    def _glob_to_re(self, pattern):
+        """Translate a shell-like glob pattern to a regular expression.
+
+        Return a string containing the regex.  Differs from
+        'fnmatch.translate()' in that '*' does not match "special characters"
+        (which are platform-specific).
+        """
+        pattern_re = fnmatch.translate(pattern)
+
+        # '?' and '*' in the glob pattern become '.' and '.*' in the RE, which
+        # IMHO is wrong -- '?' and '*' aren't supposed to match slash in Unix,
+        # and by extension they shouldn't match such "special characters" under
+        # any OS.  So change all non-escaped dots in the RE to match any
+        # character except the special characters (currently: just os.sep).
+        sep = os.sep
+        if os.sep == '\\':
+            # we're using a regex to manipulate a regex, so we need
+            # to escape the backslash twice
+            sep = r'\\\\'
+        escaped = r'\1[^%s]' % sep
+        pattern_re = re.sub(r'((? y,
+        '!=': lambda x, y: x != y,
+        '<': lambda x, y: x < y,
+        '<=': lambda x, y: x == y or x < y,
+        '>': lambda x, y: x > y,
+        '>=': lambda x, y: x == y or x > y,
+        'and': lambda x, y: x and y,
+        'or': lambda x, y: x or y,
+        'in': lambda x, y: x in y,
+        'not in': lambda x, y: x not in y,
+    }
+
+    def evaluate(self, expr, context):
+        """
+        Evaluate a marker expression returned by the :func:`parse_requirement`
+        function in the specified context.
+        """
+        if isinstance(expr, string_types):
+            if expr[0] in '\'"':
+                result = expr[1:-1]
+            else:
+                if expr not in context:
+                    raise SyntaxError('unknown variable: %s' % expr)
+                result = context[expr]
+        else:
+            assert isinstance(expr, dict)
+            op = expr['op']
+            if op not in self.operations:
+                raise NotImplementedError('op not implemented: %s' % op)
+            elhs = expr['lhs']
+            erhs = expr['rhs']
+            if _is_literal(expr['lhs']) and _is_literal(expr['rhs']):
+                raise SyntaxError('invalid comparison: %s %s %s' %
+                                  (elhs, op, erhs))
+
+            lhs = self.evaluate(elhs, context)
+            rhs = self.evaluate(erhs, context)
+            if ((_is_version_marker(elhs) or _is_version_marker(erhs))
+                    and op in ('<', '<=', '>', '>=', '===', '==', '!=', '~=')):
+                lhs = LV(lhs)
+                rhs = LV(rhs)
+            elif _is_version_marker(elhs) and op in ('in', 'not in'):
+                lhs = LV(lhs)
+                rhs = _get_versions(rhs)
+            result = self.operations[op](lhs, rhs)
+        return result
+
+
+_DIGITS = re.compile(r'\d+\.\d+')
+
+
+def default_context():
+
+    def format_full_version(info):
+        version = '%s.%s.%s' % (info.major, info.minor, info.micro)
+        kind = info.releaselevel
+        if kind != 'final':
+            version += kind[0] + str(info.serial)
+        return version
+
+    if hasattr(sys, 'implementation'):
+        implementation_version = format_full_version(
+            sys.implementation.version)
+        implementation_name = sys.implementation.name
+    else:
+        implementation_version = '0'
+        implementation_name = ''
+
+    ppv = platform.python_version()
+    m = _DIGITS.match(ppv)
+    pv = m.group(0)
+    result = {
+        'implementation_name': implementation_name,
+        'implementation_version': implementation_version,
+        'os_name': os.name,
+        'platform_machine': platform.machine(),
+        'platform_python_implementation': platform.python_implementation(),
+        'platform_release': platform.release(),
+        'platform_system': platform.system(),
+        'platform_version': platform.version(),
+        'platform_in_venv': str(in_venv()),
+        'python_full_version': ppv,
+        'python_version': pv,
+        'sys_platform': sys.platform,
+    }
+    return result
+
+
+DEFAULT_CONTEXT = default_context()
+del default_context
+
+evaluator = Evaluator()
+
+
+def interpret(marker, execution_context=None):
+    """
+    Interpret a marker and return a result depending on environment.
+
+    :param marker: The marker to interpret.
+    :type marker: str
+    :param execution_context: The context used for name lookup.
+    :type execution_context: mapping
+    """
+    try:
+        expr, rest = parse_marker(marker)
+    except Exception as e:
+        raise SyntaxError('Unable to interpret marker syntax: %s: %s' %
+                          (marker, e))
+    if rest and rest[0] != '#':
+        raise SyntaxError('unexpected trailing data in marker: %s: %s' %
+                          (marker, rest))
+    context = dict(DEFAULT_CONTEXT)
+    if execution_context:
+        context.update(execution_context)
+    return evaluator.evaluate(expr, context)
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/distlib/metadata.py b/venv/lib/python3.12/site-packages/pip/_vendor/distlib/metadata.py
new file mode 100644
index 00000000..7189aeef
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_vendor/distlib/metadata.py
@@ -0,0 +1,1068 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2012 The Python Software Foundation.
+# See LICENSE.txt and CONTRIBUTORS.txt.
+#
+"""Implementation of the Metadata for Python packages PEPs.
+
+Supports all metadata formats (1.0, 1.1, 1.2, 1.3/2.1 and 2.2).
+"""
+from __future__ import unicode_literals
+
+import codecs
+from email import message_from_file
+import json
+import logging
+import re
+
+
+from . import DistlibException, __version__
+from .compat import StringIO, string_types, text_type
+from .markers import interpret
+from .util import extract_by_key, get_extras
+from .version import get_scheme, PEP440_VERSION_RE
+
+logger = logging.getLogger(__name__)
+
+
+class MetadataMissingError(DistlibException):
+    """A required metadata is missing"""
+
+
+class MetadataConflictError(DistlibException):
+    """Attempt to read or write metadata fields that are conflictual."""
+
+
+class MetadataUnrecognizedVersionError(DistlibException):
+    """Unknown metadata version number."""
+
+
+class MetadataInvalidError(DistlibException):
+    """A metadata value is invalid"""
+
+# public API of this module
+__all__ = ['Metadata', 'PKG_INFO_ENCODING', 'PKG_INFO_PREFERRED_VERSION']
+
+# Encoding used for the PKG-INFO files
+PKG_INFO_ENCODING = 'utf-8'
+
+# preferred version. Hopefully will be changed
+# to 1.2 once PEP 345 is supported everywhere
+PKG_INFO_PREFERRED_VERSION = '1.1'
+
+_LINE_PREFIX_1_2 = re.compile('\n       \\|')
+_LINE_PREFIX_PRE_1_2 = re.compile('\n        ')
+_241_FIELDS = ('Metadata-Version', 'Name', 'Version', 'Platform',
+               'Summary', 'Description',
+               'Keywords', 'Home-page', 'Author', 'Author-email',
+               'License')
+
+_314_FIELDS = ('Metadata-Version', 'Name', 'Version', 'Platform',
+               'Supported-Platform', 'Summary', 'Description',
+               'Keywords', 'Home-page', 'Author', 'Author-email',
+               'License', 'Classifier', 'Download-URL', 'Obsoletes',
+               'Provides', 'Requires')
+
+_314_MARKERS = ('Obsoletes', 'Provides', 'Requires', 'Classifier',
+                'Download-URL')
+
+_345_FIELDS = ('Metadata-Version', 'Name', 'Version', 'Platform',
+               'Supported-Platform', 'Summary', 'Description',
+               'Keywords', 'Home-page', 'Author', 'Author-email',
+               'Maintainer', 'Maintainer-email', 'License',
+               'Classifier', 'Download-URL', 'Obsoletes-Dist',
+               'Project-URL', 'Provides-Dist', 'Requires-Dist',
+               'Requires-Python', 'Requires-External')
+
+_345_MARKERS = ('Provides-Dist', 'Requires-Dist', 'Requires-Python',
+                'Obsoletes-Dist', 'Requires-External', 'Maintainer',
+                'Maintainer-email', 'Project-URL')
+
+_426_FIELDS = ('Metadata-Version', 'Name', 'Version', 'Platform',
+               'Supported-Platform', 'Summary', 'Description',
+               'Keywords', 'Home-page', 'Author', 'Author-email',
+               'Maintainer', 'Maintainer-email', 'License',
+               'Classifier', 'Download-URL', 'Obsoletes-Dist',
+               'Project-URL', 'Provides-Dist', 'Requires-Dist',
+               'Requires-Python', 'Requires-External', 'Private-Version',
+               'Obsoleted-By', 'Setup-Requires-Dist', 'Extension',
+               'Provides-Extra')
+
+_426_MARKERS = ('Private-Version', 'Provides-Extra', 'Obsoleted-By',
+                'Setup-Requires-Dist', 'Extension')
+
+# See issue #106: Sometimes 'Requires' and 'Provides' occur wrongly in
+# the metadata. Include them in the tuple literal below to allow them
+# (for now).
+# Ditto for Obsoletes - see issue #140.
+_566_FIELDS = _426_FIELDS + ('Description-Content-Type',
+                             'Requires', 'Provides', 'Obsoletes')
+
+_566_MARKERS = ('Description-Content-Type',)
+
+_643_MARKERS = ('Dynamic', 'License-File')
+
+_643_FIELDS = _566_FIELDS + _643_MARKERS
+
+_ALL_FIELDS = set()
+_ALL_FIELDS.update(_241_FIELDS)
+_ALL_FIELDS.update(_314_FIELDS)
+_ALL_FIELDS.update(_345_FIELDS)
+_ALL_FIELDS.update(_426_FIELDS)
+_ALL_FIELDS.update(_566_FIELDS)
+_ALL_FIELDS.update(_643_FIELDS)
+
+EXTRA_RE = re.compile(r'''extra\s*==\s*("([^"]+)"|'([^']+)')''')
+
+
+def _version2fieldlist(version):
+    if version == '1.0':
+        return _241_FIELDS
+    elif version == '1.1':
+        return _314_FIELDS
+    elif version == '1.2':
+        return _345_FIELDS
+    elif version in ('1.3', '2.1'):
+        # avoid adding field names if already there
+        return _345_FIELDS + tuple(f for f in _566_FIELDS if f not in _345_FIELDS)
+    elif version == '2.0':
+        raise ValueError('Metadata 2.0 is withdrawn and not supported')
+        # return _426_FIELDS
+    elif version == '2.2':
+        return _643_FIELDS
+    raise MetadataUnrecognizedVersionError(version)
+
+
+def _best_version(fields):
+    """Detect the best version depending on the fields used."""
+    def _has_marker(keys, markers):
+        return any(marker in keys for marker in markers)
+
+    keys = [key for key, value in fields.items() if value not in ([], 'UNKNOWN', None)]
+    possible_versions = ['1.0', '1.1', '1.2', '1.3', '2.1', '2.2']  # 2.0 removed
+
+    # first let's try to see if a field is not part of one of the version
+    for key in keys:
+        if key not in _241_FIELDS and '1.0' in possible_versions:
+            possible_versions.remove('1.0')
+            logger.debug('Removed 1.0 due to %s', key)
+        if key not in _314_FIELDS and '1.1' in possible_versions:
+            possible_versions.remove('1.1')
+            logger.debug('Removed 1.1 due to %s', key)
+        if key not in _345_FIELDS and '1.2' in possible_versions:
+            possible_versions.remove('1.2')
+            logger.debug('Removed 1.2 due to %s', key)
+        if key not in _566_FIELDS and '1.3' in possible_versions:
+            possible_versions.remove('1.3')
+            logger.debug('Removed 1.3 due to %s', key)
+        if key not in _566_FIELDS and '2.1' in possible_versions:
+            if key != 'Description':  # In 2.1, description allowed after headers
+                possible_versions.remove('2.1')
+                logger.debug('Removed 2.1 due to %s', key)
+        if key not in _643_FIELDS and '2.2' in possible_versions:
+            possible_versions.remove('2.2')
+            logger.debug('Removed 2.2 due to %s', key)
+        # if key not in _426_FIELDS and '2.0' in possible_versions:
+            # possible_versions.remove('2.0')
+            # logger.debug('Removed 2.0 due to %s', key)
+
+    # possible_version contains qualified versions
+    if len(possible_versions) == 1:
+        return possible_versions[0]   # found !
+    elif len(possible_versions) == 0:
+        logger.debug('Out of options - unknown metadata set: %s', fields)
+        raise MetadataConflictError('Unknown metadata set')
+
+    # let's see if one unique marker is found
+    is_1_1 = '1.1' in possible_versions and _has_marker(keys, _314_MARKERS)
+    is_1_2 = '1.2' in possible_versions and _has_marker(keys, _345_MARKERS)
+    is_2_1 = '2.1' in possible_versions and _has_marker(keys, _566_MARKERS)
+    # is_2_0 = '2.0' in possible_versions and _has_marker(keys, _426_MARKERS)
+    is_2_2 = '2.2' in possible_versions and _has_marker(keys, _643_MARKERS)
+    if int(is_1_1) + int(is_1_2) + int(is_2_1) + int(is_2_2) > 1:
+        raise MetadataConflictError('You used incompatible 1.1/1.2/2.1/2.2 fields')
+
+    # we have the choice, 1.0, or 1.2, 2.1 or 2.2
+    #   - 1.0 has a broken Summary field but works with all tools
+    #   - 1.1 is to avoid
+    #   - 1.2 fixes Summary but has little adoption
+    #   - 2.1 adds more features
+    #   - 2.2 is the latest
+    if not is_1_1 and not is_1_2 and not is_2_1 and not is_2_2:
+        # we couldn't find any specific marker
+        if PKG_INFO_PREFERRED_VERSION in possible_versions:
+            return PKG_INFO_PREFERRED_VERSION
+    if is_1_1:
+        return '1.1'
+    if is_1_2:
+        return '1.2'
+    if is_2_1:
+        return '2.1'
+    # if is_2_2:
+        # return '2.2'
+
+    return '2.2'
+
+# This follows the rules about transforming keys as described in
+# https://www.python.org/dev/peps/pep-0566/#id17
+_ATTR2FIELD = {
+    name.lower().replace("-", "_"): name for name in _ALL_FIELDS
+}
+_FIELD2ATTR = {field: attr for attr, field in _ATTR2FIELD.items()}
+
+_PREDICATE_FIELDS = ('Requires-Dist', 'Obsoletes-Dist', 'Provides-Dist')
+_VERSIONS_FIELDS = ('Requires-Python',)
+_VERSION_FIELDS = ('Version',)
+_LISTFIELDS = ('Platform', 'Classifier', 'Obsoletes',
+               'Requires', 'Provides', 'Obsoletes-Dist',
+               'Provides-Dist', 'Requires-Dist', 'Requires-External',
+               'Project-URL', 'Supported-Platform', 'Setup-Requires-Dist',
+               'Provides-Extra', 'Extension', 'License-File')
+_LISTTUPLEFIELDS = ('Project-URL',)
+
+_ELEMENTSFIELD = ('Keywords',)
+
+_UNICODEFIELDS = ('Author', 'Maintainer', 'Summary', 'Description')
+
+_MISSING = object()
+
+_FILESAFE = re.compile('[^A-Za-z0-9.]+')
+
+
+def _get_name_and_version(name, version, for_filename=False):
+    """Return the distribution name with version.
+
+    If for_filename is true, return a filename-escaped form."""
+    if for_filename:
+        # For both name and version any runs of non-alphanumeric or '.'
+        # characters are replaced with a single '-'.  Additionally any
+        # spaces in the version string become '.'
+        name = _FILESAFE.sub('-', name)
+        version = _FILESAFE.sub('-', version.replace(' ', '.'))
+    return '%s-%s' % (name, version)
+
+
+class LegacyMetadata(object):
+    """The legacy metadata of a release.
+
+    Supports versions 1.0, 1.1, 1.2, 2.0 and 1.3/2.1 (auto-detected). You can
+    instantiate the class with one of these arguments (or none):
+    - *path*, the path to a metadata file
+    - *fileobj* give a file-like object with metadata as content
+    - *mapping* is a dict-like object
+    - *scheme* is a version scheme name
+    """
+    # TODO document the mapping API and UNKNOWN default key
+
+    def __init__(self, path=None, fileobj=None, mapping=None,
+                 scheme='default'):
+        if [path, fileobj, mapping].count(None) < 2:
+            raise TypeError('path, fileobj and mapping are exclusive')
+        self._fields = {}
+        self.requires_files = []
+        self._dependencies = None
+        self.scheme = scheme
+        if path is not None:
+            self.read(path)
+        elif fileobj is not None:
+            self.read_file(fileobj)
+        elif mapping is not None:
+            self.update(mapping)
+            self.set_metadata_version()
+
+    def set_metadata_version(self):
+        self._fields['Metadata-Version'] = _best_version(self._fields)
+
+    def _write_field(self, fileobj, name, value):
+        fileobj.write('%s: %s\n' % (name, value))
+
+    def __getitem__(self, name):
+        return self.get(name)
+
+    def __setitem__(self, name, value):
+        return self.set(name, value)
+
+    def __delitem__(self, name):
+        field_name = self._convert_name(name)
+        try:
+            del self._fields[field_name]
+        except KeyError:
+            raise KeyError(name)
+
+    def __contains__(self, name):
+        return (name in self._fields or
+                self._convert_name(name) in self._fields)
+
+    def _convert_name(self, name):
+        if name in _ALL_FIELDS:
+            return name
+        name = name.replace('-', '_').lower()
+        return _ATTR2FIELD.get(name, name)
+
+    def _default_value(self, name):
+        if name in _LISTFIELDS or name in _ELEMENTSFIELD:
+            return []
+        return 'UNKNOWN'
+
+    def _remove_line_prefix(self, value):
+        if self.metadata_version in ('1.0', '1.1'):
+            return _LINE_PREFIX_PRE_1_2.sub('\n', value)
+        else:
+            return _LINE_PREFIX_1_2.sub('\n', value)
+
+    def __getattr__(self, name):
+        if name in _ATTR2FIELD:
+            return self[name]
+        raise AttributeError(name)
+
+    #
+    # Public API
+    #
+
+#    dependencies = property(_get_dependencies, _set_dependencies)
+
+    def get_fullname(self, filesafe=False):
+        """Return the distribution name with version.
+
+        If filesafe is true, return a filename-escaped form."""
+        return _get_name_and_version(self['Name'], self['Version'], filesafe)
+
+    def is_field(self, name):
+        """return True if name is a valid metadata key"""
+        name = self._convert_name(name)
+        return name in _ALL_FIELDS
+
+    def is_multi_field(self, name):
+        name = self._convert_name(name)
+        return name in _LISTFIELDS
+
+    def read(self, filepath):
+        """Read the metadata values from a file path."""
+        fp = codecs.open(filepath, 'r', encoding='utf-8')
+        try:
+            self.read_file(fp)
+        finally:
+            fp.close()
+
+    def read_file(self, fileob):
+        """Read the metadata values from a file object."""
+        msg = message_from_file(fileob)
+        self._fields['Metadata-Version'] = msg['metadata-version']
+
+        # When reading, get all the fields we can
+        for field in _ALL_FIELDS:
+            if field not in msg:
+                continue
+            if field in _LISTFIELDS:
+                # we can have multiple lines
+                values = msg.get_all(field)
+                if field in _LISTTUPLEFIELDS and values is not None:
+                    values = [tuple(value.split(',')) for value in values]
+                self.set(field, values)
+            else:
+                # single line
+                value = msg[field]
+                if value is not None and value != 'UNKNOWN':
+                    self.set(field, value)
+
+        # PEP 566 specifies that the body be used for the description, if
+        # available
+        body = msg.get_payload()
+        self["Description"] = body if body else self["Description"]
+        # logger.debug('Attempting to set metadata for %s', self)
+        # self.set_metadata_version()
+
+    def write(self, filepath, skip_unknown=False):
+        """Write the metadata fields to filepath."""
+        fp = codecs.open(filepath, 'w', encoding='utf-8')
+        try:
+            self.write_file(fp, skip_unknown)
+        finally:
+            fp.close()
+
+    def write_file(self, fileobject, skip_unknown=False):
+        """Write the PKG-INFO format data to a file object."""
+        self.set_metadata_version()
+
+        for field in _version2fieldlist(self['Metadata-Version']):
+            values = self.get(field)
+            if skip_unknown and values in ('UNKNOWN', [], ['UNKNOWN']):
+                continue
+            if field in _ELEMENTSFIELD:
+                self._write_field(fileobject, field, ','.join(values))
+                continue
+            if field not in _LISTFIELDS:
+                if field == 'Description':
+                    if self.metadata_version in ('1.0', '1.1'):
+                        values = values.replace('\n', '\n        ')
+                    else:
+                        values = values.replace('\n', '\n       |')
+                values = [values]
+
+            if field in _LISTTUPLEFIELDS:
+                values = [','.join(value) for value in values]
+
+            for value in values:
+                self._write_field(fileobject, field, value)
+
+    def update(self, other=None, **kwargs):
+        """Set metadata values from the given iterable `other` and kwargs.
+
+        Behavior is like `dict.update`: If `other` has a ``keys`` method,
+        they are looped over and ``self[key]`` is assigned ``other[key]``.
+        Else, ``other`` is an iterable of ``(key, value)`` iterables.
+
+        Keys that don't match a metadata field or that have an empty value are
+        dropped.
+        """
+        def _set(key, value):
+            if key in _ATTR2FIELD and value:
+                self.set(self._convert_name(key), value)
+
+        if not other:
+            # other is None or empty container
+            pass
+        elif hasattr(other, 'keys'):
+            for k in other.keys():
+                _set(k, other[k])
+        else:
+            for k, v in other:
+                _set(k, v)
+
+        if kwargs:
+            for k, v in kwargs.items():
+                _set(k, v)
+
+    def set(self, name, value):
+        """Control then set a metadata field."""
+        name = self._convert_name(name)
+
+        if ((name in _ELEMENTSFIELD or name == 'Platform') and
+            not isinstance(value, (list, tuple))):
+            if isinstance(value, string_types):
+                value = [v.strip() for v in value.split(',')]
+            else:
+                value = []
+        elif (name in _LISTFIELDS and
+              not isinstance(value, (list, tuple))):
+            if isinstance(value, string_types):
+                value = [value]
+            else:
+                value = []
+
+        if logger.isEnabledFor(logging.WARNING):
+            project_name = self['Name']
+
+            scheme = get_scheme(self.scheme)
+            if name in _PREDICATE_FIELDS and value is not None:
+                for v in value:
+                    # check that the values are valid
+                    if not scheme.is_valid_matcher(v.split(';')[0]):
+                        logger.warning(
+                            "'%s': '%s' is not valid (field '%s')",
+                            project_name, v, name)
+            # FIXME this rejects UNKNOWN, is that right?
+            elif name in _VERSIONS_FIELDS and value is not None:
+                if not scheme.is_valid_constraint_list(value):
+                    logger.warning("'%s': '%s' is not a valid version (field '%s')",
+                                   project_name, value, name)
+            elif name in _VERSION_FIELDS and value is not None:
+                if not scheme.is_valid_version(value):
+                    logger.warning("'%s': '%s' is not a valid version (field '%s')",
+                                   project_name, value, name)
+
+        if name in _UNICODEFIELDS:
+            if name == 'Description':
+                value = self._remove_line_prefix(value)
+
+        self._fields[name] = value
+
+    def get(self, name, default=_MISSING):
+        """Get a metadata field."""
+        name = self._convert_name(name)
+        if name not in self._fields:
+            if default is _MISSING:
+                default = self._default_value(name)
+            return default
+        if name in _UNICODEFIELDS:
+            value = self._fields[name]
+            return value
+        elif name in _LISTFIELDS:
+            value = self._fields[name]
+            if value is None:
+                return []
+            res = []
+            for val in value:
+                if name not in _LISTTUPLEFIELDS:
+                    res.append(val)
+                else:
+                    # That's for Project-URL
+                    res.append((val[0], val[1]))
+            return res
+
+        elif name in _ELEMENTSFIELD:
+            value = self._fields[name]
+            if isinstance(value, string_types):
+                return value.split(',')
+        return self._fields[name]
+
+    def check(self, strict=False):
+        """Check if the metadata is compliant. If strict is True then raise if
+        no Name or Version are provided"""
+        self.set_metadata_version()
+
+        # XXX should check the versions (if the file was loaded)
+        missing, warnings = [], []
+
+        for attr in ('Name', 'Version'):  # required by PEP 345
+            if attr not in self:
+                missing.append(attr)
+
+        if strict and missing != []:
+            msg = 'missing required metadata: %s' % ', '.join(missing)
+            raise MetadataMissingError(msg)
+
+        for attr in ('Home-page', 'Author'):
+            if attr not in self:
+                missing.append(attr)
+
+        # checking metadata 1.2 (XXX needs to check 1.1, 1.0)
+        if self['Metadata-Version'] != '1.2':
+            return missing, warnings
+
+        scheme = get_scheme(self.scheme)
+
+        def are_valid_constraints(value):
+            for v in value:
+                if not scheme.is_valid_matcher(v.split(';')[0]):
+                    return False
+            return True
+
+        for fields, controller in ((_PREDICATE_FIELDS, are_valid_constraints),
+                                   (_VERSIONS_FIELDS,
+                                    scheme.is_valid_constraint_list),
+                                   (_VERSION_FIELDS,
+                                    scheme.is_valid_version)):
+            for field in fields:
+                value = self.get(field, None)
+                if value is not None and not controller(value):
+                    warnings.append("Wrong value for '%s': %s" % (field, value))
+
+        return missing, warnings
+
+    def todict(self, skip_missing=False):
+        """Return fields as a dict.
+
+        Field names will be converted to use the underscore-lowercase style
+        instead of hyphen-mixed case (i.e. home_page instead of Home-page).
+        This is as per https://www.python.org/dev/peps/pep-0566/#id17.
+        """
+        self.set_metadata_version()
+
+        fields = _version2fieldlist(self['Metadata-Version'])
+
+        data = {}
+
+        for field_name in fields:
+            if not skip_missing or field_name in self._fields:
+                key = _FIELD2ATTR[field_name]
+                if key != 'project_url':
+                    data[key] = self[field_name]
+                else:
+                    data[key] = [','.join(u) for u in self[field_name]]
+
+        return data
+
+    def add_requirements(self, requirements):
+        if self['Metadata-Version'] == '1.1':
+            # we can't have 1.1 metadata *and* Setuptools requires
+            for field in ('Obsoletes', 'Requires', 'Provides'):
+                if field in self:
+                    del self[field]
+        self['Requires-Dist'] += requirements
+
+    # Mapping API
+    # TODO could add iter* variants
+
+    def keys(self):
+        return list(_version2fieldlist(self['Metadata-Version']))
+
+    def __iter__(self):
+        for key in self.keys():
+            yield key
+
+    def values(self):
+        return [self[key] for key in self.keys()]
+
+    def items(self):
+        return [(key, self[key]) for key in self.keys()]
+
+    def __repr__(self):
+        return '<%s %s %s>' % (self.__class__.__name__, self.name,
+                               self.version)
+
+
+METADATA_FILENAME = 'pydist.json'
+WHEEL_METADATA_FILENAME = 'metadata.json'
+LEGACY_METADATA_FILENAME = 'METADATA'
+
+
+class Metadata(object):
+    """
+    The metadata of a release. This implementation uses 2.1
+    metadata where possible. If not possible, it wraps a LegacyMetadata
+    instance which handles the key-value metadata format.
+    """
+
+    METADATA_VERSION_MATCHER = re.compile(r'^\d+(\.\d+)*$')
+
+    NAME_MATCHER = re.compile('^[0-9A-Z]([0-9A-Z_.-]*[0-9A-Z])?$', re.I)
+
+    FIELDNAME_MATCHER = re.compile('^[A-Z]([0-9A-Z-]*[0-9A-Z])?$', re.I)
+
+    VERSION_MATCHER = PEP440_VERSION_RE
+
+    SUMMARY_MATCHER = re.compile('.{1,2047}')
+
+    METADATA_VERSION = '2.0'
+
+    GENERATOR = 'distlib (%s)' % __version__
+
+    MANDATORY_KEYS = {
+        'name': (),
+        'version': (),
+        'summary': ('legacy',),
+    }
+
+    INDEX_KEYS = ('name version license summary description author '
+                  'author_email keywords platform home_page classifiers '
+                  'download_url')
+
+    DEPENDENCY_KEYS = ('extras run_requires test_requires build_requires '
+                       'dev_requires provides meta_requires obsoleted_by '
+                       'supports_environments')
+
+    SYNTAX_VALIDATORS = {
+        'metadata_version': (METADATA_VERSION_MATCHER, ()),
+        'name': (NAME_MATCHER, ('legacy',)),
+        'version': (VERSION_MATCHER, ('legacy',)),
+        'summary': (SUMMARY_MATCHER, ('legacy',)),
+        'dynamic': (FIELDNAME_MATCHER, ('legacy',)),
+    }
+
+    __slots__ = ('_legacy', '_data', 'scheme')
+
+    def __init__(self, path=None, fileobj=None, mapping=None,
+                 scheme='default'):
+        if [path, fileobj, mapping].count(None) < 2:
+            raise TypeError('path, fileobj and mapping are exclusive')
+        self._legacy = None
+        self._data = None
+        self.scheme = scheme
+        #import pdb; pdb.set_trace()
+        if mapping is not None:
+            try:
+                self._validate_mapping(mapping, scheme)
+                self._data = mapping
+            except MetadataUnrecognizedVersionError:
+                self._legacy = LegacyMetadata(mapping=mapping, scheme=scheme)
+                self.validate()
+        else:
+            data = None
+            if path:
+                with open(path, 'rb') as f:
+                    data = f.read()
+            elif fileobj:
+                data = fileobj.read()
+            if data is None:
+                # Initialised with no args - to be added
+                self._data = {
+                    'metadata_version': self.METADATA_VERSION,
+                    'generator': self.GENERATOR,
+                }
+            else:
+                if not isinstance(data, text_type):
+                    data = data.decode('utf-8')
+                try:
+                    self._data = json.loads(data)
+                    self._validate_mapping(self._data, scheme)
+                except ValueError:
+                    # Note: MetadataUnrecognizedVersionError does not
+                    # inherit from ValueError (it's a DistlibException,
+                    # which should not inherit from ValueError).
+                    # The ValueError comes from the json.load - if that
+                    # succeeds and we get a validation error, we want
+                    # that to propagate
+                    self._legacy = LegacyMetadata(fileobj=StringIO(data),
+                                                  scheme=scheme)
+                    self.validate()
+
+    common_keys = set(('name', 'version', 'license', 'keywords', 'summary'))
+
+    none_list = (None, list)
+    none_dict = (None, dict)
+
+    mapped_keys = {
+        'run_requires': ('Requires-Dist', list),
+        'build_requires': ('Setup-Requires-Dist', list),
+        'dev_requires': none_list,
+        'test_requires': none_list,
+        'meta_requires': none_list,
+        'extras': ('Provides-Extra', list),
+        'modules': none_list,
+        'namespaces': none_list,
+        'exports': none_dict,
+        'commands': none_dict,
+        'classifiers': ('Classifier', list),
+        'source_url': ('Download-URL', None),
+        'metadata_version': ('Metadata-Version', None),
+    }
+
+    del none_list, none_dict
+
+    def __getattribute__(self, key):
+        common = object.__getattribute__(self, 'common_keys')
+        mapped = object.__getattribute__(self, 'mapped_keys')
+        if key in mapped:
+            lk, maker = mapped[key]
+            if self._legacy:
+                if lk is None:
+                    result = None if maker is None else maker()
+                else:
+                    result = self._legacy.get(lk)
+            else:
+                value = None if maker is None else maker()
+                if key not in ('commands', 'exports', 'modules', 'namespaces',
+                               'classifiers'):
+                    result = self._data.get(key, value)
+                else:
+                    # special cases for PEP 459
+                    sentinel = object()
+                    result = sentinel
+                    d = self._data.get('extensions')
+                    if d:
+                        if key == 'commands':
+                            result = d.get('python.commands', value)
+                        elif key == 'classifiers':
+                            d = d.get('python.details')
+                            if d:
+                                result = d.get(key, value)
+                        else:
+                            d = d.get('python.exports')
+                            if not d:
+                                d = self._data.get('python.exports')
+                            if d:
+                                result = d.get(key, value)
+                    if result is sentinel:
+                        result = value
+        elif key not in common:
+            result = object.__getattribute__(self, key)
+        elif self._legacy:
+            result = self._legacy.get(key)
+        else:
+            result = self._data.get(key)
+        return result
+
+    def _validate_value(self, key, value, scheme=None):
+        if key in self.SYNTAX_VALIDATORS:
+            pattern, exclusions = self.SYNTAX_VALIDATORS[key]
+            if (scheme or self.scheme) not in exclusions:
+                m = pattern.match(value)
+                if not m:
+                    raise MetadataInvalidError("'%s' is an invalid value for "
+                                               "the '%s' property" % (value,
+                                                                    key))
+
+    def __setattr__(self, key, value):
+        self._validate_value(key, value)
+        common = object.__getattribute__(self, 'common_keys')
+        mapped = object.__getattribute__(self, 'mapped_keys')
+        if key in mapped:
+            lk, _ = mapped[key]
+            if self._legacy:
+                if lk is None:
+                    raise NotImplementedError
+                self._legacy[lk] = value
+            elif key not in ('commands', 'exports', 'modules', 'namespaces',
+                             'classifiers'):
+                self._data[key] = value
+            else:
+                # special cases for PEP 459
+                d = self._data.setdefault('extensions', {})
+                if key == 'commands':
+                    d['python.commands'] = value
+                elif key == 'classifiers':
+                    d = d.setdefault('python.details', {})
+                    d[key] = value
+                else:
+                    d = d.setdefault('python.exports', {})
+                    d[key] = value
+        elif key not in common:
+            object.__setattr__(self, key, value)
+        else:
+            if key == 'keywords':
+                if isinstance(value, string_types):
+                    value = value.strip()
+                    if value:
+                        value = value.split()
+                    else:
+                        value = []
+            if self._legacy:
+                self._legacy[key] = value
+            else:
+                self._data[key] = value
+
+    @property
+    def name_and_version(self):
+        return _get_name_and_version(self.name, self.version, True)
+
+    @property
+    def provides(self):
+        if self._legacy:
+            result = self._legacy['Provides-Dist']
+        else:
+            result = self._data.setdefault('provides', [])
+        s = '%s (%s)' % (self.name, self.version)
+        if s not in result:
+            result.append(s)
+        return result
+
+    @provides.setter
+    def provides(self, value):
+        if self._legacy:
+            self._legacy['Provides-Dist'] = value
+        else:
+            self._data['provides'] = value
+
+    def get_requirements(self, reqts, extras=None, env=None):
+        """
+        Base method to get dependencies, given a set of extras
+        to satisfy and an optional environment context.
+        :param reqts: A list of sometimes-wanted dependencies,
+                      perhaps dependent on extras and environment.
+        :param extras: A list of optional components being requested.
+        :param env: An optional environment for marker evaluation.
+        """
+        if self._legacy:
+            result = reqts
+        else:
+            result = []
+            extras = get_extras(extras or [], self.extras)
+            for d in reqts:
+                if 'extra' not in d and 'environment' not in d:
+                    # unconditional
+                    include = True
+                else:
+                    if 'extra' not in d:
+                        # Not extra-dependent - only environment-dependent
+                        include = True
+                    else:
+                        include = d.get('extra') in extras
+                    if include:
+                        # Not excluded because of extras, check environment
+                        marker = d.get('environment')
+                        if marker:
+                            include = interpret(marker, env)
+                if include:
+                    result.extend(d['requires'])
+            for key in ('build', 'dev', 'test'):
+                e = ':%s:' % key
+                if e in extras:
+                    extras.remove(e)
+                    # A recursive call, but it should terminate since 'test'
+                    # has been removed from the extras
+                    reqts = self._data.get('%s_requires' % key, [])
+                    result.extend(self.get_requirements(reqts, extras=extras,
+                                                        env=env))
+        return result
+
+    @property
+    def dictionary(self):
+        if self._legacy:
+            return self._from_legacy()
+        return self._data
+
+    @property
+    def dependencies(self):
+        if self._legacy:
+            raise NotImplementedError
+        else:
+            return extract_by_key(self._data, self.DEPENDENCY_KEYS)
+
+    @dependencies.setter
+    def dependencies(self, value):
+        if self._legacy:
+            raise NotImplementedError
+        else:
+            self._data.update(value)
+
+    def _validate_mapping(self, mapping, scheme):
+        if mapping.get('metadata_version') != self.METADATA_VERSION:
+            raise MetadataUnrecognizedVersionError()
+        missing = []
+        for key, exclusions in self.MANDATORY_KEYS.items():
+            if key not in mapping:
+                if scheme not in exclusions:
+                    missing.append(key)
+        if missing:
+            msg = 'Missing metadata items: %s' % ', '.join(missing)
+            raise MetadataMissingError(msg)
+        for k, v in mapping.items():
+            self._validate_value(k, v, scheme)
+
+    def validate(self):
+        if self._legacy:
+            missing, warnings = self._legacy.check(True)
+            if missing or warnings:
+                logger.warning('Metadata: missing: %s, warnings: %s',
+                               missing, warnings)
+        else:
+            self._validate_mapping(self._data, self.scheme)
+
+    def todict(self):
+        if self._legacy:
+            return self._legacy.todict(True)
+        else:
+            result = extract_by_key(self._data, self.INDEX_KEYS)
+            return result
+
+    def _from_legacy(self):
+        assert self._legacy and not self._data
+        result = {
+            'metadata_version': self.METADATA_VERSION,
+            'generator': self.GENERATOR,
+        }
+        lmd = self._legacy.todict(True)     # skip missing ones
+        for k in ('name', 'version', 'license', 'summary', 'description',
+                  'classifier'):
+            if k in lmd:
+                if k == 'classifier':
+                    nk = 'classifiers'
+                else:
+                    nk = k
+                result[nk] = lmd[k]
+        kw = lmd.get('Keywords', [])
+        if kw == ['']:
+            kw = []
+        result['keywords'] = kw
+        keys = (('requires_dist', 'run_requires'),
+                ('setup_requires_dist', 'build_requires'))
+        for ok, nk in keys:
+            if ok in lmd and lmd[ok]:
+                result[nk] = [{'requires': lmd[ok]}]
+        result['provides'] = self.provides
+        author = {}
+        maintainer = {}
+        return result
+
+    LEGACY_MAPPING = {
+        'name': 'Name',
+        'version': 'Version',
+        ('extensions', 'python.details', 'license'): 'License',
+        'summary': 'Summary',
+        'description': 'Description',
+        ('extensions', 'python.project', 'project_urls', 'Home'): 'Home-page',
+        ('extensions', 'python.project', 'contacts', 0, 'name'): 'Author',
+        ('extensions', 'python.project', 'contacts', 0, 'email'): 'Author-email',
+        'source_url': 'Download-URL',
+        ('extensions', 'python.details', 'classifiers'): 'Classifier',
+    }
+
+    def _to_legacy(self):
+        def process_entries(entries):
+            reqts = set()
+            for e in entries:
+                extra = e.get('extra')
+                env = e.get('environment')
+                rlist = e['requires']
+                for r in rlist:
+                    if not env and not extra:
+                        reqts.add(r)
+                    else:
+                        marker = ''
+                        if extra:
+                            marker = 'extra == "%s"' % extra
+                        if env:
+                            if marker:
+                                marker = '(%s) and %s' % (env, marker)
+                            else:
+                                marker = env
+                        reqts.add(';'.join((r, marker)))
+            return reqts
+
+        assert self._data and not self._legacy
+        result = LegacyMetadata()
+        nmd = self._data
+        # import pdb; pdb.set_trace()
+        for nk, ok in self.LEGACY_MAPPING.items():
+            if not isinstance(nk, tuple):
+                if nk in nmd:
+                    result[ok] = nmd[nk]
+            else:
+                d = nmd
+                found = True
+                for k in nk:
+                    try:
+                        d = d[k]
+                    except (KeyError, IndexError):
+                        found = False
+                        break
+                if found:
+                    result[ok] = d
+        r1 = process_entries(self.run_requires + self.meta_requires)
+        r2 = process_entries(self.build_requires + self.dev_requires)
+        if self.extras:
+            result['Provides-Extra'] = sorted(self.extras)
+        result['Requires-Dist'] = sorted(r1)
+        result['Setup-Requires-Dist'] = sorted(r2)
+        # TODO: any other fields wanted
+        return result
+
+    def write(self, path=None, fileobj=None, legacy=False, skip_unknown=True):
+        if [path, fileobj].count(None) != 1:
+            raise ValueError('Exactly one of path and fileobj is needed')
+        self.validate()
+        if legacy:
+            if self._legacy:
+                legacy_md = self._legacy
+            else:
+                legacy_md = self._to_legacy()
+            if path:
+                legacy_md.write(path, skip_unknown=skip_unknown)
+            else:
+                legacy_md.write_file(fileobj, skip_unknown=skip_unknown)
+        else:
+            if self._legacy:
+                d = self._from_legacy()
+            else:
+                d = self._data
+            if fileobj:
+                json.dump(d, fileobj, ensure_ascii=True, indent=2,
+                          sort_keys=True)
+            else:
+                with codecs.open(path, 'w', 'utf-8') as f:
+                    json.dump(d, f, ensure_ascii=True, indent=2,
+                              sort_keys=True)
+
+    def add_requirements(self, requirements):
+        if self._legacy:
+            self._legacy.add_requirements(requirements)
+        else:
+            run_requires = self._data.setdefault('run_requires', [])
+            always = None
+            for entry in run_requires:
+                if 'environment' not in entry and 'extra' not in entry:
+                    always = entry
+                    break
+            if always is None:
+                always = { 'requires': requirements }
+                run_requires.insert(0, always)
+            else:
+                rset = set(always['requires']) | set(requirements)
+                always['requires'] = sorted(rset)
+
+    def __repr__(self):
+        name = self.name or '(no name)'
+        version = self.version or 'no version'
+        return '<%s %s %s (%s)>' % (self.__class__.__name__,
+                                    self.metadata_version, name, version)
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/distlib/resources.py b/venv/lib/python3.12/site-packages/pip/_vendor/distlib/resources.py
new file mode 100644
index 00000000..fef52aa1
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_vendor/distlib/resources.py
@@ -0,0 +1,358 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2013-2017 Vinay Sajip.
+# Licensed to the Python Software Foundation under a contributor agreement.
+# See LICENSE.txt and CONTRIBUTORS.txt.
+#
+from __future__ import unicode_literals
+
+import bisect
+import io
+import logging
+import os
+import pkgutil
+import sys
+import types
+import zipimport
+
+from . import DistlibException
+from .util import cached_property, get_cache_base, Cache
+
+logger = logging.getLogger(__name__)
+
+
+cache = None    # created when needed
+
+
+class ResourceCache(Cache):
+    def __init__(self, base=None):
+        if base is None:
+            # Use native string to avoid issues on 2.x: see Python #20140.
+            base = os.path.join(get_cache_base(), str('resource-cache'))
+        super(ResourceCache, self).__init__(base)
+
+    def is_stale(self, resource, path):
+        """
+        Is the cache stale for the given resource?
+
+        :param resource: The :class:`Resource` being cached.
+        :param path: The path of the resource in the cache.
+        :return: True if the cache is stale.
+        """
+        # Cache invalidation is a hard problem :-)
+        return True
+
+    def get(self, resource):
+        """
+        Get a resource into the cache,
+
+        :param resource: A :class:`Resource` instance.
+        :return: The pathname of the resource in the cache.
+        """
+        prefix, path = resource.finder.get_cache_info(resource)
+        if prefix is None:
+            result = path
+        else:
+            result = os.path.join(self.base, self.prefix_to_dir(prefix), path)
+            dirname = os.path.dirname(result)
+            if not os.path.isdir(dirname):
+                os.makedirs(dirname)
+            if not os.path.exists(result):
+                stale = True
+            else:
+                stale = self.is_stale(resource, path)
+            if stale:
+                # write the bytes of the resource to the cache location
+                with open(result, 'wb') as f:
+                    f.write(resource.bytes)
+        return result
+
+
+class ResourceBase(object):
+    def __init__(self, finder, name):
+        self.finder = finder
+        self.name = name
+
+
+class Resource(ResourceBase):
+    """
+    A class representing an in-package resource, such as a data file. This is
+    not normally instantiated by user code, but rather by a
+    :class:`ResourceFinder` which manages the resource.
+    """
+    is_container = False        # Backwards compatibility
+
+    def as_stream(self):
+        """
+        Get the resource as a stream.
+
+        This is not a property to make it obvious that it returns a new stream
+        each time.
+        """
+        return self.finder.get_stream(self)
+
+    @cached_property
+    def file_path(self):
+        global cache
+        if cache is None:
+            cache = ResourceCache()
+        return cache.get(self)
+
+    @cached_property
+    def bytes(self):
+        return self.finder.get_bytes(self)
+
+    @cached_property
+    def size(self):
+        return self.finder.get_size(self)
+
+
+class ResourceContainer(ResourceBase):
+    is_container = True     # Backwards compatibility
+
+    @cached_property
+    def resources(self):
+        return self.finder.get_resources(self)
+
+
+class ResourceFinder(object):
+    """
+    Resource finder for file system resources.
+    """
+
+    if sys.platform.startswith('java'):
+        skipped_extensions = ('.pyc', '.pyo', '.class')
+    else:
+        skipped_extensions = ('.pyc', '.pyo')
+
+    def __init__(self, module):
+        self.module = module
+        self.loader = getattr(module, '__loader__', None)
+        self.base = os.path.dirname(getattr(module, '__file__', ''))
+
+    def _adjust_path(self, path):
+        return os.path.realpath(path)
+
+    def _make_path(self, resource_name):
+        # Issue #50: need to preserve type of path on Python 2.x
+        # like os.path._get_sep
+        if isinstance(resource_name, bytes):    # should only happen on 2.x
+            sep = b'/'
+        else:
+            sep = '/'
+        parts = resource_name.split(sep)
+        parts.insert(0, self.base)
+        result = os.path.join(*parts)
+        return self._adjust_path(result)
+
+    def _find(self, path):
+        return os.path.exists(path)
+
+    def get_cache_info(self, resource):
+        return None, resource.path
+
+    def find(self, resource_name):
+        path = self._make_path(resource_name)
+        if not self._find(path):
+            result = None
+        else:
+            if self._is_directory(path):
+                result = ResourceContainer(self, resource_name)
+            else:
+                result = Resource(self, resource_name)
+            result.path = path
+        return result
+
+    def get_stream(self, resource):
+        return open(resource.path, 'rb')
+
+    def get_bytes(self, resource):
+        with open(resource.path, 'rb') as f:
+            return f.read()
+
+    def get_size(self, resource):
+        return os.path.getsize(resource.path)
+
+    def get_resources(self, resource):
+        def allowed(f):
+            return (f != '__pycache__' and not
+                    f.endswith(self.skipped_extensions))
+        return set([f for f in os.listdir(resource.path) if allowed(f)])
+
+    def is_container(self, resource):
+        return self._is_directory(resource.path)
+
+    _is_directory = staticmethod(os.path.isdir)
+
+    def iterator(self, resource_name):
+        resource = self.find(resource_name)
+        if resource is not None:
+            todo = [resource]
+            while todo:
+                resource = todo.pop(0)
+                yield resource
+                if resource.is_container:
+                    rname = resource.name
+                    for name in resource.resources:
+                        if not rname:
+                            new_name = name
+                        else:
+                            new_name = '/'.join([rname, name])
+                        child = self.find(new_name)
+                        if child.is_container:
+                            todo.append(child)
+                        else:
+                            yield child
+
+
+class ZipResourceFinder(ResourceFinder):
+    """
+    Resource finder for resources in .zip files.
+    """
+    def __init__(self, module):
+        super(ZipResourceFinder, self).__init__(module)
+        archive = self.loader.archive
+        self.prefix_len = 1 + len(archive)
+        # PyPy doesn't have a _files attr on zipimporter, and you can't set one
+        if hasattr(self.loader, '_files'):
+            self._files = self.loader._files
+        else:
+            self._files = zipimport._zip_directory_cache[archive]
+        self.index = sorted(self._files)
+
+    def _adjust_path(self, path):
+        return path
+
+    def _find(self, path):
+        path = path[self.prefix_len:]
+        if path in self._files:
+            result = True
+        else:
+            if path and path[-1] != os.sep:
+                path = path + os.sep
+            i = bisect.bisect(self.index, path)
+            try:
+                result = self.index[i].startswith(path)
+            except IndexError:
+                result = False
+        if not result:
+            logger.debug('_find failed: %r %r', path, self.loader.prefix)
+        else:
+            logger.debug('_find worked: %r %r', path, self.loader.prefix)
+        return result
+
+    def get_cache_info(self, resource):
+        prefix = self.loader.archive
+        path = resource.path[1 + len(prefix):]
+        return prefix, path
+
+    def get_bytes(self, resource):
+        return self.loader.get_data(resource.path)
+
+    def get_stream(self, resource):
+        return io.BytesIO(self.get_bytes(resource))
+
+    def get_size(self, resource):
+        path = resource.path[self.prefix_len:]
+        return self._files[path][3]
+
+    def get_resources(self, resource):
+        path = resource.path[self.prefix_len:]
+        if path and path[-1] != os.sep:
+            path += os.sep
+        plen = len(path)
+        result = set()
+        i = bisect.bisect(self.index, path)
+        while i < len(self.index):
+            if not self.index[i].startswith(path):
+                break
+            s = self.index[i][plen:]
+            result.add(s.split(os.sep, 1)[0])   # only immediate children
+            i += 1
+        return result
+
+    def _is_directory(self, path):
+        path = path[self.prefix_len:]
+        if path and path[-1] != os.sep:
+            path += os.sep
+        i = bisect.bisect(self.index, path)
+        try:
+            result = self.index[i].startswith(path)
+        except IndexError:
+            result = False
+        return result
+
+
+_finder_registry = {
+    type(None): ResourceFinder,
+    zipimport.zipimporter: ZipResourceFinder
+}
+
+try:
+    # In Python 3.6, _frozen_importlib -> _frozen_importlib_external
+    try:
+        import _frozen_importlib_external as _fi
+    except ImportError:
+        import _frozen_importlib as _fi
+    _finder_registry[_fi.SourceFileLoader] = ResourceFinder
+    _finder_registry[_fi.FileFinder] = ResourceFinder
+    # See issue #146
+    _finder_registry[_fi.SourcelessFileLoader] = ResourceFinder
+    del _fi
+except (ImportError, AttributeError):
+    pass
+
+
+def register_finder(loader, finder_maker):
+    _finder_registry[type(loader)] = finder_maker
+
+
+_finder_cache = {}
+
+
+def finder(package):
+    """
+    Return a resource finder for a package.
+    :param package: The name of the package.
+    :return: A :class:`ResourceFinder` instance for the package.
+    """
+    if package in _finder_cache:
+        result = _finder_cache[package]
+    else:
+        if package not in sys.modules:
+            __import__(package)
+        module = sys.modules[package]
+        path = getattr(module, '__path__', None)
+        if path is None:
+            raise DistlibException('You cannot get a finder for a module, '
+                                   'only for a package')
+        loader = getattr(module, '__loader__', None)
+        finder_maker = _finder_registry.get(type(loader))
+        if finder_maker is None:
+            raise DistlibException('Unable to locate finder for %r' % package)
+        result = finder_maker(module)
+        _finder_cache[package] = result
+    return result
+
+
+_dummy_module = types.ModuleType(str('__dummy__'))
+
+
+def finder_for_path(path):
+    """
+    Return a resource finder for a path, which should represent a container.
+
+    :param path: The path.
+    :return: A :class:`ResourceFinder` instance for the path.
+    """
+    result = None
+    # calls any path hooks, gets importer into cache
+    pkgutil.get_importer(path)
+    loader = sys.path_importer_cache.get(path)
+    finder = _finder_registry.get(type(loader))
+    if finder:
+        module = _dummy_module
+        module.__file__ = os.path.join(path, '')
+        module.__loader__ = loader
+        result = finder(module)
+    return result
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/distlib/scripts.py b/venv/lib/python3.12/site-packages/pip/_vendor/distlib/scripts.py
new file mode 100644
index 00000000..e16292b8
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_vendor/distlib/scripts.py
@@ -0,0 +1,466 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2013-2023 Vinay Sajip.
+# Licensed to the Python Software Foundation under a contributor agreement.
+# See LICENSE.txt and CONTRIBUTORS.txt.
+#
+from io import BytesIO
+import logging
+import os
+import re
+import struct
+import sys
+import time
+from zipfile import ZipInfo
+
+from .compat import sysconfig, detect_encoding, ZipFile
+from .resources import finder
+from .util import (FileOperator, get_export_entry, convert_path,
+                   get_executable, get_platform, in_venv)
+
+logger = logging.getLogger(__name__)
+
+_DEFAULT_MANIFEST = '''
+
+
+ 
+
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+'''.strip()
+
+# check if Python is called on the first line with this expression
+FIRST_LINE_RE = re.compile(b'^#!.*pythonw?[0-9.]*([ \t].*)?$')
+SCRIPT_TEMPLATE = r'''# -*- coding: utf-8 -*-
+import re
+import sys
+from %(module)s import %(import_name)s
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(%(func)s())
+'''
+
+# Pre-fetch the contents of all executable wrapper stubs.
+# This is to address https://github.com/pypa/pip/issues/12666.
+# When updating pip, we rename the old pip in place before installing the
+# new version. If we try to fetch a wrapper *after* that rename, the finder
+# machinery will be confused as the package is no longer available at the
+# location where it was imported from. So we load everything into memory in
+# advance.
+
+# Issue 31: don't hardcode an absolute package name, but
+# determine it relative to the current package
+distlib_package = __name__.rsplit('.', 1)[0]
+
+WRAPPERS = {
+    r.name: r.bytes
+    for r in finder(distlib_package).iterator("")
+    if r.name.endswith(".exe")
+}
+
+
+def enquote_executable(executable):
+    if ' ' in executable:
+        # make sure we quote only the executable in case of env
+        # for example /usr/bin/env "/dir with spaces/bin/jython"
+        # instead of "/usr/bin/env /dir with spaces/bin/jython"
+        # otherwise whole
+        if executable.startswith('/usr/bin/env '):
+            env, _executable = executable.split(' ', 1)
+            if ' ' in _executable and not _executable.startswith('"'):
+                executable = '%s "%s"' % (env, _executable)
+        else:
+            if not executable.startswith('"'):
+                executable = '"%s"' % executable
+    return executable
+
+
+# Keep the old name around (for now), as there is at least one project using it!
+_enquote_executable = enquote_executable
+
+
+class ScriptMaker(object):
+    """
+    A class to copy or create scripts from source scripts or callable
+    specifications.
+    """
+    script_template = SCRIPT_TEMPLATE
+
+    executable = None  # for shebangs
+
+    def __init__(self,
+                 source_dir,
+                 target_dir,
+                 add_launchers=True,
+                 dry_run=False,
+                 fileop=None):
+        self.source_dir = source_dir
+        self.target_dir = target_dir
+        self.add_launchers = add_launchers
+        self.force = False
+        self.clobber = False
+        # It only makes sense to set mode bits on POSIX.
+        self.set_mode = (os.name == 'posix') or (os.name == 'java'
+                                                 and os._name == 'posix')
+        self.variants = set(('', 'X.Y'))
+        self._fileop = fileop or FileOperator(dry_run)
+
+        self._is_nt = os.name == 'nt' or (os.name == 'java'
+                                          and os._name == 'nt')
+        self.version_info = sys.version_info
+
+    def _get_alternate_executable(self, executable, options):
+        if options.get('gui', False) and self._is_nt:  # pragma: no cover
+            dn, fn = os.path.split(executable)
+            fn = fn.replace('python', 'pythonw')
+            executable = os.path.join(dn, fn)
+        return executable
+
+    if sys.platform.startswith('java'):  # pragma: no cover
+
+        def _is_shell(self, executable):
+            """
+            Determine if the specified executable is a script
+            (contains a #! line)
+            """
+            try:
+                with open(executable) as fp:
+                    return fp.read(2) == '#!'
+            except (OSError, IOError):
+                logger.warning('Failed to open %s', executable)
+                return False
+
+        def _fix_jython_executable(self, executable):
+            if self._is_shell(executable):
+                # Workaround for Jython is not needed on Linux systems.
+                import java
+
+                if java.lang.System.getProperty('os.name') == 'Linux':
+                    return executable
+            elif executable.lower().endswith('jython.exe'):
+                # Use wrapper exe for Jython on Windows
+                return executable
+            return '/usr/bin/env %s' % executable
+
+    def _build_shebang(self, executable, post_interp):
+        """
+        Build a shebang line. In the simple case (on Windows, or a shebang line
+        which is not too long or contains spaces) use a simple formulation for
+        the shebang. Otherwise, use /bin/sh as the executable, with a contrived
+        shebang which allows the script to run either under Python or sh, using
+        suitable quoting. Thanks to Harald Nordgren for his input.
+
+        See also: http://www.in-ulm.de/~mascheck/various/shebang/#length
+                  https://hg.mozilla.org/mozilla-central/file/tip/mach
+        """
+        if os.name != 'posix':
+            simple_shebang = True
+        else:
+            # Add 3 for '#!' prefix and newline suffix.
+            shebang_length = len(executable) + len(post_interp) + 3
+            if sys.platform == 'darwin':
+                max_shebang_length = 512
+            else:
+                max_shebang_length = 127
+            simple_shebang = ((b' ' not in executable)
+                              and (shebang_length <= max_shebang_length))
+
+        if simple_shebang:
+            result = b'#!' + executable + post_interp + b'\n'
+        else:
+            result = b'#!/bin/sh\n'
+            result += b"'''exec' " + executable + post_interp + b' "$0" "$@"\n'
+            result += b"' '''"
+        return result
+
+    def _get_shebang(self, encoding, post_interp=b'', options=None):
+        enquote = True
+        if self.executable:
+            executable = self.executable
+            enquote = False  # assume this will be taken care of
+        elif not sysconfig.is_python_build():
+            executable = get_executable()
+        elif in_venv():  # pragma: no cover
+            executable = os.path.join(
+                sysconfig.get_path('scripts'),
+                'python%s' % sysconfig.get_config_var('EXE'))
+        else:  # pragma: no cover
+            if os.name == 'nt':
+                # for Python builds from source on Windows, no Python executables with
+                # a version suffix are created, so we use python.exe
+                executable = os.path.join(
+                    sysconfig.get_config_var('BINDIR'),
+                    'python%s' % (sysconfig.get_config_var('EXE')))
+            else:
+                executable = os.path.join(
+                    sysconfig.get_config_var('BINDIR'),
+                    'python%s%s' % (sysconfig.get_config_var('VERSION'),
+                                    sysconfig.get_config_var('EXE')))
+        if options:
+            executable = self._get_alternate_executable(executable, options)
+
+        if sys.platform.startswith('java'):  # pragma: no cover
+            executable = self._fix_jython_executable(executable)
+
+        # Normalise case for Windows - COMMENTED OUT
+        # executable = os.path.normcase(executable)
+        # N.B. The normalising operation above has been commented out: See
+        # issue #124. Although paths in Windows are generally case-insensitive,
+        # they aren't always. For example, a path containing a ẞ (which is a
+        # LATIN CAPITAL LETTER SHARP S - U+1E9E) is normcased to ß (which is a
+        # LATIN SMALL LETTER SHARP S' - U+00DF). The two are not considered by
+        # Windows as equivalent in path names.
+
+        # If the user didn't specify an executable, it may be necessary to
+        # cater for executable paths with spaces (not uncommon on Windows)
+        if enquote:
+            executable = enquote_executable(executable)
+        # Issue #51: don't use fsencode, since we later try to
+        # check that the shebang is decodable using utf-8.
+        executable = executable.encode('utf-8')
+        # in case of IronPython, play safe and enable frames support
+        if (sys.platform == 'cli' and '-X:Frames' not in post_interp
+                and '-X:FullFrames' not in post_interp):  # pragma: no cover
+            post_interp += b' -X:Frames'
+        shebang = self._build_shebang(executable, post_interp)
+        # Python parser starts to read a script using UTF-8 until
+        # it gets a #coding:xxx cookie. The shebang has to be the
+        # first line of a file, the #coding:xxx cookie cannot be
+        # written before. So the shebang has to be decodable from
+        # UTF-8.
+        try:
+            shebang.decode('utf-8')
+        except UnicodeDecodeError:  # pragma: no cover
+            raise ValueError('The shebang (%r) is not decodable from utf-8' %
+                             shebang)
+        # If the script is encoded to a custom encoding (use a
+        # #coding:xxx cookie), the shebang has to be decodable from
+        # the script encoding too.
+        if encoding != 'utf-8':
+            try:
+                shebang.decode(encoding)
+            except UnicodeDecodeError:  # pragma: no cover
+                raise ValueError('The shebang (%r) is not decodable '
+                                 'from the script encoding (%r)' %
+                                 (shebang, encoding))
+        return shebang
+
+    def _get_script_text(self, entry):
+        return self.script_template % dict(
+            module=entry.prefix,
+            import_name=entry.suffix.split('.')[0],
+            func=entry.suffix)
+
+    manifest = _DEFAULT_MANIFEST
+
+    def get_manifest(self, exename):
+        base = os.path.basename(exename)
+        return self.manifest % base
+
+    def _write_script(self, names, shebang, script_bytes, filenames, ext):
+        use_launcher = self.add_launchers and self._is_nt
+        linesep = os.linesep.encode('utf-8')
+        if not shebang.endswith(linesep):
+            shebang += linesep
+        if not use_launcher:
+            script_bytes = shebang + script_bytes
+        else:  # pragma: no cover
+            if ext == 'py':
+                launcher = self._get_launcher('t')
+            else:
+                launcher = self._get_launcher('w')
+            stream = BytesIO()
+            with ZipFile(stream, 'w') as zf:
+                source_date_epoch = os.environ.get('SOURCE_DATE_EPOCH')
+                if source_date_epoch:
+                    date_time = time.gmtime(int(source_date_epoch))[:6]
+                    zinfo = ZipInfo(filename='__main__.py',
+                                    date_time=date_time)
+                    zf.writestr(zinfo, script_bytes)
+                else:
+                    zf.writestr('__main__.py', script_bytes)
+            zip_data = stream.getvalue()
+            script_bytes = launcher + shebang + zip_data
+        for name in names:
+            outname = os.path.join(self.target_dir, name)
+            if use_launcher:  # pragma: no cover
+                n, e = os.path.splitext(outname)
+                if e.startswith('.py'):
+                    outname = n
+                outname = '%s.exe' % outname
+                try:
+                    self._fileop.write_binary_file(outname, script_bytes)
+                except Exception:
+                    # Failed writing an executable - it might be in use.
+                    logger.warning('Failed to write executable - trying to '
+                                   'use .deleteme logic')
+                    dfname = '%s.deleteme' % outname
+                    if os.path.exists(dfname):
+                        os.remove(dfname)  # Not allowed to fail here
+                    os.rename(outname, dfname)  # nor here
+                    self._fileop.write_binary_file(outname, script_bytes)
+                    logger.debug('Able to replace executable using '
+                                 '.deleteme logic')
+                    try:
+                        os.remove(dfname)
+                    except Exception:
+                        pass  # still in use - ignore error
+            else:
+                if self._is_nt and not outname.endswith(
+                        '.' + ext):  # pragma: no cover
+                    outname = '%s.%s' % (outname, ext)
+                if os.path.exists(outname) and not self.clobber:
+                    logger.warning('Skipping existing file %s', outname)
+                    continue
+                self._fileop.write_binary_file(outname, script_bytes)
+                if self.set_mode:
+                    self._fileop.set_executable_mode([outname])
+            filenames.append(outname)
+
+    variant_separator = '-'
+
+    def get_script_filenames(self, name):
+        result = set()
+        if '' in self.variants:
+            result.add(name)
+        if 'X' in self.variants:
+            result.add('%s%s' % (name, self.version_info[0]))
+        if 'X.Y' in self.variants:
+            result.add('%s%s%s.%s' %
+                       (name, self.variant_separator, self.version_info[0],
+                        self.version_info[1]))
+        return result
+
+    def _make_script(self, entry, filenames, options=None):
+        post_interp = b''
+        if options:
+            args = options.get('interpreter_args', [])
+            if args:
+                args = ' %s' % ' '.join(args)
+                post_interp = args.encode('utf-8')
+        shebang = self._get_shebang('utf-8', post_interp, options=options)
+        script = self._get_script_text(entry).encode('utf-8')
+        scriptnames = self.get_script_filenames(entry.name)
+        if options and options.get('gui', False):
+            ext = 'pyw'
+        else:
+            ext = 'py'
+        self._write_script(scriptnames, shebang, script, filenames, ext)
+
+    def _copy_script(self, script, filenames):
+        adjust = False
+        script = os.path.join(self.source_dir, convert_path(script))
+        outname = os.path.join(self.target_dir, os.path.basename(script))
+        if not self.force and not self._fileop.newer(script, outname):
+            logger.debug('not copying %s (up-to-date)', script)
+            return
+
+        # Always open the file, but ignore failures in dry-run mode --
+        # that way, we'll get accurate feedback if we can read the
+        # script.
+        try:
+            f = open(script, 'rb')
+        except IOError:  # pragma: no cover
+            if not self.dry_run:
+                raise
+            f = None
+        else:
+            first_line = f.readline()
+            if not first_line:  # pragma: no cover
+                logger.warning('%s is an empty file (skipping)', script)
+                return
+
+            match = FIRST_LINE_RE.match(first_line.replace(b'\r\n', b'\n'))
+            if match:
+                adjust = True
+                post_interp = match.group(1) or b''
+
+        if not adjust:
+            if f:
+                f.close()
+            self._fileop.copy_file(script, outname)
+            if self.set_mode:
+                self._fileop.set_executable_mode([outname])
+            filenames.append(outname)
+        else:
+            logger.info('copying and adjusting %s -> %s', script,
+                        self.target_dir)
+            if not self._fileop.dry_run:
+                encoding, lines = detect_encoding(f.readline)
+                f.seek(0)
+                shebang = self._get_shebang(encoding, post_interp)
+                if b'pythonw' in first_line:  # pragma: no cover
+                    ext = 'pyw'
+                else:
+                    ext = 'py'
+                n = os.path.basename(outname)
+                self._write_script([n], shebang, f.read(), filenames, ext)
+            if f:
+                f.close()
+
+    @property
+    def dry_run(self):
+        return self._fileop.dry_run
+
+    @dry_run.setter
+    def dry_run(self, value):
+        self._fileop.dry_run = value
+
+    if os.name == 'nt' or (os.name == 'java'
+                           and os._name == 'nt'):  # pragma: no cover
+        # Executable launcher support.
+        # Launchers are from https://bitbucket.org/vinay.sajip/simple_launcher/
+
+        def _get_launcher(self, kind):
+            if struct.calcsize('P') == 8:  # 64-bit
+                bits = '64'
+            else:
+                bits = '32'
+            platform_suffix = '-arm' if get_platform() == 'win-arm64' else ''
+            name = '%s%s%s.exe' % (kind, bits, platform_suffix)
+            if name not in WRAPPERS:
+                msg = ('Unable to find resource %s in package %s' %
+                       (name, distlib_package))
+                raise ValueError(msg)
+            return WRAPPERS[name]
+
+    # Public API follows
+
+    def make(self, specification, options=None):
+        """
+        Make a script.
+
+        :param specification: The specification, which is either a valid export
+                              entry specification (to make a script from a
+                              callable) or a filename (to make a script by
+                              copying from a source location).
+        :param options: A dictionary of options controlling script generation.
+        :return: A list of all absolute pathnames written to.
+        """
+        filenames = []
+        entry = get_export_entry(specification)
+        if entry is None:
+            self._copy_script(specification, filenames)
+        else:
+            self._make_script(entry, filenames, options=options)
+        return filenames
+
+    def make_multiple(self, specifications, options=None):
+        """
+        Take a list of specifications and make scripts from them,
+        :param specifications: A list of specifications.
+        :return: A list of all absolute pathnames written to,
+        """
+        filenames = []
+        for specification in specifications:
+            filenames.extend(self.make(specification, options))
+        return filenames
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/distlib/t32.exe b/venv/lib/python3.12/site-packages/pip/_vendor/distlib/t32.exe
new file mode 100644
index 00000000..52154f0b
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_vendor/distlib/t32.exe differ
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/distlib/t64-arm.exe b/venv/lib/python3.12/site-packages/pip/_vendor/distlib/t64-arm.exe
new file mode 100644
index 00000000..e1ab8f8f
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_vendor/distlib/t64-arm.exe differ
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/distlib/t64.exe b/venv/lib/python3.12/site-packages/pip/_vendor/distlib/t64.exe
new file mode 100644
index 00000000..e8bebdba
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_vendor/distlib/t64.exe differ
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/distlib/util.py b/venv/lib/python3.12/site-packages/pip/_vendor/distlib/util.py
new file mode 100644
index 00000000..ba58858d
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_vendor/distlib/util.py
@@ -0,0 +1,2025 @@
+#
+# Copyright (C) 2012-2023 The Python Software Foundation.
+# See LICENSE.txt and CONTRIBUTORS.txt.
+#
+import codecs
+from collections import deque
+import contextlib
+import csv
+from glob import iglob as std_iglob
+import io
+import json
+import logging
+import os
+import py_compile
+import re
+import socket
+try:
+    import ssl
+except ImportError:  # pragma: no cover
+    ssl = None
+import subprocess
+import sys
+import tarfile
+import tempfile
+import textwrap
+
+try:
+    import threading
+except ImportError:  # pragma: no cover
+    import dummy_threading as threading
+import time
+
+from . import DistlibException
+from .compat import (string_types, text_type, shutil, raw_input, StringIO,
+                     cache_from_source, urlopen, urljoin, httplib, xmlrpclib,
+                     HTTPHandler, BaseConfigurator, valid_ident,
+                     Container, configparser, URLError, ZipFile, fsdecode,
+                     unquote, urlparse)
+
+logger = logging.getLogger(__name__)
+
+#
+# Requirement parsing code as per PEP 508
+#
+
+IDENTIFIER = re.compile(r'^([\w\.-]+)\s*')
+VERSION_IDENTIFIER = re.compile(r'^([\w\.*+-]+)\s*')
+COMPARE_OP = re.compile(r'^(<=?|>=?|={2,3}|[~!]=)\s*')
+MARKER_OP = re.compile(r'^((<=?)|(>=?)|={2,3}|[~!]=|in|not\s+in)\s*')
+OR = re.compile(r'^or\b\s*')
+AND = re.compile(r'^and\b\s*')
+NON_SPACE = re.compile(r'(\S+)\s*')
+STRING_CHUNK = re.compile(r'([\s\w\.{}()*+#:;,/?!~`@$%^&=|<>\[\]-]+)')
+
+
+def parse_marker(marker_string):
+    """
+    Parse a marker string and return a dictionary containing a marker expression.
+
+    The dictionary will contain keys "op", "lhs" and "rhs" for non-terminals in
+    the expression grammar, or strings. A string contained in quotes is to be
+    interpreted as a literal string, and a string not contained in quotes is a
+    variable (such as os_name).
+    """
+
+    def marker_var(remaining):
+        # either identifier, or literal string
+        m = IDENTIFIER.match(remaining)
+        if m:
+            result = m.groups()[0]
+            remaining = remaining[m.end():]
+        elif not remaining:
+            raise SyntaxError('unexpected end of input')
+        else:
+            q = remaining[0]
+            if q not in '\'"':
+                raise SyntaxError('invalid expression: %s' % remaining)
+            oq = '\'"'.replace(q, '')
+            remaining = remaining[1:]
+            parts = [q]
+            while remaining:
+                # either a string chunk, or oq, or q to terminate
+                if remaining[0] == q:
+                    break
+                elif remaining[0] == oq:
+                    parts.append(oq)
+                    remaining = remaining[1:]
+                else:
+                    m = STRING_CHUNK.match(remaining)
+                    if not m:
+                        raise SyntaxError('error in string literal: %s' %
+                                          remaining)
+                    parts.append(m.groups()[0])
+                    remaining = remaining[m.end():]
+            else:
+                s = ''.join(parts)
+                raise SyntaxError('unterminated string: %s' % s)
+            parts.append(q)
+            result = ''.join(parts)
+            remaining = remaining[1:].lstrip()  # skip past closing quote
+        return result, remaining
+
+    def marker_expr(remaining):
+        if remaining and remaining[0] == '(':
+            result, remaining = marker(remaining[1:].lstrip())
+            if remaining[0] != ')':
+                raise SyntaxError('unterminated parenthesis: %s' % remaining)
+            remaining = remaining[1:].lstrip()
+        else:
+            lhs, remaining = marker_var(remaining)
+            while remaining:
+                m = MARKER_OP.match(remaining)
+                if not m:
+                    break
+                op = m.groups()[0]
+                remaining = remaining[m.end():]
+                rhs, remaining = marker_var(remaining)
+                lhs = {'op': op, 'lhs': lhs, 'rhs': rhs}
+            result = lhs
+        return result, remaining
+
+    def marker_and(remaining):
+        lhs, remaining = marker_expr(remaining)
+        while remaining:
+            m = AND.match(remaining)
+            if not m:
+                break
+            remaining = remaining[m.end():]
+            rhs, remaining = marker_expr(remaining)
+            lhs = {'op': 'and', 'lhs': lhs, 'rhs': rhs}
+        return lhs, remaining
+
+    def marker(remaining):
+        lhs, remaining = marker_and(remaining)
+        while remaining:
+            m = OR.match(remaining)
+            if not m:
+                break
+            remaining = remaining[m.end():]
+            rhs, remaining = marker_and(remaining)
+            lhs = {'op': 'or', 'lhs': lhs, 'rhs': rhs}
+        return lhs, remaining
+
+    return marker(marker_string)
+
+
+def parse_requirement(req):
+    """
+    Parse a requirement passed in as a string. Return a Container
+    whose attributes contain the various parts of the requirement.
+    """
+    remaining = req.strip()
+    if not remaining or remaining.startswith('#'):
+        return None
+    m = IDENTIFIER.match(remaining)
+    if not m:
+        raise SyntaxError('name expected: %s' % remaining)
+    distname = m.groups()[0]
+    remaining = remaining[m.end():]
+    extras = mark_expr = versions = uri = None
+    if remaining and remaining[0] == '[':
+        i = remaining.find(']', 1)
+        if i < 0:
+            raise SyntaxError('unterminated extra: %s' % remaining)
+        s = remaining[1:i]
+        remaining = remaining[i + 1:].lstrip()
+        extras = []
+        while s:
+            m = IDENTIFIER.match(s)
+            if not m:
+                raise SyntaxError('malformed extra: %s' % s)
+            extras.append(m.groups()[0])
+            s = s[m.end():]
+            if not s:
+                break
+            if s[0] != ',':
+                raise SyntaxError('comma expected in extras: %s' % s)
+            s = s[1:].lstrip()
+        if not extras:
+            extras = None
+    if remaining:
+        if remaining[0] == '@':
+            # it's a URI
+            remaining = remaining[1:].lstrip()
+            m = NON_SPACE.match(remaining)
+            if not m:
+                raise SyntaxError('invalid URI: %s' % remaining)
+            uri = m.groups()[0]
+            t = urlparse(uri)
+            # there are issues with Python and URL parsing, so this test
+            # is a bit crude. See bpo-20271, bpo-23505. Python doesn't
+            # always parse invalid URLs correctly - it should raise
+            # exceptions for malformed URLs
+            if not (t.scheme and t.netloc):
+                raise SyntaxError('Invalid URL: %s' % uri)
+            remaining = remaining[m.end():].lstrip()
+        else:
+
+            def get_versions(ver_remaining):
+                """
+                Return a list of operator, version tuples if any are
+                specified, else None.
+                """
+                m = COMPARE_OP.match(ver_remaining)
+                versions = None
+                if m:
+                    versions = []
+                    while True:
+                        op = m.groups()[0]
+                        ver_remaining = ver_remaining[m.end():]
+                        m = VERSION_IDENTIFIER.match(ver_remaining)
+                        if not m:
+                            raise SyntaxError('invalid version: %s' %
+                                              ver_remaining)
+                        v = m.groups()[0]
+                        versions.append((op, v))
+                        ver_remaining = ver_remaining[m.end():]
+                        if not ver_remaining or ver_remaining[0] != ',':
+                            break
+                        ver_remaining = ver_remaining[1:].lstrip()
+                        # Some packages have a trailing comma which would break things
+                        # See issue #148
+                        if not ver_remaining:
+                            break
+                        m = COMPARE_OP.match(ver_remaining)
+                        if not m:
+                            raise SyntaxError('invalid constraint: %s' %
+                                              ver_remaining)
+                    if not versions:
+                        versions = None
+                return versions, ver_remaining
+
+            if remaining[0] != '(':
+                versions, remaining = get_versions(remaining)
+            else:
+                i = remaining.find(')', 1)
+                if i < 0:
+                    raise SyntaxError('unterminated parenthesis: %s' %
+                                      remaining)
+                s = remaining[1:i]
+                remaining = remaining[i + 1:].lstrip()
+                # As a special diversion from PEP 508, allow a version number
+                # a.b.c in parentheses as a synonym for ~= a.b.c (because this
+                # is allowed in earlier PEPs)
+                if COMPARE_OP.match(s):
+                    versions, _ = get_versions(s)
+                else:
+                    m = VERSION_IDENTIFIER.match(s)
+                    if not m:
+                        raise SyntaxError('invalid constraint: %s' % s)
+                    v = m.groups()[0]
+                    s = s[m.end():].lstrip()
+                    if s:
+                        raise SyntaxError('invalid constraint: %s' % s)
+                    versions = [('~=', v)]
+
+    if remaining:
+        if remaining[0] != ';':
+            raise SyntaxError('invalid requirement: %s' % remaining)
+        remaining = remaining[1:].lstrip()
+
+        mark_expr, remaining = parse_marker(remaining)
+
+    if remaining and remaining[0] != '#':
+        raise SyntaxError('unexpected trailing data: %s' % remaining)
+
+    if not versions:
+        rs = distname
+    else:
+        rs = '%s %s' % (distname, ', '.join(
+            ['%s %s' % con for con in versions]))
+    return Container(name=distname,
+                     extras=extras,
+                     constraints=versions,
+                     marker=mark_expr,
+                     url=uri,
+                     requirement=rs)
+
+
+def get_resources_dests(resources_root, rules):
+    """Find destinations for resources files"""
+
+    def get_rel_path(root, path):
+        # normalizes and returns a lstripped-/-separated path
+        root = root.replace(os.path.sep, '/')
+        path = path.replace(os.path.sep, '/')
+        assert path.startswith(root)
+        return path[len(root):].lstrip('/')
+
+    destinations = {}
+    for base, suffix, dest in rules:
+        prefix = os.path.join(resources_root, base)
+        for abs_base in iglob(prefix):
+            abs_glob = os.path.join(abs_base, suffix)
+            for abs_path in iglob(abs_glob):
+                resource_file = get_rel_path(resources_root, abs_path)
+                if dest is None:  # remove the entry if it was here
+                    destinations.pop(resource_file, None)
+                else:
+                    rel_path = get_rel_path(abs_base, abs_path)
+                    rel_dest = dest.replace(os.path.sep, '/').rstrip('/')
+                    destinations[resource_file] = rel_dest + '/' + rel_path
+    return destinations
+
+
+def in_venv():
+    if hasattr(sys, 'real_prefix'):
+        # virtualenv venvs
+        result = True
+    else:
+        # PEP 405 venvs
+        result = sys.prefix != getattr(sys, 'base_prefix', sys.prefix)
+    return result
+
+
+def get_executable():
+    # The __PYVENV_LAUNCHER__ dance is apparently no longer needed, as
+    # changes to the stub launcher mean that sys.executable always points
+    # to the stub on OS X
+    #    if sys.platform == 'darwin' and ('__PYVENV_LAUNCHER__'
+    #                                     in os.environ):
+    #        result =  os.environ['__PYVENV_LAUNCHER__']
+    #    else:
+    #        result = sys.executable
+    #    return result
+    # Avoid normcasing: see issue #143
+    # result = os.path.normcase(sys.executable)
+    result = sys.executable
+    if not isinstance(result, text_type):
+        result = fsdecode(result)
+    return result
+
+
+def proceed(prompt, allowed_chars, error_prompt=None, default=None):
+    p = prompt
+    while True:
+        s = raw_input(p)
+        p = prompt
+        if not s and default:
+            s = default
+        if s:
+            c = s[0].lower()
+            if c in allowed_chars:
+                break
+            if error_prompt:
+                p = '%c: %s\n%s' % (c, error_prompt, prompt)
+    return c
+
+
+def extract_by_key(d, keys):
+    if isinstance(keys, string_types):
+        keys = keys.split()
+    result = {}
+    for key in keys:
+        if key in d:
+            result[key] = d[key]
+    return result
+
+
+def read_exports(stream):
+    if sys.version_info[0] >= 3:
+        # needs to be a text stream
+        stream = codecs.getreader('utf-8')(stream)
+    # Try to load as JSON, falling back on legacy format
+    data = stream.read()
+    stream = StringIO(data)
+    try:
+        jdata = json.load(stream)
+        result = jdata['extensions']['python.exports']['exports']
+        for group, entries in result.items():
+            for k, v in entries.items():
+                s = '%s = %s' % (k, v)
+                entry = get_export_entry(s)
+                assert entry is not None
+                entries[k] = entry
+        return result
+    except Exception:
+        stream.seek(0, 0)
+
+    def read_stream(cp, stream):
+        if hasattr(cp, 'read_file'):
+            cp.read_file(stream)
+        else:
+            cp.readfp(stream)
+
+    cp = configparser.ConfigParser()
+    try:
+        read_stream(cp, stream)
+    except configparser.MissingSectionHeaderError:
+        stream.close()
+        data = textwrap.dedent(data)
+        stream = StringIO(data)
+        read_stream(cp, stream)
+
+    result = {}
+    for key in cp.sections():
+        result[key] = entries = {}
+        for name, value in cp.items(key):
+            s = '%s = %s' % (name, value)
+            entry = get_export_entry(s)
+            assert entry is not None
+            # entry.dist = self
+            entries[name] = entry
+    return result
+
+
+def write_exports(exports, stream):
+    if sys.version_info[0] >= 3:
+        # needs to be a text stream
+        stream = codecs.getwriter('utf-8')(stream)
+    cp = configparser.ConfigParser()
+    for k, v in exports.items():
+        # TODO check k, v for valid values
+        cp.add_section(k)
+        for entry in v.values():
+            if entry.suffix is None:
+                s = entry.prefix
+            else:
+                s = '%s:%s' % (entry.prefix, entry.suffix)
+            if entry.flags:
+                s = '%s [%s]' % (s, ', '.join(entry.flags))
+            cp.set(k, entry.name, s)
+    cp.write(stream)
+
+
+@contextlib.contextmanager
+def tempdir():
+    td = tempfile.mkdtemp()
+    try:
+        yield td
+    finally:
+        shutil.rmtree(td)
+
+
+@contextlib.contextmanager
+def chdir(d):
+    cwd = os.getcwd()
+    try:
+        os.chdir(d)
+        yield
+    finally:
+        os.chdir(cwd)
+
+
+@contextlib.contextmanager
+def socket_timeout(seconds=15):
+    cto = socket.getdefaulttimeout()
+    try:
+        socket.setdefaulttimeout(seconds)
+        yield
+    finally:
+        socket.setdefaulttimeout(cto)
+
+
+class cached_property(object):
+
+    def __init__(self, func):
+        self.func = func
+        # for attr in ('__name__', '__module__', '__doc__'):
+        #     setattr(self, attr, getattr(func, attr, None))
+
+    def __get__(self, obj, cls=None):
+        if obj is None:
+            return self
+        value = self.func(obj)
+        object.__setattr__(obj, self.func.__name__, value)
+        # obj.__dict__[self.func.__name__] = value = self.func(obj)
+        return value
+
+
+def convert_path(pathname):
+    """Return 'pathname' as a name that will work on the native filesystem.
+
+    The path is split on '/' and put back together again using the current
+    directory separator.  Needed because filenames in the setup script are
+    always supplied in Unix style, and have to be converted to the local
+    convention before we can actually use them in the filesystem.  Raises
+    ValueError on non-Unix-ish systems if 'pathname' either starts or
+    ends with a slash.
+    """
+    if os.sep == '/':
+        return pathname
+    if not pathname:
+        return pathname
+    if pathname[0] == '/':
+        raise ValueError("path '%s' cannot be absolute" % pathname)
+    if pathname[-1] == '/':
+        raise ValueError("path '%s' cannot end with '/'" % pathname)
+
+    paths = pathname.split('/')
+    while os.curdir in paths:
+        paths.remove(os.curdir)
+    if not paths:
+        return os.curdir
+    return os.path.join(*paths)
+
+
+class FileOperator(object):
+
+    def __init__(self, dry_run=False):
+        self.dry_run = dry_run
+        self.ensured = set()
+        self._init_record()
+
+    def _init_record(self):
+        self.record = False
+        self.files_written = set()
+        self.dirs_created = set()
+
+    def record_as_written(self, path):
+        if self.record:
+            self.files_written.add(path)
+
+    def newer(self, source, target):
+        """Tell if the target is newer than the source.
+
+        Returns true if 'source' exists and is more recently modified than
+        'target', or if 'source' exists and 'target' doesn't.
+
+        Returns false if both exist and 'target' is the same age or younger
+        than 'source'. Raise PackagingFileError if 'source' does not exist.
+
+        Note that this test is not very accurate: files created in the same
+        second will have the same "age".
+        """
+        if not os.path.exists(source):
+            raise DistlibException("file '%r' does not exist" %
+                                   os.path.abspath(source))
+        if not os.path.exists(target):
+            return True
+
+        return os.stat(source).st_mtime > os.stat(target).st_mtime
+
+    def copy_file(self, infile, outfile, check=True):
+        """Copy a file respecting dry-run and force flags.
+        """
+        self.ensure_dir(os.path.dirname(outfile))
+        logger.info('Copying %s to %s', infile, outfile)
+        if not self.dry_run:
+            msg = None
+            if check:
+                if os.path.islink(outfile):
+                    msg = '%s is a symlink' % outfile
+                elif os.path.exists(outfile) and not os.path.isfile(outfile):
+                    msg = '%s is a non-regular file' % outfile
+            if msg:
+                raise ValueError(msg + ' which would be overwritten')
+            shutil.copyfile(infile, outfile)
+        self.record_as_written(outfile)
+
+    def copy_stream(self, instream, outfile, encoding=None):
+        assert not os.path.isdir(outfile)
+        self.ensure_dir(os.path.dirname(outfile))
+        logger.info('Copying stream %s to %s', instream, outfile)
+        if not self.dry_run:
+            if encoding is None:
+                outstream = open(outfile, 'wb')
+            else:
+                outstream = codecs.open(outfile, 'w', encoding=encoding)
+            try:
+                shutil.copyfileobj(instream, outstream)
+            finally:
+                outstream.close()
+        self.record_as_written(outfile)
+
+    def write_binary_file(self, path, data):
+        self.ensure_dir(os.path.dirname(path))
+        if not self.dry_run:
+            if os.path.exists(path):
+                os.remove(path)
+            with open(path, 'wb') as f:
+                f.write(data)
+        self.record_as_written(path)
+
+    def write_text_file(self, path, data, encoding):
+        self.write_binary_file(path, data.encode(encoding))
+
+    def set_mode(self, bits, mask, files):
+        if os.name == 'posix' or (os.name == 'java' and os._name == 'posix'):
+            # Set the executable bits (owner, group, and world) on
+            # all the files specified.
+            for f in files:
+                if self.dry_run:
+                    logger.info("changing mode of %s", f)
+                else:
+                    mode = (os.stat(f).st_mode | bits) & mask
+                    logger.info("changing mode of %s to %o", f, mode)
+                    os.chmod(f, mode)
+
+    set_executable_mode = lambda s, f: s.set_mode(0o555, 0o7777, f)
+
+    def ensure_dir(self, path):
+        path = os.path.abspath(path)
+        if path not in self.ensured and not os.path.exists(path):
+            self.ensured.add(path)
+            d, f = os.path.split(path)
+            self.ensure_dir(d)
+            logger.info('Creating %s' % path)
+            if not self.dry_run:
+                os.mkdir(path)
+            if self.record:
+                self.dirs_created.add(path)
+
+    def byte_compile(self,
+                     path,
+                     optimize=False,
+                     force=False,
+                     prefix=None,
+                     hashed_invalidation=False):
+        dpath = cache_from_source(path, not optimize)
+        logger.info('Byte-compiling %s to %s', path, dpath)
+        if not self.dry_run:
+            if force or self.newer(path, dpath):
+                if not prefix:
+                    diagpath = None
+                else:
+                    assert path.startswith(prefix)
+                    diagpath = path[len(prefix):]
+            compile_kwargs = {}
+            if hashed_invalidation and hasattr(py_compile,
+                                               'PycInvalidationMode'):
+                compile_kwargs[
+                    'invalidation_mode'] = py_compile.PycInvalidationMode.CHECKED_HASH
+            py_compile.compile(path, dpath, diagpath, True,
+                               **compile_kwargs)  # raise error
+        self.record_as_written(dpath)
+        return dpath
+
+    def ensure_removed(self, path):
+        if os.path.exists(path):
+            if os.path.isdir(path) and not os.path.islink(path):
+                logger.debug('Removing directory tree at %s', path)
+                if not self.dry_run:
+                    shutil.rmtree(path)
+                if self.record:
+                    if path in self.dirs_created:
+                        self.dirs_created.remove(path)
+            else:
+                if os.path.islink(path):
+                    s = 'link'
+                else:
+                    s = 'file'
+                logger.debug('Removing %s %s', s, path)
+                if not self.dry_run:
+                    os.remove(path)
+                if self.record:
+                    if path in self.files_written:
+                        self.files_written.remove(path)
+
+    def is_writable(self, path):
+        result = False
+        while not result:
+            if os.path.exists(path):
+                result = os.access(path, os.W_OK)
+                break
+            parent = os.path.dirname(path)
+            if parent == path:
+                break
+            path = parent
+        return result
+
+    def commit(self):
+        """
+        Commit recorded changes, turn off recording, return
+        changes.
+        """
+        assert self.record
+        result = self.files_written, self.dirs_created
+        self._init_record()
+        return result
+
+    def rollback(self):
+        if not self.dry_run:
+            for f in list(self.files_written):
+                if os.path.exists(f):
+                    os.remove(f)
+            # dirs should all be empty now, except perhaps for
+            # __pycache__ subdirs
+            # reverse so that subdirs appear before their parents
+            dirs = sorted(self.dirs_created, reverse=True)
+            for d in dirs:
+                flist = os.listdir(d)
+                if flist:
+                    assert flist == ['__pycache__']
+                    sd = os.path.join(d, flist[0])
+                    os.rmdir(sd)
+                os.rmdir(d)  # should fail if non-empty
+        self._init_record()
+
+
+def resolve(module_name, dotted_path):
+    if module_name in sys.modules:
+        mod = sys.modules[module_name]
+    else:
+        mod = __import__(module_name)
+    if dotted_path is None:
+        result = mod
+    else:
+        parts = dotted_path.split('.')
+        result = getattr(mod, parts.pop(0))
+        for p in parts:
+            result = getattr(result, p)
+    return result
+
+
+class ExportEntry(object):
+
+    def __init__(self, name, prefix, suffix, flags):
+        self.name = name
+        self.prefix = prefix
+        self.suffix = suffix
+        self.flags = flags
+
+    @cached_property
+    def value(self):
+        return resolve(self.prefix, self.suffix)
+
+    def __repr__(self):  # pragma: no cover
+        return '' % (self.name, self.prefix,
+                                                self.suffix, self.flags)
+
+    def __eq__(self, other):
+        if not isinstance(other, ExportEntry):
+            result = False
+        else:
+            result = (self.name == other.name and self.prefix == other.prefix
+                      and self.suffix == other.suffix
+                      and self.flags == other.flags)
+        return result
+
+    __hash__ = object.__hash__
+
+
+ENTRY_RE = re.compile(
+    r'''(?P([^\[]\S*))
+                      \s*=\s*(?P(\w+)([:\.]\w+)*)
+                      \s*(\[\s*(?P[\w-]+(=\w+)?(,\s*\w+(=\w+)?)*)\s*\])?
+                      ''', re.VERBOSE)
+
+
+def get_export_entry(specification):
+    m = ENTRY_RE.search(specification)
+    if not m:
+        result = None
+        if '[' in specification or ']' in specification:
+            raise DistlibException("Invalid specification "
+                                   "'%s'" % specification)
+    else:
+        d = m.groupdict()
+        name = d['name']
+        path = d['callable']
+        colons = path.count(':')
+        if colons == 0:
+            prefix, suffix = path, None
+        else:
+            if colons != 1:
+                raise DistlibException("Invalid specification "
+                                       "'%s'" % specification)
+            prefix, suffix = path.split(':')
+        flags = d['flags']
+        if flags is None:
+            if '[' in specification or ']' in specification:
+                raise DistlibException("Invalid specification "
+                                       "'%s'" % specification)
+            flags = []
+        else:
+            flags = [f.strip() for f in flags.split(',')]
+        result = ExportEntry(name, prefix, suffix, flags)
+    return result
+
+
+def get_cache_base(suffix=None):
+    """
+    Return the default base location for distlib caches. If the directory does
+    not exist, it is created. Use the suffix provided for the base directory,
+    and default to '.distlib' if it isn't provided.
+
+    On Windows, if LOCALAPPDATA is defined in the environment, then it is
+    assumed to be a directory, and will be the parent directory of the result.
+    On POSIX, and on Windows if LOCALAPPDATA is not defined, the user's home
+    directory - using os.expanduser('~') - will be the parent directory of
+    the result.
+
+    The result is just the directory '.distlib' in the parent directory as
+    determined above, or with the name specified with ``suffix``.
+    """
+    if suffix is None:
+        suffix = '.distlib'
+    if os.name == 'nt' and 'LOCALAPPDATA' in os.environ:
+        result = os.path.expandvars('$localappdata')
+    else:
+        # Assume posix, or old Windows
+        result = os.path.expanduser('~')
+    # we use 'isdir' instead of 'exists', because we want to
+    # fail if there's a file with that name
+    if os.path.isdir(result):
+        usable = os.access(result, os.W_OK)
+        if not usable:
+            logger.warning('Directory exists but is not writable: %s', result)
+    else:
+        try:
+            os.makedirs(result)
+            usable = True
+        except OSError:
+            logger.warning('Unable to create %s', result, exc_info=True)
+            usable = False
+    if not usable:
+        result = tempfile.mkdtemp()
+        logger.warning('Default location unusable, using %s', result)
+    return os.path.join(result, suffix)
+
+
+def path_to_cache_dir(path):
+    """
+    Convert an absolute path to a directory name for use in a cache.
+
+    The algorithm used is:
+
+    #. On Windows, any ``':'`` in the drive is replaced with ``'---'``.
+    #. Any occurrence of ``os.sep`` is replaced with ``'--'``.
+    #. ``'.cache'`` is appended.
+    """
+    d, p = os.path.splitdrive(os.path.abspath(path))
+    if d:
+        d = d.replace(':', '---')
+    p = p.replace(os.sep, '--')
+    return d + p + '.cache'
+
+
+def ensure_slash(s):
+    if not s.endswith('/'):
+        return s + '/'
+    return s
+
+
+def parse_credentials(netloc):
+    username = password = None
+    if '@' in netloc:
+        prefix, netloc = netloc.rsplit('@', 1)
+        if ':' not in prefix:
+            username = prefix
+        else:
+            username, password = prefix.split(':', 1)
+    if username:
+        username = unquote(username)
+    if password:
+        password = unquote(password)
+    return username, password, netloc
+
+
+def get_process_umask():
+    result = os.umask(0o22)
+    os.umask(result)
+    return result
+
+
+def is_string_sequence(seq):
+    result = True
+    i = None
+    for i, s in enumerate(seq):
+        if not isinstance(s, string_types):
+            result = False
+            break
+    assert i is not None
+    return result
+
+
+PROJECT_NAME_AND_VERSION = re.compile(
+    '([a-z0-9_]+([.-][a-z_][a-z0-9_]*)*)-'
+    '([a-z0-9_.+-]+)', re.I)
+PYTHON_VERSION = re.compile(r'-py(\d\.?\d?)')
+
+
+def split_filename(filename, project_name=None):
+    """
+    Extract name, version, python version from a filename (no extension)
+
+    Return name, version, pyver or None
+    """
+    result = None
+    pyver = None
+    filename = unquote(filename).replace(' ', '-')
+    m = PYTHON_VERSION.search(filename)
+    if m:
+        pyver = m.group(1)
+        filename = filename[:m.start()]
+    if project_name and len(filename) > len(project_name) + 1:
+        m = re.match(re.escape(project_name) + r'\b', filename)
+        if m:
+            n = m.end()
+            result = filename[:n], filename[n + 1:], pyver
+    if result is None:
+        m = PROJECT_NAME_AND_VERSION.match(filename)
+        if m:
+            result = m.group(1), m.group(3), pyver
+    return result
+
+
+# Allow spaces in name because of legacy dists like "Twisted Core"
+NAME_VERSION_RE = re.compile(r'(?P[\w .-]+)\s*'
+                             r'\(\s*(?P[^\s)]+)\)$')
+
+
+def parse_name_and_version(p):
+    """
+    A utility method used to get name and version from a string.
+
+    From e.g. a Provides-Dist value.
+
+    :param p: A value in a form 'foo (1.0)'
+    :return: The name and version as a tuple.
+    """
+    m = NAME_VERSION_RE.match(p)
+    if not m:
+        raise DistlibException('Ill-formed name/version string: \'%s\'' % p)
+    d = m.groupdict()
+    return d['name'].strip().lower(), d['ver']
+
+
+def get_extras(requested, available):
+    result = set()
+    requested = set(requested or [])
+    available = set(available or [])
+    if '*' in requested:
+        requested.remove('*')
+        result |= available
+    for r in requested:
+        if r == '-':
+            result.add(r)
+        elif r.startswith('-'):
+            unwanted = r[1:]
+            if unwanted not in available:
+                logger.warning('undeclared extra: %s' % unwanted)
+            if unwanted in result:
+                result.remove(unwanted)
+        else:
+            if r not in available:
+                logger.warning('undeclared extra: %s' % r)
+            result.add(r)
+    return result
+
+
+#
+# Extended metadata functionality
+#
+
+
+def _get_external_data(url):
+    result = {}
+    try:
+        # urlopen might fail if it runs into redirections,
+        # because of Python issue #13696. Fixed in locators
+        # using a custom redirect handler.
+        resp = urlopen(url)
+        headers = resp.info()
+        ct = headers.get('Content-Type')
+        if not ct.startswith('application/json'):
+            logger.debug('Unexpected response for JSON request: %s', ct)
+        else:
+            reader = codecs.getreader('utf-8')(resp)
+            # data = reader.read().decode('utf-8')
+            # result = json.loads(data)
+            result = json.load(reader)
+    except Exception as e:
+        logger.exception('Failed to get external data for %s: %s', url, e)
+    return result
+
+
+_external_data_base_url = 'https://www.red-dove.com/pypi/projects/'
+
+
+def get_project_data(name):
+    url = '%s/%s/project.json' % (name[0].upper(), name)
+    url = urljoin(_external_data_base_url, url)
+    result = _get_external_data(url)
+    return result
+
+
+def get_package_data(name, version):
+    url = '%s/%s/package-%s.json' % (name[0].upper(), name, version)
+    url = urljoin(_external_data_base_url, url)
+    return _get_external_data(url)
+
+
+class Cache(object):
+    """
+    A class implementing a cache for resources that need to live in the file system
+    e.g. shared libraries. This class was moved from resources to here because it
+    could be used by other modules, e.g. the wheel module.
+    """
+
+    def __init__(self, base):
+        """
+        Initialise an instance.
+
+        :param base: The base directory where the cache should be located.
+        """
+        # we use 'isdir' instead of 'exists', because we want to
+        # fail if there's a file with that name
+        if not os.path.isdir(base):  # pragma: no cover
+            os.makedirs(base)
+        if (os.stat(base).st_mode & 0o77) != 0:
+            logger.warning('Directory \'%s\' is not private', base)
+        self.base = os.path.abspath(os.path.normpath(base))
+
+    def prefix_to_dir(self, prefix):
+        """
+        Converts a resource prefix to a directory name in the cache.
+        """
+        return path_to_cache_dir(prefix)
+
+    def clear(self):
+        """
+        Clear the cache.
+        """
+        not_removed = []
+        for fn in os.listdir(self.base):
+            fn = os.path.join(self.base, fn)
+            try:
+                if os.path.islink(fn) or os.path.isfile(fn):
+                    os.remove(fn)
+                elif os.path.isdir(fn):
+                    shutil.rmtree(fn)
+            except Exception:
+                not_removed.append(fn)
+        return not_removed
+
+
+class EventMixin(object):
+    """
+    A very simple publish/subscribe system.
+    """
+
+    def __init__(self):
+        self._subscribers = {}
+
+    def add(self, event, subscriber, append=True):
+        """
+        Add a subscriber for an event.
+
+        :param event: The name of an event.
+        :param subscriber: The subscriber to be added (and called when the
+                           event is published).
+        :param append: Whether to append or prepend the subscriber to an
+                       existing subscriber list for the event.
+        """
+        subs = self._subscribers
+        if event not in subs:
+            subs[event] = deque([subscriber])
+        else:
+            sq = subs[event]
+            if append:
+                sq.append(subscriber)
+            else:
+                sq.appendleft(subscriber)
+
+    def remove(self, event, subscriber):
+        """
+        Remove a subscriber for an event.
+
+        :param event: The name of an event.
+        :param subscriber: The subscriber to be removed.
+        """
+        subs = self._subscribers
+        if event not in subs:
+            raise ValueError('No subscribers: %r' % event)
+        subs[event].remove(subscriber)
+
+    def get_subscribers(self, event):
+        """
+        Return an iterator for the subscribers for an event.
+        :param event: The event to return subscribers for.
+        """
+        return iter(self._subscribers.get(event, ()))
+
+    def publish(self, event, *args, **kwargs):
+        """
+        Publish a event and return a list of values returned by its
+        subscribers.
+
+        :param event: The event to publish.
+        :param args: The positional arguments to pass to the event's
+                     subscribers.
+        :param kwargs: The keyword arguments to pass to the event's
+                       subscribers.
+        """
+        result = []
+        for subscriber in self.get_subscribers(event):
+            try:
+                value = subscriber(event, *args, **kwargs)
+            except Exception:
+                logger.exception('Exception during event publication')
+                value = None
+            result.append(value)
+        logger.debug('publish %s: args = %s, kwargs = %s, result = %s', event,
+                     args, kwargs, result)
+        return result
+
+
+#
+# Simple sequencing
+#
+class Sequencer(object):
+
+    def __init__(self):
+        self._preds = {}
+        self._succs = {}
+        self._nodes = set()  # nodes with no preds/succs
+
+    def add_node(self, node):
+        self._nodes.add(node)
+
+    def remove_node(self, node, edges=False):
+        if node in self._nodes:
+            self._nodes.remove(node)
+        if edges:
+            for p in set(self._preds.get(node, ())):
+                self.remove(p, node)
+            for s in set(self._succs.get(node, ())):
+                self.remove(node, s)
+            # Remove empties
+            for k, v in list(self._preds.items()):
+                if not v:
+                    del self._preds[k]
+            for k, v in list(self._succs.items()):
+                if not v:
+                    del self._succs[k]
+
+    def add(self, pred, succ):
+        assert pred != succ
+        self._preds.setdefault(succ, set()).add(pred)
+        self._succs.setdefault(pred, set()).add(succ)
+
+    def remove(self, pred, succ):
+        assert pred != succ
+        try:
+            preds = self._preds[succ]
+            succs = self._succs[pred]
+        except KeyError:  # pragma: no cover
+            raise ValueError('%r not a successor of anything' % succ)
+        try:
+            preds.remove(pred)
+            succs.remove(succ)
+        except KeyError:  # pragma: no cover
+            raise ValueError('%r not a successor of %r' % (succ, pred))
+
+    def is_step(self, step):
+        return (step in self._preds or step in self._succs
+                or step in self._nodes)
+
+    def get_steps(self, final):
+        if not self.is_step(final):
+            raise ValueError('Unknown: %r' % final)
+        result = []
+        todo = []
+        seen = set()
+        todo.append(final)
+        while todo:
+            step = todo.pop(0)
+            if step in seen:
+                # if a step was already seen,
+                # move it to the end (so it will appear earlier
+                # when reversed on return) ... but not for the
+                # final step, as that would be confusing for
+                # users
+                if step != final:
+                    result.remove(step)
+                    result.append(step)
+            else:
+                seen.add(step)
+                result.append(step)
+                preds = self._preds.get(step, ())
+                todo.extend(preds)
+        return reversed(result)
+
+    @property
+    def strong_connections(self):
+        # http://en.wikipedia.org/wiki/Tarjan%27s_strongly_connected_components_algorithm
+        index_counter = [0]
+        stack = []
+        lowlinks = {}
+        index = {}
+        result = []
+
+        graph = self._succs
+
+        def strongconnect(node):
+            # set the depth index for this node to the smallest unused index
+            index[node] = index_counter[0]
+            lowlinks[node] = index_counter[0]
+            index_counter[0] += 1
+            stack.append(node)
+
+            # Consider successors
+            try:
+                successors = graph[node]
+            except Exception:
+                successors = []
+            for successor in successors:
+                if successor not in lowlinks:
+                    # Successor has not yet been visited
+                    strongconnect(successor)
+                    lowlinks[node] = min(lowlinks[node], lowlinks[successor])
+                elif successor in stack:
+                    # the successor is in the stack and hence in the current
+                    # strongly connected component (SCC)
+                    lowlinks[node] = min(lowlinks[node], index[successor])
+
+            # If `node` is a root node, pop the stack and generate an SCC
+            if lowlinks[node] == index[node]:
+                connected_component = []
+
+                while True:
+                    successor = stack.pop()
+                    connected_component.append(successor)
+                    if successor == node:
+                        break
+                component = tuple(connected_component)
+                # storing the result
+                result.append(component)
+
+        for node in graph:
+            if node not in lowlinks:
+                strongconnect(node)
+
+        return result
+
+    @property
+    def dot(self):
+        result = ['digraph G {']
+        for succ in self._preds:
+            preds = self._preds[succ]
+            for pred in preds:
+                result.append('  %s -> %s;' % (pred, succ))
+        for node in self._nodes:
+            result.append('  %s;' % node)
+        result.append('}')
+        return '\n'.join(result)
+
+
+#
+# Unarchiving functionality for zip, tar, tgz, tbz, whl
+#
+
+ARCHIVE_EXTENSIONS = ('.tar.gz', '.tar.bz2', '.tar', '.zip', '.tgz', '.tbz',
+                      '.whl')
+
+
+def unarchive(archive_filename, dest_dir, format=None, check=True):
+
+    def check_path(path):
+        if not isinstance(path, text_type):
+            path = path.decode('utf-8')
+        p = os.path.abspath(os.path.join(dest_dir, path))
+        if not p.startswith(dest_dir) or p[plen] != os.sep:
+            raise ValueError('path outside destination: %r' % p)
+
+    dest_dir = os.path.abspath(dest_dir)
+    plen = len(dest_dir)
+    archive = None
+    if format is None:
+        if archive_filename.endswith(('.zip', '.whl')):
+            format = 'zip'
+        elif archive_filename.endswith(('.tar.gz', '.tgz')):
+            format = 'tgz'
+            mode = 'r:gz'
+        elif archive_filename.endswith(('.tar.bz2', '.tbz')):
+            format = 'tbz'
+            mode = 'r:bz2'
+        elif archive_filename.endswith('.tar'):
+            format = 'tar'
+            mode = 'r'
+        else:  # pragma: no cover
+            raise ValueError('Unknown format for %r' % archive_filename)
+    try:
+        if format == 'zip':
+            archive = ZipFile(archive_filename, 'r')
+            if check:
+                names = archive.namelist()
+                for name in names:
+                    check_path(name)
+        else:
+            archive = tarfile.open(archive_filename, mode)
+            if check:
+                names = archive.getnames()
+                for name in names:
+                    check_path(name)
+        if format != 'zip' and sys.version_info[0] < 3:
+            # See Python issue 17153. If the dest path contains Unicode,
+            # tarfile extraction fails on Python 2.x if a member path name
+            # contains non-ASCII characters - it leads to an implicit
+            # bytes -> unicode conversion using ASCII to decode.
+            for tarinfo in archive.getmembers():
+                if not isinstance(tarinfo.name, text_type):
+                    tarinfo.name = tarinfo.name.decode('utf-8')
+
+        # Limit extraction of dangerous items, if this Python
+        # allows it easily. If not, just trust the input.
+        # See: https://docs.python.org/3/library/tarfile.html#extraction-filters
+        def extraction_filter(member, path):
+            """Run tarfile.tar_filter, but raise the expected ValueError"""
+            # This is only called if the current Python has tarfile filters
+            try:
+                return tarfile.tar_filter(member, path)
+            except tarfile.FilterError as exc:
+                raise ValueError(str(exc))
+
+        archive.extraction_filter = extraction_filter
+
+        archive.extractall(dest_dir)
+
+    finally:
+        if archive:
+            archive.close()
+
+
+def zip_dir(directory):
+    """zip a directory tree into a BytesIO object"""
+    result = io.BytesIO()
+    dlen = len(directory)
+    with ZipFile(result, "w") as zf:
+        for root, dirs, files in os.walk(directory):
+            for name in files:
+                full = os.path.join(root, name)
+                rel = root[dlen:]
+                dest = os.path.join(rel, name)
+                zf.write(full, dest)
+    return result
+
+
+#
+# Simple progress bar
+#
+
+UNITS = ('', 'K', 'M', 'G', 'T', 'P')
+
+
+class Progress(object):
+    unknown = 'UNKNOWN'
+
+    def __init__(self, minval=0, maxval=100):
+        assert maxval is None or maxval >= minval
+        self.min = self.cur = minval
+        self.max = maxval
+        self.started = None
+        self.elapsed = 0
+        self.done = False
+
+    def update(self, curval):
+        assert self.min <= curval
+        assert self.max is None or curval <= self.max
+        self.cur = curval
+        now = time.time()
+        if self.started is None:
+            self.started = now
+        else:
+            self.elapsed = now - self.started
+
+    def increment(self, incr):
+        assert incr >= 0
+        self.update(self.cur + incr)
+
+    def start(self):
+        self.update(self.min)
+        return self
+
+    def stop(self):
+        if self.max is not None:
+            self.update(self.max)
+        self.done = True
+
+    @property
+    def maximum(self):
+        return self.unknown if self.max is None else self.max
+
+    @property
+    def percentage(self):
+        if self.done:
+            result = '100 %'
+        elif self.max is None:
+            result = ' ?? %'
+        else:
+            v = 100.0 * (self.cur - self.min) / (self.max - self.min)
+            result = '%3d %%' % v
+        return result
+
+    def format_duration(self, duration):
+        if (duration <= 0) and self.max is None or self.cur == self.min:
+            result = '??:??:??'
+        # elif duration < 1:
+        #     result = '--:--:--'
+        else:
+            result = time.strftime('%H:%M:%S', time.gmtime(duration))
+        return result
+
+    @property
+    def ETA(self):
+        if self.done:
+            prefix = 'Done'
+            t = self.elapsed
+            # import pdb; pdb.set_trace()
+        else:
+            prefix = 'ETA '
+            if self.max is None:
+                t = -1
+            elif self.elapsed == 0 or (self.cur == self.min):
+                t = 0
+            else:
+                # import pdb; pdb.set_trace()
+                t = float(self.max - self.min)
+                t /= self.cur - self.min
+                t = (t - 1) * self.elapsed
+        return '%s: %s' % (prefix, self.format_duration(t))
+
+    @property
+    def speed(self):
+        if self.elapsed == 0:
+            result = 0.0
+        else:
+            result = (self.cur - self.min) / self.elapsed
+        for unit in UNITS:
+            if result < 1000:
+                break
+            result /= 1000.0
+        return '%d %sB/s' % (result, unit)
+
+
+#
+# Glob functionality
+#
+
+RICH_GLOB = re.compile(r'\{([^}]*)\}')
+_CHECK_RECURSIVE_GLOB = re.compile(r'[^/\\,{]\*\*|\*\*[^/\\,}]')
+_CHECK_MISMATCH_SET = re.compile(r'^[^{]*\}|\{[^}]*$')
+
+
+def iglob(path_glob):
+    """Extended globbing function that supports ** and {opt1,opt2,opt3}."""
+    if _CHECK_RECURSIVE_GLOB.search(path_glob):
+        msg = """invalid glob %r: recursive glob "**" must be used alone"""
+        raise ValueError(msg % path_glob)
+    if _CHECK_MISMATCH_SET.search(path_glob):
+        msg = """invalid glob %r: mismatching set marker '{' or '}'"""
+        raise ValueError(msg % path_glob)
+    return _iglob(path_glob)
+
+
+def _iglob(path_glob):
+    rich_path_glob = RICH_GLOB.split(path_glob, 1)
+    if len(rich_path_glob) > 1:
+        assert len(rich_path_glob) == 3, rich_path_glob
+        prefix, set, suffix = rich_path_glob
+        for item in set.split(','):
+            for path in _iglob(''.join((prefix, item, suffix))):
+                yield path
+    else:
+        if '**' not in path_glob:
+            for item in std_iglob(path_glob):
+                yield item
+        else:
+            prefix, radical = path_glob.split('**', 1)
+            if prefix == '':
+                prefix = '.'
+            if radical == '':
+                radical = '*'
+            else:
+                # we support both
+                radical = radical.lstrip('/')
+                radical = radical.lstrip('\\')
+            for path, dir, files in os.walk(prefix):
+                path = os.path.normpath(path)
+                for fn in _iglob(os.path.join(path, radical)):
+                    yield fn
+
+
+if ssl:
+    from .compat import (HTTPSHandler as BaseHTTPSHandler, match_hostname,
+                         CertificateError)
+
+    #
+    # HTTPSConnection which verifies certificates/matches domains
+    #
+
+    class HTTPSConnection(httplib.HTTPSConnection):
+        ca_certs = None  # set this to the path to the certs file (.pem)
+        check_domain = True  # only used if ca_certs is not None
+
+        # noinspection PyPropertyAccess
+        def connect(self):
+            sock = socket.create_connection((self.host, self.port),
+                                            self.timeout)
+            if getattr(self, '_tunnel_host', False):
+                self.sock = sock
+                self._tunnel()
+
+            context = ssl.SSLContext(ssl.PROTOCOL_SSLv23)
+            if hasattr(ssl, 'OP_NO_SSLv2'):
+                context.options |= ssl.OP_NO_SSLv2
+            if getattr(self, 'cert_file', None):
+                context.load_cert_chain(self.cert_file, self.key_file)
+            kwargs = {}
+            if self.ca_certs:
+                context.verify_mode = ssl.CERT_REQUIRED
+                context.load_verify_locations(cafile=self.ca_certs)
+                if getattr(ssl, 'HAS_SNI', False):
+                    kwargs['server_hostname'] = self.host
+
+            self.sock = context.wrap_socket(sock, **kwargs)
+            if self.ca_certs and self.check_domain:
+                try:
+                    match_hostname(self.sock.getpeercert(), self.host)
+                    logger.debug('Host verified: %s', self.host)
+                except CertificateError:  # pragma: no cover
+                    self.sock.shutdown(socket.SHUT_RDWR)
+                    self.sock.close()
+                    raise
+
+    class HTTPSHandler(BaseHTTPSHandler):
+
+        def __init__(self, ca_certs, check_domain=True):
+            BaseHTTPSHandler.__init__(self)
+            self.ca_certs = ca_certs
+            self.check_domain = check_domain
+
+        def _conn_maker(self, *args, **kwargs):
+            """
+            This is called to create a connection instance. Normally you'd
+            pass a connection class to do_open, but it doesn't actually check for
+            a class, and just expects a callable. As long as we behave just as a
+            constructor would have, we should be OK. If it ever changes so that
+            we *must* pass a class, we'll create an UnsafeHTTPSConnection class
+            which just sets check_domain to False in the class definition, and
+            choose which one to pass to do_open.
+            """
+            result = HTTPSConnection(*args, **kwargs)
+            if self.ca_certs:
+                result.ca_certs = self.ca_certs
+                result.check_domain = self.check_domain
+            return result
+
+        def https_open(self, req):
+            try:
+                return self.do_open(self._conn_maker, req)
+            except URLError as e:
+                if 'certificate verify failed' in str(e.reason):
+                    raise CertificateError(
+                        'Unable to verify server certificate '
+                        'for %s' % req.host)
+                else:
+                    raise
+
+    #
+    # To prevent against mixing HTTP traffic with HTTPS (examples: A Man-In-The-
+    # Middle proxy using HTTP listens on port 443, or an index mistakenly serves
+    # HTML containing a http://xyz link when it should be https://xyz),
+    # you can use the following handler class, which does not allow HTTP traffic.
+    #
+    # It works by inheriting from HTTPHandler - so build_opener won't add a
+    # handler for HTTP itself.
+    #
+    class HTTPSOnlyHandler(HTTPSHandler, HTTPHandler):
+
+        def http_open(self, req):
+            raise URLError(
+                'Unexpected HTTP request on what should be a secure '
+                'connection: %s' % req)
+
+
+#
+# XML-RPC with timeouts
+#
+class Transport(xmlrpclib.Transport):
+
+    def __init__(self, timeout, use_datetime=0):
+        self.timeout = timeout
+        xmlrpclib.Transport.__init__(self, use_datetime)
+
+    def make_connection(self, host):
+        h, eh, x509 = self.get_host_info(host)
+        if not self._connection or host != self._connection[0]:
+            self._extra_headers = eh
+            self._connection = host, httplib.HTTPConnection(h)
+        return self._connection[1]
+
+
+if ssl:
+
+    class SafeTransport(xmlrpclib.SafeTransport):
+
+        def __init__(self, timeout, use_datetime=0):
+            self.timeout = timeout
+            xmlrpclib.SafeTransport.__init__(self, use_datetime)
+
+        def make_connection(self, host):
+            h, eh, kwargs = self.get_host_info(host)
+            if not kwargs:
+                kwargs = {}
+            kwargs['timeout'] = self.timeout
+            if not self._connection or host != self._connection[0]:
+                self._extra_headers = eh
+                self._connection = host, httplib.HTTPSConnection(
+                    h, None, **kwargs)
+            return self._connection[1]
+
+
+class ServerProxy(xmlrpclib.ServerProxy):
+
+    def __init__(self, uri, **kwargs):
+        self.timeout = timeout = kwargs.pop('timeout', None)
+        # The above classes only come into play if a timeout
+        # is specified
+        if timeout is not None:
+            # scheme = splittype(uri)  # deprecated as of Python 3.8
+            scheme = urlparse(uri)[0]
+            use_datetime = kwargs.get('use_datetime', 0)
+            if scheme == 'https':
+                tcls = SafeTransport
+            else:
+                tcls = Transport
+            kwargs['transport'] = t = tcls(timeout, use_datetime=use_datetime)
+            self.transport = t
+        xmlrpclib.ServerProxy.__init__(self, uri, **kwargs)
+
+
+#
+# CSV functionality. This is provided because on 2.x, the csv module can't
+# handle Unicode. However, we need to deal with Unicode in e.g. RECORD files.
+#
+
+
+def _csv_open(fn, mode, **kwargs):
+    if sys.version_info[0] < 3:
+        mode += 'b'
+    else:
+        kwargs['newline'] = ''
+        # Python 3 determines encoding from locale. Force 'utf-8'
+        # file encoding to match other forced utf-8 encoding
+        kwargs['encoding'] = 'utf-8'
+    return open(fn, mode, **kwargs)
+
+
+class CSVBase(object):
+    defaults = {
+        'delimiter': str(','),  # The strs are used because we need native
+        'quotechar': str('"'),  # str in the csv API (2.x won't take
+        'lineterminator': str('\n')  # Unicode)
+    }
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *exc_info):
+        self.stream.close()
+
+
+class CSVReader(CSVBase):
+
+    def __init__(self, **kwargs):
+        if 'stream' in kwargs:
+            stream = kwargs['stream']
+            if sys.version_info[0] >= 3:
+                # needs to be a text stream
+                stream = codecs.getreader('utf-8')(stream)
+            self.stream = stream
+        else:
+            self.stream = _csv_open(kwargs['path'], 'r')
+        self.reader = csv.reader(self.stream, **self.defaults)
+
+    def __iter__(self):
+        return self
+
+    def next(self):
+        result = next(self.reader)
+        if sys.version_info[0] < 3:
+            for i, item in enumerate(result):
+                if not isinstance(item, text_type):
+                    result[i] = item.decode('utf-8')
+        return result
+
+    __next__ = next
+
+
+class CSVWriter(CSVBase):
+
+    def __init__(self, fn, **kwargs):
+        self.stream = _csv_open(fn, 'w')
+        self.writer = csv.writer(self.stream, **self.defaults)
+
+    def writerow(self, row):
+        if sys.version_info[0] < 3:
+            r = []
+            for item in row:
+                if isinstance(item, text_type):
+                    item = item.encode('utf-8')
+                r.append(item)
+            row = r
+        self.writer.writerow(row)
+
+
+#
+#   Configurator functionality
+#
+
+
+class Configurator(BaseConfigurator):
+
+    value_converters = dict(BaseConfigurator.value_converters)
+    value_converters['inc'] = 'inc_convert'
+
+    def __init__(self, config, base=None):
+        super(Configurator, self).__init__(config)
+        self.base = base or os.getcwd()
+
+    def configure_custom(self, config):
+
+        def convert(o):
+            if isinstance(o, (list, tuple)):
+                result = type(o)([convert(i) for i in o])
+            elif isinstance(o, dict):
+                if '()' in o:
+                    result = self.configure_custom(o)
+                else:
+                    result = {}
+                    for k in o:
+                        result[k] = convert(o[k])
+            else:
+                result = self.convert(o)
+            return result
+
+        c = config.pop('()')
+        if not callable(c):
+            c = self.resolve(c)
+        props = config.pop('.', None)
+        # Check for valid identifiers
+        args = config.pop('[]', ())
+        if args:
+            args = tuple([convert(o) for o in args])
+        items = [(k, convert(config[k])) for k in config if valid_ident(k)]
+        kwargs = dict(items)
+        result = c(*args, **kwargs)
+        if props:
+            for n, v in props.items():
+                setattr(result, n, convert(v))
+        return result
+
+    def __getitem__(self, key):
+        result = self.config[key]
+        if isinstance(result, dict) and '()' in result:
+            self.config[key] = result = self.configure_custom(result)
+        return result
+
+    def inc_convert(self, value):
+        """Default converter for the inc:// protocol."""
+        if not os.path.isabs(value):
+            value = os.path.join(self.base, value)
+        with codecs.open(value, 'r', encoding='utf-8') as f:
+            result = json.load(f)
+        return result
+
+
+class SubprocessMixin(object):
+    """
+    Mixin for running subprocesses and capturing their output
+    """
+
+    def __init__(self, verbose=False, progress=None):
+        self.verbose = verbose
+        self.progress = progress
+
+    def reader(self, stream, context):
+        """
+        Read lines from a subprocess' output stream and either pass to a progress
+        callable (if specified) or write progress information to sys.stderr.
+        """
+        progress = self.progress
+        verbose = self.verbose
+        while True:
+            s = stream.readline()
+            if not s:
+                break
+            if progress is not None:
+                progress(s, context)
+            else:
+                if not verbose:
+                    sys.stderr.write('.')
+                else:
+                    sys.stderr.write(s.decode('utf-8'))
+                sys.stderr.flush()
+        stream.close()
+
+    def run_command(self, cmd, **kwargs):
+        p = subprocess.Popen(cmd,
+                             stdout=subprocess.PIPE,
+                             stderr=subprocess.PIPE,
+                             **kwargs)
+        t1 = threading.Thread(target=self.reader, args=(p.stdout, 'stdout'))
+        t1.start()
+        t2 = threading.Thread(target=self.reader, args=(p.stderr, 'stderr'))
+        t2.start()
+        p.wait()
+        t1.join()
+        t2.join()
+        if self.progress is not None:
+            self.progress('done.', 'main')
+        elif self.verbose:
+            sys.stderr.write('done.\n')
+        return p
+
+
+def normalize_name(name):
+    """Normalize a python package name a la PEP 503"""
+    # https://www.python.org/dev/peps/pep-0503/#normalized-names
+    return re.sub('[-_.]+', '-', name).lower()
+
+
+# def _get_pypirc_command():
+# """
+# Get the distutils command for interacting with PyPI configurations.
+# :return: the command.
+# """
+# from distutils.core import Distribution
+# from distutils.config import PyPIRCCommand
+# d = Distribution()
+# return PyPIRCCommand(d)
+
+
+class PyPIRCFile(object):
+
+    DEFAULT_REPOSITORY = 'https://upload.pypi.org/legacy/'
+    DEFAULT_REALM = 'pypi'
+
+    def __init__(self, fn=None, url=None):
+        if fn is None:
+            fn = os.path.join(os.path.expanduser('~'), '.pypirc')
+        self.filename = fn
+        self.url = url
+
+    def read(self):
+        result = {}
+
+        if os.path.exists(self.filename):
+            repository = self.url or self.DEFAULT_REPOSITORY
+
+            config = configparser.RawConfigParser()
+            config.read(self.filename)
+            sections = config.sections()
+            if 'distutils' in sections:
+                # let's get the list of servers
+                index_servers = config.get('distutils', 'index-servers')
+                _servers = [
+                    server.strip() for server in index_servers.split('\n')
+                    if server.strip() != ''
+                ]
+                if _servers == []:
+                    # nothing set, let's try to get the default pypi
+                    if 'pypi' in sections:
+                        _servers = ['pypi']
+                else:
+                    for server in _servers:
+                        result = {'server': server}
+                        result['username'] = config.get(server, 'username')
+
+                        # optional params
+                        for key, default in (('repository',
+                                              self.DEFAULT_REPOSITORY),
+                                             ('realm', self.DEFAULT_REALM),
+                                             ('password', None)):
+                            if config.has_option(server, key):
+                                result[key] = config.get(server, key)
+                            else:
+                                result[key] = default
+
+                        # work around people having "repository" for the "pypi"
+                        # section of their config set to the HTTP (rather than
+                        # HTTPS) URL
+                        if (server == 'pypi' and repository
+                                in (self.DEFAULT_REPOSITORY, 'pypi')):
+                            result['repository'] = self.DEFAULT_REPOSITORY
+                        elif (result['server'] != repository
+                              and result['repository'] != repository):
+                            result = {}
+            elif 'server-login' in sections:
+                # old format
+                server = 'server-login'
+                if config.has_option(server, 'repository'):
+                    repository = config.get(server, 'repository')
+                else:
+                    repository = self.DEFAULT_REPOSITORY
+                result = {
+                    'username': config.get(server, 'username'),
+                    'password': config.get(server, 'password'),
+                    'repository': repository,
+                    'server': server,
+                    'realm': self.DEFAULT_REALM
+                }
+        return result
+
+    def update(self, username, password):
+        # import pdb; pdb.set_trace()
+        config = configparser.RawConfigParser()
+        fn = self.filename
+        config.read(fn)
+        if not config.has_section('pypi'):
+            config.add_section('pypi')
+        config.set('pypi', 'username', username)
+        config.set('pypi', 'password', password)
+        with open(fn, 'w') as f:
+            config.write(f)
+
+
+def _load_pypirc(index):
+    """
+    Read the PyPI access configuration as supported by distutils.
+    """
+    return PyPIRCFile(url=index.url).read()
+
+
+def _store_pypirc(index):
+    PyPIRCFile().update(index.username, index.password)
+
+
+#
+# get_platform()/get_host_platform() copied from Python 3.10.a0 source, with some minor
+# tweaks
+#
+
+
+def get_host_platform():
+    """Return a string that identifies the current platform.  This is used mainly to
+    distinguish platform-specific build directories and platform-specific built
+    distributions.  Typically includes the OS name and version and the
+    architecture (as supplied by 'os.uname()'), although the exact information
+    included depends on the OS; eg. on Linux, the kernel version isn't
+    particularly important.
+
+    Examples of returned values:
+       linux-i586
+       linux-alpha (?)
+       solaris-2.6-sun4u
+
+    Windows will return one of:
+       win-amd64 (64bit Windows on AMD64 (aka x86_64, Intel64, EM64T, etc)
+       win32 (all others - specifically, sys.platform is returned)
+
+    For other non-POSIX platforms, currently just returns 'sys.platform'.
+
+    """
+    if os.name == 'nt':
+        if 'amd64' in sys.version.lower():
+            return 'win-amd64'
+        if '(arm)' in sys.version.lower():
+            return 'win-arm32'
+        if '(arm64)' in sys.version.lower():
+            return 'win-arm64'
+        return sys.platform
+
+    # Set for cross builds explicitly
+    if "_PYTHON_HOST_PLATFORM" in os.environ:
+        return os.environ["_PYTHON_HOST_PLATFORM"]
+
+    if os.name != 'posix' or not hasattr(os, 'uname'):
+        # XXX what about the architecture? NT is Intel or Alpha,
+        # Mac OS is M68k or PPC, etc.
+        return sys.platform
+
+    # Try to distinguish various flavours of Unix
+
+    (osname, host, release, version, machine) = os.uname()
+
+    # Convert the OS name to lowercase, remove '/' characters, and translate
+    # spaces (for "Power Macintosh")
+    osname = osname.lower().replace('/', '')
+    machine = machine.replace(' ', '_').replace('/', '-')
+
+    if osname[:5] == 'linux':
+        # At least on Linux/Intel, 'machine' is the processor --
+        # i386, etc.
+        # XXX what about Alpha, SPARC, etc?
+        return "%s-%s" % (osname, machine)
+
+    elif osname[:5] == 'sunos':
+        if release[0] >= '5':  # SunOS 5 == Solaris 2
+            osname = 'solaris'
+            release = '%d.%s' % (int(release[0]) - 3, release[2:])
+            # We can't use 'platform.architecture()[0]' because a
+            # bootstrap problem. We use a dict to get an error
+            # if some suspicious happens.
+            bitness = {2147483647: '32bit', 9223372036854775807: '64bit'}
+            machine += '.%s' % bitness[sys.maxsize]
+        # fall through to standard osname-release-machine representation
+    elif osname[:3] == 'aix':
+        from _aix_support import aix_platform
+        return aix_platform()
+    elif osname[:6] == 'cygwin':
+        osname = 'cygwin'
+        rel_re = re.compile(r'[\d.]+', re.ASCII)
+        m = rel_re.match(release)
+        if m:
+            release = m.group()
+    elif osname[:6] == 'darwin':
+        import _osx_support
+        try:
+            from distutils import sysconfig
+        except ImportError:
+            import sysconfig
+        osname, release, machine = _osx_support.get_platform_osx(
+            sysconfig.get_config_vars(), osname, release, machine)
+
+    return '%s-%s-%s' % (osname, release, machine)
+
+
+_TARGET_TO_PLAT = {
+    'x86': 'win32',
+    'x64': 'win-amd64',
+    'arm': 'win-arm32',
+}
+
+
+def get_platform():
+    if os.name != 'nt':
+        return get_host_platform()
+    cross_compilation_target = os.environ.get('VSCMD_ARG_TGT_ARCH')
+    if cross_compilation_target not in _TARGET_TO_PLAT:
+        return get_host_platform()
+    return _TARGET_TO_PLAT[cross_compilation_target]
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/distlib/version.py b/venv/lib/python3.12/site-packages/pip/_vendor/distlib/version.py
new file mode 100644
index 00000000..14171ac9
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_vendor/distlib/version.py
@@ -0,0 +1,751 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2012-2023 The Python Software Foundation.
+# See LICENSE.txt and CONTRIBUTORS.txt.
+#
+"""
+Implementation of a flexible versioning scheme providing support for PEP-440,
+setuptools-compatible and semantic versioning.
+"""
+
+import logging
+import re
+
+from .compat import string_types
+from .util import parse_requirement
+
+__all__ = ['NormalizedVersion', 'NormalizedMatcher',
+           'LegacyVersion', 'LegacyMatcher',
+           'SemanticVersion', 'SemanticMatcher',
+           'UnsupportedVersionError', 'get_scheme']
+
+logger = logging.getLogger(__name__)
+
+
+class UnsupportedVersionError(ValueError):
+    """This is an unsupported version."""
+    pass
+
+
+class Version(object):
+    def __init__(self, s):
+        self._string = s = s.strip()
+        self._parts = parts = self.parse(s)
+        assert isinstance(parts, tuple)
+        assert len(parts) > 0
+
+    def parse(self, s):
+        raise NotImplementedError('please implement in a subclass')
+
+    def _check_compatible(self, other):
+        if type(self) != type(other):
+            raise TypeError('cannot compare %r and %r' % (self, other))
+
+    def __eq__(self, other):
+        self._check_compatible(other)
+        return self._parts == other._parts
+
+    def __ne__(self, other):
+        return not self.__eq__(other)
+
+    def __lt__(self, other):
+        self._check_compatible(other)
+        return self._parts < other._parts
+
+    def __gt__(self, other):
+        return not (self.__lt__(other) or self.__eq__(other))
+
+    def __le__(self, other):
+        return self.__lt__(other) or self.__eq__(other)
+
+    def __ge__(self, other):
+        return self.__gt__(other) or self.__eq__(other)
+
+    # See http://docs.python.org/reference/datamodel#object.__hash__
+    def __hash__(self):
+        return hash(self._parts)
+
+    def __repr__(self):
+        return "%s('%s')" % (self.__class__.__name__, self._string)
+
+    def __str__(self):
+        return self._string
+
+    @property
+    def is_prerelease(self):
+        raise NotImplementedError('Please implement in subclasses.')
+
+
+class Matcher(object):
+    version_class = None
+
+    # value is either a callable or the name of a method
+    _operators = {
+        '<': lambda v, c, p: v < c,
+        '>': lambda v, c, p: v > c,
+        '<=': lambda v, c, p: v == c or v < c,
+        '>=': lambda v, c, p: v == c or v > c,
+        '==': lambda v, c, p: v == c,
+        '===': lambda v, c, p: v == c,
+        # by default, compatible => >=.
+        '~=': lambda v, c, p: v == c or v > c,
+        '!=': lambda v, c, p: v != c,
+    }
+
+    # this is a method only to support alternative implementations
+    # via overriding
+    def parse_requirement(self, s):
+        return parse_requirement(s)
+
+    def __init__(self, s):
+        if self.version_class is None:
+            raise ValueError('Please specify a version class')
+        self._string = s = s.strip()
+        r = self.parse_requirement(s)
+        if not r:
+            raise ValueError('Not valid: %r' % s)
+        self.name = r.name
+        self.key = self.name.lower()    # for case-insensitive comparisons
+        clist = []
+        if r.constraints:
+            # import pdb; pdb.set_trace()
+            for op, s in r.constraints:
+                if s.endswith('.*'):
+                    if op not in ('==', '!='):
+                        raise ValueError('\'.*\' not allowed for '
+                                         '%r constraints' % op)
+                    # Could be a partial version (e.g. for '2.*') which
+                    # won't parse as a version, so keep it as a string
+                    vn, prefix = s[:-2], True
+                    # Just to check that vn is a valid version
+                    self.version_class(vn)
+                else:
+                    # Should parse as a version, so we can create an
+                    # instance for the comparison
+                    vn, prefix = self.version_class(s), False
+                clist.append((op, vn, prefix))
+        self._parts = tuple(clist)
+
+    def match(self, version):
+        """
+        Check if the provided version matches the constraints.
+
+        :param version: The version to match against this instance.
+        :type version: String or :class:`Version` instance.
+        """
+        if isinstance(version, string_types):
+            version = self.version_class(version)
+        for operator, constraint, prefix in self._parts:
+            f = self._operators.get(operator)
+            if isinstance(f, string_types):
+                f = getattr(self, f)
+            if not f:
+                msg = ('%r not implemented '
+                       'for %s' % (operator, self.__class__.__name__))
+                raise NotImplementedError(msg)
+            if not f(version, constraint, prefix):
+                return False
+        return True
+
+    @property
+    def exact_version(self):
+        result = None
+        if len(self._parts) == 1 and self._parts[0][0] in ('==', '==='):
+            result = self._parts[0][1]
+        return result
+
+    def _check_compatible(self, other):
+        if type(self) != type(other) or self.name != other.name:
+            raise TypeError('cannot compare %s and %s' % (self, other))
+
+    def __eq__(self, other):
+        self._check_compatible(other)
+        return self.key == other.key and self._parts == other._parts
+
+    def __ne__(self, other):
+        return not self.__eq__(other)
+
+    # See http://docs.python.org/reference/datamodel#object.__hash__
+    def __hash__(self):
+        return hash(self.key) + hash(self._parts)
+
+    def __repr__(self):
+        return "%s(%r)" % (self.__class__.__name__, self._string)
+
+    def __str__(self):
+        return self._string
+
+
+PEP440_VERSION_RE = re.compile(r'^v?(\d+!)?(\d+(\.\d+)*)((a|alpha|b|beta|c|rc|pre|preview)(\d+)?)?'
+                               r'(\.(post|r|rev)(\d+)?)?([._-]?(dev)(\d+)?)?'
+                               r'(\+([a-zA-Z\d]+(\.[a-zA-Z\d]+)?))?$', re.I)
+
+
+def _pep_440_key(s):
+    s = s.strip()
+    m = PEP440_VERSION_RE.match(s)
+    if not m:
+        raise UnsupportedVersionError('Not a valid version: %s' % s)
+    groups = m.groups()
+    nums = tuple(int(v) for v in groups[1].split('.'))
+    while len(nums) > 1 and nums[-1] == 0:
+        nums = nums[:-1]
+
+    if not groups[0]:
+        epoch = 0
+    else:
+        epoch = int(groups[0][:-1])
+    pre = groups[4:6]
+    post = groups[7:9]
+    dev = groups[10:12]
+    local = groups[13]
+    if pre == (None, None):
+        pre = ()
+    else:
+        if pre[1] is None:
+            pre = pre[0], 0
+        else:
+            pre = pre[0], int(pre[1])
+    if post == (None, None):
+        post = ()
+    else:
+        if post[1] is None:
+            post = post[0], 0
+        else:
+            post = post[0], int(post[1])
+    if dev == (None, None):
+        dev = ()
+    else:
+        if dev[1] is None:
+            dev = dev[0], 0
+        else:
+            dev = dev[0], int(dev[1])
+    if local is None:
+        local = ()
+    else:
+        parts = []
+        for part in local.split('.'):
+            # to ensure that numeric compares as > lexicographic, avoid
+            # comparing them directly, but encode a tuple which ensures
+            # correct sorting
+            if part.isdigit():
+                part = (1, int(part))
+            else:
+                part = (0, part)
+            parts.append(part)
+        local = tuple(parts)
+    if not pre:
+        # either before pre-release, or final release and after
+        if not post and dev:
+            # before pre-release
+            pre = ('a', -1)     # to sort before a0
+        else:
+            pre = ('z',)        # to sort after all pre-releases
+    # now look at the state of post and dev.
+    if not post:
+        post = ('_',)   # sort before 'a'
+    if not dev:
+        dev = ('final',)
+
+    return epoch, nums, pre, post, dev, local
+
+
+_normalized_key = _pep_440_key
+
+
+class NormalizedVersion(Version):
+    """A rational version.
+
+    Good:
+        1.2         # equivalent to "1.2.0"
+        1.2.0
+        1.2a1
+        1.2.3a2
+        1.2.3b1
+        1.2.3c1
+        1.2.3.4
+        TODO: fill this out
+
+    Bad:
+        1           # minimum two numbers
+        1.2a        # release level must have a release serial
+        1.2.3b
+    """
+    def parse(self, s):
+        result = _normalized_key(s)
+        # _normalized_key loses trailing zeroes in the release
+        # clause, since that's needed to ensure that X.Y == X.Y.0 == X.Y.0.0
+        # However, PEP 440 prefix matching needs it: for example,
+        # (~= 1.4.5.0) matches differently to (~= 1.4.5.0.0).
+        m = PEP440_VERSION_RE.match(s)      # must succeed
+        groups = m.groups()
+        self._release_clause = tuple(int(v) for v in groups[1].split('.'))
+        return result
+
+    PREREL_TAGS = set(['a', 'b', 'c', 'rc', 'dev'])
+
+    @property
+    def is_prerelease(self):
+        return any(t[0] in self.PREREL_TAGS for t in self._parts if t)
+
+
+def _match_prefix(x, y):
+    x = str(x)
+    y = str(y)
+    if x == y:
+        return True
+    if not x.startswith(y):
+        return False
+    n = len(y)
+    return x[n] == '.'
+
+
+class NormalizedMatcher(Matcher):
+    version_class = NormalizedVersion
+
+    # value is either a callable or the name of a method
+    _operators = {
+        '~=': '_match_compatible',
+        '<': '_match_lt',
+        '>': '_match_gt',
+        '<=': '_match_le',
+        '>=': '_match_ge',
+        '==': '_match_eq',
+        '===': '_match_arbitrary',
+        '!=': '_match_ne',
+    }
+
+    def _adjust_local(self, version, constraint, prefix):
+        if prefix:
+            strip_local = '+' not in constraint and version._parts[-1]
+        else:
+            # both constraint and version are
+            # NormalizedVersion instances.
+            # If constraint does not have a local component,
+            # ensure the version doesn't, either.
+            strip_local = not constraint._parts[-1] and version._parts[-1]
+        if strip_local:
+            s = version._string.split('+', 1)[0]
+            version = self.version_class(s)
+        return version, constraint
+
+    def _match_lt(self, version, constraint, prefix):
+        version, constraint = self._adjust_local(version, constraint, prefix)
+        if version >= constraint:
+            return False
+        release_clause = constraint._release_clause
+        pfx = '.'.join([str(i) for i in release_clause])
+        return not _match_prefix(version, pfx)
+
+    def _match_gt(self, version, constraint, prefix):
+        version, constraint = self._adjust_local(version, constraint, prefix)
+        if version <= constraint:
+            return False
+        release_clause = constraint._release_clause
+        pfx = '.'.join([str(i) for i in release_clause])
+        return not _match_prefix(version, pfx)
+
+    def _match_le(self, version, constraint, prefix):
+        version, constraint = self._adjust_local(version, constraint, prefix)
+        return version <= constraint
+
+    def _match_ge(self, version, constraint, prefix):
+        version, constraint = self._adjust_local(version, constraint, prefix)
+        return version >= constraint
+
+    def _match_eq(self, version, constraint, prefix):
+        version, constraint = self._adjust_local(version, constraint, prefix)
+        if not prefix:
+            result = (version == constraint)
+        else:
+            result = _match_prefix(version, constraint)
+        return result
+
+    def _match_arbitrary(self, version, constraint, prefix):
+        return str(version) == str(constraint)
+
+    def _match_ne(self, version, constraint, prefix):
+        version, constraint = self._adjust_local(version, constraint, prefix)
+        if not prefix:
+            result = (version != constraint)
+        else:
+            result = not _match_prefix(version, constraint)
+        return result
+
+    def _match_compatible(self, version, constraint, prefix):
+        version, constraint = self._adjust_local(version, constraint, prefix)
+        if version == constraint:
+            return True
+        if version < constraint:
+            return False
+#        if not prefix:
+#            return True
+        release_clause = constraint._release_clause
+        if len(release_clause) > 1:
+            release_clause = release_clause[:-1]
+        pfx = '.'.join([str(i) for i in release_clause])
+        return _match_prefix(version, pfx)
+
+
+_REPLACEMENTS = (
+    (re.compile('[.+-]$'), ''),                     # remove trailing puncts
+    (re.compile(r'^[.](\d)'), r'0.\1'),             # .N -> 0.N at start
+    (re.compile('^[.-]'), ''),                      # remove leading puncts
+    (re.compile(r'^\((.*)\)$'), r'\1'),             # remove parentheses
+    (re.compile(r'^v(ersion)?\s*(\d+)'), r'\2'),    # remove leading v(ersion)
+    (re.compile(r'^r(ev)?\s*(\d+)'), r'\2'),        # remove leading v(ersion)
+    (re.compile('[.]{2,}'), '.'),                   # multiple runs of '.'
+    (re.compile(r'\b(alfa|apha)\b'), 'alpha'),      # misspelt alpha
+    (re.compile(r'\b(pre-alpha|prealpha)\b'),
+        'pre.alpha'),                               # standardise
+    (re.compile(r'\(beta\)$'), 'beta'),             # remove parentheses
+)
+
+_SUFFIX_REPLACEMENTS = (
+    (re.compile('^[:~._+-]+'), ''),                   # remove leading puncts
+    (re.compile('[,*")([\\]]'), ''),                  # remove unwanted chars
+    (re.compile('[~:+_ -]'), '.'),                    # replace illegal chars
+    (re.compile('[.]{2,}'), '.'),                   # multiple runs of '.'
+    (re.compile(r'\.$'), ''),                       # trailing '.'
+)
+
+_NUMERIC_PREFIX = re.compile(r'(\d+(\.\d+)*)')
+
+
+def _suggest_semantic_version(s):
+    """
+    Try to suggest a semantic form for a version for which
+    _suggest_normalized_version couldn't come up with anything.
+    """
+    result = s.strip().lower()
+    for pat, repl in _REPLACEMENTS:
+        result = pat.sub(repl, result)
+    if not result:
+        result = '0.0.0'
+
+    # Now look for numeric prefix, and separate it out from
+    # the rest.
+    # import pdb; pdb.set_trace()
+    m = _NUMERIC_PREFIX.match(result)
+    if not m:
+        prefix = '0.0.0'
+        suffix = result
+    else:
+        prefix = m.groups()[0].split('.')
+        prefix = [int(i) for i in prefix]
+        while len(prefix) < 3:
+            prefix.append(0)
+        if len(prefix) == 3:
+            suffix = result[m.end():]
+        else:
+            suffix = '.'.join([str(i) for i in prefix[3:]]) + result[m.end():]
+            prefix = prefix[:3]
+        prefix = '.'.join([str(i) for i in prefix])
+        suffix = suffix.strip()
+    if suffix:
+        # import pdb; pdb.set_trace()
+        # massage the suffix.
+        for pat, repl in _SUFFIX_REPLACEMENTS:
+            suffix = pat.sub(repl, suffix)
+
+    if not suffix:
+        result = prefix
+    else:
+        sep = '-' if 'dev' in suffix else '+'
+        result = prefix + sep + suffix
+    if not is_semver(result):
+        result = None
+    return result
+
+
+def _suggest_normalized_version(s):
+    """Suggest a normalized version close to the given version string.
+
+    If you have a version string that isn't rational (i.e. NormalizedVersion
+    doesn't like it) then you might be able to get an equivalent (or close)
+    rational version from this function.
+
+    This does a number of simple normalizations to the given string, based
+    on observation of versions currently in use on PyPI. Given a dump of
+    those version during PyCon 2009, 4287 of them:
+    - 2312 (53.93%) match NormalizedVersion without change
+      with the automatic suggestion
+    - 3474 (81.04%) match when using this suggestion method
+
+    @param s {str} An irrational version string.
+    @returns A rational version string, or None, if couldn't determine one.
+    """
+    try:
+        _normalized_key(s)
+        return s   # already rational
+    except UnsupportedVersionError:
+        pass
+
+    rs = s.lower()
+
+    # part of this could use maketrans
+    for orig, repl in (('-alpha', 'a'), ('-beta', 'b'), ('alpha', 'a'),
+                       ('beta', 'b'), ('rc', 'c'), ('-final', ''),
+                       ('-pre', 'c'),
+                       ('-release', ''), ('.release', ''), ('-stable', ''),
+                       ('+', '.'), ('_', '.'), (' ', ''), ('.final', ''),
+                       ('final', '')):
+        rs = rs.replace(orig, repl)
+
+    # if something ends with dev or pre, we add a 0
+    rs = re.sub(r"pre$", r"pre0", rs)
+    rs = re.sub(r"dev$", r"dev0", rs)
+
+    # if we have something like "b-2" or "a.2" at the end of the
+    # version, that is probably beta, alpha, etc
+    # let's remove the dash or dot
+    rs = re.sub(r"([abc]|rc)[\-\.](\d+)$", r"\1\2", rs)
+
+    # 1.0-dev-r371 -> 1.0.dev371
+    # 0.1-dev-r79 -> 0.1.dev79
+    rs = re.sub(r"[\-\.](dev)[\-\.]?r?(\d+)$", r".\1\2", rs)
+
+    # Clean: 2.0.a.3, 2.0.b1, 0.9.0~c1
+    rs = re.sub(r"[.~]?([abc])\.?", r"\1", rs)
+
+    # Clean: v0.3, v1.0
+    if rs.startswith('v'):
+        rs = rs[1:]
+
+    # Clean leading '0's on numbers.
+    # TODO: unintended side-effect on, e.g., "2003.05.09"
+    # PyPI stats: 77 (~2%) better
+    rs = re.sub(r"\b0+(\d+)(?!\d)", r"\1", rs)
+
+    # Clean a/b/c with no version. E.g. "1.0a" -> "1.0a0". Setuptools infers
+    # zero.
+    # PyPI stats: 245 (7.56%) better
+    rs = re.sub(r"(\d+[abc])$", r"\g<1>0", rs)
+
+    # the 'dev-rNNN' tag is a dev tag
+    rs = re.sub(r"\.?(dev-r|dev\.r)\.?(\d+)$", r".dev\2", rs)
+
+    # clean the - when used as a pre delimiter
+    rs = re.sub(r"-(a|b|c)(\d+)$", r"\1\2", rs)
+
+    # a terminal "dev" or "devel" can be changed into ".dev0"
+    rs = re.sub(r"[\.\-](dev|devel)$", r".dev0", rs)
+
+    # a terminal "dev" can be changed into ".dev0"
+    rs = re.sub(r"(?![\.\-])dev$", r".dev0", rs)
+
+    # a terminal "final" or "stable" can be removed
+    rs = re.sub(r"(final|stable)$", "", rs)
+
+    # The 'r' and the '-' tags are post release tags
+    #   0.4a1.r10       ->  0.4a1.post10
+    #   0.9.33-17222    ->  0.9.33.post17222
+    #   0.9.33-r17222   ->  0.9.33.post17222
+    rs = re.sub(r"\.?(r|-|-r)\.?(\d+)$", r".post\2", rs)
+
+    # Clean 'r' instead of 'dev' usage:
+    #   0.9.33+r17222   ->  0.9.33.dev17222
+    #   1.0dev123       ->  1.0.dev123
+    #   1.0.git123      ->  1.0.dev123
+    #   1.0.bzr123      ->  1.0.dev123
+    #   0.1a0dev.123    ->  0.1a0.dev123
+    # PyPI stats:  ~150 (~4%) better
+    rs = re.sub(r"\.?(dev|git|bzr)\.?(\d+)$", r".dev\2", rs)
+
+    # Clean '.pre' (normalized from '-pre' above) instead of 'c' usage:
+    #   0.2.pre1        ->  0.2c1
+    #   0.2-c1         ->  0.2c1
+    #   1.0preview123   ->  1.0c123
+    # PyPI stats: ~21 (0.62%) better
+    rs = re.sub(r"\.?(pre|preview|-c)(\d+)$", r"c\g<2>", rs)
+
+    # Tcl/Tk uses "px" for their post release markers
+    rs = re.sub(r"p(\d+)$", r".post\1", rs)
+
+    try:
+        _normalized_key(rs)
+    except UnsupportedVersionError:
+        rs = None
+    return rs
+
+#
+#   Legacy version processing (distribute-compatible)
+#
+
+
+_VERSION_PART = re.compile(r'([a-z]+|\d+|[\.-])', re.I)
+_VERSION_REPLACE = {
+    'pre': 'c',
+    'preview': 'c',
+    '-': 'final-',
+    'rc': 'c',
+    'dev': '@',
+    '': None,
+    '.': None,
+}
+
+
+def _legacy_key(s):
+    def get_parts(s):
+        result = []
+        for p in _VERSION_PART.split(s.lower()):
+            p = _VERSION_REPLACE.get(p, p)
+            if p:
+                if '0' <= p[:1] <= '9':
+                    p = p.zfill(8)
+                else:
+                    p = '*' + p
+                result.append(p)
+        result.append('*final')
+        return result
+
+    result = []
+    for p in get_parts(s):
+        if p.startswith('*'):
+            if p < '*final':
+                while result and result[-1] == '*final-':
+                    result.pop()
+            while result and result[-1] == '00000000':
+                result.pop()
+        result.append(p)
+    return tuple(result)
+
+
+class LegacyVersion(Version):
+    def parse(self, s):
+        return _legacy_key(s)
+
+    @property
+    def is_prerelease(self):
+        result = False
+        for x in self._parts:
+            if (isinstance(x, string_types) and x.startswith('*') and
+                    x < '*final'):
+                result = True
+                break
+        return result
+
+
+class LegacyMatcher(Matcher):
+    version_class = LegacyVersion
+
+    _operators = dict(Matcher._operators)
+    _operators['~='] = '_match_compatible'
+
+    numeric_re = re.compile(r'^(\d+(\.\d+)*)')
+
+    def _match_compatible(self, version, constraint, prefix):
+        if version < constraint:
+            return False
+        m = self.numeric_re.match(str(constraint))
+        if not m:
+            logger.warning('Cannot compute compatible match for version %s '
+                           ' and constraint %s', version, constraint)
+            return True
+        s = m.groups()[0]
+        if '.' in s:
+            s = s.rsplit('.', 1)[0]
+        return _match_prefix(version, s)
+
+#
+#   Semantic versioning
+#
+
+
+_SEMVER_RE = re.compile(r'^(\d+)\.(\d+)\.(\d+)'
+                        r'(-[a-z0-9]+(\.[a-z0-9-]+)*)?'
+                        r'(\+[a-z0-9]+(\.[a-z0-9-]+)*)?$', re.I)
+
+
+def is_semver(s):
+    return _SEMVER_RE.match(s)
+
+
+def _semantic_key(s):
+    def make_tuple(s, absent):
+        if s is None:
+            result = (absent,)
+        else:
+            parts = s[1:].split('.')
+            # We can't compare ints and strings on Python 3, so fudge it
+            # by zero-filling numeric values so simulate a numeric comparison
+            result = tuple([p.zfill(8) if p.isdigit() else p for p in parts])
+        return result
+
+    m = is_semver(s)
+    if not m:
+        raise UnsupportedVersionError(s)
+    groups = m.groups()
+    major, minor, patch = [int(i) for i in groups[:3]]
+    # choose the '|' and '*' so that versions sort correctly
+    pre, build = make_tuple(groups[3], '|'), make_tuple(groups[5], '*')
+    return (major, minor, patch), pre, build
+
+
+class SemanticVersion(Version):
+    def parse(self, s):
+        return _semantic_key(s)
+
+    @property
+    def is_prerelease(self):
+        return self._parts[1][0] != '|'
+
+
+class SemanticMatcher(Matcher):
+    version_class = SemanticVersion
+
+
+class VersionScheme(object):
+    def __init__(self, key, matcher, suggester=None):
+        self.key = key
+        self.matcher = matcher
+        self.suggester = suggester
+
+    def is_valid_version(self, s):
+        try:
+            self.matcher.version_class(s)
+            result = True
+        except UnsupportedVersionError:
+            result = False
+        return result
+
+    def is_valid_matcher(self, s):
+        try:
+            self.matcher(s)
+            result = True
+        except UnsupportedVersionError:
+            result = False
+        return result
+
+    def is_valid_constraint_list(self, s):
+        """
+        Used for processing some metadata fields
+        """
+        # See issue #140. Be tolerant of a single trailing comma.
+        if s.endswith(','):
+            s = s[:-1]
+        return self.is_valid_matcher('dummy_name (%s)' % s)
+
+    def suggest(self, s):
+        if self.suggester is None:
+            result = None
+        else:
+            result = self.suggester(s)
+        return result
+
+
+_SCHEMES = {
+    'normalized': VersionScheme(_normalized_key, NormalizedMatcher,
+                                _suggest_normalized_version),
+    'legacy': VersionScheme(_legacy_key, LegacyMatcher, lambda self, s: s),
+    'semantic': VersionScheme(_semantic_key, SemanticMatcher,
+                              _suggest_semantic_version),
+}
+
+_SCHEMES['default'] = _SCHEMES['normalized']
+
+
+def get_scheme(name):
+    if name not in _SCHEMES:
+        raise ValueError('unknown scheme name: %r' % name)
+    return _SCHEMES[name]
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/distlib/w32.exe b/venv/lib/python3.12/site-packages/pip/_vendor/distlib/w32.exe
new file mode 100644
index 00000000..4ee2d3a3
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_vendor/distlib/w32.exe differ
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/distlib/w64-arm.exe b/venv/lib/python3.12/site-packages/pip/_vendor/distlib/w64-arm.exe
new file mode 100644
index 00000000..951d5817
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_vendor/distlib/w64-arm.exe differ
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/distlib/w64.exe b/venv/lib/python3.12/site-packages/pip/_vendor/distlib/w64.exe
new file mode 100644
index 00000000..5763076d
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_vendor/distlib/w64.exe differ
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/distlib/wheel.py b/venv/lib/python3.12/site-packages/pip/_vendor/distlib/wheel.py
new file mode 100644
index 00000000..4a5a30e1
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_vendor/distlib/wheel.py
@@ -0,0 +1,1099 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2013-2023 Vinay Sajip.
+# Licensed to the Python Software Foundation under a contributor agreement.
+# See LICENSE.txt and CONTRIBUTORS.txt.
+#
+from __future__ import unicode_literals
+
+import base64
+import codecs
+import datetime
+from email import message_from_file
+import hashlib
+import json
+import logging
+import os
+import posixpath
+import re
+import shutil
+import sys
+import tempfile
+import zipfile
+
+from . import __version__, DistlibException
+from .compat import sysconfig, ZipFile, fsdecode, text_type, filter
+from .database import InstalledDistribution
+from .metadata import Metadata, WHEEL_METADATA_FILENAME, LEGACY_METADATA_FILENAME
+from .util import (FileOperator, convert_path, CSVReader, CSVWriter, Cache,
+                   cached_property, get_cache_base, read_exports, tempdir,
+                   get_platform)
+from .version import NormalizedVersion, UnsupportedVersionError
+
+logger = logging.getLogger(__name__)
+
+cache = None  # created when needed
+
+if hasattr(sys, 'pypy_version_info'):  # pragma: no cover
+    IMP_PREFIX = 'pp'
+elif sys.platform.startswith('java'):  # pragma: no cover
+    IMP_PREFIX = 'jy'
+elif sys.platform == 'cli':  # pragma: no cover
+    IMP_PREFIX = 'ip'
+else:
+    IMP_PREFIX = 'cp'
+
+VER_SUFFIX = sysconfig.get_config_var('py_version_nodot')
+if not VER_SUFFIX:  # pragma: no cover
+    VER_SUFFIX = '%s%s' % sys.version_info[:2]
+PYVER = 'py' + VER_SUFFIX
+IMPVER = IMP_PREFIX + VER_SUFFIX
+
+ARCH = get_platform().replace('-', '_').replace('.', '_')
+
+ABI = sysconfig.get_config_var('SOABI')
+if ABI and ABI.startswith('cpython-'):
+    ABI = ABI.replace('cpython-', 'cp').split('-')[0]
+else:
+
+    def _derive_abi():
+        parts = ['cp', VER_SUFFIX]
+        if sysconfig.get_config_var('Py_DEBUG'):
+            parts.append('d')
+        if IMP_PREFIX == 'cp':
+            vi = sys.version_info[:2]
+            if vi < (3, 8):
+                wpm = sysconfig.get_config_var('WITH_PYMALLOC')
+                if wpm is None:
+                    wpm = True
+                if wpm:
+                    parts.append('m')
+                if vi < (3, 3):
+                    us = sysconfig.get_config_var('Py_UNICODE_SIZE')
+                    if us == 4 or (us is None and sys.maxunicode == 0x10FFFF):
+                        parts.append('u')
+        return ''.join(parts)
+
+    ABI = _derive_abi()
+    del _derive_abi
+
+FILENAME_RE = re.compile(
+    r'''
+(?P[^-]+)
+-(?P\d+[^-]*)
+(-(?P\d+[^-]*))?
+-(?P\w+\d+(\.\w+\d+)*)
+-(?P\w+)
+-(?P\w+(\.\w+)*)
+\.whl$
+''', re.IGNORECASE | re.VERBOSE)
+
+NAME_VERSION_RE = re.compile(
+    r'''
+(?P[^-]+)
+-(?P\d+[^-]*)
+(-(?P\d+[^-]*))?$
+''', re.IGNORECASE | re.VERBOSE)
+
+SHEBANG_RE = re.compile(br'\s*#![^\r\n]*')
+SHEBANG_DETAIL_RE = re.compile(br'^(\s*#!("[^"]+"|\S+))\s+(.*)$')
+SHEBANG_PYTHON = b'#!python'
+SHEBANG_PYTHONW = b'#!pythonw'
+
+if os.sep == '/':
+    to_posix = lambda o: o
+else:
+    to_posix = lambda o: o.replace(os.sep, '/')
+
+if sys.version_info[0] < 3:
+    import imp
+else:
+    imp = None
+    import importlib.machinery
+    import importlib.util
+
+
+def _get_suffixes():
+    if imp:
+        return [s[0] for s in imp.get_suffixes()]
+    else:
+        return importlib.machinery.EXTENSION_SUFFIXES
+
+
+def _load_dynamic(name, path):
+    # https://docs.python.org/3/library/importlib.html#importing-a-source-file-directly
+    if imp:
+        return imp.load_dynamic(name, path)
+    else:
+        spec = importlib.util.spec_from_file_location(name, path)
+        module = importlib.util.module_from_spec(spec)
+        sys.modules[name] = module
+        spec.loader.exec_module(module)
+        return module
+
+
+class Mounter(object):
+
+    def __init__(self):
+        self.impure_wheels = {}
+        self.libs = {}
+
+    def add(self, pathname, extensions):
+        self.impure_wheels[pathname] = extensions
+        self.libs.update(extensions)
+
+    def remove(self, pathname):
+        extensions = self.impure_wheels.pop(pathname)
+        for k, v in extensions:
+            if k in self.libs:
+                del self.libs[k]
+
+    def find_module(self, fullname, path=None):
+        if fullname in self.libs:
+            result = self
+        else:
+            result = None
+        return result
+
+    def load_module(self, fullname):
+        if fullname in sys.modules:
+            result = sys.modules[fullname]
+        else:
+            if fullname not in self.libs:
+                raise ImportError('unable to find extension for %s' % fullname)
+            result = _load_dynamic(fullname, self.libs[fullname])
+            result.__loader__ = self
+            parts = fullname.rsplit('.', 1)
+            if len(parts) > 1:
+                result.__package__ = parts[0]
+        return result
+
+
+_hook = Mounter()
+
+
+class Wheel(object):
+    """
+    Class to build and install from Wheel files (PEP 427).
+    """
+
+    wheel_version = (1, 1)
+    hash_kind = 'sha256'
+
+    def __init__(self, filename=None, sign=False, verify=False):
+        """
+        Initialise an instance using a (valid) filename.
+        """
+        self.sign = sign
+        self.should_verify = verify
+        self.buildver = ''
+        self.pyver = [PYVER]
+        self.abi = ['none']
+        self.arch = ['any']
+        self.dirname = os.getcwd()
+        if filename is None:
+            self.name = 'dummy'
+            self.version = '0.1'
+            self._filename = self.filename
+        else:
+            m = NAME_VERSION_RE.match(filename)
+            if m:
+                info = m.groupdict('')
+                self.name = info['nm']
+                # Reinstate the local version separator
+                self.version = info['vn'].replace('_', '-')
+                self.buildver = info['bn']
+                self._filename = self.filename
+            else:
+                dirname, filename = os.path.split(filename)
+                m = FILENAME_RE.match(filename)
+                if not m:
+                    raise DistlibException('Invalid name or '
+                                           'filename: %r' % filename)
+                if dirname:
+                    self.dirname = os.path.abspath(dirname)
+                self._filename = filename
+                info = m.groupdict('')
+                self.name = info['nm']
+                self.version = info['vn']
+                self.buildver = info['bn']
+                self.pyver = info['py'].split('.')
+                self.abi = info['bi'].split('.')
+                self.arch = info['ar'].split('.')
+
+    @property
+    def filename(self):
+        """
+        Build and return a filename from the various components.
+        """
+        if self.buildver:
+            buildver = '-' + self.buildver
+        else:
+            buildver = ''
+        pyver = '.'.join(self.pyver)
+        abi = '.'.join(self.abi)
+        arch = '.'.join(self.arch)
+        # replace - with _ as a local version separator
+        version = self.version.replace('-', '_')
+        return '%s-%s%s-%s-%s-%s.whl' % (self.name, version, buildver, pyver,
+                                         abi, arch)
+
+    @property
+    def exists(self):
+        path = os.path.join(self.dirname, self.filename)
+        return os.path.isfile(path)
+
+    @property
+    def tags(self):
+        for pyver in self.pyver:
+            for abi in self.abi:
+                for arch in self.arch:
+                    yield pyver, abi, arch
+
+    @cached_property
+    def metadata(self):
+        pathname = os.path.join(self.dirname, self.filename)
+        name_ver = '%s-%s' % (self.name, self.version)
+        info_dir = '%s.dist-info' % name_ver
+        wrapper = codecs.getreader('utf-8')
+        with ZipFile(pathname, 'r') as zf:
+            self.get_wheel_metadata(zf)
+            # wv = wheel_metadata['Wheel-Version'].split('.', 1)
+            # file_version = tuple([int(i) for i in wv])
+            # if file_version < (1, 1):
+            # fns = [WHEEL_METADATA_FILENAME, METADATA_FILENAME,
+            # LEGACY_METADATA_FILENAME]
+            # else:
+            # fns = [WHEEL_METADATA_FILENAME, METADATA_FILENAME]
+            fns = [WHEEL_METADATA_FILENAME, LEGACY_METADATA_FILENAME]
+            result = None
+            for fn in fns:
+                try:
+                    metadata_filename = posixpath.join(info_dir, fn)
+                    with zf.open(metadata_filename) as bf:
+                        wf = wrapper(bf)
+                        result = Metadata(fileobj=wf)
+                        if result:
+                            break
+                except KeyError:
+                    pass
+            if not result:
+                raise ValueError('Invalid wheel, because metadata is '
+                                 'missing: looked in %s' % ', '.join(fns))
+        return result
+
+    def get_wheel_metadata(self, zf):
+        name_ver = '%s-%s' % (self.name, self.version)
+        info_dir = '%s.dist-info' % name_ver
+        metadata_filename = posixpath.join(info_dir, 'WHEEL')
+        with zf.open(metadata_filename) as bf:
+            wf = codecs.getreader('utf-8')(bf)
+            message = message_from_file(wf)
+        return dict(message)
+
+    @cached_property
+    def info(self):
+        pathname = os.path.join(self.dirname, self.filename)
+        with ZipFile(pathname, 'r') as zf:
+            result = self.get_wheel_metadata(zf)
+        return result
+
+    def process_shebang(self, data):
+        m = SHEBANG_RE.match(data)
+        if m:
+            end = m.end()
+            shebang, data_after_shebang = data[:end], data[end:]
+            # Preserve any arguments after the interpreter
+            if b'pythonw' in shebang.lower():
+                shebang_python = SHEBANG_PYTHONW
+            else:
+                shebang_python = SHEBANG_PYTHON
+            m = SHEBANG_DETAIL_RE.match(shebang)
+            if m:
+                args = b' ' + m.groups()[-1]
+            else:
+                args = b''
+            shebang = shebang_python + args
+            data = shebang + data_after_shebang
+        else:
+            cr = data.find(b'\r')
+            lf = data.find(b'\n')
+            if cr < 0 or cr > lf:
+                term = b'\n'
+            else:
+                if data[cr:cr + 2] == b'\r\n':
+                    term = b'\r\n'
+                else:
+                    term = b'\r'
+            data = SHEBANG_PYTHON + term + data
+        return data
+
+    def get_hash(self, data, hash_kind=None):
+        if hash_kind is None:
+            hash_kind = self.hash_kind
+        try:
+            hasher = getattr(hashlib, hash_kind)
+        except AttributeError:
+            raise DistlibException('Unsupported hash algorithm: %r' %
+                                   hash_kind)
+        result = hasher(data).digest()
+        result = base64.urlsafe_b64encode(result).rstrip(b'=').decode('ascii')
+        return hash_kind, result
+
+    def write_record(self, records, record_path, archive_record_path):
+        records = list(records)  # make a copy, as mutated
+        records.append((archive_record_path, '', ''))
+        with CSVWriter(record_path) as writer:
+            for row in records:
+                writer.writerow(row)
+
+    def write_records(self, info, libdir, archive_paths):
+        records = []
+        distinfo, info_dir = info
+        # hasher = getattr(hashlib, self.hash_kind)
+        for ap, p in archive_paths:
+            with open(p, 'rb') as f:
+                data = f.read()
+            digest = '%s=%s' % self.get_hash(data)
+            size = os.path.getsize(p)
+            records.append((ap, digest, size))
+
+        p = os.path.join(distinfo, 'RECORD')
+        ap = to_posix(os.path.join(info_dir, 'RECORD'))
+        self.write_record(records, p, ap)
+        archive_paths.append((ap, p))
+
+    def build_zip(self, pathname, archive_paths):
+        with ZipFile(pathname, 'w', zipfile.ZIP_DEFLATED) as zf:
+            for ap, p in archive_paths:
+                logger.debug('Wrote %s to %s in wheel', p, ap)
+                zf.write(p, ap)
+
+    def build(self, paths, tags=None, wheel_version=None):
+        """
+        Build a wheel from files in specified paths, and use any specified tags
+        when determining the name of the wheel.
+        """
+        if tags is None:
+            tags = {}
+
+        libkey = list(filter(lambda o: o in paths, ('purelib', 'platlib')))[0]
+        if libkey == 'platlib':
+            is_pure = 'false'
+            default_pyver = [IMPVER]
+            default_abi = [ABI]
+            default_arch = [ARCH]
+        else:
+            is_pure = 'true'
+            default_pyver = [PYVER]
+            default_abi = ['none']
+            default_arch = ['any']
+
+        self.pyver = tags.get('pyver', default_pyver)
+        self.abi = tags.get('abi', default_abi)
+        self.arch = tags.get('arch', default_arch)
+
+        libdir = paths[libkey]
+
+        name_ver = '%s-%s' % (self.name, self.version)
+        data_dir = '%s.data' % name_ver
+        info_dir = '%s.dist-info' % name_ver
+
+        archive_paths = []
+
+        # First, stuff which is not in site-packages
+        for key in ('data', 'headers', 'scripts'):
+            if key not in paths:
+                continue
+            path = paths[key]
+            if os.path.isdir(path):
+                for root, dirs, files in os.walk(path):
+                    for fn in files:
+                        p = fsdecode(os.path.join(root, fn))
+                        rp = os.path.relpath(p, path)
+                        ap = to_posix(os.path.join(data_dir, key, rp))
+                        archive_paths.append((ap, p))
+                        if key == 'scripts' and not p.endswith('.exe'):
+                            with open(p, 'rb') as f:
+                                data = f.read()
+                            data = self.process_shebang(data)
+                            with open(p, 'wb') as f:
+                                f.write(data)
+
+        # Now, stuff which is in site-packages, other than the
+        # distinfo stuff.
+        path = libdir
+        distinfo = None
+        for root, dirs, files in os.walk(path):
+            if root == path:
+                # At the top level only, save distinfo for later
+                # and skip it for now
+                for i, dn in enumerate(dirs):
+                    dn = fsdecode(dn)
+                    if dn.endswith('.dist-info'):
+                        distinfo = os.path.join(root, dn)
+                        del dirs[i]
+                        break
+                assert distinfo, '.dist-info directory expected, not found'
+
+            for fn in files:
+                # comment out next suite to leave .pyc files in
+                if fsdecode(fn).endswith(('.pyc', '.pyo')):
+                    continue
+                p = os.path.join(root, fn)
+                rp = to_posix(os.path.relpath(p, path))
+                archive_paths.append((rp, p))
+
+        # Now distinfo. Assumed to be flat, i.e. os.listdir is enough.
+        files = os.listdir(distinfo)
+        for fn in files:
+            if fn not in ('RECORD', 'INSTALLER', 'SHARED', 'WHEEL'):
+                p = fsdecode(os.path.join(distinfo, fn))
+                ap = to_posix(os.path.join(info_dir, fn))
+                archive_paths.append((ap, p))
+
+        wheel_metadata = [
+            'Wheel-Version: %d.%d' % (wheel_version or self.wheel_version),
+            'Generator: distlib %s' % __version__,
+            'Root-Is-Purelib: %s' % is_pure,
+        ]
+        for pyver, abi, arch in self.tags:
+            wheel_metadata.append('Tag: %s-%s-%s' % (pyver, abi, arch))
+        p = os.path.join(distinfo, 'WHEEL')
+        with open(p, 'w') as f:
+            f.write('\n'.join(wheel_metadata))
+        ap = to_posix(os.path.join(info_dir, 'WHEEL'))
+        archive_paths.append((ap, p))
+
+        # sort the entries by archive path. Not needed by any spec, but it
+        # keeps the archive listing and RECORD tidier than they would otherwise
+        # be. Use the number of path segments to keep directory entries together,
+        # and keep the dist-info stuff at the end.
+        def sorter(t):
+            ap = t[0]
+            n = ap.count('/')
+            if '.dist-info' in ap:
+                n += 10000
+            return (n, ap)
+
+        archive_paths = sorted(archive_paths, key=sorter)
+
+        # Now, at last, RECORD.
+        # Paths in here are archive paths - nothing else makes sense.
+        self.write_records((distinfo, info_dir), libdir, archive_paths)
+        # Now, ready to build the zip file
+        pathname = os.path.join(self.dirname, self.filename)
+        self.build_zip(pathname, archive_paths)
+        return pathname
+
+    def skip_entry(self, arcname):
+        """
+        Determine whether an archive entry should be skipped when verifying
+        or installing.
+        """
+        # The signature file won't be in RECORD,
+        # and we  don't currently don't do anything with it
+        # We also skip directories, as they won't be in RECORD
+        # either. See:
+        #
+        # https://github.com/pypa/wheel/issues/294
+        # https://github.com/pypa/wheel/issues/287
+        # https://github.com/pypa/wheel/pull/289
+        #
+        return arcname.endswith(('/', '/RECORD.jws'))
+
+    def install(self, paths, maker, **kwargs):
+        """
+        Install a wheel to the specified paths. If kwarg ``warner`` is
+        specified, it should be a callable, which will be called with two
+        tuples indicating the wheel version of this software and the wheel
+        version in the file, if there is a discrepancy in the versions.
+        This can be used to issue any warnings to raise any exceptions.
+        If kwarg ``lib_only`` is True, only the purelib/platlib files are
+        installed, and the headers, scripts, data and dist-info metadata are
+        not written. If kwarg ``bytecode_hashed_invalidation`` is True, written
+        bytecode will try to use file-hash based invalidation (PEP-552) on
+        supported interpreter versions (CPython 2.7+).
+
+        The return value is a :class:`InstalledDistribution` instance unless
+        ``options.lib_only`` is True, in which case the return value is ``None``.
+        """
+
+        dry_run = maker.dry_run
+        warner = kwargs.get('warner')
+        lib_only = kwargs.get('lib_only', False)
+        bc_hashed_invalidation = kwargs.get('bytecode_hashed_invalidation',
+                                            False)
+
+        pathname = os.path.join(self.dirname, self.filename)
+        name_ver = '%s-%s' % (self.name, self.version)
+        data_dir = '%s.data' % name_ver
+        info_dir = '%s.dist-info' % name_ver
+
+        metadata_name = posixpath.join(info_dir, LEGACY_METADATA_FILENAME)
+        wheel_metadata_name = posixpath.join(info_dir, 'WHEEL')
+        record_name = posixpath.join(info_dir, 'RECORD')
+
+        wrapper = codecs.getreader('utf-8')
+
+        with ZipFile(pathname, 'r') as zf:
+            with zf.open(wheel_metadata_name) as bwf:
+                wf = wrapper(bwf)
+                message = message_from_file(wf)
+            wv = message['Wheel-Version'].split('.', 1)
+            file_version = tuple([int(i) for i in wv])
+            if (file_version != self.wheel_version) and warner:
+                warner(self.wheel_version, file_version)
+
+            if message['Root-Is-Purelib'] == 'true':
+                libdir = paths['purelib']
+            else:
+                libdir = paths['platlib']
+
+            records = {}
+            with zf.open(record_name) as bf:
+                with CSVReader(stream=bf) as reader:
+                    for row in reader:
+                        p = row[0]
+                        records[p] = row
+
+            data_pfx = posixpath.join(data_dir, '')
+            info_pfx = posixpath.join(info_dir, '')
+            script_pfx = posixpath.join(data_dir, 'scripts', '')
+
+            # make a new instance rather than a copy of maker's,
+            # as we mutate it
+            fileop = FileOperator(dry_run=dry_run)
+            fileop.record = True  # so we can rollback if needed
+
+            bc = not sys.dont_write_bytecode  # Double negatives. Lovely!
+
+            outfiles = []  # for RECORD writing
+
+            # for script copying/shebang processing
+            workdir = tempfile.mkdtemp()
+            # set target dir later
+            # we default add_launchers to False, as the
+            # Python Launcher should be used instead
+            maker.source_dir = workdir
+            maker.target_dir = None
+            try:
+                for zinfo in zf.infolist():
+                    arcname = zinfo.filename
+                    if isinstance(arcname, text_type):
+                        u_arcname = arcname
+                    else:
+                        u_arcname = arcname.decode('utf-8')
+                    if self.skip_entry(u_arcname):
+                        continue
+                    row = records[u_arcname]
+                    if row[2] and str(zinfo.file_size) != row[2]:
+                        raise DistlibException('size mismatch for '
+                                               '%s' % u_arcname)
+                    if row[1]:
+                        kind, value = row[1].split('=', 1)
+                        with zf.open(arcname) as bf:
+                            data = bf.read()
+                        _, digest = self.get_hash(data, kind)
+                        if digest != value:
+                            raise DistlibException('digest mismatch for '
+                                                   '%s' % arcname)
+
+                    if lib_only and u_arcname.startswith((info_pfx, data_pfx)):
+                        logger.debug('lib_only: skipping %s', u_arcname)
+                        continue
+                    is_script = (u_arcname.startswith(script_pfx)
+                                 and not u_arcname.endswith('.exe'))
+
+                    if u_arcname.startswith(data_pfx):
+                        _, where, rp = u_arcname.split('/', 2)
+                        outfile = os.path.join(paths[where], convert_path(rp))
+                    else:
+                        # meant for site-packages.
+                        if u_arcname in (wheel_metadata_name, record_name):
+                            continue
+                        outfile = os.path.join(libdir, convert_path(u_arcname))
+                    if not is_script:
+                        with zf.open(arcname) as bf:
+                            fileop.copy_stream(bf, outfile)
+                        # Issue #147: permission bits aren't preserved. Using
+                        # zf.extract(zinfo, libdir) should have worked, but didn't,
+                        # see https://www.thetopsites.net/article/53834422.shtml
+                        # So ... manually preserve permission bits as given in zinfo
+                        if os.name == 'posix':
+                            # just set the normal permission bits
+                            os.chmod(outfile,
+                                     (zinfo.external_attr >> 16) & 0x1FF)
+                        outfiles.append(outfile)
+                        # Double check the digest of the written file
+                        if not dry_run and row[1]:
+                            with open(outfile, 'rb') as bf:
+                                data = bf.read()
+                                _, newdigest = self.get_hash(data, kind)
+                                if newdigest != digest:
+                                    raise DistlibException('digest mismatch '
+                                                           'on write for '
+                                                           '%s' % outfile)
+                        if bc and outfile.endswith('.py'):
+                            try:
+                                pyc = fileop.byte_compile(
+                                    outfile,
+                                    hashed_invalidation=bc_hashed_invalidation)
+                                outfiles.append(pyc)
+                            except Exception:
+                                # Don't give up if byte-compilation fails,
+                                # but log it and perhaps warn the user
+                                logger.warning('Byte-compilation failed',
+                                               exc_info=True)
+                    else:
+                        fn = os.path.basename(convert_path(arcname))
+                        workname = os.path.join(workdir, fn)
+                        with zf.open(arcname) as bf:
+                            fileop.copy_stream(bf, workname)
+
+                        dn, fn = os.path.split(outfile)
+                        maker.target_dir = dn
+                        filenames = maker.make(fn)
+                        fileop.set_executable_mode(filenames)
+                        outfiles.extend(filenames)
+
+                if lib_only:
+                    logger.debug('lib_only: returning None')
+                    dist = None
+                else:
+                    # Generate scripts
+
+                    # Try to get pydist.json so we can see if there are
+                    # any commands to generate. If this fails (e.g. because
+                    # of a legacy wheel), log a warning but don't give up.
+                    commands = None
+                    file_version = self.info['Wheel-Version']
+                    if file_version == '1.0':
+                        # Use legacy info
+                        ep = posixpath.join(info_dir, 'entry_points.txt')
+                        try:
+                            with zf.open(ep) as bwf:
+                                epdata = read_exports(bwf)
+                            commands = {}
+                            for key in ('console', 'gui'):
+                                k = '%s_scripts' % key
+                                if k in epdata:
+                                    commands['wrap_%s' % key] = d = {}
+                                    for v in epdata[k].values():
+                                        s = '%s:%s' % (v.prefix, v.suffix)
+                                        if v.flags:
+                                            s += ' [%s]' % ','.join(v.flags)
+                                        d[v.name] = s
+                        except Exception:
+                            logger.warning('Unable to read legacy script '
+                                           'metadata, so cannot generate '
+                                           'scripts')
+                    else:
+                        try:
+                            with zf.open(metadata_name) as bwf:
+                                wf = wrapper(bwf)
+                                commands = json.load(wf).get('extensions')
+                                if commands:
+                                    commands = commands.get('python.commands')
+                        except Exception:
+                            logger.warning('Unable to read JSON metadata, so '
+                                           'cannot generate scripts')
+                    if commands:
+                        console_scripts = commands.get('wrap_console', {})
+                        gui_scripts = commands.get('wrap_gui', {})
+                        if console_scripts or gui_scripts:
+                            script_dir = paths.get('scripts', '')
+                            if not os.path.isdir(script_dir):
+                                raise ValueError('Valid script path not '
+                                                 'specified')
+                            maker.target_dir = script_dir
+                            for k, v in console_scripts.items():
+                                script = '%s = %s' % (k, v)
+                                filenames = maker.make(script)
+                                fileop.set_executable_mode(filenames)
+
+                            if gui_scripts:
+                                options = {'gui': True}
+                                for k, v in gui_scripts.items():
+                                    script = '%s = %s' % (k, v)
+                                    filenames = maker.make(script, options)
+                                    fileop.set_executable_mode(filenames)
+
+                    p = os.path.join(libdir, info_dir)
+                    dist = InstalledDistribution(p)
+
+                    # Write SHARED
+                    paths = dict(paths)  # don't change passed in dict
+                    del paths['purelib']
+                    del paths['platlib']
+                    paths['lib'] = libdir
+                    p = dist.write_shared_locations(paths, dry_run)
+                    if p:
+                        outfiles.append(p)
+
+                    # Write RECORD
+                    dist.write_installed_files(outfiles, paths['prefix'],
+                                               dry_run)
+                return dist
+            except Exception:  # pragma: no cover
+                logger.exception('installation failed.')
+                fileop.rollback()
+                raise
+            finally:
+                shutil.rmtree(workdir)
+
+    def _get_dylib_cache(self):
+        global cache
+        if cache is None:
+            # Use native string to avoid issues on 2.x: see Python #20140.
+            base = os.path.join(get_cache_base(), str('dylib-cache'),
+                                '%s.%s' % sys.version_info[:2])
+            cache = Cache(base)
+        return cache
+
+    def _get_extensions(self):
+        pathname = os.path.join(self.dirname, self.filename)
+        name_ver = '%s-%s' % (self.name, self.version)
+        info_dir = '%s.dist-info' % name_ver
+        arcname = posixpath.join(info_dir, 'EXTENSIONS')
+        wrapper = codecs.getreader('utf-8')
+        result = []
+        with ZipFile(pathname, 'r') as zf:
+            try:
+                with zf.open(arcname) as bf:
+                    wf = wrapper(bf)
+                    extensions = json.load(wf)
+                    cache = self._get_dylib_cache()
+                    prefix = cache.prefix_to_dir(pathname)
+                    cache_base = os.path.join(cache.base, prefix)
+                    if not os.path.isdir(cache_base):
+                        os.makedirs(cache_base)
+                    for name, relpath in extensions.items():
+                        dest = os.path.join(cache_base, convert_path(relpath))
+                        if not os.path.exists(dest):
+                            extract = True
+                        else:
+                            file_time = os.stat(dest).st_mtime
+                            file_time = datetime.datetime.fromtimestamp(
+                                file_time)
+                            info = zf.getinfo(relpath)
+                            wheel_time = datetime.datetime(*info.date_time)
+                            extract = wheel_time > file_time
+                        if extract:
+                            zf.extract(relpath, cache_base)
+                        result.append((name, dest))
+            except KeyError:
+                pass
+        return result
+
+    def is_compatible(self):
+        """
+        Determine if a wheel is compatible with the running system.
+        """
+        return is_compatible(self)
+
+    def is_mountable(self):
+        """
+        Determine if a wheel is asserted as mountable by its metadata.
+        """
+        return True  # for now - metadata details TBD
+
+    def mount(self, append=False):
+        pathname = os.path.abspath(os.path.join(self.dirname, self.filename))
+        if not self.is_compatible():
+            msg = 'Wheel %s not compatible with this Python.' % pathname
+            raise DistlibException(msg)
+        if not self.is_mountable():
+            msg = 'Wheel %s is marked as not mountable.' % pathname
+            raise DistlibException(msg)
+        if pathname in sys.path:
+            logger.debug('%s already in path', pathname)
+        else:
+            if append:
+                sys.path.append(pathname)
+            else:
+                sys.path.insert(0, pathname)
+            extensions = self._get_extensions()
+            if extensions:
+                if _hook not in sys.meta_path:
+                    sys.meta_path.append(_hook)
+                _hook.add(pathname, extensions)
+
+    def unmount(self):
+        pathname = os.path.abspath(os.path.join(self.dirname, self.filename))
+        if pathname not in sys.path:
+            logger.debug('%s not in path', pathname)
+        else:
+            sys.path.remove(pathname)
+            if pathname in _hook.impure_wheels:
+                _hook.remove(pathname)
+            if not _hook.impure_wheels:
+                if _hook in sys.meta_path:
+                    sys.meta_path.remove(_hook)
+
+    def verify(self):
+        pathname = os.path.join(self.dirname, self.filename)
+        name_ver = '%s-%s' % (self.name, self.version)
+        # data_dir = '%s.data' % name_ver
+        info_dir = '%s.dist-info' % name_ver
+
+        # metadata_name = posixpath.join(info_dir, LEGACY_METADATA_FILENAME)
+        wheel_metadata_name = posixpath.join(info_dir, 'WHEEL')
+        record_name = posixpath.join(info_dir, 'RECORD')
+
+        wrapper = codecs.getreader('utf-8')
+
+        with ZipFile(pathname, 'r') as zf:
+            with zf.open(wheel_metadata_name) as bwf:
+                wf = wrapper(bwf)
+                message_from_file(wf)
+            # wv = message['Wheel-Version'].split('.', 1)
+            # file_version = tuple([int(i) for i in wv])
+            # TODO version verification
+
+            records = {}
+            with zf.open(record_name) as bf:
+                with CSVReader(stream=bf) as reader:
+                    for row in reader:
+                        p = row[0]
+                        records[p] = row
+
+            for zinfo in zf.infolist():
+                arcname = zinfo.filename
+                if isinstance(arcname, text_type):
+                    u_arcname = arcname
+                else:
+                    u_arcname = arcname.decode('utf-8')
+                # See issue #115: some wheels have .. in their entries, but
+                # in the filename ... e.g. __main__..py ! So the check is
+                # updated to look for .. in the directory portions
+                p = u_arcname.split('/')
+                if '..' in p:
+                    raise DistlibException('invalid entry in '
+                                           'wheel: %r' % u_arcname)
+
+                if self.skip_entry(u_arcname):
+                    continue
+                row = records[u_arcname]
+                if row[2] and str(zinfo.file_size) != row[2]:
+                    raise DistlibException('size mismatch for '
+                                           '%s' % u_arcname)
+                if row[1]:
+                    kind, value = row[1].split('=', 1)
+                    with zf.open(arcname) as bf:
+                        data = bf.read()
+                    _, digest = self.get_hash(data, kind)
+                    if digest != value:
+                        raise DistlibException('digest mismatch for '
+                                               '%s' % arcname)
+
+    def update(self, modifier, dest_dir=None, **kwargs):
+        """
+        Update the contents of a wheel in a generic way. The modifier should
+        be a callable which expects a dictionary argument: its keys are
+        archive-entry paths, and its values are absolute filesystem paths
+        where the contents the corresponding archive entries can be found. The
+        modifier is free to change the contents of the files pointed to, add
+        new entries and remove entries, before returning. This method will
+        extract the entire contents of the wheel to a temporary location, call
+        the modifier, and then use the passed (and possibly updated)
+        dictionary to write a new wheel. If ``dest_dir`` is specified, the new
+        wheel is written there -- otherwise, the original wheel is overwritten.
+
+        The modifier should return True if it updated the wheel, else False.
+        This method returns the same value the modifier returns.
+        """
+
+        def get_version(path_map, info_dir):
+            version = path = None
+            key = '%s/%s' % (info_dir, LEGACY_METADATA_FILENAME)
+            if key not in path_map:
+                key = '%s/PKG-INFO' % info_dir
+            if key in path_map:
+                path = path_map[key]
+                version = Metadata(path=path).version
+            return version, path
+
+        def update_version(version, path):
+            updated = None
+            try:
+                NormalizedVersion(version)
+                i = version.find('-')
+                if i < 0:
+                    updated = '%s+1' % version
+                else:
+                    parts = [int(s) for s in version[i + 1:].split('.')]
+                    parts[-1] += 1
+                    updated = '%s+%s' % (version[:i], '.'.join(
+                        str(i) for i in parts))
+            except UnsupportedVersionError:
+                logger.debug(
+                    'Cannot update non-compliant (PEP-440) '
+                    'version %r', version)
+            if updated:
+                md = Metadata(path=path)
+                md.version = updated
+                legacy = path.endswith(LEGACY_METADATA_FILENAME)
+                md.write(path=path, legacy=legacy)
+                logger.debug('Version updated from %r to %r', version, updated)
+
+        pathname = os.path.join(self.dirname, self.filename)
+        name_ver = '%s-%s' % (self.name, self.version)
+        info_dir = '%s.dist-info' % name_ver
+        record_name = posixpath.join(info_dir, 'RECORD')
+        with tempdir() as workdir:
+            with ZipFile(pathname, 'r') as zf:
+                path_map = {}
+                for zinfo in zf.infolist():
+                    arcname = zinfo.filename
+                    if isinstance(arcname, text_type):
+                        u_arcname = arcname
+                    else:
+                        u_arcname = arcname.decode('utf-8')
+                    if u_arcname == record_name:
+                        continue
+                    if '..' in u_arcname:
+                        raise DistlibException('invalid entry in '
+                                               'wheel: %r' % u_arcname)
+                    zf.extract(zinfo, workdir)
+                    path = os.path.join(workdir, convert_path(u_arcname))
+                    path_map[u_arcname] = path
+
+            # Remember the version.
+            original_version, _ = get_version(path_map, info_dir)
+            # Files extracted. Call the modifier.
+            modified = modifier(path_map, **kwargs)
+            if modified:
+                # Something changed - need to build a new wheel.
+                current_version, path = get_version(path_map, info_dir)
+                if current_version and (current_version == original_version):
+                    # Add or update local version to signify changes.
+                    update_version(current_version, path)
+                # Decide where the new wheel goes.
+                if dest_dir is None:
+                    fd, newpath = tempfile.mkstemp(suffix='.whl',
+                                                   prefix='wheel-update-',
+                                                   dir=workdir)
+                    os.close(fd)
+                else:
+                    if not os.path.isdir(dest_dir):
+                        raise DistlibException('Not a directory: %r' %
+                                               dest_dir)
+                    newpath = os.path.join(dest_dir, self.filename)
+                archive_paths = list(path_map.items())
+                distinfo = os.path.join(workdir, info_dir)
+                info = distinfo, info_dir
+                self.write_records(info, workdir, archive_paths)
+                self.build_zip(newpath, archive_paths)
+                if dest_dir is None:
+                    shutil.copyfile(newpath, pathname)
+        return modified
+
+
+def _get_glibc_version():
+    import platform
+    ver = platform.libc_ver()
+    result = []
+    if ver[0] == 'glibc':
+        for s in ver[1].split('.'):
+            result.append(int(s) if s.isdigit() else 0)
+        result = tuple(result)
+    return result
+
+
+def compatible_tags():
+    """
+    Return (pyver, abi, arch) tuples compatible with this Python.
+    """
+    versions = [VER_SUFFIX]
+    major = VER_SUFFIX[0]
+    for minor in range(sys.version_info[1] - 1, -1, -1):
+        versions.append(''.join([major, str(minor)]))
+
+    abis = []
+    for suffix in _get_suffixes():
+        if suffix.startswith('.abi'):
+            abis.append(suffix.split('.', 2)[1])
+    abis.sort()
+    if ABI != 'none':
+        abis.insert(0, ABI)
+    abis.append('none')
+    result = []
+
+    arches = [ARCH]
+    if sys.platform == 'darwin':
+        m = re.match(r'(\w+)_(\d+)_(\d+)_(\w+)$', ARCH)
+        if m:
+            name, major, minor, arch = m.groups()
+            minor = int(minor)
+            matches = [arch]
+            if arch in ('i386', 'ppc'):
+                matches.append('fat')
+            if arch in ('i386', 'ppc', 'x86_64'):
+                matches.append('fat3')
+            if arch in ('ppc64', 'x86_64'):
+                matches.append('fat64')
+            if arch in ('i386', 'x86_64'):
+                matches.append('intel')
+            if arch in ('i386', 'x86_64', 'intel', 'ppc', 'ppc64'):
+                matches.append('universal')
+            while minor >= 0:
+                for match in matches:
+                    s = '%s_%s_%s_%s' % (name, major, minor, match)
+                    if s != ARCH:  # already there
+                        arches.append(s)
+                minor -= 1
+
+    # Most specific - our Python version, ABI and arch
+    for abi in abis:
+        for arch in arches:
+            result.append((''.join((IMP_PREFIX, versions[0])), abi, arch))
+            # manylinux
+            if abi != 'none' and sys.platform.startswith('linux'):
+                arch = arch.replace('linux_', '')
+                parts = _get_glibc_version()
+                if len(parts) == 2:
+                    if parts >= (2, 5):
+                        result.append((''.join((IMP_PREFIX, versions[0])), abi,
+                                       'manylinux1_%s' % arch))
+                    if parts >= (2, 12):
+                        result.append((''.join((IMP_PREFIX, versions[0])), abi,
+                                       'manylinux2010_%s' % arch))
+                    if parts >= (2, 17):
+                        result.append((''.join((IMP_PREFIX, versions[0])), abi,
+                                       'manylinux2014_%s' % arch))
+                    result.append(
+                        (''.join((IMP_PREFIX, versions[0])), abi,
+                         'manylinux_%s_%s_%s' % (parts[0], parts[1], arch)))
+
+    # where no ABI / arch dependency, but IMP_PREFIX dependency
+    for i, version in enumerate(versions):
+        result.append((''.join((IMP_PREFIX, version)), 'none', 'any'))
+        if i == 0:
+            result.append((''.join((IMP_PREFIX, version[0])), 'none', 'any'))
+
+    # no IMP_PREFIX, ABI or arch dependency
+    for i, version in enumerate(versions):
+        result.append((''.join(('py', version)), 'none', 'any'))
+        if i == 0:
+            result.append((''.join(('py', version[0])), 'none', 'any'))
+
+    return set(result)
+
+
+COMPATIBLE_TAGS = compatible_tags()
+
+del compatible_tags
+
+
+def is_compatible(wheel, tags=None):
+    if not isinstance(wheel, Wheel):
+        wheel = Wheel(wheel)  # assume it's a filename
+    result = False
+    if tags is None:
+        tags = COMPATIBLE_TAGS
+    for ver, abi, arch in tags:
+        if ver in wheel.pyver and abi in wheel.abi and arch in wheel.arch:
+            result = True
+            break
+    return result
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/distro/__init__.py b/venv/lib/python3.12/site-packages/pip/_vendor/distro/__init__.py
new file mode 100644
index 00000000..7686fe85
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_vendor/distro/__init__.py
@@ -0,0 +1,54 @@
+from .distro import (
+    NORMALIZED_DISTRO_ID,
+    NORMALIZED_LSB_ID,
+    NORMALIZED_OS_ID,
+    LinuxDistribution,
+    __version__,
+    build_number,
+    codename,
+    distro_release_attr,
+    distro_release_info,
+    id,
+    info,
+    like,
+    linux_distribution,
+    lsb_release_attr,
+    lsb_release_info,
+    major_version,
+    minor_version,
+    name,
+    os_release_attr,
+    os_release_info,
+    uname_attr,
+    uname_info,
+    version,
+    version_parts,
+)
+
+__all__ = [
+    "NORMALIZED_DISTRO_ID",
+    "NORMALIZED_LSB_ID",
+    "NORMALIZED_OS_ID",
+    "LinuxDistribution",
+    "build_number",
+    "codename",
+    "distro_release_attr",
+    "distro_release_info",
+    "id",
+    "info",
+    "like",
+    "linux_distribution",
+    "lsb_release_attr",
+    "lsb_release_info",
+    "major_version",
+    "minor_version",
+    "name",
+    "os_release_attr",
+    "os_release_info",
+    "uname_attr",
+    "uname_info",
+    "version",
+    "version_parts",
+]
+
+__version__ = __version__
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/distro/__main__.py b/venv/lib/python3.12/site-packages/pip/_vendor/distro/__main__.py
new file mode 100644
index 00000000..0c01d5b0
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_vendor/distro/__main__.py
@@ -0,0 +1,4 @@
+from .distro import main
+
+if __name__ == "__main__":
+    main()
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/distro/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_vendor/distro/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 00000000..b19f31fd
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_vendor/distro/__pycache__/__init__.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/distro/__pycache__/__main__.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_vendor/distro/__pycache__/__main__.cpython-312.pyc
new file mode 100644
index 00000000..9427dcff
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_vendor/distro/__pycache__/__main__.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/distro/__pycache__/distro.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_vendor/distro/__pycache__/distro.cpython-312.pyc
new file mode 100644
index 00000000..90f40b52
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_vendor/distro/__pycache__/distro.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/distro/distro.py b/venv/lib/python3.12/site-packages/pip/_vendor/distro/distro.py
new file mode 100644
index 00000000..78ccdfa4
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_vendor/distro/distro.py
@@ -0,0 +1,1403 @@
+#!/usr/bin/env python
+# Copyright 2015-2021 Nir Cohen
+#
+# 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.
+
+"""
+The ``distro`` package (``distro`` stands for Linux Distribution) provides
+information about the Linux distribution it runs on, such as a reliable
+machine-readable distro ID, or version information.
+
+It is the recommended replacement for Python's original
+:py:func:`platform.linux_distribution` function, but it provides much more
+functionality. An alternative implementation became necessary because Python
+3.5 deprecated this function, and Python 3.8 removed it altogether. Its
+predecessor function :py:func:`platform.dist` was already deprecated since
+Python 2.6 and removed in Python 3.8. Still, there are many cases in which
+access to OS distribution information is needed. See `Python issue 1322
+`_ for more information.
+"""
+
+import argparse
+import json
+import logging
+import os
+import re
+import shlex
+import subprocess
+import sys
+import warnings
+from typing import (
+    Any,
+    Callable,
+    Dict,
+    Iterable,
+    Optional,
+    Sequence,
+    TextIO,
+    Tuple,
+    Type,
+)
+
+try:
+    from typing import TypedDict
+except ImportError:
+    # Python 3.7
+    TypedDict = dict
+
+__version__ = "1.9.0"
+
+
+class VersionDict(TypedDict):
+    major: str
+    minor: str
+    build_number: str
+
+
+class InfoDict(TypedDict):
+    id: str
+    version: str
+    version_parts: VersionDict
+    like: str
+    codename: str
+
+
+_UNIXCONFDIR = os.environ.get("UNIXCONFDIR", "/etc")
+_UNIXUSRLIBDIR = os.environ.get("UNIXUSRLIBDIR", "/usr/lib")
+_OS_RELEASE_BASENAME = "os-release"
+
+#: Translation table for normalizing the "ID" attribute defined in os-release
+#: files, for use by the :func:`distro.id` method.
+#:
+#: * Key: Value as defined in the os-release file, translated to lower case,
+#:   with blanks translated to underscores.
+#:
+#: * Value: Normalized value.
+NORMALIZED_OS_ID = {
+    "ol": "oracle",  # Oracle Linux
+    "opensuse-leap": "opensuse",  # Newer versions of OpenSuSE report as opensuse-leap
+}
+
+#: Translation table for normalizing the "Distributor ID" attribute returned by
+#: the lsb_release command, for use by the :func:`distro.id` method.
+#:
+#: * Key: Value as returned by the lsb_release command, translated to lower
+#:   case, with blanks translated to underscores.
+#:
+#: * Value: Normalized value.
+NORMALIZED_LSB_ID = {
+    "enterpriseenterpriseas": "oracle",  # Oracle Enterprise Linux 4
+    "enterpriseenterpriseserver": "oracle",  # Oracle Linux 5
+    "redhatenterpriseworkstation": "rhel",  # RHEL 6, 7 Workstation
+    "redhatenterpriseserver": "rhel",  # RHEL 6, 7 Server
+    "redhatenterprisecomputenode": "rhel",  # RHEL 6 ComputeNode
+}
+
+#: Translation table for normalizing the distro ID derived from the file name
+#: of distro release files, for use by the :func:`distro.id` method.
+#:
+#: * Key: Value as derived from the file name of a distro release file,
+#:   translated to lower case, with blanks translated to underscores.
+#:
+#: * Value: Normalized value.
+NORMALIZED_DISTRO_ID = {
+    "redhat": "rhel",  # RHEL 6.x, 7.x
+}
+
+# Pattern for content of distro release file (reversed)
+_DISTRO_RELEASE_CONTENT_REVERSED_PATTERN = re.compile(
+    r"(?:[^)]*\)(.*)\()? *(?:STL )?([\d.+\-a-z]*\d) *(?:esaeler *)?(.+)"
+)
+
+# Pattern for base file name of distro release file
+_DISTRO_RELEASE_BASENAME_PATTERN = re.compile(r"(\w+)[-_](release|version)$")
+
+# Base file names to be looked up for if _UNIXCONFDIR is not readable.
+_DISTRO_RELEASE_BASENAMES = [
+    "SuSE-release",
+    "altlinux-release",
+    "arch-release",
+    "base-release",
+    "centos-release",
+    "fedora-release",
+    "gentoo-release",
+    "mageia-release",
+    "mandrake-release",
+    "mandriva-release",
+    "mandrivalinux-release",
+    "manjaro-release",
+    "oracle-release",
+    "redhat-release",
+    "rocky-release",
+    "sl-release",
+    "slackware-version",
+]
+
+# Base file names to be ignored when searching for distro release file
+_DISTRO_RELEASE_IGNORE_BASENAMES = (
+    "debian_version",
+    "lsb-release",
+    "oem-release",
+    _OS_RELEASE_BASENAME,
+    "system-release",
+    "plesk-release",
+    "iredmail-release",
+    "board-release",
+    "ec2_version",
+)
+
+
+def linux_distribution(full_distribution_name: bool = True) -> Tuple[str, str, str]:
+    """
+    .. deprecated:: 1.6.0
+
+        :func:`distro.linux_distribution()` is deprecated. It should only be
+        used as a compatibility shim with Python's
+        :py:func:`platform.linux_distribution()`. Please use :func:`distro.id`,
+        :func:`distro.version` and :func:`distro.name` instead.
+
+    Return information about the current OS distribution as a tuple
+    ``(id_name, version, codename)`` with items as follows:
+
+    * ``id_name``:  If *full_distribution_name* is false, the result of
+      :func:`distro.id`. Otherwise, the result of :func:`distro.name`.
+
+    * ``version``:  The result of :func:`distro.version`.
+
+    * ``codename``:  The extra item (usually in parentheses) after the
+      os-release version number, or the result of :func:`distro.codename`.
+
+    The interface of this function is compatible with the original
+    :py:func:`platform.linux_distribution` function, supporting a subset of
+    its parameters.
+
+    The data it returns may not exactly be the same, because it uses more data
+    sources than the original function, and that may lead to different data if
+    the OS distribution is not consistent across multiple data sources it
+    provides (there are indeed such distributions ...).
+
+    Another reason for differences is the fact that the :func:`distro.id`
+    method normalizes the distro ID string to a reliable machine-readable value
+    for a number of popular OS distributions.
+    """
+    warnings.warn(
+        "distro.linux_distribution() is deprecated. It should only be used as a "
+        "compatibility shim with Python's platform.linux_distribution(). Please use "
+        "distro.id(), distro.version() and distro.name() instead.",
+        DeprecationWarning,
+        stacklevel=2,
+    )
+    return _distro.linux_distribution(full_distribution_name)
+
+
+def id() -> str:
+    """
+    Return the distro ID of the current distribution, as a
+    machine-readable string.
+
+    For a number of OS distributions, the returned distro ID value is
+    *reliable*, in the sense that it is documented and that it does not change
+    across releases of the distribution.
+
+    This package maintains the following reliable distro ID values:
+
+    ==============  =========================================
+    Distro ID       Distribution
+    ==============  =========================================
+    "ubuntu"        Ubuntu
+    "debian"        Debian
+    "rhel"          RedHat Enterprise Linux
+    "centos"        CentOS
+    "fedora"        Fedora
+    "sles"          SUSE Linux Enterprise Server
+    "opensuse"      openSUSE
+    "amzn"          Amazon Linux
+    "arch"          Arch Linux
+    "buildroot"     Buildroot
+    "cloudlinux"    CloudLinux OS
+    "exherbo"       Exherbo Linux
+    "gentoo"        GenToo Linux
+    "ibm_powerkvm"  IBM PowerKVM
+    "kvmibm"        KVM for IBM z Systems
+    "linuxmint"     Linux Mint
+    "mageia"        Mageia
+    "mandriva"      Mandriva Linux
+    "parallels"     Parallels
+    "pidora"        Pidora
+    "raspbian"      Raspbian
+    "oracle"        Oracle Linux (and Oracle Enterprise Linux)
+    "scientific"    Scientific Linux
+    "slackware"     Slackware
+    "xenserver"     XenServer
+    "openbsd"       OpenBSD
+    "netbsd"        NetBSD
+    "freebsd"       FreeBSD
+    "midnightbsd"   MidnightBSD
+    "rocky"         Rocky Linux
+    "aix"           AIX
+    "guix"          Guix System
+    "altlinux"      ALT Linux
+    ==============  =========================================
+
+    If you have a need to get distros for reliable IDs added into this set,
+    or if you find that the :func:`distro.id` function returns a different
+    distro ID for one of the listed distros, please create an issue in the
+    `distro issue tracker`_.
+
+    **Lookup hierarchy and transformations:**
+
+    First, the ID is obtained from the following sources, in the specified
+    order. The first available and non-empty value is used:
+
+    * the value of the "ID" attribute of the os-release file,
+
+    * the value of the "Distributor ID" attribute returned by the lsb_release
+      command,
+
+    * the first part of the file name of the distro release file,
+
+    The so determined ID value then passes the following transformations,
+    before it is returned by this method:
+
+    * it is translated to lower case,
+
+    * blanks (which should not be there anyway) are translated to underscores,
+
+    * a normalization of the ID is performed, based upon
+      `normalization tables`_. The purpose of this normalization is to ensure
+      that the ID is as reliable as possible, even across incompatible changes
+      in the OS distributions. A common reason for an incompatible change is
+      the addition of an os-release file, or the addition of the lsb_release
+      command, with ID values that differ from what was previously determined
+      from the distro release file name.
+    """
+    return _distro.id()
+
+
+def name(pretty: bool = False) -> str:
+    """
+    Return the name of the current OS distribution, as a human-readable
+    string.
+
+    If *pretty* is false, the name is returned without version or codename.
+    (e.g. "CentOS Linux")
+
+    If *pretty* is true, the version and codename are appended.
+    (e.g. "CentOS Linux 7.1.1503 (Core)")
+
+    **Lookup hierarchy:**
+
+    The name is obtained from the following sources, in the specified order.
+    The first available and non-empty value is used:
+
+    * If *pretty* is false:
+
+      - the value of the "NAME" attribute of the os-release file,
+
+      - the value of the "Distributor ID" attribute returned by the lsb_release
+        command,
+
+      - the value of the "" field of the distro release file.
+
+    * If *pretty* is true:
+
+      - the value of the "PRETTY_NAME" attribute of the os-release file,
+
+      - the value of the "Description" attribute returned by the lsb_release
+        command,
+
+      - the value of the "" field of the distro release file, appended
+        with the value of the pretty version ("" and ""
+        fields) of the distro release file, if available.
+    """
+    return _distro.name(pretty)
+
+
+def version(pretty: bool = False, best: bool = False) -> str:
+    """
+    Return the version of the current OS distribution, as a human-readable
+    string.
+
+    If *pretty* is false, the version is returned without codename (e.g.
+    "7.0").
+
+    If *pretty* is true, the codename in parenthesis is appended, if the
+    codename is non-empty (e.g. "7.0 (Maipo)").
+
+    Some distributions provide version numbers with different precisions in
+    the different sources of distribution information. Examining the different
+    sources in a fixed priority order does not always yield the most precise
+    version (e.g. for Debian 8.2, or CentOS 7.1).
+
+    Some other distributions may not provide this kind of information. In these
+    cases, an empty string would be returned. This behavior can be observed
+    with rolling releases distributions (e.g. Arch Linux).
+
+    The *best* parameter can be used to control the approach for the returned
+    version:
+
+    If *best* is false, the first non-empty version number in priority order of
+    the examined sources is returned.
+
+    If *best* is true, the most precise version number out of all examined
+    sources is returned.
+
+    **Lookup hierarchy:**
+
+    In all cases, the version number is obtained from the following sources.
+    If *best* is false, this order represents the priority order:
+
+    * the value of the "VERSION_ID" attribute of the os-release file,
+    * the value of the "Release" attribute returned by the lsb_release
+      command,
+    * the version number parsed from the "" field of the first line
+      of the distro release file,
+    * the version number parsed from the "PRETTY_NAME" attribute of the
+      os-release file, if it follows the format of the distro release files.
+    * the version number parsed from the "Description" attribute returned by
+      the lsb_release command, if it follows the format of the distro release
+      files.
+    """
+    return _distro.version(pretty, best)
+
+
+def version_parts(best: bool = False) -> Tuple[str, str, str]:
+    """
+    Return the version of the current OS distribution as a tuple
+    ``(major, minor, build_number)`` with items as follows:
+
+    * ``major``:  The result of :func:`distro.major_version`.
+
+    * ``minor``:  The result of :func:`distro.minor_version`.
+
+    * ``build_number``:  The result of :func:`distro.build_number`.
+
+    For a description of the *best* parameter, see the :func:`distro.version`
+    method.
+    """
+    return _distro.version_parts(best)
+
+
+def major_version(best: bool = False) -> str:
+    """
+    Return the major version of the current OS distribution, as a string,
+    if provided.
+    Otherwise, the empty string is returned. The major version is the first
+    part of the dot-separated version string.
+
+    For a description of the *best* parameter, see the :func:`distro.version`
+    method.
+    """
+    return _distro.major_version(best)
+
+
+def minor_version(best: bool = False) -> str:
+    """
+    Return the minor version of the current OS distribution, as a string,
+    if provided.
+    Otherwise, the empty string is returned. The minor version is the second
+    part of the dot-separated version string.
+
+    For a description of the *best* parameter, see the :func:`distro.version`
+    method.
+    """
+    return _distro.minor_version(best)
+
+
+def build_number(best: bool = False) -> str:
+    """
+    Return the build number of the current OS distribution, as a string,
+    if provided.
+    Otherwise, the empty string is returned. The build number is the third part
+    of the dot-separated version string.
+
+    For a description of the *best* parameter, see the :func:`distro.version`
+    method.
+    """
+    return _distro.build_number(best)
+
+
+def like() -> str:
+    """
+    Return a space-separated list of distro IDs of distributions that are
+    closely related to the current OS distribution in regards to packaging
+    and programming interfaces, for example distributions the current
+    distribution is a derivative from.
+
+    **Lookup hierarchy:**
+
+    This information item is only provided by the os-release file.
+    For details, see the description of the "ID_LIKE" attribute in the
+    `os-release man page
+    `_.
+    """
+    return _distro.like()
+
+
+def codename() -> str:
+    """
+    Return the codename for the release of the current OS distribution,
+    as a string.
+
+    If the distribution does not have a codename, an empty string is returned.
+
+    Note that the returned codename is not always really a codename. For
+    example, openSUSE returns "x86_64". This function does not handle such
+    cases in any special way and just returns the string it finds, if any.
+
+    **Lookup hierarchy:**
+
+    * the codename within the "VERSION" attribute of the os-release file, if
+      provided,
+
+    * the value of the "Codename" attribute returned by the lsb_release
+      command,
+
+    * the value of the "" field of the distro release file.
+    """
+    return _distro.codename()
+
+
+def info(pretty: bool = False, best: bool = False) -> InfoDict:
+    """
+    Return certain machine-readable information items about the current OS
+    distribution in a dictionary, as shown in the following example:
+
+    .. sourcecode:: python
+
+        {
+            'id': 'rhel',
+            'version': '7.0',
+            'version_parts': {
+                'major': '7',
+                'minor': '0',
+                'build_number': ''
+            },
+            'like': 'fedora',
+            'codename': 'Maipo'
+        }
+
+    The dictionary structure and keys are always the same, regardless of which
+    information items are available in the underlying data sources. The values
+    for the various keys are as follows:
+
+    * ``id``:  The result of :func:`distro.id`.
+
+    * ``version``:  The result of :func:`distro.version`.
+
+    * ``version_parts -> major``:  The result of :func:`distro.major_version`.
+
+    * ``version_parts -> minor``:  The result of :func:`distro.minor_version`.
+
+    * ``version_parts -> build_number``:  The result of
+      :func:`distro.build_number`.
+
+    * ``like``:  The result of :func:`distro.like`.
+
+    * ``codename``:  The result of :func:`distro.codename`.
+
+    For a description of the *pretty* and *best* parameters, see the
+    :func:`distro.version` method.
+    """
+    return _distro.info(pretty, best)
+
+
+def os_release_info() -> Dict[str, str]:
+    """
+    Return a dictionary containing key-value pairs for the information items
+    from the os-release file data source of the current OS distribution.
+
+    See `os-release file`_ for details about these information items.
+    """
+    return _distro.os_release_info()
+
+
+def lsb_release_info() -> Dict[str, str]:
+    """
+    Return a dictionary containing key-value pairs for the information items
+    from the lsb_release command data source of the current OS distribution.
+
+    See `lsb_release command output`_ for details about these information
+    items.
+    """
+    return _distro.lsb_release_info()
+
+
+def distro_release_info() -> Dict[str, str]:
+    """
+    Return a dictionary containing key-value pairs for the information items
+    from the distro release file data source of the current OS distribution.
+
+    See `distro release file`_ for details about these information items.
+    """
+    return _distro.distro_release_info()
+
+
+def uname_info() -> Dict[str, str]:
+    """
+    Return a dictionary containing key-value pairs for the information items
+    from the distro release file data source of the current OS distribution.
+    """
+    return _distro.uname_info()
+
+
+def os_release_attr(attribute: str) -> str:
+    """
+    Return a single named information item from the os-release file data source
+    of the current OS distribution.
+
+    Parameters:
+
+    * ``attribute`` (string): Key of the information item.
+
+    Returns:
+
+    * (string): Value of the information item, if the item exists.
+      The empty string, if the item does not exist.
+
+    See `os-release file`_ for details about these information items.
+    """
+    return _distro.os_release_attr(attribute)
+
+
+def lsb_release_attr(attribute: str) -> str:
+    """
+    Return a single named information item from the lsb_release command output
+    data source of the current OS distribution.
+
+    Parameters:
+
+    * ``attribute`` (string): Key of the information item.
+
+    Returns:
+
+    * (string): Value of the information item, if the item exists.
+      The empty string, if the item does not exist.
+
+    See `lsb_release command output`_ for details about these information
+    items.
+    """
+    return _distro.lsb_release_attr(attribute)
+
+
+def distro_release_attr(attribute: str) -> str:
+    """
+    Return a single named information item from the distro release file
+    data source of the current OS distribution.
+
+    Parameters:
+
+    * ``attribute`` (string): Key of the information item.
+
+    Returns:
+
+    * (string): Value of the information item, if the item exists.
+      The empty string, if the item does not exist.
+
+    See `distro release file`_ for details about these information items.
+    """
+    return _distro.distro_release_attr(attribute)
+
+
+def uname_attr(attribute: str) -> str:
+    """
+    Return a single named information item from the distro release file
+    data source of the current OS distribution.
+
+    Parameters:
+
+    * ``attribute`` (string): Key of the information item.
+
+    Returns:
+
+    * (string): Value of the information item, if the item exists.
+                The empty string, if the item does not exist.
+    """
+    return _distro.uname_attr(attribute)
+
+
+try:
+    from functools import cached_property
+except ImportError:
+    # Python < 3.8
+    class cached_property:  # type: ignore
+        """A version of @property which caches the value.  On access, it calls the
+        underlying function and sets the value in `__dict__` so future accesses
+        will not re-call the property.
+        """
+
+        def __init__(self, f: Callable[[Any], Any]) -> None:
+            self._fname = f.__name__
+            self._f = f
+
+        def __get__(self, obj: Any, owner: Type[Any]) -> Any:
+            assert obj is not None, f"call {self._fname} on an instance"
+            ret = obj.__dict__[self._fname] = self._f(obj)
+            return ret
+
+
+class LinuxDistribution:
+    """
+    Provides information about a OS distribution.
+
+    This package creates a private module-global instance of this class with
+    default initialization arguments, that is used by the
+    `consolidated accessor functions`_ and `single source accessor functions`_.
+    By using default initialization arguments, that module-global instance
+    returns data about the current OS distribution (i.e. the distro this
+    package runs on).
+
+    Normally, it is not necessary to create additional instances of this class.
+    However, in situations where control is needed over the exact data sources
+    that are used, instances of this class can be created with a specific
+    distro release file, or a specific os-release file, or without invoking the
+    lsb_release command.
+    """
+
+    def __init__(
+        self,
+        include_lsb: Optional[bool] = None,
+        os_release_file: str = "",
+        distro_release_file: str = "",
+        include_uname: Optional[bool] = None,
+        root_dir: Optional[str] = None,
+        include_oslevel: Optional[bool] = None,
+    ) -> None:
+        """
+        The initialization method of this class gathers information from the
+        available data sources, and stores that in private instance attributes.
+        Subsequent access to the information items uses these private instance
+        attributes, so that the data sources are read only once.
+
+        Parameters:
+
+        * ``include_lsb`` (bool): Controls whether the
+          `lsb_release command output`_ is included as a data source.
+
+          If the lsb_release command is not available in the program execution
+          path, the data source for the lsb_release command will be empty.
+
+        * ``os_release_file`` (string): The path name of the
+          `os-release file`_ that is to be used as a data source.
+
+          An empty string (the default) will cause the default path name to
+          be used (see `os-release file`_ for details).
+
+          If the specified or defaulted os-release file does not exist, the
+          data source for the os-release file will be empty.
+
+        * ``distro_release_file`` (string): The path name of the
+          `distro release file`_ that is to be used as a data source.
+
+          An empty string (the default) will cause a default search algorithm
+          to be used (see `distro release file`_ for details).
+
+          If the specified distro release file does not exist, or if no default
+          distro release file can be found, the data source for the distro
+          release file will be empty.
+
+        * ``include_uname`` (bool): Controls whether uname command output is
+          included as a data source. If the uname command is not available in
+          the program execution path the data source for the uname command will
+          be empty.
+
+        * ``root_dir`` (string): The absolute path to the root directory to use
+          to find distro-related information files. Note that ``include_*``
+          parameters must not be enabled in combination with ``root_dir``.
+
+        * ``include_oslevel`` (bool): Controls whether (AIX) oslevel command
+          output is included as a data source. If the oslevel command is not
+          available in the program execution path the data source will be
+          empty.
+
+        Public instance attributes:
+
+        * ``os_release_file`` (string): The path name of the
+          `os-release file`_ that is actually used as a data source. The
+          empty string if no distro release file is used as a data source.
+
+        * ``distro_release_file`` (string): The path name of the
+          `distro release file`_ that is actually used as a data source. The
+          empty string if no distro release file is used as a data source.
+
+        * ``include_lsb`` (bool): The result of the ``include_lsb`` parameter.
+          This controls whether the lsb information will be loaded.
+
+        * ``include_uname`` (bool): The result of the ``include_uname``
+          parameter. This controls whether the uname information will
+          be loaded.
+
+        * ``include_oslevel`` (bool): The result of the ``include_oslevel``
+          parameter. This controls whether (AIX) oslevel information will be
+          loaded.
+
+        * ``root_dir`` (string): The result of the ``root_dir`` parameter.
+          The absolute path to the root directory to use to find distro-related
+          information files.
+
+        Raises:
+
+        * :py:exc:`ValueError`: Initialization parameters combination is not
+           supported.
+
+        * :py:exc:`OSError`: Some I/O issue with an os-release file or distro
+          release file.
+
+        * :py:exc:`UnicodeError`: A data source has unexpected characters or
+          uses an unexpected encoding.
+        """
+        self.root_dir = root_dir
+        self.etc_dir = os.path.join(root_dir, "etc") if root_dir else _UNIXCONFDIR
+        self.usr_lib_dir = (
+            os.path.join(root_dir, "usr/lib") if root_dir else _UNIXUSRLIBDIR
+        )
+
+        if os_release_file:
+            self.os_release_file = os_release_file
+        else:
+            etc_dir_os_release_file = os.path.join(self.etc_dir, _OS_RELEASE_BASENAME)
+            usr_lib_os_release_file = os.path.join(
+                self.usr_lib_dir, _OS_RELEASE_BASENAME
+            )
+
+            # NOTE: The idea is to respect order **and** have it set
+            #       at all times for API backwards compatibility.
+            if os.path.isfile(etc_dir_os_release_file) or not os.path.isfile(
+                usr_lib_os_release_file
+            ):
+                self.os_release_file = etc_dir_os_release_file
+            else:
+                self.os_release_file = usr_lib_os_release_file
+
+        self.distro_release_file = distro_release_file or ""  # updated later
+
+        is_root_dir_defined = root_dir is not None
+        if is_root_dir_defined and (include_lsb or include_uname or include_oslevel):
+            raise ValueError(
+                "Including subprocess data sources from specific root_dir is disallowed"
+                " to prevent false information"
+            )
+        self.include_lsb = (
+            include_lsb if include_lsb is not None else not is_root_dir_defined
+        )
+        self.include_uname = (
+            include_uname if include_uname is not None else not is_root_dir_defined
+        )
+        self.include_oslevel = (
+            include_oslevel if include_oslevel is not None else not is_root_dir_defined
+        )
+
+    def __repr__(self) -> str:
+        """Return repr of all info"""
+        return (
+            "LinuxDistribution("
+            "os_release_file={self.os_release_file!r}, "
+            "distro_release_file={self.distro_release_file!r}, "
+            "include_lsb={self.include_lsb!r}, "
+            "include_uname={self.include_uname!r}, "
+            "include_oslevel={self.include_oslevel!r}, "
+            "root_dir={self.root_dir!r}, "
+            "_os_release_info={self._os_release_info!r}, "
+            "_lsb_release_info={self._lsb_release_info!r}, "
+            "_distro_release_info={self._distro_release_info!r}, "
+            "_uname_info={self._uname_info!r}, "
+            "_oslevel_info={self._oslevel_info!r})".format(self=self)
+        )
+
+    def linux_distribution(
+        self, full_distribution_name: bool = True
+    ) -> Tuple[str, str, str]:
+        """
+        Return information about the OS distribution that is compatible
+        with Python's :func:`platform.linux_distribution`, supporting a subset
+        of its parameters.
+
+        For details, see :func:`distro.linux_distribution`.
+        """
+        return (
+            self.name() if full_distribution_name else self.id(),
+            self.version(),
+            self._os_release_info.get("release_codename") or self.codename(),
+        )
+
+    def id(self) -> str:
+        """Return the distro ID of the OS distribution, as a string.
+
+        For details, see :func:`distro.id`.
+        """
+
+        def normalize(distro_id: str, table: Dict[str, str]) -> str:
+            distro_id = distro_id.lower().replace(" ", "_")
+            return table.get(distro_id, distro_id)
+
+        distro_id = self.os_release_attr("id")
+        if distro_id:
+            return normalize(distro_id, NORMALIZED_OS_ID)
+
+        distro_id = self.lsb_release_attr("distributor_id")
+        if distro_id:
+            return normalize(distro_id, NORMALIZED_LSB_ID)
+
+        distro_id = self.distro_release_attr("id")
+        if distro_id:
+            return normalize(distro_id, NORMALIZED_DISTRO_ID)
+
+        distro_id = self.uname_attr("id")
+        if distro_id:
+            return normalize(distro_id, NORMALIZED_DISTRO_ID)
+
+        return ""
+
+    def name(self, pretty: bool = False) -> str:
+        """
+        Return the name of the OS distribution, as a string.
+
+        For details, see :func:`distro.name`.
+        """
+        name = (
+            self.os_release_attr("name")
+            or self.lsb_release_attr("distributor_id")
+            or self.distro_release_attr("name")
+            or self.uname_attr("name")
+        )
+        if pretty:
+            name = self.os_release_attr("pretty_name") or self.lsb_release_attr(
+                "description"
+            )
+            if not name:
+                name = self.distro_release_attr("name") or self.uname_attr("name")
+                version = self.version(pretty=True)
+                if version:
+                    name = f"{name} {version}"
+        return name or ""
+
+    def version(self, pretty: bool = False, best: bool = False) -> str:
+        """
+        Return the version of the OS distribution, as a string.
+
+        For details, see :func:`distro.version`.
+        """
+        versions = [
+            self.os_release_attr("version_id"),
+            self.lsb_release_attr("release"),
+            self.distro_release_attr("version_id"),
+            self._parse_distro_release_content(self.os_release_attr("pretty_name")).get(
+                "version_id", ""
+            ),
+            self._parse_distro_release_content(
+                self.lsb_release_attr("description")
+            ).get("version_id", ""),
+            self.uname_attr("release"),
+        ]
+        if self.uname_attr("id").startswith("aix"):
+            # On AIX platforms, prefer oslevel command output.
+            versions.insert(0, self.oslevel_info())
+        elif self.id() == "debian" or "debian" in self.like().split():
+            # On Debian-like, add debian_version file content to candidates list.
+            versions.append(self._debian_version)
+        version = ""
+        if best:
+            # This algorithm uses the last version in priority order that has
+            # the best precision. If the versions are not in conflict, that
+            # does not matter; otherwise, using the last one instead of the
+            # first one might be considered a surprise.
+            for v in versions:
+                if v.count(".") > version.count(".") or version == "":
+                    version = v
+        else:
+            for v in versions:
+                if v != "":
+                    version = v
+                    break
+        if pretty and version and self.codename():
+            version = f"{version} ({self.codename()})"
+        return version
+
+    def version_parts(self, best: bool = False) -> Tuple[str, str, str]:
+        """
+        Return the version of the OS distribution, as a tuple of version
+        numbers.
+
+        For details, see :func:`distro.version_parts`.
+        """
+        version_str = self.version(best=best)
+        if version_str:
+            version_regex = re.compile(r"(\d+)\.?(\d+)?\.?(\d+)?")
+            matches = version_regex.match(version_str)
+            if matches:
+                major, minor, build_number = matches.groups()
+                return major, minor or "", build_number or ""
+        return "", "", ""
+
+    def major_version(self, best: bool = False) -> str:
+        """
+        Return the major version number of the current distribution.
+
+        For details, see :func:`distro.major_version`.
+        """
+        return self.version_parts(best)[0]
+
+    def minor_version(self, best: bool = False) -> str:
+        """
+        Return the minor version number of the current distribution.
+
+        For details, see :func:`distro.minor_version`.
+        """
+        return self.version_parts(best)[1]
+
+    def build_number(self, best: bool = False) -> str:
+        """
+        Return the build number of the current distribution.
+
+        For details, see :func:`distro.build_number`.
+        """
+        return self.version_parts(best)[2]
+
+    def like(self) -> str:
+        """
+        Return the IDs of distributions that are like the OS distribution.
+
+        For details, see :func:`distro.like`.
+        """
+        return self.os_release_attr("id_like") or ""
+
+    def codename(self) -> str:
+        """
+        Return the codename of the OS distribution.
+
+        For details, see :func:`distro.codename`.
+        """
+        try:
+            # Handle os_release specially since distros might purposefully set
+            # this to empty string to have no codename
+            return self._os_release_info["codename"]
+        except KeyError:
+            return (
+                self.lsb_release_attr("codename")
+                or self.distro_release_attr("codename")
+                or ""
+            )
+
+    def info(self, pretty: bool = False, best: bool = False) -> InfoDict:
+        """
+        Return certain machine-readable information about the OS
+        distribution.
+
+        For details, see :func:`distro.info`.
+        """
+        return InfoDict(
+            id=self.id(),
+            version=self.version(pretty, best),
+            version_parts=VersionDict(
+                major=self.major_version(best),
+                minor=self.minor_version(best),
+                build_number=self.build_number(best),
+            ),
+            like=self.like(),
+            codename=self.codename(),
+        )
+
+    def os_release_info(self) -> Dict[str, str]:
+        """
+        Return a dictionary containing key-value pairs for the information
+        items from the os-release file data source of the OS distribution.
+
+        For details, see :func:`distro.os_release_info`.
+        """
+        return self._os_release_info
+
+    def lsb_release_info(self) -> Dict[str, str]:
+        """
+        Return a dictionary containing key-value pairs for the information
+        items from the lsb_release command data source of the OS
+        distribution.
+
+        For details, see :func:`distro.lsb_release_info`.
+        """
+        return self._lsb_release_info
+
+    def distro_release_info(self) -> Dict[str, str]:
+        """
+        Return a dictionary containing key-value pairs for the information
+        items from the distro release file data source of the OS
+        distribution.
+
+        For details, see :func:`distro.distro_release_info`.
+        """
+        return self._distro_release_info
+
+    def uname_info(self) -> Dict[str, str]:
+        """
+        Return a dictionary containing key-value pairs for the information
+        items from the uname command data source of the OS distribution.
+
+        For details, see :func:`distro.uname_info`.
+        """
+        return self._uname_info
+
+    def oslevel_info(self) -> str:
+        """
+        Return AIX' oslevel command output.
+        """
+        return self._oslevel_info
+
+    def os_release_attr(self, attribute: str) -> str:
+        """
+        Return a single named information item from the os-release file data
+        source of the OS distribution.
+
+        For details, see :func:`distro.os_release_attr`.
+        """
+        return self._os_release_info.get(attribute, "")
+
+    def lsb_release_attr(self, attribute: str) -> str:
+        """
+        Return a single named information item from the lsb_release command
+        output data source of the OS distribution.
+
+        For details, see :func:`distro.lsb_release_attr`.
+        """
+        return self._lsb_release_info.get(attribute, "")
+
+    def distro_release_attr(self, attribute: str) -> str:
+        """
+        Return a single named information item from the distro release file
+        data source of the OS distribution.
+
+        For details, see :func:`distro.distro_release_attr`.
+        """
+        return self._distro_release_info.get(attribute, "")
+
+    def uname_attr(self, attribute: str) -> str:
+        """
+        Return a single named information item from the uname command
+        output data source of the OS distribution.
+
+        For details, see :func:`distro.uname_attr`.
+        """
+        return self._uname_info.get(attribute, "")
+
+    @cached_property
+    def _os_release_info(self) -> Dict[str, str]:
+        """
+        Get the information items from the specified os-release file.
+
+        Returns:
+            A dictionary containing all information items.
+        """
+        if os.path.isfile(self.os_release_file):
+            with open(self.os_release_file, encoding="utf-8") as release_file:
+                return self._parse_os_release_content(release_file)
+        return {}
+
+    @staticmethod
+    def _parse_os_release_content(lines: TextIO) -> Dict[str, str]:
+        """
+        Parse the lines of an os-release file.
+
+        Parameters:
+
+        * lines: Iterable through the lines in the os-release file.
+                 Each line must be a unicode string or a UTF-8 encoded byte
+                 string.
+
+        Returns:
+            A dictionary containing all information items.
+        """
+        props = {}
+        lexer = shlex.shlex(lines, posix=True)
+        lexer.whitespace_split = True
+
+        tokens = list(lexer)
+        for token in tokens:
+            # At this point, all shell-like parsing has been done (i.e.
+            # comments processed, quotes and backslash escape sequences
+            # processed, multi-line values assembled, trailing newlines
+            # stripped, etc.), so the tokens are now either:
+            # * variable assignments: var=value
+            # * commands or their arguments (not allowed in os-release)
+            # Ignore any tokens that are not variable assignments
+            if "=" in token:
+                k, v = token.split("=", 1)
+                props[k.lower()] = v
+
+        if "version" in props:
+            # extract release codename (if any) from version attribute
+            match = re.search(r"\((\D+)\)|,\s*(\D+)", props["version"])
+            if match:
+                release_codename = match.group(1) or match.group(2)
+                props["codename"] = props["release_codename"] = release_codename
+
+        if "version_codename" in props:
+            # os-release added a version_codename field.  Use that in
+            # preference to anything else Note that some distros purposefully
+            # do not have code names.  They should be setting
+            # version_codename=""
+            props["codename"] = props["version_codename"]
+        elif "ubuntu_codename" in props:
+            # Same as above but a non-standard field name used on older Ubuntus
+            props["codename"] = props["ubuntu_codename"]
+
+        return props
+
+    @cached_property
+    def _lsb_release_info(self) -> Dict[str, str]:
+        """
+        Get the information items from the lsb_release command output.
+
+        Returns:
+            A dictionary containing all information items.
+        """
+        if not self.include_lsb:
+            return {}
+        try:
+            cmd = ("lsb_release", "-a")
+            stdout = subprocess.check_output(cmd, stderr=subprocess.DEVNULL)
+        # Command not found or lsb_release returned error
+        except (OSError, subprocess.CalledProcessError):
+            return {}
+        content = self._to_str(stdout).splitlines()
+        return self._parse_lsb_release_content(content)
+
+    @staticmethod
+    def _parse_lsb_release_content(lines: Iterable[str]) -> Dict[str, str]:
+        """
+        Parse the output of the lsb_release command.
+
+        Parameters:
+
+        * lines: Iterable through the lines of the lsb_release output.
+                 Each line must be a unicode string or a UTF-8 encoded byte
+                 string.
+
+        Returns:
+            A dictionary containing all information items.
+        """
+        props = {}
+        for line in lines:
+            kv = line.strip("\n").split(":", 1)
+            if len(kv) != 2:
+                # Ignore lines without colon.
+                continue
+            k, v = kv
+            props.update({k.replace(" ", "_").lower(): v.strip()})
+        return props
+
+    @cached_property
+    def _uname_info(self) -> Dict[str, str]:
+        if not self.include_uname:
+            return {}
+        try:
+            cmd = ("uname", "-rs")
+            stdout = subprocess.check_output(cmd, stderr=subprocess.DEVNULL)
+        except OSError:
+            return {}
+        content = self._to_str(stdout).splitlines()
+        return self._parse_uname_content(content)
+
+    @cached_property
+    def _oslevel_info(self) -> str:
+        if not self.include_oslevel:
+            return ""
+        try:
+            stdout = subprocess.check_output("oslevel", stderr=subprocess.DEVNULL)
+        except (OSError, subprocess.CalledProcessError):
+            return ""
+        return self._to_str(stdout).strip()
+
+    @cached_property
+    def _debian_version(self) -> str:
+        try:
+            with open(
+                os.path.join(self.etc_dir, "debian_version"), encoding="ascii"
+            ) as fp:
+                return fp.readline().rstrip()
+        except FileNotFoundError:
+            return ""
+
+    @staticmethod
+    def _parse_uname_content(lines: Sequence[str]) -> Dict[str, str]:
+        if not lines:
+            return {}
+        props = {}
+        match = re.search(r"^([^\s]+)\s+([\d\.]+)", lines[0].strip())
+        if match:
+            name, version = match.groups()
+
+            # This is to prevent the Linux kernel version from
+            # appearing as the 'best' version on otherwise
+            # identifiable distributions.
+            if name == "Linux":
+                return {}
+            props["id"] = name.lower()
+            props["name"] = name
+            props["release"] = version
+        return props
+
+    @staticmethod
+    def _to_str(bytestring: bytes) -> str:
+        encoding = sys.getfilesystemencoding()
+        return bytestring.decode(encoding)
+
+    @cached_property
+    def _distro_release_info(self) -> Dict[str, str]:
+        """
+        Get the information items from the specified distro release file.
+
+        Returns:
+            A dictionary containing all information items.
+        """
+        if self.distro_release_file:
+            # If it was specified, we use it and parse what we can, even if
+            # its file name or content does not match the expected pattern.
+            distro_info = self._parse_distro_release_file(self.distro_release_file)
+            basename = os.path.basename(self.distro_release_file)
+            # The file name pattern for user-specified distro release files
+            # is somewhat more tolerant (compared to when searching for the
+            # file), because we want to use what was specified as best as
+            # possible.
+            match = _DISTRO_RELEASE_BASENAME_PATTERN.match(basename)
+        else:
+            try:
+                basenames = [
+                    basename
+                    for basename in os.listdir(self.etc_dir)
+                    if basename not in _DISTRO_RELEASE_IGNORE_BASENAMES
+                    and os.path.isfile(os.path.join(self.etc_dir, basename))
+                ]
+                # We sort for repeatability in cases where there are multiple
+                # distro specific files; e.g. CentOS, Oracle, Enterprise all
+                # containing `redhat-release` on top of their own.
+                basenames.sort()
+            except OSError:
+                # This may occur when /etc is not readable but we can't be
+                # sure about the *-release files. Check common entries of
+                # /etc for information. If they turn out to not be there the
+                # error is handled in `_parse_distro_release_file()`.
+                basenames = _DISTRO_RELEASE_BASENAMES
+            for basename in basenames:
+                match = _DISTRO_RELEASE_BASENAME_PATTERN.match(basename)
+                if match is None:
+                    continue
+                filepath = os.path.join(self.etc_dir, basename)
+                distro_info = self._parse_distro_release_file(filepath)
+                # The name is always present if the pattern matches.
+                if "name" not in distro_info:
+                    continue
+                self.distro_release_file = filepath
+                break
+            else:  # the loop didn't "break": no candidate.
+                return {}
+
+        if match is not None:
+            distro_info["id"] = match.group(1)
+
+        # CloudLinux < 7: manually enrich info with proper id.
+        if "cloudlinux" in distro_info.get("name", "").lower():
+            distro_info["id"] = "cloudlinux"
+
+        return distro_info
+
+    def _parse_distro_release_file(self, filepath: str) -> Dict[str, str]:
+        """
+        Parse a distro release file.
+
+        Parameters:
+
+        * filepath: Path name of the distro release file.
+
+        Returns:
+            A dictionary containing all information items.
+        """
+        try:
+            with open(filepath, encoding="utf-8") as fp:
+                # Only parse the first line. For instance, on SLES there
+                # are multiple lines. We don't want them...
+                return self._parse_distro_release_content(fp.readline())
+        except OSError:
+            # Ignore not being able to read a specific, seemingly version
+            # related file.
+            # See https://github.com/python-distro/distro/issues/162
+            return {}
+
+    @staticmethod
+    def _parse_distro_release_content(line: str) -> Dict[str, str]:
+        """
+        Parse a line from a distro release file.
+
+        Parameters:
+        * line: Line from the distro release file. Must be a unicode string
+                or a UTF-8 encoded byte string.
+
+        Returns:
+            A dictionary containing all information items.
+        """
+        matches = _DISTRO_RELEASE_CONTENT_REVERSED_PATTERN.match(line.strip()[::-1])
+        distro_info = {}
+        if matches:
+            # regexp ensures non-None
+            distro_info["name"] = matches.group(3)[::-1]
+            if matches.group(2):
+                distro_info["version_id"] = matches.group(2)[::-1]
+            if matches.group(1):
+                distro_info["codename"] = matches.group(1)[::-1]
+        elif line:
+            distro_info["name"] = line.strip()
+        return distro_info
+
+
+_distro = LinuxDistribution()
+
+
+def main() -> None:
+    logger = logging.getLogger(__name__)
+    logger.setLevel(logging.DEBUG)
+    logger.addHandler(logging.StreamHandler(sys.stdout))
+
+    parser = argparse.ArgumentParser(description="OS distro info tool")
+    parser.add_argument(
+        "--json", "-j", help="Output in machine readable format", action="store_true"
+    )
+
+    parser.add_argument(
+        "--root-dir",
+        "-r",
+        type=str,
+        dest="root_dir",
+        help="Path to the root filesystem directory (defaults to /)",
+    )
+
+    args = parser.parse_args()
+
+    if args.root_dir:
+        dist = LinuxDistribution(
+            include_lsb=False,
+            include_uname=False,
+            include_oslevel=False,
+            root_dir=args.root_dir,
+        )
+    else:
+        dist = _distro
+
+    if args.json:
+        logger.info(json.dumps(dist.info(), indent=4, sort_keys=True))
+    else:
+        logger.info("Name: %s", dist.name(pretty=True))
+        distribution_version = dist.version(pretty=True)
+        logger.info("Version: %s", distribution_version)
+        distribution_codename = dist.codename()
+        logger.info("Codename: %s", distribution_codename)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/distro/py.typed b/venv/lib/python3.12/site-packages/pip/_vendor/distro/py.typed
new file mode 100644
index 00000000..e69de29b
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/idna/__init__.py b/venv/lib/python3.12/site-packages/pip/_vendor/idna/__init__.py
new file mode 100644
index 00000000..a40eeafc
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_vendor/idna/__init__.py
@@ -0,0 +1,44 @@
+from .package_data import __version__
+from .core import (
+    IDNABidiError,
+    IDNAError,
+    InvalidCodepoint,
+    InvalidCodepointContext,
+    alabel,
+    check_bidi,
+    check_hyphen_ok,
+    check_initial_combiner,
+    check_label,
+    check_nfc,
+    decode,
+    encode,
+    ulabel,
+    uts46_remap,
+    valid_contextj,
+    valid_contexto,
+    valid_label_length,
+    valid_string_length,
+)
+from .intranges import intranges_contain
+
+__all__ = [
+    "IDNABidiError",
+    "IDNAError",
+    "InvalidCodepoint",
+    "InvalidCodepointContext",
+    "alabel",
+    "check_bidi",
+    "check_hyphen_ok",
+    "check_initial_combiner",
+    "check_label",
+    "check_nfc",
+    "decode",
+    "encode",
+    "intranges_contain",
+    "ulabel",
+    "uts46_remap",
+    "valid_contextj",
+    "valid_contexto",
+    "valid_label_length",
+    "valid_string_length",
+]
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/idna/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_vendor/idna/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 00000000..c104b85e
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_vendor/idna/__pycache__/__init__.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/idna/__pycache__/codec.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_vendor/idna/__pycache__/codec.cpython-312.pyc
new file mode 100644
index 00000000..2c48839b
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_vendor/idna/__pycache__/codec.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/idna/__pycache__/compat.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_vendor/idna/__pycache__/compat.cpython-312.pyc
new file mode 100644
index 00000000..983d129c
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_vendor/idna/__pycache__/compat.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/idna/__pycache__/core.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_vendor/idna/__pycache__/core.cpython-312.pyc
new file mode 100644
index 00000000..8e393bf4
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_vendor/idna/__pycache__/core.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/idna/__pycache__/idnadata.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_vendor/idna/__pycache__/idnadata.cpython-312.pyc
new file mode 100644
index 00000000..8f0c29b3
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_vendor/idna/__pycache__/idnadata.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/idna/__pycache__/intranges.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_vendor/idna/__pycache__/intranges.cpython-312.pyc
new file mode 100644
index 00000000..7678e15c
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_vendor/idna/__pycache__/intranges.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/idna/__pycache__/package_data.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_vendor/idna/__pycache__/package_data.cpython-312.pyc
new file mode 100644
index 00000000..6ee2bc22
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_vendor/idna/__pycache__/package_data.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/idna/__pycache__/uts46data.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_vendor/idna/__pycache__/uts46data.cpython-312.pyc
new file mode 100644
index 00000000..04ec1700
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_vendor/idna/__pycache__/uts46data.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/idna/codec.py b/venv/lib/python3.12/site-packages/pip/_vendor/idna/codec.py
new file mode 100644
index 00000000..c855a4de
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_vendor/idna/codec.py
@@ -0,0 +1,118 @@
+from .core import encode, decode, alabel, ulabel, IDNAError
+import codecs
+import re
+from typing import Any, Tuple, Optional
+
+_unicode_dots_re = re.compile('[\u002e\u3002\uff0e\uff61]')
+
+class Codec(codecs.Codec):
+
+    def encode(self, data: str, errors: str = 'strict') -> Tuple[bytes, int]:
+        if errors != 'strict':
+            raise IDNAError('Unsupported error handling \"{}\"'.format(errors))
+
+        if not data:
+            return b"", 0
+
+        return encode(data), len(data)
+
+    def decode(self, data: bytes, errors: str = 'strict') -> Tuple[str, int]:
+        if errors != 'strict':
+            raise IDNAError('Unsupported error handling \"{}\"'.format(errors))
+
+        if not data:
+            return '', 0
+
+        return decode(data), len(data)
+
+class IncrementalEncoder(codecs.BufferedIncrementalEncoder):
+    def _buffer_encode(self, data: str, errors: str, final: bool) -> Tuple[bytes, int]:
+        if errors != 'strict':
+            raise IDNAError('Unsupported error handling \"{}\"'.format(errors))
+
+        if not data:
+            return b'', 0
+
+        labels = _unicode_dots_re.split(data)
+        trailing_dot = b''
+        if labels:
+            if not labels[-1]:
+                trailing_dot = b'.'
+                del labels[-1]
+            elif not final:
+                # Keep potentially unfinished label until the next call
+                del labels[-1]
+                if labels:
+                    trailing_dot = b'.'
+
+        result = []
+        size = 0
+        for label in labels:
+            result.append(alabel(label))
+            if size:
+                size += 1
+            size += len(label)
+
+        # Join with U+002E
+        result_bytes = b'.'.join(result) + trailing_dot
+        size += len(trailing_dot)
+        return result_bytes, size
+
+class IncrementalDecoder(codecs.BufferedIncrementalDecoder):
+    def _buffer_decode(self, data: Any, errors: str, final: bool) -> Tuple[str, int]:
+        if errors != 'strict':
+            raise IDNAError('Unsupported error handling \"{}\"'.format(errors))
+
+        if not data:
+            return ('', 0)
+
+        if not isinstance(data, str):
+            data = str(data, 'ascii')
+
+        labels = _unicode_dots_re.split(data)
+        trailing_dot = ''
+        if labels:
+            if not labels[-1]:
+                trailing_dot = '.'
+                del labels[-1]
+            elif not final:
+                # Keep potentially unfinished label until the next call
+                del labels[-1]
+                if labels:
+                    trailing_dot = '.'
+
+        result = []
+        size = 0
+        for label in labels:
+            result.append(ulabel(label))
+            if size:
+                size += 1
+            size += len(label)
+
+        result_str = '.'.join(result) + trailing_dot
+        size += len(trailing_dot)
+        return (result_str, size)
+
+
+class StreamWriter(Codec, codecs.StreamWriter):
+    pass
+
+
+class StreamReader(Codec, codecs.StreamReader):
+    pass
+
+
+def search_function(name: str) -> Optional[codecs.CodecInfo]:
+    if name != 'idna2008':
+        return None
+    return codecs.CodecInfo(
+        name=name,
+        encode=Codec().encode,
+        decode=Codec().decode,
+        incrementalencoder=IncrementalEncoder,
+        incrementaldecoder=IncrementalDecoder,
+        streamwriter=StreamWriter,
+        streamreader=StreamReader,
+    )
+
+codecs.register(search_function)
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/idna/compat.py b/venv/lib/python3.12/site-packages/pip/_vendor/idna/compat.py
new file mode 100644
index 00000000..786e6bda
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_vendor/idna/compat.py
@@ -0,0 +1,13 @@
+from .core import *
+from .codec import *
+from typing import Any, Union
+
+def ToASCII(label: str) -> bytes:
+    return encode(label)
+
+def ToUnicode(label: Union[bytes, bytearray]) -> str:
+    return decode(label)
+
+def nameprep(s: Any) -> None:
+    raise NotImplementedError('IDNA 2008 does not utilise nameprep protocol')
+
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/idna/core.py b/venv/lib/python3.12/site-packages/pip/_vendor/idna/core.py
new file mode 100644
index 00000000..0dae61ac
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_vendor/idna/core.py
@@ -0,0 +1,395 @@
+from . import idnadata
+import bisect
+import unicodedata
+import re
+from typing import Union, Optional
+from .intranges import intranges_contain
+
+_virama_combining_class = 9
+_alabel_prefix = b'xn--'
+_unicode_dots_re = re.compile('[\u002e\u3002\uff0e\uff61]')
+
+class IDNAError(UnicodeError):
+    """ Base exception for all IDNA-encoding related problems """
+    pass
+
+
+class IDNABidiError(IDNAError):
+    """ Exception when bidirectional requirements are not satisfied """
+    pass
+
+
+class InvalidCodepoint(IDNAError):
+    """ Exception when a disallowed or unallocated codepoint is used """
+    pass
+
+
+class InvalidCodepointContext(IDNAError):
+    """ Exception when the codepoint is not valid in the context it is used """
+    pass
+
+
+def _combining_class(cp: int) -> int:
+    v = unicodedata.combining(chr(cp))
+    if v == 0:
+        if not unicodedata.name(chr(cp)):
+            raise ValueError('Unknown character in unicodedata')
+    return v
+
+def _is_script(cp: str, script: str) -> bool:
+    return intranges_contain(ord(cp), idnadata.scripts[script])
+
+def _punycode(s: str) -> bytes:
+    return s.encode('punycode')
+
+def _unot(s: int) -> str:
+    return 'U+{:04X}'.format(s)
+
+
+def valid_label_length(label: Union[bytes, str]) -> bool:
+    if len(label) > 63:
+        return False
+    return True
+
+
+def valid_string_length(label: Union[bytes, str], trailing_dot: bool) -> bool:
+    if len(label) > (254 if trailing_dot else 253):
+        return False
+    return True
+
+
+def check_bidi(label: str, check_ltr: bool = False) -> bool:
+    # Bidi rules should only be applied if string contains RTL characters
+    bidi_label = False
+    for (idx, cp) in enumerate(label, 1):
+        direction = unicodedata.bidirectional(cp)
+        if direction == '':
+            # String likely comes from a newer version of Unicode
+            raise IDNABidiError('Unknown directionality in label {} at position {}'.format(repr(label), idx))
+        if direction in ['R', 'AL', 'AN']:
+            bidi_label = True
+    if not bidi_label and not check_ltr:
+        return True
+
+    # Bidi rule 1
+    direction = unicodedata.bidirectional(label[0])
+    if direction in ['R', 'AL']:
+        rtl = True
+    elif direction == 'L':
+        rtl = False
+    else:
+        raise IDNABidiError('First codepoint in label {} must be directionality L, R or AL'.format(repr(label)))
+
+    valid_ending = False
+    number_type = None  # type: Optional[str]
+    for (idx, cp) in enumerate(label, 1):
+        direction = unicodedata.bidirectional(cp)
+
+        if rtl:
+            # Bidi rule 2
+            if not direction in ['R', 'AL', 'AN', 'EN', 'ES', 'CS', 'ET', 'ON', 'BN', 'NSM']:
+                raise IDNABidiError('Invalid direction for codepoint at position {} in a right-to-left label'.format(idx))
+            # Bidi rule 3
+            if direction in ['R', 'AL', 'EN', 'AN']:
+                valid_ending = True
+            elif direction != 'NSM':
+                valid_ending = False
+            # Bidi rule 4
+            if direction in ['AN', 'EN']:
+                if not number_type:
+                    number_type = direction
+                else:
+                    if number_type != direction:
+                        raise IDNABidiError('Can not mix numeral types in a right-to-left label')
+        else:
+            # Bidi rule 5
+            if not direction in ['L', 'EN', 'ES', 'CS', 'ET', 'ON', 'BN', 'NSM']:
+                raise IDNABidiError('Invalid direction for codepoint at position {} in a left-to-right label'.format(idx))
+            # Bidi rule 6
+            if direction in ['L', 'EN']:
+                valid_ending = True
+            elif direction != 'NSM':
+                valid_ending = False
+
+    if not valid_ending:
+        raise IDNABidiError('Label ends with illegal codepoint directionality')
+
+    return True
+
+
+def check_initial_combiner(label: str) -> bool:
+    if unicodedata.category(label[0])[0] == 'M':
+        raise IDNAError('Label begins with an illegal combining character')
+    return True
+
+
+def check_hyphen_ok(label: str) -> bool:
+    if label[2:4] == '--':
+        raise IDNAError('Label has disallowed hyphens in 3rd and 4th position')
+    if label[0] == '-' or label[-1] == '-':
+        raise IDNAError('Label must not start or end with a hyphen')
+    return True
+
+
+def check_nfc(label: str) -> None:
+    if unicodedata.normalize('NFC', label) != label:
+        raise IDNAError('Label must be in Normalization Form C')
+
+
+def valid_contextj(label: str, pos: int) -> bool:
+    cp_value = ord(label[pos])
+
+    if cp_value == 0x200c:
+
+        if pos > 0:
+            if _combining_class(ord(label[pos - 1])) == _virama_combining_class:
+                return True
+
+        ok = False
+        for i in range(pos-1, -1, -1):
+            joining_type = idnadata.joining_types.get(ord(label[i]))
+            if joining_type == ord('T'):
+                continue
+            elif joining_type in [ord('L'), ord('D')]:
+                ok = True
+                break
+            else:
+                break
+
+        if not ok:
+            return False
+
+        ok = False
+        for i in range(pos+1, len(label)):
+            joining_type = idnadata.joining_types.get(ord(label[i]))
+            if joining_type == ord('T'):
+                continue
+            elif joining_type in [ord('R'), ord('D')]:
+                ok = True
+                break
+            else:
+                break
+        return ok
+
+    if cp_value == 0x200d:
+
+        if pos > 0:
+            if _combining_class(ord(label[pos - 1])) == _virama_combining_class:
+                return True
+        return False
+
+    else:
+
+        return False
+
+
+def valid_contexto(label: str, pos: int, exception: bool = False) -> bool:
+    cp_value = ord(label[pos])
+
+    if cp_value == 0x00b7:
+        if 0 < pos < len(label)-1:
+            if ord(label[pos - 1]) == 0x006c and ord(label[pos + 1]) == 0x006c:
+                return True
+        return False
+
+    elif cp_value == 0x0375:
+        if pos < len(label)-1 and len(label) > 1:
+            return _is_script(label[pos + 1], 'Greek')
+        return False
+
+    elif cp_value == 0x05f3 or cp_value == 0x05f4:
+        if pos > 0:
+            return _is_script(label[pos - 1], 'Hebrew')
+        return False
+
+    elif cp_value == 0x30fb:
+        for cp in label:
+            if cp == '\u30fb':
+                continue
+            if _is_script(cp, 'Hiragana') or _is_script(cp, 'Katakana') or _is_script(cp, 'Han'):
+                return True
+        return False
+
+    elif 0x660 <= cp_value <= 0x669:
+        for cp in label:
+            if 0x6f0 <= ord(cp) <= 0x06f9:
+                return False
+        return True
+
+    elif 0x6f0 <= cp_value <= 0x6f9:
+        for cp in label:
+            if 0x660 <= ord(cp) <= 0x0669:
+                return False
+        return True
+
+    return False
+
+
+def check_label(label: Union[str, bytes, bytearray]) -> None:
+    if isinstance(label, (bytes, bytearray)):
+        label = label.decode('utf-8')
+    if len(label) == 0:
+        raise IDNAError('Empty Label')
+
+    check_nfc(label)
+    check_hyphen_ok(label)
+    check_initial_combiner(label)
+
+    for (pos, cp) in enumerate(label):
+        cp_value = ord(cp)
+        if intranges_contain(cp_value, idnadata.codepoint_classes['PVALID']):
+            continue
+        elif intranges_contain(cp_value, idnadata.codepoint_classes['CONTEXTJ']):
+            if not valid_contextj(label, pos):
+                raise InvalidCodepointContext('Joiner {} not allowed at position {} in {}'.format(
+                    _unot(cp_value), pos+1, repr(label)))
+        elif intranges_contain(cp_value, idnadata.codepoint_classes['CONTEXTO']):
+            if not valid_contexto(label, pos):
+                raise InvalidCodepointContext('Codepoint {} not allowed at position {} in {}'.format(_unot(cp_value), pos+1, repr(label)))
+        else:
+            raise InvalidCodepoint('Codepoint {} at position {} of {} not allowed'.format(_unot(cp_value), pos+1, repr(label)))
+
+    check_bidi(label)
+
+
+def alabel(label: str) -> bytes:
+    try:
+        label_bytes = label.encode('ascii')
+        ulabel(label_bytes)
+        if not valid_label_length(label_bytes):
+            raise IDNAError('Label too long')
+        return label_bytes
+    except UnicodeEncodeError:
+        pass
+
+    check_label(label)
+    label_bytes = _alabel_prefix + _punycode(label)
+
+    if not valid_label_length(label_bytes):
+        raise IDNAError('Label too long')
+
+    return label_bytes
+
+
+def ulabel(label: Union[str, bytes, bytearray]) -> str:
+    if not isinstance(label, (bytes, bytearray)):
+        try:
+            label_bytes = label.encode('ascii')
+        except UnicodeEncodeError:
+            check_label(label)
+            return label
+    else:
+        label_bytes = label
+
+    label_bytes = label_bytes.lower()
+    if label_bytes.startswith(_alabel_prefix):
+        label_bytes = label_bytes[len(_alabel_prefix):]
+        if not label_bytes:
+            raise IDNAError('Malformed A-label, no Punycode eligible content found')
+        if label_bytes.decode('ascii')[-1] == '-':
+            raise IDNAError('A-label must not end with a hyphen')
+    else:
+        check_label(label_bytes)
+        return label_bytes.decode('ascii')
+
+    try:
+        label = label_bytes.decode('punycode')
+    except UnicodeError:
+        raise IDNAError('Invalid A-label')
+    check_label(label)
+    return label
+
+
+def uts46_remap(domain: str, std3_rules: bool = True, transitional: bool = False) -> str:
+    """Re-map the characters in the string according to UTS46 processing."""
+    from .uts46data import uts46data
+    output = ''
+
+    for pos, char in enumerate(domain):
+        code_point = ord(char)
+        try:
+            uts46row = uts46data[code_point if code_point < 256 else
+                bisect.bisect_left(uts46data, (code_point, 'Z')) - 1]
+            status = uts46row[1]
+            replacement = None  # type: Optional[str]
+            if len(uts46row) == 3:
+                replacement = uts46row[2]
+            if (status == 'V' or
+                    (status == 'D' and not transitional) or
+                    (status == '3' and not std3_rules and replacement is None)):
+                output += char
+            elif replacement is not None and (status == 'M' or
+                    (status == '3' and not std3_rules) or
+                    (status == 'D' and transitional)):
+                output += replacement
+            elif status != 'I':
+                raise IndexError()
+        except IndexError:
+            raise InvalidCodepoint(
+                'Codepoint {} not allowed at position {} in {}'.format(
+                _unot(code_point), pos + 1, repr(domain)))
+
+    return unicodedata.normalize('NFC', output)
+
+
+def encode(s: Union[str, bytes, bytearray], strict: bool = False, uts46: bool = False, std3_rules: bool = False, transitional: bool = False) -> bytes:
+    if not isinstance(s, str):
+        try:
+            s = str(s, 'ascii')
+        except UnicodeDecodeError:
+            raise IDNAError('should pass a unicode string to the function rather than a byte string.')
+    if uts46:
+        s = uts46_remap(s, std3_rules, transitional)
+    trailing_dot = False
+    result = []
+    if strict:
+        labels = s.split('.')
+    else:
+        labels = _unicode_dots_re.split(s)
+    if not labels or labels == ['']:
+        raise IDNAError('Empty domain')
+    if labels[-1] == '':
+        del labels[-1]
+        trailing_dot = True
+    for label in labels:
+        s = alabel(label)
+        if s:
+            result.append(s)
+        else:
+            raise IDNAError('Empty label')
+    if trailing_dot:
+        result.append(b'')
+    s = b'.'.join(result)
+    if not valid_string_length(s, trailing_dot):
+        raise IDNAError('Domain too long')
+    return s
+
+
+def decode(s: Union[str, bytes, bytearray], strict: bool = False, uts46: bool = False, std3_rules: bool = False) -> str:
+    try:
+        if not isinstance(s, str):
+            s = str(s, 'ascii')
+    except UnicodeDecodeError:
+        raise IDNAError('Invalid ASCII in A-label')
+    if uts46:
+        s = uts46_remap(s, std3_rules, False)
+    trailing_dot = False
+    result = []
+    if not strict:
+        labels = _unicode_dots_re.split(s)
+    else:
+        labels = s.split('.')
+    if not labels or labels == ['']:
+        raise IDNAError('Empty domain')
+    if not labels[-1]:
+        del labels[-1]
+        trailing_dot = True
+    for label in labels:
+        s = ulabel(label)
+        if s:
+            result.append(s)
+        else:
+            raise IDNAError('Empty label')
+    if trailing_dot:
+        result.append('')
+    return '.'.join(result)
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/idna/idnadata.py b/venv/lib/python3.12/site-packages/pip/_vendor/idna/idnadata.py
new file mode 100644
index 00000000..c61dcf97
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_vendor/idna/idnadata.py
@@ -0,0 +1,4245 @@
+# This file is automatically generated by tools/idna-data
+
+__version__ = '15.1.0'
+scripts = {
+    'Greek': (
+        0x37000000374,
+        0x37500000378,
+        0x37a0000037e,
+        0x37f00000380,
+        0x38400000385,
+        0x38600000387,
+        0x3880000038b,
+        0x38c0000038d,
+        0x38e000003a2,
+        0x3a3000003e2,
+        0x3f000000400,
+        0x1d2600001d2b,
+        0x1d5d00001d62,
+        0x1d6600001d6b,
+        0x1dbf00001dc0,
+        0x1f0000001f16,
+        0x1f1800001f1e,
+        0x1f2000001f46,
+        0x1f4800001f4e,
+        0x1f5000001f58,
+        0x1f5900001f5a,
+        0x1f5b00001f5c,
+        0x1f5d00001f5e,
+        0x1f5f00001f7e,
+        0x1f8000001fb5,
+        0x1fb600001fc5,
+        0x1fc600001fd4,
+        0x1fd600001fdc,
+        0x1fdd00001ff0,
+        0x1ff200001ff5,
+        0x1ff600001fff,
+        0x212600002127,
+        0xab650000ab66,
+        0x101400001018f,
+        0x101a0000101a1,
+        0x1d2000001d246,
+    ),
+    'Han': (
+        0x2e8000002e9a,
+        0x2e9b00002ef4,
+        0x2f0000002fd6,
+        0x300500003006,
+        0x300700003008,
+        0x30210000302a,
+        0x30380000303c,
+        0x340000004dc0,
+        0x4e000000a000,
+        0xf9000000fa6e,
+        0xfa700000fada,
+        0x16fe200016fe4,
+        0x16ff000016ff2,
+        0x200000002a6e0,
+        0x2a7000002b73a,
+        0x2b7400002b81e,
+        0x2b8200002cea2,
+        0x2ceb00002ebe1,
+        0x2ebf00002ee5e,
+        0x2f8000002fa1e,
+        0x300000003134b,
+        0x31350000323b0,
+    ),
+    'Hebrew': (
+        0x591000005c8,
+        0x5d0000005eb,
+        0x5ef000005f5,
+        0xfb1d0000fb37,
+        0xfb380000fb3d,
+        0xfb3e0000fb3f,
+        0xfb400000fb42,
+        0xfb430000fb45,
+        0xfb460000fb50,
+    ),
+    'Hiragana': (
+        0x304100003097,
+        0x309d000030a0,
+        0x1b0010001b120,
+        0x1b1320001b133,
+        0x1b1500001b153,
+        0x1f2000001f201,
+    ),
+    'Katakana': (
+        0x30a1000030fb,
+        0x30fd00003100,
+        0x31f000003200,
+        0x32d0000032ff,
+        0x330000003358,
+        0xff660000ff70,
+        0xff710000ff9e,
+        0x1aff00001aff4,
+        0x1aff50001affc,
+        0x1affd0001afff,
+        0x1b0000001b001,
+        0x1b1200001b123,
+        0x1b1550001b156,
+        0x1b1640001b168,
+    ),
+}
+joining_types = {
+    0xad: 84,
+    0x300: 84,
+    0x301: 84,
+    0x302: 84,
+    0x303: 84,
+    0x304: 84,
+    0x305: 84,
+    0x306: 84,
+    0x307: 84,
+    0x308: 84,
+    0x309: 84,
+    0x30a: 84,
+    0x30b: 84,
+    0x30c: 84,
+    0x30d: 84,
+    0x30e: 84,
+    0x30f: 84,
+    0x310: 84,
+    0x311: 84,
+    0x312: 84,
+    0x313: 84,
+    0x314: 84,
+    0x315: 84,
+    0x316: 84,
+    0x317: 84,
+    0x318: 84,
+    0x319: 84,
+    0x31a: 84,
+    0x31b: 84,
+    0x31c: 84,
+    0x31d: 84,
+    0x31e: 84,
+    0x31f: 84,
+    0x320: 84,
+    0x321: 84,
+    0x322: 84,
+    0x323: 84,
+    0x324: 84,
+    0x325: 84,
+    0x326: 84,
+    0x327: 84,
+    0x328: 84,
+    0x329: 84,
+    0x32a: 84,
+    0x32b: 84,
+    0x32c: 84,
+    0x32d: 84,
+    0x32e: 84,
+    0x32f: 84,
+    0x330: 84,
+    0x331: 84,
+    0x332: 84,
+    0x333: 84,
+    0x334: 84,
+    0x335: 84,
+    0x336: 84,
+    0x337: 84,
+    0x338: 84,
+    0x339: 84,
+    0x33a: 84,
+    0x33b: 84,
+    0x33c: 84,
+    0x33d: 84,
+    0x33e: 84,
+    0x33f: 84,
+    0x340: 84,
+    0x341: 84,
+    0x342: 84,
+    0x343: 84,
+    0x344: 84,
+    0x345: 84,
+    0x346: 84,
+    0x347: 84,
+    0x348: 84,
+    0x349: 84,
+    0x34a: 84,
+    0x34b: 84,
+    0x34c: 84,
+    0x34d: 84,
+    0x34e: 84,
+    0x34f: 84,
+    0x350: 84,
+    0x351: 84,
+    0x352: 84,
+    0x353: 84,
+    0x354: 84,
+    0x355: 84,
+    0x356: 84,
+    0x357: 84,
+    0x358: 84,
+    0x359: 84,
+    0x35a: 84,
+    0x35b: 84,
+    0x35c: 84,
+    0x35d: 84,
+    0x35e: 84,
+    0x35f: 84,
+    0x360: 84,
+    0x361: 84,
+    0x362: 84,
+    0x363: 84,
+    0x364: 84,
+    0x365: 84,
+    0x366: 84,
+    0x367: 84,
+    0x368: 84,
+    0x369: 84,
+    0x36a: 84,
+    0x36b: 84,
+    0x36c: 84,
+    0x36d: 84,
+    0x36e: 84,
+    0x36f: 84,
+    0x483: 84,
+    0x484: 84,
+    0x485: 84,
+    0x486: 84,
+    0x487: 84,
+    0x488: 84,
+    0x489: 84,
+    0x591: 84,
+    0x592: 84,
+    0x593: 84,
+    0x594: 84,
+    0x595: 84,
+    0x596: 84,
+    0x597: 84,
+    0x598: 84,
+    0x599: 84,
+    0x59a: 84,
+    0x59b: 84,
+    0x59c: 84,
+    0x59d: 84,
+    0x59e: 84,
+    0x59f: 84,
+    0x5a0: 84,
+    0x5a1: 84,
+    0x5a2: 84,
+    0x5a3: 84,
+    0x5a4: 84,
+    0x5a5: 84,
+    0x5a6: 84,
+    0x5a7: 84,
+    0x5a8: 84,
+    0x5a9: 84,
+    0x5aa: 84,
+    0x5ab: 84,
+    0x5ac: 84,
+    0x5ad: 84,
+    0x5ae: 84,
+    0x5af: 84,
+    0x5b0: 84,
+    0x5b1: 84,
+    0x5b2: 84,
+    0x5b3: 84,
+    0x5b4: 84,
+    0x5b5: 84,
+    0x5b6: 84,
+    0x5b7: 84,
+    0x5b8: 84,
+    0x5b9: 84,
+    0x5ba: 84,
+    0x5bb: 84,
+    0x5bc: 84,
+    0x5bd: 84,
+    0x5bf: 84,
+    0x5c1: 84,
+    0x5c2: 84,
+    0x5c4: 84,
+    0x5c5: 84,
+    0x5c7: 84,
+    0x610: 84,
+    0x611: 84,
+    0x612: 84,
+    0x613: 84,
+    0x614: 84,
+    0x615: 84,
+    0x616: 84,
+    0x617: 84,
+    0x618: 84,
+    0x619: 84,
+    0x61a: 84,
+    0x61c: 84,
+    0x620: 68,
+    0x622: 82,
+    0x623: 82,
+    0x624: 82,
+    0x625: 82,
+    0x626: 68,
+    0x627: 82,
+    0x628: 68,
+    0x629: 82,
+    0x62a: 68,
+    0x62b: 68,
+    0x62c: 68,
+    0x62d: 68,
+    0x62e: 68,
+    0x62f: 82,
+    0x630: 82,
+    0x631: 82,
+    0x632: 82,
+    0x633: 68,
+    0x634: 68,
+    0x635: 68,
+    0x636: 68,
+    0x637: 68,
+    0x638: 68,
+    0x639: 68,
+    0x63a: 68,
+    0x63b: 68,
+    0x63c: 68,
+    0x63d: 68,
+    0x63e: 68,
+    0x63f: 68,
+    0x640: 67,
+    0x641: 68,
+    0x642: 68,
+    0x643: 68,
+    0x644: 68,
+    0x645: 68,
+    0x646: 68,
+    0x647: 68,
+    0x648: 82,
+    0x649: 68,
+    0x64a: 68,
+    0x64b: 84,
+    0x64c: 84,
+    0x64d: 84,
+    0x64e: 84,
+    0x64f: 84,
+    0x650: 84,
+    0x651: 84,
+    0x652: 84,
+    0x653: 84,
+    0x654: 84,
+    0x655: 84,
+    0x656: 84,
+    0x657: 84,
+    0x658: 84,
+    0x659: 84,
+    0x65a: 84,
+    0x65b: 84,
+    0x65c: 84,
+    0x65d: 84,
+    0x65e: 84,
+    0x65f: 84,
+    0x66e: 68,
+    0x66f: 68,
+    0x670: 84,
+    0x671: 82,
+    0x672: 82,
+    0x673: 82,
+    0x675: 82,
+    0x676: 82,
+    0x677: 82,
+    0x678: 68,
+    0x679: 68,
+    0x67a: 68,
+    0x67b: 68,
+    0x67c: 68,
+    0x67d: 68,
+    0x67e: 68,
+    0x67f: 68,
+    0x680: 68,
+    0x681: 68,
+    0x682: 68,
+    0x683: 68,
+    0x684: 68,
+    0x685: 68,
+    0x686: 68,
+    0x687: 68,
+    0x688: 82,
+    0x689: 82,
+    0x68a: 82,
+    0x68b: 82,
+    0x68c: 82,
+    0x68d: 82,
+    0x68e: 82,
+    0x68f: 82,
+    0x690: 82,
+    0x691: 82,
+    0x692: 82,
+    0x693: 82,
+    0x694: 82,
+    0x695: 82,
+    0x696: 82,
+    0x697: 82,
+    0x698: 82,
+    0x699: 82,
+    0x69a: 68,
+    0x69b: 68,
+    0x69c: 68,
+    0x69d: 68,
+    0x69e: 68,
+    0x69f: 68,
+    0x6a0: 68,
+    0x6a1: 68,
+    0x6a2: 68,
+    0x6a3: 68,
+    0x6a4: 68,
+    0x6a5: 68,
+    0x6a6: 68,
+    0x6a7: 68,
+    0x6a8: 68,
+    0x6a9: 68,
+    0x6aa: 68,
+    0x6ab: 68,
+    0x6ac: 68,
+    0x6ad: 68,
+    0x6ae: 68,
+    0x6af: 68,
+    0x6b0: 68,
+    0x6b1: 68,
+    0x6b2: 68,
+    0x6b3: 68,
+    0x6b4: 68,
+    0x6b5: 68,
+    0x6b6: 68,
+    0x6b7: 68,
+    0x6b8: 68,
+    0x6b9: 68,
+    0x6ba: 68,
+    0x6bb: 68,
+    0x6bc: 68,
+    0x6bd: 68,
+    0x6be: 68,
+    0x6bf: 68,
+    0x6c0: 82,
+    0x6c1: 68,
+    0x6c2: 68,
+    0x6c3: 82,
+    0x6c4: 82,
+    0x6c5: 82,
+    0x6c6: 82,
+    0x6c7: 82,
+    0x6c8: 82,
+    0x6c9: 82,
+    0x6ca: 82,
+    0x6cb: 82,
+    0x6cc: 68,
+    0x6cd: 82,
+    0x6ce: 68,
+    0x6cf: 82,
+    0x6d0: 68,
+    0x6d1: 68,
+    0x6d2: 82,
+    0x6d3: 82,
+    0x6d5: 82,
+    0x6d6: 84,
+    0x6d7: 84,
+    0x6d8: 84,
+    0x6d9: 84,
+    0x6da: 84,
+    0x6db: 84,
+    0x6dc: 84,
+    0x6df: 84,
+    0x6e0: 84,
+    0x6e1: 84,
+    0x6e2: 84,
+    0x6e3: 84,
+    0x6e4: 84,
+    0x6e7: 84,
+    0x6e8: 84,
+    0x6ea: 84,
+    0x6eb: 84,
+    0x6ec: 84,
+    0x6ed: 84,
+    0x6ee: 82,
+    0x6ef: 82,
+    0x6fa: 68,
+    0x6fb: 68,
+    0x6fc: 68,
+    0x6ff: 68,
+    0x70f: 84,
+    0x710: 82,
+    0x711: 84,
+    0x712: 68,
+    0x713: 68,
+    0x714: 68,
+    0x715: 82,
+    0x716: 82,
+    0x717: 82,
+    0x718: 82,
+    0x719: 82,
+    0x71a: 68,
+    0x71b: 68,
+    0x71c: 68,
+    0x71d: 68,
+    0x71e: 82,
+    0x71f: 68,
+    0x720: 68,
+    0x721: 68,
+    0x722: 68,
+    0x723: 68,
+    0x724: 68,
+    0x725: 68,
+    0x726: 68,
+    0x727: 68,
+    0x728: 82,
+    0x729: 68,
+    0x72a: 82,
+    0x72b: 68,
+    0x72c: 82,
+    0x72d: 68,
+    0x72e: 68,
+    0x72f: 82,
+    0x730: 84,
+    0x731: 84,
+    0x732: 84,
+    0x733: 84,
+    0x734: 84,
+    0x735: 84,
+    0x736: 84,
+    0x737: 84,
+    0x738: 84,
+    0x739: 84,
+    0x73a: 84,
+    0x73b: 84,
+    0x73c: 84,
+    0x73d: 84,
+    0x73e: 84,
+    0x73f: 84,
+    0x740: 84,
+    0x741: 84,
+    0x742: 84,
+    0x743: 84,
+    0x744: 84,
+    0x745: 84,
+    0x746: 84,
+    0x747: 84,
+    0x748: 84,
+    0x749: 84,
+    0x74a: 84,
+    0x74d: 82,
+    0x74e: 68,
+    0x74f: 68,
+    0x750: 68,
+    0x751: 68,
+    0x752: 68,
+    0x753: 68,
+    0x754: 68,
+    0x755: 68,
+    0x756: 68,
+    0x757: 68,
+    0x758: 68,
+    0x759: 82,
+    0x75a: 82,
+    0x75b: 82,
+    0x75c: 68,
+    0x75d: 68,
+    0x75e: 68,
+    0x75f: 68,
+    0x760: 68,
+    0x761: 68,
+    0x762: 68,
+    0x763: 68,
+    0x764: 68,
+    0x765: 68,
+    0x766: 68,
+    0x767: 68,
+    0x768: 68,
+    0x769: 68,
+    0x76a: 68,
+    0x76b: 82,
+    0x76c: 82,
+    0x76d: 68,
+    0x76e: 68,
+    0x76f: 68,
+    0x770: 68,
+    0x771: 82,
+    0x772: 68,
+    0x773: 82,
+    0x774: 82,
+    0x775: 68,
+    0x776: 68,
+    0x777: 68,
+    0x778: 82,
+    0x779: 82,
+    0x77a: 68,
+    0x77b: 68,
+    0x77c: 68,
+    0x77d: 68,
+    0x77e: 68,
+    0x77f: 68,
+    0x7a6: 84,
+    0x7a7: 84,
+    0x7a8: 84,
+    0x7a9: 84,
+    0x7aa: 84,
+    0x7ab: 84,
+    0x7ac: 84,
+    0x7ad: 84,
+    0x7ae: 84,
+    0x7af: 84,
+    0x7b0: 84,
+    0x7ca: 68,
+    0x7cb: 68,
+    0x7cc: 68,
+    0x7cd: 68,
+    0x7ce: 68,
+    0x7cf: 68,
+    0x7d0: 68,
+    0x7d1: 68,
+    0x7d2: 68,
+    0x7d3: 68,
+    0x7d4: 68,
+    0x7d5: 68,
+    0x7d6: 68,
+    0x7d7: 68,
+    0x7d8: 68,
+    0x7d9: 68,
+    0x7da: 68,
+    0x7db: 68,
+    0x7dc: 68,
+    0x7dd: 68,
+    0x7de: 68,
+    0x7df: 68,
+    0x7e0: 68,
+    0x7e1: 68,
+    0x7e2: 68,
+    0x7e3: 68,
+    0x7e4: 68,
+    0x7e5: 68,
+    0x7e6: 68,
+    0x7e7: 68,
+    0x7e8: 68,
+    0x7e9: 68,
+    0x7ea: 68,
+    0x7eb: 84,
+    0x7ec: 84,
+    0x7ed: 84,
+    0x7ee: 84,
+    0x7ef: 84,
+    0x7f0: 84,
+    0x7f1: 84,
+    0x7f2: 84,
+    0x7f3: 84,
+    0x7fa: 67,
+    0x7fd: 84,
+    0x816: 84,
+    0x817: 84,
+    0x818: 84,
+    0x819: 84,
+    0x81b: 84,
+    0x81c: 84,
+    0x81d: 84,
+    0x81e: 84,
+    0x81f: 84,
+    0x820: 84,
+    0x821: 84,
+    0x822: 84,
+    0x823: 84,
+    0x825: 84,
+    0x826: 84,
+    0x827: 84,
+    0x829: 84,
+    0x82a: 84,
+    0x82b: 84,
+    0x82c: 84,
+    0x82d: 84,
+    0x840: 82,
+    0x841: 68,
+    0x842: 68,
+    0x843: 68,
+    0x844: 68,
+    0x845: 68,
+    0x846: 82,
+    0x847: 82,
+    0x848: 68,
+    0x849: 82,
+    0x84a: 68,
+    0x84b: 68,
+    0x84c: 68,
+    0x84d: 68,
+    0x84e: 68,
+    0x84f: 68,
+    0x850: 68,
+    0x851: 68,
+    0x852: 68,
+    0x853: 68,
+    0x854: 82,
+    0x855: 68,
+    0x856: 82,
+    0x857: 82,
+    0x858: 82,
+    0x859: 84,
+    0x85a: 84,
+    0x85b: 84,
+    0x860: 68,
+    0x862: 68,
+    0x863: 68,
+    0x864: 68,
+    0x865: 68,
+    0x867: 82,
+    0x868: 68,
+    0x869: 82,
+    0x86a: 82,
+    0x870: 82,
+    0x871: 82,
+    0x872: 82,
+    0x873: 82,
+    0x874: 82,
+    0x875: 82,
+    0x876: 82,
+    0x877: 82,
+    0x878: 82,
+    0x879: 82,
+    0x87a: 82,
+    0x87b: 82,
+    0x87c: 82,
+    0x87d: 82,
+    0x87e: 82,
+    0x87f: 82,
+    0x880: 82,
+    0x881: 82,
+    0x882: 82,
+    0x883: 67,
+    0x884: 67,
+    0x885: 67,
+    0x886: 68,
+    0x889: 68,
+    0x88a: 68,
+    0x88b: 68,
+    0x88c: 68,
+    0x88d: 68,
+    0x88e: 82,
+    0x898: 84,
+    0x899: 84,
+    0x89a: 84,
+    0x89b: 84,
+    0x89c: 84,
+    0x89d: 84,
+    0x89e: 84,
+    0x89f: 84,
+    0x8a0: 68,
+    0x8a1: 68,
+    0x8a2: 68,
+    0x8a3: 68,
+    0x8a4: 68,
+    0x8a5: 68,
+    0x8a6: 68,
+    0x8a7: 68,
+    0x8a8: 68,
+    0x8a9: 68,
+    0x8aa: 82,
+    0x8ab: 82,
+    0x8ac: 82,
+    0x8ae: 82,
+    0x8af: 68,
+    0x8b0: 68,
+    0x8b1: 82,
+    0x8b2: 82,
+    0x8b3: 68,
+    0x8b4: 68,
+    0x8b5: 68,
+    0x8b6: 68,
+    0x8b7: 68,
+    0x8b8: 68,
+    0x8b9: 82,
+    0x8ba: 68,
+    0x8bb: 68,
+    0x8bc: 68,
+    0x8bd: 68,
+    0x8be: 68,
+    0x8bf: 68,
+    0x8c0: 68,
+    0x8c1: 68,
+    0x8c2: 68,
+    0x8c3: 68,
+    0x8c4: 68,
+    0x8c5: 68,
+    0x8c6: 68,
+    0x8c7: 68,
+    0x8c8: 68,
+    0x8ca: 84,
+    0x8cb: 84,
+    0x8cc: 84,
+    0x8cd: 84,
+    0x8ce: 84,
+    0x8cf: 84,
+    0x8d0: 84,
+    0x8d1: 84,
+    0x8d2: 84,
+    0x8d3: 84,
+    0x8d4: 84,
+    0x8d5: 84,
+    0x8d6: 84,
+    0x8d7: 84,
+    0x8d8: 84,
+    0x8d9: 84,
+    0x8da: 84,
+    0x8db: 84,
+    0x8dc: 84,
+    0x8dd: 84,
+    0x8de: 84,
+    0x8df: 84,
+    0x8e0: 84,
+    0x8e1: 84,
+    0x8e3: 84,
+    0x8e4: 84,
+    0x8e5: 84,
+    0x8e6: 84,
+    0x8e7: 84,
+    0x8e8: 84,
+    0x8e9: 84,
+    0x8ea: 84,
+    0x8eb: 84,
+    0x8ec: 84,
+    0x8ed: 84,
+    0x8ee: 84,
+    0x8ef: 84,
+    0x8f0: 84,
+    0x8f1: 84,
+    0x8f2: 84,
+    0x8f3: 84,
+    0x8f4: 84,
+    0x8f5: 84,
+    0x8f6: 84,
+    0x8f7: 84,
+    0x8f8: 84,
+    0x8f9: 84,
+    0x8fa: 84,
+    0x8fb: 84,
+    0x8fc: 84,
+    0x8fd: 84,
+    0x8fe: 84,
+    0x8ff: 84,
+    0x900: 84,
+    0x901: 84,
+    0x902: 84,
+    0x93a: 84,
+    0x93c: 84,
+    0x941: 84,
+    0x942: 84,
+    0x943: 84,
+    0x944: 84,
+    0x945: 84,
+    0x946: 84,
+    0x947: 84,
+    0x948: 84,
+    0x94d: 84,
+    0x951: 84,
+    0x952: 84,
+    0x953: 84,
+    0x954: 84,
+    0x955: 84,
+    0x956: 84,
+    0x957: 84,
+    0x962: 84,
+    0x963: 84,
+    0x981: 84,
+    0x9bc: 84,
+    0x9c1: 84,
+    0x9c2: 84,
+    0x9c3: 84,
+    0x9c4: 84,
+    0x9cd: 84,
+    0x9e2: 84,
+    0x9e3: 84,
+    0x9fe: 84,
+    0xa01: 84,
+    0xa02: 84,
+    0xa3c: 84,
+    0xa41: 84,
+    0xa42: 84,
+    0xa47: 84,
+    0xa48: 84,
+    0xa4b: 84,
+    0xa4c: 84,
+    0xa4d: 84,
+    0xa51: 84,
+    0xa70: 84,
+    0xa71: 84,
+    0xa75: 84,
+    0xa81: 84,
+    0xa82: 84,
+    0xabc: 84,
+    0xac1: 84,
+    0xac2: 84,
+    0xac3: 84,
+    0xac4: 84,
+    0xac5: 84,
+    0xac7: 84,
+    0xac8: 84,
+    0xacd: 84,
+    0xae2: 84,
+    0xae3: 84,
+    0xafa: 84,
+    0xafb: 84,
+    0xafc: 84,
+    0xafd: 84,
+    0xafe: 84,
+    0xaff: 84,
+    0xb01: 84,
+    0xb3c: 84,
+    0xb3f: 84,
+    0xb41: 84,
+    0xb42: 84,
+    0xb43: 84,
+    0xb44: 84,
+    0xb4d: 84,
+    0xb55: 84,
+    0xb56: 84,
+    0xb62: 84,
+    0xb63: 84,
+    0xb82: 84,
+    0xbc0: 84,
+    0xbcd: 84,
+    0xc00: 84,
+    0xc04: 84,
+    0xc3c: 84,
+    0xc3e: 84,
+    0xc3f: 84,
+    0xc40: 84,
+    0xc46: 84,
+    0xc47: 84,
+    0xc48: 84,
+    0xc4a: 84,
+    0xc4b: 84,
+    0xc4c: 84,
+    0xc4d: 84,
+    0xc55: 84,
+    0xc56: 84,
+    0xc62: 84,
+    0xc63: 84,
+    0xc81: 84,
+    0xcbc: 84,
+    0xcbf: 84,
+    0xcc6: 84,
+    0xccc: 84,
+    0xccd: 84,
+    0xce2: 84,
+    0xce3: 84,
+    0xd00: 84,
+    0xd01: 84,
+    0xd3b: 84,
+    0xd3c: 84,
+    0xd41: 84,
+    0xd42: 84,
+    0xd43: 84,
+    0xd44: 84,
+    0xd4d: 84,
+    0xd62: 84,
+    0xd63: 84,
+    0xd81: 84,
+    0xdca: 84,
+    0xdd2: 84,
+    0xdd3: 84,
+    0xdd4: 84,
+    0xdd6: 84,
+    0xe31: 84,
+    0xe34: 84,
+    0xe35: 84,
+    0xe36: 84,
+    0xe37: 84,
+    0xe38: 84,
+    0xe39: 84,
+    0xe3a: 84,
+    0xe47: 84,
+    0xe48: 84,
+    0xe49: 84,
+    0xe4a: 84,
+    0xe4b: 84,
+    0xe4c: 84,
+    0xe4d: 84,
+    0xe4e: 84,
+    0xeb1: 84,
+    0xeb4: 84,
+    0xeb5: 84,
+    0xeb6: 84,
+    0xeb7: 84,
+    0xeb8: 84,
+    0xeb9: 84,
+    0xeba: 84,
+    0xebb: 84,
+    0xebc: 84,
+    0xec8: 84,
+    0xec9: 84,
+    0xeca: 84,
+    0xecb: 84,
+    0xecc: 84,
+    0xecd: 84,
+    0xece: 84,
+    0xf18: 84,
+    0xf19: 84,
+    0xf35: 84,
+    0xf37: 84,
+    0xf39: 84,
+    0xf71: 84,
+    0xf72: 84,
+    0xf73: 84,
+    0xf74: 84,
+    0xf75: 84,
+    0xf76: 84,
+    0xf77: 84,
+    0xf78: 84,
+    0xf79: 84,
+    0xf7a: 84,
+    0xf7b: 84,
+    0xf7c: 84,
+    0xf7d: 84,
+    0xf7e: 84,
+    0xf80: 84,
+    0xf81: 84,
+    0xf82: 84,
+    0xf83: 84,
+    0xf84: 84,
+    0xf86: 84,
+    0xf87: 84,
+    0xf8d: 84,
+    0xf8e: 84,
+    0xf8f: 84,
+    0xf90: 84,
+    0xf91: 84,
+    0xf92: 84,
+    0xf93: 84,
+    0xf94: 84,
+    0xf95: 84,
+    0xf96: 84,
+    0xf97: 84,
+    0xf99: 84,
+    0xf9a: 84,
+    0xf9b: 84,
+    0xf9c: 84,
+    0xf9d: 84,
+    0xf9e: 84,
+    0xf9f: 84,
+    0xfa0: 84,
+    0xfa1: 84,
+    0xfa2: 84,
+    0xfa3: 84,
+    0xfa4: 84,
+    0xfa5: 84,
+    0xfa6: 84,
+    0xfa7: 84,
+    0xfa8: 84,
+    0xfa9: 84,
+    0xfaa: 84,
+    0xfab: 84,
+    0xfac: 84,
+    0xfad: 84,
+    0xfae: 84,
+    0xfaf: 84,
+    0xfb0: 84,
+    0xfb1: 84,
+    0xfb2: 84,
+    0xfb3: 84,
+    0xfb4: 84,
+    0xfb5: 84,
+    0xfb6: 84,
+    0xfb7: 84,
+    0xfb8: 84,
+    0xfb9: 84,
+    0xfba: 84,
+    0xfbb: 84,
+    0xfbc: 84,
+    0xfc6: 84,
+    0x102d: 84,
+    0x102e: 84,
+    0x102f: 84,
+    0x1030: 84,
+    0x1032: 84,
+    0x1033: 84,
+    0x1034: 84,
+    0x1035: 84,
+    0x1036: 84,
+    0x1037: 84,
+    0x1039: 84,
+    0x103a: 84,
+    0x103d: 84,
+    0x103e: 84,
+    0x1058: 84,
+    0x1059: 84,
+    0x105e: 84,
+    0x105f: 84,
+    0x1060: 84,
+    0x1071: 84,
+    0x1072: 84,
+    0x1073: 84,
+    0x1074: 84,
+    0x1082: 84,
+    0x1085: 84,
+    0x1086: 84,
+    0x108d: 84,
+    0x109d: 84,
+    0x135d: 84,
+    0x135e: 84,
+    0x135f: 84,
+    0x1712: 84,
+    0x1713: 84,
+    0x1714: 84,
+    0x1732: 84,
+    0x1733: 84,
+    0x1752: 84,
+    0x1753: 84,
+    0x1772: 84,
+    0x1773: 84,
+    0x17b4: 84,
+    0x17b5: 84,
+    0x17b7: 84,
+    0x17b8: 84,
+    0x17b9: 84,
+    0x17ba: 84,
+    0x17bb: 84,
+    0x17bc: 84,
+    0x17bd: 84,
+    0x17c6: 84,
+    0x17c9: 84,
+    0x17ca: 84,
+    0x17cb: 84,
+    0x17cc: 84,
+    0x17cd: 84,
+    0x17ce: 84,
+    0x17cf: 84,
+    0x17d0: 84,
+    0x17d1: 84,
+    0x17d2: 84,
+    0x17d3: 84,
+    0x17dd: 84,
+    0x1807: 68,
+    0x180a: 67,
+    0x180b: 84,
+    0x180c: 84,
+    0x180d: 84,
+    0x180f: 84,
+    0x1820: 68,
+    0x1821: 68,
+    0x1822: 68,
+    0x1823: 68,
+    0x1824: 68,
+    0x1825: 68,
+    0x1826: 68,
+    0x1827: 68,
+    0x1828: 68,
+    0x1829: 68,
+    0x182a: 68,
+    0x182b: 68,
+    0x182c: 68,
+    0x182d: 68,
+    0x182e: 68,
+    0x182f: 68,
+    0x1830: 68,
+    0x1831: 68,
+    0x1832: 68,
+    0x1833: 68,
+    0x1834: 68,
+    0x1835: 68,
+    0x1836: 68,
+    0x1837: 68,
+    0x1838: 68,
+    0x1839: 68,
+    0x183a: 68,
+    0x183b: 68,
+    0x183c: 68,
+    0x183d: 68,
+    0x183e: 68,
+    0x183f: 68,
+    0x1840: 68,
+    0x1841: 68,
+    0x1842: 68,
+    0x1843: 68,
+    0x1844: 68,
+    0x1845: 68,
+    0x1846: 68,
+    0x1847: 68,
+    0x1848: 68,
+    0x1849: 68,
+    0x184a: 68,
+    0x184b: 68,
+    0x184c: 68,
+    0x184d: 68,
+    0x184e: 68,
+    0x184f: 68,
+    0x1850: 68,
+    0x1851: 68,
+    0x1852: 68,
+    0x1853: 68,
+    0x1854: 68,
+    0x1855: 68,
+    0x1856: 68,
+    0x1857: 68,
+    0x1858: 68,
+    0x1859: 68,
+    0x185a: 68,
+    0x185b: 68,
+    0x185c: 68,
+    0x185d: 68,
+    0x185e: 68,
+    0x185f: 68,
+    0x1860: 68,
+    0x1861: 68,
+    0x1862: 68,
+    0x1863: 68,
+    0x1864: 68,
+    0x1865: 68,
+    0x1866: 68,
+    0x1867: 68,
+    0x1868: 68,
+    0x1869: 68,
+    0x186a: 68,
+    0x186b: 68,
+    0x186c: 68,
+    0x186d: 68,
+    0x186e: 68,
+    0x186f: 68,
+    0x1870: 68,
+    0x1871: 68,
+    0x1872: 68,
+    0x1873: 68,
+    0x1874: 68,
+    0x1875: 68,
+    0x1876: 68,
+    0x1877: 68,
+    0x1878: 68,
+    0x1885: 84,
+    0x1886: 84,
+    0x1887: 68,
+    0x1888: 68,
+    0x1889: 68,
+    0x188a: 68,
+    0x188b: 68,
+    0x188c: 68,
+    0x188d: 68,
+    0x188e: 68,
+    0x188f: 68,
+    0x1890: 68,
+    0x1891: 68,
+    0x1892: 68,
+    0x1893: 68,
+    0x1894: 68,
+    0x1895: 68,
+    0x1896: 68,
+    0x1897: 68,
+    0x1898: 68,
+    0x1899: 68,
+    0x189a: 68,
+    0x189b: 68,
+    0x189c: 68,
+    0x189d: 68,
+    0x189e: 68,
+    0x189f: 68,
+    0x18a0: 68,
+    0x18a1: 68,
+    0x18a2: 68,
+    0x18a3: 68,
+    0x18a4: 68,
+    0x18a5: 68,
+    0x18a6: 68,
+    0x18a7: 68,
+    0x18a8: 68,
+    0x18a9: 84,
+    0x18aa: 68,
+    0x1920: 84,
+    0x1921: 84,
+    0x1922: 84,
+    0x1927: 84,
+    0x1928: 84,
+    0x1932: 84,
+    0x1939: 84,
+    0x193a: 84,
+    0x193b: 84,
+    0x1a17: 84,
+    0x1a18: 84,
+    0x1a1b: 84,
+    0x1a56: 84,
+    0x1a58: 84,
+    0x1a59: 84,
+    0x1a5a: 84,
+    0x1a5b: 84,
+    0x1a5c: 84,
+    0x1a5d: 84,
+    0x1a5e: 84,
+    0x1a60: 84,
+    0x1a62: 84,
+    0x1a65: 84,
+    0x1a66: 84,
+    0x1a67: 84,
+    0x1a68: 84,
+    0x1a69: 84,
+    0x1a6a: 84,
+    0x1a6b: 84,
+    0x1a6c: 84,
+    0x1a73: 84,
+    0x1a74: 84,
+    0x1a75: 84,
+    0x1a76: 84,
+    0x1a77: 84,
+    0x1a78: 84,
+    0x1a79: 84,
+    0x1a7a: 84,
+    0x1a7b: 84,
+    0x1a7c: 84,
+    0x1a7f: 84,
+    0x1ab0: 84,
+    0x1ab1: 84,
+    0x1ab2: 84,
+    0x1ab3: 84,
+    0x1ab4: 84,
+    0x1ab5: 84,
+    0x1ab6: 84,
+    0x1ab7: 84,
+    0x1ab8: 84,
+    0x1ab9: 84,
+    0x1aba: 84,
+    0x1abb: 84,
+    0x1abc: 84,
+    0x1abd: 84,
+    0x1abe: 84,
+    0x1abf: 84,
+    0x1ac0: 84,
+    0x1ac1: 84,
+    0x1ac2: 84,
+    0x1ac3: 84,
+    0x1ac4: 84,
+    0x1ac5: 84,
+    0x1ac6: 84,
+    0x1ac7: 84,
+    0x1ac8: 84,
+    0x1ac9: 84,
+    0x1aca: 84,
+    0x1acb: 84,
+    0x1acc: 84,
+    0x1acd: 84,
+    0x1ace: 84,
+    0x1b00: 84,
+    0x1b01: 84,
+    0x1b02: 84,
+    0x1b03: 84,
+    0x1b34: 84,
+    0x1b36: 84,
+    0x1b37: 84,
+    0x1b38: 84,
+    0x1b39: 84,
+    0x1b3a: 84,
+    0x1b3c: 84,
+    0x1b42: 84,
+    0x1b6b: 84,
+    0x1b6c: 84,
+    0x1b6d: 84,
+    0x1b6e: 84,
+    0x1b6f: 84,
+    0x1b70: 84,
+    0x1b71: 84,
+    0x1b72: 84,
+    0x1b73: 84,
+    0x1b80: 84,
+    0x1b81: 84,
+    0x1ba2: 84,
+    0x1ba3: 84,
+    0x1ba4: 84,
+    0x1ba5: 84,
+    0x1ba8: 84,
+    0x1ba9: 84,
+    0x1bab: 84,
+    0x1bac: 84,
+    0x1bad: 84,
+    0x1be6: 84,
+    0x1be8: 84,
+    0x1be9: 84,
+    0x1bed: 84,
+    0x1bef: 84,
+    0x1bf0: 84,
+    0x1bf1: 84,
+    0x1c2c: 84,
+    0x1c2d: 84,
+    0x1c2e: 84,
+    0x1c2f: 84,
+    0x1c30: 84,
+    0x1c31: 84,
+    0x1c32: 84,
+    0x1c33: 84,
+    0x1c36: 84,
+    0x1c37: 84,
+    0x1cd0: 84,
+    0x1cd1: 84,
+    0x1cd2: 84,
+    0x1cd4: 84,
+    0x1cd5: 84,
+    0x1cd6: 84,
+    0x1cd7: 84,
+    0x1cd8: 84,
+    0x1cd9: 84,
+    0x1cda: 84,
+    0x1cdb: 84,
+    0x1cdc: 84,
+    0x1cdd: 84,
+    0x1cde: 84,
+    0x1cdf: 84,
+    0x1ce0: 84,
+    0x1ce2: 84,
+    0x1ce3: 84,
+    0x1ce4: 84,
+    0x1ce5: 84,
+    0x1ce6: 84,
+    0x1ce7: 84,
+    0x1ce8: 84,
+    0x1ced: 84,
+    0x1cf4: 84,
+    0x1cf8: 84,
+    0x1cf9: 84,
+    0x1dc0: 84,
+    0x1dc1: 84,
+    0x1dc2: 84,
+    0x1dc3: 84,
+    0x1dc4: 84,
+    0x1dc5: 84,
+    0x1dc6: 84,
+    0x1dc7: 84,
+    0x1dc8: 84,
+    0x1dc9: 84,
+    0x1dca: 84,
+    0x1dcb: 84,
+    0x1dcc: 84,
+    0x1dcd: 84,
+    0x1dce: 84,
+    0x1dcf: 84,
+    0x1dd0: 84,
+    0x1dd1: 84,
+    0x1dd2: 84,
+    0x1dd3: 84,
+    0x1dd4: 84,
+    0x1dd5: 84,
+    0x1dd6: 84,
+    0x1dd7: 84,
+    0x1dd8: 84,
+    0x1dd9: 84,
+    0x1dda: 84,
+    0x1ddb: 84,
+    0x1ddc: 84,
+    0x1ddd: 84,
+    0x1dde: 84,
+    0x1ddf: 84,
+    0x1de0: 84,
+    0x1de1: 84,
+    0x1de2: 84,
+    0x1de3: 84,
+    0x1de4: 84,
+    0x1de5: 84,
+    0x1de6: 84,
+    0x1de7: 84,
+    0x1de8: 84,
+    0x1de9: 84,
+    0x1dea: 84,
+    0x1deb: 84,
+    0x1dec: 84,
+    0x1ded: 84,
+    0x1dee: 84,
+    0x1def: 84,
+    0x1df0: 84,
+    0x1df1: 84,
+    0x1df2: 84,
+    0x1df3: 84,
+    0x1df4: 84,
+    0x1df5: 84,
+    0x1df6: 84,
+    0x1df7: 84,
+    0x1df8: 84,
+    0x1df9: 84,
+    0x1dfa: 84,
+    0x1dfb: 84,
+    0x1dfc: 84,
+    0x1dfd: 84,
+    0x1dfe: 84,
+    0x1dff: 84,
+    0x200b: 84,
+    0x200d: 67,
+    0x200e: 84,
+    0x200f: 84,
+    0x202a: 84,
+    0x202b: 84,
+    0x202c: 84,
+    0x202d: 84,
+    0x202e: 84,
+    0x2060: 84,
+    0x2061: 84,
+    0x2062: 84,
+    0x2063: 84,
+    0x2064: 84,
+    0x206a: 84,
+    0x206b: 84,
+    0x206c: 84,
+    0x206d: 84,
+    0x206e: 84,
+    0x206f: 84,
+    0x20d0: 84,
+    0x20d1: 84,
+    0x20d2: 84,
+    0x20d3: 84,
+    0x20d4: 84,
+    0x20d5: 84,
+    0x20d6: 84,
+    0x20d7: 84,
+    0x20d8: 84,
+    0x20d9: 84,
+    0x20da: 84,
+    0x20db: 84,
+    0x20dc: 84,
+    0x20dd: 84,
+    0x20de: 84,
+    0x20df: 84,
+    0x20e0: 84,
+    0x20e1: 84,
+    0x20e2: 84,
+    0x20e3: 84,
+    0x20e4: 84,
+    0x20e5: 84,
+    0x20e6: 84,
+    0x20e7: 84,
+    0x20e8: 84,
+    0x20e9: 84,
+    0x20ea: 84,
+    0x20eb: 84,
+    0x20ec: 84,
+    0x20ed: 84,
+    0x20ee: 84,
+    0x20ef: 84,
+    0x20f0: 84,
+    0x2cef: 84,
+    0x2cf0: 84,
+    0x2cf1: 84,
+    0x2d7f: 84,
+    0x2de0: 84,
+    0x2de1: 84,
+    0x2de2: 84,
+    0x2de3: 84,
+    0x2de4: 84,
+    0x2de5: 84,
+    0x2de6: 84,
+    0x2de7: 84,
+    0x2de8: 84,
+    0x2de9: 84,
+    0x2dea: 84,
+    0x2deb: 84,
+    0x2dec: 84,
+    0x2ded: 84,
+    0x2dee: 84,
+    0x2def: 84,
+    0x2df0: 84,
+    0x2df1: 84,
+    0x2df2: 84,
+    0x2df3: 84,
+    0x2df4: 84,
+    0x2df5: 84,
+    0x2df6: 84,
+    0x2df7: 84,
+    0x2df8: 84,
+    0x2df9: 84,
+    0x2dfa: 84,
+    0x2dfb: 84,
+    0x2dfc: 84,
+    0x2dfd: 84,
+    0x2dfe: 84,
+    0x2dff: 84,
+    0x302a: 84,
+    0x302b: 84,
+    0x302c: 84,
+    0x302d: 84,
+    0x3099: 84,
+    0x309a: 84,
+    0xa66f: 84,
+    0xa670: 84,
+    0xa671: 84,
+    0xa672: 84,
+    0xa674: 84,
+    0xa675: 84,
+    0xa676: 84,
+    0xa677: 84,
+    0xa678: 84,
+    0xa679: 84,
+    0xa67a: 84,
+    0xa67b: 84,
+    0xa67c: 84,
+    0xa67d: 84,
+    0xa69e: 84,
+    0xa69f: 84,
+    0xa6f0: 84,
+    0xa6f1: 84,
+    0xa802: 84,
+    0xa806: 84,
+    0xa80b: 84,
+    0xa825: 84,
+    0xa826: 84,
+    0xa82c: 84,
+    0xa840: 68,
+    0xa841: 68,
+    0xa842: 68,
+    0xa843: 68,
+    0xa844: 68,
+    0xa845: 68,
+    0xa846: 68,
+    0xa847: 68,
+    0xa848: 68,
+    0xa849: 68,
+    0xa84a: 68,
+    0xa84b: 68,
+    0xa84c: 68,
+    0xa84d: 68,
+    0xa84e: 68,
+    0xa84f: 68,
+    0xa850: 68,
+    0xa851: 68,
+    0xa852: 68,
+    0xa853: 68,
+    0xa854: 68,
+    0xa855: 68,
+    0xa856: 68,
+    0xa857: 68,
+    0xa858: 68,
+    0xa859: 68,
+    0xa85a: 68,
+    0xa85b: 68,
+    0xa85c: 68,
+    0xa85d: 68,
+    0xa85e: 68,
+    0xa85f: 68,
+    0xa860: 68,
+    0xa861: 68,
+    0xa862: 68,
+    0xa863: 68,
+    0xa864: 68,
+    0xa865: 68,
+    0xa866: 68,
+    0xa867: 68,
+    0xa868: 68,
+    0xa869: 68,
+    0xa86a: 68,
+    0xa86b: 68,
+    0xa86c: 68,
+    0xa86d: 68,
+    0xa86e: 68,
+    0xa86f: 68,
+    0xa870: 68,
+    0xa871: 68,
+    0xa872: 76,
+    0xa8c4: 84,
+    0xa8c5: 84,
+    0xa8e0: 84,
+    0xa8e1: 84,
+    0xa8e2: 84,
+    0xa8e3: 84,
+    0xa8e4: 84,
+    0xa8e5: 84,
+    0xa8e6: 84,
+    0xa8e7: 84,
+    0xa8e8: 84,
+    0xa8e9: 84,
+    0xa8ea: 84,
+    0xa8eb: 84,
+    0xa8ec: 84,
+    0xa8ed: 84,
+    0xa8ee: 84,
+    0xa8ef: 84,
+    0xa8f0: 84,
+    0xa8f1: 84,
+    0xa8ff: 84,
+    0xa926: 84,
+    0xa927: 84,
+    0xa928: 84,
+    0xa929: 84,
+    0xa92a: 84,
+    0xa92b: 84,
+    0xa92c: 84,
+    0xa92d: 84,
+    0xa947: 84,
+    0xa948: 84,
+    0xa949: 84,
+    0xa94a: 84,
+    0xa94b: 84,
+    0xa94c: 84,
+    0xa94d: 84,
+    0xa94e: 84,
+    0xa94f: 84,
+    0xa950: 84,
+    0xa951: 84,
+    0xa980: 84,
+    0xa981: 84,
+    0xa982: 84,
+    0xa9b3: 84,
+    0xa9b6: 84,
+    0xa9b7: 84,
+    0xa9b8: 84,
+    0xa9b9: 84,
+    0xa9bc: 84,
+    0xa9bd: 84,
+    0xa9e5: 84,
+    0xaa29: 84,
+    0xaa2a: 84,
+    0xaa2b: 84,
+    0xaa2c: 84,
+    0xaa2d: 84,
+    0xaa2e: 84,
+    0xaa31: 84,
+    0xaa32: 84,
+    0xaa35: 84,
+    0xaa36: 84,
+    0xaa43: 84,
+    0xaa4c: 84,
+    0xaa7c: 84,
+    0xaab0: 84,
+    0xaab2: 84,
+    0xaab3: 84,
+    0xaab4: 84,
+    0xaab7: 84,
+    0xaab8: 84,
+    0xaabe: 84,
+    0xaabf: 84,
+    0xaac1: 84,
+    0xaaec: 84,
+    0xaaed: 84,
+    0xaaf6: 84,
+    0xabe5: 84,
+    0xabe8: 84,
+    0xabed: 84,
+    0xfb1e: 84,
+    0xfe00: 84,
+    0xfe01: 84,
+    0xfe02: 84,
+    0xfe03: 84,
+    0xfe04: 84,
+    0xfe05: 84,
+    0xfe06: 84,
+    0xfe07: 84,
+    0xfe08: 84,
+    0xfe09: 84,
+    0xfe0a: 84,
+    0xfe0b: 84,
+    0xfe0c: 84,
+    0xfe0d: 84,
+    0xfe0e: 84,
+    0xfe0f: 84,
+    0xfe20: 84,
+    0xfe21: 84,
+    0xfe22: 84,
+    0xfe23: 84,
+    0xfe24: 84,
+    0xfe25: 84,
+    0xfe26: 84,
+    0xfe27: 84,
+    0xfe28: 84,
+    0xfe29: 84,
+    0xfe2a: 84,
+    0xfe2b: 84,
+    0xfe2c: 84,
+    0xfe2d: 84,
+    0xfe2e: 84,
+    0xfe2f: 84,
+    0xfeff: 84,
+    0xfff9: 84,
+    0xfffa: 84,
+    0xfffb: 84,
+    0x101fd: 84,
+    0x102e0: 84,
+    0x10376: 84,
+    0x10377: 84,
+    0x10378: 84,
+    0x10379: 84,
+    0x1037a: 84,
+    0x10a01: 84,
+    0x10a02: 84,
+    0x10a03: 84,
+    0x10a05: 84,
+    0x10a06: 84,
+    0x10a0c: 84,
+    0x10a0d: 84,
+    0x10a0e: 84,
+    0x10a0f: 84,
+    0x10a38: 84,
+    0x10a39: 84,
+    0x10a3a: 84,
+    0x10a3f: 84,
+    0x10ac0: 68,
+    0x10ac1: 68,
+    0x10ac2: 68,
+    0x10ac3: 68,
+    0x10ac4: 68,
+    0x10ac5: 82,
+    0x10ac7: 82,
+    0x10ac9: 82,
+    0x10aca: 82,
+    0x10acd: 76,
+    0x10ace: 82,
+    0x10acf: 82,
+    0x10ad0: 82,
+    0x10ad1: 82,
+    0x10ad2: 82,
+    0x10ad3: 68,
+    0x10ad4: 68,
+    0x10ad5: 68,
+    0x10ad6: 68,
+    0x10ad7: 76,
+    0x10ad8: 68,
+    0x10ad9: 68,
+    0x10ada: 68,
+    0x10adb: 68,
+    0x10adc: 68,
+    0x10add: 82,
+    0x10ade: 68,
+    0x10adf: 68,
+    0x10ae0: 68,
+    0x10ae1: 82,
+    0x10ae4: 82,
+    0x10ae5: 84,
+    0x10ae6: 84,
+    0x10aeb: 68,
+    0x10aec: 68,
+    0x10aed: 68,
+    0x10aee: 68,
+    0x10aef: 82,
+    0x10b80: 68,
+    0x10b81: 82,
+    0x10b82: 68,
+    0x10b83: 82,
+    0x10b84: 82,
+    0x10b85: 82,
+    0x10b86: 68,
+    0x10b87: 68,
+    0x10b88: 68,
+    0x10b89: 82,
+    0x10b8a: 68,
+    0x10b8b: 68,
+    0x10b8c: 82,
+    0x10b8d: 68,
+    0x10b8e: 82,
+    0x10b8f: 82,
+    0x10b90: 68,
+    0x10b91: 82,
+    0x10ba9: 82,
+    0x10baa: 82,
+    0x10bab: 82,
+    0x10bac: 82,
+    0x10bad: 68,
+    0x10bae: 68,
+    0x10d00: 76,
+    0x10d01: 68,
+    0x10d02: 68,
+    0x10d03: 68,
+    0x10d04: 68,
+    0x10d05: 68,
+    0x10d06: 68,
+    0x10d07: 68,
+    0x10d08: 68,
+    0x10d09: 68,
+    0x10d0a: 68,
+    0x10d0b: 68,
+    0x10d0c: 68,
+    0x10d0d: 68,
+    0x10d0e: 68,
+    0x10d0f: 68,
+    0x10d10: 68,
+    0x10d11: 68,
+    0x10d12: 68,
+    0x10d13: 68,
+    0x10d14: 68,
+    0x10d15: 68,
+    0x10d16: 68,
+    0x10d17: 68,
+    0x10d18: 68,
+    0x10d19: 68,
+    0x10d1a: 68,
+    0x10d1b: 68,
+    0x10d1c: 68,
+    0x10d1d: 68,
+    0x10d1e: 68,
+    0x10d1f: 68,
+    0x10d20: 68,
+    0x10d21: 68,
+    0x10d22: 82,
+    0x10d23: 68,
+    0x10d24: 84,
+    0x10d25: 84,
+    0x10d26: 84,
+    0x10d27: 84,
+    0x10eab: 84,
+    0x10eac: 84,
+    0x10efd: 84,
+    0x10efe: 84,
+    0x10eff: 84,
+    0x10f30: 68,
+    0x10f31: 68,
+    0x10f32: 68,
+    0x10f33: 82,
+    0x10f34: 68,
+    0x10f35: 68,
+    0x10f36: 68,
+    0x10f37: 68,
+    0x10f38: 68,
+    0x10f39: 68,
+    0x10f3a: 68,
+    0x10f3b: 68,
+    0x10f3c: 68,
+    0x10f3d: 68,
+    0x10f3e: 68,
+    0x10f3f: 68,
+    0x10f40: 68,
+    0x10f41: 68,
+    0x10f42: 68,
+    0x10f43: 68,
+    0x10f44: 68,
+    0x10f46: 84,
+    0x10f47: 84,
+    0x10f48: 84,
+    0x10f49: 84,
+    0x10f4a: 84,
+    0x10f4b: 84,
+    0x10f4c: 84,
+    0x10f4d: 84,
+    0x10f4e: 84,
+    0x10f4f: 84,
+    0x10f50: 84,
+    0x10f51: 68,
+    0x10f52: 68,
+    0x10f53: 68,
+    0x10f54: 82,
+    0x10f70: 68,
+    0x10f71: 68,
+    0x10f72: 68,
+    0x10f73: 68,
+    0x10f74: 82,
+    0x10f75: 82,
+    0x10f76: 68,
+    0x10f77: 68,
+    0x10f78: 68,
+    0x10f79: 68,
+    0x10f7a: 68,
+    0x10f7b: 68,
+    0x10f7c: 68,
+    0x10f7d: 68,
+    0x10f7e: 68,
+    0x10f7f: 68,
+    0x10f80: 68,
+    0x10f81: 68,
+    0x10f82: 84,
+    0x10f83: 84,
+    0x10f84: 84,
+    0x10f85: 84,
+    0x10fb0: 68,
+    0x10fb2: 68,
+    0x10fb3: 68,
+    0x10fb4: 82,
+    0x10fb5: 82,
+    0x10fb6: 82,
+    0x10fb8: 68,
+    0x10fb9: 82,
+    0x10fba: 82,
+    0x10fbb: 68,
+    0x10fbc: 68,
+    0x10fbd: 82,
+    0x10fbe: 68,
+    0x10fbf: 68,
+    0x10fc1: 68,
+    0x10fc2: 82,
+    0x10fc3: 82,
+    0x10fc4: 68,
+    0x10fc9: 82,
+    0x10fca: 68,
+    0x10fcb: 76,
+    0x11001: 84,
+    0x11038: 84,
+    0x11039: 84,
+    0x1103a: 84,
+    0x1103b: 84,
+    0x1103c: 84,
+    0x1103d: 84,
+    0x1103e: 84,
+    0x1103f: 84,
+    0x11040: 84,
+    0x11041: 84,
+    0x11042: 84,
+    0x11043: 84,
+    0x11044: 84,
+    0x11045: 84,
+    0x11046: 84,
+    0x11070: 84,
+    0x11073: 84,
+    0x11074: 84,
+    0x1107f: 84,
+    0x11080: 84,
+    0x11081: 84,
+    0x110b3: 84,
+    0x110b4: 84,
+    0x110b5: 84,
+    0x110b6: 84,
+    0x110b9: 84,
+    0x110ba: 84,
+    0x110c2: 84,
+    0x11100: 84,
+    0x11101: 84,
+    0x11102: 84,
+    0x11127: 84,
+    0x11128: 84,
+    0x11129: 84,
+    0x1112a: 84,
+    0x1112b: 84,
+    0x1112d: 84,
+    0x1112e: 84,
+    0x1112f: 84,
+    0x11130: 84,
+    0x11131: 84,
+    0x11132: 84,
+    0x11133: 84,
+    0x11134: 84,
+    0x11173: 84,
+    0x11180: 84,
+    0x11181: 84,
+    0x111b6: 84,
+    0x111b7: 84,
+    0x111b8: 84,
+    0x111b9: 84,
+    0x111ba: 84,
+    0x111bb: 84,
+    0x111bc: 84,
+    0x111bd: 84,
+    0x111be: 84,
+    0x111c9: 84,
+    0x111ca: 84,
+    0x111cb: 84,
+    0x111cc: 84,
+    0x111cf: 84,
+    0x1122f: 84,
+    0x11230: 84,
+    0x11231: 84,
+    0x11234: 84,
+    0x11236: 84,
+    0x11237: 84,
+    0x1123e: 84,
+    0x11241: 84,
+    0x112df: 84,
+    0x112e3: 84,
+    0x112e4: 84,
+    0x112e5: 84,
+    0x112e6: 84,
+    0x112e7: 84,
+    0x112e8: 84,
+    0x112e9: 84,
+    0x112ea: 84,
+    0x11300: 84,
+    0x11301: 84,
+    0x1133b: 84,
+    0x1133c: 84,
+    0x11340: 84,
+    0x11366: 84,
+    0x11367: 84,
+    0x11368: 84,
+    0x11369: 84,
+    0x1136a: 84,
+    0x1136b: 84,
+    0x1136c: 84,
+    0x11370: 84,
+    0x11371: 84,
+    0x11372: 84,
+    0x11373: 84,
+    0x11374: 84,
+    0x11438: 84,
+    0x11439: 84,
+    0x1143a: 84,
+    0x1143b: 84,
+    0x1143c: 84,
+    0x1143d: 84,
+    0x1143e: 84,
+    0x1143f: 84,
+    0x11442: 84,
+    0x11443: 84,
+    0x11444: 84,
+    0x11446: 84,
+    0x1145e: 84,
+    0x114b3: 84,
+    0x114b4: 84,
+    0x114b5: 84,
+    0x114b6: 84,
+    0x114b7: 84,
+    0x114b8: 84,
+    0x114ba: 84,
+    0x114bf: 84,
+    0x114c0: 84,
+    0x114c2: 84,
+    0x114c3: 84,
+    0x115b2: 84,
+    0x115b3: 84,
+    0x115b4: 84,
+    0x115b5: 84,
+    0x115bc: 84,
+    0x115bd: 84,
+    0x115bf: 84,
+    0x115c0: 84,
+    0x115dc: 84,
+    0x115dd: 84,
+    0x11633: 84,
+    0x11634: 84,
+    0x11635: 84,
+    0x11636: 84,
+    0x11637: 84,
+    0x11638: 84,
+    0x11639: 84,
+    0x1163a: 84,
+    0x1163d: 84,
+    0x1163f: 84,
+    0x11640: 84,
+    0x116ab: 84,
+    0x116ad: 84,
+    0x116b0: 84,
+    0x116b1: 84,
+    0x116b2: 84,
+    0x116b3: 84,
+    0x116b4: 84,
+    0x116b5: 84,
+    0x116b7: 84,
+    0x1171d: 84,
+    0x1171e: 84,
+    0x1171f: 84,
+    0x11722: 84,
+    0x11723: 84,
+    0x11724: 84,
+    0x11725: 84,
+    0x11727: 84,
+    0x11728: 84,
+    0x11729: 84,
+    0x1172a: 84,
+    0x1172b: 84,
+    0x1182f: 84,
+    0x11830: 84,
+    0x11831: 84,
+    0x11832: 84,
+    0x11833: 84,
+    0x11834: 84,
+    0x11835: 84,
+    0x11836: 84,
+    0x11837: 84,
+    0x11839: 84,
+    0x1183a: 84,
+    0x1193b: 84,
+    0x1193c: 84,
+    0x1193e: 84,
+    0x11943: 84,
+    0x119d4: 84,
+    0x119d5: 84,
+    0x119d6: 84,
+    0x119d7: 84,
+    0x119da: 84,
+    0x119db: 84,
+    0x119e0: 84,
+    0x11a01: 84,
+    0x11a02: 84,
+    0x11a03: 84,
+    0x11a04: 84,
+    0x11a05: 84,
+    0x11a06: 84,
+    0x11a07: 84,
+    0x11a08: 84,
+    0x11a09: 84,
+    0x11a0a: 84,
+    0x11a33: 84,
+    0x11a34: 84,
+    0x11a35: 84,
+    0x11a36: 84,
+    0x11a37: 84,
+    0x11a38: 84,
+    0x11a3b: 84,
+    0x11a3c: 84,
+    0x11a3d: 84,
+    0x11a3e: 84,
+    0x11a47: 84,
+    0x11a51: 84,
+    0x11a52: 84,
+    0x11a53: 84,
+    0x11a54: 84,
+    0x11a55: 84,
+    0x11a56: 84,
+    0x11a59: 84,
+    0x11a5a: 84,
+    0x11a5b: 84,
+    0x11a8a: 84,
+    0x11a8b: 84,
+    0x11a8c: 84,
+    0x11a8d: 84,
+    0x11a8e: 84,
+    0x11a8f: 84,
+    0x11a90: 84,
+    0x11a91: 84,
+    0x11a92: 84,
+    0x11a93: 84,
+    0x11a94: 84,
+    0x11a95: 84,
+    0x11a96: 84,
+    0x11a98: 84,
+    0x11a99: 84,
+    0x11c30: 84,
+    0x11c31: 84,
+    0x11c32: 84,
+    0x11c33: 84,
+    0x11c34: 84,
+    0x11c35: 84,
+    0x11c36: 84,
+    0x11c38: 84,
+    0x11c39: 84,
+    0x11c3a: 84,
+    0x11c3b: 84,
+    0x11c3c: 84,
+    0x11c3d: 84,
+    0x11c3f: 84,
+    0x11c92: 84,
+    0x11c93: 84,
+    0x11c94: 84,
+    0x11c95: 84,
+    0x11c96: 84,
+    0x11c97: 84,
+    0x11c98: 84,
+    0x11c99: 84,
+    0x11c9a: 84,
+    0x11c9b: 84,
+    0x11c9c: 84,
+    0x11c9d: 84,
+    0x11c9e: 84,
+    0x11c9f: 84,
+    0x11ca0: 84,
+    0x11ca1: 84,
+    0x11ca2: 84,
+    0x11ca3: 84,
+    0x11ca4: 84,
+    0x11ca5: 84,
+    0x11ca6: 84,
+    0x11ca7: 84,
+    0x11caa: 84,
+    0x11cab: 84,
+    0x11cac: 84,
+    0x11cad: 84,
+    0x11cae: 84,
+    0x11caf: 84,
+    0x11cb0: 84,
+    0x11cb2: 84,
+    0x11cb3: 84,
+    0x11cb5: 84,
+    0x11cb6: 84,
+    0x11d31: 84,
+    0x11d32: 84,
+    0x11d33: 84,
+    0x11d34: 84,
+    0x11d35: 84,
+    0x11d36: 84,
+    0x11d3a: 84,
+    0x11d3c: 84,
+    0x11d3d: 84,
+    0x11d3f: 84,
+    0x11d40: 84,
+    0x11d41: 84,
+    0x11d42: 84,
+    0x11d43: 84,
+    0x11d44: 84,
+    0x11d45: 84,
+    0x11d47: 84,
+    0x11d90: 84,
+    0x11d91: 84,
+    0x11d95: 84,
+    0x11d97: 84,
+    0x11ef3: 84,
+    0x11ef4: 84,
+    0x11f00: 84,
+    0x11f01: 84,
+    0x11f36: 84,
+    0x11f37: 84,
+    0x11f38: 84,
+    0x11f39: 84,
+    0x11f3a: 84,
+    0x11f40: 84,
+    0x11f42: 84,
+    0x13430: 84,
+    0x13431: 84,
+    0x13432: 84,
+    0x13433: 84,
+    0x13434: 84,
+    0x13435: 84,
+    0x13436: 84,
+    0x13437: 84,
+    0x13438: 84,
+    0x13439: 84,
+    0x1343a: 84,
+    0x1343b: 84,
+    0x1343c: 84,
+    0x1343d: 84,
+    0x1343e: 84,
+    0x1343f: 84,
+    0x13440: 84,
+    0x13447: 84,
+    0x13448: 84,
+    0x13449: 84,
+    0x1344a: 84,
+    0x1344b: 84,
+    0x1344c: 84,
+    0x1344d: 84,
+    0x1344e: 84,
+    0x1344f: 84,
+    0x13450: 84,
+    0x13451: 84,
+    0x13452: 84,
+    0x13453: 84,
+    0x13454: 84,
+    0x13455: 84,
+    0x16af0: 84,
+    0x16af1: 84,
+    0x16af2: 84,
+    0x16af3: 84,
+    0x16af4: 84,
+    0x16b30: 84,
+    0x16b31: 84,
+    0x16b32: 84,
+    0x16b33: 84,
+    0x16b34: 84,
+    0x16b35: 84,
+    0x16b36: 84,
+    0x16f4f: 84,
+    0x16f8f: 84,
+    0x16f90: 84,
+    0x16f91: 84,
+    0x16f92: 84,
+    0x16fe4: 84,
+    0x1bc9d: 84,
+    0x1bc9e: 84,
+    0x1bca0: 84,
+    0x1bca1: 84,
+    0x1bca2: 84,
+    0x1bca3: 84,
+    0x1cf00: 84,
+    0x1cf01: 84,
+    0x1cf02: 84,
+    0x1cf03: 84,
+    0x1cf04: 84,
+    0x1cf05: 84,
+    0x1cf06: 84,
+    0x1cf07: 84,
+    0x1cf08: 84,
+    0x1cf09: 84,
+    0x1cf0a: 84,
+    0x1cf0b: 84,
+    0x1cf0c: 84,
+    0x1cf0d: 84,
+    0x1cf0e: 84,
+    0x1cf0f: 84,
+    0x1cf10: 84,
+    0x1cf11: 84,
+    0x1cf12: 84,
+    0x1cf13: 84,
+    0x1cf14: 84,
+    0x1cf15: 84,
+    0x1cf16: 84,
+    0x1cf17: 84,
+    0x1cf18: 84,
+    0x1cf19: 84,
+    0x1cf1a: 84,
+    0x1cf1b: 84,
+    0x1cf1c: 84,
+    0x1cf1d: 84,
+    0x1cf1e: 84,
+    0x1cf1f: 84,
+    0x1cf20: 84,
+    0x1cf21: 84,
+    0x1cf22: 84,
+    0x1cf23: 84,
+    0x1cf24: 84,
+    0x1cf25: 84,
+    0x1cf26: 84,
+    0x1cf27: 84,
+    0x1cf28: 84,
+    0x1cf29: 84,
+    0x1cf2a: 84,
+    0x1cf2b: 84,
+    0x1cf2c: 84,
+    0x1cf2d: 84,
+    0x1cf30: 84,
+    0x1cf31: 84,
+    0x1cf32: 84,
+    0x1cf33: 84,
+    0x1cf34: 84,
+    0x1cf35: 84,
+    0x1cf36: 84,
+    0x1cf37: 84,
+    0x1cf38: 84,
+    0x1cf39: 84,
+    0x1cf3a: 84,
+    0x1cf3b: 84,
+    0x1cf3c: 84,
+    0x1cf3d: 84,
+    0x1cf3e: 84,
+    0x1cf3f: 84,
+    0x1cf40: 84,
+    0x1cf41: 84,
+    0x1cf42: 84,
+    0x1cf43: 84,
+    0x1cf44: 84,
+    0x1cf45: 84,
+    0x1cf46: 84,
+    0x1d167: 84,
+    0x1d168: 84,
+    0x1d169: 84,
+    0x1d173: 84,
+    0x1d174: 84,
+    0x1d175: 84,
+    0x1d176: 84,
+    0x1d177: 84,
+    0x1d178: 84,
+    0x1d179: 84,
+    0x1d17a: 84,
+    0x1d17b: 84,
+    0x1d17c: 84,
+    0x1d17d: 84,
+    0x1d17e: 84,
+    0x1d17f: 84,
+    0x1d180: 84,
+    0x1d181: 84,
+    0x1d182: 84,
+    0x1d185: 84,
+    0x1d186: 84,
+    0x1d187: 84,
+    0x1d188: 84,
+    0x1d189: 84,
+    0x1d18a: 84,
+    0x1d18b: 84,
+    0x1d1aa: 84,
+    0x1d1ab: 84,
+    0x1d1ac: 84,
+    0x1d1ad: 84,
+    0x1d242: 84,
+    0x1d243: 84,
+    0x1d244: 84,
+    0x1da00: 84,
+    0x1da01: 84,
+    0x1da02: 84,
+    0x1da03: 84,
+    0x1da04: 84,
+    0x1da05: 84,
+    0x1da06: 84,
+    0x1da07: 84,
+    0x1da08: 84,
+    0x1da09: 84,
+    0x1da0a: 84,
+    0x1da0b: 84,
+    0x1da0c: 84,
+    0x1da0d: 84,
+    0x1da0e: 84,
+    0x1da0f: 84,
+    0x1da10: 84,
+    0x1da11: 84,
+    0x1da12: 84,
+    0x1da13: 84,
+    0x1da14: 84,
+    0x1da15: 84,
+    0x1da16: 84,
+    0x1da17: 84,
+    0x1da18: 84,
+    0x1da19: 84,
+    0x1da1a: 84,
+    0x1da1b: 84,
+    0x1da1c: 84,
+    0x1da1d: 84,
+    0x1da1e: 84,
+    0x1da1f: 84,
+    0x1da20: 84,
+    0x1da21: 84,
+    0x1da22: 84,
+    0x1da23: 84,
+    0x1da24: 84,
+    0x1da25: 84,
+    0x1da26: 84,
+    0x1da27: 84,
+    0x1da28: 84,
+    0x1da29: 84,
+    0x1da2a: 84,
+    0x1da2b: 84,
+    0x1da2c: 84,
+    0x1da2d: 84,
+    0x1da2e: 84,
+    0x1da2f: 84,
+    0x1da30: 84,
+    0x1da31: 84,
+    0x1da32: 84,
+    0x1da33: 84,
+    0x1da34: 84,
+    0x1da35: 84,
+    0x1da36: 84,
+    0x1da3b: 84,
+    0x1da3c: 84,
+    0x1da3d: 84,
+    0x1da3e: 84,
+    0x1da3f: 84,
+    0x1da40: 84,
+    0x1da41: 84,
+    0x1da42: 84,
+    0x1da43: 84,
+    0x1da44: 84,
+    0x1da45: 84,
+    0x1da46: 84,
+    0x1da47: 84,
+    0x1da48: 84,
+    0x1da49: 84,
+    0x1da4a: 84,
+    0x1da4b: 84,
+    0x1da4c: 84,
+    0x1da4d: 84,
+    0x1da4e: 84,
+    0x1da4f: 84,
+    0x1da50: 84,
+    0x1da51: 84,
+    0x1da52: 84,
+    0x1da53: 84,
+    0x1da54: 84,
+    0x1da55: 84,
+    0x1da56: 84,
+    0x1da57: 84,
+    0x1da58: 84,
+    0x1da59: 84,
+    0x1da5a: 84,
+    0x1da5b: 84,
+    0x1da5c: 84,
+    0x1da5d: 84,
+    0x1da5e: 84,
+    0x1da5f: 84,
+    0x1da60: 84,
+    0x1da61: 84,
+    0x1da62: 84,
+    0x1da63: 84,
+    0x1da64: 84,
+    0x1da65: 84,
+    0x1da66: 84,
+    0x1da67: 84,
+    0x1da68: 84,
+    0x1da69: 84,
+    0x1da6a: 84,
+    0x1da6b: 84,
+    0x1da6c: 84,
+    0x1da75: 84,
+    0x1da84: 84,
+    0x1da9b: 84,
+    0x1da9c: 84,
+    0x1da9d: 84,
+    0x1da9e: 84,
+    0x1da9f: 84,
+    0x1daa1: 84,
+    0x1daa2: 84,
+    0x1daa3: 84,
+    0x1daa4: 84,
+    0x1daa5: 84,
+    0x1daa6: 84,
+    0x1daa7: 84,
+    0x1daa8: 84,
+    0x1daa9: 84,
+    0x1daaa: 84,
+    0x1daab: 84,
+    0x1daac: 84,
+    0x1daad: 84,
+    0x1daae: 84,
+    0x1daaf: 84,
+    0x1e000: 84,
+    0x1e001: 84,
+    0x1e002: 84,
+    0x1e003: 84,
+    0x1e004: 84,
+    0x1e005: 84,
+    0x1e006: 84,
+    0x1e008: 84,
+    0x1e009: 84,
+    0x1e00a: 84,
+    0x1e00b: 84,
+    0x1e00c: 84,
+    0x1e00d: 84,
+    0x1e00e: 84,
+    0x1e00f: 84,
+    0x1e010: 84,
+    0x1e011: 84,
+    0x1e012: 84,
+    0x1e013: 84,
+    0x1e014: 84,
+    0x1e015: 84,
+    0x1e016: 84,
+    0x1e017: 84,
+    0x1e018: 84,
+    0x1e01b: 84,
+    0x1e01c: 84,
+    0x1e01d: 84,
+    0x1e01e: 84,
+    0x1e01f: 84,
+    0x1e020: 84,
+    0x1e021: 84,
+    0x1e023: 84,
+    0x1e024: 84,
+    0x1e026: 84,
+    0x1e027: 84,
+    0x1e028: 84,
+    0x1e029: 84,
+    0x1e02a: 84,
+    0x1e08f: 84,
+    0x1e130: 84,
+    0x1e131: 84,
+    0x1e132: 84,
+    0x1e133: 84,
+    0x1e134: 84,
+    0x1e135: 84,
+    0x1e136: 84,
+    0x1e2ae: 84,
+    0x1e2ec: 84,
+    0x1e2ed: 84,
+    0x1e2ee: 84,
+    0x1e2ef: 84,
+    0x1e4ec: 84,
+    0x1e4ed: 84,
+    0x1e4ee: 84,
+    0x1e4ef: 84,
+    0x1e8d0: 84,
+    0x1e8d1: 84,
+    0x1e8d2: 84,
+    0x1e8d3: 84,
+    0x1e8d4: 84,
+    0x1e8d5: 84,
+    0x1e8d6: 84,
+    0x1e900: 68,
+    0x1e901: 68,
+    0x1e902: 68,
+    0x1e903: 68,
+    0x1e904: 68,
+    0x1e905: 68,
+    0x1e906: 68,
+    0x1e907: 68,
+    0x1e908: 68,
+    0x1e909: 68,
+    0x1e90a: 68,
+    0x1e90b: 68,
+    0x1e90c: 68,
+    0x1e90d: 68,
+    0x1e90e: 68,
+    0x1e90f: 68,
+    0x1e910: 68,
+    0x1e911: 68,
+    0x1e912: 68,
+    0x1e913: 68,
+    0x1e914: 68,
+    0x1e915: 68,
+    0x1e916: 68,
+    0x1e917: 68,
+    0x1e918: 68,
+    0x1e919: 68,
+    0x1e91a: 68,
+    0x1e91b: 68,
+    0x1e91c: 68,
+    0x1e91d: 68,
+    0x1e91e: 68,
+    0x1e91f: 68,
+    0x1e920: 68,
+    0x1e921: 68,
+    0x1e922: 68,
+    0x1e923: 68,
+    0x1e924: 68,
+    0x1e925: 68,
+    0x1e926: 68,
+    0x1e927: 68,
+    0x1e928: 68,
+    0x1e929: 68,
+    0x1e92a: 68,
+    0x1e92b: 68,
+    0x1e92c: 68,
+    0x1e92d: 68,
+    0x1e92e: 68,
+    0x1e92f: 68,
+    0x1e930: 68,
+    0x1e931: 68,
+    0x1e932: 68,
+    0x1e933: 68,
+    0x1e934: 68,
+    0x1e935: 68,
+    0x1e936: 68,
+    0x1e937: 68,
+    0x1e938: 68,
+    0x1e939: 68,
+    0x1e93a: 68,
+    0x1e93b: 68,
+    0x1e93c: 68,
+    0x1e93d: 68,
+    0x1e93e: 68,
+    0x1e93f: 68,
+    0x1e940: 68,
+    0x1e941: 68,
+    0x1e942: 68,
+    0x1e943: 68,
+    0x1e944: 84,
+    0x1e945: 84,
+    0x1e946: 84,
+    0x1e947: 84,
+    0x1e948: 84,
+    0x1e949: 84,
+    0x1e94a: 84,
+    0x1e94b: 84,
+    0xe0001: 84,
+    0xe0020: 84,
+    0xe0021: 84,
+    0xe0022: 84,
+    0xe0023: 84,
+    0xe0024: 84,
+    0xe0025: 84,
+    0xe0026: 84,
+    0xe0027: 84,
+    0xe0028: 84,
+    0xe0029: 84,
+    0xe002a: 84,
+    0xe002b: 84,
+    0xe002c: 84,
+    0xe002d: 84,
+    0xe002e: 84,
+    0xe002f: 84,
+    0xe0030: 84,
+    0xe0031: 84,
+    0xe0032: 84,
+    0xe0033: 84,
+    0xe0034: 84,
+    0xe0035: 84,
+    0xe0036: 84,
+    0xe0037: 84,
+    0xe0038: 84,
+    0xe0039: 84,
+    0xe003a: 84,
+    0xe003b: 84,
+    0xe003c: 84,
+    0xe003d: 84,
+    0xe003e: 84,
+    0xe003f: 84,
+    0xe0040: 84,
+    0xe0041: 84,
+    0xe0042: 84,
+    0xe0043: 84,
+    0xe0044: 84,
+    0xe0045: 84,
+    0xe0046: 84,
+    0xe0047: 84,
+    0xe0048: 84,
+    0xe0049: 84,
+    0xe004a: 84,
+    0xe004b: 84,
+    0xe004c: 84,
+    0xe004d: 84,
+    0xe004e: 84,
+    0xe004f: 84,
+    0xe0050: 84,
+    0xe0051: 84,
+    0xe0052: 84,
+    0xe0053: 84,
+    0xe0054: 84,
+    0xe0055: 84,
+    0xe0056: 84,
+    0xe0057: 84,
+    0xe0058: 84,
+    0xe0059: 84,
+    0xe005a: 84,
+    0xe005b: 84,
+    0xe005c: 84,
+    0xe005d: 84,
+    0xe005e: 84,
+    0xe005f: 84,
+    0xe0060: 84,
+    0xe0061: 84,
+    0xe0062: 84,
+    0xe0063: 84,
+    0xe0064: 84,
+    0xe0065: 84,
+    0xe0066: 84,
+    0xe0067: 84,
+    0xe0068: 84,
+    0xe0069: 84,
+    0xe006a: 84,
+    0xe006b: 84,
+    0xe006c: 84,
+    0xe006d: 84,
+    0xe006e: 84,
+    0xe006f: 84,
+    0xe0070: 84,
+    0xe0071: 84,
+    0xe0072: 84,
+    0xe0073: 84,
+    0xe0074: 84,
+    0xe0075: 84,
+    0xe0076: 84,
+    0xe0077: 84,
+    0xe0078: 84,
+    0xe0079: 84,
+    0xe007a: 84,
+    0xe007b: 84,
+    0xe007c: 84,
+    0xe007d: 84,
+    0xe007e: 84,
+    0xe007f: 84,
+    0xe0100: 84,
+    0xe0101: 84,
+    0xe0102: 84,
+    0xe0103: 84,
+    0xe0104: 84,
+    0xe0105: 84,
+    0xe0106: 84,
+    0xe0107: 84,
+    0xe0108: 84,
+    0xe0109: 84,
+    0xe010a: 84,
+    0xe010b: 84,
+    0xe010c: 84,
+    0xe010d: 84,
+    0xe010e: 84,
+    0xe010f: 84,
+    0xe0110: 84,
+    0xe0111: 84,
+    0xe0112: 84,
+    0xe0113: 84,
+    0xe0114: 84,
+    0xe0115: 84,
+    0xe0116: 84,
+    0xe0117: 84,
+    0xe0118: 84,
+    0xe0119: 84,
+    0xe011a: 84,
+    0xe011b: 84,
+    0xe011c: 84,
+    0xe011d: 84,
+    0xe011e: 84,
+    0xe011f: 84,
+    0xe0120: 84,
+    0xe0121: 84,
+    0xe0122: 84,
+    0xe0123: 84,
+    0xe0124: 84,
+    0xe0125: 84,
+    0xe0126: 84,
+    0xe0127: 84,
+    0xe0128: 84,
+    0xe0129: 84,
+    0xe012a: 84,
+    0xe012b: 84,
+    0xe012c: 84,
+    0xe012d: 84,
+    0xe012e: 84,
+    0xe012f: 84,
+    0xe0130: 84,
+    0xe0131: 84,
+    0xe0132: 84,
+    0xe0133: 84,
+    0xe0134: 84,
+    0xe0135: 84,
+    0xe0136: 84,
+    0xe0137: 84,
+    0xe0138: 84,
+    0xe0139: 84,
+    0xe013a: 84,
+    0xe013b: 84,
+    0xe013c: 84,
+    0xe013d: 84,
+    0xe013e: 84,
+    0xe013f: 84,
+    0xe0140: 84,
+    0xe0141: 84,
+    0xe0142: 84,
+    0xe0143: 84,
+    0xe0144: 84,
+    0xe0145: 84,
+    0xe0146: 84,
+    0xe0147: 84,
+    0xe0148: 84,
+    0xe0149: 84,
+    0xe014a: 84,
+    0xe014b: 84,
+    0xe014c: 84,
+    0xe014d: 84,
+    0xe014e: 84,
+    0xe014f: 84,
+    0xe0150: 84,
+    0xe0151: 84,
+    0xe0152: 84,
+    0xe0153: 84,
+    0xe0154: 84,
+    0xe0155: 84,
+    0xe0156: 84,
+    0xe0157: 84,
+    0xe0158: 84,
+    0xe0159: 84,
+    0xe015a: 84,
+    0xe015b: 84,
+    0xe015c: 84,
+    0xe015d: 84,
+    0xe015e: 84,
+    0xe015f: 84,
+    0xe0160: 84,
+    0xe0161: 84,
+    0xe0162: 84,
+    0xe0163: 84,
+    0xe0164: 84,
+    0xe0165: 84,
+    0xe0166: 84,
+    0xe0167: 84,
+    0xe0168: 84,
+    0xe0169: 84,
+    0xe016a: 84,
+    0xe016b: 84,
+    0xe016c: 84,
+    0xe016d: 84,
+    0xe016e: 84,
+    0xe016f: 84,
+    0xe0170: 84,
+    0xe0171: 84,
+    0xe0172: 84,
+    0xe0173: 84,
+    0xe0174: 84,
+    0xe0175: 84,
+    0xe0176: 84,
+    0xe0177: 84,
+    0xe0178: 84,
+    0xe0179: 84,
+    0xe017a: 84,
+    0xe017b: 84,
+    0xe017c: 84,
+    0xe017d: 84,
+    0xe017e: 84,
+    0xe017f: 84,
+    0xe0180: 84,
+    0xe0181: 84,
+    0xe0182: 84,
+    0xe0183: 84,
+    0xe0184: 84,
+    0xe0185: 84,
+    0xe0186: 84,
+    0xe0187: 84,
+    0xe0188: 84,
+    0xe0189: 84,
+    0xe018a: 84,
+    0xe018b: 84,
+    0xe018c: 84,
+    0xe018d: 84,
+    0xe018e: 84,
+    0xe018f: 84,
+    0xe0190: 84,
+    0xe0191: 84,
+    0xe0192: 84,
+    0xe0193: 84,
+    0xe0194: 84,
+    0xe0195: 84,
+    0xe0196: 84,
+    0xe0197: 84,
+    0xe0198: 84,
+    0xe0199: 84,
+    0xe019a: 84,
+    0xe019b: 84,
+    0xe019c: 84,
+    0xe019d: 84,
+    0xe019e: 84,
+    0xe019f: 84,
+    0xe01a0: 84,
+    0xe01a1: 84,
+    0xe01a2: 84,
+    0xe01a3: 84,
+    0xe01a4: 84,
+    0xe01a5: 84,
+    0xe01a6: 84,
+    0xe01a7: 84,
+    0xe01a8: 84,
+    0xe01a9: 84,
+    0xe01aa: 84,
+    0xe01ab: 84,
+    0xe01ac: 84,
+    0xe01ad: 84,
+    0xe01ae: 84,
+    0xe01af: 84,
+    0xe01b0: 84,
+    0xe01b1: 84,
+    0xe01b2: 84,
+    0xe01b3: 84,
+    0xe01b4: 84,
+    0xe01b5: 84,
+    0xe01b6: 84,
+    0xe01b7: 84,
+    0xe01b8: 84,
+    0xe01b9: 84,
+    0xe01ba: 84,
+    0xe01bb: 84,
+    0xe01bc: 84,
+    0xe01bd: 84,
+    0xe01be: 84,
+    0xe01bf: 84,
+    0xe01c0: 84,
+    0xe01c1: 84,
+    0xe01c2: 84,
+    0xe01c3: 84,
+    0xe01c4: 84,
+    0xe01c5: 84,
+    0xe01c6: 84,
+    0xe01c7: 84,
+    0xe01c8: 84,
+    0xe01c9: 84,
+    0xe01ca: 84,
+    0xe01cb: 84,
+    0xe01cc: 84,
+    0xe01cd: 84,
+    0xe01ce: 84,
+    0xe01cf: 84,
+    0xe01d0: 84,
+    0xe01d1: 84,
+    0xe01d2: 84,
+    0xe01d3: 84,
+    0xe01d4: 84,
+    0xe01d5: 84,
+    0xe01d6: 84,
+    0xe01d7: 84,
+    0xe01d8: 84,
+    0xe01d9: 84,
+    0xe01da: 84,
+    0xe01db: 84,
+    0xe01dc: 84,
+    0xe01dd: 84,
+    0xe01de: 84,
+    0xe01df: 84,
+    0xe01e0: 84,
+    0xe01e1: 84,
+    0xe01e2: 84,
+    0xe01e3: 84,
+    0xe01e4: 84,
+    0xe01e5: 84,
+    0xe01e6: 84,
+    0xe01e7: 84,
+    0xe01e8: 84,
+    0xe01e9: 84,
+    0xe01ea: 84,
+    0xe01eb: 84,
+    0xe01ec: 84,
+    0xe01ed: 84,
+    0xe01ee: 84,
+    0xe01ef: 84,
+}
+codepoint_classes = {
+    'PVALID': (
+        0x2d0000002e,
+        0x300000003a,
+        0x610000007b,
+        0xdf000000f7,
+        0xf800000100,
+        0x10100000102,
+        0x10300000104,
+        0x10500000106,
+        0x10700000108,
+        0x1090000010a,
+        0x10b0000010c,
+        0x10d0000010e,
+        0x10f00000110,
+        0x11100000112,
+        0x11300000114,
+        0x11500000116,
+        0x11700000118,
+        0x1190000011a,
+        0x11b0000011c,
+        0x11d0000011e,
+        0x11f00000120,
+        0x12100000122,
+        0x12300000124,
+        0x12500000126,
+        0x12700000128,
+        0x1290000012a,
+        0x12b0000012c,
+        0x12d0000012e,
+        0x12f00000130,
+        0x13100000132,
+        0x13500000136,
+        0x13700000139,
+        0x13a0000013b,
+        0x13c0000013d,
+        0x13e0000013f,
+        0x14200000143,
+        0x14400000145,
+        0x14600000147,
+        0x14800000149,
+        0x14b0000014c,
+        0x14d0000014e,
+        0x14f00000150,
+        0x15100000152,
+        0x15300000154,
+        0x15500000156,
+        0x15700000158,
+        0x1590000015a,
+        0x15b0000015c,
+        0x15d0000015e,
+        0x15f00000160,
+        0x16100000162,
+        0x16300000164,
+        0x16500000166,
+        0x16700000168,
+        0x1690000016a,
+        0x16b0000016c,
+        0x16d0000016e,
+        0x16f00000170,
+        0x17100000172,
+        0x17300000174,
+        0x17500000176,
+        0x17700000178,
+        0x17a0000017b,
+        0x17c0000017d,
+        0x17e0000017f,
+        0x18000000181,
+        0x18300000184,
+        0x18500000186,
+        0x18800000189,
+        0x18c0000018e,
+        0x19200000193,
+        0x19500000196,
+        0x1990000019c,
+        0x19e0000019f,
+        0x1a1000001a2,
+        0x1a3000001a4,
+        0x1a5000001a6,
+        0x1a8000001a9,
+        0x1aa000001ac,
+        0x1ad000001ae,
+        0x1b0000001b1,
+        0x1b4000001b5,
+        0x1b6000001b7,
+        0x1b9000001bc,
+        0x1bd000001c4,
+        0x1ce000001cf,
+        0x1d0000001d1,
+        0x1d2000001d3,
+        0x1d4000001d5,
+        0x1d6000001d7,
+        0x1d8000001d9,
+        0x1da000001db,
+        0x1dc000001de,
+        0x1df000001e0,
+        0x1e1000001e2,
+        0x1e3000001e4,
+        0x1e5000001e6,
+        0x1e7000001e8,
+        0x1e9000001ea,
+        0x1eb000001ec,
+        0x1ed000001ee,
+        0x1ef000001f1,
+        0x1f5000001f6,
+        0x1f9000001fa,
+        0x1fb000001fc,
+        0x1fd000001fe,
+        0x1ff00000200,
+        0x20100000202,
+        0x20300000204,
+        0x20500000206,
+        0x20700000208,
+        0x2090000020a,
+        0x20b0000020c,
+        0x20d0000020e,
+        0x20f00000210,
+        0x21100000212,
+        0x21300000214,
+        0x21500000216,
+        0x21700000218,
+        0x2190000021a,
+        0x21b0000021c,
+        0x21d0000021e,
+        0x21f00000220,
+        0x22100000222,
+        0x22300000224,
+        0x22500000226,
+        0x22700000228,
+        0x2290000022a,
+        0x22b0000022c,
+        0x22d0000022e,
+        0x22f00000230,
+        0x23100000232,
+        0x2330000023a,
+        0x23c0000023d,
+        0x23f00000241,
+        0x24200000243,
+        0x24700000248,
+        0x2490000024a,
+        0x24b0000024c,
+        0x24d0000024e,
+        0x24f000002b0,
+        0x2b9000002c2,
+        0x2c6000002d2,
+        0x2ec000002ed,
+        0x2ee000002ef,
+        0x30000000340,
+        0x34200000343,
+        0x3460000034f,
+        0x35000000370,
+        0x37100000372,
+        0x37300000374,
+        0x37700000378,
+        0x37b0000037e,
+        0x39000000391,
+        0x3ac000003cf,
+        0x3d7000003d8,
+        0x3d9000003da,
+        0x3db000003dc,
+        0x3dd000003de,
+        0x3df000003e0,
+        0x3e1000003e2,
+        0x3e3000003e4,
+        0x3e5000003e6,
+        0x3e7000003e8,
+        0x3e9000003ea,
+        0x3eb000003ec,
+        0x3ed000003ee,
+        0x3ef000003f0,
+        0x3f3000003f4,
+        0x3f8000003f9,
+        0x3fb000003fd,
+        0x43000000460,
+        0x46100000462,
+        0x46300000464,
+        0x46500000466,
+        0x46700000468,
+        0x4690000046a,
+        0x46b0000046c,
+        0x46d0000046e,
+        0x46f00000470,
+        0x47100000472,
+        0x47300000474,
+        0x47500000476,
+        0x47700000478,
+        0x4790000047a,
+        0x47b0000047c,
+        0x47d0000047e,
+        0x47f00000480,
+        0x48100000482,
+        0x48300000488,
+        0x48b0000048c,
+        0x48d0000048e,
+        0x48f00000490,
+        0x49100000492,
+        0x49300000494,
+        0x49500000496,
+        0x49700000498,
+        0x4990000049a,
+        0x49b0000049c,
+        0x49d0000049e,
+        0x49f000004a0,
+        0x4a1000004a2,
+        0x4a3000004a4,
+        0x4a5000004a6,
+        0x4a7000004a8,
+        0x4a9000004aa,
+        0x4ab000004ac,
+        0x4ad000004ae,
+        0x4af000004b0,
+        0x4b1000004b2,
+        0x4b3000004b4,
+        0x4b5000004b6,
+        0x4b7000004b8,
+        0x4b9000004ba,
+        0x4bb000004bc,
+        0x4bd000004be,
+        0x4bf000004c0,
+        0x4c2000004c3,
+        0x4c4000004c5,
+        0x4c6000004c7,
+        0x4c8000004c9,
+        0x4ca000004cb,
+        0x4cc000004cd,
+        0x4ce000004d0,
+        0x4d1000004d2,
+        0x4d3000004d4,
+        0x4d5000004d6,
+        0x4d7000004d8,
+        0x4d9000004da,
+        0x4db000004dc,
+        0x4dd000004de,
+        0x4df000004e0,
+        0x4e1000004e2,
+        0x4e3000004e4,
+        0x4e5000004e6,
+        0x4e7000004e8,
+        0x4e9000004ea,
+        0x4eb000004ec,
+        0x4ed000004ee,
+        0x4ef000004f0,
+        0x4f1000004f2,
+        0x4f3000004f4,
+        0x4f5000004f6,
+        0x4f7000004f8,
+        0x4f9000004fa,
+        0x4fb000004fc,
+        0x4fd000004fe,
+        0x4ff00000500,
+        0x50100000502,
+        0x50300000504,
+        0x50500000506,
+        0x50700000508,
+        0x5090000050a,
+        0x50b0000050c,
+        0x50d0000050e,
+        0x50f00000510,
+        0x51100000512,
+        0x51300000514,
+        0x51500000516,
+        0x51700000518,
+        0x5190000051a,
+        0x51b0000051c,
+        0x51d0000051e,
+        0x51f00000520,
+        0x52100000522,
+        0x52300000524,
+        0x52500000526,
+        0x52700000528,
+        0x5290000052a,
+        0x52b0000052c,
+        0x52d0000052e,
+        0x52f00000530,
+        0x5590000055a,
+        0x56000000587,
+        0x58800000589,
+        0x591000005be,
+        0x5bf000005c0,
+        0x5c1000005c3,
+        0x5c4000005c6,
+        0x5c7000005c8,
+        0x5d0000005eb,
+        0x5ef000005f3,
+        0x6100000061b,
+        0x62000000640,
+        0x64100000660,
+        0x66e00000675,
+        0x679000006d4,
+        0x6d5000006dd,
+        0x6df000006e9,
+        0x6ea000006f0,
+        0x6fa00000700,
+        0x7100000074b,
+        0x74d000007b2,
+        0x7c0000007f6,
+        0x7fd000007fe,
+        0x8000000082e,
+        0x8400000085c,
+        0x8600000086b,
+        0x87000000888,
+        0x8890000088f,
+        0x898000008e2,
+        0x8e300000958,
+        0x96000000964,
+        0x96600000970,
+        0x97100000984,
+        0x9850000098d,
+        0x98f00000991,
+        0x993000009a9,
+        0x9aa000009b1,
+        0x9b2000009b3,
+        0x9b6000009ba,
+        0x9bc000009c5,
+        0x9c7000009c9,
+        0x9cb000009cf,
+        0x9d7000009d8,
+        0x9e0000009e4,
+        0x9e6000009f2,
+        0x9fc000009fd,
+        0x9fe000009ff,
+        0xa0100000a04,
+        0xa0500000a0b,
+        0xa0f00000a11,
+        0xa1300000a29,
+        0xa2a00000a31,
+        0xa3200000a33,
+        0xa3500000a36,
+        0xa3800000a3a,
+        0xa3c00000a3d,
+        0xa3e00000a43,
+        0xa4700000a49,
+        0xa4b00000a4e,
+        0xa5100000a52,
+        0xa5c00000a5d,
+        0xa6600000a76,
+        0xa8100000a84,
+        0xa8500000a8e,
+        0xa8f00000a92,
+        0xa9300000aa9,
+        0xaaa00000ab1,
+        0xab200000ab4,
+        0xab500000aba,
+        0xabc00000ac6,
+        0xac700000aca,
+        0xacb00000ace,
+        0xad000000ad1,
+        0xae000000ae4,
+        0xae600000af0,
+        0xaf900000b00,
+        0xb0100000b04,
+        0xb0500000b0d,
+        0xb0f00000b11,
+        0xb1300000b29,
+        0xb2a00000b31,
+        0xb3200000b34,
+        0xb3500000b3a,
+        0xb3c00000b45,
+        0xb4700000b49,
+        0xb4b00000b4e,
+        0xb5500000b58,
+        0xb5f00000b64,
+        0xb6600000b70,
+        0xb7100000b72,
+        0xb8200000b84,
+        0xb8500000b8b,
+        0xb8e00000b91,
+        0xb9200000b96,
+        0xb9900000b9b,
+        0xb9c00000b9d,
+        0xb9e00000ba0,
+        0xba300000ba5,
+        0xba800000bab,
+        0xbae00000bba,
+        0xbbe00000bc3,
+        0xbc600000bc9,
+        0xbca00000bce,
+        0xbd000000bd1,
+        0xbd700000bd8,
+        0xbe600000bf0,
+        0xc0000000c0d,
+        0xc0e00000c11,
+        0xc1200000c29,
+        0xc2a00000c3a,
+        0xc3c00000c45,
+        0xc4600000c49,
+        0xc4a00000c4e,
+        0xc5500000c57,
+        0xc5800000c5b,
+        0xc5d00000c5e,
+        0xc6000000c64,
+        0xc6600000c70,
+        0xc8000000c84,
+        0xc8500000c8d,
+        0xc8e00000c91,
+        0xc9200000ca9,
+        0xcaa00000cb4,
+        0xcb500000cba,
+        0xcbc00000cc5,
+        0xcc600000cc9,
+        0xcca00000cce,
+        0xcd500000cd7,
+        0xcdd00000cdf,
+        0xce000000ce4,
+        0xce600000cf0,
+        0xcf100000cf4,
+        0xd0000000d0d,
+        0xd0e00000d11,
+        0xd1200000d45,
+        0xd4600000d49,
+        0xd4a00000d4f,
+        0xd5400000d58,
+        0xd5f00000d64,
+        0xd6600000d70,
+        0xd7a00000d80,
+        0xd8100000d84,
+        0xd8500000d97,
+        0xd9a00000db2,
+        0xdb300000dbc,
+        0xdbd00000dbe,
+        0xdc000000dc7,
+        0xdca00000dcb,
+        0xdcf00000dd5,
+        0xdd600000dd7,
+        0xdd800000de0,
+        0xde600000df0,
+        0xdf200000df4,
+        0xe0100000e33,
+        0xe3400000e3b,
+        0xe4000000e4f,
+        0xe5000000e5a,
+        0xe8100000e83,
+        0xe8400000e85,
+        0xe8600000e8b,
+        0xe8c00000ea4,
+        0xea500000ea6,
+        0xea700000eb3,
+        0xeb400000ebe,
+        0xec000000ec5,
+        0xec600000ec7,
+        0xec800000ecf,
+        0xed000000eda,
+        0xede00000ee0,
+        0xf0000000f01,
+        0xf0b00000f0c,
+        0xf1800000f1a,
+        0xf2000000f2a,
+        0xf3500000f36,
+        0xf3700000f38,
+        0xf3900000f3a,
+        0xf3e00000f43,
+        0xf4400000f48,
+        0xf4900000f4d,
+        0xf4e00000f52,
+        0xf5300000f57,
+        0xf5800000f5c,
+        0xf5d00000f69,
+        0xf6a00000f6d,
+        0xf7100000f73,
+        0xf7400000f75,
+        0xf7a00000f81,
+        0xf8200000f85,
+        0xf8600000f93,
+        0xf9400000f98,
+        0xf9900000f9d,
+        0xf9e00000fa2,
+        0xfa300000fa7,
+        0xfa800000fac,
+        0xfad00000fb9,
+        0xfba00000fbd,
+        0xfc600000fc7,
+        0x10000000104a,
+        0x10500000109e,
+        0x10d0000010fb,
+        0x10fd00001100,
+        0x120000001249,
+        0x124a0000124e,
+        0x125000001257,
+        0x125800001259,
+        0x125a0000125e,
+        0x126000001289,
+        0x128a0000128e,
+        0x1290000012b1,
+        0x12b2000012b6,
+        0x12b8000012bf,
+        0x12c0000012c1,
+        0x12c2000012c6,
+        0x12c8000012d7,
+        0x12d800001311,
+        0x131200001316,
+        0x13180000135b,
+        0x135d00001360,
+        0x138000001390,
+        0x13a0000013f6,
+        0x14010000166d,
+        0x166f00001680,
+        0x16810000169b,
+        0x16a0000016eb,
+        0x16f1000016f9,
+        0x170000001716,
+        0x171f00001735,
+        0x174000001754,
+        0x17600000176d,
+        0x176e00001771,
+        0x177200001774,
+        0x1780000017b4,
+        0x17b6000017d4,
+        0x17d7000017d8,
+        0x17dc000017de,
+        0x17e0000017ea,
+        0x18100000181a,
+        0x182000001879,
+        0x1880000018ab,
+        0x18b0000018f6,
+        0x19000000191f,
+        0x19200000192c,
+        0x19300000193c,
+        0x19460000196e,
+        0x197000001975,
+        0x1980000019ac,
+        0x19b0000019ca,
+        0x19d0000019da,
+        0x1a0000001a1c,
+        0x1a2000001a5f,
+        0x1a6000001a7d,
+        0x1a7f00001a8a,
+        0x1a9000001a9a,
+        0x1aa700001aa8,
+        0x1ab000001abe,
+        0x1abf00001acf,
+        0x1b0000001b4d,
+        0x1b5000001b5a,
+        0x1b6b00001b74,
+        0x1b8000001bf4,
+        0x1c0000001c38,
+        0x1c4000001c4a,
+        0x1c4d00001c7e,
+        0x1cd000001cd3,
+        0x1cd400001cfb,
+        0x1d0000001d2c,
+        0x1d2f00001d30,
+        0x1d3b00001d3c,
+        0x1d4e00001d4f,
+        0x1d6b00001d78,
+        0x1d7900001d9b,
+        0x1dc000001e00,
+        0x1e0100001e02,
+        0x1e0300001e04,
+        0x1e0500001e06,
+        0x1e0700001e08,
+        0x1e0900001e0a,
+        0x1e0b00001e0c,
+        0x1e0d00001e0e,
+        0x1e0f00001e10,
+        0x1e1100001e12,
+        0x1e1300001e14,
+        0x1e1500001e16,
+        0x1e1700001e18,
+        0x1e1900001e1a,
+        0x1e1b00001e1c,
+        0x1e1d00001e1e,
+        0x1e1f00001e20,
+        0x1e2100001e22,
+        0x1e2300001e24,
+        0x1e2500001e26,
+        0x1e2700001e28,
+        0x1e2900001e2a,
+        0x1e2b00001e2c,
+        0x1e2d00001e2e,
+        0x1e2f00001e30,
+        0x1e3100001e32,
+        0x1e3300001e34,
+        0x1e3500001e36,
+        0x1e3700001e38,
+        0x1e3900001e3a,
+        0x1e3b00001e3c,
+        0x1e3d00001e3e,
+        0x1e3f00001e40,
+        0x1e4100001e42,
+        0x1e4300001e44,
+        0x1e4500001e46,
+        0x1e4700001e48,
+        0x1e4900001e4a,
+        0x1e4b00001e4c,
+        0x1e4d00001e4e,
+        0x1e4f00001e50,
+        0x1e5100001e52,
+        0x1e5300001e54,
+        0x1e5500001e56,
+        0x1e5700001e58,
+        0x1e5900001e5a,
+        0x1e5b00001e5c,
+        0x1e5d00001e5e,
+        0x1e5f00001e60,
+        0x1e6100001e62,
+        0x1e6300001e64,
+        0x1e6500001e66,
+        0x1e6700001e68,
+        0x1e6900001e6a,
+        0x1e6b00001e6c,
+        0x1e6d00001e6e,
+        0x1e6f00001e70,
+        0x1e7100001e72,
+        0x1e7300001e74,
+        0x1e7500001e76,
+        0x1e7700001e78,
+        0x1e7900001e7a,
+        0x1e7b00001e7c,
+        0x1e7d00001e7e,
+        0x1e7f00001e80,
+        0x1e8100001e82,
+        0x1e8300001e84,
+        0x1e8500001e86,
+        0x1e8700001e88,
+        0x1e8900001e8a,
+        0x1e8b00001e8c,
+        0x1e8d00001e8e,
+        0x1e8f00001e90,
+        0x1e9100001e92,
+        0x1e9300001e94,
+        0x1e9500001e9a,
+        0x1e9c00001e9e,
+        0x1e9f00001ea0,
+        0x1ea100001ea2,
+        0x1ea300001ea4,
+        0x1ea500001ea6,
+        0x1ea700001ea8,
+        0x1ea900001eaa,
+        0x1eab00001eac,
+        0x1ead00001eae,
+        0x1eaf00001eb0,
+        0x1eb100001eb2,
+        0x1eb300001eb4,
+        0x1eb500001eb6,
+        0x1eb700001eb8,
+        0x1eb900001eba,
+        0x1ebb00001ebc,
+        0x1ebd00001ebe,
+        0x1ebf00001ec0,
+        0x1ec100001ec2,
+        0x1ec300001ec4,
+        0x1ec500001ec6,
+        0x1ec700001ec8,
+        0x1ec900001eca,
+        0x1ecb00001ecc,
+        0x1ecd00001ece,
+        0x1ecf00001ed0,
+        0x1ed100001ed2,
+        0x1ed300001ed4,
+        0x1ed500001ed6,
+        0x1ed700001ed8,
+        0x1ed900001eda,
+        0x1edb00001edc,
+        0x1edd00001ede,
+        0x1edf00001ee0,
+        0x1ee100001ee2,
+        0x1ee300001ee4,
+        0x1ee500001ee6,
+        0x1ee700001ee8,
+        0x1ee900001eea,
+        0x1eeb00001eec,
+        0x1eed00001eee,
+        0x1eef00001ef0,
+        0x1ef100001ef2,
+        0x1ef300001ef4,
+        0x1ef500001ef6,
+        0x1ef700001ef8,
+        0x1ef900001efa,
+        0x1efb00001efc,
+        0x1efd00001efe,
+        0x1eff00001f08,
+        0x1f1000001f16,
+        0x1f2000001f28,
+        0x1f3000001f38,
+        0x1f4000001f46,
+        0x1f5000001f58,
+        0x1f6000001f68,
+        0x1f7000001f71,
+        0x1f7200001f73,
+        0x1f7400001f75,
+        0x1f7600001f77,
+        0x1f7800001f79,
+        0x1f7a00001f7b,
+        0x1f7c00001f7d,
+        0x1fb000001fb2,
+        0x1fb600001fb7,
+        0x1fc600001fc7,
+        0x1fd000001fd3,
+        0x1fd600001fd8,
+        0x1fe000001fe3,
+        0x1fe400001fe8,
+        0x1ff600001ff7,
+        0x214e0000214f,
+        0x218400002185,
+        0x2c3000002c60,
+        0x2c6100002c62,
+        0x2c6500002c67,
+        0x2c6800002c69,
+        0x2c6a00002c6b,
+        0x2c6c00002c6d,
+        0x2c7100002c72,
+        0x2c7300002c75,
+        0x2c7600002c7c,
+        0x2c8100002c82,
+        0x2c8300002c84,
+        0x2c8500002c86,
+        0x2c8700002c88,
+        0x2c8900002c8a,
+        0x2c8b00002c8c,
+        0x2c8d00002c8e,
+        0x2c8f00002c90,
+        0x2c9100002c92,
+        0x2c9300002c94,
+        0x2c9500002c96,
+        0x2c9700002c98,
+        0x2c9900002c9a,
+        0x2c9b00002c9c,
+        0x2c9d00002c9e,
+        0x2c9f00002ca0,
+        0x2ca100002ca2,
+        0x2ca300002ca4,
+        0x2ca500002ca6,
+        0x2ca700002ca8,
+        0x2ca900002caa,
+        0x2cab00002cac,
+        0x2cad00002cae,
+        0x2caf00002cb0,
+        0x2cb100002cb2,
+        0x2cb300002cb4,
+        0x2cb500002cb6,
+        0x2cb700002cb8,
+        0x2cb900002cba,
+        0x2cbb00002cbc,
+        0x2cbd00002cbe,
+        0x2cbf00002cc0,
+        0x2cc100002cc2,
+        0x2cc300002cc4,
+        0x2cc500002cc6,
+        0x2cc700002cc8,
+        0x2cc900002cca,
+        0x2ccb00002ccc,
+        0x2ccd00002cce,
+        0x2ccf00002cd0,
+        0x2cd100002cd2,
+        0x2cd300002cd4,
+        0x2cd500002cd6,
+        0x2cd700002cd8,
+        0x2cd900002cda,
+        0x2cdb00002cdc,
+        0x2cdd00002cde,
+        0x2cdf00002ce0,
+        0x2ce100002ce2,
+        0x2ce300002ce5,
+        0x2cec00002ced,
+        0x2cee00002cf2,
+        0x2cf300002cf4,
+        0x2d0000002d26,
+        0x2d2700002d28,
+        0x2d2d00002d2e,
+        0x2d3000002d68,
+        0x2d7f00002d97,
+        0x2da000002da7,
+        0x2da800002daf,
+        0x2db000002db7,
+        0x2db800002dbf,
+        0x2dc000002dc7,
+        0x2dc800002dcf,
+        0x2dd000002dd7,
+        0x2dd800002ddf,
+        0x2de000002e00,
+        0x2e2f00002e30,
+        0x300500003008,
+        0x302a0000302e,
+        0x303c0000303d,
+        0x304100003097,
+        0x30990000309b,
+        0x309d0000309f,
+        0x30a1000030fb,
+        0x30fc000030ff,
+        0x310500003130,
+        0x31a0000031c0,
+        0x31f000003200,
+        0x340000004dc0,
+        0x4e000000a48d,
+        0xa4d00000a4fe,
+        0xa5000000a60d,
+        0xa6100000a62c,
+        0xa6410000a642,
+        0xa6430000a644,
+        0xa6450000a646,
+        0xa6470000a648,
+        0xa6490000a64a,
+        0xa64b0000a64c,
+        0xa64d0000a64e,
+        0xa64f0000a650,
+        0xa6510000a652,
+        0xa6530000a654,
+        0xa6550000a656,
+        0xa6570000a658,
+        0xa6590000a65a,
+        0xa65b0000a65c,
+        0xa65d0000a65e,
+        0xa65f0000a660,
+        0xa6610000a662,
+        0xa6630000a664,
+        0xa6650000a666,
+        0xa6670000a668,
+        0xa6690000a66a,
+        0xa66b0000a66c,
+        0xa66d0000a670,
+        0xa6740000a67e,
+        0xa67f0000a680,
+        0xa6810000a682,
+        0xa6830000a684,
+        0xa6850000a686,
+        0xa6870000a688,
+        0xa6890000a68a,
+        0xa68b0000a68c,
+        0xa68d0000a68e,
+        0xa68f0000a690,
+        0xa6910000a692,
+        0xa6930000a694,
+        0xa6950000a696,
+        0xa6970000a698,
+        0xa6990000a69a,
+        0xa69b0000a69c,
+        0xa69e0000a6e6,
+        0xa6f00000a6f2,
+        0xa7170000a720,
+        0xa7230000a724,
+        0xa7250000a726,
+        0xa7270000a728,
+        0xa7290000a72a,
+        0xa72b0000a72c,
+        0xa72d0000a72e,
+        0xa72f0000a732,
+        0xa7330000a734,
+        0xa7350000a736,
+        0xa7370000a738,
+        0xa7390000a73a,
+        0xa73b0000a73c,
+        0xa73d0000a73e,
+        0xa73f0000a740,
+        0xa7410000a742,
+        0xa7430000a744,
+        0xa7450000a746,
+        0xa7470000a748,
+        0xa7490000a74a,
+        0xa74b0000a74c,
+        0xa74d0000a74e,
+        0xa74f0000a750,
+        0xa7510000a752,
+        0xa7530000a754,
+        0xa7550000a756,
+        0xa7570000a758,
+        0xa7590000a75a,
+        0xa75b0000a75c,
+        0xa75d0000a75e,
+        0xa75f0000a760,
+        0xa7610000a762,
+        0xa7630000a764,
+        0xa7650000a766,
+        0xa7670000a768,
+        0xa7690000a76a,
+        0xa76b0000a76c,
+        0xa76d0000a76e,
+        0xa76f0000a770,
+        0xa7710000a779,
+        0xa77a0000a77b,
+        0xa77c0000a77d,
+        0xa77f0000a780,
+        0xa7810000a782,
+        0xa7830000a784,
+        0xa7850000a786,
+        0xa7870000a789,
+        0xa78c0000a78d,
+        0xa78e0000a790,
+        0xa7910000a792,
+        0xa7930000a796,
+        0xa7970000a798,
+        0xa7990000a79a,
+        0xa79b0000a79c,
+        0xa79d0000a79e,
+        0xa79f0000a7a0,
+        0xa7a10000a7a2,
+        0xa7a30000a7a4,
+        0xa7a50000a7a6,
+        0xa7a70000a7a8,
+        0xa7a90000a7aa,
+        0xa7af0000a7b0,
+        0xa7b50000a7b6,
+        0xa7b70000a7b8,
+        0xa7b90000a7ba,
+        0xa7bb0000a7bc,
+        0xa7bd0000a7be,
+        0xa7bf0000a7c0,
+        0xa7c10000a7c2,
+        0xa7c30000a7c4,
+        0xa7c80000a7c9,
+        0xa7ca0000a7cb,
+        0xa7d10000a7d2,
+        0xa7d30000a7d4,
+        0xa7d50000a7d6,
+        0xa7d70000a7d8,
+        0xa7d90000a7da,
+        0xa7f60000a7f8,
+        0xa7fa0000a828,
+        0xa82c0000a82d,
+        0xa8400000a874,
+        0xa8800000a8c6,
+        0xa8d00000a8da,
+        0xa8e00000a8f8,
+        0xa8fb0000a8fc,
+        0xa8fd0000a92e,
+        0xa9300000a954,
+        0xa9800000a9c1,
+        0xa9cf0000a9da,
+        0xa9e00000a9ff,
+        0xaa000000aa37,
+        0xaa400000aa4e,
+        0xaa500000aa5a,
+        0xaa600000aa77,
+        0xaa7a0000aac3,
+        0xaadb0000aade,
+        0xaae00000aaf0,
+        0xaaf20000aaf7,
+        0xab010000ab07,
+        0xab090000ab0f,
+        0xab110000ab17,
+        0xab200000ab27,
+        0xab280000ab2f,
+        0xab300000ab5b,
+        0xab600000ab69,
+        0xabc00000abeb,
+        0xabec0000abee,
+        0xabf00000abfa,
+        0xac000000d7a4,
+        0xfa0e0000fa10,
+        0xfa110000fa12,
+        0xfa130000fa15,
+        0xfa1f0000fa20,
+        0xfa210000fa22,
+        0xfa230000fa25,
+        0xfa270000fa2a,
+        0xfb1e0000fb1f,
+        0xfe200000fe30,
+        0xfe730000fe74,
+        0x100000001000c,
+        0x1000d00010027,
+        0x100280001003b,
+        0x1003c0001003e,
+        0x1003f0001004e,
+        0x100500001005e,
+        0x10080000100fb,
+        0x101fd000101fe,
+        0x102800001029d,
+        0x102a0000102d1,
+        0x102e0000102e1,
+        0x1030000010320,
+        0x1032d00010341,
+        0x103420001034a,
+        0x103500001037b,
+        0x103800001039e,
+        0x103a0000103c4,
+        0x103c8000103d0,
+        0x104280001049e,
+        0x104a0000104aa,
+        0x104d8000104fc,
+        0x1050000010528,
+        0x1053000010564,
+        0x10597000105a2,
+        0x105a3000105b2,
+        0x105b3000105ba,
+        0x105bb000105bd,
+        0x1060000010737,
+        0x1074000010756,
+        0x1076000010768,
+        0x1078000010781,
+        0x1080000010806,
+        0x1080800010809,
+        0x1080a00010836,
+        0x1083700010839,
+        0x1083c0001083d,
+        0x1083f00010856,
+        0x1086000010877,
+        0x108800001089f,
+        0x108e0000108f3,
+        0x108f4000108f6,
+        0x1090000010916,
+        0x109200001093a,
+        0x10980000109b8,
+        0x109be000109c0,
+        0x10a0000010a04,
+        0x10a0500010a07,
+        0x10a0c00010a14,
+        0x10a1500010a18,
+        0x10a1900010a36,
+        0x10a3800010a3b,
+        0x10a3f00010a40,
+        0x10a6000010a7d,
+        0x10a8000010a9d,
+        0x10ac000010ac8,
+        0x10ac900010ae7,
+        0x10b0000010b36,
+        0x10b4000010b56,
+        0x10b6000010b73,
+        0x10b8000010b92,
+        0x10c0000010c49,
+        0x10cc000010cf3,
+        0x10d0000010d28,
+        0x10d3000010d3a,
+        0x10e8000010eaa,
+        0x10eab00010ead,
+        0x10eb000010eb2,
+        0x10efd00010f1d,
+        0x10f2700010f28,
+        0x10f3000010f51,
+        0x10f7000010f86,
+        0x10fb000010fc5,
+        0x10fe000010ff7,
+        0x1100000011047,
+        0x1106600011076,
+        0x1107f000110bb,
+        0x110c2000110c3,
+        0x110d0000110e9,
+        0x110f0000110fa,
+        0x1110000011135,
+        0x1113600011140,
+        0x1114400011148,
+        0x1115000011174,
+        0x1117600011177,
+        0x11180000111c5,
+        0x111c9000111cd,
+        0x111ce000111db,
+        0x111dc000111dd,
+        0x1120000011212,
+        0x1121300011238,
+        0x1123e00011242,
+        0x1128000011287,
+        0x1128800011289,
+        0x1128a0001128e,
+        0x1128f0001129e,
+        0x1129f000112a9,
+        0x112b0000112eb,
+        0x112f0000112fa,
+        0x1130000011304,
+        0x113050001130d,
+        0x1130f00011311,
+        0x1131300011329,
+        0x1132a00011331,
+        0x1133200011334,
+        0x113350001133a,
+        0x1133b00011345,
+        0x1134700011349,
+        0x1134b0001134e,
+        0x1135000011351,
+        0x1135700011358,
+        0x1135d00011364,
+        0x113660001136d,
+        0x1137000011375,
+        0x114000001144b,
+        0x114500001145a,
+        0x1145e00011462,
+        0x11480000114c6,
+        0x114c7000114c8,
+        0x114d0000114da,
+        0x11580000115b6,
+        0x115b8000115c1,
+        0x115d8000115de,
+        0x1160000011641,
+        0x1164400011645,
+        0x116500001165a,
+        0x11680000116b9,
+        0x116c0000116ca,
+        0x117000001171b,
+        0x1171d0001172c,
+        0x117300001173a,
+        0x1174000011747,
+        0x118000001183b,
+        0x118c0000118ea,
+        0x118ff00011907,
+        0x119090001190a,
+        0x1190c00011914,
+        0x1191500011917,
+        0x1191800011936,
+        0x1193700011939,
+        0x1193b00011944,
+        0x119500001195a,
+        0x119a0000119a8,
+        0x119aa000119d8,
+        0x119da000119e2,
+        0x119e3000119e5,
+        0x11a0000011a3f,
+        0x11a4700011a48,
+        0x11a5000011a9a,
+        0x11a9d00011a9e,
+        0x11ab000011af9,
+        0x11c0000011c09,
+        0x11c0a00011c37,
+        0x11c3800011c41,
+        0x11c5000011c5a,
+        0x11c7200011c90,
+        0x11c9200011ca8,
+        0x11ca900011cb7,
+        0x11d0000011d07,
+        0x11d0800011d0a,
+        0x11d0b00011d37,
+        0x11d3a00011d3b,
+        0x11d3c00011d3e,
+        0x11d3f00011d48,
+        0x11d5000011d5a,
+        0x11d6000011d66,
+        0x11d6700011d69,
+        0x11d6a00011d8f,
+        0x11d9000011d92,
+        0x11d9300011d99,
+        0x11da000011daa,
+        0x11ee000011ef7,
+        0x11f0000011f11,
+        0x11f1200011f3b,
+        0x11f3e00011f43,
+        0x11f5000011f5a,
+        0x11fb000011fb1,
+        0x120000001239a,
+        0x1248000012544,
+        0x12f9000012ff1,
+        0x1300000013430,
+        0x1344000013456,
+        0x1440000014647,
+        0x1680000016a39,
+        0x16a4000016a5f,
+        0x16a6000016a6a,
+        0x16a7000016abf,
+        0x16ac000016aca,
+        0x16ad000016aee,
+        0x16af000016af5,
+        0x16b0000016b37,
+        0x16b4000016b44,
+        0x16b5000016b5a,
+        0x16b6300016b78,
+        0x16b7d00016b90,
+        0x16e6000016e80,
+        0x16f0000016f4b,
+        0x16f4f00016f88,
+        0x16f8f00016fa0,
+        0x16fe000016fe2,
+        0x16fe300016fe5,
+        0x16ff000016ff2,
+        0x17000000187f8,
+        0x1880000018cd6,
+        0x18d0000018d09,
+        0x1aff00001aff4,
+        0x1aff50001affc,
+        0x1affd0001afff,
+        0x1b0000001b123,
+        0x1b1320001b133,
+        0x1b1500001b153,
+        0x1b1550001b156,
+        0x1b1640001b168,
+        0x1b1700001b2fc,
+        0x1bc000001bc6b,
+        0x1bc700001bc7d,
+        0x1bc800001bc89,
+        0x1bc900001bc9a,
+        0x1bc9d0001bc9f,
+        0x1cf000001cf2e,
+        0x1cf300001cf47,
+        0x1da000001da37,
+        0x1da3b0001da6d,
+        0x1da750001da76,
+        0x1da840001da85,
+        0x1da9b0001daa0,
+        0x1daa10001dab0,
+        0x1df000001df1f,
+        0x1df250001df2b,
+        0x1e0000001e007,
+        0x1e0080001e019,
+        0x1e01b0001e022,
+        0x1e0230001e025,
+        0x1e0260001e02b,
+        0x1e08f0001e090,
+        0x1e1000001e12d,
+        0x1e1300001e13e,
+        0x1e1400001e14a,
+        0x1e14e0001e14f,
+        0x1e2900001e2af,
+        0x1e2c00001e2fa,
+        0x1e4d00001e4fa,
+        0x1e7e00001e7e7,
+        0x1e7e80001e7ec,
+        0x1e7ed0001e7ef,
+        0x1e7f00001e7ff,
+        0x1e8000001e8c5,
+        0x1e8d00001e8d7,
+        0x1e9220001e94c,
+        0x1e9500001e95a,
+        0x200000002a6e0,
+        0x2a7000002b73a,
+        0x2b7400002b81e,
+        0x2b8200002cea2,
+        0x2ceb00002ebe1,
+        0x2ebf00002ee5e,
+        0x300000003134b,
+        0x31350000323b0,
+    ),
+    'CONTEXTJ': (
+        0x200c0000200e,
+    ),
+    'CONTEXTO': (
+        0xb7000000b8,
+        0x37500000376,
+        0x5f3000005f5,
+        0x6600000066a,
+        0x6f0000006fa,
+        0x30fb000030fc,
+    ),
+}
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/idna/intranges.py b/venv/lib/python3.12/site-packages/pip/_vendor/idna/intranges.py
new file mode 100644
index 00000000..6a43b047
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_vendor/idna/intranges.py
@@ -0,0 +1,54 @@
+"""
+Given a list of integers, made up of (hopefully) a small number of long runs
+of consecutive integers, compute a representation of the form
+((start1, end1), (start2, end2) ...). Then answer the question "was x present
+in the original list?" in time O(log(# runs)).
+"""
+
+import bisect
+from typing import List, Tuple
+
+def intranges_from_list(list_: List[int]) -> Tuple[int, ...]:
+    """Represent a list of integers as a sequence of ranges:
+    ((start_0, end_0), (start_1, end_1), ...), such that the original
+    integers are exactly those x such that start_i <= x < end_i for some i.
+
+    Ranges are encoded as single integers (start << 32 | end), not as tuples.
+    """
+
+    sorted_list = sorted(list_)
+    ranges = []
+    last_write = -1
+    for i in range(len(sorted_list)):
+        if i+1 < len(sorted_list):
+            if sorted_list[i] == sorted_list[i+1]-1:
+                continue
+        current_range = sorted_list[last_write+1:i+1]
+        ranges.append(_encode_range(current_range[0], current_range[-1] + 1))
+        last_write = i
+
+    return tuple(ranges)
+
+def _encode_range(start: int, end: int) -> int:
+    return (start << 32) | end
+
+def _decode_range(r: int) -> Tuple[int, int]:
+    return (r >> 32), (r & ((1 << 32) - 1))
+
+
+def intranges_contain(int_: int, ranges: Tuple[int, ...]) -> bool:
+    """Determine if `int_` falls into one of the ranges in `ranges`."""
+    tuple_ = _encode_range(int_, 0)
+    pos = bisect.bisect_left(ranges, tuple_)
+    # we could be immediately ahead of a tuple (start, end)
+    # with start < int_ <= end
+    if pos > 0:
+        left, right = _decode_range(ranges[pos-1])
+        if left <= int_ < right:
+            return True
+    # or we could be immediately behind a tuple (int_, end)
+    if pos < len(ranges):
+        left, _ = _decode_range(ranges[pos])
+        if left == int_:
+            return True
+    return False
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/idna/package_data.py b/venv/lib/python3.12/site-packages/pip/_vendor/idna/package_data.py
new file mode 100644
index 00000000..ed811133
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_vendor/idna/package_data.py
@@ -0,0 +1,2 @@
+__version__ = '3.7'
+
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/idna/py.typed b/venv/lib/python3.12/site-packages/pip/_vendor/idna/py.typed
new file mode 100644
index 00000000..e69de29b
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/idna/uts46data.py b/venv/lib/python3.12/site-packages/pip/_vendor/idna/uts46data.py
new file mode 100644
index 00000000..6a1eddbf
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_vendor/idna/uts46data.py
@@ -0,0 +1,8598 @@
+# This file is automatically generated by tools/idna-data
+# vim: set fileencoding=utf-8 :
+
+from typing import List, Tuple, Union
+
+
+"""IDNA Mapping Table from UTS46."""
+
+
+__version__ = '15.1.0'
+def _seg_0() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x0, '3'),
+    (0x1, '3'),
+    (0x2, '3'),
+    (0x3, '3'),
+    (0x4, '3'),
+    (0x5, '3'),
+    (0x6, '3'),
+    (0x7, '3'),
+    (0x8, '3'),
+    (0x9, '3'),
+    (0xA, '3'),
+    (0xB, '3'),
+    (0xC, '3'),
+    (0xD, '3'),
+    (0xE, '3'),
+    (0xF, '3'),
+    (0x10, '3'),
+    (0x11, '3'),
+    (0x12, '3'),
+    (0x13, '3'),
+    (0x14, '3'),
+    (0x15, '3'),
+    (0x16, '3'),
+    (0x17, '3'),
+    (0x18, '3'),
+    (0x19, '3'),
+    (0x1A, '3'),
+    (0x1B, '3'),
+    (0x1C, '3'),
+    (0x1D, '3'),
+    (0x1E, '3'),
+    (0x1F, '3'),
+    (0x20, '3'),
+    (0x21, '3'),
+    (0x22, '3'),
+    (0x23, '3'),
+    (0x24, '3'),
+    (0x25, '3'),
+    (0x26, '3'),
+    (0x27, '3'),
+    (0x28, '3'),
+    (0x29, '3'),
+    (0x2A, '3'),
+    (0x2B, '3'),
+    (0x2C, '3'),
+    (0x2D, 'V'),
+    (0x2E, 'V'),
+    (0x2F, '3'),
+    (0x30, 'V'),
+    (0x31, 'V'),
+    (0x32, 'V'),
+    (0x33, 'V'),
+    (0x34, 'V'),
+    (0x35, 'V'),
+    (0x36, 'V'),
+    (0x37, 'V'),
+    (0x38, 'V'),
+    (0x39, 'V'),
+    (0x3A, '3'),
+    (0x3B, '3'),
+    (0x3C, '3'),
+    (0x3D, '3'),
+    (0x3E, '3'),
+    (0x3F, '3'),
+    (0x40, '3'),
+    (0x41, 'M', 'a'),
+    (0x42, 'M', 'b'),
+    (0x43, 'M', 'c'),
+    (0x44, 'M', 'd'),
+    (0x45, 'M', 'e'),
+    (0x46, 'M', 'f'),
+    (0x47, 'M', 'g'),
+    (0x48, 'M', 'h'),
+    (0x49, 'M', 'i'),
+    (0x4A, 'M', 'j'),
+    (0x4B, 'M', 'k'),
+    (0x4C, 'M', 'l'),
+    (0x4D, 'M', 'm'),
+    (0x4E, 'M', 'n'),
+    (0x4F, 'M', 'o'),
+    (0x50, 'M', 'p'),
+    (0x51, 'M', 'q'),
+    (0x52, 'M', 'r'),
+    (0x53, 'M', 's'),
+    (0x54, 'M', 't'),
+    (0x55, 'M', 'u'),
+    (0x56, 'M', 'v'),
+    (0x57, 'M', 'w'),
+    (0x58, 'M', 'x'),
+    (0x59, 'M', 'y'),
+    (0x5A, 'M', 'z'),
+    (0x5B, '3'),
+    (0x5C, '3'),
+    (0x5D, '3'),
+    (0x5E, '3'),
+    (0x5F, '3'),
+    (0x60, '3'),
+    (0x61, 'V'),
+    (0x62, 'V'),
+    (0x63, 'V'),
+    ]
+
+def _seg_1() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x64, 'V'),
+    (0x65, 'V'),
+    (0x66, 'V'),
+    (0x67, 'V'),
+    (0x68, 'V'),
+    (0x69, 'V'),
+    (0x6A, 'V'),
+    (0x6B, 'V'),
+    (0x6C, 'V'),
+    (0x6D, 'V'),
+    (0x6E, 'V'),
+    (0x6F, 'V'),
+    (0x70, 'V'),
+    (0x71, 'V'),
+    (0x72, 'V'),
+    (0x73, 'V'),
+    (0x74, 'V'),
+    (0x75, 'V'),
+    (0x76, 'V'),
+    (0x77, 'V'),
+    (0x78, 'V'),
+    (0x79, 'V'),
+    (0x7A, 'V'),
+    (0x7B, '3'),
+    (0x7C, '3'),
+    (0x7D, '3'),
+    (0x7E, '3'),
+    (0x7F, '3'),
+    (0x80, 'X'),
+    (0x81, 'X'),
+    (0x82, 'X'),
+    (0x83, 'X'),
+    (0x84, 'X'),
+    (0x85, 'X'),
+    (0x86, 'X'),
+    (0x87, 'X'),
+    (0x88, 'X'),
+    (0x89, 'X'),
+    (0x8A, 'X'),
+    (0x8B, 'X'),
+    (0x8C, 'X'),
+    (0x8D, 'X'),
+    (0x8E, 'X'),
+    (0x8F, 'X'),
+    (0x90, 'X'),
+    (0x91, 'X'),
+    (0x92, 'X'),
+    (0x93, 'X'),
+    (0x94, 'X'),
+    (0x95, 'X'),
+    (0x96, 'X'),
+    (0x97, 'X'),
+    (0x98, 'X'),
+    (0x99, 'X'),
+    (0x9A, 'X'),
+    (0x9B, 'X'),
+    (0x9C, 'X'),
+    (0x9D, 'X'),
+    (0x9E, 'X'),
+    (0x9F, 'X'),
+    (0xA0, '3', ' '),
+    (0xA1, 'V'),
+    (0xA2, 'V'),
+    (0xA3, 'V'),
+    (0xA4, 'V'),
+    (0xA5, 'V'),
+    (0xA6, 'V'),
+    (0xA7, 'V'),
+    (0xA8, '3', ' ̈'),
+    (0xA9, 'V'),
+    (0xAA, 'M', 'a'),
+    (0xAB, 'V'),
+    (0xAC, 'V'),
+    (0xAD, 'I'),
+    (0xAE, 'V'),
+    (0xAF, '3', ' ̄'),
+    (0xB0, 'V'),
+    (0xB1, 'V'),
+    (0xB2, 'M', '2'),
+    (0xB3, 'M', '3'),
+    (0xB4, '3', ' ́'),
+    (0xB5, 'M', 'μ'),
+    (0xB6, 'V'),
+    (0xB7, 'V'),
+    (0xB8, '3', ' ̧'),
+    (0xB9, 'M', '1'),
+    (0xBA, 'M', 'o'),
+    (0xBB, 'V'),
+    (0xBC, 'M', '1⁄4'),
+    (0xBD, 'M', '1⁄2'),
+    (0xBE, 'M', '3⁄4'),
+    (0xBF, 'V'),
+    (0xC0, 'M', 'à'),
+    (0xC1, 'M', 'á'),
+    (0xC2, 'M', 'â'),
+    (0xC3, 'M', 'ã'),
+    (0xC4, 'M', 'ä'),
+    (0xC5, 'M', 'å'),
+    (0xC6, 'M', 'æ'),
+    (0xC7, 'M', 'ç'),
+    ]
+
+def _seg_2() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0xC8, 'M', 'è'),
+    (0xC9, 'M', 'é'),
+    (0xCA, 'M', 'ê'),
+    (0xCB, 'M', 'ë'),
+    (0xCC, 'M', 'ì'),
+    (0xCD, 'M', 'í'),
+    (0xCE, 'M', 'î'),
+    (0xCF, 'M', 'ï'),
+    (0xD0, 'M', 'ð'),
+    (0xD1, 'M', 'ñ'),
+    (0xD2, 'M', 'ò'),
+    (0xD3, 'M', 'ó'),
+    (0xD4, 'M', 'ô'),
+    (0xD5, 'M', 'õ'),
+    (0xD6, 'M', 'ö'),
+    (0xD7, 'V'),
+    (0xD8, 'M', 'ø'),
+    (0xD9, 'M', 'ù'),
+    (0xDA, 'M', 'ú'),
+    (0xDB, 'M', 'û'),
+    (0xDC, 'M', 'ü'),
+    (0xDD, 'M', 'ý'),
+    (0xDE, 'M', 'þ'),
+    (0xDF, 'D', 'ss'),
+    (0xE0, 'V'),
+    (0xE1, 'V'),
+    (0xE2, 'V'),
+    (0xE3, 'V'),
+    (0xE4, 'V'),
+    (0xE5, 'V'),
+    (0xE6, 'V'),
+    (0xE7, 'V'),
+    (0xE8, 'V'),
+    (0xE9, 'V'),
+    (0xEA, 'V'),
+    (0xEB, 'V'),
+    (0xEC, 'V'),
+    (0xED, 'V'),
+    (0xEE, 'V'),
+    (0xEF, 'V'),
+    (0xF0, 'V'),
+    (0xF1, 'V'),
+    (0xF2, 'V'),
+    (0xF3, 'V'),
+    (0xF4, 'V'),
+    (0xF5, 'V'),
+    (0xF6, 'V'),
+    (0xF7, 'V'),
+    (0xF8, 'V'),
+    (0xF9, 'V'),
+    (0xFA, 'V'),
+    (0xFB, 'V'),
+    (0xFC, 'V'),
+    (0xFD, 'V'),
+    (0xFE, 'V'),
+    (0xFF, 'V'),
+    (0x100, 'M', 'ā'),
+    (0x101, 'V'),
+    (0x102, 'M', 'ă'),
+    (0x103, 'V'),
+    (0x104, 'M', 'ą'),
+    (0x105, 'V'),
+    (0x106, 'M', 'ć'),
+    (0x107, 'V'),
+    (0x108, 'M', 'ĉ'),
+    (0x109, 'V'),
+    (0x10A, 'M', 'ċ'),
+    (0x10B, 'V'),
+    (0x10C, 'M', 'č'),
+    (0x10D, 'V'),
+    (0x10E, 'M', 'ď'),
+    (0x10F, 'V'),
+    (0x110, 'M', 'đ'),
+    (0x111, 'V'),
+    (0x112, 'M', 'ē'),
+    (0x113, 'V'),
+    (0x114, 'M', 'ĕ'),
+    (0x115, 'V'),
+    (0x116, 'M', 'ė'),
+    (0x117, 'V'),
+    (0x118, 'M', 'ę'),
+    (0x119, 'V'),
+    (0x11A, 'M', 'ě'),
+    (0x11B, 'V'),
+    (0x11C, 'M', 'ĝ'),
+    (0x11D, 'V'),
+    (0x11E, 'M', 'ğ'),
+    (0x11F, 'V'),
+    (0x120, 'M', 'ġ'),
+    (0x121, 'V'),
+    (0x122, 'M', 'ģ'),
+    (0x123, 'V'),
+    (0x124, 'M', 'ĥ'),
+    (0x125, 'V'),
+    (0x126, 'M', 'ħ'),
+    (0x127, 'V'),
+    (0x128, 'M', 'ĩ'),
+    (0x129, 'V'),
+    (0x12A, 'M', 'ī'),
+    (0x12B, 'V'),
+    ]
+
+def _seg_3() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x12C, 'M', 'ĭ'),
+    (0x12D, 'V'),
+    (0x12E, 'M', 'į'),
+    (0x12F, 'V'),
+    (0x130, 'M', 'i̇'),
+    (0x131, 'V'),
+    (0x132, 'M', 'ij'),
+    (0x134, 'M', 'ĵ'),
+    (0x135, 'V'),
+    (0x136, 'M', 'ķ'),
+    (0x137, 'V'),
+    (0x139, 'M', 'ĺ'),
+    (0x13A, 'V'),
+    (0x13B, 'M', 'ļ'),
+    (0x13C, 'V'),
+    (0x13D, 'M', 'ľ'),
+    (0x13E, 'V'),
+    (0x13F, 'M', 'l·'),
+    (0x141, 'M', 'ł'),
+    (0x142, 'V'),
+    (0x143, 'M', 'ń'),
+    (0x144, 'V'),
+    (0x145, 'M', 'ņ'),
+    (0x146, 'V'),
+    (0x147, 'M', 'ň'),
+    (0x148, 'V'),
+    (0x149, 'M', 'ʼn'),
+    (0x14A, 'M', 'ŋ'),
+    (0x14B, 'V'),
+    (0x14C, 'M', 'ō'),
+    (0x14D, 'V'),
+    (0x14E, 'M', 'ŏ'),
+    (0x14F, 'V'),
+    (0x150, 'M', 'ő'),
+    (0x151, 'V'),
+    (0x152, 'M', 'œ'),
+    (0x153, 'V'),
+    (0x154, 'M', 'ŕ'),
+    (0x155, 'V'),
+    (0x156, 'M', 'ŗ'),
+    (0x157, 'V'),
+    (0x158, 'M', 'ř'),
+    (0x159, 'V'),
+    (0x15A, 'M', 'ś'),
+    (0x15B, 'V'),
+    (0x15C, 'M', 'ŝ'),
+    (0x15D, 'V'),
+    (0x15E, 'M', 'ş'),
+    (0x15F, 'V'),
+    (0x160, 'M', 'š'),
+    (0x161, 'V'),
+    (0x162, 'M', 'ţ'),
+    (0x163, 'V'),
+    (0x164, 'M', 'ť'),
+    (0x165, 'V'),
+    (0x166, 'M', 'ŧ'),
+    (0x167, 'V'),
+    (0x168, 'M', 'ũ'),
+    (0x169, 'V'),
+    (0x16A, 'M', 'ū'),
+    (0x16B, 'V'),
+    (0x16C, 'M', 'ŭ'),
+    (0x16D, 'V'),
+    (0x16E, 'M', 'ů'),
+    (0x16F, 'V'),
+    (0x170, 'M', 'ű'),
+    (0x171, 'V'),
+    (0x172, 'M', 'ų'),
+    (0x173, 'V'),
+    (0x174, 'M', 'ŵ'),
+    (0x175, 'V'),
+    (0x176, 'M', 'ŷ'),
+    (0x177, 'V'),
+    (0x178, 'M', 'ÿ'),
+    (0x179, 'M', 'ź'),
+    (0x17A, 'V'),
+    (0x17B, 'M', 'ż'),
+    (0x17C, 'V'),
+    (0x17D, 'M', 'ž'),
+    (0x17E, 'V'),
+    (0x17F, 'M', 's'),
+    (0x180, 'V'),
+    (0x181, 'M', 'ɓ'),
+    (0x182, 'M', 'ƃ'),
+    (0x183, 'V'),
+    (0x184, 'M', 'ƅ'),
+    (0x185, 'V'),
+    (0x186, 'M', 'ɔ'),
+    (0x187, 'M', 'ƈ'),
+    (0x188, 'V'),
+    (0x189, 'M', 'ɖ'),
+    (0x18A, 'M', 'ɗ'),
+    (0x18B, 'M', 'ƌ'),
+    (0x18C, 'V'),
+    (0x18E, 'M', 'ǝ'),
+    (0x18F, 'M', 'ə'),
+    (0x190, 'M', 'ɛ'),
+    (0x191, 'M', 'ƒ'),
+    (0x192, 'V'),
+    (0x193, 'M', 'ɠ'),
+    ]
+
+def _seg_4() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x194, 'M', 'ɣ'),
+    (0x195, 'V'),
+    (0x196, 'M', 'ɩ'),
+    (0x197, 'M', 'ɨ'),
+    (0x198, 'M', 'ƙ'),
+    (0x199, 'V'),
+    (0x19C, 'M', 'ɯ'),
+    (0x19D, 'M', 'ɲ'),
+    (0x19E, 'V'),
+    (0x19F, 'M', 'ɵ'),
+    (0x1A0, 'M', 'ơ'),
+    (0x1A1, 'V'),
+    (0x1A2, 'M', 'ƣ'),
+    (0x1A3, 'V'),
+    (0x1A4, 'M', 'ƥ'),
+    (0x1A5, 'V'),
+    (0x1A6, 'M', 'ʀ'),
+    (0x1A7, 'M', 'ƨ'),
+    (0x1A8, 'V'),
+    (0x1A9, 'M', 'ʃ'),
+    (0x1AA, 'V'),
+    (0x1AC, 'M', 'ƭ'),
+    (0x1AD, 'V'),
+    (0x1AE, 'M', 'ʈ'),
+    (0x1AF, 'M', 'ư'),
+    (0x1B0, 'V'),
+    (0x1B1, 'M', 'ʊ'),
+    (0x1B2, 'M', 'ʋ'),
+    (0x1B3, 'M', 'ƴ'),
+    (0x1B4, 'V'),
+    (0x1B5, 'M', 'ƶ'),
+    (0x1B6, 'V'),
+    (0x1B7, 'M', 'ʒ'),
+    (0x1B8, 'M', 'ƹ'),
+    (0x1B9, 'V'),
+    (0x1BC, 'M', 'ƽ'),
+    (0x1BD, 'V'),
+    (0x1C4, 'M', 'dž'),
+    (0x1C7, 'M', 'lj'),
+    (0x1CA, 'M', 'nj'),
+    (0x1CD, 'M', 'ǎ'),
+    (0x1CE, 'V'),
+    (0x1CF, 'M', 'ǐ'),
+    (0x1D0, 'V'),
+    (0x1D1, 'M', 'ǒ'),
+    (0x1D2, 'V'),
+    (0x1D3, 'M', 'ǔ'),
+    (0x1D4, 'V'),
+    (0x1D5, 'M', 'ǖ'),
+    (0x1D6, 'V'),
+    (0x1D7, 'M', 'ǘ'),
+    (0x1D8, 'V'),
+    (0x1D9, 'M', 'ǚ'),
+    (0x1DA, 'V'),
+    (0x1DB, 'M', 'ǜ'),
+    (0x1DC, 'V'),
+    (0x1DE, 'M', 'ǟ'),
+    (0x1DF, 'V'),
+    (0x1E0, 'M', 'ǡ'),
+    (0x1E1, 'V'),
+    (0x1E2, 'M', 'ǣ'),
+    (0x1E3, 'V'),
+    (0x1E4, 'M', 'ǥ'),
+    (0x1E5, 'V'),
+    (0x1E6, 'M', 'ǧ'),
+    (0x1E7, 'V'),
+    (0x1E8, 'M', 'ǩ'),
+    (0x1E9, 'V'),
+    (0x1EA, 'M', 'ǫ'),
+    (0x1EB, 'V'),
+    (0x1EC, 'M', 'ǭ'),
+    (0x1ED, 'V'),
+    (0x1EE, 'M', 'ǯ'),
+    (0x1EF, 'V'),
+    (0x1F1, 'M', 'dz'),
+    (0x1F4, 'M', 'ǵ'),
+    (0x1F5, 'V'),
+    (0x1F6, 'M', 'ƕ'),
+    (0x1F7, 'M', 'ƿ'),
+    (0x1F8, 'M', 'ǹ'),
+    (0x1F9, 'V'),
+    (0x1FA, 'M', 'ǻ'),
+    (0x1FB, 'V'),
+    (0x1FC, 'M', 'ǽ'),
+    (0x1FD, 'V'),
+    (0x1FE, 'M', 'ǿ'),
+    (0x1FF, 'V'),
+    (0x200, 'M', 'ȁ'),
+    (0x201, 'V'),
+    (0x202, 'M', 'ȃ'),
+    (0x203, 'V'),
+    (0x204, 'M', 'ȅ'),
+    (0x205, 'V'),
+    (0x206, 'M', 'ȇ'),
+    (0x207, 'V'),
+    (0x208, 'M', 'ȉ'),
+    (0x209, 'V'),
+    (0x20A, 'M', 'ȋ'),
+    (0x20B, 'V'),
+    (0x20C, 'M', 'ȍ'),
+    ]
+
+def _seg_5() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x20D, 'V'),
+    (0x20E, 'M', 'ȏ'),
+    (0x20F, 'V'),
+    (0x210, 'M', 'ȑ'),
+    (0x211, 'V'),
+    (0x212, 'M', 'ȓ'),
+    (0x213, 'V'),
+    (0x214, 'M', 'ȕ'),
+    (0x215, 'V'),
+    (0x216, 'M', 'ȗ'),
+    (0x217, 'V'),
+    (0x218, 'M', 'ș'),
+    (0x219, 'V'),
+    (0x21A, 'M', 'ț'),
+    (0x21B, 'V'),
+    (0x21C, 'M', 'ȝ'),
+    (0x21D, 'V'),
+    (0x21E, 'M', 'ȟ'),
+    (0x21F, 'V'),
+    (0x220, 'M', 'ƞ'),
+    (0x221, 'V'),
+    (0x222, 'M', 'ȣ'),
+    (0x223, 'V'),
+    (0x224, 'M', 'ȥ'),
+    (0x225, 'V'),
+    (0x226, 'M', 'ȧ'),
+    (0x227, 'V'),
+    (0x228, 'M', 'ȩ'),
+    (0x229, 'V'),
+    (0x22A, 'M', 'ȫ'),
+    (0x22B, 'V'),
+    (0x22C, 'M', 'ȭ'),
+    (0x22D, 'V'),
+    (0x22E, 'M', 'ȯ'),
+    (0x22F, 'V'),
+    (0x230, 'M', 'ȱ'),
+    (0x231, 'V'),
+    (0x232, 'M', 'ȳ'),
+    (0x233, 'V'),
+    (0x23A, 'M', 'ⱥ'),
+    (0x23B, 'M', 'ȼ'),
+    (0x23C, 'V'),
+    (0x23D, 'M', 'ƚ'),
+    (0x23E, 'M', 'ⱦ'),
+    (0x23F, 'V'),
+    (0x241, 'M', 'ɂ'),
+    (0x242, 'V'),
+    (0x243, 'M', 'ƀ'),
+    (0x244, 'M', 'ʉ'),
+    (0x245, 'M', 'ʌ'),
+    (0x246, 'M', 'ɇ'),
+    (0x247, 'V'),
+    (0x248, 'M', 'ɉ'),
+    (0x249, 'V'),
+    (0x24A, 'M', 'ɋ'),
+    (0x24B, 'V'),
+    (0x24C, 'M', 'ɍ'),
+    (0x24D, 'V'),
+    (0x24E, 'M', 'ɏ'),
+    (0x24F, 'V'),
+    (0x2B0, 'M', 'h'),
+    (0x2B1, 'M', 'ɦ'),
+    (0x2B2, 'M', 'j'),
+    (0x2B3, 'M', 'r'),
+    (0x2B4, 'M', 'ɹ'),
+    (0x2B5, 'M', 'ɻ'),
+    (0x2B6, 'M', 'ʁ'),
+    (0x2B7, 'M', 'w'),
+    (0x2B8, 'M', 'y'),
+    (0x2B9, 'V'),
+    (0x2D8, '3', ' ̆'),
+    (0x2D9, '3', ' ̇'),
+    (0x2DA, '3', ' ̊'),
+    (0x2DB, '3', ' ̨'),
+    (0x2DC, '3', ' ̃'),
+    (0x2DD, '3', ' ̋'),
+    (0x2DE, 'V'),
+    (0x2E0, 'M', 'ɣ'),
+    (0x2E1, 'M', 'l'),
+    (0x2E2, 'M', 's'),
+    (0x2E3, 'M', 'x'),
+    (0x2E4, 'M', 'ʕ'),
+    (0x2E5, 'V'),
+    (0x340, 'M', '̀'),
+    (0x341, 'M', '́'),
+    (0x342, 'V'),
+    (0x343, 'M', '̓'),
+    (0x344, 'M', '̈́'),
+    (0x345, 'M', 'ι'),
+    (0x346, 'V'),
+    (0x34F, 'I'),
+    (0x350, 'V'),
+    (0x370, 'M', 'ͱ'),
+    (0x371, 'V'),
+    (0x372, 'M', 'ͳ'),
+    (0x373, 'V'),
+    (0x374, 'M', 'ʹ'),
+    (0x375, 'V'),
+    (0x376, 'M', 'ͷ'),
+    (0x377, 'V'),
+    ]
+
+def _seg_6() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x378, 'X'),
+    (0x37A, '3', ' ι'),
+    (0x37B, 'V'),
+    (0x37E, '3', ';'),
+    (0x37F, 'M', 'ϳ'),
+    (0x380, 'X'),
+    (0x384, '3', ' ́'),
+    (0x385, '3', ' ̈́'),
+    (0x386, 'M', 'ά'),
+    (0x387, 'M', '·'),
+    (0x388, 'M', 'έ'),
+    (0x389, 'M', 'ή'),
+    (0x38A, 'M', 'ί'),
+    (0x38B, 'X'),
+    (0x38C, 'M', 'ό'),
+    (0x38D, 'X'),
+    (0x38E, 'M', 'ύ'),
+    (0x38F, 'M', 'ώ'),
+    (0x390, 'V'),
+    (0x391, 'M', 'α'),
+    (0x392, 'M', 'β'),
+    (0x393, 'M', 'γ'),
+    (0x394, 'M', 'δ'),
+    (0x395, 'M', 'ε'),
+    (0x396, 'M', 'ζ'),
+    (0x397, 'M', 'η'),
+    (0x398, 'M', 'θ'),
+    (0x399, 'M', 'ι'),
+    (0x39A, 'M', 'κ'),
+    (0x39B, 'M', 'λ'),
+    (0x39C, 'M', 'μ'),
+    (0x39D, 'M', 'ν'),
+    (0x39E, 'M', 'ξ'),
+    (0x39F, 'M', 'ο'),
+    (0x3A0, 'M', 'π'),
+    (0x3A1, 'M', 'ρ'),
+    (0x3A2, 'X'),
+    (0x3A3, 'M', 'σ'),
+    (0x3A4, 'M', 'τ'),
+    (0x3A5, 'M', 'υ'),
+    (0x3A6, 'M', 'φ'),
+    (0x3A7, 'M', 'χ'),
+    (0x3A8, 'M', 'ψ'),
+    (0x3A9, 'M', 'ω'),
+    (0x3AA, 'M', 'ϊ'),
+    (0x3AB, 'M', 'ϋ'),
+    (0x3AC, 'V'),
+    (0x3C2, 'D', 'σ'),
+    (0x3C3, 'V'),
+    (0x3CF, 'M', 'ϗ'),
+    (0x3D0, 'M', 'β'),
+    (0x3D1, 'M', 'θ'),
+    (0x3D2, 'M', 'υ'),
+    (0x3D3, 'M', 'ύ'),
+    (0x3D4, 'M', 'ϋ'),
+    (0x3D5, 'M', 'φ'),
+    (0x3D6, 'M', 'π'),
+    (0x3D7, 'V'),
+    (0x3D8, 'M', 'ϙ'),
+    (0x3D9, 'V'),
+    (0x3DA, 'M', 'ϛ'),
+    (0x3DB, 'V'),
+    (0x3DC, 'M', 'ϝ'),
+    (0x3DD, 'V'),
+    (0x3DE, 'M', 'ϟ'),
+    (0x3DF, 'V'),
+    (0x3E0, 'M', 'ϡ'),
+    (0x3E1, 'V'),
+    (0x3E2, 'M', 'ϣ'),
+    (0x3E3, 'V'),
+    (0x3E4, 'M', 'ϥ'),
+    (0x3E5, 'V'),
+    (0x3E6, 'M', 'ϧ'),
+    (0x3E7, 'V'),
+    (0x3E8, 'M', 'ϩ'),
+    (0x3E9, 'V'),
+    (0x3EA, 'M', 'ϫ'),
+    (0x3EB, 'V'),
+    (0x3EC, 'M', 'ϭ'),
+    (0x3ED, 'V'),
+    (0x3EE, 'M', 'ϯ'),
+    (0x3EF, 'V'),
+    (0x3F0, 'M', 'κ'),
+    (0x3F1, 'M', 'ρ'),
+    (0x3F2, 'M', 'σ'),
+    (0x3F3, 'V'),
+    (0x3F4, 'M', 'θ'),
+    (0x3F5, 'M', 'ε'),
+    (0x3F6, 'V'),
+    (0x3F7, 'M', 'ϸ'),
+    (0x3F8, 'V'),
+    (0x3F9, 'M', 'σ'),
+    (0x3FA, 'M', 'ϻ'),
+    (0x3FB, 'V'),
+    (0x3FD, 'M', 'ͻ'),
+    (0x3FE, 'M', 'ͼ'),
+    (0x3FF, 'M', 'ͽ'),
+    (0x400, 'M', 'ѐ'),
+    (0x401, 'M', 'ё'),
+    (0x402, 'M', 'ђ'),
+    ]
+
+def _seg_7() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x403, 'M', 'ѓ'),
+    (0x404, 'M', 'є'),
+    (0x405, 'M', 'ѕ'),
+    (0x406, 'M', 'і'),
+    (0x407, 'M', 'ї'),
+    (0x408, 'M', 'ј'),
+    (0x409, 'M', 'љ'),
+    (0x40A, 'M', 'њ'),
+    (0x40B, 'M', 'ћ'),
+    (0x40C, 'M', 'ќ'),
+    (0x40D, 'M', 'ѝ'),
+    (0x40E, 'M', 'ў'),
+    (0x40F, 'M', 'џ'),
+    (0x410, 'M', 'а'),
+    (0x411, 'M', 'б'),
+    (0x412, 'M', 'в'),
+    (0x413, 'M', 'г'),
+    (0x414, 'M', 'д'),
+    (0x415, 'M', 'е'),
+    (0x416, 'M', 'ж'),
+    (0x417, 'M', 'з'),
+    (0x418, 'M', 'и'),
+    (0x419, 'M', 'й'),
+    (0x41A, 'M', 'к'),
+    (0x41B, 'M', 'л'),
+    (0x41C, 'M', 'м'),
+    (0x41D, 'M', 'н'),
+    (0x41E, 'M', 'о'),
+    (0x41F, 'M', 'п'),
+    (0x420, 'M', 'р'),
+    (0x421, 'M', 'с'),
+    (0x422, 'M', 'т'),
+    (0x423, 'M', 'у'),
+    (0x424, 'M', 'ф'),
+    (0x425, 'M', 'х'),
+    (0x426, 'M', 'ц'),
+    (0x427, 'M', 'ч'),
+    (0x428, 'M', 'ш'),
+    (0x429, 'M', 'щ'),
+    (0x42A, 'M', 'ъ'),
+    (0x42B, 'M', 'ы'),
+    (0x42C, 'M', 'ь'),
+    (0x42D, 'M', 'э'),
+    (0x42E, 'M', 'ю'),
+    (0x42F, 'M', 'я'),
+    (0x430, 'V'),
+    (0x460, 'M', 'ѡ'),
+    (0x461, 'V'),
+    (0x462, 'M', 'ѣ'),
+    (0x463, 'V'),
+    (0x464, 'M', 'ѥ'),
+    (0x465, 'V'),
+    (0x466, 'M', 'ѧ'),
+    (0x467, 'V'),
+    (0x468, 'M', 'ѩ'),
+    (0x469, 'V'),
+    (0x46A, 'M', 'ѫ'),
+    (0x46B, 'V'),
+    (0x46C, 'M', 'ѭ'),
+    (0x46D, 'V'),
+    (0x46E, 'M', 'ѯ'),
+    (0x46F, 'V'),
+    (0x470, 'M', 'ѱ'),
+    (0x471, 'V'),
+    (0x472, 'M', 'ѳ'),
+    (0x473, 'V'),
+    (0x474, 'M', 'ѵ'),
+    (0x475, 'V'),
+    (0x476, 'M', 'ѷ'),
+    (0x477, 'V'),
+    (0x478, 'M', 'ѹ'),
+    (0x479, 'V'),
+    (0x47A, 'M', 'ѻ'),
+    (0x47B, 'V'),
+    (0x47C, 'M', 'ѽ'),
+    (0x47D, 'V'),
+    (0x47E, 'M', 'ѿ'),
+    (0x47F, 'V'),
+    (0x480, 'M', 'ҁ'),
+    (0x481, 'V'),
+    (0x48A, 'M', 'ҋ'),
+    (0x48B, 'V'),
+    (0x48C, 'M', 'ҍ'),
+    (0x48D, 'V'),
+    (0x48E, 'M', 'ҏ'),
+    (0x48F, 'V'),
+    (0x490, 'M', 'ґ'),
+    (0x491, 'V'),
+    (0x492, 'M', 'ғ'),
+    (0x493, 'V'),
+    (0x494, 'M', 'ҕ'),
+    (0x495, 'V'),
+    (0x496, 'M', 'җ'),
+    (0x497, 'V'),
+    (0x498, 'M', 'ҙ'),
+    (0x499, 'V'),
+    (0x49A, 'M', 'қ'),
+    (0x49B, 'V'),
+    (0x49C, 'M', 'ҝ'),
+    (0x49D, 'V'),
+    ]
+
+def _seg_8() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x49E, 'M', 'ҟ'),
+    (0x49F, 'V'),
+    (0x4A0, 'M', 'ҡ'),
+    (0x4A1, 'V'),
+    (0x4A2, 'M', 'ң'),
+    (0x4A3, 'V'),
+    (0x4A4, 'M', 'ҥ'),
+    (0x4A5, 'V'),
+    (0x4A6, 'M', 'ҧ'),
+    (0x4A7, 'V'),
+    (0x4A8, 'M', 'ҩ'),
+    (0x4A9, 'V'),
+    (0x4AA, 'M', 'ҫ'),
+    (0x4AB, 'V'),
+    (0x4AC, 'M', 'ҭ'),
+    (0x4AD, 'V'),
+    (0x4AE, 'M', 'ү'),
+    (0x4AF, 'V'),
+    (0x4B0, 'M', 'ұ'),
+    (0x4B1, 'V'),
+    (0x4B2, 'M', 'ҳ'),
+    (0x4B3, 'V'),
+    (0x4B4, 'M', 'ҵ'),
+    (0x4B5, 'V'),
+    (0x4B6, 'M', 'ҷ'),
+    (0x4B7, 'V'),
+    (0x4B8, 'M', 'ҹ'),
+    (0x4B9, 'V'),
+    (0x4BA, 'M', 'һ'),
+    (0x4BB, 'V'),
+    (0x4BC, 'M', 'ҽ'),
+    (0x4BD, 'V'),
+    (0x4BE, 'M', 'ҿ'),
+    (0x4BF, 'V'),
+    (0x4C0, 'X'),
+    (0x4C1, 'M', 'ӂ'),
+    (0x4C2, 'V'),
+    (0x4C3, 'M', 'ӄ'),
+    (0x4C4, 'V'),
+    (0x4C5, 'M', 'ӆ'),
+    (0x4C6, 'V'),
+    (0x4C7, 'M', 'ӈ'),
+    (0x4C8, 'V'),
+    (0x4C9, 'M', 'ӊ'),
+    (0x4CA, 'V'),
+    (0x4CB, 'M', 'ӌ'),
+    (0x4CC, 'V'),
+    (0x4CD, 'M', 'ӎ'),
+    (0x4CE, 'V'),
+    (0x4D0, 'M', 'ӑ'),
+    (0x4D1, 'V'),
+    (0x4D2, 'M', 'ӓ'),
+    (0x4D3, 'V'),
+    (0x4D4, 'M', 'ӕ'),
+    (0x4D5, 'V'),
+    (0x4D6, 'M', 'ӗ'),
+    (0x4D7, 'V'),
+    (0x4D8, 'M', 'ә'),
+    (0x4D9, 'V'),
+    (0x4DA, 'M', 'ӛ'),
+    (0x4DB, 'V'),
+    (0x4DC, 'M', 'ӝ'),
+    (0x4DD, 'V'),
+    (0x4DE, 'M', 'ӟ'),
+    (0x4DF, 'V'),
+    (0x4E0, 'M', 'ӡ'),
+    (0x4E1, 'V'),
+    (0x4E2, 'M', 'ӣ'),
+    (0x4E3, 'V'),
+    (0x4E4, 'M', 'ӥ'),
+    (0x4E5, 'V'),
+    (0x4E6, 'M', 'ӧ'),
+    (0x4E7, 'V'),
+    (0x4E8, 'M', 'ө'),
+    (0x4E9, 'V'),
+    (0x4EA, 'M', 'ӫ'),
+    (0x4EB, 'V'),
+    (0x4EC, 'M', 'ӭ'),
+    (0x4ED, 'V'),
+    (0x4EE, 'M', 'ӯ'),
+    (0x4EF, 'V'),
+    (0x4F0, 'M', 'ӱ'),
+    (0x4F1, 'V'),
+    (0x4F2, 'M', 'ӳ'),
+    (0x4F3, 'V'),
+    (0x4F4, 'M', 'ӵ'),
+    (0x4F5, 'V'),
+    (0x4F6, 'M', 'ӷ'),
+    (0x4F7, 'V'),
+    (0x4F8, 'M', 'ӹ'),
+    (0x4F9, 'V'),
+    (0x4FA, 'M', 'ӻ'),
+    (0x4FB, 'V'),
+    (0x4FC, 'M', 'ӽ'),
+    (0x4FD, 'V'),
+    (0x4FE, 'M', 'ӿ'),
+    (0x4FF, 'V'),
+    (0x500, 'M', 'ԁ'),
+    (0x501, 'V'),
+    (0x502, 'M', 'ԃ'),
+    ]
+
+def _seg_9() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x503, 'V'),
+    (0x504, 'M', 'ԅ'),
+    (0x505, 'V'),
+    (0x506, 'M', 'ԇ'),
+    (0x507, 'V'),
+    (0x508, 'M', 'ԉ'),
+    (0x509, 'V'),
+    (0x50A, 'M', 'ԋ'),
+    (0x50B, 'V'),
+    (0x50C, 'M', 'ԍ'),
+    (0x50D, 'V'),
+    (0x50E, 'M', 'ԏ'),
+    (0x50F, 'V'),
+    (0x510, 'M', 'ԑ'),
+    (0x511, 'V'),
+    (0x512, 'M', 'ԓ'),
+    (0x513, 'V'),
+    (0x514, 'M', 'ԕ'),
+    (0x515, 'V'),
+    (0x516, 'M', 'ԗ'),
+    (0x517, 'V'),
+    (0x518, 'M', 'ԙ'),
+    (0x519, 'V'),
+    (0x51A, 'M', 'ԛ'),
+    (0x51B, 'V'),
+    (0x51C, 'M', 'ԝ'),
+    (0x51D, 'V'),
+    (0x51E, 'M', 'ԟ'),
+    (0x51F, 'V'),
+    (0x520, 'M', 'ԡ'),
+    (0x521, 'V'),
+    (0x522, 'M', 'ԣ'),
+    (0x523, 'V'),
+    (0x524, 'M', 'ԥ'),
+    (0x525, 'V'),
+    (0x526, 'M', 'ԧ'),
+    (0x527, 'V'),
+    (0x528, 'M', 'ԩ'),
+    (0x529, 'V'),
+    (0x52A, 'M', 'ԫ'),
+    (0x52B, 'V'),
+    (0x52C, 'M', 'ԭ'),
+    (0x52D, 'V'),
+    (0x52E, 'M', 'ԯ'),
+    (0x52F, 'V'),
+    (0x530, 'X'),
+    (0x531, 'M', 'ա'),
+    (0x532, 'M', 'բ'),
+    (0x533, 'M', 'գ'),
+    (0x534, 'M', 'դ'),
+    (0x535, 'M', 'ե'),
+    (0x536, 'M', 'զ'),
+    (0x537, 'M', 'է'),
+    (0x538, 'M', 'ը'),
+    (0x539, 'M', 'թ'),
+    (0x53A, 'M', 'ժ'),
+    (0x53B, 'M', 'ի'),
+    (0x53C, 'M', 'լ'),
+    (0x53D, 'M', 'խ'),
+    (0x53E, 'M', 'ծ'),
+    (0x53F, 'M', 'կ'),
+    (0x540, 'M', 'հ'),
+    (0x541, 'M', 'ձ'),
+    (0x542, 'M', 'ղ'),
+    (0x543, 'M', 'ճ'),
+    (0x544, 'M', 'մ'),
+    (0x545, 'M', 'յ'),
+    (0x546, 'M', 'ն'),
+    (0x547, 'M', 'շ'),
+    (0x548, 'M', 'ո'),
+    (0x549, 'M', 'չ'),
+    (0x54A, 'M', 'պ'),
+    (0x54B, 'M', 'ջ'),
+    (0x54C, 'M', 'ռ'),
+    (0x54D, 'M', 'ս'),
+    (0x54E, 'M', 'վ'),
+    (0x54F, 'M', 'տ'),
+    (0x550, 'M', 'ր'),
+    (0x551, 'M', 'ց'),
+    (0x552, 'M', 'ւ'),
+    (0x553, 'M', 'փ'),
+    (0x554, 'M', 'ք'),
+    (0x555, 'M', 'օ'),
+    (0x556, 'M', 'ֆ'),
+    (0x557, 'X'),
+    (0x559, 'V'),
+    (0x587, 'M', 'եւ'),
+    (0x588, 'V'),
+    (0x58B, 'X'),
+    (0x58D, 'V'),
+    (0x590, 'X'),
+    (0x591, 'V'),
+    (0x5C8, 'X'),
+    (0x5D0, 'V'),
+    (0x5EB, 'X'),
+    (0x5EF, 'V'),
+    (0x5F5, 'X'),
+    (0x606, 'V'),
+    (0x61C, 'X'),
+    (0x61D, 'V'),
+    ]
+
+def _seg_10() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x675, 'M', 'اٴ'),
+    (0x676, 'M', 'وٴ'),
+    (0x677, 'M', 'ۇٴ'),
+    (0x678, 'M', 'يٴ'),
+    (0x679, 'V'),
+    (0x6DD, 'X'),
+    (0x6DE, 'V'),
+    (0x70E, 'X'),
+    (0x710, 'V'),
+    (0x74B, 'X'),
+    (0x74D, 'V'),
+    (0x7B2, 'X'),
+    (0x7C0, 'V'),
+    (0x7FB, 'X'),
+    (0x7FD, 'V'),
+    (0x82E, 'X'),
+    (0x830, 'V'),
+    (0x83F, 'X'),
+    (0x840, 'V'),
+    (0x85C, 'X'),
+    (0x85E, 'V'),
+    (0x85F, 'X'),
+    (0x860, 'V'),
+    (0x86B, 'X'),
+    (0x870, 'V'),
+    (0x88F, 'X'),
+    (0x898, 'V'),
+    (0x8E2, 'X'),
+    (0x8E3, 'V'),
+    (0x958, 'M', 'क़'),
+    (0x959, 'M', 'ख़'),
+    (0x95A, 'M', 'ग़'),
+    (0x95B, 'M', 'ज़'),
+    (0x95C, 'M', 'ड़'),
+    (0x95D, 'M', 'ढ़'),
+    (0x95E, 'M', 'फ़'),
+    (0x95F, 'M', 'य़'),
+    (0x960, 'V'),
+    (0x984, 'X'),
+    (0x985, 'V'),
+    (0x98D, 'X'),
+    (0x98F, 'V'),
+    (0x991, 'X'),
+    (0x993, 'V'),
+    (0x9A9, 'X'),
+    (0x9AA, 'V'),
+    (0x9B1, 'X'),
+    (0x9B2, 'V'),
+    (0x9B3, 'X'),
+    (0x9B6, 'V'),
+    (0x9BA, 'X'),
+    (0x9BC, 'V'),
+    (0x9C5, 'X'),
+    (0x9C7, 'V'),
+    (0x9C9, 'X'),
+    (0x9CB, 'V'),
+    (0x9CF, 'X'),
+    (0x9D7, 'V'),
+    (0x9D8, 'X'),
+    (0x9DC, 'M', 'ড়'),
+    (0x9DD, 'M', 'ঢ়'),
+    (0x9DE, 'X'),
+    (0x9DF, 'M', 'য়'),
+    (0x9E0, 'V'),
+    (0x9E4, 'X'),
+    (0x9E6, 'V'),
+    (0x9FF, 'X'),
+    (0xA01, 'V'),
+    (0xA04, 'X'),
+    (0xA05, 'V'),
+    (0xA0B, 'X'),
+    (0xA0F, 'V'),
+    (0xA11, 'X'),
+    (0xA13, 'V'),
+    (0xA29, 'X'),
+    (0xA2A, 'V'),
+    (0xA31, 'X'),
+    (0xA32, 'V'),
+    (0xA33, 'M', 'ਲ਼'),
+    (0xA34, 'X'),
+    (0xA35, 'V'),
+    (0xA36, 'M', 'ਸ਼'),
+    (0xA37, 'X'),
+    (0xA38, 'V'),
+    (0xA3A, 'X'),
+    (0xA3C, 'V'),
+    (0xA3D, 'X'),
+    (0xA3E, 'V'),
+    (0xA43, 'X'),
+    (0xA47, 'V'),
+    (0xA49, 'X'),
+    (0xA4B, 'V'),
+    (0xA4E, 'X'),
+    (0xA51, 'V'),
+    (0xA52, 'X'),
+    (0xA59, 'M', 'ਖ਼'),
+    (0xA5A, 'M', 'ਗ਼'),
+    (0xA5B, 'M', 'ਜ਼'),
+    (0xA5C, 'V'),
+    (0xA5D, 'X'),
+    ]
+
+def _seg_11() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0xA5E, 'M', 'ਫ਼'),
+    (0xA5F, 'X'),
+    (0xA66, 'V'),
+    (0xA77, 'X'),
+    (0xA81, 'V'),
+    (0xA84, 'X'),
+    (0xA85, 'V'),
+    (0xA8E, 'X'),
+    (0xA8F, 'V'),
+    (0xA92, 'X'),
+    (0xA93, 'V'),
+    (0xAA9, 'X'),
+    (0xAAA, 'V'),
+    (0xAB1, 'X'),
+    (0xAB2, 'V'),
+    (0xAB4, 'X'),
+    (0xAB5, 'V'),
+    (0xABA, 'X'),
+    (0xABC, 'V'),
+    (0xAC6, 'X'),
+    (0xAC7, 'V'),
+    (0xACA, 'X'),
+    (0xACB, 'V'),
+    (0xACE, 'X'),
+    (0xAD0, 'V'),
+    (0xAD1, 'X'),
+    (0xAE0, 'V'),
+    (0xAE4, 'X'),
+    (0xAE6, 'V'),
+    (0xAF2, 'X'),
+    (0xAF9, 'V'),
+    (0xB00, 'X'),
+    (0xB01, 'V'),
+    (0xB04, 'X'),
+    (0xB05, 'V'),
+    (0xB0D, 'X'),
+    (0xB0F, 'V'),
+    (0xB11, 'X'),
+    (0xB13, 'V'),
+    (0xB29, 'X'),
+    (0xB2A, 'V'),
+    (0xB31, 'X'),
+    (0xB32, 'V'),
+    (0xB34, 'X'),
+    (0xB35, 'V'),
+    (0xB3A, 'X'),
+    (0xB3C, 'V'),
+    (0xB45, 'X'),
+    (0xB47, 'V'),
+    (0xB49, 'X'),
+    (0xB4B, 'V'),
+    (0xB4E, 'X'),
+    (0xB55, 'V'),
+    (0xB58, 'X'),
+    (0xB5C, 'M', 'ଡ଼'),
+    (0xB5D, 'M', 'ଢ଼'),
+    (0xB5E, 'X'),
+    (0xB5F, 'V'),
+    (0xB64, 'X'),
+    (0xB66, 'V'),
+    (0xB78, 'X'),
+    (0xB82, 'V'),
+    (0xB84, 'X'),
+    (0xB85, 'V'),
+    (0xB8B, 'X'),
+    (0xB8E, 'V'),
+    (0xB91, 'X'),
+    (0xB92, 'V'),
+    (0xB96, 'X'),
+    (0xB99, 'V'),
+    (0xB9B, 'X'),
+    (0xB9C, 'V'),
+    (0xB9D, 'X'),
+    (0xB9E, 'V'),
+    (0xBA0, 'X'),
+    (0xBA3, 'V'),
+    (0xBA5, 'X'),
+    (0xBA8, 'V'),
+    (0xBAB, 'X'),
+    (0xBAE, 'V'),
+    (0xBBA, 'X'),
+    (0xBBE, 'V'),
+    (0xBC3, 'X'),
+    (0xBC6, 'V'),
+    (0xBC9, 'X'),
+    (0xBCA, 'V'),
+    (0xBCE, 'X'),
+    (0xBD0, 'V'),
+    (0xBD1, 'X'),
+    (0xBD7, 'V'),
+    (0xBD8, 'X'),
+    (0xBE6, 'V'),
+    (0xBFB, 'X'),
+    (0xC00, 'V'),
+    (0xC0D, 'X'),
+    (0xC0E, 'V'),
+    (0xC11, 'X'),
+    (0xC12, 'V'),
+    (0xC29, 'X'),
+    (0xC2A, 'V'),
+    ]
+
+def _seg_12() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0xC3A, 'X'),
+    (0xC3C, 'V'),
+    (0xC45, 'X'),
+    (0xC46, 'V'),
+    (0xC49, 'X'),
+    (0xC4A, 'V'),
+    (0xC4E, 'X'),
+    (0xC55, 'V'),
+    (0xC57, 'X'),
+    (0xC58, 'V'),
+    (0xC5B, 'X'),
+    (0xC5D, 'V'),
+    (0xC5E, 'X'),
+    (0xC60, 'V'),
+    (0xC64, 'X'),
+    (0xC66, 'V'),
+    (0xC70, 'X'),
+    (0xC77, 'V'),
+    (0xC8D, 'X'),
+    (0xC8E, 'V'),
+    (0xC91, 'X'),
+    (0xC92, 'V'),
+    (0xCA9, 'X'),
+    (0xCAA, 'V'),
+    (0xCB4, 'X'),
+    (0xCB5, 'V'),
+    (0xCBA, 'X'),
+    (0xCBC, 'V'),
+    (0xCC5, 'X'),
+    (0xCC6, 'V'),
+    (0xCC9, 'X'),
+    (0xCCA, 'V'),
+    (0xCCE, 'X'),
+    (0xCD5, 'V'),
+    (0xCD7, 'X'),
+    (0xCDD, 'V'),
+    (0xCDF, 'X'),
+    (0xCE0, 'V'),
+    (0xCE4, 'X'),
+    (0xCE6, 'V'),
+    (0xCF0, 'X'),
+    (0xCF1, 'V'),
+    (0xCF4, 'X'),
+    (0xD00, 'V'),
+    (0xD0D, 'X'),
+    (0xD0E, 'V'),
+    (0xD11, 'X'),
+    (0xD12, 'V'),
+    (0xD45, 'X'),
+    (0xD46, 'V'),
+    (0xD49, 'X'),
+    (0xD4A, 'V'),
+    (0xD50, 'X'),
+    (0xD54, 'V'),
+    (0xD64, 'X'),
+    (0xD66, 'V'),
+    (0xD80, 'X'),
+    (0xD81, 'V'),
+    (0xD84, 'X'),
+    (0xD85, 'V'),
+    (0xD97, 'X'),
+    (0xD9A, 'V'),
+    (0xDB2, 'X'),
+    (0xDB3, 'V'),
+    (0xDBC, 'X'),
+    (0xDBD, 'V'),
+    (0xDBE, 'X'),
+    (0xDC0, 'V'),
+    (0xDC7, 'X'),
+    (0xDCA, 'V'),
+    (0xDCB, 'X'),
+    (0xDCF, 'V'),
+    (0xDD5, 'X'),
+    (0xDD6, 'V'),
+    (0xDD7, 'X'),
+    (0xDD8, 'V'),
+    (0xDE0, 'X'),
+    (0xDE6, 'V'),
+    (0xDF0, 'X'),
+    (0xDF2, 'V'),
+    (0xDF5, 'X'),
+    (0xE01, 'V'),
+    (0xE33, 'M', 'ํา'),
+    (0xE34, 'V'),
+    (0xE3B, 'X'),
+    (0xE3F, 'V'),
+    (0xE5C, 'X'),
+    (0xE81, 'V'),
+    (0xE83, 'X'),
+    (0xE84, 'V'),
+    (0xE85, 'X'),
+    (0xE86, 'V'),
+    (0xE8B, 'X'),
+    (0xE8C, 'V'),
+    (0xEA4, 'X'),
+    (0xEA5, 'V'),
+    (0xEA6, 'X'),
+    (0xEA7, 'V'),
+    (0xEB3, 'M', 'ໍາ'),
+    (0xEB4, 'V'),
+    ]
+
+def _seg_13() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0xEBE, 'X'),
+    (0xEC0, 'V'),
+    (0xEC5, 'X'),
+    (0xEC6, 'V'),
+    (0xEC7, 'X'),
+    (0xEC8, 'V'),
+    (0xECF, 'X'),
+    (0xED0, 'V'),
+    (0xEDA, 'X'),
+    (0xEDC, 'M', 'ຫນ'),
+    (0xEDD, 'M', 'ຫມ'),
+    (0xEDE, 'V'),
+    (0xEE0, 'X'),
+    (0xF00, 'V'),
+    (0xF0C, 'M', '་'),
+    (0xF0D, 'V'),
+    (0xF43, 'M', 'གྷ'),
+    (0xF44, 'V'),
+    (0xF48, 'X'),
+    (0xF49, 'V'),
+    (0xF4D, 'M', 'ཌྷ'),
+    (0xF4E, 'V'),
+    (0xF52, 'M', 'དྷ'),
+    (0xF53, 'V'),
+    (0xF57, 'M', 'བྷ'),
+    (0xF58, 'V'),
+    (0xF5C, 'M', 'ཛྷ'),
+    (0xF5D, 'V'),
+    (0xF69, 'M', 'ཀྵ'),
+    (0xF6A, 'V'),
+    (0xF6D, 'X'),
+    (0xF71, 'V'),
+    (0xF73, 'M', 'ཱི'),
+    (0xF74, 'V'),
+    (0xF75, 'M', 'ཱུ'),
+    (0xF76, 'M', 'ྲྀ'),
+    (0xF77, 'M', 'ྲཱྀ'),
+    (0xF78, 'M', 'ླྀ'),
+    (0xF79, 'M', 'ླཱྀ'),
+    (0xF7A, 'V'),
+    (0xF81, 'M', 'ཱྀ'),
+    (0xF82, 'V'),
+    (0xF93, 'M', 'ྒྷ'),
+    (0xF94, 'V'),
+    (0xF98, 'X'),
+    (0xF99, 'V'),
+    (0xF9D, 'M', 'ྜྷ'),
+    (0xF9E, 'V'),
+    (0xFA2, 'M', 'ྡྷ'),
+    (0xFA3, 'V'),
+    (0xFA7, 'M', 'ྦྷ'),
+    (0xFA8, 'V'),
+    (0xFAC, 'M', 'ྫྷ'),
+    (0xFAD, 'V'),
+    (0xFB9, 'M', 'ྐྵ'),
+    (0xFBA, 'V'),
+    (0xFBD, 'X'),
+    (0xFBE, 'V'),
+    (0xFCD, 'X'),
+    (0xFCE, 'V'),
+    (0xFDB, 'X'),
+    (0x1000, 'V'),
+    (0x10A0, 'X'),
+    (0x10C7, 'M', 'ⴧ'),
+    (0x10C8, 'X'),
+    (0x10CD, 'M', 'ⴭ'),
+    (0x10CE, 'X'),
+    (0x10D0, 'V'),
+    (0x10FC, 'M', 'ნ'),
+    (0x10FD, 'V'),
+    (0x115F, 'X'),
+    (0x1161, 'V'),
+    (0x1249, 'X'),
+    (0x124A, 'V'),
+    (0x124E, 'X'),
+    (0x1250, 'V'),
+    (0x1257, 'X'),
+    (0x1258, 'V'),
+    (0x1259, 'X'),
+    (0x125A, 'V'),
+    (0x125E, 'X'),
+    (0x1260, 'V'),
+    (0x1289, 'X'),
+    (0x128A, 'V'),
+    (0x128E, 'X'),
+    (0x1290, 'V'),
+    (0x12B1, 'X'),
+    (0x12B2, 'V'),
+    (0x12B6, 'X'),
+    (0x12B8, 'V'),
+    (0x12BF, 'X'),
+    (0x12C0, 'V'),
+    (0x12C1, 'X'),
+    (0x12C2, 'V'),
+    (0x12C6, 'X'),
+    (0x12C8, 'V'),
+    (0x12D7, 'X'),
+    (0x12D8, 'V'),
+    (0x1311, 'X'),
+    (0x1312, 'V'),
+    ]
+
+def _seg_14() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x1316, 'X'),
+    (0x1318, 'V'),
+    (0x135B, 'X'),
+    (0x135D, 'V'),
+    (0x137D, 'X'),
+    (0x1380, 'V'),
+    (0x139A, 'X'),
+    (0x13A0, 'V'),
+    (0x13F6, 'X'),
+    (0x13F8, 'M', 'Ᏸ'),
+    (0x13F9, 'M', 'Ᏹ'),
+    (0x13FA, 'M', 'Ᏺ'),
+    (0x13FB, 'M', 'Ᏻ'),
+    (0x13FC, 'M', 'Ᏼ'),
+    (0x13FD, 'M', 'Ᏽ'),
+    (0x13FE, 'X'),
+    (0x1400, 'V'),
+    (0x1680, 'X'),
+    (0x1681, 'V'),
+    (0x169D, 'X'),
+    (0x16A0, 'V'),
+    (0x16F9, 'X'),
+    (0x1700, 'V'),
+    (0x1716, 'X'),
+    (0x171F, 'V'),
+    (0x1737, 'X'),
+    (0x1740, 'V'),
+    (0x1754, 'X'),
+    (0x1760, 'V'),
+    (0x176D, 'X'),
+    (0x176E, 'V'),
+    (0x1771, 'X'),
+    (0x1772, 'V'),
+    (0x1774, 'X'),
+    (0x1780, 'V'),
+    (0x17B4, 'X'),
+    (0x17B6, 'V'),
+    (0x17DE, 'X'),
+    (0x17E0, 'V'),
+    (0x17EA, 'X'),
+    (0x17F0, 'V'),
+    (0x17FA, 'X'),
+    (0x1800, 'V'),
+    (0x1806, 'X'),
+    (0x1807, 'V'),
+    (0x180B, 'I'),
+    (0x180E, 'X'),
+    (0x180F, 'I'),
+    (0x1810, 'V'),
+    (0x181A, 'X'),
+    (0x1820, 'V'),
+    (0x1879, 'X'),
+    (0x1880, 'V'),
+    (0x18AB, 'X'),
+    (0x18B0, 'V'),
+    (0x18F6, 'X'),
+    (0x1900, 'V'),
+    (0x191F, 'X'),
+    (0x1920, 'V'),
+    (0x192C, 'X'),
+    (0x1930, 'V'),
+    (0x193C, 'X'),
+    (0x1940, 'V'),
+    (0x1941, 'X'),
+    (0x1944, 'V'),
+    (0x196E, 'X'),
+    (0x1970, 'V'),
+    (0x1975, 'X'),
+    (0x1980, 'V'),
+    (0x19AC, 'X'),
+    (0x19B0, 'V'),
+    (0x19CA, 'X'),
+    (0x19D0, 'V'),
+    (0x19DB, 'X'),
+    (0x19DE, 'V'),
+    (0x1A1C, 'X'),
+    (0x1A1E, 'V'),
+    (0x1A5F, 'X'),
+    (0x1A60, 'V'),
+    (0x1A7D, 'X'),
+    (0x1A7F, 'V'),
+    (0x1A8A, 'X'),
+    (0x1A90, 'V'),
+    (0x1A9A, 'X'),
+    (0x1AA0, 'V'),
+    (0x1AAE, 'X'),
+    (0x1AB0, 'V'),
+    (0x1ACF, 'X'),
+    (0x1B00, 'V'),
+    (0x1B4D, 'X'),
+    (0x1B50, 'V'),
+    (0x1B7F, 'X'),
+    (0x1B80, 'V'),
+    (0x1BF4, 'X'),
+    (0x1BFC, 'V'),
+    (0x1C38, 'X'),
+    (0x1C3B, 'V'),
+    (0x1C4A, 'X'),
+    (0x1C4D, 'V'),
+    (0x1C80, 'M', 'в'),
+    ]
+
+def _seg_15() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x1C81, 'M', 'д'),
+    (0x1C82, 'M', 'о'),
+    (0x1C83, 'M', 'с'),
+    (0x1C84, 'M', 'т'),
+    (0x1C86, 'M', 'ъ'),
+    (0x1C87, 'M', 'ѣ'),
+    (0x1C88, 'M', 'ꙋ'),
+    (0x1C89, 'X'),
+    (0x1C90, 'M', 'ა'),
+    (0x1C91, 'M', 'ბ'),
+    (0x1C92, 'M', 'გ'),
+    (0x1C93, 'M', 'დ'),
+    (0x1C94, 'M', 'ე'),
+    (0x1C95, 'M', 'ვ'),
+    (0x1C96, 'M', 'ზ'),
+    (0x1C97, 'M', 'თ'),
+    (0x1C98, 'M', 'ი'),
+    (0x1C99, 'M', 'კ'),
+    (0x1C9A, 'M', 'ლ'),
+    (0x1C9B, 'M', 'მ'),
+    (0x1C9C, 'M', 'ნ'),
+    (0x1C9D, 'M', 'ო'),
+    (0x1C9E, 'M', 'პ'),
+    (0x1C9F, 'M', 'ჟ'),
+    (0x1CA0, 'M', 'რ'),
+    (0x1CA1, 'M', 'ს'),
+    (0x1CA2, 'M', 'ტ'),
+    (0x1CA3, 'M', 'უ'),
+    (0x1CA4, 'M', 'ფ'),
+    (0x1CA5, 'M', 'ქ'),
+    (0x1CA6, 'M', 'ღ'),
+    (0x1CA7, 'M', 'ყ'),
+    (0x1CA8, 'M', 'შ'),
+    (0x1CA9, 'M', 'ჩ'),
+    (0x1CAA, 'M', 'ც'),
+    (0x1CAB, 'M', 'ძ'),
+    (0x1CAC, 'M', 'წ'),
+    (0x1CAD, 'M', 'ჭ'),
+    (0x1CAE, 'M', 'ხ'),
+    (0x1CAF, 'M', 'ჯ'),
+    (0x1CB0, 'M', 'ჰ'),
+    (0x1CB1, 'M', 'ჱ'),
+    (0x1CB2, 'M', 'ჲ'),
+    (0x1CB3, 'M', 'ჳ'),
+    (0x1CB4, 'M', 'ჴ'),
+    (0x1CB5, 'M', 'ჵ'),
+    (0x1CB6, 'M', 'ჶ'),
+    (0x1CB7, 'M', 'ჷ'),
+    (0x1CB8, 'M', 'ჸ'),
+    (0x1CB9, 'M', 'ჹ'),
+    (0x1CBA, 'M', 'ჺ'),
+    (0x1CBB, 'X'),
+    (0x1CBD, 'M', 'ჽ'),
+    (0x1CBE, 'M', 'ჾ'),
+    (0x1CBF, 'M', 'ჿ'),
+    (0x1CC0, 'V'),
+    (0x1CC8, 'X'),
+    (0x1CD0, 'V'),
+    (0x1CFB, 'X'),
+    (0x1D00, 'V'),
+    (0x1D2C, 'M', 'a'),
+    (0x1D2D, 'M', 'æ'),
+    (0x1D2E, 'M', 'b'),
+    (0x1D2F, 'V'),
+    (0x1D30, 'M', 'd'),
+    (0x1D31, 'M', 'e'),
+    (0x1D32, 'M', 'ǝ'),
+    (0x1D33, 'M', 'g'),
+    (0x1D34, 'M', 'h'),
+    (0x1D35, 'M', 'i'),
+    (0x1D36, 'M', 'j'),
+    (0x1D37, 'M', 'k'),
+    (0x1D38, 'M', 'l'),
+    (0x1D39, 'M', 'm'),
+    (0x1D3A, 'M', 'n'),
+    (0x1D3B, 'V'),
+    (0x1D3C, 'M', 'o'),
+    (0x1D3D, 'M', 'ȣ'),
+    (0x1D3E, 'M', 'p'),
+    (0x1D3F, 'M', 'r'),
+    (0x1D40, 'M', 't'),
+    (0x1D41, 'M', 'u'),
+    (0x1D42, 'M', 'w'),
+    (0x1D43, 'M', 'a'),
+    (0x1D44, 'M', 'ɐ'),
+    (0x1D45, 'M', 'ɑ'),
+    (0x1D46, 'M', 'ᴂ'),
+    (0x1D47, 'M', 'b'),
+    (0x1D48, 'M', 'd'),
+    (0x1D49, 'M', 'e'),
+    (0x1D4A, 'M', 'ə'),
+    (0x1D4B, 'M', 'ɛ'),
+    (0x1D4C, 'M', 'ɜ'),
+    (0x1D4D, 'M', 'g'),
+    (0x1D4E, 'V'),
+    (0x1D4F, 'M', 'k'),
+    (0x1D50, 'M', 'm'),
+    (0x1D51, 'M', 'ŋ'),
+    (0x1D52, 'M', 'o'),
+    (0x1D53, 'M', 'ɔ'),
+    ]
+
+def _seg_16() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x1D54, 'M', 'ᴖ'),
+    (0x1D55, 'M', 'ᴗ'),
+    (0x1D56, 'M', 'p'),
+    (0x1D57, 'M', 't'),
+    (0x1D58, 'M', 'u'),
+    (0x1D59, 'M', 'ᴝ'),
+    (0x1D5A, 'M', 'ɯ'),
+    (0x1D5B, 'M', 'v'),
+    (0x1D5C, 'M', 'ᴥ'),
+    (0x1D5D, 'M', 'β'),
+    (0x1D5E, 'M', 'γ'),
+    (0x1D5F, 'M', 'δ'),
+    (0x1D60, 'M', 'φ'),
+    (0x1D61, 'M', 'χ'),
+    (0x1D62, 'M', 'i'),
+    (0x1D63, 'M', 'r'),
+    (0x1D64, 'M', 'u'),
+    (0x1D65, 'M', 'v'),
+    (0x1D66, 'M', 'β'),
+    (0x1D67, 'M', 'γ'),
+    (0x1D68, 'M', 'ρ'),
+    (0x1D69, 'M', 'φ'),
+    (0x1D6A, 'M', 'χ'),
+    (0x1D6B, 'V'),
+    (0x1D78, 'M', 'н'),
+    (0x1D79, 'V'),
+    (0x1D9B, 'M', 'ɒ'),
+    (0x1D9C, 'M', 'c'),
+    (0x1D9D, 'M', 'ɕ'),
+    (0x1D9E, 'M', 'ð'),
+    (0x1D9F, 'M', 'ɜ'),
+    (0x1DA0, 'M', 'f'),
+    (0x1DA1, 'M', 'ɟ'),
+    (0x1DA2, 'M', 'ɡ'),
+    (0x1DA3, 'M', 'ɥ'),
+    (0x1DA4, 'M', 'ɨ'),
+    (0x1DA5, 'M', 'ɩ'),
+    (0x1DA6, 'M', 'ɪ'),
+    (0x1DA7, 'M', 'ᵻ'),
+    (0x1DA8, 'M', 'ʝ'),
+    (0x1DA9, 'M', 'ɭ'),
+    (0x1DAA, 'M', 'ᶅ'),
+    (0x1DAB, 'M', 'ʟ'),
+    (0x1DAC, 'M', 'ɱ'),
+    (0x1DAD, 'M', 'ɰ'),
+    (0x1DAE, 'M', 'ɲ'),
+    (0x1DAF, 'M', 'ɳ'),
+    (0x1DB0, 'M', 'ɴ'),
+    (0x1DB1, 'M', 'ɵ'),
+    (0x1DB2, 'M', 'ɸ'),
+    (0x1DB3, 'M', 'ʂ'),
+    (0x1DB4, 'M', 'ʃ'),
+    (0x1DB5, 'M', 'ƫ'),
+    (0x1DB6, 'M', 'ʉ'),
+    (0x1DB7, 'M', 'ʊ'),
+    (0x1DB8, 'M', 'ᴜ'),
+    (0x1DB9, 'M', 'ʋ'),
+    (0x1DBA, 'M', 'ʌ'),
+    (0x1DBB, 'M', 'z'),
+    (0x1DBC, 'M', 'ʐ'),
+    (0x1DBD, 'M', 'ʑ'),
+    (0x1DBE, 'M', 'ʒ'),
+    (0x1DBF, 'M', 'θ'),
+    (0x1DC0, 'V'),
+    (0x1E00, 'M', 'ḁ'),
+    (0x1E01, 'V'),
+    (0x1E02, 'M', 'ḃ'),
+    (0x1E03, 'V'),
+    (0x1E04, 'M', 'ḅ'),
+    (0x1E05, 'V'),
+    (0x1E06, 'M', 'ḇ'),
+    (0x1E07, 'V'),
+    (0x1E08, 'M', 'ḉ'),
+    (0x1E09, 'V'),
+    (0x1E0A, 'M', 'ḋ'),
+    (0x1E0B, 'V'),
+    (0x1E0C, 'M', 'ḍ'),
+    (0x1E0D, 'V'),
+    (0x1E0E, 'M', 'ḏ'),
+    (0x1E0F, 'V'),
+    (0x1E10, 'M', 'ḑ'),
+    (0x1E11, 'V'),
+    (0x1E12, 'M', 'ḓ'),
+    (0x1E13, 'V'),
+    (0x1E14, 'M', 'ḕ'),
+    (0x1E15, 'V'),
+    (0x1E16, 'M', 'ḗ'),
+    (0x1E17, 'V'),
+    (0x1E18, 'M', 'ḙ'),
+    (0x1E19, 'V'),
+    (0x1E1A, 'M', 'ḛ'),
+    (0x1E1B, 'V'),
+    (0x1E1C, 'M', 'ḝ'),
+    (0x1E1D, 'V'),
+    (0x1E1E, 'M', 'ḟ'),
+    (0x1E1F, 'V'),
+    (0x1E20, 'M', 'ḡ'),
+    (0x1E21, 'V'),
+    (0x1E22, 'M', 'ḣ'),
+    (0x1E23, 'V'),
+    ]
+
+def _seg_17() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x1E24, 'M', 'ḥ'),
+    (0x1E25, 'V'),
+    (0x1E26, 'M', 'ḧ'),
+    (0x1E27, 'V'),
+    (0x1E28, 'M', 'ḩ'),
+    (0x1E29, 'V'),
+    (0x1E2A, 'M', 'ḫ'),
+    (0x1E2B, 'V'),
+    (0x1E2C, 'M', 'ḭ'),
+    (0x1E2D, 'V'),
+    (0x1E2E, 'M', 'ḯ'),
+    (0x1E2F, 'V'),
+    (0x1E30, 'M', 'ḱ'),
+    (0x1E31, 'V'),
+    (0x1E32, 'M', 'ḳ'),
+    (0x1E33, 'V'),
+    (0x1E34, 'M', 'ḵ'),
+    (0x1E35, 'V'),
+    (0x1E36, 'M', 'ḷ'),
+    (0x1E37, 'V'),
+    (0x1E38, 'M', 'ḹ'),
+    (0x1E39, 'V'),
+    (0x1E3A, 'M', 'ḻ'),
+    (0x1E3B, 'V'),
+    (0x1E3C, 'M', 'ḽ'),
+    (0x1E3D, 'V'),
+    (0x1E3E, 'M', 'ḿ'),
+    (0x1E3F, 'V'),
+    (0x1E40, 'M', 'ṁ'),
+    (0x1E41, 'V'),
+    (0x1E42, 'M', 'ṃ'),
+    (0x1E43, 'V'),
+    (0x1E44, 'M', 'ṅ'),
+    (0x1E45, 'V'),
+    (0x1E46, 'M', 'ṇ'),
+    (0x1E47, 'V'),
+    (0x1E48, 'M', 'ṉ'),
+    (0x1E49, 'V'),
+    (0x1E4A, 'M', 'ṋ'),
+    (0x1E4B, 'V'),
+    (0x1E4C, 'M', 'ṍ'),
+    (0x1E4D, 'V'),
+    (0x1E4E, 'M', 'ṏ'),
+    (0x1E4F, 'V'),
+    (0x1E50, 'M', 'ṑ'),
+    (0x1E51, 'V'),
+    (0x1E52, 'M', 'ṓ'),
+    (0x1E53, 'V'),
+    (0x1E54, 'M', 'ṕ'),
+    (0x1E55, 'V'),
+    (0x1E56, 'M', 'ṗ'),
+    (0x1E57, 'V'),
+    (0x1E58, 'M', 'ṙ'),
+    (0x1E59, 'V'),
+    (0x1E5A, 'M', 'ṛ'),
+    (0x1E5B, 'V'),
+    (0x1E5C, 'M', 'ṝ'),
+    (0x1E5D, 'V'),
+    (0x1E5E, 'M', 'ṟ'),
+    (0x1E5F, 'V'),
+    (0x1E60, 'M', 'ṡ'),
+    (0x1E61, 'V'),
+    (0x1E62, 'M', 'ṣ'),
+    (0x1E63, 'V'),
+    (0x1E64, 'M', 'ṥ'),
+    (0x1E65, 'V'),
+    (0x1E66, 'M', 'ṧ'),
+    (0x1E67, 'V'),
+    (0x1E68, 'M', 'ṩ'),
+    (0x1E69, 'V'),
+    (0x1E6A, 'M', 'ṫ'),
+    (0x1E6B, 'V'),
+    (0x1E6C, 'M', 'ṭ'),
+    (0x1E6D, 'V'),
+    (0x1E6E, 'M', 'ṯ'),
+    (0x1E6F, 'V'),
+    (0x1E70, 'M', 'ṱ'),
+    (0x1E71, 'V'),
+    (0x1E72, 'M', 'ṳ'),
+    (0x1E73, 'V'),
+    (0x1E74, 'M', 'ṵ'),
+    (0x1E75, 'V'),
+    (0x1E76, 'M', 'ṷ'),
+    (0x1E77, 'V'),
+    (0x1E78, 'M', 'ṹ'),
+    (0x1E79, 'V'),
+    (0x1E7A, 'M', 'ṻ'),
+    (0x1E7B, 'V'),
+    (0x1E7C, 'M', 'ṽ'),
+    (0x1E7D, 'V'),
+    (0x1E7E, 'M', 'ṿ'),
+    (0x1E7F, 'V'),
+    (0x1E80, 'M', 'ẁ'),
+    (0x1E81, 'V'),
+    (0x1E82, 'M', 'ẃ'),
+    (0x1E83, 'V'),
+    (0x1E84, 'M', 'ẅ'),
+    (0x1E85, 'V'),
+    (0x1E86, 'M', 'ẇ'),
+    (0x1E87, 'V'),
+    ]
+
+def _seg_18() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x1E88, 'M', 'ẉ'),
+    (0x1E89, 'V'),
+    (0x1E8A, 'M', 'ẋ'),
+    (0x1E8B, 'V'),
+    (0x1E8C, 'M', 'ẍ'),
+    (0x1E8D, 'V'),
+    (0x1E8E, 'M', 'ẏ'),
+    (0x1E8F, 'V'),
+    (0x1E90, 'M', 'ẑ'),
+    (0x1E91, 'V'),
+    (0x1E92, 'M', 'ẓ'),
+    (0x1E93, 'V'),
+    (0x1E94, 'M', 'ẕ'),
+    (0x1E95, 'V'),
+    (0x1E9A, 'M', 'aʾ'),
+    (0x1E9B, 'M', 'ṡ'),
+    (0x1E9C, 'V'),
+    (0x1E9E, 'M', 'ß'),
+    (0x1E9F, 'V'),
+    (0x1EA0, 'M', 'ạ'),
+    (0x1EA1, 'V'),
+    (0x1EA2, 'M', 'ả'),
+    (0x1EA3, 'V'),
+    (0x1EA4, 'M', 'ấ'),
+    (0x1EA5, 'V'),
+    (0x1EA6, 'M', 'ầ'),
+    (0x1EA7, 'V'),
+    (0x1EA8, 'M', 'ẩ'),
+    (0x1EA9, 'V'),
+    (0x1EAA, 'M', 'ẫ'),
+    (0x1EAB, 'V'),
+    (0x1EAC, 'M', 'ậ'),
+    (0x1EAD, 'V'),
+    (0x1EAE, 'M', 'ắ'),
+    (0x1EAF, 'V'),
+    (0x1EB0, 'M', 'ằ'),
+    (0x1EB1, 'V'),
+    (0x1EB2, 'M', 'ẳ'),
+    (0x1EB3, 'V'),
+    (0x1EB4, 'M', 'ẵ'),
+    (0x1EB5, 'V'),
+    (0x1EB6, 'M', 'ặ'),
+    (0x1EB7, 'V'),
+    (0x1EB8, 'M', 'ẹ'),
+    (0x1EB9, 'V'),
+    (0x1EBA, 'M', 'ẻ'),
+    (0x1EBB, 'V'),
+    (0x1EBC, 'M', 'ẽ'),
+    (0x1EBD, 'V'),
+    (0x1EBE, 'M', 'ế'),
+    (0x1EBF, 'V'),
+    (0x1EC0, 'M', 'ề'),
+    (0x1EC1, 'V'),
+    (0x1EC2, 'M', 'ể'),
+    (0x1EC3, 'V'),
+    (0x1EC4, 'M', 'ễ'),
+    (0x1EC5, 'V'),
+    (0x1EC6, 'M', 'ệ'),
+    (0x1EC7, 'V'),
+    (0x1EC8, 'M', 'ỉ'),
+    (0x1EC9, 'V'),
+    (0x1ECA, 'M', 'ị'),
+    (0x1ECB, 'V'),
+    (0x1ECC, 'M', 'ọ'),
+    (0x1ECD, 'V'),
+    (0x1ECE, 'M', 'ỏ'),
+    (0x1ECF, 'V'),
+    (0x1ED0, 'M', 'ố'),
+    (0x1ED1, 'V'),
+    (0x1ED2, 'M', 'ồ'),
+    (0x1ED3, 'V'),
+    (0x1ED4, 'M', 'ổ'),
+    (0x1ED5, 'V'),
+    (0x1ED6, 'M', 'ỗ'),
+    (0x1ED7, 'V'),
+    (0x1ED8, 'M', 'ộ'),
+    (0x1ED9, 'V'),
+    (0x1EDA, 'M', 'ớ'),
+    (0x1EDB, 'V'),
+    (0x1EDC, 'M', 'ờ'),
+    (0x1EDD, 'V'),
+    (0x1EDE, 'M', 'ở'),
+    (0x1EDF, 'V'),
+    (0x1EE0, 'M', 'ỡ'),
+    (0x1EE1, 'V'),
+    (0x1EE2, 'M', 'ợ'),
+    (0x1EE3, 'V'),
+    (0x1EE4, 'M', 'ụ'),
+    (0x1EE5, 'V'),
+    (0x1EE6, 'M', 'ủ'),
+    (0x1EE7, 'V'),
+    (0x1EE8, 'M', 'ứ'),
+    (0x1EE9, 'V'),
+    (0x1EEA, 'M', 'ừ'),
+    (0x1EEB, 'V'),
+    (0x1EEC, 'M', 'ử'),
+    (0x1EED, 'V'),
+    (0x1EEE, 'M', 'ữ'),
+    (0x1EEF, 'V'),
+    (0x1EF0, 'M', 'ự'),
+    ]
+
+def _seg_19() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x1EF1, 'V'),
+    (0x1EF2, 'M', 'ỳ'),
+    (0x1EF3, 'V'),
+    (0x1EF4, 'M', 'ỵ'),
+    (0x1EF5, 'V'),
+    (0x1EF6, 'M', 'ỷ'),
+    (0x1EF7, 'V'),
+    (0x1EF8, 'M', 'ỹ'),
+    (0x1EF9, 'V'),
+    (0x1EFA, 'M', 'ỻ'),
+    (0x1EFB, 'V'),
+    (0x1EFC, 'M', 'ỽ'),
+    (0x1EFD, 'V'),
+    (0x1EFE, 'M', 'ỿ'),
+    (0x1EFF, 'V'),
+    (0x1F08, 'M', 'ἀ'),
+    (0x1F09, 'M', 'ἁ'),
+    (0x1F0A, 'M', 'ἂ'),
+    (0x1F0B, 'M', 'ἃ'),
+    (0x1F0C, 'M', 'ἄ'),
+    (0x1F0D, 'M', 'ἅ'),
+    (0x1F0E, 'M', 'ἆ'),
+    (0x1F0F, 'M', 'ἇ'),
+    (0x1F10, 'V'),
+    (0x1F16, 'X'),
+    (0x1F18, 'M', 'ἐ'),
+    (0x1F19, 'M', 'ἑ'),
+    (0x1F1A, 'M', 'ἒ'),
+    (0x1F1B, 'M', 'ἓ'),
+    (0x1F1C, 'M', 'ἔ'),
+    (0x1F1D, 'M', 'ἕ'),
+    (0x1F1E, 'X'),
+    (0x1F20, 'V'),
+    (0x1F28, 'M', 'ἠ'),
+    (0x1F29, 'M', 'ἡ'),
+    (0x1F2A, 'M', 'ἢ'),
+    (0x1F2B, 'M', 'ἣ'),
+    (0x1F2C, 'M', 'ἤ'),
+    (0x1F2D, 'M', 'ἥ'),
+    (0x1F2E, 'M', 'ἦ'),
+    (0x1F2F, 'M', 'ἧ'),
+    (0x1F30, 'V'),
+    (0x1F38, 'M', 'ἰ'),
+    (0x1F39, 'M', 'ἱ'),
+    (0x1F3A, 'M', 'ἲ'),
+    (0x1F3B, 'M', 'ἳ'),
+    (0x1F3C, 'M', 'ἴ'),
+    (0x1F3D, 'M', 'ἵ'),
+    (0x1F3E, 'M', 'ἶ'),
+    (0x1F3F, 'M', 'ἷ'),
+    (0x1F40, 'V'),
+    (0x1F46, 'X'),
+    (0x1F48, 'M', 'ὀ'),
+    (0x1F49, 'M', 'ὁ'),
+    (0x1F4A, 'M', 'ὂ'),
+    (0x1F4B, 'M', 'ὃ'),
+    (0x1F4C, 'M', 'ὄ'),
+    (0x1F4D, 'M', 'ὅ'),
+    (0x1F4E, 'X'),
+    (0x1F50, 'V'),
+    (0x1F58, 'X'),
+    (0x1F59, 'M', 'ὑ'),
+    (0x1F5A, 'X'),
+    (0x1F5B, 'M', 'ὓ'),
+    (0x1F5C, 'X'),
+    (0x1F5D, 'M', 'ὕ'),
+    (0x1F5E, 'X'),
+    (0x1F5F, 'M', 'ὗ'),
+    (0x1F60, 'V'),
+    (0x1F68, 'M', 'ὠ'),
+    (0x1F69, 'M', 'ὡ'),
+    (0x1F6A, 'M', 'ὢ'),
+    (0x1F6B, 'M', 'ὣ'),
+    (0x1F6C, 'M', 'ὤ'),
+    (0x1F6D, 'M', 'ὥ'),
+    (0x1F6E, 'M', 'ὦ'),
+    (0x1F6F, 'M', 'ὧ'),
+    (0x1F70, 'V'),
+    (0x1F71, 'M', 'ά'),
+    (0x1F72, 'V'),
+    (0x1F73, 'M', 'έ'),
+    (0x1F74, 'V'),
+    (0x1F75, 'M', 'ή'),
+    (0x1F76, 'V'),
+    (0x1F77, 'M', 'ί'),
+    (0x1F78, 'V'),
+    (0x1F79, 'M', 'ό'),
+    (0x1F7A, 'V'),
+    (0x1F7B, 'M', 'ύ'),
+    (0x1F7C, 'V'),
+    (0x1F7D, 'M', 'ώ'),
+    (0x1F7E, 'X'),
+    (0x1F80, 'M', 'ἀι'),
+    (0x1F81, 'M', 'ἁι'),
+    (0x1F82, 'M', 'ἂι'),
+    (0x1F83, 'M', 'ἃι'),
+    (0x1F84, 'M', 'ἄι'),
+    (0x1F85, 'M', 'ἅι'),
+    (0x1F86, 'M', 'ἆι'),
+    (0x1F87, 'M', 'ἇι'),
+    ]
+
+def _seg_20() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x1F88, 'M', 'ἀι'),
+    (0x1F89, 'M', 'ἁι'),
+    (0x1F8A, 'M', 'ἂι'),
+    (0x1F8B, 'M', 'ἃι'),
+    (0x1F8C, 'M', 'ἄι'),
+    (0x1F8D, 'M', 'ἅι'),
+    (0x1F8E, 'M', 'ἆι'),
+    (0x1F8F, 'M', 'ἇι'),
+    (0x1F90, 'M', 'ἠι'),
+    (0x1F91, 'M', 'ἡι'),
+    (0x1F92, 'M', 'ἢι'),
+    (0x1F93, 'M', 'ἣι'),
+    (0x1F94, 'M', 'ἤι'),
+    (0x1F95, 'M', 'ἥι'),
+    (0x1F96, 'M', 'ἦι'),
+    (0x1F97, 'M', 'ἧι'),
+    (0x1F98, 'M', 'ἠι'),
+    (0x1F99, 'M', 'ἡι'),
+    (0x1F9A, 'M', 'ἢι'),
+    (0x1F9B, 'M', 'ἣι'),
+    (0x1F9C, 'M', 'ἤι'),
+    (0x1F9D, 'M', 'ἥι'),
+    (0x1F9E, 'M', 'ἦι'),
+    (0x1F9F, 'M', 'ἧι'),
+    (0x1FA0, 'M', 'ὠι'),
+    (0x1FA1, 'M', 'ὡι'),
+    (0x1FA2, 'M', 'ὢι'),
+    (0x1FA3, 'M', 'ὣι'),
+    (0x1FA4, 'M', 'ὤι'),
+    (0x1FA5, 'M', 'ὥι'),
+    (0x1FA6, 'M', 'ὦι'),
+    (0x1FA7, 'M', 'ὧι'),
+    (0x1FA8, 'M', 'ὠι'),
+    (0x1FA9, 'M', 'ὡι'),
+    (0x1FAA, 'M', 'ὢι'),
+    (0x1FAB, 'M', 'ὣι'),
+    (0x1FAC, 'M', 'ὤι'),
+    (0x1FAD, 'M', 'ὥι'),
+    (0x1FAE, 'M', 'ὦι'),
+    (0x1FAF, 'M', 'ὧι'),
+    (0x1FB0, 'V'),
+    (0x1FB2, 'M', 'ὰι'),
+    (0x1FB3, 'M', 'αι'),
+    (0x1FB4, 'M', 'άι'),
+    (0x1FB5, 'X'),
+    (0x1FB6, 'V'),
+    (0x1FB7, 'M', 'ᾶι'),
+    (0x1FB8, 'M', 'ᾰ'),
+    (0x1FB9, 'M', 'ᾱ'),
+    (0x1FBA, 'M', 'ὰ'),
+    (0x1FBB, 'M', 'ά'),
+    (0x1FBC, 'M', 'αι'),
+    (0x1FBD, '3', ' ̓'),
+    (0x1FBE, 'M', 'ι'),
+    (0x1FBF, '3', ' ̓'),
+    (0x1FC0, '3', ' ͂'),
+    (0x1FC1, '3', ' ̈͂'),
+    (0x1FC2, 'M', 'ὴι'),
+    (0x1FC3, 'M', 'ηι'),
+    (0x1FC4, 'M', 'ήι'),
+    (0x1FC5, 'X'),
+    (0x1FC6, 'V'),
+    (0x1FC7, 'M', 'ῆι'),
+    (0x1FC8, 'M', 'ὲ'),
+    (0x1FC9, 'M', 'έ'),
+    (0x1FCA, 'M', 'ὴ'),
+    (0x1FCB, 'M', 'ή'),
+    (0x1FCC, 'M', 'ηι'),
+    (0x1FCD, '3', ' ̓̀'),
+    (0x1FCE, '3', ' ̓́'),
+    (0x1FCF, '3', ' ̓͂'),
+    (0x1FD0, 'V'),
+    (0x1FD3, 'M', 'ΐ'),
+    (0x1FD4, 'X'),
+    (0x1FD6, 'V'),
+    (0x1FD8, 'M', 'ῐ'),
+    (0x1FD9, 'M', 'ῑ'),
+    (0x1FDA, 'M', 'ὶ'),
+    (0x1FDB, 'M', 'ί'),
+    (0x1FDC, 'X'),
+    (0x1FDD, '3', ' ̔̀'),
+    (0x1FDE, '3', ' ̔́'),
+    (0x1FDF, '3', ' ̔͂'),
+    (0x1FE0, 'V'),
+    (0x1FE3, 'M', 'ΰ'),
+    (0x1FE4, 'V'),
+    (0x1FE8, 'M', 'ῠ'),
+    (0x1FE9, 'M', 'ῡ'),
+    (0x1FEA, 'M', 'ὺ'),
+    (0x1FEB, 'M', 'ύ'),
+    (0x1FEC, 'M', 'ῥ'),
+    (0x1FED, '3', ' ̈̀'),
+    (0x1FEE, '3', ' ̈́'),
+    (0x1FEF, '3', '`'),
+    (0x1FF0, 'X'),
+    (0x1FF2, 'M', 'ὼι'),
+    (0x1FF3, 'M', 'ωι'),
+    (0x1FF4, 'M', 'ώι'),
+    (0x1FF5, 'X'),
+    (0x1FF6, 'V'),
+    ]
+
+def _seg_21() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x1FF7, 'M', 'ῶι'),
+    (0x1FF8, 'M', 'ὸ'),
+    (0x1FF9, 'M', 'ό'),
+    (0x1FFA, 'M', 'ὼ'),
+    (0x1FFB, 'M', 'ώ'),
+    (0x1FFC, 'M', 'ωι'),
+    (0x1FFD, '3', ' ́'),
+    (0x1FFE, '3', ' ̔'),
+    (0x1FFF, 'X'),
+    (0x2000, '3', ' '),
+    (0x200B, 'I'),
+    (0x200C, 'D', ''),
+    (0x200E, 'X'),
+    (0x2010, 'V'),
+    (0x2011, 'M', '‐'),
+    (0x2012, 'V'),
+    (0x2017, '3', ' ̳'),
+    (0x2018, 'V'),
+    (0x2024, 'X'),
+    (0x2027, 'V'),
+    (0x2028, 'X'),
+    (0x202F, '3', ' '),
+    (0x2030, 'V'),
+    (0x2033, 'M', '′′'),
+    (0x2034, 'M', '′′′'),
+    (0x2035, 'V'),
+    (0x2036, 'M', '‵‵'),
+    (0x2037, 'M', '‵‵‵'),
+    (0x2038, 'V'),
+    (0x203C, '3', '!!'),
+    (0x203D, 'V'),
+    (0x203E, '3', ' ̅'),
+    (0x203F, 'V'),
+    (0x2047, '3', '??'),
+    (0x2048, '3', '?!'),
+    (0x2049, '3', '!?'),
+    (0x204A, 'V'),
+    (0x2057, 'M', '′′′′'),
+    (0x2058, 'V'),
+    (0x205F, '3', ' '),
+    (0x2060, 'I'),
+    (0x2061, 'X'),
+    (0x2064, 'I'),
+    (0x2065, 'X'),
+    (0x2070, 'M', '0'),
+    (0x2071, 'M', 'i'),
+    (0x2072, 'X'),
+    (0x2074, 'M', '4'),
+    (0x2075, 'M', '5'),
+    (0x2076, 'M', '6'),
+    (0x2077, 'M', '7'),
+    (0x2078, 'M', '8'),
+    (0x2079, 'M', '9'),
+    (0x207A, '3', '+'),
+    (0x207B, 'M', '−'),
+    (0x207C, '3', '='),
+    (0x207D, '3', '('),
+    (0x207E, '3', ')'),
+    (0x207F, 'M', 'n'),
+    (0x2080, 'M', '0'),
+    (0x2081, 'M', '1'),
+    (0x2082, 'M', '2'),
+    (0x2083, 'M', '3'),
+    (0x2084, 'M', '4'),
+    (0x2085, 'M', '5'),
+    (0x2086, 'M', '6'),
+    (0x2087, 'M', '7'),
+    (0x2088, 'M', '8'),
+    (0x2089, 'M', '9'),
+    (0x208A, '3', '+'),
+    (0x208B, 'M', '−'),
+    (0x208C, '3', '='),
+    (0x208D, '3', '('),
+    (0x208E, '3', ')'),
+    (0x208F, 'X'),
+    (0x2090, 'M', 'a'),
+    (0x2091, 'M', 'e'),
+    (0x2092, 'M', 'o'),
+    (0x2093, 'M', 'x'),
+    (0x2094, 'M', 'ə'),
+    (0x2095, 'M', 'h'),
+    (0x2096, 'M', 'k'),
+    (0x2097, 'M', 'l'),
+    (0x2098, 'M', 'm'),
+    (0x2099, 'M', 'n'),
+    (0x209A, 'M', 'p'),
+    (0x209B, 'M', 's'),
+    (0x209C, 'M', 't'),
+    (0x209D, 'X'),
+    (0x20A0, 'V'),
+    (0x20A8, 'M', 'rs'),
+    (0x20A9, 'V'),
+    (0x20C1, 'X'),
+    (0x20D0, 'V'),
+    (0x20F1, 'X'),
+    (0x2100, '3', 'a/c'),
+    (0x2101, '3', 'a/s'),
+    (0x2102, 'M', 'c'),
+    (0x2103, 'M', '°c'),
+    (0x2104, 'V'),
+    ]
+
+def _seg_22() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x2105, '3', 'c/o'),
+    (0x2106, '3', 'c/u'),
+    (0x2107, 'M', 'ɛ'),
+    (0x2108, 'V'),
+    (0x2109, 'M', '°f'),
+    (0x210A, 'M', 'g'),
+    (0x210B, 'M', 'h'),
+    (0x210F, 'M', 'ħ'),
+    (0x2110, 'M', 'i'),
+    (0x2112, 'M', 'l'),
+    (0x2114, 'V'),
+    (0x2115, 'M', 'n'),
+    (0x2116, 'M', 'no'),
+    (0x2117, 'V'),
+    (0x2119, 'M', 'p'),
+    (0x211A, 'M', 'q'),
+    (0x211B, 'M', 'r'),
+    (0x211E, 'V'),
+    (0x2120, 'M', 'sm'),
+    (0x2121, 'M', 'tel'),
+    (0x2122, 'M', 'tm'),
+    (0x2123, 'V'),
+    (0x2124, 'M', 'z'),
+    (0x2125, 'V'),
+    (0x2126, 'M', 'ω'),
+    (0x2127, 'V'),
+    (0x2128, 'M', 'z'),
+    (0x2129, 'V'),
+    (0x212A, 'M', 'k'),
+    (0x212B, 'M', 'å'),
+    (0x212C, 'M', 'b'),
+    (0x212D, 'M', 'c'),
+    (0x212E, 'V'),
+    (0x212F, 'M', 'e'),
+    (0x2131, 'M', 'f'),
+    (0x2132, 'X'),
+    (0x2133, 'M', 'm'),
+    (0x2134, 'M', 'o'),
+    (0x2135, 'M', 'א'),
+    (0x2136, 'M', 'ב'),
+    (0x2137, 'M', 'ג'),
+    (0x2138, 'M', 'ד'),
+    (0x2139, 'M', 'i'),
+    (0x213A, 'V'),
+    (0x213B, 'M', 'fax'),
+    (0x213C, 'M', 'π'),
+    (0x213D, 'M', 'γ'),
+    (0x213F, 'M', 'π'),
+    (0x2140, 'M', '∑'),
+    (0x2141, 'V'),
+    (0x2145, 'M', 'd'),
+    (0x2147, 'M', 'e'),
+    (0x2148, 'M', 'i'),
+    (0x2149, 'M', 'j'),
+    (0x214A, 'V'),
+    (0x2150, 'M', '1⁄7'),
+    (0x2151, 'M', '1⁄9'),
+    (0x2152, 'M', '1⁄10'),
+    (0x2153, 'M', '1⁄3'),
+    (0x2154, 'M', '2⁄3'),
+    (0x2155, 'M', '1⁄5'),
+    (0x2156, 'M', '2⁄5'),
+    (0x2157, 'M', '3⁄5'),
+    (0x2158, 'M', '4⁄5'),
+    (0x2159, 'M', '1⁄6'),
+    (0x215A, 'M', '5⁄6'),
+    (0x215B, 'M', '1⁄8'),
+    (0x215C, 'M', '3⁄8'),
+    (0x215D, 'M', '5⁄8'),
+    (0x215E, 'M', '7⁄8'),
+    (0x215F, 'M', '1⁄'),
+    (0x2160, 'M', 'i'),
+    (0x2161, 'M', 'ii'),
+    (0x2162, 'M', 'iii'),
+    (0x2163, 'M', 'iv'),
+    (0x2164, 'M', 'v'),
+    (0x2165, 'M', 'vi'),
+    (0x2166, 'M', 'vii'),
+    (0x2167, 'M', 'viii'),
+    (0x2168, 'M', 'ix'),
+    (0x2169, 'M', 'x'),
+    (0x216A, 'M', 'xi'),
+    (0x216B, 'M', 'xii'),
+    (0x216C, 'M', 'l'),
+    (0x216D, 'M', 'c'),
+    (0x216E, 'M', 'd'),
+    (0x216F, 'M', 'm'),
+    (0x2170, 'M', 'i'),
+    (0x2171, 'M', 'ii'),
+    (0x2172, 'M', 'iii'),
+    (0x2173, 'M', 'iv'),
+    (0x2174, 'M', 'v'),
+    (0x2175, 'M', 'vi'),
+    (0x2176, 'M', 'vii'),
+    (0x2177, 'M', 'viii'),
+    (0x2178, 'M', 'ix'),
+    (0x2179, 'M', 'x'),
+    (0x217A, 'M', 'xi'),
+    (0x217B, 'M', 'xii'),
+    (0x217C, 'M', 'l'),
+    ]
+
+def _seg_23() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x217D, 'M', 'c'),
+    (0x217E, 'M', 'd'),
+    (0x217F, 'M', 'm'),
+    (0x2180, 'V'),
+    (0x2183, 'X'),
+    (0x2184, 'V'),
+    (0x2189, 'M', '0⁄3'),
+    (0x218A, 'V'),
+    (0x218C, 'X'),
+    (0x2190, 'V'),
+    (0x222C, 'M', '∫∫'),
+    (0x222D, 'M', '∫∫∫'),
+    (0x222E, 'V'),
+    (0x222F, 'M', '∮∮'),
+    (0x2230, 'M', '∮∮∮'),
+    (0x2231, 'V'),
+    (0x2329, 'M', '〈'),
+    (0x232A, 'M', '〉'),
+    (0x232B, 'V'),
+    (0x2427, 'X'),
+    (0x2440, 'V'),
+    (0x244B, 'X'),
+    (0x2460, 'M', '1'),
+    (0x2461, 'M', '2'),
+    (0x2462, 'M', '3'),
+    (0x2463, 'M', '4'),
+    (0x2464, 'M', '5'),
+    (0x2465, 'M', '6'),
+    (0x2466, 'M', '7'),
+    (0x2467, 'M', '8'),
+    (0x2468, 'M', '9'),
+    (0x2469, 'M', '10'),
+    (0x246A, 'M', '11'),
+    (0x246B, 'M', '12'),
+    (0x246C, 'M', '13'),
+    (0x246D, 'M', '14'),
+    (0x246E, 'M', '15'),
+    (0x246F, 'M', '16'),
+    (0x2470, 'M', '17'),
+    (0x2471, 'M', '18'),
+    (0x2472, 'M', '19'),
+    (0x2473, 'M', '20'),
+    (0x2474, '3', '(1)'),
+    (0x2475, '3', '(2)'),
+    (0x2476, '3', '(3)'),
+    (0x2477, '3', '(4)'),
+    (0x2478, '3', '(5)'),
+    (0x2479, '3', '(6)'),
+    (0x247A, '3', '(7)'),
+    (0x247B, '3', '(8)'),
+    (0x247C, '3', '(9)'),
+    (0x247D, '3', '(10)'),
+    (0x247E, '3', '(11)'),
+    (0x247F, '3', '(12)'),
+    (0x2480, '3', '(13)'),
+    (0x2481, '3', '(14)'),
+    (0x2482, '3', '(15)'),
+    (0x2483, '3', '(16)'),
+    (0x2484, '3', '(17)'),
+    (0x2485, '3', '(18)'),
+    (0x2486, '3', '(19)'),
+    (0x2487, '3', '(20)'),
+    (0x2488, 'X'),
+    (0x249C, '3', '(a)'),
+    (0x249D, '3', '(b)'),
+    (0x249E, '3', '(c)'),
+    (0x249F, '3', '(d)'),
+    (0x24A0, '3', '(e)'),
+    (0x24A1, '3', '(f)'),
+    (0x24A2, '3', '(g)'),
+    (0x24A3, '3', '(h)'),
+    (0x24A4, '3', '(i)'),
+    (0x24A5, '3', '(j)'),
+    (0x24A6, '3', '(k)'),
+    (0x24A7, '3', '(l)'),
+    (0x24A8, '3', '(m)'),
+    (0x24A9, '3', '(n)'),
+    (0x24AA, '3', '(o)'),
+    (0x24AB, '3', '(p)'),
+    (0x24AC, '3', '(q)'),
+    (0x24AD, '3', '(r)'),
+    (0x24AE, '3', '(s)'),
+    (0x24AF, '3', '(t)'),
+    (0x24B0, '3', '(u)'),
+    (0x24B1, '3', '(v)'),
+    (0x24B2, '3', '(w)'),
+    (0x24B3, '3', '(x)'),
+    (0x24B4, '3', '(y)'),
+    (0x24B5, '3', '(z)'),
+    (0x24B6, 'M', 'a'),
+    (0x24B7, 'M', 'b'),
+    (0x24B8, 'M', 'c'),
+    (0x24B9, 'M', 'd'),
+    (0x24BA, 'M', 'e'),
+    (0x24BB, 'M', 'f'),
+    (0x24BC, 'M', 'g'),
+    (0x24BD, 'M', 'h'),
+    (0x24BE, 'M', 'i'),
+    (0x24BF, 'M', 'j'),
+    (0x24C0, 'M', 'k'),
+    ]
+
+def _seg_24() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x24C1, 'M', 'l'),
+    (0x24C2, 'M', 'm'),
+    (0x24C3, 'M', 'n'),
+    (0x24C4, 'M', 'o'),
+    (0x24C5, 'M', 'p'),
+    (0x24C6, 'M', 'q'),
+    (0x24C7, 'M', 'r'),
+    (0x24C8, 'M', 's'),
+    (0x24C9, 'M', 't'),
+    (0x24CA, 'M', 'u'),
+    (0x24CB, 'M', 'v'),
+    (0x24CC, 'M', 'w'),
+    (0x24CD, 'M', 'x'),
+    (0x24CE, 'M', 'y'),
+    (0x24CF, 'M', 'z'),
+    (0x24D0, 'M', 'a'),
+    (0x24D1, 'M', 'b'),
+    (0x24D2, 'M', 'c'),
+    (0x24D3, 'M', 'd'),
+    (0x24D4, 'M', 'e'),
+    (0x24D5, 'M', 'f'),
+    (0x24D6, 'M', 'g'),
+    (0x24D7, 'M', 'h'),
+    (0x24D8, 'M', 'i'),
+    (0x24D9, 'M', 'j'),
+    (0x24DA, 'M', 'k'),
+    (0x24DB, 'M', 'l'),
+    (0x24DC, 'M', 'm'),
+    (0x24DD, 'M', 'n'),
+    (0x24DE, 'M', 'o'),
+    (0x24DF, 'M', 'p'),
+    (0x24E0, 'M', 'q'),
+    (0x24E1, 'M', 'r'),
+    (0x24E2, 'M', 's'),
+    (0x24E3, 'M', 't'),
+    (0x24E4, 'M', 'u'),
+    (0x24E5, 'M', 'v'),
+    (0x24E6, 'M', 'w'),
+    (0x24E7, 'M', 'x'),
+    (0x24E8, 'M', 'y'),
+    (0x24E9, 'M', 'z'),
+    (0x24EA, 'M', '0'),
+    (0x24EB, 'V'),
+    (0x2A0C, 'M', '∫∫∫∫'),
+    (0x2A0D, 'V'),
+    (0x2A74, '3', '::='),
+    (0x2A75, '3', '=='),
+    (0x2A76, '3', '==='),
+    (0x2A77, 'V'),
+    (0x2ADC, 'M', '⫝̸'),
+    (0x2ADD, 'V'),
+    (0x2B74, 'X'),
+    (0x2B76, 'V'),
+    (0x2B96, 'X'),
+    (0x2B97, 'V'),
+    (0x2C00, 'M', 'ⰰ'),
+    (0x2C01, 'M', 'ⰱ'),
+    (0x2C02, 'M', 'ⰲ'),
+    (0x2C03, 'M', 'ⰳ'),
+    (0x2C04, 'M', 'ⰴ'),
+    (0x2C05, 'M', 'ⰵ'),
+    (0x2C06, 'M', 'ⰶ'),
+    (0x2C07, 'M', 'ⰷ'),
+    (0x2C08, 'M', 'ⰸ'),
+    (0x2C09, 'M', 'ⰹ'),
+    (0x2C0A, 'M', 'ⰺ'),
+    (0x2C0B, 'M', 'ⰻ'),
+    (0x2C0C, 'M', 'ⰼ'),
+    (0x2C0D, 'M', 'ⰽ'),
+    (0x2C0E, 'M', 'ⰾ'),
+    (0x2C0F, 'M', 'ⰿ'),
+    (0x2C10, 'M', 'ⱀ'),
+    (0x2C11, 'M', 'ⱁ'),
+    (0x2C12, 'M', 'ⱂ'),
+    (0x2C13, 'M', 'ⱃ'),
+    (0x2C14, 'M', 'ⱄ'),
+    (0x2C15, 'M', 'ⱅ'),
+    (0x2C16, 'M', 'ⱆ'),
+    (0x2C17, 'M', 'ⱇ'),
+    (0x2C18, 'M', 'ⱈ'),
+    (0x2C19, 'M', 'ⱉ'),
+    (0x2C1A, 'M', 'ⱊ'),
+    (0x2C1B, 'M', 'ⱋ'),
+    (0x2C1C, 'M', 'ⱌ'),
+    (0x2C1D, 'M', 'ⱍ'),
+    (0x2C1E, 'M', 'ⱎ'),
+    (0x2C1F, 'M', 'ⱏ'),
+    (0x2C20, 'M', 'ⱐ'),
+    (0x2C21, 'M', 'ⱑ'),
+    (0x2C22, 'M', 'ⱒ'),
+    (0x2C23, 'M', 'ⱓ'),
+    (0x2C24, 'M', 'ⱔ'),
+    (0x2C25, 'M', 'ⱕ'),
+    (0x2C26, 'M', 'ⱖ'),
+    (0x2C27, 'M', 'ⱗ'),
+    (0x2C28, 'M', 'ⱘ'),
+    (0x2C29, 'M', 'ⱙ'),
+    (0x2C2A, 'M', 'ⱚ'),
+    (0x2C2B, 'M', 'ⱛ'),
+    (0x2C2C, 'M', 'ⱜ'),
+    ]
+
+def _seg_25() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x2C2D, 'M', 'ⱝ'),
+    (0x2C2E, 'M', 'ⱞ'),
+    (0x2C2F, 'M', 'ⱟ'),
+    (0x2C30, 'V'),
+    (0x2C60, 'M', 'ⱡ'),
+    (0x2C61, 'V'),
+    (0x2C62, 'M', 'ɫ'),
+    (0x2C63, 'M', 'ᵽ'),
+    (0x2C64, 'M', 'ɽ'),
+    (0x2C65, 'V'),
+    (0x2C67, 'M', 'ⱨ'),
+    (0x2C68, 'V'),
+    (0x2C69, 'M', 'ⱪ'),
+    (0x2C6A, 'V'),
+    (0x2C6B, 'M', 'ⱬ'),
+    (0x2C6C, 'V'),
+    (0x2C6D, 'M', 'ɑ'),
+    (0x2C6E, 'M', 'ɱ'),
+    (0x2C6F, 'M', 'ɐ'),
+    (0x2C70, 'M', 'ɒ'),
+    (0x2C71, 'V'),
+    (0x2C72, 'M', 'ⱳ'),
+    (0x2C73, 'V'),
+    (0x2C75, 'M', 'ⱶ'),
+    (0x2C76, 'V'),
+    (0x2C7C, 'M', 'j'),
+    (0x2C7D, 'M', 'v'),
+    (0x2C7E, 'M', 'ȿ'),
+    (0x2C7F, 'M', 'ɀ'),
+    (0x2C80, 'M', 'ⲁ'),
+    (0x2C81, 'V'),
+    (0x2C82, 'M', 'ⲃ'),
+    (0x2C83, 'V'),
+    (0x2C84, 'M', 'ⲅ'),
+    (0x2C85, 'V'),
+    (0x2C86, 'M', 'ⲇ'),
+    (0x2C87, 'V'),
+    (0x2C88, 'M', 'ⲉ'),
+    (0x2C89, 'V'),
+    (0x2C8A, 'M', 'ⲋ'),
+    (0x2C8B, 'V'),
+    (0x2C8C, 'M', 'ⲍ'),
+    (0x2C8D, 'V'),
+    (0x2C8E, 'M', 'ⲏ'),
+    (0x2C8F, 'V'),
+    (0x2C90, 'M', 'ⲑ'),
+    (0x2C91, 'V'),
+    (0x2C92, 'M', 'ⲓ'),
+    (0x2C93, 'V'),
+    (0x2C94, 'M', 'ⲕ'),
+    (0x2C95, 'V'),
+    (0x2C96, 'M', 'ⲗ'),
+    (0x2C97, 'V'),
+    (0x2C98, 'M', 'ⲙ'),
+    (0x2C99, 'V'),
+    (0x2C9A, 'M', 'ⲛ'),
+    (0x2C9B, 'V'),
+    (0x2C9C, 'M', 'ⲝ'),
+    (0x2C9D, 'V'),
+    (0x2C9E, 'M', 'ⲟ'),
+    (0x2C9F, 'V'),
+    (0x2CA0, 'M', 'ⲡ'),
+    (0x2CA1, 'V'),
+    (0x2CA2, 'M', 'ⲣ'),
+    (0x2CA3, 'V'),
+    (0x2CA4, 'M', 'ⲥ'),
+    (0x2CA5, 'V'),
+    (0x2CA6, 'M', 'ⲧ'),
+    (0x2CA7, 'V'),
+    (0x2CA8, 'M', 'ⲩ'),
+    (0x2CA9, 'V'),
+    (0x2CAA, 'M', 'ⲫ'),
+    (0x2CAB, 'V'),
+    (0x2CAC, 'M', 'ⲭ'),
+    (0x2CAD, 'V'),
+    (0x2CAE, 'M', 'ⲯ'),
+    (0x2CAF, 'V'),
+    (0x2CB0, 'M', 'ⲱ'),
+    (0x2CB1, 'V'),
+    (0x2CB2, 'M', 'ⲳ'),
+    (0x2CB3, 'V'),
+    (0x2CB4, 'M', 'ⲵ'),
+    (0x2CB5, 'V'),
+    (0x2CB6, 'M', 'ⲷ'),
+    (0x2CB7, 'V'),
+    (0x2CB8, 'M', 'ⲹ'),
+    (0x2CB9, 'V'),
+    (0x2CBA, 'M', 'ⲻ'),
+    (0x2CBB, 'V'),
+    (0x2CBC, 'M', 'ⲽ'),
+    (0x2CBD, 'V'),
+    (0x2CBE, 'M', 'ⲿ'),
+    (0x2CBF, 'V'),
+    (0x2CC0, 'M', 'ⳁ'),
+    (0x2CC1, 'V'),
+    (0x2CC2, 'M', 'ⳃ'),
+    (0x2CC3, 'V'),
+    (0x2CC4, 'M', 'ⳅ'),
+    (0x2CC5, 'V'),
+    (0x2CC6, 'M', 'ⳇ'),
+    ]
+
+def _seg_26() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x2CC7, 'V'),
+    (0x2CC8, 'M', 'ⳉ'),
+    (0x2CC9, 'V'),
+    (0x2CCA, 'M', 'ⳋ'),
+    (0x2CCB, 'V'),
+    (0x2CCC, 'M', 'ⳍ'),
+    (0x2CCD, 'V'),
+    (0x2CCE, 'M', 'ⳏ'),
+    (0x2CCF, 'V'),
+    (0x2CD0, 'M', 'ⳑ'),
+    (0x2CD1, 'V'),
+    (0x2CD2, 'M', 'ⳓ'),
+    (0x2CD3, 'V'),
+    (0x2CD4, 'M', 'ⳕ'),
+    (0x2CD5, 'V'),
+    (0x2CD6, 'M', 'ⳗ'),
+    (0x2CD7, 'V'),
+    (0x2CD8, 'M', 'ⳙ'),
+    (0x2CD9, 'V'),
+    (0x2CDA, 'M', 'ⳛ'),
+    (0x2CDB, 'V'),
+    (0x2CDC, 'M', 'ⳝ'),
+    (0x2CDD, 'V'),
+    (0x2CDE, 'M', 'ⳟ'),
+    (0x2CDF, 'V'),
+    (0x2CE0, 'M', 'ⳡ'),
+    (0x2CE1, 'V'),
+    (0x2CE2, 'M', 'ⳣ'),
+    (0x2CE3, 'V'),
+    (0x2CEB, 'M', 'ⳬ'),
+    (0x2CEC, 'V'),
+    (0x2CED, 'M', 'ⳮ'),
+    (0x2CEE, 'V'),
+    (0x2CF2, 'M', 'ⳳ'),
+    (0x2CF3, 'V'),
+    (0x2CF4, 'X'),
+    (0x2CF9, 'V'),
+    (0x2D26, 'X'),
+    (0x2D27, 'V'),
+    (0x2D28, 'X'),
+    (0x2D2D, 'V'),
+    (0x2D2E, 'X'),
+    (0x2D30, 'V'),
+    (0x2D68, 'X'),
+    (0x2D6F, 'M', 'ⵡ'),
+    (0x2D70, 'V'),
+    (0x2D71, 'X'),
+    (0x2D7F, 'V'),
+    (0x2D97, 'X'),
+    (0x2DA0, 'V'),
+    (0x2DA7, 'X'),
+    (0x2DA8, 'V'),
+    (0x2DAF, 'X'),
+    (0x2DB0, 'V'),
+    (0x2DB7, 'X'),
+    (0x2DB8, 'V'),
+    (0x2DBF, 'X'),
+    (0x2DC0, 'V'),
+    (0x2DC7, 'X'),
+    (0x2DC8, 'V'),
+    (0x2DCF, 'X'),
+    (0x2DD0, 'V'),
+    (0x2DD7, 'X'),
+    (0x2DD8, 'V'),
+    (0x2DDF, 'X'),
+    (0x2DE0, 'V'),
+    (0x2E5E, 'X'),
+    (0x2E80, 'V'),
+    (0x2E9A, 'X'),
+    (0x2E9B, 'V'),
+    (0x2E9F, 'M', '母'),
+    (0x2EA0, 'V'),
+    (0x2EF3, 'M', '龟'),
+    (0x2EF4, 'X'),
+    (0x2F00, 'M', '一'),
+    (0x2F01, 'M', '丨'),
+    (0x2F02, 'M', '丶'),
+    (0x2F03, 'M', '丿'),
+    (0x2F04, 'M', '乙'),
+    (0x2F05, 'M', '亅'),
+    (0x2F06, 'M', '二'),
+    (0x2F07, 'M', '亠'),
+    (0x2F08, 'M', '人'),
+    (0x2F09, 'M', '儿'),
+    (0x2F0A, 'M', '入'),
+    (0x2F0B, 'M', '八'),
+    (0x2F0C, 'M', '冂'),
+    (0x2F0D, 'M', '冖'),
+    (0x2F0E, 'M', '冫'),
+    (0x2F0F, 'M', '几'),
+    (0x2F10, 'M', '凵'),
+    (0x2F11, 'M', '刀'),
+    (0x2F12, 'M', '力'),
+    (0x2F13, 'M', '勹'),
+    (0x2F14, 'M', '匕'),
+    (0x2F15, 'M', '匚'),
+    (0x2F16, 'M', '匸'),
+    (0x2F17, 'M', '十'),
+    (0x2F18, 'M', '卜'),
+    (0x2F19, 'M', '卩'),
+    ]
+
+def _seg_27() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x2F1A, 'M', '厂'),
+    (0x2F1B, 'M', '厶'),
+    (0x2F1C, 'M', '又'),
+    (0x2F1D, 'M', '口'),
+    (0x2F1E, 'M', '囗'),
+    (0x2F1F, 'M', '土'),
+    (0x2F20, 'M', '士'),
+    (0x2F21, 'M', '夂'),
+    (0x2F22, 'M', '夊'),
+    (0x2F23, 'M', '夕'),
+    (0x2F24, 'M', '大'),
+    (0x2F25, 'M', '女'),
+    (0x2F26, 'M', '子'),
+    (0x2F27, 'M', '宀'),
+    (0x2F28, 'M', '寸'),
+    (0x2F29, 'M', '小'),
+    (0x2F2A, 'M', '尢'),
+    (0x2F2B, 'M', '尸'),
+    (0x2F2C, 'M', '屮'),
+    (0x2F2D, 'M', '山'),
+    (0x2F2E, 'M', '巛'),
+    (0x2F2F, 'M', '工'),
+    (0x2F30, 'M', '己'),
+    (0x2F31, 'M', '巾'),
+    (0x2F32, 'M', '干'),
+    (0x2F33, 'M', '幺'),
+    (0x2F34, 'M', '广'),
+    (0x2F35, 'M', '廴'),
+    (0x2F36, 'M', '廾'),
+    (0x2F37, 'M', '弋'),
+    (0x2F38, 'M', '弓'),
+    (0x2F39, 'M', '彐'),
+    (0x2F3A, 'M', '彡'),
+    (0x2F3B, 'M', '彳'),
+    (0x2F3C, 'M', '心'),
+    (0x2F3D, 'M', '戈'),
+    (0x2F3E, 'M', '戶'),
+    (0x2F3F, 'M', '手'),
+    (0x2F40, 'M', '支'),
+    (0x2F41, 'M', '攴'),
+    (0x2F42, 'M', '文'),
+    (0x2F43, 'M', '斗'),
+    (0x2F44, 'M', '斤'),
+    (0x2F45, 'M', '方'),
+    (0x2F46, 'M', '无'),
+    (0x2F47, 'M', '日'),
+    (0x2F48, 'M', '曰'),
+    (0x2F49, 'M', '月'),
+    (0x2F4A, 'M', '木'),
+    (0x2F4B, 'M', '欠'),
+    (0x2F4C, 'M', '止'),
+    (0x2F4D, 'M', '歹'),
+    (0x2F4E, 'M', '殳'),
+    (0x2F4F, 'M', '毋'),
+    (0x2F50, 'M', '比'),
+    (0x2F51, 'M', '毛'),
+    (0x2F52, 'M', '氏'),
+    (0x2F53, 'M', '气'),
+    (0x2F54, 'M', '水'),
+    (0x2F55, 'M', '火'),
+    (0x2F56, 'M', '爪'),
+    (0x2F57, 'M', '父'),
+    (0x2F58, 'M', '爻'),
+    (0x2F59, 'M', '爿'),
+    (0x2F5A, 'M', '片'),
+    (0x2F5B, 'M', '牙'),
+    (0x2F5C, 'M', '牛'),
+    (0x2F5D, 'M', '犬'),
+    (0x2F5E, 'M', '玄'),
+    (0x2F5F, 'M', '玉'),
+    (0x2F60, 'M', '瓜'),
+    (0x2F61, 'M', '瓦'),
+    (0x2F62, 'M', '甘'),
+    (0x2F63, 'M', '生'),
+    (0x2F64, 'M', '用'),
+    (0x2F65, 'M', '田'),
+    (0x2F66, 'M', '疋'),
+    (0x2F67, 'M', '疒'),
+    (0x2F68, 'M', '癶'),
+    (0x2F69, 'M', '白'),
+    (0x2F6A, 'M', '皮'),
+    (0x2F6B, 'M', '皿'),
+    (0x2F6C, 'M', '目'),
+    (0x2F6D, 'M', '矛'),
+    (0x2F6E, 'M', '矢'),
+    (0x2F6F, 'M', '石'),
+    (0x2F70, 'M', '示'),
+    (0x2F71, 'M', '禸'),
+    (0x2F72, 'M', '禾'),
+    (0x2F73, 'M', '穴'),
+    (0x2F74, 'M', '立'),
+    (0x2F75, 'M', '竹'),
+    (0x2F76, 'M', '米'),
+    (0x2F77, 'M', '糸'),
+    (0x2F78, 'M', '缶'),
+    (0x2F79, 'M', '网'),
+    (0x2F7A, 'M', '羊'),
+    (0x2F7B, 'M', '羽'),
+    (0x2F7C, 'M', '老'),
+    (0x2F7D, 'M', '而'),
+    ]
+
+def _seg_28() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x2F7E, 'M', '耒'),
+    (0x2F7F, 'M', '耳'),
+    (0x2F80, 'M', '聿'),
+    (0x2F81, 'M', '肉'),
+    (0x2F82, 'M', '臣'),
+    (0x2F83, 'M', '自'),
+    (0x2F84, 'M', '至'),
+    (0x2F85, 'M', '臼'),
+    (0x2F86, 'M', '舌'),
+    (0x2F87, 'M', '舛'),
+    (0x2F88, 'M', '舟'),
+    (0x2F89, 'M', '艮'),
+    (0x2F8A, 'M', '色'),
+    (0x2F8B, 'M', '艸'),
+    (0x2F8C, 'M', '虍'),
+    (0x2F8D, 'M', '虫'),
+    (0x2F8E, 'M', '血'),
+    (0x2F8F, 'M', '行'),
+    (0x2F90, 'M', '衣'),
+    (0x2F91, 'M', '襾'),
+    (0x2F92, 'M', '見'),
+    (0x2F93, 'M', '角'),
+    (0x2F94, 'M', '言'),
+    (0x2F95, 'M', '谷'),
+    (0x2F96, 'M', '豆'),
+    (0x2F97, 'M', '豕'),
+    (0x2F98, 'M', '豸'),
+    (0x2F99, 'M', '貝'),
+    (0x2F9A, 'M', '赤'),
+    (0x2F9B, 'M', '走'),
+    (0x2F9C, 'M', '足'),
+    (0x2F9D, 'M', '身'),
+    (0x2F9E, 'M', '車'),
+    (0x2F9F, 'M', '辛'),
+    (0x2FA0, 'M', '辰'),
+    (0x2FA1, 'M', '辵'),
+    (0x2FA2, 'M', '邑'),
+    (0x2FA3, 'M', '酉'),
+    (0x2FA4, 'M', '釆'),
+    (0x2FA5, 'M', '里'),
+    (0x2FA6, 'M', '金'),
+    (0x2FA7, 'M', '長'),
+    (0x2FA8, 'M', '門'),
+    (0x2FA9, 'M', '阜'),
+    (0x2FAA, 'M', '隶'),
+    (0x2FAB, 'M', '隹'),
+    (0x2FAC, 'M', '雨'),
+    (0x2FAD, 'M', '靑'),
+    (0x2FAE, 'M', '非'),
+    (0x2FAF, 'M', '面'),
+    (0x2FB0, 'M', '革'),
+    (0x2FB1, 'M', '韋'),
+    (0x2FB2, 'M', '韭'),
+    (0x2FB3, 'M', '音'),
+    (0x2FB4, 'M', '頁'),
+    (0x2FB5, 'M', '風'),
+    (0x2FB6, 'M', '飛'),
+    (0x2FB7, 'M', '食'),
+    (0x2FB8, 'M', '首'),
+    (0x2FB9, 'M', '香'),
+    (0x2FBA, 'M', '馬'),
+    (0x2FBB, 'M', '骨'),
+    (0x2FBC, 'M', '高'),
+    (0x2FBD, 'M', '髟'),
+    (0x2FBE, 'M', '鬥'),
+    (0x2FBF, 'M', '鬯'),
+    (0x2FC0, 'M', '鬲'),
+    (0x2FC1, 'M', '鬼'),
+    (0x2FC2, 'M', '魚'),
+    (0x2FC3, 'M', '鳥'),
+    (0x2FC4, 'M', '鹵'),
+    (0x2FC5, 'M', '鹿'),
+    (0x2FC6, 'M', '麥'),
+    (0x2FC7, 'M', '麻'),
+    (0x2FC8, 'M', '黃'),
+    (0x2FC9, 'M', '黍'),
+    (0x2FCA, 'M', '黑'),
+    (0x2FCB, 'M', '黹'),
+    (0x2FCC, 'M', '黽'),
+    (0x2FCD, 'M', '鼎'),
+    (0x2FCE, 'M', '鼓'),
+    (0x2FCF, 'M', '鼠'),
+    (0x2FD0, 'M', '鼻'),
+    (0x2FD1, 'M', '齊'),
+    (0x2FD2, 'M', '齒'),
+    (0x2FD3, 'M', '龍'),
+    (0x2FD4, 'M', '龜'),
+    (0x2FD5, 'M', '龠'),
+    (0x2FD6, 'X'),
+    (0x3000, '3', ' '),
+    (0x3001, 'V'),
+    (0x3002, 'M', '.'),
+    (0x3003, 'V'),
+    (0x3036, 'M', '〒'),
+    (0x3037, 'V'),
+    (0x3038, 'M', '十'),
+    (0x3039, 'M', '卄'),
+    (0x303A, 'M', '卅'),
+    (0x303B, 'V'),
+    (0x3040, 'X'),
+    ]
+
+def _seg_29() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x3041, 'V'),
+    (0x3097, 'X'),
+    (0x3099, 'V'),
+    (0x309B, '3', ' ゙'),
+    (0x309C, '3', ' ゚'),
+    (0x309D, 'V'),
+    (0x309F, 'M', 'より'),
+    (0x30A0, 'V'),
+    (0x30FF, 'M', 'コト'),
+    (0x3100, 'X'),
+    (0x3105, 'V'),
+    (0x3130, 'X'),
+    (0x3131, 'M', 'ᄀ'),
+    (0x3132, 'M', 'ᄁ'),
+    (0x3133, 'M', 'ᆪ'),
+    (0x3134, 'M', 'ᄂ'),
+    (0x3135, 'M', 'ᆬ'),
+    (0x3136, 'M', 'ᆭ'),
+    (0x3137, 'M', 'ᄃ'),
+    (0x3138, 'M', 'ᄄ'),
+    (0x3139, 'M', 'ᄅ'),
+    (0x313A, 'M', 'ᆰ'),
+    (0x313B, 'M', 'ᆱ'),
+    (0x313C, 'M', 'ᆲ'),
+    (0x313D, 'M', 'ᆳ'),
+    (0x313E, 'M', 'ᆴ'),
+    (0x313F, 'M', 'ᆵ'),
+    (0x3140, 'M', 'ᄚ'),
+    (0x3141, 'M', 'ᄆ'),
+    (0x3142, 'M', 'ᄇ'),
+    (0x3143, 'M', 'ᄈ'),
+    (0x3144, 'M', 'ᄡ'),
+    (0x3145, 'M', 'ᄉ'),
+    (0x3146, 'M', 'ᄊ'),
+    (0x3147, 'M', 'ᄋ'),
+    (0x3148, 'M', 'ᄌ'),
+    (0x3149, 'M', 'ᄍ'),
+    (0x314A, 'M', 'ᄎ'),
+    (0x314B, 'M', 'ᄏ'),
+    (0x314C, 'M', 'ᄐ'),
+    (0x314D, 'M', 'ᄑ'),
+    (0x314E, 'M', 'ᄒ'),
+    (0x314F, 'M', 'ᅡ'),
+    (0x3150, 'M', 'ᅢ'),
+    (0x3151, 'M', 'ᅣ'),
+    (0x3152, 'M', 'ᅤ'),
+    (0x3153, 'M', 'ᅥ'),
+    (0x3154, 'M', 'ᅦ'),
+    (0x3155, 'M', 'ᅧ'),
+    (0x3156, 'M', 'ᅨ'),
+    (0x3157, 'M', 'ᅩ'),
+    (0x3158, 'M', 'ᅪ'),
+    (0x3159, 'M', 'ᅫ'),
+    (0x315A, 'M', 'ᅬ'),
+    (0x315B, 'M', 'ᅭ'),
+    (0x315C, 'M', 'ᅮ'),
+    (0x315D, 'M', 'ᅯ'),
+    (0x315E, 'M', 'ᅰ'),
+    (0x315F, 'M', 'ᅱ'),
+    (0x3160, 'M', 'ᅲ'),
+    (0x3161, 'M', 'ᅳ'),
+    (0x3162, 'M', 'ᅴ'),
+    (0x3163, 'M', 'ᅵ'),
+    (0x3164, 'X'),
+    (0x3165, 'M', 'ᄔ'),
+    (0x3166, 'M', 'ᄕ'),
+    (0x3167, 'M', 'ᇇ'),
+    (0x3168, 'M', 'ᇈ'),
+    (0x3169, 'M', 'ᇌ'),
+    (0x316A, 'M', 'ᇎ'),
+    (0x316B, 'M', 'ᇓ'),
+    (0x316C, 'M', 'ᇗ'),
+    (0x316D, 'M', 'ᇙ'),
+    (0x316E, 'M', 'ᄜ'),
+    (0x316F, 'M', 'ᇝ'),
+    (0x3170, 'M', 'ᇟ'),
+    (0x3171, 'M', 'ᄝ'),
+    (0x3172, 'M', 'ᄞ'),
+    (0x3173, 'M', 'ᄠ'),
+    (0x3174, 'M', 'ᄢ'),
+    (0x3175, 'M', 'ᄣ'),
+    (0x3176, 'M', 'ᄧ'),
+    (0x3177, 'M', 'ᄩ'),
+    (0x3178, 'M', 'ᄫ'),
+    (0x3179, 'M', 'ᄬ'),
+    (0x317A, 'M', 'ᄭ'),
+    (0x317B, 'M', 'ᄮ'),
+    (0x317C, 'M', 'ᄯ'),
+    (0x317D, 'M', 'ᄲ'),
+    (0x317E, 'M', 'ᄶ'),
+    (0x317F, 'M', 'ᅀ'),
+    (0x3180, 'M', 'ᅇ'),
+    (0x3181, 'M', 'ᅌ'),
+    (0x3182, 'M', 'ᇱ'),
+    (0x3183, 'M', 'ᇲ'),
+    (0x3184, 'M', 'ᅗ'),
+    (0x3185, 'M', 'ᅘ'),
+    (0x3186, 'M', 'ᅙ'),
+    (0x3187, 'M', 'ᆄ'),
+    (0x3188, 'M', 'ᆅ'),
+    ]
+
+def _seg_30() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x3189, 'M', 'ᆈ'),
+    (0x318A, 'M', 'ᆑ'),
+    (0x318B, 'M', 'ᆒ'),
+    (0x318C, 'M', 'ᆔ'),
+    (0x318D, 'M', 'ᆞ'),
+    (0x318E, 'M', 'ᆡ'),
+    (0x318F, 'X'),
+    (0x3190, 'V'),
+    (0x3192, 'M', '一'),
+    (0x3193, 'M', '二'),
+    (0x3194, 'M', '三'),
+    (0x3195, 'M', '四'),
+    (0x3196, 'M', '上'),
+    (0x3197, 'M', '中'),
+    (0x3198, 'M', '下'),
+    (0x3199, 'M', '甲'),
+    (0x319A, 'M', '乙'),
+    (0x319B, 'M', '丙'),
+    (0x319C, 'M', '丁'),
+    (0x319D, 'M', '天'),
+    (0x319E, 'M', '地'),
+    (0x319F, 'M', '人'),
+    (0x31A0, 'V'),
+    (0x31E4, 'X'),
+    (0x31F0, 'V'),
+    (0x3200, '3', '(ᄀ)'),
+    (0x3201, '3', '(ᄂ)'),
+    (0x3202, '3', '(ᄃ)'),
+    (0x3203, '3', '(ᄅ)'),
+    (0x3204, '3', '(ᄆ)'),
+    (0x3205, '3', '(ᄇ)'),
+    (0x3206, '3', '(ᄉ)'),
+    (0x3207, '3', '(ᄋ)'),
+    (0x3208, '3', '(ᄌ)'),
+    (0x3209, '3', '(ᄎ)'),
+    (0x320A, '3', '(ᄏ)'),
+    (0x320B, '3', '(ᄐ)'),
+    (0x320C, '3', '(ᄑ)'),
+    (0x320D, '3', '(ᄒ)'),
+    (0x320E, '3', '(가)'),
+    (0x320F, '3', '(나)'),
+    (0x3210, '3', '(다)'),
+    (0x3211, '3', '(라)'),
+    (0x3212, '3', '(마)'),
+    (0x3213, '3', '(바)'),
+    (0x3214, '3', '(사)'),
+    (0x3215, '3', '(아)'),
+    (0x3216, '3', '(자)'),
+    (0x3217, '3', '(차)'),
+    (0x3218, '3', '(카)'),
+    (0x3219, '3', '(타)'),
+    (0x321A, '3', '(파)'),
+    (0x321B, '3', '(하)'),
+    (0x321C, '3', '(주)'),
+    (0x321D, '3', '(오전)'),
+    (0x321E, '3', '(오후)'),
+    (0x321F, 'X'),
+    (0x3220, '3', '(一)'),
+    (0x3221, '3', '(二)'),
+    (0x3222, '3', '(三)'),
+    (0x3223, '3', '(四)'),
+    (0x3224, '3', '(五)'),
+    (0x3225, '3', '(六)'),
+    (0x3226, '3', '(七)'),
+    (0x3227, '3', '(八)'),
+    (0x3228, '3', '(九)'),
+    (0x3229, '3', '(十)'),
+    (0x322A, '3', '(月)'),
+    (0x322B, '3', '(火)'),
+    (0x322C, '3', '(水)'),
+    (0x322D, '3', '(木)'),
+    (0x322E, '3', '(金)'),
+    (0x322F, '3', '(土)'),
+    (0x3230, '3', '(日)'),
+    (0x3231, '3', '(株)'),
+    (0x3232, '3', '(有)'),
+    (0x3233, '3', '(社)'),
+    (0x3234, '3', '(名)'),
+    (0x3235, '3', '(特)'),
+    (0x3236, '3', '(財)'),
+    (0x3237, '3', '(祝)'),
+    (0x3238, '3', '(労)'),
+    (0x3239, '3', '(代)'),
+    (0x323A, '3', '(呼)'),
+    (0x323B, '3', '(学)'),
+    (0x323C, '3', '(監)'),
+    (0x323D, '3', '(企)'),
+    (0x323E, '3', '(資)'),
+    (0x323F, '3', '(協)'),
+    (0x3240, '3', '(祭)'),
+    (0x3241, '3', '(休)'),
+    (0x3242, '3', '(自)'),
+    (0x3243, '3', '(至)'),
+    (0x3244, 'M', '問'),
+    (0x3245, 'M', '幼'),
+    (0x3246, 'M', '文'),
+    (0x3247, 'M', '箏'),
+    (0x3248, 'V'),
+    (0x3250, 'M', 'pte'),
+    (0x3251, 'M', '21'),
+    ]
+
+def _seg_31() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x3252, 'M', '22'),
+    (0x3253, 'M', '23'),
+    (0x3254, 'M', '24'),
+    (0x3255, 'M', '25'),
+    (0x3256, 'M', '26'),
+    (0x3257, 'M', '27'),
+    (0x3258, 'M', '28'),
+    (0x3259, 'M', '29'),
+    (0x325A, 'M', '30'),
+    (0x325B, 'M', '31'),
+    (0x325C, 'M', '32'),
+    (0x325D, 'M', '33'),
+    (0x325E, 'M', '34'),
+    (0x325F, 'M', '35'),
+    (0x3260, 'M', 'ᄀ'),
+    (0x3261, 'M', 'ᄂ'),
+    (0x3262, 'M', 'ᄃ'),
+    (0x3263, 'M', 'ᄅ'),
+    (0x3264, 'M', 'ᄆ'),
+    (0x3265, 'M', 'ᄇ'),
+    (0x3266, 'M', 'ᄉ'),
+    (0x3267, 'M', 'ᄋ'),
+    (0x3268, 'M', 'ᄌ'),
+    (0x3269, 'M', 'ᄎ'),
+    (0x326A, 'M', 'ᄏ'),
+    (0x326B, 'M', 'ᄐ'),
+    (0x326C, 'M', 'ᄑ'),
+    (0x326D, 'M', 'ᄒ'),
+    (0x326E, 'M', '가'),
+    (0x326F, 'M', '나'),
+    (0x3270, 'M', '다'),
+    (0x3271, 'M', '라'),
+    (0x3272, 'M', '마'),
+    (0x3273, 'M', '바'),
+    (0x3274, 'M', '사'),
+    (0x3275, 'M', '아'),
+    (0x3276, 'M', '자'),
+    (0x3277, 'M', '차'),
+    (0x3278, 'M', '카'),
+    (0x3279, 'M', '타'),
+    (0x327A, 'M', '파'),
+    (0x327B, 'M', '하'),
+    (0x327C, 'M', '참고'),
+    (0x327D, 'M', '주의'),
+    (0x327E, 'M', '우'),
+    (0x327F, 'V'),
+    (0x3280, 'M', '一'),
+    (0x3281, 'M', '二'),
+    (0x3282, 'M', '三'),
+    (0x3283, 'M', '四'),
+    (0x3284, 'M', '五'),
+    (0x3285, 'M', '六'),
+    (0x3286, 'M', '七'),
+    (0x3287, 'M', '八'),
+    (0x3288, 'M', '九'),
+    (0x3289, 'M', '十'),
+    (0x328A, 'M', '月'),
+    (0x328B, 'M', '火'),
+    (0x328C, 'M', '水'),
+    (0x328D, 'M', '木'),
+    (0x328E, 'M', '金'),
+    (0x328F, 'M', '土'),
+    (0x3290, 'M', '日'),
+    (0x3291, 'M', '株'),
+    (0x3292, 'M', '有'),
+    (0x3293, 'M', '社'),
+    (0x3294, 'M', '名'),
+    (0x3295, 'M', '特'),
+    (0x3296, 'M', '財'),
+    (0x3297, 'M', '祝'),
+    (0x3298, 'M', '労'),
+    (0x3299, 'M', '秘'),
+    (0x329A, 'M', '男'),
+    (0x329B, 'M', '女'),
+    (0x329C, 'M', '適'),
+    (0x329D, 'M', '優'),
+    (0x329E, 'M', '印'),
+    (0x329F, 'M', '注'),
+    (0x32A0, 'M', '項'),
+    (0x32A1, 'M', '休'),
+    (0x32A2, 'M', '写'),
+    (0x32A3, 'M', '正'),
+    (0x32A4, 'M', '上'),
+    (0x32A5, 'M', '中'),
+    (0x32A6, 'M', '下'),
+    (0x32A7, 'M', '左'),
+    (0x32A8, 'M', '右'),
+    (0x32A9, 'M', '医'),
+    (0x32AA, 'M', '宗'),
+    (0x32AB, 'M', '学'),
+    (0x32AC, 'M', '監'),
+    (0x32AD, 'M', '企'),
+    (0x32AE, 'M', '資'),
+    (0x32AF, 'M', '協'),
+    (0x32B0, 'M', '夜'),
+    (0x32B1, 'M', '36'),
+    (0x32B2, 'M', '37'),
+    (0x32B3, 'M', '38'),
+    (0x32B4, 'M', '39'),
+    (0x32B5, 'M', '40'),
+    ]
+
+def _seg_32() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x32B6, 'M', '41'),
+    (0x32B7, 'M', '42'),
+    (0x32B8, 'M', '43'),
+    (0x32B9, 'M', '44'),
+    (0x32BA, 'M', '45'),
+    (0x32BB, 'M', '46'),
+    (0x32BC, 'M', '47'),
+    (0x32BD, 'M', '48'),
+    (0x32BE, 'M', '49'),
+    (0x32BF, 'M', '50'),
+    (0x32C0, 'M', '1月'),
+    (0x32C1, 'M', '2月'),
+    (0x32C2, 'M', '3月'),
+    (0x32C3, 'M', '4月'),
+    (0x32C4, 'M', '5月'),
+    (0x32C5, 'M', '6月'),
+    (0x32C6, 'M', '7月'),
+    (0x32C7, 'M', '8月'),
+    (0x32C8, 'M', '9月'),
+    (0x32C9, 'M', '10月'),
+    (0x32CA, 'M', '11月'),
+    (0x32CB, 'M', '12月'),
+    (0x32CC, 'M', 'hg'),
+    (0x32CD, 'M', 'erg'),
+    (0x32CE, 'M', 'ev'),
+    (0x32CF, 'M', 'ltd'),
+    (0x32D0, 'M', 'ア'),
+    (0x32D1, 'M', 'イ'),
+    (0x32D2, 'M', 'ウ'),
+    (0x32D3, 'M', 'エ'),
+    (0x32D4, 'M', 'オ'),
+    (0x32D5, 'M', 'カ'),
+    (0x32D6, 'M', 'キ'),
+    (0x32D7, 'M', 'ク'),
+    (0x32D8, 'M', 'ケ'),
+    (0x32D9, 'M', 'コ'),
+    (0x32DA, 'M', 'サ'),
+    (0x32DB, 'M', 'シ'),
+    (0x32DC, 'M', 'ス'),
+    (0x32DD, 'M', 'セ'),
+    (0x32DE, 'M', 'ソ'),
+    (0x32DF, 'M', 'タ'),
+    (0x32E0, 'M', 'チ'),
+    (0x32E1, 'M', 'ツ'),
+    (0x32E2, 'M', 'テ'),
+    (0x32E3, 'M', 'ト'),
+    (0x32E4, 'M', 'ナ'),
+    (0x32E5, 'M', 'ニ'),
+    (0x32E6, 'M', 'ヌ'),
+    (0x32E7, 'M', 'ネ'),
+    (0x32E8, 'M', 'ノ'),
+    (0x32E9, 'M', 'ハ'),
+    (0x32EA, 'M', 'ヒ'),
+    (0x32EB, 'M', 'フ'),
+    (0x32EC, 'M', 'ヘ'),
+    (0x32ED, 'M', 'ホ'),
+    (0x32EE, 'M', 'マ'),
+    (0x32EF, 'M', 'ミ'),
+    (0x32F0, 'M', 'ム'),
+    (0x32F1, 'M', 'メ'),
+    (0x32F2, 'M', 'モ'),
+    (0x32F3, 'M', 'ヤ'),
+    (0x32F4, 'M', 'ユ'),
+    (0x32F5, 'M', 'ヨ'),
+    (0x32F6, 'M', 'ラ'),
+    (0x32F7, 'M', 'リ'),
+    (0x32F8, 'M', 'ル'),
+    (0x32F9, 'M', 'レ'),
+    (0x32FA, 'M', 'ロ'),
+    (0x32FB, 'M', 'ワ'),
+    (0x32FC, 'M', 'ヰ'),
+    (0x32FD, 'M', 'ヱ'),
+    (0x32FE, 'M', 'ヲ'),
+    (0x32FF, 'M', '令和'),
+    (0x3300, 'M', 'アパート'),
+    (0x3301, 'M', 'アルファ'),
+    (0x3302, 'M', 'アンペア'),
+    (0x3303, 'M', 'アール'),
+    (0x3304, 'M', 'イニング'),
+    (0x3305, 'M', 'インチ'),
+    (0x3306, 'M', 'ウォン'),
+    (0x3307, 'M', 'エスクード'),
+    (0x3308, 'M', 'エーカー'),
+    (0x3309, 'M', 'オンス'),
+    (0x330A, 'M', 'オーム'),
+    (0x330B, 'M', 'カイリ'),
+    (0x330C, 'M', 'カラット'),
+    (0x330D, 'M', 'カロリー'),
+    (0x330E, 'M', 'ガロン'),
+    (0x330F, 'M', 'ガンマ'),
+    (0x3310, 'M', 'ギガ'),
+    (0x3311, 'M', 'ギニー'),
+    (0x3312, 'M', 'キュリー'),
+    (0x3313, 'M', 'ギルダー'),
+    (0x3314, 'M', 'キロ'),
+    (0x3315, 'M', 'キログラム'),
+    (0x3316, 'M', 'キロメートル'),
+    (0x3317, 'M', 'キロワット'),
+    (0x3318, 'M', 'グラム'),
+    (0x3319, 'M', 'グラムトン'),
+    ]
+
+def _seg_33() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x331A, 'M', 'クルゼイロ'),
+    (0x331B, 'M', 'クローネ'),
+    (0x331C, 'M', 'ケース'),
+    (0x331D, 'M', 'コルナ'),
+    (0x331E, 'M', 'コーポ'),
+    (0x331F, 'M', 'サイクル'),
+    (0x3320, 'M', 'サンチーム'),
+    (0x3321, 'M', 'シリング'),
+    (0x3322, 'M', 'センチ'),
+    (0x3323, 'M', 'セント'),
+    (0x3324, 'M', 'ダース'),
+    (0x3325, 'M', 'デシ'),
+    (0x3326, 'M', 'ドル'),
+    (0x3327, 'M', 'トン'),
+    (0x3328, 'M', 'ナノ'),
+    (0x3329, 'M', 'ノット'),
+    (0x332A, 'M', 'ハイツ'),
+    (0x332B, 'M', 'パーセント'),
+    (0x332C, 'M', 'パーツ'),
+    (0x332D, 'M', 'バーレル'),
+    (0x332E, 'M', 'ピアストル'),
+    (0x332F, 'M', 'ピクル'),
+    (0x3330, 'M', 'ピコ'),
+    (0x3331, 'M', 'ビル'),
+    (0x3332, 'M', 'ファラッド'),
+    (0x3333, 'M', 'フィート'),
+    (0x3334, 'M', 'ブッシェル'),
+    (0x3335, 'M', 'フラン'),
+    (0x3336, 'M', 'ヘクタール'),
+    (0x3337, 'M', 'ペソ'),
+    (0x3338, 'M', 'ペニヒ'),
+    (0x3339, 'M', 'ヘルツ'),
+    (0x333A, 'M', 'ペンス'),
+    (0x333B, 'M', 'ページ'),
+    (0x333C, 'M', 'ベータ'),
+    (0x333D, 'M', 'ポイント'),
+    (0x333E, 'M', 'ボルト'),
+    (0x333F, 'M', 'ホン'),
+    (0x3340, 'M', 'ポンド'),
+    (0x3341, 'M', 'ホール'),
+    (0x3342, 'M', 'ホーン'),
+    (0x3343, 'M', 'マイクロ'),
+    (0x3344, 'M', 'マイル'),
+    (0x3345, 'M', 'マッハ'),
+    (0x3346, 'M', 'マルク'),
+    (0x3347, 'M', 'マンション'),
+    (0x3348, 'M', 'ミクロン'),
+    (0x3349, 'M', 'ミリ'),
+    (0x334A, 'M', 'ミリバール'),
+    (0x334B, 'M', 'メガ'),
+    (0x334C, 'M', 'メガトン'),
+    (0x334D, 'M', 'メートル'),
+    (0x334E, 'M', 'ヤード'),
+    (0x334F, 'M', 'ヤール'),
+    (0x3350, 'M', 'ユアン'),
+    (0x3351, 'M', 'リットル'),
+    (0x3352, 'M', 'リラ'),
+    (0x3353, 'M', 'ルピー'),
+    (0x3354, 'M', 'ルーブル'),
+    (0x3355, 'M', 'レム'),
+    (0x3356, 'M', 'レントゲン'),
+    (0x3357, 'M', 'ワット'),
+    (0x3358, 'M', '0点'),
+    (0x3359, 'M', '1点'),
+    (0x335A, 'M', '2点'),
+    (0x335B, 'M', '3点'),
+    (0x335C, 'M', '4点'),
+    (0x335D, 'M', '5点'),
+    (0x335E, 'M', '6点'),
+    (0x335F, 'M', '7点'),
+    (0x3360, 'M', '8点'),
+    (0x3361, 'M', '9点'),
+    (0x3362, 'M', '10点'),
+    (0x3363, 'M', '11点'),
+    (0x3364, 'M', '12点'),
+    (0x3365, 'M', '13点'),
+    (0x3366, 'M', '14点'),
+    (0x3367, 'M', '15点'),
+    (0x3368, 'M', '16点'),
+    (0x3369, 'M', '17点'),
+    (0x336A, 'M', '18点'),
+    (0x336B, 'M', '19点'),
+    (0x336C, 'M', '20点'),
+    (0x336D, 'M', '21点'),
+    (0x336E, 'M', '22点'),
+    (0x336F, 'M', '23点'),
+    (0x3370, 'M', '24点'),
+    (0x3371, 'M', 'hpa'),
+    (0x3372, 'M', 'da'),
+    (0x3373, 'M', 'au'),
+    (0x3374, 'M', 'bar'),
+    (0x3375, 'M', 'ov'),
+    (0x3376, 'M', 'pc'),
+    (0x3377, 'M', 'dm'),
+    (0x3378, 'M', 'dm2'),
+    (0x3379, 'M', 'dm3'),
+    (0x337A, 'M', 'iu'),
+    (0x337B, 'M', '平成'),
+    (0x337C, 'M', '昭和'),
+    (0x337D, 'M', '大正'),
+    ]
+
+def _seg_34() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x337E, 'M', '明治'),
+    (0x337F, 'M', '株式会社'),
+    (0x3380, 'M', 'pa'),
+    (0x3381, 'M', 'na'),
+    (0x3382, 'M', 'μa'),
+    (0x3383, 'M', 'ma'),
+    (0x3384, 'M', 'ka'),
+    (0x3385, 'M', 'kb'),
+    (0x3386, 'M', 'mb'),
+    (0x3387, 'M', 'gb'),
+    (0x3388, 'M', 'cal'),
+    (0x3389, 'M', 'kcal'),
+    (0x338A, 'M', 'pf'),
+    (0x338B, 'M', 'nf'),
+    (0x338C, 'M', 'μf'),
+    (0x338D, 'M', 'μg'),
+    (0x338E, 'M', 'mg'),
+    (0x338F, 'M', 'kg'),
+    (0x3390, 'M', 'hz'),
+    (0x3391, 'M', 'khz'),
+    (0x3392, 'M', 'mhz'),
+    (0x3393, 'M', 'ghz'),
+    (0x3394, 'M', 'thz'),
+    (0x3395, 'M', 'μl'),
+    (0x3396, 'M', 'ml'),
+    (0x3397, 'M', 'dl'),
+    (0x3398, 'M', 'kl'),
+    (0x3399, 'M', 'fm'),
+    (0x339A, 'M', 'nm'),
+    (0x339B, 'M', 'μm'),
+    (0x339C, 'M', 'mm'),
+    (0x339D, 'M', 'cm'),
+    (0x339E, 'M', 'km'),
+    (0x339F, 'M', 'mm2'),
+    (0x33A0, 'M', 'cm2'),
+    (0x33A1, 'M', 'm2'),
+    (0x33A2, 'M', 'km2'),
+    (0x33A3, 'M', 'mm3'),
+    (0x33A4, 'M', 'cm3'),
+    (0x33A5, 'M', 'm3'),
+    (0x33A6, 'M', 'km3'),
+    (0x33A7, 'M', 'm∕s'),
+    (0x33A8, 'M', 'm∕s2'),
+    (0x33A9, 'M', 'pa'),
+    (0x33AA, 'M', 'kpa'),
+    (0x33AB, 'M', 'mpa'),
+    (0x33AC, 'M', 'gpa'),
+    (0x33AD, 'M', 'rad'),
+    (0x33AE, 'M', 'rad∕s'),
+    (0x33AF, 'M', 'rad∕s2'),
+    (0x33B0, 'M', 'ps'),
+    (0x33B1, 'M', 'ns'),
+    (0x33B2, 'M', 'μs'),
+    (0x33B3, 'M', 'ms'),
+    (0x33B4, 'M', 'pv'),
+    (0x33B5, 'M', 'nv'),
+    (0x33B6, 'M', 'μv'),
+    (0x33B7, 'M', 'mv'),
+    (0x33B8, 'M', 'kv'),
+    (0x33B9, 'M', 'mv'),
+    (0x33BA, 'M', 'pw'),
+    (0x33BB, 'M', 'nw'),
+    (0x33BC, 'M', 'μw'),
+    (0x33BD, 'M', 'mw'),
+    (0x33BE, 'M', 'kw'),
+    (0x33BF, 'M', 'mw'),
+    (0x33C0, 'M', 'kω'),
+    (0x33C1, 'M', 'mω'),
+    (0x33C2, 'X'),
+    (0x33C3, 'M', 'bq'),
+    (0x33C4, 'M', 'cc'),
+    (0x33C5, 'M', 'cd'),
+    (0x33C6, 'M', 'c∕kg'),
+    (0x33C7, 'X'),
+    (0x33C8, 'M', 'db'),
+    (0x33C9, 'M', 'gy'),
+    (0x33CA, 'M', 'ha'),
+    (0x33CB, 'M', 'hp'),
+    (0x33CC, 'M', 'in'),
+    (0x33CD, 'M', 'kk'),
+    (0x33CE, 'M', 'km'),
+    (0x33CF, 'M', 'kt'),
+    (0x33D0, 'M', 'lm'),
+    (0x33D1, 'M', 'ln'),
+    (0x33D2, 'M', 'log'),
+    (0x33D3, 'M', 'lx'),
+    (0x33D4, 'M', 'mb'),
+    (0x33D5, 'M', 'mil'),
+    (0x33D6, 'M', 'mol'),
+    (0x33D7, 'M', 'ph'),
+    (0x33D8, 'X'),
+    (0x33D9, 'M', 'ppm'),
+    (0x33DA, 'M', 'pr'),
+    (0x33DB, 'M', 'sr'),
+    (0x33DC, 'M', 'sv'),
+    (0x33DD, 'M', 'wb'),
+    (0x33DE, 'M', 'v∕m'),
+    (0x33DF, 'M', 'a∕m'),
+    (0x33E0, 'M', '1日'),
+    (0x33E1, 'M', '2日'),
+    ]
+
+def _seg_35() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x33E2, 'M', '3日'),
+    (0x33E3, 'M', '4日'),
+    (0x33E4, 'M', '5日'),
+    (0x33E5, 'M', '6日'),
+    (0x33E6, 'M', '7日'),
+    (0x33E7, 'M', '8日'),
+    (0x33E8, 'M', '9日'),
+    (0x33E9, 'M', '10日'),
+    (0x33EA, 'M', '11日'),
+    (0x33EB, 'M', '12日'),
+    (0x33EC, 'M', '13日'),
+    (0x33ED, 'M', '14日'),
+    (0x33EE, 'M', '15日'),
+    (0x33EF, 'M', '16日'),
+    (0x33F0, 'M', '17日'),
+    (0x33F1, 'M', '18日'),
+    (0x33F2, 'M', '19日'),
+    (0x33F3, 'M', '20日'),
+    (0x33F4, 'M', '21日'),
+    (0x33F5, 'M', '22日'),
+    (0x33F6, 'M', '23日'),
+    (0x33F7, 'M', '24日'),
+    (0x33F8, 'M', '25日'),
+    (0x33F9, 'M', '26日'),
+    (0x33FA, 'M', '27日'),
+    (0x33FB, 'M', '28日'),
+    (0x33FC, 'M', '29日'),
+    (0x33FD, 'M', '30日'),
+    (0x33FE, 'M', '31日'),
+    (0x33FF, 'M', 'gal'),
+    (0x3400, 'V'),
+    (0xA48D, 'X'),
+    (0xA490, 'V'),
+    (0xA4C7, 'X'),
+    (0xA4D0, 'V'),
+    (0xA62C, 'X'),
+    (0xA640, 'M', 'ꙁ'),
+    (0xA641, 'V'),
+    (0xA642, 'M', 'ꙃ'),
+    (0xA643, 'V'),
+    (0xA644, 'M', 'ꙅ'),
+    (0xA645, 'V'),
+    (0xA646, 'M', 'ꙇ'),
+    (0xA647, 'V'),
+    (0xA648, 'M', 'ꙉ'),
+    (0xA649, 'V'),
+    (0xA64A, 'M', 'ꙋ'),
+    (0xA64B, 'V'),
+    (0xA64C, 'M', 'ꙍ'),
+    (0xA64D, 'V'),
+    (0xA64E, 'M', 'ꙏ'),
+    (0xA64F, 'V'),
+    (0xA650, 'M', 'ꙑ'),
+    (0xA651, 'V'),
+    (0xA652, 'M', 'ꙓ'),
+    (0xA653, 'V'),
+    (0xA654, 'M', 'ꙕ'),
+    (0xA655, 'V'),
+    (0xA656, 'M', 'ꙗ'),
+    (0xA657, 'V'),
+    (0xA658, 'M', 'ꙙ'),
+    (0xA659, 'V'),
+    (0xA65A, 'M', 'ꙛ'),
+    (0xA65B, 'V'),
+    (0xA65C, 'M', 'ꙝ'),
+    (0xA65D, 'V'),
+    (0xA65E, 'M', 'ꙟ'),
+    (0xA65F, 'V'),
+    (0xA660, 'M', 'ꙡ'),
+    (0xA661, 'V'),
+    (0xA662, 'M', 'ꙣ'),
+    (0xA663, 'V'),
+    (0xA664, 'M', 'ꙥ'),
+    (0xA665, 'V'),
+    (0xA666, 'M', 'ꙧ'),
+    (0xA667, 'V'),
+    (0xA668, 'M', 'ꙩ'),
+    (0xA669, 'V'),
+    (0xA66A, 'M', 'ꙫ'),
+    (0xA66B, 'V'),
+    (0xA66C, 'M', 'ꙭ'),
+    (0xA66D, 'V'),
+    (0xA680, 'M', 'ꚁ'),
+    (0xA681, 'V'),
+    (0xA682, 'M', 'ꚃ'),
+    (0xA683, 'V'),
+    (0xA684, 'M', 'ꚅ'),
+    (0xA685, 'V'),
+    (0xA686, 'M', 'ꚇ'),
+    (0xA687, 'V'),
+    (0xA688, 'M', 'ꚉ'),
+    (0xA689, 'V'),
+    (0xA68A, 'M', 'ꚋ'),
+    (0xA68B, 'V'),
+    (0xA68C, 'M', 'ꚍ'),
+    (0xA68D, 'V'),
+    (0xA68E, 'M', 'ꚏ'),
+    (0xA68F, 'V'),
+    (0xA690, 'M', 'ꚑ'),
+    (0xA691, 'V'),
+    ]
+
+def _seg_36() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0xA692, 'M', 'ꚓ'),
+    (0xA693, 'V'),
+    (0xA694, 'M', 'ꚕ'),
+    (0xA695, 'V'),
+    (0xA696, 'M', 'ꚗ'),
+    (0xA697, 'V'),
+    (0xA698, 'M', 'ꚙ'),
+    (0xA699, 'V'),
+    (0xA69A, 'M', 'ꚛ'),
+    (0xA69B, 'V'),
+    (0xA69C, 'M', 'ъ'),
+    (0xA69D, 'M', 'ь'),
+    (0xA69E, 'V'),
+    (0xA6F8, 'X'),
+    (0xA700, 'V'),
+    (0xA722, 'M', 'ꜣ'),
+    (0xA723, 'V'),
+    (0xA724, 'M', 'ꜥ'),
+    (0xA725, 'V'),
+    (0xA726, 'M', 'ꜧ'),
+    (0xA727, 'V'),
+    (0xA728, 'M', 'ꜩ'),
+    (0xA729, 'V'),
+    (0xA72A, 'M', 'ꜫ'),
+    (0xA72B, 'V'),
+    (0xA72C, 'M', 'ꜭ'),
+    (0xA72D, 'V'),
+    (0xA72E, 'M', 'ꜯ'),
+    (0xA72F, 'V'),
+    (0xA732, 'M', 'ꜳ'),
+    (0xA733, 'V'),
+    (0xA734, 'M', 'ꜵ'),
+    (0xA735, 'V'),
+    (0xA736, 'M', 'ꜷ'),
+    (0xA737, 'V'),
+    (0xA738, 'M', 'ꜹ'),
+    (0xA739, 'V'),
+    (0xA73A, 'M', 'ꜻ'),
+    (0xA73B, 'V'),
+    (0xA73C, 'M', 'ꜽ'),
+    (0xA73D, 'V'),
+    (0xA73E, 'M', 'ꜿ'),
+    (0xA73F, 'V'),
+    (0xA740, 'M', 'ꝁ'),
+    (0xA741, 'V'),
+    (0xA742, 'M', 'ꝃ'),
+    (0xA743, 'V'),
+    (0xA744, 'M', 'ꝅ'),
+    (0xA745, 'V'),
+    (0xA746, 'M', 'ꝇ'),
+    (0xA747, 'V'),
+    (0xA748, 'M', 'ꝉ'),
+    (0xA749, 'V'),
+    (0xA74A, 'M', 'ꝋ'),
+    (0xA74B, 'V'),
+    (0xA74C, 'M', 'ꝍ'),
+    (0xA74D, 'V'),
+    (0xA74E, 'M', 'ꝏ'),
+    (0xA74F, 'V'),
+    (0xA750, 'M', 'ꝑ'),
+    (0xA751, 'V'),
+    (0xA752, 'M', 'ꝓ'),
+    (0xA753, 'V'),
+    (0xA754, 'M', 'ꝕ'),
+    (0xA755, 'V'),
+    (0xA756, 'M', 'ꝗ'),
+    (0xA757, 'V'),
+    (0xA758, 'M', 'ꝙ'),
+    (0xA759, 'V'),
+    (0xA75A, 'M', 'ꝛ'),
+    (0xA75B, 'V'),
+    (0xA75C, 'M', 'ꝝ'),
+    (0xA75D, 'V'),
+    (0xA75E, 'M', 'ꝟ'),
+    (0xA75F, 'V'),
+    (0xA760, 'M', 'ꝡ'),
+    (0xA761, 'V'),
+    (0xA762, 'M', 'ꝣ'),
+    (0xA763, 'V'),
+    (0xA764, 'M', 'ꝥ'),
+    (0xA765, 'V'),
+    (0xA766, 'M', 'ꝧ'),
+    (0xA767, 'V'),
+    (0xA768, 'M', 'ꝩ'),
+    (0xA769, 'V'),
+    (0xA76A, 'M', 'ꝫ'),
+    (0xA76B, 'V'),
+    (0xA76C, 'M', 'ꝭ'),
+    (0xA76D, 'V'),
+    (0xA76E, 'M', 'ꝯ'),
+    (0xA76F, 'V'),
+    (0xA770, 'M', 'ꝯ'),
+    (0xA771, 'V'),
+    (0xA779, 'M', 'ꝺ'),
+    (0xA77A, 'V'),
+    (0xA77B, 'M', 'ꝼ'),
+    (0xA77C, 'V'),
+    (0xA77D, 'M', 'ᵹ'),
+    (0xA77E, 'M', 'ꝿ'),
+    (0xA77F, 'V'),
+    ]
+
+def _seg_37() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0xA780, 'M', 'ꞁ'),
+    (0xA781, 'V'),
+    (0xA782, 'M', 'ꞃ'),
+    (0xA783, 'V'),
+    (0xA784, 'M', 'ꞅ'),
+    (0xA785, 'V'),
+    (0xA786, 'M', 'ꞇ'),
+    (0xA787, 'V'),
+    (0xA78B, 'M', 'ꞌ'),
+    (0xA78C, 'V'),
+    (0xA78D, 'M', 'ɥ'),
+    (0xA78E, 'V'),
+    (0xA790, 'M', 'ꞑ'),
+    (0xA791, 'V'),
+    (0xA792, 'M', 'ꞓ'),
+    (0xA793, 'V'),
+    (0xA796, 'M', 'ꞗ'),
+    (0xA797, 'V'),
+    (0xA798, 'M', 'ꞙ'),
+    (0xA799, 'V'),
+    (0xA79A, 'M', 'ꞛ'),
+    (0xA79B, 'V'),
+    (0xA79C, 'M', 'ꞝ'),
+    (0xA79D, 'V'),
+    (0xA79E, 'M', 'ꞟ'),
+    (0xA79F, 'V'),
+    (0xA7A0, 'M', 'ꞡ'),
+    (0xA7A1, 'V'),
+    (0xA7A2, 'M', 'ꞣ'),
+    (0xA7A3, 'V'),
+    (0xA7A4, 'M', 'ꞥ'),
+    (0xA7A5, 'V'),
+    (0xA7A6, 'M', 'ꞧ'),
+    (0xA7A7, 'V'),
+    (0xA7A8, 'M', 'ꞩ'),
+    (0xA7A9, 'V'),
+    (0xA7AA, 'M', 'ɦ'),
+    (0xA7AB, 'M', 'ɜ'),
+    (0xA7AC, 'M', 'ɡ'),
+    (0xA7AD, 'M', 'ɬ'),
+    (0xA7AE, 'M', 'ɪ'),
+    (0xA7AF, 'V'),
+    (0xA7B0, 'M', 'ʞ'),
+    (0xA7B1, 'M', 'ʇ'),
+    (0xA7B2, 'M', 'ʝ'),
+    (0xA7B3, 'M', 'ꭓ'),
+    (0xA7B4, 'M', 'ꞵ'),
+    (0xA7B5, 'V'),
+    (0xA7B6, 'M', 'ꞷ'),
+    (0xA7B7, 'V'),
+    (0xA7B8, 'M', 'ꞹ'),
+    (0xA7B9, 'V'),
+    (0xA7BA, 'M', 'ꞻ'),
+    (0xA7BB, 'V'),
+    (0xA7BC, 'M', 'ꞽ'),
+    (0xA7BD, 'V'),
+    (0xA7BE, 'M', 'ꞿ'),
+    (0xA7BF, 'V'),
+    (0xA7C0, 'M', 'ꟁ'),
+    (0xA7C1, 'V'),
+    (0xA7C2, 'M', 'ꟃ'),
+    (0xA7C3, 'V'),
+    (0xA7C4, 'M', 'ꞔ'),
+    (0xA7C5, 'M', 'ʂ'),
+    (0xA7C6, 'M', 'ᶎ'),
+    (0xA7C7, 'M', 'ꟈ'),
+    (0xA7C8, 'V'),
+    (0xA7C9, 'M', 'ꟊ'),
+    (0xA7CA, 'V'),
+    (0xA7CB, 'X'),
+    (0xA7D0, 'M', 'ꟑ'),
+    (0xA7D1, 'V'),
+    (0xA7D2, 'X'),
+    (0xA7D3, 'V'),
+    (0xA7D4, 'X'),
+    (0xA7D5, 'V'),
+    (0xA7D6, 'M', 'ꟗ'),
+    (0xA7D7, 'V'),
+    (0xA7D8, 'M', 'ꟙ'),
+    (0xA7D9, 'V'),
+    (0xA7DA, 'X'),
+    (0xA7F2, 'M', 'c'),
+    (0xA7F3, 'M', 'f'),
+    (0xA7F4, 'M', 'q'),
+    (0xA7F5, 'M', 'ꟶ'),
+    (0xA7F6, 'V'),
+    (0xA7F8, 'M', 'ħ'),
+    (0xA7F9, 'M', 'œ'),
+    (0xA7FA, 'V'),
+    (0xA82D, 'X'),
+    (0xA830, 'V'),
+    (0xA83A, 'X'),
+    (0xA840, 'V'),
+    (0xA878, 'X'),
+    (0xA880, 'V'),
+    (0xA8C6, 'X'),
+    (0xA8CE, 'V'),
+    (0xA8DA, 'X'),
+    (0xA8E0, 'V'),
+    (0xA954, 'X'),
+    ]
+
+def _seg_38() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0xA95F, 'V'),
+    (0xA97D, 'X'),
+    (0xA980, 'V'),
+    (0xA9CE, 'X'),
+    (0xA9CF, 'V'),
+    (0xA9DA, 'X'),
+    (0xA9DE, 'V'),
+    (0xA9FF, 'X'),
+    (0xAA00, 'V'),
+    (0xAA37, 'X'),
+    (0xAA40, 'V'),
+    (0xAA4E, 'X'),
+    (0xAA50, 'V'),
+    (0xAA5A, 'X'),
+    (0xAA5C, 'V'),
+    (0xAAC3, 'X'),
+    (0xAADB, 'V'),
+    (0xAAF7, 'X'),
+    (0xAB01, 'V'),
+    (0xAB07, 'X'),
+    (0xAB09, 'V'),
+    (0xAB0F, 'X'),
+    (0xAB11, 'V'),
+    (0xAB17, 'X'),
+    (0xAB20, 'V'),
+    (0xAB27, 'X'),
+    (0xAB28, 'V'),
+    (0xAB2F, 'X'),
+    (0xAB30, 'V'),
+    (0xAB5C, 'M', 'ꜧ'),
+    (0xAB5D, 'M', 'ꬷ'),
+    (0xAB5E, 'M', 'ɫ'),
+    (0xAB5F, 'M', 'ꭒ'),
+    (0xAB60, 'V'),
+    (0xAB69, 'M', 'ʍ'),
+    (0xAB6A, 'V'),
+    (0xAB6C, 'X'),
+    (0xAB70, 'M', 'Ꭰ'),
+    (0xAB71, 'M', 'Ꭱ'),
+    (0xAB72, 'M', 'Ꭲ'),
+    (0xAB73, 'M', 'Ꭳ'),
+    (0xAB74, 'M', 'Ꭴ'),
+    (0xAB75, 'M', 'Ꭵ'),
+    (0xAB76, 'M', 'Ꭶ'),
+    (0xAB77, 'M', 'Ꭷ'),
+    (0xAB78, 'M', 'Ꭸ'),
+    (0xAB79, 'M', 'Ꭹ'),
+    (0xAB7A, 'M', 'Ꭺ'),
+    (0xAB7B, 'M', 'Ꭻ'),
+    (0xAB7C, 'M', 'Ꭼ'),
+    (0xAB7D, 'M', 'Ꭽ'),
+    (0xAB7E, 'M', 'Ꭾ'),
+    (0xAB7F, 'M', 'Ꭿ'),
+    (0xAB80, 'M', 'Ꮀ'),
+    (0xAB81, 'M', 'Ꮁ'),
+    (0xAB82, 'M', 'Ꮂ'),
+    (0xAB83, 'M', 'Ꮃ'),
+    (0xAB84, 'M', 'Ꮄ'),
+    (0xAB85, 'M', 'Ꮅ'),
+    (0xAB86, 'M', 'Ꮆ'),
+    (0xAB87, 'M', 'Ꮇ'),
+    (0xAB88, 'M', 'Ꮈ'),
+    (0xAB89, 'M', 'Ꮉ'),
+    (0xAB8A, 'M', 'Ꮊ'),
+    (0xAB8B, 'M', 'Ꮋ'),
+    (0xAB8C, 'M', 'Ꮌ'),
+    (0xAB8D, 'M', 'Ꮍ'),
+    (0xAB8E, 'M', 'Ꮎ'),
+    (0xAB8F, 'M', 'Ꮏ'),
+    (0xAB90, 'M', 'Ꮐ'),
+    (0xAB91, 'M', 'Ꮑ'),
+    (0xAB92, 'M', 'Ꮒ'),
+    (0xAB93, 'M', 'Ꮓ'),
+    (0xAB94, 'M', 'Ꮔ'),
+    (0xAB95, 'M', 'Ꮕ'),
+    (0xAB96, 'M', 'Ꮖ'),
+    (0xAB97, 'M', 'Ꮗ'),
+    (0xAB98, 'M', 'Ꮘ'),
+    (0xAB99, 'M', 'Ꮙ'),
+    (0xAB9A, 'M', 'Ꮚ'),
+    (0xAB9B, 'M', 'Ꮛ'),
+    (0xAB9C, 'M', 'Ꮜ'),
+    (0xAB9D, 'M', 'Ꮝ'),
+    (0xAB9E, 'M', 'Ꮞ'),
+    (0xAB9F, 'M', 'Ꮟ'),
+    (0xABA0, 'M', 'Ꮠ'),
+    (0xABA1, 'M', 'Ꮡ'),
+    (0xABA2, 'M', 'Ꮢ'),
+    (0xABA3, 'M', 'Ꮣ'),
+    (0xABA4, 'M', 'Ꮤ'),
+    (0xABA5, 'M', 'Ꮥ'),
+    (0xABA6, 'M', 'Ꮦ'),
+    (0xABA7, 'M', 'Ꮧ'),
+    (0xABA8, 'M', 'Ꮨ'),
+    (0xABA9, 'M', 'Ꮩ'),
+    (0xABAA, 'M', 'Ꮪ'),
+    (0xABAB, 'M', 'Ꮫ'),
+    (0xABAC, 'M', 'Ꮬ'),
+    (0xABAD, 'M', 'Ꮭ'),
+    (0xABAE, 'M', 'Ꮮ'),
+    ]
+
+def _seg_39() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0xABAF, 'M', 'Ꮯ'),
+    (0xABB0, 'M', 'Ꮰ'),
+    (0xABB1, 'M', 'Ꮱ'),
+    (0xABB2, 'M', 'Ꮲ'),
+    (0xABB3, 'M', 'Ꮳ'),
+    (0xABB4, 'M', 'Ꮴ'),
+    (0xABB5, 'M', 'Ꮵ'),
+    (0xABB6, 'M', 'Ꮶ'),
+    (0xABB7, 'M', 'Ꮷ'),
+    (0xABB8, 'M', 'Ꮸ'),
+    (0xABB9, 'M', 'Ꮹ'),
+    (0xABBA, 'M', 'Ꮺ'),
+    (0xABBB, 'M', 'Ꮻ'),
+    (0xABBC, 'M', 'Ꮼ'),
+    (0xABBD, 'M', 'Ꮽ'),
+    (0xABBE, 'M', 'Ꮾ'),
+    (0xABBF, 'M', 'Ꮿ'),
+    (0xABC0, 'V'),
+    (0xABEE, 'X'),
+    (0xABF0, 'V'),
+    (0xABFA, 'X'),
+    (0xAC00, 'V'),
+    (0xD7A4, 'X'),
+    (0xD7B0, 'V'),
+    (0xD7C7, 'X'),
+    (0xD7CB, 'V'),
+    (0xD7FC, 'X'),
+    (0xF900, 'M', '豈'),
+    (0xF901, 'M', '更'),
+    (0xF902, 'M', '車'),
+    (0xF903, 'M', '賈'),
+    (0xF904, 'M', '滑'),
+    (0xF905, 'M', '串'),
+    (0xF906, 'M', '句'),
+    (0xF907, 'M', '龜'),
+    (0xF909, 'M', '契'),
+    (0xF90A, 'M', '金'),
+    (0xF90B, 'M', '喇'),
+    (0xF90C, 'M', '奈'),
+    (0xF90D, 'M', '懶'),
+    (0xF90E, 'M', '癩'),
+    (0xF90F, 'M', '羅'),
+    (0xF910, 'M', '蘿'),
+    (0xF911, 'M', '螺'),
+    (0xF912, 'M', '裸'),
+    (0xF913, 'M', '邏'),
+    (0xF914, 'M', '樂'),
+    (0xF915, 'M', '洛'),
+    (0xF916, 'M', '烙'),
+    (0xF917, 'M', '珞'),
+    (0xF918, 'M', '落'),
+    (0xF919, 'M', '酪'),
+    (0xF91A, 'M', '駱'),
+    (0xF91B, 'M', '亂'),
+    (0xF91C, 'M', '卵'),
+    (0xF91D, 'M', '欄'),
+    (0xF91E, 'M', '爛'),
+    (0xF91F, 'M', '蘭'),
+    (0xF920, 'M', '鸞'),
+    (0xF921, 'M', '嵐'),
+    (0xF922, 'M', '濫'),
+    (0xF923, 'M', '藍'),
+    (0xF924, 'M', '襤'),
+    (0xF925, 'M', '拉'),
+    (0xF926, 'M', '臘'),
+    (0xF927, 'M', '蠟'),
+    (0xF928, 'M', '廊'),
+    (0xF929, 'M', '朗'),
+    (0xF92A, 'M', '浪'),
+    (0xF92B, 'M', '狼'),
+    (0xF92C, 'M', '郎'),
+    (0xF92D, 'M', '來'),
+    (0xF92E, 'M', '冷'),
+    (0xF92F, 'M', '勞'),
+    (0xF930, 'M', '擄'),
+    (0xF931, 'M', '櫓'),
+    (0xF932, 'M', '爐'),
+    (0xF933, 'M', '盧'),
+    (0xF934, 'M', '老'),
+    (0xF935, 'M', '蘆'),
+    (0xF936, 'M', '虜'),
+    (0xF937, 'M', '路'),
+    (0xF938, 'M', '露'),
+    (0xF939, 'M', '魯'),
+    (0xF93A, 'M', '鷺'),
+    (0xF93B, 'M', '碌'),
+    (0xF93C, 'M', '祿'),
+    (0xF93D, 'M', '綠'),
+    (0xF93E, 'M', '菉'),
+    (0xF93F, 'M', '錄'),
+    (0xF940, 'M', '鹿'),
+    (0xF941, 'M', '論'),
+    (0xF942, 'M', '壟'),
+    (0xF943, 'M', '弄'),
+    (0xF944, 'M', '籠'),
+    (0xF945, 'M', '聾'),
+    (0xF946, 'M', '牢'),
+    (0xF947, 'M', '磊'),
+    (0xF948, 'M', '賂'),
+    (0xF949, 'M', '雷'),
+    ]
+
+def _seg_40() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0xF94A, 'M', '壘'),
+    (0xF94B, 'M', '屢'),
+    (0xF94C, 'M', '樓'),
+    (0xF94D, 'M', '淚'),
+    (0xF94E, 'M', '漏'),
+    (0xF94F, 'M', '累'),
+    (0xF950, 'M', '縷'),
+    (0xF951, 'M', '陋'),
+    (0xF952, 'M', '勒'),
+    (0xF953, 'M', '肋'),
+    (0xF954, 'M', '凜'),
+    (0xF955, 'M', '凌'),
+    (0xF956, 'M', '稜'),
+    (0xF957, 'M', '綾'),
+    (0xF958, 'M', '菱'),
+    (0xF959, 'M', '陵'),
+    (0xF95A, 'M', '讀'),
+    (0xF95B, 'M', '拏'),
+    (0xF95C, 'M', '樂'),
+    (0xF95D, 'M', '諾'),
+    (0xF95E, 'M', '丹'),
+    (0xF95F, 'M', '寧'),
+    (0xF960, 'M', '怒'),
+    (0xF961, 'M', '率'),
+    (0xF962, 'M', '異'),
+    (0xF963, 'M', '北'),
+    (0xF964, 'M', '磻'),
+    (0xF965, 'M', '便'),
+    (0xF966, 'M', '復'),
+    (0xF967, 'M', '不'),
+    (0xF968, 'M', '泌'),
+    (0xF969, 'M', '數'),
+    (0xF96A, 'M', '索'),
+    (0xF96B, 'M', '參'),
+    (0xF96C, 'M', '塞'),
+    (0xF96D, 'M', '省'),
+    (0xF96E, 'M', '葉'),
+    (0xF96F, 'M', '說'),
+    (0xF970, 'M', '殺'),
+    (0xF971, 'M', '辰'),
+    (0xF972, 'M', '沈'),
+    (0xF973, 'M', '拾'),
+    (0xF974, 'M', '若'),
+    (0xF975, 'M', '掠'),
+    (0xF976, 'M', '略'),
+    (0xF977, 'M', '亮'),
+    (0xF978, 'M', '兩'),
+    (0xF979, 'M', '凉'),
+    (0xF97A, 'M', '梁'),
+    (0xF97B, 'M', '糧'),
+    (0xF97C, 'M', '良'),
+    (0xF97D, 'M', '諒'),
+    (0xF97E, 'M', '量'),
+    (0xF97F, 'M', '勵'),
+    (0xF980, 'M', '呂'),
+    (0xF981, 'M', '女'),
+    (0xF982, 'M', '廬'),
+    (0xF983, 'M', '旅'),
+    (0xF984, 'M', '濾'),
+    (0xF985, 'M', '礪'),
+    (0xF986, 'M', '閭'),
+    (0xF987, 'M', '驪'),
+    (0xF988, 'M', '麗'),
+    (0xF989, 'M', '黎'),
+    (0xF98A, 'M', '力'),
+    (0xF98B, 'M', '曆'),
+    (0xF98C, 'M', '歷'),
+    (0xF98D, 'M', '轢'),
+    (0xF98E, 'M', '年'),
+    (0xF98F, 'M', '憐'),
+    (0xF990, 'M', '戀'),
+    (0xF991, 'M', '撚'),
+    (0xF992, 'M', '漣'),
+    (0xF993, 'M', '煉'),
+    (0xF994, 'M', '璉'),
+    (0xF995, 'M', '秊'),
+    (0xF996, 'M', '練'),
+    (0xF997, 'M', '聯'),
+    (0xF998, 'M', '輦'),
+    (0xF999, 'M', '蓮'),
+    (0xF99A, 'M', '連'),
+    (0xF99B, 'M', '鍊'),
+    (0xF99C, 'M', '列'),
+    (0xF99D, 'M', '劣'),
+    (0xF99E, 'M', '咽'),
+    (0xF99F, 'M', '烈'),
+    (0xF9A0, 'M', '裂'),
+    (0xF9A1, 'M', '說'),
+    (0xF9A2, 'M', '廉'),
+    (0xF9A3, 'M', '念'),
+    (0xF9A4, 'M', '捻'),
+    (0xF9A5, 'M', '殮'),
+    (0xF9A6, 'M', '簾'),
+    (0xF9A7, 'M', '獵'),
+    (0xF9A8, 'M', '令'),
+    (0xF9A9, 'M', '囹'),
+    (0xF9AA, 'M', '寧'),
+    (0xF9AB, 'M', '嶺'),
+    (0xF9AC, 'M', '怜'),
+    (0xF9AD, 'M', '玲'),
+    ]
+
+def _seg_41() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0xF9AE, 'M', '瑩'),
+    (0xF9AF, 'M', '羚'),
+    (0xF9B0, 'M', '聆'),
+    (0xF9B1, 'M', '鈴'),
+    (0xF9B2, 'M', '零'),
+    (0xF9B3, 'M', '靈'),
+    (0xF9B4, 'M', '領'),
+    (0xF9B5, 'M', '例'),
+    (0xF9B6, 'M', '禮'),
+    (0xF9B7, 'M', '醴'),
+    (0xF9B8, 'M', '隸'),
+    (0xF9B9, 'M', '惡'),
+    (0xF9BA, 'M', '了'),
+    (0xF9BB, 'M', '僚'),
+    (0xF9BC, 'M', '寮'),
+    (0xF9BD, 'M', '尿'),
+    (0xF9BE, 'M', '料'),
+    (0xF9BF, 'M', '樂'),
+    (0xF9C0, 'M', '燎'),
+    (0xF9C1, 'M', '療'),
+    (0xF9C2, 'M', '蓼'),
+    (0xF9C3, 'M', '遼'),
+    (0xF9C4, 'M', '龍'),
+    (0xF9C5, 'M', '暈'),
+    (0xF9C6, 'M', '阮'),
+    (0xF9C7, 'M', '劉'),
+    (0xF9C8, 'M', '杻'),
+    (0xF9C9, 'M', '柳'),
+    (0xF9CA, 'M', '流'),
+    (0xF9CB, 'M', '溜'),
+    (0xF9CC, 'M', '琉'),
+    (0xF9CD, 'M', '留'),
+    (0xF9CE, 'M', '硫'),
+    (0xF9CF, 'M', '紐'),
+    (0xF9D0, 'M', '類'),
+    (0xF9D1, 'M', '六'),
+    (0xF9D2, 'M', '戮'),
+    (0xF9D3, 'M', '陸'),
+    (0xF9D4, 'M', '倫'),
+    (0xF9D5, 'M', '崙'),
+    (0xF9D6, 'M', '淪'),
+    (0xF9D7, 'M', '輪'),
+    (0xF9D8, 'M', '律'),
+    (0xF9D9, 'M', '慄'),
+    (0xF9DA, 'M', '栗'),
+    (0xF9DB, 'M', '率'),
+    (0xF9DC, 'M', '隆'),
+    (0xF9DD, 'M', '利'),
+    (0xF9DE, 'M', '吏'),
+    (0xF9DF, 'M', '履'),
+    (0xF9E0, 'M', '易'),
+    (0xF9E1, 'M', '李'),
+    (0xF9E2, 'M', '梨'),
+    (0xF9E3, 'M', '泥'),
+    (0xF9E4, 'M', '理'),
+    (0xF9E5, 'M', '痢'),
+    (0xF9E6, 'M', '罹'),
+    (0xF9E7, 'M', '裏'),
+    (0xF9E8, 'M', '裡'),
+    (0xF9E9, 'M', '里'),
+    (0xF9EA, 'M', '離'),
+    (0xF9EB, 'M', '匿'),
+    (0xF9EC, 'M', '溺'),
+    (0xF9ED, 'M', '吝'),
+    (0xF9EE, 'M', '燐'),
+    (0xF9EF, 'M', '璘'),
+    (0xF9F0, 'M', '藺'),
+    (0xF9F1, 'M', '隣'),
+    (0xF9F2, 'M', '鱗'),
+    (0xF9F3, 'M', '麟'),
+    (0xF9F4, 'M', '林'),
+    (0xF9F5, 'M', '淋'),
+    (0xF9F6, 'M', '臨'),
+    (0xF9F7, 'M', '立'),
+    (0xF9F8, 'M', '笠'),
+    (0xF9F9, 'M', '粒'),
+    (0xF9FA, 'M', '狀'),
+    (0xF9FB, 'M', '炙'),
+    (0xF9FC, 'M', '識'),
+    (0xF9FD, 'M', '什'),
+    (0xF9FE, 'M', '茶'),
+    (0xF9FF, 'M', '刺'),
+    (0xFA00, 'M', '切'),
+    (0xFA01, 'M', '度'),
+    (0xFA02, 'M', '拓'),
+    (0xFA03, 'M', '糖'),
+    (0xFA04, 'M', '宅'),
+    (0xFA05, 'M', '洞'),
+    (0xFA06, 'M', '暴'),
+    (0xFA07, 'M', '輻'),
+    (0xFA08, 'M', '行'),
+    (0xFA09, 'M', '降'),
+    (0xFA0A, 'M', '見'),
+    (0xFA0B, 'M', '廓'),
+    (0xFA0C, 'M', '兀'),
+    (0xFA0D, 'M', '嗀'),
+    (0xFA0E, 'V'),
+    (0xFA10, 'M', '塚'),
+    (0xFA11, 'V'),
+    (0xFA12, 'M', '晴'),
+    ]
+
+def _seg_42() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0xFA13, 'V'),
+    (0xFA15, 'M', '凞'),
+    (0xFA16, 'M', '猪'),
+    (0xFA17, 'M', '益'),
+    (0xFA18, 'M', '礼'),
+    (0xFA19, 'M', '神'),
+    (0xFA1A, 'M', '祥'),
+    (0xFA1B, 'M', '福'),
+    (0xFA1C, 'M', '靖'),
+    (0xFA1D, 'M', '精'),
+    (0xFA1E, 'M', '羽'),
+    (0xFA1F, 'V'),
+    (0xFA20, 'M', '蘒'),
+    (0xFA21, 'V'),
+    (0xFA22, 'M', '諸'),
+    (0xFA23, 'V'),
+    (0xFA25, 'M', '逸'),
+    (0xFA26, 'M', '都'),
+    (0xFA27, 'V'),
+    (0xFA2A, 'M', '飯'),
+    (0xFA2B, 'M', '飼'),
+    (0xFA2C, 'M', '館'),
+    (0xFA2D, 'M', '鶴'),
+    (0xFA2E, 'M', '郞'),
+    (0xFA2F, 'M', '隷'),
+    (0xFA30, 'M', '侮'),
+    (0xFA31, 'M', '僧'),
+    (0xFA32, 'M', '免'),
+    (0xFA33, 'M', '勉'),
+    (0xFA34, 'M', '勤'),
+    (0xFA35, 'M', '卑'),
+    (0xFA36, 'M', '喝'),
+    (0xFA37, 'M', '嘆'),
+    (0xFA38, 'M', '器'),
+    (0xFA39, 'M', '塀'),
+    (0xFA3A, 'M', '墨'),
+    (0xFA3B, 'M', '層'),
+    (0xFA3C, 'M', '屮'),
+    (0xFA3D, 'M', '悔'),
+    (0xFA3E, 'M', '慨'),
+    (0xFA3F, 'M', '憎'),
+    (0xFA40, 'M', '懲'),
+    (0xFA41, 'M', '敏'),
+    (0xFA42, 'M', '既'),
+    (0xFA43, 'M', '暑'),
+    (0xFA44, 'M', '梅'),
+    (0xFA45, 'M', '海'),
+    (0xFA46, 'M', '渚'),
+    (0xFA47, 'M', '漢'),
+    (0xFA48, 'M', '煮'),
+    (0xFA49, 'M', '爫'),
+    (0xFA4A, 'M', '琢'),
+    (0xFA4B, 'M', '碑'),
+    (0xFA4C, 'M', '社'),
+    (0xFA4D, 'M', '祉'),
+    (0xFA4E, 'M', '祈'),
+    (0xFA4F, 'M', '祐'),
+    (0xFA50, 'M', '祖'),
+    (0xFA51, 'M', '祝'),
+    (0xFA52, 'M', '禍'),
+    (0xFA53, 'M', '禎'),
+    (0xFA54, 'M', '穀'),
+    (0xFA55, 'M', '突'),
+    (0xFA56, 'M', '節'),
+    (0xFA57, 'M', '練'),
+    (0xFA58, 'M', '縉'),
+    (0xFA59, 'M', '繁'),
+    (0xFA5A, 'M', '署'),
+    (0xFA5B, 'M', '者'),
+    (0xFA5C, 'M', '臭'),
+    (0xFA5D, 'M', '艹'),
+    (0xFA5F, 'M', '著'),
+    (0xFA60, 'M', '褐'),
+    (0xFA61, 'M', '視'),
+    (0xFA62, 'M', '謁'),
+    (0xFA63, 'M', '謹'),
+    (0xFA64, 'M', '賓'),
+    (0xFA65, 'M', '贈'),
+    (0xFA66, 'M', '辶'),
+    (0xFA67, 'M', '逸'),
+    (0xFA68, 'M', '難'),
+    (0xFA69, 'M', '響'),
+    (0xFA6A, 'M', '頻'),
+    (0xFA6B, 'M', '恵'),
+    (0xFA6C, 'M', '𤋮'),
+    (0xFA6D, 'M', '舘'),
+    (0xFA6E, 'X'),
+    (0xFA70, 'M', '並'),
+    (0xFA71, 'M', '况'),
+    (0xFA72, 'M', '全'),
+    (0xFA73, 'M', '侀'),
+    (0xFA74, 'M', '充'),
+    (0xFA75, 'M', '冀'),
+    (0xFA76, 'M', '勇'),
+    (0xFA77, 'M', '勺'),
+    (0xFA78, 'M', '喝'),
+    (0xFA79, 'M', '啕'),
+    (0xFA7A, 'M', '喙'),
+    (0xFA7B, 'M', '嗢'),
+    (0xFA7C, 'M', '塚'),
+    ]
+
+def _seg_43() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0xFA7D, 'M', '墳'),
+    (0xFA7E, 'M', '奄'),
+    (0xFA7F, 'M', '奔'),
+    (0xFA80, 'M', '婢'),
+    (0xFA81, 'M', '嬨'),
+    (0xFA82, 'M', '廒'),
+    (0xFA83, 'M', '廙'),
+    (0xFA84, 'M', '彩'),
+    (0xFA85, 'M', '徭'),
+    (0xFA86, 'M', '惘'),
+    (0xFA87, 'M', '慎'),
+    (0xFA88, 'M', '愈'),
+    (0xFA89, 'M', '憎'),
+    (0xFA8A, 'M', '慠'),
+    (0xFA8B, 'M', '懲'),
+    (0xFA8C, 'M', '戴'),
+    (0xFA8D, 'M', '揄'),
+    (0xFA8E, 'M', '搜'),
+    (0xFA8F, 'M', '摒'),
+    (0xFA90, 'M', '敖'),
+    (0xFA91, 'M', '晴'),
+    (0xFA92, 'M', '朗'),
+    (0xFA93, 'M', '望'),
+    (0xFA94, 'M', '杖'),
+    (0xFA95, 'M', '歹'),
+    (0xFA96, 'M', '殺'),
+    (0xFA97, 'M', '流'),
+    (0xFA98, 'M', '滛'),
+    (0xFA99, 'M', '滋'),
+    (0xFA9A, 'M', '漢'),
+    (0xFA9B, 'M', '瀞'),
+    (0xFA9C, 'M', '煮'),
+    (0xFA9D, 'M', '瞧'),
+    (0xFA9E, 'M', '爵'),
+    (0xFA9F, 'M', '犯'),
+    (0xFAA0, 'M', '猪'),
+    (0xFAA1, 'M', '瑱'),
+    (0xFAA2, 'M', '甆'),
+    (0xFAA3, 'M', '画'),
+    (0xFAA4, 'M', '瘝'),
+    (0xFAA5, 'M', '瘟'),
+    (0xFAA6, 'M', '益'),
+    (0xFAA7, 'M', '盛'),
+    (0xFAA8, 'M', '直'),
+    (0xFAA9, 'M', '睊'),
+    (0xFAAA, 'M', '着'),
+    (0xFAAB, 'M', '磌'),
+    (0xFAAC, 'M', '窱'),
+    (0xFAAD, 'M', '節'),
+    (0xFAAE, 'M', '类'),
+    (0xFAAF, 'M', '絛'),
+    (0xFAB0, 'M', '練'),
+    (0xFAB1, 'M', '缾'),
+    (0xFAB2, 'M', '者'),
+    (0xFAB3, 'M', '荒'),
+    (0xFAB4, 'M', '華'),
+    (0xFAB5, 'M', '蝹'),
+    (0xFAB6, 'M', '襁'),
+    (0xFAB7, 'M', '覆'),
+    (0xFAB8, 'M', '視'),
+    (0xFAB9, 'M', '調'),
+    (0xFABA, 'M', '諸'),
+    (0xFABB, 'M', '請'),
+    (0xFABC, 'M', '謁'),
+    (0xFABD, 'M', '諾'),
+    (0xFABE, 'M', '諭'),
+    (0xFABF, 'M', '謹'),
+    (0xFAC0, 'M', '變'),
+    (0xFAC1, 'M', '贈'),
+    (0xFAC2, 'M', '輸'),
+    (0xFAC3, 'M', '遲'),
+    (0xFAC4, 'M', '醙'),
+    (0xFAC5, 'M', '鉶'),
+    (0xFAC6, 'M', '陼'),
+    (0xFAC7, 'M', '難'),
+    (0xFAC8, 'M', '靖'),
+    (0xFAC9, 'M', '韛'),
+    (0xFACA, 'M', '響'),
+    (0xFACB, 'M', '頋'),
+    (0xFACC, 'M', '頻'),
+    (0xFACD, 'M', '鬒'),
+    (0xFACE, 'M', '龜'),
+    (0xFACF, 'M', '𢡊'),
+    (0xFAD0, 'M', '𢡄'),
+    (0xFAD1, 'M', '𣏕'),
+    (0xFAD2, 'M', '㮝'),
+    (0xFAD3, 'M', '䀘'),
+    (0xFAD4, 'M', '䀹'),
+    (0xFAD5, 'M', '𥉉'),
+    (0xFAD6, 'M', '𥳐'),
+    (0xFAD7, 'M', '𧻓'),
+    (0xFAD8, 'M', '齃'),
+    (0xFAD9, 'M', '龎'),
+    (0xFADA, 'X'),
+    (0xFB00, 'M', 'ff'),
+    (0xFB01, 'M', 'fi'),
+    (0xFB02, 'M', 'fl'),
+    (0xFB03, 'M', 'ffi'),
+    (0xFB04, 'M', 'ffl'),
+    (0xFB05, 'M', 'st'),
+    ]
+
+def _seg_44() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0xFB07, 'X'),
+    (0xFB13, 'M', 'մն'),
+    (0xFB14, 'M', 'մե'),
+    (0xFB15, 'M', 'մի'),
+    (0xFB16, 'M', 'վն'),
+    (0xFB17, 'M', 'մխ'),
+    (0xFB18, 'X'),
+    (0xFB1D, 'M', 'יִ'),
+    (0xFB1E, 'V'),
+    (0xFB1F, 'M', 'ײַ'),
+    (0xFB20, 'M', 'ע'),
+    (0xFB21, 'M', 'א'),
+    (0xFB22, 'M', 'ד'),
+    (0xFB23, 'M', 'ה'),
+    (0xFB24, 'M', 'כ'),
+    (0xFB25, 'M', 'ל'),
+    (0xFB26, 'M', 'ם'),
+    (0xFB27, 'M', 'ר'),
+    (0xFB28, 'M', 'ת'),
+    (0xFB29, '3', '+'),
+    (0xFB2A, 'M', 'שׁ'),
+    (0xFB2B, 'M', 'שׂ'),
+    (0xFB2C, 'M', 'שּׁ'),
+    (0xFB2D, 'M', 'שּׂ'),
+    (0xFB2E, 'M', 'אַ'),
+    (0xFB2F, 'M', 'אָ'),
+    (0xFB30, 'M', 'אּ'),
+    (0xFB31, 'M', 'בּ'),
+    (0xFB32, 'M', 'גּ'),
+    (0xFB33, 'M', 'דּ'),
+    (0xFB34, 'M', 'הּ'),
+    (0xFB35, 'M', 'וּ'),
+    (0xFB36, 'M', 'זּ'),
+    (0xFB37, 'X'),
+    (0xFB38, 'M', 'טּ'),
+    (0xFB39, 'M', 'יּ'),
+    (0xFB3A, 'M', 'ךּ'),
+    (0xFB3B, 'M', 'כּ'),
+    (0xFB3C, 'M', 'לּ'),
+    (0xFB3D, 'X'),
+    (0xFB3E, 'M', 'מּ'),
+    (0xFB3F, 'X'),
+    (0xFB40, 'M', 'נּ'),
+    (0xFB41, 'M', 'סּ'),
+    (0xFB42, 'X'),
+    (0xFB43, 'M', 'ףּ'),
+    (0xFB44, 'M', 'פּ'),
+    (0xFB45, 'X'),
+    (0xFB46, 'M', 'צּ'),
+    (0xFB47, 'M', 'קּ'),
+    (0xFB48, 'M', 'רּ'),
+    (0xFB49, 'M', 'שּ'),
+    (0xFB4A, 'M', 'תּ'),
+    (0xFB4B, 'M', 'וֹ'),
+    (0xFB4C, 'M', 'בֿ'),
+    (0xFB4D, 'M', 'כֿ'),
+    (0xFB4E, 'M', 'פֿ'),
+    (0xFB4F, 'M', 'אל'),
+    (0xFB50, 'M', 'ٱ'),
+    (0xFB52, 'M', 'ٻ'),
+    (0xFB56, 'M', 'پ'),
+    (0xFB5A, 'M', 'ڀ'),
+    (0xFB5E, 'M', 'ٺ'),
+    (0xFB62, 'M', 'ٿ'),
+    (0xFB66, 'M', 'ٹ'),
+    (0xFB6A, 'M', 'ڤ'),
+    (0xFB6E, 'M', 'ڦ'),
+    (0xFB72, 'M', 'ڄ'),
+    (0xFB76, 'M', 'ڃ'),
+    (0xFB7A, 'M', 'چ'),
+    (0xFB7E, 'M', 'ڇ'),
+    (0xFB82, 'M', 'ڍ'),
+    (0xFB84, 'M', 'ڌ'),
+    (0xFB86, 'M', 'ڎ'),
+    (0xFB88, 'M', 'ڈ'),
+    (0xFB8A, 'M', 'ژ'),
+    (0xFB8C, 'M', 'ڑ'),
+    (0xFB8E, 'M', 'ک'),
+    (0xFB92, 'M', 'گ'),
+    (0xFB96, 'M', 'ڳ'),
+    (0xFB9A, 'M', 'ڱ'),
+    (0xFB9E, 'M', 'ں'),
+    (0xFBA0, 'M', 'ڻ'),
+    (0xFBA4, 'M', 'ۀ'),
+    (0xFBA6, 'M', 'ہ'),
+    (0xFBAA, 'M', 'ھ'),
+    (0xFBAE, 'M', 'ے'),
+    (0xFBB0, 'M', 'ۓ'),
+    (0xFBB2, 'V'),
+    (0xFBC3, 'X'),
+    (0xFBD3, 'M', 'ڭ'),
+    (0xFBD7, 'M', 'ۇ'),
+    (0xFBD9, 'M', 'ۆ'),
+    (0xFBDB, 'M', 'ۈ'),
+    (0xFBDD, 'M', 'ۇٴ'),
+    (0xFBDE, 'M', 'ۋ'),
+    (0xFBE0, 'M', 'ۅ'),
+    (0xFBE2, 'M', 'ۉ'),
+    (0xFBE4, 'M', 'ې'),
+    (0xFBE8, 'M', 'ى'),
+    ]
+
+def _seg_45() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0xFBEA, 'M', 'ئا'),
+    (0xFBEC, 'M', 'ئە'),
+    (0xFBEE, 'M', 'ئو'),
+    (0xFBF0, 'M', 'ئۇ'),
+    (0xFBF2, 'M', 'ئۆ'),
+    (0xFBF4, 'M', 'ئۈ'),
+    (0xFBF6, 'M', 'ئې'),
+    (0xFBF9, 'M', 'ئى'),
+    (0xFBFC, 'M', 'ی'),
+    (0xFC00, 'M', 'ئج'),
+    (0xFC01, 'M', 'ئح'),
+    (0xFC02, 'M', 'ئم'),
+    (0xFC03, 'M', 'ئى'),
+    (0xFC04, 'M', 'ئي'),
+    (0xFC05, 'M', 'بج'),
+    (0xFC06, 'M', 'بح'),
+    (0xFC07, 'M', 'بخ'),
+    (0xFC08, 'M', 'بم'),
+    (0xFC09, 'M', 'بى'),
+    (0xFC0A, 'M', 'بي'),
+    (0xFC0B, 'M', 'تج'),
+    (0xFC0C, 'M', 'تح'),
+    (0xFC0D, 'M', 'تخ'),
+    (0xFC0E, 'M', 'تم'),
+    (0xFC0F, 'M', 'تى'),
+    (0xFC10, 'M', 'تي'),
+    (0xFC11, 'M', 'ثج'),
+    (0xFC12, 'M', 'ثم'),
+    (0xFC13, 'M', 'ثى'),
+    (0xFC14, 'M', 'ثي'),
+    (0xFC15, 'M', 'جح'),
+    (0xFC16, 'M', 'جم'),
+    (0xFC17, 'M', 'حج'),
+    (0xFC18, 'M', 'حم'),
+    (0xFC19, 'M', 'خج'),
+    (0xFC1A, 'M', 'خح'),
+    (0xFC1B, 'M', 'خم'),
+    (0xFC1C, 'M', 'سج'),
+    (0xFC1D, 'M', 'سح'),
+    (0xFC1E, 'M', 'سخ'),
+    (0xFC1F, 'M', 'سم'),
+    (0xFC20, 'M', 'صح'),
+    (0xFC21, 'M', 'صم'),
+    (0xFC22, 'M', 'ضج'),
+    (0xFC23, 'M', 'ضح'),
+    (0xFC24, 'M', 'ضخ'),
+    (0xFC25, 'M', 'ضم'),
+    (0xFC26, 'M', 'طح'),
+    (0xFC27, 'M', 'طم'),
+    (0xFC28, 'M', 'ظم'),
+    (0xFC29, 'M', 'عج'),
+    (0xFC2A, 'M', 'عم'),
+    (0xFC2B, 'M', 'غج'),
+    (0xFC2C, 'M', 'غم'),
+    (0xFC2D, 'M', 'فج'),
+    (0xFC2E, 'M', 'فح'),
+    (0xFC2F, 'M', 'فخ'),
+    (0xFC30, 'M', 'فم'),
+    (0xFC31, 'M', 'فى'),
+    (0xFC32, 'M', 'في'),
+    (0xFC33, 'M', 'قح'),
+    (0xFC34, 'M', 'قم'),
+    (0xFC35, 'M', 'قى'),
+    (0xFC36, 'M', 'قي'),
+    (0xFC37, 'M', 'كا'),
+    (0xFC38, 'M', 'كج'),
+    (0xFC39, 'M', 'كح'),
+    (0xFC3A, 'M', 'كخ'),
+    (0xFC3B, 'M', 'كل'),
+    (0xFC3C, 'M', 'كم'),
+    (0xFC3D, 'M', 'كى'),
+    (0xFC3E, 'M', 'كي'),
+    (0xFC3F, 'M', 'لج'),
+    (0xFC40, 'M', 'لح'),
+    (0xFC41, 'M', 'لخ'),
+    (0xFC42, 'M', 'لم'),
+    (0xFC43, 'M', 'لى'),
+    (0xFC44, 'M', 'لي'),
+    (0xFC45, 'M', 'مج'),
+    (0xFC46, 'M', 'مح'),
+    (0xFC47, 'M', 'مخ'),
+    (0xFC48, 'M', 'مم'),
+    (0xFC49, 'M', 'مى'),
+    (0xFC4A, 'M', 'مي'),
+    (0xFC4B, 'M', 'نج'),
+    (0xFC4C, 'M', 'نح'),
+    (0xFC4D, 'M', 'نخ'),
+    (0xFC4E, 'M', 'نم'),
+    (0xFC4F, 'M', 'نى'),
+    (0xFC50, 'M', 'ني'),
+    (0xFC51, 'M', 'هج'),
+    (0xFC52, 'M', 'هم'),
+    (0xFC53, 'M', 'هى'),
+    (0xFC54, 'M', 'هي'),
+    (0xFC55, 'M', 'يج'),
+    (0xFC56, 'M', 'يح'),
+    (0xFC57, 'M', 'يخ'),
+    (0xFC58, 'M', 'يم'),
+    (0xFC59, 'M', 'يى'),
+    (0xFC5A, 'M', 'يي'),
+    ]
+
+def _seg_46() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0xFC5B, 'M', 'ذٰ'),
+    (0xFC5C, 'M', 'رٰ'),
+    (0xFC5D, 'M', 'ىٰ'),
+    (0xFC5E, '3', ' ٌّ'),
+    (0xFC5F, '3', ' ٍّ'),
+    (0xFC60, '3', ' َّ'),
+    (0xFC61, '3', ' ُّ'),
+    (0xFC62, '3', ' ِّ'),
+    (0xFC63, '3', ' ّٰ'),
+    (0xFC64, 'M', 'ئر'),
+    (0xFC65, 'M', 'ئز'),
+    (0xFC66, 'M', 'ئم'),
+    (0xFC67, 'M', 'ئن'),
+    (0xFC68, 'M', 'ئى'),
+    (0xFC69, 'M', 'ئي'),
+    (0xFC6A, 'M', 'بر'),
+    (0xFC6B, 'M', 'بز'),
+    (0xFC6C, 'M', 'بم'),
+    (0xFC6D, 'M', 'بن'),
+    (0xFC6E, 'M', 'بى'),
+    (0xFC6F, 'M', 'بي'),
+    (0xFC70, 'M', 'تر'),
+    (0xFC71, 'M', 'تز'),
+    (0xFC72, 'M', 'تم'),
+    (0xFC73, 'M', 'تن'),
+    (0xFC74, 'M', 'تى'),
+    (0xFC75, 'M', 'تي'),
+    (0xFC76, 'M', 'ثر'),
+    (0xFC77, 'M', 'ثز'),
+    (0xFC78, 'M', 'ثم'),
+    (0xFC79, 'M', 'ثن'),
+    (0xFC7A, 'M', 'ثى'),
+    (0xFC7B, 'M', 'ثي'),
+    (0xFC7C, 'M', 'فى'),
+    (0xFC7D, 'M', 'في'),
+    (0xFC7E, 'M', 'قى'),
+    (0xFC7F, 'M', 'قي'),
+    (0xFC80, 'M', 'كا'),
+    (0xFC81, 'M', 'كل'),
+    (0xFC82, 'M', 'كم'),
+    (0xFC83, 'M', 'كى'),
+    (0xFC84, 'M', 'كي'),
+    (0xFC85, 'M', 'لم'),
+    (0xFC86, 'M', 'لى'),
+    (0xFC87, 'M', 'لي'),
+    (0xFC88, 'M', 'ما'),
+    (0xFC89, 'M', 'مم'),
+    (0xFC8A, 'M', 'نر'),
+    (0xFC8B, 'M', 'نز'),
+    (0xFC8C, 'M', 'نم'),
+    (0xFC8D, 'M', 'نن'),
+    (0xFC8E, 'M', 'نى'),
+    (0xFC8F, 'M', 'ني'),
+    (0xFC90, 'M', 'ىٰ'),
+    (0xFC91, 'M', 'ير'),
+    (0xFC92, 'M', 'يز'),
+    (0xFC93, 'M', 'يم'),
+    (0xFC94, 'M', 'ين'),
+    (0xFC95, 'M', 'يى'),
+    (0xFC96, 'M', 'يي'),
+    (0xFC97, 'M', 'ئج'),
+    (0xFC98, 'M', 'ئح'),
+    (0xFC99, 'M', 'ئخ'),
+    (0xFC9A, 'M', 'ئم'),
+    (0xFC9B, 'M', 'ئه'),
+    (0xFC9C, 'M', 'بج'),
+    (0xFC9D, 'M', 'بح'),
+    (0xFC9E, 'M', 'بخ'),
+    (0xFC9F, 'M', 'بم'),
+    (0xFCA0, 'M', 'به'),
+    (0xFCA1, 'M', 'تج'),
+    (0xFCA2, 'M', 'تح'),
+    (0xFCA3, 'M', 'تخ'),
+    (0xFCA4, 'M', 'تم'),
+    (0xFCA5, 'M', 'ته'),
+    (0xFCA6, 'M', 'ثم'),
+    (0xFCA7, 'M', 'جح'),
+    (0xFCA8, 'M', 'جم'),
+    (0xFCA9, 'M', 'حج'),
+    (0xFCAA, 'M', 'حم'),
+    (0xFCAB, 'M', 'خج'),
+    (0xFCAC, 'M', 'خم'),
+    (0xFCAD, 'M', 'سج'),
+    (0xFCAE, 'M', 'سح'),
+    (0xFCAF, 'M', 'سخ'),
+    (0xFCB0, 'M', 'سم'),
+    (0xFCB1, 'M', 'صح'),
+    (0xFCB2, 'M', 'صخ'),
+    (0xFCB3, 'M', 'صم'),
+    (0xFCB4, 'M', 'ضج'),
+    (0xFCB5, 'M', 'ضح'),
+    (0xFCB6, 'M', 'ضخ'),
+    (0xFCB7, 'M', 'ضم'),
+    (0xFCB8, 'M', 'طح'),
+    (0xFCB9, 'M', 'ظم'),
+    (0xFCBA, 'M', 'عج'),
+    (0xFCBB, 'M', 'عم'),
+    (0xFCBC, 'M', 'غج'),
+    (0xFCBD, 'M', 'غم'),
+    (0xFCBE, 'M', 'فج'),
+    ]
+
+def _seg_47() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0xFCBF, 'M', 'فح'),
+    (0xFCC0, 'M', 'فخ'),
+    (0xFCC1, 'M', 'فم'),
+    (0xFCC2, 'M', 'قح'),
+    (0xFCC3, 'M', 'قم'),
+    (0xFCC4, 'M', 'كج'),
+    (0xFCC5, 'M', 'كح'),
+    (0xFCC6, 'M', 'كخ'),
+    (0xFCC7, 'M', 'كل'),
+    (0xFCC8, 'M', 'كم'),
+    (0xFCC9, 'M', 'لج'),
+    (0xFCCA, 'M', 'لح'),
+    (0xFCCB, 'M', 'لخ'),
+    (0xFCCC, 'M', 'لم'),
+    (0xFCCD, 'M', 'له'),
+    (0xFCCE, 'M', 'مج'),
+    (0xFCCF, 'M', 'مح'),
+    (0xFCD0, 'M', 'مخ'),
+    (0xFCD1, 'M', 'مم'),
+    (0xFCD2, 'M', 'نج'),
+    (0xFCD3, 'M', 'نح'),
+    (0xFCD4, 'M', 'نخ'),
+    (0xFCD5, 'M', 'نم'),
+    (0xFCD6, 'M', 'نه'),
+    (0xFCD7, 'M', 'هج'),
+    (0xFCD8, 'M', 'هم'),
+    (0xFCD9, 'M', 'هٰ'),
+    (0xFCDA, 'M', 'يج'),
+    (0xFCDB, 'M', 'يح'),
+    (0xFCDC, 'M', 'يخ'),
+    (0xFCDD, 'M', 'يم'),
+    (0xFCDE, 'M', 'يه'),
+    (0xFCDF, 'M', 'ئم'),
+    (0xFCE0, 'M', 'ئه'),
+    (0xFCE1, 'M', 'بم'),
+    (0xFCE2, 'M', 'به'),
+    (0xFCE3, 'M', 'تم'),
+    (0xFCE4, 'M', 'ته'),
+    (0xFCE5, 'M', 'ثم'),
+    (0xFCE6, 'M', 'ثه'),
+    (0xFCE7, 'M', 'سم'),
+    (0xFCE8, 'M', 'سه'),
+    (0xFCE9, 'M', 'شم'),
+    (0xFCEA, 'M', 'شه'),
+    (0xFCEB, 'M', 'كل'),
+    (0xFCEC, 'M', 'كم'),
+    (0xFCED, 'M', 'لم'),
+    (0xFCEE, 'M', 'نم'),
+    (0xFCEF, 'M', 'نه'),
+    (0xFCF0, 'M', 'يم'),
+    (0xFCF1, 'M', 'يه'),
+    (0xFCF2, 'M', 'ـَّ'),
+    (0xFCF3, 'M', 'ـُّ'),
+    (0xFCF4, 'M', 'ـِّ'),
+    (0xFCF5, 'M', 'طى'),
+    (0xFCF6, 'M', 'طي'),
+    (0xFCF7, 'M', 'عى'),
+    (0xFCF8, 'M', 'عي'),
+    (0xFCF9, 'M', 'غى'),
+    (0xFCFA, 'M', 'غي'),
+    (0xFCFB, 'M', 'سى'),
+    (0xFCFC, 'M', 'سي'),
+    (0xFCFD, 'M', 'شى'),
+    (0xFCFE, 'M', 'شي'),
+    (0xFCFF, 'M', 'حى'),
+    (0xFD00, 'M', 'حي'),
+    (0xFD01, 'M', 'جى'),
+    (0xFD02, 'M', 'جي'),
+    (0xFD03, 'M', 'خى'),
+    (0xFD04, 'M', 'خي'),
+    (0xFD05, 'M', 'صى'),
+    (0xFD06, 'M', 'صي'),
+    (0xFD07, 'M', 'ضى'),
+    (0xFD08, 'M', 'ضي'),
+    (0xFD09, 'M', 'شج'),
+    (0xFD0A, 'M', 'شح'),
+    (0xFD0B, 'M', 'شخ'),
+    (0xFD0C, 'M', 'شم'),
+    (0xFD0D, 'M', 'شر'),
+    (0xFD0E, 'M', 'سر'),
+    (0xFD0F, 'M', 'صر'),
+    (0xFD10, 'M', 'ضر'),
+    (0xFD11, 'M', 'طى'),
+    (0xFD12, 'M', 'طي'),
+    (0xFD13, 'M', 'عى'),
+    (0xFD14, 'M', 'عي'),
+    (0xFD15, 'M', 'غى'),
+    (0xFD16, 'M', 'غي'),
+    (0xFD17, 'M', 'سى'),
+    (0xFD18, 'M', 'سي'),
+    (0xFD19, 'M', 'شى'),
+    (0xFD1A, 'M', 'شي'),
+    (0xFD1B, 'M', 'حى'),
+    (0xFD1C, 'M', 'حي'),
+    (0xFD1D, 'M', 'جى'),
+    (0xFD1E, 'M', 'جي'),
+    (0xFD1F, 'M', 'خى'),
+    (0xFD20, 'M', 'خي'),
+    (0xFD21, 'M', 'صى'),
+    (0xFD22, 'M', 'صي'),
+    ]
+
+def _seg_48() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0xFD23, 'M', 'ضى'),
+    (0xFD24, 'M', 'ضي'),
+    (0xFD25, 'M', 'شج'),
+    (0xFD26, 'M', 'شح'),
+    (0xFD27, 'M', 'شخ'),
+    (0xFD28, 'M', 'شم'),
+    (0xFD29, 'M', 'شر'),
+    (0xFD2A, 'M', 'سر'),
+    (0xFD2B, 'M', 'صر'),
+    (0xFD2C, 'M', 'ضر'),
+    (0xFD2D, 'M', 'شج'),
+    (0xFD2E, 'M', 'شح'),
+    (0xFD2F, 'M', 'شخ'),
+    (0xFD30, 'M', 'شم'),
+    (0xFD31, 'M', 'سه'),
+    (0xFD32, 'M', 'شه'),
+    (0xFD33, 'M', 'طم'),
+    (0xFD34, 'M', 'سج'),
+    (0xFD35, 'M', 'سح'),
+    (0xFD36, 'M', 'سخ'),
+    (0xFD37, 'M', 'شج'),
+    (0xFD38, 'M', 'شح'),
+    (0xFD39, 'M', 'شخ'),
+    (0xFD3A, 'M', 'طم'),
+    (0xFD3B, 'M', 'ظم'),
+    (0xFD3C, 'M', 'اً'),
+    (0xFD3E, 'V'),
+    (0xFD50, 'M', 'تجم'),
+    (0xFD51, 'M', 'تحج'),
+    (0xFD53, 'M', 'تحم'),
+    (0xFD54, 'M', 'تخم'),
+    (0xFD55, 'M', 'تمج'),
+    (0xFD56, 'M', 'تمح'),
+    (0xFD57, 'M', 'تمخ'),
+    (0xFD58, 'M', 'جمح'),
+    (0xFD5A, 'M', 'حمي'),
+    (0xFD5B, 'M', 'حمى'),
+    (0xFD5C, 'M', 'سحج'),
+    (0xFD5D, 'M', 'سجح'),
+    (0xFD5E, 'M', 'سجى'),
+    (0xFD5F, 'M', 'سمح'),
+    (0xFD61, 'M', 'سمج'),
+    (0xFD62, 'M', 'سمم'),
+    (0xFD64, 'M', 'صحح'),
+    (0xFD66, 'M', 'صمم'),
+    (0xFD67, 'M', 'شحم'),
+    (0xFD69, 'M', 'شجي'),
+    (0xFD6A, 'M', 'شمخ'),
+    (0xFD6C, 'M', 'شمم'),
+    (0xFD6E, 'M', 'ضحى'),
+    (0xFD6F, 'M', 'ضخم'),
+    (0xFD71, 'M', 'طمح'),
+    (0xFD73, 'M', 'طمم'),
+    (0xFD74, 'M', 'طمي'),
+    (0xFD75, 'M', 'عجم'),
+    (0xFD76, 'M', 'عمم'),
+    (0xFD78, 'M', 'عمى'),
+    (0xFD79, 'M', 'غمم'),
+    (0xFD7A, 'M', 'غمي'),
+    (0xFD7B, 'M', 'غمى'),
+    (0xFD7C, 'M', 'فخم'),
+    (0xFD7E, 'M', 'قمح'),
+    (0xFD7F, 'M', 'قمم'),
+    (0xFD80, 'M', 'لحم'),
+    (0xFD81, 'M', 'لحي'),
+    (0xFD82, 'M', 'لحى'),
+    (0xFD83, 'M', 'لجج'),
+    (0xFD85, 'M', 'لخم'),
+    (0xFD87, 'M', 'لمح'),
+    (0xFD89, 'M', 'محج'),
+    (0xFD8A, 'M', 'محم'),
+    (0xFD8B, 'M', 'محي'),
+    (0xFD8C, 'M', 'مجح'),
+    (0xFD8D, 'M', 'مجم'),
+    (0xFD8E, 'M', 'مخج'),
+    (0xFD8F, 'M', 'مخم'),
+    (0xFD90, 'X'),
+    (0xFD92, 'M', 'مجخ'),
+    (0xFD93, 'M', 'همج'),
+    (0xFD94, 'M', 'همم'),
+    (0xFD95, 'M', 'نحم'),
+    (0xFD96, 'M', 'نحى'),
+    (0xFD97, 'M', 'نجم'),
+    (0xFD99, 'M', 'نجى'),
+    (0xFD9A, 'M', 'نمي'),
+    (0xFD9B, 'M', 'نمى'),
+    (0xFD9C, 'M', 'يمم'),
+    (0xFD9E, 'M', 'بخي'),
+    (0xFD9F, 'M', 'تجي'),
+    (0xFDA0, 'M', 'تجى'),
+    (0xFDA1, 'M', 'تخي'),
+    (0xFDA2, 'M', 'تخى'),
+    (0xFDA3, 'M', 'تمي'),
+    (0xFDA4, 'M', 'تمى'),
+    (0xFDA5, 'M', 'جمي'),
+    (0xFDA6, 'M', 'جحى'),
+    (0xFDA7, 'M', 'جمى'),
+    (0xFDA8, 'M', 'سخى'),
+    (0xFDA9, 'M', 'صحي'),
+    (0xFDAA, 'M', 'شحي'),
+    ]
+
+def _seg_49() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0xFDAB, 'M', 'ضحي'),
+    (0xFDAC, 'M', 'لجي'),
+    (0xFDAD, 'M', 'لمي'),
+    (0xFDAE, 'M', 'يحي'),
+    (0xFDAF, 'M', 'يجي'),
+    (0xFDB0, 'M', 'يمي'),
+    (0xFDB1, 'M', 'ممي'),
+    (0xFDB2, 'M', 'قمي'),
+    (0xFDB3, 'M', 'نحي'),
+    (0xFDB4, 'M', 'قمح'),
+    (0xFDB5, 'M', 'لحم'),
+    (0xFDB6, 'M', 'عمي'),
+    (0xFDB7, 'M', 'كمي'),
+    (0xFDB8, 'M', 'نجح'),
+    (0xFDB9, 'M', 'مخي'),
+    (0xFDBA, 'M', 'لجم'),
+    (0xFDBB, 'M', 'كمم'),
+    (0xFDBC, 'M', 'لجم'),
+    (0xFDBD, 'M', 'نجح'),
+    (0xFDBE, 'M', 'جحي'),
+    (0xFDBF, 'M', 'حجي'),
+    (0xFDC0, 'M', 'مجي'),
+    (0xFDC1, 'M', 'فمي'),
+    (0xFDC2, 'M', 'بحي'),
+    (0xFDC3, 'M', 'كمم'),
+    (0xFDC4, 'M', 'عجم'),
+    (0xFDC5, 'M', 'صمم'),
+    (0xFDC6, 'M', 'سخي'),
+    (0xFDC7, 'M', 'نجي'),
+    (0xFDC8, 'X'),
+    (0xFDCF, 'V'),
+    (0xFDD0, 'X'),
+    (0xFDF0, 'M', 'صلے'),
+    (0xFDF1, 'M', 'قلے'),
+    (0xFDF2, 'M', 'الله'),
+    (0xFDF3, 'M', 'اكبر'),
+    (0xFDF4, 'M', 'محمد'),
+    (0xFDF5, 'M', 'صلعم'),
+    (0xFDF6, 'M', 'رسول'),
+    (0xFDF7, 'M', 'عليه'),
+    (0xFDF8, 'M', 'وسلم'),
+    (0xFDF9, 'M', 'صلى'),
+    (0xFDFA, '3', 'صلى الله عليه وسلم'),
+    (0xFDFB, '3', 'جل جلاله'),
+    (0xFDFC, 'M', 'ریال'),
+    (0xFDFD, 'V'),
+    (0xFE00, 'I'),
+    (0xFE10, '3', ','),
+    (0xFE11, 'M', '、'),
+    (0xFE12, 'X'),
+    (0xFE13, '3', ':'),
+    (0xFE14, '3', ';'),
+    (0xFE15, '3', '!'),
+    (0xFE16, '3', '?'),
+    (0xFE17, 'M', '〖'),
+    (0xFE18, 'M', '〗'),
+    (0xFE19, 'X'),
+    (0xFE20, 'V'),
+    (0xFE30, 'X'),
+    (0xFE31, 'M', '—'),
+    (0xFE32, 'M', '–'),
+    (0xFE33, '3', '_'),
+    (0xFE35, '3', '('),
+    (0xFE36, '3', ')'),
+    (0xFE37, '3', '{'),
+    (0xFE38, '3', '}'),
+    (0xFE39, 'M', '〔'),
+    (0xFE3A, 'M', '〕'),
+    (0xFE3B, 'M', '【'),
+    (0xFE3C, 'M', '】'),
+    (0xFE3D, 'M', '《'),
+    (0xFE3E, 'M', '》'),
+    (0xFE3F, 'M', '〈'),
+    (0xFE40, 'M', '〉'),
+    (0xFE41, 'M', '「'),
+    (0xFE42, 'M', '」'),
+    (0xFE43, 'M', '『'),
+    (0xFE44, 'M', '』'),
+    (0xFE45, 'V'),
+    (0xFE47, '3', '['),
+    (0xFE48, '3', ']'),
+    (0xFE49, '3', ' ̅'),
+    (0xFE4D, '3', '_'),
+    (0xFE50, '3', ','),
+    (0xFE51, 'M', '、'),
+    (0xFE52, 'X'),
+    (0xFE54, '3', ';'),
+    (0xFE55, '3', ':'),
+    (0xFE56, '3', '?'),
+    (0xFE57, '3', '!'),
+    (0xFE58, 'M', '—'),
+    (0xFE59, '3', '('),
+    (0xFE5A, '3', ')'),
+    (0xFE5B, '3', '{'),
+    (0xFE5C, '3', '}'),
+    (0xFE5D, 'M', '〔'),
+    (0xFE5E, 'M', '〕'),
+    (0xFE5F, '3', '#'),
+    (0xFE60, '3', '&'),
+    (0xFE61, '3', '*'),
+    ]
+
+def _seg_50() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0xFE62, '3', '+'),
+    (0xFE63, 'M', '-'),
+    (0xFE64, '3', '<'),
+    (0xFE65, '3', '>'),
+    (0xFE66, '3', '='),
+    (0xFE67, 'X'),
+    (0xFE68, '3', '\\'),
+    (0xFE69, '3', '$'),
+    (0xFE6A, '3', '%'),
+    (0xFE6B, '3', '@'),
+    (0xFE6C, 'X'),
+    (0xFE70, '3', ' ً'),
+    (0xFE71, 'M', 'ـً'),
+    (0xFE72, '3', ' ٌ'),
+    (0xFE73, 'V'),
+    (0xFE74, '3', ' ٍ'),
+    (0xFE75, 'X'),
+    (0xFE76, '3', ' َ'),
+    (0xFE77, 'M', 'ـَ'),
+    (0xFE78, '3', ' ُ'),
+    (0xFE79, 'M', 'ـُ'),
+    (0xFE7A, '3', ' ِ'),
+    (0xFE7B, 'M', 'ـِ'),
+    (0xFE7C, '3', ' ّ'),
+    (0xFE7D, 'M', 'ـّ'),
+    (0xFE7E, '3', ' ْ'),
+    (0xFE7F, 'M', 'ـْ'),
+    (0xFE80, 'M', 'ء'),
+    (0xFE81, 'M', 'آ'),
+    (0xFE83, 'M', 'أ'),
+    (0xFE85, 'M', 'ؤ'),
+    (0xFE87, 'M', 'إ'),
+    (0xFE89, 'M', 'ئ'),
+    (0xFE8D, 'M', 'ا'),
+    (0xFE8F, 'M', 'ب'),
+    (0xFE93, 'M', 'ة'),
+    (0xFE95, 'M', 'ت'),
+    (0xFE99, 'M', 'ث'),
+    (0xFE9D, 'M', 'ج'),
+    (0xFEA1, 'M', 'ح'),
+    (0xFEA5, 'M', 'خ'),
+    (0xFEA9, 'M', 'د'),
+    (0xFEAB, 'M', 'ذ'),
+    (0xFEAD, 'M', 'ر'),
+    (0xFEAF, 'M', 'ز'),
+    (0xFEB1, 'M', 'س'),
+    (0xFEB5, 'M', 'ش'),
+    (0xFEB9, 'M', 'ص'),
+    (0xFEBD, 'M', 'ض'),
+    (0xFEC1, 'M', 'ط'),
+    (0xFEC5, 'M', 'ظ'),
+    (0xFEC9, 'M', 'ع'),
+    (0xFECD, 'M', 'غ'),
+    (0xFED1, 'M', 'ف'),
+    (0xFED5, 'M', 'ق'),
+    (0xFED9, 'M', 'ك'),
+    (0xFEDD, 'M', 'ل'),
+    (0xFEE1, 'M', 'م'),
+    (0xFEE5, 'M', 'ن'),
+    (0xFEE9, 'M', 'ه'),
+    (0xFEED, 'M', 'و'),
+    (0xFEEF, 'M', 'ى'),
+    (0xFEF1, 'M', 'ي'),
+    (0xFEF5, 'M', 'لآ'),
+    (0xFEF7, 'M', 'لأ'),
+    (0xFEF9, 'M', 'لإ'),
+    (0xFEFB, 'M', 'لا'),
+    (0xFEFD, 'X'),
+    (0xFEFF, 'I'),
+    (0xFF00, 'X'),
+    (0xFF01, '3', '!'),
+    (0xFF02, '3', '"'),
+    (0xFF03, '3', '#'),
+    (0xFF04, '3', '$'),
+    (0xFF05, '3', '%'),
+    (0xFF06, '3', '&'),
+    (0xFF07, '3', '\''),
+    (0xFF08, '3', '('),
+    (0xFF09, '3', ')'),
+    (0xFF0A, '3', '*'),
+    (0xFF0B, '3', '+'),
+    (0xFF0C, '3', ','),
+    (0xFF0D, 'M', '-'),
+    (0xFF0E, 'M', '.'),
+    (0xFF0F, '3', '/'),
+    (0xFF10, 'M', '0'),
+    (0xFF11, 'M', '1'),
+    (0xFF12, 'M', '2'),
+    (0xFF13, 'M', '3'),
+    (0xFF14, 'M', '4'),
+    (0xFF15, 'M', '5'),
+    (0xFF16, 'M', '6'),
+    (0xFF17, 'M', '7'),
+    (0xFF18, 'M', '8'),
+    (0xFF19, 'M', '9'),
+    (0xFF1A, '3', ':'),
+    (0xFF1B, '3', ';'),
+    (0xFF1C, '3', '<'),
+    (0xFF1D, '3', '='),
+    (0xFF1E, '3', '>'),
+    ]
+
+def _seg_51() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0xFF1F, '3', '?'),
+    (0xFF20, '3', '@'),
+    (0xFF21, 'M', 'a'),
+    (0xFF22, 'M', 'b'),
+    (0xFF23, 'M', 'c'),
+    (0xFF24, 'M', 'd'),
+    (0xFF25, 'M', 'e'),
+    (0xFF26, 'M', 'f'),
+    (0xFF27, 'M', 'g'),
+    (0xFF28, 'M', 'h'),
+    (0xFF29, 'M', 'i'),
+    (0xFF2A, 'M', 'j'),
+    (0xFF2B, 'M', 'k'),
+    (0xFF2C, 'M', 'l'),
+    (0xFF2D, 'M', 'm'),
+    (0xFF2E, 'M', 'n'),
+    (0xFF2F, 'M', 'o'),
+    (0xFF30, 'M', 'p'),
+    (0xFF31, 'M', 'q'),
+    (0xFF32, 'M', 'r'),
+    (0xFF33, 'M', 's'),
+    (0xFF34, 'M', 't'),
+    (0xFF35, 'M', 'u'),
+    (0xFF36, 'M', 'v'),
+    (0xFF37, 'M', 'w'),
+    (0xFF38, 'M', 'x'),
+    (0xFF39, 'M', 'y'),
+    (0xFF3A, 'M', 'z'),
+    (0xFF3B, '3', '['),
+    (0xFF3C, '3', '\\'),
+    (0xFF3D, '3', ']'),
+    (0xFF3E, '3', '^'),
+    (0xFF3F, '3', '_'),
+    (0xFF40, '3', '`'),
+    (0xFF41, 'M', 'a'),
+    (0xFF42, 'M', 'b'),
+    (0xFF43, 'M', 'c'),
+    (0xFF44, 'M', 'd'),
+    (0xFF45, 'M', 'e'),
+    (0xFF46, 'M', 'f'),
+    (0xFF47, 'M', 'g'),
+    (0xFF48, 'M', 'h'),
+    (0xFF49, 'M', 'i'),
+    (0xFF4A, 'M', 'j'),
+    (0xFF4B, 'M', 'k'),
+    (0xFF4C, 'M', 'l'),
+    (0xFF4D, 'M', 'm'),
+    (0xFF4E, 'M', 'n'),
+    (0xFF4F, 'M', 'o'),
+    (0xFF50, 'M', 'p'),
+    (0xFF51, 'M', 'q'),
+    (0xFF52, 'M', 'r'),
+    (0xFF53, 'M', 's'),
+    (0xFF54, 'M', 't'),
+    (0xFF55, 'M', 'u'),
+    (0xFF56, 'M', 'v'),
+    (0xFF57, 'M', 'w'),
+    (0xFF58, 'M', 'x'),
+    (0xFF59, 'M', 'y'),
+    (0xFF5A, 'M', 'z'),
+    (0xFF5B, '3', '{'),
+    (0xFF5C, '3', '|'),
+    (0xFF5D, '3', '}'),
+    (0xFF5E, '3', '~'),
+    (0xFF5F, 'M', '⦅'),
+    (0xFF60, 'M', '⦆'),
+    (0xFF61, 'M', '.'),
+    (0xFF62, 'M', '「'),
+    (0xFF63, 'M', '」'),
+    (0xFF64, 'M', '、'),
+    (0xFF65, 'M', '・'),
+    (0xFF66, 'M', 'ヲ'),
+    (0xFF67, 'M', 'ァ'),
+    (0xFF68, 'M', 'ィ'),
+    (0xFF69, 'M', 'ゥ'),
+    (0xFF6A, 'M', 'ェ'),
+    (0xFF6B, 'M', 'ォ'),
+    (0xFF6C, 'M', 'ャ'),
+    (0xFF6D, 'M', 'ュ'),
+    (0xFF6E, 'M', 'ョ'),
+    (0xFF6F, 'M', 'ッ'),
+    (0xFF70, 'M', 'ー'),
+    (0xFF71, 'M', 'ア'),
+    (0xFF72, 'M', 'イ'),
+    (0xFF73, 'M', 'ウ'),
+    (0xFF74, 'M', 'エ'),
+    (0xFF75, 'M', 'オ'),
+    (0xFF76, 'M', 'カ'),
+    (0xFF77, 'M', 'キ'),
+    (0xFF78, 'M', 'ク'),
+    (0xFF79, 'M', 'ケ'),
+    (0xFF7A, 'M', 'コ'),
+    (0xFF7B, 'M', 'サ'),
+    (0xFF7C, 'M', 'シ'),
+    (0xFF7D, 'M', 'ス'),
+    (0xFF7E, 'M', 'セ'),
+    (0xFF7F, 'M', 'ソ'),
+    (0xFF80, 'M', 'タ'),
+    (0xFF81, 'M', 'チ'),
+    (0xFF82, 'M', 'ツ'),
+    ]
+
+def _seg_52() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0xFF83, 'M', 'テ'),
+    (0xFF84, 'M', 'ト'),
+    (0xFF85, 'M', 'ナ'),
+    (0xFF86, 'M', 'ニ'),
+    (0xFF87, 'M', 'ヌ'),
+    (0xFF88, 'M', 'ネ'),
+    (0xFF89, 'M', 'ノ'),
+    (0xFF8A, 'M', 'ハ'),
+    (0xFF8B, 'M', 'ヒ'),
+    (0xFF8C, 'M', 'フ'),
+    (0xFF8D, 'M', 'ヘ'),
+    (0xFF8E, 'M', 'ホ'),
+    (0xFF8F, 'M', 'マ'),
+    (0xFF90, 'M', 'ミ'),
+    (0xFF91, 'M', 'ム'),
+    (0xFF92, 'M', 'メ'),
+    (0xFF93, 'M', 'モ'),
+    (0xFF94, 'M', 'ヤ'),
+    (0xFF95, 'M', 'ユ'),
+    (0xFF96, 'M', 'ヨ'),
+    (0xFF97, 'M', 'ラ'),
+    (0xFF98, 'M', 'リ'),
+    (0xFF99, 'M', 'ル'),
+    (0xFF9A, 'M', 'レ'),
+    (0xFF9B, 'M', 'ロ'),
+    (0xFF9C, 'M', 'ワ'),
+    (0xFF9D, 'M', 'ン'),
+    (0xFF9E, 'M', '゙'),
+    (0xFF9F, 'M', '゚'),
+    (0xFFA0, 'X'),
+    (0xFFA1, 'M', 'ᄀ'),
+    (0xFFA2, 'M', 'ᄁ'),
+    (0xFFA3, 'M', 'ᆪ'),
+    (0xFFA4, 'M', 'ᄂ'),
+    (0xFFA5, 'M', 'ᆬ'),
+    (0xFFA6, 'M', 'ᆭ'),
+    (0xFFA7, 'M', 'ᄃ'),
+    (0xFFA8, 'M', 'ᄄ'),
+    (0xFFA9, 'M', 'ᄅ'),
+    (0xFFAA, 'M', 'ᆰ'),
+    (0xFFAB, 'M', 'ᆱ'),
+    (0xFFAC, 'M', 'ᆲ'),
+    (0xFFAD, 'M', 'ᆳ'),
+    (0xFFAE, 'M', 'ᆴ'),
+    (0xFFAF, 'M', 'ᆵ'),
+    (0xFFB0, 'M', 'ᄚ'),
+    (0xFFB1, 'M', 'ᄆ'),
+    (0xFFB2, 'M', 'ᄇ'),
+    (0xFFB3, 'M', 'ᄈ'),
+    (0xFFB4, 'M', 'ᄡ'),
+    (0xFFB5, 'M', 'ᄉ'),
+    (0xFFB6, 'M', 'ᄊ'),
+    (0xFFB7, 'M', 'ᄋ'),
+    (0xFFB8, 'M', 'ᄌ'),
+    (0xFFB9, 'M', 'ᄍ'),
+    (0xFFBA, 'M', 'ᄎ'),
+    (0xFFBB, 'M', 'ᄏ'),
+    (0xFFBC, 'M', 'ᄐ'),
+    (0xFFBD, 'M', 'ᄑ'),
+    (0xFFBE, 'M', 'ᄒ'),
+    (0xFFBF, 'X'),
+    (0xFFC2, 'M', 'ᅡ'),
+    (0xFFC3, 'M', 'ᅢ'),
+    (0xFFC4, 'M', 'ᅣ'),
+    (0xFFC5, 'M', 'ᅤ'),
+    (0xFFC6, 'M', 'ᅥ'),
+    (0xFFC7, 'M', 'ᅦ'),
+    (0xFFC8, 'X'),
+    (0xFFCA, 'M', 'ᅧ'),
+    (0xFFCB, 'M', 'ᅨ'),
+    (0xFFCC, 'M', 'ᅩ'),
+    (0xFFCD, 'M', 'ᅪ'),
+    (0xFFCE, 'M', 'ᅫ'),
+    (0xFFCF, 'M', 'ᅬ'),
+    (0xFFD0, 'X'),
+    (0xFFD2, 'M', 'ᅭ'),
+    (0xFFD3, 'M', 'ᅮ'),
+    (0xFFD4, 'M', 'ᅯ'),
+    (0xFFD5, 'M', 'ᅰ'),
+    (0xFFD6, 'M', 'ᅱ'),
+    (0xFFD7, 'M', 'ᅲ'),
+    (0xFFD8, 'X'),
+    (0xFFDA, 'M', 'ᅳ'),
+    (0xFFDB, 'M', 'ᅴ'),
+    (0xFFDC, 'M', 'ᅵ'),
+    (0xFFDD, 'X'),
+    (0xFFE0, 'M', '¢'),
+    (0xFFE1, 'M', '£'),
+    (0xFFE2, 'M', '¬'),
+    (0xFFE3, '3', ' ̄'),
+    (0xFFE4, 'M', '¦'),
+    (0xFFE5, 'M', '¥'),
+    (0xFFE6, 'M', '₩'),
+    (0xFFE7, 'X'),
+    (0xFFE8, 'M', '│'),
+    (0xFFE9, 'M', '←'),
+    (0xFFEA, 'M', '↑'),
+    (0xFFEB, 'M', '→'),
+    (0xFFEC, 'M', '↓'),
+    (0xFFED, 'M', '■'),
+    ]
+
+def _seg_53() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0xFFEE, 'M', '○'),
+    (0xFFEF, 'X'),
+    (0x10000, 'V'),
+    (0x1000C, 'X'),
+    (0x1000D, 'V'),
+    (0x10027, 'X'),
+    (0x10028, 'V'),
+    (0x1003B, 'X'),
+    (0x1003C, 'V'),
+    (0x1003E, 'X'),
+    (0x1003F, 'V'),
+    (0x1004E, 'X'),
+    (0x10050, 'V'),
+    (0x1005E, 'X'),
+    (0x10080, 'V'),
+    (0x100FB, 'X'),
+    (0x10100, 'V'),
+    (0x10103, 'X'),
+    (0x10107, 'V'),
+    (0x10134, 'X'),
+    (0x10137, 'V'),
+    (0x1018F, 'X'),
+    (0x10190, 'V'),
+    (0x1019D, 'X'),
+    (0x101A0, 'V'),
+    (0x101A1, 'X'),
+    (0x101D0, 'V'),
+    (0x101FE, 'X'),
+    (0x10280, 'V'),
+    (0x1029D, 'X'),
+    (0x102A0, 'V'),
+    (0x102D1, 'X'),
+    (0x102E0, 'V'),
+    (0x102FC, 'X'),
+    (0x10300, 'V'),
+    (0x10324, 'X'),
+    (0x1032D, 'V'),
+    (0x1034B, 'X'),
+    (0x10350, 'V'),
+    (0x1037B, 'X'),
+    (0x10380, 'V'),
+    (0x1039E, 'X'),
+    (0x1039F, 'V'),
+    (0x103C4, 'X'),
+    (0x103C8, 'V'),
+    (0x103D6, 'X'),
+    (0x10400, 'M', '𐐨'),
+    (0x10401, 'M', '𐐩'),
+    (0x10402, 'M', '𐐪'),
+    (0x10403, 'M', '𐐫'),
+    (0x10404, 'M', '𐐬'),
+    (0x10405, 'M', '𐐭'),
+    (0x10406, 'M', '𐐮'),
+    (0x10407, 'M', '𐐯'),
+    (0x10408, 'M', '𐐰'),
+    (0x10409, 'M', '𐐱'),
+    (0x1040A, 'M', '𐐲'),
+    (0x1040B, 'M', '𐐳'),
+    (0x1040C, 'M', '𐐴'),
+    (0x1040D, 'M', '𐐵'),
+    (0x1040E, 'M', '𐐶'),
+    (0x1040F, 'M', '𐐷'),
+    (0x10410, 'M', '𐐸'),
+    (0x10411, 'M', '𐐹'),
+    (0x10412, 'M', '𐐺'),
+    (0x10413, 'M', '𐐻'),
+    (0x10414, 'M', '𐐼'),
+    (0x10415, 'M', '𐐽'),
+    (0x10416, 'M', '𐐾'),
+    (0x10417, 'M', '𐐿'),
+    (0x10418, 'M', '𐑀'),
+    (0x10419, 'M', '𐑁'),
+    (0x1041A, 'M', '𐑂'),
+    (0x1041B, 'M', '𐑃'),
+    (0x1041C, 'M', '𐑄'),
+    (0x1041D, 'M', '𐑅'),
+    (0x1041E, 'M', '𐑆'),
+    (0x1041F, 'M', '𐑇'),
+    (0x10420, 'M', '𐑈'),
+    (0x10421, 'M', '𐑉'),
+    (0x10422, 'M', '𐑊'),
+    (0x10423, 'M', '𐑋'),
+    (0x10424, 'M', '𐑌'),
+    (0x10425, 'M', '𐑍'),
+    (0x10426, 'M', '𐑎'),
+    (0x10427, 'M', '𐑏'),
+    (0x10428, 'V'),
+    (0x1049E, 'X'),
+    (0x104A0, 'V'),
+    (0x104AA, 'X'),
+    (0x104B0, 'M', '𐓘'),
+    (0x104B1, 'M', '𐓙'),
+    (0x104B2, 'M', '𐓚'),
+    (0x104B3, 'M', '𐓛'),
+    (0x104B4, 'M', '𐓜'),
+    (0x104B5, 'M', '𐓝'),
+    (0x104B6, 'M', '𐓞'),
+    (0x104B7, 'M', '𐓟'),
+    (0x104B8, 'M', '𐓠'),
+    (0x104B9, 'M', '𐓡'),
+    ]
+
+def _seg_54() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x104BA, 'M', '𐓢'),
+    (0x104BB, 'M', '𐓣'),
+    (0x104BC, 'M', '𐓤'),
+    (0x104BD, 'M', '𐓥'),
+    (0x104BE, 'M', '𐓦'),
+    (0x104BF, 'M', '𐓧'),
+    (0x104C0, 'M', '𐓨'),
+    (0x104C1, 'M', '𐓩'),
+    (0x104C2, 'M', '𐓪'),
+    (0x104C3, 'M', '𐓫'),
+    (0x104C4, 'M', '𐓬'),
+    (0x104C5, 'M', '𐓭'),
+    (0x104C6, 'M', '𐓮'),
+    (0x104C7, 'M', '𐓯'),
+    (0x104C8, 'M', '𐓰'),
+    (0x104C9, 'M', '𐓱'),
+    (0x104CA, 'M', '𐓲'),
+    (0x104CB, 'M', '𐓳'),
+    (0x104CC, 'M', '𐓴'),
+    (0x104CD, 'M', '𐓵'),
+    (0x104CE, 'M', '𐓶'),
+    (0x104CF, 'M', '𐓷'),
+    (0x104D0, 'M', '𐓸'),
+    (0x104D1, 'M', '𐓹'),
+    (0x104D2, 'M', '𐓺'),
+    (0x104D3, 'M', '𐓻'),
+    (0x104D4, 'X'),
+    (0x104D8, 'V'),
+    (0x104FC, 'X'),
+    (0x10500, 'V'),
+    (0x10528, 'X'),
+    (0x10530, 'V'),
+    (0x10564, 'X'),
+    (0x1056F, 'V'),
+    (0x10570, 'M', '𐖗'),
+    (0x10571, 'M', '𐖘'),
+    (0x10572, 'M', '𐖙'),
+    (0x10573, 'M', '𐖚'),
+    (0x10574, 'M', '𐖛'),
+    (0x10575, 'M', '𐖜'),
+    (0x10576, 'M', '𐖝'),
+    (0x10577, 'M', '𐖞'),
+    (0x10578, 'M', '𐖟'),
+    (0x10579, 'M', '𐖠'),
+    (0x1057A, 'M', '𐖡'),
+    (0x1057B, 'X'),
+    (0x1057C, 'M', '𐖣'),
+    (0x1057D, 'M', '𐖤'),
+    (0x1057E, 'M', '𐖥'),
+    (0x1057F, 'M', '𐖦'),
+    (0x10580, 'M', '𐖧'),
+    (0x10581, 'M', '𐖨'),
+    (0x10582, 'M', '𐖩'),
+    (0x10583, 'M', '𐖪'),
+    (0x10584, 'M', '𐖫'),
+    (0x10585, 'M', '𐖬'),
+    (0x10586, 'M', '𐖭'),
+    (0x10587, 'M', '𐖮'),
+    (0x10588, 'M', '𐖯'),
+    (0x10589, 'M', '𐖰'),
+    (0x1058A, 'M', '𐖱'),
+    (0x1058B, 'X'),
+    (0x1058C, 'M', '𐖳'),
+    (0x1058D, 'M', '𐖴'),
+    (0x1058E, 'M', '𐖵'),
+    (0x1058F, 'M', '𐖶'),
+    (0x10590, 'M', '𐖷'),
+    (0x10591, 'M', '𐖸'),
+    (0x10592, 'M', '𐖹'),
+    (0x10593, 'X'),
+    (0x10594, 'M', '𐖻'),
+    (0x10595, 'M', '𐖼'),
+    (0x10596, 'X'),
+    (0x10597, 'V'),
+    (0x105A2, 'X'),
+    (0x105A3, 'V'),
+    (0x105B2, 'X'),
+    (0x105B3, 'V'),
+    (0x105BA, 'X'),
+    (0x105BB, 'V'),
+    (0x105BD, 'X'),
+    (0x10600, 'V'),
+    (0x10737, 'X'),
+    (0x10740, 'V'),
+    (0x10756, 'X'),
+    (0x10760, 'V'),
+    (0x10768, 'X'),
+    (0x10780, 'V'),
+    (0x10781, 'M', 'ː'),
+    (0x10782, 'M', 'ˑ'),
+    (0x10783, 'M', 'æ'),
+    (0x10784, 'M', 'ʙ'),
+    (0x10785, 'M', 'ɓ'),
+    (0x10786, 'X'),
+    (0x10787, 'M', 'ʣ'),
+    (0x10788, 'M', 'ꭦ'),
+    (0x10789, 'M', 'ʥ'),
+    (0x1078A, 'M', 'ʤ'),
+    (0x1078B, 'M', 'ɖ'),
+    (0x1078C, 'M', 'ɗ'),
+    ]
+
+def _seg_55() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x1078D, 'M', 'ᶑ'),
+    (0x1078E, 'M', 'ɘ'),
+    (0x1078F, 'M', 'ɞ'),
+    (0x10790, 'M', 'ʩ'),
+    (0x10791, 'M', 'ɤ'),
+    (0x10792, 'M', 'ɢ'),
+    (0x10793, 'M', 'ɠ'),
+    (0x10794, 'M', 'ʛ'),
+    (0x10795, 'M', 'ħ'),
+    (0x10796, 'M', 'ʜ'),
+    (0x10797, 'M', 'ɧ'),
+    (0x10798, 'M', 'ʄ'),
+    (0x10799, 'M', 'ʪ'),
+    (0x1079A, 'M', 'ʫ'),
+    (0x1079B, 'M', 'ɬ'),
+    (0x1079C, 'M', '𝼄'),
+    (0x1079D, 'M', 'ꞎ'),
+    (0x1079E, 'M', 'ɮ'),
+    (0x1079F, 'M', '𝼅'),
+    (0x107A0, 'M', 'ʎ'),
+    (0x107A1, 'M', '𝼆'),
+    (0x107A2, 'M', 'ø'),
+    (0x107A3, 'M', 'ɶ'),
+    (0x107A4, 'M', 'ɷ'),
+    (0x107A5, 'M', 'q'),
+    (0x107A6, 'M', 'ɺ'),
+    (0x107A7, 'M', '𝼈'),
+    (0x107A8, 'M', 'ɽ'),
+    (0x107A9, 'M', 'ɾ'),
+    (0x107AA, 'M', 'ʀ'),
+    (0x107AB, 'M', 'ʨ'),
+    (0x107AC, 'M', 'ʦ'),
+    (0x107AD, 'M', 'ꭧ'),
+    (0x107AE, 'M', 'ʧ'),
+    (0x107AF, 'M', 'ʈ'),
+    (0x107B0, 'M', 'ⱱ'),
+    (0x107B1, 'X'),
+    (0x107B2, 'M', 'ʏ'),
+    (0x107B3, 'M', 'ʡ'),
+    (0x107B4, 'M', 'ʢ'),
+    (0x107B5, 'M', 'ʘ'),
+    (0x107B6, 'M', 'ǀ'),
+    (0x107B7, 'M', 'ǁ'),
+    (0x107B8, 'M', 'ǂ'),
+    (0x107B9, 'M', '𝼊'),
+    (0x107BA, 'M', '𝼞'),
+    (0x107BB, 'X'),
+    (0x10800, 'V'),
+    (0x10806, 'X'),
+    (0x10808, 'V'),
+    (0x10809, 'X'),
+    (0x1080A, 'V'),
+    (0x10836, 'X'),
+    (0x10837, 'V'),
+    (0x10839, 'X'),
+    (0x1083C, 'V'),
+    (0x1083D, 'X'),
+    (0x1083F, 'V'),
+    (0x10856, 'X'),
+    (0x10857, 'V'),
+    (0x1089F, 'X'),
+    (0x108A7, 'V'),
+    (0x108B0, 'X'),
+    (0x108E0, 'V'),
+    (0x108F3, 'X'),
+    (0x108F4, 'V'),
+    (0x108F6, 'X'),
+    (0x108FB, 'V'),
+    (0x1091C, 'X'),
+    (0x1091F, 'V'),
+    (0x1093A, 'X'),
+    (0x1093F, 'V'),
+    (0x10940, 'X'),
+    (0x10980, 'V'),
+    (0x109B8, 'X'),
+    (0x109BC, 'V'),
+    (0x109D0, 'X'),
+    (0x109D2, 'V'),
+    (0x10A04, 'X'),
+    (0x10A05, 'V'),
+    (0x10A07, 'X'),
+    (0x10A0C, 'V'),
+    (0x10A14, 'X'),
+    (0x10A15, 'V'),
+    (0x10A18, 'X'),
+    (0x10A19, 'V'),
+    (0x10A36, 'X'),
+    (0x10A38, 'V'),
+    (0x10A3B, 'X'),
+    (0x10A3F, 'V'),
+    (0x10A49, 'X'),
+    (0x10A50, 'V'),
+    (0x10A59, 'X'),
+    (0x10A60, 'V'),
+    (0x10AA0, 'X'),
+    (0x10AC0, 'V'),
+    (0x10AE7, 'X'),
+    (0x10AEB, 'V'),
+    (0x10AF7, 'X'),
+    (0x10B00, 'V'),
+    ]
+
+def _seg_56() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x10B36, 'X'),
+    (0x10B39, 'V'),
+    (0x10B56, 'X'),
+    (0x10B58, 'V'),
+    (0x10B73, 'X'),
+    (0x10B78, 'V'),
+    (0x10B92, 'X'),
+    (0x10B99, 'V'),
+    (0x10B9D, 'X'),
+    (0x10BA9, 'V'),
+    (0x10BB0, 'X'),
+    (0x10C00, 'V'),
+    (0x10C49, 'X'),
+    (0x10C80, 'M', '𐳀'),
+    (0x10C81, 'M', '𐳁'),
+    (0x10C82, 'M', '𐳂'),
+    (0x10C83, 'M', '𐳃'),
+    (0x10C84, 'M', '𐳄'),
+    (0x10C85, 'M', '𐳅'),
+    (0x10C86, 'M', '𐳆'),
+    (0x10C87, 'M', '𐳇'),
+    (0x10C88, 'M', '𐳈'),
+    (0x10C89, 'M', '𐳉'),
+    (0x10C8A, 'M', '𐳊'),
+    (0x10C8B, 'M', '𐳋'),
+    (0x10C8C, 'M', '𐳌'),
+    (0x10C8D, 'M', '𐳍'),
+    (0x10C8E, 'M', '𐳎'),
+    (0x10C8F, 'M', '𐳏'),
+    (0x10C90, 'M', '𐳐'),
+    (0x10C91, 'M', '𐳑'),
+    (0x10C92, 'M', '𐳒'),
+    (0x10C93, 'M', '𐳓'),
+    (0x10C94, 'M', '𐳔'),
+    (0x10C95, 'M', '𐳕'),
+    (0x10C96, 'M', '𐳖'),
+    (0x10C97, 'M', '𐳗'),
+    (0x10C98, 'M', '𐳘'),
+    (0x10C99, 'M', '𐳙'),
+    (0x10C9A, 'M', '𐳚'),
+    (0x10C9B, 'M', '𐳛'),
+    (0x10C9C, 'M', '𐳜'),
+    (0x10C9D, 'M', '𐳝'),
+    (0x10C9E, 'M', '𐳞'),
+    (0x10C9F, 'M', '𐳟'),
+    (0x10CA0, 'M', '𐳠'),
+    (0x10CA1, 'M', '𐳡'),
+    (0x10CA2, 'M', '𐳢'),
+    (0x10CA3, 'M', '𐳣'),
+    (0x10CA4, 'M', '𐳤'),
+    (0x10CA5, 'M', '𐳥'),
+    (0x10CA6, 'M', '𐳦'),
+    (0x10CA7, 'M', '𐳧'),
+    (0x10CA8, 'M', '𐳨'),
+    (0x10CA9, 'M', '𐳩'),
+    (0x10CAA, 'M', '𐳪'),
+    (0x10CAB, 'M', '𐳫'),
+    (0x10CAC, 'M', '𐳬'),
+    (0x10CAD, 'M', '𐳭'),
+    (0x10CAE, 'M', '𐳮'),
+    (0x10CAF, 'M', '𐳯'),
+    (0x10CB0, 'M', '𐳰'),
+    (0x10CB1, 'M', '𐳱'),
+    (0x10CB2, 'M', '𐳲'),
+    (0x10CB3, 'X'),
+    (0x10CC0, 'V'),
+    (0x10CF3, 'X'),
+    (0x10CFA, 'V'),
+    (0x10D28, 'X'),
+    (0x10D30, 'V'),
+    (0x10D3A, 'X'),
+    (0x10E60, 'V'),
+    (0x10E7F, 'X'),
+    (0x10E80, 'V'),
+    (0x10EAA, 'X'),
+    (0x10EAB, 'V'),
+    (0x10EAE, 'X'),
+    (0x10EB0, 'V'),
+    (0x10EB2, 'X'),
+    (0x10EFD, 'V'),
+    (0x10F28, 'X'),
+    (0x10F30, 'V'),
+    (0x10F5A, 'X'),
+    (0x10F70, 'V'),
+    (0x10F8A, 'X'),
+    (0x10FB0, 'V'),
+    (0x10FCC, 'X'),
+    (0x10FE0, 'V'),
+    (0x10FF7, 'X'),
+    (0x11000, 'V'),
+    (0x1104E, 'X'),
+    (0x11052, 'V'),
+    (0x11076, 'X'),
+    (0x1107F, 'V'),
+    (0x110BD, 'X'),
+    (0x110BE, 'V'),
+    (0x110C3, 'X'),
+    (0x110D0, 'V'),
+    (0x110E9, 'X'),
+    (0x110F0, 'V'),
+    ]
+
+def _seg_57() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x110FA, 'X'),
+    (0x11100, 'V'),
+    (0x11135, 'X'),
+    (0x11136, 'V'),
+    (0x11148, 'X'),
+    (0x11150, 'V'),
+    (0x11177, 'X'),
+    (0x11180, 'V'),
+    (0x111E0, 'X'),
+    (0x111E1, 'V'),
+    (0x111F5, 'X'),
+    (0x11200, 'V'),
+    (0x11212, 'X'),
+    (0x11213, 'V'),
+    (0x11242, 'X'),
+    (0x11280, 'V'),
+    (0x11287, 'X'),
+    (0x11288, 'V'),
+    (0x11289, 'X'),
+    (0x1128A, 'V'),
+    (0x1128E, 'X'),
+    (0x1128F, 'V'),
+    (0x1129E, 'X'),
+    (0x1129F, 'V'),
+    (0x112AA, 'X'),
+    (0x112B0, 'V'),
+    (0x112EB, 'X'),
+    (0x112F0, 'V'),
+    (0x112FA, 'X'),
+    (0x11300, 'V'),
+    (0x11304, 'X'),
+    (0x11305, 'V'),
+    (0x1130D, 'X'),
+    (0x1130F, 'V'),
+    (0x11311, 'X'),
+    (0x11313, 'V'),
+    (0x11329, 'X'),
+    (0x1132A, 'V'),
+    (0x11331, 'X'),
+    (0x11332, 'V'),
+    (0x11334, 'X'),
+    (0x11335, 'V'),
+    (0x1133A, 'X'),
+    (0x1133B, 'V'),
+    (0x11345, 'X'),
+    (0x11347, 'V'),
+    (0x11349, 'X'),
+    (0x1134B, 'V'),
+    (0x1134E, 'X'),
+    (0x11350, 'V'),
+    (0x11351, 'X'),
+    (0x11357, 'V'),
+    (0x11358, 'X'),
+    (0x1135D, 'V'),
+    (0x11364, 'X'),
+    (0x11366, 'V'),
+    (0x1136D, 'X'),
+    (0x11370, 'V'),
+    (0x11375, 'X'),
+    (0x11400, 'V'),
+    (0x1145C, 'X'),
+    (0x1145D, 'V'),
+    (0x11462, 'X'),
+    (0x11480, 'V'),
+    (0x114C8, 'X'),
+    (0x114D0, 'V'),
+    (0x114DA, 'X'),
+    (0x11580, 'V'),
+    (0x115B6, 'X'),
+    (0x115B8, 'V'),
+    (0x115DE, 'X'),
+    (0x11600, 'V'),
+    (0x11645, 'X'),
+    (0x11650, 'V'),
+    (0x1165A, 'X'),
+    (0x11660, 'V'),
+    (0x1166D, 'X'),
+    (0x11680, 'V'),
+    (0x116BA, 'X'),
+    (0x116C0, 'V'),
+    (0x116CA, 'X'),
+    (0x11700, 'V'),
+    (0x1171B, 'X'),
+    (0x1171D, 'V'),
+    (0x1172C, 'X'),
+    (0x11730, 'V'),
+    (0x11747, 'X'),
+    (0x11800, 'V'),
+    (0x1183C, 'X'),
+    (0x118A0, 'M', '𑣀'),
+    (0x118A1, 'M', '𑣁'),
+    (0x118A2, 'M', '𑣂'),
+    (0x118A3, 'M', '𑣃'),
+    (0x118A4, 'M', '𑣄'),
+    (0x118A5, 'M', '𑣅'),
+    (0x118A6, 'M', '𑣆'),
+    (0x118A7, 'M', '𑣇'),
+    (0x118A8, 'M', '𑣈'),
+    (0x118A9, 'M', '𑣉'),
+    (0x118AA, 'M', '𑣊'),
+    ]
+
+def _seg_58() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x118AB, 'M', '𑣋'),
+    (0x118AC, 'M', '𑣌'),
+    (0x118AD, 'M', '𑣍'),
+    (0x118AE, 'M', '𑣎'),
+    (0x118AF, 'M', '𑣏'),
+    (0x118B0, 'M', '𑣐'),
+    (0x118B1, 'M', '𑣑'),
+    (0x118B2, 'M', '𑣒'),
+    (0x118B3, 'M', '𑣓'),
+    (0x118B4, 'M', '𑣔'),
+    (0x118B5, 'M', '𑣕'),
+    (0x118B6, 'M', '𑣖'),
+    (0x118B7, 'M', '𑣗'),
+    (0x118B8, 'M', '𑣘'),
+    (0x118B9, 'M', '𑣙'),
+    (0x118BA, 'M', '𑣚'),
+    (0x118BB, 'M', '𑣛'),
+    (0x118BC, 'M', '𑣜'),
+    (0x118BD, 'M', '𑣝'),
+    (0x118BE, 'M', '𑣞'),
+    (0x118BF, 'M', '𑣟'),
+    (0x118C0, 'V'),
+    (0x118F3, 'X'),
+    (0x118FF, 'V'),
+    (0x11907, 'X'),
+    (0x11909, 'V'),
+    (0x1190A, 'X'),
+    (0x1190C, 'V'),
+    (0x11914, 'X'),
+    (0x11915, 'V'),
+    (0x11917, 'X'),
+    (0x11918, 'V'),
+    (0x11936, 'X'),
+    (0x11937, 'V'),
+    (0x11939, 'X'),
+    (0x1193B, 'V'),
+    (0x11947, 'X'),
+    (0x11950, 'V'),
+    (0x1195A, 'X'),
+    (0x119A0, 'V'),
+    (0x119A8, 'X'),
+    (0x119AA, 'V'),
+    (0x119D8, 'X'),
+    (0x119DA, 'V'),
+    (0x119E5, 'X'),
+    (0x11A00, 'V'),
+    (0x11A48, 'X'),
+    (0x11A50, 'V'),
+    (0x11AA3, 'X'),
+    (0x11AB0, 'V'),
+    (0x11AF9, 'X'),
+    (0x11B00, 'V'),
+    (0x11B0A, 'X'),
+    (0x11C00, 'V'),
+    (0x11C09, 'X'),
+    (0x11C0A, 'V'),
+    (0x11C37, 'X'),
+    (0x11C38, 'V'),
+    (0x11C46, 'X'),
+    (0x11C50, 'V'),
+    (0x11C6D, 'X'),
+    (0x11C70, 'V'),
+    (0x11C90, 'X'),
+    (0x11C92, 'V'),
+    (0x11CA8, 'X'),
+    (0x11CA9, 'V'),
+    (0x11CB7, 'X'),
+    (0x11D00, 'V'),
+    (0x11D07, 'X'),
+    (0x11D08, 'V'),
+    (0x11D0A, 'X'),
+    (0x11D0B, 'V'),
+    (0x11D37, 'X'),
+    (0x11D3A, 'V'),
+    (0x11D3B, 'X'),
+    (0x11D3C, 'V'),
+    (0x11D3E, 'X'),
+    (0x11D3F, 'V'),
+    (0x11D48, 'X'),
+    (0x11D50, 'V'),
+    (0x11D5A, 'X'),
+    (0x11D60, 'V'),
+    (0x11D66, 'X'),
+    (0x11D67, 'V'),
+    (0x11D69, 'X'),
+    (0x11D6A, 'V'),
+    (0x11D8F, 'X'),
+    (0x11D90, 'V'),
+    (0x11D92, 'X'),
+    (0x11D93, 'V'),
+    (0x11D99, 'X'),
+    (0x11DA0, 'V'),
+    (0x11DAA, 'X'),
+    (0x11EE0, 'V'),
+    (0x11EF9, 'X'),
+    (0x11F00, 'V'),
+    (0x11F11, 'X'),
+    (0x11F12, 'V'),
+    (0x11F3B, 'X'),
+    (0x11F3E, 'V'),
+    ]
+
+def _seg_59() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x11F5A, 'X'),
+    (0x11FB0, 'V'),
+    (0x11FB1, 'X'),
+    (0x11FC0, 'V'),
+    (0x11FF2, 'X'),
+    (0x11FFF, 'V'),
+    (0x1239A, 'X'),
+    (0x12400, 'V'),
+    (0x1246F, 'X'),
+    (0x12470, 'V'),
+    (0x12475, 'X'),
+    (0x12480, 'V'),
+    (0x12544, 'X'),
+    (0x12F90, 'V'),
+    (0x12FF3, 'X'),
+    (0x13000, 'V'),
+    (0x13430, 'X'),
+    (0x13440, 'V'),
+    (0x13456, 'X'),
+    (0x14400, 'V'),
+    (0x14647, 'X'),
+    (0x16800, 'V'),
+    (0x16A39, 'X'),
+    (0x16A40, 'V'),
+    (0x16A5F, 'X'),
+    (0x16A60, 'V'),
+    (0x16A6A, 'X'),
+    (0x16A6E, 'V'),
+    (0x16ABF, 'X'),
+    (0x16AC0, 'V'),
+    (0x16ACA, 'X'),
+    (0x16AD0, 'V'),
+    (0x16AEE, 'X'),
+    (0x16AF0, 'V'),
+    (0x16AF6, 'X'),
+    (0x16B00, 'V'),
+    (0x16B46, 'X'),
+    (0x16B50, 'V'),
+    (0x16B5A, 'X'),
+    (0x16B5B, 'V'),
+    (0x16B62, 'X'),
+    (0x16B63, 'V'),
+    (0x16B78, 'X'),
+    (0x16B7D, 'V'),
+    (0x16B90, 'X'),
+    (0x16E40, 'M', '𖹠'),
+    (0x16E41, 'M', '𖹡'),
+    (0x16E42, 'M', '𖹢'),
+    (0x16E43, 'M', '𖹣'),
+    (0x16E44, 'M', '𖹤'),
+    (0x16E45, 'M', '𖹥'),
+    (0x16E46, 'M', '𖹦'),
+    (0x16E47, 'M', '𖹧'),
+    (0x16E48, 'M', '𖹨'),
+    (0x16E49, 'M', '𖹩'),
+    (0x16E4A, 'M', '𖹪'),
+    (0x16E4B, 'M', '𖹫'),
+    (0x16E4C, 'M', '𖹬'),
+    (0x16E4D, 'M', '𖹭'),
+    (0x16E4E, 'M', '𖹮'),
+    (0x16E4F, 'M', '𖹯'),
+    (0x16E50, 'M', '𖹰'),
+    (0x16E51, 'M', '𖹱'),
+    (0x16E52, 'M', '𖹲'),
+    (0x16E53, 'M', '𖹳'),
+    (0x16E54, 'M', '𖹴'),
+    (0x16E55, 'M', '𖹵'),
+    (0x16E56, 'M', '𖹶'),
+    (0x16E57, 'M', '𖹷'),
+    (0x16E58, 'M', '𖹸'),
+    (0x16E59, 'M', '𖹹'),
+    (0x16E5A, 'M', '𖹺'),
+    (0x16E5B, 'M', '𖹻'),
+    (0x16E5C, 'M', '𖹼'),
+    (0x16E5D, 'M', '𖹽'),
+    (0x16E5E, 'M', '𖹾'),
+    (0x16E5F, 'M', '𖹿'),
+    (0x16E60, 'V'),
+    (0x16E9B, 'X'),
+    (0x16F00, 'V'),
+    (0x16F4B, 'X'),
+    (0x16F4F, 'V'),
+    (0x16F88, 'X'),
+    (0x16F8F, 'V'),
+    (0x16FA0, 'X'),
+    (0x16FE0, 'V'),
+    (0x16FE5, 'X'),
+    (0x16FF0, 'V'),
+    (0x16FF2, 'X'),
+    (0x17000, 'V'),
+    (0x187F8, 'X'),
+    (0x18800, 'V'),
+    (0x18CD6, 'X'),
+    (0x18D00, 'V'),
+    (0x18D09, 'X'),
+    (0x1AFF0, 'V'),
+    (0x1AFF4, 'X'),
+    (0x1AFF5, 'V'),
+    (0x1AFFC, 'X'),
+    (0x1AFFD, 'V'),
+    ]
+
+def _seg_60() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x1AFFF, 'X'),
+    (0x1B000, 'V'),
+    (0x1B123, 'X'),
+    (0x1B132, 'V'),
+    (0x1B133, 'X'),
+    (0x1B150, 'V'),
+    (0x1B153, 'X'),
+    (0x1B155, 'V'),
+    (0x1B156, 'X'),
+    (0x1B164, 'V'),
+    (0x1B168, 'X'),
+    (0x1B170, 'V'),
+    (0x1B2FC, 'X'),
+    (0x1BC00, 'V'),
+    (0x1BC6B, 'X'),
+    (0x1BC70, 'V'),
+    (0x1BC7D, 'X'),
+    (0x1BC80, 'V'),
+    (0x1BC89, 'X'),
+    (0x1BC90, 'V'),
+    (0x1BC9A, 'X'),
+    (0x1BC9C, 'V'),
+    (0x1BCA0, 'I'),
+    (0x1BCA4, 'X'),
+    (0x1CF00, 'V'),
+    (0x1CF2E, 'X'),
+    (0x1CF30, 'V'),
+    (0x1CF47, 'X'),
+    (0x1CF50, 'V'),
+    (0x1CFC4, 'X'),
+    (0x1D000, 'V'),
+    (0x1D0F6, 'X'),
+    (0x1D100, 'V'),
+    (0x1D127, 'X'),
+    (0x1D129, 'V'),
+    (0x1D15E, 'M', '𝅗𝅥'),
+    (0x1D15F, 'M', '𝅘𝅥'),
+    (0x1D160, 'M', '𝅘𝅥𝅮'),
+    (0x1D161, 'M', '𝅘𝅥𝅯'),
+    (0x1D162, 'M', '𝅘𝅥𝅰'),
+    (0x1D163, 'M', '𝅘𝅥𝅱'),
+    (0x1D164, 'M', '𝅘𝅥𝅲'),
+    (0x1D165, 'V'),
+    (0x1D173, 'X'),
+    (0x1D17B, 'V'),
+    (0x1D1BB, 'M', '𝆹𝅥'),
+    (0x1D1BC, 'M', '𝆺𝅥'),
+    (0x1D1BD, 'M', '𝆹𝅥𝅮'),
+    (0x1D1BE, 'M', '𝆺𝅥𝅮'),
+    (0x1D1BF, 'M', '𝆹𝅥𝅯'),
+    (0x1D1C0, 'M', '𝆺𝅥𝅯'),
+    (0x1D1C1, 'V'),
+    (0x1D1EB, 'X'),
+    (0x1D200, 'V'),
+    (0x1D246, 'X'),
+    (0x1D2C0, 'V'),
+    (0x1D2D4, 'X'),
+    (0x1D2E0, 'V'),
+    (0x1D2F4, 'X'),
+    (0x1D300, 'V'),
+    (0x1D357, 'X'),
+    (0x1D360, 'V'),
+    (0x1D379, 'X'),
+    (0x1D400, 'M', 'a'),
+    (0x1D401, 'M', 'b'),
+    (0x1D402, 'M', 'c'),
+    (0x1D403, 'M', 'd'),
+    (0x1D404, 'M', 'e'),
+    (0x1D405, 'M', 'f'),
+    (0x1D406, 'M', 'g'),
+    (0x1D407, 'M', 'h'),
+    (0x1D408, 'M', 'i'),
+    (0x1D409, 'M', 'j'),
+    (0x1D40A, 'M', 'k'),
+    (0x1D40B, 'M', 'l'),
+    (0x1D40C, 'M', 'm'),
+    (0x1D40D, 'M', 'n'),
+    (0x1D40E, 'M', 'o'),
+    (0x1D40F, 'M', 'p'),
+    (0x1D410, 'M', 'q'),
+    (0x1D411, 'M', 'r'),
+    (0x1D412, 'M', 's'),
+    (0x1D413, 'M', 't'),
+    (0x1D414, 'M', 'u'),
+    (0x1D415, 'M', 'v'),
+    (0x1D416, 'M', 'w'),
+    (0x1D417, 'M', 'x'),
+    (0x1D418, 'M', 'y'),
+    (0x1D419, 'M', 'z'),
+    (0x1D41A, 'M', 'a'),
+    (0x1D41B, 'M', 'b'),
+    (0x1D41C, 'M', 'c'),
+    (0x1D41D, 'M', 'd'),
+    (0x1D41E, 'M', 'e'),
+    (0x1D41F, 'M', 'f'),
+    (0x1D420, 'M', 'g'),
+    (0x1D421, 'M', 'h'),
+    (0x1D422, 'M', 'i'),
+    (0x1D423, 'M', 'j'),
+    (0x1D424, 'M', 'k'),
+    ]
+
+def _seg_61() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x1D425, 'M', 'l'),
+    (0x1D426, 'M', 'm'),
+    (0x1D427, 'M', 'n'),
+    (0x1D428, 'M', 'o'),
+    (0x1D429, 'M', 'p'),
+    (0x1D42A, 'M', 'q'),
+    (0x1D42B, 'M', 'r'),
+    (0x1D42C, 'M', 's'),
+    (0x1D42D, 'M', 't'),
+    (0x1D42E, 'M', 'u'),
+    (0x1D42F, 'M', 'v'),
+    (0x1D430, 'M', 'w'),
+    (0x1D431, 'M', 'x'),
+    (0x1D432, 'M', 'y'),
+    (0x1D433, 'M', 'z'),
+    (0x1D434, 'M', 'a'),
+    (0x1D435, 'M', 'b'),
+    (0x1D436, 'M', 'c'),
+    (0x1D437, 'M', 'd'),
+    (0x1D438, 'M', 'e'),
+    (0x1D439, 'M', 'f'),
+    (0x1D43A, 'M', 'g'),
+    (0x1D43B, 'M', 'h'),
+    (0x1D43C, 'M', 'i'),
+    (0x1D43D, 'M', 'j'),
+    (0x1D43E, 'M', 'k'),
+    (0x1D43F, 'M', 'l'),
+    (0x1D440, 'M', 'm'),
+    (0x1D441, 'M', 'n'),
+    (0x1D442, 'M', 'o'),
+    (0x1D443, 'M', 'p'),
+    (0x1D444, 'M', 'q'),
+    (0x1D445, 'M', 'r'),
+    (0x1D446, 'M', 's'),
+    (0x1D447, 'M', 't'),
+    (0x1D448, 'M', 'u'),
+    (0x1D449, 'M', 'v'),
+    (0x1D44A, 'M', 'w'),
+    (0x1D44B, 'M', 'x'),
+    (0x1D44C, 'M', 'y'),
+    (0x1D44D, 'M', 'z'),
+    (0x1D44E, 'M', 'a'),
+    (0x1D44F, 'M', 'b'),
+    (0x1D450, 'M', 'c'),
+    (0x1D451, 'M', 'd'),
+    (0x1D452, 'M', 'e'),
+    (0x1D453, 'M', 'f'),
+    (0x1D454, 'M', 'g'),
+    (0x1D455, 'X'),
+    (0x1D456, 'M', 'i'),
+    (0x1D457, 'M', 'j'),
+    (0x1D458, 'M', 'k'),
+    (0x1D459, 'M', 'l'),
+    (0x1D45A, 'M', 'm'),
+    (0x1D45B, 'M', 'n'),
+    (0x1D45C, 'M', 'o'),
+    (0x1D45D, 'M', 'p'),
+    (0x1D45E, 'M', 'q'),
+    (0x1D45F, 'M', 'r'),
+    (0x1D460, 'M', 's'),
+    (0x1D461, 'M', 't'),
+    (0x1D462, 'M', 'u'),
+    (0x1D463, 'M', 'v'),
+    (0x1D464, 'M', 'w'),
+    (0x1D465, 'M', 'x'),
+    (0x1D466, 'M', 'y'),
+    (0x1D467, 'M', 'z'),
+    (0x1D468, 'M', 'a'),
+    (0x1D469, 'M', 'b'),
+    (0x1D46A, 'M', 'c'),
+    (0x1D46B, 'M', 'd'),
+    (0x1D46C, 'M', 'e'),
+    (0x1D46D, 'M', 'f'),
+    (0x1D46E, 'M', 'g'),
+    (0x1D46F, 'M', 'h'),
+    (0x1D470, 'M', 'i'),
+    (0x1D471, 'M', 'j'),
+    (0x1D472, 'M', 'k'),
+    (0x1D473, 'M', 'l'),
+    (0x1D474, 'M', 'm'),
+    (0x1D475, 'M', 'n'),
+    (0x1D476, 'M', 'o'),
+    (0x1D477, 'M', 'p'),
+    (0x1D478, 'M', 'q'),
+    (0x1D479, 'M', 'r'),
+    (0x1D47A, 'M', 's'),
+    (0x1D47B, 'M', 't'),
+    (0x1D47C, 'M', 'u'),
+    (0x1D47D, 'M', 'v'),
+    (0x1D47E, 'M', 'w'),
+    (0x1D47F, 'M', 'x'),
+    (0x1D480, 'M', 'y'),
+    (0x1D481, 'M', 'z'),
+    (0x1D482, 'M', 'a'),
+    (0x1D483, 'M', 'b'),
+    (0x1D484, 'M', 'c'),
+    (0x1D485, 'M', 'd'),
+    (0x1D486, 'M', 'e'),
+    (0x1D487, 'M', 'f'),
+    (0x1D488, 'M', 'g'),
+    ]
+
+def _seg_62() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x1D489, 'M', 'h'),
+    (0x1D48A, 'M', 'i'),
+    (0x1D48B, 'M', 'j'),
+    (0x1D48C, 'M', 'k'),
+    (0x1D48D, 'M', 'l'),
+    (0x1D48E, 'M', 'm'),
+    (0x1D48F, 'M', 'n'),
+    (0x1D490, 'M', 'o'),
+    (0x1D491, 'M', 'p'),
+    (0x1D492, 'M', 'q'),
+    (0x1D493, 'M', 'r'),
+    (0x1D494, 'M', 's'),
+    (0x1D495, 'M', 't'),
+    (0x1D496, 'M', 'u'),
+    (0x1D497, 'M', 'v'),
+    (0x1D498, 'M', 'w'),
+    (0x1D499, 'M', 'x'),
+    (0x1D49A, 'M', 'y'),
+    (0x1D49B, 'M', 'z'),
+    (0x1D49C, 'M', 'a'),
+    (0x1D49D, 'X'),
+    (0x1D49E, 'M', 'c'),
+    (0x1D49F, 'M', 'd'),
+    (0x1D4A0, 'X'),
+    (0x1D4A2, 'M', 'g'),
+    (0x1D4A3, 'X'),
+    (0x1D4A5, 'M', 'j'),
+    (0x1D4A6, 'M', 'k'),
+    (0x1D4A7, 'X'),
+    (0x1D4A9, 'M', 'n'),
+    (0x1D4AA, 'M', 'o'),
+    (0x1D4AB, 'M', 'p'),
+    (0x1D4AC, 'M', 'q'),
+    (0x1D4AD, 'X'),
+    (0x1D4AE, 'M', 's'),
+    (0x1D4AF, 'M', 't'),
+    (0x1D4B0, 'M', 'u'),
+    (0x1D4B1, 'M', 'v'),
+    (0x1D4B2, 'M', 'w'),
+    (0x1D4B3, 'M', 'x'),
+    (0x1D4B4, 'M', 'y'),
+    (0x1D4B5, 'M', 'z'),
+    (0x1D4B6, 'M', 'a'),
+    (0x1D4B7, 'M', 'b'),
+    (0x1D4B8, 'M', 'c'),
+    (0x1D4B9, 'M', 'd'),
+    (0x1D4BA, 'X'),
+    (0x1D4BB, 'M', 'f'),
+    (0x1D4BC, 'X'),
+    (0x1D4BD, 'M', 'h'),
+    (0x1D4BE, 'M', 'i'),
+    (0x1D4BF, 'M', 'j'),
+    (0x1D4C0, 'M', 'k'),
+    (0x1D4C1, 'M', 'l'),
+    (0x1D4C2, 'M', 'm'),
+    (0x1D4C3, 'M', 'n'),
+    (0x1D4C4, 'X'),
+    (0x1D4C5, 'M', 'p'),
+    (0x1D4C6, 'M', 'q'),
+    (0x1D4C7, 'M', 'r'),
+    (0x1D4C8, 'M', 's'),
+    (0x1D4C9, 'M', 't'),
+    (0x1D4CA, 'M', 'u'),
+    (0x1D4CB, 'M', 'v'),
+    (0x1D4CC, 'M', 'w'),
+    (0x1D4CD, 'M', 'x'),
+    (0x1D4CE, 'M', 'y'),
+    (0x1D4CF, 'M', 'z'),
+    (0x1D4D0, 'M', 'a'),
+    (0x1D4D1, 'M', 'b'),
+    (0x1D4D2, 'M', 'c'),
+    (0x1D4D3, 'M', 'd'),
+    (0x1D4D4, 'M', 'e'),
+    (0x1D4D5, 'M', 'f'),
+    (0x1D4D6, 'M', 'g'),
+    (0x1D4D7, 'M', 'h'),
+    (0x1D4D8, 'M', 'i'),
+    (0x1D4D9, 'M', 'j'),
+    (0x1D4DA, 'M', 'k'),
+    (0x1D4DB, 'M', 'l'),
+    (0x1D4DC, 'M', 'm'),
+    (0x1D4DD, 'M', 'n'),
+    (0x1D4DE, 'M', 'o'),
+    (0x1D4DF, 'M', 'p'),
+    (0x1D4E0, 'M', 'q'),
+    (0x1D4E1, 'M', 'r'),
+    (0x1D4E2, 'M', 's'),
+    (0x1D4E3, 'M', 't'),
+    (0x1D4E4, 'M', 'u'),
+    (0x1D4E5, 'M', 'v'),
+    (0x1D4E6, 'M', 'w'),
+    (0x1D4E7, 'M', 'x'),
+    (0x1D4E8, 'M', 'y'),
+    (0x1D4E9, 'M', 'z'),
+    (0x1D4EA, 'M', 'a'),
+    (0x1D4EB, 'M', 'b'),
+    (0x1D4EC, 'M', 'c'),
+    (0x1D4ED, 'M', 'd'),
+    (0x1D4EE, 'M', 'e'),
+    (0x1D4EF, 'M', 'f'),
+    ]
+
+def _seg_63() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x1D4F0, 'M', 'g'),
+    (0x1D4F1, 'M', 'h'),
+    (0x1D4F2, 'M', 'i'),
+    (0x1D4F3, 'M', 'j'),
+    (0x1D4F4, 'M', 'k'),
+    (0x1D4F5, 'M', 'l'),
+    (0x1D4F6, 'M', 'm'),
+    (0x1D4F7, 'M', 'n'),
+    (0x1D4F8, 'M', 'o'),
+    (0x1D4F9, 'M', 'p'),
+    (0x1D4FA, 'M', 'q'),
+    (0x1D4FB, 'M', 'r'),
+    (0x1D4FC, 'M', 's'),
+    (0x1D4FD, 'M', 't'),
+    (0x1D4FE, 'M', 'u'),
+    (0x1D4FF, 'M', 'v'),
+    (0x1D500, 'M', 'w'),
+    (0x1D501, 'M', 'x'),
+    (0x1D502, 'M', 'y'),
+    (0x1D503, 'M', 'z'),
+    (0x1D504, 'M', 'a'),
+    (0x1D505, 'M', 'b'),
+    (0x1D506, 'X'),
+    (0x1D507, 'M', 'd'),
+    (0x1D508, 'M', 'e'),
+    (0x1D509, 'M', 'f'),
+    (0x1D50A, 'M', 'g'),
+    (0x1D50B, 'X'),
+    (0x1D50D, 'M', 'j'),
+    (0x1D50E, 'M', 'k'),
+    (0x1D50F, 'M', 'l'),
+    (0x1D510, 'M', 'm'),
+    (0x1D511, 'M', 'n'),
+    (0x1D512, 'M', 'o'),
+    (0x1D513, 'M', 'p'),
+    (0x1D514, 'M', 'q'),
+    (0x1D515, 'X'),
+    (0x1D516, 'M', 's'),
+    (0x1D517, 'M', 't'),
+    (0x1D518, 'M', 'u'),
+    (0x1D519, 'M', 'v'),
+    (0x1D51A, 'M', 'w'),
+    (0x1D51B, 'M', 'x'),
+    (0x1D51C, 'M', 'y'),
+    (0x1D51D, 'X'),
+    (0x1D51E, 'M', 'a'),
+    (0x1D51F, 'M', 'b'),
+    (0x1D520, 'M', 'c'),
+    (0x1D521, 'M', 'd'),
+    (0x1D522, 'M', 'e'),
+    (0x1D523, 'M', 'f'),
+    (0x1D524, 'M', 'g'),
+    (0x1D525, 'M', 'h'),
+    (0x1D526, 'M', 'i'),
+    (0x1D527, 'M', 'j'),
+    (0x1D528, 'M', 'k'),
+    (0x1D529, 'M', 'l'),
+    (0x1D52A, 'M', 'm'),
+    (0x1D52B, 'M', 'n'),
+    (0x1D52C, 'M', 'o'),
+    (0x1D52D, 'M', 'p'),
+    (0x1D52E, 'M', 'q'),
+    (0x1D52F, 'M', 'r'),
+    (0x1D530, 'M', 's'),
+    (0x1D531, 'M', 't'),
+    (0x1D532, 'M', 'u'),
+    (0x1D533, 'M', 'v'),
+    (0x1D534, 'M', 'w'),
+    (0x1D535, 'M', 'x'),
+    (0x1D536, 'M', 'y'),
+    (0x1D537, 'M', 'z'),
+    (0x1D538, 'M', 'a'),
+    (0x1D539, 'M', 'b'),
+    (0x1D53A, 'X'),
+    (0x1D53B, 'M', 'd'),
+    (0x1D53C, 'M', 'e'),
+    (0x1D53D, 'M', 'f'),
+    (0x1D53E, 'M', 'g'),
+    (0x1D53F, 'X'),
+    (0x1D540, 'M', 'i'),
+    (0x1D541, 'M', 'j'),
+    (0x1D542, 'M', 'k'),
+    (0x1D543, 'M', 'l'),
+    (0x1D544, 'M', 'm'),
+    (0x1D545, 'X'),
+    (0x1D546, 'M', 'o'),
+    (0x1D547, 'X'),
+    (0x1D54A, 'M', 's'),
+    (0x1D54B, 'M', 't'),
+    (0x1D54C, 'M', 'u'),
+    (0x1D54D, 'M', 'v'),
+    (0x1D54E, 'M', 'w'),
+    (0x1D54F, 'M', 'x'),
+    (0x1D550, 'M', 'y'),
+    (0x1D551, 'X'),
+    (0x1D552, 'M', 'a'),
+    (0x1D553, 'M', 'b'),
+    (0x1D554, 'M', 'c'),
+    (0x1D555, 'M', 'd'),
+    (0x1D556, 'M', 'e'),
+    ]
+
+def _seg_64() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x1D557, 'M', 'f'),
+    (0x1D558, 'M', 'g'),
+    (0x1D559, 'M', 'h'),
+    (0x1D55A, 'M', 'i'),
+    (0x1D55B, 'M', 'j'),
+    (0x1D55C, 'M', 'k'),
+    (0x1D55D, 'M', 'l'),
+    (0x1D55E, 'M', 'm'),
+    (0x1D55F, 'M', 'n'),
+    (0x1D560, 'M', 'o'),
+    (0x1D561, 'M', 'p'),
+    (0x1D562, 'M', 'q'),
+    (0x1D563, 'M', 'r'),
+    (0x1D564, 'M', 's'),
+    (0x1D565, 'M', 't'),
+    (0x1D566, 'M', 'u'),
+    (0x1D567, 'M', 'v'),
+    (0x1D568, 'M', 'w'),
+    (0x1D569, 'M', 'x'),
+    (0x1D56A, 'M', 'y'),
+    (0x1D56B, 'M', 'z'),
+    (0x1D56C, 'M', 'a'),
+    (0x1D56D, 'M', 'b'),
+    (0x1D56E, 'M', 'c'),
+    (0x1D56F, 'M', 'd'),
+    (0x1D570, 'M', 'e'),
+    (0x1D571, 'M', 'f'),
+    (0x1D572, 'M', 'g'),
+    (0x1D573, 'M', 'h'),
+    (0x1D574, 'M', 'i'),
+    (0x1D575, 'M', 'j'),
+    (0x1D576, 'M', 'k'),
+    (0x1D577, 'M', 'l'),
+    (0x1D578, 'M', 'm'),
+    (0x1D579, 'M', 'n'),
+    (0x1D57A, 'M', 'o'),
+    (0x1D57B, 'M', 'p'),
+    (0x1D57C, 'M', 'q'),
+    (0x1D57D, 'M', 'r'),
+    (0x1D57E, 'M', 's'),
+    (0x1D57F, 'M', 't'),
+    (0x1D580, 'M', 'u'),
+    (0x1D581, 'M', 'v'),
+    (0x1D582, 'M', 'w'),
+    (0x1D583, 'M', 'x'),
+    (0x1D584, 'M', 'y'),
+    (0x1D585, 'M', 'z'),
+    (0x1D586, 'M', 'a'),
+    (0x1D587, 'M', 'b'),
+    (0x1D588, 'M', 'c'),
+    (0x1D589, 'M', 'd'),
+    (0x1D58A, 'M', 'e'),
+    (0x1D58B, 'M', 'f'),
+    (0x1D58C, 'M', 'g'),
+    (0x1D58D, 'M', 'h'),
+    (0x1D58E, 'M', 'i'),
+    (0x1D58F, 'M', 'j'),
+    (0x1D590, 'M', 'k'),
+    (0x1D591, 'M', 'l'),
+    (0x1D592, 'M', 'm'),
+    (0x1D593, 'M', 'n'),
+    (0x1D594, 'M', 'o'),
+    (0x1D595, 'M', 'p'),
+    (0x1D596, 'M', 'q'),
+    (0x1D597, 'M', 'r'),
+    (0x1D598, 'M', 's'),
+    (0x1D599, 'M', 't'),
+    (0x1D59A, 'M', 'u'),
+    (0x1D59B, 'M', 'v'),
+    (0x1D59C, 'M', 'w'),
+    (0x1D59D, 'M', 'x'),
+    (0x1D59E, 'M', 'y'),
+    (0x1D59F, 'M', 'z'),
+    (0x1D5A0, 'M', 'a'),
+    (0x1D5A1, 'M', 'b'),
+    (0x1D5A2, 'M', 'c'),
+    (0x1D5A3, 'M', 'd'),
+    (0x1D5A4, 'M', 'e'),
+    (0x1D5A5, 'M', 'f'),
+    (0x1D5A6, 'M', 'g'),
+    (0x1D5A7, 'M', 'h'),
+    (0x1D5A8, 'M', 'i'),
+    (0x1D5A9, 'M', 'j'),
+    (0x1D5AA, 'M', 'k'),
+    (0x1D5AB, 'M', 'l'),
+    (0x1D5AC, 'M', 'm'),
+    (0x1D5AD, 'M', 'n'),
+    (0x1D5AE, 'M', 'o'),
+    (0x1D5AF, 'M', 'p'),
+    (0x1D5B0, 'M', 'q'),
+    (0x1D5B1, 'M', 'r'),
+    (0x1D5B2, 'M', 's'),
+    (0x1D5B3, 'M', 't'),
+    (0x1D5B4, 'M', 'u'),
+    (0x1D5B5, 'M', 'v'),
+    (0x1D5B6, 'M', 'w'),
+    (0x1D5B7, 'M', 'x'),
+    (0x1D5B8, 'M', 'y'),
+    (0x1D5B9, 'M', 'z'),
+    (0x1D5BA, 'M', 'a'),
+    ]
+
+def _seg_65() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x1D5BB, 'M', 'b'),
+    (0x1D5BC, 'M', 'c'),
+    (0x1D5BD, 'M', 'd'),
+    (0x1D5BE, 'M', 'e'),
+    (0x1D5BF, 'M', 'f'),
+    (0x1D5C0, 'M', 'g'),
+    (0x1D5C1, 'M', 'h'),
+    (0x1D5C2, 'M', 'i'),
+    (0x1D5C3, 'M', 'j'),
+    (0x1D5C4, 'M', 'k'),
+    (0x1D5C5, 'M', 'l'),
+    (0x1D5C6, 'M', 'm'),
+    (0x1D5C7, 'M', 'n'),
+    (0x1D5C8, 'M', 'o'),
+    (0x1D5C9, 'M', 'p'),
+    (0x1D5CA, 'M', 'q'),
+    (0x1D5CB, 'M', 'r'),
+    (0x1D5CC, 'M', 's'),
+    (0x1D5CD, 'M', 't'),
+    (0x1D5CE, 'M', 'u'),
+    (0x1D5CF, 'M', 'v'),
+    (0x1D5D0, 'M', 'w'),
+    (0x1D5D1, 'M', 'x'),
+    (0x1D5D2, 'M', 'y'),
+    (0x1D5D3, 'M', 'z'),
+    (0x1D5D4, 'M', 'a'),
+    (0x1D5D5, 'M', 'b'),
+    (0x1D5D6, 'M', 'c'),
+    (0x1D5D7, 'M', 'd'),
+    (0x1D5D8, 'M', 'e'),
+    (0x1D5D9, 'M', 'f'),
+    (0x1D5DA, 'M', 'g'),
+    (0x1D5DB, 'M', 'h'),
+    (0x1D5DC, 'M', 'i'),
+    (0x1D5DD, 'M', 'j'),
+    (0x1D5DE, 'M', 'k'),
+    (0x1D5DF, 'M', 'l'),
+    (0x1D5E0, 'M', 'm'),
+    (0x1D5E1, 'M', 'n'),
+    (0x1D5E2, 'M', 'o'),
+    (0x1D5E3, 'M', 'p'),
+    (0x1D5E4, 'M', 'q'),
+    (0x1D5E5, 'M', 'r'),
+    (0x1D5E6, 'M', 's'),
+    (0x1D5E7, 'M', 't'),
+    (0x1D5E8, 'M', 'u'),
+    (0x1D5E9, 'M', 'v'),
+    (0x1D5EA, 'M', 'w'),
+    (0x1D5EB, 'M', 'x'),
+    (0x1D5EC, 'M', 'y'),
+    (0x1D5ED, 'M', 'z'),
+    (0x1D5EE, 'M', 'a'),
+    (0x1D5EF, 'M', 'b'),
+    (0x1D5F0, 'M', 'c'),
+    (0x1D5F1, 'M', 'd'),
+    (0x1D5F2, 'M', 'e'),
+    (0x1D5F3, 'M', 'f'),
+    (0x1D5F4, 'M', 'g'),
+    (0x1D5F5, 'M', 'h'),
+    (0x1D5F6, 'M', 'i'),
+    (0x1D5F7, 'M', 'j'),
+    (0x1D5F8, 'M', 'k'),
+    (0x1D5F9, 'M', 'l'),
+    (0x1D5FA, 'M', 'm'),
+    (0x1D5FB, 'M', 'n'),
+    (0x1D5FC, 'M', 'o'),
+    (0x1D5FD, 'M', 'p'),
+    (0x1D5FE, 'M', 'q'),
+    (0x1D5FF, 'M', 'r'),
+    (0x1D600, 'M', 's'),
+    (0x1D601, 'M', 't'),
+    (0x1D602, 'M', 'u'),
+    (0x1D603, 'M', 'v'),
+    (0x1D604, 'M', 'w'),
+    (0x1D605, 'M', 'x'),
+    (0x1D606, 'M', 'y'),
+    (0x1D607, 'M', 'z'),
+    (0x1D608, 'M', 'a'),
+    (0x1D609, 'M', 'b'),
+    (0x1D60A, 'M', 'c'),
+    (0x1D60B, 'M', 'd'),
+    (0x1D60C, 'M', 'e'),
+    (0x1D60D, 'M', 'f'),
+    (0x1D60E, 'M', 'g'),
+    (0x1D60F, 'M', 'h'),
+    (0x1D610, 'M', 'i'),
+    (0x1D611, 'M', 'j'),
+    (0x1D612, 'M', 'k'),
+    (0x1D613, 'M', 'l'),
+    (0x1D614, 'M', 'm'),
+    (0x1D615, 'M', 'n'),
+    (0x1D616, 'M', 'o'),
+    (0x1D617, 'M', 'p'),
+    (0x1D618, 'M', 'q'),
+    (0x1D619, 'M', 'r'),
+    (0x1D61A, 'M', 's'),
+    (0x1D61B, 'M', 't'),
+    (0x1D61C, 'M', 'u'),
+    (0x1D61D, 'M', 'v'),
+    (0x1D61E, 'M', 'w'),
+    ]
+
+def _seg_66() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x1D61F, 'M', 'x'),
+    (0x1D620, 'M', 'y'),
+    (0x1D621, 'M', 'z'),
+    (0x1D622, 'M', 'a'),
+    (0x1D623, 'M', 'b'),
+    (0x1D624, 'M', 'c'),
+    (0x1D625, 'M', 'd'),
+    (0x1D626, 'M', 'e'),
+    (0x1D627, 'M', 'f'),
+    (0x1D628, 'M', 'g'),
+    (0x1D629, 'M', 'h'),
+    (0x1D62A, 'M', 'i'),
+    (0x1D62B, 'M', 'j'),
+    (0x1D62C, 'M', 'k'),
+    (0x1D62D, 'M', 'l'),
+    (0x1D62E, 'M', 'm'),
+    (0x1D62F, 'M', 'n'),
+    (0x1D630, 'M', 'o'),
+    (0x1D631, 'M', 'p'),
+    (0x1D632, 'M', 'q'),
+    (0x1D633, 'M', 'r'),
+    (0x1D634, 'M', 's'),
+    (0x1D635, 'M', 't'),
+    (0x1D636, 'M', 'u'),
+    (0x1D637, 'M', 'v'),
+    (0x1D638, 'M', 'w'),
+    (0x1D639, 'M', 'x'),
+    (0x1D63A, 'M', 'y'),
+    (0x1D63B, 'M', 'z'),
+    (0x1D63C, 'M', 'a'),
+    (0x1D63D, 'M', 'b'),
+    (0x1D63E, 'M', 'c'),
+    (0x1D63F, 'M', 'd'),
+    (0x1D640, 'M', 'e'),
+    (0x1D641, 'M', 'f'),
+    (0x1D642, 'M', 'g'),
+    (0x1D643, 'M', 'h'),
+    (0x1D644, 'M', 'i'),
+    (0x1D645, 'M', 'j'),
+    (0x1D646, 'M', 'k'),
+    (0x1D647, 'M', 'l'),
+    (0x1D648, 'M', 'm'),
+    (0x1D649, 'M', 'n'),
+    (0x1D64A, 'M', 'o'),
+    (0x1D64B, 'M', 'p'),
+    (0x1D64C, 'M', 'q'),
+    (0x1D64D, 'M', 'r'),
+    (0x1D64E, 'M', 's'),
+    (0x1D64F, 'M', 't'),
+    (0x1D650, 'M', 'u'),
+    (0x1D651, 'M', 'v'),
+    (0x1D652, 'M', 'w'),
+    (0x1D653, 'M', 'x'),
+    (0x1D654, 'M', 'y'),
+    (0x1D655, 'M', 'z'),
+    (0x1D656, 'M', 'a'),
+    (0x1D657, 'M', 'b'),
+    (0x1D658, 'M', 'c'),
+    (0x1D659, 'M', 'd'),
+    (0x1D65A, 'M', 'e'),
+    (0x1D65B, 'M', 'f'),
+    (0x1D65C, 'M', 'g'),
+    (0x1D65D, 'M', 'h'),
+    (0x1D65E, 'M', 'i'),
+    (0x1D65F, 'M', 'j'),
+    (0x1D660, 'M', 'k'),
+    (0x1D661, 'M', 'l'),
+    (0x1D662, 'M', 'm'),
+    (0x1D663, 'M', 'n'),
+    (0x1D664, 'M', 'o'),
+    (0x1D665, 'M', 'p'),
+    (0x1D666, 'M', 'q'),
+    (0x1D667, 'M', 'r'),
+    (0x1D668, 'M', 's'),
+    (0x1D669, 'M', 't'),
+    (0x1D66A, 'M', 'u'),
+    (0x1D66B, 'M', 'v'),
+    (0x1D66C, 'M', 'w'),
+    (0x1D66D, 'M', 'x'),
+    (0x1D66E, 'M', 'y'),
+    (0x1D66F, 'M', 'z'),
+    (0x1D670, 'M', 'a'),
+    (0x1D671, 'M', 'b'),
+    (0x1D672, 'M', 'c'),
+    (0x1D673, 'M', 'd'),
+    (0x1D674, 'M', 'e'),
+    (0x1D675, 'M', 'f'),
+    (0x1D676, 'M', 'g'),
+    (0x1D677, 'M', 'h'),
+    (0x1D678, 'M', 'i'),
+    (0x1D679, 'M', 'j'),
+    (0x1D67A, 'M', 'k'),
+    (0x1D67B, 'M', 'l'),
+    (0x1D67C, 'M', 'm'),
+    (0x1D67D, 'M', 'n'),
+    (0x1D67E, 'M', 'o'),
+    (0x1D67F, 'M', 'p'),
+    (0x1D680, 'M', 'q'),
+    (0x1D681, 'M', 'r'),
+    (0x1D682, 'M', 's'),
+    ]
+
+def _seg_67() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x1D683, 'M', 't'),
+    (0x1D684, 'M', 'u'),
+    (0x1D685, 'M', 'v'),
+    (0x1D686, 'M', 'w'),
+    (0x1D687, 'M', 'x'),
+    (0x1D688, 'M', 'y'),
+    (0x1D689, 'M', 'z'),
+    (0x1D68A, 'M', 'a'),
+    (0x1D68B, 'M', 'b'),
+    (0x1D68C, 'M', 'c'),
+    (0x1D68D, 'M', 'd'),
+    (0x1D68E, 'M', 'e'),
+    (0x1D68F, 'M', 'f'),
+    (0x1D690, 'M', 'g'),
+    (0x1D691, 'M', 'h'),
+    (0x1D692, 'M', 'i'),
+    (0x1D693, 'M', 'j'),
+    (0x1D694, 'M', 'k'),
+    (0x1D695, 'M', 'l'),
+    (0x1D696, 'M', 'm'),
+    (0x1D697, 'M', 'n'),
+    (0x1D698, 'M', 'o'),
+    (0x1D699, 'M', 'p'),
+    (0x1D69A, 'M', 'q'),
+    (0x1D69B, 'M', 'r'),
+    (0x1D69C, 'M', 's'),
+    (0x1D69D, 'M', 't'),
+    (0x1D69E, 'M', 'u'),
+    (0x1D69F, 'M', 'v'),
+    (0x1D6A0, 'M', 'w'),
+    (0x1D6A1, 'M', 'x'),
+    (0x1D6A2, 'M', 'y'),
+    (0x1D6A3, 'M', 'z'),
+    (0x1D6A4, 'M', 'ı'),
+    (0x1D6A5, 'M', 'ȷ'),
+    (0x1D6A6, 'X'),
+    (0x1D6A8, 'M', 'α'),
+    (0x1D6A9, 'M', 'β'),
+    (0x1D6AA, 'M', 'γ'),
+    (0x1D6AB, 'M', 'δ'),
+    (0x1D6AC, 'M', 'ε'),
+    (0x1D6AD, 'M', 'ζ'),
+    (0x1D6AE, 'M', 'η'),
+    (0x1D6AF, 'M', 'θ'),
+    (0x1D6B0, 'M', 'ι'),
+    (0x1D6B1, 'M', 'κ'),
+    (0x1D6B2, 'M', 'λ'),
+    (0x1D6B3, 'M', 'μ'),
+    (0x1D6B4, 'M', 'ν'),
+    (0x1D6B5, 'M', 'ξ'),
+    (0x1D6B6, 'M', 'ο'),
+    (0x1D6B7, 'M', 'π'),
+    (0x1D6B8, 'M', 'ρ'),
+    (0x1D6B9, 'M', 'θ'),
+    (0x1D6BA, 'M', 'σ'),
+    (0x1D6BB, 'M', 'τ'),
+    (0x1D6BC, 'M', 'υ'),
+    (0x1D6BD, 'M', 'φ'),
+    (0x1D6BE, 'M', 'χ'),
+    (0x1D6BF, 'M', 'ψ'),
+    (0x1D6C0, 'M', 'ω'),
+    (0x1D6C1, 'M', '∇'),
+    (0x1D6C2, 'M', 'α'),
+    (0x1D6C3, 'M', 'β'),
+    (0x1D6C4, 'M', 'γ'),
+    (0x1D6C5, 'M', 'δ'),
+    (0x1D6C6, 'M', 'ε'),
+    (0x1D6C7, 'M', 'ζ'),
+    (0x1D6C8, 'M', 'η'),
+    (0x1D6C9, 'M', 'θ'),
+    (0x1D6CA, 'M', 'ι'),
+    (0x1D6CB, 'M', 'κ'),
+    (0x1D6CC, 'M', 'λ'),
+    (0x1D6CD, 'M', 'μ'),
+    (0x1D6CE, 'M', 'ν'),
+    (0x1D6CF, 'M', 'ξ'),
+    (0x1D6D0, 'M', 'ο'),
+    (0x1D6D1, 'M', 'π'),
+    (0x1D6D2, 'M', 'ρ'),
+    (0x1D6D3, 'M', 'σ'),
+    (0x1D6D5, 'M', 'τ'),
+    (0x1D6D6, 'M', 'υ'),
+    (0x1D6D7, 'M', 'φ'),
+    (0x1D6D8, 'M', 'χ'),
+    (0x1D6D9, 'M', 'ψ'),
+    (0x1D6DA, 'M', 'ω'),
+    (0x1D6DB, 'M', '∂'),
+    (0x1D6DC, 'M', 'ε'),
+    (0x1D6DD, 'M', 'θ'),
+    (0x1D6DE, 'M', 'κ'),
+    (0x1D6DF, 'M', 'φ'),
+    (0x1D6E0, 'M', 'ρ'),
+    (0x1D6E1, 'M', 'π'),
+    (0x1D6E2, 'M', 'α'),
+    (0x1D6E3, 'M', 'β'),
+    (0x1D6E4, 'M', 'γ'),
+    (0x1D6E5, 'M', 'δ'),
+    (0x1D6E6, 'M', 'ε'),
+    (0x1D6E7, 'M', 'ζ'),
+    (0x1D6E8, 'M', 'η'),
+    ]
+
+def _seg_68() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x1D6E9, 'M', 'θ'),
+    (0x1D6EA, 'M', 'ι'),
+    (0x1D6EB, 'M', 'κ'),
+    (0x1D6EC, 'M', 'λ'),
+    (0x1D6ED, 'M', 'μ'),
+    (0x1D6EE, 'M', 'ν'),
+    (0x1D6EF, 'M', 'ξ'),
+    (0x1D6F0, 'M', 'ο'),
+    (0x1D6F1, 'M', 'π'),
+    (0x1D6F2, 'M', 'ρ'),
+    (0x1D6F3, 'M', 'θ'),
+    (0x1D6F4, 'M', 'σ'),
+    (0x1D6F5, 'M', 'τ'),
+    (0x1D6F6, 'M', 'υ'),
+    (0x1D6F7, 'M', 'φ'),
+    (0x1D6F8, 'M', 'χ'),
+    (0x1D6F9, 'M', 'ψ'),
+    (0x1D6FA, 'M', 'ω'),
+    (0x1D6FB, 'M', '∇'),
+    (0x1D6FC, 'M', 'α'),
+    (0x1D6FD, 'M', 'β'),
+    (0x1D6FE, 'M', 'γ'),
+    (0x1D6FF, 'M', 'δ'),
+    (0x1D700, 'M', 'ε'),
+    (0x1D701, 'M', 'ζ'),
+    (0x1D702, 'M', 'η'),
+    (0x1D703, 'M', 'θ'),
+    (0x1D704, 'M', 'ι'),
+    (0x1D705, 'M', 'κ'),
+    (0x1D706, 'M', 'λ'),
+    (0x1D707, 'M', 'μ'),
+    (0x1D708, 'M', 'ν'),
+    (0x1D709, 'M', 'ξ'),
+    (0x1D70A, 'M', 'ο'),
+    (0x1D70B, 'M', 'π'),
+    (0x1D70C, 'M', 'ρ'),
+    (0x1D70D, 'M', 'σ'),
+    (0x1D70F, 'M', 'τ'),
+    (0x1D710, 'M', 'υ'),
+    (0x1D711, 'M', 'φ'),
+    (0x1D712, 'M', 'χ'),
+    (0x1D713, 'M', 'ψ'),
+    (0x1D714, 'M', 'ω'),
+    (0x1D715, 'M', '∂'),
+    (0x1D716, 'M', 'ε'),
+    (0x1D717, 'M', 'θ'),
+    (0x1D718, 'M', 'κ'),
+    (0x1D719, 'M', 'φ'),
+    (0x1D71A, 'M', 'ρ'),
+    (0x1D71B, 'M', 'π'),
+    (0x1D71C, 'M', 'α'),
+    (0x1D71D, 'M', 'β'),
+    (0x1D71E, 'M', 'γ'),
+    (0x1D71F, 'M', 'δ'),
+    (0x1D720, 'M', 'ε'),
+    (0x1D721, 'M', 'ζ'),
+    (0x1D722, 'M', 'η'),
+    (0x1D723, 'M', 'θ'),
+    (0x1D724, 'M', 'ι'),
+    (0x1D725, 'M', 'κ'),
+    (0x1D726, 'M', 'λ'),
+    (0x1D727, 'M', 'μ'),
+    (0x1D728, 'M', 'ν'),
+    (0x1D729, 'M', 'ξ'),
+    (0x1D72A, 'M', 'ο'),
+    (0x1D72B, 'M', 'π'),
+    (0x1D72C, 'M', 'ρ'),
+    (0x1D72D, 'M', 'θ'),
+    (0x1D72E, 'M', 'σ'),
+    (0x1D72F, 'M', 'τ'),
+    (0x1D730, 'M', 'υ'),
+    (0x1D731, 'M', 'φ'),
+    (0x1D732, 'M', 'χ'),
+    (0x1D733, 'M', 'ψ'),
+    (0x1D734, 'M', 'ω'),
+    (0x1D735, 'M', '∇'),
+    (0x1D736, 'M', 'α'),
+    (0x1D737, 'M', 'β'),
+    (0x1D738, 'M', 'γ'),
+    (0x1D739, 'M', 'δ'),
+    (0x1D73A, 'M', 'ε'),
+    (0x1D73B, 'M', 'ζ'),
+    (0x1D73C, 'M', 'η'),
+    (0x1D73D, 'M', 'θ'),
+    (0x1D73E, 'M', 'ι'),
+    (0x1D73F, 'M', 'κ'),
+    (0x1D740, 'M', 'λ'),
+    (0x1D741, 'M', 'μ'),
+    (0x1D742, 'M', 'ν'),
+    (0x1D743, 'M', 'ξ'),
+    (0x1D744, 'M', 'ο'),
+    (0x1D745, 'M', 'π'),
+    (0x1D746, 'M', 'ρ'),
+    (0x1D747, 'M', 'σ'),
+    (0x1D749, 'M', 'τ'),
+    (0x1D74A, 'M', 'υ'),
+    (0x1D74B, 'M', 'φ'),
+    (0x1D74C, 'M', 'χ'),
+    (0x1D74D, 'M', 'ψ'),
+    (0x1D74E, 'M', 'ω'),
+    ]
+
+def _seg_69() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x1D74F, 'M', '∂'),
+    (0x1D750, 'M', 'ε'),
+    (0x1D751, 'M', 'θ'),
+    (0x1D752, 'M', 'κ'),
+    (0x1D753, 'M', 'φ'),
+    (0x1D754, 'M', 'ρ'),
+    (0x1D755, 'M', 'π'),
+    (0x1D756, 'M', 'α'),
+    (0x1D757, 'M', 'β'),
+    (0x1D758, 'M', 'γ'),
+    (0x1D759, 'M', 'δ'),
+    (0x1D75A, 'M', 'ε'),
+    (0x1D75B, 'M', 'ζ'),
+    (0x1D75C, 'M', 'η'),
+    (0x1D75D, 'M', 'θ'),
+    (0x1D75E, 'M', 'ι'),
+    (0x1D75F, 'M', 'κ'),
+    (0x1D760, 'M', 'λ'),
+    (0x1D761, 'M', 'μ'),
+    (0x1D762, 'M', 'ν'),
+    (0x1D763, 'M', 'ξ'),
+    (0x1D764, 'M', 'ο'),
+    (0x1D765, 'M', 'π'),
+    (0x1D766, 'M', 'ρ'),
+    (0x1D767, 'M', 'θ'),
+    (0x1D768, 'M', 'σ'),
+    (0x1D769, 'M', 'τ'),
+    (0x1D76A, 'M', 'υ'),
+    (0x1D76B, 'M', 'φ'),
+    (0x1D76C, 'M', 'χ'),
+    (0x1D76D, 'M', 'ψ'),
+    (0x1D76E, 'M', 'ω'),
+    (0x1D76F, 'M', '∇'),
+    (0x1D770, 'M', 'α'),
+    (0x1D771, 'M', 'β'),
+    (0x1D772, 'M', 'γ'),
+    (0x1D773, 'M', 'δ'),
+    (0x1D774, 'M', 'ε'),
+    (0x1D775, 'M', 'ζ'),
+    (0x1D776, 'M', 'η'),
+    (0x1D777, 'M', 'θ'),
+    (0x1D778, 'M', 'ι'),
+    (0x1D779, 'M', 'κ'),
+    (0x1D77A, 'M', 'λ'),
+    (0x1D77B, 'M', 'μ'),
+    (0x1D77C, 'M', 'ν'),
+    (0x1D77D, 'M', 'ξ'),
+    (0x1D77E, 'M', 'ο'),
+    (0x1D77F, 'M', 'π'),
+    (0x1D780, 'M', 'ρ'),
+    (0x1D781, 'M', 'σ'),
+    (0x1D783, 'M', 'τ'),
+    (0x1D784, 'M', 'υ'),
+    (0x1D785, 'M', 'φ'),
+    (0x1D786, 'M', 'χ'),
+    (0x1D787, 'M', 'ψ'),
+    (0x1D788, 'M', 'ω'),
+    (0x1D789, 'M', '∂'),
+    (0x1D78A, 'M', 'ε'),
+    (0x1D78B, 'M', 'θ'),
+    (0x1D78C, 'M', 'κ'),
+    (0x1D78D, 'M', 'φ'),
+    (0x1D78E, 'M', 'ρ'),
+    (0x1D78F, 'M', 'π'),
+    (0x1D790, 'M', 'α'),
+    (0x1D791, 'M', 'β'),
+    (0x1D792, 'M', 'γ'),
+    (0x1D793, 'M', 'δ'),
+    (0x1D794, 'M', 'ε'),
+    (0x1D795, 'M', 'ζ'),
+    (0x1D796, 'M', 'η'),
+    (0x1D797, 'M', 'θ'),
+    (0x1D798, 'M', 'ι'),
+    (0x1D799, 'M', 'κ'),
+    (0x1D79A, 'M', 'λ'),
+    (0x1D79B, 'M', 'μ'),
+    (0x1D79C, 'M', 'ν'),
+    (0x1D79D, 'M', 'ξ'),
+    (0x1D79E, 'M', 'ο'),
+    (0x1D79F, 'M', 'π'),
+    (0x1D7A0, 'M', 'ρ'),
+    (0x1D7A1, 'M', 'θ'),
+    (0x1D7A2, 'M', 'σ'),
+    (0x1D7A3, 'M', 'τ'),
+    (0x1D7A4, 'M', 'υ'),
+    (0x1D7A5, 'M', 'φ'),
+    (0x1D7A6, 'M', 'χ'),
+    (0x1D7A7, 'M', 'ψ'),
+    (0x1D7A8, 'M', 'ω'),
+    (0x1D7A9, 'M', '∇'),
+    (0x1D7AA, 'M', 'α'),
+    (0x1D7AB, 'M', 'β'),
+    (0x1D7AC, 'M', 'γ'),
+    (0x1D7AD, 'M', 'δ'),
+    (0x1D7AE, 'M', 'ε'),
+    (0x1D7AF, 'M', 'ζ'),
+    (0x1D7B0, 'M', 'η'),
+    (0x1D7B1, 'M', 'θ'),
+    (0x1D7B2, 'M', 'ι'),
+    (0x1D7B3, 'M', 'κ'),
+    ]
+
+def _seg_70() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x1D7B4, 'M', 'λ'),
+    (0x1D7B5, 'M', 'μ'),
+    (0x1D7B6, 'M', 'ν'),
+    (0x1D7B7, 'M', 'ξ'),
+    (0x1D7B8, 'M', 'ο'),
+    (0x1D7B9, 'M', 'π'),
+    (0x1D7BA, 'M', 'ρ'),
+    (0x1D7BB, 'M', 'σ'),
+    (0x1D7BD, 'M', 'τ'),
+    (0x1D7BE, 'M', 'υ'),
+    (0x1D7BF, 'M', 'φ'),
+    (0x1D7C0, 'M', 'χ'),
+    (0x1D7C1, 'M', 'ψ'),
+    (0x1D7C2, 'M', 'ω'),
+    (0x1D7C3, 'M', '∂'),
+    (0x1D7C4, 'M', 'ε'),
+    (0x1D7C5, 'M', 'θ'),
+    (0x1D7C6, 'M', 'κ'),
+    (0x1D7C7, 'M', 'φ'),
+    (0x1D7C8, 'M', 'ρ'),
+    (0x1D7C9, 'M', 'π'),
+    (0x1D7CA, 'M', 'ϝ'),
+    (0x1D7CC, 'X'),
+    (0x1D7CE, 'M', '0'),
+    (0x1D7CF, 'M', '1'),
+    (0x1D7D0, 'M', '2'),
+    (0x1D7D1, 'M', '3'),
+    (0x1D7D2, 'M', '4'),
+    (0x1D7D3, 'M', '5'),
+    (0x1D7D4, 'M', '6'),
+    (0x1D7D5, 'M', '7'),
+    (0x1D7D6, 'M', '8'),
+    (0x1D7D7, 'M', '9'),
+    (0x1D7D8, 'M', '0'),
+    (0x1D7D9, 'M', '1'),
+    (0x1D7DA, 'M', '2'),
+    (0x1D7DB, 'M', '3'),
+    (0x1D7DC, 'M', '4'),
+    (0x1D7DD, 'M', '5'),
+    (0x1D7DE, 'M', '6'),
+    (0x1D7DF, 'M', '7'),
+    (0x1D7E0, 'M', '8'),
+    (0x1D7E1, 'M', '9'),
+    (0x1D7E2, 'M', '0'),
+    (0x1D7E3, 'M', '1'),
+    (0x1D7E4, 'M', '2'),
+    (0x1D7E5, 'M', '3'),
+    (0x1D7E6, 'M', '4'),
+    (0x1D7E7, 'M', '5'),
+    (0x1D7E8, 'M', '6'),
+    (0x1D7E9, 'M', '7'),
+    (0x1D7EA, 'M', '8'),
+    (0x1D7EB, 'M', '9'),
+    (0x1D7EC, 'M', '0'),
+    (0x1D7ED, 'M', '1'),
+    (0x1D7EE, 'M', '2'),
+    (0x1D7EF, 'M', '3'),
+    (0x1D7F0, 'M', '4'),
+    (0x1D7F1, 'M', '5'),
+    (0x1D7F2, 'M', '6'),
+    (0x1D7F3, 'M', '7'),
+    (0x1D7F4, 'M', '8'),
+    (0x1D7F5, 'M', '9'),
+    (0x1D7F6, 'M', '0'),
+    (0x1D7F7, 'M', '1'),
+    (0x1D7F8, 'M', '2'),
+    (0x1D7F9, 'M', '3'),
+    (0x1D7FA, 'M', '4'),
+    (0x1D7FB, 'M', '5'),
+    (0x1D7FC, 'M', '6'),
+    (0x1D7FD, 'M', '7'),
+    (0x1D7FE, 'M', '8'),
+    (0x1D7FF, 'M', '9'),
+    (0x1D800, 'V'),
+    (0x1DA8C, 'X'),
+    (0x1DA9B, 'V'),
+    (0x1DAA0, 'X'),
+    (0x1DAA1, 'V'),
+    (0x1DAB0, 'X'),
+    (0x1DF00, 'V'),
+    (0x1DF1F, 'X'),
+    (0x1DF25, 'V'),
+    (0x1DF2B, 'X'),
+    (0x1E000, 'V'),
+    (0x1E007, 'X'),
+    (0x1E008, 'V'),
+    (0x1E019, 'X'),
+    (0x1E01B, 'V'),
+    (0x1E022, 'X'),
+    (0x1E023, 'V'),
+    (0x1E025, 'X'),
+    (0x1E026, 'V'),
+    (0x1E02B, 'X'),
+    (0x1E030, 'M', 'а'),
+    (0x1E031, 'M', 'б'),
+    (0x1E032, 'M', 'в'),
+    (0x1E033, 'M', 'г'),
+    (0x1E034, 'M', 'д'),
+    (0x1E035, 'M', 'е'),
+    (0x1E036, 'M', 'ж'),
+    ]
+
+def _seg_71() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x1E037, 'M', 'з'),
+    (0x1E038, 'M', 'и'),
+    (0x1E039, 'M', 'к'),
+    (0x1E03A, 'M', 'л'),
+    (0x1E03B, 'M', 'м'),
+    (0x1E03C, 'M', 'о'),
+    (0x1E03D, 'M', 'п'),
+    (0x1E03E, 'M', 'р'),
+    (0x1E03F, 'M', 'с'),
+    (0x1E040, 'M', 'т'),
+    (0x1E041, 'M', 'у'),
+    (0x1E042, 'M', 'ф'),
+    (0x1E043, 'M', 'х'),
+    (0x1E044, 'M', 'ц'),
+    (0x1E045, 'M', 'ч'),
+    (0x1E046, 'M', 'ш'),
+    (0x1E047, 'M', 'ы'),
+    (0x1E048, 'M', 'э'),
+    (0x1E049, 'M', 'ю'),
+    (0x1E04A, 'M', 'ꚉ'),
+    (0x1E04B, 'M', 'ә'),
+    (0x1E04C, 'M', 'і'),
+    (0x1E04D, 'M', 'ј'),
+    (0x1E04E, 'M', 'ө'),
+    (0x1E04F, 'M', 'ү'),
+    (0x1E050, 'M', 'ӏ'),
+    (0x1E051, 'M', 'а'),
+    (0x1E052, 'M', 'б'),
+    (0x1E053, 'M', 'в'),
+    (0x1E054, 'M', 'г'),
+    (0x1E055, 'M', 'д'),
+    (0x1E056, 'M', 'е'),
+    (0x1E057, 'M', 'ж'),
+    (0x1E058, 'M', 'з'),
+    (0x1E059, 'M', 'и'),
+    (0x1E05A, 'M', 'к'),
+    (0x1E05B, 'M', 'л'),
+    (0x1E05C, 'M', 'о'),
+    (0x1E05D, 'M', 'п'),
+    (0x1E05E, 'M', 'с'),
+    (0x1E05F, 'M', 'у'),
+    (0x1E060, 'M', 'ф'),
+    (0x1E061, 'M', 'х'),
+    (0x1E062, 'M', 'ц'),
+    (0x1E063, 'M', 'ч'),
+    (0x1E064, 'M', 'ш'),
+    (0x1E065, 'M', 'ъ'),
+    (0x1E066, 'M', 'ы'),
+    (0x1E067, 'M', 'ґ'),
+    (0x1E068, 'M', 'і'),
+    (0x1E069, 'M', 'ѕ'),
+    (0x1E06A, 'M', 'џ'),
+    (0x1E06B, 'M', 'ҫ'),
+    (0x1E06C, 'M', 'ꙑ'),
+    (0x1E06D, 'M', 'ұ'),
+    (0x1E06E, 'X'),
+    (0x1E08F, 'V'),
+    (0x1E090, 'X'),
+    (0x1E100, 'V'),
+    (0x1E12D, 'X'),
+    (0x1E130, 'V'),
+    (0x1E13E, 'X'),
+    (0x1E140, 'V'),
+    (0x1E14A, 'X'),
+    (0x1E14E, 'V'),
+    (0x1E150, 'X'),
+    (0x1E290, 'V'),
+    (0x1E2AF, 'X'),
+    (0x1E2C0, 'V'),
+    (0x1E2FA, 'X'),
+    (0x1E2FF, 'V'),
+    (0x1E300, 'X'),
+    (0x1E4D0, 'V'),
+    (0x1E4FA, 'X'),
+    (0x1E7E0, 'V'),
+    (0x1E7E7, 'X'),
+    (0x1E7E8, 'V'),
+    (0x1E7EC, 'X'),
+    (0x1E7ED, 'V'),
+    (0x1E7EF, 'X'),
+    (0x1E7F0, 'V'),
+    (0x1E7FF, 'X'),
+    (0x1E800, 'V'),
+    (0x1E8C5, 'X'),
+    (0x1E8C7, 'V'),
+    (0x1E8D7, 'X'),
+    (0x1E900, 'M', '𞤢'),
+    (0x1E901, 'M', '𞤣'),
+    (0x1E902, 'M', '𞤤'),
+    (0x1E903, 'M', '𞤥'),
+    (0x1E904, 'M', '𞤦'),
+    (0x1E905, 'M', '𞤧'),
+    (0x1E906, 'M', '𞤨'),
+    (0x1E907, 'M', '𞤩'),
+    (0x1E908, 'M', '𞤪'),
+    (0x1E909, 'M', '𞤫'),
+    (0x1E90A, 'M', '𞤬'),
+    (0x1E90B, 'M', '𞤭'),
+    (0x1E90C, 'M', '𞤮'),
+    (0x1E90D, 'M', '𞤯'),
+    ]
+
+def _seg_72() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x1E90E, 'M', '𞤰'),
+    (0x1E90F, 'M', '𞤱'),
+    (0x1E910, 'M', '𞤲'),
+    (0x1E911, 'M', '𞤳'),
+    (0x1E912, 'M', '𞤴'),
+    (0x1E913, 'M', '𞤵'),
+    (0x1E914, 'M', '𞤶'),
+    (0x1E915, 'M', '𞤷'),
+    (0x1E916, 'M', '𞤸'),
+    (0x1E917, 'M', '𞤹'),
+    (0x1E918, 'M', '𞤺'),
+    (0x1E919, 'M', '𞤻'),
+    (0x1E91A, 'M', '𞤼'),
+    (0x1E91B, 'M', '𞤽'),
+    (0x1E91C, 'M', '𞤾'),
+    (0x1E91D, 'M', '𞤿'),
+    (0x1E91E, 'M', '𞥀'),
+    (0x1E91F, 'M', '𞥁'),
+    (0x1E920, 'M', '𞥂'),
+    (0x1E921, 'M', '𞥃'),
+    (0x1E922, 'V'),
+    (0x1E94C, 'X'),
+    (0x1E950, 'V'),
+    (0x1E95A, 'X'),
+    (0x1E95E, 'V'),
+    (0x1E960, 'X'),
+    (0x1EC71, 'V'),
+    (0x1ECB5, 'X'),
+    (0x1ED01, 'V'),
+    (0x1ED3E, 'X'),
+    (0x1EE00, 'M', 'ا'),
+    (0x1EE01, 'M', 'ب'),
+    (0x1EE02, 'M', 'ج'),
+    (0x1EE03, 'M', 'د'),
+    (0x1EE04, 'X'),
+    (0x1EE05, 'M', 'و'),
+    (0x1EE06, 'M', 'ز'),
+    (0x1EE07, 'M', 'ح'),
+    (0x1EE08, 'M', 'ط'),
+    (0x1EE09, 'M', 'ي'),
+    (0x1EE0A, 'M', 'ك'),
+    (0x1EE0B, 'M', 'ل'),
+    (0x1EE0C, 'M', 'م'),
+    (0x1EE0D, 'M', 'ن'),
+    (0x1EE0E, 'M', 'س'),
+    (0x1EE0F, 'M', 'ع'),
+    (0x1EE10, 'M', 'ف'),
+    (0x1EE11, 'M', 'ص'),
+    (0x1EE12, 'M', 'ق'),
+    (0x1EE13, 'M', 'ر'),
+    (0x1EE14, 'M', 'ش'),
+    (0x1EE15, 'M', 'ت'),
+    (0x1EE16, 'M', 'ث'),
+    (0x1EE17, 'M', 'خ'),
+    (0x1EE18, 'M', 'ذ'),
+    (0x1EE19, 'M', 'ض'),
+    (0x1EE1A, 'M', 'ظ'),
+    (0x1EE1B, 'M', 'غ'),
+    (0x1EE1C, 'M', 'ٮ'),
+    (0x1EE1D, 'M', 'ں'),
+    (0x1EE1E, 'M', 'ڡ'),
+    (0x1EE1F, 'M', 'ٯ'),
+    (0x1EE20, 'X'),
+    (0x1EE21, 'M', 'ب'),
+    (0x1EE22, 'M', 'ج'),
+    (0x1EE23, 'X'),
+    (0x1EE24, 'M', 'ه'),
+    (0x1EE25, 'X'),
+    (0x1EE27, 'M', 'ح'),
+    (0x1EE28, 'X'),
+    (0x1EE29, 'M', 'ي'),
+    (0x1EE2A, 'M', 'ك'),
+    (0x1EE2B, 'M', 'ل'),
+    (0x1EE2C, 'M', 'م'),
+    (0x1EE2D, 'M', 'ن'),
+    (0x1EE2E, 'M', 'س'),
+    (0x1EE2F, 'M', 'ع'),
+    (0x1EE30, 'M', 'ف'),
+    (0x1EE31, 'M', 'ص'),
+    (0x1EE32, 'M', 'ق'),
+    (0x1EE33, 'X'),
+    (0x1EE34, 'M', 'ش'),
+    (0x1EE35, 'M', 'ت'),
+    (0x1EE36, 'M', 'ث'),
+    (0x1EE37, 'M', 'خ'),
+    (0x1EE38, 'X'),
+    (0x1EE39, 'M', 'ض'),
+    (0x1EE3A, 'X'),
+    (0x1EE3B, 'M', 'غ'),
+    (0x1EE3C, 'X'),
+    (0x1EE42, 'M', 'ج'),
+    (0x1EE43, 'X'),
+    (0x1EE47, 'M', 'ح'),
+    (0x1EE48, 'X'),
+    (0x1EE49, 'M', 'ي'),
+    (0x1EE4A, 'X'),
+    (0x1EE4B, 'M', 'ل'),
+    (0x1EE4C, 'X'),
+    (0x1EE4D, 'M', 'ن'),
+    (0x1EE4E, 'M', 'س'),
+    ]
+
+def _seg_73() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x1EE4F, 'M', 'ع'),
+    (0x1EE50, 'X'),
+    (0x1EE51, 'M', 'ص'),
+    (0x1EE52, 'M', 'ق'),
+    (0x1EE53, 'X'),
+    (0x1EE54, 'M', 'ش'),
+    (0x1EE55, 'X'),
+    (0x1EE57, 'M', 'خ'),
+    (0x1EE58, 'X'),
+    (0x1EE59, 'M', 'ض'),
+    (0x1EE5A, 'X'),
+    (0x1EE5B, 'M', 'غ'),
+    (0x1EE5C, 'X'),
+    (0x1EE5D, 'M', 'ں'),
+    (0x1EE5E, 'X'),
+    (0x1EE5F, 'M', 'ٯ'),
+    (0x1EE60, 'X'),
+    (0x1EE61, 'M', 'ب'),
+    (0x1EE62, 'M', 'ج'),
+    (0x1EE63, 'X'),
+    (0x1EE64, 'M', 'ه'),
+    (0x1EE65, 'X'),
+    (0x1EE67, 'M', 'ح'),
+    (0x1EE68, 'M', 'ط'),
+    (0x1EE69, 'M', 'ي'),
+    (0x1EE6A, 'M', 'ك'),
+    (0x1EE6B, 'X'),
+    (0x1EE6C, 'M', 'م'),
+    (0x1EE6D, 'M', 'ن'),
+    (0x1EE6E, 'M', 'س'),
+    (0x1EE6F, 'M', 'ع'),
+    (0x1EE70, 'M', 'ف'),
+    (0x1EE71, 'M', 'ص'),
+    (0x1EE72, 'M', 'ق'),
+    (0x1EE73, 'X'),
+    (0x1EE74, 'M', 'ش'),
+    (0x1EE75, 'M', 'ت'),
+    (0x1EE76, 'M', 'ث'),
+    (0x1EE77, 'M', 'خ'),
+    (0x1EE78, 'X'),
+    (0x1EE79, 'M', 'ض'),
+    (0x1EE7A, 'M', 'ظ'),
+    (0x1EE7B, 'M', 'غ'),
+    (0x1EE7C, 'M', 'ٮ'),
+    (0x1EE7D, 'X'),
+    (0x1EE7E, 'M', 'ڡ'),
+    (0x1EE7F, 'X'),
+    (0x1EE80, 'M', 'ا'),
+    (0x1EE81, 'M', 'ب'),
+    (0x1EE82, 'M', 'ج'),
+    (0x1EE83, 'M', 'د'),
+    (0x1EE84, 'M', 'ه'),
+    (0x1EE85, 'M', 'و'),
+    (0x1EE86, 'M', 'ز'),
+    (0x1EE87, 'M', 'ح'),
+    (0x1EE88, 'M', 'ط'),
+    (0x1EE89, 'M', 'ي'),
+    (0x1EE8A, 'X'),
+    (0x1EE8B, 'M', 'ل'),
+    (0x1EE8C, 'M', 'م'),
+    (0x1EE8D, 'M', 'ن'),
+    (0x1EE8E, 'M', 'س'),
+    (0x1EE8F, 'M', 'ع'),
+    (0x1EE90, 'M', 'ف'),
+    (0x1EE91, 'M', 'ص'),
+    (0x1EE92, 'M', 'ق'),
+    (0x1EE93, 'M', 'ر'),
+    (0x1EE94, 'M', 'ش'),
+    (0x1EE95, 'M', 'ت'),
+    (0x1EE96, 'M', 'ث'),
+    (0x1EE97, 'M', 'خ'),
+    (0x1EE98, 'M', 'ذ'),
+    (0x1EE99, 'M', 'ض'),
+    (0x1EE9A, 'M', 'ظ'),
+    (0x1EE9B, 'M', 'غ'),
+    (0x1EE9C, 'X'),
+    (0x1EEA1, 'M', 'ب'),
+    (0x1EEA2, 'M', 'ج'),
+    (0x1EEA3, 'M', 'د'),
+    (0x1EEA4, 'X'),
+    (0x1EEA5, 'M', 'و'),
+    (0x1EEA6, 'M', 'ز'),
+    (0x1EEA7, 'M', 'ح'),
+    (0x1EEA8, 'M', 'ط'),
+    (0x1EEA9, 'M', 'ي'),
+    (0x1EEAA, 'X'),
+    (0x1EEAB, 'M', 'ل'),
+    (0x1EEAC, 'M', 'م'),
+    (0x1EEAD, 'M', 'ن'),
+    (0x1EEAE, 'M', 'س'),
+    (0x1EEAF, 'M', 'ع'),
+    (0x1EEB0, 'M', 'ف'),
+    (0x1EEB1, 'M', 'ص'),
+    (0x1EEB2, 'M', 'ق'),
+    (0x1EEB3, 'M', 'ر'),
+    (0x1EEB4, 'M', 'ش'),
+    (0x1EEB5, 'M', 'ت'),
+    (0x1EEB6, 'M', 'ث'),
+    (0x1EEB7, 'M', 'خ'),
+    (0x1EEB8, 'M', 'ذ'),
+    ]
+
+def _seg_74() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x1EEB9, 'M', 'ض'),
+    (0x1EEBA, 'M', 'ظ'),
+    (0x1EEBB, 'M', 'غ'),
+    (0x1EEBC, 'X'),
+    (0x1EEF0, 'V'),
+    (0x1EEF2, 'X'),
+    (0x1F000, 'V'),
+    (0x1F02C, 'X'),
+    (0x1F030, 'V'),
+    (0x1F094, 'X'),
+    (0x1F0A0, 'V'),
+    (0x1F0AF, 'X'),
+    (0x1F0B1, 'V'),
+    (0x1F0C0, 'X'),
+    (0x1F0C1, 'V'),
+    (0x1F0D0, 'X'),
+    (0x1F0D1, 'V'),
+    (0x1F0F6, 'X'),
+    (0x1F101, '3', '0,'),
+    (0x1F102, '3', '1,'),
+    (0x1F103, '3', '2,'),
+    (0x1F104, '3', '3,'),
+    (0x1F105, '3', '4,'),
+    (0x1F106, '3', '5,'),
+    (0x1F107, '3', '6,'),
+    (0x1F108, '3', '7,'),
+    (0x1F109, '3', '8,'),
+    (0x1F10A, '3', '9,'),
+    (0x1F10B, 'V'),
+    (0x1F110, '3', '(a)'),
+    (0x1F111, '3', '(b)'),
+    (0x1F112, '3', '(c)'),
+    (0x1F113, '3', '(d)'),
+    (0x1F114, '3', '(e)'),
+    (0x1F115, '3', '(f)'),
+    (0x1F116, '3', '(g)'),
+    (0x1F117, '3', '(h)'),
+    (0x1F118, '3', '(i)'),
+    (0x1F119, '3', '(j)'),
+    (0x1F11A, '3', '(k)'),
+    (0x1F11B, '3', '(l)'),
+    (0x1F11C, '3', '(m)'),
+    (0x1F11D, '3', '(n)'),
+    (0x1F11E, '3', '(o)'),
+    (0x1F11F, '3', '(p)'),
+    (0x1F120, '3', '(q)'),
+    (0x1F121, '3', '(r)'),
+    (0x1F122, '3', '(s)'),
+    (0x1F123, '3', '(t)'),
+    (0x1F124, '3', '(u)'),
+    (0x1F125, '3', '(v)'),
+    (0x1F126, '3', '(w)'),
+    (0x1F127, '3', '(x)'),
+    (0x1F128, '3', '(y)'),
+    (0x1F129, '3', '(z)'),
+    (0x1F12A, 'M', '〔s〕'),
+    (0x1F12B, 'M', 'c'),
+    (0x1F12C, 'M', 'r'),
+    (0x1F12D, 'M', 'cd'),
+    (0x1F12E, 'M', 'wz'),
+    (0x1F12F, 'V'),
+    (0x1F130, 'M', 'a'),
+    (0x1F131, 'M', 'b'),
+    (0x1F132, 'M', 'c'),
+    (0x1F133, 'M', 'd'),
+    (0x1F134, 'M', 'e'),
+    (0x1F135, 'M', 'f'),
+    (0x1F136, 'M', 'g'),
+    (0x1F137, 'M', 'h'),
+    (0x1F138, 'M', 'i'),
+    (0x1F139, 'M', 'j'),
+    (0x1F13A, 'M', 'k'),
+    (0x1F13B, 'M', 'l'),
+    (0x1F13C, 'M', 'm'),
+    (0x1F13D, 'M', 'n'),
+    (0x1F13E, 'M', 'o'),
+    (0x1F13F, 'M', 'p'),
+    (0x1F140, 'M', 'q'),
+    (0x1F141, 'M', 'r'),
+    (0x1F142, 'M', 's'),
+    (0x1F143, 'M', 't'),
+    (0x1F144, 'M', 'u'),
+    (0x1F145, 'M', 'v'),
+    (0x1F146, 'M', 'w'),
+    (0x1F147, 'M', 'x'),
+    (0x1F148, 'M', 'y'),
+    (0x1F149, 'M', 'z'),
+    (0x1F14A, 'M', 'hv'),
+    (0x1F14B, 'M', 'mv'),
+    (0x1F14C, 'M', 'sd'),
+    (0x1F14D, 'M', 'ss'),
+    (0x1F14E, 'M', 'ppv'),
+    (0x1F14F, 'M', 'wc'),
+    (0x1F150, 'V'),
+    (0x1F16A, 'M', 'mc'),
+    (0x1F16B, 'M', 'md'),
+    (0x1F16C, 'M', 'mr'),
+    (0x1F16D, 'V'),
+    (0x1F190, 'M', 'dj'),
+    (0x1F191, 'V'),
+    ]
+
+def _seg_75() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x1F1AE, 'X'),
+    (0x1F1E6, 'V'),
+    (0x1F200, 'M', 'ほか'),
+    (0x1F201, 'M', 'ココ'),
+    (0x1F202, 'M', 'サ'),
+    (0x1F203, 'X'),
+    (0x1F210, 'M', '手'),
+    (0x1F211, 'M', '字'),
+    (0x1F212, 'M', '双'),
+    (0x1F213, 'M', 'デ'),
+    (0x1F214, 'M', '二'),
+    (0x1F215, 'M', '多'),
+    (0x1F216, 'M', '解'),
+    (0x1F217, 'M', '天'),
+    (0x1F218, 'M', '交'),
+    (0x1F219, 'M', '映'),
+    (0x1F21A, 'M', '無'),
+    (0x1F21B, 'M', '料'),
+    (0x1F21C, 'M', '前'),
+    (0x1F21D, 'M', '後'),
+    (0x1F21E, 'M', '再'),
+    (0x1F21F, 'M', '新'),
+    (0x1F220, 'M', '初'),
+    (0x1F221, 'M', '終'),
+    (0x1F222, 'M', '生'),
+    (0x1F223, 'M', '販'),
+    (0x1F224, 'M', '声'),
+    (0x1F225, 'M', '吹'),
+    (0x1F226, 'M', '演'),
+    (0x1F227, 'M', '投'),
+    (0x1F228, 'M', '捕'),
+    (0x1F229, 'M', '一'),
+    (0x1F22A, 'M', '三'),
+    (0x1F22B, 'M', '遊'),
+    (0x1F22C, 'M', '左'),
+    (0x1F22D, 'M', '中'),
+    (0x1F22E, 'M', '右'),
+    (0x1F22F, 'M', '指'),
+    (0x1F230, 'M', '走'),
+    (0x1F231, 'M', '打'),
+    (0x1F232, 'M', '禁'),
+    (0x1F233, 'M', '空'),
+    (0x1F234, 'M', '合'),
+    (0x1F235, 'M', '満'),
+    (0x1F236, 'M', '有'),
+    (0x1F237, 'M', '月'),
+    (0x1F238, 'M', '申'),
+    (0x1F239, 'M', '割'),
+    (0x1F23A, 'M', '営'),
+    (0x1F23B, 'M', '配'),
+    (0x1F23C, 'X'),
+    (0x1F240, 'M', '〔本〕'),
+    (0x1F241, 'M', '〔三〕'),
+    (0x1F242, 'M', '〔二〕'),
+    (0x1F243, 'M', '〔安〕'),
+    (0x1F244, 'M', '〔点〕'),
+    (0x1F245, 'M', '〔打〕'),
+    (0x1F246, 'M', '〔盗〕'),
+    (0x1F247, 'M', '〔勝〕'),
+    (0x1F248, 'M', '〔敗〕'),
+    (0x1F249, 'X'),
+    (0x1F250, 'M', '得'),
+    (0x1F251, 'M', '可'),
+    (0x1F252, 'X'),
+    (0x1F260, 'V'),
+    (0x1F266, 'X'),
+    (0x1F300, 'V'),
+    (0x1F6D8, 'X'),
+    (0x1F6DC, 'V'),
+    (0x1F6ED, 'X'),
+    (0x1F6F0, 'V'),
+    (0x1F6FD, 'X'),
+    (0x1F700, 'V'),
+    (0x1F777, 'X'),
+    (0x1F77B, 'V'),
+    (0x1F7DA, 'X'),
+    (0x1F7E0, 'V'),
+    (0x1F7EC, 'X'),
+    (0x1F7F0, 'V'),
+    (0x1F7F1, 'X'),
+    (0x1F800, 'V'),
+    (0x1F80C, 'X'),
+    (0x1F810, 'V'),
+    (0x1F848, 'X'),
+    (0x1F850, 'V'),
+    (0x1F85A, 'X'),
+    (0x1F860, 'V'),
+    (0x1F888, 'X'),
+    (0x1F890, 'V'),
+    (0x1F8AE, 'X'),
+    (0x1F8B0, 'V'),
+    (0x1F8B2, 'X'),
+    (0x1F900, 'V'),
+    (0x1FA54, 'X'),
+    (0x1FA60, 'V'),
+    (0x1FA6E, 'X'),
+    (0x1FA70, 'V'),
+    (0x1FA7D, 'X'),
+    (0x1FA80, 'V'),
+    (0x1FA89, 'X'),
+    ]
+
+def _seg_76() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x1FA90, 'V'),
+    (0x1FABE, 'X'),
+    (0x1FABF, 'V'),
+    (0x1FAC6, 'X'),
+    (0x1FACE, 'V'),
+    (0x1FADC, 'X'),
+    (0x1FAE0, 'V'),
+    (0x1FAE9, 'X'),
+    (0x1FAF0, 'V'),
+    (0x1FAF9, 'X'),
+    (0x1FB00, 'V'),
+    (0x1FB93, 'X'),
+    (0x1FB94, 'V'),
+    (0x1FBCB, 'X'),
+    (0x1FBF0, 'M', '0'),
+    (0x1FBF1, 'M', '1'),
+    (0x1FBF2, 'M', '2'),
+    (0x1FBF3, 'M', '3'),
+    (0x1FBF4, 'M', '4'),
+    (0x1FBF5, 'M', '5'),
+    (0x1FBF6, 'M', '6'),
+    (0x1FBF7, 'M', '7'),
+    (0x1FBF8, 'M', '8'),
+    (0x1FBF9, 'M', '9'),
+    (0x1FBFA, 'X'),
+    (0x20000, 'V'),
+    (0x2A6E0, 'X'),
+    (0x2A700, 'V'),
+    (0x2B73A, 'X'),
+    (0x2B740, 'V'),
+    (0x2B81E, 'X'),
+    (0x2B820, 'V'),
+    (0x2CEA2, 'X'),
+    (0x2CEB0, 'V'),
+    (0x2EBE1, 'X'),
+    (0x2EBF0, 'V'),
+    (0x2EE5E, 'X'),
+    (0x2F800, 'M', '丽'),
+    (0x2F801, 'M', '丸'),
+    (0x2F802, 'M', '乁'),
+    (0x2F803, 'M', '𠄢'),
+    (0x2F804, 'M', '你'),
+    (0x2F805, 'M', '侮'),
+    (0x2F806, 'M', '侻'),
+    (0x2F807, 'M', '倂'),
+    (0x2F808, 'M', '偺'),
+    (0x2F809, 'M', '備'),
+    (0x2F80A, 'M', '僧'),
+    (0x2F80B, 'M', '像'),
+    (0x2F80C, 'M', '㒞'),
+    (0x2F80D, 'M', '𠘺'),
+    (0x2F80E, 'M', '免'),
+    (0x2F80F, 'M', '兔'),
+    (0x2F810, 'M', '兤'),
+    (0x2F811, 'M', '具'),
+    (0x2F812, 'M', '𠔜'),
+    (0x2F813, 'M', '㒹'),
+    (0x2F814, 'M', '內'),
+    (0x2F815, 'M', '再'),
+    (0x2F816, 'M', '𠕋'),
+    (0x2F817, 'M', '冗'),
+    (0x2F818, 'M', '冤'),
+    (0x2F819, 'M', '仌'),
+    (0x2F81A, 'M', '冬'),
+    (0x2F81B, 'M', '况'),
+    (0x2F81C, 'M', '𩇟'),
+    (0x2F81D, 'M', '凵'),
+    (0x2F81E, 'M', '刃'),
+    (0x2F81F, 'M', '㓟'),
+    (0x2F820, 'M', '刻'),
+    (0x2F821, 'M', '剆'),
+    (0x2F822, 'M', '割'),
+    (0x2F823, 'M', '剷'),
+    (0x2F824, 'M', '㔕'),
+    (0x2F825, 'M', '勇'),
+    (0x2F826, 'M', '勉'),
+    (0x2F827, 'M', '勤'),
+    (0x2F828, 'M', '勺'),
+    (0x2F829, 'M', '包'),
+    (0x2F82A, 'M', '匆'),
+    (0x2F82B, 'M', '北'),
+    (0x2F82C, 'M', '卉'),
+    (0x2F82D, 'M', '卑'),
+    (0x2F82E, 'M', '博'),
+    (0x2F82F, 'M', '即'),
+    (0x2F830, 'M', '卽'),
+    (0x2F831, 'M', '卿'),
+    (0x2F834, 'M', '𠨬'),
+    (0x2F835, 'M', '灰'),
+    (0x2F836, 'M', '及'),
+    (0x2F837, 'M', '叟'),
+    (0x2F838, 'M', '𠭣'),
+    (0x2F839, 'M', '叫'),
+    (0x2F83A, 'M', '叱'),
+    (0x2F83B, 'M', '吆'),
+    (0x2F83C, 'M', '咞'),
+    (0x2F83D, 'M', '吸'),
+    (0x2F83E, 'M', '呈'),
+    (0x2F83F, 'M', '周'),
+    (0x2F840, 'M', '咢'),
+    ]
+
+def _seg_77() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x2F841, 'M', '哶'),
+    (0x2F842, 'M', '唐'),
+    (0x2F843, 'M', '啓'),
+    (0x2F844, 'M', '啣'),
+    (0x2F845, 'M', '善'),
+    (0x2F847, 'M', '喙'),
+    (0x2F848, 'M', '喫'),
+    (0x2F849, 'M', '喳'),
+    (0x2F84A, 'M', '嗂'),
+    (0x2F84B, 'M', '圖'),
+    (0x2F84C, 'M', '嘆'),
+    (0x2F84D, 'M', '圗'),
+    (0x2F84E, 'M', '噑'),
+    (0x2F84F, 'M', '噴'),
+    (0x2F850, 'M', '切'),
+    (0x2F851, 'M', '壮'),
+    (0x2F852, 'M', '城'),
+    (0x2F853, 'M', '埴'),
+    (0x2F854, 'M', '堍'),
+    (0x2F855, 'M', '型'),
+    (0x2F856, 'M', '堲'),
+    (0x2F857, 'M', '報'),
+    (0x2F858, 'M', '墬'),
+    (0x2F859, 'M', '𡓤'),
+    (0x2F85A, 'M', '売'),
+    (0x2F85B, 'M', '壷'),
+    (0x2F85C, 'M', '夆'),
+    (0x2F85D, 'M', '多'),
+    (0x2F85E, 'M', '夢'),
+    (0x2F85F, 'M', '奢'),
+    (0x2F860, 'M', '𡚨'),
+    (0x2F861, 'M', '𡛪'),
+    (0x2F862, 'M', '姬'),
+    (0x2F863, 'M', '娛'),
+    (0x2F864, 'M', '娧'),
+    (0x2F865, 'M', '姘'),
+    (0x2F866, 'M', '婦'),
+    (0x2F867, 'M', '㛮'),
+    (0x2F868, 'X'),
+    (0x2F869, 'M', '嬈'),
+    (0x2F86A, 'M', '嬾'),
+    (0x2F86C, 'M', '𡧈'),
+    (0x2F86D, 'M', '寃'),
+    (0x2F86E, 'M', '寘'),
+    (0x2F86F, 'M', '寧'),
+    (0x2F870, 'M', '寳'),
+    (0x2F871, 'M', '𡬘'),
+    (0x2F872, 'M', '寿'),
+    (0x2F873, 'M', '将'),
+    (0x2F874, 'X'),
+    (0x2F875, 'M', '尢'),
+    (0x2F876, 'M', '㞁'),
+    (0x2F877, 'M', '屠'),
+    (0x2F878, 'M', '屮'),
+    (0x2F879, 'M', '峀'),
+    (0x2F87A, 'M', '岍'),
+    (0x2F87B, 'M', '𡷤'),
+    (0x2F87C, 'M', '嵃'),
+    (0x2F87D, 'M', '𡷦'),
+    (0x2F87E, 'M', '嵮'),
+    (0x2F87F, 'M', '嵫'),
+    (0x2F880, 'M', '嵼'),
+    (0x2F881, 'M', '巡'),
+    (0x2F882, 'M', '巢'),
+    (0x2F883, 'M', '㠯'),
+    (0x2F884, 'M', '巽'),
+    (0x2F885, 'M', '帨'),
+    (0x2F886, 'M', '帽'),
+    (0x2F887, 'M', '幩'),
+    (0x2F888, 'M', '㡢'),
+    (0x2F889, 'M', '𢆃'),
+    (0x2F88A, 'M', '㡼'),
+    (0x2F88B, 'M', '庰'),
+    (0x2F88C, 'M', '庳'),
+    (0x2F88D, 'M', '庶'),
+    (0x2F88E, 'M', '廊'),
+    (0x2F88F, 'M', '𪎒'),
+    (0x2F890, 'M', '廾'),
+    (0x2F891, 'M', '𢌱'),
+    (0x2F893, 'M', '舁'),
+    (0x2F894, 'M', '弢'),
+    (0x2F896, 'M', '㣇'),
+    (0x2F897, 'M', '𣊸'),
+    (0x2F898, 'M', '𦇚'),
+    (0x2F899, 'M', '形'),
+    (0x2F89A, 'M', '彫'),
+    (0x2F89B, 'M', '㣣'),
+    (0x2F89C, 'M', '徚'),
+    (0x2F89D, 'M', '忍'),
+    (0x2F89E, 'M', '志'),
+    (0x2F89F, 'M', '忹'),
+    (0x2F8A0, 'M', '悁'),
+    (0x2F8A1, 'M', '㤺'),
+    (0x2F8A2, 'M', '㤜'),
+    (0x2F8A3, 'M', '悔'),
+    (0x2F8A4, 'M', '𢛔'),
+    (0x2F8A5, 'M', '惇'),
+    (0x2F8A6, 'M', '慈'),
+    (0x2F8A7, 'M', '慌'),
+    (0x2F8A8, 'M', '慎'),
+    ]
+
+def _seg_78() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x2F8A9, 'M', '慌'),
+    (0x2F8AA, 'M', '慺'),
+    (0x2F8AB, 'M', '憎'),
+    (0x2F8AC, 'M', '憲'),
+    (0x2F8AD, 'M', '憤'),
+    (0x2F8AE, 'M', '憯'),
+    (0x2F8AF, 'M', '懞'),
+    (0x2F8B0, 'M', '懲'),
+    (0x2F8B1, 'M', '懶'),
+    (0x2F8B2, 'M', '成'),
+    (0x2F8B3, 'M', '戛'),
+    (0x2F8B4, 'M', '扝'),
+    (0x2F8B5, 'M', '抱'),
+    (0x2F8B6, 'M', '拔'),
+    (0x2F8B7, 'M', '捐'),
+    (0x2F8B8, 'M', '𢬌'),
+    (0x2F8B9, 'M', '挽'),
+    (0x2F8BA, 'M', '拼'),
+    (0x2F8BB, 'M', '捨'),
+    (0x2F8BC, 'M', '掃'),
+    (0x2F8BD, 'M', '揤'),
+    (0x2F8BE, 'M', '𢯱'),
+    (0x2F8BF, 'M', '搢'),
+    (0x2F8C0, 'M', '揅'),
+    (0x2F8C1, 'M', '掩'),
+    (0x2F8C2, 'M', '㨮'),
+    (0x2F8C3, 'M', '摩'),
+    (0x2F8C4, 'M', '摾'),
+    (0x2F8C5, 'M', '撝'),
+    (0x2F8C6, 'M', '摷'),
+    (0x2F8C7, 'M', '㩬'),
+    (0x2F8C8, 'M', '敏'),
+    (0x2F8C9, 'M', '敬'),
+    (0x2F8CA, 'M', '𣀊'),
+    (0x2F8CB, 'M', '旣'),
+    (0x2F8CC, 'M', '書'),
+    (0x2F8CD, 'M', '晉'),
+    (0x2F8CE, 'M', '㬙'),
+    (0x2F8CF, 'M', '暑'),
+    (0x2F8D0, 'M', '㬈'),
+    (0x2F8D1, 'M', '㫤'),
+    (0x2F8D2, 'M', '冒'),
+    (0x2F8D3, 'M', '冕'),
+    (0x2F8D4, 'M', '最'),
+    (0x2F8D5, 'M', '暜'),
+    (0x2F8D6, 'M', '肭'),
+    (0x2F8D7, 'M', '䏙'),
+    (0x2F8D8, 'M', '朗'),
+    (0x2F8D9, 'M', '望'),
+    (0x2F8DA, 'M', '朡'),
+    (0x2F8DB, 'M', '杞'),
+    (0x2F8DC, 'M', '杓'),
+    (0x2F8DD, 'M', '𣏃'),
+    (0x2F8DE, 'M', '㭉'),
+    (0x2F8DF, 'M', '柺'),
+    (0x2F8E0, 'M', '枅'),
+    (0x2F8E1, 'M', '桒'),
+    (0x2F8E2, 'M', '梅'),
+    (0x2F8E3, 'M', '𣑭'),
+    (0x2F8E4, 'M', '梎'),
+    (0x2F8E5, 'M', '栟'),
+    (0x2F8E6, 'M', '椔'),
+    (0x2F8E7, 'M', '㮝'),
+    (0x2F8E8, 'M', '楂'),
+    (0x2F8E9, 'M', '榣'),
+    (0x2F8EA, 'M', '槪'),
+    (0x2F8EB, 'M', '檨'),
+    (0x2F8EC, 'M', '𣚣'),
+    (0x2F8ED, 'M', '櫛'),
+    (0x2F8EE, 'M', '㰘'),
+    (0x2F8EF, 'M', '次'),
+    (0x2F8F0, 'M', '𣢧'),
+    (0x2F8F1, 'M', '歔'),
+    (0x2F8F2, 'M', '㱎'),
+    (0x2F8F3, 'M', '歲'),
+    (0x2F8F4, 'M', '殟'),
+    (0x2F8F5, 'M', '殺'),
+    (0x2F8F6, 'M', '殻'),
+    (0x2F8F7, 'M', '𣪍'),
+    (0x2F8F8, 'M', '𡴋'),
+    (0x2F8F9, 'M', '𣫺'),
+    (0x2F8FA, 'M', '汎'),
+    (0x2F8FB, 'M', '𣲼'),
+    (0x2F8FC, 'M', '沿'),
+    (0x2F8FD, 'M', '泍'),
+    (0x2F8FE, 'M', '汧'),
+    (0x2F8FF, 'M', '洖'),
+    (0x2F900, 'M', '派'),
+    (0x2F901, 'M', '海'),
+    (0x2F902, 'M', '流'),
+    (0x2F903, 'M', '浩'),
+    (0x2F904, 'M', '浸'),
+    (0x2F905, 'M', '涅'),
+    (0x2F906, 'M', '𣴞'),
+    (0x2F907, 'M', '洴'),
+    (0x2F908, 'M', '港'),
+    (0x2F909, 'M', '湮'),
+    (0x2F90A, 'M', '㴳'),
+    (0x2F90B, 'M', '滋'),
+    (0x2F90C, 'M', '滇'),
+    ]
+
+def _seg_79() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x2F90D, 'M', '𣻑'),
+    (0x2F90E, 'M', '淹'),
+    (0x2F90F, 'M', '潮'),
+    (0x2F910, 'M', '𣽞'),
+    (0x2F911, 'M', '𣾎'),
+    (0x2F912, 'M', '濆'),
+    (0x2F913, 'M', '瀹'),
+    (0x2F914, 'M', '瀞'),
+    (0x2F915, 'M', '瀛'),
+    (0x2F916, 'M', '㶖'),
+    (0x2F917, 'M', '灊'),
+    (0x2F918, 'M', '災'),
+    (0x2F919, 'M', '灷'),
+    (0x2F91A, 'M', '炭'),
+    (0x2F91B, 'M', '𠔥'),
+    (0x2F91C, 'M', '煅'),
+    (0x2F91D, 'M', '𤉣'),
+    (0x2F91E, 'M', '熜'),
+    (0x2F91F, 'X'),
+    (0x2F920, 'M', '爨'),
+    (0x2F921, 'M', '爵'),
+    (0x2F922, 'M', '牐'),
+    (0x2F923, 'M', '𤘈'),
+    (0x2F924, 'M', '犀'),
+    (0x2F925, 'M', '犕'),
+    (0x2F926, 'M', '𤜵'),
+    (0x2F927, 'M', '𤠔'),
+    (0x2F928, 'M', '獺'),
+    (0x2F929, 'M', '王'),
+    (0x2F92A, 'M', '㺬'),
+    (0x2F92B, 'M', '玥'),
+    (0x2F92C, 'M', '㺸'),
+    (0x2F92E, 'M', '瑇'),
+    (0x2F92F, 'M', '瑜'),
+    (0x2F930, 'M', '瑱'),
+    (0x2F931, 'M', '璅'),
+    (0x2F932, 'M', '瓊'),
+    (0x2F933, 'M', '㼛'),
+    (0x2F934, 'M', '甤'),
+    (0x2F935, 'M', '𤰶'),
+    (0x2F936, 'M', '甾'),
+    (0x2F937, 'M', '𤲒'),
+    (0x2F938, 'M', '異'),
+    (0x2F939, 'M', '𢆟'),
+    (0x2F93A, 'M', '瘐'),
+    (0x2F93B, 'M', '𤾡'),
+    (0x2F93C, 'M', '𤾸'),
+    (0x2F93D, 'M', '𥁄'),
+    (0x2F93E, 'M', '㿼'),
+    (0x2F93F, 'M', '䀈'),
+    (0x2F940, 'M', '直'),
+    (0x2F941, 'M', '𥃳'),
+    (0x2F942, 'M', '𥃲'),
+    (0x2F943, 'M', '𥄙'),
+    (0x2F944, 'M', '𥄳'),
+    (0x2F945, 'M', '眞'),
+    (0x2F946, 'M', '真'),
+    (0x2F948, 'M', '睊'),
+    (0x2F949, 'M', '䀹'),
+    (0x2F94A, 'M', '瞋'),
+    (0x2F94B, 'M', '䁆'),
+    (0x2F94C, 'M', '䂖'),
+    (0x2F94D, 'M', '𥐝'),
+    (0x2F94E, 'M', '硎'),
+    (0x2F94F, 'M', '碌'),
+    (0x2F950, 'M', '磌'),
+    (0x2F951, 'M', '䃣'),
+    (0x2F952, 'M', '𥘦'),
+    (0x2F953, 'M', '祖'),
+    (0x2F954, 'M', '𥚚'),
+    (0x2F955, 'M', '𥛅'),
+    (0x2F956, 'M', '福'),
+    (0x2F957, 'M', '秫'),
+    (0x2F958, 'M', '䄯'),
+    (0x2F959, 'M', '穀'),
+    (0x2F95A, 'M', '穊'),
+    (0x2F95B, 'M', '穏'),
+    (0x2F95C, 'M', '𥥼'),
+    (0x2F95D, 'M', '𥪧'),
+    (0x2F95F, 'X'),
+    (0x2F960, 'M', '䈂'),
+    (0x2F961, 'M', '𥮫'),
+    (0x2F962, 'M', '篆'),
+    (0x2F963, 'M', '築'),
+    (0x2F964, 'M', '䈧'),
+    (0x2F965, 'M', '𥲀'),
+    (0x2F966, 'M', '糒'),
+    (0x2F967, 'M', '䊠'),
+    (0x2F968, 'M', '糨'),
+    (0x2F969, 'M', '糣'),
+    (0x2F96A, 'M', '紀'),
+    (0x2F96B, 'M', '𥾆'),
+    (0x2F96C, 'M', '絣'),
+    (0x2F96D, 'M', '䌁'),
+    (0x2F96E, 'M', '緇'),
+    (0x2F96F, 'M', '縂'),
+    (0x2F970, 'M', '繅'),
+    (0x2F971, 'M', '䌴'),
+    (0x2F972, 'M', '𦈨'),
+    (0x2F973, 'M', '𦉇'),
+    ]
+
+def _seg_80() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x2F974, 'M', '䍙'),
+    (0x2F975, 'M', '𦋙'),
+    (0x2F976, 'M', '罺'),
+    (0x2F977, 'M', '𦌾'),
+    (0x2F978, 'M', '羕'),
+    (0x2F979, 'M', '翺'),
+    (0x2F97A, 'M', '者'),
+    (0x2F97B, 'M', '𦓚'),
+    (0x2F97C, 'M', '𦔣'),
+    (0x2F97D, 'M', '聠'),
+    (0x2F97E, 'M', '𦖨'),
+    (0x2F97F, 'M', '聰'),
+    (0x2F980, 'M', '𣍟'),
+    (0x2F981, 'M', '䏕'),
+    (0x2F982, 'M', '育'),
+    (0x2F983, 'M', '脃'),
+    (0x2F984, 'M', '䐋'),
+    (0x2F985, 'M', '脾'),
+    (0x2F986, 'M', '媵'),
+    (0x2F987, 'M', '𦞧'),
+    (0x2F988, 'M', '𦞵'),
+    (0x2F989, 'M', '𣎓'),
+    (0x2F98A, 'M', '𣎜'),
+    (0x2F98B, 'M', '舁'),
+    (0x2F98C, 'M', '舄'),
+    (0x2F98D, 'M', '辞'),
+    (0x2F98E, 'M', '䑫'),
+    (0x2F98F, 'M', '芑'),
+    (0x2F990, 'M', '芋'),
+    (0x2F991, 'M', '芝'),
+    (0x2F992, 'M', '劳'),
+    (0x2F993, 'M', '花'),
+    (0x2F994, 'M', '芳'),
+    (0x2F995, 'M', '芽'),
+    (0x2F996, 'M', '苦'),
+    (0x2F997, 'M', '𦬼'),
+    (0x2F998, 'M', '若'),
+    (0x2F999, 'M', '茝'),
+    (0x2F99A, 'M', '荣'),
+    (0x2F99B, 'M', '莭'),
+    (0x2F99C, 'M', '茣'),
+    (0x2F99D, 'M', '莽'),
+    (0x2F99E, 'M', '菧'),
+    (0x2F99F, 'M', '著'),
+    (0x2F9A0, 'M', '荓'),
+    (0x2F9A1, 'M', '菊'),
+    (0x2F9A2, 'M', '菌'),
+    (0x2F9A3, 'M', '菜'),
+    (0x2F9A4, 'M', '𦰶'),
+    (0x2F9A5, 'M', '𦵫'),
+    (0x2F9A6, 'M', '𦳕'),
+    (0x2F9A7, 'M', '䔫'),
+    (0x2F9A8, 'M', '蓱'),
+    (0x2F9A9, 'M', '蓳'),
+    (0x2F9AA, 'M', '蔖'),
+    (0x2F9AB, 'M', '𧏊'),
+    (0x2F9AC, 'M', '蕤'),
+    (0x2F9AD, 'M', '𦼬'),
+    (0x2F9AE, 'M', '䕝'),
+    (0x2F9AF, 'M', '䕡'),
+    (0x2F9B0, 'M', '𦾱'),
+    (0x2F9B1, 'M', '𧃒'),
+    (0x2F9B2, 'M', '䕫'),
+    (0x2F9B3, 'M', '虐'),
+    (0x2F9B4, 'M', '虜'),
+    (0x2F9B5, 'M', '虧'),
+    (0x2F9B6, 'M', '虩'),
+    (0x2F9B7, 'M', '蚩'),
+    (0x2F9B8, 'M', '蚈'),
+    (0x2F9B9, 'M', '蜎'),
+    (0x2F9BA, 'M', '蛢'),
+    (0x2F9BB, 'M', '蝹'),
+    (0x2F9BC, 'M', '蜨'),
+    (0x2F9BD, 'M', '蝫'),
+    (0x2F9BE, 'M', '螆'),
+    (0x2F9BF, 'X'),
+    (0x2F9C0, 'M', '蟡'),
+    (0x2F9C1, 'M', '蠁'),
+    (0x2F9C2, 'M', '䗹'),
+    (0x2F9C3, 'M', '衠'),
+    (0x2F9C4, 'M', '衣'),
+    (0x2F9C5, 'M', '𧙧'),
+    (0x2F9C6, 'M', '裗'),
+    (0x2F9C7, 'M', '裞'),
+    (0x2F9C8, 'M', '䘵'),
+    (0x2F9C9, 'M', '裺'),
+    (0x2F9CA, 'M', '㒻'),
+    (0x2F9CB, 'M', '𧢮'),
+    (0x2F9CC, 'M', '𧥦'),
+    (0x2F9CD, 'M', '䚾'),
+    (0x2F9CE, 'M', '䛇'),
+    (0x2F9CF, 'M', '誠'),
+    (0x2F9D0, 'M', '諭'),
+    (0x2F9D1, 'M', '變'),
+    (0x2F9D2, 'M', '豕'),
+    (0x2F9D3, 'M', '𧲨'),
+    (0x2F9D4, 'M', '貫'),
+    (0x2F9D5, 'M', '賁'),
+    (0x2F9D6, 'M', '贛'),
+    (0x2F9D7, 'M', '起'),
+    ]
+
+def _seg_81() -> List[Union[Tuple[int, str], Tuple[int, str, str]]]:
+    return [
+    (0x2F9D8, 'M', '𧼯'),
+    (0x2F9D9, 'M', '𠠄'),
+    (0x2F9DA, 'M', '跋'),
+    (0x2F9DB, 'M', '趼'),
+    (0x2F9DC, 'M', '跰'),
+    (0x2F9DD, 'M', '𠣞'),
+    (0x2F9DE, 'M', '軔'),
+    (0x2F9DF, 'M', '輸'),
+    (0x2F9E0, 'M', '𨗒'),
+    (0x2F9E1, 'M', '𨗭'),
+    (0x2F9E2, 'M', '邔'),
+    (0x2F9E3, 'M', '郱'),
+    (0x2F9E4, 'M', '鄑'),
+    (0x2F9E5, 'M', '𨜮'),
+    (0x2F9E6, 'M', '鄛'),
+    (0x2F9E7, 'M', '鈸'),
+    (0x2F9E8, 'M', '鋗'),
+    (0x2F9E9, 'M', '鋘'),
+    (0x2F9EA, 'M', '鉼'),
+    (0x2F9EB, 'M', '鏹'),
+    (0x2F9EC, 'M', '鐕'),
+    (0x2F9ED, 'M', '𨯺'),
+    (0x2F9EE, 'M', '開'),
+    (0x2F9EF, 'M', '䦕'),
+    (0x2F9F0, 'M', '閷'),
+    (0x2F9F1, 'M', '𨵷'),
+    (0x2F9F2, 'M', '䧦'),
+    (0x2F9F3, 'M', '雃'),
+    (0x2F9F4, 'M', '嶲'),
+    (0x2F9F5, 'M', '霣'),
+    (0x2F9F6, 'M', '𩅅'),
+    (0x2F9F7, 'M', '𩈚'),
+    (0x2F9F8, 'M', '䩮'),
+    (0x2F9F9, 'M', '䩶'),
+    (0x2F9FA, 'M', '韠'),
+    (0x2F9FB, 'M', '𩐊'),
+    (0x2F9FC, 'M', '䪲'),
+    (0x2F9FD, 'M', '𩒖'),
+    (0x2F9FE, 'M', '頋'),
+    (0x2FA00, 'M', '頩'),
+    (0x2FA01, 'M', '𩖶'),
+    (0x2FA02, 'M', '飢'),
+    (0x2FA03, 'M', '䬳'),
+    (0x2FA04, 'M', '餩'),
+    (0x2FA05, 'M', '馧'),
+    (0x2FA06, 'M', '駂'),
+    (0x2FA07, 'M', '駾'),
+    (0x2FA08, 'M', '䯎'),
+    (0x2FA09, 'M', '𩬰'),
+    (0x2FA0A, 'M', '鬒'),
+    (0x2FA0B, 'M', '鱀'),
+    (0x2FA0C, 'M', '鳽'),
+    (0x2FA0D, 'M', '䳎'),
+    (0x2FA0E, 'M', '䳭'),
+    (0x2FA0F, 'M', '鵧'),
+    (0x2FA10, 'M', '𪃎'),
+    (0x2FA11, 'M', '䳸'),
+    (0x2FA12, 'M', '𪄅'),
+    (0x2FA13, 'M', '𪈎'),
+    (0x2FA14, 'M', '𪊑'),
+    (0x2FA15, 'M', '麻'),
+    (0x2FA16, 'M', '䵖'),
+    (0x2FA17, 'M', '黹'),
+    (0x2FA18, 'M', '黾'),
+    (0x2FA19, 'M', '鼅'),
+    (0x2FA1A, 'M', '鼏'),
+    (0x2FA1B, 'M', '鼖'),
+    (0x2FA1C, 'M', '鼻'),
+    (0x2FA1D, 'M', '𪘀'),
+    (0x2FA1E, 'X'),
+    (0x30000, 'V'),
+    (0x3134B, 'X'),
+    (0x31350, 'V'),
+    (0x323B0, 'X'),
+    (0xE0100, 'I'),
+    (0xE01F0, 'X'),
+    ]
+
+uts46data = tuple(
+    _seg_0()
+    + _seg_1()
+    + _seg_2()
+    + _seg_3()
+    + _seg_4()
+    + _seg_5()
+    + _seg_6()
+    + _seg_7()
+    + _seg_8()
+    + _seg_9()
+    + _seg_10()
+    + _seg_11()
+    + _seg_12()
+    + _seg_13()
+    + _seg_14()
+    + _seg_15()
+    + _seg_16()
+    + _seg_17()
+    + _seg_18()
+    + _seg_19()
+    + _seg_20()
+    + _seg_21()
+    + _seg_22()
+    + _seg_23()
+    + _seg_24()
+    + _seg_25()
+    + _seg_26()
+    + _seg_27()
+    + _seg_28()
+    + _seg_29()
+    + _seg_30()
+    + _seg_31()
+    + _seg_32()
+    + _seg_33()
+    + _seg_34()
+    + _seg_35()
+    + _seg_36()
+    + _seg_37()
+    + _seg_38()
+    + _seg_39()
+    + _seg_40()
+    + _seg_41()
+    + _seg_42()
+    + _seg_43()
+    + _seg_44()
+    + _seg_45()
+    + _seg_46()
+    + _seg_47()
+    + _seg_48()
+    + _seg_49()
+    + _seg_50()
+    + _seg_51()
+    + _seg_52()
+    + _seg_53()
+    + _seg_54()
+    + _seg_55()
+    + _seg_56()
+    + _seg_57()
+    + _seg_58()
+    + _seg_59()
+    + _seg_60()
+    + _seg_61()
+    + _seg_62()
+    + _seg_63()
+    + _seg_64()
+    + _seg_65()
+    + _seg_66()
+    + _seg_67()
+    + _seg_68()
+    + _seg_69()
+    + _seg_70()
+    + _seg_71()
+    + _seg_72()
+    + _seg_73()
+    + _seg_74()
+    + _seg_75()
+    + _seg_76()
+    + _seg_77()
+    + _seg_78()
+    + _seg_79()
+    + _seg_80()
+    + _seg_81()
+)  # type: Tuple[Union[Tuple[int, str], Tuple[int, str, str]], ...]
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/msgpack/__init__.py b/venv/lib/python3.12/site-packages/pip/_vendor/msgpack/__init__.py
new file mode 100644
index 00000000..919b86f1
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_vendor/msgpack/__init__.py
@@ -0,0 +1,55 @@
+from .exceptions import *
+from .ext import ExtType, Timestamp
+
+import os
+
+
+version = (1, 0, 8)
+__version__ = "1.0.8"
+
+
+if os.environ.get("MSGPACK_PUREPYTHON"):
+    from .fallback import Packer, unpackb, Unpacker
+else:
+    try:
+        from ._cmsgpack import Packer, unpackb, Unpacker
+    except ImportError:
+        from .fallback import Packer, unpackb, Unpacker
+
+
+def pack(o, stream, **kwargs):
+    """
+    Pack object `o` and write it to `stream`
+
+    See :class:`Packer` for options.
+    """
+    packer = Packer(**kwargs)
+    stream.write(packer.pack(o))
+
+
+def packb(o, **kwargs):
+    """
+    Pack object `o` and return packed bytes
+
+    See :class:`Packer` for options.
+    """
+    return Packer(**kwargs).pack(o)
+
+
+def unpack(stream, **kwargs):
+    """
+    Unpack an object from `stream`.
+
+    Raises `ExtraData` when `stream` contains extra bytes.
+    See :class:`Unpacker` for options.
+    """
+    data = stream.read()
+    return unpackb(data, **kwargs)
+
+
+# alias for compatibility to simplejson/marshal/pickle.
+load = unpack
+loads = unpackb
+
+dump = pack
+dumps = packb
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/msgpack/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_vendor/msgpack/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 00000000..c9edc6da
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_vendor/msgpack/__pycache__/__init__.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/msgpack/__pycache__/exceptions.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_vendor/msgpack/__pycache__/exceptions.cpython-312.pyc
new file mode 100644
index 00000000..d9609b2e
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_vendor/msgpack/__pycache__/exceptions.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/msgpack/__pycache__/ext.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_vendor/msgpack/__pycache__/ext.cpython-312.pyc
new file mode 100644
index 00000000..8bd7c7f5
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_vendor/msgpack/__pycache__/ext.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/msgpack/__pycache__/fallback.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_vendor/msgpack/__pycache__/fallback.cpython-312.pyc
new file mode 100644
index 00000000..0084b85f
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_vendor/msgpack/__pycache__/fallback.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/msgpack/exceptions.py b/venv/lib/python3.12/site-packages/pip/_vendor/msgpack/exceptions.py
new file mode 100644
index 00000000..d6d2615c
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_vendor/msgpack/exceptions.py
@@ -0,0 +1,48 @@
+class UnpackException(Exception):
+    """Base class for some exceptions raised while unpacking.
+
+    NOTE: unpack may raise exception other than subclass of
+    UnpackException.  If you want to catch all error, catch
+    Exception instead.
+    """
+
+
+class BufferFull(UnpackException):
+    pass
+
+
+class OutOfData(UnpackException):
+    pass
+
+
+class FormatError(ValueError, UnpackException):
+    """Invalid msgpack format"""
+
+
+class StackError(ValueError, UnpackException):
+    """Too nested"""
+
+
+# Deprecated.  Use ValueError instead
+UnpackValueError = ValueError
+
+
+class ExtraData(UnpackValueError):
+    """ExtraData is raised when there is trailing data.
+
+    This exception is raised while only one-shot (not streaming)
+    unpack.
+    """
+
+    def __init__(self, unpacked, extra):
+        self.unpacked = unpacked
+        self.extra = extra
+
+    def __str__(self):
+        return "unpack(b) received extra data."
+
+
+# Deprecated.  Use Exception instead to catch all exception during packing.
+PackException = Exception
+PackValueError = ValueError
+PackOverflowError = OverflowError
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/msgpack/ext.py b/venv/lib/python3.12/site-packages/pip/_vendor/msgpack/ext.py
new file mode 100644
index 00000000..02c2c430
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_vendor/msgpack/ext.py
@@ -0,0 +1,168 @@
+from collections import namedtuple
+import datetime
+import struct
+
+
+class ExtType(namedtuple("ExtType", "code data")):
+    """ExtType represents ext type in msgpack."""
+
+    def __new__(cls, code, data):
+        if not isinstance(code, int):
+            raise TypeError("code must be int")
+        if not isinstance(data, bytes):
+            raise TypeError("data must be bytes")
+        if not 0 <= code <= 127:
+            raise ValueError("code must be 0~127")
+        return super().__new__(cls, code, data)
+
+
+class Timestamp:
+    """Timestamp represents the Timestamp extension type in msgpack.
+
+    When built with Cython, msgpack uses C methods to pack and unpack `Timestamp`.
+    When using pure-Python msgpack, :func:`to_bytes` and :func:`from_bytes` are used to pack and
+    unpack `Timestamp`.
+
+    This class is immutable: Do not override seconds and nanoseconds.
+    """
+
+    __slots__ = ["seconds", "nanoseconds"]
+
+    def __init__(self, seconds, nanoseconds=0):
+        """Initialize a Timestamp object.
+
+        :param int seconds:
+            Number of seconds since the UNIX epoch (00:00:00 UTC Jan 1 1970, minus leap seconds).
+            May be negative.
+
+        :param int nanoseconds:
+            Number of nanoseconds to add to `seconds` to get fractional time.
+            Maximum is 999_999_999.  Default is 0.
+
+        Note: Negative times (before the UNIX epoch) are represented as neg. seconds + pos. ns.
+        """
+        if not isinstance(seconds, int):
+            raise TypeError("seconds must be an integer")
+        if not isinstance(nanoseconds, int):
+            raise TypeError("nanoseconds must be an integer")
+        if not (0 <= nanoseconds < 10**9):
+            raise ValueError("nanoseconds must be a non-negative integer less than 999999999.")
+        self.seconds = seconds
+        self.nanoseconds = nanoseconds
+
+    def __repr__(self):
+        """String representation of Timestamp."""
+        return f"Timestamp(seconds={self.seconds}, nanoseconds={self.nanoseconds})"
+
+    def __eq__(self, other):
+        """Check for equality with another Timestamp object"""
+        if type(other) is self.__class__:
+            return self.seconds == other.seconds and self.nanoseconds == other.nanoseconds
+        return False
+
+    def __ne__(self, other):
+        """not-equals method (see :func:`__eq__()`)"""
+        return not self.__eq__(other)
+
+    def __hash__(self):
+        return hash((self.seconds, self.nanoseconds))
+
+    @staticmethod
+    def from_bytes(b):
+        """Unpack bytes into a `Timestamp` object.
+
+        Used for pure-Python msgpack unpacking.
+
+        :param b: Payload from msgpack ext message with code -1
+        :type b: bytes
+
+        :returns: Timestamp object unpacked from msgpack ext payload
+        :rtype: Timestamp
+        """
+        if len(b) == 4:
+            seconds = struct.unpack("!L", b)[0]
+            nanoseconds = 0
+        elif len(b) == 8:
+            data64 = struct.unpack("!Q", b)[0]
+            seconds = data64 & 0x00000003FFFFFFFF
+            nanoseconds = data64 >> 34
+        elif len(b) == 12:
+            nanoseconds, seconds = struct.unpack("!Iq", b)
+        else:
+            raise ValueError(
+                "Timestamp type can only be created from 32, 64, or 96-bit byte objects"
+            )
+        return Timestamp(seconds, nanoseconds)
+
+    def to_bytes(self):
+        """Pack this Timestamp object into bytes.
+
+        Used for pure-Python msgpack packing.
+
+        :returns data: Payload for EXT message with code -1 (timestamp type)
+        :rtype: bytes
+        """
+        if (self.seconds >> 34) == 0:  # seconds is non-negative and fits in 34 bits
+            data64 = self.nanoseconds << 34 | self.seconds
+            if data64 & 0xFFFFFFFF00000000 == 0:
+                # nanoseconds is zero and seconds < 2**32, so timestamp 32
+                data = struct.pack("!L", data64)
+            else:
+                # timestamp 64
+                data = struct.pack("!Q", data64)
+        else:
+            # timestamp 96
+            data = struct.pack("!Iq", self.nanoseconds, self.seconds)
+        return data
+
+    @staticmethod
+    def from_unix(unix_sec):
+        """Create a Timestamp from posix timestamp in seconds.
+
+        :param unix_float: Posix timestamp in seconds.
+        :type unix_float: int or float
+        """
+        seconds = int(unix_sec // 1)
+        nanoseconds = int((unix_sec % 1) * 10**9)
+        return Timestamp(seconds, nanoseconds)
+
+    def to_unix(self):
+        """Get the timestamp as a floating-point value.
+
+        :returns: posix timestamp
+        :rtype: float
+        """
+        return self.seconds + self.nanoseconds / 1e9
+
+    @staticmethod
+    def from_unix_nano(unix_ns):
+        """Create a Timestamp from posix timestamp in nanoseconds.
+
+        :param int unix_ns: Posix timestamp in nanoseconds.
+        :rtype: Timestamp
+        """
+        return Timestamp(*divmod(unix_ns, 10**9))
+
+    def to_unix_nano(self):
+        """Get the timestamp as a unixtime in nanoseconds.
+
+        :returns: posix timestamp in nanoseconds
+        :rtype: int
+        """
+        return self.seconds * 10**9 + self.nanoseconds
+
+    def to_datetime(self):
+        """Get the timestamp as a UTC datetime.
+
+        :rtype: `datetime.datetime`
+        """
+        utc = datetime.timezone.utc
+        return datetime.datetime.fromtimestamp(0, utc) + datetime.timedelta(seconds=self.to_unix())
+
+    @staticmethod
+    def from_datetime(dt):
+        """Create a Timestamp from datetime with tzinfo.
+
+        :rtype: Timestamp
+        """
+        return Timestamp.from_unix(dt.timestamp())
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/msgpack/fallback.py b/venv/lib/python3.12/site-packages/pip/_vendor/msgpack/fallback.py
new file mode 100644
index 00000000..a174162a
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_vendor/msgpack/fallback.py
@@ -0,0 +1,951 @@
+"""Fallback pure Python implementation of msgpack"""
+from datetime import datetime as _DateTime
+import sys
+import struct
+
+
+if hasattr(sys, "pypy_version_info"):
+    # StringIO is slow on PyPy, StringIO is faster.  However: PyPy's own
+    # StringBuilder is fastest.
+    from __pypy__ import newlist_hint
+
+    try:
+        from __pypy__.builders import BytesBuilder as StringBuilder
+    except ImportError:
+        from __pypy__.builders import StringBuilder
+    USING_STRINGBUILDER = True
+
+    class StringIO:
+        def __init__(self, s=b""):
+            if s:
+                self.builder = StringBuilder(len(s))
+                self.builder.append(s)
+            else:
+                self.builder = StringBuilder()
+
+        def write(self, s):
+            if isinstance(s, memoryview):
+                s = s.tobytes()
+            elif isinstance(s, bytearray):
+                s = bytes(s)
+            self.builder.append(s)
+
+        def getvalue(self):
+            return self.builder.build()
+
+else:
+    USING_STRINGBUILDER = False
+    from io import BytesIO as StringIO
+
+    newlist_hint = lambda size: []
+
+
+from .exceptions import BufferFull, OutOfData, ExtraData, FormatError, StackError
+
+from .ext import ExtType, Timestamp
+
+
+EX_SKIP = 0
+EX_CONSTRUCT = 1
+EX_READ_ARRAY_HEADER = 2
+EX_READ_MAP_HEADER = 3
+
+TYPE_IMMEDIATE = 0
+TYPE_ARRAY = 1
+TYPE_MAP = 2
+TYPE_RAW = 3
+TYPE_BIN = 4
+TYPE_EXT = 5
+
+DEFAULT_RECURSE_LIMIT = 511
+
+
+def _check_type_strict(obj, t, type=type, tuple=tuple):
+    if type(t) is tuple:
+        return type(obj) in t
+    else:
+        return type(obj) is t
+
+
+def _get_data_from_buffer(obj):
+    view = memoryview(obj)
+    if view.itemsize != 1:
+        raise ValueError("cannot unpack from multi-byte object")
+    return view
+
+
+def unpackb(packed, **kwargs):
+    """
+    Unpack an object from `packed`.
+
+    Raises ``ExtraData`` when *packed* contains extra bytes.
+    Raises ``ValueError`` when *packed* is incomplete.
+    Raises ``FormatError`` when *packed* is not valid msgpack.
+    Raises ``StackError`` when *packed* contains too nested.
+    Other exceptions can be raised during unpacking.
+
+    See :class:`Unpacker` for options.
+    """
+    unpacker = Unpacker(None, max_buffer_size=len(packed), **kwargs)
+    unpacker.feed(packed)
+    try:
+        ret = unpacker._unpack()
+    except OutOfData:
+        raise ValueError("Unpack failed: incomplete input")
+    except RecursionError:
+        raise StackError
+    if unpacker._got_extradata():
+        raise ExtraData(ret, unpacker._get_extradata())
+    return ret
+
+
+_NO_FORMAT_USED = ""
+_MSGPACK_HEADERS = {
+    0xC4: (1, _NO_FORMAT_USED, TYPE_BIN),
+    0xC5: (2, ">H", TYPE_BIN),
+    0xC6: (4, ">I", TYPE_BIN),
+    0xC7: (2, "Bb", TYPE_EXT),
+    0xC8: (3, ">Hb", TYPE_EXT),
+    0xC9: (5, ">Ib", TYPE_EXT),
+    0xCA: (4, ">f"),
+    0xCB: (8, ">d"),
+    0xCC: (1, _NO_FORMAT_USED),
+    0xCD: (2, ">H"),
+    0xCE: (4, ">I"),
+    0xCF: (8, ">Q"),
+    0xD0: (1, "b"),
+    0xD1: (2, ">h"),
+    0xD2: (4, ">i"),
+    0xD3: (8, ">q"),
+    0xD4: (1, "b1s", TYPE_EXT),
+    0xD5: (2, "b2s", TYPE_EXT),
+    0xD6: (4, "b4s", TYPE_EXT),
+    0xD7: (8, "b8s", TYPE_EXT),
+    0xD8: (16, "b16s", TYPE_EXT),
+    0xD9: (1, _NO_FORMAT_USED, TYPE_RAW),
+    0xDA: (2, ">H", TYPE_RAW),
+    0xDB: (4, ">I", TYPE_RAW),
+    0xDC: (2, ">H", TYPE_ARRAY),
+    0xDD: (4, ">I", TYPE_ARRAY),
+    0xDE: (2, ">H", TYPE_MAP),
+    0xDF: (4, ">I", TYPE_MAP),
+}
+
+
+class Unpacker:
+    """Streaming unpacker.
+
+    Arguments:
+
+    :param file_like:
+        File-like object having `.read(n)` method.
+        If specified, unpacker reads serialized data from it and `.feed()` is not usable.
+
+    :param int read_size:
+        Used as `file_like.read(read_size)`. (default: `min(16*1024, max_buffer_size)`)
+
+    :param bool use_list:
+        If true, unpack msgpack array to Python list.
+        Otherwise, unpack to Python tuple. (default: True)
+
+    :param bool raw:
+        If true, unpack msgpack raw to Python bytes.
+        Otherwise, unpack to Python str by decoding with UTF-8 encoding (default).
+
+    :param int timestamp:
+        Control how timestamp type is unpacked:
+
+            0 - Timestamp
+            1 - float  (Seconds from the EPOCH)
+            2 - int  (Nanoseconds from the EPOCH)
+            3 - datetime.datetime  (UTC).
+
+    :param bool strict_map_key:
+        If true (default), only str or bytes are accepted for map (dict) keys.
+
+    :param object_hook:
+        When specified, it should be callable.
+        Unpacker calls it with a dict argument after unpacking msgpack map.
+        (See also simplejson)
+
+    :param object_pairs_hook:
+        When specified, it should be callable.
+        Unpacker calls it with a list of key-value pairs after unpacking msgpack map.
+        (See also simplejson)
+
+    :param str unicode_errors:
+        The error handler for decoding unicode. (default: 'strict')
+        This option should be used only when you have msgpack data which
+        contains invalid UTF-8 string.
+
+    :param int max_buffer_size:
+        Limits size of data waiting unpacked.  0 means 2**32-1.
+        The default value is 100*1024*1024 (100MiB).
+        Raises `BufferFull` exception when it is insufficient.
+        You should set this parameter when unpacking data from untrusted source.
+
+    :param int max_str_len:
+        Deprecated, use *max_buffer_size* instead.
+        Limits max length of str. (default: max_buffer_size)
+
+    :param int max_bin_len:
+        Deprecated, use *max_buffer_size* instead.
+        Limits max length of bin. (default: max_buffer_size)
+
+    :param int max_array_len:
+        Limits max length of array.
+        (default: max_buffer_size)
+
+    :param int max_map_len:
+        Limits max length of map.
+        (default: max_buffer_size//2)
+
+    :param int max_ext_len:
+        Deprecated, use *max_buffer_size* instead.
+        Limits max size of ext type.  (default: max_buffer_size)
+
+    Example of streaming deserialize from file-like object::
+
+        unpacker = Unpacker(file_like)
+        for o in unpacker:
+            process(o)
+
+    Example of streaming deserialize from socket::
+
+        unpacker = Unpacker()
+        while True:
+            buf = sock.recv(1024**2)
+            if not buf:
+                break
+            unpacker.feed(buf)
+            for o in unpacker:
+                process(o)
+
+    Raises ``ExtraData`` when *packed* contains extra bytes.
+    Raises ``OutOfData`` when *packed* is incomplete.
+    Raises ``FormatError`` when *packed* is not valid msgpack.
+    Raises ``StackError`` when *packed* contains too nested.
+    Other exceptions can be raised during unpacking.
+    """
+
+    def __init__(
+        self,
+        file_like=None,
+        read_size=0,
+        use_list=True,
+        raw=False,
+        timestamp=0,
+        strict_map_key=True,
+        object_hook=None,
+        object_pairs_hook=None,
+        list_hook=None,
+        unicode_errors=None,
+        max_buffer_size=100 * 1024 * 1024,
+        ext_hook=ExtType,
+        max_str_len=-1,
+        max_bin_len=-1,
+        max_array_len=-1,
+        max_map_len=-1,
+        max_ext_len=-1,
+    ):
+        if unicode_errors is None:
+            unicode_errors = "strict"
+
+        if file_like is None:
+            self._feeding = True
+        else:
+            if not callable(file_like.read):
+                raise TypeError("`file_like.read` must be callable")
+            self.file_like = file_like
+            self._feeding = False
+
+        #: array of bytes fed.
+        self._buffer = bytearray()
+        #: Which position we currently reads
+        self._buff_i = 0
+
+        # When Unpacker is used as an iterable, between the calls to next(),
+        # the buffer is not "consumed" completely, for efficiency sake.
+        # Instead, it is done sloppily.  To make sure we raise BufferFull at
+        # the correct moments, we have to keep track of how sloppy we were.
+        # Furthermore, when the buffer is incomplete (that is: in the case
+        # we raise an OutOfData) we need to rollback the buffer to the correct
+        # state, which _buf_checkpoint records.
+        self._buf_checkpoint = 0
+
+        if not max_buffer_size:
+            max_buffer_size = 2**31 - 1
+        if max_str_len == -1:
+            max_str_len = max_buffer_size
+        if max_bin_len == -1:
+            max_bin_len = max_buffer_size
+        if max_array_len == -1:
+            max_array_len = max_buffer_size
+        if max_map_len == -1:
+            max_map_len = max_buffer_size // 2
+        if max_ext_len == -1:
+            max_ext_len = max_buffer_size
+
+        self._max_buffer_size = max_buffer_size
+        if read_size > self._max_buffer_size:
+            raise ValueError("read_size must be smaller than max_buffer_size")
+        self._read_size = read_size or min(self._max_buffer_size, 16 * 1024)
+        self._raw = bool(raw)
+        self._strict_map_key = bool(strict_map_key)
+        self._unicode_errors = unicode_errors
+        self._use_list = use_list
+        if not (0 <= timestamp <= 3):
+            raise ValueError("timestamp must be 0..3")
+        self._timestamp = timestamp
+        self._list_hook = list_hook
+        self._object_hook = object_hook
+        self._object_pairs_hook = object_pairs_hook
+        self._ext_hook = ext_hook
+        self._max_str_len = max_str_len
+        self._max_bin_len = max_bin_len
+        self._max_array_len = max_array_len
+        self._max_map_len = max_map_len
+        self._max_ext_len = max_ext_len
+        self._stream_offset = 0
+
+        if list_hook is not None and not callable(list_hook):
+            raise TypeError("`list_hook` is not callable")
+        if object_hook is not None and not callable(object_hook):
+            raise TypeError("`object_hook` is not callable")
+        if object_pairs_hook is not None and not callable(object_pairs_hook):
+            raise TypeError("`object_pairs_hook` is not callable")
+        if object_hook is not None and object_pairs_hook is not None:
+            raise TypeError("object_pairs_hook and object_hook are mutually exclusive")
+        if not callable(ext_hook):
+            raise TypeError("`ext_hook` is not callable")
+
+    def feed(self, next_bytes):
+        assert self._feeding
+        view = _get_data_from_buffer(next_bytes)
+        if len(self._buffer) - self._buff_i + len(view) > self._max_buffer_size:
+            raise BufferFull
+
+        # Strip buffer before checkpoint before reading file.
+        if self._buf_checkpoint > 0:
+            del self._buffer[: self._buf_checkpoint]
+            self._buff_i -= self._buf_checkpoint
+            self._buf_checkpoint = 0
+
+        # Use extend here: INPLACE_ADD += doesn't reliably typecast memoryview in jython
+        self._buffer.extend(view)
+
+    def _consume(self):
+        """Gets rid of the used parts of the buffer."""
+        self._stream_offset += self._buff_i - self._buf_checkpoint
+        self._buf_checkpoint = self._buff_i
+
+    def _got_extradata(self):
+        return self._buff_i < len(self._buffer)
+
+    def _get_extradata(self):
+        return self._buffer[self._buff_i :]
+
+    def read_bytes(self, n):
+        ret = self._read(n, raise_outofdata=False)
+        self._consume()
+        return ret
+
+    def _read(self, n, raise_outofdata=True):
+        # (int) -> bytearray
+        self._reserve(n, raise_outofdata=raise_outofdata)
+        i = self._buff_i
+        ret = self._buffer[i : i + n]
+        self._buff_i = i + len(ret)
+        return ret
+
+    def _reserve(self, n, raise_outofdata=True):
+        remain_bytes = len(self._buffer) - self._buff_i - n
+
+        # Fast path: buffer has n bytes already
+        if remain_bytes >= 0:
+            return
+
+        if self._feeding:
+            self._buff_i = self._buf_checkpoint
+            raise OutOfData
+
+        # Strip buffer before checkpoint before reading file.
+        if self._buf_checkpoint > 0:
+            del self._buffer[: self._buf_checkpoint]
+            self._buff_i -= self._buf_checkpoint
+            self._buf_checkpoint = 0
+
+        # Read from file
+        remain_bytes = -remain_bytes
+        if remain_bytes + len(self._buffer) > self._max_buffer_size:
+            raise BufferFull
+        while remain_bytes > 0:
+            to_read_bytes = max(self._read_size, remain_bytes)
+            read_data = self.file_like.read(to_read_bytes)
+            if not read_data:
+                break
+            assert isinstance(read_data, bytes)
+            self._buffer += read_data
+            remain_bytes -= len(read_data)
+
+        if len(self._buffer) < n + self._buff_i and raise_outofdata:
+            self._buff_i = 0  # rollback
+            raise OutOfData
+
+    def _read_header(self):
+        typ = TYPE_IMMEDIATE
+        n = 0
+        obj = None
+        self._reserve(1)
+        b = self._buffer[self._buff_i]
+        self._buff_i += 1
+        if b & 0b10000000 == 0:
+            obj = b
+        elif b & 0b11100000 == 0b11100000:
+            obj = -1 - (b ^ 0xFF)
+        elif b & 0b11100000 == 0b10100000:
+            n = b & 0b00011111
+            typ = TYPE_RAW
+            if n > self._max_str_len:
+                raise ValueError(f"{n} exceeds max_str_len({self._max_str_len})")
+            obj = self._read(n)
+        elif b & 0b11110000 == 0b10010000:
+            n = b & 0b00001111
+            typ = TYPE_ARRAY
+            if n > self._max_array_len:
+                raise ValueError(f"{n} exceeds max_array_len({self._max_array_len})")
+        elif b & 0b11110000 == 0b10000000:
+            n = b & 0b00001111
+            typ = TYPE_MAP
+            if n > self._max_map_len:
+                raise ValueError(f"{n} exceeds max_map_len({self._max_map_len})")
+        elif b == 0xC0:
+            obj = None
+        elif b == 0xC2:
+            obj = False
+        elif b == 0xC3:
+            obj = True
+        elif 0xC4 <= b <= 0xC6:
+            size, fmt, typ = _MSGPACK_HEADERS[b]
+            self._reserve(size)
+            if len(fmt) > 0:
+                n = struct.unpack_from(fmt, self._buffer, self._buff_i)[0]
+            else:
+                n = self._buffer[self._buff_i]
+            self._buff_i += size
+            if n > self._max_bin_len:
+                raise ValueError(f"{n} exceeds max_bin_len({self._max_bin_len})")
+            obj = self._read(n)
+        elif 0xC7 <= b <= 0xC9:
+            size, fmt, typ = _MSGPACK_HEADERS[b]
+            self._reserve(size)
+            L, n = struct.unpack_from(fmt, self._buffer, self._buff_i)
+            self._buff_i += size
+            if L > self._max_ext_len:
+                raise ValueError(f"{L} exceeds max_ext_len({self._max_ext_len})")
+            obj = self._read(L)
+        elif 0xCA <= b <= 0xD3:
+            size, fmt = _MSGPACK_HEADERS[b]
+            self._reserve(size)
+            if len(fmt) > 0:
+                obj = struct.unpack_from(fmt, self._buffer, self._buff_i)[0]
+            else:
+                obj = self._buffer[self._buff_i]
+            self._buff_i += size
+        elif 0xD4 <= b <= 0xD8:
+            size, fmt, typ = _MSGPACK_HEADERS[b]
+            if self._max_ext_len < size:
+                raise ValueError(f"{size} exceeds max_ext_len({self._max_ext_len})")
+            self._reserve(size + 1)
+            n, obj = struct.unpack_from(fmt, self._buffer, self._buff_i)
+            self._buff_i += size + 1
+        elif 0xD9 <= b <= 0xDB:
+            size, fmt, typ = _MSGPACK_HEADERS[b]
+            self._reserve(size)
+            if len(fmt) > 0:
+                (n,) = struct.unpack_from(fmt, self._buffer, self._buff_i)
+            else:
+                n = self._buffer[self._buff_i]
+            self._buff_i += size
+            if n > self._max_str_len:
+                raise ValueError(f"{n} exceeds max_str_len({self._max_str_len})")
+            obj = self._read(n)
+        elif 0xDC <= b <= 0xDD:
+            size, fmt, typ = _MSGPACK_HEADERS[b]
+            self._reserve(size)
+            (n,) = struct.unpack_from(fmt, self._buffer, self._buff_i)
+            self._buff_i += size
+            if n > self._max_array_len:
+                raise ValueError(f"{n} exceeds max_array_len({self._max_array_len})")
+        elif 0xDE <= b <= 0xDF:
+            size, fmt, typ = _MSGPACK_HEADERS[b]
+            self._reserve(size)
+            (n,) = struct.unpack_from(fmt, self._buffer, self._buff_i)
+            self._buff_i += size
+            if n > self._max_map_len:
+                raise ValueError(f"{n} exceeds max_map_len({self._max_map_len})")
+        else:
+            raise FormatError("Unknown header: 0x%x" % b)
+        return typ, n, obj
+
+    def _unpack(self, execute=EX_CONSTRUCT):
+        typ, n, obj = self._read_header()
+
+        if execute == EX_READ_ARRAY_HEADER:
+            if typ != TYPE_ARRAY:
+                raise ValueError("Expected array")
+            return n
+        if execute == EX_READ_MAP_HEADER:
+            if typ != TYPE_MAP:
+                raise ValueError("Expected map")
+            return n
+        # TODO should we eliminate the recursion?
+        if typ == TYPE_ARRAY:
+            if execute == EX_SKIP:
+                for i in range(n):
+                    # TODO check whether we need to call `list_hook`
+                    self._unpack(EX_SKIP)
+                return
+            ret = newlist_hint(n)
+            for i in range(n):
+                ret.append(self._unpack(EX_CONSTRUCT))
+            if self._list_hook is not None:
+                ret = self._list_hook(ret)
+            # TODO is the interaction between `list_hook` and `use_list` ok?
+            return ret if self._use_list else tuple(ret)
+        if typ == TYPE_MAP:
+            if execute == EX_SKIP:
+                for i in range(n):
+                    # TODO check whether we need to call hooks
+                    self._unpack(EX_SKIP)
+                    self._unpack(EX_SKIP)
+                return
+            if self._object_pairs_hook is not None:
+                ret = self._object_pairs_hook(
+                    (self._unpack(EX_CONSTRUCT), self._unpack(EX_CONSTRUCT)) for _ in range(n)
+                )
+            else:
+                ret = {}
+                for _ in range(n):
+                    key = self._unpack(EX_CONSTRUCT)
+                    if self._strict_map_key and type(key) not in (str, bytes):
+                        raise ValueError("%s is not allowed for map key" % str(type(key)))
+                    if isinstance(key, str):
+                        key = sys.intern(key)
+                    ret[key] = self._unpack(EX_CONSTRUCT)
+                if self._object_hook is not None:
+                    ret = self._object_hook(ret)
+            return ret
+        if execute == EX_SKIP:
+            return
+        if typ == TYPE_RAW:
+            if self._raw:
+                obj = bytes(obj)
+            else:
+                obj = obj.decode("utf_8", self._unicode_errors)
+            return obj
+        if typ == TYPE_BIN:
+            return bytes(obj)
+        if typ == TYPE_EXT:
+            if n == -1:  # timestamp
+                ts = Timestamp.from_bytes(bytes(obj))
+                if self._timestamp == 1:
+                    return ts.to_unix()
+                elif self._timestamp == 2:
+                    return ts.to_unix_nano()
+                elif self._timestamp == 3:
+                    return ts.to_datetime()
+                else:
+                    return ts
+            else:
+                return self._ext_hook(n, bytes(obj))
+        assert typ == TYPE_IMMEDIATE
+        return obj
+
+    def __iter__(self):
+        return self
+
+    def __next__(self):
+        try:
+            ret = self._unpack(EX_CONSTRUCT)
+            self._consume()
+            return ret
+        except OutOfData:
+            self._consume()
+            raise StopIteration
+        except RecursionError:
+            raise StackError
+
+    next = __next__
+
+    def skip(self):
+        self._unpack(EX_SKIP)
+        self._consume()
+
+    def unpack(self):
+        try:
+            ret = self._unpack(EX_CONSTRUCT)
+        except RecursionError:
+            raise StackError
+        self._consume()
+        return ret
+
+    def read_array_header(self):
+        ret = self._unpack(EX_READ_ARRAY_HEADER)
+        self._consume()
+        return ret
+
+    def read_map_header(self):
+        ret = self._unpack(EX_READ_MAP_HEADER)
+        self._consume()
+        return ret
+
+    def tell(self):
+        return self._stream_offset
+
+
+class Packer:
+    """
+    MessagePack Packer
+
+    Usage::
+
+        packer = Packer()
+        astream.write(packer.pack(a))
+        astream.write(packer.pack(b))
+
+    Packer's constructor has some keyword arguments:
+
+    :param default:
+        When specified, it should be callable.
+        Convert user type to builtin type that Packer supports.
+        See also simplejson's document.
+
+    :param bool use_single_float:
+        Use single precision float type for float. (default: False)
+
+    :param bool autoreset:
+        Reset buffer after each pack and return its content as `bytes`. (default: True).
+        If set this to false, use `bytes()` to get content and `.reset()` to clear buffer.
+
+    :param bool use_bin_type:
+        Use bin type introduced in msgpack spec 2.0 for bytes.
+        It also enables str8 type for unicode. (default: True)
+
+    :param bool strict_types:
+        If set to true, types will be checked to be exact. Derived classes
+        from serializable types will not be serialized and will be
+        treated as unsupported type and forwarded to default.
+        Additionally tuples will not be serialized as lists.
+        This is useful when trying to implement accurate serialization
+        for python types.
+
+    :param bool datetime:
+        If set to true, datetime with tzinfo is packed into Timestamp type.
+        Note that the tzinfo is stripped in the timestamp.
+        You can get UTC datetime with `timestamp=3` option of the Unpacker.
+
+    :param str unicode_errors:
+        The error handler for encoding unicode. (default: 'strict')
+        DO NOT USE THIS!!  This option is kept for very specific usage.
+
+    Example of streaming deserialize from file-like object::
+
+        unpacker = Unpacker(file_like)
+        for o in unpacker:
+            process(o)
+
+    Example of streaming deserialize from socket::
+
+        unpacker = Unpacker()
+        while True:
+            buf = sock.recv(1024**2)
+            if not buf:
+                break
+            unpacker.feed(buf)
+            for o in unpacker:
+                process(o)
+
+    Raises ``ExtraData`` when *packed* contains extra bytes.
+    Raises ``OutOfData`` when *packed* is incomplete.
+    Raises ``FormatError`` when *packed* is not valid msgpack.
+    Raises ``StackError`` when *packed* contains too nested.
+    Other exceptions can be raised during unpacking.
+    """
+
+    def __init__(
+        self,
+        default=None,
+        use_single_float=False,
+        autoreset=True,
+        use_bin_type=True,
+        strict_types=False,
+        datetime=False,
+        unicode_errors=None,
+    ):
+        self._strict_types = strict_types
+        self._use_float = use_single_float
+        self._autoreset = autoreset
+        self._use_bin_type = use_bin_type
+        self._buffer = StringIO()
+        self._datetime = bool(datetime)
+        self._unicode_errors = unicode_errors or "strict"
+        if default is not None:
+            if not callable(default):
+                raise TypeError("default must be callable")
+        self._default = default
+
+    def _pack(
+        self,
+        obj,
+        nest_limit=DEFAULT_RECURSE_LIMIT,
+        check=isinstance,
+        check_type_strict=_check_type_strict,
+    ):
+        default_used = False
+        if self._strict_types:
+            check = check_type_strict
+            list_types = list
+        else:
+            list_types = (list, tuple)
+        while True:
+            if nest_limit < 0:
+                raise ValueError("recursion limit exceeded")
+            if obj is None:
+                return self._buffer.write(b"\xc0")
+            if check(obj, bool):
+                if obj:
+                    return self._buffer.write(b"\xc3")
+                return self._buffer.write(b"\xc2")
+            if check(obj, int):
+                if 0 <= obj < 0x80:
+                    return self._buffer.write(struct.pack("B", obj))
+                if -0x20 <= obj < 0:
+                    return self._buffer.write(struct.pack("b", obj))
+                if 0x80 <= obj <= 0xFF:
+                    return self._buffer.write(struct.pack("BB", 0xCC, obj))
+                if -0x80 <= obj < 0:
+                    return self._buffer.write(struct.pack(">Bb", 0xD0, obj))
+                if 0xFF < obj <= 0xFFFF:
+                    return self._buffer.write(struct.pack(">BH", 0xCD, obj))
+                if -0x8000 <= obj < -0x80:
+                    return self._buffer.write(struct.pack(">Bh", 0xD1, obj))
+                if 0xFFFF < obj <= 0xFFFFFFFF:
+                    return self._buffer.write(struct.pack(">BI", 0xCE, obj))
+                if -0x80000000 <= obj < -0x8000:
+                    return self._buffer.write(struct.pack(">Bi", 0xD2, obj))
+                if 0xFFFFFFFF < obj <= 0xFFFFFFFFFFFFFFFF:
+                    return self._buffer.write(struct.pack(">BQ", 0xCF, obj))
+                if -0x8000000000000000 <= obj < -0x80000000:
+                    return self._buffer.write(struct.pack(">Bq", 0xD3, obj))
+                if not default_used and self._default is not None:
+                    obj = self._default(obj)
+                    default_used = True
+                    continue
+                raise OverflowError("Integer value out of range")
+            if check(obj, (bytes, bytearray)):
+                n = len(obj)
+                if n >= 2**32:
+                    raise ValueError("%s is too large" % type(obj).__name__)
+                self._pack_bin_header(n)
+                return self._buffer.write(obj)
+            if check(obj, str):
+                obj = obj.encode("utf-8", self._unicode_errors)
+                n = len(obj)
+                if n >= 2**32:
+                    raise ValueError("String is too large")
+                self._pack_raw_header(n)
+                return self._buffer.write(obj)
+            if check(obj, memoryview):
+                n = obj.nbytes
+                if n >= 2**32:
+                    raise ValueError("Memoryview is too large")
+                self._pack_bin_header(n)
+                return self._buffer.write(obj)
+            if check(obj, float):
+                if self._use_float:
+                    return self._buffer.write(struct.pack(">Bf", 0xCA, obj))
+                return self._buffer.write(struct.pack(">Bd", 0xCB, obj))
+            if check(obj, (ExtType, Timestamp)):
+                if check(obj, Timestamp):
+                    code = -1
+                    data = obj.to_bytes()
+                else:
+                    code = obj.code
+                    data = obj.data
+                assert isinstance(code, int)
+                assert isinstance(data, bytes)
+                L = len(data)
+                if L == 1:
+                    self._buffer.write(b"\xd4")
+                elif L == 2:
+                    self._buffer.write(b"\xd5")
+                elif L == 4:
+                    self._buffer.write(b"\xd6")
+                elif L == 8:
+                    self._buffer.write(b"\xd7")
+                elif L == 16:
+                    self._buffer.write(b"\xd8")
+                elif L <= 0xFF:
+                    self._buffer.write(struct.pack(">BB", 0xC7, L))
+                elif L <= 0xFFFF:
+                    self._buffer.write(struct.pack(">BH", 0xC8, L))
+                else:
+                    self._buffer.write(struct.pack(">BI", 0xC9, L))
+                self._buffer.write(struct.pack("b", code))
+                self._buffer.write(data)
+                return
+            if check(obj, list_types):
+                n = len(obj)
+                self._pack_array_header(n)
+                for i in range(n):
+                    self._pack(obj[i], nest_limit - 1)
+                return
+            if check(obj, dict):
+                return self._pack_map_pairs(len(obj), obj.items(), nest_limit - 1)
+
+            if self._datetime and check(obj, _DateTime) and obj.tzinfo is not None:
+                obj = Timestamp.from_datetime(obj)
+                default_used = 1
+                continue
+
+            if not default_used and self._default is not None:
+                obj = self._default(obj)
+                default_used = 1
+                continue
+
+            if self._datetime and check(obj, _DateTime):
+                raise ValueError(f"Cannot serialize {obj!r} where tzinfo=None")
+
+            raise TypeError(f"Cannot serialize {obj!r}")
+
+    def pack(self, obj):
+        try:
+            self._pack(obj)
+        except:
+            self._buffer = StringIO()  # force reset
+            raise
+        if self._autoreset:
+            ret = self._buffer.getvalue()
+            self._buffer = StringIO()
+            return ret
+
+    def pack_map_pairs(self, pairs):
+        self._pack_map_pairs(len(pairs), pairs)
+        if self._autoreset:
+            ret = self._buffer.getvalue()
+            self._buffer = StringIO()
+            return ret
+
+    def pack_array_header(self, n):
+        if n >= 2**32:
+            raise ValueError
+        self._pack_array_header(n)
+        if self._autoreset:
+            ret = self._buffer.getvalue()
+            self._buffer = StringIO()
+            return ret
+
+    def pack_map_header(self, n):
+        if n >= 2**32:
+            raise ValueError
+        self._pack_map_header(n)
+        if self._autoreset:
+            ret = self._buffer.getvalue()
+            self._buffer = StringIO()
+            return ret
+
+    def pack_ext_type(self, typecode, data):
+        if not isinstance(typecode, int):
+            raise TypeError("typecode must have int type.")
+        if not 0 <= typecode <= 127:
+            raise ValueError("typecode should be 0-127")
+        if not isinstance(data, bytes):
+            raise TypeError("data must have bytes type")
+        L = len(data)
+        if L > 0xFFFFFFFF:
+            raise ValueError("Too large data")
+        if L == 1:
+            self._buffer.write(b"\xd4")
+        elif L == 2:
+            self._buffer.write(b"\xd5")
+        elif L == 4:
+            self._buffer.write(b"\xd6")
+        elif L == 8:
+            self._buffer.write(b"\xd7")
+        elif L == 16:
+            self._buffer.write(b"\xd8")
+        elif L <= 0xFF:
+            self._buffer.write(b"\xc7" + struct.pack("B", L))
+        elif L <= 0xFFFF:
+            self._buffer.write(b"\xc8" + struct.pack(">H", L))
+        else:
+            self._buffer.write(b"\xc9" + struct.pack(">I", L))
+        self._buffer.write(struct.pack("B", typecode))
+        self._buffer.write(data)
+
+    def _pack_array_header(self, n):
+        if n <= 0x0F:
+            return self._buffer.write(struct.pack("B", 0x90 + n))
+        if n <= 0xFFFF:
+            return self._buffer.write(struct.pack(">BH", 0xDC, n))
+        if n <= 0xFFFFFFFF:
+            return self._buffer.write(struct.pack(">BI", 0xDD, n))
+        raise ValueError("Array is too large")
+
+    def _pack_map_header(self, n):
+        if n <= 0x0F:
+            return self._buffer.write(struct.pack("B", 0x80 + n))
+        if n <= 0xFFFF:
+            return self._buffer.write(struct.pack(">BH", 0xDE, n))
+        if n <= 0xFFFFFFFF:
+            return self._buffer.write(struct.pack(">BI", 0xDF, n))
+        raise ValueError("Dict is too large")
+
+    def _pack_map_pairs(self, n, pairs, nest_limit=DEFAULT_RECURSE_LIMIT):
+        self._pack_map_header(n)
+        for k, v in pairs:
+            self._pack(k, nest_limit - 1)
+            self._pack(v, nest_limit - 1)
+
+    def _pack_raw_header(self, n):
+        if n <= 0x1F:
+            self._buffer.write(struct.pack("B", 0xA0 + n))
+        elif self._use_bin_type and n <= 0xFF:
+            self._buffer.write(struct.pack(">BB", 0xD9, n))
+        elif n <= 0xFFFF:
+            self._buffer.write(struct.pack(">BH", 0xDA, n))
+        elif n <= 0xFFFFFFFF:
+            self._buffer.write(struct.pack(">BI", 0xDB, n))
+        else:
+            raise ValueError("Raw is too large")
+
+    def _pack_bin_header(self, n):
+        if not self._use_bin_type:
+            return self._pack_raw_header(n)
+        elif n <= 0xFF:
+            return self._buffer.write(struct.pack(">BB", 0xC4, n))
+        elif n <= 0xFFFF:
+            return self._buffer.write(struct.pack(">BH", 0xC5, n))
+        elif n <= 0xFFFFFFFF:
+            return self._buffer.write(struct.pack(">BI", 0xC6, n))
+        else:
+            raise ValueError("Bin is too large")
+
+    def bytes(self):
+        """Return internal buffer contents as bytes object"""
+        return self._buffer.getvalue()
+
+    def reset(self):
+        """Reset internal buffer.
+
+        This method is useful only when autoreset=False.
+        """
+        self._buffer = StringIO()
+
+    def getbuffer(self):
+        """Return view of internal buffer."""
+        if USING_STRINGBUILDER:
+            return memoryview(self.bytes())
+        else:
+            return self._buffer.getbuffer()
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/packaging/__init__.py b/venv/lib/python3.12/site-packages/pip/_vendor/packaging/__init__.py
new file mode 100644
index 00000000..9ba41d83
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_vendor/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__ = "24.1"
+
+__author__ = "Donald Stufft and individual contributors"
+__email__ = "donald@stufft.io"
+
+__license__ = "BSD-2-Clause or Apache-2.0"
+__copyright__ = "2014 %s" % __author__
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/packaging/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_vendor/packaging/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 00000000..385609ed
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_vendor/packaging/__pycache__/__init__.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/packaging/__pycache__/_elffile.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_vendor/packaging/__pycache__/_elffile.cpython-312.pyc
new file mode 100644
index 00000000..dc4d22c6
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_vendor/packaging/__pycache__/_elffile.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/packaging/__pycache__/_manylinux.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_vendor/packaging/__pycache__/_manylinux.cpython-312.pyc
new file mode 100644
index 00000000..0d2610d9
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_vendor/packaging/__pycache__/_manylinux.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/packaging/__pycache__/_musllinux.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_vendor/packaging/__pycache__/_musllinux.cpython-312.pyc
new file mode 100644
index 00000000..008f22f5
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_vendor/packaging/__pycache__/_musllinux.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/packaging/__pycache__/_parser.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_vendor/packaging/__pycache__/_parser.cpython-312.pyc
new file mode 100644
index 00000000..60c6187f
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_vendor/packaging/__pycache__/_parser.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/packaging/__pycache__/_structures.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_vendor/packaging/__pycache__/_structures.cpython-312.pyc
new file mode 100644
index 00000000..1e0036ee
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_vendor/packaging/__pycache__/_structures.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/packaging/__pycache__/_tokenizer.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_vendor/packaging/__pycache__/_tokenizer.cpython-312.pyc
new file mode 100644
index 00000000..58b65178
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_vendor/packaging/__pycache__/_tokenizer.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/packaging/__pycache__/markers.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_vendor/packaging/__pycache__/markers.cpython-312.pyc
new file mode 100644
index 00000000..29b173e2
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_vendor/packaging/__pycache__/markers.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/packaging/__pycache__/metadata.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_vendor/packaging/__pycache__/metadata.cpython-312.pyc
new file mode 100644
index 00000000..c337d93f
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_vendor/packaging/__pycache__/metadata.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/packaging/__pycache__/requirements.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_vendor/packaging/__pycache__/requirements.cpython-312.pyc
new file mode 100644
index 00000000..c0bb87f1
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_vendor/packaging/__pycache__/requirements.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/packaging/__pycache__/specifiers.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_vendor/packaging/__pycache__/specifiers.cpython-312.pyc
new file mode 100644
index 00000000..18d63b7e
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_vendor/packaging/__pycache__/specifiers.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/packaging/__pycache__/tags.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_vendor/packaging/__pycache__/tags.cpython-312.pyc
new file mode 100644
index 00000000..807e953b
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_vendor/packaging/__pycache__/tags.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/packaging/__pycache__/utils.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_vendor/packaging/__pycache__/utils.cpython-312.pyc
new file mode 100644
index 00000000..f3d27852
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_vendor/packaging/__pycache__/utils.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/packaging/__pycache__/version.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_vendor/packaging/__pycache__/version.cpython-312.pyc
new file mode 100644
index 00000000..ad67a251
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_vendor/packaging/__pycache__/version.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/packaging/_elffile.py b/venv/lib/python3.12/site-packages/pip/_vendor/packaging/_elffile.py
new file mode 100644
index 00000000..f7a02180
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_vendor/packaging/_elffile.py
@@ -0,0 +1,110 @@
+"""
+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:
+            raise ELFInvalid("unable to parse identification")
+        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:
+            raise ELFInvalid(
+                f"unrecognized capacity ({self.capacity}) or "
+                f"encoding ({self.encoding})"
+            )
+
+        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.12/site-packages/pip/_vendor/packaging/_manylinux.py b/venv/lib/python3.12/site-packages/pip/_vendor/packaging/_manylinux.py
new file mode 100644
index 00000000..08f651fb
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_vendor/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,"
+            f" got: {version_str}",
+            RuntimeWarning,
+        )
+        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.12/site-packages/pip/_vendor/packaging/_musllinux.py b/venv/lib/python3.12/site-packages/pip/_vendor/packaging/_musllinux.py
new file mode 100644
index 00000000..d2bf30b5
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_vendor/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.12/site-packages/pip/_vendor/packaging/_parser.py b/venv/lib/python3.12/site-packages/pip/_vendor/packaging/_parser.py
new file mode 100644
index 00000000..c1238c06
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_vendor/packaging/_parser.py
@@ -0,0 +1,354 @@
+"""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.12/site-packages/pip/_vendor/packaging/_structures.py b/venv/lib/python3.12/site-packages/pip/_vendor/packaging/_structures.py
new file mode 100644
index 00000000..90a6465f
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_vendor/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.12/site-packages/pip/_vendor/packaging/_tokenizer.py b/venv/lib/python3.12/site-packages/pip/_vendor/packaging/_tokenizer.py
new file mode 100644
index 00000000..89d04160
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_vendor/packaging/_tokenizer.py
@@ -0,0 +1,194 @@
+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)
+                |extra
+            )\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.12/site-packages/pip/_vendor/packaging/markers.py b/venv/lib/python3.12/site-packages/pip/_vendor/packaging/markers.py
new file mode 100644
index 00000000..7ac7bb69
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_vendor/packaging/markers.py
@@ -0,0 +1,325 @@
+# 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 Any, Callable, TypedDict, 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__ = [
+    "InvalidMarker",
+    "UndefinedComparison",
+    "UndefinedEnvironmentName",
+    "Marker",
+    "default_environment",
+]
+
+Operator = Callable[[str, str], bool]
+
+
+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) -> bool:
+    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(*values: str, key: str) -> tuple[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":
+        return tuple(canonicalize_name(v) for v in values)
+
+    # other environment markers don't have such standards
+    return values
+
+
+def _evaluate_markers(markers: MarkerList, environment: dict[str, 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]
+
+            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 = "{0.major}.{0.minor}.{0.micro}".format(info)
+    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) -> 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 environment is determined from the current Python process.
+        """
+        current_environment = cast("dict[str, str]", default_environment())
+        current_environment["extra"] = ""
+        # Work around platform.python_version() returning something that is not PEP 440
+        # compliant for non-tagged Python builds. We preserve default_environment()'s
+        # behavior of returning platform.python_version() verbatim, and leave it to the
+        # caller to provide a syntactically valid version if they want to override it.
+        if current_environment["python_full_version"].endswith("+"):
+            current_environment["python_full_version"] += "local"
+        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 current_environment["extra"] is None:
+                current_environment["extra"] = ""
+
+        return _evaluate_markers(self._markers, current_environment)
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/packaging/metadata.py b/venv/lib/python3.12/site-packages/pip/_vendor/packaging/metadata.py
new file mode 100644
index 00000000..eb8dc844
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_vendor/packaging/metadata.py
@@ -0,0 +1,804 @@
+from __future__ import annotations
+
+import email.feedparser
+import email.header
+import email.message
+import email.parser
+import email.policy
+import typing
+from typing import (
+    Any,
+    Callable,
+    Generic,
+    Literal,
+    TypedDict,
+    cast,
+)
+
+from . import requirements, specifiers, utils
+from . import version as version_module
+
+T = typing.TypeVar("T")
+
+
+try:
+    ExceptionGroup
+except NameError:  # 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})"
+
+else:  # pragma: no cover
+    ExceptionGroup = ExceptionGroup
+
+
+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.
+
+
+_STRING_FIELDS = {
+    "author",
+    "author_email",
+    "description",
+    "description_content_type",
+    "download_url",
+    "home_page",
+    "license",
+    "maintainer",
+    "maintainer_email",
+    "metadata_version",
+    "name",
+    "requires_python",
+    "summary",
+    "version",
+}
+
+_LIST_FIELDS = {
+    "classifiers",
+    "dynamic",
+    "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-separate keyboards 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: str = msg.get_payload()
+        return payload
+    # If our source is a bytes, then we're managing the encoding and we need
+    # to deal with it.
+    else:
+        bpayload: bytes = msg.get_payload(decode=True)
+        try:
+            return bpayload.decode("utf8", "strict")
+        except UnicodeDecodeError:
+            raise ValueError("payload in an invalid encoding")
+
+
+# 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",
+    "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))
+        )
+    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"]
+_MetadataVersion = Literal["1.0", "1.1", "1.2", "2.1", "2.2", "2.3"]
+
+_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
+            )
+        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
+            )
+
+    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"{value!r} is not allowed as a dynamic field"
+                )
+            elif dynamic_field not in _EMAIL_TO_RAW_MAPPING:
+                raise self._invalid_metadata(f"{value!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
+            )
+        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
+            )
+
+    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)
+        else:
+            return reqs
+
+
+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,
+                                "{field} introduced in metadata version "
+                                "{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: _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`"""
+    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.12/site-packages/pip/_vendor/packaging/py.typed b/venv/lib/python3.12/site-packages/pip/_vendor/packaging/py.typed
new file mode 100644
index 00000000..e69de29b
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/packaging/requirements.py b/venv/lib/python3.12/site-packages/pip/_vendor/packaging/requirements.py
new file mode 100644
index 00000000..4e068c95
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_vendor/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.12/site-packages/pip/_vendor/packaging/specifiers.py b/venv/lib/python3.12/site-packages/pip/_vendor/packaging/specifiers.py
new file mode 100644
index 00000000..f3ac480f
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_vendor/packaging/specifiers.py
@@ -0,0 +1,1009 @@
+# 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 pip._vendor.packaging.specifiers import Specifier, SpecifierSet, InvalidSpecifier
+    from pip._vendor.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}'")
+
+        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 = "", 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.
+        :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.
+        """
+
+        # Split on `,` to break each individual specifier into it's 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))
+
+        # 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.12/site-packages/pip/_vendor/packaging/tags.py b/venv/lib/python3.12/site-packages/pip/_vendor/packaging/tags.py
new file mode 100644
index 00000000..6667d299
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_vendor/packaging/tags.py
@@ -0,0 +1,568 @@
+# 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]
+MacVersion = 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__ = ["_interpreter", "_abi", "_platform", "_hash"]
+
+    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:
+                interpreter = "cp{version}".format(
+                    version=_version_nodot((python_version[0], minor_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: MacVersion, 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: MacVersion | 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("MacVersion", 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("MacVersion", 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.
+        for minor_version in range(version[1], -1, -1):
+            compat_version = 10, minor_version
+            binary_formats = _mac_binary_formats(compat_version, arch)
+            for binary_format in binary_formats:
+                yield "macosx_{major}_{minor}_{binary_format}".format(
+                    major=10, minor=minor_version, binary_format=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.
+        for major_version in range(version[0], 10, -1):
+            compat_version = major_version, 0
+            binary_formats = _mac_binary_formats(compat_version, arch)
+            for binary_format in binary_formats:
+                yield "macosx_{major}_{minor}_{binary_format}".format(
+                    major=major_version, minor=0, binary_format=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.
+        if arch == "x86_64":
+            for minor_version in range(16, 3, -1):
+                compat_version = 10, minor_version
+                binary_formats = _mac_binary_formats(compat_version, arch)
+                for binary_format in binary_formats:
+                    yield "macosx_{major}_{minor}_{binary_format}".format(
+                        major=compat_version[0],
+                        minor=compat_version[1],
+                        binary_format=binary_format,
+                    )
+        else:
+            for minor_version in range(16, 3, -1):
+                compat_version = 10, minor_version
+                binary_format = "universal2"
+                yield "macosx_{major}_{minor}_{binary_format}".format(
+                    major=compat_version[0],
+                    minor=compat_version[1],
+                    binary_format=binary_format,
+                )
+
+
+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() == "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.12/site-packages/pip/_vendor/packaging/utils.py b/venv/lib/python3.12/site-packages/pip/_vendor/packaging/utils.py
new file mode 100644
index 00000000..d33da5bb
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_vendor/packaging/utils.py
@@ -0,0 +1,174 @@
+# 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 re
+from typing import NewType, Tuple, Union, cast
+
+from .tags import Tag, parse_tag
+from .version import InvalidVersion, Version
+
+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
+
+
+def canonicalize_version(
+    version: Version | str, *, strip_trailing_zero: bool = True
+) -> str:
+    """
+    This is very similar to Version.__str__, but has one subtle difference
+    with the way it handles the release segment.
+    """
+    if isinstance(version, str):
+        try:
+            parsed = Version(version)
+        except InvalidVersion:
+            # Legacy versions cannot be normalized
+            return version
+    else:
+        parsed = version
+
+    parts = []
+
+    # Epoch
+    if parsed.epoch != 0:
+        parts.append(f"{parsed.epoch}!")
+
+    # Release segment
+    release_segment = ".".join(str(x) for x in parsed.release)
+    if strip_trailing_zero:
+        # NB: This strips trailing '.0's to normalize
+        release_segment = re.sub(r"(\.0)+$", "", release_segment)
+    parts.append(release_segment)
+
+    # Pre-release
+    if parsed.pre is not None:
+        parts.append("".join(str(x) for x in parsed.pre))
+
+    # Post-release
+    if parsed.post is not None:
+        parts.append(f".post{parsed.post}")
+
+    # Development release
+    if parsed.dev is not None:
+        parts.append(f".dev{parsed.dev}")
+
+    # Local version segment
+    if parsed.local is not None:
+        parts.append(f"+{parsed.local}")
+
+    return "".join(parts)
+
+
+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}"
+        )
+
+    filename = filename[:-4]
+    dashes = filename.count("-")
+    if dashes not in (4, 5):
+        raise InvalidWheelFilename(
+            f"Invalid wheel filename (wrong number of parts): {filename}"
+        )
+
+    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}")
+    name = canonicalize_name(name_part)
+
+    try:
+        version = Version(parts[1])
+    except InvalidVersion as e:
+        raise InvalidWheelFilename(
+            f"Invalid wheel filename (invalid version): {filename}"
+        ) 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}'"
+            )
+        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}"
+        )
+
+    # 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}")
+
+    name = canonicalize_name(name_part)
+
+    try:
+        version = Version(version_part)
+    except InvalidVersion as e:
+        raise InvalidSdistFilename(
+            f"Invalid sdist filename (invalid version): {filename}"
+        ) from e
+
+    return (name, version)
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/packaging/version.py b/venv/lib/python3.12/site-packages/pip/_vendor/packaging/version.py
new file mode 100644
index 00000000..8b0a0408
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_vendor/packaging/version.py
@@ -0,0 +1,563 @@
+# 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 pip._vendor.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", "parse", "Version", "InvalidVersion"]
+
+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}'")
+
+        # 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 rounded-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.2.3+abc.dev1").public
+        '1.2.3'
+        """
+        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.3+abc.dev1").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
+
+
+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)
+    if not letter and 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.12/site-packages/pip/_vendor/pkg_resources/__init__.py b/venv/lib/python3.12/site-packages/pip/_vendor/pkg_resources/__init__.py
new file mode 100644
index 00000000..57ce7f10
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_vendor/pkg_resources/__init__.py
@@ -0,0 +1,3676 @@
+# TODO: Add Generic type annotations to initialized collections.
+# For now we'd simply use implicit Any/Unknown which would add redundant annotations
+# mypy: disable-error-code="var-annotated"
+"""
+Package resource API
+--------------------
+
+A resource is a logical file contained within a package, or a logical
+subdirectory thereof.  The package resource API expects resource names
+to have their path parts separated with ``/``, *not* whatever the local
+path separator is.  Do not use os.path operations to manipulate resource
+names being passed into the API.
+
+The package resource API is designed to work with normal filesystem packages,
+.egg files, and unpacked .egg files.  It can also work in a limited way with
+.zip files and with custom PEP 302 loaders that support the ``get_data()``
+method.
+
+This module is deprecated. Users are directed to :mod:`importlib.resources`,
+:mod:`importlib.metadata` and :pypi:`packaging` instead.
+"""
+
+from __future__ import annotations
+
+import sys
+
+if sys.version_info < (3, 8):  # noqa: UP036 # Check for unsupported versions
+    raise RuntimeError("Python 3.8 or later is required")
+
+import os
+import io
+import time
+import re
+import types
+from typing import (
+    Any,
+    Literal,
+    Dict,
+    Iterator,
+    Mapping,
+    MutableSequence,
+    NamedTuple,
+    NoReturn,
+    Tuple,
+    Union,
+    TYPE_CHECKING,
+    Protocol,
+    Callable,
+    Iterable,
+    TypeVar,
+    overload,
+)
+import zipfile
+import zipimport
+import warnings
+import stat
+import functools
+import pkgutil
+import operator
+import platform
+import collections
+import plistlib
+import email.parser
+import errno
+import tempfile
+import textwrap
+import inspect
+import ntpath
+import posixpath
+import importlib
+import importlib.abc
+import importlib.machinery
+from pkgutil import get_importer
+
+import _imp
+
+# capture these to bypass sandboxing
+from os import utime
+from os import open as os_open
+from os.path import isdir, split
+
+try:
+    from os import mkdir, rename, unlink
+
+    WRITE_SUPPORT = True
+except ImportError:
+    # no write support, probably under GAE
+    WRITE_SUPPORT = False
+
+from pip._internal.utils._jaraco_text import (
+    yield_lines,
+    drop_comment,
+    join_continuation,
+)
+from pip._vendor.packaging import markers as _packaging_markers
+from pip._vendor.packaging import requirements as _packaging_requirements
+from pip._vendor.packaging import utils as _packaging_utils
+from pip._vendor.packaging import version as _packaging_version
+from pip._vendor.platformdirs import user_cache_dir as _user_cache_dir
+
+if TYPE_CHECKING:
+    from _typeshed import BytesPath, StrPath, StrOrBytesPath
+    from pip._vendor.typing_extensions import Self
+
+
+# Patch: Remove deprecation warning from vendored pkg_resources.
+# Setting PYTHONWARNINGS=error to verify builds produce no warnings
+# causes immediate exceptions.
+# See https://github.com/pypa/pip/issues/12243
+
+
+_T = TypeVar("_T")
+_DistributionT = TypeVar("_DistributionT", bound="Distribution")
+# Type aliases
+_NestedStr = Union[str, Iterable[Union[str, Iterable["_NestedStr"]]]]
+_InstallerTypeT = Callable[["Requirement"], "_DistributionT"]
+_InstallerType = Callable[["Requirement"], Union["Distribution", None]]
+_PkgReqType = Union[str, "Requirement"]
+_EPDistType = Union["Distribution", _PkgReqType]
+_MetadataType = Union["IResourceProvider", None]
+_ResolvedEntryPoint = Any  # Can be any attribute in the module
+_ResourceStream = Any  # TODO / Incomplete: A readable file-like object
+# Any object works, but let's indicate we expect something like a module (optionally has __loader__ or __file__)
+_ModuleLike = Union[object, types.ModuleType]
+# Any: Should be _ModuleLike but we end up with issues where _ModuleLike doesn't have _ZipLoaderModule's __loader__
+_ProviderFactoryType = Callable[[Any], "IResourceProvider"]
+_DistFinderType = Callable[[_T, str, bool], Iterable["Distribution"]]
+_NSHandlerType = Callable[[_T, str, str, types.ModuleType], Union[str, None]]
+_AdapterT = TypeVar(
+    "_AdapterT", _DistFinderType[Any], _ProviderFactoryType, _NSHandlerType[Any]
+)
+
+
+# Use _typeshed.importlib.LoaderProtocol once available https://github.com/python/typeshed/pull/11890
+class _LoaderProtocol(Protocol):
+    def load_module(self, fullname: str, /) -> types.ModuleType: ...
+
+
+class _ZipLoaderModule(Protocol):
+    __loader__: zipimport.zipimporter
+
+
+_PEP440_FALLBACK = re.compile(r"^v?(?P(?:[0-9]+!)?[0-9]+(?:\.[0-9]+)*)", re.I)
+
+
+class PEP440Warning(RuntimeWarning):
+    """
+    Used when there is an issue with a version or specifier not complying with
+    PEP 440.
+    """
+
+
+parse_version = _packaging_version.Version
+
+
+_state_vars: dict[str, str] = {}
+
+
+def _declare_state(vartype: str, varname: str, initial_value: _T) -> _T:
+    _state_vars[varname] = vartype
+    return initial_value
+
+
+def __getstate__() -> dict[str, Any]:
+    state = {}
+    g = globals()
+    for k, v in _state_vars.items():
+        state[k] = g['_sget_' + v](g[k])
+    return state
+
+
+def __setstate__(state: dict[str, Any]) -> dict[str, Any]:
+    g = globals()
+    for k, v in state.items():
+        g['_sset_' + _state_vars[k]](k, g[k], v)
+    return state
+
+
+def _sget_dict(val):
+    return val.copy()
+
+
+def _sset_dict(key, ob, state):
+    ob.clear()
+    ob.update(state)
+
+
+def _sget_object(val):
+    return val.__getstate__()
+
+
+def _sset_object(key, ob, state):
+    ob.__setstate__(state)
+
+
+_sget_none = _sset_none = lambda *args: None
+
+
+def get_supported_platform():
+    """Return this platform's maximum compatible version.
+
+    distutils.util.get_platform() normally reports the minimum version
+    of macOS that would be required to *use* extensions produced by
+    distutils.  But what we want when checking compatibility is to know the
+    version of macOS that we are *running*.  To allow usage of packages that
+    explicitly require a newer version of macOS, we must also know the
+    current version of the OS.
+
+    If this condition occurs for any other platform with a version in its
+    platform strings, this function should be extended accordingly.
+    """
+    plat = get_build_platform()
+    m = macosVersionString.match(plat)
+    if m is not None and sys.platform == "darwin":
+        try:
+            plat = 'macosx-%s-%s' % ('.'.join(_macos_vers()[:2]), m.group(3))
+        except ValueError:
+            # not macOS
+            pass
+    return plat
+
+
+__all__ = [
+    # Basic resource access and distribution/entry point discovery
+    'require',
+    'run_script',
+    'get_provider',
+    'get_distribution',
+    'load_entry_point',
+    'get_entry_map',
+    'get_entry_info',
+    'iter_entry_points',
+    'resource_string',
+    'resource_stream',
+    'resource_filename',
+    'resource_listdir',
+    'resource_exists',
+    'resource_isdir',
+    # Environmental control
+    'declare_namespace',
+    'working_set',
+    'add_activation_listener',
+    'find_distributions',
+    'set_extraction_path',
+    'cleanup_resources',
+    'get_default_cache',
+    # Primary implementation classes
+    'Environment',
+    'WorkingSet',
+    'ResourceManager',
+    'Distribution',
+    'Requirement',
+    'EntryPoint',
+    # Exceptions
+    'ResolutionError',
+    'VersionConflict',
+    'DistributionNotFound',
+    'UnknownExtra',
+    'ExtractionError',
+    # Warnings
+    'PEP440Warning',
+    # Parsing functions and string utilities
+    'parse_requirements',
+    'parse_version',
+    'safe_name',
+    'safe_version',
+    'get_platform',
+    'compatible_platforms',
+    'yield_lines',
+    'split_sections',
+    'safe_extra',
+    'to_filename',
+    'invalid_marker',
+    'evaluate_marker',
+    # filesystem utilities
+    'ensure_directory',
+    'normalize_path',
+    # Distribution "precedence" constants
+    'EGG_DIST',
+    'BINARY_DIST',
+    'SOURCE_DIST',
+    'CHECKOUT_DIST',
+    'DEVELOP_DIST',
+    # "Provider" interfaces, implementations, and registration/lookup APIs
+    'IMetadataProvider',
+    'IResourceProvider',
+    'FileMetadata',
+    'PathMetadata',
+    'EggMetadata',
+    'EmptyProvider',
+    'empty_provider',
+    'NullProvider',
+    'EggProvider',
+    'DefaultProvider',
+    'ZipProvider',
+    'register_finder',
+    'register_namespace_handler',
+    'register_loader_type',
+    'fixup_namespace_packages',
+    'get_importer',
+    # Warnings
+    'PkgResourcesDeprecationWarning',
+    # Deprecated/backward compatibility only
+    'run_main',
+    'AvailableDistributions',
+]
+
+
+class ResolutionError(Exception):
+    """Abstract base for dependency resolution errors"""
+
+    def __repr__(self):
+        return self.__class__.__name__ + repr(self.args)
+
+
+class VersionConflict(ResolutionError):
+    """
+    An already-installed version conflicts with the requested version.
+
+    Should be initialized with the installed Distribution and the requested
+    Requirement.
+    """
+
+    _template = "{self.dist} is installed but {self.req} is required"
+
+    @property
+    def dist(self) -> Distribution:
+        return self.args[0]
+
+    @property
+    def req(self) -> Requirement:
+        return self.args[1]
+
+    def report(self):
+        return self._template.format(**locals())
+
+    def with_context(self, required_by: set[Distribution | str]):
+        """
+        If required_by is non-empty, return a version of self that is a
+        ContextualVersionConflict.
+        """
+        if not required_by:
+            return self
+        args = self.args + (required_by,)
+        return ContextualVersionConflict(*args)
+
+
+class ContextualVersionConflict(VersionConflict):
+    """
+    A VersionConflict that accepts a third parameter, the set of the
+    requirements that required the installed Distribution.
+    """
+
+    _template = VersionConflict._template + ' by {self.required_by}'
+
+    @property
+    def required_by(self) -> set[str]:
+        return self.args[2]
+
+
+class DistributionNotFound(ResolutionError):
+    """A requested distribution was not found"""
+
+    _template = (
+        "The '{self.req}' distribution was not found "
+        "and is required by {self.requirers_str}"
+    )
+
+    @property
+    def req(self) -> Requirement:
+        return self.args[0]
+
+    @property
+    def requirers(self) -> set[str] | None:
+        return self.args[1]
+
+    @property
+    def requirers_str(self):
+        if not self.requirers:
+            return 'the application'
+        return ', '.join(self.requirers)
+
+    def report(self):
+        return self._template.format(**locals())
+
+    def __str__(self):
+        return self.report()
+
+
+class UnknownExtra(ResolutionError):
+    """Distribution doesn't have an "extra feature" of the given name"""
+
+
+_provider_factories: dict[type[_ModuleLike], _ProviderFactoryType] = {}
+
+PY_MAJOR = '{}.{}'.format(*sys.version_info)
+EGG_DIST = 3
+BINARY_DIST = 2
+SOURCE_DIST = 1
+CHECKOUT_DIST = 0
+DEVELOP_DIST = -1
+
+
+def register_loader_type(
+    loader_type: type[_ModuleLike], provider_factory: _ProviderFactoryType
+):
+    """Register `provider_factory` to make providers for `loader_type`
+
+    `loader_type` is the type or class of a PEP 302 ``module.__loader__``,
+    and `provider_factory` is a function that, passed a *module* object,
+    returns an ``IResourceProvider`` for that module.
+    """
+    _provider_factories[loader_type] = provider_factory
+
+
+@overload
+def get_provider(moduleOrReq: str) -> IResourceProvider: ...
+@overload
+def get_provider(moduleOrReq: Requirement) -> Distribution: ...
+def get_provider(moduleOrReq: str | Requirement) -> IResourceProvider | Distribution:
+    """Return an IResourceProvider for the named module or requirement"""
+    if isinstance(moduleOrReq, Requirement):
+        return working_set.find(moduleOrReq) or require(str(moduleOrReq))[0]
+    try:
+        module = sys.modules[moduleOrReq]
+    except KeyError:
+        __import__(moduleOrReq)
+        module = sys.modules[moduleOrReq]
+    loader = getattr(module, '__loader__', None)
+    return _find_adapter(_provider_factories, loader)(module)
+
+
+@functools.lru_cache(maxsize=None)
+def _macos_vers():
+    version = platform.mac_ver()[0]
+    # fallback for MacPorts
+    if version == '':
+        plist = '/System/Library/CoreServices/SystemVersion.plist'
+        if os.path.exists(plist):
+            with open(plist, 'rb') as fh:
+                plist_content = plistlib.load(fh)
+            if 'ProductVersion' in plist_content:
+                version = plist_content['ProductVersion']
+    return version.split('.')
+
+
+def _macos_arch(machine):
+    return {'PowerPC': 'ppc', 'Power_Macintosh': 'ppc'}.get(machine, machine)
+
+
+def get_build_platform():
+    """Return this platform's string for platform-specific distributions
+
+    XXX Currently this is the same as ``distutils.util.get_platform()``, but it
+    needs some hacks for Linux and macOS.
+    """
+    from sysconfig import get_platform
+
+    plat = get_platform()
+    if sys.platform == "darwin" and not plat.startswith('macosx-'):
+        try:
+            version = _macos_vers()
+            machine = os.uname()[4].replace(" ", "_")
+            return "macosx-%d.%d-%s" % (
+                int(version[0]),
+                int(version[1]),
+                _macos_arch(machine),
+            )
+        except ValueError:
+            # if someone is running a non-Mac darwin system, this will fall
+            # through to the default implementation
+            pass
+    return plat
+
+
+macosVersionString = re.compile(r"macosx-(\d+)\.(\d+)-(.*)")
+darwinVersionString = re.compile(r"darwin-(\d+)\.(\d+)\.(\d+)-(.*)")
+# XXX backward compat
+get_platform = get_build_platform
+
+
+def compatible_platforms(provided: str | None, required: str | None):
+    """Can code for the `provided` platform run on the `required` platform?
+
+    Returns true if either platform is ``None``, or the platforms are equal.
+
+    XXX Needs compatibility checks for Linux and other unixy OSes.
+    """
+    if provided is None or required is None or provided == required:
+        # easy case
+        return True
+
+    # macOS special cases
+    reqMac = macosVersionString.match(required)
+    if reqMac:
+        provMac = macosVersionString.match(provided)
+
+        # is this a Mac package?
+        if not provMac:
+            # this is backwards compatibility for packages built before
+            # setuptools 0.6. All packages built after this point will
+            # use the new macOS designation.
+            provDarwin = darwinVersionString.match(provided)
+            if provDarwin:
+                dversion = int(provDarwin.group(1))
+                macosversion = "%s.%s" % (reqMac.group(1), reqMac.group(2))
+                if (
+                    dversion == 7
+                    and macosversion >= "10.3"
+                    or dversion == 8
+                    and macosversion >= "10.4"
+                ):
+                    return True
+            # egg isn't macOS or legacy darwin
+            return False
+
+        # are they the same major version and machine type?
+        if provMac.group(1) != reqMac.group(1) or provMac.group(3) != reqMac.group(3):
+            return False
+
+        # is the required OS major update >= the provided one?
+        if int(provMac.group(2)) > int(reqMac.group(2)):
+            return False
+
+        return True
+
+    # XXX Linux and other platforms' special cases should go here
+    return False
+
+
+@overload
+def get_distribution(dist: _DistributionT) -> _DistributionT: ...
+@overload
+def get_distribution(dist: _PkgReqType) -> Distribution: ...
+def get_distribution(dist: Distribution | _PkgReqType) -> Distribution:
+    """Return a current distribution object for a Requirement or string"""
+    if isinstance(dist, str):
+        dist = Requirement.parse(dist)
+    if isinstance(dist, Requirement):
+        # Bad type narrowing, dist has to be a Requirement here, so get_provider has to return Distribution
+        dist = get_provider(dist)  # type: ignore[assignment]
+    if not isinstance(dist, Distribution):
+        raise TypeError("Expected str, Requirement, or Distribution", dist)
+    return dist
+
+
+def load_entry_point(dist: _EPDistType, group: str, name: str) -> _ResolvedEntryPoint:
+    """Return `name` entry point of `group` for `dist` or raise ImportError"""
+    return get_distribution(dist).load_entry_point(group, name)
+
+
+@overload
+def get_entry_map(
+    dist: _EPDistType, group: None = None
+) -> dict[str, dict[str, EntryPoint]]: ...
+@overload
+def get_entry_map(dist: _EPDistType, group: str) -> dict[str, EntryPoint]: ...
+def get_entry_map(dist: _EPDistType, group: str | None = None):
+    """Return the entry point map for `group`, or the full entry map"""
+    return get_distribution(dist).get_entry_map(group)
+
+
+def get_entry_info(dist: _EPDistType, group: str, name: str):
+    """Return the EntryPoint object for `group`+`name`, or ``None``"""
+    return get_distribution(dist).get_entry_info(group, name)
+
+
+class IMetadataProvider(Protocol):
+    def has_metadata(self, name: str) -> bool:
+        """Does the package's distribution contain the named metadata?"""
+
+    def get_metadata(self, name: str) -> str:
+        """The named metadata resource as a string"""
+
+    def get_metadata_lines(self, name: str) -> Iterator[str]:
+        """Yield named metadata resource as list of non-blank non-comment lines
+
+        Leading and trailing whitespace is stripped from each line, and lines
+        with ``#`` as the first non-blank character are omitted."""
+
+    def metadata_isdir(self, name: str) -> bool:
+        """Is the named metadata a directory?  (like ``os.path.isdir()``)"""
+
+    def metadata_listdir(self, name: str) -> list[str]:
+        """List of metadata names in the directory (like ``os.listdir()``)"""
+
+    def run_script(self, script_name: str, namespace: dict[str, Any]) -> None:
+        """Execute the named script in the supplied namespace dictionary"""
+
+
+class IResourceProvider(IMetadataProvider, Protocol):
+    """An object that provides access to package resources"""
+
+    def get_resource_filename(
+        self, manager: ResourceManager, resource_name: str
+    ) -> str:
+        """Return a true filesystem path for `resource_name`
+
+        `manager` must be a ``ResourceManager``"""
+
+    def get_resource_stream(
+        self, manager: ResourceManager, resource_name: str
+    ) -> _ResourceStream:
+        """Return a readable file-like object for `resource_name`
+
+        `manager` must be a ``ResourceManager``"""
+
+    def get_resource_string(
+        self, manager: ResourceManager, resource_name: str
+    ) -> bytes:
+        """Return the contents of `resource_name` as :obj:`bytes`
+
+        `manager` must be a ``ResourceManager``"""
+
+    def has_resource(self, resource_name: str) -> bool:
+        """Does the package contain the named resource?"""
+
+    def resource_isdir(self, resource_name: str) -> bool:
+        """Is the named resource a directory?  (like ``os.path.isdir()``)"""
+
+    def resource_listdir(self, resource_name: str) -> list[str]:
+        """List of resource names in the directory (like ``os.listdir()``)"""
+
+
+class WorkingSet:
+    """A collection of active distributions on sys.path (or a similar list)"""
+
+    def __init__(self, entries: Iterable[str] | None = None):
+        """Create working set from list of path entries (default=sys.path)"""
+        self.entries: list[str] = []
+        self.entry_keys = {}
+        self.by_key = {}
+        self.normalized_to_canonical_keys = {}
+        self.callbacks = []
+
+        if entries is None:
+            entries = sys.path
+
+        for entry in entries:
+            self.add_entry(entry)
+
+    @classmethod
+    def _build_master(cls):
+        """
+        Prepare the master working set.
+        """
+        ws = cls()
+        try:
+            from __main__ import __requires__
+        except ImportError:
+            # The main program does not list any requirements
+            return ws
+
+        # ensure the requirements are met
+        try:
+            ws.require(__requires__)
+        except VersionConflict:
+            return cls._build_from_requirements(__requires__)
+
+        return ws
+
+    @classmethod
+    def _build_from_requirements(cls, req_spec):
+        """
+        Build a working set from a requirement spec. Rewrites sys.path.
+        """
+        # try it without defaults already on sys.path
+        # by starting with an empty path
+        ws = cls([])
+        reqs = parse_requirements(req_spec)
+        dists = ws.resolve(reqs, Environment())
+        for dist in dists:
+            ws.add(dist)
+
+        # add any missing entries from sys.path
+        for entry in sys.path:
+            if entry not in ws.entries:
+                ws.add_entry(entry)
+
+        # then copy back to sys.path
+        sys.path[:] = ws.entries
+        return ws
+
+    def add_entry(self, entry: str):
+        """Add a path item to ``.entries``, finding any distributions on it
+
+        ``find_distributions(entry, True)`` is used to find distributions
+        corresponding to the path entry, and they are added.  `entry` is
+        always appended to ``.entries``, even if it is already present.
+        (This is because ``sys.path`` can contain the same value more than
+        once, and the ``.entries`` of the ``sys.path`` WorkingSet should always
+        equal ``sys.path``.)
+        """
+        self.entry_keys.setdefault(entry, [])
+        self.entries.append(entry)
+        for dist in find_distributions(entry, True):
+            self.add(dist, entry, False)
+
+    def __contains__(self, dist: Distribution) -> bool:
+        """True if `dist` is the active distribution for its project"""
+        return self.by_key.get(dist.key) == dist
+
+    def find(self, req: Requirement) -> Distribution | None:
+        """Find a distribution matching requirement `req`
+
+        If there is an active distribution for the requested project, this
+        returns it as long as it meets the version requirement specified by
+        `req`.  But, if there is an active distribution for the project and it
+        does *not* meet the `req` requirement, ``VersionConflict`` is raised.
+        If there is no active distribution for the requested project, ``None``
+        is returned.
+        """
+        dist = self.by_key.get(req.key)
+
+        if dist is None:
+            canonical_key = self.normalized_to_canonical_keys.get(req.key)
+
+            if canonical_key is not None:
+                req.key = canonical_key
+                dist = self.by_key.get(canonical_key)
+
+        if dist is not None and dist not in req:
+            # XXX add more info
+            raise VersionConflict(dist, req)
+        return dist
+
+    def iter_entry_points(self, group: str, name: str | None = None):
+        """Yield entry point objects from `group` matching `name`
+
+        If `name` is None, yields all entry points in `group` from all
+        distributions in the working set, otherwise only ones matching
+        both `group` and `name` are yielded (in distribution order).
+        """
+        return (
+            entry
+            for dist in self
+            for entry in dist.get_entry_map(group).values()
+            if name is None or name == entry.name
+        )
+
+    def run_script(self, requires: str, script_name: str):
+        """Locate distribution for `requires` and run `script_name` script"""
+        ns = sys._getframe(1).f_globals
+        name = ns['__name__']
+        ns.clear()
+        ns['__name__'] = name
+        self.require(requires)[0].run_script(script_name, ns)
+
+    def __iter__(self) -> Iterator[Distribution]:
+        """Yield distributions for non-duplicate projects in the working set
+
+        The yield order is the order in which the items' path entries were
+        added to the working set.
+        """
+        seen = set()
+        for item in self.entries:
+            if item not in self.entry_keys:
+                # workaround a cache issue
+                continue
+
+            for key in self.entry_keys[item]:
+                if key not in seen:
+                    seen.add(key)
+                    yield self.by_key[key]
+
+    def add(
+        self,
+        dist: Distribution,
+        entry: str | None = None,
+        insert: bool = True,
+        replace: bool = False,
+    ):
+        """Add `dist` to working set, associated with `entry`
+
+        If `entry` is unspecified, it defaults to the ``.location`` of `dist`.
+        On exit from this routine, `entry` is added to the end of the working
+        set's ``.entries`` (if it wasn't already present).
+
+        `dist` is only added to the working set if it's for a project that
+        doesn't already have a distribution in the set, unless `replace=True`.
+        If it's added, any callbacks registered with the ``subscribe()`` method
+        will be called.
+        """
+        if insert:
+            dist.insert_on(self.entries, entry, replace=replace)
+
+        if entry is None:
+            entry = dist.location
+        keys = self.entry_keys.setdefault(entry, [])
+        keys2 = self.entry_keys.setdefault(dist.location, [])
+        if not replace and dist.key in self.by_key:
+            # ignore hidden distros
+            return
+
+        self.by_key[dist.key] = dist
+        normalized_name = _packaging_utils.canonicalize_name(dist.key)
+        self.normalized_to_canonical_keys[normalized_name] = dist.key
+        if dist.key not in keys:
+            keys.append(dist.key)
+        if dist.key not in keys2:
+            keys2.append(dist.key)
+        self._added_new(dist)
+
+    @overload
+    def resolve(
+        self,
+        requirements: Iterable[Requirement],
+        env: Environment | None,
+        installer: _InstallerTypeT[_DistributionT],
+        replace_conflicting: bool = False,
+        extras: tuple[str, ...] | None = None,
+    ) -> list[_DistributionT]: ...
+    @overload
+    def resolve(
+        self,
+        requirements: Iterable[Requirement],
+        env: Environment | None = None,
+        *,
+        installer: _InstallerTypeT[_DistributionT],
+        replace_conflicting: bool = False,
+        extras: tuple[str, ...] | None = None,
+    ) -> list[_DistributionT]: ...
+    @overload
+    def resolve(
+        self,
+        requirements: Iterable[Requirement],
+        env: Environment | None = None,
+        installer: _InstallerType | None = None,
+        replace_conflicting: bool = False,
+        extras: tuple[str, ...] | None = None,
+    ) -> list[Distribution]: ...
+    def resolve(
+        self,
+        requirements: Iterable[Requirement],
+        env: Environment | None = None,
+        installer: _InstallerType | None | _InstallerTypeT[_DistributionT] = None,
+        replace_conflicting: bool = False,
+        extras: tuple[str, ...] | None = None,
+    ) -> list[Distribution] | list[_DistributionT]:
+        """List all distributions needed to (recursively) meet `requirements`
+
+        `requirements` must be a sequence of ``Requirement`` objects.  `env`,
+        if supplied, should be an ``Environment`` instance.  If
+        not supplied, it defaults to all distributions available within any
+        entry or distribution in the working set.  `installer`, if supplied,
+        will be invoked with each requirement that cannot be met by an
+        already-installed distribution; it should return a ``Distribution`` or
+        ``None``.
+
+        Unless `replace_conflicting=True`, raises a VersionConflict exception
+        if
+        any requirements are found on the path that have the correct name but
+        the wrong version.  Otherwise, if an `installer` is supplied it will be
+        invoked to obtain the correct version of the requirement and activate
+        it.
+
+        `extras` is a list of the extras to be used with these requirements.
+        This is important because extra requirements may look like `my_req;
+        extra = "my_extra"`, which would otherwise be interpreted as a purely
+        optional requirement.  Instead, we want to be able to assert that these
+        requirements are truly required.
+        """
+
+        # set up the stack
+        requirements = list(requirements)[::-1]
+        # set of processed requirements
+        processed = set()
+        # key -> dist
+        best = {}
+        to_activate = []
+
+        req_extras = _ReqExtras()
+
+        # Mapping of requirement to set of distributions that required it;
+        # useful for reporting info about conflicts.
+        required_by = collections.defaultdict(set)
+
+        while requirements:
+            # process dependencies breadth-first
+            req = requirements.pop(0)
+            if req in processed:
+                # Ignore cyclic or redundant dependencies
+                continue
+
+            if not req_extras.markers_pass(req, extras):
+                continue
+
+            dist = self._resolve_dist(
+                req, best, replace_conflicting, env, installer, required_by, to_activate
+            )
+
+            # push the new requirements onto the stack
+            new_requirements = dist.requires(req.extras)[::-1]
+            requirements.extend(new_requirements)
+
+            # Register the new requirements needed by req
+            for new_requirement in new_requirements:
+                required_by[new_requirement].add(req.project_name)
+                req_extras[new_requirement] = req.extras
+
+            processed.add(req)
+
+        # return list of distros to activate
+        return to_activate
+
+    def _resolve_dist(
+        self, req, best, replace_conflicting, env, installer, required_by, to_activate
+    ) -> Distribution:
+        dist = best.get(req.key)
+        if dist is None:
+            # Find the best distribution and add it to the map
+            dist = self.by_key.get(req.key)
+            if dist is None or (dist not in req and replace_conflicting):
+                ws = self
+                if env is None:
+                    if dist is None:
+                        env = Environment(self.entries)
+                    else:
+                        # Use an empty environment and workingset to avoid
+                        # any further conflicts with the conflicting
+                        # distribution
+                        env = Environment([])
+                        ws = WorkingSet([])
+                dist = best[req.key] = env.best_match(
+                    req, ws, installer, replace_conflicting=replace_conflicting
+                )
+                if dist is None:
+                    requirers = required_by.get(req, None)
+                    raise DistributionNotFound(req, requirers)
+            to_activate.append(dist)
+        if dist not in req:
+            # Oops, the "best" so far conflicts with a dependency
+            dependent_req = required_by[req]
+            raise VersionConflict(dist, req).with_context(dependent_req)
+        return dist
+
+    @overload
+    def find_plugins(
+        self,
+        plugin_env: Environment,
+        full_env: Environment | None,
+        installer: _InstallerTypeT[_DistributionT],
+        fallback: bool = True,
+    ) -> tuple[list[_DistributionT], dict[Distribution, Exception]]: ...
+    @overload
+    def find_plugins(
+        self,
+        plugin_env: Environment,
+        full_env: Environment | None = None,
+        *,
+        installer: _InstallerTypeT[_DistributionT],
+        fallback: bool = True,
+    ) -> tuple[list[_DistributionT], dict[Distribution, Exception]]: ...
+    @overload
+    def find_plugins(
+        self,
+        plugin_env: Environment,
+        full_env: Environment | None = None,
+        installer: _InstallerType | None = None,
+        fallback: bool = True,
+    ) -> tuple[list[Distribution], dict[Distribution, Exception]]: ...
+    def find_plugins(
+        self,
+        plugin_env: Environment,
+        full_env: Environment | None = None,
+        installer: _InstallerType | None | _InstallerTypeT[_DistributionT] = None,
+        fallback: bool = True,
+    ) -> tuple[
+        list[Distribution] | list[_DistributionT],
+        dict[Distribution, Exception],
+    ]:
+        """Find all activatable distributions in `plugin_env`
+
+        Example usage::
+
+            distributions, errors = working_set.find_plugins(
+                Environment(plugin_dirlist)
+            )
+            # add plugins+libs to sys.path
+            map(working_set.add, distributions)
+            # display errors
+            print('Could not load', errors)
+
+        The `plugin_env` should be an ``Environment`` instance that contains
+        only distributions that are in the project's "plugin directory" or
+        directories. The `full_env`, if supplied, should be an ``Environment``
+        contains all currently-available distributions.  If `full_env` is not
+        supplied, one is created automatically from the ``WorkingSet`` this
+        method is called on, which will typically mean that every directory on
+        ``sys.path`` will be scanned for distributions.
+
+        `installer` is a standard installer callback as used by the
+        ``resolve()`` method. The `fallback` flag indicates whether we should
+        attempt to resolve older versions of a plugin if the newest version
+        cannot be resolved.
+
+        This method returns a 2-tuple: (`distributions`, `error_info`), where
+        `distributions` is a list of the distributions found in `plugin_env`
+        that were loadable, along with any other distributions that are needed
+        to resolve their dependencies.  `error_info` is a dictionary mapping
+        unloadable plugin distributions to an exception instance describing the
+        error that occurred. Usually this will be a ``DistributionNotFound`` or
+        ``VersionConflict`` instance.
+        """
+
+        plugin_projects = list(plugin_env)
+        # scan project names in alphabetic order
+        plugin_projects.sort()
+
+        error_info: dict[Distribution, Exception] = {}
+        distributions: dict[Distribution, Exception | None] = {}
+
+        if full_env is None:
+            env = Environment(self.entries)
+            env += plugin_env
+        else:
+            env = full_env + plugin_env
+
+        shadow_set = self.__class__([])
+        # put all our entries in shadow_set
+        list(map(shadow_set.add, self))
+
+        for project_name in plugin_projects:
+            for dist in plugin_env[project_name]:
+                req = [dist.as_requirement()]
+
+                try:
+                    resolvees = shadow_set.resolve(req, env, installer)
+
+                except ResolutionError as v:
+                    # save error info
+                    error_info[dist] = v
+                    if fallback:
+                        # try the next older version of project
+                        continue
+                    else:
+                        # give up on this project, keep going
+                        break
+
+                else:
+                    list(map(shadow_set.add, resolvees))
+                    distributions.update(dict.fromkeys(resolvees))
+
+                    # success, no need to try any more versions of this project
+                    break
+
+        sorted_distributions = list(distributions)
+        sorted_distributions.sort()
+
+        return sorted_distributions, error_info
+
+    def require(self, *requirements: _NestedStr):
+        """Ensure that distributions matching `requirements` are activated
+
+        `requirements` must be a string or a (possibly-nested) sequence
+        thereof, specifying the distributions and versions required.  The
+        return value is a sequence of the distributions that needed to be
+        activated to fulfill the requirements; all relevant distributions are
+        included, even if they were already activated in this working set.
+        """
+        needed = self.resolve(parse_requirements(requirements))
+
+        for dist in needed:
+            self.add(dist)
+
+        return needed
+
+    def subscribe(
+        self, callback: Callable[[Distribution], object], existing: bool = True
+    ):
+        """Invoke `callback` for all distributions
+
+        If `existing=True` (default),
+        call on all existing ones, as well.
+        """
+        if callback in self.callbacks:
+            return
+        self.callbacks.append(callback)
+        if not existing:
+            return
+        for dist in self:
+            callback(dist)
+
+    def _added_new(self, dist):
+        for callback in self.callbacks:
+            callback(dist)
+
+    def __getstate__(self):
+        return (
+            self.entries[:],
+            self.entry_keys.copy(),
+            self.by_key.copy(),
+            self.normalized_to_canonical_keys.copy(),
+            self.callbacks[:],
+        )
+
+    def __setstate__(self, e_k_b_n_c):
+        entries, keys, by_key, normalized_to_canonical_keys, callbacks = e_k_b_n_c
+        self.entries = entries[:]
+        self.entry_keys = keys.copy()
+        self.by_key = by_key.copy()
+        self.normalized_to_canonical_keys = normalized_to_canonical_keys.copy()
+        self.callbacks = callbacks[:]
+
+
+class _ReqExtras(Dict["Requirement", Tuple[str, ...]]):
+    """
+    Map each requirement to the extras that demanded it.
+    """
+
+    def markers_pass(self, req: Requirement, extras: tuple[str, ...] | None = None):
+        """
+        Evaluate markers for req against each extra that
+        demanded it.
+
+        Return False if the req has a marker and fails
+        evaluation. Otherwise, return True.
+        """
+        extra_evals = (
+            req.marker.evaluate({'extra': extra})
+            for extra in self.get(req, ()) + (extras or (None,))
+        )
+        return not req.marker or any(extra_evals)
+
+
+class Environment:
+    """Searchable snapshot of distributions on a search path"""
+
+    def __init__(
+        self,
+        search_path: Iterable[str] | None = None,
+        platform: str | None = get_supported_platform(),
+        python: str | None = PY_MAJOR,
+    ):
+        """Snapshot distributions available on a search path
+
+        Any distributions found on `search_path` are added to the environment.
+        `search_path` should be a sequence of ``sys.path`` items.  If not
+        supplied, ``sys.path`` is used.
+
+        `platform` is an optional string specifying the name of the platform
+        that platform-specific distributions must be compatible with.  If
+        unspecified, it defaults to the current platform.  `python` is an
+        optional string naming the desired version of Python (e.g. ``'3.6'``);
+        it defaults to the current version.
+
+        You may explicitly set `platform` (and/or `python`) to ``None`` if you
+        wish to map *all* distributions, not just those compatible with the
+        running platform or Python version.
+        """
+        self._distmap = {}
+        self.platform = platform
+        self.python = python
+        self.scan(search_path)
+
+    def can_add(self, dist: Distribution):
+        """Is distribution `dist` acceptable for this environment?
+
+        The distribution must match the platform and python version
+        requirements specified when this environment was created, or False
+        is returned.
+        """
+        py_compat = (
+            self.python is None
+            or dist.py_version is None
+            or dist.py_version == self.python
+        )
+        return py_compat and compatible_platforms(dist.platform, self.platform)
+
+    def remove(self, dist: Distribution):
+        """Remove `dist` from the environment"""
+        self._distmap[dist.key].remove(dist)
+
+    def scan(self, search_path: Iterable[str] | None = None):
+        """Scan `search_path` for distributions usable in this environment
+
+        Any distributions found are added to the environment.
+        `search_path` should be a sequence of ``sys.path`` items.  If not
+        supplied, ``sys.path`` is used.  Only distributions conforming to
+        the platform/python version defined at initialization are added.
+        """
+        if search_path is None:
+            search_path = sys.path
+
+        for item in search_path:
+            for dist in find_distributions(item):
+                self.add(dist)
+
+    def __getitem__(self, project_name: str) -> list[Distribution]:
+        """Return a newest-to-oldest list of distributions for `project_name`
+
+        Uses case-insensitive `project_name` comparison, assuming all the
+        project's distributions use their project's name converted to all
+        lowercase as their key.
+
+        """
+        distribution_key = project_name.lower()
+        return self._distmap.get(distribution_key, [])
+
+    def add(self, dist: Distribution):
+        """Add `dist` if we ``can_add()`` it and it has not already been added"""
+        if self.can_add(dist) and dist.has_version():
+            dists = self._distmap.setdefault(dist.key, [])
+            if dist not in dists:
+                dists.append(dist)
+                dists.sort(key=operator.attrgetter('hashcmp'), reverse=True)
+
+    @overload
+    def best_match(
+        self,
+        req: Requirement,
+        working_set: WorkingSet,
+        installer: _InstallerTypeT[_DistributionT],
+        replace_conflicting: bool = False,
+    ) -> _DistributionT: ...
+    @overload
+    def best_match(
+        self,
+        req: Requirement,
+        working_set: WorkingSet,
+        installer: _InstallerType | None = None,
+        replace_conflicting: bool = False,
+    ) -> Distribution | None: ...
+    def best_match(
+        self,
+        req: Requirement,
+        working_set: WorkingSet,
+        installer: _InstallerType | None | _InstallerTypeT[_DistributionT] = None,
+        replace_conflicting: bool = False,
+    ) -> Distribution | None:
+        """Find distribution best matching `req` and usable on `working_set`
+
+        This calls the ``find(req)`` method of the `working_set` to see if a
+        suitable distribution is already active.  (This may raise
+        ``VersionConflict`` if an unsuitable version of the project is already
+        active in the specified `working_set`.)  If a suitable distribution
+        isn't active, this method returns the newest distribution in the
+        environment that meets the ``Requirement`` in `req`.  If no suitable
+        distribution is found, and `installer` is supplied, then the result of
+        calling the environment's ``obtain(req, installer)`` method will be
+        returned.
+        """
+        try:
+            dist = working_set.find(req)
+        except VersionConflict:
+            if not replace_conflicting:
+                raise
+            dist = None
+        if dist is not None:
+            return dist
+        for dist in self[req.key]:
+            if dist in req:
+                return dist
+        # try to download/install
+        return self.obtain(req, installer)
+
+    @overload
+    def obtain(
+        self,
+        requirement: Requirement,
+        installer: _InstallerTypeT[_DistributionT],
+    ) -> _DistributionT: ...
+    @overload
+    def obtain(
+        self,
+        requirement: Requirement,
+        installer: Callable[[Requirement], None] | None = None,
+    ) -> None: ...
+    @overload
+    def obtain(
+        self,
+        requirement: Requirement,
+        installer: _InstallerType | None = None,
+    ) -> Distribution | None: ...
+    def obtain(
+        self,
+        requirement: Requirement,
+        installer: Callable[[Requirement], None]
+        | _InstallerType
+        | None
+        | _InstallerTypeT[_DistributionT] = None,
+    ) -> Distribution | None:
+        """Obtain a distribution matching `requirement` (e.g. via download)
+
+        Obtain a distro that matches requirement (e.g. via download).  In the
+        base ``Environment`` class, this routine just returns
+        ``installer(requirement)``, unless `installer` is None, in which case
+        None is returned instead.  This method is a hook that allows subclasses
+        to attempt other ways of obtaining a distribution before falling back
+        to the `installer` argument."""
+        return installer(requirement) if installer else None
+
+    def __iter__(self) -> Iterator[str]:
+        """Yield the unique project names of the available distributions"""
+        for key in self._distmap.keys():
+            if self[key]:
+                yield key
+
+    def __iadd__(self, other: Distribution | Environment):
+        """In-place addition of a distribution or environment"""
+        if isinstance(other, Distribution):
+            self.add(other)
+        elif isinstance(other, Environment):
+            for project in other:
+                for dist in other[project]:
+                    self.add(dist)
+        else:
+            raise TypeError("Can't add %r to environment" % (other,))
+        return self
+
+    def __add__(self, other: Distribution | Environment):
+        """Add an environment or distribution to an environment"""
+        new = self.__class__([], platform=None, python=None)
+        for env in self, other:
+            new += env
+        return new
+
+
+# XXX backward compatibility
+AvailableDistributions = Environment
+
+
+class ExtractionError(RuntimeError):
+    """An error occurred extracting a resource
+
+    The following attributes are available from instances of this exception:
+
+    manager
+        The resource manager that raised this exception
+
+    cache_path
+        The base directory for resource extraction
+
+    original_error
+        The exception instance that caused extraction to fail
+    """
+
+    manager: ResourceManager
+    cache_path: str
+    original_error: BaseException | None
+
+
+class ResourceManager:
+    """Manage resource extraction and packages"""
+
+    extraction_path: str | None = None
+
+    def __init__(self):
+        self.cached_files = {}
+
+    def resource_exists(self, package_or_requirement: _PkgReqType, resource_name: str):
+        """Does the named resource exist?"""
+        return get_provider(package_or_requirement).has_resource(resource_name)
+
+    def resource_isdir(self, package_or_requirement: _PkgReqType, resource_name: str):
+        """Is the named resource an existing directory?"""
+        return get_provider(package_or_requirement).resource_isdir(resource_name)
+
+    def resource_filename(
+        self, package_or_requirement: _PkgReqType, resource_name: str
+    ):
+        """Return a true filesystem path for specified resource"""
+        return get_provider(package_or_requirement).get_resource_filename(
+            self, resource_name
+        )
+
+    def resource_stream(self, package_or_requirement: _PkgReqType, resource_name: str):
+        """Return a readable file-like object for specified resource"""
+        return get_provider(package_or_requirement).get_resource_stream(
+            self, resource_name
+        )
+
+    def resource_string(
+        self, package_or_requirement: _PkgReqType, resource_name: str
+    ) -> bytes:
+        """Return specified resource as :obj:`bytes`"""
+        return get_provider(package_or_requirement).get_resource_string(
+            self, resource_name
+        )
+
+    def resource_listdir(self, package_or_requirement: _PkgReqType, resource_name: str):
+        """List the contents of the named resource directory"""
+        return get_provider(package_or_requirement).resource_listdir(resource_name)
+
+    def extraction_error(self) -> NoReturn:
+        """Give an error message for problems extracting file(s)"""
+
+        old_exc = sys.exc_info()[1]
+        cache_path = self.extraction_path or get_default_cache()
+
+        tmpl = textwrap.dedent(
+            """
+            Can't extract file(s) to egg cache
+
+            The following error occurred while trying to extract file(s)
+            to the Python egg cache:
+
+              {old_exc}
+
+            The Python egg cache directory is currently set to:
+
+              {cache_path}
+
+            Perhaps your account does not have write access to this directory?
+            You can change the cache directory by setting the PYTHON_EGG_CACHE
+            environment variable to point to an accessible directory.
+            """
+        ).lstrip()
+        err = ExtractionError(tmpl.format(**locals()))
+        err.manager = self
+        err.cache_path = cache_path
+        err.original_error = old_exc
+        raise err
+
+    def get_cache_path(self, archive_name: str, names: Iterable[StrPath] = ()):
+        """Return absolute location in cache for `archive_name` and `names`
+
+        The parent directory of the resulting path will be created if it does
+        not already exist.  `archive_name` should be the base filename of the
+        enclosing egg (which may not be the name of the enclosing zipfile!),
+        including its ".egg" extension.  `names`, if provided, should be a
+        sequence of path name parts "under" the egg's extraction location.
+
+        This method should only be called by resource providers that need to
+        obtain an extraction location, and only for names they intend to
+        extract, as it tracks the generated names for possible cleanup later.
+        """
+        extract_path = self.extraction_path or get_default_cache()
+        target_path = os.path.join(extract_path, archive_name + '-tmp', *names)
+        try:
+            _bypass_ensure_directory(target_path)
+        except Exception:
+            self.extraction_error()
+
+        self._warn_unsafe_extraction_path(extract_path)
+
+        self.cached_files[target_path] = True
+        return target_path
+
+    @staticmethod
+    def _warn_unsafe_extraction_path(path):
+        """
+        If the default extraction path is overridden and set to an insecure
+        location, such as /tmp, it opens up an opportunity for an attacker to
+        replace an extracted file with an unauthorized payload. Warn the user
+        if a known insecure location is used.
+
+        See Distribute #375 for more details.
+        """
+        if os.name == 'nt' and not path.startswith(os.environ['windir']):
+            # On Windows, permissions are generally restrictive by default
+            #  and temp directories are not writable by other users, so
+            #  bypass the warning.
+            return
+        mode = os.stat(path).st_mode
+        if mode & stat.S_IWOTH or mode & stat.S_IWGRP:
+            msg = (
+                "Extraction path is writable by group/others "
+                "and vulnerable to attack when "
+                "used with get_resource_filename ({path}). "
+                "Consider a more secure "
+                "location (set with .set_extraction_path or the "
+                "PYTHON_EGG_CACHE environment variable)."
+            ).format(**locals())
+            warnings.warn(msg, UserWarning)
+
+    def postprocess(self, tempname: StrOrBytesPath, filename: StrOrBytesPath):
+        """Perform any platform-specific postprocessing of `tempname`
+
+        This is where Mac header rewrites should be done; other platforms don't
+        have anything special they should do.
+
+        Resource providers should call this method ONLY after successfully
+        extracting a compressed resource.  They must NOT call it on resources
+        that are already in the filesystem.
+
+        `tempname` is the current (temporary) name of the file, and `filename`
+        is the name it will be renamed to by the caller after this routine
+        returns.
+        """
+
+        if os.name == 'posix':
+            # Make the resource executable
+            mode = ((os.stat(tempname).st_mode) | 0o555) & 0o7777
+            os.chmod(tempname, mode)
+
+    def set_extraction_path(self, path: str):
+        """Set the base path where resources will be extracted to, if needed.
+
+        If you do not call this routine before any extractions take place, the
+        path defaults to the return value of ``get_default_cache()``.  (Which
+        is based on the ``PYTHON_EGG_CACHE`` environment variable, with various
+        platform-specific fallbacks.  See that routine's documentation for more
+        details.)
+
+        Resources are extracted to subdirectories of this path based upon
+        information given by the ``IResourceProvider``.  You may set this to a
+        temporary directory, but then you must call ``cleanup_resources()`` to
+        delete the extracted files when done.  There is no guarantee that
+        ``cleanup_resources()`` will be able to remove all extracted files.
+
+        (Note: you may not change the extraction path for a given resource
+        manager once resources have been extracted, unless you first call
+        ``cleanup_resources()``.)
+        """
+        if self.cached_files:
+            raise ValueError("Can't change extraction path, files already extracted")
+
+        self.extraction_path = path
+
+    def cleanup_resources(self, force: bool = False) -> list[str]:
+        """
+        Delete all extracted resource files and directories, returning a list
+        of the file and directory names that could not be successfully removed.
+        This function does not have any concurrency protection, so it should
+        generally only be called when the extraction path is a temporary
+        directory exclusive to a single process.  This method is not
+        automatically called; you must call it explicitly or register it as an
+        ``atexit`` function if you wish to ensure cleanup of a temporary
+        directory used for extractions.
+        """
+        # XXX
+        return []
+
+
+def get_default_cache() -> str:
+    """
+    Return the ``PYTHON_EGG_CACHE`` environment variable
+    or a platform-relevant user cache dir for an app
+    named "Python-Eggs".
+    """
+    return os.environ.get('PYTHON_EGG_CACHE') or _user_cache_dir(appname='Python-Eggs')
+
+
+def safe_name(name: str):
+    """Convert an arbitrary string to a standard distribution name
+
+    Any runs of non-alphanumeric/. characters are replaced with a single '-'.
+    """
+    return re.sub('[^A-Za-z0-9.]+', '-', name)
+
+
+def safe_version(version: str):
+    """
+    Convert an arbitrary string to a standard version string
+    """
+    try:
+        # normalize the version
+        return str(_packaging_version.Version(version))
+    except _packaging_version.InvalidVersion:
+        version = version.replace(' ', '.')
+        return re.sub('[^A-Za-z0-9.]+', '-', version)
+
+
+def _forgiving_version(version):
+    """Fallback when ``safe_version`` is not safe enough
+    >>> parse_version(_forgiving_version('0.23ubuntu1'))
+    
+    >>> parse_version(_forgiving_version('0.23-'))
+    
+    >>> parse_version(_forgiving_version('0.-_'))
+    
+    >>> parse_version(_forgiving_version('42.+?1'))
+    
+    >>> parse_version(_forgiving_version('hello world'))
+    
+    """
+    version = version.replace(' ', '.')
+    match = _PEP440_FALLBACK.search(version)
+    if match:
+        safe = match["safe"]
+        rest = version[len(safe) :]
+    else:
+        safe = "0"
+        rest = version
+    local = f"sanitized.{_safe_segment(rest)}".strip(".")
+    return f"{safe}.dev0+{local}"
+
+
+def _safe_segment(segment):
+    """Convert an arbitrary string into a safe segment"""
+    segment = re.sub('[^A-Za-z0-9.]+', '-', segment)
+    segment = re.sub('-[^A-Za-z0-9]+', '-', segment)
+    return re.sub(r'\.[^A-Za-z0-9]+', '.', segment).strip(".-")
+
+
+def safe_extra(extra: str):
+    """Convert an arbitrary string to a standard 'extra' name
+
+    Any runs of non-alphanumeric characters are replaced with a single '_',
+    and the result is always lowercased.
+    """
+    return re.sub('[^A-Za-z0-9.-]+', '_', extra).lower()
+
+
+def to_filename(name: str):
+    """Convert a project or version name to its filename-escaped form
+
+    Any '-' characters are currently replaced with '_'.
+    """
+    return name.replace('-', '_')
+
+
+def invalid_marker(text: str):
+    """
+    Validate text as a PEP 508 environment marker; return an exception
+    if invalid or False otherwise.
+    """
+    try:
+        evaluate_marker(text)
+    except SyntaxError as e:
+        e.filename = None
+        e.lineno = None
+        return e
+    return False
+
+
+def evaluate_marker(text: str, extra: str | None = None) -> bool:
+    """
+    Evaluate a PEP 508 environment marker.
+    Return a boolean indicating the marker result in this environment.
+    Raise SyntaxError if marker is invalid.
+
+    This implementation uses the 'pyparsing' module.
+    """
+    try:
+        marker = _packaging_markers.Marker(text)
+        return marker.evaluate()
+    except _packaging_markers.InvalidMarker as e:
+        raise SyntaxError(e) from e
+
+
+class NullProvider:
+    """Try to implement resources and metadata for arbitrary PEP 302 loaders"""
+
+    egg_name: str | None = None
+    egg_info: str | None = None
+    loader: _LoaderProtocol | None = None
+
+    def __init__(self, module: _ModuleLike):
+        self.loader = getattr(module, '__loader__', None)
+        self.module_path = os.path.dirname(getattr(module, '__file__', ''))
+
+    def get_resource_filename(self, manager: ResourceManager, resource_name: str):
+        return self._fn(self.module_path, resource_name)
+
+    def get_resource_stream(self, manager: ResourceManager, resource_name: str):
+        return io.BytesIO(self.get_resource_string(manager, resource_name))
+
+    def get_resource_string(
+        self, manager: ResourceManager, resource_name: str
+    ) -> bytes:
+        return self._get(self._fn(self.module_path, resource_name))
+
+    def has_resource(self, resource_name: str):
+        return self._has(self._fn(self.module_path, resource_name))
+
+    def _get_metadata_path(self, name):
+        return self._fn(self.egg_info, name)
+
+    def has_metadata(self, name: str) -> bool:
+        if not self.egg_info:
+            return False
+
+        path = self._get_metadata_path(name)
+        return self._has(path)
+
+    def get_metadata(self, name: str):
+        if not self.egg_info:
+            return ""
+        path = self._get_metadata_path(name)
+        value = self._get(path)
+        try:
+            return value.decode('utf-8')
+        except UnicodeDecodeError as exc:
+            # Include the path in the error message to simplify
+            # troubleshooting, and without changing the exception type.
+            exc.reason += ' in {} file at path: {}'.format(name, path)
+            raise
+
+    def get_metadata_lines(self, name: str) -> Iterator[str]:
+        return yield_lines(self.get_metadata(name))
+
+    def resource_isdir(self, resource_name: str):
+        return self._isdir(self._fn(self.module_path, resource_name))
+
+    def metadata_isdir(self, name: str) -> bool:
+        return bool(self.egg_info and self._isdir(self._fn(self.egg_info, name)))
+
+    def resource_listdir(self, resource_name: str):
+        return self._listdir(self._fn(self.module_path, resource_name))
+
+    def metadata_listdir(self, name: str) -> list[str]:
+        if self.egg_info:
+            return self._listdir(self._fn(self.egg_info, name))
+        return []
+
+    def run_script(self, script_name: str, namespace: dict[str, Any]):
+        script = 'scripts/' + script_name
+        if not self.has_metadata(script):
+            raise ResolutionError(
+                "Script {script!r} not found in metadata at {self.egg_info!r}".format(
+                    **locals()
+                ),
+            )
+
+        script_text = self.get_metadata(script).replace('\r\n', '\n')
+        script_text = script_text.replace('\r', '\n')
+        script_filename = self._fn(self.egg_info, script)
+        namespace['__file__'] = script_filename
+        if os.path.exists(script_filename):
+            source = _read_utf8_with_fallback(script_filename)
+            code = compile(source, script_filename, 'exec')
+            exec(code, namespace, namespace)
+        else:
+            from linecache import cache
+
+            cache[script_filename] = (
+                len(script_text),
+                0,
+                script_text.split('\n'),
+                script_filename,
+            )
+            script_code = compile(script_text, script_filename, 'exec')
+            exec(script_code, namespace, namespace)
+
+    def _has(self, path) -> bool:
+        raise NotImplementedError(
+            "Can't perform this operation for unregistered loader type"
+        )
+
+    def _isdir(self, path) -> bool:
+        raise NotImplementedError(
+            "Can't perform this operation for unregistered loader type"
+        )
+
+    def _listdir(self, path) -> list[str]:
+        raise NotImplementedError(
+            "Can't perform this operation for unregistered loader type"
+        )
+
+    def _fn(self, base: str | None, resource_name: str):
+        if base is None:
+            raise TypeError(
+                "`base` parameter in `_fn` is `None`. Either override this method or check the parameter first."
+            )
+        self._validate_resource_path(resource_name)
+        if resource_name:
+            return os.path.join(base, *resource_name.split('/'))
+        return base
+
+    @staticmethod
+    def _validate_resource_path(path):
+        """
+        Validate the resource paths according to the docs.
+        https://setuptools.pypa.io/en/latest/pkg_resources.html#basic-resource-access
+
+        >>> warned = getfixture('recwarn')
+        >>> warnings.simplefilter('always')
+        >>> vrp = NullProvider._validate_resource_path
+        >>> vrp('foo/bar.txt')
+        >>> bool(warned)
+        False
+        >>> vrp('../foo/bar.txt')
+        >>> bool(warned)
+        True
+        >>> warned.clear()
+        >>> vrp('/foo/bar.txt')
+        >>> bool(warned)
+        True
+        >>> vrp('foo/../../bar.txt')
+        >>> bool(warned)
+        True
+        >>> warned.clear()
+        >>> vrp('foo/f../bar.txt')
+        >>> bool(warned)
+        False
+
+        Windows path separators are straight-up disallowed.
+        >>> vrp(r'\\foo/bar.txt')
+        Traceback (most recent call last):
+        ...
+        ValueError: Use of .. or absolute path in a resource path \
+is not allowed.
+
+        >>> vrp(r'C:\\foo/bar.txt')
+        Traceback (most recent call last):
+        ...
+        ValueError: Use of .. or absolute path in a resource path \
+is not allowed.
+
+        Blank values are allowed
+
+        >>> vrp('')
+        >>> bool(warned)
+        False
+
+        Non-string values are not.
+
+        >>> vrp(None)
+        Traceback (most recent call last):
+        ...
+        AttributeError: ...
+        """
+        invalid = (
+            os.path.pardir in path.split(posixpath.sep)
+            or posixpath.isabs(path)
+            or ntpath.isabs(path)
+            or path.startswith("\\")
+        )
+        if not invalid:
+            return
+
+        msg = "Use of .. or absolute path in a resource path is not allowed."
+
+        # Aggressively disallow Windows absolute paths
+        if (path.startswith("\\") or ntpath.isabs(path)) and not posixpath.isabs(path):
+            raise ValueError(msg)
+
+        # for compatibility, warn; in future
+        # raise ValueError(msg)
+        issue_warning(
+            msg[:-1] + " and will raise exceptions in a future release.",
+            DeprecationWarning,
+        )
+
+    def _get(self, path) -> bytes:
+        if hasattr(self.loader, 'get_data') and self.loader:
+            # Already checked get_data exists
+            return self.loader.get_data(path)  # type: ignore[attr-defined]
+        raise NotImplementedError(
+            "Can't perform this operation for loaders without 'get_data()'"
+        )
+
+
+register_loader_type(object, NullProvider)
+
+
+def _parents(path):
+    """
+    yield all parents of path including path
+    """
+    last = None
+    while path != last:
+        yield path
+        last = path
+        path, _ = os.path.split(path)
+
+
+class EggProvider(NullProvider):
+    """Provider based on a virtual filesystem"""
+
+    def __init__(self, module: _ModuleLike):
+        super().__init__(module)
+        self._setup_prefix()
+
+    def _setup_prefix(self):
+        # Assume that metadata may be nested inside a "basket"
+        # of multiple eggs and use module_path instead of .archive.
+        eggs = filter(_is_egg_path, _parents(self.module_path))
+        egg = next(eggs, None)
+        egg and self._set_egg(egg)
+
+    def _set_egg(self, path: str):
+        self.egg_name = os.path.basename(path)
+        self.egg_info = os.path.join(path, 'EGG-INFO')
+        self.egg_root = path
+
+
+class DefaultProvider(EggProvider):
+    """Provides access to package resources in the filesystem"""
+
+    def _has(self, path) -> bool:
+        return os.path.exists(path)
+
+    def _isdir(self, path) -> bool:
+        return os.path.isdir(path)
+
+    def _listdir(self, path):
+        return os.listdir(path)
+
+    def get_resource_stream(self, manager: object, resource_name: str):
+        return open(self._fn(self.module_path, resource_name), 'rb')
+
+    def _get(self, path) -> bytes:
+        with open(path, 'rb') as stream:
+            return stream.read()
+
+    @classmethod
+    def _register(cls):
+        loader_names = (
+            'SourceFileLoader',
+            'SourcelessFileLoader',
+        )
+        for name in loader_names:
+            loader_cls = getattr(importlib.machinery, name, type(None))
+            register_loader_type(loader_cls, cls)
+
+
+DefaultProvider._register()
+
+
+class EmptyProvider(NullProvider):
+    """Provider that returns nothing for all requests"""
+
+    # A special case, we don't want all Providers inheriting from NullProvider to have a potentially None module_path
+    module_path: str | None = None  # type: ignore[assignment]
+
+    _isdir = _has = lambda self, path: False
+
+    def _get(self, path) -> bytes:
+        return b''
+
+    def _listdir(self, path):
+        return []
+
+    def __init__(self):
+        pass
+
+
+empty_provider = EmptyProvider()
+
+
+class ZipManifests(Dict[str, "MemoizedZipManifests.manifest_mod"]):
+    """
+    zip manifest builder
+    """
+
+    # `path` could be `StrPath | IO[bytes]` but that violates the LSP for `MemoizedZipManifests.load`
+    @classmethod
+    def build(cls, path: str):
+        """
+        Build a dictionary similar to the zipimport directory
+        caches, except instead of tuples, store ZipInfo objects.
+
+        Use a platform-specific path separator (os.sep) for the path keys
+        for compatibility with pypy on Windows.
+        """
+        with zipfile.ZipFile(path) as zfile:
+            items = (
+                (
+                    name.replace('/', os.sep),
+                    zfile.getinfo(name),
+                )
+                for name in zfile.namelist()
+            )
+            return dict(items)
+
+    load = build
+
+
+class MemoizedZipManifests(ZipManifests):
+    """
+    Memoized zipfile manifests.
+    """
+
+    class manifest_mod(NamedTuple):
+        manifest: dict[str, zipfile.ZipInfo]
+        mtime: float
+
+    def load(self, path: str) -> dict[str, zipfile.ZipInfo]:  # type: ignore[override] # ZipManifests.load is a classmethod
+        """
+        Load a manifest at path or return a suitable manifest already loaded.
+        """
+        path = os.path.normpath(path)
+        mtime = os.stat(path).st_mtime
+
+        if path not in self or self[path].mtime != mtime:
+            manifest = self.build(path)
+            self[path] = self.manifest_mod(manifest, mtime)
+
+        return self[path].manifest
+
+
+class ZipProvider(EggProvider):
+    """Resource support for zips and eggs"""
+
+    eagers: list[str] | None = None
+    _zip_manifests = MemoizedZipManifests()
+    # ZipProvider's loader should always be a zipimporter or equivalent
+    loader: zipimport.zipimporter
+
+    def __init__(self, module: _ZipLoaderModule):
+        super().__init__(module)
+        self.zip_pre = self.loader.archive + os.sep
+
+    def _zipinfo_name(self, fspath):
+        # Convert a virtual filename (full path to file) into a zipfile subpath
+        # usable with the zipimport directory cache for our target archive
+        fspath = fspath.rstrip(os.sep)
+        if fspath == self.loader.archive:
+            return ''
+        if fspath.startswith(self.zip_pre):
+            return fspath[len(self.zip_pre) :]
+        raise AssertionError("%s is not a subpath of %s" % (fspath, self.zip_pre))
+
+    def _parts(self, zip_path):
+        # Convert a zipfile subpath into an egg-relative path part list.
+        # pseudo-fs path
+        fspath = self.zip_pre + zip_path
+        if fspath.startswith(self.egg_root + os.sep):
+            return fspath[len(self.egg_root) + 1 :].split(os.sep)
+        raise AssertionError("%s is not a subpath of %s" % (fspath, self.egg_root))
+
+    @property
+    def zipinfo(self):
+        return self._zip_manifests.load(self.loader.archive)
+
+    def get_resource_filename(self, manager: ResourceManager, resource_name: str):
+        if not self.egg_name:
+            raise NotImplementedError(
+                "resource_filename() only supported for .egg, not .zip"
+            )
+        # no need to lock for extraction, since we use temp names
+        zip_path = self._resource_to_zip(resource_name)
+        eagers = self._get_eager_resources()
+        if '/'.join(self._parts(zip_path)) in eagers:
+            for name in eagers:
+                self._extract_resource(manager, self._eager_to_zip(name))
+        return self._extract_resource(manager, zip_path)
+
+    @staticmethod
+    def _get_date_and_size(zip_stat):
+        size = zip_stat.file_size
+        # ymdhms+wday, yday, dst
+        date_time = zip_stat.date_time + (0, 0, -1)
+        # 1980 offset already done
+        timestamp = time.mktime(date_time)
+        return timestamp, size
+
+    # FIXME: 'ZipProvider._extract_resource' is too complex (12)
+    def _extract_resource(self, manager: ResourceManager, zip_path) -> str:  # noqa: C901
+        if zip_path in self._index():
+            for name in self._index()[zip_path]:
+                last = self._extract_resource(manager, os.path.join(zip_path, name))
+            # return the extracted directory name
+            return os.path.dirname(last)
+
+        timestamp, size = self._get_date_and_size(self.zipinfo[zip_path])
+
+        if not WRITE_SUPPORT:
+            raise OSError(
+                '"os.rename" and "os.unlink" are not supported on this platform'
+            )
+        try:
+            if not self.egg_name:
+                raise OSError(
+                    '"egg_name" is empty. This likely means no egg could be found from the "module_path".'
+                )
+            real_path = manager.get_cache_path(self.egg_name, self._parts(zip_path))
+
+            if self._is_current(real_path, zip_path):
+                return real_path
+
+            outf, tmpnam = _mkstemp(
+                ".$extract",
+                dir=os.path.dirname(real_path),
+            )
+            os.write(outf, self.loader.get_data(zip_path))
+            os.close(outf)
+            utime(tmpnam, (timestamp, timestamp))
+            manager.postprocess(tmpnam, real_path)
+
+            try:
+                rename(tmpnam, real_path)
+
+            except OSError:
+                if os.path.isfile(real_path):
+                    if self._is_current(real_path, zip_path):
+                        # the file became current since it was checked above,
+                        #  so proceed.
+                        return real_path
+                    # Windows, del old file and retry
+                    elif os.name == 'nt':
+                        unlink(real_path)
+                        rename(tmpnam, real_path)
+                        return real_path
+                raise
+
+        except OSError:
+            # report a user-friendly error
+            manager.extraction_error()
+
+        return real_path
+
+    def _is_current(self, file_path, zip_path):
+        """
+        Return True if the file_path is current for this zip_path
+        """
+        timestamp, size = self._get_date_and_size(self.zipinfo[zip_path])
+        if not os.path.isfile(file_path):
+            return False
+        stat = os.stat(file_path)
+        if stat.st_size != size or stat.st_mtime != timestamp:
+            return False
+        # check that the contents match
+        zip_contents = self.loader.get_data(zip_path)
+        with open(file_path, 'rb') as f:
+            file_contents = f.read()
+        return zip_contents == file_contents
+
+    def _get_eager_resources(self):
+        if self.eagers is None:
+            eagers = []
+            for name in ('native_libs.txt', 'eager_resources.txt'):
+                if self.has_metadata(name):
+                    eagers.extend(self.get_metadata_lines(name))
+            self.eagers = eagers
+        return self.eagers
+
+    def _index(self):
+        try:
+            return self._dirindex
+        except AttributeError:
+            ind = {}
+            for path in self.zipinfo:
+                parts = path.split(os.sep)
+                while parts:
+                    parent = os.sep.join(parts[:-1])
+                    if parent in ind:
+                        ind[parent].append(parts[-1])
+                        break
+                    else:
+                        ind[parent] = [parts.pop()]
+            self._dirindex = ind
+            return ind
+
+    def _has(self, fspath) -> bool:
+        zip_path = self._zipinfo_name(fspath)
+        return zip_path in self.zipinfo or zip_path in self._index()
+
+    def _isdir(self, fspath) -> bool:
+        return self._zipinfo_name(fspath) in self._index()
+
+    def _listdir(self, fspath):
+        return list(self._index().get(self._zipinfo_name(fspath), ()))
+
+    def _eager_to_zip(self, resource_name: str):
+        return self._zipinfo_name(self._fn(self.egg_root, resource_name))
+
+    def _resource_to_zip(self, resource_name: str):
+        return self._zipinfo_name(self._fn(self.module_path, resource_name))
+
+
+register_loader_type(zipimport.zipimporter, ZipProvider)
+
+
+class FileMetadata(EmptyProvider):
+    """Metadata handler for standalone PKG-INFO files
+
+    Usage::
+
+        metadata = FileMetadata("/path/to/PKG-INFO")
+
+    This provider rejects all data and metadata requests except for PKG-INFO,
+    which is treated as existing, and will be the contents of the file at
+    the provided location.
+    """
+
+    def __init__(self, path: StrPath):
+        self.path = path
+
+    def _get_metadata_path(self, name):
+        return self.path
+
+    def has_metadata(self, name: str) -> bool:
+        return name == 'PKG-INFO' and os.path.isfile(self.path)
+
+    def get_metadata(self, name: str):
+        if name != 'PKG-INFO':
+            raise KeyError("No metadata except PKG-INFO is available")
+
+        with open(self.path, encoding='utf-8', errors="replace") as f:
+            metadata = f.read()
+        self._warn_on_replacement(metadata)
+        return metadata
+
+    def _warn_on_replacement(self, metadata):
+        replacement_char = '�'
+        if replacement_char in metadata:
+            tmpl = "{self.path} could not be properly decoded in UTF-8"
+            msg = tmpl.format(**locals())
+            warnings.warn(msg)
+
+    def get_metadata_lines(self, name: str) -> Iterator[str]:
+        return yield_lines(self.get_metadata(name))
+
+
+class PathMetadata(DefaultProvider):
+    """Metadata provider for egg directories
+
+    Usage::
+
+        # Development eggs:
+
+        egg_info = "/path/to/PackageName.egg-info"
+        base_dir = os.path.dirname(egg_info)
+        metadata = PathMetadata(base_dir, egg_info)
+        dist_name = os.path.splitext(os.path.basename(egg_info))[0]
+        dist = Distribution(basedir, project_name=dist_name, metadata=metadata)
+
+        # Unpacked egg directories:
+
+        egg_path = "/path/to/PackageName-ver-pyver-etc.egg"
+        metadata = PathMetadata(egg_path, os.path.join(egg_path,'EGG-INFO'))
+        dist = Distribution.from_filename(egg_path, metadata=metadata)
+    """
+
+    def __init__(self, path: str, egg_info: str):
+        self.module_path = path
+        self.egg_info = egg_info
+
+
+class EggMetadata(ZipProvider):
+    """Metadata provider for .egg files"""
+
+    def __init__(self, importer: zipimport.zipimporter):
+        """Create a metadata provider from a zipimporter"""
+
+        self.zip_pre = importer.archive + os.sep
+        self.loader = importer
+        if importer.prefix:
+            self.module_path = os.path.join(importer.archive, importer.prefix)
+        else:
+            self.module_path = importer.archive
+        self._setup_prefix()
+
+
+_distribution_finders: dict[type, _DistFinderType[Any]] = _declare_state(
+    'dict', '_distribution_finders', {}
+)
+
+
+def register_finder(importer_type: type[_T], distribution_finder: _DistFinderType[_T]):
+    """Register `distribution_finder` to find distributions in sys.path items
+
+    `importer_type` is the type or class of a PEP 302 "Importer" (sys.path item
+    handler), and `distribution_finder` is a callable that, passed a path
+    item and the importer instance, yields ``Distribution`` instances found on
+    that path item.  See ``pkg_resources.find_on_path`` for an example."""
+    _distribution_finders[importer_type] = distribution_finder
+
+
+def find_distributions(path_item: str, only: bool = False):
+    """Yield distributions accessible via `path_item`"""
+    importer = get_importer(path_item)
+    finder = _find_adapter(_distribution_finders, importer)
+    return finder(importer, path_item, only)
+
+
+def find_eggs_in_zip(
+    importer: zipimport.zipimporter, path_item: str, only: bool = False
+) -> Iterator[Distribution]:
+    """
+    Find eggs in zip files; possibly multiple nested eggs.
+    """
+    if importer.archive.endswith('.whl'):
+        # wheels are not supported with this finder
+        # they don't have PKG-INFO metadata, and won't ever contain eggs
+        return
+    metadata = EggMetadata(importer)
+    if metadata.has_metadata('PKG-INFO'):
+        yield Distribution.from_filename(path_item, metadata=metadata)
+    if only:
+        # don't yield nested distros
+        return
+    for subitem in metadata.resource_listdir(''):
+        if _is_egg_path(subitem):
+            subpath = os.path.join(path_item, subitem)
+            dists = find_eggs_in_zip(zipimport.zipimporter(subpath), subpath)
+            yield from dists
+        elif subitem.lower().endswith(('.dist-info', '.egg-info')):
+            subpath = os.path.join(path_item, subitem)
+            submeta = EggMetadata(zipimport.zipimporter(subpath))
+            submeta.egg_info = subpath
+            yield Distribution.from_location(path_item, subitem, submeta)
+
+
+register_finder(zipimport.zipimporter, find_eggs_in_zip)
+
+
+def find_nothing(
+    importer: object | None, path_item: str | None, only: bool | None = False
+):
+    return ()
+
+
+register_finder(object, find_nothing)
+
+
+def find_on_path(importer: object | None, path_item, only=False):
+    """Yield distributions accessible on a sys.path directory"""
+    path_item = _normalize_cached(path_item)
+
+    if _is_unpacked_egg(path_item):
+        yield Distribution.from_filename(
+            path_item,
+            metadata=PathMetadata(path_item, os.path.join(path_item, 'EGG-INFO')),
+        )
+        return
+
+    entries = (os.path.join(path_item, child) for child in safe_listdir(path_item))
+
+    # scan for .egg and .egg-info in directory
+    for entry in sorted(entries):
+        fullpath = os.path.join(path_item, entry)
+        factory = dist_factory(path_item, entry, only)
+        yield from factory(fullpath)
+
+
+def dist_factory(path_item, entry, only):
+    """Return a dist_factory for the given entry."""
+    lower = entry.lower()
+    is_egg_info = lower.endswith('.egg-info')
+    is_dist_info = lower.endswith('.dist-info') and os.path.isdir(
+        os.path.join(path_item, entry)
+    )
+    is_meta = is_egg_info or is_dist_info
+    return (
+        distributions_from_metadata
+        if is_meta
+        else find_distributions
+        if not only and _is_egg_path(entry)
+        else resolve_egg_link
+        if not only and lower.endswith('.egg-link')
+        else NoDists()
+    )
+
+
+class NoDists:
+    """
+    >>> bool(NoDists())
+    False
+
+    >>> list(NoDists()('anything'))
+    []
+    """
+
+    def __bool__(self):
+        return False
+
+    def __call__(self, fullpath):
+        return iter(())
+
+
+def safe_listdir(path: StrOrBytesPath):
+    """
+    Attempt to list contents of path, but suppress some exceptions.
+    """
+    try:
+        return os.listdir(path)
+    except (PermissionError, NotADirectoryError):
+        pass
+    except OSError as e:
+        # Ignore the directory if does not exist, not a directory or
+        # permission denied
+        if e.errno not in (errno.ENOTDIR, errno.EACCES, errno.ENOENT):
+            raise
+    return ()
+
+
+def distributions_from_metadata(path: str):
+    root = os.path.dirname(path)
+    if os.path.isdir(path):
+        if len(os.listdir(path)) == 0:
+            # empty metadata dir; skip
+            return
+        metadata: _MetadataType = PathMetadata(root, path)
+    else:
+        metadata = FileMetadata(path)
+    entry = os.path.basename(path)
+    yield Distribution.from_location(
+        root,
+        entry,
+        metadata,
+        precedence=DEVELOP_DIST,
+    )
+
+
+def non_empty_lines(path):
+    """
+    Yield non-empty lines from file at path
+    """
+    for line in _read_utf8_with_fallback(path).splitlines():
+        line = line.strip()
+        if line:
+            yield line
+
+
+def resolve_egg_link(path):
+    """
+    Given a path to an .egg-link, resolve distributions
+    present in the referenced path.
+    """
+    referenced_paths = non_empty_lines(path)
+    resolved_paths = (
+        os.path.join(os.path.dirname(path), ref) for ref in referenced_paths
+    )
+    dist_groups = map(find_distributions, resolved_paths)
+    return next(dist_groups, ())
+
+
+if hasattr(pkgutil, 'ImpImporter'):
+    register_finder(pkgutil.ImpImporter, find_on_path)
+
+register_finder(importlib.machinery.FileFinder, find_on_path)
+
+_namespace_handlers: dict[type, _NSHandlerType[Any]] = _declare_state(
+    'dict', '_namespace_handlers', {}
+)
+_namespace_packages: dict[str | None, list[str]] = _declare_state(
+    'dict', '_namespace_packages', {}
+)
+
+
+def register_namespace_handler(
+    importer_type: type[_T], namespace_handler: _NSHandlerType[_T]
+):
+    """Register `namespace_handler` to declare namespace packages
+
+    `importer_type` is the type or class of a PEP 302 "Importer" (sys.path item
+    handler), and `namespace_handler` is a callable like this::
+
+        def namespace_handler(importer, path_entry, moduleName, module):
+            # return a path_entry to use for child packages
+
+    Namespace handlers are only called if the importer object has already
+    agreed that it can handle the relevant path item, and they should only
+    return a subpath if the module __path__ does not already contain an
+    equivalent subpath.  For an example namespace handler, see
+    ``pkg_resources.file_ns_handler``.
+    """
+    _namespace_handlers[importer_type] = namespace_handler
+
+
+def _handle_ns(packageName, path_item):
+    """Ensure that named package includes a subpath of path_item (if needed)"""
+
+    importer = get_importer(path_item)
+    if importer is None:
+        return None
+
+    # use find_spec (PEP 451) and fall-back to find_module (PEP 302)
+    try:
+        spec = importer.find_spec(packageName)
+    except AttributeError:
+        # capture warnings due to #1111
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore")
+            loader = importer.find_module(packageName)
+    else:
+        loader = spec.loader if spec else None
+
+    if loader is None:
+        return None
+    module = sys.modules.get(packageName)
+    if module is None:
+        module = sys.modules[packageName] = types.ModuleType(packageName)
+        module.__path__ = []
+        _set_parent_ns(packageName)
+    elif not hasattr(module, '__path__'):
+        raise TypeError("Not a package:", packageName)
+    handler = _find_adapter(_namespace_handlers, importer)
+    subpath = handler(importer, path_item, packageName, module)
+    if subpath is not None:
+        path = module.__path__
+        path.append(subpath)
+        importlib.import_module(packageName)
+        _rebuild_mod_path(path, packageName, module)
+    return subpath
+
+
+def _rebuild_mod_path(orig_path, package_name, module: types.ModuleType):
+    """
+    Rebuild module.__path__ ensuring that all entries are ordered
+    corresponding to their sys.path order
+    """
+    sys_path = [_normalize_cached(p) for p in sys.path]
+
+    def safe_sys_path_index(entry):
+        """
+        Workaround for #520 and #513.
+        """
+        try:
+            return sys_path.index(entry)
+        except ValueError:
+            return float('inf')
+
+    def position_in_sys_path(path):
+        """
+        Return the ordinal of the path based on its position in sys.path
+        """
+        path_parts = path.split(os.sep)
+        module_parts = package_name.count('.') + 1
+        parts = path_parts[:-module_parts]
+        return safe_sys_path_index(_normalize_cached(os.sep.join(parts)))
+
+    new_path = sorted(orig_path, key=position_in_sys_path)
+    new_path = [_normalize_cached(p) for p in new_path]
+
+    if isinstance(module.__path__, list):
+        module.__path__[:] = new_path
+    else:
+        module.__path__ = new_path
+
+
+def declare_namespace(packageName: str):
+    """Declare that package 'packageName' is a namespace package"""
+
+    msg = (
+        f"Deprecated call to `pkg_resources.declare_namespace({packageName!r})`.\n"
+        "Implementing implicit namespace packages (as specified in PEP 420) "
+        "is preferred to `pkg_resources.declare_namespace`. "
+        "See https://setuptools.pypa.io/en/latest/references/"
+        "keywords.html#keyword-namespace-packages"
+    )
+    warnings.warn(msg, DeprecationWarning, stacklevel=2)
+
+    _imp.acquire_lock()
+    try:
+        if packageName in _namespace_packages:
+            return
+
+        path: MutableSequence[str] = sys.path
+        parent, _, _ = packageName.rpartition('.')
+
+        if parent:
+            declare_namespace(parent)
+            if parent not in _namespace_packages:
+                __import__(parent)
+            try:
+                path = sys.modules[parent].__path__
+            except AttributeError as e:
+                raise TypeError("Not a package:", parent) from e
+
+        # Track what packages are namespaces, so when new path items are added,
+        # they can be updated
+        _namespace_packages.setdefault(parent or None, []).append(packageName)
+        _namespace_packages.setdefault(packageName, [])
+
+        for path_item in path:
+            # Ensure all the parent's path items are reflected in the child,
+            # if they apply
+            _handle_ns(packageName, path_item)
+
+    finally:
+        _imp.release_lock()
+
+
+def fixup_namespace_packages(path_item: str, parent: str | None = None):
+    """Ensure that previously-declared namespace packages include path_item"""
+    _imp.acquire_lock()
+    try:
+        for package in _namespace_packages.get(parent, ()):
+            subpath = _handle_ns(package, path_item)
+            if subpath:
+                fixup_namespace_packages(subpath, package)
+    finally:
+        _imp.release_lock()
+
+
+def file_ns_handler(
+    importer: object,
+    path_item: StrPath,
+    packageName: str,
+    module: types.ModuleType,
+):
+    """Compute an ns-package subpath for a filesystem or zipfile importer"""
+
+    subpath = os.path.join(path_item, packageName.split('.')[-1])
+    normalized = _normalize_cached(subpath)
+    for item in module.__path__:
+        if _normalize_cached(item) == normalized:
+            break
+    else:
+        # Only return the path if it's not already there
+        return subpath
+
+
+if hasattr(pkgutil, 'ImpImporter'):
+    register_namespace_handler(pkgutil.ImpImporter, file_ns_handler)
+
+register_namespace_handler(zipimport.zipimporter, file_ns_handler)
+register_namespace_handler(importlib.machinery.FileFinder, file_ns_handler)
+
+
+def null_ns_handler(
+    importer: object,
+    path_item: str | None,
+    packageName: str | None,
+    module: _ModuleLike | None,
+):
+    return None
+
+
+register_namespace_handler(object, null_ns_handler)
+
+
+@overload
+def normalize_path(filename: StrPath) -> str: ...
+@overload
+def normalize_path(filename: BytesPath) -> bytes: ...
+def normalize_path(filename: StrOrBytesPath):
+    """Normalize a file/dir name for comparison purposes"""
+    return os.path.normcase(os.path.realpath(os.path.normpath(_cygwin_patch(filename))))
+
+
+def _cygwin_patch(filename: StrOrBytesPath):  # pragma: nocover
+    """
+    Contrary to POSIX 2008, on Cygwin, getcwd (3) contains
+    symlink components. Using
+    os.path.abspath() works around this limitation. A fix in os.getcwd()
+    would probably better, in Cygwin even more so, except
+    that this seems to be by design...
+    """
+    return os.path.abspath(filename) if sys.platform == 'cygwin' else filename
+
+
+if TYPE_CHECKING:
+    # https://github.com/python/mypy/issues/16261
+    # https://github.com/python/typeshed/issues/6347
+    @overload
+    def _normalize_cached(filename: StrPath) -> str: ...
+    @overload
+    def _normalize_cached(filename: BytesPath) -> bytes: ...
+    def _normalize_cached(filename: StrOrBytesPath) -> str | bytes: ...
+else:
+
+    @functools.lru_cache(maxsize=None)
+    def _normalize_cached(filename):
+        return normalize_path(filename)
+
+
+def _is_egg_path(path):
+    """
+    Determine if given path appears to be an egg.
+    """
+    return _is_zip_egg(path) or _is_unpacked_egg(path)
+
+
+def _is_zip_egg(path):
+    return (
+        path.lower().endswith('.egg')
+        and os.path.isfile(path)
+        and zipfile.is_zipfile(path)
+    )
+
+
+def _is_unpacked_egg(path):
+    """
+    Determine if given path appears to be an unpacked egg.
+    """
+    return path.lower().endswith('.egg') and os.path.isfile(
+        os.path.join(path, 'EGG-INFO', 'PKG-INFO')
+    )
+
+
+def _set_parent_ns(packageName):
+    parts = packageName.split('.')
+    name = parts.pop()
+    if parts:
+        parent = '.'.join(parts)
+        setattr(sys.modules[parent], name, sys.modules[packageName])
+
+
+MODULE = re.compile(r"\w+(\.\w+)*$").match
+EGG_NAME = re.compile(
+    r"""
+    (?P[^-]+) (
+        -(?P[^-]+) (
+            -py(?P[^-]+) (
+                -(?P.+)
+            )?
+        )?
+    )?
+    """,
+    re.VERBOSE | re.IGNORECASE,
+).match
+
+
+class EntryPoint:
+    """Object representing an advertised importable object"""
+
+    def __init__(
+        self,
+        name: str,
+        module_name: str,
+        attrs: Iterable[str] = (),
+        extras: Iterable[str] = (),
+        dist: Distribution | None = None,
+    ):
+        if not MODULE(module_name):
+            raise ValueError("Invalid module name", module_name)
+        self.name = name
+        self.module_name = module_name
+        self.attrs = tuple(attrs)
+        self.extras = tuple(extras)
+        self.dist = dist
+
+    def __str__(self):
+        s = "%s = %s" % (self.name, self.module_name)
+        if self.attrs:
+            s += ':' + '.'.join(self.attrs)
+        if self.extras:
+            s += ' [%s]' % ','.join(self.extras)
+        return s
+
+    def __repr__(self):
+        return "EntryPoint.parse(%r)" % str(self)
+
+    @overload
+    def load(
+        self,
+        require: Literal[True] = True,
+        env: Environment | None = None,
+        installer: _InstallerType | None = None,
+    ) -> _ResolvedEntryPoint: ...
+    @overload
+    def load(
+        self,
+        require: Literal[False],
+        *args: Any,
+        **kwargs: Any,
+    ) -> _ResolvedEntryPoint: ...
+    def load(
+        self,
+        require: bool = True,
+        *args: Environment | _InstallerType | None,
+        **kwargs: Environment | _InstallerType | None,
+    ) -> _ResolvedEntryPoint:
+        """
+        Require packages for this EntryPoint, then resolve it.
+        """
+        if not require or args or kwargs:
+            warnings.warn(
+                "Parameters to load are deprecated.  Call .resolve and "
+                ".require separately.",
+                PkgResourcesDeprecationWarning,
+                stacklevel=2,
+            )
+        if require:
+            # We could pass `env` and `installer` directly,
+            # but keeping `*args` and `**kwargs` for backwards compatibility
+            self.require(*args, **kwargs)  # type: ignore
+        return self.resolve()
+
+    def resolve(self) -> _ResolvedEntryPoint:
+        """
+        Resolve the entry point from its module and attrs.
+        """
+        module = __import__(self.module_name, fromlist=['__name__'], level=0)
+        try:
+            return functools.reduce(getattr, self.attrs, module)
+        except AttributeError as exc:
+            raise ImportError(str(exc)) from exc
+
+    def require(
+        self,
+        env: Environment | None = None,
+        installer: _InstallerType | None = None,
+    ):
+        if not self.dist:
+            error_cls = UnknownExtra if self.extras else AttributeError
+            raise error_cls("Can't require() without a distribution", self)
+
+        # Get the requirements for this entry point with all its extras and
+        # then resolve them. We have to pass `extras` along when resolving so
+        # that the working set knows what extras we want. Otherwise, for
+        # dist-info distributions, the working set will assume that the
+        # requirements for that extra are purely optional and skip over them.
+        reqs = self.dist.requires(self.extras)
+        items = working_set.resolve(reqs, env, installer, extras=self.extras)
+        list(map(working_set.add, items))
+
+    pattern = re.compile(
+        r'\s*'
+        r'(?P.+?)\s*'
+        r'=\s*'
+        r'(?P[\w.]+)\s*'
+        r'(:\s*(?P[\w.]+))?\s*'
+        r'(?P\[.*\])?\s*$'
+    )
+
+    @classmethod
+    def parse(cls, src: str, dist: Distribution | None = None):
+        """Parse a single entry point from string `src`
+
+        Entry point syntax follows the form::
+
+            name = some.module:some.attr [extra1, extra2]
+
+        The entry name and module name are required, but the ``:attrs`` and
+        ``[extras]`` parts are optional
+        """
+        m = cls.pattern.match(src)
+        if not m:
+            msg = "EntryPoint must be in 'name=module:attrs [extras]' format"
+            raise ValueError(msg, src)
+        res = m.groupdict()
+        extras = cls._parse_extras(res['extras'])
+        attrs = res['attr'].split('.') if res['attr'] else ()
+        return cls(res['name'], res['module'], attrs, extras, dist)
+
+    @classmethod
+    def _parse_extras(cls, extras_spec):
+        if not extras_spec:
+            return ()
+        req = Requirement.parse('x' + extras_spec)
+        if req.specs:
+            raise ValueError
+        return req.extras
+
+    @classmethod
+    def parse_group(
+        cls,
+        group: str,
+        lines: _NestedStr,
+        dist: Distribution | None = None,
+    ):
+        """Parse an entry point group"""
+        if not MODULE(group):
+            raise ValueError("Invalid group name", group)
+        this: dict[str, Self] = {}
+        for line in yield_lines(lines):
+            ep = cls.parse(line, dist)
+            if ep.name in this:
+                raise ValueError("Duplicate entry point", group, ep.name)
+            this[ep.name] = ep
+        return this
+
+    @classmethod
+    def parse_map(
+        cls,
+        data: str | Iterable[str] | dict[str, str | Iterable[str]],
+        dist: Distribution | None = None,
+    ):
+        """Parse a map of entry point groups"""
+        _data: Iterable[tuple[str | None, str | Iterable[str]]]
+        if isinstance(data, dict):
+            _data = data.items()
+        else:
+            _data = split_sections(data)
+        maps: dict[str, dict[str, Self]] = {}
+        for group, lines in _data:
+            if group is None:
+                if not lines:
+                    continue
+                raise ValueError("Entry points must be listed in groups")
+            group = group.strip()
+            if group in maps:
+                raise ValueError("Duplicate group name", group)
+            maps[group] = cls.parse_group(group, lines, dist)
+        return maps
+
+
+def _version_from_file(lines):
+    """
+    Given an iterable of lines from a Metadata file, return
+    the value of the Version field, if present, or None otherwise.
+    """
+
+    def is_version_line(line):
+        return line.lower().startswith('version:')
+
+    version_lines = filter(is_version_line, lines)
+    line = next(iter(version_lines), '')
+    _, _, value = line.partition(':')
+    return safe_version(value.strip()) or None
+
+
+class Distribution:
+    """Wrap an actual or potential sys.path entry w/metadata"""
+
+    PKG_INFO = 'PKG-INFO'
+
+    def __init__(
+        self,
+        location: str | None = None,
+        metadata: _MetadataType = None,
+        project_name: str | None = None,
+        version: str | None = None,
+        py_version: str | None = PY_MAJOR,
+        platform: str | None = None,
+        precedence: int = EGG_DIST,
+    ):
+        self.project_name = safe_name(project_name or 'Unknown')
+        if version is not None:
+            self._version = safe_version(version)
+        self.py_version = py_version
+        self.platform = platform
+        self.location = location
+        self.precedence = precedence
+        self._provider = metadata or empty_provider
+
+    @classmethod
+    def from_location(
+        cls,
+        location: str,
+        basename: StrPath,
+        metadata: _MetadataType = None,
+        **kw: int,  # We could set `precedence` explicitly, but keeping this as `**kw` for full backwards and subclassing compatibility
+    ) -> Distribution:
+        project_name, version, py_version, platform = [None] * 4
+        basename, ext = os.path.splitext(basename)
+        if ext.lower() in _distributionImpl:
+            cls = _distributionImpl[ext.lower()]
+
+            match = EGG_NAME(basename)
+            if match:
+                project_name, version, py_version, platform = match.group(
+                    'name', 'ver', 'pyver', 'plat'
+                )
+        return cls(
+            location,
+            metadata,
+            project_name=project_name,
+            version=version,
+            py_version=py_version,
+            platform=platform,
+            **kw,
+        )._reload_version()
+
+    def _reload_version(self):
+        return self
+
+    @property
+    def hashcmp(self):
+        return (
+            self._forgiving_parsed_version,
+            self.precedence,
+            self.key,
+            self.location,
+            self.py_version or '',
+            self.platform or '',
+        )
+
+    def __hash__(self):
+        return hash(self.hashcmp)
+
+    def __lt__(self, other: Distribution):
+        return self.hashcmp < other.hashcmp
+
+    def __le__(self, other: Distribution):
+        return self.hashcmp <= other.hashcmp
+
+    def __gt__(self, other: Distribution):
+        return self.hashcmp > other.hashcmp
+
+    def __ge__(self, other: Distribution):
+        return self.hashcmp >= other.hashcmp
+
+    def __eq__(self, other: object):
+        if not isinstance(other, self.__class__):
+            # It's not a Distribution, so they are not equal
+            return False
+        return self.hashcmp == other.hashcmp
+
+    def __ne__(self, other: object):
+        return not self == other
+
+    # These properties have to be lazy so that we don't have to load any
+    # metadata until/unless it's actually needed.  (i.e., some distributions
+    # may not know their name or version without loading PKG-INFO)
+
+    @property
+    def key(self):
+        try:
+            return self._key
+        except AttributeError:
+            self._key = key = self.project_name.lower()
+            return key
+
+    @property
+    def parsed_version(self):
+        if not hasattr(self, "_parsed_version"):
+            try:
+                self._parsed_version = parse_version(self.version)
+            except _packaging_version.InvalidVersion as ex:
+                info = f"(package: {self.project_name})"
+                if hasattr(ex, "add_note"):
+                    ex.add_note(info)  # PEP 678
+                    raise
+                raise _packaging_version.InvalidVersion(f"{str(ex)} {info}") from None
+
+        return self._parsed_version
+
+    @property
+    def _forgiving_parsed_version(self):
+        try:
+            return self.parsed_version
+        except _packaging_version.InvalidVersion as ex:
+            self._parsed_version = parse_version(_forgiving_version(self.version))
+
+            notes = "\n".join(getattr(ex, "__notes__", []))  # PEP 678
+            msg = f"""!!\n\n
+            *************************************************************************
+            {str(ex)}\n{notes}
+
+            This is a long overdue deprecation.
+            For the time being, `pkg_resources` will use `{self._parsed_version}`
+            as a replacement to avoid breaking existing environments,
+            but no future compatibility is guaranteed.
+
+            If you maintain package {self.project_name} you should implement
+            the relevant changes to adequate the project to PEP 440 immediately.
+            *************************************************************************
+            \n\n!!
+            """
+            warnings.warn(msg, DeprecationWarning)
+
+            return self._parsed_version
+
+    @property
+    def version(self):
+        try:
+            return self._version
+        except AttributeError as e:
+            version = self._get_version()
+            if version is None:
+                path = self._get_metadata_path_for_display(self.PKG_INFO)
+                msg = ("Missing 'Version:' header and/or {} file at path: {}").format(
+                    self.PKG_INFO, path
+                )
+                raise ValueError(msg, self) from e
+
+            return version
+
+    @property
+    def _dep_map(self):
+        """
+        A map of extra to its list of (direct) requirements
+        for this distribution, including the null extra.
+        """
+        try:
+            return self.__dep_map
+        except AttributeError:
+            self.__dep_map = self._filter_extras(self._build_dep_map())
+        return self.__dep_map
+
+    @staticmethod
+    def _filter_extras(dm: dict[str | None, list[Requirement]]):
+        """
+        Given a mapping of extras to dependencies, strip off
+        environment markers and filter out any dependencies
+        not matching the markers.
+        """
+        for extra in list(filter(None, dm)):
+            new_extra: str | None = extra
+            reqs = dm.pop(extra)
+            new_extra, _, marker = extra.partition(':')
+            fails_marker = marker and (
+                invalid_marker(marker) or not evaluate_marker(marker)
+            )
+            if fails_marker:
+                reqs = []
+            new_extra = safe_extra(new_extra) or None
+
+            dm.setdefault(new_extra, []).extend(reqs)
+        return dm
+
+    def _build_dep_map(self):
+        dm = {}
+        for name in 'requires.txt', 'depends.txt':
+            for extra, reqs in split_sections(self._get_metadata(name)):
+                dm.setdefault(extra, []).extend(parse_requirements(reqs))
+        return dm
+
+    def requires(self, extras: Iterable[str] = ()):
+        """List of Requirements needed for this distro if `extras` are used"""
+        dm = self._dep_map
+        deps: list[Requirement] = []
+        deps.extend(dm.get(None, ()))
+        for ext in extras:
+            try:
+                deps.extend(dm[safe_extra(ext)])
+            except KeyError as e:
+                raise UnknownExtra(
+                    "%s has no such extra feature %r" % (self, ext)
+                ) from e
+        return deps
+
+    def _get_metadata_path_for_display(self, name):
+        """
+        Return the path to the given metadata file, if available.
+        """
+        try:
+            # We need to access _get_metadata_path() on the provider object
+            # directly rather than through this class's __getattr__()
+            # since _get_metadata_path() is marked private.
+            path = self._provider._get_metadata_path(name)
+
+        # Handle exceptions e.g. in case the distribution's metadata
+        # provider doesn't support _get_metadata_path().
+        except Exception:
+            return '[could not detect]'
+
+        return path
+
+    def _get_metadata(self, name):
+        if self.has_metadata(name):
+            yield from self.get_metadata_lines(name)
+
+    def _get_version(self):
+        lines = self._get_metadata(self.PKG_INFO)
+        return _version_from_file(lines)
+
+    def activate(self, path: list[str] | None = None, replace: bool = False):
+        """Ensure distribution is importable on `path` (default=sys.path)"""
+        if path is None:
+            path = sys.path
+        self.insert_on(path, replace=replace)
+        if path is sys.path and self.location is not None:
+            fixup_namespace_packages(self.location)
+            for pkg in self._get_metadata('namespace_packages.txt'):
+                if pkg in sys.modules:
+                    declare_namespace(pkg)
+
+    def egg_name(self):
+        """Return what this distribution's standard .egg filename should be"""
+        filename = "%s-%s-py%s" % (
+            to_filename(self.project_name),
+            to_filename(self.version),
+            self.py_version or PY_MAJOR,
+        )
+
+        if self.platform:
+            filename += '-' + self.platform
+        return filename
+
+    def __repr__(self):
+        if self.location:
+            return "%s (%s)" % (self, self.location)
+        else:
+            return str(self)
+
+    def __str__(self):
+        try:
+            version = getattr(self, 'version', None)
+        except ValueError:
+            version = None
+        version = version or "[unknown version]"
+        return "%s %s" % (self.project_name, version)
+
+    def __getattr__(self, attr):
+        """Delegate all unrecognized public attributes to .metadata provider"""
+        if attr.startswith('_'):
+            raise AttributeError(attr)
+        return getattr(self._provider, attr)
+
+    def __dir__(self):
+        return list(
+            set(super().__dir__())
+            | set(attr for attr in self._provider.__dir__() if not attr.startswith('_'))
+        )
+
+    @classmethod
+    def from_filename(
+        cls,
+        filename: StrPath,
+        metadata: _MetadataType = None,
+        **kw: int,  # We could set `precedence` explicitly, but keeping this as `**kw` for full backwards and subclassing compatibility
+    ):
+        return cls.from_location(
+            _normalize_cached(filename), os.path.basename(filename), metadata, **kw
+        )
+
+    def as_requirement(self):
+        """Return a ``Requirement`` that matches this distribution exactly"""
+        if isinstance(self.parsed_version, _packaging_version.Version):
+            spec = "%s==%s" % (self.project_name, self.parsed_version)
+        else:
+            spec = "%s===%s" % (self.project_name, self.parsed_version)
+
+        return Requirement.parse(spec)
+
+    def load_entry_point(self, group: str, name: str) -> _ResolvedEntryPoint:
+        """Return the `name` entry point of `group` or raise ImportError"""
+        ep = self.get_entry_info(group, name)
+        if ep is None:
+            raise ImportError("Entry point %r not found" % ((group, name),))
+        return ep.load()
+
+    @overload
+    def get_entry_map(self, group: None = None) -> dict[str, dict[str, EntryPoint]]: ...
+    @overload
+    def get_entry_map(self, group: str) -> dict[str, EntryPoint]: ...
+    def get_entry_map(self, group: str | None = None):
+        """Return the entry point map for `group`, or the full entry map"""
+        if not hasattr(self, "_ep_map"):
+            self._ep_map = EntryPoint.parse_map(
+                self._get_metadata('entry_points.txt'), self
+            )
+        if group is not None:
+            return self._ep_map.get(group, {})
+        return self._ep_map
+
+    def get_entry_info(self, group: str, name: str):
+        """Return the EntryPoint object for `group`+`name`, or ``None``"""
+        return self.get_entry_map(group).get(name)
+
+    # FIXME: 'Distribution.insert_on' is too complex (13)
+    def insert_on(  # noqa: C901
+        self,
+        path: list[str],
+        loc=None,
+        replace: bool = False,
+    ):
+        """Ensure self.location is on path
+
+        If replace=False (default):
+            - If location is already in path anywhere, do nothing.
+            - Else:
+              - If it's an egg and its parent directory is on path,
+                insert just ahead of the parent.
+              - Else: add to the end of path.
+        If replace=True:
+            - If location is already on path anywhere (not eggs)
+              or higher priority than its parent (eggs)
+              do nothing.
+            - Else:
+              - If it's an egg and its parent directory is on path,
+                insert just ahead of the parent,
+                removing any lower-priority entries.
+              - Else: add it to the front of path.
+        """
+
+        loc = loc or self.location
+        if not loc:
+            return
+
+        nloc = _normalize_cached(loc)
+        bdir = os.path.dirname(nloc)
+        npath = [(p and _normalize_cached(p) or p) for p in path]
+
+        for p, item in enumerate(npath):
+            if item == nloc:
+                if replace:
+                    break
+                else:
+                    # don't modify path (even removing duplicates) if
+                    # found and not replace
+                    return
+            elif item == bdir and self.precedence == EGG_DIST:
+                # if it's an .egg, give it precedence over its directory
+                # UNLESS it's already been added to sys.path and replace=False
+                if (not replace) and nloc in npath[p:]:
+                    return
+                if path is sys.path:
+                    self.check_version_conflict()
+                path.insert(p, loc)
+                npath.insert(p, nloc)
+                break
+        else:
+            if path is sys.path:
+                self.check_version_conflict()
+            if replace:
+                path.insert(0, loc)
+            else:
+                path.append(loc)
+            return
+
+        # p is the spot where we found or inserted loc; now remove duplicates
+        while True:
+            try:
+                np = npath.index(nloc, p + 1)
+            except ValueError:
+                break
+            else:
+                del npath[np], path[np]
+                # ha!
+                p = np
+
+        return
+
+    def check_version_conflict(self):
+        if self.key == 'setuptools':
+            # ignore the inevitable setuptools self-conflicts  :(
+            return
+
+        nsp = dict.fromkeys(self._get_metadata('namespace_packages.txt'))
+        loc = normalize_path(self.location)
+        for modname in self._get_metadata('top_level.txt'):
+            if (
+                modname not in sys.modules
+                or modname in nsp
+                or modname in _namespace_packages
+            ):
+                continue
+            if modname in ('pkg_resources', 'setuptools', 'site'):
+                continue
+            fn = getattr(sys.modules[modname], '__file__', None)
+            if fn and (
+                normalize_path(fn).startswith(loc) or fn.startswith(self.location)
+            ):
+                continue
+            issue_warning(
+                "Module %s was already imported from %s, but %s is being added"
+                " to sys.path" % (modname, fn, self.location),
+            )
+
+    def has_version(self):
+        try:
+            self.version
+        except ValueError:
+            issue_warning("Unbuilt egg for " + repr(self))
+            return False
+        except SystemError:
+            # TODO: remove this except clause when python/cpython#103632 is fixed.
+            return False
+        return True
+
+    def clone(self, **kw: str | int | IResourceProvider | None):
+        """Copy this distribution, substituting in any changed keyword args"""
+        names = 'project_name version py_version platform location precedence'
+        for attr in names.split():
+            kw.setdefault(attr, getattr(self, attr, None))
+        kw.setdefault('metadata', self._provider)
+        # Unsafely unpacking. But keeping **kw for backwards and subclassing compatibility
+        return self.__class__(**kw)  # type:ignore[arg-type]
+
+    @property
+    def extras(self):
+        return [dep for dep in self._dep_map if dep]
+
+
+class EggInfoDistribution(Distribution):
+    def _reload_version(self):
+        """
+        Packages installed by distutils (e.g. numpy or scipy),
+        which uses an old safe_version, and so
+        their version numbers can get mangled when
+        converted to filenames (e.g., 1.11.0.dev0+2329eae to
+        1.11.0.dev0_2329eae). These distributions will not be
+        parsed properly
+        downstream by Distribution and safe_version, so
+        take an extra step and try to get the version number from
+        the metadata file itself instead of the filename.
+        """
+        md_version = self._get_version()
+        if md_version:
+            self._version = md_version
+        return self
+
+
+class DistInfoDistribution(Distribution):
+    """
+    Wrap an actual or potential sys.path entry
+    w/metadata, .dist-info style.
+    """
+
+    PKG_INFO = 'METADATA'
+    EQEQ = re.compile(r"([\(,])\s*(\d.*?)\s*([,\)])")
+
+    @property
+    def _parsed_pkg_info(self):
+        """Parse and cache metadata"""
+        try:
+            return self._pkg_info
+        except AttributeError:
+            metadata = self.get_metadata(self.PKG_INFO)
+            self._pkg_info = email.parser.Parser().parsestr(metadata)
+            return self._pkg_info
+
+    @property
+    def _dep_map(self):
+        try:
+            return self.__dep_map
+        except AttributeError:
+            self.__dep_map = self._compute_dependencies()
+            return self.__dep_map
+
+    def _compute_dependencies(self) -> dict[str | None, list[Requirement]]:
+        """Recompute this distribution's dependencies."""
+        self.__dep_map: dict[str | None, list[Requirement]] = {None: []}
+
+        reqs: list[Requirement] = []
+        # Including any condition expressions
+        for req in self._parsed_pkg_info.get_all('Requires-Dist') or []:
+            reqs.extend(parse_requirements(req))
+
+        def reqs_for_extra(extra):
+            for req in reqs:
+                if not req.marker or req.marker.evaluate({'extra': extra}):
+                    yield req
+
+        common = types.MappingProxyType(dict.fromkeys(reqs_for_extra(None)))
+        self.__dep_map[None].extend(common)
+
+        for extra in self._parsed_pkg_info.get_all('Provides-Extra') or []:
+            s_extra = safe_extra(extra.strip())
+            self.__dep_map[s_extra] = [
+                r for r in reqs_for_extra(extra) if r not in common
+            ]
+
+        return self.__dep_map
+
+
+_distributionImpl = {
+    '.egg': Distribution,
+    '.egg-info': EggInfoDistribution,
+    '.dist-info': DistInfoDistribution,
+}
+
+
+def issue_warning(*args, **kw):
+    level = 1
+    g = globals()
+    try:
+        # find the first stack frame that is *not* code in
+        # the pkg_resources module, to use for the warning
+        while sys._getframe(level).f_globals is g:
+            level += 1
+    except ValueError:
+        pass
+    warnings.warn(stacklevel=level + 1, *args, **kw)
+
+
+def parse_requirements(strs: _NestedStr):
+    """
+    Yield ``Requirement`` objects for each specification in `strs`.
+
+    `strs` must be a string, or a (possibly-nested) iterable thereof.
+    """
+    return map(Requirement, join_continuation(map(drop_comment, yield_lines(strs))))
+
+
+class RequirementParseError(_packaging_requirements.InvalidRequirement):
+    "Compatibility wrapper for InvalidRequirement"
+
+
+class Requirement(_packaging_requirements.Requirement):
+    def __init__(self, requirement_string: str):
+        """DO NOT CALL THIS UNDOCUMENTED METHOD; use Requirement.parse()!"""
+        super().__init__(requirement_string)
+        self.unsafe_name = self.name
+        project_name = safe_name(self.name)
+        self.project_name, self.key = project_name, project_name.lower()
+        self.specs = [(spec.operator, spec.version) for spec in self.specifier]
+        # packaging.requirements.Requirement uses a set for its extras. We use a variable-length tuple
+        self.extras: tuple[str] = tuple(map(safe_extra, self.extras))
+        self.hashCmp = (
+            self.key,
+            self.url,
+            self.specifier,
+            frozenset(self.extras),
+            str(self.marker) if self.marker else None,
+        )
+        self.__hash = hash(self.hashCmp)
+
+    def __eq__(self, other: object):
+        return isinstance(other, Requirement) and self.hashCmp == other.hashCmp
+
+    def __ne__(self, other):
+        return not self == other
+
+    def __contains__(self, item: Distribution | str | tuple[str, ...]) -> bool:
+        if isinstance(item, Distribution):
+            if item.key != self.key:
+                return False
+
+            item = item.version
+
+        # Allow prereleases always in order to match the previous behavior of
+        # this method. In the future this should be smarter and follow PEP 440
+        # more accurately.
+        return self.specifier.contains(item, prereleases=True)
+
+    def __hash__(self):
+        return self.__hash
+
+    def __repr__(self):
+        return "Requirement.parse(%r)" % str(self)
+
+    @staticmethod
+    def parse(s: str | Iterable[str]):
+        (req,) = parse_requirements(s)
+        return req
+
+
+def _always_object(classes):
+    """
+    Ensure object appears in the mro even
+    for old-style classes.
+    """
+    if object not in classes:
+        return classes + (object,)
+    return classes
+
+
+def _find_adapter(registry: Mapping[type, _AdapterT], ob: object) -> _AdapterT:
+    """Return an adapter factory for `ob` from `registry`"""
+    types = _always_object(inspect.getmro(getattr(ob, '__class__', type(ob))))
+    for t in types:
+        if t in registry:
+            return registry[t]
+    # _find_adapter would previously return None, and immediately be called.
+    # So we're raising a TypeError to keep backward compatibility if anyone depended on that behaviour.
+    raise TypeError(f"Could not find adapter for {registry} and {ob}")
+
+
+def ensure_directory(path: StrOrBytesPath):
+    """Ensure that the parent directory of `path` exists"""
+    dirname = os.path.dirname(path)
+    os.makedirs(dirname, exist_ok=True)
+
+
+def _bypass_ensure_directory(path):
+    """Sandbox-bypassing version of ensure_directory()"""
+    if not WRITE_SUPPORT:
+        raise OSError('"os.mkdir" not supported on this platform.')
+    dirname, filename = split(path)
+    if dirname and filename and not isdir(dirname):
+        _bypass_ensure_directory(dirname)
+        try:
+            mkdir(dirname, 0o755)
+        except FileExistsError:
+            pass
+
+
+def split_sections(s: _NestedStr) -> Iterator[tuple[str | None, list[str]]]:
+    """Split a string or iterable thereof into (section, content) pairs
+
+    Each ``section`` is a stripped version of the section header ("[section]")
+    and each ``content`` is a list of stripped lines excluding blank lines and
+    comment-only lines.  If there are any such lines before the first section
+    header, they're returned in a first ``section`` of ``None``.
+    """
+    section = None
+    content = []
+    for line in yield_lines(s):
+        if line.startswith("["):
+            if line.endswith("]"):
+                if section or content:
+                    yield section, content
+                section = line[1:-1].strip()
+                content = []
+            else:
+                raise ValueError("Invalid section heading", line)
+        else:
+            content.append(line)
+
+    # wrap up last segment
+    yield section, content
+
+
+def _mkstemp(*args, **kw):
+    old_open = os.open
+    try:
+        # temporarily bypass sandboxing
+        os.open = os_open
+        return tempfile.mkstemp(*args, **kw)
+    finally:
+        # and then put it back
+        os.open = old_open
+
+
+# Silence the PEP440Warning by default, so that end users don't get hit by it
+# randomly just because they use pkg_resources. We want to append the rule
+# because we want earlier uses of filterwarnings to take precedence over this
+# one.
+warnings.filterwarnings("ignore", category=PEP440Warning, append=True)
+
+
+class PkgResourcesDeprecationWarning(Warning):
+    """
+    Base class for warning about deprecations in ``pkg_resources``
+
+    This class is not derived from ``DeprecationWarning``, and as such is
+    visible by default.
+    """
+
+
+# Ported from ``setuptools`` to avoid introducing an import inter-dependency:
+_LOCALE_ENCODING = "locale" if sys.version_info >= (3, 10) else None
+
+
+def _read_utf8_with_fallback(file: str, fallback_encoding=_LOCALE_ENCODING) -> str:
+    """See setuptools.unicode_utils._read_utf8_with_fallback"""
+    try:
+        with open(file, "r", encoding="utf-8") as f:
+            return f.read()
+    except UnicodeDecodeError:  # pragma: no cover
+        msg = f"""\
+        ********************************************************************************
+        `encoding="utf-8"` fails with {file!r}, trying `encoding={fallback_encoding!r}`.
+
+        This fallback behaviour is considered **deprecated** and future versions of
+        `setuptools/pkg_resources` may not implement it.
+
+        Please encode {file!r} with "utf-8" to ensure future builds will succeed.
+
+        If this file was produced by `setuptools` itself, cleaning up the cached files
+        and re-building/re-installing the package with a newer version of `setuptools`
+        (e.g. by updating `build-system.requires` in its `pyproject.toml`)
+        might solve the problem.
+        ********************************************************************************
+        """
+        # TODO: Add a deadline?
+        #       See comment in setuptools.unicode_utils._Utf8EncodingNeeded
+        warnings.warn(msg, PkgResourcesDeprecationWarning, stacklevel=2)
+        with open(file, "r", encoding=fallback_encoding) as f:
+            return f.read()
+
+
+# from jaraco.functools 1.3
+def _call_aside(f, *args, **kwargs):
+    f(*args, **kwargs)
+    return f
+
+
+@_call_aside
+def _initialize(g=globals()):
+    "Set up global resource manager (deliberately not state-saved)"
+    manager = ResourceManager()
+    g['_manager'] = manager
+    g.update(
+        (name, getattr(manager, name))
+        for name in dir(manager)
+        if not name.startswith('_')
+    )
+
+
+@_call_aside
+def _initialize_master_working_set():
+    """
+    Prepare the master working set and make the ``require()``
+    API available.
+
+    This function has explicit effects on the global state
+    of pkg_resources. It is intended to be invoked once at
+    the initialization of this module.
+
+    Invocation by other packages is unsupported and done
+    at their own risk.
+    """
+    working_set = _declare_state('object', 'working_set', WorkingSet._build_master())
+
+    require = working_set.require
+    iter_entry_points = working_set.iter_entry_points
+    add_activation_listener = working_set.subscribe
+    run_script = working_set.run_script
+    # backward compatibility
+    run_main = run_script
+    # Activate all distributions already on sys.path with replace=False and
+    # ensure that all distributions added to the working set in the future
+    # (e.g. by calling ``require()``) will get activated as well,
+    # with higher priority (replace=True).
+    tuple(dist.activate(replace=False) for dist in working_set)
+    add_activation_listener(
+        lambda dist: dist.activate(replace=True),
+        existing=False,
+    )
+    working_set.entries = []
+    # match order
+    list(map(working_set.add_entry, sys.path))
+    globals().update(locals())
+
+
+if TYPE_CHECKING:
+    # All of these are set by the @_call_aside methods above
+    __resource_manager = ResourceManager()  # Won't exist at runtime
+    resource_exists = __resource_manager.resource_exists
+    resource_isdir = __resource_manager.resource_isdir
+    resource_filename = __resource_manager.resource_filename
+    resource_stream = __resource_manager.resource_stream
+    resource_string = __resource_manager.resource_string
+    resource_listdir = __resource_manager.resource_listdir
+    set_extraction_path = __resource_manager.set_extraction_path
+    cleanup_resources = __resource_manager.cleanup_resources
+
+    working_set = WorkingSet()
+    require = working_set.require
+    iter_entry_points = working_set.iter_entry_points
+    add_activation_listener = working_set.subscribe
+    run_script = working_set.run_script
+    run_main = run_script
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/pkg_resources/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_vendor/pkg_resources/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 00000000..bad9e123
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_vendor/pkg_resources/__pycache__/__init__.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/platformdirs/__init__.py b/venv/lib/python3.12/site-packages/pip/_vendor/platformdirs/__init__.py
new file mode 100644
index 00000000..d58dd2b7
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_vendor/platformdirs/__init__.py
@@ -0,0 +1,627 @@
+"""
+Utilities for determining application-specific dirs.
+
+See  for details and usage.
+
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+from typing import TYPE_CHECKING
+
+from .api import PlatformDirsABC
+from .version import __version__
+from .version import __version_tuple__ as __version_info__
+
+if TYPE_CHECKING:
+    from pathlib import Path
+    from typing import Literal
+
+
+def _set_platform_dir_class() -> type[PlatformDirsABC]:
+    if sys.platform == "win32":
+        from pip._vendor.platformdirs.windows import Windows as Result  # noqa: PLC0415
+    elif sys.platform == "darwin":
+        from pip._vendor.platformdirs.macos import MacOS as Result  # noqa: PLC0415
+    else:
+        from pip._vendor.platformdirs.unix import Unix as Result  # noqa: PLC0415
+
+    if os.getenv("ANDROID_DATA") == "/data" and os.getenv("ANDROID_ROOT") == "/system":
+        if os.getenv("SHELL") or os.getenv("PREFIX"):
+            return Result
+
+        from pip._vendor.platformdirs.android import _android_folder  # noqa: PLC0415
+
+        if _android_folder() is not None:
+            from pip._vendor.platformdirs.android import Android  # noqa: PLC0415
+
+            return Android  # return to avoid redefinition of a result
+
+    return Result
+
+
+PlatformDirs = _set_platform_dir_class()  #: Currently active platform
+AppDirs = PlatformDirs  #: Backwards compatibility with appdirs
+
+
+def user_data_dir(
+    appname: str | None = None,
+    appauthor: str | None | Literal[False] = None,
+    version: str | None = None,
+    roaming: bool = False,  # noqa: FBT001, FBT002
+    ensure_exists: bool = False,  # noqa: FBT001, FBT002
+) -> str:
+    """
+    :param appname: See `appname `.
+    :param appauthor: See `appauthor `.
+    :param version: See `version `.
+    :param roaming: See `roaming `.
+    :param ensure_exists: See `ensure_exists `.
+    :returns: data directory tied to the user
+    """
+    return PlatformDirs(
+        appname=appname,
+        appauthor=appauthor,
+        version=version,
+        roaming=roaming,
+        ensure_exists=ensure_exists,
+    ).user_data_dir
+
+
+def site_data_dir(
+    appname: str | None = None,
+    appauthor: str | None | Literal[False] = None,
+    version: str | None = None,
+    multipath: bool = False,  # noqa: FBT001, FBT002
+    ensure_exists: bool = False,  # noqa: FBT001, FBT002
+) -> str:
+    """
+    :param appname: See `appname `.
+    :param appauthor: See `appauthor `.
+    :param version: See `version `.
+    :param multipath: See `roaming `.
+    :param ensure_exists: See `ensure_exists `.
+    :returns: data directory shared by users
+    """
+    return PlatformDirs(
+        appname=appname,
+        appauthor=appauthor,
+        version=version,
+        multipath=multipath,
+        ensure_exists=ensure_exists,
+    ).site_data_dir
+
+
+def user_config_dir(
+    appname: str | None = None,
+    appauthor: str | None | Literal[False] = None,
+    version: str | None = None,
+    roaming: bool = False,  # noqa: FBT001, FBT002
+    ensure_exists: bool = False,  # noqa: FBT001, FBT002
+) -> str:
+    """
+    :param appname: See `appname `.
+    :param appauthor: See `appauthor `.
+    :param version: See `version `.
+    :param roaming: See `roaming `.
+    :param ensure_exists: See `ensure_exists `.
+    :returns: config directory tied to the user
+    """
+    return PlatformDirs(
+        appname=appname,
+        appauthor=appauthor,
+        version=version,
+        roaming=roaming,
+        ensure_exists=ensure_exists,
+    ).user_config_dir
+
+
+def site_config_dir(
+    appname: str | None = None,
+    appauthor: str | None | Literal[False] = None,
+    version: str | None = None,
+    multipath: bool = False,  # noqa: FBT001, FBT002
+    ensure_exists: bool = False,  # noqa: FBT001, FBT002
+) -> str:
+    """
+    :param appname: See `appname `.
+    :param appauthor: See `appauthor `.
+    :param version: See `version `.
+    :param multipath: See `roaming `.
+    :param ensure_exists: See `ensure_exists `.
+    :returns: config directory shared by the users
+    """
+    return PlatformDirs(
+        appname=appname,
+        appauthor=appauthor,
+        version=version,
+        multipath=multipath,
+        ensure_exists=ensure_exists,
+    ).site_config_dir
+
+
+def user_cache_dir(
+    appname: str | None = None,
+    appauthor: str | None | Literal[False] = None,
+    version: str | None = None,
+    opinion: bool = True,  # noqa: FBT001, FBT002
+    ensure_exists: bool = False,  # noqa: FBT001, FBT002
+) -> str:
+    """
+    :param appname: See `appname `.
+    :param appauthor: See `appauthor `.
+    :param version: See `version `.
+    :param opinion: See `roaming `.
+    :param ensure_exists: See `ensure_exists `.
+    :returns: cache directory tied to the user
+    """
+    return PlatformDirs(
+        appname=appname,
+        appauthor=appauthor,
+        version=version,
+        opinion=opinion,
+        ensure_exists=ensure_exists,
+    ).user_cache_dir
+
+
+def site_cache_dir(
+    appname: str | None = None,
+    appauthor: str | None | Literal[False] = None,
+    version: str | None = None,
+    opinion: bool = True,  # noqa: FBT001, FBT002
+    ensure_exists: bool = False,  # noqa: FBT001, FBT002
+) -> str:
+    """
+    :param appname: See `appname `.
+    :param appauthor: See `appauthor `.
+    :param version: See `version `.
+    :param opinion: See `opinion `.
+    :param ensure_exists: See `ensure_exists `.
+    :returns: cache directory tied to the user
+    """
+    return PlatformDirs(
+        appname=appname,
+        appauthor=appauthor,
+        version=version,
+        opinion=opinion,
+        ensure_exists=ensure_exists,
+    ).site_cache_dir
+
+
+def user_state_dir(
+    appname: str | None = None,
+    appauthor: str | None | Literal[False] = None,
+    version: str | None = None,
+    roaming: bool = False,  # noqa: FBT001, FBT002
+    ensure_exists: bool = False,  # noqa: FBT001, FBT002
+) -> str:
+    """
+    :param appname: See `appname `.
+    :param appauthor: See `appauthor `.
+    :param version: See `version `.
+    :param roaming: See `roaming `.
+    :param ensure_exists: See `ensure_exists `.
+    :returns: state directory tied to the user
+    """
+    return PlatformDirs(
+        appname=appname,
+        appauthor=appauthor,
+        version=version,
+        roaming=roaming,
+        ensure_exists=ensure_exists,
+    ).user_state_dir
+
+
+def user_log_dir(
+    appname: str | None = None,
+    appauthor: str | None | Literal[False] = None,
+    version: str | None = None,
+    opinion: bool = True,  # noqa: FBT001, FBT002
+    ensure_exists: bool = False,  # noqa: FBT001, FBT002
+) -> str:
+    """
+    :param appname: See `appname `.
+    :param appauthor: See `appauthor `.
+    :param version: See `version `.
+    :param opinion: See `roaming `.
+    :param ensure_exists: See `ensure_exists `.
+    :returns: log directory tied to the user
+    """
+    return PlatformDirs(
+        appname=appname,
+        appauthor=appauthor,
+        version=version,
+        opinion=opinion,
+        ensure_exists=ensure_exists,
+    ).user_log_dir
+
+
+def user_documents_dir() -> str:
+    """:returns: documents directory tied to the user"""
+    return PlatformDirs().user_documents_dir
+
+
+def user_downloads_dir() -> str:
+    """:returns: downloads directory tied to the user"""
+    return PlatformDirs().user_downloads_dir
+
+
+def user_pictures_dir() -> str:
+    """:returns: pictures directory tied to the user"""
+    return PlatformDirs().user_pictures_dir
+
+
+def user_videos_dir() -> str:
+    """:returns: videos directory tied to the user"""
+    return PlatformDirs().user_videos_dir
+
+
+def user_music_dir() -> str:
+    """:returns: music directory tied to the user"""
+    return PlatformDirs().user_music_dir
+
+
+def user_desktop_dir() -> str:
+    """:returns: desktop directory tied to the user"""
+    return PlatformDirs().user_desktop_dir
+
+
+def user_runtime_dir(
+    appname: str | None = None,
+    appauthor: str | None | Literal[False] = None,
+    version: str | None = None,
+    opinion: bool = True,  # noqa: FBT001, FBT002
+    ensure_exists: bool = False,  # noqa: FBT001, FBT002
+) -> str:
+    """
+    :param appname: See `appname `.
+    :param appauthor: See `appauthor `.
+    :param version: See `version `.
+    :param opinion: See `opinion `.
+    :param ensure_exists: See `ensure_exists `.
+    :returns: runtime directory tied to the user
+    """
+    return PlatformDirs(
+        appname=appname,
+        appauthor=appauthor,
+        version=version,
+        opinion=opinion,
+        ensure_exists=ensure_exists,
+    ).user_runtime_dir
+
+
+def site_runtime_dir(
+    appname: str | None = None,
+    appauthor: str | None | Literal[False] = None,
+    version: str | None = None,
+    opinion: bool = True,  # noqa: FBT001, FBT002
+    ensure_exists: bool = False,  # noqa: FBT001, FBT002
+) -> str:
+    """
+    :param appname: See `appname `.
+    :param appauthor: See `appauthor `.
+    :param version: See `version `.
+    :param opinion: See `opinion `.
+    :param ensure_exists: See `ensure_exists `.
+    :returns: runtime directory shared by users
+    """
+    return PlatformDirs(
+        appname=appname,
+        appauthor=appauthor,
+        version=version,
+        opinion=opinion,
+        ensure_exists=ensure_exists,
+    ).site_runtime_dir
+
+
+def user_data_path(
+    appname: str | None = None,
+    appauthor: str | None | Literal[False] = None,
+    version: str | None = None,
+    roaming: bool = False,  # noqa: FBT001, FBT002
+    ensure_exists: bool = False,  # noqa: FBT001, FBT002
+) -> Path:
+    """
+    :param appname: See `appname `.
+    :param appauthor: See `appauthor `.
+    :param version: See `version `.
+    :param roaming: See `roaming `.
+    :param ensure_exists: See `ensure_exists `.
+    :returns: data path tied to the user
+    """
+    return PlatformDirs(
+        appname=appname,
+        appauthor=appauthor,
+        version=version,
+        roaming=roaming,
+        ensure_exists=ensure_exists,
+    ).user_data_path
+
+
+def site_data_path(
+    appname: str | None = None,
+    appauthor: str | None | Literal[False] = None,
+    version: str | None = None,
+    multipath: bool = False,  # noqa: FBT001, FBT002
+    ensure_exists: bool = False,  # noqa: FBT001, FBT002
+) -> Path:
+    """
+    :param appname: See `appname `.
+    :param appauthor: See `appauthor `.
+    :param version: See `version `.
+    :param multipath: See `multipath `.
+    :param ensure_exists: See `ensure_exists `.
+    :returns: data path shared by users
+    """
+    return PlatformDirs(
+        appname=appname,
+        appauthor=appauthor,
+        version=version,
+        multipath=multipath,
+        ensure_exists=ensure_exists,
+    ).site_data_path
+
+
+def user_config_path(
+    appname: str | None = None,
+    appauthor: str | None | Literal[False] = None,
+    version: str | None = None,
+    roaming: bool = False,  # noqa: FBT001, FBT002
+    ensure_exists: bool = False,  # noqa: FBT001, FBT002
+) -> Path:
+    """
+    :param appname: See `appname `.
+    :param appauthor: See `appauthor `.
+    :param version: See `version `.
+    :param roaming: See `roaming `.
+    :param ensure_exists: See `ensure_exists `.
+    :returns: config path tied to the user
+    """
+    return PlatformDirs(
+        appname=appname,
+        appauthor=appauthor,
+        version=version,
+        roaming=roaming,
+        ensure_exists=ensure_exists,
+    ).user_config_path
+
+
+def site_config_path(
+    appname: str | None = None,
+    appauthor: str | None | Literal[False] = None,
+    version: str | None = None,
+    multipath: bool = False,  # noqa: FBT001, FBT002
+    ensure_exists: bool = False,  # noqa: FBT001, FBT002
+) -> Path:
+    """
+    :param appname: See `appname `.
+    :param appauthor: See `appauthor `.
+    :param version: See `version `.
+    :param multipath: See `roaming `.
+    :param ensure_exists: See `ensure_exists `.
+    :returns: config path shared by the users
+    """
+    return PlatformDirs(
+        appname=appname,
+        appauthor=appauthor,
+        version=version,
+        multipath=multipath,
+        ensure_exists=ensure_exists,
+    ).site_config_path
+
+
+def site_cache_path(
+    appname: str | None = None,
+    appauthor: str | None | Literal[False] = None,
+    version: str | None = None,
+    opinion: bool = True,  # noqa: FBT001, FBT002
+    ensure_exists: bool = False,  # noqa: FBT001, FBT002
+) -> Path:
+    """
+    :param appname: See `appname `.
+    :param appauthor: See `appauthor `.
+    :param version: See `version `.
+    :param opinion: See `opinion `.
+    :param ensure_exists: See `ensure_exists `.
+    :returns: cache directory tied to the user
+    """
+    return PlatformDirs(
+        appname=appname,
+        appauthor=appauthor,
+        version=version,
+        opinion=opinion,
+        ensure_exists=ensure_exists,
+    ).site_cache_path
+
+
+def user_cache_path(
+    appname: str | None = None,
+    appauthor: str | None | Literal[False] = None,
+    version: str | None = None,
+    opinion: bool = True,  # noqa: FBT001, FBT002
+    ensure_exists: bool = False,  # noqa: FBT001, FBT002
+) -> Path:
+    """
+    :param appname: See `appname `.
+    :param appauthor: See `appauthor `.
+    :param version: See `version `.
+    :param opinion: See `roaming `.
+    :param ensure_exists: See `ensure_exists `.
+    :returns: cache path tied to the user
+    """
+    return PlatformDirs(
+        appname=appname,
+        appauthor=appauthor,
+        version=version,
+        opinion=opinion,
+        ensure_exists=ensure_exists,
+    ).user_cache_path
+
+
+def user_state_path(
+    appname: str | None = None,
+    appauthor: str | None | Literal[False] = None,
+    version: str | None = None,
+    roaming: bool = False,  # noqa: FBT001, FBT002
+    ensure_exists: bool = False,  # noqa: FBT001, FBT002
+) -> Path:
+    """
+    :param appname: See `appname `.
+    :param appauthor: See `appauthor `.
+    :param version: See `version `.
+    :param roaming: See `roaming `.
+    :param ensure_exists: See `ensure_exists `.
+    :returns: state path tied to the user
+    """
+    return PlatformDirs(
+        appname=appname,
+        appauthor=appauthor,
+        version=version,
+        roaming=roaming,
+        ensure_exists=ensure_exists,
+    ).user_state_path
+
+
+def user_log_path(
+    appname: str | None = None,
+    appauthor: str | None | Literal[False] = None,
+    version: str | None = None,
+    opinion: bool = True,  # noqa: FBT001, FBT002
+    ensure_exists: bool = False,  # noqa: FBT001, FBT002
+) -> Path:
+    """
+    :param appname: See `appname `.
+    :param appauthor: See `appauthor `.
+    :param version: See `version `.
+    :param opinion: See `roaming `.
+    :param ensure_exists: See `ensure_exists `.
+    :returns: log path tied to the user
+    """
+    return PlatformDirs(
+        appname=appname,
+        appauthor=appauthor,
+        version=version,
+        opinion=opinion,
+        ensure_exists=ensure_exists,
+    ).user_log_path
+
+
+def user_documents_path() -> Path:
+    """:returns: documents a path tied to the user"""
+    return PlatformDirs().user_documents_path
+
+
+def user_downloads_path() -> Path:
+    """:returns: downloads path tied to the user"""
+    return PlatformDirs().user_downloads_path
+
+
+def user_pictures_path() -> Path:
+    """:returns: pictures path tied to the user"""
+    return PlatformDirs().user_pictures_path
+
+
+def user_videos_path() -> Path:
+    """:returns: videos path tied to the user"""
+    return PlatformDirs().user_videos_path
+
+
+def user_music_path() -> Path:
+    """:returns: music path tied to the user"""
+    return PlatformDirs().user_music_path
+
+
+def user_desktop_path() -> Path:
+    """:returns: desktop path tied to the user"""
+    return PlatformDirs().user_desktop_path
+
+
+def user_runtime_path(
+    appname: str | None = None,
+    appauthor: str | None | Literal[False] = None,
+    version: str | None = None,
+    opinion: bool = True,  # noqa: FBT001, FBT002
+    ensure_exists: bool = False,  # noqa: FBT001, FBT002
+) -> Path:
+    """
+    :param appname: See `appname `.
+    :param appauthor: See `appauthor `.
+    :param version: See `version `.
+    :param opinion: See `opinion `.
+    :param ensure_exists: See `ensure_exists `.
+    :returns: runtime path tied to the user
+    """
+    return PlatformDirs(
+        appname=appname,
+        appauthor=appauthor,
+        version=version,
+        opinion=opinion,
+        ensure_exists=ensure_exists,
+    ).user_runtime_path
+
+
+def site_runtime_path(
+    appname: str | None = None,
+    appauthor: str | None | Literal[False] = None,
+    version: str | None = None,
+    opinion: bool = True,  # noqa: FBT001, FBT002
+    ensure_exists: bool = False,  # noqa: FBT001, FBT002
+) -> Path:
+    """
+    :param appname: See `appname `.
+    :param appauthor: See `appauthor `.
+    :param version: See `version `.
+    :param opinion: See `opinion `.
+    :param ensure_exists: See `ensure_exists `.
+    :returns: runtime path shared by users
+    """
+    return PlatformDirs(
+        appname=appname,
+        appauthor=appauthor,
+        version=version,
+        opinion=opinion,
+        ensure_exists=ensure_exists,
+    ).site_runtime_path
+
+
+__all__ = [
+    "AppDirs",
+    "PlatformDirs",
+    "PlatformDirsABC",
+    "__version__",
+    "__version_info__",
+    "site_cache_dir",
+    "site_cache_path",
+    "site_config_dir",
+    "site_config_path",
+    "site_data_dir",
+    "site_data_path",
+    "site_runtime_dir",
+    "site_runtime_path",
+    "user_cache_dir",
+    "user_cache_path",
+    "user_config_dir",
+    "user_config_path",
+    "user_data_dir",
+    "user_data_path",
+    "user_desktop_dir",
+    "user_desktop_path",
+    "user_documents_dir",
+    "user_documents_path",
+    "user_downloads_dir",
+    "user_downloads_path",
+    "user_log_dir",
+    "user_log_path",
+    "user_music_dir",
+    "user_music_path",
+    "user_pictures_dir",
+    "user_pictures_path",
+    "user_runtime_dir",
+    "user_runtime_path",
+    "user_state_dir",
+    "user_state_path",
+    "user_videos_dir",
+    "user_videos_path",
+]
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/platformdirs/__main__.py b/venv/lib/python3.12/site-packages/pip/_vendor/platformdirs/__main__.py
new file mode 100644
index 00000000..fa8a677a
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_vendor/platformdirs/__main__.py
@@ -0,0 +1,55 @@
+"""Main entry point."""
+
+from __future__ import annotations
+
+from pip._vendor.platformdirs import PlatformDirs, __version__
+
+PROPS = (
+    "user_data_dir",
+    "user_config_dir",
+    "user_cache_dir",
+    "user_state_dir",
+    "user_log_dir",
+    "user_documents_dir",
+    "user_downloads_dir",
+    "user_pictures_dir",
+    "user_videos_dir",
+    "user_music_dir",
+    "user_runtime_dir",
+    "site_data_dir",
+    "site_config_dir",
+    "site_cache_dir",
+    "site_runtime_dir",
+)
+
+
+def main() -> None:
+    """Run the main entry point."""
+    app_name = "MyApp"
+    app_author = "MyCompany"
+
+    print(f"-- platformdirs {__version__} --")  # noqa: T201
+
+    print("-- app dirs (with optional 'version')")  # noqa: T201
+    dirs = PlatformDirs(app_name, app_author, version="1.0")
+    for prop in PROPS:
+        print(f"{prop}: {getattr(dirs, prop)}")  # noqa: T201
+
+    print("\n-- app dirs (without optional 'version')")  # noqa: T201
+    dirs = PlatformDirs(app_name, app_author)
+    for prop in PROPS:
+        print(f"{prop}: {getattr(dirs, prop)}")  # noqa: T201
+
+    print("\n-- app dirs (without optional 'appauthor')")  # noqa: T201
+    dirs = PlatformDirs(app_name)
+    for prop in PROPS:
+        print(f"{prop}: {getattr(dirs, prop)}")  # noqa: T201
+
+    print("\n-- app dirs (with disabled 'appauthor')")  # noqa: T201
+    dirs = PlatformDirs(app_name, appauthor=False)
+    for prop in PROPS:
+        print(f"{prop}: {getattr(dirs, prop)}")  # noqa: T201
+
+
+if __name__ == "__main__":
+    main()
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/platformdirs/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_vendor/platformdirs/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 00000000..2a27d4e3
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_vendor/platformdirs/__pycache__/__init__.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/platformdirs/__pycache__/__main__.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_vendor/platformdirs/__pycache__/__main__.cpython-312.pyc
new file mode 100644
index 00000000..6b9f5ef6
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_vendor/platformdirs/__pycache__/__main__.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/platformdirs/__pycache__/android.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_vendor/platformdirs/__pycache__/android.cpython-312.pyc
new file mode 100644
index 00000000..173bcd01
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_vendor/platformdirs/__pycache__/android.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/platformdirs/__pycache__/api.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_vendor/platformdirs/__pycache__/api.cpython-312.pyc
new file mode 100644
index 00000000..1b9bbd19
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_vendor/platformdirs/__pycache__/api.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/platformdirs/__pycache__/macos.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_vendor/platformdirs/__pycache__/macos.cpython-312.pyc
new file mode 100644
index 00000000..f70e9200
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_vendor/platformdirs/__pycache__/macos.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/platformdirs/__pycache__/unix.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_vendor/platformdirs/__pycache__/unix.cpython-312.pyc
new file mode 100644
index 00000000..9df7d01b
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_vendor/platformdirs/__pycache__/unix.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/platformdirs/__pycache__/version.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_vendor/platformdirs/__pycache__/version.cpython-312.pyc
new file mode 100644
index 00000000..ca5155da
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_vendor/platformdirs/__pycache__/version.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/platformdirs/__pycache__/windows.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_vendor/platformdirs/__pycache__/windows.cpython-312.pyc
new file mode 100644
index 00000000..249a1af3
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_vendor/platformdirs/__pycache__/windows.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/platformdirs/android.py b/venv/lib/python3.12/site-packages/pip/_vendor/platformdirs/android.py
new file mode 100644
index 00000000..afd3141c
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_vendor/platformdirs/android.py
@@ -0,0 +1,249 @@
+"""Android."""
+
+from __future__ import annotations
+
+import os
+import re
+import sys
+from functools import lru_cache
+from typing import TYPE_CHECKING, cast
+
+from .api import PlatformDirsABC
+
+
+class Android(PlatformDirsABC):
+    """
+    Follows the guidance `from here `_.
+
+    Makes use of the `appname `, `version
+    `, `ensure_exists `.
+
+    """
+
+    @property
+    def user_data_dir(self) -> str:
+        """:return: data directory tied to the user, e.g. ``/data/user///files/``"""
+        return self._append_app_name_and_version(cast(str, _android_folder()), "files")
+
+    @property
+    def site_data_dir(self) -> str:
+        """:return: data directory shared by users, same as `user_data_dir`"""
+        return self.user_data_dir
+
+    @property
+    def user_config_dir(self) -> str:
+        """
+        :return: config directory tied to the user, e.g. \
+        ``/data/user///shared_prefs/``
+        """
+        return self._append_app_name_and_version(cast(str, _android_folder()), "shared_prefs")
+
+    @property
+    def site_config_dir(self) -> str:
+        """:return: config directory shared by the users, same as `user_config_dir`"""
+        return self.user_config_dir
+
+    @property
+    def user_cache_dir(self) -> str:
+        """:return: cache directory tied to the user, e.g.,``/data/user///cache/``"""
+        return self._append_app_name_and_version(cast(str, _android_folder()), "cache")
+
+    @property
+    def site_cache_dir(self) -> str:
+        """:return: cache directory shared by users, same as `user_cache_dir`"""
+        return self.user_cache_dir
+
+    @property
+    def user_state_dir(self) -> str:
+        """:return: state directory tied to the user, same as `user_data_dir`"""
+        return self.user_data_dir
+
+    @property
+    def user_log_dir(self) -> str:
+        """
+        :return: log directory tied to the user, same as `user_cache_dir` if not opinionated else ``log`` in it,
+          e.g. ``/data/user///cache//log``
+        """
+        path = self.user_cache_dir
+        if self.opinion:
+            path = os.path.join(path, "log")  # noqa: PTH118
+        return path
+
+    @property
+    def user_documents_dir(self) -> str:
+        """:return: documents directory tied to the user e.g. ``/storage/emulated/0/Documents``"""
+        return _android_documents_folder()
+
+    @property
+    def user_downloads_dir(self) -> str:
+        """:return: downloads directory tied to the user e.g. ``/storage/emulated/0/Downloads``"""
+        return _android_downloads_folder()
+
+    @property
+    def user_pictures_dir(self) -> str:
+        """:return: pictures directory tied to the user e.g. ``/storage/emulated/0/Pictures``"""
+        return _android_pictures_folder()
+
+    @property
+    def user_videos_dir(self) -> str:
+        """:return: videos directory tied to the user e.g. ``/storage/emulated/0/DCIM/Camera``"""
+        return _android_videos_folder()
+
+    @property
+    def user_music_dir(self) -> str:
+        """:return: music directory tied to the user e.g. ``/storage/emulated/0/Music``"""
+        return _android_music_folder()
+
+    @property
+    def user_desktop_dir(self) -> str:
+        """:return: desktop directory tied to the user e.g. ``/storage/emulated/0/Desktop``"""
+        return "/storage/emulated/0/Desktop"
+
+    @property
+    def user_runtime_dir(self) -> str:
+        """
+        :return: runtime directory tied to the user, same as `user_cache_dir` if not opinionated else ``tmp`` in it,
+          e.g. ``/data/user///cache//tmp``
+        """
+        path = self.user_cache_dir
+        if self.opinion:
+            path = os.path.join(path, "tmp")  # noqa: PTH118
+        return path
+
+    @property
+    def site_runtime_dir(self) -> str:
+        """:return: runtime directory shared by users, same as `user_runtime_dir`"""
+        return self.user_runtime_dir
+
+
+@lru_cache(maxsize=1)
+def _android_folder() -> str | None:  # noqa: C901, PLR0912
+    """:return: base folder for the Android OS or None if it cannot be found"""
+    result: str | None = None
+    # type checker isn't happy with our "import android", just don't do this when type checking see
+    # https://stackoverflow.com/a/61394121
+    if not TYPE_CHECKING:
+        try:
+            # First try to get a path to android app using python4android (if available)...
+            from android import mActivity  # noqa: PLC0415
+
+            context = cast("android.content.Context", mActivity.getApplicationContext())  # noqa: F821
+            result = context.getFilesDir().getParentFile().getAbsolutePath()
+        except Exception:  # noqa: BLE001
+            result = None
+    if result is None:
+        try:
+            # ...and fall back to using plain pyjnius, if python4android isn't available or doesn't deliver any useful
+            # result...
+            from jnius import autoclass  # noqa: PLC0415
+
+            context = autoclass("android.content.Context")
+            result = context.getFilesDir().getParentFile().getAbsolutePath()
+        except Exception:  # noqa: BLE001
+            result = None
+    if result is None:
+        # and if that fails, too, find an android folder looking at path on the sys.path
+        # warning: only works for apps installed under /data, not adopted storage etc.
+        pattern = re.compile(r"/data/(data|user/\d+)/(.+)/files")
+        for path in sys.path:
+            if pattern.match(path):
+                result = path.split("/files")[0]
+                break
+        else:
+            result = None
+    if result is None:
+        # one last try: find an android folder looking at path on the sys.path taking adopted storage paths into
+        # account
+        pattern = re.compile(r"/mnt/expand/[a-fA-F0-9-]{36}/(data|user/\d+)/(.+)/files")
+        for path in sys.path:
+            if pattern.match(path):
+                result = path.split("/files")[0]
+                break
+        else:
+            result = None
+    return result
+
+
+@lru_cache(maxsize=1)
+def _android_documents_folder() -> str:
+    """:return: documents folder for the Android OS"""
+    # Get directories with pyjnius
+    try:
+        from jnius import autoclass  # noqa: PLC0415
+
+        context = autoclass("android.content.Context")
+        environment = autoclass("android.os.Environment")
+        documents_dir: str = context.getExternalFilesDir(environment.DIRECTORY_DOCUMENTS).getAbsolutePath()
+    except Exception:  # noqa: BLE001
+        documents_dir = "/storage/emulated/0/Documents"
+
+    return documents_dir
+
+
+@lru_cache(maxsize=1)
+def _android_downloads_folder() -> str:
+    """:return: downloads folder for the Android OS"""
+    # Get directories with pyjnius
+    try:
+        from jnius import autoclass  # noqa: PLC0415
+
+        context = autoclass("android.content.Context")
+        environment = autoclass("android.os.Environment")
+        downloads_dir: str = context.getExternalFilesDir(environment.DIRECTORY_DOWNLOADS).getAbsolutePath()
+    except Exception:  # noqa: BLE001
+        downloads_dir = "/storage/emulated/0/Downloads"
+
+    return downloads_dir
+
+
+@lru_cache(maxsize=1)
+def _android_pictures_folder() -> str:
+    """:return: pictures folder for the Android OS"""
+    # Get directories with pyjnius
+    try:
+        from jnius import autoclass  # noqa: PLC0415
+
+        context = autoclass("android.content.Context")
+        environment = autoclass("android.os.Environment")
+        pictures_dir: str = context.getExternalFilesDir(environment.DIRECTORY_PICTURES).getAbsolutePath()
+    except Exception:  # noqa: BLE001
+        pictures_dir = "/storage/emulated/0/Pictures"
+
+    return pictures_dir
+
+
+@lru_cache(maxsize=1)
+def _android_videos_folder() -> str:
+    """:return: videos folder for the Android OS"""
+    # Get directories with pyjnius
+    try:
+        from jnius import autoclass  # noqa: PLC0415
+
+        context = autoclass("android.content.Context")
+        environment = autoclass("android.os.Environment")
+        videos_dir: str = context.getExternalFilesDir(environment.DIRECTORY_DCIM).getAbsolutePath()
+    except Exception:  # noqa: BLE001
+        videos_dir = "/storage/emulated/0/DCIM/Camera"
+
+    return videos_dir
+
+
+@lru_cache(maxsize=1)
+def _android_music_folder() -> str:
+    """:return: music folder for the Android OS"""
+    # Get directories with pyjnius
+    try:
+        from jnius import autoclass  # noqa: PLC0415
+
+        context = autoclass("android.content.Context")
+        environment = autoclass("android.os.Environment")
+        music_dir: str = context.getExternalFilesDir(environment.DIRECTORY_MUSIC).getAbsolutePath()
+    except Exception:  # noqa: BLE001
+        music_dir = "/storage/emulated/0/Music"
+
+    return music_dir
+
+
+__all__ = [
+    "Android",
+]
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/platformdirs/api.py b/venv/lib/python3.12/site-packages/pip/_vendor/platformdirs/api.py
new file mode 100644
index 00000000..c50caa64
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_vendor/platformdirs/api.py
@@ -0,0 +1,292 @@
+"""Base API."""
+
+from __future__ import annotations
+
+import os
+from abc import ABC, abstractmethod
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from typing import Iterator, Literal
+
+
+class PlatformDirsABC(ABC):  # noqa: PLR0904
+    """Abstract base class for platform directories."""
+
+    def __init__(  # noqa: PLR0913, PLR0917
+        self,
+        appname: str | None = None,
+        appauthor: str | None | Literal[False] = None,
+        version: str | None = None,
+        roaming: bool = False,  # noqa: FBT001, FBT002
+        multipath: bool = False,  # noqa: FBT001, FBT002
+        opinion: bool = True,  # noqa: FBT001, FBT002
+        ensure_exists: bool = False,  # noqa: FBT001, FBT002
+    ) -> None:
+        """
+        Create a new platform directory.
+
+        :param appname: See `appname`.
+        :param appauthor: See `appauthor`.
+        :param version: See `version`.
+        :param roaming: See `roaming`.
+        :param multipath: See `multipath`.
+        :param opinion: See `opinion`.
+        :param ensure_exists: See `ensure_exists`.
+
+        """
+        self.appname = appname  #: The name of application.
+        self.appauthor = appauthor
+        """
+        The name of the app author or distributing body for this application.
+
+        Typically, it is the owning company name. Defaults to `appname`. You may pass ``False`` to disable it.
+
+        """
+        self.version = version
+        """
+        An optional version path element to append to the path.
+
+        You might want to use this if you want multiple versions of your app to be able to run independently. If used,
+        this would typically be ``.``.
+
+        """
+        self.roaming = roaming
+        """
+        Whether to use the roaming appdata directory on Windows.
+
+        That means that for users on a Windows network setup for roaming profiles, this user data will be synced on
+        login (see
+        `here `_).
+
+        """
+        self.multipath = multipath
+        """
+        An optional parameter which indicates that the entire list of data dirs should be returned.
+
+        By default, the first item would only be returned.
+
+        """
+        self.opinion = opinion  #: A flag to indicating to use opinionated values.
+        self.ensure_exists = ensure_exists
+        """
+        Optionally create the directory (and any missing parents) upon access if it does not exist.
+
+        By default, no directories are created.
+
+        """
+
+    def _append_app_name_and_version(self, *base: str) -> str:
+        params = list(base[1:])
+        if self.appname:
+            params.append(self.appname)
+            if self.version:
+                params.append(self.version)
+        path = os.path.join(base[0], *params)  # noqa: PTH118
+        self._optionally_create_directory(path)
+        return path
+
+    def _optionally_create_directory(self, path: str) -> None:
+        if self.ensure_exists:
+            Path(path).mkdir(parents=True, exist_ok=True)
+
+    @property
+    @abstractmethod
+    def user_data_dir(self) -> str:
+        """:return: data directory tied to the user"""
+
+    @property
+    @abstractmethod
+    def site_data_dir(self) -> str:
+        """:return: data directory shared by users"""
+
+    @property
+    @abstractmethod
+    def user_config_dir(self) -> str:
+        """:return: config directory tied to the user"""
+
+    @property
+    @abstractmethod
+    def site_config_dir(self) -> str:
+        """:return: config directory shared by the users"""
+
+    @property
+    @abstractmethod
+    def user_cache_dir(self) -> str:
+        """:return: cache directory tied to the user"""
+
+    @property
+    @abstractmethod
+    def site_cache_dir(self) -> str:
+        """:return: cache directory shared by users"""
+
+    @property
+    @abstractmethod
+    def user_state_dir(self) -> str:
+        """:return: state directory tied to the user"""
+
+    @property
+    @abstractmethod
+    def user_log_dir(self) -> str:
+        """:return: log directory tied to the user"""
+
+    @property
+    @abstractmethod
+    def user_documents_dir(self) -> str:
+        """:return: documents directory tied to the user"""
+
+    @property
+    @abstractmethod
+    def user_downloads_dir(self) -> str:
+        """:return: downloads directory tied to the user"""
+
+    @property
+    @abstractmethod
+    def user_pictures_dir(self) -> str:
+        """:return: pictures directory tied to the user"""
+
+    @property
+    @abstractmethod
+    def user_videos_dir(self) -> str:
+        """:return: videos directory tied to the user"""
+
+    @property
+    @abstractmethod
+    def user_music_dir(self) -> str:
+        """:return: music directory tied to the user"""
+
+    @property
+    @abstractmethod
+    def user_desktop_dir(self) -> str:
+        """:return: desktop directory tied to the user"""
+
+    @property
+    @abstractmethod
+    def user_runtime_dir(self) -> str:
+        """:return: runtime directory tied to the user"""
+
+    @property
+    @abstractmethod
+    def site_runtime_dir(self) -> str:
+        """:return: runtime directory shared by users"""
+
+    @property
+    def user_data_path(self) -> Path:
+        """:return: data path tied to the user"""
+        return Path(self.user_data_dir)
+
+    @property
+    def site_data_path(self) -> Path:
+        """:return: data path shared by users"""
+        return Path(self.site_data_dir)
+
+    @property
+    def user_config_path(self) -> Path:
+        """:return: config path tied to the user"""
+        return Path(self.user_config_dir)
+
+    @property
+    def site_config_path(self) -> Path:
+        """:return: config path shared by the users"""
+        return Path(self.site_config_dir)
+
+    @property
+    def user_cache_path(self) -> Path:
+        """:return: cache path tied to the user"""
+        return Path(self.user_cache_dir)
+
+    @property
+    def site_cache_path(self) -> Path:
+        """:return: cache path shared by users"""
+        return Path(self.site_cache_dir)
+
+    @property
+    def user_state_path(self) -> Path:
+        """:return: state path tied to the user"""
+        return Path(self.user_state_dir)
+
+    @property
+    def user_log_path(self) -> Path:
+        """:return: log path tied to the user"""
+        return Path(self.user_log_dir)
+
+    @property
+    def user_documents_path(self) -> Path:
+        """:return: documents a path tied to the user"""
+        return Path(self.user_documents_dir)
+
+    @property
+    def user_downloads_path(self) -> Path:
+        """:return: downloads path tied to the user"""
+        return Path(self.user_downloads_dir)
+
+    @property
+    def user_pictures_path(self) -> Path:
+        """:return: pictures path tied to the user"""
+        return Path(self.user_pictures_dir)
+
+    @property
+    def user_videos_path(self) -> Path:
+        """:return: videos path tied to the user"""
+        return Path(self.user_videos_dir)
+
+    @property
+    def user_music_path(self) -> Path:
+        """:return: music path tied to the user"""
+        return Path(self.user_music_dir)
+
+    @property
+    def user_desktop_path(self) -> Path:
+        """:return: desktop path tied to the user"""
+        return Path(self.user_desktop_dir)
+
+    @property
+    def user_runtime_path(self) -> Path:
+        """:return: runtime path tied to the user"""
+        return Path(self.user_runtime_dir)
+
+    @property
+    def site_runtime_path(self) -> Path:
+        """:return: runtime path shared by users"""
+        return Path(self.site_runtime_dir)
+
+    def iter_config_dirs(self) -> Iterator[str]:
+        """:yield: all user and site configuration directories."""
+        yield self.user_config_dir
+        yield self.site_config_dir
+
+    def iter_data_dirs(self) -> Iterator[str]:
+        """:yield: all user and site data directories."""
+        yield self.user_data_dir
+        yield self.site_data_dir
+
+    def iter_cache_dirs(self) -> Iterator[str]:
+        """:yield: all user and site cache directories."""
+        yield self.user_cache_dir
+        yield self.site_cache_dir
+
+    def iter_runtime_dirs(self) -> Iterator[str]:
+        """:yield: all user and site runtime directories."""
+        yield self.user_runtime_dir
+        yield self.site_runtime_dir
+
+    def iter_config_paths(self) -> Iterator[Path]:
+        """:yield: all user and site configuration paths."""
+        for path in self.iter_config_dirs():
+            yield Path(path)
+
+    def iter_data_paths(self) -> Iterator[Path]:
+        """:yield: all user and site data paths."""
+        for path in self.iter_data_dirs():
+            yield Path(path)
+
+    def iter_cache_paths(self) -> Iterator[Path]:
+        """:yield: all user and site cache paths."""
+        for path in self.iter_cache_dirs():
+            yield Path(path)
+
+    def iter_runtime_paths(self) -> Iterator[Path]:
+        """:yield: all user and site runtime paths."""
+        for path in self.iter_runtime_dirs():
+            yield Path(path)
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/platformdirs/macos.py b/venv/lib/python3.12/site-packages/pip/_vendor/platformdirs/macos.py
new file mode 100644
index 00000000..eb1ba5df
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_vendor/platformdirs/macos.py
@@ -0,0 +1,130 @@
+"""macOS."""
+
+from __future__ import annotations
+
+import os.path
+import sys
+
+from .api import PlatformDirsABC
+
+
+class MacOS(PlatformDirsABC):
+    """
+    Platform directories for the macOS operating system.
+
+    Follows the guidance from
+    `Apple documentation `_.
+    Makes use of the `appname `,
+    `version `,
+    `ensure_exists `.
+
+    """
+
+    @property
+    def user_data_dir(self) -> str:
+        """:return: data directory tied to the user, e.g. ``~/Library/Application Support/$appname/$version``"""
+        return self._append_app_name_and_version(os.path.expanduser("~/Library/Application Support"))  # noqa: PTH111
+
+    @property
+    def site_data_dir(self) -> str:
+        """
+        :return: data directory shared by users, e.g. ``/Library/Application Support/$appname/$version``.
+          If we're using a Python binary managed by `Homebrew `_, the directory
+          will be under the Homebrew prefix, e.g. ``/opt/homebrew/share/$appname/$version``.
+          If `multipath ` is enabled, and we're in Homebrew,
+          the response is a multi-path string separated by ":", e.g.
+          ``/opt/homebrew/share/$appname/$version:/Library/Application Support/$appname/$version``
+        """
+        is_homebrew = sys.prefix.startswith("/opt/homebrew")
+        path_list = [self._append_app_name_and_version("/opt/homebrew/share")] if is_homebrew else []
+        path_list.append(self._append_app_name_and_version("/Library/Application Support"))
+        if self.multipath:
+            return os.pathsep.join(path_list)
+        return path_list[0]
+
+    @property
+    def user_config_dir(self) -> str:
+        """:return: config directory tied to the user, same as `user_data_dir`"""
+        return self.user_data_dir
+
+    @property
+    def site_config_dir(self) -> str:
+        """:return: config directory shared by the users, same as `site_data_dir`"""
+        return self.site_data_dir
+
+    @property
+    def user_cache_dir(self) -> str:
+        """:return: cache directory tied to the user, e.g. ``~/Library/Caches/$appname/$version``"""
+        return self._append_app_name_and_version(os.path.expanduser("~/Library/Caches"))  # noqa: PTH111
+
+    @property
+    def site_cache_dir(self) -> str:
+        """
+        :return: cache directory shared by users, e.g. ``/Library/Caches/$appname/$version``.
+          If we're using a Python binary managed by `Homebrew `_, the directory
+          will be under the Homebrew prefix, e.g. ``/opt/homebrew/var/cache/$appname/$version``.
+          If `multipath ` is enabled, and we're in Homebrew,
+          the response is a multi-path string separated by ":", e.g.
+          ``/opt/homebrew/var/cache/$appname/$version:/Library/Caches/$appname/$version``
+        """
+        is_homebrew = sys.prefix.startswith("/opt/homebrew")
+        path_list = [self._append_app_name_and_version("/opt/homebrew/var/cache")] if is_homebrew else []
+        path_list.append(self._append_app_name_and_version("/Library/Caches"))
+        if self.multipath:
+            return os.pathsep.join(path_list)
+        return path_list[0]
+
+    @property
+    def user_state_dir(self) -> str:
+        """:return: state directory tied to the user, same as `user_data_dir`"""
+        return self.user_data_dir
+
+    @property
+    def user_log_dir(self) -> str:
+        """:return: log directory tied to the user, e.g. ``~/Library/Logs/$appname/$version``"""
+        return self._append_app_name_and_version(os.path.expanduser("~/Library/Logs"))  # noqa: PTH111
+
+    @property
+    def user_documents_dir(self) -> str:
+        """:return: documents directory tied to the user, e.g. ``~/Documents``"""
+        return os.path.expanduser("~/Documents")  # noqa: PTH111
+
+    @property
+    def user_downloads_dir(self) -> str:
+        """:return: downloads directory tied to the user, e.g. ``~/Downloads``"""
+        return os.path.expanduser("~/Downloads")  # noqa: PTH111
+
+    @property
+    def user_pictures_dir(self) -> str:
+        """:return: pictures directory tied to the user, e.g. ``~/Pictures``"""
+        return os.path.expanduser("~/Pictures")  # noqa: PTH111
+
+    @property
+    def user_videos_dir(self) -> str:
+        """:return: videos directory tied to the user, e.g. ``~/Movies``"""
+        return os.path.expanduser("~/Movies")  # noqa: PTH111
+
+    @property
+    def user_music_dir(self) -> str:
+        """:return: music directory tied to the user, e.g. ``~/Music``"""
+        return os.path.expanduser("~/Music")  # noqa: PTH111
+
+    @property
+    def user_desktop_dir(self) -> str:
+        """:return: desktop directory tied to the user, e.g. ``~/Desktop``"""
+        return os.path.expanduser("~/Desktop")  # noqa: PTH111
+
+    @property
+    def user_runtime_dir(self) -> str:
+        """:return: runtime directory tied to the user, e.g. ``~/Library/Caches/TemporaryItems/$appname/$version``"""
+        return self._append_app_name_and_version(os.path.expanduser("~/Library/Caches/TemporaryItems"))  # noqa: PTH111
+
+    @property
+    def site_runtime_dir(self) -> str:
+        """:return: runtime directory shared by users, same as `user_runtime_dir`"""
+        return self.user_runtime_dir
+
+
+__all__ = [
+    "MacOS",
+]
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/platformdirs/py.typed b/venv/lib/python3.12/site-packages/pip/_vendor/platformdirs/py.typed
new file mode 100644
index 00000000..e69de29b
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/platformdirs/unix.py b/venv/lib/python3.12/site-packages/pip/_vendor/platformdirs/unix.py
new file mode 100644
index 00000000..9500ade6
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_vendor/platformdirs/unix.py
@@ -0,0 +1,275 @@
+"""Unix."""
+
+from __future__ import annotations
+
+import os
+import sys
+from configparser import ConfigParser
+from pathlib import Path
+from typing import Iterator, NoReturn
+
+from .api import PlatformDirsABC
+
+if sys.platform == "win32":
+
+    def getuid() -> NoReturn:
+        msg = "should only be used on Unix"
+        raise RuntimeError(msg)
+
+else:
+    from os import getuid
+
+
+class Unix(PlatformDirsABC):  # noqa: PLR0904
+    """
+    On Unix/Linux, we follow the `XDG Basedir Spec `_.
+
+    The spec allows overriding directories with environment variables. The examples shown are the default values,
+    alongside the name of the environment variable that overrides them. Makes use of the `appname
+    `, `version `, `multipath
+    `, `opinion `, `ensure_exists
+    `.
+
+    """
+
+    @property
+    def user_data_dir(self) -> str:
+        """
+        :return: data directory tied to the user, e.g. ``~/.local/share/$appname/$version`` or
+         ``$XDG_DATA_HOME/$appname/$version``
+        """
+        path = os.environ.get("XDG_DATA_HOME", "")
+        if not path.strip():
+            path = os.path.expanduser("~/.local/share")  # noqa: PTH111
+        return self._append_app_name_and_version(path)
+
+    @property
+    def _site_data_dirs(self) -> list[str]:
+        path = os.environ.get("XDG_DATA_DIRS", "")
+        if not path.strip():
+            path = f"/usr/local/share{os.pathsep}/usr/share"
+        return [self._append_app_name_and_version(p) for p in path.split(os.pathsep)]
+
+    @property
+    def site_data_dir(self) -> str:
+        """
+        :return: data directories shared by users (if `multipath ` is
+         enabled and ``XDG_DATA_DIRS`` is set and a multi path the response is also a multi path separated by the
+         OS path separator), e.g. ``/usr/local/share/$appname/$version`` or ``/usr/share/$appname/$version``
+        """
+        # XDG default for $XDG_DATA_DIRS; only first, if multipath is False
+        dirs = self._site_data_dirs
+        if not self.multipath:
+            return dirs[0]
+        return os.pathsep.join(dirs)
+
+    @property
+    def user_config_dir(self) -> str:
+        """
+        :return: config directory tied to the user, e.g. ``~/.config/$appname/$version`` or
+         ``$XDG_CONFIG_HOME/$appname/$version``
+        """
+        path = os.environ.get("XDG_CONFIG_HOME", "")
+        if not path.strip():
+            path = os.path.expanduser("~/.config")  # noqa: PTH111
+        return self._append_app_name_and_version(path)
+
+    @property
+    def _site_config_dirs(self) -> list[str]:
+        path = os.environ.get("XDG_CONFIG_DIRS", "")
+        if not path.strip():
+            path = "/etc/xdg"
+        return [self._append_app_name_and_version(p) for p in path.split(os.pathsep)]
+
+    @property
+    def site_config_dir(self) -> str:
+        """
+        :return: config directories shared by users (if `multipath `
+         is enabled and ``XDG_CONFIG_DIRS`` is set and a multi path the response is also a multi path separated by
+         the OS path separator), e.g. ``/etc/xdg/$appname/$version``
+        """
+        # XDG default for $XDG_CONFIG_DIRS only first, if multipath is False
+        dirs = self._site_config_dirs
+        if not self.multipath:
+            return dirs[0]
+        return os.pathsep.join(dirs)
+
+    @property
+    def user_cache_dir(self) -> str:
+        """
+        :return: cache directory tied to the user, e.g. ``~/.cache/$appname/$version`` or
+         ``~/$XDG_CACHE_HOME/$appname/$version``
+        """
+        path = os.environ.get("XDG_CACHE_HOME", "")
+        if not path.strip():
+            path = os.path.expanduser("~/.cache")  # noqa: PTH111
+        return self._append_app_name_and_version(path)
+
+    @property
+    def site_cache_dir(self) -> str:
+        """:return: cache directory shared by users, e.g. ``/var/cache/$appname/$version``"""
+        return self._append_app_name_and_version("/var/cache")
+
+    @property
+    def user_state_dir(self) -> str:
+        """
+        :return: state directory tied to the user, e.g. ``~/.local/state/$appname/$version`` or
+         ``$XDG_STATE_HOME/$appname/$version``
+        """
+        path = os.environ.get("XDG_STATE_HOME", "")
+        if not path.strip():
+            path = os.path.expanduser("~/.local/state")  # noqa: PTH111
+        return self._append_app_name_and_version(path)
+
+    @property
+    def user_log_dir(self) -> str:
+        """:return: log directory tied to the user, same as `user_state_dir` if not opinionated else ``log`` in it"""
+        path = self.user_state_dir
+        if self.opinion:
+            path = os.path.join(path, "log")  # noqa: PTH118
+            self._optionally_create_directory(path)
+        return path
+
+    @property
+    def user_documents_dir(self) -> str:
+        """:return: documents directory tied to the user, e.g. ``~/Documents``"""
+        return _get_user_media_dir("XDG_DOCUMENTS_DIR", "~/Documents")
+
+    @property
+    def user_downloads_dir(self) -> str:
+        """:return: downloads directory tied to the user, e.g. ``~/Downloads``"""
+        return _get_user_media_dir("XDG_DOWNLOAD_DIR", "~/Downloads")
+
+    @property
+    def user_pictures_dir(self) -> str:
+        """:return: pictures directory tied to the user, e.g. ``~/Pictures``"""
+        return _get_user_media_dir("XDG_PICTURES_DIR", "~/Pictures")
+
+    @property
+    def user_videos_dir(self) -> str:
+        """:return: videos directory tied to the user, e.g. ``~/Videos``"""
+        return _get_user_media_dir("XDG_VIDEOS_DIR", "~/Videos")
+
+    @property
+    def user_music_dir(self) -> str:
+        """:return: music directory tied to the user, e.g. ``~/Music``"""
+        return _get_user_media_dir("XDG_MUSIC_DIR", "~/Music")
+
+    @property
+    def user_desktop_dir(self) -> str:
+        """:return: desktop directory tied to the user, e.g. ``~/Desktop``"""
+        return _get_user_media_dir("XDG_DESKTOP_DIR", "~/Desktop")
+
+    @property
+    def user_runtime_dir(self) -> str:
+        """
+        :return: runtime directory tied to the user, e.g. ``/run/user/$(id -u)/$appname/$version`` or
+         ``$XDG_RUNTIME_DIR/$appname/$version``.
+
+         For FreeBSD/OpenBSD/NetBSD, it would return ``/var/run/user/$(id -u)/$appname/$version`` if
+         exists, otherwise ``/tmp/runtime-$(id -u)/$appname/$version``, if``$XDG_RUNTIME_DIR``
+         is not set.
+        """
+        path = os.environ.get("XDG_RUNTIME_DIR", "")
+        if not path.strip():
+            if sys.platform.startswith(("freebsd", "openbsd", "netbsd")):
+                path = f"/var/run/user/{getuid()}"
+                if not Path(path).exists():
+                    path = f"/tmp/runtime-{getuid()}"  # noqa: S108
+            else:
+                path = f"/run/user/{getuid()}"
+        return self._append_app_name_and_version(path)
+
+    @property
+    def site_runtime_dir(self) -> str:
+        """
+        :return: runtime directory shared by users, e.g. ``/run/$appname/$version`` or \
+        ``$XDG_RUNTIME_DIR/$appname/$version``.
+
+        Note that this behaves almost exactly like `user_runtime_dir` if ``$XDG_RUNTIME_DIR`` is set, but will
+        fall back to paths associated to the root user instead of a regular logged-in user if it's not set.
+
+        If you wish to ensure that a logged-in root user path is returned e.g. ``/run/user/0``, use `user_runtime_dir`
+        instead.
+
+        For FreeBSD/OpenBSD/NetBSD, it would return ``/var/run/$appname/$version`` if ``$XDG_RUNTIME_DIR`` is not set.
+        """
+        path = os.environ.get("XDG_RUNTIME_DIR", "")
+        if not path.strip():
+            if sys.platform.startswith(("freebsd", "openbsd", "netbsd")):
+                path = "/var/run"
+            else:
+                path = "/run"
+        return self._append_app_name_and_version(path)
+
+    @property
+    def site_data_path(self) -> Path:
+        """:return: data path shared by users. Only return the first item, even if ``multipath`` is set to ``True``"""
+        return self._first_item_as_path_if_multipath(self.site_data_dir)
+
+    @property
+    def site_config_path(self) -> Path:
+        """:return: config path shared by the users, returns the first item, even if ``multipath`` is set to ``True``"""
+        return self._first_item_as_path_if_multipath(self.site_config_dir)
+
+    @property
+    def site_cache_path(self) -> Path:
+        """:return: cache path shared by users. Only return the first item, even if ``multipath`` is set to ``True``"""
+        return self._first_item_as_path_if_multipath(self.site_cache_dir)
+
+    def _first_item_as_path_if_multipath(self, directory: str) -> Path:
+        if self.multipath:
+            # If multipath is True, the first path is returned.
+            directory = directory.split(os.pathsep)[0]
+        return Path(directory)
+
+    def iter_config_dirs(self) -> Iterator[str]:
+        """:yield: all user and site configuration directories."""
+        yield self.user_config_dir
+        yield from self._site_config_dirs
+
+    def iter_data_dirs(self) -> Iterator[str]:
+        """:yield: all user and site data directories."""
+        yield self.user_data_dir
+        yield from self._site_data_dirs
+
+
+def _get_user_media_dir(env_var: str, fallback_tilde_path: str) -> str:
+    media_dir = _get_user_dirs_folder(env_var)
+    if media_dir is None:
+        media_dir = os.environ.get(env_var, "").strip()
+        if not media_dir:
+            media_dir = os.path.expanduser(fallback_tilde_path)  # noqa: PTH111
+
+    return media_dir
+
+
+def _get_user_dirs_folder(key: str) -> str | None:
+    """
+    Return directory from user-dirs.dirs config file.
+
+    See https://freedesktop.org/wiki/Software/xdg-user-dirs/.
+
+    """
+    user_dirs_config_path = Path(Unix().user_config_dir) / "user-dirs.dirs"
+    if user_dirs_config_path.exists():
+        parser = ConfigParser()
+
+        with user_dirs_config_path.open() as stream:
+            # Add fake section header, so ConfigParser doesn't complain
+            parser.read_string(f"[top]\n{stream.read()}")
+
+        if key not in parser["top"]:
+            return None
+
+        path = parser["top"][key].strip('"')
+        # Handle relative home paths
+        return path.replace("$HOME", os.path.expanduser("~"))  # noqa: PTH111
+
+    return None
+
+
+__all__ = [
+    "Unix",
+]
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/platformdirs/version.py b/venv/lib/python3.12/site-packages/pip/_vendor/platformdirs/version.py
new file mode 100644
index 00000000..6483ddce
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_vendor/platformdirs/version.py
@@ -0,0 +1,16 @@
+# file generated by setuptools_scm
+# don't change, don't track in version control
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple, Union
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+else:
+    VERSION_TUPLE = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+
+__version__ = version = '4.2.2'
+__version_tuple__ = version_tuple = (4, 2, 2)
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/platformdirs/windows.py b/venv/lib/python3.12/site-packages/pip/_vendor/platformdirs/windows.py
new file mode 100644
index 00000000..d7bc9609
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_vendor/platformdirs/windows.py
@@ -0,0 +1,272 @@
+"""Windows."""
+
+from __future__ import annotations
+
+import os
+import sys
+from functools import lru_cache
+from typing import TYPE_CHECKING
+
+from .api import PlatformDirsABC
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+
+class Windows(PlatformDirsABC):
+    """
+    `MSDN on where to store app data files `_.
+
+    Makes use of the `appname `, `appauthor
+    `, `version `, `roaming
+    `, `opinion `, `ensure_exists
+    `.
+
+    """
+
+    @property
+    def user_data_dir(self) -> str:
+        """
+        :return: data directory tied to the user, e.g.
+         ``%USERPROFILE%\\AppData\\Local\\$appauthor\\$appname`` (not roaming) or
+         ``%USERPROFILE%\\AppData\\Roaming\\$appauthor\\$appname`` (roaming)
+        """
+        const = "CSIDL_APPDATA" if self.roaming else "CSIDL_LOCAL_APPDATA"
+        path = os.path.normpath(get_win_folder(const))
+        return self._append_parts(path)
+
+    def _append_parts(self, path: str, *, opinion_value: str | None = None) -> str:
+        params = []
+        if self.appname:
+            if self.appauthor is not False:
+                author = self.appauthor or self.appname
+                params.append(author)
+            params.append(self.appname)
+            if opinion_value is not None and self.opinion:
+                params.append(opinion_value)
+            if self.version:
+                params.append(self.version)
+        path = os.path.join(path, *params)  # noqa: PTH118
+        self._optionally_create_directory(path)
+        return path
+
+    @property
+    def site_data_dir(self) -> str:
+        """:return: data directory shared by users, e.g. ``C:\\ProgramData\\$appauthor\\$appname``"""
+        path = os.path.normpath(get_win_folder("CSIDL_COMMON_APPDATA"))
+        return self._append_parts(path)
+
+    @property
+    def user_config_dir(self) -> str:
+        """:return: config directory tied to the user, same as `user_data_dir`"""
+        return self.user_data_dir
+
+    @property
+    def site_config_dir(self) -> str:
+        """:return: config directory shared by the users, same as `site_data_dir`"""
+        return self.site_data_dir
+
+    @property
+    def user_cache_dir(self) -> str:
+        """
+        :return: cache directory tied to the user (if opinionated with ``Cache`` folder within ``$appname``) e.g.
+         ``%USERPROFILE%\\AppData\\Local\\$appauthor\\$appname\\Cache\\$version``
+        """
+        path = os.path.normpath(get_win_folder("CSIDL_LOCAL_APPDATA"))
+        return self._append_parts(path, opinion_value="Cache")
+
+    @property
+    def site_cache_dir(self) -> str:
+        """:return: cache directory shared by users, e.g. ``C:\\ProgramData\\$appauthor\\$appname\\Cache\\$version``"""
+        path = os.path.normpath(get_win_folder("CSIDL_COMMON_APPDATA"))
+        return self._append_parts(path, opinion_value="Cache")
+
+    @property
+    def user_state_dir(self) -> str:
+        """:return: state directory tied to the user, same as `user_data_dir`"""
+        return self.user_data_dir
+
+    @property
+    def user_log_dir(self) -> str:
+        """:return: log directory tied to the user, same as `user_data_dir` if not opinionated else ``Logs`` in it"""
+        path = self.user_data_dir
+        if self.opinion:
+            path = os.path.join(path, "Logs")  # noqa: PTH118
+            self._optionally_create_directory(path)
+        return path
+
+    @property
+    def user_documents_dir(self) -> str:
+        """:return: documents directory tied to the user e.g. ``%USERPROFILE%\\Documents``"""
+        return os.path.normpath(get_win_folder("CSIDL_PERSONAL"))
+
+    @property
+    def user_downloads_dir(self) -> str:
+        """:return: downloads directory tied to the user e.g. ``%USERPROFILE%\\Downloads``"""
+        return os.path.normpath(get_win_folder("CSIDL_DOWNLOADS"))
+
+    @property
+    def user_pictures_dir(self) -> str:
+        """:return: pictures directory tied to the user e.g. ``%USERPROFILE%\\Pictures``"""
+        return os.path.normpath(get_win_folder("CSIDL_MYPICTURES"))
+
+    @property
+    def user_videos_dir(self) -> str:
+        """:return: videos directory tied to the user e.g. ``%USERPROFILE%\\Videos``"""
+        return os.path.normpath(get_win_folder("CSIDL_MYVIDEO"))
+
+    @property
+    def user_music_dir(self) -> str:
+        """:return: music directory tied to the user e.g. ``%USERPROFILE%\\Music``"""
+        return os.path.normpath(get_win_folder("CSIDL_MYMUSIC"))
+
+    @property
+    def user_desktop_dir(self) -> str:
+        """:return: desktop directory tied to the user, e.g. ``%USERPROFILE%\\Desktop``"""
+        return os.path.normpath(get_win_folder("CSIDL_DESKTOPDIRECTORY"))
+
+    @property
+    def user_runtime_dir(self) -> str:
+        """
+        :return: runtime directory tied to the user, e.g.
+         ``%USERPROFILE%\\AppData\\Local\\Temp\\$appauthor\\$appname``
+        """
+        path = os.path.normpath(os.path.join(get_win_folder("CSIDL_LOCAL_APPDATA"), "Temp"))  # noqa: PTH118
+        return self._append_parts(path)
+
+    @property
+    def site_runtime_dir(self) -> str:
+        """:return: runtime directory shared by users, same as `user_runtime_dir`"""
+        return self.user_runtime_dir
+
+
+def get_win_folder_from_env_vars(csidl_name: str) -> str:
+    """Get folder from environment variables."""
+    result = get_win_folder_if_csidl_name_not_env_var(csidl_name)
+    if result is not None:
+        return result
+
+    env_var_name = {
+        "CSIDL_APPDATA": "APPDATA",
+        "CSIDL_COMMON_APPDATA": "ALLUSERSPROFILE",
+        "CSIDL_LOCAL_APPDATA": "LOCALAPPDATA",
+    }.get(csidl_name)
+    if env_var_name is None:
+        msg = f"Unknown CSIDL name: {csidl_name}"
+        raise ValueError(msg)
+    result = os.environ.get(env_var_name)
+    if result is None:
+        msg = f"Unset environment variable: {env_var_name}"
+        raise ValueError(msg)
+    return result
+
+
+def get_win_folder_if_csidl_name_not_env_var(csidl_name: str) -> str | None:
+    """Get a folder for a CSIDL name that does not exist as an environment variable."""
+    if csidl_name == "CSIDL_PERSONAL":
+        return os.path.join(os.path.normpath(os.environ["USERPROFILE"]), "Documents")  # noqa: PTH118
+
+    if csidl_name == "CSIDL_DOWNLOADS":
+        return os.path.join(os.path.normpath(os.environ["USERPROFILE"]), "Downloads")  # noqa: PTH118
+
+    if csidl_name == "CSIDL_MYPICTURES":
+        return os.path.join(os.path.normpath(os.environ["USERPROFILE"]), "Pictures")  # noqa: PTH118
+
+    if csidl_name == "CSIDL_MYVIDEO":
+        return os.path.join(os.path.normpath(os.environ["USERPROFILE"]), "Videos")  # noqa: PTH118
+
+    if csidl_name == "CSIDL_MYMUSIC":
+        return os.path.join(os.path.normpath(os.environ["USERPROFILE"]), "Music")  # noqa: PTH118
+    return None
+
+
+def get_win_folder_from_registry(csidl_name: str) -> str:
+    """
+    Get folder from the registry.
+
+    This is a fallback technique at best. I'm not sure if using the registry for these guarantees us the correct answer
+    for all CSIDL_* names.
+
+    """
+    shell_folder_name = {
+        "CSIDL_APPDATA": "AppData",
+        "CSIDL_COMMON_APPDATA": "Common AppData",
+        "CSIDL_LOCAL_APPDATA": "Local AppData",
+        "CSIDL_PERSONAL": "Personal",
+        "CSIDL_DOWNLOADS": "{374DE290-123F-4565-9164-39C4925E467B}",
+        "CSIDL_MYPICTURES": "My Pictures",
+        "CSIDL_MYVIDEO": "My Video",
+        "CSIDL_MYMUSIC": "My Music",
+    }.get(csidl_name)
+    if shell_folder_name is None:
+        msg = f"Unknown CSIDL name: {csidl_name}"
+        raise ValueError(msg)
+    if sys.platform != "win32":  # only needed for mypy type checker to know that this code runs only on Windows
+        raise NotImplementedError
+    import winreg  # noqa: PLC0415
+
+    key = winreg.OpenKey(winreg.HKEY_CURRENT_USER, r"Software\Microsoft\Windows\CurrentVersion\Explorer\Shell Folders")
+    directory, _ = winreg.QueryValueEx(key, shell_folder_name)
+    return str(directory)
+
+
+def get_win_folder_via_ctypes(csidl_name: str) -> str:
+    """Get folder with ctypes."""
+    # There is no 'CSIDL_DOWNLOADS'.
+    # Use 'CSIDL_PROFILE' (40) and append the default folder 'Downloads' instead.
+    # https://learn.microsoft.com/en-us/windows/win32/shell/knownfolderid
+
+    import ctypes  # noqa: PLC0415
+
+    csidl_const = {
+        "CSIDL_APPDATA": 26,
+        "CSIDL_COMMON_APPDATA": 35,
+        "CSIDL_LOCAL_APPDATA": 28,
+        "CSIDL_PERSONAL": 5,
+        "CSIDL_MYPICTURES": 39,
+        "CSIDL_MYVIDEO": 14,
+        "CSIDL_MYMUSIC": 13,
+        "CSIDL_DOWNLOADS": 40,
+        "CSIDL_DESKTOPDIRECTORY": 16,
+    }.get(csidl_name)
+    if csidl_const is None:
+        msg = f"Unknown CSIDL name: {csidl_name}"
+        raise ValueError(msg)
+
+    buf = ctypes.create_unicode_buffer(1024)
+    windll = getattr(ctypes, "windll")  # noqa: B009 # using getattr to avoid false positive with mypy type checker
+    windll.shell32.SHGetFolderPathW(None, csidl_const, None, 0, buf)
+
+    # Downgrade to short path name if it has high-bit chars.
+    if any(ord(c) > 255 for c in buf):  # noqa: PLR2004
+        buf2 = ctypes.create_unicode_buffer(1024)
+        if windll.kernel32.GetShortPathNameW(buf.value, buf2, 1024):
+            buf = buf2
+
+    if csidl_name == "CSIDL_DOWNLOADS":
+        return os.path.join(buf.value, "Downloads")  # noqa: PTH118
+
+    return buf.value
+
+
+def _pick_get_win_folder() -> Callable[[str], str]:
+    try:
+        import ctypes  # noqa: PLC0415
+    except ImportError:
+        pass
+    else:
+        if hasattr(ctypes, "windll"):
+            return get_win_folder_via_ctypes
+    try:
+        import winreg  # noqa: PLC0415, F401
+    except ImportError:
+        return get_win_folder_from_env_vars
+    else:
+        return get_win_folder_from_registry
+
+
+get_win_folder = lru_cache(maxsize=None)(_pick_get_win_folder())
+
+__all__ = [
+    "Windows",
+]
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/pygments/__init__.py b/venv/lib/python3.12/site-packages/pip/_vendor/pygments/__init__.py
new file mode 100644
index 00000000..60ae9bb8
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_vendor/pygments/__init__.py
@@ -0,0 +1,82 @@
+"""
+    Pygments
+    ~~~~~~~~
+
+    Pygments is a syntax highlighting package written in Python.
+
+    It is a generic syntax highlighter for general use in all kinds of software
+    such as forum systems, wikis or other applications that need to prettify
+    source code. Highlights are:
+
+    * a wide range of common languages and markup formats is supported
+    * special attention is paid to details, increasing quality by a fair amount
+    * support for new languages and formats are added easily
+    * a number of output formats, presently HTML, LaTeX, RTF, SVG, all image
+      formats that PIL supports, and ANSI sequences
+    * it is usable as a command-line tool and as a library
+    * ... and it highlights even Brainfuck!
+
+    The `Pygments master branch`_ is installable with ``easy_install Pygments==dev``.
+
+    .. _Pygments master branch:
+       https://github.com/pygments/pygments/archive/master.zip#egg=Pygments-dev
+
+    :copyright: Copyright 2006-2024 by the Pygments team, see AUTHORS.
+    :license: BSD, see LICENSE for details.
+"""
+from io import StringIO, BytesIO
+
+__version__ = '2.18.0'
+__docformat__ = 'restructuredtext'
+
+__all__ = ['lex', 'format', 'highlight']
+
+
+def lex(code, lexer):
+    """
+    Lex `code` with the `lexer` (must be a `Lexer` instance)
+    and return an iterable of tokens. Currently, this only calls
+    `lexer.get_tokens()`.
+    """
+    try:
+        return lexer.get_tokens(code)
+    except TypeError:
+        # Heuristic to catch a common mistake.
+        from pip._vendor.pygments.lexer import RegexLexer
+        if isinstance(lexer, type) and issubclass(lexer, RegexLexer):
+            raise TypeError('lex() argument must be a lexer instance, '
+                            'not a class')
+        raise
+
+
+def format(tokens, formatter, outfile=None):  # pylint: disable=redefined-builtin
+    """
+    Format ``tokens`` (an iterable of tokens) with the formatter ``formatter``
+    (a `Formatter` instance).
+
+    If ``outfile`` is given and a valid file object (an object with a
+    ``write`` method), the result will be written to it, otherwise it
+    is returned as a string.
+    """
+    try:
+        if not outfile:
+            realoutfile = getattr(formatter, 'encoding', None) and BytesIO() or StringIO()
+            formatter.format(tokens, realoutfile)
+            return realoutfile.getvalue()
+        else:
+            formatter.format(tokens, outfile)
+    except TypeError:
+        # Heuristic to catch a common mistake.
+        from pip._vendor.pygments.formatter import Formatter
+        if isinstance(formatter, type) and issubclass(formatter, Formatter):
+            raise TypeError('format() argument must be a formatter instance, '
+                            'not a class')
+        raise
+
+
+def highlight(code, lexer, formatter, outfile=None):
+    """
+    This is the most high-level highlighting function. It combines `lex` and
+    `format` in one function.
+    """
+    return format(lex(code, lexer), formatter, outfile)
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/pygments/__main__.py b/venv/lib/python3.12/site-packages/pip/_vendor/pygments/__main__.py
new file mode 100644
index 00000000..dcc6e5ad
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_vendor/pygments/__main__.py
@@ -0,0 +1,17 @@
+"""
+    pygments.__main__
+    ~~~~~~~~~~~~~~~~~
+
+    Main entry point for ``python -m pygments``.
+
+    :copyright: Copyright 2006-2024 by the Pygments team, see AUTHORS.
+    :license: BSD, see LICENSE for details.
+"""
+
+import sys
+from pip._vendor.pygments.cmdline import main
+
+try:
+    sys.exit(main(sys.argv))
+except KeyboardInterrupt:
+    sys.exit(1)
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/pygments/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_vendor/pygments/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 00000000..2d0ed532
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_vendor/pygments/__pycache__/__init__.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/pygments/__pycache__/__main__.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_vendor/pygments/__pycache__/__main__.cpython-312.pyc
new file mode 100644
index 00000000..51f4cd78
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_vendor/pygments/__pycache__/__main__.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/pygments/__pycache__/cmdline.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_vendor/pygments/__pycache__/cmdline.cpython-312.pyc
new file mode 100644
index 00000000..23b4409a
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_vendor/pygments/__pycache__/cmdline.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/pygments/__pycache__/console.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_vendor/pygments/__pycache__/console.cpython-312.pyc
new file mode 100644
index 00000000..e3b5cbec
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_vendor/pygments/__pycache__/console.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/pygments/__pycache__/filter.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_vendor/pygments/__pycache__/filter.cpython-312.pyc
new file mode 100644
index 00000000..a9a2f764
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_vendor/pygments/__pycache__/filter.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/pygments/__pycache__/formatter.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_vendor/pygments/__pycache__/formatter.cpython-312.pyc
new file mode 100644
index 00000000..3cc7574e
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_vendor/pygments/__pycache__/formatter.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/pygments/__pycache__/lexer.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_vendor/pygments/__pycache__/lexer.cpython-312.pyc
new file mode 100644
index 00000000..a631960d
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_vendor/pygments/__pycache__/lexer.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/pygments/__pycache__/modeline.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_vendor/pygments/__pycache__/modeline.cpython-312.pyc
new file mode 100644
index 00000000..50ef4f3a
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_vendor/pygments/__pycache__/modeline.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/pygments/__pycache__/plugin.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_vendor/pygments/__pycache__/plugin.cpython-312.pyc
new file mode 100644
index 00000000..94e59158
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_vendor/pygments/__pycache__/plugin.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/pygments/__pycache__/regexopt.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_vendor/pygments/__pycache__/regexopt.cpython-312.pyc
new file mode 100644
index 00000000..fbb70a1c
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_vendor/pygments/__pycache__/regexopt.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/pygments/__pycache__/scanner.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_vendor/pygments/__pycache__/scanner.cpython-312.pyc
new file mode 100644
index 00000000..f9f9dd81
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_vendor/pygments/__pycache__/scanner.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/pygments/__pycache__/sphinxext.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_vendor/pygments/__pycache__/sphinxext.cpython-312.pyc
new file mode 100644
index 00000000..32060dc5
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_vendor/pygments/__pycache__/sphinxext.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/pygments/__pycache__/style.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_vendor/pygments/__pycache__/style.cpython-312.pyc
new file mode 100644
index 00000000..630dbfbb
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_vendor/pygments/__pycache__/style.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/pygments/__pycache__/token.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_vendor/pygments/__pycache__/token.cpython-312.pyc
new file mode 100644
index 00000000..3d7f776b
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_vendor/pygments/__pycache__/token.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/pygments/__pycache__/unistring.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_vendor/pygments/__pycache__/unistring.cpython-312.pyc
new file mode 100644
index 00000000..bc6671bb
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_vendor/pygments/__pycache__/unistring.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/pygments/__pycache__/util.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_vendor/pygments/__pycache__/util.cpython-312.pyc
new file mode 100644
index 00000000..49588f3d
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_vendor/pygments/__pycache__/util.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/pygments/cmdline.py b/venv/lib/python3.12/site-packages/pip/_vendor/pygments/cmdline.py
new file mode 100644
index 00000000..0a7072ef
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_vendor/pygments/cmdline.py
@@ -0,0 +1,668 @@
+"""
+    pygments.cmdline
+    ~~~~~~~~~~~~~~~~
+
+    Command line interface.
+
+    :copyright: Copyright 2006-2024 by the Pygments team, see AUTHORS.
+    :license: BSD, see LICENSE for details.
+"""
+
+import os
+import sys
+import shutil
+import argparse
+from textwrap import dedent
+
+from pip._vendor.pygments import __version__, highlight
+from pip._vendor.pygments.util import ClassNotFound, OptionError, docstring_headline, \
+    guess_decode, guess_decode_from_terminal, terminal_encoding, \
+    UnclosingTextIOWrapper
+from pip._vendor.pygments.lexers import get_all_lexers, get_lexer_by_name, guess_lexer, \
+    load_lexer_from_file, get_lexer_for_filename, find_lexer_class_for_filename
+from pip._vendor.pygments.lexers.special import TextLexer
+from pip._vendor.pygments.formatters.latex import LatexEmbeddedLexer, LatexFormatter
+from pip._vendor.pygments.formatters import get_all_formatters, get_formatter_by_name, \
+    load_formatter_from_file, get_formatter_for_filename, find_formatter_class
+from pip._vendor.pygments.formatters.terminal import TerminalFormatter
+from pip._vendor.pygments.formatters.terminal256 import Terminal256Formatter, TerminalTrueColorFormatter
+from pip._vendor.pygments.filters import get_all_filters, find_filter_class
+from pip._vendor.pygments.styles import get_all_styles, get_style_by_name
+
+
+def _parse_options(o_strs):
+    opts = {}
+    if not o_strs:
+        return opts
+    for o_str in o_strs:
+        if not o_str.strip():
+            continue
+        o_args = o_str.split(',')
+        for o_arg in o_args:
+            o_arg = o_arg.strip()
+            try:
+                o_key, o_val = o_arg.split('=', 1)
+                o_key = o_key.strip()
+                o_val = o_val.strip()
+            except ValueError:
+                opts[o_arg] = True
+            else:
+                opts[o_key] = o_val
+    return opts
+
+
+def _parse_filters(f_strs):
+    filters = []
+    if not f_strs:
+        return filters
+    for f_str in f_strs:
+        if ':' in f_str:
+            fname, fopts = f_str.split(':', 1)
+            filters.append((fname, _parse_options([fopts])))
+        else:
+            filters.append((f_str, {}))
+    return filters
+
+
+def _print_help(what, name):
+    try:
+        if what == 'lexer':
+            cls = get_lexer_by_name(name)
+            print(f"Help on the {cls.name} lexer:")
+            print(dedent(cls.__doc__))
+        elif what == 'formatter':
+            cls = find_formatter_class(name)
+            print(f"Help on the {cls.name} formatter:")
+            print(dedent(cls.__doc__))
+        elif what == 'filter':
+            cls = find_filter_class(name)
+            print(f"Help on the {name} filter:")
+            print(dedent(cls.__doc__))
+        return 0
+    except (AttributeError, ValueError):
+        print(f"{what} not found!", file=sys.stderr)
+        return 1
+
+
+def _print_list(what):
+    if what == 'lexer':
+        print()
+        print("Lexers:")
+        print("~~~~~~~")
+
+        info = []
+        for fullname, names, exts, _ in get_all_lexers():
+            tup = (', '.join(names)+':', fullname,
+                   exts and '(filenames ' + ', '.join(exts) + ')' or '')
+            info.append(tup)
+        info.sort()
+        for i in info:
+            print(('* {}\n    {} {}').format(*i))
+
+    elif what == 'formatter':
+        print()
+        print("Formatters:")
+        print("~~~~~~~~~~~")
+
+        info = []
+        for cls in get_all_formatters():
+            doc = docstring_headline(cls)
+            tup = (', '.join(cls.aliases) + ':', doc, cls.filenames and
+                   '(filenames ' + ', '.join(cls.filenames) + ')' or '')
+            info.append(tup)
+        info.sort()
+        for i in info:
+            print(('* {}\n    {} {}').format(*i))
+
+    elif what == 'filter':
+        print()
+        print("Filters:")
+        print("~~~~~~~~")
+
+        for name in get_all_filters():
+            cls = find_filter_class(name)
+            print("* " + name + ':')
+            print(f"    {docstring_headline(cls)}")
+
+    elif what == 'style':
+        print()
+        print("Styles:")
+        print("~~~~~~~")
+
+        for name in get_all_styles():
+            cls = get_style_by_name(name)
+            print("* " + name + ':')
+            print(f"    {docstring_headline(cls)}")
+
+
+def _print_list_as_json(requested_items):
+    import json
+    result = {}
+    if 'lexer' in requested_items:
+        info = {}
+        for fullname, names, filenames, mimetypes in get_all_lexers():
+            info[fullname] = {
+                'aliases': names,
+                'filenames': filenames,
+                'mimetypes': mimetypes
+            }
+        result['lexers'] = info
+
+    if 'formatter' in requested_items:
+        info = {}
+        for cls in get_all_formatters():
+            doc = docstring_headline(cls)
+            info[cls.name] = {
+                'aliases': cls.aliases,
+                'filenames': cls.filenames,
+                'doc': doc
+            }
+        result['formatters'] = info
+
+    if 'filter' in requested_items:
+        info = {}
+        for name in get_all_filters():
+            cls = find_filter_class(name)
+            info[name] = {
+                'doc': docstring_headline(cls)
+            }
+        result['filters'] = info
+
+    if 'style' in requested_items:
+        info = {}
+        for name in get_all_styles():
+            cls = get_style_by_name(name)
+            info[name] = {
+                'doc': docstring_headline(cls)
+            }
+        result['styles'] = info
+
+    json.dump(result, sys.stdout)
+
+def main_inner(parser, argns):
+    if argns.help:
+        parser.print_help()
+        return 0
+
+    if argns.V:
+        print(f'Pygments version {__version__}, (c) 2006-2024 by Georg Brandl, Matthäus '
+              'Chajdas and contributors.')
+        return 0
+
+    def is_only_option(opt):
+        return not any(v for (k, v) in vars(argns).items() if k != opt)
+
+    # handle ``pygmentize -L``
+    if argns.L is not None:
+        arg_set = set()
+        for k, v in vars(argns).items():
+            if v:
+                arg_set.add(k)
+
+        arg_set.discard('L')
+        arg_set.discard('json')
+
+        if arg_set:
+            parser.print_help(sys.stderr)
+            return 2
+
+        # print version
+        if not argns.json:
+            main(['', '-V'])
+        allowed_types = {'lexer', 'formatter', 'filter', 'style'}
+        largs = [arg.rstrip('s') for arg in argns.L]
+        if any(arg not in allowed_types for arg in largs):
+            parser.print_help(sys.stderr)
+            return 0
+        if not largs:
+            largs = allowed_types
+        if not argns.json:
+            for arg in largs:
+                _print_list(arg)
+        else:
+            _print_list_as_json(largs)
+        return 0
+
+    # handle ``pygmentize -H``
+    if argns.H:
+        if not is_only_option('H'):
+            parser.print_help(sys.stderr)
+            return 2
+        what, name = argns.H
+        if what not in ('lexer', 'formatter', 'filter'):
+            parser.print_help(sys.stderr)
+            return 2
+        return _print_help(what, name)
+
+    # parse -O options
+    parsed_opts = _parse_options(argns.O or [])
+
+    # parse -P options
+    for p_opt in argns.P or []:
+        try:
+            name, value = p_opt.split('=', 1)
+        except ValueError:
+            parsed_opts[p_opt] = True
+        else:
+            parsed_opts[name] = value
+
+    # encodings
+    inencoding = parsed_opts.get('inencoding', parsed_opts.get('encoding'))
+    outencoding = parsed_opts.get('outencoding', parsed_opts.get('encoding'))
+
+    # handle ``pygmentize -N``
+    if argns.N:
+        lexer = find_lexer_class_for_filename(argns.N)
+        if lexer is None:
+            lexer = TextLexer
+
+        print(lexer.aliases[0])
+        return 0
+
+    # handle ``pygmentize -C``
+    if argns.C:
+        inp = sys.stdin.buffer.read()
+        try:
+            lexer = guess_lexer(inp, inencoding=inencoding)
+        except ClassNotFound:
+            lexer = TextLexer
+
+        print(lexer.aliases[0])
+        return 0
+
+    # handle ``pygmentize -S``
+    S_opt = argns.S
+    a_opt = argns.a
+    if S_opt is not None:
+        f_opt = argns.f
+        if not f_opt:
+            parser.print_help(sys.stderr)
+            return 2
+        if argns.l or argns.INPUTFILE:
+            parser.print_help(sys.stderr)
+            return 2
+
+        try:
+            parsed_opts['style'] = S_opt
+            fmter = get_formatter_by_name(f_opt, **parsed_opts)
+        except ClassNotFound as err:
+            print(err, file=sys.stderr)
+            return 1
+
+        print(fmter.get_style_defs(a_opt or ''))
+        return 0
+
+    # if no -S is given, -a is not allowed
+    if argns.a is not None:
+        parser.print_help(sys.stderr)
+        return 2
+
+    # parse -F options
+    F_opts = _parse_filters(argns.F or [])
+
+    # -x: allow custom (eXternal) lexers and formatters
+    allow_custom_lexer_formatter = bool(argns.x)
+
+    # select lexer
+    lexer = None
+
+    # given by name?
+    lexername = argns.l
+    if lexername:
+        # custom lexer, located relative to user's cwd
+        if allow_custom_lexer_formatter and '.py' in lexername:
+            try:
+                filename = None
+                name = None
+                if ':' in lexername:
+                    filename, name = lexername.rsplit(':', 1)
+
+                    if '.py' in name:
+                        # This can happen on Windows: If the lexername is
+                        # C:\lexer.py -- return to normal load path in that case
+                        name = None
+
+                if filename and name:
+                    lexer = load_lexer_from_file(filename, name,
+                                                 **parsed_opts)
+                else:
+                    lexer = load_lexer_from_file(lexername, **parsed_opts)
+            except ClassNotFound as err:
+                print('Error:', err, file=sys.stderr)
+                return 1
+        else:
+            try:
+                lexer = get_lexer_by_name(lexername, **parsed_opts)
+            except (OptionError, ClassNotFound) as err:
+                print('Error:', err, file=sys.stderr)
+                return 1
+
+    # read input code
+    code = None
+
+    if argns.INPUTFILE:
+        if argns.s:
+            print('Error: -s option not usable when input file specified',
+                  file=sys.stderr)
+            return 2
+
+        infn = argns.INPUTFILE
+        try:
+            with open(infn, 'rb') as infp:
+                code = infp.read()
+        except Exception as err:
+            print('Error: cannot read infile:', err, file=sys.stderr)
+            return 1
+        if not inencoding:
+            code, inencoding = guess_decode(code)
+
+        # do we have to guess the lexer?
+        if not lexer:
+            try:
+                lexer = get_lexer_for_filename(infn, code, **parsed_opts)
+            except ClassNotFound as err:
+                if argns.g:
+                    try:
+                        lexer = guess_lexer(code, **parsed_opts)
+                    except ClassNotFound:
+                        lexer = TextLexer(**parsed_opts)
+                else:
+                    print('Error:', err, file=sys.stderr)
+                    return 1
+            except OptionError as err:
+                print('Error:', err, file=sys.stderr)
+                return 1
+
+    elif not argns.s:  # treat stdin as full file (-s support is later)
+        # read code from terminal, always in binary mode since we want to
+        # decode ourselves and be tolerant with it
+        code = sys.stdin.buffer.read()  # use .buffer to get a binary stream
+        if not inencoding:
+            code, inencoding = guess_decode_from_terminal(code, sys.stdin)
+            # else the lexer will do the decoding
+        if not lexer:
+            try:
+                lexer = guess_lexer(code, **parsed_opts)
+            except ClassNotFound:
+                lexer = TextLexer(**parsed_opts)
+
+    else:  # -s option needs a lexer with -l
+        if not lexer:
+            print('Error: when using -s a lexer has to be selected with -l',
+                  file=sys.stderr)
+            return 2
+
+    # process filters
+    for fname, fopts in F_opts:
+        try:
+            lexer.add_filter(fname, **fopts)
+        except ClassNotFound as err:
+            print('Error:', err, file=sys.stderr)
+            return 1
+
+    # select formatter
+    outfn = argns.o
+    fmter = argns.f
+    if fmter:
+        # custom formatter, located relative to user's cwd
+        if allow_custom_lexer_formatter and '.py' in fmter:
+            try:
+                filename = None
+                name = None
+                if ':' in fmter:
+                    # Same logic as above for custom lexer
+                    filename, name = fmter.rsplit(':', 1)
+
+                    if '.py' in name:
+                        name = None
+
+                if filename and name:
+                    fmter = load_formatter_from_file(filename, name,
+                                                     **parsed_opts)
+                else:
+                    fmter = load_formatter_from_file(fmter, **parsed_opts)
+            except ClassNotFound as err:
+                print('Error:', err, file=sys.stderr)
+                return 1
+        else:
+            try:
+                fmter = get_formatter_by_name(fmter, **parsed_opts)
+            except (OptionError, ClassNotFound) as err:
+                print('Error:', err, file=sys.stderr)
+                return 1
+
+    if outfn:
+        if not fmter:
+            try:
+                fmter = get_formatter_for_filename(outfn, **parsed_opts)
+            except (OptionError, ClassNotFound) as err:
+                print('Error:', err, file=sys.stderr)
+                return 1
+        try:
+            outfile = open(outfn, 'wb')
+        except Exception as err:
+            print('Error: cannot open outfile:', err, file=sys.stderr)
+            return 1
+    else:
+        if not fmter:
+            if os.environ.get('COLORTERM','') in ('truecolor', '24bit'):
+                fmter = TerminalTrueColorFormatter(**parsed_opts)
+            elif '256' in os.environ.get('TERM', ''):
+                fmter = Terminal256Formatter(**parsed_opts)
+            else:
+                fmter = TerminalFormatter(**parsed_opts)
+        outfile = sys.stdout.buffer
+
+    # determine output encoding if not explicitly selected
+    if not outencoding:
+        if outfn:
+            # output file? use lexer encoding for now (can still be None)
+            fmter.encoding = inencoding
+        else:
+            # else use terminal encoding
+            fmter.encoding = terminal_encoding(sys.stdout)
+
+    # provide coloring under Windows, if possible
+    if not outfn and sys.platform in ('win32', 'cygwin') and \
+       fmter.name in ('Terminal', 'Terminal256'):  # pragma: no cover
+        # unfortunately colorama doesn't support binary streams on Py3
+        outfile = UnclosingTextIOWrapper(outfile, encoding=fmter.encoding)
+        fmter.encoding = None
+        try:
+            import colorama.initialise
+        except ImportError:
+            pass
+        else:
+            outfile = colorama.initialise.wrap_stream(
+                outfile, convert=None, strip=None, autoreset=False, wrap=True)
+
+    # When using the LaTeX formatter and the option `escapeinside` is
+    # specified, we need a special lexer which collects escaped text
+    # before running the chosen language lexer.
+    escapeinside = parsed_opts.get('escapeinside', '')
+    if len(escapeinside) == 2 and isinstance(fmter, LatexFormatter):
+        left = escapeinside[0]
+        right = escapeinside[1]
+        lexer = LatexEmbeddedLexer(left, right, lexer)
+
+    # ... and do it!
+    if not argns.s:
+        # process whole input as per normal...
+        try:
+            highlight(code, lexer, fmter, outfile)
+        finally:
+            if outfn:
+                outfile.close()
+        return 0
+    else:
+        # line by line processing of stdin (eg: for 'tail -f')...
+        try:
+            while 1:
+                line = sys.stdin.buffer.readline()
+                if not line:
+                    break
+                if not inencoding:
+                    line = guess_decode_from_terminal(line, sys.stdin)[0]
+                highlight(line, lexer, fmter, outfile)
+                if hasattr(outfile, 'flush'):
+                    outfile.flush()
+            return 0
+        except KeyboardInterrupt:  # pragma: no cover
+            return 0
+        finally:
+            if outfn:
+                outfile.close()
+
+
+class HelpFormatter(argparse.HelpFormatter):
+    def __init__(self, prog, indent_increment=2, max_help_position=16, width=None):
+        if width is None:
+            try:
+                width = shutil.get_terminal_size().columns - 2
+            except Exception:
+                pass
+        argparse.HelpFormatter.__init__(self, prog, indent_increment,
+                                        max_help_position, width)
+
+
+def main(args=sys.argv):
+    """
+    Main command line entry point.
+    """
+    desc = "Highlight an input file and write the result to an output file."
+    parser = argparse.ArgumentParser(description=desc, add_help=False,
+                                     formatter_class=HelpFormatter)
+
+    operation = parser.add_argument_group('Main operation')
+    lexersel = operation.add_mutually_exclusive_group()
+    lexersel.add_argument(
+        '-l', metavar='LEXER',
+        help='Specify the lexer to use.  (Query names with -L.)  If not '
+        'given and -g is not present, the lexer is guessed from the filename.')
+    lexersel.add_argument(
+        '-g', action='store_true',
+        help='Guess the lexer from the file contents, or pass through '
+        'as plain text if nothing can be guessed.')
+    operation.add_argument(
+        '-F', metavar='FILTER[:options]', action='append',
+        help='Add a filter to the token stream.  (Query names with -L.) '
+        'Filter options are given after a colon if necessary.')
+    operation.add_argument(
+        '-f', metavar='FORMATTER',
+        help='Specify the formatter to use.  (Query names with -L.) '
+        'If not given, the formatter is guessed from the output filename, '
+        'and defaults to the terminal formatter if the output is to the '
+        'terminal or an unknown file extension.')
+    operation.add_argument(
+        '-O', metavar='OPTION=value[,OPTION=value,...]', action='append',
+        help='Give options to the lexer and formatter as a comma-separated '
+        'list of key-value pairs. '
+        'Example: `-O bg=light,python=cool`.')
+    operation.add_argument(
+        '-P', metavar='OPTION=value', action='append',
+        help='Give a single option to the lexer and formatter - with this '
+        'you can pass options whose value contains commas and equal signs. '
+        'Example: `-P "heading=Pygments, the Python highlighter"`.')
+    operation.add_argument(
+        '-o', metavar='OUTPUTFILE',
+        help='Where to write the output.  Defaults to standard output.')
+
+    operation.add_argument(
+        'INPUTFILE', nargs='?',
+        help='Where to read the input.  Defaults to standard input.')
+
+    flags = parser.add_argument_group('Operation flags')
+    flags.add_argument(
+        '-v', action='store_true',
+        help='Print a detailed traceback on unhandled exceptions, which '
+        'is useful for debugging and bug reports.')
+    flags.add_argument(
+        '-s', action='store_true',
+        help='Process lines one at a time until EOF, rather than waiting to '
+        'process the entire file.  This only works for stdin, only for lexers '
+        'with no line-spanning constructs, and is intended for streaming '
+        'input such as you get from `tail -f`. '
+        'Example usage: `tail -f sql.log | pygmentize -s -l sql`.')
+    flags.add_argument(
+        '-x', action='store_true',
+        help='Allow custom lexers and formatters to be loaded from a .py file '
+        'relative to the current working directory. For example, '
+        '`-l ./customlexer.py -x`. By default, this option expects a file '
+        'with a class named CustomLexer or CustomFormatter; you can also '
+        'specify your own class name with a colon (`-l ./lexer.py:MyLexer`). '
+        'Users should be very careful not to use this option with untrusted '
+        'files, because it will import and run them.')
+    flags.add_argument('--json', help='Output as JSON. This can '
+        'be only used in conjunction with -L.',
+        default=False,
+        action='store_true')
+
+    special_modes_group = parser.add_argument_group(
+        'Special modes - do not do any highlighting')
+    special_modes = special_modes_group.add_mutually_exclusive_group()
+    special_modes.add_argument(
+        '-S', metavar='STYLE -f formatter',
+        help='Print style definitions for STYLE for a formatter '
+        'given with -f. The argument given by -a is formatter '
+        'dependent.')
+    special_modes.add_argument(
+        '-L', nargs='*', metavar='WHAT',
+        help='List lexers, formatters, styles or filters -- '
+        'give additional arguments for the thing(s) you want to list '
+        '(e.g. "styles"), or omit them to list everything.')
+    special_modes.add_argument(
+        '-N', metavar='FILENAME',
+        help='Guess and print out a lexer name based solely on the given '
+        'filename. Does not take input or highlight anything. If no specific '
+        'lexer can be determined, "text" is printed.')
+    special_modes.add_argument(
+        '-C', action='store_true',
+        help='Like -N, but print out a lexer name based solely on '
+        'a given content from standard input.')
+    special_modes.add_argument(
+        '-H', action='store', nargs=2, metavar=('NAME', 'TYPE'),
+        help='Print detailed help for the object  of type , '
+        'where  is one of "lexer", "formatter" or "filter".')
+    special_modes.add_argument(
+        '-V', action='store_true',
+        help='Print the package version.')
+    special_modes.add_argument(
+        '-h', '--help', action='store_true',
+        help='Print this help.')
+    special_modes_group.add_argument(
+        '-a', metavar='ARG',
+        help='Formatter-specific additional argument for the -S (print '
+        'style sheet) mode.')
+
+    argns = parser.parse_args(args[1:])
+
+    try:
+        return main_inner(parser, argns)
+    except BrokenPipeError:
+        # someone closed our stdout, e.g. by quitting a pager.
+        return 0
+    except Exception:
+        if argns.v:
+            print(file=sys.stderr)
+            print('*' * 65, file=sys.stderr)
+            print('An unhandled exception occurred while highlighting.',
+                  file=sys.stderr)
+            print('Please report the whole traceback to the issue tracker at',
+                  file=sys.stderr)
+            print('.',
+                  file=sys.stderr)
+            print('*' * 65, file=sys.stderr)
+            print(file=sys.stderr)
+            raise
+        import traceback
+        info = traceback.format_exception(*sys.exc_info())
+        msg = info[-1].strip()
+        if len(info) >= 3:
+            # extract relevant file and position info
+            msg += '\n   (f{})'.format(info[-2].split('\n')[0].strip()[1:])
+        print(file=sys.stderr)
+        print('*** Error while highlighting:', file=sys.stderr)
+        print(msg, file=sys.stderr)
+        print('*** If this is a bug you want to report, please rerun with -v.',
+              file=sys.stderr)
+        return 1
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/pygments/console.py b/venv/lib/python3.12/site-packages/pip/_vendor/pygments/console.py
new file mode 100644
index 00000000..4c1a0621
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_vendor/pygments/console.py
@@ -0,0 +1,70 @@
+"""
+    pygments.console
+    ~~~~~~~~~~~~~~~~
+
+    Format colored console output.
+
+    :copyright: Copyright 2006-2024 by the Pygments team, see AUTHORS.
+    :license: BSD, see LICENSE for details.
+"""
+
+esc = "\x1b["
+
+codes = {}
+codes[""] = ""
+codes["reset"] = esc + "39;49;00m"
+
+codes["bold"] = esc + "01m"
+codes["faint"] = esc + "02m"
+codes["standout"] = esc + "03m"
+codes["underline"] = esc + "04m"
+codes["blink"] = esc + "05m"
+codes["overline"] = esc + "06m"
+
+dark_colors = ["black", "red", "green", "yellow", "blue",
+               "magenta", "cyan", "gray"]
+light_colors = ["brightblack", "brightred", "brightgreen", "brightyellow", "brightblue",
+                "brightmagenta", "brightcyan", "white"]
+
+x = 30
+for dark, light in zip(dark_colors, light_colors):
+    codes[dark] = esc + "%im" % x
+    codes[light] = esc + "%im" % (60 + x)
+    x += 1
+
+del dark, light, x
+
+codes["white"] = codes["bold"]
+
+
+def reset_color():
+    return codes["reset"]
+
+
+def colorize(color_key, text):
+    return codes[color_key] + text + codes["reset"]
+
+
+def ansiformat(attr, text):
+    """
+    Format ``text`` with a color and/or some attributes::
+
+        color       normal color
+        *color*     bold color
+        _color_     underlined color
+        +color+     blinking color
+    """
+    result = []
+    if attr[:1] == attr[-1:] == '+':
+        result.append(codes['blink'])
+        attr = attr[1:-1]
+    if attr[:1] == attr[-1:] == '*':
+        result.append(codes['bold'])
+        attr = attr[1:-1]
+    if attr[:1] == attr[-1:] == '_':
+        result.append(codes['underline'])
+        attr = attr[1:-1]
+    result.append(codes[attr])
+    result.append(text)
+    result.append(codes['reset'])
+    return ''.join(result)
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/pygments/filter.py b/venv/lib/python3.12/site-packages/pip/_vendor/pygments/filter.py
new file mode 100644
index 00000000..aa6f7604
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_vendor/pygments/filter.py
@@ -0,0 +1,70 @@
+"""
+    pygments.filter
+    ~~~~~~~~~~~~~~~
+
+    Module that implements the default filter.
+
+    :copyright: Copyright 2006-2024 by the Pygments team, see AUTHORS.
+    :license: BSD, see LICENSE for details.
+"""
+
+
+def apply_filters(stream, filters, lexer=None):
+    """
+    Use this method to apply an iterable of filters to
+    a stream. If lexer is given it's forwarded to the
+    filter, otherwise the filter receives `None`.
+    """
+    def _apply(filter_, stream):
+        yield from filter_.filter(lexer, stream)
+    for filter_ in filters:
+        stream = _apply(filter_, stream)
+    return stream
+
+
+def simplefilter(f):
+    """
+    Decorator that converts a function into a filter::
+
+        @simplefilter
+        def lowercase(self, lexer, stream, options):
+            for ttype, value in stream:
+                yield ttype, value.lower()
+    """
+    return type(f.__name__, (FunctionFilter,), {
+        '__module__': getattr(f, '__module__'),
+        '__doc__': f.__doc__,
+        'function': f,
+    })
+
+
+class Filter:
+    """
+    Default filter. Subclass this class or use the `simplefilter`
+    decorator to create own filters.
+    """
+
+    def __init__(self, **options):
+        self.options = options
+
+    def filter(self, lexer, stream):
+        raise NotImplementedError()
+
+
+class FunctionFilter(Filter):
+    """
+    Abstract class used by `simplefilter` to create simple
+    function filters on the fly. The `simplefilter` decorator
+    automatically creates subclasses of this class for
+    functions passed to it.
+    """
+    function = None
+
+    def __init__(self, **options):
+        if not hasattr(self, 'function'):
+            raise TypeError(f'{self.__class__.__name__!r} used without bound function')
+        Filter.__init__(self, **options)
+
+    def filter(self, lexer, stream):
+        # pylint: disable=not-callable
+        yield from self.function(lexer, stream, self.options)
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/pygments/filters/__init__.py b/venv/lib/python3.12/site-packages/pip/_vendor/pygments/filters/__init__.py
new file mode 100644
index 00000000..9255ca22
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_vendor/pygments/filters/__init__.py
@@ -0,0 +1,940 @@
+"""
+    pygments.filters
+    ~~~~~~~~~~~~~~~~
+
+    Module containing filter lookup functions and default
+    filters.
+
+    :copyright: Copyright 2006-2024 by the Pygments team, see AUTHORS.
+    :license: BSD, see LICENSE for details.
+"""
+
+import re
+
+from pip._vendor.pygments.token import String, Comment, Keyword, Name, Error, Whitespace, \
+    string_to_tokentype
+from pip._vendor.pygments.filter import Filter
+from pip._vendor.pygments.util import get_list_opt, get_int_opt, get_bool_opt, \
+    get_choice_opt, ClassNotFound, OptionError
+from pip._vendor.pygments.plugin import find_plugin_filters
+
+
+def find_filter_class(filtername):
+    """Lookup a filter by name. Return None if not found."""
+    if filtername in FILTERS:
+        return FILTERS[filtername]
+    for name, cls in find_plugin_filters():
+        if name == filtername:
+            return cls
+    return None
+
+
+def get_filter_by_name(filtername, **options):
+    """Return an instantiated filter.
+
+    Options are passed to the filter initializer if wanted.
+    Raise a ClassNotFound if not found.
+    """
+    cls = find_filter_class(filtername)
+    if cls:
+        return cls(**options)
+    else:
+        raise ClassNotFound(f'filter {filtername!r} not found')
+
+
+def get_all_filters():
+    """Return a generator of all filter names."""
+    yield from FILTERS
+    for name, _ in find_plugin_filters():
+        yield name
+
+
+def _replace_special(ttype, value, regex, specialttype,
+                     replacefunc=lambda x: x):
+    last = 0
+    for match in regex.finditer(value):
+        start, end = match.start(), match.end()
+        if start != last:
+            yield ttype, value[last:start]
+        yield specialttype, replacefunc(value[start:end])
+        last = end
+    if last != len(value):
+        yield ttype, value[last:]
+
+
+class CodeTagFilter(Filter):
+    """Highlight special code tags in comments and docstrings.
+
+    Options accepted:
+
+    `codetags` : list of strings
+       A list of strings that are flagged as code tags.  The default is to
+       highlight ``XXX``, ``TODO``, ``FIXME``, ``BUG`` and ``NOTE``.
+
+    .. versionchanged:: 2.13
+       Now recognizes ``FIXME`` by default.
+    """
+
+    def __init__(self, **options):
+        Filter.__init__(self, **options)
+        tags = get_list_opt(options, 'codetags',
+                            ['XXX', 'TODO', 'FIXME', 'BUG', 'NOTE'])
+        self.tag_re = re.compile(r'\b({})\b'.format('|'.join([
+            re.escape(tag) for tag in tags if tag
+        ])))
+
+    def filter(self, lexer, stream):
+        regex = self.tag_re
+        for ttype, value in stream:
+            if ttype in String.Doc or \
+               ttype in Comment and \
+               ttype not in Comment.Preproc:
+                yield from _replace_special(ttype, value, regex, Comment.Special)
+            else:
+                yield ttype, value
+
+
+class SymbolFilter(Filter):
+    """Convert mathematical symbols such as \\ in Isabelle
+    or \\longrightarrow in LaTeX into Unicode characters.
+
+    This is mostly useful for HTML or console output when you want to
+    approximate the source rendering you'd see in an IDE.
+
+    Options accepted:
+
+    `lang` : string
+       The symbol language. Must be one of ``'isabelle'`` or
+       ``'latex'``.  The default is ``'isabelle'``.
+    """
+
+    latex_symbols = {
+        '\\alpha'                : '\U000003b1',
+        '\\beta'                 : '\U000003b2',
+        '\\gamma'                : '\U000003b3',
+        '\\delta'                : '\U000003b4',
+        '\\varepsilon'           : '\U000003b5',
+        '\\zeta'                 : '\U000003b6',
+        '\\eta'                  : '\U000003b7',
+        '\\vartheta'             : '\U000003b8',
+        '\\iota'                 : '\U000003b9',
+        '\\kappa'                : '\U000003ba',
+        '\\lambda'               : '\U000003bb',
+        '\\mu'                   : '\U000003bc',
+        '\\nu'                   : '\U000003bd',
+        '\\xi'                   : '\U000003be',
+        '\\pi'                   : '\U000003c0',
+        '\\varrho'               : '\U000003c1',
+        '\\sigma'                : '\U000003c3',
+        '\\tau'                  : '\U000003c4',
+        '\\upsilon'              : '\U000003c5',
+        '\\varphi'               : '\U000003c6',
+        '\\chi'                  : '\U000003c7',
+        '\\psi'                  : '\U000003c8',
+        '\\omega'                : '\U000003c9',
+        '\\Gamma'                : '\U00000393',
+        '\\Delta'                : '\U00000394',
+        '\\Theta'                : '\U00000398',
+        '\\Lambda'               : '\U0000039b',
+        '\\Xi'                   : '\U0000039e',
+        '\\Pi'                   : '\U000003a0',
+        '\\Sigma'                : '\U000003a3',
+        '\\Upsilon'              : '\U000003a5',
+        '\\Phi'                  : '\U000003a6',
+        '\\Psi'                  : '\U000003a8',
+        '\\Omega'                : '\U000003a9',
+        '\\leftarrow'            : '\U00002190',
+        '\\longleftarrow'        : '\U000027f5',
+        '\\rightarrow'           : '\U00002192',
+        '\\longrightarrow'       : '\U000027f6',
+        '\\Leftarrow'            : '\U000021d0',
+        '\\Longleftarrow'        : '\U000027f8',
+        '\\Rightarrow'           : '\U000021d2',
+        '\\Longrightarrow'       : '\U000027f9',
+        '\\leftrightarrow'       : '\U00002194',
+        '\\longleftrightarrow'   : '\U000027f7',
+        '\\Leftrightarrow'       : '\U000021d4',
+        '\\Longleftrightarrow'   : '\U000027fa',
+        '\\mapsto'               : '\U000021a6',
+        '\\longmapsto'           : '\U000027fc',
+        '\\relbar'               : '\U00002500',
+        '\\Relbar'               : '\U00002550',
+        '\\hookleftarrow'        : '\U000021a9',
+        '\\hookrightarrow'       : '\U000021aa',
+        '\\leftharpoondown'      : '\U000021bd',
+        '\\rightharpoondown'     : '\U000021c1',
+        '\\leftharpoonup'        : '\U000021bc',
+        '\\rightharpoonup'       : '\U000021c0',
+        '\\rightleftharpoons'    : '\U000021cc',
+        '\\leadsto'              : '\U0000219d',
+        '\\downharpoonleft'      : '\U000021c3',
+        '\\downharpoonright'     : '\U000021c2',
+        '\\upharpoonleft'        : '\U000021bf',
+        '\\upharpoonright'       : '\U000021be',
+        '\\restriction'          : '\U000021be',
+        '\\uparrow'              : '\U00002191',
+        '\\Uparrow'              : '\U000021d1',
+        '\\downarrow'            : '\U00002193',
+        '\\Downarrow'            : '\U000021d3',
+        '\\updownarrow'          : '\U00002195',
+        '\\Updownarrow'          : '\U000021d5',
+        '\\langle'               : '\U000027e8',
+        '\\rangle'               : '\U000027e9',
+        '\\lceil'                : '\U00002308',
+        '\\rceil'                : '\U00002309',
+        '\\lfloor'               : '\U0000230a',
+        '\\rfloor'               : '\U0000230b',
+        '\\flqq'                 : '\U000000ab',
+        '\\frqq'                 : '\U000000bb',
+        '\\bot'                  : '\U000022a5',
+        '\\top'                  : '\U000022a4',
+        '\\wedge'                : '\U00002227',
+        '\\bigwedge'             : '\U000022c0',
+        '\\vee'                  : '\U00002228',
+        '\\bigvee'               : '\U000022c1',
+        '\\forall'               : '\U00002200',
+        '\\exists'               : '\U00002203',
+        '\\nexists'              : '\U00002204',
+        '\\neg'                  : '\U000000ac',
+        '\\Box'                  : '\U000025a1',
+        '\\Diamond'              : '\U000025c7',
+        '\\vdash'                : '\U000022a2',
+        '\\models'               : '\U000022a8',
+        '\\dashv'                : '\U000022a3',
+        '\\surd'                 : '\U0000221a',
+        '\\le'                   : '\U00002264',
+        '\\ge'                   : '\U00002265',
+        '\\ll'                   : '\U0000226a',
+        '\\gg'                   : '\U0000226b',
+        '\\lesssim'              : '\U00002272',
+        '\\gtrsim'               : '\U00002273',
+        '\\lessapprox'           : '\U00002a85',
+        '\\gtrapprox'            : '\U00002a86',
+        '\\in'                   : '\U00002208',
+        '\\notin'                : '\U00002209',
+        '\\subset'               : '\U00002282',
+        '\\supset'               : '\U00002283',
+        '\\subseteq'             : '\U00002286',
+        '\\supseteq'             : '\U00002287',
+        '\\sqsubset'             : '\U0000228f',
+        '\\sqsupset'             : '\U00002290',
+        '\\sqsubseteq'           : '\U00002291',
+        '\\sqsupseteq'           : '\U00002292',
+        '\\cap'                  : '\U00002229',
+        '\\bigcap'               : '\U000022c2',
+        '\\cup'                  : '\U0000222a',
+        '\\bigcup'               : '\U000022c3',
+        '\\sqcup'                : '\U00002294',
+        '\\bigsqcup'             : '\U00002a06',
+        '\\sqcap'                : '\U00002293',
+        '\\Bigsqcap'             : '\U00002a05',
+        '\\setminus'             : '\U00002216',
+        '\\propto'               : '\U0000221d',
+        '\\uplus'                : '\U0000228e',
+        '\\bigplus'              : '\U00002a04',
+        '\\sim'                  : '\U0000223c',
+        '\\doteq'                : '\U00002250',
+        '\\simeq'                : '\U00002243',
+        '\\approx'               : '\U00002248',
+        '\\asymp'                : '\U0000224d',
+        '\\cong'                 : '\U00002245',
+        '\\equiv'                : '\U00002261',
+        '\\Join'                 : '\U000022c8',
+        '\\bowtie'               : '\U00002a1d',
+        '\\prec'                 : '\U0000227a',
+        '\\succ'                 : '\U0000227b',
+        '\\preceq'               : '\U0000227c',
+        '\\succeq'               : '\U0000227d',
+        '\\parallel'             : '\U00002225',
+        '\\mid'                  : '\U000000a6',
+        '\\pm'                   : '\U000000b1',
+        '\\mp'                   : '\U00002213',
+        '\\times'                : '\U000000d7',
+        '\\div'                  : '\U000000f7',
+        '\\cdot'                 : '\U000022c5',
+        '\\star'                 : '\U000022c6',
+        '\\circ'                 : '\U00002218',
+        '\\dagger'               : '\U00002020',
+        '\\ddagger'              : '\U00002021',
+        '\\lhd'                  : '\U000022b2',
+        '\\rhd'                  : '\U000022b3',
+        '\\unlhd'                : '\U000022b4',
+        '\\unrhd'                : '\U000022b5',
+        '\\triangleleft'         : '\U000025c3',
+        '\\triangleright'        : '\U000025b9',
+        '\\triangle'             : '\U000025b3',
+        '\\triangleq'            : '\U0000225c',
+        '\\oplus'                : '\U00002295',
+        '\\bigoplus'             : '\U00002a01',
+        '\\otimes'               : '\U00002297',
+        '\\bigotimes'            : '\U00002a02',
+        '\\odot'                 : '\U00002299',
+        '\\bigodot'              : '\U00002a00',
+        '\\ominus'               : '\U00002296',
+        '\\oslash'               : '\U00002298',
+        '\\dots'                 : '\U00002026',
+        '\\cdots'                : '\U000022ef',
+        '\\sum'                  : '\U00002211',
+        '\\prod'                 : '\U0000220f',
+        '\\coprod'               : '\U00002210',
+        '\\infty'                : '\U0000221e',
+        '\\int'                  : '\U0000222b',
+        '\\oint'                 : '\U0000222e',
+        '\\clubsuit'             : '\U00002663',
+        '\\diamondsuit'          : '\U00002662',
+        '\\heartsuit'            : '\U00002661',
+        '\\spadesuit'            : '\U00002660',
+        '\\aleph'                : '\U00002135',
+        '\\emptyset'             : '\U00002205',
+        '\\nabla'                : '\U00002207',
+        '\\partial'              : '\U00002202',
+        '\\flat'                 : '\U0000266d',
+        '\\natural'              : '\U0000266e',
+        '\\sharp'                : '\U0000266f',
+        '\\angle'                : '\U00002220',
+        '\\copyright'            : '\U000000a9',
+        '\\textregistered'       : '\U000000ae',
+        '\\textonequarter'       : '\U000000bc',
+        '\\textonehalf'          : '\U000000bd',
+        '\\textthreequarters'    : '\U000000be',
+        '\\textordfeminine'      : '\U000000aa',
+        '\\textordmasculine'     : '\U000000ba',
+        '\\euro'                 : '\U000020ac',
+        '\\pounds'               : '\U000000a3',
+        '\\yen'                  : '\U000000a5',
+        '\\textcent'             : '\U000000a2',
+        '\\textcurrency'         : '\U000000a4',
+        '\\textdegree'           : '\U000000b0',
+    }
+
+    isabelle_symbols = {
+        '\\'                 : '\U0001d7ec',
+        '\\'                  : '\U0001d7ed',
+        '\\'                  : '\U0001d7ee',
+        '\\'                : '\U0001d7ef',
+        '\\'                 : '\U0001d7f0',
+        '\\'                 : '\U0001d7f1',
+        '\\'                  : '\U0001d7f2',
+        '\\'                : '\U0001d7f3',
+        '\\'                : '\U0001d7f4',
+        '\\'                 : '\U0001d7f5',
+        '\\'                    : '\U0001d49c',
+        '\\'                    : '\U0000212c',
+        '\\'                    : '\U0001d49e',
+        '\\'                    : '\U0001d49f',
+        '\\'                    : '\U00002130',
+        '\\'                    : '\U00002131',
+        '\\'                    : '\U0001d4a2',
+        '\\'                    : '\U0000210b',
+        '\\'                    : '\U00002110',
+        '\\'                    : '\U0001d4a5',
+        '\\'                    : '\U0001d4a6',
+        '\\'                    : '\U00002112',
+        '\\'                    : '\U00002133',
+        '\\'                    : '\U0001d4a9',
+        '\\'                    : '\U0001d4aa',
+        '\\
'                    : '\U0001d5c9',
+        '\\'                    : '\U0001d5ca',
+        '\\'                    : '\U0001d5cb',
+        '\\'                    : '\U0001d5cc',
+        '\\'                    : '\U0001d5cd',
+        '\\'                    : '\U0001d5ce',
+        '\\'                    : '\U0001d5cf',
+        '\\'                    : '\U0001d5d0',
+        '\\'                    : '\U0001d5d1',
+        '\\'                    : '\U0001d5d2',
+        '\\'                    : '\U0001d5d3',
+        '\\'                   : '\U0001d504',
+        '\\'                   : '\U0001d505',
+        '\\'                   : '\U0000212d',
+        '\\
'                   : '\U0001d507',
+        '\\'                   : '\U0001d508',
+        '\\'                   : '\U0001d509',
+        '\\'                   : '\U0001d50a',
+        '\\'                   : '\U0000210c',
+        '\\'                   : '\U00002111',
+        '\\'                   : '\U0001d50d',
+        '\\'                   : '\U0001d50e',
+        '\\'                   : '\U0001d50f',
+        '\\'                   : '\U0001d510',
+        '\\'                   : '\U0001d511',
+        '\\'                   : '\U0001d512',
+        '\\'                   : '\U0001d513',
+        '\\'                   : '\U0001d514',
+        '\\'                   : '\U0000211c',
+        '\\'                   : '\U0001d516',
+        '\\'                   : '\U0001d517',
+        '\\'                   : '\U0001d518',
+        '\\'                   : '\U0001d519',
+        '\\'                   : '\U0001d51a',
+        '\\'                   : '\U0001d51b',
+        '\\'                   : '\U0001d51c',
+        '\\'                   : '\U00002128',
+        '\\'                   : '\U0001d51e',
+        '\\'                   : '\U0001d51f',
+        '\\'                   : '\U0001d520',
+        '\\
'                   : '\U0001d521',
+        '\\'                   : '\U0001d522',
+        '\\'                   : '\U0001d523',
+        '\\'                   : '\U0001d524',
+        '\\'                   : '\U0001d525',
+        '\\'                   : '\U0001d526',
+        '\\'                   : '\U0001d527',
+        '\\'                   : '\U0001d528',
+        '\\'                   : '\U0001d529',
+        '\\'                   : '\U0001d52a',
+        '\\'                   : '\U0001d52b',
+        '\\'                   : '\U0001d52c',
+        '\\'                   : '\U0001d52d',
+        '\\'                   : '\U0001d52e',
+        '\\'                   : '\U0001d52f',
+        '\\'                   : '\U0001d530',
+        '\\'                   : '\U0001d531',
+        '\\'                   : '\U0001d532',
+        '\\'                   : '\U0001d533',
+        '\\'                   : '\U0001d534',
+        '\\'                   : '\U0001d535',
+        '\\'                   : '\U0001d536',
+        '\\'                   : '\U0001d537',
+        '\\'                : '\U000003b1',
+        '\\'                 : '\U000003b2',
+        '\\'                : '\U000003b3',
+        '\\'                : '\U000003b4',
+        '\\'              : '\U000003b5',
+        '\\'                 : '\U000003b6',
+        '\\'                  : '\U000003b7',
+        '\\'                : '\U000003b8',
+        '\\'                 : '\U000003b9',
+        '\\'                : '\U000003ba',
+        '\\'               : '\U000003bb',
+        '\\'                   : '\U000003bc',
+        '\\'                   : '\U000003bd',
+        '\\'                   : '\U000003be',
+        '\\'                   : '\U000003c0',
+        '\\'                  : '\U000003c1',
+        '\\'                : '\U000003c3',
+        '\\'                  : '\U000003c4',
+        '\\'              : '\U000003c5',
+        '\\'                  : '\U000003c6',
+        '\\'                  : '\U000003c7',
+        '\\'                  : '\U000003c8',
+        '\\'                : '\U000003c9',
+        '\\'                : '\U00000393',
+        '\\'                : '\U00000394',
+        '\\'                : '\U00000398',
+        '\\'               : '\U0000039b',
+        '\\'                   : '\U0000039e',
+        '\\'                   : '\U000003a0',
+        '\\'                : '\U000003a3',
+        '\\'              : '\U000003a5',
+        '\\'                  : '\U000003a6',
+        '\\'                  : '\U000003a8',
+        '\\'                : '\U000003a9',
+        '\\'                 : '\U0001d539',
+        '\\'              : '\U00002102',
+        '\\'                  : '\U00002115',
+        '\\'                  : '\U0000211a',
+        '\\'                 : '\U0000211d',
+        '\\'                  : '\U00002124',
+        '\\'            : '\U00002190',
+        '\\'        : '\U000027f5',
+        '\\'           : '\U00002192',
+        '\\'       : '\U000027f6',
+        '\\'            : '\U000021d0',
+        '\\'        : '\U000027f8',
+        '\\'           : '\U000021d2',
+        '\\'       : '\U000027f9',
+        '\\'       : '\U00002194',
+        '\\'   : '\U000027f7',
+        '\\'       : '\U000021d4',
+        '\\'   : '\U000027fa',
+        '\\'               : '\U000021a6',
+        '\\'           : '\U000027fc',
+        '\\'             : '\U00002500',
+        '\\'             : '\U00002550',
+        '\\'        : '\U000021a9',
+        '\\'       : '\U000021aa',
+        '\\'      : '\U000021bd',
+        '\\'     : '\U000021c1',
+        '\\'        : '\U000021bc',
+        '\\'       : '\U000021c0',
+        '\\'    : '\U000021cc',
+        '\\'              : '\U0000219d',
+        '\\'      : '\U000021c3',
+        '\\'     : '\U000021c2',
+        '\\'        : '\U000021bf',
+        '\\'       : '\U000021be',
+        '\\'          : '\U000021be',
+        '\\'                : '\U00002237',
+        '\\'                   : '\U00002191',
+        '\\'                   : '\U000021d1',
+        '\\'                 : '\U00002193',
+        '\\'                 : '\U000021d3',
+        '\\'               : '\U00002195',
+        '\\'               : '\U000021d5',
+        '\\'               : '\U000027e8',
+        '\\'               : '\U000027e9',
+        '\\'                : '\U00002308',
+        '\\'                : '\U00002309',
+        '\\'               : '\U0000230a',
+        '\\'               : '\U0000230b',
+        '\\'                : '\U00002987',
+        '\\'                : '\U00002988',
+        '\\'               : '\U000027e6',
+        '\\'               : '\U000027e7',
+        '\\'               : '\U00002983',
+        '\\'               : '\U00002984',
+        '\\'        : '\U000000ab',
+        '\\'       : '\U000000bb',
+        '\\'               : '\U000022a5',
+        '\\'                  : '\U000022a4',
+        '\\'                  : '\U00002227',
+        '\\'                  : '\U000022c0',
+        '\\'                   : '\U00002228',
+        '\\'                   : '\U000022c1',
+        '\\'               : '\U00002200',
+        '\\'               : '\U00002203',
+        '\\'              : '\U00002204',
+        '\\'                  : '\U000000ac',
+        '\\'                  : '\U000025a1',
+        '\\'              : '\U000025c7',
+        '\\'            : '\U000022a2',
+        '\\'            : '\U000022a8',
+        '\\'           : '\U000022a9',
+        '\\'           : '\U000022ab',
+        '\\'            : '\U000022a3',
+        '\\'                 : '\U0000221a',
+        '\\'                   : '\U00002264',
+        '\\'                   : '\U00002265',
+        '\\'                : '\U0000226a',
+        '\\'             : '\U0000226b',
+        '\\'              : '\U00002272',
+        '\\'           : '\U00002273',
+        '\\'           : '\U00002a85',
+        '\\'        : '\U00002a86',
+        '\\'                   : '\U00002208',
+        '\\'                : '\U00002209',
+        '\\'               : '\U00002282',
+        '\\'               : '\U00002283',
+        '\\'             : '\U00002286',
+        '\\'             : '\U00002287',
+        '\\'             : '\U0000228f',
+        '\\'             : '\U00002290',
+        '\\'           : '\U00002291',
+        '\\'           : '\U00002292',
+        '\\'                : '\U00002229',
+        '\\'                : '\U000022c2',
+        '\\'                : '\U0000222a',
+        '\\'                : '\U000022c3',
+        '\\'              : '\U00002294',
+        '\\'              : '\U00002a06',
+        '\\'              : '\U00002293',
+        '\\'              : '\U00002a05',
+        '\\'             : '\U00002216',
+        '\\'               : '\U0000221d',
+        '\\'                : '\U0000228e',
+        '\\'                : '\U00002a04',
+        '\\'                : '\U00002260',
+        '\\'                  : '\U0000223c',
+        '\\'                : '\U00002250',
+        '\\'                : '\U00002243',
+        '\\'               : '\U00002248',
+        '\\'                : '\U0000224d',
+        '\\'                 : '\U00002245',
+        '\\'                : '\U00002323',
+        '\\'                : '\U00002261',
+        '\\'                : '\U00002322',
+        '\\'                 : '\U000022c8',
+        '\\'               : '\U00002a1d',
+        '\\'                 : '\U0000227a',
+        '\\'                 : '\U0000227b',
+        '\\'               : '\U0000227c',
+        '\\'               : '\U0000227d',
+        '\\'             : '\U00002225',
+        '\\'                  : '\U000000a6',
+        '\\'            : '\U000000b1',
+        '\\'            : '\U00002213',
+        '\\'                : '\U000000d7',
+        '\\
'                  : '\U000000f7',
+        '\\'                 : '\U000022c5',
+        '\\'                 : '\U000022c6',
+        '\\'               : '\U00002219',
+        '\\'                 : '\U00002218',
+        '\\'               : '\U00002020',
+        '\\'              : '\U00002021',
+        '\\'                  : '\U000022b2',
+        '\\'                  : '\U000022b3',
+        '\\'                : '\U000022b4',
+        '\\'                : '\U000022b5',
+        '\\'         : '\U000025c3',
+        '\\'        : '\U000025b9',
+        '\\'             : '\U000025b3',
+        '\\'            : '\U0000225c',
+        '\\'                : '\U00002295',
+        '\\'                : '\U00002a01',
+        '\\'               : '\U00002297',
+        '\\'               : '\U00002a02',
+        '\\'                 : '\U00002299',
+        '\\'                 : '\U00002a00',
+        '\\'               : '\U00002296',
+        '\\'               : '\U00002298',
+        '\\'                 : '\U00002026',
+        '\\'                : '\U000022ef',
+        '\\'                  : '\U00002211',
+        '\\'                 : '\U0000220f',
+        '\\'               : '\U00002210',
+        '\\'             : '\U0000221e',
+        '\\'             : '\U0000222b',
+        '\\'            : '\U0000222e',
+        '\\'             : '\U00002663',
+        '\\'          : '\U00002662',
+        '\\'            : '\U00002661',
+        '\\'            : '\U00002660',
+        '\\'                : '\U00002135',
+        '\\'             : '\U00002205',
+        '\\'                : '\U00002207',
+        '\\'              : '\U00002202',
+        '\\'                 : '\U0000266d',
+        '\\'              : '\U0000266e',
+        '\\'                : '\U0000266f',
+        '\\'                : '\U00002220',
+        '\\'            : '\U000000a9',
+        '\\'           : '\U000000ae',
+        '\\'               : '\U000000ad',
+        '\\'              : '\U000000af',
+        '\\'           : '\U000000bc',
+        '\\'              : '\U000000bd',
+        '\\'        : '\U000000be',
+        '\\'          : '\U000000aa',
+        '\\'         : '\U000000ba',
+        '\\
'              : '\U000000a7',
+        '\\'            : '\U000000b6',
+        '\\'           : '\U000000a1',
+        '\\'         : '\U000000bf',
+        '\\'                 : '\U000020ac',
+        '\\'               : '\U000000a3',
+        '\\'                  : '\U000000a5',
+        '\\'                 : '\U000000a2',
+        '\\'             : '\U000000a4',
+        '\\'               : '\U000000b0',
+        '\\'                : '\U00002a3f',
+        '\\'                  : '\U00002127',
+        '\\'              : '\U000025ca',
+        '\\'                   : '\U00002118',
+        '\\'                : '\U00002240',
+        '\\'               : '\U000022c4',
+        '\\'                : '\U000000b4',
+        '\\'                : '\U00000131',
+        '\\'             : '\U000000a8',
+        '\\'              : '\U000000b8',
+        '\\'         : '\U000002dd',
+        '\\'                 : '\U000003f5',
+        '\\'              : '\U000023ce',
+        '\\'                 : '\U00002039',
+        '\\'                : '\U0000203a',
+        '\\'                 : '\U00002302',
+        '\\<^sub>'                 : '\U000021e9',
+        '\\<^sup>'                 : '\U000021e7',
+        '\\<^bold>'                : '\U00002759',
+        '\\<^bsub>'                : '\U000021d8',
+        '\\<^esub>'                : '\U000021d9',
+        '\\<^bsup>'                : '\U000021d7',
+        '\\<^esup>'                : '\U000021d6',
+    }
+
+    lang_map = {'isabelle' : isabelle_symbols, 'latex' : latex_symbols}
+
+    def __init__(self, **options):
+        Filter.__init__(self, **options)
+        lang = get_choice_opt(options, 'lang',
+                              ['isabelle', 'latex'], 'isabelle')
+        self.symbols = self.lang_map[lang]
+
+    def filter(self, lexer, stream):
+        for ttype, value in stream:
+            if value in self.symbols:
+                yield ttype, self.symbols[value]
+            else:
+                yield ttype, value
+
+
+class KeywordCaseFilter(Filter):
+    """Convert keywords to lowercase or uppercase or capitalize them, which
+    means first letter uppercase, rest lowercase.
+
+    This can be useful e.g. if you highlight Pascal code and want to adapt the
+    code to your styleguide.
+
+    Options accepted:
+
+    `case` : string
+       The casing to convert keywords to. Must be one of ``'lower'``,
+       ``'upper'`` or ``'capitalize'``.  The default is ``'lower'``.
+    """
+
+    def __init__(self, **options):
+        Filter.__init__(self, **options)
+        case = get_choice_opt(options, 'case',
+                              ['lower', 'upper', 'capitalize'], 'lower')
+        self.convert = getattr(str, case)
+
+    def filter(self, lexer, stream):
+        for ttype, value in stream:
+            if ttype in Keyword:
+                yield ttype, self.convert(value)
+            else:
+                yield ttype, value
+
+
+class NameHighlightFilter(Filter):
+    """Highlight a normal Name (and Name.*) token with a different token type.
+
+    Example::
+
+        filter = NameHighlightFilter(
+            names=['foo', 'bar', 'baz'],
+            tokentype=Name.Function,
+        )
+
+    This would highlight the names "foo", "bar" and "baz"
+    as functions. `Name.Function` is the default token type.
+
+    Options accepted:
+
+    `names` : list of strings
+      A list of names that should be given the different token type.
+      There is no default.
+    `tokentype` : TokenType or string
+      A token type or a string containing a token type name that is
+      used for highlighting the strings in `names`.  The default is
+      `Name.Function`.
+    """
+
+    def __init__(self, **options):
+        Filter.__init__(self, **options)
+        self.names = set(get_list_opt(options, 'names', []))
+        tokentype = options.get('tokentype')
+        if tokentype:
+            self.tokentype = string_to_tokentype(tokentype)
+        else:
+            self.tokentype = Name.Function
+
+    def filter(self, lexer, stream):
+        for ttype, value in stream:
+            if ttype in Name and value in self.names:
+                yield self.tokentype, value
+            else:
+                yield ttype, value
+
+
+class ErrorToken(Exception):
+    pass
+
+
+class RaiseOnErrorTokenFilter(Filter):
+    """Raise an exception when the lexer generates an error token.
+
+    Options accepted:
+
+    `excclass` : Exception class
+      The exception class to raise.
+      The default is `pygments.filters.ErrorToken`.
+
+    .. versionadded:: 0.8
+    """
+
+    def __init__(self, **options):
+        Filter.__init__(self, **options)
+        self.exception = options.get('excclass', ErrorToken)
+        try:
+            # issubclass() will raise TypeError if first argument is not a class
+            if not issubclass(self.exception, Exception):
+                raise TypeError
+        except TypeError:
+            raise OptionError('excclass option is not an exception class')
+
+    def filter(self, lexer, stream):
+        for ttype, value in stream:
+            if ttype is Error:
+                raise self.exception(value)
+            yield ttype, value
+
+
+class VisibleWhitespaceFilter(Filter):
+    """Convert tabs, newlines and/or spaces to visible characters.
+
+    Options accepted:
+
+    `spaces` : string or bool
+      If this is a one-character string, spaces will be replaces by this string.
+      If it is another true value, spaces will be replaced by ``·`` (unicode
+      MIDDLE DOT).  If it is a false value, spaces will not be replaced.  The
+      default is ``False``.
+    `tabs` : string or bool
+      The same as for `spaces`, but the default replacement character is ``»``
+      (unicode RIGHT-POINTING DOUBLE ANGLE QUOTATION MARK).  The default value
+      is ``False``.  Note: this will not work if the `tabsize` option for the
+      lexer is nonzero, as tabs will already have been expanded then.
+    `tabsize` : int
+      If tabs are to be replaced by this filter (see the `tabs` option), this
+      is the total number of characters that a tab should be expanded to.
+      The default is ``8``.
+    `newlines` : string or bool
+      The same as for `spaces`, but the default replacement character is ``¶``
+      (unicode PILCROW SIGN).  The default value is ``False``.
+    `wstokentype` : bool
+      If true, give whitespace the special `Whitespace` token type.  This allows
+      styling the visible whitespace differently (e.g. greyed out), but it can
+      disrupt background colors.  The default is ``True``.
+
+    .. versionadded:: 0.8
+    """
+
+    def __init__(self, **options):
+        Filter.__init__(self, **options)
+        for name, default in [('spaces',   '·'),
+                              ('tabs',     '»'),
+                              ('newlines', '¶')]:
+            opt = options.get(name, False)
+            if isinstance(opt, str) and len(opt) == 1:
+                setattr(self, name, opt)
+            else:
+                setattr(self, name, (opt and default or ''))
+        tabsize = get_int_opt(options, 'tabsize', 8)
+        if self.tabs:
+            self.tabs += ' ' * (tabsize - 1)
+        if self.newlines:
+            self.newlines += '\n'
+        self.wstt = get_bool_opt(options, 'wstokentype', True)
+
+    def filter(self, lexer, stream):
+        if self.wstt:
+            spaces = self.spaces or ' '
+            tabs = self.tabs or '\t'
+            newlines = self.newlines or '\n'
+            regex = re.compile(r'\s')
+
+            def replacefunc(wschar):
+                if wschar == ' ':
+                    return spaces
+                elif wschar == '\t':
+                    return tabs
+                elif wschar == '\n':
+                    return newlines
+                return wschar
+
+            for ttype, value in stream:
+                yield from _replace_special(ttype, value, regex, Whitespace,
+                                            replacefunc)
+        else:
+            spaces, tabs, newlines = self.spaces, self.tabs, self.newlines
+            # simpler processing
+            for ttype, value in stream:
+                if spaces:
+                    value = value.replace(' ', spaces)
+                if tabs:
+                    value = value.replace('\t', tabs)
+                if newlines:
+                    value = value.replace('\n', newlines)
+                yield ttype, value
+
+
+class GobbleFilter(Filter):
+    """Gobbles source code lines (eats initial characters).
+
+    This filter drops the first ``n`` characters off every line of code.  This
+    may be useful when the source code fed to the lexer is indented by a fixed
+    amount of space that isn't desired in the output.
+
+    Options accepted:
+
+    `n` : int
+       The number of characters to gobble.
+
+    .. versionadded:: 1.2
+    """
+    def __init__(self, **options):
+        Filter.__init__(self, **options)
+        self.n = get_int_opt(options, 'n', 0)
+
+    def gobble(self, value, left):
+        if left < len(value):
+            return value[left:], 0
+        else:
+            return '', left - len(value)
+
+    def filter(self, lexer, stream):
+        n = self.n
+        left = n  # How many characters left to gobble.
+        for ttype, value in stream:
+            # Remove ``left`` tokens from first line, ``n`` from all others.
+            parts = value.split('\n')
+            (parts[0], left) = self.gobble(parts[0], left)
+            for i in range(1, len(parts)):
+                (parts[i], left) = self.gobble(parts[i], n)
+            value = '\n'.join(parts)
+
+            if value != '':
+                yield ttype, value
+
+
+class TokenMergeFilter(Filter):
+    """Merges consecutive tokens with the same token type in the output
+    stream of a lexer.
+
+    .. versionadded:: 1.2
+    """
+    def __init__(self, **options):
+        Filter.__init__(self, **options)
+
+    def filter(self, lexer, stream):
+        current_type = None
+        current_value = None
+        for ttype, value in stream:
+            if ttype is current_type:
+                current_value += value
+            else:
+                if current_type is not None:
+                    yield current_type, current_value
+                current_type = ttype
+                current_value = value
+        if current_type is not None:
+            yield current_type, current_value
+
+
+FILTERS = {
+    'codetagify':     CodeTagFilter,
+    'keywordcase':    KeywordCaseFilter,
+    'highlight':      NameHighlightFilter,
+    'raiseonerror':   RaiseOnErrorTokenFilter,
+    'whitespace':     VisibleWhitespaceFilter,
+    'gobble':         GobbleFilter,
+    'tokenmerge':     TokenMergeFilter,
+    'symbols':        SymbolFilter,
+}
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/pygments/filters/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_vendor/pygments/filters/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 00000000..00a09fd4
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_vendor/pygments/filters/__pycache__/__init__.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/pygments/formatter.py b/venv/lib/python3.12/site-packages/pip/_vendor/pygments/formatter.py
new file mode 100644
index 00000000..d2666037
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_vendor/pygments/formatter.py
@@ -0,0 +1,129 @@
+"""
+    pygments.formatter
+    ~~~~~~~~~~~~~~~~~~
+
+    Base formatter class.
+
+    :copyright: Copyright 2006-2024 by the Pygments team, see AUTHORS.
+    :license: BSD, see LICENSE for details.
+"""
+
+import codecs
+
+from pip._vendor.pygments.util import get_bool_opt
+from pip._vendor.pygments.styles import get_style_by_name
+
+__all__ = ['Formatter']
+
+
+def _lookup_style(style):
+    if isinstance(style, str):
+        return get_style_by_name(style)
+    return style
+
+
+class Formatter:
+    """
+    Converts a token stream to text.
+
+    Formatters should have attributes to help selecting them. These
+    are similar to the corresponding :class:`~pygments.lexer.Lexer`
+    attributes.
+
+    .. autoattribute:: name
+       :no-value:
+
+    .. autoattribute:: aliases
+       :no-value:
+
+    .. autoattribute:: filenames
+       :no-value:
+
+    You can pass options as keyword arguments to the constructor.
+    All formatters accept these basic options:
+
+    ``style``
+        The style to use, can be a string or a Style subclass
+        (default: "default"). Not used by e.g. the
+        TerminalFormatter.
+    ``full``
+        Tells the formatter to output a "full" document, i.e.
+        a complete self-contained document. This doesn't have
+        any effect for some formatters (default: false).
+    ``title``
+        If ``full`` is true, the title that should be used to
+        caption the document (default: '').
+    ``encoding``
+        If given, must be an encoding name. This will be used to
+        convert the Unicode token strings to byte strings in the
+        output. If it is "" or None, Unicode strings will be written
+        to the output file, which most file-like objects do not
+        support (default: None).
+    ``outencoding``
+        Overrides ``encoding`` if given.
+
+    """
+
+    #: Full name for the formatter, in human-readable form.
+    name = None
+
+    #: A list of short, unique identifiers that can be used to lookup
+    #: the formatter from a list, e.g. using :func:`.get_formatter_by_name()`.
+    aliases = []
+
+    #: A list of fnmatch patterns that match filenames for which this
+    #: formatter can produce output. The patterns in this list should be unique
+    #: among all formatters.
+    filenames = []
+
+    #: If True, this formatter outputs Unicode strings when no encoding
+    #: option is given.
+    unicodeoutput = True
+
+    def __init__(self, **options):
+        """
+        As with lexers, this constructor takes arbitrary optional arguments,
+        and if you override it, you should first process your own options, then
+        call the base class implementation.
+        """
+        self.style = _lookup_style(options.get('style', 'default'))
+        self.full = get_bool_opt(options, 'full', False)
+        self.title = options.get('title', '')
+        self.encoding = options.get('encoding', None) or None
+        if self.encoding in ('guess', 'chardet'):
+            # can happen for e.g. pygmentize -O encoding=guess
+            self.encoding = 'utf-8'
+        self.encoding = options.get('outencoding') or self.encoding
+        self.options = options
+
+    def get_style_defs(self, arg=''):
+        """
+        This method must return statements or declarations suitable to define
+        the current style for subsequent highlighted text (e.g. CSS classes
+        in the `HTMLFormatter`).
+
+        The optional argument `arg` can be used to modify the generation and
+        is formatter dependent (it is standardized because it can be given on
+        the command line).
+
+        This method is called by the ``-S`` :doc:`command-line option `,
+        the `arg` is then given by the ``-a`` option.
+        """
+        return ''
+
+    def format(self, tokensource, outfile):
+        """
+        This method must format the tokens from the `tokensource` iterable and
+        write the formatted version to the file object `outfile`.
+
+        Formatter options can control how exactly the tokens are converted.
+        """
+        if self.encoding:
+            # wrap the outfile in a StreamWriter
+            outfile = codecs.lookup(self.encoding)[3](outfile)
+        return self.format_unencoded(tokensource, outfile)
+
+    # Allow writing Formatter[str] or Formatter[bytes]. That's equivalent to
+    # Formatter. This helps when using third-party type stubs from typeshed.
+    def __class_getitem__(cls, name):
+        return cls
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/pygments/formatters/__init__.py b/venv/lib/python3.12/site-packages/pip/_vendor/pygments/formatters/__init__.py
new file mode 100644
index 00000000..f19e9931
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_vendor/pygments/formatters/__init__.py
@@ -0,0 +1,157 @@
+"""
+    pygments.formatters
+    ~~~~~~~~~~~~~~~~~~~
+
+    Pygments formatters.
+
+    :copyright: Copyright 2006-2024 by the Pygments team, see AUTHORS.
+    :license: BSD, see LICENSE for details.
+"""
+
+import re
+import sys
+import types
+import fnmatch
+from os.path import basename
+
+from pip._vendor.pygments.formatters._mapping import FORMATTERS
+from pip._vendor.pygments.plugin import find_plugin_formatters
+from pip._vendor.pygments.util import ClassNotFound
+
+__all__ = ['get_formatter_by_name', 'get_formatter_for_filename',
+           'get_all_formatters', 'load_formatter_from_file'] + list(FORMATTERS)
+
+_formatter_cache = {}  # classes by name
+_pattern_cache = {}
+
+
+def _fn_matches(fn, glob):
+    """Return whether the supplied file name fn matches pattern filename."""
+    if glob not in _pattern_cache:
+        pattern = _pattern_cache[glob] = re.compile(fnmatch.translate(glob))
+        return pattern.match(fn)
+    return _pattern_cache[glob].match(fn)
+
+
+def _load_formatters(module_name):
+    """Load a formatter (and all others in the module too)."""
+    mod = __import__(module_name, None, None, ['__all__'])
+    for formatter_name in mod.__all__:
+        cls = getattr(mod, formatter_name)
+        _formatter_cache[cls.name] = cls
+
+
+def get_all_formatters():
+    """Return a generator for all formatter classes."""
+    # NB: this returns formatter classes, not info like get_all_lexers().
+    for info in FORMATTERS.values():
+        if info[1] not in _formatter_cache:
+            _load_formatters(info[0])
+        yield _formatter_cache[info[1]]
+    for _, formatter in find_plugin_formatters():
+        yield formatter
+
+
+def find_formatter_class(alias):
+    """Lookup a formatter by alias.
+
+    Returns None if not found.
+    """
+    for module_name, name, aliases, _, _ in FORMATTERS.values():
+        if alias in aliases:
+            if name not in _formatter_cache:
+                _load_formatters(module_name)
+            return _formatter_cache[name]
+    for _, cls in find_plugin_formatters():
+        if alias in cls.aliases:
+            return cls
+
+
+def get_formatter_by_name(_alias, **options):
+    """
+    Return an instance of a :class:`.Formatter` subclass that has `alias` in its
+    aliases list. The formatter is given the `options` at its instantiation.
+
+    Will raise :exc:`pygments.util.ClassNotFound` if no formatter with that
+    alias is found.
+    """
+    cls = find_formatter_class(_alias)
+    if cls is None:
+        raise ClassNotFound(f"no formatter found for name {_alias!r}")
+    return cls(**options)
+
+
+def load_formatter_from_file(filename, formattername="CustomFormatter", **options):
+    """
+    Return a `Formatter` subclass instance loaded from the provided file, relative
+    to the current directory.
+
+    The file is expected to contain a Formatter class named ``formattername``
+    (by default, CustomFormatter). Users should be very careful with the input, because
+    this method is equivalent to running ``eval()`` on the input file. The formatter is
+    given the `options` at its instantiation.
+
+    :exc:`pygments.util.ClassNotFound` is raised if there are any errors loading
+    the formatter.
+
+    .. versionadded:: 2.2
+    """
+    try:
+        # This empty dict will contain the namespace for the exec'd file
+        custom_namespace = {}
+        with open(filename, 'rb') as f:
+            exec(f.read(), custom_namespace)
+        # Retrieve the class `formattername` from that namespace
+        if formattername not in custom_namespace:
+            raise ClassNotFound(f'no valid {formattername} class found in {filename}')
+        formatter_class = custom_namespace[formattername]
+        # And finally instantiate it with the options
+        return formatter_class(**options)
+    except OSError as err:
+        raise ClassNotFound(f'cannot read {filename}: {err}')
+    except ClassNotFound:
+        raise
+    except Exception as err:
+        raise ClassNotFound(f'error when loading custom formatter: {err}')
+
+
+def get_formatter_for_filename(fn, **options):
+    """
+    Return a :class:`.Formatter` subclass instance that has a filename pattern
+    matching `fn`. The formatter is given the `options` at its instantiation.
+
+    Will raise :exc:`pygments.util.ClassNotFound` if no formatter for that filename
+    is found.
+    """
+    fn = basename(fn)
+    for modname, name, _, filenames, _ in FORMATTERS.values():
+        for filename in filenames:
+            if _fn_matches(fn, filename):
+                if name not in _formatter_cache:
+                    _load_formatters(modname)
+                return _formatter_cache[name](**options)
+    for _name, cls in find_plugin_formatters():
+        for filename in cls.filenames:
+            if _fn_matches(fn, filename):
+                return cls(**options)
+    raise ClassNotFound(f"no formatter found for file name {fn!r}")
+
+
+class _automodule(types.ModuleType):
+    """Automatically import formatters."""
+
+    def __getattr__(self, name):
+        info = FORMATTERS.get(name)
+        if info:
+            _load_formatters(info[0])
+            cls = _formatter_cache[info[1]]
+            setattr(self, name, cls)
+            return cls
+        raise AttributeError(name)
+
+
+oldmod = sys.modules[__name__]
+newmod = _automodule(__name__)
+newmod.__dict__.update(oldmod.__dict__)
+sys.modules[__name__] = newmod
+del newmod.newmod, newmod.oldmod, newmod.sys, newmod.types
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/pygments/formatters/__pycache__/__init__.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_vendor/pygments/formatters/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 00000000..8b1c2a4e
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_vendor/pygments/formatters/__pycache__/__init__.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/pygments/formatters/__pycache__/_mapping.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_vendor/pygments/formatters/__pycache__/_mapping.cpython-312.pyc
new file mode 100644
index 00000000..bd112cbd
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_vendor/pygments/formatters/__pycache__/_mapping.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/pygments/formatters/__pycache__/bbcode.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_vendor/pygments/formatters/__pycache__/bbcode.cpython-312.pyc
new file mode 100644
index 00000000..303cac0f
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_vendor/pygments/formatters/__pycache__/bbcode.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/pygments/formatters/__pycache__/groff.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_vendor/pygments/formatters/__pycache__/groff.cpython-312.pyc
new file mode 100644
index 00000000..9695812b
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_vendor/pygments/formatters/__pycache__/groff.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/pygments/formatters/__pycache__/html.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_vendor/pygments/formatters/__pycache__/html.cpython-312.pyc
new file mode 100644
index 00000000..0a0f576b
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_vendor/pygments/formatters/__pycache__/html.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/pygments/formatters/__pycache__/img.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_vendor/pygments/formatters/__pycache__/img.cpython-312.pyc
new file mode 100644
index 00000000..7c552909
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_vendor/pygments/formatters/__pycache__/img.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/pygments/formatters/__pycache__/irc.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_vendor/pygments/formatters/__pycache__/irc.cpython-312.pyc
new file mode 100644
index 00000000..674b07ba
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_vendor/pygments/formatters/__pycache__/irc.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/pygments/formatters/__pycache__/latex.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_vendor/pygments/formatters/__pycache__/latex.cpython-312.pyc
new file mode 100644
index 00000000..1277e397
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_vendor/pygments/formatters/__pycache__/latex.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/pygments/formatters/__pycache__/other.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_vendor/pygments/formatters/__pycache__/other.cpython-312.pyc
new file mode 100644
index 00000000..06e23976
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_vendor/pygments/formatters/__pycache__/other.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/pygments/formatters/__pycache__/pangomarkup.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_vendor/pygments/formatters/__pycache__/pangomarkup.cpython-312.pyc
new file mode 100644
index 00000000..7a160a54
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_vendor/pygments/formatters/__pycache__/pangomarkup.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/pygments/formatters/__pycache__/rtf.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_vendor/pygments/formatters/__pycache__/rtf.cpython-312.pyc
new file mode 100644
index 00000000..a683880e
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_vendor/pygments/formatters/__pycache__/rtf.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/pygments/formatters/__pycache__/svg.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_vendor/pygments/formatters/__pycache__/svg.cpython-312.pyc
new file mode 100644
index 00000000..76f8e1ad
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_vendor/pygments/formatters/__pycache__/svg.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/pygments/formatters/__pycache__/terminal.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_vendor/pygments/formatters/__pycache__/terminal.cpython-312.pyc
new file mode 100644
index 00000000..34ad7271
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_vendor/pygments/formatters/__pycache__/terminal.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/pygments/formatters/__pycache__/terminal256.cpython-312.pyc b/venv/lib/python3.12/site-packages/pip/_vendor/pygments/formatters/__pycache__/terminal256.cpython-312.pyc
new file mode 100644
index 00000000..5d97d5be
Binary files /dev/null and b/venv/lib/python3.12/site-packages/pip/_vendor/pygments/formatters/__pycache__/terminal256.cpython-312.pyc differ
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/pygments/formatters/_mapping.py b/venv/lib/python3.12/site-packages/pip/_vendor/pygments/formatters/_mapping.py
new file mode 100644
index 00000000..72ca8404
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_vendor/pygments/formatters/_mapping.py
@@ -0,0 +1,23 @@
+# Automatically generated by scripts/gen_mapfiles.py.
+# DO NOT EDIT BY HAND; run `tox -e mapfiles` instead.
+
+FORMATTERS = {
+    'BBCodeFormatter': ('pygments.formatters.bbcode', 'BBCode', ('bbcode', 'bb'), (), 'Format tokens with BBcodes. These formatting codes are used by many bulletin boards, so you can highlight your sourcecode with pygments before posting it there.'),
+    'BmpImageFormatter': ('pygments.formatters.img', 'img_bmp', ('bmp', 'bitmap'), ('*.bmp',), 'Create a bitmap image from source code. This uses the Python Imaging Library to generate a pixmap from the source code.'),
+    'GifImageFormatter': ('pygments.formatters.img', 'img_gif', ('gif',), ('*.gif',), 'Create a GIF image from source code. This uses the Python Imaging Library to generate a pixmap from the source code.'),
+    'GroffFormatter': ('pygments.formatters.groff', 'groff', ('groff', 'troff', 'roff'), (), 'Format tokens with groff escapes to change their color and font style.'),
+    'HtmlFormatter': ('pygments.formatters.html', 'HTML', ('html',), ('*.html', '*.htm'), "Format tokens as HTML 4 ```` tags. By default, the content is enclosed in a ``
`` tag, itself wrapped in a ``
`` tag (but see the `nowrap` option). The ``
``'s CSS class can be set by the `cssclass` option."),
+    'IRCFormatter': ('pygments.formatters.irc', 'IRC', ('irc', 'IRC'), (), 'Format tokens with IRC color sequences'),
+    'ImageFormatter': ('pygments.formatters.img', 'img', ('img', 'IMG', 'png'), ('*.png',), 'Create a PNG image from source code. This uses the Python Imaging Library to generate a pixmap from the source code.'),
+    'JpgImageFormatter': ('pygments.formatters.img', 'img_jpg', ('jpg', 'jpeg'), ('*.jpg',), 'Create a JPEG image from source code. This uses the Python Imaging Library to generate a pixmap from the source code.'),
+    'LatexFormatter': ('pygments.formatters.latex', 'LaTeX', ('latex', 'tex'), ('*.tex',), 'Format tokens as LaTeX code. This needs the `fancyvrb` and `color` standard packages.'),
+    'NullFormatter': ('pygments.formatters.other', 'Text only', ('text', 'null'), ('*.txt',), 'Output the text unchanged without any formatting.'),
+    'PangoMarkupFormatter': ('pygments.formatters.pangomarkup', 'Pango Markup', ('pango', 'pangomarkup'), (), 'Format tokens as Pango Markup code. It can then be rendered to an SVG.'),
+    'RawTokenFormatter': ('pygments.formatters.other', 'Raw tokens', ('raw', 'tokens'), ('*.raw',), 'Format tokens as a raw representation for storing token streams.'),
+    'RtfFormatter': ('pygments.formatters.rtf', 'RTF', ('rtf',), ('*.rtf',), 'Format tokens as RTF markup. This formatter automatically outputs full RTF documents with color information and other useful stuff. Perfect for Copy and Paste into Microsoft(R) Word(R) documents.'),
+    'SvgFormatter': ('pygments.formatters.svg', 'SVG', ('svg',), ('*.svg',), 'Format tokens as an SVG graphics file.  This formatter is still experimental. Each line of code is a ```` element with explicit ``x`` and ``y`` coordinates containing ```` elements with the individual token styles.'),
+    'Terminal256Formatter': ('pygments.formatters.terminal256', 'Terminal256', ('terminal256', 'console256', '256'), (), 'Format tokens with ANSI color sequences, for output in a 256-color terminal or console.  Like in `TerminalFormatter` color sequences are terminated at newlines, so that paging the output works correctly.'),
+    'TerminalFormatter': ('pygments.formatters.terminal', 'Terminal', ('terminal', 'console'), (), 'Format tokens with ANSI color sequences, for output in a text console. Color sequences are terminated at newlines, so that paging the output works correctly.'),
+    'TerminalTrueColorFormatter': ('pygments.formatters.terminal256', 'TerminalTrueColor', ('terminal16m', 'console16m', '16m'), (), 'Format tokens with ANSI color sequences, for output in a true-color terminal or console.  Like in `TerminalFormatter` color sequences are terminated at newlines, so that paging the output works correctly.'),
+    'TestcaseFormatter': ('pygments.formatters.other', 'Testcase', ('testcase',), (), 'Format tokens as appropriate for a new testcase.'),
+}
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/pygments/formatters/bbcode.py b/venv/lib/python3.12/site-packages/pip/_vendor/pygments/formatters/bbcode.py
new file mode 100644
index 00000000..5a05bd96
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_vendor/pygments/formatters/bbcode.py
@@ -0,0 +1,108 @@
+"""
+    pygments.formatters.bbcode
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    BBcode formatter.
+
+    :copyright: Copyright 2006-2024 by the Pygments team, see AUTHORS.
+    :license: BSD, see LICENSE for details.
+"""
+
+
+from pip._vendor.pygments.formatter import Formatter
+from pip._vendor.pygments.util import get_bool_opt
+
+__all__ = ['BBCodeFormatter']
+
+
+class BBCodeFormatter(Formatter):
+    """
+    Format tokens with BBcodes. These formatting codes are used by many
+    bulletin boards, so you can highlight your sourcecode with pygments before
+    posting it there.
+
+    This formatter has no support for background colors and borders, as there
+    are no common BBcode tags for that.
+
+    Some board systems (e.g. phpBB) don't support colors in their [code] tag,
+    so you can't use the highlighting together with that tag.
+    Text in a [code] tag usually is shown with a monospace font (which this
+    formatter can do with the ``monofont`` option) and no spaces (which you
+    need for indentation) are removed.
+
+    Additional options accepted:
+
+    `style`
+        The style to use, can be a string or a Style subclass (default:
+        ``'default'``).
+
+    `codetag`
+        If set to true, put the output into ``[code]`` tags (default:
+        ``false``)
+
+    `monofont`
+        If set to true, add a tag to show the code with a monospace font
+        (default: ``false``).
+    """
+    name = 'BBCode'
+    aliases = ['bbcode', 'bb']
+    filenames = []
+
+    def __init__(self, **options):
+        Formatter.__init__(self, **options)
+        self._code = get_bool_opt(options, 'codetag', False)
+        self._mono = get_bool_opt(options, 'monofont', False)
+
+        self.styles = {}
+        self._make_styles()
+
+    def _make_styles(self):
+        for ttype, ndef in self.style:
+            start = end = ''
+            if ndef['color']:
+                start += '[color=#{}]'.format(ndef['color'])
+                end = '[/color]' + end
+            if ndef['bold']:
+                start += '[b]'
+                end = '[/b]' + end
+            if ndef['italic']:
+                start += '[i]'
+                end = '[/i]' + end
+            if ndef['underline']:
+                start += '[u]'
+                end = '[/u]' + end
+            # there are no common BBcodes for background-color and border
+
+            self.styles[ttype] = start, end
+
+    def format_unencoded(self, tokensource, outfile):
+        if self._code:
+            outfile.write('[code]')
+        if self._mono:
+            outfile.write('[font=monospace]')
+
+        lastval = ''
+        lasttype = None
+
+        for ttype, value in tokensource:
+            while ttype not in self.styles:
+                ttype = ttype.parent
+            if ttype == lasttype:
+                lastval += value
+            else:
+                if lastval:
+                    start, end = self.styles[lasttype]
+                    outfile.write(''.join((start, lastval, end)))
+                lastval = value
+                lasttype = ttype
+
+        if lastval:
+            start, end = self.styles[lasttype]
+            outfile.write(''.join((start, lastval, end)))
+
+        if self._mono:
+            outfile.write('[/font]')
+        if self._code:
+            outfile.write('[/code]')
+        if self._code or self._mono:
+            outfile.write('\n')
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/pygments/formatters/groff.py b/venv/lib/python3.12/site-packages/pip/_vendor/pygments/formatters/groff.py
new file mode 100644
index 00000000..5c8a958f
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_vendor/pygments/formatters/groff.py
@@ -0,0 +1,170 @@
+"""
+    pygments.formatters.groff
+    ~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    Formatter for groff output.
+
+    :copyright: Copyright 2006-2024 by the Pygments team, see AUTHORS.
+    :license: BSD, see LICENSE for details.
+"""
+
+import math
+from pip._vendor.pygments.formatter import Formatter
+from pip._vendor.pygments.util import get_bool_opt, get_int_opt
+
+__all__ = ['GroffFormatter']
+
+
+class GroffFormatter(Formatter):
+    """
+    Format tokens with groff escapes to change their color and font style.
+
+    .. versionadded:: 2.11
+
+    Additional options accepted:
+
+    `style`
+        The style to use, can be a string or a Style subclass (default:
+        ``'default'``).
+
+    `monospaced`
+        If set to true, monospace font will be used (default: ``true``).
+
+    `linenos`
+        If set to true, print the line numbers (default: ``false``).
+
+    `wrap`
+        Wrap lines to the specified number of characters. Disabled if set to 0
+        (default: ``0``).
+    """
+
+    name = 'groff'
+    aliases = ['groff','troff','roff']
+    filenames = []
+
+    def __init__(self, **options):
+        Formatter.__init__(self, **options)
+
+        self.monospaced = get_bool_opt(options, 'monospaced', True)
+        self.linenos = get_bool_opt(options, 'linenos', False)
+        self._lineno = 0
+        self.wrap = get_int_opt(options, 'wrap', 0)
+        self._linelen = 0
+
+        self.styles = {}
+        self._make_styles()
+
+
+    def _make_styles(self):
+        regular = '\\f[CR]' if self.monospaced else '\\f[R]'
+        bold = '\\f[CB]' if self.monospaced else '\\f[B]'
+        italic = '\\f[CI]' if self.monospaced else '\\f[I]'
+
+        for ttype, ndef in self.style:
+            start = end = ''
+            if ndef['color']:
+                start += '\\m[{}]'.format(ndef['color'])
+                end = '\\m[]' + end
+            if ndef['bold']:
+                start += bold
+                end = regular + end
+            if ndef['italic']:
+                start += italic
+                end = regular + end
+            if ndef['bgcolor']:
+                start += '\\M[{}]'.format(ndef['bgcolor'])
+                end = '\\M[]' + end
+
+            self.styles[ttype] = start, end
+
+
+    def _define_colors(self, outfile):
+        colors = set()
+        for _, ndef in self.style:
+            if ndef['color'] is not None:
+                colors.add(ndef['color'])
+
+        for color in sorted(colors):
+            outfile.write('.defcolor ' + color + ' rgb #' + color + '\n')
+
+
+    def _write_lineno(self, outfile):
+        self._lineno += 1
+        outfile.write("%s% 4d " % (self._lineno != 1 and '\n' or '', self._lineno))
+
+
+    def _wrap_line(self, line):
+        length = len(line.rstrip('\n'))
+        space = '     ' if self.linenos else ''
+        newline = ''
+
+        if length > self.wrap:
+            for i in range(0, math.floor(length / self.wrap)):
+                chunk = line[i*self.wrap:i*self.wrap+self.wrap]
+                newline += (chunk + '\n' + space)
+            remainder = length % self.wrap
+            if remainder > 0:
+                newline += line[-remainder-1:]
+                self._linelen = remainder
+        elif self._linelen + length > self.wrap:
+            newline = ('\n' + space) + line
+            self._linelen = length
+        else:
+            newline = line
+            self._linelen += length
+
+        return newline
+
+
+    def _escape_chars(self, text):
+        text = text.replace('\\', '\\[u005C]'). \
+                    replace('.', '\\[char46]'). \
+                    replace('\'', '\\[u0027]'). \
+                    replace('`', '\\[u0060]'). \
+                    replace('~', '\\[u007E]')
+        copy = text
+
+        for char in copy:
+            if len(char) != len(char.encode()):
+                uni = char.encode('unicode_escape') \
+                    .decode()[1:] \
+                    .replace('x', 'u00') \
+                    .upper()
+                text = text.replace(char, '\\[u' + uni[1:] + ']')
+
+        return text
+
+
+    def format_unencoded(self, tokensource, outfile):
+        self._define_colors(outfile)
+
+        outfile.write('.nf\n\\f[CR]\n')
+
+        if self.linenos:
+            self._write_lineno(outfile)
+
+        for ttype, value in tokensource:
+            while ttype not in self.styles:
+                ttype = ttype.parent
+            start, end = self.styles[ttype]
+
+            for line in value.splitlines(True):
+                if self.wrap > 0:
+                    line = self._wrap_line(line)
+
+                if start and end:
+                    text = self._escape_chars(line.rstrip('\n'))
+                    if text != '':
+                        outfile.write(''.join((start, text, end)))
+                else:
+                    outfile.write(self._escape_chars(line.rstrip('\n')))
+
+                if line.endswith('\n'):
+                    if self.linenos:
+                        self._write_lineno(outfile)
+                        self._linelen = 0
+                    else:
+                        outfile.write('\n')
+                        self._linelen = 0
+
+        outfile.write('\n.fi')
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/pygments/formatters/html.py b/venv/lib/python3.12/site-packages/pip/_vendor/pygments/formatters/html.py
new file mode 100644
index 00000000..7aa938f5
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_vendor/pygments/formatters/html.py
@@ -0,0 +1,987 @@
+"""
+    pygments.formatters.html
+    ~~~~~~~~~~~~~~~~~~~~~~~~
+
+    Formatter for HTML output.
+
+    :copyright: Copyright 2006-2024 by the Pygments team, see AUTHORS.
+    :license: BSD, see LICENSE for details.
+"""
+
+import functools
+import os
+import sys
+import os.path
+from io import StringIO
+
+from pip._vendor.pygments.formatter import Formatter
+from pip._vendor.pygments.token import Token, Text, STANDARD_TYPES
+from pip._vendor.pygments.util import get_bool_opt, get_int_opt, get_list_opt
+
+try:
+    import ctags
+except ImportError:
+    ctags = None
+
+__all__ = ['HtmlFormatter']
+
+
+_escape_html_table = {
+    ord('&'): '&',
+    ord('<'): '<',
+    ord('>'): '>',
+    ord('"'): '"',
+    ord("'"): ''',
+}
+
+
+def escape_html(text, table=_escape_html_table):
+    """Escape &, <, > as well as single and double quotes for HTML."""
+    return text.translate(table)
+
+
+def webify(color):
+    if color.startswith('calc') or color.startswith('var'):
+        return color
+    else:
+        return '#' + color
+
+
+def _get_ttype_class(ttype):
+    fname = STANDARD_TYPES.get(ttype)
+    if fname:
+        return fname
+    aname = ''
+    while fname is None:
+        aname = '-' + ttype[-1] + aname
+        ttype = ttype.parent
+        fname = STANDARD_TYPES.get(ttype)
+    return fname + aname
+
+
+CSSFILE_TEMPLATE = '''\
+/*
+generated by Pygments 
+Copyright 2006-2024 by the Pygments team.
+Licensed under the BSD license, see LICENSE for details.
+*/
+%(styledefs)s
+'''
+
+DOC_HEADER = '''\
+
+
+
+
+  %(title)s
+  
+  
+
+
+
%(title)s

+
+'''
+
+DOC_HEADER_EXTERNALCSS = '''\
+
+
+
+
+  %(title)s
+  
+  
+
+
+
%(title)s

+
+'''
+
+DOC_FOOTER = '''\
+
+
+'''
+
+
+class HtmlFormatter(Formatter):
+    r"""
+    Format tokens as HTML 4 ```` tags. By default, the content is enclosed
+    in a ``
`` tag, itself wrapped in a ``
`` tag (but see the `nowrap` option).
+    The ``
``'s CSS class can be set by the `cssclass` option.
+
+    If the `linenos` option is set to ``"table"``, the ``
`` is
+    additionally wrapped inside a ```` which has one row and two
+    cells: one containing the line numbers and one containing the code.
+    Example:
+
+    .. sourcecode:: html
+
+        

+        

+          
+          
+        

+            
1
+            2

+          		
+            
def foo(bar):
+              pass
+            

+          

+
+    (whitespace added to improve clarity).
+
+    A list of lines can be specified using the `hl_lines` option to make these
+    lines highlighted (as of Pygments 0.11).
+
+    With the `full` option, a complete HTML 4 document is output, including
+    the style definitions inside a ``
+
+
+    
{code}

+
+
+"""
+
+CONSOLE_SVG_FORMAT = """\
+
+    
+    
+
+    
+    
+      
+    
+    {lines}
+    
+
+    {chrome}
+    
+    {backgrounds}
+    
+    {matrix}
+    
+    
+
+"""
+
+_SVG_FONT_FAMILY = "Rich Fira Code"
+_SVG_CLASSES_PREFIX = "rich-svg"
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/rich/_extension.py b/venv/lib/python3.12/site-packages/pip/_vendor/rich/_extension.py
new file mode 100644
index 00000000..cbd6da9b
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_vendor/rich/_extension.py
@@ -0,0 +1,10 @@
+from typing import Any
+
+
+def load_ipython_extension(ip: Any) -> None:  # pragma: no cover
+    # prevent circular import
+    from pip._vendor.rich.pretty import install
+    from pip._vendor.rich.traceback import install as tr_install
+
+    install()
+    tr_install()
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/rich/_fileno.py b/venv/lib/python3.12/site-packages/pip/_vendor/rich/_fileno.py
new file mode 100644
index 00000000..b17ee651
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_vendor/rich/_fileno.py
@@ -0,0 +1,24 @@
+from __future__ import annotations
+
+from typing import IO, Callable
+
+
+def get_fileno(file_like: IO[str]) -> int | None:
+    """Get fileno() from a file, accounting for poorly implemented file-like objects.
+
+    Args:
+        file_like (IO): A file-like object.
+
+    Returns:
+        int | None: The result of fileno if available, or None if operation failed.
+    """
+    fileno: Callable[[], int] | None = getattr(file_like, "fileno", None)
+    if fileno is not None:
+        try:
+            return fileno()
+        except Exception:
+            # `fileno` is documented as potentially raising a OSError
+            # Alas, from the issues, there are so many poorly implemented file-like objects,
+            # that `fileno()` can raise just about anything.
+            return None
+    return None
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/rich/_inspect.py b/venv/lib/python3.12/site-packages/pip/_vendor/rich/_inspect.py
new file mode 100644
index 00000000..30446ceb
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_vendor/rich/_inspect.py
@@ -0,0 +1,270 @@
+from __future__ import absolute_import
+
+import inspect
+from inspect import cleandoc, getdoc, getfile, isclass, ismodule, signature
+from typing import Any, Collection, Iterable, Optional, Tuple, Type, Union
+
+from .console import Group, RenderableType
+from .control import escape_control_codes
+from .highlighter import ReprHighlighter
+from .jupyter import JupyterMixin
+from .panel import Panel
+from .pretty import Pretty
+from .table import Table
+from .text import Text, TextType
+
+
+def _first_paragraph(doc: str) -> str:
+    """Get the first paragraph from a docstring."""
+    paragraph, _, _ = doc.partition("\n\n")
+    return paragraph
+
+
+class Inspect(JupyterMixin):
+    """A renderable to inspect any Python Object.
+
+    Args:
+        obj (Any): An object to inspect.
+        title (str, optional): Title to display over inspect result, or None use type. Defaults to None.
+        help (bool, optional): Show full help text rather than just first paragraph. Defaults to False.
+        methods (bool, optional): Enable inspection of callables. Defaults to False.
+        docs (bool, optional): Also render doc strings. Defaults to True.
+        private (bool, optional): Show private attributes (beginning with underscore). Defaults to False.
+        dunder (bool, optional): Show attributes starting with double underscore. Defaults to False.
+        sort (bool, optional): Sort attributes alphabetically. Defaults to True.
+        all (bool, optional): Show all attributes. Defaults to False.
+        value (bool, optional): Pretty print value of object. Defaults to True.
+    """
+
+    def __init__(
+        self,
+        obj: Any,
+        *,
+        title: Optional[TextType] = None,
+        help: bool = False,
+        methods: bool = False,
+        docs: bool = True,
+        private: bool = False,
+        dunder: bool = False,
+        sort: bool = True,
+        all: bool = True,
+        value: bool = True,
+    ) -> None:
+        self.highlighter = ReprHighlighter()
+        self.obj = obj
+        self.title = title or self._make_title(obj)
+        if all:
+            methods = private = dunder = True
+        self.help = help
+        self.methods = methods
+        self.docs = docs or help
+        self.private = private or dunder
+        self.dunder = dunder
+        self.sort = sort
+        self.value = value
+
+    def _make_title(self, obj: Any) -> Text:
+        """Make a default title."""
+        title_str = (
+            str(obj)
+            if (isclass(obj) or callable(obj) or ismodule(obj))
+            else str(type(obj))
+        )
+        title_text = self.highlighter(title_str)
+        return title_text
+
+    def __rich__(self) -> Panel:
+        return Panel.fit(
+            Group(*self._render()),
+            title=self.title,
+            border_style="scope.border",
+            padding=(0, 1),
+        )
+
+    def _get_signature(self, name: str, obj: Any) -> Optional[Text]:
+        """Get a signature for a callable."""
+        try:
+            _signature = str(signature(obj)) + ":"
+        except ValueError:
+            _signature = "(...)"
+        except TypeError:
+            return None
+
+        source_filename: Optional[str] = None
+        try:
+            source_filename = getfile(obj)
+        except (OSError, TypeError):
+            # OSError is raised if obj has no source file, e.g. when defined in REPL.
+            pass
+
+        callable_name = Text(name, style="inspect.callable")
+        if source_filename:
+            callable_name.stylize(f"link file://{source_filename}")
+        signature_text = self.highlighter(_signature)
+
+        qualname = name or getattr(obj, "__qualname__", name)
+
+        # If obj is a module, there may be classes (which are callable) to display
+        if inspect.isclass(obj):
+            prefix = "class"
+        elif inspect.iscoroutinefunction(obj):
+            prefix = "async def"
+        else:
+            prefix = "def"
+
+        qual_signature = Text.assemble(
+            (f"{prefix} ", f"inspect.{prefix.replace(' ', '_')}"),
+            (qualname, "inspect.callable"),
+            signature_text,
+        )
+
+        return qual_signature
+
+    def _render(self) -> Iterable[RenderableType]:
+        """Render object."""
+
+        def sort_items(item: Tuple[str, Any]) -> Tuple[bool, str]:
+            key, (_error, value) = item
+            return (callable(value), key.strip("_").lower())
+
+        def safe_getattr(attr_name: str) -> Tuple[Any, Any]:
+            """Get attribute or any exception."""
+            try:
+                return (None, getattr(obj, attr_name))
+            except Exception as error:
+                return (error, None)
+
+        obj = self.obj
+        keys = dir(obj)
+        total_items = len(keys)
+        if not self.dunder:
+            keys = [key for key in keys if not key.startswith("__")]
+        if not self.private:
+            keys = [key for key in keys if not key.startswith("_")]
+        not_shown_count = total_items - len(keys)
+        items = [(key, safe_getattr(key)) for key in keys]
+        if self.sort:
+            items.sort(key=sort_items)
+
+        items_table = Table.grid(padding=(0, 1), expand=False)
+        items_table.add_column(justify="right")
+        add_row = items_table.add_row
+        highlighter = self.highlighter
+
+        if callable(obj):
+            signature = self._get_signature("", obj)
+            if signature is not None:
+                yield signature
+                yield ""
+
+        if self.docs:
+            _doc = self._get_formatted_doc(obj)
+            if _doc is not None:
+                doc_text = Text(_doc, style="inspect.help")
+                doc_text = highlighter(doc_text)
+                yield doc_text
+                yield ""
+
+        if self.value and not (isclass(obj) or callable(obj) or ismodule(obj)):
+            yield Panel(
+                Pretty(obj, indent_guides=True, max_length=10, max_string=60),
+                border_style="inspect.value.border",
+            )
+            yield ""
+
+        for key, (error, value) in items:
+            key_text = Text.assemble(
+                (
+                    key,
+                    "inspect.attr.dunder" if key.startswith("__") else "inspect.attr",
+                ),
+                (" =", "inspect.equals"),
+            )
+            if error is not None:
+                warning = key_text.copy()
+                warning.stylize("inspect.error")
+                add_row(warning, highlighter(repr(error)))
+                continue
+
+            if callable(value):
+                if not self.methods:
+                    continue
+
+                _signature_text = self._get_signature(key, value)
+                if _signature_text is None:
+                    add_row(key_text, Pretty(value, highlighter=highlighter))
+                else:
+                    if self.docs:
+                        docs = self._get_formatted_doc(value)
+                        if docs is not None:
+                            _signature_text.append("\n" if "\n" in docs else " ")
+                            doc = highlighter(docs)
+                            doc.stylize("inspect.doc")
+                            _signature_text.append(doc)
+
+                    add_row(key_text, _signature_text)
+            else:
+                add_row(key_text, Pretty(value, highlighter=highlighter))
+        if items_table.row_count:
+            yield items_table
+        elif not_shown_count:
+            yield Text.from_markup(
+                f"[b cyan]{not_shown_count}[/][i] attribute(s) not shown.[/i] "
+                f"Run [b][magenta]inspect[/]([not b]inspect[/])[/b] for options."
+            )
+
+    def _get_formatted_doc(self, object_: Any) -> Optional[str]:
+        """
+        Extract the docstring of an object, process it and returns it.
+        The processing consists in cleaning up the doctring's indentation,
+        taking only its 1st paragraph if `self.help` is not True,
+        and escape its control codes.
+
+        Args:
+            object_ (Any): the object to get the docstring from.
+
+        Returns:
+            Optional[str]: the processed docstring, or None if no docstring was found.
+        """
+        docs = getdoc(object_)
+        if docs is None:
+            return None
+        docs = cleandoc(docs).strip()
+        if not self.help:
+            docs = _first_paragraph(docs)
+        return escape_control_codes(docs)
+
+
+def get_object_types_mro(obj: Union[object, Type[Any]]) -> Tuple[type, ...]:
+    """Returns the MRO of an object's class, or of the object itself if it's a class."""
+    if not hasattr(obj, "__mro__"):
+        # N.B. we cannot use `if type(obj) is type` here because it doesn't work with
+        # some types of classes, such as the ones that use abc.ABCMeta.
+        obj = type(obj)
+    return getattr(obj, "__mro__", ())
+
+
+def get_object_types_mro_as_strings(obj: object) -> Collection[str]:
+    """
+    Returns the MRO of an object's class as full qualified names, or of the object itself if it's a class.
+
+    Examples:
+        `object_types_mro_as_strings(JSONDecoder)` will return `['json.decoder.JSONDecoder', 'builtins.object']`
+    """
+    return [
+        f'{getattr(type_, "__module__", "")}.{getattr(type_, "__qualname__", "")}'
+        for type_ in get_object_types_mro(obj)
+    ]
+
+
+def is_object_one_of_types(
+    obj: object, fully_qualified_types_names: Collection[str]
+) -> bool:
+    """
+    Returns `True` if the given object's class (or the object itself, if it's a class) has one of the
+    fully qualified names in its MRO.
+    """
+    for type_name in get_object_types_mro_as_strings(obj):
+        if type_name in fully_qualified_types_names:
+            return True
+    return False
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/rich/_log_render.py b/venv/lib/python3.12/site-packages/pip/_vendor/rich/_log_render.py
new file mode 100644
index 00000000..fc16c844
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_vendor/rich/_log_render.py
@@ -0,0 +1,94 @@
+from datetime import datetime
+from typing import Iterable, List, Optional, TYPE_CHECKING, Union, Callable
+
+
+from .text import Text, TextType
+
+if TYPE_CHECKING:
+    from .console import Console, ConsoleRenderable, RenderableType
+    from .table import Table
+
+FormatTimeCallable = Callable[[datetime], Text]
+
+
+class LogRender:
+    def __init__(
+        self,
+        show_time: bool = True,
+        show_level: bool = False,
+        show_path: bool = True,
+        time_format: Union[str, FormatTimeCallable] = "[%x %X]",
+        omit_repeated_times: bool = True,
+        level_width: Optional[int] = 8,
+    ) -> None:
+        self.show_time = show_time
+        self.show_level = show_level
+        self.show_path = show_path
+        self.time_format = time_format
+        self.omit_repeated_times = omit_repeated_times
+        self.level_width = level_width
+        self._last_time: Optional[Text] = None
+
+    def __call__(
+        self,
+        console: "Console",
+        renderables: Iterable["ConsoleRenderable"],
+        log_time: Optional[datetime] = None,
+        time_format: Optional[Union[str, FormatTimeCallable]] = None,
+        level: TextType = "",
+        path: Optional[str] = None,
+        line_no: Optional[int] = None,
+        link_path: Optional[str] = None,
+    ) -> "Table":
+        from .containers import Renderables
+        from .table import Table
+
+        output = Table.grid(padding=(0, 1))
+        output.expand = True
+        if self.show_time:
+            output.add_column(style="log.time")
+        if self.show_level:
+            output.add_column(style="log.level", width=self.level_width)
+        output.add_column(ratio=1, style="log.message", overflow="fold")
+        if self.show_path and path:
+            output.add_column(style="log.path")
+        row: List["RenderableType"] = []
+        if self.show_time:
+            log_time = log_time or console.get_datetime()
+            time_format = time_format or self.time_format
+            if callable(time_format):
+                log_time_display = time_format(log_time)
+            else:
+                log_time_display = Text(log_time.strftime(time_format))
+            if log_time_display == self._last_time and self.omit_repeated_times:
+                row.append(Text(" " * len(log_time_display)))
+            else:
+                row.append(log_time_display)
+                self._last_time = log_time_display
+        if self.show_level:
+            row.append(level)
+
+        row.append(Renderables(renderables))
+        if self.show_path and path:
+            path_text = Text()
+            path_text.append(
+                path, style=f"link file://{link_path}" if link_path else ""
+            )
+            if line_no:
+                path_text.append(":")
+                path_text.append(
+                    f"{line_no}",
+                    style=f"link file://{link_path}#{line_no}" if link_path else "",
+                )
+            row.append(path_text)
+
+        output.add_row(*row)
+        return output
+
+
+if __name__ == "__main__":  # pragma: no cover
+    from pip._vendor.rich.console import Console
+
+    c = Console()
+    c.print("[on blue]Hello", justify="right")
+    c.log("[on blue]hello", justify="right")
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/rich/_loop.py b/venv/lib/python3.12/site-packages/pip/_vendor/rich/_loop.py
new file mode 100644
index 00000000..01c6cafb
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_vendor/rich/_loop.py
@@ -0,0 +1,43 @@
+from typing import Iterable, Tuple, TypeVar
+
+T = TypeVar("T")
+
+
+def loop_first(values: Iterable[T]) -> Iterable[Tuple[bool, T]]:
+    """Iterate and generate a tuple with a flag for first value."""
+    iter_values = iter(values)
+    try:
+        value = next(iter_values)
+    except StopIteration:
+        return
+    yield True, value
+    for value in iter_values:
+        yield False, value
+
+
+def loop_last(values: Iterable[T]) -> Iterable[Tuple[bool, T]]:
+    """Iterate and generate a tuple with a flag for last value."""
+    iter_values = iter(values)
+    try:
+        previous_value = next(iter_values)
+    except StopIteration:
+        return
+    for value in iter_values:
+        yield False, previous_value
+        previous_value = value
+    yield True, previous_value
+
+
+def loop_first_last(values: Iterable[T]) -> Iterable[Tuple[bool, bool, T]]:
+    """Iterate and generate a tuple with a flag for first and last value."""
+    iter_values = iter(values)
+    try:
+        previous_value = next(iter_values)
+    except StopIteration:
+        return
+    first = True
+    for value in iter_values:
+        yield first, False, previous_value
+        first = False
+        previous_value = value
+    yield first, True, previous_value
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/rich/_null_file.py b/venv/lib/python3.12/site-packages/pip/_vendor/rich/_null_file.py
new file mode 100644
index 00000000..b659673e
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_vendor/rich/_null_file.py
@@ -0,0 +1,69 @@
+from types import TracebackType
+from typing import IO, Iterable, Iterator, List, Optional, Type
+
+
+class NullFile(IO[str]):
+    def close(self) -> None:
+        pass
+
+    def isatty(self) -> bool:
+        return False
+
+    def read(self, __n: int = 1) -> str:
+        return ""
+
+    def readable(self) -> bool:
+        return False
+
+    def readline(self, __limit: int = 1) -> str:
+        return ""
+
+    def readlines(self, __hint: int = 1) -> List[str]:
+        return []
+
+    def seek(self, __offset: int, __whence: int = 1) -> int:
+        return 0
+
+    def seekable(self) -> bool:
+        return False
+
+    def tell(self) -> int:
+        return 0
+
+    def truncate(self, __size: Optional[int] = 1) -> int:
+        return 0
+
+    def writable(self) -> bool:
+        return False
+
+    def writelines(self, __lines: Iterable[str]) -> None:
+        pass
+
+    def __next__(self) -> str:
+        return ""
+
+    def __iter__(self) -> Iterator[str]:
+        return iter([""])
+
+    def __enter__(self) -> IO[str]:
+        pass
+
+    def __exit__(
+        self,
+        __t: Optional[Type[BaseException]],
+        __value: Optional[BaseException],
+        __traceback: Optional[TracebackType],
+    ) -> None:
+        pass
+
+    def write(self, text: str) -> int:
+        return 0
+
+    def flush(self) -> None:
+        pass
+
+    def fileno(self) -> int:
+        return -1
+
+
+NULL_FILE = NullFile()
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/rich/_palettes.py b/venv/lib/python3.12/site-packages/pip/_vendor/rich/_palettes.py
new file mode 100644
index 00000000..3c748d33
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_vendor/rich/_palettes.py
@@ -0,0 +1,309 @@
+from .palette import Palette
+
+
+# Taken from https://en.wikipedia.org/wiki/ANSI_escape_code (Windows 10 column)
+WINDOWS_PALETTE = Palette(
+    [
+        (12, 12, 12),
+        (197, 15, 31),
+        (19, 161, 14),
+        (193, 156, 0),
+        (0, 55, 218),
+        (136, 23, 152),
+        (58, 150, 221),
+        (204, 204, 204),
+        (118, 118, 118),
+        (231, 72, 86),
+        (22, 198, 12),
+        (249, 241, 165),
+        (59, 120, 255),
+        (180, 0, 158),
+        (97, 214, 214),
+        (242, 242, 242),
+    ]
+)
+
+# # The standard ansi colors (including bright variants)
+STANDARD_PALETTE = Palette(
+    [
+        (0, 0, 0),
+        (170, 0, 0),
+        (0, 170, 0),
+        (170, 85, 0),
+        (0, 0, 170),
+        (170, 0, 170),
+        (0, 170, 170),
+        (170, 170, 170),
+        (85, 85, 85),
+        (255, 85, 85),
+        (85, 255, 85),
+        (255, 255, 85),
+        (85, 85, 255),
+        (255, 85, 255),
+        (85, 255, 255),
+        (255, 255, 255),
+    ]
+)
+
+
+# The 256 color palette
+EIGHT_BIT_PALETTE = Palette(
+    [
+        (0, 0, 0),
+        (128, 0, 0),
+        (0, 128, 0),
+        (128, 128, 0),
+        (0, 0, 128),
+        (128, 0, 128),
+        (0, 128, 128),
+        (192, 192, 192),
+        (128, 128, 128),
+        (255, 0, 0),
+        (0, 255, 0),
+        (255, 255, 0),
+        (0, 0, 255),
+        (255, 0, 255),
+        (0, 255, 255),
+        (255, 255, 255),
+        (0, 0, 0),
+        (0, 0, 95),
+        (0, 0, 135),
+        (0, 0, 175),
+        (0, 0, 215),
+        (0, 0, 255),
+        (0, 95, 0),
+        (0, 95, 95),
+        (0, 95, 135),
+        (0, 95, 175),
+        (0, 95, 215),
+        (0, 95, 255),
+        (0, 135, 0),
+        (0, 135, 95),
+        (0, 135, 135),
+        (0, 135, 175),
+        (0, 135, 215),
+        (0, 135, 255),
+        (0, 175, 0),
+        (0, 175, 95),
+        (0, 175, 135),
+        (0, 175, 175),
+        (0, 175, 215),
+        (0, 175, 255),
+        (0, 215, 0),
+        (0, 215, 95),
+        (0, 215, 135),
+        (0, 215, 175),
+        (0, 215, 215),
+        (0, 215, 255),
+        (0, 255, 0),
+        (0, 255, 95),
+        (0, 255, 135),
+        (0, 255, 175),
+        (0, 255, 215),
+        (0, 255, 255),
+        (95, 0, 0),
+        (95, 0, 95),
+        (95, 0, 135),
+        (95, 0, 175),
+        (95, 0, 215),
+        (95, 0, 255),
+        (95, 95, 0),
+        (95, 95, 95),
+        (95, 95, 135),
+        (95, 95, 175),
+        (95, 95, 215),
+        (95, 95, 255),
+        (95, 135, 0),
+        (95, 135, 95),
+        (95, 135, 135),
+        (95, 135, 175),
+        (95, 135, 215),
+        (95, 135, 255),
+        (95, 175, 0),
+        (95, 175, 95),
+        (95, 175, 135),
+        (95, 175, 175),
+        (95, 175, 215),
+        (95, 175, 255),
+        (95, 215, 0),
+        (95, 215, 95),
+        (95, 215, 135),
+        (95, 215, 175),
+        (95, 215, 215),
+        (95, 215, 255),
+        (95, 255, 0),
+        (95, 255, 95),
+        (95, 255, 135),
+        (95, 255, 175),
+        (95, 255, 215),
+        (95, 255, 255),
+        (135, 0, 0),
+        (135, 0, 95),
+        (135, 0, 135),
+        (135, 0, 175),
+        (135, 0, 215),
+        (135, 0, 255),
+        (135, 95, 0),
+        (135, 95, 95),
+        (135, 95, 135),
+        (135, 95, 175),
+        (135, 95, 215),
+        (135, 95, 255),
+        (135, 135, 0),
+        (135, 135, 95),
+        (135, 135, 135),
+        (135, 135, 175),
+        (135, 135, 215),
+        (135, 135, 255),
+        (135, 175, 0),
+        (135, 175, 95),
+        (135, 175, 135),
+        (135, 175, 175),
+        (135, 175, 215),
+        (135, 175, 255),
+        (135, 215, 0),
+        (135, 215, 95),
+        (135, 215, 135),
+        (135, 215, 175),
+        (135, 215, 215),
+        (135, 215, 255),
+        (135, 255, 0),
+        (135, 255, 95),
+        (135, 255, 135),
+        (135, 255, 175),
+        (135, 255, 215),
+        (135, 255, 255),
+        (175, 0, 0),
+        (175, 0, 95),
+        (175, 0, 135),
+        (175, 0, 175),
+        (175, 0, 215),
+        (175, 0, 255),
+        (175, 95, 0),
+        (175, 95, 95),
+        (175, 95, 135),
+        (175, 95, 175),
+        (175, 95, 215),
+        (175, 95, 255),
+        (175, 135, 0),
+        (175, 135, 95),
+        (175, 135, 135),
+        (175, 135, 175),
+        (175, 135, 215),
+        (175, 135, 255),
+        (175, 175, 0),
+        (175, 175, 95),
+        (175, 175, 135),
+        (175, 175, 175),
+        (175, 175, 215),
+        (175, 175, 255),
+        (175, 215, 0),
+        (175, 215, 95),
+        (175, 215, 135),
+        (175, 215, 175),
+        (175, 215, 215),
+        (175, 215, 255),
+        (175, 255, 0),
+        (175, 255, 95),
+        (175, 255, 135),
+        (175, 255, 175),
+        (175, 255, 215),
+        (175, 255, 255),
+        (215, 0, 0),
+        (215, 0, 95),
+        (215, 0, 135),
+        (215, 0, 175),
+        (215, 0, 215),
+        (215, 0, 255),
+        (215, 95, 0),
+        (215, 95, 95),
+        (215, 95, 135),
+        (215, 95, 175),
+        (215, 95, 215),
+        (215, 95, 255),
+        (215, 135, 0),
+        (215, 135, 95),
+        (215, 135, 135),
+        (215, 135, 175),
+        (215, 135, 215),
+        (215, 135, 255),
+        (215, 175, 0),
+        (215, 175, 95),
+        (215, 175, 135),
+        (215, 175, 175),
+        (215, 175, 215),
+        (215, 175, 255),
+        (215, 215, 0),
+        (215, 215, 95),
+        (215, 215, 135),
+        (215, 215, 175),
+        (215, 215, 215),
+        (215, 215, 255),
+        (215, 255, 0),
+        (215, 255, 95),
+        (215, 255, 135),
+        (215, 255, 175),
+        (215, 255, 215),
+        (215, 255, 255),
+        (255, 0, 0),
+        (255, 0, 95),
+        (255, 0, 135),
+        (255, 0, 175),
+        (255, 0, 215),
+        (255, 0, 255),
+        (255, 95, 0),
+        (255, 95, 95),
+        (255, 95, 135),
+        (255, 95, 175),
+        (255, 95, 215),
+        (255, 95, 255),
+        (255, 135, 0),
+        (255, 135, 95),
+        (255, 135, 135),
+        (255, 135, 175),
+        (255, 135, 215),
+        (255, 135, 255),
+        (255, 175, 0),
+        (255, 175, 95),
+        (255, 175, 135),
+        (255, 175, 175),
+        (255, 175, 215),
+        (255, 175, 255),
+        (255, 215, 0),
+        (255, 215, 95),
+        (255, 215, 135),
+        (255, 215, 175),
+        (255, 215, 215),
+        (255, 215, 255),
+        (255, 255, 0),
+        (255, 255, 95),
+        (255, 255, 135),
+        (255, 255, 175),
+        (255, 255, 215),
+        (255, 255, 255),
+        (8, 8, 8),
+        (18, 18, 18),
+        (28, 28, 28),
+        (38, 38, 38),
+        (48, 48, 48),
+        (58, 58, 58),
+        (68, 68, 68),
+        (78, 78, 78),
+        (88, 88, 88),
+        (98, 98, 98),
+        (108, 108, 108),
+        (118, 118, 118),
+        (128, 128, 128),
+        (138, 138, 138),
+        (148, 148, 148),
+        (158, 158, 158),
+        (168, 168, 168),
+        (178, 178, 178),
+        (188, 188, 188),
+        (198, 198, 198),
+        (208, 208, 208),
+        (218, 218, 218),
+        (228, 228, 228),
+        (238, 238, 238),
+    ]
+)
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/rich/_pick.py b/venv/lib/python3.12/site-packages/pip/_vendor/rich/_pick.py
new file mode 100644
index 00000000..4f6d8b2d
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_vendor/rich/_pick.py
@@ -0,0 +1,17 @@
+from typing import Optional
+
+
+def pick_bool(*values: Optional[bool]) -> bool:
+    """Pick the first non-none bool or return the last value.
+
+    Args:
+        *values (bool): Any number of boolean or None values.
+
+    Returns:
+        bool: First non-none boolean.
+    """
+    assert values, "1 or more values required"
+    for value in values:
+        if value is not None:
+            return value
+    return bool(value)
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/rich/_ratio.py b/venv/lib/python3.12/site-packages/pip/_vendor/rich/_ratio.py
new file mode 100644
index 00000000..95267b0c
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_vendor/rich/_ratio.py
@@ -0,0 +1,159 @@
+import sys
+from fractions import Fraction
+from math import ceil
+from typing import cast, List, Optional, Sequence
+
+if sys.version_info >= (3, 8):
+    from typing import Protocol
+else:
+    from pip._vendor.typing_extensions import Protocol  # pragma: no cover
+
+
+class Edge(Protocol):
+    """Any object that defines an edge (such as Layout)."""
+
+    size: Optional[int] = None
+    ratio: int = 1
+    minimum_size: int = 1
+
+
+def ratio_resolve(total: int, edges: Sequence[Edge]) -> List[int]:
+    """Divide total space to satisfy size, ratio, and minimum_size, constraints.
+
+    The returned list of integers should add up to total in most cases, unless it is
+    impossible to satisfy all the constraints. For instance, if there are two edges
+    with a minimum size of 20 each and `total` is 30 then the returned list will be
+    greater than total. In practice, this would mean that a Layout object would
+    clip the rows that would overflow the screen height.
+
+    Args:
+        total (int): Total number of characters.
+        edges (List[Edge]): Edges within total space.
+
+    Returns:
+        List[int]: Number of characters for each edge.
+    """
+    # Size of edge or None for yet to be determined
+    sizes = [(edge.size or None) for edge in edges]
+
+    _Fraction = Fraction
+
+    # While any edges haven't been calculated
+    while None in sizes:
+        # Get flexible edges and index to map these back on to sizes list
+        flexible_edges = [
+            (index, edge)
+            for index, (size, edge) in enumerate(zip(sizes, edges))
+            if size is None
+        ]
+        # Remaining space in total
+        remaining = total - sum(size or 0 for size in sizes)
+        if remaining <= 0:
+            # No room for flexible edges
+            return [
+                ((edge.minimum_size or 1) if size is None else size)
+                for size, edge in zip(sizes, edges)
+            ]
+        # Calculate number of characters in a ratio portion
+        portion = _Fraction(
+            remaining, sum((edge.ratio or 1) for _, edge in flexible_edges)
+        )
+
+        # If any edges will be less than their minimum, replace size with the minimum
+        for index, edge in flexible_edges:
+            if portion * edge.ratio <= edge.minimum_size:
+                sizes[index] = edge.minimum_size
+                # New fixed size will invalidate calculations, so we need to repeat the process
+                break
+        else:
+            # Distribute flexible space and compensate for rounding error
+            # Since edge sizes can only be integers we need to add the remainder
+            # to the following line
+            remainder = _Fraction(0)
+            for index, edge in flexible_edges:
+                size, remainder = divmod(portion * edge.ratio + remainder, 1)
+                sizes[index] = size
+            break
+    # Sizes now contains integers only
+    return cast(List[int], sizes)
+
+
+def ratio_reduce(
+    total: int, ratios: List[int], maximums: List[int], values: List[int]
+) -> List[int]:
+    """Divide an integer total in to parts based on ratios.
+
+    Args:
+        total (int): The total to divide.
+        ratios (List[int]): A list of integer ratios.
+        maximums (List[int]): List of maximums values for each slot.
+        values (List[int]): List of values
+
+    Returns:
+        List[int]: A list of integers guaranteed to sum to total.
+    """
+    ratios = [ratio if _max else 0 for ratio, _max in zip(ratios, maximums)]
+    total_ratio = sum(ratios)
+    if not total_ratio:
+        return values[:]
+    total_remaining = total
+    result: List[int] = []
+    append = result.append
+    for ratio, maximum, value in zip(ratios, maximums, values):
+        if ratio and total_ratio > 0:
+            distributed = min(maximum, round(ratio * total_remaining / total_ratio))
+            append(value - distributed)
+            total_remaining -= distributed
+            total_ratio -= ratio
+        else:
+            append(value)
+    return result
+
+
+def ratio_distribute(
+    total: int, ratios: List[int], minimums: Optional[List[int]] = None
+) -> List[int]:
+    """Distribute an integer total in to parts based on ratios.
+
+    Args:
+        total (int): The total to divide.
+        ratios (List[int]): A list of integer ratios.
+        minimums (List[int]): List of minimum values for each slot.
+
+    Returns:
+        List[int]: A list of integers guaranteed to sum to total.
+    """
+    if minimums:
+        ratios = [ratio if _min else 0 for ratio, _min in zip(ratios, minimums)]
+    total_ratio = sum(ratios)
+    assert total_ratio > 0, "Sum of ratios must be > 0"
+
+    total_remaining = total
+    distributed_total: List[int] = []
+    append = distributed_total.append
+    if minimums is None:
+        _minimums = [0] * len(ratios)
+    else:
+        _minimums = minimums
+    for ratio, minimum in zip(ratios, _minimums):
+        if total_ratio > 0:
+            distributed = max(minimum, ceil(ratio * total_remaining / total_ratio))
+        else:
+            distributed = total_remaining
+        append(distributed)
+        total_ratio -= ratio
+        total_remaining -= distributed
+    return distributed_total
+
+
+if __name__ == "__main__":
+    from dataclasses import dataclass
+
+    @dataclass
+    class E:
+        size: Optional[int] = None
+        ratio: int = 1
+        minimum_size: int = 1
+
+    resolved = ratio_resolve(110, [E(None, 1, 1), E(None, 1, 1), E(None, 1, 1)])
+    print(sum(resolved))
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/rich/_spinners.py b/venv/lib/python3.12/site-packages/pip/_vendor/rich/_spinners.py
new file mode 100644
index 00000000..d0bb1fe7
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_vendor/rich/_spinners.py
@@ -0,0 +1,482 @@
+"""
+Spinners are from:
+* cli-spinners:
+    MIT License
+    Copyright (c) Sindre Sorhus  (sindresorhus.com)
+    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.
+"""
+
+SPINNERS = {
+    "dots": {
+        "interval": 80,
+        "frames": "⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏",
+    },
+    "dots2": {"interval": 80, "frames": "⣾⣽⣻⢿⡿⣟⣯⣷"},
+    "dots3": {
+        "interval": 80,
+        "frames": "⠋⠙⠚⠞⠖⠦⠴⠲⠳⠓",
+    },
+    "dots4": {
+        "interval": 80,
+        "frames": "⠄⠆⠇⠋⠙⠸⠰⠠⠰⠸⠙⠋⠇⠆",
+    },
+    "dots5": {
+        "interval": 80,
+        "frames": "⠋⠙⠚⠒⠂⠂⠒⠲⠴⠦⠖⠒⠐⠐⠒⠓⠋",
+    },
+    "dots6": {
+        "interval": 80,
+        "frames": "⠁⠉⠙⠚⠒⠂⠂⠒⠲⠴⠤⠄⠄⠤⠴⠲⠒⠂⠂⠒⠚⠙⠉⠁",
+    },
+    "dots7": {
+        "interval": 80,
+        "frames": "⠈⠉⠋⠓⠒⠐⠐⠒⠖⠦⠤⠠⠠⠤⠦⠖⠒⠐⠐⠒⠓⠋⠉⠈",
+    },
+    "dots8": {
+        "interval": 80,
+        "frames": "⠁⠁⠉⠙⠚⠒⠂⠂⠒⠲⠴⠤⠄⠄⠤⠠⠠⠤⠦⠖⠒⠐⠐⠒⠓⠋⠉⠈⠈",
+    },
+    "dots9": {"interval": 80, "frames": "⢹⢺⢼⣸⣇⡧⡗⡏"},
+    "dots10": {"interval": 80, "frames": "⢄⢂⢁⡁⡈⡐⡠"},
+    "dots11": {"interval": 100, "frames": "⠁⠂⠄⡀⢀⠠⠐⠈"},
+    "dots12": {
+        "interval": 80,
+        "frames": [
+            "⢀⠀",
+            "⡀⠀",
+            "⠄⠀",
+            "⢂⠀",
+            "⡂⠀",
+            "⠅⠀",
+            "⢃⠀",
+            "⡃⠀",
+            "⠍⠀",
+            "⢋⠀",
+            "⡋⠀",
+            "⠍⠁",
+            "⢋⠁",
+            "⡋⠁",
+            "⠍⠉",
+            "⠋⠉",
+            "⠋⠉",
+            "⠉⠙",
+            "⠉⠙",
+            "⠉⠩",
+            "⠈⢙",
+            "⠈⡙",
+            "⢈⠩",
+            "⡀⢙",
+            "⠄⡙",
+            "⢂⠩",
+            "⡂⢘",
+            "⠅⡘",
+            "⢃⠨",
+            "⡃⢐",
+            "⠍⡐",
+            "⢋⠠",
+            "⡋⢀",
+            "⠍⡁",
+            "⢋⠁",
+            "⡋⠁",
+            "⠍⠉",
+            "⠋⠉",
+            "⠋⠉",
+            "⠉⠙",
+            "⠉⠙",
+            "⠉⠩",
+            "⠈⢙",
+            "⠈⡙",
+            "⠈⠩",
+            "⠀⢙",
+            "⠀⡙",
+            "⠀⠩",
+            "⠀⢘",
+            "⠀⡘",
+            "⠀⠨",
+            "⠀⢐",
+            "⠀⡐",
+            "⠀⠠",
+            "⠀⢀",
+            "⠀⡀",
+        ],
+    },
+    "dots8Bit": {
+        "interval": 80,
+        "frames": "⠀⠁⠂⠃⠄⠅⠆⠇⡀⡁⡂⡃⡄⡅⡆⡇⠈⠉⠊⠋⠌⠍⠎⠏⡈⡉⡊⡋⡌⡍⡎⡏⠐⠑⠒⠓⠔⠕⠖⠗⡐⡑⡒⡓⡔⡕⡖⡗⠘⠙⠚⠛⠜⠝⠞⠟⡘⡙"
+        "⡚⡛⡜⡝⡞⡟⠠⠡⠢⠣⠤⠥⠦⠧⡠⡡⡢⡣⡤⡥⡦⡧⠨⠩⠪⠫⠬⠭⠮⠯⡨⡩⡪⡫⡬⡭⡮⡯⠰⠱⠲⠳⠴⠵⠶⠷⡰⡱⡲⡳⡴⡵⡶⡷⠸⠹⠺⠻"
+        "⠼⠽⠾⠿⡸⡹⡺⡻⡼⡽⡾⡿⢀⢁⢂⢃⢄⢅⢆⢇⣀⣁⣂⣃⣄⣅⣆⣇⢈⢉⢊⢋⢌⢍⢎⢏⣈⣉⣊⣋⣌⣍⣎⣏⢐⢑⢒⢓⢔⢕⢖⢗⣐⣑⣒⣓⣔⣕"
+        "⣖⣗⢘⢙⢚⢛⢜⢝⢞⢟⣘⣙⣚⣛⣜⣝⣞⣟⢠⢡⢢⢣⢤⢥⢦⢧⣠⣡⣢⣣⣤⣥⣦⣧⢨⢩⢪⢫⢬⢭⢮⢯⣨⣩⣪⣫⣬⣭⣮⣯⢰⢱⢲⢳⢴⢵⢶⢷"
+        "⣰⣱⣲⣳⣴⣵⣶⣷⢸⢹⢺⢻⢼⢽⢾⢿⣸⣹⣺⣻⣼⣽⣾⣿",
+    },
+    "line": {"interval": 130, "frames": ["-", "\\", "|", "/"]},
+    "line2": {"interval": 100, "frames": "⠂-–—–-"},
+    "pipe": {"interval": 100, "frames": "┤┘┴└├┌┬┐"},
+    "simpleDots": {"interval": 400, "frames": [".  ", ".. ", "...", "   "]},
+    "simpleDotsScrolling": {
+        "interval": 200,
+        "frames": [".  ", ".. ", "...", " ..", "  .", "   "],
+    },
+    "star": {"interval": 70, "frames": "✶✸✹✺✹✷"},
+    "star2": {"interval": 80, "frames": "+x*"},
+    "flip": {
+        "interval": 70,
+        "frames": "___-``'´-___",
+    },
+    "hamburger": {"interval": 100, "frames": "☱☲☴"},
+    "growVertical": {
+        "interval": 120,
+        "frames": "▁▃▄▅▆▇▆▅▄▃",
+    },
+    "growHorizontal": {
+        "interval": 120,
+        "frames": "▏▎▍▌▋▊▉▊▋▌▍▎",
+    },
+    "balloon": {"interval": 140, "frames": " .oO@* "},
+    "balloon2": {"interval": 120, "frames": ".oO°Oo."},
+    "noise": {"interval": 100, "frames": "▓▒░"},
+    "bounce": {"interval": 120, "frames": "⠁⠂⠄⠂"},
+    "boxBounce": {"interval": 120, "frames": "▖▘▝▗"},
+    "boxBounce2": {"interval": 100, "frames": "▌▀▐▄"},
+    "triangle": {"interval": 50, "frames": "◢◣◤◥"},
+    "arc": {"interval": 100, "frames": "◜◠◝◞◡◟"},
+    "circle": {"interval": 120, "frames": "◡⊙◠"},
+    "squareCorners": {"interval": 180, "frames": "◰◳◲◱"},
+    "circleQuarters": {"interval": 120, "frames": "◴◷◶◵"},
+    "circleHalves": {"interval": 50, "frames": "◐◓◑◒"},
+    "squish": {"interval": 100, "frames": "╫╪"},
+    "toggle": {"interval": 250, "frames": "⊶⊷"},
+    "toggle2": {"interval": 80, "frames": "▫▪"},
+    "toggle3": {"interval": 120, "frames": "□■"},
+    "toggle4": {"interval": 100, "frames": "■□▪▫"},
+    "toggle5": {"interval": 100, "frames": "▮▯"},
+    "toggle6": {"interval": 300, "frames": "ဝ၀"},
+    "toggle7": {"interval": 80, "frames": "⦾⦿"},
+    "toggle8": {"interval": 100, "frames": "◍◌"},
+    "toggle9": {"interval": 100, "frames": "◉◎"},
+    "toggle10": {"interval": 100, "frames": "㊂㊀㊁"},
+    "toggle11": {"interval": 50, "frames": "⧇⧆"},
+    "toggle12": {"interval": 120, "frames": "☗☖"},
+    "toggle13": {"interval": 80, "frames": "=*-"},
+    "arrow": {"interval": 100, "frames": "←↖↑↗→↘↓↙"},
+    "arrow2": {
+        "interval": 80,
+        "frames": ["⬆️ ", "↗️ ", "➡️ ", "↘️ ", "⬇️ ", "↙️ ", "⬅️ ", "↖️ "],
+    },
+    "arrow3": {
+        "interval": 120,
+        "frames": ["▹▹▹▹▹", "▸▹▹▹▹", "▹▸▹▹▹", "▹▹▸▹▹", "▹▹▹▸▹", "▹▹▹▹▸"],
+    },
+    "bouncingBar": {
+        "interval": 80,
+        "frames": [
+            "[    ]",
+            "[=   ]",
+            "[==  ]",
+            "[=== ]",
+            "[ ===]",
+            "[  ==]",
+            "[   =]",
+            "[    ]",
+            "[   =]",
+            "[  ==]",
+            "[ ===]",
+            "[====]",
+            "[=== ]",
+            "[==  ]",
+            "[=   ]",
+        ],
+    },
+    "bouncingBall": {
+        "interval": 80,
+        "frames": [
+            "( ●    )",
+            "(  ●   )",
+            "(   ●  )",
+            "(    ● )",
+            "(     ●)",
+            "(    ● )",
+            "(   ●  )",
+            "(  ●   )",
+            "( ●    )",
+            "(●     )",
+        ],
+    },
+    "smiley": {"interval": 200, "frames": ["😄 ", "😝 "]},
+    "monkey": {"interval": 300, "frames": ["🙈 ", "🙈 ", "🙉 ", "🙊 "]},
+    "hearts": {"interval": 100, "frames": ["💛 ", "💙 ", "💜 ", "💚 ", "❤️ "]},
+    "clock": {
+        "interval": 100,
+        "frames": [
+            "🕛 ",
+            "🕐 ",
+            "🕑 ",
+            "🕒 ",
+            "🕓 ",
+            "🕔 ",
+            "🕕 ",
+            "🕖 ",
+            "🕗 ",
+            "🕘 ",
+            "🕙 ",
+            "🕚 ",
+        ],
+    },
+    "earth": {"interval": 180, "frames": ["🌍 ", "🌎 ", "🌏 "]},
+    "material": {
+        "interval": 17,
+        "frames": [
+            "█▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁",
+            "██▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁",
+            "███▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁",
+            "████▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁",
+            "██████▁▁▁▁▁▁▁▁▁▁▁▁▁▁",
+            "██████▁▁▁▁▁▁▁▁▁▁▁▁▁▁",
+            "███████▁▁▁▁▁▁▁▁▁▁▁▁▁",
+            "████████▁▁▁▁▁▁▁▁▁▁▁▁",
+            "█████████▁▁▁▁▁▁▁▁▁▁▁",
+            "█████████▁▁▁▁▁▁▁▁▁▁▁",
+            "██████████▁▁▁▁▁▁▁▁▁▁",
+            "███████████▁▁▁▁▁▁▁▁▁",
+            "█████████████▁▁▁▁▁▁▁",
+            "██████████████▁▁▁▁▁▁",
+            "██████████████▁▁▁▁▁▁",
+            "▁██████████████▁▁▁▁▁",
+            "▁██████████████▁▁▁▁▁",
+            "▁██████████████▁▁▁▁▁",
+            "▁▁██████████████▁▁▁▁",
+            "▁▁▁██████████████▁▁▁",
+            "▁▁▁▁█████████████▁▁▁",
+            "▁▁▁▁██████████████▁▁",
+            "▁▁▁▁██████████████▁▁",
+            "▁▁▁▁▁██████████████▁",
+            "▁▁▁▁▁██████████████▁",
+            "▁▁▁▁▁██████████████▁",
+            "▁▁▁▁▁▁██████████████",
+            "▁▁▁▁▁▁██████████████",
+            "▁▁▁▁▁▁▁█████████████",
+            "▁▁▁▁▁▁▁█████████████",
+            "▁▁▁▁▁▁▁▁████████████",
+            "▁▁▁▁▁▁▁▁████████████",
+            "▁▁▁▁▁▁▁▁▁███████████",
+            "▁▁▁▁▁▁▁▁▁███████████",
+            "▁▁▁▁▁▁▁▁▁▁██████████",
+            "▁▁▁▁▁▁▁▁▁▁██████████",
+            "▁▁▁▁▁▁▁▁▁▁▁▁████████",
+            "▁▁▁▁▁▁▁▁▁▁▁▁▁███████",
+            "▁▁▁▁▁▁▁▁▁▁▁▁▁▁██████",
+            "▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁█████",
+            "▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁█████",
+            "█▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁████",
+            "██▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁███",
+            "██▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁███",
+            "███▁▁▁▁▁▁▁▁▁▁▁▁▁▁███",
+            "████▁▁▁▁▁▁▁▁▁▁▁▁▁▁██",
+            "█████▁▁▁▁▁▁▁▁▁▁▁▁▁▁█",
+            "█████▁▁▁▁▁▁▁▁▁▁▁▁▁▁█",
+            "██████▁▁▁▁▁▁▁▁▁▁▁▁▁█",
+            "████████▁▁▁▁▁▁▁▁▁▁▁▁",
+            "█████████▁▁▁▁▁▁▁▁▁▁▁",
+            "█████████▁▁▁▁▁▁▁▁▁▁▁",
+            "█████████▁▁▁▁▁▁▁▁▁▁▁",
+            "█████████▁▁▁▁▁▁▁▁▁▁▁",
+            "███████████▁▁▁▁▁▁▁▁▁",
+            "████████████▁▁▁▁▁▁▁▁",
+            "████████████▁▁▁▁▁▁▁▁",
+            "██████████████▁▁▁▁▁▁",
+            "██████████████▁▁▁▁▁▁",
+            "▁██████████████▁▁▁▁▁",
+            "▁██████████████▁▁▁▁▁",
+            "▁▁▁█████████████▁▁▁▁",
+            "▁▁▁▁▁████████████▁▁▁",
+            "▁▁▁▁▁████████████▁▁▁",
+            "▁▁▁▁▁▁███████████▁▁▁",
+            "▁▁▁▁▁▁▁▁█████████▁▁▁",
+            "▁▁▁▁▁▁▁▁█████████▁▁▁",
+            "▁▁▁▁▁▁▁▁▁█████████▁▁",
+            "▁▁▁▁▁▁▁▁▁█████████▁▁",
+            "▁▁▁▁▁▁▁▁▁▁█████████▁",
+            "▁▁▁▁▁▁▁▁▁▁▁████████▁",
+            "▁▁▁▁▁▁▁▁▁▁▁████████▁",
+            "▁▁▁▁▁▁▁▁▁▁▁▁███████▁",
+            "▁▁▁▁▁▁▁▁▁▁▁▁███████▁",
+            "▁▁▁▁▁▁▁▁▁▁▁▁▁███████",
+            "▁▁▁▁▁▁▁▁▁▁▁▁▁███████",
+            "▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁█████",
+            "▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁████",
+            "▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁████",
+            "▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁████",
+            "▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁███",
+            "▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁███",
+            "▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁██",
+            "▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁██",
+            "▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁██",
+            "▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁█",
+            "▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁█",
+            "▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁█",
+            "▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁",
+            "▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁",
+            "▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁",
+            "▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁",
+        ],
+    },
+    "moon": {
+        "interval": 80,
+        "frames": ["🌑 ", "🌒 ", "🌓 ", "🌔 ", "🌕 ", "🌖 ", "🌗 ", "🌘 "],
+    },
+    "runner": {"interval": 140, "frames": ["🚶 ", "🏃 "]},
+    "pong": {
+        "interval": 80,
+        "frames": [
+            "▐⠂       ▌",
+            "▐⠈       ▌",
+            "▐ ⠂      ▌",
+            "▐ ⠠      ▌",
+            "▐  ⡀     ▌",
+            "▐  ⠠     ▌",
+            "▐   ⠂    ▌",
+            "▐   ⠈    ▌",
+            "▐    ⠂   ▌",
+            "▐    ⠠   ▌",
+            "▐     ⡀  ▌",
+            "▐     ⠠  ▌",
+            "▐      ⠂ ▌",
+            "▐      ⠈ ▌",
+            "▐       ⠂▌",
+            "▐       ⠠▌",
+            "▐       ⡀▌",
+            "▐      ⠠ ▌",
+            "▐      ⠂ ▌",
+            "▐     ⠈  ▌",
+            "▐     ⠂  ▌",
+            "▐    ⠠   ▌",
+            "▐    ⡀   ▌",
+            "▐   ⠠    ▌",
+            "▐   ⠂    ▌",
+            "▐  ⠈     ▌",
+            "▐  ⠂     ▌",
+            "▐ ⠠      ▌",
+            "▐ ⡀      ▌",
+            "▐⠠       ▌",
+        ],
+    },
+    "shark": {
+        "interval": 120,
+        "frames": [
+            "▐|\\____________▌",
+            "▐_|\\___________▌",
+            "▐__|\\__________▌",
+            "▐___|\\_________▌",
+            "▐____|\\________▌",
+            "▐_____|\\_______▌",
+            "▐______|\\______▌",
+            "▐_______|\\_____▌",
+            "▐________|\\____▌",
+            "▐_________|\\___▌",
+            "▐__________|\\__▌",
+            "▐___________|\\_▌",
+            "▐____________|\\▌",
+            "▐____________/|▌",
+            "▐___________/|_▌",
+            "▐__________/|__▌",
+            "▐_________/|___▌",
+            "▐________/|____▌",
+            "▐_______/|_____▌",
+            "▐______/|______▌",
+            "▐_____/|_______▌",
+            "▐____/|________▌",
+            "▐___/|_________▌",
+            "▐__/|__________▌",
+            "▐_/|___________▌",
+            "▐/|____________▌",
+        ],
+    },
+    "dqpb": {"interval": 100, "frames": "dqpb"},
+    "weather": {
+        "interval": 100,
+        "frames": [
+            "☀️ ",
+            "☀️ ",
+            "☀️ ",
+            "🌤 ",
+            "⛅️ ",
+            "🌥 ",
+            "☁️ ",
+            "🌧 ",
+            "🌨 ",
+            "🌧 ",
+            "🌨 ",
+            "🌧 ",
+            "🌨 ",
+            "⛈ ",
+            "🌨 ",
+            "🌧 ",
+            "🌨 ",
+            "☁️ ",
+            "🌥 ",
+            "⛅️ ",
+            "🌤 ",
+            "☀️ ",
+            "☀️ ",
+        ],
+    },
+    "christmas": {"interval": 400, "frames": "🌲🎄"},
+    "grenade": {
+        "interval": 80,
+        "frames": [
+            "،   ",
+            "′   ",
+            " ´ ",
+            " ‾ ",
+            "  ⸌",
+            "  ⸊",
+            "  |",
+            "  ⁎",
+            "  ⁕",
+            " ෴ ",
+            "  ⁓",
+            "   ",
+            "   ",
+            "   ",
+        ],
+    },
+    "point": {"interval": 125, "frames": ["∙∙∙", "●∙∙", "∙●∙", "∙∙●", "∙∙∙"]},
+    "layer": {"interval": 150, "frames": "-=≡"},
+    "betaWave": {
+        "interval": 80,
+        "frames": [
+            "ρββββββ",
+            "βρβββββ",
+            "ββρββββ",
+            "βββρβββ",
+            "ββββρββ",
+            "βββββρβ",
+            "ββββββρ",
+        ],
+    },
+    "aesthetic": {
+        "interval": 80,
+        "frames": [
+            "▰▱▱▱▱▱▱",
+            "▰▰▱▱▱▱▱",
+            "▰▰▰▱▱▱▱",
+            "▰▰▰▰▱▱▱",
+            "▰▰▰▰▰▱▱",
+            "▰▰▰▰▰▰▱",
+            "▰▰▰▰▰▰▰",
+            "▰▱▱▱▱▱▱",
+        ],
+    },
+}
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/rich/_stack.py b/venv/lib/python3.12/site-packages/pip/_vendor/rich/_stack.py
new file mode 100644
index 00000000..194564e7
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_vendor/rich/_stack.py
@@ -0,0 +1,16 @@
+from typing import List, TypeVar
+
+T = TypeVar("T")
+
+
+class Stack(List[T]):
+    """A small shim over builtin list."""
+
+    @property
+    def top(self) -> T:
+        """Get top of stack."""
+        return self[-1]
+
+    def push(self, item: T) -> None:
+        """Push an item on to the stack (append in stack nomenclature)."""
+        self.append(item)
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/rich/_timer.py b/venv/lib/python3.12/site-packages/pip/_vendor/rich/_timer.py
new file mode 100644
index 00000000..a2ca6be0
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_vendor/rich/_timer.py
@@ -0,0 +1,19 @@
+"""
+Timer context manager, only used in debug.
+
+"""
+
+from time import time
+
+import contextlib
+from typing import Generator
+
+
+@contextlib.contextmanager
+def timer(subject: str = "time") -> Generator[None, None, None]:
+    """print the elapsed time. (only used in debugging)"""
+    start = time()
+    yield
+    elapsed = time() - start
+    elapsed_ms = elapsed * 1000
+    print(f"{subject} elapsed {elapsed_ms:.1f}ms")
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/rich/_win32_console.py b/venv/lib/python3.12/site-packages/pip/_vendor/rich/_win32_console.py
new file mode 100644
index 00000000..81b10829
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_vendor/rich/_win32_console.py
@@ -0,0 +1,662 @@
+"""Light wrapper around the Win32 Console API - this module should only be imported on Windows
+
+The API that this module wraps is documented at https://docs.microsoft.com/en-us/windows/console/console-functions
+"""
+import ctypes
+import sys
+from typing import Any
+
+windll: Any = None
+if sys.platform == "win32":
+    windll = ctypes.LibraryLoader(ctypes.WinDLL)
+else:
+    raise ImportError(f"{__name__} can only be imported on Windows")
+
+import time
+from ctypes import Structure, byref, wintypes
+from typing import IO, NamedTuple, Type, cast
+
+from pip._vendor.rich.color import ColorSystem
+from pip._vendor.rich.style import Style
+
+STDOUT = -11
+ENABLE_VIRTUAL_TERMINAL_PROCESSING = 4
+
+COORD = wintypes._COORD
+
+
+class LegacyWindowsError(Exception):
+    pass
+
+
+class WindowsCoordinates(NamedTuple):
+    """Coordinates in the Windows Console API are (y, x), not (x, y).
+    This class is intended to prevent that confusion.
+    Rows and columns are indexed from 0.
+    This class can be used in place of wintypes._COORD in arguments and argtypes.
+    """
+
+    row: int
+    col: int
+
+    @classmethod
+    def from_param(cls, value: "WindowsCoordinates") -> COORD:
+        """Converts a WindowsCoordinates into a wintypes _COORD structure.
+        This classmethod is internally called by ctypes to perform the conversion.
+
+        Args:
+            value (WindowsCoordinates): The input coordinates to convert.
+
+        Returns:
+            wintypes._COORD: The converted coordinates struct.
+        """
+        return COORD(value.col, value.row)
+
+
+class CONSOLE_SCREEN_BUFFER_INFO(Structure):
+    _fields_ = [
+        ("dwSize", COORD),
+        ("dwCursorPosition", COORD),
+        ("wAttributes", wintypes.WORD),
+        ("srWindow", wintypes.SMALL_RECT),
+        ("dwMaximumWindowSize", COORD),
+    ]
+
+
+class CONSOLE_CURSOR_INFO(ctypes.Structure):
+    _fields_ = [("dwSize", wintypes.DWORD), ("bVisible", wintypes.BOOL)]
+
+
+_GetStdHandle = windll.kernel32.GetStdHandle
+_GetStdHandle.argtypes = [
+    wintypes.DWORD,
+]
+_GetStdHandle.restype = wintypes.HANDLE
+
+
+def GetStdHandle(handle: int = STDOUT) -> wintypes.HANDLE:
+    """Retrieves a handle to the specified standard device (standard input, standard output, or standard error).
+
+    Args:
+        handle (int): Integer identifier for the handle. Defaults to -11 (stdout).
+
+    Returns:
+        wintypes.HANDLE: The handle
+    """
+    return cast(wintypes.HANDLE, _GetStdHandle(handle))
+
+
+_GetConsoleMode = windll.kernel32.GetConsoleMode
+_GetConsoleMode.argtypes = [wintypes.HANDLE, wintypes.LPDWORD]
+_GetConsoleMode.restype = wintypes.BOOL
+
+
+def GetConsoleMode(std_handle: wintypes.HANDLE) -> int:
+    """Retrieves the current input mode of a console's input buffer
+    or the current output mode of a console screen buffer.
+
+    Args:
+        std_handle (wintypes.HANDLE): A handle to the console input buffer or the console screen buffer.
+
+    Raises:
+        LegacyWindowsError: If any error occurs while calling the Windows console API.
+
+    Returns:
+        int: Value representing the current console mode as documented at
+            https://docs.microsoft.com/en-us/windows/console/getconsolemode#parameters
+    """
+
+    console_mode = wintypes.DWORD()
+    success = bool(_GetConsoleMode(std_handle, console_mode))
+    if not success:
+        raise LegacyWindowsError("Unable to get legacy Windows Console Mode")
+    return console_mode.value
+
+
+_FillConsoleOutputCharacterW = windll.kernel32.FillConsoleOutputCharacterW
+_FillConsoleOutputCharacterW.argtypes = [
+    wintypes.HANDLE,
+    ctypes.c_char,
+    wintypes.DWORD,
+    cast(Type[COORD], WindowsCoordinates),
+    ctypes.POINTER(wintypes.DWORD),
+]
+_FillConsoleOutputCharacterW.restype = wintypes.BOOL
+
+
+def FillConsoleOutputCharacter(
+    std_handle: wintypes.HANDLE,
+    char: str,
+    length: int,
+    start: WindowsCoordinates,
+) -> int:
+    """Writes a character to the console screen buffer a specified number of times, beginning at the specified coordinates.
+
+    Args:
+        std_handle (wintypes.HANDLE): A handle to the console input buffer or the console screen buffer.
+        char (str): The character to write. Must be a string of length 1.
+        length (int): The number of times to write the character.
+        start (WindowsCoordinates): The coordinates to start writing at.
+
+    Returns:
+        int: The number of characters written.
+    """
+    character = ctypes.c_char(char.encode())
+    num_characters = wintypes.DWORD(length)
+    num_written = wintypes.DWORD(0)
+    _FillConsoleOutputCharacterW(
+        std_handle,
+        character,
+        num_characters,
+        start,
+        byref(num_written),
+    )
+    return num_written.value
+
+
+_FillConsoleOutputAttribute = windll.kernel32.FillConsoleOutputAttribute
+_FillConsoleOutputAttribute.argtypes = [
+    wintypes.HANDLE,
+    wintypes.WORD,
+    wintypes.DWORD,
+    cast(Type[COORD], WindowsCoordinates),
+    ctypes.POINTER(wintypes.DWORD),
+]
+_FillConsoleOutputAttribute.restype = wintypes.BOOL
+
+
+def FillConsoleOutputAttribute(
+    std_handle: wintypes.HANDLE,
+    attributes: int,
+    length: int,
+    start: WindowsCoordinates,
+) -> int:
+    """Sets the character attributes for a specified number of character cells,
+    beginning at the specified coordinates in a screen buffer.
+
+    Args:
+        std_handle (wintypes.HANDLE): A handle to the console input buffer or the console screen buffer.
+        attributes (int): Integer value representing the foreground and background colours of the cells.
+        length (int): The number of cells to set the output attribute of.
+        start (WindowsCoordinates): The coordinates of the first cell whose attributes are to be set.
+
+    Returns:
+        int: The number of cells whose attributes were actually set.
+    """
+    num_cells = wintypes.DWORD(length)
+    style_attrs = wintypes.WORD(attributes)
+    num_written = wintypes.DWORD(0)
+    _FillConsoleOutputAttribute(
+        std_handle, style_attrs, num_cells, start, byref(num_written)
+    )
+    return num_written.value
+
+
+_SetConsoleTextAttribute = windll.kernel32.SetConsoleTextAttribute
+_SetConsoleTextAttribute.argtypes = [
+    wintypes.HANDLE,
+    wintypes.WORD,
+]
+_SetConsoleTextAttribute.restype = wintypes.BOOL
+
+
+def SetConsoleTextAttribute(
+    std_handle: wintypes.HANDLE, attributes: wintypes.WORD
+) -> bool:
+    """Set the colour attributes for all text written after this function is called.
+
+    Args:
+        std_handle (wintypes.HANDLE): A handle to the console input buffer or the console screen buffer.
+        attributes (int): Integer value representing the foreground and background colours.
+
+
+    Returns:
+        bool: True if the attribute was set successfully, otherwise False.
+    """
+    return bool(_SetConsoleTextAttribute(std_handle, attributes))
+
+
+_GetConsoleScreenBufferInfo = windll.kernel32.GetConsoleScreenBufferInfo
+_GetConsoleScreenBufferInfo.argtypes = [
+    wintypes.HANDLE,
+    ctypes.POINTER(CONSOLE_SCREEN_BUFFER_INFO),
+]
+_GetConsoleScreenBufferInfo.restype = wintypes.BOOL
+
+
+def GetConsoleScreenBufferInfo(
+    std_handle: wintypes.HANDLE,
+) -> CONSOLE_SCREEN_BUFFER_INFO:
+    """Retrieves information about the specified console screen buffer.
+
+    Args:
+        std_handle (wintypes.HANDLE): A handle to the console input buffer or the console screen buffer.
+
+    Returns:
+        CONSOLE_SCREEN_BUFFER_INFO: A CONSOLE_SCREEN_BUFFER_INFO ctype struct contain information about
+            screen size, cursor position, colour attributes, and more."""
+    console_screen_buffer_info = CONSOLE_SCREEN_BUFFER_INFO()
+    _GetConsoleScreenBufferInfo(std_handle, byref(console_screen_buffer_info))
+    return console_screen_buffer_info
+
+
+_SetConsoleCursorPosition = windll.kernel32.SetConsoleCursorPosition
+_SetConsoleCursorPosition.argtypes = [
+    wintypes.HANDLE,
+    cast(Type[COORD], WindowsCoordinates),
+]
+_SetConsoleCursorPosition.restype = wintypes.BOOL
+
+
+def SetConsoleCursorPosition(
+    std_handle: wintypes.HANDLE, coords: WindowsCoordinates
+) -> bool:
+    """Set the position of the cursor in the console screen
+
+    Args:
+        std_handle (wintypes.HANDLE): A handle to the console input buffer or the console screen buffer.
+        coords (WindowsCoordinates): The coordinates to move the cursor to.
+
+    Returns:
+        bool: True if the function succeeds, otherwise False.
+    """
+    return bool(_SetConsoleCursorPosition(std_handle, coords))
+
+
+_GetConsoleCursorInfo = windll.kernel32.GetConsoleCursorInfo
+_GetConsoleCursorInfo.argtypes = [
+    wintypes.HANDLE,
+    ctypes.POINTER(CONSOLE_CURSOR_INFO),
+]
+_GetConsoleCursorInfo.restype = wintypes.BOOL
+
+
+def GetConsoleCursorInfo(
+    std_handle: wintypes.HANDLE, cursor_info: CONSOLE_CURSOR_INFO
+) -> bool:
+    """Get the cursor info - used to get cursor visibility and width
+
+    Args:
+        std_handle (wintypes.HANDLE): A handle to the console input buffer or the console screen buffer.
+        cursor_info (CONSOLE_CURSOR_INFO): CONSOLE_CURSOR_INFO ctype struct that receives information
+            about the console's cursor.
+
+    Returns:
+          bool: True if the function succeeds, otherwise False.
+    """
+    return bool(_GetConsoleCursorInfo(std_handle, byref(cursor_info)))
+
+
+_SetConsoleCursorInfo = windll.kernel32.SetConsoleCursorInfo
+_SetConsoleCursorInfo.argtypes = [
+    wintypes.HANDLE,
+    ctypes.POINTER(CONSOLE_CURSOR_INFO),
+]
+_SetConsoleCursorInfo.restype = wintypes.BOOL
+
+
+def SetConsoleCursorInfo(
+    std_handle: wintypes.HANDLE, cursor_info: CONSOLE_CURSOR_INFO
+) -> bool:
+    """Set the cursor info - used for adjusting cursor visibility and width
+
+    Args:
+        std_handle (wintypes.HANDLE): A handle to the console input buffer or the console screen buffer.
+        cursor_info (CONSOLE_CURSOR_INFO): CONSOLE_CURSOR_INFO ctype struct containing the new cursor info.
+
+    Returns:
+          bool: True if the function succeeds, otherwise False.
+    """
+    return bool(_SetConsoleCursorInfo(std_handle, byref(cursor_info)))
+
+
+_SetConsoleTitle = windll.kernel32.SetConsoleTitleW
+_SetConsoleTitle.argtypes = [wintypes.LPCWSTR]
+_SetConsoleTitle.restype = wintypes.BOOL
+
+
+def SetConsoleTitle(title: str) -> bool:
+    """Sets the title of the current console window
+
+    Args:
+        title (str): The new title of the console window.
+
+    Returns:
+        bool: True if the function succeeds, otherwise False.
+    """
+    return bool(_SetConsoleTitle(title))
+
+
+class LegacyWindowsTerm:
+    """This class allows interaction with the legacy Windows Console API. It should only be used in the context
+    of environments where virtual terminal processing is not available. However, if it is used in a Windows environment,
+    the entire API should work.
+
+    Args:
+        file (IO[str]): The file which the Windows Console API HANDLE is retrieved from, defaults to sys.stdout.
+    """
+
+    BRIGHT_BIT = 8
+
+    # Indices are ANSI color numbers, values are the corresponding Windows Console API color numbers
+    ANSI_TO_WINDOWS = [
+        0,  # black                      The Windows colours are defined in wincon.h as follows:
+        4,  # red                         define FOREGROUND_BLUE            0x0001 -- 0000 0001
+        2,  # green                       define FOREGROUND_GREEN           0x0002 -- 0000 0010
+        6,  # yellow                      define FOREGROUND_RED             0x0004 -- 0000 0100
+        1,  # blue                        define FOREGROUND_INTENSITY       0x0008 -- 0000 1000
+        5,  # magenta                     define BACKGROUND_BLUE            0x0010 -- 0001 0000
+        3,  # cyan                        define BACKGROUND_GREEN           0x0020 -- 0010 0000
+        7,  # white                       define BACKGROUND_RED             0x0040 -- 0100 0000
+        8,  # bright black (grey)         define BACKGROUND_INTENSITY       0x0080 -- 1000 0000
+        12,  # bright red
+        10,  # bright green
+        14,  # bright yellow
+        9,  # bright blue
+        13,  # bright magenta
+        11,  # bright cyan
+        15,  # bright white
+    ]
+
+    def __init__(self, file: "IO[str]") -> None:
+        handle = GetStdHandle(STDOUT)
+        self._handle = handle
+        default_text = GetConsoleScreenBufferInfo(handle).wAttributes
+        self._default_text = default_text
+
+        self._default_fore = default_text & 7
+        self._default_back = (default_text >> 4) & 7
+        self._default_attrs = self._default_fore | (self._default_back << 4)
+
+        self._file = file
+        self.write = file.write
+        self.flush = file.flush
+
+    @property
+    def cursor_position(self) -> WindowsCoordinates:
+        """Returns the current position of the cursor (0-based)
+
+        Returns:
+            WindowsCoordinates: The current cursor position.
+        """
+        coord: COORD = GetConsoleScreenBufferInfo(self._handle).dwCursorPosition
+        return WindowsCoordinates(row=cast(int, coord.Y), col=cast(int, coord.X))
+
+    @property
+    def screen_size(self) -> WindowsCoordinates:
+        """Returns the current size of the console screen buffer, in character columns and rows
+
+        Returns:
+            WindowsCoordinates: The width and height of the screen as WindowsCoordinates.
+        """
+        screen_size: COORD = GetConsoleScreenBufferInfo(self._handle).dwSize
+        return WindowsCoordinates(
+            row=cast(int, screen_size.Y), col=cast(int, screen_size.X)
+        )
+
+    def write_text(self, text: str) -> None:
+        """Write text directly to the terminal without any modification of styles
+
+        Args:
+            text (str): The text to write to the console
+        """
+        self.write(text)
+        self.flush()
+
+    def write_styled(self, text: str, style: Style) -> None:
+        """Write styled text to the terminal.
+
+        Args:
+            text (str): The text to write
+            style (Style): The style of the text
+        """
+        color = style.color
+        bgcolor = style.bgcolor
+        if style.reverse:
+            color, bgcolor = bgcolor, color
+
+        if color:
+            fore = color.downgrade(ColorSystem.WINDOWS).number
+            fore = fore if fore is not None else 7  # Default to ANSI 7: White
+            if style.bold:
+                fore = fore | self.BRIGHT_BIT
+            if style.dim:
+                fore = fore & ~self.BRIGHT_BIT
+            fore = self.ANSI_TO_WINDOWS[fore]
+        else:
+            fore = self._default_fore
+
+        if bgcolor:
+            back = bgcolor.downgrade(ColorSystem.WINDOWS).number
+            back = back if back is not None else 0  # Default to ANSI 0: Black
+            back = self.ANSI_TO_WINDOWS[back]
+        else:
+            back = self._default_back
+
+        assert fore is not None
+        assert back is not None
+
+        SetConsoleTextAttribute(
+            self._handle, attributes=ctypes.c_ushort(fore | (back << 4))
+        )
+        self.write_text(text)
+        SetConsoleTextAttribute(self._handle, attributes=self._default_text)
+
+    def move_cursor_to(self, new_position: WindowsCoordinates) -> None:
+        """Set the position of the cursor
+
+        Args:
+            new_position (WindowsCoordinates): The WindowsCoordinates representing the new position of the cursor.
+        """
+        if new_position.col < 0 or new_position.row < 0:
+            return
+        SetConsoleCursorPosition(self._handle, coords=new_position)
+
+    def erase_line(self) -> None:
+        """Erase all content on the line the cursor is currently located at"""
+        screen_size = self.screen_size
+        cursor_position = self.cursor_position
+        cells_to_erase = screen_size.col
+        start_coordinates = WindowsCoordinates(row=cursor_position.row, col=0)
+        FillConsoleOutputCharacter(
+            self._handle, " ", length=cells_to_erase, start=start_coordinates
+        )
+        FillConsoleOutputAttribute(
+            self._handle,
+            self._default_attrs,
+            length=cells_to_erase,
+            start=start_coordinates,
+        )
+
+    def erase_end_of_line(self) -> None:
+        """Erase all content from the cursor position to the end of that line"""
+        cursor_position = self.cursor_position
+        cells_to_erase = self.screen_size.col - cursor_position.col
+        FillConsoleOutputCharacter(
+            self._handle, " ", length=cells_to_erase, start=cursor_position
+        )
+        FillConsoleOutputAttribute(
+            self._handle,
+            self._default_attrs,
+            length=cells_to_erase,
+            start=cursor_position,
+        )
+
+    def erase_start_of_line(self) -> None:
+        """Erase all content from the cursor position to the start of that line"""
+        row, col = self.cursor_position
+        start = WindowsCoordinates(row, 0)
+        FillConsoleOutputCharacter(self._handle, " ", length=col, start=start)
+        FillConsoleOutputAttribute(
+            self._handle, self._default_attrs, length=col, start=start
+        )
+
+    def move_cursor_up(self) -> None:
+        """Move the cursor up a single cell"""
+        cursor_position = self.cursor_position
+        SetConsoleCursorPosition(
+            self._handle,
+            coords=WindowsCoordinates(
+                row=cursor_position.row - 1, col=cursor_position.col
+            ),
+        )
+
+    def move_cursor_down(self) -> None:
+        """Move the cursor down a single cell"""
+        cursor_position = self.cursor_position
+        SetConsoleCursorPosition(
+            self._handle,
+            coords=WindowsCoordinates(
+                row=cursor_position.row + 1,
+                col=cursor_position.col,
+            ),
+        )
+
+    def move_cursor_forward(self) -> None:
+        """Move the cursor forward a single cell. Wrap to the next line if required."""
+        row, col = self.cursor_position
+        if col == self.screen_size.col - 1:
+            row += 1
+            col = 0
+        else:
+            col += 1
+        SetConsoleCursorPosition(
+            self._handle, coords=WindowsCoordinates(row=row, col=col)
+        )
+
+    def move_cursor_to_column(self, column: int) -> None:
+        """Move cursor to the column specified by the zero-based column index, staying on the same row
+
+        Args:
+            column (int): The zero-based column index to move the cursor to.
+        """
+        row, _ = self.cursor_position
+        SetConsoleCursorPosition(self._handle, coords=WindowsCoordinates(row, column))
+
+    def move_cursor_backward(self) -> None:
+        """Move the cursor backward a single cell. Wrap to the previous line if required."""
+        row, col = self.cursor_position
+        if col == 0:
+            row -= 1
+            col = self.screen_size.col - 1
+        else:
+            col -= 1
+        SetConsoleCursorPosition(
+            self._handle, coords=WindowsCoordinates(row=row, col=col)
+        )
+
+    def hide_cursor(self) -> None:
+        """Hide the cursor"""
+        current_cursor_size = self._get_cursor_size()
+        invisible_cursor = CONSOLE_CURSOR_INFO(dwSize=current_cursor_size, bVisible=0)
+        SetConsoleCursorInfo(self._handle, cursor_info=invisible_cursor)
+
+    def show_cursor(self) -> None:
+        """Show the cursor"""
+        current_cursor_size = self._get_cursor_size()
+        visible_cursor = CONSOLE_CURSOR_INFO(dwSize=current_cursor_size, bVisible=1)
+        SetConsoleCursorInfo(self._handle, cursor_info=visible_cursor)
+
+    def set_title(self, title: str) -> None:
+        """Set the title of the terminal window
+
+        Args:
+            title (str): The new title of the console window
+        """
+        assert len(title) < 255, "Console title must be less than 255 characters"
+        SetConsoleTitle(title)
+
+    def _get_cursor_size(self) -> int:
+        """Get the percentage of the character cell that is filled by the cursor"""
+        cursor_info = CONSOLE_CURSOR_INFO()
+        GetConsoleCursorInfo(self._handle, cursor_info=cursor_info)
+        return int(cursor_info.dwSize)
+
+
+if __name__ == "__main__":
+    handle = GetStdHandle()
+
+    from pip._vendor.rich.console import Console
+
+    console = Console()
+
+    term = LegacyWindowsTerm(sys.stdout)
+    term.set_title("Win32 Console Examples")
+
+    style = Style(color="black", bgcolor="red")
+
+    heading = Style.parse("black on green")
+
+    # Check colour output
+    console.rule("Checking colour output")
+    console.print("[on red]on red!")
+    console.print("[blue]blue!")
+    console.print("[yellow]yellow!")
+    console.print("[bold yellow]bold yellow!")
+    console.print("[bright_yellow]bright_yellow!")
+    console.print("[dim bright_yellow]dim bright_yellow!")
+    console.print("[italic cyan]italic cyan!")
+    console.print("[bold white on blue]bold white on blue!")
+    console.print("[reverse bold white on blue]reverse bold white on blue!")
+    console.print("[bold black on cyan]bold black on cyan!")
+    console.print("[black on green]black on green!")
+    console.print("[blue on green]blue on green!")
+    console.print("[white on black]white on black!")
+    console.print("[black on white]black on white!")
+    console.print("[#1BB152 on #DA812D]#1BB152 on #DA812D!")
+
+    # Check cursor movement
+    console.rule("Checking cursor movement")
+    console.print()
+    term.move_cursor_backward()
+    term.move_cursor_backward()
+    term.write_text("went back and wrapped to prev line")
+    time.sleep(1)
+    term.move_cursor_up()
+    term.write_text("we go up")
+    time.sleep(1)
+    term.move_cursor_down()
+    term.write_text("and down")
+    time.sleep(1)
+    term.move_cursor_up()
+    term.move_cursor_backward()
+    term.move_cursor_backward()
+    term.write_text("we went up and back 2")
+    time.sleep(1)
+    term.move_cursor_down()
+    term.move_cursor_backward()
+    term.move_cursor_backward()
+    term.write_text("we went down and back 2")
+    time.sleep(1)
+
+    # Check erasing of lines
+    term.hide_cursor()
+    console.print()
+    console.rule("Checking line erasing")
+    console.print("\n...Deleting to the start of the line...")
+    term.write_text("The red arrow shows the cursor location, and direction of erase")
+    time.sleep(1)
+    term.move_cursor_to_column(16)
+    term.write_styled("<", Style.parse("black on red"))
+    term.move_cursor_backward()
+    time.sleep(1)
+    term.erase_start_of_line()
+    time.sleep(1)
+
+    console.print("\n\n...And to the end of the line...")
+    term.write_text("The red arrow shows the cursor location, and direction of erase")
+    time.sleep(1)
+
+    term.move_cursor_to_column(16)
+    term.write_styled(">", Style.parse("black on red"))
+    time.sleep(1)
+    term.erase_end_of_line()
+    time.sleep(1)
+
+    console.print("\n\n...Now the whole line will be erased...")
+    term.write_styled("I'm going to disappear!", style=Style.parse("black on cyan"))
+    time.sleep(1)
+    term.erase_line()
+
+    term.show_cursor()
+    print("\n")
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/rich/_windows.py b/venv/lib/python3.12/site-packages/pip/_vendor/rich/_windows.py
new file mode 100644
index 00000000..7520a9f9
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_vendor/rich/_windows.py
@@ -0,0 +1,71 @@
+import sys
+from dataclasses import dataclass
+
+
+@dataclass
+class WindowsConsoleFeatures:
+    """Windows features available."""
+
+    vt: bool = False
+    """The console supports VT codes."""
+    truecolor: bool = False
+    """The console supports truecolor."""
+
+
+try:
+    import ctypes
+    from ctypes import LibraryLoader
+
+    if sys.platform == "win32":
+        windll = LibraryLoader(ctypes.WinDLL)
+    else:
+        windll = None
+        raise ImportError("Not windows")
+
+    from pip._vendor.rich._win32_console import (
+        ENABLE_VIRTUAL_TERMINAL_PROCESSING,
+        GetConsoleMode,
+        GetStdHandle,
+        LegacyWindowsError,
+    )
+
+except (AttributeError, ImportError, ValueError):
+    # Fallback if we can't load the Windows DLL
+    def get_windows_console_features() -> WindowsConsoleFeatures:
+        features = WindowsConsoleFeatures()
+        return features
+
+else:
+
+    def get_windows_console_features() -> WindowsConsoleFeatures:
+        """Get windows console features.
+
+        Returns:
+            WindowsConsoleFeatures: An instance of WindowsConsoleFeatures.
+        """
+        handle = GetStdHandle()
+        try:
+            console_mode = GetConsoleMode(handle)
+            success = True
+        except LegacyWindowsError:
+            console_mode = 0
+            success = False
+        vt = bool(success and console_mode & ENABLE_VIRTUAL_TERMINAL_PROCESSING)
+        truecolor = False
+        if vt:
+            win_version = sys.getwindowsversion()
+            truecolor = win_version.major > 10 or (
+                win_version.major == 10 and win_version.build >= 15063
+            )
+        features = WindowsConsoleFeatures(vt=vt, truecolor=truecolor)
+        return features
+
+
+if __name__ == "__main__":
+    import platform
+
+    features = get_windows_console_features()
+    from pip._vendor.rich import print
+
+    print(f'platform="{platform.system()}"')
+    print(repr(features))
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/rich/_windows_renderer.py b/venv/lib/python3.12/site-packages/pip/_vendor/rich/_windows_renderer.py
new file mode 100644
index 00000000..5ece0564
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_vendor/rich/_windows_renderer.py
@@ -0,0 +1,56 @@
+from typing import Iterable, Sequence, Tuple, cast
+
+from pip._vendor.rich._win32_console import LegacyWindowsTerm, WindowsCoordinates
+from pip._vendor.rich.segment import ControlCode, ControlType, Segment
+
+
+def legacy_windows_render(buffer: Iterable[Segment], term: LegacyWindowsTerm) -> None:
+    """Makes appropriate Windows Console API calls based on the segments in the buffer.
+
+    Args:
+        buffer (Iterable[Segment]): Iterable of Segments to convert to Win32 API calls.
+        term (LegacyWindowsTerm): Used to call the Windows Console API.
+    """
+    for text, style, control in buffer:
+        if not control:
+            if style:
+                term.write_styled(text, style)
+            else:
+                term.write_text(text)
+        else:
+            control_codes: Sequence[ControlCode] = control
+            for control_code in control_codes:
+                control_type = control_code[0]
+                if control_type == ControlType.CURSOR_MOVE_TO:
+                    _, x, y = cast(Tuple[ControlType, int, int], control_code)
+                    term.move_cursor_to(WindowsCoordinates(row=y - 1, col=x - 1))
+                elif control_type == ControlType.CARRIAGE_RETURN:
+                    term.write_text("\r")
+                elif control_type == ControlType.HOME:
+                    term.move_cursor_to(WindowsCoordinates(0, 0))
+                elif control_type == ControlType.CURSOR_UP:
+                    term.move_cursor_up()
+                elif control_type == ControlType.CURSOR_DOWN:
+                    term.move_cursor_down()
+                elif control_type == ControlType.CURSOR_FORWARD:
+                    term.move_cursor_forward()
+                elif control_type == ControlType.CURSOR_BACKWARD:
+                    term.move_cursor_backward()
+                elif control_type == ControlType.CURSOR_MOVE_TO_COLUMN:
+                    _, column = cast(Tuple[ControlType, int], control_code)
+                    term.move_cursor_to_column(column - 1)
+                elif control_type == ControlType.HIDE_CURSOR:
+                    term.hide_cursor()
+                elif control_type == ControlType.SHOW_CURSOR:
+                    term.show_cursor()
+                elif control_type == ControlType.ERASE_IN_LINE:
+                    _, mode = cast(Tuple[ControlType, int], control_code)
+                    if mode == 0:
+                        term.erase_end_of_line()
+                    elif mode == 1:
+                        term.erase_start_of_line()
+                    elif mode == 2:
+                        term.erase_line()
+                elif control_type == ControlType.SET_WINDOW_TITLE:
+                    _, title = cast(Tuple[ControlType, str], control_code)
+                    term.set_title(title)
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/rich/_wrap.py b/venv/lib/python3.12/site-packages/pip/_vendor/rich/_wrap.py
new file mode 100644
index 00000000..2e94ff6f
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_vendor/rich/_wrap.py
@@ -0,0 +1,93 @@
+from __future__ import annotations
+
+import re
+from typing import Iterable
+
+from ._loop import loop_last
+from .cells import cell_len, chop_cells
+
+re_word = re.compile(r"\s*\S+\s*")
+
+
+def words(text: str) -> Iterable[tuple[int, int, str]]:
+    """Yields each word from the text as a tuple
+    containing (start_index, end_index, word). A "word" in this context may
+    include the actual word and any whitespace to the right.
+    """
+    position = 0
+    word_match = re_word.match(text, position)
+    while word_match is not None:
+        start, end = word_match.span()
+        word = word_match.group(0)
+        yield start, end, word
+        word_match = re_word.match(text, end)
+
+
+def divide_line(text: str, width: int, fold: bool = True) -> list[int]:
+    """Given a string of text, and a width (measured in cells), return a list
+    of cell offsets which the string should be split at in order for it to fit
+    within the given width.
+
+    Args:
+        text: The text to examine.
+        width: The available cell width.
+        fold: If True, words longer than `width` will be folded onto a new line.
+
+    Returns:
+        A list of indices to break the line at.
+    """
+    break_positions: list[int] = []  # offsets to insert the breaks at
+    append = break_positions.append
+    cell_offset = 0
+    _cell_len = cell_len
+
+    for start, _end, word in words(text):
+        word_length = _cell_len(word.rstrip())
+        remaining_space = width - cell_offset
+        word_fits_remaining_space = remaining_space >= word_length
+
+        if word_fits_remaining_space:
+            # Simplest case - the word fits within the remaining width for this line.
+            cell_offset += _cell_len(word)
+        else:
+            # Not enough space remaining for this word on the current line.
+            if word_length > width:
+                # The word doesn't fit on any line, so we can't simply
+                # place it on the next line...
+                if fold:
+                    # Fold the word across multiple lines.
+                    folded_word = chop_cells(word, width=width)
+                    for last, line in loop_last(folded_word):
+                        if start:
+                            append(start)
+                        if last:
+                            cell_offset = _cell_len(line)
+                        else:
+                            start += len(line)
+                else:
+                    # Folding isn't allowed, so crop the word.
+                    if start:
+                        append(start)
+                    cell_offset = _cell_len(word)
+            elif cell_offset and start:
+                # The word doesn't fit within the remaining space on the current
+                # line, but it *can* fit on to the next (empty) line.
+                append(start)
+                cell_offset = _cell_len(word)
+
+    return break_positions
+
+
+if __name__ == "__main__":  # pragma: no cover
+    from .console import Console
+
+    console = Console(width=10)
+    console.print("12345 abcdefghijklmnopqrstuvwyxzABCDEFGHIJKLMNOPQRSTUVWXYZ 12345")
+    print(chop_cells("abcdefghijklmnopqrstuvwxyz", 10))
+
+    console = Console(width=20)
+    console.rule()
+    console.print("TextualはPythonの高速アプリケーション開発フレームワークです")
+
+    console.rule()
+    console.print("アプリケーションは1670万色を使用でき")
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/rich/abc.py b/venv/lib/python3.12/site-packages/pip/_vendor/rich/abc.py
new file mode 100644
index 00000000..e6e498ef
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_vendor/rich/abc.py
@@ -0,0 +1,33 @@
+from abc import ABC
+
+
+class RichRenderable(ABC):
+    """An abstract base class for Rich renderables.
+
+    Note that there is no need to extend this class, the intended use is to check if an
+    object supports the Rich renderable protocol. For example::
+
+        if isinstance(my_object, RichRenderable):
+            console.print(my_object)
+
+    """
+
+    @classmethod
+    def __subclasshook__(cls, other: type) -> bool:
+        """Check if this class supports the rich render protocol."""
+        return hasattr(other, "__rich_console__") or hasattr(other, "__rich__")
+
+
+if __name__ == "__main__":  # pragma: no cover
+    from pip._vendor.rich.text import Text
+
+    t = Text()
+    print(isinstance(Text, RichRenderable))
+    print(isinstance(t, RichRenderable))
+
+    class Foo:
+        pass
+
+    f = Foo()
+    print(isinstance(f, RichRenderable))
+    print(isinstance("", RichRenderable))
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/rich/align.py b/venv/lib/python3.12/site-packages/pip/_vendor/rich/align.py
new file mode 100644
index 00000000..f7b734fd
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_vendor/rich/align.py
@@ -0,0 +1,311 @@
+import sys
+from itertools import chain
+from typing import TYPE_CHECKING, Iterable, Optional
+
+if sys.version_info >= (3, 8):
+    from typing import Literal
+else:
+    from pip._vendor.typing_extensions import Literal  # pragma: no cover
+
+from .constrain import Constrain
+from .jupyter import JupyterMixin
+from .measure import Measurement
+from .segment import Segment
+from .style import StyleType
+
+if TYPE_CHECKING:
+    from .console import Console, ConsoleOptions, RenderableType, RenderResult
+
+AlignMethod = Literal["left", "center", "right"]
+VerticalAlignMethod = Literal["top", "middle", "bottom"]
+
+
+class Align(JupyterMixin):
+    """Align a renderable by adding spaces if necessary.
+
+    Args:
+        renderable (RenderableType): A console renderable.
+        align (AlignMethod): One of "left", "center", or "right""
+        style (StyleType, optional): An optional style to apply to the background.
+        vertical (Optional[VerticalAlignMethod], optional): Optional vertical align, one of "top", "middle", or "bottom". Defaults to None.
+        pad (bool, optional): Pad the right with spaces. Defaults to True.
+        width (int, optional): Restrict contents to given width, or None to use default width. Defaults to None.
+        height (int, optional): Set height of align renderable, or None to fit to contents. Defaults to None.
+
+    Raises:
+        ValueError: if ``align`` is not one of the expected values.
+    """
+
+    def __init__(
+        self,
+        renderable: "RenderableType",
+        align: AlignMethod = "left",
+        style: Optional[StyleType] = None,
+        *,
+        vertical: Optional[VerticalAlignMethod] = None,
+        pad: bool = True,
+        width: Optional[int] = None,
+        height: Optional[int] = None,
+    ) -> None:
+        if align not in ("left", "center", "right"):
+            raise ValueError(
+                f'invalid value for align, expected "left", "center", or "right" (not {align!r})'
+            )
+        if vertical is not None and vertical not in ("top", "middle", "bottom"):
+            raise ValueError(
+                f'invalid value for vertical, expected "top", "middle", or "bottom" (not {vertical!r})'
+            )
+        self.renderable = renderable
+        self.align = align
+        self.style = style
+        self.vertical = vertical
+        self.pad = pad
+        self.width = width
+        self.height = height
+
+    def __repr__(self) -> str:
+        return f"Align({self.renderable!r}, {self.align!r})"
+
+    @classmethod
+    def left(
+        cls,
+        renderable: "RenderableType",
+        style: Optional[StyleType] = None,
+        *,
+        vertical: Optional[VerticalAlignMethod] = None,
+        pad: bool = True,
+        width: Optional[int] = None,
+        height: Optional[int] = None,
+    ) -> "Align":
+        """Align a renderable to the left."""
+        return cls(
+            renderable,
+            "left",
+            style=style,
+            vertical=vertical,
+            pad=pad,
+            width=width,
+            height=height,
+        )
+
+    @classmethod
+    def center(
+        cls,
+        renderable: "RenderableType",
+        style: Optional[StyleType] = None,
+        *,
+        vertical: Optional[VerticalAlignMethod] = None,
+        pad: bool = True,
+        width: Optional[int] = None,
+        height: Optional[int] = None,
+    ) -> "Align":
+        """Align a renderable to the center."""
+        return cls(
+            renderable,
+            "center",
+            style=style,
+            vertical=vertical,
+            pad=pad,
+            width=width,
+            height=height,
+        )
+
+    @classmethod
+    def right(
+        cls,
+        renderable: "RenderableType",
+        style: Optional[StyleType] = None,
+        *,
+        vertical: Optional[VerticalAlignMethod] = None,
+        pad: bool = True,
+        width: Optional[int] = None,
+        height: Optional[int] = None,
+    ) -> "Align":
+        """Align a renderable to the right."""
+        return cls(
+            renderable,
+            "right",
+            style=style,
+            vertical=vertical,
+            pad=pad,
+            width=width,
+            height=height,
+        )
+
+    def __rich_console__(
+        self, console: "Console", options: "ConsoleOptions"
+    ) -> "RenderResult":
+        align = self.align
+        width = console.measure(self.renderable, options=options).maximum
+        rendered = console.render(
+            Constrain(
+                self.renderable, width if self.width is None else min(width, self.width)
+            ),
+            options.update(height=None),
+        )
+        lines = list(Segment.split_lines(rendered))
+        width, height = Segment.get_shape(lines)
+        lines = Segment.set_shape(lines, width, height)
+        new_line = Segment.line()
+        excess_space = options.max_width - width
+        style = console.get_style(self.style) if self.style is not None else None
+
+        def generate_segments() -> Iterable[Segment]:
+            if excess_space <= 0:
+                # Exact fit
+                for line in lines:
+                    yield from line
+                    yield new_line
+
+            elif align == "left":
+                # Pad on the right
+                pad = Segment(" " * excess_space, style) if self.pad else None
+                for line in lines:
+                    yield from line
+                    if pad:
+                        yield pad
+                    yield new_line
+
+            elif align == "center":
+                # Pad left and right
+                left = excess_space // 2
+                pad = Segment(" " * left, style)
+                pad_right = (
+                    Segment(" " * (excess_space - left), style) if self.pad else None
+                )
+                for line in lines:
+                    if left:
+                        yield pad
+                    yield from line
+                    if pad_right:
+                        yield pad_right
+                    yield new_line
+
+            elif align == "right":
+                # Padding on left
+                pad = Segment(" " * excess_space, style)
+                for line in lines:
+                    yield pad
+                    yield from line
+                    yield new_line
+
+        blank_line = (
+            Segment(f"{' ' * (self.width or options.max_width)}\n", style)
+            if self.pad
+            else Segment("\n")
+        )
+
+        def blank_lines(count: int) -> Iterable[Segment]:
+            if count > 0:
+                for _ in range(count):
+                    yield blank_line
+
+        vertical_height = self.height or options.height
+        iter_segments: Iterable[Segment]
+        if self.vertical and vertical_height is not None:
+            if self.vertical == "top":
+                bottom_space = vertical_height - height
+                iter_segments = chain(generate_segments(), blank_lines(bottom_space))
+            elif self.vertical == "middle":
+                top_space = (vertical_height - height) // 2
+                bottom_space = vertical_height - top_space - height
+                iter_segments = chain(
+                    blank_lines(top_space),
+                    generate_segments(),
+                    blank_lines(bottom_space),
+                )
+            else:  #  self.vertical == "bottom":
+                top_space = vertical_height - height
+                iter_segments = chain(blank_lines(top_space), generate_segments())
+        else:
+            iter_segments = generate_segments()
+        if self.style:
+            style = console.get_style(self.style)
+            iter_segments = Segment.apply_style(iter_segments, style)
+        yield from iter_segments
+
+    def __rich_measure__(
+        self, console: "Console", options: "ConsoleOptions"
+    ) -> Measurement:
+        measurement = Measurement.get(console, options, self.renderable)
+        return measurement
+
+
+class VerticalCenter(JupyterMixin):
+    """Vertically aligns a renderable.
+
+    Warn:
+        This class is deprecated and may be removed in a future version. Use Align class with
+        `vertical="middle"`.
+
+    Args:
+        renderable (RenderableType): A renderable object.
+    """
+
+    def __init__(
+        self,
+        renderable: "RenderableType",
+        style: Optional[StyleType] = None,
+    ) -> None:
+        self.renderable = renderable
+        self.style = style
+
+    def __repr__(self) -> str:
+        return f"VerticalCenter({self.renderable!r})"
+
+    def __rich_console__(
+        self, console: "Console", options: "ConsoleOptions"
+    ) -> "RenderResult":
+        style = console.get_style(self.style) if self.style is not None else None
+        lines = console.render_lines(
+            self.renderable, options.update(height=None), pad=False
+        )
+        width, _height = Segment.get_shape(lines)
+        new_line = Segment.line()
+        height = options.height or options.size.height
+        top_space = (height - len(lines)) // 2
+        bottom_space = height - top_space - len(lines)
+        blank_line = Segment(f"{' ' * width}", style)
+
+        def blank_lines(count: int) -> Iterable[Segment]:
+            for _ in range(count):
+                yield blank_line
+                yield new_line
+
+        if top_space > 0:
+            yield from blank_lines(top_space)
+        for line in lines:
+            yield from line
+            yield new_line
+        if bottom_space > 0:
+            yield from blank_lines(bottom_space)
+
+    def __rich_measure__(
+        self, console: "Console", options: "ConsoleOptions"
+    ) -> Measurement:
+        measurement = Measurement.get(console, options, self.renderable)
+        return measurement
+
+
+if __name__ == "__main__":  # pragma: no cover
+    from pip._vendor.rich.console import Console, Group
+    from pip._vendor.rich.highlighter import ReprHighlighter
+    from pip._vendor.rich.panel import Panel
+
+    highlighter = ReprHighlighter()
+    console = Console()
+
+    panel = Panel(
+        Group(
+            Align.left(highlighter("align='left'")),
+            Align.center(highlighter("align='center'")),
+            Align.right(highlighter("align='right'")),
+        ),
+        width=60,
+        style="on dark_blue",
+        title="Align",
+    )
+
+    console.print(
+        Align.center(panel, vertical="middle", style="on red", height=console.height)
+    )
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/rich/ansi.py b/venv/lib/python3.12/site-packages/pip/_vendor/rich/ansi.py
new file mode 100644
index 00000000..66365e65
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_vendor/rich/ansi.py
@@ -0,0 +1,240 @@
+import re
+import sys
+from contextlib import suppress
+from typing import Iterable, NamedTuple, Optional
+
+from .color import Color
+from .style import Style
+from .text import Text
+
+re_ansi = re.compile(
+    r"""
+(?:\x1b\](.*?)\x1b\\)|
+(?:\x1b([(@-Z\\-_]|\[[0-?]*[ -/]*[@-~]))
+""",
+    re.VERBOSE,
+)
+
+
+class _AnsiToken(NamedTuple):
+    """Result of ansi tokenized string."""
+
+    plain: str = ""
+    sgr: Optional[str] = ""
+    osc: Optional[str] = ""
+
+
+def _ansi_tokenize(ansi_text: str) -> Iterable[_AnsiToken]:
+    """Tokenize a string in to plain text and ANSI codes.
+
+    Args:
+        ansi_text (str): A String containing ANSI codes.
+
+    Yields:
+        AnsiToken: A named tuple of (plain, sgr, osc)
+    """
+
+    position = 0
+    sgr: Optional[str]
+    osc: Optional[str]
+    for match in re_ansi.finditer(ansi_text):
+        start, end = match.span(0)
+        osc, sgr = match.groups()
+        if start > position:
+            yield _AnsiToken(ansi_text[position:start])
+        if sgr:
+            if sgr == "(":
+                position = end + 1
+                continue
+            if sgr.endswith("m"):
+                yield _AnsiToken("", sgr[1:-1], osc)
+        else:
+            yield _AnsiToken("", sgr, osc)
+        position = end
+    if position < len(ansi_text):
+        yield _AnsiToken(ansi_text[position:])
+
+
+SGR_STYLE_MAP = {
+    1: "bold",
+    2: "dim",
+    3: "italic",
+    4: "underline",
+    5: "blink",
+    6: "blink2",
+    7: "reverse",
+    8: "conceal",
+    9: "strike",
+    21: "underline2",
+    22: "not dim not bold",
+    23: "not italic",
+    24: "not underline",
+    25: "not blink",
+    26: "not blink2",
+    27: "not reverse",
+    28: "not conceal",
+    29: "not strike",
+    30: "color(0)",
+    31: "color(1)",
+    32: "color(2)",
+    33: "color(3)",
+    34: "color(4)",
+    35: "color(5)",
+    36: "color(6)",
+    37: "color(7)",
+    39: "default",
+    40: "on color(0)",
+    41: "on color(1)",
+    42: "on color(2)",
+    43: "on color(3)",
+    44: "on color(4)",
+    45: "on color(5)",
+    46: "on color(6)",
+    47: "on color(7)",
+    49: "on default",
+    51: "frame",
+    52: "encircle",
+    53: "overline",
+    54: "not frame not encircle",
+    55: "not overline",
+    90: "color(8)",
+    91: "color(9)",
+    92: "color(10)",
+    93: "color(11)",
+    94: "color(12)",
+    95: "color(13)",
+    96: "color(14)",
+    97: "color(15)",
+    100: "on color(8)",
+    101: "on color(9)",
+    102: "on color(10)",
+    103: "on color(11)",
+    104: "on color(12)",
+    105: "on color(13)",
+    106: "on color(14)",
+    107: "on color(15)",
+}
+
+
+class AnsiDecoder:
+    """Translate ANSI code in to styled Text."""
+
+    def __init__(self) -> None:
+        self.style = Style.null()
+
+    def decode(self, terminal_text: str) -> Iterable[Text]:
+        """Decode ANSI codes in an iterable of lines.
+
+        Args:
+            lines (Iterable[str]): An iterable of lines of terminal output.
+
+        Yields:
+            Text: Marked up Text.
+        """
+        for line in terminal_text.splitlines():
+            yield self.decode_line(line)
+
+    def decode_line(self, line: str) -> Text:
+        """Decode a line containing ansi codes.
+
+        Args:
+            line (str): A line of terminal output.
+
+        Returns:
+            Text: A Text instance marked up according to ansi codes.
+        """
+        from_ansi = Color.from_ansi
+        from_rgb = Color.from_rgb
+        _Style = Style
+        text = Text()
+        append = text.append
+        line = line.rsplit("\r", 1)[-1]
+        for plain_text, sgr, osc in _ansi_tokenize(line):
+            if plain_text:
+                append(plain_text, self.style or None)
+            elif osc is not None:
+                if osc.startswith("8;"):
+                    _params, semicolon, link = osc[2:].partition(";")
+                    if semicolon:
+                        self.style = self.style.update_link(link or None)
+            elif sgr is not None:
+                # Translate in to semi-colon separated codes
+                # Ignore invalid codes, because we want to be lenient
+                codes = [
+                    min(255, int(_code) if _code else 0)
+                    for _code in sgr.split(";")
+                    if _code.isdigit() or _code == ""
+                ]
+                iter_codes = iter(codes)
+                for code in iter_codes:
+                    if code == 0:
+                        # reset
+                        self.style = _Style.null()
+                    elif code in SGR_STYLE_MAP:
+                        # styles
+                        self.style += _Style.parse(SGR_STYLE_MAP[code])
+                    elif code == 38:
+                        #  Foreground
+                        with suppress(StopIteration):
+                            color_type = next(iter_codes)
+                            if color_type == 5:
+                                self.style += _Style.from_color(
+                                    from_ansi(next(iter_codes))
+                                )
+                            elif color_type == 2:
+                                self.style += _Style.from_color(
+                                    from_rgb(
+                                        next(iter_codes),
+                                        next(iter_codes),
+                                        next(iter_codes),
+                                    )
+                                )
+                    elif code == 48:
+                        # Background
+                        with suppress(StopIteration):
+                            color_type = next(iter_codes)
+                            if color_type == 5:
+                                self.style += _Style.from_color(
+                                    None, from_ansi(next(iter_codes))
+                                )
+                            elif color_type == 2:
+                                self.style += _Style.from_color(
+                                    None,
+                                    from_rgb(
+                                        next(iter_codes),
+                                        next(iter_codes),
+                                        next(iter_codes),
+                                    ),
+                                )
+
+        return text
+
+
+if sys.platform != "win32" and __name__ == "__main__":  # pragma: no cover
+    import io
+    import os
+    import pty
+    import sys
+
+    decoder = AnsiDecoder()
+
+    stdout = io.BytesIO()
+
+    def read(fd: int) -> bytes:
+        data = os.read(fd, 1024)
+        stdout.write(data)
+        return data
+
+    pty.spawn(sys.argv[1:], read)
+
+    from .console import Console
+
+    console = Console(record=True)
+
+    stdout_result = stdout.getvalue().decode("utf-8")
+    print(stdout_result)
+
+    for line in decoder.decode(stdout_result):
+        console.print(line)
+
+    console.save_html("stdout.html")
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/rich/bar.py b/venv/lib/python3.12/site-packages/pip/_vendor/rich/bar.py
new file mode 100644
index 00000000..022284b5
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_vendor/rich/bar.py
@@ -0,0 +1,93 @@
+from typing import Optional, Union
+
+from .color import Color
+from .console import Console, ConsoleOptions, RenderResult
+from .jupyter import JupyterMixin
+from .measure import Measurement
+from .segment import Segment
+from .style import Style
+
+# There are left-aligned characters for 1/8 to 7/8, but
+# the right-aligned characters exist only for 1/8 and 4/8.
+BEGIN_BLOCK_ELEMENTS = ["█", "█", "█", "▐", "▐", "▐", "▕", "▕"]
+END_BLOCK_ELEMENTS = [" ", "▏", "▎", "▍", "▌", "▋", "▊", "▉"]
+FULL_BLOCK = "█"
+
+
+class Bar(JupyterMixin):
+    """Renders a solid block bar.
+
+    Args:
+        size (float): Value for the end of the bar.
+        begin (float): Begin point (between 0 and size, inclusive).
+        end (float): End point (between 0 and size, inclusive).
+        width (int, optional): Width of the bar, or ``None`` for maximum width. Defaults to None.
+        color (Union[Color, str], optional): Color of the bar. Defaults to "default".
+        bgcolor (Union[Color, str], optional): Color of bar background. Defaults to "default".
+    """
+
+    def __init__(
+        self,
+        size: float,
+        begin: float,
+        end: float,
+        *,
+        width: Optional[int] = None,
+        color: Union[Color, str] = "default",
+        bgcolor: Union[Color, str] = "default",
+    ):
+        self.size = size
+        self.begin = max(begin, 0)
+        self.end = min(end, size)
+        self.width = width
+        self.style = Style(color=color, bgcolor=bgcolor)
+
+    def __repr__(self) -> str:
+        return f"Bar({self.size}, {self.begin}, {self.end})"
+
+    def __rich_console__(
+        self, console: Console, options: ConsoleOptions
+    ) -> RenderResult:
+        width = min(
+            self.width if self.width is not None else options.max_width,
+            options.max_width,
+        )
+
+        if self.begin >= self.end:
+            yield Segment(" " * width, self.style)
+            yield Segment.line()
+            return
+
+        prefix_complete_eights = int(width * 8 * self.begin / self.size)
+        prefix_bar_count = prefix_complete_eights // 8
+        prefix_eights_count = prefix_complete_eights % 8
+
+        body_complete_eights = int(width * 8 * self.end / self.size)
+        body_bar_count = body_complete_eights // 8
+        body_eights_count = body_complete_eights % 8
+
+        # When start and end fall into the same cell, we ideally should render
+        # a symbol that's "center-aligned", but there is no good symbol in Unicode.
+        # In this case, we fall back to right-aligned block symbol for simplicity.
+
+        prefix = " " * prefix_bar_count
+        if prefix_eights_count:
+            prefix += BEGIN_BLOCK_ELEMENTS[prefix_eights_count]
+
+        body = FULL_BLOCK * body_bar_count
+        if body_eights_count:
+            body += END_BLOCK_ELEMENTS[body_eights_count]
+
+        suffix = " " * (width - len(body))
+
+        yield Segment(prefix + body[len(prefix) :] + suffix, self.style)
+        yield Segment.line()
+
+    def __rich_measure__(
+        self, console: Console, options: ConsoleOptions
+    ) -> Measurement:
+        return (
+            Measurement(self.width, self.width)
+            if self.width is not None
+            else Measurement(4, options.max_width)
+        )
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/rich/box.py b/venv/lib/python3.12/site-packages/pip/_vendor/rich/box.py
new file mode 100644
index 00000000..0511a9e4
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_vendor/rich/box.py
@@ -0,0 +1,480 @@
+import sys
+from typing import TYPE_CHECKING, Iterable, List
+
+if sys.version_info >= (3, 8):
+    from typing import Literal
+else:
+    from pip._vendor.typing_extensions import Literal  # pragma: no cover
+
+
+from ._loop import loop_last
+
+if TYPE_CHECKING:
+    from pip._vendor.rich.console import ConsoleOptions
+
+
+class Box:
+    """Defines characters to render boxes.
+
+    ┌─┬┐ top
+    │ ││ head
+    ├─┼┤ head_row
+    │ ││ mid
+    ├─┼┤ row
+    ├─┼┤ foot_row
+    │ ││ foot
+    └─┴┘ bottom
+
+    Args:
+        box (str): Characters making up box.
+        ascii (bool, optional): True if this box uses ascii characters only. Default is False.
+    """
+
+    def __init__(self, box: str, *, ascii: bool = False) -> None:
+        self._box = box
+        self.ascii = ascii
+        line1, line2, line3, line4, line5, line6, line7, line8 = box.splitlines()
+        # top
+        self.top_left, self.top, self.top_divider, self.top_right = iter(line1)
+        # head
+        self.head_left, _, self.head_vertical, self.head_right = iter(line2)
+        # head_row
+        (
+            self.head_row_left,
+            self.head_row_horizontal,
+            self.head_row_cross,
+            self.head_row_right,
+        ) = iter(line3)
+
+        # mid
+        self.mid_left, _, self.mid_vertical, self.mid_right = iter(line4)
+        # row
+        self.row_left, self.row_horizontal, self.row_cross, self.row_right = iter(line5)
+        # foot_row
+        (
+            self.foot_row_left,
+            self.foot_row_horizontal,
+            self.foot_row_cross,
+            self.foot_row_right,
+        ) = iter(line6)
+        # foot
+        self.foot_left, _, self.foot_vertical, self.foot_right = iter(line7)
+        # bottom
+        self.bottom_left, self.bottom, self.bottom_divider, self.bottom_right = iter(
+            line8
+        )
+
+    def __repr__(self) -> str:
+        return "Box(...)"
+
+    def __str__(self) -> str:
+        return self._box
+
+    def substitute(self, options: "ConsoleOptions", safe: bool = True) -> "Box":
+        """Substitute this box for another if it won't render due to platform issues.
+
+        Args:
+            options (ConsoleOptions): Console options used in rendering.
+            safe (bool, optional): Substitute this for another Box if there are known problems
+                displaying on the platform (currently only relevant on Windows). Default is True.
+
+        Returns:
+            Box: A different Box or the same Box.
+        """
+        box = self
+        if options.legacy_windows and safe:
+            box = LEGACY_WINDOWS_SUBSTITUTIONS.get(box, box)
+        if options.ascii_only and not box.ascii:
+            box = ASCII
+        return box
+
+    def get_plain_headed_box(self) -> "Box":
+        """If this box uses special characters for the borders of the header, then
+        return the equivalent box that does not.
+
+        Returns:
+            Box: The most similar Box that doesn't use header-specific box characters.
+                If the current Box already satisfies this criterion, then it's returned.
+        """
+        return PLAIN_HEADED_SUBSTITUTIONS.get(self, self)
+
+    def get_top(self, widths: Iterable[int]) -> str:
+        """Get the top of a simple box.
+
+        Args:
+            widths (List[int]): Widths of columns.
+
+        Returns:
+            str: A string of box characters.
+        """
+
+        parts: List[str] = []
+        append = parts.append
+        append(self.top_left)
+        for last, width in loop_last(widths):
+            append(self.top * width)
+            if not last:
+                append(self.top_divider)
+        append(self.top_right)
+        return "".join(parts)
+
+    def get_row(
+        self,
+        widths: Iterable[int],
+        level: Literal["head", "row", "foot", "mid"] = "row",
+        edge: bool = True,
+    ) -> str:
+        """Get the top of a simple box.
+
+        Args:
+            width (List[int]): Widths of columns.
+
+        Returns:
+            str: A string of box characters.
+        """
+        if level == "head":
+            left = self.head_row_left
+            horizontal = self.head_row_horizontal
+            cross = self.head_row_cross
+            right = self.head_row_right
+        elif level == "row":
+            left = self.row_left
+            horizontal = self.row_horizontal
+            cross = self.row_cross
+            right = self.row_right
+        elif level == "mid":
+            left = self.mid_left
+            horizontal = " "
+            cross = self.mid_vertical
+            right = self.mid_right
+        elif level == "foot":
+            left = self.foot_row_left
+            horizontal = self.foot_row_horizontal
+            cross = self.foot_row_cross
+            right = self.foot_row_right
+        else:
+            raise ValueError("level must be 'head', 'row' or 'foot'")
+
+        parts: List[str] = []
+        append = parts.append
+        if edge:
+            append(left)
+        for last, width in loop_last(widths):
+            append(horizontal * width)
+            if not last:
+                append(cross)
+        if edge:
+            append(right)
+        return "".join(parts)
+
+    def get_bottom(self, widths: Iterable[int]) -> str:
+        """Get the bottom of a simple box.
+
+        Args:
+            widths (List[int]): Widths of columns.
+
+        Returns:
+            str: A string of box characters.
+        """
+
+        parts: List[str] = []
+        append = parts.append
+        append(self.bottom_left)
+        for last, width in loop_last(widths):
+            append(self.bottom * width)
+            if not last:
+                append(self.bottom_divider)
+        append(self.bottom_right)
+        return "".join(parts)
+
+
+# fmt: off
+ASCII: Box = Box(
+    "+--+\n"
+    "| ||\n"
+    "|-+|\n"
+    "| ||\n"
+    "|-+|\n"
+    "|-+|\n"
+    "| ||\n"
+    "+--+\n",
+    ascii=True,
+)
+
+ASCII2: Box = Box(
+    "+-++\n"
+    "| ||\n"
+    "+-++\n"
+    "| ||\n"
+    "+-++\n"
+    "+-++\n"
+    "| ||\n"
+    "+-++\n",
+    ascii=True,
+)
+
+ASCII_DOUBLE_HEAD: Box = Box(
+    "+-++\n"
+    "| ||\n"
+    "+=++\n"
+    "| ||\n"
+    "+-++\n"
+    "+-++\n"
+    "| ||\n"
+    "+-++\n",
+    ascii=True,
+)
+
+SQUARE: Box = Box(
+    "┌─┬┐\n"
+    "│ ││\n"
+    "├─┼┤\n"
+    "│ ││\n"
+    "├─┼┤\n"
+    "├─┼┤\n"
+    "│ ││\n"
+    "└─┴┘\n"
+)
+
+SQUARE_DOUBLE_HEAD: Box = Box(
+    "┌─┬┐\n"
+    "│ ││\n"
+    "╞═╪╡\n"
+    "│ ││\n"
+    "├─┼┤\n"
+    "├─┼┤\n"
+    "│ ││\n"
+    "└─┴┘\n"
+)
+
+MINIMAL: Box = Box(
+    "  ╷ \n"
+    "  │ \n"
+    "╶─┼╴\n"
+    "  │ \n"
+    "╶─┼╴\n"
+    "╶─┼╴\n"
+    "  │ \n"
+    "  ╵ \n"
+)
+
+
+MINIMAL_HEAVY_HEAD: Box = Box(
+    "  ╷ \n"
+    "  │ \n"
+    "╺━┿╸\n"
+    "  │ \n"
+    "╶─┼╴\n"
+    "╶─┼╴\n"
+    "  │ \n"
+    "  ╵ \n"
+)
+
+MINIMAL_DOUBLE_HEAD: Box = Box(
+    "  ╷ \n"
+    "  │ \n"
+    " ═╪ \n"
+    "  │ \n"
+    " ─┼ \n"
+    " ─┼ \n"
+    "  │ \n"
+    "  ╵ \n"
+)
+
+
+SIMPLE: Box = Box(
+    "    \n"
+    "    \n"
+    " ── \n"
+    "    \n"
+    "    \n"
+    " ── \n"
+    "    \n"
+    "    \n"
+)
+
+SIMPLE_HEAD: Box = Box(
+    "    \n"
+    "    \n"
+    " ── \n"
+    "    \n"
+    "    \n"
+    "    \n"
+    "    \n"
+    "    \n"
+)
+
+
+SIMPLE_HEAVY: Box = Box(
+    "    \n"
+    "    \n"
+    " ━━ \n"
+    "    \n"
+    "    \n"
+    " ━━ \n"
+    "    \n"
+    "    \n"
+)
+
+
+HORIZONTALS: Box = Box(
+    " ── \n"
+    "    \n"
+    " ── \n"
+    "    \n"
+    " ── \n"
+    " ── \n"
+    "    \n"
+    " ── \n"
+)
+
+ROUNDED: Box = Box(
+    "╭─┬╮\n"
+    "│ ││\n"
+    "├─┼┤\n"
+    "│ ││\n"
+    "├─┼┤\n"
+    "├─┼┤\n"
+    "│ ││\n"
+    "╰─┴╯\n"
+)
+
+HEAVY: Box = Box(
+    "┏━┳┓\n"
+    "┃ ┃┃\n"
+    "┣━╋┫\n"
+    "┃ ┃┃\n"
+    "┣━╋┫\n"
+    "┣━╋┫\n"
+    "┃ ┃┃\n"
+    "┗━┻┛\n"
+)
+
+HEAVY_EDGE: Box = Box(
+    "┏━┯┓\n"
+    "┃ │┃\n"
+    "┠─┼┨\n"
+    "┃ │┃\n"
+    "┠─┼┨\n"
+    "┠─┼┨\n"
+    "┃ │┃\n"
+    "┗━┷┛\n"
+)
+
+HEAVY_HEAD: Box = Box(
+    "┏━┳┓\n"
+    "┃ ┃┃\n"
+    "┡━╇┩\n"
+    "│ ││\n"
+    "├─┼┤\n"
+    "├─┼┤\n"
+    "│ ││\n"
+    "└─┴┘\n"
+)
+
+DOUBLE: Box = Box(
+    "╔═╦╗\n"
+    "║ ║║\n"
+    "╠═╬╣\n"
+    "║ ║║\n"
+    "╠═╬╣\n"
+    "╠═╬╣\n"
+    "║ ║║\n"
+    "╚═╩╝\n"
+)
+
+DOUBLE_EDGE: Box = Box(
+    "╔═╤╗\n"
+    "║ │║\n"
+    "╟─┼╢\n"
+    "║ │║\n"
+    "╟─┼╢\n"
+    "╟─┼╢\n"
+    "║ │║\n"
+    "╚═╧╝\n"
+)
+
+MARKDOWN: Box = Box(
+    "    \n"
+    "| ||\n"
+    "|-||\n"
+    "| ||\n"
+    "|-||\n"
+    "|-||\n"
+    "| ||\n"
+    "    \n",
+    ascii=True,
+)
+# fmt: on
+
+# Map Boxes that don't render with raster fonts on to equivalent that do
+LEGACY_WINDOWS_SUBSTITUTIONS = {
+    ROUNDED: SQUARE,
+    MINIMAL_HEAVY_HEAD: MINIMAL,
+    SIMPLE_HEAVY: SIMPLE,
+    HEAVY: SQUARE,
+    HEAVY_EDGE: SQUARE,
+    HEAVY_HEAD: SQUARE,
+}
+
+# Map headed boxes to their headerless equivalents
+PLAIN_HEADED_SUBSTITUTIONS = {
+    HEAVY_HEAD: SQUARE,
+    SQUARE_DOUBLE_HEAD: SQUARE,
+    MINIMAL_DOUBLE_HEAD: MINIMAL,
+    MINIMAL_HEAVY_HEAD: MINIMAL,
+    ASCII_DOUBLE_HEAD: ASCII2,
+}
+
+
+if __name__ == "__main__":  # pragma: no cover
+    from pip._vendor.rich.columns import Columns
+    from pip._vendor.rich.panel import Panel
+
+    from . import box as box
+    from .console import Console
+    from .table import Table
+    from .text import Text
+
+    console = Console(record=True)
+
+    BOXES = [
+        "ASCII",
+        "ASCII2",
+        "ASCII_DOUBLE_HEAD",
+        "SQUARE",
+        "SQUARE_DOUBLE_HEAD",
+        "MINIMAL",
+        "MINIMAL_HEAVY_HEAD",
+        "MINIMAL_DOUBLE_HEAD",
+        "SIMPLE",
+        "SIMPLE_HEAD",
+        "SIMPLE_HEAVY",
+        "HORIZONTALS",
+        "ROUNDED",
+        "HEAVY",
+        "HEAVY_EDGE",
+        "HEAVY_HEAD",
+        "DOUBLE",
+        "DOUBLE_EDGE",
+        "MARKDOWN",
+    ]
+
+    console.print(Panel("[bold green]Box Constants", style="green"), justify="center")
+    console.print()
+
+    columns = Columns(expand=True, padding=2)
+    for box_name in sorted(BOXES):
+        table = Table(
+            show_footer=True, style="dim", border_style="not dim", expand=True
+        )
+        table.add_column("Header 1", "Footer 1")
+        table.add_column("Header 2", "Footer 2")
+        table.add_row("Cell", "Cell")
+        table.add_row("Cell", "Cell")
+        table.box = getattr(box, box_name)
+        table.title = Text(f"box.{box_name}", style="magenta")
+        columns.add_renderable(table)
+    console.print(columns)
+
+    # console.save_svg("box.svg")
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/rich/cells.py b/venv/lib/python3.12/site-packages/pip/_vendor/rich/cells.py
new file mode 100644
index 00000000..f85f928f
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_vendor/rich/cells.py
@@ -0,0 +1,167 @@
+from __future__ import annotations
+
+import re
+from functools import lru_cache
+from typing import Callable
+
+from ._cell_widths import CELL_WIDTHS
+
+# Regex to match sequence of the most common character ranges
+_is_single_cell_widths = re.compile("^[\u0020-\u006f\u00a0\u02ff\u0370-\u0482]*$").match
+
+
+@lru_cache(4096)
+def cached_cell_len(text: str) -> int:
+    """Get the number of cells required to display text.
+
+    This method always caches, which may use up a lot of memory. It is recommended to use
+    `cell_len` over this method.
+
+    Args:
+        text (str): Text to display.
+
+    Returns:
+        int: Get the number of cells required to display text.
+    """
+    _get_size = get_character_cell_size
+    total_size = sum(_get_size(character) for character in text)
+    return total_size
+
+
+def cell_len(text: str, _cell_len: Callable[[str], int] = cached_cell_len) -> int:
+    """Get the number of cells required to display text.
+
+    Args:
+        text (str): Text to display.
+
+    Returns:
+        int: Get the number of cells required to display text.
+    """
+    if len(text) < 512:
+        return _cell_len(text)
+    _get_size = get_character_cell_size
+    total_size = sum(_get_size(character) for character in text)
+    return total_size
+
+
+@lru_cache(maxsize=4096)
+def get_character_cell_size(character: str) -> int:
+    """Get the cell size of a character.
+
+    Args:
+        character (str): A single character.
+
+    Returns:
+        int: Number of cells (0, 1 or 2) occupied by that character.
+    """
+    return _get_codepoint_cell_size(ord(character))
+
+
+@lru_cache(maxsize=4096)
+def _get_codepoint_cell_size(codepoint: int) -> int:
+    """Get the cell size of a character.
+
+    Args:
+        codepoint (int): Codepoint of a character.
+
+    Returns:
+        int: Number of cells (0, 1 or 2) occupied by that character.
+    """
+
+    _table = CELL_WIDTHS
+    lower_bound = 0
+    upper_bound = len(_table) - 1
+    index = (lower_bound + upper_bound) // 2
+    while True:
+        start, end, width = _table[index]
+        if codepoint < start:
+            upper_bound = index - 1
+        elif codepoint > end:
+            lower_bound = index + 1
+        else:
+            return 0 if width == -1 else width
+        if upper_bound < lower_bound:
+            break
+        index = (lower_bound + upper_bound) // 2
+    return 1
+
+
+def set_cell_size(text: str, total: int) -> str:
+    """Set the length of a string to fit within given number of cells."""
+
+    if _is_single_cell_widths(text):
+        size = len(text)
+        if size < total:
+            return text + " " * (total - size)
+        return text[:total]
+
+    if total <= 0:
+        return ""
+    cell_size = cell_len(text)
+    if cell_size == total:
+        return text
+    if cell_size < total:
+        return text + " " * (total - cell_size)
+
+    start = 0
+    end = len(text)
+
+    # Binary search until we find the right size
+    while True:
+        pos = (start + end) // 2
+        before = text[: pos + 1]
+        before_len = cell_len(before)
+        if before_len == total + 1 and cell_len(before[-1]) == 2:
+            return before[:-1] + " "
+        if before_len == total:
+            return before
+        if before_len > total:
+            end = pos
+        else:
+            start = pos
+
+
+def chop_cells(
+    text: str,
+    width: int,
+) -> list[str]:
+    """Split text into lines such that each line fits within the available (cell) width.
+
+    Args:
+        text: The text to fold such that it fits in the given width.
+        width: The width available (number of cells).
+
+    Returns:
+        A list of strings such that each string in the list has cell width
+        less than or equal to the available width.
+    """
+    _get_character_cell_size = get_character_cell_size
+    lines: list[list[str]] = [[]]
+
+    append_new_line = lines.append
+    append_to_last_line = lines[-1].append
+
+    total_width = 0
+
+    for character in text:
+        cell_width = _get_character_cell_size(character)
+        char_doesnt_fit = total_width + cell_width > width
+
+        if char_doesnt_fit:
+            append_new_line([character])
+            append_to_last_line = lines[-1].append
+            total_width = cell_width
+        else:
+            append_to_last_line(character)
+            total_width += cell_width
+
+    return ["".join(line) for line in lines]
+
+
+if __name__ == "__main__":  # pragma: no cover
+    print(get_character_cell_size("😽"))
+    for line in chop_cells("""这是对亚洲语言支持的测试。面对模棱两可的想法，拒绝猜测的诱惑。""", 8):
+        print(line)
+    for n in range(80, 1, -1):
+        print(set_cell_size("""这是对亚洲语言支持的测试。面对模棱两可的想法，拒绝猜测的诱惑。""", n) + "|")
+        print("x" * n)
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/rich/color.py b/venv/lib/python3.12/site-packages/pip/_vendor/rich/color.py
new file mode 100644
index 00000000..4270a278
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_vendor/rich/color.py
@@ -0,0 +1,621 @@
+import platform
+import re
+from colorsys import rgb_to_hls
+from enum import IntEnum
+from functools import lru_cache
+from typing import TYPE_CHECKING, NamedTuple, Optional, Tuple
+
+from ._palettes import EIGHT_BIT_PALETTE, STANDARD_PALETTE, WINDOWS_PALETTE
+from .color_triplet import ColorTriplet
+from .repr import Result, rich_repr
+from .terminal_theme import DEFAULT_TERMINAL_THEME
+
+if TYPE_CHECKING:  # pragma: no cover
+    from .terminal_theme import TerminalTheme
+    from .text import Text
+
+
+WINDOWS = platform.system() == "Windows"
+
+
+class ColorSystem(IntEnum):
+    """One of the 3 color system supported by terminals."""
+
+    STANDARD = 1
+    EIGHT_BIT = 2
+    TRUECOLOR = 3
+    WINDOWS = 4
+
+    def __repr__(self) -> str:
+        return f"ColorSystem.{self.name}"
+
+    def __str__(self) -> str:
+        return repr(self)
+
+
+class ColorType(IntEnum):
+    """Type of color stored in Color class."""
+
+    DEFAULT = 0
+    STANDARD = 1
+    EIGHT_BIT = 2
+    TRUECOLOR = 3
+    WINDOWS = 4
+
+    def __repr__(self) -> str:
+        return f"ColorType.{self.name}"
+
+
+ANSI_COLOR_NAMES = {
+    "black": 0,
+    "red": 1,
+    "green": 2,
+    "yellow": 3,
+    "blue": 4,
+    "magenta": 5,
+    "cyan": 6,
+    "white": 7,
+    "bright_black": 8,
+    "bright_red": 9,
+    "bright_green": 10,
+    "bright_yellow": 11,
+    "bright_blue": 12,
+    "bright_magenta": 13,
+    "bright_cyan": 14,
+    "bright_white": 15,
+    "grey0": 16,
+    "gray0": 16,
+    "navy_blue": 17,
+    "dark_blue": 18,
+    "blue3": 20,
+    "blue1": 21,
+    "dark_green": 22,
+    "deep_sky_blue4": 25,
+    "dodger_blue3": 26,
+    "dodger_blue2": 27,
+    "green4": 28,
+    "spring_green4": 29,
+    "turquoise4": 30,
+    "deep_sky_blue3": 32,
+    "dodger_blue1": 33,
+    "green3": 40,
+    "spring_green3": 41,
+    "dark_cyan": 36,
+    "light_sea_green": 37,
+    "deep_sky_blue2": 38,
+    "deep_sky_blue1": 39,
+    "spring_green2": 47,
+    "cyan3": 43,
+    "dark_turquoise": 44,
+    "turquoise2": 45,
+    "green1": 46,
+    "spring_green1": 48,
+    "medium_spring_green": 49,
+    "cyan2": 50,
+    "cyan1": 51,
+    "dark_red": 88,
+    "deep_pink4": 125,
+    "purple4": 55,
+    "purple3": 56,
+    "blue_violet": 57,
+    "orange4": 94,
+    "grey37": 59,
+    "gray37": 59,
+    "medium_purple4": 60,
+    "slate_blue3": 62,
+    "royal_blue1": 63,
+    "chartreuse4": 64,
+    "dark_sea_green4": 71,
+    "pale_turquoise4": 66,
+    "steel_blue": 67,
+    "steel_blue3": 68,
+    "cornflower_blue": 69,
+    "chartreuse3": 76,
+    "cadet_blue": 73,
+    "sky_blue3": 74,
+    "steel_blue1": 81,
+    "pale_green3": 114,
+    "sea_green3": 78,
+    "aquamarine3": 79,
+    "medium_turquoise": 80,
+    "chartreuse2": 112,
+    "sea_green2": 83,
+    "sea_green1": 85,
+    "aquamarine1": 122,
+    "dark_slate_gray2": 87,
+    "dark_magenta": 91,
+    "dark_violet": 128,
+    "purple": 129,
+    "light_pink4": 95,
+    "plum4": 96,
+    "medium_purple3": 98,
+    "slate_blue1": 99,
+    "yellow4": 106,
+    "wheat4": 101,
+    "grey53": 102,
+    "gray53": 102,
+    "light_slate_grey": 103,
+    "light_slate_gray": 103,
+    "medium_purple": 104,
+    "light_slate_blue": 105,
+    "dark_olive_green3": 149,
+    "dark_sea_green": 108,
+    "light_sky_blue3": 110,
+    "sky_blue2": 111,
+    "dark_sea_green3": 150,
+    "dark_slate_gray3": 116,
+    "sky_blue1": 117,
+    "chartreuse1": 118,
+    "light_green": 120,
+    "pale_green1": 156,
+    "dark_slate_gray1": 123,
+    "red3": 160,
+    "medium_violet_red": 126,
+    "magenta3": 164,
+    "dark_orange3": 166,
+    "indian_red": 167,
+    "hot_pink3": 168,
+    "medium_orchid3": 133,
+    "medium_orchid": 134,
+    "medium_purple2": 140,
+    "dark_goldenrod": 136,
+    "light_salmon3": 173,
+    "rosy_brown": 138,
+    "grey63": 139,
+    "gray63": 139,
+    "medium_purple1": 141,
+    "gold3": 178,
+    "dark_khaki": 143,
+    "navajo_white3": 144,
+    "grey69": 145,
+    "gray69": 145,
+    "light_steel_blue3": 146,
+    "light_steel_blue": 147,
+    "yellow3": 184,
+    "dark_sea_green2": 157,
+    "light_cyan3": 152,
+    "light_sky_blue1": 153,
+    "green_yellow": 154,
+    "dark_olive_green2": 155,
+    "dark_sea_green1": 193,
+    "pale_turquoise1": 159,
+    "deep_pink3": 162,
+    "magenta2": 200,
+    "hot_pink2": 169,
+    "orchid": 170,
+    "medium_orchid1": 207,
+    "orange3": 172,
+    "light_pink3": 174,
+    "pink3": 175,
+    "plum3": 176,
+    "violet": 177,
+    "light_goldenrod3": 179,
+    "tan": 180,
+    "misty_rose3": 181,
+    "thistle3": 182,
+    "plum2": 183,
+    "khaki3": 185,
+    "light_goldenrod2": 222,
+    "light_yellow3": 187,
+    "grey84": 188,
+    "gray84": 188,
+    "light_steel_blue1": 189,
+    "yellow2": 190,
+    "dark_olive_green1": 192,
+    "honeydew2": 194,
+    "light_cyan1": 195,
+    "red1": 196,
+    "deep_pink2": 197,
+    "deep_pink1": 199,
+    "magenta1": 201,
+    "orange_red1": 202,
+    "indian_red1": 204,
+    "hot_pink": 206,
+    "dark_orange": 208,
+    "salmon1": 209,
+    "light_coral": 210,
+    "pale_violet_red1": 211,
+    "orchid2": 212,
+    "orchid1": 213,
+    "orange1": 214,
+    "sandy_brown": 215,
+    "light_salmon1": 216,
+    "light_pink1": 217,
+    "pink1": 218,
+    "plum1": 219,
+    "gold1": 220,
+    "navajo_white1": 223,
+    "misty_rose1": 224,
+    "thistle1": 225,
+    "yellow1": 226,
+    "light_goldenrod1": 227,
+    "khaki1": 228,
+    "wheat1": 229,
+    "cornsilk1": 230,
+    "grey100": 231,
+    "gray100": 231,
+    "grey3": 232,
+    "gray3": 232,
+    "grey7": 233,
+    "gray7": 233,
+    "grey11": 234,
+    "gray11": 234,
+    "grey15": 235,
+    "gray15": 235,
+    "grey19": 236,
+    "gray19": 236,
+    "grey23": 237,
+    "gray23": 237,
+    "grey27": 238,
+    "gray27": 238,
+    "grey30": 239,
+    "gray30": 239,
+    "grey35": 240,
+    "gray35": 240,
+    "grey39": 241,
+    "gray39": 241,
+    "grey42": 242,
+    "gray42": 242,
+    "grey46": 243,
+    "gray46": 243,
+    "grey50": 244,
+    "gray50": 244,
+    "grey54": 245,
+    "gray54": 245,
+    "grey58": 246,
+    "gray58": 246,
+    "grey62": 247,
+    "gray62": 247,
+    "grey66": 248,
+    "gray66": 248,
+    "grey70": 249,
+    "gray70": 249,
+    "grey74": 250,
+    "gray74": 250,
+    "grey78": 251,
+    "gray78": 251,
+    "grey82": 252,
+    "gray82": 252,
+    "grey85": 253,
+    "gray85": 253,
+    "grey89": 254,
+    "gray89": 254,
+    "grey93": 255,
+    "gray93": 255,
+}
+
+
+class ColorParseError(Exception):
+    """The color could not be parsed."""
+
+
+RE_COLOR = re.compile(
+    r"""^
+\#([0-9a-f]{6})$|
+color\(([0-9]{1,3})\)$|
+rgb\(([\d\s,]+)\)$
+""",
+    re.VERBOSE,
+)
+
+
+@rich_repr
+class Color(NamedTuple):
+    """Terminal color definition."""
+
+    name: str
+    """The name of the color (typically the input to Color.parse)."""
+    type: ColorType
+    """The type of the color."""
+    number: Optional[int] = None
+    """The color number, if a standard color, or None."""
+    triplet: Optional[ColorTriplet] = None
+    """A triplet of color components, if an RGB color."""
+
+    def __rich__(self) -> "Text":
+        """Displays the actual color if Rich printed."""
+        from .style import Style
+        from .text import Text
+
+        return Text.assemble(
+            f"",
+        )
+
+    def __rich_repr__(self) -> Result:
+        yield self.name
+        yield self.type
+        yield "number", self.number, None
+        yield "triplet", self.triplet, None
+
+    @property
+    def system(self) -> ColorSystem:
+        """Get the native color system for this color."""
+        if self.type == ColorType.DEFAULT:
+            return ColorSystem.STANDARD
+        return ColorSystem(int(self.type))
+
+    @property
+    def is_system_defined(self) -> bool:
+        """Check if the color is ultimately defined by the system."""
+        return self.system not in (ColorSystem.EIGHT_BIT, ColorSystem.TRUECOLOR)
+
+    @property
+    def is_default(self) -> bool:
+        """Check if the color is a default color."""
+        return self.type == ColorType.DEFAULT
+
+    def get_truecolor(
+        self, theme: Optional["TerminalTheme"] = None, foreground: bool = True
+    ) -> ColorTriplet:
+        """Get an equivalent color triplet for this color.
+
+        Args:
+            theme (TerminalTheme, optional): Optional terminal theme, or None to use default. Defaults to None.
+            foreground (bool, optional): True for a foreground color, or False for background. Defaults to True.
+
+        Returns:
+            ColorTriplet: A color triplet containing RGB components.
+        """
+
+        if theme is None:
+            theme = DEFAULT_TERMINAL_THEME
+        if self.type == ColorType.TRUECOLOR:
+            assert self.triplet is not None
+            return self.triplet
+        elif self.type == ColorType.EIGHT_BIT:
+            assert self.number is not None
+            return EIGHT_BIT_PALETTE[self.number]
+        elif self.type == ColorType.STANDARD:
+            assert self.number is not None
+            return theme.ansi_colors[self.number]
+        elif self.type == ColorType.WINDOWS:
+            assert self.number is not None
+            return WINDOWS_PALETTE[self.number]
+        else:  # self.type == ColorType.DEFAULT:
+            assert self.number is None
+            return theme.foreground_color if foreground else theme.background_color
+
+    @classmethod
+    def from_ansi(cls, number: int) -> "Color":
+        """Create a Color number from it's 8-bit ansi number.
+
+        Args:
+            number (int): A number between 0-255 inclusive.
+
+        Returns:
+            Color: A new Color instance.
+        """
+        return cls(
+            name=f"color({number})",
+            type=(ColorType.STANDARD if number < 16 else ColorType.EIGHT_BIT),
+            number=number,
+        )
+
+    @classmethod
+    def from_triplet(cls, triplet: "ColorTriplet") -> "Color":
+        """Create a truecolor RGB color from a triplet of values.
+
+        Args:
+            triplet (ColorTriplet): A color triplet containing red, green and blue components.
+
+        Returns:
+            Color: A new color object.
+        """
+        return cls(name=triplet.hex, type=ColorType.TRUECOLOR, triplet=triplet)
+
+    @classmethod
+    def from_rgb(cls, red: float, green: float, blue: float) -> "Color":
+        """Create a truecolor from three color components in the range(0->255).
+
+        Args:
+            red (float): Red component in range 0-255.
+            green (float): Green component in range 0-255.
+            blue (float): Blue component in range 0-255.
+
+        Returns:
+            Color: A new color object.
+        """
+        return cls.from_triplet(ColorTriplet(int(red), int(green), int(blue)))
+
+    @classmethod
+    def default(cls) -> "Color":
+        """Get a Color instance representing the default color.
+
+        Returns:
+            Color: Default color.
+        """
+        return cls(name="default", type=ColorType.DEFAULT)
+
+    @classmethod
+    @lru_cache(maxsize=1024)
+    def parse(cls, color: str) -> "Color":
+        """Parse a color definition."""
+        original_color = color
+        color = color.lower().strip()
+
+        if color == "default":
+            return cls(color, type=ColorType.DEFAULT)
+
+        color_number = ANSI_COLOR_NAMES.get(color)
+        if color_number is not None:
+            return cls(
+                color,
+                type=(ColorType.STANDARD if color_number < 16 else ColorType.EIGHT_BIT),
+                number=color_number,
+            )
+
+        color_match = RE_COLOR.match(color)
+        if color_match is None:
+            raise ColorParseError(f"{original_color!r} is not a valid color")
+
+        color_24, color_8, color_rgb = color_match.groups()
+        if color_24:
+            triplet = ColorTriplet(
+                int(color_24[0:2], 16), int(color_24[2:4], 16), int(color_24[4:6], 16)
+            )
+            return cls(color, ColorType.TRUECOLOR, triplet=triplet)
+
+        elif color_8:
+            number = int(color_8)
+            if number > 255:
+                raise ColorParseError(f"color number must be <= 255 in {color!r}")
+            return cls(
+                color,
+                type=(ColorType.STANDARD if number < 16 else ColorType.EIGHT_BIT),
+                number=number,
+            )
+
+        else:  #  color_rgb:
+            components = color_rgb.split(",")
+            if len(components) != 3:
+                raise ColorParseError(
+                    f"expected three components in {original_color!r}"
+                )
+            red, green, blue = components
+            triplet = ColorTriplet(int(red), int(green), int(blue))
+            if not all(component <= 255 for component in triplet):
+                raise ColorParseError(
+                    f"color components must be <= 255 in {original_color!r}"
+                )
+            return cls(color, ColorType.TRUECOLOR, triplet=triplet)
+
+    @lru_cache(maxsize=1024)
+    def get_ansi_codes(self, foreground: bool = True) -> Tuple[str, ...]:
+        """Get the ANSI escape codes for this color."""
+        _type = self.type
+        if _type == ColorType.DEFAULT:
+            return ("39" if foreground else "49",)
+
+        elif _type == ColorType.WINDOWS:
+            number = self.number
+            assert number is not None
+            fore, back = (30, 40) if number < 8 else (82, 92)
+            return (str(fore + number if foreground else back + number),)
+
+        elif _type == ColorType.STANDARD:
+            number = self.number
+            assert number is not None
+            fore, back = (30, 40) if number < 8 else (82, 92)
+            return (str(fore + number if foreground else back + number),)
+
+        elif _type == ColorType.EIGHT_BIT:
+            assert self.number is not None
+            return ("38" if foreground else "48", "5", str(self.number))
+
+        else:  # self.standard == ColorStandard.TRUECOLOR:
+            assert self.triplet is not None
+            red, green, blue = self.triplet
+            return ("38" if foreground else "48", "2", str(red), str(green), str(blue))
+
+    @lru_cache(maxsize=1024)
+    def downgrade(self, system: ColorSystem) -> "Color":
+        """Downgrade a color system to a system with fewer colors."""
+
+        if self.type in (ColorType.DEFAULT, system):
+            return self
+        # Convert to 8-bit color from truecolor color
+        if system == ColorSystem.EIGHT_BIT and self.system == ColorSystem.TRUECOLOR:
+            assert self.triplet is not None
+            _h, l, s = rgb_to_hls(*self.triplet.normalized)
+            # If saturation is under 15% assume it is grayscale
+            if s < 0.15:
+                gray = round(l * 25.0)
+                if gray == 0:
+                    color_number = 16
+                elif gray == 25:
+                    color_number = 231
+                else:
+                    color_number = 231 + gray
+                return Color(self.name, ColorType.EIGHT_BIT, number=color_number)
+
+            red, green, blue = self.triplet
+            six_red = red / 95 if red < 95 else 1 + (red - 95) / 40
+            six_green = green / 95 if green < 95 else 1 + (green - 95) / 40
+            six_blue = blue / 95 if blue < 95 else 1 + (blue - 95) / 40
+
+            color_number = (
+                16 + 36 * round(six_red) + 6 * round(six_green) + round(six_blue)
+            )
+            return Color(self.name, ColorType.EIGHT_BIT, number=color_number)
+
+        # Convert to standard from truecolor or 8-bit
+        elif system == ColorSystem.STANDARD:
+            if self.system == ColorSystem.TRUECOLOR:
+                assert self.triplet is not None
+                triplet = self.triplet
+            else:  # self.system == ColorSystem.EIGHT_BIT
+                assert self.number is not None
+                triplet = ColorTriplet(*EIGHT_BIT_PALETTE[self.number])
+
+            color_number = STANDARD_PALETTE.match(triplet)
+            return Color(self.name, ColorType.STANDARD, number=color_number)
+
+        elif system == ColorSystem.WINDOWS:
+            if self.system == ColorSystem.TRUECOLOR:
+                assert self.triplet is not None
+                triplet = self.triplet
+            else:  # self.system == ColorSystem.EIGHT_BIT
+                assert self.number is not None
+                if self.number < 16:
+                    return Color(self.name, ColorType.WINDOWS, number=self.number)
+                triplet = ColorTriplet(*EIGHT_BIT_PALETTE[self.number])
+
+            color_number = WINDOWS_PALETTE.match(triplet)
+            return Color(self.name, ColorType.WINDOWS, number=color_number)
+
+        return self
+
+
+def parse_rgb_hex(hex_color: str) -> ColorTriplet:
+    """Parse six hex characters in to RGB triplet."""
+    assert len(hex_color) == 6, "must be 6 characters"
+    color = ColorTriplet(
+        int(hex_color[0:2], 16), int(hex_color[2:4], 16), int(hex_color[4:6], 16)
+    )
+    return color
+
+
+def blend_rgb(
+    color1: ColorTriplet, color2: ColorTriplet, cross_fade: float = 0.5
+) -> ColorTriplet:
+    """Blend one RGB color in to another."""
+    r1, g1, b1 = color1
+    r2, g2, b2 = color2
+    new_color = ColorTriplet(
+        int(r1 + (r2 - r1) * cross_fade),
+        int(g1 + (g2 - g1) * cross_fade),
+        int(b1 + (b2 - b1) * cross_fade),
+    )
+    return new_color
+
+
+if __name__ == "__main__":  # pragma: no cover
+    from .console import Console
+    from .table import Table
+    from .text import Text
+
+    console = Console()
+
+    table = Table(show_footer=False, show_edge=True)
+    table.add_column("Color", width=10, overflow="ellipsis")
+    table.add_column("Number", justify="right", style="yellow")
+    table.add_column("Name", style="green")
+    table.add_column("Hex", style="blue")
+    table.add_column("RGB", style="magenta")
+
+    colors = sorted((v, k) for k, v in ANSI_COLOR_NAMES.items())
+    for color_number, name in colors:
+        if "grey" in name:
+            continue
+        color_cell = Text(" " * 10, style=f"on {name}")
+        if color_number < 16:
+            table.add_row(color_cell, f"{color_number}", Text(f'"{name}"'))
+        else:
+            color = EIGHT_BIT_PALETTE[color_number]  # type: ignore[has-type]
+            table.add_row(
+                color_cell, str(color_number), Text(f'"{name}"'), color.hex, color.rgb
+            )
+
+    console.print(table)
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/rich/color_triplet.py b/venv/lib/python3.12/site-packages/pip/_vendor/rich/color_triplet.py
new file mode 100644
index 00000000..02cab328
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_vendor/rich/color_triplet.py
@@ -0,0 +1,38 @@
+from typing import NamedTuple, Tuple
+
+
+class ColorTriplet(NamedTuple):
+    """The red, green, and blue components of a color."""
+
+    red: int
+    """Red component in 0 to 255 range."""
+    green: int
+    """Green component in 0 to 255 range."""
+    blue: int
+    """Blue component in 0 to 255 range."""
+
+    @property
+    def hex(self) -> str:
+        """get the color triplet in CSS style."""
+        red, green, blue = self
+        return f"#{red:02x}{green:02x}{blue:02x}"
+
+    @property
+    def rgb(self) -> str:
+        """The color in RGB format.
+
+        Returns:
+            str: An rgb color, e.g. ``"rgb(100,23,255)"``.
+        """
+        red, green, blue = self
+        return f"rgb({red},{green},{blue})"
+
+    @property
+    def normalized(self) -> Tuple[float, float, float]:
+        """Convert components into floats between 0 and 1.
+
+        Returns:
+            Tuple[float, float, float]: A tuple of three normalized colour components.
+        """
+        red, green, blue = self
+        return red / 255.0, green / 255.0, blue / 255.0
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/rich/columns.py b/venv/lib/python3.12/site-packages/pip/_vendor/rich/columns.py
new file mode 100644
index 00000000..669a3a70
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_vendor/rich/columns.py
@@ -0,0 +1,187 @@
+from collections import defaultdict
+from itertools import chain
+from operator import itemgetter
+from typing import Dict, Iterable, List, Optional, Tuple
+
+from .align import Align, AlignMethod
+from .console import Console, ConsoleOptions, RenderableType, RenderResult
+from .constrain import Constrain
+from .measure import Measurement
+from .padding import Padding, PaddingDimensions
+from .table import Table
+from .text import TextType
+from .jupyter import JupyterMixin
+
+
+class Columns(JupyterMixin):
+    """Display renderables in neat columns.
+
+    Args:
+        renderables (Iterable[RenderableType]): Any number of Rich renderables (including str).
+        width (int, optional): The desired width of the columns, or None to auto detect. Defaults to None.
+        padding (PaddingDimensions, optional): Optional padding around cells. Defaults to (0, 1).
+        expand (bool, optional): Expand columns to full width. Defaults to False.
+        equal (bool, optional): Arrange in to equal sized columns. Defaults to False.
+        column_first (bool, optional): Align items from top to bottom (rather than left to right). Defaults to False.
+        right_to_left (bool, optional): Start column from right hand side. Defaults to False.
+        align (str, optional): Align value ("left", "right", or "center") or None for default. Defaults to None.
+        title (TextType, optional): Optional title for Columns.
+    """
+
+    def __init__(
+        self,
+        renderables: Optional[Iterable[RenderableType]] = None,
+        padding: PaddingDimensions = (0, 1),
+        *,
+        width: Optional[int] = None,
+        expand: bool = False,
+        equal: bool = False,
+        column_first: bool = False,
+        right_to_left: bool = False,
+        align: Optional[AlignMethod] = None,
+        title: Optional[TextType] = None,
+    ) -> None:
+        self.renderables = list(renderables or [])
+        self.width = width
+        self.padding = padding
+        self.expand = expand
+        self.equal = equal
+        self.column_first = column_first
+        self.right_to_left = right_to_left
+        self.align: Optional[AlignMethod] = align
+        self.title = title
+
+    def add_renderable(self, renderable: RenderableType) -> None:
+        """Add a renderable to the columns.
+
+        Args:
+            renderable (RenderableType): Any renderable object.
+        """
+        self.renderables.append(renderable)
+
+    def __rich_console__(
+        self, console: Console, options: ConsoleOptions
+    ) -> RenderResult:
+        render_str = console.render_str
+        renderables = [
+            render_str(renderable) if isinstance(renderable, str) else renderable
+            for renderable in self.renderables
+        ]
+        if not renderables:
+            return
+        _top, right, _bottom, left = Padding.unpack(self.padding)
+        width_padding = max(left, right)
+        max_width = options.max_width
+        widths: Dict[int, int] = defaultdict(int)
+        column_count = len(renderables)
+
+        get_measurement = Measurement.get
+        renderable_widths = [
+            get_measurement(console, options, renderable).maximum
+            for renderable in renderables
+        ]
+        if self.equal:
+            renderable_widths = [max(renderable_widths)] * len(renderable_widths)
+
+        def iter_renderables(
+            column_count: int,
+        ) -> Iterable[Tuple[int, Optional[RenderableType]]]:
+            item_count = len(renderables)
+            if self.column_first:
+                width_renderables = list(zip(renderable_widths, renderables))
+
+                column_lengths: List[int] = [item_count // column_count] * column_count
+                for col_no in range(item_count % column_count):
+                    column_lengths[col_no] += 1
+
+                row_count = (item_count + column_count - 1) // column_count
+                cells = [[-1] * column_count for _ in range(row_count)]
+                row = col = 0
+                for index in range(item_count):
+                    cells[row][col] = index
+                    column_lengths[col] -= 1
+                    if column_lengths[col]:
+                        row += 1
+                    else:
+                        col += 1
+                        row = 0
+                for index in chain.from_iterable(cells):
+                    if index == -1:
+                        break
+                    yield width_renderables[index]
+            else:
+                yield from zip(renderable_widths, renderables)
+            # Pad odd elements with spaces
+            if item_count % column_count:
+                for _ in range(column_count - (item_count % column_count)):
+                    yield 0, None
+
+        table = Table.grid(padding=self.padding, collapse_padding=True, pad_edge=False)
+        table.expand = self.expand
+        table.title = self.title
+
+        if self.width is not None:
+            column_count = (max_width) // (self.width + width_padding)
+            for _ in range(column_count):
+                table.add_column(width=self.width)
+        else:
+            while column_count > 1:
+                widths.clear()
+                column_no = 0
+                for renderable_width, _ in iter_renderables(column_count):
+                    widths[column_no] = max(widths[column_no], renderable_width)
+                    total_width = sum(widths.values()) + width_padding * (
+                        len(widths) - 1
+                    )
+                    if total_width > max_width:
+                        column_count = len(widths) - 1
+                        break
+                    else:
+                        column_no = (column_no + 1) % column_count
+                else:
+                    break
+
+        get_renderable = itemgetter(1)
+        _renderables = [
+            get_renderable(_renderable)
+            for _renderable in iter_renderables(column_count)
+        ]
+        if self.equal:
+            _renderables = [
+                None
+                if renderable is None
+                else Constrain(renderable, renderable_widths[0])
+                for renderable in _renderables
+            ]
+        if self.align:
+            align = self.align
+            _Align = Align
+            _renderables = [
+                None if renderable is None else _Align(renderable, align)
+                for renderable in _renderables
+            ]
+
+        right_to_left = self.right_to_left
+        add_row = table.add_row
+        for start in range(0, len(_renderables), column_count):
+            row = _renderables[start : start + column_count]
+            if right_to_left:
+                row = row[::-1]
+            add_row(*row)
+        yield table
+
+
+if __name__ == "__main__":  # pragma: no cover
+    import os
+
+    console = Console()
+
+    files = [f"{i} {s}" for i, s in enumerate(sorted(os.listdir()))]
+    columns = Columns(files, padding=(0, 1), expand=False, equal=False)
+    console.print(columns)
+    console.rule()
+    columns.column_first = True
+    console.print(columns)
+    columns.right_to_left = True
+    console.rule()
+    console.print(columns)
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/rich/console.py b/venv/lib/python3.12/site-packages/pip/_vendor/rich/console.py
new file mode 100644
index 00000000..a11c7c13
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_vendor/rich/console.py
@@ -0,0 +1,2633 @@
+import inspect
+import os
+import platform
+import sys
+import threading
+import zlib
+from abc import ABC, abstractmethod
+from dataclasses import dataclass, field
+from datetime import datetime
+from functools import wraps
+from getpass import getpass
+from html import escape
+from inspect import isclass
+from itertools import islice
+from math import ceil
+from time import monotonic
+from types import FrameType, ModuleType, TracebackType
+from typing import (
+    IO,
+    TYPE_CHECKING,
+    Any,
+    Callable,
+    Dict,
+    Iterable,
+    List,
+    Mapping,
+    NamedTuple,
+    Optional,
+    TextIO,
+    Tuple,
+    Type,
+    Union,
+    cast,
+)
+
+from pip._vendor.rich._null_file import NULL_FILE
+
+if sys.version_info >= (3, 8):
+    from typing import Literal, Protocol, runtime_checkable
+else:
+    from pip._vendor.typing_extensions import (
+        Literal,
+        Protocol,
+        runtime_checkable,
+    )  # pragma: no cover
+
+from . import errors, themes
+from ._emoji_replace import _emoji_replace
+from ._export_format import CONSOLE_HTML_FORMAT, CONSOLE_SVG_FORMAT
+from ._fileno import get_fileno
+from ._log_render import FormatTimeCallable, LogRender
+from .align import Align, AlignMethod
+from .color import ColorSystem, blend_rgb
+from .control import Control
+from .emoji import EmojiVariant
+from .highlighter import NullHighlighter, ReprHighlighter
+from .markup import render as render_markup
+from .measure import Measurement, measure_renderables
+from .pager import Pager, SystemPager
+from .pretty import Pretty, is_expandable
+from .protocol import rich_cast
+from .region import Region
+from .scope import render_scope
+from .screen import Screen
+from .segment import Segment
+from .style import Style, StyleType
+from .styled import Styled
+from .terminal_theme import DEFAULT_TERMINAL_THEME, SVG_EXPORT_THEME, TerminalTheme
+from .text import Text, TextType
+from .theme import Theme, ThemeStack
+
+if TYPE_CHECKING:
+    from ._windows import WindowsConsoleFeatures
+    from .live import Live
+    from .status import Status
+
+JUPYTER_DEFAULT_COLUMNS = 115
+JUPYTER_DEFAULT_LINES = 100
+WINDOWS = platform.system() == "Windows"
+
+HighlighterType = Callable[[Union[str, "Text"]], "Text"]
+JustifyMethod = Literal["default", "left", "center", "right", "full"]
+OverflowMethod = Literal["fold", "crop", "ellipsis", "ignore"]
+
+
+class NoChange:
+    pass
+
+
+NO_CHANGE = NoChange()
+
+try:
+    _STDIN_FILENO = sys.__stdin__.fileno()
+except Exception:
+    _STDIN_FILENO = 0
+try:
+    _STDOUT_FILENO = sys.__stdout__.fileno()
+except Exception:
+    _STDOUT_FILENO = 1
+try:
+    _STDERR_FILENO = sys.__stderr__.fileno()
+except Exception:
+    _STDERR_FILENO = 2
+
+_STD_STREAMS = (_STDIN_FILENO, _STDOUT_FILENO, _STDERR_FILENO)
+_STD_STREAMS_OUTPUT = (_STDOUT_FILENO, _STDERR_FILENO)
+
+
+_TERM_COLORS = {
+    "kitty": ColorSystem.EIGHT_BIT,
+    "256color": ColorSystem.EIGHT_BIT,
+    "16color": ColorSystem.STANDARD,
+}
+
+
+class ConsoleDimensions(NamedTuple):
+    """Size of the terminal."""
+
+    width: int
+    """The width of the console in 'cells'."""
+    height: int
+    """The height of the console in lines."""
+
+
+@dataclass
+class ConsoleOptions:
+    """Options for __rich_console__ method."""
+
+    size: ConsoleDimensions
+    """Size of console."""
+    legacy_windows: bool
+    """legacy_windows: flag for legacy windows."""
+    min_width: int
+    """Minimum width of renderable."""
+    max_width: int
+    """Maximum width of renderable."""
+    is_terminal: bool
+    """True if the target is a terminal, otherwise False."""
+    encoding: str
+    """Encoding of terminal."""
+    max_height: int
+    """Height of container (starts as terminal)"""
+    justify: Optional[JustifyMethod] = None
+    """Justify value override for renderable."""
+    overflow: Optional[OverflowMethod] = None
+    """Overflow value override for renderable."""
+    no_wrap: Optional[bool] = False
+    """Disable wrapping for text."""
+    highlight: Optional[bool] = None
+    """Highlight override for render_str."""
+    markup: Optional[bool] = None
+    """Enable markup when rendering strings."""
+    height: Optional[int] = None
+
+    @property
+    def ascii_only(self) -> bool:
+        """Check if renderables should use ascii only."""
+        return not self.encoding.startswith("utf")
+
+    def copy(self) -> "ConsoleOptions":
+        """Return a copy of the options.
+
+        Returns:
+            ConsoleOptions: a copy of self.
+        """
+        options: ConsoleOptions = ConsoleOptions.__new__(ConsoleOptions)
+        options.__dict__ = self.__dict__.copy()
+        return options
+
+    def update(
+        self,
+        *,
+        width: Union[int, NoChange] = NO_CHANGE,
+        min_width: Union[int, NoChange] = NO_CHANGE,
+        max_width: Union[int, NoChange] = NO_CHANGE,
+        justify: Union[Optional[JustifyMethod], NoChange] = NO_CHANGE,
+        overflow: Union[Optional[OverflowMethod], NoChange] = NO_CHANGE,
+        no_wrap: Union[Optional[bool], NoChange] = NO_CHANGE,
+        highlight: Union[Optional[bool], NoChange] = NO_CHANGE,
+        markup: Union[Optional[bool], NoChange] = NO_CHANGE,
+        height: Union[Optional[int], NoChange] = NO_CHANGE,
+    ) -> "ConsoleOptions":
+        """Update values, return a copy."""
+        options = self.copy()
+        if not isinstance(width, NoChange):
+            options.min_width = options.max_width = max(0, width)
+        if not isinstance(min_width, NoChange):
+            options.min_width = min_width
+        if not isinstance(max_width, NoChange):
+            options.max_width = max_width
+        if not isinstance(justify, NoChange):
+            options.justify = justify
+        if not isinstance(overflow, NoChange):
+            options.overflow = overflow
+        if not isinstance(no_wrap, NoChange):
+            options.no_wrap = no_wrap
+        if not isinstance(highlight, NoChange):
+            options.highlight = highlight
+        if not isinstance(markup, NoChange):
+            options.markup = markup
+        if not isinstance(height, NoChange):
+            if height is not None:
+                options.max_height = height
+            options.height = None if height is None else max(0, height)
+        return options
+
+    def update_width(self, width: int) -> "ConsoleOptions":
+        """Update just the width, return a copy.
+
+        Args:
+            width (int): New width (sets both min_width and max_width)
+
+        Returns:
+            ~ConsoleOptions: New console options instance.
+        """
+        options = self.copy()
+        options.min_width = options.max_width = max(0, width)
+        return options
+
+    def update_height(self, height: int) -> "ConsoleOptions":
+        """Update the height, and return a copy.
+
+        Args:
+            height (int): New height
+
+        Returns:
+            ~ConsoleOptions: New Console options instance.
+        """
+        options = self.copy()
+        options.max_height = options.height = height
+        return options
+
+    def reset_height(self) -> "ConsoleOptions":
+        """Return a copy of the options with height set to ``None``.
+
+        Returns:
+            ~ConsoleOptions: New console options instance.
+        """
+        options = self.copy()
+        options.height = None
+        return options
+
+    def update_dimensions(self, width: int, height: int) -> "ConsoleOptions":
+        """Update the width and height, and return a copy.
+
+        Args:
+            width (int): New width (sets both min_width and max_width).
+            height (int): New height.
+
+        Returns:
+            ~ConsoleOptions: New console options instance.
+        """
+        options = self.copy()
+        options.min_width = options.max_width = max(0, width)
+        options.height = options.max_height = height
+        return options
+
+
+@runtime_checkable
+class RichCast(Protocol):
+    """An object that may be 'cast' to a console renderable."""
+
+    def __rich__(
+        self,
+    ) -> Union["ConsoleRenderable", "RichCast", str]:  # pragma: no cover
+        ...
+
+
+@runtime_checkable
+class ConsoleRenderable(Protocol):
+    """An object that supports the console protocol."""
+
+    def __rich_console__(
+        self, console: "Console", options: "ConsoleOptions"
+    ) -> "RenderResult":  # pragma: no cover
+        ...
+
+
+# A type that may be rendered by Console.
+RenderableType = Union[ConsoleRenderable, RichCast, str]
+"""A string or any object that may be rendered by Rich."""
+
+# The result of calling a __rich_console__ method.
+RenderResult = Iterable[Union[RenderableType, Segment]]
+
+_null_highlighter = NullHighlighter()
+
+
+class CaptureError(Exception):
+    """An error in the Capture context manager."""
+
+
+class NewLine:
+    """A renderable to generate new line(s)"""
+
+    def __init__(self, count: int = 1) -> None:
+        self.count = count
+
+    def __rich_console__(
+        self, console: "Console", options: "ConsoleOptions"
+    ) -> Iterable[Segment]:
+        yield Segment("\n" * self.count)
+
+
+class ScreenUpdate:
+    """Render a list of lines at a given offset."""
+
+    def __init__(self, lines: List[List[Segment]], x: int, y: int) -> None:
+        self._lines = lines
+        self.x = x
+        self.y = y
+
+    def __rich_console__(
+        self, console: "Console", options: ConsoleOptions
+    ) -> RenderResult:
+        x = self.x
+        move_to = Control.move_to
+        for offset, line in enumerate(self._lines, self.y):
+            yield move_to(x, offset)
+            yield from line
+
+
+class Capture:
+    """Context manager to capture the result of printing to the console.
+    See :meth:`~rich.console.Console.capture` for how to use.
+
+    Args:
+        console (Console): A console instance to capture output.
+    """
+
+    def __init__(self, console: "Console") -> None:
+        self._console = console
+        self._result: Optional[str] = None
+
+    def __enter__(self) -> "Capture":
+        self._console.begin_capture()
+        return self
+
+    def __exit__(
+        self,
+        exc_type: Optional[Type[BaseException]],
+        exc_val: Optional[BaseException],
+        exc_tb: Optional[TracebackType],
+    ) -> None:
+        self._result = self._console.end_capture()
+
+    def get(self) -> str:
+        """Get the result of the capture."""
+        if self._result is None:
+            raise CaptureError(
+                "Capture result is not available until context manager exits."
+            )
+        return self._result
+
+
+class ThemeContext:
+    """A context manager to use a temporary theme. See :meth:`~rich.console.Console.use_theme` for usage."""
+
+    def __init__(self, console: "Console", theme: Theme, inherit: bool = True) -> None:
+        self.console = console
+        self.theme = theme
+        self.inherit = inherit
+
+    def __enter__(self) -> "ThemeContext":
+        self.console.push_theme(self.theme)
+        return self
+
+    def __exit__(
+        self,
+        exc_type: Optional[Type[BaseException]],
+        exc_val: Optional[BaseException],
+        exc_tb: Optional[TracebackType],
+    ) -> None:
+        self.console.pop_theme()
+
+
+class PagerContext:
+    """A context manager that 'pages' content. See :meth:`~rich.console.Console.pager` for usage."""
+
+    def __init__(
+        self,
+        console: "Console",
+        pager: Optional[Pager] = None,
+        styles: bool = False,
+        links: bool = False,
+    ) -> None:
+        self._console = console
+        self.pager = SystemPager() if pager is None else pager
+        self.styles = styles
+        self.links = links
+
+    def __enter__(self) -> "PagerContext":
+        self._console._enter_buffer()
+        return self
+
+    def __exit__(
+        self,
+        exc_type: Optional[Type[BaseException]],
+        exc_val: Optional[BaseException],
+        exc_tb: Optional[TracebackType],
+    ) -> None:
+        if exc_type is None:
+            with self._console._lock:
+                buffer: List[Segment] = self._console._buffer[:]
+                del self._console._buffer[:]
+                segments: Iterable[Segment] = buffer
+                if not self.styles:
+                    segments = Segment.strip_styles(segments)
+                elif not self.links:
+                    segments = Segment.strip_links(segments)
+                content = self._console._render_buffer(segments)
+            self.pager.show(content)
+        self._console._exit_buffer()
+
+
+class ScreenContext:
+    """A context manager that enables an alternative screen. See :meth:`~rich.console.Console.screen` for usage."""
+
+    def __init__(
+        self, console: "Console", hide_cursor: bool, style: StyleType = ""
+    ) -> None:
+        self.console = console
+        self.hide_cursor = hide_cursor
+        self.screen = Screen(style=style)
+        self._changed = False
+
+    def update(
+        self, *renderables: RenderableType, style: Optional[StyleType] = None
+    ) -> None:
+        """Update the screen.
+
+        Args:
+            renderable (RenderableType, optional): Optional renderable to replace current renderable,
+                or None for no change. Defaults to None.
+            style: (Style, optional): Replacement style, or None for no change. Defaults to None.
+        """
+        if renderables:
+            self.screen.renderable = (
+                Group(*renderables) if len(renderables) > 1 else renderables[0]
+            )
+        if style is not None:
+            self.screen.style = style
+        self.console.print(self.screen, end="")
+
+    def __enter__(self) -> "ScreenContext":
+        self._changed = self.console.set_alt_screen(True)
+        if self._changed and self.hide_cursor:
+            self.console.show_cursor(False)
+        return self
+
+    def __exit__(
+        self,
+        exc_type: Optional[Type[BaseException]],
+        exc_val: Optional[BaseException],
+        exc_tb: Optional[TracebackType],
+    ) -> None:
+        if self._changed:
+            self.console.set_alt_screen(False)
+            if self.hide_cursor:
+                self.console.show_cursor(True)
+
+
+class Group:
+    """Takes a group of renderables and returns a renderable object that renders the group.
+
+    Args:
+        renderables (Iterable[RenderableType]): An iterable of renderable objects.
+        fit (bool, optional): Fit dimension of group to contents, or fill available space. Defaults to True.
+    """
+
+    def __init__(self, *renderables: "RenderableType", fit: bool = True) -> None:
+        self._renderables = renderables
+        self.fit = fit
+        self._render: Optional[List[RenderableType]] = None
+
+    @property
+    def renderables(self) -> List["RenderableType"]:
+        if self._render is None:
+            self._render = list(self._renderables)
+        return self._render
+
+    def __rich_measure__(
+        self, console: "Console", options: "ConsoleOptions"
+    ) -> "Measurement":
+        if self.fit:
+            return measure_renderables(console, options, self.renderables)
+        else:
+            return Measurement(options.max_width, options.max_width)
+
+    def __rich_console__(
+        self, console: "Console", options: "ConsoleOptions"
+    ) -> RenderResult:
+        yield from self.renderables
+
+
+def group(fit: bool = True) -> Callable[..., Callable[..., Group]]:
+    """A decorator that turns an iterable of renderables in to a group.
+
+    Args:
+        fit (bool, optional): Fit dimension of group to contents, or fill available space. Defaults to True.
+    """
+
+    def decorator(
+        method: Callable[..., Iterable[RenderableType]]
+    ) -> Callable[..., Group]:
+        """Convert a method that returns an iterable of renderables in to a Group."""
+
+        @wraps(method)
+        def _replace(*args: Any, **kwargs: Any) -> Group:
+            renderables = method(*args, **kwargs)
+            return Group(*renderables, fit=fit)
+
+        return _replace
+
+    return decorator
+
+
+def _is_jupyter() -> bool:  # pragma: no cover
+    """Check if we're running in a Jupyter notebook."""
+    try:
+        get_ipython  # type: ignore[name-defined]
+    except NameError:
+        return False
+    ipython = get_ipython()  # type: ignore[name-defined]
+    shell = ipython.__class__.__name__
+    if (
+        "google.colab" in str(ipython.__class__)
+        or os.getenv("DATABRICKS_RUNTIME_VERSION")
+        or shell == "ZMQInteractiveShell"
+    ):
+        return True  # Jupyter notebook or qtconsole
+    elif shell == "TerminalInteractiveShell":
+        return False  # Terminal running IPython
+    else:
+        return False  # Other type (?)
+
+
+COLOR_SYSTEMS = {
+    "standard": ColorSystem.STANDARD,
+    "256": ColorSystem.EIGHT_BIT,
+    "truecolor": ColorSystem.TRUECOLOR,
+    "windows": ColorSystem.WINDOWS,
+}
+
+_COLOR_SYSTEMS_NAMES = {system: name for name, system in COLOR_SYSTEMS.items()}
+
+
+@dataclass
+class ConsoleThreadLocals(threading.local):
+    """Thread local values for Console context."""
+
+    theme_stack: ThemeStack
+    buffer: List[Segment] = field(default_factory=list)
+    buffer_index: int = 0
+
+
+class RenderHook(ABC):
+    """Provides hooks in to the render process."""
+
+    @abstractmethod
+    def process_renderables(
+        self, renderables: List[ConsoleRenderable]
+    ) -> List[ConsoleRenderable]:
+        """Called with a list of objects to render.
+
+        This method can return a new list of renderables, or modify and return the same list.
+
+        Args:
+            renderables (List[ConsoleRenderable]): A number of renderable objects.
+
+        Returns:
+            List[ConsoleRenderable]: A replacement list of renderables.
+        """
+
+
+_windows_console_features: Optional["WindowsConsoleFeatures"] = None
+
+
+def get_windows_console_features() -> "WindowsConsoleFeatures":  # pragma: no cover
+    global _windows_console_features
+    if _windows_console_features is not None:
+        return _windows_console_features
+    from ._windows import get_windows_console_features
+
+    _windows_console_features = get_windows_console_features()
+    return _windows_console_features
+
+
+def detect_legacy_windows() -> bool:
+    """Detect legacy Windows."""
+    return WINDOWS and not get_windows_console_features().vt
+
+
+class Console:
+    """A high level console interface.
+
+    Args:
+        color_system (str, optional): The color system supported by your terminal,
+            either ``"standard"``, ``"256"`` or ``"truecolor"``. Leave as ``"auto"`` to autodetect.
+        force_terminal (Optional[bool], optional): Enable/disable terminal control codes, or None to auto-detect terminal. Defaults to None.
+        force_jupyter (Optional[bool], optional): Enable/disable Jupyter rendering, or None to auto-detect Jupyter. Defaults to None.
+        force_interactive (Optional[bool], optional): Enable/disable interactive mode, or None to auto detect. Defaults to None.
+        soft_wrap (Optional[bool], optional): Set soft wrap default on print method. Defaults to False.
+        theme (Theme, optional): An optional style theme object, or ``None`` for default theme.
+        stderr (bool, optional): Use stderr rather than stdout if ``file`` is not specified. Defaults to False.
+        file (IO, optional): A file object where the console should write to. Defaults to stdout.
+        quiet (bool, Optional): Boolean to suppress all output. Defaults to False.
+        width (int, optional): The width of the terminal. Leave as default to auto-detect width.
+        height (int, optional): The height of the terminal. Leave as default to auto-detect height.
+        style (StyleType, optional): Style to apply to all output, or None for no style. Defaults to None.
+        no_color (Optional[bool], optional): Enabled no color mode, or None to auto detect. Defaults to None.
+        tab_size (int, optional): Number of spaces used to replace a tab character. Defaults to 8.
+        record (bool, optional): Boolean to enable recording of terminal output,
+            required to call :meth:`export_html`, :meth:`export_svg`, and :meth:`export_text`. Defaults to False.
+        markup (bool, optional): Boolean to enable :ref:`console_markup`. Defaults to True.
+        emoji (bool, optional): Enable emoji code. Defaults to True.
+        emoji_variant (str, optional): Optional emoji variant, either "text" or "emoji". Defaults to None.
+        highlight (bool, optional): Enable automatic highlighting. Defaults to True.
+        log_time (bool, optional): Boolean to enable logging of time by :meth:`log` methods. Defaults to True.
+        log_path (bool, optional): Boolean to enable the logging of the caller by :meth:`log`. Defaults to True.
+        log_time_format (Union[str, TimeFormatterCallable], optional): If ``log_time`` is enabled, either string for strftime or callable that formats the time. Defaults to "[%X] ".
+        highlighter (HighlighterType, optional): Default highlighter.
+        legacy_windows (bool, optional): Enable legacy Windows mode, or ``None`` to auto detect. Defaults to ``None``.
+        safe_box (bool, optional): Restrict box options that don't render on legacy Windows.
+        get_datetime (Callable[[], datetime], optional): Callable that gets the current time as a datetime.datetime object (used by Console.log),
+            or None for datetime.now.
+        get_time (Callable[[], time], optional): Callable that gets the current time in seconds, default uses time.monotonic.
+    """
+
+    _environ: Mapping[str, str] = os.environ
+
+    def __init__(
+        self,
+        *,
+        color_system: Optional[
+            Literal["auto", "standard", "256", "truecolor", "windows"]
+        ] = "auto",
+        force_terminal: Optional[bool] = None,
+        force_jupyter: Optional[bool] = None,
+        force_interactive: Optional[bool] = None,
+        soft_wrap: bool = False,
+        theme: Optional[Theme] = None,
+        stderr: bool = False,
+        file: Optional[IO[str]] = None,
+        quiet: bool = False,
+        width: Optional[int] = None,
+        height: Optional[int] = None,
+        style: Optional[StyleType] = None,
+        no_color: Optional[bool] = None,
+        tab_size: int = 8,
+        record: bool = False,
+        markup: bool = True,
+        emoji: bool = True,
+        emoji_variant: Optional[EmojiVariant] = None,
+        highlight: bool = True,
+        log_time: bool = True,
+        log_path: bool = True,
+        log_time_format: Union[str, FormatTimeCallable] = "[%X]",
+        highlighter: Optional["HighlighterType"] = ReprHighlighter(),
+        legacy_windows: Optional[bool] = None,
+        safe_box: bool = True,
+        get_datetime: Optional[Callable[[], datetime]] = None,
+        get_time: Optional[Callable[[], float]] = None,
+        _environ: Optional[Mapping[str, str]] = None,
+    ):
+        # Copy of os.environ allows us to replace it for testing
+        if _environ is not None:
+            self._environ = _environ
+
+        self.is_jupyter = _is_jupyter() if force_jupyter is None else force_jupyter
+        if self.is_jupyter:
+            if width is None:
+                jupyter_columns = self._environ.get("JUPYTER_COLUMNS")
+                if jupyter_columns is not None and jupyter_columns.isdigit():
+                    width = int(jupyter_columns)
+                else:
+                    width = JUPYTER_DEFAULT_COLUMNS
+            if height is None:
+                jupyter_lines = self._environ.get("JUPYTER_LINES")
+                if jupyter_lines is not None and jupyter_lines.isdigit():
+                    height = int(jupyter_lines)
+                else:
+                    height = JUPYTER_DEFAULT_LINES
+
+        self.tab_size = tab_size
+        self.record = record
+        self._markup = markup
+        self._emoji = emoji
+        self._emoji_variant: Optional[EmojiVariant] = emoji_variant
+        self._highlight = highlight
+        self.legacy_windows: bool = (
+            (detect_legacy_windows() and not self.is_jupyter)
+            if legacy_windows is None
+            else legacy_windows
+        )
+
+        if width is None:
+            columns = self._environ.get("COLUMNS")
+            if columns is not None and columns.isdigit():
+                width = int(columns) - self.legacy_windows
+        if height is None:
+            lines = self._environ.get("LINES")
+            if lines is not None and lines.isdigit():
+                height = int(lines)
+
+        self.soft_wrap = soft_wrap
+        self._width = width
+        self._height = height
+
+        self._color_system: Optional[ColorSystem]
+
+        self._force_terminal = None
+        if force_terminal is not None:
+            self._force_terminal = force_terminal
+
+        self._file = file
+        self.quiet = quiet
+        self.stderr = stderr
+
+        if color_system is None:
+            self._color_system = None
+        elif color_system == "auto":
+            self._color_system = self._detect_color_system()
+        else:
+            self._color_system = COLOR_SYSTEMS[color_system]
+
+        self._lock = threading.RLock()
+        self._log_render = LogRender(
+            show_time=log_time,
+            show_path=log_path,
+            time_format=log_time_format,
+        )
+        self.highlighter: HighlighterType = highlighter or _null_highlighter
+        self.safe_box = safe_box
+        self.get_datetime = get_datetime or datetime.now
+        self.get_time = get_time or monotonic
+        self.style = style
+        self.no_color = (
+            no_color if no_color is not None else "NO_COLOR" in self._environ
+        )
+        self.is_interactive = (
+            (self.is_terminal and not self.is_dumb_terminal)
+            if force_interactive is None
+            else force_interactive
+        )
+
+        self._record_buffer_lock = threading.RLock()
+        self._thread_locals = ConsoleThreadLocals(
+            theme_stack=ThemeStack(themes.DEFAULT if theme is None else theme)
+        )
+        self._record_buffer: List[Segment] = []
+        self._render_hooks: List[RenderHook] = []
+        self._live: Optional["Live"] = None
+        self._is_alt_screen = False
+
+    def __repr__(self) -> str:
+        return f""
+
+    @property
+    def file(self) -> IO[str]:
+        """Get the file object to write to."""
+        file = self._file or (sys.stderr if self.stderr else sys.stdout)
+        file = getattr(file, "rich_proxied_file", file)
+        if file is None:
+            file = NULL_FILE
+        return file
+
+    @file.setter
+    def file(self, new_file: IO[str]) -> None:
+        """Set a new file object."""
+        self._file = new_file
+
+    @property
+    def _buffer(self) -> List[Segment]:
+        """Get a thread local buffer."""
+        return self._thread_locals.buffer
+
+    @property
+    def _buffer_index(self) -> int:
+        """Get a thread local buffer."""
+        return self._thread_locals.buffer_index
+
+    @_buffer_index.setter
+    def _buffer_index(self, value: int) -> None:
+        self._thread_locals.buffer_index = value
+
+    @property
+    def _theme_stack(self) -> ThemeStack:
+        """Get the thread local theme stack."""
+        return self._thread_locals.theme_stack
+
+    def _detect_color_system(self) -> Optional[ColorSystem]:
+        """Detect color system from env vars."""
+        if self.is_jupyter:
+            return ColorSystem.TRUECOLOR
+        if not self.is_terminal or self.is_dumb_terminal:
+            return None
+        if WINDOWS:  # pragma: no cover
+            if self.legacy_windows:  # pragma: no cover
+                return ColorSystem.WINDOWS
+            windows_console_features = get_windows_console_features()
+            return (
+                ColorSystem.TRUECOLOR
+                if windows_console_features.truecolor
+                else ColorSystem.EIGHT_BIT
+            )
+        else:
+            color_term = self._environ.get("COLORTERM", "").strip().lower()
+            if color_term in ("truecolor", "24bit"):
+                return ColorSystem.TRUECOLOR
+            term = self._environ.get("TERM", "").strip().lower()
+            _term_name, _hyphen, colors = term.rpartition("-")
+            color_system = _TERM_COLORS.get(colors, ColorSystem.STANDARD)
+            return color_system
+
+    def _enter_buffer(self) -> None:
+        """Enter in to a buffer context, and buffer all output."""
+        self._buffer_index += 1
+
+    def _exit_buffer(self) -> None:
+        """Leave buffer context, and render content if required."""
+        self._buffer_index -= 1
+        self._check_buffer()
+
+    def set_live(self, live: "Live") -> None:
+        """Set Live instance. Used by Live context manager.
+
+        Args:
+            live (Live): Live instance using this Console.
+
+        Raises:
+            errors.LiveError: If this Console has a Live context currently active.
+        """
+        with self._lock:
+            if self._live is not None:
+                raise errors.LiveError("Only one live display may be active at once")
+            self._live = live
+
+    def clear_live(self) -> None:
+        """Clear the Live instance."""
+        with self._lock:
+            self._live = None
+
+    def push_render_hook(self, hook: RenderHook) -> None:
+        """Add a new render hook to the stack.
+
+        Args:
+            hook (RenderHook): Render hook instance.
+        """
+        with self._lock:
+            self._render_hooks.append(hook)
+
+    def pop_render_hook(self) -> None:
+        """Pop the last renderhook from the stack."""
+        with self._lock:
+            self._render_hooks.pop()
+
+    def __enter__(self) -> "Console":
+        """Own context manager to enter buffer context."""
+        self._enter_buffer()
+        return self
+
+    def __exit__(self, exc_type: Any, exc_value: Any, traceback: Any) -> None:
+        """Exit buffer context."""
+        self._exit_buffer()
+
+    def begin_capture(self) -> None:
+        """Begin capturing console output. Call :meth:`end_capture` to exit capture mode and return output."""
+        self._enter_buffer()
+
+    def end_capture(self) -> str:
+        """End capture mode and return captured string.
+
+        Returns:
+            str: Console output.
+        """
+        render_result = self._render_buffer(self._buffer)
+        del self._buffer[:]
+        self._exit_buffer()
+        return render_result
+
+    def push_theme(self, theme: Theme, *, inherit: bool = True) -> None:
+        """Push a new theme on to the top of the stack, replacing the styles from the previous theme.
+        Generally speaking, you should call :meth:`~rich.console.Console.use_theme` to get a context manager, rather
+        than calling this method directly.
+
+        Args:
+            theme (Theme): A theme instance.
+            inherit (bool, optional): Inherit existing styles. Defaults to True.
+        """
+        self._theme_stack.push_theme(theme, inherit=inherit)
+
+    def pop_theme(self) -> None:
+        """Remove theme from top of stack, restoring previous theme."""
+        self._theme_stack.pop_theme()
+
+    def use_theme(self, theme: Theme, *, inherit: bool = True) -> ThemeContext:
+        """Use a different theme for the duration of the context manager.
+
+        Args:
+            theme (Theme): Theme instance to user.
+            inherit (bool, optional): Inherit existing console styles. Defaults to True.
+
+        Returns:
+            ThemeContext: [description]
+        """
+        return ThemeContext(self, theme, inherit)
+
+    @property
+    def color_system(self) -> Optional[str]:
+        """Get color system string.
+
+        Returns:
+            Optional[str]: "standard", "256" or "truecolor".
+        """
+
+        if self._color_system is not None:
+            return _COLOR_SYSTEMS_NAMES[self._color_system]
+        else:
+            return None
+
+    @property
+    def encoding(self) -> str:
+        """Get the encoding of the console file, e.g. ``"utf-8"``.
+
+        Returns:
+            str: A standard encoding string.
+        """
+        return (getattr(self.file, "encoding", "utf-8") or "utf-8").lower()
+
+    @property
+    def is_terminal(self) -> bool:
+        """Check if the console is writing to a terminal.
+
+        Returns:
+            bool: True if the console writing to a device capable of
+            understanding terminal codes, otherwise False.
+        """
+        if self._force_terminal is not None:
+            return self._force_terminal
+
+        if hasattr(sys.stdin, "__module__") and sys.stdin.__module__.startswith(
+            "idlelib"
+        ):
+            # Return False for Idle which claims to be a tty but can't handle ansi codes
+            return False
+
+        if self.is_jupyter:
+            # return False for Jupyter, which may have FORCE_COLOR set
+            return False
+
+        # If FORCE_COLOR env var has any value at all, we assume a terminal.
+        force_color = self._environ.get("FORCE_COLOR")
+        if force_color is not None:
+            self._force_terminal = True
+            return True
+
+        isatty: Optional[Callable[[], bool]] = getattr(self.file, "isatty", None)
+        try:
+            return False if isatty is None else isatty()
+        except ValueError:
+            # in some situation (at the end of a pytest run for example) isatty() can raise
+            # ValueError: I/O operation on closed file
+            # return False because we aren't in a terminal anymore
+            return False
+
+    @property
+    def is_dumb_terminal(self) -> bool:
+        """Detect dumb terminal.
+
+        Returns:
+            bool: True if writing to a dumb terminal, otherwise False.
+
+        """
+        _term = self._environ.get("TERM", "")
+        is_dumb = _term.lower() in ("dumb", "unknown")
+        return self.is_terminal and is_dumb
+
+    @property
+    def options(self) -> ConsoleOptions:
+        """Get default console options."""
+        return ConsoleOptions(
+            max_height=self.size.height,
+            size=self.size,
+            legacy_windows=self.legacy_windows,
+            min_width=1,
+            max_width=self.width,
+            encoding=self.encoding,
+            is_terminal=self.is_terminal,
+        )
+
+    @property
+    def size(self) -> ConsoleDimensions:
+        """Get the size of the console.
+
+        Returns:
+            ConsoleDimensions: A named tuple containing the dimensions.
+        """
+
+        if self._width is not None and self._height is not None:
+            return ConsoleDimensions(self._width - self.legacy_windows, self._height)
+
+        if self.is_dumb_terminal:
+            return ConsoleDimensions(80, 25)
+
+        width: Optional[int] = None
+        height: Optional[int] = None
+
+        if WINDOWS:  # pragma: no cover
+            try:
+                width, height = os.get_terminal_size()
+            except (AttributeError, ValueError, OSError):  # Probably not a terminal
+                pass
+        else:
+            for file_descriptor in _STD_STREAMS:
+                try:
+                    width, height = os.get_terminal_size(file_descriptor)
+                except (AttributeError, ValueError, OSError):
+                    pass
+                else:
+                    break
+
+        columns = self._environ.get("COLUMNS")
+        if columns is not None and columns.isdigit():
+            width = int(columns)
+        lines = self._environ.get("LINES")
+        if lines is not None and lines.isdigit():
+            height = int(lines)
+
+        # get_terminal_size can report 0, 0 if run from pseudo-terminal
+        width = width or 80
+        height = height or 25
+        return ConsoleDimensions(
+            width - self.legacy_windows if self._width is None else self._width,
+            height if self._height is None else self._height,
+        )
+
+    @size.setter
+    def size(self, new_size: Tuple[int, int]) -> None:
+        """Set a new size for the terminal.
+
+        Args:
+            new_size (Tuple[int, int]): New width and height.
+        """
+        width, height = new_size
+        self._width = width
+        self._height = height
+
+    @property
+    def width(self) -> int:
+        """Get the width of the console.
+
+        Returns:
+            int: The width (in characters) of the console.
+        """
+        return self.size.width
+
+    @width.setter
+    def width(self, width: int) -> None:
+        """Set width.
+
+        Args:
+            width (int): New width.
+        """
+        self._width = width
+
+    @property
+    def height(self) -> int:
+        """Get the height of the console.
+
+        Returns:
+            int: The height (in lines) of the console.
+        """
+        return self.size.height
+
+    @height.setter
+    def height(self, height: int) -> None:
+        """Set height.
+
+        Args:
+            height (int): new height.
+        """
+        self._height = height
+
+    def bell(self) -> None:
+        """Play a 'bell' sound (if supported by the terminal)."""
+        self.control(Control.bell())
+
+    def capture(self) -> Capture:
+        """A context manager to *capture* the result of print() or log() in a string,
+        rather than writing it to the console.
+
+        Example:
+            >>> from rich.console import Console
+            >>> console = Console()
+            >>> with console.capture() as capture:
+            ...     console.print("[bold magenta]Hello World[/]")
+            >>> print(capture.get())
+
+        Returns:
+            Capture: Context manager with disables writing to the terminal.
+        """
+        capture = Capture(self)
+        return capture
+
+    def pager(
+        self, pager: Optional[Pager] = None, styles: bool = False, links: bool = False
+    ) -> PagerContext:
+        """A context manager to display anything printed within a "pager". The pager application
+        is defined by the system and will typically support at least pressing a key to scroll.
+
+        Args:
+            pager (Pager, optional): A pager object, or None to use :class:`~rich.pager.SystemPager`. Defaults to None.
+            styles (bool, optional): Show styles in pager. Defaults to False.
+            links (bool, optional): Show links in pager. Defaults to False.
+
+        Example:
+            >>> from rich.console import Console
+            >>> from rich.__main__ import make_test_card
+            >>> console = Console()
+            >>> with console.pager():
+                    console.print(make_test_card())
+
+        Returns:
+            PagerContext: A context manager.
+        """
+        return PagerContext(self, pager=pager, styles=styles, links=links)
+
+    def line(self, count: int = 1) -> None:
+        """Write new line(s).
+
+        Args:
+            count (int, optional): Number of new lines. Defaults to 1.
+        """
+
+        assert count >= 0, "count must be >= 0"
+        self.print(NewLine(count))
+
+    def clear(self, home: bool = True) -> None:
+        """Clear the screen.
+
+        Args:
+            home (bool, optional): Also move the cursor to 'home' position. Defaults to True.
+        """
+        if home:
+            self.control(Control.clear(), Control.home())
+        else:
+            self.control(Control.clear())
+
+    def status(
+        self,
+        status: RenderableType,
+        *,
+        spinner: str = "dots",
+        spinner_style: StyleType = "status.spinner",
+        speed: float = 1.0,
+        refresh_per_second: float = 12.5,
+    ) -> "Status":
+        """Display a status and spinner.
+
+        Args:
+            status (RenderableType): A status renderable (str or Text typically).
+            spinner (str, optional): Name of spinner animation (see python -m rich.spinner). Defaults to "dots".
+            spinner_style (StyleType, optional): Style of spinner. Defaults to "status.spinner".
+            speed (float, optional): Speed factor for spinner animation. Defaults to 1.0.
+            refresh_per_second (float, optional): Number of refreshes per second. Defaults to 12.5.
+
+        Returns:
+            Status: A Status object that may be used as a context manager.
+        """
+        from .status import Status
+
+        status_renderable = Status(
+            status,
+            console=self,
+            spinner=spinner,
+            spinner_style=spinner_style,
+            speed=speed,
+            refresh_per_second=refresh_per_second,
+        )
+        return status_renderable
+
+    def show_cursor(self, show: bool = True) -> bool:
+        """Show or hide the cursor.
+
+        Args:
+            show (bool, optional): Set visibility of the cursor.
+        """
+        if self.is_terminal:
+            self.control(Control.show_cursor(show))
+            return True
+        return False
+
+    def set_alt_screen(self, enable: bool = True) -> bool:
+        """Enables alternative screen mode.
+
+        Note, if you enable this mode, you should ensure that is disabled before
+        the application exits. See :meth:`~rich.Console.screen` for a context manager
+        that handles this for you.
+
+        Args:
+            enable (bool, optional): Enable (True) or disable (False) alternate screen. Defaults to True.
+
+        Returns:
+            bool: True if the control codes were written.
+
+        """
+        changed = False
+        if self.is_terminal and not self.legacy_windows:
+            self.control(Control.alt_screen(enable))
+            changed = True
+            self._is_alt_screen = enable
+        return changed
+
+    @property
+    def is_alt_screen(self) -> bool:
+        """Check if the alt screen was enabled.
+
+        Returns:
+            bool: True if the alt screen was enabled, otherwise False.
+        """
+        return self._is_alt_screen
+
+    def set_window_title(self, title: str) -> bool:
+        """Set the title of the console terminal window.
+
+        Warning: There is no means within Rich of "resetting" the window title to its
+        previous value, meaning the title you set will persist even after your application
+        exits.
+
+        ``fish`` shell resets the window title before and after each command by default,
+        negating this issue. Windows Terminal and command prompt will also reset the title for you.
+        Most other shells and terminals, however, do not do this.
+
+        Some terminals may require configuration changes before you can set the title.
+        Some terminals may not support setting the title at all.
+
+        Other software (including the terminal itself, the shell, custom prompts, plugins, etc.)
+        may also set the terminal window title. This could result in whatever value you write
+        using this method being overwritten.
+
+        Args:
+            title (str): The new title of the terminal window.
+
+        Returns:
+            bool: True if the control code to change the terminal title was
+                written, otherwise False. Note that a return value of True
+                does not guarantee that the window title has actually changed,
+                since the feature may be unsupported/disabled in some terminals.
+        """
+        if self.is_terminal:
+            self.control(Control.title(title))
+            return True
+        return False
+
+    def screen(
+        self, hide_cursor: bool = True, style: Optional[StyleType] = None
+    ) -> "ScreenContext":
+        """Context manager to enable and disable 'alternative screen' mode.
+
+        Args:
+            hide_cursor (bool, optional): Also hide the cursor. Defaults to False.
+            style (Style, optional): Optional style for screen. Defaults to None.
+
+        Returns:
+            ~ScreenContext: Context which enables alternate screen on enter, and disables it on exit.
+        """
+        return ScreenContext(self, hide_cursor=hide_cursor, style=style or "")
+
+    def measure(
+        self, renderable: RenderableType, *, options: Optional[ConsoleOptions] = None
+    ) -> Measurement:
+        """Measure a renderable. Returns a :class:`~rich.measure.Measurement` object which contains
+        information regarding the number of characters required to print the renderable.
+
+        Args:
+            renderable (RenderableType): Any renderable or string.
+            options (Optional[ConsoleOptions], optional): Options to use when measuring, or None
+                to use default options. Defaults to None.
+
+        Returns:
+            Measurement: A measurement of the renderable.
+        """
+        measurement = Measurement.get(self, options or self.options, renderable)
+        return measurement
+
+    def render(
+        self, renderable: RenderableType, options: Optional[ConsoleOptions] = None
+    ) -> Iterable[Segment]:
+        """Render an object in to an iterable of `Segment` instances.
+
+        This method contains the logic for rendering objects with the console protocol.
+        You are unlikely to need to use it directly, unless you are extending the library.
+
+        Args:
+            renderable (RenderableType): An object supporting the console protocol, or
+                an object that may be converted to a string.
+            options (ConsoleOptions, optional): An options object, or None to use self.options. Defaults to None.
+
+        Returns:
+            Iterable[Segment]: An iterable of segments that may be rendered.
+        """
+
+        _options = options or self.options
+        if _options.max_width < 1:
+            # No space to render anything. This prevents potential recursion errors.
+            return
+        render_iterable: RenderResult
+
+        renderable = rich_cast(renderable)
+        if hasattr(renderable, "__rich_console__") and not isclass(renderable):
+            render_iterable = renderable.__rich_console__(self, _options)  # type: ignore[union-attr]
+        elif isinstance(renderable, str):
+            text_renderable = self.render_str(
+                renderable, highlight=_options.highlight, markup=_options.markup
+            )
+            render_iterable = text_renderable.__rich_console__(self, _options)
+        else:
+            raise errors.NotRenderableError(
+                f"Unable to render {renderable!r}; "
+                "A str, Segment or object with __rich_console__ method is required"
+            )
+
+        try:
+            iter_render = iter(render_iterable)
+        except TypeError:
+            raise errors.NotRenderableError(
+                f"object {render_iterable!r} is not renderable"
+            )
+        _Segment = Segment
+        _options = _options.reset_height()
+        for render_output in iter_render:
+            if isinstance(render_output, _Segment):
+                yield render_output
+            else:
+                yield from self.render(render_output, _options)
+
+    def render_lines(
+        self,
+        renderable: RenderableType,
+        options: Optional[ConsoleOptions] = None,
+        *,
+        style: Optional[Style] = None,
+        pad: bool = True,
+        new_lines: bool = False,
+    ) -> List[List[Segment]]:
+        """Render objects in to a list of lines.
+
+        The output of render_lines is useful when further formatting of rendered console text
+        is required, such as the Panel class which draws a border around any renderable object.
+
+        Args:
+            renderable (RenderableType): Any object renderable in the console.
+            options (Optional[ConsoleOptions], optional): Console options, or None to use self.options. Default to ``None``.
+            style (Style, optional): Optional style to apply to renderables. Defaults to ``None``.
+            pad (bool, optional): Pad lines shorter than render width. Defaults to ``True``.
+            new_lines (bool, optional): Include "\n" characters at end of lines.
+
+        Returns:
+            List[List[Segment]]: A list of lines, where a line is a list of Segment objects.
+        """
+        with self._lock:
+            render_options = options or self.options
+            _rendered = self.render(renderable, render_options)
+            if style:
+                _rendered = Segment.apply_style(_rendered, style)
+
+            render_height = render_options.height
+            if render_height is not None:
+                render_height = max(0, render_height)
+
+            lines = list(
+                islice(
+                    Segment.split_and_crop_lines(
+                        _rendered,
+                        render_options.max_width,
+                        include_new_lines=new_lines,
+                        pad=pad,
+                        style=style,
+                    ),
+                    None,
+                    render_height,
+                )
+            )
+            if render_options.height is not None:
+                extra_lines = render_options.height - len(lines)
+                if extra_lines > 0:
+                    pad_line = [
+                        [Segment(" " * render_options.max_width, style), Segment("\n")]
+                        if new_lines
+                        else [Segment(" " * render_options.max_width, style)]
+                    ]
+                    lines.extend(pad_line * extra_lines)
+
+            return lines
+
+    def render_str(
+        self,
+        text: str,
+        *,
+        style: Union[str, Style] = "",
+        justify: Optional[JustifyMethod] = None,
+        overflow: Optional[OverflowMethod] = None,
+        emoji: Optional[bool] = None,
+        markup: Optional[bool] = None,
+        highlight: Optional[bool] = None,
+        highlighter: Optional[HighlighterType] = None,
+    ) -> "Text":
+        """Convert a string to a Text instance. This is called automatically if
+        you print or log a string.
+
+        Args:
+            text (str): Text to render.
+            style (Union[str, Style], optional): Style to apply to rendered text.
+            justify (str, optional): Justify method: "default", "left", "center", "full", or "right". Defaults to ``None``.
+            overflow (str, optional): Overflow method: "crop", "fold", or "ellipsis". Defaults to ``None``.
+            emoji (Optional[bool], optional): Enable emoji, or ``None`` to use Console default.
+            markup (Optional[bool], optional): Enable markup, or ``None`` to use Console default.
+            highlight (Optional[bool], optional): Enable highlighting, or ``None`` to use Console default.
+            highlighter (HighlighterType, optional): Optional highlighter to apply.
+        Returns:
+            ConsoleRenderable: Renderable object.
+
+        """
+        emoji_enabled = emoji or (emoji is None and self._emoji)
+        markup_enabled = markup or (markup is None and self._markup)
+        highlight_enabled = highlight or (highlight is None and self._highlight)
+
+        if markup_enabled:
+            rich_text = render_markup(
+                text,
+                style=style,
+                emoji=emoji_enabled,
+                emoji_variant=self._emoji_variant,
+            )
+            rich_text.justify = justify
+            rich_text.overflow = overflow
+        else:
+            rich_text = Text(
+                _emoji_replace(text, default_variant=self._emoji_variant)
+                if emoji_enabled
+                else text,
+                justify=justify,
+                overflow=overflow,
+                style=style,
+            )
+
+        _highlighter = (highlighter or self.highlighter) if highlight_enabled else None
+        if _highlighter is not None:
+            highlight_text = _highlighter(str(rich_text))
+            highlight_text.copy_styles(rich_text)
+            return highlight_text
+
+        return rich_text
+
+    def get_style(
+        self, name: Union[str, Style], *, default: Optional[Union[Style, str]] = None
+    ) -> Style:
+        """Get a Style instance by its theme name or parse a definition.
+
+        Args:
+            name (str): The name of a style or a style definition.
+
+        Returns:
+            Style: A Style object.
+
+        Raises:
+            MissingStyle: If no style could be parsed from name.
+
+        """
+        if isinstance(name, Style):
+            return name
+
+        try:
+            style = self._theme_stack.get(name)
+            if style is None:
+                style = Style.parse(name)
+            return style.copy() if style.link else style
+        except errors.StyleSyntaxError as error:
+            if default is not None:
+                return self.get_style(default)
+            raise errors.MissingStyle(
+                f"Failed to get style {name!r}; {error}"
+            ) from None
+
+    def _collect_renderables(
+        self,
+        objects: Iterable[Any],
+        sep: str,
+        end: str,
+        *,
+        justify: Optional[JustifyMethod] = None,
+        emoji: Optional[bool] = None,
+        markup: Optional[bool] = None,
+        highlight: Optional[bool] = None,
+    ) -> List[ConsoleRenderable]:
+        """Combine a number of renderables and text into one renderable.
+
+        Args:
+            objects (Iterable[Any]): Anything that Rich can render.
+            sep (str): String to write between print data.
+            end (str): String to write at end of print data.
+            justify (str, optional): One of "left", "right", "center", or "full". Defaults to ``None``.
+            emoji (Optional[bool], optional): Enable emoji code, or ``None`` to use console default.
+            markup (Optional[bool], optional): Enable markup, or ``None`` to use console default.
+            highlight (Optional[bool], optional): Enable automatic highlighting, or ``None`` to use console default.
+
+        Returns:
+            List[ConsoleRenderable]: A list of things to render.
+        """
+        renderables: List[ConsoleRenderable] = []
+        _append = renderables.append
+        text: List[Text] = []
+        append_text = text.append
+
+        append = _append
+        if justify in ("left", "center", "right"):
+
+            def align_append(renderable: RenderableType) -> None:
+                _append(Align(renderable, cast(AlignMethod, justify)))
+
+            append = align_append
+
+        _highlighter: HighlighterType = _null_highlighter
+        if highlight or (highlight is None and self._highlight):
+            _highlighter = self.highlighter
+
+        def check_text() -> None:
+            if text:
+                sep_text = Text(sep, justify=justify, end=end)
+                append(sep_text.join(text))
+                text.clear()
+
+        for renderable in objects:
+            renderable = rich_cast(renderable)
+            if isinstance(renderable, str):
+                append_text(
+                    self.render_str(
+                        renderable, emoji=emoji, markup=markup, highlighter=_highlighter
+                    )
+                )
+            elif isinstance(renderable, Text):
+                append_text(renderable)
+            elif isinstance(renderable, ConsoleRenderable):
+                check_text()
+                append(renderable)
+            elif is_expandable(renderable):
+                check_text()
+                append(Pretty(renderable, highlighter=_highlighter))
+            else:
+                append_text(_highlighter(str(renderable)))
+
+        check_text()
+
+        if self.style is not None:
+            style = self.get_style(self.style)
+            renderables = [Styled(renderable, style) for renderable in renderables]
+
+        return renderables
+
+    def rule(
+        self,
+        title: TextType = "",
+        *,
+        characters: str = "─",
+        style: Union[str, Style] = "rule.line",
+        align: AlignMethod = "center",
+    ) -> None:
+        """Draw a line with optional centered title.
+
+        Args:
+            title (str, optional): Text to render over the rule. Defaults to "".
+            characters (str, optional): Character(s) to form the line. Defaults to "─".
+            style (str, optional): Style of line. Defaults to "rule.line".
+            align (str, optional): How to align the title, one of "left", "center", or "right". Defaults to "center".
+        """
+        from .rule import Rule
+
+        rule = Rule(title=title, characters=characters, style=style, align=align)
+        self.print(rule)
+
+    def control(self, *control: Control) -> None:
+        """Insert non-printing control codes.
+
+        Args:
+            control_codes (str): Control codes, such as those that may move the cursor.
+        """
+        if not self.is_dumb_terminal:
+            with self:
+                self._buffer.extend(_control.segment for _control in control)
+
+    def out(
+        self,
+        *objects: Any,
+        sep: str = " ",
+        end: str = "\n",
+        style: Optional[Union[str, Style]] = None,
+        highlight: Optional[bool] = None,
+    ) -> None:
+        """Output to the terminal. This is a low-level way of writing to the terminal which unlike
+        :meth:`~rich.console.Console.print` won't pretty print, wrap text, or apply markup, but will
+        optionally apply highlighting and a basic style.
+
+        Args:
+            sep (str, optional): String to write between print data. Defaults to " ".
+            end (str, optional): String to write at end of print data. Defaults to "\\\\n".
+            style (Union[str, Style], optional): A style to apply to output. Defaults to None.
+            highlight (Optional[bool], optional): Enable automatic highlighting, or ``None`` to use
+                console default. Defaults to ``None``.
+        """
+        raw_output: str = sep.join(str(_object) for _object in objects)
+        self.print(
+            raw_output,
+            style=style,
+            highlight=highlight,
+            emoji=False,
+            markup=False,
+            no_wrap=True,
+            overflow="ignore",
+            crop=False,
+            end=end,
+        )
+
+    def print(
+        self,
+        *objects: Any,
+        sep: str = " ",
+        end: str = "\n",
+        style: Optional[Union[str, Style]] = None,
+        justify: Optional[JustifyMethod] = None,
+        overflow: Optional[OverflowMethod] = None,
+        no_wrap: Optional[bool] = None,
+        emoji: Optional[bool] = None,
+        markup: Optional[bool] = None,
+        highlight: Optional[bool] = None,
+        width: Optional[int] = None,
+        height: Optional[int] = None,
+        crop: bool = True,
+        soft_wrap: Optional[bool] = None,
+        new_line_start: bool = False,
+    ) -> None:
+        """Print to the console.
+
+        Args:
+            objects (positional args): Objects to log to the terminal.
+            sep (str, optional): String to write between print data. Defaults to " ".
+            end (str, optional): String to write at end of print data. Defaults to "\\\\n".
+            style (Union[str, Style], optional): A style to apply to output. Defaults to None.
+            justify (str, optional): Justify method: "default", "left", "right", "center", or "full". Defaults to ``None``.
+            overflow (str, optional): Overflow method: "ignore", "crop", "fold", or "ellipsis". Defaults to None.
+            no_wrap (Optional[bool], optional): Disable word wrapping. Defaults to None.
+            emoji (Optional[bool], optional): Enable emoji code, or ``None`` to use console default. Defaults to ``None``.
+            markup (Optional[bool], optional): Enable markup, or ``None`` to use console default. Defaults to ``None``.
+            highlight (Optional[bool], optional): Enable automatic highlighting, or ``None`` to use console default. Defaults to ``None``.
+            width (Optional[int], optional): Width of output, or ``None`` to auto-detect. Defaults to ``None``.
+            crop (Optional[bool], optional): Crop output to width of terminal. Defaults to True.
+            soft_wrap (bool, optional): Enable soft wrap mode which disables word wrapping and cropping of text or ``None`` for
+                Console default. Defaults to ``None``.
+            new_line_start (bool, False): Insert a new line at the start if the output contains more than one line. Defaults to ``False``.
+        """
+        if not objects:
+            objects = (NewLine(),)
+
+        if soft_wrap is None:
+            soft_wrap = self.soft_wrap
+        if soft_wrap:
+            if no_wrap is None:
+                no_wrap = True
+            if overflow is None:
+                overflow = "ignore"
+            crop = False
+        render_hooks = self._render_hooks[:]
+        with self:
+            renderables = self._collect_renderables(
+                objects,
+                sep,
+                end,
+                justify=justify,
+                emoji=emoji,
+                markup=markup,
+                highlight=highlight,
+            )
+            for hook in render_hooks:
+                renderables = hook.process_renderables(renderables)
+            render_options = self.options.update(
+                justify=justify,
+                overflow=overflow,
+                width=min(width, self.width) if width is not None else NO_CHANGE,
+                height=height,
+                no_wrap=no_wrap,
+                markup=markup,
+                highlight=highlight,
+            )
+
+            new_segments: List[Segment] = []
+            extend = new_segments.extend
+            render = self.render
+            if style is None:
+                for renderable in renderables:
+                    extend(render(renderable, render_options))
+            else:
+                for renderable in renderables:
+                    extend(
+                        Segment.apply_style(
+                            render(renderable, render_options), self.get_style(style)
+                        )
+                    )
+            if new_line_start:
+                if (
+                    len("".join(segment.text for segment in new_segments).splitlines())
+                    > 1
+                ):
+                    new_segments.insert(0, Segment.line())
+            if crop:
+                buffer_extend = self._buffer.extend
+                for line in Segment.split_and_crop_lines(
+                    new_segments, self.width, pad=False
+                ):
+                    buffer_extend(line)
+            else:
+                self._buffer.extend(new_segments)
+
+    def print_json(
+        self,
+        json: Optional[str] = None,
+        *,
+        data: Any = None,
+        indent: Union[None, int, str] = 2,
+        highlight: bool = True,
+        skip_keys: bool = False,
+        ensure_ascii: bool = False,
+        check_circular: bool = True,
+        allow_nan: bool = True,
+        default: Optional[Callable[[Any], Any]] = None,
+        sort_keys: bool = False,
+    ) -> None:
+        """Pretty prints JSON. Output will be valid JSON.
+
+        Args:
+            json (Optional[str]): A string containing JSON.
+            data (Any): If json is not supplied, then encode this data.
+            indent (Union[None, int, str], optional): Number of spaces to indent. Defaults to 2.
+            highlight (bool, optional): Enable highlighting of output: Defaults to True.
+            skip_keys (bool, optional): Skip keys not of a basic type. Defaults to False.
+            ensure_ascii (bool, optional): Escape all non-ascii characters. Defaults to False.
+            check_circular (bool, optional): Check for circular references. Defaults to True.
+            allow_nan (bool, optional): Allow NaN and Infinity values. Defaults to True.
+            default (Callable, optional): A callable that converts values that can not be encoded
+                in to something that can be JSON encoded. Defaults to None.
+            sort_keys (bool, optional): Sort dictionary keys. Defaults to False.
+        """
+        from pip._vendor.rich.json import JSON
+
+        if json is None:
+            json_renderable = JSON.from_data(
+                data,
+                indent=indent,
+                highlight=highlight,
+                skip_keys=skip_keys,
+                ensure_ascii=ensure_ascii,
+                check_circular=check_circular,
+                allow_nan=allow_nan,
+                default=default,
+                sort_keys=sort_keys,
+            )
+        else:
+            if not isinstance(json, str):
+                raise TypeError(
+                    f"json must be str. Did you mean print_json(data={json!r}) ?"
+                )
+            json_renderable = JSON(
+                json,
+                indent=indent,
+                highlight=highlight,
+                skip_keys=skip_keys,
+                ensure_ascii=ensure_ascii,
+                check_circular=check_circular,
+                allow_nan=allow_nan,
+                default=default,
+                sort_keys=sort_keys,
+            )
+        self.print(json_renderable, soft_wrap=True)
+
+    def update_screen(
+        self,
+        renderable: RenderableType,
+        *,
+        region: Optional[Region] = None,
+        options: Optional[ConsoleOptions] = None,
+    ) -> None:
+        """Update the screen at a given offset.
+
+        Args:
+            renderable (RenderableType): A Rich renderable.
+            region (Region, optional): Region of screen to update, or None for entire screen. Defaults to None.
+            x (int, optional): x offset. Defaults to 0.
+            y (int, optional): y offset. Defaults to 0.
+
+        Raises:
+            errors.NoAltScreen: If the Console isn't in alt screen mode.
+
+        """
+        if not self.is_alt_screen:
+            raise errors.NoAltScreen("Alt screen must be enabled to call update_screen")
+        render_options = options or self.options
+        if region is None:
+            x = y = 0
+            render_options = render_options.update_dimensions(
+                render_options.max_width, render_options.height or self.height
+            )
+        else:
+            x, y, width, height = region
+            render_options = render_options.update_dimensions(width, height)
+
+        lines = self.render_lines(renderable, options=render_options)
+        self.update_screen_lines(lines, x, y)
+
+    def update_screen_lines(
+        self, lines: List[List[Segment]], x: int = 0, y: int = 0
+    ) -> None:
+        """Update lines of the screen at a given offset.
+
+        Args:
+            lines (List[List[Segment]]): Rendered lines (as produced by :meth:`~rich.Console.render_lines`).
+            x (int, optional): x offset (column no). Defaults to 0.
+            y (int, optional): y offset (column no). Defaults to 0.
+
+        Raises:
+            errors.NoAltScreen: If the Console isn't in alt screen mode.
+        """
+        if not self.is_alt_screen:
+            raise errors.NoAltScreen("Alt screen must be enabled to call update_screen")
+        screen_update = ScreenUpdate(lines, x, y)
+        segments = self.render(screen_update)
+        self._buffer.extend(segments)
+        self._check_buffer()
+
+    def print_exception(
+        self,
+        *,
+        width: Optional[int] = 100,
+        extra_lines: int = 3,
+        theme: Optional[str] = None,
+        word_wrap: bool = False,
+        show_locals: bool = False,
+        suppress: Iterable[Union[str, ModuleType]] = (),
+        max_frames: int = 100,
+    ) -> None:
+        """Prints a rich render of the last exception and traceback.
+
+        Args:
+            width (Optional[int], optional): Number of characters used to render code. Defaults to 100.
+            extra_lines (int, optional): Additional lines of code to render. Defaults to 3.
+            theme (str, optional): Override pygments theme used in traceback
+            word_wrap (bool, optional): Enable word wrapping of long lines. Defaults to False.
+            show_locals (bool, optional): Enable display of local variables. Defaults to False.
+            suppress (Iterable[Union[str, ModuleType]]): Optional sequence of modules or paths to exclude from traceback.
+            max_frames (int): Maximum number of frames to show in a traceback, 0 for no maximum. Defaults to 100.
+        """
+        from .traceback import Traceback
+
+        traceback = Traceback(
+            width=width,
+            extra_lines=extra_lines,
+            theme=theme,
+            word_wrap=word_wrap,
+            show_locals=show_locals,
+            suppress=suppress,
+            max_frames=max_frames,
+        )
+        self.print(traceback)
+
+    @staticmethod
+    def _caller_frame_info(
+        offset: int,
+        currentframe: Callable[[], Optional[FrameType]] = inspect.currentframe,
+    ) -> Tuple[str, int, Dict[str, Any]]:
+        """Get caller frame information.
+
+        Args:
+            offset (int): the caller offset within the current frame stack.
+            currentframe (Callable[[], Optional[FrameType]], optional): the callable to use to
+                retrieve the current frame. Defaults to ``inspect.currentframe``.
+
+        Returns:
+            Tuple[str, int, Dict[str, Any]]: A tuple containing the filename, the line number and
+                the dictionary of local variables associated with the caller frame.
+
+        Raises:
+            RuntimeError: If the stack offset is invalid.
+        """
+        # Ignore the frame of this local helper
+        offset += 1
+
+        frame = currentframe()
+        if frame is not None:
+            # Use the faster currentframe where implemented
+            while offset and frame is not None:
+                frame = frame.f_back
+                offset -= 1
+            assert frame is not None
+            return frame.f_code.co_filename, frame.f_lineno, frame.f_locals
+        else:
+            # Fallback to the slower stack
+            frame_info = inspect.stack()[offset]
+            return frame_info.filename, frame_info.lineno, frame_info.frame.f_locals
+
+    def log(
+        self,
+        *objects: Any,
+        sep: str = " ",
+        end: str = "\n",
+        style: Optional[Union[str, Style]] = None,
+        justify: Optional[JustifyMethod] = None,
+        emoji: Optional[bool] = None,
+        markup: Optional[bool] = None,
+        highlight: Optional[bool] = None,
+        log_locals: bool = False,
+        _stack_offset: int = 1,
+    ) -> None:
+        """Log rich content to the terminal.
+
+        Args:
+            objects (positional args): Objects to log to the terminal.
+            sep (str, optional): String to write between print data. Defaults to " ".
+            end (str, optional): String to write at end of print data. Defaults to "\\\\n".
+            style (Union[str, Style], optional): A style to apply to output. Defaults to None.
+            justify (str, optional): One of "left", "right", "center", or "full". Defaults to ``None``.
+            emoji (Optional[bool], optional): Enable emoji code, or ``None`` to use console default. Defaults to None.
+            markup (Optional[bool], optional): Enable markup, or ``None`` to use console default. Defaults to None.
+            highlight (Optional[bool], optional): Enable automatic highlighting, or ``None`` to use console default. Defaults to None.
+            log_locals (bool, optional): Boolean to enable logging of locals where ``log()``
+                was called. Defaults to False.
+            _stack_offset (int, optional): Offset of caller from end of call stack. Defaults to 1.
+        """
+        if not objects:
+            objects = (NewLine(),)
+
+        render_hooks = self._render_hooks[:]
+
+        with self:
+            renderables = self._collect_renderables(
+                objects,
+                sep,
+                end,
+                justify=justify,
+                emoji=emoji,
+                markup=markup,
+                highlight=highlight,
+            )
+            if style is not None:
+                renderables = [Styled(renderable, style) for renderable in renderables]
+
+            filename, line_no, locals = self._caller_frame_info(_stack_offset)
+            link_path = None if filename.startswith("<") else os.path.abspath(filename)
+            path = filename.rpartition(os.sep)[-1]
+            if log_locals:
+                locals_map = {
+                    key: value
+                    for key, value in locals.items()
+                    if not key.startswith("__")
+                }
+                renderables.append(render_scope(locals_map, title="[i]locals"))
+
+            renderables = [
+                self._log_render(
+                    self,
+                    renderables,
+                    log_time=self.get_datetime(),
+                    path=path,
+                    line_no=line_no,
+                    link_path=link_path,
+                )
+            ]
+            for hook in render_hooks:
+                renderables = hook.process_renderables(renderables)
+            new_segments: List[Segment] = []
+            extend = new_segments.extend
+            render = self.render
+            render_options = self.options
+            for renderable in renderables:
+                extend(render(renderable, render_options))
+            buffer_extend = self._buffer.extend
+            for line in Segment.split_and_crop_lines(
+                new_segments, self.width, pad=False
+            ):
+                buffer_extend(line)
+
+    def _check_buffer(self) -> None:
+        """Check if the buffer may be rendered. Render it if it can (e.g. Console.quiet is False)
+        Rendering is supported on Windows, Unix and Jupyter environments. For
+        legacy Windows consoles, the win32 API is called directly.
+        This method will also record what it renders if recording is enabled via Console.record.
+        """
+        if self.quiet:
+            del self._buffer[:]
+            return
+        with self._lock:
+            if self.record:
+                with self._record_buffer_lock:
+                    self._record_buffer.extend(self._buffer[:])
+
+            if self._buffer_index == 0:
+                if self.is_jupyter:  # pragma: no cover
+                    from .jupyter import display
+
+                    display(self._buffer, self._render_buffer(self._buffer[:]))
+                    del self._buffer[:]
+                else:
+                    if WINDOWS:
+                        use_legacy_windows_render = False
+                        if self.legacy_windows:
+                            fileno = get_fileno(self.file)
+                            if fileno is not None:
+                                use_legacy_windows_render = (
+                                    fileno in _STD_STREAMS_OUTPUT
+                                )
+
+                        if use_legacy_windows_render:
+                            from pip._vendor.rich._win32_console import LegacyWindowsTerm
+                            from pip._vendor.rich._windows_renderer import legacy_windows_render
+
+                            buffer = self._buffer[:]
+                            if self.no_color and self._color_system:
+                                buffer = list(Segment.remove_color(buffer))
+
+                            legacy_windows_render(buffer, LegacyWindowsTerm(self.file))
+                        else:
+                            # Either a non-std stream on legacy Windows, or modern Windows.
+                            text = self._render_buffer(self._buffer[:])
+                            # https://bugs.python.org/issue37871
+                            # https://github.com/python/cpython/issues/82052
+                            # We need to avoid writing more than 32Kb in a single write, due to the above bug
+                            write = self.file.write
+                            # Worse case scenario, every character is 4 bytes of utf-8
+                            MAX_WRITE = 32 * 1024 // 4
+                            try:
+                                if len(text) <= MAX_WRITE:
+                                    write(text)
+                                else:
+                                    batch: List[str] = []
+                                    batch_append = batch.append
+                                    size = 0
+                                    for line in text.splitlines(True):
+                                        if size + len(line) > MAX_WRITE and batch:
+                                            write("".join(batch))
+                                            batch.clear()
+                                            size = 0
+                                        batch_append(line)
+                                        size += len(line)
+                                    if batch:
+                                        write("".join(batch))
+                                        batch.clear()
+                            except UnicodeEncodeError as error:
+                                error.reason = f"{error.reason}\n*** You may need to add PYTHONIOENCODING=utf-8 to your environment ***"
+                                raise
+                    else:
+                        text = self._render_buffer(self._buffer[:])
+                        try:
+                            self.file.write(text)
+                        except UnicodeEncodeError as error:
+                            error.reason = f"{error.reason}\n*** You may need to add PYTHONIOENCODING=utf-8 to your environment ***"
+                            raise
+
+                    self.file.flush()
+                    del self._buffer[:]
+
+    def _render_buffer(self, buffer: Iterable[Segment]) -> str:
+        """Render buffered output, and clear buffer."""
+        output: List[str] = []
+        append = output.append
+        color_system = self._color_system
+        legacy_windows = self.legacy_windows
+        not_terminal = not self.is_terminal
+        if self.no_color and color_system:
+            buffer = Segment.remove_color(buffer)
+        for text, style, control in buffer:
+            if style:
+                append(
+                    style.render(
+                        text,
+                        color_system=color_system,
+                        legacy_windows=legacy_windows,
+                    )
+                )
+            elif not (not_terminal and control):
+                append(text)
+
+        rendered = "".join(output)
+        return rendered
+
+    def input(
+        self,
+        prompt: TextType = "",
+        *,
+        markup: bool = True,
+        emoji: bool = True,
+        password: bool = False,
+        stream: Optional[TextIO] = None,
+    ) -> str:
+        """Displays a prompt and waits for input from the user. The prompt may contain color / style.
+
+        It works in the same way as Python's builtin :func:`input` function and provides elaborate line editing and history features if Python's builtin :mod:`readline` module is previously loaded.
+
+        Args:
+            prompt (Union[str, Text]): Text to render in the prompt.
+            markup (bool, optional): Enable console markup (requires a str prompt). Defaults to True.
+            emoji (bool, optional): Enable emoji (requires a str prompt). Defaults to True.
+            password: (bool, optional): Hide typed text. Defaults to False.
+            stream: (TextIO, optional): Optional file to read input from (rather than stdin). Defaults to None.
+
+        Returns:
+            str: Text read from stdin.
+        """
+        if prompt:
+            self.print(prompt, markup=markup, emoji=emoji, end="")
+        if password:
+            result = getpass("", stream=stream)
+        else:
+            if stream:
+                result = stream.readline()
+            else:
+                result = input()
+        return result
+
+    def export_text(self, *, clear: bool = True, styles: bool = False) -> str:
+        """Generate text from console contents (requires record=True argument in constructor).
+
+        Args:
+            clear (bool, optional): Clear record buffer after exporting. Defaults to ``True``.
+            styles (bool, optional): If ``True``, ansi escape codes will be included. ``False`` for plain text.
+                Defaults to ``False``.
+
+        Returns:
+            str: String containing console contents.
+
+        """
+        assert (
+            self.record
+        ), "To export console contents set record=True in the constructor or instance"
+
+        with self._record_buffer_lock:
+            if styles:
+                text = "".join(
+                    (style.render(text) if style else text)
+                    for text, style, _ in self._record_buffer
+                )
+            else:
+                text = "".join(
+                    segment.text
+                    for segment in self._record_buffer
+                    if not segment.control
+                )
+            if clear:
+                del self._record_buffer[:]
+        return text
+
+    def save_text(self, path: str, *, clear: bool = True, styles: bool = False) -> None:
+        """Generate text from console and save to a given location (requires record=True argument in constructor).
+
+        Args:
+            path (str): Path to write text files.
+            clear (bool, optional): Clear record buffer after exporting. Defaults to ``True``.
+            styles (bool, optional): If ``True``, ansi style codes will be included. ``False`` for plain text.
+                Defaults to ``False``.
+
+        """
+        text = self.export_text(clear=clear, styles=styles)
+        with open(path, "wt", encoding="utf-8") as write_file:
+            write_file.write(text)
+
+    def export_html(
+        self,
+        *,
+        theme: Optional[TerminalTheme] = None,
+        clear: bool = True,
+        code_format: Optional[str] = None,
+        inline_styles: bool = False,
+    ) -> str:
+        """Generate HTML from console contents (requires record=True argument in constructor).
+
+        Args:
+            theme (TerminalTheme, optional): TerminalTheme object containing console colors.
+            clear (bool, optional): Clear record buffer after exporting. Defaults to ``True``.
+            code_format (str, optional): Format string to render HTML. In addition to '{foreground}',
+                '{background}', and '{code}', should contain '{stylesheet}' if inline_styles is ``False``.
+            inline_styles (bool, optional): If ``True`` styles will be inlined in to spans, which makes files
+                larger but easier to cut and paste markup. If ``False``, styles will be embedded in a style tag.
+                Defaults to False.
+
+        Returns:
+            str: String containing console contents as HTML.
+        """
+        assert (
+            self.record
+        ), "To export console contents set record=True in the constructor or instance"
+        fragments: List[str] = []
+        append = fragments.append
+        _theme = theme or DEFAULT_TERMINAL_THEME
+        stylesheet = ""
+
+        render_code_format = CONSOLE_HTML_FORMAT if code_format is None else code_format
+
+        with self._record_buffer_lock:
+            if inline_styles:
+                for text, style, _ in Segment.filter_control(
+                    Segment.simplify(self._record_buffer)
+                ):
+                    text = escape(text)
+                    if style:
+                        rule = style.get_html_style(_theme)
+                        if style.link:
+                            text = f'{text}'
+                        text = f'{text}' if rule else text
+                    append(text)
+            else:
+                styles: Dict[str, int] = {}
+                for text, style, _ in Segment.filter_control(
+                    Segment.simplify(self._record_buffer)
+                ):
+                    text = escape(text)
+                    if style:
+                        rule = style.get_html_style(_theme)
+                        style_number = styles.setdefault(rule, len(styles) + 1)
+                        if style.link:
+                            text = f'{text}'
+                        else:
+                            text = f'{text}'
+                    append(text)
+                stylesheet_rules: List[str] = []
+                stylesheet_append = stylesheet_rules.append
+                for style_rule, style_number in styles.items():
+                    if style_rule:
+                        stylesheet_append(f".r{style_number} {{{style_rule}}}")
+                stylesheet = "\n".join(stylesheet_rules)
+
+            rendered_code = render_code_format.format(
+                code="".join(fragments),
+                stylesheet=stylesheet,
+                foreground=_theme.foreground_color.hex,
+                background=_theme.background_color.hex,
+            )
+            if clear:
+                del self._record_buffer[:]
+        return rendered_code
+
+    def save_html(
+        self,
+        path: str,
+        *,
+        theme: Optional[TerminalTheme] = None,
+        clear: bool = True,
+        code_format: str = CONSOLE_HTML_FORMAT,
+        inline_styles: bool = False,
+    ) -> None:
+        """Generate HTML from console contents and write to a file (requires record=True argument in constructor).
+
+        Args:
+            path (str): Path to write html file.
+            theme (TerminalTheme, optional): TerminalTheme object containing console colors.
+            clear (bool, optional): Clear record buffer after exporting. Defaults to ``True``.
+            code_format (str, optional): Format string to render HTML. In addition to '{foreground}',
+                '{background}', and '{code}', should contain '{stylesheet}' if inline_styles is ``False``.
+            inline_styles (bool, optional): If ``True`` styles will be inlined in to spans, which makes files
+                larger but easier to cut and paste markup. If ``False``, styles will be embedded in a style tag.
+                Defaults to False.
+
+        """
+        html = self.export_html(
+            theme=theme,
+            clear=clear,
+            code_format=code_format,
+            inline_styles=inline_styles,
+        )
+        with open(path, "wt", encoding="utf-8") as write_file:
+            write_file.write(html)
+
+    def export_svg(
+        self,
+        *,
+        title: str = "Rich",
+        theme: Optional[TerminalTheme] = None,
+        clear: bool = True,
+        code_format: str = CONSOLE_SVG_FORMAT,
+        font_aspect_ratio: float = 0.61,
+        unique_id: Optional[str] = None,
+    ) -> str:
+        """
+        Generate an SVG from the console contents (requires record=True in Console constructor).
+
+        Args:
+            title (str, optional): The title of the tab in the output image
+            theme (TerminalTheme, optional): The ``TerminalTheme`` object to use to style the terminal
+            clear (bool, optional): Clear record buffer after exporting. Defaults to ``True``
+            code_format (str, optional): Format string used to generate the SVG. Rich will inject a number of variables
+                into the string in order to form the final SVG output. The default template used and the variables
+                injected by Rich can be found by inspecting the ``console.CONSOLE_SVG_FORMAT`` variable.
+            font_aspect_ratio (float, optional): The width to height ratio of the font used in the ``code_format``
+                string. Defaults to 0.61, which is the width to height ratio of Fira Code (the default font).
+                If you aren't specifying a different font inside ``code_format``, you probably don't need this.
+            unique_id (str, optional): unique id that is used as the prefix for various elements (CSS styles, node
+                ids). If not set, this defaults to a computed value based on the recorded content.
+        """
+
+        from pip._vendor.rich.cells import cell_len
+
+        style_cache: Dict[Style, str] = {}
+
+        def get_svg_style(style: Style) -> str:
+            """Convert a Style to CSS rules for SVG."""
+            if style in style_cache:
+                return style_cache[style]
+            css_rules = []
+            color = (
+                _theme.foreground_color
+                if (style.color is None or style.color.is_default)
+                else style.color.get_truecolor(_theme)
+            )
+            bgcolor = (
+                _theme.background_color
+                if (style.bgcolor is None or style.bgcolor.is_default)
+                else style.bgcolor.get_truecolor(_theme)
+            )
+            if style.reverse:
+                color, bgcolor = bgcolor, color
+            if style.dim:
+                color = blend_rgb(color, bgcolor, 0.4)
+            css_rules.append(f"fill: {color.hex}")
+            if style.bold:
+                css_rules.append("font-weight: bold")
+            if style.italic:
+                css_rules.append("font-style: italic;")
+            if style.underline:
+                css_rules.append("text-decoration: underline;")
+            if style.strike:
+                css_rules.append("text-decoration: line-through;")
+
+            css = ";".join(css_rules)
+            style_cache[style] = css
+            return css
+
+        _theme = theme or SVG_EXPORT_THEME
+
+        width = self.width
+        char_height = 20
+        char_width = char_height * font_aspect_ratio
+        line_height = char_height * 1.22
+
+        margin_top = 1
+        margin_right = 1
+        margin_bottom = 1
+        margin_left = 1
+
+        padding_top = 40
+        padding_right = 8
+        padding_bottom = 8
+        padding_left = 8
+
+        padding_width = padding_left + padding_right
+        padding_height = padding_top + padding_bottom
+        margin_width = margin_left + margin_right
+        margin_height = margin_top + margin_bottom
+
+        text_backgrounds: List[str] = []
+        text_group: List[str] = []
+        classes: Dict[str, int] = {}
+        style_no = 1
+
+        def escape_text(text: str) -> str:
+            """HTML escape text and replace spaces with nbsp."""
+            return escape(text).replace(" ", " ")
+
+        def make_tag(
+            name: str, content: Optional[str] = None, **attribs: object
+        ) -> str:
+            """Make a tag from name, content, and attributes."""
+
+            def stringify(value: object) -> str:
+                if isinstance(value, (float)):
+                    return format(value, "g")
+                return str(value)
+
+            tag_attribs = " ".join(
+                f'{k.lstrip("_").replace("_", "-")}="{stringify(v)}"'
+                for k, v in attribs.items()
+            )
+            return (
+                f"<{name} {tag_attribs}>{content}"
+                if content
+                else f"<{name} {tag_attribs}/>"
+            )
+
+        with self._record_buffer_lock:
+            segments = list(Segment.filter_control(self._record_buffer))
+            if clear:
+                self._record_buffer.clear()
+
+        if unique_id is None:
+            unique_id = "terminal-" + str(
+                zlib.adler32(
+                    ("".join(repr(segment) for segment in segments)).encode(
+                        "utf-8",
+                        "ignore",
+                    )
+                    + title.encode("utf-8", "ignore")
+                )
+            )
+        y = 0
+        for y, line in enumerate(Segment.split_and_crop_lines(segments, length=width)):
+            x = 0
+            for text, style, _control in line:
+                style = style or Style()
+                rules = get_svg_style(style)
+                if rules not in classes:
+                    classes[rules] = style_no
+                    style_no += 1
+                class_name = f"r{classes[rules]}"
+
+                if style.reverse:
+                    has_background = True
+                    background = (
+                        _theme.foreground_color.hex
+                        if style.color is None
+                        else style.color.get_truecolor(_theme).hex
+                    )
+                else:
+                    bgcolor = style.bgcolor
+                    has_background = bgcolor is not None and not bgcolor.is_default
+                    background = (
+                        _theme.background_color.hex
+                        if style.bgcolor is None
+                        else style.bgcolor.get_truecolor(_theme).hex
+                    )
+
+                text_length = cell_len(text)
+                if has_background:
+                    text_backgrounds.append(
+                        make_tag(
+                            "rect",
+                            fill=background,
+                            x=x * char_width,
+                            y=y * line_height + 1.5,
+                            width=char_width * text_length,
+                            height=line_height + 0.25,
+                            shape_rendering="crispEdges",
+                        )
+                    )
+
+                if text != " " * len(text):
+                    text_group.append(
+                        make_tag(
+                            "text",
+                            escape_text(text),
+                            _class=f"{unique_id}-{class_name}",
+                            x=x * char_width,
+                            y=y * line_height + char_height,
+                            textLength=char_width * len(text),
+                            clip_path=f"url(#{unique_id}-line-{y})",
+                        )
+                    )
+                x += cell_len(text)
+
+        line_offsets = [line_no * line_height + 1.5 for line_no in range(y)]
+        lines = "\n".join(
+            f"""
+    {make_tag("rect", x=0, y=offset, width=char_width * width, height=line_height + 0.25)}
+            """
+            for line_no, offset in enumerate(line_offsets)
+        )
+
+        styles = "\n".join(
+            f".{unique_id}-r{rule_no} {{ {css} }}" for css, rule_no in classes.items()
+        )
+        backgrounds = "".join(text_backgrounds)
+        matrix = "".join(text_group)
+
+        terminal_width = ceil(width * char_width + padding_width)
+        terminal_height = (y + 1) * line_height + padding_height
+        chrome = make_tag(
+            "rect",
+            fill=_theme.background_color.hex,
+            stroke="rgba(255,255,255,0.35)",
+            stroke_width="1",
+            x=margin_left,
+            y=margin_top,
+            width=terminal_width,
+            height=terminal_height,
+            rx=8,
+        )
+
+        title_color = _theme.foreground_color.hex
+        if title:
+            chrome += make_tag(
+                "text",
+                escape_text(title),
+                _class=f"{unique_id}-title",
+                fill=title_color,
+                text_anchor="middle",
+                x=terminal_width // 2,
+                y=margin_top + char_height + 6,
+            )
+        chrome += f"""
+            
+            
+            
+            
+            
+        """
+
+        svg = code_format.format(
+            unique_id=unique_id,
+            char_width=char_width,
+            char_height=char_height,
+            line_height=line_height,
+            terminal_width=char_width * width - 1,
+            terminal_height=(y + 1) * line_height - 1,
+            width=terminal_width + margin_width,
+            height=terminal_height + margin_height,
+            terminal_x=margin_left + padding_left,
+            terminal_y=margin_top + padding_top,
+            styles=styles,
+            chrome=chrome,
+            backgrounds=backgrounds,
+            matrix=matrix,
+            lines=lines,
+        )
+        return svg
+
+    def save_svg(
+        self,
+        path: str,
+        *,
+        title: str = "Rich",
+        theme: Optional[TerminalTheme] = None,
+        clear: bool = True,
+        code_format: str = CONSOLE_SVG_FORMAT,
+        font_aspect_ratio: float = 0.61,
+        unique_id: Optional[str] = None,
+    ) -> None:
+        """Generate an SVG file from the console contents (requires record=True in Console constructor).
+
+        Args:
+            path (str): The path to write the SVG to.
+            title (str, optional): The title of the tab in the output image
+            theme (TerminalTheme, optional): The ``TerminalTheme`` object to use to style the terminal
+            clear (bool, optional): Clear record buffer after exporting. Defaults to ``True``
+            code_format (str, optional): Format string used to generate the SVG. Rich will inject a number of variables
+                into the string in order to form the final SVG output. The default template used and the variables
+                injected by Rich can be found by inspecting the ``console.CONSOLE_SVG_FORMAT`` variable.
+            font_aspect_ratio (float, optional): The width to height ratio of the font used in the ``code_format``
+                string. Defaults to 0.61, which is the width to height ratio of Fira Code (the default font).
+                If you aren't specifying a different font inside ``code_format``, you probably don't need this.
+            unique_id (str, optional): unique id that is used as the prefix for various elements (CSS styles, node
+                ids). If not set, this defaults to a computed value based on the recorded content.
+        """
+        svg = self.export_svg(
+            title=title,
+            theme=theme,
+            clear=clear,
+            code_format=code_format,
+            font_aspect_ratio=font_aspect_ratio,
+            unique_id=unique_id,
+        )
+        with open(path, "wt", encoding="utf-8") as write_file:
+            write_file.write(svg)
+
+
+def _svg_hash(svg_main_code: str) -> str:
+    """Returns a unique hash for the given SVG main code.
+
+    Args:
+        svg_main_code (str): The content we're going to inject in the SVG envelope.
+
+    Returns:
+        str: a hash of the given content
+    """
+    return str(zlib.adler32(svg_main_code.encode()))
+
+
+if __name__ == "__main__":  # pragma: no cover
+    console = Console(record=True)
+
+    console.log(
+        "JSONRPC [i]request[/i]",
+        5,
+        1.3,
+        True,
+        False,
+        None,
+        {
+            "jsonrpc": "2.0",
+            "method": "subtract",
+            "params": {"minuend": 42, "subtrahend": 23},
+            "id": 3,
+        },
+    )
+
+    console.log("Hello, World!", "{'a': 1}", repr(console))
+
+    console.print(
+        {
+            "name": None,
+            "empty": [],
+            "quiz": {
+                "sport": {
+                    "answered": True,
+                    "q1": {
+                        "question": "Which one is correct team name in NBA?",
+                        "options": [
+                            "New York Bulls",
+                            "Los Angeles Kings",
+                            "Golden State Warriors",
+                            "Huston Rocket",
+                        ],
+                        "answer": "Huston Rocket",
+                    },
+                },
+                "maths": {
+                    "answered": False,
+                    "q1": {
+                        "question": "5 + 7 = ?",
+                        "options": [10, 11, 12, 13],
+                        "answer": 12,
+                    },
+                    "q2": {
+                        "question": "12 - 8 = ?",
+                        "options": [1, 2, 3, 4],
+                        "answer": 4,
+                    },
+                },
+            },
+        }
+    )
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/rich/constrain.py b/venv/lib/python3.12/site-packages/pip/_vendor/rich/constrain.py
new file mode 100644
index 00000000..65fdf563
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_vendor/rich/constrain.py
@@ -0,0 +1,37 @@
+from typing import Optional, TYPE_CHECKING
+
+from .jupyter import JupyterMixin
+from .measure import Measurement
+
+if TYPE_CHECKING:
+    from .console import Console, ConsoleOptions, RenderableType, RenderResult
+
+
+class Constrain(JupyterMixin):
+    """Constrain the width of a renderable to a given number of characters.
+
+    Args:
+        renderable (RenderableType): A renderable object.
+        width (int, optional): The maximum width (in characters) to render. Defaults to 80.
+    """
+
+    def __init__(self, renderable: "RenderableType", width: Optional[int] = 80) -> None:
+        self.renderable = renderable
+        self.width = width
+
+    def __rich_console__(
+        self, console: "Console", options: "ConsoleOptions"
+    ) -> "RenderResult":
+        if self.width is None:
+            yield self.renderable
+        else:
+            child_options = options.update_width(min(self.width, options.max_width))
+            yield from console.render(self.renderable, child_options)
+
+    def __rich_measure__(
+        self, console: "Console", options: "ConsoleOptions"
+    ) -> "Measurement":
+        if self.width is not None:
+            options = options.update_width(self.width)
+        measurement = Measurement.get(console, options, self.renderable)
+        return measurement
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/rich/containers.py b/venv/lib/python3.12/site-packages/pip/_vendor/rich/containers.py
new file mode 100644
index 00000000..901ff8ba
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_vendor/rich/containers.py
@@ -0,0 +1,167 @@
+from itertools import zip_longest
+from typing import (
+    TYPE_CHECKING,
+    Iterable,
+    Iterator,
+    List,
+    Optional,
+    TypeVar,
+    Union,
+    overload,
+)
+
+if TYPE_CHECKING:
+    from .console import (
+        Console,
+        ConsoleOptions,
+        JustifyMethod,
+        OverflowMethod,
+        RenderResult,
+        RenderableType,
+    )
+    from .text import Text
+
+from .cells import cell_len
+from .measure import Measurement
+
+T = TypeVar("T")
+
+
+class Renderables:
+    """A list subclass which renders its contents to the console."""
+
+    def __init__(
+        self, renderables: Optional[Iterable["RenderableType"]] = None
+    ) -> None:
+        self._renderables: List["RenderableType"] = (
+            list(renderables) if renderables is not None else []
+        )
+
+    def __rich_console__(
+        self, console: "Console", options: "ConsoleOptions"
+    ) -> "RenderResult":
+        """Console render method to insert line-breaks."""
+        yield from self._renderables
+
+    def __rich_measure__(
+        self, console: "Console", options: "ConsoleOptions"
+    ) -> "Measurement":
+        dimensions = [
+            Measurement.get(console, options, renderable)
+            for renderable in self._renderables
+        ]
+        if not dimensions:
+            return Measurement(1, 1)
+        _min = max(dimension.minimum for dimension in dimensions)
+        _max = max(dimension.maximum for dimension in dimensions)
+        return Measurement(_min, _max)
+
+    def append(self, renderable: "RenderableType") -> None:
+        self._renderables.append(renderable)
+
+    def __iter__(self) -> Iterable["RenderableType"]:
+        return iter(self._renderables)
+
+
+class Lines:
+    """A list subclass which can render to the console."""
+
+    def __init__(self, lines: Iterable["Text"] = ()) -> None:
+        self._lines: List["Text"] = list(lines)
+
+    def __repr__(self) -> str:
+        return f"Lines({self._lines!r})"
+
+    def __iter__(self) -> Iterator["Text"]:
+        return iter(self._lines)
+
+    @overload
+    def __getitem__(self, index: int) -> "Text":
+        ...
+
+    @overload
+    def __getitem__(self, index: slice) -> List["Text"]:
+        ...
+
+    def __getitem__(self, index: Union[slice, int]) -> Union["Text", List["Text"]]:
+        return self._lines[index]
+
+    def __setitem__(self, index: int, value: "Text") -> "Lines":
+        self._lines[index] = value
+        return self
+
+    def __len__(self) -> int:
+        return self._lines.__len__()
+
+    def __rich_console__(
+        self, console: "Console", options: "ConsoleOptions"
+    ) -> "RenderResult":
+        """Console render method to insert line-breaks."""
+        yield from self._lines
+
+    def append(self, line: "Text") -> None:
+        self._lines.append(line)
+
+    def extend(self, lines: Iterable["Text"]) -> None:
+        self._lines.extend(lines)
+
+    def pop(self, index: int = -1) -> "Text":
+        return self._lines.pop(index)
+
+    def justify(
+        self,
+        console: "Console",
+        width: int,
+        justify: "JustifyMethod" = "left",
+        overflow: "OverflowMethod" = "fold",
+    ) -> None:
+        """Justify and overflow text to a given width.
+
+        Args:
+            console (Console): Console instance.
+            width (int): Number of cells available per line.
+            justify (str, optional): Default justify method for text: "left", "center", "full" or "right". Defaults to "left".
+            overflow (str, optional): Default overflow for text: "crop", "fold", or "ellipsis". Defaults to "fold".
+
+        """
+        from .text import Text
+
+        if justify == "left":
+            for line in self._lines:
+                line.truncate(width, overflow=overflow, pad=True)
+        elif justify == "center":
+            for line in self._lines:
+                line.rstrip()
+                line.truncate(width, overflow=overflow)
+                line.pad_left((width - cell_len(line.plain)) // 2)
+                line.pad_right(width - cell_len(line.plain))
+        elif justify == "right":
+            for line in self._lines:
+                line.rstrip()
+                line.truncate(width, overflow=overflow)
+                line.pad_left(width - cell_len(line.plain))
+        elif justify == "full":
+            for line_index, line in enumerate(self._lines):
+                if line_index == len(self._lines) - 1:
+                    break
+                words = line.split(" ")
+                words_size = sum(cell_len(word.plain) for word in words)
+                num_spaces = len(words) - 1
+                spaces = [1 for _ in range(num_spaces)]
+                index = 0
+                if spaces:
+                    while words_size + num_spaces < width:
+                        spaces[len(spaces) - index - 1] += 1
+                        num_spaces += 1
+                        index = (index + 1) % len(spaces)
+                tokens: List[Text] = []
+                for index, (word, next_word) in enumerate(
+                    zip_longest(words, words[1:])
+                ):
+                    tokens.append(word)
+                    if index < len(spaces):
+                        style = word.get_style_at_offset(console, -1)
+                        next_style = next_word.get_style_at_offset(console, 0)
+                        space_style = style if style == next_style else line.style
+                        tokens.append(Text(" " * spaces[index], style=space_style))
+                self[line_index] = Text("").join(tokens)
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/rich/control.py b/venv/lib/python3.12/site-packages/pip/_vendor/rich/control.py
new file mode 100644
index 00000000..88fcb929
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_vendor/rich/control.py
@@ -0,0 +1,225 @@
+import sys
+import time
+from typing import TYPE_CHECKING, Callable, Dict, Iterable, List, Union
+
+if sys.version_info >= (3, 8):
+    from typing import Final
+else:
+    from pip._vendor.typing_extensions import Final  # pragma: no cover
+
+from .segment import ControlCode, ControlType, Segment
+
+if TYPE_CHECKING:
+    from .console import Console, ConsoleOptions, RenderResult
+
+STRIP_CONTROL_CODES: Final = [
+    7,  # Bell
+    8,  # Backspace
+    11,  # Vertical tab
+    12,  # Form feed
+    13,  # Carriage return
+]
+_CONTROL_STRIP_TRANSLATE: Final = {
+    _codepoint: None for _codepoint in STRIP_CONTROL_CODES
+}
+
+CONTROL_ESCAPE: Final = {
+    7: "\\a",
+    8: "\\b",
+    11: "\\v",
+    12: "\\f",
+    13: "\\r",
+}
+
+CONTROL_CODES_FORMAT: Dict[int, Callable[..., str]] = {
+    ControlType.BELL: lambda: "\x07",
+    ControlType.CARRIAGE_RETURN: lambda: "\r",
+    ControlType.HOME: lambda: "\x1b[H",
+    ControlType.CLEAR: lambda: "\x1b[2J",
+    ControlType.ENABLE_ALT_SCREEN: lambda: "\x1b[?1049h",
+    ControlType.DISABLE_ALT_SCREEN: lambda: "\x1b[?1049l",
+    ControlType.SHOW_CURSOR: lambda: "\x1b[?25h",
+    ControlType.HIDE_CURSOR: lambda: "\x1b[?25l",
+    ControlType.CURSOR_UP: lambda param: f"\x1b[{param}A",
+    ControlType.CURSOR_DOWN: lambda param: f"\x1b[{param}B",
+    ControlType.CURSOR_FORWARD: lambda param: f"\x1b[{param}C",
+    ControlType.CURSOR_BACKWARD: lambda param: f"\x1b[{param}D",
+    ControlType.CURSOR_MOVE_TO_COLUMN: lambda param: f"\x1b[{param+1}G",
+    ControlType.ERASE_IN_LINE: lambda param: f"\x1b[{param}K",
+    ControlType.CURSOR_MOVE_TO: lambda x, y: f"\x1b[{y+1};{x+1}H",
+    ControlType.SET_WINDOW_TITLE: lambda title: f"\x1b]0;{title}\x07",
+}
+
+
+class Control:
+    """A renderable that inserts a control code (non printable but may move cursor).
+
+    Args:
+        *codes (str): Positional arguments are either a :class:`~rich.segment.ControlType` enum or a
+            tuple of ControlType and an integer parameter
+    """
+
+    __slots__ = ["segment"]
+
+    def __init__(self, *codes: Union[ControlType, ControlCode]) -> None:
+        control_codes: List[ControlCode] = [
+            (code,) if isinstance(code, ControlType) else code for code in codes
+        ]
+        _format_map = CONTROL_CODES_FORMAT
+        rendered_codes = "".join(
+            _format_map[code](*parameters) for code, *parameters in control_codes
+        )
+        self.segment = Segment(rendered_codes, None, control_codes)
+
+    @classmethod
+    def bell(cls) -> "Control":
+        """Ring the 'bell'."""
+        return cls(ControlType.BELL)
+
+    @classmethod
+    def home(cls) -> "Control":
+        """Move cursor to 'home' position."""
+        return cls(ControlType.HOME)
+
+    @classmethod
+    def move(cls, x: int = 0, y: int = 0) -> "Control":
+        """Move cursor relative to current position.
+
+        Args:
+            x (int): X offset.
+            y (int): Y offset.
+
+        Returns:
+            ~Control: Control object.
+
+        """
+
+        def get_codes() -> Iterable[ControlCode]:
+            control = ControlType
+            if x:
+                yield (
+                    control.CURSOR_FORWARD if x > 0 else control.CURSOR_BACKWARD,
+                    abs(x),
+                )
+            if y:
+                yield (
+                    control.CURSOR_DOWN if y > 0 else control.CURSOR_UP,
+                    abs(y),
+                )
+
+        control = cls(*get_codes())
+        return control
+
+    @classmethod
+    def move_to_column(cls, x: int, y: int = 0) -> "Control":
+        """Move to the given column, optionally add offset to row.
+
+        Returns:
+            x (int): absolute x (column)
+            y (int): optional y offset (row)
+
+        Returns:
+            ~Control: Control object.
+        """
+
+        return (
+            cls(
+                (ControlType.CURSOR_MOVE_TO_COLUMN, x),
+                (
+                    ControlType.CURSOR_DOWN if y > 0 else ControlType.CURSOR_UP,
+                    abs(y),
+                ),
+            )
+            if y
+            else cls((ControlType.CURSOR_MOVE_TO_COLUMN, x))
+        )
+
+    @classmethod
+    def move_to(cls, x: int, y: int) -> "Control":
+        """Move cursor to absolute position.
+
+        Args:
+            x (int): x offset (column)
+            y (int): y offset (row)
+
+        Returns:
+            ~Control: Control object.
+        """
+        return cls((ControlType.CURSOR_MOVE_TO, x, y))
+
+    @classmethod
+    def clear(cls) -> "Control":
+        """Clear the screen."""
+        return cls(ControlType.CLEAR)
+
+    @classmethod
+    def show_cursor(cls, show: bool) -> "Control":
+        """Show or hide the cursor."""
+        return cls(ControlType.SHOW_CURSOR if show else ControlType.HIDE_CURSOR)
+
+    @classmethod
+    def alt_screen(cls, enable: bool) -> "Control":
+        """Enable or disable alt screen."""
+        if enable:
+            return cls(ControlType.ENABLE_ALT_SCREEN, ControlType.HOME)
+        else:
+            return cls(ControlType.DISABLE_ALT_SCREEN)
+
+    @classmethod
+    def title(cls, title: str) -> "Control":
+        """Set the terminal window title
+
+        Args:
+            title (str): The new terminal window title
+        """
+        return cls((ControlType.SET_WINDOW_TITLE, title))
+
+    def __str__(self) -> str:
+        return self.segment.text
+
+    def __rich_console__(
+        self, console: "Console", options: "ConsoleOptions"
+    ) -> "RenderResult":
+        if self.segment.text:
+            yield self.segment
+
+
+def strip_control_codes(
+    text: str, _translate_table: Dict[int, None] = _CONTROL_STRIP_TRANSLATE
+) -> str:
+    """Remove control codes from text.
+
+    Args:
+        text (str): A string possibly contain control codes.
+
+    Returns:
+        str: String with control codes removed.
+    """
+    return text.translate(_translate_table)
+
+
+def escape_control_codes(
+    text: str,
+    _translate_table: Dict[int, str] = CONTROL_ESCAPE,
+) -> str:
+    """Replace control codes with their "escaped" equivalent in the given text.
+    (e.g. "\b" becomes "\\b")
+
+    Args:
+        text (str): A string possibly containing control codes.
+
+    Returns:
+        str: String with control codes replaced with their escaped version.
+    """
+    return text.translate(_translate_table)
+
+
+if __name__ == "__main__":  # pragma: no cover
+    from pip._vendor.rich.console import Console
+
+    console = Console()
+    console.print("Look at the title of your terminal window ^")
+    # console.print(Control((ControlType.SET_WINDOW_TITLE, "Hello, world!")))
+    for i in range(10):
+        console.set_window_title("🚀 Loading" + "." * i)
+        time.sleep(0.5)
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/rich/default_styles.py b/venv/lib/python3.12/site-packages/pip/_vendor/rich/default_styles.py
new file mode 100644
index 00000000..dca37193
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_vendor/rich/default_styles.py
@@ -0,0 +1,190 @@
+from typing import Dict
+
+from .style import Style
+
+DEFAULT_STYLES: Dict[str, Style] = {
+    "none": Style.null(),
+    "reset": Style(
+        color="default",
+        bgcolor="default",
+        dim=False,
+        bold=False,
+        italic=False,
+        underline=False,
+        blink=False,
+        blink2=False,
+        reverse=False,
+        conceal=False,
+        strike=False,
+    ),
+    "dim": Style(dim=True),
+    "bright": Style(dim=False),
+    "bold": Style(bold=True),
+    "strong": Style(bold=True),
+    "code": Style(reverse=True, bold=True),
+    "italic": Style(italic=True),
+    "emphasize": Style(italic=True),
+    "underline": Style(underline=True),
+    "blink": Style(blink=True),
+    "blink2": Style(blink2=True),
+    "reverse": Style(reverse=True),
+    "strike": Style(strike=True),
+    "black": Style(color="black"),
+    "red": Style(color="red"),
+    "green": Style(color="green"),
+    "yellow": Style(color="yellow"),
+    "magenta": Style(color="magenta"),
+    "cyan": Style(color="cyan"),
+    "white": Style(color="white"),
+    "inspect.attr": Style(color="yellow", italic=True),
+    "inspect.attr.dunder": Style(color="yellow", italic=True, dim=True),
+    "inspect.callable": Style(bold=True, color="red"),
+    "inspect.async_def": Style(italic=True, color="bright_cyan"),
+    "inspect.def": Style(italic=True, color="bright_cyan"),
+    "inspect.class": Style(italic=True, color="bright_cyan"),
+    "inspect.error": Style(bold=True, color="red"),
+    "inspect.equals": Style(),
+    "inspect.help": Style(color="cyan"),
+    "inspect.doc": Style(dim=True),
+    "inspect.value.border": Style(color="green"),
+    "live.ellipsis": Style(bold=True, color="red"),
+    "layout.tree.row": Style(dim=False, color="red"),
+    "layout.tree.column": Style(dim=False, color="blue"),
+    "logging.keyword": Style(bold=True, color="yellow"),
+    "logging.level.notset": Style(dim=True),
+    "logging.level.debug": Style(color="green"),
+    "logging.level.info": Style(color="blue"),
+    "logging.level.warning": Style(color="red"),
+    "logging.level.error": Style(color="red", bold=True),
+    "logging.level.critical": Style(color="red", bold=True, reverse=True),
+    "log.level": Style.null(),
+    "log.time": Style(color="cyan", dim=True),
+    "log.message": Style.null(),
+    "log.path": Style(dim=True),
+    "repr.ellipsis": Style(color="yellow"),
+    "repr.indent": Style(color="green", dim=True),
+    "repr.error": Style(color="red", bold=True),
+    "repr.str": Style(color="green", italic=False, bold=False),
+    "repr.brace": Style(bold=True),
+    "repr.comma": Style(bold=True),
+    "repr.ipv4": Style(bold=True, color="bright_green"),
+    "repr.ipv6": Style(bold=True, color="bright_green"),
+    "repr.eui48": Style(bold=True, color="bright_green"),
+    "repr.eui64": Style(bold=True, color="bright_green"),
+    "repr.tag_start": Style(bold=True),
+    "repr.tag_name": Style(color="bright_magenta", bold=True),
+    "repr.tag_contents": Style(color="default"),
+    "repr.tag_end": Style(bold=True),
+    "repr.attrib_name": Style(color="yellow", italic=False),
+    "repr.attrib_equal": Style(bold=True),
+    "repr.attrib_value": Style(color="magenta", italic=False),
+    "repr.number": Style(color="cyan", bold=True, italic=False),
+    "repr.number_complex": Style(color="cyan", bold=True, italic=False),  # same
+    "repr.bool_true": Style(color="bright_green", italic=True),
+    "repr.bool_false": Style(color="bright_red", italic=True),
+    "repr.none": Style(color="magenta", italic=True),
+    "repr.url": Style(underline=True, color="bright_blue", italic=False, bold=False),
+    "repr.uuid": Style(color="bright_yellow", bold=False),
+    "repr.call": Style(color="magenta", bold=True),
+    "repr.path": Style(color="magenta"),
+    "repr.filename": Style(color="bright_magenta"),
+    "rule.line": Style(color="bright_green"),
+    "rule.text": Style.null(),
+    "json.brace": Style(bold=True),
+    "json.bool_true": Style(color="bright_green", italic=True),
+    "json.bool_false": Style(color="bright_red", italic=True),
+    "json.null": Style(color="magenta", italic=True),
+    "json.number": Style(color="cyan", bold=True, italic=False),
+    "json.str": Style(color="green", italic=False, bold=False),
+    "json.key": Style(color="blue", bold=True),
+    "prompt": Style.null(),
+    "prompt.choices": Style(color="magenta", bold=True),
+    "prompt.default": Style(color="cyan", bold=True),
+    "prompt.invalid": Style(color="red"),
+    "prompt.invalid.choice": Style(color="red"),
+    "pretty": Style.null(),
+    "scope.border": Style(color="blue"),
+    "scope.key": Style(color="yellow", italic=True),
+    "scope.key.special": Style(color="yellow", italic=True, dim=True),
+    "scope.equals": Style(color="red"),
+    "table.header": Style(bold=True),
+    "table.footer": Style(bold=True),
+    "table.cell": Style.null(),
+    "table.title": Style(italic=True),
+    "table.caption": Style(italic=True, dim=True),
+    "traceback.error": Style(color="red", italic=True),
+    "traceback.border.syntax_error": Style(color="bright_red"),
+    "traceback.border": Style(color="red"),
+    "traceback.text": Style.null(),
+    "traceback.title": Style(color="red", bold=True),
+    "traceback.exc_type": Style(color="bright_red", bold=True),
+    "traceback.exc_value": Style.null(),
+    "traceback.offset": Style(color="bright_red", bold=True),
+    "bar.back": Style(color="grey23"),
+    "bar.complete": Style(color="rgb(249,38,114)"),
+    "bar.finished": Style(color="rgb(114,156,31)"),
+    "bar.pulse": Style(color="rgb(249,38,114)"),
+    "progress.description": Style.null(),
+    "progress.filesize": Style(color="green"),
+    "progress.filesize.total": Style(color="green"),
+    "progress.download": Style(color="green"),
+    "progress.elapsed": Style(color="yellow"),
+    "progress.percentage": Style(color="magenta"),
+    "progress.remaining": Style(color="cyan"),
+    "progress.data.speed": Style(color="red"),
+    "progress.spinner": Style(color="green"),
+    "status.spinner": Style(color="green"),
+    "tree": Style(),
+    "tree.line": Style(),
+    "markdown.paragraph": Style(),
+    "markdown.text": Style(),
+    "markdown.em": Style(italic=True),
+    "markdown.emph": Style(italic=True),  # For commonmark backwards compatibility
+    "markdown.strong": Style(bold=True),
+    "markdown.code": Style(bold=True, color="cyan", bgcolor="black"),
+    "markdown.code_block": Style(color="cyan", bgcolor="black"),
+    "markdown.block_quote": Style(color="magenta"),
+    "markdown.list": Style(color="cyan"),
+    "markdown.item": Style(),
+    "markdown.item.bullet": Style(color="yellow", bold=True),
+    "markdown.item.number": Style(color="yellow", bold=True),
+    "markdown.hr": Style(color="yellow"),
+    "markdown.h1.border": Style(),
+    "markdown.h1": Style(bold=True),
+    "markdown.h2": Style(bold=True, underline=True),
+    "markdown.h3": Style(bold=True),
+    "markdown.h4": Style(bold=True, dim=True),
+    "markdown.h5": Style(underline=True),
+    "markdown.h6": Style(italic=True),
+    "markdown.h7": Style(italic=True, dim=True),
+    "markdown.link": Style(color="bright_blue"),
+    "markdown.link_url": Style(color="blue", underline=True),
+    "markdown.s": Style(strike=True),
+    "iso8601.date": Style(color="blue"),
+    "iso8601.time": Style(color="magenta"),
+    "iso8601.timezone": Style(color="yellow"),
+}
+
+
+if __name__ == "__main__":  # pragma: no cover
+    import argparse
+    import io
+
+    from pip._vendor.rich.console import Console
+    from pip._vendor.rich.table import Table
+    from pip._vendor.rich.text import Text
+
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--html", action="store_true", help="Export as HTML table")
+    args = parser.parse_args()
+    html: bool = args.html
+    console = Console(record=True, width=70, file=io.StringIO()) if html else Console()
+
+    table = Table("Name", "Styling")
+
+    for style_name, style in DEFAULT_STYLES.items():
+        table.add_row(Text(style_name, style=style), str(style))
+
+    console.print(table)
+    if html:
+        print(console.export_html(inline_styles=True))
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/rich/diagnose.py b/venv/lib/python3.12/site-packages/pip/_vendor/rich/diagnose.py
new file mode 100644
index 00000000..ad361838
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_vendor/rich/diagnose.py
@@ -0,0 +1,37 @@
+import os
+import platform
+
+from pip._vendor.rich import inspect
+from pip._vendor.rich.console import Console, get_windows_console_features
+from pip._vendor.rich.panel import Panel
+from pip._vendor.rich.pretty import Pretty
+
+
+def report() -> None:  # pragma: no cover
+    """Print a report to the terminal with debugging information"""
+    console = Console()
+    inspect(console)
+    features = get_windows_console_features()
+    inspect(features)
+
+    env_names = (
+        "TERM",
+        "COLORTERM",
+        "CLICOLOR",
+        "NO_COLOR",
+        "TERM_PROGRAM",
+        "COLUMNS",
+        "LINES",
+        "JUPYTER_COLUMNS",
+        "JUPYTER_LINES",
+        "JPY_PARENT_PID",
+        "VSCODE_VERBOSE_LOGGING",
+    )
+    env = {name: os.getenv(name) for name in env_names}
+    console.print(Panel.fit((Pretty(env)), title="[b]Environment Variables"))
+
+    console.print(f'platform="{platform.system()}"')
+
+
+if __name__ == "__main__":  # pragma: no cover
+    report()
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/rich/emoji.py b/venv/lib/python3.12/site-packages/pip/_vendor/rich/emoji.py
new file mode 100644
index 00000000..791f0465
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_vendor/rich/emoji.py
@@ -0,0 +1,96 @@
+import sys
+from typing import TYPE_CHECKING, Optional, Union
+
+from .jupyter import JupyterMixin
+from .segment import Segment
+from .style import Style
+from ._emoji_codes import EMOJI
+from ._emoji_replace import _emoji_replace
+
+if sys.version_info >= (3, 8):
+    from typing import Literal
+else:
+    from pip._vendor.typing_extensions import Literal  # pragma: no cover
+
+
+if TYPE_CHECKING:
+    from .console import Console, ConsoleOptions, RenderResult
+
+
+EmojiVariant = Literal["emoji", "text"]
+
+
+class NoEmoji(Exception):
+    """No emoji by that name."""
+
+
+class Emoji(JupyterMixin):
+    __slots__ = ["name", "style", "_char", "variant"]
+
+    VARIANTS = {"text": "\uFE0E", "emoji": "\uFE0F"}
+
+    def __init__(
+        self,
+        name: str,
+        style: Union[str, Style] = "none",
+        variant: Optional[EmojiVariant] = None,
+    ) -> None:
+        """A single emoji character.
+
+        Args:
+            name (str): Name of emoji.
+            style (Union[str, Style], optional): Optional style. Defaults to None.
+
+        Raises:
+            NoEmoji: If the emoji doesn't exist.
+        """
+        self.name = name
+        self.style = style
+        self.variant = variant
+        try:
+            self._char = EMOJI[name]
+        except KeyError:
+            raise NoEmoji(f"No emoji called {name!r}")
+        if variant is not None:
+            self._char += self.VARIANTS.get(variant, "")
+
+    @classmethod
+    def replace(cls, text: str) -> str:
+        """Replace emoji markup with corresponding unicode characters.
+
+        Args:
+            text (str): A string with emojis codes, e.g. "Hello :smiley:!"
+
+        Returns:
+            str: A string with emoji codes replaces with actual emoji.
+        """
+        return _emoji_replace(text)
+
+    def __repr__(self) -> str:
+        return f""
+
+    def __str__(self) -> str:
+        return self._char
+
+    def __rich_console__(
+        self, console: "Console", options: "ConsoleOptions"
+    ) -> "RenderResult":
+        yield Segment(self._char, console.get_style(self.style))
+
+
+if __name__ == "__main__":  # pragma: no cover
+    import sys
+
+    from pip._vendor.rich.columns import Columns
+    from pip._vendor.rich.console import Console
+
+    console = Console(record=True)
+
+    columns = Columns(
+        (f":{name}: {name}" for name in sorted(EMOJI.keys()) if "\u200D" not in name),
+        column_first=True,
+    )
+
+    console.print(columns)
+    if len(sys.argv) > 1:
+        console.save_html(sys.argv[1])
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/rich/errors.py b/venv/lib/python3.12/site-packages/pip/_vendor/rich/errors.py
new file mode 100644
index 00000000..0bcbe53e
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_vendor/rich/errors.py
@@ -0,0 +1,34 @@
+class ConsoleError(Exception):
+    """An error in console operation."""
+
+
+class StyleError(Exception):
+    """An error in styles."""
+
+
+class StyleSyntaxError(ConsoleError):
+    """Style was badly formatted."""
+
+
+class MissingStyle(StyleError):
+    """No such style."""
+
+
+class StyleStackError(ConsoleError):
+    """Style stack is invalid."""
+
+
+class NotRenderableError(ConsoleError):
+    """Object is not renderable."""
+
+
+class MarkupError(ConsoleError):
+    """Markup was badly formatted."""
+
+
+class LiveError(ConsoleError):
+    """Error related to Live display."""
+
+
+class NoAltScreen(ConsoleError):
+    """Alt screen mode was required."""
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/rich/file_proxy.py b/venv/lib/python3.12/site-packages/pip/_vendor/rich/file_proxy.py
new file mode 100644
index 00000000..4b0b0da6
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_vendor/rich/file_proxy.py
@@ -0,0 +1,57 @@
+import io
+from typing import IO, TYPE_CHECKING, Any, List
+
+from .ansi import AnsiDecoder
+from .text import Text
+
+if TYPE_CHECKING:
+    from .console import Console
+
+
+class FileProxy(io.TextIOBase):
+    """Wraps a file (e.g. sys.stdout) and redirects writes to a console."""
+
+    def __init__(self, console: "Console", file: IO[str]) -> None:
+        self.__console = console
+        self.__file = file
+        self.__buffer: List[str] = []
+        self.__ansi_decoder = AnsiDecoder()
+
+    @property
+    def rich_proxied_file(self) -> IO[str]:
+        """Get proxied file."""
+        return self.__file
+
+    def __getattr__(self, name: str) -> Any:
+        return getattr(self.__file, name)
+
+    def write(self, text: str) -> int:
+        if not isinstance(text, str):
+            raise TypeError(f"write() argument must be str, not {type(text).__name__}")
+        buffer = self.__buffer
+        lines: List[str] = []
+        while text:
+            line, new_line, text = text.partition("\n")
+            if new_line:
+                lines.append("".join(buffer) + line)
+                buffer.clear()
+            else:
+                buffer.append(line)
+                break
+        if lines:
+            console = self.__console
+            with console:
+                output = Text("\n").join(
+                    self.__ansi_decoder.decode_line(line) for line in lines
+                )
+                console.print(output)
+        return len(text)
+
+    def flush(self) -> None:
+        output = "".join(self.__buffer)
+        if output:
+            self.__console.print(output)
+        del self.__buffer[:]
+
+    def fileno(self) -> int:
+        return self.__file.fileno()
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/rich/filesize.py b/venv/lib/python3.12/site-packages/pip/_vendor/rich/filesize.py
new file mode 100644
index 00000000..99f118e2
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_vendor/rich/filesize.py
@@ -0,0 +1,89 @@
+# coding: utf-8
+"""Functions for reporting filesizes. Borrowed from https://github.com/PyFilesystem/pyfilesystem2
+
+The functions declared in this module should cover the different
+use cases needed to generate a string representation of a file size
+using several different units. Since there are many standards regarding
+file size units, three different functions have been implemented.
+
+See Also:
+    * `Wikipedia: Binary prefix `_
+
+"""
+
+__all__ = ["decimal"]
+
+from typing import Iterable, List, Optional, Tuple
+
+
+def _to_str(
+    size: int,
+    suffixes: Iterable[str],
+    base: int,
+    *,
+    precision: Optional[int] = 1,
+    separator: Optional[str] = " ",
+) -> str:
+    if size == 1:
+        return "1 byte"
+    elif size < base:
+        return "{:,} bytes".format(size)
+
+    for i, suffix in enumerate(suffixes, 2):  # noqa: B007
+        unit = base**i
+        if size < unit:
+            break
+    return "{:,.{precision}f}{separator}{}".format(
+        (base * size / unit),
+        suffix,
+        precision=precision,
+        separator=separator,
+    )
+
+
+def pick_unit_and_suffix(size: int, suffixes: List[str], base: int) -> Tuple[int, str]:
+    """Pick a suffix and base for the given size."""
+    for i, suffix in enumerate(suffixes):
+        unit = base**i
+        if size < unit * base:
+            break
+    return unit, suffix
+
+
+def decimal(
+    size: int,
+    *,
+    precision: Optional[int] = 1,
+    separator: Optional[str] = " ",
+) -> str:
+    """Convert a filesize in to a string (powers of 1000, SI prefixes).
+
+    In this convention, ``1000 B = 1 kB``.
+
+    This is typically the format used to advertise the storage
+    capacity of USB flash drives and the like (*256 MB* meaning
+    actually a storage capacity of more than *256 000 000 B*),
+    or used by **Mac OS X** since v10.6 to report file sizes.
+
+    Arguments:
+        int (size): A file size.
+        int (precision): The number of decimal places to include (default = 1).
+        str (separator): The string to separate the value from the units (default = " ").
+
+    Returns:
+        `str`: A string containing a abbreviated file size and units.
+
+    Example:
+        >>> filesize.decimal(30000)
+        '30.0 kB'
+        >>> filesize.decimal(30000, precision=2, separator="")
+        '30.00kB'
+
+    """
+    return _to_str(
+        size,
+        ("kB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"),
+        1000,
+        precision=precision,
+        separator=separator,
+    )
diff --git a/venv/lib/python3.12/site-packages/pip/_vendor/rich/highlighter.py b/venv/lib/python3.12/site-packages/pip/_vendor/rich/highlighter.py
new file mode 100644
index 00000000..27714b25
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pip/_vendor/rich/highlighter.py
@@ -0,0 +1,232 @@
+import re
+from abc import ABC, abstractmethod
+from typing import List, Union
+
+from .text import Span, Text
+
+
+def _combine_regex(*regexes: str) -> str:
+    """Combine a number of regexes in to a single regex.
+
+    Returns:
+        str: New regex with all regexes ORed together.
+    """
+    return "|".join(regexes)
+
+
+class Highlighter(ABC):
+    """Abstract base class for highlighters."""
+
+    def __call__(self, text: Union[str, Text]) -> Text:
+        """Highlight a str or Text instance.
+
+        Args:
+            text (Union[str, ~Text]): Text to highlight.
+
+        Raises:
+            TypeError: If not called with text or str.
+
+        Returns:
+            Text: A test instance with highlighting applied.
+        """
+        if isinstance(text, str):
+            highlight_text = Text(text)
+        elif isinstance(text, Text):
+            highlight_text = text.copy()
+        else:
+            raise TypeError(f"str or Text instance required, not {text!r}")
+        self.highlight(highlight_text)
+        return highlight_text
+
+    @abstractmethod
+    def highlight(self, text: Text) -> None:
+        """Apply highlighting in place to text.
+
+        Args:
+            text (~Text): A text object highlight.
+        """
+
+
+class NullHighlighter(Highlighter):
+    """A highlighter object that doesn't highlight.
+
+    May be used to disable highlighting entirely.
+
+    """
+
+    def highlight(self, text: Text) -> None:
+        """Nothing to do"""
+
+
+class RegexHighlighter(Highlighter):
+    """Applies highlighting from a list of regular expressions."""
+
+    highlights: List[str] = []
+    base_style: str = ""
+
+    def highlight(self, text: Text) -> None:
+        """Highlight :class:`rich.text.Text` using regular expressions.
+
+        Args:
+            text (~Text): Text to highlighted.
+
+        """
+
+        highlight_regex = text.highlight_regex
+        for re_highlight in self.highlights:
+            highlight_regex(re_highlight, style_prefix=self.base_style)
+
+
+class ReprHighlighter(RegexHighlighter):
+    """Highlights the text typically produced from ``__repr__`` methods."""
+
+    base_style = "repr."
+    highlights = [
+        r"(?P<)(?P[-\w.:|]*)(?P[\w\W]*)(?P>)",
+        r'(?P[\w_]{1,50})=(?P"?[\w_]+"?)?',
+        r"(?P[][{}()])",
+        _combine_regex(
+            r"(?P[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3})",
+            r"(?P([A-Fa-f0-9]{1,4}::?){1,7}[A-Fa-f0-9]{1,4})",
+            r"(?P(?:[0-9A-Fa-f]{1,2}-){7}[0-9A-Fa-f]{1,2}|(?:[0-9A-Fa-f]{1,2}:){7}[0-9A-Fa-f]{1,2}|(?:[0-9A-Fa-f]{4}\.){3}[0-9A-Fa-f]{4})",
+            r"(?P(?:[0-9A-Fa-f]{1,2}-){5}[0-9A-Fa-f]{1,2}|(?:[0-9A-Fa-f]{1,2}:){5}[0-9A-Fa-f]{1,2}|(?:[0-9A-Fa-f]{4}\.){2}[0-9A-Fa-f]{4})",
+            r"(?P[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12})",
+            r"(?P[\w.]*?)\(",
+            r"\b(?PTrue)\b|\b(?PFalse)\b|\b(?PNone)\b",
+            r"(?P\.\.\.)",
+            r"(?P(?(?\B(/[-\w._+]+)*\/)(?P[-\w._+]*)?",
+            r"(?b?'''.*?(?(file|https|http|ws|wss)://[-0-9a-zA-Z$_+!`(),.?/;:&=%#~]*)",
+        ),
+    ]
+
+
+class JSONHighlighter(RegexHighlighter):
+    """Highlights JSON"""
+
+    # Captures the start and end of JSON strings, handling escaped quotes
+    JSON_STR = r"(?b?\".*?(?[\{\[\(\)\]\}])",
+            r"\b(?Ptrue)\b|\b(?Pfalse)\b|\b(?Pnull)\b",
+            r"(?P(? None:
+        super().highlight(text)
+
+        # Additional work to handle highlighting JSON keys
+        plain = text.plain
+        append = text.spans.append
+        whitespace = self.JSON_WHITESPACE
+        for match in re.finditer(self.JSON_STR, plain):
+            start, end = match.span()
+            cursor = end
+            while cursor < len(plain):
+                char = plain[cursor]
+                cursor += 1
+                if char == ":":
+                    append(Span(start, end, "json.key"))
+                elif char in whitespace:
+                    continue
+                break
+
+
+class ISO8601Highlighter(RegexHighlighter):
+    """Highlights the ISO8601 date time strings.
+    Regex reference: https://www.oreilly.com/library/view/regular-expressions-cookbook/9781449327453/ch04s07.html
+    """
+
+    base_style = "iso8601."
+    highlights = [
+        #
+        # Dates
+        #
+        # Calendar month (e.g. 2008-08). The hyphen is required
+        r"^(?P[0-9]{4})-(?P1[0-2]|0[1-9])$",
+        # Calendar date w/o hyphens (e.g. 20080830)
+        r"^(?P(?P[0-9]{4})(?P1[0-2]|0[1-9])(?P3[01]|0[1-9]|[12][0-9]))$",
+        # Ordinal date (e.g. 2008-243). The hyphen is optional
+        r"^(?P(?P[0-9]{4})-?(?P36[0-6]|3[0-5][0-9]|[12][0-9]{2}|0[1-9][0-9]|00[1-9]))$",
+        #
+        # Weeks
+        #
+        # Week of the year (e.g., 2008-W35). The hyphen is optional
+        r"^(?P(?P[0-9]{4})-?W(?P5[0-3]|[1-4][0-9]|0[1-9]))$",
+        # Week date (e.g., 2008-W35-6). The hyphens are optional
+        r"^(?P(?P[0-9]{4})-?W(?P5[0-3]|[1-4][0-9]|0[1-9])-?(?P[1-7]))$",
+        #
+        # Times
+        #
+        # Hours and minutes (e.g., 17:21). The colon is optional
+        r"^(?P
'                    : '\U0001d4ab',
+        '\\'                    : '\U0001d4ac',
+        '\\'                    : '\U0000211b',
+        '\\'                    : '\U0001d4ae',
+        '\\'                    : '\U0001d4af',
+        '\\'                    : '\U0001d4b0',
+        '\\'                    : '\U0001d4b1',
+        '\\'                    : '\U0001d4b2',
+        '\\'                    : '\U0001d4b3',
+        '\\'                    : '\U0001d4b4',
+        '\\'                    : '\U0001d4b5',
+        '\\'                    : '\U0001d5ba',
+        '\\'                    : '\U0001d5bb',
+        '\\'                    : '\U0001d5bc',
+        '\\'                    : '\U0001d5bd',
+        '\\'                    : '\U0001d5be',
+        '\\'                    : '\U0001d5bf',
+        '\\'                    : '\U0001d5c0',
+        '\\'                    : '\U0001d5c1',
+        '\\'                    : '\U0001d5c2',
+        '\\'                    : '\U0001d5c3',
+        '\\'                    : '\U0001d5c4',
+        '\\'                    : '\U0001d5c5',
+        '\\'                    : '\U0001d5c6',
+        '\\'                    : '\U0001d5c7',
+        '\\'                    : '\U0001d5c8',
+        '\\